diff --git a/.clang-tidy b/.clang-tidy
index 5b36ac93d48d..02b565b23585 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,20 +1,26 @@
 Checks: >
   *,
   -abseil-*,
+  -altera-struct-pack-align,
+  -altera-unroll-loops,
   -android-*,
-  -cert-err58-cpp,
+  -boost-use-ranges,
+  -bugprone-easily-swappable-parameters,
   -cert-err58-cpp,
   -clang-analyzer-osx-*,
   -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-avoid-const-or-ref-data-members,
+  -cppcoreguidelines-avoid-do-while,
   -cppcoreguidelines-avoid-goto,
   -cppcoreguidelines-avoid-magic-numbers,
   -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
   -cppcoreguidelines-owning-memory,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
   -cppcoreguidelines-pro-bounds-pointer-arithmetic,
   -cppcoreguidelines-pro-type-reinterpret-cast,
   -cppcoreguidelines-pro-type-vararg,
-  -cppcoreguidelines-pro-type-vararg,
   -cppcoreguidelines-special-member-functions,
   -fuchsia-*,
   -google-*,
@@ -25,25 +31,31 @@ Checks: >
   -hicpp-special-member-functions,
   -hicpp-use-equals-default,
   -hicpp-vararg,
-  -hicpp-vararg,
   -llvm-header-guard,
   -llvm-include-order,
+  -llvm-qualified-auto,
   -llvmlibc-*,
   -misc-no-recursion,
-  -misc-no-recursion,
   -misc-non-private-member-variables-in-classes,
   -misc-unused-parameters,
   -modernize-avoid-c-arrays,
   -modernize-deprecated-headers,
+  -modernize-use-designated-initializers,
   -modernize-use-nodiscard,
   -modernize-use-trailing-return-type,
   -mpi-*,
   -objc-*,
   -openmp-*,
+  -performance-avoid-endl,
+  -performance-enum-size,
   -readability-avoid-const-params-in-decls,
   -readability-convert-member-functions-to-static,
+  -readability-function-cognitive-complexity,
+  -readability-identifier-length,
   -readability-implicit-bool-conversion,
   -readability-magic-numbers,
+  -readability-math-missing-parentheses,
+  -readability-qualified-auto,
   -zircon-*,
 
 HeaderFilterRegex: '.*'
diff --git a/.cmake-format.yaml b/.cmake-format.yaml
deleted file mode 100644
index bbbd89f433a5..000000000000
--- a/.cmake-format.yaml
+++ /dev/null
@@ -1,83 +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.
-
-# 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/.dockerignore b/.dockerignore
new file mode 100644
index 000000000000..6506b8ae624c
--- /dev/null
+++ b/.dockerignore
@@ -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.
+<<<<<<<< HEAD:.yamlfmt.yml
+match_type: doublestar
+exclude:
+  - '**/.clang-format'
+  - '**/.clang-tidy'
+formatter:
+  type: basic
+  retain_line_breaks_single: true
+  scan_folded_as_literal: true
+  indent: 2
+========
+
+.git*
+docs/
+static/
+website/
+
+_build/
+
+# Python binary dirs
+.venv/
+dist/
+wheelhouse/
+>>>>>>>> 59b492a9bce45f487f24b5cbae7dc845ea3d0827:.dockerignore
diff --git a/.gersemirc b/.gersemirc
new file mode 100644
index 000000000000..6d6ca521020c
--- /dev/null
+++ b/.gersemirc
@@ -0,0 +1,13 @@
+# vim: set filetype=yaml :
+
+line_length: 100
+indent: 2
+definitions:
+  - CMake/third-party/FBCMakeParseArgs.cmake
+  - CMake/third-party/FBThriftCppLibrary.cmake
+  - CMake/FindThrift.cmake
+  - velox/experimental/breeze/cmake
+  - velox/experimental/breeze/test
+  - velox/experimental/breeze/perftest
+extensions:
+  - scripts/ci/gersemi_cmd_definitions.py
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 03e20d010ca9..79cac5c9a768 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -24,14 +24,18 @@
 
 # Build & CI
 CMake/ @assignUser @majetideepak
-*.cmake @assignUser @majetideepak
-**/CMakeLists.txt @assignUser @majetideepak
+/CMakeLists.txt @assignUser
+*.cmake @majetideepak
+**/CMakeLists.txt @majetideepak
 scripts/ @assignUser @majetideepak
 .github/ @assignUser @majetideepak
 
 # Breeze
 velox/experimental/breeze @dreveman
 
+# cuDF
+velox/experimental/cudf/ @bdice @karthikeyann @devavret @mhaseeb123
+
 # Parquet
 velox/dwio/parquet/ @majetideepak
 
@@ -43,3 +47,6 @@ velox/connectors/ @majetideepak
 
 # Caching
 velox/common/caching/ @majetideepak
+
+# Spark Functions
+velox/functions/sparksql/ @jinchengchenghh @rui-mo @zhli1142015
diff --git a/.github/workflows/linux-build-base.yml b/.github/workflows/linux-build-base.yml
index 044c9757fedd..de2a187dcbea 100644
--- a/.github/workflows/linux-build-base.yml
+++ b/.github/workflows/linux-build-base.yml
@@ -84,7 +84,7 @@ jobs:
             export CC=/usr/bin/clang-15
             export CXX=/usr/bin/clang++-15
           fi
-          make release
+          make release TREAT_WARNINGS_AS_ERRORS=0
 
       - name: Show CCache stats after build
         run: ccache -vs
diff --git a/.github/zizmor.yml b/.github/zizmor.yml
index 82e325d5047c..0919ec9a9d26 100644
--- a/.github/zizmor.yml
+++ b/.github/zizmor.yml
@@ -15,9 +15,6 @@ rules:
   use-trusted-publishing:
     ignore:
       - build_pyvelox.yml
-
   unpinned-images:
     ignore:
-      # linux-build-base.yml builds and publishes a container image which we then use immediately;
-      # so we need to use the images dynamically generated (i.e., unpinned) tag.
       - linux-build-base.yml
diff --git a/.gitignore b/.gitignore
index 3ebb2942c5c4..9ce01803eaf9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -293,8 +293,7 @@ distribute/*
 *.bin
 cmake_build
 .cmake_build
-cmake-build-debug
-cmake-build-release
+cmake-build-*
 
 # tests
 test/test.sql
@@ -325,5 +324,6 @@ src/amalgamation/
 velox/docs/sphinx/source/README_generated_*
 velox/docs/bindings/python/_generate/*
 scripts/bm-report/report.html
+scripts/bm-report/result
 dist/
 wheelhouse/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index c902b08ed1ff..2a6563fdc5df 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -35,22 +35,16 @@ repos:
 
   - repo: local
     hooks:
-      - id: cmake-format
-        name: cmake-format
-        description: Format CMake files.
-        entry: cmake-format
-        language: python
-        files: (CMakeLists.*|.*\.cmake|.*\.cmake.in)$
-        args: [--in-place]
-        require_serial: false
-        additional_dependencies: [cmake-format==0.6.13, pyyaml]
-
       - id: clang-tidy
         name: clang-tidy
-        description: Run clang-tidy on C/C++ files
+        description: >-
+          Run clang-tidy on C/C++ files, requires 'compile_commands.json'
+          to be available in the repo root (e.g. symlinked) or BUILD_PATH
+          set to it's path e.g. _build/release.
         stages:
-          - manual # Needs compile_commands.json
-        entry: clang-tidy
+          - pre-commit
+        entry: ./scripts/checks/run-clang-tidy.py
+        args: [--commit, HEAD]
         language: python
         types_or: [c++, c]
         additional_dependencies: [clang-tidy==18.1.8]
@@ -76,8 +70,14 @@ repos:
           NOTICE.txt
           )$
 
+  - repo: https://github.com/BlankSpruce/gersemi
+    rev: 0.21.0
+    hooks:
+      - id: gersemi
+        name: CMake formatter
+
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v18.1.3
+    rev: v21.1.2
     hooks:
       - id: clang-format
         # types_or: [c++, c, cuda, metal, objective-c]
@@ -91,6 +91,19 @@ repos:
         args: [--fix]
       - id: ruff-format
 
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.10.0.1
+    hooks:
+      - id: shellcheck
+        args: [-x, --severity=warning]
+
+  - repo: https://github.com/scop/pre-commit-shfmt
+    rev: v3.11.0-1
+    hooks:
+      - id: shfmt
+        # w: write changes, s: simplify, i set indent to 2 spaces
+        args: [-w, -s, -i, '2']
+
   # The following checks mostly target GitHub Actions workflows.
   - repo: https://github.com/adrienverge/yamllint.git
     rev: v1.37.0
diff --git a/CMake/FindArrow.cmake b/CMake/FindArrow.cmake
index 4e09b3971dcd..99bd6412f6fb 100644
--- a/CMake/FindArrow.cmake
+++ b/CMake/FindArrow.cmake
@@ -25,7 +25,8 @@ find_package_handle_standard_args(
   ARROW_LIB
   ARROW_TESTING_LIB
   ARROW_INCLUDE_PATH
-  Thrift_FOUND)
+  Thrift_FOUND
+)
 
 # Only add the libraries once.
 if(Arrow_FOUND AND NOT TARGET arrow)
@@ -34,10 +35,13 @@ if(Arrow_FOUND AND NOT TARGET arrow)
   add_library(thrift ALIAS thrift::thrift)
 
   set_target_properties(
-    arrow arrow_testing PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                   ${ARROW_INCLUDE_PATH})
-  set_target_properties(arrow PROPERTIES IMPORTED_LOCATION ${ARROW_LIB}
-                                         INTERFACE_LINK_LIBRARIES thrift)
-  set_target_properties(arrow_testing PROPERTIES IMPORTED_LOCATION
-                                                 ${ARROW_TESTING_LIB})
+    arrow
+    arrow_testing
+    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${ARROW_INCLUDE_PATH}
+  )
+  set_target_properties(
+    arrow
+    PROPERTIES IMPORTED_LOCATION ${ARROW_LIB} INTERFACE_LINK_LIBRARIES thrift
+  )
+  set_target_properties(arrow_testing PROPERTIES IMPORTED_LOCATION ${ARROW_TESTING_LIB})
 endif()
diff --git a/CMake/FindSnappy.cmake b/CMake/FindSnappy.cmake
deleted file mode 100644
index e2a0359f8f7c..000000000000
--- a/CMake/FindSnappy.cmake
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# - Try to find snappy
-# Once done, this will define
-#
-# SNAPPY_FOUND - system has Glog
-# SNAPPY_INCLUDE_DIRS - deprecated
-# SNAPPY_LIBRARIES -  deprecated
-# Snappy::snappy will be defined based on CMAKE_FIND_LIBRARY_SUFFIXES priority
-
-include(FindPackageHandleStandardArgs)
-include(SelectLibraryConfigurations)
-
-find_library(SNAPPY_LIBRARY_RELEASE snappy PATHS $SNAPPY_LIBRARYDIR})
-find_library(SNAPPY_LIBRARY_DEBUG snappyd PATHS ${SNAPPY_LIBRARYDIR})
-
-find_path(SNAPPY_INCLUDE_DIR snappy.h PATHS ${SNAPPY_INCLUDEDIR})
-
-select_library_configurations(SNAPPY)
-
-find_package_handle_standard_args(Snappy DEFAULT_MSG SNAPPY_LIBRARY
-                                  SNAPPY_INCLUDE_DIR)
-
-mark_as_advanced(SNAPPY_LIBRARY SNAPPY_INCLUDE_DIR)
-
-get_filename_component(libsnappy_ext ${SNAPPY_LIBRARY} EXT)
-if(libsnappy_ext STREQUAL ".a")
-  set(libsnappy_type STATIC)
-else()
-  set(libsnappy_type SHARED)
-endif()
-
-if(NOT TARGET Snappy::snappy)
-  add_library(Snappy::snappy ${libsnappy_type} IMPORTED)
-  set_target_properties(Snappy::snappy PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                                  "${SNAPPY_INCLUDE_DIR}")
-  set_target_properties(
-    Snappy::snappy PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-                              IMPORTED_LOCATION "${SNAPPY_LIBRARIES}")
-endif()
diff --git a/CMake/FindSodium.cmake b/CMake/FindSodium.cmake
index 68ea1f96550c..2cd1c4e3de2e 100644
--- a/CMake/FindSodium.cmake
+++ b/CMake/FindSodium.cmake
@@ -40,9 +40,12 @@ if(NOT (sodium_USE_STATIC_LIBS EQUAL sodium_USE_STATIC_LIBS_LAST))
   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")
+  set(
+    sodium_USE_STATIC_LIBS_LAST
+    ${sodium_USE_STATIC_LIBS}
+    CACHE INTERNAL
+    "internal change tracking variable"
+  )
 endif()
 
 # ##############################################################################
@@ -57,7 +60,7 @@ if(UNIX)
   if(sodium_USE_STATIC_LIBS)
     foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
       if(NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending
-                                             # with .a
+        # with .a
         list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
       endif()
     endforeach()
@@ -79,32 +82,26 @@ if(UNIX)
   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_DEBUG NAMES ${${XPREFIX}_LIBRARIES} HINTS ${${XPREFIX}_LIBRARY_DIRS})
   find_library(
     sodium_LIBRARY_RELEASE
     NAMES ${${XPREFIX}_LIBRARIES}
-    HINTS ${${XPREFIX}_LIBRARY_DIRS})
+    HINTS ${${XPREFIX}_LIBRARY_DIRS}
+  )
 
   # ############################################################################
   # Windows
 elseif(WIN32)
-  set(sodium_DIR
-      "$ENV{sodium_DIR}"
-      CACHE FILEPATH "sodium install directory")
+  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)
+  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"
+      WRITE
+      "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp"
       [=[
             #if defined _M_IX86
             #error ARCH_VALUE x86_32
@@ -112,13 +109,15 @@ elseif(WIN32)
             #error ARCH_VALUE x86_64
             #endif
             #error ARCH_VALUE unknown
-        ]=])
+        ]=]
+    )
     try_compile(
-      _UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}"
+      _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}")
+      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")
@@ -126,10 +125,7 @@ elseif(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."
-      )
+      message(FATAL_ERROR "the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake.")
     endif()
     string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
 
@@ -147,64 +143,53 @@ elseif(WIN32)
     endif()
 
     string(REPLACE "$$CONFIG$$" "Debug" _DEBUG_PATH_SUFFIX "${_PLATFORM_PATH}")
-    string(REPLACE "$$CONFIG$$" "Release" _RELEASE_PATH_SUFFIX
-                   "${_PLATFORM_PATH}")
+    string(REPLACE "$$CONFIG$$" "Release" _RELEASE_PATH_SUFFIX "${_PLATFORM_PATH}")
 
     find_library(
-      sodium_LIBRARY_DEBUG libsodium.lib
+      sodium_LIBRARY_DEBUG
+      libsodium.lib
       HINTS ${sodium_DIR}
-      PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
+      PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
+    )
     find_library(
-      sodium_LIBRARY_RELEASE libsodium.lib
+      sodium_LIBRARY_RELEASE
+      libsodium.lib
       HINTS ${sodium_DIR}
-      PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
+      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
+        sodium_DLL_DEBUG
+        libsodium
         HINTS ${sodium_DIR}
-        PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX})
+        PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
+      )
       find_library(
-        sodium_DLL_RELEASE libsodium
+        sodium_DLL_RELEASE
+        libsodium
         HINTS ${sodium_DIR}
-        PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX})
+        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)
+      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)
+      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)
+        "${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")
@@ -225,12 +210,13 @@ if(sodium_INCLUDE_DIR)
   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)
+      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()
 
@@ -239,11 +225,11 @@ 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)
+  VERSION_VAR sodium_VERSION
+)
 
 if(Sodium_FOUND)
-  set(sodium_LIBRARIES optimized ${sodium_LIBRARY_RELEASE} debug
-                       ${sodium_LIBRARY_DEBUG})
+  set(sodium_LIBRARIES optimized ${sodium_LIBRARY_RELEASE} debug ${sodium_LIBRARY_DEBUG})
 endif()
 
 # mark file paths as advanced
@@ -268,8 +254,10 @@ endif()
 
 set_target_properties(
   sodium
-  PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${sodium_INCLUDE_DIR}"
-             IMPORTED_LINK_INTERFACE_LANGUAGES "C")
+  PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "${sodium_INCLUDE_DIR}"
+    IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+)
 
 if(sodium_USE_STATIC_LIBS)
   set_target_properties(
@@ -277,19 +265,25 @@ if(sodium_USE_STATIC_LIBS)
     PROPERTIES
       INTERFACE_COMPILE_DEFINITIONS "SODIUM_STATIC"
       IMPORTED_LOCATION "${sodium_LIBRARY_RELEASE}"
-      IMPORTED_LOCATION_DEBUG "${sodium_LIBRARY_DEBUG}")
+      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}")
+      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}")
+      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}")
+      set_target_properties(sodium PROPERTIES IMPORTED_LOCATION_DEBUG "${sodium_DLL_DEBUG}")
     endif()
     if(NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
       set_target_properties(
@@ -297,7 +291,8 @@ else()
         PROPERTIES
           IMPORTED_LOCATION_RELWITHDEBINFO "${sodium_DLL_RELEASE}"
           IMPORTED_LOCATION_MINSIZEREL "${sodium_DLL_RELEASE}"
-          IMPORTED_LOCATION_RELEASE "${sodium_DLL_RELEASE}")
+          IMPORTED_LOCATION_RELEASE "${sodium_DLL_RELEASE}"
+      )
     endif()
   endif()
 endif()
diff --git a/CMake/FindThrift.cmake b/CMake/FindThrift.cmake
index 273500a6ae36..48c1a84b1d1a 100644
--- a/CMake/FindThrift.cmake
+++ b/CMake/FindThrift.cmake
@@ -30,16 +30,16 @@
 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
+      "#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)
+    set(Thrift_VERSION "${Thrift_VERSION}" PARENT_SCOPE)
   else()
-    set(Thrift_VERSION
-        ""
-        PARENT_SCOPE)
+    set(Thrift_VERSION "" PARENT_SCOPE)
   endif()
 endfunction(EXTRACT_THRIFT_VERSION)
 
@@ -77,8 +77,9 @@ if(ARROW_THRIFT_USE_SHARED)
     "${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}"
+  set(
+    THRIFT_LIB_NAMES
+    "${CMAKE_STATIC_LIBRARY_PREFIX}${THRIFT_LIB_NAME_BASE}${CMAKE_STATIC_LIBRARY_SUFFIX}"
   )
 endif()
 
@@ -87,16 +88,11 @@ if(Thrift_ROOT)
     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()
+    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
@@ -112,21 +108,25 @@ else()
       THRIFT_LIB
       NAMES ${THRIFT_LIB_NAMES}
       PATHS ${THRIFT_PC_LIBRARY_DIRS}
-      NO_DEFAULT_PATH)
+      NO_DEFAULT_PATH
+    )
     find_program(
-      THRIFT_COMPILER thrift
+      THRIFT_COMPILER
+      thrift
       HINTS ${THRIFT_PC_PREFIX}
       NO_DEFAULT_PATH
-      PATH_SUFFIXES "bin")
+      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")
+      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()
+    EXTRACT_THRIFT_VERSION()
   endif()
 endif()
 
@@ -140,7 +140,8 @@ find_package_handle_standard_args(
   Thrift
   REQUIRED_VARS THRIFT_LIB THRIFT_INCLUDE_DIR
   VERSION_VAR Thrift_VERSION
-  HANDLE_COMPONENTS)
+  HANDLE_COMPONENTS
+)
 
 if(Thrift_FOUND)
   if(ARROW_THRIFT_USE_SHARED)
@@ -150,18 +151,18 @@ if(Thrift_FOUND)
   endif()
   set_target_properties(
     thrift::thrift
-    PROPERTIES IMPORTED_LOCATION "${THRIFT_LIB}" INTERFACE_INCLUDE_DIRECTORIES
-                                                 "${THRIFT_INCLUDE_DIR}")
+    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")
+    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}")
+    set_target_properties(thrift::compiler PROPERTIES IMPORTED_LOCATION "${THRIFT_COMPILER}")
   endif()
 endif()
diff --git a/CMake/FindXxhash.cmake b/CMake/FindXxhash.cmake
index 04419b7c238f..31b828243274 100644
--- a/CMake/FindXxhash.cmake
+++ b/CMake/FindXxhash.cmake
@@ -25,8 +25,7 @@ include(SelectLibraryConfigurations)
 select_library_configurations(Xxhash)
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Xxhash DEFAULT_MSG Xxhash_LIBRARY
-                                  Xxhash_INCLUDE_DIR)
+find_package_handle_standard_args(Xxhash DEFAULT_MSG Xxhash_LIBRARY Xxhash_INCLUDE_DIR)
 
 if(Xxhash_FOUND)
   message(STATUS "Found xxhash: ${Xxhash_LIBRARY}")
diff --git a/CMake/Findc-ares.cmake b/CMake/Findc-ares.cmake
index 0e3f1fe0938a..58087c018fa9 100644
--- a/CMake/Findc-ares.cmake
+++ b/CMake/Findc-ares.cmake
@@ -19,22 +19,20 @@ if(c-ares_FOUND)
   endif()
 endif()
 
-find_path(
-  C_ARES_INCLUDE_DIR
-  NAMES ares.h
-  PATH_SUFFIXES c-ares)
+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)
+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}")
+    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
index 457bd88e26c1..ec1059067dfe 100644
--- a/CMake/Finddouble-conversion.cmake
+++ b/CMake/Finddouble-conversion.cmake
@@ -12,23 +12,25 @@ if(double-conversion_FOUND)
   endif()
 endif()
 
-find_path(
-  DOUBLE_CONVERSION_INCLUDE_DIR
-  NAMES double-conversion.h
-  PATH_SUFFIXES double-conversion)
+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)
+  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}")
+    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/Findglog.cmake b/CMake/Findglog.cmake
index 81deadb36442..067669eece03 100644
--- a/CMake/Findglog.cmake
+++ b/CMake/Findglog.cmake
@@ -29,8 +29,7 @@ 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)
+find_package_handle_standard_args(glog DEFAULT_MSG GLOG_LIBRARY GLOG_INCLUDE_DIR)
 
 mark_as_advanced(GLOG_LIBRARY GLOG_INCLUDE_DIR)
 
@@ -39,9 +38,9 @@ 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 INTERFACE_INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIRS}")
   set_target_properties(
-    glog::glog PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-                          IMPORTED_LOCATION "${GLOG_LIBRARIES}")
+    glog::glog
+    PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" IMPORTED_LOCATION "${GLOG_LIBRARIES}"
+  )
 endif()
diff --git a/CMake/Findlz4.cmake b/CMake/Findlz4.cmake
index d13c951b8898..2840d0174795 100644
--- a/CMake/Findlz4.cmake
+++ b/CMake/Findlz4.cmake
@@ -43,9 +43,9 @@ endif()
 
 if(NOT TARGET lz4::lz4)
   add_library(lz4::lz4 ${liblz4_type} IMPORTED)
-  set_target_properties(lz4::lz4 PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                            "${LZ4_INCLUDE_DIR}")
+  set_target_properties(lz4::lz4 PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${LZ4_INCLUDE_DIR}")
   set_target_properties(
-    lz4::lz4 PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-                        IMPORTED_LOCATION "${LZ4_LIBRARIES}")
+    lz4::lz4
+    PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" IMPORTED_LOCATION "${LZ4_LIBRARIES}"
+  )
 endif()
diff --git a/CMake/Findlzo2.cmake b/CMake/Findlzo2.cmake
index 9f9fbbbe11ca..f052fd8fc0dc 100644
--- a/CMake/Findlzo2.cmake
+++ b/CMake/Findlzo2.cmake
@@ -30,8 +30,7 @@ find_path(LZO2_INCLUDE_DIR lzo/lzo1a.h PATHS ${LZO2_INCLUDEDIR})
 
 select_library_configurations(LZO2)
 
-find_package_handle_standard_args(lzo2 DEFAULT_MSG LZO2_LIBRARY
-                                  LZO2_INCLUDE_DIR)
+find_package_handle_standard_args(lzo2 DEFAULT_MSG LZO2_LIBRARY LZO2_INCLUDE_DIR)
 
 mark_as_advanced(LZO2_LIBRARY LZO2_INCLUDE_DIR)
 
@@ -44,9 +43,9 @@ endif()
 
 if(NOT TARGET lzo2::lzo2)
   add_library(lzo2::lzo2 ${liblzo2_type} IMPORTED)
-  set_target_properties(lzo2::lzo2 PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                              "${LZO2_INCLUDE_DIR}")
+  set_target_properties(lzo2::lzo2 PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${LZO2_INCLUDE_DIR}")
   set_target_properties(
-    lzo2::lzo2 PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-                          IMPORTED_LOCATION "${LZO2_LIBRARIES}")
+    lzo2::lzo2
+    PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" IMPORTED_LOCATION "${LZO2_LIBRARIES}"
+  )
 endif()
diff --git a/CMake/Findpyarrow.cmake b/CMake/Findpyarrow.cmake
index 593ef06fc170..f7df31083301 100644
--- a/CMake/Findpyarrow.cmake
+++ b/CMake/Findpyarrow.cmake
@@ -16,32 +16,30 @@ find_package(Python REQUIRED COMPONENTS Interpreter)
 
 execute_process(
   COMMAND
-    "${Python_EXECUTABLE}" -c "\
+    "${Python_EXECUTABLE}" -c
+    "\
 import pyarrow
 print(pyarrow.get_include())
 "
   OUTPUT_VARIABLE _pyarrow_include_dir
-  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+)
 
 execute_process(
   COMMAND
-    "${Python_EXECUTABLE}" -c "\
+    "${Python_EXECUTABLE}" -c
+    "\
 import pyarrow
 pyarrow.create_library_symlinks()
 print(pyarrow.get_library_dirs()[0])
 "
   OUTPUT_VARIABLE _pyarrow_lib_dir
-  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+)
 
-find_library(
-  _libarrow arrow
-  PATHS ${_pyarrow_lib_dir}
-  NO_DEFAULT_PATH)
+find_library(_libarrow arrow PATHS ${_pyarrow_lib_dir} NO_DEFAULT_PATH)
 
-find_library(
-  _libarrow_py arrow_python
-  PATHS ${_pyarrow_lib_dir}
-  NO_DEFAULT_PATH)
+find_library(_libarrow_py arrow_python PATHS ${_pyarrow_lib_dir} NO_DEFAULT_PATH)
 
 set(pyarrow_LIBARROW ${_libarrow})
 set(pyarrow_LIBARROW_PYTHON ${_libarrow_py})
@@ -51,8 +49,9 @@ mark_as_advanced(_libarrow _libarrow_py _pyarrow_include_dir _pyarrow_lib_dir)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(
-  pyarrow REQUIRED_VARS pyarrow_LIBARROW pyarrow_LIBARROW_PYTHON
-                        pyarrow_INCLUDE_DIR)
+  pyarrow
+  REQUIRED_VARS pyarrow_LIBARROW pyarrow_LIBARROW_PYTHON pyarrow_INCLUDE_DIR
+)
 
 if(pyarrow_FOUND)
   if(NOT TARGET pyarrow::dev)
@@ -63,7 +62,7 @@ if(pyarrow_FOUND)
         IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
         IMPORTED_LOCATION "${pyarrow_LIBARROW_PYTHON}"
         INTERFACE_INCLUDE_DIRECTORIES "${pyarrow_INCLUDE_DIR}"
-        INTERFACE_LINK_LIBRARIES "${pyarrow_LIBARROW}")
-
+        INTERFACE_LINK_LIBRARIES "${pyarrow_LIBARROW}"
+    )
   endif()
 endif()
diff --git a/CMake/Findre2.cmake b/CMake/Findre2.cmake
index 1a438cce0e0a..ff8b484972c8 100644
--- a/CMake/Findre2.cmake
+++ b/CMake/Findre2.cmake
@@ -35,8 +35,7 @@ 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}")
+    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.
@@ -47,12 +46,10 @@ if(RE2_FOUND)
         list(REMOVE_ITEM RE2_CFLAGS_OTHER "${flag}")
       endif()
     endforeach()
-    set_property(TARGET re2::re2 PROPERTY INTERFACE_COMPILE_OPTIONS
-                                          "${RE2_CFLAGS_OTHER}")
+    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}")
+    set_property(TARGET re2::re2 PROPERTY INTERFACE_LINK_LIBRARIES "${RE2_LDFLAGS}")
   endif()
   message(STATUS "Found RE2 via pkg-config.")
   return()
diff --git a/CMake/Findstemmer.cmake b/CMake/Findstemmer.cmake
index 8796ce461ac5..7b22996d8943 100644
--- a/CMake/Findstemmer.cmake
+++ b/CMake/Findstemmer.cmake
@@ -25,6 +25,8 @@ if(NOT TARGET stemmer::stemmer)
   find_path(STEMMER_INCLUDE_PATH libstemmer.h)
   set_target_properties(
     stemmer::stemmer
-    PROPERTIES IMPORTED_LOCATION ${STEMMER_LIB} INTERFACE_INCLUDE_DIRECTORIES
-                                                ${STEMMER_INCLUDE_PATH})
+    PROPERTIES
+      IMPORTED_LOCATION ${STEMMER_LIB}
+      INTERFACE_INCLUDE_DIRECTORIES ${STEMMER_INCLUDE_PATH}
+  )
 endif()
diff --git a/CMake/Findzstd.cmake b/CMake/Findzstd.cmake
index 3285c5744d5b..26f7917e98bb 100644
--- a/CMake/Findzstd.cmake
+++ b/CMake/Findzstd.cmake
@@ -30,8 +30,7 @@ find_path(ZSTD_INCLUDE_DIR zstd.h PATHS ${ZSTD_INCLUDEDIR})
 
 select_library_configurations(ZSTD)
 
-find_package_handle_standard_args(zstd DEFAULT_MSG ZSTD_LIBRARY
-                                  ZSTD_INCLUDE_DIR)
+find_package_handle_standard_args(zstd DEFAULT_MSG ZSTD_LIBRARY ZSTD_INCLUDE_DIR)
 
 mark_as_advanced(ZSTD_LIBRARY ZSTD_INCLUDE_DIR)
 
@@ -44,11 +43,11 @@ endif()
 
 if(NOT TARGET zstd::zstd)
   add_library(zstd::zstd ${libzstd_type} IMPORTED)
-  set_target_properties(zstd::zstd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                              "${ZSTD_INCLUDE_DIR}")
+  set_target_properties(zstd::zstd PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${ZSTD_INCLUDE_DIR}")
   set_target_properties(
-    zstd::zstd PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C"
-                          IMPORTED_LOCATION "${ZSTD_LIBRARIES}")
+    zstd::zstd
+    PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" IMPORTED_LOCATION "${ZSTD_LIBRARIES}"
+  )
 endif()
 
 if(NOT TARGET zstd::libzstd_shared)
diff --git a/CMake/ResolveDependency.cmake b/CMake/ResolveDependency.cmake
index 0290c154d316..3c3517a18cf3 100644
--- a/CMake/ResolveDependency.cmake
+++ b/CMake/ResolveDependency.cmake
@@ -32,8 +32,7 @@ include(FetchContent)
 include(ExternalProject)
 include(ProcessorCount)
 include(CheckCXXCompilerFlag)
-list(APPEND CMAKE_MODULE_PATH
-     ${CMAKE_CURRENT_LIST_DIR}/resolve_dependency_modules)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/resolve_dependency_modules)
 
 # Enable SSL certificate verification for file downloads
 set(CMAKE_TLS_VERIFY true)
@@ -83,9 +82,7 @@ macro(velox_resolve_dependency dependency_name)
   elseif(${dependency_name}_SOURCE STREQUAL "BUNDLED")
     velox_build_dependency(${dependency_name})
   else()
-    message(
-      FATAL_ERROR
-        "Invalid source for ${dependency_name}: ${${dependency_name}_SOURCE}")
+    message(FATAL_ERROR "Invalid source for ${dependency_name}: ${${dependency_name}_SOURCE}")
   endif()
 
   list(POP_BACK CMAKE_MESSAGE_INDENT)
@@ -93,10 +90,12 @@ endmacro()
 
 # By using a macro we don't need to propagate the value into the parent scope.
 macro(velox_set_source dependency_name)
-  velox_set_with_default(${dependency_name}_SOURCE ${dependency_name}_SOURCE
-                         ${VELOX_DEPENDENCY_SOURCE})
-  message(
-    STATUS "Setting ${dependency_name} source to ${${dependency_name}_SOURCE}")
+  velox_set_with_default(
+    ${dependency_name}_SOURCE
+    ${dependency_name}_SOURCE
+    ${VELOX_DEPENDENCY_SOURCE}
+  )
+  message(STATUS "Setting ${dependency_name} source to ${${dependency_name}_SOURCE}")
 endmacro()
 
 # Set var_name to the value of $ENV{envvar_name} if ENV is defined. If neither
@@ -105,13 +104,9 @@ endmacro()
 # automatically! Use PARENT_SCOPE.
 function(velox_set_with_default var_name envvar_name default)
   if(DEFINED ENV{${envvar_name}})
-    set(${var_name}
-        $ENV{${envvar_name}}
-        PARENT_SCOPE)
+    set(${var_name} $ENV{${envvar_name}} PARENT_SCOPE)
   elseif(NOT DEFINED ${var_name})
-    set(${var_name}
-        ${default}
-        PARENT_SCOPE)
+    set(${var_name} ${default} PARENT_SCOPE)
   endif()
 endfunction()
 
@@ -121,13 +116,21 @@ macro(velox_resolve_dependency_url dependency_name)
   string(PREPEND VELOX_${dependency_name}_BUILD_SHA256_CHECKSUM "SHA256=")
 
   velox_set_with_default(
-    VELOX_${dependency_name}_SOURCE_URL VELOX_${dependency_name}_URL
-    ${VELOX_${dependency_name}_SOURCE_URL})
-  message(VERBOSE "Set VELOX_${dependency_name}_SOURCE_URL to "
-          "${VELOX_${dependency_name}_SOURCE_URL}")
+    VELOX_${dependency_name}_SOURCE_URL
+    VELOX_${dependency_name}_URL
+    ${VELOX_${dependency_name}_SOURCE_URL}
+  )
+  message(
+    VERBOSE
+    "Set VELOX_${dependency_name}_SOURCE_URL to "
+    "${VELOX_${dependency_name}_SOURCE_URL}"
+  )
   if(DEFINED ENV{VELOX_${dependency_name}_URL})
-    velox_set_with_default(VELOX_${dependency_name}_BUILD_SHA256_CHECKSUM
-                           VELOX_${dependency_name}_SHA256 "")
+    velox_set_with_default(
+      VELOX_${dependency_name}_BUILD_SHA256_CHECKSUM
+      VELOX_${dependency_name}_SHA256
+      ""
+    )
     if(DEFINED ENV{VELOX_${dependency_name}_SHA256})
       string(PREPEND VELOX_${dependency_name}_BUILD_SHA256_CHECKSUM "SHA256=")
     endif()
diff --git a/CMake/VeloxConfig.cmake.in b/CMake/VeloxConfig.cmake.in
new file mode 100644
index 000000000000..158f47277b4a
--- /dev/null
+++ b/CMake/VeloxConfig.cmake.in
@@ -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.
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+block()
+  list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
+
+  if("@Arrow_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(Arrow)
+  endif()
+  if("@Boost_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(Boost COMPONENTS "@BOOST_INCLUDE_LIBRARIES@")
+  endif()
+  find_dependency(double-conversion)
+  if("@folly_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(folly)
+  endif()
+  if("@fmt_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(fmt)
+  endif()
+  if("@gflags_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(gflags)
+  endif()
+  if("@glog_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(glog)
+  endif()
+  if("@VELOX_ENABLE_COMPRESSION_LZ4@")
+    find_dependency(lz4)
+  endif()
+  if("@Protobuf_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(Protobuf)
+  endif()
+  if("@re2_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(re2)
+  endif()
+  if("@stemmer_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(stemmer)
+  endif()
+  if("@VELOX_BUILD_MINIMAL_WITH_DWIO@" OR "@VELOX_ENABLE_HIVE_CONNECTOR@")
+    find_dependency(Snappy)
+    find_dependency(ZLIB)
+    find_dependency(zstd)
+  endif()
+  if("@simdjson_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(simdjson)
+  endif()
+  if("@Thrift_FOUND@")
+    find_dependency(Thrift)
+  endif()
+  if("@xsimd_SOURCE@" STREQUAL "SYSTEM")
+    find_dependency(xsimd)
+  endif()
+endblock()
+
+include("${CMAKE_CURRENT_LIST_DIR}/VeloxTargets.cmake")
+
+check_required_components(Velox)
diff --git a/CMake/VeloxUtils.cmake b/CMake/VeloxUtils.cmake
index 5db4624555a8..8a63332fd335 100644
--- a/CMake/VeloxUtils.cmake
+++ b/CMake/VeloxUtils.cmake
@@ -12,34 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 include_guard(GLOBAL)
-function(get_rpath_origin VAR)
+
+include(CMakePackageConfigHelpers)
+
+function(velox_get_rpath_origin VAR)
   if(APPLE)
     set(_origin @loader_path)
   else()
     set(_origin "\$ORIGIN")
   endif()
-  set(${VAR}
-      ${_origin}
-      PARENT_SCOPE)
+  set(${VAR} ${_origin} PARENT_SCOPE)
 endfunction()
 
 function(pyvelox_add_module TARGET)
   pybind11_add_module(${TARGET} ${ARGN})
 
   if(DEFINED SKBUILD_PROJECT_VERSION_FULL)
-    target_compile_definitions(
-      ${TARGET} PRIVATE PYVELOX_VERSION=${SKBUILD_PROJECT_VERSION_FULL})
+    target_compile_definitions(${TARGET} PRIVATE PYVELOX_VERSION=${SKBUILD_PROJECT_VERSION_FULL})
   else()
     target_compile_definitions(${TARGET} PRIVATE PYVELOX_VERSION=dev)
   endif()
 
   # Set the rpath so linker looks within pyvelox package for libs
-  get_rpath_origin(_origin)
+  velox_get_rpath_origin(_origin)
   set_target_properties(
-    ${TARGET} PROPERTIES INSTALL_RPATH "${_origin}/;${CMAKE_BINARY_DIR}/lib"
-                         INSTALL_RPATH_USE_LINK_PATH TRUE)
-  install(TARGETS ${TARGET} LIBRARY DESTINATION pyvelox
-                                    COMPONENT pyvelox_libraries)
+    ${TARGET}
+    PROPERTIES INSTALL_RPATH "${_origin}/;${CMAKE_BINARY_DIR}/lib" INSTALL_RPATH_USE_LINK_PATH TRUE
+  )
+  install(TARGETS ${TARGET} LIBRARY DESTINATION pyvelox COMPONENT pyvelox_libraries)
 endfunction()
 
 # TODO use file sets
@@ -50,10 +50,9 @@ function(velox_install_library_headers)
     cmake_path(
       RELATIVE_PATH
       CMAKE_CURRENT_SOURCE_DIR
-      BASE_DIRECTORY
-      "${CMAKE_SOURCE_DIR}"
-      OUTPUT_VARIABLE
-      _hdr_dir)
+      BASE_DIRECTORY "${CMAKE_SOURCE_DIR}"
+      OUTPUT_VARIABLE _hdr_dir
+    )
     install(FILES ${_hdrs} DESTINATION include/${_hdr_dir})
   endif()
 endfunction()
@@ -70,12 +69,7 @@ function(velox_add_library TARGET)
   set(options OBJECT STATIC SHARED INTERFACE)
   set(oneValueArgs)
   set(multiValueArgs)
-  cmake_parse_arguments(
-    VELOX
-    "${options}"
-    "${oneValueArgs}"
-    "${multiValueArgs}"
-    ${ARGN})
+  cmake_parse_arguments(VELOX "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
   # Remove library type specifiers from ARGN
   set(library_type)
@@ -98,8 +92,9 @@ function(velox_add_library TARGET)
     if(TARGET velox)
       # Target already exists, append sources to it.
       target_sources(velox PRIVATE ${ARGN})
-      install(TARGETS velox LIBRARY DESTINATION pyvelox
-                                    COMPONENT pyvelox_libraries)
+      if(VELOX_BUILD_PYTHON_PACKAGE)
+        install(TARGETS velox LIBRARY DESTINATION pyvelox COMPONENT pyvelox_libraries)
+      endif()
     else()
       set(_type STATIC)
       if(VELOX_BUILD_SHARED)
@@ -107,11 +102,56 @@ function(velox_add_library TARGET)
       endif()
       # Create the target if this is the first invocation.
       add_library(velox ${_type} ${ARGN})
-      set_target_properties(velox PROPERTIES LIBRARY_OUTPUT_DIRECTORY
-                                             ${PROJECT_BINARY_DIR}/lib)
-      set_target_properties(velox PROPERTIES ARCHIVE_OUTPUT_DIRECTORY
-                                             ${PROJECT_BINARY_DIR}/lib)
-      install(TARGETS velox DESTINATION lib/velox)
+      set_target_properties(velox PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
+      set_target_properties(velox PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
+      install(TARGETS velox DESTINATION lib/velox EXPORT velox_targets)
+      if(VELOX_BUILD_CMAKE_PACKAGE)
+        set(package_cmake_dir "lib/cmake/Velox")
+        set(config_cmake_in "${PROJECT_SOURCE_DIR}/CMake/VeloxConfig.cmake.in")
+        set(config_cmake "${PROJECT_BINARY_DIR}/CMake/VeloxConfig.cmake")
+        configure_package_config_file(
+          "${config_cmake_in}"
+          "${config_cmake}"
+          INSTALL_DESTINATION "${package_cmake_dir}"
+        )
+        install(FILES "${config_cmake}" DESTINATION "${package_cmake_dir}")
+        set(system_dependencies)
+        if(Arrow_SOURCE STREQUAL "SYSTEM")
+          list(APPEND system_dependencies Arrow)
+        endif()
+        if(glog_SOURCE STREQUAL "SYSTEM")
+          list(APPEND system_dependencies glog)
+        endif()
+        if(VELOX_ENABLE_COMPRESSION_LZ4)
+          list(APPEND system_dependencies lz4)
+        endif()
+        if(re2_SOURCE STREQUAL "SYSTEM")
+          list(APPEND system_dependencies re2)
+        endif()
+        if(stemmer_SOURCE STREQUAL "SYSTEM")
+          list(APPEND system_dependencies stemmer)
+        endif()
+        if(VELOX_BUILD_MINIMAL_WITH_DWIO OR VELOX_ENABLE_HIVE_CONNECTOR)
+          list(APPEND system_dependencies Snappy zstd)
+        endif()
+        foreach(system_dependency ${system_dependencies})
+          set(velox_find_module "${PROJECT_SOURCE_DIR}/CMake/Find${system_dependency}.cmake")
+          if(EXISTS "${velox_find_module}")
+            install(FILES "${velox_find_module}" DESTINATION "${package_cmake_dir}")
+          endif()
+        endforeach()
+        # TODO: We can enable this once we add version to Velox.
+        # set(version_cmake "${PROJECT_BINARY_DIR}/CMake/VeloxConfigVersion.cmake")
+        # write_basic_package_version_file("${version_cmake}"
+        #                                  COMPATIBILITY SameMajorVersion)
+        # install(FILES "${version_cmake}" DESTINATION "${package_cmake_dir}")
+        install(
+          EXPORT velox_targets
+          DESTINATION "${package_cmake_dir}"
+          NAMESPACE "Velox::"
+          FILE "VeloxTargets.cmake"
+        )
+      endif()
     endif()
     # create alias for compatability
     if(NOT TARGET ${TARGET})
@@ -131,15 +171,17 @@ function(velox_link_libraries TARGET)
     # These targets follow the velox_* name for consistency but are NOT actually
     # aliases to velox when building the mono lib and need to be linked
     # explicitly (this is a hack)
-    set(explicit_targets
-        velox_exec_test_lib
-        # see velox/experimental/wave/README.md
-        velox_wave_common
-        velox_wave_decode
-        velox_wave_dwio
-        velox_wave_exec
-        velox_wave_stream
-        velox_wave_vector)
+    set(
+      explicit_targets
+      velox_exec_test_lib
+      # see velox/experimental/wave/README.md
+      velox_wave_common
+      velox_wave_decode
+      velox_wave_dwio
+      velox_wave_exec
+      velox_wave_stream
+      velox_wave_vector
+    )
 
     foreach(_arg ${ARGN})
       list(FIND explicit_targets ${_arg} _explicit)
diff --git a/CMake/resolve_dependency_modules/README.md b/CMake/resolve_dependency_modules/README.md
index 268617cbabe7..a1314eec783c 100644
--- a/CMake/resolve_dependency_modules/README.md
+++ b/CMake/resolve_dependency_modules/README.md
@@ -6,45 +6,44 @@ 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      |
-| folly             | v2025.04.28.00  | Yes      |
-| fizz              | v2025.04.28.00  | No       |
-| wangle            | v2025.04.28.00  | No       |
-| mvfst             | v2025.04.28.00  | No       |
-| fbthrift          | v2025.04.28.00  | No       |
-| libstemmer        | 2.2.0           | Yes      |
-| DuckDB (testing)  | 0.8.1           | Yes      |
-| cpr (testing)     | 1.10.15         | Yes      |
-| arrow             | 15.0.0          | Yes      |
-| geos              | 3.10.2          | Yes      |
-| fast_float        | v8.0.2          | Yes      |
-| xxhash            | default         | No       |
-| thrift            | 0.16            | No       |
+| Library Name      | Minimum Version | Bundled? | Comment |
+|-------------------|-----------------|----------|---------|
+| 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       ||
+| 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               | 2024-07-02      | Yes      ||
+| fmt               | 11.2.0          | Yes      | Used API must be fmt 9 compatible |
+| simdjson          | 4.1.0           | Yes      ||
+| faiss             | 1.11.0          | Yes      ||
+| folly             | v2025.04.28.00  | Yes      ||
+| fizz              | v2025.04.28.00  | No       ||
+| wangle            | v2025.04.28.00  | No       ||
+| mvfst             | v2025.04.28.00  | No       ||
+| fbthrift          | v2025.04.28.00  | No       ||
+| libstemmer        | 2.2.0           | Yes      ||
+| DuckDB (testing)  | 0.8.1           | Yes      ||
+| arrow             | 15.0.0          | Yes      ||
+| geos              | 3.10.7          | Yes      ||
+| fast_float        | v8.0.2          | Yes      ||
+| xxhash            | default         | No       ||
+| thrift            | 0.16            | No       ||
 
 # Bundled Dependency Management
 This module provides a dependency management system that allows us to automatically fetch and build dependencies from source if needed.
diff --git a/CMake/resolve_dependency_modules/absl.cmake b/CMake/resolve_dependency_modules/absl.cmake
index c382e128eabf..505e39df6349 100644
--- a/CMake/resolve_dependency_modules/absl.cmake
+++ b/CMake/resolve_dependency_modules/absl.cmake
@@ -14,12 +14,16 @@
 include_guard(GLOBAL)
 
 set(VELOX_ABSL_BUILD_VERSION 20240116.2)
-set(VELOX_ABSL_BUILD_SHA256_CHECKSUM
-    733726b8c3a6d39a4120d7e45ea8b41a434cdacde401cba500f14236c49b39dc)
+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")
+  CONCAT
+  VELOX_ABSL_SOURCE_URL
+  "https://github.com/abseil/abseil-cpp/archive/refs/tags/"
+  "${VELOX_ABSL_BUILD_VERSION}.tar.gz"
+)
 
 velox_resolve_dependency_url(ABSL)
 
@@ -29,8 +33,11 @@ FetchContent_Declare(
   absl
   URL ${VELOX_ABSL_SOURCE_URL}
   URL_HASH ${VELOX_ABSL_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM
-  PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/absl/absl-macos.patch)
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+  SYSTEM
+  PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/absl/absl-macos.patch
+)
 
 set(ABSL_BUILD_TESTING OFF)
 set(ABSL_PROPAGATE_CXX_STD ON)
diff --git a/CMake/resolve_dependency_modules/antlr4-runtime.cmake b/CMake/resolve_dependency_modules/antlr4-runtime.cmake
index 86bc799ce715..cf8d77325462 100644
--- a/CMake/resolve_dependency_modules/antlr4-runtime.cmake
+++ b/CMake/resolve_dependency_modules/antlr4-runtime.cmake
@@ -14,10 +14,13 @@
 include_guard(GLOBAL)
 
 set(VELOX_ANTLR4_RUNTIME_VERSION 4.13.2)
-set(VELOX_ANTLR4_RUNTIME_BUILD_SHA256_CHECKSUM
-    9f18272a9b32b622835a3365f850dd1063d60f5045fb1e12ce475ae6e18a35bb)
-set(VELOX_ANTLR4_RUNTIME_SOURCE_URL
-    "https://github.com/antlr/antlr4/archive/refs/tags/${VELOX_ANTLR4_RUNTIME_VERSION}.tar.gz"
+set(
+  VELOX_ANTLR4_RUNTIME_BUILD_SHA256_CHECKSUM
+  9f18272a9b32b622835a3365f850dd1063d60f5045fb1e12ce475ae6e18a35bb
+)
+set(
+  VELOX_ANTLR4_RUNTIME_SOURCE_URL
+  "https://github.com/antlr/antlr4/archive/refs/tags/${VELOX_ANTLR4_RUNTIME_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(ANTLR4_RUNTIME)
@@ -28,9 +31,10 @@ FetchContent_Declare(
   antlr4-runtime
   URL ${VELOX_ANTLR4_RUNTIME_SOURCE_URL}
   URL_HASH ${VELOX_ANTLR4_RUNTIME_BUILD_SHA256_CHECKSUM}
-  SOURCE_SUBDIR runtime/Cpp OVERRIDE_FIND_PACKAGE)
+  SOURCE_SUBDIR
+  runtime/Cpp
+  OVERRIDE_FIND_PACKAGE
+)
 
-set(ANTLR4_INSTALL
-    ON
-    CACHE BOOL "" FORCE)
+set(ANTLR4_INSTALL ON CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(antlr4-runtime)
diff --git a/CMake/resolve_dependency_modules/arrow/CMakeLists.txt b/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
index 5144d646e788..401644d11f85 100644
--- a/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
+++ b/CMake/resolve_dependency_modules/arrow/CMakeLists.txt
@@ -21,28 +21,31 @@ if(VELOX_ENABLE_ARROW)
   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}
-      -DCMAKE_POLICY_VERSION_MINIMUM=3.5
-      # Remove with Arrow upgrade to Arrow 20.
-      -DARROW_CXXFLAGS=-Wno-documentation)
-  set(ARROW_LIBDIR ${ARROW_PREFIX}/install/${CMAKE_INSTALL_LIBDIR})
+  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_LIBDIR=lib
+    -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}
+    -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+    # Remove with Arrow upgrade to Arrow 20.
+    -DARROW_CXXFLAGS=-Wno-documentation
+  )
+  set(ARROW_LIBDIR ${ARROW_PREFIX}/install/lib)
 
   add_library(thrift STATIC IMPORTED GLOBAL)
   if(NOT Thrift_FOUND)
@@ -53,15 +56,17 @@ if(VELOX_ENABLE_ARROW)
     set(THRIFT_INCLUDE_DIR ${THRIFT_ROOT}/include)
   endif()
 
-  set_property(TARGET thrift PROPERTY INTERFACE_INCLUDE_DIRECTORIES
-                                      ${THRIFT_INCLUDE_DIR})
+  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
-      ab74c60c46938505c8cd7599b1d2826c68450645d5860d0ff40f67e371a5d0b5)
-  set(VELOX_ARROW_SOURCE_URL
-      "https://github.com/apache/arrow/archive/refs/tags/apache-arrow-${VELOX_ARROW_BUILD_VERSION}.tar.gz"
+  set(
+    VELOX_ARROW_BUILD_SHA256_CHECKSUM
+    ab74c60c46938505c8cd7599b1d2826c68450645d5860d0ff40f67e371a5d0b5
+  )
+  set(
+    VELOX_ARROW_SOURCE_URL
+    "https://github.com/apache/arrow/archive/refs/tags/apache-arrow-${VELOX_ARROW_BUILD_VERSION}.tar.gz"
   )
 
   velox_resolve_dependency_url(ARROW)
@@ -73,9 +78,11 @@ if(VELOX_ENABLE_ARROW)
     URL_HASH ${VELOX_ARROW_BUILD_SHA256_CHECKSUM}
     SOURCE_SUBDIR cpp
     CMAKE_ARGS ${ARROW_CMAKE_ARGS}
-    BUILD_BYPRODUCTS ${ARROW_LIBDIR}/libarrow.a
-                     ${ARROW_LIBDIR}/libarrow_testing.a ${THRIFT_LIB}
-    PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/thrift-download.patch)
+    BUILD_BYPRODUCTS ${ARROW_LIBDIR}/libarrow.a ${ARROW_LIBDIR}/libarrow_testing.a ${THRIFT_LIB}
+    PATCH_COMMAND
+      git apply ${CMAKE_CURRENT_LIST_DIR}/thrift-download.patch && git apply
+      ${CMAKE_CURRENT_LIST_DIR}/cmake-compatibility.patch
+  )
 
   add_library(arrow STATIC IMPORTED GLOBAL)
   add_library(arrow_testing STATIC IMPORTED GLOBAL)
@@ -83,13 +90,14 @@ if(VELOX_ENABLE_ARROW)
   add_dependencies(arrow_testing arrow)
   file(MAKE_DIRECTORY ${ARROW_PREFIX}/install/include)
   set_target_properties(
-    arrow arrow_testing PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                   ${ARROW_PREFIX}/install/include)
-  set_target_properties(arrow PROPERTIES IMPORTED_LOCATION
-                                         ${ARROW_LIBDIR}/libarrow.a)
+    arrow
+    arrow_testing
+    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)
-
+    arrow_testing
+    PROPERTIES IMPORTED_LOCATION ${ARROW_LIBDIR}/libarrow_testing.a
+  )
 endif()
diff --git a/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch b/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch
new file mode 100644
index 000000000000..249ea6090483
--- /dev/null
+++ b/CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch
@@ -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.
+
+--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
++++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
+@@ -971,7 +971,8 @@
+     -DCMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY=${CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY}
+     -DCMAKE_INSTALL_LIBDIR=lib
+     -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
+-    -DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE_MAKEFILE})
++    -DCMAKE_VERBOSE_MAKEFILE=${CMAKE_VERBOSE_MAKEFILE}
++    -DCMAKE_POLICY_VERSION_MINIMUM=3.5)
+
+ # Enable s/ccache if set by parent.
+ if(CMAKE_C_COMPILER_LAUNCHER AND CMAKE_CXX_COMPILER_LAUNCHER)
+@@ -1026,6 +1027,7 @@
+   set(CMAKE_COMPILE_WARNING_AS_ERROR FALSE)
+   set(CMAKE_EXPORT_NO_PACKAGE_REGISTRY TRUE)
+   set(CMAKE_MACOSX_RPATH ${ARROW_INSTALL_NAME_RPATH})
++  set(CMAKE_POLICY_VERSION_MINIMUM 3.5)
+   if(MSVC)
+     string(REPLACE "/WX" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
+     string(REPLACE "/WX" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
diff --git a/CMake/resolve_dependency_modules/boost.cmake b/CMake/resolve_dependency_modules/boost.cmake
index 842cba6f1334..dfbc61698477 100644
--- a/CMake/resolve_dependency_modules/boost.cmake
+++ b/CMake/resolve_dependency_modules/boost.cmake
@@ -15,13 +15,6 @@ include_guard(GLOBAL)
 
 add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/boost)
 
-if(ICU_SOURCE)
-  if(${ICU_SOURCE} STREQUAL "BUNDLED")
-    # ensure ICU is built before Boost
-    add_dependencies(boost_regex ICU ICU::i18n)
-  endif()
-endif()
-
 # This prevents system boost from leaking in
 set(Boost_NO_SYSTEM_PATHS ON)
 # We have to keep the FindBoost.cmake in an subfolder to prevent it from
diff --git a/CMake/resolve_dependency_modules/boost/CMakeLists.txt b/CMake/resolve_dependency_modules/boost/CMakeLists.txt
index 69018a0f3a68..c653eba61f3f 100644
--- a/CMake/resolve_dependency_modules/boost/CMakeLists.txt
+++ b/CMake/resolve_dependency_modules/boost/CMakeLists.txt
@@ -23,12 +23,16 @@ add_compile_options(-w)
 # officale releases for some reason)
 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
-    4d27e9efed0f6f152dc28db6430b9d3dfb40c0345da7342eaa5a987dde57bd95)
+  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
+  4d27e9efed0f6f152dc28db6430b9d3dfb40c0345da7342eaa5a987dde57bd95
+)
 
 velox_resolve_dependency_url(BOOST)
 message(STATUS "Building boost from source")
@@ -42,22 +46,28 @@ endif()
 FetchContent_Declare(
   Boost
   URL ${VELOX_BOOST_SOURCE_URL}
-  URL_HASH ${VELOX_BOOST_BUILD_SHA256_CHECKSUM})
+  URL_HASH ${VELOX_BOOST_BUILD_SHA256_CHECKSUM}
+)
 
 # Configure the file before adding the header only libs
-configure_file(${CMAKE_CURRENT_LIST_DIR}/FindBoost.cmake.in
-               ${CMAKE_CURRENT_LIST_DIR}/FindBoost.cmake @ONLY)
+configure_file(
+  ${CMAKE_CURRENT_LIST_DIR}/FindBoost.cmake.in
+  ${CMAKE_CURRENT_LIST_DIR}/FindBoost.cmake
+  @ONLY
+)
 
-set(BOOST_HEADER_ONLY
-    crc
-    circular_buffer
-    math
-    multi_index
-    multiprecision
-    numeric_conversion
-    random
-    uuid
-    variant)
+set(
+  BOOST_HEADER_ONLY
+  crc
+  circular_buffer
+  math
+  multi_index
+  multiprecision
+  numeric_conversion
+  random
+  uuid
+  variant
+)
 list(APPEND BOOST_INCLUDE_LIBRARIES ${BOOST_HEADER_ONLY})
 
 # The `headers` target is not created by Boost cmake and leads to a warning
@@ -66,7 +76,5 @@ set(BUILD_SHARED_LIBS OFF)
 FetchContent_MakeAvailable(Boost)
 
 list(TRANSFORM BOOST_HEADER_ONLY PREPEND Boost::)
-target_link_libraries(
-  boost_headers
-  INTERFACE ${BOOST_HEADER_ONLY})
+target_link_libraries(boost_headers INTERFACE ${BOOST_HEADER_ONLY})
 add_library(Boost::headers ALIAS boost_headers)
diff --git a/CMake/resolve_dependency_modules/c-ares.cmake b/CMake/resolve_dependency_modules/c-ares.cmake
index ccc48b632728..267ee27758c9 100644
--- a/CMake/resolve_dependency_modules/c-ares.cmake
+++ b/CMake/resolve_dependency_modules/c-ares.cmake
@@ -14,12 +14,16 @@
 include_guard(GLOBAL)
 
 set(VELOX_CARES_BUILD_VERSION cares-1_13_0)
-set(VELOX_CARES_BUILD_SHA256_CHECKSUM
-    7c48c57706a38691041920e705d2a04426ad9c68d40edd600685323f214b2d57)
+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")
+  CONCAT
+  VELOX_CARES_SOURCE_URL
+  "https://github.com/c-ares/c-ares/archive/refs/tags/"
+  "${VELOX_CARES_BUILD_VERSION}.tar.gz"
+)
 
 velox_resolve_dependency_url(CARES)
 
@@ -29,10 +33,11 @@ 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)
+  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)
diff --git a/CMake/resolve_dependency_modules/clp.cmake b/CMake/resolve_dependency_modules/clp.cmake
index 72e5e65b9f41..c9579fbc314b 100644
--- a/CMake/resolve_dependency_modules/clp.cmake
+++ b/CMake/resolve_dependency_modules/clp.cmake
@@ -16,28 +16,16 @@ include_guard(GLOBAL)
 FetchContent_Declare(
   clp
   GIT_REPOSITORY https://github.com/y-scope/clp.git
-  GIT_TAG v0.8.0)
+  GIT_TAG f82e6114160a6addd4727259906bcf621ac9912c
+)
 
-set(CLP_BUILD_CLP_REGEX_UTILS
-    OFF
-    CACHE BOOL "Build CLP regex utils")
-set(CLP_BUILD_CLP_S_JSONCONSTRUCTOR
-    OFF
-    CACHE BOOL "Build CLP-S JSON constructor")
-set(CLP_BUILD_CLP_S_REDUCER_DEPENDENCIES
-    OFF
-    CACHE BOOL "Build CLP-S reducer dependencies")
-set(CLP_BUILD_CLP_S_SEARCH_SQL
-    OFF
-    CACHE BOOL "Build CLP-S search SQL")
-set(CLP_BUILD_EXECUTABLES
-    OFF
-    CACHE BOOL "Build CLP executables")
-set(CLP_BUILD_TESTING
-    OFF
-    CACHE BOOL "Build CLP tests")
+set(CLP_BUILD_CLP_REGEX_UTILS OFF CACHE BOOL "Build CLP regex utils")
+set(CLP_BUILD_CLP_S_JSONCONSTRUCTOR OFF CACHE BOOL "Build CLP-S JSON constructor")
+set(CLP_BUILD_CLP_S_REDUCER_DEPENDENCIES OFF CACHE BOOL "Build CLP-S reducer dependencies")
+set(CLP_BUILD_CLP_S_SEARCH_SQL OFF CACHE BOOL "Build CLP-S search SQL")
+set(CLP_BUILD_EXECUTABLES OFF CACHE BOOL "Build CLP executables")
+set(CLP_BUILD_TESTING OFF CACHE BOOL "Build CLP tests")
 
 FetchContent_Populate(clp)
 
-add_subdirectory(${clp_SOURCE_DIR}/components/core
-                 ${clp_BINARY_DIR}/components/core)
+add_subdirectory(${clp_SOURCE_DIR}/components/core ${clp_BINARY_DIR}/components/core)
diff --git a/CMake/resolve_dependency_modules/cpr.cmake b/CMake/resolve_dependency_modules/cpr.cmake
deleted file mode 100644
index 488595e08512..000000000000
--- a/CMake/resolve_dependency_modules/cpr.cmake
+++ /dev/null
@@ -1,47 +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_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)
-velox_resolve_dependency(curl)
-
-velox_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 ${VELOX_BUILD_SHARED})
-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)
-unset(BUILD_SHARED_LIBS)
diff --git a/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch b/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch
deleted file mode 100644
index 49821889f2bf..000000000000
--- a/CMake/resolve_dependency_modules/cpr/cpr-libcurl-compatible.patch
+++ /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.
-#
-# 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/cudf.cmake b/CMake/resolve_dependency_modules/cudf.cmake
index 56f7b9bf1d18..e21406411865 100644
--- a/CMake/resolve_dependency_modules/cudf.cmake
+++ b/CMake/resolve_dependency_modules/cudf.cmake
@@ -17,79 +17,48 @@ include_guard(GLOBAL)
 # 3.30.4 is the minimum version required by cudf
 cmake_minimum_required(VERSION 3.30.4)
 
-set(VELOX_rapids_cmake_VERSION 25.04)
-set(VELOX_rapids_cmake_BUILD_SHA256_CHECKSUM
-    458c14eaff9000067b32d65c8c914f4521090ede7690e16eb57035ce731386db)
-set(VELOX_rapids_cmake_SOURCE_URL
-    "https://github.com/rapidsai/rapids-cmake/archive/7828fc8ff2e9f4fa86099f3c844505c2f47ac672.tar.gz"
-)
-velox_resolve_dependency_url(rapids_cmake)
+# Add velox_resolve_dependency_url here for rapids-cmake, rmm, and kvikio if a specific version or commit is needed.
 
-set(VELOX_rmm_VERSION 25.04)
-set(VELOX_rmm_BUILD_SHA256_CHECKSUM
-    294905094213a2d1fd8e024500359ff871bc52f913a3fbaca3514727c49f62de)
-set(VELOX_rmm_SOURCE_URL
-    "https://github.com/rapidsai/rmm/archive/d8b7dacdeda302d2e37313c02d14ef5e1d1e98ea.tar.gz"
-)
-velox_resolve_dependency_url(rmm)
+set(VELOX_cudf_VERSION 25.12 CACHE STRING "cudf version")
 
-set(VELOX_kvikio_VERSION 25.04)
-set(VELOX_kvikio_BUILD_SHA256_CHECKSUM
-    4a0b15295d0a397433930bf9a309e4ad2361b25dc7a7b3e6a35d0c9419d0cb62)
-set(VELOX_kvikio_SOURCE_URL
-    "https://github.com/rapidsai/kvikio/archive/5c710f37236bda76e447e929e17b1efbc6c632c3.tar.gz"
+set(
+  VELOX_cudf_BUILD_SHA256_CHECKSUM
+  4ec101a368e1423a1a3831a121f0d24e2d91ed044aed68faee0ba18fda38b450
 )
-velox_resolve_dependency_url(kvikio)
-
-set(VELOX_cudf_VERSION 25.04)
-set(VELOX_cudf_BUILD_SHA256_CHECKSUM
-    e5a1900dfaf23dab2c5808afa17a2d04fa867d2892ecec1cb37908f3b73715c2)
-set(VELOX_cudf_SOURCE_URL
-    "https://github.com/rapidsai/cudf/archive/4c1c99011da2c23856244e05adda78ba66697105.tar.gz"
+set(
+  VELOX_cudf_SOURCE_URL
+  "https://github.com/rapidsai/cudf/archive/181bd7b85c614e9c8f755a62f07f4b9c9334b615.tar.gz"
 )
 velox_resolve_dependency_url(cudf)
 
 # Use block so we don't leak variables
 block(SCOPE_FOR VARIABLES)
-# Setup libcudf build to not have testing components
-set(BUILD_TESTS OFF)
-set(CUDF_BUILD_TESTUTIL OFF)
-set(BUILD_SHARED_LIBS ON)
-
-FetchContent_Declare(
-  rapids-cmake
-  URL ${VELOX_rapids_cmake_SOURCE_URL}
-  URL_HASH ${VELOX_rapids_cmake_BUILD_SHA256_CHECKSUM}
-  UPDATE_DISCONNECTED 1)
-
-FetchContent_Declare(
-  rmm
-  URL ${VELOX_rmm_SOURCE_URL}
-  URL_HASH ${VELOX_rmm_BUILD_SHA256_CHECKSUM}
-  UPDATE_DISCONNECTED 1)
+  # Setup libcudf build to not have testing components
+  set(BUILD_TESTS OFF)
+  set(CUDF_BUILD_TESTUTIL OFF)
+  set(BUILD_SHARED_LIBS ON)
 
-FetchContent_Declare(
-  kvikio
-  URL ${VELOX_kvikio_SOURCE_URL}
-  URL_HASH ${VELOX_kvikio_BUILD_SHA256_CHECKSUM}
-  SOURCE_SUBDIR cpp
-  UPDATE_DISCONNECTED 1)
+  # Add FetchContent_Declare here for rapids-cmake, rmm, and kvikio if a specific version or commit is needed.
 
-FetchContent_Declare(
-  cudf
-  URL ${VELOX_cudf_SOURCE_URL}
-  URL_HASH ${VELOX_cudf_BUILD_SHA256_CHECKSUM}
-  SOURCE_SUBDIR cpp
-  UPDATE_DISCONNECTED 1)
+  FetchContent_Declare(
+    cudf
+    URL ${VELOX_cudf_SOURCE_URL}
+    URL_HASH ${VELOX_cudf_BUILD_SHA256_CHECKSUM}
+    SOURCE_SUBDIR
+    cpp
+    UPDATE_DISCONNECTED 1
+  )
 
-FetchContent_MakeAvailable(cudf)
+  FetchContent_MakeAvailable(cudf)
 
-# cudf sets all warnings as errors, and therefore fails to compile with velox
-# expanded set of warnings. We selectively disable problematic warnings just for
-# cudf
-target_compile_options(
-  cudf PRIVATE -Wno-non-virtual-dtor -Wno-missing-field-initializers
-               -Wno-deprecated-copy)
+  # cudf sets all warnings as errors, and therefore fails to compile with velox
+  # expanded set of warnings. We selectively disable problematic warnings just for
+  # cudf
+  target_compile_options(
+    cudf
+    PRIVATE -Wno-non-virtual-dtor -Wno-missing-field-initializers -Wno-deprecated-copy -Wno-restrict
+  )
 
-unset(BUILD_SHARED_LIBS)
+  unset(BUILD_SHARED_LIBS)
+  unset(BUILD_TESTING CACHE)
 endblock()
diff --git a/CMake/resolve_dependency_modules/curl.cmake b/CMake/resolve_dependency_modules/curl.cmake
index 80be3e09b975..fd4b51adf2b4 100644
--- a/CMake/resolve_dependency_modules/curl.cmake
+++ b/CMake/resolve_dependency_modules/curl.cmake
@@ -13,18 +13,4 @@
 # 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")
-
-velox_resolve_dependency_url(CURL)
-
-FetchContent_Declare(
-  curl
-  URL ${VELOX_CURL_SOURCE_URL}
-  URL_HASH ${VELOX_CURL_BUILD_SHA256_CHECKSUM})
+add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/curl)
diff --git a/CMake/resolve_dependency_modules/curl/CMakeLists.txt b/CMake/resolve_dependency_modules/curl/CMakeLists.txt
new file mode 100644
index 000000000000..867c19cf242f
--- /dev/null
+++ b/CMake/resolve_dependency_modules/curl/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.
+
+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"
+)
+
+set(BUILD_TESTING OFF)
+set(BUILD_SHARED_LIBS ON)
+
+velox_resolve_dependency_url(CURL)
+
+message(STATUS "Building CURL from source")
+
+FetchContent_Declare(curl URL ${VELOX_CURL_SOURCE_URL} URL_HASH ${VELOX_CURL_BUILD_SHA256_CHECKSUM})
+
+FetchContent_MakeAvailable(curl)
+
+# Curl uses CMake option for BUILD_TESTING and BUILD_SHARED_LIBS
+# See CMake option semantics.
+unset(BUILD_TESTING CACHE)
+unset(BUILD_SHARED_LIBS CACHE)
diff --git a/CMake/resolve_dependency_modules/date.cmake b/CMake/resolve_dependency_modules/date.cmake
index 275aa6e0a080..4daaee85f067 100644
--- a/CMake/resolve_dependency_modules/date.cmake
+++ b/CMake/resolve_dependency_modules/date.cmake
@@ -14,18 +14,19 @@
 include_guard(GLOBAL)
 
 set(VELOX_DATE_BUILD_VERSION 3.0.1)
-set(VELOX_DATE_BUILD_SHA256_CHECKSUM
-    7a390f200f0ccd207e8cff6757e04817c1a0aec3e327b006b7eb451c57ee3538)
-set(VELOX_DATE_SOURCE_URL
-    "https://github.com/HowardHinnant/date/archive/refs/tags/v${VELOX_DATE_BUILD_VERSION}.tar.gz"
+set(
+  VELOX_DATE_BUILD_SHA256_CHECKSUM
+  7a390f200f0ccd207e8cff6757e04817c1a0aec3e327b006b7eb451c57ee3538
+)
+set(
+  VELOX_DATE_SOURCE_URL
+  "https://github.com/HowardHinnant/date/archive/refs/tags/v${VELOX_DATE_BUILD_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(DATE)
 
 # Optionally set CMake variables *before* make-available
-set(CMAKE_INSTALL_MESSAGE
-    LAZY
-    CACHE STRING "" FORCE)
+set(CMAKE_INSTALL_MESSAGE LAZY CACHE STRING "" FORCE)
 
 message(STATUS "Building date from source")
 
@@ -33,6 +34,7 @@ FetchContent_Declare(
   date
   URL ${VELOX_DATE_SOURCE_URL}
   URL_HASH ${VELOX_DATE_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE)
+  OVERRIDE_FIND_PACKAGE
+)
 
 FetchContent_MakeAvailable(date)
diff --git a/CMake/resolve_dependency_modules/duckdb.cmake b/CMake/resolve_dependency_modules/duckdb.cmake
index 75dde1f8eebd..bd3fbd7e14f8 100644
--- a/CMake/resolve_dependency_modules/duckdb.cmake
+++ b/CMake/resolve_dependency_modules/duckdb.cmake
@@ -14,10 +14,13 @@
 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"
+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"
 )
 set(CMAKE_POLICY_VERSION_MINIMUM 3.5)
 
@@ -25,19 +28,23 @@ velox_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.
+# twice. Velox already does this.
 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)
+    ${CMAKE_CURRENT_LIST_DIR}/duckdb/re2.patch
+)
 
+# DuckDB uses git commands to retrieve version information during the build,
+# which works with git clone. To prevent incorrectly using the parent project's
+# git version when building from a tarball, we define GIT_COMMIT_HASH to skip
+# that.
+set(GIT_COMMIT_HASH "6536a77")
 set(BUILD_UNITTESTS OFF)
+set(BUILD_TESTING OFF)
 set(ENABLE_SANITIZER OFF)
 set(ENABLE_UBSAN OFF)
 set(BUILD_SHELL OFF)
@@ -46,6 +53,10 @@ 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")
+# Clang17 requires this. See issue #13215.
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 17.0.0)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-template-arg-list-after-template-kw")
+endif()
 
 FetchContent_MakeAvailable(duckdb)
 
@@ -55,3 +66,5 @@ endif()
 
 set(CMAKE_CXX_FLAGS ${PREVIOUS_CMAKE_CXX_FLAGS})
 set(CMAKE_BUILD_TYPE ${PREVIOUS_BUILD_TYPE})
+# Some DuckDB third-party package sets this flags. We cannot control that.
+unset(BUILD_TESTING)
diff --git a/CMake/resolve_dependency_modules/duckdb/fix-duckdbversion.patch b/CMake/resolve_dependency_modules/duckdb/fix-duckdbversion.patch
deleted file mode 100644
index d990646800f5..000000000000
--- a/CMake/resolve_dependency_modules/duckdb/fix-duckdbversion.patch
+++ /dev/null
@@ -1,59 +0,0 @@
---- 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/faiss.cmake b/CMake/resolve_dependency_modules/faiss.cmake
new file mode 100644
index 000000000000..db158dbe65d3
--- /dev/null
+++ b/CMake/resolve_dependency_modules/faiss.cmake
@@ -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_guard(GLOBAL)
+
+set(VELOX_FAISS_BUILD_VERSION 1.11.0)
+set(
+  VELOX_FAISS_BUILD_SHA256_CHECKSUM
+  c5d517da6deb6a6d74290d7145331fc7474426025e2d826fa4a6d40670f4493c
+)
+set(
+  VELOX_FAISS_SOURCE_URL
+  "https://github.com/facebookresearch/faiss/archive/refs/tags/v${VELOX_FAISS_BUILD_VERSION}.tar.gz"
+)
+
+velox_resolve_dependency_url(FAISS)
+
+# We need these hints for macos to build.
+if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+  message(STATUS "Detected Apple platform")
+  execute_process(
+    COMMAND brew --prefix libomp
+    RESULT_VARIABLE BREW_LIBOMP_RESULT
+    OUTPUT_VARIABLE BREW_LIBOMP_PREFIX
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(BREW_LIBOMP_RESULT EQUAL 0 AND EXISTS "${BREW_LIBOMP_PREFIX}")
+    list(APPEND CMAKE_PREFIX_PATH "${BREW_LIBOMP_PREFIX}")
+  endif()
+
+  execute_process(
+    COMMAND brew --prefix openblas
+    RESULT_VARIABLE BREW_OPENBLAS_RESULT
+    OUTPUT_VARIABLE BREW_OPENBLAS_PREFIX
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(BREW_OPENBLAS_RESULT EQUAL 0 AND EXISTS "${BREW_OPENBLAS_PREFIX}")
+    list(APPEND CMAKE_PREFIX_PATH "${BREW_OPENBLAS_PREFIX}")
+  endif()
+endif()
+
+FetchContent_Declare(
+  faiss
+  URL ${VELOX_FAISS_SOURCE_URL}
+  URL_HASH ${VELOX_FAISS_BUILD_SHA256_CHECKSUM}
+  SYSTEM
+  EXCLUDE_FROM_ALL
+)
+
+# Set build options
+block()
+  set(BUILD_SHARED_LIBS OFF)
+  set(BUILD_TESTING OFF)
+  set(CMAKE_BUILD_TYPE Release)
+  set(FAISS_ENABLE_GPU OFF)
+  set(FAISS_ENABLE_PYTHON OFF)
+  set(FAISS_ENABLE_GPU_TESTS OFF)
+  # Make FAISS available
+  FetchContent_MakeAvailable(faiss)
+  add_library(FAISS::faiss ALIAS faiss)
+  unset(BUILD_TESTING CACHE)
+  unset(BUILD_SHARED_LIBS CACHE)
+endblock()
diff --git a/CMake/resolve_dependency_modules/fastfloat.cmake b/CMake/resolve_dependency_modules/fastfloat.cmake
index 2800cdf566fc..9f31b08c6c92 100644
--- a/CMake/resolve_dependency_modules/fastfloat.cmake
+++ b/CMake/resolve_dependency_modules/fastfloat.cmake
@@ -14,10 +14,13 @@
 include_guard(GLOBAL)
 
 set(VELOX_FASTFLOAT_VERSION v8.0.2)
-set(VELOX_FASTFLOAT_BUILD_SHA256_CHECKSUM
-    e14a33089712b681d74d94e2a11362643bd7d769ae8f7e7caefe955f57f7eacd)
-set(VELOX_FASTFLOAT_SOURCE_URL
-    "https://github.com/fastfloat/fast_float/archive/refs/tags/${VELOX_FASTFLOAT_VERSION}.tar.gz"
+set(
+  VELOX_FASTFLOAT_BUILD_SHA256_CHECKSUM
+  e14a33089712b681d74d94e2a11362643bd7d769ae8f7e7caefe955f57f7eacd
+)
+set(
+  VELOX_FASTFLOAT_SOURCE_URL
+  "https://github.com/fastfloat/fast_float/archive/refs/tags/${VELOX_FASTFLOAT_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(FASTFLOAT)
@@ -26,7 +29,8 @@ message(STATUS "Building fast_float from source")
 FetchContent_Declare(
   fastfloat
   URL ${VELOX_FASTFLOAT_SOURCE_URL}
-  URL_HASH ${VELOX_FASTFLOAT_BUILD_SHA256_CHECKSUM})
+  URL_HASH ${VELOX_FASTFLOAT_BUILD_SHA256_CHECKSUM}
+)
 set(fastfloat_BUILD_TESTS OFF)
 FetchContent_MakeAvailable(fastfloat)
 # If folly is bundled it uses find_path fast_float/fast_float.h to locate the
@@ -39,4 +43,5 @@ find_path(
   FASTFLOAT_INCLUDE_DIR
   NAMES fast_float/fast_float.h
   PATHS ${FASTFLOAT_SOURCE_DIR}
-  PATH_SUFFIXES include)
+  PATH_SUFFIXES include
+)
diff --git a/CMake/resolve_dependency_modules/fmt.cmake b/CMake/resolve_dependency_modules/fmt.cmake
index cb57fd28fa4c..9e8087f1da00 100644
--- a/CMake/resolve_dependency_modules/fmt.cmake
+++ b/CMake/resolve_dependency_modules/fmt.cmake
@@ -13,19 +13,17 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_FMT_VERSION 10.1.1)
-set(VELOX_FMT_BUILD_SHA256_CHECKSUM
-    78b8c0a72b1c35e4443a7e308df52498252d1cefc2b08c9a97bc9ee6cfe61f8b)
-set(VELOX_FMT_SOURCE_URL
-    "https://github.com/fmtlib/fmt/archive/${VELOX_FMT_VERSION}.tar.gz")
+set(VELOX_FMT_VERSION 11.2.0)
+set(
+  VELOX_FMT_BUILD_SHA256_CHECKSUM
+  bc23066d87ab3168f27cef3e97d545fa63314f5c79df5ea444d41d56f962c6af
+)
+set(VELOX_FMT_SOURCE_URL "https://github.com/fmtlib/fmt/archive/${VELOX_FMT_VERSION}.tar.gz")
 
 velox_resolve_dependency_url(FMT)
 
 message(STATUS "Building fmt from source")
-FetchContent_Declare(
-  fmt
-  URL ${VELOX_FMT_SOURCE_URL}
-  URL_HASH ${VELOX_FMT_BUILD_SHA256_CHECKSUM})
+FetchContent_Declare(fmt URL ${VELOX_FMT_SOURCE_URL} 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/folly/CMakeLists.txt b/CMake/resolve_dependency_modules/folly/CMakeLists.txt
index 57156ee0f3fd..884193118de8 100644
--- a/CMake/resolve_dependency_modules/folly/CMakeLists.txt
+++ b/CMake/resolve_dependency_modules/folly/CMakeLists.txt
@@ -14,14 +14,17 @@
 project(Folly)
 cmake_minimum_required(VERSION 3.28)
 
-velox_set_source(fastfloat)
-velox_resolve_dependency(fastfloat CONFIG REQUIRED)
+velox_set_source(FastFloat)
+velox_resolve_dependency(FastFloat CONFIG REQUIRED)
 
 set(VELOX_FOLLY_BUILD_VERSION v2025.04.28.00)
-set(VELOX_FOLLY_BUILD_SHA256_CHECKSUM
-    ccbb7eac662023f9f5beba94e51350d527f33d8a7a036eb5e3d8a5cf1b49d3bc)
-set(VELOX_FOLLY_SOURCE_URL
-    "https://github.com/facebook/folly/releases/download/${VELOX_FOLLY_BUILD_VERSION}/folly-${VELOX_FOLLY_BUILD_VERSION}.tar.gz"
+set(
+  VELOX_FOLLY_BUILD_SHA256_CHECKSUM
+  ccbb7eac662023f9f5beba94e51350d527f33d8a7a036eb5e3d8a5cf1b49d3bc
+)
+set(
+  VELOX_FOLLY_SOURCE_URL
+  "https://github.com/facebook/folly/releases/download/${VELOX_FOLLY_BUILD_VERSION}/folly-${VELOX_FOLLY_BUILD_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(FOLLY)
@@ -41,8 +44,11 @@ FetchContent_Declare(
   folly
   URL ${VELOX_FOLLY_SOURCE_URL}
   URL_HASH ${VELOX_FOLLY_BUILD_SHA256_CHECKSUM}
-  PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/folly-no-export.patch
-                ${glog_patch} OVERRIDE_FIND_PACKAGE SYSTEM EXCLUDE_FROM_ALL)
+  PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/folly-no-export.patch ${glog_patch}
+  OVERRIDE_FIND_PACKAGE
+  SYSTEM
+  EXCLUDE_FROM_ALL
+)
 
 set(BUILD_SHARED_LIBS ${VELOX_BUILD_SHARED})
 
diff --git a/CMake/resolve_dependency_modules/geos.cmake b/CMake/resolve_dependency_modules/geos.cmake
index 2cc129deda8b..f092ba823b1f 100644
--- a/CMake/resolve_dependency_modules/geos.cmake
+++ b/CMake/resolve_dependency_modules/geos.cmake
@@ -12,40 +12,47 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 include_guard(GLOBAL)
-# GEOS Configuration
-set(VELOX_GEOS_BUILD_VERSION 3.10.2)
-set(VELOX_GEOS_BUILD_SHA256_CHECKSUM
-    50bbc599ac386b4c2b3962dcc411f0040a61f204aaef4eba7225ecdd0cf45715)
-string(CONCAT VELOX_GEOS_SOURCE_URL "https://download.osgeo.org/geos/"
-              "geos-${VELOX_GEOS_BUILD_VERSION}.tar.bz2")
 
-velox_resolve_dependency_url(GEOS)
-
-FetchContent_Declare(
-  geos
-  URL ${VELOX_GEOS_SOURCE_URL}
-  URL_HASH ${VELOX_GEOS_BUILD_SHA256_CHECKSUM}
-  PATCH_COMMAND
-    git apply "${CMAKE_CURRENT_LIST_DIR}/geos/geos-cmakelists.patch" && git
-    apply "${CMAKE_CURRENT_LIST_DIR}/geos/geos-build.patch")
-
-list(APPEND CMAKE_MODULE_PATH "${geos_SOURCE_DIR}/cmake")
-set(BUILD_SHARED_LIBS ${VELOX_BUILD_SHARED})
-set(CMAKE_BUILD_TYPE Release)
-set(PREVIOUS_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -Wno-nonnull ")
-
-# This option defaults to on and adds warning flags that fail the build.
-set(GEOS_BUILD_DEVELOPER OFF)
-
-if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -Wno-dangling-pointer")
-endif()
-
-FetchContent_MakeAvailable(geos)
-
-add_library(GEOS::geos ALIAS geos)
-
-unset(BUILD_SHARED_LIBS)
-set(CMAKE_CXX_FLAGS ${PREVIOUS_CMAKE_CXX_FLAGS})
-set(CMAKE_BUILD_TYPE ${PREVIOUS_BUILD_TYPE})
+# This creates a separate scope so any changed variables don't affect
+# the rest of the build.
+block()
+  set(VELOX_GEOS_BUILD_VERSION 3.10.7)
+  set(
+    VELOX_GEOS_BUILD_SHA256_CHECKSUM
+    8b2ab4d04d660e27f2006550798f49dd11748c3767455cae9f71967dc437da1f
+  )
+  string(
+    CONCAT
+    VELOX_GEOS_SOURCE_URL
+    "https://download.osgeo.org/geos/"
+    "geos-${VELOX_GEOS_BUILD_VERSION}.tar.bz2"
+  )
+
+  velox_resolve_dependency_url(GEOS)
+
+  FetchContent_Declare(
+    geos
+    URL ${VELOX_GEOS_SOURCE_URL}
+    URL_HASH ${VELOX_GEOS_BUILD_SHA256_CHECKSUM}
+    PATCH_COMMAND git apply "${CMAKE_CURRENT_LIST_DIR}/geos/geos-cmakelists.patch"
+    OVERRIDE_FIND_PACKAGE
+    SYSTEM
+    EXCLUDE_FROM_ALL
+  )
+
+  list(APPEND CMAKE_MODULE_PATH "${geos_SOURCE_DIR}/cmake")
+  set(BUILD_SHARED_LIBS OFF)
+  set(BUILD_TESTING OFF)
+  set(CMAKE_BUILD_TYPE Release)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -Wno-nonnull ")
+  # This option defaults to on and adds warning flags that fail the build.
+  set(GEOS_BUILD_DEVELOPER OFF)
+
+  if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  -Wno-dangling-pointer")
+  endif()
+
+  FetchContent_MakeAvailable(geos)
+
+  add_library(GEOS::geos ALIAS geos)
+endblock()
diff --git a/CMake/resolve_dependency_modules/geos/geos-build.patch b/CMake/resolve_dependency_modules/geos/geos-build.patch
deleted file mode 100644
index 4194a5f44c15..000000000000
--- a/CMake/resolve_dependency_modules/geos/geos-build.patch
+++ /dev/null
@@ -1,46 +0,0 @@
---- a/capi/geos_ts_c.cpp
-+++ b/capi/geos_ts_c.cpp
-@@ -2168,7 +2168,7 @@ extern "C" {
-     const char* GEOSversion()
-     {
-         static char version[256];
--        sprintf(version, "%s", GEOS_CAPI_VERSION);
-+        snprintf(version, sizeof(version), "%s", GEOS_CAPI_VERSION);
-         return version;
-     }
-
---- a/include/geos/io/ByteOrderDataInStream.h
-+++ b/include/geos/io/ByteOrderDataInStream.h
-@@ -22,6 +22,7 @@
-
- #include <geos/export.h>
- #include <cstdint>
-+#include <cstddef>
-
- //#include <geos/io/ParseException.h>
- //#include <geos/io/ByteOrderValues.h>
---- a/tests/unit/math/DDTest.cpp
-+++ b/tests/unit/math/DDTest.cpp
-@@ -160,11 +160,9 @@ struct test_dd_data {
-         DD t2 = t*t;
-         DD at(0.0);
-         DD two(2.0);
--        int k = 0;
-         DD d(1.0);
-         int sign = 1;
-         while (t.doubleValue() > eps) {
--            k++;
-             if (sign < 0)
-                 at = at - (t / d);
-             else
-@@ -187,10 +185,8 @@ struct test_dd_data {
-         DD s(2.0);
-         DD t(1.0);
-         double n = 1.0;
--        int i = 0;
-         while(t.doubleValue() > eps)
-         {
--            i++;
-             n += 1.0;
-             t = t / DD(n);
-             s = s + t;
diff --git a/CMake/resolve_dependency_modules/gflags.cmake b/CMake/resolve_dependency_modules/gflags.cmake
index 7c7aa2854cba..f937a7f7087d 100644
--- a/CMake/resolve_dependency_modules/gflags.cmake
+++ b/CMake/resolve_dependency_modules/gflags.cmake
@@ -14,12 +14,16 @@
 include_guard(GLOBAL)
 
 set(VELOX_GFLAGS_VERSION 2.2.2)
-set(VELOX_GFLAGS_BUILD_SHA256_CHECKSUM
-    34af2f15cf7367513b352bdcd2493ab14ce43692d2dcd9dfc499492966c64dcf)
+set(
+  VELOX_GFLAGS_BUILD_SHA256_CHECKSUM
+  34af2f15cf7367513b352bdcd2493ab14ce43692d2dcd9dfc499492966c64dcf
+)
 string(
-  CONCAT VELOX_GFLAGS_SOURCE_URL
-         "https://github.com/gflags/gflags/archive/refs/tags/"
-         "v${VELOX_GFLAGS_VERSION}.tar.gz")
+  CONCAT
+  VELOX_GFLAGS_SOURCE_URL
+  "https://github.com/gflags/gflags/archive/refs/tags/"
+  "v${VELOX_GFLAGS_VERSION}.tar.gz"
+)
 
 velox_resolve_dependency_url(GFLAGS)
 
@@ -29,7 +33,10 @@ FetchContent_Declare(
   URL ${VELOX_GFLAGS_SOURCE_URL}
   URL_HASH ${VELOX_GFLAGS_BUILD_SHA256_CHECKSUM}
   PATCH_COMMAND git apply ${CMAKE_CURRENT_LIST_DIR}/gflags/gflags-config.patch
-                OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+  SYSTEM
+)
 
 # glog relies on the old `google` namespace
 set(GFLAGS_NAMESPACE "google;gflags")
@@ -52,9 +59,13 @@ FetchContent_MakeAvailable(gflags)
 
 # Workaround for https://github.com/gflags/gflags/issues/277
 if(DEFINED CACHED_BUILD_SHARED_LIBS)
-  set(BUILD_SHARED_LIBS
-      ${CACHED_BUILD_SHARED_LIBS}
-      CACHE BOOL "Restored after setting up gflags" FORCE)
+  set(
+    BUILD_SHARED_LIBS
+    ${CACHED_BUILD_SHARED_LIBS}
+    CACHE BOOL
+    "Restored after setting up gflags"
+    FORCE
+  )
 endif()
 
 # This causes find_package(gflags) in other dependencies to search in the build
diff --git a/CMake/resolve_dependency_modules/glog.cmake b/CMake/resolve_dependency_modules/glog.cmake
index 61dfe479e71b..28256bfa0838 100644
--- a/CMake/resolve_dependency_modules/glog.cmake
+++ b/CMake/resolve_dependency_modules/glog.cmake
@@ -14,10 +14,13 @@
 include_guard(GLOBAL)
 
 set(VELOX_GLOG_VERSION 0.6.0)
-set(VELOX_GLOG_BUILD_SHA256_CHECKSUM
-    8a83bf982f37bb70825df71a9709fa90ea9f4447fb3c099e1d720a439d88bad6)
-set(VELOX_GLOG_SOURCE_URL
-    "https://github.com/google/glog/archive/refs/tags/v${VELOX_GLOG_VERSION}.tar.gz"
+set(
+  VELOX_GLOG_BUILD_SHA256_CHECKSUM
+  8a83bf982f37bb70825df71a9709fa90ea9f4447fb3c099e1d720a439d88bad6
+)
+set(
+  VELOX_GLOG_SOURCE_URL
+  "https://github.com/google/glog/archive/refs/tags/v${VELOX_GLOG_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(GLOG)
@@ -29,8 +32,11 @@ FetchContent_Declare(
   URL_HASH ${VELOX_GLOG_BUILD_SHA256_CHECKSUM}
   PATCH_COMMAND
     git apply ${CMAKE_CURRENT_LIST_DIR}/glog/glog-no-export.patch && git apply
-    ${CMAKE_CURRENT_LIST_DIR}/glog/glog-config.patch SYSTEM
-    OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL)
+    ${CMAKE_CURRENT_LIST_DIR}/glog/glog-config.patch
+  SYSTEM
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+)
 
 set(BUILD_SHARED_LIBS ${VELOX_BUILD_SHARED})
 set(WITH_UNWIND OFF)
@@ -47,17 +53,13 @@ add_dependencies(glog gflags::gflags)
 
 # The default target has the glog-src as an include dir but this causes issues
 # with folly due to an internal glog 'demangle.h' being mistaken for a system
-# header so we remove glog_SOURCE_DIR by overwriting
-# INTERFACE_INCLUDE_DIRECTORIES
-get_target_property(
-  _glog_target glog::glog ALIASED_TARGET) # Can't set properties on ALIAS
-                                          # targets
-set_target_properties(
-  ${_glog_target}
-  PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${glog_BINARY_DIR})
+# header so we remove glog_SOURCE_DIR by overwriting INTERFACE_INCLUDE_DIRECTORIES
+
+# Can't set properties on ALIAS targets
+get_target_property(_glog_target glog::glog ALIASED_TARGET)
+
+set_target_properties(${_glog_target} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${glog_BINARY_DIR})
 
 # These headers are missing from glog_BINARY_DIR
-file(COPY ${glog_SOURCE_DIR}/src/glog/platform.h
-     DESTINATION ${glog_BINARY_DIR}/glog)
-file(COPY ${glog_SOURCE_DIR}/src/glog/log_severity.h
-     DESTINATION ${glog_BINARY_DIR}/glog)
+file(COPY ${glog_SOURCE_DIR}/src/glog/platform.h DESTINATION ${glog_BINARY_DIR}/glog)
+file(COPY ${glog_SOURCE_DIR}/src/glog/log_severity.h DESTINATION ${glog_BINARY_DIR}/glog)
diff --git a/CMake/resolve_dependency_modules/google_cloud_cpp_storage.cmake b/CMake/resolve_dependency_modules/google_cloud_cpp_storage.cmake
index 894cb7a216ed..403b252fa58c 100644
--- a/CMake/resolve_dependency_modules/google_cloud_cpp_storage.cmake
+++ b/CMake/resolve_dependency_modules/google_cloud_cpp_storage.cmake
@@ -17,12 +17,16 @@ velox_set_source(gRPC)
 velox_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)
+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")
+  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"
+)
 
 velox_resolve_dependency_url(GOOGLE_CLOUD_CPP)
 
@@ -32,10 +36,11 @@ 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)
+  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.")
+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
index 7ee7dd2d9775..5b762077368a 100644
--- a/CMake/resolve_dependency_modules/grpc.cmake
+++ b/CMake/resolve_dependency_modules/grpc.cmake
@@ -17,12 +17,16 @@ velox_set_source(absl)
 velox_resolve_dependency(absl CONFIG REQUIRED)
 
 set(VELOX_GRPC_BUILD_VERSION 1.48.1)
-set(VELOX_GRPC_BUILD_SHA256_CHECKSUM
-    320366665d19027cda87b2368c03939006a37e0388bfd1091c8d2a96fbc93bd8)
+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")
+  CONCAT
+  VELOX_GRPC_SOURCE_URL
+  "https://github.com/grpc/grpc/archive/refs/tags/"
+  "v${VELOX_GRPC_BUILD_VERSION}.tar.gz"
+)
 
 velox_resolve_dependency_url(GRPC)
 
@@ -32,32 +36,20 @@ FetchContent_Declare(
   gRPC
   URL ${VELOX_GRPC_SOURCE_URL}
   URL_HASH ${VELOX_GRPC_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL)
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+)
 
 # We need to specify CACHE explicitly even when we have
 # set(CMAKE_POLICY_DEFAULT_CMP0077 NEW). Because gRPC doesn't use option(). gRPC
 # uses set(... CACHE). So CMP0077 isn't affected.
-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")
+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++)
diff --git a/CMake/resolve_dependency_modules/gtest.cmake b/CMake/resolve_dependency_modules/gtest.cmake
index f1c892bb4c43..09ea9611aa05 100644
--- a/CMake/resolve_dependency_modules/gtest.cmake
+++ b/CMake/resolve_dependency_modules/gtest.cmake
@@ -14,10 +14,13 @@
 include_guard(GLOBAL)
 
 set(VELOX_GTEST_VERSION 1.13.0)
-set(VELOX_GTEST_BUILD_SHA256_CHECKSUM
-    ad7fdba11ea011c1d925b3289cf4af2c66a352e18d4c7264392fead75e919363)
-set(VELOX_GTEST_SOURCE_URL
-    "https://github.com/google/googletest/archive/refs/tags/v${VELOX_GTEST_VERSION}.tar.gz"
+set(
+  VELOX_GTEST_BUILD_SHA256_CHECKSUM
+  ad7fdba11ea011c1d925b3289cf4af2c66a352e18d4c7264392fead75e919363
+)
+set(
+  VELOX_GTEST_SOURCE_URL
+  "https://github.com/google/googletest/archive/refs/tags/v${VELOX_GTEST_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(GTEST)
@@ -27,7 +30,10 @@ FetchContent_Declare(
   googletest
   URL ${VELOX_GTEST_SOURCE_URL}
   URL_HASH ${VELOX_GTEST_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE SYSTEM EXCLUDE_FROM_ALL)
+  OVERRIDE_FIND_PACKAGE
+  SYSTEM
+  EXCLUDE_FROM_ALL
+)
 
 FetchContent_MakeAvailable(googletest)
 
diff --git a/CMake/resolve_dependency_modules/icu.cmake b/CMake/resolve_dependency_modules/icu.cmake
index 59f7f4eb0835..8f83c681e37e 100644
--- a/CMake/resolve_dependency_modules/icu.cmake
+++ b/CMake/resolve_dependency_modules/icu.cmake
@@ -14,13 +14,17 @@
 include_guard(GLOBAL)
 
 set(VELOX_ICU4C_BUILD_VERSION 72)
-set(VELOX_ICU4C_BUILD_SHA256_CHECKSUM
-    a2d2d38217092a7ed56635e34467f92f976b370e20182ad325edea6681a71d68)
+set(
+  VELOX_ICU4C_BUILD_SHA256_CHECKSUM
+  a2d2d38217092a7ed56635e34467f92f976b370e20182ad325edea6681a71d68
+)
 string(
-  CONCAT VELOX_ICU4C_SOURCE_URL
-         "https://github.com/unicode-org/icu/releases/download/"
-         "release-${VELOX_ICU4C_BUILD_VERSION}-1/"
-         "icu4c-${VELOX_ICU4C_BUILD_VERSION}_1-src.tgz")
+  CONCAT
+  VELOX_ICU4C_SOURCE_URL
+  "https://github.com/unicode-org/icu/releases/download/"
+  "release-${VELOX_ICU4C_BUILD_VERSION}-1/"
+  "icu4c-${VELOX_ICU4C_BUILD_VERSION}_1-src.tgz"
+)
 
 velox_resolve_dependency_url(ICU4C)
 
@@ -31,15 +35,17 @@ velox_set_with_default(NUM_JOBS NUM_THREADS ${NUM_JOBS})
 find_program(MAKE_PROGRAM make REQUIRED)
 
 set(ICU_CFG --disable-tests --disable-samples)
-set(HOST_ENV_CMAKE
-    ${CMAKE_COMMAND}
-    -E
-    env
-    CC="${CMAKE_C_COMPILER}"
-    CXX="${CMAKE_CXX_COMPILER}"
-    CFLAGS="${CMAKE_C_FLAGS}"
-    CXXFLAGS="${CMAKE_CXX_FLAGS} -w"
-    LDFLAGS="${CMAKE_MODULE_LINKER_FLAGS}")
+set(
+  HOST_ENV_CMAKE
+  ${CMAKE_COMMAND}
+  -E
+  env
+  CC="${CMAKE_C_COMPILER}"
+  CXX="${CMAKE_CXX_COMPILER}"
+  CFLAGS="${CMAKE_C_FLAGS}"
+  CXXFLAGS="${CMAKE_CXX_FLAGS} -w"
+  LDFLAGS="${CMAKE_MODULE_LINKER_FLAGS}"
+)
 set(ICU_DIR ${CMAKE_CURRENT_BINARY_DIR}/_deps/icu)
 set(ICU_INCLUDE_DIRS ${ICU_DIR}/include)
 set(ICU_LIBRARIES ${ICU_DIR}/lib)
@@ -51,10 +57,11 @@ ExternalProject_Add(
   URL_HASH ${VELOX_ICU4C_BUILD_SHA256_CHECKSUM}
   SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/icu-src
   BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/icu-bld
-  CONFIGURE_COMMAND <SOURCE_DIR>/source/configure --prefix=${ICU_DIR}
-                    --libdir=${ICU_LIBRARIES} ${ICU_CFG}
+  CONFIGURE_COMMAND
+    <SOURCE_DIR>/source/configure --prefix=${ICU_DIR} --libdir=${ICU_LIBRARIES} ${ICU_CFG}
   BUILD_COMMAND ${MAKE_PROGRAM} -j ${NUM_JOBS}
-  INSTALL_COMMAND ${HOST_ENV_CMAKE} ${MAKE_PROGRAM} install)
+  INSTALL_COMMAND ${HOST_ENV_CMAKE} ${MAKE_PROGRAM} install
+)
 
 add_library(ICU::ICU UNKNOWN IMPORTED)
 add_dependencies(ICU::ICU ICU-build)
@@ -65,26 +72,25 @@ file(MAKE_DIRECTORY ${ICU_INCLUDE_DIRS})
 file(MAKE_DIRECTORY ${ICU_LIBRARIES})
 
 # Create a target for each component
-set(icu_components
-    data
-    i18n
-    io
-    uc
-    tu)
+set(
+  icu_components
+  data
+  i18n
+  io
+  uc
+  tu
+)
 
 foreach(component ${icu_components})
   add_library(ICU::${component} SHARED IMPORTED)
-  string(
-    CONCAT ICU_${component}_LIBRARY
-           ${ICU_LIBRARIES}
-           "/libicu"
-           ${component}
-           ".so")
+  string(CONCAT ICU_${component}_LIBRARY ${ICU_LIBRARIES} "/libicu" ${component} ".so")
   file(TOUCH ${ICU_${component}_LIBRARY})
   set_target_properties(
     ICU::${component}
-    PROPERTIES IMPORTED_LOCATION ${ICU_${component}_LIBRARY}
-               INTERFACE_SYSTEM_INCLUDE_DIRECTORIES ${ICU_INCLUDE_DIRS})
+    PROPERTIES
+      IMPORTED_LOCATION ${ICU_${component}_LIBRARY}
+      INTERFACE_SYSTEM_INCLUDE_DIRECTORIES ${ICU_INCLUDE_DIRS}
+  )
   target_link_libraries(ICU::ICU INTERFACE ICU::${component})
 endforeach()
 
diff --git a/CMake/resolve_dependency_modules/icu/FindICU.cmake b/CMake/resolve_dependency_modules/icu/FindICU.cmake
index 15413ecc415d..bfcd265b2dc7 100644
--- a/CMake/resolve_dependency_modules/icu/FindICU.cmake
+++ b/CMake/resolve_dependency_modules/icu/FindICU.cmake
@@ -13,12 +13,14 @@
 # limitations under the License.
 message("Using ICU - Bundled")
 set(ICU_FOUND TRUE)
-set(icu_components
-    data
-    i18n
-    io
-    uc
-    tu)
+set(
+  icu_components
+  data
+  i18n
+  io
+  uc
+  tu
+)
 foreach(component icu_components)
   set(ICU_${component}_FOUND TRUE)
 endforeach()
diff --git a/CMake/resolve_dependency_modules/log_surgeon.cmake b/CMake/resolve_dependency_modules/log_surgeon.cmake
index f6d206666a70..2f549adeff22 100644
--- a/CMake/resolve_dependency_modules/log_surgeon.cmake
+++ b/CMake/resolve_dependency_modules/log_surgeon.cmake
@@ -16,8 +16,9 @@ include_guard(GLOBAL)
 FetchContent_Declare(
   log_surgeon
   GIT_REPOSITORY https://github.com/y-scope/log-surgeon.git
-  GIT_TAG 85d4f2c09c0e55f1fb87cdc8b0f4d13fb1a733e1
-  OVERRIDE_FIND_PACKAGE)
+  GIT_TAG 193e1f91eb137bb935a7f44b13cc8dd945a8d742
+  OVERRIDE_FIND_PACKAGE
+)
 
 set(log_surgeon_BUILD_TESTING OFF)
 FetchContent_MakeAvailable(log_surgeon)
diff --git a/CMake/resolve_dependency_modules/microsoft_gsl.cmake b/CMake/resolve_dependency_modules/microsoft_gsl.cmake
index 5fc1731231e3..808b4ad2d456 100644
--- a/CMake/resolve_dependency_modules/microsoft_gsl.cmake
+++ b/CMake/resolve_dependency_modules/microsoft_gsl.cmake
@@ -15,10 +15,13 @@ include_guard(GLOBAL)
 
 # Version you want to build
 set(VELOX_GSL_BUILD_VERSION 4.0.0)
-set(VELOX_GSL_BUILD_SHA256_CHECKSUM
-    f0e32cb10654fea91ad56bde89170d78cfbf4363ee0b01d8f097de2ba49f6ce9)
-set(VELOX_GSL_SOURCE_URL
-    "https://github.com/microsoft/GSL/archive/refs/tags/v${VELOX_GSL_BUILD_VERSION}.tar.gz"
+set(
+  VELOX_GSL_BUILD_SHA256_CHECKSUM
+  f0e32cb10654fea91ad56bde89170d78cfbf4363ee0b01d8f097de2ba49f6ce9
+)
+set(
+  VELOX_GSL_SOURCE_URL
+  "https://github.com/microsoft/GSL/archive/refs/tags/v${VELOX_GSL_BUILD_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(GSL)
@@ -29,6 +32,9 @@ FetchContent_Declare(
   Microsoft.GSL
   URL ${VELOX_GSL_SOURCE_URL}
   URL_HASH ${VELOX_GSL_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+  SYSTEM
+)
 
 FetchContent_MakeAvailable(Microsoft.GSL)
diff --git a/CMake/resolve_dependency_modules/msgpack-cxx.cmake b/CMake/resolve_dependency_modules/msgpack-cxx.cmake
index 9f20800b74e3..3e1215d761db 100644
--- a/CMake/resolve_dependency_modules/msgpack-cxx.cmake
+++ b/CMake/resolve_dependency_modules/msgpack-cxx.cmake
@@ -14,10 +14,13 @@
 include_guard(GLOBAL)
 
 set(VELOX_MSGPACK_BUILD_VERSION cpp-7.0.0)
-set(VELOX_MSGPACK_BUILD_SHA256_CHECKSUM
-    070881ebea9208cf7e731fd5a46a11404025b2f260ab9527e32dfcb7c689fbfc)
-set(VELOX_MSGPACK_SOURCE_URL
-    "https://github.com/msgpack/msgpack-c/archive/refs/tags/${VELOX_MSGPACK_BUILD_VERSION}.tar.gz"
+set(
+  VELOX_MSGPACK_BUILD_SHA256_CHECKSUM
+  070881ebea9208cf7e731fd5a46a11404025b2f260ab9527e32dfcb7c689fbfc
+)
+set(
+  VELOX_MSGPACK_SOURCE_URL
+  "https://github.com/msgpack/msgpack-c/archive/refs/tags/${VELOX_MSGPACK_BUILD_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(MSGPACK)
@@ -28,7 +31,10 @@ FetchContent_Declare(
   msgpack-cxx
   URL ${VELOX_MSGPACK_SOURCE_URL}
   URL_HASH ${VELOX_MSGPACK_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+  SYSTEM
+)
 
 set(MSGPACK_USE_BOOST OFF)
 
diff --git a/CMake/resolve_dependency_modules/nlohmann_json.cmake b/CMake/resolve_dependency_modules/nlohmann_json.cmake
index 1b0298f6618e..0405de452a6e 100644
--- a/CMake/resolve_dependency_modules/nlohmann_json.cmake
+++ b/CMake/resolve_dependency_modules/nlohmann_json.cmake
@@ -14,10 +14,13 @@
 include_guard(GLOBAL)
 
 set(VELOX_NLOHMANN_JSON_BUILD_VERSION 3.11.3)
-set(VELOX_NLOHMANN_JSON_BUILD_SHA256_CHECKSUM
-    0d8ef5af7f9794e3263480193c491549b2ba6cc74bb018906202ada498a79406)
-set(VELOX_NLOHMANN_JSON_SOURCE_URL
-    "https://github.com/nlohmann/json/archive/refs/tags/v${VELOX_NLOHMANN_JSON_BUILD_VERSION}.tar.gz"
+set(
+  VELOX_NLOHMANN_JSON_BUILD_SHA256_CHECKSUM
+  0d8ef5af7f9794e3263480193c491549b2ba6cc74bb018906202ada498a79406
+)
+set(
+  VELOX_NLOHMANN_JSON_SOURCE_URL
+  "https://github.com/nlohmann/json/archive/refs/tags/v${VELOX_NLOHMANN_JSON_BUILD_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(NLOHMANN_JSON)
@@ -28,10 +31,9 @@ FetchContent_Declare(
   nlohmann_json
   URL ${VELOX_NLOHMANN_JSON_SOURCE_URL}
   URL_HASH ${VELOX_NLOHMANN_JSON_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE)
+  OVERRIDE_FIND_PACKAGE
+)
 
-set(JSON_BuildTests
-    OFF
-    CACHE INTERNAL "")
+set(JSON_BuildTests OFF CACHE INTERNAL "")
 
 FetchContent_MakeAvailable(nlohmann_json)
diff --git a/CMake/resolve_dependency_modules/protobuf.cmake b/CMake/resolve_dependency_modules/protobuf.cmake
index 3193eedac934..a7d54da6554b 100644
--- a/CMake/resolve_dependency_modules/protobuf.cmake
+++ b/CMake/resolve_dependency_modules/protobuf.cmake
@@ -14,22 +14,26 @@
 include_guard(GLOBAL)
 
 set(VELOX_PROTOBUF_BUILD_VERSION 21.8)
-set(VELOX_PROTOBUF_BUILD_SHA256_CHECKSUM
-    83ad4faf95ff9cbece7cb9c56eb3ca9e42c3497b77001840ab616982c6269fb6)
+set(
+  VELOX_PROTOBUF_BUILD_SHA256_CHECKSUM
+  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"
+    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()
   velox_set_source(absl)
   velox_resolve_dependency(absl CONFIG REQUIRED)
   string(
-    CONCAT VELOX_PROTOBUF_SOURCE_URL
-           "https://github.com/protocolbuffers/protobuf/archive/"
-           "v${VELOX_PROTOBUF_BUILD_VERSION}.tar.gz")
+    CONCAT
+    VELOX_PROTOBUF_SOURCE_URL
+    "https://github.com/protocolbuffers/protobuf/archive/"
+    "v${VELOX_PROTOBUF_BUILD_VERSION}.tar.gz"
+  )
 endif()
 
 velox_resolve_dependency_url(PROTOBUF)
@@ -40,7 +44,10 @@ FetchContent_Declare(
   protobuf
   URL ${VELOX_PROTOBUF_SOURCE_URL}
   URL_HASH ${VELOX_PROTOBUF_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+  SYSTEM
+)
 
 set(protobuf_BUILD_TESTS OFF)
 set(protobuf_ABSL_PROVIDER "package")
diff --git a/CMake/resolve_dependency_modules/pybind11.cmake b/CMake/resolve_dependency_modules/pybind11.cmake
index d9577c9d9ee3..16c1b10ea9cc 100644
--- a/CMake/resolve_dependency_modules/pybind11.cmake
+++ b/CMake/resolve_dependency_modules/pybind11.cmake
@@ -14,12 +14,16 @@
 include_guard(GLOBAL)
 
 set(VELOX_PYBIND11_BUILD_VERSION 2.10.0)
-set(VELOX_PYBIND11_BUILD_SHA256_CHECKSUM
-    eacf582fa8f696227988d08cfc46121770823839fe9e301a20fbce67e7cd70ec)
+set(
+  VELOX_PYBIND11_BUILD_SHA256_CHECKSUM
+  eacf582fa8f696227988d08cfc46121770823839fe9e301a20fbce67e7cd70ec
+)
 string(
-  CONCAT VELOX_PYBIND11_SOURCE_URL
-         "https://github.com/pybind/pybind11/archive/refs/tags/"
-         "v${VELOX_PYBIND11_BUILD_VERSION}.tar.gz")
+  CONCAT
+  VELOX_PYBIND11_SOURCE_URL
+  "https://github.com/pybind/pybind11/archive/refs/tags/"
+  "v${VELOX_PYBIND11_BUILD_VERSION}.tar.gz"
+)
 
 velox_resolve_dependency_url(PYBIND11)
 
@@ -28,6 +32,7 @@ message(STATUS "Building Pybind11 from source")
 FetchContent_Declare(
   pybind11
   URL ${VELOX_PYBIND11_SOURCE_URL}
-  URL_HASH ${VELOX_PYBIND11_BUILD_SHA256_CHECKSUM})
+  URL_HASH ${VELOX_PYBIND11_BUILD_SHA256_CHECKSUM}
+)
 
 FetchContent_MakeAvailable(pybind11)
diff --git a/CMake/resolve_dependency_modules/re2.cmake b/CMake/resolve_dependency_modules/re2.cmake
index 2caaf20d3162..738e0564b7cb 100644
--- a/CMake/resolve_dependency_modules/re2.cmake
+++ b/CMake/resolve_dependency_modules/re2.cmake
@@ -17,18 +17,22 @@ if(DEFINED ENV{VELOX_RE2_URL})
   set(VELOX_RE2_SOURCE_URL "$ENV{VELOX_RE2_URL}")
 else()
   set(VELOX_RE2_VERSION 2024-07-02)
-  set(VELOX_RE2_SOURCE_URL
-      "https://github.com/google/re2/archive/refs/tags/${VELOX_RE2_VERSION}.tar.gz"
+  set(
+    VELOX_RE2_SOURCE_URL
+    "https://github.com/google/re2/archive/refs/tags/${VELOX_RE2_VERSION}.tar.gz"
+  )
+  set(
+    VELOX_RE2_BUILD_SHA256_CHECKSUM
+    eb2df807c781601c14a260a507a5bb4509be1ee626024cb45acbd57cb9d4032b
   )
-  set(VELOX_RE2_BUILD_SHA256_CHECKSUM
-      eb2df807c781601c14a260a507a5bb4509be1ee626024cb45acbd57cb9d4032b)
 endif()
 
 message(STATUS "Building re2 from source")
 FetchContent_Declare(
   re2
   URL ${VELOX_RE2_SOURCE_URL}
-  URL_HASH SHA256=${VELOX_RE2_BUILD_SHA256_CHECKSUM})
+  URL_HASH SHA256=${VELOX_RE2_BUILD_SHA256_CHECKSUM}
+)
 
 set(RE2_USE_ICU ON)
 set(RE2_BUILD_TESTING OFF)
@@ -40,9 +44,7 @@ velox_resolve_dependency(absl)
 FetchContent_MakeAvailable(re2)
 if("${absl_SOURCE}" STREQUAL "SYSTEM")
   if(DEFINED absl_VERSION AND "${absl_VERSION}" VERSION_LESS "20240116")
-    message(
-      FATAL_ERROR
-        "Abseil 20240116 or later is required for bundled RE2: ${absl_VERSION}")
+    message(FATAL_ERROR "Abseil 20240116 or later is required for bundled RE2: ${absl_VERSION}")
   endif()
 elseif("${absl_SOURCE}" STREQUAL "BUNDLED")
   # Build RE2 after Abseil so the files are available
@@ -58,3 +60,5 @@ set(re2_INCLUDE_DIRS ${re2_SOURCE_DIR})
 
 set(RE2_ROOT ${re2_BINARY_DIR})
 set(re2_ROOT ${re2_BINARY_DIR})
+
+unset(BUILD_TESTING CACHE)
diff --git a/CMake/resolve_dependency_modules/simdjson.cmake b/CMake/resolve_dependency_modules/simdjson.cmake
index 5d28789747ee..59894896c8bf 100644
--- a/CMake/resolve_dependency_modules/simdjson.cmake
+++ b/CMake/resolve_dependency_modules/simdjson.cmake
@@ -13,11 +13,14 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_SIMDJSON_VERSION 3.9.3)
-set(VELOX_SIMDJSON_BUILD_SHA256_CHECKSUM
-    2e3d10abcde543d3dd8eba9297522cafdcebdd1db4f51b28f3bc95bf1d6ad23c)
-set(VELOX_SIMDJSON_SOURCE_URL
-    "https://github.com/simdjson/simdjson/archive/refs/tags/v${VELOX_SIMDJSON_VERSION}.tar.gz"
+set(VELOX_SIMDJSON_VERSION 4.1.0)
+set(
+  VELOX_SIMDJSON_BUILD_SHA256_CHECKSUM
+  78115e37b2e88ec63e6ae20bb148063a9112c55bcd71404c8572078fd8a6ac3e
+)
+set(
+  VELOX_SIMDJSON_SOURCE_URL
+  "https://github.com/simdjson/simdjson/archive/refs/tags/v${VELOX_SIMDJSON_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(SIMDJSON)
@@ -28,7 +31,7 @@ FetchContent_Declare(
   simdjson
   URL ${VELOX_SIMDJSON_SOURCE_URL}
   URL_HASH ${VELOX_SIMDJSON_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE)
+)
 
 if(${VELOX_SIMDJSON_SKIPUTF8VALIDATION})
   set(SIMDJSON_SKIPUTF8VALIDATION ON)
diff --git a/CMake/resolve_dependency_modules/spdlog.cmake b/CMake/resolve_dependency_modules/spdlog.cmake
index a7a1ddfe6988..68c54dc41a0e 100644
--- a/CMake/resolve_dependency_modules/spdlog.cmake
+++ b/CMake/resolve_dependency_modules/spdlog.cmake
@@ -13,11 +13,14 @@
 # limitations under the License.
 include_guard(GLOBAL)
 
-set(VELOX_SPDLOG_BUILD_VERSION 1.12.0)
-set(VELOX_SPDLOG_BUILD_SHA256_CHECKSUM
-    4dccf2d10f410c1e2feaff89966bfc49a1abb29ef6f08246335b110e001e09a9)
-set(VELOX_SPDLOG_SOURCE_URL
-    "https://github.com/gabime/spdlog/archive/refs/tags/v${VELOX_SPDLOG_BUILD_VERSION}.tar.gz"
+set(VELOX_SPDLOG_BUILD_VERSION 1.15.3)
+set(
+  VELOX_SPDLOG_BUILD_SHA256_CHECKSUM
+  15a04e69c222eb6c01094b5c7ff8a249b36bb22788d72519646fb85feb267e67
+)
+set(
+  VELOX_SPDLOG_SOURCE_URL
+  "https://github.com/gabime/spdlog/archive/refs/tags/v${VELOX_SPDLOG_BUILD_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(SPDLOG)
@@ -28,7 +31,10 @@ FetchContent_Declare(
   spdlog
   URL ${VELOX_SPDLOG_SOURCE_URL}
   URL_HASH ${VELOX_SPDLOG_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+  SYSTEM
+)
 
 set(SPDLOG_FMT_EXTERNAL ON)
 FetchContent_MakeAvailable(spdlog)
diff --git a/CMake/resolve_dependency_modules/stemmer.cmake b/CMake/resolve_dependency_modules/stemmer.cmake
index a3ab123f1659..17686ea2832a 100644
--- a/CMake/resolve_dependency_modules/stemmer.cmake
+++ b/CMake/resolve_dependency_modules/stemmer.cmake
@@ -14,10 +14,13 @@
 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"
+set(
+  VELOX_STEMMER_BUILD_SHA256_CHECKSUM
+  b941d9fe9cf36b4e2f8d3873cd4d8b8775bd94867a1df8d8c001bb8b688377c3
+)
+set(
+  VELOX_STEMMER_SOURCE_URL
+  "https://snowballstem.org/dist/libstemmer_c-${VELOX_STEMMER_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(STEMMER)
@@ -51,7 +54,8 @@ 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})
+      ${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/CMake/resolve_dependency_modules/template.cmake b/CMake/resolve_dependency_modules/template.cmake
index 1db752bac7f0..5455efb8781b 100644
--- a/CMake/resolve_dependency_modules/template.cmake
+++ b/CMake/resolve_dependency_modules/template.cmake
@@ -16,8 +16,8 @@ include_guard(GLOBAL)
 set(VELOX_<PACKAGE>_VERSION x.y.z)
 # release artifacts are tough (except the auto generated ones)
 set(VELOX_<PACKAGE>_BUILD_SHA256_CHECKSUM 123)
-set(VELOX_<PACKAGE>_SOURCE_URL "") # ideally don't use github archive links as
-                                   # they are not guranteed to be hash stable
+# ideally don't use github archive links as they are not guaranteed to be hash stable
+set(VELOX_<PACKAGE>_SOURCE_URL "")
 
 velox_resolve_dependency_url(<PACKAGE>)
 
@@ -25,6 +25,7 @@ message(STATUS "Building <PACKAGE> from source")
 FetchContent_Declare(
   <package>
   URL ${VELOX_<PACKAGE>_SOURCE_URL}
-  URL_HASH ${VELOX_<PACKAGE>_BUILD_SHA256_CHECKSUM})
+  URL_HASH ${VELOX_<PACKAGE>_BUILD_SHA256_CHECKSUM}
+)
 
 FetchContent_MakeAvailable(<package>)
diff --git a/CMake/resolve_dependency_modules/xsimd.cmake b/CMake/resolve_dependency_modules/xsimd.cmake
index 56f1bc2aef97..7cbd4258ab25 100644
--- a/CMake/resolve_dependency_modules/xsimd.cmake
+++ b/CMake/resolve_dependency_modules/xsimd.cmake
@@ -14,10 +14,13 @@
 include_guard(GLOBAL)
 
 set(VELOX_XSIMD_VERSION 10.0.0)
-set(VELOX_XSIMD_BUILD_SHA256_CHECKSUM
-    73f818368b3a4dad92fab1b2933d93694241bd2365a6181747b2df1768f6afdd)
-set(VELOX_XSIMD_SOURCE_URL
-    "https://github.com/xtensor-stack/xsimd/archive/refs/tags/${VELOX_XSIMD_VERSION}.tar.gz"
+set(
+  VELOX_XSIMD_BUILD_SHA256_CHECKSUM
+  73f818368b3a4dad92fab1b2933d93694241bd2365a6181747b2df1768f6afdd
+)
+set(
+  VELOX_XSIMD_SOURCE_URL
+  "https://github.com/xtensor-stack/xsimd/archive/refs/tags/${VELOX_XSIMD_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(XSIMD)
@@ -26,6 +29,7 @@ message(STATUS "Building xsimd from source")
 FetchContent_Declare(
   xsimd
   URL ${VELOX_XSIMD_SOURCE_URL}
-  URL_HASH ${VELOX_XSIMD_BUILD_SHA256_CHECKSUM})
+  URL_HASH ${VELOX_XSIMD_BUILD_SHA256_CHECKSUM}
+)
 
 FetchContent_MakeAvailable(xsimd)
diff --git a/CMake/resolve_dependency_modules/ystdlib.cmake b/CMake/resolve_dependency_modules/ystdlib.cmake
index eca92f1d59e7..a6cb7b29d3f0 100644
--- a/CMake/resolve_dependency_modules/ystdlib.cmake
+++ b/CMake/resolve_dependency_modules/ystdlib.cmake
@@ -14,10 +14,13 @@
 include_guard(GLOBAL)
 
 set(VELOX_YSTDLIB_BUILD_VERSION 9ed78cd)
-set(VELOX_YSTDLIB_BUILD_SHA256_CHECKSUM
-    65990dc2bcc4a355c2181bfe31a7800f492309d1bcd340f52a34e85047e61bc8)
-set(VELOX_YSTDLIB_SOURCE_URL
-    "https://github.com/y-scope/ystdlib-cpp/archive/${VELOX_YSTDLIB_BUILD_VERSION}.tar.gz"
+set(
+  VELOX_YSTDLIB_BUILD_SHA256_CHECKSUM
+  65990dc2bcc4a355c2181bfe31a7800f492309d1bcd340f52a34e85047e61bc8
+)
+set(
+  VELOX_YSTDLIB_SOURCE_URL
+  "https://github.com/y-scope/ystdlib-cpp/archive/${VELOX_YSTDLIB_BUILD_VERSION}.tar.gz"
 )
 
 velox_resolve_dependency_url(YSTDLIB)
@@ -28,7 +31,10 @@ FetchContent_Declare(
   ystdlib
   URL ${VELOX_YSTDLIB_SOURCE_URL}
   URL_HASH ${VELOX_YSTDLIB_BUILD_SHA256_CHECKSUM}
-  OVERRIDE_FIND_PACKAGE EXCLUDE_FROM_ALL SYSTEM)
+  OVERRIDE_FIND_PACKAGE
+  EXCLUDE_FROM_ALL
+  SYSTEM
+)
 
 set(ystdlib_BUILD_TESTING OFF)
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8dbe5950d1b0..b2f0e2fc0101 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,7 +13,7 @@
 # limitations under the License.
 cmake_minimum_required(VERSION 3.28)
 message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 set(CMAKE_CXX_EXTENSIONS ON) # Big Int is an extension
 message(STATUS "CXX standard: ${CMAKE_CXX_STANDARD}")
@@ -36,15 +36,16 @@ 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")
+  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")
+  elseif(
+    DEFINED ENV{VELOX_DEPENDENCY_SOURCE}
+    AND NOT "$ENV{VELOX_DEPENDENCY_SOURCE}" STREQUAL "CONDA"
+  )
     message(STATUS "Overriding Conda environment: $ENV{CONDA_PREFIX}")
   endif()
 endif()
@@ -54,37 +55,43 @@ if(DEFINED ENV{INSTALL_PREFIX})
   list(APPEND CMAKE_PREFIX_PATH "$ENV{INSTALL_PREFIX}")
 endif()
 
-list(PREPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMake"
-     "${PROJECT_SOURCE_DIR}/CMake/third-party")
+list(
+  PREPEND
+  CMAKE_MODULE_PATH
+  "${PROJECT_SOURCE_DIR}/CMake"
+  "${PROJECT_SOURCE_DIR}/CMake/third-party"
+)
 
 # Include our ThirdPartyToolchain dependencies macros
 include(ResolveDependency)
 include(VeloxUtils)
 include(CMakeDependentOption)
 
-velox_set_with_default(VELOX_DEPENDENCY_SOURCE_DEFAULT VELOX_DEPENDENCY_SOURCE
-                       AUTO)
+velox_set_with_default(VELOX_DEPENDENCY_SOURCE_DEFAULT VELOX_DEPENDENCY_SOURCE AUTO)
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 
 # Add all options below
 option(
   VELOX_BUILD_TESTING
   "Enable Velox tests. This will enable all other build options automatically."
-  ON)
+  ON
+)
 option(
   VELOX_BUILD_MINIMAL
   "Build a minimal set of components only. This will override other build options."
-  OFF)
+  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)
+  OFF
+)
 option(VELOX_MONO_LIBRARY "Build single unified library." OFF)
 option(ENABLE_ALL_WARNINGS "Enable -Wall and -Wextra compiler warnings." ON)
 option(VELOX_BUILD_SHARED "Build Velox as shared libraries." OFF)
-option(VELOX_SKIP_WAVE_BRANCH_KERNEL_TEST "Disable Wave branch kernel test."
-       OFF)
+option(VELOX_BUILD_CMAKE_PACKAGE "Build CMake package for Velox." OFF)
+option(VELOX_SKIP_WAVE_BRANCH_KERNEL_TEST "Disable Wave branch kernel test." OFF)
 # While it's possible to build both in one go we currently want to build either
 # static or shared.
 cmake_dependent_option(
@@ -92,7 +99,8 @@ cmake_dependent_option(
   "Build Velox as static libraries."
   ON
   "NOT VELOX_BUILD_SHARED"
-  OFF)
+  OFF
+)
 
 if(VELOX_BUILD_SHARED AND NOT VELOX_MONO_LIBRARY)
   # The large number of targets currently in use within Velox make a shared
@@ -103,8 +111,9 @@ endif()
 if(VELOX_BUILD_SHARED)
   message(
     WARNING
-      "When building Velox as a shared library it's recommended to build against a shared build of folly to avoid issues with linking of gflags."
-      "This is currently NOT being enforced so user discretion is advised.")
+    "When building Velox as a shared library it's recommended to build against a shared build of folly to avoid issues with linking of gflags. "
+    "This is currently NOT being enforced so user discretion is advised."
+  )
 endif()
 
 # option() always creates a BOOL variable so we have to use a normal cache
@@ -113,30 +122,33 @@ endif()
 # * AUTO: Try SYSTEM first fall back to BUNDLED.
 # * SYSTEM: Use installed dependencies via find_package.
 # * BUNDLED: Build dependencies from source.
-set(VELOX_DEPENDENCY_SOURCE
-    ${VELOX_DEPENDENCY_SOURCE_DEFAULT}
-    CACHE
-      STRING
-      "Default source for all dependencies with source builds enabled: AUTO SYSTEM BUNDLED."
+set(
+  VELOX_DEPENDENCY_SOURCE
+  ${VELOX_DEPENDENCY_SOURCE_DEFAULT}
+  CACHE STRING
+  "Default source for all dependencies with source builds enabled: AUTO SYSTEM BUNDLED."
 )
-set(VELOX_GFLAGS_TYPE
-    "shared"
-    CACHE
-      STRING
-      "Specify whether to find the gflags package as a shared or static package"
+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_CLP_CONNECTOR "Build CLP connector." ON)
 option(VELOX_ENABLE_HIVE_CONNECTOR "Build Hive connector." ON)
 option(VELOX_ENABLE_TPCH_CONNECTOR "Build TPC-H connector." ON)
+option(VELOX_ENABLE_TPCDS_CONNECTOR "Build TPC-DS 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_ICEBERG_FUNCTIONS "Build Iceberg functions." ON)
 option(VELOX_ENABLE_EXPRESSION "Build expression." ON)
 option(
   VELOX_ENABLE_EXAMPLES
-  "Build examples. This will enable VELOX_ENABLE_EXPRESSION automatically." OFF)
-option(VELOX_ENABLE_SUBSTRAIT "Build Substrait-to-Velox converter." OFF)
+  "Build examples. This will enable VELOX_ENABLE_EXPRESSION automatically."
+  OFF
+)
 option(VELOX_ENABLE_BENCHMARKS "Enable Velox top level benchmarks." OFF)
 option(VELOX_ENABLE_BENCHMARKS_BASIC "Enable Velox basic benchmarks." OFF)
 option(VELOX_ENABLE_S3 "Build S3 Connector" OFF)
@@ -158,15 +170,15 @@ option(VELOX_BUILD_RUNNER "Builds velox runner" ON)
 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)
-option(VELOX_SIMDJSON_SKIPUTF8VALIDATION
-       "Skip simdjson utf8 validation in JSON parsing" OFF)
+  OFF
+)
+option(VELOX_SIMDJSON_SKIPUTF8VALIDATION "Skip simdjson utf8 validation in JSON parsing" OFF)
+option(VELOX_ENABLE_FAISS "Build faiss vector search support" OFF)
 
 # 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)
+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
@@ -178,12 +190,20 @@ if(${VELOX_BUILD_MINIMAL} OR ${VELOX_BUILD_MINIMAL_WITH_DWIO})
   set(VELOX_ENABLE_CLP_CONNECTOR OFF)
   set(VELOX_ENABLE_HIVE_CONNECTOR OFF)
   set(VELOX_ENABLE_TPCH_CONNECTOR OFF)
+  set(VELOX_ENABLE_TPCDS_CONNECTOR OFF)
   set(VELOX_ENABLE_SPARK_FUNCTIONS OFF)
   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)
+else()
+  if(VELOX_BUILD_CMAKE_PACKAGE)
+    message(
+      FATAL_ERROR
+      "VELOX_BUILD_CMAKE_PACKAGE is only available with "
+      "VELOX_BUILD_MINIMAL=ON or VELOX_BUILD_MINIMAL_WITH_DWIO=ON for now."
+    )
+  endif()
 endif()
 
 if(${VELOX_ENABLE_BENCHMARKS})
@@ -194,16 +214,24 @@ if(VELOX_ENABLE_BENCHMARKS_BASIC)
   set(VELOX_BUILD_TEST_UTILS ON)
 endif()
 
+if(VELOX_ENABLE_CUDF)
+  message(STATUS "Building curl from source to satisfy cuDF curl version requirement")
+  set(CURL_SOURCE BUNDLED)
+  velox_resolve_dependency(CURL)
+endif()
+
 if(VELOX_BUILD_TESTING OR VELOX_BUILD_TEST_UTILS)
-  set(cpr_SOURCE BUNDLED)
-  velox_resolve_dependency(cpr)
+  # cuDF bundles curl since it needs a specific version.
+  # Use bundled or system curl otherwise.
+  if(NOT VELOX_ENABLE_CUDF)
+    velox_set_source(CURL)
+    velox_resolve_dependency(CURL)
+  endif()
   set(VELOX_ENABLE_DUCKDB ON)
   set(VELOX_ENABLE_PARSE ON)
 endif()
 
-if(${VELOX_BUILD_TESTING}
-   OR ${VELOX_BUILD_MINIMAL_WITH_DWIO}
-   OR ${VELOX_ENABLE_HIVE_CONNECTOR})
+if(${VELOX_BUILD_TESTING} OR ${VELOX_BUILD_MINIMAL_WITH_DWIO} OR ${VELOX_ENABLE_HIVE_CONNECTOR})
   set(VELOX_ENABLE_COMPRESSION_LZ4 ON)
 endif()
 
@@ -231,6 +259,14 @@ if(${VELOX_ENABLE_DUCKDB})
   velox_resolve_dependency(DuckDB)
 endif()
 
+if(VELOX_ENABLE_FAISS)
+  velox_set_source(faiss)
+  velox_resolve_dependency(faiss)
+  if(NOT TARGET FAISS::faiss)
+    add_library(FAISS::faiss ALIAS faiss)
+  endif()
+endif()
+
 if(DEFINED ENV{INSTALL_PREFIX})
   # Allow installed package headers to be picked up before brew/system package
   # headers. We set this after DuckDB bundling since DuckDB uses its own
@@ -242,11 +278,12 @@ endif()
 # dependencies.
 find_package(OpenSSL REQUIRED)
 
-if(VELOX_ENABLE_CCACHE
-   AND NOT CMAKE_C_COMPILER_LAUNCHER
-   AND NOT CMAKE_CXX_COMPILER_LAUNCHER
-   AND NOT CMAKE_CUDA_COMPILER_LAUNCHER)
-
+if(
+  VELOX_ENABLE_CCACHE
+  AND NOT CMAKE_C_COMPILER_LAUNCHER
+  AND NOT CMAKE_CXX_COMPILER_LAUNCHER
+  AND NOT CMAKE_CUDA_COMPILER_LAUNCHER
+)
   find_program(CCACHE_FOUND ccache)
 
   if(CCACHE_FOUND)
@@ -262,8 +299,10 @@ 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")
+  elseif(
+    "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+    OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang"
+  )
     add_compile_options(-fcolor-diagnostics)
   endif()
 endif()
@@ -273,7 +312,7 @@ if(VELOX_ENABLE_S3)
   if(AWSSDK_ROOT_DIR)
     list(APPEND CMAKE_PREFIX_PATH ${AWSSDK_ROOT_DIR})
   endif()
-  find_package(AWSSDK REQUIRED COMPONENTS s3;identity-management)
+  find_package(AWSSDK 1.11.654 REQUIRED COMPONENTS s3;identity-management)
   add_definitions(-DVELOX_ENABLE_S3)
 endif()
 
@@ -323,12 +362,38 @@ endif()
 # Required so velox code can be used in a dynamic library
 set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
 
+# For C++20 support we need GNU GCC11 (or later versions) or Clang/AppleClang 15
+# (or later versions) to get support for the used features.
+if(
+  NOT
+    (
+      (
+        "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU"
+        AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER_EQUAL 11
+      )
+      OR
+        (
+          (
+            "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+            OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang"
+          )
+          AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 15
+        )
+    )
+)
+  message(
+    FATAL_ERROR
+    "Unsupported compiler ${CMAKE_CXX_COMPILER_ID} with version ${CMAKE_CXX_COMPILER_VERSION} found."
+  )
+endif()
+
 execute_process(
   COMMAND
     bash -c
     "( source ${CMAKE_CURRENT_SOURCE_DIR}/scripts/setup-helper-functions.sh && echo -n $(get_cxx_flags $ENV{CPU_TARGET}))"
   OUTPUT_VARIABLE SCRIPT_CXX_FLAGS
-  RESULT_VARIABLE COMMAND_STATUS)
+  RESULT_VARIABLE COMMAND_STATUS
+)
 
 if(COMMAND_STATUS EQUAL "1")
   message(FATAL_ERROR "Unable to determine compiler flags!")
@@ -353,28 +418,28 @@ string(APPEND CMAKE_CXX_FLAGS " -DFOLLY_CFG_NO_COROUTINES")
 # Under Ninja, we are able to designate certain targets large enough to require
 # restricted parallelism.
 if("${MAX_HIGH_MEM_JOBS}")
-  set_property(GLOBAL PROPERTY JOB_POOLS
-                               "high_memory_pool=${MAX_HIGH_MEM_JOBS}")
+  set_property(GLOBAL PROPERTY JOB_POOLS "high_memory_pool=${MAX_HIGH_MEM_JOBS}")
 else()
   set_property(GLOBAL PROPERTY JOB_POOLS high_memory_pool=1000)
 endif()
 
 if("${MAX_LINK_JOBS}")
-  set_property(GLOBAL APPEND PROPERTY JOB_POOLS
-                                      "link_job_pool=${MAX_LINK_JOBS}")
+  set_property(GLOBAL APPEND PROPERTY JOB_POOLS "link_job_pool=${MAX_LINK_JOBS}")
   set(CMAKE_JOB_POOL_LINK link_job_pool)
 endif()
 
 if(ENABLE_ALL_WARNINGS)
   if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-    set(KNOWN_COMPILER_SPECIFIC_WARNINGS
-        "-Wno-implicit-const-int-float-conversion \
-         -Wno-range-loop-analysis \
+    set(
+      KNOWN_COMPILER_SPECIFIC_WARNINGS
+      "-Wno-range-loop-analysis \
          -Wno-mismatched-tags \
-         -Wno-nullability-completeness")
+         -Wno-nullability-completeness"
+    )
   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    set(KNOWN_COMPILER_SPECIFIC_WARNINGS
-        "-Wno-implicit-fallthrough \
+    set(
+      KNOWN_COMPILER_SPECIFIC_WARNINGS
+      "-Wno-implicit-fallthrough \
          -Wno-class-memaccess \
          -Wno-comment \
          -Wno-int-in-bool-context \
@@ -383,15 +448,28 @@ if(ENABLE_ALL_WARNINGS)
          -Wno-maybe-uninitialized \
          -Wno-unused-result \
          -Wno-format-overflow \
-         -Wno-strict-aliasing")
+         -Wno-strict-aliasing"
+    )
+    # Avoid compiler bug for GCC 12.2.1
+    # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105329
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "12.2.1")
+      string(APPEND KNOWN_COMPILER_SPECIFIC_WARNINGS " -Wno-restrict")
+    endif()
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0.0")
+      string(APPEND KNOWN_COMPILER_SPECIFIC_WARNINGS " -Wno-error=template-id-cdtor")
+      string(APPEND KNOWN_COMPILER_SPECIFIC_WARNINGS " -Wno-overloaded-virtual")
+      string(APPEND KNOWN_COMPILER_SPECIFIC_WARNINGS " -Wno-error=tautological-compare")
+    endif()
   endif()
 
-  set(KNOWN_WARNINGS
-      "-Wno-unused \
+  set(
+    KNOWN_WARNINGS
+    "-Wno-unused \
        -Wno-unused-parameter \
        -Wno-sign-compare \
        -Wno-ignored-qualifiers \
-       ${KNOWN_COMPILER_SPECIFIC_WARNINGS}")
+       ${KNOWN_COMPILER_SPECIFIC_WARNINGS}"
+  )
 
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra ${KNOWN_WARNINGS}")
 endif()
@@ -413,20 +491,32 @@ if(VELOX_ENABLE_WAVE OR VELOX_ENABLE_CUDF)
       if(arch LESS 70)
         message(
           FATAL_ERROR
-            "CUDA architecture ${arch} is below 70. CUDF requires Volta (SM 70) or newer GPUs."
+          "CUDA architecture ${arch} is below 70. CUDF requires Volta (SM 70) or newer GPUs."
         )
       endif()
     endforeach()
     set(VELOX_ENABLE_ARROW ON)
     velox_set_source(cudf)
     velox_resolve_dependency(cudf)
+    if(TARGET aws-cpp-sdk-core)
+      # Fix for AWS SDK CPP using hardcoded system curl instead of soft link to curl
+      get_target_property(override_curl_lib aws-cpp-sdk-core INTERFACE_LINK_LIBRARIES)
+      list(REMOVE_ITEM override_curl_lib "/usr/lib64/libcurl.so")
+      list(APPEND override_curl_lib "\$<LINK_ONLY:CURL::libcurl>")
+      set_target_properties(
+        aws-cpp-sdk-core
+        PROPERTIES INTERFACE_LINK_LIBRARIES "${override_curl_lib}"
+      )
+    endif()
   endif()
 endif()
 
 # Set after the test of the CUDA compiler. Otherwise, the test fails with
 # -latomic not found because it is added right after the compiler exe.
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
-   AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_GREATER_EQUAL 15)
+if(
+  "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+  AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_GREATER_EQUAL 15
+)
   set(CMAKE_EXE_LINKER_FLAGS "-latomic")
 endif()
 
@@ -437,7 +527,8 @@ if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
     COMMAND brew --prefix icu4c
     RESULT_VARIABLE BREW_ICU4C
     OUTPUT_VARIABLE BREW_ICU4C_PREFIX
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
   if(BREW_ICU4C EQUAL 0 AND EXISTS "${BREW_ICU4C_PREFIX}")
     message(STATUS "Found icu4c installed by Homebrew at ${BREW_ICU4C_PREFIX}")
     list(APPEND CMAKE_PREFIX_PATH "${BREW_ICU4C_PREFIX}")
@@ -449,24 +540,22 @@ endif()
 velox_set_source(ICU)
 velox_resolve_dependency(
   ICU
-  COMPONENTS
-  data
-  i18n
-  io
-  uc
-  tu)
-
-set(BOOST_INCLUDE_LIBRARIES
-    atomic
-    context
-    date_time
-    filesystem
-    iostreams
-    program_options
-    regex
-    system
-    url
-    thread)
+  COMPONENTS data i18n io uc tu
+)
+
+set(
+  BOOST_INCLUDE_LIBRARIES
+  atomic
+  context
+  date_time
+  filesystem
+  iostreams
+  program_options
+  regex
+  system
+  url
+  thread
+)
 
 velox_set_source(Boost)
 velox_resolve_dependency(Boost 1.77.0 COMPONENTS ${BOOST_INCLUDE_LIBRARIES})
@@ -480,9 +569,7 @@ if(NOT TARGET gflags::gflags)
   # target even when velox is built as a subproject which uses
   # `find_package(gflags)` which does not create a globally imported target that
   # we can ALIAS.
-  add_library(gflags_gflags INTERFACE)
-  target_link_libraries(gflags_gflags INTERFACE gflags)
-  add_library(gflags::gflags ALIAS gflags_gflags)
+  add_library(gflags::gflags ALIAS gflags)
 endif()
 
 if(${gflags_SOURCE} STREQUAL "BUNDLED")
@@ -495,7 +582,7 @@ endif()
 velox_resolve_dependency(glog)
 
 velox_set_source(fmt)
-velox_resolve_dependency(fmt 9.0.0)
+velox_resolve_dependency(fmt 11.2.0)
 
 if(VELOX_ENABLE_COMPRESSION_LZ4)
   find_package(lz4 REQUIRED)
@@ -506,9 +593,19 @@ if(${VELOX_BUILD_MINIMAL_WITH_DWIO} OR ${VELOX_ENABLE_HIVE_CONNECTOR})
   #
   # TODO: make these optional and pluggable.
   find_package(ZLIB REQUIRED)
-  find_package(lzo2 REQUIRED)
   find_package(zstd REQUIRED)
   find_package(Snappy REQUIRED)
+  # Ensure zstd::zstd target exists - handle different zstd package configurations
+  if(NOT TARGET zstd::zstd)
+    if(TARGET zstd::libzstd_static)
+      add_library(zstd::zstd ALIAS zstd::libzstd_static)
+    elseif(TARGET zstd::libzstd_shared)
+      add_library(zstd::zstd ALIAS zstd::libzstd_shared)
+    else()
+      # Fallback: use Findzstd.cmake to create the target
+      include(Findzstd)
+    endif()
+  endif()
 endif()
 
 velox_set_source(re2)
@@ -540,32 +637,25 @@ if(${VELOX_ENABLE_CLP_CONNECTOR})
   velox_set_source(spdlog)
   velox_resolve_dependency(spdlog)
 
+  velox_set_source(ystdlib)
+  velox_resolve_dependency(ystdlib)
+
   # Dependencies that depend on other dependencies
   velox_set_source(log_surgeon)
   velox_resolve_dependency(log_surgeon)
 
-  velox_set_source(ystdlib)
-  velox_resolve_dependency(ystdlib)
-
   set(clp_SOURCE BUNDLED)
   velox_resolve_dependency(clp)
 endif()
 
 if(${VELOX_BUILD_PYTHON_PACKAGE})
-  find_package(
-    Python 3.9
-    COMPONENTS Interpreter Development.Module
-    REQUIRED)
+  find_package(Python 3.9 COMPONENTS Interpreter Development.Module REQUIRED)
   velox_set_source(pybind11)
   velox_resolve_dependency(pybind11 2.10.0)
 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)
-
+# DWIO (ORC/DWRF) depends on protobuf.
+if(${VELOX_BUILD_MINIMAL_WITH_DWIO} OR ${VELOX_ENABLE_HIVE_CONNECTOR} OR VELOX_ENABLE_GCS)
   # Locate or build protobuf.
   velox_set_source(Protobuf)
   velox_resolve_dependency(Protobuf 3.21.7 REQUIRED)
@@ -573,7 +663,10 @@ if(${VELOX_BUILD_MINIMAL_WITH_DWIO}
 endif()
 
 velox_set_source(simdjson)
-velox_resolve_dependency(simdjson 3.9.3)
+velox_resolve_dependency(simdjson 4.1.0)
+
+velox_set_source(FastFloat)
+velox_resolve_dependency(FastFloat)
 
 velox_set_source(folly)
 velox_resolve_dependency(folly)
@@ -608,13 +701,6 @@ endif()
 
 # GCC needs to link a library to enable std::filesystem.
 if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
-
-  # Ensure we have gcc at least 9+.
-  if(CMAKE_CXX_COMPILER_VERSION LESS 9.0)
-    message(
-      FATAL_ERROR "VELOX requires gcc > 9. Found ${CMAKE_CXX_COMPILER_VERSION}")
-  endif()
-
   # Find Threads library
   find_package(Threads REQUIRED)
 endif()
@@ -622,7 +708,7 @@ endif()
 if(VELOX_BUILD_TESTING AND NOT VELOX_ENABLE_DUCKDB)
   message(
     FATAL_ERROR
-      "Unit tests require duckDB to be enabled (VELOX_ENABLE_DUCKDB=ON or VELOX_BUILD_TESTING=OFF)"
+    "Unit tests require duckDB to be enabled (VELOX_ENABLE_DUCKDB=ON or VELOX_BUILD_TESTING=OFF)"
   )
 endif()
 
@@ -639,10 +725,10 @@ if(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
     COMMAND brew --prefix bison
     RESULT_VARIABLE BREW_BISON
     OUTPUT_VARIABLE BREW_BISON_PREFIX
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
   if(BREW_BISON EQUAL 0 AND EXISTS "${BREW_BISON_PREFIX}")
-    message(
-      STATUS "Found Bison keg installed by Homebrew at ${BREW_BISON_PREFIX}")
+    message(STATUS "Found Bison keg installed by Homebrew at ${BREW_BISON_PREFIX}")
     set(BISON_EXECUTABLE "${BREW_BISON_PREFIX}/bin/bison")
   endif()
 
@@ -650,10 +736,10 @@ if(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
     COMMAND brew --prefix flex
     RESULT_VARIABLE BREW_FLEX
     OUTPUT_VARIABLE BREW_FLEX_PREFIX
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
   if(BREW_FLEX EQUAL 0 AND EXISTS "${BREW_FLEX_PREFIX}")
-    message(
-      STATUS "Found Flex keg installed by Homebrew at ${BREW_FLEX_PREFIX}")
+    message(STATUS "Found Flex keg installed by Homebrew at ${BREW_FLEX_PREFIX}")
     set(FLEX_EXECUTABLE "${BREW_FLEX_PREFIX}/bin/flex")
     set(FLEX_INCLUDE_DIR "${BREW_FLEX_PREFIX}/include")
   endif()
@@ -668,9 +754,7 @@ include_directories(SYSTEM velox/external)
 if(NOT VELOX_DISABLE_GOOGLETEST)
   velox_set_source(GTest)
   velox_resolve_dependency(GTest)
-  set(VELOX_GTEST_INCUDE_DIR
-      "${gtest_SOURCE_DIR}/include"
-      PARENT_SCOPE)
+  set(VELOX_GTEST_INCUDE_DIR "${gtest_SOURCE_DIR}/include" PARENT_SCOPE)
 endif()
 
 velox_set_source(xsimd)
@@ -686,10 +770,6 @@ endif()
 
 include_directories(.)
 
-# TODO: Include all other installation files. For now just making sure this
-# generates an installable makefile.
-install(FILES velox/type/Type.h DESTINATION "include/velox")
-
 # Adding this down here prevents warnings in dependencies from stopping the
 # build
 if("${TREAT_WARNINGS_AS_ERRORS}")
diff --git a/CODING_STYLE.md b/CODING_STYLE.md
index 43947192cd74..97a60199941e 100644
--- a/CODING_STYLE.md
+++ b/CODING_STYLE.md
@@ -246,16 +246,17 @@ About comment style:
 * As a general rule, do not use string literals without declaring a named
   constant for them.
   * The best way to make a constant string literal is to use constexpr
-    `std::string_view`/`folly::StringPiece`
+    `std::string_view`
   * **NEVER** use `std::string` - this makes your code more prone to SIOF bugs.
   * Avoid `const char* const` and `const char*` - these are less efficient to
     convert to `std::string` later on in your program if you ever need to
-    because `std::string_view`/ `folly::StringPiece` knows its size and can use
-    a more efficient constructor. `std::string_view`/ `folly::StringPiece` also
-    has richer interfaces and often works as a drop-in replacement to
-    `std::string`.
+    because `std::string_view` knows its size and can use a more efficient
+    constructor. `std::string_view` also has richer interfaces and often
+    works as a drop-in replacement to `std::string`.
   * Need compile-time string concatenation? You can use `folly::FixedString`
     for that.
+  * Do not use `folly::StringPiece` in new code, use `std::string_view`
+    instead.
 
 ## Macros
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a76dd9e334cc..8db9559bddd3 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -137,6 +137,7 @@ where:
 * *Type* can be any of the following keywords:
   * **feat** when new features are being added.
   * **fix** for bug fixes.
+  * **perf** for performance improvements.
   * **build** for build or CI-related improvements.
   * **test** for adding tests (only).
   * **docs** for enhancements to documentation (only).
diff --git a/Makefile b/Makefile
index be290e806ea8..b9548ea66f0a 100644
--- a/Makefile
+++ b/Makefile
@@ -56,6 +56,8 @@ endif
 
 ifdef CUDA_ARCHITECTURES
 CMAKE_FLAGS += -DCMAKE_CUDA_ARCHITECTURES="$(CUDA_ARCHITECTURES)"
+else
+EXTRA_CMAKE_CUDA_FLAGS = -DCMAKE_CUDA_ARCHITECTURES="native"
 endif
 
 ifdef CUDA_COMPILER
@@ -101,10 +103,10 @@ cmake:					#: Use CMake to create a Makefile build system
 		${EXTRA_CMAKE_FLAGS}
 
 cmake-wave:
-	$(MAKE) EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_WAVE=ON" cmake
+	$(MAKE) EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_WAVE=ON ${EXTRA_CMAKE_CUDA_FLAGS}" cmake
 
 cmake-cudf:
-	$(MAKE) EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_CUDF=ON" cmake
+	$(MAKE) EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} -DVELOX_ENABLE_CUDF=ON ${EXTRA_CMAKE_CUDA_FLAGS}" cmake
 
 build:					#: Build the software based in BUILD_DIR and BUILD_TYPE variables
 	cmake --build $(BUILD_BASE_DIR)/$(BUILD_DIR) -j $(NUM_THREADS)
@@ -118,13 +120,17 @@ release:				#: Build the release version
 	$(MAKE) build BUILD_DIR=release
 
 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) 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) cmake BUILD_DIR=release BUILD_TYPE=release \
+		EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} \
+			-DVELOX_BUILD_MINIMAL=ON"
 	$(MAKE) build BUILD_DIR=release
 
 wave:			   	         #: Build with Wave GPU support
@@ -144,26 +150,39 @@ cudf-debug:			 #: Build with debugging symbols and cuDF GPU support
 	$(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) 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) cmake BUILD_DIR=debug BUILD_TYPE=debug \
+		EXTRA_CMAKE_FLAGS="${EXTRA_CMAKE_FLAGS} \
+			-DVELOX_BUILD_MINIMAL_WITH_DWIO=ON"
 	$(MAKE) build BUILD_DIR=debug
 
+sve_build:		#: Build with SVE-specific configuration
+# Check for SVE support and set appropriate compilers
+	@SVE_CC=$$(if [ "$$(lscpu | grep -q "sve" && grep -qi "ubuntu" /etc/os-release && echo 1)" = "1" ]; then echo "/usr/bin/gcc-12"; else echo "gcc"; fi); \
+	SVE_CXX=$$(if [ "$$(lscpu | grep -q "sve" && grep -qi "ubuntu" /etc/os-release && echo 1)" = "1" ]; then echo "/usr/bin/g++-12"; else echo "g++"; fi); \
+	echo "Using CC=$$SVE_CC, CXX=$$SVE_CXX"; \
+	export CC=$$SVE_CC; export CXX=$$SVE_CXX; \
+	$(MAKE) cmake BUILD_DIR=release BUILD_TYPE=release EXTRA_CMAKE_FLAGS="-DCMAKE_C_COMPILER=$$SVE_CC -DCMAKE_CXX_COMPILER=$$SVE_CXX -DCMAKE_CXX_FLAGS='$(COMPILER_FLAGS) -Wno-error=stringop-overflow $(shell ./scripts/setup-helper-functions.sh detect_sve_flags)'" && \
+	$(MAKE) build BUILD_DIR=release
+
 benchmarks-basic-build:
-	$(MAKE) release EXTRA_CMAKE_FLAGS=" ${EXTRA_CMAKE_FLAGS} \
-                                            -DVELOX_BUILD_TESTING=OFF \
-                                            -DVELOX_ENABLE_BENCHMARKS_BASIC=ON \
-					    -DVELOX_BUILD_RUNNER=OFF"
+	$(MAKE) release \
+		EXTRA_CMAKE_FLAGS=" ${EXTRA_CMAKE_FLAGS} \
+			-DVELOX_BUILD_TESTING=OFF \
+			-DVELOX_ENABLE_BENCHMARKS_BASIC=ON \
+			-DVELOX_BUILD_RUNNER=OFF"
 
 benchmarks-build:
-	$(MAKE) release EXTRA_CMAKE_FLAGS=" ${EXTRA_CMAKE_FLAGS} \
-                                            -DVELOX_BUILD_TESTING=OFF \
-                                            -DVELOX_ENABLE_BENCHMARKS=ON \
-					    -DVELOX_BUILD_RUNNER=OFF"
+	$(MAKE) release \
+		EXTRA_CMAKE_FLAGS=" ${EXTRA_CMAKE_FLAGS} \
+			-DVELOX_BUILD_TESTING=OFF \
+			-DVELOX_ENABLE_BENCHMARKS=ON \
+			-DVELOX_BUILD_RUNNER=OFF"
 
 benchmarks-basic-run:
 	scripts/ci/benchmark-runner.py run \
diff --git a/NOTICE.txt b/NOTICE.txt
index 4fb5849fba09..ca4cf2db6b4d 100644
--- a/NOTICE.txt
+++ b/NOTICE.txt
@@ -15,97 +15,142 @@ This product includes software from the Arrow project.
 * https://github.com/apache/arrow/blob/apache-arrow-15.0.0/cpp/src/arrow/io/hdfs_internal.cc
 Which contain the following NOTICE file:
 -------
-	Apache Arrow
-	Copyright 2016-2024 The Apache Software Foundation
-	This product includes software developed at
-	The Apache Software Foundation (http://www.apache.org/).
-	This product includes software from the SFrame project (BSD, 3-clause).
-	* Copyright (C) 2015 Dato, Inc.
-	* Copyright (c) 2009 Carnegie Mellon University.
-	This product includes software from the Feather project (Apache 2.0)
-	https://github.com/wesm/feather
-	This product includes software from the DyND project (BSD 2-clause)
-	https://github.com/libdynd
-	This product includes software from the LLVM project
-	 * distributed under the University of Illinois Open Source
-	This product includes software from the google-lint project
-	 * Copyright (c) 2009 Google Inc. All rights reserved.
-	This product includes software from the mman-win32 project
-	 * Copyright https://code.google.com/p/mman-win32/
-	 * Licensed under the MIT License;
-	This product includes software from the LevelDB project
-	 * Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-	 * Use of this source code is governed by a BSD-style license that can be
-	 * Moved from Kudu http://github.com/cloudera/kudu
-	This product includes software from the CMake project
-	 * Copyright 2001-2009 Kitware, Inc.
-	 * Copyright 2012-2014 Continuum Analytics, Inc.
-	 * All rights reserved.
-	This product includes software from https://github.com/matthew-brett/multibuild (BSD 2-clause)
-	 * Copyright (c) 2013-2016, Matt Terry and Matthew Brett; all rights reserved.
-	This product includes software from the Ibis project (Apache 2.0)
-	 * Copyright (c) 2015 Cloudera, Inc.
-	 * https://github.com/cloudera/ibis
-	This product includes software from Dremio (Apache 2.0)
-	  * Copyright (C) 2017-2018 Dremio Corporation
-	  * https://github.com/dremio/dremio-oss
-	This product includes software from Google Guava (Apache 2.0)
-	  * Copyright (C) 2007 The Guava Authors
-	  * https://github.com/google/guava
-	This product include software from CMake (BSD 3-Clause)
-	  * CMake - Cross Platform Makefile Generator
-	  * Copyright 2000-2019 Kitware, Inc. and Contributors
-	The web site includes files generated by Jekyll.
-	--------------------------------------------------------------------------------
-	This product includes code from Apache Kudu, which includes the following in
-	its NOTICE file:
-	  Apache Kudu
-	  Copyright 2016 The Apache Software Foundation
-	  This product includes software developed at
-	  The Apache Software Foundation (http://www.apache.org/).
-	  Portions of this software were developed at
-	  Cloudera, Inc (http://www.cloudera.com/).
-	--------------------------------------------------------------------------------
-	This product includes code from Apache ORC, which includes the following in
-	its NOTICE file:
-	  Apache ORC
-	  Copyright 2013-2019 The Apache Software Foundation
-	  This product includes software developed by The Apache Software
-	  Foundation (http://www.apache.org/).
-	  This product includes software developed by Hewlett-Packard:
-	  (c) Copyright [2014-2015] Hewlett-Packard Development Company, L.P
+  Apache Arrow
+  Copyright 2016-2024 The Apache Software Foundation
+  This product includes software developed at
+  The Apache Software Foundation (http://www.apache.org/).
+  This product includes software from the SFrame project (BSD, 3-clause).
+  * Copyright (C) 2015 Dato, Inc.
+  * Copyright (c) 2009 Carnegie Mellon University.
+  This product includes software from the Feather project (Apache 2.0)
+  https://github.com/wesm/feather
+  This product includes software from the DyND project (BSD 2-clause)
+  https://github.com/libdynd
+  This product includes software from the LLVM project
+   * distributed under the University of Illinois Open Source
+  This product includes software from the google-lint project
+   * Copyright (c) 2009 Google Inc. All rights reserved.
+  This product includes software from the mman-win32 project
+   * Copyright https://code.google.com/p/mman-win32/
+   * Licensed under the MIT License;
+  This product includes software from the LevelDB project
+   * Copyright (c) 2011 The LevelDB Authors. All rights reserved.
+   * Use of this source code is governed by a BSD-style license that can be
+   * Moved from Kudu http://github.com/cloudera/kudu
+  This product includes software from the CMake project
+   * Copyright 2001-2009 Kitware, Inc.
+   * Copyright 2012-2014 Continuum Analytics, Inc.
+   * All rights reserved.
+  This product includes software from https://github.com/matthew-brett/multibuild (BSD 2-clause)
+   * Copyright (c) 2013-2016, Matt Terry and Matthew Brett; all rights reserved.
+  This product includes software from the Ibis project (Apache 2.0)
+   * Copyright (c) 2015 Cloudera, Inc.
+   * https://github.com/cloudera/ibis
+  This product includes software from Dremio (Apache 2.0)
+    * Copyright (C) 2017-2018 Dremio Corporation
+    * https://github.com/dremio/dremio-oss
+  This product includes software from Google Guava (Apache 2.0)
+    * Copyright (C) 2007 The Guava Authors
+    * https://github.com/google/guava
+  This product include software from CMake (BSD 3-Clause)
+    * CMake - Cross Platform Makefile Generator
+    * Copyright 2000-2019 Kitware, Inc. and Contributors
+  The web site includes files generated by Jekyll.
+  --------------------------------------------------------------------------------
+  This product includes code from Apache Kudu, which includes the following in
+  its NOTICE file:
+    Apache Kudu
+    Copyright 2016 The Apache Software Foundation
+    This product includes software developed at
+    The Apache Software Foundation (http://www.apache.org/).
+    Portions of this software were developed at
+    Cloudera, Inc (http://www.cloudera.com/).
+  --------------------------------------------------------------------------------
+  This product includes code from Apache ORC, which includes the following in
+  its NOTICE file:
+    Apache ORC
+    Copyright 2013-2019 The Apache Software Foundation
+    This product includes software developed by The Apache Software
+    Foundation (http://www.apache.org/).
+    This product includes software developed by Hewlett-Packard:
+    (c) Copyright [2014-2015] Hewlett-Packard Development Company, L.P
 -------
 
 This product includes software from the The Hadoop project.
 * https://github.com/apache/hadoop/blob/release-3.3.0-RC0/hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfs/include/hdfs/hdfs.h
 Which contains the following NOTICE file:
 ----
-	Apache Hadoop
-	Copyright 2006 and onwards The Apache Software Foundation.
-	This product includes software developed at
-	The Apache Software Foundation (http://www.apache.org/).
-	Export Control Notice
-	---------------------
-	This distribution includes cryptographic software.  The country in
-	which you currently reside may have restrictions on the import,
-	possession, use, and/or re-export to another country, of
-	encryption software.  BEFORE using any encryption software, please
-	check your country's laws, regulations and policies concerning the
-	import, possession, or use, and re-export of encryption software, to
-	see if this is permitted.  See <http://www.wassenaar.org/> for more
-	information.
-	The U.S. Government Department of Commerce, Bureau of Industry and
-	Security (BIS), has classified this software as Export Commodity
-	Control Number (ECCN) 5D002.C.1, which includes information security
-	software using or performing cryptographic functions with asymmetric
-	algorithms.  The form and manner of this Apache Software Foundation
-	distribution makes it eligible for export under the License Exception
-	ENC Technology Software Unrestricted (TSU) exception (see the BIS
-	Export Administration Regulations, Section 740.13) for both object
-	code and source code.
-	The following provides more details on the included cryptographic software:
-	This software uses the SSL libraries from the Jetty project written
-	by mortbay.org.
-	Hadoop Yarn Server Web Proxy uses the BouncyCastle Java
-	cryptography APIs written by the Legion of the Bouncy Castle Inc.
+  Apache Hadoop
+  Copyright 2006 and onwards The Apache Software Foundation.
+  This product includes software developed at
+  The Apache Software Foundation (http://www.apache.org/).
+  Export Control Notice
+  ---------------------
+  This distribution includes cryptographic software.  The country in
+  which you currently reside may have restrictions on the import,
+  possession, use, and/or re-export to another country, of
+  encryption software.  BEFORE using any encryption software, please
+  check your country's laws, regulations and policies concerning the
+  import, possession, or use, and re-export of encryption software, to
+  see if this is permitted.  See <http://www.wassenaar.org/> for more
+  information.
+  The U.S. Government Department of Commerce, Bureau of Industry and
+  Security (BIS), has classified this software as Export Commodity
+  Control Number (ECCN) 5D002.C.1, which includes information security
+  software using or performing cryptographic functions with asymmetric
+  algorithms.  The form and manner of this Apache Software Foundation
+  distribution makes it eligible for export under the License Exception
+  ENC Technology Software Unrestricted (TSU) exception (see the BIS
+  Export Administration Regulations, Section 740.13) for both object
+  code and source code.
+  The following provides more details on the included cryptographic software:
+  This software uses the SSL libraries from the Jetty project written
+  by mortbay.org.
+  Hadoop Yarn Server Web Proxy uses the BouncyCastle Java
+  cryptography APIs written by the Legion of the Bouncy Castle Inc.
+----
+
+This product includes software from the The Spark project.
+* https://github.com/apache/spark/tree/v3.5.1/connector/connect/common/src/main/protobuf/spark/connect
+Which contain the following NOTICE file:
+----
+  Apache Spark
+  Copyright 2014 and onwards The Apache Software Foundation.
+
+  This product includes software developed at
+  The Apache Software Foundation (http://www.apache.org/).
+  Export Control Notice
+  ---------------------
+
+  This distribution includes cryptographic software. The country in which you currently reside may have
+  restrictions on the import, possession, use, and/or re-export to another country, of encryption software.
+  BEFORE using any encryption software, please check your country's laws, regulations and policies concerning
+  the import, possession, or use, and re-export of encryption software, to see if this is permitted. See
+  <http://www.wassenaar.org/> for more information.
+
+  The U.S. Government Department of Commerce, Bureau of Industry and Security (BIS), has classified this
+  software as Export Commodity Control Number (ECCN) 5D002.C.1, which includes information security software
+  using or performing cryptographic functions with asymmetric algorithms. The form and manner of this Apache
+  Software Foundation distribution makes it eligible for export under the License Exception ENC Technology
+  Software Unrestricted (TSU) exception (see the BIS Export Administration Regulations, Section 740.13) for
+  both object code and source code.
+
+  The following provides more details on the included cryptographic software:
+
+  This software uses Apache Commons Crypto (https://commons.apache.org/proper/commons-crypto/) to
+  support authentication, and encryption and decryption of data sent across the network between
+  services.
+
+
+  Metrics
+  Copyright 2010-2013 Coda Hale and Yammer, Inc.
+
+  This product includes software developed by Coda Hale and Yammer, Inc.
+
+  This product includes code derived from the JSR-166 project (ThreadLocalRandom, Striped64,
+  LongAdder), which was released with the following comments:
+
+    Written by Doug Lea with assistance from members of JCP JSR-166
+    Expert Group and released to the public domain, as explained at
+    http://creativecommons.org/publicdomain/zero/1.0/
 ----
diff --git a/README.md b/README.md
index 16fd3cd265cf..3fb83181fd9c 100644
--- a/README.md
+++ b/README.md
@@ -112,6 +112,32 @@ Details on the dependencies and how Velox manages some of them for you
 Velox also provides the following scripts to help developers setup and install Velox
 dependencies for a given platform.
 
+### Supported OS and compiler matrix
+
+The minimum versions of supported compilers:
+
+| OS | Compiler | Version |
+|----|----------|---------|
+| Linux | gcc | 11 |
+| Linux | clang | 15 |
+| macOS | clang | 15 |
+
+The recommended OS versions and compilers:
+
+| OS | Compiler | Version |
+|----|----------|---------|
+| CentOS 9/RHEL 9 | gcc | 12 |
+| Ubuntu 22.04 | gcc | 11 |
+| macOS | clang | 16 |
+
+Alternative combinations:
+
+| OS | Compiler | Version |
+|----|----------|---------|
+| CentOS 9/RHEL 9 | gcc | 11 |
+| Ubuntu 20.04 | gcc | 11 |
+| Ubuntu 24.04 | clang | 15 |
+
 ### Setting up dependencies
 
 The following setup scripts use the `DEPENDENCY_DIR` environment variable to set the
@@ -125,7 +151,7 @@ Using the default install location `/usr/local` on macOS is discouraged since th
 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
+say `export INSTALL_PREFIX=/Users/$USER/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
diff --git a/docker-bake.hcl b/docker-bake.hcl
new file mode 100644
index 000000000000..3a63980522a6
--- /dev/null
+++ b/docker-bake.hcl
@@ -0,0 +1,148 @@
+variable "tag" {
+  default = "ghcr.io/facebookincubator/velox-dev"
+}
+
+# Variable to control cache pushing
+variable "DOCKER_UPLOAD_CACHE" {
+  default = false
+}
+
+function "cache-to-arch" {
+  params = [name, arch]
+  # We don't want to push local build to the cache by accident
+  # so we remove cache-to unless we are running in CI
+  result = DOCKER_UPLOAD_CACHE ? [{
+    type        = "registry"
+    ref         = "${tag}:build-cache-${name}-${arch}"
+    mode        = "max"
+    compression = "zstd"
+  }] : []
+}
+
+function "cache-from-arch" {
+  params = [name, arch]
+  result = [{
+    type = "registry"
+    ref  = "${tag}:build-cache-${name}-${arch}"
+  }]
+}
+
+function "ci_images_by_arch" {
+  params = [arch]
+  result = ["centos9-${arch}", "adapters-${arch}"]
+}
+
+group "ci-amd64" {
+  targets = ci_images_by_arch("amd64")
+}
+
+group "ci-arm64" {
+  targets = ci_images_by_arch("arm64")
+}
+
+group "default" {
+  targets = []
+}
+
+target "base" {
+  output = [
+    DOCKER_UPLOAD_CACHE ? {
+      type           = "registry"
+      compression    = "zstd"
+      oci-mediatypes = true
+      } : {
+      # For local builds with the docker driver the image will be loaded
+      # even without explicitly adding the `docker` exporter
+      type = "cacheonly"
+    }
+
+  ]
+}
+
+target "pyvelox" {
+  inherits   = ["base"]
+  context    = "."
+  name       = "pyvelox-${arch}"
+  dockerfile = "scripts/docker/centos-multi.dockerfile"
+  target     = "pyvelox"
+  args = {
+    image              = "quay.io/pypa/manylinux_2_28:latest"
+    VELOX_BUILD_SHARED = "OFF"
+  }
+  matrix = {
+    arch = ["amd64", "arm64"]
+  }
+  platforms  = ["linux/${arch}"]
+  tags       = ["${tag}:pyvelox-${arch}"]
+  cache-to   = cache-to-arch("pyvelox", "${arch}")
+  cache-from = cache-from-arch("pyvelox", "${arch}")
+}
+
+target "adapters" {
+  inherits = ["base","adapters-cpp"]
+  name     = "adapters-${arch}"
+  matrix = {
+    arch = ["amd64", "arm64"]
+  }
+  platforms  = ["linux/${arch}"]
+  tags       = ["${tag}:adapters-${arch}"]
+  cache-to   = cache-to-arch("adapters", "${arch}")
+  cache-from = cache-from-arch("adapters", "${arch}")
+}
+
+target "centos9" {
+  inherits = ["base","centos-cpp"]
+  name     = "centos9-${arch}"
+  matrix = {
+    arch = ["amd64", "arm64"]
+  }
+  platforms  = ["linux/${arch}"]
+  tags       = ["${tag}:centos9-${arch}"]
+  cache-to   = cache-to-arch("centos9", "${arch}")
+  cache-from = cache-from-arch("centos9", "${arch}")
+}
+
+target "ubuntu-amd64" {
+  inherits   = ["base","ubuntu-cpp"]
+  cache-to   = cache-to-arch("ubuntu", "amd64")
+  cache-from = cache-from-arch("ubuntu", "amd64")
+}
+
+group "ubuntu-arm64" {
+  # We don't actually want to build the ubuntu arm image, this is a trick to simplify CI
+  # Empty targets don't fail the build.
+  targets = []
+}
+
+group "fedora-arm64" {
+  # We don't actually want to build the fedora arm image, this is a trick to simplify CI
+  # Empty targets don't fail the build.
+  targets = []
+}
+
+target "fedora-amd64" {
+  inherits   = ["base", "fedora"]
+  dockerfile = "scripts/docker/fedora.dockerfile"
+  cache-to   = cache-to-arch("fedora", "amd64")
+  cache-from = cache-from-arch("fedora", "amd64")
+}
+
+group "java" {
+  # The main work is in the well cached download steps and the shared base stage,
+  # so these can easily be run on the same node in ci
+  targets = ["spark-server", "presto-java"]
+}
+
+target "spark-server" {
+  inherits = ["base"]
+  target     = "spark-server"
+  cache-to   = cache-to-arch("spark-server", "amd64")
+  cache-from = cache-from-arch("spark-server", "amd64")
+}
+
+target "presto-java" {
+  inherits = ["base"]
+  target     = "presto-java"
+  cache-to   = cache-to-arch("presto-java", "amd64")
+  cache-from = cache-from-arch("presto-java", "amd64")
+}
diff --git a/docker-compose.yml b/docker-compose.yml
index d7cc50d1a8f0..65d99a93bf7d 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -11,77 +11,63 @@
 # WITHOUT 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: '3.5'
 
+# The docker-compose file is used only for running the services:
+# `docker compose run adapters-cpp`
+#
+# If you want to build any of the images you will need to use docker bake:
+# `docker bake adapters-amd64`
+#
+# The target names are defined in docker-bake.hcl, you can use the names
+# from `docker-compose.yml`, like `adapters-cpp` but those will not make use
+# of layer caching and will tag images with the wrong tag for the multi-arch images.
+# Do this for local use only!
+#
+# When testing changes you want to push as a PR use docker bake.
 services:
-  ubuntu-cpp:
-    # 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:ubuntu-22.04
+  # This is not an actual target and just used to inherit the env and volume
+  # defaults
+  base-block:
     build:
       context: .
-      dockerfile: scripts/docker/ubuntu-22.04-cpp.dockerfile
     environment:
-      NUM_THREADS: 8 # default value for NUM_THREADS
-      VELOX_DEPENDENCY_SOURCE: BUNDLED # Build dependencies from source
+      NUM_THREADS: ${NUM_THREADS:-8} # default value for NUM_THREADS
       CCACHE_DIR: /velox/.ccache
     volumes:
       - .:/velox:delegated
-    command: scripts/docker/docker-command.sh
+    working_dir: /velox
+    command: /velox/scripts/docker/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/docker/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
+  ubuntu-cpp:
+    extends: base-block
+    image: ghcr.io/facebookincubator/velox-dev:ubuntu-22.04
     build:
-      context: .
-      dockerfile: scripts/docker/adapters.dockerfile
-      args:
-        image: ghcr.io/facebookincubator/velox-dev:centos9
+      dockerfile: scripts/docker/ubuntu-22.04-cpp.dockerfile
     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/docker-command.sh
+      VELOX_DEPENDENCY_SOURCE: BUNDLED # Build dependencies from source
 
-  adapters-cuda:
-    # Usage:
-    #   docker-compose pull adapters-cuda or docker-compose build adapters-cuda
-    #   or
-    #   docker-compose run --rm adapters-cuda
-    #   or
-    #   docker-compose run -e NUM_THREADS=<NUMBER_OF_THREADS_TO_USE> --rm adapters-cuda
-    #   to set the number of threads used during compilation
-    # scripts/docker/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
+  centos-cpp:
+    extends: base-block
+    image: ghcr.io/facebookincubator/velox-dev:centos9
     build:
-      context: .
-      dockerfile: scripts/docker/adapters.dockerfile
+      dockerfile: scripts/docker/centos-multi.dockerfile
+      target: centos9
       args:
-        image: ghcr.io/facebookincubator/velox-dev:centos9
+        image: quay.io/centos/centos:stream9
+        VELOX_BUILD_SHARED: "ON"
+
+  adapters-cpp:
+    extends: centos-cpp
+    image: ghcr.io/facebookincubator/velox-dev:adapters
     environment:
-      NUM_THREADS: 8 # default value for NUM_THREADS
-      CCACHE_DIR: /velox/.ccache
-      EXTRA_CMAKE_FLAGS: >
+      EXTRA_CMAKE_FLAGS: >-
         -DVELOX_ENABLE_PARQUET=ON
         -DVELOX_ENABLE_S3=ON
+    build:
+      target: adapters
+
+  adapters-cuda:
+    extends: adapters-cpp
     privileged: true
     deploy:
       resources:
@@ -90,70 +76,28 @@ services:
             - driver: nvidia
               count: 1
               capabilities: [gpu]
-    volumes:
-      - .:/velox:delegated
-    working_dir: /velox
-    command: /velox/scripts/docker/docker-command.sh
-
-  centos-cpp:
-    # Usage:
-    #   docker-compose pull centos-cpp or docker-compose build centos-cpp
-    #   docker-compose run --rm centos-cpp
-    #   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:centos9
-    build:
-      context: .
-      dockerfile: scripts/docker/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
-    working_dir: /velox
-    command: /velox/scripts/docker/docker-command.sh
 
   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
+    extends: base-block
     image: ghcr.io/facebookincubator/velox-dev:presto-java
     build:
       args:
-        - PRESTO_VERSION=0.290
-      context: .
-      dockerfile: scripts/docker/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/docker-command.sh
+        - PRESTO_VERSION=0.295
+      dockerfile: scripts/docker/java.dockerfile
 
   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
+    extends: base-block
     image: ghcr.io/facebookincubator/velox-dev:spark-server
     build:
       args:
         - SPARK_VERSION=3.5.1
-      context: .
-      dockerfile: scripts/docker/spark-container.dockerfile
+      dockerfile: scripts/docker/java.dockerfile
+
+  fedora:
+    extends: base-block
+    image: ghcr.io/facebookincubator/velox-dev:fedora
+    build:
+      dockerfile: scripts/docker/fedora.dockerfile
+      target: fedora
     environment:
-      NUM_THREADS: 8 # default value for NUM_THREADS
-      CCACHE_DIR: /velox/.ccache
-    volumes:
-      - .:/velox:delegated
-    working_dir: /velox
-    command: /velox/scripts/docker/docker-command.sh
+      VELOX_BUILD_SHARED: "ON"
diff --git a/pyproject.toml b/pyproject.toml
index 439d447e583d..d22044ea01b2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -46,6 +46,9 @@ classifiers = [
 [project.urls]
 homepage = "https://github.com/facebookincubator/velox"
 
+[project.optional-dependencies]
+docs = ["sphinx", "sphinx-tabs", "breathe", "sphinx_rtd_theme", "chardet"]
+
 [tool.scikit-build]
 build-dir = "_build/python"
 metadata.version.provider = "scikit_build_core.metadata.setuptools_scm"
@@ -110,7 +113,7 @@ cmake.define.TREAT_WARNINGS_AS_ERRORS = false
 [tool.setuptools_scm]
 root = '.'
 version_scheme = 'guess-next-dev'
-git_describe_command = 'git describe --dirty --tags --long --match "pyvelox-v[0-9]*.*"'
+git_describe_command = ['git', 'describe', '--dirty', '--tags', '--long', '--match', 'pyvelox-v[0-9]*']
 fallback_version = '0.2.0a'
 
 [tool.cibuildwheel]
diff --git a/python/test/test_runner.py b/python/test/test_runner.py
index bafde6730e10..59a5baf4a430 100644
--- a/python/test/test_runner.py
+++ b/python/test/test_runner.py
@@ -40,7 +40,7 @@ def setUp(self) -> None:
     def tearDown(self) -> None:
         unregister_all()
 
-    def test_runner_empty(self):
+    def test_empty(self):
         plan_builder = PlanBuilder().values()
         runner = LocalRunner(plan_builder.get_plan_node())
         total_size = 0
@@ -49,19 +49,19 @@ def test_runner_empty(self):
             total_size += vector.size()
         self.assertEqual(total_size, 0)
 
-    def test_runner_not_executed(self):
+    def test_not_executed(self):
         # Ensure it won't hang on destruction when it was not executed.
         plan_builder = PlanBuilder().values()
         LocalRunner(plan_builder.get_plan_node())
 
-    def test_runner_executed_twice(self):
+    def test_executed_twice(self):
         # Ensure the runner fails if it is executed twice.
         plan_builder = PlanBuilder().values()
         runner = LocalRunner(plan_builder.get_plan_node())
         runner.execute()
         self.assertRaises(RuntimeError, runner.execute)
 
-    def test_runner_with_values(self):
+    def test_values(self):
         vectors = []
         batch_size = 10
         num_batches = 10
@@ -79,7 +79,7 @@ def test_runner_with_values(self):
             total_size += vector.size()
         self.assertEqual(total_size, 100)
 
-    def test_runner_with_values_order_limit(self):
+    def test_values_order_limit(self):
         vectors = []
         batch_size = 10
         num_batches = 10
@@ -103,7 +103,7 @@ def test_runner_with_values_order_limit(self):
         )
         self.assertEqual(output, expected_result)
 
-    def test_runner_with_hash_join(self):
+    def test_hash_join(self):
         batch_size = 100
         probe = list(range(batch_size))
         build = [i for i in probe if i % 2 == 0]
@@ -138,7 +138,7 @@ def test_runner_with_hash_join(self):
         result = int(vector.child_at(0)[0])
         self.assertEqual(result, sum(build))
 
-    def test_runner_with_merge_join(self):
+    def test_merge_join(self):
         batch_size = 10
         array = pyarrow.array([42] * batch_size)
         batch = to_velox(pyarrow.record_batch([array], names=["c0"]))
@@ -159,7 +159,7 @@ def test_runner_with_merge_join(self):
             total_size += vector.size()
         self.assertEqual(total_size, batch_size * batch_size)
 
-    def test_runner_with_merge_sort(self):
+    def test_merge_sort(self):
         array = pyarrow.array([0, 1, 2, 3, 4])
         batch = to_velox(pyarrow.record_batch([array], names=["c0"]))
 
@@ -186,6 +186,43 @@ def test_runner_with_merge_sort(self):
         )
         self.assertEqual(output, expected)
 
+    def test_unnest_and_streaming_aggregate(self):
+        batch_size = 100
+        base = list(range(batch_size))
+
+        input_vector = to_velox(
+            pyarrow.record_batch([pyarrow.array([base])], names=["c0"])
+        )
+        # Single row containing an array column with `batch_size` elements.
+        self.assertEqual(input_vector.size(), 1)
+
+        # Unnest it and check we get batch_size rows.
+        plan_builder = PlanBuilder()
+        plan_builder.values([input_vector]).unnest(unnest_columns=["c0"])
+
+        runner = LocalRunner(plan_builder.get_plan_node())
+        iterator = runner.execute()
+        vector = next(iterator)
+
+        self.assertRaises(StopIteration, next, iterator)
+        self.assertEqual(vector.size(), batch_size)
+
+        # Unnest then stream aggregate it back to ensure we get the input
+        # vector back.
+        plan_builder = PlanBuilder()
+        plan_builder.values([input_vector]).unnest(
+            unnest_columns=["c0"],
+        ).streaming_aggregate(
+            grouping_keys=[],
+            aggregations=["array_agg(c0_e)"],
+        )
+
+        runner = LocalRunner(plan_builder.get_plan_node())
+        iterator = runner.execute()
+        vector = next(iterator)
+
+        self.assertEqual(vector, input_vector)
+
     def test_register_connectors(self):
         register_hive("conn1")
         self.assertRaises(RuntimeError, register_hive, "conn1")
@@ -209,11 +246,12 @@ def test_write_read_file(self):
         input_batch = to_velox(pyarrow.record_batch([array], names=["c0"]))
 
         with tempfile.TemporaryDirectory() as temp_dir:
-            output_file = f"{temp_dir}/output_file"
+            output_file_name = "output_file"
+            output_file_path = f"{temp_dir}/{output_file_name}"
 
             plan_builder = PlanBuilder()
             plan_builder.values([input_batch]).table_write(
-                output_file=DWRF(output_file),
+                output_file=DWRF(output_file_path),
                 connector_id="hive",
             )
 
@@ -225,14 +263,14 @@ def test_write_read_file(self):
             self.assertNotEqual(runner.print_plan_with_stats(), "")
 
             output_file_from_table_writer = self.extract_file(output)
-            self.assertEqual(output_file, output_file_from_table_writer)
+            self.assertEqual(output_file_path, output_file_from_table_writer)
 
             # Now scan it back.
             scan_plan_builder = PlanBuilder()
             scan_plan_builder.table_scan(
                 output_schema=ROW(["c0"], [BIGINT()]),
                 connector_id="hive",
-                input_files=[DWRF(output_file)],
+                input_files=[DWRF(output_file_path)],
             )
 
             runner = LocalRunner(scan_plan_builder.get_plan_node())
@@ -243,6 +281,28 @@ def test_write_read_file(self):
             # Ensure the read batch is the same as the one written.
             self.assertEqual(input_batch, result)
 
+            # Test special columns ($row_group_id and $row_number).
+            special_column_plan_builder = PlanBuilder().table_scan(
+                output_schema=ROW(
+                    ["$row_group_id", "row_number"],
+                    [VARCHAR(), BIGINT()],
+                ),
+                row_index="row_number",
+                connector_id="hive",
+                input_files=[DWRF(output_file_path)],
+            )
+
+            runner = LocalRunner(special_column_plan_builder.get_plan_node())
+            iterator = runner.execute()
+            result = next(iterator)
+            self.assertRaises(StopIteration, next, iterator)
+
+            # First column is always the output file name; the second is a
+            # monotonically increasing row id.
+            for i in range(batch_size):
+                self.assertEqual(result.child_at(0)[i], output_file_name)
+                self.assertEqual(result.child_at(1)[i], str(i))
+
     def test_tpch_gen(self):
         register_tpch("tpch")
         register_hive("hive")
diff --git a/python/test/test_type.py b/python/test/test_type.py
index ff079cd1cb17..b059ee587236 100644
--- a/python/test/test_type.py
+++ b/python/test/test_type.py
@@ -26,6 +26,7 @@
     DOUBLE,
     VARCHAR,
     VARBINARY,
+    JSON,
     ARRAY,
     MAP,
     ROW,
@@ -43,6 +44,7 @@ def test_simple_types(self):
         self.assertTrue(isinstance(DOUBLE(), Type))
         self.assertTrue(isinstance(VARCHAR(), Type))
         self.assertTrue(isinstance(VARBINARY(), Type))
+        self.assertTrue(isinstance(JSON(), Type))
 
     def test_complex_types(self):
         self.assertTrue(isinstance(ARRAY(VARCHAR()), Type))
@@ -86,3 +88,5 @@ def test_equality(self):
 
         self.assertNotEqual(BIGINT(), INTEGER())
         self.assertNotEqual(ARRAY(BIGINT()), REAL())
+        self.assertNotEqual(VARBINARY(), VARCHAR())
+        self.assertNotEqual(JSON(), VARCHAR())
diff --git a/scripts/checks/license-header.py b/scripts/checks/license-header.py
index 6f2ebb52e809..03dcdaff48f6 100755
--- a/scripts/checks/license-header.py
+++ b/scripts/checks/license-header.py
@@ -100,7 +100,7 @@ def wrapper_hash(header, args):
         "*.cmake": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
         "*.cpp": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.hpp": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
-        "*.dockfile": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
+        "*.dockerfile": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
         "*.h": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.inc": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.java": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
@@ -110,6 +110,7 @@ def wrapper_hash(header, args):
         "*.thrift": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.txt": attrdict({"wrapper": wrapper_hash, "hashbang": True}),
         "*.yml": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
+        "*.yaml": attrdict({"wrapper": wrapper_hash, "hashbang": False}),
         "*.cu": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.cuh": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
         "*.clcpp": attrdict({"wrapper": wrapper_chpp, "hashbang": False}),
@@ -228,7 +229,13 @@ def main():
             # If removing the header text, zero it out there.
             header_comment = ""
 
-        message(log_to, "Fix  : " + filepath)
+        if os.environ.get("GITHUB_ACTIONS"):
+            print(
+                f"::error file={filepath},line=1,endLine=1,title=Missing license header::"
+                + "Please add the properly commented license header."
+            )
+        else:
+            message(log_to, "Fix  : " + filepath)
 
         if args.check:
             fail = True
diff --git a/scripts/checks/run-clang-tidy.py b/scripts/checks/run-clang-tidy.py
index 5d7016c3d9ed..c694ebacbd2a 100755
--- a/scripts/checks/run-clang-tidy.py
+++ b/scripts/checks/run-clang-tidy.py
@@ -15,75 +15,12 @@
 
 import argparse
 import json
-import regex
+import re
 import sys
+import os
 
 import util
 
-CODE_CHECKS = """*
-    -abseil-*
-    -android-*
-    -cert-err58-cpp
-    -clang-analyzer-osx-*
-    -cppcoreguidelines-avoid-c-arrays
-    -cppcoreguidelines-avoid-magic-numbers
-    -cppcoreguidelines-pro-bounds-array-to-pointer-decay
-    -cppcoreguidelines-pro-bounds-pointer-arithmetic
-    -cppcoreguidelines-pro-type-reinterpret-cast
-    -cppcoreguidelines-pro-type-vararg
-    -fuchsia-*
-    -google-*
-    -hicpp-avoid-c-arrays
-    -hicpp-deprecated-headers
-    -hicpp-no-array-decay
-    -hicpp-use-equals-default
-    -hicpp-vararg
-    -llvmlibc-*
-    -llvm-header-guard
-    -llvm-include-order
-    -mpi-*
-    -misc-non-private-member-variables-in-classes
-    -misc-no-recursion
-    -misc-unused-parameters
-    -modernize-avoid-c-arrays
-    -modernize-deprecated-headers
-    -modernize-use-nodiscard
-    -modernize-use-trailing-return-type
-    -objc-*
-    -openmp-*
-    -readability-avoid-const-params-in-decls
-    -readability-convert-member-functions-to-static
-    -readability-magic-numbers
-    -zircon-*
-"""
-
-# Additional opt-outs because googletest macros trip too many things.
-#
-TEST_CHECKS = (
-    CODE_CHECKS
-    + """
-    -cert-err58-cpp
-    -cppcoreguidelines-avoid-goto
-    -cppcoreguidelines-avoid-non-const-global-variables
-    -cppcoreguidelines-owning-memory
-    -cppcoreguidelines-pro-type-vararg
-    -cppcoreguidelines-special-member-functions
-    -hicpp-avoid-goto
-    -hicpp-special-member-functions
-    -hicpp-vararg
-    -misc-no-recursion
-    -readability-implicit-bool-conversion
-"""
-)
-
-
-def check_list(check_string):
-    return ",".join([check.strip() for check in check_string.strip().splitlines()])
-
-
-CODE_CHECKS = check_list(CODE_CHECKS)
-TEST_CHECKS = check_list(TEST_CHECKS)
-
 
 class Multimap(dict):
     def __setitem__(self, key, value):
@@ -101,15 +38,15 @@ def git_changed_lines(commit):
         line = line.rstrip("\n")
         fields = line.split()
 
-        match = regex.match(r"^\+\+\+ b/.*", line)
+        match = re.match(r"^\+\+\+ b/.*", line)
         if match:
             file = ""
 
-        match = regex.match(r"^\+\+\+ b/(.*(\.cpp|\.h))$", line)
+        match = re.match(r"^\+\+\+ b/(.*(\.cpp|\.h|\.hpp))$", line)
         if match:
             file = match.group(1)
 
-        match = regex.match(r"^@@", line)
+        match = re.match(r"^@@", line)
         if match and file != "":
             lspan = fields[2].split(",")
             if len(lspan) <= 1:
@@ -117,60 +54,71 @@ def git_changed_lines(commit):
 
             changed_lines[file] = [int(lspan[0]), int(lspan[0]) + int(lspan[1])]
 
-    return json.dumps(
-        [{"name": key, "lines": value} for key, value in changed_lines.items()]
-    )
-
-
-def checks(args):
-    status, stdout, stderr = util.run(
-        f"clang-tidy -checks='{CODE_CHECKS}' --list-checks"
-    )
-    print(stdout)
+    return changed_lines
 
 
 def check_output(output):
-    return regex.match(r"^/.* warning: ", output)
+    return re.match(r"(^/.* warning: |^$)", output)
 
 
 def tidy(args):
     files = util.input_files(args.files)
+    files = [file for file in files if re.match(r".*(\.cpp|\.h|\.hpp)$", file)]
 
-    groups = Multimap()
+    in_gha = os.environ.get("GITHUB_ACTIONS") is not None
 
-    for file in files:
-        groups["test" if "/tests/" in file else "main"] = file
+    changed_lines = git_changed_lines(args.commit)
 
-    fix = "--fix" if args.fix == "fix" else ""
-    lines = (
-        ("'--line-filter=" + git_changed_lines(args.commit)) + "'"
-        if args.commit is not None
-        else ""
+    line_filter = json.dumps(
+        [{"name": key, "lines": value} for key, value in changed_lines.items()]
     )
+    filtered_files = [*changed_lines.keys()]
+    if len(filtered_files) == 0:
+        return 0
+
+    fix = "--fix" if args.fix == "fix" else ""
+    lines = f"'--line-filter={line_filter}'" if args.commit is not None else ""
 
     ok = True
-    if groups.get("main", None):
-        status, stdout, stderr = util.run(
-            f"xargs clang-tidy -p=build/release/ --format-style=file -header-filter='.*' --checks='{CODE_CHECKS}' --quiet {fix} {lines}",
-            input=groups["main"],
-        )
-        ok = check_output(stdout) and ok
+    build_path = args.p or os.getenv("BUILD_PATH")
+    build_path_str = f"-p {build_path}" if build_path else ""
+
+    if build_path_str == "" and not os.path.isfile(
+        os.getcwd().join("compile_commands.json")
+    ):
+        print("compile_commands.json not found, skipping clang-tidy")
+        return 0
 
-    if groups.get("test", None):
-        status, stdout, stderr = util.run(
-            f"xargs clang-tidy -p=build/release/ --format-style=file -header-filter='.*' --checks='{TEST_CHECKS}' --quiet {fix} {lines}",
-            input=groups["test"],
+    status, stdout, stderr = util.run(
+        f"xargs clang-tidy --format-style=file -header-filter='.*' --quiet {build_path_str} {fix} {lines}",
+        input=filtered_files,
+    )
+
+    if in_gha:
+        clang_tidy_pattern = (
+            r"^(.*):(\d+):(\d+):\s+(error|warning):\s+(.*) \[([a-z0-9,\-]+)\]\s*$"
         )
-        ok = check_output(stdout) and ok
+
+        for stdout_line in stdout.split("\n"):
+            m = re.match(clang_tidy_pattern, stdout_line)
+            if m is not None:
+                file, line, col, severity, message, rule = m.groups()
+                file = file.removeprefix("/__w/velox/velox/")
+                print(
+                    f"::{severity} file={file},line={line},col={col},title={rule}::{message}"
+                )
+
+    ok = check_output(stdout)
 
     return 0 if ok else 1
 
 
 def parse_args():
     global parser
-    parser = argparse.ArgumentParser(description="CircliCi Utility")
+    parser = argparse.ArgumentParser(description="Clang Tidy Utility")
     parser.add_argument("--commit")
     parser.add_argument("--fix")
+    parser.add_argument("-p", help="Path containing 'compile_commands.json'")
 
     parser.add_argument("files", metavar="FILES", nargs="+", help="files to process")
 
diff --git a/scripts/checks/util.py b/scripts/checks/util.py
index c0b34532a945..fe7f05c86dd7 100644
--- a/scripts/checks/util.py
+++ b/scripts/checks/util.py
@@ -15,7 +15,7 @@
 import gzip
 import json
 import os
-import regex
+import re
 import subprocess
 import sys
 
@@ -27,7 +27,7 @@ class attrdict(dict):
 
 class string(str):
     def extract(self, rexp):
-        return regex.match(rexp, self).group(1)
+        return re.match(rexp, self).group(1)
 
     def json(self):
         return json.loads(self, object_hook=attrdict)
diff --git a/scripts/ci/bm-report/report.qmd b/scripts/ci/bm-report/report.qmd
index a91a116a6b93..b9ad14c79a44 100644
--- a/scripts/ci/bm-report/report.qmd
+++ b/scripts/ci/bm-report/report.qmd
@@ -50,7 +50,7 @@ run_shas <- runs |>
   jsonlite::fromJSON()
 
 run_ids <- mruns(run_shas) |>
-  filter(commit.branch == "facebookincubator:main", substr(id, 1, 2) == "BM") |>
+  filter(substr(id, 1, 2) == "BM") |>
   pull(id)
 
 # Speed up local dev by saving 'results' as conbench requests can't be memoised
diff --git a/scripts/ci/gersemi_cmd_definitions.py b/scripts/ci/gersemi_cmd_definitions.py
new file mode 100644
index 000000000000..78aca426e6ae
--- /dev/null
+++ b/scripts/ci/gersemi_cmd_definitions.py
@@ -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.
+
+from copy import deepcopy
+
+from gersemi.builtin_commands import builtin_commands
+
+# Gersemi throws a runtime error if two commands use the same builtin definition
+# but changing the canonical name in a deepcopy prevents this
+velox_add_library = deepcopy(builtin_commands["add_library"])
+velox_base_add_library = deepcopy(builtin_commands["add_library"])
+velox_add_library["_canonical_name"] = "velox_add_library"
+velox_base_add_library["_canonical_name"] = "velox_base_add_library"
+
+pybind11_add_module = {
+    "front_positional_arguments": ["target_name"],
+    "options": [
+        "MODULE",
+        "SHARED",
+        "EXCLUDE_FROM_ALL",
+        "THIN_LTO",
+        "NO_EXTRAS",
+        "OPT_SIZE",
+    ],
+    "back_positional_arguments": ["sources"],
+    "_canonical_name": "pybind11_add_module",
+}
+pyvelox_add_module = deepcopy(pybind11_add_module)
+pyvelox_add_module["_canonical_name"] = "pyvelox_add_module"
+
+# Define the argument structure of our custom functions, this influences how they are formatted
+command_definitions = {
+    "pybind11_add_module": pybind11_add_module,
+    "pyvelox_add_module": pyvelox_add_module,
+    "velox_add_library": velox_add_library,
+    "velox_base_add_library": velox_base_add_library,
+    "velox_build_dependency": {
+        "front_positional_arguments": ["dependency_name"],
+    },
+    "velox_compile_definitions": builtin_commands["target_compile_definitions"],
+    "velox_get_rpath_origin": {"front_positional_arguments": ["output_variable"]},
+    "velox_include_directories": builtin_commands["target_include_directories"],
+    "velox_install_library_headers": {"options": ["nothing"]},
+    "velox_link_libraries": builtin_commands["target_link_libraries"],
+    "velox_resolve_dependency": builtin_commands["find_package"],
+    "velox_resolve_dependency_url": {"front_positional_arguments": ["dependency_name"]},
+    "velox_set_source": {"front_positional_arguments": ["dependency_name"]},
+    "velox_set_with_default": {
+        "front_positional_arguments": ["var_name", "envvar_name", "default"]
+    },
+    "velox_sources": builtin_commands["target_sources"],
+}
diff --git a/scripts/ci/presto/start-prestojava.sh b/scripts/ci/presto/start-prestojava.sh
index 4a02636aa820..30ef1ecfc965 100755
--- a/scripts/ci/presto/start-prestojava.sh
+++ b/scripts/ci/presto/start-prestojava.sh
@@ -15,4 +15,4 @@
 
 set -e
 
-"$PRESTO_HOME"/bin/launcher --pid-file=/tmp/pidfile  run
+"$PRESTO_HOME"/bin/launcher --pid-file=/tmp/pidfile run
diff --git a/scripts/ci/signature.py b/scripts/ci/signature.py
index daa876942f1a..f9534e88d0cc 100644
--- a/scripts/ci/signature.py
+++ b/scripts/ci/signature.py
@@ -337,7 +337,7 @@ def parse_args(args):
     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="?"
+        "ticket_value", type=get_tickets, default=20, nargs="?"
     )
     bias_command_parser.add_argument("error_path", type=str, default="")
 
diff --git a/scripts/ci/spark/start-spark.sh b/scripts/ci/spark/start-spark.sh
index 7aca5999f8f9..7f081386452d 100755
--- a/scripts/ci/spark/start-spark.sh
+++ b/scripts/ci/spark/start-spark.sh
@@ -15,4 +15,4 @@
 
 set -e
 
-"$SPARK_HOME"/sbin/start-connect-server.sh --jars "$SPARK_HOME"/misc/spark-connect_2.12-3.5.1.jar
+"$SPARK_HOME"/sbin/start-connect-server.sh --jars "$SPARK_HOME"/misc/spark-connect.jar
diff --git a/scripts/docker/adapters.dockerfile b/scripts/docker/adapters.dockerfile
deleted file mode 100644
index 47ce766b95bf..000000000000
--- a/scripts/docker/adapters.dockerfile
+++ /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.
-# Build the test and build container for presto_cpp
-ARG image=ghcr.io/facebookincubator/velox-dev:centos9
-FROM $image
-
-COPY scripts/setup-centos9.sh /
-COPY scripts/setup-common.sh /
-COPY scripts/setup-versions.sh /
-COPY scripts/setup-helper-functions.sh /
-RUN mkdir build && bash -c "{ \
-    cd build && \
-    source /opt/rh/gcc-toolset-12/enable && \
-    source /setup-centos9.sh && \
-    install_adapters && \
-    install_cuda 12.8; \
-  }" && \
-  rm -rf build && dnf remove -y conda && dnf clean all
-
-# put CUDA binaries on the PATH
-ENV PATH=/usr/local/cuda/bin:${PATH}
-
-# configuration for nvidia-container-toolkit
-ENV NVIDIA_VISIBLE_DEVICES=all
-ENV NVIDIA_DRIVER_CAPABILITIES="compute,utility"
-
-# 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 /setup-classpath.sh && source /opt/rh/gcc-toolset-12/enable && exec \"$@\"", "--"]
-CMD ["/bin/bash"]
diff --git a/scripts/docker/centos-multi.dockerfile b/scripts/docker/centos-multi.dockerfile
new file mode 100644
index 000000000000..d957e70d511d
--- /dev/null
+++ b/scripts/docker/centos-multi.dockerfile
@@ -0,0 +1,166 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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
+
+# This multi-stage Dockerfile contains the following relevant targets:
+#   - centos9: Our base CI build
+#   - adapters: Based on centos9 with all optional dependencies installed
+#   - pyvelox: Image used by cibuildwheel to build pyvelox
+
+########################
+# Stage 1: Base Build  #
+########################
+ARG image=quay.io/centos/centos:stream9
+FROM $image AS base-build
+
+COPY scripts/setup-helper-functions.sh /
+COPY scripts/setup-versions.sh /
+COPY scripts/setup-common.sh /
+COPY scripts/setup-centos9.sh /
+COPY CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch /
+
+ARG VELOX_BUILD_SHARED=ON
+# Building libvelox.so requires folly and gflags to be built shared as well for now
+ENV VELOX_BUILD_SHARED=${VELOX_BUILD_SHARED}
+
+RUN mkdir build
+WORKDIR /build
+
+# We don't want UV symlinks to be copied into the following stages
+ENV UV_TOOL_BIN_DIR=/usr/local/bin \
+    UV_INSTALL_DIR=/usr/local/bin \
+    INSTALL_PREFIX=/deps
+
+# CMake 4.0 removed support for cmake minimums of <=3.5 and will fail builds, this overrides it
+ENV CMAKE_POLICY_VERSION_MINIMUM="3.5" \
+    VELOX_ARROW_CMAKE_PATCH=/cmake-compatibility.patch
+
+# Some CMake configs contain the hard coded prefix '/deps', we need to replace that with
+# the future location to avoid build errors in the base-image
+RUN bash /setup-centos9.sh && \
+    find $INSTALL_PREFIX/lib/cmake -type f -name '*.cmake' -exec sed -i 's|/deps/|/usr/local/|g' {} \;
+
+########################
+# Stage 2: Base Image  #
+########################
+FROM $image AS base-image
+
+COPY scripts/setup-helper-functions.sh /
+COPY scripts/setup-versions.sh /
+COPY scripts/setup-common.sh /
+COPY scripts/setup-centos9.sh /
+
+# This way it's on the PATH and doesn't clash with the version installed in manylinux
+ENV UV_TOOL_BIN_DIR=/usr/local/bin \
+    UV_INSTALL_DIR=/usr/local/bin
+
+RUN /bin/bash -c 'source /setup-centos9.sh && \
+      install_build_prerequisites && \
+      install_velox_deps_from_dnf && \
+      dnf clean all'
+
+RUN ln -s $(which python3) /usr/bin/python
+
+COPY --from=base-build /deps /usr/local
+
+########################
+# Stage: Centos 9      #
+########################
+FROM base-image AS centos9
+
+# Install tools needed for CI
+RUN /bin/bash -c "source /setup-centos9.sh && \
+      dnf_install 'dnf-command(config-manager)' && \
+      dnf config-manager --add-repo 'https://cli.github.com/packages/rpm/gh-cli.repo' && \
+      dnf_install 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"]
+
+########################
+# Stage: PyVelox       #
+########################
+FROM base-image AS pyvelox
+
+ENV LD_LIBRARY_PATH="/usr/local/lib:/usr/local/lib64:$LD_LIBRARY_PATH"
+
+########################
+# Stage: Adapters Build#
+########################
+FROM $image AS adapters-build
+
+COPY scripts/setup-helper-functions.sh /
+COPY scripts/setup-versions.sh /
+COPY scripts/setup-common.sh /
+COPY scripts/setup-centos9.sh /
+COPY scripts/setup-centos-adapters.sh /
+
+RUN mkdir build
+WORKDIR /build
+
+ENV UV_TOOL_BIN_DIR=/usr/local/bin \
+    UV_INSTALL_DIR=/usr/local/bin \
+    INSTALL_PREFIX=/deps
+
+RUN bash -c 'source /setup-centos9.sh && install_build_prerequisites'
+
+RUN bash /setup-centos-adapters.sh install_adapters && \
+    find $INSTALL_PREFIX/lib/cmake -type f -name '*.cmake' -exec sed -i 's|/deps/|/usr/local/|g' {} \;
+
+########################
+# Stage: Adapters      #
+########################
+FROM centos9 AS adapters
+
+COPY scripts/setup-centos-adapters.sh /
+
+RUN bash /setup-centos-adapters.sh install_cuda && \
+      dnf clean all
+
+RUN bash /setup-centos-adapters.sh install_adapters_deps_from_dnf && \
+      dnf clean all
+
+# put CUDA binaries on the PATH
+ENV PATH=/usr/local/cuda/bin:${PATH}
+
+# configuration for nvidia-container-toolkit
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV NVIDIA_DRIVER_CAPABILITIES="compute,utility"
+
+# Install test dependencies
+RUN uv pip install --system https://github.com/googleapis/storage-testbench/archive/refs/tags/v0.36.0.tar.gz
+
+RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
+RUN . /root/.nvm/nvm.sh && nvm install 22
+
+# Install azurite and symlink nvm managed binaries into /usr/local/bin which is on the path
+RUN . /root/.nvm/nvm.sh && npm install -g azurite && \
+      ln -s $(dirname $(which node))/* /usr/local/bin
+
+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 --from=adapters-build /deps /usr/local
+
+COPY scripts/setup-classpath.sh /
+ENTRYPOINT ["/bin/bash", "-c", "source /setup-classpath.sh && source /opt/rh/gcc-toolset-12/enable && exec \"$@\"", "--"]
+CMD ["/bin/bash"]
diff --git a/scripts/docker/centos.dockerfile b/scripts/docker/centos.dockerfile
deleted file mode 100644
index 8d9ffb24563e..000000000000
--- a/scripts/docker/centos.dockerfile
+++ /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.
-# 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-versions.sh /
-COPY scripts/setup-common.sh /
-COPY scripts/setup-centos9.sh /
-
-# Building libvelox.so requires folly and gflags to be built shared as well for now
-ENV  VELOX_BUILD_SHARED=ON
-# 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/docker/docker-command.sh b/scripts/docker/docker-command.sh
index 8abc2af30188..88faf22c997d 100755
--- a/scripts/docker/docker-command.sh
+++ b/scripts/docker/docker-command.sh
@@ -16,4 +16,4 @@
 set -eu
 # Compilation and testing
 make
-cd _build/release && ctest -j${NUM_THREADS} --output-on-failure --no-tests=error
+cd _build/release && ctest -j"${NUM_THREADS}" --output-on-failure --no-tests=error
diff --git a/scripts/docker/fedora.dockerfile b/scripts/docker/fedora.dockerfile
new file mode 100644
index 000000000000..28478c5857bd
--- /dev/null
+++ b/scripts/docker/fedora.dockerfile
@@ -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.
+
+########################
+# Stage 1: Base Build  #
+########################
+ARG base=quay.io/fedora/fedora:42-x86_64
+FROM $base AS base-build
+
+COPY scripts/setup-helper-functions.sh /
+COPY scripts/setup-versions.sh /
+COPY scripts/setup-common.sh /
+COPY scripts/setup-centos9.sh /
+COPY scripts/setup-fedora.sh /
+COPY CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch /
+
+ARG VELOX_BUILD_SHARED=ON
+# Building libvelox.so requires folly and gflags to be built shared as well for now
+ENV VELOX_BUILD_SHARED=${VELOX_BUILD_SHARED}
+
+RUN mkdir build
+WORKDIR /build
+
+# We don't want UV symlinks to be copied into the following stages
+ENV UV_TOOL_BIN_DIR=/usr/local/bin \
+    UV_INSTALL_DIR=/usr/local/bin \
+    INSTALL_PREFIX=/deps
+
+# CMake 4.0 removed support for cmake minimums of <=3.5 and will fail builds, this overrides it
+ENV CMAKE_POLICY_VERSION_MINIMUM="3.5" \
+    VELOX_ARROW_CMAKE_PATCH=/cmake-compatibility.patch
+
+# Some CMake configs contain the hard coded prefix '/deps', we need to replace that with
+# the future location to avoid build errors in the base-image
+RUN bash /setup-fedora.sh && \
+    find $INSTALL_PREFIX/lib/cmake -type f -name '*.cmake' -exec sed -i 's|/deps/|/usr/local/|g' {} \;
+
+########################
+# Stage 2: Base Image  #
+########################
+FROM $base AS fedora
+
+COPY scripts/setup-helper-functions.sh /
+COPY scripts/setup-versions.sh /
+COPY scripts/setup-common.sh /
+COPY scripts/setup-centos9.sh /
+COPY scripts/setup-fedora.sh /
+
+# This way it's on the PATH and doesn't clash with the version installed in manylinux
+ENV UV_TOOL_BIN_DIR=/usr/local/bin \
+    UV_INSTALL_DIR=/usr/local/bin
+
+RUN /bin/bash -c 'source /setup-fedora.sh && \
+      install_build_prerequisites && \
+      install_velox_deps_from_dnf && \
+      dnf_install jq gh &&\
+      dnf clean all'
+
+RUN ln -s $(which python3) /usr/bin/python
+
+COPY --from=base-build /deps /usr/local
diff --git a/scripts/docker/java.dockerfile b/scripts/docker/java.dockerfile
new file mode 100644
index 000000000000..0d75fb216d6c
--- /dev/null
+++ b/scripts/docker/java.dockerfile
@@ -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.
+# Build the test and build container for presto_cpp
+
+# Global arg default to share across stages
+ARG SPARK_VERSION=3.5.1
+ARG PRESTO_VERSION=0.295
+
+#########################
+# Stage: Spark Download #
+#########################
+# This allows us to cache the (slow) download until we change Spark version
+FROM alpine:3.22 AS spark-download
+ARG SPARK_VERSION
+
+RUN wget -O spark.tgz https://archive.apache.org/dist/spark/spark-${SPARK_VERSION}/spark-${SPARK_VERSION}-bin-hadoop3.tgz
+RUN wget -O spark-connect.jar \
+    https://repo1.maven.org/maven2/org/apache/spark/spark-connect_2.12/${SPARK_VERSION}/spark-connect_2.12-${SPARK_VERSION}.jar
+
+RUN tar -zxf spark.tgz
+
+##########################
+# Stage: Presto Download #
+##########################
+# This allows us to cache the (slow) download until we change version
+FROM alpine:3.22 AS presto-download
+ARG PRESTO_VERSION
+
+RUN wget -O presto-server.tar.gz \
+    https://repo1.maven.org/maven2/com/facebook/presto/presto-server/${PRESTO_VERSION}/presto-server-${PRESTO_VERSION}.tar.gz
+RUN wget -O presto-cli \
+    https://github.com/prestodb/presto/releases/download/${PRESTO_VERSION}/presto-cli-${PRESTO_VERSION}-executable.jar
+
+RUN tar -xzf presto-server.tar.gz
+
+#########################
+# Stage: Java Base      #
+#########################
+FROM ghcr.io/facebookincubator/velox-dev:centos9 AS java-base
+
+RUN dnf install -y -q --setopt=install_weak_deps=False java-17-openjdk less procps tzdata
+
+# 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
+
+#########################
+# Stage: Spark Server   #
+#########################
+FROM java-base AS spark-server
+ARG SPARK_VERSION
+
+ENV SPARK_HOME="/opt/spark-server"
+
+COPY scripts/ci/spark/conf/spark-defaults.conf.example $SPARK_HOME/conf/spark-defaults.conf
+COPY scripts/ci/spark/conf/spark-env.sh.example $SPARK_HOME/conf/spark-env.sh
+COPY scripts/ci/spark/conf/workers.example $SPARK_HOME/conf/workers
+COPY scripts/ci/spark/start-spark.sh /opt/
+
+COPY --from=spark-download /spark-${SPARK_VERSION}-bin-hadoop3 $SPARK_HOME/
+COPY --from=spark-download /spark-connect.jar $SPARK_HOME/misc/
+
+WORKDIR /velox
+
+#########################
+# Stage: Presto Java    #
+#########################
+FROM java-base AS presto-java
+ARG PRESTO_VERSION
+
+ENV PRESTO_HOME="/opt/presto-server"
+
+COPY scripts/ci/presto/etc/config.properties.example $PRESTO_HOME/etc/config.properties
+COPY scripts/ci/presto/etc/jvm.config.example $PRESTO_HOME/etc/jvm.config
+COPY scripts/ci/presto/etc/node.properties $PRESTO_HOME/etc/node.properties
+COPY scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog/
+COPY scripts/ci/presto/start-prestojava.sh /opt/
+
+COPY --from=presto-download /presto-server-$PRESTO_VERSION  $PRESTO_HOME/
+COPY --from=presto-download --chmod=755 /presto-cli  /opt/
+
+RUN ln -s /opt/presto-cli /usr/local/bin/ && \
+      mkdir -p $PRESTO_HOME/etc/data && \
+      mkdir -p /usr/lib/presto/utils
+
+
+WORKDIR /velox
diff --git a/scripts/docker/prestojava-container.dockerfile b/scripts/docker/prestojava-container.dockerfile
deleted file mode 100644
index 373e37db6286..000000000000
--- a/scripts/docker/prestojava-container.dockerfile
+++ /dev/null
@@ -1,51 +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 ghcr.io/facebookincubator/velox-dev:centos9
-
-ARG PRESTO_VERSION=0.290
-
-COPY 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/ci/presto/etc/config.properties.example $PRESTO_HOME/etc/config.properties
-COPY scripts/ci/presto/etc/jvm.config.example $PRESTO_HOME/etc/jvm.config
-COPY scripts/ci/presto/etc/node.properties $PRESTO_HOME/etc/node.properties
-COPY scripts/ci/presto/etc/hive.properties $PRESTO_HOME/etc/catalog
-COPY scripts/ci/presto/start-prestojava.sh /opt
-
-WORKDIR /velox
diff --git a/scripts/docker/pyvelox.dockerfile b/scripts/docker/pyvelox.dockerfile
deleted file mode 100644
index 5757345ef9b8..000000000000
--- a/scripts/docker/pyvelox.dockerfile
+++ /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.
-# Build the test and build container for presto_cpp
-FROM quay.io/pypa/manylinux_2_28_x86_64:latest
-
-COPY scripts/setup-helper-functions.sh /
-COPY scripts/setup-manylinux.sh /
-
-# Build static folly to reduce wheel size (folly.so is ~120M)
-ENV  VELOX_BUILD_SHARED=OFF
-# 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-manylinux.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 LD_LIBRARY_PATH="/usr/local/lib:/usr/local/lib64:$LD_LIBRARY_PATH"
diff --git a/scripts/docker/spark-container.dockerfile b/scripts/docker/spark-container.dockerfile
deleted file mode 100644
index a9825628088a..000000000000
--- a/scripts/docker/spark-container.dockerfile
+++ /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.
-# Build the test and build container for presto_cpp
-#
-FROM ghcr.io/facebookincubator/velox-dev:centos9
-
-ARG SPARK_VERSION=3.5.1
-
-COPY 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/ci/spark/conf/spark-defaults.conf.example $SPARK_HOME/conf/spark-defaults.conf
-COPY scripts/ci/spark/conf/spark-env.sh.example $SPARK_HOME/conf/spark-env.sh
-COPY scripts/ci/spark/conf/workers.example $SPARK_HOME/conf/workers
-COPY scripts/ci/spark/start-spark.sh /opt
-
-WORKDIR /velox
diff --git a/scripts/docker/ubuntu-22.04-cpp.dockerfile b/scripts/docker/ubuntu-22.04-cpp.dockerfile
index 5cd1f76099ac..8175ecd6823b 100644
--- a/scripts/docker/ubuntu-22.04-cpp.dockerfile
+++ b/scripts/docker/ubuntu-22.04-cpp.dockerfile
@@ -14,8 +14,6 @@
 ARG base=ubuntu:22.04
 FROM ${base}
 
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
 RUN apt update && \
       apt install -y sudo \
             lsb-release \
@@ -24,6 +22,11 @@ RUN apt update && \
 
 
 COPY scripts /velox/scripts/
+COPY CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch /
+
+ENV VELOX_ARROW_CMAKE_PATCH=/cmake-compatibility.patch \
+    UV_TOOL_BIN_DIR=/usr/local/bin \
+    UV_INSTALL_DIR=/usr/local/bin
 
 # TZ and DEBIAN_FRONTEND="noninteractive"
 # are required to avoid tzdata installation
@@ -32,6 +35,6 @@ 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
+RUN /bin/bash -o pipefail /velox/scripts/setup-ubuntu.sh
 
 WORKDIR /velox
diff --git a/scripts/docker/yscope-velox-builder.dockerfile b/scripts/docker/yscope-velox-builder.dockerfile
index 38f04afb6ca2..c70c13419210 100644
--- a/scripts/docker/yscope-velox-builder.dockerfile
+++ b/scripts/docker/yscope-velox-builder.dockerfile
@@ -21,32 +21,18 @@ SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 ENV TZ=Etc/UTC
 ENV DEBIAN_FRONTEND=noninteractive
 
-# Install CMake 3.28.3 using its install script
-# NOTE: `scripts/setup-ubuntu.sh` installs CMake via pip, but sometimes the pip-installed CMake
-# doesn't show up on the path in container environments (causing, for example, FastFloat library
-# build failures). Using CMake's install script avoids this issue.
-RUN curl --fail --location --show-error --silent --remote-name \
-        https://github.com/Kitware/CMake/releases/download/v3.28.3/cmake-3.28.3-linux-x86_64.sh \
-    && chmod +x cmake-3.28.3-linux-x86_64.sh \
-    && ./cmake-3.28.3-linux-x86_64.sh --skip-license --prefix=/usr/local \
-    && rm cmake-3.28.3-linux-x86_64.sh
+# Copy dependency installation scripts and CMake modules together so that setup-common.sh's
+# relative path resolution (SCRIPT_DIR/../CMake/...) works correctly (after rarely-changing
+# layers for better caching)
+COPY scripts /tmp/velox-deps/scripts/
+COPY CMake/resolve_dependency_modules /tmp/velox-deps/CMake/resolve_dependency_modules/
 
-# Copy dependency installation scripts (after rarely-changing layers for better caching)
-COPY scripts /tmp/velox-deps/
+ENV UV_TOOL_BIN_DIR=/usr/local/bin
+ENV UV_INSTALL_DIR=/usr/local/bin
 
-RUN /tmp/velox-deps/setup-ubuntu.sh \
-    && mv /tmp/.venv /opt/velox-venv \
+RUN /tmp/velox-deps/scripts/setup-ubuntu.sh \
     && rm -rf /tmp/velox-deps
 
-# Activate the virtual environment.
-#
-# NOTE: We set `ENV` variables directly rather than using `source /opt/velox-venv/bin/activate` in
-# a `RUN` command since the latter only persists for that single instruction (each `RUN` starts a
-# fresh shell), whereas the former persists across all subsequent `RUN` commands and in containers
-# that use the image.
-ENV VIRTUAL_ENV="/opt/velox-venv"
-ENV PATH="${VIRTUAL_ENV}/bin:${PATH}"
-
 ENV CCACHE_DIR=/var/cache/ccache
 
 # Disable compression to trade disk space for speed in CI builds
@@ -63,7 +49,7 @@ ENV CCACHE_NOHASHDIR=true
 # - We clear the stats after warmup so that CI builds only show their own cache hits.
 COPY . /tmp/velox-src/
 WORKDIR /tmp/velox-src
-RUN CCACHE_BASEDIR=/tmp/velox-src make release \
+RUN CCACHE_BASEDIR=/tmp/velox-src make release TREAT_WARNINGS_AS_ERRORS=0 \
     && echo "CCache statistics after warmup build:" \
     && ccache --verbose --show-stats \
     && ccache --zero-stats
diff --git a/scripts/info.sh b/scripts/info.sh
index effbd94277c5..132a0fc3ca61 100755
--- a/scripts/info.sh
+++ b/scripts/info.sh
@@ -25,16 +25,16 @@ fi
 info=$(cmake --system-information)
 
 ext() {
-  grep -oE '".+"$' $1 | tr -d '"'
+  grep -oE '".+"$' | tr -d '"'
 }
 
 print_info() {
-echo "$info" | grep -e "$1" | ext
+  echo "$info" | grep -e "$1" | ext
 }
 
 result="
 Velox System Info v${version}
-Commit: $(git rev-parse HEAD 2> /dev/null || echo "Not in a git repo.")
+Commit: $(git rev-parse HEAD 2>/dev/null || echo "Not in a git repo.")
 CMake Version: $(cmake --version | grep -oE '[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+')
 System: $(print_info 'CMAKE_SYSTEM "')
 Arch: $(print_info 'CMAKE_SYSTEM_PROCESSOR')
@@ -61,14 +61,14 @@ all="$result  $conda"
 echo "$all"
 
 if [ -x "$(command -v xclip)" ]; then
- clip="xclip -selection c"
+  clip="xclip -selection c"
 elif [ -x "$(command -v pbcopy)" ]; then
   clip="pbcopy"
 else
-  echo "\nThe results will be copied to your clipboard if xclip is installed."
+  printf "\nThe results will be copied to your clipboard if xclip is installed."
 fi
 
-if [ ! -z "$clip" ]; then
+if [ -n "$clip" ]; then
   echo "$all" | $clip
   echo "Result copied to clipboard!"
 fi
diff --git a/scripts/setup-centos-adapters.sh b/scripts/setup-centos-adapters.sh
new file mode 100755
index 000000000000..1167c95f69db
--- /dev/null
+++ b/scripts/setup-centos-adapters.sh
@@ -0,0 +1,113 @@
+#!/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.
+# shellcheck source-path=SCRIPT_DIR
+
+# This script installs addition dependencies for the adapters build
+# of Velox. The scrip expects base dependencies to already be installed.
+#
+# This script is split of from setup-centos9.sh to improve docker caching
+#
+# 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.
+# * VELOX_CUDA_VERSION="12.8": Which version of CUDA to install, will pick up
+#   CUDA_VERSION from the env
+
+set -efx -o pipefail
+
+VELOX_CUDA_VERSION=${CUDA_VERSION:-"12.8"}
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPT_DIR"/setup-centos9.sh
+
+function install_cuda {
+  # See https://developer.nvidia.com/cuda-downloads
+  local arch
+  arch="$(uname -m)"
+  local repo_url
+  version="${1:-$VELOX_CUDA_VERSION}"
+
+  if [[ $arch == "x86_64" ]]; then
+    repo_url="https://developer.download.nvidia.com/compute/cuda/repos/rhel9/x86_64/cuda-rhel9.repo"
+  elif [[ $arch == "aarch64" ]]; then
+    # Using SBSA (Server Base System Architecture) repository for ARM64 servers
+    repo_url="https://developer.download.nvidia.com/compute/cuda/repos/rhel9/sbsa/cuda-rhel9.repo"
+  else
+    echo "Unsupported architecture: $arch" >&2
+    return 1
+  fi
+
+  dnf config-manager --add-repo "$repo_url"
+  local dashed
+  dashed="$(echo "$version" | tr '.' '-')"
+  dnf_install \
+    cuda-compat-"$dashed" \
+    cuda-driver-devel-"$dashed" \
+    cuda-minimal-build-"$dashed" \
+    cuda-nvrtc-devel-"$dashed" \
+    libcufile-devel-"$dashed" \
+    libnvjitlink-devel-"$dashed" \
+    numactl-libs
+}
+
+function install_adapters_deps_from_dnf {
+  local gcs_deps=(curl-devel c-ares-devel re2-devel)
+  local azure_deps=(perl-IPC-Cmd openssl-devel libxml2-devel)
+  local hdfs_deps=(libxml2-devel libgsasl-devel libuuid-devel krb5-devel java-1.8.0-openjdk-devel)
+
+  dnf_install "${azure_deps[@]}" "${gcs_deps[@]}" "${hdfs_deps[@]}"
+}
+
+function install_s3 {
+  install_aws_deps
+  local MINIO_OS="linux"
+  install_minio ${MINIO_OS}
+}
+
+function install_adapters {
+  run_and_time install_adapters_deps_from_dnf
+  run_and_time install_s3
+  run_and_time install_gcs_sdk_cpp
+  run_and_time install_azure_storage_sdk_cpp
+  run_and_time install_hdfs_deps
+}
+
+(return 2>/dev/null) && return # If script was sourced, don't run commands.
+
+(
+  if [[ $# -ne 0 ]]; then
+    # Activate gcc12; enable errors on unset variables afterwards.
+    source /opt/rh/gcc-toolset-12/enable || exit 1
+    set -u
+
+    for cmd in "$@"; do
+      run_and_time "${cmd}"
+    done
+    echo "All specified dependencies installed!"
+  else
+    # Activate gcc12; enable errors on unset variables afterwards.
+    source /opt/rh/gcc-toolset-12/enable || exit 1
+    set -u
+    install_cuda "$VELOX_CUDA_VERSION"
+    install_adapters
+    echo "All dependencies for the Velox Adapters 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-centos9.sh b/scripts/setup-centos9.sh
index c0cd353fb667..54f6f94d697c 100755
--- a/scripts/setup-centos9.sh
+++ b/scripts/setup-centos9.sh
@@ -12,6 +12,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.
+# shellcheck source-path=SCRIPT_DIR
 
 # This script documents setting up a Centos9 host for Velox
 # development.  Running it should make you ready to compile.
@@ -28,15 +29,16 @@
 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-common.sh
-export CXXFLAGS=$(get_cxx_flags) # Used by boost.
-export CFLAGS=${CXXFLAGS//"-std=c++17"/} # Used by LZO.
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPT_DIR"/setup-common.sh
+CXXFLAGS=$(get_cxx_flags) # Used by boost.
+export CXXFLAGS
 export COMPILER_FLAGS=${CXXFLAGS}
 SUDO="${SUDO:-""}"
 USE_CLANG="${USE_CLANG:-false}"
 export INSTALL_PREFIX=${INSTALL_PREFIX:-"/usr/local"}
 DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)/deps-download}
+export UV_TOOL_BIN_DIR="${UV_TOOL_BIN_DIR:-"$INSTALL_PREFIX"/bin}"
 
 function dnf_install {
   dnf install -y -q --setopt=install_weak_deps=False "$@"
@@ -50,12 +52,15 @@ function install_clang15 {
 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
+  if grep -q CentOS /etc/os-release; then
+    dnf config-manager --set-enabled crb
+    dnf update -y
+  fi
+  dnf_install autoconf automake ccache clang gcc-toolset-12 gcc-toolset-14 git libtool \
+    llvm ninja-build python3-pip python3-devel wget which
 
-  pip install cmake==3.30.4
+  install_uv
+  uv_install cmake@3.31.1
 
   if [[ ${USE_CLANG} != "false" ]]; then
     install_clang15
@@ -69,8 +74,7 @@ function install_velox_deps_from_dnf {
     libdwarf-devel elfutils-libelf-devel curl-devel libicu-devel bison flex \
     libsodium-devel zlib-devel gtest-devel gmock-devel xxhash-devel
 
-  # install sphinx for doc gen
-  pip install sphinx sphinx-tabs breathe sphinx_rtd_theme
+  install_faiss_deps
 }
 
 function install_conda {
@@ -80,51 +84,12 @@ function install_conda {
 function install_gflags {
   # Remove an older version if present.
   dnf remove -y gflags
-  wget_and_untar https://github.com/gflags/gflags/archive/${GFLAGS_VERSION}.tar.gz gflags
+  wget_and_untar https://github.com/gflags/gflags/archive/"${GFLAGS_VERSION}".tar.gz gflags
   cmake_install_dir gflags -DBUILD_SHARED_LIBS=ON -DBUILD_STATIC_LIBS=ON -DBUILD_gflags_LIB=ON -DLIB_SUFFIX=64
 }
 
-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
-  local dashed="$(echo $1 | tr '.' '-')"
-  dnf install -y \
-    cuda-compat-$dashed \
-    cuda-driver-devel-$dashed \
-    cuda-minimal-build-$dashed \
-    cuda-nvrtc-devel-$dashed
-}
-
-function install_s3 {
-  install_aws_deps
-
-  local MINIO_OS="linux"
-  install_minio ${MINIO_OS}
-}
-
-function install_gcs {
-  # Dependencies of GCS, probably a workaround until the docker image is rebuilt
-  dnf -y install npm curl-devel c-ares-devel
-  install_gcs-sdk-cpp
-}
-
-function install_abfs {
-  # Dependencies of Azure Storage Blob cpp
-  dnf -y install perl-IPC-Cmd openssl libxml2-devel
-  install_azure-storage-sdk-cpp
-}
-
-function install_hdfs {
-  dnf -y install libxml2-devel libgsasl-devel libuuid-devel krb5-devel
-  install_hdfs_deps
-  yum install -y java-1.8.0-openjdk-devel
-}
-
-function install_adapters {
-  run_and_time install_s3
-  run_and_time install_gcs
-  run_and_time install_abfs
-  run_and_time install_hdfs
+function install_faiss_deps {
+  dnf_install openblas-devel libomp
 }
 
 function install_velox_deps {
@@ -132,7 +97,6 @@ function install_velox_deps {
   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
@@ -150,9 +114,10 @@ function install_velox_deps {
   run_and_time install_xsimd
   run_and_time install_simdjson
   run_and_time install_geos
+  run_and_time install_faiss
 }
 
-(return 2> /dev/null) && return # If script was sourced, don't run commands.
+(return 2>/dev/null) && return # If script was sourced, don't run commands.
 
 (
   if [[ $# -ne 0 ]]; then
diff --git a/scripts/setup-classpath.sh b/scripts/setup-classpath.sh
index bfd7066dc63c..fbb99f6751a8 100644
--- a/scripts/setup-classpath.sh
+++ b/scripts/setup-classpath.sh
@@ -11,5 +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.
+# shellcheck shell=bash
 
-export CLASSPATH=`/usr/local/hadoop/bin/hdfs classpath --glob`
+CLASSPATH=$(/usr/local/hadoop/bin/hdfs classpath --glob)
+export CLASSPATH
diff --git a/scripts/setup-common.sh b/scripts/setup-common.sh
index d9a02c47f0c5..b9ae39ed89ae 100755
--- a/scripts/setup-common.sh
+++ b/scripts/setup-common.sh
@@ -12,153 +12,205 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+# trigger reinstall
+# shellcheck source-path=SCRIPT_DIR
 
-SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
-source $SCRIPTDIR/setup-helper-functions.sh
-source $SCRIPTDIR/setup-versions.sh
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPT_DIR"/setup-helper-functions.sh
+source "$SCRIPT_DIR"/setup-versions.sh
 
-VELOX_BUILD_SHARED=${VELOX_BUILD_SHARED:-"OFF"} #Build folly and gflags shared for use in libvelox.so.
+VELOX_BUILD_SHARED=${VELOX_BUILD_SHARED:-"OFF"}        #Build folly and gflags shared for use in libvelox.so.
+VELOX_ARROW_CMAKE_PATCH=${VELOX_ARROW_CMAKE_PATCH:-""} # avoid error due to +u
 CMAKE_BUILD_TYPE="${BUILD_TYPE:-Release}"
 DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)}
 BUILD_GEOS="${BUILD_GEOS:-true}"
+BUILD_FAISS="${BUILD_FAISS:-true}"
 BUILD_DUCKDB="${BUILD_DUCKDB:-true}"
 EXTRA_ARROW_OPTIONS=${EXTRA_ARROW_OPTIONS:-""}
+SIMDJSON_SKIPUTF8VALIDATION=${SIMDJSON_SKIPUTF8VALIDATION:-"OFF"}
 
 USE_CLANG="${USE_CLANG:-false}"
 
 MACHINE=$(uname -m)
 
-WGET_OPTIONS=${WGET_OPTIONS:-""}
+# Read WGET_OPTIONS into an array which can be expanded to nothing
+# using a normal variable expands into an empty string causing wget to exit 1
+read -r -a WGET_OPTS <<<"${WGET_OPTIONS:-}"
 
 mkdir -p "${DEPENDENCY_DIR}"
 
 function install_fmt {
-  wget_and_untar https://github.com/fmtlib/fmt/archive/${FMT_VERSION}.tar.gz fmt
+  wget_and_untar https://github.com/fmtlib/fmt/archive/"${FMT_VERSION}".tar.gz fmt
   cmake_install_dir fmt -DFMT_TEST=OFF
 }
 
 function install_folly {
   # Folly Portability.h being used to decide whether or not support coroutines
   # causes issues (build, link) if the selection is not consistent across users of folly.
+  # shellcheck disable=SC2034
   EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  wget_and_untar https://github.com/facebook/folly/archive/refs/tags/${FB_OS_VERSION}.tar.gz folly
+  wget_and_untar https://github.com/facebook/folly/archive/refs/tags/"${FB_OS_VERSION}".tar.gz folly
   cmake_install_dir folly -DBUILD_SHARED_LIBS="$VELOX_BUILD_SHARED" -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON
 }
 
 function install_fizz {
   # Folly Portability.h being used to decide whether or not support coroutines
   # causes issues (build, link) if the selection is not consistent across users of folly.
+  # shellcheck disable=SC2034
   EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  wget_and_untar https://github.com/facebookincubator/fizz/archive/refs/tags/${FB_OS_VERSION}.tar.gz 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_fast_float {
-  wget_and_untar https://github.com/fastfloat/fast_float/archive/refs/tags/${FAST_FLOAT_VERSION}.tar.gz fast_float
+  wget_and_untar https://github.com/fastfloat/fast_float/archive/refs/tags/"${FAST_FLOAT_VERSION}".tar.gz fast_float
   cmake_install_dir fast_float -DBUILD_TESTS=OFF
 }
 
 function install_wangle {
   # Folly Portability.h being used to decide whether or not support coroutines
   # causes issues (build, link) if the selection is not consistent across users of folly.
+  # shellcheck disable=SC2034
   EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  wget_and_untar https://github.com/facebook/wangle/archive/refs/tags/${FB_OS_VERSION}.tar.gz 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 {
   # Folly Portability.h being used to decide whether or not support coroutines
   # causes issues (build, link) if the selection is not consistent across users of folly.
+  # shellcheck disable=SC2034
   EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  wget_and_untar https://github.com/facebook/mvfst/archive/refs/tags/${FB_OS_VERSION}.tar.gz 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 {
   # Folly Portability.h being used to decide whether or not support coroutines
   # causes issues (build, link) if the selection is not consistent across users of folly.
+  # shellcheck disable=SC2034
   EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  wget_and_untar https://github.com/facebook/fbthrift/archive/refs/tags/${FB_OS_VERSION}.tar.gz 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_duckdb {
-  if $BUILD_DUCKDB ; then
-    wget_and_untar https://github.com/duckdb/duckdb/archive/refs/tags/${DUCKDB_VERSION}.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=${CMAKE_BUILD_TYPE}
+  if $BUILD_DUCKDB; then
+    wget_and_untar https://github.com/duckdb/duckdb/archive/refs/tags/"${DUCKDB_VERSION}".tar.gz duckdb
+    # DuckDB uses git commands to retrieve version information during the build,
+    # which works with git clone. To prevent incorrectly using the parent project's
+    # git version when building from a tarball, we define GIT_COMMIT_HASH to skip
+    # that.
+    cmake_install_dir duckdb \
+      -DGIT_COMMIT_HASH="6536a77" -DBUILD_UNITTESTS=OFF -DENABLE_SANITIZER=OFF -DENABLE_UBSAN=OFF \
+      -DBUILD_SHELL=OFF -DEXPORT_DLL_SYMBOLS=OFF -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}"
   fi
 }
 
 function install_boost {
-  wget_and_untar https://github.com/boostorg/boost/releases/download/${BOOST_VERSION}/${BOOST_VERSION}.tar.gz boost
+  wget_and_untar https://github.com/boostorg/boost/releases/download/"${BOOST_VERSION}"/"${BOOST_VERSION}".tar.gz boost
   (
-    cd ${DEPENDENCY_DIR}/boost
+    cd "${DEPENDENCY_DIR}"/boost || exit
     if [[ "$(uname)" == "Linux" && ${USE_CLANG} != "false" ]]; then
-      ./bootstrap.sh --prefix=${INSTALL_PREFIX} --with-toolset="clang-15"
+      ./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}
+      ./bootstrap.sh --prefix="${INSTALL_PREFIX}"
       ${SUDO} ./b2 "-j${NPROC}" -d0 install threading=multi --without-python
     fi
   )
 }
 
 function install_protobuf {
-  wget_and_untar https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-all-${PROTOBUF_VERSION}.tar.gz protobuf
+  install_abseil
+
+  wget_and_untar https://github.com/protocolbuffers/protobuf/releases/download/v"${PROTOBUF_VERSION}"/protobuf-all-"${PROTOBUF_VERSION}".tar.gz protobuf
   cmake_install_dir protobuf -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_ABSL_PROVIDER=package
 }
 
 function install_double_conversion {
-  wget_and_untar https://github.com/google/double-conversion/archive/refs/tags/${DOUBLE_CONVERSION_VERSION}.tar.gz double-conversion
+  wget_and_untar https://github.com/google/double-conversion/archive/refs/tags/"${DOUBLE_CONVERSION_VERSION}".tar.gz double-conversion
   cmake_install_dir double-conversion -DBUILD_TESTING=OFF
 }
 
 function install_ranges_v3 {
-  wget_and_untar https://github.com/ericniebler/range-v3/archive/refs/tags/${RANGE_V3_VERSION}.tar.gz ranges_v3
+  wget_and_untar https://github.com/ericniebler/range-v3/archive/refs/tags/"${RANGE_V3_VERSION}".tar.gz ranges_v3
   cmake_install_dir ranges_v3 -DRANGES_ENABLE_WERROR=OFF -DRANGE_V3_TESTS=OFF -DRANGE_V3_EXAMPLES=OFF
 }
 
+function install_abseil {
+  wget_and_untar https://github.com/abseil/abseil-cpp/archive/refs/tags/"${ABSEIL_VERSION}".tar.gz abseil-cpp
+  local OS
+  OS=$(uname)
+  if [[ $OS == "Darwin" ]]; then
+    ABSOLUTE_SCRIPTDIR=$(realpath "$SCRIPT_DIR")
+    (
+      cd "${DEPENDENCY_DIR}/abseil-cpp" || exit 1
+      git apply $ABSOLUTE_SCRIPTDIR/../CMake/resolve_dependency_modules/absl/absl-macos.patch
+    )
+  fi
+  cmake_install_dir abseil-cpp \
+    -DABSL_BUILD_TESTING=OFF \
+    -DCMAKE_CXX_STANDARD=17 \
+    -DABSL_PROPAGATE_CXX_STD=ON \
+    -DABSL_ENABLE_INSTALL=ON
+}
+
 function install_re2 {
-  wget_and_untar https://github.com/google/re2/archive/refs/tags/${RE2_VERSION}.tar.gz re2
-  cmake_install_dir re2 -DRE2_BUILD_TESTING=OFF
+  install_abseil
+
+  wget_and_untar https://github.com/google/re2/archive/refs/tags/"${RE2_VERSION}".tar.gz re2
+  cmake_install_dir re2 -DRE2_BUILD_TESTING=OFF -Dabsl_DIR="${INSTALL_PREFIX}/lib/cmake/absl"
 }
 
 function install_glog {
-  wget_and_untar https://github.com/google/glog/archive/${GLOG_VERSION}.tar.gz glog
+  wget_and_untar https://github.com/google/glog/archive/"${GLOG_VERSION}".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-${LZO_VERSION}.tar.gz lzo
+  wget_and_untar http://www.oberhumer.com/opensource/lzo/download/lzo-"${LZO_VERSION}".tar.gz lzo
   (
-    cd ${DEPENDENCY_DIR}/lzo
-    ./configure --prefix=${INSTALL_PREFIX} --enable-shared --disable-static --docdir=/usr/share/doc/lzo-${LZO_VERSION}
+    cd "${DEPENDENCY_DIR}"/lzo || exit
+    ./configure --prefix="${INSTALL_PREFIX}" --enable-shared --disable-static --docdir=/usr/share/doc/lzo-"${LZO_VERSION}"
     make "-j${NPROC}"
     ${SUDO} make install
   )
 }
 
 function install_snappy {
-  wget_and_untar https://github.com/google/snappy/archive/${SNAPPY_VERSION}.tar.gz snappy
+  wget_and_untar https://github.com/google/snappy/archive/"${SNAPPY_VERSION}".tar.gz snappy
   cmake_install_dir snappy -DSNAPPY_BUILD_TESTS=OFF
 }
 
 function install_xsimd {
-  wget_and_untar https://github.com/xtensor-stack/xsimd/archive/refs/tags/${XSIMD_VERSION}.tar.gz xsimd
+  wget_and_untar https://github.com/xtensor-stack/xsimd/archive/refs/tags/"${XSIMD_VERSION}".tar.gz xsimd
   cmake_install_dir xsimd
 }
 
 function install_simdjson {
-  wget_and_untar https://github.com/simdjson/simdjson/archive/refs/tags/v${SIMDJSON_VERSION}.tar.gz simdjson
-  cmake_install_dir simdjson
+  wget_and_untar https://github.com/simdjson/simdjson/archive/refs/tags/v"${SIMDJSON_VERSION}".tar.gz simdjson
+  cmake_install_dir simdjson -DSIMDJSON_SKIPUTF8VALIDATION=${SIMDJSON_SKIPUTF8VALIDATION}
 }
 
 function install_arrow {
-  wget_and_untar https://github.com/apache/arrow/archive/apache-arrow-${ARROW_VERSION}.tar.gz arrow
+  wget_and_untar https://github.com/apache/arrow/archive/apache-arrow-"${ARROW_VERSION}".tar.gz arrow
+  (
+    # Can be removed after an upgrade to Arrow 20.0.0
+    if [ -z "$VELOX_ARROW_CMAKE_PATCH" ]; then
+      # We need to set a different path when building the Dockerfile.
+      ABSOLUTE_SCRIPTDIR=$(realpath "$SCRIPT_DIR")
+      VELOX_ARROW_CMAKE_PATCH="$ABSOLUTE_SCRIPTDIR/../CMake/resolve_dependency_modules/arrow/cmake-compatibility.patch"
+    fi
+
+    cd "$DEPENDENCY_DIR"/arrow || exit 1
+    git apply "$VELOX_ARROW_CMAKE_PATCH"
+  ) || exit 1
+
   cmake_install_dir arrow/cpp \
     -DARROW_PARQUET=OFF \
     -DARROW_WITH_THRIFT=ON \
@@ -171,74 +223,84 @@ function install_arrow {
     -DARROW_RUNTIME_SIMD_LEVEL=NONE \
     -DARROW_WITH_UTF8PROC=OFF \
     -DARROW_TESTING=ON \
-    -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX} \
+    -DCMAKE_INSTALL_PREFIX="$INSTALL_PREFIX" \
     -DCMAKE_BUILD_TYPE=Release \
     -DARROW_BUILD_STATIC=ON \
-    -DBOOST_ROOT=${INSTALL_PREFIX}
+    -DBOOST_ROOT="$INSTALL_PREFIX" \
+    $EXTRA_ARROW_OPTIONS
 }
 
 function install_thrift {
-   wget_and_untar https://github.com/apache/thrift/archive/${THRIFT_VERSION}.tar.gz thrift
-
-   EXTRA_CXXFLAGS="-O3 -fPIC"
-   # Clang will generate warnings and they need to be suppressed, otherwise the build will fail.
-   if [[ ${USE_CLANG} != "false" ]]; then
-     EXTRA_CXXFLAGS="-O3 -fPIC -Wno-inconsistent-missing-override -Wno-unused-but-set-variable"
-   fi
-
-   CXX_FLAGS="$EXTRA_CXXFLAGS" cmake_install_dir thrift \
-     -DBUILD_SHARED_LIBS=OFF \
-     -DBUILD_COMPILER=ON \
-     -DBUILD_EXAMPLES=OFF \
-     -DBUILD_TUTORIALS=OFF \
-     -DCMAKE_DEBUG_POSTFIX= \
-     -DWITH_AS3=OFF \
-     -DWITH_CPP=ON \
-     -DWITH_C_GLIB=OFF \
-     -DWITH_JAVA=OFF \
-     -DWITH_JAVASCRIPT=OFF \
-     -DWITH_LIBEVENT=OFF \
-     -DWITH_NODEJS=OFF \
-     -DWITH_PYTHON=OFF \
-     -DWITH_QT5=OFF \
-     -DWITH_ZLIB=OFF \
-     ${EXTRA_ARROW_OPTIONS}
+  wget_and_untar https://github.com/apache/thrift/archive/"${THRIFT_VERSION}".tar.gz thrift
+
+  EXTRA_CXXFLAGS="-O3 -fPIC"
+  # Clang will generate warnings and they need to be suppressed, otherwise the build will fail.
+  if [[ ${USE_CLANG} != "false" ]]; then
+    EXTRA_CXXFLAGS="-O3 -fPIC -Wno-inconsistent-missing-override -Wno-unused-but-set-variable"
+  fi
+
+  CXX_FLAGS="$EXTRA_CXXFLAGS" cmake_install_dir thrift \
+    -DBUILD_SHARED_LIBS=OFF \
+    -DBUILD_COMPILER=ON \
+    -DBUILD_EXAMPLES=OFF \
+    -DBUILD_TUTORIALS=OFF \
+    -DCMAKE_DEBUG_POSTFIX= \
+    -DWITH_AS3=OFF \
+    -DWITH_CPP=ON \
+    -DWITH_C_GLIB=OFF \
+    -DWITH_JAVA=OFF \
+    -DWITH_JAVASCRIPT=OFF \
+    -DWITH_LIBEVENT=OFF \
+    -DWITH_NODEJS=OFF \
+    -DWITH_PYTHON=OFF \
+    -DWITH_QT5=OFF \
+    -DWITH_ZLIB=OFF
 }
 
 function install_stemmer {
-  wget_and_untar https://snowballstem.org/dist/libstemmer_c-${STEMMER_VERSION}.tar.gz stemmer
+  wget_and_untar https://snowballstem.org/dist/libstemmer_c-"${STEMMER_VERSION}".tar.gz stemmer
   (
-    cd ${DEPENDENCY_DIR}/stemmer
-    sed -i '/CPPFLAGS=-Iinclude/ s/$/ -fPIC/' Makefile
+    cd "${DEPENDENCY_DIR}"/stemmer || exit
+    sed -i='' '/CPPFLAGS=-Iinclude/ s/$/ -fPIC/' Makefile
     make clean && make "-j${NPROC}"
-    ${SUDO} cp libstemmer.a ${INSTALL_PREFIX}/lib/
-    ${SUDO} cp include/libstemmer.h ${INSTALL_PREFIX}/include/
+    ${SUDO} cp libstemmer.a "${INSTALL_PREFIX}"/lib/
+    ${SUDO} cp include/libstemmer.h "${INSTALL_PREFIX}"/include/
   )
 }
 
 function install_geos {
-  if [[ "$BUILD_GEOS" == "true" ]]; then
-    wget_and_untar https://github.com/libgeos/geos/archive/${GEOS_VERSION}.tar.gz geos
-    if [[ "$(uname)" == "Darwin" ]]; then
-      ABSOLUTE_SCRIPTDIR=$(realpath ${SCRIPTDIR})
-      (
-        # Adopted from the bundled patching needed for macOS.
-        cd "${DEPENDENCY_DIR}/geos" || exit 1
-        git apply "${ABSOLUTE_SCRIPTDIR}/../CMake/resolve_dependency_modules/geos/geos-cmakelists.patch"
-        git apply "${ABSOLUTE_SCRIPTDIR}/../CMake/resolve_dependency_modules/geos/geos-build.patch"
-      )
-    fi
+  if [[ $BUILD_GEOS == "true" ]]; then
+    wget_and_untar https://github.com/libgeos/geos/archive/"${GEOS_VERSION}".tar.gz geos
     cmake_install_dir geos -DBUILD_TESTING=OFF
   fi
 }
 
+function install_faiss_deps {
+  echo "Unsupported platform for faiss"
+}
+
+function install_faiss {
+  if [[ $BUILD_FAISS == "true" ]]; then
+    # Install OpenBLAS and libomp if not already installed
+    install_faiss_deps
+
+    wget_and_untar "https://github.com/facebookresearch/faiss/archive/refs/tags/v${FAISS_VERSION}.tar.gz" faiss
+    cmake_install_dir faiss \
+      -DFAISS_ENABLE_GPU=OFF \
+      -DFAISS_ENABLE_PYTHON=OFF \
+      -DFAISS_ENABLE_REMOTE=OFF \
+      -DFAISS_ENABLE_GPU_TESTS=OFF \
+      -DFAISS_ENABLE_BENCHMARKS=OFF
+  fi
+}
+
 # Adapters that can be installed.
 
 function install_aws_deps {
   local AWS_REPO_NAME="aws/aws-sdk-cpp"
 
-  github_checkout $AWS_REPO_NAME $AWS_SDK_VERSION --depth 1 --recurse-submodules
-  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"
+  github_checkout $AWS_REPO_NAME "$AWS_SDK_VERSION" --depth 1 --recurse-submodules
+  cmake_install_dir aws-sdk-cpp -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"
 }
 
 function install_minio {
@@ -253,32 +315,28 @@ function install_minio {
     echo "Unsupported Minio platform"
   fi
 
-  wget ${WGET_OPTIONS} https://dl.min.io/server/minio/release/${MINIO_OS}-${MINIO_ARCH}/archive/minio.RELEASE.${MINIO_VERSION} -O ${MINIO_BINARY_NAME}
-  chmod +x ./${MINIO_BINARY_NAME}
-  ${SUDO} mv ./${MINIO_BINARY_NAME} /usr/local/bin/
+  wget "${WGET_OPTS[@]}" https://dl.min.io/server/minio/release/"${MINIO_OS}"-${MINIO_ARCH}/archive/minio.RELEASE."${MINIO_VERSION}" -O "${MINIO_BINARY_NAME}"
+  chmod +x ./"${MINIO_BINARY_NAME}"
+  mkdir -p "$INSTALL_PREFIX"/bin/
+  ${SUDO} mv ./"${MINIO_BINARY_NAME}" "$INSTALL_PREFIX"/bin/
 }
 
-function install_gcs-sdk-cpp {
+function install_gcs_sdk_cpp {
   # Install gcs dependencies
   # https://github.com/googleapis/google-cloud-cpp/blob/main/doc/packaging.md#required-libraries
 
   # abseil-cpp
-  github_checkout abseil/abseil-cpp ${ABSEIL_VERSION} --depth 1
-  cmake_install \
-    -DABSL_BUILD_TESTING=OFF \
-    -DCMAKE_CXX_STANDARD=17 \
-    -DABSL_PROPAGATE_CXX_STD=ON \
-    -DABSL_ENABLE_INSTALL=ON
+  install_abseil
 
   # protobuf
-  github_checkout protocolbuffers/protobuf v${PROTOBUF_VERSION} --depth 1
-  cmake_install \
+  github_checkout protocolbuffers/protobuf v"${PROTOBUF_VERSION}" --depth 1
+  cmake_install_dir protobuf \
     -Dprotobuf_BUILD_TESTS=OFF \
     -Dprotobuf_ABSL_PROVIDER=package
 
   # grpc
-  github_checkout grpc/grpc ${GRPC_VERSION} --depth 1
-  cmake_install \
+  github_checkout grpc/grpc "${GRPC_VERSION}" --depth 1
+  cmake_install_dir grpc \
     -DgRPC_BUILD_TESTS=OFF \
     -DgRPC_ABSL_PROVIDER=package \
     -DgRPC_ZLIB_PROVIDER=package \
@@ -289,71 +347,95 @@ function install_gcs-sdk-cpp {
     -DgRPC_INSTALL=ON
 
   # crc32
-  github_checkout google/crc32c ${CRC32_VERSION} --depth 1
-  cmake_install \
+  github_checkout google/crc32c "${CRC32_VERSION}" --depth 1
+  cmake_install_dir crc32c \
     -DCRC32C_BUILD_TESTS=OFF \
     -DCRC32C_BUILD_BENCHMARKS=OFF \
     -DCRC32C_USE_GLOG=OFF
 
   # nlohmann json
-  github_checkout nlohmann/json ${NLOHMAN_JSON_VERSION} --depth 1
-  cmake_install \
+  github_checkout nlohmann/json "${NLOHMAN_JSON_VERSION}" --depth 1
+  cmake_install_dir json \
     -DJSON_BuildTests=OFF
 
   # google-cloud-cpp
-  github_checkout googleapis/google-cloud-cpp ${GOOGLE_CLOUD_CPP_VERSION} --depth 1
-  cmake_install \
+  github_checkout googleapis/google-cloud-cpp "${GOOGLE_CLOUD_CPP_VERSION}" --depth 1
+  cmake_install_dir google-cloud-cpp \
     -DGOOGLE_CLOUD_CPP_ENABLE_EXAMPLES=OFF \
     -DGOOGLE_CLOUD_CPP_ENABLE=storage
 }
 
-function install_azure-storage-sdk-cpp {
+function install_azure_storage_sdk_cpp {
   # 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_${AZURE_SDK_VERSION}
-  sed -i "s/set(VCPKG_COMMIT_STRING .*)/set(VCPKG_COMMIT_STRING $vcpkg_commit_id)/" cmake-modules/AzureVcpkg.cmake
+  github_checkout azure/azure-sdk-for-cpp azure-storage-files-datalake_"${AZURE_SDK_VERSION}"
+  pushd azure-sdk-for-cpp || exit
+  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
+    if [[ $openssl_version == 1.1.1* ]]; then
       openssl_version="1.1.1n"
     fi
-    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
+    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
   (
-    cd $azure_core_dir
-    cmake_install  -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF
+    cd $azure_core_dir || exit
+    cmake_install -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -DBUILD_SHARED_LIBS=OFF
   )
   # install azure-identity
   (
-    cd sdk/identity/azure-identity
-    cmake_install -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF
+    cd sdk/identity/azure-identity || exit
+    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=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF
+    cd sdk/storage/azure-storage-common || exit
+    cmake_install -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -DBUILD_SHARED_LIBS=OFF
   )
   # install azure-storage-blobs
   (
-    cd sdk/storage/azure-storage-blobs
-    cmake_install -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_SHARED_LIBS=OFF
+    cd sdk/storage/azure-storage-blobs || exit
+    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
+    cd sdk/storage/azure-storage-files-datalake || exit
+    cmake_install -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -DBUILD_SHARED_LIBS=OFF
   )
+  popd || exit
 }
 
 function install_hdfs_deps {
   # Dependencies for Hadoop testing
-  wget_and_untar https://archive.apache.org/dist/hadoop/common/hadoop-${HADOOP_VERSION}/hadoop-${HADOOP_VERSION}.tar.gz hadoop
-  cp -a ${DEPENDENCY_DIR}/hadoop /usr/local/
-  wget ${WGET_OPTIONS} -P /usr/local/hadoop/share/hadoop/common/lib/ https://repo1.maven.org/maven2/junit/junit/4.11/junit-4.11.jar
+  wget_and_untar https://dlcdn.apache.org/hadoop/common/hadoop-"${HADOOP_VERSION}"/hadoop-"${HADOOP_VERSION}".tar.gz hadoop
+  cp -a "${DEPENDENCY_DIR}"/hadoop "$INSTALL_PREFIX"
+  wget "${WGET_OPTS[@]}" -P "$INSTALL_PREFIX"/hadoop/share/hadoop/common/lib/ https://repo1.maven.org/maven2/junit/junit/4.11/junit-4.11.jar
+}
+
+function install_uv {
+  if command -v uv >/dev/null 2>&1; then
+    echo "uv is already installed."
+  else
+    echo "Installing uv..."
+
+    export UV_TOOL_BIN_DIR="${UV_TOOL_BIN_DIR:-$INSTALL_PREFIX/bin}"
+    export UV_INSTALL_DIR=${UV_INSTALL_DIR:-"$UV_TOOL_BIN_DIR"}
+
+    curl -LsSf https://astral.sh/uv/install.sh | sh
+    uv tool update-shell
+  fi
+}
+
+function uv_install {
+  uv tool install "$@" || {
+    ret=$?
+    # exit code 2 means the binary already exists, so we can ignore that
+    [ "$ret" -eq 2 ] || exit "$ret"
+  }
 }
diff --git a/scripts/setup-fedora.sh b/scripts/setup-fedora.sh
new file mode 100755
index 000000000000..80d958f19a4b
--- /dev/null
+++ b/scripts/setup-fedora.sh
@@ -0,0 +1,132 @@
+#!/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.
+# shellcheck source-path=SCRIPT_DIR
+
+# This script documents setting up a Fedora 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-fedora.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.
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPT_DIR"/setup-centos9.sh
+
+# Install packages required for build.
+function install_build_prerequisites {
+  dnf update -y
+  dnf_install dnf-plugins-core # For ccache, ninja
+  dnf_install autoconf automake ccache git g++-14 libtool \
+    ninja-build python3-pip python3-devel wget which
+
+  # Set up gcc alternatives
+  sudo alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 140 \
+    --slave /usr/bin/g++ g++ /usr/bin/g++-14 \
+    --slave /usr/bin/gcov gcov /usr/bin/gcov-14 \
+    --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-14 \
+    --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-14 \
+    --slave /usr/bin/gcc-nm gcc-nm /usr/bin/gcc-nm-14
+
+  install_uv
+  uv_install cmake
+
+  if [[ ${USE_CLANG} != "false" ]]; then
+    install_clang15
+  fi
+}
+
+function install_velox_deps_from_dnf {
+  dnf_install \
+    bison boost-devel c-ares-devel curl-devel double-conversion-devel \
+    elfutils-libelf-devel flex fmt-devel gflags-devel glog-devel gmock-devel \
+    gtest-devel libdwarf-devel libevent-devel libicu-devel \
+    libsodium-devel libzstd-devel lz4-devel openssl-devel-engine \
+    re2-devel snappy-devel thrift-devel xxhash-devel zlib-devel grpc-devel grpc-plugins
+
+  install_faiss_deps
+}
+
+function install_velox_deps {
+  run_and_time install_velox_deps_from_dnf
+  run_and_time install_gcs_sdk_cpp #grpc, abseil, protobuf
+  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_stemmer
+  run_and_time install_arrow
+  run_and_time install_xsimd    # to new in fedora repos
+  run_and_time install_simdjson # to new in fedora repos
+  run_and_time install_geos     # to new in fedora repos
+  run_and_time install_faiss
+}
+
+(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 gcc 14
+      export CXX=/usr/bin/gcc-14
+      export CXX=/usr/bin/g++-14
+      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 gcc 14
+      export CXX=/usr/bin/gcc-14
+      export CXX=/usr/bin/g++-14
+      set -u
+    fi
+    install_velox_deps
+    # BUILD_TESTING requires grpc
+    dnf_install grpc
+    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-helper-functions.sh b/scripts/setup-helper-functions.sh
index d5867e736783..a50fb02ae0ec 100755
--- a/scripts/setup-helper-functions.sh
+++ b/scripts/setup-helper-functions.sh
@@ -23,10 +23,16 @@ NPROC=${BUILD_THREADS:-$(getconf _NPROCESSORS_ONLN)}
 
 CURL_OPTIONS=${CURL_OPTIONS:-""}
 CMAKE_OPTIONS=${CMAKE_OPTIONS:-""}
+ARM_BUILD_TARGET=${ARM_BUILD_TARGET:-"local"}
 
 function run_and_time {
-  time "$@" || (echo "Failed to run $* ." ; exit 1 )
-  { echo "+ Finished running $*"; } 2> /dev/null
+  time "$@"
+  if [ $? -ne 0 ]; then
+    echo "Failed to run $* ."
+    exit 1
+  else
+    echo "+ Finished running $*" 2>/dev/null
+  fi
 }
 
 function prompt {
@@ -34,14 +40,14 @@ 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
+      [[ -z ${input} ]] && read input
+      if [[ ${input} == "Y" || ${input} == "y" || ${input} == "" ]]; then
         return 0
-      elif [[ "${input}" == "N" || "${input}" == "n" ]]; then
+      elif [[ ${input} == "N" || ${input} == "n" ]]; then
         return 1
       fi
     done
-  ) 2> /dev/null
+  ) 2>/dev/null
 }
 
 function github_checkout {
@@ -49,10 +55,11 @@ function github_checkout {
   shift
   local VERSION=$1
   shift
-  local GIT_CLONE_PARAMS=$@
-  local DIRNAME=$(basename $REPO)
+  local GIT_CLONE_PARAMS=("$@")
+  local DIRNAME
+  DIRNAME=$(basename "$REPO")
   SUDO="${SUDO:-""}"
-  cd "${DEPENDENCY_DIR}"
+  cd "${DEPENDENCY_DIR}" || exit
   if [ -z "${DIRNAME}" ]; then
     echo "Failed to get repo name from ${REPO}"
     exit 1
@@ -61,9 +68,8 @@ function github_checkout {
     ${SUDO} rm -rf "${DIRNAME}"
   fi
   if [ ! -d "${DIRNAME}" ]; then
-    git clone -q -b $VERSION $GIT_CLONE_PARAMS "https://github.com/${REPO}.git"
+    git clone -q -b "$VERSION" "${GIT_CLONE_PARAMS[@]}" "https://github.com/${REPO}.git"
   fi
-  cd "${DIRNAME}"
 }
 
 # get_cxx_flags [$CPU_ARCH]
@@ -81,130 +87,167 @@ function github_checkout {
 # CXX_FLAGS=$(get_cxx_flags) or
 # CXX_FLAGS=$(get_cxx_flags "avx")
 
+# shellcheck disable=SC2120
 function get_cxx_flags {
   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
+  local OS
+  OS=$(uname)
+  local MACHINE
+  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
+        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
+        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"
+  "arm64")
+    echo -n "-mcpu=apple-m1+crc"
     ;;
 
-    "avx")
-      echo -n "-mavx2 -mfma -mavx -mf16c -mlzcnt  -mbmi2"
+  "avx")
+    echo -n "-mavx2 -mfma -mavx -mf16c -mlzcnt  -mbmi2"
     ;;
 
-    "sse")
-      echo -n "-msse4.2 "
+  "sse")
+    echo -n "-msse4.2 "
     ;;
 
-    "aarch64")
-      # 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"
-      Neoverse_V2="d4f"
-      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 "
-        elif [ "$ARM_CPU_PRODUCT" = "$Neoverse_N2" ]; then
-          echo -n "-mcpu=neoverse-n2 "
-        elif [ "$ARM_CPU_PRODUCT" = "$Neoverse_V1" ]; then
-          echo -n "-mcpu=neoverse-v1 "
-        elif [ "$ARM_CPU_PRODUCT" = "$Neoverse_V2" ]; then
-          # Read the JEDEC JEP-106 manufacturer ID to distinguish different Neoverse V2 cores
-          # https://developer.arm.com/documentation/ka001301/latest/
-          SOC_ID_FILE="/sys/devices/soc0/soc_id"
-          GRACE_SOC_ID="jep106:036b:0241"
-          # Check for NVIDIA Grace which has various extensions
-          if [ -f "$SOC_ID_FILE" ] && [ "$(cat $SOC_ID_FILE)" = "$GRACE_SOC_ID" ]; then
-            echo -n "-mcpu=neoverse-v2+crypto+sha3+sm4+sve2-aes+sve2-sha3+sve2-sm4"
-          else
-            echo -n "-mcpu=neoverse-v2 "
-          fi
+  "aarch64")
+    # 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"
+    Neoverse_V2="d4f"
+    if [ -f "$ARM_CPU_FILE" ] && [ "$ARM_BUILD_TARGET" = "local" ]; 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 "
+      elif [ "$ARM_CPU_PRODUCT" = "$Neoverse_N2" ]; then
+        echo -n "-mcpu=neoverse-n2 "
+      elif [ "$ARM_CPU_PRODUCT" = "$Neoverse_V1" ]; then
+        echo -n "-mcpu=neoverse-v1 "
+      elif [ "$ARM_CPU_PRODUCT" = "$Neoverse_V2" ]; then
+        # Read the JEDEC JEP-106 manufacturer ID to distinguish different Neoverse V2 cores
+        # https://developer.arm.com/documentation/ka001301/latest/
+        SOC_ID_FILE="/sys/devices/soc0/soc_id"
+        GRACE_SOC_ID="jep106:036b:0241"
+        # Check for NVIDIA Grace which has various extensions
+        if [ -f "$SOC_ID_FILE" ] && [ "$(cat $SOC_ID_FILE)" = "$GRACE_SOC_ID" ]; then
+          echo -n "-mcpu=neoverse-v2+crypto+sha3+sm4+sve2-aes+sve2-sha3+sve2-sm4"
         else
-          echo -n "-march=armv8-a+crc+crypto "
+          echo -n "-mcpu=neoverse-v2 "
         fi
       else
-        echo -n ""
+        echo -n "-march=armv8-a+crc+crypto "
       fi
+    else
+      echo -n "-march=armv8-a+crc+crypto "
+    fi
     ;;
   *)
     echo -n "Architecture not supported!"
+    ;;
   esac
 
 }
 
+detect_sve_flags() {
+  if grep -q "sve" /proc/cpuinfo; then
+    ARCH_FLAGS="-march=armv8-a+sve"
+    SVE_VECTOR_BITS=$(
+      gcc $ARCH_FLAGS -o detect_sve_vector -xc++ - -lstdc++ <<EOF
+      #include <arm_sve.h>
+      #include <iostream>
+      int main() {
+          std::cout << svcntb() * 8 << std::endl;
+          return 0;
+      }
+EOF
+      ./detect_sve_vector 2>/dev/null
+    )
+
+    if [ "$SVE_VECTOR_BITS" ]; then
+      echo "-msve-vector-bits=$SVE_VECTOR_BITS -DSVE_BITS=$SVE_VECTOR_BITS"
+    fi
+
+    rm -f detect_sve_vector
+  fi
+}
+
+if [[ ${BASH_SOURCE[0]} == "${0}" && $1 == "detect_sve_flags" ]]; then
+  detect_sve_flags
+fi
+
 function wget_and_untar {
   local URL=$1
   local DIR=$2
   mkdir -p "${DEPENDENCY_DIR}"
-  pushd "${DEPENDENCY_DIR}"
+  pushd "${DEPENDENCY_DIR}" || exit
   SUDO="${SUDO:-""}"
   if [ -d "${DIR}" ]; then
     if prompt "${DIR} already exists. Delete?"; then
       ${SUDO} rm -rf "${DIR}"
     else
-      popd
+      popd || exit
       return
     fi
   fi
   mkdir -p "${DIR}"
-  pushd "${DIR}"
-  curl ${CURL_OPTIONS} -L "${URL}" > $2.tar.gz
-  tar -xz --strip-components=1 -f $2.tar.gz
-  popd
-  popd
+  pushd "${DIR}" || exit
+  # Use ${VAR:+"$VAR"} pattern to only include CURL_OPTIONS if it's not empty
+  # as curl >=8.6.0 rejects empty arguments
+  curl ${CURL_OPTIONS:+${CURL_OPTIONS}} -L "${URL}" -o "$2".tar.gz
+  tar -xz --strip-components=1 --no-same-owner -f "$2".tar.gz
+  popd || exit
+  popd || exit
 }
 
 function cmake_install_dir {
-  pushd "${DEPENDENCY_DIR}/$1"
+  pushd "${DEPENDENCY_DIR}/$1" || exit
   # remove the directory argument
   shift
-  cmake_install $@
-  popd
+  cmake_install "$@"
+  popd || exit
 }
 
 function cmake_install {
-  local NAME=$(basename "$(pwd)")
+  local NAME
+  NAME=$(basename "$(pwd)")
   local BINARY_DIR=_build
   SUDO="${SUDO:-""}"
   if [ -d "${BINARY_DIR}" ]; then
@@ -222,8 +265,9 @@ function cmake_install {
   COMPILER_FLAGS+=${EXTRA_PKG_CXXFLAGS}
 
   # CMAKE_POSITION_INDEPENDENT_CODE is required so that Velox can be built into dynamic libraries \
-  cmake -Wno-dev ${CMAKE_OPTIONS} -B"${BINARY_DIR}" \
+  cmake -Wno-dev "${CMAKE_OPTIONS}" -B"${BINARY_DIR}" \
     -GNinja \
+    -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
     -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
     "${INSTALL_PREFIX+-DCMAKE_PREFIX_PATH=}${INSTALL_PREFIX-}" \
     "${INSTALL_PREFIX+-DCMAKE_INSTALL_PREFIX=}${INSTALL_PREFIX-}" \
@@ -231,6 +275,9 @@ function cmake_install {
     -DBUILD_TESTING=OFF \
     "$@"
   # Exit if the build fails.
-  cmake --build "${BINARY_DIR}" "-j ${NPROC}" || { echo 'build failed' ; exit 1; }
+  cmake --build "${BINARY_DIR}" "-j ${NPROC}" || {
+    echo 'build failed'
+    exit 1
+  }
   ${SUDO} cmake --install "${BINARY_DIR}"
 }
diff --git a/scripts/setup-macos.sh b/scripts/setup-macos.sh
index ceae1e5eed22..a10295a372c7 100755
--- a/scripts/setup-macos.sh
+++ b/scripts/setup-macos.sh
@@ -12,6 +12,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.
+# shellcheck source-path=SCRIPT_DIR
 
 # This script documents setting up a macOS host for Velox
 # development.  Running it should make you ready to compile.
@@ -28,26 +29,28 @@
 set -e # Exit on error.
 set -x # Print commands that are executed.
 
-SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
 export INSTALL_PREFIX=${INSTALL_PREFIX:-"$(pwd)/deps-install"}
-source $SCRIPTDIR/setup-common.sh
-PYTHON_VENV=${PYTHON_VENV:-"${SCRIPTDIR}/../.venv"}
+source "$SCRIPT_DIR"/setup-common.sh
+PYTHON_VENV=${PYTHON_VENV:-"${SCRIPT_DIR}/../.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 "
+OS_CXXFLAGS=" -isystem $(brew --prefix)/include "
+export OS_CXXFLAGS
+export CMAKE_POLICY_VERSION_MINIMUM="3.5"
 
 DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)}
-MACOS_VELOX_DEPS="bison flex gflags glog googletest icu4c libevent libsodium lz4 lzo openssl protobuf@21 simdjson snappy xz zstd"
-MACOS_BUILD_DEPS="ninja cmake ccache"
+MACOS_VELOX_DEPS="bison flex gflags glog googletest icu4c libevent libsodium lz4 openssl protobuf@21 simdjson snappy xz xxhash zstd"
+
+MACOS_BUILD_DEPS="ninja cmake"
 
 SUDO="${SUDO:-""}"
 
 function update_brew {
   DEFAULT_BREW_PATH=/usr/local/bin/brew
-  if [ `arch` == "arm64" ] ;
-    then
-      DEFAULT_BREW_PATH=$(which brew) ;
+  if [ "$(arch)" == "arm64" ]; then
+    DEFAULT_BREW_PATH=$(which brew)
   fi
   BREW_PATH=${BREW_PATH:-$DEFAULT_BREW_PATH}
   $BREW_PATH update --auto-update --verbose
@@ -56,42 +59,47 @@ function update_brew {
 
 function install_from_brew {
   pkg=$1
-  if [[ "${pkg}" =~ ^([0-9a-z-]*):([0-9](\.[0-9\])*)$ ]];
-  then
+  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 )
+    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 )
+    (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_BUILD_DEPS}
-  do
-    install_from_brew ${pkg}
+  for pkg in ${MACOS_BUILD_DEPS}; do
+    install_from_brew "${pkg}"
   done
-  if [ ! -f ${PYTHON_VENV}/pyvenv.cfg ]; then
+  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
+    python3 -m venv "${PYTHON_VENV}"
   fi
+  source "${PYTHON_VENV}"/bin/activate
+  pip3 install regex pyyaml
+
+  # Install ccache
+  curl -L https://github.com/ccache/ccache/releases/download/v"${CCACHE_VERSION}"/ccache-"${CCACHE_VERSION}"-darwin.tar.gz -o ccache.tar.gz
+  tar -xf ccache.tar.gz
+  $SUDO mkdir -p "$INSTALL_PREFIX"/bin
+  $SUDO mv ccache-"${CCACHE_VERSION}"-darwin/ccache "$INSTALL_PREFIX"/bin
+  rm -rf ccache-"${CCACHE_VERSION}"-darwin ccache.tar.gz
 }
 
 function install_velox_deps_from_brew {
-  for pkg in ${MACOS_VELOX_DEPS}
-  do
-    install_from_brew ${pkg}
+  for pkg in ${MACOS_VELOX_DEPS}; do
+    install_from_brew "${pkg}"
   done
 }
 
@@ -103,11 +111,11 @@ function install_s3 {
 }
 
 function install_gcs {
-  install_gcs-sdk-cpp
+  install_gcs_sdk_cpp
 }
 
 function install_abfs {
-  install_azure-storage-sdk-cpp
+  install_azure_storage_sdk_cpp
 }
 
 function install_hdfs {
@@ -122,6 +130,48 @@ function install_adapters {
   run_and_time install_hdfs
 }
 
+function install_duckdb_clang {
+  clang_major_version=$(echo | clang -dM -E - | grep __clang_major__ | awk '{print $3}')
+  # Clang17 requires this. See issue #13215.
+  if [ "${clang_major_version}" -ge 17 ]; then
+    EXTRA_PKG_CXXFLAGS=" -Wno-missing-template-arg-list-after-template-kw" install_duckdb
+  else
+    install_duckdb
+  fi
+}
+
+function install_faiss_deps {
+  brew install openblas
+  brew install libomp
+}
+
+function install_faiss {
+  if [[ $BUILD_FAISS == "true" ]]; then
+    # Install OpenBLAS and libomp if not already installed
+    install_faiss_deps
+
+    wget_and_untar "https://github.com/facebookresearch/faiss/archive/refs/tags/v${FAISS_VERSION}.tar.gz" faiss
+
+    local cmake_args
+    cmake_args=(
+      -DFAISS_ENABLE_GPU=OFF
+      -DFAISS_ENABLE_PYTHON=OFF
+      -DFAISS_ENABLE_REMOTE=OFF
+      -DFAISS_ENABLE_GPU_TESTS=OFF
+      -DFAISS_ENABLE_BENCHMARKS=OFF
+      -DFAISS_ENABLE_GPU=OFF
+      -DFAISS_ENABLE_MKL=OFF
+    )
+
+    local libomp_prefix
+    libomp_prefix=$(brew --prefix libomp)
+    cmake_args+=(
+      "-DCMAKE_PREFIX_PATH=${libomp_prefix}"
+    )
+    cmake_install_dir faiss "${cmake_args[@]}"
+  fi
+}
+
 function install_velox_deps {
   run_and_time install_velox_deps_from_brew
   run_and_time install_ranges_v3
@@ -136,14 +186,17 @@ function install_velox_deps {
   run_and_time install_mvfst
   run_and_time install_fbthrift
   run_and_time install_xsimd
-  run_and_time install_duckdb
   run_and_time install_stemmer
-  run_and_time install_thrift
+  # We allow arrow to bundle thrift on MacOS due to issues with bison and flex.
+  # See https://github.com/facebook/fbthrift/pull/317 for an explanation.
+  # run_and_time install_thrift
   run_and_time install_arrow
+  run_and_time install_duckdb_clang
   run_and_time install_geos
+  run_and_time install_faiss
 }
 
-(return 2> /dev/null) && return # If script was sourced, don't run commands.
+(return 2>/dev/null) && return # If script was sourced, don't run commands.
 
 (
   update_brew
@@ -160,7 +213,7 @@ function install_velox_deps {
       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\""
+    echo 'All deps for Velox installed! Now try "make"'
   fi
 )
 
diff --git a/scripts/setup-manylinux.sh b/scripts/setup-manylinux.sh
index b82db9263fbb..424db964cce3 100755
--- a/scripts/setup-manylinux.sh
+++ b/scripts/setup-manylinux.sh
@@ -12,6 +12,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.
+# shellcheck source-path=SCRIPT_DIR
 
 # This script documents setting up a Centos9 host for Velox
 # development.  Running it should make you ready to compile.
@@ -28,27 +29,16 @@
 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=${BUILD_THREADS:-$(getconf _NPROCESSORS_ONLN)}
-export CXXFLAGS=$(get_cxx_flags) # Used by boost.
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPT_DIR"/setup-common.sh
+CXXFLAGS=$(get_cxx_flags) # Used by boost.
+export CXXFLAGS
 export CFLAGS=${CXXFLAGS//"-std=c++17"/} # Used by LZO.
-CMAKE_BUILD_TYPE="${BUILD_TYPE:-Release}"
-VELOX_BUILD_SHARED=${VELOX_BUILD_SHARED:-"OFF"} #Build folly and gflags shared for use in libvelox.so.
-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="v2025.04.28.00"
-FMT_VERSION="10.1.1"
-BOOST_VERSION="boost-1.84.0"
-THRIFT_VERSION="v0.21.0"
-# Note: when updating arrow check if thrift needs an update as well.
-ARROW_VERSION="15.0.0"
-STEMMER_VERSION="2.2.0"
-DUCKDB_VERSION="v0.8.1"
-FAST_FLOAT_VERSION="v8.0.2"
+export THRIFT_VERSION="v0.21.0"
 
 # CMake 4.0 removed support for cmake minimums of <=3.5 and will fail builds, this overrides it
 export CMAKE_POLICY_VERSION_MINIMUM="3.5"
@@ -70,7 +60,6 @@ function install_build_prerequisites {
   dnf_install ninja-build cmake ccache gcc-toolset-12 git wget which
   dnf_install autoconf automake python3-devel pip libtool
 
-
   if [[ ${USE_CLANG} != "false" ]]; then
     install_clang15
   fi
@@ -81,7 +70,7 @@ 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 xxhash-devel
+    libsodium-devel zlib-devel gtest-devel gmock-devel xxhash-devel
 }
 
 function install_conda {
@@ -91,187 +80,36 @@ function 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
+  wget_and_untar https://github.com/gflags/gflags/archive/"${GFLAGS_VERSION}".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 CXXFLAGS="-fPIC" --prefix=${INSTALL_PREFIX}
-    make "-j${NPROC}"
-    make install
-    ldconfig
-  )
-}
-
-function install_fizz {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, lin) if the selection is not consistent across users of folly.
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  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_fast_float {
-  wget_and_untar https://github.com/fastfloat/fast_float/archive/refs/tags/${FAST_FLOAT_VERSION}.tar.gz fast_float
-  cmake_install_dir fast_float -DBUILD_TESTS=OFF
-}
-
-function install_folly {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, lin) if the selection is not consistent across users of folly.
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  wget_and_untar https://github.com/facebook/folly/archive/refs/tags/${FB_OS_VERSION}.tar.gz folly
-  cmake_install_dir folly -DBUILD_SHARED_LIBS="$VELOX_BUILD_SHARED" -DBUILD_TESTS=OFF -DFOLLY_HAVE_INT128_T=ON
-}
-
-function install_wangle {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, lin) if the selection is not consistent across users of folly.
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  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 {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, lin) if the selection is not consistent across users of folly.
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  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 {
-  # Folly Portability.h being used to decide whether or not support coroutines
-  # causes issues (build, lin) if the selection is not consistent across users of folly.
-  EXTRA_PKG_CXXFLAGS=" -DFOLLY_CFG_NO_COROUTINES"
-  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/${DUCKDB_VERSION}.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_stemmer {
-  wget_and_untar https://snowballstem.org/dist/libstemmer_c-${STEMMER_VERSION}.tar.gz stemmer
-  (
-    cd ${DEPENDENCY_DIR}/stemmer
-    sed -i '/CPPFLAGS=-Iinclude/ s/$/ -fPIC/' Makefile
-    make clean && make "-j${NPROC}"
-    ${SUDO} cp libstemmer.a ${INSTALL_PREFIX}/lib/
-    ${SUDO} cp include/libstemmer.h ${INSTALL_PREFIX}/include/
-  )
-}
-
-function install_thrift {
-  wget_and_untar https://github.com/apache/thrift/archive/${THRIFT_VERSION}.tar.gz thrift
-
-  EXTRA_CXXFLAGS="-O3 -fPIC"
-  # Clang will generate warnings and they need to be suppressed, otherwise the build will fail.
-  if [[ ${USE_CLANG} != "false" ]]; then
-    EXTRA_CXXFLAGS="-O3 -fPIC -Wno-inconsistent-missing-override -Wno-unused-but-set-variable"
-  fi
-
-  CXX_FLAGS="$EXTRA_CXXFLAGS" cmake_install_dir thrift \
-    -DBUILD_SHARED_LIBS=OFF \
-    -DBUILD_COMPILER=OFF \
-    -DBUILD_EXAMPLES=OFF \
-    -DBUILD_TUTORIALS=OFF \
-    -DCMAKE_DEBUG_POSTFIX= \
-    -DWITH_AS3=OFF \
-    -DWITH_CPP=ON \
-    -DWITH_C_GLIB=OFF \
-    -DWITH_JAVA=OFF \
-    -DWITH_JAVASCRIPT=OFF \
-    -DWITH_LIBEVENT=OFF \
-    -DWITH_NODEJS=OFF \
-    -DWITH_PYTHON=OFF \
-    -DWITH_QT5=OFF \
-    -DWITH_ZLIB=OFF
-}
-
-function install_arrow {
-  wget_and_untar https://github.com/apache/arrow/archive/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 \
-    -DBOOST_ROOT=${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
-  local dashed="$(echo $1 | tr '.' '-')"
-  dnf install -y cuda-nvcc-$dashed cuda-cudart-devel-$dashed cuda-nvrtc-devel-$dashed cuda-driver-devel-$dashed
+  local arch
+  arch=$(uname -m)
+  local repo_url
+
+  if [[ $arch == "x86_64" ]]; then
+    repo_url="https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo"
+  elif [[ $arch == "aarch64" ]]; then
+    # Using SBSA (Server Base System Architecture) repository for ARM64 servers
+    repo_url="https://developer.download.nvidia.com/compute/cuda/repos/rhel8/sbsa/cuda-rhel8.repo"
+  else
+    echo "Unsupported architecture: $arch" >&2
+    return 1
+  fi
+
+  dnf config-manager --add-repo "$repo_url"
+  local dashed
+  dashed="$(echo "$1" | tr '.' '-')"
+  dnf install -y cuda-nvcc-"$dashed" cuda-cudart-devel-"$dashed" cuda-nvrtc-devel-"$dashed" cuda-driver-devel-"$dashed" libnvjitlink-devel-"$dashed"
 }
 
 function install_velox_deps {
   run_and_time install_velox_deps_from_dnf
   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
@@ -288,7 +126,7 @@ function install_velox_deps {
   run_and_time install_arrow
 }
 
-(return 2> /dev/null) && return # If script was sourced, don't run commands.
+(return 2>/dev/null) && return # If script was sourced, don't run commands.
 
 (
   if [[ $# -ne 0 ]]; then
diff --git a/scripts/setup-ubuntu.sh b/scripts/setup-ubuntu.sh
index 33711884bc8e..221fe26853d1 100755
--- a/scripts/setup-ubuntu.sh
+++ b/scripts/setup-ubuntu.sh
@@ -12,6 +12,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.
+# shellcheck source-path=SCRIPT_DIR
+# shellcheck disable=SC2076
 
 # This script documents setting up a Ubuntu host for Velox
 # development.  Running it should make you ready to compile.
@@ -27,15 +29,15 @@
 
 # Minimal setup for Ubuntu 22.04.
 set -eufx -o pipefail
-SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
-source $SCRIPTDIR/setup-common.sh
+SCRIPT_DIR=$(dirname "${BASH_SOURCE[0]}")
+source "$SCRIPT_DIR"/setup-common.sh
 
 SUDO="${SUDO:-"sudo --preserve-env"}"
 USE_CLANG="${USE_CLANG:-false}"
 export INSTALL_PREFIX=${INSTALL_PREFIX:-"/usr/local"}
 DEPENDENCY_DIR=${DEPENDENCY_DIR:-$(pwd)/deps-download}
 VERSION=$(cat /etc/os-release | grep VERSION_ID)
-PYTHON_VENV=${PYTHON_VENV:-"${SCRIPTDIR}/../.venv"}
+PYTHON_VENV=${PYTHON_VENV:-"${SCRIPT_DIR}/../.venv"}
 
 # On Ubuntu 20.04 dependencies need to be built using gcc11.
 # On Ubuntu 22.04 gcc11 is already the system gcc installed.
@@ -44,6 +46,10 @@ if [[ ${VERSION} =~ "20.04" ]]; then
   export CXX=/usr/bin/g++-11
 fi
 
+if lscpu | grep -q "sve"; then
+  $SUDO apt install -y gcc-12 g++-12
+fi
+
 function install_clang15 {
   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."
@@ -82,13 +88,8 @@ function install_build_prerequisites {
     libtool \
     wget
 
-  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;
-  # Install to /usr/local to make it available to all users.
-  ${SUDO} pip3 install cmake==3.28.3
+  install_uv
+  uv_install cmake==3.30.4
 
   install_gcc11_if_needed
 
@@ -98,14 +99,6 @@ function install_build_prerequisites {
 
 }
 
-# Install packages required to fix format
-function install_format_prerequisites {
-  pip3 install regex
-  ${SUDO} apt install -y \
-    clang-format \
-    cmake-format
-}
-
 # Install packages required for build.
 function install_velox_deps_from_apt {
   ${SUDO} apt update
@@ -126,7 +119,6 @@ function install_velox_deps_from_apt {
     libre2-dev \
     libsnappy-dev \
     libsodium-dev \
-    liblzo2-dev \
     libelf-dev \
     libdwarf-dev \
     bison \
@@ -138,7 +130,7 @@ function install_velox_deps_from_apt {
 
 function install_conda {
   MINICONDA_PATH="${HOME:-/opt}/miniconda-for-velox"
-  if [ -e ${MINICONDA_PATH} ]; then
+  if [ -e "${MINICONDA_PATH}" ]; then
     echo "File or directory already exists: ${MINICONDA_PATH}"
     return
   fi
@@ -149,25 +141,56 @@ function install_conda {
   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
+    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_cuda {
   # See https://developer.nvidia.com/cuda-downloads
+  local arch
+  arch=$(uname -m)
+  local os_ver
+
+  if [[ ${VERSION} =~ "24.04" ]]; then
+    os_ver="ubuntu2404"
+  elif [[ ${VERSION} =~ "22.04" ]]; then
+    os_ver="ubuntu2204"
+  elif [[ ${VERSION} =~ "20.04" ]]; then
+    os_ver="ubuntu2004"
+  else
+    echo "Unsupported Ubuntu version: ${VERSION}" >&2
+    return 1
+  fi
+
+  local cuda_repo
+  if [[ $arch == "x86_64" ]]; then
+    cuda_repo="${os_ver}/x86_64"
+  elif [[ $arch == "aarch64" ]]; then
+    cuda_repo="${os_ver}/sbsa"
+  else
+    echo "Unsupported architecture: $arch" >&2
+    return 1
+  fi
+
   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
+    wget https://developer.download.nvidia.com/compute/cuda/repos/${cuda_repo}/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
-  local dashed="$(echo $1 | tr '.' '-')"
+
+  local dashed
+  dashed="$(echo "$1" | tr '.' '-')"
+
   $SUDO apt install -y \
-    cuda-compat-$dashed \
-    cuda-driver-dev-$dashed \
-    cuda-minimal-build-$dashed \
-    cuda-nvrtc-dev-$dashed
+    cuda-compat-"$dashed" \
+    cuda-driver-dev-"$dashed" \
+    cuda-minimal-build-"$dashed" \
+    cuda-nvrtc-dev-"$dashed" \
+    libcufile-dev-"$dashed" \
+    libnvjitlink-dev-"$dashed" \
+    libnuma1
 }
 
 function install_s3 {
@@ -179,18 +202,18 @@ function install_s3 {
 
 function install_gcs {
   # Dependencies of GCS, probably a workaround until the docker image is rebuilt
-  apt install -y --no-install-recommends libc-ares-dev libcurl4-openssl-dev
-  install_gcs-sdk-cpp
+  ${SUDO} apt install -y --no-install-recommends libc-ares-dev libcurl4-openssl-dev
+  install_gcs_sdk_cpp
 }
 
 function install_abfs {
   # Dependencies of Azure Storage Blob cpp
-  apt install -y openssl libxml2-dev
-  install_azure-storage-sdk-cpp
+  ${SUDO} apt install -y openssl libxml2-dev
+  install_azure_storage_sdk_cpp
 }
 
 function install_hdfs {
-  apt install -y --no-install-recommends libxml2-dev libgsasl7-dev uuid-dev openjdk-8-jdk
+  ${SUDO} apt install -y --no-install-recommends libxml2-dev libgsasl7-dev uuid-dev openjdk-8-jdk
   install_hdfs_deps
 }
 
@@ -201,6 +224,10 @@ function install_adapters {
   run_and_time install_hdfs
 }
 
+function install_faiss_deps {
+  ${SUDO} apt-get install -y libopenblas-dev libomp-dev
+}
+
 function install_velox_deps {
   run_and_time install_velox_deps_from_apt
   run_and_time install_fmt
@@ -220,15 +247,15 @@ function install_velox_deps {
   run_and_time install_xsimd
   run_and_time install_simdjson
   run_and_time install_geos
+  run_and_time install_faiss
 }
 
 function install_apt_deps {
   install_build_prerequisites
-  install_format_prerequisites
   install_velox_deps_from_apt
 }
 
-(return 2> /dev/null) && return # If script was sourced, don't run commands.
+(return 2>/dev/null) && return # If script was sourced, don't run commands.
 
 (
   if [[ ${USE_CLANG} != "false" ]]; then
diff --git a/scripts/setup-versions.sh b/scripts/setup-versions.sh
index 836a97c3c7c7..685794a88160 100755
--- a/scripts/setup-versions.sh
+++ b/scripts/setup-versions.sh
@@ -1,4 +1,5 @@
 #!/bin/bash
+# shellcheck disable=SC2034
 # Copyright (c) Facebook, Inc. and its affiliates.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,28 +20,28 @@
 
 # Build dependencies versions.
 FB_OS_VERSION="v2025.04.28.00"
-FMT_VERSION="10.1.1"
+FMT_VERSION="11.2.0"
 BOOST_VERSION="boost-1.84.0"
 ARROW_VERSION="15.0.0"
 DUCKDB_VERSION="v0.8.1"
 PROTOBUF_VERSION="21.8"
-MINIO_VERSION="2022-05-26T05-48-41Z"
-MINIO_BINARY_NAME="minio-2022-05-26"
-AWS_SDK_VERSION="1.11.321"
 XSIMD_VERSION="10.0.0"
-SIMDJSON_VERSION="3.9.3"
+SIMDJSON_VERSION="4.1.0"
 CPR_VERSION="1.10.5"
 DOUBLE_CONVERSION_VERSION="v3.1.5"
 RANGE_V3_VERSION="0.12.0"
-RE2_VERSION="2022-02-01"
+RE2_VERSION="2024-07-02"
 GFLAGS_VERSION="v2.2.2"
 GLOG_VERSION="v0.6.0"
 LZO_VERSION="2.10"
 SNAPPY_VERSION="1.1.8"
-THRIFT_VERSION="v0.16.0"
+THRIFT_VERSION="${THRIFT_VERSION:-v0.16.0}"
 STEMMER_VERSION="2.2.0"
-GEOS_VERSION="3.10.2"
+GEOS_VERSION="3.10.7"
+# shellcheck disable=SC2034
+FAISS_VERSION="1.11.0"
 FAST_FLOAT_VERSION="v8.0.2"
+CCACHE_VERSION="4.11.3"
 
 # Adapter related versions.
 ABSEIL_VERSION="20240116.2"
@@ -48,5 +49,8 @@ GRPC_VERSION="v1.48.1"
 CRC32_VERSION="1.1.2"
 NLOHMAN_JSON_VERSION="v3.11.3"
 GOOGLE_CLOUD_CPP_VERSION="v2.22.0"
-HADOOP_VERSION="3.3.0"
+HADOOP_VERSION="3.3.6"
 AZURE_SDK_VERSION="12.8.0"
+MINIO_VERSION="2022-05-26T05-48-41Z"
+MINIO_BINARY_NAME="minio-2022-05-26"
+AWS_SDK_VERSION="1.11.654"
diff --git a/scripts/tests/TestFramework.sh b/scripts/tests/TestFramework.sh
index 03b73d3c4e71..8874bad39607 100644
--- a/scripts/tests/TestFramework.sh
+++ b/scripts/tests/TestFramework.sh
@@ -46,15 +46,15 @@ printf -- "------   %-52s   ------   ------\n" ----
 
 Test() {
     Expect=Pass
-    if [ x"$1" = "x!" ] ; then Expect=Fail;  shift
+    if [ "$1" = "!" ] ; then Expect=Fail;  shift
     fi
 
     Title=$1; shift
-    TestsRun=`expr $TestsRun + 1`
+    TestsRun=$(expr $TestsRun + 1)
 
-    printf "%6d %-52s"  $TestsRun "$Title" 1>&2
+    printf "%6d %-52s"  "$TestsRun" "$Title" 1>&2
 
-    Start=`Clock`
+    Start=$(Clock)
     if [ "$SetMinusX" = 1 ] ; then
         set -x
     fi
@@ -70,12 +70,12 @@ Calc() {
 
 TestCleanUp() {
     local result="$1"
-    Now=`Clock`; Elapse=$(Calc $Now - $Start)
+    Now=$(Clock); Elapse=$(Calc "$Now" - "$Start")
 
-    if [ "$result" = Pass ] ; then TestsPassed=`expr $TestsPassed + 1`
-    else                           TestsFailed=`expr $TestsFailed + 1`
+    if [ "$result" = Pass ] ; then TestsPassed=$(expr $TestsPassed + 1)
+    else                           TestsFailed=$(expr $TestsFailed + 1)
     fi
-    printf "    $result %7.3f\n" $Elapse 1>&2
+    printf "    $result %7.3f\n" "$Elapse" 1>&2
 
     if [ "$result" = Fail -a $ExitOnFail = 1 ] ; then
         exit 1
@@ -132,7 +132,7 @@ CompareArgs() {
 
 CompareEval() {
     while [ $# -ge 2 ] ; do
-    x=`$1`
+    x=$($1)
     y=$2
     shift; shift
 
diff --git a/scripts/tests/test_LicenseHeader.sh b/scripts/tests/test_LicenseHeader.sh
index fe6fc5e98169..6cadc727b9a0 100755
--- a/scripts/tests/test_LicenseHeader.sh
+++ b/scripts/tests/test_LicenseHeader.sh
@@ -12,16 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-SRC=$(dirname $0)
+SRC=$(dirname "$0")
 DATA=$SRC/data
 
-source $SRC/TestFramework.sh
+source "$SRC"/TestFramework.sh
 
 LICENSE_HEADER=$SRC/../license-header.py
 LICENSE_HEADER_FILE=$SRC/../../license.header
 
 license_header() {
-    $SRC/../license-header.py --header $LICENSE_HEADER_FILE "$@"
+    "$SRC"/../license-header.py --header "$LICENSE_HEADER_FILE" "$@"
 }
 
 TestFile() {
@@ -30,10 +30,10 @@ TestFile() {
     local expected="$1"     ; shift
 
     Test "license-header.py $title file $file"
-        cp $DATA/$file .
-        license_header "$@" -i $file
+        cp "$DATA"/"$file" .
+        license_header "$@" -i "$file"
 
-    DiffFiles $file $DATA/$expected
+    DiffFiles "$file" "$DATA"/"$expected"
 }
 
 # Test header insertion
@@ -69,15 +69,15 @@ TestFile Almost foo.almost.sh      foo.expected.sh
 TestFile Almost hashbang.almost.sh hashbang.expected.sh
 
 Test "List of Files in stdin"
-    cp $DATA/foo.sh .
+    cp "$DATA"/foo.sh .
 
     echo foo.sh | license_header -i -
 
-    DiffFiles foo.sh $DATA/foo.expected.sh
+    DiffFiles foo.sh "$DATA"/foo.expected.sh
 
 Test "Header Check Only - OK"
-    cp $DATA/foo.expected.sh .
-    cp $DATA/foo.expected.cpp .
+    cp "$DATA"/foo.expected.sh .
+    cp "$DATA"/foo.expected.cpp .
 
     if license_header "$@" -k foo.expected.sh foo.expected.cpp ; then
         Pass
@@ -86,8 +86,8 @@ Test "Header Check Only - OK"
     fi
 
 Test "Header Check Only - Fix"
-    cp $DATA/foo.sh .
-    cp $DATA/foo.cpp .
+    cp "$DATA"/foo.sh .
+    cp "$DATA"/foo.cpp .
 
     if license_header "$@" -k foo.sh foo.cpp; then
         Fail
@@ -96,10 +96,10 @@ Test "Header Check Only - Fix"
     fi
 
 Test "Header Check Verbose"
-    cp $DATA/foo.sh .
-    cp $DATA/foo.expected.sh .
-    cp $DATA/foo.cpp .
-    cp $DATA/foo.expected.cpp .
+    cp "$DATA"/foo.sh .
+    cp "$DATA"/foo.expected.sh .
+    cp "$DATA"/foo.cpp .
+    cp "$DATA"/foo.expected.cpp .
 
     result=$(license_header "$@" -vk foo.sh foo.expected.sh foo.cpp foo.expected.cpp)
     expected="\
diff --git a/scripts/velox_env_linux.yml b/scripts/velox_env_linux.yml
index 58e722cee5ac..2560bb3b29af 100644
--- a/scripts/velox_env_linux.yml
+++ b/scripts/velox_env_linux.yml
@@ -26,7 +26,7 @@ dependencies:
   - binutils
   - bison
   - clangxx=14
-  - cmake=3.28.3
+  - cmake=3.30.4
   - ccache
   - flex
   - gxx=12 # has to be installed to get clang to work...
@@ -58,7 +58,6 @@ dependencies:
   - libtool
   - libunwind
   - lz4-c
-  - lzo
   - openssl=1.1
   - re2
   - simdjson
diff --git a/scripts/velox_env_mac.yml b/scripts/velox_env_mac.yml
index 8c24af8e31a5..34c58679d734 100644
--- a/scripts/velox_env_mac.yml
+++ b/scripts/velox_env_mac.yml
@@ -56,7 +56,6 @@ dependencies:
   - libsodium
   - libtool
   - lz4-c
-  - lzo
   - openssl=1.1.*
   - re2
   - snappy
diff --git a/velox/CMakeLists.txt b/velox/CMakeLists.txt
index 45d6a4540545..1bf6976e8e50 100644
--- a/velox/CMakeLists.txt
+++ b/velox/CMakeLists.txt
@@ -33,9 +33,7 @@ if(${VELOX_ENABLE_EXAMPLES} AND ${VELOX_ENABLE_EXPRESSION})
   add_subdirectory(examples)
 endif()
 
-if(${VELOX_ENABLE_BENCHMARKS} OR ${VELOX_ENABLE_BENCHMARKS_BASIC})
-  add_subdirectory(benchmarks)
-endif()
+add_subdirectory(benchmarks)
 
 if(${VELOX_ENABLE_EXPRESSION})
   add_subdirectory(expression)
@@ -54,15 +52,15 @@ if(${VELOX_ENABLE_TPCH_CONNECTOR})
   add_subdirectory(tpch/gen)
 endif()
 
+if(${VELOX_ENABLE_TPCDS_CONNECTOR})
+  add_subdirectory(tpcds/gen)
+endif()
+
 add_subdirectory(functions) # depends on md5 (postgresql)
 add_subdirectory(connectors)
 
 if(${VELOX_ENABLE_EXEC})
   add_subdirectory(exec)
-  # Disable runner from pyvelox builds
-  if(${VELOX_BUILD_RUNNER})
-    add_subdirectory(runner)
-  endif()
 endif()
 
 if(${VELOX_ENABLE_DUCKDB})
@@ -80,11 +78,6 @@ if(VELOX_ENABLE_WAVE OR VELOX_ENABLE_CUDF)
   endif()
 endif()
 
-# substrait converter
-if(${VELOX_ENABLE_SUBSTRAIT})
-  add_subdirectory(substrait)
-endif()
-
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tool)
 endif()
diff --git a/velox/benchmarks/CMakeLists.txt b/velox/benchmarks/CMakeLists.txt
index 45466b1ed3fd..48dc1fde93fc 100644
--- a/velox/benchmarks/CMakeLists.txt
+++ b/velox/benchmarks/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.
-add_subdirectory(basic)
 
-set(velox_benchmark_deps
+if(${VELOX_BUILD_TEST_UTILS})
+  set(
+    velox_benchmark_deps
     velox_type
     velox_vector
     velox_vector_fuzzer
@@ -26,40 +27,47 @@ set(velox_benchmark_deps
     Folly::follybenchmark
     ${DOUBLE_CONVERSION}
     gflags::gflags
-    glog::glog)
+    glog::glog
+  )
 
-add_library(velox_benchmark_builder ExpressionBenchmarkBuilder.cpp)
-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::gtest)
+  add_library(velox_benchmark_builder ExpressionBenchmarkBuilder.cpp)
+  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::gtest)
+
+  add_library(velox_query_benchmark QueryBenchmarkBase.cpp)
+
+  target_link_libraries(
+    velox_query_benchmark
+    velox_aggregates
+    velox_connector
+    velox_exec
+    velox_exec_test_lib
+    velox_dwio_common
+    velox_dwio_common_exception
+    velox_dwio_parquet_reader
+    velox_dwio_common_test_utils
+    velox_exception
+    velox_memory
+    velox_process
+    velox_serialization
+    velox_encode
+    velox_type
+    velox_type_fbhive
+    velox_caching
+    velox_vector_test_lib
+    Folly::folly
+    Folly::follybenchmark
+    fmt::fmt
+  )
+endif()
+
+if(${VELOX_ENABLE_BENCHMARKS_BASIC})
+  add_subdirectory(basic)
+endif()
 
 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::folly
-  Folly::follybenchmark
-  fmt::fmt)
diff --git a/velox/benchmarks/QueryBenchmarkBase.cpp b/velox/benchmarks/QueryBenchmarkBase.cpp
index 469b6c00542d..852e55d34173 100644
--- a/velox/benchmarks/QueryBenchmarkBase.cpp
+++ b/velox/benchmarks/QueryBenchmarkBase.cpp
@@ -15,12 +15,37 @@
  */
 
 #include "velox/benchmarks/QueryBenchmarkBase.h"
+#include <iostream>
+#include "velox/common/base/SuccinctPrinter.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/dwio/dwrf/RegisterDwrfReader.h"
+#include "velox/dwio/parquet/RegisterParquetReader.h"
+#include "velox/exec/Split.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
 
-DEFINE_string(data_format, "parquet", "Data format");
+namespace {
 
-DEFINE_validator(
-    data_format,
-    &facebook::velox::QueryBenchmarkBase::validateDataFormat);
+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;
+}
+} // namespace
+
+DEFINE_string(data_format, "parquet", "Data format: parquet or dwrf.");
+
+DEFINE_validator(data_format, &validateDataFormat);
 
 DEFINE_bool(
     include_custom_stats,
@@ -97,20 +122,24 @@ 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::string RunStats::toString(bool detail) const {
+  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))
+      << "%)";
+  if (!flags.empty()) {
+    out << " flags: ";
+    for (auto& pair : flags) {
+      out << pair.first << "=" << pair.second << " ";
+    }
   }
-  std::cout
-      << fmt::format(
-             "Invalid value for --{}: {}. Allowed values are [\"parquet\", \"dwrf\"]",
-             flagname,
-             value)
-      << std::endl;
-  return false;
+  out << std::endl << "======" << std::endl;
+  if (detail) {
+    out << std::endl << output << std::endl;
+  }
+  return out.str();
 }
 
 // static
@@ -175,6 +204,20 @@ void QueryBenchmarkBase::initialize() {
       std::make_unique<folly::IOThreadPoolExecutor>(FLAGS_num_io_threads);
 
   // Add new values into the hive configuration...
+  auto properties = makeConnectorProperties();
+
+  // Create hive connector with config...
+  connector::hive::HiveConnectorFactory factory;
+  auto hiveConnector =
+      factory.newConnector(kHiveConnectorId, properties, ioExecutor_.get());
+  connector::registerConnector(hiveConnector);
+  parquet::registerParquetReaderFactory();
+  dwrf::registerDwrfReaderFactory();
+}
+
+std::shared_ptr<config::ConfigBase>
+QueryBenchmarkBase::makeConnectorProperties() {
+  // Default behaviour identical to the original hard-coded version.
   auto configurationValues = std::unordered_map<std::string, std::string>();
   configurationValues[connector::hive::HiveConfig::kMaxCoalescedBytes] =
       std::to_string(FLAGS_max_coalesced_bytes);
@@ -182,19 +225,8 @@ void QueryBenchmarkBase::initialize() {
       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...
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(kHiveConnectorId, properties, ioExecutor_.get());
-  connector::registerConnector(hiveConnector);
-  parquet::registerParquetReaderFactory();
-  dwrf::registerDwrfReaderFactory();
+  return std::make_shared<config::ConfigBase>(
+      std::move(configurationValues), true);
 }
 
 std::vector<std::shared_ptr<connector::ConnectorSplit>>
@@ -218,13 +250,16 @@ void QueryBenchmarkBase::shutdown() {
 }
 
 std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
-QueryBenchmarkBase::run(const TpchPlan& tpchPlan) {
+QueryBenchmarkBase::run(
+    const TpchPlan& tpchPlan,
+    const std::unordered_map<std::string, std::string>& queryConfigs) {
   int32_t repeat = 0;
   try {
     for (;;) {
       CursorParameters params;
       params.maxDrivers = FLAGS_num_drivers;
       params.planNode = tpchPlan.plan;
+      params.queryConfigs = queryConfigs;
       params.queryConfigs[core::QueryConfig::kMaxSplitPreloadPerDriver] =
           std::to_string(FLAGS_split_preload_per_driver);
       const int numSplitsPerFile = FLAGS_num_splits_per_file;
@@ -326,10 +361,14 @@ void QueryBenchmarkBase::runCombinations(int32_t level) {
       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);
+      if (!stats.userNanos) {
+        stats.userNanos = tvNanos(final.ru_utime) - tvNanos(start.ru_utime);
+        stats.systemNanos = tvNanos(final.ru_stime) - tvNanos(start.ru_stime);
+      }
+    }
+    if (!stats.micros) {
+      stats.micros = micros;
     }
-    stats.micros = micros;
     stats.output = result.str();
     for (auto i = 0; i < parameters_.size(); ++i) {
       std::string name;
@@ -340,12 +379,19 @@ void QueryBenchmarkBase::runCombinations(int32_t level) {
   } 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;
+      if (flag.substr(0, 2) == "s-") {
+        auto config = flag.substr(2, flag.size() - 2);
+        config_[config] = value;
+        std::cout << "Set session config " << config << " = " << value
+                  << std::endl;
+      } else {
+        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;
       }
-      std::cout << result << std::endl;
       runCombinations(level + 1);
     }
   }
diff --git a/velox/benchmarks/QueryBenchmarkBase.h b/velox/benchmarks/QueryBenchmarkBase.h
index a5a172a8216c..755b67d36a9c 100644
--- a/velox/benchmarks/QueryBenchmarkBase.h
+++ b/velox/benchmarks/QueryBenchmarkBase.h
@@ -17,31 +17,16 @@
 #pragma once
 
 #include <fcntl.h>
-#include <sys/resource.h>
-#include <sys/time.h>
-
 #include <folly/Benchmark.h>
+#include <folly/executors/IOThreadPoolExecutor.h>
 #include <folly/init/Init.h>
 #include <gflags/gflags.h>
+#include <sys/resource.h>
 #include <sys/stat.h>
+#include <sys/time.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/dwio/dwrf/RegisterDwrfReader.h"
-#include "velox/dwio/parquet/RegisterParquetReader.h"
-#include "velox/exec/PlanNodeStats.h"
-#include "velox/exec/Split.h"
-#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/Cursor.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);
@@ -58,22 +43,7 @@ struct RunStats {
   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();
-  }
+  std::string toString(bool detail) const;
 };
 
 struct ParameterDim {
@@ -85,9 +55,10 @@ class QueryBenchmarkBase {
  public:
   virtual ~QueryBenchmarkBase() = default;
   virtual void initialize();
-  void shutdown();
+  virtual void shutdown();
   std::pair<std::unique_ptr<exec::TaskCursor>, std::vector<RowVectorPtr>> run(
-      const exec::test::TpchPlan& tpchPlan);
+      const exec::test::TpchPlan& tpchPlan,
+      const std::unordered_map<std::string, std::string>& queryConfigs = {});
 
   virtual std::vector<std::shared_ptr<connector::ConnectorSplit>> listSplits(
       const std::string& path,
@@ -96,10 +67,6 @@ class QueryBenchmarkBase {
 
   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);
@@ -115,11 +82,17 @@ class QueryBenchmarkBase {
 
   void runAllCombinations();
 
+  virtual std::shared_ptr<config::ConfigBase> makeConnectorProperties();
+
  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_;
+
+  // QueryConfig properties. May be part of parameter sweep.
+  std::unordered_map<std::string, std::string> config_;
+
   // Parameter combinations to try. Each element specifies a flag and possible
   // values. All permutations are tried.
   std::vector<ParameterDim> parameters_;
diff --git a/velox/benchmarks/basic/CMakeLists.txt b/velox/benchmarks/basic/CMakeLists.txt
index b15bf4a07f11..7ba8c8fee604 100644
--- a/velox/benchmarks/basic/CMakeLists.txt
+++ b/velox/benchmarks/basic/CMakeLists.txt
@@ -11,62 +11,72 @@
 # WITHOUT 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(velox_benchmark_deps
-    velox_type
-    velox_vector
-    velox_vector_fuzzer
-    velox_expression
-    velox_parse_parser
-    velox_parse_utils
-    velox_parse_expression
-    velox_serialization
-    velox_benchmark_builder
-    velox_vector_test_lib
-    Folly::folly
-    Folly::follybenchmark
-    ${DOUBLE_CONVERSION}
-    gflags::gflags
-    glog::glog)
+set(
+  velox_benchmark_deps
+  velox_type
+  velox_vector
+  velox_vector_fuzzer
+  velox_expression
+  velox_parse_parser
+  velox_parse_utils
+  velox_parse_expression
+  velox_serialization
+  velox_benchmark_builder
+  velox_vector_test_lib
+  Folly::folly
+  Folly::follybenchmark
+  ${DOUBLE_CONVERSION}
+  gflags::gflags
+  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_estimate_flat_size EstimateFlatSizeBenchmark.cpp)
+target_link_libraries(velox_benchmark_estimate_flat_size ${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)
+  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)
+  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_row_fast
-  velox_functions_prestosql)
+  velox_benchmark_feature_normalization
+  ${velox_benchmark_deps}
+  velox_row_fast
+  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)
+  velox_benchmark_basic_preproc
+  ${velox_benchmark_deps}
+  velox_functions_prestosql
+  velox_vector_test_lib
+)
 
 add_executable(velox_like_tpch_benchmark LikeTpchBenchmark.cpp)
 target_link_libraries(
@@ -74,7 +84,8 @@ target_link_libraries(
   ${velox_benchmark_deps}
   velox_functions_lib
   velox_tpch_gen
-  velox_vector_test_lib)
+  velox_vector_test_lib
+)
 
 add_executable(velox_like_benchmark LikeBenchmark.cpp)
 target_link_libraries(
@@ -82,16 +93,19 @@ target_link_libraries(
   ${velox_benchmark_deps}
   velox_functions_lib
   velox_functions_prestosql
-  velox_vector_test_lib)
+  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 velox_common_fuzzer_util)
+  velox_benchmark_basic_vector_fuzzer
+  ${velox_benchmark_deps}
+  velox_vector_test_lib
+  velox_common_fuzzer_util
+)
 
 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(
@@ -100,4 +114,5 @@ target_link_libraries(
   velox_vector_test_lib
   velox_functions_spark
   velox_functions_prestosql
-  velox_row_fast)
+  velox_row_fast
+)
diff --git a/velox/benchmarks/basic/EstimateFlatSizeBenchmark.cpp b/velox/benchmarks/basic/EstimateFlatSizeBenchmark.cpp
new file mode 100644
index 000000000000..a0ad3a8e4613
--- /dev/null
+++ b/velox/benchmarks/basic/EstimateFlatSizeBenchmark.cpp
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <gflags/gflags.h>
+
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+DEFINE_int64(fuzzer_seed, 99887766, "Seed for random input dataset generator");
+DEFINE_int64(vector_size, 10000, "Size of vectors to benchmark");
+DEFINE_int64(row_children, 1000, "Number of children in row vector");
+DEFINE_int64(dict_nesting, 5, "Number of dictionary nesting levels");
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace {
+
+class EstimateFlatSizeBenchmark
+    : public functions::test::FunctionBenchmarkBase {
+ public:
+  EstimateFlatSizeBenchmark(size_t vectorSize, size_t rowChildren)
+      : FunctionBenchmarkBase(),
+        vectorSize_(vectorSize),
+        numRowChildren_(rowChildren) {
+    VectorFuzzer::Options opts;
+    opts.vectorSize = vectorSize_;
+    opts.nullRatio = 0;
+    opts.stringLength = 10;
+    VectorFuzzer fuzzer(opts, pool(), FLAGS_fuzzer_seed);
+
+    // Create flat vectors of different types
+    flatBigintVector_ = fuzzer.fuzzFlat(BIGINT());
+    flatVarcharVector_ = fuzzer.fuzzFlat(VARCHAR());
+
+    // Create constant vectors
+    constantBigintVector_ = fuzzer.fuzzConstant(BIGINT());
+    constantVarcharVector_ = fuzzer.fuzzConstant(VARCHAR());
+
+    // Create dictionary vectors
+    dictionaryBigintVector_ = fuzzer.fuzzDictionary(fuzzer.fuzzFlat(BIGINT()));
+    dictionaryVarcharVector_ =
+        fuzzer.fuzzDictionary(fuzzer.fuzzFlat(VARCHAR()));
+
+    // Create nested dictionary vector
+    nestedDictionaryVector_ = fuzzer.fuzzFlat(BIGINT());
+    for (size_t i = 0; i < 5; ++i) {
+      nestedDictionaryVector_ = fuzzer.fuzzDictionary(nestedDictionaryVector_);
+    }
+
+    // Create a nested row vector with complex children
+    std::vector<std::string> names;
+    std::vector<TypePtr> types;
+    std::vector<VectorPtr> children;
+
+    // Create a mix of different types of children
+    for (size_t i = 0; i < numRowChildren_; ++i) {
+      names.push_back(fmt::format("field{}", i));
+
+      // Create different types of children based on the index
+      switch (i % 5) {
+        case 0: {
+          // Flat vector
+          types.push_back(BIGINT());
+          children.push_back(fuzzer.fuzzFlat(BIGINT()));
+          break;
+        }
+        case 1: {
+          // Dictionary vector
+          types.push_back(VARCHAR());
+          children.push_back(fuzzer.fuzzDictionary(fuzzer.fuzzFlat(VARCHAR())));
+          break;
+        }
+        case 2: {
+          // Nested row vector
+          std::vector<std::string> nestedNames = {
+              "nested1", "nested2", "nested3"};
+          std::vector<TypePtr> nestedTypes = {BIGINT(), VARCHAR(), DOUBLE()};
+          auto nestedRowType =
+              ROW(std::move(nestedNames), std::move(nestedTypes));
+          types.push_back(nestedRowType);
+          children.push_back(fuzzer.fuzzRow(nestedRowType, vectorSize_));
+          break;
+        }
+        case 3: {
+          // Array vector
+          auto arrayType = ARRAY(BIGINT());
+          types.push_back(arrayType);
+          children.push_back(fuzzer.fuzzArray(BIGINT(), vectorSize_));
+          break;
+        }
+        case 4: {
+          // Map vector
+          auto mapType = MAP(VARCHAR(), BIGINT());
+          types.push_back(mapType);
+          children.push_back(fuzzer.fuzzMap(VARCHAR(), BIGINT(), vectorSize_));
+          break;
+        }
+      }
+    }
+
+    auto rowType = ROW(std::move(names), std::move(types));
+    rowVector_ = std::make_shared<RowVector>(
+        pool(), rowType, nullptr, vectorSize_, std::move(children));
+  }
+
+  // Benchmark methods for estimateFlatSize
+  void estimateFlatSizeFlatBigint() {
+    auto size = flatBigintVector_->estimateFlatSize();
+    folly::doNotOptimizeAway(size);
+  }
+
+  void estimateFlatSizeFlatVarchar() {
+    auto size = flatVarcharVector_->estimateFlatSize();
+    folly::doNotOptimizeAway(size);
+  }
+
+  void estimateFlatSizeConstantBigint() {
+    auto size = constantBigintVector_->estimateFlatSize();
+    folly::doNotOptimizeAway(size);
+  }
+
+  void estimateFlatSizeConstantVarchar() {
+    auto size = constantVarcharVector_->estimateFlatSize();
+    folly::doNotOptimizeAway(size);
+  }
+
+  void estimateFlatSizeDictionaryBigint() {
+    auto size = dictionaryBigintVector_->estimateFlatSize();
+    folly::doNotOptimizeAway(size);
+  }
+
+  void estimateFlatSizeDictionaryVarchar() {
+    auto size = dictionaryVarcharVector_->estimateFlatSize();
+    folly::doNotOptimizeAway(size);
+  }
+
+  void estimateFlatSizeNestedDictionary() {
+    auto size = nestedDictionaryVector_->estimateFlatSize();
+    folly::doNotOptimizeAway(size);
+  }
+
+  void estimateFlatSizeRowVector() {
+    auto size = rowVector_->estimateFlatSize();
+    folly::doNotOptimizeAway(size);
+  }
+
+ private:
+  const size_t vectorSize_;
+  const size_t numRowChildren_;
+
+  VectorPtr flatBigintVector_;
+  VectorPtr flatVarcharVector_;
+  VectorPtr constantBigintVector_;
+  VectorPtr constantVarcharVector_;
+  VectorPtr dictionaryBigintVector_;
+  VectorPtr dictionaryVarcharVector_;
+  VectorPtr nestedDictionaryVector_;
+  RowVectorPtr rowVector_;
+};
+
+std::unique_ptr<EstimateFlatSizeBenchmark> benchmark;
+
+template <typename Func>
+void run(Func&& func, size_t iterations = 100) {
+  for (auto i = 0; i < iterations; i++) {
+    func();
+  }
+}
+
+BENCHMARK(estimateFlatSizeFlatBigint) {
+  run([&] { benchmark->estimateFlatSizeFlatBigint(); });
+}
+
+BENCHMARK(estimateFlatSizeFlatVarchar) {
+  run([&] { benchmark->estimateFlatSizeFlatVarchar(); });
+}
+
+BENCHMARK(estimateFlatSizeConstantBigint) {
+  run([&] { benchmark->estimateFlatSizeConstantBigint(); });
+}
+
+BENCHMARK(estimateFlatSizeConstantVarchar) {
+  run([&] { benchmark->estimateFlatSizeConstantVarchar(); });
+}
+
+BENCHMARK(estimateFlatSizeDictionaryBigint) {
+  run([&] { benchmark->estimateFlatSizeDictionaryBigint(); });
+}
+
+BENCHMARK(estimateFlatSizeDictionaryVarchar) {
+  run([&] { benchmark->estimateFlatSizeDictionaryVarchar(); });
+}
+
+BENCHMARK(estimateFlatSizeNestedDictionary) {
+  run([&] { benchmark->estimateFlatSizeNestedDictionary(); });
+}
+
+BENCHMARK(estimateFlatSizeRowVector) {
+  run([&] { benchmark->estimateFlatSizeRowVector(); });
+}
+
+} // namespace
+
+int main(int argc, char* argv[]) {
+  folly::Init init{&argc, &argv};
+  ::gflags::ParseCommandLineFlags(&argc, &argv, true);
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+
+  benchmark = std::make_unique<EstimateFlatSizeBenchmark>(
+      FLAGS_vector_size, FLAGS_row_children);
+  folly::runBenchmarks();
+  benchmark.reset();
+  return 0;
+}
diff --git a/velox/benchmarks/basic/LikeTpchBenchmark.cpp b/velox/benchmarks/basic/LikeTpchBenchmark.cpp
index 1f4dab648f94..d904ae5118b2 100644
--- a/velox/benchmarks/basic/LikeTpchBenchmark.cpp
+++ b/velox/benchmarks/basic/LikeTpchBenchmark.cpp
@@ -127,8 +127,9 @@ class LikeFunctionsBenchmark : public FunctionBaseTest,
         return tpchSupplier->childAt(6);
       }
       default:
-        VELOX_FAIL(fmt::format(
-            "Tpch data generation for case {} is not supported", tpchCase));
+        VELOX_FAIL(
+            fmt::format(
+                "Tpch data generation for case {} is not supported", tpchCase));
     }
   }
 
diff --git a/velox/benchmarks/basic/Preproc.cpp b/velox/benchmarks/basic/Preproc.cpp
index f3fbca54b4f7..51e57dea9d94 100644
--- a/velox/benchmarks/basic/Preproc.cpp
+++ b/velox/benchmarks/basic/Preproc.cpp
@@ -186,11 +186,12 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
   for (auto type :
        {"tinyint", "smallint", "integer", "bigint", "real", "double"}) {
-    signatures.push_back(exec::FunctionSignatureBuilder()
-                             .returnType(type)
-                             .argumentType(type)
-                             .argumentType(type)
-                             .build());
+    signatures.push_back(
+        exec::FunctionSignatureBuilder()
+            .returnType(type)
+            .argumentType(type)
+            .argumentType(type)
+            .build());
   }
   return signatures;
 }
diff --git a/velox/benchmarks/basic/SimpleCastExpr.cpp b/velox/benchmarks/basic/SimpleCastExpr.cpp
index 1ae05f03dd88..e2708e7f77d0 100644
--- a/velox/benchmarks/basic/SimpleCastExpr.cpp
+++ b/velox/benchmarks/basic/SimpleCastExpr.cpp
@@ -19,6 +19,7 @@
 
 #include <gflags/gflags.h>
 
+#include "velox/core/Expressions.h"
 #include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
diff --git a/velox/benchmarks/basic/VectorSlice.cpp b/velox/benchmarks/basic/VectorSlice.cpp
index 44ad91f8200a..54b706265e71 100644
--- a/velox/benchmarks/basic/VectorSlice.cpp
+++ b/velox/benchmarks/basic/VectorSlice.cpp
@@ -37,9 +37,10 @@ constexpr int kVectorSize = 16 << 10;
 
 struct BenchmarkData {
   BenchmarkData()
-      : pool_(memory::memoryManager()->addLeafPool(
-            "BenchmarkData",
-            FLAGS_use_thread_safe_memory_usage_track)) {
+      : pool_(
+            memory::memoryManager()->addLeafPool(
+                "BenchmarkData",
+                FLAGS_use_thread_safe_memory_usage_track)) {
     VectorFuzzer::Options opts;
     opts.nullRatio = 0.01;
     opts.vectorSize = kVectorSize;
diff --git a/velox/benchmarks/filesystem/CMakeLists.txt b/velox/benchmarks/filesystem/CMakeLists.txt
index 10a5ebdf710d..5f5b411b94ab 100644
--- a/velox/benchmarks/filesystem/CMakeLists.txt
+++ b/velox/benchmarks/filesystem/CMakeLists.txt
@@ -16,16 +16,12 @@ add_library(velox_read_benchmark_lib ReadBenchmark.cpp)
 
 target_link_libraries(
   velox_read_benchmark_lib
-  PUBLIC velox_file velox_time Folly::folly gflags::gflags)
+  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)
+  PRIVATE velox_read_benchmark_lib velox_hive_config velox_s3fs velox_hdfs velox_abfs velox_gcs
+)
diff --git a/velox/benchmarks/filesystem/ReadBenchmark.h b/velox/benchmarks/filesystem/ReadBenchmark.h
index e033bc953aca..69b26082d647 100644
--- a/velox/benchmarks/filesystem/ReadBenchmark.h
+++ b/velox/benchmarks/filesystem/ReadBenchmark.h
@@ -180,8 +180,9 @@ class ReadBenchmark {
             } else {
               std::vector<folly::Range<char*>> ranges;
               for (auto start = 0; start < rangeSize; start += size + gap) {
-                ranges.push_back(folly::Range<char*>(
-                    globalScratch.buffer.data() + start, size));
+                ranges.push_back(
+                    folly::Range<char*>(
+                        globalScratch.buffer.data() + start, size));
                 if (gap && start + gap < rangeSize) {
                   ranges.push_back(folly::Range<char*>(nullptr, gap));
                 }
diff --git a/velox/benchmarks/tpch/CMakeLists.txt b/velox/benchmarks/tpch/CMakeLists.txt
index 1ac7c3f1aee7..1dbe29ea7d2c 100644
--- a/velox/benchmarks/tpch/CMakeLists.txt
+++ b/velox/benchmarks/tpch/CMakeLists.txt
@@ -36,9 +36,9 @@ target_link_libraries(
   velox_vector_test_lib
   Folly::follybenchmark
   Folly::folly
-  fmt::fmt)
+  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 25d02224fc58..585e5c6eba98 100644
--- a/velox/benchmarks/tpch/TpchBenchmark.cpp
+++ b/velox/benchmarks/tpch/TpchBenchmark.cpp
@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 
-#include "velox/benchmarks/QueryBenchmarkBase.h"
+#include "velox/benchmarks/tpch/TpchBenchmark.h"
+#include <iostream>
+#include "velox/exec/PlanNodeStats.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -57,178 +59,165 @@ DEFINE_int32(
     "include in IO meter query. The columns are sorted by name and the n% first "
     "are scanned");
 
-std::shared_ptr<TpchQueryBuilder> queryBuilder;
-
-class TpchBenchmark : public QueryBenchmarkBase {
- public:
-  void runMain(std::ostream& out, RunStats& runStats) override {
-    if (FLAGS_run_query_verbose == -1 && FLAGS_io_meter_column_pct == 0) {
-      folly::runBenchmarks();
-    } else {
-      const auto queryPlan = FLAGS_io_meter_column_pct > 0
-          ? queryBuilder->getIoMeterPlan(FLAGS_io_meter_column_pct)
-          : queryBuilder->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") {
-          rawInputBytes += first.rawInputBytes;
-        }
+void TpchBenchmark::initQueryBuilder() {
+  queryBuilder_ =
+      std::make_shared<TpchQueryBuilder>(toFileFormat(FLAGS_data_format));
+  queryBuilder_->initialize(FLAGS_data_path);
+}
+
+void TpchBenchmark::initialize() {
+  QueryBenchmarkBase::initialize();
+  initQueryBuilder();
+}
+
+void TpchBenchmark::shutdown() {
+  QueryBenchmarkBase::shutdown();
+  queryBuilder_.reset();
+}
+
+void TpchBenchmark::runMain(
+    std::ostream& out,
+    facebook::velox::RunStats& runStats) {
+  if (FLAGS_run_query_verbose == -1 && FLAGS_io_meter_column_pct == 0) {
+    folly::runBenchmarks();
+  } else {
+    auto queryPlan = FLAGS_io_meter_column_pct > 0
+        ? queryBuilder_->getIoMeterPlan(FLAGS_io_meter_column_pct)
+        : queryBuilder_->getQueryPlan(FLAGS_run_query_verbose);
+    auto [cursor, actualResults] = run(queryPlan, queryConfigs_);
+    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") {
+        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;
     }
+    runStats.rawInputBytes = rawInputBytes;
+    out << fmt::format(
+               "Execution time: {}",
+               facebook::velox::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;
   }
-};
+}
 
-TpchBenchmark benchmark;
+std::unique_ptr<TpchBenchmark> benchmark;
 
 BENCHMARK(q1) {
-  const auto planContext = queryBuilder->getQueryPlan(1);
-  benchmark.run(planContext);
+  benchmark->runQuery(1);
 }
 
 BENCHMARK(q2) {
-  const auto planContext = queryBuilder->getQueryPlan(2);
-  benchmark.run(planContext);
+  benchmark->runQuery(2);
 }
 
 BENCHMARK(q3) {
-  const auto planContext = queryBuilder->getQueryPlan(3);
-  benchmark.run(planContext);
+  benchmark->runQuery(3);
 }
 
 BENCHMARK(q4) {
-  const auto planContext = queryBuilder->getQueryPlan(4);
-  benchmark.run(planContext);
+  benchmark->runQuery(4);
 }
 
 BENCHMARK(q5) {
-  const auto planContext = queryBuilder->getQueryPlan(5);
-  benchmark.run(planContext);
+  benchmark->runQuery(5);
 }
 
 BENCHMARK(q6) {
-  const auto planContext = queryBuilder->getQueryPlan(6);
-  benchmark.run(planContext);
+  benchmark->runQuery(6);
 }
 
 BENCHMARK(q7) {
-  const auto planContext = queryBuilder->getQueryPlan(7);
-  benchmark.run(planContext);
+  benchmark->runQuery(7);
 }
 
 BENCHMARK(q8) {
-  const auto planContext = queryBuilder->getQueryPlan(8);
-  benchmark.run(planContext);
+  benchmark->runQuery(8);
 }
 
 BENCHMARK(q9) {
-  const auto planContext = queryBuilder->getQueryPlan(9);
-  benchmark.run(planContext);
+  benchmark->runQuery(9);
 }
 
 BENCHMARK(q10) {
-  const auto planContext = queryBuilder->getQueryPlan(10);
-  benchmark.run(planContext);
+  benchmark->runQuery(10);
 }
 
 BENCHMARK(q11) {
-  const auto planContext = queryBuilder->getQueryPlan(11);
-  benchmark.run(planContext);
+  benchmark->runQuery(11);
 }
 
 BENCHMARK(q12) {
-  const auto planContext = queryBuilder->getQueryPlan(12);
-  benchmark.run(planContext);
+  benchmark->runQuery(12);
 }
 
 BENCHMARK(q13) {
-  const auto planContext = queryBuilder->getQueryPlan(13);
-  benchmark.run(planContext);
+  benchmark->runQuery(13);
 }
 
 BENCHMARK(q14) {
-  const auto planContext = queryBuilder->getQueryPlan(14);
-  benchmark.run(planContext);
+  benchmark->runQuery(14);
 }
 
 BENCHMARK(q15) {
-  const auto planContext = queryBuilder->getQueryPlan(15);
-  benchmark.run(planContext);
+  benchmark->runQuery(15);
 }
 
 BENCHMARK(q16) {
-  const auto planContext = queryBuilder->getQueryPlan(16);
-  benchmark.run(planContext);
+  benchmark->runQuery(16);
 }
 
 BENCHMARK(q17) {
-  const auto planContext = queryBuilder->getQueryPlan(17);
-  benchmark.run(planContext);
+  benchmark->runQuery(17);
 }
 
 BENCHMARK(q18) {
-  const auto planContext = queryBuilder->getQueryPlan(18);
-  benchmark.run(planContext);
+  benchmark->runQuery(18);
 }
 
 BENCHMARK(q19) {
-  const auto planContext = queryBuilder->getQueryPlan(19);
-  benchmark.run(planContext);
+  benchmark->runQuery(19);
 }
 
 BENCHMARK(q20) {
-  const auto planContext = queryBuilder->getQueryPlan(20);
-  benchmark.run(planContext);
+  benchmark->runQuery(20);
 }
 
 BENCHMARK(q21) {
-  const auto planContext = queryBuilder->getQueryPlan(21);
-  benchmark.run(planContext);
+  benchmark->runQuery(21);
 }
 
 BENCHMARK(q22) {
-  const auto planContext = queryBuilder->getQueryPlan(22);
-  benchmark.run(planContext);
+  benchmark->runQuery(22);
 }
 
-int tpchBenchmarkMain() {
-  benchmark.initialize();
-  queryBuilder =
-      std::make_shared<TpchQueryBuilder>(toFileFormat(FLAGS_data_format));
-  queryBuilder->initialize(FLAGS_data_path);
+void tpchBenchmarkMain() {
+  VELOX_CHECK_NOT_NULL(benchmark);
+  benchmark->initialize();
   if (FLAGS_test_flags_file.empty()) {
     RunStats ignore;
-    benchmark.runMain(std::cout, ignore);
+    benchmark->runMain(std::cout, ignore);
   } else {
-    benchmark.runAllCombinations();
+    benchmark->runAllCombinations();
   }
-  benchmark.shutdown();
-  queryBuilder.reset();
-  return 0;
+  benchmark->shutdown();
 }
diff --git a/velox/benchmarks/tpch/TpchBenchmark.h b/velox/benchmarks/tpch/TpchBenchmark.h
index e66e7c53cbc5..7297f7db17ad 100644
--- a/velox/benchmarks/tpch/TpchBenchmark.h
+++ b/velox/benchmarks/tpch/TpchBenchmark.h
@@ -15,4 +15,31 @@
  */
 #pragma once
 
+#include "velox/benchmarks/QueryBenchmarkBase.h"
+#include "velox/exec/tests/utils/TpchQueryBuilder.h"
+
+class TpchBenchmark : public facebook::velox::QueryBenchmarkBase {
+ public:
+  void initialize() override;
+
+  void shutdown() override;
+
+  void runMain(std::ostream& out, facebook::velox::RunStats& runStats) override;
+
+  void runQuery(int32_t queryId) {
+    const auto planContext = queryBuilder_->getQueryPlan(queryId);
+    run(planContext, queryConfigs_);
+  }
+
+ protected:
+  std::unordered_map<std::string, std::string> queryConfigs_;
+
+ private:
+  void initQueryBuilder();
+
+  std::shared_ptr<facebook::velox::exec::test::TpchQueryBuilder> queryBuilder_;
+};
+
+extern std::unique_ptr<TpchBenchmark> benchmark;
+
 void tpchBenchmarkMain();
diff --git a/velox/benchmarks/tpch/TpchBenchmarkMain.cpp b/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
index 4477455d8f3c..0fa9718ca7ba 100644
--- a/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
+++ b/velox/benchmarks/tpch/TpchBenchmarkMain.cpp
@@ -24,5 +24,6 @@ int main(int argc, char** argv) {
       "This program benchmarks TPC-H queries. Run 'velox_tpch_benchmark -helpon=TpchBenchmark' for available options.\n");
   gflags::SetUsageMessage(kUsage);
   folly::Init init{&argc, &argv, false};
+  benchmark = std::make_unique<TpchBenchmark>();
   tpchBenchmarkMain();
 }
diff --git a/velox/benchmarks/unstable/CMakeLists.txt b/velox/benchmarks/unstable/CMakeLists.txt
index cbd8e1cf6dca..3ca3339fca9c 100644
--- a/velox/benchmarks/unstable/CMakeLists.txt
+++ b/velox/benchmarks/unstable/CMakeLists.txt
@@ -11,21 +11,22 @@
 # WITHOUT 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(velox_benchmark_deps
-    velox_type
-    velox_vector
-    velox_vector_fuzzer
-    velox_expression
-    velox_parse_parser
-    velox_parse_utils
-    velox_parse_expression
-    velox_serialization
-    Folly::folly
-    Folly::follybenchmark
-    ${DOUBLE_CONVERSION}
-    gflags::gflags
-    glog::glog)
+set(
+  velox_benchmark_deps
+  velox_type
+  velox_vector
+  velox_vector_fuzzer
+  velox_expression
+  velox_parse_parser
+  velox_parse_utils
+  velox_parse_expression
+  velox_serialization
+  Folly::folly
+  Folly::follybenchmark
+  ${DOUBLE_CONVERSION}
+  gflags::gflags
+  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/buffer/Buffer.cpp b/velox/buffer/Buffer.cpp
index 806959295401..abb7a3f09d63 100644
--- a/velox/buffer/Buffer.cpp
+++ b/velox/buffer/Buffer.cpp
@@ -18,9 +18,24 @@
 
 namespace facebook::velox {
 
+std::string Buffer::typeString(Type type) {
+  switch (type) {
+    case Type::kPOD:
+      return "kPOD";
+    case Type::kNonPOD:
+      return "kNonPOD";
+    case Type::kPODView:
+      return "kPODView";
+    case Type::kNonPODView:
+      return "kNonPODView";
+    default:
+      return fmt::format("Unknown({})", static_cast<int>(type));
+  }
+}
+
 namespace {
 struct BufferReleaser {
-  explicit BufferReleaser(const BufferPtr& parent) : parent_(parent) {}
+  explicit BufferReleaser(BufferPtr parent) : parent_{std::move(parent)} {}
   void addRef() const {}
   void release() const {}
 
diff --git a/velox/buffer/Buffer.h b/velox/buffer/Buffer.h
index 4e6dba9ebf2f..85ceab567123 100644
--- a/velox/buffer/Buffer.h
+++ b/velox/buffer/Buffer.h
@@ -19,6 +19,8 @@
 #include <iomanip>
 
 #include <boost/intrusive_ptr.hpp>
+#include <fmt/format.h>
+#include <utility>
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Exceptions.h"
@@ -26,8 +28,7 @@
 #include "velox/common/base/SimdUtil.h"
 #include "velox/common/memory/Memory.h"
 
-namespace facebook {
-namespace velox {
+namespace facebook::velox {
 
 class Buffer;
 class AlignedBuffer;
@@ -58,21 +59,40 @@ class Buffer {
   // type. Thus the conditions are: trivial destructor (no resources to release)
   // and trivially copyable (so memcpy works)
   template <typename T>
-  static inline constexpr bool is_pod_like_v =
+  static constexpr bool is_pod_like_v =
       std::is_trivially_destructible_v<T> && std::is_trivially_copyable_v<T>;
 
-  virtual ~Buffer() {}
+  virtual ~Buffer() = default;
 
-  void addRef() {
-    referenceCount_.fetch_add(1);
+  static constexpr uint8_t kPODBit = 0;
+  static constexpr uint8_t kPODMask = 1 << kPODBit;
+  static constexpr uint8_t kViewBit = 1;
+  static constexpr uint8_t kViewMask = 1 << kViewBit;
+  static_assert(kPODBit != kViewBit);
+
+  enum class Type : uint8_t {
+    kNonPOD = 0 << kPODBit | 0 << kViewBit,
+    kPOD = 1 << kPODBit | 0 << kViewBit,
+    kNonPODView = 0 << kPODBit | 1 << kViewBit,
+    kPODView = 1 << kPODBit | 1 << kViewBit,
+  };
+
+  static std::string typeString(Type type);
+
+  Type type() const {
+    return type_;
+  }
+
+  void addRef() noexcept {
+    referenceCount_.fetch_add(1, std::memory_order_acq_rel);
   }
 
-  int refCount() const {
-    return referenceCount_;
+  int refCount() const noexcept {
+    return referenceCount_.load(std::memory_order_acquire);
   }
 
   void release() {
-    if (referenceCount_.fetch_sub(1) == 1) {
+    if (referenceCount_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
       releaseResources();
       if (pool_) {
         freeToPool();
@@ -86,13 +106,13 @@ class Buffer {
   const T* as() const {
     // We can't check actual types, but we can sanity-check POD/non-POD
     // conversion. `void` is special as it's used in type-erased contexts
-    VELOX_DCHECK((std::is_same_v<T, void>) || podType_ == is_pod_like_v<T>);
+    VELOX_DCHECK(std::is_void_v<T> || isPOD() == is_pod_like_v<T>);
     return reinterpret_cast<const T*>(data_);
   }
 
   template <typename T>
   Range<T> asRange() {
-    return Range<T>(as<T>(), 0, size() / sizeof(T));
+    return {as<T>(), 0, static_cast<int32_t>(size() / sizeof(T))};
   }
 
   template <typename T>
@@ -102,16 +122,16 @@ class Buffer {
     VELOX_CHECK(!isView());
     // We can't check actual types, but we can sanity-check POD/non-POD
     // conversion. `void` is special as it's used in type-erased contexts
-    VELOX_DCHECK((std::is_same_v<T, void>) || podType_ == is_pod_like_v<T>);
+    VELOX_DCHECK(std::is_void_v<T> || isPOD() == is_pod_like_v<T>);
     return reinterpret_cast<T*>(data_);
   }
 
   template <typename T>
   MutableRange<T> asMutableRange() {
-    return MutableRange<T>(asMutable<T>(), 0, size() / sizeof(T));
+    return {asMutable<T>(), 0, static_cast<int32_t>(size() / sizeof(T))};
   }
 
-  size_t size() const {
+  size_t size() const noexcept {
     return size_;
   }
 
@@ -126,24 +146,28 @@ class Buffer {
     checkEndGuard();
   }
 
-  uint64_t capacity() const {
+  uint64_t capacity() const noexcept {
     return capacity_;
   }
 
-  bool unique() const {
-    return referenceCount_ == 1;
+  bool unique() const noexcept {
+    return refCount() == 1;
   }
 
-  velox::memory::MemoryPool* pool() const {
+  velox::memory::MemoryPool* pool() const noexcept {
     return pool_;
   }
 
-  bool isMutable() const {
+  bool isMutable() const noexcept {
     return !isView() && unique();
   }
 
-  virtual bool isView() const {
-    return false;
+  bool isView() const {
+    return (static_cast<uint8_t>(type_) & kViewMask) != 0;
+  }
+
+  bool isPOD() const {
+    return (static_cast<uint8_t>(type_) & kPODMask) != 0;
   }
 
   friend std::ostream& operator<<(std::ostream& os, const Buffer& buffer) {
@@ -199,6 +223,14 @@ class Buffer {
         sizeof(T), is_pod_like_v<T>, buffer, offset, length);
   }
 
+  /// Transfers this buffer to 'pool'. Returns true if the transfer succeeds, or
+  /// false if the transfer fails. A buffer can be transferred to 'pool' if its
+  /// original pool and 'pool' are from the same MemoryAllocator and the buffer
+  /// is not a BufferView.
+  virtual bool transferTo(velox::memory::MemoryPool* /*pool*/) {
+    VELOX_NYI("{} unsupported", __FUNCTION__);
+  }
+
  protected:
   // Writes a magic word at 'capacity_'. No-op for a BufferView. The actual
   // logic is inside a separate virtual function, allowing override by derived
@@ -241,7 +273,7 @@ class Buffer {
   virtual void copyFrom(const Buffer* other, size_t bytes) {
     VELOX_CHECK(!isView());
     VELOX_CHECK_GE(capacity_, bytes);
-    VELOX_CHECK(podType_);
+    VELOX_CHECK_EQ(type_, Type::kPOD);
     memcpy(data_, other->data_, bytes);
   }
 
@@ -252,27 +284,24 @@ class Buffer {
   }
 
   Buffer(
-      velox::memory::MemoryPool* pool,
+      Type type,
       uint8_t* data,
       size_t capacity,
-      bool podType)
-      : pool_(pool),
-        data_(data),
-        capacity_(capacity),
-        referenceCount_(0),
-        podType_(podType) {}
+      velox::memory::MemoryPool* pool)
+      : pool_{pool}, data_{data}, capacity_{capacity}, type_{type} {}
 
   velox::memory::MemoryPool* const pool_;
   uint8_t* const data_;
-  uint64_t size_ = 0;
-  uint64_t capacity_ = 0;
-  std::atomic<int32_t> referenceCount_;
-  bool podType_ = true;
-  // Pad to 64 bytes. If using as int32_t[], guarantee that value at index -1 ==
-  // -1.
-  uint64_t padding_[2] = {static_cast<uint64_t>(-1), static_cast<uint64_t>(-1)};
-  // Needs to use setCapacity() from static method reallocate().
-  friend class AlignedBuffer;
+
+  uint64_t size_{0};
+  uint64_t capacity_;
+  std::atomic_int32_t referenceCount_{0};
+
+  const Type type_;
+
+  // Pad to 64 bytes.
+  // If using as int32_t[], guarantee that value at index -1 == -1.
+  uint64_t padding_[2]{static_cast<uint64_t>(-1), static_cast<uint64_t>(-1)};
 
  private:
   static BufferPtr sliceBufferZeroCopy(
@@ -281,6 +310,9 @@ class Buffer {
       const BufferPtr& buffer,
       size_t offset,
       size_t length);
+
+  // Needs to use setCapacity() from static method reallocate().
+  friend class AlignedBuffer;
 };
 
 static_assert(
@@ -289,12 +321,12 @@ static_assert(
 
 template <>
 inline Range<bool> Buffer::asRange<bool>() {
-  return Range<bool>(as<uint64_t>(), 0, size() * 8);
+  return {as<uint64_t>(), 0, static_cast<int32_t>(size() * 8)};
 }
 
 template <>
 inline MutableRange<bool> Buffer::asMutableRange<bool>() {
-  return MutableRange<bool>(asMutable<uint64_t>(), 0, size() * 8);
+  return {asMutable<uint64_t>(), 0, static_cast<int32_t>(size() * 8)};
 }
 
 template <>
@@ -304,11 +336,11 @@ BufferPtr Buffer::slice<bool>(
     size_t length,
     memory::MemoryPool* pool);
 
-static inline void intrusive_ptr_add_ref(Buffer* buffer) {
+FOLLY_ALWAYS_INLINE void intrusive_ptr_add_ref(Buffer* buffer) noexcept {
   buffer->addRef();
 }
 
-static inline void intrusive_ptr_release(Buffer* buffer) {
+FOLLY_ALWAYS_INLINE void intrusive_ptr_release(Buffer* buffer) noexcept {
   buffer->release();
 }
 
@@ -325,7 +357,7 @@ class AlignedBuffer : public Buffer {
   static constexpr int32_t kSizeofAlignedBuffer = 64;
   static constexpr int32_t kPaddedSize = kSizeofAlignedBuffer + simd::kPadding;
 
-  ~AlignedBuffer() {
+  ~AlignedBuffer() override {
     // This may throw, which is expected to signal an error to the
     // user. This is better for distributed debugging than killing the
     // process. In concept this indicates the possibility of memory
@@ -337,10 +369,8 @@ class AlignedBuffer : public Buffer {
   // It's almost like partial specialization, but we redirect all POD types to
   // the same non-templated class
   template <typename T>
-  using ImplClass = typename std::conditional<
-      is_pod_like_v<T>,
-      AlignedBuffer,
-      NonPODAlignedBuffer<T>>::type;
+  using ImplClass = std::
+      conditional_t<is_pod_like_v<T>, AlignedBuffer, NonPODAlignedBuffer<T>>;
 
   /**
    * Allocates enough memory to store numElements of type T.  May
@@ -367,7 +397,8 @@ class AlignedBuffer : public Buffer {
     }
 
     void* memory = pool->allocate(preferredSize);
-    auto* buffer = new (memory) ImplClass<T>(pool, preferredSize - kPaddedSize);
+    VELOX_CHECK_NOT_NULL(memory);
+    auto* buffer = new (memory) ImplClass<T>{pool, preferredSize - kPaddedSize};
     // set size explicitly instead of setSize because `fillNewMemory` already
     // called the constructors
     buffer->size_ = size;
@@ -376,6 +407,18 @@ class AlignedBuffer : public Buffer {
     return result;
   }
 
+  /// A verbose version of the allocate() with the exact size.
+  /// May allocate slightly more memory than strictly necessary. Guarantees that
+  /// simd::kPadding bytes past capacity() are addressable and asserts that
+  /// these do not get overrun.
+  template <typename T>
+  static BufferPtr allocateExact(
+      size_t numElements,
+      velox::memory::MemoryPool* pool,
+      const std::optional<T>& initValue = std::nullopt) {
+    return allocate<T>(numElements, pool, initValue, true);
+  }
+
   // Changes the capacity of '*buffer'. The buffer may grow/shrink in
   // place or may change addresses. The content is copied up to the
   // old size() or the new size, whichever is smaller. If the buffer grows, the
@@ -417,34 +460,32 @@ class AlignedBuffer : public Buffer {
       // called the constructors
       newBuffer->size_ = size;
       *buffer = std::move(newBuffer);
-      return;
-    }
-    if (!old->unique()) {
+    } else if (!old->unique()) {
       auto newBuffer = allocate<T>(numElements, pool);
       newBuffer->copyFrom(old, std::min(size, old->size()));
       reinterpret_cast<AlignedBuffer*>(newBuffer.get())
           ->template fillNewMemory<T>(old->size(), size, initValue);
       newBuffer->size_ = size;
       *buffer = std::move(newBuffer);
-      return;
-    }
-    auto oldCapacity = checkedPlus<size_t>(old->capacity(), kPaddedSize);
-    auto preferredSize =
-        pool->preferredSize(checkedPlus<size_t>(size, kPaddedSize));
+    } else {
+      auto oldCapacity = checkedPlus<size_t>(old->capacity(), kPaddedSize);
+      auto preferredSize =
+          pool->preferredSize(checkedPlus<size_t>(size, kPaddedSize));
 
-    void* newPtr = pool->reallocate(old, oldCapacity, preferredSize);
+      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();
+      // 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();
 
-    auto newBuffer =
-        new (newPtr) AlignedBuffer(pool, preferredSize - kPaddedSize);
-    newBuffer->setSize(size);
-    newBuffer->fillNewMemory<T>(oldSize, size, initValue);
+      auto newBuffer =
+          new (newPtr) AlignedBuffer{pool, preferredSize - kPaddedSize};
+      newBuffer->setSize(size);
+      newBuffer->fillNewMemory<T>(oldSize, size, initValue);
 
-    *buffer = newBuffer;
+      *buffer = newBuffer;
+    }
   }
 
   // Appends bytes starting at 'items' for a length of 'sizeof(T) *
@@ -479,7 +520,7 @@ class AlignedBuffer : public Buffer {
     }
 
     VELOX_CHECK(
-        bufferPtr->podType_, "Support for non POD types not implemented yet");
+        bufferPtr->isPOD(), "Support for non POD types not implemented yet");
 
     // The reason we use uint8_t is because mutableNulls()->size() will return
     // in byte count. We also don't bother initializing since copyFrom will be
@@ -491,13 +532,49 @@ class AlignedBuffer : public Buffer {
     return newBuffer;
   }
 
+  template <typename T>
+  static BufferPtr copy(
+      const BufferPtr& buffer,
+      velox::memory::MemoryPool* pool) {
+    if (buffer == nullptr) {
+      return nullptr;
+    }
+
+    // The reason we use uint8_t is because mutableNulls()->size() will return
+    // in byte count. We also don't bother initializing since copyFrom will be
+    // overwriting anyway.
+    BufferPtr newBuffer;
+    if constexpr (std::is_same_v<T, bool>) {
+      newBuffer = AlignedBuffer::allocate<uint8_t>(buffer->size(), pool);
+    } else {
+      const auto numElements = checkedDivide(buffer->size(), sizeof(T));
+      newBuffer = AlignedBuffer::allocate<T>(numElements, pool);
+    }
+
+    newBuffer->copyFrom(buffer.get(), newBuffer->size());
+
+    return newBuffer;
+  }
+
+  bool transferTo(velox::memory::MemoryPool* pool) override {
+    if (pool_ == pool) {
+      return true;
+    }
+    if (pool_->transferTo(
+            pool, this, checkedPlus<size_t>(kPaddedSize, capacity_))) {
+      setPool(pool);
+      return true;
+    }
+    return false;
+  }
+
  protected:
   AlignedBuffer(velox::memory::MemoryPool* pool, size_t capacity)
-      : Buffer(
-            pool,
+      : Buffer{
+            Type::kPOD,
             reinterpret_cast<uint8_t*>(this) + sizeof(*this),
             capacity,
-            true /*podType*/) {
+            pool} {
     static_assert(sizeof(*this) == kAlignment);
     static_assert(sizeof(*this) == kSizeofAlignedBuffer);
     setEndGuard();
@@ -531,7 +608,12 @@ class AlignedBuffer : public Buffer {
     }
   }
 
- protected:
+  void setPool(velox::memory::MemoryPool* pool) {
+    velox::memory::MemoryPool** poolPtr =
+        const_cast<velox::memory::MemoryPool**>(&pool_);
+    *poolPtr = pool;
+  }
+
   void setEndGuardImpl() override {
     *reinterpret_cast<uint64_t*>(data_ + capacity_) = kEndGuard;
   }
@@ -596,13 +678,30 @@ class NonPODAlignedBuffer : public Buffer {
     }
   }
 
+  bool transferTo(velox::memory::MemoryPool* pool) override {
+    if (pool_ == pool) {
+      return true;
+    }
+
+    if (pool_->transferTo(
+            pool,
+            this,
+            checkedPlus<size_t>(AlignedBuffer::kPaddedSize, capacity_))) {
+      velox::memory::MemoryPool** poolPtr =
+          const_cast<velox::memory::MemoryPool**>(&pool_);
+      *poolPtr = pool;
+      return true;
+    }
+    return false;
+  }
+
  protected:
   NonPODAlignedBuffer(velox::memory::MemoryPool* pool, size_t capacity)
-      : Buffer(
-            pool,
+      : Buffer{
+            Type::kNonPOD,
             reinterpret_cast<uint8_t*>(this) + sizeof(*this),
             capacity,
-            false /*podType*/) {
+            pool} {
     static_assert(sizeof(*this) == AlignedBuffer::kAlignment);
     static_assert(sizeof(*this) == sizeof(AlignedBuffer));
   }
@@ -610,8 +709,8 @@ class NonPODAlignedBuffer : public Buffer {
   void releaseResources() override {
     VELOX_CHECK_EQ(size_ % sizeof(T), 0);
     size_t numValues = size_ / sizeof(T);
-    // we can't use asMutable because it checks isMutable and we wan't to
-    // destroy regardless
+    // we can't use asMutable because it checks isMutable and we wan't
+    // to destroy regardless
     T* ptr = reinterpret_cast<T*>(data_);
     for (int i = 0; i < numValues; ++i) {
       ptr[i].~T();
@@ -619,6 +718,8 @@ class NonPODAlignedBuffer : public Buffer {
   }
 
   void copyFrom(const Buffer* other, size_t bytes) override {
+    // TODO: change this to isMutable(). See
+    // https://github.com/facebookincubator/velox/issues/6562.
     VELOX_CHECK(!isView());
     VELOX_CHECK_GE(size_, bytes);
     VELOX_DCHECK(
@@ -650,10 +751,12 @@ class NonPODAlignedBuffer : public Buffer {
     int oldNum = oldBytes / sizeof(T);
     int newNum = newBytes / sizeof(T);
     auto data = asMutable<T>();
-    for (int i = oldNum; i < newNum; ++i) {
-      if (initValue) {
+    if (initValue) {
+      for (int i = oldNum; i < newNum; ++i) {
         new (data + i) T(*initValue);
-      } else {
+      }
+    } else {
+      for (int i = oldNum; i < newNum; ++i) {
         new (data + i) T();
       }
     }
@@ -673,40 +776,60 @@ class NonPODAlignedBuffer : public Buffer {
 template <typename Releaser>
 class BufferView : public Buffer {
  public:
-  static BufferPtr create(
-      const uint8_t* data,
-      size_t size,
-      Releaser releaser,
-      bool podType = true) {
-    BufferView<Releaser>* view = new BufferView(data, size, releaser, podType);
-    BufferPtr result(view);
+  template <typename R = Releaser>
+  static BufferPtr
+  create(const uint8_t* data, size_t size, R&& releaser, bool podType = true) {
+    auto* view = new BufferView{data, size, std::forward<R>(releaser), podType};
+    BufferPtr result{view};
     return result;
   }
 
+  // Helper method to create a buffer view referencing another existing Buffer.
+  template <typename R = Releaser>
+  static BufferPtr
+  create(const BufferPtr& innerBuffer, R&& releaser, bool podType = true) {
+    return create(
+        innerBuffer->as<uint8_t>(),
+        innerBuffer->size(),
+        std::forward<R>(releaser),
+        podType);
+  }
+
   ~BufferView() override {
     releaser_.release();
   }
 
-  bool isView() const override {
-    return true;
+  bool transferTo(velox::memory::MemoryPool* pool) override {
+    if (pool_ == pool) {
+      return true;
+    }
+    return false;
   }
 
  private:
-  BufferView(const uint8_t* data, size_t size, Releaser releaser, bool podType)
+  template <typename R>
+  BufferView(const uint8_t* data, size_t size, R&& releaser, bool podType)
       // A BufferView must be created over the data held by a cache
       // pin, which is typically const. The Buffer enforces const-ness
       // when returning the pointer. We cast away the const here to
       // avoid a separate code path for const and non-const Buffer
       // payloads.
-      : Buffer(nullptr, const_cast<uint8_t*>(data), size, podType),
-        releaser_(releaser) {
+      : Buffer{podType ? Type::kPODView : Type::kNonPODView, const_cast<uint8_t*>(data), size, nullptr},
+        releaser_{std::forward<R>(releaser)} {
     size_ = size;
-    capacity_ = size;
     releaser_.addRef();
   }
 
-  Releaser const releaser_;
+  [[no_unique_address]] const Releaser releaser_;
 };
 
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox
+
+// fmt formatter specialization for Buffer::Type
+template <>
+struct fmt::formatter<facebook::velox::Buffer::Type> : formatter<std::string> {
+  auto format(facebook::velox::Buffer::Type s, format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::Buffer::typeString(s), ctx);
+  }
+};
diff --git a/velox/buffer/StringViewBufferHolder.cpp b/velox/buffer/StringViewBufferHolder.cpp
index 83479bba0a7c..750b011b2c10 100644
--- a/velox/buffer/StringViewBufferHolder.cpp
+++ b/velox/buffer/StringViewBufferHolder.cpp
@@ -26,8 +26,9 @@ StringView StringViewBufferHolder::getOwnedStringView(
   if (stringBuffers_.empty() ||
       stringBuffers_.back()->size() + size >
           stringBuffers_.back()->capacity()) {
-    stringBuffers_.push_back(AlignedBuffer::allocate<char>(
-        std::max(size, kInitialStringReservation), pool_));
+    stringBuffers_.push_back(
+        AlignedBuffer::allocate<char>(
+            std::max(size, kInitialStringReservation), pool_));
     stringBuffers_.back()->setSize(0);
   }
   auto stringBuffer = stringBuffers_.back().get();
diff --git a/velox/buffer/StringViewBufferHolder.h b/velox/buffer/StringViewBufferHolder.h
index c066d0dbc0a1..962b484fd9e4 100644
--- a/velox/buffer/StringViewBufferHolder.h
+++ b/velox/buffer/StringViewBufferHolder.h
@@ -33,7 +33,7 @@ class StringViewBufferHolder {
 
   /// Return a copy of the StringView where the StringView is copied to this
   /// StringViewBufferHolder if the StringView is not inlined. std::string and
-  /// folly::StringPiece are also copied to the internal buffers (see the
+  /// std::string_view are also copied to the internal buffers (see the
   /// specializations below).
   ///
   /// NOTE: Out of convenience, we allow different types to be passed in, but
@@ -52,8 +52,8 @@ class StringViewBufferHolder {
     return getOwnedStringView(value.data(), value.size());
   }
 
-  /// Specialization for folly::StringPiece type.
-  StringView getOwnedValue(folly::StringPiece value) {
+  /// Specialization for std::string_view type.
+  StringView getOwnedValue(std::string_view value) {
     return getOwnedStringView(value.data(), value.size());
   }
 
@@ -72,6 +72,17 @@ class StringViewBufferHolder {
     return stringBuffers_;
   }
 
+  /// Add a buffer to the list of buffers. This is used to allow bulk addition
+  /// of values with fewer overall buffers vs adding a value at a time via
+  /// getOwnedValue. The buffer must be allocated on the same underlying memory
+  /// pool.
+  void addOwnedBuffer(BufferPtr&& inBuffer) {
+    VELOX_CHECK(
+        inBuffer->pool() == pool_,
+        "Buffer must be allocated on same memory pool");
+    stringBuffers_.push_back(std::move(inBuffer));
+  }
+
  private:
   StringView getOwnedStringView(StringView stringView);
   StringView getOwnedStringView(const char* data, int32_t size);
diff --git a/velox/buffer/tests/BufferTest.cpp b/velox/buffer/tests/BufferTest.cpp
index 9db4963221da..a45eeff24724 100644
--- a/velox/buffer/tests/BufferTest.cpp
+++ b/velox/buffer/tests/BufferTest.cpp
@@ -143,6 +143,20 @@ TEST_F(BufferTest, testAlignedBufferExact) {
   EXPECT_GE(buffer4->capacity(), oneMBMinusPad + 1);
 }
 
+TEST_F(BufferTest, testAllocateExact) {
+  const int32_t oneMBMinusPad = 1024 * 1024 - AlignedBuffer::kPaddedSize;
+
+  BufferPtr buffer1 = AlignedBuffer::allocateExact<char>(
+      oneMBMinusPad + 1, pool_.get(), std::nullopt);
+  EXPECT_EQ(buffer1->size(), oneMBMinusPad + 1);
+  EXPECT_GE(buffer1->capacity(), oneMBMinusPad + 1);
+
+  BufferPtr buffer2 = AlignedBuffer::allocateExact<char>(3, pool_.get(), 'i');
+  for (size_t i = 0; i < buffer2->size(); i++) {
+    EXPECT_EQ(buffer2->as<char>()[i], 'i');
+  }
+}
+
 TEST_F(BufferTest, testAsRange) {
   // Simple 2 element vector.
   std::vector<uint8_t> testData({5, 255});
@@ -484,7 +498,9 @@ TEST_F(BufferTest, testNonPOD) {
 TEST_F(BufferTest, testNonPODMemoryUsage) {
   using T = std::shared_ptr<void>;
   const int64_t currentBytes = pool_->usedBytes();
-  { auto buffer = AlignedBuffer::allocate<T>(0, pool_.get()); }
+  {
+    auto buffer = AlignedBuffer::allocate<T>(0, pool_.get());
+  }
   EXPECT_EQ(pool_->usedBytes(), currentBytes);
 }
 
@@ -535,5 +551,34 @@ TEST_F(BufferTest, sliceBooleanBuffer) {
       Buffer::slice<bool>(bufferPtr, 5, 6, nullptr), "Pool must not be null.");
 }
 
+TEST_F(BufferTest, testType) {
+  // Test AlignedBuffer type
+  auto alignedBuffer = AlignedBuffer::allocate<char>(100, pool_.get());
+  EXPECT_EQ(alignedBuffer->type(), Buffer::Type::kPOD);
+  EXPECT_TRUE(alignedBuffer->isPOD());
+  EXPECT_FALSE(alignedBuffer->isView());
+
+  // Test NonPODAlignedBuffer type
+  auto nonPODBuffer = AlignedBuffer::allocate<NonPOD>(10, pool_.get());
+  EXPECT_EQ(nonPODBuffer->type(), Buffer::Type::kNonPOD);
+  EXPECT_FALSE(nonPODBuffer->isPOD());
+  EXPECT_FALSE(nonPODBuffer->isView());
+
+  // Test BufferView type
+  MockCachePin pin;
+  const char* data = "test data";
+  auto podBufferView = BufferView<MockCachePin&>::create(
+      reinterpret_cast<const uint8_t*>(data), 9, pin);
+  EXPECT_EQ(podBufferView->type(), Buffer::Type::kPODView);
+  EXPECT_TRUE(podBufferView->isPOD());
+  EXPECT_TRUE(podBufferView->isView());
+
+  auto nonPodBufferView = BufferView<MockCachePin&>::create(
+      reinterpret_cast<const uint8_t*>(data), 9, pin, false);
+  EXPECT_EQ(nonPodBufferView->type(), Buffer::Type::kNonPODView);
+  EXPECT_FALSE(nonPodBufferView->isPOD());
+  EXPECT_TRUE(nonPodBufferView->isView());
+}
+
 } // namespace velox
 } // namespace facebook
diff --git a/velox/buffer/tests/CMakeLists.txt b/velox/buffer/tests/CMakeLists.txt
index 097f5ee3bb3f..9ca02cf2545b 100644
--- a/velox/buffer/tests/CMakeLists.txt
+++ b/velox/buffer/tests/CMakeLists.txt
@@ -25,4 +25,5 @@ target_link_libraries(
   GTest::gmock
   glog::glog
   gflags::gflags
-  pthread)
+  pthread
+)
diff --git a/velox/buffer/tests/StringViewBufferHolderTest.cpp b/velox/buffer/tests/StringViewBufferHolderTest.cpp
index 4049be7503fa..4ae7ece1a381 100644
--- a/velox/buffer/tests/StringViewBufferHolderTest.cpp
+++ b/velox/buffer/tests/StringViewBufferHolderTest.cpp
@@ -161,23 +161,21 @@ TEST_F(StringViewBufferHolderTest, getOwnedValueCanBeCalledWithStringType) {
   ASSERT_EQ(1, holder.buffers().size());
 }
 
-TEST_F(
-    StringViewBufferHolderTest,
-    getOwnedValueCanBeCalledWithStringPieceType) {
+TEST_F(StringViewBufferHolderTest, getOwnedValueCanBeCalledWithStringViewType) {
   const char* buf = "abcdefghijklmnopqrstuvxz";
   StringView result;
-  folly::StringPiece piece;
+  std::string_view view;
 
   auto holder = makeHolder();
   ASSERT_EQ(0, holder.buffers().size());
 
   {
     std::string str = buf;
-    piece = str;
-    result = holder.getOwnedValue(piece);
+    view = str;
+    result = holder.getOwnedValue(view);
   }
 
-  // `str` is already destructed and piece is invalid.
+  // `str` is already destructed and `view` is invalid.
   ASSERT_EQ(StringView(buf), result);
   ASSERT_EQ(1, holder.buffers().size());
 }
@@ -208,4 +206,25 @@ TEST_F(StringViewBufferHolderTest, buffersCopy) {
   EXPECT_NE(&buffers, &firstMoved);
 }
 
+TEST_F(StringViewBufferHolderTest, addOwnedBuffer) {
+  auto holder = makeHolder();
+  ASSERT_EQ(0, holder.buffers().size());
+  auto buffer = AlignedBuffer::allocate<char>(10, pool_.get());
+  holder.addOwnedBuffer(std::move(buffer));
+  ASSERT_EQ(1, holder.buffers().size());
+  ASSERT_EQ(1, holder.moveBuffers().size());
+}
+
+TEST_F(StringViewBufferHolderTest, addOwnedBufferThrowsForWrongPool) {
+  auto holder = makeHolder();
+  ASSERT_EQ(0, holder.buffers().size());
+  auto buffer = AlignedBuffer::allocate<char>(10, pool_.get());
+  holder.addOwnedBuffer(std::move(buffer));
+
+  auto newPool = memory::memoryManager()->addLeafPool();
+  ASSERT_THROW(
+      holder.addOwnedBuffer(AlignedBuffer::allocate<char>(10, newPool.get())),
+      VeloxException);
+}
+
 } // namespace facebook::velox
diff --git a/velox/common/CMakeLists.txt b/velox/common/CMakeLists.txt
index 6661427654be..f6457da34760 100644
--- a/velox/common/CMakeLists.txt
+++ b/velox/common/CMakeLists.txt
@@ -18,6 +18,8 @@ add_subdirectory(config)
 add_subdirectory(dynamic_registry)
 add_subdirectory(encode)
 add_subdirectory(file)
+add_subdirectory(future)
+add_subdirectory(geospatial)
 add_subdirectory(hyperloglog)
 add_subdirectory(io)
 add_subdirectory(memory)
@@ -26,3 +28,5 @@ add_subdirectory(serialization)
 add_subdirectory(time)
 add_subdirectory(testutil)
 add_subdirectory(fuzzer)
+
+velox_install_library_headers()
diff --git a/velox/common/Casts.h b/velox/common/Casts.h
new file mode 100644
index 000000000000..0f03271d6495
--- /dev/null
+++ b/velox/common/Casts.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/common/base/Exceptions.h"
+
+#include <folly/Demangle.h>
+
+namespace facebook::velox {
+
+namespace detail {
+
+template <typename From, typename To>
+void ensureCastSucceeded(To* casted, From* original) {
+  // Either casted or original will be nullptr. Otherwise it's a bad usage.
+  if (casted == nullptr) {
+    VELOX_CHECK_NOT_NULL(
+        original, "If casted is nullptr, original must not be.");
+    VELOX_FAIL(
+        "Failed to cast from '{}' to '{}'. Object is of type '{}'.",
+        folly::demangle(typeid(From).name()),
+        folly::demangle(typeid(To).name()),
+        folly::demangle(typeid(*original).name()));
+  }
+}
+
+} // namespace detail
+
+// `checkedPointerCast` is a dynamic casting tool to throw a Velox exception
+// when the casting failed. Use this instead of `std::dynamic_pointer_cast`
+// when:
+//   1) Casting must happen
+//   2) We want a stack trace if it failed.
+template <typename To, typename From>
+std::shared_ptr<To> checkedPointerCast(const std::shared_ptr<From>& input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto casted = std::dynamic_pointer_cast<To>(input);
+  detail::ensureCastSucceeded(casted.get(), input.get());
+  return casted;
+}
+
+template <typename To, typename From>
+std::unique_ptr<To> checkedPointerCast(std::unique_ptr<From> input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto* released = input.release();
+  To* casted{nullptr};
+  try {
+    casted = dynamic_cast<To*>(released);
+    detail::ensureCastSucceeded(casted, released);
+  } catch (...) {
+    input.reset(released);
+    throw;
+  }
+  return std::unique_ptr<To>(casted);
+}
+
+template <typename To, typename From>
+To* checkedPointerCast(From* input) {
+  VELOX_CHECK_NOT_NULL(input);
+  auto* casted = dynamic_cast<To*>(input);
+  detail::ensureCastSucceeded(casted, input);
+  return casted;
+}
+
+template <typename To, typename From>
+std::unique_ptr<To> staticUniquePointerCast(std::unique_ptr<From> input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto* released = input.release();
+  auto* casted = static_cast<To*>(released);
+  return std::unique_ptr<To>(casted);
+}
+
+template <typename To, typename From>
+bool isInstanceOf(const std::shared_ptr<From>& input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto* casted = dynamic_cast<const To*>(input.get());
+  return casted != nullptr;
+}
+
+template <typename To, typename From>
+bool isInstanceOf(const std::unique_ptr<From>& input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto* casted = dynamic_cast<const To*>(input.get());
+  return casted != nullptr;
+}
+
+template <typename To, typename From>
+bool isInstanceOf(const From* input) {
+  VELOX_CHECK_NOT_NULL(input);
+  auto* casted = dynamic_cast<const To*>(input);
+  return casted != nullptr;
+}
+
+#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
+template <typename To, typename From>
+std::shared_ptr<To> checked_pointer_cast(const std::shared_ptr<From>& input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto casted = std::dynamic_pointer_cast<To>(input);
+  detail::ensureCastSucceeded(casted.get(), input.get());
+  return casted;
+}
+
+template <typename To, typename From>
+std::unique_ptr<To> checked_pointer_cast(std::unique_ptr<From> input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto* released = input.release();
+  To* casted{nullptr};
+  try {
+    casted = dynamic_cast<To*>(released);
+    detail::ensureCastSucceeded(casted, released);
+  } catch (...) {
+    input.reset(released);
+    throw;
+  }
+  return std::unique_ptr<To>(casted);
+}
+
+template <typename To, typename From>
+To* checked_pointer_cast(From* input) {
+  VELOX_CHECK_NOT_NULL(input);
+  auto* casted = dynamic_cast<To*>(input);
+  detail::ensureCastSucceeded(casted, input);
+  return casted;
+}
+
+template <typename To, typename From>
+std::unique_ptr<To> static_unique_pointer_cast(std::unique_ptr<From> input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto* released = input.release();
+  auto* casted = static_cast<To*>(released);
+  return std::unique_ptr<To>(casted);
+}
+
+template <typename To, typename From>
+bool is_instance_of(const std::shared_ptr<From>& input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto* casted = dynamic_cast<const To*>(input.get());
+  return casted != nullptr;
+}
+
+template <typename To, typename From>
+bool is_instance_of(const std::unique_ptr<From>& input) {
+  VELOX_CHECK_NOT_NULL(input.get());
+  auto* casted = dynamic_cast<const To*>(input.get());
+  return casted != nullptr;
+}
+
+template <typename To, typename From>
+bool is_instance_of(const From* input) {
+  VELOX_CHECK_NOT_NULL(input);
+  auto* casted = dynamic_cast<const To*>(input);
+  return casted != nullptr;
+}
+#endif
+
+} // namespace facebook::velox
diff --git a/velox/common/Enums.h b/velox/common/Enums.h
new file mode 100644
index 000000000000..8f844ea1b050
--- /dev/null
+++ b/velox/common/Enums.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 "folly/container/F14Map.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox {
+
+struct Enums {
+  /// Helper function to invert a mapping from enum type to name.
+  template <typename EnumType, typename StringType>
+  static auto invertMap(
+      const folly::F14FastMap<EnumType, StringType>& mapping) {
+    folly::F14FastMap<StringType, EnumType> inverted;
+    for (const auto& [key, value] : mapping) {
+      const bool emplaced = inverted.emplace(value, key).second;
+      VELOX_USER_CHECK(
+          emplaced, "Cannot invert a map with duplicate values: {}", value);
+    }
+    return inverted;
+  }
+};
+
+} // namespace facebook::velox
+
+/// Helper macros to implement bi-direction mappings between enum values and
+/// names.
+///
+/// Usage:
+///
+/// In the header file, define the enum:
+///
+/// #include "velox/common/Enums.h"
+///
+/// enum class Foo {...};
+///
+/// VELOX_DECLARE_ENUM_NAME(Foo);
+///
+/// In the cpp file, define the mapping:
+///
+/// namespace {
+/// const auto& fooNames() {
+///   static const folly::F14FastMap<Foo, std::string_view> kNames = {
+///       {Foo::kFirst, "FIRST"},
+///       {Foo::kSecond, "SECOND"},
+///        ...
+///   };
+///   return kNames;
+/// }
+/// } // namespace
+///
+/// VELOX_DEFINE_ENUM_NAME(Foo, fooNames);
+///
+/// In the client code, use FooName::toName(Foo::kFirst) to get the name of the
+/// enum and FooName::toFoo("FIRST") or FooName::tryToFoo("FIRST") to get the
+/// enum value. toFoo throws an exception if input is not a valid name, while
+/// tryToFoo returns a std::nullopt.
+///
+/// Use _EMBEDDED_ versions of the macros to define enums embedded in other
+/// classes.
+
+#define VELOX_DECLARE_ENUM_NAME(EnumType)                                  \
+  struct EnumType##Name {                                                  \
+    static std::string_view toName(EnumType value);                        \
+    static EnumType to##EnumType(std::string_view name);                   \
+    static std::optional<EnumType> tryTo##EnumType(std::string_view name); \
+  };                                                                       \
+  std::ostream& operator<<(std::ostream& os, const EnumType& value);
+
+#define VELOX_DEFINE_ENUM_NAME(EnumType, Names)                             \
+  std::string_view EnumType##Name::toName(EnumType value) {                 \
+    const auto& names = Names();                                            \
+    auto it = names.find(value);                                            \
+    VELOX_CHECK(                                                            \
+        it != names.end(),                                                  \
+        "Invalid enum value: {}",                                           \
+        static_cast<std::underlying_type_t<EnumType>>(value));              \
+    return it->second;                                                      \
+  }                                                                         \
+                                                                            \
+  std::optional<EnumType> EnumType##Name::tryTo##EnumType(                  \
+      std::string_view name) {                                              \
+    static const auto kValues = facebook::velox::Enums::invertMap(Names()); \
+                                                                            \
+    auto it = kValues.find(name);                                           \
+    if (it == kValues.end()) {                                              \
+      return std::nullopt;                                                  \
+    }                                                                       \
+    return it->second;                                                      \
+  }                                                                         \
+  std::ostream& operator<<(std::ostream& os, const EnumType& value) {       \
+    os << EnumType##Name::toName(value);                                    \
+    return os;                                                              \
+  }                                                                         \
+                                                                            \
+  EnumType EnumType##Name::to##EnumType(std::string_view name) {            \
+    const auto maybeType = EnumType##Name::tryTo##EnumType(name);           \
+    VELOX_CHECK(maybeType, "Invalid enum name: {}", name);                  \
+    return *maybeType;                                                      \
+  }
+
+#define VELOX_DECLARE_EMBEDDED_ENUM_NAME(EnumType)     \
+  static std::string_view toName(EnumType value);      \
+  static EnumType to##EnumType(std::string_view name); \
+  static std::optional<EnumType> tryTo##EnumType(std::string_view name);
+
+#define VELOX_DEFINE_EMBEDDED_ENUM_NAME(Class, EnumType, Names)             \
+  std::string_view Class::toName(Class::EnumType value) {                   \
+    const auto& names = Names();                                            \
+    auto it = names.find(value);                                            \
+    VELOX_CHECK(                                                            \
+        it != names.end(),                                                  \
+        "Invalid enum value: {}",                                           \
+        static_cast<std::underlying_type_t<Class::EnumType>>(value));       \
+    return it->second;                                                      \
+  }                                                                         \
+                                                                            \
+  std::optional<Class::EnumType> Class::tryTo##EnumType(                    \
+      std::string_view name) {                                              \
+    static const auto kValues = facebook::velox::Enums::invertMap(Names()); \
+                                                                            \
+    auto it = kValues.find(name);                                           \
+    if (it == kValues.end()) {                                              \
+      return std::nullopt;                                                  \
+    }                                                                       \
+    return it->second;                                                      \
+  }                                                                         \
+                                                                            \
+  Class::EnumType Class::to##EnumType(std::string_view name) {              \
+    const auto maybeType = Class::tryTo##EnumType(name);                    \
+    VELOX_CHECK(maybeType, "Invalid enum name: {}", name);                  \
+    return *maybeType;                                                      \
+  }
diff --git a/velox/common/base/AdmissionController.cpp b/velox/common/base/AdmissionController.cpp
index c7e1b71ea5ac..e1dae70a402e 100644
--- a/velox/common/base/AdmissionController.cpp
+++ b/velox/common/base/AdmissionController.cpp
@@ -32,12 +32,10 @@ void AdmissionController::accept(uint64_t resourceUnits) {
   {
     std::lock_guard<std::mutex> l(mu_);
     if (unitsUsed_ + resourceUnits > config_.maxLimit) {
-      auto [unblockPromise, unblockFuture] = makeVeloxContinuePromiseContract();
       Request req;
       req.unitsRequested = resourceUnits;
-      req.promise = std::move(unblockPromise);
+      future = req.promise.getSemiFuture();
       queue_.push_back(std::move(req));
-      future = std::move(unblockFuture);
     } else {
       updatedValue = unitsUsed_ += resourceUnits;
     }
diff --git a/velox/common/base/AsyncSource.h b/velox/common/base/AsyncSource.h
index 76740dd8681a..02901068c1da 100644
--- a/velox/common/base/AsyncSource.h
+++ b/velox/common/base/AsyncSource.h
@@ -56,8 +56,8 @@ class AsyncSource {
 
   ~AsyncSource() {
     VELOX_CHECK(
-        moved_ || closed_,
-        "AsyncSource should be properly consumed or closed.");
+        moved_ || closed_ || (cancelled_ && !making_),
+        "AsyncSource should be properly consumed, closed, or cancelled.");
   }
 
   // Makes an item if it is not already made. To be called on a background
@@ -121,7 +121,7 @@ class AsyncSource {
         return nullptr;
       }
       if (making_) {
-        promise_ = std::make_unique<ContinuePromise>();
+        promise_ = std::make_unique<ContinuePromise>("AsyncSource::move");
         wait = promise_->getSemiFuture();
       } else {
         if (!make_) {
@@ -163,6 +163,18 @@ class AsyncSource {
     return timing_;
   }
 
+  /// Cancels the task if it hasn't started yet.
+  /// If the task has already started, the task will continue but AsyncSource
+  /// is marked as cancelled to allow proper cleanup in destructor.
+  void cancel() {
+    std::lock_guard<std::mutex> l(mutex_);
+    cancelled_ = true;
+    if (make_ == nullptr) {
+      return;
+    }
+    make_ = nullptr;
+  }
+
   /// 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
@@ -178,7 +190,7 @@ class AsyncSource {
     {
       std::lock_guard<std::mutex> l(mutex_);
       if (making_) {
-        promise_ = std::make_unique<ContinuePromise>();
+        promise_ = std::make_unique<ContinuePromise>("AsyncSource::close");
         wait = promise_->getSemiFuture();
       } else if (make_) {
         make_ = nullptr;
@@ -217,5 +229,6 @@ class AsyncSource {
   CpuWallTiming timing_;
   bool closed_{false};
   bool moved_{false};
+  bool cancelled_{false};
 };
 } // namespace facebook::velox
diff --git a/velox/common/base/BigintIdMap.h b/velox/common/base/BigintIdMap.h
index e63445f4d127..97d3abfdb514 100644
--- a/velox/common/base/BigintIdMap.h
+++ b/velox/common/base/BigintIdMap.h
@@ -31,8 +31,10 @@ class BigintIdMap {
   static constexpr int64_t kMaxCapacity = 1 << 30; // 1G entries, 12GB
 
   BigintIdMap(int32_t capacity, memory::MemoryPool& pool) : pool_(pool) {
-    makeTable(std::max<int32_t>(
-        2 * sizeof(xsimd::batch<int64_t, A>), bits::nextPowerOfTwo(capacity)));
+    makeTable(
+        std::max<int32_t>(
+            2 * sizeof(xsimd::batch<int64_t, A>),
+            bits::nextPowerOfTwo(capacity)));
   }
 
   BigintIdMap(const BigintIdMap& other) = delete;
diff --git a/velox/common/base/BitUtil.h b/velox/common/base/BitUtil.h
index be159ad2ea51..3257cbe4b0f0 100644
--- a/velox/common/base/BitUtil.h
+++ b/velox/common/base/BitUtil.h
@@ -48,6 +48,8 @@ namespace facebook {
 namespace velox {
 namespace bits {
 
+inline constexpr uint64_t kNullHash = 1;
+
 template <typename T>
 inline bool isBitSet(const T* bits, uint64_t idx) {
   return bits[idx / (sizeof(bits[0]) * 8)] &
@@ -92,6 +94,11 @@ inline void setBit(T* bits, uint64_t idx, bool value) {
   value ? setBit(bits, idx) : clearBit(bits, idx);
 }
 
+inline void negateBit(void* bits, uint64_t idx) {
+  auto* bitsAs8Bit = reinterpret_cast<uint8_t*>(bits);
+  bitsAs8Bit[idx / 8] ^= (1 << (idx % 8));
+}
+
 inline void negate(uint64_t* bits, int32_t size) {
   int32_t i = 0;
   for (; i + 64 <= size; i += 64) {
diff --git a/velox/common/base/BloomFilter.h b/velox/common/base/BloomFilter.h
index 1d23e382834b..6fab5a4376cf 100644
--- a/velox/common/base/BloomFilter.h
+++ b/velox/common/base/BloomFilter.h
@@ -61,6 +61,20 @@ class BloomFilter {
     return test(bits_.data(), bits_.size(), value);
   }
 
+  /// Tests an input value directly on a serialized bloom filter.
+  /// For the implementation V1, this API involves no copy of the bloom
+  /// filter data.
+  static bool mayContain(const char* serializedBloom, uint64_t value) {
+    common::InputByteStream stream(serializedBloom);
+    const auto version = stream.read<int8_t>();
+    VELOX_USER_CHECK_EQ(kBloomFilterV1, version);
+    const auto size = stream.read<int32_t>();
+    VELOX_USER_CHECK_GT(size, 0);
+    const uint64_t* bloomBits =
+        reinterpret_cast<const uint64_t*>(serializedBloom + stream.offset());
+    return test(bloomBits, size, value);
+  }
+
   void merge(const char* serialized) {
     common::InputByteStream stream(serialized);
     auto version = stream.read<int8_t>();
@@ -127,7 +141,7 @@ class BloomFilter {
     return mask == (bloom[index] & mask);
   }
 
-  const int8_t kBloomFilterV1 = 1;
+  static constexpr int8_t kBloomFilterV1 = 1;
   std::vector<uint64_t, Allocator> bits_;
 };
 
diff --git a/velox/common/base/CMakeLists.txt b/velox/common/base/CMakeLists.txt
index 58cd1f38ed2e..3774a4215429 100644
--- a/velox/common/base/CMakeLists.txt
+++ b/velox/common/base/CMakeLists.txt
@@ -12,16 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_exception Exceptions.cpp VeloxException.cpp
-                  Exceptions.h)
+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)
+  PUBLIC velox_flag_definitions velox_process Folly::folly fmt::fmt gflags::gflags glog::glog
+)
 
 velox_add_library(
   velox_common_base
@@ -36,14 +31,17 @@ velox_add_library(
   SkewedPartitionBalancer.cpp
   SpillConfig.cpp
   SpillStats.cpp
+  SplitBlockBloomFilter.cpp
   StatsReporter.cpp
   SuccinctPrinter.cpp
-  TraceConfig.cpp)
+  TraceConfig.cpp
+)
 
 velox_link_libraries(
   velox_common_base
   PUBLIC velox_exception Folly::folly fmt::fmt xsimd
-  PRIVATE velox_common_compression velox_process velox_test_util glog::glog)
+  PRIVATE velox_caching velox_common_compression velox_process velox_test_util glog::glog
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
@@ -61,10 +59,8 @@ velox_link_libraries(
   velox_process
   glog::glog
   Folly::folly
-  fmt::fmt)
+  fmt::fmt
+)
 
 velox_add_library(velox_status Status.cpp)
-velox_link_libraries(
-  velox_status
-  PUBLIC fmt::fmt Folly::folly
-  PRIVATE glog::glog)
+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 f5f58ba1092b..7ad405cf2908 100644
--- a/velox/common/base/CoalesceIo.h
+++ b/velox/common/base/CoalesceIo.h
@@ -65,14 +65,13 @@ CoalesceIoStats coalesceIo(
     AddRanges addRanges,
     SkipRange skipRange,
     IoFunc ioFunc) {
-  std::vector<Range> buffers;
   int32_t startItem = 0;
   auto startOffset = offsetFunc(startItem);
   auto lastEndOffset = startOffset;
   std::vector<Range> ranges;
   CoalesceIoStats result;
   for (int32_t i = 0; i < items.size(); ++i) {
-    auto& item = items[i];
+    const auto& item = items[i];
     const auto itemOffset = offsetFunc(i);
     const auto itemSize = sizeFunc(i);
     result.payloadBytes += itemSize;
diff --git a/velox/common/base/CompareFlags.h b/velox/common/base/CompareFlags.h
index 265f84652f81..f7873ab330df 100644
--- a/velox/common/base/CompareFlags.h
+++ b/velox/common/base/CompareFlags.h
@@ -84,7 +84,7 @@ struct CompareFlags {
     ///       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.
+    ///       ex: (1, 1) = (1, 1) is true.
     ///
     ///   4. Maps:
     ///     - Keys are compared first, if keys are not equal values are not
@@ -171,6 +171,13 @@ struct CompareFlags {
     }
   }
 
+  /// Returns a copy of the flags with the ascending flag flipped.
+  static CompareFlags reverseDirection(const CompareFlags& flags) {
+    CompareFlags result = flags;
+    result.ascending = !result.ascending;
+    return result;
+  }
+
   std::string toString() const {
     return fmt::format(
         "[NullFirst[{}] Ascending[{}] EqualsOnly[{}] NullHandleMode[{}]]",
diff --git a/velox/common/base/CountBits.h b/velox/common/base/CountBits.h
index b267d2f636ef..f40fb95355e5 100644
--- a/velox/common/base/CountBits.h
+++ b/velox/common/base/CountBits.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include <folly/CPortability.h>
+
 namespace facebook::velox {
 
 // Copied from format.h of fmt.
diff --git a/velox/common/base/Counters.cpp b/velox/common/base/Counters.cpp
index ed7de5f18959..6e88aa653e86 100644
--- a/velox/common/base/Counters.cpp
+++ b/velox/common/base/Counters.cpp
@@ -45,6 +45,9 @@ void registerVeloxMetrics() {
   DEFINE_HISTOGRAM_METRIC(
       kMetricTaskBarrierProcessTimeMs, 1'000, 0, 30'000, 50, 90, 99, 100);
 
+  // Tracks the total number of splits received by all tasks.
+  DEFINE_METRIC(kMetricTaskSplitsCount, facebook::velox::StatType::COUNT);
+
   /// ================== Cache Counters =================
 
   // Tracks hive handle generation latency in range of [0, 100s] and reports
@@ -75,6 +78,14 @@ void registerVeloxMetrics() {
   DEFINE_METRIC(
       kMetricMemoryAllocatorMappedBytes, facebook::velox::StatType::AVG);
 
+  // Number of bytes allocated and explicitly mmap'd by the application via
+  // allocateContiguous, outside of 'sizeClasses'. These pages are counted in
+  // 'kMetricMemoryAllocatorAllocatedBytes' and
+  // 'kMetricMemoryAllocatorMappedBytes'.
+  DEFINE_METRIC(
+      kMetricMemoryAllocatorExternalMappedBytes,
+      facebook::velox::StatType::AVG);
+
   // Number of bytes currently allocated (used) from MemoryAllocator in the form
   // of 'Allocation' or 'ContiguousAllocation'.
   DEFINE_METRIC(
@@ -84,13 +95,6 @@ void registerVeloxMetrics() {
   DEFINE_METRIC(
       kMetricMemoryAllocatorTotalUsedBytes, facebook::velox::StatType::AVG);
 
-  // Number of bytes currently mapped in MmapAllocator, in the form of
-  // 'ContiguousAllocation'.
-  //
-  // NOTE: This applies only to MmapAllocator
-  DEFINE_METRIC(
-      kMetricMmapAllocatorExternalMappedBytes, 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.
@@ -106,8 +110,13 @@ void registerVeloxMetrics() {
   // 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 tiny cache entries.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumTinyEntries, facebook::velox::StatType::AVG);
+
+  // Total number of large cache entries.
+  DEFINE_METRIC(
+      kMetricMemoryCacheNumLargeEntries, facebook::velox::StatType::AVG);
 
   // Total number of cache entries that do not cache anything.
   DEFINE_METRIC(
@@ -248,6 +257,10 @@ void registerVeloxMetrics() {
   // Total number of error while writing to SSD cache files.
   DEFINE_METRIC(kMetricSsdCacheWriteSsdErrors, facebook::velox::StatType::SUM);
 
+  // Total number of errors due to SSD no space for writes.
+  DEFINE_METRIC(
+      kMetricSsdCacheWriteNoSpaceErrors, facebook::velox::StatType::SUM);
+
   // Total number of errors while writing SSD checkpoint file.
   DEFINE_METRIC(
       kMetricSsdCacheWriteCheckpointErrors, facebook::velox::StatType::SUM);
@@ -255,6 +268,10 @@ void registerVeloxMetrics() {
   // Total number of writes dropped due to no cache space.
   DEFINE_METRIC(kMetricSsdCacheWriteSsdDropped, facebook::velox::StatType::SUM);
 
+  // Total number of writes dropped due to entry limit exceeded.
+  DEFINE_METRIC(
+      kMetricSsdCacheWriteExceedEntryLimit, facebook::velox::StatType::SUM);
+
   // Total number of errors while reading from SSD cache files.
   DEFINE_METRIC(kMetricSsdCacheReadSsdErrors, facebook::velox::StatType::SUM);
 
@@ -364,9 +381,6 @@ void registerVeloxMetrics() {
       kMetricTaskMemoryReclaimWaitTimeoutCount,
       facebook::velox::StatType::COUNT);
 
-  // Tracks the total number of splits received by all tasks.
-  DEFINE_METRIC(kMetricTaskSplitsCount, 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
@@ -643,16 +657,17 @@ void registerVeloxMetrics() {
   DEFINE_HISTOGRAM_METRIC(
       kMetricIndexLookupBlockedWaitTimeMs, 32, 0, 16L << 10, 50, 90, 99, 100);
 
+  // The number of index lookup results with error.
+  DEFINE_METRIC(
+      kMetricIndexLookupErrorResultCount, facebook::velox::StatType::COUNT);
+
   /// ================== Table Scan Counters =================
-  // The time distribution of table scan batch processing time in range of [0,
-  // 16s] with 512 buckets and reports P50, P90, P99, and P100.
-  DEFINE_HISTOGRAM_METRIC(
-      kMetricTableScanBatchProcessTimeMs, 32, 0, 16L << 10, 50, 90, 99, 100);
+  // Tracks the averaged table scan batch processing time in milliseconds.
+  DEFINE_METRIC(
+      kMetricTableScanBatchProcessTimeMs, facebook::velox::StatType::AVG);
 
-  // The size distribution of table scan output batch in range of [0, 512MB]
-  // with 512 buckets and reports P50, P90, P99, and P100
-  DEFINE_HISTOGRAM_METRIC(
-      kMetricTableScanBatchBytes, 1L << 20, 0, 512L << 20, 50, 90, 99, 100);
+  // Tracks the averaged table scan output batch size in bytes.
+  DEFINE_METRIC(kMetricTableScanBatchBytes, facebook::velox::StatType::AVG);
 
   /// ================== Storage Counters =================
 
diff --git a/velox/common/base/Counters.h b/velox/common/base/Counters.h
index 78703336eb68..3a144f1bc881 100644
--- a/velox/common/base/Counters.h
+++ b/velox/common/base/Counters.h
@@ -23,373 +23,374 @@ namespace facebook::velox {
 /// Velox metrics Registration.
 void registerVeloxMetrics();
 
-constexpr folly::StringPiece kMetricHiveFileHandleGenerateLatencyMs{
+constexpr std::string_view kMetricHiveFileHandleGenerateLatencyMs{
     "velox.hive_file_handle_generate_latency_ms"};
 
-constexpr folly::StringPiece kMetricCacheShrinkCount{
-    "velox.cache_shrink_count"};
+constexpr std::string_view kMetricCacheShrinkCount{"velox.cache_shrink_count"};
 
-constexpr folly::StringPiece kMetricCacheShrinkTimeMs{"velox.cache_shrink_ms"};
+constexpr std::string_view kMetricCacheShrinkTimeMs{"velox.cache_shrink_ms"};
 
-constexpr folly::StringPiece kMetricMaxSpillLevelExceededCount{
+constexpr std::string_view kMetricMaxSpillLevelExceededCount{
     "velox.spill_max_level_exceeded_count"};
 
-constexpr folly::StringPiece kMetricQueryMemoryReclaimTimeMs{
+constexpr std::string_view kMetricQueryMemoryReclaimTimeMs{
     "velox.query_memory_reclaim_time_ms"};
 
-constexpr folly::StringPiece kMetricQueryMemoryReclaimedBytes{
+constexpr std::string_view kMetricQueryMemoryReclaimedBytes{
     "velox.query_memory_reclaim_bytes"};
 
-constexpr folly::StringPiece kMetricQueryMemoryReclaimCount{
+constexpr std::string_view kMetricQueryMemoryReclaimCount{
     "velox.query_memory_reclaim_count"};
 
-constexpr folly::StringPiece kMetricTaskMemoryReclaimCount{
+constexpr std::string_view kMetricTaskMemoryReclaimCount{
     "velox.task_memory_reclaim_count"};
 
-constexpr folly::StringPiece kMetricTaskMemoryReclaimWaitTimeMs{
+constexpr std::string_view kMetricTaskMemoryReclaimWaitTimeMs{
     "velox.task_memory_reclaim_wait_ms"};
 
-constexpr folly::StringPiece kMetricTaskMemoryReclaimExecTimeMs{
+constexpr std::string_view kMetricTaskMemoryReclaimExecTimeMs{
     "velox.task_memory_reclaim_exec_ms"};
 
-constexpr folly::StringPiece kMetricTaskMemoryReclaimWaitTimeoutCount{
+constexpr std::string_view kMetricTaskMemoryReclaimWaitTimeoutCount{
     "velox.task_memory_reclaim_wait_timeout_count"};
 
-constexpr folly::StringPiece kMetricTaskSplitsCount{"velox.task_splits_count"};
+constexpr std::string_view kMetricTaskSplitsCount{"velox.task_splits_count"};
 
-constexpr folly::StringPiece kMetricOpMemoryReclaimTimeMs{
+constexpr std::string_view kMetricOpMemoryReclaimTimeMs{
     "velox.op_memory_reclaim_time_ms"};
 
-constexpr folly::StringPiece kMetricOpMemoryReclaimedBytes{
+constexpr std::string_view kMetricOpMemoryReclaimedBytes{
     "velox.op_memory_reclaim_bytes"};
 
-constexpr folly::StringPiece kMetricOpMemoryReclaimCount{
+constexpr std::string_view kMetricOpMemoryReclaimCount{
     "velox.op_memory_reclaim_count"};
 
-constexpr folly::StringPiece kMetricMemoryNonReclaimableCount{
+constexpr std::string_view kMetricMemoryNonReclaimableCount{
     "velox.memory_non_reclaimable_count"};
 
-constexpr folly::StringPiece kMetricMemoryPoolInitialCapacityBytes{
+constexpr std::string_view kMetricMemoryPoolInitialCapacityBytes{
     "velox.memory_pool_initial_capacity_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryPoolCapacityGrowCount{
+constexpr std::string_view kMetricMemoryPoolCapacityGrowCount{
     "velox.memory_pool_capacity_growth_count"};
 
-constexpr folly::StringPiece kMetricMemoryPoolUsageLeakBytes{
+constexpr std::string_view kMetricMemoryPoolUsageLeakBytes{
     "velox.memory_pool_usage_leak_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryPoolReservationLeakBytes{
+constexpr std::string_view kMetricMemoryPoolReservationLeakBytes{
     "velox.memory_pool_reservation_leak_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorDoubleFreeCount{
+constexpr std::string_view kMetricMemoryAllocatorDoubleFreeCount{
     "velox.memory_allocator_double_free_count"};
 
-constexpr folly::StringPiece kMetricArbitratorLocalArbitrationCount{
+constexpr std::string_view kMetricArbitratorLocalArbitrationCount{
     "velox.arbitrator_local_arbitration_count"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationCount{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationCount{
     "velox.arbitrator_global_arbitration_count"};
 
-constexpr folly::StringPiece
-    kMetricArbitratorGlobalArbitrationNumReclaimVictims{
-        "velox.arbitrator_global_arbitration_num_reclaim_victims"};
+constexpr std::string_view kMetricArbitratorGlobalArbitrationNumReclaimVictims{
+    "velox.arbitrator_global_arbitration_num_reclaim_victims"};
 
-constexpr folly::StringPiece
-    kMetricArbitratorGlobalArbitrationFailedVictimCount{
-        "velox.arbitrator_global_arbitration_failed_victim_count"};
+constexpr std::string_view kMetricArbitratorGlobalArbitrationFailedVictimCount{
+    "velox.arbitrator_global_arbitration_failed_victim_count"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationBytes{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationBytes{
     "velox.arbitrator_global_arbitration_bytes"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationTimeMs{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationTimeMs{
     "velox.arbitrator_global_arbitration_time_ms"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationWaitCount{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationWaitCount{
     "velox.arbitrator_global_arbitration_wait_count"};
 
-constexpr folly::StringPiece kMetricArbitratorGlobalArbitrationWaitTimeMs{
+constexpr std::string_view kMetricArbitratorGlobalArbitrationWaitTimeMs{
     "velox.arbitrator_global_arbitration_wait_time_ms"};
 
-constexpr folly::StringPiece kMetricArbitratorAbortedCount{
+constexpr std::string_view kMetricArbitratorAbortedCount{
     "velox.arbitrator_aborted_count"};
 
-constexpr folly::StringPiece kMetricArbitratorFailuresCount{
+constexpr std::string_view kMetricArbitratorFailuresCount{
     "velox.arbitrator_failures_count"};
 
-constexpr folly::StringPiece kMetricArbitratorOpExecTimeMs{
+constexpr std::string_view kMetricArbitratorOpExecTimeMs{
     "velox.arbitrator_op_exec_time_ms"};
 
-constexpr folly::StringPiece kMetricArbitratorFreeCapacityBytes{
+constexpr std::string_view kMetricArbitratorFreeCapacityBytes{
     "velox.arbitrator_free_capacity_bytes"};
 
-constexpr folly::StringPiece kMetricArbitratorFreeReservedCapacityBytes{
+constexpr std::string_view kMetricArbitratorFreeReservedCapacityBytes{
     "velox.arbitrator_free_reserved_capacity_bytes"};
 
-constexpr folly::StringPiece kMetricDriverYieldCount{
-    "velox.driver_yield_count"};
+constexpr std::string_view kMetricDriverYieldCount{"velox.driver_yield_count"};
 
-constexpr folly::StringPiece kMetricDriverQueueTimeMs{
+constexpr std::string_view kMetricDriverQueueTimeMs{
     "velox.driver_queue_time_ms"};
 
-constexpr folly::StringPiece kMetricDriverExecTimeMs{
-    "velox.driver_exec_time_ms"};
+constexpr std::string_view kMetricDriverExecTimeMs{"velox.driver_exec_time_ms"};
 
-constexpr folly::StringPiece kMetricSpilledInputBytes{
-    "velox.spill_input_bytes"};
+constexpr std::string_view kMetricSpilledInputBytes{"velox.spill_input_bytes"};
 
-constexpr folly::StringPiece kMetricSpilledBytes{"velox.spill_bytes"};
+constexpr std::string_view kMetricSpilledBytes{"velox.spill_bytes"};
 
-constexpr folly::StringPiece kMetricSpilledRowsCount{"velox.spill_rows_count"};
+constexpr std::string_view kMetricSpilledRowsCount{"velox.spill_rows_count"};
 
-constexpr folly::StringPiece kMetricSpilledFilesCount{
-    "velox.spill_files_count"};
+constexpr std::string_view kMetricSpilledFilesCount{"velox.spill_files_count"};
 
-constexpr folly::StringPiece kMetricSpillFillTimeMs{"velox.spill_fill_time_ms"};
+constexpr std::string_view kMetricSpillFillTimeMs{"velox.spill_fill_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillSortTimeMs{"velox.spill_sort_time_ms"};
+constexpr std::string_view kMetricSpillSortTimeMs{"velox.spill_sort_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillExtractVectorTimeMs{
+constexpr std::string_view kMetricSpillExtractVectorTimeMs{
     "velox.spill_extract_vector_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillSerializationTimeMs{
+constexpr std::string_view kMetricSpillSerializationTimeMs{
     "velox.spill_serialization_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillWritesCount{
-    "velox.spill_writes_count"};
+constexpr std::string_view kMetricSpillWritesCount{"velox.spill_writes_count"};
 
-constexpr folly::StringPiece kMetricSpillFlushTimeMs{
-    "velox.spill_flush_time_ms"};
+constexpr std::string_view kMetricSpillFlushTimeMs{"velox.spill_flush_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillWriteTimeMs{
-    "velox.spill_write_time_ms"};
+constexpr std::string_view kMetricSpillWriteTimeMs{"velox.spill_write_time_ms"};
 
-constexpr folly::StringPiece kMetricSpillMemoryBytes{
-    "velox.spill_memory_bytes"};
+constexpr std::string_view kMetricSpillMemoryBytes{"velox.spill_memory_bytes"};
 
-constexpr folly::StringPiece kMetricSpillPeakMemoryBytes{
+constexpr std::string_view kMetricSpillPeakMemoryBytes{
     "velox.spill_peak_memory_bytes"};
 
-constexpr folly::StringPiece kMetricFileWriterEarlyFlushedRawBytes{
+constexpr std::string_view kMetricFileWriterEarlyFlushedRawBytes{
     "velox.file_writer_early_flushed_raw_bytes"};
 
-constexpr folly::StringPiece kMetricHiveSortWriterFinishTimeMs{
+constexpr std::string_view kMetricHiveSortWriterFinishTimeMs{
     "velox.hive_sort_writer_finish_time_ms"};
 
-constexpr folly::StringPiece kMetricArbitratorRequestsCount{
+constexpr std::string_view kMetricArbitratorRequestsCount{
     "velox.arbitrator_requests_count"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorMappedBytes{
+constexpr std::string_view kMetricMemoryAllocatorMappedBytes{
     "velox.memory_allocator_mapped_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorAllocatedBytes{
+constexpr std::string_view kMetricMemoryAllocatorExternalMappedBytes{
+    "velox.memory_allocator_external_mapped_bytes"};
+
+constexpr std::string_view kMetricMemoryAllocatorAllocatedBytes{
     "velox.memory_allocator_allocated_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryAllocatorTotalUsedBytes{
+constexpr std::string_view kMetricMemoryAllocatorTotalUsedBytes{
     "velox.memory_allocator_total_used_bytes"};
 
-constexpr folly::StringPiece kMetricMmapAllocatorExternalMappedBytes{
-    "velox.mmap_allocator_external_mapped_bytes"};
-
-constexpr folly::StringPiece kMetricMmapAllocatorDelegatedAllocatedBytes{
+constexpr std::string_view kMetricMmapAllocatorDelegatedAllocatedBytes{
     "velox.mmap_allocator_delegated_allocated_bytes"};
 
-constexpr folly::StringPiece kMetricCacheMaxAgeSecs{"velox.cache_max_age_secs"};
+constexpr std::string_view kMetricCacheMaxAgeSecs{"velox.cache_max_age_secs"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumEntries{
-    "velox.memory_cache_num_entries"};
+constexpr std::string_view kMetricMemoryCacheNumTinyEntries{
+    "velox.memory_cache_num_tiny_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumEmptyEntries{
+constexpr std::string_view kMetricMemoryCacheNumLargeEntries{
+    "velox.memory_cache_num_large_entries"};
+
+constexpr std::string_view kMetricMemoryCacheNumEmptyEntries{
     "velox.memory_cache_num_empty_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumSharedEntries{
+constexpr std::string_view kMetricMemoryCacheNumSharedEntries{
     "velox.memory_cache_num_shared_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumExclusiveEntries{
+constexpr std::string_view kMetricMemoryCacheNumExclusiveEntries{
     "velox.memory_cache_num_exclusive_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumPrefetchedEntries{
+constexpr std::string_view kMetricMemoryCacheNumPrefetchedEntries{
     "velox.memory_cache_num_prefetched_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalTinyBytes{
+constexpr std::string_view kMetricMemoryCacheTotalTinyBytes{
     "velox.memory_cache_total_tiny_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalLargeBytes{
+constexpr std::string_view kMetricMemoryCacheTotalLargeBytes{
     "velox.memory_cache_total_large_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalTinyPaddingBytes{
+constexpr std::string_view kMetricMemoryCacheTotalTinyPaddingBytes{
     "velox.memory_cache_total_tiny_padding_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalLargePaddingBytes{
+constexpr std::string_view kMetricMemoryCacheTotalLargePaddingBytes{
     "velox.memory_cache_total_large_padding_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheTotalPrefetchBytes{
+constexpr std::string_view kMetricMemoryCacheTotalPrefetchBytes{
     "velox.memory_cache_total_prefetched_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheSumEvictScore{
+constexpr std::string_view kMetricMemoryCacheSumEvictScore{
     "velox.memory_cache_sum_evict_score"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumHits{
+constexpr std::string_view kMetricMemoryCacheNumHits{
     "velox.memory_cache_num_hits"};
 
-constexpr folly::StringPiece kMetricMemoryCacheHitBytes{
+constexpr std::string_view kMetricMemoryCacheHitBytes{
     "velox.memory_cache_hit_bytes"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumNew{
+constexpr std::string_view kMetricMemoryCacheNumNew{
     "velox.memory_cache_num_new"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumEvicts{
+constexpr std::string_view kMetricMemoryCacheNumEvicts{
     "velox.memory_cache_num_evicts"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumSavableEvicts{
+constexpr std::string_view kMetricMemoryCacheNumSavableEvicts{
     "velox.memory_cache_num_savable_evicts"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumEvictChecks{
+constexpr std::string_view kMetricMemoryCacheNumEvictChecks{
     "velox.memory_cache_num_evict_checks"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumWaitExclusive{
+constexpr std::string_view kMetricMemoryCacheNumWaitExclusive{
     "velox.memory_cache_num_wait_exclusive"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumAllocClocks{
+constexpr std::string_view kMetricMemoryCacheNumAllocClocks{
     "velox.memory_cache_num_alloc_clocks"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumAgedOutEntries{
+constexpr std::string_view kMetricMemoryCacheNumAgedOutEntries{
     "velox.memory_cache_num_aged_out_entries"};
 
-constexpr folly::StringPiece kMetricMemoryCacheNumStaleEntries{
+constexpr std::string_view kMetricMemoryCacheNumStaleEntries{
     "velox.memory_cache_num_stale_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheCachedRegions{
+constexpr std::string_view kMetricSsdCacheCachedRegions{
     "velox.ssd_cache_cached_regions"};
 
-constexpr folly::StringPiece kMetricSsdCacheCachedEntries{
+constexpr std::string_view kMetricSsdCacheCachedEntries{
     "velox.ssd_cache_cached_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheCachedBytes{
+constexpr std::string_view kMetricSsdCacheCachedBytes{
     "velox.ssd_cache_cached_bytes"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadEntries{
+constexpr std::string_view kMetricSsdCacheReadEntries{
     "velox.ssd_cache_read_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadBytes{
+constexpr std::string_view kMetricSsdCacheReadBytes{
     "velox.ssd_cache_read_bytes"};
 
-constexpr folly::StringPiece kMetricSsdCacheWrittenEntries{
+constexpr std::string_view kMetricSsdCacheWrittenEntries{
     "velox.ssd_cache_written_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheWrittenBytes{
+constexpr std::string_view kMetricSsdCacheWrittenBytes{
     "velox.ssd_cache_written_bytes"};
 
-constexpr folly::StringPiece kMetricSsdCacheAgedOutEntries{
+constexpr std::string_view kMetricSsdCacheAgedOutEntries{
     "velox.ssd_cache_aged_out_entries"};
 
-constexpr folly::StringPiece kMetricSsdCacheAgedOutRegions{
+constexpr std::string_view kMetricSsdCacheAgedOutRegions{
     "velox.ssd_cache_aged_out_regions"};
 
-constexpr folly::StringPiece kMetricSsdCacheOpenSsdErrors{
+constexpr std::string_view kMetricSsdCacheOpenSsdErrors{
     "velox.ssd_cache_open_ssd_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheOpenCheckpointErrors{
+constexpr std::string_view kMetricSsdCacheOpenCheckpointErrors{
     "velox.ssd_cache_open_checkpoint_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheOpenLogErrors{
+constexpr std::string_view kMetricSsdCacheOpenLogErrors{
     "velox.ssd_cache_open_log_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheMetaFileDeleteErrors{
+constexpr std::string_view kMetricSsdCacheMetaFileDeleteErrors{
     "velox.ssd_cache_delete_meta_file_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheGrowFileErrors{
+constexpr std::string_view kMetricSsdCacheGrowFileErrors{
     "velox.ssd_cache_grow_file_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheWriteSsdErrors{
+constexpr std::string_view kMetricSsdCacheWriteSsdErrors{
     "velox.ssd_cache_write_ssd_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheWriteSsdDropped{
+constexpr std::string_view kMetricSsdCacheWriteNoSpaceErrors{
+    "velox.ssd_cache_write_no_space_errors"};
+
+constexpr std::string_view kMetricSsdCacheWriteSsdDropped{
     "velox.ssd_cache_write_ssd_dropped"};
 
-constexpr folly::StringPiece kMetricSsdCacheWriteCheckpointErrors{
+constexpr std::string_view kMetricSsdCacheWriteExceedEntryLimit{
+    "velox.ssd_cache_write_exceed_entry_limit"};
+
+constexpr std::string_view kMetricSsdCacheWriteCheckpointErrors{
     "velox.ssd_cache_write_checkpoint_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadCorruptions{
+constexpr std::string_view kMetricSsdCacheReadCorruptions{
     "velox.ssd_cache_read_corruptions"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadSsdErrors{
+constexpr std::string_view kMetricSsdCacheReadSsdErrors{
     "velox.ssd_cache_read_ssd_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadCheckpointErrors{
+constexpr std::string_view kMetricSsdCacheReadCheckpointErrors{
     "velox.ssd_cache_read_checkpoint_errors"};
 
-constexpr folly::StringPiece kMetricSsdCacheReadWithoutChecksum{
+constexpr std::string_view kMetricSsdCacheReadWithoutChecksum{
     "velox.ssd_cache_read_without_checksum"};
 
-constexpr folly::StringPiece kMetricSsdCacheCheckpointsRead{
+constexpr std::string_view kMetricSsdCacheCheckpointsRead{
     "velox.ssd_cache_checkpoints_read"};
 
-constexpr folly::StringPiece kMetricSsdCacheCheckpointsWritten{
+constexpr std::string_view kMetricSsdCacheCheckpointsWritten{
     "velox.ssd_cache_checkpoints_written"};
 
-constexpr folly::StringPiece kMetricSsdCacheRegionsEvicted{
+constexpr std::string_view kMetricSsdCacheRegionsEvicted{
     "velox.ssd_cache_regions_evicted"};
 
-constexpr folly::StringPiece kMetricSsdCacheRecoveredEntries{
+constexpr std::string_view kMetricSsdCacheRecoveredEntries{
     "velox.ssd_cache_recovered_entries"};
 
-constexpr folly::StringPiece kMetricExchangeTransactionCreateDelay{
+constexpr std::string_view kMetricExchangeTransactionCreateDelay{
     "velox.exchange.transaction_create_delay_ms"};
 
-constexpr folly::StringPiece kMetricExchangeDataTimeMs{
+constexpr std::string_view kMetricExchangeDataTimeMs{
     "velox.exchange_data_time_ms"};
 
-constexpr folly::StringPiece kMetricExchangeDataBytes{
+constexpr std::string_view kMetricExchangeDataBytes{
     "velox.exchange_data_bytes"};
 
-constexpr folly::StringPiece kMetricExchangeDataSize{
-    "velox.exchange_data_size"};
+constexpr std::string_view kMetricExchangeDataSize{"velox.exchange_data_size"};
 
-constexpr folly::StringPiece kMetricExchangeDataCount{
+constexpr std::string_view kMetricExchangeDataCount{
     "velox.exchange_data_count"};
 
-constexpr folly::StringPiece kMetricExchangeDataSizeTimeMs{
+constexpr std::string_view kMetricExchangeDataSizeTimeMs{
     "velox.exchange_data_size_time_ms"};
 
-constexpr folly::StringPiece kMetricExchangeDataSizeCount{
+constexpr std::string_view kMetricExchangeDataSizeCount{
     "velox.exchange_data_size_count"};
 
-constexpr folly::StringPiece kMetricStorageThrottledDurationMs{
+constexpr std::string_view kMetricStorageThrottledDurationMs{
     "velox.storage_throttled_duration_ms"};
 
-constexpr folly::StringPiece kMetricStorageLocalThrottled{
+constexpr std::string_view kMetricStorageLocalThrottled{
     "velox.storage_local_throttled_count"};
 
-constexpr folly::StringPiece kMetricStorageGlobalThrottled{
+constexpr std::string_view kMetricStorageGlobalThrottled{
     "velox.storage_global_throttled_count"};
 
-constexpr folly::StringPiece kMetricStorageNetworkThrottled{
+constexpr std::string_view kMetricStorageNetworkThrottled{
     "velox.storage_network_throttled_count"};
 
-constexpr folly::StringPiece kMetricIndexLookupResultRawBytes{
+constexpr std::string_view kMetricIndexLookupResultRawBytes{
     "velox.index_lookup_result_raw_bytes"};
 
-constexpr folly::StringPiece kMetricIndexLookupResultBytes{
+constexpr std::string_view kMetricIndexLookupResultBytes{
     "velox.index_lookup_result_bytes"};
 
-constexpr folly::StringPiece kMetricIndexLookupTimeMs{
+constexpr std::string_view kMetricIndexLookupTimeMs{
     "velox.index_lookup_time_ms"};
 
-constexpr folly::StringPiece kMetricIndexLookupWaitTimeMs{
+constexpr std::string_view kMetricIndexLookupWaitTimeMs{
     "velox.index_lookup_wait_time_ms"};
 
-constexpr folly::StringPiece kMetricIndexLookupBlockedWaitTimeMs{
+constexpr std::string_view kMetricIndexLookupBlockedWaitTimeMs{
     "velox.index_lookup_blocked_wait_time_ms"};
 
-constexpr folly::StringPiece kMetricTableScanBatchProcessTimeMs{
+constexpr std::string_view kMetricIndexLookupErrorResultCount{
+    "velox.index_lookup_error_result_count"};
+
+constexpr std::string_view kMetricTableScanBatchProcessTimeMs{
     "velox.table_scan_batch_process_time_ms"};
 
-constexpr folly::StringPiece kMetricTableScanBatchBytes{
+constexpr std::string_view kMetricTableScanBatchBytes{
     "velox.table_scan_batch_bytes"};
 
-constexpr folly::StringPiece kMetricTaskBatchProcessTimeMs{
+constexpr std::string_view kMetricTaskBatchProcessTimeMs{
     "velox.task_batch_process_time_ms"};
 
-constexpr folly::StringPiece kMetricTaskBarrierProcessTimeMs{
+constexpr std::string_view kMetricTaskBarrierProcessTimeMs{
     "velox.task_barrier_process_time_ms"};
+
 } // namespace facebook::velox
diff --git a/velox/common/base/ExceptionHelper.h b/velox/common/base/ExceptionHelper.h
new file mode 100644
index 000000000000..193641ce63ae
--- /dev/null
+++ b/velox/common/base/ExceptionHelper.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.
+ */
+
+#pragma once
+
+#include <fmt/format.h>
+#include <string>
+
+namespace facebook::velox {
+
+struct CompileTimeEmptyString {
+  CompileTimeEmptyString() = default;
+  constexpr operator const char*() const {
+    return "";
+  }
+  constexpr operator std::string_view() const {
+    return {};
+  }
+  operator std::string() const {
+    return {};
+  }
+};
+
+// When there is no message passed, we can statically detect this case
+// and avoid passing even a single unnecessary argument pointer,
+// minimizing size and thus maximizing eligibility for inlining.
+inline CompileTimeEmptyString errorMessage() {
+  return {};
+}
+
+inline const char* errorMessage(const char* s) {
+  return s;
+}
+
+inline std::string errorMessage(const std::string& str) {
+  return str;
+}
+
+template <typename... Args>
+std::string errorMessage(fmt::string_view fmt, const Args&... args) {
+  return fmt::vformat(fmt, fmt::make_format_args(args...));
+}
+} // namespace facebook::velox
diff --git a/velox/common/base/Exceptions.h b/velox/common/base/Exceptions.h
index 11fa7ae9ec59..4485b8b006a4 100644
--- a/velox/common/base/Exceptions.h
+++ b/velox/common/base/Exceptions.h
@@ -19,10 +19,10 @@
 #include <memory>
 #include <sstream>
 
-#include <fmt/format.h>
 #include <fmt/ostream.h>
 #include <folly/Preprocessor.h>
 
+#include "velox/common/base/ExceptionHelper.h"
 #include "velox/common/base/FmtStdFormatters.h"
 #include "velox/common/base/VeloxException.h"
 
@@ -39,19 +39,6 @@ struct VeloxCheckFailArgs {
   bool isRetriable;
 };
 
-struct CompileTimeEmptyString {
-  CompileTimeEmptyString() = default;
-  constexpr operator const char*() const {
-    return "";
-  }
-  constexpr operator std::string_view() const {
-    return {};
-  }
-  operator std::string() const {
-    return {};
-  }
-};
-
 // veloxCheckFail is defined as a separate helper function rather than
 // a macro or inline `throw` expression to allow the compiler *not* to
 // inline it when it is large. Having an out-of-line error path helps
@@ -131,46 +118,26 @@ struct VeloxCheckFailStringType<std::string> {
   template void veloxCheckFail<exception_type, const std::string&>(     \
       const VeloxCheckFailArgs& args, const std::string&);
 
-// When there is no message passed, we can statically detect this case
-// and avoid passing even a single unnecessary argument pointer,
-// minimizing size and thus maximizing eligibility for inlining.
-inline CompileTimeEmptyString errorMessage() {
-  return {};
-}
-
-inline const char* errorMessage(const char* s) {
-  return s;
-}
-
-inline std::string errorMessage(const std::string& str) {
-  return str;
-}
-
-template <typename... Args>
-std::string errorMessage(fmt::string_view fmt, const Args&... args) {
-  return fmt::vformat(fmt, fmt::make_format_args(args...));
-}
-
 } // namespace detail
 
-#define _VELOX_THROW_IMPL(                                               \
-    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__,                                                \
-            exprStr,                                                     \
-            errorSource,                                                 \
-            errorCode,                                                   \
-            isRetriable};                                                \
-    auto message = ::facebook::velox::detail::errorMessage(__VA_ARGS__); \
-    ::facebook::velox::detail::veloxCheckFail<                           \
-        exception,                                                       \
-        typename ::facebook::velox::detail::VeloxCheckFailStringType<    \
-            decltype(message)>::type>(veloxCheckFailArgs, message);      \
+#define _VELOX_THROW_IMPL(                                            \
+    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__,                                             \
+            exprStr,                                                  \
+            errorSource,                                              \
+            errorCode,                                                \
+            isRetriable};                                             \
+    auto message = ::facebook::velox::errorMessage(__VA_ARGS__);      \
+    ::facebook::velox::detail::veloxCheckFail<                        \
+        exception,                                                    \
+        typename ::facebook::velox::detail::VeloxCheckFailStringType< \
+            decltype(message)>::type>(veloxCheckFailArgs, message);   \
   } while (0)
 
 #define _VELOX_CHECK_AND_THROW_IMPL(                                    \
diff --git a/velox/common/base/Macros.h b/velox/common/base/Macros.h
index 48bc0f38dcdf..62664a488f53 100644
--- a/velox/common/base/Macros.h
+++ b/velox/common/base/Macros.h
@@ -32,3 +32,13 @@
 // Need this extra layer to expand __COUNTER__.
 #define VELOX_VARNAME_IMPL(x, y) VELOX_CONCAT(x, y)
 #define VELOX_VARNAME(x) VELOX_VARNAME_IMPL(x, __COUNTER__)
+
+// Workaround for GCC bug, it was fixed only in GCC 13.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93413
+// TLDR: GCC 12 and earlier do not support constexpr static variables for
+// non-template classes with virtual default destructors.
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 13
+#define VELOX_CONSTEXPR_SINGLETON static const
+#else
+#define VELOX_CONSTEXPR_SINGLETON static constexpr
+#endif
diff --git a/velox/common/base/Nulls.h b/velox/common/base/Nulls.h
index b3d7e7d5a7fa..cc84ea7efc96 100644
--- a/velox/common/base/Nulls.h
+++ b/velox/common/base/Nulls.h
@@ -34,28 +34,29 @@ constexpr char kNotNullByte = 0xff;
 constexpr uint64_t kNull64 = 0UL;
 constexpr uint64_t kNotNull64 = (~0UL);
 
-inline bool isBitNull(const uint64_t* bits, int32_t index) {
+inline bool isBitNull(const uint64_t* bits, uint32_t index) {
   return isBitSet(bits, index) == kNull;
 }
 
-inline void setNull(uint64_t* bits, int32_t index) {
+inline void setNull(uint64_t* bits, uint32_t index) {
   clearBit(bits, index);
 }
 
-inline void clearNull(uint64_t* bits, int32_t index) {
+inline void clearNull(uint64_t* bits, uint32_t index) {
   setBit(bits, index);
 }
 
-inline void setNull(uint64_t* bits, int32_t index, bool isNull) {
+inline void setNull(uint64_t* bits, uint32_t index, bool isNull) {
   setBit(bits, index, !isNull);
 }
 
 inline uint64_t
-countNonNulls(const uint64_t* nulls, int32_t begin, int32_t end) {
+countNonNulls(const uint64_t* nulls, uint32_t begin, uint32_t end) {
   return countBits(nulls, begin, end);
 }
 
-inline uint64_t countNulls(const uint64_t* nulls, int32_t begin, int32_t end) {
+inline uint64_t
+countNulls(const uint64_t* nulls, uint32_t begin, uint32_t end) {
   return (end - begin) - countNonNulls(nulls, begin, end);
 }
 
diff --git a/velox/common/base/PeriodicStatsReporter.cpp b/velox/common/base/PeriodicStatsReporter.cpp
index ba9c3134dbed..fb07906dcfe8 100644
--- a/velox/common/base/PeriodicStatsReporter.cpp
+++ b/velox/common/base/PeriodicStatsReporter.cpp
@@ -112,21 +112,22 @@ void PeriodicStatsReporter::reportAllocatorStats() {
   RECORD_METRIC_VALUE(
       kMetricMemoryAllocatorMappedBytes,
       (velox::memory::AllocationTraits::pageBytes(allocator_->numMapped())));
+  RECORD_METRIC_VALUE(
+      kMetricMemoryAllocatorExternalMappedBytes,
+      (velox::memory::AllocationTraits::pageBytes(
+          allocator_->numExternalMapped())));
   RECORD_METRIC_VALUE(
       kMetricMemoryAllocatorAllocatedBytes,
       (velox::memory::AllocationTraits::pageBytes(allocator_->numAllocated())));
   RECORD_METRIC_VALUE(
       kMetricMemoryAllocatorTotalUsedBytes, (allocator_->totalUsedBytes()));
+
   // TODO(jtan6): Remove condition after T150019700 is done
   if (auto* mmapAllocator =
           dynamic_cast<const velox::memory::MmapAllocator*>(allocator_)) {
     RECORD_METRIC_VALUE(
         kMetricMmapAllocatorDelegatedAllocatedBytes,
         (mmapAllocator->numMallocBytes()));
-    RECORD_METRIC_VALUE(
-        kMetricMmapAllocatorExternalMappedBytes,
-        velox::memory::AllocationTraits::pageBytes(
-            (mmapAllocator->numExternalMapped())));
   }
   // TODO(xiaoxmeng): add memory allocation size stats.
 }
@@ -138,7 +139,10 @@ void PeriodicStatsReporter::reportCacheStats() {
   const auto cacheStats = cache_->refreshStats();
 
   // Memory cache snapshot stats.
-  RECORD_METRIC_VALUE(kMetricMemoryCacheNumEntries, cacheStats.numEntries);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheNumTinyEntries, cacheStats.numTinyEntries);
+  RECORD_METRIC_VALUE(
+      kMetricMemoryCacheNumLargeEntries, cacheStats.numLargeEntries);
   RECORD_METRIC_VALUE(
       kMetricMemoryCacheNumEmptyEntries, cacheStats.numEmptyEntries);
   RECORD_METRIC_VALUE(kMetricMemoryCacheNumSharedEntries, cacheStats.numShared);
@@ -207,8 +211,13 @@ void PeriodicStatsReporter::reportCacheStats() {
         kMetricSsdCacheGrowFileErrors, deltaSsdStats.growFileErrors);
     REPORT_IF_NOT_ZERO(
         kMetricSsdCacheWriteSsdErrors, deltaSsdStats.writeSsdErrors);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheWriteNoSpaceErrors, deltaSsdStats.writeSsdNoSpaceErrors);
     REPORT_IF_NOT_ZERO(
         kMetricSsdCacheWriteSsdDropped, deltaSsdStats.writeSsdDropped);
+    REPORT_IF_NOT_ZERO(
+        kMetricSsdCacheWriteExceedEntryLimit,
+        deltaSsdStats.writeSsdExceedEntryLimit);
     REPORT_IF_NOT_ZERO(
         kMetricSsdCacheWriteCheckpointErrors,
         deltaSsdStats.writeCheckpointErrors);
diff --git a/velox/common/base/Portability.h b/velox/common/base/Portability.h
index 60049fcc54c7..85e890585e58 100644
--- a/velox/common/base/Portability.h
+++ b/velox/common/base/Portability.h
@@ -19,6 +19,7 @@
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
+#include <mutex>
 #include <vector>
 
 inline size_t count_trailing_zeros(uint64_t x) {
diff --git a/velox/common/base/RuntimeMetrics.cpp b/velox/common/base/RuntimeMetrics.cpp
index 691eb9f4a403..3130cbcabef1 100644
--- a/velox/common/base/RuntimeMetrics.cpp
+++ b/velox/common/base/RuntimeMetrics.cpp
@@ -48,7 +48,7 @@ void RuntimeMetric::merge(const RuntimeMetric& other)
   max = std::max(max, other.max);
 }
 
-void RuntimeMetric::printMetric(std::stringstream& stream) const {
+void RuntimeMetric::printMetric(std::ostream& stream) const {
   switch (unit) {
     case RuntimeCounter::Unit::kNanos:
       stream << " sum: " << succinctNanos(sum) << ", count: " << count
@@ -80,7 +80,6 @@ std::string RuntimeMetric::toString() const {
           succinctNanos(min),
           succinctNanos(max),
           succinctNanos(count == 0 ? 0 : sum / count));
-      break;
     case RuntimeCounter::Unit::kBytes:
       return fmt::format(
           "sum:{}, count:{}, min:{}, max:{}, avg: {}",
@@ -89,7 +88,6 @@ std::string RuntimeMetric::toString() const {
           succinctBytes(min),
           succinctBytes(max),
           succinctBytes(count == 0 ? 0 : sum / count));
-      break;
     case RuntimeCounter::Unit::kNone:
       [[fallthrough]];
     default:
diff --git a/velox/common/base/RuntimeMetrics.h b/velox/common/base/RuntimeMetrics.h
index 55b4d027da9d..6402719fa970 100644
--- a/velox/common/base/RuntimeMetrics.h
+++ b/velox/common/base/RuntimeMetrics.h
@@ -19,9 +19,6 @@
 #include <fmt/format.h>
 #include <folly/CppAttributes.h>
 #include <limits>
-#include <sstream>
-
-#include "velox/common/base/SuccinctPrinter.h"
 
 namespace facebook::velox {
 
@@ -51,13 +48,21 @@ struct RuntimeMetric {
       RuntimeCounter::Unit _unit = RuntimeCounter::Unit::kNone)
       : unit(_unit), sum{value}, count{1}, min{value}, max{value} {}
 
+  explicit RuntimeMetric(
+      int64_t _sum,
+      int64_t _count,
+      int64_t _min,
+      int64_t _max,
+      RuntimeCounter::Unit _unit = RuntimeCounter::Unit::kNone)
+      : unit(_unit), sum{_sum}, count{_count}, min{_min}, max{_max} {}
+
   void addValue(int64_t value);
 
   /// Aggregate sets 'min' and 'max' to 'sum', also sets 'count' to 1 if
   /// positive.
   void aggregate();
 
-  void printMetric(std::stringstream& stream) const;
+  void printMetric(std::ostream& stream) const;
 
   void merge(const RuntimeMetric& other);
 
@@ -81,11 +86,10 @@ class BaseRuntimeStatWriter {
 /// thread.
 /// NOTE: This is only used by the Velox Driver at the moment, which ensures the
 /// active Operator is being used by the writer.
-void setThreadLocalRunTimeStatWriter(
-    BaseRuntimeStatWriter* FOLLY_NULLABLE writer);
+void setThreadLocalRunTimeStatWriter(BaseRuntimeStatWriter* writer);
 
 /// Retrives the current runtime stats writer.
-BaseRuntimeStatWriter* FOLLY_NULLABLE getThreadLocalRunTimeStatWriter();
+BaseRuntimeStatWriter* getThreadLocalRunTimeStatWriter();
 
 /// Writes runtime counter to the current Operator running on that thread.
 void addThreadLocalRuntimeStat(
@@ -95,8 +99,7 @@ void addThreadLocalRuntimeStat(
 /// Scope guard to conveniently set and revert back the current stat writer.
 class RuntimeStatWriterScopeGuard {
  public:
-  explicit RuntimeStatWriterScopeGuard(
-      BaseRuntimeStatWriter* FOLLY_NULLABLE writer)
+  explicit RuntimeStatWriterScopeGuard(BaseRuntimeStatWriter* writer)
       : prevWriter_(getThreadLocalRunTimeStatWriter()) {
     setThreadLocalRunTimeStatWriter(writer);
   }
@@ -106,7 +109,7 @@ class RuntimeStatWriterScopeGuard {
   }
 
  private:
-  BaseRuntimeStatWriter* const FOLLY_NULLABLE prevWriter_;
+  BaseRuntimeStatWriter* const prevWriter_;
 };
 
 } // namespace facebook::velox
diff --git a/velox/common/base/Semaphore.h b/velox/common/base/Semaphore.h
index 760a07262735..a18acc28ed8d 100644
--- a/velox/common/base/Semaphore.h
+++ b/velox/common/base/Semaphore.h
@@ -63,8 +63,8 @@ class Semaphore {
  private:
   std::mutex mutex_;
   std::condition_variable cv_;
-  volatile int32_t count_;
-  volatile int32_t numWaiting_{0};
+  int32_t count_;
+  int32_t numWaiting_{0};
 };
 
 } // namespace facebook::velox
diff --git a/velox/common/base/SimdUtil-inl.h b/velox/common/base/SimdUtil-inl.h
index ba5593e96e1a..937c86d9f7ee 100644
--- a/velox/common/base/SimdUtil-inl.h
+++ b/velox/common/base/SimdUtil-inl.h
@@ -25,6 +25,13 @@ XSIMD_DECLARE_SIMD_REGISTER(
 } // namespace xsimd::types
 #endif
 
+#if XSIMD_WITH_SVE
+#include <arm_sve.h>
+namespace xsimd::types {
+XSIMD_DECLARE_SIMD_REGISTER(bool, sve, detail::sve_vector_type<unsigned char>);
+}
+#endif
+
 namespace facebook::velox::simd {
 
 namespace detail {
@@ -91,6 +98,10 @@ struct BitMask<T, A, 1> {
     return (vaddv_u8(vget_high_u8(vmask)) << 8) | vaddv_u8(vget_low_u8(vmask));
   }
 #endif
+
+  static int toBitMask(xsimd::batch_bool<T, A> mask, const xsimd::generic&) {
+    return genericToBitMask(mask);
+  }
 };
 
 template <typename T, typename A>
@@ -290,9 +301,21 @@ template <>
 inline xsimd::batch_bool<float, xsimd::default_arch> leadingMask(
     int i,
     const xsimd::default_arch&) {
+  /*
+  With GCC builds, compiler throws an error "invalid cast" on reintepreting to
+  the same data type, in SVE 256's case, svbool_t
+  __attribute__((arm_sve_vector_bits(256))).
+  So this is a workaround for now. Can be updated once the bug in GCC is
+  resolved in future GCC versions.
+  */
+
+#if XSIMD_WITH_SVE && defined(__GNUC__) && !defined(__clang__)
+  return xsimd::batch_bool<float, xsimd::default_arch>(leadingMask32[i].data);
+#else
   return reinterpret_cast<
       xsimd::batch_bool<float, xsimd::default_arch>::register_type>(
       leadingMask32[i].data);
+#endif
 }
 
 template <>
@@ -306,9 +329,21 @@ template <>
 inline xsimd::batch_bool<double, xsimd::default_arch> leadingMask(
     int i,
     const xsimd::default_arch&) {
+  /*
+  With GCC builds, compiler throws an error "invalid cast" on reintepreting to
+  the same data type, in SVE 256's case, svbool_t
+  __attribute__((arm_sve_vector_bits(256))).
+  So this is a workaround for now. Can be updated once the bug in GCC is
+  resolved in future GCC versions.
+  */
+
+#if XSIMD_WITH_SVE && defined(__GNUC__) && !defined(__clang__)
+  return xsimd::batch_bool<double, xsimd::default_arch>(leadingMask64[i].data);
+#else
   return reinterpret_cast<
       xsimd::batch_bool<double, xsimd::default_arch>::register_type>(
       leadingMask64[i].data);
+#endif
 }
 
 } // namespace detail
@@ -341,7 +376,7 @@ struct CopyWord<xsimd::batch<int8_t, A>, A> {
 // sizeof(T). Returns false if 'bytes' went to 0.
 template <typename T, typename A>
 inline bool copyNextWord(void*& to, const void*& from, int64_t& bytes) {
-  if (bytes >= sizeof(T)) {
+  if (bytes >= static_cast<int64_t>(sizeof(T))) {
     CopyWord<T, A>::apply(to, from);
     bytes -= sizeof(T);
     if (!bytes) {
@@ -362,7 +397,7 @@ inline void memcpy(void* to, const void* from, int64_t bytes, const A& arch) {
       return;
     }
   }
-  while (bytes >= sizeof(int64_t)) {
+  while (bytes >= static_cast<int64_t>(sizeof(int64_t))) {
     if (!detail::copyNextWord<int64_t, A>(to, from, bytes)) {
       return;
     }
@@ -417,7 +452,7 @@ void memset(void* to, char data, int32_t bytes, const A& arch) {
     }
   }
   int64_t data64 = *reinterpret_cast<int64_t*>(&v);
-  while (bytes >= sizeof(int64_t)) {
+  while (bytes >= static_cast<int64_t>(sizeof(int64_t))) {
     if (!detail::setNextWord<int64_t>(to, data64, bytes, arch)) {
       return;
     }
@@ -525,6 +560,18 @@ struct Gather<T, int32_t, A, 4> {
     return maskApply<kScale>(src, mask, base, loadIndices(indices, arch), arch);
   }
 
+#if XSIMD_WITH_SVE
+  template <int kScale>
+  static xsimd::batch<T, A> maskApply(
+      xsimd::batch<T, A> src,
+      xsimd::batch_bool<T, A> mask,
+      const T* base,
+      const int32_t* indices,
+      const xsimd::sve& arch) {
+    return genericMaskGather<T, A, kScale>(src, mask, base, indices);
+  }
+#endif
+
   template <int kScale>
   static xsimd::batch<T, A> maskApply(
       xsimd::batch<T, A> src,
@@ -582,6 +629,22 @@ struct Gather<T, int32_t, A, 8> {
     return Batch64<int32_t>::load_unaligned(indices);
   }
 
+#if (XSIMD_WITH_SVE && SVE_BITS == 128)
+
+  static Batch64<int32_t> loadIndices(
+      const int32_t* indices,
+      const xsimd::sve&) {
+    return Batch64<int32_t>::load_unaligned(indices);
+  }
+#endif
+#if (XSIMD_WITH_SVE && SVE_BITS == 256)
+  static Batch128<int32_t> loadIndices(
+      const int32_t* indices,
+      const xsimd::sve&) {
+    return Batch128<int32_t>::load_unaligned(indices);
+  }
+#endif
+
   static Batch64<int32_t> loadIndices(
       const int32_t* indices,
       const xsimd::neon&) {
@@ -602,6 +665,34 @@ struct Gather<T, int32_t, A, 8> {
     return genericGather<T, A, kScale>(base, indices);
   }
 
+#if (XSIMD_WITH_SVE && SVE_BITS == 256)
+  template <int kScale>
+  static xsimd::batch<T, A>
+  apply(const T* base, Batch128<int32_t> vindex, const xsimd::sve&) {
+    constexpr int N = xsimd::batch<T, A>::size;
+    alignas(A::alignment()) T dst[N];
+    auto bytes = reinterpret_cast<const char*>(base);
+    for (int i = 0; i < N; ++i) {
+      dst[i] = *reinterpret_cast<const T*>(bytes + vindex.data[i] * kScale);
+    }
+    return xsimd::load_aligned(dst);
+  }
+#endif
+
+#if (XSIMD_WITH_SVE && SVE_BITS == 128)
+  template <int kScale>
+  static xsimd::batch<T, A>
+  apply(const T* base, Batch64<int32_t> vindex, const xsimd::sve&) {
+    constexpr int N = xsimd::batch<T, A>::size;
+    alignas(A::alignment()) T dst[N];
+    auto bytes = reinterpret_cast<const char*>(base);
+    for (int i = 0; i < N; ++i) {
+      dst[i] = *reinterpret_cast<const T*>(bytes + vindex.data[i] * kScale);
+    }
+    return xsimd::load_aligned(dst);
+  }
+#endif
+
 #if XSIMD_WITH_AVX2
   template <int kScale>
   static xsimd::batch<T, A> apply(
@@ -624,6 +715,48 @@ struct Gather<T, int32_t, A, 8> {
     return genericMaskGather<T, A, kScale>(src, mask, base, indices);
   }
 
+#if XSIMD_WITH_SVE
+  template <int kScale>
+  static xsimd::batch<T, A> maskApply(
+      xsimd::batch<T, A> src,
+      xsimd::batch_bool<T, A> mask,
+      const T* base,
+      const int32_t* indices,
+      const xsimd::sve& arch) {
+    return genericMaskGather<T, A, kScale>(src, mask, base, indices);
+  }
+#endif
+
+#if (XSIMD_WITH_SVE && SVE_BITS == 128)
+  template <int kScale>
+  static xsimd::batch<T, A> maskApply(
+      xsimd::batch<T, A> src,
+      xsimd::batch_bool<T, A> mask,
+      const T* base,
+      Batch64<int32_t> vindex,
+      const xsimd::sve& arch) {
+    constexpr int N = Batch64<int32_t>::size;
+    alignas(A::alignment()) int32_t indices[N];
+    vindex.store_unaligned(indices);
+    return maskApply<kScale>(src, mask, base, indices, arch);
+  }
+#endif
+
+#if (XSIMD_WITH_SVE && SVE_BITS == 256)
+  template <int kScale>
+  static xsimd::batch<T, A> maskApply(
+      xsimd::batch<T, A> src,
+      xsimd::batch_bool<T, A> mask,
+      const T* base,
+      Batch128<int32_t> vindex,
+      const xsimd::sve& arch) {
+    constexpr int N = Batch128<int32_t>::size;
+    alignas(A::alignment()) int32_t indices[N];
+    vindex.store_unaligned(indices);
+    return maskApply<kScale>(src, mask, base, indices, arch);
+  }
+#endif
+
 #if XSIMD_WITH_AVX2
   template <int kScale>
   static xsimd::batch<T, A> maskApply(
@@ -697,6 +830,18 @@ struct Gather<T, int64_t, A, 8> {
     return maskApply<kScale>(src, mask, base, loadIndices(indices, arch), arch);
   }
 
+#if XSIMD_WITH_SVE
+  template <int kScale>
+  static xsimd::batch<T, A> maskApply(
+      xsimd::batch<T, A> src,
+      xsimd::batch_bool<T, A> mask,
+      const T* base,
+      const int64_t* indices,
+      const xsimd::sve& arch) {
+    return genericMaskGather<T, A, kScale>(src, mask, base, indices);
+  }
+#endif
+
 #if XSIMD_WITH_AVX2
   template <int kScale>
   static xsimd::batch<T, A> maskApply(
@@ -756,6 +901,26 @@ xsimd::batch<int16_t, A> pack32(
 }
 #endif
 
+template <typename A>
+xsimd::batch<int16_t, A> pack32(
+    xsimd::batch<int32_t, A> x,
+    xsimd::batch<int32_t, A> y,
+    const xsimd::generic&) {
+  constexpr std::size_t size = xsimd::batch<int32_t, A>::size;
+  alignas(A) int32_t xArr[size];
+  alignas(A) int32_t yArr[size];
+  alignas(A) int16_t resultArr[2 * size];
+
+  x.store_unaligned(xArr);
+  y.store_unaligned(yArr);
+
+  for (std::size_t i = 0; i < size; ++i) {
+    resultArr[i] = static_cast<int16_t>(xArr[i]);
+    resultArr[i + size] = static_cast<int16_t>(yArr[i]);
+  }
+  return xsimd::batch<int16_t, A>::load_unaligned(resultArr);
+}
+
 #if XSIMD_WITH_AVX2
 template <typename A>
 xsimd::batch<int16_t, A> pack32(
@@ -795,6 +960,16 @@ template <typename T>
 Batch64<T> genericPermute(Batch64<T> data, Batch64<int32_t> idx) {
   static_assert(data.size >= idx.size);
   Batch64<T> ans;
+  for (size_t i = 0; i < idx.size; ++i) {
+    ans.data[i] = data.data[idx.data[i]];
+  }
+  return ans;
+}
+
+template <typename T>
+Batch128<T> genericPermute(Batch128<T> data, Batch128<int32_t> idx) {
+  static_assert(data.size >= idx.size);
+  Batch128<T> ans;
   for (int i = 0; i < idx.size; ++i) {
     ans.data[i] = data.data[idx.data[i]];
   }
@@ -865,7 +1040,8 @@ xsimd::batch<int16_t, A> gather(
   } else {
     second = xsimd::batch<int32_t, A>::broadcast(0);
   }
-  return detail::pack32(first, second, arch);
+  auto packed = detail::pack32(first, second, arch);
+  return packed;
 }
 
 namespace detail {
@@ -988,6 +1164,25 @@ struct GetHalf<int64_t, int32_t, A> {
   }
 #endif
 
+  template <bool kSecond>
+  static xsimd::batch<int64_t, A> apply(
+      xsimd::batch<int32_t, A> data,
+      const xsimd::generic&) {
+    constexpr std::size_t input_size = xsimd::batch<int32_t, A>::size;
+    constexpr std::size_t half_size = input_size / 2;
+
+    std::array<int32_t, input_size> input_buffer;
+    data.store_aligned(input_buffer.data());
+
+    std::array<int64_t, half_size> output_buffer;
+    for (std::size_t i = 0; i < half_size; ++i) {
+      output_buffer[i] = static_cast<int64_t>(
+          kSecond ? input_buffer[i + half_size] : input_buffer[i]);
+    }
+
+    return xsimd::load_aligned(output_buffer.data());
+  }
+
 #if XSIMD_WITH_NEON
   template <bool kSecond>
   static xsimd::batch<int64_t, A> apply(
@@ -1039,6 +1234,23 @@ struct GetHalf<uint64_t, int32_t, A> {
     return vmovl_u32(vreinterpret_u32_s32(half));
   }
 #endif
+
+  template <bool kSecond>
+  static xsimd::batch<uint64_t, A> apply(
+      xsimd::batch<int32_t, A> data,
+      const xsimd::generic&) {
+    constexpr std::size_t input_size = xsimd::batch<int32_t, A>::size;
+    constexpr std::size_t half_size = input_size / 2;
+    std::array<int32_t, input_size> input_buffer;
+    data.store_aligned(input_buffer.data());
+    std::array<uint64_t, half_size> output_buffer;
+    for (std::size_t i = 0; i < half_size; ++i) {
+      output_buffer[i] = static_cast<uint64_t>(
+          kSecond ? static_cast<uint32_t>(input_buffer[i + half_size])
+                  : static_cast<uint32_t>(input_buffer[i]));
+    }
+    return xsimd::load_aligned(output_buffer.data());
+  }
 };
 
 } // namespace detail
@@ -1082,6 +1294,21 @@ struct Filter<T, A, 2> {
     return ans;
   }
 #endif
+
+#if XSIMD_WITH_SVE
+  static xsimd::batch<T, A>
+  apply(xsimd::batch<T, A> data, int mask, const xsimd::sve& arch) {
+    int lane_count = svcntb() / sizeof(T);
+    T compressed[lane_count];
+    int idx = 0;
+    for (int i = 0; i < lane_count; i++) {
+      if (mask & (1 << i)) {
+        compressed[idx++] = data.get(i);
+      }
+    }
+    return xsimd::load_unaligned(compressed);
+  }
+#endif
 };
 
 template <typename T, typename A>
@@ -1132,6 +1359,15 @@ struct Crc32<uint64_t, A> {
   }
 #endif
 
+#if XSIMD_WITH_SVE
+  static uint32_t apply(uint32_t checksum, uint64_t value, const xsimd::sve&) {
+    __asm__("crc32cx %w[c], %w[c], %x[v]"
+            : [c] "+r"(checksum)
+            : [v] "r"(value));
+    return checksum;
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static uint32_t apply(uint32_t checksum, uint64_t value, const xsimd::neon&) {
     __asm__("crc32cx %w[c], %w[c], %x[v]"
@@ -1157,6 +1393,20 @@ xsimd::batch<T, A> iota(const A&) {
 
 namespace detail {
 
+#if (XSIMD_WITH_SVE && SVE_BITS == 256)
+template <typename T, typename A>
+struct HalfBatchImpl<T, A, std::enable_if_t<std::is_base_of_v<xsimd::sve, A>>> {
+  using Type = Batch128<T>;
+};
+#endif
+
+#if (XSIMD_WITH_SVE && SVE_BITS == 128)
+template <typename T, typename A>
+struct HalfBatchImpl<T, A, std::enable_if_t<std::is_base_of_v<xsimd::sve, A>>> {
+  using Type = Batch64<T>;
+};
+#endif
+
 template <typename T, typename A>
 struct HalfBatchImpl<T, A, std::enable_if_t<std::is_base_of_v<xsimd::avx, A>>> {
   using Type = xsimd::batch<T, xsimd::sse2>;
@@ -1194,10 +1444,18 @@ struct ReinterpretBatch<T, T, A> {
   }
 };
 
-#if XSIMD_WITH_NEON || XSIMD_WITH_NEON64
+#if XSIMD_WITH_NEON || XSIMD_WITH_NEON64 || XSIMD_WITH_SVE
 
 template <typename A>
 struct ReinterpretBatch<uint8_t, int8_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<uint8_t, A> apply(
+      xsimd::batch<int8_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_u8_s8(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<uint8_t, A> apply(
       xsimd::batch<int8_t, A> data,
@@ -1217,6 +1475,14 @@ struct ReinterpretBatch<uint8_t, int8_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<int8_t, uint8_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<int8_t, A> apply(
+      xsimd::batch<uint8_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_s8_u8(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<int8_t, A> apply(
       xsimd::batch<uint8_t, A> data,
@@ -1236,6 +1502,14 @@ struct ReinterpretBatch<int8_t, uint8_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<uint16_t, int16_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<uint16_t, A> apply(
+      xsimd::batch<int16_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_u16_s16(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<uint16_t, A> apply(
       xsimd::batch<int16_t, A> data,
@@ -1255,6 +1529,14 @@ struct ReinterpretBatch<uint16_t, int16_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<int16_t, uint16_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<int16_t, A> apply(
+      xsimd::batch<uint16_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_s16_u16(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<int16_t, A> apply(
       xsimd::batch<uint16_t, A> data,
@@ -1274,6 +1556,14 @@ struct ReinterpretBatch<int16_t, uint16_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<uint32_t, int32_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<uint32_t, A> apply(
+      xsimd::batch<int32_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_u32_s32(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<uint32_t, A> apply(
       xsimd::batch<int32_t, A> data,
@@ -1293,6 +1583,14 @@ struct ReinterpretBatch<uint32_t, int32_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<int32_t, uint32_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<int32_t, A> apply(
+      xsimd::batch<uint32_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_s32_u32(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<int32_t, A> apply(
       xsimd::batch<uint32_t, A> data,
@@ -1312,6 +1610,14 @@ struct ReinterpretBatch<int32_t, uint32_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<uint64_t, uint32_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<uint64_t, A> apply(
+      xsimd::batch<uint32_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_u64_u32(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<uint64_t, A> apply(
       xsimd::batch<uint32_t, A> data,
@@ -1331,6 +1637,14 @@ struct ReinterpretBatch<uint64_t, uint32_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<uint64_t, int64_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<uint64_t, A> apply(
+      xsimd::batch<int64_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_u64_s64(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<uint64_t, A> apply(
       xsimd::batch<int64_t, A> data,
@@ -1350,6 +1664,14 @@ struct ReinterpretBatch<uint64_t, int64_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<uint32_t, int64_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<uint32_t, A> apply(
+      xsimd::batch<int64_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_u32_s64(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<uint32_t, A> apply(
       xsimd::batch<int64_t, A> data,
@@ -1369,6 +1691,14 @@ struct ReinterpretBatch<uint32_t, int64_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<int64_t, uint64_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<int64_t, A> apply(
+      xsimd::batch<uint64_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_s64_u64(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<int64_t, A> apply(
       xsimd::batch<uint64_t, A> data,
@@ -1388,6 +1718,14 @@ struct ReinterpretBatch<int64_t, uint64_t, A> {
 
 template <typename A>
 struct ReinterpretBatch<uint32_t, uint64_t, A> {
+#if XSIMD_WITH_SVE
+  static xsimd::batch<uint32_t, A> apply(
+      xsimd::batch<uint64_t, A> data,
+      const xsimd::sve&) {
+    return svreinterpret_u32_u64(data.data);
+  }
+#endif
+
 #if XSIMD_WITH_NEON
   static xsimd::batch<uint32_t, A> apply(
       xsimd::batch<uint64_t, A> data,
@@ -1444,6 +1782,9 @@ namespace detail {
 #if XSIMD_WITH_AVX2
 using CharVector = xsimd::batch<uint8_t, xsimd::avx2>;
 #define VELOX_SIMD_STRSTR 1
+#elif XSIMD_WITH_SVE
+using CharVector = xsimd::batch<uint8_t, xsimd::sve>;
+#define VELOX_SIMD_STRSTR 1
 #elif XSIMD_WITH_NEON
 using CharVector = xsimd::batch<uint8_t, xsimd::neon>;
 #define VELOX_SIMD_STRSTR 1
@@ -1458,7 +1799,7 @@ size_t FOLLY_ALWAYS_INLINE smidStrstrMemcmp(
     const char* s,
     int64_t n,
     const char* needle,
-    size_t needleSize) {
+    int64_t needleSize) {
   static_assert(kNeedleSize >= 2);
   VELOX_DCHECK_GT(needleSize, 1);
   VELOX_DCHECK_GT(n, 0);
@@ -1506,7 +1847,7 @@ size_t FOLLY_ALWAYS_INLINE smidStrstrMemcmp(
   }
 
   return std::string::npos;
-};
+}
 
 #endif
 
diff --git a/velox/common/base/SimdUtil.h b/velox/common/base/SimdUtil.h
index edc7e06c2dfc..d853931776e3 100644
--- a/velox/common/base/SimdUtil.h
+++ b/velox/common/base/SimdUtil.h
@@ -131,6 +131,50 @@ struct Batch64 {
   }
 };
 
+template <typename T>
+struct Batch128 {
+  static constexpr size_t size = [] {
+    static_assert(16 % sizeof(T) == 0);
+    return 16 / sizeof(T);
+  }();
+
+  T data[size];
+
+  static Batch128 from(std::initializer_list<T> values) {
+    VELOX_DCHECK_EQ(values.size(), size);
+    Batch128 ans;
+    for (int i = 0; i < size; ++i) {
+      ans.data[i] = *(values.begin() + i);
+    }
+    return ans;
+  }
+
+  void store_unaligned(T* out) const {
+    std::copy(std::begin(data), std::end(data), out);
+  }
+
+  static Batch128 load_aligned(const T* mem) {
+    return load_unaligned(mem);
+  }
+
+  static Batch128 load_unaligned(const T* mem) {
+    Batch128 ans;
+    std::copy(mem, mem + size, ans.data);
+    return ans;
+  }
+
+  friend Batch128 operator+(Batch128 x, T y) {
+    for (int i = 0; i < size; ++i) {
+      x.data[i] += y;
+    }
+    return x;
+  }
+
+  friend Batch128 operator-(Batch128 x, T y) {
+    return x + (-y);
+  }
+};
+
 namespace detail {
 template <typename T, typename IndexType, typename A, int kSizeT = sizeof(T)>
 struct Gather;
@@ -178,6 +222,17 @@ gather(const T* base, Batch64<IndexType> vindex, const A& arch = {}) {
   return Impl::template apply<kScale>(base, vindex.data, arch);
 }
 
+template <
+    typename T,
+    typename IndexType,
+    int kScale = sizeof(T),
+    typename A = xsimd::default_arch>
+xsimd::batch<T, A>
+gather(const T* base, Batch128<IndexType> vindex, const A& arch = {}) {
+  using Impl = detail::Gather<T, IndexType, A>;
+  return Impl::template apply<kScale>(base, vindex.data, arch);
+}
+
 // Same as 'gather' above except the indices are read from memory.
 template <
     typename T,
@@ -223,6 +278,21 @@ xsimd::batch<T, A> maskGather(
   return Impl::template maskApply<kScale>(src, mask, base, vindex.data, arch);
 }
 
+template <
+    typename T,
+    typename IndexType,
+    int kScale = sizeof(T),
+    typename A = xsimd::default_arch>
+xsimd::batch<T, A> maskGather(
+    xsimd::batch<T, A> src,
+    xsimd::batch_bool<T, A> mask,
+    const T* base,
+    Batch128<IndexType> vindex,
+    const A& arch = {}) {
+  using Impl = detail::Gather<T, IndexType, A>;
+  return Impl::template maskApply<kScale>(src, mask, base, vindex.data, arch);
+}
+
 // Same as 'maskGather' above but read indices from memory.
 template <
     typename T,
@@ -360,6 +430,7 @@ uint32_t crc32U64(uint32_t checksum, uint64_t value, const A& arch = {}) {
 template <typename T, typename A = xsimd::default_arch>
 xsimd::batch<T, A> iota(const A& = {});
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 // Returns a batch with all elements set to value.  For batch<bool> we
 // use one bit to represent one element.
 template <typename T, typename A = xsimd::default_arch>
@@ -375,6 +446,7 @@ xsimd::batch<T, A> setAll(T value, const A& = {}) {
     return xsimd::broadcast<T, A>(value);
   }
 }
+#endif
 
 // 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
diff --git a/velox/common/base/SkewedPartitionBalancer.cpp b/velox/common/base/SkewedPartitionBalancer.cpp
index 24cb1511469e..7a1b4a6efa34 100644
--- a/velox/common/base/SkewedPartitionBalancer.cpp
+++ b/velox/common/base/SkewedPartitionBalancer.cpp
@@ -30,9 +30,10 @@ SkewedPartitionRebalancer::SkewedPartitionRebalancer(
       numTasks_(numTasks),
       minProcessedBytesRebalanceThresholdPerPartition_(
           minProcessedBytesRebalanceThresholdPerPartition),
-      minProcessedBytesRebalanceThreshold_(std::max(
-          minProcessedBytesRebalanceThreshold,
-          minProcessedBytesRebalanceThresholdPerPartition_)),
+      minProcessedBytesRebalanceThreshold_(
+          std::max(
+              minProcessedBytesRebalanceThreshold,
+              minProcessedBytesRebalanceThresholdPerPartition_)),
       partitionRowCount_(numPartitions_),
       partitionAssignments_(numPartitions_) {
   VELOX_CHECK_GT(numPartitions_, 0);
@@ -174,9 +175,10 @@ void SkewedPartitionRebalancer::rebalanceBasedOnTaskSkewness(
 
       const uint32_t totalAssignedTasks =
           partitionAssignments_[maxPartition].size();
-      if (partitionBytes_[maxPartition] <
-          (minProcessedBytesRebalanceThresholdPerPartition_ *
-           totalAssignedTasks)) {
+      if (partitionBytes_[maxPartition] == 0 ||
+          (partitionBytes_[maxPartition] <
+           (minProcessedBytesRebalanceThresholdPerPartition_ *
+            totalAssignedTasks))) {
         break;
       }
 
diff --git a/velox/common/base/SpillConfig.cpp b/velox/common/base/SpillConfig.cpp
index dd428a41ec7b..caf55d773865 100644
--- a/velox/common/base/SpillConfig.cpp
+++ b/velox/common/base/SpillConfig.cpp
@@ -34,8 +34,10 @@ SpillConfig::SpillConfig(
     uint64_t _maxSpillRunRows,
     uint64_t _writerFlushThresholdSize,
     const std::string& _compressionKind,
+    uint32_t _numMaxMergeFiles,
     std::optional<PrefixSortConfig> _prefixSortConfig,
-    const std::string& _fileCreateConfig)
+    const std::string& _fileCreateConfig,
+    uint32_t _windowMinReadBatchRows)
     : getSpillDirPathCb(std::move(_getSpillDirPathCb)),
       updateAndCheckSpillLimitCb(std::move(_updateAndCheckSpillLimitCb)),
       fileNamePrefix(std::move(_fileNamePrefix)),
@@ -53,12 +55,18 @@ SpillConfig::SpillConfig(
       maxSpillRunRows(_maxSpillRunRows),
       writerFlushThresholdSize(_writerFlushThresholdSize),
       compressionKind(common::stringToCompressionKind(_compressionKind)),
+      numMaxMergeFiles(_numMaxMergeFiles),
       prefixSortConfig(_prefixSortConfig),
-      fileCreateConfig(_fileCreateConfig) {
+      fileCreateConfig(_fileCreateConfig),
+      windowMinReadBatchRows(_windowMinReadBatchRows) {
   VELOX_USER_CHECK_GE(
       spillableReservationGrowthPct,
       minSpillableReservationPct,
       "Spillable memory reservation growth pct should not be lower than minimum available pct");
+  VELOX_CHECK_NE(
+      numMaxMergeFiles,
+      1,
+      "NumMaxMergeFiles should not be 1 as merging should take at least 2 files to make progress");
 }
 
 int32_t SpillConfig::spillLevel(uint8_t startBitOffset) const {
diff --git a/velox/common/base/SpillConfig.h b/velox/common/base/SpillConfig.h
index 7f30bc6e614f..8c77e9270f8c 100644
--- a/velox/common/base/SpillConfig.h
+++ b/velox/common/base/SpillConfig.h
@@ -52,6 +52,13 @@ using GetSpillDirectoryPathCB = std::function<std::string_view()>;
 /// bytes exceed the set limit.
 using UpdateAndCheckSpillLimitCB = std::function<void(uint64_t)>;
 
+/// Specifies the options for spill to disk.
+struct SpillDiskOptions {
+  std::string spillDirPath;
+  bool spillDirCreated{true};
+  std::function<std::string()> spillDirCreateCb{nullptr};
+};
+
 /// Specifies the config for spilling.
 struct SpillConfig {
   SpillConfig() = default;
@@ -71,8 +78,10 @@ struct SpillConfig {
       uint64_t _maxSpillRunRows,
       uint64_t _writerFlushThresholdSize,
       const std::string& _compressionKind,
+      uint32_t numMaxMergeFiles,
       std::optional<PrefixSortConfig> _prefixSortConfig = std::nullopt,
-      const std::string& _fileCreateConfig = {});
+      const std::string& _fileCreateConfig = {},
+      uint32_t _windowMinReadBatchRows = 1'000);
 
   /// Returns the spilling level with given 'startBitOffset' and
   /// 'numPartitionBits'.
@@ -151,11 +160,22 @@ struct SpillConfig {
   /// CompressionKind when spilling, CompressionKind_NONE means no compression.
   common::CompressionKind compressionKind;
 
+  /// The max number of files to merge at a time when merging sorted files into
+  /// a single ordered stream. 0 means unlimited. This is used to reduce memory
+  /// pressure by capping the number of open files when merging spilled sorted
+  /// files to avoid using too much memory and causing OOM. Note that this is
+  /// only applicable for ordered spill, is not applicable for spill scenarios
+  /// that don't need sorting, e.g. HashJoin.
+  uint32_t numMaxMergeFiles;
+
   /// Prefix sort config when spilling, enable prefix sort when this config is
   /// set, otherwise, fallback to timsort.
   std::optional<PrefixSortConfig> prefixSortConfig;
 
   /// Custom options passed to velox::FileSystem to create spill WriteFile.
   std::string fileCreateConfig;
+
+  /// The minimum number of rows to read when processing spilled window data.
+  uint32_t windowMinReadBatchRows;
 };
 } // namespace facebook::velox::common
diff --git a/velox/common/base/SpillStats.cpp b/velox/common/base/SpillStats.cpp
index 5c5e51014b78..caa8cc66ab07 100644
--- a/velox/common/base/SpillStats.cpp
+++ b/velox/common/base/SpillStats.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/base/SpillStats.h"
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/StatsReporter.h"
@@ -24,7 +25,7 @@ namespace facebook::velox::common {
 namespace {
 std::vector<folly::Synchronized<SpillStats>>& allSpillStats() {
   static std::vector<folly::Synchronized<SpillStats>> spillStatsList(
-      std::thread::hardware_concurrency());
+      folly::hardware_concurrency());
   return spillStatsList;
 }
 
@@ -124,98 +125,6 @@ SpillStats SpillStats::operator-(const SpillStats& other) const {
   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(spillExtractVectorTimeNanos);
-  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,
-             spillExtractVectorTimeNanos,
-             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.spillExtractVectorTimeNanos,
-             other.spillSerializationTimeNanos,
-             other.spillWrites,
-             other.spillFlushTimeNanos,
-             other.spillWriteTimeNanos,
-             spillMaxLevelExceededCount,
-             spillReadBytes,
-             spillReads,
-             spillReadTimeNanos,
-             spillDeserializationTimeNanos);
-}
-
 void SpillStats::reset() {
   spillRuns = 0;
   spilledInputBytes = 0;
diff --git a/velox/common/base/SpillStats.h b/velox/common/base/SpillStats.h
index da9c5fe92184..36e3c7b33e70 100644
--- a/velox/common/base/SpillStats.h
+++ b/velox/common/base/SpillStats.h
@@ -15,8 +15,9 @@
  */
 #pragma once
 
-#include <stdint.h>
-#include <string.h>
+#include <compare>
+#include <cstdint>
+#include <cstring>
 
 #include <folly/executors/CPUThreadPoolExecutor.h>
 
@@ -97,14 +98,7 @@ struct SpillStats {
 
   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;
+  bool operator==(const SpillStats& other) const = default;
 
   void reset();
 
diff --git a/velox/common/base/SplitBlockBloomFilter.cpp b/velox/common/base/SplitBlockBloomFilter.cpp
new file mode 100644
index 000000000000..ef4d5e87c564
--- /dev/null
+++ b/velox/common/base/SplitBlockBloomFilter.cpp
@@ -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.
+ */
+
+#include "velox/common/base/SplitBlockBloomFilter.h"
+
+#include "velox/common/base/BitUtil.h"
+#include "velox/common/base/Exceptions.h"
+
+#include <bit>
+#include <sstream>
+
+namespace facebook::velox {
+
+int64_t SplitBlockBloomFilter::numBlocks(
+    int64_t numElements,
+    double falsePositive) {
+  constexpr int K = xsimd::batch<uint32_t>::size;
+  int64_t numBits = std::ceil(
+      -K * numElements / std::log(1 - std::pow(falsePositive, 1.0 / K)));
+  return bits::divRoundUp(numBits, 8 * sizeof(Block));
+}
+
+SplitBlockBloomFilter::SplitBlockBloomFilter(const std::span<Block>& blocks)
+    : blocks_(blocks) {
+  VELOX_CHECK_EQ(reinterpret_cast<uintptr_t>(blocks.data()) % sizeof(Block), 0);
+}
+
+std::string SplitBlockBloomFilter::debugString() const {
+  std::ostringstream out;
+  out << "numBlocks=" << blocks_.size() << '\n';
+  int64_t byBlockSetBits[1 + 8 * sizeof(Block)]{};
+  int64_t byBitPosition[8 * sizeof(Block)]{};
+  for (auto& block : blocks_) {
+    int numSetBits = 0;
+    for (int i = 0; i < xsimd::batch<uint32_t>::size; ++i) {
+      auto n = std::popcount(block.data[i]);
+      numSetBits += n;
+      for (int j = 0; j < 32; ++j) {
+        byBitPosition[j + i * 32] += 1 & (block.data[i] >> j);
+      }
+    }
+    ++byBlockSetBits[numSetBits];
+  }
+  for (int i = 0; i <= 8 * sizeof(Block); ++i) {
+    out << "Block set bits " << i << ": " << byBlockSetBits[i] << '\n';
+  }
+  for (int i = 0; i < 8 * sizeof(Block); ++i) {
+    out << "Bit " << i << ": " << byBitPosition[i] << '\n';
+  }
+  return out.str();
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/base/SplitBlockBloomFilter.h b/velox/common/base/SplitBlockBloomFilter.h
new file mode 100644
index 000000000000..b5a40f88c3be
--- /dev/null
+++ b/velox/common/base/SplitBlockBloomFilter.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/SimdUtil.h"
+
+#include <cstdint>
+#include <span>
+
+namespace facebook::velox {
+
+/// SIMDized bloom filter implementation.  We take 8 or 4 (depending on the SIMD
+/// register size) bits from the inserted value, and split them into a block.  A
+/// block is the same size of a SIMD register.
+///
+/// This data structure is not responsible for memory management or hashing.
+///
+/// A detailed explanation about how the data structure works can be found here:
+/// https://parquet.apache.org/docs/file-format/bloomfilter/
+class SplitBlockBloomFilter {
+ public:
+  /// A block is basically a SIMD register.  Made public so user can calculate
+  /// the size needed for memory allocation; otherwise it's implementation
+  /// detail.
+  struct alignas(sizeof(xsimd::batch<uint32_t>)) Block {
+    uint32_t data[xsimd::batch<uint32_t>::size];
+  };
+
+  /// Calculate the number of blocks needed to satisfy certain number of inserts
+  /// and false positive rate.  A rough estimation between the memory usage and
+  /// false positive rate can be found below:
+  ///
+  /// | Bits of space per insert | False positive probability |
+  /// |--------------------------|----------------------------|
+  /// |                      6.0 |                        10% |
+  /// |                     10.5 |                         1% |
+  /// |                     16.9 |                       0.1% |
+  /// |                     26.4 |                      0.01% |
+  /// |                       41 |                     0.001% |
+  static int64_t numBlocks(int64_t numElements, double falsePositive);
+
+  /// Construct the bloom filter using the blocks memory passed as parameter.
+  /// The block memory address must be aligned with block size (i.e. SIMD
+  /// register size).  It is recommended to use numBlocks() to calculate the
+  /// number of block for allocation.
+  explicit SplitBlockBloomFilter(const std::span<Block>& blocks);
+
+  /// Delete copy constructor and assignment to avoid accidentally mutating the
+  /// same underlying block data from multiple places.
+  SplitBlockBloomFilter(const SplitBlockBloomFilter&) = delete;
+  SplitBlockBloomFilter& operator=(const SplitBlockBloomFilter&) = delete;
+
+  SplitBlockBloomFilter(SplitBlockBloomFilter&&) = default;
+
+  /// Insert a hash into the bloom filter.  The function used to generate this
+  /// hash should be avalanching.
+  void insert(uint64_t hash) {
+    auto mask = makeMask(hash);
+    auto* block = blocks_[blockIndex(hash)].data;
+    (xsimd::load_aligned(block) | mask).store_aligned(block);
+  }
+
+  /// Check whether a hash has been inserted before.  Could return true when it
+  /// has not been inserted.  Never return false when the hash has been
+  /// inserted.
+  bool mayContain(uint64_t hash) const {
+    auto mask = makeMask(hash);
+    auto block = xsimd::load_aligned(blocks_[blockIndex(hash)].data);
+#if XSIMD_WITH_AVX
+    return _mm256_testc_si256(block, mask);
+#else
+    return xsimd::all(xsimd::bitwise_andnot(mask, block) == 0);
+#endif
+  }
+
+  /// Return the block index of the given hash.
+  uint64_t blockIndex(uint64_t hash) const {
+    return ((hash >> 32) * blocks_.size()) >> 32;
+  }
+
+  std::string debugString() const;
+
+ private:
+  static_assert(64 % sizeof(Block) == 0);
+
+  template <typename A = xsimd::default_arch>
+  static xsimd::batch<uint32_t, A> makeSaltsVec() {
+    constexpr uint32_t kSalts[] = {
+        0x2df1424bU,
+        0x44974d91U,
+        0x47b6137bU,
+        0x5c6bfb31U,
+        0x705495c7U,
+        0x8824ad5bU,
+        0x9efc4947U,
+        0xa2b7289dU,
+    };
+    if constexpr (xsimd::batch<uint32_t, A>::size == 8) {
+      return xsimd::batch<uint32_t, A>(
+          kSalts[0],
+          kSalts[1],
+          kSalts[2],
+          kSalts[3],
+          kSalts[4],
+          kSalts[5],
+          kSalts[6],
+          kSalts[7]);
+    } else {
+      static_assert(xsimd::batch<uint32_t, A>::size == 4);
+      return xsimd::batch<uint32_t, A>(
+          kSalts[0], kSalts[2], kSalts[4], kSalts[6]);
+    }
+  }
+
+  static xsimd::batch<uint32_t> makeMask(uint32_t hash) {
+    auto shifts = (makeSaltsVec() * xsimd::broadcast(hash)) >> 27;
+    return xsimd::broadcast<uint32_t>(1) << shifts;
+  }
+
+  std::span<Block> const blocks_;
+};
+
+} // namespace facebook::velox
diff --git a/velox/common/base/StatsReporter.h b/velox/common/base/StatsReporter.h
index d306c31cde18..9df453a75db1 100644
--- a/velox/common/base/StatsReporter.h
+++ b/velox/common/base/StatsReporter.h
@@ -17,7 +17,6 @@
 #pragma once
 
 #include <folly/Singleton.h>
-#include <memory>
 
 /// StatsReporter designed to assist in reporting various metrics of the
 /// application that uses velox library. The library itself does not implement
@@ -64,7 +63,7 @@ enum class StatType {
   HISTOGRAM,
 };
 
-inline std::string statTypeString(StatType stat) {
+inline std::string_view statTypeString(StatType stat) {
   switch (stat) {
     case StatType::AVG:
       return "Avg";
@@ -77,7 +76,7 @@ inline std::string statTypeString(StatType stat) {
     case StatType::HISTOGRAM:
       return "Histogram";
     default:
-      return fmt::format("UNKNOWN: {}", static_cast<int>(stat));
+      return "Unknown";
   }
 }
 
@@ -85,17 +84,17 @@ inline std::string statTypeString(StatType stat) {
 /// different implementations.
 class BaseStatsReporter {
  public:
-  virtual ~BaseStatsReporter() {}
+  virtual ~BaseStatsReporter() = default;
 
   /// 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 registerMetricExportType(const char* key, StatType statType)
-      const = 0;
+      const {}
 
   virtual void registerMetricExportType(
       folly::StringPiece key,
-      StatType statType) const = 0;
+      StatType statType) const {}
 
   /// Register a histogram with a list of percentiles defined.
   /// @param key The key to identify the histogram.
@@ -108,35 +107,98 @@ class BaseStatsReporter {
       int64_t bucketWidth,
       int64_t min,
       int64_t max,
-      const std::vector<int32_t>& pcts) const = 0;
+      const std::vector<int32_t>& pcts) const {}
 
   virtual void registerHistogramMetricExportType(
       folly::StringPiece key,
       int64_t bucketWidth,
       int64_t min,
       int64_t max,
-      const std::vector<int32_t>& pcts) const = 0;
+      const std::vector<int32_t>& pcts) const {}
+
+  /// Register a quantile metric for quantile stats with export types,
+  /// quantiles, and sliding window periods.
+  /// @param key The key to identify the stat.
+  /// @param statTypes The list of stat types to export (e.g., AVG, SUM, COUNT).
+  /// @param pcts The quantile percentiles to track (as values between 0.0
+  /// and 1.0, e.g., 0.5 for 50th percentile, 0.95 for 95th percentile).
+  /// @param slidingWindowsSeconds The sliding window periods in seconds.
+  virtual void registerQuantileMetricExportType(
+      const char* key,
+      const std::vector<StatType>& statTypes,
+      const std::vector<double>& pcts,
+      const std::vector<size_t>& slidingWindowsSeconds = {60}) const {}
+
+  virtual void registerQuantileMetricExportType(
+      folly::StringPiece key,
+      const std::vector<StatType>& statTypes,
+      const std::vector<double>& pcts,
+      const std::vector<size_t>& slidingWindowsSeconds = {60}) const {}
+
+  /// Register a dynamic quantile metric with a template key pattern that
+  /// supports runtime substitution.
+  /// @param keyPattern The key pattern with {} placeholders for substitution.
+  /// @param statTypes The list of stat types to export.
+  /// @param pcts The quantile percentiles to track.
+  /// @param slidingWindowsSeconds The sliding window periods in seconds.
+  virtual void registerDynamicQuantileMetricExportType(
+      const char* keyPattern,
+      const std::vector<StatType>& statTypes,
+      const std::vector<double>& pcts,
+      const std::vector<size_t>& slidingWindowsSeconds = {60}) const {}
+
+  virtual void registerDynamicQuantileMetricExportType(
+      folly::StringPiece keyPattern,
+      const std::vector<StatType>& statTypes,
+      const std::vector<double>& pcts,
+      const std::vector<size_t>& slidingWindowsSeconds = {60}) const {}
 
   /// Add the given value to the stat.
-  virtual void addMetricValue(const std::string& key, size_t value = 1)
-      const = 0;
+  virtual void addMetricValue(const std::string& key, size_t value = 1) const {}
 
-  virtual void addMetricValue(const char* key, size_t value = 1) const = 0;
+  virtual void addMetricValue(const char* key, size_t value = 1) const {}
 
-  virtual void addMetricValue(folly::StringPiece key, size_t value = 1)
-      const = 0;
+  virtual void addMetricValue(folly::StringPiece key, size_t value = 1) const {}
 
   /// Add the given value to the histogram.
   virtual void addHistogramMetricValue(const std::string& key, size_t value)
-      const = 0;
+      const {}
 
-  virtual void addHistogramMetricValue(const char* key, size_t value) const = 0;
+  virtual void addHistogramMetricValue(const char* key, size_t value) const {}
 
   virtual void addHistogramMetricValue(folly::StringPiece key, size_t value)
-      const = 0;
+      const {}
+
+  /// Add the given value to a quantile metric.
+  virtual void addQuantileMetricValue(const std::string& key, size_t value = 1)
+      const {}
+
+  virtual void addQuantileMetricValue(const char* key, size_t value = 1) const {
+  }
+
+  virtual void addQuantileMetricValue(folly::StringPiece key, size_t value = 1)
+      const {}
+
+  /// Add the given value to a quantile metric.
+  virtual void addDynamicQuantileMetricValue(
+      const std::string& key,
+      folly::Range<const folly::StringPiece*> subkeys,
+      size_t value = 1) const {}
+
+  virtual void addDynamicQuantileMetricValue(
+      const char* key,
+      folly::Range<const folly::StringPiece*> subkeys,
+      size_t value = 1) const {}
+
+  virtual void addDynamicQuantileMetricValue(
+      folly::StringPiece key,
+      folly::Range<const folly::StringPiece*> subkeys,
+      size_t value = 1) const {}
 
   /// Return the aggregated metrics in a serialized string format.
-  virtual std::string fetchMetrics() = 0;
+  virtual std::string fetchMetrics() {
+    return "";
+  }
 
   static bool registered;
 };
@@ -165,6 +227,30 @@ class DummyStatsReporter : public BaseStatsReporter {
       int64_t /* max */,
       const std::vector<int32_t>& /* pcts */) const override {}
 
+  void registerQuantileMetricExportType(
+      const char* /* key */,
+      const std::vector<StatType>& /* statTypes */,
+      const std::vector<double>& /* pcts */,
+      const std::vector<size_t>& /* slidingWindowsSeconds */) const override {}
+
+  void registerQuantileMetricExportType(
+      folly::StringPiece /* key */,
+      const std::vector<StatType>& /* statTypes */,
+      const std::vector<double>& /* pcts */,
+      const std::vector<size_t>& /* slidingWindowsSeconds */) const override {}
+
+  void registerDynamicQuantileMetricExportType(
+      const char* /* keyPattern */,
+      const std::vector<StatType>& /* statTypes */,
+      const std::vector<double>& /* pcts */,
+      const std::vector<size_t>& /* slidingWindowsSeconds */) const override {}
+
+  void registerDynamicQuantileMetricExportType(
+      folly::StringPiece /* keyPattern */,
+      const std::vector<StatType>& /* statTypes */,
+      const std::vector<double>& /* pcts */,
+      const std::vector<size_t>& /* slidingWindowsSeconds */) const override {}
+
   void addMetricValue(const std::string& /* key */, size_t /* value */)
       const override {}
 
@@ -183,11 +269,82 @@ class DummyStatsReporter : public BaseStatsReporter {
   void addHistogramMetricValue(folly::StringPiece /* key */, size_t /* value */)
       const override {}
 
+  void addQuantileMetricValue(const std::string& /* key */, size_t /* value */)
+      const override {}
+
+  void addQuantileMetricValue(const char* /* key */, size_t /* value */)
+      const override {}
+
+  void addQuantileMetricValue(folly::StringPiece /* key */, size_t /* value */)
+      const override {}
+
+  void addDynamicQuantileMetricValue(
+      const std::string& /* key */,
+      folly::Range<const folly::StringPiece*> /* subkeys */,
+      size_t /* value */) const override {}
+
+  void addDynamicQuantileMetricValue(
+      const char* /* key */,
+      folly::Range<const folly::StringPiece*> /* subkeys */,
+      size_t /* value */) const override {}
+
+  void addDynamicQuantileMetricValue(
+      folly::StringPiece /* key */,
+      folly::Range<const folly::StringPiece*> /* subkeys */,
+      size_t /* value */) const override {}
+
   std::string fetchMetrics() override {
     return "";
   }
 };
 
+/// Helper functions to create vectors from variadic arguments, reducing
+/// boilerplate in quantile stat definitions.
+
+/// Create a vector of StatTypes from variadic arguments.
+/// Usage: statTypes(StatType::AVG, StatType::COUNT, StatType::SUM)
+template <typename... Args>
+std::vector<StatType> statTypes(Args... args) {
+  return std::vector<StatType>{args...};
+}
+
+/// Create a vector of percentiles from variadic arguments.
+/// Usage: percentiles(0.5, 0.95, 0.99)
+template <typename... Args>
+std::vector<double> percentiles(Args... args) {
+  return std::vector<double>{static_cast<double>(args)...};
+}
+
+/// Create a vector of sliding window periods in seconds from variadic
+/// arguments. Usage: slidingWindowsSeconds(60, 600, 3600)
+template <typename... Args>
+std::vector<size_t> slidingWindowsSeconds(Args... args) {
+  return std::vector<size_t>{static_cast<size_t>(args)...};
+}
+
+/// Helper class that stores subkeys in a member array and converts to
+/// folly::Range. This is a temporary object that lives just for the duration of
+/// the macro call.
+template <size_t N>
+class subkeys {
+  std::array<folly::StringPiece, N> pieces_;
+
+ public:
+  template <typename... Args>
+  subkeys(Args&&... args)
+      : pieces_{folly::StringPiece(std::forward<Args>(args))...} {}
+
+  /// Conversion operator to folly::Range<const folly::StringPiece*>
+  operator folly::Range<const folly::StringPiece*>() const {
+    return folly::Range<const folly::StringPiece*>(
+        pieces_.data(), pieces_.size());
+  }
+};
+
+/// Template deduction guide for subkeys class
+template <typename... Args>
+subkeys(Args&&...) -> subkeys<sizeof...(Args)>;
+
 #define DEFINE_METRIC(key, type)                               \
   {                                                            \
     if (::facebook::velox::BaseStatsReporter::registered) {    \
@@ -236,4 +393,52 @@ class DummyStatsReporter : public BaseStatsReporter {
       }                                                          \
     }                                                            \
   }
+
+#define DEFINE_QUANTILE_STAT(key, statTypes, percentiles, slidingWindows) \
+  {                                                                       \
+    if (::facebook::velox::BaseStatsReporter::registered) {               \
+      auto reporter = folly::Singleton<                                   \
+          facebook::velox::BaseStatsReporter>::try_get_fast();            \
+      if (FOLLY_LIKELY(reporter != nullptr)) {                            \
+        reporter->registerQuantileMetricExportType(                       \
+            (key), (statTypes), (percentiles), (slidingWindows));         \
+      }                                                                   \
+    }                                                                     \
+  }
+
+#define RECORD_QUANTILE_STAT_VALUE(key, ...)                    \
+  {                                                             \
+    if (::facebook::velox::BaseStatsReporter::registered) {     \
+      auto reporter = folly::Singleton<                         \
+          facebook::velox::BaseStatsReporter>::try_get_fast();  \
+      if (FOLLY_LIKELY(reporter != nullptr)) {                  \
+        reporter->addQuantileMetricValue((key), ##__VA_ARGS__); \
+      }                                                         \
+    }                                                           \
+  }
+
+#define DEFINE_DYNAMIC_QUANTILE_STAT(                                    \
+    keyPattern, statTypes, percentiles, slidingWindows)                  \
+  {                                                                      \
+    if (::facebook::velox::BaseStatsReporter::registered) {              \
+      auto reporter = folly::Singleton<                                  \
+          facebook::velox::BaseStatsReporter>::try_get_fast();           \
+      if (FOLLY_LIKELY(reporter != nullptr)) {                           \
+        reporter->registerDynamicQuantileMetricExportType(               \
+            (keyPattern), (statTypes), (percentiles), (slidingWindows)); \
+      }                                                                  \
+    }                                                                    \
+  }
+
+#define RECORD_DYNAMIC_QUANTILE_STAT_VALUE(keyPattern, subkeys, ...) \
+  {                                                                  \
+    if (::facebook::velox::BaseStatsReporter::registered) {          \
+      auto reporter = folly::Singleton<                              \
+          facebook::velox::BaseStatsReporter>::try_get_fast();       \
+      if (FOLLY_LIKELY(reporter != nullptr)) {                       \
+        reporter->addDynamicQuantileMetricValue(                     \
+            (keyPattern), (subkeys), ##__VA_ARGS__);                 \
+      }                                                              \
+    }                                                                \
+  }
 } // namespace facebook::velox
diff --git a/velox/common/base/Status.cpp b/velox/common/base/Status.cpp
index a170d3d9053f..46a5f603846a 100644
--- a/velox/common/base/Status.cpp
+++ b/velox/common/base/Status.cpp
@@ -115,4 +115,19 @@ void Status::warn(const std::string_view& message) const {
   LOG(WARNING) << message << ": " << toString();
 }
 
+std::string internal::generateError(std::string message, std::string exprStr) {
+  std::string elaborateMessage;
+  if (!message.empty()) {
+    elaborateMessage += "Reason: ";
+    elaborateMessage += message;
+    elaborateMessage += '\n';
+  }
+  if (!exprStr.empty()) {
+    elaborateMessage += "Expression: ";
+    elaborateMessage += exprStr;
+    elaborateMessage += '\n';
+  }
+  return elaborateMessage;
+}
+
 } // namespace facebook::velox
diff --git a/velox/common/base/Status.h b/velox/common/base/Status.h
index f5fd816d9469..1cf42673bc82 100644
--- a/velox/common/base/Status.h
+++ b/velox/common/base/Status.h
@@ -26,6 +26,8 @@
 #include <folly/Expected.h>
 #include <folly/Likely.h>
 
+#include "velox/common/base/ExceptionHelper.h"
+
 namespace facebook::velox {
 
 /// The Status object is an object holding the outcome of an operation (success
@@ -213,9 +215,6 @@ class [[nodiscard]] Status {
   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;
@@ -528,6 +527,77 @@ void Status::moveFrom(Status& s) {
     VELOX_RETURN_IF(!__s.ok(), __s);                          \
   } while (false)
 
+#define _VELOX_RETURN_IMPL(expr, exprStr, error, ...)                    \
+  do {                                                                   \
+    if (FOLLY_UNLIKELY(expr)) {                                          \
+      if (::facebook::velox::threadSkipErrorDetails()) {                 \
+        return error();                                                  \
+      }                                                                  \
+      auto message = ::facebook::velox::errorMessage(__VA_ARGS__);       \
+      return error(                                                      \
+          ::facebook::velox::internal::generateError(message, exprStr)); \
+    }                                                                    \
+  } 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
+/// arguments), we can just pass our own format string and arguments straight
+/// through.
+#define _VELOX_RETURN_OP_WITH_USER_FMT_HELPER(  \
+    implmacro, expr1, expr2, op, user_fmt, ...) \
+  implmacro(                                    \
+      (expr1)op(expr2),                         \
+      #expr1 " " #op " " #expr2,                \
+      "({} vs. {}) " user_fmt,                  \
+      expr1,                                    \
+      expr2,                                    \
+      ##__VA_ARGS__)
+
+#define _VELOX_RETURN_OP_HELPER(implmacro, expr1, expr2, op, ...) \
+  do {                                                            \
+    if constexpr (FOLLY_PP_DETAIL_NARGS(__VA_ARGS__) > 0) {       \
+      _VELOX_RETURN_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_USER_RETURN_IMPL(expr, exprStr, ...) \
+  _VELOX_RETURN_IMPL(                               \
+      expr, exprStr, ::facebook::velox::Status::UserError, ##__VA_ARGS__)
+
+#define _VELOX_USER_RETURN_OP(expr1, expr2, op, ...) \
+  _VELOX_RETURN_OP_HELPER(                           \
+      _VELOX_USER_RETURN_IMPL, expr1, expr2, op, ##__VA_ARGS__)
+
+// For all below macros, an additional message can be passed using a
+// format string and arguments, as with `fmt::format`.
+#define VELOX_USER_RETURN(expr, ...) \
+  _VELOX_USER_RETURN_IMPL(expr, #expr, ##__VA_ARGS__)
+#define VELOX_USER_RETURN_GT(e1, e2, ...) \
+  _VELOX_USER_RETURN_OP(e1, e2, >, ##__VA_ARGS__)
+#define VELOX_USER_RETURN_GE(e1, e2, ...) \
+  _VELOX_USER_RETURN_OP(e1, e2, >=, ##__VA_ARGS__)
+#define VELOX_USER_RETURN_LT(e1, e2, ...) \
+  _VELOX_USER_RETURN_OP(e1, e2, <, ##__VA_ARGS__)
+#define VELOX_USER_RETURN_LE(e1, e2, ...) \
+  _VELOX_USER_RETURN_OP(e1, e2, <=, ##__VA_ARGS__)
+#define VELOX_USER_RETURN_EQ(e1, e2, ...) \
+  _VELOX_USER_RETURN_OP(e1, e2, ==, ##__VA_ARGS__)
+#define VELOX_USER_RETURN_NE(e1, e2, ...) \
+  _VELOX_USER_RETURN_OP(e1, e2, !=, ##__VA_ARGS__)
+#define VELOX_USER_RETURN_NULL(e, ...) \
+  VELOX_USER_RETURN(e == nullptr, ##__VA_ARGS__)
+#define VELOX_USER_RETURN_NOT_NULL(e, ...) \
+  VELOX_USER_RETURN(e != nullptr, ##__VA_ARGS__)
+
 namespace internal {
 
 /// Common API for extracting Status from either Status or Result<T> (the latter
@@ -540,6 +610,8 @@ inline Status genericToStatus(Status&& st) {
   return std::move(st);
 }
 
+std::string generateError(std::string message, std::string exprStr);
+
 } // namespace internal
 
 /// Holds a result or an error. Designed to be used by APIs that do not throw.
diff --git a/velox/common/base/TraceConfig.cpp b/velox/common/base/TraceConfig.cpp
index d88a529ac7cd..5007be9a48c7 100644
--- a/velox/common/base/TraceConfig.cpp
+++ b/velox/common/base/TraceConfig.cpp
@@ -22,14 +22,16 @@
 namespace facebook::velox {
 
 TraceConfig::TraceConfig(
-    std::unordered_set<std::string> _queryNodeIds,
+    std::string _queryNodeId,
     std::string _queryTraceDir,
     UpdateAndCheckTraceLimitCB _updateAndCheckTraceLimitCB,
-    std::string _taskRegExp)
-    : queryNodes(std::move(_queryNodeIds)),
+    std::string _taskRegExp,
+    bool _dryRun)
+    : queryNodeId(std::move(_queryNodeId)),
       queryTraceDir(std::move(_queryTraceDir)),
       updateAndCheckTraceLimitCB(std::move(_updateAndCheckTraceLimitCB)),
-      taskRegExp(std::move(_taskRegExp)) {
-  VELOX_CHECK(!queryNodes.empty(), "Query trace nodes cannot be empty");
+      taskRegExp(std::move(_taskRegExp)),
+      dryRun(_dryRun) {
+  VELOX_CHECK(!queryNodeId.empty(), "The query trace node cannot be empty");
 }
 } // namespace facebook::velox
diff --git a/velox/common/base/TraceConfig.h b/velox/common/base/TraceConfig.h
index 231733facb2e..0eb84070f227 100644
--- a/velox/common/base/TraceConfig.h
+++ b/velox/common/base/TraceConfig.h
@@ -38,18 +38,23 @@ namespace facebook::velox {
 using UpdateAndCheckTraceLimitCB = std::function<void(uint64_t)>;
 
 struct TraceConfig {
-  /// Target query trace nodes.
-  std::unordered_set<std::string> queryNodes;
+  /// Target query trace node id.
+  std::string queryNodeId;
   /// Base dir of query trace.
   std::string queryTraceDir;
   UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB;
   /// The trace task regexp.
   std::string taskRegExp;
+  /// If true, we only collect operator input trace without the actual
+  /// execution. This is used by crash debugging so that we can collect the
+  /// input that triggers the crash.
+  bool dryRun{false};
 
   TraceConfig(
-      std::unordered_set<std::string> _queryNodeIds,
-      std::string _queryTraceDir,
-      UpdateAndCheckTraceLimitCB _updateAndCheckTraceLimitCB,
-      std::string _taskRegExp);
+      std::string queryNodeId,
+      std::string queryTraceDir,
+      UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB,
+      std::string taskRegExp,
+      bool dryRun);
 };
 } // namespace facebook::velox
diff --git a/velox/exec/TreeOfLosers.h b/velox/common/base/TreeOfLosers.h
similarity index 100%
rename from velox/exec/TreeOfLosers.h
rename to velox/common/base/TreeOfLosers.h
diff --git a/velox/common/base/VeloxException.cpp b/velox/common/base/VeloxException.cpp
index 735953d169a8..380659e60a5f 100644
--- a/velox/common/base/VeloxException.cpp
+++ b/velox/common/base/VeloxException.cpp
@@ -169,6 +169,18 @@ bool isStackTraceEnabled(VeloxException::Type type) {
   return last->compare_exchange_strong(latest, now, std::memory_order_relaxed);
 }
 
+void stringAppendNumber(std::string& str, size_t number) {
+  // Manual implementation of itoa to avoid the cost of std::to_string.
+  const auto numberStartOffset = str.end() -
+      str.begin(); // Not `size()`. We need distance. The type is different.
+  size_t remaining = number;
+  do {
+    str += static_cast<char>('0' + remaining % 10);
+    remaining /= 10;
+  } while (remaining);
+  reverse(str.begin() + numberStartOffset, str.end());
+}
+
 } // namespace
 
 template <typename F>
@@ -248,13 +260,7 @@ void VeloxException::State::finalize() const {
 
   if (line) {
     elaborateMessage += "Line: ";
-    auto len = elaborateMessage.size();
-    size_t t = line;
-    do {
-      elaborateMessage += static_cast<char>('0' + t % 10);
-      t /= 10;
-    } while (t);
-    reverse(elaborateMessage.begin() + len, elaborateMessage.end());
+    stringAppendNumber(elaborateMessage, line);
     elaborateMessage += '\n';
   }
 
diff --git a/velox/common/base/VeloxException.h b/velox/common/base/VeloxException.h
index 758eb1b6e6d8..b9ffb813f4f5 100644
--- a/velox/common/base/VeloxException.h
+++ b/velox/common/base/VeloxException.h
@@ -53,6 +53,10 @@ inline constexpr auto kErrorSourceRuntime = "RUNTIME"_fs;
 /// Errors where the root cause of the problem is some unreliable aspect of the
 /// system are classified with source SYSTEM.
 inline constexpr auto kErrorSourceSystem = "SYSTEM"_fs;
+
+/// Errors where the root cause of the problem is some external dependency (e.g.
+/// storage)
+inline constexpr auto kErrorSourceExternal = "EXTERNAL"_fs;
 } // namespace error_source
 
 namespace error_code {
@@ -438,7 +442,7 @@ ExceptionContext& getExceptionContext();
 /// exception context with the previous context held by the thread_local
 /// variable to allow retrieving the top-level context when there is an
 /// exception context hierarchy.
-class ExceptionContextSetter {
+class [[nodiscard]] ExceptionContextSetter {
  public:
   explicit ExceptionContextSetter(ExceptionContext value)
       : prev_{getExceptionContext()} {
diff --git a/velox/common/base/benchmarks/CMakeLists.txt b/velox/common/base/benchmarks/CMakeLists.txt
index a64e83974b6e..b4ffaf2f60a7 100644
--- a/velox/common/base/benchmarks/CMakeLists.txt
+++ b/velox/common/base/benchmarks/CMakeLists.txt
@@ -16,27 +16,37 @@ add_executable(velox_common_base_benchmarks BitUtilBenchmark.cpp)
 target_link_libraries(
   velox_common_base_benchmarks
   PUBLIC Folly::follybenchmark
-  PRIVATE velox_common_base Folly::folly)
+  PRIVATE velox_common_base Folly::folly
+)
 
 add_executable(velox_common_stringsearch_benchmarks StringSearchBenchmark.cpp)
 
 target_link_libraries(
   velox_common_stringsearch_benchmarks
   PUBLIC Folly::follybenchmark
-  PRIVATE velox_common_base Folly::folly)
+  PRIVATE velox_common_base Folly::folly
+)
 
-add_executable(velox_common_indexed_priority_queue_benchmark
-               IndexedPriorityQueueBenchmark.cpp)
+add_executable(velox_common_indexed_priority_queue_benchmark IndexedPriorityQueueBenchmark.cpp)
 
 target_link_libraries(
   velox_common_indexed_priority_queue_benchmark
   PUBLIC Folly::follybenchmark
-  PRIVATE velox_common_base Folly::folly)
+  PRIVATE velox_common_base Folly::folly
+)
 
-add_executable(velox_common_sorting_network_benchmark
-               SortingNetworkBenchmark.cpp)
+add_executable(velox_common_sorting_network_benchmark SortingNetworkBenchmark.cpp)
 
 target_link_libraries(
   velox_common_sorting_network_benchmark
   PUBLIC Folly::follybenchmark
-  PRIVATE velox_common_base Folly::folly)
+  PRIVATE velox_common_base Folly::folly
+)
+
+add_executable(velox_common_split_block_bloom_filter_benchmark SplitBlockBloomFilterBenchmark.cpp)
+
+target_link_libraries(
+  velox_common_split_block_bloom_filter_benchmark
+  PUBLIC Folly::follybenchmark
+  PRIVATE velox_common_base Folly::folly
+)
diff --git a/velox/common/base/benchmarks/SplitBlockBloomFilterBenchmark.cpp b/velox/common/base/benchmarks/SplitBlockBloomFilterBenchmark.cpp
new file mode 100644
index 000000000000..6706be84ab24
--- /dev/null
+++ b/velox/common/base/benchmarks/SplitBlockBloomFilterBenchmark.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/common/base/SplitBlockBloomFilter.h"
+
+#include <folly/Benchmark.h>
+#include <folly/Random.h>
+#include <folly/init/Init.h>
+
+#define VELOX_BENCHMARK(_make, _name, ...) \
+  [[maybe_unused]] auto _name = _make(FOLLY_PP_STRINGIZE(_name), __VA_ARGS__)
+
+namespace facebook::velox {
+namespace {
+
+template <typename T, typename Hasher>
+class SplitBlockBloomFilterBenchmark {
+ public:
+  SplitBlockBloomFilterBenchmark(
+      const char* name,
+      Hasher hasher,
+      double falsePositive,
+      int numInserts,
+      int numTests)
+      : hasher_(std::move(hasher)),
+        numTests_(numTests),
+        blocks_(SplitBlockBloomFilter::numBlocks(numInserts, falsePositive)),
+        filter_(blocks_) {
+    for (int i = 0; i < numInserts; ++i) {
+      filter_.insert(hasher_(generateValue()));
+    }
+    folly::addBenchmark(__FILE__, name, [this] { return run(); });
+  }
+
+ private:
+  static T generateValue() {
+    if constexpr (sizeof(T) == 8) {
+      return folly::Random::rand64();
+    } else {
+      static_assert(sizeof(T) == 4);
+      return folly::Random::rand32();
+    }
+  }
+
+  unsigned run() const {
+    int numHits = 0;
+    for (int i = 0; i < numTests_; ++i) {
+      numHits += filter_.mayContain(hasher_(generateValue()));
+    }
+    folly::doNotOptimizeAway(numHits);
+    return numTests_;
+  }
+
+  const Hasher hasher_;
+  const double numTests_;
+  std::vector<SplitBlockBloomFilter::Block> blocks_;
+  SplitBlockBloomFilter filter_;
+};
+
+template <typename T, typename Hasher>
+SplitBlockBloomFilterBenchmark<T, Hasher> makeBenchmark(
+    const char* name,
+    Hasher hasher,
+    double falsePositive,
+    int numInserts,
+    int numTests) {
+  return SplitBlockBloomFilterBenchmark<T, Hasher>(
+      name, std::move(hasher), falsePositive, numInserts, numTests);
+}
+
+} // namespace
+} // namespace facebook::velox
+
+int main(int argc, char* argv[]) {
+  using namespace facebook::velox;
+  folly::Init follyInit(&argc, &argv);
+  VELOX_BENCHMARK(
+      makeBenchmark<int32_t>,
+      int32,
+      folly::hasher<int64_t>(),
+      0.01,
+      5'000'000,
+      10'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64,
+      folly::hasher<int64_t>(),
+      0.01,
+      5'000'000,
+      10'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_nohash,
+      folly::identity,
+      0.01,
+      5'000'000,
+      10'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int32_t>,
+      int32_small,
+      folly::hasher<int64_t>(),
+      0.01,
+      500'000,
+      1'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_small,
+      folly::hasher<int64_t>(),
+      0.01,
+      500'000,
+      1'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_nohash_small,
+      folly::identity,
+      0.01,
+      500'000,
+      1'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int32_t>,
+      int32_large,
+      folly::hasher<int64_t>(),
+      0.01,
+      50'000'000,
+      100'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_large,
+      folly::hasher<int64_t>(),
+      0.01,
+      50'000'000,
+      100'000'000);
+  VELOX_BENCHMARK(
+      makeBenchmark<int64_t>,
+      int64_nohash_large,
+      folly::identity,
+      0.01,
+      50'000'000,
+      100'000'000);
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/common/base/benchmarks/StringSearchBenchmark.cpp b/velox/common/base/benchmarks/StringSearchBenchmark.cpp
index 5fee996709a3..cad51cb56fa7 100644
--- a/velox/common/base/benchmarks/StringSearchBenchmark.cpp
+++ b/velox/common/base/benchmarks/StringSearchBenchmark.cpp
@@ -105,11 +105,12 @@ class TestStringSearch {
   void runSearching(size_t iters) const {
     if constexpr (alg == SIMD) {
       FOR_EACH_RANGE (i, 0, iters)
-        doNotOptimizeAway(simd::simdStrstr(
-            heyStack_.data(),
-            heyStack_.size(),
-            needle_.data(),
-            needle_.size()));
+        doNotOptimizeAway(
+            simd::simdStrstr(
+                heyStack_.data(),
+                heyStack_.size(),
+                needle_.data(),
+                needle_.size()));
     } else if constexpr (alg == STD) {
       FOR_EACH_RANGE (i, 0, iters)
         doNotOptimizeAway(
diff --git a/velox/common/base/tests/AsyncSourceTest.cpp b/velox/common/base/tests/AsyncSourceTest.cpp
index 657a7ba8e08e..ce20becfeb4f 100644
--- a/velox/common/base/tests/AsyncSourceTest.cpp
+++ b/velox/common/base/tests/AsyncSourceTest.cpp
@@ -296,3 +296,134 @@ TEST(AsyncSourceTest, setContexts) {
 
   verifyContexts("test2", "task_id2");
 }
+
+TEST(AsyncSourceTest, cancel) {
+  DataCounter::reset();
+
+  // Cancel before prepare() - task should not run and resources cleaned up
+  {
+    auto dataCounter = std::make_shared<DataCounter>();
+    auto asyncSource = std::make_shared<AsyncSource<uint64_t>>([dataCounter]() {
+      return std::make_unique<uint64_t>(dataCounter->objectNumber());
+    });
+    dataCounter.reset();
+
+    asyncSource->cancel();
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+  }
+  DataCounter::reset();
+
+  // Cancel while task is running in prepare() - should not affect the
+  // prepare() result
+  {
+    folly::Baton<> startBaton;
+    folly::Baton<> finishBaton;
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        [&startBaton, &finishBaton]() {
+          startBaton.post();
+          finishBaton.wait();
+          return std::make_unique<DataCounter>();
+        });
+
+    auto thread = std::thread([&asyncSource] { asyncSource->prepare(); });
+    EXPECT_TRUE(
+        startBaton.try_wait_for(1s)); // Make sure prepare() gets lock first
+
+    asyncSource->cancel(); // Should be no-op
+
+    finishBaton.post();
+    thread.join();
+
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+    EXPECT_TRUE(asyncSource->hasValue());
+  }
+  DataCounter::reset();
+
+  // Cancel after prepare() completes - should not destroy the result
+  {
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        []() { return std::make_unique<DataCounter>(); });
+    asyncSource->prepare();
+
+    asyncSource->cancel(); // Should be no-op since make_ was taken
+
+    EXPECT_TRUE(asyncSource->hasValue());
+    EXPECT_NE(asyncSource->move(), nullptr);
+  }
+  DataCounter::reset();
+
+  // prepare() and move() are no-ops after cancel()
+  {
+    std::atomic<bool> taskExecuted{false};
+    auto asyncSource =
+        std::make_shared<AsyncSource<DataCounter>>([&taskExecuted]() {
+          taskExecuted = true;
+          return std::make_unique<DataCounter>();
+        });
+
+    asyncSource->cancel();
+    asyncSource->prepare(); // No-op
+    EXPECT_FALSE(taskExecuted);
+    EXPECT_FALSE(asyncSource->hasValue());
+
+    EXPECT_EQ(asyncSource->move(), nullptr); // No-op
+    EXPECT_FALSE(taskExecuted);
+  }
+
+  // Multiple cancel calls are idempotent
+  {
+    auto dataCounter = std::make_shared<DataCounter>();
+    auto asyncSource = std::make_shared<AsyncSource<uint64_t>>([dataCounter]() {
+      return std::make_unique<uint64_t>(dataCounter->objectNumber());
+    });
+    dataCounter.reset();
+
+    asyncSource->cancel();
+    asyncSource->cancel(); // Should be safe
+    EXPECT_EQ(DataCounter::numDeletedDataCounters(), 1);
+  }
+  DataCounter::reset();
+
+  // Cancel called during move() execution - should be no-op
+  {
+    folly::Baton<> moveStarted;
+    folly::Baton<> continueMove;
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        [&moveStarted, &continueMove]() {
+          moveStarted.post();
+          continueMove.wait();
+          return std::make_unique<DataCounter>();
+        });
+
+    // move() will execute the lambda inline since prepare() wasn't called
+    auto moveThread = std::thread([&asyncSource] {
+      auto result = asyncSource->move();
+      EXPECT_NE(result, nullptr);
+    });
+
+    EXPECT_TRUE(moveStarted.try_wait_for(1s)); // Wait for move to start
+
+    asyncSource->cancel(); // Should be no-op - make_ already taken
+
+    continueMove.post();
+    moveThread.join();
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  }
+  DataCounter::reset();
+
+  // Cancel called after move() completes - should be no-op
+  {
+    auto asyncSource = std::make_shared<AsyncSource<DataCounter>>(
+        []() { return std::make_unique<DataCounter>(); });
+
+    auto result = asyncSource->move(); // Complete move
+    EXPECT_NE(result, nullptr);
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+
+    asyncSource->cancel(); // Should be no-op - moved_ is true, make_ is null
+
+    // Item was already consumed
+    EXPECT_EQ(DataCounter::numCreatedDataCounters(), 1);
+  }
+  DataCounter::reset();
+}
diff --git a/velox/common/base/tests/BitUtilTest.cpp b/velox/common/base/tests/BitUtilTest.cpp
index 5ee8e4ce5066..4450a5145ca1 100644
--- a/velox/common/base/tests/BitUtilTest.cpp
+++ b/velox/common/base/tests/BitUtilTest.cpp
@@ -541,6 +541,21 @@ TEST_F(BitUtilTest, getAndClearLastSetBit) {
   EXPECT_EQ(bits, 0);
 }
 
+TEST_F(BitUtilTest, negateBit) {
+  char data[35];
+  for (int32_t i = 0; i < 100; i++) {
+    setBit(data, i, true);
+  }
+  std::vector<uint64_t> indices = {0, 1, 2, 3, 4, 5, 6, 7};
+  for (auto i : indices) {
+    negateBit(data, i);
+    EXPECT_EQ(isBitSet(data, i), false);
+  }
+  for (int32_t i = 8; i < 100; i++) {
+    EXPECT_EQ(isBitSet(data, i), true);
+  }
+}
+
 TEST_F(BitUtilTest, negate) {
   char data[35];
   for (int32_t i = 0; i < 100; i++) {
diff --git a/velox/common/base/tests/BloomFilterTest.cpp b/velox/common/base/tests/BloomFilterTest.cpp
index fdc15090dd1d..7b1833042ea2 100644
--- a/velox/common/base/tests/BloomFilterTest.cpp
+++ b/velox/common/base/tests/BloomFilterTest.cpp
@@ -63,6 +63,38 @@ TEST_F(BloomFilterTest, serialize) {
   EXPECT_EQ(bloom.serializedSize(), deserialized.serializedSize());
 }
 
+TEST_F(BloomFilterTest, staticMayContain) {
+  constexpr int32_t kSize = 1024;
+  std::string serializedBloom;
+  BloomFilter bloom;
+  bloom.reset(kSize);
+  for (auto i = 0; i < kSize; ++i) {
+    bloom.insert(folly::hasher<int32_t>()(i));
+  }
+  serializedBloom.resize(bloom.serializedSize());
+  bloom.serialize(serializedBloom.data());
+  int32_t numFalsePositives = 0;
+  for (auto i = 0; i < kSize; ++i) {
+    EXPECT_TRUE(
+        BloomFilter<>::mayContain(
+            serializedBloom.data(), folly::hasher<int32_t>()(i)));
+
+    const uint64_t smallValueHash = folly::hasher<int32_t>()(i + kSize);
+    const bool isFalsePositiveForSmallValue =
+        BloomFilter<>::mayContain(serializedBloom.data(), smallValueHash);
+    EXPECT_EQ(isFalsePositiveForSmallValue, bloom.mayContain(smallValueHash));
+    numFalsePositives += isFalsePositiveForSmallValue;
+
+    const uint64_t largeValueHash =
+        folly::hasher<int32_t>()((i + kSize) * 123451);
+    const bool isFalsePositiveForLargeValue =
+        BloomFilter<>::mayContain(serializedBloom.data(), largeValueHash);
+    EXPECT_EQ(isFalsePositiveForLargeValue, bloom.mayContain(largeValueHash));
+    numFalsePositives += isFalsePositiveForLargeValue;
+  }
+  EXPECT_GT(2, 100 * numFalsePositives / kSize);
+}
+
 TEST_F(BloomFilterTest, merge) {
   constexpr int32_t kSize = 10;
   BloomFilter bloom;
diff --git a/velox/common/base/tests/CMakeLists.txt b/velox/common/base/tests/CMakeLists.txt
index 6f1a7ab4ef20..0a85dca57ce1 100644
--- a/velox/common/base/tests/CMakeLists.txt
+++ b/velox/common/base/tests/CMakeLists.txt
@@ -32,9 +32,11 @@ add_executable(
   SkewedPartitionBalancerTest.cpp
   SpillConfigTest.cpp
   SpillStatsTest.cpp
+  SplitBlockBloomFilterTest.cpp
   StatsReporterTest.cpp
   StatusTest.cpp
-  SuccinctPrinterTest.cpp)
+  SuccinctPrinterTest.cpp
+)
 
 add_test(velox_base_test velox_base_test)
 
@@ -55,7 +57,8 @@ target_link_libraries(
     gflags::gflags
     GTest::gtest
     GTest::gmock
-    GTest::gtest_main)
+    GTest::gtest_main
+)
 
 add_executable(velox_id_map_test IdMapTest.cpp)
 
@@ -70,14 +73,11 @@ target_link_libraries(
   glog::glog
   GTest::gtest
   GTest::gtest_main
-  pthread)
+  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)
+  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
index c96fc1ac9576..07967c0f965d 100644
--- a/velox/common/base/tests/ConcurrentCounterTest.cpp
+++ b/velox/common/base/tests/ConcurrentCounterTest.cpp
@@ -18,6 +18,7 @@
 
 #include <fmt/format.h>
 #include <folly/Random.h>
+#include <folly/system/HardwareConcurrency.h>
 #include <gtest/gtest.h>
 #include "velox/common/base/tests/GTestUtils.h"
 
@@ -48,7 +49,7 @@ class ConcurrentCounterTest : public testing::TestWithParam<bool> {
 
   void setupCounter() {
     counter_ = std::make_unique<ConcurrentCounter<int64_t>>(
-        std::thread::hardware_concurrency());
+        folly::hardware_concurrency());
   }
 
   const bool useUpdateFn_{GetParam()};
@@ -72,8 +73,8 @@ 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);
+  numThreads.push_back(folly::hardware_concurrency());
+  numThreads.push_back(folly::hardware_concurrency() * 2);
   for (int numThreads : numThreads) {
     SCOPED_TRACE(fmt::format("numThreads: {}", numThreads));
     counter_->testingClear();
diff --git a/velox/common/base/tests/ExceptionTest.cpp b/velox/common/base/tests/ExceptionTest.cpp
index 9386b8cb672e..ff00f02489d2 100644
--- a/velox/common/base/tests/ExceptionTest.cpp
+++ b/velox/common/base/tests/ExceptionTest.cpp
@@ -41,7 +41,7 @@ struct fmt::formatter<Counter> {
   template <typename FormatContext>
   auto format(const Counter& c, FormatContext& ctx) const {
     auto x = c.counter++;
-    return format_to(ctx.out(), "{}", x);
+    return fmt::format_to(ctx.out(), "{}", x);
   }
 };
 
@@ -65,7 +65,7 @@ void verifyVeloxException(
     std::function<void()> f,
     const std::string& messagePrefix) {
   verifyException<VeloxException>(f, [&messagePrefix](const auto& e) {
-    EXPECT_TRUE(folly::StringPiece{e.what()}.startsWith(messagePrefix))
+    EXPECT_TRUE(std::string_view{e.what()}.starts_with(messagePrefix))
         << "\nException message prefix mismatch.\n\nExpected prefix: "
         << messagePrefix << "\n\nActual message: " << e.what();
   });
@@ -106,11 +106,12 @@ void testExceptionTraceCollectionControl(bool userException, bool enabled) {
           false);
     }
   } catch (VeloxException& e) {
-    SCOPED_TRACE(fmt::format(
-        "enabled: {}, user flag: {}, sys flag: {}",
-        enabled,
-        FLAGS_velox_exception_user_stacktrace_enabled,
-        FLAGS_velox_exception_system_stacktrace_enabled));
+    SCOPED_TRACE(
+        fmt::format(
+            "enabled: {}, user flag: {}, sys flag: {}",
+            enabled,
+            FLAGS_velox_exception_user_stacktrace_enabled,
+            FLAGS_velox_exception_system_stacktrace_enabled));
     ASSERT_EQ(userException, e.exceptionType() == VeloxException::Type::kUser);
     ASSERT_EQ(enabled, e.stackTrace() != nullptr);
   }
@@ -170,12 +171,13 @@ void testExceptionTraceCollectionRateControl(
             false);
       }
     } catch (VeloxException& e) {
-      SCOPED_TRACE(fmt::format(
-          "userException: {}, hasRateLimit: {}, user limit: {}ms, sys limit: {}ms",
-          userException,
-          hasRateLimit,
-          FLAGS_velox_exception_user_stacktrace_rate_limit_ms,
-          FLAGS_velox_exception_system_stacktrace_rate_limit_ms));
+      SCOPED_TRACE(
+          fmt::format(
+              "userException: {}, hasRateLimit: {}, user limit: {}ms, sys limit: {}ms",
+              userException,
+              hasRateLimit,
+              FLAGS_velox_exception_user_stacktrace_rate_limit_ms,
+              FLAGS_velox_exception_system_stacktrace_rate_limit_ms));
       ASSERT_EQ(
           userException, e.exceptionType() == VeloxException::Type::kUser);
       ASSERT_EQ(!hasRateLimit || ((iter % 2) == 0), e.stackTrace() != nullptr);
@@ -1015,6 +1017,6 @@ TEST(ExceptionTest, exceptionMacroInlining) {
   try {
     VELOX_USER_FAIL(errorStr, "definitely");
   } catch (const std::exception& e) {
-    ASSERT_TRUE(folly::StringPiece{e.what()}.startsWith("argument not found"));
+    ASSERT_TRUE(std::string_view{e.what()}.starts_with("argument not found"));
   }
 }
diff --git a/velox/common/base/tests/GTestUtils.h b/velox/common/base/tests/GTestUtils.h
index 1f733808740a..42ec23513c4b 100644
--- a/velox/common/base/tests/GTestUtils.h
+++ b/velox/common/base/tests/GTestUtils.h
@@ -61,13 +61,15 @@
       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() << "'."
+  {                                                                        \
+    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)                            \
@@ -99,12 +101,46 @@
       _errorCode,                           \
       _errorMessage)
 
+#define VELOX_EXPECT_EQ_TYPES(actual, expected)                         \
+  {                                                                     \
+    auto _actualType = (actual);                                        \
+    auto _expectedType = (expected);                                    \
+    if (_expectedType != nullptr) {                                     \
+      ASSERT_TRUE(_actualType != nullptr)                               \
+          << "Expected: " << _expectedType->toString() << ", got null"; \
+      EXPECT_EQ(*_actualType, *_expectedType)                           \
+          << "Expected: " << _expectedType->toString() << ", got "      \
+          << _actualType->toString();                                   \
+    } else {                                                            \
+      EXPECT_EQ(_actualType, nullptr)                                   \
+          << "Expected null, got " << _actualType->toString();          \
+    }                                                                   \
+  }
+
+#define VELOX_ASSERT_EQ_TYPES(actual, expected)                         \
+  {                                                                     \
+    auto _actualType = (actual);                                        \
+    auto _expectedType = (expected);                                    \
+    if (_expectedType != nullptr) {                                     \
+      ASSERT_TRUE(_actualType != nullptr)                               \
+          << "Expected: " << _expectedType->toString() << ", got null"; \
+      ASSERT_EQ(*_actualType, *_expectedType)                           \
+          << "Expected: " << _expectedType->toString() << ", got "      \
+          << _actualType->toString();                                   \
+    } else {                                                            \
+      ASSERT_EQ(_actualType, nullptr)                                   \
+          << "Expected null, got " << _actualType->toString();          \
+    }                                                                   \
+  }
+
 #ifndef NDEBUG
 #define DEBUG_ONLY_TEST(test_fixture, test_name) TEST(test_fixture, test_name)
 #define DEBUG_ONLY_TEST_F(test_fixture, test_name) \
   TEST_F(test_fixture, test_name)
 #define DEBUG_ONLY_TEST_P(test_fixture, test_name) \
   TEST_P(test_fixture, test_name)
+#define DEBUG_ONLY_CO_TEST_F(test_fixture, test_name) \
+  CO_TEST_F(test_fixture, test_name)
 #else
 #define DEBUG_ONLY_TEST(test_fixture, test_name) \
   TEST(test_fixture, DISABLED_##test_name)
@@ -112,4 +148,6 @@
   TEST_F(test_fixture, DISABLED_##test_name)
 #define DEBUG_ONLY_TEST_P(test_fixture, test_name) \
   TEST_P(test_fixture, DISABLED_##test_name)
+#define DEBUG_ONLY_CO_TEST_F(test_fixture, test_name) \
+  CO_TEST_F(test_fixture, DISABLED_test_name)
 #endif
diff --git a/velox/common/base/tests/Memcpy.cpp b/velox/common/base/tests/Memcpy.cpp
index 2ab51f87815e..18c7150759be 100644
--- a/velox/common/base/tests/Memcpy.cpp
+++ b/velox/common/base/tests/Memcpy.cpp
@@ -74,7 +74,7 @@ int main(int argc, char** argv) {
   Semaphore sem(0);
   std::vector<CopyCallable> ops;
   ops.resize(FLAGS_threads);
-  volatile uint64_t totalSum = 0;
+  uint64_t totalSum = 0;
   uint64_t totalUsec = 0;
   for (auto repeat = 0; repeat < FLAGS_repeats; ++repeat) {
     // Read once through 'other' to clear cache effects.
diff --git a/velox/common/base/tests/SimdUtilTest.cpp b/velox/common/base/tests/SimdUtilTest.cpp
index 447cc55a6e2f..4b932d9a1b3e 100644
--- a/velox/common/base/tests/SimdUtilTest.cpp
+++ b/velox/common/base/tests/SimdUtilTest.cpp
@@ -126,6 +126,7 @@ class SimdUtilTest : public testing::Test {
   folly::Random::DefaultGenerator rng_;
 };
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 TEST_F(SimdUtilTest, setAll) {
   auto bits = simd::setAll(true);
   auto words = reinterpret_cast<int64_t*>(&bits);
@@ -133,6 +134,7 @@ TEST_F(SimdUtilTest, setAll) {
     EXPECT_EQ(words[i], -1ll);
   }
 }
+#endif
 
 TEST_F(SimdUtilTest, bitIndices) {
   testIndices(1);
diff --git a/velox/common/base/tests/SkewedPartitionBalancerTest.cpp b/velox/common/base/tests/SkewedPartitionBalancerTest.cpp
index 5edb57563c60..9df4a2be7d73 100644
--- a/velox/common/base/tests/SkewedPartitionBalancerTest.cpp
+++ b/velox/common/base/tests/SkewedPartitionBalancerTest.cpp
@@ -409,8 +409,9 @@ TEST_F(SkewedPartitionRebalancerTest, concurrentFuzz) {
         threads.emplace_back([&]() {
           std::mt19937 localRng{200};
           for (int iteration = 0; iteration < 1'000; ++iteration) {
-            SCOPED_TRACE(fmt::format(
-                "taskCount {}, iteration {}", taskCount, iteration));
+            SCOPED_TRACE(
+                fmt::format(
+                    "taskCount {}, iteration {}", taskCount, iteration));
             const uint64_t processedBytes =
                 1 + folly::Random::rand32(512, localRng);
             balancer->addProcessedBytes(processedBytes);
diff --git a/velox/common/base/tests/SpillConfigTest.cpp b/velox/common/base/tests/SpillConfigTest.cpp
index 9949486a4862..30251da5c9bb 100644
--- a/velox/common/base/tests/SpillConfigTest.cpp
+++ b/velox/common/base/tests/SpillConfigTest.cpp
@@ -48,6 +48,7 @@ TEST_P(SpillConfigTest, spillLevel) {
       0,
       0,
       "none",
+      0,
       prefixSortConfig_);
   struct {
     uint8_t bitOffset;
@@ -134,6 +135,7 @@ TEST_P(SpillConfigTest, spillLevelLimit) {
         0,
         0,
         "none",
+        0,
         prefixSortConfig_);
 
     ASSERT_EQ(
@@ -181,6 +183,7 @@ TEST_P(SpillConfigTest, spillableReservationPercentages) {
           1'000'000,
           0,
           "none",
+          0,
           prefixSortConfig_);
     };
 
diff --git a/velox/common/base/tests/SpillStatsTest.cpp b/velox/common/base/tests/SpillStatsTest.cpp
index a9630c2bc972..965640114825 100644
--- a/velox/common/base/tests/SpillStatsTest.cpp
+++ b/velox/common/base/tests/SpillStatsTest.cpp
@@ -62,19 +62,11 @@ TEST(SpillStatsTest, spillStats) {
   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);
@@ -114,10 +106,6 @@ TEST(SpillStatsTest, spillStats) {
   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;
diff --git a/velox/common/base/tests/SplitBlockBloomFilterTest.cpp b/velox/common/base/tests/SplitBlockBloomFilterTest.cpp
new file mode 100644
index 000000000000..2a98ea756348
--- /dev/null
+++ b/velox/common/base/tests/SplitBlockBloomFilterTest.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/SplitBlockBloomFilter.h"
+#include "velox/common/testutil/RandomSeed.h"
+
+#include <folly/container/F14Set.h>
+#include <gtest/gtest.h>
+
+#include <random>
+
+namespace facebook::velox::test {
+namespace {
+
+template <typename Hasher>
+SplitBlockBloomFilter makeFilter(
+    const folly::F14FastSet<int64_t>& values,
+    const Hasher& hasher,
+    std::vector<SplitBlockBloomFilter::Block>& blocks) {
+  blocks.resize(SplitBlockBloomFilter::numBlocks(values.size(), 0.01));
+  bzero(blocks.data(), blocks.size() * sizeof(SplitBlockBloomFilter::Block));
+  SplitBlockBloomFilter filter(blocks);
+  for (auto& value : values) {
+    filter.insert(hasher(value));
+  }
+  return filter;
+}
+
+TEST(SplitBlockBloomFilterTest, numBlocks) {
+  ASSERT_EQ(
+      SplitBlockBloomFilter::numBlocks(50'000'000, 0.01) *
+          sizeof(SplitBlockBloomFilter::Block),
+      xsimd::batch<uint32_t>::size == 8 ? 60509568 : 65766912);
+  ASSERT_EQ(
+      SplitBlockBloomFilter::numBlocks(45'523'964, 0.1) *
+          sizeof(SplitBlockBloomFilter::Block),
+      xsimd::batch<uint32_t>::size == 8 ? 32848640 : 27546352);
+}
+
+TEST(SplitBlockBloomFilterTest, contiguous) {
+  constexpr int kSize = 100'000;
+  std::default_random_engine gen(common::testutil::getRandomSeed(42));
+  std::uniform_int_distribution<> dist(0, 9);
+  folly::F14FastSet<int64_t> values;
+  values.reserve(kSize / 10);
+  for (int i = 0; i < kSize; ++i) {
+    if (dist(gen) == 0) {
+      values.insert(i);
+    }
+  }
+  std::vector<SplitBlockBloomFilter::Block> blocks;
+  auto test = [&](auto hasher) {
+    auto filter = makeFilter(values, hasher, blocks);
+    int numFalsePositive = 0;
+    for (int i = 0; i < kSize; ++i) {
+      if (values.contains(i)) {
+        ASSERT_TRUE(filter.mayContain(hasher(i)));
+      } else {
+        numFalsePositive += filter.mayContain(hasher(i));
+      }
+    }
+    ASSERT_LT(1.0 * numFalsePositive / kSize, 0.03);
+  };
+  {
+    SCOPED_TRACE("Folly");
+    test(folly::hasher<int64_t>());
+  }
+  {
+    SCOPED_TRACE("Multiplication");
+    test([](auto x) { return x * 0xc6a4a7935bd1e995L; });
+  }
+}
+
+TEST(SplitBlockBloomFilterTest, random) {
+  constexpr int kSize = 100'000;
+  std::default_random_engine gen(common::testutil::getRandomSeed(42));
+  std::uniform_int_distribution<int64_t> dist;
+  folly::F14FastSet<int64_t> values;
+  values.reserve(kSize);
+  for (int i = 0; i < kSize; ++i) {
+    values.insert(dist(gen));
+  }
+  std::vector<SplitBlockBloomFilter::Block> blocks;
+  auto test = [&](auto hasher) {
+    auto filter = makeFilter(values, hasher, blocks);
+    for (auto value : values) {
+      ASSERT_TRUE(filter.mayContain(hasher(value)));
+    }
+    int numFalsePositive = 0;
+    for (int i = 0; i < kSize; ++i) {
+      auto value = dist(gen);
+      if (!values.contains(value)) {
+        numFalsePositive += filter.mayContain(hasher(value));
+      }
+    }
+    ASSERT_LT(1.0 * numFalsePositive / kSize, 0.03);
+  };
+  {
+    SCOPED_TRACE("Folly");
+    test(folly::hasher<int64_t>());
+  }
+  {
+    SCOPED_TRACE("Multiplication");
+    test([](auto x) { return x * 0xc6a4a7935bd1e995L; });
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::test
diff --git a/velox/common/base/tests/StatsReporterTest.cpp b/velox/common/base/tests/StatsReporterTest.cpp
index 1fed4b9eb948..d76827d32f97 100644
--- a/velox/common/base/tests/StatsReporterTest.cpp
+++ b/velox/common/base/tests/StatsReporterTest.cpp
@@ -15,7 +15,6 @@
  */
 
 #include "velox/common/base/StatsReporter.h"
-#include <folly/Singleton.h>
 #include <folly/init/Init.h>
 #include <gtest/gtest.h>
 #include <cstdint>
@@ -23,114 +22,81 @@
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/PeriodicStatsReporter.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/base/tests/StatsReporterUtils.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 {
+namespace facebook::velox::test {
 
-class TestReporter : public BaseStatsReporter {
- public:
-  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 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 registerMetricExportType(folly::StringPiece key, StatType statType)
-      const override {
-    statTypeMap[key.str()] = statType;
-  }
-
-  void registerHistogramMetricExportType(
-      const char* key,
-      int64_t /* bucketWidth */,
-      int64_t /* min */,
-      int64_t /* max */,
-      const std::vector<int32_t>& pcts) const override {
-    histogramPercentilesMap[key] = pcts;
-  }
-
-  void registerHistogramMetricExportType(
-      folly::StringPiece key,
-      int64_t /* bucketWidth */,
-      int64_t /* min */,
-      int64_t /* max */,
-      const std::vector<int32_t>& pcts) const override {
-    histogramPercentilesMap[key.str()] = pcts;
-  }
-
-  void addMetricValue(const std::string& key, const size_t value)
-      const override {
-    std::lock_guard<std::mutex> l(m);
-    counterMap[key] += value;
-  }
-
-  void addMetricValue(const char* key, const size_t value) const override {
-    std::lock_guard<std::mutex> l(m);
-    counterMap[key] += value;
-  }
-
-  void addMetricValue(folly::StringPiece key, size_t value) const override {
-    std::lock_guard<std::mutex> l(m);
-    counterMap[key.str()] += value;
-  }
-
-  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 addHistogramMetricValue(const char* key, size_t value) const override {
-    std::lock_guard<std::mutex> l(m);
-    counterMap[key] = std::max(counterMap[key], value);
-  }
-
-  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();
-  }
+struct QuantileConfig {
+  std::vector<StatType> statTypes;
+  std::vector<double> percentiles;
+  std::vector<size_t> slidingWindows;
 };
 
+inline QuantileConfig createStandardConfig() {
+  return {{StatType::AVG, StatType::COUNT}, {0.5, 0.95}, {60, 600}};
+}
+
 class StatsReporterTest : public testing::Test {
  protected:
   void SetUp() override {
+    // Set the registered flag to true so macros will work
+    BaseStatsReporter::registered = true;
     reporter_ = std::dynamic_pointer_cast<TestReporter>(
         folly::Singleton<BaseStatsReporter>::try_get());
     reporter_->clear();
   }
   void TearDown() override {
     reporter_->clear();
+    // Reset the registered flag
+    BaseStatsReporter::registered = false;
   }
 
+ public:
   std::shared_ptr<TestReporter> reporter_;
+
+  void verifyQuantileRegistration(
+      const std::string& key,
+      const QuantileConfig& config) {
+    EXPECT_TRUE(reporter_->quantileStatTypesMap.count(key));
+    EXPECT_EQ(config.statTypes, reporter_->quantileStatTypesMap[key]);
+    EXPECT_EQ(config.percentiles, reporter_->quantilePercentilesMap[key]);
+    EXPECT_EQ(config.slidingWindows, reporter_->quantileSlidingWindowsMap[key]);
+  }
+
+  void verifyDynamicQuantileRegistration(
+      const std::string& pattern,
+      const QuantileConfig& config) {
+    EXPECT_TRUE(reporter_->dynamicQuantileStatTypesMap.count(pattern));
+    EXPECT_EQ(
+        config.statTypes, reporter_->dynamicQuantileStatTypesMap[pattern]);
+    EXPECT_EQ(
+        config.percentiles, reporter_->dynamicQuantilePercentilesMap[pattern]);
+    EXPECT_EQ(
+        config.slidingWindows,
+        reporter_->dynamicQuantileSlidingWindowsMap[pattern]);
+  }
+
+  template <typename KeyType>
+  void registerAndVerifyQuantile(
+      KeyType key,
+      const QuantileConfig& config = createStandardConfig()) {
+    reporter_->registerQuantileMetricExportType(
+        key, config.statTypes, config.percentiles, config.slidingWindows);
+    verifyQuantileRegistration(std::string(key), config);
+  }
+
+  template <typename KeyType>
+  void registerAndVerifyDynamicQuantile(
+      KeyType pattern,
+      const QuantileConfig& config = createStandardConfig()) {
+    reporter_->registerDynamicQuantileMetricExportType(
+        pattern, config.statTypes, config.percentiles, config.slidingWindows);
+    verifyDynamicQuantileRegistration(std::string(pattern), config);
+  }
 };
 
 TEST_F(StatsReporterTest, trivialReporter) {
@@ -193,7 +159,7 @@ class TestStatsReportMmapAllocator : public memory::MmapAllocator {
     return numMallocBytes_;
   }
 
-  memory::MachinePageCount numExternalMapped() const {
+  memory::MachinePageCount numExternalMapped() const override {
     return numExternalMapped_;
   }
 
@@ -443,69 +409,109 @@ TEST_F(PeriodicStatsReporterTest, basic) {
   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(kMetricMemoryAllocatorMappedBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryAllocatorAllocatedBytes.str()), 1);
-    ASSERT_EQ(
-        counterMap.count(kMetricMmapAllocatorDelegatedAllocatedBytes.str()), 1);
-    ASSERT_EQ(
-        counterMap.count(kMetricMmapAllocatorExternalMappedBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSpillMemoryBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricSpillPeakMemoryBytes.str()), 1);
-    ASSERT_EQ(counterMap.count(kMetricMemoryAllocatorTotalUsedBytes.str()), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricArbitratorFreeCapacityBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(
+            std::string(kMetricArbitratorFreeReservedCapacityBytes)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumTinyEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumLargeEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumEmptyEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumSharedEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumExclusiveEntries)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumPrefetchedEntries)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalTinyBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalLargeBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalTinyPaddingBytes)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalLargePaddingBytes)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheTotalPrefetchBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCachedEntries)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCachedRegions)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCachedBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricCacheMaxAgeSecs)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryAllocatorMappedBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryAllocatorAllocatedBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(
+            std::string(kMetricMmapAllocatorDelegatedAllocatedBytes)),
+        1);
+    ASSERT_EQ(
+        counterMap.count(
+            std::string(kMetricMemoryAllocatorExternalMappedBytes)),
+        1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSpillMemoryBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSpillPeakMemoryBytes)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryAllocatorTotalUsedBytes)), 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(kMetricSsdCacheMetaFileDeleteErrors.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(), 23);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumHits)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheHitBytes)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumNew)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumEvicts)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumSavableEvicts)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumEvictChecks)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumWaitExclusive)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumAllocClocks)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumAgedOutEntries)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheSumEvictScore)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadEntries)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadBytes)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWrittenEntries)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWrittenBytes)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheOpenSsdErrors)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheOpenCheckpointErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheOpenLogErrors)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheMetaFileDeleteErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheGrowFileErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWriteSsdErrors)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteNoSpaceErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWriteSsdDropped)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteExceedEntryLimit)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteCheckpointErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadSsdErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadCorruptions)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheReadCheckpointErrors)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCheckpointsRead)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheCheckpointsWritten)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheRegionsEvicted)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheAgedOutEntries)), 0);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheAgedOutRegions)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheRecoveredEntries)), 0);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheReadWithoutChecksum)), 0);
+    ASSERT_EQ(counterMap.size(), 24);
   }
 
   // Update stats
@@ -526,7 +532,9 @@ TEST_F(PeriodicStatsReporterTest, basic) {
   newSsdStats->deleteMetaFileErrors = 10;
   newSsdStats->growFileErrors = 10;
   newSsdStats->writeSsdErrors = 10;
+  newSsdStats->writeSsdNoSpaceErrors = 1;
   newSsdStats->writeSsdDropped = 10;
+  newSsdStats->writeSsdExceedEntryLimit = 10;
   newSsdStats->writeCheckpointErrors = 10;
   newSsdStats->readSsdErrors = 10;
   newSsdStats->readSsdCorruptions = 10;
@@ -545,8 +553,9 @@ TEST_F(PeriodicStatsReporterTest, basic) {
        .allocClocks = 10,
        .sumEvictScore = 10,
        .ssdStats = newSsdStats});
-  arbitrator.updateStats(memory::MemoryArbitrator::Stats(
-      10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10));
+  arbitrator.updateStats(
+      memory::MemoryArbitrator::Stats(
+          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
@@ -556,39 +565,56 @@ TEST_F(PeriodicStatsReporterTest, basic) {
   // 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(kMetricSsdCacheMetaFileDeleteErrors.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(), 55);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumHits)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheHitBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumNew)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricMemoryCacheNumEvicts)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumSavableEvicts)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumEvictChecks)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumWaitExclusive)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumAllocClocks)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheNumAgedOutEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricMemoryCacheSumEvictScore)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadEntries)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWrittenEntries)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWrittenBytes)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheOpenSsdErrors)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheOpenCheckpointErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheOpenLogErrors)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheMetaFileDeleteErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheGrowFileErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWriteSsdErrors)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteNoSpaceErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheWriteSsdDropped)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteExceedEntryLimit)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheWriteCheckpointErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadSsdErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheReadCorruptions)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheReadCheckpointErrors)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheCheckpointsRead)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheCheckpointsWritten)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheRegionsEvicted)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheAgedOutEntries)), 1);
+    ASSERT_EQ(counterMap.count(std::string(kMetricSsdCacheAgedOutRegions)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheRecoveredEntries)), 1);
+    ASSERT_EQ(
+        counterMap.count(std::string(kMetricSsdCacheReadWithoutChecksum)), 1);
+    ASSERT_EQ(counterMap.size(), 58);
   }
 }
 
@@ -612,12 +638,332 @@ TEST_F(PeriodicStatsReporterTest, allNullOption) {
   ASSERT_NO_THROW(stopPeriodicStatsReporter());
 }
 
+TEST_F(StatsReporterTest, registerQuantileMetricExportType) {
+  QuantileConfig config = {
+      {StatType::AVG, StatType::SUM, StatType::COUNT},
+      {0.5, 0.95, 0.99},
+      {60, 600}};
+  registerAndVerifyQuantile("test_quantile_stat", config);
+}
+
+TEST_F(StatsReporterTest, quantileRegistrationWithValues) {
+  // Test registration and value addition (covers all key types via templates)
+  const char* charKey = "test_quantile_char";
+  std::string stringKey = "test_quantile_string";
+  folly::StringPiece spKey("test_quantile_sp");
+
+  QuantileConfig config1 = {
+      {StatType::AVG, StatType::COUNT}, {0.5, 0.95}, {60, 600}};
+  QuantileConfig config2 = {
+      {StatType::SUM, StatType::COUNT}, {0.75, 0.99}, {300}};
+  QuantileConfig config3 = {{StatType::RATE}, {0.75, 0.90}, {3600}};
+
+  registerAndVerifyQuantile(charKey, config1);
+  registerAndVerifyQuantile(stringKey, config2);
+  registerAndVerifyQuantile(spKey, config3);
+
+  // Test value addition
+  reporter_->addQuantileMetricValue(charKey, 100);
+  reporter_->addQuantileMetricValue(charKey, 50);
+  EXPECT_EQ(150, reporter_->counterMap[std::string(charKey)]);
+
+  reporter_->addQuantileMetricValue(stringKey, 200);
+  reporter_->addQuantileMetricValue(stringKey, 300);
+  EXPECT_EQ(500, reporter_->counterMap[stringKey]);
+
+  reporter_->addQuantileMetricValue(spKey, 25);
+  reporter_->addQuantileMetricValue(spKey, 75);
+  EXPECT_EQ(100, reporter_->counterMap[std::string(spKey)]);
+}
+
+TEST_F(StatsReporterTest, multipleQuantileStats) {
+  QuantileConfig config1 = {{StatType::AVG}, {0.5}, {60}};
+  QuantileConfig config2 = {
+      {StatType::COUNT, StatType::SUM}, {0.95, 0.99, 0.999}, {300, 900}};
+
+  registerAndVerifyQuantile("metric1", config1);
+  registerAndVerifyQuantile("metric2", config2);
+}
+
+TEST_F(StatsReporterTest, emptyVectors) {
+  // Test registration with empty vectors (should be allowed)
+  std::vector<StatType> emptyStatTypes;
+  std::vector<double> emptyPercentiles;
+  std::vector<size_t> emptySlidingWindows;
+
+  EXPECT_NO_THROW(reporter_->registerQuantileMetricExportType(
+      "empty_metric", emptyStatTypes, emptyPercentiles, emptySlidingWindows));
+
+  EXPECT_TRUE(reporter_->quantileStatTypesMap.count("empty_metric"));
+  EXPECT_TRUE(reporter_->quantileStatTypesMap["empty_metric"].empty());
+  EXPECT_TRUE(reporter_->quantilePercentilesMap["empty_metric"].empty());
+  EXPECT_TRUE(reporter_->quantileSlidingWindowsMap["empty_metric"].empty());
+}
+
+TEST_F(StatsReporterTest, quantileStatMacros) {
+  DEFINE_QUANTILE_STAT(
+      "macro_test_stat",
+      statTypes(StatType::AVG, StatType::COUNT),
+      percentiles(0.5, 0.95, 0.99),
+      slidingWindowsSeconds(60, 600));
+
+  QuantileConfig expectedConfig = {
+      {StatType::AVG, StatType::COUNT}, {0.5, 0.95, 0.99}, {60, 600}};
+  verifyQuantileRegistration("macro_test_stat", expectedConfig);
+
+  RECORD_QUANTILE_STAT_VALUE("macro_test_stat", 100);
+  RECORD_QUANTILE_STAT_VALUE("macro_test_stat", 50);
+  RECORD_QUANTILE_STAT_VALUE("macro_test_stat"); // Default value of 1
+
+  EXPECT_EQ(151, reporter_->counterMap["macro_test_stat"]);
+}
+
+TEST_F(StatsReporterTest, dynamicQuantileRegistrationWithValues) {
+  // Test registration and value addition for different key types
+  const char* charPattern = "test_metric_char.{}.{}";
+  std::string stringPattern = "test_metric_string.{}.{}";
+  folly::StringPiece spPattern("test_metric_sp.{}.{}");
+
+  QuantileConfig config1 = {{StatType::AVG}, {0.95}, {300}};
+  QuantileConfig config2 = {{StatType::COUNT}, {0.5}, {60}};
+  QuantileConfig config3 = {{StatType::SUM}, {0.5, 0.99}, {60, 600}};
+
+  registerAndVerifyDynamicQuantile(charPattern, config1);
+  registerAndVerifyDynamicQuantile(stringPattern, config2);
+  registerAndVerifyDynamicQuantile(spPattern, config3);
+
+  auto subkeys1 = subkeys("db1", "table1");
+  auto subkeys2 = subkeys("server1", "endpoint1");
+  auto subkeys3 = subkeys("region1", "service1");
+
+  reporter_->addDynamicQuantileMetricValue(charPattern, subkeys1, 50);
+  reporter_->addDynamicQuantileMetricValue(charPattern, subkeys1, 150);
+  EXPECT_EQ(200, reporter_->counterMap["test_metric_char.db1.table1"]);
+
+  reporter_->addDynamicQuantileMetricValue(stringPattern, subkeys2, 100);
+  reporter_->addDynamicQuantileMetricValue(stringPattern, subkeys2, 200);
+  EXPECT_EQ(300, reporter_->counterMap["test_metric_string.server1.endpoint1"]);
+
+  reporter_->addDynamicQuantileMetricValue(spPattern, subkeys3, 75);
+  reporter_->addDynamicQuantileMetricValue(spPattern, subkeys3, 125);
+  EXPECT_EQ(200, reporter_->counterMap["test_metric_sp.region1.service1"]);
+}
+
+TEST_F(StatsReporterTest, dynamicQuantileRegistrationOnly) {
+  // Test registration without values (registration-only test)
+  QuantileConfig config = {
+      {StatType::AVG, StatType::COUNT}, {0.5, 0.95}, {60, 600}};
+  const char* pattern = "registration_test.{}.{}";
+
+  registerAndVerifyDynamicQuantile(pattern, config);
+
+  // Verify registration worked but no values recorded yet
+  EXPECT_EQ(0, reporter_->counterMap.count("registration_test.key1.key2"));
+}
+
+TEST_F(StatsReporterTest, dynamicQuantileMetricUnregisteredPattern) {
+  // Try to add a value for a dynamic quantile metric that was never registered
+  // This should silently ignore the value (not crash)
+  auto subkeyValues = subkeys("unregistered", "pattern");
+  EXPECT_NO_THROW(reporter_->addDynamicQuantileMetricValue(
+      "unregistered_pattern.{}.{}", subkeyValues, 42));
+
+  // Verify no value was recorded
+  EXPECT_EQ(
+      0,
+      reporter_->counterMap.count("unregistered_pattern.unregistered.pattern"));
+}
+
+struct DynamicQuantilePatternTestCase {
+  std::string testName;
+  std::function<void(StatsReporterTest*)> testFunc;
+};
+
+class DynamicQuantilePatternTest
+    : public StatsReporterTest,
+      public testing::WithParamInterface<DynamicQuantilePatternTestCase> {};
+
+TEST_P(DynamicQuantilePatternTest, PatternScenarios) {
+  const auto& testCase = GetParam();
+  testCase.testFunc(this);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    PatternScenarios,
+    DynamicQuantilePatternTest,
+    testing::Values(
+        DynamicQuantilePatternTestCase{
+            "DefaultValue",
+            [](StatsReporterTest* test) {
+              test->reporter_->registerDynamicQuantileMetricExportType(
+                  "default_value_metric.{}",
+                  statTypes(StatType::COUNT),
+                  percentiles(0.5),
+                  slidingWindowsSeconds(60));
+
+              auto subkeyValues = subkeys("test");
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "default_value_metric.{}", subkeyValues, 1);
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "default_value_metric.{}", subkeyValues, 1);
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "default_value_metric.{}", subkeyValues, 1);
+
+              EXPECT_EQ(
+                  3, test->reporter_->counterMap["default_value_metric.test"]);
+            }},
+        DynamicQuantilePatternTestCase{
+            "MultiplePatterns",
+            [](StatsReporterTest* test) {
+              test->reporter_->registerDynamicQuantileMetricExportType(
+                  "pattern1.{}.{}",
+                  statTypes(StatType::AVG),
+                  percentiles(0.5),
+                  slidingWindowsSeconds(60));
+
+              test->reporter_->registerDynamicQuantileMetricExportType(
+                  "pattern2.{}.{}.{}",
+                  statTypes(StatType::COUNT, StatType::SUM),
+                  percentiles(0.95, 0.99, 0.999),
+                  slidingWindowsSeconds(300, 900));
+
+              auto subkeys2 = subkeys("key1", "key2");
+              auto subkeys3 = subkeys("key1", "key2", "key3");
+
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "pattern1.{}.{}", subkeys2, 100);
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "pattern2.{}.{}.{}", subkeys3, 200);
+
+              EXPECT_EQ(100, test->reporter_->counterMap["pattern1.key1.key2"]);
+              EXPECT_EQ(
+                  200, test->reporter_->counterMap["pattern2.key1.key2.key3"]);
+            }},
+        DynamicQuantilePatternTestCase{
+            "ComplexPattern",
+            [](StatsReporterTest* test) {
+              test->reporter_->registerDynamicQuantileMetricExportType(
+                  "complex.{}.latency.{}.p95",
+                  statTypes(StatType::AVG, StatType::COUNT),
+                  percentiles(0.95, 0.99),
+                  slidingWindowsSeconds(60, 300, 3600));
+
+              auto subkeyValues = subkeys("http_server", "endpoint_api");
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "complex.{}.latency.{}.p95", subkeyValues, 150);
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "complex.{}.latency.{}.p95", subkeyValues, 200);
+
+              EXPECT_EQ(
+                  350,
+                  test->reporter_->counterMap
+                      ["complex.http_server.latency.endpoint_api.p95"]);
+            }},
+        DynamicQuantilePatternTestCase{
+            "SingleSubkey",
+            [](StatsReporterTest* test) {
+              test->reporter_->registerDynamicQuantileMetricExportType(
+                  "single_sub.{}",
+                  statTypes(StatType::RATE),
+                  percentiles(0.75),
+                  slidingWindowsSeconds(600));
+
+              auto subkeyValues = subkeys("single_value");
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "single_sub.{}", subkeyValues, 300);
+
+              EXPECT_EQ(
+                  300, test->reporter_->counterMap["single_sub.single_value"]);
+            }},
+        DynamicQuantilePatternTestCase{
+            "MultipleInstances",
+            [](StatsReporterTest* test) {
+              test->reporter_->registerDynamicQuantileMetricExportType(
+                  "instance_test.{}.{}",
+                  statTypes(StatType::SUM),
+                  percentiles(0.5),
+                  slidingWindowsSeconds(60));
+
+              auto subkeys1 = subkeys("instance1", "metric1");
+              auto subkeys2 = subkeys("instance2", "metric2");
+              auto subkeys3 = subkeys("instance1", "metric2");
+
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "instance_test.{}.{}", subkeys1, 100);
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "instance_test.{}.{}", subkeys2, 200);
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "instance_test.{}.{}", subkeys3, 300);
+              test->reporter_->addDynamicQuantileMetricValue(
+                  "instance_test.{}.{}", subkeys1, 50);
+
+              EXPECT_EQ(
+                  150,
+                  test->reporter_
+                      ->counterMap["instance_test.instance1.metric1"]);
+              EXPECT_EQ(
+                  200,
+                  test->reporter_
+                      ->counterMap["instance_test.instance2.metric2"]);
+              EXPECT_EQ(
+                  300,
+                  test->reporter_
+                      ->counterMap["instance_test.instance1.metric2"]);
+            }}));
+
+TEST_F(StatsReporterTest, dynamicQuantileMetricEmptyVectors) {
+  // Test registration with empty vectors (should be allowed)
+  std::vector<StatType> emptyStatTypes;
+  std::vector<double> emptyPercentiles;
+  std::vector<size_t> emptySlidingWindows;
+
+  EXPECT_NO_THROW(reporter_->registerDynamicQuantileMetricExportType(
+      "empty_metric.{}",
+      emptyStatTypes,
+      emptyPercentiles,
+      emptySlidingWindows));
+
+  EXPECT_TRUE(reporter_->dynamicQuantileStatTypesMap.count("empty_metric.{}"));
+  EXPECT_TRUE(
+      reporter_->dynamicQuantileStatTypesMap["empty_metric.{}"].empty());
+  EXPECT_TRUE(
+      reporter_->dynamicQuantilePercentilesMap["empty_metric.{}"].empty());
+  EXPECT_TRUE(
+      reporter_->dynamicQuantileSlidingWindowsMap["empty_metric.{}"].empty());
+
+  // Try to use the empty pattern
+  auto subkeyValues = subkeys("test");
+  EXPECT_NO_THROW(reporter_->addDynamicQuantileMetricValue(
+      "empty_metric.{}", subkeyValues, 100));
+}
+
+TEST_F(StatsReporterTest, dynamicQuantileStatMacros) {
+  DEFINE_DYNAMIC_QUANTILE_STAT(
+      "macro_test.{}.{}",
+      statTypes(StatType::AVG, StatType::COUNT),
+      percentiles(0.5, 0.95, 0.99),
+      slidingWindowsSeconds(60, 600));
+
+  QuantileConfig expectedConfig = {
+      {StatType::AVG, StatType::COUNT}, {0.5, 0.95, 0.99}, {60, 600}};
+  verifyDynamicQuantileRegistration("macro_test.{}.{}", expectedConfig);
+
+  RECORD_DYNAMIC_QUANTILE_STAT_VALUE(
+      "macro_test.{}.{}", subkeys("service", "method"), 100);
+  RECORD_DYNAMIC_QUANTILE_STAT_VALUE(
+      "macro_test.{}.{}", subkeys("service", "method"), 50);
+  RECORD_DYNAMIC_QUANTILE_STAT_VALUE(
+      "macro_test.{}.{}", subkeys("service", "method")); // Default value of 1
+
+  EXPECT_EQ(151, reporter_->counterMap["macro_test.service.method"]);
+}
+
 // Registering to folly Singleton with intended reporter type
 folly::Singleton<BaseStatsReporter> reporter([]() {
   return new TestReporter();
 });
 
-} // namespace facebook::velox
+} // namespace facebook::velox::test
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
diff --git a/velox/common/base/tests/StatsReporterUtils.h b/velox/common/base/tests/StatsReporterUtils.h
new file mode 100644
index 000000000000..f58111c3e29a
--- /dev/null
+++ b/velox/common/base/tests/StatsReporterUtils.h
@@ -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.
+ */
+
+#pragma once
+
+#include <fmt/args.h>
+#include <cstdint>
+#include <map>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "velox/common/base/StatsReporter.h"
+
+namespace facebook::velox::test {
+
+/// A test implementation of BaseStatsReporter for use in unit tests.
+/// This class provides a mock implementation that captures all metric
+/// registrations and values for verification in tests.
+class TestReporter : public BaseStatsReporter {
+ public:
+  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;
+
+  mutable std::unordered_map<std::string, std::vector<StatType>>
+      quantileStatTypesMap;
+  mutable std::unordered_map<std::string, std::vector<double>>
+      quantilePercentilesMap;
+  mutable std::unordered_map<std::string, std::vector<size_t>>
+      quantileSlidingWindowsMap;
+
+  mutable std::unordered_map<std::string, std::vector<StatType>>
+      dynamicQuantileStatTypesMap;
+  mutable std::unordered_map<std::string, std::vector<double>>
+      dynamicQuantilePercentilesMap;
+  mutable std::unordered_map<std::string, std::vector<size_t>>
+      dynamicQuantileSlidingWindowsMap;
+
+  void clear() {
+    std::lock_guard<std::mutex> l(m);
+    counterMap.clear();
+    statTypeMap.clear();
+    histogramPercentilesMap.clear();
+    quantileStatTypesMap.clear();
+    quantilePercentilesMap.clear();
+    quantileSlidingWindowsMap.clear();
+    dynamicQuantileStatTypesMap.clear();
+    dynamicQuantilePercentilesMap.clear();
+    dynamicQuantileSlidingWindowsMap.clear();
+  }
+
+  void registerMetricExportType(const char* key, StatType statType)
+      const override {
+    statTypeMap[key] = statType;
+  }
+
+  void registerMetricExportType(folly::StringPiece key, StatType statType)
+      const override {
+    statTypeMap[std::string(key)] = statType;
+  }
+
+  void registerHistogramMetricExportType(
+      const char* key,
+      int64_t /* bucketWidth */,
+      int64_t /* min */,
+      int64_t /* max */,
+      const std::vector<int32_t>& pcts) const override {
+    histogramPercentilesMap[key] = pcts;
+  }
+
+  void registerHistogramMetricExportType(
+      folly::StringPiece key,
+      int64_t /* bucketWidth */,
+      int64_t /* min */,
+      int64_t /* max */,
+      const std::vector<int32_t>& pcts) const override {
+    histogramPercentilesMap[std::string(key)] = pcts;
+  }
+
+  void registerQuantileMetricExportType(
+      const char* key,
+      const std::vector<StatType>& statTypes,
+      const std::vector<double>& pcts,
+      const std::vector<size_t>& slidingWindowsSeconds) const override {
+    std::lock_guard<std::mutex> l(m);
+    quantileStatTypesMap[key] = statTypes;
+    quantilePercentilesMap[key] = pcts;
+    quantileSlidingWindowsMap[key] = slidingWindowsSeconds;
+  }
+
+  void registerQuantileMetricExportType(
+      folly::StringPiece key,
+      const std::vector<StatType>& statTypes,
+      const std::vector<double>& pcts,
+      const std::vector<size_t>& slidingWindowsSeconds) const override {
+    std::lock_guard<std::mutex> l(m);
+    quantileStatTypesMap[std::string(key)] = statTypes;
+    quantilePercentilesMap[std::string(key)] = pcts;
+    quantileSlidingWindowsMap[std::string(key)] = slidingWindowsSeconds;
+  }
+
+  void addMetricValue(const std::string& key, const size_t value)
+      const override {
+    std::lock_guard<std::mutex> l(m);
+    counterMap[key] += value;
+  }
+
+  void addMetricValue(const char* key, const size_t value) const override {
+    std::lock_guard<std::mutex> l(m);
+    counterMap[key] += value;
+  }
+
+  void addMetricValue(folly::StringPiece key, size_t value) const override {
+    std::lock_guard<std::mutex> l(m);
+    counterMap[std::string(key)] += value;
+  }
+
+  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 addHistogramMetricValue(const char* key, size_t value) const override {
+    std::lock_guard<std::mutex> l(m);
+    counterMap[key] = std::max(counterMap[key], value);
+  }
+
+  void addHistogramMetricValue(folly::StringPiece key, size_t value)
+      const override {
+    std::lock_guard<std::mutex> l(m);
+    counterMap[std::string(key)] =
+        std::max(counterMap[std::string(key)], value);
+  }
+
+  void addQuantileMetricValue(const std::string& key, size_t value)
+      const override {
+    std::lock_guard<std::mutex> l(m);
+    counterMap[key] += value;
+  }
+
+  void addQuantileMetricValue(const char* key, size_t value) const override {
+    std::lock_guard<std::mutex> l(m);
+    counterMap[key] += value;
+  }
+
+  void addQuantileMetricValue(folly::StringPiece key, size_t value)
+      const override {
+    std::lock_guard<std::mutex> l(m);
+    counterMap[std::string(key)] += value;
+  }
+
+  void registerDynamicQuantileMetricExportType(
+      const char* keyPattern,
+      const std::vector<StatType>& statTypes,
+      const std::vector<double>& pcts,
+      const std::vector<size_t>& slidingWindowsSeconds) const override {
+    std::lock_guard<std::mutex> l(m);
+    dynamicQuantileStatTypesMap[keyPattern] = statTypes;
+    dynamicQuantilePercentilesMap[keyPattern] = pcts;
+    dynamicQuantileSlidingWindowsMap[keyPattern] = slidingWindowsSeconds;
+  }
+
+  void registerDynamicQuantileMetricExportType(
+      folly::StringPiece keyPattern,
+      const std::vector<StatType>& statTypes,
+      const std::vector<double>& pcts,
+      const std::vector<size_t>& slidingWindowsSeconds) const override {
+    std::lock_guard<std::mutex> l(m);
+    dynamicQuantileStatTypesMap[std::string(keyPattern)] = statTypes;
+    dynamicQuantilePercentilesMap[std::string(keyPattern)] = pcts;
+    dynamicQuantileSlidingWindowsMap[std::string(keyPattern)] =
+        slidingWindowsSeconds;
+  }
+
+  void addDynamicQuantileMetricValue(
+      const std::string& key,
+      folly::Range<const folly::StringPiece*> subkeys,
+      size_t value) const override {
+    std::lock_guard<std::mutex> l(m);
+    // Check if the pattern was registered, if not silently ignore
+    if (dynamicQuantileStatTypesMap.find(key) ==
+        dynamicQuantileStatTypesMap.end()) {
+      return;
+    }
+
+    // Substitute placeholders in the key pattern with subkeys using fmt::format
+    std::string formattedKey;
+    fmt::dynamic_format_arg_store<fmt::format_context> store;
+    for (const auto& subkey : subkeys) {
+      store.push_back(subkey);
+    }
+    formattedKey = fmt::vformat(key, store);
+    counterMap[formattedKey] += value;
+  }
+
+  void addDynamicQuantileMetricValue(
+      const char* key,
+      folly::Range<const folly::StringPiece*> subkeys,
+      size_t value) const override {
+    addDynamicQuantileMetricValue(std::string(key), subkeys, value);
+  }
+
+  void addDynamicQuantileMetricValue(
+      folly::StringPiece key,
+      folly::Range<const folly::StringPiece*> subkeys,
+      size_t value) const override {
+    addDynamicQuantileMetricValue(std::string(key), subkeys, 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();
+  }
+
+  // Get the current counter value for a specific key.
+  // Returns 0 if the key doesn't exist.
+  size_t getCounterValue(const std::string& key) const {
+    std::lock_guard<std::mutex> l(m);
+    auto it = counterMap.find(key);
+    return it != counterMap.end() ? it->second : 0;
+  }
+};
+
+} // namespace facebook::velox::test
diff --git a/velox/common/base/tests/StatusTest.cpp b/velox/common/base/tests/StatusTest.cpp
index d5caa276a606..1501c18dd303 100644
--- a/velox/common/base/tests/StatusTest.cpp
+++ b/velox/common/base/tests/StatusTest.cpp
@@ -118,6 +118,36 @@ Status returnNotOk(Status s) {
   return Status::Invalid("invalid");
 }
 
+#define STATUS_MACRO_TEST(name, macro) \
+  Status returnMacro##name() {         \
+    macro;                             \
+    return Status::OK();               \
+  }
+
+STATUS_MACRO_TEST(EmptyMessage, VELOX_USER_RETURN_GT(2, 1));
+STATUS_MACRO_TEST(Format, VELOX_USER_RETURN_GT(2, 1, "Occurred {} times.", 5));
+STATUS_MACRO_TEST(GT, VELOX_USER_RETURN_GT(2, 1, "User error occurred."));
+STATUS_MACRO_TEST(GE, VELOX_USER_RETURN_GE(2, 1, "User error occurred."));
+STATUS_MACRO_TEST(LT, VELOX_USER_RETURN_LT(1, 2, "User error occurred."));
+STATUS_MACRO_TEST(LE, VELOX_USER_RETURN_LE(1, 2, "User error occurred."));
+STATUS_MACRO_TEST(EQ, VELOX_USER_RETURN_EQ(1, 1, "User error occurred."));
+STATUS_MACRO_TEST(NE, VELOX_USER_RETURN_NE(1, 3, "User error occurred."));
+STATUS_MACRO_TEST(
+    NULL,
+    VELOX_USER_RETURN_NULL(nullptr, "User error occurred."));
+
+Status returnNotNull(Status* status) {
+  VELOX_USER_RETURN_NOT_NULL(status, "User error occurred.");
+  return Status::OK();
+}
+
+Status returnMacroCheck() {
+  Status status = Status::OK();
+  VELOX_USER_RETURN(
+      status.code() != StatusCode::kCancelled, "User error occurred.");
+  return Status::OK();
+}
+
 TEST(StatusTest, statusMacros) {
   ASSERT_EQ(returnIf(true), Status::Invalid("error"));
   ASSERT_EQ(returnIf(false), Status::OK());
@@ -134,6 +164,67 @@ TEST(StatusTest, statusMacros) {
     didThrow = true;
   }
   ASSERT_TRUE(didThrow) << "VELOX_CHECK_OK did not throw";
+
+  ASSERT_EQ(
+      returnMacroCheck(),
+      Status::UserError(
+          "Reason: User error occurred.\nExpression: status.code() != StatusCode::kCancelled\n"));
+  ASSERT_EQ(
+      returnMacroEmptyMessage(),
+      Status::UserError("Reason: (2 vs. 1)\nExpression: 2 > 1\n"));
+  ASSERT_EQ(
+      returnMacroFormat(),
+      Status::UserError(
+          "Reason: (2 vs. 1) Occurred 5 times.\nExpression: 2 > 1\n"));
+  ASSERT_EQ(
+      returnMacroGT(),
+      Status::UserError(
+          "Reason: (2 vs. 1) User error occurred.\nExpression: 2 > 1\n"));
+  ASSERT_EQ(
+      returnMacroGE(),
+      Status::UserError(
+          "Reason: (2 vs. 1) User error occurred.\nExpression: 2 >= 1\n"));
+  ASSERT_EQ(
+      returnMacroLT(),
+      Status::UserError(
+          "Reason: (1 vs. 2) User error occurred.\nExpression: 1 < 2\n"));
+  ASSERT_EQ(
+      returnMacroLE(),
+      Status::UserError(
+          "Reason: (1 vs. 2) User error occurred.\nExpression: 1 <= 2\n"));
+  ASSERT_EQ(
+      returnMacroEQ(),
+      Status::UserError(
+          "Reason: (1 vs. 1) User error occurred.\nExpression: 1 == 1\n"));
+  ASSERT_EQ(
+      returnMacroNE(),
+      Status::UserError(
+          "Reason: (1 vs. 3) User error occurred.\nExpression: 1 != 3\n"));
+  ASSERT_EQ(
+      returnMacroNULL(),
+      Status::UserError(
+          "Reason: User error occurred.\nExpression: nullptr == nullptr\n"));
+  Status status = Status::OK();
+  ASSERT_EQ(
+      returnNotNull(&status),
+      Status::UserError(
+          "Reason: User error occurred.\nExpression: status != nullptr\n"));
+}
+
+TEST(StatusTest, statusMacrosSkipDetails) {
+  ScopedThreadSkipErrorDetails skipErrorDetails(true);
+  ASSERT_EQ(returnMacroCheck(), Status::UserError());
+  ASSERT_EQ(returnMacroEmptyMessage(), Status::UserError());
+  ASSERT_EQ(returnMacroFormat(), Status::UserError());
+  ASSERT_EQ(returnMacroGT(), Status::UserError());
+  ASSERT_EQ(returnMacroGE(), Status::UserError());
+  ASSERT_EQ(returnMacroLT(), Status::UserError());
+  ASSERT_EQ(returnMacroLE(), Status::UserError());
+  ASSERT_EQ(returnMacroEQ(), Status::UserError());
+  ASSERT_EQ(returnMacroNE(), Status::UserError());
+  ASSERT_EQ(returnMacroNULL(), Status::UserError());
+  Status status = Status::OK();
+  ASSERT_EQ(returnNotNull(&status), Status::UserError());
 }
 
 Expected<int> modulo(int a, int b) {
diff --git a/velox/common/caching/AsyncDataCache.cpp b/velox/common/caching/AsyncDataCache.cpp
index 717107416d51..b54b4fa6979f 100644
--- a/velox/common/caching/AsyncDataCache.cpp
+++ b/velox/common/caching/AsyncDataCache.cpp
@@ -23,7 +23,6 @@
 #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(                                                     \
@@ -129,10 +128,11 @@ void AsyncDataCacheEntry::initialize(FileCacheKey key) {
     } else {
       // No memory to cover 'this'.
       release();
-      VELOX_CACHE_ERROR(fmt::format(
-          "Failed to allocate {} pages for cache: {}",
-          sizePages,
-          cache->allocator()->getAndClearFailureMessage()));
+      VELOX_CACHE_ERROR(
+          fmt::format(
+              "Failed to allocate {} pages for cache: {}",
+              sizePages,
+              cache->allocator()->getAndClearFailureMessage()));
     }
   }
 }
@@ -151,7 +151,7 @@ std::string AsyncDataCacheEntry::toString() const {
       numPins_);
 }
 
-std::unique_ptr<AsyncDataCacheEntry> CacheShard::getFreeEntry() {
+std::unique_ptr<AsyncDataCacheEntry> CacheShard::getFreeEntryLocked() {
   std::unique_ptr<AsyncDataCacheEntry> newEntry;
   if (freeEntries_.empty()) {
     newEntry = std::make_unique<AsyncDataCacheEntry>(this);
@@ -176,7 +176,7 @@ CachePin CacheShard::findOrCreate(
       if (foundEntry->isExclusive()) {
         ++numWaitExclusive_;
         if (wait != nullptr) {
-          *wait = foundEntry->getFuture();
+          *wait = foundEntry->getFutureLocked();
         }
         return CachePin();
       }
@@ -212,7 +212,7 @@ CachePin CacheShard::findOrCreate(
       entryMap_.erase(it);
     }
 
-    auto newEntry = getFreeEntry();
+    auto newEntry = getFreeEntryLocked();
     // Initialize the members that must be set inside 'mutex_'.
     newEntry->numPins_ = AsyncDataCacheEntry::kExclusive;
     newEntry->promise_ = nullptr;
@@ -336,7 +336,7 @@ std::unique_ptr<folly::SharedPromise<bool>> CacheShard::removeEntry(
   removeEntryLocked(entry);
   // After the entry is removed from the hash table, a promise can no longer
   // be made. It is safe to move the promise and realize it.
-  return entry->movePromise();
+  return entry->movePromiseLocked();
 }
 
 void CacheShard::removeEntryLocked(AsyncDataCacheEntry* entry) {
@@ -409,7 +409,7 @@ uint64_t CacheShard::evict(
           eventCounter_ > entries_.size() / 4 ||
           numChecked > entries_.size() / 8) {
         now = accessTime();
-        calibrateThreshold();
+        calibrateThresholdLocked();
         numChecked = 0;
         eventCounter_ = 0;
       }
@@ -490,8 +490,8 @@ void CacheShard::freeAllocations(std::vector<memory::Allocation>& allocations) {
   allocations.clear();
 }
 
-void CacheShard::calibrateThreshold() {
-  auto numSamples = std::min<int32_t>(10, entries_.size());
+void CacheShard::calibrateThresholdLocked() {
+  auto numSamples = std::min<int32_t>(kMaxEvictionSamples, entries_.size());
   auto now = accessTime();
   auto entryIndex = (clockHand_ % entries_.size());
   auto step = entries_.size() / numSamples;
@@ -510,22 +510,32 @@ void CacheShard::calibrateThreshold() {
         return score;
       },
       numSamples,
-      80);
+      kEvictionPercentile);
 }
 
 void CacheShard::updateStats(CacheStats& stats) {
   std::lock_guard<std::mutex> l(mutex_);
   for (auto& entry : entries_) {
-    if (!entry || !entry->key_.fileNum.hasValue()) {
+    if (!entry) {
       ++stats.numEmptyEntries;
       continue;
     }
 
     if (entry->isExclusive()) {
-      stats.exclusivePinnedBytes +=
-          entry->data().byteSize() + entry->tinyData_.capacity();
+      // We cannot read data() or tinyData_ which are being allocated during
+      // initialize(). Use size_ as an approximation of the pinned bytes.
+      stats.exclusivePinnedBytes += entry->size_;
       ++stats.numExclusive;
-    } else if (entry->isShared()) {
+      // Skip rest of the field accesses while entry is being initialized.
+      continue;
+    }
+
+    if (!entry->key_.fileNum.hasValue()) {
+      ++stats.numEmptyEntries;
+      continue;
+    }
+
+    if (entry->isShared()) {
       stats.sharedPinnedBytes +=
           entry->data().byteSize() + entry->tinyData_.capacity();
       ++stats.numShared;
@@ -537,11 +547,15 @@ void CacheShard::updateStats(CacheStats& stats) {
     }
 
     ++stats.numEntries;
-    stats.tinySize += entry->tinyData_.size();
-    stats.tinyPadding += entry->tinyData_.capacity() - entry->tinyData_.size();
     if (entry->tinyData_.empty()) {
       stats.largeSize += entry->size_;
       stats.largePadding += entry->data_.byteSize() - entry->size_;
+      ++stats.numLargeEntries;
+    } else {
+      stats.tinySize += entry->tinyData_.size();
+      stats.tinyPadding +=
+          entry->tinyData_.capacity() - entry->tinyData_.size();
+      ++stats.numTinyEntries;
     }
   }
   stats.numHit += numHit_;
@@ -658,7 +672,7 @@ CacheStats CacheStats::operator-(const CacheStats& other) const {
 AsyncDataCache::AsyncDataCache(
     memory::MemoryAllocator* allocator,
     std::unique_ptr<SsdCache> ssdCache)
-    : AsyncDataCache({}, allocator, std::move(ssdCache)){};
+    : AsyncDataCache({}, allocator, std::move(ssdCache)) {}
 
 AsyncDataCache::AsyncDataCache(
     const Options& options,
@@ -835,7 +849,6 @@ uint64_t AsyncDataCache::shrink(uint64_t targetBytes) {
   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};
   {
@@ -843,7 +856,8 @@ uint64_t AsyncDataCache::shrink(uint64_t targetBytes) {
     for (int shard = 0; shard < shards_.size(); ++shard) {
       memory::Allocation unused;
       evictedBytes += shards_[shardCounter_++ & (kShardMask)]->evict(
-          std::max<uint64_t>(minBytesToEvict, targetBytes - evictedBytes),
+          std::max<uint64_t>(
+              CacheShard::kMinBytesToEvict, 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.
@@ -875,7 +889,7 @@ bool AsyncDataCache::canTryAllocate(
     return true;
   }
   return numPages - acquired.numPages() <=
-      (memory::AllocationTraits::numPages(allocator_->capacity())) -
+      memory::AllocationTraits::numPages(allocator_->capacity()) -
       allocator_->numAllocated();
 }
 
@@ -1064,8 +1078,9 @@ CoalesceIoStats readPins(
       [&](int32_t size, std::vector<folly::Range<char*>>& ranges) {
         // This hack allows us to store the size of the gap in the Range,
         // without actually allocating a buffer for it.
-        ranges.push_back(folly::Range<char*>(
-            nullptr, reinterpret_cast<char*>(static_cast<uint64_t>(size))));
+        ranges.push_back(
+            folly::Range<char*>(
+                nullptr, reinterpret_cast<char*>(static_cast<uint64_t>(size))));
       },
       std::move(readFunc));
 }
diff --git a/velox/common/caching/AsyncDataCache.h b/velox/common/caching/AsyncDataCache.h
index 5f0bf7bf6088..0baf904deb03 100644
--- a/velox/common/caching/AsyncDataCache.h
+++ b/velox/common/caching/AsyncDataCache.h
@@ -263,22 +263,21 @@ 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'.
-  std::unique_ptr<folly::SharedPromise<bool>> movePromise() {
-    return std::move(promise_);
-  }
-
   std::string toString() const;
 
  private:
   void release();
   void addReference();
 
+  // Moves the promise out of 'this'. Must be called inside the mutex of
+  // 'shard_'.
+  std::unique_ptr<folly::SharedPromise<bool>> movePromiseLocked() {
+    return std::move(promise_);
+  }
+
   // Returns a future that will be realized when a caller can retry getting
   // 'this'. Must be called inside the mutex of 'shard_'.
-  folly::SemiFuture<bool> getFuture() {
+  folly::SemiFuture<bool> getFutureLocked() {
     if (promise_ == nullptr) {
       promise_ = std::make_unique<folly::SharedPromise<bool>>();
     }
@@ -308,7 +307,7 @@ class AsyncDataCacheEntry {
   // 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};
+  tsan_atomic<bool> isPrefetch_{false};
 
   // Sets after first use of a prefetched entry. Cleared by
   // getAndClearFirstUseFlag(). Does not require synchronization since used for
@@ -496,6 +495,10 @@ struct CacheStats {
   int64_t largePadding{0};
   /// Total number of entries.
   int32_t numEntries{0};
+  /// Total number of tiny entries.
+  int32_t numTinyEntries{0};
+  /// Total number of large entries.
+  int32_t numLargeEntries{0};
   /// Number of entries that do not cache anything.
   int32_t numEmptyEntries{0};
   /// Number of entries pinned for shared access.
@@ -556,6 +559,8 @@ struct CacheStats {
 /// and other housekeeping.
 class CacheShard {
  public:
+  static constexpr uint64_t kMinBytesToEvict = 8UL << 20; // 8MB
+
   CacheShard(AsyncDataCache* cache, double maxWriteRatio)
       : cache_(cache), maxWriteRatio_(maxWriteRatio) {}
 
@@ -629,8 +634,10 @@ class CacheShard {
  private:
   static constexpr uint32_t kMaxFreeEntries = 1 << 10;
   static constexpr int32_t kNoThreshold = std::numeric_limits<int32_t>::max();
+  static constexpr int32_t kMaxEvictionSamples = 10;
+  static constexpr int32_t kEvictionPercentile = 80;
 
-  void calibrateThreshold();
+  void calibrateThresholdLocked();
 
   void removeEntryLocked(AsyncDataCacheEntry* entry);
 
@@ -638,7 +645,7 @@ class CacheShard {
   //
   // TODO: consider to pass a size hint so as to select the a free entry which
   // already has the right amount of memory associated with it.
-  std::unique_ptr<AsyncDataCacheEntry> getFreeEntry();
+  std::unique_ptr<AsyncDataCacheEntry> getFreeEntryLocked();
 
   CachePin initEntry(RawFileCacheKey key, AsyncDataCacheEntry* entry);
 
@@ -703,7 +710,7 @@ class AsyncDataCache : public memory::Cache {
         int32_t _minSsdSavableBytes = 1 << 24)
         : maxWriteRatio(_maxWriteRatio),
           ssdSavableRatio(_ssdSavableRatio),
-          minSsdSavableBytes(_minSsdSavableBytes){};
+          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
@@ -794,8 +801,7 @@ class AsyncDataCache : public memory::Cache {
 #endif
   /// Returns snapshot of the aggregated stats from all shards and the stats of
   /// SSD cache if used.
-  virtual CacheStats
-  refreshStats() const;
+  virtual CacheStats refreshStats() const;
 
   /// If 'details' is true, returns the stats of the backing memory allocator
   /// and ssd cache. Otherwise, only returns the cache stats.
@@ -845,7 +851,7 @@ class AsyncDataCache : public memory::Cache {
       const std::vector<RawFileCacheKey>& keys,
       const SizeFunc& sizeFunc,
       const ProcessPin& processPin) {
-    for (auto i = 0; i < keys.size(); ++i) {
+    for (size_t i = 0; i < keys.size(); ++i) {
       auto pin = findOrCreate(keys[i], sizeFunc(i), nullptr);
       if (pin.empty() || pin.checkedEntry()->isShared()) {
         continue;
@@ -876,9 +882,12 @@ class AsyncDataCache : public memory::Cache {
   void clear();
 
  private:
-  static constexpr int32_t kNumShards = 4; // Must be power of 2.
+  // Must be power of 2.
+  static constexpr int32_t kNumShards = 4;
   static constexpr int32_t kShardMask = kNumShards - 1;
 
+  static_assert((kNumShards & kShardMask) == 0);
+
   // True if 'acquired' has more pages than 'numPages' or allocator has space
   // for numPages - acquired pages of more allocation.
   bool canTryAllocate(
diff --git a/velox/common/caching/CMakeLists.txt b/velox/common/caching/CMakeLists.txt
index 7e49a752868a..bc09b5552c86 100644
--- a/velox/common/caching/CMakeLists.txt
+++ b/velox/common/caching/CMakeLists.txt
@@ -21,18 +21,21 @@ velox_add_library(
   SsdCache.cpp
   SsdFile.cpp
   SsdFileTracker.cpp
-  StringIdMap.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
-  PRIVATE velox_time)
+  PUBLIC
+    velox_common_base
+    velox_exception
+    velox_file
+    velox_memory
+    velox_process
+    velox_time
+    Folly::folly
+    fmt::fmt
+  PRIVATE velox_time
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/common/caching/SsdCache.cpp b/velox/common/caching/SsdCache.cpp
index 2347b45982fd..50d32d6ba3ec 100644
--- a/velox/common/caching/SsdCache.cpp
+++ b/velox/common/caching/SsdCache.cpp
@@ -32,7 +32,8 @@ SsdCache::SsdCache(const Config& config)
     : filePrefix_(config.filePrefix),
       numShards_(config.numShards),
       groupStats_(std::make_unique<FileGroupStats>()),
-      executor_(config.executor) {
+      executor_(config.executor),
+      maxEntries_(config.maxEntries) {
   // 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(
@@ -58,6 +59,9 @@ SsdCache::SsdCache(const Config& config)
   const uint64_t sizeQuantum = numShards_ * SsdFile::kRegionSize;
   const int32_t fileMaxRegions =
       bits::roundUp(config.maxBytes, sizeQuantum) / sizeQuantum;
+  // Distribute maxEntries across shards
+  const uint64_t maxEntriesPerShard =
+      maxEntries_ == 0 ? 0 : bits::divRoundUp(maxEntries_, numShards_);
   for (auto i = 0; i < numShards_; ++i) {
     const auto fileConfig = SsdFile::Config(
         fmt::format("{}{}", filePrefix_, i),
@@ -67,6 +71,7 @@ SsdCache::SsdCache(const Config& config)
         config.disableFileCow,
         config.checksumEnabled,
         checksumReadVerificationEnabled,
+        maxEntriesPerShard,
         executor_);
     files_.push_back(std::make_unique<SsdFile>(fileConfig));
   }
@@ -90,7 +95,8 @@ bool SsdCache::startWrite() {
 }
 
 void SsdCache::write(std::vector<CachePin> pins) {
-  VELOX_CHECK_EQ(numShards_, writesInProgress_);
+  VELOX_CHECK_EQ(
+      numShards_, writesInProgress_, "startWrite() have not been called");
 
   TestValue::adjust("facebook::velox::cache::SsdCache::write", this);
 
@@ -98,7 +104,7 @@ void SsdCache::write(std::vector<CachePin> pins) {
 
   uint64_t bytes = 0;
   std::vector<std::vector<CachePin>> shards(numShards_);
-  for (auto& pin : pins) {
+  for (const auto& pin : pins) {
     bytes += pin.checkedEntry()->size();
     const auto& target = file(pin.checkedEntry()->key().fileNum.id());
     shards[target.shardId()].push_back(std::move(pin));
@@ -135,9 +141,10 @@ void SsdCache::write(std::vector<CachePin> pins) {
         // Typically occurs every few GB. Allows detecting unusually slow rates
         // from failing devices.
         VELOX_SSD_CACHE_LOG(INFO) << fmt::format(
-            "Wrote {}, {} bytes/s",
+            "Wrote {} to SSD, {} bytes/s",
             succinctBytes(bytes),
-            static_cast<float>(bytes) / (getCurrentTimeMicro() - startTimeUs));
+            static_cast<double>(bytes) * 1'000'000 /
+                (getCurrentTimeMicro() - startTimeUs));
       }
     });
   }
@@ -191,7 +198,11 @@ std::string SsdCache::toString() const {
   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 << " " << (data.entriesCached >> 10) << "K entries";
+  if (maxEntries_ > 0) {
+    out << " (max " << (maxEntries_ >> 10) << "K)";
+  }
+  out << ".";
   out << "\nGroupStats: " << groupStats_->toString(capacity);
   return out.str();
 }
@@ -207,7 +218,7 @@ void SsdCache::shutdown() {
 
   VELOX_SSD_CACHE_LOG(INFO) << "SSD cache is shutting down";
   while (writesInProgress_) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+    std::this_thread::sleep_for(kWriteWaitMs);
   }
   for (auto& file : files_) {
     file->checkpoint(true);
@@ -223,7 +234,7 @@ void SsdCache::clear() {
 
 void SsdCache::waitForWriteToFinish() {
   while (writesInProgress_ != 0) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
+    std::this_thread::sleep_for(kWriteWaitMs);
   }
 }
 
diff --git a/velox/common/caching/SsdCache.h b/velox/common/caching/SsdCache.h
index e46705949481..2ec837958c14 100644
--- a/velox/common/caching/SsdCache.h
+++ b/velox/common/caching/SsdCache.h
@@ -23,6 +23,8 @@ namespace facebook::velox::cache {
 #define VELOX_SSD_CACHE_LOG_PREFIX "[SSDCA] "
 #define VELOX_SSD_CACHE_LOG(severity) \
   LOG(severity) << VELOX_SSD_CACHE_LOG_PREFIX
+#define VELOX_SSD_CACHE_LOG_EVERY_MS(severity, ms) \
+  FB_LOG_EVERY_MS(severity, ms) << VELOX_SSD_CACHE_LOG_PREFIX
 
 namespace test {
 class SsdCacheTestHelper;
@@ -41,7 +43,8 @@ class SsdCache {
         uint64_t _checkpointIntervalBytes = 0,
         bool _disableFileCow = false,
         bool _checksumEnabled = false,
-        bool _checksumReadVerificationEnabled = false)
+        bool _checksumReadVerificationEnabled = false,
+        uint64_t _maxEntries = 0)
         : filePrefix(_filePrefix),
           maxBytes(_maxBytes),
           numShards(_numShards),
@@ -49,7 +52,8 @@ class SsdCache {
           disableFileCow(_disableFileCow),
           checksumEnabled(_checksumEnabled),
           checksumReadVerificationEnabled(_checksumReadVerificationEnabled),
-          executor(_executor){};
+          executor(_executor),
+          maxEntries(_maxEntries) {}
 
     std::string filePrefix;
     uint64_t maxBytes;
@@ -71,6 +75,10 @@ class SsdCache {
     /// Executor for async fsync in checkpoint.
     folly::Executor* executor;
 
+    /// Maximum number of SSD cache entries allowed. A value of 0 means no
+    /// limit. When the limit is reached, new entry writes will be skipped.
+    uint64_t maxEntries;
+
     std::string toString() const {
       return fmt::format(
           "{} shards, capacity {}, checkpoint size {}, file cow {}, checksum {}, read verification {}",
@@ -169,6 +177,9 @@ class SsdCache {
   void waitForWriteToFinish();
 
  private:
+  // Polling interval for waiting on write completion
+  static constexpr auto kWriteWaitMs = std::chrono::milliseconds(100);
+
   void checkNotShutdownLocked() {
     VELOX_CHECK(
         !shutdown_, "Unexpected write after SSD cache has been shutdown");
@@ -179,6 +190,9 @@ class SsdCache {
   // Stats for selecting entries to save from AsyncDataCache.
   const std::unique_ptr<FileGroupStats> groupStats_;
   folly::Executor* const executor_;
+  // Maximum number of SSD cache entries allowed. 0 means no limit.
+  const uint64_t maxEntries_;
+
   mutable std::mutex mutex_;
 
   std::vector<std::unique_ptr<SsdFile>> files_;
diff --git a/velox/common/caching/SsdFile.cpp b/velox/common/caching/SsdFile.cpp
index fa5c46f22dae..caf78d29beb7 100644
--- a/velox/common/caching/SsdFile.cpp
+++ b/velox/common/caching/SsdFile.cpp
@@ -112,9 +112,10 @@ SsdFile::SsdFile(const Config& config)
       checksumReadVerificationEnabled_(
           config.checksumEnabled && config.checksumReadVerificationEnabled),
       shardId_(config.shardId),
+      maxEntries_(config.maxEntries),
+      executor_(config.executor),
       fs_(filesystems::getFileSystem(fileName_, nullptr)),
-      checkpointIntervalBytes_(config.checkpointIntervalBytes),
-      executor_(config.executor) {
+      checkpointIntervalBytes_(config.checkpointIntervalBytes) {
   process::TraceContext trace("SsdFile::SsdFile");
   filesystems::FileOptions fileOptions;
   fileOptions.shouldThrowOnFileAlreadyExists = false;
@@ -307,8 +308,19 @@ bool SsdFile::growOrEvictLocked() {
     }
   }
 
-  auto candidates =
-      tracker_.findEvictionCandidates(3, numRegions_, regionPins_);
+  // If SSD is in no space state and future eviction logging cannot go through,
+  // skip eviction, to avoid data inconsistency for checkpointing. Eviction log
+  // is up to date. Separately when SSD is in no space state,
+  // growOrEvictLocked() would not be invoked by write() in the first place.
+  if (state_.load() == State::kNoSpace) {
+    VELOX_SSD_CACHE_LOG_EVERY_MS(WARNING, 1'000)
+        << "Failed to grow cache file " << fileName_
+        << " due to SSD in no space state.";
+    return false;
+  }
+
+  auto candidates = tracker_.findEvictionCandidates(
+      kNumEvictionCandidates, numRegions_, regionPins_);
   if (candidates.empty()) {
     suspended_ = true;
     return false;
@@ -345,6 +357,23 @@ void SsdFile::clearRegionEntriesLocked(const std::vector<int32_t>& regions) {
 
 void SsdFile::write(std::vector<CachePin>& pins) {
   process::TraceContext trace("SsdFile::write");
+
+  if (state_.load() == State::kNoSpace) {
+    ++stats_.writeSsdDropped;
+    VELOX_SSD_CACHE_LOG_EVERY_MS(WARNING, 10'000)
+        << "SSD file write is dropped in no space state.";
+    return;
+  }
+
+  // Check entry count limit before writing
+  if (maxEntries_ > 0) {
+    std::shared_lock<std::shared_mutex> l(mutex_);
+    if (entries_.size() + pins.size() >= maxEntries_) {
+      ++stats_.writeSsdExceedEntryLimit;
+      return;
+    }
+  }
+
   // 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());
@@ -438,16 +467,29 @@ bool SsdFile::write(
     int64_t offset,
     int64_t length,
     const std::vector<iovec>& iovecs) {
+  VELOX_DCHECK_NE(state_.load(), State::kNoSpace);
+
   try {
     writeFile_->write(iovecs, offset, length);
     return true;
   } catch (const std::exception&) {
+    const int err = errno;
     VELOX_SSD_CACHE_LOG(ERROR)
         << "Failed to write to SSD, file name: " << fileName_
         << ", size: " << iovecs.size() << ", offset: " << offset
-        << ", error code: " << errno
-        << ", error string: " << folly::errnoStr(errno);
+        << ", error code: " << err
+        << ", error string: " << folly::errnoStr(err);
     ++stats_.writeSsdErrors;
+
+    if (err == ENOSPC) {
+      if (state_.exchange(State::kNoSpace) != State::kNoSpace) {
+        VELOX_SSD_CACHE_LOG(WARNING)
+            << "State of cache file " << fileName_ << " transits to "
+            << stateString(State::kNoSpace);
+      }
+      ++stats_.writeSsdNoSpaceErrors;
+    }
+
     return false;
   }
 }
@@ -520,6 +562,9 @@ void SsdFile::updateStats(SsdCacheStats& stats) const {
   stats.deleteMetaFileErrors += stats_.deleteMetaFileErrors;
   stats.growFileErrors += stats_.growFileErrors;
   stats.writeSsdErrors += stats_.writeSsdErrors;
+  stats.writeSsdNoSpaceErrors += stats_.writeSsdNoSpaceErrors;
+  stats.writeSsdDropped += stats_.writeSsdDropped;
+  stats.writeSsdExceedEntryLimit += stats_.writeSsdExceedEntryLimit;
   stats.writeCheckpointErrors += stats_.writeCheckpointErrors;
   stats.readSsdErrors += stats_.readSsdErrors;
   stats.readCheckpointErrors += stats_.readCheckpointErrors;
@@ -711,9 +756,10 @@ void SsdFile::maybeFlushCheckpointBuffer(uint32_t appendBytes, bool force) {
       (force ||
        checkpointBufferedDataSize_ + appendBytes >= kCheckpointBufferSize)) {
     VELOX_CHECK_NOT_NULL(checkpointBuffer_);
-    checkpointWriteFile_->append(std::string_view(
-        static_cast<const char*>(checkpointBuffer_),
-        checkpointBufferedDataSize_));
+    checkpointWriteFile_->append(
+        std::string_view(
+            static_cast<const char*>(checkpointBuffer_),
+            checkpointBufferedDataSize_));
     checkpointBufferedDataSize_ = 0;
   }
 }
@@ -830,6 +876,23 @@ void SsdFile::checkpoint(bool force) {
   }
 }
 
+// static
+std::string SsdFile::stateString(State state) {
+  switch (state) {
+    case State::kActive:
+      return "Active";
+    case State::kNoSpace:
+      return "NoSpace";
+    default:
+      return fmt::format("UNKNOWN: {}", static_cast<uint8_t>(state));
+  }
+}
+
+std::ostream& operator<<(std::ostream& out, const SsdFile::State& state) {
+  out << SsdFile::stateString(state);
+  return out;
+}
+
 void SsdFile::initializeCheckpoint() {
   if (!checkpointEnabled()) {
     return;
@@ -964,7 +1027,7 @@ void SsdFile::readCheckpoint() {
     auto checkpointReadFile = fs_->openFileForRead(checkpointPath);
     stream = std::make_unique<common::FileInputStream>(
         std::move(checkpointReadFile),
-        1 << 20,
+        kCheckpointReadBufferSize,
         memory::memoryManager()->cachePool());
   } catch (std::exception& e) {
     ++stats_.openCheckpointErrors;
diff --git a/velox/common/caching/SsdFile.h b/velox/common/caching/SsdFile.h
index c9ab1f5b3016..eb5ecc861821 100644
--- a/velox/common/caching/SsdFile.h
+++ b/velox/common/caching/SsdFile.h
@@ -32,16 +32,18 @@ class SsdFileTestHelper;
 class SsdCacheTestHelper;
 } // namespace test
 
-/// 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.
+/// The 'fileBits_' field is 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 41 bits are the offset. The 'checksum_' field is optional and is used
+/// only when the checksum feature is enabled, otherwise, its value is always 0.
 class SsdRun {
  public:
   static constexpr int32_t kSizeBits = 23;
 
-  SsdRun() : fileBits_(0) {}
+  SsdRun() = default;
 
   SsdRun(uint64_t offset, uint32_t size, uint32_t checksum)
-      : fileBits_((offset << kSizeBits) | ((size - 1))), checksum_(checksum) {
+      : fileBits_((offset << kSizeBits) | (size - 1)), checksum_(checksum) {
     VELOX_CHECK_LT(offset, 1L << (64 - kSizeBits));
     VELOX_CHECK_NE(size, 0);
     VELOX_CHECK_LE(size, 1 << kSizeBits);
@@ -58,9 +60,11 @@ class SsdRun {
     checksum_ = other.checksum_;
   }
 
-  void operator=(SsdRun&& other) {
+  void operator=(SsdRun&& other) noexcept {
     fileBits_ = other.fileBits_;
     checksum_ = other.checksum_;
+    other.fileBits_ = 0;
+    other.checksum_ = 0;
   }
 
   uint64_t offset() const {
@@ -83,8 +87,8 @@ class SsdRun {
 
  private:
   // Contains the file offset and size.
-  uint64_t fileBits_;
-  uint32_t checksum_;
+  uint64_t fileBits_{0};
+  uint32_t checksum_{0};
 };
 
 /// Represents an SsdFile entry that is planned for load or being loaded. This
@@ -164,7 +168,9 @@ struct SsdCacheStats {
     deleteMetaFileErrors = tsanAtomicValue(other.deleteMetaFileErrors);
     growFileErrors = tsanAtomicValue(other.growFileErrors);
     writeSsdErrors = tsanAtomicValue(other.writeSsdErrors);
+    writeSsdNoSpaceErrors = tsanAtomicValue(other.writeSsdNoSpaceErrors);
     writeSsdDropped = tsanAtomicValue(other.writeSsdDropped);
+    writeSsdExceedEntryLimit = tsanAtomicValue(other.writeSsdExceedEntryLimit);
     writeCheckpointErrors = tsanAtomicValue(other.writeCheckpointErrors);
     readSsdErrors = tsanAtomicValue(other.readSsdErrors);
     readCheckpointErrors = tsanAtomicValue(other.readCheckpointErrors);
@@ -193,7 +199,11 @@ struct SsdCacheStats {
         deleteMetaFileErrors - other.deleteMetaFileErrors;
     result.growFileErrors = growFileErrors - other.growFileErrors;
     result.writeSsdErrors = writeSsdErrors - other.writeSsdErrors;
+    result.writeSsdNoSpaceErrors =
+        writeSsdNoSpaceErrors - other.writeSsdNoSpaceErrors;
     result.writeSsdDropped = writeSsdDropped - other.writeSsdDropped;
+    result.writeSsdExceedEntryLimit =
+        writeSsdExceedEntryLimit - other.writeSsdExceedEntryLimit;
     result.writeCheckpointErrors =
         writeCheckpointErrors - other.writeCheckpointErrors;
     result.readSsdCorruptions = readSsdCorruptions - other.readSsdCorruptions;
@@ -232,7 +242,9 @@ struct SsdCacheStats {
   tsan_atomic<uint32_t> deleteMetaFileErrors{0};
   tsan_atomic<uint32_t> growFileErrors{0};
   tsan_atomic<uint32_t> writeSsdErrors{0};
+  tsan_atomic<uint32_t> writeSsdNoSpaceErrors{0};
   tsan_atomic<uint32_t> writeSsdDropped{0};
+  tsan_atomic<uint32_t> writeSsdExceedEntryLimit{0};
   tsan_atomic<uint32_t> writeCheckpointErrors{0};
   tsan_atomic<uint32_t> readSsdErrors{0};
   tsan_atomic<uint32_t> readCheckpointErrors{0};
@@ -257,6 +269,7 @@ class SsdFile {
         bool _disableFileCow = false,
         bool _checksumEnabled = false,
         bool _checksumReadVerificationEnabled = false,
+        uint64_t _maxEntries = 0,
         folly::Executor* _executor = nullptr)
         : fileName(_fileName),
           shardId(_shardId),
@@ -266,7 +279,8 @@ class SsdFile {
           checksumEnabled(_checksumEnabled),
           checksumReadVerificationEnabled(
               _checksumEnabled && _checksumReadVerificationEnabled),
-          executor(_executor){};
+          maxEntries(_maxEntries),
+          executor(_executor) {}
 
     /// Name of cache file, used as prefix for checkpoint files.
     const std::string fileName;
@@ -279,19 +293,28 @@ class SsdFile {
 
     /// Checkpoint after every 'checkpointIntervalBytes' written into this
     /// file. 0 means no checkpointing. This is set to 0 if checkpointing fails.
-    uint64_t checkpointIntervalBytes;
+    const uint64_t checkpointIntervalBytes;
 
     /// True if copy on write should be disabled.
-    bool disableFileCow;
+    const bool disableFileCow;
 
     /// If true, checksum write to SSD is enabled.
-    bool checksumEnabled;
+    const bool checksumEnabled;
 
     /// If true, checksum read verification from SSD is enabled.
-    bool checksumReadVerificationEnabled;
+    const bool checksumReadVerificationEnabled;
+
+    /// Maximum number of SSD cache entries allowed. A value of 0 means no
+    /// limit. When the limit is reached, new entry writes will be skipped.
+    const uint64_t maxEntries;
 
     /// Executor for async fsync in checkpoint.
-    folly::Executor* executor;
+    folly::Executor* const executor;
+  };
+
+  enum class State : uint8_t {
+    kActive,
+    kNoSpace,
   };
 
   static constexpr uint64_t kRegionSize = 1 << 26; // 64MB
@@ -300,6 +323,9 @@ class SsdFile {
   /// filename.
   SsdFile(const Config& config);
 
+  /// Convert State to std::string.
+  static std::string stateString(State state);
+
   /// 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'.
@@ -386,8 +412,19 @@ class SsdFile {
   // Magic number at end of completed checkpoint file.
   static constexpr int64_t kCheckpointEndMarker = 0xcbedf11e;
 
+  // Maximum percentage of erased entries in a region before it becomes
+  // eligible for clearing and reuse. When more than 50% of a region's
+  // entries have been erased (e.g., via TTL eviction), the region can be
+  // cleared and added back to the writable regions pool.
   static constexpr int kMaxErasedSizePct = 50;
 
+  // Number of eviction candidates to consider when selecting regions to
+  // evict.
+  static constexpr int32_t kNumEvictionCandidates = 3;
+
+  // Buffer size for reading checkpoint files during recovery.
+  static constexpr int32_t kCheckpointReadBufferSize = 1 << 20; // 1MB
+
   // Updates the read count of a region.
   void regionRead(int32_t region, int32_t size) {
     tracker_.regionRead(region, size);
@@ -473,6 +510,10 @@ class SsdFile {
     if (!checkpointEnabled()) {
       return false;
     }
+    // Once no SSD space, skip the subsequent checkpointing.
+    if (state_.load() == State::kNoSpace) {
+      return false;
+    }
     return force || (bytesAfterCheckpoint_ >= checkpointIntervalBytes_);
   }
 
@@ -548,6 +589,12 @@ class SsdFile {
   // Shard index within 'cache_'.
   const int32_t shardId_;
 
+  // Maximum number of SSD cache entries allowed in this file. 0 means no limit.
+  const uint64_t maxEntries_;
+
+  // Executor for async fsync in checkpoint.
+  folly::Executor* const executor_;
+
   // Serializes access to all private data members.
   mutable std::shared_mutex mutex_;
 
@@ -578,6 +625,8 @@ class SsdFile {
   // Map of file number and offset to location in file.
   folly::F14FastMap<FileCacheKey, SsdRun> entries_;
 
+  std::atomic<State> state_{State::kActive};
+
   // File system.
   std::shared_ptr<filesystems::FileSystem> fs_;
 
@@ -603,9 +652,6 @@ class SsdFile {
   // means no checkpointing. This is set to 0 if checkpointing fails.
   int64_t checkpointIntervalBytes_{0};
 
-  // Executor for async fsync in checkpoint.
-  folly::Executor* executor_;
-
   // Count of bytes written after last checkpoint.
   std::atomic<uint64_t> bytesAfterCheckpoint_{0};
 
@@ -622,4 +668,16 @@ class SsdFile {
   friend class test::SsdCacheTestHelper;
 };
 
+std::ostream& operator<<(std::ostream& out, const SsdFile::State& state);
+
 } // namespace facebook::velox::cache
+
+template <>
+struct fmt::formatter<facebook::velox::cache::SsdFile::State>
+    : formatter<std::string> {
+  auto format(facebook::velox::cache::SsdFile::State state, format_context& ctx)
+      const {
+    return formatter<std::string>::format(
+        facebook::velox::cache::SsdFile::stateString(state), ctx);
+  }
+};
diff --git a/velox/common/caching/StringIdMap.cpp b/velox/common/caching/StringIdMap.cpp
index c8c88542da1e..e991c5a750ea 100644
--- a/velox/common/caching/StringIdMap.cpp
+++ b/velox/common/caching/StringIdMap.cpp
@@ -31,8 +31,8 @@ void StringIdMap::release(uint64_t id) {
   std::lock_guard<std::mutex> l(mutex_);
   auto it = idToEntry_.find(id);
   if (it != idToEntry_.end()) {
-    VELOX_CHECK_LT(
-        0, it->second.numInUse, "Extra release of id in StringIdMap");
+    VELOX_CHECK_GT(
+        it->second.numInUse, 0, "Extra release of id in StringIdMap");
     if (--it->second.numInUse == 0) {
       pinnedSize_ -= it->second.string.size();
       auto strIter = stringToId_.find(it->second.string);
@@ -60,11 +60,11 @@ uint64_t StringIdMap::makeId(std::string_view string) {
   if (it != stringToId_.end()) {
     auto entry = idToEntry_.find(it->second);
     VELOX_CHECK(entry != idToEntry_.end());
-    if (++entry->second.numInUse == 1) {
-      pinnedSize_ += entry->second.string.size();
-    }
+    VELOX_CHECK_GE(entry->second.numInUse, 1);
+    ++entry->second.numInUse;
     return it->second;
   }
+
   Entry entry;
   entry.string = string;
   // Check that we do not use an id twice. In practice this never
@@ -91,9 +91,8 @@ uint64_t StringIdMap::recoverId(uint64_t id, std::string_view string) {
         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();
-    }
+    VELOX_CHECK_GE(entry->second.numInUse, 1);
+    ++entry->second.numInUse;
     return id;
   }
 
diff --git a/velox/common/caching/tests/AsyncDataCacheTest.cpp b/velox/common/caching/tests/AsyncDataCacheTest.cpp
index f60da8f4ba56..00ef2c6a80b9 100644
--- a/velox/common/caching/tests/AsyncDataCacheTest.cpp
+++ b/velox/common/caching/tests/AsyncDataCacheTest.cpp
@@ -670,7 +670,7 @@ TEST_P(AsyncDataCacheTest, pin) {
   EXPECT_LT(0, cache_->incrementPrefetchPages(0));
   auto stats = cache_->refreshStats();
   EXPECT_EQ(1, stats.numExclusive);
-  EXPECT_LE(kSize, stats.largeSize);
+  EXPECT_EQ(0, stats.largeSize);
 
   CachePin otherPin;
   EXPECT_THROW(otherPin = pin, VeloxException);
@@ -1138,13 +1138,13 @@ TEST_P(AsyncDataCacheTest, shrinkCache) {
       pins.push_back(std::move(largePin));
     }
     auto stats = cache_->refreshStats();
-    ASSERT_EQ(stats.numEntries, numEntries * 2);
+    ASSERT_EQ(stats.numEntries, 0);
     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.tinySize, 0);
+    ASSERT_EQ(stats.largeSize, 0);
     ASSERT_EQ(stats.sharedPinnedBytes, 0);
     ASSERT_GE(
         stats.exclusivePinnedBytes,
@@ -1402,9 +1402,10 @@ TEST_P(AsyncDataCacheTest, makeEvictable) {
       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});
+        keys.push_back(
+            RawFileCacheKey{
+                pin.checkedEntry()->key().fileNum.id(),
+                pin.checkedEntry()->key().offset});
       }
       cachePins.clear();
       for (const auto& key : keys) {
diff --git a/velox/common/caching/tests/CMakeLists.txt b/velox/common/caching/tests/CMakeLists.txt
index 78cdf56656f8..c80dacb33969 100644
--- a/velox/common/caching/tests/CMakeLists.txt
+++ b/velox/common/caching/tests/CMakeLists.txt
@@ -16,12 +16,8 @@ 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
-    velox_time
-    glog::glog
-    GTest::gtest
-    GTest::gtest_main)
+  PRIVATE velox_common_base Folly::folly velox_time glog::glog GTest::gtest GTest::gtest_main
+)
 
 add_executable(
   velox_cache_test
@@ -29,7 +25,8 @@ add_executable(
   CacheTTLControllerTest.cpp
   SsdFileTest.cpp
   SsdFileTrackerTest.cpp
-  StringIdMapTest.cpp)
+  StringIdMapTest.cpp
+)
 add_test(velox_cache_test velox_cache_test)
 target_link_libraries(
   velox_cache_test
@@ -43,16 +40,12 @@ target_link_libraries(
     Folly::folly
     glog::glog
     GTest::gtest
-    GTest::gtest_main)
+    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
-    velox_time
-    glog::glog
-    GTest::gtest
-    GTest::gtest_main)
+  PRIVATE velox_common_base Folly::folly velox_time glog::glog GTest::gtest GTest::gtest_main
+)
diff --git a/velox/common/caching/tests/CacheTestUtil.h b/velox/common/caching/tests/CacheTestUtil.h
index 731da4e876a8..0be663d07970 100644
--- a/velox/common/caching/tests/CacheTestUtil.h
+++ b/velox/common/caching/tests/CacheTestUtil.h
@@ -59,6 +59,18 @@ class SsdFileTestHelper {
     return ssdFile_->checksumReadVerificationEnabled_;
   }
 
+  SsdFile::State state() const {
+    return ssdFile_->state_.load();
+  }
+
+  void setState(SsdFile::State state) {
+    ssdFile_->state_ = state;
+  }
+
+  int32_t maxRegions() const {
+    return ssdFile_->maxRegions_;
+  }
+
   /// Deletes the backing file.
   void deleteFile() {
     process::TraceContext trace("SsdFile::testingDeleteFile");
diff --git a/velox/common/caching/tests/SsdFileTest.cpp b/velox/common/caching/tests/SsdFileTest.cpp
index bf4f2a94fbf6..a5ef1f6d0c2b 100644
--- a/velox/common/caching/tests/SsdFileTest.cpp
+++ b/velox/common/caching/tests/SsdFileTest.cpp
@@ -96,7 +96,8 @@ class SsdFileTest : public testing::Test {
       uint64_t checkpointIntervalBytes = 0,
       bool checksumEnabled = false,
       bool checksumReadVerificationEnabled = false,
-      bool disableFileCow = false) {
+      bool disableFileCow = false,
+      uint64_t maxEntries = 0) {
     SsdFile::Config config(
         fmt::format("{}/ssdtest", tempDirectory_->getPath()),
         0, // shardId
@@ -105,6 +106,7 @@ class SsdFileTest : public testing::Test {
         disableFileCow,
         checksumEnabled,
         checksumReadVerificationEnabled,
+        maxEntries,
         ssdExecutor());
     ssdFile_ = std::make_unique<SsdFile>(config);
     if (ssdFile_ != nullptr) {
@@ -231,8 +233,9 @@ class SsdFileTest : public testing::Test {
     std::vector<SsdPin> ssdPins;
     ssdPins.reserve(pins.size());
     for (auto& pin : pins) {
-      ssdPins.push_back(ssdFile_->find(RawFileCacheKey{
-          pin.entry()->key().fileNum.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);
@@ -820,6 +823,110 @@ TEST_F(SsdFileTest, ssdReadWithoutChecksumCheck) {
 #endif
 }
 
+TEST_F(SsdFileTest, writeInNoSpaceState) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  initializeCache(kSsdSize);
+
+  // Verify the initial state is kActive.
+  EXPECT_EQ(ssdFileHelper_->state(), SsdFile::State::kActive);
+
+  // Verify the cache write is successful in the initial kActiveState.
+  auto pins = makePins(fileName_.id(), 0, 4096, 4096, 4096 * 10);
+  ssdFile_->write(pins);
+  SsdCacheStats statsBeforeNoSpace;
+  ssdFile_->updateStats(statsBeforeNoSpace);
+  EXPECT_GT(statsBeforeNoSpace.entriesWritten, 0);
+  EXPECT_EQ(statsBeforeNoSpace.writeSsdDropped, 0);
+
+  // Set the state to kNoSpace to simulate the SSD running out of space.
+  ssdFileHelper_->setState(SsdFile::State::kNoSpace);
+  EXPECT_EQ(ssdFileHelper_->state(), SsdFile::State::kNoSpace);
+
+  // Verify that writes are dropped and no new entries are written in the
+  // kNoSpace state.
+  auto morePins = makePins(fileName_.id(), 4096 * 10, 4096, 4096, 4096 * 5);
+  ssdFile_->write(morePins);
+  SsdCacheStats statsAfterNoSpace;
+  ssdFile_->updateStats(statsAfterNoSpace);
+  EXPECT_GT(
+      statsAfterNoSpace.writeSsdDropped, statsBeforeNoSpace.writeSsdDropped);
+  EXPECT_EQ(
+      statsAfterNoSpace.entriesWritten, statsBeforeNoSpace.entriesWritten);
+
+  // Verify none of the new entries have ssdFile set.
+  for (const auto& pin : morePins) {
+    EXPECT_EQ(pin.entry()->ssdFile(), nullptr);
+  }
+}
+
+TEST_F(SsdFileTest, checkpointInNoSpaceState) {
+  constexpr int64_t kSsdSize = 4 * SsdFile::kRegionSize;
+  const uint64_t checkpointIntervalBytes = 2 * SsdFile::kRegionSize;
+  initializeCache(kSsdSize, checkpointIntervalBytes);
+
+  // Write some entries to trigger checkpoint eligibility.
+  auto pins = makePins(fileName_.id(), 0, 4096, 4096, 3 * SsdFile::kRegionSize);
+  ssdFile_->write(pins);
+
+  SsdCacheStats statsBeforeNoSpace;
+  ssdFile_->updateStats(statsBeforeNoSpace);
+
+  // Set the state to kNoSpace.
+  ssdFileHelper_->setState(SsdFile::State::kNoSpace);
+  EXPECT_EQ(ssdFileHelper_->state(), SsdFile::State::kNoSpace);
+
+  // Verify checkpointing is skipped in the kNoSpace state.
+  ssdFile_->checkpoint(true);
+
+  SsdCacheStats statsAfterNoSpace;
+  ssdFile_->updateStats(statsAfterNoSpace);
+  EXPECT_EQ(
+      statsAfterNoSpace.checkpointsWritten,
+      statsBeforeNoSpace.checkpointsWritten);
+}
+
+TEST_F(SsdFileTest, growOrEvictBlockedInNoSpaceState) {
+  constexpr int64_t kSsdSize = 4 * SsdFile::kRegionSize;
+  const uint64_t checkpointIntervalBytes = kSsdSize;
+  initializeCache(kSsdSize, checkpointIntervalBytes);
+
+  // Fill up the SSD cache to trigger eviction on subsequent writes.
+  for (auto startOffset = 0; startOffset <= kSsdSize - SsdFile::kRegionSize;
+       startOffset += SsdFile::kRegionSize) {
+    auto pins = makePins(
+        fileName_.id(), startOffset, 4096, 4096, SsdFile::kRegionSize - 1024);
+    ssdFile_->write(pins);
+  }
+
+  // The SSD cache is at max regins.
+  SsdCacheStats statsBeforeNoSpace;
+  ssdFile_->updateStats(statsBeforeNoSpace);
+  EXPECT_EQ(statsBeforeNoSpace.regionsCached, ssdFileHelper_->maxRegions());
+
+  ssdFileHelper_->setState(SsdFile::State::kNoSpace);
+  EXPECT_EQ(ssdFileHelper_->state(), SsdFile::State::kNoSpace);
+
+  // Verify the eviction should not happen since write was dropped before
+  // eviction.
+  auto newPins = makePins(fileName_.id(), kSsdSize * 2, 4096, 4096, 4096 * 5);
+  ssdFile_->write(newPins);
+
+  SsdCacheStats statsAfterNoSpace;
+  ssdFile_->updateStats(statsAfterNoSpace);
+
+  EXPECT_EQ(
+      statsAfterNoSpace.regionsEvicted, statsBeforeNoSpace.regionsEvicted);
+  EXPECT_GT(
+      statsAfterNoSpace.writeSsdDropped, statsBeforeNoSpace.writeSsdDropped);
+  EXPECT_EQ(
+      statsAfterNoSpace.entriesWritten, statsBeforeNoSpace.entriesWritten);
+
+  // Verify none of the new entries have ssdFile set.
+  for (const auto& pin : newPins) {
+    EXPECT_EQ(pin.entry()->ssdFile(), nullptr);
+  }
+}
+
 TEST_F(SsdFileTest, dataFileErrorInjection) {
   constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
   initializeCache(kSsdSize, 0, false, false, false, true);
@@ -868,8 +975,9 @@ TEST_F(SsdFileTest, dataFileErrorInjection) {
   std::vector<SsdPin> ssdPins;
   ssdPins.reserve(pins.size());
   for (auto& pin : pins) {
-    ssdPins.push_back(ssdFile_->find(RawFileCacheKey{
-        pin.entry()->key().fileNum.id(), pin.entry()->key().offset}));
+    ssdPins.push_back(ssdFile_->find(
+        RawFileCacheKey{
+            pin.entry()->key().fileNum.id(), pin.entry()->key().offset}));
   }
 
   SsdCacheStats statsWithReadErrorInjected;
@@ -954,6 +1062,65 @@ TEST_F(SsdFileTest, evictlogFileErrorInjection) {
   ASSERT_GT(statsAfterRecovery.readCheckpointErrors, 0);
 }
 
+TEST_F(SsdFileTest, maxEntriesLimit) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  constexpr uint64_t kMaxEntries = 100;
+  FLAGS_velox_ssd_verify_write = true;
+
+  initializeCache(kSsdSize);
+  // Re-initialize SSD file with maxEntries limit
+  initializeSsdFile(kSsdSize, 0, false, false, false, kMaxEntries);
+
+  // Write more entries than the limit
+  auto pins = makePins(fileName_.id(), 0, 4096, 2048 * 1025, 62 * kMB);
+  ASSERT_GT(pins.size(), kMaxEntries);
+
+  ssdFile_->write(pins);
+
+  SsdCacheStats stats;
+  ssdFile_->updateStats(stats);
+
+  // The SSD file should have at most maxEntries
+  EXPECT_LE(stats.entriesCached, kMaxEntries);
+  // Some writes should have been dropped due to the entry limit
+  EXPECT_GT(stats.writeSsdExceedEntryLimit, 0);
+}
+
+TEST_F(SsdFileTest, noWritesDroppedWithinMaxEntriesLimit) {
+  constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
+  constexpr uint64_t kMaxEntries = 200;
+  FLAGS_velox_ssd_verify_write = true;
+
+  initializeCache(kSsdSize);
+  // Re-initialize SSD file with maxEntries limit
+  initializeSsdFile(kSsdSize, 0, false, false, false, kMaxEntries);
+
+  // Write fewer entries than the limit
+  auto pins = makePins(fileName_.id(), 0, 4096, 4096, 4096 * 50);
+  ASSERT_LT(pins.size(), kMaxEntries);
+  const auto numPins = pins.size();
+
+  ssdFile_->write(pins);
+
+  SsdCacheStats stats;
+  ssdFile_->updateStats(stats);
+
+  // All entries should be cached since we're within the limit
+  EXPECT_EQ(stats.entriesCached, numPins);
+  // No writes should be dropped due to exceeding entry limit
+  EXPECT_EQ(stats.writeSsdExceedEntryLimit, 0);
+  // No writes should be dropped due to lack of space
+  EXPECT_EQ(stats.writeSsdDropped, 0);
+  // All entries should have been written
+  EXPECT_EQ(stats.entriesWritten, numPins);
+
+  // Verify all entries are readable
+  for (auto& pin : pins) {
+    EXPECT_EQ(ssdFile_.get(), pin.entry()->ssdFile());
+  }
+  readAndCheckPins(pins);
+}
+
 #ifdef VELOX_SSD_FILE_TEST_SET_NO_COW_FLAG
 TEST_F(SsdFileTest, disabledCow) {
   constexpr int64_t kSsdSize = 16 * SsdFile::kRegionSize;
diff --git a/velox/common/caching/tests/StringIdMapTest.cpp b/velox/common/caching/tests/StringIdMapTest.cpp
index 59d95af2e88a..1a1d006748aa 100644
--- a/velox/common/caching/tests/StringIdMapTest.cpp
+++ b/velox/common/caching/tests/StringIdMapTest.cpp
@@ -22,7 +22,7 @@
 using namespace facebook::velox;
 
 TEST(StringIdMapTest, basic) {
-  constexpr const char* kFile1 = "file_1";
+  constexpr std::string_view kFile1 = "file_1";
   StringIdMap map;
   uint64_t id = 0;
   {
@@ -33,7 +33,7 @@ TEST(StringIdMapTest, basic) {
     id = lease2.id();
     lease1 = lease2;
     EXPECT_EQ(id, lease1.id());
-    EXPECT_EQ(strlen(kFile1), map.pinnedSize());
+    EXPECT_EQ(kFile1.size(), map.pinnedSize());
   }
   StringIdLease lease3(map, kFile1);
   EXPECT_NE(lease3.id(), id);
@@ -56,50 +56,48 @@ TEST(StringIdMapTest, rehash) {
 }
 
 TEST(StringIdMapTest, recover) {
-  constexpr const char* kRecoverFile1 = "file_1";
-  constexpr const char* kRecoverFile2 = "file_2";
-  constexpr const char* kRecoverFile3 = "file_3";
+  constexpr std::string_view kRecoverFile1("file_1");
+  constexpr std::string_view kRecoverFile2("file_2");
+  constexpr std::string_view 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.pinnedSize(), kRecoverFile1.size());
     ASSERT_EQ(map.testingLastId(), recoverId1);
     VELOX_ASSERT_THROW(
-        std::make_unique<StringIdLease>(map, recoverId1, kRecoverFile2),
+        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),
+        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.pinnedSize(), kRecoverFile1.size());
   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.pinnedSize(), kRecoverFile1.size() + kRecoverFile2.size());
     ASSERT_EQ(map.testingLastId(), recoverId2);
     VELOX_ASSERT_THROW(
-        std::make_unique<StringIdLease>(map, recoverId2, kRecoverFile3),
+        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),
+        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.pinnedSize(), kRecoverFile1.size() + kRecoverFile2.size());
   }
 
   ASSERT_EQ(map.testingLastId(), recoverId2);
-  ASSERT_EQ(map.pinnedSize(), ::strlen(kRecoverFile1));
+  ASSERT_EQ(map.pinnedSize(), kRecoverFile1.size());
 }
diff --git a/velox/common/compression/CMakeLists.txt b/velox/common/compression/CMakeLists.txt
index d6ff2579ea8b..d8743ce38603 100644
--- a/velox/common/compression/CMakeLists.txt
+++ b/velox/common/compression/CMakeLists.txt
@@ -20,12 +20,11 @@ velox_add_library(velox_common_compression Compression.cpp LzoDecompressor.cpp)
 velox_link_libraries(
   velox_common_compression
   PUBLIC velox_status Folly::folly
-  PRIVATE velox_exception)
+  PRIVATE velox_exception
+)
 
 if(VELOX_ENABLE_COMPRESSION_LZ4)
-  velox_sources(velox_common_compression PRIVATE Lz4Compression.cpp
-                HadoopCompressionFormat.cpp)
+  velox_sources(velox_common_compression PRIVATE Lz4Compression.cpp HadoopCompressionFormat.cpp)
   velox_link_libraries(velox_common_compression PUBLIC lz4::lz4)
-  velox_compile_definitions(velox_common_compression
-                            PRIVATE VELOX_ENABLE_COMPRESSION_LZ4)
+  velox_compile_definitions(velox_common_compression PRIVATE VELOX_ENABLE_COMPRESSION_LZ4)
 endif()
diff --git a/velox/common/compression/Compression.cpp b/velox/common/compression/Compression.cpp
index 8473b4fe119a..4dde4b95a89b 100644
--- a/velox/common/compression/Compression.cpp
+++ b/velox/common/compression/Compression.cpp
@@ -122,9 +122,10 @@ Expected<std::unique_ptr<Codec>> Codec::create(
     const CodecOptions& codecOptions) {
   if (!isAvailable(kind)) {
     auto name = compressionKindToString(kind);
-    return folly::makeUnexpected(Status::Invalid(
-        "Support for codec '{}' is either not built or not implemented.",
-        name));
+    return folly::makeUnexpected(
+        Status::Invalid(
+            "Support for codec '{}' is either not built or not implemented.",
+            name));
   }
 
   auto compressionLevel = codecOptions.compressionLevel;
@@ -155,9 +156,10 @@ Expected<std::unique_ptr<Codec>> Codec::create(
   }
   VELOX_RETURN_UNEXPECTED_IF(
       codec == nullptr,
-      Status::Invalid(fmt::format(
-          "Support for codec '{}' is either not built or not implemented.",
-          compressionKindToString(kind))));
+      Status::Invalid(
+          fmt::format(
+              "Support for codec '{}' is either not built or not implemented.",
+              compressionKindToString(kind))));
 
   VELOX_RETURN_UNEXPECTED_NOT_OK(codec->init());
 
@@ -184,8 +186,9 @@ bool Codec::isAvailable(CompressionKind kind) {
 Expected<uint64_t> Codec::getUncompressedLength(
     const uint8_t* input,
     uint64_t inputLength) const {
-  return folly::makeUnexpected(Status::Invalid(
-      "getUncompressedLength is unsupported with {} format.", name()));
+  return folly::makeUnexpected(
+      Status::Invalid(
+          "getUncompressedLength is unsupported with {} format.", name()));
 }
 
 Expected<uint64_t> Codec::compressFixedLength(
@@ -203,14 +206,16 @@ bool Codec::supportsStreamingCompression() const {
 
 Expected<std::shared_ptr<StreamingCompressor>>
 Codec::makeStreamingCompressor() {
-  return folly::makeUnexpected(Status::Invalid(
-      "Streaming compression is unsupported with {} format.", name()));
+  return folly::makeUnexpected(
+      Status::Invalid(
+          "Streaming compression is unsupported with {} format.", name()));
 }
 
 Expected<std::shared_ptr<StreamingDecompressor>>
 Codec::makeStreamingDecompressor() {
-  return folly::makeUnexpected(Status::Invalid(
-      "Streaming decompression is unsupported with {} format.", name()));
+  return folly::makeUnexpected(
+      Status::Invalid(
+          "Streaming decompression is unsupported with {} format.", name()));
 }
 
 int32_t Codec::compressionLevel() const {
diff --git a/velox/common/compression/Lz4Compression.cpp b/velox/common/compression/Lz4Compression.cpp
index 111b34bf7695..58c6ed6662f5 100644
--- a/velox/common/compression/Lz4Compression.cpp
+++ b/velox/common/compression/Lz4Compression.cpp
@@ -223,7 +223,7 @@ Status LZ4Compressor::init() {
   firstTime_ = true;
 
   ret = LZ4F_createCompressionContext(&ctx_, LZ4F_VERSION);
-  VELOX_RETURN_IF(LZ4F_isError(ret), lz4Error("LZ4 init failed: ", ret));
+  VELOX_RETURN_IF(LZ4F_isError(ret), lz4Error("LZ4 init failed: {}", ret));
   return Status::OK();
 }
 
@@ -255,7 +255,7 @@ Expected<StreamingCompressor::CompressResult> LZ4Compressor::compress(
       ctx_, output, outputSize, input, inputSize, nullptr /* options */);
   VELOX_RETURN_UNEXPECTED_IF(
       LZ4F_isError(numBytesOrError),
-      lz4Error("LZ4 compress updated failed: ", numBytesOrError));
+      lz4Error("LZ4 compress updated failed: {}", numBytesOrError));
   bytesWritten += static_cast<int64_t>(numBytesOrError);
 
   VELOX_DCHECK_LE(bytesWritten, outputSize);
@@ -287,7 +287,7 @@ Expected<StreamingCompressor::FlushResult> LZ4Compressor::flush(
       LZ4F_flush(ctx_, output, outputSize, nullptr /* options */);
   VELOX_RETURN_UNEXPECTED_IF(
       LZ4F_isError(numBytesOrError),
-      lz4Error("LZ4 flush failed: ", numBytesOrError));
+      lz4Error("LZ4 flush failed: {}", numBytesOrError));
   bytesWritten += static_cast<uint64_t>(numBytesOrError);
 
   VELOX_DCHECK_LE(bytesWritten, outputLength);
@@ -319,7 +319,7 @@ Expected<StreamingCompressor::EndResult> LZ4Compressor::finalize(
       LZ4F_compressEnd(ctx_, output, outputSize, nullptr /* options */);
   VELOX_RETURN_UNEXPECTED_IF(
       LZ4F_isError(numBytesOrError),
-      lz4Error("LZ4 end failed: ", numBytesOrError));
+      lz4Error("LZ4 finalize failed: {}", numBytesOrError));
   bytesWritten += static_cast<uint64_t>(numBytesOrError);
 
   VELOX_DCHECK_LE(bytesWritten, outputLength);
@@ -333,7 +333,7 @@ Status LZ4Compressor::compressBegin(
   auto numBytesOrError = LZ4F_compressBegin(ctx_, output, outputLen, &prefs_);
   VELOX_RETURN_IF(
       LZ4F_isError(numBytesOrError),
-      lz4Error("LZ4 compress begin failed: ", numBytesOrError));
+      lz4Error("LZ4 compress begin failed: {}", numBytesOrError));
   firstTime_ = false;
   output += numBytesOrError;
   outputLen -= numBytesOrError;
@@ -344,7 +344,7 @@ Status LZ4Compressor::compressBegin(
 Status LZ4Decompressor::init() {
   finished_ = false;
   auto ret = LZ4F_createDecompressionContext(&ctx_, LZ4F_VERSION);
-  VELOX_RETURN_IF(LZ4F_isError(ret), lz4Error("LZ4 init failed: ", ret));
+  VELOX_RETURN_IF(LZ4F_isError(ret), lz4Error("LZ4 init failed: {}", ret));
   return Status::OK();
 }
 
@@ -378,7 +378,7 @@ Expected<StreamingDecompressor::DecompressResult> LZ4Decompressor::decompress(
   auto ret = LZ4F_decompress(
       ctx_, output, &outputSize, input, &inputSize, nullptr /* options */);
   VELOX_RETURN_UNEXPECTED_IF(
-      LZ4F_isError(ret), lz4Error("LZ4 decompress failed: ", ret));
+      LZ4F_isError(ret), lz4Error("LZ4 decompression failed: {}", ret));
   finished_ = (ret == 0);
   return DecompressResult{
       static_cast<uint64_t>(inputSize),
@@ -443,7 +443,7 @@ Expected<uint64_t> Lz4FrameCodec::compress(
       static_cast<size_t>(inputLength),
       &prefs_);
   VELOX_RETURN_UNEXPECTED_IF(
-      LZ4F_isError(ret), lz4Error("Lz4 compression failure: ", ret));
+      LZ4F_isError(ret), lz4Error("LZ4 compression failed: {}", ret));
   return static_cast<uint64_t>(ret);
 }
 
@@ -470,12 +470,11 @@ Expected<uint64_t> Lz4FrameCodec::decompress(
           bytesWritten += result.bytesWritten;
           VELOX_RETURN_UNEXPECTED_IF(
               result.outputTooSmall,
-              Status::IOError("Lz4 decompression buffer too small."));
+              Status::IOError("LZ4 decompression buffer too small."));
         }
         VELOX_RETURN_UNEXPECTED_IF(
             !decompressor->isFinished() || inputLength != 0,
-            Status::IOError(
-                "Lz4 compressed input contains less than one frame."));
+            Status::IOError("LZ4 decompression failed."));
         return bytesWritten;
       });
 }
@@ -534,7 +533,7 @@ Expected<uint64_t> Lz4RawCodec::compress(
         compressionLevel_);
   }
   VELOX_RETURN_UNEXPECTED_IF(
-      compressedSize == 0, Status::IOError("Lz4 compression failure."));
+      compressedSize == 0, Status::IOError("LZ4 compression failed."));
   return static_cast<uint64_t>(compressedSize);
 }
 
@@ -551,7 +550,7 @@ Expected<uint64_t> Lz4RawCodec::decompress(
       static_cast<int>(inputLength),
       static_cast<int>(outputLength));
   VELOX_RETURN_UNEXPECTED_IF(
-      decompressedSize < 0, Status::IOError("Lz4 decompression failure."));
+      decompressedSize < 0, Status::IOError("LZ4 decompression failed."));
   return static_cast<uint64_t>(decompressedSize);
 }
 
diff --git a/velox/common/compression/tests/CMakeLists.txt b/velox/common/compression/tests/CMakeLists.txt
index 3b75b6fea698..5f7a19e7906a 100644
--- a/velox/common/compression/tests/CMakeLists.txt
+++ b/velox/common/compression/tests/CMakeLists.txt
@@ -17,5 +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
-          GTest::gtest_main)
+  PRIVATE velox_common_compression velox_exception GTest::gtest GTest::gtest_main
+)
diff --git a/velox/common/compression/tests/CompressionTest.cpp b/velox/common/compression/tests/CompressionTest.cpp
index 846d606e4499..fbaef2253da7 100644
--- a/velox/common/compression/tests/CompressionTest.cpp
+++ b/velox/common/compression/tests/CompressionTest.cpp
@@ -19,6 +19,7 @@
 #include <memory>
 #include <random>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include <gtest/gtest.h>
@@ -99,18 +100,18 @@ void checkCodecRoundtrip(
     Codec* c1,
     Codec* c2,
     const std::vector<uint8_t>& data) {
-  auto maxCompressedLen =
+  auto maxCompressedLength =
       static_cast<size_t>(c1->maxCompressedLength(data.size()));
-  std::vector<uint8_t> compressed(maxCompressedLen);
+  std::vector<uint8_t> compressed(maxCompressedLength);
   // Allocate at least 1 byte to ensure data.get() is not nullptr.
   std::vector<uint8_t> decompressed(data.size() == 0 ? 1 : data.size());
 
   // Compress with codec c1.
-  auto compressionLength =
+  auto compressedLength =
       c1->compress(
-            data.data(), data.size(), compressed.data(), maxCompressedLen)
+            data.data(), data.size(), compressed.data(), maxCompressedLength)
           .thenOrThrow(folly::identity, throwsNotOk);
-  compressed.resize(compressionLength);
+  compressed.resize(compressedLength);
 
   // Decompress with codec c2.
   auto decompressedLength = c2->decompress(
@@ -122,6 +123,39 @@ void checkCodecRoundtrip(
   decompressed.resize(data.size());
   ASSERT_EQ(data, decompressed);
   ASSERT_EQ(data.size(), decompressedLength);
+
+  // Compress with codec c1 with a smaller output buffer to test compression
+  // failure.
+  static const std::unordered_map<std::string_view, std::string>
+      compressionFailures = {
+          {"lz4", "LZ4 compression failed: ERROR_dstMaxSize_tooSmall"},
+          {"lz4_raw", "LZ4 compression failed"},
+          {"lz4_hadoop", "LZ4 compression failed"}};
+  VELOX_ASSERT_ERROR_STATUS(
+      c1->compress(
+            data.data(), data.size(), compressed.data(), compressedLength - 1)
+          .error(),
+      StatusCode::kIOError,
+      compressionFailures.at(c1->name()));
+
+  // Decompress corrupted data.
+  std::vector<uint8_t> corruptedData = compressed;
+  corruptedData.resize(compressed.size() + 1);
+
+  static const std::unordered_map<std::string_view, std::string>
+      decompressionFailures = {
+          {"lz4", "LZ4 decompression failed."},
+          {"lz4_raw", "LZ4 decompression failed."},
+          {"lz4_hadoop", "LZ4 decompression failed."}};
+  VELOX_ASSERT_ERROR_STATUS(
+      c2->decompress(
+            corruptedData.data(),
+            corruptedData.size(),
+            decompressed.data(),
+            decompressed.size())
+          .error(),
+      StatusCode::kIOError,
+      decompressionFailures.at(c2->name()));
 }
 
 // Use same codec for both compression and decompression.
diff --git a/velox/common/config/CMakeLists.txt b/velox/common/config/CMakeLists.txt
index 9639a2c8b6f7..c2d2acd82b93 100644
--- a/velox/common/config/CMakeLists.txt
+++ b/velox/common/config/CMakeLists.txt
@@ -17,7 +17,4 @@ if(${VELOX_BUILD_TESTING})
 endif()
 
 velox_add_library(velox_common_config Config.cpp)
-velox_link_libraries(
-  velox_common_config
-  PUBLIC velox_common_base velox_exception
-  PRIVATE re2::re2)
+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
index 18cc705949cd..987dbdb3dc05 100644
--- a/velox/common/config/Config.cpp
+++ b/velox/common/config/Config.cpp
@@ -138,13 +138,12 @@ std::unordered_map<std::string, std::string> ConfigBase::rawConfigsCopy()
   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;
+std::optional<std::string> ConfigBase::access(const std::string& key) const {
+  std::shared_lock l{mutex_};
+  if (auto it = configs_.find(key); it != configs_.end()) {
+    return it->second;
   }
-  return val;
+  return std::nullopt;
 }
+
 } // namespace facebook::velox::config
diff --git a/velox/common/config/Config.h b/velox/common/config/Config.h
index 96f77d59cd7b..16031818d9b2 100644
--- a/velox/common/config/Config.h
+++ b/velox/common/config/Config.h
@@ -23,6 +23,7 @@
 
 #include "folly/Conv.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/config/IConfig.h"
 
 namespace facebook::velox::config {
 
@@ -47,7 +48,7 @@ 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 {
+class ConfigBase : public IConfig {
  public:
   template <typename T>
   struct Entry {
@@ -111,49 +112,20 @@ class ConfigBase {
                                   : 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;
-    }
-  }
-
-  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;
-    }
-  }
+  using IConfig::get;
 
   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;
+  std::unordered_map<std::string, std::string> rawConfigsCopy() const final;
 
  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;
+  std::optional<std::string> access(const std::string& key) const final;
 
   const bool mutable_;
 };
diff --git a/velox/common/config/IConfig.h b/velox/common/config/IConfig.h
new file mode 100644
index 000000000000..06d8d8bc3f5e
--- /dev/null
+++ b/velox/common/config/IConfig.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 <folly/Conv.h>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace facebook::velox::config {
+
+/// IConfig - Read-only config interface
+/// for accessing key-value parameters.
+/// Supports value retrieval by key and
+/// duplication of the raw configuration data.
+/// Can be used by velox::QueryConfig to access
+/// externally managed system configuration.
+class IConfig {
+ public:
+  template <typename T>
+  std::optional<T> get(
+      const std::string& key,
+      const std::function<T(std::string, std::string)>& toT =
+          [](auto /* unused */, auto value) {
+            return folly::to<T>(value);
+          }) const {
+    if (auto val = access(key)) {
+      return toT(key, *val);
+    }
+    return std::nullopt;
+  }
+
+  template <typename T>
+  T get(
+      const std::string& key,
+      const T& defaultValue,
+      const std::function<T(std::string, std::string)>& toT =
+          [](auto /* unused */, auto value) {
+            return folly::to<T>(value);
+          }) const {
+    if (auto val = access(key)) {
+      return toT(key, *val);
+    }
+    return defaultValue;
+  }
+
+  virtual std::unordered_map<std::string, std::string> rawConfigsCopy()
+      const = 0;
+
+  virtual ~IConfig() = default;
+
+ private:
+  virtual std::optional<std::string> access(const std::string& key) const = 0;
+};
+
+} // namespace facebook::velox::config
diff --git a/velox/common/config/tests/CMakeLists.txt b/velox/common/config/tests/CMakeLists.txt
index 83de01821eea..feb2ae1222b0 100644
--- a/velox/common/config/tests/CMakeLists.txt
+++ b/velox/common/config/tests/CMakeLists.txt
@@ -17,4 +17,5 @@ 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)
+  PRIVATE velox_common_config GTest::gtest GTest::gtest_main
+)
diff --git a/velox/common/dynamic_registry/tests/CMakeLists.txt b/velox/common/dynamic_registry/tests/CMakeLists.txt
index 58132e596e1f..40ccba9a9895 100644
--- a/velox/common/dynamic_registry/tests/CMakeLists.txt
+++ b/velox/common/dynamic_registry/tests/CMakeLists.txt
@@ -17,47 +17,40 @@
 # VELOX_TEST_DYNAMIC_LIBRARY_PATH macro to locate the .so binary.
 
 add_library(velox_function_dynamic SHARED DynamicFunction.cpp)
-add_library(velox_overwrite_int_function_dynamic SHARED
-            DynamicIntFunctionOverwrite.cpp)
-add_library(velox_overwrite_varchar_function_dynamic SHARED
-            DynamicVarcharFunctionOverwrite.cpp)
+add_library(velox_overwrite_int_function_dynamic SHARED DynamicIntFunctionOverwrite.cpp)
+add_library(velox_overwrite_varchar_function_dynamic SHARED DynamicVarcharFunctionOverwrite.cpp)
 add_library(velox_function_err_dynamic SHARED DynamicErrFunction.cpp)
-add_library(velox_overload_int_function_dynamic SHARED
-            DynamicIntFunctionOverload.cpp)
-add_library(velox_overload_varchar_function_dynamic SHARED
-            DynamicVarcharFunctionOverload.cpp)
-add_library(velox_function_non_default_dynamic SHARED
-            DynamicFunctionNonDefault.cpp)
+add_library(velox_overload_int_function_dynamic SHARED DynamicIntFunctionOverload.cpp)
+add_library(velox_overload_varchar_function_dynamic SHARED DynamicVarcharFunctionOverload.cpp)
+add_library(velox_function_non_default_dynamic SHARED DynamicFunctionNonDefault.cpp)
 
 set(CMAKE_DYLIB_TEST_LINK_LIBRARIES fmt::fmt Folly::folly glog::glog xsimd)
 
-target_link_libraries(
-  velox_function_dynamic
-  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
+target_link_libraries(velox_function_dynamic PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
 
 target_link_libraries(
   velox_overwrite_int_function_dynamic
-  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
+  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES}
+)
 
 target_link_libraries(
   velox_overwrite_varchar_function_dynamic
-  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
+  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES}
+)
 
-target_link_libraries(
-  velox_function_err_dynamic
-  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
+target_link_libraries(velox_function_err_dynamic PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
 
 target_link_libraries(
   velox_overload_int_function_dynamic
-  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
+  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES}
+)
 
 target_link_libraries(
   velox_overload_varchar_function_dynamic
-  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
+  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES}
+)
 
-target_link_libraries(
-  velox_function_non_default_dynamic
-  PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
+target_link_libraries(velox_function_non_default_dynamic PRIVATE ${CMAKE_DYLIB_TEST_LINK_LIBRARIES})
 
 if(APPLE)
   set(COMMON_LIBRARY_LINK_OPTIONS "-Wl,-undefined,dynamic_lookup")
@@ -68,20 +61,13 @@ else()
   set(COMMON_LIBRARY_LINK_OPTIONS "-Wl,--exclude-libs,ALL")
 endif()
 
-target_link_options(velox_function_dynamic PRIVATE
-                    ${COMMON_LIBRARY_LINK_OPTIONS})
-target_link_options(velox_overwrite_int_function_dynamic PRIVATE
-                    ${COMMON_LIBRARY_LINK_OPTIONS})
-target_link_options(velox_overwrite_varchar_function_dynamic PRIVATE
-                    ${COMMON_LIBRARY_LINK_OPTIONS})
-target_link_options(velox_function_err_dynamic PRIVATE
-                    ${COMMON_LIBRARY_LINK_OPTIONS})
-target_link_options(velox_overload_int_function_dynamic PRIVATE
-                    ${COMMON_LIBRARY_LINK_OPTIONS})
-target_link_options(velox_overload_varchar_function_dynamic PRIVATE
-                    ${COMMON_LIBRARY_LINK_OPTIONS})
-target_link_options(velox_function_non_default_dynamic PRIVATE
-                    ${COMMON_LIBRARY_LINK_OPTIONS})
+target_link_options(velox_function_dynamic PRIVATE ${COMMON_LIBRARY_LINK_OPTIONS})
+target_link_options(velox_overwrite_int_function_dynamic PRIVATE ${COMMON_LIBRARY_LINK_OPTIONS})
+target_link_options(velox_overwrite_varchar_function_dynamic PRIVATE ${COMMON_LIBRARY_LINK_OPTIONS})
+target_link_options(velox_function_err_dynamic PRIVATE ${COMMON_LIBRARY_LINK_OPTIONS})
+target_link_options(velox_overload_int_function_dynamic PRIVATE ${COMMON_LIBRARY_LINK_OPTIONS})
+target_link_options(velox_overload_varchar_function_dynamic PRIVATE ${COMMON_LIBRARY_LINK_OPTIONS})
+target_link_options(velox_function_non_default_dynamic PRIVATE ${COMMON_LIBRARY_LINK_OPTIONS})
 
 # Here's the actual test which will dynamically load the library defined above.
 add_executable(velox_function_dynamic_link_test DynamicLinkTest.cpp)
@@ -94,15 +80,16 @@ target_link_libraries(
   xsimd
   GTest::gmock
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 target_compile_definitions(
   velox_function_dynamic_link_test
-  PRIVATE VELOX_TEST_DYNAMIC_LIBRARY_PATH="${CMAKE_CURRENT_BINARY_DIR}")
+  PRIVATE VELOX_TEST_DYNAMIC_LIBRARY_PATH="${CMAKE_CURRENT_BINARY_DIR}"
+)
 target_compile_definitions(
   velox_function_dynamic_link_test
-  PRIVATE
-    VELOX_TEST_DYNAMIC_LIBRARY_PATH_SUFFIX="${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  PRIVATE VELOX_TEST_DYNAMIC_LIBRARY_PATH_SUFFIX="${CMAKE_SHARED_LIBRARY_SUFFIX}"
+)
 
-add_test(NAME velox_function_dynamic_link_test
-         COMMAND velox_function_dynamic_link_test)
+add_test(NAME velox_function_dynamic_link_test COMMAND velox_function_dynamic_link_test)
diff --git a/velox/common/dynamic_registry/tests/DynamicErrFunction.cpp b/velox/common/dynamic_registry/tests/DynamicErrFunction.cpp
index f97444f465e9..f3e8ef3826f5 100644
--- a/velox/common/dynamic_registry/tests/DynamicErrFunction.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicErrFunction.cpp
@@ -18,8 +18,8 @@
 
 // This file defines a mock function that will be dynamically linked and
 // registered. There are no restrictions as to how the function needs to be
-// defined, but the library (.so) needs to provide a `void registry()` C
-// function in the top-level namespace.
+// defined, but the library (.so) needs to provide a `void registerExtensions()`
+// C function in the top-level namespace.
 //
 // (note the extern "C" directive to prevent the compiler from mangling the
 // symbol name).
diff --git a/velox/common/dynamic_registry/tests/DynamicFunction.cpp b/velox/common/dynamic_registry/tests/DynamicFunction.cpp
index a41a216521d2..dcc852d956d8 100644
--- a/velox/common/dynamic_registry/tests/DynamicFunction.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicFunction.cpp
@@ -18,8 +18,8 @@
 
 // This file defines a mock function that will be dynamically linked and
 // registered. There are no restrictions as to how the function needs to be
-// defined, but the library (.so) needs to provide a `void registry()` C
-// function in the top-level namespace.
+// defined, but the library (.so) needs to provide a `void registerExtensions()`
+// C function in the top-level namespace.
 //
 // (note the extern "C" directive to prevent the compiler from mangling the
 // symbol name).
diff --git a/velox/common/dynamic_registry/tests/DynamicFunctionNonDefault.cpp b/velox/common/dynamic_registry/tests/DynamicFunctionNonDefault.cpp
index 8489c88a9e4f..aebff84ce74f 100644
--- a/velox/common/dynamic_registry/tests/DynamicFunctionNonDefault.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicFunctionNonDefault.cpp
@@ -18,8 +18,8 @@
 
 // This file defines a mock function that will be dynamically linked and
 // registered. There are no restrictions as to how the function needs to be
-// defined, but the library (.so) needs to provide a `void registry()` C
-// function in the top-level namespace.
+// defined, but the library (.so) needs to provide a `void registerExtensions()`
+// C function in the top-level namespace.
 //
 // (note the extern "C" directive to prevent the compiler from mangling the
 // symbol name).
diff --git a/velox/common/dynamic_registry/tests/DynamicIntFunctionOverload.cpp b/velox/common/dynamic_registry/tests/DynamicIntFunctionOverload.cpp
index f0be371c1201..5129f9cff1d3 100644
--- a/velox/common/dynamic_registry/tests/DynamicIntFunctionOverload.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicIntFunctionOverload.cpp
@@ -18,8 +18,8 @@
 
 // This file defines a mock function that will be dynamically linked and
 // registered. There are no restrictions as to how the function needs to be
-// defined, but the library (.so) needs to provide a `void registry()` C
-// function in the top-level namespace.
+// defined, but the library (.so) needs to provide a `void registerExtensions()`
+// C function in the top-level namespace.
 //
 // (note the extern "C" directive to prevent the compiler from mangling the
 // symbol name).
diff --git a/velox/common/dynamic_registry/tests/DynamicIntFunctionOverwrite.cpp b/velox/common/dynamic_registry/tests/DynamicIntFunctionOverwrite.cpp
index dbb9623a2604..804edeec30bd 100644
--- a/velox/common/dynamic_registry/tests/DynamicIntFunctionOverwrite.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicIntFunctionOverwrite.cpp
@@ -18,8 +18,8 @@
 
 // This file defines a mock function that will be dynamically linked and
 // registered. There are no restrictions as to how the function needs to be
-// defined, but the library (.so) needs to provide a `void registry()` C
-// function in the top-level namespace.
+// defined, but the library (.so) needs to provide a `void registerExtensions()`
+// C function in the top-level namespace.
 //
 // (note the extern "C" directive to prevent the compiler from mangling the
 // symbol name).
diff --git a/velox/common/dynamic_registry/tests/DynamicLinkTest.cpp b/velox/common/dynamic_registry/tests/DynamicLinkTest.cpp
index 97672761bb88..fbade514dbdf 100644
--- a/velox/common/dynamic_registry/tests/DynamicLinkTest.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicLinkTest.cpp
@@ -152,8 +152,8 @@ TEST_F(DynamicLinkTest, dynamicLoadErrFunc) {
       dynamicFunctionFail(0, 0),
       "Scalar function signature is not supported: dynamic_err(BIGINT). Supported signatures: (array(bigint)) -> bigint.");
 
-  auto check = makeRowVector(
-      {makeNullableArrayVector(std::vector<std::vector<std::optional<int64_t>>>{
+  auto check = makeRowVector({makeNullableArrayVector(
+      std::vector<std::vector<std::optional<int64_t>>>{
           {0, 1, 3, 4, 5, 6, 7, 8, 9}})});
 
   // Expecting a success because we are passing in an array.
diff --git a/velox/common/dynamic_registry/tests/DynamicVarcharFunctionOverload.cpp b/velox/common/dynamic_registry/tests/DynamicVarcharFunctionOverload.cpp
index 250eea92a1c6..1f6c4788ff5b 100644
--- a/velox/common/dynamic_registry/tests/DynamicVarcharFunctionOverload.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicVarcharFunctionOverload.cpp
@@ -18,8 +18,8 @@
 
 // This file defines a mock function that will be dynamically linked and
 // registered. There are no restrictions as to how the function needs to be
-// defined, but the library (.so) needs to provide a `void registry()` C
-// function in the top-level namespace.
+// defined, but the library (.so) needs to provide a `void registerExtensions()`
+// C function in the top-level namespace.
 //
 // (note the extern "C" directive to prevent the compiler from mangling the
 // symbol name).
diff --git a/velox/common/dynamic_registry/tests/DynamicVarcharFunctionOverwrite.cpp b/velox/common/dynamic_registry/tests/DynamicVarcharFunctionOverwrite.cpp
index 1678a16e0b98..adbdd299a238 100644
--- a/velox/common/dynamic_registry/tests/DynamicVarcharFunctionOverwrite.cpp
+++ b/velox/common/dynamic_registry/tests/DynamicVarcharFunctionOverwrite.cpp
@@ -18,8 +18,8 @@
 
 // This file defines a mock function that will be dynamically linked and
 // registered. There are no restrictions as to how the function needs to be
-// defined, but the library (.so) needs to provide a `void registry()` C
-// function in the top-level namespace.
+// defined, but the library (.so) needs to provide a `void registerExtensions()`
+// C function in the top-level namespace.
 //
 // (note the extern "C" directive to prevent the compiler from mangling the
 // symbol name).
diff --git a/velox/common/encode/Base32.cpp b/velox/common/encode/Base32.cpp
new file mode 100644
index 000000000000..b43a2b03f0a3
--- /dev/null
+++ b/velox/common/encode/Base32.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/Base32.h"
+
+#include <folly/Expected.h>
+#include <cctype>
+#include <cstdint>
+
+#include "velox/common/base/CheckedArithmetic.h"
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::encoding {
+
+// Reverse lookup table for decoding. 255 means invalid character.
+// Only uppercase letters (A-Z) and digits 2-7 are valid per RFC 4648.
+// Lowercase letters are NOT supported (matching Google Guava's
+// BaseEncoding.base32()).
+constexpr const Base32::ReverseIndex kBase32ReverseIndexTable = {
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 0-15
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 16-31
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 32-47
+    255, 255, 26,  27,  28,  29,  30,  31,  255,
+    255, 255, 255, 255, 255, 255, 255, // 48-63 ('2'-'7')
+    255, 0,   1,   2,   3,   4,   5,   6,   7,
+    8,   9,   10,  11,  12,  13,  14, // 64-79 ('A'-'O')
+    15,  16,  17,  18,  19,  20,  21,  22,  23,
+    24,  25,  255, 255, 255, 255, 255, // 80-95 ('P'-'Z')
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 96-111 (lowercase 'a'-'o' - INVALID)
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 112-127 (lowercase 'p'-'z' - INVALID)
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 128-143
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 144-159
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 160-175
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 176-191
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 192-207
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 208-223
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, // 224-239
+    255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255 // 240-255
+};
+
+// static
+folly::Expected<uint8_t, Status> Base32::base32ReverseLookup(
+    char encodedChar,
+    const ReverseIndex& reverseIndex) {
+  auto index = reverseIndex[static_cast<uint8_t>(encodedChar)];
+  if (index >= 32) {
+    return folly::makeUnexpected(
+        Status::UserError("Unrecognized character: {}", encodedChar));
+  }
+  return index;
+}
+
+// static
+folly::Expected<size_t, Status> Base32::calculateDecodedSize(
+    const char* input,
+    const size_t inputSize) {
+  if (inputSize == 0) {
+    return 0;
+  }
+
+  // Count valid (non-padding, non-whitespace) characters and validate them
+  size_t validCharCount = 0;
+  for (size_t i = 0; i < inputSize; ++i) {
+    char c = input[i];
+    if (c == Base32::kPadding || std::isspace(static_cast<unsigned char>(c))) {
+      continue;
+    }
+
+    // Validate character first
+    auto index = kBase32ReverseIndexTable[static_cast<uint8_t>(c)];
+    if (index >= 32) {
+      return folly::makeUnexpected(
+          Status::UserError("Unrecognized character: {}", c));
+    }
+    validCharCount++;
+  }
+
+  // Validate input length matches Google Guava's Base32 behavior.
+  // Base32 encoding groups characters into quantums of 8 characters (40 bits).
+  // Valid character counts (mod 8) are: 0, 2, 4, 5, 7
+  // Invalid character counts (mod 8) are: 1, 3, 6
+  // These invalid counts leave too many incomplete bits that cannot form
+  // complete bytes.
+  if (validCharCount > 0) {
+    size_t remainder = validCharCount % 8;
+    if (remainder == 1 || remainder == 3 || remainder == 6) {
+      return folly::makeUnexpected(
+          Status::UserError("Invalid input length {}", validCharCount));
+    }
+  }
+
+  // Calculate decoded size
+  // Each base32 character represents 5 bits
+  // We need to convert to bytes (8 bits each)
+  size_t totalBits = checkedMultiply(validCharCount, size_t(5));
+  size_t decodedSize = totalBits / 8;
+
+  return decodedSize;
+}
+
+// static
+Status Base32::decode(
+    const char* input,
+    size_t inputSize,
+    char* outputBuffer,
+    size_t outputSize) {
+  auto decodedSize = decodeImpl(
+      input, inputSize, outputBuffer, outputSize, kBase32ReverseIndexTable);
+  if (decodedSize.hasError()) {
+    return decodedSize.error();
+  }
+  return Status::OK();
+}
+
+// Decodes Base32 input using the provided reverse lookup table.
+// This is the core decoding implementation that accumulates 5-bit values
+// from Base32 characters and outputs 8-bit bytes.
+// static
+folly::Expected<size_t, Status> Base32::decodeImpl(
+    const char* input,
+    size_t inputSize,
+    char* outputBuffer,
+    size_t outputSize,
+    const ReverseIndex& reverseIndex) {
+  if (inputSize == 0) {
+    return 0;
+  }
+
+  size_t outputPos = 0;
+  uint64_t accumulator = 0;
+  size_t bitsAccumulated = 0;
+
+  for (size_t i = 0; i < inputSize; ++i) {
+    char c = input[i];
+
+    // Skip padding and whitespace (RFC 4648 allows whitespace in encoded data)
+    if (c == Base32::kPadding || std::isspace(static_cast<unsigned char>(c))) {
+      continue;
+    }
+
+    // Validate and convert character to 5-bit value
+    auto value = base32ReverseLookup(c, reverseIndex);
+    if (value.hasError()) {
+      return folly::makeUnexpected(value.error());
+    }
+
+    // Accumulate 5 bits from each Base32 character
+    // Each character contributes 5 bits to the bit accumulator
+    accumulator = (accumulator << 5) | value.value();
+    bitsAccumulated += 5;
+
+    // Extract full bytes (8 bits) when we have accumulated enough bits
+    if (bitsAccumulated >= 8) {
+      if (outputPos >= outputSize) {
+        return folly::makeUnexpected(
+            Status::UserError("Output buffer too small"));
+      }
+      outputBuffer[outputPos++] =
+          static_cast<char>((accumulator >> (bitsAccumulated - 8)) & 0xFF);
+      bitsAccumulated -= 8;
+    }
+  }
+
+  return outputPos;
+}
+
+} // namespace facebook::velox::encoding
diff --git a/velox/common/encode/Base32.h b/velox/common/encode/Base32.h
new file mode 100644
index 000000000000..246a60d7994f
--- /dev/null
+++ b/velox/common/encode/Base32.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 <folly/Range.h>
+
+#include <array>
+#include <string>
+
+#include "velox/common/base/Status.h"
+
+namespace facebook::velox::encoding {
+
+class Base32 {
+ public:
+  static const size_t kCharsetSize = 32;
+  static const size_t kReverseIndexSize = 256;
+
+  /// Character set used for Base32 encoding.
+  /// Contains specific characters that form the encoding scheme.
+  using Charset = std::array<char, kCharsetSize>;
+
+  /// Reverse lookup table for decoding.
+  /// Maps each possible encoded character to its corresponding numeric value
+  /// within the encoding base.
+  using ReverseIndex = std::array<uint8_t, kReverseIndexSize>;
+
+  /// Decodes the specified number of characters from the 'input' and writes the
+  /// result to the 'outputBuffer'.
+  static Status decode(
+      const char* input,
+      size_t inputSize,
+      char* outputBuffer,
+      size_t outputSize);
+
+  /// Calculates the decoded size based on encoded input.
+  static folly::Expected<size_t, Status> calculateDecodedSize(
+      const char* input,
+      const size_t inputSize);
+
+  // Padding character used in encoding.
+  static const char kPadding = '=';
+
+  // Constants defining the size in bytes of binary and encoded blocks for
+  // Base32 encoding. Size of a binary block in bytes (5 bytes = 40 bits)
+  static const int kBinaryBlockByteSize = 5;
+  // Size of an encoded block in bytes (8 bytes = 40 bits)
+  static const int kEncodedBlockByteSize = 8;
+
+ private:
+  // Reverse lookup helper function to get the original index of a Base32
+  // character.
+  static folly::Expected<uint8_t, Status> base32ReverseLookup(
+      char encodedChar,
+      const ReverseIndex& reverseIndex);
+
+  // Decodes the specified data using the provided reverse lookup table.
+  static folly::Expected<size_t, Status> decodeImpl(
+      const char* input,
+      size_t inputSize,
+      char* outputBuffer,
+      size_t outputSize,
+      const ReverseIndex& reverseIndex);
+};
+
+} // namespace facebook::velox::encoding
diff --git a/velox/common/encode/Base64.cpp b/velox/common/encode/Base64.cpp
index cc62a8f7a0e8..2b87fd141ab5 100644
--- a/velox/common/encode/Base64.cpp
+++ b/velox/common/encode/Base64.cpp
@@ -187,14 +187,13 @@ size_t Base64::calculateEncodedSize(size_t inputSize, bool withPadding) {
 
 // static
 void Base64::encode(const char* input, size_t inputSize, char* output) {
-  encodeImpl(
-      folly::StringPiece(input, inputSize), kBase64Charset, true, output);
+  encodeImpl(std::string_view(input, inputSize), kBase64Charset, true, output);
 }
 
 // static
 void Base64::encodeUrl(const char* input, size_t inputSize, char* output) {
   encodeImpl(
-      folly::StringPiece(input, inputSize), kBase64UrlCharset, true, output);
+      std::string_view(input, inputSize), kBase64UrlCharset, true, output);
 }
 
 // static
@@ -249,13 +248,13 @@ void Base64::encodeImpl(
 }
 
 // static
-std::string Base64::encode(folly::StringPiece text) {
+std::string Base64::encode(std::string_view text) {
   return encodeImpl(text, kBase64Charset, true);
 }
 
 // static
 std::string Base64::encode(const char* input, size_t inputSize) {
-  return encode(folly::StringPiece(input, inputSize));
+  return encode(std::string_view(input, inputSize));
 }
 
 namespace {
@@ -308,7 +307,7 @@ std::string Base64::encode(const folly::IOBuf* inputBuffer) {
 }
 
 // static
-std::string Base64::decode(folly::StringPiece encodedText) {
+std::string Base64::decode(std::string_view encodedText) {
   std::string decodedResult;
   decode(std::make_pair(encodedText.data(), encodedText.size()), decodedResult);
   return decodedResult;
@@ -346,9 +345,10 @@ Expected<uint8_t> Base64::base64ReverseLookup(
     const ReverseIndex& reverseIndex) {
   auto reverseLookupValue = reverseIndex[static_cast<uint8_t>(encodedChar)];
   if (reverseLookupValue >= 0x40) {
-    return folly::makeUnexpected(Status::UserError(
-        "decode() - invalid input string: invalid character '{}'",
-        encodedChar));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "decode() - invalid input string: invalid character '{}'",
+            encodedChar));
   }
   return reverseLookupValue;
 }
@@ -381,8 +381,9 @@ Expected<size_t> Base64::calculateDecodedSize(
     // block size
     if (inputSize % kEncodedBlockByteSize != 0) {
       return folly::makeUnexpected(
-          Status::UserError("Base64::decode() - invalid input string: "
-                            "string length is not a multiple of 4."));
+          Status::UserError(
+              "Base64::decode() - invalid input string: "
+              "string length is not a multiple of 4."));
     }
 
     auto decodedSize =
@@ -403,9 +404,10 @@ Expected<size_t> Base64::calculateDecodedSize(
   // Adjust the needed size for extra bytes, if present
   if (extraBytes) {
     if (extraBytes == 1) {
-      return folly::makeUnexpected(Status::UserError(
-          "Base64::decode() - invalid input string: "
-          "string length cannot be 1 more than a multiple of 4."));
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Base64::decode() - invalid input string: "
+              "string length cannot be 1 more than a multiple of 4."));
     }
     decodedSize += (extraBytes * kBinaryBlockByteSize) / kEncodedBlockByteSize;
   }
@@ -431,8 +433,9 @@ Expected<size_t> Base64::decodeImpl(
 
   if (outputSize < decodedSize.value()) {
     return folly::makeUnexpected(
-        Status::UserError("Base64::decode() - invalid output string: "
-                          "output string is too small."));
+        Status::UserError(
+            "Base64::decode() - invalid output string: "
+            "output string is too small."));
   }
   outputSize = decodedSize.value();
 
@@ -492,13 +495,13 @@ Expected<size_t> Base64::decodeImpl(
 }
 
 // static
-std::string Base64::encodeUrl(folly::StringPiece text) {
+std::string Base64::encodeUrl(std::string_view text) {
   return encodeImpl(text, kBase64UrlCharset, false);
 }
 
 // static
 std::string Base64::encodeUrl(const char* input, size_t inputSize) {
-  return encodeUrl(folly::StringPiece(input, inputSize));
+  return encodeUrl(std::string_view(input, inputSize));
 }
 
 // static
@@ -521,7 +524,7 @@ Status Base64::decodeUrl(
 }
 
 // static
-std::string Base64::decodeUrl(folly::StringPiece encodedText) {
+std::string Base64::decodeUrl(std::string_view encodedText) {
   std::string decodedOutput;
   decodeUrl(
       std::make_pair(encodedText.data(), encodedText.size()), decodedOutput);
@@ -546,4 +549,189 @@ void Base64::decodeUrl(
   decodedOutput.resize(decodedSize.value());
 }
 
+// static
+Status Base64::decodeMime(const char* input, size_t inputSize, char* output) {
+  if (inputSize == 0) {
+    return Status::OK();
+  }
+
+  // 24-bit buffer.
+  uint32_t accumulator = 0;
+  // Next shift amount.
+  int bitsNeeded = 18;
+  size_t idx = 0;
+  char* outPtr = output;
+
+  while (idx < inputSize) {
+    unsigned char c = static_cast<unsigned char>(input[idx++]);
+    int val = kBase64ReverseIndexTable[c];
+
+    // Padding character.
+    if (c == kPadding) {
+      // If we see '=' too early or only one '=' when two are needed → error.
+      if (bitsNeeded == 18 ||
+          (bitsNeeded == 6 && (idx == inputSize || input[idx++] != kPadding))) {
+        return Status::UserError(
+            "Input byte array has wrong 4-byte ending unit.");
+      }
+      break;
+    }
+
+    // Skip whitespace or other non-Base64 chars.
+    if (val < 0 || val >= 0x40) {
+      continue;
+    }
+
+    // Accumulate 6 bits
+    accumulator |= (static_cast<uint32_t>(val) << bitsNeeded);
+    bitsNeeded -= 6;
+
+    // If we've collected 24 bits, write out 3 bytes.
+    if (bitsNeeded < 0) {
+      *outPtr++ = static_cast<char>((accumulator >> 16) & 0xFF);
+      *outPtr++ = static_cast<char>((accumulator >> 8) & 0xFF);
+      *outPtr++ = static_cast<char>(accumulator & 0xFF);
+      accumulator = 0;
+      bitsNeeded = 18;
+    }
+  }
+
+  // Handle any remaining bits (1 or 2 bytes).
+  if (bitsNeeded == 0) {
+    *outPtr++ = static_cast<char>((accumulator >> 16) & 0xFF);
+    *outPtr++ = static_cast<char>((accumulator >> 8) & 0xFF);
+  } else if (bitsNeeded == 6) {
+    *outPtr++ = static_cast<char>((accumulator >> 16) & 0xFF);
+  } else if (bitsNeeded == 12) {
+    return Status::UserError("Last unit does not have enough valid bits.");
+  }
+
+  // Verify no illegal trailing Base64 data.
+  while (idx < inputSize) {
+    unsigned char c = static_cast<unsigned char>(input[idx++]);
+    int val = kBase64ReverseIndexTable[c];
+    // Valid data after completion is an error.
+    if (val >= 0 && val < 0x40) {
+      return Status::UserError("Input byte array has incorrect ending.");
+    }
+    // '=' padding beyond handled ones is OK; other negatives are skips.
+  }
+
+  return Status::OK();
+}
+
+// static
+Expected<size_t> Base64::calculateMimeDecodedSize(
+    const char* input,
+    const size_t inputSize) {
+  if (inputSize == 0) {
+    return 0;
+  }
+  if (inputSize < 2) {
+    if (kBase64ReverseIndexTable[static_cast<uint8_t>(input[0])] >= 0x40) {
+      return 0;
+    }
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Input should at least have 2 bytes for base64 bytes."));
+  }
+  auto decodedSize = inputSize;
+  // Compute how many true Base64 chars.
+  for (size_t i = 0; i < inputSize; ++i) {
+    auto c = input[i];
+    if (c == kPadding) {
+      decodedSize -= inputSize - i;
+      break;
+    }
+    if (kBase64ReverseIndexTable[static_cast<uint8_t>(c)] >= 0x40) {
+      decodedSize--;
+    }
+  }
+  // If no explicit padding but validChars ≢ 0 mod 4, infer missing '='.
+  size_t paddings = 0;
+  if ((decodedSize & 0x3) != 0) {
+    paddings = 4 - (decodedSize & 0x3);
+  }
+  // Each 4-char block yields 3 bytes; subtract padding.
+  decodedSize = 3 * ((decodedSize + 3) / 4) - paddings;
+  return decodedSize;
+}
+
+// static
+void Base64::encodeMime(const char* input, size_t inputSize, char* output) {
+  // If there's nothing to encode, do nothing.
+  if (inputSize == 0) {
+    return;
+  }
+
+  const char* readPtr = input;
+  char* writePtr = output;
+  // Bytes per 76-char line.
+  const size_t bytesPerLine = (kMaxLineLength / 4) * 3;
+  size_t remaining = inputSize;
+
+  // Process full lines of up to 'bytesPerLine' bytes.
+  while (remaining >= 3) {
+    // Round down to a multiple of 3, but not more than one line.
+    size_t chunk = std::min(bytesPerLine, (remaining / 3) * 3);
+    const char* chunkEnd = readPtr + chunk;
+
+    // Encode each group of 3 bytes into 4 Base64 characters.
+    while (readPtr + 2 < chunkEnd) {
+      // Read three bytes separately to avoid undefined behavior.
+      uint8_t b0 = static_cast<uint8_t>(*readPtr++);
+      uint8_t b1 = static_cast<uint8_t>(*readPtr++);
+      uint8_t b2 = static_cast<uint8_t>(*readPtr++);
+      // Pack into a 24-bit value.
+      uint32_t trio = (static_cast<uint32_t>(b0) << 16) |
+          (static_cast<uint32_t>(b1) << 8) | static_cast<uint32_t>(b2);
+      // Emit four Base64 characters.
+      *writePtr++ = kBase64Charset[(trio >> 18) & 0x3F];
+      *writePtr++ = kBase64Charset[(trio >> 12) & 0x3F];
+      *writePtr++ = kBase64Charset[(trio >> 6) & 0x3F];
+      *writePtr++ = kBase64Charset[trio & 0x3F];
+    }
+
+    remaining -= chunk;
+
+    // Insert CRLF if we filled exactly one line and still have more data.
+    if (chunk == bytesPerLine && remaining > 0) {
+      *writePtr++ = kNewline[0];
+      *writePtr++ = kNewline[1];
+    }
+  }
+
+  // Handle the final 1 or 2 leftover bytes with padding.
+  if (remaining > 0) {
+    uint8_t b0 = static_cast<uint8_t>(*readPtr++);
+    // First Base64 character from the high 6 bits.
+    *writePtr++ = kBase64Charset[b0 >> 2];
+
+    if (remaining == 1) {
+      // Only one byte remains: produce two chars + two '=' paddings.
+      *writePtr++ = kBase64Charset[(b0 & 0x03) << 4];
+      *writePtr++ = kPadding;
+      *writePtr = kPadding;
+    } else {
+      // Two bytes remain: produce three chars + one '=' padding.
+      uint8_t b1 = static_cast<uint8_t>(*readPtr);
+      *writePtr++ = kBase64Charset[((b0 & 0x03) << 4) | (b1 >> 4)];
+      *writePtr++ = kBase64Charset[(b1 & 0x0F) << 2];
+      *writePtr = kPadding;
+    }
+  }
+}
+
+// static
+size_t Base64::calculateMimeEncodedSize(size_t inputSize) {
+  if (inputSize == 0) {
+    return 0;
+  }
+
+  size_t encodedSize = calculateEncodedSize(inputSize, true);
+  // Add CRLFs: one per full kMaxLineLength block.
+  encodedSize += (encodedSize - 1) / kMaxLineLength * kNewline.size();
+  return encodedSize;
+}
+
 } // namespace facebook::velox::encoding
diff --git a/velox/common/encode/Base64.h b/velox/common/encode/Base64.h
index e6f802489b27..7dca7d2fdbce 100644
--- a/velox/common/encode/Base64.h
+++ b/velox/common/encode/Base64.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include <folly/Range.h>
 #include <folly/io/IOBuf.h>
 
 #include <array>
@@ -45,7 +44,7 @@ class Base64 {
   static std::string encode(const char* input, size_t inputSize);
 
   /// Encodes the specified text.
-  static std::string encode(folly::StringPiece text);
+  static std::string encode(std::string_view text);
 
   /// Encodes the specified IOBuf data.
   static std::string encode(const folly::IOBuf* inputBuffer);
@@ -60,7 +59,7 @@ class Base64 {
   static std::string encodeUrl(const char* input, size_t inputSize);
 
   /// Encodes the specified text using URL encoding.
-  static std::string encodeUrl(folly::StringPiece text);
+  static std::string encodeUrl(std::string_view text);
 
   /// Encodes the specified IOBuf data using URL encoding.
   static std::string encodeUrl(const folly::IOBuf* inputBuffer);
@@ -72,7 +71,7 @@ class Base64 {
   encodeUrl(const char* input, size_t inputSize, char* outputBuffer);
 
   /// Decodes the input Base64 encoded string.
-  static std::string decode(folly::StringPiece encodedText);
+  static std::string decode(std::string_view encodedText);
 
   /// Decodes the specified encoded payload and writes the result to the
   /// 'output'.
@@ -94,7 +93,7 @@ class Base64 {
       size_t outputSize);
 
   /// Decodes the input Base64 URL encoded string.
-  static std::string decodeUrl(folly::StringPiece encodedText);
+  static std::string decodeUrl(std::string_view encodedText);
 
   /// Decodes the specified URL encoded payload and writes the result to the
   /// 'output'.
@@ -110,6 +109,16 @@ class Base64 {
       char* outputBuffer,
       size_t outputSize);
 
+  /// Decodes a Base64 MIME‐mode buffer back to binary.
+  /// Skips any non-Base64 chars (e.g. CR/LF).
+  static Status
+  decodeMime(const char* input, size_t inputSize, char* outputBuffer);
+
+  /// Encodes the input buffer into Base64 MIME format.
+  /// Inserts a CRLF every kMaxLineLength output characters.
+  static void
+  encodeMime(const char* input, size_t inputSize, char* outputBuffer);
+
   /// Calculates the encoded size based on input 'inputSize'.
   static size_t calculateEncodedSize(size_t inputSize, bool withPadding = true);
 
@@ -119,10 +128,25 @@ class Base64 {
       const char* input,
       size_t& inputSize);
 
+  /// Calculates the decoded binary size of a MIME‐mode Base64 input,
+  /// accounting for padding and ignoring whitespace.
+  static Expected<size_t> calculateMimeDecodedSize(
+      const char* input,
+      const size_t inputSize);
+
+  /// Computes the exact output length for MIME‐mode Base64 encoding,
+  /// including required CRLF line breaks.
+  static size_t calculateMimeEncodedSize(size_t inputSize);
+
  private:
   // Padding character used in encoding.
   static const char kPadding = '=';
 
+  // Soft Line breaks used in mime encoding as defined in RFC 2045, section 6.8:
+  // https://www.rfc-editor.org/rfc/rfc2045#section-6.8
+  inline static const std::string kNewline{"\r\n"};
+  static const size_t kMaxLineLength = 76;
+
   // Checks if the input Base64 string is padded.
   static inline bool isPadded(const char* input, size_t inputSize) {
     return (inputSize > 0 && input[inputSize - 1] == kPadding);
diff --git a/velox/common/strings/ByteStream.h b/velox/common/encode/ByteStream.h
similarity index 91%
rename from velox/common/strings/ByteStream.h
rename to velox/common/encode/ByteStream.h
index 0a02b7a6a31a..9ebbee1054d7 100644
--- a/velox/common/strings/ByteStream.h
+++ b/velox/common/encode/ByteStream.h
@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#pragma once
+
 /**
  * Interfaces for efficient stream-like I/O.
  */
 
-#ifndef COMMON_STRINGS_BYTESTREAM_H_
-#define COMMON_STRINGS_BYTESTREAM_H_
-
 #include <limits>
 #include <streambuf>
 #include <string>
@@ -27,10 +27,8 @@
 #include <glog/logging.h>
 
 #include <folly/FBString.h>
-#include <folly/Range.h>
 
-namespace facebook {
-namespace strings {
+namespace facebook::velox::strings {
 
 const size_t kSizeMax = std::numeric_limits<size_t>::max();
 
@@ -88,28 +86,28 @@ class ByteSink {
    * append() will return 0).  In particular, this may not be used for
    * non-blocking behavior.
    */
-  virtual size_t append(folly::StringPiece str) = 0;
+  virtual size_t append(std::string_view str) = 0;
   size_t append(const void* data, size_t size) {
-    return append(folly::StringPiece(static_cast<const char*>(data), size));
+    return append(std::string_view(static_cast<const char*>(data), size));
   }
 
   /**
-   * Append the given string to this ByteSink.  The string must remain
+   * Append the given string to this ByteSink. The string must remain
    * allocated (and unchanged) until the ByteSink is destroyed.
    */
-  virtual size_t appendAllocated(folly::StringPiece str) {
+  virtual size_t appendAllocated(std::string_view str) {
     return append(str);
   }
 
   /**
    * Convenience function that appends the bitwise representation of count
-   * objects starting at address obj.  The usual caveats about endianness,
+   * objects starting at address obj. The usual caveats about endianness,
    * padding apply.
    */
   template <class T>
   size_t appendBitwise(const T* obj, size_t count) {
     const size_t sz = count * sizeof(T);
-    return append(folly::StringPiece(reinterpret_cast<const char*>(obj), sz));
+    return append(std::string_view(reinterpret_cast<const char*>(obj), sz));
   }
 
   /**
@@ -187,8 +185,8 @@ class SByteSink : public ByteSink {
  public:
   explicit SByteSink(S* str) : str_(str) {}
 
-  size_t append(folly::StringPiece s) override {
-    str_->append(s.start(), s.size());
+  size_t append(std::string_view s) override {
+    str_->append(s.data(), s.size());
     return s.size();
   }
 
@@ -239,7 +237,7 @@ class ByteSource {
    * next() will return false, but bad() will also return false.  On error,
    * next() returns false, and bad() returns true.
    */
-  virtual bool next(folly::StringPiece* chunk) = 0;
+  virtual bool next(std::string_view* chunk) = 0;
 
   /**
    * Push back the last numBytes returned by the last next() call, so
@@ -318,7 +316,7 @@ class ByteSourceBuffer : public std::basic_streambuf<char> {
 class StringByteSource : public ByteSource {
  public:
   explicit StringByteSource(
-      const folly::StringPiece& str,
+      const std::string_view& str,
       size_t maxBytes = kSizeMax)
       : str_(str),
         offset_(0),
@@ -328,15 +326,17 @@ class StringByteSource : public ByteSource {
   bool bad() const override {
     return false;
   }
-  bool next(folly::StringPiece* chunk) override {
+
+  bool next(std::string_view* chunk) override {
     if (offset_ == str_.size()) {
       return false;
     }
     size_t len = std::min(str_.size() - offset_, maxBytes_);
-    chunk->reset(str_.start() + offset_, len);
+    *chunk = std::string_view(str_.data() + offset_, len);
     offset_ += len;
     return true;
   }
+
   void backUp(size_t numBytes) override {
     CHECK_LE(numBytes, maxBytes_);
     CHECK_GE(offset_, numBytes);
@@ -344,12 +344,9 @@ class StringByteSource : public ByteSource {
   }
 
  private:
-  folly::StringPiece str_;
+  std::string_view str_;
   size_t offset_;
   size_t maxBytes_;
 };
 
-} // namespace strings
-} // namespace facebook
-
-#endif /* __COMMON_STRINGS_BYTESTREAM_H_ */
+} // namespace facebook::velox::strings
diff --git a/velox/common/encode/CMakeLists.txt b/velox/common/encode/CMakeLists.txt
index 15acfcc232a2..32875adc48e7 100644
--- a/velox/common/encode/CMakeLists.txt
+++ b/velox/common/encode/CMakeLists.txt
@@ -16,5 +16,5 @@ if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
 
-velox_add_library(velox_encode Base64.cpp)
+velox_add_library(velox_encode Base64.cpp Base32.cpp)
 velox_link_libraries(velox_encode PUBLIC velox_status Folly::folly)
diff --git a/velox/common/encode/Coding.h b/velox/common/encode/Coding.h
index 284c226da901..e4edaac4bcde 100644
--- a/velox/common/encode/Coding.h
+++ b/velox/common/encode/Coding.h
@@ -13,22 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#pragma once
+
 //
 // Miscellaneous number encoding/decoding routines
 // - Varint coding
 // - ZigZag coding
 
-#ifndef FACEBOOK_COMMON_ENCODE_CODING_H_
-#define FACEBOOK_COMMON_ENCODE_CODING_H_
-
 #include <folly/GroupVarint.h>
 #include <folly/Likely.h>
 #include <algorithm>
-#include <utility>
+
+#include "velox/common/encode/ByteStream.h"
 #include "velox/common/encode/UInt128.h"
-#include "velox/common/strings/ByteStream.h"
 
-namespace facebook {
+namespace facebook::velox {
 
 // Variable-length integer encoding, using a little-endian, base-128
 // representation.
@@ -49,6 +49,7 @@ class Varint {
   static UInt128 shift(uint64_t a, uint64_t b, uint32_t bBits) {
     return (UInt128(a) << bBits) | b;
   }
+
   static std::pair<uint64_t, uint64_t> unshift(UInt128 val, uint32_t bBits) {
     std::pair<uint64_t, uint64_t> p;
     p.second = val.lo() & ((static_cast<uint64_t>(1) << bBits) - 1);
@@ -108,19 +109,20 @@ class Varint {
     char buf[kMaxSize64];
     char* p = buf;
     encode(val, &p);
-    sink->append(folly::StringPiece(buf, p - buf));
+    sink->append(std::string_view(buf, p - buf));
   }
+
   static void encode128ToByteSink(UInt128 val, strings::ByteSink* sink) {
     char buf[kMaxSize128];
     char* p = buf;
     encode128(val, &p);
-    sink->append(folly::StringPiece(buf, p - buf));
+    sink->append(std::string_view(buf, p - buf));
   }
 
   // Returns true if decode can be called without causing a CHECK failure.
   // The pointers are not adjusted at all
-  static bool canDecode(folly::StringPiece src) {
-    src = src.subpiece(0, kMaxSize64);
+  static bool canDecode(std::string_view src) {
+    src = src.substr(0, kMaxSize64);
     return std::any_of(
         src.begin(), src.end(), [](char v) { return ~v & 0x80; });
   }
@@ -163,6 +165,7 @@ class Varint {
     *src = p;
     return val;
   }
+
   static UInt128 decode128(const char** src, int64_t max_size) {
     if (max_size > kMaxSize128) {
       // Varint-encoded numbers are at most 19 bytes, and we want to catch
@@ -184,17 +187,18 @@ class Varint {
     return val;
   }
 
-  // Decode a value from a StringPiece, and advance the StringPiece.
-  static uint64_t decode(folly::StringPiece* data) {
-    const char* p = data->start();
+  // Decode a value from a string_view, and advance it.
+  static uint64_t decode(std::string_view* data) {
+    const char* p = data->data();
     uint64_t val = decode(&p, data->size());
-    data->advance(p - data->start());
+    data->remove_prefix(p - data->data());
     return val;
   }
-  static UInt128 decode128(folly::StringPiece* data) {
-    const char* p = data->start();
+
+  static UInt128 decode128(std::string_view* data) {
+    const char* p = data->data();
     UInt128 val = decode128(&p, data->size());
-    data->advance(p - data->start());
+    data->remove_prefix(p - data->data());
     return val;
   }
 
@@ -203,13 +207,13 @@ class Varint {
     uint64_t val = 0;
     int32_t shift = 0;
     int32_t max_size = kMaxSize64;
-    folly::StringPiece chunk;
+    std::string_view chunk;
     int32_t remaining = 0;
     const char* p = nullptr;
     for (;;) {
       if (remaining == 0) {
         CHECK(src->next(&chunk));
-        p = chunk.start();
+        p = chunk.data();
         remaining = chunk.size();
         DCHECK_GT(remaining, 0);
       }
@@ -229,17 +233,18 @@ class Varint {
     }
     return val;
   }
+
   static UInt128 decode128FromByteSource(strings::ByteSource* src) {
     UInt128 val = 0;
     int32_t shift = 0;
     int32_t max_size = kMaxSize128;
-    folly::StringPiece chunk;
+    std::string_view chunk;
     int32_t remaining = 0;
     const char* p = nullptr;
     for (;;) {
       if (remaining == 0) {
         CHECK(src->next(&chunk));
-        p = chunk.start();
+        p = chunk.data();
         remaining = chunk.size();
         DCHECK_GT(remaining, 0);
       }
@@ -283,32 +288,30 @@ class ZigZag {
   }
 };
 
-namespace internal {
+namespace detail {
 class ByteSinkAppender {
  public:
   /* implicit */ ByteSinkAppender(strings::ByteSink* out) : out_(out) {}
-  void operator()(folly::StringPiece sp) {
+  void operator()(std::string_view sp) {
     out_->append(sp.data(), sp.size());
   }
 
  private:
   strings::ByteSink* out_;
 };
-} // namespace internal
+} // namespace detail
 
 // Import GroupVarint encoding / decoding code from folly
 
 typedef folly::GroupVarint32 GroupVarint32;
 typedef folly::GroupVarint64 GroupVarint64;
 
-typedef folly::GroupVarintEncoder<uint32_t, internal::ByteSinkAppender>
+typedef folly::GroupVarintEncoder<uint32_t, detail::ByteSinkAppender>
     GroupVarint32Encoder;
-typedef folly::GroupVarintEncoder<uint64_t, internal::ByteSinkAppender>
+typedef folly::GroupVarintEncoder<uint64_t, detail::ByteSinkAppender>
     GroupVarint64Encoder;
 
 typedef folly::GroupVarintDecoder<uint32_t> GroupVarint32Decoder;
 typedef folly::GroupVarintDecoder<uint64_t> GroupVarint64Decoder;
 
-} // namespace facebook
-
-#endif /* FACEBOOK_COMMON_ENCODE_CODING_H_ */
+} // namespace facebook::velox
diff --git a/velox/common/encode/UInt128.h b/velox/common/encode/UInt128.h
index 8167e1fe5eee..45c879e51525 100644
--- a/velox/common/encode/UInt128.h
+++ b/velox/common/encode/UInt128.h
@@ -108,12 +108,7 @@ class UInt128 {
     return UInt128(~hi_, ~lo_);
   }
 
-  bool operator==(UInt128 other) const {
-    return hi_ == other.hi_ && lo_ == other.lo_;
-  }
-  bool operator!=(UInt128 other) const {
-    return !(*this == other);
-  }
+  bool operator==(const UInt128& other) const = default;
 
  private:
   uint64_t hi_;
diff --git a/velox/common/encode/tests/Base64Test.cpp b/velox/common/encode/tests/Base64Test.cpp
index 37ddcf8240f8..bc78bd6c5019 100644
--- a/velox/common/encode/tests/Base64Test.cpp
+++ b/velox/common/encode/tests/Base64Test.cpp
@@ -25,27 +25,20 @@ namespace facebook::velox::encoding {
 class Base64Test : public ::testing::Test {};
 
 TEST_F(Base64Test, fromBase64) {
-  EXPECT_EQ(
-      "Hello, World!",
-      Base64::decode(folly::StringPiece("SGVsbG8sIFdvcmxkIQ==")));
+  EXPECT_EQ("Hello, World!", Base64::decode("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==")));
+      Base64::decode("QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4="));
+  EXPECT_EQ("Simple text", Base64::decode("U2ltcGxlIHRleHQ="));
+  EXPECT_EQ("1234567890", Base64::decode("MTIzNDU2Nzg5MA=="));
 
   // Check encoded strings without padding
-  EXPECT_EQ(
-      "Hello, World!",
-      Base64::decode(folly::StringPiece("SGVsbG8sIFdvcmxkIQ")));
+  EXPECT_EQ("Hello, World!", Base64::decode("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")));
+      Base64::decode("QmFzZTY0IGVuY29kaW5nIGlzIGZ1bi4"));
+  EXPECT_EQ("Simple text", Base64::decode("U2ltcGxlIHRleHQ"));
+  EXPECT_EQ("1234567890", Base64::decode("MTIzNDU2Nzg5MA"));
 }
 
 TEST_F(Base64Test, calculateDecodedSizeProperSize) {
@@ -107,4 +100,75 @@ TEST_F(Base64Test, countsPaddingCorrectly) {
   EXPECT_EQ(1, Base64::numPadding("ABC=", 4));
   EXPECT_EQ(2, Base64::numPadding("AB==", 4));
 }
+
+TEST_F(Base64Test, calculateMimeDecodedSize) {
+  EXPECT_EQ(0, Base64::calculateMimeDecodedSize("", 0).value());
+  EXPECT_EQ(0, Base64::calculateMimeDecodedSize("#", 1).value());
+  EXPECT_EQ(3, Base64::calculateMimeDecodedSize("TWFu", 4).value());
+  EXPECT_EQ(1, Base64::calculateMimeDecodedSize("AQ==", 4).value());
+  EXPECT_EQ(2, Base64::calculateMimeDecodedSize("TWE=", 4).value());
+  EXPECT_EQ(3, Base64::calculateMimeDecodedSize("TWFu\r\n", 6).value());
+  EXPECT_EQ(3, Base64::calculateMimeDecodedSize("!TW!Fu!", 7).value());
+  EXPECT_EQ(1, Base64::calculateMimeDecodedSize("TQ", 2).value());
+  EXPECT_EQ(
+      Base64::calculateMimeDecodedSize("A", 1).error(),
+      Status::UserError(
+          "Input should at least have 2 bytes for base64 bytes."));
+}
+
+TEST_F(Base64Test, decodeMime) {
+  auto decodeMime = [](const std::string& in) {
+    size_t decSize =
+        Base64::calculateMimeDecodedSize(in.data(), in.size()).value();
+    std::string out(decSize, '\0');
+    auto result = Base64::decodeMime(in.data(), in.size(), out.data());
+    if (!result.ok()) {
+      VELOX_USER_FAIL(result.message());
+    }
+    return out;
+  };
+  EXPECT_EQ("", decodeMime(""));
+  EXPECT_EQ("Man", decodeMime("TWFu"));
+  EXPECT_EQ("ManMan", decodeMime("TWFu\r\nTWFu"));
+  EXPECT_EQ("\x01", decodeMime("AQ=="));
+  EXPECT_EQ("\xff\xee", decodeMime("/+4="));
+  VELOX_ASSERT_USER_THROW(
+      decodeMime("QUFBx"), "Last unit does not have enough valid bits");
+  VELOX_ASSERT_USER_THROW(
+      decodeMime("xx=y"), "Input byte array has wrong 4-byte ending unit");
+  VELOX_ASSERT_USER_THROW(
+      decodeMime("xx="), "Input byte array has wrong 4-byte ending unit");
+  VELOX_ASSERT_USER_THROW(
+      decodeMime("QUFB="), "Input byte array has wrong 4-byte ending unit");
+  VELOX_ASSERT_USER_THROW(
+      decodeMime("AQ==y"), "Input byte array has incorrect ending");
+}
+
+TEST_F(Base64Test, calculateMimeEncodedSize) {
+  EXPECT_EQ(0, Base64::calculateMimeEncodedSize(0));
+  EXPECT_EQ(8, Base64::calculateMimeEncodedSize(4));
+  EXPECT_EQ(76, Base64::calculateMimeEncodedSize(57));
+  EXPECT_EQ(82, Base64::calculateMimeEncodedSize(58));
+  EXPECT_EQ(274, Base64::calculateMimeEncodedSize(200));
+}
+
+TEST_F(Base64Test, encodeMime) {
+  auto encodeMime = [](const std::string& in) {
+    size_t len = Base64::calculateMimeEncodedSize(in.size());
+    std::string out(len, '\0');
+    Base64::encodeMime(in.data(), in.size(), out.data());
+    return out;
+  };
+  EXPECT_EQ("", encodeMime(""));
+  EXPECT_EQ("TWFu", encodeMime("Man"));
+  EXPECT_EQ("AQ==", encodeMime("\x01"));
+  EXPECT_EQ("/+4=", encodeMime("\xff\xee"));
+  EXPECT_EQ(
+      "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB",
+      encodeMime(std::string(57, 'A')));
+  EXPECT_EQ(
+      "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\r\nQQ==",
+      encodeMime(std::string(58, 'A')));
+}
+
 } // namespace facebook::velox::encoding
diff --git a/velox/common/encode/tests/CMakeLists.txt b/velox/common/encode/tests/CMakeLists.txt
index 5a72d9c55382..9acd50159563 100644
--- a/velox/common/encode/tests/CMakeLists.txt
+++ b/velox/common/encode/tests/CMakeLists.txt
@@ -17,9 +17,5 @@ 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
-    velox_status
-    GTest::gtest
-    GTest::gtest_main)
+  PRIVATE velox_encode velox_exception velox_status velox_common_base GTest::gtest GTest::gtest_main
+)
diff --git a/velox/common/encode/tests/ZigZagTest.cpp b/velox/common/encode/tests/ZigZagTest.cpp
index a69d6326056d..e7a02add7608 100644
--- a/velox/common/encode/tests/ZigZagTest.cpp
+++ b/velox/common/encode/tests/ZigZagTest.cpp
@@ -15,7 +15,6 @@
  */
 
 #include <gtest/gtest.h>
-#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/encode/Coding.h"
 #include "velox/type/HugeInt.h"
 
diff --git a/velox/common/file/CMakeLists.txt b/velox/common/file/CMakeLists.txt
index 31d9f1ebe0ff..b89a4e3a38e8 100644
--- a/velox/common/file/CMakeLists.txt
+++ b/velox/common/file/CMakeLists.txt
@@ -14,16 +14,12 @@
 
 # for generated headers
 include_directories(.)
-velox_add_library(
-  velox_file
-  File.cpp
-  FileInputStream.cpp
-  FileSystems.cpp
-  Utils.cpp)
+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_buffer velox_common_base fmt::fmt glog::glog)
+  PRIVATE velox_buffer velox_common_base fmt::fmt glog::glog
+)
 
 if(${VELOX_BUILD_TESTING} OR ${VELOX_BUILD_TEST_UTILS})
   add_subdirectory(tests)
diff --git a/velox/common/file/File.cpp b/velox/common/file/File.cpp
index c1f1e8982737..668cba32cede 100644
--- a/velox/common/file/File.cpp
+++ b/velox/common/file/File.cpp
@@ -60,10 +60,10 @@ T getAttribute(
 std::string ReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   std::string buf;
   buf.resize(length);
-  auto res = pread(offset, length, buf.data(), stats);
+  auto res = pread(offset, length, buf.data(), fileStorageContext);
   buf.resize(res.size());
   return buf;
 }
@@ -71,7 +71,7 @@ std::string ReadFile::pread(
 uint64_t ReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   auto fileSize = size();
   uint64_t numRead = 0;
   if (offset >= fileSize) {
@@ -81,7 +81,7 @@ uint64_t ReadFile::preadv(
     auto copySize = std::min<size_t>(range.size(), fileSize - offset);
     // NOTE: skip the gap in case of coalesce io.
     if (range.data() != nullptr) {
-      pread(offset, copySize, range.data(), stats);
+      pread(offset, copySize, range.data(), fileStorageContext);
     }
     offset += copySize;
     numRead += copySize;
@@ -92,18 +92,21 @@ uint64_t ReadFile::preadv(
 uint64_t ReadFile::preadv(
     folly::Range<const common::Region*> regions,
     folly::Range<folly::IOBuf*> iobufs,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) 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(), stats);
+    pread(
+        region.offset,
+        region.length,
+        output.writableData(),
+        fileStorageContext);
     output.append(region.length);
     length += region.length;
   }
-
   return length;
 }
 
@@ -111,7 +114,7 @@ std::string_view InMemoryReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   bytesRead_ += length;
   memcpy(buf, file_.data() + offset, length);
   return {static_cast<char*>(buf), length};
@@ -120,7 +123,7 @@ std::string_view InMemoryReadFile::pread(
 std::string InMemoryReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   bytesRead_ += length;
   return std::string(file_.data() + offset, length);
 }
@@ -202,7 +205,7 @@ std::string_view LocalReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   preadInternal(offset, length, static_cast<char*>(buf));
   return {static_cast<char*>(buf), length};
 }
@@ -210,7 +213,7 @@ std::string_view LocalReadFile::pread(
 uint64_t LocalReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   // Dropped bytes sized so that a typical dropped range of 50K is not
   // too many iovecs.
   static thread_local std::vector<char> droppedBytes(16 * 1024);
@@ -267,17 +270,18 @@ uint64_t LocalReadFile::preadv(
 folly::SemiFuture<uint64_t> LocalReadFile::preadvAsync(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   if (!executor_) {
-    return ReadFile::preadvAsync(offset, buffers, stats);
+    return ReadFile::preadvAsync(offset, buffers, fileStorageContext);
   }
   auto [promise, future] = folly::makePromiseContract<uint64_t>();
   executor_->add([this,
                   _promise = std::move(promise),
                   _offset = offset,
                   _buffers = buffers,
-                  _stats = stats]() mutable {
-    auto delegateFuture = ReadFile::preadvAsync(_offset, _buffers, _stats);
+                  _fileStorageContext = fileStorageContext]() mutable {
+    auto delegateFuture =
+        ReadFile::preadvAsync(_offset, _buffers, _fileStorageContext);
     _promise.setTry(std::move(delegateFuture).getTry());
   });
   return std::move(future);
diff --git a/velox/common/file/File.h b/velox/common/file/File.h
index 18d1c264ca7a..6089915dffac 100644
--- a/velox/common/file/File.h
+++ b/velox/common/file/File.h
@@ -37,14 +37,32 @@
 #include <folly/Executor.h>
 #include <folly/Range.h>
 #include <folly/futures/Future.h>
+#include <folly/io/IOBuf.h>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/Region.h"
 #include "velox/common/io/IoStatistics.h"
 
+#include <folly/container/F14Map.h>
+
 namespace facebook::velox {
 
+struct FileStorageContext {
+  /// Stats for IO operations
+  filesystems::File::IoStats* ioStats{nullptr};
+
+  /// Options for file read operations
+  folly::F14FastMap<std::string, std::string> fileReadOps;
+
+  FileStorageContext() = default;
+
+  FileStorageContext(
+      filesystems::File::IoStats* stats,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {})
+      : ioStats(stats), fileReadOps(std::move(fileReadOps)) {}
+};
+
 // A read-only file.  All methods in this object should be thread safe.
 class ReadFile {
  public:
@@ -52,16 +70,12 @@ class ReadFile {
 
   // Reads the data at [offset, offset + length) into the provided pre-allocated
   // buffer 'buf'. The bytes are returned as a string_view pointing to 'buf'.
-  //
-  // 'stats' is an IoStatistics pointer passed in by the caller to collect stats
-  // for this read operation.
-  //
   // This method should be thread safe.
   virtual std::string_view pread(
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const = 0;
+      const FileStorageContext& fileStorageContext = {}) const = 0;
 
   // Same as above, but returns owned data directly.
   //
@@ -69,20 +83,16 @@ class ReadFile {
   virtual std::string pread(
       uint64_t offset,
       uint64_t length,
-      filesystems::File::IoStats* stats = nullptr) const;
+      const FileStorageContext& fileStorageContext = {}) const;
 
   // Reads starting at 'offset' into the memory referenced by the
   // Ranges in 'buffers'. The buffers are filled left to right. A
   // buffer with nullptr data will cause its size worth of bytes to be skipped.
-  //
-  // 'stats' is an IoStatistics pointer passed in by the caller to collect stats
-  // for this read operation.
-  //
   // This method should be thread safe.
   virtual uint64_t preadv(
       uint64_t /*offset*/,
       const std::vector<folly::Range<char*>>& /*buffers*/,
-      filesystems::File::IoStats* stats = nullptr) const;
+      const FileStorageContext& fileStorageContext = {}) const;
 
   // Vectorized read API. Implementations can coalesce and parallelize.
   // The offsets don't need to be sorted.
@@ -93,30 +103,23 @@ class ReadFile {
   // 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).
-  //
-  // 'stats' is an IoStatistics pointer passed in by the caller to collect stats
-  // for this read operation.
-  //
   // This method should be thread safe.
   virtual uint64_t preadv(
       folly::Range<const common::Region*> regions,
       folly::Range<folly::IOBuf*> iobufs,
-      filesystems::File::IoStats* stats = nullptr) const;
+      const FileStorageContext& fileStorageContext = {}) 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.
-  ///
-  /// 'stats' is an IoStatistics pointer passed in by the caller to collect
-  /// stats for this read operation.
-  ///
   /// This method should be thread safe.
   virtual folly::SemiFuture<uint64_t> preadvAsync(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const {
+      const FileStorageContext& fileStorageContext = {}) const {
     try {
-      return folly::SemiFuture<uint64_t>(preadv(offset, buffers, stats));
+      return folly::SemiFuture<uint64_t>(
+          preadv(offset, buffers, fileStorageContext));
     } catch (const std::exception& e) {
       return folly::makeSemiFuture<uint64_t>(e);
     }
@@ -240,12 +243,12 @@ class InMemoryReadFile : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileStorageContext& fileStorageContext = {}) const override;
 
   std::string pread(
       uint64_t offset,
       uint64_t length,
-      filesystems::File::IoStats* stats) const override;
+      const FileStorageContext& fileStorageContext = {}) const override;
 
   uint64_t size() const final {
     return file_.size();
@@ -311,19 +314,19 @@ class LocalReadFile final : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileStorageContext& fileStorageContext = {}) const final;
 
   uint64_t size() const final;
 
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileStorageContext& fileStorageContext = {}) const final;
 
   folly::SemiFuture<uint64_t> preadvAsync(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileStorageContext& fileStorageContext = {}) const override;
 
   bool hasPreadvAsync() const override {
     return executor_ != nullptr;
diff --git a/velox/common/file/FileSystems.cpp b/velox/common/file/FileSystems.cpp
index aa738b6a43ba..d5d07ceb943b 100644
--- a/velox/common/file/FileSystems.cpp
+++ b/velox/common/file/FileSystems.cpp
@@ -17,6 +17,7 @@
 #include "velox/common/file/FileSystems.h"
 #include <folly/executors/CPUThreadPoolExecutor.h>
 #include <folly/synchronization/CallOnce.h>
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/file/File.h"
 
@@ -90,7 +91,7 @@ class LocalFileSystem : public FileSystem {
                       std::max(
                           1,
                           static_cast<int32_t>(
-                              std::thread::hardware_concurrency() / 2)),
+                              folly::hardware_concurrency() / 2)),
                       std::make_shared<folly::NamedThreadFactory>(
                           "LocalReadahead"))
                 : nullptr) {}
@@ -229,7 +230,7 @@ class LocalFileSystem : public FileSystem {
     // 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("/") == 0 || filePath.find(kFileScheme) == 0;
+      return filePath.starts_with('/') || filePath.starts_with(kFileScheme);
     };
   }
 
diff --git a/velox/common/file/FileSystems.h b/velox/common/file/FileSystems.h
index a1173190ba56..4362dcea4914 100644
--- a/velox/common/file/FileSystems.h
+++ b/velox/common/file/FileSystems.h
@@ -17,6 +17,7 @@
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/file/TokenProvider.h"
 #include "velox/common/memory/MemoryPool.h"
 
 #include <functional>
@@ -47,10 +48,10 @@ struct FileOptions {
   /// etc.
   static constexpr folly::StringPiece kFileCreateConfig{"file-create-config"};
 
-  std::unordered_map<std::string, std::string> values;
+  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;
+  std::optional<int64_t> fileSize{};
 
   /// Whether to create parent directories if they don't exist.
   ///
@@ -84,6 +85,13 @@ struct FileOptions {
   /// A hint to the file system for which region size of the file should be
   /// read. Specifically, the read length.
   std::optional<int64_t> readRangeHint{std::nullopt};
+
+  /// A token provider that can be used to get tokens for accessing the file.
+  std::shared_ptr<TokenProvider> tokenProvider{nullptr};
+
+  /// File read operations metadata that can be passed to the underlying file
+  /// system for tracking and logging purposes.
+  folly::F14FastMap<std::string, std::string> fileReadOps{};
 };
 
 /// Defines directory options
diff --git a/velox/common/file/PlainUserNameTokenProvider.h b/velox/common/file/PlainUserNameTokenProvider.h
new file mode 100644
index 000000000000..acbc8c38748c
--- /dev/null
+++ b/velox/common/file/PlainUserNameTokenProvider.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 <memory>
+#include "velox/common/file/TokenProvider.h"
+
+namespace facebook::velox::filesystems {
+
+class PlainUserNameAccessToken : public filesystems::AccessToken {
+ public:
+  explicit PlainUserNameAccessToken(const std::string& user) : user_(user) {}
+  ~PlainUserNameAccessToken() override = default;
+  std::string getUser() const {
+    return user_;
+  }
+
+ private:
+  std::string user_;
+};
+
+class PlainUserNameTokenProvider : public filesystems::TokenProvider {
+ public:
+  explicit PlainUserNameTokenProvider(const std::string& user) : user_(user) {}
+  bool equals(const TokenProvider& other) const override {
+    auto* o = dynamic_cast<const PlainUserNameTokenProvider*>(&other);
+    return o && o->user_ == user_;
+  }
+  size_t hash() const override {
+    return std::hash<std::string>()(user_);
+  }
+  std::shared_ptr<filesystems::AccessToken> getToken(
+      const filesystems::AccessTokenKey& /*key*/) const override {
+    return std::make_shared<PlainUserNameAccessToken>(user_);
+  }
+
+ private:
+  std::string user_;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/common/file/Region.h b/velox/common/file/Region.h
index ae2ef9c8a2b2..5d588479b769 100644
--- a/velox/common/file/Region.h
+++ b/velox/common/file/Region.h
@@ -17,8 +17,13 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 #include <string_view>
 
+#include <fmt/format.h>
+
+#include "velox/common/base/SuccinctPrinter.h"
+
 namespace facebook::velox::common {
 
 /// Defines a disk region to read.
@@ -35,6 +40,14 @@ struct Region {
     return offset < other.offset ||
         (offset == other.offset && length < other.length);
   }
+
+  std::string toString() const {
+    return fmt::format(
+        "Region{{offset: {}, length: {}, label: {}}}",
+        offset,
+        succinctBytes(length),
+        label);
+  }
 };
 
 } // namespace facebook::velox::common
diff --git a/velox/common/file/TokenProvider.h b/velox/common/file/TokenProvider.h
new file mode 100644
index 000000000000..e262fe8d0b99
--- /dev/null
+++ b/velox/common/file/TokenProvider.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 <memory>
+#include <string>
+
+namespace facebook::velox::filesystems {
+
+/// Identifier for the file systems to implement to differentiate different
+/// tokens needed in the same query (user).  Such information usually needs to
+/// be passed down and stored in the ReadFile/WriteFile object of the specific
+/// file system.
+class AccessTokenKey {
+ public:
+  virtual ~AccessTokenKey() = default;
+};
+
+/// Abstract token each file system can implement and cast.
+class AccessToken {
+ public:
+  virtual ~AccessToken() = default;
+};
+
+/// Interface for providing access tokens to file systems.
+class TokenProvider {
+ public:
+  virtual ~TokenProvider() = default;
+
+  virtual bool equals(const TokenProvider& other) const = 0;
+  virtual size_t hash() const = 0;
+
+  virtual std::shared_ptr<AccessToken> getToken(
+      const AccessTokenKey& key) const = 0;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/common/file/Utils.h b/velox/common/file/Utils.h
index b19468fbe1fe..1d04d5608066 100644
--- a/velox/common/file/Utils.h
+++ b/velox/common/file/Utils.h
@@ -44,10 +44,6 @@ class CoalesceRegions {
       return lhs.begin_ == rhs.begin_ && lhs.end_ == rhs.end_;
     }
 
-    friend bool operator!=(const Iter& lhs, const Iter& rhs) {
-      return !(lhs == rhs);
-    }
-
     std::pair<RegionIter, RegionIter> operator*() const {
       return {begin_, end_};
     }
diff --git a/velox/common/file/tests/CMakeLists.txt b/velox/common/file/tests/CMakeLists.txt
index fb9ef6f73521..47b3c11e3d2b 100644
--- a/velox/common/file/tests/CMakeLists.txt
+++ b/velox/common/file/tests/CMakeLists.txt
@@ -12,15 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_file_test_utils TestUtils.cpp FaultyFile.cpp
-                                  FaultyFileSystem.cpp)
+add_library(velox_file_test_utils TestUtils.cpp FaultyFile.cpp FaultyFileSystem.cpp)
 
-target_link_libraries(
-  velox_file_test_utils
-  PUBLIC velox_file)
+target_link_libraries(velox_file_test_utils PUBLIC velox_file)
 
-add_executable(velox_file_test FileTest.cpp FileInputStreamTest.cpp
-                               UtilsTest.cpp)
+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
@@ -31,4 +27,5 @@ target_link_libraries(
     velox_temp_path
     GTest::gmock
     GTest::gtest
-    GTest::gtest_main)
+    GTest::gtest_main
+)
diff --git a/velox/common/file/tests/FaultyFile.cpp b/velox/common/file/tests/FaultyFile.cpp
index 17897fa99214..434028a6750d 100644
--- a/velox/common/file/tests/FaultyFile.cpp
+++ b/velox/common/file/tests/FaultyFile.cpp
@@ -34,7 +34,7 @@ std::string_view FaultyReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   if (injectionHook_ != nullptr) {
     FaultFileReadOperation op(path_, offset, length, buf);
     injectionHook_(&op);
@@ -42,13 +42,13 @@ std::string_view FaultyReadFile::pread(
       return std::string_view(static_cast<char*>(op.buf), op.length);
     }
   }
-  return delegatedFile_->pread(offset, length, buf, stats);
+  return delegatedFile_->pread(offset, length, buf, fileStorageContext);
 }
 
 uint64_t FaultyReadFile::preadv(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   if (injectionHook_ != nullptr) {
     FaultFileReadvOperation op(path_, offset, buffers);
     injectionHook_(&op);
@@ -56,16 +56,16 @@ uint64_t FaultyReadFile::preadv(
       return op.readBytes;
     }
   }
-  return delegatedFile_->preadv(offset, buffers, stats);
+  return delegatedFile_->preadv(offset, buffers, fileStorageContext);
 }
 
 folly::SemiFuture<uint64_t> FaultyReadFile::preadvAsync(
     uint64_t offset,
     const std::vector<folly::Range<char*>>& buffers,
-    filesystems::File::IoStats* stats) const {
+    const FileStorageContext& fileStorageContext) const {
   // TODO: add fault injection for async read later.
   if (delegatedFile_->hasPreadvAsync() || executor_ == nullptr) {
-    return delegatedFile_->preadvAsync(offset, buffers, stats);
+    return delegatedFile_->preadvAsync(offset, buffers, fileStorageContext);
   }
   auto promise = std::make_unique<folly::Promise<uint64_t>>();
   folly::SemiFuture<uint64_t> future = promise->getSemiFuture();
@@ -73,9 +73,9 @@ folly::SemiFuture<uint64_t> FaultyReadFile::preadvAsync(
                   _promise = std::move(promise),
                   _offset = offset,
                   _buffers = buffers,
-                  _stats = stats]() {
+                  _fileStorageContext = fileStorageContext]() {
     auto delegateFuture =
-        delegatedFile_->preadvAsync(_offset, _buffers, _stats);
+        delegatedFile_->preadvAsync(_offset, _buffers, _fileStorageContext);
     _promise->setValue(delegateFuture.wait().value());
   });
   return future;
diff --git a/velox/common/file/tests/FaultyFile.h b/velox/common/file/tests/FaultyFile.h
index 2b4818bd7a16..8fac903b0f6e 100644
--- a/velox/common/file/tests/FaultyFile.h
+++ b/velox/common/file/tests/FaultyFile.h
@@ -29,7 +29,7 @@ class FaultyReadFile : public ReadFile {
       FileFaultInjectionHook injectionHook,
       folly::Executor* executor);
 
-  ~FaultyReadFile() override{};
+  ~FaultyReadFile() override {}
 
   uint64_t size() const override {
     return delegatedFile_->size();
@@ -39,12 +39,12 @@ class FaultyReadFile : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileStorageContext& fileStorageContext = {}) const override;
 
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileStorageContext& fileStorageContext = {}) const override;
 
   uint64_t memoryUsage() const override {
     return delegatedFile_->memoryUsage();
@@ -72,7 +72,7 @@ class FaultyReadFile : public ReadFile {
   folly::SemiFuture<uint64_t> preadvAsync(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override;
+      const FileStorageContext& fileStorageContext = {}) const override;
 
  private:
   const std::string path_;
@@ -88,7 +88,7 @@ class FaultyWriteFile : public WriteFile {
       std::shared_ptr<WriteFile> delegatedFile,
       FileFaultInjectionHook injectionHook);
 
-  ~FaultyWriteFile() override{};
+  ~FaultyWriteFile() override {}
 
   void append(std::string_view data) override;
 
diff --git a/velox/common/file/tests/FaultyFileSystem.h b/velox/common/file/tests/FaultyFileSystem.h
index 1dbd698df66b..c14cc7201ee1 100644
--- a/velox/common/file/tests/FaultyFileSystem.h
+++ b/velox/common/file/tests/FaultyFileSystem.h
@@ -176,7 +176,7 @@ class FaultyFileSystem : public FileSystem {
   mutable std::mutex mu_;
   std::optional<FileInjections> fileInjections_;
   std::optional<FileSystemInjections> fsInjections_;
-  folly::Executor* executor_;
+  folly::Executor* executor_{nullptr};
 };
 
 /// Registers the faulty filesystem.
diff --git a/velox/common/file/tests/FileTest.cpp b/velox/common/file/tests/FileTest.cpp
index 6194fbcc35ba..fb819d63e90c 100644
--- a/velox/common/file/tests/FileTest.cpp
+++ b/velox/common/file/tests/FileTest.cpp
@@ -16,6 +16,7 @@
 
 #include <fcntl.h>
 #include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/system/HardwareConcurrency.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/File.h"
@@ -168,8 +169,9 @@ TEST(InMemoryFile, preadv) {
   std::vector<std::string> values;
   values.reserve(iobufs.size());
   for (auto& iobuf : iobufs) {
-    values.push_back(std::string{
-        reinterpret_cast<const char*>(iobuf.data()), iobuf.length()});
+    values.push_back(
+        std::string{
+            reinterpret_cast<const char*>(iobuf.data()), iobuf.length()});
   }
 
   EXPECT_EQ(expected, values);
@@ -187,9 +189,7 @@ class LocalFileTest : public ::testing::TestWithParam<bool> {
   const bool useFaultyFs_;
   const std::unique_ptr<folly::CPUThreadPoolExecutor> executor_ =
       std::make_unique<folly::CPUThreadPoolExecutor>(
-          std::max(
-              1,
-              static_cast<int32_t>(std::thread::hardware_concurrency() / 2)),
+          std::max(1, static_cast<int32_t>(folly::hardware_concurrency() / 2)),
           std::make_shared<folly::NamedThreadFactory>(
               "LocalFileReadAheadTest"));
 };
diff --git a/velox/common/file/tests/PlainUserNameTokenProviderTest.cpp b/velox/common/file/tests/PlainUserNameTokenProviderTest.cpp
new file mode 100644
index 000000000000..a49c749bdb93
--- /dev/null
+++ b/velox/common/file/tests/PlainUserNameTokenProviderTest.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/file/PlainUserNameTokenProvider.h"
+#include <gtest/gtest.h>
+#include "velox/common/file/TokenProvider.h"
+
+using namespace ::testing;
+namespace facebook::velox::filesystems {
+TEST(PlainUserNameTokenProviderTest, testTokenProviderUserName) {
+  filesystems::AccessTokenKey key;
+  auto tokenProvider =
+      std::make_shared<PlainUserNameTokenProvider>("test_user");
+  auto baseToken = tokenProvider->getToken(key);
+  auto userToken =
+      std::dynamic_pointer_cast<PlainUserNameAccessToken>(baseToken);
+  ASSERT_EQ(userToken->getUser(), "test_user");
+}
+
+TEST(PlainUserNameTokenProviderTest, testTokenProviderEquals) {
+  auto tokenProvider1 =
+      std::make_shared<PlainUserNameTokenProvider>("test_user_1");
+  auto tokenProvider2 = tokenProvider1;
+  auto tokenProvider3 =
+      std::make_shared<PlainUserNameTokenProvider>("test_user_1");
+  auto tokenProvider4 =
+      std::make_shared<PlainUserNameTokenProvider>("test_user_2");
+  ASSERT_TRUE(tokenProvider1->equals(*tokenProvider2));
+  ASSERT_TRUE(tokenProvider1->equals(*tokenProvider3));
+  ASSERT_FALSE(tokenProvider1->equals(*tokenProvider4));
+}
+
+TEST(PlainUserNameTokenProviderTest, testTokenProviderHash) {
+  auto tokenProvider1 =
+      std::make_shared<PlainUserNameTokenProvider>("test_user_1");
+  auto tokenProvider2 =
+      std::make_shared<PlainUserNameTokenProvider>("test_user_1");
+  auto tokenProvider3 =
+      std::make_shared<PlainUserNameTokenProvider>("test_user_2");
+  ASSERT_EQ(tokenProvider1->hash(), tokenProvider2->hash());
+  ASSERT_NE(tokenProvider1->hash(), tokenProvider3->hash());
+}
+} // namespace facebook::velox::filesystems
diff --git a/velox/common/file/tests/UtilsTest.cpp b/velox/common/file/tests/UtilsTest.cpp
index a2b2d6ee5a04..f7d2e1ffa8a3 100644
--- a/velox/common/file/tests/UtilsTest.cpp
+++ b/velox/common/file/tests/UtilsTest.cpp
@@ -17,6 +17,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "velox/common/file/Region.h"
 #include "velox/common/file/Utils.h"
 #include "velox/common/file/tests/TestUtils.h"
 
@@ -98,11 +99,12 @@ auto getReader(
           /* minTailRoom*/ 0);
 
       for (size_t i = 1; i < size; ++i) {
-        head->appendToChain(folly::IOBuf::copyBuffer(
-            buf.data() + offset + i,
-            /* size */ 1,
-            /* headroom */ 0,
-            /* minTailRoom*/ 0));
+        head->appendToChain(
+            folly::IOBuf::copyBuffer(
+                buf.data() + offset + i,
+                /* size */ 1,
+                /* headroom */ 0,
+                /* minTailRoom*/ 0));
       }
       return head;
     } else {
@@ -289,3 +291,19 @@ INSTANTIATE_TEST_SUITE_P(
     ReadToIOBufsTest,
     ValuesIn(
         std::vector<bool /* Should generated chained IOBuf */>({false, true})));
+
+TEST(RegionTest, toString) {
+  EXPECT_EQ(Region(0, 0).toString(), "Region{offset: 0, length: 0B, label: }");
+  EXPECT_EQ(
+      Region(100, 256).toString(),
+      "Region{offset: 100, length: 256B, label: }");
+  EXPECT_EQ(
+      Region(1024, 1024, "test").toString(),
+      "Region{offset: 1024, length: 1.00KB, label: test}");
+  EXPECT_EQ(
+      Region(0, 1'048'576, "stream").toString(),
+      "Region{offset: 0, length: 1.00MB, label: stream}");
+  EXPECT_EQ(
+      Region(12345, 1'073'741'824).toString(),
+      "Region{offset: 12345, length: 1.00GB, label: }");
+}
diff --git a/scripts/docs-requirements.txt b/velox/common/future/CMakeLists.txt
similarity index 91%
rename from scripts/docs-requirements.txt
rename to velox/common/future/CMakeLists.txt
index 955db01b172d..a598690b32e5 100644
--- a/scripts/docs-requirements.txt
+++ b/velox/common/future/CMakeLists.txt
@@ -11,8 +11,4 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-sphinx
-sphinx-tabs
-breathe
-sphinx_rtd_theme
-chardet
+velox_install_library_headers()
diff --git a/velox/common/future/VeloxPromise.h b/velox/common/future/VeloxPromise.h
index ea0d02fbef9c..7ac170a2fc11 100644
--- a/velox/common/future/VeloxPromise.h
+++ b/velox/common/future/VeloxPromise.h
@@ -28,12 +28,15 @@ class VeloxPromise : public folly::Promise<T> {
   VeloxPromise() : folly::Promise<T>() {}
 
   explicit VeloxPromise(const std::string& context)
-      : folly::Promise<T>(), context_(context) {}
+      : folly::Promise<T>(), context_(context) {
+    if (context.empty()) {
+      LOG(WARNING)
+          << "PROMISE: VeloxPromise must be constructed with a context.";
+    }
+  }
 
-  VeloxPromise(
-      folly::futures::detail::EmptyConstruct,
-      const std::string& context) noexcept
-      : folly::Promise<T>(folly::Promise<T>::makeEmpty()), context_(context) {}
+  explicit VeloxPromise(folly::futures::detail::EmptyConstruct) noexcept
+      : folly::Promise<T>(folly::Promise<T>::makeEmpty()) {}
 
   ~VeloxPromise() {
     if (!this->isFulfilled()) {
@@ -42,7 +45,7 @@ class VeloxPromise : public folly::Promise<T> {
     }
   }
 
-  explicit VeloxPromise(VeloxPromise<T>&& other) noexcept
+  VeloxPromise(VeloxPromise<T>&& other) noexcept
       : folly::Promise<T>(std::move(other)),
         context_(std::move(other.context_)) {}
 
@@ -52,8 +55,8 @@ class VeloxPromise : public folly::Promise<T> {
     return *this;
   }
 
-  static VeloxPromise makeEmpty(const std::string& context = "") noexcept {
-    return VeloxPromise<T>(folly::futures::detail::EmptyConstruct{}, context);
+  static VeloxPromise makeEmpty() noexcept {
+    return VeloxPromise<T>(folly::futures::detail::EmptyConstruct{});
   }
 
  private:
@@ -65,8 +68,14 @@ using ContinuePromise = VeloxPromise<folly::Unit>;
 using ContinueFuture = folly::SemiFuture<folly::Unit>;
 
 /// Equivalent of folly's makePromiseContract for VeloxPromise.
+///
+/// NOTE: When you already have a valid promise, just call
+/// Promise::getSemiFuture() on it to get the future, instead of using this
+/// function to overwrite the promise.  Overwriting valid promise would cause
+/// exception throwing and stack unwinding thus performance issue.  See
+/// https://github.com/prestodb/presto/issues/26094 for details.
 static inline std::pair<ContinuePromise, ContinueFuture>
-makeVeloxContinuePromiseContract(const std::string& promiseContext = "") {
+makeVeloxContinuePromiseContract(const std::string& promiseContext) {
   auto p = ContinuePromise(promiseContext);
   auto f = p.getSemiFuture();
   return std::make_pair(std::move(p), std::move(f));
diff --git a/velox/common/fuzzer/CMakeLists.txt b/velox/common/fuzzer/CMakeLists.txt
index 1ecff4348f55..d2e3663b73d0 100644
--- a/velox/common/fuzzer/CMakeLists.txt
+++ b/velox/common/fuzzer/CMakeLists.txt
@@ -23,7 +23,8 @@ velox_link_libraries(
   Folly::folly
   velox_type
   velox_common_fuzzer_util
-  velox_functions_prestosql)
+  velox_functions_prestosql
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/common/fuzzer/ConstrainedGenerators.cpp b/velox/common/fuzzer/ConstrainedGenerators.cpp
index c5c65dbc5031..2e5daddc1742 100644
--- a/velox/common/fuzzer/ConstrainedGenerators.cpp
+++ b/velox/common/fuzzer/ConstrainedGenerators.cpp
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-#include <boost/random/uniform_int_distribution.hpp>
-#include <cfloat>
-
 #include "velox/common/fuzzer/ConstrainedGenerators.h"
+#include <boost/random/uniform_int_distribution.hpp>
 #include "velox/common/fuzzer/Utils.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/SetDigest.h"
 #include "velox/functions/lib/TDigest.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
 
@@ -49,13 +49,21 @@ folly::json::serialization_opts getSerializationOptions(
   folly::json::serialization_opts opts;
   opts.allow_non_string_keys = true;
   opts.allow_nan_inf = true;
+  opts.sort_keys = true;
   if (makeRandomVariation) {
     opts.convert_int_keys = rand<bool>(rng);
     opts.pretty_formatting = rand<bool>(rng);
     opts.pretty_formatting_indent_width = rand<uint32_t>(rng, 0, 4);
     opts.encode_non_ascii = rand<bool>(rng);
-    opts.sort_keys = rand<bool>(rng);
     opts.skip_invalid_utf8 = rand<bool>(rng);
+
+    // With 50% chance, sort object keys in reverse order.
+    if (rand<bool>(rng)) {
+      opts.sort_keys_by = [](folly::dynamic const& left,
+                             folly::dynamic const& right) {
+        return right < left;
+      };
+    }
   }
   return opts;
 }
@@ -104,9 +112,9 @@ folly::dynamic JsonInputGenerator::convertVariantToDynamic(
     case TypeKind::BIGINT:
       return convertVariantToDynamicPrimitive<TypeKind::BIGINT>(object);
     case TypeKind::REAL:
-      return convertVariantToDynamicPrimitive<TypeKind::REAL>(object);
+      return convertVariantToDynamicFloatingPoint<TypeKind::REAL>(object);
     case TypeKind::DOUBLE:
-      return convertVariantToDynamicPrimitive<TypeKind::DOUBLE>(object);
+      return convertVariantToDynamicFloatingPoint<TypeKind::DOUBLE>(object);
     case TypeKind::VARCHAR:
       return convertVariantToDynamicPrimitive<TypeKind::VARCHAR>(object);
     case TypeKind::VARBINARY:
@@ -261,22 +269,94 @@ variant TDigestInputGenerator::generate() {
     return variant::null(type_->kind());
   }
   velox::functions::TDigest<> digest;
-  double compression = rand<double>(rng_, 10.0, 100.0);
+  double compression = rand<double>(rng_, 10.0, 1000.0);
   digest.setCompression(compression);
   std::vector<int16_t> positions;
-  for (int i = 0; i < 10; i++) {
-    double value = rand<double>(rng_, 0.0, 100.0);
-    int64_t weight = rand<int64_t>(rng_, 1, 100);
+  static boost::random::uniform_real_distribution<double> valueDist(
+      0.0, 1000.0);
+  static boost::random::uniform_int_distribution<int64_t> weightDist(1, 1000);
+  for (int i = 0; i < 100; i++) {
+    double value = valueDist(rng_);
+    int64_t weight = weightDist(rng_);
     digest.add(positions, value, weight);
   }
   digest.compress(positions);
   size_t byteSize = digest.serializedByteSize();
   std::string serializedDigest(byteSize, '\0');
   digest.serialize(&serializedDigest[0]);
-  StringView serializedView(serializedDigest.data(), serializedDigest.size());
   return variant::create<TypeKind::VARBINARY>(serializedDigest);
 }
 
+SetDigestInputGenerator::SetDigestInputGenerator(
+    size_t seed,
+    const TypePtr& type,
+    double nullRatio)
+    : AbstractInputGenerator(seed, type, nullptr, nullRatio),
+      pool_(velox::memory::memoryManager()->addLeafPool()),
+      allocator_(std::make_unique<HashStringAllocator>(pool_.get())) {
+  // SetDigest supports int64_t and StringView
+  static const std::vector<TypePtr> kBaseTypes{BIGINT(), VARCHAR()};
+  baseType_ = kBaseTypes[rand<size_t>(rng_, 0, kBaseTypes.size() - 1)];
+}
+
+SetDigestInputGenerator::~SetDigestInputGenerator() = default;
+
+template <typename T>
+variant SetDigestInputGenerator::generateTyped() {
+  velox::functions::SetDigest<int64_t> digest(allocator_.get());
+
+  int numValues = rand<int>(rng_, 10, 100);
+  for (int i = 0; i < numValues; ++i) {
+    int64_t value = rand<int64_t>(rng_);
+    digest.add(value);
+  }
+
+  size_t byteSize = digest.estimatedSerializedSize();
+  std::string serializedDigest(byteSize, '\0');
+  digest.serialize(&serializedDigest[0]);
+  return variant::create<TypeKind::VARBINARY>(serializedDigest);
+}
+
+template <>
+variant SetDigestInputGenerator::generateTyped<std::string>() {
+  velox::functions::SetDigest<StringView> digest(allocator_.get());
+
+  int numValues = rand<int>(rng_, 10, 100);
+  static const std::vector<UTF8CharList> encodings{
+      UTF8CharList::ASCII,
+      UTF8CharList::UNICODE_CASE_SENSITIVE,
+      UTF8CharList::EXTENDED_UNICODE,
+      UTF8CharList::MATHEMATICAL_SYMBOLS};
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+#pragma GCC diagnostic pop
+
+  for (int i = 0; i < numValues; ++i) {
+    auto size = rand<int32_t>(rng_, 0, 100);
+    std::string result;
+    auto str = randString(rng_, size, encodings, result, converter);
+    digest.add(StringView(str));
+  }
+
+  size_t byteSize = digest.estimatedSerializedSize();
+  std::string serializedDigest(byteSize, '\0');
+  digest.serialize(&serializedDigest[0]);
+  return variant::create<TypeKind::VARBINARY>(serializedDigest);
+}
+
+variant SetDigestInputGenerator::generate() {
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  if (baseType_->isBigint()) {
+    return generateTyped<int64_t>();
+  } else {
+    return generateTyped<std::string>();
+  }
+}
+
 // BingTileInputGenerator
 
 BingTileInputGenerator::BingTileInputGenerator(
@@ -303,6 +383,40 @@ int64_t BingTileInputGenerator::generateImpl() {
   return static_cast<int64_t>(BingTileType::bingTileCoordsToInt(x, y, zoom));
 }
 
+QDigestInputGenerator::QDigestInputGenerator(
+    size_t seed,
+    const TypePtr& type,
+    double nullRatio,
+    const TypePtr& qdigestType)
+    : AbstractInputGenerator(seed, type, nullptr, nullRatio),
+      qdigestType{qdigestType} {}
+
+QDigestInputGenerator::~QDigestInputGenerator() = default;
+
+variant QDigestInputGenerator::generate() {
+  constexpr double kAccuracy = 1.0E-3;
+
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  size_t len = rand(rng_, 1, 1000);
+
+  std::string serializedStr = [&]() {
+    switch (qdigestType->kind()) {
+      case TypeKind::BIGINT:
+        return createSerializedDigest<int64_t>(len, kAccuracy);
+      case TypeKind::DOUBLE:
+        return createSerializedDigest<double>(len, kAccuracy);
+      case TypeKind::REAL:
+        return createSerializedDigest<float>(len, kAccuracy);
+      default:
+        VELOX_FAIL("Unsupported type for QDigest: {}", qdigestType->toString());
+    }
+  }();
+  return variant::create<TypeKind::VARBINARY>(std::move(serializedStr));
+}
+
 // Utility functions
 template <bool, TypeKind KIND>
 std::unique_ptr<AbstractInputGenerator> getRandomInputGeneratorPrimitive(
@@ -494,7 +608,6 @@ CastVarcharInputGenerator::CastVarcharInputGenerator(
 
 CastVarcharInputGenerator::~CastVarcharInputGenerator() = default;
 
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 std::string CastVarcharInputGenerator::generateValidPrimitiveAsString() {
   switch (castToType_->kind()) {
     case TypeKind::BOOLEAN: {
@@ -532,7 +645,10 @@ std::string CastVarcharInputGenerator::generateValidPrimitiveAsString() {
     case TypeKind::VARCHAR: {
       // Generate random string.
       std::string input;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
       std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+#pragma GCC diagnostic pop
       auto randomStr = randString(
           rng_,
           rand<size_t>(rng_, 0, 20),
@@ -543,9 +659,10 @@ std::string CastVarcharInputGenerator::generateValidPrimitiveAsString() {
     }
     default:
       // cast from varchar doesn't support complex types
-      VELOX_FAIL_UNSUPPORTED_INPUT_UNCATCHABLE(fmt::format(
-          "Type `{}` not supported for cast varchar custom generator",
-          castToType_->kind()));
+      VELOX_FAIL_UNSUPPORTED_INPUT_UNCATCHABLE(
+          fmt::format(
+              "Type `{}` not supported for cast varchar custom generator",
+              castToType_->kind()));
   }
 }
 
@@ -588,4 +705,216 @@ variant CastVarcharInputGenerator::generate() {
   return variant(input);
 }
 
+// URLInputGenerator creates URL input data for URL functions.
+URLInputGenerator::URLInputGenerator(
+    size_t seed,
+    const TypePtr& type,
+    double nullRatio,
+    std::string functionName,
+    std::vector<std::string> functionsToSkipForMailTo,
+    std::vector<std::string> functionsToSkipForTruncate)
+    : AbstractInputGenerator(seed, type, nullptr, nullRatio),
+      functionName_{std::move(functionName)},
+      functionsToSkipForMailTo_{std::move(functionsToSkipForMailTo)},
+      functionsToSkipForTruncate_{std::move(functionsToSkipForTruncate)} {}
+
+URLInputGenerator::~URLInputGenerator() = default;
+
+std::shared_ptr<RuleList> URLInputGenerator::generateURLRules() {
+  auto url = RuleList({
+      std::make_shared<ChoiceRule>(
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>("http"),
+              std::make_shared<ConstantRule>("https"),
+          })),
+      std::make_shared<ConstantRule>("://"),
+      std::make_shared<WordRule>(rng_), // domain
+      std::make_shared<ConstantRule>("."),
+      std::make_shared<WordRule>(rng_, 2, 3, true),
+      std::make_shared<OptionalRule>( // port
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>(":"),
+              std::make_shared<NumRule>(rng_, 3, 7, true)})),
+      std::make_shared<RepeatingRule>( // path
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>("/"),
+              std::make_shared<WordRule>(rng_),
+          }),
+          0,
+          5),
+      std::make_shared<OptionalRule>( // query
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>("?"),
+              std::make_shared<WordRule>(rng_),
+              std::make_shared<ConstantRule>("="),
+              std::make_shared<WordRule>(rng_),
+              std::make_shared<RepeatingRule>(
+                  rng_,
+                  std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+                      std::make_shared<ConstantRule>("&"),
+                      std::make_shared<WordRule>(rng_),
+                      std::make_shared<ConstantRule>("="),
+                      std::make_shared<WordRule>(rng_)}),
+                  1,
+                  3),
+              std::make_shared<RepeatingRule>(
+                  rng_,
+                  std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+                      std::make_shared<ConstantRule>("["),
+                      std::make_shared<ConstantRule>("]")}),
+                  0,
+                  3),
+          })),
+      std::make_shared<OptionalRule>( // fragment
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>("#"),
+              std::make_shared<WordRule>(rng_),
+              std::make_shared<RepeatingRule>(
+                  rng_,
+                  std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+                      std::make_shared<ConstantRule>("["),
+                      std::make_shared<ConstantRule>("]")}),
+                  0,
+                  3),
+          })),
+  });
+
+  return std::make_shared<RuleList>(url);
+}
+
+std::shared_ptr<RuleList> URLInputGenerator::generateChromeExtensionRules() {
+  auto chrome_extension = RuleList({
+      std::make_shared<ConstantRule>("chrome-extension:/"),
+      std::make_shared<RepeatingRule>(
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>("/"),
+              std::make_shared<WordRule>(rng_)}),
+          1,
+          3),
+      std::make_shared<ConstantRule>("/"),
+      std::make_shared<WordRule>(rng_),
+      std::make_shared<ConstantRule>(".html"),
+  });
+
+  return std::make_shared<RuleList>(chrome_extension);
+}
+
+std::shared_ptr<RuleList> URLInputGenerator::generateMailToRules() {
+  auto mailTo = RuleList({
+      std::make_shared<ConstantRule>("mailto:"),
+      std::make_shared<WordRule>(rng_),
+      std::make_shared<ConstantRule>("@"),
+      std::make_shared<WordRule>(rng_),
+      std::make_shared<ConstantRule>("."),
+      std::make_shared<WordRule>(rng_, 2, 3, true),
+      std::make_shared<OptionalRule>( // subject
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>("&"),
+              std::make_shared<ConstantRule>("subject"),
+              std::make_shared<ConstantRule>("="),
+              std::make_shared<WordRule>(rng_),
+              std::make_shared<RepeatingRule>(
+                  rng_,
+                  std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+                      std::make_shared<ConstantRule>("\%20"),
+                      std::make_shared<WordRule>(rng_)}),
+                  1,
+                  3)})),
+      std::make_shared<OptionalRule>( // recipients
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>("&"),
+              std::make_shared<ConstantRule>("cc"),
+              std::make_shared<ConstantRule>("="),
+              std::make_shared<WordRule>(rng_),
+              std::make_shared<ConstantRule>("@"),
+              std::make_shared<WordRule>(rng_),
+              std::make_shared<ConstantRule>("."),
+              std::make_shared<WordRule>(rng_, 2, 3, true),
+              std::make_shared<RepeatingRule>(
+                  rng_,
+                  std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+                      std::make_shared<ConstantRule>("&"),
+                      std::make_shared<ConstantRule>("bcc"),
+                      std::make_shared<ConstantRule>("="),
+                      std::make_shared<WordRule>(rng_),
+                      std::make_shared<ConstantRule>("@"),
+                      std::make_shared<WordRule>(rng_),
+                      std::make_shared<ConstantRule>("."),
+                      std::make_shared<WordRule>(rng_, 2, 3, true),
+                  }),
+                  1,
+                  3)})),
+      std::make_shared<OptionalRule>( // body
+          rng_,
+          std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+              std::make_shared<ConstantRule>("&"),
+              std::make_shared<ConstantRule>("body"),
+              std::make_shared<ConstantRule>("="),
+              std::make_shared<WordRule>(rng_),
+              std::make_shared<RepeatingRule>(
+                  rng_,
+                  std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+                      std::make_shared<ConstantRule>("\%20"),
+                      std::make_shared<WordRule>(rng_)}),
+                  1,
+                  3)})),
+  });
+
+  return std::make_shared<RuleList>(mailTo);
+}
+
+variant URLInputGenerator::generate() {
+  // Randomly add nulls.
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  std::vector<std::shared_ptr<Rule>> rules;
+  rules.push_back(generateURLRules());
+  rules.push_back(generateChromeExtensionRules());
+  if (std::find(
+          functionsToSkipForMailTo_.begin(),
+          functionsToSkipForMailTo_.end(),
+          functionName_) == functionsToSkipForMailTo_.end()) {
+    rules.push_back(generateMailToRules());
+  }
+
+  auto choices = ChoiceRule(rng_, std::make_shared<RuleList>(rules));
+
+  auto input = choices.generate();
+
+  // Make additional random variations to valid input data to see how these
+  // functions process them.
+  if (coinToss(rng_, 0.2)) {
+    makeRandomStrVariation(
+        input,
+        rng_,
+        RandomStrVariationOptions{
+            0.0,
+            0.1,
+            std::find(
+                functionsToSkipForTruncate_.begin(),
+                functionsToSkipForTruncate_.end(),
+                functionName_) != functionsToSkipForTruncate_.end()
+                ? 0.0
+                : 0.1});
+  }
+
+  // Intentionally ignore these cases due to intentional differences, see
+  // https://github.com/facebookincubator/velox/issues/14204
+  if (input == "https://" || input == "https:") {
+    return variant::null(type_->kind());
+  }
+
+  return variant(input);
+}
+
 } // namespace facebook::velox::fuzzer
diff --git a/velox/common/fuzzer/ConstrainedGenerators.h b/velox/common/fuzzer/ConstrainedGenerators.h
index 70bc1026d9ea..930fd2bade6a 100644
--- a/velox/common/fuzzer/ConstrainedGenerators.h
+++ b/velox/common/fuzzer/ConstrainedGenerators.h
@@ -21,6 +21,8 @@
 #include "folly/json.h"
 
 #include "velox/common/fuzzer/Utils.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/QuantileDigest.h"
 #include "velox/type/Type.h"
 #include "velox/type/Variant.h"
 
@@ -81,7 +83,7 @@ template <typename T>
 class RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, StringView>>>
     : public AbstractInputGenerator {
  public:
-  RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, StringView>>>(
+  RandomInputGenerator(
       size_t seed,
       const TypePtr& type,
       double nullRatio,
@@ -97,8 +99,7 @@ class RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, StringView>>>
         encodings_{encodings},
         randomStrVariationOptions_{randomStrVariationOptions} {}
 
-  ~RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, StringView>>>()
-      override = default;
+  ~RandomInputGenerator() override = default;
 
   variant generate() override {
     if (coinToss(rng_, nullRatio_)) {
@@ -125,7 +126,7 @@ template <typename T>
 class RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, ArrayType>>>
     : public AbstractInputGenerator {
  public:
-  RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, ArrayType>>>(
+  RandomInputGenerator(
       size_t seed,
       const TypePtr& type,
       double nullRatio,
@@ -142,8 +143,7 @@ class RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, ArrayType>>>
         containAtIndex_{containAtIndex},
         containGenerator_{std::move(containGenerator)} {}
 
-  ~RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, ArrayType>>>()
-      override = default;
+  ~RandomInputGenerator() override = default;
 
   variant generate() override {
     if (coinToss(rng_, nullRatio_)) {
@@ -179,7 +179,7 @@ template <typename T>
 class RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, MapType>>>
     : public AbstractInputGenerator {
  public:
-  RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, MapType>>>(
+  RandomInputGenerator(
       size_t seed,
       const TypePtr& type,
       double nullRatio,
@@ -206,8 +206,7 @@ class RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, MapType>>>
     }
   }
 
-  ~RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, MapType>>>()
-      override = default;
+  ~RandomInputGenerator() override = default;
 
   variant generate() override {
     if (coinToss(rng_, nullRatio_)) {
@@ -247,7 +246,7 @@ template <typename T>
 class RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, RowType>>>
     : public AbstractInputGenerator {
  public:
-  RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, RowType>>>(
+  RandomInputGenerator(
       size_t seed,
       const TypePtr& type,
       std::vector<std::unique_ptr<AbstractInputGenerator>> fieldGenerators,
@@ -266,8 +265,7 @@ class RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, RowType>>>
     }
   }
 
-  ~RandomInputGenerator<T, std::enable_if_t<std::is_same_v<T, RowType>>>()
-      override = default;
+  ~RandomInputGenerator() override = default;
 
   variant generate() override {
     if (coinToss(rng_, nullRatio_)) {
@@ -383,6 +381,21 @@ class JsonInputGenerator : public AbstractInputGenerator {
     return folly::dynamic(value);
   }
 
+  // Presto and Velox JSON parser have different behavior for floating point
+  // with magnitudes greater than equal to 10^-3 and less than 10^7. Clamp
+  // values to avoid scientific notation when comparing JSON parse results.
+  template <TypeKind KIND>
+  folly::dynamic convertVariantToDynamicFloatingPoint(const variant& v) {
+    using T = typename TypeTraits<KIND>::DeepCopiedType;
+    VELOX_CHECK(v.isSet());
+    const T value = v.value<T>();
+    const T absValue = std::abs(value);
+    const T sign = value < 0 ? static_cast<T>(-1.0) : static_cast<T>(1.0);
+    const T clampedValue =
+        std::clamp(absValue, static_cast<T>(1e-3), static_cast<T>(1e7 - 1));
+    return folly::dynamic(sign * clampedValue);
+  }
+
   folly::dynamic convertVariantToDynamic(const variant& object);
 
   void makeRandomVariation(std::string& json);
@@ -424,7 +437,6 @@ class PhoneNumberInputGenerator : public AbstractInputGenerator {
 /// them:
 ///  - On strings, arrays, and objects: .length()
 ///  - On arrays: [begin:end:step]
-
 class JsonPathGenerator : public AbstractInputGenerator {
  public:
   JsonPathGenerator(
@@ -480,6 +492,33 @@ class CastVarcharInputGenerator : public AbstractInputGenerator {
   std::string generateValidPrimitiveAsString();
 };
 
+class URLInputGenerator : public AbstractInputGenerator {
+ public:
+  URLInputGenerator(
+      size_t seed,
+      const TypePtr& type,
+      double nullRatio,
+      std::string functionName,
+      std::vector<std::string> functionsToSkipForMailTo,
+      std::vector<std::string> functionsToSkipForTruncate);
+
+  ~URLInputGenerator() override;
+
+  variant generate() override;
+
+ private:
+  std::shared_ptr<RuleList> generateURLRules();
+  std::shared_ptr<RuleList> generateMailToRules();
+  std::shared_ptr<RuleList> generateChromeExtensionRules();
+
+  const std::string functionName_;
+  // Particular UDFs are known to have mismatches for mailto and trucated input.
+  // Let's skip those test cases for now. More info can be found in
+  // https://github.com/facebookincubator/velox/issues/14204.
+  const std::vector<std::string> functionsToSkipForMailTo_;
+  const std::vector<std::string> functionsToSkipForTruncate_;
+};
+
 class TDigestInputGenerator : public AbstractInputGenerator {
  public:
   TDigestInputGenerator(size_t seed, const TypePtr& type, double nullRatio);
@@ -489,6 +528,23 @@ class TDigestInputGenerator : public AbstractInputGenerator {
   variant generate() override;
 };
 
+class SetDigestInputGenerator : public AbstractInputGenerator {
+ public:
+  SetDigestInputGenerator(size_t seed, const TypePtr& type, double nullRatio);
+
+  ~SetDigestInputGenerator() override;
+
+  variant generate() override;
+
+ private:
+  template <typename T>
+  variant generateTyped();
+
+  TypePtr baseType_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::unique_ptr<HashStringAllocator> allocator_;
+};
+
 class BingTileInputGenerator : public AbstractInputGenerator {
  public:
   BingTileInputGenerator(size_t seed, const TypePtr& type, double nullRatio);
@@ -500,4 +556,59 @@ class BingTileInputGenerator : public AbstractInputGenerator {
  private:
   int64_t generateImpl();
 };
+
+class QDigestInputGenerator : public AbstractInputGenerator {
+ public:
+  QDigestInputGenerator(
+      size_t seed,
+      const TypePtr& type,
+      double nullRatio,
+      const TypePtr& qdigestType);
+
+  ~QDigestInputGenerator() override;
+
+  variant generate() override;
+
+ private:
+  const TypePtr qdigestType;
+
+  template <typename T>
+  std::vector<T> generateRandomValue(size_t len) {
+    std::vector<T> values;
+    values.reserve(len);
+
+    auto makeDist = []() {
+      if constexpr (std::is_integral_v<T>) {
+        return std::uniform_int_distribution<T>(0, 10000);
+      } else {
+        return std::uniform_real_distribution<T>(0.0, 10000.0);
+      }
+    };
+
+    auto dist = makeDist();
+    for (size_t i = 0; i < len; ++i) {
+      values.push_back(dist(rng_));
+    }
+    return values;
+  }
+
+  template <typename T>
+  std::string createSerializedDigest(size_t len, double accuracy) {
+    using facebook::velox::functions::qdigest::QuantileDigest;
+
+    std::allocator<T> allocator;
+    QuantileDigest<T, std::allocator<T>> digest(allocator, accuracy);
+
+    const auto input = generateRandomValue<T>(len);
+    auto dist = boost::random::uniform_real_distribution<T>(1.0, 100.0);
+    for (const auto& value : input) {
+      digest.add(value, dist(rng_));
+    }
+    const auto serializedSize = digest.serializedByteSize();
+    std::vector<char> serializedData(serializedSize);
+    digest.serialize(serializedData.data());
+
+    return std::string(serializedData.begin(), serializedData.end());
+  }
+};
 } // namespace facebook::velox::fuzzer
diff --git a/velox/common/fuzzer/Utils.cpp b/velox/common/fuzzer/Utils.cpp
index 7cdb14e9ca4f..5d8394d84de0 100644
--- a/velox/common/fuzzer/Utils.cpp
+++ b/velox/common/fuzzer/Utils.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "velox/common/fuzzer/Utils.h"
+#include <fmt/format.h>
+#include "velox/type/Time.h"
 
 namespace facebook::velox::fuzzer {
 
@@ -152,6 +154,15 @@ static const std::vector<std::vector<std::pair<char16_t, char16_t>>>
             {u'\u27C0', u'\u27EF'}, // Math Symbols.
             {u'\u2A00', u'\u2AFF'}, // Supplemental.
         },
+        // UTF8CharList::ALPHABETIC
+        {
+            {u'A', u'Z'}, // Uppercase alphabetic characters.
+            {u'a', u'z'}, // Lowercase alphabetic characters.
+        },
+        // UTF8CharList::NUMERIC
+        {
+            {u'0', u'9'}, // Numeric characters.
+        },
     };
 
 FOLLY_ALWAYS_INLINE char16_t getRandomChar(
@@ -193,4 +204,38 @@ std::string randString(
 }
 #pragma GCC diagnostic pop
 
+int16_t generateRandomTimezoneOffset(
+    FuzzerGenerator& rng,
+    double frequentlyUsedProbability) {
+  // 25% probability: pick from frequently used offsets
+  // 75% probability: generate random offset in range [-840, 840]
+  if (coinToss(rng, frequentlyUsedProbability)) {
+    auto index =
+        rand<size_t>(rng, 0, kFrequentlyUsedTimezoneOffsets.size() - 1);
+    return kFrequentlyUsedTimezoneOffsets[index];
+  } else {
+    return rand<int16_t>(rng, -util::kTimeZoneBias, util::kTimeZoneBias);
+  }
+}
+
+std::string timezoneOffsetToString(int16_t offsetMinutes) {
+  // Validate range [-840, 840]
+  VELOX_USER_CHECK(
+      offsetMinutes >= -util::kTimeZoneBias &&
+          offsetMinutes <= util::kTimeZoneBias,
+      "Timezone offset {} minutes is out of range [-840, 840]",
+      offsetMinutes);
+
+  // Determine sign
+  char sign = (offsetMinutes >= 0) ? '+' : '-';
+
+  // Calculate hours and minutes using absolute value
+  int16_t absOffset = std::abs(offsetMinutes);
+  int16_t hours = absOffset / util::kMinutesInHour;
+  int16_t minutes = absOffset % util::kMinutesInHour;
+
+  // Format as "+HH:mm" or "-HH:mm" with zero-padding
+  return fmt::format("{}{:02d}:{:02d}", sign, hours, minutes);
+}
+
 } // namespace facebook::velox::fuzzer
diff --git a/velox/common/fuzzer/Utils.h b/velox/common/fuzzer/Utils.h
index 951ef7564fd0..5c011321b223 100644
--- a/velox/common/fuzzer/Utils.h
+++ b/velox/common/fuzzer/Utils.h
@@ -31,11 +31,24 @@ namespace facebook::velox::fuzzer {
 
 using FuzzerGenerator = folly::detail::DefaultGenerator;
 
+// Frequently used timezone offsets in minutes (US timezones including DST)
+// -240 = UTC-4:00 (EDT)
+// -300 = UTC-5:00 (EST/CDT)
+// -360 = UTC-6:00 (CST/MDT)
+// -420 = UTC-7:00 (MST/PDT)
+// -480 = UTC-8:00 (PST)
+// -540 = UTC-9:00 (AKST)
+// -600 = UTC-10:00 (HST)
+constexpr std::array<int16_t, 7> kFrequentlyUsedTimezoneOffsets =
+    {-240, -300, -360, -420, -480, -540, -600};
+
 enum UTF8CharList {
   ASCII = 0, // Ascii character set.
   UNICODE_CASE_SENSITIVE = 1, // Unicode scripts that support case.
   EXTENDED_UNICODE = 2, // Extended Unicode: Arabic, Devanagiri etc
-  MATHEMATICAL_SYMBOLS = 3 // Mathematical Symbols.
+  MATHEMATICAL_SYMBOLS = 3, // Mathematical Symbols.
+  ALPHABETIC = 4, // Alphabetic Symbols.
+  NUMERIC = 5 // Numeric Symbols.
 };
 
 bool coinToss(FuzzerGenerator& rng, double threshold);
@@ -165,6 +178,33 @@ inline Timestamp rand(FuzzerGenerator& rng, DataSpec /*dataSpec*/) {
 
 int32_t randDate(FuzzerGenerator& rng);
 
+/// Generate random timezone offset using biased distribution
+/// 25% probability: picks from frequently used offsets
+/// 75% probability: generates random offset from [-840, 840]
+///
+/// @param rng Random number generator
+/// @param frequentlyUsedProbability Probability of selecting from frequently
+///        used offsets (default 0.25 for 25%)
+/// @return Timezone offset in minutes [-840, 840]
+int16_t generateRandomTimezoneOffset(
+    FuzzerGenerator& rng,
+    double frequentlyUsedProbability = 0.25);
+
+/// Convert timezone offset in minutes to "+HH:mm" or "-HH:mm" format
+/// Always uses Presto-compatible +HH:mm format (never +HH or +HHmm)
+///
+/// Examples:
+/// - 0 → "+00:00"
+/// - 330 → "+05:30"
+/// - -300 → "-05:00"
+/// - 840 → "+14:00"
+/// - -840 → "-14:00"
+///
+/// @param offsetMinutes Timezone offset in minutes [-840, 840]
+/// @return Timezone offset string in "+HH:mm" or "-HH:mm" format
+/// @throws VeloxException if offsetMinutes is out of range [-840, 840]
+std::string timezoneOffsetToString(int16_t offsetMinutes);
+
 template <
     typename T,
     typename std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
@@ -188,4 +228,215 @@ std::string randString(
     std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t>& converter);
 #pragma GCC diagnostic pop
 
+// Beginning of rule or grammar based input generation. The following set of
+// classes will allow us to use a rule based approach to generate random inputs.
+
+// Class rule defines abstract function generate which outputs our input string
+// dependent on the defined rule instantiation.
+class Rule {
+ public:
+  Rule() = default;
+
+  virtual std::string generate() {
+    return "";
+  }
+
+  virtual ~Rule() = default;
+};
+
+// List of Rules.
+class RuleList : public Rule {
+ public:
+  explicit RuleList(std::vector<std::shared_ptr<Rule>> rules)
+      : rules_{std::move(rules)} {}
+
+  std::string generate() override {
+    std::string string;
+    for (auto& rule : rules_) {
+      string += rule->generate();
+    }
+    return string;
+  }
+
+  size_t size() {
+    return rules_.size();
+  }
+
+  std::shared_ptr<Rule> operator[](size_t index) const {
+    if (index >= rules_.size()) {
+      throw std::out_of_range("Index out of range");
+    }
+    return rules_[index];
+  }
+
+  virtual ~RuleList() = default;
+
+ private:
+  std::vector<std::shared_ptr<Rule>> rules_;
+};
+
+// Rules that are randomly included.
+class OptionalRule : public Rule {
+ public:
+  OptionalRule(FuzzerGenerator& rng, std::shared_ptr<Rule> rule)
+      : rng_(rng), rule_(std::move(rule)) {}
+
+  std::string generate() override {
+    return coinToss(rng_, .5) ? rule_->generate() : "";
+  }
+
+  virtual ~OptionalRule() = default;
+
+ private:
+  FuzzerGenerator& rng_;
+  std::shared_ptr<Rule> rule_;
+};
+
+// Rules that can repeat 'count' times.
+class RepeatingRule : public Rule {
+ public:
+  RepeatingRule(
+      FuzzerGenerator& rng,
+      std::shared_ptr<Rule> rule,
+      size_t minCount,
+      size_t maxCount)
+      : rng_(rng),
+        rule_(std::move(rule)),
+        minCount_(minCount),
+        maxCount_(maxCount) {}
+
+  std::string generate() override {
+    auto repetitions = rand<size_t>(rng_, minCount_, maxCount_);
+    std::string string;
+    for (size_t i = 0; i < repetitions; ++i) {
+      string += rule_->generate();
+    }
+    return string;
+  }
+
+  virtual ~RepeatingRule() = default;
+
+ private:
+  FuzzerGenerator& rng_;
+  std::shared_ptr<Rule> rule_;
+  size_t minCount_, maxCount_;
+};
+
+// Rule randomly chosen from list.
+class ChoiceRule : public Rule {
+ public:
+  ChoiceRule(FuzzerGenerator& rng, std::shared_ptr<RuleList> rules)
+      : rng_(rng), rules_(std::move(rules)) {}
+
+  std::string generate() override {
+    auto index = rand<size_t>(rng_, 0, rules_->size() - 1);
+    return (*rules_)[index]->generate();
+  }
+
+  virtual ~ChoiceRule() = default;
+
+ private:
+  FuzzerGenerator& rng_;
+  std::shared_ptr<RuleList> rules_;
+};
+
+// Simple rule that is just a constant string.
+class ConstantRule : public Rule {
+ public:
+  explicit ConstantRule(std::string constant)
+      : constant_(std::move(constant)) {}
+
+  std::string generate() override {
+    return constant_;
+  }
+
+  virtual ~ConstantRule() = default;
+
+ private:
+  std::string constant_;
+};
+
+// String of 1 to 20 characters long that generates ASCII characters. Size and
+// character list can be modified.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+class StringRule : public Rule {
+ public:
+  explicit StringRule(
+      FuzzerGenerator& rng,
+      std::vector<UTF8CharList> encodings = {UTF8CharList::ASCII},
+      size_t minLength = 1,
+      size_t maxLength = 20,
+      bool flexibleLength = true)
+      : rng_(rng),
+        encodings_(std::move(encodings)),
+        minLength_(minLength),
+        maxLength_(maxLength),
+        flexibleLength_(flexibleLength) {}
+
+  std::string generate() override {
+    auto length = maxLength_;
+    if (flexibleLength_) {
+      length = rand<size_t>(rng_, minLength_, maxLength_);
+    }
+    return randString(rng_, length, encodings_, buf_, converter_);
+  }
+
+  virtual ~StringRule() = default;
+
+ private:
+  FuzzerGenerator& rng_;
+  std::vector<UTF8CharList> encodings_;
+  size_t minLength_;
+  size_t maxLength_;
+  bool flexibleLength_;
+
+  std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter_;
+  std::string buf_;
+};
+#pragma GCC diagnostic pop
+
+// Extends from StringRule, uses only alphabetic characters
+class WordRule : public StringRule {
+ public:
+  explicit WordRule(FuzzerGenerator& rng)
+      : StringRule(rng, {UTF8CharList::ALPHABETIC}) {}
+
+  WordRule(
+      FuzzerGenerator& rng,
+      size_t minLength,
+      size_t maxLength,
+      bool flexibleLength)
+      : StringRule(
+            rng,
+            {UTF8CharList::ALPHABETIC},
+            minLength,
+            maxLength,
+            flexibleLength) {}
+
+  virtual ~WordRule() = default;
+};
+
+// Extends from StringRule, uses only numeric characters for random number
+// generation with a particular size.
+class NumRule : public StringRule {
+ public:
+  explicit NumRule(FuzzerGenerator& rng)
+      : StringRule(rng, {UTF8CharList::NUMERIC}) {}
+
+  NumRule(
+      FuzzerGenerator& rng,
+      size_t minLength,
+      size_t maxLength,
+      bool flexibleLength)
+      : StringRule(
+            rng,
+            {UTF8CharList::NUMERIC},
+            minLength,
+            maxLength,
+            flexibleLength) {}
+
+  virtual ~NumRule() = default;
+};
+
 } // namespace facebook::velox::fuzzer
diff --git a/velox/common/fuzzer/tests/CMakeLists.txt b/velox/common/fuzzer/tests/CMakeLists.txt
index 88e9e2875acb..9278ec7fb8d4 100644
--- a/velox/common/fuzzer/tests/CMakeLists.txt
+++ b/velox/common/fuzzer/tests/CMakeLists.txt
@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_constrained_input_generators_test
-               ConstrainedGeneratorsTest.cpp)
+add_executable(velox_constrained_input_generators_test ConstrainedGeneratorsTest.cpp)
 
 add_test(
   NAME velox_constrained_input_generators_test
   COMMAND velox_constrained_input_generators_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_constrained_input_generators_test
@@ -28,4 +28,5 @@ target_link_libraries(
   velox_type
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
diff --git a/velox/common/fuzzer/tests/ConstrainedGeneratorsTest.cpp b/velox/common/fuzzer/tests/ConstrainedGeneratorsTest.cpp
index b36801de5695..1defe5db7b2a 100644
--- a/velox/common/fuzzer/tests/ConstrainedGeneratorsTest.cpp
+++ b/velox/common/fuzzer/tests/ConstrainedGeneratorsTest.cpp
@@ -21,6 +21,8 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/functions/prestosql/json/JsonExtractor.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 #include "velox/type/Variant.h"
 
@@ -404,9 +406,10 @@ TEST_F(ConstrainedGeneratorsTest, jsonPath) {
     const auto jsonPath = jsonPathGenerator->generate();
     if (jsonPath.hasValue()) {
       if (json.hasValue()) {
-        EXPECT_NO_THROW(functions::jsonExtract(
-            json.value<TypeKind::VARCHAR>(),
-            jsonPath.value<TypeKind::VARCHAR>()));
+        EXPECT_NO_THROW(
+            functions::jsonExtract(
+                json.value<TypeKind::VARCHAR>(),
+                jsonPath.value<TypeKind::VARCHAR>()));
       }
     } else {
       hasNull = true;
@@ -422,4 +425,29 @@ TEST_F(ConstrainedGeneratorsTest, tdigest) {
   EXPECT_EQ(value.kind(), TypeKind::VARBINARY);
 }
 
+TEST_F(ConstrainedGeneratorsTest, setdigest) {
+  std::unique_ptr<SetDigestInputGenerator> generator =
+      std::make_unique<SetDigestInputGenerator>(0, SETDIGEST(), 0.4);
+  auto value = generator->generate();
+  EXPECT_EQ(value.kind(), TypeKind::VARBINARY);
+}
+
+TEST_F(ConstrainedGeneratorsTest, qdigest) {
+  std::unique_ptr<QDigestInputGenerator> generator =
+      std::make_unique<QDigestInputGenerator>(
+          0, QDIGEST(DOUBLE()), 0.4, DOUBLE());
+  auto value = generator->generate();
+  EXPECT_EQ(value.kind(), TypeKind::VARBINARY);
+
+  generator =
+      std::make_unique<QDigestInputGenerator>(0, QDIGEST(REAL()), 0.4, REAL());
+  value = generator->generate();
+  EXPECT_EQ(value.kind(), TypeKind::VARBINARY);
+
+  generator = std::make_unique<QDigestInputGenerator>(
+      0, QDIGEST(BIGINT()), 0.4, BIGINT());
+  value = generator->generate();
+  EXPECT_EQ(value.kind(), TypeKind::VARBINARY);
+}
+
 } // namespace facebook::velox::fuzzer::test
diff --git a/velox/common/fuzzer/tests/UtilsTest.cpp b/velox/common/fuzzer/tests/UtilsTest.cpp
new file mode 100644
index 000000000000..5e82bdc85d62
--- /dev/null
+++ b/velox/common/fuzzer/tests/UtilsTest.cpp
@@ -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.
+ */
+
+#include "velox/common/fuzzer/Utils.h"
+
+#include <gtest/gtest.h>
+
+#include <regex>
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer::test {
+
+class UtilsTest : public testing::Test {};
+
+TEST_F(UtilsTest, testRuleList) {
+  auto simple = RuleList(
+      std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("Hello"),
+          std::make_shared<ConstantRule>(","),
+          std::make_shared<ConstantRule>(" "),
+          std::make_shared<ConstantRule>("world"),
+          std::make_shared<ConstantRule>("!"),
+      });
+  ASSERT_EQ(simple.generate(), "Hello, world!");
+
+  FuzzerGenerator rng;
+  auto fuzz = RuleList(
+      std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("Hello"),
+          std::make_shared<ConstantRule>(","),
+          std::make_shared<ConstantRule>(" "),
+          std::make_shared<WordRule>(rng),
+          std::make_shared<ConstantRule>("!"),
+      });
+  ASSERT_TRUE(
+      std::regex_match(fuzz.generate(), std::regex("Hello, \\w{1,20}!")));
+}
+
+TEST_F(UtilsTest, testOptionalRule) {
+  FuzzerGenerator rng;
+  auto simple = std::make_shared<OptionalRule>(
+      rng,
+      std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("a"),
+      }));
+  ASSERT_TRUE(std::regex_match(simple->generate(), std::regex("^(|a)$")));
+}
+
+TEST_F(UtilsTest, testRepeatingRule) {
+  FuzzerGenerator rng;
+  auto simple = std::make_shared<RepeatingRule>(
+      rng,
+      std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("a"),
+      }),
+      2,
+      5);
+  ASSERT_TRUE(std::regex_match(simple->generate(), std::regex("^a{2,5}$")));
+
+  auto fuzz = std::make_shared<RepeatingRule>(
+      rng,
+      std::make_shared<RuleList>(std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("a"),
+          std::make_shared<WordRule>(rng, 1, 1, false),
+      }),
+      2,
+      5);
+  ASSERT_TRUE(std::regex_match(fuzz->generate(), std::regex("^\\w{4,10}$")));
+}
+
+TEST_F(UtilsTest, testConstantRule) {
+  auto rule = std::make_shared<ConstantRule>("a");
+  ASSERT_EQ(rule->generate(), "a");
+
+  auto rule_list = RuleList(
+      std::vector<std::shared_ptr<Rule>>{
+          std::make_shared<ConstantRule>("a"),
+          std::make_shared<ConstantRule>("b"),
+          std::make_shared<ConstantRule>("c")});
+  ASSERT_EQ(rule_list.generate(), "abc");
+}
+
+TEST_F(UtilsTest, testStringRule) {
+  FuzzerGenerator rng;
+  auto simple = std::make_shared<StringRule>(rng);
+  ASSERT_TRUE(
+      std::regex_match(
+          simple->generate(), std::regex("^[\x21-\x7F]+$"))); // printable ascii
+  ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\w+$")));
+  ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\d+$")));
+
+  auto specified_flexible = std::make_shared<StringRule>(
+      rng, std::vector<UTF8CharList>{UTF8CharList::ASCII}, 3, 7, true);
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{0,2}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^[\\x21-\\x7F]{8,}$")));
+
+  auto specified_strict = std::make_shared<StringRule>(
+      rng, std::vector<UTF8CharList>{UTF8CharList::ASCII}, 3, 7, false);
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_strict->generate(), std::regex("^[\x21-\x7F]{7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_strict->generate(), std::regex("^[\x21-\x7F]{8}$")));
+}
+
+TEST_F(UtilsTest, testWordRule) {
+  FuzzerGenerator rng;
+  auto simple = std::make_shared<WordRule>(rng);
+  ASSERT_TRUE(std::regex_match(simple->generate(), std::regex("^[a-zA-Z]+$")));
+  ASSERT_TRUE(std::regex_match(simple->generate(), std::regex("^\\w+$")));
+  ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\d+$")));
+  ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\W+$")));
+
+  auto specified_flexible = std::make_shared<WordRule>(rng, 3, 7, true);
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^[a-zA-Z]{3,7}$")));
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\w{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\d{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\w{0,2}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\w{8,}$")));
+
+  auto specified_strict = std::make_shared<WordRule>(rng, 3, 7, false);
+  ASSERT_TRUE(
+      std::regex_match(specified_strict->generate(), std::regex("^\\w{7}$")));
+  ASSERT_FALSE(
+      std::regex_match(specified_strict->generate(), std::regex("^\\w{8}$")));
+}
+
+TEST_F(UtilsTest, testNumRule) {
+  FuzzerGenerator rng;
+  auto simple = std::make_shared<NumRule>(rng);
+  ASSERT_TRUE(std::regex_match(simple->generate(), std::regex("^\\d+$")));
+  ASSERT_FALSE(std::regex_match(simple->generate(), std::regex("^\\D+$")));
+
+  auto specified_flexible = std::make_shared<NumRule>(rng, 3, 7, true);
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\d{3,7}$")));
+  ASSERT_TRUE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\w{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\D{3,7}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\d{0,2}$")));
+  ASSERT_FALSE(
+      std::regex_match(
+          specified_flexible->generate(), std::regex("^\\d{8,}$")));
+
+  auto specified_strict = std::make_shared<NumRule>(rng, 3, 7, false);
+  ASSERT_TRUE(
+      std::regex_match(specified_strict->generate(), std::regex("^\\d{7}$")));
+  ASSERT_FALSE(
+      std::regex_match(specified_strict->generate(), std::regex("^\\d{8}$")));
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch b/velox/common/geospatial/CMakeLists.txt
similarity index 66%
rename from CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch
rename to velox/common/geospatial/CMakeLists.txt
index 4fca92831a20..515f0021d152 100644
--- a/CMake/resolve_dependency_modules/cpr/cpr-remove-sancheck.patch
+++ b/velox/common/geospatial/CMakeLists.txt
@@ -11,14 +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.
-# 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
+if(VELOX_ENABLE_GEO)
+  velox_add_library(velox_common_geospatial_serde GeometrySerde.cpp)
+  velox_link_libraries(velox_common_geospatial_serde velox_expression GEOS::geos)
+endif()
+
+velox_install_library_headers()
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/common/geospatial/GeometryConstants.h b/velox/common/geospatial/GeometryConstants.h
new file mode 100644
index 000000000000..d598f29e0262
--- /dev/null
+++ b/velox/common/geospatial/GeometryConstants.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 <cstdint>
+
+// This file contains constats for working with geospatial queries.
+// They _must not_ require the GEOS library (or any 3p library).
+
+namespace facebook::velox::common::geospatial {
+
+enum class GeometrySerializationType : uint8_t {
+  POINT = 0,
+  MULTI_POINT = 1,
+  LINE_STRING = 2,
+  MULTI_LINE_STRING = 3,
+  POLYGON = 4,
+  MULTI_POLYGON = 5,
+  GEOMETRY_COLLECTION = 6,
+  ENVELOPE = 7
+};
+
+enum class EsriShapeType : uint32_t {
+  POINT = 1,
+  POLYLINE = 3,
+  POLYGON = 5,
+  MULTI_POINT = 8
+};
+
+/// Latitude/Longitude range constraints for spherical coordinates.
+constexpr double kMinLatitude = -90.0;
+constexpr double kMaxLatitude = 90.0;
+constexpr double kMinLongitude = -180.0;
+constexpr double kMaxLongitude = 180.0;
+
+/// BingTile-specific latitude constraints (narrower than standard lat/long).
+constexpr double kMinBingTileLatitude = -85.05112878;
+constexpr double kMaxBingTileLatitude = 85.05112878;
+
+} // namespace facebook::velox::common::geospatial
diff --git a/velox/common/geospatial/GeometrySerde.cpp b/velox/common/geospatial/GeometrySerde.cpp
new file mode 100644
index 000000000000..cda4e5195cf2
--- /dev/null
+++ b/velox/common/geospatial/GeometrySerde.cpp
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <geos/geom/CoordinateArraySequence.h>
+#include <geos/geom/GeometryFactory.h>
+#include <geos/geom/LineString.h>
+#include <geos/geom/Point.h>
+
+#include "velox/common/base/IOUtils.h"
+#include "velox/common/geospatial/GeometrySerde.h"
+
+using facebook::velox::common::InputByteStream;
+using facebook::velox::common::geospatial::EsriShapeType;
+using facebook::velox::common::geospatial::GeometrySerializationType;
+
+namespace facebook::velox::common::geospatial {
+
+geos::geom::GeometryFactory* GeometryDeserializer::getGeometryFactory() {
+  thread_local static geos::geom::GeometryFactory::Ptr geometryFactory =
+      geos::geom::GeometryFactory::create();
+  return geometryFactory.get();
+}
+
+std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readGeometry(
+    velox::common::InputByteStream& stream,
+    size_t size) {
+  auto geometryType = static_cast<GeometrySerializationType>(
+      stream.read<GeometrySerializationType>());
+  switch (geometryType) {
+    case GeometrySerializationType::POINT:
+      return readPoint(stream);
+    case GeometrySerializationType::MULTI_POINT:
+      return readMultiPoint(stream);
+    case GeometrySerializationType::LINE_STRING:
+      return readPolyline(stream, false);
+    case GeometrySerializationType::MULTI_LINE_STRING:
+      return readPolyline(stream, true);
+    case GeometrySerializationType::POLYGON:
+      return readPolygon(stream, false);
+    case GeometrySerializationType::MULTI_POLYGON:
+      return readPolygon(stream, true);
+    case GeometrySerializationType::ENVELOPE:
+      return readEnvelope(stream);
+    case GeometrySerializationType::GEOMETRY_COLLECTION:
+      return readGeometryCollection(stream, size);
+    default:
+      VELOX_FAIL(
+          "Unrecognized geometry type: {}", static_cast<uint8_t>(geometryType));
+  }
+}
+
+const std::unique_ptr<geos::geom::Envelope>
+GeometryDeserializer::deserializeEnvelope(const StringView& geometry) {
+  velox::common::InputByteStream inputStream(geometry.data());
+  auto geometryType = inputStream.read<GeometrySerializationType>();
+
+  switch (geometryType) {
+    case GeometrySerializationType::POINT:
+      return std::make_unique<geos::geom::Envelope>(
+          *readPoint(inputStream)->getEnvelopeInternal());
+    case GeometrySerializationType::MULTI_POINT:
+    case GeometrySerializationType::LINE_STRING:
+    case GeometrySerializationType::MULTI_LINE_STRING:
+    case GeometrySerializationType::POLYGON:
+    case GeometrySerializationType::MULTI_POLYGON:
+      skipEsriType(inputStream);
+      return deserializeEnvelope(inputStream);
+    case GeometrySerializationType::ENVELOPE:
+      return deserializeEnvelope(inputStream);
+    case GeometrySerializationType::GEOMETRY_COLLECTION:
+      return std::make_unique<geos::geom::Envelope>(
+          *readGeometryCollection(inputStream, geometry.size())
+               ->getEnvelopeInternal());
+    default:
+      VELOX_FAIL(
+          "Unrecognized geometry type: {}", static_cast<uint8_t>(geometryType));
+  }
+}
+
+std::unique_ptr<geos::geom::Envelope> GeometryDeserializer::deserializeEnvelope(
+    velox::common::InputByteStream& input) {
+  auto xMin = input.read<double>();
+  auto yMin = input.read<double>();
+  auto xMax = input.read<double>();
+  auto yMax = input.read<double>();
+
+  if (FOLLY_UNLIKELY(
+          isEsriNaN(xMin) || isEsriNaN(yMin) || isEsriNaN(xMax) ||
+          isEsriNaN(yMax))) {
+    return std::make_unique<geos::geom::Envelope>();
+  }
+
+  return std::make_unique<geos::geom::Envelope>(xMin, xMax, yMin, yMax);
+}
+
+geos::geom::Coordinate GeometryDeserializer::readCoordinate(
+    velox::common::InputByteStream& input) {
+  auto x = input.read<double>();
+  auto y = input.read<double>();
+  return {x, y};
+}
+
+std::unique_ptr<geos::geom::CoordinateSequence>
+GeometryDeserializer::readCoordinates(
+    velox::common::InputByteStream& input,
+    size_t count) {
+  auto coords = std::make_unique<geos::geom::CoordinateArraySequence>(count, 2);
+  for (size_t i = 0; i < count; ++i) {
+    // TODO: Consider using setOrdinate if there's a performance issue.
+    coords->setAt(readCoordinate(input), i);
+  }
+  return coords;
+}
+
+std::unique_ptr<geos::geom::Point> GeometryDeserializer::readPoint(
+    velox::common::InputByteStream& input) {
+  geos::geom::Coordinate coordinate = readCoordinate(input);
+  if (std::isnan(coordinate.x) || std::isnan(coordinate.y)) {
+    return getGeometryFactory()->createPoint();
+  }
+  return std::unique_ptr<geos::geom::Point>(
+      getGeometryFactory()->createPoint(coordinate));
+}
+
+std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readMultiPoint(
+    velox::common::InputByteStream& input) {
+  skipEsriType(input);
+  skipEnvelope(input);
+  size_t pointCount = input.read<int32_t>();
+  auto coords = readCoordinates(input, pointCount);
+  std::vector<std::unique_ptr<geos::geom::Point>> points;
+  points.reserve(coords->size());
+  for (size_t i = 0; i < coords->size(); ++i) {
+    points.push_back(
+        std::unique_ptr<geos::geom::Point>(getGeometryFactory()->createPoint(
+            geos::geom::Coordinate(coords->getX(i), coords->getY(i)))));
+  }
+  return getGeometryFactory()->createMultiPoint(std::move(points));
+}
+
+std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readPolyline(
+    velox::common::InputByteStream& input,
+    bool multiType) {
+  skipEsriType(input);
+  skipEnvelope(input);
+  size_t partCount = input.read<int32_t>();
+  size_t pointCount = input.read<int32_t>();
+
+  if (partCount == 0) {
+    if (multiType) {
+      return getGeometryFactory()->createMultiLineString();
+    }
+    return getGeometryFactory()->createLineString();
+  }
+
+  std::vector<size_t> startIndexes(partCount);
+  for (size_t i = 0; i < partCount; ++i) {
+    startIndexes[i] = input.read<int32_t>();
+  }
+
+  std::vector<size_t> partLengths(partCount);
+  if (partCount > 1) {
+    partLengths[0] = startIndexes[1];
+    for (size_t i = 1; i < partCount - 1; ++i) {
+      partLengths[i] = startIndexes[i + 1] - startIndexes[i];
+    }
+  }
+  partLengths[partCount - 1] = pointCount - startIndexes[partCount - 1];
+
+  std::vector<std::unique_ptr<geos::geom::LineString>> lineStrings;
+  lineStrings.reserve(partCount);
+  for (size_t i = 0; i < partCount; ++i) {
+    lineStrings.push_back(
+        getGeometryFactory()->createLineString(
+            readCoordinates(input, partLengths[i])));
+  }
+
+  if (multiType) {
+    return getGeometryFactory()->createMultiLineString(std::move(lineStrings));
+  }
+
+  if (lineStrings.size() != 1) {
+    VELOX_FAIL("Expected a single LineString for non-multiType polyline.");
+  }
+
+  return std::move(lineStrings[0]);
+}
+
+std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readPolygon(
+    velox::common::InputByteStream& input,
+    bool multiType) {
+  skipEsriType(input);
+  skipEnvelope(input);
+
+  size_t partCount = input.read<int32_t>();
+  size_t pointCount = input.read<int32_t>();
+  if (partCount == 0) {
+    if (multiType) {
+      return getGeometryFactory()->createMultiPolygon();
+    }
+    return getGeometryFactory()->createPolygon();
+  }
+
+  std::vector<size_t> startIndexes(partCount);
+  for (size_t i = 0; i < partCount; i++) {
+    startIndexes[i] = input.read<int32_t>();
+  }
+
+  std::vector<size_t> partLengths(partCount);
+  if (partCount > 1) {
+    partLengths[0] = startIndexes[1];
+    for (size_t i = 1; i < partCount - 1; i++) {
+      partLengths[i] = startIndexes[i + 1] - startIndexes[i];
+    }
+  }
+  partLengths[partCount - 1] = pointCount - startIndexes[partCount - 1];
+
+  std::unique_ptr<geos::geom::LinearRing> shell = nullptr;
+  std::vector<std::unique_ptr<geos::geom::LinearRing>> holes;
+  std::vector<std::unique_ptr<geos::geom::Polygon>> polygons;
+
+  // Shells _should_ be clockwise and holes _should_ be counter-clockwise,
+  // but this doesn't always happen for single Polygons. For single Polygons,
+  // we read the first ring as a shell and the rest as holes. For MultiPolygons,
+  // we read the first ring as a shell, and any counter-clockwise rings as
+  // holes, then push a polygon and reset if a clockwise ring is encountered.
+  for (size_t i = 0; i < partCount; i++) {
+    auto coordinates = readCoordinates(input, partLengths[i]);
+
+    if (multiType) {
+      bool clockwiseFlag =
+          GeometrySerializer::isClockwise(coordinates, 0, coordinates->size());
+      if (shell && clockwiseFlag) {
+        // next polygon has started
+        polygons.push_back(
+            getGeometryFactory()->createPolygon(
+                std::move(shell), std::move(holes)));
+        holes.clear();
+        shell = nullptr;
+      }
+    }
+
+    auto ring = getGeometryFactory()->createLinearRing(std::move(coordinates));
+    if (shell == nullptr) {
+      shell = std::move(ring);
+    } else {
+      holes.push_back(std::move(ring));
+    }
+  }
+
+  polygons.push_back(
+      getGeometryFactory()->createPolygon(std::move(shell), std::move(holes)));
+
+  if (multiType) {
+    return getGeometryFactory()->createMultiPolygon(std::move(polygons));
+  }
+
+  if (polygons.size() != 1) {
+    VELOX_FAIL("Expected exactly one polygon, but found multiple.");
+  }
+  return std::move(polygons[0]);
+}
+
+std::unique_ptr<geos::geom::Geometry> GeometryDeserializer::readEnvelope(
+    velox::common::InputByteStream& input) {
+  auto xMin = input.read<double>();
+  auto yMin = input.read<double>();
+  auto xMax = input.read<double>();
+  auto yMax = input.read<double>();
+
+  if (isEsriNaN(xMin) || isEsriNaN(yMin) || isEsriNaN(xMax) ||
+      isEsriNaN(yMax)) {
+    return getGeometryFactory()->createPolygon();
+  }
+
+  auto coordinates = std::make_unique<geos::geom::CoordinateArraySequence>();
+  coordinates->add(geos::geom::Coordinate(xMin, yMin));
+  coordinates->add(geos::geom::Coordinate(xMin, yMax));
+  coordinates->add(geos::geom::Coordinate(xMax, yMax));
+  coordinates->add(geos::geom::Coordinate(xMax, yMin));
+  coordinates->add(geos::geom::Coordinate(xMin, yMin)); // Close the ring
+
+  auto shell = getGeometryFactory()->createLinearRing(std::move(coordinates));
+  return getGeometryFactory()->createPolygon(std::move(shell), {});
+}
+
+std::unique_ptr<geos::geom::Geometry>
+GeometryDeserializer::readGeometryCollection(
+    velox::common::InputByteStream& input,
+    size_t size) {
+  std::vector<std::unique_ptr<geos::geom::Geometry>> geometries;
+
+  auto offset = input.offset();
+  while (size - offset > 0) {
+    // Skip the length field
+    input.read<int32_t>();
+    geometries.push_back(readGeometry(input, size));
+    offset = input.offset();
+  }
+  std::vector<const geos::geom::Geometry*> rawGeometries;
+  rawGeometries.reserve(geometries.size());
+  for (const auto& geometry : geometries) {
+    rawGeometries.push_back(geometry.get());
+  }
+
+  return std::unique_ptr<geos::geom::GeometryCollection>(
+      getGeometryFactory()->createGeometryCollection(rawGeometries));
+}
+
+} // namespace facebook::velox::common::geospatial
diff --git a/velox/common/geospatial/GeometrySerde.h b/velox/common/geospatial/GeometrySerde.h
new file mode 100644
index 000000000000..3b622b570761
--- /dev/null
+++ b/velox/common/geospatial/GeometrySerde.h
@@ -0,0 +1,518 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/Likely.h>
+#include <geos/geom/CoordinateArraySequence.h>
+#include <geos/geom/Geometry.h>
+#include <geos/geom/GeometryFactory.h>
+
+#include "velox/common/base/IOUtils.h"
+#include "velox/common/geospatial/GeometryConstants.h"
+#include "velox/expression/ComplexViewTypes.h"
+#include "velox/type/StringView.h"
+
+namespace facebook::velox::common::geospatial {
+
+/**
+ * VarbinaryWriter is a utility for serializing raw binary data to a
+ * generic writer interface. It supports writing either raw byte arrays
+ * or trivially copyable types.
+ *
+ * @tparam StringWriter A type that provides an `append(std::string_view)`
+ * method, used to consume the binary output. Examples include `std::string` or
+ *         `core::StringWriter`.
+ */
+template <typename StringWriter>
+class VarbinaryWriter {
+ public:
+  /* implicit */ VarbinaryWriter(StringWriter& stringWriter)
+      : stringWriter_(stringWriter) {}
+  VarbinaryWriter() = delete;
+
+  void write(const char* data, size_t size) {
+    stringWriter_.append(std::string_view(data, size));
+  }
+
+  template <typename T>
+  void write(const T& value) {
+    static_assert(
+        std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+    stringWriter_.append(
+        std::string_view(reinterpret_cast<const char*>(&value), sizeof(T)));
+  }
+
+ private:
+  StringWriter& stringWriter_;
+};
+
+class GeometrySerializer {
+ public:
+  /// Serialize geometry into Velox's internal format.  Do not call this within
+  /// GEOS_TRY macro: it will catch the exceptions that need to bubble up.
+  template <typename StringWriter>
+  static void serialize(
+      const geos::geom::Geometry& geometry,
+      StringWriter& stringWriter) {
+    VarbinaryWriter writer(stringWriter);
+    writeGeometry(geometry, writer);
+  }
+
+  template <typename StringWriter>
+  static void serializeEnvelope(
+      double xMin,
+      double yMin,
+      double xMax,
+      double yMax,
+      StringWriter& stringWriter) {
+    VarbinaryWriter writer(stringWriter);
+    writer.write(static_cast<uint8_t>(GeometrySerializationType::ENVELOPE));
+    writer.write(xMin);
+    writer.write(yMin);
+    writer.write(xMax);
+    writer.write(yMax);
+  }
+
+  template <typename StringWriter>
+  static void serializeEnvelope(
+      geos::geom::Envelope& envelope,
+      StringWriter& stringWriter) {
+    if (FOLLY_UNLIKELY(envelope.isNull())) {
+      serializeEnvelope(
+          std::numeric_limits<double>::quiet_NaN(),
+          std::numeric_limits<double>::quiet_NaN(),
+          std::numeric_limits<double>::quiet_NaN(),
+          std::numeric_limits<double>::quiet_NaN(),
+          stringWriter);
+    } else {
+      serializeEnvelope(
+          envelope.getMinX(),
+          envelope.getMinY(),
+          envelope.getMaxX(),
+          envelope.getMaxY(),
+          stringWriter);
+    }
+  }
+
+  /// Determines if a ring of coordinates (from `start` to `end`) is oriented
+  /// clockwise.
+  FOLLY_ALWAYS_INLINE static bool isClockwise(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
+      size_t start,
+      size_t end) {
+    double sum = 0.0;
+    for (size_t i = start; i < end - 1; i++) {
+      const auto& p1 = coordinates->getAt(i);
+      const auto& p2 = coordinates->getAt(i + 1);
+      sum += (p2.x - p1.x) * (p2.y + p1.y);
+    }
+    return sum > 0.0;
+  }
+
+  /// Reverses the order of coordinates in the sequence between `start` and
+  /// `end`
+  FOLLY_ALWAYS_INLINE static void reverse(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
+      size_t start,
+      size_t end) {
+    for (size_t i = 0; i < (end - start) / 2; ++i) {
+      auto temp = coordinates->getAt(start + i);
+      coordinates->setAt(coordinates->getAt(end - 1 - i), start + i);
+      coordinates->setAt(temp, end - 1 - i);
+    }
+  }
+
+  /// Ensures that a polygon ring has the canonical orientation:
+  /// - Exterior rings (shells) must be clockwise.
+  /// - Interior rings (holes) must be counter-clockwise.
+  FOLLY_ALWAYS_INLINE static void canonicalizePolygonCoordinates(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
+      size_t start,
+      size_t end,
+      bool isShell) {
+    bool isClockwiseFlag = isClockwise(coordinates, start, end);
+
+    if ((isShell && !isClockwiseFlag) || (!isShell && isClockwiseFlag)) {
+      reverse(coordinates, start, end);
+    }
+  }
+
+  /// Applies `canonicalizePolygonCoordinates` to all rings in a polygon.
+  FOLLY_ALWAYS_INLINE static void canonicalizePolygonCoordinates(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coordinates,
+      const std::vector<size_t>& partIndexes,
+      const std::vector<bool>& shellPart) {
+    for (size_t part = 0; part < partIndexes.size() - 1; part++) {
+      canonicalizePolygonCoordinates(
+          coordinates,
+          partIndexes[part],
+          partIndexes[part + 1],
+          shellPart[part]);
+    }
+    if (!partIndexes.empty()) {
+      canonicalizePolygonCoordinates(
+          coordinates,
+          partIndexes.back(),
+          coordinates->size(),
+          shellPart.back());
+    }
+  }
+
+ private:
+  template <typename T>
+  static void writeGeometry(
+      const geos::geom::Geometry& geometry,
+      VarbinaryWriter<T>& writer) {
+    auto geometryType = geometry.getGeometryTypeId();
+    switch (geometryType) {
+      case geos::geom::GEOS_POINT:
+        writePoint(geometry, writer);
+        break;
+      case geos::geom::GEOS_MULTIPOINT:
+        writeMultiPoint(geometry, writer);
+        break;
+      case geos::geom::GEOS_LINESTRING:
+      case geos::geom::GEOS_LINEARRING:
+        writePolyline(geometry, writer, false);
+        break;
+      case geos::geom::GEOS_MULTILINESTRING:
+        writePolyline(geometry, writer, true);
+        break;
+      case geos::geom::GEOS_POLYGON:
+        writePolygon(geometry, writer, false);
+        break;
+      case geos::geom::GEOS_MULTIPOLYGON:
+        writePolygon(geometry, writer, true);
+        break;
+      case geos::geom::GEOS_GEOMETRYCOLLECTION:
+        writeGeometryCollection(geometry, writer);
+        break;
+      default:
+        VELOX_FAIL(
+            "Unrecognized geometry type: {}",
+            static_cast<uint32_t>(geometryType));
+        break;
+    }
+  }
+
+  template <typename T>
+  static void writeEnvelope(
+      const geos::geom::Geometry& geometry,
+      VarbinaryWriter<T>& writer) {
+    if (geometry.isEmpty()) {
+      writer.write(std::numeric_limits<double>::quiet_NaN());
+      writer.write(std::numeric_limits<double>::quiet_NaN());
+      writer.write(std::numeric_limits<double>::quiet_NaN());
+      writer.write(std::numeric_limits<double>::quiet_NaN());
+      return;
+    }
+
+    auto envelope = geometry.getEnvelopeInternal();
+    writer.write(envelope->getMinX());
+    writer.write(envelope->getMinY());
+    writer.write(envelope->getMaxX());
+    writer.write(envelope->getMaxY());
+  }
+
+  template <typename T>
+  static void writeCoordinates(
+      const std::unique_ptr<geos::geom::CoordinateSequence>& coords,
+      VarbinaryWriter<T>& writer) {
+    for (size_t i = 0; i < coords->size(); ++i) {
+      writer.write(coords->getX(i));
+      writer.write(coords->getY(i));
+    }
+  }
+
+  template <typename T>
+  static void writePoint(
+      const geos::geom::Geometry& point,
+      VarbinaryWriter<T>& writer) {
+    writer.write(static_cast<uint8_t>(GeometrySerializationType::POINT));
+    if (!point.isEmpty()) {
+      writeCoordinates(point.getCoordinates(), writer);
+    } else {
+      writer.write(std::numeric_limits<double>::quiet_NaN());
+      writer.write(std::numeric_limits<double>::quiet_NaN());
+    }
+  }
+
+  template <typename T>
+  static void writeMultiPoint(
+      const geos::geom::Geometry& geometry,
+      VarbinaryWriter<T>& writer) {
+    writer.write(static_cast<uint8_t>(GeometrySerializationType::MULTI_POINT));
+    writer.write(static_cast<int32_t>(EsriShapeType::MULTI_POINT));
+    writeEnvelope(geometry, writer);
+    writer.write(static_cast<int32_t>(geometry.getNumPoints()));
+    writeCoordinates(geometry.getCoordinates(), writer);
+  }
+
+  template <typename T>
+  static void writePolyline(
+      const geos::geom::Geometry& geometry,
+      VarbinaryWriter<T>& writer,
+      bool multiType) {
+    size_t numParts;
+    size_t numPoints = geometry.getNumPoints();
+
+    if (multiType) {
+      numParts = geometry.getNumGeometries();
+      writer.write(
+          static_cast<uint8_t>(GeometrySerializationType::MULTI_LINE_STRING));
+    } else {
+      numParts = (numPoints > 0) ? 1 : 0;
+      writer.write(
+          static_cast<uint8_t>(GeometrySerializationType::LINE_STRING));
+    }
+
+    writer.write(static_cast<int32_t>(EsriShapeType::POLYLINE));
+
+    writeEnvelope(geometry, writer);
+
+    writer.write(static_cast<int32_t>(numParts));
+    writer.write(static_cast<int32_t>(numPoints));
+
+    size_t partIndex = 0;
+    for (size_t geomIdx = 0; geomIdx < numParts; ++geomIdx) {
+      writer.write(static_cast<int32_t>(partIndex));
+      partIndex += geometry.getGeometryN(geomIdx)->getNumPoints();
+    }
+
+    if (multiType) {
+      for (size_t partIdx = 0; partIdx < numParts; ++partIdx) {
+        const auto* part = geometry.getGeometryN(partIdx);
+        writeCoordinates(part->getCoordinates(), writer);
+      }
+    } else {
+      writeCoordinates(geometry.getCoordinates(), writer);
+    }
+  }
+
+  template <typename T>
+  static void writePolygon(
+      const geos::geom::Geometry& geometry,
+      VarbinaryWriter<T>& writer,
+      bool multiType) {
+    size_t numGeometries = geometry.getNumGeometries();
+    size_t numParts = 0;
+    size_t numPoints = geometry.getNumPoints();
+
+    for (size_t geomIdx = 0; geomIdx < numGeometries; geomIdx++) {
+      auto polygon = dynamic_cast<const geos::geom::Polygon*>(
+          geometry.getGeometryN(geomIdx));
+      if (polygon && polygon->getNumPoints() > 0) {
+        numParts += polygon->getNumInteriorRing() + 1;
+      }
+    }
+
+    if (multiType) {
+      writer.write(
+          static_cast<uint8_t>(GeometrySerializationType::MULTI_POLYGON));
+    } else {
+      writer.write(static_cast<uint8_t>(GeometrySerializationType::POLYGON));
+    }
+
+    writer.write(static_cast<int32_t>(EsriShapeType::POLYGON));
+    writeEnvelope(geometry, writer);
+
+    writer.write(static_cast<int32_t>(numParts));
+    writer.write(static_cast<int32_t>(numPoints));
+
+    if (numParts == 0) {
+      return;
+    }
+
+    std::vector<size_t> partIndexes(numParts);
+    std::vector<bool> shellPart(numParts);
+
+    size_t currentPart = 0;
+    size_t currentPoint = 0;
+    for (size_t geomIdx = 0; geomIdx < numGeometries; geomIdx++) {
+      const geos::geom::Polygon* polygon =
+          dynamic_cast<const geos::geom::Polygon*>(
+              geometry.getGeometryN(geomIdx));
+
+      partIndexes[currentPart] = currentPoint;
+      shellPart[currentPart] = true;
+      currentPart++;
+      currentPoint += polygon->getExteriorRing()->getNumPoints();
+
+      size_t holesCount = polygon->getNumInteriorRing();
+      for (size_t holeIndex = 0; holeIndex < holesCount; holeIndex++) {
+        partIndexes[currentPart] = currentPoint;
+        shellPart[currentPart] = false;
+        currentPart++;
+        currentPoint += polygon->getInteriorRingN(holeIndex)->getNumPoints();
+      }
+    }
+
+    for (size_t partIndex : partIndexes) {
+      writer.write(static_cast<int32_t>(partIndex));
+    }
+
+    auto coordinates = geometry.getCoordinates();
+    canonicalizePolygonCoordinates(coordinates, partIndexes, shellPart);
+    writeCoordinates(coordinates, writer);
+  }
+
+  template <typename T>
+  static void writeGeometryCollection(
+      const geos::geom::Geometry& collection,
+      VarbinaryWriter<T>& writer) {
+    writer.write(
+        static_cast<uint8_t>(GeometrySerializationType::GEOMETRY_COLLECTION));
+
+    for (size_t geometryIndex = 0;
+         geometryIndex < collection.getNumGeometries();
+         ++geometryIndex) {
+      auto* geometry = collection.getGeometryN(geometryIndex);
+      // Use a temporary buffer to serialize the geometry and calculate its
+      // length
+      std::string tempBuffer;
+      VarbinaryWriter tempOutput(tempBuffer);
+
+      writeGeometry(*geometry, tempOutput);
+
+      int32_t length = static_cast<int32_t>(tempBuffer.size());
+      writer.write(length);
+      writer.write(tempBuffer.data(), tempBuffer.size());
+    }
+  }
+};
+
+class GeometryDeserializer {
+ public:
+  /// Deserialize Velox's internal format to a geometry.  Do not call this
+  /// within GEOS_TRY macro: it will catch the exceptions that need to bubble
+  /// up.
+  static std::unique_ptr<geos::geom::Geometry> deserialize(
+      const StringView& geometryString) {
+    velox::common::InputByteStream inputStream(geometryString.data());
+    return readGeometry(inputStream, geometryString.size());
+  }
+
+  static const std::unique_ptr<geos::geom::Envelope> deserializeEnvelope(
+      const StringView& geometry);
+
+  template <typename T>
+  static std::unique_ptr<geos::geom::CoordinateArraySequence>
+  deserializePointsToCoordinate(
+      const exec::ArrayView<true, T>& input,
+      const std::string& functionName,
+      bool forbidDuplicates) {
+    std::unique_ptr<geos::geom::CoordinateArraySequence> coords =
+        std::make_unique<geos::geom::CoordinateArraySequence>(input.size(), 2);
+
+    double lastX = std::numeric_limits<double>::signaling_NaN();
+    double lastY = std::numeric_limits<double>::signaling_NaN();
+    for (int i = 0; i < input.size(); i++) {
+      if (!input[i].has_value()) {
+        VELOX_USER_FAIL(
+            fmt::format(
+                "Invalid input to {}: input array contains null at index {}.",
+                functionName,
+                i));
+      }
+
+      StringView view = *input[i];
+
+      velox::common::InputByteStream inputStream(view.data());
+      auto geometryType = inputStream.read<GeometrySerializationType>();
+      if (geometryType != GeometrySerializationType::POINT) {
+        VELOX_USER_FAIL(
+            fmt::format(
+                "Non-point geometry in {} input at index {}.",
+                functionName,
+                i));
+      }
+      auto x = inputStream.read<double>();
+      auto y = inputStream.read<double>();
+      if (std::isnan(x) || std::isnan(y)) {
+        VELOX_USER_FAIL(
+            fmt::format(
+                "Empty point in {} input at index {}.", functionName, i));
+      }
+      if (forbidDuplicates && x == lastX && y == lastY) {
+        VELOX_USER_FAIL(
+            fmt::format(
+                "Repeated point sequence in {}: point {},{} at index {}.",
+                functionName,
+                x,
+                y,
+                i));
+      }
+      lastX = x;
+      lastY = y;
+      coords->setAt({x, y}, i);
+    }
+    return coords;
+  }
+
+  /// Returns the thread-local GEOS geometry factory.
+  static geos::geom::GeometryFactory* getGeometryFactory();
+
+ private:
+  static std::unique_ptr<geos::geom::Geometry> readGeometry(
+      velox::common::InputByteStream& stream,
+      size_t size);
+
+  static bool isEsriNaN(double d) {
+    return std::isnan(d) || d < -1.0E38;
+  }
+
+  static void skipEsriType(velox::common::InputByteStream& input) {
+    input.read<int32_t>(); // Esri type is an integer
+  }
+
+  static void skipEnvelope(velox::common::InputByteStream& input) {
+    input.read<double>(4); // Envelopes are 4 doubles (minX, minY, maxX, maxY)
+  }
+
+  static std::unique_ptr<geos::geom::Envelope> deserializeEnvelope(
+      velox::common::InputByteStream& input);
+
+  static geos::geom::Coordinate readCoordinate(
+      velox::common::InputByteStream& input);
+
+  static std::unique_ptr<geos::geom::CoordinateSequence> readCoordinates(
+      velox::common::InputByteStream& input,
+      size_t count);
+
+  static std::unique_ptr<geos::geom::Point> readPoint(
+      velox::common::InputByteStream& input);
+
+  static std::unique_ptr<geos::geom::Geometry> readMultiPoint(
+      velox::common::InputByteStream& input);
+
+  static std::unique_ptr<geos::geom::Geometry> readPolyline(
+      velox::common::InputByteStream& input,
+      bool multiType);
+
+  static std::unique_ptr<geos::geom::Geometry> readPolygon(
+      velox::common::InputByteStream& input,
+      bool multiType);
+
+  static std::unique_ptr<geos::geom::Geometry> readEnvelope(
+      velox::common::InputByteStream& input);
+
+  static std::unique_ptr<geos::geom::Geometry> readGeometryCollection(
+      velox::common::InputByteStream& input,
+      size_t size);
+};
+
+} // namespace facebook::velox::common::geospatial
diff --git a/velox/common/geospatial/tests/CMakeLists.txt b/velox/common/geospatial/tests/CMakeLists.txt
new file mode 100644
index 000000000000..55b2f76cde56
--- /dev/null
+++ b/velox/common/geospatial/tests/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.
+
+if(VELOX_ENABLE_GEO)
+  add_executable(velox_common_geospatial_serde_test GeometrySerdeTest.cpp)
+
+  add_test(velox_common_geospatial_serde_test velox_common_geospatial_serde_test)
+
+  target_link_libraries(
+    velox_common_geospatial_serde_test
+    velox_common_geospatial_serde
+    GTest::gtest
+    GTest::gtest_main
+    GTest::gmock
+    GTest::gmock_main
+    GEOS::geos
+  )
+endif()
diff --git a/velox/common/geospatial/tests/GeometrySerdeTest.cpp b/velox/common/geospatial/tests/GeometrySerdeTest.cpp
new file mode 100644
index 000000000000..14ee6186a682
--- /dev/null
+++ b/velox/common/geospatial/tests/GeometrySerdeTest.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/common/geospatial/GeometrySerde.h"
+#include <geos/geom/Geometry.h>
+#include <geos/io/WKTReader.h>
+#include <geos/io/WKTWriter.h>
+#include <gtest/gtest.h>
+#include "velox/type/StringView.h"
+
+using namespace ::testing;
+
+using namespace facebook::velox::common::geospatial;
+
+void assertRoundtrip(const std::string& wkt) {
+  geos::io::WKTReader reader;
+  geos::io::WKTWriter writer;
+  std::unique_ptr<geos::geom::Geometry> geometry = reader.read(wkt);
+
+  std::string buffer;
+  GeometrySerializer::serialize(*geometry, buffer);
+  facebook::velox::StringView readBuffer(buffer);
+  auto deserialized = GeometryDeserializer::deserialize(readBuffer);
+
+  EXPECT_TRUE(geometry->equals(deserialized.get()))
+      << std::endl
+      << "Input:" << std::endl
+      << wkt << std::endl
+      << "Output:" << std::endl
+      << writer.write(deserialized.get());
+}
+
+TEST(GeometrySerdeTest, testBasicSerde) {
+  assertRoundtrip("POINT EMPTY");
+  assertRoundtrip("POINT (1 2)");
+  assertRoundtrip("MULTIPOINT EMPTY");
+  assertRoundtrip("MULTIPOINT (1 2)");
+  assertRoundtrip("MULTIPOINT (1 2, 1 0)");
+
+  assertRoundtrip("LINESTRING EMPTY");
+  assertRoundtrip("LINESTRING (1 2, 1 0)");
+  assertRoundtrip("LINESTRING (1 0, 2 0, 2 1, 1 1, 1 0)");
+  assertRoundtrip("MULTILINESTRING EMPTY");
+  assertRoundtrip("MULTILINESTRING ((1 2, 1 0))");
+  assertRoundtrip("MULTILINESTRING ((1 2, 1 0), (10 11, 12 13))");
+
+  assertRoundtrip("POLYGON EMPTY");
+  assertRoundtrip("POLYGON ((1 0, 2 0, 2 1, 1 1, 1 0))");
+  assertRoundtrip(
+      "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))");
+  assertRoundtrip("MULTIPOLYGON EMPTY");
+  assertRoundtrip("MULTIPOLYGON (((1 0, 2 0, 2 1, 1 1, 1 0)))");
+  assertRoundtrip(
+      "MULTIPOLYGON ( ((10 0, 20 0, 20 10, 10 10, 10 0)),  ((0 0, 4 0, 4 4, 0 4, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)) )");
+}
+
+TEST(GeometrySerdeTest, testGeometryCollectionSerde) {
+  assertRoundtrip("GEOMETRYCOLLECTION EMPTY");
+  assertRoundtrip("GEOMETRYCOLLECTION (POINT EMPTY)");
+  assertRoundtrip("GEOMETRYCOLLECTION (POINT (0 0))");
+  assertRoundtrip("GEOMETRYCOLLECTION (POINT (0 0), POINT EMPTY)");
+  assertRoundtrip("GEOMETRYCOLLECTION (POINT (0 0), POINT (0 0))");
+  assertRoundtrip("GEOMETRYCOLLECTION (POINT (0 0), POINT (1 1))");
+  assertRoundtrip("GEOMETRYCOLLECTION (MULTIPOINT EMPTY)");
+  assertRoundtrip(
+      "GEOMETRYCOLLECTION (MULTIPOINT (0 0, 1 2), POINT (1 1), MULTIPOINT EMPTY)");
+
+  assertRoundtrip("GEOMETRYCOLLECTION (LINESTRING EMPTY)");
+  assertRoundtrip("GEOMETRYCOLLECTION (MULTILINESTRING EMPTY)");
+  assertRoundtrip(
+      "GEOMETRYCOLLECTION (MULTILINESTRING ((0 1, 2 3, 0 3, 0 1), (10 10, 10 12, 12 10)), POINT EMPTY, LINESTRING (0 0, -1 -1, 2 0))");
+
+  assertRoundtrip("GEOMETRYCOLLECTION (POLYGON EMPTY)");
+  assertRoundtrip("GEOMETRYCOLLECTION (MULTIPOLYGON EMPTY)");
+  assertRoundtrip("GEOMETRYCOLLECTION (GEOMETRYCOLLECTION EMPTY)");
+  assertRoundtrip(
+      "GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (8 4, 5 7), POLYGON EMPTY)");
+  assertRoundtrip(
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION ( MULTIPOINT (1 2) ))");
+}
+
+TEST(GeometrySerdeTest, testComplexSerde) {
+  assertRoundtrip("GEOMETRYCOLLECTION ( MULTIPOINT EMPTY, MULTIPOINT (1 1) )");
+  assertRoundtrip("GEOMETRYCOLLECTION (POLYGON EMPTY, POINT (1 2))");
+  assertRoundtrip(
+      "GEOMETRYCOLLECTION (POLYGON EMPTY, MULTIPOINT (1 2), GEOMETRYCOLLECTION ( MULTIPOINT (3 4) ))");
+  assertRoundtrip(
+      "GEOMETRYCOLLECTION (POLYGON EMPTY, GEOMETRYCOLLECTION ( POINT (1 2), POLYGON ((0 0, 4 0, 4 4, 0 4, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), GEOMETRYCOLLECTION EMPTY, MULTIPOLYGON ( ((10 10, 14 10, 14 14, 10 14, 10 10), (11 11, 12 11, 12 12, 11 12, 11 11)), ((-1 -1, -2 -2, -1 -2, -1 -1)) ) ))");
+}
+
+TEST(GeometrySerdeTest, testSmallAreaRing) {
+  assertRoundtrip(
+      "MULTIPOLYGON (((18.6317421 49.9605785, 18.6318832 49.9607979, 18.6324683 49.9607312, 18.6332842 49.9605658, 18.6332003 49.9603557, 18.6339711 49.9602283, 18.6341994 49.9601905, 18.6343455 49.96016, 18.6344167 49.9601452, 18.6346696 49.9600919, 18.6349643 49.9600567, 18.6352271 49.9601455, 18.6354493 49.9600501, 18.6358024 49.9601071, 18.6358911 49.9600263, 18.6336542 49.9592453, 18.6334794 49.9591838, 18.6337483 49.9581339, 18.6335303 49.9580562, 18.6331284 49.9579122, 18.6324931 49.9576885, 18.6322503 49.9575998, 18.6321381 49.9581593, 18.6321172 49.9582692, 18.6324683 49.9583852, 18.6325255 49.9584004, 18.6327588 49.958489, 18.6324792 49.9588351, 18.6323941 49.9588049, 18.6323261 49.9587807, 18.6320354 49.9586789, 18.6319443 49.9592903, 18.6326731 49.9595648, 18.6331388 49.9594836, 18.6335981 49.959673, 18.6333065 49.9597934, 18.6328096 49.9600844, 18.6330209 49.9601348, 18.633424 49.9602597, 18.6332263 49.960317, 18.6315633 49.9597642, 18.6309331 49.9600741, 18.6317421 49.9605785)), ((18.6298591 49.9606201, 18.6298592 49.96062, 18.6298589 49.9606193, 18.6298591 49.9606201)))");
+}
diff --git a/velox/common/hyperloglog/CMakeLists.txt b/velox/common/hyperloglog/CMakeLists.txt
index 34ff61b18d44..649d1bc9851c 100644
--- a/velox/common/hyperloglog/CMakeLists.txt
+++ b/velox/common/hyperloglog/CMakeLists.txt
@@ -16,12 +16,10 @@ velox_add_library(
   BiasCorrection.cpp
   DenseHll.cpp
   SparseHll.cpp
-  Murmur3Hash128.cpp)
+  Murmur3Hash128.cpp
+)
 
-velox_link_libraries(
-  velox_common_hyperloglog
-  PUBLIC velox_memory
-  PRIVATE velox_exception)
+velox_link_libraries(velox_common_hyperloglog PUBLIC velox_memory PRIVATE velox_exception)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/common/hyperloglog/DenseHll.cpp b/velox/common/hyperloglog/DenseHll.cpp
index f3a3f54b2d2d..2245a3f69096 100644
--- a/velox/common/hyperloglog/DenseHll.cpp
+++ b/velox/common/hyperloglog/DenseHll.cpp
@@ -15,13 +15,13 @@
  */
 #include "velox/common/hyperloglog/DenseHll.h"
 
-#include <exception>
-#include <sstream>
+#include "velox/common/base/BitUtil.h"
 #include "velox/common/base/IOUtils.h"
 #include "velox/common/hyperloglog/BiasCorrection.h"
 #include "velox/common/hyperloglog/HllUtils.h"
 
 namespace facebook::velox::common::hll {
+
 namespace {
 const int kBitsPerBucket = 4;
 const int8_t kMaxDelta = (1 << kBitsPerBucket) - 1;
@@ -119,14 +119,26 @@ double correctBias(double rawEstimate, int8_t indexBitLength) {
 }
 } // namespace
 
-DenseHll::DenseHll(int8_t indexBitLength, HashStringAllocator* allocator)
-    : deltas_{StlAllocator<int8_t>(allocator)},
-      overflowBuckets_{StlAllocator<uint16_t>(allocator)},
-      overflowValues_{StlAllocator<int8_t>(allocator)} {
+template <typename TAllocator>
+DenseHll<TAllocator>::DenseHll(int8_t indexBitLength, TAllocator* allocator)
+    : allocator_(allocator),
+      deltas_{TStlAllocator<int8_t>(allocator)},
+      overflowBuckets_{TStlAllocator<uint16_t>(allocator)},
+      overflowValues_{TStlAllocator<int8_t>(allocator)} {
   initialize(indexBitLength);
 }
 
-void DenseHll::initialize(int8_t indexBitLength) {
+template <typename TAllocator>
+DenseHll<TAllocator>::DenseHll(TAllocator* allocator)
+    : indexBitLength_(-1),
+      baselineCount_(0),
+      allocator_(allocator),
+      deltas_{TStlAllocator<int8_t>(allocator)},
+      overflowBuckets_{TStlAllocator<uint16_t>(allocator)},
+      overflowValues_{TStlAllocator<int8_t>(allocator)} {}
+
+template <typename TAllocator>
+void DenseHll<TAllocator>::initialize(int8_t indexBitLength) {
   VELOX_CHECK_GE(indexBitLength, 4, "indexBitLength must be in [4, 16] range");
   VELOX_CHECK_LE(indexBitLength, 16, "indexBitLength must be in [4, 16] range");
 
@@ -137,13 +149,15 @@ void DenseHll::initialize(int8_t indexBitLength) {
   deltas_.resize(numBuckets * kBitsPerBucket / 8);
 }
 
-void DenseHll::insertHash(uint64_t hash) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::insertHash(uint64_t hash) {
   auto index = computeIndex(hash, indexBitLength_);
   auto value = numberOfLeadingZeros(hash, indexBitLength_) + 1;
   insert(index, value);
 }
 
-void DenseHll::insert(int32_t index, int8_t value) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::insert(int32_t index, int8_t value) {
   auto delta = value - baseline_;
   auto oldDelta = getDelta(index);
 
@@ -261,7 +275,8 @@ DenseHllView deserialize(const char* serialized) {
 }
 } // namespace
 
-int64_t DenseHll::cardinality() const {
+template <typename TAllocator>
+int64_t DenseHll<TAllocator>::cardinality() const {
   DenseHllView hll{
       indexBitLength_,
       baseline_,
@@ -272,18 +287,14 @@ int64_t DenseHll::cardinality() const {
   return cardinalityImpl(hll);
 }
 
-// static
-int64_t DenseHll::cardinality(const char* serialized) {
-  auto hll = deserialize(serialized);
-  return cardinalityImpl(hll);
-}
-
-int8_t DenseHll::getDelta(int32_t index) const {
+template <typename TAllocator>
+int8_t DenseHll<TAllocator>::getDelta(int32_t index) const {
   int slot = index >> 1;
   return (deltas_[slot] >> shiftForBucket(index)) & kBucketMask;
 }
 
-void DenseHll::setDelta(int32_t index, int8_t value) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::setDelta(int32_t index, int8_t value) {
   int slot = index >> 1;
 
   // Clear the old value.
@@ -295,12 +306,14 @@ void DenseHll::setDelta(int32_t index, int8_t value) {
   deltas_[slot] |= setMask;
 }
 
-int8_t DenseHll::getOverflow(int32_t index) const {
+template <typename TAllocator>
+int8_t DenseHll<TAllocator>::getOverflow(int32_t index) const {
   return getOverflowImpl(
       index, overflows_, overflowBuckets_.data(), overflowValues_.data());
 }
 
-int DenseHll::findOverflowEntry(int32_t index) const {
+template <typename TAllocator>
+int DenseHll<TAllocator>::findOverflowEntry(int32_t index) const {
   for (auto i = 0; i < overflows_; i++) {
     if (overflowBuckets_[i] == index) {
       return i;
@@ -309,7 +322,8 @@ int DenseHll::findOverflowEntry(int32_t index) const {
   return -1;
 }
 
-void DenseHll::adjustBaselineIfNeeded() {
+template <typename TAllocator>
+void DenseHll<TAllocator>::adjustBaselineIfNeeded() {
   auto numBuckets = 1 << indexBitLength_;
 
   while (baselineCount_ == 0) {
@@ -359,7 +373,8 @@ void DenseHll::adjustBaselineIfNeeded() {
   }
 }
 
-void DenseHll::sortOverflows() {
+template <typename TAllocator>
+void DenseHll<TAllocator>::sortOverflows() {
   // traditional insertion sort (ok for small arrays)
   for (int i = 1; i < overflows_; i++) {
     auto bucket = overflowBuckets_[i];
@@ -385,7 +400,8 @@ void DenseHll::sortOverflows() {
   }
 }
 
-int32_t DenseHll::serializedSize() const {
+template <typename TAllocator>
+int32_t DenseHll<TAllocator>::serializedSize() const {
   return 1 /* type + version */
       + 1 /* indexBitLength */
       + 1 /* baseline */
@@ -395,13 +411,17 @@ int32_t DenseHll::serializedSize() const {
       + overflows_ /* overflow bucket values */;
 }
 
-// static
-bool DenseHll::canDeserialize(const char* input) {
+int64_t DenseHlls::cardinality(const char* serialized) {
+  auto hll = deserialize(serialized);
+  return cardinalityImpl(hll);
+}
+
+bool DenseHlls::canDeserialize(const char* input) {
   return *reinterpret_cast<const int8_t*>(input) == kPrestoDenseV2;
 }
 
 // static
-bool DenseHll::canDeserialize(const char* input, int size) {
+bool DenseHlls::canDeserialize(const char* input, int size) {
   if (size < 5) {
     // Min serialized sparse HLL size is 5 bytes.
     return false;
@@ -459,22 +479,23 @@ bool DenseHll::canDeserialize(const char* input, int size) {
   return true;
 }
 
-// static
-int8_t DenseHll::deserializeIndexBitLength(const char* input) {
+int8_t DenseHlls::deserializeIndexBitLength(const char* input) {
   common::InputByteStream stream(input);
   stream.read<int8_t>();
   return stream.read<int8_t>();
 }
 
-// static
-int32_t DenseHll::estimateInMemorySize(int8_t indexBitLength) {
+int32_t DenseHlls::estimateInMemorySize(int8_t indexBitLength) {
   // Note: we don't take into account overflow entries since their number can
   // vary.
-  return sizeof(indexBitLength_) + sizeof(baseline_) + sizeof(baselineCount_) +
+  // return sizeof(indexBitLength_) + sizeof(baseline_) +
+  // sizeof(baselineCount_) + (1 << indexBitLength) / 2;
+  return sizeof(int8_t) + sizeof(int8_t) + sizeof(int32_t) +
       (1 << indexBitLength) / 2;
 }
 
-void DenseHll::serialize(char* output) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::serialize(char* output) {
   // sort overflow arrays to get consistent serialization for equivalent HLLs
   sortOverflows();
 
@@ -492,10 +513,12 @@ void DenseHll::serialize(char* output) {
   }
 }
 
-DenseHll::DenseHll(const char* serialized, HashStringAllocator* allocator)
-    : deltas_{StlAllocator<int8_t>(allocator)},
-      overflowBuckets_{StlAllocator<uint16_t>(allocator)},
-      overflowValues_{StlAllocator<int8_t>(allocator)} {
+template <typename TAllocator>
+DenseHll<TAllocator>::DenseHll(const char* serialized, TAllocator* allocator)
+    : allocator_(allocator),
+      deltas_{TStlAllocator<int8_t>(allocator)},
+      overflowBuckets_{TStlAllocator<uint16_t>(allocator)},
+      overflowValues_{TStlAllocator<int8_t>(allocator)} {
   auto hll = deserialize(serialized);
   initialize(hll.indexBitLength);
   baseline_ = hll.baseline;
@@ -525,7 +548,8 @@ DenseHll::DenseHll(const char* serialized, HashStringAllocator* allocator)
   }
 }
 
-void DenseHll::mergeWith(const DenseHll& other) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::mergeWith(const DenseHll& other) {
   VELOX_CHECK_EQ(
       indexBitLength_,
       other.indexBitLength_,
@@ -539,7 +563,8 @@ void DenseHll::mergeWith(const DenseHll& other) {
        other.overflowValues_.data()});
 }
 
-void DenseHll::mergeWith(const char* serialized) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::mergeWith(const char* serialized) {
   common::InputByteStream stream(serialized);
 
   auto version = stream.read<int8_t>();
@@ -561,7 +586,8 @@ void DenseHll::mergeWith(const char* serialized) {
   mergeWith({baseline, deltas, overflows, overflowBuckets, overflowValues});
 }
 
-std::pair<int8_t, int16_t> DenseHll::computeNewValue(
+template <typename TAllocator>
+std::pair<int8_t, int16_t> DenseHll<TAllocator>::computeNewValue(
     int8_t delta,
     int8_t otherDelta,
     int32_t bucket,
@@ -585,7 +611,8 @@ std::pair<int8_t, int16_t> DenseHll::computeNewValue(
   return {std::max(value1, value2), overflowEntry};
 }
 
-void DenseHll::mergeWith(const HllView& other) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::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;
@@ -611,7 +638,10 @@ void DenseHll::mergeWith(const HllView& other) {
   adjustBaselineIfNeeded();
 }
 
-int32_t DenseHll::mergeWithSimd(const HllView& other, int8_t newBaseline) {
+template <typename TAllocator>
+int32_t DenseHll<TAllocator>::mergeWithSimd(
+    const HllView& other,
+    int8_t newBaseline) {
   const auto batchSize = xsimd::batch<int8_t>::size;
 
   const auto bucketMaskBatch = xsimd::broadcast(kBucketMask);
@@ -751,7 +781,10 @@ int32_t DenseHll::mergeWithSimd(const HllView& other, int8_t newBaseline) {
   return baselineCount;
 }
 
-int32_t DenseHll::mergeWithScalar(const HllView& other, int8_t newBaseline) {
+template <typename TAllocator>
+int32_t DenseHll<TAllocator>::mergeWithScalar(
+    const HllView& other,
+    int8_t newBaseline) {
   int32_t baselineCount = 0;
 
   int bucket = 0;
@@ -787,8 +820,11 @@ int32_t DenseHll::mergeWithScalar(const HllView& other, int8_t newBaseline) {
   return baselineCount;
 }
 
-int8_t
-DenseHll::updateOverflow(int32_t index, int overflowEntry, int8_t delta) {
+template <typename TAllocator>
+int8_t DenseHll<TAllocator>::updateOverflow(
+    int32_t index,
+    int overflowEntry,
+    int8_t delta) {
   if (delta > kMaxDelta) {
     if (overflowEntry != -1) {
       // update existing overflow
@@ -804,7 +840,8 @@ DenseHll::updateOverflow(int32_t index, int overflowEntry, int8_t delta) {
   return delta;
 }
 
-void DenseHll::addOverflow(int32_t index, int8_t overflow) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::addOverflow(int32_t index, int8_t overflow) {
   overflowBuckets_.resize(overflows_ + 1);
   overflowValues_.resize(overflows_ + 1);
 
@@ -813,10 +850,17 @@ void DenseHll::addOverflow(int32_t index, int8_t overflow) {
   overflows_++;
 }
 
-void DenseHll::removeOverflow(int overflowEntry) {
+template <typename TAllocator>
+void DenseHll<TAllocator>::removeOverflow(int overflowEntry) {
   // Remove existing overflow.
   overflowBuckets_[overflowEntry] = overflowBuckets_[overflows_ - 1];
   overflowValues_[overflowEntry] = overflowValues_[overflows_ - 1];
   overflows_--;
 }
+
+// Explicit template instantiation for both HashStringAllocator (default) and
+// memory::MemoryPool
+template class DenseHll<HashStringAllocator>;
+template class DenseHll<memory::MemoryPool>;
+
 } // namespace facebook::velox::common::hll
diff --git a/velox/common/hyperloglog/DenseHll.h b/velox/common/hyperloglog/DenseHll.h
index b6b5f03f8cdf..6936b6d8085b 100644
--- a/velox/common/hyperloglog/DenseHll.h
+++ b/velox/common/hyperloglog/DenseHll.h
@@ -17,7 +17,45 @@
 #include "velox/common/memory/HashStringAllocator.h"
 
 namespace facebook::velox::common::hll {
-class SparseHll;
+
+class DenseHlls {
+ public:
+  /// Returns cardinality estimate from the specified serialized digest.
+  /// @param serialized Pointer to serialized DenseHll data
+  /// @return Estimated cardinality of the HyperLogLog
+  static int64_t cardinality(const char* serialized);
+
+  /// Returns true if 'input' contains Presto DenseV2 format indicator.
+  /// @param input Pointer to serialized data to check
+  /// @return True if the data is in DenseV2 format, false otherwise
+  static bool canDeserialize(const char* input);
+
+  /// Returns true if 'input' contains Presto DenseV2 format indicator and the
+  /// rest of the data matches HLL format:
+  /// 1 byte for version
+  /// 1 byte for index bit length, index bit length must be in [4,16]
+  /// 1 byte for baseline value
+  /// 2^(n-1) bytes for buckets, values in buckets must be in [0,63]
+  /// 2 bytes for # overflow buckets
+  /// 3 * #overflow buckets bytes for overflow buckets/values
+  /// More information here:
+  /// https://engineering.fb.com/2018/12/13/data-infrastructure/hyperloglog/
+  /// @param input Pointer to serialized data to validate
+  /// @param size Size of the serialized data in bytes
+  /// @return True if the data is valid DenseV2 format, false otherwise
+  static bool canDeserialize(const char* input, int size);
+
+  /// Extracts the index bit length from serialized DenseHll data.
+  /// @param input Pointer to serialized DenseHll data
+  /// @return The index bit length used in the serialized HLL
+  static int8_t deserializeIndexBitLength(const char* input);
+
+  /// Returns an estimate of memory usage for DenseHll instance with the
+  /// specified number of bits per bucket.
+  /// @param indexBitLength Number of bits per bucket (must be in [4,16])
+  /// @return Estimated memory usage in bytes
+  static int32_t estimateInMemorySize(int8_t indexBitLength);
+};
 
 /// HyperLogLog implementation using dense storage layout.
 /// The number of bits to use as bucket (indexBitLength) is specified by the
@@ -26,18 +64,19 @@ class SparseHll;
 ///
 /// Memory usage: 2 ^ (indexBitLength - 1) bytes. 2KB for indexBitLength of 12
 /// which provides max standard error of 0.023.
+template <typename TAllocator = HashStringAllocator>
 class DenseHll {
  public:
-  DenseHll(int8_t indexBitLength, HashStringAllocator* allocator);
+  template <typename U>
+  using TStlAllocator = typename TAllocator::template TStlAllocator<U>;
+
+  DenseHll(int8_t indexBitLength, TAllocator* allocator);
 
-  DenseHll(const char* serialized, HashStringAllocator* allocator);
+  DenseHll(const char* serialized, TAllocator* allocator);
 
   /// Creates an uninitialized instance that doesn't allcate any significant
   /// memory. The caller must call initialize before using the HLL.
-  explicit DenseHll(HashStringAllocator* allocator)
-      : deltas_{StlAllocator<int8_t>(allocator)},
-        overflowBuckets_{StlAllocator<uint16_t>(allocator)},
-        overflowValues_{StlAllocator<int8_t>(allocator)} {}
+  explicit DenseHll(TAllocator* allocator);
 
   /// Allocates memory that can fit 2 ^ indexBitLength buckets.
   void initialize(int8_t indexBitLength);
@@ -55,28 +94,9 @@ class DenseHll {
 
   int64_t cardinality() const;
 
-  static int64_t cardinality(const char* serialized);
-
   /// Serializes internal state using Presto DenseV2 format.
   void serialize(char* output);
 
-  /// Returns true if 'input' contains Presto DenseV2 format indicator.
-  static bool canDeserialize(const char* input);
-
-  /// Returns true if 'input' contains Presto DenseV2 format indicator and the
-  /// rest of the data matches HLL format:
-  /// 1 byte for version
-  /// 1 byte for index bit length, index bit length must be in [4,16]
-  /// 1 byte for baseline value
-  /// 2^(n-1) bytes for buckets, values in buckets must be in [0,63]
-  /// 2 bytes for # overflow buckets
-  /// 3 * #overflow buckets bytes for overflow buckets/values
-  /// More information here:
-  /// https://engineering.fb.com/2018/12/13/data-infrastructure/hyperloglog/
-  static bool canDeserialize(const char* input, int size);
-
-  static int8_t deserializeIndexBitLength(const char* input);
-
   /// Returns the size of the serialized state without serialising.
   int32_t serializedSize() const;
 
@@ -86,10 +106,6 @@ class DenseHll {
 
   void mergeWith(const char* serialized);
 
-  /// Returns an estimate of memory usage for DenseHll instance with the
-  /// specified number of bits per bucket.
-  static int32_t estimateInMemorySize(int8_t indexBitLength);
-
  private:
   int8_t getDelta(int32_t index) const;
 
@@ -147,20 +163,19 @@ class DenseHll {
   /// Number of zero deltas.
   int32_t baselineCount_;
 
+  TAllocator* allocator_;
+
   /// Per-bucket values represented as deltas from the baseline_. Each entry
   /// stores 2 values, 4 bits each. The maximum value that can be stored is 15.
   /// Larger values are stored in a separate overflow list.
-  std::vector<int8_t, StlAllocator<int8_t>> deltas_;
-
-  /// Number of overflowing values, e.g. values where delta from baseline is
-  /// greater than 15.
+  std::vector<int8_t, TStlAllocator<int8_t>> deltas_;
   int16_t overflows_{0};
 
   /// List of buckets with overflowing values.
-  std::vector<uint16_t, StlAllocator<uint16_t>> overflowBuckets_;
+  std::vector<uint16_t, TStlAllocator<uint16_t>> overflowBuckets_;
 
   /// Overflowing values stored as deltas from the deltas: value - 15 -
   /// baseline.
-  std::vector<int8_t, StlAllocator<int8_t>> overflowValues_;
+  std::vector<int8_t, TStlAllocator<int8_t>> overflowValues_;
 };
 } // namespace facebook::velox::common::hll
diff --git a/velox/common/hyperloglog/HllAccumulator.h b/velox/common/hyperloglog/HllAccumulator.h
new file mode 100644
index 000000000000..4f47b627c18a
--- /dev/null
+++ b/velox/common/hyperloglog/HllAccumulator.h
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#define XXH_INLINE_ALL
+
+#include <xxhash.h>
+#include <cmath>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/hyperloglog/DenseHll.h"
+#include "velox/common/hyperloglog/Murmur3Hash128.h"
+#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/common/memory/HashStringAllocator.h"
+
+namespace facebook::velox::common::hll {
+
+namespace detail {
+template <typename T, bool HllAsFinalResult>
+inline uint64_t hashOne(const T& value) {
+  if constexpr (std::is_same_v<T, Timestamp>) {
+    return hashOne<int64_t, HllAsFinalResult>(value.toMillis());
+  }
+  if constexpr (HllAsFinalResult) {
+    if constexpr (std::is_same_v<T, int64_t>) {
+      return common::hll::Murmur3Hash128::hash64ForLong(value, 0);
+    } else if constexpr (std::is_same_v<T, double>) {
+      return common::hll::Murmur3Hash128::hash64ForLong(
+          *reinterpret_cast<const int64_t*>(&value), 0);
+    }
+    return common::hll::Murmur3Hash128::hash64(&value, sizeof(T), 0);
+  } else {
+    return XXH64(&value, sizeof(T), 0);
+  }
+}
+
+template <>
+inline uint64_t hashOne<StringView, false>(const StringView& value) {
+  return XXH64(value.data(), value.size(), 0);
+}
+
+template <>
+inline uint64_t hashOne<StringView, true>(const StringView& value) {
+  return common::hll::Murmur3Hash128::hash64(value.data(), value.size(), 0);
+}
+
+} // namespace detail
+
+template <
+    typename T,
+    bool HllAsFinalResult,
+    typename TAllocator = HashStringAllocator>
+struct HllAccumulator {
+  explicit HllAccumulator(TAllocator* allocator)
+      : sparseHll_{allocator}, denseHll_{allocator} {}
+
+  explicit HllAccumulator(int8_t indexBitLength, TAllocator* allocator)
+      : isSparse_(true),
+        indexBitLength_(indexBitLength),
+        sparseHll_(allocator),
+        denseHll_(allocator) {
+    // Set soft memory limit for sparse HLL to convert to dense when exceeded.
+    sparseHll_.setSoftMemoryLimit(
+        DenseHlls::estimateInMemorySize(indexBitLength_));
+  }
+
+  void setIndexBitLength(int8_t indexBitLength) {
+    indexBitLength_ = indexBitLength;
+    sparseHll_.setSoftMemoryLimit(
+        DenseHlls::estimateInMemorySize(indexBitLength_));
+  }
+
+  /// Creates an HllAccumulator instance from serialized data.
+  static std::unique_ptr<HllAccumulator> deserialize(
+      const char* data,
+      TAllocator* allocator) {
+    if (SparseHlls::canDeserialize(data)) {
+      int8_t indexBitLength = SparseHlls::deserializeIndexBitLength(data);
+      auto wrapper =
+          std::make_unique<HllAccumulator>(indexBitLength, allocator);
+      wrapper->sparseHll_ = SparseHll<TAllocator>(data, allocator);
+      wrapper->sparseHll_.setSoftMemoryLimit(
+          DenseHlls::estimateInMemorySize(indexBitLength));
+      return wrapper;
+    } else if (DenseHlls::canDeserialize(data)) {
+      int8_t indexBitLength = DenseHlls::deserializeIndexBitLength(data);
+      auto wrapper =
+          std::make_unique<HllAccumulator>(indexBitLength, allocator);
+      wrapper->denseHll_ = DenseHll<TAllocator>(data, allocator);
+      wrapper->isSparse_ = false;
+      return wrapper;
+    } else {
+      VELOX_FAIL("Cannot deserialize HyperLogLog");
+    }
+  }
+
+  void append(T value) {
+    const auto hash = detail::hashOne<T, HllAsFinalResult>(value);
+    insertHash(hash);
+  }
+
+  void insertHash(uint64_t hash) {
+    if (isSparse_) {
+      // insertHash returns true if soft memory limit exceeded
+      if (sparseHll_.insertHash(hash)) {
+        toDense();
+      }
+    } else {
+      denseHll_.insertHash(hash);
+    }
+  }
+
+  int64_t cardinality() const {
+    return isSparse_ ? sparseHll_.cardinality() : denseHll_.cardinality();
+  }
+
+  void mergeWith(StringView serialized, TAllocator* allocator) {
+    auto input = serialized.data();
+    if (indexBitLength_ < 0) {
+      // deserializeIndexBitLength is the same between Dense and Sparse HLL
+      setIndexBitLength(DenseHlls::deserializeIndexBitLength(input));
+    }
+
+    if (SparseHlls::canDeserialize(input)) {
+      SparseHll<TAllocator> other{input, allocator};
+      mergeWithSparse(other);
+    } else if (DenseHlls::canDeserialize(input)) {
+      DenseHll<TAllocator> other{input, allocator};
+      mergeWithDense(other);
+    } else {
+      VELOX_USER_FAIL("Unexpected type of HLL");
+    }
+  }
+
+  void mergeWith(const HllAccumulator& other) {
+    if (indexBitLength_ < 0) {
+      setIndexBitLength(other.indexBitLength_);
+    }
+    if (other.isSparse_) {
+      mergeWithSparse(other.sparseHll_);
+    } else {
+      mergeWithDense(other.denseHll_);
+    }
+  }
+
+  int32_t serializedSize() {
+    return isSparse_ ? sparseHll_.serializedSize() : denseHll_.serializedSize();
+  }
+
+  void serialize(char* outputBuffer) {
+    return isSparse_ ? sparseHll_.serialize(indexBitLength_, outputBuffer)
+                     : denseHll_.serialize(outputBuffer);
+  }
+
+  bool isSparse() const {
+    return isSparse_;
+  }
+
+ private:
+  void toDense() {
+    isSparse_ = false;
+    denseHll_.initialize(indexBitLength_);
+    sparseHll_.toDense(denseHll_);
+    sparseHll_.reset();
+  }
+
+  void mergeWithSparse(const SparseHll<TAllocator>& other) {
+    if (isSparse_) {
+      sparseHll_.mergeWith(other);
+      if (sparseHll_.overLimit()) {
+        toDense();
+      }
+    } else {
+      other.toDense(denseHll_);
+    }
+  }
+
+  void mergeWithDense(const DenseHll<TAllocator>& other) {
+    if (isSparse_) {
+      toDense();
+    }
+    denseHll_.mergeWith(other);
+  }
+
+  bool isSparse_{true};
+  int8_t indexBitLength_{-1};
+  SparseHll<TAllocator> sparseHll_;
+  DenseHll<TAllocator> denseHll_;
+};
+
+template <>
+struct HllAccumulator<bool, false> {
+  explicit HllAccumulator(HashStringAllocator* /*allocator*/) {}
+
+  void append(bool value) {
+    approxDistinctState_ |= (1 << value);
+  }
+
+  int64_t cardinality() const {
+    return (approxDistinctState_ & 1) + ((approxDistinctState_ & 2) >> 1);
+  }
+
+  void mergeWith(
+      StringView /*serialized*/,
+      HashStringAllocator* /*allocator*/) {
+    VELOX_UNREACHABLE(
+        "APPROX_DISTINCT<BOOLEAN> unsupported mergeWith(StringView, HashStringAllocator*)");
+  }
+
+  void mergeWith(int8_t data) {
+    approxDistinctState_ |= data;
+  }
+
+  int32_t serializedSize() const {
+    return sizeof(int8_t);
+  }
+
+  void serialize(char* /*outputBuffer*/) {
+    VELOX_UNREACHABLE("APPROX_DISTINCT<BOOLEAN> unsupported serialize(char*)");
+  }
+
+  void setIndexBitLength(int8_t /*indexBitLength*/) {}
+
+  int8_t getState() const {
+    return approxDistinctState_;
+  }
+
+ private:
+  int8_t approxDistinctState_{0};
+};
+} // namespace facebook::velox::common::hll
diff --git a/velox/common/hyperloglog/KHyperLogLog.h b/velox/common/hyperloglog/KHyperLogLog.h
new file mode 100644
index 000000000000..6f4eca2c3286
--- /dev/null
+++ b/velox/common/hyperloglog/KHyperLogLog.h
@@ -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.
+ */
+#pragma once
+
+#include <map>
+#include <memory>
+
+#include <folly/container/F14Map.h>
+#include "velox/common/base/Status.h"
+#include "velox/common/hyperloglog/HllAccumulator.h"
+
+namespace facebook::velox::common::hll {
+
+/// See "KHyperLogLog: EstimatingReidentifiability and Joinability of Large Data
+/// at Scale" by Chia et al., 2019.
+/// https://research.google/pubs/khyperloglog-estimating-reidentifiability-and-joinability-of-large-data-at-scale/
+template <typename TUii, typename TAllocator>
+class KHyperLogLog {
+ public:
+  template <typename U>
+  using TStlAllocator = typename TAllocator::template TStlAllocator<U>;
+
+  static constexpr int32_t kDefaultHllBuckets = 256;
+  static constexpr int32_t kDefaultMaxSize = 4096;
+
+  explicit KHyperLogLog(TAllocator* allocator)
+      : KHyperLogLog(kDefaultMaxSize, kDefaultHllBuckets, allocator) {}
+
+  KHyperLogLog(int maxSize, int hllBuckets, TAllocator* allocator)
+      : maxSize_(maxSize),
+        hllBuckets_(hllBuckets),
+        allocator_(allocator),
+        minhash_(
+            TStlAllocator<std::pair<
+                const int64_t,
+                HllAccumulator<TUii, true, TAllocator>>>(allocator)) {
+    VELOX_CHECK(
+        hllBuckets > 0 && (hllBuckets & (hllBuckets - 1)) == 0,
+        "hllBuckets must be a power of 2");
+    // numBuckets = 2^bits
+    indexBitLength_ = static_cast<int8_t>(std::log2(hllBuckets));
+  }
+
+  /// Creates a KHyperLogLog instance from serialized data.
+  /// Returns an error status if the data is invalid.
+  static Expected<std::unique_ptr<KHyperLogLog<TUii, TAllocator>>>
+  deserialize(const char* data, size_t size, TAllocator* allocator);
+
+  /// Serializes the KHyperLogLog state to a varbinary.
+  /// The caller must ensure there is enough space at the buffer location, using
+  /// estimatedSerializedSize(). Note: Not const because DenseHll::serialize()
+  /// may reorder internal overflow arrays for deterministic serialization.
+  void serialize(char* outputBuffer);
+
+  /// Returns an estimate of the size in bytes of the serialized
+  /// representation.
+  size_t estimatedSerializedSize() const;
+
+  /// Convert JoinKey to int64_t, hash, then add with its associated User
+  /// Identifying Information (UII) to the existing KHLL.
+  template <typename TJoinKey>
+  void add(TJoinKey joinKey, TUii uii);
+
+  /// Returns the estimated cardinality (number of distinct join keys).
+  /// When isExact() is true, returns exact count. Otherwise, uses min-hash
+  /// density estimation to extrapolate to the full hash space.
+  int64_t cardinality() const;
+
+  /// Returns whether the KHyperLogLog is in exact mode.
+  /// Exact mode means the number of distinct values is less than maxSize,
+  /// so all values are being tracked exactly without approximation.
+  bool isExact() const;
+
+  size_t minhashSize() const;
+
+  /// Counts the exact number of common join keys between two KHyperLogLogs.
+  /// Both instances must be in exact mode (isExact() == true), otherwise
+  /// throws.
+  static int64_t exactIntersectionCardinality(
+      const KHyperLogLog<TUii, TAllocator>& left,
+      const KHyperLogLog<TUii, TAllocator>& right);
+
+  /// Computes the Jaccard index (similarity coefficient) between two
+  /// KHyperLogLogs. Uses the min-hash approach: looks at the first
+  /// min(|left.minhash|, |right.minhash|) entries in the sorted union of keys
+  /// and calculates the proportion that appear in both sets.
+  static double jaccardIndex(
+      const KHyperLogLog<TUii, TAllocator>& left,
+      const KHyperLogLog<TUii, TAllocator>& right);
+
+  /// Merges two KHyperLogLog instances into a new instance.
+  /// Uses the one with the smaller maxSize as the base to avoid losing
+  /// resolution. Takes ownership of the input unique_ptrs and returns one
+  /// of them to avoid copying.
+  static std::unique_ptr<KHyperLogLog<TUii, TAllocator>> merge(
+      std::unique_ptr<KHyperLogLog<TUii, TAllocator>> left,
+      std::unique_ptr<KHyperLogLog<TUii, TAllocator>> right);
+
+  /// Calculates the reidentification potential, which is the proportion of
+  /// values with cardinality (number of distinct UIIs) at or below the given
+  /// threshold. A higher value indicates more values are highly unique and
+  /// could potentially be used to reidentify individuals.
+  double reidentificationPotential(int64_t threshold) const;
+
+  /// Returns a histogram of the uniqueness distribution with specified number
+  /// of buckets. For each value, determines its cardinality (number of distinct
+  /// UIIs) and increments the corresponding bucket. For hash values larger than
+  /// the histogram size, the cardinality will be added to the last bucket at
+  /// histogramSize.
+  folly::F14FastMap<int64_t, double> uniquenessDistribution(
+      int64_t histogramSize) const;
+
+  /// Merges another KHyperLogLog instance into this one (modifies this
+  /// instance).
+  void mergeWith(const KHyperLogLog<TUii, TAllocator>& other);
+
+  /// Merges another serialized KHyperLogLog into this one.
+  /// The serialized data is assumed to be valid.
+  void mergeWith(StringView serialized, TAllocator* allocator) {
+    auto other = common::hll::KHyperLogLog<TUii, TAllocator>::deserialize(
+        serialized.data(), serialized.size(), allocator);
+    VELOX_CHECK(other.hasValue(), "Failed to deserialize KHyperLogLog");
+    mergeWith(*other.value());
+  }
+
+ private:
+  void update(int64_t hash, TUii uii);
+
+  void removeOverflowEntries();
+
+  void increaseTotalHllSize(HllAccumulator<TUii, true, TAllocator>& hll);
+
+  void decreaseTotalHllSize(HllAccumulator<TUii, true, TAllocator>& hll);
+
+  int64_t maxKey() const {
+    if (minhash_.empty()) {
+      return INT64_MIN;
+    }
+    return minhash_.rbegin()->first;
+  }
+
+  int32_t maxSize_;
+  int32_t hllBuckets_;
+  int8_t indexBitLength_;
+  TAllocator* allocator_;
+
+  std::map<
+      int64_t,
+      HllAccumulator<TUii, true, TAllocator>,
+      std::less<int64_t>,
+      TStlAllocator<
+          std::pair<const int64_t, HllAccumulator<TUii, true, TAllocator>>>>
+      minhash_;
+
+  size_t hllsTotalEstimatedSerializedSize_{0};
+};
+
+} // namespace facebook::velox::common::hll
+
+#include "velox/common/hyperloglog/KHyperLogLogImpl.h"
diff --git a/velox/common/hyperloglog/KHyperLogLogImpl.h b/velox/common/hyperloglog/KHyperLogLogImpl.h
new file mode 100644
index 000000000000..757ed4fcf298
--- /dev/null
+++ b/velox/common/hyperloglog/KHyperLogLogImpl.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/common/base/Exceptions.h"
+#include "velox/common/base/IOUtils.h"
+#include "velox/common/hyperloglog/Murmur3Hash128.h"
+#include "velox/type/HugeInt.h"
+
+namespace facebook::velox::common::hll {
+
+namespace detail {
+constexpr uint8_t kVersionByte = 1;
+constexpr int64_t kHashOutputHalfRange = INT64_MAX;
+constexpr size_t kHeaderSize = sizeof(uint8_t) // version
+    + 4 * sizeof(int32_t); // maxSize, hllBuckets, minhashSize, hllsTotalSize;
+
+template <typename TJoinKey>
+static int64_t hashKey(TJoinKey joinKey) {
+  int64_t result;
+  if constexpr (std::is_same_v<TJoinKey, Timestamp>) {
+    result = joinKey.toMillis();
+  } else if constexpr (
+      std::is_same_v<TJoinKey, int128_t> ||
+      std::is_same_v<TJoinKey, uint128_t>) {
+    return Murmur3Hash128::hash64(&joinKey, sizeof(joinKey), 0);
+  } else if constexpr (std::is_integral_v<TJoinKey>) {
+    result = static_cast<int64_t>(joinKey);
+  } else if constexpr (std::is_same_v<TJoinKey, float>) {
+    // Cast to double first, then extract bits, based on implicit coercion
+    double dbl = static_cast<double>(joinKey);
+    std::memcpy(&result, &dbl, sizeof(result));
+  } else if constexpr (std::is_same_v<TJoinKey, double>) {
+    std::memcpy(&result, &joinKey, sizeof(result));
+  } else if constexpr (std::is_same_v<TJoinKey, StringView>) {
+    result =
+        common::hll::Murmur3Hash128::hash64(joinKey.data(), joinKey.size(), 0);
+  } else {
+    VELOX_UNREACHABLE("Unsupported input type: {}", typeid(TJoinKey).name());
+  }
+
+  return Murmur3Hash128::hash64(&result, sizeof(result), 0);
+}
+} // namespace detail
+
+template <typename TUii, typename TAllocator>
+Expected<std::unique_ptr<KHyperLogLog<TUii, TAllocator>>>
+KHyperLogLog<TUii, TAllocator>::deserialize(
+    const char* data,
+    size_t size,
+    TAllocator* allocator) {
+  VELOX_RETURN_UNEXPECTED_IF(
+      size < sizeof(uint8_t),
+      Status::UserError("Invalid KHyperLogLog data: too small"));
+
+  InputByteStream stream(data);
+
+  uint8_t version = stream.read<uint8_t>();
+  VELOX_RETURN_UNEXPECTED_IF(
+      version != detail::kVersionByte,
+      Status::UserError("Unsupported KHyperLogLog version"));
+
+  VELOX_RETURN_UNEXPECTED_IF(
+      size < detail::kHeaderSize,
+      Status::UserError("Invalid KHyperLogLog data: insufficient header size"));
+
+  // Header values
+  int32_t maxSize = stream.read<int32_t>();
+  int32_t hllBuckets = stream.read<int32_t>();
+  int32_t minhashSize = stream.read<int32_t>();
+  int32_t totalHllSize = stream.read<int32_t>();
+
+  if (minhashSize == 0) {
+    VELOX_RETURN_UNEXPECTED_IF(
+        totalHllSize != 0,
+        Status::UserError(
+            "Invalid KHyperLogLog data: minhashSize is 0 but totalHllSize is not 0"));
+    size_t remainingSize = size - stream.offset();
+    VELOX_RETURN_UNEXPECTED_IF(
+        remainingSize != 0,
+        Status::UserError(
+            "Invalid KHyperLogLog data: minhashSize is 0 but extra data remains"));
+    return std::make_unique<KHyperLogLog<TUii, TAllocator>>(
+        maxSize, hllBuckets, allocator);
+  }
+
+  // Validate remaining size.
+  size_t expectedRemainingSize =
+      minhashSize * (sizeof(int32_t) + sizeof(int64_t)) + totalHllSize;
+  size_t remainingSize = size - stream.offset();
+  VELOX_RETURN_UNEXPECTED_IF(
+      remainingSize < expectedRemainingSize,
+      Status::UserError(
+          "Invalid KHyperLogLog data: insufficient data for minhash and HLLs"));
+
+  // Read HLL sizes.
+  std::vector<int32_t> hllSizes(minhashSize);
+  stream.copyTo(hllSizes.data(), minhashSize);
+
+  // Read keys.
+  std::vector<int64_t> keys(minhashSize);
+  stream.copyTo(keys.data(), minhashSize);
+
+  // Create KHyperLogLog instance.
+  auto result = std::make_unique<KHyperLogLog<TUii, TAllocator>>(
+      maxSize, hllBuckets, allocator);
+
+  // Deserialize HLLs.
+  const char* hllData = data + stream.offset();
+  remainingSize = size - stream.offset();
+
+  size_t sumOfHllSizes = 0;
+  for (int32_t hllSize : hllSizes) {
+    sumOfHllSizes += hllSize;
+  }
+
+  VELOX_RETURN_UNEXPECTED_IF(
+      remainingSize < sumOfHllSizes,
+      Status::UserError(
+          "Invalid KHyperLogLog data: insufficient data for HLLs"));
+
+  for (int32_t i = 0; i < minhashSize; ++i) {
+    int32_t hllSize = hllSizes[i];
+    int64_t key = keys[i];
+
+    auto hll =
+        HllAccumulator<TUii, true, TAllocator>::deserialize(hllData, allocator);
+    result->increaseTotalHllSize(*hll);
+    result->minhash_.emplace(key, std::move(*hll));
+
+    hllData += hllSize;
+    remainingSize -= hllSize;
+  }
+
+  return result;
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::serialize(char* outputBuffer) {
+  OutputByteStream stream(outputBuffer);
+
+  // Write version.
+  stream.appendOne<uint8_t>(detail::kVersionByte);
+
+  // Write header.
+  stream.appendOne<int32_t>(maxSize_);
+  stream.appendOne<int32_t>(hllBuckets_);
+  stream.appendOne<int32_t>(static_cast<int32_t>(minhash_.size()));
+
+  // Write the sum of all HLL sizes.
+  int32_t totalHllSize = 0;
+  for (auto& [key, hll] : minhash_) {
+    totalHllSize += hll.serializedSize();
+  }
+  stream.appendOne<int32_t>(totalHllSize);
+
+  // Write HLL sizes in sorted key order. minHash_ is a sorted map, so no
+  // additional sorting is necessary for deterministic serialization.
+  int32_t maxSerializedSize = 0;
+  for (auto& [key, hll] : minhash_) {
+    int32_t hllSerializedSize = hll.serializedSize();
+    stream.appendOne<int32_t>(hllSerializedSize);
+    maxSerializedSize = std::max(maxSerializedSize, hllSerializedSize);
+  }
+
+  // Write keys in sorted order.
+  for (const auto& [key, hll] : minhash_) {
+    stream.appendOne<int64_t>(key);
+  }
+
+  // Write serialized HLLs in sorted key order.
+  std::string hllBuffer(maxSerializedSize, '\0');
+  for (auto& [key, hll] : minhash_) {
+    const_cast<HllAccumulator<TUii, true, TAllocator>&>(hll).serialize(
+        hllBuffer.data());
+    stream.append(hllBuffer.data(), hll.serializedSize());
+  }
+}
+
+template <typename TUii, typename TAllocator>
+size_t KHyperLogLog<TUii, TAllocator>::estimatedSerializedSize() const {
+  return detail::kHeaderSize + // header: version, maxSize, hllBuckets,
+                               // minhashSize, totalHllSize
+      minhash_.size() * sizeof(int32_t) + // individual HLL sizes +
+      minhash_.size() * sizeof(int64_t) + // minhash keys +
+      hllsTotalEstimatedSerializedSize_; // sum of all HLL serialized sizes
+}
+
+template <typename TUii, typename TAllocator>
+template <typename TJoinKey>
+void KHyperLogLog<TUii, TAllocator>::add(TJoinKey joinKey, TUii uii) {
+  update(detail::hashKey(joinKey), uii);
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::update(int64_t hash, TUii uii) {
+  auto it = minhash_.end();
+  if (!(isExact() || (minhash_.size() > 0 && hash < maxKey()) ||
+        ((it = minhash_.find(hash)) != minhash_.end()))) {
+    return;
+  }
+
+  // Get or create HLL for this hash.
+  HllAccumulator<TUii, true, TAllocator>* hll;
+  if (it == minhash_.end()) {
+    auto [iterator, inserted] = minhash_.emplace(
+        hash,
+        HllAccumulator<TUii, true, TAllocator>(indexBitLength_, allocator_));
+    hll = &iterator->second;
+  } else {
+    hll = &it->second;
+    decreaseTotalHllSize(*hll);
+  }
+
+  hll->append(uii);
+
+  increaseTotalHllSize(*hll);
+  removeOverflowEntries();
+}
+
+template <typename TUii, typename TAllocator>
+int64_t KHyperLogLog<TUii, TAllocator>::cardinality() const {
+  if (isExact()) {
+    return static_cast<int64_t>(minhash_.size());
+  }
+
+  // Estimate cardinality by calculating the average spacing (density) between
+  // stored hash values, then extrapolating to the full hash space.
+  // The hash range is the full 64-bit hash range (2^64) which does not fit in a
+  // double, so both the hash range and the density are halved to keep
+  // proportions mathematically correct. The "-1" is a statistical bias
+  // correction from "On Synopses for Distinct-Value Estimation Under Multiset
+  // Operations" by Beyer et. al.
+  // Use unsigned arithmetic to avoid overflow for large maxKey values.
+  uint64_t hashesRange =
+      static_cast<uint64_t>(maxKey()) - static_cast<uint64_t>(INT64_MIN);
+  double halfDensity =
+      static_cast<double>(hashesRange) / (minhash_.size() - 1) / 2.0;
+  return static_cast<int64_t>(
+      static_cast<double>(detail::kHashOutputHalfRange) / halfDensity);
+}
+
+template <typename TUii, typename TAllocator>
+bool KHyperLogLog<TUii, TAllocator>::isExact() const {
+  return static_cast<int32_t>(minhash_.size()) < maxSize_;
+}
+
+template <typename TUii, typename TAllocator>
+size_t KHyperLogLog<TUii, TAllocator>::minhashSize() const {
+  return minhash_.size();
+}
+
+template <typename TUii, typename TAllocator>
+int64_t KHyperLogLog<TUii, TAllocator>::exactIntersectionCardinality(
+    const KHyperLogLog<TUii, TAllocator>& left,
+    const KHyperLogLog<TUii, TAllocator>& right) {
+  VELOX_CHECK(
+      left.isExact(),
+      "exactIntersectionCardinality cannot operate on approximate sets");
+  VELOX_CHECK(
+      right.isExact(),
+      "exactIntersectionCardinality cannot operate on approximate sets");
+
+  // Optimize by iterating through the smaller map and checking the larger one.
+  const auto& smaller = left.minhash_.size() <= right.minhash_.size()
+      ? left.minhash_
+      : right.minhash_;
+  const auto& larger = left.minhash_.size() <= right.minhash_.size()
+      ? right.minhash_
+      : left.minhash_;
+
+  // Count intersection of keys.
+  int64_t intersectionCnt = 0;
+  for (const auto& [key, hll] : smaller) {
+    if (larger.contains(key)) {
+      intersectionCnt++;
+    }
+  }
+
+  return intersectionCnt;
+}
+
+template <typename TUii, typename TAllocator>
+double KHyperLogLog<TUii, TAllocator>::jaccardIndex(
+    const KHyperLogLog<TUii, TAllocator>& left,
+    const KHyperLogLog<TUii, TAllocator>& right) {
+  if (left.minhash_.empty() && right.minhash_.empty()) {
+    return 1.0;
+  }
+  auto smallerSize = std::min(left.minhash_.size(), right.minhash_.size());
+
+  if (smallerSize == 0) {
+    return 0.0;
+  }
+
+  auto itA = left.minhash_.begin();
+  auto itB = right.minhash_.begin();
+
+  auto intersectionCnt = 0;
+  auto unionCnt = 0;
+
+  // Merge the two sorted sequences, counting intersection along the way.
+  while (itA != left.minhash_.end() && itB != right.minhash_.end() &&
+         unionCnt < smallerSize) {
+    if (itA->first < itB->first) {
+      ++itA;
+    } else if (itB->first < itA->first) {
+      ++itB;
+    } else {
+      intersectionCnt++;
+      ++itA;
+      ++itB;
+    }
+    unionCnt++;
+  }
+
+  return static_cast<double>(intersectionCnt) / smallerSize;
+}
+
+template <typename TUii, typename TAllocator>
+std::unique_ptr<KHyperLogLog<TUii, TAllocator>>
+KHyperLogLog<TUii, TAllocator>::merge(
+    std::unique_ptr<KHyperLogLog<TUii, TAllocator>> left,
+    std::unique_ptr<KHyperLogLog<TUii, TAllocator>> right) {
+  // The KHLL with the smaller K will be used as base. This is because if a KHLL
+  // with a smaller K is merged into a KHLL with a larger K, the smaller KHLL's
+  // minhash will not cover all of the larger minhash's range. Instead, we want
+  // to keep only the smallest K number of HLLs in the new KHLL.
+  if (left->maxSize_ <= right->maxSize_) {
+    left->mergeWith(*right);
+    return std::move(left);
+  } else {
+    right->mergeWith(*left);
+    return std::move(right);
+  }
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::mergeWith(
+    const KHyperLogLog<TUii, TAllocator>& other) {
+  for (const auto& [key, otherHll] : other.minhash_) {
+    auto it = minhash_.find(key);
+    if (it != minhash_.end()) {
+      decreaseTotalHllSize(it->second);
+      it->second.mergeWith(otherHll);
+      increaseTotalHllSize(it->second);
+    } else {
+      HllAccumulator<TUii, true, TAllocator> newHll(
+          indexBitLength_, allocator_);
+      newHll.mergeWith(otherHll);
+      increaseTotalHllSize(newHll);
+      minhash_.emplace(key, std::move(newHll));
+    }
+  }
+
+  removeOverflowEntries();
+}
+
+template <typename TUii, typename TAllocator>
+double KHyperLogLog<TUii, TAllocator>::reidentificationPotential(
+    int64_t threshold) const {
+  if (minhash_.empty()) {
+    return 0.0;
+  }
+  int64_t highlyUniqueValues = 0;
+
+  for (const auto& [key, hll] : minhash_) {
+    if (hll.cardinality() <= threshold) {
+      highlyUniqueValues++;
+    }
+  }
+
+  return static_cast<double>(highlyUniqueValues) / minhash_.size();
+}
+
+template <typename TUii, typename TAllocator>
+folly::F14FastMap<int64_t, double>
+KHyperLogLog<TUii, TAllocator>::uniquenessDistribution(
+    int64_t histogramSize) const {
+  folly::F14FastMap<int64_t, double> out;
+
+  for (int64_t i = 1; i <= histogramSize; ++i) {
+    out[i] = 0.0;
+  }
+
+  int64_t size = minhash_.size();
+  if (size == 0) {
+    return out;
+  }
+
+  double bucketScale = 1.0 / static_cast<double>(size);
+  for (const auto& [key, hll] : minhash_) {
+    int64_t cardinality = hll.cardinality();
+    int64_t bucket = std::min(cardinality, histogramSize);
+    out[bucket] += bucketScale;
+  }
+
+  return out;
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::removeOverflowEntries() {
+  while (static_cast<int32_t>(minhash_.size()) > maxSize_) {
+    auto maxIt = std::prev(minhash_.end());
+    if (maxIt != minhash_.end()) {
+      decreaseTotalHllSize(maxIt->second);
+      minhash_.erase(maxIt);
+    }
+  }
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::increaseTotalHllSize(
+    HllAccumulator<TUii, true, TAllocator>& hll) {
+  hllsTotalEstimatedSerializedSize_ += hll.serializedSize();
+}
+
+template <typename TUii, typename TAllocator>
+void KHyperLogLog<TUii, TAllocator>::decreaseTotalHllSize(
+    HllAccumulator<TUii, true, TAllocator>& hll) {
+  hllsTotalEstimatedSerializedSize_ -= hll.serializedSize();
+}
+
+} // namespace facebook::velox::common::hll
diff --git a/velox/common/hyperloglog/SparseHll.cpp b/velox/common/hyperloglog/SparseHll.cpp
index 27d290dd10ef..ed1fc10800ea 100644
--- a/velox/common/hyperloglog/SparseHll.cpp
+++ b/velox/common/hyperloglog/SparseHll.cpp
@@ -34,9 +34,8 @@ inline uint32_t decodeValue(uint32_t entry) {
   return entry & ((1 << kValueBitLength) - 1);
 }
 
-int searchIndex(
-    uint32_t index,
-    const std::vector<uint32_t, StlAllocator<uint32_t>>& entries) {
+template <typename VectorType>
+int searchIndex(uint32_t index, const VectorType& entries) {
   int low = 0;
   int high = entries.size() - 1;
 
@@ -69,7 +68,65 @@ common::InputByteStream initializeInputStream(const char* serialized) {
 }
 } // namespace
 
-bool SparseHll::insertHash(uint64_t hash) {
+// Static utility functions implementation
+int64_t SparseHlls::cardinality(const char* serialized) {
+  static const int kTotalBuckets = 1 << kIndexBitLength;
+
+  auto stream = initializeInputStream(serialized);
+  auto size = stream.read<int16_t>();
+
+  int zeroBuckets = kTotalBuckets - size;
+  return std::round(linearCounting(zeroBuckets, kTotalBuckets));
+}
+
+std::string SparseHlls::serializeEmpty(int8_t indexBitLength) {
+  static const size_t kSize = 4;
+
+  std::string serialized;
+  serialized.resize(kSize);
+
+  common::OutputByteStream stream(serialized.data());
+  stream.appendOne(kPrestoSparseV2);
+  stream.appendOne(indexBitLength);
+  stream.appendOne(static_cast<int16_t>(0));
+  return serialized;
+}
+
+bool SparseHlls::canDeserialize(const char* input) {
+  return *reinterpret_cast<const int8_t*>(input) == kPrestoSparseV2;
+}
+
+int8_t SparseHlls::deserializeIndexBitLength(const char* input) {
+  common::InputByteStream stream(input);
+  stream.read<int8_t>(); // Skip version
+  return stream.read<int8_t>(); // Return indexBitLength
+}
+
+// Template method implementations
+template <typename TAllocator>
+SparseHll<TAllocator>::SparseHll(TAllocator* allocator)
+    : allocator_(allocator), entries_{TStlAllocator<uint32_t>(allocator)} {}
+
+template <typename TAllocator>
+SparseHll<TAllocator>::SparseHll(const char* serialized, TAllocator* allocator)
+    : allocator_(allocator), entries_{TStlAllocator<uint32_t>(allocator)} {
+  common::InputByteStream stream(serialized);
+  auto version = stream.read<int8_t>();
+  VELOX_CHECK_EQ(kPrestoSparseV2, version);
+
+  // Skip indexBitLength from serialized data - we use fixed kIndexBitLength
+  // internally
+  stream.read<int8_t>();
+
+  auto size = stream.read<int16_t>();
+  entries_.resize(size);
+  for (auto i = 0; i < size; i++) {
+    entries_[i] = stream.read<uint32_t>();
+  }
+}
+
+template <typename TAllocator>
+bool SparseHll<TAllocator>::insertHash(uint64_t hash) {
   auto index = computeIndex(hash, kIndexBitLength);
   auto value = numberOfLeadingZeros(hash, kIndexBitLength);
 
@@ -88,29 +145,21 @@ bool SparseHll::insertHash(uint64_t hash) {
   return overLimit();
 }
 
-int64_t SparseHll::cardinality() const {
+template <typename TAllocator>
+int64_t SparseHll<TAllocator>::cardinality() const {
   // Estimate the cardinality using linear counting over the theoretical
   // 2^kIndexBitLength buckets available due to the fact that we're
   // recording the raw leading kIndexBitLength of the hash. This produces
   // much better precision while in the sparse regime.
-  static const int kTotalBuckets = 1 << kIndexBitLength;
+  const int kTotalBuckets = 1 << kIndexBitLength;
 
   int zeroBuckets = kTotalBuckets - entries_.size();
   return std::round(linearCounting(zeroBuckets, kTotalBuckets));
 }
 
-// static
-int64_t SparseHll::cardinality(const char* serialized) {
-  static const int kTotalBuckets = 1 << kIndexBitLength;
-
-  auto stream = initializeInputStream(serialized);
-  auto size = stream.read<int16_t>();
-
-  int zeroBuckets = kTotalBuckets - size;
-  return std::round(linearCounting(zeroBuckets, kTotalBuckets));
-}
-
-void SparseHll::serialize(int8_t indexBitLength, char* output) const {
+template <typename TAllocator>
+void SparseHll<TAllocator>::serialize(int8_t indexBitLength, char* output)
+    const {
   common::OutputByteStream stream(output);
   stream.appendOne(kPrestoSparseV2);
   stream.appendOne(indexBitLength);
@@ -120,75 +169,54 @@ void SparseHll::serialize(int8_t indexBitLength, char* output) const {
   }
 }
 
-// static
-std::string SparseHll::serializeEmpty(int8_t indexBitLength) {
-  static const size_t kSize = 4;
-
-  std::string serialized;
-  serialized.resize(kSize);
-
-  common::OutputByteStream stream(serialized.data());
-  stream.appendOne(kPrestoSparseV2);
-  stream.appendOne(indexBitLength);
-  stream.appendOne(static_cast<int16_t>(0));
-  return serialized;
-}
-
-// static
-bool SparseHll::canDeserialize(const char* input) {
-  return *reinterpret_cast<const int8_t*>(input) == kPrestoSparseV2;
-}
-
-int32_t SparseHll::serializedSize() const {
+template <typename TAllocator>
+int32_t SparseHll<TAllocator>::serializedSize() const {
   return 1 /* version */
       + 1 /* indexBitLength */
       + 2 /* number of entries */
       + entries_.size() * 4;
 }
 
-int32_t SparseHll::inMemorySize() const {
+template <typename TAllocator>
+int32_t SparseHll<TAllocator>::inMemorySize() const {
   return sizeof(uint32_t) * entries_.size();
 }
 
-SparseHll::SparseHll(const char* serialized, HashStringAllocator* allocator)
-    : entries_{StlAllocator<uint32_t>(allocator)} {
-  auto stream = initializeInputStream(serialized);
-
-  auto size = stream.read<int16_t>();
-  entries_.resize(size);
-  for (auto i = 0; i < size; i++) {
-    entries_[i] = stream.read<uint32_t>();
-  }
-}
-
-void SparseHll::mergeWith(const SparseHll& other) {
+template <typename TAllocator>
+void SparseHll<TAllocator>::mergeWith(const SparseHll<TAllocator>& other) {
   auto size = other.entries_.size();
   // This check prevents merge aggregation from being performed on
-  // empty_approx_set(), an empty HyperLogLog. The merge function typically does
-  // not take an empty HyperLogLog structure as an argument.
+  // empty_approx_set(), an empty HyperLogLog. The merge function typically
+  // does not take an empty HyperLogLog structure as an argument.
   if (size) {
     mergeWith(size, other.entries_.data());
   }
 }
 
-void SparseHll::mergeWith(const char* serialized) {
+template <typename TAllocator>
+void SparseHll<TAllocator>::mergeWith(const char* serialized) {
   auto stream = initializeInputStream(serialized);
 
   auto size = stream.read<int16_t>();
   // This check prevents merge aggregation from being performed on
-  // empty_approx_set(), an empty HyperLogLog. The merge function typically does
-  // not take an empty HyperLogLog structure as an argument.
+  // empty_approx_set(), an empty HyperLogLog. The merge function typically
+  // does not take an empty HyperLogLog structure as an argument.
   if (size) {
     mergeWith(
         size, reinterpret_cast<const uint32_t*>(serialized + stream.offset()));
   }
 }
 
-void SparseHll::mergeWith(size_t otherSize, const uint32_t* otherEntries) {
+template <typename TAllocator>
+void SparseHll<TAllocator>::mergeWith(
+    size_t otherSize,
+    const uint32_t* otherEntries) {
   VELOX_CHECK_GT(otherSize, 0);
 
   auto size = entries_.size();
-  std::vector<uint32_t> merged(size + otherSize);
+
+  auto merged = std::vector<uint32_t, TStlAllocator<uint32_t>>(
+      size + otherSize, TStlAllocator<uint32_t>(allocator_));
 
   int pos = 0;
   int leftPos = 0;
@@ -223,7 +251,8 @@ void SparseHll::mergeWith(size_t otherSize, const uint32_t* otherEntries) {
   }
 }
 
-void SparseHll::verify() const {
+template <typename TAllocator>
+void SparseHll<TAllocator>::verify() const {
   if (entries_.size() <= 1) {
     return;
   }
@@ -236,11 +265,11 @@ void SparseHll::verify() const {
   }
 }
 
-void SparseHll::toDense(DenseHll& denseHll) const {
+template <typename TAllocator>
+void SparseHll<TAllocator>::toDense(DenseHll<TAllocator>& denseHll) const {
   auto indexBitLength = denseHll.indexBitLength();
 
-  for (auto i = 0; i < entries_.size(); i++) {
-    auto entry = entries_[i];
+  for (auto entry : entries_) {
     auto index = entry >> (32 - indexBitLength);
     auto shiftedValue = entry << indexBitLength;
     auto zeros = shiftedValue == 0 ? 32 : __builtin_clz(shiftedValue);
@@ -257,4 +286,9 @@ void SparseHll::toDense(DenseHll& denseHll) const {
   }
 }
 
+// Explicit template instantiation for HashStringAllocator (default)
+template class SparseHll<HashStringAllocator>;
+// Explicit template instantiation for memory::MemoryPool
+template class SparseHll<memory::MemoryPool>;
+
 } // namespace facebook::velox::common::hll
diff --git a/velox/common/hyperloglog/SparseHll.h b/velox/common/hyperloglog/SparseHll.h
index e881b5776270..61a3cb8cb29a 100644
--- a/velox/common/hyperloglog/SparseHll.h
+++ b/velox/common/hyperloglog/SparseHll.h
@@ -18,15 +18,42 @@
 #include "velox/common/memory/HashStringAllocator.h"
 
 namespace facebook::velox::common::hll {
+
+class SparseHlls {
+ public:
+  /// Returns cardinality estimate from the specified serialized digest.
+  /// @param serialized Pointer to serialized SparseHll data
+  /// @return Estimated cardinality of the HyperLogLog
+  static int64_t cardinality(const char* serialized);
+
+  /// Returns true if 'input' has Presto SparseV2 format.
+  /// @param input Pointer to serialized data to check
+  /// @return True if the data is in SparseV2 format, false otherwise
+  static bool canDeserialize(const char* input);
+
+  /// Creates an empty serialized SparseHll with the specified index bit length.
+  /// @param indexBitLength Number of bits for indexing (must be in [4,16])
+  /// @return Serialized empty SparseHll as a string
+  static std::string serializeEmpty(int8_t indexBitLength);
+
+  /// Extracts the index bit length from serialized SparseHll data.
+  /// @param input Pointer to serialized SparseHll data
+  /// @return The index bit length used in the serialized HLL
+  static int8_t deserializeIndexBitLength(const char* input);
+};
+
 /// HyperLogLog implementation using sparse storage layout.
 /// It uses 26-bit buckets and provides high accuracy for low cardinalities.
 /// Memory usage: 4 bytes for each observed bucket.
+template <typename TAllocator = HashStringAllocator>
 class SparseHll {
  public:
-  explicit SparseHll(HashStringAllocator* allocator)
-      : entries_{StlAllocator<uint32_t>(allocator)} {}
+  template <typename U>
+  using TStlAllocator = typename TAllocator::template TStlAllocator<U>;
+
+  explicit SparseHll(TAllocator* allocator);
 
-  SparseHll(const char* serialized, HashStringAllocator* allocator);
+  SparseHll(const char* serialized, TAllocator* allocator);
 
   void setSoftMemoryLimit(uint32_t softMemoryLimit) {
     softNumEntriesLimit_ = softMemoryLimit / 4;
@@ -42,17 +69,9 @@ class SparseHll {
 
   int64_t cardinality() const;
 
-  /// Returns cardinality estimate from the specified serialized digest.
-  static int64_t cardinality(const char* serialized);
-
   /// Serializes internal state using Presto SparseV2 format.
   void serialize(int8_t indexBitLength, char* output) const;
 
-  static std::string serializeEmpty(int8_t indexBitLength);
-
-  /// Returns true if 'input' has Presto SparseV2 format.
-  static bool canDeserialize(const char* input);
-
   /// Returns the size of the serialized state without serialising.
   int32_t serializedSize() const;
 
@@ -63,7 +82,7 @@ class SparseHll {
   void mergeWith(const char* serialized);
 
   /// Merges state into provided instance of DenseHll.
-  void toDense(DenseHll& denseHll) const;
+  void toDense(DenseHll<TAllocator>& denseHll) const;
 
   /// Returns current memory usage.
   int32_t inMemorySize() const;
@@ -84,8 +103,8 @@ class SparseHll {
   /// A list of observed buckets. Each entry is a 32 bit integer encoding 26-bit
   /// bucket and 6-bit value (number of zeros in the input hash after the bucket
   /// + 1).
-  std::vector<uint32_t, StlAllocator<uint32_t>> entries_;
-
+  TAllocator* allocator_;
+  std::vector<uint32_t, TStlAllocator<uint32_t>> entries_;
   /// Number of entries that can be stored before reaching soft memory limit.
   uint32_t softNumEntriesLimit_{0};
 };
diff --git a/velox/common/hyperloglog/benchmarks/CMakeLists.txt b/velox/common/hyperloglog/benchmarks/CMakeLists.txt
index f18f8a0a2b7b..c0b49671fd66 100644
--- a/velox/common/hyperloglog/benchmarks/CMakeLists.txt
+++ b/velox/common/hyperloglog/benchmarks/CMakeLists.txt
@@ -15,5 +15,7 @@
 add_executable(velox_common_hyperloglog_dense_hll_bm DenseHll.cpp)
 
 target_link_libraries(
-  velox_common_hyperloglog_dense_hll_bm velox_common_hyperloglog
-  Folly::follybenchmark)
+  velox_common_hyperloglog_dense_hll_bm
+  velox_common_hyperloglog
+  Folly::follybenchmark
+)
diff --git a/velox/common/hyperloglog/benchmarks/DenseHll.cpp b/velox/common/hyperloglog/benchmarks/DenseHll.cpp
index 7233280f1d66..0bd112e0a720 100644
--- a/velox/common/hyperloglog/benchmarks/DenseHll.cpp
+++ b/velox/common/hyperloglog/benchmarks/DenseHll.cpp
@@ -49,7 +49,7 @@ class DenseHllBenchmark {
     folly::BenchmarkSuspender suspender;
 
     HashStringAllocator allocator(pool_);
-    common::hll::DenseHll hll(hashBits, &allocator);
+    common::hll::DenseHll<> hll(hashBits, &allocator);
 
     suspender.dismiss();
 
@@ -61,7 +61,7 @@ class DenseHllBenchmark {
  private:
   std::string makeSerializedHll(int hashBits, int32_t step) {
     HashStringAllocator allocator(pool_);
-    common::hll::DenseHll hll(hashBits, &allocator);
+    common::hll::DenseHll<> hll(hashBits, &allocator);
     for (int32_t i = 0; i < 1'000'000; ++i) {
       auto hash = hashOne(i * step);
       hll.insertHash(hash);
@@ -69,7 +69,7 @@ class DenseHllBenchmark {
     return serialize(hll);
   }
 
-  static std::string serialize(common::hll::DenseHll& denseHll) {
+  static std::string serialize(common::hll::DenseHll<>& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
diff --git a/velox/common/hyperloglog/tests/CMakeLists.txt b/velox/common/hyperloglog/tests/CMakeLists.txt
index c05a810796fe..cfa5230b68ef 100644
--- a/velox/common/hyperloglog/tests/CMakeLists.txt
+++ b/velox/common/hyperloglog/tests/CMakeLists.txt
@@ -12,11 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_common_hyperloglog_test DenseHllTest.cpp SparseHllTest.cpp)
+add_executable(
+  velox_common_hyperloglog_test
+  DenseHllTest.cpp
+  SparseHllTest.cpp
+  HllAccumulatorTest.cpp
+)
 
-add_test(NAME velox_common_hyperloglog_test
-         COMMAND velox_common_hyperloglog_test)
+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 GTest::gtest_main)
+  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 c688a6918c47..99eb261dbfb2 100644
--- a/velox/common/hyperloglog/tests/DenseHllTest.cpp
+++ b/velox/common/hyperloglog/tests/DenseHllTest.cpp
@@ -15,9 +15,8 @@
  */
 #include "velox/common/hyperloglog/DenseHll.h"
 
+#include <gtest/gtest-typed-test.h>
 #include <gtest/gtest.h>
-#include <algorithm>
-#include <map>
 #include <vector>
 
 #define XXH_INLINE_ALL
@@ -34,22 +33,27 @@ uint64_t hashOne(T value) {
   return XXH64(&value, sizeof(value), 0);
 }
 
-class DenseHllTest : public ::testing::TestWithParam<int8_t> {
+template <typename TAllocator>
+class DenseHllTest : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
-  DenseHll roundTrip(DenseHll& hll) {
-    auto size = hll.serializedSize();
-    std::string serialized;
-    serialized.resize(size);
-    hll.serialize(serialized.data());
+  void SetUp() override {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
 
-    return DenseHll(serialized.data(), &allocator_);
+  DenseHll<TAllocator> roundTrip(DenseHll<TAllocator>& hll) {
+    auto serialized = this->serialize(hll);
+    return DenseHll(serialized.data(), allocator_);
   }
 
-  std::string serialize(DenseHll& denseHll) {
+  std::string serialize(DenseHll<TAllocator>& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
@@ -58,23 +62,19 @@ class DenseHllTest : public ::testing::TestWithParam<int8_t> {
   }
 
   template <typename T>
-  void testMergeWith(
-      int8_t indexBitLength,
-      const std::vector<T>& left,
-      const std::vector<T>& right) {
-    testMergeWith(indexBitLength, left, right, false);
-    testMergeWith(indexBitLength, left, right, true);
+  void testMergeWith(const std::vector<T>& left, const std::vector<T>& right) {
+    testMergeWith(left, right, false);
+    testMergeWith(left, right, true);
   }
 
   template <typename T>
   void testMergeWith(
-      int8_t indexBitLength,
       const std::vector<T>& left,
       const std::vector<T>& right,
       bool serialized) {
-    DenseHll hllLeft{indexBitLength, &allocator_};
-    DenseHll hllRight{indexBitLength, &allocator_};
-    DenseHll expected{indexBitLength, &allocator_};
+    DenseHll hllLeft{11, allocator_};
+    DenseHll hllRight{11, allocator_};
+    DenseHll expected{11, allocator_};
 
     for (auto value : left) {
       auto hash = hashOne(value);
@@ -89,30 +89,51 @@ class DenseHllTest : public ::testing::TestWithParam<int8_t> {
     }
 
     if (serialized) {
-      auto serializedRight = serialize(hllRight);
+      auto serializedRight = this->serialize(hllRight);
       hllLeft.mergeWith(serializedRight.data());
     } else {
       hllLeft.mergeWith(hllRight);
     }
 
     ASSERT_EQ(hllLeft.cardinality(), expected.cardinality());
-    ASSERT_EQ(serialize(hllLeft), serialize(expected));
+    ASSERT_EQ(this->serialize(hllLeft), this->serialize(expected));
 
-    auto hllLeftSerialized = serialize(hllLeft);
+    auto hllLeftSerialized = this->serialize(hllLeft);
     ASSERT_EQ(
-        DenseHll::cardinality(hllLeftSerialized.data()),
+        DenseHlls::cardinality(hllLeftSerialized.data()),
         expected.cardinality());
   }
 
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
-  HashStringAllocator allocator_{pool_.get()};
+  HashStringAllocator hsa_{pool_.get()};
+  TAllocator* allocator_;
 };
 
-TEST_P(DenseHllTest, basic) {
-  int8_t indexBitLength = GetParam();
+using AllocatorTypes =
+    ::testing::Types<HashStringAllocator, memory::MemoryPool>;
+
+class NameGenerator {
+ public:
+  template <typename TAllocator>
+  static std::string GetName(int) {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      return "hsa";
+    } else if constexpr (std::is_same_v<TAllocator, memory::MemoryPool>) {
+      return "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+  }
+};
+
+TYPED_TEST_SUITE(DenseHllTest, AllocatorTypes, NameGenerator);
+
+TYPED_TEST(DenseHllTest, basic) {
+  int8_t indexBitLength = 11;
+  DenseHll denseHll{indexBitLength, this->allocator_};
 
-  DenseHll denseHll{indexBitLength, &allocator_};
   for (int i = 0; i < 1'000; i++) {
     auto value = i % 17;
     auto hash = hashOne(value);
@@ -131,31 +152,29 @@ TEST_P(DenseHllTest, basic) {
 
   ASSERT_EQ(expectedCardinality, denseHll.cardinality());
 
-  DenseHll deserialized = roundTrip(denseHll);
+  DenseHll deserialized = this->roundTrip(denseHll);
   ASSERT_EQ(expectedCardinality, deserialized.cardinality());
 
-  auto serialized = serialize(denseHll);
-  ASSERT_EQ(expectedCardinality, DenseHll::cardinality(serialized.data()));
+  auto serialized = this->serialize(denseHll);
+  ASSERT_EQ(expectedCardinality, DenseHlls::cardinality(serialized.data()));
 }
 
-TEST_P(DenseHllTest, highCardinality) {
-  int8_t indexBitLength = GetParam();
+TYPED_TEST(DenseHllTest, highCardinality) {
+  int8_t indexBitLength = 11;
+  DenseHll denseHll{indexBitLength, this->allocator_};
 
-  DenseHll denseHll{indexBitLength, &allocator_};
   for (int i = 0; i < 10'000'000; i++) {
     auto hash = hashOne(i);
     denseHll.insertHash(hash);
   }
 
-  if (indexBitLength >= 11) {
-    ASSERT_NEAR(10'000'000, denseHll.cardinality(), 150'000);
-  }
+  ASSERT_NEAR(10'000'000, denseHll.cardinality(), 150'000);
 
-  DenseHll deserialized = roundTrip(denseHll);
+  auto deserialized = this->roundTrip(denseHll);
   ASSERT_EQ(denseHll.cardinality(), deserialized.cardinality());
 
-  auto serialized = serialize(denseHll);
-  ASSERT_EQ(denseHll.cardinality(), DenseHll::cardinality(serialized.data()));
+  auto serialized = this->serialize(denseHll);
+  ASSERT_EQ(denseHll.cardinality(), DenseHlls::cardinality(serialized.data()));
 }
 
 namespace {
@@ -170,62 +189,234 @@ std::vector<T> sequence(T start, T end) {
 }
 } // namespace
 
-TEST_P(DenseHllTest, canDeserialize) {
+TYPED_TEST(DenseHllTest, mergeWith) {
+  // small, non-overlapping
+  this->testMergeWith(sequence(0, 100), sequence(100, 200));
+  this->testMergeWith(sequence(100, 200), sequence(0, 100));
+
+  // small, overlapping
+  this->testMergeWith(sequence(0, 100), sequence(50, 150));
+  this->testMergeWith(sequence(50, 150), sequence(0, 100));
+
+  // small, same
+  this->testMergeWith(sequence(0, 100), sequence(0, 100));
+
+  // large, non-overlapping
+  this->testMergeWith(sequence(0, 20'000), sequence(20'000, 40'000));
+  this->testMergeWith(sequence(20'000, 40'000), sequence(0, 20'000));
+
+  // large, overlapping
+  this->testMergeWith(sequence(0, 2'000'000), sequence(1'000'000, 3'000'000));
+  this->testMergeWith(sequence(1'000'000, 3'000'000), sequence(0, 2'000'000));
+
+  // large, same
+  this->testMergeWith(sequence(0, 2'000'000), sequence(0, 2'000'000));
+}
+
+// Separate test class for testing various index bit lengths
+template <typename TAllocator, int8_t IndexBitLength>
+struct AllocatorWithIndexBits {
+  using AllocatorType = TAllocator;
+  static constexpr int8_t indexBitLength() {
+    return IndexBitLength;
+  }
+};
+
+template <typename TParam>
+class DenseHllMergeTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    if constexpr (std::is_same_v<
+                      typename TParam::AllocatorType,
+                      HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
+
+  std::string serialize(DenseHll<typename TParam::AllocatorType>& denseHll) {
+    auto size = denseHll.serializedSize();
+    std::string serialized;
+    serialized.resize(size);
+    denseHll.serialize(serialized.data());
+    return serialized;
+  }
+
+  template <typename T>
+  void testMergeWith(
+      int8_t indexBitLength,
+      const std::vector<T>& left,
+      const std::vector<T>& right) {
+    testMergeWith(indexBitLength, left, right, false);
+    testMergeWith(indexBitLength, left, right, true);
+  }
+
+  template <typename T>
+  void testMergeWith(
+      int8_t indexBitLength,
+      const std::vector<T>& left,
+      const std::vector<T>& right,
+      bool serialized) {
+    DenseHll hllLeft{indexBitLength, allocator_};
+    DenseHll hllRight{indexBitLength, allocator_};
+    DenseHll expected{indexBitLength, allocator_};
+
+    for (auto value : left) {
+      auto hash = hashOne(value);
+      hllLeft.insertHash(hash);
+      expected.insertHash(hash);
+    }
+
+    for (auto value : right) {
+      auto hash = hashOne(value);
+      hllRight.insertHash(hash);
+      expected.insertHash(hash);
+    }
+
+    if (serialized) {
+      auto serializedRight = this->serialize(hllRight);
+      hllLeft.mergeWith(serializedRight.data());
+    } else {
+      hllLeft.mergeWith(hllRight);
+    }
+
+    ASSERT_EQ(hllLeft.cardinality(), expected.cardinality());
+    ASSERT_EQ(this->serialize(hllLeft), this->serialize(expected));
+
+    auto hllLeftSerialized = this->serialize(hllLeft);
+    ASSERT_EQ(
+        DenseHlls::cardinality(hllLeftSerialized.data()),
+        expected.cardinality());
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  HashStringAllocator hsa_{pool_.get()};
+  typename TParam::AllocatorType* allocator_;
+};
+
+using DenseHllMergeTestParams = ::testing::Types<
+    // HashStringAllocator with all index bit lengths
+    AllocatorWithIndexBits<HashStringAllocator, 4>,
+    AllocatorWithIndexBits<HashStringAllocator, 5>,
+    AllocatorWithIndexBits<HashStringAllocator, 6>,
+    AllocatorWithIndexBits<HashStringAllocator, 7>,
+    AllocatorWithIndexBits<HashStringAllocator, 8>,
+    AllocatorWithIndexBits<HashStringAllocator, 9>,
+    AllocatorWithIndexBits<HashStringAllocator, 10>,
+    AllocatorWithIndexBits<HashStringAllocator, 11>,
+    AllocatorWithIndexBits<HashStringAllocator, 12>,
+    AllocatorWithIndexBits<HashStringAllocator, 13>,
+    AllocatorWithIndexBits<HashStringAllocator, 14>,
+    AllocatorWithIndexBits<HashStringAllocator, 15>,
+    AllocatorWithIndexBits<HashStringAllocator, 16>,
+    // MemoryPool with all index bit lengths
+    AllocatorWithIndexBits<memory::MemoryPool, 4>,
+    AllocatorWithIndexBits<memory::MemoryPool, 5>,
+    AllocatorWithIndexBits<memory::MemoryPool, 6>,
+    AllocatorWithIndexBits<memory::MemoryPool, 7>,
+    AllocatorWithIndexBits<memory::MemoryPool, 8>,
+    AllocatorWithIndexBits<memory::MemoryPool, 9>,
+    AllocatorWithIndexBits<memory::MemoryPool, 10>,
+    AllocatorWithIndexBits<memory::MemoryPool, 11>,
+    AllocatorWithIndexBits<memory::MemoryPool, 12>,
+    AllocatorWithIndexBits<memory::MemoryPool, 13>,
+    AllocatorWithIndexBits<memory::MemoryPool, 14>,
+    AllocatorWithIndexBits<memory::MemoryPool, 15>,
+    AllocatorWithIndexBits<memory::MemoryPool, 16>>;
+
+class ComprehensiveNameGenerator {
+ public:
+  template <typename TParam>
+  static std::string GetName(int) {
+    std::string allocatorName;
+    if constexpr (std::is_same_v<
+                      typename TParam::AllocatorType,
+                      HashStringAllocator>) {
+      allocatorName = "hsa";
+    } else if constexpr (std::is_same_v<
+                             typename TParam::AllocatorType,
+                             memory::MemoryPool>) {
+      allocatorName = "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+    return fmt::format("{}_{}", allocatorName, TParam::indexBitLength());
+  }
+};
+
+TYPED_TEST_SUITE(
+    DenseHllMergeTest,
+    DenseHllMergeTestParams,
+    ComprehensiveNameGenerator);
+
+class DenseHllCanDeserializeTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+};
+
+TEST_F(DenseHllCanDeserializeTest, canDeserialize) {
   // These are not valid HLL but all pass canDeserialize version only check.
-  std::vector<folly::StringPiece> invalidStrings{
+  std::vector<std::string_view> invalidStrings{
       "AxIRESUhEzNBFCQWYxEjIzI1ISURNidCMlViIjOSNyATBhYSIiJDUyMBIlcSMDUiEUEiESM1ITckQkQTMSMhMyQx",
       "Aw==",
       "AyAAABEQAgAlAgAQAQAlMgAhQQABAwAAERAAAAEQACA=",
       "AwDuUjGFaQ==",
       "AwkLD8BYTA9BXyg="};
 
-  for (folly::StringPiece& invalidString : invalidStrings) {
+  for (const auto invalidString : invalidStrings) {
     auto invalidHll = Base64::decode(invalidString);
-    EXPECT_TRUE(DenseHll::canDeserialize(invalidHll.c_str()));
+    EXPECT_TRUE(DenseHlls::canDeserialize(invalidHll.c_str()));
     EXPECT_FALSE(
-        DenseHll::canDeserialize(invalidHll.c_str(), invalidHll.length()));
+        DenseHlls::canDeserialize(invalidHll.c_str(), invalidHll.length()));
   }
 
-  std::vector<folly::StringPiece> validStrings{
+  std::vector<std::string_view> validStrings{
       "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",
   };
 
-  for (folly::StringPiece& validString : validStrings) {
+  for (const auto validString : validStrings) {
     auto validHll = Base64::decode(validString);
-    EXPECT_TRUE(DenseHll::canDeserialize(validHll.c_str()));
-    EXPECT_TRUE(DenseHll::canDeserialize(validHll.c_str(), validHll.length()));
+    EXPECT_TRUE(DenseHlls::canDeserialize(validHll.c_str()));
+    EXPECT_TRUE(DenseHlls::canDeserialize(validHll.c_str(), validHll.length()));
   }
 }
 
-TEST_P(DenseHllTest, mergeWith) {
-  int8_t indexBitLength = GetParam();
+TYPED_TEST(DenseHllMergeTest, mergeWith) {
+  int8_t indexBitLength = TypeParam::indexBitLength();
 
   // small, non-overlapping
-  testMergeWith(indexBitLength, sequence(0, 100), sequence(100, 200));
-  testMergeWith(indexBitLength, sequence(100, 200), sequence(0, 100));
+  this->testMergeWith(indexBitLength, sequence(0, 100), sequence(100, 200));
+  this->testMergeWith(indexBitLength, sequence(100, 200), sequence(0, 100));
 
   // small, overlapping
-  testMergeWith(indexBitLength, sequence(0, 100), sequence(50, 150));
-  testMergeWith(indexBitLength, sequence(50, 150), sequence(0, 100));
+  this->testMergeWith(indexBitLength, sequence(0, 100), sequence(50, 150));
+  this->testMergeWith(indexBitLength, sequence(50, 150), sequence(0, 100));
 
   // small, same
-  testMergeWith(indexBitLength, sequence(0, 100), sequence(0, 100));
+  this->testMergeWith(indexBitLength, sequence(0, 100), sequence(0, 100));
 
   // large, non-overlapping
-  testMergeWith(indexBitLength, sequence(0, 20'000), sequence(20'000, 40'000));
-  testMergeWith(indexBitLength, sequence(20'000, 40'000), sequence(0, 20'000));
+  this->testMergeWith(
+      indexBitLength, sequence(0, 20'000), sequence(20'000, 40'000));
+  this->testMergeWith(
+      indexBitLength, sequence(20'000, 40'000), sequence(0, 20'000));
 
   // large, overlapping
-  testMergeWith(
+  this->testMergeWith(
       indexBitLength, sequence(0, 2'000'000), sequence(1'000'000, 3'000'000));
-  testMergeWith(
+  this->testMergeWith(
       indexBitLength, sequence(1'000'000, 3'000'000), sequence(0, 2'000'000));
 
   // large, same
-  testMergeWith(indexBitLength, sequence(0, 2'000'000), sequence(0, 2'000'000));
+  this->testMergeWith(
+      indexBitLength, sequence(0, 2'000'000), sequence(0, 2'000'000));
 }
-
-INSTANTIATE_TEST_SUITE_P(
-    DenseHllTest,
-    DenseHllTest,
-    ::testing::Values(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16));
diff --git a/velox/common/hyperloglog/tests/HllAccumulatorTest.cpp b/velox/common/hyperloglog/tests/HllAccumulatorTest.cpp
new file mode 100644
index 000000000000..02136168ebaf
--- /dev/null
+++ b/velox/common/hyperloglog/tests/HllAccumulatorTest.cpp
@@ -0,0 +1,332 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/HllAccumulator.h"
+
+#define XXH_INLINE_ALL
+#include <xxhash.h>
+
+#include <gtest/gtest-typed-test.h>
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::common::hll;
+
+namespace {
+const int8_t kDefaultIndexBitLength = 11;
+const double kDefaultStandardError =
+    1.04 / std::sqrt(1 << kDefaultIndexBitLength);
+} // namespace
+
+template <typename TAllocator>
+class HllAccumulatorTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  HashStringAllocator hsa_{pool_.get()};
+  TAllocator* allocator_{};
+};
+
+using AllocatorTypes =
+    ::testing::Types<HashStringAllocator, memory::MemoryPool>;
+
+class NameGenerator {
+ public:
+  template <typename TAllocator>
+  static std::string GetName(int) {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      return "hsa";
+    } else if constexpr (std::is_same_v<TAllocator, memory::MemoryPool>) {
+      return "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+  }
+};
+
+TYPED_TEST_SUITE(HllAccumulatorTest, AllocatorTypes, NameGenerator);
+
+TYPED_TEST(HllAccumulatorTest, basicInt64) {
+  // Test SparseHLL.
+  HllAccumulator<int64_t, false, TypeParam> accumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int64_t numValues = 100;
+  for (int64_t i = 0; i < numValues; i++) {
+    accumulator.append(i);
+  }
+
+  // Sparse HLL should be exact.
+  EXPECT_EQ(accumulator.cardinality(), numValues);
+
+  // Test DenseHLL.
+  constexpr int64_t numValuesDense = 10000;
+  for (int64_t i = 0; i < numValuesDense; i++) {
+    accumulator.append(i);
+  }
+  EXPECT_NEAR(
+      accumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, basicDouble) {
+  // Test SparseHLL.
+  HllAccumulator<double, true, TypeParam> accumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int numValues = 150;
+  for (int i = 0; i < numValues; i++) {
+    accumulator.append(static_cast<double>(i) * 1.5);
+  }
+  EXPECT_EQ(accumulator.cardinality(), numValues);
+
+  // Test DenseHLL.
+  constexpr int numValuesDense = 15000;
+  for (int i = numValues; i < numValuesDense; i++) {
+    accumulator.append(static_cast<double>(i) * 1.5);
+  }
+  EXPECT_NEAR(
+      accumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, basicStringView) {
+  // Test SparseHLL.
+  HllAccumulator<StringView, true, TypeParam> accumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int numValues = 100;
+  std::vector<std::string> strings;
+  strings.reserve(numValues);
+  for (int i = 0; i < numValues; i++) {
+    strings.push_back("value_" + std::to_string(i));
+  }
+  for (const auto& str : strings) {
+    accumulator.append(StringView(str));
+  }
+  EXPECT_EQ(accumulator.cardinality(), numValues);
+
+  // Test DenseHLL.
+  constexpr int numValuesDense = 10000;
+  for (int i = numValues; i < numValuesDense; i++) {
+    strings.push_back("value_" + std::to_string(i));
+  }
+  for (int i = numValues; i < numValuesDense; i++) {
+    accumulator.append(StringView(strings[i]));
+  }
+  EXPECT_NEAR(
+      accumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, serde) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int64_t numValues = 200;
+  for (int64_t i = 0; i < numValues; i++) {
+    accumulator.append(i);
+  }
+
+  auto size = accumulator.serializedSize();
+  std::string serialized(size, '\0');
+  accumulator.serialize(serialized.data());
+
+  auto deserialized = HllAccumulator<int64_t, false, TypeParam>::deserialize(
+      serialized.data(), this->allocator_);
+
+  EXPECT_EQ(deserialized->cardinality(), numValues);
+
+  // Test round trip
+  std::string reserialized(deserialized->serializedSize(), '\0');
+  deserialized->serialize(reserialized.data());
+  EXPECT_EQ(reserialized, serialized);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeWithBothSparse) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator1(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> accumulator2(
+      kDefaultIndexBitLength, this->allocator_);
+
+  // Add non-overlapping values that keep both sparse.
+  for (int64_t i = 0; i < 100; i++) {
+    accumulator1.append(i);
+  }
+  for (int64_t i = 100; i < 200; i++) {
+    accumulator2.append(i);
+  }
+
+  accumulator1.mergeWith(accumulator2);
+
+  // Resulting accumulator should be sparse and exact.
+  EXPECT_TRUE(accumulator1.isSparse());
+  EXPECT_EQ(accumulator1.cardinality(), 200);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeWithBothDense) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator1(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> accumulator2(
+      kDefaultIndexBitLength, this->allocator_);
+
+  // Add non-overlapping values that trigger dense mode.
+  constexpr int64_t numValues = 10000;
+  for (int64_t i = 0; i < 5000; i++) {
+    accumulator1.append(i);
+  }
+  for (int64_t i = 5000; i < numValues; i++) {
+    accumulator2.append(i);
+  }
+
+  accumulator1.mergeWith(accumulator2);
+  EXPECT_FALSE(accumulator1.isSparse());
+
+  EXPECT_NEAR(
+      accumulator1.cardinality(), numValues, numValues * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeSparseWithDense) {
+  HllAccumulator<int64_t, false, TypeParam> sparseAccumulator(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> denseAccumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  for (int64_t i = 0; i < 100; i++) {
+    sparseAccumulator.append(i);
+  }
+
+  constexpr int64_t numValuesDense = 5000;
+  for (int64_t i = 100; i < numValuesDense; i++) {
+    denseAccumulator.append(i);
+  }
+
+  sparseAccumulator.mergeWith(denseAccumulator);
+
+  // mergeWith should convert any sparse accumulator to dense if either is
+  // dense. Result should be dense and approximate.
+
+  EXPECT_FALSE(sparseAccumulator.isSparse());
+  EXPECT_NEAR(
+      sparseAccumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeDenseWithSparse) {
+  HllAccumulator<int64_t, false, TypeParam> sparseAccumulator(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> denseAccumulator(
+      kDefaultIndexBitLength, this->allocator_);
+
+  for (int64_t i = 0; i < 100; i++) {
+    sparseAccumulator.append(i);
+  }
+
+  constexpr int64_t numValuesDense = 5000;
+  for (int64_t i = 100; i < numValuesDense; i++) {
+    denseAccumulator.append(i);
+  }
+
+  denseAccumulator.mergeWith(sparseAccumulator);
+
+  // Result should be dense and approximate.
+  EXPECT_FALSE(denseAccumulator.isSparse());
+  EXPECT_NEAR(
+      denseAccumulator.cardinality(),
+      numValuesDense,
+      numValuesDense * kDefaultStandardError);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeWithSerializedDataSparse) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator1(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> accumulator2(
+      kDefaultIndexBitLength, this->allocator_);
+
+  for (int64_t i = 0; i < 100; i++) {
+    accumulator1.append(i);
+  }
+  for (int64_t i = 100; i < 200; i++) {
+    accumulator2.append(i);
+  }
+
+  auto size = accumulator2.serializedSize();
+  std::string buffer(size, '\0');
+  accumulator2.serialize(buffer.data());
+
+  // Merge with serialized data (should remain sparse).
+  accumulator1.mergeWith(StringView(buffer), this->allocator_);
+
+  // Should be sparse and exact.
+  EXPECT_TRUE(accumulator1.isSparse());
+  EXPECT_EQ(accumulator1.cardinality(), 200);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeWithOverlappingDataSparse) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator1(
+      kDefaultIndexBitLength, this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> accumulator2(
+      kDefaultIndexBitLength, this->allocator_);
+
+  for (int64_t i = 0; i < 100; i++) {
+    accumulator1.append(i);
+  }
+  for (int64_t i = 50; i < 150; i++) {
+    accumulator2.append(i);
+  }
+
+  accumulator1.mergeWith(accumulator2);
+
+  // Sparse HLL should be sparse and exact: union of [0, 100) and [50, 150) =
+  // [0, 150)
+  EXPECT_TRUE(accumulator1.isSparse());
+  EXPECT_EQ(accumulator1.cardinality(), 150);
+}
+
+TYPED_TEST(HllAccumulatorTest, mergeUninitializedAccumulator) {
+  HllAccumulator<int64_t, false, TypeParam> accumulator(this->allocator_);
+  HllAccumulator<int64_t, false, TypeParam> initialized(
+      kDefaultIndexBitLength, this->allocator_);
+
+  constexpr int64_t numValues = 100;
+  for (int64_t i = 0; i < numValues; i++) {
+    initialized.append(i);
+  }
+
+  auto size = initialized.serializedSize();
+  std::string buffer(size, '\0');
+  initialized.serialize(buffer.data());
+
+  accumulator.mergeWith(StringView(buffer), this->allocator_);
+
+  EXPECT_EQ(accumulator.cardinality(), numValues);
+}
diff --git a/velox/common/hyperloglog/tests/KHyperLogLogTest.cpp b/velox/common/hyperloglog/tests/KHyperLogLogTest.cpp
new file mode 100644
index 000000000000..0303cf1c25fd
--- /dev/null
+++ b/velox/common/hyperloglog/tests/KHyperLogLogTest.cpp
@@ -0,0 +1,705 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/KHyperLogLog.h"
+#include "velox/common/memory/Memory.h"
+
+#include <folly/Random.h>
+#include <gtest/gtest.h>
+#include <set>
+#include <unordered_set>
+#include "velox/type/Timestamp.h"
+
+using namespace facebook::velox::common::hll;
+using namespace facebook::velox::memory;
+using namespace facebook::velox;
+
+namespace {
+const int32_t kDefaultNumBuckets = 256;
+// Theoretical relative standard error formula from the HyperLogLog paper
+// (Flajolet et al.): 1.04 / sqrt(num buckets)
+const double kDefaultStandardError = 1.04 / std::sqrt(kDefaultNumBuckets);
+} // namespace
+
+class KHyperLogLogTest : public ::testing::Test {
+ public:
+  void SetUp() override {
+    facebook::velox::memory::MemoryManager::initialize({});
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool();
+    hsa_ = std::make_unique<HashStringAllocator>(pool_.get());
+    allocator_ = hsa_.get();
+  }
+
+  void TearDown() override {
+    // Clean up allocator before pool.
+    hsa_.reset();
+    pool_.reset();
+  }
+
+ protected:
+  std::shared_ptr<MemoryPool> pool_;
+  std::unique_ptr<HashStringAllocator> hsa_;
+  HashStringAllocator* allocator_{};
+
+  // Helper function to generate random values with quadratic distribution.
+  // Squaring a uniform random [0.0, 1.0] heavily skews results toward zero
+  // (e.g., ~70% of values fall in the lower half). This simulates realistic
+  // data where most values have low cardinality and few have high cardinality,
+  // which is critical for testing KHLL's privacy features under conditions
+  // where re-identification risk is highest.
+  int64_t randomLong(int64_t range) {
+    double random = folly::Random::randDouble01();
+    return static_cast<int64_t>(std::pow(random, 2.0) * range);
+  }
+
+  // Creates a KHyperLogLog with specific values for testing.
+  std::unique_ptr<KHyperLogLog<int64_t, HashStringAllocator>> createKHLL(
+      const std::vector<int64_t>& values,
+      const std::vector<int64_t>& uiis) {
+    EXPECT_EQ(values.size(), uiis.size());
+    auto khll = std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_);
+
+    for (size_t i = 0; i < values.size(); ++i) {
+      khll->add(values[i], uiis[i]);
+    }
+
+    return khll;
+  }
+};
+
+TEST_F(KHyperLogLogTest, basicCardinality) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  // Empty KHLL should have cardinality 0.
+  EXPECT_EQ(0, khll->cardinality());
+  EXPECT_TRUE(khll->isExact());
+
+  // Add some values.
+  for (int64_t i = 0; i < 100; ++i) {
+    khll->add(i, randomLong(100));
+  }
+
+  // Should be exact since it is under the default max size.
+  EXPECT_TRUE(khll->isExact());
+  EXPECT_EQ(100, khll->cardinality());
+}
+
+TEST_F(KHyperLogLogTest, cardinalityAccuracy) {
+  // Test representative precision levels (low and high) to ensure
+  // accuracy across different bucket configurations: 4 (16 buckets) and
+  // 12 (4096 buckets).
+  const int trials = 30;
+
+  for (int indexBits : {4, 12}) {
+    const int numberOfBuckets = 1 << indexBits;
+    const int maxCardinality = numberOfBuckets * 2;
+
+    std::vector<double> errors;
+
+    for (int trial = 0; trial < trials; ++trial) {
+      auto khll = std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(
+          KHyperLogLog<int64_t, HashStringAllocator>::kDefaultMaxSize,
+          numberOfBuckets,
+          allocator_);
+
+      for (int cardinality = 1; cardinality <= maxCardinality; cardinality++) {
+        khll->add(folly::Random::rand64(), 0L);
+
+        // Sample every 20% of bucket count (vs Java's 10%) to reduce test
+        // time
+        if (cardinality % (numberOfBuckets / 5) == 0) {
+          double error =
+              (static_cast<double>(khll->cardinality()) - cardinality) /
+              cardinality;
+          errors.push_back(std::abs(error));
+        }
+      }
+    }
+
+    // Calculate standard deviation
+    double mean = 0.0;
+    for (double error : errors) {
+      mean += error;
+    }
+    mean /= errors.size();
+
+    double variance = 0.0;
+    for (double error : errors) {
+      variance += (error - mean) * (error - mean);
+    }
+    variance /= errors.size();
+    double stdDev = std::sqrt(variance);
+
+    EXPECT_LE(stdDev, kDefaultStandardError)
+        << "Cardinality mismatch at indexBits " << indexBits << ", bucket "
+        << numberOfBuckets;
+  }
+}
+
+TEST_F(KHyperLogLogTest, mergeWith) {
+  auto khll1 = createKHLL(
+      std::vector<int64_t>{0, 1, 2, 3, 4, 5},
+      std::vector<int64_t>{10, 11, 12, 13, 14, 15});
+
+  auto khll2 = createKHLL(
+      std::vector<int64_t>{3, 4, 5, 6, 7, 8},
+      std::vector<int64_t>{13, 14, 15, 16, 17, 18});
+
+  auto expected = createKHLL(
+      std::vector<int64_t>{0, 1, 2, 3, 4, 5, 6, 7, 8},
+      std::vector<int64_t>{10, 11, 12, 13, 14, 15, 16, 17, 18});
+
+  khll1->mergeWith(*khll2);
+
+  EXPECT_EQ(expected->cardinality(), khll1->cardinality());
+  EXPECT_EQ(
+      expected->reidentificationPotential(10),
+      khll1->reidentificationPotential(10));
+}
+
+TEST_F(KHyperLogLogTest, merge) {
+  // Helpers to create a KHLL with given maxSize and data
+  auto createSmaller = [&]() {
+    const auto smallerSize = 5;
+    auto khll = std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(
+        smallerSize, kDefaultNumBuckets, allocator_);
+    for (size_t i = 0; i < smallerSize; ++i) {
+      khll->add(i, i);
+    }
+    return khll;
+  };
+
+  auto createLarger = [&]() {
+    const auto largerSize = 10;
+    auto khll = std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(
+        largerSize, kDefaultNumBuckets, allocator_);
+    for (size_t i = 0; i < largerSize; ++i) {
+      khll->add(i, i);
+    }
+    return khll;
+  };
+
+  // Test merge(left, right)
+  auto smallerFirst = KHyperLogLog<int64_t, HashStringAllocator>::merge(
+      createSmaller(), createLarger());
+
+  // Test merge(right, left) - should produce same result
+  auto largerFist = KHyperLogLog<int64_t, HashStringAllocator>::merge(
+      createLarger(), createSmaller());
+
+  EXPECT_EQ(smallerFirst->cardinality(), largerFist->cardinality());
+
+  // Explicitly merging smaller into larger should produce different results.
+  auto larger = createLarger();
+  larger->mergeWith(*createSmaller());
+  EXPECT_NE(larger->cardinality(), largerFist->cardinality());
+}
+
+TEST_F(KHyperLogLogTest, serde) {
+  // Test small serialization
+  std::vector<int64_t> values;
+  std::vector<int64_t> uiis;
+
+  for (int64_t i = 0; i < 1000; ++i) {
+    values.push_back(i);
+    uiis.push_back(randomLong(100));
+  }
+
+  auto khll = createKHLL(values, uiis);
+
+  size_t totalSize = khll->estimatedSerializedSize();
+  std::string outputBuffer(totalSize, '\0');
+  khll->serialize(outputBuffer.data());
+  auto deserializedResult =
+      KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+          outputBuffer.data(), outputBuffer.size(), allocator_);
+  ASSERT_TRUE(deserializedResult.hasValue());
+  auto& deserialized = deserializedResult.value();
+
+  EXPECT_EQ(khll->cardinality(), deserialized->cardinality());
+  EXPECT_EQ(
+      khll->reidentificationPotential(10),
+      deserialized->reidentificationPotential(10));
+
+  // Test round-trip
+  std::string reserializeBuffer(totalSize, '\0');
+  deserialized->serialize(reserializeBuffer.data());
+  EXPECT_EQ(outputBuffer, reserializeBuffer);
+
+  // Test empty KHLL round-trip
+  auto emptyKhll = createKHLL({}, {});
+  size_t emptySize = emptyKhll->estimatedSerializedSize();
+  std::string emptyOutputBuffer(emptySize, '\0');
+  emptyKhll->serialize(emptyOutputBuffer.data());
+  auto deserializedEmptyResult =
+      KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+          emptyOutputBuffer.data(), emptyOutputBuffer.size(), allocator_);
+  ASSERT_TRUE(deserializedEmptyResult.hasValue());
+  auto& deserializedEmpty = deserializedEmptyResult.value();
+  EXPECT_EQ(deserializedEmpty->cardinality(), 0);
+  std::string reserializedEmptyOutputBuffer(emptySize, '\0');
+  deserializedEmpty->serialize(reserializedEmptyOutputBuffer.data());
+  EXPECT_EQ(emptyOutputBuffer, reserializedEmptyOutputBuffer);
+}
+
+TEST_F(KHyperLogLogTest, uniquenessDistribution) {
+  const int histogramSize = 256;
+  const int count = 1000;
+
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+  std::map<int64_t, std::set<int64_t>> valueToUiis;
+
+  for (int i = 0; i < count; ++i) {
+    int64_t uii = randomLong(histogramSize);
+    int64_t value = randomLong(count);
+    khll->add(value, uii);
+    valueToUiis[value].insert(uii);
+  }
+  auto khllHistogram = khll->uniquenessDistribution(histogramSize);
+
+  // Build the actual histogram
+  std::map<int64_t, double> actualHistogram;
+  int size = valueToUiis.size();
+
+  for (const auto& [value, uiiSet] : valueToUiis) {
+    int64_t bucket = std::min(
+        static_cast<int64_t>(uiiSet.size()),
+        static_cast<int64_t>(histogramSize));
+    actualHistogram[bucket] += 1.0 / size;
+  }
+
+  // Verify histogram accuracy (with some tolerance for approximation)
+  for (int64_t i = 1; i < histogramSize; ++i) {
+    double expected = actualHistogram.count(i) ? actualHistogram[i] : 0.0;
+    double khllEstimated = khllHistogram.count(i) ? khllHistogram[i] : 0.0;
+
+    // Use 10% tolerance since the values of uniqueness distribution are a sum
+    // of 1 / size of minHash, and not the cardinality estimates.
+    EXPECT_NEAR(khllEstimated, expected, expected * 0.1)
+        << "Histogram mismatch at bucket " << i;
+  }
+}
+
+TEST_F(KHyperLogLogTest, reidentificationPotential) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+  std::map<int64_t, std::set<int64_t>> valueToUiis;
+
+  const int count = 1000;
+  for (int i = 0; i < count; ++i) {
+    int64_t uii = randomLong(100);
+    int64_t value = randomLong(count);
+    khll->add(value, uii);
+    valueToUiis[value].insert(uii);
+  }
+
+  // Test different thresholds
+  for (int threshold = 1; threshold < 10; ++threshold) {
+    double khllEstimated = khll->reidentificationPotential(threshold);
+
+    // Calculate the actual reidentification potential
+    int highlyUniqueCount = 0;
+    for (const auto& [value, uiiSet] : valueToUiis) {
+      if (static_cast<int>(uiiSet.size()) <= threshold) {
+        highlyUniqueCount++;
+      }
+    }
+
+    double expected =
+        static_cast<double>(highlyUniqueCount) / valueToUiis.size();
+
+    if (expected > 0) {
+      EXPECT_NEAR(khllEstimated, expected, expected * kDefaultStandardError)
+          << "Reidentification potential mismatch for threshold " << threshold;
+    }
+  }
+}
+
+TEST_F(KHyperLogLogTest, exactIntersectionCardinality) {
+  auto khll1 = createKHLL(
+      std::vector<int64_t>{1, 2, 3, 4, 5},
+      std::vector<int64_t>{10, 20, 30, 40, 50});
+
+  auto khll2 = createKHLL(
+      std::vector<int64_t>{3, 4, 5, 6, 7},
+      std::vector<int64_t>{30, 40, 50, 60, 70});
+
+  EXPECT_TRUE(khll1->isExact());
+  EXPECT_TRUE(khll2->isExact());
+
+  int64_t intersection =
+      KHyperLogLog<int64_t, HashStringAllocator>::exactIntersectionCardinality(
+          *khll1, *khll2);
+  // Values 3, 4, 5 are in both
+  EXPECT_EQ(3, intersection);
+}
+
+TEST_F(KHyperLogLogTest, jaccardIndex) {
+  // Test with larger datasets.
+  // Create two KHLLs where one is a subset of the other
+  const int64_t set1Size = 100000;
+  const int64_t set2Size = 150000;
+
+  auto khll1 =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+  auto khll2 =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  // Add values 0 to 99,999 to khll1
+  for (int64_t i = 0; i < set1Size; ++i) {
+    khll1->add(i, randomLong(100));
+  }
+
+  // Add values 0 to 149,999 to khll2 (includes all of khll1)
+  for (int64_t i = 0; i < set2Size; ++i) {
+    khll2->add(i, randomLong(100));
+  }
+
+  double jaccard =
+      KHyperLogLog<int64_t, HashStringAllocator>::jaccardIndex(*khll1, *khll2);
+
+  // Expected Jaccard = |intersection| / |union|
+  // Intersection: 100,000 (all of set1)
+  // Union: 150,000 (all of set2)
+  // Jaccard = 100,000 / 150,000 = 2/3 ≈ 0.6667
+  double expectedJaccard = static_cast<double>(set1Size) / set2Size;
+
+  EXPECT_NEAR(
+      jaccard, expectedJaccard, expectedJaccard * kDefaultStandardError);
+}
+
+TEST_F(KHyperLogLogTest, largeDataset) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  const int count = 200000;
+  std::unordered_set<int64_t> uniqueValues;
+
+  for (int i = 0; i < count; ++i) {
+    int64_t value = folly::Random::rand64();
+    int64_t uii = randomLong(100);
+    khll->add(value, uii);
+    uniqueValues.insert(value);
+  }
+
+  EXPECT_FALSE(khll->isExact());
+
+  int64_t expected = static_cast<int64_t>(uniqueValues.size());
+  int64_t khllEstimated = khll->cardinality();
+
+  EXPECT_NEAR(expected, khllEstimated, khllEstimated * kDefaultStandardError);
+}
+
+TEST_F(KHyperLogLogTest, minhashSize) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  EXPECT_EQ(0, khll->minhashSize());
+
+  khll->add(1, 10);
+  khll->add(2, 20);
+  khll->add(3, 30);
+
+  EXPECT_EQ(3, khll->minhashSize());
+}
+
+TEST_F(KHyperLogLogTest, estimatedSizes) {
+  auto khll =
+      std::make_unique<KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+  size_t initialEstimatedSerSize = khll->estimatedSerializedSize();
+
+  for (int64_t i = 0; i < 100; ++i) {
+    khll->add(i, randomLong(100));
+  }
+
+  size_t finalEstimatedSerSize = khll->estimatedSerializedSize();
+
+  // Sizes should increase after adding data.
+  EXPECT_GT(finalEstimatedSerSize, initialEstimatedSerSize);
+
+  // Verify the estimated size is accurate.
+  std::string serializedBuffer(finalEstimatedSerSize, '\0');
+  khll->serialize(serializedBuffer.data());
+  size_t actualSerSize = serializedBuffer.size();
+
+  EXPECT_LE(actualSerSize, finalEstimatedSerSize)
+      << "Actual serialized size exceeds estimate - potential buffer overflow";
+
+  EXPECT_NEAR(
+      actualSerSize,
+      finalEstimatedSerSize,
+      finalEstimatedSerSize * kDefaultStandardError);
+}
+
+TEST_F(KHyperLogLogTest, differentJoinKeyUIITypes) {
+  // Test different TJoinKey, TUii combinations:
+  // int32_t TJoinKey, int32_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<int32_t, HashStringAllocator>>(
+        allocator_);
+    for (int32_t i = 0; i < 100; ++i) {
+      khll->add(i, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserializedResult =
+        KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+            outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserializedResult.hasValue());
+    auto& deserialized = deserializedResult.value();
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // uint32_t TJoinKey, uint32_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<uint32_t, HashStringAllocator>>(
+        allocator_);
+    for (uint32_t i = 0; i < 100; ++i) {
+      khll->add(i % 10, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(10, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserializedResult =
+        KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+            outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserializedResult.hasValue());
+    auto& deserialized = deserializedResult.value();
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // int16_t TJoinKey, int16_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<int16_t, HashStringAllocator>>(
+        allocator_);
+    for (int16_t i = 0; i < 10000; ++i) {
+      khll->add(i % 100, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // uint16_t TJoinKey, uint16_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<uint16_t, HashStringAllocator>>(
+        allocator_);
+    for (uint16_t i = 0; i < 100; ++i) {
+      khll->add(i, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // int8_t TJoinKey, int8_t TUii
+  {
+    auto khll =
+        std::make_unique<KHyperLogLog<int8_t, HashStringAllocator>>(allocator_);
+    for (int8_t i = -100; i < 100; ++i) {
+      khll->add(i, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(200, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // uint8_t TJoinKey, uint8_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<uint8_t, HashStringAllocator>>(
+        allocator_);
+    for (uint8_t i = 0; i < 100; ++i) {
+      khll->add(i, i);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // float TJoinKey, float TUii
+  {
+    auto khll =
+        std::make_unique<KHyperLogLog<float, HashStringAllocator>>(allocator_);
+    for (int i = 0; i < 10; ++i) {
+      khll->add(static_cast<float>(i), static_cast<float>(i));
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(10, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // double TJoinKey, double TUii
+  {
+    auto khll =
+        std::make_unique<KHyperLogLog<double, HashStringAllocator>>(allocator_);
+    for (int i = 0; i < 100; ++i) {
+      khll->add(static_cast<double>(i), static_cast<double>(i));
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // StringView TJoinKey, StringView TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<StringView, HashStringAllocator>>(
+        allocator_);
+    std::vector<std::string> strings;
+    strings.reserve(100);
+    for (int i = 0; i < 100; ++i) {
+      strings.push_back("key_" + std::to_string(i));
+    }
+    for (int i = 0; i < 100; ++i) {
+      khll->add(StringView(strings[i]), StringView(strings[i]));
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // Timestamp TJoinKey, Timestamp TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<Timestamp, HashStringAllocator>>(
+        allocator_);
+    for (int i = 0; i < 100; ++i) {
+      Timestamp ts(i * 1000, 0);
+      khll->add(ts, ts);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+
+  // int128_t TJoinKey, int128_t TUii
+  {
+    auto khll = std::make_unique<KHyperLogLog<int128_t, HashStringAllocator>>(
+        allocator_);
+    for (int i = 0; i < 100; ++i) {
+      // Create 128-bit values with different upper and lower 64 bits
+      int128_t value = (static_cast<int128_t>(i) << 64) | (i + 1000);
+      khll->add(value, value);
+    }
+    EXPECT_TRUE(khll->isExact());
+    EXPECT_EQ(100, khll->cardinality());
+
+    // Test round trip
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    auto deserialized = KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+        outputBuffer.data(), outputBuffer.size(), allocator_);
+    ASSERT_TRUE(deserialized.hasValue());
+    std::string reserializeBuffer(totalSize, '\0');
+    deserialized.value()->serialize(reserializeBuffer.data());
+    EXPECT_EQ(outputBuffer, reserializeBuffer);
+  }
+}
diff --git a/velox/common/hyperloglog/tests/SparseHllTest.cpp b/velox/common/hyperloglog/tests/SparseHllTest.cpp
index 299e2c8aebd9..9d2ae9238d0d 100644
--- a/velox/common/hyperloglog/tests/SparseHllTest.cpp
+++ b/velox/common/hyperloglog/tests/SparseHllTest.cpp
@@ -18,6 +18,7 @@
 #define XXH_INLINE_ALL
 #include <xxhash.h>
 
+#include <gtest/gtest-typed-test.h>
 #include <gtest/gtest.h>
 
 using namespace facebook::velox;
@@ -28,12 +29,21 @@ uint64_t hashOne(T value) {
   return XXH64(&value, sizeof(value), 0);
 }
 
+template <typename TAllocator>
 class SparseHllTest : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
+  void SetUp() override {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
+
   template <typename T>
   void testMergeWith(const std::vector<T>& left, const std::vector<T>& right) {
     testMergeWith(left, right, false);
@@ -45,9 +55,9 @@ class SparseHllTest : public ::testing::Test {
       const std::vector<T>& left,
       const std::vector<T>& right,
       bool serialized) {
-    SparseHll hllLeft{&allocator_};
-    SparseHll hllRight{&allocator_};
-    SparseHll expected{&allocator_};
+    SparseHll hllLeft{allocator_};
+    SparseHll hllRight{allocator_};
+    SparseHll expected{allocator_};
 
     for (auto value : left) {
       auto hash = hashOne(value);
@@ -77,16 +87,20 @@ class SparseHllTest : public ::testing::Test {
 
     auto hllLeftSerialized = serialize(11, hllLeft);
     ASSERT_EQ(
-        SparseHll::cardinality(hllLeftSerialized.data()),
+        SparseHlls::cardinality(hllLeftSerialized.data()),
         expected.cardinality());
   }
 
-  SparseHll roundTrip(SparseHll& hll) {
-    auto serialized = serialize(11, hll);
-    return SparseHll(serialized.data(), &allocator_);
+  SparseHll<TAllocator> roundTrip(
+      SparseHll<TAllocator>& hll,
+      int8_t indexBitLength = 11) {
+    auto serialized = serialize(indexBitLength, hll);
+    return SparseHll(serialized.data(), allocator_);
   }
 
-  std::string serialize(int8_t indexBitLength, const SparseHll& sparseHll) {
+  std::string serialize(
+      int8_t indexBitLength,
+      const SparseHll<TAllocator>& sparseHll) {
     auto size = sparseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
@@ -94,7 +108,7 @@ class SparseHllTest : public ::testing::Test {
     return serialized;
   }
 
-  std::string serialize(DenseHll& denseHll) {
+  std::string serialize(DenseHll<TAllocator>& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
@@ -104,11 +118,32 @@ class SparseHllTest : public ::testing::Test {
 
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
-  HashStringAllocator allocator_{pool_.get()};
+  HashStringAllocator hsa_{pool_.get()};
+  TAllocator* allocator_;
+};
+
+using AllocatorTypes =
+    ::testing::Types<HashStringAllocator, memory::MemoryPool>;
+
+class NameGenerator {
+ public:
+  template <typename TAllocator>
+  static std::string GetName(int) {
+    if constexpr (std::is_same_v<TAllocator, HashStringAllocator>) {
+      return "hsa";
+    } else if constexpr (std::is_same_v<TAllocator, memory::MemoryPool>) {
+      return "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+  }
 };
 
-TEST_F(SparseHllTest, basic) {
-  SparseHll sparseHll{&allocator_};
+TYPED_TEST_SUITE(SparseHllTest, AllocatorTypes, NameGenerator);
+
+TYPED_TEST(SparseHllTest, basic) {
+  SparseHll sparseHll{this->allocator_};
   for (int i = 0; i < 1'000; i++) {
     auto value = i % 17;
     auto hash = hashOne(value);
@@ -118,16 +153,16 @@ TEST_F(SparseHllTest, basic) {
   sparseHll.verify();
   ASSERT_EQ(17, sparseHll.cardinality());
 
-  auto deserialized = roundTrip(sparseHll);
+  auto deserialized = this->roundTrip(sparseHll);
   deserialized.verify();
   ASSERT_EQ(17, deserialized.cardinality());
 
-  auto serialized = serialize(11, sparseHll);
-  ASSERT_EQ(17, SparseHll::cardinality(serialized.data()));
+  auto serialized = this->serialize(11, sparseHll);
+  ASSERT_EQ(17, SparseHlls::cardinality(serialized.data()));
 }
 
-TEST_F(SparseHllTest, highCardinality) {
-  SparseHll sparseHll{&allocator_};
+TYPED_TEST(SparseHllTest, highCardinality) {
+  SparseHll sparseHll{this->allocator_};
   for (int i = 0; i < 1'000; i++) {
     auto hash = hashOne(i);
     sparseHll.insertHash(hash);
@@ -136,12 +171,12 @@ TEST_F(SparseHllTest, highCardinality) {
   sparseHll.verify();
   ASSERT_EQ(1'000, sparseHll.cardinality());
 
-  auto deserialized = roundTrip(sparseHll);
+  auto deserialized = this->roundTrip(sparseHll);
   deserialized.verify();
   ASSERT_EQ(1'000, deserialized.cardinality());
 
-  auto serialized = serialize(11, sparseHll);
-  ASSERT_EQ(1'000, SparseHll::cardinality(serialized.data()));
+  auto serialized = this->serialize(11, sparseHll);
+  ASSERT_EQ(1'000, SparseHlls::cardinality(serialized.data()));
 }
 
 namespace {
@@ -156,30 +191,80 @@ std::vector<T> sequence(T start, T end) {
 }
 } // namespace
 
-TEST_F(SparseHllTest, mergeWith) {
+TYPED_TEST(SparseHllTest, mergeWith) {
   // with overlap
-  testMergeWith(sequence(0, 100), sequence(50, 150));
-  testMergeWith(sequence(50, 150), sequence(0, 100));
+  this->testMergeWith(sequence(0, 100), sequence(50, 150));
+  this->testMergeWith(sequence(50, 150), sequence(0, 100));
 
   // no overlap
-  testMergeWith(sequence(0, 100), sequence(200, 300));
-  testMergeWith(sequence(200, 300), sequence(0, 100));
+  this->testMergeWith(sequence(0, 100), sequence(200, 300));
+  this->testMergeWith(sequence(200, 300), sequence(0, 100));
 
   // idempotent
-  testMergeWith(sequence(0, 100), sequence(0, 100));
+  this->testMergeWith(sequence(0, 100), sequence(0, 100));
 
   // empty sequence
-  testMergeWith(sequence(0, 100), {});
-  testMergeWith({}, sequence(100, 300));
+  this->testMergeWith(sequence(0, 100), {});
+  this->testMergeWith({}, sequence(100, 300));
+}
+
+TYPED_TEST(SparseHllTest, toDense) {
+  int8_t indexBitLength = 11;
+
+  SparseHll sparseHll{this->allocator_};
+  DenseHll expectedHll{indexBitLength, this->allocator_};
+  for (int i = 0; i < 1'000; i++) {
+    auto hash = hashOne(i);
+    sparseHll.insertHash(hash);
+    expectedHll.insertHash(hash);
+  }
+
+  DenseHll denseHll{indexBitLength, this->allocator_};
+  sparseHll.toDense(denseHll);
+  ASSERT_EQ(denseHll.cardinality(), expectedHll.cardinality());
+  ASSERT_EQ(this->serialize(denseHll), this->serialize(expectedHll));
+}
+
+TYPED_TEST(SparseHllTest, testNumberOfZeros) {
+  int8_t indexBitLength = 11;
+  for (int i = 0; i < 64 - indexBitLength; ++i) {
+    auto hash = 1ull << i;
+    SparseHll sparseHll(this->allocator_);
+    sparseHll.insertHash(hash);
+    DenseHll expectedHll(indexBitLength, this->allocator_);
+    expectedHll.insertHash(hash);
+    DenseHll denseHll(indexBitLength, this->allocator_);
+    sparseHll.toDense(denseHll);
+    ASSERT_EQ(this->serialize(denseHll), this->serialize(expectedHll));
+  }
 }
 
-class SparseHllToDenseTest : public ::testing::TestWithParam<int8_t> {
+template <typename TAllocator, int8_t IndexBitLength>
+struct AllocatorWithIndexBits {
+  using AllocatorType = TAllocator;
+  static constexpr int8_t indexBitLength() {
+    return IndexBitLength;
+  }
+};
+
+template <typename TParam>
+class SparseHllToDenseTest : public ::testing::Test {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
-  std::string serialize(DenseHll& denseHll) {
+  void SetUp() override {
+    if constexpr (std::is_same_v<
+                      typename TParam::AllocatorType,
+                      HashStringAllocator>) {
+      allocator_ = &hsa_;
+    } else {
+      allocator_ = pool_.get();
+    }
+  }
+
+  std::string serialize(DenseHll<typename TParam::AllocatorType>& denseHll) {
     auto size = denseHll.serializedSize();
     std::string serialized;
     serialized.resize(size);
@@ -189,41 +274,93 @@ class SparseHllToDenseTest : public ::testing::TestWithParam<int8_t> {
 
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
-  HashStringAllocator allocator_{pool_.get()};
+  HashStringAllocator hsa_{pool_.get()};
+  typename TParam::AllocatorType* allocator_;
 };
 
-TEST_P(SparseHllToDenseTest, toDense) {
-  int8_t indexBitLength = GetParam();
+using SparseHllToDenseTestParams = ::testing::Types<
+    // HashStringAllocator with various index bit lengths
+    AllocatorWithIndexBits<HashStringAllocator, 4>,
+    AllocatorWithIndexBits<HashStringAllocator, 5>,
+    AllocatorWithIndexBits<HashStringAllocator, 6>,
+    AllocatorWithIndexBits<HashStringAllocator, 7>,
+    AllocatorWithIndexBits<HashStringAllocator, 8>,
+    AllocatorWithIndexBits<HashStringAllocator, 9>,
+    AllocatorWithIndexBits<HashStringAllocator, 10>,
+    AllocatorWithIndexBits<HashStringAllocator, 11>,
+    AllocatorWithIndexBits<HashStringAllocator, 12>,
+    AllocatorWithIndexBits<HashStringAllocator, 13>,
+    AllocatorWithIndexBits<HashStringAllocator, 14>,
+    AllocatorWithIndexBits<HashStringAllocator, 15>,
+    AllocatorWithIndexBits<HashStringAllocator, 16>,
+    // MemoryPool with various index bit lengths
+    AllocatorWithIndexBits<memory::MemoryPool, 4>,
+    AllocatorWithIndexBits<memory::MemoryPool, 5>,
+    AllocatorWithIndexBits<memory::MemoryPool, 6>,
+    AllocatorWithIndexBits<memory::MemoryPool, 7>,
+    AllocatorWithIndexBits<memory::MemoryPool, 8>,
+    AllocatorWithIndexBits<memory::MemoryPool, 9>,
+    AllocatorWithIndexBits<memory::MemoryPool, 10>,
+    AllocatorWithIndexBits<memory::MemoryPool, 11>,
+    AllocatorWithIndexBits<memory::MemoryPool, 12>,
+    AllocatorWithIndexBits<memory::MemoryPool, 13>,
+    AllocatorWithIndexBits<memory::MemoryPool, 14>,
+    AllocatorWithIndexBits<memory::MemoryPool, 15>,
+    AllocatorWithIndexBits<memory::MemoryPool, 16>>;
+
+class ToDenseNameGenerator {
+ public:
+  template <typename TParam>
+  static std::string GetName(int) {
+    std::string allocatorName;
+    if constexpr (std::is_same_v<
+                      typename TParam::AllocatorType,
+                      HashStringAllocator>) {
+      allocatorName = "hsa";
+    } else if constexpr (std::is_same_v<
+                             typename TParam::AllocatorType,
+                             memory::MemoryPool>) {
+      allocatorName = "pool";
+    } else {
+      VELOX_UNREACHABLE(
+          "Only HashStringAllocator and MemoryPool are supported allocator types.");
+    }
+    return fmt::format("{}_{}", allocatorName, TParam::indexBitLength());
+  }
+};
 
-  SparseHll sparseHll{&allocator_};
-  DenseHll expectedHll{indexBitLength, &allocator_};
+TYPED_TEST_SUITE(
+    SparseHllToDenseTest,
+    SparseHllToDenseTestParams,
+    ToDenseNameGenerator);
+
+TYPED_TEST(SparseHllToDenseTest, toDense) {
+  int8_t indexBitLength = TypeParam::indexBitLength();
+
+  SparseHll sparseHll{this->allocator_};
+  DenseHll expectedHll{indexBitLength, this->allocator_};
   for (int i = 0; i < 1'000; i++) {
     auto hash = hashOne(i);
     sparseHll.insertHash(hash);
     expectedHll.insertHash(hash);
   }
 
-  DenseHll denseHll{indexBitLength, &allocator_};
+  DenseHll denseHll{indexBitLength, this->allocator_};
   sparseHll.toDense(denseHll);
   ASSERT_EQ(denseHll.cardinality(), expectedHll.cardinality());
-  ASSERT_EQ(serialize(denseHll), serialize(expectedHll));
+  ASSERT_EQ(this->serialize(denseHll), this->serialize(expectedHll));
 }
 
-TEST_P(SparseHllToDenseTest, testNumberOfZeros) {
-  auto indexBitLength = GetParam();
+TYPED_TEST(SparseHllToDenseTest, testNumberOfZeros) {
+  auto indexBitLength = TypeParam::indexBitLength();
   for (int i = 0; i < 64 - indexBitLength; ++i) {
     auto hash = 1ull << i;
-    SparseHll sparseHll(&allocator_);
+    SparseHll sparseHll(this->allocator_);
     sparseHll.insertHash(hash);
-    DenseHll expectedHll(indexBitLength, &allocator_);
+    DenseHll expectedHll(indexBitLength, this->allocator_);
     expectedHll.insertHash(hash);
-    DenseHll denseHll(indexBitLength, &allocator_);
+    DenseHll denseHll(indexBitLength, this->allocator_);
     sparseHll.toDense(denseHll);
-    ASSERT_EQ(serialize(denseHll), serialize(expectedHll));
+    ASSERT_EQ(this->serialize(denseHll), this->serialize(expectedHll));
   }
 }
-
-INSTANTIATE_TEST_SUITE_P(
-    SparseHllToDenseTest,
-    SparseHllToDenseTest,
-    ::testing::Values(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16));
diff --git a/velox/common/io/IoStatistics.h b/velox/common/io/IoStatistics.h
index 2111a8877b47..1371d977a594 100644
--- a/velox/common/io/IoStatistics.h
+++ b/velox/common/io/IoStatistics.h
@@ -43,6 +43,24 @@ struct OperationCounters {
 
 class IoCounter {
  public:
+  IoCounter& operator=(const IoCounter& other) noexcept {
+    if (this != &other) {
+      count_.store(
+          other.count_.load(std::memory_order_relaxed),
+          std::memory_order_relaxed);
+      sum_.store(
+          other.sum_.load(std::memory_order_relaxed),
+          std::memory_order_relaxed);
+      min_.store(
+          other.min_.load(std::memory_order_relaxed),
+          std::memory_order_relaxed);
+      max_.store(
+          other.max_.load(std::memory_order_relaxed),
+          std::memory_order_relaxed);
+    }
+    return *this;
+  }
+
   uint64_t count() const {
     return count_;
   }
diff --git a/velox/common/memory/Allocation.cpp b/velox/common/memory/Allocation.cpp
index 884af7c82cf5..63fb4db4baa7 100644
--- a/velox/common/memory/Allocation.cpp
+++ b/velox/common/memory/Allocation.cpp
@@ -35,10 +35,11 @@ void Allocation::append(uint8_t* address, MachinePageCount numPages) {
       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));
+    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);
diff --git a/velox/common/memory/ArbitrationOperation.h b/velox/common/memory/ArbitrationOperation.h
index e494d93d2b85..d9159c583c87 100644
--- a/velox/common/memory/ArbitrationOperation.h
+++ b/velox/common/memory/ArbitrationOperation.h
@@ -154,7 +154,7 @@ struct fmt::formatter<facebook::velox::memory::ArbitrationOperation::State>
     : formatter<std::string> {
   auto format(
       facebook::velox::memory::ArbitrationOperation::State state,
-      format_context& ctx) {
+      format_context& ctx) const {
     return formatter<std::string>::format(
         facebook::velox::memory::ArbitrationOperation::stateName(state), ctx);
   }
diff --git a/velox/common/memory/ArbitrationParticipant.cpp b/velox/common/memory/ArbitrationParticipant.cpp
index 1b29c2107121..7d74c98c7311 100644
--- a/velox/common/memory/ArbitrationParticipant.cpp
+++ b/velox/common/memory/ArbitrationParticipant.cpp
@@ -31,7 +31,7 @@ using namespace facebook::velox::memory;
 
 std::string ArbitrationParticipant::Config::toString() const {
   return fmt::format(
-      "initCapacity {}, minCapacity {}, fastExponentialGrowthCapacityLimit {}, slowCapacityGrowRatio {}, minFreeCapacity {}, minFreeCapacityRatio {}, minReclaimBytes {}, minReclaimPct {}, abortCapacityLimit {}",
+      "initCapacity {}, minCapacity {}, fastExponentialGrowthCapacityLimit {}, slowCapacityGrowRatio {}, minFreeCapacity {}, minFreeCapacityRatio {}, minReclaimBytes {}, minReclaimPct {}",
       succinctBytes(initCapacity),
       succinctBytes(minCapacity),
       succinctBytes(fastExponentialGrowthCapacityLimit),
@@ -39,8 +39,7 @@ std::string ArbitrationParticipant::Config::toString() const {
       succinctBytes(minFreeCapacity),
       minFreeCapacityRatio,
       succinctBytes(minReclaimBytes),
-      minReclaimPct,
-      succinctBytes(abortCapacityLimit));
+      minReclaimPct);
 }
 
 ArbitrationParticipant::Config::Config(
@@ -51,8 +50,7 @@ ArbitrationParticipant::Config::Config(
     uint64_t _minFreeCapacity,
     double _minFreeCapacityRatio,
     uint64_t _minReclaimBytes,
-    double _minReclaimPct,
-    uint64_t _abortCapacityLimit)
+    double _minReclaimPct)
     : initCapacity(_initCapacity),
       minCapacity(_minCapacity),
       fastExponentialGrowthCapacityLimit(_fastExponentialGrowthCapacityLimit),
@@ -60,8 +58,7 @@ ArbitrationParticipant::Config::Config(
       minFreeCapacity(_minFreeCapacity),
       minFreeCapacityRatio(_minFreeCapacityRatio),
       minReclaimBytes(_minReclaimBytes),
-      minReclaimPct(_minReclaimPct),
-      abortCapacityLimit(_abortCapacityLimit) {
+      minReclaimPct(_minReclaimPct) {
   VELOX_CHECK_GE(slowCapacityGrowRatio, 0);
   VELOX_CHECK_EQ(
       fastExponentialGrowthCapacityLimit == 0,
@@ -82,10 +79,6 @@ ArbitrationParticipant::Config::Config(
       "adjustment.",
       minFreeCapacity,
       minFreeCapacityRatio);
-  VELOX_CHECK(
-      bits::isPowerOfTwo(abortCapacityLimit),
-      "abortCapacityLimit {} not a power of two",
-      abortCapacityLimit);
   VELOX_CHECK(
       0 <= minReclaimPct && minReclaimPct <= 1,
       "minReclaimPct {} must be in [0, 1]",
@@ -109,8 +102,7 @@ ArbitrationParticipant::ArbitrationParticipant(
       pool_(pool.get()),
       config_(config),
       maxCapacity_(pool_->maxCapacity()),
-      createTimeNs_(getCurrentTimeNano()),
-      poolPriority_(pool_->poolPriority()) {
+      createTimeNs_(getCurrentTimeNano()) {
   VELOX_CHECK_LE(
       config_->minCapacity,
       maxCapacity_,
@@ -363,7 +355,9 @@ uint64_t ArbitrationParticipant::abortLocked(
     if (aborted_) {
       return 0;
     }
+    aborted_ = true;
   }
+
   try {
     VELOX_MEM_LOG(WARNING) << "Memory pool " << pool_->name()
                            << " is being aborted";
@@ -378,8 +372,6 @@ uint64_t ArbitrationParticipant::abortLocked(
   VELOX_CHECK(pool_->aborted());
 
   std::lock_guard<std::mutex> l(stateLock_);
-  VELOX_CHECK(!aborted_);
-  aborted_ = true;
   return shrinkLocked(/*reclaimAll=*/true);
 }
 
@@ -449,8 +441,9 @@ ArbitrationTimedLock::ArbitrationTimedLock(
     uint64_t timeoutNs)
     : mutex_(mutex) {
   if (!mutex_.try_lock_for(std::chrono::nanoseconds(timeoutNs))) {
-    VELOX_MEM_ARBITRATION_TIMEOUT(fmt::format(
-        "Memory arbitration lock timed out when reclaiming from arbitration participant."));
+    VELOX_MEM_ARBITRATION_TIMEOUT(
+        fmt::format(
+            "Memory arbitration lock timed out when reclaiming from arbitration participant."));
   }
 }
 
diff --git a/velox/common/memory/ArbitrationParticipant.h b/velox/common/memory/ArbitrationParticipant.h
index 4eb7763c8edb..530b04b9dda0 100644
--- a/velox/common/memory/ArbitrationParticipant.h
+++ b/velox/common/memory/ArbitrationParticipant.h
@@ -119,17 +119,6 @@ class ArbitrationParticipant
     uint64_t minReclaimBytes;
     double minReclaimPct;
 
-    /// Specifies the starting memory capacity limit for global arbitration to
-    /// search for victim participant to reclaim used memory by abort. For
-    /// participants with capacity larger than the limit, the global arbitration
-    /// choose to abort the youngest participant which has the largest
-    /// participant id. This helps to let the old queries to run to completion.
-    /// The abort capacity limit is reduced by half if couldn't find a victim
-    /// participant until reaches to zero.
-    ///
-    /// NOTE: the limit must be zero or a power of 2.
-    uint64_t abortCapacityLimit;
-
     Config(
         uint64_t _initCapacity,
         uint64_t _minCapacity,
@@ -138,8 +127,7 @@ class ArbitrationParticipant
         uint64_t _minFreeCapacity,
         double _minFreeCapacityRatio,
         uint64_t _minReclaimBytes,
-        double _minReclaimPct,
-        uint64_t _abortCapacityLimit);
+        double _minReclaimPct);
 
     std::string toString() const;
   };
@@ -173,11 +161,6 @@ class ArbitrationParticipant
     return config_->minCapacity;
   }
 
-  /// Returns the priority of the underlying query memory pool.
-  uint32_t poolPriority() const {
-    return poolPriority_;
-  }
-
   /// Returns the duration of this arbitration participant since its creation.
   uint64_t durationNs() const {
     const auto now = getCurrentTimeNano();
@@ -349,7 +332,6 @@ class ArbitrationParticipant
   const Config* const config_;
   const uint64_t maxCapacity_;
   const uint64_t createTimeNs_;
-  const uint32_t poolPriority_;
 
   mutable std::mutex stateLock_;
   bool aborted_{false};
diff --git a/velox/common/memory/ByteStream.cpp b/velox/common/memory/ByteStream.cpp
index 4fe93b569216..c910f32c9c90 100644
--- a/velox/common/memory/ByteStream.cpp
+++ b/velox/common/memory/ByteStream.cpp
@@ -16,19 +16,21 @@
 
 #include "velox/common/memory/ByteStream.h"
 
+#include <algorithm>
+
 namespace facebook::velox {
 
+static ByteRange convByteRange(folly::ByteRange br) {
+  return {const_cast<uint8_t*>(br.data()), folly::to_signed(br.size()), 0};
+}
+
 std::vector<ByteRange> byteRangesFromIOBuf(folly::IOBuf* iobuf) {
   if (iobuf == nullptr) {
     return {};
   }
   std::vector<ByteRange> byteRanges;
-  auto* current = iobuf;
-  do {
-    byteRanges.push_back(
-        {current->writableData(), static_cast<int32_t>(current->length()), 0});
-    current = current->next();
-  } while (current != iobuf);
+  auto dst = std::back_inserter(byteRanges);
+  std::transform(iobuf->begin(), iobuf->end(), dst, convByteRange);
   return byteRanges;
 }
 
diff --git a/velox/common/memory/ByteStream.h b/velox/common/memory/ByteStream.h
index fee24a1f2e87..1063e71ee096 100644
--- a/velox/common/memory/ByteStream.h
+++ b/velox/common/memory/ByteStream.h
@@ -361,9 +361,10 @@ class ByteOutputStream {
     }
 
     if (current_->position + sizeof(T) * values.size() > current_->size) {
-      appendStringView(std::string_view(
-          reinterpret_cast<const char*>(&values[0]),
-          values.size() * sizeof(T)));
+      appendStringView(
+          std::string_view(
+              reinterpret_cast<const char*>(&values[0]),
+              values.size() * sizeof(T)));
       return;
     }
     auto* target = current_->buffer + current_->position;
@@ -537,9 +538,10 @@ class AppendWindow {
   ~AppendWindow() noexcept {
     if (scratchPtr_.size()) {
       try {
-        stream_.appendStringView(std::string_view(
-            reinterpret_cast<const char*>(scratchPtr_.get()),
-            scratchPtr_.size() * sizeof(T)));
+        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.
diff --git a/velox/common/memory/CMakeLists.txt b/velox/common/memory/CMakeLists.txt
index f3b39127cfd3..a36e0f06a6be 100644
--- a/velox/common/memory/CMakeLists.txt
+++ b/velox/common/memory/CMakeLists.txt
@@ -32,18 +32,21 @@ velox_add_library(
   MmapArena.cpp
   RawVector.cpp
   SharedArbitrator.cpp
-  StreamArena.cpp)
+  StreamArena.cpp
+)
 
 velox_link_libraries(
   velox_memory
-  PUBLIC velox_common_base
-         velox_common_config
-         velox_exception
-         velox_flag_definitions
-         velox_time
-         velox_type
-         Folly::folly
-         fmt::fmt
-         gflags::gflags
-         glog::glog
-  PRIVATE velox_test_util re2::re2)
+  PUBLIC
+    velox_common_base
+    velox_common_config
+    velox_exception
+    velox_flag_definitions
+    velox_time
+    velox_type
+    Folly::folly
+    fmt::fmt
+    gflags::gflags
+    glog::glog
+  PRIVATE velox_test_util re2::re2
+)
diff --git a/velox/common/memory/HashStringAllocator.h b/velox/common/memory/HashStringAllocator.h
index fd9fadc1c2b2..6e153894dfc8 100644
--- a/velox/common/memory/HashStringAllocator.h
+++ b/velox/common/memory/HashStringAllocator.h
@@ -19,7 +19,6 @@
 #include "velox/common/memory/AllocationPool.h"
 #include "velox/common/memory/ByteStream.h"
 #include "velox/common/memory/CompactDoubleList.h"
-#include "velox/common/memory/Memory.h"
 #include "velox/common/memory/StreamArena.h"
 #include "velox/type/StringView.h"
 
@@ -27,6 +26,9 @@
 
 namespace facebook::velox {
 
+template <class T>
+struct StlAllocator;
+
 /// 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.
@@ -41,6 +43,9 @@ namespace facebook::velox {
 /// backing a HashStringAllocator is set to kArenaEnd.
 class HashStringAllocator : public StreamArena {
  public:
+  template <typename T>
+  using TStlAllocator = StlAllocator<T>;
+
   /// The minimum allocation must have space after the header for the free list
   /// pointers and the trailing length.
   static constexpr int32_t kMinAlloc =
@@ -659,8 +664,8 @@ class RowSizeTracker {
         counter_(counter) {}
 
   ~RowSizeTracker() {
-    auto delta = allocator_->currentBytes() - size_;
-    if (delta) {
+    const auto delta = allocator_->currentBytes() - size_;
+    if (delta != 0) {
       saturatingIncrement(&counter_, delta);
     }
   }
@@ -668,7 +673,7 @@ class RowSizeTracker {
  private:
   // Increments T at *pointer without wrapping around at overflow.
   void saturatingIncrement(T* pointer, int64_t delta) {
-    auto value = *reinterpret_cast<TCounter*>(pointer) + delta;
+    const auto value = *reinterpret_cast<TCounter*>(pointer) + delta;
     *reinterpret_cast<TCounter*>(pointer) =
         std::min<uint64_t>(value, std::numeric_limits<TCounter>::max());
   }
@@ -685,11 +690,15 @@ struct StlAllocator {
 
   explicit StlAllocator(HashStringAllocator* allocator)
       : allocator_{allocator} {
-    VELOX_CHECK(allocator);
+    VELOX_CHECK_NOT_NULL(allocator);
   }
 
+  // We can use "explicit" here based on the C++ standard. But
+  // libstdc++ 12 or older doesn't work for std::vector<bool> and
+  // "explicit". We can avoid it by not using "explicit" here.
+  // See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115854
   template <class U>
-  explicit StlAllocator(const StlAllocator<U>& allocator)
+  StlAllocator(const StlAllocator<U>& allocator)
       : allocator_{allocator.allocator()} {
     VELOX_CHECK_NOT_NULL(allocator_);
   }
@@ -713,16 +722,10 @@ struct StlAllocator {
     return allocator_;
   }
 
-  friend bool operator==(const StlAllocator& lhs, const StlAllocator& rhs) {
-    return lhs.allocator_ == rhs.allocator_;
-  }
-
-  friend bool operator!=(const StlAllocator& lhs, const StlAllocator& rhs) {
-    return !(lhs == rhs);
-  }
+  bool operator==(const StlAllocator& other) const = default;
 
  private:
-  HashStringAllocator* allocator_;
+  HashStringAllocator* const allocator_;
 };
 
 /// An allocator backed by HashStringAllocator that guaratees a configurable
@@ -803,12 +806,6 @@ struct AlignedStlAllocator {
     return lhs.allocator_ == rhs.allocator_;
   }
 
-  friend bool operator!=(
-      const AlignedStlAllocator& lhs,
-      const AlignedStlAllocator& rhs) {
-    return !(lhs == rhs);
-  }
-
  private:
   // Pad the memory user requested by some padding to facilitate memory
   // alignment later. Memory layout:
@@ -833,7 +830,7 @@ struct AlignedStlAllocator {
     return reinterpret_cast<T*>(alignedPtr);
   }
 
-  HashStringAllocator* allocator_;
+  HashStringAllocator* const allocator_;
   const bool poolAligned_;
 };
 
diff --git a/velox/common/memory/MallocAllocator.cpp b/velox/common/memory/MallocAllocator.cpp
index ff44791763ac..775401ebe99a 100644
--- a/velox/common/memory/MallocAllocator.cpp
+++ b/velox/common/memory/MallocAllocator.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/memory/MallocAllocator.h"
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/memory/Memory.h"
 
 #include <sys/mman.h>
@@ -33,7 +34,7 @@ MallocAllocator::MallocAllocator(size_t capacity, uint32_t reservationByteLimit)
             decrementUsageWithReservationFunc(counter, decrement, lock);
             return true;
           }),
-      reservations_(std::thread::hardware_concurrency()) {}
+      reservations_(folly::hardware_concurrency()) {}
 
 MallocAllocator::~MallocAllocator() {
   // TODO: Remove the check when memory leak issue is resolved.
@@ -58,9 +59,10 @@ bool MallocAllocator::allocateNonContiguousWithoutRetry(
       !incrementUsage(totalBytes)) {
     const auto errorMsg = fmt::format(
         "Exceeded memory allocator limit when allocating {} new pages"
-        ", the memory allocator capacity is {}",
+        ", the memory allocator capacity is {}, the allocated bytes is {}",
         sizeMix.totalPages,
-        succinctBytes(capacity_));
+        succinctBytes(capacity_),
+        succinctBytes(allocatedBytes_));
     VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
     setAllocatorFailureMessage(errorMsg);
     return false;
@@ -150,6 +152,7 @@ bool MallocAllocator::allocateContiguousImpl(
     }
     numMapped_.fetch_sub(numContiguousCollateralPages);
     numAllocated_.fetch_sub(numContiguousCollateralPages);
+    numExternalMapped_.fetch_sub(numContiguousCollateralPages);
     decrementUsage(AllocationTraits::pageBytes(numContiguousCollateralPages));
     allocation.clear();
   }
@@ -171,6 +174,7 @@ bool MallocAllocator::allocateContiguousImpl(
   }
   numAllocated_.fetch_add(numPages);
   numMapped_.fetch_add(numPages);
+  numExternalMapped_.fetch_add(numPages);
   void* data = ::mmap(
       nullptr,
       AllocationTraits::pageBytes(maxPages),
@@ -228,6 +232,7 @@ void MallocAllocator::freeContiguousImpl(ContiguousAllocation& allocation) {
   }
   numMapped_.fetch_sub(numPages);
   numAllocated_.fetch_sub(numPages);
+  numExternalMapped_.fetch_sub(numPages);
   decrementUsage(bytes);
   allocation.clear();
 }
@@ -248,6 +253,7 @@ bool MallocAllocator::growContiguousWithoutRetry(
   }
   numAllocated_ += increment;
   numMapped_ += increment;
+  numExternalMapped_ += increment;
   allocation.set(
       allocation.data(),
       allocation.size() + AllocationTraits::kPageSize * increment,
diff --git a/velox/common/memory/MallocAllocator.h b/velox/common/memory/MallocAllocator.h
index ade9536f0fb6..5e3e7508fdc4 100644
--- a/velox/common/memory/MallocAllocator.h
+++ b/velox/common/memory/MallocAllocator.h
@@ -77,6 +77,10 @@ class MallocAllocator : public MemoryAllocator {
     return numMapped_;
   }
 
+  MachinePageCount numExternalMapped() const override {
+    return numExternalMapped_;
+  }
+
   bool checkConsistency() const override;
 
   std::string toString() const override;
@@ -202,11 +206,12 @@ class MallocAllocator : public MemoryAllocator {
     if (originalBytes - bytes < 0) {
       // In case of inconsistency while freeing memory, do not revert in this
       // case because free is guaranteed to happen.
-      VELOX_MEM_ALLOC_ERROR(fmt::format(
-          "Trying to free {} bytes, which is larger than current allocated "
-          "bytes {}",
-          bytes,
-          originalBytes))
+      VELOX_MEM_ALLOC_ERROR(
+          fmt::format(
+              "Trying to free {} bytes, which is larger than current allocated "
+              "bytes {}",
+              bytes,
+              originalBytes))
     }
   }
 
diff --git a/velox/common/memory/Memory.cpp b/velox/common/memory/Memory.cpp
index 3b9f3cbf716a..01de413c830d 100644
--- a/velox/common/memory/Memory.cpp
+++ b/velox/common/memory/Memory.cpp
@@ -74,36 +74,6 @@ std::unique_ptr<MemoryArbitrator> createArbitrator(
        .extraConfigs = options.extraArbitratorConfigs});
 }
 
-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.
-
-  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);
@@ -117,6 +87,50 @@ std::vector<std::shared_ptr<MemoryPool>> createSharedLeafMemoryPools(
   }
   return leafPools;
 }
+
+// Used by sys root memory pool for use case that expect a memory reclaimer to
+// set like QueryCtx.
+class SysMemoryReclaimer : public memory::MemoryReclaimer {
+ public:
+  static std::unique_ptr<memory::MemoryReclaimer> create() {
+    return std::unique_ptr<memory::MemoryReclaimer>(new SysMemoryReclaimer());
+  }
+
+  uint64_t reclaim(
+      memory::MemoryPool* pool,
+      uint64_t targetBytes,
+      uint64_t maxWaitMs,
+      memory::MemoryReclaimer::Stats& stats) override {
+    return 0;
+  }
+
+  void enterArbitration() override {}
+
+  void leaveArbitration() noexcept override {}
+
+  int32_t priority() const override {
+    return 0;
+  }
+
+  bool reclaimableBytes(const MemoryPool& pool, uint64_t& reclaimableBytes)
+      const override {
+    return false;
+  }
+
+  /// Invoked by the memory arbitrator to abort memory 'pool' and the associated
+  /// query execution when encounters non-recoverable memory reclaim error or
+  /// fails to reclaim enough free capacity. The abort is a synchronous
+  /// operation and we expect most of used memory to be freed after the abort
+  /// completes. 'error' should be passed in as the direct cause of the
+  /// abortion. It will be propagated all the way to task level for accurate
+  /// error exposure.
+  void abort(MemoryPool* pool, const std::exception_ptr& error) override {
+    VELOX_UNSUPPORTED("SysMemoryReclaimer::abort is not supported");
+  }
+
+ private:
+  SysMemoryReclaimer() : MemoryReclaimer{0} {};
+};
 } // namespace
 
 MemoryManager::MemoryManager(const MemoryManager::Options& options)
@@ -147,50 +161,7 @@ MemoryManager::MemoryManager(const MemoryManager::Options& options)
       cachePool_{addLeafPool("__sys_caching__")},
       tracePool_{addLeafPool("__sys_tracing__")},
       sharedLeafPools_(createSharedLeafMemoryPools(*sysRoot_)) {
-  VELOX_CHECK_NOT_NULL(allocator_);
-  VELOX_CHECK_NOT_NULL(arbitrator_);
-  VELOX_USER_CHECK_GE(capacity(), 0);
-  VELOX_CHECK_GE(allocator_->capacity(), arbitrator_->capacity());
-  MemoryAllocator::alignmentCheck(0, alignment_);
-  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(const MemoryManagerOptions& options)
-    : allocator_{createAllocator(options)},
-      arbitrator_(createArbitrator(options)),
-      alignment_(std::max(MemoryAllocator::kMinAlignment, options.alignment)),
-      checkUsageLeak_(options.checkUsageLeak),
-      coreOnAllocationFailureEnabled_(options.coreOnAllocationFailureEnabled),
-      disableMemoryPoolTracking_(options.disableMemoryPoolTracking),
-      getPreferredSize_(options.getPreferredSize),
-      poolDestructionCb_([&](MemoryPool* pool) { dropPool(pool); }),
-      sysRoot_{std::make_shared<MemoryPoolImpl>(
-          this,
-          std::string(kSysRootName),
-          MemoryPool::Kind::kAggregate,
-          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,
-              .coreOnAllocationFailureEnabled =
-                  options.coreOnAllocationFailureEnabled,
-              .getPreferredSize = getPreferredSize_})},
-      spillPool_{addLeafPool("__sys_spilling__")},
-      cachePool_{addLeafPool("__sys_caching__")},
-      tracePool_{addLeafPool("__sys_tracing__")},
-      sharedLeafPools_(createSharedLeafMemoryPools(*sysRoot_)) {
+  sysRoot_->setReclaimer(SysMemoryReclaimer::create());
   VELOX_CHECK_NOT_NULL(allocator_);
   VELOX_CHECK_NOT_NULL(arbitrator_);
   VELOX_USER_CHECK_GE(capacity(), 0);
@@ -256,19 +227,6 @@ void MemoryManager::initialize(const MemoryManager::Options& options) {
   state.instance.store(instance, std::memory_order_release);
 }
 
-// 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);
@@ -292,15 +250,6 @@ MemoryManager& MemoryManager::testingSetInstance(
   return *instance;
 }
 
-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 allocator_->capacity();
 }
@@ -331,8 +280,7 @@ std::shared_ptr<MemoryPool> MemoryManager::addRootPool(
     const std::string& name,
     int64_t maxCapacity,
     std::unique_ptr<MemoryReclaimer> reclaimer,
-    const std::optional<MemoryPool::DebugOptions>& poolDebugOpts,
-    uint32_t poolPriority) {
+    const std::optional<MemoryPool::DebugOptions>& poolDebugOpts) {
   std::string poolName = name;
   if (poolName.empty()) {
     static std::atomic<int64_t> poolId{0};
@@ -346,7 +294,6 @@ std::shared_ptr<MemoryPool> MemoryManager::addRootPool(
   options.coreOnAllocationFailureEnabled = coreOnAllocationFailureEnabled_;
   options.getPreferredSize = getPreferredSize_;
   options.debugOptions = poolDebugOpts;
-  options.poolPriority = poolPriority;
 
   auto pool = createRootPool(poolName, reclaimer, options);
   if (!disableMemoryPoolTracking_) {
@@ -474,10 +421,6 @@ void initializeMemoryManager(const MemoryManager::Options& options) {
   MemoryManager::initialize(options);
 }
 
-void initializeMemoryManager(const MemoryManagerOptions& options) {
-  MemoryManager::initialize(options);
-}
-
 MemoryManager* memoryManager() {
   return MemoryManager::getInstance();
 }
@@ -497,6 +440,10 @@ MemoryPool& deprecatedSharedLeafPool() {
   return deprecatedDefaultMemoryManager().deprecatedSharedLeafPool();
 }
 
+MemoryPool& deprecatedRootPool() {
+  return deprecatedDefaultMemoryManager().deprecatedSysRootPool();
+}
+
 memory::MemoryPool* spillMemoryPool() {
   return memory::MemoryManager::getInstance()->spillPool();
 }
diff --git a/velox/common/memory/Memory.h b/velox/common/memory/Memory.h
index 317c32935927..3e40d2ff9aac 100644
--- a/velox/common/memory/Memory.h
+++ b/velox/common/memory/Memory.h
@@ -41,7 +41,6 @@
 #include "velox/common/memory/MemoryPool.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
-DECLARE_bool(velox_memory_pool_debug_enabled);
 DECLARE_bool(velox_enable_memory_usage_track_in_default_memory_pool);
 
 namespace facebook::velox::memory {
@@ -59,118 +58,6 @@ namespace facebook::velox::memory {
       "{}",                                                         \
       errorMessage);
 
-/// TODO(wangke): deprecate when MemoryManagerOptions is fully migrated.
-struct MemoryManagerOptions {
-  /// Specifies the default memory allocation alignment.
-  uint16_t alignment{MemoryAllocator::kMaxAlignment};
-
-  /// If true, enable memory usage tracking in the default memory pool.
-  bool trackDefaultUsage{
-      FLAGS_velox_enable_memory_usage_track_in_default_memory_pool};
-
-  /// If true, check the memory pool and usage leaks on destruction.
-  ///
-  /// TODO: deprecate this flag after all the existing memory leak use cases
-  /// have been fixed.
-  bool checkUsageLeak{FLAGS_velox_memory_leak_check_enabled};
-
-  /// 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 =================
-
-  /// 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};
-
-  /// The string kind of memory arbitrator used in the memory manager.
-  ///
-  /// NOTE: the arbitrator will only be created if its kind is set explicitly.
-  /// Otherwise MemoryArbitrator::create returns a nullptr.
-  std::string arbitratorKind{};
-
-  /// 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 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> extraArbitratorConfigs{};
-
-  /// Provides the customized get preferred size function for memory pool
-  /// allocation. It returns the actual allocation size for a given input size.
-  /// If not set, uses the memory pool's default get preferred size function.
-  std::function<size_t(size_t)> getPreferredSize{nullptr};
-};
-
 /// 'MemoryManager' is responsible for creating allocator, arbitrator and
 /// managing the memory pools.
 class MemoryManager {
@@ -291,18 +178,12 @@ class MemoryManager {
 
   explicit MemoryManager(const Options& options = Options{});
 
-  /// TODO(wangke): deprecate when MemoryManagerOptions is fully migrated.
-  explicit MemoryManager(const MemoryManagerOptions& options);
-
   ~MemoryManager();
 
   /// Creates process-wide memory manager using specified options. Throws if
   /// memory manager has already been created by an easier call.
   static void initialize(const Options& options);
 
-  /// TODO(wangke): deprecate when MemoryManagerOptions is fully migrated.
-  static void initialize(const MemoryManagerOptions& options);
-
   /// Returns process-wide memory manager. Throws if 'initialize' hasn't been
   /// called yet.
   static MemoryManager* getInstance();
@@ -319,9 +200,6 @@ class MemoryManager {
   /// Used by test to override the process-wide memory manager.
   static MemoryManager& testingSetInstance(const Options& options);
 
-  /// TODO(wangke): deprecate when MemoryManagerOptions is fully migrated.
-  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;
@@ -337,8 +215,7 @@ class MemoryManager {
       int64_t maxCapacity = kMaxMemory,
       std::unique_ptr<MemoryReclaimer> reclaimer = nullptr,
       const std::optional<MemoryPool::DebugOptions>& poolDebugOpts =
-          std::nullopt,
-      uint32_t poolPriority = 0);
+          std::nullopt);
 
   /// Creates a leaf memory pool for direct memory allocation use with specified
   /// 'name'. If 'name' is missing, the memory manager generates a default name
@@ -390,8 +267,8 @@ class MemoryManager {
   std::string toString(bool detail = false) const;
 
   /// Returns the memory manger's internal default root memory pool for testing
-  /// purpose.
-  MemoryPool& testingDefaultRoot() const {
+  /// purpose and legacy use cases.
+  MemoryPool& deprecatedSysRootPool() const {
     return *sysRoot_;
   }
 
@@ -458,9 +335,6 @@ class MemoryManager {
 /// the function throws.
 void initializeMemoryManager(const MemoryManager::Options& options);
 
-/// TODO(wangke): deprecate when MemoryManagerOptions is fully migrated.
-void initializeMemoryManager(const MemoryManagerOptions& options);
-
 /// Returns the process-wide memory manager.
 ///
 /// NOTE: user should have already initialized memory manager by calling.
@@ -486,6 +360,9 @@ std::shared_ptr<MemoryPool> deprecatedAddDefaultLeafMemoryPool(
 /// lifecycle of the allocated memory pools properly.
 MemoryPool& deprecatedSharedLeafPool();
 
+/// Returns the sys root memory pool from the default memory manager.
+MemoryPool& deprecatedRootPool();
+
 /// Returns the system-wide memory pool for spilling memory usage.
 memory::MemoryPool* spillMemoryPool();
 
diff --git a/velox/common/memory/MemoryAllocator.h b/velox/common/memory/MemoryAllocator.h
index 4a7ac706c715..621fe2e2a884 100644
--- a/velox/common/memory/MemoryAllocator.h
+++ b/velox/common/memory/MemoryAllocator.h
@@ -87,7 +87,7 @@ struct Stats {
   /// power of 2 >= the allocation size.
   static constexpr int32_t kNumSizes = 20;
   Stats() {
-    for (auto i = 0; i < sizes.size(); ++i) {
+    for (size_t i = 0; i < sizes.size(); ++i) {
       sizes[i].size = 1 << i;
     }
   }
@@ -341,6 +341,8 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
 
   virtual MachinePageCount numMapped() const = 0;
 
+  virtual MachinePageCount numExternalMapped() const = 0;
+
   virtual Stats stats() const {
     return stats_;
   }
@@ -502,6 +504,14 @@ class MemoryAllocator : public std::enable_shared_from_this<MemoryAllocator> {
   // system by 'this' (via madvise calls).
   std::atomic<MachinePageCount> numMapped_{0};
 
+  // Number of pages allocated and explicitly mmap'd by the
+  // application via allocateContiguous, outside of
+  // 'sizeClasses'. These pages are counted in 'numAllocated_' and
+  // 'numMapped_'. Allocation requests are decided against
+  // 'numAllocated_' and 'numMapped_'. This counter is informational
+  // only.
+  std::atomic<MachinePageCount> numExternalMapped_{0};
+
   // Indicates if the failure injection is persistent or transient.
   //
   // NOTE: this is only used for testing purpose.
diff --git a/velox/common/memory/MemoryArbitrator.cpp b/velox/common/memory/MemoryArbitrator.cpp
index 1c40c8bf82df..b4b6af0a7ea1 100644
--- a/velox/common/memory/MemoryArbitrator.cpp
+++ b/velox/common/memory/MemoryArbitrator.cpp
@@ -99,7 +99,11 @@ class NoopArbitrator : public MemoryArbitrator {
   }
 
   void removePool(MemoryPool* pool) override {
-    VELOX_CHECK_EQ(pool->reservedBytes(), 0);
+    VELOX_CHECK_EQ(
+        pool->reservedBytes(),
+        0,
+        "Memory pool has unexpected reserved bytes on removal: {}",
+        pool->name());
   }
 
   // Noop arbitrator has no memory capacity limit so no operation needed for
@@ -263,9 +267,10 @@ uint64_t MemoryReclaimer::reclaim(
           nonReclaimableCandidates.push_back(Candidate{std::move(child), 0});
           continue;
         }
-        candidates.push_back(Candidate{
-            std::move(child),
-            static_cast<int64_t>(reclaimableBytesOpt.value())});
+        candidates.push_back(
+            Candidate{
+                std::move(child),
+                static_cast<int64_t>(reclaimableBytesOpt.value())});
       }
     }
   }
@@ -321,19 +326,6 @@ void MemoryReclaimer::Stats::reset() {
   reclaimWaitTimeUs = 0;
 }
 
-bool MemoryReclaimer::Stats::operator==(
-    const MemoryReclaimer::Stats& other) const {
-  return numNonReclaimableAttempts == other.numNonReclaimableAttempts &&
-      reclaimExecTimeUs == other.reclaimExecTimeUs &&
-      reclaimedBytes == other.reclaimedBytes &&
-      reclaimWaitTimeUs == other.reclaimWaitTimeUs;
-}
-
-bool MemoryReclaimer::Stats::operator!=(
-    const MemoryReclaimer::Stats& other) const {
-  return !(*this == other);
-}
-
 MemoryReclaimer::Stats& MemoryReclaimer::Stats::operator+=(
     const MemoryReclaimer::Stats& other) {
   numNonReclaimableAttempts += other.numNonReclaimableAttempts;
@@ -425,11 +417,8 @@ bool MemoryArbitrator::Stats::operator==(const Stats& other) const {
              other.numNonReclaimableAttempts);
 }
 
-bool MemoryArbitrator::Stats::operator!=(const Stats& other) const {
-  return !(*this == other);
-}
-
-bool MemoryArbitrator::Stats::operator<(const Stats& other) const {
+std::strong_ordering MemoryArbitrator::Stats::operator<=>(
+    const Stats& other) const {
   uint32_t gtCount{0};
   uint32_t ltCount{0};
 #define UPDATE_COUNTER(counter)           \
@@ -454,19 +443,9 @@ bool MemoryArbitrator::Stats::operator<(const Stats& other) const {
       "gtCount {} ltCount {}",
       gtCount,
       ltCount);
-  return ltCount > 0;
-}
-
-bool MemoryArbitrator::Stats::operator>(const Stats& other) const {
-  return !(*this < other) && (*this != other);
-}
-
-bool MemoryArbitrator::Stats::operator>=(const Stats& other) const {
-  return !(*this < other);
-}
-
-bool MemoryArbitrator::Stats::operator<=(const Stats& other) const {
-  return !(*this > other);
+  return ltCount > 0 ? std::strong_ordering::less
+      : gtCount > 0  ? std::strong_ordering::greater
+                     : std::strong_ordering::equal;
 }
 
 MemoryArbitrationContext::MemoryArbitrationContext(const MemoryPool* requestor)
diff --git a/velox/common/memory/MemoryArbitrator.h b/velox/common/memory/MemoryArbitrator.h
index b5419050f9a6..9cb833e7c85c 100644
--- a/velox/common/memory/MemoryArbitrator.h
+++ b/velox/common/memory/MemoryArbitrator.h
@@ -241,11 +241,7 @@ class MemoryArbitrator {
 
     Stats operator-(const Stats& other) const;
     bool operator==(const Stats& other) const;
-    bool operator!=(const Stats& other) const;
-    bool operator<(const Stats& other) const;
-    bool operator>(const Stats& other) const;
-    bool operator>=(const Stats& other) const;
-    bool operator<=(const Stats& other) const;
+    std::strong_ordering operator<=>(const Stats& other) const;
 
     bool empty() const {
       return numRequests == 0;
@@ -321,8 +317,7 @@ class MemoryReclaimer {
 
     void reset();
 
-    bool operator==(const Stats& other) const;
-    bool operator!=(const Stats& other) const;
+    bool operator==(const Stats& other) const = default;
     Stats& operator+=(const Stats& other);
   };
 
@@ -368,7 +363,7 @@ class MemoryReclaimer {
   /// rec3 -> rec6 -> rec7
   virtual int32_t priority() const {
     return priority_;
-  };
+  }
 
   /// Invoked by the memory arbitrator to get the amount of memory bytes that
   /// can be reclaimed from 'pool'. The function returns true if 'pool' is
@@ -404,7 +399,7 @@ class MemoryReclaimer {
   virtual void abort(MemoryPool* pool, const std::exception_ptr& error);
 
  protected:
-  explicit MemoryReclaimer(int32_t priority) : priority_(priority){};
+  explicit MemoryReclaimer(int32_t priority) : priority_(priority) {}
 
  private:
   const int32_t priority_;
diff --git a/velox/common/memory/MemoryPool.cpp b/velox/common/memory/MemoryPool.cpp
index f1c01835bebb..66ba6804cc8e 100644
--- a/velox/common/memory/MemoryPool.cpp
+++ b/velox/common/memory/MemoryPool.cpp
@@ -17,8 +17,8 @@
 #include "velox/common/memory/MemoryPool.h"
 
 #include <signal.h>
-#include <set>
 
+#include "velox/common/Casts.h"
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/StatsReporter.h"
 #include "velox/common/base/SuccinctPrinter.h"
@@ -39,14 +39,14 @@ using facebook::velox::common::testutil::TestValue;
 namespace facebook::velox::memory {
 namespace {
 // Check if memory operation is allowed and increment the named stats.
-#define CHECK_AND_INC_MEM_OP_STATS(stats)                             \
+#define CHECK_AND_INC_MEM_OP_STATS(pool, stats)                       \
   do {                                                                \
-    if (FOLLY_UNLIKELY(kind_ != Kind::kLeaf)) {                       \
+    if (FOLLY_UNLIKELY(pool->kind_ != Kind::kLeaf)) {                 \
       VELOX_FAIL(                                                     \
           "Memory operation is only allowed on leaf memory pool: {}", \
-          toString());                                                \
+          pool->toString());                                          \
     }                                                                 \
-    ++num##stats##_;                                                  \
+    ++pool->num##stats##_;                                            \
   } while (0)
 
 // Check if memory operation is allowed and increment the named stats.
@@ -154,9 +154,9 @@ std::string capacityToString(int64_t capacity) {
   return capacity == kMaxMemory ? "UNLIMITED" : succinctBytes(capacity);
 }
 
-#define DEBUG_RECORD_ALLOC(...)         \
-  if (FOLLY_UNLIKELY(debugEnabled())) { \
-    recordAllocDbg(__VA_ARGS__);        \
+#define DEBUG_RECORD_ALLOC(pool, ...)         \
+  if (FOLLY_UNLIKELY(pool->debugEnabled())) { \
+    pool->recordAllocDbg(__VA_ARGS__);        \
   }
 #define DEBUG_RECORD_FREE(...)          \
   if (FOLLY_UNLIKELY(debugEnabled())) { \
@@ -227,7 +227,6 @@ MemoryPool::MemoryPool(
       trackUsage_(options.trackUsage),
       threadSafe_(options.threadSafe),
       debugOptions_(options.debugOptions),
-      poolPriority_(options.poolPriority),
       coreOnAllocationFailureEnabled_(options.coreOnAllocationFailureEnabled),
       getPreferredSize_(
           options.getPreferredSize == nullptr
@@ -385,7 +384,7 @@ void MemoryPool::dropChild(const MemoryPool* child) {
       1,
       "Child memory pool {} doesn't exist in {}",
       child->name(),
-      toString());
+      name());
 }
 
 bool MemoryPool::aborted() const {
@@ -523,60 +522,63 @@ void* MemoryPoolImpl::allocate(
     }
   }
 
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   const auto alignedSize = sizeAlign(size);
   reserve(alignedSize);
   void* buffer = allocator_->allocateBytes(alignedSize, alignment_);
   if (FOLLY_UNLIKELY(buffer == nullptr)) {
     release(alignedSize);
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} from {} {}",
-        __FUNCTION__,
-        succinctBytes(size),
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(buffer, size);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} from {} {}",
+            __FUNCTION__,
+            succinctBytes(size),
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, buffer, size);
   return buffer;
 }
 
 void* MemoryPoolImpl::allocateZeroFilled(int64_t numEntries, int64_t sizeEach) {
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   const auto size = sizeEach * numEntries;
   const auto alignedSize = sizeAlign(size);
   reserve(alignedSize);
   void* buffer = allocator_->allocateZeroFilled(alignedSize);
   if (FOLLY_UNLIKELY(buffer == nullptr)) {
     release(alignedSize);
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} entries and {} each from {} {}",
-        __FUNCTION__,
-        numEntries,
-        succinctBytes(sizeEach),
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(buffer, size);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} entries and {} each from {} {}",
+            __FUNCTION__,
+            numEntries,
+            succinctBytes(sizeEach),
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, buffer, size);
   return buffer;
 }
 
 void* MemoryPoolImpl::reallocate(void* p, int64_t size, int64_t newSize) {
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   const auto alignedNewSize = sizeAlign(newSize);
   reserve(alignedNewSize);
 
   void* newP = allocator_->allocateBytes(alignedNewSize, alignment_);
   if (FOLLY_UNLIKELY(newP == nullptr)) {
     release(alignedNewSize);
-    handleAllocationFailure(fmt::format(
-        "{} failed with new {} and old {} from {} {}",
-        __FUNCTION__,
-        succinctBytes(newSize),
-        succinctBytes(size),
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(newP, newSize);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with new {} and old {} from {} {}",
+            __FUNCTION__,
+            succinctBytes(newSize),
+            succinctBytes(size),
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, newP, newSize);
   if (p != nullptr) {
     ::memcpy(newP, p, std::min(size, newSize));
     free(p, size);
@@ -585,18 +587,40 @@ void* MemoryPoolImpl::reallocate(void* p, int64_t size, int64_t newSize) {
 }
 
 void MemoryPoolImpl::free(void* p, int64_t size) {
-  CHECK_AND_INC_MEM_OP_STATS(Frees);
+  CHECK_AND_INC_MEM_OP_STATS(this, Frees);
   const auto alignedSize = sizeAlign(size);
   DEBUG_RECORD_FREE(p, size);
   allocator_->freeBytes(p, alignedSize);
   release(alignedSize);
 }
 
+bool MemoryPoolImpl::transferTo(MemoryPool* dest, void* buffer, uint64_t size) {
+  if (!isLeaf() || !dest->isLeaf()) {
+    return false;
+  }
+  VELOX_CHECK_NOT_NULL(dest);
+  auto* destImpl = checkedPointerCast<MemoryPoolImpl, MemoryPool>(dest);
+  if (allocator_ != destImpl->allocator_) {
+    return false;
+  }
+
+  CHECK_AND_INC_MEM_OP_STATS(destImpl, Allocs);
+  const auto alignedSize = sizeAlign(size);
+  destImpl->reserve(alignedSize);
+  DEBUG_RECORD_ALLOC(destImpl, buffer, size);
+
+  CHECK_AND_INC_MEM_OP_STATS(this, Frees);
+  DEBUG_RECORD_FREE(buffer, size);
+  release(alignedSize);
+
+  return true;
+}
+
 void MemoryPoolImpl::allocateNonContiguous(
     MachinePageCount numPages,
     Allocation& out,
     MachinePageCount minSizeClass) {
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   if (!out.empty()) {
     INC_MEM_OP_STATS(Frees);
   }
@@ -617,21 +641,22 @@ void MemoryPoolImpl::allocateNonContiguous(
           },
           minSizeClass)) {
     VELOX_CHECK(out.empty());
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} pages from {} {}",
-        __FUNCTION__,
-        numPages,
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(out);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} pages from {} {}",
+            __FUNCTION__,
+            numPages,
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, out);
   VELOX_CHECK(!out.empty());
   VELOX_CHECK_NULL(out.pool());
   out.setPool(this);
 }
 
 void MemoryPoolImpl::freeNonContiguous(Allocation& allocation) {
-  CHECK_AND_INC_MEM_OP_STATS(Frees);
+  CHECK_AND_INC_MEM_OP_STATS(this, Frees);
   DEBUG_RECORD_FREE(allocation);
   const int64_t freedBytes = allocator_->freeNonContiguous(allocation);
   VELOX_CHECK(allocation.empty());
@@ -650,7 +675,7 @@ void MemoryPoolImpl::allocateContiguous(
     MachinePageCount numPages,
     ContiguousAllocation& out,
     MachinePageCount maxPages) {
-  CHECK_AND_INC_MEM_OP_STATS(Allocs);
+  CHECK_AND_INC_MEM_OP_STATS(this, Allocs);
   if (!out.empty()) {
     INC_MEM_OP_STATS(Frees);
   }
@@ -669,21 +694,22 @@ void MemoryPoolImpl::allocateContiguous(
           },
           maxPages)) {
     VELOX_CHECK(out.empty());
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} pages from {} {}",
-        __FUNCTION__,
-        numPages,
-        toString(),
-        allocator_->getAndClearFailureMessage()));
-  }
-  DEBUG_RECORD_ALLOC(out);
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} pages from {} {}",
+            __FUNCTION__,
+            numPages,
+            toString(),
+            allocator_->getAndClearFailureMessage()));
+  }
+  DEBUG_RECORD_ALLOC(this, out);
   VELOX_CHECK(!out.empty());
   VELOX_CHECK_NULL(out.pool());
   out.setPool(this);
 }
 
 void MemoryPoolImpl::freeContiguous(ContiguousAllocation& allocation) {
-  CHECK_AND_INC_MEM_OP_STATS(Frees);
+  CHECK_AND_INC_MEM_OP_STATS(this, Frees);
   const int64_t bytesToFree = allocation.size();
   DEBUG_RECORD_FREE(allocation);
   allocator_->freeContiguous(allocation);
@@ -702,12 +728,13 @@ void MemoryPoolImpl::growContiguous(
               release(allocBytes);
             }
           })) {
-    handleAllocationFailure(fmt::format(
-        "{} failed with {} pages from {} {}",
-        __FUNCTION__,
-        increment,
-        toString(),
-        allocator_->getAndClearFailureMessage()));
+    handleAllocationFailure(
+        fmt::format(
+            "{} failed with {} pages from {} {}",
+            __FUNCTION__,
+            increment,
+            toString(),
+            allocator_->getAndClearFailureMessage()));
   }
   if (FOLLY_UNLIKELY(debugEnabled())) {
     recordGrowDbg(allocation.data(), allocation.size());
@@ -777,7 +804,7 @@ std::shared_ptr<MemoryPool> MemoryPoolImpl::genChild(
 }
 
 bool MemoryPoolImpl::maybeReserve(uint64_t increment) {
-  CHECK_AND_INC_MEM_OP_STATS(Reserves);
+  CHECK_AND_INC_MEM_OP_STATS(this, Reserves);
   TestValue::adjust(
       "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve", this);
   // TODO: make this a configurable memory pool option.
@@ -806,9 +833,6 @@ void MemoryPoolImpl::reserve(uint64_t size, bool reserveOnly) {
       reserveNonThreadSafe(size, reserveOnly);
     }
   }
-  if (reserveOnly) {
-    return;
-  }
 }
 
 void MemoryPoolImpl::reserveThreadSafe(uint64_t size, bool reserveOnly) {
@@ -886,9 +910,16 @@ void MemoryPoolImpl::growCapacity(MemoryPool* requestor, uint64_t size) {
   VELOX_CHECK(requestor->isLeaf());
   ++numCapacityGrowths_;
 
-  {
+  try {
     MemoryPoolArbitrationSection arbitrationSection(requestor);
     arbitrator_->growCapacity(this, size);
+  } catch (const VeloxRuntimeError& veloxError) {
+    if (FOLLY_UNLIKELY(
+            debugEnabled() &&
+            veloxError.errorCode() == error_code::kMemCapExceeded)) {
+      std::rethrow_exception(wrapExceptionDbg(veloxError));
+    }
+    throw;
   }
   // The memory pool might have been aborted during the time it leaves the
   // arbitration no matter the arbitration succeed or not.
@@ -928,7 +959,7 @@ void MemoryPoolImpl::incrementReservationLocked(uint64_t bytes) {
 }
 
 void MemoryPoolImpl::release() {
-  CHECK_AND_INC_MEM_OP_STATS(Releases);
+  CHECK_AND_INC_MEM_OP_STATS(this, Releases);
   release(0, true);
 }
 
@@ -985,6 +1016,21 @@ void MemoryPoolImpl::decrementReservation(uint64_t size) noexcept {
   sanityCheckLocked();
 }
 
+std::string MemoryPoolImpl::toString(bool detail) const {
+  std::string result;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    result = toStringLocked();
+  }
+  if (detail) {
+    result += "\n" + treeMemoryUsage();
+  }
+  if (FOLLY_UNLIKELY(debugEnabled())) {
+    result += "\n" + dumpRecordsDbg();
+  }
+  return result;
+}
+
 std::string MemoryPoolImpl::treeMemoryUsage(bool skipEmptyPool) const {
   if (parent_ != nullptr) {
     return parent_->treeMemoryUsage(skipEmptyPool);
@@ -1204,10 +1250,31 @@ void MemoryPoolImpl::recordAllocDbg(const void* addr, uint64_t size) {
   if (!needRecordDbg(true)) {
     return;
   }
-  std::lock_guard<std::mutex> l(debugAllocMutex_);
-  debugAllocRecords_.emplace(
-      reinterpret_cast<uint64_t>(addr),
-      AllocationRecord{size, process::StackTrace()});
+  AllocationRecord allocationRecord{size, process::StackTrace()};
+  std::lock_guard<std::mutex> debugAllocLock(debugAllocMutex_);
+  auto [it, inserted] = debugAllocRecords_.try_emplace(
+      reinterpret_cast<uint64_t>(addr), std::move(allocationRecord));
+  VELOX_CHECK(inserted);
+  if (debugOptions_->debugPoolWarnThresholdBytes == 0 ||
+      debugWarnThresholdExceeded_) {
+    return;
+  }
+  const auto usedBytes = reservedBytes();
+  if (usedBytes >= debugOptions_->debugPoolWarnThresholdBytes) {
+    debugWarnThresholdExceeded_ = true;
+    VELOX_MEM_LOG(WARNING) << fmt::format(
+        "[MemoryPool] Memory pool '{}' exceeded warning threshold of {} with allocation of {}, resulting in total size of {}.\n"
+        "======== Allocation Stack ========\n"
+        "{}\n"
+        "======= Current Allocations ======\n"
+        "{}",
+        name_,
+        succinctBytes(debugOptions_->debugPoolWarnThresholdBytes),
+        succinctBytes(size),
+        succinctBytes(usedBytes),
+        it->second.callStack.toString(),
+        dumpRecordsDbgLocked());
+  }
 }
 
 void MemoryPoolImpl::recordAllocDbg(const Allocation& allocation) {
@@ -1240,16 +1307,17 @@ void MemoryPoolImpl::recordFreeDbg(const void* addr, uint64_t size) {
   const auto allocRecord = allocResult->second;
   if (allocRecord.size != size) {
     const auto freeStackTrace = process::StackTrace().toString();
-    VELOX_FAIL(fmt::format(
-        "[MemoryPool] Trying to free {} bytes on an allocation of {} bytes.\n"
-        "======== Allocation Stack ========\n"
-        "{}\n"
-        "============ Free Stack ==========\n"
-        "{}\n",
-        size,
-        allocRecord.size,
-        allocRecord.callStack.toString(),
-        freeStackTrace));
+    VELOX_FAIL(
+        fmt::format(
+            "[MemoryPool] Trying to free {} bytes on an allocation of {} bytes.\n"
+            "======== Allocation Stack ========\n"
+            "{}\n"
+            "============ Free Stack ==========\n"
+            "{}\n",
+            size,
+            allocRecord.size,
+            allocRecord.callStack.toString(),
+            freeStackTrace));
   }
   debugAllocRecords_.erase(addrUint64);
 }
@@ -1289,10 +1357,79 @@ void MemoryPoolImpl::leakCheckDbg() {
   if (debugAllocRecords_.empty()) {
     return;
   }
-  std::stringbuf buf;
-  std::ostream oss(&buf);
-  oss << "[MemoryPool] : " << name_ << " - Detected total of "
-      << debugAllocRecords_.size() << " leaked allocations:\n";
+  VELOX_FAIL(
+      fmt::format(
+          "[MemoryPool] Leak check failed for '{}' pool - {}",
+          name_,
+          dumpRecordsDbg()));
+}
+
+void MemoryPoolImpl::treeAllocationRecordsDbg(
+    std::vector<MemoryPoolDump>& poolDumps) const {
+  VELOX_CHECK(debugEnabled());
+  {
+    std::lock_guard<std::mutex> debugAllocLock(debugAllocMutex_);
+    if (!debugAllocRecords_.empty()) {
+      MemoryPoolDump dump{
+          .dumpedRecords = fmt::format(
+              "Memory pool '{}' - {}", name(), dumpRecordsDbgLocked()),
+          .bytes = reservedBytes(),
+      };
+      poolDumps.emplace_back(std::move(dump));
+    }
+  }
+  if (isLeaf()) {
+    return;
+  }
+  visitChildren([&poolDumps](MemoryPool* pool) {
+    toImpl(pool)->treeAllocationRecordsDbg(poolDumps);
+    return true;
+  });
+}
+
+std::exception_ptr MemoryPoolImpl::wrapExceptionDbg(
+    const VeloxRuntimeError& veloxError) const {
+  VELOX_CHECK(debugEnabled());
+  VELOX_CHECK(isRoot());
+  std::vector<MemoryPoolDump> poolAllocationsSorted;
+  treeAllocationRecordsDbg(poolAllocationsSorted);
+  std::stringstream oss;
+  if (poolAllocationsSorted.empty()) {
+    oss << "No allocation records found.";
+  } else {
+    std::sort(
+        poolAllocationsSorted.begin(),
+        poolAllocationsSorted.end(),
+        [](const auto& a, const auto& b) { return a.bytes > b.bytes; });
+    for (const auto& record : poolAllocationsSorted) {
+      oss << record.dumpedRecords << "\n\n";
+    }
+  }
+  const auto wrappedMessage = fmt::format(
+      "{}\n\n"
+      "======= Current Allocations ======\n"
+      "{}",
+      veloxError.message(),
+      oss.str());
+  return std::make_exception_ptr(VeloxRuntimeError(
+      veloxError.file(),
+      veloxError.line(),
+      veloxError.function(),
+      veloxError.failingExpression(),
+      wrappedMessage,
+      veloxError.errorSource(),
+      veloxError.errorCode(),
+      veloxError.isRetriable(),
+      veloxError.exceptionName()));
+}
+
+std::string MemoryPoolImpl::dumpRecordsDbgLocked() const {
+  VELOX_CHECK(debugEnabled());
+  std::stringstream oss;
+  oss << fmt::format(
+      "Found {} allocations with {} total size:\n",
+      debugAllocRecords_.size(),
+      succinctBytes(reservedBytes()));
   struct AllocationStats {
     uint64_t size{0};
     uint64_t numAllocations{0};
@@ -1317,12 +1454,13 @@ void MemoryPoolImpl::leakCheckDbg() {
         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";
+    oss << fmt::format(
+        "======== {} allocations of {} total size ========\n{}\n",
+        pair.second.numAllocations,
+        succinctBytes(pair.second.size),
+        pair.first);
   }
-  VELOX_FAIL(buf.str());
+  return oss.str();
 }
 
 void MemoryPoolImpl::handleAllocationFailure(
diff --git a/velox/common/memory/MemoryPool.h b/velox/common/memory/MemoryPool.h
index cbb8a86cd23f..38b9febcccf0 100644
--- a/velox/common/memory/MemoryPool.h
+++ b/velox/common/memory/MemoryPool.h
@@ -29,7 +29,6 @@
 #include "velox/common/memory/MemoryArbitrator.h"
 
 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 {
@@ -42,6 +41,9 @@ class MemoryManager;
 
 constexpr int64_t kMaxMemory = std::numeric_limits<int64_t>::max();
 
+template <typename T>
+class StlAllocator;
+
 /// 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
@@ -91,6 +93,9 @@ constexpr int64_t kMaxMemory = std::numeric_limits<int64_t>::max();
 /// also provides memory usage accounting.
 class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
  public:
+  template <typename T>
+  using TStlAllocator = StlAllocator<T>;
+
   /// Defines the kinds of a memory pool.
   enum class Kind {
     /// The leaf memory pool is used for memory allocation. User can allocate
@@ -112,6 +117,12 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
     /// memory pools whose name matches the specified regular expression. Empty
     /// string means no match for all.
     std::string debugPoolNameRegex;
+
+    /// Warning threshold in bytes for debug memory pools. When set to a
+    /// non-zero value, a warning will be logged once per memory pool when
+    /// allocations cause the pool to exceed this threshold. A value of
+    /// 0 means no warning threshold is enforced.
+    uint64_t debugPoolWarnThresholdBytes{0};
   };
 
   struct Options {
@@ -152,11 +163,6 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
 
     /// If non-empty, enables debug mode for the created memory pool.
     std::optional<DebugOptions> debugOptions{std::nullopt};
-
-    /// Sets the priority of the memory pool. The priority is used for
-    /// determining which pools to abort when the system is out of memory.
-    /// higher poolPriority value respresents higher priority and vice-versa.
-    uint32_t poolPriority{0};
   };
 
   /// Constructs a named memory pool with specified 'name', 'parent' and 'kind'.
@@ -245,6 +251,13 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   /// Frees an allocated buffer.
   virtual void free(void* p, int64_t size) = 0;
 
+  /// Transfer the ownership of memory at 'buffer' for 'size' bytes to the
+  /// memory pool 'dest'. Returns true if the transfer succeeds.
+  virtual bool
+  transferTo(MemoryPool* /*dest*/, void* /*buffer*/, uint64_t /*size*/) {
+    return false;
+  }
+
   /// 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. The new memory is returned in 'out'
@@ -302,11 +315,6 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
     return alignment_;
   }
 
-  /// Returns the priority of this pool.
-  uint32_t poolPriority() const {
-    return poolPriority_;
-  }
-
   /// Resource governing methods used to track and limit the memory usage
   /// through this memory pool object.
 
@@ -556,7 +564,6 @@ class MemoryPool : public std::enable_shared_from_this<MemoryPool> {
   const bool trackUsage_;
   const bool threadSafe_;
   const std::optional<DebugOptions> debugOptions_;
-  const uint32_t poolPriority_;
   const bool coreOnAllocationFailureEnabled_;
   std::function<size_t(size_t)> getPreferredSize_;
 
@@ -615,6 +622,8 @@ class MemoryPoolImpl : public MemoryPool {
 
   void free(void* p, int64_t size) override;
 
+  bool transferTo(MemoryPool* dest, void* buffer, uint64_t size) override;
+
   void allocateNonContiguous(
       MachinePageCount numPages,
       Allocation& out,
@@ -678,17 +687,7 @@ class MemoryPoolImpl : public MemoryPool {
 
   void setDestructionCallback(const DestructionCallback& callback);
 
-  std::string toString(bool detail = false) const override {
-    std::string result;
-    {
-      std::lock_guard<std::mutex> l(mutex_);
-      result = toStringLocked();
-    }
-    if (detail) {
-      result += "\n" + treeMemoryUsage();
-    }
-    return result;
-  }
+  std::string toString(bool detail = false) const override;
 
   /// Detailed debug pool state printout by traversing the pool structure from
   /// the root memory pool.
@@ -1008,6 +1007,33 @@ class MemoryPoolImpl : public MemoryPool {
   // pool is enabled.
   void leakCheckDbg();
 
+  // Holds formatted string of dumped allocation records for a leaf memory pool,
+  // along with the total pool size in bytes.
+  struct MemoryPoolDump {
+    std::string dumpedRecords;
+    int64_t bytes;
+  };
+
+  // Recursively collects 'MemoryPoolDump' records for this memory pool and
+  // all its descendants in the tree. Called during memory capacity-exceeded
+  // exceptions to extend the error message with additional debug information.
+  void treeAllocationRecordsDbg(std::vector<MemoryPoolDump>& poolDumps) const;
+
+  // Wraps the message of a memory capacity exceeded exception with debug
+  // allocation records from all memory pools in the subtree. This function is
+  // called from the root memory pool.
+  std::exception_ptr wrapExceptionDbg(
+      const VeloxRuntimeError& veloxError) const;
+
+  // Dump the recorded call sites of the memory allocations in
+  // 'debugAllocRecords_' to the string.
+  std::string dumpRecordsDbgLocked() const;
+
+  std::string dumpRecordsDbg() const {
+    std::lock_guard<std::mutex> l(debugAllocMutex_);
+    return dumpRecordsDbgLocked();
+  }
+
   void handleAllocationFailure(const std::string& failureMessage);
 
   MemoryManager* const manager_;
@@ -1071,10 +1097,13 @@ class MemoryPoolImpl : public MemoryPool {
   std::atomic_uint64_t numCapacityGrowths_{0};
 
   // Mutex for 'debugAllocRecords_'.
-  std::mutex debugAllocMutex_;
+  mutable std::mutex debugAllocMutex_;
 
   // Map from address to 'AllocationRecord'.
   std::unordered_map<uint64_t, AllocationRecord> debugAllocRecords_;
+
+  // Flag to track if warning threshold has been exceeded once for this pool.
+  bool debugWarnThresholdExceeded_{false};
 };
 
 /// An Allocator backed by a memory pool for STL containers.
@@ -1086,6 +1115,8 @@ class StlAllocator {
 
   /* implicit */ StlAllocator(MemoryPool& pool) : pool{pool} {}
 
+  explicit StlAllocator(MemoryPool* pool) : pool{*pool} {}
+
   template <typename U>
   /* implicit */ StlAllocator(const StlAllocator<U>& a) : pool{a.pool} {}
 
@@ -1104,11 +1135,6 @@ class StlAllocator {
     }
     return false;
   }
-
-  template <typename T1>
-  bool operator!=(const StlAllocator<T1>& rhs) const {
-    return !(*this == rhs);
-  }
 };
 } // namespace facebook::velox::memory
 
diff --git a/velox/common/memory/MmapAllocator.cpp b/velox/common/memory/MmapAllocator.cpp
index 8ab440e21252..54f80b202829 100644
--- a/velox/common/memory/MmapAllocator.cpp
+++ b/velox/common/memory/MmapAllocator.cpp
@@ -33,9 +33,11 @@ MmapAllocator::MmapAllocator(const Options& options)
           maxMallocBytes_ == 0
               ? 0
               : options.capacity * options.smallAllocationReservePct / 100),
-      capacity_(bits::roundUp(
-          AllocationTraits::numPages(options.capacity - mallocReservedBytes_),
-          64 * sizeClassSizes_.back())) {
+      capacity_(
+          bits::roundUp(
+              AllocationTraits::numPages(
+                  options.capacity - mallocReservedBytes_),
+              64 * sizeClassSizes_.back())) {
   for (const auto& size : sizeClassSizes_) {
     sizeClasses_.push_back(std::make_unique<SizeClass>(capacity_ / size, size));
   }
@@ -293,10 +295,11 @@ bool MmapAllocator::allocateContiguousImpl(
     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",
+        " {} pages, the allocated pages is {}",
         newPages,
         numPages,
-        capacity_);
+        capacity_,
+        numAllocated_);
     VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
     setAllocatorFailureMessage(errorMsg);
     rollbackAllocation(0);
@@ -395,10 +398,11 @@ bool MmapAllocator::growContiguousWithoutRetry(
     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",
+        " {} pages, the allocated pages is {}",
         increment,
         allocation.numPages(),
-        capacity_);
+        capacity_,
+        numAllocated_);
     VELOX_MEM_LOG_EVERY_MS(WARNING, 1000) << errorMsg;
     setAllocatorFailureMessage(errorMsg);
     numAllocated_ -= increment;
diff --git a/velox/common/memory/MmapAllocator.h b/velox/common/memory/MmapAllocator.h
index fd17ee8fa765..f771db0071dc 100644
--- a/velox/common/memory/MmapAllocator.h
+++ b/velox/common/memory/MmapAllocator.h
@@ -145,7 +145,7 @@ class MmapAllocator : public MemoryAllocator {
     return numMapped_;
   }
 
-  MachinePageCount numExternalMapped() const {
+  MachinePageCount numExternalMapped() const override {
     return numExternalMapped_;
   }
 
@@ -382,14 +382,6 @@ class MmapAllocator : public MemoryAllocator {
   // Serializes moving capacity between size classes
   std::mutex sizeClassBalanceMutex_;
 
-  // Number of pages allocated and explicitly mmap'd by the
-  // application via allocateContiguous, outside of
-  // 'sizeClasses'. These pages are counted in 'numAllocated_' and
-  // 'numMapped_'. Allocation requests are decided against
-  // 'numAllocated_' and 'numMapped_'. This counter is informational
-  // only.
-  std::atomic<MachinePageCount> numExternalMapped_{0};
-
   // Allocations smaller than 'maxMallocBytes' will be delegated to
   // std::malloc().
   //
diff --git a/velox/common/memory/RawVector.h b/velox/common/memory/RawVector.h
index 437ba52120d5..a61703fe8173 100644
--- a/velox/common/memory/RawVector.h
+++ b/velox/common/memory/RawVector.h
@@ -36,10 +36,18 @@ class raw_vector {
   static_assert(
       std::is_trivially_destructible_v<T> && std::is_trivially_copyable_v<T>);
 
-  explicit raw_vector(memory::MemoryPool* pool = nullptr) : pool_(pool) {}
+  explicit raw_vector() {}
 
-  explicit raw_vector(int64_t size, memory::MemoryPool* pool = nullptr)
-      : pool_(pool) {
+  explicit raw_vector(int64_t size) {
+    resize(size);
+  }
+
+  explicit raw_vector(memory::MemoryPool* pool) : pool_(pool) {
+    VELOX_CHECK_NOT_NULL(pool);
+  }
+
+  explicit raw_vector(int64_t size, memory::MemoryPool* pool) : pool_(pool) {
+    VELOX_CHECK_NOT_NULL(pool);
     resize(size);
   }
 
@@ -204,9 +212,12 @@ class raw_vector {
     // Clear the word below the pointer so that we do not get read of
     // uninitialized when reading a partial word that extends below
     // the pointer.
+    // Suppress GCC14 warning. "error: writing 8 bytes into a region of size 0"
+    VELOX_SUPPRESS_STRINGOP_OVERFLOW_WARNING
     *reinterpret_cast<int64_t*>(
         reinterpret_cast<uint8_t*>(getDataFromBuffer(buffer)) -
         sizeof(int64_t)) = 0;
+    VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
     return getDataFromBuffer(buffer);
   }
 
diff --git a/velox/common/memory/Scratch.h b/velox/common/memory/Scratch.h
index dcde26e90d91..bed226a0f944 100644
--- a/velox/common/memory/Scratch.h
+++ b/velox/common/memory/Scratch.h
@@ -79,14 +79,17 @@ class Scratch {
     // stringop-overflow warning when 'newCapacity' is 0.
     folly::assume(capacity_ >= 0);
     if (newCapacity > capacity_) {
-      Item* newItems =
-          reinterpret_cast<Item*>(::malloc(sizeof(Item) * newCapacity));
+      auto* newItems =
+          reinterpret_cast<uint8_t*>(::malloc(sizeof(Item) * newCapacity));
       if (fill_ > 0) {
         ::memcpy(newItems, items_, fill_ * sizeof(Item));
       }
-      ::memset(newItems + fill_, 0, (newCapacity - fill_) * sizeof(Item));
+      ::memset(
+          newItems + fill_ * sizeof(Item),
+          0,
+          (newCapacity - fill_) * sizeof(Item));
       ::free(items_);
-      items_ = newItems;
+      items_ = reinterpret_cast<Item*>(newItems);
       capacity_ = newCapacity;
     }
     fill_ = std::min(fill_, newCapacity);
diff --git a/velox/common/memory/SharedArbitrator.cpp b/velox/common/memory/SharedArbitrator.cpp
index b694b7aa4a75..4d4c74540b11 100644
--- a/velox/common/memory/SharedArbitrator.cpp
+++ b/velox/common/memory/SharedArbitrator.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/memory/SharedArbitrator.h"
+#include <folly/system/HardwareConcurrency.h>
 #include <folly/system/ThreadName.h>
 #include <pthread.h>
 #include <mutex>
@@ -58,25 +59,28 @@ namespace {
   }
 
 #define MEM_POOL_CAP_EXCEEDED(errorMessage, requestPool) \
-  VELOX_MEM_POOL_CAP_EXCEEDED(fmt::format(               \
-      "Exceeded memory pool capacity. {}\n{}\n\n{}",     \
-      errorMessage,                                      \
-      this->toString(),                                  \
-      requestPool->toString(true)));
+  VELOX_MEM_POOL_CAP_EXCEEDED(                           \
+      fmt::format(                                       \
+          "Exceeded memory pool capacity. {}\n{}\n\n{}", \
+          errorMessage,                                  \
+          this->toString(),                              \
+          requestPool->toString(true)));
 
 #define LOCAL_MEM_ARBITRATION_FAILED(errorMessage, requestPool) \
-  VELOX_MEM_ARBITRATION_FAILED(fmt::format(                     \
-      "Local arbitration failure. {}\n{}\n\n{}",                \
-      errorMessage,                                             \
-      this->toString(),                                         \
-      requestPool->toString(true)));
+  VELOX_MEM_ARBITRATION_FAILED(                                 \
+      fmt::format(                                              \
+          "Local arbitration failure. {}\n{}\n\n{}",            \
+          errorMessage,                                         \
+          this->toString(),                                     \
+          requestPool->toString(true)));
 
 #define GLOBAL_MEM_ARBITRATION_FAILED(errorMessage, requestPool) \
-  VELOX_MEM_ARBITRATION_FAILED(fmt::format(                      \
-      "Global arbitration failure. {}\n{}\n\n{}",                \
-      errorMessage,                                              \
-      this->toString(),                                          \
-      requestPool->toString(true)));
+  VELOX_MEM_ARBITRATION_FAILED(                                  \
+      fmt::format(                                               \
+          "Global arbitration failure. {}\n{}\n\n{}",            \
+          errorMessage,                                          \
+          this->toString(),                                      \
+          requestPool->toString(true)));
 
 template <typename T>
 T getConfig(
@@ -126,10 +130,11 @@ uint64_t SharedArbitrator::ExtraConfig::memoryPoolReservedCapacity(
 uint64_t SharedArbitrator::ExtraConfig::maxMemoryArbitrationTimeNs(
     const std::unordered_map<std::string, std::string>& configs) {
   return std::chrono::duration_cast<std::chrono::nanoseconds>(
-             config::toDuration(getConfig<std::string>(
-                 configs,
-                 kMaxMemoryArbitrationTime,
-                 std::string(kDefaultMaxMemoryArbitrationTime))))
+             config::toDuration(
+                 getConfig<std::string>(
+                     configs,
+                     kMaxMemoryArbitrationTime,
+                     std::string(kDefaultMaxMemoryArbitrationTime))))
       .count();
 }
 
@@ -167,6 +172,16 @@ double SharedArbitrator::ExtraConfig::memoryPoolMinReclaimPct(
       configs, kMemoryPoolMinReclaimPct, kDefaultMemoryPoolMinReclaimPct);
 }
 
+uint64_t SharedArbitrator::ExtraConfig::memoryPoolSpillCapacityLimit(
+    const std::unordered_map<std::string, std::string>& configs) {
+  return config::toCapacity(
+      getConfig<std::string>(
+          configs,
+          kMemoryPoolSpillCapacityLimit,
+          std::string(kDefaultMemoryPoolSpillCapacityLimit)),
+      config::CapacityUnit::BYTE);
+}
+
 uint64_t SharedArbitrator::ExtraConfig::memoryPoolAbortCapacityLimit(
     const std::unordered_map<std::string, std::string>& configs) {
   return config::toCapacity(
@@ -253,8 +268,7 @@ SharedArbitrator::SharedArbitrator(const Config& config)
           ExtraConfig::memoryPoolMinFreeCapacity(config.extraConfigs),
           ExtraConfig::memoryPoolMinFreeCapacityPct(config.extraConfigs),
           ExtraConfig::memoryPoolMinReclaimBytes(config.extraConfigs),
-          ExtraConfig::memoryPoolMinReclaimPct(config.extraConfigs),
-          ExtraConfig::memoryPoolAbortCapacityLimit(config.extraConfigs)),
+          ExtraConfig::memoryPoolMinReclaimPct(config.extraConfigs)),
       memoryReclaimThreadsHwMultiplier_(
           ExtraConfig::memoryReclaimThreadsHwMultiplier(config.extraConfigs)),
       globalArbitrationEnabled_(
@@ -283,15 +297,16 @@ SharedArbitrator::SharedArbitrator(const Config& config)
       "memoryReclaimThreadsHwMultiplier_ needs to be positive");
 
   const uint64_t numReclaimThreads = std::max<size_t>(
-      1,
-      std::thread::hardware_concurrency() * memoryReclaimThreadsHwMultiplier_);
+      1, folly::hardware_concurrency() * memoryReclaimThreadsHwMultiplier_);
   memoryReclaimExecutor_ = std::make_unique<folly::CPUThreadPoolExecutor>(
       numReclaimThreads,
       std::make_shared<folly::NamedThreadFactory>("MemoryReclaim"));
   VELOX_MEM_LOG(INFO) << "Start memory reclaim executor with "
                       << numReclaimThreads << " threads";
 
-  setupGlobalArbitration();
+  setupGlobalArbitration(
+      ExtraConfig::memoryPoolSpillCapacityLimit(config.extraConfigs),
+      ExtraConfig::memoryPoolAbortCapacityLimit(config.extraConfigs));
 
   VELOX_MEM_LOG(INFO) << "Shared arbitrator created with "
                       << succinctBytes(capacity_) << " capacity, "
@@ -332,20 +347,37 @@ void SharedArbitrator::shutdown() {
   memoryReclaimExecutor_.reset();
   VELOX_MEM_LOG(INFO) << "Memory reclaim executor stopped";
 
-  VELOX_CHECK_EQ(
-      participants_.size(), 0, "Unexpected alive participants on destruction");
+  if (!participants_.empty()) {
+    std::vector<std::string> participantNames;
+    participantNames.reserve(participants_.size());
+    for (const auto& partitionEntry : participants_) {
+      participantNames.push_back(partitionEntry.second->name());
+    }
+    VELOX_FAIL(
+        "Unexpected alive participants on destruction: {}",
+        folly::join(",", participantNames));
+  }
 }
 
-void SharedArbitrator::setupGlobalArbitration() {
+void SharedArbitrator::setupGlobalArbitration(
+    uint64_t spillCapacityLimit,
+    uint64_t abortCapacityLimit) {
   if (!globalArbitrationEnabled_) {
     return;
   }
+  VELOX_CHECK(
+      bits::isPowerOfTwo(spillCapacityLimit),
+      "spillCapacityLimit {} not a power of two",
+      spillCapacityLimit);
+  VELOX_CHECK(
+      bits::isPowerOfTwo(abortCapacityLimit),
+      "abortCapacityLimit {} not a power of two",
+      abortCapacityLimit);
   VELOX_CHECK_NULL(globalArbitrationController_);
 
-  const uint64_t minAbortCapacity = 32 << 20;
-  for (auto abortLimit = participantConfig_.abortCapacityLimit; abortLimit >=
-       std::max<uint64_t>(minAbortCapacity,
-                          folly::nextPowTwo(participantConfig_.minCapacity));
+  const auto minAbortCapacity = std::max<uint64_t>(
+      32 << 20, folly::nextPowTwo(participantConfig_.minCapacity));
+  for (auto abortLimit = abortCapacityLimit; abortLimit >= minAbortCapacity;
        abortLimit /= 2) {
     globalArbitrationAbortCapacityLimits_.push_back(abortLimit);
   }
@@ -355,6 +387,22 @@ void SharedArbitrator::setupGlobalArbitration() {
                       << folly::join(
                              ",", globalArbitrationAbortCapacityLimits_);
 
+  VELOX_CHECK_GE(spillCapacityLimit, participantConfig_.minReclaimBytes);
+  const auto minSpillCapacity = std::max<uint64_t>(
+      folly::nextPowTwo(participantConfig_.minReclaimBytes),
+      folly::nextPowTwo(participantConfig_.minCapacity));
+  for (auto spillLimit = spillCapacityLimit; spillLimit >= minSpillCapacity;
+       spillLimit /= 2) {
+    globalArbitrationSpillCapacityLimits_.push_back(spillLimit);
+  }
+  if (globalArbitrationSpillCapacityLimits_.empty()) {
+    globalArbitrationSpillCapacityLimits_.push_back(minSpillCapacity);
+  }
+
+  VELOX_MEM_LOG(INFO) << "Global arbitration spill capacity limits: "
+                      << folly::join(
+                             ",", globalArbitrationSpillCapacityLimits_);
+
   globalArbitrationController_ = std::make_unique<std::thread>([&]() {
     folly::setThreadName("GlobalArbitrationController");
     globalArbitrationMain();
@@ -368,6 +416,7 @@ void SharedArbitrator::shutdownGlobalArbitration() {
   }
 
   VELOX_CHECK(!globalArbitrationAbortCapacityLimits_.empty());
+  VELOX_CHECK(!globalArbitrationSpillCapacityLimits_.empty());
   VELOX_CHECK_NOT_NULL(globalArbitrationController_);
 
   VELOX_MEM_LOG(INFO) << "Stopping global arbitration controller";
@@ -494,14 +543,14 @@ void SharedArbitrator::addPool(const std::shared_ptr<MemoryPool>& pool) {
 }
 
 void SharedArbitrator::removePool(MemoryPool* pool) {
-  VELOX_CHECK_EQ(pool->reservedBytes(), 0);
+  VELOX_CHECK_EQ(pool->reservedBytes(), 0, "{}", pool->name());
   const uint64_t freedBytes = shrinkPool(pool, 0);
-  VELOX_CHECK_EQ(pool->capacity(), 0);
+  VELOX_CHECK_EQ(pool->capacity(), 0, "{}", pool->name());
   freeCapacity(freedBytes);
 
   std::unique_lock guard{participantLock_};
   const auto ret = participants_.erase(pool->name());
-  VELOX_CHECK_EQ(ret, 1);
+  VELOX_CHECK_EQ(ret, 1, "{}", pool->name());
 }
 
 std::vector<ArbitrationCandidate> SharedArbitrator::getCandidates(
@@ -519,6 +568,7 @@ std::vector<ArbitrationCandidate> SharedArbitrator::getCandidates(
   return candidates;
 }
 
+// static
 void SharedArbitrator::sortCandidatesByReclaimableFreeCapacity(
     std::vector<ArbitrationCandidate>& candidates) {
   std::sort(
@@ -532,8 +582,9 @@ void SharedArbitrator::sortCandidatesByReclaimableFreeCapacity(
       &candidates);
 }
 
-void SharedArbitrator::sortCandidatesByReclaimableUsedCapacity(
-    std::vector<ArbitrationCandidate>& candidates) {
+std::vector<std::vector<ArbitrationCandidate>>
+SharedArbitrator::sortAndGroupSpillCandidates(
+    std::vector<ArbitrationCandidate>&& candidates) {
   std::sort(
       candidates.begin(),
       candidates.end(),
@@ -541,9 +592,95 @@ void SharedArbitrator::sortCandidatesByReclaimableUsedCapacity(
         return lhs.reclaimableUsedCapacity > rhs.reclaimableUsedCapacity;
       });
 
+  const auto numCandidates = candidates.size();
+  std::vector<std::vector<ArbitrationCandidate>> candidateGroups;
+  candidateGroups.reserve(globalArbitrationSpillCapacityLimits_.size());
+  uint32_t candidateIdx{0};
+  for (const auto& capacityLimit : globalArbitrationSpillCapacityLimits_) {
+    if (candidateIdx >= numCandidates) {
+      break;
+    }
+    candidateGroups.emplace_back();
+    candidateGroups.back().reserve(numCandidates - candidateIdx);
+    for (; candidateIdx < numCandidates; ++candidateIdx) {
+      if (candidates[candidateIdx].reclaimableUsedCapacity < capacityLimit) {
+        break;
+      }
+      candidateGroups.back().push_back(std::move(candidates[candidateIdx]));
+    }
+    if (candidateGroups.back().empty()) {
+      candidateGroups.pop_back();
+    }
+  }
+
+  // Sort candidates in each group by priority and reclaimable used capacity.
+  for (auto& candidateGroup : candidateGroups) {
+    std::sort(
+        candidateGroup.begin(),
+        candidateGroup.end(),
+        [](const ArbitrationCandidate& lhs, const ArbitrationCandidate& rhs) {
+          const auto* lhsReclaimer = lhs.participant->pool()->reclaimer();
+          const auto* rhsReclaimer = rhs.participant->pool()->reclaimer();
+          if (FOLLY_UNLIKELY(
+                  lhsReclaimer == nullptr || rhsReclaimer == nullptr)) {
+            VELOX_FAIL(
+                "Spill candidates must have memory reclaimer set. Left '{}', right '{}'",
+                lhs.participant->name(),
+                rhs.participant->name());
+          }
+          if (lhsReclaimer->priority() == rhsReclaimer->priority()) {
+            return lhs.reclaimableUsedCapacity > rhs.reclaimableUsedCapacity;
+          }
+          return lhsReclaimer->priority() > rhsReclaimer->priority();
+        });
+  }
+
   TestValue::adjust(
-      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableUsedCapacity",
-      &candidates);
+      "facebook::velox::memory::SharedArbitrator::sortAndGroupSpillCandidates",
+      &candidateGroups);
+  return candidateGroups;
+}
+
+// static
+std::vector<std::vector<ArbitrationCandidate>>
+SharedArbitrator::sortAndGroupAbortCandidates(
+    std::vector<ArbitrationCandidate>&& candidates) {
+  std::sort(
+      candidates.begin(),
+      candidates.end(),
+      [](const ArbitrationCandidate& lhs, const ArbitrationCandidate& rhs) {
+        const auto* lhsReclaimer = lhs.participant->pool()->reclaimer();
+        const auto* rhsReclaimer = rhs.participant->pool()->reclaimer();
+        if (lhsReclaimer == nullptr || rhsReclaimer == nullptr) {
+          // Participants without reclaimer are treated as low priority, putting
+          // them in front.
+          return (lhsReclaimer == nullptr) > (rhsReclaimer == nullptr);
+        }
+        return lhsReclaimer->priority() > rhsReclaimer->priority();
+      });
+
+  std::vector<std::vector<ArbitrationCandidate>> candidateGroups;
+  std::optional<int32_t> prevPriority;
+  for (auto i = 0; i < candidates.size(); ++i) {
+    const auto* curReclaimer = candidates[i].participant->pool()->reclaimer();
+    const auto curPriority = curReclaimer == nullptr
+        ? std::nullopt
+        : std::optional(curReclaimer->priority());
+    if (i == 0) {
+      prevPriority = curPriority;
+      candidateGroups.emplace_back(
+          std::vector<ArbitrationCandidate>{std::move(candidates[i])});
+      continue;
+    }
+    if (curPriority != prevPriority) {
+      prevPriority = curPriority;
+      candidateGroups.emplace_back(
+          std::vector<ArbitrationCandidate>{std::move(candidates[i])});
+    } else {
+      candidateGroups.back().push_back(std::move(candidates[i]));
+    }
+  }
+  return candidateGroups;
 }
 
 std::optional<ArbitrationCandidate> SharedArbitrator::findAbortCandidate(
@@ -561,47 +698,34 @@ std::optional<ArbitrationCandidate> SharedArbitrator::findAbortCandidate(
     return std::nullopt;
   }
 
-  // Returns if other candidate should be chosen for abort.
-  // With the same capacity size bucket, we favor highest priority followed
-  // by oldest participant to not to be killed. This allows long running
-  // highest priority query to proceed first.
-  auto chooseAnotherCandidateForAbort = [&](const ArbitrationCandidate& current,
-                                            const ArbitrationCandidate& other) {
-    if (current.participant->poolPriority() <
-        other.participant->poolPriority()) {
-      return false;
-    } else if (
-        current.participant->poolPriority() ==
-            other.participant->poolPriority() &&
-        current.participant->id() > other.participant->id()) {
-      return false;
-    }
-    return true;
-  };
-
-  for (uint64_t capacityLimit : globalArbitrationAbortCapacityLimits_) {
-    int32_t candidateIdx{-1};
-    for (int32_t i = 0; i < candidates.size(); ++i) {
-      if (candidates[i].participant->aborted()) {
-        continue;
-      }
-      if (candidates[i].currentCapacity < capacityLimit ||
-          candidates[i].currentCapacity == 0) {
-        continue;
-      }
-      if (candidateIdx == -1) {
-        candidateIdx = i;
-        continue;
+  auto candidateGroups = sortAndGroupAbortCandidates(std::move(candidates));
+
+  for (auto& candidateGroup : candidateGroups) {
+    for (uint64_t capacityLimit : globalArbitrationAbortCapacityLimits_) {
+      int32_t candidateIdx{-1};
+      for (int32_t i = 0; i < candidateGroup.size(); ++i) {
+        if (candidateGroup[i].participant->aborted()) {
+          continue;
+        }
+        if (candidateGroup[i].currentCapacity < capacityLimit ||
+            candidateGroup[i].currentCapacity == 0) {
+          continue;
+        }
+        if (candidateIdx == -1) {
+          candidateIdx = i;
+          continue;
+        }
+        // With the same capacity size bucket, we favor the old participant to
+        // not to be killed, to let long running query proceed first.
+        if (candidateGroup[candidateIdx].participant->id() <
+            candidateGroup[i].participant->id()) {
+          candidateIdx = i;
+        }
       }
-
-      if (chooseAnotherCandidateForAbort(
-              candidates[candidateIdx], candidates[i])) {
-        candidateIdx = i;
+      if (candidateIdx != -1) {
+        return candidateGroup[candidateIdx];
       }
     }
-    if (candidateIdx != -1) {
-      return candidates[candidateIdx];
-    }
   }
 
   if (!force) {
@@ -609,22 +733,23 @@ std::optional<ArbitrationCandidate> SharedArbitrator::findAbortCandidate(
     return std::nullopt;
   }
 
-  // Can't find an eligible abort candidate and then return the lowest priority
-  // youngest candidate which has the largest participant id.
-  int32_t candidateIdx{-1};
-  for (auto i = 0; i < candidates.size(); ++i) {
-    if (candidateIdx == -1) {
-      candidateIdx = i;
-    } else if (chooseAnotherCandidateForAbort(
-                   candidates[candidateIdx], candidates[i])) {
+  // Can't find an eligible abort candidate and then return the youngest
+  // candidate (which has the largest participant id) in the lowest priority
+  // bucket.
+  VELOX_CHECK(!candidateGroups.empty() && !candidateGroups[0].empty());
+  int32_t candidateIdx{0};
+  for (auto i = 0; i < candidateGroups[0].size(); ++i) {
+    if (candidateGroups[0][i].participant->id() >
+        candidateGroups[0][candidateIdx].participant->id()) {
       candidateIdx = i;
     }
   }
-  VELOX_CHECK_NE(candidateIdx, -1);
+
   VELOX_MEM_LOG(WARNING)
-      << "Can't find an eligible abort victim and force to abort the youngest participant "
-      << candidates[candidateIdx].participant->name();
-  return candidates[candidateIdx];
+      << "Can't find an eligible abort victim and force to abort the youngest "
+         "participant "
+      << candidateGroups[0][candidateIdx].participant->name();
+  return candidateGroups[0][candidateIdx];
 }
 
 void SharedArbitrator::updateArbitrationRequestStats() {
@@ -772,19 +897,21 @@ void SharedArbitrator::growCapacity(ArbitrationOperation& op) {
   RETURN_IF_TRUE(maybeGrowFromSelf(op));
 
   if (!ensureCapacity(op)) {
+    const auto maxCapacity = op.participant()->maxCapacity();
     MEM_POOL_CAP_EXCEEDED(
         fmt::format(
-            "Can't grow {} capacity with {}. This will exceed its max capacity "
+            "Can't grow {} capacity with {}. This will exceed its {} "
             "{}, current capacity {}.",
             op.participant()->name(),
             succinctBytes(op.requestBytes()),
-            succinctBytes(op.participant()->maxCapacity()),
+            capacity_ < maxCapacity ? "arbitrator capacity"
+                                    : "memory pool capacity",
+            succinctBytes(std::min(capacity_, maxCapacity)),
             succinctBytes(op.participant()->capacity())),
         op.participant()->pool());
   }
 
   checkIfAborted(op);
-  checkIfTimeout(op);
 
   RETURN_IF_TRUE(maybeGrowFromSelf(op));
 
@@ -804,6 +931,9 @@ void SharedArbitrator::growCapacity(ArbitrationOperation& op) {
               succinctBytes(participantConfig_.minReclaimBytes)),
           op.participant()->pool());
     }
+
+    checkIfTimeout(op);
+
     // After failing to acquire enough free capacity to fulfil this capacity
     // growth request, we will try to reclaim from the participant itself before
     // failing this operation. We only do this if global memory arbitration is
@@ -1016,10 +1146,11 @@ void SharedArbitrator::checkIfAborted(ArbitrationOperation& op) {
 
 void SharedArbitrator::checkIfTimeout(ArbitrationOperation& op) {
   if (FOLLY_UNLIKELY(op.hasTimeout())) {
-    VELOX_MEM_ARBITRATION_TIMEOUT(fmt::format(
-        "Memory arbitration timed out on memory pool: {} after running {}",
-        op.participant()->name(),
-        succinctNanos(op.executionTimeNs())));
+    VELOX_MEM_ARBITRATION_TIMEOUT(
+        fmt::format(
+            "Memory arbitration timed out on memory pool: {} after running {}",
+            op.participant()->name(),
+            succinctNanos(op.executionTimeNs())));
   }
 }
 
@@ -1137,31 +1268,34 @@ uint64_t SharedArbitrator::reclaimUsedMemoryBySpill(
 
   allParticipantsReclaimed = true;
   const uint64_t prevReclaimedBytes = reclaimedUsedBytes_;
-  auto candidates = getCandidates();
-  sortCandidatesByReclaimableUsedCapacity(candidates);
 
+  auto candidates = getCandidates();
   std::vector<ArbitrationCandidate> victims;
   victims.reserve(candidates.size());
+  auto candidateGroups = sortAndGroupSpillCandidates(std::move(candidates));
+
   uint64_t bytesToReclaim{0};
-  for (auto& candidate : candidates) {
-    if (candidate.reclaimableUsedCapacity <
-        participantConfig_.minReclaimBytes) {
-      break;
-    }
-    if (failedParticipants.count(candidate.participant->id()) != 0) {
-      VELOX_CHECK_EQ(
-          reclaimedParticipants.count(candidate.participant->id()), 1);
-      continue;
-    }
-    if (bytesToReclaim >= targetBytes) {
-      if (reclaimedParticipants.count(candidate.participant->id()) == 0) {
-        allParticipantsReclaimed = false;
+  for (auto& candidateGroup : candidateGroups) {
+    for (auto& candidate : candidateGroup) {
+      if (candidate.reclaimableUsedCapacity <
+          participantConfig_.minReclaimBytes) {
+        continue;
       }
-      continue;
+      if (failedParticipants.count(candidate.participant->id()) != 0) {
+        VELOX_CHECK_EQ(
+            reclaimedParticipants.count(candidate.participant->id()), 1);
+        continue;
+      }
+      if (bytesToReclaim >= targetBytes) {
+        if (reclaimedParticipants.count(candidate.participant->id()) == 0) {
+          allParticipantsReclaimed = false;
+        }
+        continue;
+      }
+      bytesToReclaim += candidate.reclaimableUsedCapacity;
+      reclaimedParticipants.insert(candidate.participant->id());
+      victims.push_back(std::move(candidate));
     }
-    bytesToReclaim += candidate.reclaimableUsedCapacity;
-    reclaimedParticipants.insert(candidate.participant->id());
-    victims.push_back(std::move(candidate));
   }
   if (victims.empty()) {
     FB_LOG_EVERY_MS(WARNING, 1'000)
@@ -1228,15 +1362,15 @@ uint64_t SharedArbitrator::reclaimUsedMemoryByAbort(bool force) {
   // after abort operation.
   const auto currentCapacity = victim.participant->pool()->capacity();
   try {
-    VELOX_MEM_POOL_ABORTED(fmt::format(
-        "Memory pool aborted to reclaim used memory, current capacity {}, "
-        "requesting capacity from global arbitration {} memory pool "
-        "priority:{}\nstats:\n{}\n{}",
-        succinctBytes(currentCapacity),
-        succinctBytes(victim.participant->globalArbitrationGrowCapacity()),
-        victim.participant->pool()->poolPriority(),
-        victim.participant->pool()->toString(),
-        victim.participant->pool()->treeMemoryUsage()));
+    VELOX_MEM_POOL_ABORTED(
+        fmt::format(
+            "Memory pool aborted to reclaim used memory, current capacity {}, "
+            "requesting capacity from global arbitration {} memory pool "
+            "stats:\n{}\n{}",
+            succinctBytes(currentCapacity),
+            succinctBytes(victim.participant->globalArbitrationGrowCapacity()),
+            victim.participant->pool()->toString(),
+            victim.participant->pool()->treeMemoryUsage()));
   } catch (VeloxRuntimeError&) {
     abort(victim.participant, std::current_exception());
     return currentCapacity;
@@ -1270,7 +1404,6 @@ uint64_t SharedArbitrator::reclaim(
   if (participant->aborted()) {
     removeGlobalArbitrationWaiter(participant->id());
   }
-  freeCapacity(reclaimedBytes);
 
   updateMemoryReclaimStats(
       reclaimedBytes, reclaimTimeNs, localArbitration, stats);
@@ -1282,6 +1415,8 @@ uint64_t SharedArbitrator::reclaim(
                       << " stats " << succinctBytes(stats.reclaimedBytes)
                       << " numNonReclaimableAttempts "
                       << stats.numNonReclaimableAttempts;
+
+  freeCapacity(reclaimedBytes);
   if (reclaimedBytes == 0) {
     FB_LOG_EVERY_MS(WARNING, 1'000) << fmt::format(
         "Nothing reclaimed from memory pool {} with reclaim target {},  memory pool stats:\n{}\n{}",
diff --git a/velox/common/memory/SharedArbitrator.h b/velox/common/memory/SharedArbitrator.h
index 5a0238e460dc..16efd247110c 100644
--- a/velox/common/memory/SharedArbitrator.h
+++ b/velox/common/memory/SharedArbitrator.h
@@ -135,13 +135,29 @@ class SharedArbitrator : public memory::MemoryArbitrator {
     static double memoryPoolMinReclaimPct(
         const std::unordered_map<std::string, std::string>& configs);
 
+    /// Specifies the starting memory capacity limit for global arbitration to
+    /// search for victim participant to reclaim used memory by spill. For
+    /// participants with reclaimable used capacity larger than the limit, the
+    /// global arbitration choose to spill the lowest priority participant with
+    /// highest reclaimable used capacity. The spill capacity limit is reduced
+    /// by half if couldn't find a victim participant until reaches to zero.
+    ///
+    /// NOTE: the limit must be zero or a power of 2.
+    static constexpr std::string_view kMemoryPoolSpillCapacityLimit{
+        "memory-pool-spill-capacity-limit"};
+    static constexpr std::string_view kDefaultMemoryPoolSpillCapacityLimit{
+        "4GB"};
+    static uint64_t memoryPoolSpillCapacityLimit(
+        const std::unordered_map<std::string, std::string>& configs);
+
     /// Specifies the starting memory capacity limit for global arbitration to
     /// search for victim participant to reclaim used memory by abort. For
     /// participants with capacity larger than the limit, the global arbitration
-    /// choose to abort the youngest participant which has the largest
-    /// participant id. This helps to let the old queries to run to completion.
-    /// The abort capacity limit is reduced by half if could not find a victim
-    /// participant until this reaches to zero.
+    /// choose to abort the participant that has lowest priority and shortest
+    /// execution time (largest participant id). This helps to let the low
+    /// priority queries to be aborted first, as well as old queries to run to
+    /// completion. The abort capacity limit is reduced by half if couldn't find
+    /// a victim participant until reaches to zero.
     ///
     /// NOTE: the limit must be zero or a power of 2.
     static constexpr std::string_view kMemoryPoolAbortCapacityLimit{
@@ -387,7 +403,9 @@ class SharedArbitrator : public memory::MemoryArbitrator {
   // Invoked to initialize the global arbitration on arbitrator start-up. It
   // starts the background threads to used memory from running queries
   // on-demand.
-  void setupGlobalArbitration();
+  void setupGlobalArbitration(
+      uint64_t spillCapacityLimit,
+      uint64_t abortCapacityLimit);
 
   // Invoked to stop the global arbitration threads on shut-down.
   void shutdownGlobalArbitration();
@@ -468,10 +486,6 @@ class SharedArbitrator : public memory::MemoryArbitrator {
 
   uint64_t reclaimUsedMemoryBySpill(uint64_t targetBytes);
 
-  // Sorts 'candidates' based on reclaimable used capacity in descending order.
-  static void sortCandidatesByReclaimableUsedCapacity(
-      std::vector<ArbitrationCandidate>& candidates);
-
   // Invoked to reclaim the used memory capacity to abort the participant with
   // the largest capacity to free up memory. The function returns the actually
   // reclaimed capacity in bytes.
@@ -483,6 +497,21 @@ class SharedArbitrator : public memory::MemoryArbitrator {
   // abort if there is no eligible one.
   uint64_t reclaimUsedMemoryByAbort(bool force);
 
+  // Sorts and groups 'candidates' for spilling. The sort firstly groups
+  // candidates first based on 'globalArbitrationSpillCapacityLimits_', larger
+  // bucket in the front. Then order each group based on priority and
+  // reclaimable used capacity in descending order, with lower priority (higher
+  // priority value) and higher reclaimable used capacity ones in front.
+  // Priority takes precedence over reclaimable used capacity.
+  std::vector<std::vector<ArbitrationCandidate>> sortAndGroupSpillCandidates(
+      std::vector<ArbitrationCandidate>&& candidates);
+
+  // Sorts 'candidates' based on participant's reclaimer priority in descending
+  // order, putting lower priority ones (with higher priority value) first, and
+  // high priority ones (with lower priority value) later.
+  static std::vector<std::vector<ArbitrationCandidate>>
+  sortAndGroupAbortCandidates(std::vector<ArbitrationCandidate>&& candidates);
+
   // Finds the participant victim to abort to free used memory based on the
   // participant's memory capacity and age. The function returns std::nullopt if
   // there is no eligible candidate. If 'force' is true, it picks up the
@@ -636,6 +665,13 @@ class SharedArbitrator : public memory::MemoryArbitrator {
   // If there is no such participant, it goes to the next limit and so on.
   std::vector<uint64_t> globalArbitrationAbortCapacityLimits_;
 
+  // The spill capacity limits listed in descending order. It is used by global
+  // arbitration to choose the victim to spill. It starts with the largest limit
+  // and spill the largest reclaimable used capacity participant whose
+  // reclaimable used capacity is larger than the limit. If there is no such
+  // participant, it goes to the next limit and so on.
+  std::vector<uint64_t> globalArbitrationSpillCapacityLimits_;
+
   // The global arbitration control thread which runs the global arbitration at
   // the background, and dispatch the actual memory reclaim work on different
   // participants to 'globalArbitrationExecutor_' and collects the results back.
diff --git a/velox/common/memory/StreamArena.h b/velox/common/memory/StreamArena.h
index c6bc95d011c2..b00b9dff950b 100644
--- a/velox/common/memory/StreamArena.h
+++ b/velox/common/memory/StreamArena.h
@@ -62,6 +62,10 @@ class StreamArena {
   /// serilizers.
   virtual void clear();
 
+  memory::MachinePageCount testingAllocationQuantum() const {
+    return allocationQuantum_;
+  }
+
  private:
   memory::MemoryPool* const pool_;
 
diff --git a/velox/common/memory/tests/ArbitrationParticipantTest.cpp b/velox/common/memory/tests/ArbitrationParticipantTest.cpp
index 8d7e70c9f587..b3abd4b27929 100644
--- a/velox/common/memory/tests/ArbitrationParticipantTest.cpp
+++ b/velox/common/memory/tests/ArbitrationParticipantTest.cpp
@@ -103,7 +103,6 @@ constexpr double kMemoryPoolMinFreeCapacityRatio = 0.25;
 constexpr uint64_t kFastExponentialGrowthCapacityLimit = 256 * MB;
 constexpr uint64_t kMemoryPoolMinReclaimBytes = 0;
 constexpr double kMemoryPoolMinReclaimPct = 0;
-constexpr uint64_t kMemoryPoolAbortCapacityLimit = 0;
 constexpr double kSlowCapacityGrowRatio = 0.25;
 
 class MemoryReclaimer;
@@ -234,11 +233,12 @@ class MockTask : public std::enable_shared_from_this<MockTask> {
       ReclaimInjectionCallback reclaimInjectCb,
       ArbitrationInjectionCallback arbitrationInjectCb) {
     root_->setReclaimer(RootMemoryReclaimer::create(shared_from_this()));
-    pool_->setReclaimer(std::make_unique<LeafMemoryReclaimer>(
-        shared_from_this(),
-        reclaimable,
-        std::move(reclaimInjectCb),
-        std::move(arbitrationInjectCb)));
+    pool_->setReclaimer(
+        std::make_unique<LeafMemoryReclaimer>(
+            shared_from_this(),
+            reclaimable,
+            std::move(reclaimInjectCb),
+            std::move(arbitrationInjectCb)));
   }
 
   const std::shared_ptr<MemoryPool>& pool() const {
@@ -415,8 +415,7 @@ static ArbitrationParticipant::Config arbitrationConfig(
     uint64_t minFreeCapacity = kMemoryPoolMinFreeCapacity,
     double minFreeCapacityRatio = kMemoryPoolMinFreeCapacityRatio,
     uint64_t minReclaimBytes = kMemoryPoolMinReclaimBytes,
-    double minReclaimPct = kMemoryPoolMinReclaimPct,
-    uint64_t abortCapacityLimit = kMemoryPoolAbortCapacityLimit) {
+    double minReclaimPct = kMemoryPoolMinReclaimPct) {
   return ArbitrationParticipant::Config{
       0,
       minCapacity,
@@ -425,8 +424,7 @@ static ArbitrationParticipant::Config arbitrationConfig(
       minFreeCapacity,
       minFreeCapacityRatio,
       minReclaimBytes,
-      minReclaimPct,
-      abortCapacityLimit};
+      minReclaimPct};
 }
 
 TEST_F(ArbitrationParticipantTest, config) {
@@ -439,13 +437,12 @@ TEST_F(ArbitrationParticipantTest, config) {
     double minFreeCapacityRatio;
     uint64_t minReclaimBytes;
     double minReclaimPct;
-    uint64_t abortCapacityLimit;
     bool expectedError;
     std::string expectedToString;
 
     std::string debugString() const {
       return fmt::format(
-          "initCapacity {}, minCapacity {}, fastExponentialGrowthCapacityLimit {}, slowCapacityGrowRatio {}, minFreeCapacity {}, minFreeCapacityRatio {}, minReclaimBytes {}, minReclaimPct {}, abortCapacityLimit {}, expectedError {}, expectedToString: {}",
+          "initCapacity {}, minCapacity {}, fastExponentialGrowthCapacityLimit {}, slowCapacityGrowRatio {}, minFreeCapacity {}, minFreeCapacityRatio {}, minReclaimBytes {}, minReclaimPct {}, expectedError {}, expectedToString: {}",
           succinctBytes(initCapacity),
           succinctBytes(minCapacity),
           succinctBytes(fastExponentialGrowthCapacityLimit),
@@ -454,7 +451,6 @@ TEST_F(ArbitrationParticipantTest, config) {
           minFreeCapacityRatio,
           succinctBytes(minReclaimBytes),
           minReclaimPct,
-          succinctBytes(abortCapacityLimit),
           expectedError,
           expectedToString);
     }
@@ -467,9 +463,8 @@ TEST_F(ArbitrationParticipantTest, config) {
        0.1,
        1,
        0.25,
-       2,
        false,
-       "initCapacity 1B, minCapacity 1B, fastExponentialGrowthCapacityLimit 1B, slowCapacityGrowRatio 0.1, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.25, abortCapacityLimit 2B"},
+       "initCapacity 1B, minCapacity 1B, fastExponentialGrowthCapacityLimit 1B, slowCapacityGrowRatio 0.1, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.25"},
       {0,
        1,
        0,
@@ -478,9 +473,8 @@ TEST_F(ArbitrationParticipantTest, config) {
        0.1,
        1,
        0.5,
-       0,
        false,
-       "initCapacity 0B, minCapacity 1B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.5, abortCapacityLimit 0B"},
+       "initCapacity 0B, minCapacity 1B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.5"},
       {0,
        1,
        0,
@@ -489,9 +483,8 @@ TEST_F(ArbitrationParticipantTest, config) {
        0,
        1,
        0.5,
-       0,
        false,
-       "initCapacity 0B, minCapacity 1B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 0B, minFreeCapacityRatio 0, minReclaimBytes 1B, minReclaimPct 0.5, abortCapacityLimit 0B"},
+       "initCapacity 0B, minCapacity 1B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 0B, minFreeCapacityRatio 0, minReclaimBytes 1B, minReclaimPct 0.5"},
       {1,
        1,
        0,
@@ -500,9 +493,8 @@ TEST_F(ArbitrationParticipantTest, config) {
        0.1,
        1,
        0.5,
-       0,
        false,
-       "initCapacity 1B, minCapacity 1B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.5, abortCapacityLimit 0B"},
+       "initCapacity 1B, minCapacity 1B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.5"},
       {1,
        0,
        1,
@@ -511,9 +503,8 @@ TEST_F(ArbitrationParticipantTest, config) {
        0.1,
        1,
        0.5,
-       0,
        false,
-       "initCapacity 1B, minCapacity 0B, fastExponentialGrowthCapacityLimit 1B, slowCapacityGrowRatio 0.1, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.5, abortCapacityLimit 0B"},
+       "initCapacity 1B, minCapacity 0B, fastExponentialGrowthCapacityLimit 1B, slowCapacityGrowRatio 0.1, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.5"},
       {1,
        0,
        0,
@@ -522,9 +513,8 @@ TEST_F(ArbitrationParticipantTest, config) {
        0.1,
        0,
        0.5,
-       1,
        false,
-       "initCapacity 1B, minCapacity 0B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 0B, minReclaimPct 0.5, abortCapacityLimit 1B"},
+       "initCapacity 1B, minCapacity 0B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 0B, minReclaimPct 0.5"},
       {0,
        0,
        0,
@@ -533,9 +523,8 @@ TEST_F(ArbitrationParticipantTest, config) {
        0,
        1,
        0.5,
-       0,
        false,
-       "initCapacity 0B, minCapacity 0B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 0B, minFreeCapacityRatio 0, minReclaimBytes 1B, minReclaimPct 0.5, abortCapacityLimit 0B"},
+       "initCapacity 0B, minCapacity 0B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 0B, minFreeCapacityRatio 0, minReclaimBytes 1B, minReclaimPct 0.5"},
       {0,
        0,
        0,
@@ -544,12 +533,11 @@ TEST_F(ArbitrationParticipantTest, config) {
        0.1,
        1,
        0.5,
-       0,
        false,
-       "initCapacity 0B, minCapacity 0B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.5, abortCapacityLimit 0B"},
-      {0, 1, 0, 0.1, 1, 0.1, 1, 0.5, 2, true, ""},
-      {0, 1, 1, 0.1, 0, 0.1, 1, 0.5, 2, true, ""},
-      {0, 1, 1, 0.1, 1, 0, 1, 0.5, 2, true, ""},
+       "initCapacity 0B, minCapacity 0B, fastExponentialGrowthCapacityLimit 0B, slowCapacityGrowRatio 0, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 1B, minReclaimPct 0.5"},
+      {0, 1, 0, 0.1, 1, 0.1, 1, 0.5, true, ""},
+      {0, 1, 1, 0.1, 0, 0.1, 1, 0.5, true, ""},
+      {0, 1, 1, 0.1, 1, 0, 1, 0.5, true, ""},
       {1,
        1,
        1,
@@ -558,15 +546,12 @@ TEST_F(ArbitrationParticipantTest, config) {
        0.1,
        0,
        0.5,
-       0,
        false,
-       "initCapacity 1B, minCapacity 1B, fastExponentialGrowthCapacityLimit 1B, slowCapacityGrowRatio 2, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 0B, minReclaimPct 0.5, abortCapacityLimit 0B"},
-      {0, 1, 1, -1, 1, 0.1, 1, 0.5, 0, true, ""},
-      {0, 1, 1, 0.1, 1, 2, 1, 0.5, 0, true, ""},
-      {0, 1, 1, 0.1, 1, -1, 1, 0.5, 0, true, ""},
-      {0, 0, 0, 0, 1, 0.1, 0, 0.5, 3, true, ""},
-      {0, 0, 0, 0, 1, 0.1, 1, 0.5, 3, true, ""},
-      {0, 0, 0, 0, 1, 0.1, 1, 1.5, 0, true, ""}};
+       "initCapacity 1B, minCapacity 1B, fastExponentialGrowthCapacityLimit 1B, slowCapacityGrowRatio 2, minFreeCapacity 1B, minFreeCapacityRatio 0.1, minReclaimBytes 0B, minReclaimPct 0.5"},
+      {0, 1, 1, -1, 1, 0.1, 1, 0.5, true, ""},
+      {0, 1, 1, 0.1, 1, 2, 1, 0.5, true, ""},
+      {0, 1, 1, 0.1, 1, -1, 1, 0.5, true, ""},
+      {0, 0, 0, 0, 1, 0.1, 1, 1.5, true, ""}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
@@ -580,8 +565,7 @@ TEST_F(ArbitrationParticipantTest, config) {
               testData.minFreeCapacity,
               testData.minFreeCapacityRatio,
               testData.minReclaimBytes,
-              testData.minReclaimPct,
-              testData.abortCapacityLimit),
+              testData.minReclaimPct),
           "");
       continue;
     }
@@ -593,8 +577,7 @@ TEST_F(ArbitrationParticipantTest, config) {
         testData.minFreeCapacity,
         testData.minFreeCapacityRatio,
         testData.minReclaimBytes,
-        testData.minReclaimPct,
-        testData.abortCapacityLimit);
+        testData.minReclaimPct);
     ASSERT_EQ(testData.initCapacity, config.initCapacity);
     ASSERT_EQ(testData.minCapacity, config.minCapacity);
     ASSERT_EQ(
@@ -605,7 +588,6 @@ TEST_F(ArbitrationParticipantTest, config) {
     ASSERT_EQ(testData.minFreeCapacityRatio, config.minFreeCapacityRatio);
     ASSERT_EQ(testData.minReclaimBytes, config.minReclaimBytes);
     ASSERT_EQ(testData.minReclaimPct, config.minReclaimPct);
-    ASSERT_EQ(testData.abortCapacityLimit, config.abortCapacityLimit);
     ASSERT_EQ(config.toString(), testData.expectedToString);
   }
 }
@@ -772,7 +754,7 @@ TEST_F(ArbitrationParticipantTest, getGrowTargets) {
     auto participant =
         ArbitrationParticipant::create(10, task->pool(), &config);
     auto scopedParticipant = participant->lock().value();
-    scopedParticipant->shrink(/*reclaimFromAll=*/true);
+    scopedParticipant->shrink(/*reclaimAll=*/true);
     ASSERT_EQ(scopedParticipant->capacity(), 0);
     void* buffer = task->allocate(testData.capacity);
     SCOPE_EXIT {
@@ -879,7 +861,7 @@ TEST_F(ArbitrationParticipantTest, reclaimableFreeCapacityAndShrink) {
         ASSERT_EQ(scopedParticipant->pool()->peakBytes(), testData.peakBytes);
       }
 
-      scopedParticipant->shrink(/*reclaimFromAll=*/true);
+      scopedParticipant->shrink(/*reclaimAll=*/true);
       scopedParticipant->grow(testData.capacity, 0);
       ASSERT_EQ(scopedParticipant->capacity(), testData.capacity);
 
@@ -1039,7 +1021,7 @@ TEST_F(ArbitrationParticipantTest, reclaimableUsedCapacityAndReclaim) {
       ASSERT_EQ(scopedParticipant->pool()->peakBytes(), testData.peakBytes);
     }
 
-    scopedParticipant->shrink(/*reclaimFromAll=*/true);
+    scopedParticipant->shrink(/*reclaimAll=*/true);
     scopedParticipant->grow(testData.capacity, 0);
     ASSERT_EQ(scopedParticipant->capacity(), testData.capacity);
 
@@ -1354,7 +1336,7 @@ TEST_F(ArbitrationParticipantTest, abort) {
     const std::string abortReason = "test abort";
     try {
       VELOX_FAIL(abortReason);
-    } catch (const VeloxRuntimeError& e) {
+    } catch (const VeloxRuntimeError&) {
       ASSERT_EQ(
           scopedParticipant->abort(std::current_exception()),
           testData.expectedReclaimCapacity);
@@ -1370,7 +1352,7 @@ TEST_F(ArbitrationParticipantTest, abort) {
 
     try {
       VELOX_FAIL(abortReason);
-    } catch (const VeloxRuntimeError& e) {
+    } catch (const VeloxRuntimeError&) {
       ASSERT_EQ(scopedParticipant->abort(std::current_exception()), 0);
     }
     ASSERT_EQ(scopedParticipant->stats().numShrinks, prevNumShrunks + 1);
@@ -1450,7 +1432,7 @@ DEBUG_ONLY_TEST_F(ArbitrationParticipantTest, reclaimLock) {
     const std::string abortReason = "test abort";
     try {
       VELOX_FAIL(abortReason);
-    } catch (const VeloxRuntimeError& e) {
+    } catch (const VeloxRuntimeError&) {
       ASSERT_EQ(scopedParticipant->abort(std::current_exception()), 32 * MB);
     }
     abortCompletedFlag = true;
@@ -1527,7 +1509,7 @@ DEBUG_ONLY_TEST_F(ArbitrationParticipantTest, abortedCheck) {
     const std::string abortReason = "test abort1";
     try {
       VELOX_FAIL(abortReason);
-    } catch (const VeloxRuntimeError& e) {
+    } catch (const VeloxRuntimeError&) {
       ASSERT_EQ(scopedParticipant->abort(std::current_exception()), MB);
     }
   });
@@ -1536,7 +1518,7 @@ DEBUG_ONLY_TEST_F(ArbitrationParticipantTest, abortedCheck) {
     const std::string abortReason = "test abort2";
     try {
       VELOX_FAIL(abortReason);
-    } catch (const VeloxRuntimeError& e) {
+    } catch (const VeloxRuntimeError&) {
       ASSERT_EQ(scopedParticipant->abort(std::current_exception()), 0);
     }
   });
@@ -1552,6 +1534,73 @@ DEBUG_ONLY_TEST_F(ArbitrationParticipantTest, abortedCheck) {
   VELOX_ASSERT_THROW(task->allocate(MB), "test abort1");
 }
 
+DEBUG_ONLY_TEST_F(ArbitrationParticipantTest, concurrentAbort) {
+  auto task = createTask(kMemoryCapacity);
+  const auto config = arbitrationConfig();
+  auto participant = ArbitrationParticipant::create(10, task->pool(), &config);
+  task->allocate(32 * MB);
+  auto scopedParticipant = participant->lock().value();
+
+  std::atomic_bool firstAbortStarted{false};
+  std::atomic_bool secondAbortWaitFlag{true};
+  folly::EventCount secondAbortWait;
+  std::atomic_bool firstAbortWaitFlag{true};
+  folly::EventCount firstAbortWait;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::ArbitrationParticipant::reclaim",
+      std::function<void(ArbitrationParticipant*)>(
+          ([&](ArbitrationParticipant* /*unused*/) {
+            VELOX_FAIL("reclaim abort message");
+          })));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::ArbitrationParticipant::abortLocked",
+      std::function<void(ArbitrationParticipant*)>(
+          ([&](ArbitrationParticipant* /*unused*/) {
+            if (!firstAbortStarted.exchange(true)) {
+              // First abort thread signals it started and waits for second
+              // abort to finish
+              secondAbortWaitFlag = false;
+              secondAbortWait.notifyAll();
+              firstAbortWait.await(
+                  [&]() { return !firstAbortWaitFlag.load(); });
+            }
+          })));
+
+  // First abort thread through reclaim - will wait at the test value
+  std::thread reclaimAbortThread([&]() {
+    memory::MemoryReclaimer::Stats stats;
+    scopedParticipant->reclaim(32 * MB, 1'000'000'000'000, stats);
+  });
+
+  // Wait for first abort to start
+  secondAbortWait.await([&]() { return !secondAbortWaitFlag.load(); });
+
+  // Second abort uses main thread.
+  try {
+    VELOX_FAIL("test abort 2");
+  } catch (const VeloxRuntimeError&) {
+    ASSERT_EQ(scopedParticipant->abort(std::current_exception()), 32 * MB);
+  }
+
+  // Signal first abort to continue
+  firstAbortWaitFlag = false;
+  firstAbortWait.notifyAll();
+
+  // Wait for first abort thread to complete
+  reclaimAbortThread.join();
+
+  // Verify the pool is aborted
+  ASSERT_TRUE(task->pool()->aborted());
+  ASSERT_TRUE(scopedParticipant->aborted());
+  ASSERT_EQ(scopedParticipant->capacity(), 0);
+
+  // Verify the error message is from the second abort
+  VELOX_ASSERT_THROW(
+      std::rethrow_exception(task->abortError()), "test abort 2");
+}
+
 TEST_F(ArbitrationParticipantTest, capacityCheck) {
   auto task = createTask(256 << 20);
   const auto config = arbitrationConfig(512 << 20);
@@ -1684,7 +1733,7 @@ TEST_F(ArbitrationParticipantTest, arbitrationOperation) {
     ASSERT_FALSE(abortOp.aborted());
     try {
       VELOX_FAIL("abort op");
-    } catch (const VeloxRuntimeError& e) {
+    } catch (const VeloxRuntimeError&) {
       ASSERT_EQ(scopedParticipant->abort(std::current_exception()), 0);
     }
     ASSERT_TRUE(abortOp.aborted());
@@ -1897,8 +1946,7 @@ TEST_F(ArbitrationParticipantTest, arbitrationOperationState) {
 #ifndef TSAN_BUILD
 TEST_F(ArbitrationParticipantTest, arbitrationOperationTimedLock) {
   auto participantPool = manager_->addRootPool("arbitrationOperationTimedLock");
-  auto config =
-      ArbitrationParticipant::Config(0, 1024, 0, 0, 0, 0, 128, 0, 512);
+  auto config = ArbitrationParticipant::Config(0, 1024, 0, 0, 0, 0, 128, 0);
   auto participant = ArbitrationParticipant::create(
       folly::Random::rand64(), participantPool, &config);
 
diff --git a/velox/common/memory/tests/ByteStreamTest.cpp b/velox/common/memory/tests/ByteStreamTest.cpp
index 7ef7eff64b3e..e77ffb2b5fa4 100644
--- a/velox/common/memory/tests/ByteStreamTest.cpp
+++ b/velox/common/memory/tests/ByteStreamTest.cpp
@@ -248,10 +248,11 @@ TEST_F(ByteStreamTest, newRangeAllocation) {
     byteStream.startWrite(0);
     for (int i = 0; i < testData.newRangeSizes.size(); ++i) {
       const auto newRangeSize = testData.newRangeSizes[i];
-      SCOPED_TRACE(fmt::format(
-          "iteration {} allocation size {}",
-          i,
-          succinctBytes(testData.newRangeSizes[i])));
+      SCOPED_TRACE(
+          fmt::format(
+              "iteration {} allocation size {}",
+              i,
+              succinctBytes(testData.newRangeSizes[i])));
       std::string value(newRangeSize, 'a');
       byteStream.appendStringView(value);
       ASSERT_EQ(arena->size(), testData.expectedArenaAllocationSizes[i]);
@@ -470,8 +471,9 @@ class InputByteStreamTest : public ByteStreamTest,
           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->append(
+            std::string_view(
+                reinterpret_cast<char*>(byteRange.buffer), byteRange.size));
       }
       writeFile->close();
       return std::make_unique<common::FileInputStream>(
diff --git a/velox/common/memory/tests/CMakeLists.txt b/velox/common/memory/tests/CMakeLists.txt
index dc93cc7368f9..bb07501386c8 100644
--- a/velox/common/memory/tests/CMakeLists.txt
+++ b/velox/common/memory/tests/CMakeLists.txt
@@ -30,7 +30,8 @@ add_executable(
   RawVectorTest.cpp
   ScratchTest.cpp
   SharedArbitratorTest.cpp
-  StreamArenaTest.cpp)
+  StreamArenaTest.cpp
+)
 
 target_link_libraries(
   velox_memory_test
@@ -51,7 +52,8 @@ target_link_libraries(
     GTest::gmock
     GTest::gtest
     GTest::gtest_main
-    re2::re2)
+    re2::re2
+)
 
 gtest_add_tests(velox_memory_test "" AUTO)
 
@@ -59,12 +61,11 @@ if(VELOX_ENABLE_BENCHMARKS)
   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)
+  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)
 endif()
diff --git a/velox/common/memory/tests/MemoryAllocatorTest.cpp b/velox/common/memory/tests/MemoryAllocatorTest.cpp
index 7b9f123f96a6..cc64ad8ddde1 100644
--- a/velox/common/memory/tests/MemoryAllocatorTest.cpp
+++ b/velox/common/memory/tests/MemoryAllocatorTest.cpp
@@ -258,8 +258,9 @@ class MemoryAllocatorTest : public testing::TestWithParam<int> {
     allocations.clear();
   }
 
-  void clearAllocations(std::vector<std::vector<std::unique_ptr<Allocation>>>&
-                            allocationsVector) {
+  void clearAllocations(
+      std::vector<std::vector<std::unique_ptr<Allocation>>>&
+          allocationsVector) {
     for (auto& allocations : allocationsVector) {
       for (auto& allocation : allocations) {
         instance_->freeNonContiguous(*allocation);
@@ -831,65 +832,66 @@ TEST_P(MemoryAllocatorTest, nonContiguousFailure) {
           static_cast<uint64_t>(numNewPages),
           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, 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}};
   std::unordered_map<MemoryAllocator::InjectedFailure, std::string>
       expectedErrorMsg = {
           {MemoryAllocator::InjectedFailure::kAllocate,
diff --git a/velox/common/memory/tests/MemoryArbitratorTest.cpp b/velox/common/memory/tests/MemoryArbitratorTest.cpp
index 4cf4c4920591..5fd819033feb 100644
--- a/velox/common/memory/tests/MemoryArbitratorTest.cpp
+++ b/velox/common/memory/tests/MemoryArbitratorTest.cpp
@@ -713,12 +713,16 @@ TEST_F(MemoryReclaimerTest, scopedReclaimedBytesRecorder) {
   auto childPool = root->addLeafChild("memoryReclaimRecorder", true);
   ASSERT_EQ(childPool->reservedBytes(), 0);
   int64_t reclaimedBytes{0};
-  { ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes); }
+  {
+    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); }
+  {
+    ScopedReclaimedBytesRecorder recorder(childPool.get(), &reclaimedBytes);
+  }
   ASSERT_EQ(reclaimedBytes, 0);
 
   reclaimedBytes = 0;
diff --git a/velox/common/memory/tests/MemoryCapExceededTest.cpp b/velox/common/memory/tests/MemoryCapExceededTest.cpp
index f44823aded0f..38c739f27f16 100644
--- a/velox/common/memory/tests/MemoryCapExceededTest.cpp
+++ b/velox/common/memory/tests/MemoryCapExceededTest.cpp
@@ -69,7 +69,7 @@ TEST_P(MemoryCapExceededTest, singleDriver) {
   // why).
   std::vector<std::string> expectedTexts = {
       "Can't grow ",
-      "capacity with 2.00MB. This will exceed its max capacity 5.00MB, current "
+      "capacity with 2.00MB. This will exceed its memory pool capacity 5.00MB, current "
       "capacity 5.00MB.\n"
       "ARBITRATOR[SHARED CAPACITY[6.00GB] STATS[numRequests 1 numRunning 1 "
       "numSucceded 0 numAborted 0 numFailures 0 numNonReclaimableAttempts 0 "
@@ -92,7 +92,7 @@ TEST_P(MemoryCapExceededTest, singleDriver) {
       "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.74MB reserved 4.00MB peak 4.00MB",
-      "op.2.0.0.Aggregation usage 3.74MB reserved 4.00MB peak 3.74MB",
+      "op.2.0.0.Aggregation usage 3.74MB reserved 4.00MB peak 3.76MB",
       "Top 2 leaf memory pool usages:"};
 
   std::vector<RowVectorPtr> data;
@@ -113,8 +113,9 @@ TEST_P(MemoryCapExceededTest, singleDriver) {
                   .orderBy({"c0"}, false)
                   .planNode();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
   CursorParameters params;
   params.planNode = plan;
   params.queryCtx = queryCtx;
@@ -171,8 +172,9 @@ TEST_P(MemoryCapExceededTest, multipleDrivers) {
                   .singleAggregation({"c0"}, {"sum(c1)"})
                   .planNode();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, exec::MemoryReclaimer::create()));
 
   const int32_t numDrivers = 10;
   CursorParameters params;
diff --git a/velox/common/memory/tests/MemoryManagerTest.cpp b/velox/common/memory/tests/MemoryManagerTest.cpp
index 9a3460bd6432..f1862a03673b 100644
--- a/velox/common/memory/tests/MemoryManagerTest.cpp
+++ b/velox/common/memory/tests/MemoryManagerTest.cpp
@@ -31,13 +31,14 @@ DECLARE_bool(velox_enable_memory_usage_track_in_default_memory_pool);
 using namespace ::testing;
 
 namespace facebook::velox::memory {
-
 namespace {
-constexpr folly::StringPiece kSysRootName{"__sys_root__"};
+
+constexpr std::string_view kSysRootName{"__sys_root__"};
 
 MemoryManager& toMemoryManager(MemoryManager& manager) {
   return *static_cast<MemoryManager*>(&manager);
 }
+
 } // namespace
 
 class MemoryManagerTest : public testing::Test {
@@ -57,11 +58,29 @@ TEST_F(MemoryManagerTest, ctor) {
     ASSERT_EQ(manager.capacity(), kMaxMemory);
     ASSERT_EQ(0, manager.getTotalBytes());
     ASSERT_EQ(manager.alignment(), MemoryAllocator::kMaxAlignment);
-    ASSERT_EQ(manager.testingDefaultRoot().alignment(), manager.alignment());
-    ASSERT_EQ(manager.testingDefaultRoot().capacity(), kMaxMemory);
-    ASSERT_EQ(manager.testingDefaultRoot().maxCapacity(), kMaxMemory);
+    ASSERT_EQ(manager.deprecatedSysRootPool().alignment(), manager.alignment());
+    ASSERT_EQ(manager.deprecatedSysRootPool().capacity(), kMaxMemory);
+    ASSERT_EQ(manager.deprecatedSysRootPool().maxCapacity(), kMaxMemory);
     ASSERT_EQ(manager.arbitrator()->kind(), "NOOP");
+    auto sysPool = manager.deprecatedSysRootPool().shared_from_this();
+    ASSERT_NE(sysPool->reclaimer(), nullptr);
+    try {
+      VELOX_FAIL("Trigger Error");
+    } catch (const velox::VeloxRuntimeError&) {
+      VELOX_ASSERT_THROW(
+          sysPool->reclaimer()->abort(
+              &manager.deprecatedSysRootPool(), std::current_exception()),
+          "SysMemoryReclaimer::abort is not supported");
+    }
+    ASSERT_EQ(sysPool->reclaimer()->priority(), 0);
+    memory::MemoryReclaimer::Stats stats;
+    ASSERT_EQ(
+        sysPool->reclaimer()->reclaim(sysPool.get(), 1'000, 1'000, stats), 0);
+    uint64_t reclaimableBytes{0};
+    ASSERT_FALSE(
+        sysPool->reclaimer()->reclaimableBytes(*sysPool, reclaimableBytes));
   }
+
   {
     const auto kCapacity = 8L * 1024 * 1024;
     MemoryManager::Options options;
@@ -70,7 +89,7 @@ TEST_F(MemoryManagerTest, ctor) {
     MemoryManager manager{options};
     ASSERT_EQ(kCapacity, manager.capacity());
     ASSERT_EQ(manager.numPools(), 3);
-    ASSERT_EQ(manager.testingDefaultRoot().alignment(), manager.alignment());
+    ASSERT_EQ(manager.deprecatedSysRootPool().alignment(), manager.alignment());
   }
   {
     const auto kCapacity = 8L * 1024 * 1024;
@@ -81,10 +100,10 @@ TEST_F(MemoryManagerTest, ctor) {
     MemoryManager manager{options};
 
     ASSERT_EQ(manager.alignment(), MemoryAllocator::kMinAlignment);
-    ASSERT_EQ(manager.testingDefaultRoot().alignment(), manager.alignment());
+    ASSERT_EQ(manager.deprecatedSysRootPool().alignment(), manager.alignment());
     // TODO: replace with root pool memory tracker quota check.
     ASSERT_EQ(
-        kSharedPoolCount + 3, manager.testingDefaultRoot().getChildCount());
+        kSharedPoolCount + 3, manager.deprecatedSysRootPool().getChildCount());
     ASSERT_EQ(kCapacity, manager.capacity());
     ASSERT_EQ(0, manager.getTotalBytes());
   }
@@ -203,14 +222,18 @@ TEST_F(MemoryManagerTest, addPool) {
   auto rootPool = manager.addRootPool("duplicateRootPool", kMaxMemory);
   ASSERT_EQ(rootPool->capacity(), kMaxMemory);
   ASSERT_EQ(rootPool->maxCapacity(), kMaxMemory);
-  { ASSERT_ANY_THROW(manager.addRootPool("duplicateRootPool", kMaxMemory)); }
+  {
+    ASSERT_ANY_THROW(manager.addRootPool("duplicateRootPool", kMaxMemory));
+  }
   auto threadSafeLeafPool = manager.addLeafPool("leafPool", true);
   ASSERT_EQ(threadSafeLeafPool->capacity(), kMaxMemory);
   ASSERT_EQ(threadSafeLeafPool->maxCapacity(), kMaxMemory);
   auto nonThreadSafeLeafPool = manager.addLeafPool("duplicateLeafPool", true);
   ASSERT_EQ(nonThreadSafeLeafPool->capacity(), kMaxMemory);
   ASSERT_EQ(nonThreadSafeLeafPool->maxCapacity(), kMaxMemory);
-  { ASSERT_ANY_THROW(manager.addLeafPool("duplicateLeafPool")); }
+  {
+    ASSERT_ANY_THROW(manager.addLeafPool("duplicateLeafPool"));
+  }
   const int64_t poolCapacity = 1 << 20;
   auto rootPoolWithMaxCapacity =
       manager.addRootPool("rootPoolWithCapacity", poolCapacity);
@@ -255,7 +278,9 @@ TEST_F(MemoryManagerTest, addPoolWithArbitrator) {
   auto nonThreadSafeLeafPool = manager.addLeafPool("duplicateLeafPool", true);
   ASSERT_EQ(nonThreadSafeLeafPool->capacity(), kMaxMemory);
   ASSERT_EQ(nonThreadSafeLeafPool->maxCapacity(), kMaxMemory);
-  { ASSERT_ANY_THROW(manager.addLeafPool("duplicateLeafPool")); }
+  {
+    ASSERT_ANY_THROW(manager.addLeafPool("duplicateLeafPool"));
+  }
   const int64_t poolCapacity = 1 << 30;
   auto rootPoolWithMaxCapacity = manager.addRootPool(
       "rootPoolWithCapacity", poolCapacity, MemoryReclaimer::create());
@@ -275,18 +300,18 @@ TEST_F(MemoryManagerTest, defaultMemoryManager) {
   auto& managerB = toMemoryManager(deprecatedDefaultMemoryManager());
   const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 3;
   ASSERT_EQ(managerA.numPools(), 3);
-  ASSERT_EQ(managerA.testingDefaultRoot().getChildCount(), kSharedPoolCount);
+  ASSERT_EQ(managerA.deprecatedSysRootPool().getChildCount(), kSharedPoolCount);
   ASSERT_EQ(managerB.numPools(), 3);
-  ASSERT_EQ(managerB.testingDefaultRoot().getChildCount(), kSharedPoolCount);
+  ASSERT_EQ(managerB.deprecatedSysRootPool().getChildCount(), kSharedPoolCount);
 
   auto child1 = managerA.addLeafPool("child_1");
-  ASSERT_EQ(child1->parent()->name(), managerA.testingDefaultRoot().name());
+  ASSERT_EQ(child1->parent()->name(), managerA.deprecatedSysRootPool().name());
   auto child2 = managerB.addLeafPool("child_2");
-  ASSERT_EQ(child2->parent()->name(), managerA.testingDefaultRoot().name());
+  ASSERT_EQ(child2->parent()->name(), managerA.deprecatedSysRootPool().name());
   EXPECT_EQ(
-      kSharedPoolCount + 2, managerA.testingDefaultRoot().getChildCount());
+      kSharedPoolCount + 2, managerA.deprecatedSysRootPool().getChildCount());
   EXPECT_EQ(
-      kSharedPoolCount + 2, managerB.testingDefaultRoot().getChildCount());
+      kSharedPoolCount + 2, managerB.deprecatedSysRootPool().getChildCount());
   ASSERT_EQ(managerA.numPools(), 5);
   ASSERT_EQ(managerB.numPools(), 5);
   auto pool = managerB.addRootPool();
@@ -300,9 +325,9 @@ TEST_F(MemoryManagerTest, defaultMemoryManager) {
       "Memory Manager[capacity UNLIMITED alignment 64B usedBytes 0B number of pools 6\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());
+      kSharedPoolCount + 1, managerA.deprecatedSysRootPool().getChildCount());
   child2.reset();
-  EXPECT_EQ(kSharedPoolCount, managerB.testingDefaultRoot().getChildCount());
+  EXPECT_EQ(kSharedPoolCount, managerB.deprecatedSysRootPool().getChildCount());
   ASSERT_EQ(managerA.numPools(), 4);
   ASSERT_EQ(managerB.numPools(), 4);
   pool.reset();
@@ -328,8 +353,9 @@ TEST_F(MemoryManagerTest, defaultMemoryManager) {
   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)));
+        testing::HasSubstr(
+            fmt::format(
+                "__sys_shared_leaf__{} usage 0B reserved 0B peak 0B\n", i)));
   }
 }
 
@@ -337,32 +363,35 @@ TEST_F(MemoryManagerTest, defaultMemoryManager) {
 TEST(MemoryHeaderTest, addDefaultLeafMemoryPool) {
   auto& manager = toMemoryManager(deprecatedDefaultMemoryManager());
   const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 3;
-  ASSERT_EQ(manager.testingDefaultRoot().getChildCount(), kSharedPoolCount);
+  ASSERT_EQ(manager.deprecatedSysRootPool().getChildCount(), kSharedPoolCount);
   {
     auto poolA = deprecatedAddDefaultLeafMemoryPool();
     ASSERT_EQ(poolA->kind(), MemoryPool::Kind::kLeaf);
     auto poolB = deprecatedAddDefaultLeafMemoryPool();
     ASSERT_EQ(poolB->kind(), MemoryPool::Kind::kLeaf);
     EXPECT_EQ(
-        kSharedPoolCount + 2, manager.testingDefaultRoot().getChildCount());
+        kSharedPoolCount + 2, manager.deprecatedSysRootPool().getChildCount());
     {
       auto poolC = deprecatedAddDefaultLeafMemoryPool();
       ASSERT_EQ(poolC->kind(), MemoryPool::Kind::kLeaf);
       EXPECT_EQ(
-          kSharedPoolCount + 3, manager.testingDefaultRoot().getChildCount());
+          kSharedPoolCount + 3,
+          manager.deprecatedSysRootPool().getChildCount());
       {
         auto poolD = deprecatedAddDefaultLeafMemoryPool();
         ASSERT_EQ(poolD->kind(), MemoryPool::Kind::kLeaf);
         EXPECT_EQ(
-            kSharedPoolCount + 4, manager.testingDefaultRoot().getChildCount());
+            kSharedPoolCount + 4,
+            manager.deprecatedSysRootPool().getChildCount());
       }
       EXPECT_EQ(
-          kSharedPoolCount + 3, manager.testingDefaultRoot().getChildCount());
+          kSharedPoolCount + 3,
+          manager.deprecatedSysRootPool().getChildCount());
     }
     EXPECT_EQ(
-        kSharedPoolCount + 2, manager.testingDefaultRoot().getChildCount());
+        kSharedPoolCount + 2, manager.deprecatedSysRootPool().getChildCount());
   }
-  EXPECT_EQ(kSharedPoolCount, manager.testingDefaultRoot().getChildCount());
+  EXPECT_EQ(kSharedPoolCount, manager.deprecatedSysRootPool().getChildCount());
 
   auto namedPool = deprecatedAddDefaultLeafMemoryPool("namedPool");
   ASSERT_EQ(namedPool->name(), "namedPool");
@@ -402,7 +431,7 @@ TEST_F(MemoryManagerTest, memoryPoolManagement) {
     if (i % 2) {
       ASSERT_EQ(pool->kind(), MemoryPool::Kind::kLeaf);
       userLeafPools.push_back(pool);
-      ASSERT_EQ(pool->parent()->name(), manager.testingDefaultRoot().name());
+      ASSERT_EQ(pool->parent()->name(), manager.deprecatedSysRootPool().name());
     } else {
       ASSERT_EQ(pool->kind(), MemoryPool::Kind::kAggregate);
       ASSERT_EQ(pool->parent(), nullptr);
@@ -442,12 +471,12 @@ TEST_F(MemoryManagerTest, globalMemoryManager) {
   auto* managerII = memoryManager();
   const auto kSharedPoolCount = FLAGS_velox_memory_num_shared_leaf_pools + 3;
   {
-    auto& rootI = manager->testingDefaultRoot();
+    auto& rootI = manager->deprecatedSysRootPool();
     const std::string childIName("some_child");
     auto childI = rootI.addLeafChild(childIName);
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 1);
 
-    auto& rootII = managerII->testingDefaultRoot();
+    auto& rootII = managerII->deprecatedSysRootPool();
     ASSERT_EQ(kSharedPoolCount + 1, rootII.getChildCount());
     std::vector<MemoryPool*> pools{};
     rootII.visitChildren([&pools](MemoryPool* child) {
@@ -466,7 +495,7 @@ TEST_F(MemoryManagerTest, globalMemoryManager) {
     auto childII = manager->addLeafPool("another_child");
     ASSERT_EQ(childII->kind(), MemoryPool::Kind::kLeaf);
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 2);
-    ASSERT_EQ(childII->parent()->name(), kSysRootName.str());
+    ASSERT_EQ(childII->parent()->name(), kSysRootName);
     childII.reset();
     ASSERT_EQ(rootI.getChildCount(), kSharedPoolCount + 1);
     ASSERT_EQ(rootII.getChildCount(), kSharedPoolCount + 1);
@@ -511,7 +540,7 @@ TEST_F(MemoryManagerTest, alignmentOptionCheck) {
         manager.alignment(),
         std::max(testData.alignment, MemoryAllocator::kMinAlignment));
     ASSERT_EQ(
-        manager.testingDefaultRoot().alignment(),
+        manager.deprecatedSysRootPool().alignment(),
         std::max(testData.alignment, MemoryAllocator::kMinAlignment));
     auto leafPool = manager.addLeafPool("leafPool");
     ASSERT_EQ(
diff --git a/velox/common/memory/tests/MemoryPoolBenchmark.cpp b/velox/common/memory/tests/MemoryPoolBenchmark.cpp
index 82296fb7e74f..077a3873e9a5 100644
--- a/velox/common/memory/tests/MemoryPoolBenchmark.cpp
+++ b/velox/common/memory/tests/MemoryPoolBenchmark.cpp
@@ -35,7 +35,7 @@ class BenchmarkHelper {
 
   std::vector<MemoryPool*> findLeaves() {
     std::vector<MemoryPool*> leaves;
-    findLeavesOf(manager_.testingDefaultRoot(), leaves);
+    findLeavesOf(manager_.deprecatedSysRootPool(), leaves);
     return leaves;
   }
 
@@ -158,7 +158,7 @@ void addNLeaves(MemoryPool& pool, size_t n) {
 BENCHMARK(FlatTree, iters) {
   folly::BenchmarkSuspender suspender;
   MemoryManager manager{};
-  addNLeaves(manager.testingDefaultRoot(), 10 * 20);
+  addNLeaves(manager.deprecatedSysRootPool(), 10 * 20);
   BenchmarkHelper helper{manager};
   suspender.dismiss();
   helper.runForEachPool([iters](MemoryPool& pool) {
diff --git a/velox/common/memory/tests/MemoryPoolTest.cpp b/velox/common/memory/tests/MemoryPoolTest.cpp
index d0b6a8bbd9cf..42f8c6f2d900 100644
--- a/velox/common/memory/tests/MemoryPoolTest.cpp
+++ b/velox/common/memory/tests/MemoryPoolTest.cpp
@@ -31,7 +31,6 @@
 #include "velox/common/testutil/TestValue.h"
 
 DECLARE_bool(velox_memory_leak_check_enabled);
-DECLARE_bool(velox_memory_pool_debug_enabled);
 DECLARE_int32(velox_memory_num_shared_leaf_pools);
 
 using namespace ::testing;
@@ -61,15 +60,16 @@ struct TestParam {
 class MemoryPoolTest : public testing::TestWithParam<TestParam> {
  public:
   static const std::vector<TestParam> getTestParams() {
-    std::vector<TestParam> params;
-    params.push_back({true, true, false});
-    params.push_back({true, false, false});
-    params.push_back({false, true, false});
-    params.push_back({false, false, false});
-    params.push_back({true, true, true});
-    params.push_back({true, false, true});
-    params.push_back({false, true, true});
-    params.push_back({false, false, true});
+    std::vector<TestParam> params = {
+        {true, true, false},
+        {true, false, false},
+        {false, true, false},
+        {false, false, false},
+        {true, true, true},
+        {true, false, true},
+        {false, true, true},
+        {false, false, true},
+    };
     return params;
   }
 
@@ -165,13 +165,14 @@ TEST_P(MemoryPoolTest, ctor) {
     auto fakeRoot = std::make_shared<MemoryPoolImpl>(
         &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,
-        "fake_root",
-        MemoryPool::Kind::kAggregate,
-        nullptr,
-        nullptr,
-        MemoryPool::Options{.threadSafe = false}));
+    ASSERT_ANY_THROW(
+        std::make_shared<MemoryPoolImpl>(
+            &manager,
+            "fake_root",
+            MemoryPool::Kind::kAggregate,
+            nullptr,
+            nullptr,
+            MemoryPool::Options{.threadSafe = false}));
     ASSERT_EQ("fake_root", fakeRoot->name());
     ASSERT_EQ(
         static_cast<MemoryPoolImpl*>(root.get())->testingAllocator(),
@@ -784,7 +785,7 @@ TEST_P(MemoryPoolTest, memoryCapExceptions) {
                     "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",
+                    " allocator capacity is 32768 pages, the allocated pages is 32769",
                     isLeafThreadSafe_ ? "thread-safe" : "non-thread-safe"),
                 ex.message());
           }
@@ -945,7 +946,7 @@ TEST_P(MemoryPoolTest, childUsageTest) {
 
 TEST_P(MemoryPoolTest, getPreferredSize) {
   MemoryManager& manager = *getMemoryManager();
-  auto& pool = dynamic_cast<MemoryPoolImpl&>(manager.testingDefaultRoot());
+  auto& pool = dynamic_cast<MemoryPoolImpl&>(manager.deprecatedSysRootPool());
 
   // size < 8
   EXPECT_EQ(8, pool.preferredSize(1));
@@ -1047,7 +1048,7 @@ TEST_P(MemoryPoolTest, customizedGetPreferredSize) {
 
 TEST_P(MemoryPoolTest, getPreferredSizeOverflow) {
   MemoryManager& manager = *getMemoryManager();
-  auto& pool = dynamic_cast<MemoryPoolImpl&>(manager.testingDefaultRoot());
+  auto& pool = dynamic_cast<MemoryPoolImpl&>(manager.deprecatedSysRootPool());
 
   EXPECT_EQ(1ULL << 32, pool.preferredSize((1ULL << 32) - 1));
   EXPECT_EQ(1ULL << 63, pool.preferredSize((1ULL << 62) - 1 + (1ULL << 62)));
@@ -1055,7 +1056,7 @@ TEST_P(MemoryPoolTest, getPreferredSizeOverflow) {
 
 TEST_P(MemoryPoolTest, allocatorOverflow) {
   MemoryManager& manager = *getMemoryManager();
-  auto& pool = dynamic_cast<MemoryPoolImpl&>(manager.testingDefaultRoot());
+  auto& pool = dynamic_cast<MemoryPoolImpl&>(manager.deprecatedSysRootPool());
   StlAllocator<int64_t> alloc(pool);
   EXPECT_THROW(alloc.allocate(1ULL << 62), VeloxException);
   EXPECT_THROW(alloc.deallocate(nullptr, 1ULL << 62), VeloxException);
@@ -1402,71 +1403,73 @@ TEST_P(MemoryPoolTest, persistentNonContiguousAllocateFailure) {
           static_cast<uint64_t>(numNewPages),
           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, 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}};
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{}, useMmap:{}, useCache:{}",
-        testData.debugString(),
-        useMmap_,
-        useCache_));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, useMmap:{}, useCache:{}",
+            testData.debugString(),
+            useMmap_,
+            useCache_));
     if ((testData.injectedFailure !=
          MemoryAllocator::InjectedFailure::kAllocate) &&
         !useMmap_) {
@@ -1584,11 +1587,12 @@ TEST_P(MemoryPoolTest, transientNonContiguousAllocateFailure) {
        MemoryAllocator::InjectedFailure::kMadvise},
       {200, 100, 100, MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{}, useMmap:{}, useCache:{}",
-        testData.debugString(),
-        useMmap_,
-        useCache_));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, useMmap:{}, useCache:{}",
+            testData.debugString(),
+            useMmap_,
+            useCache_));
     if ((testData.injectedFailure !=
          MemoryAllocator::InjectedFailure::kAllocate) &&
         !useMmap_) {
@@ -1672,81 +1676,82 @@ TEST_P(MemoryPoolTest, persistentContiguousAllocateFailure) {
           numNewPages,
           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},
-                      // Mmap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      // Madvise failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {100, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise}};
+  } 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},
+      // Mmap failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {200, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      // Madvise failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {100, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {200, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     if (!useMmap_) {
@@ -1790,87 +1795,89 @@ TEST_P(MemoryPoolTest, transientContiguousAllocateFailure) {
           numNewPages,
           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},
-                      // Mmap failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kCap},
-                      {100, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMmap},
-                      // Madvise failure injection.
-                      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {0,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {100, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun / 2,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {200, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun - 1,
-                       MemoryAllocator::InjectedFailure::kMadvise},
-                      {Allocation::PageRun::kMaxPagesInRun,
-                       Allocation::PageRun::kMaxPagesInRun / 2,
-                       MemoryAllocator::InjectedFailure::kMadvise}};
+  } 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},
+      // Mmap failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kCap},
+      {100, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {200, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kMmap},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMmap},
+      // Madvise failure injection.
+      {0, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {0,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {100, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun / 2,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {200, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun / 2 + 100,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun - 1,
+       MemoryAllocator::InjectedFailure::kMadvise},
+      {Allocation::PageRun::kMaxPagesInRun,
+       Allocation::PageRun::kMaxPagesInRun / 2,
+       MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{}, useCache:{} , useMmap:{}",
-        testData.debugString(),
-        useCache_,
-        useMmap_));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, useCache:{} , useMmap:{}",
+            testData.debugString(),
+            useCache_,
+            useMmap_));
     if (!useMmap_) {
       // No failure injections supported for contiguous allocation of
       // MallocAllocator.
@@ -1944,33 +1951,34 @@ TEST_P(MemoryPoolTest, persistentContiguousGrowAllocateFailure) {
           injectedFailure,
           expectedErrorMessage);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {10,
-                       100,
-                       MemoryAllocator::InjectedFailure::kCap,
-                       "growContiguous failed with 100 pages from Memory Pool"},
-                      {100,
-                       10,
-                       MemoryAllocator::InjectedFailure::kCap,
-                       "growContiguous failed with 10 pages from Memory Pool"},
-                      // Mmap failure injection.
-                      {10,
-                       100,
-                       MemoryAllocator::InjectedFailure::kMmap,
-                       "growContiguous failed with 100 pages from Memory Pool"},
-                      {100,
-                       10,
-                       MemoryAllocator::InjectedFailure::kMmap,
-                       "growContiguous failed with 10 pages from Memory Pool"},
-                      // Madvise failure injection.
-                      {10,
-                       100,
-                       MemoryAllocator::InjectedFailure::kMadvise,
-                       "growContiguous failed with 100 pages from Memory Pool"},
-                      {100,
-                       10,
-                       MemoryAllocator::InjectedFailure::kMadvise,
-                       "growContiguous failed with 10 pages from Memory Pool"}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {10,
+       100,
+       MemoryAllocator::InjectedFailure::kCap,
+       "growContiguous failed with 100 pages from Memory Pool"},
+      {100,
+       10,
+       MemoryAllocator::InjectedFailure::kCap,
+       "growContiguous failed with 10 pages from Memory Pool"},
+      // Mmap failure injection.
+      {10,
+       100,
+       MemoryAllocator::InjectedFailure::kMmap,
+       "growContiguous failed with 100 pages from Memory Pool"},
+      {100,
+       10,
+       MemoryAllocator::InjectedFailure::kMmap,
+       "growContiguous failed with 10 pages from Memory Pool"},
+      // Madvise failure injection.
+      {10,
+       100,
+       MemoryAllocator::InjectedFailure::kMadvise,
+       "growContiguous failed with 100 pages from Memory Pool"},
+      {100,
+       10,
+       MemoryAllocator::InjectedFailure::kMadvise,
+       "growContiguous failed with 10 pages from Memory Pool"}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     if (!useMmap_) {
@@ -2014,21 +2022,23 @@ TEST_P(MemoryPoolTest, transientContiguousGrowAllocateFailure) {
           numGrowPages,
           injectedFailure);
     }
-  } testSettings[] = {// Cap failure injection.
-                      {10, 100, MemoryAllocator::InjectedFailure::kCap},
-                      {100, 10, MemoryAllocator::InjectedFailure::kCap},
-                      // Mmap failure injection.
-                      {10, 100, MemoryAllocator::InjectedFailure::kMmap},
-                      {100, 10, MemoryAllocator::InjectedFailure::kMmap},
-                      // Madvise failure injection.
-                      {10, 100, MemoryAllocator::InjectedFailure::kMadvise},
-                      {100, 10, MemoryAllocator::InjectedFailure::kMadvise}};
+  } testSettings[] = {
+      // Cap failure injection.
+      {10, 100, MemoryAllocator::InjectedFailure::kCap},
+      {100, 10, MemoryAllocator::InjectedFailure::kCap},
+      // Mmap failure injection.
+      {10, 100, MemoryAllocator::InjectedFailure::kMmap},
+      {100, 10, MemoryAllocator::InjectedFailure::kMmap},
+      // Madvise failure injection.
+      {10, 100, MemoryAllocator::InjectedFailure::kMadvise},
+      {100, 10, MemoryAllocator::InjectedFailure::kMadvise}};
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{}, useCache:{} , useMmap:{}",
-        testData.debugString(),
-        useCache_,
-        useMmap_));
+    SCOPED_TRACE(
+        fmt::format(
+            "{}, useCache:{} , useMmap:{}",
+            testData.debugString(),
+            useCache_,
+            useMmap_));
     if (!useMmap_) {
       // No failure injections supported for contiguous allocation of
       // MallocAllocator.
@@ -2520,7 +2530,6 @@ TEST_P(MemoryPoolTest, concurrentUpdateToDifferentPools) {
 }
 
 TEST_P(MemoryPoolTest, concurrentUpdatesToTheSamePool) {
-  FLAGS_velox_memory_pool_debug_enabled = true;
   if (!isLeafThreadSafe_) {
     return;
   }
@@ -2706,7 +2715,6 @@ TEST(MemoryPoolTest, visitChildren) {
 }
 
 TEST(MemoryPoolTest, debugMode) {
-  FLAGS_velox_memory_pool_debug_enabled = true;
   constexpr int64_t kMaxMemory = 10 * GB;
   constexpr int64_t kNumIterations = 100;
   const std::vector<int64_t> kAllocSizes = {128, 8 * KB, 2 * MB};
@@ -2726,12 +2734,23 @@ TEST(MemoryPoolTest, debugMode) {
                   ->addLeafChild("child");
   const auto& allocRecords = std::dynamic_pointer_cast<MemoryPoolImpl>(pool)
                                  ->testingDebugAllocRecords();
+
   std::vector<void*> smallAllocs;
+  smallAllocs.reserve(kNumIterations);
   for (int32_t i = 0; i < kNumIterations; i++) {
     smallAllocs.push_back(pool->allocate(kAllocSizes[0]));
   }
   EXPECT_EQ(allocRecords.size(), kNumIterations);
   checkAllocs(allocRecords, kAllocSizes[0]);
+
+  // Check toString() works with debug mode enabled
+  const auto poolString = pool->toString();
+  EXPECT_FALSE(poolString.empty());
+  EXPECT_TRUE(
+      poolString.find(
+          "======== 100 allocations of 12.50KB total size ========") !=
+      std::string::npos);
+
   for (int32_t i = 0; i < kNumIterations; i++) {
     pool->free(smallAllocs[i], kAllocSizes[0]);
   }
@@ -2779,14 +2798,16 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
         "root0",
         kMaxMemory,
         nullptr,
-        debugEnabled ? std::optional(MemoryPool::DebugOptions{
-                           .debugPoolNameRegex = "NO-MATCH"})
-                     : std::nullopt);
+        debugEnabled
+            ? std::optional(
+                  MemoryPool::DebugOptions{.debugPoolNameRegex = "NO-MATCH"})
+            : std::nullopt);
     auto pool0_0 = root0->addLeafChild("PartialAggregation.0.0");
     auto* buffer0 = pool0_0->allocate(1 * KB);
-    EXPECT_TRUE(std::dynamic_pointer_cast<MemoryPoolImpl>(pool0_0)
-                    ->testingDebugAllocRecords()
-                    .empty());
+    EXPECT_TRUE(
+        std::dynamic_pointer_cast<MemoryPoolImpl>(pool0_0)
+            ->testingDebugAllocRecords()
+            .empty());
     pool0_0->free(buffer0, 1 * KB);
 
     // leaf child created from MemoryPool, match filter
@@ -2794,8 +2815,9 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
         "root1",
         kMaxMemory,
         nullptr,
-        debugEnabled ? std::optional(MemoryPool::DebugOptions{
-                           .debugPoolNameRegex = ".*PartialAggregation.*"})
+        debugEnabled ? std::optional(
+                           MemoryPool::DebugOptions{
+                               .debugPoolNameRegex = ".*PartialAggregation.*"})
                      : std::nullopt);
     auto pool1_0 = root1->addLeafChild("PartialAggregation.0.1");
     auto* buffer1 = pool1_0->allocate(1 * KB);
@@ -2816,9 +2838,10 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
 
     // old pool from root0 should not be affected by root1
     buffer0 = pool0_0->allocate(1 * KB);
-    EXPECT_TRUE(std::dynamic_pointer_cast<MemoryPoolImpl>(pool0_0)
-                    ->testingDebugAllocRecords()
-                    .empty());
+    EXPECT_TRUE(
+        std::dynamic_pointer_cast<MemoryPoolImpl>(pool0_0)
+            ->testingDebugAllocRecords()
+            .empty());
     pool0_0->free(buffer0, 1 * KB);
 
     // leaf child created from MemoryPool, match filter
@@ -2826,9 +2849,10 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
         "root2",
         kMaxMemory,
         nullptr,
-        debugEnabled ? std::optional(MemoryPool::DebugOptions{
-                           .debugPoolNameRegex = ".*OrderBy.*"})
-                     : std::nullopt);
+        debugEnabled
+            ? std::optional(
+                  MemoryPool::DebugOptions{.debugPoolNameRegex = ".*OrderBy.*"})
+            : std::nullopt);
     auto pool2_0 = root2->addLeafChild("OrderBy.0.0");
     auto* buffer2 = pool2_0->allocate(1 * KB);
     if (!debugEnabled) {
@@ -2879,13 +2903,51 @@ TEST(MemoryPoolTest, debugModeWithFilter) {
     // leaf child created from MemoryManager, not match filter
     auto sysLeaf = manager.addLeafPool("Arbitrator.0.0");
     auto* buffer5 = sysLeaf->allocate(1 * KB);
-    EXPECT_TRUE(std::dynamic_pointer_cast<MemoryPoolImpl>(sysLeaf)
-                    ->testingDebugAllocRecords()
-                    .empty());
+    EXPECT_TRUE(
+        std::dynamic_pointer_cast<MemoryPoolImpl>(sysLeaf)
+            ->testingDebugAllocRecords()
+            .empty());
     sysLeaf->free(buffer5, 1 * KB);
   }
 }
 
+TEST_P(MemoryPoolTest, debugModeWrapCapException) {
+  const uint64_t kMaxCap = 128L * MB;
+  MemoryManager::Options options;
+  options.allocatorCapacity = kMaxCap;
+  options.arbitratorCapacity = kMaxCap;
+  options.extraArbitratorConfigs = {
+      {std::string(SharedArbitrator::ExtraConfig::kReservedCapacity),
+       folly::to<std::string>(kMaxCap / 2) + "B"}};
+  setupMemory(options);
+  auto manager = getMemoryManager();
+  auto root =
+      manager->addRootPool("MemoryCapExceptions", kMaxCap, nullptr, {{".*"}});
+  auto pool1 = root->addLeafChild("static_quota_1", isLeafThreadSafe_);
+  auto pool2 = root->addLeafChild("static_quota_2", isLeafThreadSafe_);
+  {
+    std::vector<void*> buffers{
+        pool1->allocate(64L * MB), pool1->allocate(64L * MB)};
+    try {
+      pool2->allocate(1L * MB);
+    } catch (const velox::VeloxRuntimeError& ex) {
+      ASSERT_EQ(error_source::kErrorSourceRuntime.c_str(), ex.errorSource());
+      ASSERT_EQ(error_code::kMemCapExceeded.c_str(), ex.errorCode());
+      EXPECT_TRUE(
+          ex.message().find(
+              "Exceeded memory pool capacity.\n\n"
+              "======= Current Allocations ======\n"
+              "Memory pool 'static_quota_1' - Found 2 allocations with 128.00MB total size:\n"
+              "======== 2 allocations of 128.00MB total size ========") !=
+          std::string::npos)
+          << "Actual error message: " << ex.message();
+    }
+    for (auto buffer : buffers) {
+      pool1->free(buffer, 64L * MB);
+    }
+  }
+}
+
 TEST_P(MemoryPoolTest, shrinkAndGrowAPIs) {
   MemoryManager& manager = *getMemoryManager();
   std::vector<uint64_t> capacities = {kMaxMemory, 128 * MB};
@@ -3968,9 +4030,13 @@ TEST_P(MemoryPoolTest, abort) {
       ASSERT_TRUE(rootPool->aborted());
 
       // Allocate more buffer to trigger reservation increment at the root.
-      { VELOX_ASSERT_THROW(leafPool->allocate(capacity / 2), ""); }
+      {
+        VELOX_ASSERT_THROW(leafPool->allocate(capacity / 2), "");
+      }
       // Allocate more buffer to trigger memory arbitration at the root.
-      { VELOX_ASSERT_THROW(leafPool->allocate(capacity * 2), ""); }
+      {
+        VELOX_ASSERT_THROW(leafPool->allocate(capacity * 2), "");
+      }
       // Allocate without trigger memory reservation increment.
       void* buf2 = leafPool->allocate(128);
       ASSERT_EQ(leafPool->usedBytes(), 256);
@@ -4037,6 +4103,213 @@ TEST_P(MemoryPoolTest, allocationWithCoveredCollateral) {
   pool->freeContiguous(contiguousAllocation);
 }
 
+TEST_P(MemoryPoolTest, transferTo) {
+  MemoryManager::Options options;
+  options.alignment = MemoryAllocator::kMinAlignment;
+  options.allocatorCapacity = kDefaultCapacity;
+  setupMemory(options);
+  auto manager = getMemoryManager();
+
+  auto largestSizeClass = manager->allocator()->largestSizeClass();
+  std::vector<MachinePageCount> pageCounts{
+      largestSizeClass,
+      largestSizeClass + 1,
+      largestSizeClass / 10,
+      1,
+      largestSizeClass * 2,
+      largestSizeClass * 3 + 1};
+
+  auto assertEqualBytes = [](const memory::MemoryPool* pool,
+                             int64_t usedBytes,
+                             int64_t peakBytes,
+                             int64_t reservedBytes) {
+    EXPECT_EQ(pool->usedBytes(), usedBytes);
+    EXPECT_EQ(pool->peakBytes(), peakBytes);
+    EXPECT_EQ(pool->reservedBytes(), reservedBytes);
+  };
+
+  auto assertZeroByte = [](const memory::MemoryPool* pool) {
+    EXPECT_EQ(pool->usedBytes(), 0);
+    EXPECT_EQ(pool->reservedBytes(), 0);
+  };
+
+  auto getMemoryBytes = [](const memory::MemoryPool* pool) {
+    return std::make_tuple(
+        pool->usedBytes(), pool->peakBytes(), pool->reservedBytes());
+  };
+
+  auto createPools = [&manager](bool betweenDifferentRoots) {
+    auto root1 = manager->addRootPool("root1");
+    auto root2 = manager->addRootPool("root2");
+    std::shared_ptr<MemoryPool> from;
+    std::shared_ptr<MemoryPool> to;
+    if (betweenDifferentRoots) {
+      from = root1->addLeafChild("from");
+      to = root2->addLeafChild("to");
+    } else {
+      from = root1->addLeafChild("from");
+      to = root1->addLeafChild("to");
+    }
+    return std::make_tuple(root1, root2, from, to);
+  };
+
+  auto testTransferAllocate = [&assertZeroByte,
+                               &assertEqualBytes,
+                               &getMemoryBytes,
+                               &createPools](bool betweenDifferentRoots) {
+    auto [root1, root2, from, to] = createPools(betweenDifferentRoots);
+    assertZeroByte(from.get());
+    assertZeroByte(to.get());
+    assertZeroByte(from->root());
+    assertZeroByte(to->root());
+
+    const auto kSize = 1024;
+    int64_t usedBytes, rootUsedBytes;
+    int64_t peakBytes, rootPeakBytes;
+    int64_t reservedBytes, rootReservedBytes;
+    auto buffer = from->allocate(kSize);
+    // Transferring between non-leaf pools is not allowed.
+    EXPECT_FALSE(from->root()->transferTo(to.get(), buffer, kSize));
+    EXPECT_FALSE(from->transferTo(to->root(), buffer, kSize));
+
+    std::tie(usedBytes, peakBytes, reservedBytes) = getMemoryBytes(from.get());
+    std::tie(rootUsedBytes, rootPeakBytes, rootReservedBytes) =
+        getMemoryBytes(from->root());
+    from->transferTo(to.get(), buffer, kSize);
+    assertEqualBytes(to.get(), usedBytes, peakBytes, reservedBytes);
+    if (from->root() == to->root()) {
+      rootPeakBytes *= 2;
+    }
+    assertEqualBytes(
+        to->root(), rootUsedBytes, rootPeakBytes, rootReservedBytes);
+    to->free(buffer, kSize);
+    assertZeroByte(from.get());
+    assertZeroByte(to.get());
+    assertZeroByte(from->root());
+    assertZeroByte(to->root());
+  };
+
+  auto testTransferAllocateZeroFilled =
+      [&assertZeroByte, &assertEqualBytes, &getMemoryBytes, &createPools](
+          bool betweenDifferentRoots) {
+        auto [root1, root2, from, to] = createPools(betweenDifferentRoots);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+
+        const auto kSize = 1024;
+        int64_t usedBytes, rootUsedBytes;
+        int64_t peakBytes, rootPeakBytes;
+        int64_t reservedBytes, rootReservedBytes;
+        auto buffer = from->allocateZeroFilled(8, kSize / 8);
+        std::tie(usedBytes, peakBytes, reservedBytes) =
+            getMemoryBytes(from.get());
+        std::tie(rootUsedBytes, rootPeakBytes, rootReservedBytes) =
+            getMemoryBytes(from->root());
+        from->transferTo(to.get(), buffer, kSize);
+        assertEqualBytes(to.get(), usedBytes, peakBytes, reservedBytes);
+        if (from->root() == to->root()) {
+          rootPeakBytes *= 2;
+        }
+        assertEqualBytes(
+            to->root(), rootUsedBytes, rootPeakBytes, rootReservedBytes);
+        to->free(buffer, kSize);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+      };
+
+  auto testTransferAllocateContiguous =
+      [&assertZeroByte, &assertEqualBytes, &getMemoryBytes, &createPools](
+          uint64_t pageCount, bool betweenDifferentRoots) {
+        auto [root1, root2, from, to] = createPools(betweenDifferentRoots);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+
+        int64_t usedBytes, rootUsedBytes;
+        int64_t peakBytes, rootPeakBytes;
+        int64_t reservedBytes, rootReservedBytes;
+        ContiguousAllocation out;
+        from->allocateContiguous(pageCount, out);
+        std::tie(usedBytes, peakBytes, reservedBytes) =
+            getMemoryBytes(from.get());
+        std::tie(rootUsedBytes, rootPeakBytes, rootReservedBytes) =
+            getMemoryBytes(from->root());
+        from->transferTo(to.get(), out.data(), out.size());
+        assertEqualBytes(to.get(), usedBytes, peakBytes, reservedBytes);
+        if (from->root() == to->root()) {
+          rootPeakBytes *= 2;
+        }
+        assertEqualBytes(
+            to->root(), rootUsedBytes, rootPeakBytes, rootReservedBytes);
+        to->freeContiguous(out);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+      };
+
+  auto testTransferAllocateNonContiguous =
+      [&assertZeroByte, &assertEqualBytes, &getMemoryBytes, &createPools](
+          uint64_t pageCount, bool betweenDifferentRoots) {
+        auto [root1, root2, from, to] = createPools(betweenDifferentRoots);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+
+        int64_t usedBytes, rootUsedBytes;
+        int64_t peakBytes, rootPeakBytes;
+        int64_t reservedBytes, rootReservedBytes;
+        Allocation out;
+        from->allocateNonContiguous(pageCount, out);
+        std::tie(usedBytes, peakBytes, reservedBytes) =
+            getMemoryBytes(from.get());
+        std::tie(rootUsedBytes, rootPeakBytes, rootReservedBytes) =
+            getMemoryBytes(from->root());
+        for (auto i = 0; i < out.numRuns(); ++i) {
+          const auto& run = out.runAt(i);
+          from->transferTo(to.get(), run.data(), run.numBytes());
+        }
+        assertEqualBytes(to.get(), usedBytes, peakBytes, reservedBytes);
+        if (from->root() == to->root()) {
+          EXPECT_EQ(to->root()->usedBytes(), rootUsedBytes);
+          // We reserve and release memory run-by-run, so the peak bytes would
+          // be no greater than twice of the original peak bytes.
+          EXPECT_LE(to->root()->peakBytes(), rootPeakBytes * 2);
+          EXPECT_EQ(to->root()->reservedBytes(), rootReservedBytes);
+        } else {
+          assertEqualBytes(
+              to->root(), rootUsedBytes, rootPeakBytes, rootReservedBytes);
+        }
+        to->freeNonContiguous(out);
+        assertZeroByte(from.get());
+        assertZeroByte(to.get());
+        assertZeroByte(from->root());
+        assertZeroByte(to->root());
+      };
+
+  // Test transfer between siblings of the same root pool.
+  testTransferAllocate(false);
+  testTransferAllocateZeroFilled(false);
+  for (auto pageCount : pageCounts) {
+    testTransferAllocateContiguous(pageCount, false);
+    testTransferAllocateNonContiguous(pageCount, false);
+  }
+
+  // Test transfer between different root pools.
+  testTransferAllocate(true);
+  testTransferAllocateZeroFilled(true);
+  for (auto pageCount : pageCounts) {
+    testTransferAllocateContiguous(pageCount, true);
+    testTransferAllocateNonContiguous(pageCount, true);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     MemoryPoolTestSuite,
     MemoryPoolTest,
diff --git a/velox/common/memory/tests/MockSharedArbitratorTest.cpp b/velox/common/memory/tests/MockSharedArbitratorTest.cpp
index 732136a4768e..a1569f547cf7 100644
--- a/velox/common/memory/tests/MockSharedArbitratorTest.cpp
+++ b/velox/common/memory/tests/MockSharedArbitratorTest.cpp
@@ -92,12 +92,13 @@ class MockTask : public std::enable_shared_from_this<MockTask> {
 
   class MemoryReclaimer : public memory::MemoryReclaimer {
    public:
-    MemoryReclaimer(const std::shared_ptr<MockTask>& task)
-        : memory::MemoryReclaimer(0), task_(task) {}
+    MemoryReclaimer(const std::shared_ptr<MockTask>& task, int32_t priority)
+        : memory::MemoryReclaimer(priority), task_(task) {}
 
     static std::unique_ptr<MemoryReclaimer> create(
-        const std::shared_ptr<MockTask>& task) {
-      return std::make_unique<MemoryReclaimer>(task);
+        const std::shared_ptr<MockTask>& task,
+        int32_t priority) {
+      return std::make_unique<MemoryReclaimer>(task, priority);
     }
 
     void abort(MemoryPool* pool, const std::exception_ptr& error) override {
@@ -113,16 +114,12 @@ class MockTask : public std::enable_shared_from_this<MockTask> {
     std::weak_ptr<MockTask> task_;
   };
 
-  void initTaskPool(
-      MemoryManager* manager,
-      uint64_t capacity,
-      uint32_t taskPriority = 0) {
+  void
+  initTaskPool(MemoryManager* manager, uint64_t capacity, int32_t priority) {
     root_ = manager->addRootPool(
         fmt::format("RootPool-{}", poolId_++),
         capacity,
-        MemoryReclaimer::create(shared_from_this()),
-        std::nullopt,
-        taskPriority);
+        MemoryReclaimer::create(shared_from_this(), priority));
   }
 
   MemoryPool* pool() const {
@@ -439,75 +436,99 @@ class MockSharedArbitrationTest : public testing::Test {
   }
 
   void SetUp() override {
-    setupMemory();
+    setupMemory({});
   }
 
   void TearDown() override {
     clearTasks();
   }
 
-  void setupMemory(
-      int64_t memoryCapacity = kMemoryCapacity,
-      int64_t reservedMemoryCapacity = 0,
-      uint64_t memoryPoolInitCapacity = 0,
-      uint64_t memoryPoolReserveCapacity = 0,
-      uint64_t fastExponentialGrowthCapacityLimit = 0,
-      double slowCapacityGrowPct = 0,
-      uint64_t memoryPoolMinFreeCapacity = 0,
-      double memoryPoolMinFreeCapacityPct = 0,
-      uint64_t memoryPoolMinReclaimBytes = 0,
-      double memoryPoolMinReclaimPct = 0,
-      uint64_t memoryPoolAbortCapacityLimit = 0,
-      double globalArbitrationReclaimPct = 0,
-      double memoryReclaimThreadsHwMultiplier =
-          kMemoryReclaimThreadsHwMultiplier,
-      std::function<void(MemoryPool&)> arbitrationStateCheckCb = nullptr,
-      bool globalArtbitrationEnabled = true,
-      uint64_t arbitrationTimeoutNs = 5 * 60 * 1'000'000'000UL,
-      bool globalArbitrationWithoutSpill = false,
-      // Set the globalArbitrationAbortTimeRatio to be very small so that the
-      // query can be aborted sooner and the test would not timeout.
-      double globalArbitrationAbortTimeRatio = 0.005) {
+  struct ArbitratorOptions {
+    int64_t memoryCapacity{kMemoryCapacity};
+    int64_t reservedMemoryCapacity{0};
+    uint64_t memoryPoolInitCapacity{0};
+    uint64_t memoryPoolReserveCapacity{0};
+    uint64_t fastExponentialGrowthCapacityLimit{0};
+
+    double slowCapacityGrowPct{0};
+    uint64_t memoryPoolMinFreeCapacity{0};
+    double memoryPoolMinFreeCapacityPct{0};
+    uint64_t memoryPoolMinReclaimBytes{0};
+    double memoryPoolMinReclaimPct{0};
+
+    uint64_t memoryPoolSpillCapacityLimit{0};
+    uint64_t memoryPoolAbortCapacityLimit{0};
+    double globalArbitrationReclaimPct{0};
+    double memoryReclaimThreadsHwMultiplier{kMemoryReclaimThreadsHwMultiplier};
+    std::function<void(MemoryPool&)> arbitrationStateCheckCb{nullptr};
+
+    bool globalArtbitrationEnabled{true};
+    uint64_t arbitrationTimeoutNs{5 * 60 * 1'000'000'000UL};
+    bool globalArbitrationWithoutSpill{false};
+    // Set the globalArbitrationAbortTimeRatio to be very small so that the
+    // query can be aborted sooner and the test would not timeout.
+    double globalArbitrationAbortTimeRatio{0.005};
+  };
+
+  void setupMemory(ArbitratorOptions arbitratorOptions) {
     MemoryManager::Options options;
-    options.allocatorCapacity = memoryCapacity;
+    options.allocatorCapacity = arbitratorOptions.memoryCapacity;
     std::string arbitratorKind = "SHARED";
     options.arbitratorKind = arbitratorKind;
 
     using ExtraConfig = SharedArbitrator::ExtraConfig;
     options.extraArbitratorConfigs = {
         {std::string(ExtraConfig::kReservedCapacity),
-         folly::to<std::string>(reservedMemoryCapacity) + "B"},
+         folly::to<std::string>(arbitratorOptions.reservedMemoryCapacity) +
+             "B"},
         {std::string(ExtraConfig::kMemoryPoolInitialCapacity),
-         folly::to<std::string>(memoryPoolInitCapacity) + "B"},
+         folly::to<std::string>(arbitratorOptions.memoryPoolInitCapacity) +
+             "B"},
         {std::string(ExtraConfig::kMemoryPoolReservedCapacity),
-         folly::to<std::string>(memoryPoolReserveCapacity) + "B"},
+         folly::to<std::string>(arbitratorOptions.memoryPoolReserveCapacity) +
+             "B"},
         {std::string(ExtraConfig::kFastExponentialGrowthCapacityLimit),
-         folly::to<std::string>(fastExponentialGrowthCapacityLimit) + "B"},
+         folly::to<std::string>(
+             arbitratorOptions.fastExponentialGrowthCapacityLimit) +
+             "B"},
         {std::string(ExtraConfig::kSlowCapacityGrowPct),
-         folly::to<std::string>(slowCapacityGrowPct)},
+         folly::to<std::string>(arbitratorOptions.slowCapacityGrowPct)},
         {std::string(ExtraConfig::kMemoryPoolMinFreeCapacity),
-         folly::to<std::string>(memoryPoolMinFreeCapacity) + "B"},
+         folly::to<std::string>(arbitratorOptions.memoryPoolMinFreeCapacity) +
+             "B"},
         {std::string(ExtraConfig::kMemoryPoolMinFreeCapacityPct),
-         folly::to<std::string>(memoryPoolMinFreeCapacityPct)},
+         folly::to<std::string>(
+             arbitratorOptions.memoryPoolMinFreeCapacityPct)},
         {std::string(ExtraConfig::kMemoryPoolMinReclaimBytes),
-         folly::to<std::string>(memoryPoolMinReclaimBytes) + "B"},
+         folly::to<std::string>(arbitratorOptions.memoryPoolMinReclaimBytes) +
+             "B"},
         {std::string(ExtraConfig::kMemoryPoolMinReclaimPct),
-         folly::to<std::string>(memoryPoolMinReclaimPct)},
+         folly::to<std::string>(arbitratorOptions.memoryPoolMinReclaimPct)},
+        {std::string(ExtraConfig::kMemoryPoolSpillCapacityLimit),
+         folly::to<std::string>(
+             arbitratorOptions.memoryPoolSpillCapacityLimit) +
+             "B"},
         {std::string(ExtraConfig::kMemoryPoolAbortCapacityLimit),
-         folly::to<std::string>(memoryPoolAbortCapacityLimit) + "B"},
+         folly::to<std::string>(
+             arbitratorOptions.memoryPoolAbortCapacityLimit) +
+             "B"},
         {std::string(ExtraConfig::kGlobalArbitrationMemoryReclaimPct),
-         folly::to<std::string>(globalArbitrationReclaimPct)},
+         folly::to<std::string>(arbitratorOptions.globalArbitrationReclaimPct)},
         {std::string(ExtraConfig::kMemoryReclaimThreadsHwMultiplier),
-         folly::to<std::string>(memoryReclaimThreadsHwMultiplier)},
+         folly::to<std::string>(
+             arbitratorOptions.memoryReclaimThreadsHwMultiplier)},
         {std::string(ExtraConfig::kMaxMemoryArbitrationTime),
-         folly::to<std::string>(arbitrationTimeoutNs) + "ns"},
+         folly::to<std::string>(arbitratorOptions.arbitrationTimeoutNs) + "ns"},
         {std::string(ExtraConfig::kGlobalArbitrationEnabled),
-         folly::to<std::string>(globalArtbitrationEnabled)},
+         folly::to<std::string>(arbitratorOptions.globalArtbitrationEnabled)},
         {std::string(ExtraConfig::kGlobalArbitrationWithoutSpill),
-         folly::to<std::string>(globalArbitrationWithoutSpill)},
+         folly::to<std::string>(
+             arbitratorOptions.globalArbitrationWithoutSpill)},
         {std::string(ExtraConfig::kGlobalArbitrationAbortTimeRatio),
-         folly::to<std::string>(globalArbitrationAbortTimeRatio)}};
-    options.arbitrationStateCheckCb = std::move(arbitrationStateCheckCb);
+         folly::to<std::string>(
+             arbitratorOptions.globalArbitrationAbortTimeRatio)}};
+    options.arbitrationStateCheckCb =
+        std::move(arbitratorOptions.arbitrationStateCheckCb);
     options.checkUsageLeak = true;
     manager_ = std::make_unique<MemoryManager>(options);
     ASSERT_EQ(manager_->arbitrator()->kind(), arbitratorKind);
@@ -516,9 +537,9 @@ class MockSharedArbitrationTest : public testing::Test {
 
   std::shared_ptr<MockTask> addTask(
       int64_t capacity = kMaxMemory,
-      uint32_t taskPriority = 0) {
+      int32_t priority = 0) {
     auto task = std::make_shared<MockTask>();
-    task->initTaskPool(manager_.get(), capacity, taskPriority);
+    task->initTaskPool(manager_.get(), capacity, priority);
     return task;
   }
 
@@ -821,40 +842,26 @@ TEST_F(MockSharedArbitrationTest, extraConfigs) {
       "Failed while parsing SharedArbitrator configs");
   // Invalid memory reclaim executor hw multiplier.
   VELOX_ASSERT_THROW(
-      setupMemory(kMemoryCapacity, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1),
+      setupMemory({.memoryReclaimThreadsHwMultiplier = -1}),
       "memoryReclaimThreadsHwMultiplier_ needs to be positive");
   // Invalid global arbitration reclaim pct.
   VELOX_ASSERT_THROW(
-      setupMemory(kMemoryCapacity, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 200),
+      setupMemory({.globalArbitrationReclaimPct = 200}),
       "(200 vs. 100) Invalid globalArbitrationMemoryReclaimPct");
   // Invalid max memory arbitration time.
   VELOX_ASSERT_THROW(
       setupMemory(
-          kMemoryCapacity,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0,
-          0,
-          nullptr,
-          false,
-          0),
+          {.memoryReclaimThreadsHwMultiplier = 0,
+           .globalArtbitrationEnabled = false,
+           .arbitrationTimeoutNs = 0}),
       "(0 vs. 0) maxArbitrationTimeNs can't be zero");
 }
 
 TEST_F(MockSharedArbitrationTest, constructor) {
   setupMemory(
-      kMemoryCapacity,
-      kReservedMemoryCapacity,
-      kMemoryPoolInitCapacity,
-      kMemoryPoolReservedCapacity);
+      {.reservedMemoryCapacity = kReservedMemoryCapacity,
+       .memoryPoolInitCapacity = kMemoryPoolInitCapacity,
+       .memoryPoolReserveCapacity = kMemoryPoolReservedCapacity});
   const int reservedCapacity = arbitrator_->stats().freeReservedCapacityBytes;
   const int nonReservedCapacity =
       arbitrator_->stats().freeCapacityBytes - reservedCapacity;
@@ -890,7 +897,10 @@ TEST_F(MockSharedArbitrationTest, arbitrationStateCheck) {
     ASSERT_TRUE(RE2::FullMatch(pool.name(), re)) << pool.name();
     ++checkCount;
   };
-  setupMemory(memCapacity, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.0, checkCountCb);
+  setupMemory(
+      {.memoryCapacity = memCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .arbitrationStateCheckCb = checkCountCb});
 
   const int numTasks{5};
   std::vector<std::shared_ptr<MockTask>> tasks;
@@ -915,7 +925,10 @@ TEST_F(MockSharedArbitrationTest, arbitrationStateCheck) {
   MemoryArbitrationStateCheckCB badCheckCb = [&](MemoryPool& /*unused*/) {
     VELOX_FAIL("bad check");
   };
-  setupMemory(memCapacity, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.0, badCheckCb);
+  setupMemory(
+      {.memoryCapacity = memCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .arbitrationStateCheckCb = badCheckCb});
   std::shared_ptr<MockTask> task = addTask(kMemoryCapacity);
   ASSERT_EQ(task->capacity(), 0);
   MockMemoryOperator* memOp = task->addMemoryOp();
@@ -925,7 +938,9 @@ TEST_F(MockSharedArbitrationTest, arbitrationStateCheck) {
 TEST_F(MockSharedArbitrationTest, asyncArbitrationWork) {
   const int memoryCapacity = 512 * MB;
   const int poolCapacity = 256 * MB;
-  setupMemory(memoryCapacity, 0, poolCapacity, 0);
+  setupMemory(
+      {.memoryCapacity = memoryCapacity,
+       .memoryPoolInitCapacity = poolCapacity});
 
   std::atomic_int reclaimedCount{0};
   std::shared_ptr<MockTask> task = addTask(poolCapacity);
@@ -1231,8 +1246,8 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
          memoryPoolCapacity,
          memoryPoolCapacity,
          false},
-        // Global arbitration choose to abort the younger participant with same
-        // capacity bucket.
+        // Global arbitration choose to abort the younger participant with
+        // same capacity bucket.
         {memoryPoolCapacity, false, memoryPoolCapacity, 0, 0, true},
         {memoryPoolCapacity, true, memoryPoolCapacity / 2, 0, 0, false},
         {memoryPoolCapacity, true, memoryPoolCapacity / 2, 0, 0, false}},
@@ -1274,8 +1289,8 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
          false},
         {memoryPoolCapacity, true, memoryPoolCapacity, 0, 0, true},
         {memoryPoolCapacity, false, memoryPoolCapacity / 2, 0, 0, true},
-        // Global arbitration choose to abort the younger participant with same
-        // capacity bucket.
+        // Global arbitration choose to abort the younger participant with
+        // same capacity bucket.
         {memoryPoolCapacity, false, memoryPoolCapacity / 2, 0, 0, true}},
        memoryPoolCapacity,
        memoryCapacity / 2 + memoryPoolCapacity / 2,
@@ -1288,8 +1303,8 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
        {{memoryPoolCapacity, true, memoryPoolCapacity, 0, 0, true},
         {memoryPoolCapacity, true, memoryPoolCapacity, 0, 0, true},
         {memoryPoolCapacity, false, memoryPoolCapacity / 2, 0, 0, true},
-        // Global arbitration choose to abort the younger participant with same
-        // capacity bucket.
+        // Global arbitration choose to abort the younger participant with
+        // same capacity bucket.
         {memoryPoolCapacity, false, memoryPoolCapacity / 2, 0, 0, true}},
        memoryPoolCapacity,
        0,
@@ -1320,7 +1335,9 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
     SCOPED_TRACE(testData.debugString());
 
     // Make simple settings to focus shrink capacity logic testing.
-    setupMemory(memoryCapacity, 0, testData.memoryPoolInitCapacity);
+    setupMemory(
+        {.memoryCapacity = memoryCapacity,
+         .memoryPoolInitCapacity = testData.memoryPoolInitCapacity});
     std::vector<TestTaskContainer> taskContainers;
     for (const auto& testTask : testData.testTasks) {
       auto task = addTask(testTask.capacity);
@@ -1361,7 +1378,7 @@ TEST_F(MockSharedArbitrationTest, shrinkPools) {
 
 TEST_F(MockSharedArbitrationTest, shrinkPoolsDelayedAbort) {
   const int64_t memoryCapacity = 256 * MB;
-  setupMemory(memoryCapacity);
+  setupMemory({.memoryCapacity = memoryCapacity});
 
   // Create first task using half the memory
   auto task1 = addTask(128 * MB);
@@ -1404,7 +1421,7 @@ TEST_F(MockSharedArbitrationTest, shrinkPoolsDelayedAbort) {
 // serial execution mode.
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, localArbitrationsFromSameQuery) {
   const int64_t memoryCapacity = 256 << 20;
-  setupMemory(memoryCapacity);
+  setupMemory({.memoryCapacity = memoryCapacity});
   auto runTask = addTask(memoryCapacity);
   auto* runPool = runTask->addMemoryOp(true);
   auto* waitPool = runTask->addMemoryOp(true);
@@ -1484,7 +1501,7 @@ DEBUG_ONLY_TEST_F(
     localArbitrationsFromDifferentQueries) {
   const int64_t memoryCapacity = 512 << 20;
   const uint64_t memoryPoolCapacity = memoryCapacity / 2;
-  setupMemory(memoryCapacity);
+  setupMemory({.memoryCapacity = memoryCapacity});
 
   auto task1 = addTask(memoryPoolCapacity);
   auto* op1 = task1->addMemoryOp(true);
@@ -1692,7 +1709,9 @@ TEST_F(MockSharedArbitrationTest, badNonReclaimableQuery) {
     SCOPED_TRACE(testData.debugString());
 
     // Make simple settings to focus shrink capacity logic testing.
-    setupMemory(memoryCapacity, 0, 0, 0, 0, 0, 0, 0, 0, 0, memoryCapacity / 8);
+    setupMemory(
+        {.memoryCapacity = memoryCapacity,
+         .memoryPoolAbortCapacityLimit = memoryCapacity / 8});
     std::vector<TestTaskContainer> taskContainers;
     for (const auto& testTask : testData.testTasks) {
       auto task = addTask(memoryCapacity);
@@ -1739,7 +1758,9 @@ DEBUG_ONLY_TEST_F(
   const uint64_t memoryPoolReservedCapacity = 8 << 20;
   const uint64_t reservedMemoryCapacity = 64 << 20;
   setupMemory(
-      memoryCapacity, reservedMemoryCapacity, 0, memoryPoolReservedCapacity);
+      {.memoryCapacity = memoryCapacity,
+       .reservedMemoryCapacity = reservedMemoryCapacity,
+       .memoryPoolReserveCapacity = memoryPoolReservedCapacity});
 
   auto globalArbitrationTriggerThread = std::thread([&]() {
     std::unordered_map<std::string, RuntimeMetric> runtimeStats;
@@ -1816,7 +1837,9 @@ DEBUG_ONLY_TEST_F(
   const uint64_t memoryPoolCapacity = 64 << 20;
   const uint64_t memoryPoolReservedCapacity = 8 << 20;
   setupMemory(
-      memoryCapacity, reservedMemoryCapacity, 0, memoryPoolReservedCapacity);
+      {.memoryCapacity = memoryCapacity,
+       .reservedMemoryCapacity = reservedMemoryCapacity,
+       .memoryPoolReserveCapacity = memoryPoolReservedCapacity});
 
   auto localArbitrationTask = addTask(memoryPoolCapacity);
   auto* localArbitrationOp = localArbitrationTask->addMemoryOp(true);
@@ -1908,24 +1931,11 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, globalArbitrationAbortTimeRatio) {
   const uint64_t abortTimeThresholdNs =
       maxArbitrationTimeNs * globalArbitrationAbortTimeRatio;
   setupMemory(
-      memoryCapacity,
-      0,
-      memoryPoolInitCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      kMemoryReclaimThreadsHwMultiplier,
-      nullptr,
-      true,
-      maxArbitrationTimeNs,
-      false,
-      globalArbitrationAbortTimeRatio);
+      {.memoryCapacity = memoryCapacity,
+       .memoryPoolInitCapacity = memoryPoolInitCapacity,
+       .memoryReclaimThreadsHwMultiplier = kMemoryReclaimThreadsHwMultiplier,
+       .arbitrationTimeoutNs = maxArbitrationTimeNs,
+       .globalArbitrationAbortTimeRatio = globalArbitrationAbortTimeRatio});
 
   test::SharedArbitratorTestHelper arbitratorHelper(arbitrator_);
 
@@ -1989,23 +1999,11 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationWithoutSpill) {
   const int64_t memoryCapacity = 512 << 20;
   const uint64_t memoryPoolInitCapacity = memoryCapacity / 2;
   setupMemory(
-      memoryCapacity,
-      0,
-      memoryPoolInitCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      kMemoryReclaimThreadsHwMultiplier,
-      nullptr,
-      true,
-      5 * 60 * 1'000'000'000UL,
-      true);
+      {.memoryCapacity = memoryCapacity,
+       .memoryPoolInitCapacity = memoryPoolInitCapacity,
+       .memoryReclaimThreadsHwMultiplier = kMemoryReclaimThreadsHwMultiplier,
+       .arbitrationTimeoutNs = 5 * 60 * 1'000'000'000UL,
+       .globalArbitrationWithoutSpill = true});
   auto triggerTask = addTask(memoryCapacity);
   auto* triggerOp = triggerTask->addMemoryOp(false);
   triggerOp->allocate(memoryCapacity / 2);
@@ -2037,28 +2035,16 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationWithoutSpill) {
 }
 
 TEST_F(MockSharedArbitrationTest, globalArbitrationSmallParticipantLargeGrow) {
-  // This test tests global arbitration takes into consideration the additional
-  // attempting grow capacity when selecting abort partitipants.
+  // This test tests global arbitration takes into consideration the
+  // additional attempting grow capacity when selecting abort partitipants.
   const int64_t kMemoryCapacity = 512 << 20;
   const uint64_t kMemoryPoolInitCapacity = kMemoryCapacity / 2;
   setupMemory(
-      kMemoryCapacity,
-      0,
-      kMemoryPoolInitCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      kMemoryCapacity, // Set abort capacity limit to differenciate capacity.
-      0,
-      kMemoryReclaimThreadsHwMultiplier,
-      nullptr,
-      true,
-      5 * 60 * 1'000'000'000UL,
-      true);
+      {.memoryCapacity = kMemoryCapacity,
+       .memoryPoolInitCapacity = kMemoryPoolInitCapacity,
+       // Set abort capacity limit to differenciate capacity.
+       .memoryPoolAbortCapacityLimit = kMemoryCapacity,
+       .globalArbitrationWithoutSpill = true});
 
   auto task0 = addTask(kMemoryCapacity);
   auto* op0 = task0->addMemoryOp(false);
@@ -2095,71 +2081,159 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationSmallParticipantLargeGrow) {
       "Memory pool aborted to reclaim used memory");
 }
 
-TEST_F(MockSharedArbitrationTest, globalArbitrationWithMemoryPoolPriority) {
-  // This test tests global arbitration takes into consideration query priority
-  // attempting to grow capacity when selecting abort partitipants.
+TEST_F(MockSharedArbitrationTest, globalArbitrationBySpillWithPriority) {
+  const int64_t memoryCapacity = 512 << 20;
+
+  struct TaskData {
+    uint64_t capacity;
+    int32_t priority;
+    bool expectSpill;
+    std::string debugString() const {
+      return fmt::format(
+          "capacity {}, priority {}, expectSpill {}",
+          succinctBytes(capacity),
+          priority,
+          expectSpill);
+    }
+  };
+
+  struct TestData {
+    std::string testName;
+    uint64_t shrinkBytes;
+    uint64_t spillCapacityLimit;
+    uint64_t spillCapacityLowerBound;
+    std::vector<TaskData> tasks;
+    std::string debugString() const {
+      std::stringstream ss;
+      for (const auto& task : tasks) {
+        ss << task.debugString() << ", ";
+      }
+      return fmt::format(
+          "testName {}, shrinkBytes {}, tasks [{}]",
+          testName,
+          shrinkBytes,
+          ss.str());
+    }
+  };
+
+  std::vector<TestData> testSettings = {
+      {"test-0", 64 << 20, 512 << 20, 0, {}},
+
+      {"test-1",
+       64 << 20,
+       512 << 20,
+       0,
+       {{256 << 20, 0, true}, {192 << 20, 1, false}, {64 << 20, 2, false}}},
+
+      {"test-2",
+       64 << 20,
+       512 << 20,
+       0,
+       {{192 << 20, 2, true}, {192 << 20, 1, false}, {128 << 20, 0, false}}},
+
+      {"test-3",
+       256 << 20,
+       512 << 20,
+       0,
+       {{144 << 20, 1, true},
+        {136 << 20, 1, true},
+        {128 << 20, 1, false},
+        {104 << 20, 0, false}}},
+
+      {"test-4",
+       256 << 20,
+       512 << 20,
+       128 << 20,
+       {{144 << 20, 1, true},
+        {120 << 20, 1, false},
+        {120 << 20, 1, false},
+        {104 << 20, 0, false}}},
+
+      {"test-5",
+       230 << 20,
+       512 << 20,
+       0,
+       {
+           {48 << 20, 3, true},
+           {44 << 20, 3, true},
+           {40 << 20, 3, true},
+           {52 << 20, 2, true},
+           {48 << 20, 2, true},
+           {44 << 20, 2, false},
+           {56 << 20, 1, false},
+           {52 << 20, 1, false},
+           {48 << 20, 1, false},
+           {28 << 20, 4, false},
+           {28 << 20, 4, false},
+           {24 << 20, 4, false},
+       }},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    setupMemory(
+        {.memoryCapacity = memoryCapacity,
+         .memoryPoolMinReclaimBytes = testData.spillCapacityLowerBound,
+         .memoryPoolSpillCapacityLimit = testData.spillCapacityLimit,
+         .globalArbitrationWithoutSpill = true});
+
+    std::vector<std::shared_ptr<MockTask>> tasks;
+    for (const auto& taskData : testData.tasks) {
+      tasks.push_back(addTask(taskData.capacity, taskData.priority));
+      auto* op = tasks.back()->addMemoryOp(true);
+      op->allocate(taskData.capacity);
+    }
+
+    arbitrator_->shrinkCapacity(testData.shrinkBytes, true, false);
+    for (auto i = 0; i < tasks.size(); ++i) {
+      ASSERT_EQ(
+          tasks[i]->capacity() < testData.tasks[i].capacity,
+          testData.tasks[i].expectSpill);
+    }
+  }
+}
+
+TEST_F(MockSharedArbitrationTest, globalArbitrationByAbortWithPriority) {
+  // This test tests global arbitration takes into consideration query
+  // priority attempting to grow capacity when selecting abort partitipants.
   const int64_t memoryCapacity = 512 << 20;
   const uint64_t memoryPoolInitCapacity = memoryCapacity / 2;
   setupMemory(
-      memoryCapacity,
-      0,
-      memoryPoolInitCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      memoryCapacity, // Set abort capacity limit to differenciate capacity.
-      0,
-      kMemoryReclaimThreadsHwMultiplier,
-      nullptr,
-      true,
-      5 * 60 * 1'000'000'000UL,
-      true);
+      {.memoryCapacity = memoryCapacity,
+       .memoryPoolInitCapacity = memoryPoolInitCapacity,
+       // Set abort capacity limit to differenciate capacity.
+       .memoryPoolAbortCapacityLimit = memoryCapacity,
+       .globalArbitrationWithoutSpill = true});
 
-  // task0 is normal priority with 256MB capacity with initial allocation of
-  // 256MB
-  auto task0 = addTask(memoryCapacity / 2, 100);
+  auto task0 = addTask(384 << 20, 1);
   auto* op0 = task0->addMemoryOp(false);
-  op0->allocate(memoryCapacity / 2);
+  op0->allocate(384 << 20);
 
-  // task1 is low priority with 256MB capacity with initial allocation of 256MB
-  auto task1 = addTask(memoryCapacity / 2, 10);
-  auto* op1 = task1->addMemoryOp(true);
-  op1->allocate(memoryCapacity / 2);
+  auto task1 = addTask(64 << 20, 1);
+  auto* op1 = task1->addMemoryOp(false);
+  op1->allocate(64 << 20);
 
-  // task2 is normal priority in lower bucket has 256MB capacity with 0
-  // allocation
-  auto task2 = addTask(memoryCapacity / 2, 999);
-  auto* op2 = task2->addMemoryOp(true);
-
-  std::unordered_map<std::string, RuntimeMetric> runtimeStats;
-  auto statsWriter = std::make_unique<TestRuntimeStatWriter>(runtimeStats);
-  setThreadLocalRunTimeStatWriter(statsWriter.get());
+  auto task2 = addTask(64 << 20, 2);
+  auto* op2 = task2->addMemoryOp(false);
+  op2->allocate(64 << 20);
 
   // At this point, memory pool is full
   ASSERT_EQ(manager_->capacity(), manager_->getTotalBytes());
 
-  // Next allocation should succeed with side effect of lowest priority
-  // query getting killed.
-  op2->allocate(memoryCapacity / 2);
-
-  ASSERT_EQ(
-      runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].count, 1);
-  ASSERT_GT(runtimeStats[SharedArbitrator::kMemoryArbitrationWallNanos].sum, 0);
-  ASSERT_EQ(
-      runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].count, 1);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kGlobalArbitrationWaitCount].sum, 1);
-  ASSERT_EQ(runtimeStats[SharedArbitrator::kLocalArbitrationCount].count, 0);
-
-  // task1 gets aborted since its lowest priority compared to task0
-  // task2 is younger in same bucket but survives due to priority.
+  arbitrator_->shrinkCapacity(64 << 20, false, true);
   ASSERT_TRUE(task0->error() == nullptr);
-  ASSERT_TRUE(task1->error() != nullptr);
-  ASSERT_TRUE(task2->error() == nullptr);
+  ASSERT_TRUE(task1->error() == nullptr);
+  VELOX_ASSERT_THROW(
+      std::rethrow_exception(task2->error()),
+      "Memory pool aborted to reclaim used memory");
+
+  arbitrator_->shrinkCapacity(64 << 20, false, true);
+  VELOX_ASSERT_THROW(
+      std::rethrow_exception(task0->error()),
+      "Memory pool aborted to reclaim used memory");
+  ASSERT_TRUE(task1->error() == nullptr);
 
+  arbitrator_->shrinkCapacity(64 << 20, false, true);
   VELOX_ASSERT_THROW(
       std::rethrow_exception(task1->error()),
       "Memory pool aborted to reclaim used memory");
@@ -2168,7 +2242,9 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationWithMemoryPoolPriority) {
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, multipleGlobalRuns) {
   const int64_t memoryCapacity = 512 << 20;
   const uint64_t memoryPoolInitCapacity = memoryCapacity / 2;
-  setupMemory(memoryCapacity, 0, memoryPoolInitCapacity, 0);
+  setupMemory(
+      {.memoryCapacity = memoryCapacity,
+       .memoryPoolInitCapacity = memoryPoolInitCapacity});
   auto runTask = addTask(memoryCapacity);
   auto* runPool = runTask->addMemoryOp(true);
   runPool->allocate(memoryCapacity / 2);
@@ -2253,21 +2329,15 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationEnableCheck) {
     const int64_t memoryCapacity = 512 << 20;
     const uint64_t memoryPoolInitCapacity = memoryCapacity / 2;
     setupMemory(
-        memoryCapacity,
-        0,
-        memoryPoolInitCapacity,
-        0,
-        kFastExponentialGrowthCapacityLimit,
-        kSlowCapacityGrowPct,
-        kMemoryPoolMinFreeCapacity,
-        kMemoryPoolMinFreeCapacityPct,
-        0,
-        0,
-        0,
-        kGlobalArbitrationReclaimPct,
-        kMemoryReclaimThreadsHwMultiplier,
-        nullptr,
-        globalArbitrationEnabled);
+        {.memoryCapacity = memoryCapacity,
+         .memoryPoolInitCapacity = memoryPoolInitCapacity,
+         .fastExponentialGrowthCapacityLimit =
+             kFastExponentialGrowthCapacityLimit,
+         .slowCapacityGrowPct = kSlowCapacityGrowPct,
+         .memoryPoolMinFreeCapacity = kMemoryPoolMinFreeCapacity,
+         .memoryPoolMinFreeCapacityPct = kMemoryPoolMinFreeCapacityPct,
+         .globalArbitrationReclaimPct = kGlobalArbitrationReclaimPct,
+         .globalArtbitrationEnabled = globalArbitrationEnabled});
 
     test::SharedArbitratorTestHelper arbitratorHelper(arbitrator_);
     ASSERT_EQ(
@@ -2327,27 +2397,24 @@ TEST_F(MockSharedArbitrationTest, singlePoolShrinkWithoutArbitration) {
     if (testParam.expectThrow) {
       VELOX_ASSERT_THROW(
           setupMemory(
-              memoryCapacity,
-              0,
-              memoryCapacity,
-              0,
-              0,
-              0,
-              testParam.memoryPoolMinFreeCapacity,
-              testParam.memoryPoolMinFreeCapacityPct),
+              {memoryCapacity,
+               0,
+               memoryCapacity,
+               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,
-          testParam.memoryPoolMinFreeCapacity,
-          testParam.memoryPoolMinFreeCapacityPct);
+          {.memoryCapacity = memoryCapacity,
+           .memoryPoolInitCapacity = memoryCapacity,
+           .memoryPoolMinFreeCapacity = testParam.memoryPoolMinFreeCapacity,
+           .memoryPoolMinFreeCapacityPct =
+               testParam.memoryPoolMinFreeCapacityPct});
     }
 
     auto task = addTask();
@@ -2387,12 +2454,11 @@ TEST_F(MockSharedArbitrationTest, singlePoolGrowWithoutArbitration) {
   for (const auto& testParam : testParams) {
     SCOPED_TRACE(testParam.debugString());
     setupMemory(
-        memoryCapacity,
-        0,
-        memoryPoolInitCapacity,
-        0,
-        testParam.fastExponentialGrowthCapacityLimit,
-        testParam.slowCapacityGrowPct);
+        {.memoryCapacity = memoryCapacity,
+         .memoryPoolInitCapacity = memoryPoolInitCapacity,
+         .fastExponentialGrowthCapacityLimit =
+             testParam.fastExponentialGrowthCapacityLimit,
+         .slowCapacityGrowPct = testParam.slowCapacityGrowPct});
 
     auto* memOp = addMemoryOp();
     const int allocateSize = 1 * MB;
@@ -2434,8 +2500,8 @@ TEST_F(MockSharedArbitrationTest, singlePoolGrowWithoutArbitration) {
 
 TEST_F(MockSharedArbitrationTest, maxCapacityReserve) {
   struct {
-    uint64_t memCapacity;
-    uint64_t reservedCapacity;
+    int64_t memCapacity;
+    int64_t reservedCapacity;
     uint64_t poolInitCapacity;
     uint64_t poolReservedCapacity;
     uint64_t poolMaxCapacity;
@@ -2466,10 +2532,10 @@ TEST_F(MockSharedArbitrationTest, maxCapacityReserve) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     setupMemory(
-        testData.memCapacity,
-        testData.reservedCapacity,
-        testData.poolInitCapacity,
-        testData.poolReservedCapacity);
+        {.memoryCapacity = testData.memCapacity,
+         .reservedMemoryCapacity = testData.reservedCapacity,
+         .memoryPoolInitCapacity = testData.poolInitCapacity,
+         .memoryPoolReserveCapacity = testData.poolReservedCapacity});
     if (testData.expectedError) {
       VELOX_ASSERT_THROW(addTask(testData.poolMaxCapacity), "");
       continue;
@@ -2607,14 +2673,11 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     setupMemory(
-        memCapacity,
-        0,
-        poolInitCapacity,
-        0,
-        kFastExponentialGrowthCapacityLimit,
-        kSlowCapacityGrowPct,
-        0,
-        0);
+        {.memoryCapacity = memCapacity,
+         .memoryPoolInitCapacity = poolInitCapacity,
+         .fastExponentialGrowthCapacityLimit =
+             kFastExponentialGrowthCapacityLimit,
+         .slowCapacityGrowPct = kSlowCapacityGrowPct});
 
     auto requestor = addTask(testData.poolMaxCapacity);
     auto* requestorOp = addMemoryOp(requestor, testData.isReclaimable);
@@ -2655,7 +2718,7 @@ TEST_F(MockSharedArbitrationTest, ensureMemoryPoolMaxCapacity) {
 
 TEST_F(MockSharedArbitrationTest, ensureNodeMaxCapacity) {
   struct {
-    uint64_t nodeCapacity;
+    int64_t nodeCapacity;
     uint64_t poolMaxCapacity;
     bool isReclaimable;
     uint64_t allocatedBytes;
@@ -2688,7 +2751,7 @@ TEST_F(MockSharedArbitrationTest, ensureNodeMaxCapacity) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    setupMemory(testData.nodeCapacity, 0, 0, 0);
+    setupMemory({.memoryCapacity = testData.nodeCapacity});
 
     auto requestor = addTask(testData.poolMaxCapacity);
     auto* requestorOp = addMemoryOp(requestor, testData.isReclaimable);
@@ -2711,8 +2774,8 @@ TEST_F(MockSharedArbitrationTest, ensureNodeMaxCapacity) {
 }
 
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, arbitrationAbort) {
-  uint64_t memoryCapacity = 256 * MB;
-  setupMemory(memoryCapacity);
+  int64_t memoryCapacity = 256 * MB;
+  setupMemory({.memoryCapacity = memoryCapacity});
   std::shared_ptr<MockTask> task1 = addTask(memoryCapacity);
   auto* op1 =
       task1->addMemoryOp(true, [&](MemoryPool* /*unsed*/, uint64_t /*unsed*/) {
@@ -2759,8 +2822,8 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, arbitrationAbort) {
 }
 
 TEST_F(MockSharedArbitrationTest, shutdown) {
-  uint64_t memoryCapacity = 256 * MB;
-  setupMemory(memoryCapacity);
+  int64_t memoryCapacity = 256 * MB;
+  setupMemory({.memoryCapacity = memoryCapacity});
   arbitrator_->shutdown();
   // double shutdown.
   arbitrator_->shutdown();
@@ -2779,24 +2842,11 @@ TEST_F(MockSharedArbitrationTest, shutdown) {
 }
 
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, shutdownWait) {
-  uint64_t memoryCapacity = 256 * MB;
+  int64_t memoryCapacity = 256 * MB;
   setupMemory(
-      memoryCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1.0,
-      nullptr,
-      true,
-      2'000'000'000UL);
+      {.memoryCapacity = memoryCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .arbitrationTimeoutNs = 2'000'000'000UL});
   std::shared_ptr<MockTask> task1 = addTask(memoryCapacity);
   auto* op1 = task1->addMemoryOp(true);
   op1->allocate(memoryCapacity / 2);
@@ -2956,17 +3006,9 @@ TEST_F(MockSharedArbitrationTest, memoryPoolAbortCapacityLimit) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     setupMemory(
-        memoryCapacity,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        testData.memoryPoolAbortCapacityLimit);
+        {.memoryCapacity = memoryCapacity,
+         .memoryPoolAbortCapacityLimit =
+             testData.memoryPoolAbortCapacityLimit});
 
     std::vector<TestTaskContainer> taskContainers;
     for (const auto& testTask : testData.testTasks) {
@@ -2998,8 +3040,8 @@ TEST_F(MockSharedArbitrationTest, memoryPoolAbortCapacityLimit) {
 DEBUG_ONLY_TEST_F(
     MockSharedArbitrationTest,
     globalArbitrationWaitReturnEarlyWithFreeCapacity) {
-  uint64_t memoryCapacity = 256 * MB;
-  setupMemory(memoryCapacity);
+  int64_t memoryCapacity = 256 * MB;
+  setupMemory({.memoryCapacity = memoryCapacity});
   std::shared_ptr<MockTask> task1 = addTask(memoryCapacity);
   auto* op1 = task1->addMemoryOp(true);
   op1->allocate(memoryCapacity / 2);
@@ -3051,24 +3093,11 @@ DEBUG_ONLY_TEST_F(
 }
 
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, globalArbitrationTimeout) {
-  uint64_t memoryCapacity = 256 * MB;
+  int64_t memoryCapacity = 256 * MB;
   setupMemory(
-      memoryCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1.0,
-      nullptr,
-      true,
-      1'000'000'000UL);
+      {.memoryCapacity = memoryCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .arbitrationTimeoutNs = 1'000'000'000UL});
   std::shared_ptr<MockTask> task1 = addTask(memoryCapacity);
   auto* op1 = task1->addMemoryOp(true);
   op1->allocate(memoryCapacity / 2);
@@ -3109,31 +3138,18 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, globalArbitrationTimeout) {
 }
 
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, localArbitrationTimeout) {
-  uint64_t memoryCapacity = 256 * MB;
+  int64_t memoryCapacity = 256 * MB;
   setupMemory(
-      memoryCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1.0,
-      nullptr,
-      true,
-      1'000'000'000UL);
+      {.memoryCapacity = memoryCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .arbitrationTimeoutNs = 1'000'000'000UL});
   std::shared_ptr<MockTask> task = addTask(memoryCapacity);
   ASSERT_EQ(task->capacity(), 0);
   auto* op = task->addMemoryOp(true);
   op->allocate(memoryCapacity / 2);
 
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::memory::ArbitrationParticipant::reclaim",
+      "facebook::velox::memory::SharedArbitrator::growCapacity",
       std::function<void(const ArbitrationParticipant*)>(
           ([&](const ArbitrationParticipant* /*unused*/) {
             std::this_thread::sleep_for(std::chrono::seconds(2)); // NOLINT
@@ -3147,30 +3163,18 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, localArbitrationTimeout) {
         testing::HasSubstr("Memory arbitration timed out on memory pool"));
   }
 
-  // Reclaim happened before timeout check.
-  ASSERT_EQ(task->capacity(), 0);
+  // Timeout check happened before reclaim.
+  ASSERT_EQ(task->capacity(), memoryCapacity / 2);
 }
 
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, reclaimLockTimeout) {
   const uint64_t memoryCapacity = 256 * MB;
   const uint64_t arbitrationTimeoutMs = 1'000;
   setupMemory(
-      memoryCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1.0,
-      nullptr,
-      false,
-      arbitrationTimeoutMs);
+      {.memoryCapacity = memoryCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .globalArtbitrationEnabled = false,
+       .arbitrationTimeoutNs = arbitrationTimeoutMs});
   std::shared_ptr<MockTask> task = addTask(memoryCapacity);
   ASSERT_EQ(task->capacity(), 0);
   auto* op = task->addMemoryOp(true);
@@ -3187,8 +3191,8 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, reclaimLockTimeout) {
       "facebook::velox::memory::ArbitrationParticipant::reclaim",
       std::function<void(const ArbitrationParticipant*)>(
           ([&](const ArbitrationParticipant* /*unused*/) {
-            // Timeout shall be enforced at lock level. We don't expect code to
-            // execute pass the lock in reclaim method.
+            // Timeout shall be enforced at lock level. We don't expect code
+            // to execute pass the lock in reclaim method.
             FAIL();
           })));
 
@@ -3207,24 +3211,11 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, reclaimLockTimeout) {
 }
 
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, localArbitrationQueueTimeout) {
-  uint64_t memoryCapacity = 256 * MB;
+  int64_t memoryCapacity = 256 * MB;
   setupMemory(
-      memoryCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1.0,
-      nullptr,
-      true,
-      1'000'000'000UL);
+      {.memoryCapacity = memoryCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .arbitrationTimeoutNs = 1'000'000'000UL});
   std::shared_ptr<MockTask> task = addTask(memoryCapacity);
   ASSERT_EQ(task->capacity(), 0);
   auto* op = task->addMemoryOp(true);
@@ -3417,17 +3408,10 @@ TEST_F(MockSharedArbitrationTest, minReclaimBytes) {
     SCOPED_TRACE(testData.debugString());
     // Make simple settings to focus shrink capacity logic testing.
     setupMemory(
-        memoryCapacity,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        testData.minReclaimBytes,
-        0,
-        memoryCapacity);
+        {.memoryCapacity = memoryCapacity,
+         .memoryPoolMinReclaimBytes = testData.minReclaimBytes,
+         .memoryPoolSpillCapacityLimit = memoryCapacity,
+         .memoryPoolAbortCapacityLimit = memoryCapacity});
     std::vector<TestTaskContainer> taskContainers;
     for (const auto& testTask : testData.testTasks) {
       auto task = addTask();
@@ -3559,7 +3543,8 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationReclaimPct) {
     SCOPED_TRACE(testData.debugString());
 
     setupMemory(
-        memoryCapacity, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, testData.reclaimPct);
+        {.memoryCapacity = memoryCapacity,
+         .globalArbitrationReclaimPct = testData.reclaimPct});
     std::vector<TestTaskContainer> taskContainers;
     for (const auto& testTask : testData.testTasks) {
       auto task = addTask();
@@ -3591,8 +3576,11 @@ TEST_F(MockSharedArbitrationTest, globalArbitrationReclaimPct) {
 }
 
 TEST_F(MockSharedArbitrationTest, noEligibleAbortCandidate) {
-  uint64_t memoryCapacity = 256 * MB;
-  setupMemory(memoryCapacity, memoryCapacity / 2, 0, memoryCapacity / 4);
+  int64_t memoryCapacity = 256 * MB;
+  setupMemory(
+      {.memoryCapacity = memoryCapacity,
+       .reservedMemoryCapacity = memoryCapacity / 2,
+       .memoryPoolReserveCapacity = static_cast<uint64_t>(memoryCapacity / 4)});
   std::shared_ptr<MockTask> task = addTask(memoryCapacity);
   ASSERT_EQ(task->capacity(), memoryCapacity / 4);
   auto* op = task->addMemoryOp(true);
@@ -3604,7 +3592,9 @@ TEST_F(MockSharedArbitrationTest, growWithArbitrationAbort) {
   const int memCapacity = 256 * MB;
   const int initPoolCapacity = 8 * MB;
   setupMemory(
-      memCapacity, 0, initPoolCapacity, 0, 0, 0, 0, 0, 0, 0, memCapacity);
+      {.memoryCapacity = memCapacity,
+       .memoryPoolInitCapacity = initPoolCapacity,
+       .memoryPoolAbortCapacityLimit = memCapacity});
 
   auto* reclaimableOp = addMemoryOp(nullptr, true);
   ASSERT_EQ(reclaimableOp->capacity(), initPoolCapacity);
@@ -3640,10 +3630,10 @@ TEST_F(MockSharedArbitrationTest, growWithArbitrationAbort) {
 
 TEST_F(MockSharedArbitrationTest, singlePoolGrowCapacityWithArbitration) {
   const std::vector<bool> isLeafReclaimables = {false, true};
-  const uint64_t memoryCapacity = 128 * MB;
+  const int64_t memoryCapacity = 128 * MB;
   for (const auto isLeafReclaimable : isLeafReclaimables) {
     SCOPED_TRACE(fmt::format("isLeafReclaimable {}", isLeafReclaimable));
-    setupMemory(memoryCapacity);
+    setupMemory({.memoryCapacity = memoryCapacity});
     auto* op = addMemoryOp(nullptr, isLeafReclaimable);
     op->allocate(memoryCapacity);
     verifyArbitratorStats(arbitrator_->stats(), memoryCapacity, 0, 0, 1);
@@ -3676,15 +3666,17 @@ TEST_F(MockSharedArbitrationTest, singlePoolGrowCapacityWithArbitration) {
   }
 }
 
-// This test verifies if a single memory pool fails to grow capacity because of
-// reserved capacity.
+// This test verifies if a single memory pool fails to grow capacity because
+// of reserved capacity.
 // TODO: add reserved capacity check in ensure capacity.
 TEST_F(MockSharedArbitrationTest, singlePoolGrowCapacityFailedWithAbort) {
   const uint64_t memoryCapacity = 128 * MB;
   const uint64_t reservedMemoryCapacity = 64 * MB;
   const uint64_t memoryPoolReservedCapacity = 64 * MB;
   setupMemory(
-      memoryCapacity, reservedMemoryCapacity, 0, memoryPoolReservedCapacity);
+      {.memoryCapacity = memoryCapacity,
+       .reservedMemoryCapacity = reservedMemoryCapacity,
+       .memoryPoolReserveCapacity = memoryPoolReservedCapacity});
   auto* op = addMemoryOp(nullptr, true);
   op->allocate(memoryCapacity - reservedMemoryCapacity);
   verifyArbitratorStats(
@@ -3716,7 +3708,7 @@ TEST_F(MockSharedArbitrationTest, arbitrateWithCapacityShrink) {
   const std::vector<bool> isLeafReclaimables = {true, false};
   for (const auto isLeafReclaimable : isLeafReclaimables) {
     SCOPED_TRACE(fmt::format("isLeafReclaimable {}", isLeafReclaimable));
-    setupMemory();
+    setupMemory({});
     auto* reclaimedOp = addMemoryOp(nullptr, isLeafReclaimable);
     const int reclaimedOpCapacity = kMemoryCapacity * 2 / 3;
     const int allocateSize = 32 * MB;
@@ -3754,17 +3746,10 @@ TEST_F(MockSharedArbitrationTest, arbitrateWithMemoryReclaim) {
   for (const auto isLeafReclaimable : isLeafReclaimables) {
     SCOPED_TRACE(fmt::format("isLeafReclaimable {}", isLeafReclaimable));
     setupMemory(
-        memoryCapacity,
-        reservedMemoryCapacity,
-        0,
-        reservedPoolCapacity,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        memoryPoolAbortCapacityLimit);
+        {.memoryCapacity = memoryCapacity,
+         .reservedMemoryCapacity = reservedMemoryCapacity,
+         .memoryPoolReserveCapacity = reservedPoolCapacity,
+         .memoryPoolAbortCapacityLimit = memoryPoolAbortCapacityLimit});
     auto* reclaimedOp = addMemoryOp(nullptr, isLeafReclaimable);
     reclaimedOp->allocate(
         memoryCapacity - reservedMemoryCapacity - reservedPoolCapacity);
@@ -3796,22 +3781,9 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, abortWithNoCandidate) {
   const uint64_t memoryCapacity = 256 * MB;
   const uint64_t maxArbitrationTimeNs = 1'000'000'000UL;
   setupMemory(
-      memoryCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1.0,
-      nullptr,
-      true,
-      maxArbitrationTimeNs);
+      {.memoryCapacity = memoryCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .arbitrationTimeoutNs = maxArbitrationTimeNs});
   auto* reclaimedOp1 = addMemoryOp(nullptr, false);
   reclaimedOp1->allocate(memoryCapacity / 2);
   auto* reclaimedOp2 = addMemoryOp(nullptr, false);
@@ -3863,22 +3835,9 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, reclaimWithNoCandidate) {
   const uint64_t memoryCapacity = 256 * MB;
   const uint64_t maxArbitrationTimeNs = 1'000'000'000UL;
   setupMemory(
-      memoryCapacity,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1.0,
-      nullptr,
-      true,
-      maxArbitrationTimeNs);
+      {.memoryCapacity = memoryCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .arbitrationTimeoutNs = maxArbitrationTimeNs});
   auto* reclaimedOp1 = addMemoryOp(nullptr, true);
   reclaimedOp1->allocate(memoryCapacity / 2);
   auto* reclaimedOp2 = addMemoryOp(nullptr, true);
@@ -3930,21 +3889,11 @@ TEST_F(MockSharedArbitrationTest, arbitrateBySelfMemoryReclaim) {
     const uint64_t reservedCapacity = 8 * MB;
     const uint64_t poolReservedCapacity = 4 * MB;
     setupMemory(
-        memCapacity,
-        reservedCapacity,
-        reservedCapacity,
-        poolReservedCapacity,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        kMemoryReclaimThreadsHwMultiplier,
-        nullptr,
-        false);
+        {.memoryCapacity = memCapacity,
+         .reservedMemoryCapacity = reservedCapacity,
+         .memoryPoolInitCapacity = reservedCapacity,
+         .memoryPoolReserveCapacity = poolReservedCapacity,
+         .globalArtbitrationEnabled = false});
     std::shared_ptr<MockTask> task = addTask(kMemoryCapacity);
     auto* memOp = addMemoryOp(task, isLeafReclaimable);
     const int allocateSize = 8 * MB;
@@ -3992,7 +3941,7 @@ TEST_F(MockSharedArbitrationTest, noAbortOnRequestWhenArbitrationFails) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    setupMemory(memCapacity, 0);
+    setupMemory({.memoryCapacity = memCapacity});
     std::shared_ptr<MockTask> task = addTask(kMemoryCapacity);
     auto* memOp = addMemoryOp(task, false);
     if (testData.initialAllocationSize != 0) {
@@ -4023,7 +3972,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, orderedArbitration) {
             }
           })));
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableUsedCapacity",
+      "facebook::velox::memory::SharedArbitrator::sortSpillCandidates",
       std::function<void(const std::vector<ArbitrationCandidate>*)>(
           ([&](const std::vector<ArbitrationCandidate>* candidates) {
             for (int i = 1; i < candidates->size(); ++i) {
@@ -4035,7 +3984,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, orderedArbitration) {
 
   folly::Random::DefaultGenerator rng;
   rng.seed(512);
-  const uint64_t memCapacity = 512 * MB;
+  const int64_t memCapacity = 512 * MB;
   const uint64_t reservedMemCapacity = 128 * MB;
   const uint64_t initPoolCapacity = 32 * MB;
   const uint64_t reservedPoolCapacity = 8 * MB;
@@ -4056,10 +4005,10 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, orderedArbitration) {
     SCOPED_TRACE(testData.debugString());
 
     setupMemory(
-        memCapacity,
-        reservedMemCapacity,
-        initPoolCapacity,
-        reservedPoolCapacity);
+        {.memoryCapacity = memCapacity,
+         .reservedMemoryCapacity = reservedMemCapacity,
+         .memoryPoolInitCapacity = initPoolCapacity,
+         .memoryPoolReserveCapacity = reservedPoolCapacity});
     std::vector<MockMemoryOperator*> memOps;
     for (int i = 0; i < numTasks; ++i) {
       auto* memOp = addMemoryOp();
@@ -4092,7 +4041,9 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, orderedArbitration) {
 TEST_F(MockSharedArbitrationTest, enterArbitrationException) {
   const uint64_t memCapacity = 128 * MB;
   const uint64_t initPoolCapacity = memCapacity;
-  setupMemory(memCapacity, 0, initPoolCapacity, 0);
+  setupMemory(
+      {.memoryCapacity = memCapacity,
+       .memoryPoolInitCapacity = initPoolCapacity});
   auto* reclaimedOp = addMemoryOp();
   ASSERT_EQ(reclaimedOp->capacity(), memCapacity);
   const int allocationSize = 8 * MB;
@@ -4158,14 +4109,11 @@ TEST_F(MockSharedArbitrationTest, noArbitratiognFromAbortedPool) {
 
 TEST_F(MockSharedArbitrationTest, memoryReclaimeFailureTriggeredAbort) {
   setupMemory(
-      kMemoryCapacity,
-      0,
-      kMemoryPoolInitCapacity,
-      0,
-      kFastExponentialGrowthCapacityLimit,
-      kSlowCapacityGrowPct,
-      0,
-      0);
+      {.memoryCapacity = kMemoryCapacity,
+       .memoryPoolInitCapacity = kMemoryPoolInitCapacity,
+       .fastExponentialGrowthCapacityLimit =
+           kFastExponentialGrowthCapacityLimit,
+       .slowCapacityGrowPct = kSlowCapacityGrowPct});
   const int numTasks = 4;
   const int smallTaskMemoryCapacity = kMemoryCapacity / 8;
   const int largeTaskMemoryCapacity = kMemoryCapacity / 2;
@@ -4212,7 +4160,7 @@ TEST_F(MockSharedArbitrationTest, memoryReclaimeFailureTriggeredAbort) {
 
 // This test makes sure the memory capacity grows as expected.
 DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, concurrentArbitrationRequests) {
-  setupMemory(kMemoryCapacity);
+  setupMemory({.memoryCapacity = kMemoryCapacity});
   std::shared_ptr<MockTask> task = addTask();
   MockMemoryOperator* op1 = addMemoryOp(task);
   MockMemoryOperator* op2 = addMemoryOp(task);
@@ -4248,7 +4196,7 @@ DEBUG_ONLY_TEST_F(MockSharedArbitrationTest, concurrentArbitrationRequests) {
 DEBUG_ONLY_TEST_F(
     MockSharedArbitrationTest,
     freeUnusedCapacityWhenReclaimMemoryPool) {
-  setupMemory(kMemoryCapacity);
+  setupMemory({.memoryCapacity = kMemoryCapacity});
   const int allocationSize = kMemoryCapacity / 4;
   std::shared_ptr<MockTask> reclaimedTask = addTask();
   MockMemoryOperator* reclaimedTaskOp = addMemoryOp(reclaimedTask);
@@ -4263,7 +4211,7 @@ DEBUG_ONLY_TEST_F(
   folly::EventCount reclaimBlock;
   std::atomic_bool reclaimBlockFlag{true};
   SCOPED_TESTVALUE_SET(
-      "facebook::velox::memory::SharedArbitrator::sortCandidatesByReclaimableUsedCapacity",
+      "facebook::velox::memory::SharedArbitrator::sortAndGroupSpillCandidates",
       std::function<void(const MemoryPool*)>(([&](const MemoryPool* /*unsed*/) {
         reclaimWaitFlag = false;
         reclaimWait.notifyAll();
@@ -4294,7 +4242,7 @@ DEBUG_ONLY_TEST_F(
 
 TEST_F(MockSharedArbitrationTest, arbitrationFailure) {
   int64_t maxCapacity = 128 * MB;
-  int64_t initialCapacity = 0 * MB;
+  uint64_t initialCapacity = 0 * MB;
   struct {
     int64_t requestorCapacity;
     int64_t requestorRequestBytes;
@@ -4320,7 +4268,9 @@ TEST_F(MockSharedArbitrationTest, arbitrationFailure) {
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    setupMemory(maxCapacity, 0, initialCapacity);
+    setupMemory(
+        {.memoryCapacity = maxCapacity,
+         .memoryPoolInitCapacity = initialCapacity});
     std::shared_ptr<MockTask> requestorTask = addTask();
     MockMemoryOperator* requestorOp = addMemoryOp(requestorTask, false);
     requestorOp->allocate(testData.requestorCapacity);
@@ -4371,21 +4321,11 @@ TEST_F(
     // Set min reclaim bytes to avoid reclaim from itself before fail the
     // arbitration.
     setupMemory(
-        memoryCapacity,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        hasMinReclaimBytes ? MB : 0,
-        0,
-        0,
-        0,
-        1.0,
-        nullptr,
-        false);
+        {.memoryCapacity = memoryCapacity,
+         .memoryPoolMinReclaimBytes =
+             (hasMinReclaimBytes ? static_cast<uint64_t>(MB) : 0UL),
+         .memoryReclaimThreadsHwMultiplier = 1.0,
+         .globalArtbitrationEnabled = false});
     std::shared_ptr<MockTask> task1 = addTask();
     MockMemoryOperator* op1 = task1->addMemoryOp(false);
     op1->allocate(memoryCapacity / 4 * 3);
@@ -4405,7 +4345,9 @@ TEST_F(
     reclaimBeforeReachCapacityLimitWhenGlobalArbitrationDisabled) {
   const int64_t memoryCapacity = 128 * MB;
   setupMemory(
-      memoryCapacity, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.0, nullptr, false);
+      {.memoryCapacity = memoryCapacity,
+       .memoryReclaimThreadsHwMultiplier = 1.0,
+       .globalArtbitrationEnabled = false});
   std::shared_ptr<MockTask> task1 = addTask();
   MockMemoryOperator* op1 = task1->addMemoryOp(true);
   op1->allocate(memoryCapacity / 2);
diff --git a/velox/common/memory/tests/RawVectorTest.cpp b/velox/common/memory/tests/RawVectorTest.cpp
index 3d28f136d8cd..cfd9611b57c1 100644
--- a/velox/common/memory/tests/RawVectorTest.cpp
+++ b/velox/common/memory/tests/RawVectorTest.cpp
@@ -48,8 +48,19 @@ class RawVectorTest : public testing::WithParamInterface<TestParam>,
   std::shared_ptr<memory::MemoryPool> pool_;
 };
 
+raw_vector<int32_t> makeRawVector(
+    int64_t initialCapacity = 0,
+    memory::MemoryPool* pool = nullptr) {
+  if (pool != nullptr) {
+    return raw_vector<int32_t>(initialCapacity, pool);
+  } else {
+    return raw_vector<int32_t>(initialCapacity);
+  }
+}
+
 TEST_P(RawVectorTest, basic) {
-  raw_vector<int32_t> ints(pool_.get());
+  raw_vector<int32_t> ints =
+      makeRawVector(0, GetParam().useMemoryPool ? pool_.get() : nullptr);
   EXPECT_TRUE(ints.empty());
   EXPECT_EQ(0, ints.capacity());
   EXPECT_EQ(0, ints.size());
@@ -60,7 +71,8 @@ TEST_P(RawVectorTest, basic) {
 }
 
 TEST_P(RawVectorTest, padding) {
-  raw_vector<int32_t> ints(1000, pool_.get());
+  raw_vector<int32_t> ints =
+      makeRawVector(1000, GetParam().useMemoryPool ? pool_.get() : nullptr);
   EXPECT_EQ(1000, ints.size());
   // Check padding. Write a vector right below start and right after
   // capacity. These should fit and give no error with asan.
@@ -71,7 +83,8 @@ TEST_P(RawVectorTest, padding) {
 }
 
 TEST_P(RawVectorTest, resize) {
-  raw_vector<int32_t> ints(1000, pool_.get());
+  raw_vector<int32_t> ints =
+      makeRawVector(1000, GetParam().useMemoryPool ? pool_.get() : nullptr);
   ints.resize(ints.capacity());
   auto size = ints.size();
   ints[size - 1] = 12345;
@@ -105,17 +118,24 @@ TEST_P(RawVectorTest, copyAndMove) {
       {leaf0.get(), nullptr},
       {nullptr, leaf0.get()}};
   for (auto& data : testData) {
-    raw_vector<int32_t> ints(1000, data.sourcePool);
+    raw_vector<int32_t> ints = makeRawVector(1000, data.sourcePool);
     // a raw_vector is intentionally not initialized.
     memset(ints.data(), 11, ints.size() * sizeof(int32_t));
     ints[ints.size() - 1] = 12345;
-    raw_vector<int32_t> intsCopy(data.destPool);
+    raw_vector<int32_t> intsCopy;
+    if (data.destPool) {
+      intsCopy = raw_vector<int32_t>(data.destPool);
+    }
     intsCopy = ints;
     EXPECT_EQ(
         0, memcmp(ints.data(), intsCopy.data(), ints.size() * sizeof(int32_t)));
 
-    raw_vector<int32_t> intsMoved(data.destPool);
+    raw_vector<int32_t> intsMoved;
+    if (data.destPool) {
+      intsMoved = raw_vector<int32_t>(data.destPool);
+    }
     intsMoved = std::move(ints);
+    // NOLINTNEXTLINE(bugprone-use-after-move)
     EXPECT_TRUE(ints.empty());
 
     EXPECT_EQ(
@@ -128,7 +148,8 @@ TEST_P(RawVectorTest, copyAndMove) {
 }
 
 TEST_P(RawVectorTest, iota) {
-  raw_vector<int32_t> storage(pool_.get());
+  raw_vector<int32_t> storage =
+      makeRawVector(0, GetParam().useMemoryPool ? pool_.get() : nullptr);
   // Small sizes are preallocated.
   EXPECT_EQ(11, iota(12, storage)[11]);
   EXPECT_TRUE(storage.empty());
@@ -138,7 +159,8 @@ TEST_P(RawVectorTest, iota) {
 }
 
 TEST_P(RawVectorTest, iterator) {
-  raw_vector<int> data(pool_.get());
+  raw_vector<int> data =
+      makeRawVector(0, GetParam().useMemoryPool ? pool_.get() : nullptr);
   data.push_back(11);
   data.push_back(22);
   data.push_back(33);
@@ -150,7 +172,8 @@ TEST_P(RawVectorTest, iterator) {
 }
 
 TEST_P(RawVectorTest, toStdVector) {
-  raw_vector<int> data(pool_.get());
+  raw_vector<int> data =
+      makeRawVector(0, GetParam().useMemoryPool ? pool_.get() : nullptr);
   data.push_back(11);
   data.push_back(22);
   data.push_back(33);
diff --git a/velox/common/memory/tests/SharedArbitratorTest.cpp b/velox/common/memory/tests/SharedArbitratorTest.cpp
index f01cc043da5c..96b052d9c52c 100644
--- a/velox/common/memory/tests/SharedArbitratorTest.cpp
+++ b/velox/common/memory/tests/SharedArbitratorTest.cpp
@@ -365,11 +365,12 @@ DEBUG_ONLY_TEST_P(
       .queryCtx(queryCtx)
       .spillDirectory(spillDirectory->getPath())
       .config(core::QueryConfig::kSpillEnabled, "true")
-      .plan(PlanBuilder()
-                .values(vectors)
-                .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                .capturePlanNodeId(aggregationNodeId)
-                .planNode())
+      .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());
@@ -590,11 +591,12 @@ DEBUG_ONLY_TEST_P(SharedArbitrationTestWithThreadingModes, reclaimToOrderBy) {
           newQueryBuilder()
               .queryCtx(orderByQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .orderBy({"c0 ASC NULLS LAST"}, false)
-                        .capturePlanNodeId(orderByNodeId)
-                        .planNode())
+              .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);
@@ -607,12 +609,13 @@ DEBUG_ONLY_TEST_P(SharedArbitrationTestWithThreadingModes, reclaimToOrderBy) {
           newQueryBuilder()
               .queryCtx(fakeMemoryQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
+              .plan(
+                  PlanBuilder()
+                      .values(vectors)
+                      .addNode([&](std::string id, core::PlanNodePtr input) {
+                        return std::make_shared<FakeMemoryNode>(id, input);
+                      })
+                      .planNode())
               .assertResults("SELECT * FROM tmp");
     });
 
@@ -691,11 +694,12 @@ DEBUG_ONLY_TEST_P(
           newQueryBuilder()
               .queryCtx(aggregationQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                        .capturePlanNodeId(aggregationNodeId)
-                        .planNode())
+              .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());
@@ -709,12 +713,13 @@ DEBUG_ONLY_TEST_P(
           newQueryBuilder()
               .queryCtx(fakeMemoryQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
+              .plan(
+                  PlanBuilder()
+                      .values(vectors)
+                      .addNode([&](std::string id, core::PlanNodePtr input) {
+                        return std::make_shared<FakeMemoryNode>(id, input);
+                      })
+                      .planNode())
               .assertResults("SELECT * FROM tmp");
     });
 
@@ -755,7 +760,7 @@ DEBUG_ONLY_TEST_P(
     folly::EventCount taskPauseWait;
     auto taskPauseWaitKey = taskPauseWait.prepareWait();
 
-    const auto fakeAllocationSize = kMemoryCapacity - (32L << 20);
+    const auto fakeAllocationSize = kMemoryCapacity - (2L << 20);
 
     std::atomic<bool> injectAllocationOnce{true};
     fakeOperatorFactory_->setAllocationCallback([&](Operator* op) {
@@ -822,12 +827,13 @@ DEBUG_ONLY_TEST_P(
           newQueryBuilder()
               .queryCtx(fakeMemoryQueryCtx)
               .serialExecution(isSerialExecutionMode_)
-              .plan(PlanBuilder()
-                        .values(vectors)
-                        .addNode([&](std::string id, core::PlanNodePtr input) {
-                          return std::make_shared<FakeMemoryNode>(id, input);
-                        })
-                        .planNode())
+              .plan(
+                  PlanBuilder()
+                      .values(vectors)
+                      .addNode([&](std::string id, core::PlanNodePtr input) {
+                        return std::make_shared<FakeMemoryNode>(id, input);
+                      })
+                      .planNode())
               .assertResults("SELECT * FROM tmp");
     });
 
@@ -950,12 +956,13 @@ DEBUG_ONLY_TEST_P(
             .config(core::QueryConfig::kJoinSpillEnabled, "true")
             .config(core::QueryConfig::kSpillNumPartitionBits, "2")
             .maxDrivers(numDrivers)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .localPartition({"c0", "c1"})
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .localPartition(std::vector<std::string>{})
-                      .planNode())
+            .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"),
         "Aborted for external error");
@@ -1022,12 +1029,13 @@ DEBUG_ONLY_TEST_P(
                .config(core::QueryConfig::kSpillEnabled, "true")
                .config(core::QueryConfig::kJoinSpillEnabled, "true")
                .config(core::QueryConfig::kSpillNumPartitionBits, "2")
-               .plan(PlanBuilder()
-                         .values(vectors)
-                         .localPartition({"c0", "c1"})
-                         .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                         .localPartition(std::vector<std::string>{})
-                         .planNode())
+               .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");
   });
@@ -1194,23 +1202,25 @@ DEBUG_ONLY_TEST_P(
       if (sameDriver) {
         task = newQueryBuilder()
                    .queryCtx(queryCtx)
-                   .plan(PlanBuilder()
-                             .values(vectors)
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .capturePlanNodeId(aggregationNodeId)
-                             .localPartition(std::vector<std::string>{})
-                             .planNode())
+                   .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 = newQueryBuilder()
                    .queryCtx(queryCtx)
-                   .plan(PlanBuilder()
-                             .values(vectors)
-                             .localPartition({"c0", "c1"})
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .capturePlanNodeId(aggregationNodeId)
-                             .planNode())
+                   .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");
       }
@@ -1369,6 +1379,7 @@ TEST_P(
           if (e.errorCode() != error_code::kMemCapExceeded.c_str() &&
               e.errorCode() != error_code::kMemAborted.c_str() &&
               e.errorCode() != error_code::kMemAllocError.c_str() &&
+              e.errorCode() != error_code::kMemArbitrationTimeout.c_str() &&
               (e.message() != "Aborted for external error")) {
             std::rethrow_exception(std::current_exception());
           }
@@ -1424,12 +1435,20 @@ TEST_P(SharedArbitrationTestWithThreadingModes, reserveReleaseCounters) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SharedArbitrationTest,
     SharedArbitrationTestWithParallelExecutionModeOnly,
-    testing::ValuesIn(std::vector<TestParam>{{false}}));
+    testing::ValuesIn(std::vector<TestParam>{{false}}),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}", info.param.isSerialExecutionMode ? "serial" : "parallel");
+    });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SharedArbitrationTest,
     SharedArbitrationTestWithThreadingModes,
-    testing::ValuesIn(std::vector<TestParam>{{false}, {true}}));
+    testing::ValuesIn(std::vector<TestParam>{{false}, {true}}),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}", info.param.isSerialExecutionMode ? "serial" : "parallel");
+    });
 } // namespace facebook::velox::memory
 
 int main(int argc, char** argv) {
diff --git a/velox/common/memory/tests/SharedArbitratorTestUtil.h b/velox/common/memory/tests/SharedArbitratorTestUtil.h
index d8124599606d..8af5e3e05726 100644
--- a/velox/common/memory/tests/SharedArbitratorTestUtil.h
+++ b/velox/common/memory/tests/SharedArbitratorTestUtil.h
@@ -109,43 +109,4 @@ class ArbitrationParticipantTestHelper {
   ArbitrationParticipant* const participant_;
 };
 
-struct ArbitrationTestStructs {
-  ArbitrationParticipant::Config config;
-  std::shared_ptr<ArbitrationParticipant> participant{nullptr};
-  std::shared_ptr<ArbitrationOperation> operation{nullptr};
-
-  static ArbitrationTestStructs createArbitrationTestStructs(
-      const std::shared_ptr<MemoryPool>& pool,
-      uint64_t initCapacity = 1024,
-      uint64_t minCapacity = 128,
-      uint64_t fastExponentialGrowthCapacityLimit = 0,
-      double slowCapacityGrowRatio = 0,
-      uint64_t minFreeCapacity = 0,
-      double minFreeCapacityRatio = 0,
-      uint64_t minReclaimBytes = 128,
-      double minReclaimPct = 0,
-      uint64_t abortCapacityLimit = 512,
-      uint64_t requestBytes = 128,
-      uint64_t maxArbitrationTimeNs = 1'000'000'000'000UL /* 1'000s */) {
-    ArbitrationTestStructs ret{
-        .config = ArbitrationParticipant::Config(
-            initCapacity,
-            minCapacity,
-            fastExponentialGrowthCapacityLimit,
-            slowCapacityGrowRatio,
-            minFreeCapacity,
-            minFreeCapacityRatio,
-            minReclaimBytes,
-            minReclaimPct,
-            abortCapacityLimit)};
-    ret.participant = ArbitrationParticipant::create(
-        folly::Random::rand64(), pool, &ret.config);
-    ret.operation = std::make_shared<ArbitrationOperation>(
-        ScopedArbitrationParticipant(ret.participant, pool),
-        requestBytes,
-        maxArbitrationTimeNs);
-    return ret;
-  }
-};
-
 } // namespace facebook::velox::memory::test
diff --git a/velox/common/process/CMakeLists.txt b/velox/common/process/CMakeLists.txt
index 1ac1085e98e7..2fb856caa543 100644
--- a/velox/common/process/CMakeLists.txt
+++ b/velox/common/process/CMakeLists.txt
@@ -18,19 +18,22 @@ velox_add_library(
   StackTrace.cpp
   ThreadDebugInfo.cpp
   TraceContext.cpp
-  TraceHistory.cpp)
+  TraceHistory.cpp
+)
 
 velox_link_libraries(
   velox_process
   PUBLIC velox_file velox_flag_definitions Folly::folly
-  PRIVATE fmt::fmt gflags::gflags)
+  PRIVATE fmt::fmt gflags::gflags
+)
 
 # Profiler need not be part of the core Velox library
 add_library(velox_profiler OBJECT Profiler.cpp)
 target_link_libraries(
   velox_profiler
   PUBLIC velox_flag_definitions Folly::folly
-  PRIVATE fmt::fmt gflags::gflags glog::glog)
+  PRIVATE fmt::fmt gflags::gflags glog::glog
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/common/process/Profiler.cpp b/velox/common/process/Profiler.cpp
index 82a5e8365269..012c3ce35242 100644
--- a/velox/common/process/Profiler.cpp
+++ b/velox/common/process/Profiler.cpp
@@ -153,12 +153,13 @@ void Profiler::copyToResult(const std::string* data) {
     auto now = nowSeconds();
     auto elapsed = (now - sampleStartTime_);
     auto cpu = cpuSeconds();
-    out->append(fmt::format(
-        "Profile from {} to {} at {}% CPU\n\n",
+    out->append(
+        fmt::format(
+            "Profile from {} to {} at {}% CPU\n\n",
 
-        timeString(sampleStartTime_),
-        timeString(now),
-        100 * (cpu - cpuAtSampleStart_) / std::max<int64_t>(1, elapsed)));
+            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_();
@@ -191,18 +192,19 @@ std::thread Profiler::startSample() {
     // 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
+    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();
     }
diff --git a/velox/common/process/StackTrace.cpp b/velox/common/process/StackTrace.cpp
index 96cf0a91a25e..fb8ebc3db1df 100644
--- a/velox/common/process/StackTrace.cpp
+++ b/velox/common/process/StackTrace.cpp
@@ -46,14 +46,14 @@ StackTrace::StackTrace(int32_t skipFrames) {
 }
 
 StackTrace::StackTrace(const StackTrace& other) {
-  bt_pointers_ = other.bt_pointers_;
-  if (folly::test_once(other.bt_vector_flag_)) {
-    bt_vector_ = other.bt_vector_;
-    folly::call_once(bt_vector_flag_, [] {}); // Set the flag.
+  btPtrs_ = other.btPtrs_;
+  if (folly::test_once(other.btVectorFlag_)) {
+    btVector_ = other.btVector_;
+    folly::call_once(btVectorFlag_, [] {}); // Set the flag.
   }
-  if (folly::test_once(other.bt_flag_)) {
+  if (folly::test_once(other.btFlag_)) {
     bt_ = other.bt_;
-    folly::call_once(bt_flag_, [] {}); // Set the flag.
+    folly::call_once(btFlag_, [] {}); // Set the flag.
   }
 }
 
@@ -69,9 +69,9 @@ void StackTrace::create(int32_t skipFrames) {
   const int32_t kDefaultSkipFrameAdjust = 2; // ::create(), ::StackTrace()
   const int32_t kMaxFrames = 75;
 
-  bt_pointers_.clear();
-  uintptr_t btpointers[kMaxFrames];
-  ssize_t framecount = folly::symbolizer::getStackTrace(btpointers, kMaxFrames);
+  btPtrs_.clear();
+  uintptr_t btPtrs[kMaxFrames];
+  ssize_t framecount = folly::symbolizer::getStackTrace(btPtrs, kMaxFrames);
   if (framecount <= 0) {
     return;
   }
@@ -79,9 +79,9 @@ void StackTrace::create(int32_t skipFrames) {
   framecount = std::min(framecount, static_cast<ssize_t>(kMaxFrames));
   skipFrames = std::max(skipFrames + kDefaultSkipFrameAdjust, 0);
 
-  bt_pointers_.reserve(framecount - skipFrames);
+  btPtrs_.reserve(framecount - skipFrames);
   for (int32_t i = skipFrames; i < framecount; i++) {
-    bt_pointers_.push_back(reinterpret_cast<void*>(btpointers[i]));
+    btPtrs_.push_back(reinterpret_cast<void*>(btPtrs[i]));
   }
 }
 
@@ -89,32 +89,32 @@ void StackTrace::create(int32_t skipFrames) {
 // reporting functions
 
 const std::vector<std::string>& StackTrace::toStrVector() const {
-  folly::call_once(bt_vector_flag_, [&] {
+  folly::call_once(btVectorFlag_, [&] {
     size_t frame = 0;
     static folly::Indestructible<folly::fbstring> myname{
         folly::demangle(typeid(decltype(*this))) + "::"};
-    bt_vector_.reserve(bt_pointers_.size());
-    for (auto ptr : bt_pointers_) {
+    btVector_.reserve(btPtrs_.size());
+    for (auto ptr : btPtrs_) {
       auto framename = translateFrame(ptr);
-      if (folly::StringPiece(framename).startsWith(*myname)) {
+      if (framename.starts_with(*myname)) {
         continue; // ignore frames in the StackTrace class
       }
-      bt_vector_.push_back(fmt::format("# {:<2d} {}", frame++, framename));
+      btVector_.push_back(fmt::format("# {:<2d} {}", frame++, framename));
     }
   });
-  return bt_vector_;
+  return btVector_;
 }
 
 const std::string& StackTrace::toString() const {
-  folly::call_once(bt_flag_, [&] {
+  folly::call_once(btFlag_, [&] {
     const auto& vec = toStrVector();
     size_t needed = 0;
     for (const auto& frame : vec) {
       needed += frame.size() + 1;
     }
     bt_.reserve(needed);
-    for (const auto& frame_title : vec) {
-      bt_ += frame_title;
+    for (const auto& frameTitle : vec) {
+      bt_ += frameTitle;
       bt_ += '\n';
     }
   });
diff --git a/velox/common/process/StackTrace.h b/velox/common/process/StackTrace.h
index 1632d2468151..de114c1d9d32 100644
--- a/velox/common/process/StackTrace.h
+++ b/velox/common/process/StackTrace.h
@@ -25,65 +25,47 @@ namespace facebook::velox::process {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// TODO: Deprecate in favor of folly::symbolizer.
+/// TODO: Deprecate in favor of folly::symbolizer.
 class StackTrace {
  public:
-  /**
-   * Translate a frame pointer to file name and line number pair.
-   */
+  /// Translate a frame pointer to file name and line number pair.
   static std::string translateFrame(void* framePtr, bool lineNumbers = true);
 
-  /**
-   * Demangle a function name.
-   */
+  /// Demangle a function name.
   static std::string demangle(const char* mangled);
 
- public:
-  /**
-   * Constructor -- saves the current stack trace. By default, we skip the
-   * frames for StackTrace::StackTrace.  If you want those, you can pass
-   * '-2' to skipFrames.
-   */
+  /// Constructor -- saves the current stack trace. By default, we skip the
+  /// frames for StackTrace::StackTrace.  If you want those, you can pass '-2'
+  /// to skipFrames.
   explicit StackTrace(int32_t skipFrames = 0);
 
   StackTrace(const StackTrace& other);
   StackTrace& operator=(const StackTrace& other);
 
-  /**
-   * Generate an output of the written stack trace.
-   */
+  /// Generate an output of the written stack trace.
   const std::string& toString() const;
 
-  /**
-   * Generate a vector that for each position has the title of the frame.
-   */
+  /// Generate a vector that for each position has the title of the frame.
   const std::vector<std::string>& toStrVector() const;
 
-  /**
-   * Return the raw stack pointers.
-   */
+  /// Return the raw stack pointers.
   const std::vector<void*>& getStack() const {
-    return bt_pointers_;
+    return btPtrs_;
   }
 
-  /**
-   * Log stacktrace into a file under /tmp. If "out" is not null,
-   * also store translated stack trace into the variable.
-   * Returns the name of the generated file.
-   */
+  /// Log stacktrace into a file under /tmp. If "out" is not null, also store
+  /// translated stack trace into the variable. Returns the name of the
+  /// generated file.
   std::string log(const char* errorType, std::string* out = nullptr) const;
 
  private:
-  /**
-   * Record bt pointers.
-   */
+  // Record bt pointers.
   void create(int32_t skipFrames);
 
- private:
-  std::vector<void*> bt_pointers_;
-  mutable folly::once_flag bt_vector_flag_;
-  mutable std::vector<std::string> bt_vector_;
-  mutable folly::once_flag bt_flag_;
+  std::vector<void*> btPtrs_;
+  mutable folly::once_flag btVectorFlag_;
+  mutable std::vector<std::string> btVector_;
+  mutable folly::once_flag btFlag_;
   mutable std::string bt_;
 };
 
diff --git a/velox/common/process/tests/CMakeLists.txt b/velox/common/process/tests/CMakeLists.txt
index 5f36a9bacf94..6200f5474fd8 100644
--- a/velox/common/process/tests/CMakeLists.txt
+++ b/velox/common/process/tests/CMakeLists.txt
@@ -12,17 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_process_test ProfilerTest.cpp ThreadLocalRegistryTest.cpp
-                                  TraceContextTest.cpp TraceHistoryTest.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
-    velox_profiler
-    fmt::fmt
-    velox_time
-    GTest::gtest
-    GTest::gtest_main)
+  PRIVATE velox_process velox_profiler fmt::fmt velox_time GTest::gtest GTest::gtest_main
+)
diff --git a/velox/common/serialization/CMakeLists.txt b/velox/common/serialization/CMakeLists.txt
index c818597442d2..772987a61f35 100644
--- a/velox/common/serialization/CMakeLists.txt
+++ b/velox/common/serialization/CMakeLists.txt
@@ -14,8 +14,7 @@
 
 velox_add_library(velox_serialization DeserializationRegistry.cpp)
 
-velox_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/Serializable.h b/velox/common/serialization/Serializable.h
index befe526f4b84..148d12ae2c7c 100644
--- a/velox/common/serialization/Serializable.h
+++ b/velox/common/serialization/Serializable.h
@@ -143,9 +143,9 @@ class ISerializable {
   template <
       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) {
-    if (!val.hasValue()) {
+          std::is_same_v<T, std::optional<typename T::value_type>>>>
+  static folly::dynamic serialize(const std::optional<T>& val) {
+    if (!val.has_value()) {
       return nullptr;
     }
 
@@ -250,16 +250,16 @@ class ISerializable {
   template <
       typename T,
       typename = std::enable_if_t<
-          std::is_same_v<T, folly::Optional<typename T::value_type>>>>
-  static folly::Optional<
+          std::is_same_v<T, std::optional<typename T::value_type>>>>
+  static std::optional<
       decltype(ISerializable::deserialize<typename T::value_type>(
           std::declval<folly::dynamic>()))>
   deserialize(const folly::dynamic& obj, void* context = nullptr) {
     if (obj.isNull()) {
-      return folly::none;
+      return std::nullopt;
     }
     auto val = deserialize<typename T::value_type>(obj);
-    return folly::Optional<
+    return std::optional<
         decltype(ISerializable::deserialize<typename T::value_type>(
             std::declval<folly::dynamic>()))>(move(val));
   }
@@ -298,8 +298,7 @@ class ISerializable {
   }
 
   template <
-      template <typename, typename, typename...>
-      typename TMap,
+      template <typename, typename, typename...> typename TMap,
       typename TKey,
       typename TMapped,
       typename... TArgs,
diff --git a/velox/common/serialization/tests/CMakeLists.txt b/velox/common/serialization/tests/CMakeLists.txt
index 74b2baf630ea..a61f9252cace 100644
--- a/velox/common/serialization/tests/CMakeLists.txt
+++ b/velox/common/serialization/tests/CMakeLists.txt
@@ -17,10 +17,5 @@ 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
-    GTest::gtest_main)
+  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 90b60852b9b7..a9692a8da161 100644
--- a/velox/common/serialization/tests/SerializableTest.cpp
+++ b/velox/common/serialization/tests/SerializableTest.cpp
@@ -160,8 +160,7 @@ TEST(SerializableTest, context) {
 }
 
 template <
-    template <typename, typename, typename...>
-    typename TMap,
+    template <typename, typename, typename...> typename TMap,
     typename TKey,
     typename TMapped,
     typename TIt,
diff --git a/velox/common/testutil/CMakeLists.txt b/velox/common/testutil/CMakeLists.txt
index 6e8e05b849ff..5b5dca326d9d 100644
--- a/velox/common/testutil/CMakeLists.txt
+++ b/velox/common/testutil/CMakeLists.txt
@@ -12,13 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(velox_test_util ScopedTestTime.cpp TestValue.cpp
-                  RandomSeed.cpp)
+velox_add_library(velox_test_util ScopedTestTime.cpp TestValue.cpp RandomSeed.cpp)
 
-velox_link_libraries(
-  velox_test_util
-  PUBLIC velox_exception
-  PRIVATE glog::glog Folly::folly)
+velox_link_libraries(velox_test_util PUBLIC velox_exception PRIVATE glog::glog Folly::folly)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/common/testutil/OptionalEmpty.h b/velox/common/testutil/OptionalEmpty.h
index dc7a22029289..ace3e3ad0688 100644
--- a/velox/common/testutil/OptionalEmpty.h
+++ b/velox/common/testutil/OptionalEmpty.h
@@ -30,4 +30,13 @@ struct OptionalEmptyT {
 
 inline constexpr OptionalEmptyT optionalEmpty;
 
+struct EmptyT {
+  template <typename T>
+  operator std::vector<T>() const {
+    return {};
+  }
+};
+
+inline constexpr EmptyT Empty;
+
 } // namespace facebook::velox::common::testutil
diff --git a/velox/common/testutil/TestValue.cpp b/velox/common/testutil/TestValue.cpp
index b833b980ac42..bf14f66d8070 100644
--- a/velox/common/testutil/TestValue.cpp
+++ b/velox/common/testutil/TestValue.cpp
@@ -20,7 +20,7 @@ namespace facebook::velox::common::testutil {
 
 std::mutex TestValue::mutex_;
 bool TestValue::enabled_ = false;
-std::unordered_map<std::string, TestValue::Callback> TestValue::injectionMap_;
+folly::F14FastMap<std::string, TestValue::Callback> TestValue::injectionMap_;
 
 #ifndef NDEBUG
 void TestValue::enable() {
@@ -38,12 +38,12 @@ bool TestValue::enabled() {
   return enabled_;
 }
 
-void TestValue::clear(const std::string& injectionPoint) {
+void TestValue::clear(std::string_view injectionPoint) {
   std::lock_guard<std::mutex> l(mutex_);
   injectionMap_.erase(injectionPoint);
 }
 
-void TestValue::adjust(const std::string& injectionPoint, void* testData) {
+void TestValue::adjust(std::string_view injectionPoint, void* testData) {
   Callback injectionCb;
   {
     std::lock_guard<std::mutex> l(mutex_);
@@ -60,7 +60,7 @@ void TestValue::disable() {}
 bool TestValue::enabled() {
   return false;
 }
-void TestValue::clear(const std::string& injectionPoint) {}
+void TestValue::clear(std::string_view injectionPoint) {}
 #endif
 
 } // namespace facebook::velox::common::testutil
diff --git a/velox/common/testutil/TestValue.h b/velox/common/testutil/TestValue.h
index ba988a6935bb..321936bd67cd 100644
--- a/velox/common/testutil/TestValue.h
+++ b/velox/common/testutil/TestValue.h
@@ -15,9 +15,10 @@
  */
 #pragma once
 
+#include <folly/container/F14Map.h>
 #include <mutex>
 #include <string>
-#include <unordered_map>
+#include <string_view>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Macros.h"
@@ -45,24 +46,24 @@ class TestValue {
   /// injected callback hook.
   template <typename T>
   static void set(
-      const std::string& injectionPoint,
+      std::string_view injectionPoint,
       std::function<void(T*)> injectionCb);
 
   /// Invoked by the test code to unregister a callback hook at the specified
   /// execution point.
-  static void clear(const std::string& injectionPoint);
+  static void clear(std::string_view injectionPoint);
 
   /// Invoked by the production code to try to invoke the test callback hook
   /// with 'testData' if there is one registered at the specified execution
   /// point. 'testData' capture the mutable production execution state.
-  static void adjust(const std::string& injectionPoint, void* testData);
+  static void adjust(std::string_view injectionPoint, void* testData);
 
  private:
   using Callback = std::function<void(void*)>;
 
   static std::mutex mutex_;
   static bool enabled_;
-  static std::unordered_map<std::string, Callback> injectionMap_;
+  static folly::F14FastMap<std::string, Callback> injectionMap_;
 };
 
 class ScopedTestValue {
@@ -79,13 +80,13 @@ class ScopedTestValue {
   }
 
  private:
-  const std::string point_;
+  std::string point_;
 };
 
 #ifndef NDEBUG
 template <typename T>
 void TestValue::set(
-    const std::string& injectionPoint,
+    std::string_view injectionPoint,
     std::function<void(T*)> injectionCb) {
   std::lock_guard<std::mutex> l(mutex_);
   if (!enabled_) {
@@ -99,15 +100,14 @@ void TestValue::set(
 #else
 template <typename T>
 void TestValue::set(
-    const std::string& injectionPoint,
+    std::string_view injectionPoint,
     std::function<void(T*)> injectionCb) {}
 #endif
 
 #ifdef NDEBUG
 // Keep the definition in header so that it can be inlined (elided).
-inline void TestValue::adjust(
-    const std::string& injectionPoint,
-    void* testData) {}
+inline void TestValue::adjust(std::string_view injectionPoint, void* testData) {
+}
 #endif
 
 #define SCOPED_TESTVALUE_SET(point, ...)                              \
diff --git a/velox/common/testutil/tests/CMakeLists.txt b/velox/common/testutil/tests/CMakeLists.txt
index d164600656a3..727b492bf564 100644
--- a/velox/common/testutil/tests/CMakeLists.txt
+++ b/velox/common/testutil/tests/CMakeLists.txt
@@ -12,15 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 include(GoogleTest)
-add_executable(velox_test_util_test TestScopedTestTime.cpp TestValueTest.cpp)
+add_executable(velox_test_util_test CastsTest.cpp 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_exec
-    velox_time
-    GTest::gtest
-    GTest::gtest_main)
+  PRIVATE velox_test_util velox_exception velox_exec velox_time GTest::gtest GTest::gtest_main
+)
diff --git a/velox/common/testutil/tests/CastsTest.cpp b/velox/common/testutil/tests/CastsTest.cpp
new file mode 100644
index 000000000000..b5a9cf600527
--- /dev/null
+++ b/velox/common/testutil/tests/CastsTest.cpp
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <memory>
+
+#include "velox/common/Casts.h"
+#include "velox/common/base/tests/GTestUtils.h"
+
+namespace facebook::velox {
+
+namespace {
+
+// Test classes for inheritance hierarchy
+class BaseClass {
+ public:
+  virtual ~BaseClass() = default;
+  virtual int getValue() const {
+    return 42;
+  }
+};
+
+class DerivedClass : public BaseClass {
+ public:
+  int getValue() const override {
+    return 100;
+  }
+
+  int getDerivedValue() const {
+    return 200;
+  }
+};
+
+class AnotherDerivedClass : public BaseClass {
+ public:
+  int getValue() const override {
+    return 300;
+  }
+};
+
+class UnrelatedClass {
+ public:
+  virtual ~UnrelatedClass() = default;
+  int getValue() const {
+    return 999;
+  }
+};
+
+} // namespace
+
+class CastsTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    basePtr_ = std::make_shared<BaseClass>();
+    derivedPtr_ = std::make_shared<DerivedClass>();
+    anotherDerivedPtr_ = std::make_shared<AnotherDerivedClass>();
+    unrelatedPtr_ = std::make_shared<UnrelatedClass>();
+
+    baseUniquePtr_ = std::make_unique<BaseClass>();
+    derivedUniquePtr_ = std::make_unique<DerivedClass>();
+
+    baseRawPtr_ = new BaseClass();
+    derivedRawPtr_ = new DerivedClass();
+  }
+
+  void TearDown() override {
+    delete baseRawPtr_;
+    delete derivedRawPtr_;
+  }
+
+  std::shared_ptr<BaseClass> basePtr_;
+  std::shared_ptr<DerivedClass> derivedPtr_;
+  std::shared_ptr<AnotherDerivedClass> anotherDerivedPtr_;
+  std::shared_ptr<UnrelatedClass> unrelatedPtr_;
+
+  std::unique_ptr<BaseClass> baseUniquePtr_;
+  std::unique_ptr<DerivedClass> derivedUniquePtr_;
+
+  BaseClass* baseRawPtr_;
+  DerivedClass* derivedRawPtr_;
+};
+
+// Tests for checkedPointerCast with shared_ptr
+TEST_F(CastsTest, checkedPointerCastSharedPtrSuccess) {
+  // Cast derived to base (should always work)
+  auto result = checkedPointerCast<BaseClass>(derivedPtr_);
+  EXPECT_NE(result, nullptr);
+  EXPECT_EQ(result->getValue(), 100);
+
+  // Cast base to derived when it actually is derived
+  std::shared_ptr<BaseClass> basePtrToDerived = derivedPtr_;
+  auto derivedResult = checkedPointerCast<DerivedClass>(basePtrToDerived);
+  EXPECT_NE(derivedResult, nullptr);
+  EXPECT_EQ(derivedResult->getValue(), 100);
+  EXPECT_EQ(derivedResult->getDerivedValue(), 200);
+}
+
+TEST_F(CastsTest, checkedPointerCastSharedPtrFailure) {
+  // Try to cast base to derived when it's not actually derived
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(basePtr_), "");
+
+  // Try to cast to unrelated class
+  VELOX_ASSERT_THROW(checkedPointerCast<UnrelatedClass>(derivedPtr_), "");
+}
+
+TEST_F(CastsTest, checkedPointerCastSharedPtrNullInput) {
+  std::shared_ptr<BaseClass> nullPtr;
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(nullPtr), "");
+}
+
+// Tests for checkedPointerCast with unique_ptr
+TEST_F(CastsTest, checkedPointerCastUniquePtrSuccess) {
+  // Cast derived to base
+  auto derivedForCast = std::make_unique<DerivedClass>();
+  auto result = checkedPointerCast<BaseClass>(std::move(derivedForCast));
+  EXPECT_NE(result, nullptr);
+  EXPECT_EQ(result->getValue(), 100);
+
+  // Cast base to derived when it actually is derived
+  std::unique_ptr<BaseClass> basePtrToDerived =
+      std::make_unique<DerivedClass>();
+  auto derivedResult =
+      checkedPointerCast<DerivedClass>(std::move(basePtrToDerived));
+  EXPECT_NE(derivedResult, nullptr);
+  EXPECT_EQ(derivedResult->getValue(), 100);
+  EXPECT_EQ(derivedResult->getDerivedValue(), 200);
+}
+
+TEST_F(CastsTest, checkedPointerCastUniquePtrFailure) {
+  // Try to cast base to derived when it's not actually derived
+  auto baseForCast = std::make_unique<BaseClass>();
+  VELOX_ASSERT_THROW(
+      checkedPointerCast<DerivedClass>(std::move(baseForCast)), "");
+}
+
+TEST_F(CastsTest, checkedPointerCastUniquePtrNullInput) {
+  std::unique_ptr<BaseClass> nullPtr;
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(std::move(nullPtr)), "");
+}
+
+// Tests for checkedPointerCast with raw pointers
+TEST_F(CastsTest, checkedPointerCastRawPtrSuccess) {
+  // Cast derived to base
+  auto result = checkedPointerCast<BaseClass>(derivedRawPtr_);
+  EXPECT_NE(result, nullptr);
+  EXPECT_EQ(result->getValue(), 100);
+
+  // Cast base to derived when it actually is derived
+  BaseClass* basePtrToDerived = derivedRawPtr_;
+  auto derivedResult = checkedPointerCast<DerivedClass>(basePtrToDerived);
+  EXPECT_NE(derivedResult, nullptr);
+  EXPECT_EQ(derivedResult->getValue(), 100);
+  EXPECT_EQ(derivedResult->getDerivedValue(), 200);
+}
+
+TEST_F(CastsTest, checkedPointerCastRawPtrFailure) {
+  // Try to cast base to derived when it's not actually derived
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(baseRawPtr_), "");
+}
+
+TEST_F(CastsTest, checkedPointerCastRawPtrNullInput) {
+  BaseClass* nullPtr = nullptr;
+  VELOX_ASSERT_THROW(checkedPointerCast<DerivedClass>(nullPtr), "");
+}
+
+// Tests for staticUniquePointerCast
+TEST_F(CastsTest, staticUniquePointerCastSuccess) {
+  // Create a unique_ptr to derived and cast to base
+  auto derivedForCast = std::make_unique<DerivedClass>();
+  auto originalPtr = derivedForCast.get();
+  auto result = staticUniquePointerCast<BaseClass>(std::move(derivedForCast));
+
+  EXPECT_NE(result, nullptr);
+  EXPECT_EQ(result.get(), originalPtr); // Should be the same pointer
+  EXPECT_EQ(result->getValue(), 100);
+}
+
+TEST_F(CastsTest, staticUniquePointerCastNullInput) {
+  std::unique_ptr<DerivedClass> nullPtr;
+  VELOX_ASSERT_THROW(
+      staticUniquePointerCast<BaseClass>(std::move(nullPtr)), "");
+}
+
+// Tests for isInstanceOf with shared_ptr
+TEST_F(CastsTest, isInstanceOfSharedPtr) {
+  // Test positive cases
+  EXPECT_TRUE(isInstanceOf<BaseClass>(derivedPtr_));
+  EXPECT_TRUE(isInstanceOf<DerivedClass>(derivedPtr_));
+  EXPECT_TRUE(isInstanceOf<BaseClass>(anotherDerivedPtr_));
+  EXPECT_TRUE(isInstanceOf<AnotherDerivedClass>(anotherDerivedPtr_));
+
+  // Test negative cases
+  EXPECT_FALSE(isInstanceOf<DerivedClass>(basePtr_));
+  EXPECT_FALSE(isInstanceOf<AnotherDerivedClass>(derivedPtr_));
+  EXPECT_FALSE(isInstanceOf<DerivedClass>(anotherDerivedPtr_));
+  EXPECT_FALSE(isInstanceOf<UnrelatedClass>(derivedPtr_));
+}
+
+TEST_F(CastsTest, isInstanceOfSharedPtrNullInput) {
+  std::shared_ptr<BaseClass> nullPtr;
+  VELOX_ASSERT_THROW(isInstanceOf<DerivedClass>(nullPtr), "");
+}
+
+// Tests for isInstanceOf with unique_ptr
+TEST_F(CastsTest, isInstanceOfUniquePtr) {
+  // Test positive cases
+  EXPECT_TRUE(isInstanceOf<BaseClass>(derivedUniquePtr_));
+  EXPECT_TRUE(isInstanceOf<DerivedClass>(derivedUniquePtr_));
+
+  // Test negative cases
+  EXPECT_FALSE(isInstanceOf<DerivedClass>(baseUniquePtr_));
+  EXPECT_FALSE(isInstanceOf<AnotherDerivedClass>(derivedUniquePtr_));
+}
+
+TEST_F(CastsTest, isInstanceOfUniquePtrNullInput) {
+  std::unique_ptr<BaseClass> nullPtr;
+  VELOX_ASSERT_THROW(isInstanceOf<DerivedClass>(nullPtr), "");
+}
+
+// Tests for isInstanceOf with raw pointers
+TEST_F(CastsTest, isInstanceOfRawPtr) {
+  // Test positive cases
+  EXPECT_TRUE(isInstanceOf<BaseClass>(derivedRawPtr_));
+  EXPECT_TRUE(isInstanceOf<DerivedClass>(derivedRawPtr_));
+
+  // Test negative cases
+  EXPECT_FALSE(isInstanceOf<DerivedClass>(baseRawPtr_));
+  EXPECT_FALSE(isInstanceOf<AnotherDerivedClass>(derivedRawPtr_));
+}
+
+TEST_F(CastsTest, isInstanceOfRawPtrNullInput) {
+  BaseClass* nullPtr = nullptr;
+  VELOX_ASSERT_THROW(isInstanceOf<DerivedClass>(nullPtr), "");
+}
+
+// Test error messages contain useful information
+TEST_F(CastsTest, errorMessageContent) {
+  try {
+    checkedPointerCast<DerivedClass>(basePtr_);
+    FAIL() << "Expected VeloxException to be thrown";
+  } catch (const VeloxException& e) {
+    const std::string& message = e.message();
+    // Check that the error message contains type information
+    EXPECT_TRUE(message.find("Failed to cast") != std::string::npos);
+    EXPECT_TRUE(message.find("BaseClass") != std::string::npos);
+    EXPECT_TRUE(message.find("DerivedClass") != std::string::npos);
+  }
+}
+
+// Test that successful casts preserve object identity
+TEST_F(CastsTest, objectIdentityPreserved) {
+  // For shared_ptr
+  std::shared_ptr<BaseClass> basePtrToDerived = derivedPtr_;
+  auto castedShared = checkedPointerCast<DerivedClass>(basePtrToDerived);
+  EXPECT_EQ(castedShared.get(), derivedPtr_.get());
+
+  // For raw ptr
+  BaseClass* basePtrToDerivedRaw = derivedRawPtr_;
+  auto castedRaw = checkedPointerCast<DerivedClass>(basePtrToDerivedRaw);
+  EXPECT_EQ(castedRaw, derivedRawPtr_);
+}
+
+// Test exception safety for unique_ptr casting
+TEST_F(CastsTest, uniquePtrExceptionSafety) {
+  auto baseForCast = std::make_unique<BaseClass>();
+
+  try {
+    checkedPointerCast<DerivedClass>(std::move(baseForCast));
+    FAIL() << "Expected VeloxException to be thrown";
+  } catch (const VeloxException&) {
+    // The unique_ptr should have been restored and the object should still
+    // exist We can't directly test this without access to the internal
+    // implementation, but the test framework will detect memory leaks if the
+    // object was lost
+  }
+}
+
+} // namespace facebook::velox
diff --git a/velox/common/time/CMakeLists.txt b/velox/common/time/CMakeLists.txt
index 8c9e39f51835..46c878968f03 100644
--- a/velox/common/time/CMakeLists.txt
+++ b/velox/common/time/CMakeLists.txt
@@ -16,5 +16,4 @@ if(${VELOX_BUILD_TESTING})
 endif()
 
 velox_add_library(velox_time CpuWallTimer.cpp Timer.cpp)
-velox_link_libraries(velox_time PUBLIC velox_process velox_test_util
-                                       Folly::folly fmt::fmt)
+velox_link_libraries(velox_time PUBLIC velox_process velox_test_util Folly::folly fmt::fmt)
diff --git a/velox/common/time/CpuWallTimer.cpp b/velox/common/time/CpuWallTimer.cpp
index e21944b05d1c..93537bb13d62 100644
--- a/velox/common/time/CpuWallTimer.cpp
+++ b/velox/common/time/CpuWallTimer.cpp
@@ -18,15 +18,19 @@
 
 namespace facebook::velox {
 
-CpuWallTimer::CpuWallTimer(CpuWallTiming& timing) : timing_(timing) {
+CpuWallTimer::CpuWallTimer(CpuWallTiming& timing)
+    : wallTimeStart_(std::chrono::steady_clock::now()),
+      cpuTimeStart_(process::threadCpuNanos()),
+      timing_(timing) {
   ++timing_.count;
-  cpuTimeStart_ = process::threadCpuNanos();
-  wallTimeStart_ = std::chrono::steady_clock::now();
 }
 
 CpuWallTimer::~CpuWallTimer() {
+  // 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.
   timing_.cpuNanos += process::threadCpuNanos() - cpuTimeStart_;
-  auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
+  const auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(
       std::chrono::steady_clock::now() - wallTimeStart_);
   timing_.wallNanos += duration.count();
 }
diff --git a/velox/common/time/CpuWallTimer.h b/velox/common/time/CpuWallTimer.h
index 430ec614b1e6..06feb989848c 100644
--- a/velox/common/time/CpuWallTimer.h
+++ b/velox/common/time/CpuWallTimer.h
@@ -18,19 +18,25 @@
 #include <fmt/format.h>
 #include <chrono>
 
+#include "velox/common/base/Macros.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/process/ProcessBase.h"
 
 namespace facebook::velox {
 
-// Tracks call count and elapsed CPU and wall time for a repeating operation.
+/// Tracks call count and elapsed CPU and wall time for a repeating operation.
 struct CpuWallTiming {
   uint64_t count = 0;
   uint64_t wallNanos = 0;
   uint64_t cpuNanos = 0;
 
+  auto operator<=>(const CpuWallTiming&) const = default;
+
   void add(const CpuWallTiming& other) {
+    // Suppress spurious warnings in GCC 13.
+    VELOX_SUPPRESS_STRINGOP_OVERFLOW_WARNING
     count += other.count;
+    VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
     cpuNanos += other.cpuNanos;
     wallNanos += other.wallNanos;
   }
@@ -50,15 +56,17 @@ struct CpuWallTiming {
   }
 };
 
-// Adds elapsed CPU and wall time to a CpuWallTiming.
+/// Adds elapsed CPU and wall time to a CpuWallTiming.
 class CpuWallTimer {
  public:
   explicit CpuWallTimer(CpuWallTiming& timing);
   ~CpuWallTimer();
 
  private:
-  uint64_t cpuTimeStart_;
-  std::chrono::steady_clock::time_point wallTimeStart_;
+  // 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_;
   CpuWallTiming& timing_;
 };
 
@@ -73,8 +81,8 @@ class DeltaCpuWallTimeStopWatch {
     // 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 =
+    const uint64_t cpuTimeDuration = process::threadCpuNanos() - cpuTimeStart_;
+    const uint64_t wallTimeDuration =
         std::chrono::duration_cast<std::chrono::nanoseconds>(
             std::chrono::steady_clock::now() - wallTimeStart_)
             .count();
diff --git a/velox/common/time/tests/CMakeLists.txt b/velox/common/time/tests/CMakeLists.txt
index 2b2bc5caa9dc..cb602e651a35 100644
--- a/velox/common/time/tests/CMakeLists.txt
+++ b/velox/common/time/tests/CMakeLists.txt
@@ -15,8 +15,6 @@ include(GoogleTest)
 
 add_executable(velox_time_test CpuWallTimerTest.cpp)
 
-target_link_libraries(
-  velox_time_test
-  PRIVATE velox_time glog::glog GTest::gtest 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 743ecbcaac00..4568f83650d9 100644
--- a/velox/connectors/CMakeLists.txt
+++ b/velox/connectors/CMakeLists.txt
@@ -29,6 +29,10 @@ if(${VELOX_ENABLE_TPCH_CONNECTOR})
   add_subdirectory(tpch)
 endif()
 
+if(${VELOX_ENABLE_TPCDS_CONNECTOR})
+  add_subdirectory(tpcds)
+endif()
+
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
diff --git a/velox/connectors/Connector.cpp b/velox/connectors/Connector.cpp
index cddbc31d8de1..ba9d1a9c4154 100644
--- a/velox/connectors/Connector.cpp
+++ b/velox/connectors/Connector.cpp
@@ -18,12 +18,6 @@
 
 namespace facebook::velox::connector {
 namespace {
-std::unordered_map<std::string, std::shared_ptr<ConnectorFactory>>&
-connectorFactories() {
-  static std::unordered_map<std::string, std::shared_ptr<ConnectorFactory>>
-      factories;
-  return factories;
-}
 
 std::unordered_map<std::string, std::shared_ptr<Connector>>& connectors() {
   static std::unordered_map<std::string, std::shared_ptr<Connector>> connectors;
@@ -43,35 +37,6 @@ std::string DataSink::Stats::toString() const {
       spillStats.toString());
 }
 
-bool registerConnectorFactory(std::shared_ptr<ConnectorFactory> factory) {
-  bool ok =
-      connectorFactories().insert({factory->connectorName(), factory}).second;
-  VELOX_CHECK(
-      ok,
-      "ConnectorFactory with name '{}' is already registered",
-      factory->connectorName());
-  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);
-  VELOX_CHECK(
-      it != connectorFactories().end(),
-      "ConnectorFactory with name '{}' not registered",
-      connectorName);
-  return it->second;
-}
-
 bool registerConnector(std::shared_ptr<Connector> connector) {
   bool ok = connectors().insert({connector->connectorId(), connector}).second;
   VELOX_CHECK(
@@ -95,6 +60,10 @@ std::shared_ptr<Connector> getConnector(const std::string& connectorId) {
   return it->second;
 }
 
+bool hasConnector(const std::string& connectorId) {
+  return connectors().find(connectorId) != connectors().end();
+}
+
 const std::unordered_map<std::string, std::shared_ptr<Connector>>&
 getAllConnectors() {
   return connectors();
@@ -130,27 +99,18 @@ std::shared_ptr<cache::ScanTracker> Connector::getTracker(
   });
 }
 
-std::string commitStrategyToString(CommitStrategy commitStrategy) {
-  switch (commitStrategy) {
-    case CommitStrategy::kNoCommit:
-      return "NO_COMMIT";
-    case CommitStrategy::kTaskCommit:
-      return "TASK_COMMIT";
-    default:
-      VELOX_UNREACHABLE(
-          "UNKOWN COMMIT STRATEGY: {}", static_cast<int>(commitStrategy));
-  }
+namespace {
+const folly::F14FastMap<CommitStrategy, std::string_view>&
+commitStrategyNames() {
+  static const folly::F14FastMap<CommitStrategy, std::string_view> kNames = {
+      {CommitStrategy::kNoCommit, "NO_COMMIT"},
+      {CommitStrategy::kTaskCommit, "TASK_COMMIT"},
+  };
+  return kNames;
 }
+} // namespace
 
-CommitStrategy stringToCommitStrategy(const std::string& strategy) {
-  if (strategy == "NO_COMMIT") {
-    return CommitStrategy::kNoCommit;
-  } else if (strategy == "TASK_COMMIT") {
-    return CommitStrategy::kTaskCommit;
-  } else {
-    VELOX_UNREACHABLE("UNKOWN COMMIT STRATEGY: {}", strategy);
-  }
-}
+VELOX_DEFINE_ENUM_NAME(CommitStrategy, commitStrategyNames);
 
 folly::dynamic ColumnHandle::serializeBase(std::string_view name) {
   folly::dynamic obj = folly::dynamic::object;
@@ -173,4 +133,5 @@ folly::dynamic ConnectorTableHandle::serializeBase(
 folly::dynamic ConnectorTableHandle::serialize() const {
   return serializeBase("ConnectorTableHandle");
 }
+
 } // namespace facebook::velox::connector
diff --git a/velox/connectors/Connector.h b/velox/connectors/Connector.h
index 96b0e045830d..2eb85594c09c 100644
--- a/velox/connectors/Connector.h
+++ b/velox/connectors/Connector.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "folly/CancellationToken.h"
+#include "velox/common/Enums.h"
 #include "velox/common/base/AsyncSource.h"
 #include "velox/common/base/PrefixSortConfig.h"
 #include "velox/common/base/RuntimeMetrics.h"
@@ -23,9 +24,11 @@
 #include "velox/common/base/SpillStats.h"
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/caching/ScanTracker.h"
+#include "velox/common/file/TokenProvider.h"
 #include "velox/common/future/VeloxPromise.h"
 #include "velox/core/ExpressionEvaluator.h"
-#include "velox/type/Subfield.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/type/Filter.h"
 #include "velox/vector/ComplexVector.h"
 
 #include <folly/Synchronized.h>
@@ -36,9 +39,6 @@ class Config;
 namespace facebook::velox::wave {
 class WaveDataSource;
 }
-namespace facebook::velox::common {
-class Filter;
-}
 namespace facebook::velox::config {
 class ConfigBase;
 }
@@ -77,7 +77,15 @@ struct ConnectorSplit : public ISerializable {
     return nullptr;
   }
 
-  virtual ~ConnectorSplit() {}
+  virtual uint64_t size() const {
+    return 0;
+  }
+
+  virtual ~ConnectorSplit() {
+    if (dataSource) {
+      dataSource->close();
+    }
+  }
 
   virtual std::string toString() const {
     return fmt::format(
@@ -92,8 +100,10 @@ class ColumnHandle : public ISerializable {
  public:
   virtual ~ColumnHandle() = default;
 
-  virtual const std::string& name() const {
-    VELOX_UNSUPPORTED();
+  virtual const std::string& name() const = 0;
+
+  virtual std::string toString() const {
+    return name();
   }
 
   folly::dynamic serialize() const override;
@@ -104,6 +114,12 @@ class ColumnHandle : public ISerializable {
 
 using ColumnHandlePtr = std::shared_ptr<const ColumnHandle>;
 
+using ColumnHandleMap =
+    std::unordered_map<std::string, connector::ColumnHandlePtr>;
+
+class ConnectorTableHandle;
+using ConnectorTableHandlePtr = std::shared_ptr<const ConnectorTableHandle>;
+
 class ConnectorTableHandle : public ISerializable {
  public:
   explicit ConnectorTableHandle(std::string connectorId)
@@ -111,26 +127,22 @@ class ConnectorTableHandle : public ISerializable {
 
   virtual ~ConnectorTableHandle() = default;
 
-  virtual std::string toString() const {
-    VELOX_NYI();
-  }
-
   const std::string& connectorId() const {
     return connectorId_;
   }
 
-  /// Returns the connector-dependent table name. Used with
-  /// ConnectorMetadata. Implementations need to supply a definition
-  /// to work with metadata.
-  virtual const std::string& name() const {
-    VELOX_UNSUPPORTED();
-  }
+  /// Returns the table name.
+  virtual const std::string& name() const = 0;
 
   /// Returns true if the connector table handle supports index lookup.
   virtual bool supportsIndexLookup() const {
     return false;
   }
 
+  virtual std::string toString() const {
+    return name();
+  }
+
   virtual folly::dynamic serialize() const override;
 
  protected:
@@ -140,8 +152,6 @@ class ConnectorTableHandle : public ISerializable {
   const std::string connectorId_;
 };
 
-using ConnectorTableHandlePtr = std::shared_ptr<const ConnectorTableHandle>;
-
 /// Represents a request for writing to connector
 class ConnectorInsertTableHandle : public ISerializable {
  public:
@@ -160,26 +170,18 @@ class ConnectorInsertTableHandle : public ISerializable {
   }
 };
 
+using ConnectorInsertTableHandlePtr =
+    std::shared_ptr<const ConnectorInsertTableHandle>;
+
 /// Represents the commit strategy for writing to connector.
 enum class CommitStrategy {
   /// No more commit actions are needed.
   kNoCommit,
   /// Task level commit is needed.
-  kTaskCommit
+  kTaskCommit,
 };
 
-/// Return a string encoding of the given commit strategy.
-std::string commitStrategyToString(CommitStrategy commitStrategy);
-
-FOLLY_ALWAYS_INLINE std::ostream& operator<<(
-    std::ostream& os,
-    CommitStrategy strategy) {
-  os << commitStrategyToString(strategy);
-  return os;
-}
-
-/// Return a commit strategy of the given string encoding.
-CommitStrategy stringToCommitStrategy(const std::string& strategy);
+VELOX_DECLARE_ENUM_NAME(CommitStrategy);
 
 /// Writes data received from table writer operator into different partitions
 /// based on the specific table layout. The actual implementation doesn't need
@@ -225,6 +227,10 @@ class DataSink {
 
   /// Returns the stats of this data sink.
   virtual Stats stats() const = 0;
+
+  virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() const {
+    return {};
+  }
 };
 
 class DataSource {
@@ -247,6 +253,10 @@ class DataSource {
       uint64_t size,
       velox::ContinueFuture& future) = 0;
 
+  virtual const common::SubfieldFilters* getFilters() const {
+    return nullptr;
+  }
+
   /// Add dynamically generated filter.
   /// @param outputChannel index into outputType specified in
   /// Connector::createDataSource() that identifies the column this filter
@@ -261,7 +271,9 @@ class DataSource {
   /// Returns the number of input rows processed so far.
   virtual uint64_t getCompletedRows() = 0;
 
-  virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() = 0;
+  virtual std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() {
+    return {};
+  }
 
   /// 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
@@ -361,6 +373,11 @@ class IndexSource {
    public:
     virtual ~LookupResultIterator() = default;
 
+    /// Invoked to check if there are more lookup results available to fetch.
+    /// Returns true if there are more results, false otherwise. This allows
+    /// the caller to determine whether to continue calling 'next()'.
+    virtual bool hasNext() = 0;
+
     /// Invoked to fetch up to 'size' number of output rows. Returns nullptr if
     /// all the lookup results have been fetched. Returns std::nullopt and sets
     /// the 'future' if started asynchronous work and needs to wait for it to
@@ -399,7 +416,8 @@ class ConnectorQueryCtx {
       int driverId,
       const std::string& sessionTimezone,
       bool adjustTimestampToTimezone = false,
-      folly::CancellationToken cancellationToken = {})
+      folly::CancellationToken cancellationToken = {},
+      std::shared_ptr<filesystems::TokenProvider> tokenProvider = {})
       : operatorPool_(operatorPool),
         connectorPool_(connectorPool),
         sessionProperties_(sessionProperties),
@@ -414,7 +432,8 @@ class ConnectorQueryCtx {
         planNodeId_(planNodeId),
         sessionTimezone_(sessionTimezone),
         adjustTimestampToTimezone_(adjustTimestampToTimezone),
-        cancellationToken_(std::move(cancellationToken)) {
+        cancellationToken_(std::move(cancellationToken)),
+        fsTokenProvider_(std::move(tokenProvider)) {
     VELOX_CHECK_NOT_NULL(sessionProperties);
   }
 
@@ -502,6 +521,18 @@ class ConnectorQueryCtx {
     selectiveNimbleReaderEnabled_ = value;
   }
 
+  core::QueryConfig::RowSizeTrackingMode rowSizeTrackingMode() const {
+    return rowSizeTrackingEnabled_;
+  }
+
+  void setRowSizeTrackingMode(core::QueryConfig::RowSizeTrackingMode value) {
+    rowSizeTrackingEnabled_ = value;
+  }
+
+  std::shared_ptr<filesystems::TokenProvider> fsTokenProvider() const {
+    return fsTokenProvider_;
+  }
+
  private:
   memory::MemoryPool* const operatorPool_;
   memory::MemoryPool* const connectorPool_;
@@ -518,14 +549,40 @@ class ConnectorQueryCtx {
   const std::string sessionTimezone_;
   const bool adjustTimestampToTimezone_;
   const folly::CancellationToken cancellationToken_;
+  const std::shared_ptr<filesystems::TokenProvider> fsTokenProvider_;
   bool selectiveNimbleReaderEnabled_{false};
+  core::QueryConfig::RowSizeTrackingMode rowSizeTrackingEnabled_{
+      core::QueryConfig::RowSizeTrackingMode::ENABLED_FOR_ALL};
 };
 
-class ConnectorMetadata;
+class Connector;
+
+class ConnectorFactory {
+ public:
+  explicit ConnectorFactory(const char* name) : name_(name) {}
+
+  virtual ~ConnectorFactory() = default;
+
+  const std::string& connectorName() const {
+    return name_;
+  }
+
+  virtual std::shared_ptr<Connector> newConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor = nullptr,
+      folly::Executor* cpuExecutor = nullptr) = 0;
+
+ private:
+  const std::string name_;
+};
 
 class Connector {
  public:
-  explicit Connector(const std::string& id) : id_(id) {}
+  explicit Connector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config = nullptr)
+      : id_(id), config_(std::move(config)) {}
 
   virtual ~Connector() = default;
 
@@ -533,9 +590,8 @@ class Connector {
     return id_;
   }
 
-  virtual const std::shared_ptr<const config::ConfigBase>& connectorConfig()
-      const {
-    VELOX_NYI("connectorConfig is not supported yet");
+  const std::shared_ptr<const config::ConfigBase>& connectorConfig() const {
+    return config_;
   }
 
   /// Returns true if this connector would accept a filter dynamically
@@ -544,25 +600,17 @@ class Connector {
     return false;
   }
 
-  /// Returns a ConnectorMetadata for accessing table
-  /// information.
-  virtual ConnectorMetadata* metadata() const {
-    VELOX_UNSUPPORTED();
-  }
-
   virtual std::unique_ptr<DataSource> createDataSource(
       const RowTypePtr& outputType,
-      const std::shared_ptr<ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+      const ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& 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.
-  virtual bool supportsSplitPreload() {
+  virtual bool supportsSplitPreload() const {
     return false;
   }
 
@@ -613,10 +661,8 @@ class Connector {
       const std::vector<std::shared_ptr<core::IndexLookupCondition>>&
           joinConditions,
       const RowTypePtr& outputType,
-      const std::shared_ptr<ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+      const ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& columnHandles,
       ConnectorQueryCtx* connectorQueryCtx) {
     VELOX_UNSUPPORTED(
         "Connector {} does not support index source", connectorId());
@@ -624,7 +670,7 @@ class Connector {
 
   virtual std::unique_ptr<DataSink> createDataSink(
       RowTypePtr inputType,
-      std::shared_ptr<ConnectorInsertTableHandle> connectorInsertTableHandle,
+      ConnectorInsertTableHandlePtr connectorInsertTableHandle,
       ConnectorQueryCtx* connectorQueryCtx,
       CommitStrategy commitStrategy) = 0;
 
@@ -636,65 +682,43 @@ class Connector {
       const std::string& scanId,
       int32_t loadQuantum);
 
+  /// Returns the IOExecutor used by the connector. It is used to run async IO
+  /// operations by the connector.
+  virtual folly::Executor* ioExecutor() const {
+    return nullptr;
+  }
+
+  // This is for backward compatibility, todo: remove after verax repo is
+  // updated
   virtual folly::Executor* executor() const {
     return nullptr;
   }
 
+  /// The name of the common runtime stats collected and reported by connector
+  /// data/index sources.
+  static inline const std::string kTotalRemainingFilterTime{
+      "totalRemainingFilterWallNanos"};
+
  private:
   static void unregisterTracker(cache::ScanTracker* tracker);
 
   const std::string id_;
+  const std::shared_ptr<const config::ConfigBase> config_;
 
   static folly::Synchronized<
       std::unordered_map<std::string_view, std::weak_ptr<cache::ScanTracker>>>
       trackers_;
 };
 
-class ConnectorFactory {
- public:
-  explicit ConnectorFactory(const char* name) : name_(name) {}
-
-  virtual ~ConnectorFactory() = default;
-
-  const std::string& connectorName() const {
-    return name_;
-  }
-
-  virtual std::shared_ptr<Connector> newConnector(
-      const std::string& id,
-      std::shared_ptr<const config::ConfigBase> config,
-      folly::Executor* ioExecutor = nullptr,
-      folly::Executor* cpuExecutor = nullptr) = 0;
-
- private:
-  const std::string name_;
-};
-
-/// Adds a factory for creating connectors to the registry using connector
-/// name as the key. Throws if factor with the same name is already present.
-/// Always returns true. The return value makes it easy to use with
-/// 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(
-    const std::string& connectorName);
-
 /// Adds connector instance to the registry using connector ID as the key.
 /// Throws if connector with the same ID is already present. Always returns
 /// true. The return value makes it easy to use with FB_ANONYMOUS_VARIABLE.
 bool registerConnector(std::shared_ptr<Connector> connector);
 
+/// Returns true if a connector with the specified ID has been registered, false
+/// otherwise.
+bool hasConnector(const std::string& connectorId);
+
 /// Removes the connector with specified ID from the registry. Returns true
 /// if connector was removed and false if connector didn't exist.
 bool unregisterConnector(const std::string& connectorId);
diff --git a/velox/connectors/clp/CMakeLists.txt b/velox/connectors/clp/CMakeLists.txt
index 6f5d8633a7fd..ecfdc19fe06d 100644
--- a/velox/connectors/clp/CMakeLists.txt
+++ b/velox/connectors/clp/CMakeLists.txt
@@ -19,11 +19,10 @@ velox_add_library(
   ClpConfig.cpp
   ClpConnector.cpp
   ClpDataSource.cpp
-  ClpTableHandle.cpp)
+  ClpTableHandle.cpp
+)
 
-velox_link_libraries(velox_clp_connector
-                     PRIVATE clp-s-search simdjson::simdjson velox_connector)
-target_compile_features(velox_clp_connector PRIVATE cxx_std_20)
+velox_link_libraries(velox_clp_connector PRIVATE clp-s-search simdjson::simdjson velox_connector)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/connectors/clp/ClpColumnHandle.h b/velox/connectors/clp/ClpColumnHandle.h
index d69efdd1749f..6b0493f789bd 100644
--- a/velox/connectors/clp/ClpColumnHandle.h
+++ b/velox/connectors/clp/ClpColumnHandle.h
@@ -30,6 +30,10 @@ class ClpColumnHandle : public ColumnHandle {
         originalColumnName_(originalColumnName),
         columnType_(columnType) {}
 
+  const std::string& name() const override {
+    return columnName_;
+  }
+
   const std::string& columnName() const {
     return columnName_;
   }
diff --git a/velox/connectors/clp/ClpConnector.cpp b/velox/connectors/clp/ClpConnector.cpp
index 25f90171c271..1c4e3647ce7e 100644
--- a/velox/connectors/clp/ClpConnector.cpp
+++ b/velox/connectors/clp/ClpConnector.cpp
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#include "clp_s/TimestampPattern.hpp"
-
 #include "velox/connectors/clp/ClpConnector.h"
 #include "velox/connectors/clp/ClpDataSource.h"
 
@@ -28,10 +26,8 @@ ClpConnector::ClpConnector(
 
 std::unique_ptr<DataSource> ClpConnector::createDataSource(
     const RowTypePtr& outputType,
-    const std::shared_ptr<ConnectorTableHandle>& tableHandle,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+    const ConnectorTableHandlePtr& tableHandle,
+    const connector::ColumnHandleMap& columnHandles,
     ConnectorQueryCtx* connectorQueryCtx) {
   return std::make_unique<ClpDataSource>(
       outputType,
@@ -43,20 +39,16 @@ std::unique_ptr<DataSource> ClpConnector::createDataSource(
 
 std::unique_ptr<DataSink> ClpConnector::createDataSink(
     RowTypePtr inputType,
-    std::shared_ptr<ConnectorInsertTableHandle> connectorInsertTableHandle,
+    ConnectorInsertTableHandlePtr connectorInsertTableHandle,
     ConnectorQueryCtx* connectorQueryCtx,
     CommitStrategy commitStrategy) {
   VELOX_NYI("createDataSink for ClpConnector is not implemented!");
 }
 
 ClpConnectorFactory::ClpConnectorFactory()
-    : ConnectorFactory(kClpConnectorName) {
-  clp_s::TimestampPattern::init();
-}
+    : ConnectorFactory(kClpConnectorName) {}
 
 ClpConnectorFactory::ClpConnectorFactory(const char* connectorName)
-    : ConnectorFactory(connectorName) {
-  clp_s::TimestampPattern::init();
-}
+    : ConnectorFactory(connectorName) {}
 
 } // namespace facebook::velox::connector::clp
diff --git a/velox/connectors/clp/ClpConnector.h b/velox/connectors/clp/ClpConnector.h
index 59efe8d8bb7b..ddccfdbbd3ec 100644
--- a/velox/connectors/clp/ClpConnector.h
+++ b/velox/connectors/clp/ClpConnector.h
@@ -28,7 +28,7 @@ class ClpConnector : public Connector {
       std::shared_ptr<const config::ConfigBase> config);
 
   [[nodiscard]] const std::shared_ptr<const config::ConfigBase>&
-  connectorConfig() const override {
+  connectorConfig() const {
     return config_->config();
   }
 
@@ -38,19 +38,17 @@ class ClpConnector : public Connector {
 
   std::unique_ptr<DataSource> createDataSource(
       const RowTypePtr& outputType,
-      const std::shared_ptr<ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+      const ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& columnHandles,
       ConnectorQueryCtx* connectorQueryCtx) override;
 
-  bool supportsSplitPreload() override {
+  bool supportsSplitPreload() const override {
     return false;
   }
 
   std::unique_ptr<DataSink> createDataSink(
       RowTypePtr inputType,
-      std::shared_ptr<ConnectorInsertTableHandle> connectorInsertTableHandle,
+      ConnectorInsertTableHandlePtr connectorInsertTableHandle,
       ConnectorQueryCtx* connectorQueryCtx,
       CommitStrategy commitStrategy) override;
 
diff --git a/velox/connectors/clp/ClpDataSource.cpp b/velox/connectors/clp/ClpDataSource.cpp
index ac038869bf93..40e09296f956 100644
--- a/velox/connectors/clp/ClpDataSource.cpp
+++ b/velox/connectors/clp/ClpDataSource.cpp
@@ -29,14 +29,13 @@ namespace facebook::velox::connector::clp {
 
 ClpDataSource::ClpDataSource(
     const RowTypePtr& outputType,
-    const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+    const ConnectorTableHandlePtr& tableHandle,
+    const connector::ColumnHandleMap& columnHandles,
     velox::memory::MemoryPool* pool,
     std::shared_ptr<const ClpConfig>& clpConfig)
     : pool_(pool), outputType_(outputType) {
-  auto clpTableHandle = std::dynamic_pointer_cast<ClpTableHandle>(tableHandle);
+  auto clpTableHandle =
+      std::dynamic_pointer_cast<const ClpTableHandle>(tableHandle);
   storageType_ = clpConfig->storageType();
   s3AuthProvider_ = clpConfig->s3AuthProvider();
 
@@ -47,7 +46,7 @@ ClpDataSource::ClpDataSource(
         "ColumnHandle not found for output name: {}",
         outputName);
     auto clpColumnHandle =
-        std::dynamic_pointer_cast<ClpColumnHandle>(columnHandle->second);
+        std::dynamic_pointer_cast<const ClpColumnHandle>(columnHandle->second);
     VELOX_CHECK_NOT_NULL(
         clpColumnHandle,
         "ColumnHandle must be an instance of ClpColumnHandle for output name: {}",
diff --git a/velox/connectors/clp/ClpDataSource.h b/velox/connectors/clp/ClpDataSource.h
index a500219f3f82..66efbd47081c 100644
--- a/velox/connectors/clp/ClpDataSource.h
+++ b/velox/connectors/clp/ClpDataSource.h
@@ -34,10 +34,8 @@ class ClpDataSource : public DataSource {
  public:
   ClpDataSource(
       const RowTypePtr& outputType,
-      const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+      const ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& columnHandles,
       velox::memory::MemoryPool* pool,
       std::shared_ptr<const ClpConfig>& clpConfig);
 
@@ -60,7 +58,7 @@ class ClpDataSource : public DataSource {
     return completedRows_;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
     return {};
   }
 
diff --git a/velox/connectors/clp/ClpTableHandle.h b/velox/connectors/clp/ClpTableHandle.h
index 357fcd102c9a..7ef0b0526cbd 100644
--- a/velox/connectors/clp/ClpTableHandle.h
+++ b/velox/connectors/clp/ClpTableHandle.h
@@ -25,6 +25,10 @@ class ClpTableHandle : public ConnectorTableHandle {
   ClpTableHandle(const std::string& connectorId, const std::string& tableName)
       : ConnectorTableHandle(connectorId), tableName_(tableName) {}
 
+  const std::string& name() const override {
+    return tableName_;
+  }
+
   [[nodiscard]] const std::string& tableName() const {
     return tableName_;
   }
diff --git a/velox/connectors/clp/search_lib/CMakeLists.txt b/velox/connectors/clp/search_lib/CMakeLists.txt
index 69451d2fc79f..f675e0b0a423 100644
--- a/velox/connectors/clp/search_lib/CMakeLists.txt
+++ b/velox/connectors/clp/search_lib/CMakeLists.txt
@@ -20,14 +20,10 @@ velox_add_library(
   ClpPackageS3AuthProvider.h
   ClpS3AuthProviderBase.cpp
   ClpS3AuthProviderBase.h
-  ClpTimestampsUtils.h)
+  ClpTimestampsUtils.h
+)
 
 add_subdirectory(archive)
 add_subdirectory(ir)
 
-velox_link_libraries(
-  clp-s-search
-  PUBLIC clp-s-archive-search
-  PUBLIC clp-s-ir-search)
-
-target_compile_features(clp-s-search PRIVATE cxx_std_20)
+velox_link_libraries(clp-s-search PUBLIC clp-s-archive-search PUBLIC clp-s-ir-search)
diff --git a/velox/connectors/clp/search_lib/archive/CMakeLists.txt b/velox/connectors/clp/search_lib/archive/CMakeLists.txt
index d1739d9e2efb..806350505c1f 100644
--- a/velox/connectors/clp/search_lib/archive/CMakeLists.txt
+++ b/velox/connectors/clp/search_lib/archive/CMakeLists.txt
@@ -17,11 +17,11 @@ velox_add_library(
   ClpArchiveCursor.cpp
   ClpArchiveJsonStringVectorLoader.cpp
   ClpArchiveVectorLoader.cpp
-  ClpQueryRunner.cpp)
+  ClpQueryRunner.cpp
+)
 
 velox_link_libraries(
   clp-s-archive-search
   PUBLIC clp_s::archive_reader velox_vector
-  PRIVATE clp_s::clp_dependencies clp_s::io clp_s::search clp_s::search::kql)
-
-target_compile_features(clp-s-archive-search PRIVATE cxx_std_20)
+  PRIVATE clp_s::clp_dependencies clp_s::io clp_s::search clp_s::search::kql
+)
diff --git a/velox/connectors/clp/search_lib/archive/ClpArchiveVectorLoader.cpp b/velox/connectors/clp/search_lib/archive/ClpArchiveVectorLoader.cpp
index 14a51d6674be..eb2434726ae0 100644
--- a/velox/connectors/clp/search_lib/archive/ClpArchiveVectorLoader.cpp
+++ b/velox/connectors/clp/search_lib/archive/ClpArchiveVectorLoader.cpp
@@ -72,7 +72,7 @@ void ClpArchiveVectorLoader::populateTimestampData(
     case clp_s::NodeType::FormattedFloat:
     case clp_s::NodeType::DictionaryFloat:
     case clp_s::NodeType::Integer:
-    case clp_s::NodeType::DateString:
+    case clp_s::NodeType::DeprecatedDateString:
       supportedNodeType = true;
       break;
     default:
@@ -115,7 +115,8 @@ void ClpArchiveVectorLoader::populateTimestampData(
           convertToVeloxTimestamp(
               std::get<int64_t>(reader->extract_value(messageIndex))));
     } else {
-      auto reader = static_cast<clp_s::DateStringColumnReader*>(columnReader_);
+      auto reader =
+          static_cast<clp_s::DeprecatedDateStringColumnReader*>(columnReader_);
       vector->set(
           vectorIndex,
           convertToVeloxTimestamp(reader->get_encoded_time(messageIndex)));
@@ -214,8 +215,9 @@ void ClpArchiveVectorLoader::loadInternal(
         populateTimestampData<clp_s::NodeType::Integer>(rows, timestampVector);
       } else if (
           nullptr !=
-          dynamic_cast<clp_s::DateStringColumnReader*>(columnReader_)) {
-        populateTimestampData<clp_s::NodeType::DateString>(
+          dynamic_cast<clp_s::DeprecatedDateStringColumnReader*>(
+              columnReader_)) {
+        populateTimestampData<clp_s::NodeType::DeprecatedDateString>(
             rows, timestampVector);
       } else if (
           nullptr != dynamic_cast<clp_s::FloatColumnReader*>(columnReader_)) {
@@ -261,8 +263,8 @@ template void
 ClpArchiveVectorLoader::populateTimestampData<clp_s::NodeType::Integer>(
     RowSet rows,
     FlatVector<facebook::velox::Timestamp>* vector);
-template void
-ClpArchiveVectorLoader::populateTimestampData<clp_s::NodeType::DateString>(
+template void ClpArchiveVectorLoader::populateTimestampData<
+    clp_s::NodeType::DeprecatedDateString>(
     RowSet rows,
     FlatVector<facebook::velox::Timestamp>* vector);
 template void
diff --git a/velox/connectors/clp/search_lib/ir/CMakeLists.txt b/velox/connectors/clp/search_lib/ir/CMakeLists.txt
index 568492f385a4..964c24a66faf 100644
--- a/velox/connectors/clp/search_lib/ir/CMakeLists.txt
+++ b/velox/connectors/clp/search_lib/ir/CMakeLists.txt
@@ -16,7 +16,8 @@ velox_add_library(
   STATIC
   ClpIrCursor.cpp
   ClpIrJsonStringVectorLoader.cpp
-  ClpIrVectorLoader.cpp)
+  ClpIrVectorLoader.cpp
+)
 
 velox_link_libraries(
   clp-s-ir-search
@@ -29,4 +30,5 @@ velox_link_libraries(
     clp_s::search
     clp_s::search::ast
     clp_s::search::kql
-    velox_vector)
+    velox_vector
+)
diff --git a/velox/connectors/clp/tests/CMakeLists.txt b/velox/connectors/clp/tests/CMakeLists.txt
index 5f7fd1f57c88..2b26c3a4dcf6 100644
--- a/velox/connectors/clp/tests/CMakeLists.txt
+++ b/velox/connectors/clp/tests/CMakeLists.txt
@@ -21,7 +21,7 @@ target_link_libraries(
   velox_exec_test_lib
   velox_vector_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
-file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples
-     DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/velox/connectors/clp/tests/ClpConnectorTest.cpp b/velox/connectors/clp/tests/ClpConnectorTest.cpp
index 4f2963fe97bc..114d5e50cbdd 100644
--- a/velox/connectors/clp/tests/ClpConnectorTest.cpp
+++ b/velox/connectors/clp/tests/ClpConnectorTest.cpp
@@ -45,22 +45,18 @@ class ClpConnectorTest : public exec::test::OperatorTestBase {
 
   void SetUp() override {
     OperatorTestBase::SetUp();
-    connector::registerConnectorFactory(
-        std::make_shared<connector::clp::ClpConnectorFactory>());
-    auto clpConnector =
-        connector::getConnectorFactory(
-            connector::clp::ClpConnectorFactory::kClpConnectorName)
-            ->newConnector(
-                kClpConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>{}));
+    connector::clp::ClpConnectorFactory factory;
+    auto clpConnector = factory.newConnector(
+        kClpConnectorId,
+        std::make_shared<const config::ConfigBase>(
+            std::unordered_map<std::string, std::string>{}),
+        nullptr,
+        nullptr);
     connector::registerConnector(clpConnector);
   }
 
   void TearDown() override {
     connector::unregisterConnector(kClpConnectorId);
-    connector::unregisterConnectorFactory(
-        connector::clp::ClpConnectorFactory::kClpConnectorName);
     OperatorTestBase::TearDown();
   }
 
@@ -68,8 +64,9 @@ class ClpConnectorTest : public exec::test::OperatorTestBase {
       const std::string& splitPath,
       ClpConnectorSplit::SplitType type,
       std::shared_ptr<std::string> kqlQuery) {
-    return exec::Split(std::make_shared<ClpConnectorSplit>(
-        kClpConnectorId, splitPath, static_cast<int>(type), kqlQuery));
+    return exec::Split(
+        std::make_shared<ClpConnectorSplit>(
+            kClpConnectorId, splitPath, static_cast<int>(type), kqlQuery));
   }
 
   RowVectorPtr getResults(
@@ -88,27 +85,28 @@ class ClpConnectorTest : public exec::test::OperatorTestBase {
 
 TEST_F(ClpConnectorTest, test1NoPushdown) {
   const std::shared_ptr<std::string> kqlQuery = nullptr;
-  auto plan = PlanBuilder()
-                  .startTableScan()
-                  .outputType(
-                      ROW({"requestId", "userId", "method"},
-                          {VARCHAR(), VARCHAR(), VARCHAR()}))
-                  .tableHandle(std::make_shared<ClpTableHandle>(
-                      kClpConnectorId, "test_1"))
-                  .assignments({
-                      {"requestId",
-                       std::make_shared<ClpColumnHandle>(
-                           "requestId", "requestId", VARCHAR())},
-                      {"userId",
-                       std::make_shared<ClpColumnHandle>(
-                           "userId", "userId", VARCHAR())},
-                      {"method",
-                       std::make_shared<ClpColumnHandle>(
-                           "method", "method", VARCHAR())},
-                  })
-                  .endTableScan()
-                  .filter("method = 'GET'")
-                  .planNode();
+  auto plan =
+      PlanBuilder()
+          .startTableScan()
+          .outputType(
+              ROW({"requestId", "userId", "method"},
+                  {VARCHAR(), VARCHAR(), VARCHAR()}))
+          .tableHandle(
+              std::make_shared<ClpTableHandle>(kClpConnectorId, "test_1"))
+          .assignments({
+              {"requestId",
+               std::make_shared<ClpColumnHandle>(
+                   "requestId", "requestId", VARCHAR())},
+              {"userId",
+               std::make_shared<ClpColumnHandle>(
+                   "userId", "userId", VARCHAR())},
+              {"method",
+               std::make_shared<ClpColumnHandle>(
+                   "method", "method", VARCHAR())},
+          })
+          .endTableScan()
+          .filter("method = 'GET'")
+          .planNode();
 
   auto output = getResults(
       plan,
@@ -189,13 +187,13 @@ TEST_F(ClpConnectorTest, test1Pushdown) {
           getExampleFilePath("test_1.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected =
-      makeRowVector({// requestId
-                     makeFlatVector<StringView>({"req-106"}),
-                     // userId
-                     makeNullableFlatVector<StringView>({std::nullopt}),
-                     // path
-                     makeFlatVector<StringView>({"/auth/login"})});
+  auto expected = makeRowVector(
+      {// requestId
+       makeFlatVector<StringView>({"req-106"}),
+       // userId
+       makeNullableFlatVector<StringView>({std::nullopt}),
+       // path
+       makeFlatVector<StringView>({"/auth/login"})});
   test::assertEqualVectors(expected, output);
 
   auto irOutput = getResults(
@@ -209,27 +207,28 @@ TEST_F(ClpConnectorTest, test1Pushdown) {
 
 TEST_F(ClpConnectorTest, test1JsonString) {
   const std::shared_ptr<std::string> kqlQuery = nullptr;
-  auto plan = PlanBuilder()
-                  .startTableScan()
-                  .outputType(
-                      ROW({"requestId", "__json_string", "method"},
-                          {VARCHAR(), VARCHAR(), VARCHAR()}))
-                  .tableHandle(std::make_shared<ClpTableHandle>(
-                      kClpConnectorId, "test_1"))
-                  .assignments({
-                      {"requestId",
-                       std::make_shared<ClpColumnHandle>(
-                           "requestId", "requestId", VARCHAR())},
-                      {"__json_string",
-                       std::make_shared<ClpColumnHandle>(
-                           "__json_string", "__json_string", VARCHAR())},
-                      {"method",
-                       std::make_shared<ClpColumnHandle>(
-                           "method", "method", VARCHAR())},
-                  })
-                  .endTableScan()
-                  .filter("method = 'GET'")
-                  .planNode();
+  auto plan =
+      PlanBuilder()
+          .startTableScan()
+          .outputType(
+              ROW({"requestId", "__json_string", "method"},
+                  {VARCHAR(), VARCHAR(), VARCHAR()}))
+          .tableHandle(
+              std::make_shared<ClpTableHandle>(kClpConnectorId, "test_1"))
+          .assignments({
+              {"requestId",
+               std::make_shared<ClpColumnHandle>(
+                   "requestId", "requestId", VARCHAR())},
+              {"__json_string",
+               std::make_shared<ClpColumnHandle>(
+                   "__json_string", "__json_string", VARCHAR())},
+              {"method",
+               std::make_shared<ClpColumnHandle>(
+                   "method", "method", VARCHAR())},
+          })
+          .endTableScan()
+          .filter("method = 'GET'")
+          .planNode();
 
   const auto methodVector = makeFlatVector<StringView>({
       "GET",
@@ -318,19 +317,19 @@ TEST_F(ClpConnectorTest, test2NoPushdown) {
           getExampleFilePath("test_2.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected =
-      makeRowVector({// timestamp
-                     makeFlatVector<Timestamp>({Timestamp(
-                         kTestTimestampSeconds, kTestTimestampNanoseconds)}),
-                     // event
-                     makeRowVector({
-                         // event.type
-                         makeFlatVector<StringView>({"storage"}),
-                         // event.subtype
-                         makeFlatVector<StringView>({"disk_usage"}),
-                         // event.severity
-                         makeFlatVector<StringView>({"WARNING"}),
-                     })});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>(
+           {Timestamp(kTestTimestampSeconds, kTestTimestampNanoseconds)}),
+       // event
+       makeRowVector({
+           // event.type
+           makeFlatVector<StringView>({"storage"}),
+           // event.subtype
+           makeFlatVector<StringView>({"disk_usage"}),
+           // event.severity
+           makeFlatVector<StringView>({"WARNING"}),
+       })});
   test::assertEqualVectors(expected, output);
 
   auto irOutput = getResults(
@@ -347,27 +346,28 @@ TEST_F(ClpConnectorTest, test2Pushdown) {
       "(event.severity: \"WARNING\" OR event.severity: \"ERROR\") AND "
       "((event.type: \"network\" AND event.subtype: \"connection\") OR "
       "(event.type: \"storage\" AND event.subtype: \"disk*\"))");
-  auto plan = PlanBuilder()
-                  .startTableScan()
-                  .outputType(
-                      ROW({"timestamp", "event"},
-                          {TIMESTAMP(),
-                           ROW({"type", "subtype", "severity"},
-                               {VARCHAR(), VARCHAR(), VARCHAR()})}))
-                  .tableHandle(std::make_shared<ClpTableHandle>(
-                      kClpConnectorId, "test_2"))
-                  .assignments(
-                      {{"timestamp",
-                        std::make_shared<ClpColumnHandle>(
-                            "timestamp", "timestamp", TIMESTAMP())},
-                       {"event",
-                        std::make_shared<ClpColumnHandle>(
-                            "event",
-                            "event",
-                            ROW({"type", "subtype", "severity"},
-                                {VARCHAR(), VARCHAR(), VARCHAR()}))}})
-                  .endTableScan()
-                  .planNode();
+  auto plan =
+      PlanBuilder()
+          .startTableScan()
+          .outputType(
+              ROW({"timestamp", "event"},
+                  {TIMESTAMP(),
+                   ROW({"type", "subtype", "severity"},
+                       {VARCHAR(), VARCHAR(), VARCHAR()})}))
+          .tableHandle(
+              std::make_shared<ClpTableHandle>(kClpConnectorId, "test_2"))
+          .assignments(
+              {{"timestamp",
+                std::make_shared<ClpColumnHandle>(
+                    "timestamp", "timestamp", TIMESTAMP())},
+               {"event",
+                std::make_shared<ClpColumnHandle>(
+                    "event",
+                    "event",
+                    ROW({"type", "subtype", "severity"},
+                        {VARCHAR(), VARCHAR(), VARCHAR()}))}})
+          .endTableScan()
+          .planNode();
 
   auto output = getResults(
       plan,
@@ -375,19 +375,19 @@ TEST_F(ClpConnectorTest, test2Pushdown) {
           getExampleFilePath("test_2.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected =
-      makeRowVector({// timestamp
-                     makeFlatVector<Timestamp>({Timestamp(
-                         kTestTimestampSeconds, kTestTimestampNanoseconds)}),
-                     // event
-                     makeRowVector({
-                         // event.type
-                         makeFlatVector<StringView>({"storage"}),
-                         // event.subtype
-                         makeFlatVector<StringView>({"disk_usage"}),
-                         // event.severity
-                         makeFlatVector<StringView>({"WARNING"}),
-                     })});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>(
+           {Timestamp(kTestTimestampSeconds, kTestTimestampNanoseconds)}),
+       // event
+       makeRowVector({
+           // event.type
+           makeFlatVector<StringView>({"storage"}),
+           // event.subtype
+           makeFlatVector<StringView>({"disk_usage"}),
+           // event.severity
+           makeFlatVector<StringView>({"WARNING"}),
+       })});
   test::assertEqualVectors(expected, output);
 
   auto irOutput = getResults(
@@ -438,15 +438,16 @@ TEST_F(ClpConnectorTest, test2Hybrid) {
        makeFlatVector<Timestamp>(
            {Timestamp(kTestTimestampSeconds, kTestTimestampNanoseconds)}),
        // event
-       makeRowVector({// event.type
-                      makeFlatVector<StringView>({"storage"}),
-                      // event.subtype
-                      makeFlatVector<StringView>({"disk_usage"}),
-                      // event.severity
-                      makeFlatVector<StringView>({"WARNING"}),
-                      // event.tags
-                      makeArrayVector<StringView>(
-                          {{"\"filesystem\"", "\"monitoring\""}})})
+       makeRowVector(
+           {// event.type
+            makeFlatVector<StringView>({"storage"}),
+            // event.subtype
+            makeFlatVector<StringView>({"disk_usage"}),
+            // event.severity
+            makeFlatVector<StringView>({"WARNING"}),
+            // event.tags
+            makeArrayVector<StringView>(
+                {{"\"filesystem\"", "\"monitoring\""}})})
 
       });
   test::assertEqualVectors(expected, output);
@@ -465,21 +466,22 @@ TEST_F(ClpConnectorTest, test2JsonString) {
       "(event.severity: \"WARNING\" OR event.severity: \"ERROR\") AND "
       "((event.type: \"network\" AND event.subtype: \"connection\") OR "
       "(event.type: \"storage\" AND event.subtype: \"disk*\"))");
-  auto plan = PlanBuilder()
-                  .startTableScan()
-                  .outputType(ROW(
-                      {"timestamp", "__json_string"}, {TIMESTAMP(), VARCHAR()}))
-                  .tableHandle(std::make_shared<ClpTableHandle>(
-                      kClpConnectorId, "test_2"))
-                  .assignments(
-                      {{"timestamp",
-                        std::make_shared<ClpColumnHandle>(
-                            "timestamp", "timestamp", TIMESTAMP())},
-                       {"__json_string",
-                        std::make_shared<ClpColumnHandle>(
-                            "__json_string", "__json_string", VARCHAR())}})
-                  .endTableScan()
-                  .planNode();
+  auto plan =
+      PlanBuilder()
+          .startTableScan()
+          .outputType(
+              ROW({"timestamp", "__json_string"}, {TIMESTAMP(), VARCHAR()}))
+          .tableHandle(
+              std::make_shared<ClpTableHandle>(kClpConnectorId, "test_2"))
+          .assignments(
+              {{"timestamp",
+                std::make_shared<ClpColumnHandle>(
+                    "timestamp", "timestamp", TIMESTAMP())},
+               {"__json_string",
+                std::make_shared<ClpColumnHandle>(
+                    "__json_string", "__json_string", VARCHAR())}})
+          .endTableScan()
+          .planNode();
 
   auto output = getResults(
       plan,
@@ -515,17 +517,18 @@ TEST_F(ClpConnectorTest, test2JsonString) {
 
 TEST_F(ClpConnectorTest, test3TimestampMarshalling) {
   const std::shared_ptr<std::string> kqlQuery = nullptr;
-  auto plan = PlanBuilder(pool_.get())
-                  .startTableScan()
-                  .outputType(ROW({"timestamp"}, {TIMESTAMP()}))
-                  .tableHandle(std::make_shared<ClpTableHandle>(
-                      kClpConnectorId, "test_3"))
-                  .assignments(
-                      {{"timestamp",
-                        std::make_shared<ClpColumnHandle>(
-                            "timestamp", "timestamp", TIMESTAMP())}})
-                  .endTableScan()
-                  .planNode();
+  auto plan =
+      PlanBuilder(pool_.get())
+          .startTableScan()
+          .outputType(ROW({"timestamp"}, {TIMESTAMP()}))
+          .tableHandle(
+              std::make_shared<ClpTableHandle>(kClpConnectorId, "test_3"))
+          .assignments(
+              {{"timestamp",
+                std::make_shared<ClpColumnHandle>(
+                    "timestamp", "timestamp", TIMESTAMP())}})
+          .endTableScan()
+          .planNode();
 
   auto output = getResults(
       plan,
@@ -546,18 +549,19 @@ TEST_F(ClpConnectorTest, test3TimestampMarshalling) {
 
 TEST_F(ClpConnectorTest, test4IrTimestampNoPushdown) {
   const std::shared_ptr<std::string> kqlQuery = nullptr;
-  auto plan = PlanBuilder(pool_.get())
-                  .startTableScan()
-                  .outputType(ROW({"timestamp"}, {TIMESTAMP()}))
-                  .tableHandle(std::make_shared<ClpTableHandle>(
-                      kClpConnectorId, "test_4"))
-                  .assignments(
-                      {{"timestamp",
-                        std::make_shared<ClpColumnHandle>(
-                            "timestamp", "timestamp", TIMESTAMP())}})
-                  .endTableScan()
-                  .filter("\"timestamp\" < timestamp '2025-08-24 02:36:45'")
-                  .planNode();
+  auto plan =
+      PlanBuilder(pool_.get())
+          .startTableScan()
+          .outputType(ROW({"timestamp"}, {TIMESTAMP()}))
+          .tableHandle(
+              std::make_shared<ClpTableHandle>(kClpConnectorId, "test_4"))
+          .assignments(
+              {{"timestamp",
+                std::make_shared<ClpColumnHandle>(
+                    "timestamp", "timestamp", TIMESTAMP())}})
+          .endTableScan()
+          .filter("\"timestamp\" < timestamp '2025-08-24 02:36:45'")
+          .planNode();
 
   auto output = getResults(
       plan,
@@ -578,17 +582,18 @@ TEST_F(ClpConnectorTest, test4IrTimestampPushdown) {
   // which is not supported yet so the value will be NULL.
   const std::shared_ptr<std::string> kqlQuery =
       std::make_shared<std::string>("(timestamp < 1756003005000000)");
-  auto plan = PlanBuilder(pool_.get())
-                  .startTableScan()
-                  .outputType(ROW({"timestamp"}, {TIMESTAMP()}))
-                  .tableHandle(std::make_shared<ClpTableHandle>(
-                      kClpConnectorId, "test_4"))
-                  .assignments(
-                      {{"timestamp",
-                        std::make_shared<ClpColumnHandle>(
-                            "timestamp", "timestamp", TIMESTAMP())}})
-                  .endTableScan()
-                  .planNode();
+  auto plan =
+      PlanBuilder(pool_.get())
+          .startTableScan()
+          .outputType(ROW({"timestamp"}, {TIMESTAMP()}))
+          .tableHandle(
+              std::make_shared<ClpTableHandle>(kClpConnectorId, "test_4"))
+          .assignments(
+              {{"timestamp",
+                std::make_shared<ClpColumnHandle>(
+                    "timestamp", "timestamp", TIMESTAMP())}})
+          .endTableScan()
+          .planNode();
 
   auto output = getResults(
       plan,
@@ -633,23 +638,24 @@ TEST_F(ClpConnectorTest, test5FloatTimestampNoPushdown) {
           getExampleFilePath("test_5.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected = makeRowVector({// timestamp
-                                 makeFlatVector<Timestamp>(
-                                     {Timestamp(1746003005, 124000000),
-                                      Timestamp(1746003005, 124100000),
-                                      Timestamp(1746003005, 125000000),
-                                      Timestamp(1746003005, 126000000),
-                                      Timestamp(1746003005, 127000000),
-                                      Timestamp(1746003060, 0),
-                                      Timestamp(1746003065, 0)}),
-                                 makeFlatVector<double>(
-                                     {1.2345678912345E9,
-                                      1E16,
-                                      1.234567891234567E9,
-                                      1.234567891234567E9,
-                                      -1.234567891234567E-9,
-                                      1234567891.234567,
-                                      -1234567891.234567})});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>(
+           {Timestamp(1746003005, 124000000),
+            Timestamp(1746003005, 124100000),
+            Timestamp(1746003005, 125000000),
+            Timestamp(1746003005, 126000000),
+            Timestamp(1746003005, 127000000),
+            Timestamp(1746003060, 0),
+            Timestamp(1746003065, 0)}),
+       makeFlatVector<double>(
+           {1.2345678912345E9,
+            1E16,
+            1.234567891234567E9,
+            1.234567891234567E9,
+            -1.234567891234567E-9,
+            1234567891.234567,
+            -1234567891.234567})});
   test::assertEqualVectors(expected, output);
 }
 
@@ -683,17 +689,18 @@ TEST_F(ClpConnectorTest, test5FloatTimestampPushdown) {
           getExampleFilePath("test_5.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected = makeRowVector({// timestamp
-                                 makeFlatVector<Timestamp>(
-                                     {Timestamp(1746003005, 124000000),
-                                      Timestamp(1746003005, 124100000),
-                                      Timestamp(1746003005, 125000000),
-                                      Timestamp(1746003005, 126000000)}),
-                                 makeFlatVector<double>(
-                                     {1.234567891234500E9,
-                                      1E16,
-                                      1.234567891234567E9,
-                                      1.234567891234567E9})});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>(
+           {Timestamp(1746003005, 124000000),
+            Timestamp(1746003005, 124100000),
+            Timestamp(1746003005, 125000000),
+            Timestamp(1746003005, 126000000)}),
+       makeFlatVector<double>(
+           {1.234567891234500E9,
+            1E16,
+            1.234567891234567E9,
+            1.234567891234567E9})});
   test::assertEqualVectors(expected, output);
 }
 
@@ -725,29 +732,30 @@ TEST_F(ClpConnectorTest, test5FormattedFloatNoPushdown) {
           getExampleFilePath("test_5.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected = makeRowVector({// timestamp
-                                 makeFlatVector<Timestamp>(
-                                     {Timestamp(1746003005, 123457000),
-                                      Timestamp(1746003115, 0),
-                                      Timestamp(1746003120, 0),
-                                      Timestamp(1746003125, 0),
-                                      Timestamp(1746003130, 0),
-                                      Timestamp(1746003135, 0),
-                                      Timestamp(1746003140, 0),
-                                      Timestamp(1746003145, 0),
-                                      Timestamp(1746003185, 0),
-                                      Timestamp(1746003190, 0)}),
-                                 makeFlatVector<double>(
-                                     {1.2345678912345E-29,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0})});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>(
+           {Timestamp(1746003005, 123457000),
+            Timestamp(1746003115, 0),
+            Timestamp(1746003120, 0),
+            Timestamp(1746003125, 0),
+            Timestamp(1746003130, 0),
+            Timestamp(1746003135, 0),
+            Timestamp(1746003140, 0),
+            Timestamp(1746003145, 0),
+            Timestamp(1746003185, 0),
+            Timestamp(1746003190, 0)}),
+       makeFlatVector<double>(
+           {1.2345678912345E-29,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0})});
   test::assertEqualVectors(expected, output);
 }
 
@@ -778,29 +786,30 @@ TEST_F(ClpConnectorTest, test5FormattedFloatPushdown) {
           getExampleFilePath("test_5.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected = makeRowVector({// timestamp
-                                 makeFlatVector<Timestamp>(
-                                     {Timestamp(1746003005, 123457000),
-                                      Timestamp(1746003115, 0),
-                                      Timestamp(1746003120, 0),
-                                      Timestamp(1746003125, 0),
-                                      Timestamp(1746003130, 0),
-                                      Timestamp(1746003135, 0),
-                                      Timestamp(1746003140, 0),
-                                      Timestamp(1746003145, 0),
-                                      Timestamp(1746003185, 0),
-                                      Timestamp(1746003190, 0)}),
-                                 makeFlatVector<double>(
-                                     {1.2345678912345E-29,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0,
-                                      0.0})});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>(
+           {Timestamp(1746003005, 123457000),
+            Timestamp(1746003115, 0),
+            Timestamp(1746003120, 0),
+            Timestamp(1746003125, 0),
+            Timestamp(1746003130, 0),
+            Timestamp(1746003135, 0),
+            Timestamp(1746003140, 0),
+            Timestamp(1746003145, 0),
+            Timestamp(1746003185, 0),
+            Timestamp(1746003190, 0)}),
+       makeFlatVector<double>(
+           {1.2345678912345E-29,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0})});
   test::assertEqualVectors(expected, output);
 }
 
@@ -831,11 +840,11 @@ TEST_F(ClpConnectorTest, test5DictionaryFloatNoPushdown) {
           getExampleFilePath("test_5.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected =
-      makeRowVector({// timestamp
-                     makeFlatVector<Timestamp>(
-                         {Timestamp(1746003195, 0), Timestamp(1746003200, 0)}),
-                     makeFlatVector<double>({2, 2})});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>(
+           {Timestamp(1746003195, 0), Timestamp(1746003200, 0)}),
+       makeFlatVector<double>({2, 2})});
   test::assertEqualVectors(expected, output);
 }
 
@@ -866,11 +875,11 @@ TEST_F(ClpConnectorTest, test5DictionaryFloatPushdown) {
           getExampleFilePath("test_5.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected =
-      makeRowVector({// timestamp
-                     makeFlatVector<Timestamp>(
-                         {Timestamp(1746003195, 0), Timestamp(1746003200, 0)}),
-                     makeFlatVector<double>({2, 2})});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>(
+           {Timestamp(1746003195, 0), Timestamp(1746003200, 0)}),
+       makeFlatVector<double>({2, 2})});
   test::assertEqualVectors(expected, output);
 }
 
@@ -901,16 +910,17 @@ TEST_F(ClpConnectorTest, test5HybridNoPushdown) {
           getExampleFilePath("test_5.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected = makeRowVector({// timestamp
-                                 makeFlatVector<Timestamp>({
-                                     Timestamp(1746003105, 0),
-                                     Timestamp(1746003110, 0),
-                                     Timestamp(1746003150, 0),
-                                     Timestamp(1746003155, 0),
-                                     Timestamp(1746003160, 0),
-                                     Timestamp(1746003205, 0),
-                                 }),
-                                 makeFlatVector<double>({1, 1, 1, 1, 1, 1})});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>({
+           Timestamp(1746003105, 0),
+           Timestamp(1746003110, 0),
+           Timestamp(1746003150, 0),
+           Timestamp(1746003155, 0),
+           Timestamp(1746003160, 0),
+           Timestamp(1746003205, 0),
+       }),
+       makeFlatVector<double>({1, 1, 1, 1, 1, 1})});
   test::assertEqualVectors(expected, output);
 }
 
@@ -941,16 +951,17 @@ TEST_F(ClpConnectorTest, test5HybridPushdown) {
           getExampleFilePath("test_5.clps"),
           ClpConnectorSplit::SplitType::kArchive,
           kqlQuery)});
-  auto expected = makeRowVector({// timestamp
-                                 makeFlatVector<Timestamp>({
-                                     Timestamp(1746003105, 0),
-                                     Timestamp(1746003110, 0),
-                                     Timestamp(1746003150, 0),
-                                     Timestamp(1746003155, 0),
-                                     Timestamp(1746003160, 0),
-                                     Timestamp(1746003205, 0),
-                                 }),
-                                 makeFlatVector<double>({1, 1, 1, 1, 1, 1})});
+  auto expected = makeRowVector(
+      {// timestamp
+       makeFlatVector<Timestamp>({
+           Timestamp(1746003105, 0),
+           Timestamp(1746003110, 0),
+           Timestamp(1746003150, 0),
+           Timestamp(1746003155, 0),
+           Timestamp(1746003160, 0),
+           Timestamp(1746003205, 0),
+       }),
+       makeFlatVector<double>({1, 1, 1, 1, 1, 1})});
   test::assertEqualVectors(expected, output);
 }
 
diff --git a/velox/connectors/fuzzer/CMakeLists.txt b/velox/connectors/fuzzer/CMakeLists.txt
index a777f8a29a4f..8e21030f99db 100644
--- a/velox/connectors/fuzzer/CMakeLists.txt
+++ b/velox/connectors/fuzzer/CMakeLists.txt
@@ -14,8 +14,7 @@
 
 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 53f0c1843664..f17b8faefd9c 100644
--- a/velox/connectors/fuzzer/FuzzerConnector.cpp
+++ b/velox/connectors/fuzzer/FuzzerConnector.cpp
@@ -20,12 +20,12 @@
 namespace facebook::velox::connector::fuzzer {
 
 FuzzerDataSource::FuzzerDataSource(
-    const std::shared_ptr<const RowType>& outputType,
-    const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
+    const RowTypePtr& outputType,
+    const connector::ConnectorTableHandlePtr& tableHandle,
     velox::memory::MemoryPool* pool)
     : outputType_(outputType), pool_(pool) {
   auto fuzzerTableHandle =
-      std::dynamic_pointer_cast<FuzzerTableHandle>(tableHandle);
+      std::dynamic_pointer_cast<const FuzzerTableHandle>(tableHandle);
   VELOX_CHECK_NOT_NULL(
       fuzzerTableHandle,
       "TableHandle must be an instance of FuzzerTableHandle");
diff --git a/velox/connectors/fuzzer/FuzzerConnector.h b/velox/connectors/fuzzer/FuzzerConnector.h
index 64477b73ea36..5b3f9bf74e22 100644
--- a/velox/connectors/fuzzer/FuzzerConnector.h
+++ b/velox/connectors/fuzzer/FuzzerConnector.h
@@ -34,7 +34,7 @@ namespace facebook::velox::connector::fuzzer {
 
 class FuzzerTableHandle : public ConnectorTableHandle {
  public:
-  explicit FuzzerTableHandle(
+  FuzzerTableHandle(
       std::string connectorId,
       VectorFuzzer::Options options,
       size_t fuzzerSeed = 0)
@@ -42,21 +42,20 @@ class FuzzerTableHandle : public ConnectorTableHandle {
         fuzzerOptions(options),
         fuzzerSeed(fuzzerSeed) {}
 
-  ~FuzzerTableHandle() override {}
-
-  std::string toString() const override {
-    return "fuzzer-mock-table";
+  const std::string& name() const override {
+    static const std::string kName = "fuzzer-mock-table";
+    return kName;
   }
 
   const VectorFuzzer::Options fuzzerOptions;
-  size_t fuzzerSeed;
+  const size_t fuzzerSeed;
 };
 
 class FuzzerDataSource : public DataSource {
  public:
   FuzzerDataSource(
-      const std::shared_ptr<const RowType>& outputType,
-      const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
+      const RowTypePtr& outputType,
+      const connector::ConnectorTableHandlePtr& tableHandle,
       velox::memory::MemoryPool* pool);
 
   void addSplit(std::shared_ptr<ConnectorSplit> split) override;
@@ -78,7 +77,7 @@ class FuzzerDataSource : public DataSource {
     return completedBytes_;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
     // TODO: Which stats do we want to expose here?
     return {};
   }
@@ -109,11 +108,9 @@ class FuzzerConnector final : public Connector {
       : Connector(id) {}
 
   std::unique_ptr<DataSource> createDataSource(
-      const std::shared_ptr<const RowType>& outputType,
-      const std::shared_ptr<ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& /*columnHandles*/,
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& /*columnHandles*/,
       ConnectorQueryCtx* connectorQueryCtx) override final {
     return std::make_unique<FuzzerDataSource>(
         outputType, tableHandle, connectorQueryCtx->memoryPool());
@@ -121,8 +118,7 @@ class FuzzerConnector final : public Connector {
 
   std::unique_ptr<DataSink> createDataSink(
       RowTypePtr /*inputType*/,
-      std::shared_ptr<
-          ConnectorInsertTableHandle> /*connectorInsertTableHandle*/,
+      ConnectorInsertTableHandlePtr /*connectorInsertTableHandle*/,
       ConnectorQueryCtx* /*connectorQueryCtx*/,
       CommitStrategy /*commitStrategy*/) override final {
     VELOX_NYI("FuzzerConnector does not support data sink.");
diff --git a/velox/connectors/fuzzer/tests/CMakeLists.txt b/velox/connectors/fuzzer/tests/CMakeLists.txt
index 803619339097..6f0dbf3b6472 100644
--- a/velox/connectors/fuzzer/tests/CMakeLists.txt
+++ b/velox/connectors/fuzzer/tests/CMakeLists.txt
@@ -22,4 +22,5 @@ target_link_libraries(
   velox_exec_test_lib
   velox_aggregates
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/connectors/fuzzer/tests/FuzzerConnectorTest.cpp b/velox/connectors/fuzzer/tests/FuzzerConnectorTest.cpp
index 5b5fe277ac59..a9900512cd4c 100644
--- a/velox/connectors/fuzzer/tests/FuzzerConnectorTest.cpp
+++ b/velox/connectors/fuzzer/tests/FuzzerConnectorTest.cpp
@@ -124,13 +124,13 @@ TEST_F(FuzzerConnectorTest, reproducible) {
   auto plan1 = PlanBuilder()
                    .startTableScan()
                    .outputType(type)
-                   .tableHandle(makeFuzzerTableHandle(/*fuzerSeed=*/1234))
+                   .tableHandle(makeFuzzerTableHandle(/*fuzzerSeed=*/1234))
                    .endTableScan()
                    .planNode();
   auto plan2 = PlanBuilder()
                    .startTableScan()
                    .outputType(type)
-                   .tableHandle(makeFuzzerTableHandle(/*fuzerSeed=*/1234))
+                   .tableHandle(makeFuzzerTableHandle(/*fuzzerSeed=*/1234))
                    .endTableScan()
                    .planNode();
 
diff --git a/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h b/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
index 971b54dbe9b8..b0c703f54bc2 100644
--- a/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
+++ b/velox/connectors/fuzzer/tests/FuzzerConnectorTestBase.h
@@ -26,20 +26,13 @@ class FuzzerConnectorTestBase : public exec::test::OperatorTestBase {
 
   void SetUp() override {
     OperatorTestBase::SetUp();
-    connector::registerConnectorFactory(
-        std::make_shared<connector::fuzzer::FuzzerConnectorFactory>());
-    std::shared_ptr<const config::ConfigBase> config;
-    auto fuzzerConnector =
-        connector::getConnectorFactory(
-            connector::fuzzer::FuzzerConnectorFactory::kFuzzerConnectorName)
-            ->newConnector(kFuzzerConnectorId, config);
+    connector::fuzzer::FuzzerConnectorFactory factory;
+    auto fuzzerConnector = factory.newConnector(kFuzzerConnectorId, nullptr);
     connector::registerConnector(fuzzerConnector);
   }
 
   void TearDown() override {
     connector::unregisterConnector(kFuzzerConnectorId);
-    connector::unregisterConnectorFactory(
-        connector::fuzzer::FuzzerConnectorFactory::kFuzzerConnectorName);
     OperatorTestBase::TearDown();
   }
 
diff --git a/velox/connectors/hive/BufferedInputBuilder.cpp b/velox/connectors/hive/BufferedInputBuilder.cpp
new file mode 100644
index 000000000000..f4fb6c1a828c
--- /dev/null
+++ b/velox/connectors/hive/BufferedInputBuilder.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/connectors/hive/BufferedInputBuilder.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+
+namespace facebook::velox::connector::hive {
+
+class DefaultBufferInputBuilder : public BufferedInputBuilder {
+ public:
+  std::unique_ptr<dwio::common::BufferedInput> create(
+      const FileHandle& fileHandle,
+      const dwio::common::ReaderOptions& readerOpts,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      std::shared_ptr<io::IoStatistics> ioStats,
+      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      folly::Executor* executor,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps) override {
+    return createBufferedInput(
+        fileHandle,
+        readerOpts,
+        connectorQueryCtx,
+        ioStats,
+        fsStats,
+        executor,
+        fileReadOps);
+  }
+};
+
+// static
+std::shared_ptr<BufferedInputBuilder> BufferedInputBuilder::builder_ =
+    std::make_shared<DefaultBufferInputBuilder>();
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/BufferedInputBuilder.h b/velox/connectors/hive/BufferedInputBuilder.h
new file mode 100644
index 000000000000..d23049fed6bb
--- /dev/null
+++ b/velox/connectors/hive/BufferedInputBuilder.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.
+ */
+
+#pragma once
+#include <folly/Executor.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 {
+
+/// Registering a different implementation of BufferedInput is allowed using
+/// 'registerBuilder' API.
+class BufferedInputBuilder {
+ public:
+  virtual ~BufferedInputBuilder() = default;
+
+  static const std::shared_ptr<BufferedInputBuilder>& getInstance() {
+    VELOX_CHECK_NOT_NULL(builder_, "Builder is not registered");
+    return builder_;
+  }
+
+  static void registerBuilder(std::shared_ptr<BufferedInputBuilder> builder) {
+    VELOX_CHECK_NOT_NULL(builder);
+    builder_ = std::move(builder);
+  }
+
+  virtual std::unique_ptr<dwio::common::BufferedInput> create(
+      const FileHandle& fileHandle,
+      const dwio::common::ReaderOptions& readerOpts,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      std::shared_ptr<io::IoStatistics> ioStats,
+      std::shared_ptr<filesystems::File::IoStats> fsStats,
+      folly::Executor* executor,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {}) = 0;
+
+ private:
+  static std::shared_ptr<BufferedInputBuilder> builder_;
+};
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/CMakeLists.txt b/velox/connectors/hive/CMakeLists.txt
index 6c8aa05487b4..e6f980d8e3fc 100644
--- a/velox/connectors/hive/CMakeLists.txt
+++ b/velox/connectors/hive/CMakeLists.txt
@@ -20,6 +20,7 @@ add_subdirectory(iceberg)
 velox_add_library(
   velox_hive_connector
   OBJECT
+  BufferedInputBuilder.cpp
   FileHandle.cpp
   HiveConfig.cpp
   HiveConnector.cpp
@@ -27,16 +28,17 @@ velox_add_library(
   HiveConnectorSplit.cpp
   HiveDataSink.cpp
   HiveDataSource.cpp
-  HivePartitionUtil.cpp
+  HivePartitionName.cpp
   PartitionIdGenerator.cpp
   SplitReader.cpp
-  TableHandle.cpp)
+  TableHandle.cpp
+)
 
 velox_link_libraries(
   velox_hive_connector
   PUBLIC velox_hive_iceberg_splitreader
-  PRIVATE velox_common_io velox_connector velox_dwio_catalog_fbhive
-          velox_hive_partition_function)
+  PRIVATE velox_common_io velox_connector velox_dwio_catalog_fbhive velox_hive_partition_function
+)
 
 velox_add_library(velox_hive_partition_function HivePartitionFunction.cpp)
 
diff --git a/velox/connectors/hive/FileHandle.cpp b/velox/connectors/hive/FileHandle.cpp
index a75225cb4ee6..413ca86bef46 100644
--- a/velox/connectors/hive/FileHandle.cpp
+++ b/velox/connectors/hive/FileHandle.cpp
@@ -40,7 +40,7 @@ std::string groupName(const std::string& filename) {
 } // namespace
 
 std::unique_ptr<FileHandle> FileHandleGenerator::operator()(
-    const std::string& filename,
+    const FileHandleKey& key,
     const FileProperties* properties,
     filesystems::File::IoStats* stats) {
   // We have seen cases where drivers are stuck when creating file handles.
@@ -53,11 +53,14 @@ std::unique_ptr<FileHandle> FileHandleGenerator::operator()(
     fileHandle = std::make_unique<FileHandle>();
     filesystems::FileOptions options;
     options.stats = stats;
+    options.tokenProvider = key.tokenProvider;
     if (properties) {
       options.fileSize = properties->fileSize;
       options.readRangeHint = properties->readRangeHint;
       options.extraFileInfo = properties->extraFileInfo;
+      options.fileReadOps = properties->fileReadOps;
     }
+    const auto& filename = key.filename;
     fileHandle->file = filesystems::getFileSystem(filename, properties_)
                            ->openFileForRead(filename, options);
     fileHandle->uuid = StringIdLease(fileIds(), filename);
diff --git a/velox/connectors/hive/FileHandle.h b/velox/connectors/hive/FileHandle.h
index 0a053742ca56..6f9b4050c31e 100644
--- a/velox/connectors/hive/FileHandle.h
+++ b/velox/connectors/hive/FileHandle.h
@@ -25,10 +25,12 @@
 
 #pragma once
 
+#include "velox/common/base/BitUtil.h"
 #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/common/file/TokenProvider.h"
 #include "velox/connectors/hive/FileProperties.h"
 
 namespace facebook::velox {
@@ -59,7 +61,44 @@ struct FileHandleSizer {
   uint64_t operator()(const FileHandle& a);
 };
 
-using FileHandleCache = SimpleLRUCache<std::string, FileHandle>;
+struct FileHandleKey {
+  std::string filename;
+  std::shared_ptr<filesystems::TokenProvider> tokenProvider{nullptr};
+
+  bool operator==(const FileHandleKey& other) const {
+    if (filename != other.filename) {
+      return false;
+    }
+
+    if (tokenProvider == other.tokenProvider) {
+      return true;
+    }
+
+    if (!tokenProvider || !other.tokenProvider) {
+      return false;
+    }
+
+    return tokenProvider->equals(*other.tokenProvider);
+  }
+};
+
+} // namespace facebook::velox
+
+namespace std {
+template <>
+struct hash<facebook::velox::FileHandleKey> {
+  size_t operator()(const facebook::velox::FileHandleKey& key) const noexcept {
+    size_t filenameHash = std::hash<std::string>()(key.filename);
+    return key.tokenProvider ? facebook::velox::bits::hashMix(
+                                   filenameHash, key.tokenProvider->hash())
+                             : filenameHash;
+  }
+};
+} // namespace std
+
+namespace facebook::velox {
+using FileHandleCache =
+    SimpleLRUCache<facebook::velox::FileHandleKey, FileHandle>;
 
 // Creates FileHandles via the Generator interface the CachedFactory requires.
 class FileHandleGenerator {
@@ -68,7 +107,7 @@ class FileHandleGenerator {
   FileHandleGenerator(std::shared_ptr<const config::ConfigBase> properties)
       : properties_(std::move(properties)) {}
   std::unique_ptr<FileHandle> operator()(
-      const std::string& filename,
+      const FileHandleKey& filename,
       const FileProperties* properties,
       filesystems::File::IoStats* stats);
 
@@ -77,14 +116,14 @@ class FileHandleGenerator {
 };
 
 using FileHandleFactory = CachedFactory<
-    std::string,
+    FileHandleKey,
     FileHandle,
     FileHandleGenerator,
     FileProperties,
     filesystems::File::IoStats,
     FileHandleSizer>;
 
-using FileHandleCachedPtr = CachedPtr<std::string, FileHandle>;
+using FileHandleCachedPtr = CachedPtr<FileHandleKey, FileHandle>;
 
 using FileHandleCacheStats = SimpleLRUCacheStats;
 
diff --git a/velox/connectors/hive/FileProperties.h b/velox/connectors/hive/FileProperties.h
index d3ed9e3cbd6b..a6158e1fec65 100644
--- a/velox/connectors/hive/FileProperties.h
+++ b/velox/connectors/hive/FileProperties.h
@@ -25,6 +25,7 @@
 
 #pragma once
 
+#include <folly/container/F14Map.h>
 #include <cstdint>
 
 namespace facebook::velox {
@@ -34,6 +35,7 @@ struct FileProperties {
   std::optional<int64_t> modificationTime;
   std::optional<int64_t> readRangeHint{std::nullopt};
   std::shared_ptr<std::string> extraFileInfo{nullptr};
+  folly::F14FastMap<std::string, std::string> fileReadOps{};
 };
 
 } // namespace facebook::velox
diff --git a/velox/connectors/hive/HiveConfig.cpp b/velox/connectors/hive/HiveConfig.cpp
index 5eaab02e648b..8b354e2ed7d4 100644
--- a/velox/connectors/hive/HiveConfig.cpp
+++ b/velox/connectors/hive/HiveConfig.cpp
@@ -67,6 +67,11 @@ uint32_t HiveConfig::maxPartitionsPerWriters(
       config_->get<uint32_t>(kMaxPartitionsPerWriters, 128));
 }
 
+uint32_t HiveConfig::maxBucketCount(const config::ConfigBase* session) const {
+  return session->get<uint32_t>(
+      kMaxBucketCountSession, config_->get<uint32_t>(kMaxBucketCount, 100'000));
+}
+
 bool HiveConfig::immutablePartitions() const {
   return config_->get<bool>(kImmutablePartitions, false);
 }
@@ -88,6 +93,11 @@ std::optional<std::string> HiveConfig::gcsMaxRetryTime() const {
       config_->get<std::string>(kGcsMaxRetryTime));
 }
 
+std::optional<std::string> HiveConfig::gcsAuthAccessTokenProvider() const {
+  return static_cast<std::optional<std::string>>(
+      config_->get<std::string>(kGcsAuthAccessTokenProvider));
+}
+
 bool HiveConfig::isOrcUseColumnNames(const config::ConfigBase* session) const {
   return session->get<bool>(
       kOrcUseColumnNamesSession, config_->get<bool>(kOrcUseColumnNames, false));
@@ -149,6 +159,15 @@ int32_t HiveConfig::prefetchRowGroups() const {
   return config_->get<int32_t>(kPrefetchRowGroups, 1);
 }
 
+size_t HiveConfig::parallelUnitLoadCount(
+    const config::ConfigBase* session) const {
+  auto count = session->get<size_t>(
+      kParallelUnitLoadCountSession,
+      config_->get<size_t>(kParallelUnitLoadCount, 0));
+  VELOX_CHECK_LE(count, 100, "parallelUnitLoadCount too large: {}", count);
+  return count;
+}
+
 int32_t HiveConfig::loadQuantum(const config::ConfigBase* session) const {
   return session->get<int32_t>(
       kLoadQuantumSession, config_->get<int32_t>(kLoadQuantum, 8 << 20));
@@ -233,4 +252,25 @@ std::string HiveConfig::hiveLocalFileFormat() const {
   return config_->get<std::string>(kLocalFileFormat, "");
 }
 
+bool HiveConfig::preserveFlatMapsInMemory(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kPreserveFlatMapsInMemorySession,
+      config_->get<bool>(kPreserveFlatMapsInMemory, false));
+}
+
+std::string HiveConfig::user(const config::ConfigBase* session) const {
+  return session->get<std::string>(kUser, config_->get<std::string>(kUser, ""));
+}
+
+std::string HiveConfig::source(const config::ConfigBase* session) const {
+  return session->get<std::string>(
+      kSource, config_->get<std::string>(kSource, ""));
+}
+
+std::string HiveConfig::schema(const config::ConfigBase* session) const {
+  return session->get<std::string>(
+      kSchema, config_->get<std::string>(kSchema, ""));
+}
+
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConfig.h b/velox/connectors/hive/HiveConfig.h
index 04dbd754b81a..f69da84ff0c1 100644
--- a/velox/connectors/hive/HiveConfig.h
+++ b/velox/connectors/hive/HiveConfig.h
@@ -49,6 +49,10 @@ class HiveConfig {
   static constexpr const char* kMaxPartitionsPerWritersSession =
       "max_partitions_per_writers";
 
+  /// Maximum number of buckets allowed to output by the table writers.
+  static constexpr const char* kMaxBucketCount = "hive.max-bucket-count";
+  static constexpr const char* kMaxBucketCountSession = "hive.max_bucket_count";
+
   /// Whether new data can be inserted into an unpartition table.
   /// Velox currently does not support appending data to existing partitions.
   static constexpr const char* kImmutablePartitions =
@@ -67,12 +71,13 @@ class HiveConfig {
   /// The GCS maximum time allowed to retry transient errors.
   static constexpr const char* kGcsMaxRetryTime = "hive.gcs.max-retry-time";
 
+  static constexpr const char* kGcsAuthAccessTokenProvider =
+      "hive.gcs.auth.access-token-provider";
+
   /// 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";
+      "orc_use_column_names";
 
   /// Maps table field names to file field names using names, not indices.
   static constexpr const char* kParquetUseColumnNames =
@@ -139,6 +144,15 @@ class HiveConfig {
   /// meta data together. Optimization to decrease the small IO requests
   static constexpr const char* kFilePreloadThreshold = "file-preload-threshold";
 
+  /// When set to be larger than 0, parallel unit loader feature is enabled and
+  /// it configures how many units (e.g., stripes) we load in parallel.
+  /// When set to 0, parallel unit loader feature is disabled and on demand unit
+  /// loader would be used.
+  static constexpr const char* kParallelUnitLoadCount =
+      "parallel-unit-load-count";
+  static constexpr const char* kParallelUnitLoadCountSession =
+      "parallel_unit_load_count";
+
   /// 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.
@@ -183,11 +197,24 @@ class HiveConfig {
   static constexpr const char* kLocalDataPath = "hive_local_data_path";
   static constexpr const char* kLocalFileFormat = "hive_local_file_format";
 
+  /// Whether to preserve flat maps in memory as FlatMapVectors instead of
+  /// converting them to MapVectors.
+  static constexpr const char* kPreserveFlatMapsInMemory =
+      "hive.preserve-flat-maps-in-memory";
+  static constexpr const char* kPreserveFlatMapsInMemorySession =
+      "hive.preserve_flat_maps_in_memory";
+
+  static constexpr const char* kUser = "user";
+  static constexpr const char* kSource = "source";
+  static constexpr const char* kSchema = "schema";
+
   InsertExistingPartitionsBehavior insertExistingPartitionsBehavior(
       const config::ConfigBase* session) const;
 
   uint32_t maxPartitionsPerWriters(const config::ConfigBase* session) const;
 
+  uint32_t maxBucketCount(const config::ConfigBase* session) const;
+
   bool immutablePartitions() const;
 
   std::string gcsEndpoint() const;
@@ -198,6 +225,8 @@ class HiveConfig {
 
   std::optional<std::string> gcsMaxRetryTime() const;
 
+  std::optional<std::string> gcsAuthAccessTokenProvider() const;
+
   bool isOrcUseColumnNames(const config::ConfigBase* session) const;
 
   bool isParquetUseColumnNames(const config::ConfigBase* session) const;
@@ -217,6 +246,8 @@ class HiveConfig {
 
   int32_t prefetchRowGroups() const;
 
+  size_t parallelUnitLoadCount(const config::ConfigBase* session) const;
+
   int32_t loadQuantum(const config::ConfigBase* session) const;
 
   int32_t numCacheFileHandles() const;
@@ -261,6 +292,19 @@ class HiveConfig {
   /// hiveLocalDataPath().
   std::string hiveLocalFileFormat() const;
 
+  /// Whether to preserve flat maps in memory as FlatMapVectors instead of
+  /// converting them to MapVectors.
+  bool preserveFlatMapsInMemory(const config::ConfigBase* session) const;
+
+  /// User of the query. Used for storage logging.
+  std::string user(const config::ConfigBase* session) const;
+
+  /// Source of the query. Used for storage access and logging.
+  std::string source(const config::ConfigBase* session) const;
+
+  /// Schema of the query. Used for storage logging.
+  std::string schema(const config::ConfigBase* session) const;
+
   HiveConfig(std::shared_ptr<const config::ConfigBase> config) {
     VELOX_CHECK_NOT_NULL(
         config, "Config is null for HiveConfig initialization");
diff --git a/velox/connectors/hive/HiveConnector.cpp b/velox/connectors/hive/HiveConnector.cpp
index 4ef9e8f06179..e04828e83aaa 100644
--- a/velox/connectors/hive/HiveConnector.cpp
+++ b/velox/connectors/hive/HiveConnector.cpp
@@ -16,13 +16,10 @@
 
 #include "velox/connectors/hive/HiveConnector.h"
 
-#include "velox/common/base/Fs.h"
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HiveDataSink.h"
 #include "velox/connectors/hive/HiveDataSource.h"
 #include "velox/connectors/hive/HivePartitionFunction.h"
-#include "velox/expression/ExprToSubfieldFilter.h"
-#include "velox/expression/FieldReference.h"
 
 #include <boost/lexical_cast.hpp>
 #include <memory>
@@ -31,27 +28,19 @@ using namespace facebook::velox::exec;
 
 namespace facebook::velox::connector::hive {
 
-namespace {
-std::vector<std::unique_ptr<HiveConnectorMetadataFactory>>&
-hiveConnectorMetadataFactories() {
-  static std::vector<std::unique_ptr<HiveConnectorMetadataFactory>> factories;
-  return factories;
-}
-} // namespace
-
 HiveConnector::HiveConnector(
     const std::string& id,
     std::shared_ptr<const config::ConfigBase> config,
-    folly::Executor* executor)
-    : Connector(id),
-      hiveConfig_(std::make_shared<HiveConfig>(config)),
+    folly::Executor* ioExecutor)
+    : Connector(id, std::move(config)),
+      hiveConfig_(std::make_shared<HiveConfig>(connectorConfig())),
       fileHandleFactory_(
           hiveConfig_->isFileHandleCacheEnabled()
-              ? std::make_unique<SimpleLRUCache<std::string, FileHandle>>(
+              ? std::make_unique<SimpleLRUCache<FileHandleKey, FileHandle>>(
                     hiveConfig_->numCacheFileHandles())
               : nullptr,
-          std::make_unique<FileHandleGenerator>(config)),
-      executor_(executor) {
+          std::make_unique<FileHandleGenerator>(hiveConfig_->config())),
+      ioExecutor_(ioExecutor) {
   if (hiveConfig_->isFileHandleCacheEnabled()) {
     LOG(INFO) << "Hive connector " << connectorId()
               << " created with maximum of "
@@ -62,38 +51,31 @@ HiveConnector::HiveConnector(
     LOG(INFO) << "Hive connector " << connectorId()
               << " created with file handle cache disabled";
   }
-  for (auto& factory : hiveConnectorMetadataFactories()) {
-    metadata_ = factory->create(this);
-    if (metadata_ != nullptr) {
-      break;
-    }
-  }
 }
 
 std::unique_ptr<DataSource> HiveConnector::createDataSource(
     const RowTypePtr& outputType,
-    const std::shared_ptr<ConnectorTableHandle>& tableHandle,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+    const ConnectorTableHandlePtr& tableHandle,
+    const std::unordered_map<std::string, ColumnHandlePtr>& columnHandles,
     ConnectorQueryCtx* connectorQueryCtx) {
   return std::make_unique<HiveDataSource>(
       outputType,
       tableHandle,
       columnHandles,
       &fileHandleFactory_,
-      executor_,
+      ioExecutor_,
       connectorQueryCtx,
       hiveConfig_);
 }
 
 std::unique_ptr<DataSink> HiveConnector::createDataSink(
     RowTypePtr inputType,
-    std::shared_ptr<ConnectorInsertTableHandle> connectorInsertTableHandle,
+    ConnectorInsertTableHandlePtr connectorInsertTableHandle,
     ConnectorQueryCtx* connectorQueryCtx,
     CommitStrategy commitStrategy) {
-  auto hiveInsertHandle = std::dynamic_pointer_cast<HiveInsertTableHandle>(
-      connectorInsertTableHandle);
+  auto hiveInsertHandle =
+      std::dynamic_pointer_cast<const HiveInsertTableHandle>(
+          connectorInsertTableHandle);
   VELOX_CHECK_NOT_NULL(
       hiveInsertHandle, "Hive connector expecting hive write handle!");
   return std::make_unique<HiveDataSink>(
@@ -104,6 +86,19 @@ std::unique_ptr<DataSink> HiveConnector::createDataSink(
       hiveConfig_);
 }
 
+// static
+void HiveConnector::registerSerDe() {
+  HiveTableHandle::registerSerDe();
+  HiveColumnHandle::registerSerDe();
+  HiveConnectorSplit::registerSerDe();
+  HiveInsertTableHandle::registerSerDe();
+  HiveInsertFileNameGenerator::registerSerDe();
+  LocationHandle::registerSerDe();
+  HiveBucketProperty::registerSerDe();
+  HiveSortingColumn::registerSerDe();
+  HivePartitionFunctionSpec::registerSerDe();
+}
+
 std::unique_ptr<core::PartitionFunction> HivePartitionFunctionSpec::create(
     int numPartitions,
     bool localExchange) const {
@@ -125,7 +120,7 @@ std::unique_ptr<core::PartitionFunction> HivePartitionFunctionSpec::create(
           std::mt19937{0});
     }
   }
-  return std::make_unique<velox::connector::hive::HivePartitionFunction>(
+  return std::make_unique<HivePartitionFunction>(
       numBuckets_,
       bucketToPartition_.empty() ? std::move(bucketToPartitions)
                                  : bucketToPartition_,
@@ -190,16 +185,11 @@ core::PartitionFunctionSpecPtr HivePartitionFunctionSpec::deserialize(
       std::move(constValues));
 }
 
-void registerHivePartitionFunctionSerDe() {
+// static
+void HivePartitionFunctionSpec::registerSerDe() {
   auto& registry = DeserializationWithContextRegistryForSharedPtr();
   registry.Register(
       "HivePartitionFunctionSpec", HivePartitionFunctionSpec::deserialize);
 }
 
-bool registerHiveConnectorMetadataFactory(
-    std::unique_ptr<HiveConnectorMetadataFactory> factory) {
-  hiveConnectorMetadataFactories().push_back(std::move(factory));
-  return true;
-}
-
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConnector.h b/velox/connectors/hive/HiveConnector.h
index 937fdd850edf..845461ea412e 100644
--- a/velox/connectors/hive/HiveConnector.h
+++ b/velox/connectors/hive/HiveConnector.h
@@ -34,40 +34,28 @@ class HiveConnector : public Connector {
       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;
   }
 
-  ConnectorMetadata* metadata() const override {
-    VELOX_CHECK_NOT_NULL(metadata_);
-    return metadata_.get();
-  }
-
   std::unique_ptr<DataSource> createDataSource(
       const RowTypePtr& outputType,
-      const std::shared_ptr<ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+      const ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& columnHandles,
       ConnectorQueryCtx* connectorQueryCtx) override;
 
-  bool supportsSplitPreload() override {
+  bool supportsSplitPreload() const override {
     return true;
   }
 
   std::unique_ptr<DataSink> createDataSink(
       RowTypePtr inputType,
-      std::shared_ptr<ConnectorInsertTableHandle> connectorInsertTableHandle,
+      ConnectorInsertTableHandlePtr connectorInsertTableHandle,
       ConnectorQueryCtx* connectorQueryCtx,
       CommitStrategy commitStrategy) override;
 
-  folly::Executor* executor() const override {
-    return executor_;
+  folly::Executor* ioExecutor() const override {
+    return ioExecutor_;
   }
 
   FileHandleCacheStats fileHandleCacheStats() {
@@ -80,11 +68,12 @@ class HiveConnector : public Connector {
     return fileHandleFactory_.clearCache();
   }
 
+  static void registerSerDe();
+
  protected:
   const std::shared_ptr<HiveConfig> hiveConfig_;
   FileHandleFactory fileHandleFactory_;
-  folly::Executor* executor_;
-  std::shared_ptr<ConnectorMetadata> metadata_;
+  folly::Executor* ioExecutor_;
 };
 
 class HiveConnectorFactory : public ConnectorFactory {
@@ -100,7 +89,7 @@ class HiveConnectorFactory : public ConnectorFactory {
       const std::string& id,
       std::shared_ptr<const config::ConfigBase> config,
       folly::Executor* ioExecutor = nullptr,
-      folly::Executor* cpuExecutor = nullptr) override {
+      [[maybe_unused]] folly::Executor* cpuExecutor = nullptr) override {
     return std::make_shared<HiveConnector>(id, config, ioExecutor);
   }
 };
@@ -147,6 +136,8 @@ class HivePartitionFunctionSpec : public core::PartitionFunctionSpec {
       const folly::dynamic& obj,
       void* context);
 
+  static void registerSerDe();
+
  private:
   const int numBuckets_;
   const std::vector<int> bucketToPartition_;
@@ -154,23 +145,4 @@ class HivePartitionFunctionSpec : public core::PartitionFunctionSpec {
   const std::vector<VectorPtr> constValues_;
 };
 
-void registerHivePartitionFunctionSerDe();
-
-/// Hook for connecting metadata functions to a HiveConnector. Each registered
-/// factory is called after initializing a HiveConnector until one of these
-/// returns a ConnectorMetadata instance.
-class HiveConnectorMetadataFactory {
- public:
-  virtual ~HiveConnectorMetadataFactory() = default;
-
-  /// Returns a ConnectorMetadata to complete'hiveConnector' if 'this'
-  /// recognizes a data source, e.g. local file system or remote metadata
-  /// service associated to configs in 'hiveConnector'.
-  virtual std::shared_ptr<ConnectorMetadata> create(
-      HiveConnector* connector) = 0;
-};
-
-bool registerHiveConnectorMetadataFactory(
-    std::unique_ptr<HiveConnectorMetadataFactory>);
-
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConnectorSplit.cpp b/velox/connectors/hive/HiveConnectorSplit.cpp
index fba4902b180c..e7e32686692e 100644
--- a/velox/connectors/hive/HiveConnectorSplit.cpp
+++ b/velox/connectors/hive/HiveConnectorSplit.cpp
@@ -30,6 +30,10 @@ std::string HiveConnectorSplit::toString() const {
   return fmt::format("Hive: {} {} - {}", filePath, start, length);
 }
 
+uint64_t HiveConnectorSplit::size() const {
+  return length;
+}
+
 std::string HiveConnectorSplit::getFileName() const {
   const auto i = filePath.rfind('/');
   return i == std::string::npos ? filePath : filePath.substr(i + 1);
@@ -144,8 +148,10 @@ std::shared_ptr<HiveConnectorSplit> HiveConnectorSplit::create(
     std::vector<std::shared_ptr<HiveColumnHandle>> bucketColumnHandles;
     for (const auto& bucketColumnHandleObj :
          bucketConversionObj["bucketColumnHandles"]) {
-      bucketColumnHandles.push_back(std::const_pointer_cast<HiveColumnHandle>(
-          ISerializable::deserialize<HiveColumnHandle>(bucketColumnHandleObj)));
+      bucketColumnHandles.push_back(
+          std::const_pointer_cast<HiveColumnHandle>(
+              ISerializable::deserialize<HiveColumnHandle>(
+                  bucketColumnHandleObj)));
     }
     bucketConversion = HiveBucketConversion{
         .tableBucketCount = static_cast<int32_t>(
diff --git a/velox/connectors/hive/HiveConnectorSplit.h b/velox/connectors/hive/HiveConnectorSplit.h
index 16a50c42abd3..3485c2330fa5 100644
--- a/velox/connectors/hive/HiveConnectorSplit.h
+++ b/velox/connectors/hive/HiveConnectorSplit.h
@@ -106,42 +106,9 @@ struct HiveConnectorSplit : public connector::ConnectorSplit {
         rowIdProperties(_rowIdProperties),
         bucketConversion(_bucketConversion) {}
 
-#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
-  HiveConnectorSplit(
-      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>& _serdeParameters,
-      const std::unordered_map<std::string, std::string>& _storageParameters,
-      int64_t splitWeight = 0,
-      bool cacheable = true,
-      const std::unordered_map<std::string, std::string>& _infoColumns = {},
-      std::optional<FileProperties> _properties = std::nullopt,
-      std::optional<RowIdProperties> _rowIdProperties = std::nullopt,
-      const std::optional<HiveBucketConversion>& _bucketConversion =
-          std::nullopt)
-      : ConnectorSplit(connectorId, splitWeight, cacheable),
-        filePath(_filePath),
-        fileFormat(_fileFormat),
-        start(_start),
-        length(_length),
-        partitionKeys(_partitionKeys),
-        tableBucketNumber(_tableBucketNumber),
-        customSplitInfo(_customSplitInfo),
-        extraFileInfo(_extraFileInfo),
-        serdeParameters(_serdeParameters),
-        infoColumns(_infoColumns),
-        properties(_properties),
-        rowIdProperties(_rowIdProperties),
-        bucketConversion(_bucketConversion) {}
-#endif
+  ~HiveConnectorSplit() = default;
+
+  uint64_t size() const override;
 
   std::string toString() const override;
 
diff --git a/velox/connectors/hive/HiveConnectorUtil.cpp b/velox/connectors/hive/HiveConnectorUtil.cpp
index 1fd83c483537..0110f3be394a 100644
--- a/velox/connectors/hive/HiveConnectorUtil.cpp
+++ b/velox/connectors/hive/HiveConnectorUtil.cpp
@@ -21,6 +21,7 @@
 #include "velox/dwio/common/CachedBufferedInput.h"
 #include "velox/dwio/common/DirectBufferedInput.h"
 #include "velox/expression/Expr.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 
 namespace facebook::velox::connector::hive {
@@ -73,14 +74,15 @@ std::unique_ptr<common::Filter> makeFloatingPointMapKeyFilter(
     if (lowerUnbounded && upperUnbounded) {
       continue;
     }
-    filters.push_back(std::make_unique<common::FloatingPointRange<T>>(
-        lower,
-        lowerUnbounded,
-        lowerExclusive,
-        upper,
-        upperUnbounded,
-        upperExclusive,
-        false));
+    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]);
@@ -110,8 +112,7 @@ void addSubfields(
       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);
+        auto* nestedField = element->as<common::Subfield::NestedField>();
         VELOX_CHECK(
             nestedField,
             "Unsupported for row subfields pruning: {}",
@@ -150,20 +151,18 @@ void addSubfields(
       std::vector<int64_t> longSubscripts;
       for (auto& subfield : subfields) {
         auto* element = subfield.subfield->path()[level].get();
-        if (dynamic_cast<const common::Subfield::AllSubscripts*>(element)) {
+        if (element->is(common::SubfieldKind::kAllSubscripts)) {
           return;
         }
         if (stringKey) {
-          auto* subscript =
-              dynamic_cast<const common::Subfield::StringSubscript*>(element);
+          auto* subscript = element->as<common::Subfield::StringSubscript>();
           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);
+          auto* subscript = element->as<common::Subfield::LongSubscript>();
           VELOX_CHECK(
               subscript,
               "Unsupported for long map pruning: {}",
@@ -242,8 +241,7 @@ inline uint8_t parseDelimiter(const std::string& delim) {
 
 inline bool isSynthesizedColumn(
     const std::string& name,
-    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
-        infoColumns) {
+    const std::unordered_map<std::string, HiveColumnHandlePtr>& infoColumns) {
   return infoColumns.count(name) != 0;
 }
 
@@ -263,7 +261,7 @@ const std::string& getColumnName(const common::Subfield& subfield) {
   return field->name();
 }
 
-void checkColumnNameLowerCase(const std::shared_ptr<const Type>& type) {
+void checkColumnNameLowerCase(const TypePtr& type) {
   switch (type->kind()) {
     case TypeKind::ARRAY:
       checkColumnNameLowerCase(type->asArray().elementType());
@@ -289,8 +287,7 @@ void checkColumnNameLowerCase(const std::shared_ptr<const Type>& type) {
 
 void checkColumnNameLowerCase(
     const common::SubfieldFilters& filters,
-    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
-        infoColumns) {
+    const std::unordered_map<std::string, HiveColumnHandlePtr>& infoColumns) {
   for (const auto& filterIt : filters) {
     const auto name = filterIt.first.toString();
     if (isSynthesizedColumn(name, infoColumns)) {
@@ -330,7 +327,11 @@ void processFieldSpec(
     if (type.isMap() && !spec.isConstant()) {
       auto* keys = spec.childByName(common::ScanSpec::kMapKeysFieldName);
       VELOX_CHECK_NOT_NULL(keys);
-      keys->addFilter(common::IsNotNull());
+      if (keys->filter()) {
+        VELOX_CHECK(!keys->filter()->testNull());
+      } else {
+        keys->setFilter(std::make_shared<common::IsNotNull>());
+      }
     }
   });
   if (dataColumns) {
@@ -351,10 +352,8 @@ std::shared_ptr<common::ScanSpec> makeScanSpec(
         outputSubfields,
     const common::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::unordered_map<std::string, HiveColumnHandlePtr>& partitionKeys,
+    const std::unordered_map<std::string, HiveColumnHandlePtr>& infoColumns,
     const SpecialColumnNames& specialColumns,
     bool disableStatsBasedFilterReorder,
     memory::MemoryPool* pool) {
@@ -443,7 +442,8 @@ std::shared_ptr<common::ScanSpec> makeScanSpec(
       continue;
     }
     auto fieldSpec = spec->getOrCreateChild(pair.first);
-    fieldSpec->addFilter(*pair.second);
+    VELOX_CHECK_NULL(spec->filter());
+    fieldSpec->setFilter(pair.second);
   }
 
   if (disableStatsBasedFilterReorder) {
@@ -614,6 +614,7 @@ void configureRowReaderOptions(
     const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
     const std::shared_ptr<const HiveConfig>& hiveConfig,
     const config::ConfigBase* sessionProperties,
+    folly::Executor* const ioExecutor,
     dwio::common::RowReaderOptions& rowReaderOptions) {
   auto skipRowsIt =
       tableParameters.find(dwio::common::TableParameter::kSkipHeaderLineCount);
@@ -621,12 +622,18 @@ void configureRowReaderOptions(
     rowReaderOptions.setSkipRows(folly::to<uint64_t>(skipRowsIt->second));
   }
   rowReaderOptions.setScanSpec(scanSpec);
+  rowReaderOptions.setIOExecutor(ioExecutor);
   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)));
+    rowReaderOptions.setTimestampPrecision(
+        static_cast<TimestampPrecision>(
+            hiveConfig->readTimestampUnit(sessionProperties)));
+    rowReaderOptions.setPreserveFlatMapsInMemory(
+        hiveConfig->preserveFlatMapsInMemory(sessionProperties));
+    rowReaderOptions.setParallelUnitLoadCount(
+        hiveConfig->parallelUnitLoadCount(sessionProperties));
   }
   rowReaderOptions.setSerdeParameters(hiveSplit->serdeParameters);
 }
@@ -637,7 +644,7 @@ bool applyPartitionFilter(
     const TypePtr& type,
     const std::string& partitionValue,
     bool isPartitionDateDaysSinceEpoch,
-    common::Filter* filter,
+    const common::Filter* filter,
     bool asLocalTime) {
   if (type->isDate()) {
     int32_t result = 0;
@@ -646,7 +653,7 @@ bool applyPartitionFilter(
     if (isPartitionDateDaysSinceEpoch) {
       result = folly::to<int32_t>(partitionValue);
     } else {
-      result = DATE()->toDays(static_cast<folly::StringPiece>(partitionValue));
+      result = DATE()->toDays(partitionValue);
     }
     return applyFilter(*filter, result);
   }
@@ -691,7 +698,7 @@ bool testFilters(
     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>>&
+    const std::unordered_map<std::string, HiveColumnHandlePtr>&
         partitionKeysHandle,
     bool asLocalTime) {
   const auto totalRows = reader->numberOfRows();
@@ -753,32 +760,50 @@ std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
     const ConnectorQueryCtx* connectorQueryCtx,
     std::shared_ptr<io::IoStatistics> ioStats,
     std::shared_ptr<filesystems::File::IoStats> fsStats,
-    folly::Executor* executor) {
+    folly::Executor* executor,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
   if (connectorQueryCtx->cache()) {
     return std::make_unique<dwio::common::CachedBufferedInput>(
         fileHandle.file,
         dwio::common::MetricsLog::voidLog(),
-        fileHandle.uuid.id(),
+        fileHandle.uuid,
         connectorQueryCtx->cache(),
         Connector::getTracker(
             connectorQueryCtx->scanId(), readerOpts.loadQuantum()),
-        fileHandle.groupId.id(),
+        fileHandle.groupId,
         ioStats,
         std::move(fsStats),
         executor,
-        readerOpts);
+        readerOpts,
+        fileReadOps);
+  }
+  if (readerOpts.fileFormat() == dwio::common::FileFormat::NIMBLE) {
+    // Nimble streams (in case of single chunk) are compressed as whole and need
+    // to be fully fetched in order to do decompression, so there is no point to
+    // fetch them by quanta.  Just use BufferedInput to fetch streams as whole
+    // to reduce memory footprint.
+    return std::make_unique<dwio::common::BufferedInput>(
+        fileHandle.file,
+        readerOpts.memoryPool(),
+        dwio::common::MetricsLog::voidLog(),
+        ioStats.get(),
+        fsStats.get(),
+        dwio::common::BufferedInput::kMaxMergeDistance,
+        std::nullopt,
+        fileReadOps);
   }
   return std::make_unique<dwio::common::DirectBufferedInput>(
       fileHandle.file,
       dwio::common::MetricsLog::voidLog(),
-      fileHandle.uuid.id(),
+      fileHandle.uuid,
       Connector::getTracker(
           connectorQueryCtx->scanId(), readerOpts.loadQuantum()),
-      fileHandle.groupId.id(),
+      fileHandle.groupId,
       std::move(ioStats),
       std::move(fsStats),
       executor,
-      readerOpts);
+      readerOpts,
+      fileReadOps);
 }
 
 namespace {
@@ -848,8 +873,6 @@ double getPrestoSampleRate(
   return std::max(0.0, std::min(1.0, rate->value().value<double>()));
 }
 
-} // namespace
-
 core::TypedExprPtr extractFiltersFromRemainingFilter(
     const core::TypedExprPtr& expr,
     core::ExpressionEvaluator* evaluator,
@@ -862,10 +885,10 @@ core::TypedExprPtr extractFiltersFromRemainingFilter(
   }
   common::Filter* oldFilter = nullptr;
   try {
-    common::Subfield subfield;
-    if (auto filter = exec::ExprToSubfieldFilterParser::getInstance()
-                          ->leafCallToSubfieldFilter(
-                              *call, subfield, evaluator, negated)) {
+    if (auto subfieldAndFilter =
+            exec::ExprToSubfieldFilterParser::getInstance()
+                ->leafCallToSubfieldFilter(*call, evaluator, negated)) {
+      auto& [subfield, filter] = subfieldAndFilter.value();
       if (auto it = filters.find(subfield); it != filters.end()) {
         oldFilter = it->second.get();
         filter = filter->mergeWith(oldFilter);
@@ -887,20 +910,73 @@ core::TypedExprPtr extractFiltersFromRemainingFilter(
     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 ((call->name() == expression::kAnd && !negated) ||
+      (call->name() == expression::kOr && negated)) {
+    std::vector<core::TypedExprPtr> args;
+    args.reserve(call->inputs().size());
+    for (const auto& input : call->inputs()) {
+      if (auto arg = extractFiltersFromRemainingFilter(
+              input, evaluator, negated, filters, sampleRate)) {
+        args.push_back(std::move(arg));
+      }
+      // If extractFiltersFromRemainingFilter returns nullptr, it means
+      // everything in input is converted to filters.
+    }
+    if (args.empty()) {
+      return nullptr;
     }
-    if (!rhs) {
-      return lhs;
+    if (args.size() == 1) {
+      return std::move(args[0]);
     }
-    return replaceInputs(call, {lhs, rhs});
+    return replaceInputs(call, std::move(args));
   }
+
+  if ((call->name() == expression::kAnd && negated) ||
+      (call->name() == expression::kOr && !negated)) {
+    std::vector<std::unique_ptr<common::Filter>> disjuncts;
+    common::Subfield subfield;
+
+    for (const auto& input : call->inputs()) {
+      common::SubfieldFilters tmpFilters;
+      double tmpSampleRate = 1;
+      auto tmpRemaining = extractFiltersFromRemainingFilter(
+          input, evaluator, negated, tmpFilters, tmpSampleRate);
+
+      if (tmpRemaining != nullptr || tmpSampleRate != 1 ||
+          tmpFilters.size() != 1) {
+        disjuncts.clear();
+        break;
+      }
+
+      if (disjuncts.empty()) {
+        subfield = tmpFilters.begin()->first.clone();
+      } else if (!(subfield == tmpFilters.begin()->first)) {
+        disjuncts.clear();
+        break;
+      }
+
+      disjuncts.push_back(tmpFilters.begin()->second->clone());
+    }
+
+    if (!disjuncts.empty()) {
+      auto filter =
+          exec::ExprToSubfieldFilterParser::makeOrFilter(std::move(disjuncts));
+
+      if (filter == nullptr) {
+        return expr;
+      }
+
+      auto it = filters.find(subfield);
+      if (it != filters.end()) {
+        filter = filter->mergeWith(it->second.get());
+      }
+
+      filters.insert_or_assign(std::move(subfield), std::move(filter));
+
+      return nullptr;
+    }
+  }
+
   if (!negated) {
     double rate = getPrestoSampleRate(expr, call, evaluator);
     if (rate != -1) {
@@ -908,6 +984,18 @@ core::TypedExprPtr extractFiltersFromRemainingFilter(
       return nullptr;
     }
   }
+
   return expr;
 }
+} // namespace
+
+core::TypedExprPtr extractFiltersFromRemainingFilter(
+    const core::TypedExprPtr& expr,
+    core::ExpressionEvaluator* evaluator,
+    common::SubfieldFilters& filters,
+    double& sampleRate) {
+  return extractFiltersFromRemainingFilter(
+      expr, evaluator, /*negated=*/false, filters, sampleRate);
+}
+
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HiveConnectorUtil.h b/velox/connectors/hive/HiveConnectorUtil.h
index 0209a50848e2..a1e35cdcd27a 100644
--- a/velox/connectors/hive/HiveConnectorUtil.h
+++ b/velox/connectors/hive/HiveConnectorUtil.h
@@ -32,12 +32,13 @@ struct HiveConnectorSplit;
 
 const std::string& getColumnName(const common::Subfield& subfield);
 
-void checkColumnNameLowerCase(const std::shared_ptr<const Type>& type);
+void checkColumnNameLowerCase(const TypePtr& type);
 
 void checkColumnNameLowerCase(
     const common::SubfieldFilters& filters,
-    const std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>&
-        infoColumns);
+    const std::unordered_map<
+        std::string,
+        std::shared_ptr<const HiveColumnHandle>>& infoColumns);
 
 void checkColumnNameLowerCase(const core::TypedExprPtr& typeExpr);
 
@@ -52,10 +53,12 @@ std::shared_ptr<common::ScanSpec> makeScanSpec(
         outputSubfields,
     const common::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::unordered_map<
+        std::string,
+        std::shared_ptr<const HiveColumnHandle>>& partitionKeys,
+    const std::unordered_map<
+        std::string,
+        std::shared_ptr<const HiveColumnHandle>>& infoColumns,
     const SpecialColumnNames& specialColumns,
     bool disableStatsBasedFilterReorder,
     memory::MemoryPool* pool);
@@ -83,6 +86,7 @@ void configureRowReaderOptions(
     const std::shared_ptr<const HiveConnectorSplit>& hiveSplit,
     const std::shared_ptr<const HiveConfig>& hiveConfig,
     const config::ConfigBase* sessionProperties,
+    folly::Executor* ioExecutor,
     dwio::common::RowReaderOptions& rowReaderOptions);
 
 bool testFilters(
@@ -91,8 +95,9 @@ bool testFilters(
     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,
+    const std::unordered_map<
+        std::string,
+        std::shared_ptr<const HiveColumnHandle>>& partitionKeysHandle,
     bool asLocalTime);
 
 std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
@@ -101,12 +106,49 @@ std::unique_ptr<dwio::common::BufferedInput> createBufferedInput(
     const ConnectorQueryCtx* connectorQueryCtx,
     std::shared_ptr<io::IoStatistics> ioStats,
     std::shared_ptr<filesystems::File::IoStats> fsStats,
-    folly::Executor* executor);
-
+    folly::Executor* executor,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps = {});
+
+/// Given a boolean expression, breaks it up into conjuncts and sorts these into
+/// single-column comparisons with constants (filters), rand() < sampleRate, and
+/// the rest (return value).
+///
+/// Multiple rand() < K conjuncts are combined into a single sampleRate by
+/// multiplying individual sample rates. rand() < 0.1 and rand() < 0.2 produces
+/// sampleRate = 0.02.
+///
+/// Multiple single-column comparisons with constants that reference the same
+/// column or subfield are combined into a single filter. Pre-existing entries
+/// in 'filters' are preserved and combined with the ones extracted from the
+/// 'expr'.
+///
+/// NOT(x OR y) is converted to (NOT x) AND (NOT y).
+///
+/// @param expr Boolean expression to break up.
+/// @param evaluator Expression evaluator to use.
+/// @param filters Mapping from a column or a subfield to comparison with
+/// constant.
+/// @param sampleRate Sample rate extracted from rand() < sampleRate conjuncts.
+/// @return Expression with filters and rand() < sampleRate conjuncts removed.
+///
+/// Examples:
+///   expr := a = 1 AND b > 0
+///   filters := {a: eq(1), b: gt(0)}
+//    sampleRate left unmodified
+//    return value is nullptr
+///
+///   expr: not (a > 0 or b > 10)
+///   filters := {a: le(0), b: le(10)}
+///   sampleRate left unmodified
+///   return value is nullptr
+///
+///   expr := a > 0 AND a < b AND rand() < 0.1
+///   filters := {a: gt(0)}
+///   sampleRate := 0.1
+///   return value is a < b
 core::TypedExprPtr extractFiltersFromRemainingFilter(
     const core::TypedExprPtr& expr,
     core::ExpressionEvaluator* evaluator,
-    bool negated,
     common::SubfieldFilters& filters,
     double& sampleRate);
 
diff --git a/velox/connectors/hive/HiveDataSink.cpp b/velox/connectors/hive/HiveDataSink.cpp
index f6f3c8d8c656..16eb602724e8 100644
--- a/velox/connectors/hive/HiveDataSink.cpp
+++ b/velox/connectors/hive/HiveDataSink.cpp
@@ -24,7 +24,6 @@
 #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/Options.h"
 #include "velox/dwio/common/SortingWriter.h"
 #include "velox/exec/OperatorUtils.h"
@@ -78,36 +77,23 @@ RowVectorPtr makeDataInput(
       input->getNullCount());
 }
 
-// Returns a subset of column indices corresponding to partition keys.
-std::vector<column_index_t> getPartitionChannels(
-    const std::shared_ptr<const HiveInsertTableHandle>& insertTableHandle) {
-  std::vector<column_index_t> channels;
-
-  for (column_index_t i = 0; i < insertTableHandle->inputColumns().size();
-       i++) {
-    if (insertTableHandle->inputColumns()[i]->isPartitionKey()) {
-      channels.push_back(i);
-    }
-  }
-
-  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);
-    }
+// Creates a PartitionIdGenerator if the table is partitioned, otherwise returns
+// nullptr.
+std::unique_ptr<PartitionIdGenerator> createPartitionIdGenerator(
+    const RowTypePtr& inputType,
+    const std::shared_ptr<const HiveInsertTableHandle>& insertTableHandle,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const ConnectorQueryCtx* connectorQueryCtx) {
+  auto partitionChannels = insertTableHandle->partitionChannels();
+  if (partitionChannels.empty()) {
+    return nullptr;
   }
-
-  return dataChannels;
+  return std::make_unique<PartitionIdGenerator>(
+      inputType,
+      partitionChannels,
+      hiveConfig->maxPartitionsPerWriters(
+          connectorQueryCtx->sessionProperties()),
+      connectorQueryCtx->memoryPool());
 }
 
 std::string makePartitionDirectory(
@@ -166,9 +152,10 @@ std::unique_ptr<core::PartitionFunction> createBucketFunction(
 
 std::string computeBucketedFileName(
     const std::string& queryId,
+    uint32_t maxBucketCount,
     uint32_t bucket) {
-  static const uint32_t kMaxBucketCountPadding =
-      std::to_string(HiveDataSink::maxBucketCount() - 1).size();
+  const uint32_t kMaxBucketCountPadding =
+      std::to_string(maxBucketCount - 1).size();
   const std::string bucketValueStr = std::to_string(bucket);
   return fmt::format(
       "0{:0>{}}_0_{}", bucketValueStr, kMaxBucketCountPadding, queryId);
@@ -200,6 +187,29 @@ FOLLY_ALWAYS_INLINE int32_t
 getBucketCount(const HiveBucketProperty* bucketProperty) {
   return bucketProperty == nullptr ? 0 : bucketProperty->bucketCount();
 }
+
+std::vector<column_index_t> computePartitionChannels(
+    const std::vector<std::shared_ptr<const HiveColumnHandle>>& inputColumns) {
+  std::vector<column_index_t> channels;
+  for (auto i = 0; i < inputColumns.size(); i++) {
+    if (inputColumns[i]->isPartitionKey()) {
+      channels.push_back(i);
+    }
+  }
+  return channels;
+}
+
+std::vector<column_index_t> computeNonPartitionChannels(
+    const std::vector<std::shared_ptr<const HiveColumnHandle>>& inputColumns) {
+  std::vector<column_index_t> channels;
+  for (auto i = 0; i < inputColumns.size(); i++) {
+    if (!inputColumns[i]->isPartitionKey()) {
+      channels.push_back(i);
+    }
+  }
+  return channels;
+}
+
 } // namespace
 
 const HiveWriterId& HiveWriterId::unpartitionedId() {
@@ -365,6 +375,52 @@ std::string HiveBucketProperty::toString() const {
   return out.str();
 }
 
+HiveInsertTableHandle::HiveInsertTableHandle(
+    std::vector<std::shared_ptr<const HiveColumnHandle>> inputColumns,
+    std::shared_ptr<const LocationHandle> locationHandle,
+    dwio::common::FileFormat storageFormat,
+    std::shared_ptr<const HiveBucketProperty> bucketProperty,
+    std::optional<common::CompressionKind> compressionKind,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
+    const std::shared_ptr<dwio::common::WriterOptions>& writerOptions,
+    // When this option is set the HiveDataSink will always write a file even
+    // if there's no data. This is useful when the table is bucketed, but the
+    // engine handles ensuring a 1 to 1 mapping from task to bucket.
+    const bool ensureFiles,
+    std::shared_ptr<const FileNameGenerator> fileNameGenerator)
+    : inputColumns_(std::move(inputColumns)),
+      locationHandle_(std::move(locationHandle)),
+      storageFormat_(storageFormat),
+      bucketProperty_(std::move(bucketProperty)),
+      compressionKind_(compressionKind),
+      serdeParameters_(serdeParameters),
+      writerOptions_(writerOptions),
+      ensureFiles_(ensureFiles),
+      fileNameGenerator_(std::move(fileNameGenerator)),
+      partitionChannels_(computePartitionChannels(inputColumns_)),
+      nonPartitionChannels_(computeNonPartitionChannels(inputColumns_)) {
+  if (compressionKind.has_value()) {
+    VELOX_CHECK(
+        compressionKind.value() != common::CompressionKind_MAX,
+        "Unsupported compression type: CompressionKind_MAX");
+  }
+
+  if (ensureFiles_) {
+    // If ensureFiles is set and either the bucketProperty is set or some
+    // partition keys are in the data, there is not a 1:1 mapping from Task to
+    // files so we can't proactively create writers.
+    VELOX_CHECK(
+        bucketProperty_ == nullptr || bucketProperty_->bucketCount() == 0,
+        "ensureFiles is not supported with bucketing");
+
+    for (const auto& inputColumn : inputColumns_) {
+      VELOX_CHECK(
+          !inputColumn->isPartitionKey(),
+          "ensureFiles is not supported with partition keys in the data");
+    }
+  }
+}
+
 HiveDataSink::HiveDataSink(
     RowTypePtr inputType,
     std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
@@ -382,7 +438,14 @@ HiveDataSink::HiveDataSink(
               ? createBucketFunction(
                     *insertTableHandle->bucketProperty(),
                     inputType)
-              : nullptr) {}
+              : nullptr,
+          insertTableHandle->partitionChannels(),
+          insertTableHandle->nonPartitionChannels(),
+          createPartitionIdGenerator(
+              inputType,
+              insertTableHandle,
+              hiveConfig,
+              connectorQueryCtx)) {}
 
 HiveDataSink::HiveDataSink(
     RowTypePtr inputType,
@@ -391,7 +454,10 @@ HiveDataSink::HiveDataSink(
     CommitStrategy commitStrategy,
     const std::shared_ptr<const HiveConfig>& hiveConfig,
     uint32_t bucketCount,
-    std::unique_ptr<core::PartitionFunction> bucketFunction)
+    std::unique_ptr<core::PartitionFunction> bucketFunction,
+    const std::vector<column_index_t>& partitionChannels,
+    const std::vector<column_index_t>& dataChannels,
+    std::unique_ptr<PartitionIdGenerator> partitionIdGenerator)
     : inputType_(std::move(inputType)),
       insertTableHandle_(std::move(insertTableHandle)),
       connectorQueryCtx_(connectorQueryCtx),
@@ -400,19 +466,9 @@ HiveDataSink::HiveDataSink(
       updateMode_(getUpdateMode()),
       maxOpenWriters_(hiveConfig_->maxPartitionsPerWriters(
           connectorQueryCtx->sessionProperties())),
-      partitionChannels_(getPartitionChannels(insertTableHandle_)),
-      partitionIdGenerator_(
-          !partitionChannels_.empty()
-              ? std::make_unique<PartitionIdGenerator>(
-                    inputType_,
-                    partitionChannels_,
-                    maxOpenWriters_,
-                    connectorQueryCtx_->memoryPool(),
-                    hiveConfig_->isPartitionPathAsLowerCase(
-                        connectorQueryCtx->sessionProperties()))
-              : nullptr),
-      dataChannels_(
-          getNonPartitionChannels(partitionChannels_, inputType_->size())),
+      partitionChannels_(partitionChannels),
+      partitionIdGenerator_(std::move(partitionIdGenerator)),
+      dataChannels_(dataChannels),
       bucketCount_(static_cast<int32_t>(bucketCount)),
       bucketFunction_(std::move(bucketFunction)),
       writerFactory_(
@@ -421,16 +477,21 @@ HiveDataSink::HiveDataSink(
       sortWriterFinishTimeSliceLimitMs_(getFinishTimeSliceLimitMsFromHiveConfig(
           hiveConfig_,
           connectorQueryCtx->sessionProperties())),
+      partitionKeyAsLowerCase_(hiveConfig_->isPartitionPathAsLowerCase(
+          connectorQueryCtx_->sessionProperties())),
       fileNameGenerator_(insertTableHandle_->fileNameGenerator()) {
+  fileSystemStats_ = std::make_unique<filesystems::File::IoStats>();
   if (isBucketed()) {
     VELOX_USER_CHECK_LT(
-        bucketCount_, maxBucketCount(), "bucketCount exceeds the limit");
+        bucketCount_,
+        hiveConfig_->maxBucketCount(connectorQueryCtx->sessionProperties()),
+        "bucketCount exceeds the limit");
   }
   VELOX_USER_CHECK(
       (commitStrategy_ == CommitStrategy::kNoCommit) ||
           (commitStrategy_ == CommitStrategy::kTaskCommit),
       "Unsupported commit strategy: {}",
-      commitStrategyToString(commitStrategy_));
+      CommitStrategyName::toName(commitStrategy_));
 
   if (insertTableHandle_->ensureFiles()) {
     VELOX_CHECK(
@@ -465,12 +526,16 @@ HiveDataSink::HiveDataSink(
 bool HiveDataSink::canReclaim() const {
   // Currently, we only support memory reclaim on dwrf file writer.
   return (spillConfig_ != nullptr) &&
-      (insertTableHandle_->storageFormat() == dwio::common::FileFormat::DWRF);
+      (insertTableHandle_->storageFormat() == dwio::common::FileFormat::DWRF ||
+       insertTableHandle_->storageFormat() == dwio::common::FileFormat::NIMBLE);
 }
 
 void HiveDataSink::appendData(RowVectorPtr input) {
   checkRunning();
 
+  // Lazy load all the input columns.
+  input->loadedVector();
+
   // Write to unpartitioned (and unbucketed) table.
   if (!isPartitioned() && !isBucketed()) {
     const auto index = ensureWriter(HiveWriterId::unpartitionedId());
@@ -481,11 +546,6 @@ void HiveDataSink::appendData(RowVectorPtr input) {
   // Compute partition and bucket numbers.
   computePartitionAndBucketIds(input);
 
-  // Lazy load all the input columns.
-  for (column_index_t i = 0; i < input->childrenSize(); ++i) {
-    input->childAt(i)->loadedVector();
-  }
-
   // All inputs belong to a single non-bucketed partition. The partition id
   // must be zero.
   if (!isBucketed() && partitionIdGenerator_->numPartitions() == 1) {
@@ -590,6 +650,19 @@ DataSink::Stats HiveDataSink::stats() const {
   return stats;
 }
 
+std::unordered_map<std::string, RuntimeCounter> HiveDataSink::runtimeStats()
+    const {
+  std::unordered_map<std::string, RuntimeCounter> runtimeStats;
+
+  const auto fsStatsMap = fileSystemStats_->stats();
+  for (const auto& [statName, statValue] : fsStatsMap) {
+    runtimeStats.emplace(
+        statName, RuntimeCounter(statValue.sum, statValue.unit));
+  }
+
+  return runtimeStats;
+}
+
 std::shared_ptr<memory::MemoryPool> HiveDataSink::createWriterPool(
     const HiveWriterId& writerId) {
   auto* connectorPool = connectorQueryCtx_->connectorMemoryPool();
@@ -667,7 +740,10 @@ bool HiveDataSink::finish() {
 std::vector<std::string> HiveDataSink::close() {
   setState(State::kClosed);
   closeInternal();
+  return commitMessage();
+}
 
+std::vector<std::string> HiveDataSink::commitMessage() const {
   std::vector<std::string> partitionUpdates;
   partitionUpdates.reserve(writerInfo_.size());
   for (int i = 0; i < writerInfo_.size(); ++i) {
@@ -730,38 +806,8 @@ uint32_t HiveDataSink::ensureWriter(const HiveWriterId& id) {
   return appendWriter(id);
 }
 
-uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
-  // Check max open writers.
-  VELOX_USER_CHECK_LE(
-      writers_.size(), maxOpenWriters_, "Exceeded open writer limit");
-  VELOX_CHECK_EQ(writers_.size(), writerInfo_.size());
-  VELOX_CHECK_EQ(writerIndexMap_.size(), writerInfo_.size());
-
-  std::optional<std::string> partitionName;
-  if (isPartitioned()) {
-    partitionName =
-        partitionIdGenerator_->partitionName(id.partitionId.value());
-  }
-
-  // Without explicitly setting flush policy, the default memory based flush
-  // policy is used.
-  auto writerParameters = getWriterParameters(partitionName, id.bucketId);
-  const auto writePath = fs::path(writerParameters.writeDirectory()) /
-      writerParameters.writeFileName();
-  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());
-
+std::shared_ptr<dwio::common::WriterOptions> HiveDataSink::createWriterOptions()
+    const {
   // Take the writer options provided by the user as a starting point, or
   // allocate a new one.
   auto options = insertTableHandle_->writerOptions();
@@ -789,10 +835,11 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
     options->spillConfig = spillConfig_;
   }
 
-  if (options->nonReclaimableSection == nullptr) {
-    options->nonReclaimableSection =
-        writerInfo_.back()->nonReclaimableSectionHolder.get();
-  }
+  // Always set nonReclaimableSection to the current writer's holder.
+  // Since insertTableHandle_->writerOptions() returns a shared_ptr, we need
+  // to ensure each writer has its own nonReclaimableSection pointer.
+  options->nonReclaimableSection =
+      writerInfo_.back()->nonReclaimableSectionHolder.get();
 
   if (options->memoryReclaimerFactory == nullptr ||
       options->memoryReclaimerFactory() == nullptr) {
@@ -811,6 +858,43 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
   options->adjustTimestampToTimezone =
       connectorQueryCtx_->adjustTimestampToTimezone();
   options->processConfigs(*hiveConfig_->config(), *connectorSessionProperties);
+  return options;
+}
+
+uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
+  // Check max open writers.
+  VELOX_USER_CHECK_LE(
+      writers_.size(), maxOpenWriters_, "Exceeded open writer limit");
+  VELOX_CHECK_EQ(writers_.size(), writerInfo_.size());
+  VELOX_CHECK_EQ(writerIndexMap_.size(), writerInfo_.size());
+
+  std::optional<std::string> partitionName;
+  if (isPartitioned()) {
+    partitionName = getPartitionName(id.partitionId.value());
+  }
+
+  // Without explicitly setting flush policy, the default memory based flush
+  // policy is used.
+  auto writerParameters = getWriterParameters(partitionName, id.bucketId);
+  const auto writePath = fs::path(writerParameters.writeDirectory()) /
+      writerParameters.writeFileName();
+  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_unique<io::IoStatistics>());
+
+  setMemoryReclaimers(writerInfo_.back().get(), ioStats_.back().get());
+
+  auto options = createWriterOptions();
 
   // Prevents the memory allocation during the writer creation.
   WRITER_NON_RECLAIMABLE_SECTION_GUARD(writerInfo_.size() - 1);
@@ -824,10 +908,16 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
               .pool = writerInfo_.back()->sinkPool.get(),
               .metricLogger = dwio::common::MetricsLog::voidLog(),
               .stats = ioStats_.back().get(),
+              .fileSystemStats = fileSystemStats_.get(),
           }),
       options);
   writer = maybeCreateBucketSortWriter(std::move(writer));
   writers_.emplace_back(std::move(writer));
+  addThreadLocalRuntimeStat(
+      fmt::format(
+          "{}WriterCount",
+          dwio::common::toString(insertTableHandle_->storageFormat())),
+      RuntimeCounter(1));
   // Extends the buffer used for partition rows calculations.
   partitionSizes_.emplace_back(0);
   partitionRows_.emplace_back(nullptr);
@@ -837,6 +927,15 @@ uint32_t HiveDataSink::appendWriter(const HiveWriterId& id) {
   return writerIndexMap_[id];
 }
 
+std::string HiveDataSink::getPartitionName(uint32_t partitionId) const {
+  VELOX_CHECK_NOT_NULL(partitionIdGenerator_);
+
+  return HivePartitionName::partitionName(
+      partitionId,
+      partitionIdGenerator_->partitionValues(),
+      partitionKeyAsLowerCase_);
+}
+
 std::unique_ptr<facebook::velox::dwio::common::Writer>
 HiveDataSink::maybeCreateBucketSortWriter(
     std::unique_ptr<facebook::velox::dwio::common::Writer> writer) {
@@ -878,6 +977,24 @@ HiveWriterId HiveDataSink::getWriterId(size_t row) const {
   return HiveWriterId{partitionId, bucketId};
 }
 
+void HiveDataSink::updatePartitionRows(
+    uint32_t index,
+    vector_size_t numRows,
+    vector_size_t row) {
+  VELOX_DCHECK_LT(index, partitionSizes_.size());
+  VELOX_DCHECK_EQ(partitionSizes_.size(), partitionRows_.size());
+  VELOX_DCHECK_EQ(partitionRows_.size(), rawPartitionRows_.size());
+  if (FOLLY_UNLIKELY(partitionRows_[index] == nullptr) ||
+      (partitionRows_[index]->capacity() < numRows * sizeof(vector_size_t))) {
+    partitionRows_[index] =
+        allocateIndices(numRows, connectorQueryCtx_->memoryPool());
+    rawPartitionRows_[index] =
+        partitionRows_[index]->asMutable<vector_size_t>();
+  }
+  rawPartitionRows_[index][partitionSizes_[index]] = row;
+  ++partitionSizes_[index];
+}
+
 void HiveDataSink::splitInputRowsAndEnsureWriters() {
   VELOX_CHECK(isPartitioned() || isBucketed());
   if (isBucketed() && isPartitioned()) {
@@ -891,19 +1008,7 @@ void HiveDataSink::splitInputRowsAndEnsureWriters() {
   for (auto row = 0; row < numRows; ++row) {
     const auto id = getWriterId(row);
     const 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());
-    if (FOLLY_UNLIKELY(partitionRows_[index] == nullptr) ||
-        (partitionRows_[index]->capacity() < numRows * sizeof(vector_size_t))) {
-      partitionRows_[index] =
-          allocateIndices(numRows, connectorQueryCtx_->memoryPool());
-      rawPartitionRows_[index] =
-          partitionRows_[index]->asMutable<vector_size_t>();
-    }
-    rawPartitionRows_[index][partitionSizes_[index]] = row;
-    ++partitionSizes_[index];
+    updatePartitionRows(index, numRows, row);
   }
 
   for (uint32_t i = 0; i < partitionSizes_.size(); ++i) {
@@ -932,6 +1037,17 @@ HiveWriterParameters HiveDataSink::getWriterParameters(
 
 std::pair<std::string, std::string> HiveDataSink::getWriterFileNames(
     std::optional<uint32_t> bucketId) const {
+  if (auto hiveInsertFileNameGenerator =
+          std::dynamic_pointer_cast<const HiveInsertFileNameGenerator>(
+              fileNameGenerator_)) {
+    return hiveInsertFileNameGenerator->gen(
+        bucketId,
+        insertTableHandle_,
+        *connectorQueryCtx_,
+        hiveConfig_,
+        isCommitRequired());
+  }
+
   return fileNameGenerator_->gen(
       bucketId, insertTableHandle_, *connectorQueryCtx_, isCommitRequired());
 }
@@ -941,13 +1057,33 @@ std::pair<std::string, std::string> HiveInsertFileNameGenerator::gen(
     const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
     const ConnectorQueryCtx& connectorQueryCtx,
     bool commitRequired) const {
+  auto defaultHiveConfig =
+      std::make_shared<const HiveConfig>(std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+
+  return this->gen(
+      bucketId,
+      insertTableHandle,
+      connectorQueryCtx,
+      defaultHiveConfig,
+      commitRequired);
+}
+
+std::pair<std::string, std::string> HiveInsertFileNameGenerator::gen(
+    std::optional<uint32_t> bucketId,
+    const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
+    const ConnectorQueryCtx& connectorQueryCtx,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    bool commitRequired) const {
   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());
+    targetFileName = computeBucketedFileName(
+        connectorQueryCtx.queryId(),
+        hiveConfig->maxBucketCount(connectorQueryCtx.sessionProperties()),
+        bucketId.value());
   } 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
diff --git a/velox/connectors/hive/HiveDataSink.h b/velox/connectors/hive/HiveDataSink.h
index c1354b1ca6b3..bf1ad3b6c39f 100644
--- a/velox/connectors/hive/HiveDataSink.h
+++ b/velox/connectors/hive/HiveDataSink.h
@@ -18,6 +18,7 @@
 #include "velox/common/compression/Compression.h"
 #include "velox/connectors/Connector.h"
 #include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/HivePartitionName.h"
 #include "velox/connectors/hive/PartitionIdGenerator.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/dwio/common/Options.h"
@@ -25,10 +26,6 @@
 #include "velox/dwio/common/WriterFactory.h"
 #include "velox/exec/MemoryReclaimer.h"
 
-namespace facebook::velox::dwrf {
-class Writer;
-}
-
 namespace facebook::velox::connector::hive {
 
 class LocationHandle;
@@ -217,6 +214,15 @@ class HiveInsertFileNameGenerator : public FileNameGenerator {
       const ConnectorQueryCtx& connectorQueryCtx,
       bool commitRequired) const override;
 
+  /// Version of file generation that takes hiveConfig into account when
+  /// generating file names
+  std::pair<std::string, std::string> gen(
+      std::optional<uint32_t> bucketId,
+      const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
+      const ConnectorQueryCtx& connectorQueryCtx,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      bool commitRequired) const;
+
   static void registerSerDe();
 
   folly::dynamic serialize() const override;
@@ -245,37 +251,7 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
       // engine handles ensuring a 1 to 1 mapping from task to bucket.
       const bool ensureFiles = false,
       std::shared_ptr<const FileNameGenerator> fileNameGenerator =
-          std::make_shared<const HiveInsertFileNameGenerator>())
-      : inputColumns_(std::move(inputColumns)),
-        locationHandle_(std::move(locationHandle)),
-        storageFormat_(storageFormat),
-        bucketProperty_(std::move(bucketProperty)),
-        compressionKind_(compressionKind),
-        serdeParameters_(serdeParameters),
-        writerOptions_(writerOptions),
-        ensureFiles_(ensureFiles),
-        fileNameGenerator_(std::move(fileNameGenerator)) {
-    if (compressionKind.has_value()) {
-      VELOX_CHECK(
-          compressionKind.value() != common::CompressionKind_MAX,
-          "Unsupported compression type: CompressionKind_MAX");
-    }
-
-    if (ensureFiles_) {
-      // If ensureFiles is set and either the bucketProperty is set or some
-      // partition keys are in the data, there is not a 1:1 mapping from Task to
-      // files so we can't proactively create writers.
-      VELOX_CHECK(
-          bucketProperty_ == nullptr || bucketProperty_->bucketCount() == 0,
-          "ensureFiles is not supported with bucketing");
-
-      for (const auto& inputColumn : inputColumns_) {
-        VELOX_CHECK(
-            !inputColumn->isPartitionKey(),
-            "ensureFiles is not supported with partition keys in the data");
-      }
-    }
-  }
+          std::make_shared<const HiveInsertFileNameGenerator>());
 
   virtual ~HiveInsertTableHandle() = default;
 
@@ -324,6 +300,16 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
 
   bool isExistingTable() const;
 
+  /// Returns a subset of column indices corresponding to partition keys.
+  const std::vector<column_index_t>& partitionChannels() const {
+    return partitionChannels_;
+  }
+
+  /// Returns the column indices of non-partition data columns.
+  const std::vector<column_index_t>& nonPartitionChannels() const {
+    return nonPartitionChannels_;
+  }
+
   folly::dynamic serialize() const override;
 
   static HiveInsertTableHandlePtr create(const folly::dynamic& obj);
@@ -332,9 +318,11 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
 
   std::string toString() const override;
 
- private:
+ protected:
   const std::vector<std::shared_ptr<const HiveColumnHandle>> inputColumns_;
   const std::shared_ptr<const LocationHandle> locationHandle_;
+
+ private:
   const dwio::common::FileFormat storageFormat_;
   const std::shared_ptr<const HiveBucketProperty> bucketProperty_;
   const std::optional<common::CompressionKind> compressionKind_;
@@ -342,6 +330,8 @@ class HiveInsertTableHandle : public ConnectorInsertTableHandle {
   const std::shared_ptr<dwio::common::WriterOptions> writerOptions_;
   const bool ensureFiles_;
   const std::shared_ptr<const FileNameGenerator> fileNameGenerator_;
+  const std::vector<column_index_t> partitionChannels_;
+  const std::vector<column_index_t> nonPartitionChannels_;
 };
 
 /// Parameters for Hive writers.
@@ -509,6 +499,17 @@ class HiveDataSink : public DataSink {
   };
   static std::string stateString(State state);
 
+  /// Creates a HiveDataSink for writing data to Hive table files.
+  ///
+  /// @param inputType The schema of input data rows to be written.
+  /// @param insertTableHandle Metadata about the table write operation,
+  /// including storage format, compression, bucketing, and partitioning
+  /// configuration.
+  /// @param connectorQueryCtx Query context with session properties, memory
+  /// pools, and spill configuration.
+  /// @param commitStrategy Strategy for committing written data (kNoCommit or
+  /// kTaskCommit).
+  /// @param hiveConfig Hive connector configuration.
   HiveDataSink(
       RowTypePtr inputType,
       std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
@@ -516,6 +517,31 @@ class HiveDataSink : public DataSink {
       CommitStrategy commitStrategy,
       const std::shared_ptr<const HiveConfig>& hiveConfig);
 
+  /// Constructor with explicit bucketing and partitioning parameters.
+  ///
+  /// @param inputType The schema of input data rows to be written.
+  /// @param insertTableHandle Metadata about the table write operation,
+  /// including storage format, compression, location, and serialization
+  /// parameters.
+  /// @param connectorQueryCtx Query context with session properties, memory
+  /// pools, and spill configuration.
+  /// @param commitStrategy Strategy for committing written data (kNoCommit or
+  /// kTaskCommit). Determines whether temporary files need to be renamed on
+  /// commit.
+  /// @param hiveConfig Hive connector configuration with settings for max
+  /// partitions, bucketing limits etc.
+  /// @param bucketCount Number of buckets for bucketed tables (0 if not
+  /// bucketed). Must be less than the configured max bucket count.
+  /// @param bucketFunction Function to compute bucket IDs from row data
+  /// (nullptr if not bucketed). Used to distribute rows across buckets.
+  /// @param partitionChannels Column indices used for partitioning (empty if
+  /// not partitioned). These columns are extracted to determine partition
+  /// directories.
+  /// @param dataChannels Column indices for the actual data columns to be
+  /// written.
+  /// @param partitionIdGenerator Generates partition IDs from partition column
+  /// values (nullptr if not partitioned). Compute partition key combinations to
+  /// unique IDs.
   HiveDataSink(
       RowTypePtr inputType,
       std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
@@ -523,12 +549,10 @@ class HiveDataSink : public DataSink {
       CommitStrategy commitStrategy,
       const std::shared_ptr<const HiveConfig>& hiveConfig,
       uint32_t bucketCount,
-      std::unique_ptr<core::PartitionFunction> bucketFunction);
-
-  static uint32_t maxBucketCount() {
-    static const uint32_t kMaxBucketCount = 100'000;
-    return kMaxBucketCount;
-  }
+      std::unique_ptr<core::PartitionFunction> bucketFunction,
+      const std::vector<column_index_t>& partitionChannels,
+      const std::vector<column_index_t>& dataChannels,
+      std::unique_ptr<PartitionIdGenerator> partitionIdGenerator);
 
   void appendData(RowVectorPtr input) override;
 
@@ -536,17 +560,27 @@ class HiveDataSink : public DataSink {
 
   Stats stats() const override;
 
+  std::unordered_map<std::string, RuntimeCounter> runtimeStats() const override;
+
   std::vector<std::string> close() override;
 
   void abort() override;
 
   bool canReclaim() const;
 
- private:
+ protected:
   // Validates the state transition from 'oldState' to 'newState'.
   void checkStateTransition(State oldState, State newState);
   void setState(State newState);
 
+  // Generates commit messages for all writers containing metadata about written
+  // files. Creates a JSON object for each writer with partition name,
+  // file paths, file names, data sizes, and row counts. This metadata is used
+  // by the coordinator to commit the transaction and update the metastore.
+  //
+  // @return Vector of JSON strings, one per writer.
+  virtual std::vector<std::string> commitMessage() const;
+
   class WriterReclaimer : public exec::MemoryReclaimer {
    public:
     static std::unique_ptr<memory::MemoryReclaimer> create(
@@ -609,11 +643,11 @@ class HiveDataSink : public DataSink {
       io::IoStatistics* ioStats);
 
   // Compute the partition id and bucket id for each row in 'input'.
-  void computePartitionAndBucketIds(const RowVectorPtr& input);
+  virtual 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;
+  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
@@ -623,16 +657,36 @@ class HiveDataSink : public DataSink {
 
   // Makes sure to create one writer for the given writer id. The function
   // returns the corresponding index in 'writers_'.
-  uint32_t ensureWriter(const HiveWriterId& id);
+  virtual uint32_t ensureWriter(const HiveWriterId& id);
 
   // Appends a new writer for the given 'id'. The function returns the index of
   // the newly created writer in 'writers_'.
   uint32_t appendWriter(const HiveWriterId& id);
 
+  // Creates and configures WriterOptions based on file format.
+  // Sets up compression, schema, and other writer configuration based on the
+  // insert table handle and connector settings.
+  virtual std::shared_ptr<dwio::common::WriterOptions> createWriterOptions()
+      const;
+
+  // Returns the Hive partition directory name for the given partition ID.
+  // Converts the partition values associated with the partition ID into a
+  // Hive-formatted directory path. Returns std::nullopt if the table is
+  // unpartitioned. Should be called only when writing to a partitioned table.
+  virtual std::string getPartitionName(uint32_t partitionId) const;
+
   std::unique_ptr<facebook::velox::dwio::common::Writer>
   maybeCreateBucketSortWriter(
       std::unique_ptr<facebook::velox::dwio::common::Writer> writer);
 
+  // Records a row index for a specific partition. This method maintains the
+  // mapping of which input rows belong to which partition by storing row
+  // indices in partition-specific buffers. If the buffer for the partition
+  // doesn't exist or is too small, it allocates/reallocates the buffer to
+  // accommodate all rows.
+  void
+  updatePartitionRows(uint32_t index, vector_size_t numRows, vector_size_t row);
+
   HiveWriterParameters getWriterParameters(
       const std::optional<std::string>& partition,
       std::optional<uint32_t> bucketId) const;
@@ -658,6 +712,15 @@ class HiveDataSink : public DataSink {
 
   void closeInternal();
 
+  // IMPORTANT NOTE: these are passed to writers as raw pointers. HiveDataSink
+  // owns the lifetime of these objects, and therefore must destroy them last.
+  // Additionally, we must assume that no objects which hold a reference to
+  // these stats will outlive the HiveDataSink instance. This is a reasonable
+  // assumption given the semantics of these stats objects.
+  std::vector<std::unique_ptr<io::IoStatistics>> ioStats_;
+  // Generic filesystem stats, exposed as RuntimeStats
+  std::unique_ptr<filesystems::File::IoStats> fileSystemStats_;
+
   const RowTypePtr inputType_;
   const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle_;
   const ConnectorQueryCtx* const connectorQueryCtx_;
@@ -674,6 +737,7 @@ class HiveDataSink : public DataSink {
   const std::shared_ptr<dwio::common::WriterFactory> writerFactory_;
   const common::SpillConfig* const spillConfig_;
   const uint64_t sortWriterFinishTimeSliceLimitMs_{0};
+  const bool partitionKeyAsLowerCase_;
 
   std::vector<column_index_t> sortColumnIndices_;
   std::vector<CompareFlags> sortCompareFlags_;
@@ -690,8 +754,6 @@ class HiveDataSink : public DataSink {
   // writers_ are both indexed by partitionId.
   std::vector<std::shared_ptr<HiveWriterInfo>> writerInfo_;
   std::vector<std::unique_ptr<dwio::common::Writer>> writers_;
-  // IO statistics collected for each writer.
-  std::vector<std::shared_ptr<io::IoStatistics>> ioStats_;
 
   // Below are structures updated when processing current input. partitionIds_
   // are indexed by the row of input_. partitionRows_, rawPartitionRows_ and
diff --git a/velox/connectors/hive/HiveDataSource.cpp b/velox/connectors/hive/HiveDataSource.cpp
index 5ee0a1fc9b94..8ae61574eb5a 100644
--- a/velox/connectors/hive/HiveDataSource.cpp
+++ b/velox/connectors/hive/HiveDataSource.cpp
@@ -22,16 +22,12 @@
 
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConfig.h"
-#include "velox/dwio/common/ReaderFactory.h"
 #include "velox/expression/FieldReference.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::connector::hive {
 
-class HiveTableHandle;
-class HiveColumnHandle;
-
 namespace {
 
 bool isMember(
@@ -54,56 +50,99 @@ bool shouldEagerlyMaterialize(
   return false;
 }
 
+void checkColumnHandleConsistent(
+    const HiveColumnHandle& x,
+    const HiveColumnHandle& y) {
+  VELOX_CHECK(
+      x.columnType() == y.columnType(),
+      "Inconsistent column handle: {}",
+      x.name());
+  VELOX_CHECK_EQ(
+      *x.dataType(), *y.dataType(), "Inconsistent column handle: {}", x.name());
+  VELOX_CHECK_EQ(
+      *x.hiveType(), *y.hiveType(), "Inconsistent column handle: {}", x.name());
+}
+
 } // namespace
 
+void HiveDataSource::processColumnHandle(const HiveColumnHandlePtr& handle) {
+  switch (handle->columnType()) {
+    case HiveColumnHandle::ColumnType::kRegular:
+      break;
+    case HiveColumnHandle::ColumnType::kPartitionKey:
+      partitionKeys_.emplace(handle->name(), handle);
+      break;
+    case HiveColumnHandle::ColumnType::kSynthesized:
+      infoColumns_.emplace(handle->name(), handle);
+      break;
+    case HiveColumnHandle::ColumnType::kRowIndex:
+      specialColumns_.rowIndex = handle->name();
+      break;
+    case HiveColumnHandle::ColumnType::kRowId:
+      specialColumns_.rowId = handle->name();
+      break;
+  }
+}
+
 HiveDataSource::HiveDataSource(
     const RowTypePtr& outputType,
-    const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+    const connector::ConnectorTableHandlePtr& tableHandle,
+    const connector::ColumnHandleMap& assignments,
     FileHandleFactory* fileHandleFactory,
-    folly::Executor* executor,
+    folly::Executor* ioExecutor,
     const ConnectorQueryCtx* connectorQueryCtx,
     const std::shared_ptr<HiveConfig>& hiveConfig)
     : fileHandleFactory_(fileHandleFactory),
-      executor_(executor),
+      ioExecutor_(ioExecutor),
       connectorQueryCtx_(connectorQueryCtx),
       hiveConfig_(hiveConfig),
       pool_(connectorQueryCtx->memoryPool()),
       outputType_(outputType),
       expressionEvaluator_(connectorQueryCtx->expressionEvaluator()) {
+  hiveTableHandle_ =
+      std::dynamic_pointer_cast<const HiveTableHandle>(tableHandle);
+  VELOX_CHECK_NOT_NULL(
+      hiveTableHandle_, "TableHandle must be an instance of HiveTableHandle");
+
+  folly::F14FastMap<std::string_view, const HiveColumnHandle*> columnHandles;
   // 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);
+  for (const auto& [canonicalizedName, columnHandle] : assignments) {
+    auto handle =
+        std::dynamic_pointer_cast<const HiveColumnHandle>(columnHandle);
     VELOX_CHECK_NOT_NULL(
         handle,
         "ColumnHandle must be an instance of HiveColumnHandle for {}",
         canonicalizedName);
-    switch (handle->columnType()) {
-      case HiveColumnHandle::ColumnType::kRegular:
-        break;
-      case HiveColumnHandle::ColumnType::kPartitionKey:
-        partitionKeys_.emplace(handle->name(), handle);
-        break;
-      case HiveColumnHandle::ColumnType::kSynthesized:
-        infoColumns_.emplace(handle->name(), handle);
-        break;
-      case HiveColumnHandle::ColumnType::kRowIndex:
-        specialColumns_.rowIndex = handle->name();
-        break;
-      case HiveColumnHandle::ColumnType::kRowId:
-        specialColumns_.rowId = handle->name();
-        break;
+    const auto [it, unique] =
+        columnHandles.emplace(handle->name(), handle.get());
+    if (!unique) {
+      // This should not happen normally, but there is some bug in Presto DELETE
+      // queries that sometimes we do get duplicate assignments for partitioning
+      // columns.
+      checkColumnHandleConsistent(*handle, *it->second);
+      VELOX_CHECK(
+          handle->columnType() == HiveColumnHandle::ColumnType::kPartitionKey,
+          "Cannot map from same table column to different outputs in table scan; a project node should be used instead: {}",
+          handle->name());
+      continue;
+    }
+    processColumnHandle(handle);
+  }
+  for (auto& handle : hiveTableHandle_->filterColumnHandles()) {
+    auto it = columnHandles.find(handle->name());
+    if (it != columnHandles.end()) {
+      checkColumnHandleConsistent(*handle, *it->second);
+      continue;
     }
+    processColumnHandle(handle);
   }
 
   std::vector<std::string> readColumnNames;
   auto readColumnTypes = outputType_->children();
   for (const auto& outputName : outputType_->names()) {
-    auto it = columnHandles.find(outputName);
+    auto it = assignments.find(outputName);
     VELOX_CHECK(
-        it != columnHandles.end(),
+        it != assignments.end(),
         "ColumnHandle is missing for output column: {}",
         outputName);
 
@@ -116,11 +155,9 @@ HiveDataSource::HiveDataSource(
           "Required subfield does not match column name");
       subfields_[handle->name()].push_back(&subfield);
     }
+    columnPostProcessors_.push_back(handle->postProcessor());
   }
 
-  hiveTableHandle_ = std::dynamic_pointer_cast<HiveTableHandle>(tableHandle);
-  VELOX_CHECK_NOT_NULL(
-      hiveTableHandle_, "TableHandle must be an instance of HiveTableHandle");
   if (hiveConfig_->isFileColumnNamesReadAsLowerCase(
           connectorQueryCtx->sessionProperties())) {
     checkColumnNameLowerCase(outputType_);
@@ -129,13 +166,12 @@ HiveDataSource::HiveDataSource(
   }
 
   for (const auto& [k, v] : hiveTableHandle_->subfieldFilters()) {
-    filters_.emplace(k.clone(), v->clone());
+    filters_.emplace(k.clone(), v);
   }
-  double sampleRate = 1;
+  double sampleRate = hiveTableHandle_->sampleRate();
   auto remainingFilter = extractFiltersFromRemainingFilter(
       hiveTableHandle_->remainingFilter(),
       expressionEvaluator_,
-      false,
       filters_,
       sampleRate);
   if (sampleRate != 1) {
@@ -217,7 +253,7 @@ std::unique_ptr<SplitReader> HiveDataSource::createSplitReader() {
       ioStats_,
       fsStats_,
       fileHandleFactory_,
-      executor_,
+      ioExecutor_,
       scanSpec_);
 }
 
@@ -403,8 +439,11 @@ std::optional<RowVectorPtr> HiveDataSource::next(
       // don't need to reallocate the result for every batch.
       child->disableMemo();
     }
-    outputColumns.emplace_back(
-        exec::wrapChild(rowsRemaining, remainingIndices, child));
+    auto column = exec::wrapChild(rowsRemaining, remainingIndices, child);
+    if (columnPostProcessors_[i]) {
+      columnPostProcessors_[i](column);
+    }
+    outputColumns.push_back(std::move(column));
   }
 
   return std::make_shared<RowVector>(
@@ -415,67 +454,80 @@ void HiveDataSource::addDynamicFilter(
     column_index_t outputChannel,
     const std::shared_ptr<common::Filter>& filter) {
   auto& fieldSpec = scanSpec_->getChildByChannel(outputChannel);
-  fieldSpec.addFilter(*filter);
+  fieldSpec.setFilter(filter);
   scanSpec_->resetCachedValues(true);
   if (splitReader_) {
     splitReader_->resetFilterCaches();
   }
 }
 
-std::unordered_map<std::string, RuntimeCounter> HiveDataSource::runtimeStats() {
-  auto res = runtimeStats_.toMap();
+std::unordered_map<std::string, RuntimeMetric>
+HiveDataSource::getRuntimeStats() {
+  auto res = runtimeStats_.toRuntimeMetricMap();
   res.insert(
-      {{"numPrefetch", RuntimeCounter(ioStats_->prefetch().count())},
+      {{"numPrefetch", RuntimeMetric(ioStats_->prefetch().count())},
        {"prefetchBytes",
-        RuntimeCounter(
-            ioStats_->prefetch().sum(), RuntimeCounter::Unit::kBytes)},
+        RuntimeMetric(
+            ioStats_->prefetch().sum(),
+            ioStats_->prefetch().count(),
+            ioStats_->prefetch().min(),
+            ioStats_->prefetch().max(),
+            RuntimeCounter::Unit::kBytes)},
        {"totalScanTime",
-        RuntimeCounter(
-            ioStats_->totalScanTime(), RuntimeCounter::Unit::kNanos)},
-       {"totalRemainingFilterTime",
-        RuntimeCounter(
+        RuntimeMetric(ioStats_->totalScanTime(), RuntimeCounter::Unit::kNanos)},
+       {Connector::kTotalRemainingFilterTime,
+        RuntimeMetric(
             totalRemainingFilterTime_.load(std::memory_order_relaxed),
             RuntimeCounter::Unit::kNanos)},
        {"ioWaitWallNanos",
-        RuntimeCounter(
+        RuntimeMetric(
             ioStats_->queryThreadIoLatency().sum() * 1000,
-            RuntimeCounter::Unit::kNanos)},
-       {"maxSingleIoWaitWallNanos",
-        RuntimeCounter(
+            ioStats_->queryThreadIoLatency().count(),
+            ioStats_->queryThreadIoLatency().min() * 1000,
             ioStats_->queryThreadIoLatency().max() * 1000,
             RuntimeCounter::Unit::kNanos)},
        {"overreadBytes",
-        RuntimeCounter(
+        RuntimeMetric(
             ioStats_->rawOverreadBytes(), RuntimeCounter::Unit::kBytes)}});
   if (ioStats_->read().count() > 0) {
-    res.insert({"numStorageRead", RuntimeCounter(ioStats_->read().count())});
     res.insert(
         {"storageReadBytes",
-         RuntimeCounter(ioStats_->read().sum(), RuntimeCounter::Unit::kBytes)});
+         RuntimeMetric(
+             ioStats_->read().sum(),
+             ioStats_->read().count(),
+             ioStats_->read().min(),
+             ioStats_->read().max(),
+             RuntimeCounter::Unit::kBytes)});
   }
   if (ioStats_->ssdRead().count() > 0) {
-    res.insert({"numLocalRead", RuntimeCounter(ioStats_->ssdRead().count())});
+    res.insert({"numLocalRead", RuntimeMetric(ioStats_->ssdRead().count())});
     res.insert(
         {"localReadBytes",
-         RuntimeCounter(
-             ioStats_->ssdRead().sum(), RuntimeCounter::Unit::kBytes)});
+         RuntimeMetric(
+             ioStats_->ssdRead().sum(),
+             ioStats_->ssdRead().count(),
+             ioStats_->ssdRead().min(),
+             ioStats_->ssdRead().max(),
+             RuntimeCounter::Unit::kBytes)});
   }
   if (ioStats_->ramHit().count() > 0) {
-    res.insert({"numRamRead", RuntimeCounter(ioStats_->ramHit().count())});
+    res.insert({"numRamRead", RuntimeMetric(ioStats_->ramHit().count())});
     res.insert(
         {"ramReadBytes",
-         RuntimeCounter(
-             ioStats_->ramHit().sum(), RuntimeCounter::Unit::kBytes)});
+         RuntimeMetric(
+             ioStats_->ramHit().sum(),
+             ioStats_->ramHit().count(),
+             ioStats_->ramHit().min(),
+             ioStats_->ramHit().max(),
+             RuntimeCounter::Unit::kBytes)});
   }
   if (numBucketConversion_ > 0) {
-    res.insert({"numBucketConversion", RuntimeCounter(numBucketConversion_)});
+    res.insert({"numBucketConversion", RuntimeMetric(numBucketConversion_)});
   }
 
   const auto fsStats = fsStats_->stats();
   for (const auto& storageStats : fsStats) {
-    res.emplace(
-        storageStats.first,
-        RuntimeCounter(storageStats.second.sum, storageStats.second.unit));
+    res.emplace(storageStats.first, storageStats.second);
   }
   return res;
 }
@@ -492,6 +544,7 @@ void HiveDataSource::setFromDataSource(
   readerOutputType_ = std::move(source->readerOutputType_);
   source->scanSpec_->moveAdaptationFrom(*scanSpec_);
   scanSpec_ = std::move(source->scanSpec_);
+  metadataFilter_ = std::move(source->metadataFilter_);
   splitReader_ = std::move(source->splitReader_);
   splitReader_->setConnectorQueryCtx(connectorQueryCtx_);
   // New io will be accounted on the stats of 'source'. Add the existing
@@ -550,7 +603,7 @@ std::shared_ptr<wave::WaveDataSource> HiveDataSource::toWaveDataSource() {
         readerOutputType_,
         &partitionKeys_,
         fileHandleFactory_,
-        executor_,
+        ioExecutor_,
         connectorQueryCtx_,
         hiveConfig_,
         ioStats_,
diff --git a/velox/connectors/hive/HiveDataSource.h b/velox/connectors/hive/HiveDataSource.h
index 29b31dcee1e6..b019421eccf7 100644
--- a/velox/connectors/hive/HiveDataSource.h
+++ b/velox/connectors/hive/HiveDataSource.h
@@ -36,12 +36,10 @@ class HiveDataSource : public DataSource {
  public:
   HiveDataSource(
       const RowTypePtr& outputType,
-      const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+      const connector::ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& assignments,
       FileHandleFactory* fileHandleFactory,
-      folly::Executor* executor,
+      folly::Executor* ioExecutor,
       const ConnectorQueryCtx* connectorQueryCtx,
       const std::shared_ptr<HiveConfig>& hiveConfig);
 
@@ -62,7 +60,7 @@ class HiveDataSource : public DataSource {
     return completedRows_;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override;
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override;
 
   bool allPrefetchIssued() const override {
     return splitReader_ && splitReader_->allPrefetchIssued();
@@ -72,15 +70,18 @@ class HiveDataSource : public DataSource {
 
   int64_t estimatedRowSize() override;
 
+  const common::SubfieldFilters* getFilters() const override {
+    return &filters_;
+  }
+
   std::shared_ptr<wave::WaveDataSource> toWaveDataSource() override;
 
   using WaveDelegateHookFunction =
       std::function<std::shared_ptr<wave::WaveDataSource>(
-          const std::shared_ptr<HiveTableHandle>& hiveTableHandle,
+          const HiveTableHandlePtr& hiveTableHandle,
           const std::shared_ptr<common::ScanSpec>& scanSpec,
           const RowTypePtr& readerOutputType,
-          std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
-              partitionKeys,
+          std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
           FileHandleFactory* fileHandleFactory,
           folly::Executor* executor,
           const ConnectorQueryCtx* connectorQueryCtx,
@@ -101,13 +102,13 @@ class HiveDataSource : public DataSource {
   virtual std::unique_ptr<SplitReader> createSplitReader();
 
   FileHandleFactory* const fileHandleFactory_;
-  folly::Executor* const executor_;
+  folly::Executor* const ioExecutor_;
   const ConnectorQueryCtx* const connectorQueryCtx_;
   const std::shared_ptr<HiveConfig> hiveConfig_;
   memory::MemoryPool* const pool_;
 
   std::shared_ptr<HiveConnectorSplit> split_;
-  std::shared_ptr<HiveTableHandle> hiveTableHandle_;
+  HiveTableHandlePtr hiveTableHandle_;
   std::shared_ptr<common::ScanSpec> scanSpec_;
   VectorPtr output_;
   std::unique_ptr<SplitReader> splitReader_;
@@ -119,8 +120,7 @@ class HiveDataSource : public DataSource {
 
   // Column handles for the partition key columns keyed on partition key column
   // name.
-  std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>
-      partitionKeys_;
+  std::unordered_map<std::string, HiveColumnHandlePtr> partitionKeys_;
 
   std::shared_ptr<io::IoStatistics> ioStats_;
   std::shared_ptr<filesystems::File::IoStats> fsStats_;
@@ -147,17 +147,21 @@ class HiveDataSource : public DataSource {
     return emptyOutput_;
   }
 
+  // Add the information from column handle to the corresponding fields in this
+  // object.
+  void processColumnHandle(const HiveColumnHandlePtr& handle);
+
   // The row type for the data source output, not including filter-only columns
   const RowTypePtr outputType_;
   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_;
+  std::unordered_map<std::string, HiveColumnHandlePtr> infoColumns_;
   SpecialColumnNames specialColumns_{};
   std::vector<common::Subfield> remainingFilterSubfields_;
   folly::F14FastMap<std::string, std::vector<const common::Subfield*>>
       subfields_;
+  std::vector<std::function<void(VectorPtr&)>> columnPostProcessors_;
   common::SubfieldFilters filters_;
   std::shared_ptr<common::MetadataFilter> metadataFilter_;
   std::unique_ptr<exec::ExprSet> remainingFilterExprSet_;
diff --git a/velox/connectors/hive/HivePartitionFunction.cpp b/velox/connectors/hive/HivePartitionFunction.cpp
index d273cc8163e3..548aff99e15d 100644
--- a/velox/connectors/hive/HivePartitionFunction.cpp
+++ b/velox/connectors/hive/HivePartitionFunction.cpp
@@ -15,6 +15,8 @@
  */
 #include "velox/connectors/hive/HivePartitionFunction.h"
 
+#include <utility>
+
 namespace facebook::velox::connector::hive {
 
 namespace {
@@ -31,8 +33,7 @@ int32_t hashInt64(int64_t value) {
 __attribute__((no_sanitize("integer")))
 #endif
 #endif
-uint32_t
-hashBytes(StringView bytes, int32_t initialValue) {
+uint32_t hashBytes(StringView bytes, int32_t initialValue) {
   uint32_t hash = initialValue;
   auto* data = bytes.data();
   for (auto i = 0; i < bytes.size(); ++i) {
@@ -461,7 +462,7 @@ HivePartitionFunction::HivePartitionFunction(
     std::vector<column_index_t> keyChannels,
     const std::vector<VectorPtr>& constValues)
     : numBuckets_{numBuckets},
-      bucketToPartition_{bucketToPartition},
+      bucketToPartition_{std::move(bucketToPartition)},
       keyChannels_{std::move(keyChannels)} {
   precomputedHashes_.resize(keyChannels_.size());
   size_t constChannel{0};
@@ -495,7 +496,7 @@ std::optional<uint32_t> HivePartitionFunction::partition(
     }
   }
 
-  static const int32_t kInt32Max = std::numeric_limits<int32_t>::max();
+  static constexpr int32_t kInt32Max = std::numeric_limits<int32_t>::max();
 
   if (bucketToPartition_.empty()) {
     // NOTE: if bucket to partition mapping is empty, then we do
diff --git a/velox/connectors/hive/HivePartitionName.cpp b/velox/connectors/hive/HivePartitionName.cpp
new file mode 100644
index 000000000000..2d7e7b9b665b
--- /dev/null
+++ b/velox/connectors/hive/HivePartitionName.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/connectors/hive/HivePartitionName.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/dwio/catalog/fbhive/FileUtils.h"
+#include "velox/type/DecimalUtil.h"
+
+namespace facebook::velox::connector::hive {
+
+using namespace facebook::velox::dwio::catalog::fbhive;
+
+namespace {
+
+template <typename T>
+std::string formatDecimal(T value, const TypePtr& type) {
+  const auto& [p, s] = getDecimalPrecisionScale(*type);
+  const auto& maxSize = DecimalUtil::maxStringViewSize(p, s);
+  std::string buffer(maxSize, '\0');
+  const auto& actualSize =
+      DecimalUtil::castToString(value, s, maxSize, buffer.data());
+  buffer.resize(actualSize);
+  return buffer;
+}
+
+} // namespace
+
+std::string HivePartitionName::toName(int32_t value, const TypePtr& type) {
+  if (type->isDate()) {
+    return DateType::toIso8601(value);
+  }
+  return fmt::to_string(value);
+}
+
+std::string HivePartitionName::toName(int64_t value, const TypePtr& type) {
+  if (type->isShortDecimal()) {
+    return formatDecimal(value, type);
+  }
+  return fmt::to_string(value);
+}
+
+std::string HivePartitionName::toName(int128_t value, const TypePtr& type) {
+  if (type->isLongDecimal()) {
+    return formatDecimal(value, type);
+  }
+  return fmt::to_string(value);
+}
+
+std::string HivePartitionName::toName(Timestamp value, const TypePtr& type) {
+  value.toTimezone(Timestamp::defaultTimezone());
+  TimestampToStringOptions options;
+  options.dateTimeSeparator = ' ';
+  // Set the precision to milliseconds, and enable the skipTrailingZeros match
+  // the timestamp precision and truncation behavior of Presto.
+  options.precision = TimestampPrecision::kMilliseconds;
+  options.skipTrailingZeros = true;
+
+  auto result = value.toString(options);
+
+  // Presto's java.sql.Timestamp.toString() always keeps at least one decimal
+  // place even when all fractional seconds are zero.
+  // If skipTrailingZeros removed all fractional digits, add back ".0" to match
+  // Presto's behavior.
+  if (auto dotPos = result.find_last_of('.'); dotPos == std::string::npos) {
+    // No decimal point found, add ".0"
+    result += ".0";
+  }
+
+  return result;
+}
+
+std::string HivePartitionName::partitionName(
+    uint32_t partitionId,
+    const RowVectorPtr& partitionValues,
+    bool partitionKeyAsLowerCase) {
+  auto toPartitionName =
+      [](auto value, const TypePtr& type, int /*columnIndex*/) {
+        return HivePartitionName::toName(value, type);
+      };
+  return FileUtils::makePartName(
+      partitionKeyValues(
+          partitionId,
+          partitionValues,
+          /*nullValueString=*/"",
+          toPartitionName),
+      partitionKeyAsLowerCase);
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HivePartitionName.h b/velox/connectors/hive/HivePartitionName.h
new file mode 100644
index 000000000000..3e519528866c
--- /dev/null
+++ b/velox/connectors/hive/HivePartitionName.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 <memory>
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/SimpleVector.h"
+
+namespace facebook::velox::connector::hive {
+
+/// Converting partition values to their string representations.
+/// Provides template methods for formatting different data types according to
+/// Hive partitioning conventions.
+class HivePartitionName {
+ public:
+  /// Generic template for formatting partition values to strings using
+  /// fmt::to_string. Specialized for types that need special handling
+  /// (int32_t, int64_t, int128_t, Timestamp).
+  template <typename T>
+  FOLLY_ALWAYS_INLINE static std::string toName(T value, const TypePtr& type) {
+    return fmt::to_string(value);
+  }
+
+  /// Format int32_t partition values. Specialized to handle DATE type which
+  /// requires ISO-8601 formatting (YYYY-MM-DD) instead of raw integer value.
+  static std::string toName(int32_t value, const TypePtr& type);
+
+  /// Format int64_t partition values. Specialized to handle short DECIMAL type
+  /// which requires decimal string formatting with proper precision and scale
+  /// instead of raw integer value.
+  static std::string toName(int64_t value, const TypePtr& type);
+
+  /// Format int128_t partition values. Specialized to handle long DECIMAL type
+  /// which requires decimal string formatting with proper precision and scale
+  /// instead of raw integer value.
+  static std::string toName(int128_t value, const TypePtr& type);
+
+  /// Format Timestamp partition values. Specialized to:
+  /// 1. Convert to default timezone
+  /// 2. Use space as date-time separator (not 'T')
+  /// 3. Use millisecond precision with trailing zeros skipped
+  /// 4. Always keep at least ".0" for fractional seconds (Presto compatibility)
+  static std::string toName(Timestamp value, const TypePtr& type);
+
+  /// Build partition key-value pairs from partition values.
+  /// Returns a vector of (key, value) pairs for all partition columns.
+  /// @tparam F A callable that converts a value to a partition string.
+  ///         Takes (value, type, columnIndex) and returns string.
+  /// @param partitionId The partition ID (row index) to extract values from.
+  /// @param partitionValues RowVector containing partition values.
+  /// @param nullValueString The string to use for null values.
+  /// @param toPartitionName Callable to convert a value to a string.
+  template <typename F>
+  static std::vector<std::pair<std::string, std::string>> partitionKeyValues(
+      uint32_t partitionId,
+      const RowVectorPtr& partitionValues,
+      const std::string& nullValueString,
+      const F& toPartitionName);
+
+  /// Generate a Hive partition directory name from partition values for
+  /// partitionId.
+  ///
+  /// @param partitionId The row index in partitionValues to extract values
+  ///        from.
+  /// @param partitionValues RowVector containing partition values. Each
+  ///        child vector represents a partition column, and the row at
+  ///        partitionId contains the values for this partition.
+  /// @param partitionKeyAsLowerCase Controls whether partition column names
+  ///        should be converted to lowercase in the output. When true, column
+  ///        names are lowercased (e.g., "year=2025"); when false, original
+  ///        casing is preserved (e.g., "Year=2025").
+  /// @return A formatted partition directory name string. Null values are
+  /// represented as __HIVE_DEFAULT_PARTITION__.
+  static std::string partitionName(
+      uint32_t partitionId,
+      const RowVectorPtr& partitionValues,
+      bool partitionKeyAsLowerCase);
+};
+
+namespace detail {
+
+// Unified template function to extract partition key-value string from a
+// vector. Used by both Hive and Iceberg partition name generators.
+//
+// @tparam Kind The TypeKind of the partition column.
+// @tparam F A callable that converts a value to a partition string.
+// @param partitionVector The vector containing partition values.
+// @param row The row index to extract the value from.
+// @param type The type of the partition column.
+// @param columnIndex The column index in the partition values.
+// @param toPartitionName Callable to convert a value to a partition string.
+// @return A pair of (column_name, formatted_value).
+template <TypeKind Kind, typename F>
+std::string makePartitionKeyValueString(
+    const BaseVector& partitionVector,
+    vector_size_t row,
+    const TypePtr& type,
+    int columnIndex,
+    const F& toPartitionName) {
+  using T = typename TypeTraits<Kind>::NativeType;
+
+  return toPartitionName(
+      partitionVector.as<SimpleVector<T>>()->valueAt(row), type, columnIndex);
+}
+
+#define PARTITION_TYPE_DISPATCH(TEMPLATE_FUNC, typeKind, ...)                  \
+  [&]() {                                                                      \
+    switch (typeKind) {                                                        \
+      case TypeKind::BOOLEAN:                                                  \
+      case TypeKind::TINYINT:                                                  \
+      case TypeKind::SMALLINT:                                                 \
+      case TypeKind::INTEGER:                                                  \
+      case TypeKind::BIGINT:                                                   \
+      case TypeKind::VARCHAR:                                                  \
+      case TypeKind::VARBINARY:                                                \
+      case TypeKind::TIMESTAMP:                                                \
+        return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(                             \
+            TEMPLATE_FUNC, typeKind, __VA_ARGS__);                             \
+      default:                                                                 \
+        VELOX_UNSUPPORTED(                                                     \
+            "Unsupported partition type: {}", TypeKindName::toName(typeKind)); \
+    }                                                                          \
+  }()
+
+} // namespace detail
+
+template <typename F>
+std::vector<std::pair<std::string, std::string>>
+HivePartitionName::partitionKeyValues(
+    uint32_t partitionId,
+    const RowVectorPtr& partitionValues,
+    const std::string& nullValueString,
+    const F& toPartitionName) {
+  std::vector<std::pair<std::string, std::string>> partitionKeyValuePairs;
+  for (auto i = 0; i < partitionValues->childrenSize(); i++) {
+    const auto& child = partitionValues->childAt(i);
+    const auto& name = partitionValues->rowType()->nameOf(i);
+    if (child->isNullAt(partitionId)) {
+      partitionKeyValuePairs.emplace_back(
+          std::make_pair(name, nullValueString));
+      continue;
+    }
+
+    partitionKeyValuePairs.emplace_back(
+        std::make_pair(
+            name,
+            PARTITION_TYPE_DISPATCH(
+                detail::makePartitionKeyValueString,
+                child->typeKind(),
+                *child->loadedVector(),
+                partitionId,
+                child->type(),
+                i,
+                toPartitionName)));
+  }
+  return partitionKeyValuePairs;
+}
+
+} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/HivePartitionUtil.cpp b/velox/connectors/hive/HivePartitionUtil.cpp
deleted file mode 100644
index cbc53c79b5ea..000000000000
--- a/velox/connectors/hive/HivePartitionUtil.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 "velox/connectors/hive/HivePartitionUtil.h"
-
-namespace facebook::velox::connector::hive {
-
-#define PARTITION_TYPE_DISPATCH(TEMPLATE_FUNC, typeKind, ...)               \
-  [&]() {                                                                   \
-    switch (typeKind) {                                                     \
-      case TypeKind::BOOLEAN:                                               \
-      case TypeKind::TINYINT:                                               \
-      case TypeKind::SMALLINT:                                              \
-      case TypeKind::INTEGER:                                               \
-      case TypeKind::BIGINT:                                                \
-      case TypeKind::VARCHAR:                                               \
-      case TypeKind::VARBINARY:                                             \
-        return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(                          \
-            TEMPLATE_FUNC, typeKind, __VA_ARGS__);                          \
-      default:                                                              \
-        VELOX_UNSUPPORTED(                                                  \
-            "Unsupported partition type: {}", mapTypeKindToName(typeKind)); \
-    }                                                                       \
-  }()
-
-namespace {
-template <typename T>
-inline std::string makePartitionValueString(T value) {
-  return folly::to<std::string>(value);
-}
-
-template <>
-inline std::string makePartitionValueString(bool value) {
-  return value ? "true" : "false";
-}
-
-template <TypeKind Kind>
-std::pair<std::string, std::string> makePartitionKeyValueString(
-    const BaseVector* partitionVector,
-    vector_size_t row,
-    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
-
-std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
-    const RowVectorPtr& partitionsVector,
-    vector_size_t row) {
-  std::vector<std::pair<std::string, std::string>> partitionKeyValues;
-  for (auto i = 0; i < partitionsVector->childrenSize(); 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;
-}
-
-} // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/PartitionIdGenerator.cpp b/velox/connectors/hive/PartitionIdGenerator.cpp
index deec8dc5b005..a4773da58a10 100644
--- a/velox/connectors/hive/PartitionIdGenerator.cpp
+++ b/velox/connectors/hive/PartitionIdGenerator.cpp
@@ -16,37 +16,30 @@
 
 #include "velox/connectors/hive/PartitionIdGenerator.h"
 
-#include "velox/connectors/hive/HivePartitionUtil.h"
-#include "velox/dwio/catalog/fbhive/FileUtils.h"
-
-using namespace facebook::velox::dwio::catalog::fbhive;
-
 namespace facebook::velox::connector::hive {
 
 PartitionIdGenerator::PartitionIdGenerator(
     const RowTypePtr& inputType,
     std::vector<column_index_t> partitionChannels,
     uint32_t maxPartitions,
-    memory::MemoryPool* pool,
-    bool partitionPathAsLowerCase)
-    : partitionChannels_(std::move(partitionChannels)),
-      maxPartitions_(maxPartitions),
-      partitionPathAsLowerCase_(partitionPathAsLowerCase) {
+    memory::MemoryPool* pool)
+    : pool_(pool),
+      partitionChannels_(std::move(partitionChannels)),
+      maxPartitions_(maxPartitions) {
   VELOX_USER_CHECK(
       !partitionChannels_.empty(), "There must be at least one partition key.");
   for (auto channel : partitionChannels_) {
     hashers_.emplace_back(
         exec::VectorHasher::create(inputType->childAt(channel), channel));
+    VELOX_USER_CHECK(
+        hashers_.back()->typeSupportsValueIds(),
+        "Unsupported partition type: {}.",
+        inputType->childAt(channel)->toString());
   }
 
   std::vector<TypePtr> partitionKeyTypes;
   std::vector<std::string> partitionKeyNames;
   for (auto channel : partitionChannels_) {
-    VELOX_USER_CHECK(
-        exec::VectorHasher::typeKindSupportsValueIds(
-            inputType->childAt(channel)->kind()),
-        "Unsupported partition type: {}.",
-        inputType->childAt(channel)->toString());
     partitionKeyTypes.push_back(inputType->childAt(channel));
     partitionKeyNames.push_back(inputType->nameOf(channel));
   }
@@ -96,12 +89,6 @@ void PartitionIdGenerator::run(
   }
 }
 
-std::string PartitionIdGenerator::partitionName(uint64_t partitionId) const {
-  return FileUtils::makePartName(
-      extractPartitionKeyValues(partitionValues_, partitionId),
-      partitionPathAsLowerCase_);
-}
-
 void PartitionIdGenerator::computeValueIds(
     const RowVectorPtr& input,
     raw_vector<uint64_t>& valueIds) {
@@ -154,7 +141,7 @@ void PartitionIdGenerator::updateValueToPartitionIdMapping() {
 
   partitionIds_.clear();
 
-  raw_vector<uint64_t> newValueIds(numPartitions);
+  raw_vector<uint64_t> newValueIds(numPartitions, pool_);
   SelectivityVector rows(numPartitions);
   for (auto i = 0; i < hashers_.size(); ++i) {
     auto& hasher = hashers_[i];
diff --git a/velox/connectors/hive/PartitionIdGenerator.h b/velox/connectors/hive/PartitionIdGenerator.h
index 01b638c0f3ad..0a53252829c8 100644
--- a/velox/connectors/hive/PartitionIdGenerator.h
+++ b/velox/connectors/hive/PartitionIdGenerator.h
@@ -29,14 +29,11 @@ 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,
-      bool partitionPathAsLowerCase);
+      memory::MemoryPool* pool);
 
   /// Generate sequential partition IDs for input vector.
   /// @param input Input RowVector.
@@ -48,11 +45,16 @@ class PartitionIdGenerator {
     return partitionIds_.size();
   }
 
-  /// Return partition name for the given partition id in the typical Hive
-  /// style. It is derived from the partitionValues_ at index partitionId.
-  /// Partition keys appear in the order of partition columns in the table
-  /// schema.
-  std::string partitionName(uint64_t partitionId) const;
+  /// Returns the RowVector containing transformed partition keys.
+  /// Each row in this vector corresponds to a partition ID (row index =
+  /// partition ID).
+  /// Should be called after calling run() method.
+  ///
+  /// @return RowVector with one column per partition column, columns in same
+  /// order as partitionChannels_.
+  const RowVectorPtr& partitionValues() const {
+    return partitionValues_;
+  }
 
  private:
   static constexpr const int32_t kHasherReservePct = 20;
@@ -75,12 +77,12 @@ class PartitionIdGenerator {
       const RowVectorPtr& input,
       vector_size_t row);
 
+  memory::MemoryPool* const pool_;
+
   const std::vector<column_index_t> partitionChannels_;
 
   const uint32_t maxPartitions_;
 
-  const bool partitionPathAsLowerCase_;
-
   std::vector<std::unique_ptr<exec::VectorHasher>> hashers_;
   bool hasMultiplierSet_ = false;
 
diff --git a/velox/connectors/hive/SplitReader.cpp b/velox/connectors/hive/SplitReader.cpp
index 0bd741efda8c..8913044903c8 100644
--- a/velox/connectors/hive/SplitReader.cpp
+++ b/velox/connectors/hive/SplitReader.cpp
@@ -17,76 +17,88 @@
 #include "velox/connectors/hive/SplitReader.h"
 
 #include "velox/common/caching/CacheTTLController.h"
+#include "velox/connectors/hive/BufferedInputBuilder.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 {
 
 template <TypeKind kind>
-VectorPtr newConstantFromString(
+VectorPtr newConstantFromStringImpl(
     const TypePtr& type,
     const std::optional<std::string>& value,
-    vector_size_t size,
     velox::memory::MemoryPool* pool,
-    const std::string& sessionTimezone,
-    bool asLocalTime,
-    bool isPartitionDateDaysSinceEpoch = false) {
+    bool isLocalTimestamp,
+    bool isDaysSinceEpoch) {
   using T = typename TypeTraits<kind>::NativeType;
   if (!value.has_value()) {
-    return std::make_shared<ConstantVector<T>>(pool, size, true, type, T());
+    return std::make_shared<ConstantVector<T>>(pool, 1, true, type, T());
   }
 
   if (type->isDate()) {
     int32_t days = 0;
     // For Iceberg, the date partition values are already in daysSinceEpoch
     // form.
-    if (isPartitionDateDaysSinceEpoch) {
+    if (isDaysSinceEpoch) {
       days = folly::to<int32_t>(value.value());
     } else {
-      days = DATE()->toDays(static_cast<folly::StringPiece>(value.value()));
+      days = DATE()->toDays(value.value());
     }
     return std::make_shared<ConstantVector<int32_t>>(
-        pool, size, false, type, std::move(days));
+        pool, 1, false, type, std::move(days));
   }
 
   if constexpr (std::is_same_v<T, StringView>) {
     return std::make_shared<ConstantVector<StringView>>(
-        pool, size, false, type, StringView(value.value()));
+        pool, 1, 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) {
-      if (asLocalTime) {
+      if (isLocalTimestamp) {
         copy.toGMT(Timestamp::defaultTimezone());
       }
     }
     return std::make_shared<ConstantVector<T>>(
-        pool, size, false, type, std::move(copy));
+        pool, 1, false, type, std::move(copy));
   }
 }
 } // namespace
 
+VectorPtr newConstantFromString(
+    const TypePtr& type,
+    const std::optional<std::string>& value,
+    velox::memory::MemoryPool* pool,
+    bool isLocalTimestamp,
+    bool isDaysSinceEpoch) {
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+      newConstantFromStringImpl,
+      type->kind(),
+      type,
+      value,
+      pool,
+      isLocalTimestamp,
+      isDaysSinceEpoch);
+}
+
 std::unique_ptr<SplitReader> SplitReader::create(
     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,
+    const HiveTableHandlePtr& hiveTableHandle,
+    const std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
     const ConnectorQueryCtx* connectorQueryCtx,
     const std::shared_ptr<const HiveConfig>& hiveConfig,
     const RowTypePtr& readerOutputType,
     const std::shared_ptr<io::IoStatistics>& ioStats,
     const std::shared_ptr<filesystems::File::IoStats>& fsStats,
     FileHandleFactory* fileHandleFactory,
-    folly::Executor* executor,
+    folly::Executor* ioExecutor,
     const std::shared_ptr<common::ScanSpec>& scanSpec) {
   //  Create the SplitReader based on hiveSplit->customSplitInfo["table_format"]
   if (hiveSplit->customSplitInfo.count("table_format") > 0 &&
@@ -101,7 +113,7 @@ std::unique_ptr<SplitReader> SplitReader::create(
         ioStats,
         fsStats,
         fileHandleFactory,
-        executor,
+        ioExecutor,
         scanSpec);
   } else {
     return std::unique_ptr<SplitReader>(new SplitReader(
@@ -114,23 +126,22 @@ std::unique_ptr<SplitReader> SplitReader::create(
         ioStats,
         fsStats,
         fileHandleFactory,
-        executor,
+        ioExecutor,
         scanSpec));
   }
 }
 
 SplitReader::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 HiveTableHandlePtr& hiveTableHandle,
+    const std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
     const ConnectorQueryCtx* connectorQueryCtx,
     const std::shared_ptr<const HiveConfig>& hiveConfig,
     const RowTypePtr& readerOutputType,
     const std::shared_ptr<io::IoStatistics>& ioStats,
     const std::shared_ptr<filesystems::File::IoStats>& fsStats,
     FileHandleFactory* fileHandleFactory,
-    folly::Executor* executor,
+    folly::Executor* ioExecutor,
     const std::shared_ptr<common::ScanSpec>& scanSpec)
     : hiveSplit_(hiveSplit),
       hiveTableHandle_(hiveTableHandle),
@@ -141,7 +152,7 @@ SplitReader::SplitReader(
       ioStats_(ioStats),
       fsStats_(fsStats),
       fileHandleFactory_(fileHandleFactory),
-      executor_(executor),
+      ioExecutor_(ioExecutor),
       pool_(connectorQueryCtx->memoryPool()),
       scanSpec_(scanSpec),
       baseReaderOpts_(connectorQueryCtx->memoryPool()),
@@ -162,8 +173,9 @@ void SplitReader::configureReaderOptions(
 
 void SplitReader::prepareSplit(
     std::shared_ptr<common::MetadataFilter> metadataFilter,
-    dwio::common::RuntimeStatistics& runtimeStats) {
-  createReader();
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
+  createReader(fileReadOps);
   if (emptySplit_) {
     return;
   }
@@ -174,7 +186,7 @@ void SplitReader::prepareSplit(
     return;
   }
 
-  createRowReader(std::move(metadataFilter), std::move(rowType));
+  createRowReader(std::move(metadataFilter), std::move(rowType), std::nullopt);
 }
 
 void SplitReader::setBucketConversion(
@@ -223,7 +235,7 @@ uint64_t SplitReader::next(uint64_t size, VectorPtr& output) {
     mutation.randomSkip = baseReaderOpts_.randomSkip().get();
     numScanned = baseRowReader_->next(size, output, &mutation);
   }
-  if (partitionFunction_) {
+  if (numScanned > 0 && output->size() > 0 && partitionFunction_) {
     applyBucketConversion(
         output, bucketConversionRows(*output->asChecked<RowVector>()));
   }
@@ -285,16 +297,22 @@ std::string SplitReader::toString() const {
       static_cast<const void*>(baseRowReader_.get()));
 }
 
-void SplitReader::createReader() {
+void SplitReader::createReader(
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
   VELOX_CHECK_NE(
       baseReaderOpts_.fileFormat(), dwio::common::FileFormat::UNKNOWN);
 
   FileHandleCachedPtr fileHandleCachePtr;
+  FileHandleKey fileHandleKey{
+      .filename = hiveSplit_->filePath,
+      .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
+
+  auto fileProperties = hiveSplit_->properties.value_or(FileProperties{});
+  fileProperties.fileReadOps = fileReadOps;
+
   try {
     fileHandleCachePtr = fileHandleFactory_->generate(
-        hiveSplit_->filePath,
-        hiveSplit_->properties.has_value() ? &*hiveSplit_->properties : nullptr,
-        fsStats_ ? fsStats_.get() : nullptr);
+        fileHandleKey, &fileProperties, fsStats_ ? fsStats_.get() : nullptr);
     VELOX_CHECK_NOT_NULL(fileHandleCachePtr.get());
   } catch (const VeloxRuntimeError& e) {
     if (e.errorCode() == error_code::kFileNotFound &&
@@ -313,13 +331,14 @@ void SplitReader::createReader() {
   if (auto* cacheTTLController = cache::CacheTTLController::getInstance()) {
     cacheTTLController->addOpenFileInfo(fileHandleCachePtr->uuid.id());
   }
-  auto baseFileInput = createBufferedInput(
+  auto baseFileInput = BufferedInputBuilder::getInstance()->create(
       *fileHandleCachePtr,
       baseReaderOpts_,
       connectorQueryCtx_,
       ioStats_,
       fsStats_,
-      executor_);
+      ioExecutor_,
+      fileReadOps);
 
   baseReader_ = dwio::common::getReaderFactory(baseReaderOpts_.fileFormat())
                     ->createReader(std::move(baseFileInput), baseReaderOpts_);
@@ -369,7 +388,8 @@ bool SplitReader::checkIfSplitIsEmpty(
 
 void SplitReader::createRowReader(
     std::shared_ptr<common::MetadataFilter> metadataFilter,
-    RowTypePtr rowType) {
+    RowTypePtr rowType,
+    std::optional<bool> rowSizeTrackingEnabled) {
   VELOX_CHECK_NULL(baseRowReader_);
   configureRowReaderOptions(
       hiveTableHandle_->tableParameters(),
@@ -379,7 +399,13 @@ void SplitReader::createRowReader(
       hiveSplit_,
       hiveConfig_,
       connectorQueryCtx_->sessionProperties(),
+      ioExecutor_,
       baseRowReaderOpts_);
+  baseRowReaderOpts_.setTrackRowSize(
+      rowSizeTrackingEnabled.has_value()
+          ? *rowSizeTrackingEnabled
+          : connectorQueryCtx_->rowSizeTrackingMode() !=
+              core::QueryConfig::RowSizeTrackingMode::DISABLED);
   baseRowReader_ = baseReader_->createRowReader(baseRowReaderOpts_);
 }
 
@@ -401,16 +427,13 @@ std::vector<TypePtr> SplitReader::adaptColumns(
                iter != hiveSplit_->infoColumns.end()) {
       auto infoColumnType =
           readerOutputType_->childAt(readerOutputType_->getChildIdx(fieldName));
-      auto constant = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-          newConstantFromString,
-          infoColumnType->kind(),
+      auto constant = newConstantFromString(
           infoColumnType,
           iter->second,
-          1,
           connectorQueryCtx_->memoryPool(),
-          connectorQueryCtx_->sessionTimezone(),
           hiveConfig_->readTimestampPartitionValueAsLocalTime(
-              connectorQueryCtx_->sessionProperties()));
+              connectorQueryCtx_->sessionProperties()),
+          false);
       childSpec->setConstantValue(constant);
     } else if (
         childSpec->columnType() == common::ScanSpec::ColumnType::kRegular) {
@@ -418,10 +441,11 @@ std::vector<TypePtr> SplitReader::adaptColumns(
       if (!fileTypeIdx.has_value()) {
         // Column is missing. Most likely due to schema evolution.
         VELOX_CHECK(tableSchema, "Unable to resolve column '{}'", fieldName);
-        childSpec->setConstantValue(BaseVector::createNullConstant(
-            tableSchema->findChild(fieldName),
-            1,
-            connectorQueryCtx_->memoryPool()));
+        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);
@@ -457,14 +481,10 @@ void SplitReader::setPartitionValue(
       "ColumnHandle is missing for partition key {}",
       partitionKey);
   auto type = it->second->dataType();
-  auto constant = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-      newConstantFromString,
-      type->kind(),
+  auto constant = newConstantFromString(
       type,
       value,
-      1,
       connectorQueryCtx_->memoryPool(),
-      connectorQueryCtx_->sessionTimezone(),
       hiveConfig_->readTimestampPartitionValueAsLocalTime(
           connectorQueryCtx_->sessionProperties()),
       it->second->isPartitionDateValueDaysSinceEpoch());
diff --git a/velox/connectors/hive/SplitReader.h b/velox/connectors/hive/SplitReader.h
index 21c77ea2014a..46ecccb4eca7 100644
--- a/velox/connectors/hive/SplitReader.h
+++ b/velox/connectors/hive/SplitReader.h
@@ -25,7 +25,6 @@
 
 namespace facebook::velox {
 class BaseVector;
-class variant;
 using VectorPtr = std::shared_ptr<BaseVector>;
 } // namespace facebook::velox
 
@@ -48,6 +47,36 @@ class MemoryPool;
 
 namespace facebook::velox::connector::hive {
 
+/// Creates a constant vector of size 1 from a string representation of a value.
+///
+/// Used to materialize partition column values and info columns (e.g., $path,
+/// $file_size) when reading Hive and Iceberg tables. Partition values are
+/// stored as strings in HiveConnectorSplit::partitionKeys and need to be
+/// converted to their appropriate types.
+///
+/// @param type The target Velox type for the constant vector. Supports all
+/// scalar types including primitives, dates, timestamps.
+/// @param value The string representation of the value to convert, formatted
+/// the same way as CAST(x as VARCHAR). Date values must be formatted using ISO
+/// 8601 as YYYY-MM-DD. If nullopt, creates a null constant vector.
+/// @param pool Memory pool for allocating the constant vector.
+/// @param isLocalTimestamp If true and type is TIMESTAMP, interprets the string
+/// value as local time and converts it to GMT. If false, treats the value
+/// as already in GMT.
+/// @param isDaysSinceEpoch If true and type is DATE, treats the string value as
+/// an integer representing days since epoch (used by Iceberg). If false, parses
+/// the string as a date string in ISO 8601 format (used by Hive).
+///
+/// @return A constant vector of size 1 containing the converted value, or a
+/// null constant if value is nullopt.
+/// @throws VeloxUserError if the string cannot be converted to the target type.
+VectorPtr newConstantFromString(
+    const TypePtr& type,
+    const std::optional<std::string>& value,
+    velox::memory::MemoryPool* pool,
+    bool isLocalTimestamp,
+    bool isDaysSinceEpoch);
+
 struct HiveConnectorSplit;
 class HiveTableHandle;
 class HiveColumnHandle;
@@ -58,15 +87,16 @@ class SplitReader {
   static std::unique_ptr<SplitReader> create(
       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,
+      const std::unordered_map<
+          std::string,
+          std::shared_ptr<const HiveColumnHandle>>* partitionKeys,
       const ConnectorQueryCtx* connectorQueryCtx,
       const std::shared_ptr<const HiveConfig>& hiveConfig,
       const RowTypePtr& readerOutputType,
       const std::shared_ptr<io::IoStatistics>& ioStats,
       const std::shared_ptr<filesystems::File::IoStats>& fsStats,
       FileHandleFactory* fileHandleFactory,
-      folly::Executor* executor,
+      folly::Executor* ioExecutor,
       const std::shared_ptr<common::ScanSpec>& scanSpec);
 
   virtual ~SplitReader() = default;
@@ -80,7 +110,8 @@ class SplitReader {
   /// would be called only once per incoming split
   virtual void prepareSplit(
       std::shared_ptr<common::MetadataFilter> metadataFilter,
-      dwio::common::RuntimeStatistics& runtimeStats);
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {});
 
   virtual uint64_t next(uint64_t size, VectorPtr& output);
 
@@ -110,8 +141,9 @@ class SplitReader {
   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 std::unordered_map<
+          std::string,
+          std::shared_ptr<const HiveColumnHandle>>* partitionKeys,
       const ConnectorQueryCtx* connectorQueryCtx,
       const std::shared_ptr<const HiveConfig>& hiveConfig,
       const RowTypePtr& readerOutputType,
@@ -123,7 +155,8 @@ class SplitReader {
 
   /// Create the dwio::common::Reader object baseReader_, which will be used to
   /// read the data file's metadata and schema
-  void createReader();
+  void createReader(
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {});
 
   // Adjust the scan spec according to the current split, then return the
   // adapted row type.
@@ -146,7 +179,8 @@ class SplitReader {
   /// ColumnReaders that will be used to read the data
   void createRowReader(
       std::shared_ptr<common::MetadataFilter> metadataFilter,
-      RowTypePtr rowType);
+      RowTypePtr rowType,
+      std::optional<bool> rowSizeTrackingEnabled);
 
   const folly::F14FastSet<column_index_t>& bucketChannels() const {
     return bucketChannels_;
@@ -159,24 +193,31 @@ class SplitReader {
       VectorPtr& output,
       const std::vector<BaseVector::CopyRange>& ranges);
 
- private:
-  /// Different table formats may have different meatadata columns.
-  /// This function will be used to update the scanSpec for these columns.
-  std::vector<TypePtr> adaptColumns(
-      const RowTypePtr& fileType,
-      const std::shared_ptr<const velox::RowType>& tableSchema) const;
-
+  /// Sets a constant partition value on the scanSpec for a partition column.
+  /// Converts the partition key string value to the appropriate type and sets
+  /// it as a constant value in the scanSpec, so the column will be filled
+  /// with this constant value.
+  ///
+  /// @param spec The scan spec to set the constant value on.
+  /// @param partitionKey The name of the partition column.
   void setPartitionValue(
       common::ScanSpec* spec,
       const std::string& partitionKey,
       const std::optional<std::string>& value) const;
 
+ private:
+  /// 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 RowTypePtr& tableSchema) const;
+
  protected:
   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_;
+      std::shared_ptr<const HiveColumnHandle>>* const partitionKeys_;
   const ConnectorQueryCtx* connectorQueryCtx_;
   const std::shared_ptr<const HiveConfig> hiveConfig_;
 
@@ -184,7 +225,7 @@ class SplitReader {
   const std::shared_ptr<io::IoStatistics> ioStats_;
   const std::shared_ptr<filesystems::File::IoStats> fsStats_;
   FileHandleFactory* const fileHandleFactory_;
-  folly::Executor* const executor_;
+  folly::Executor* const ioExecutor_;
   memory::MemoryPool* const pool_;
 
   std::shared_ptr<common::ScanSpec> scanSpec_;
diff --git a/velox/connectors/hive/TableHandle.cpp b/velox/connectors/hive/TableHandle.cpp
index 3f7c8b6f93d5..85f4a2f3ada8 100644
--- a/velox/connectors/hive/TableHandle.cpp
+++ b/velox/connectors/hive/TableHandle.cpp
@@ -26,6 +26,7 @@ columnTypeNames() {
       {HiveColumnHandle::ColumnType::kRegular, "Regular"},
       {HiveColumnHandle::ColumnType::kSynthesized, "Synthesized"},
       {HiveColumnHandle::ColumnType::kRowIndex, "RowIndex"},
+      {HiveColumnHandle::ColumnType::kRowId, "RowId"},
   };
 }
 
@@ -110,14 +111,21 @@ HiveTableHandle::HiveTableHandle(
     common::SubfieldFilters subfieldFilters,
     const core::TypedExprPtr& remainingFilter,
     const RowTypePtr& dataColumns,
-    const std::unordered_map<std::string, std::string>& tableParameters)
+    const std::unordered_map<std::string, std::string>& tableParameters,
+    std::vector<HiveColumnHandlePtr> filterColumnHandles,
+    double sampleRate)
     : ConnectorTableHandle(std::move(connectorId)),
       tableName_(tableName),
       filterPushdownEnabled_(filterPushdownEnabled),
       subfieldFilters_(std::move(subfieldFilters)),
       remainingFilter_(remainingFilter),
+      sampleRate_{sampleRate},
       dataColumns_(dataColumns),
-      tableParameters_(tableParameters) {}
+      tableParameters_(tableParameters),
+      filterColumnHandles_(std::move(filterColumnHandles)) {
+  VELOX_CHECK_GT(sampleRate_, 0.0, "Sample rate must be positive");
+  VELOX_CHECK_LE(sampleRate_, 1.0, "Sample rate must not exceed 1.0");
+}
 
 std::string HiveTableHandle::toString() const {
   std::stringstream out;
@@ -139,6 +147,9 @@ std::string HiveTableHandle::toString() const {
     }
     out << "]";
   }
+  if (sampleRate_ < 1.0) {
+    out << ", sample rate: " << sampleRate_;
+  }
   if (remainingFilter_) {
     out << ", remaining filter: (" << remainingFilter_->toString() << ")";
   }
@@ -159,6 +170,19 @@ std::string HiveTableHandle::toString() const {
     }
     out << "]";
   }
+  if (!filterColumnHandles_.empty()) {
+    out << ", filter column handles: [";
+    bool first = true;
+    for (auto& handle : filterColumnHandles_) {
+      if (first) {
+        first = false;
+      } else {
+        out << ", ";
+      }
+      out << handle->toString();
+    }
+    out << "]";
+  }
   return out.str();
 }
 
@@ -179,6 +203,11 @@ folly::dynamic HiveTableHandle::serialize() const {
   if (remainingFilter_) {
     obj["remainingFilter"] = remainingFilter_->serialize();
   }
+
+  if (sampleRate_ < 1.0) {
+    obj["sampleRate"] = sampleRate_;
+  }
+
   if (dataColumns_) {
     obj["dataColumns"] = dataColumns_->serialize();
   }
@@ -187,6 +216,13 @@ folly::dynamic HiveTableHandle::serialize() const {
     tableParameters[param.first] = param.second;
   }
   obj["tableParameters"] = tableParameters;
+  if (!filterColumnHandles_.empty()) {
+    folly::dynamic filterColumnHandles = folly::dynamic::array;
+    for (const auto& handle : filterColumnHandles_) {
+      filterColumnHandles.push_back(handle->serialize());
+    }
+    obj["filterColumnHandles"] = filterColumnHandles;
+  }
 
   return obj;
 }
@@ -214,6 +250,11 @@ ConnectorTableHandlePtr HiveTableHandle::create(
         filter->clone();
   }
 
+  double sampleRate = 1.0;
+  if (obj.count("sampleRate")) {
+    sampleRate = obj["sampleRate"].asDouble();
+  }
+
   RowTypePtr dataColumns;
   if (auto it = obj.find("dataColumns"); it != obj.items().end()) {
     dataColumns = ISerializable::deserialize<RowType>(it->second, context);
@@ -226,6 +267,14 @@ ConnectorTableHandlePtr HiveTableHandle::create(
     tableParameters.emplace(key.asString(), value.asString());
   }
 
+  std::vector<HiveColumnHandlePtr> filterColumnHandles;
+  if (auto it = obj.find("filterColumnHandles"); it != obj.items().end()) {
+    for (const auto& handle : it->second) {
+      filterColumnHandles.push_back(
+          ISerializable::deserialize<HiveColumnHandle>(handle, context));
+    }
+  }
+
   return std::make_shared<const HiveTableHandle>(
       connectorId,
       tableName,
@@ -233,7 +282,9 @@ ConnectorTableHandlePtr HiveTableHandle::create(
       std::move(subfieldFilters),
       remainingFilter,
       dataColumns,
-      tableParameters);
+      tableParameters,
+      std::move(filterColumnHandles),
+      sampleRate);
 }
 
 void HiveTableHandle::registerSerDe() {
diff --git a/velox/connectors/hive/TableHandle.h b/velox/connectors/hive/TableHandle.h
index 2711da55a37a..a59e371a84fd 100644
--- a/velox/connectors/hive/TableHandle.h
+++ b/velox/connectors/hive/TableHandle.h
@@ -25,6 +25,8 @@ namespace facebook::velox::connector::hive {
 
 class HiveColumnHandle : public ColumnHandle {
  public:
+  /// NOTE: Make sure to update the mapping in columnTypeNames() when modifying
+  /// this.
   enum class ColumnType {
     kPartitionKey,
     kRegular,
@@ -53,13 +55,15 @@ class HiveColumnHandle : public ColumnHandle {
       TypePtr dataType,
       TypePtr hiveType,
       std::vector<common::Subfield> requiredSubfields = {},
-      ColumnParseParameters columnParseParameters = {})
+      ColumnParseParameters columnParseParameters = {},
+      std::function<void(VectorPtr&)> postProcessor = {})
       : name_(name),
         columnType_(columnType),
         dataType_(std::move(dataType)),
         hiveType_(std::move(hiveType)),
         requiredSubfields_(std::move(requiredSubfields)),
-        columnParseParameters_(columnParseParameters) {
+        columnParseParameters_(columnParseParameters),
+        postProcessor_(std::move(postProcessor)) {
     VELOX_USER_CHECK(
         dataType_->equivalent(*hiveType_),
         "data type {} and hive type {} do not match",
@@ -110,7 +114,24 @@ class HiveColumnHandle : public ColumnHandle {
         ColumnParseParameters::kDaysSinceEpoch;
   }
 
-  std::string toString() const;
+  /// Apply some row-wise post processing to this column when it is present in
+  /// output.
+  ///
+  /// It's not allowed to change the size of the vector in the processor.  The
+  /// top level vector is guaranteed to be safe to change.  Any inner vectors
+  /// and buffers need to check the reference count before doing any change in
+  /// place, otherwise you need to allocate new vectors and buffers.
+  ///
+  /// For lazy vector, this will be applied after the lazy vector is loaded.
+  /// This is only applied after all the filtering is done; the filters (both
+  /// subfield filters and remaining filter) still apply to values before post
+  /// processing.  ValueHook usage will be disabled if a post processor is
+  /// present.
+  const std::function<void(VectorPtr&)>& postProcessor() const {
+    return postProcessor_;
+  }
+
+  std::string toString() const override;
 
   folly::dynamic serialize() const override;
 
@@ -130,10 +151,17 @@ class HiveColumnHandle : public ColumnHandle {
   const TypePtr hiveType_;
   const std::vector<common::Subfield> requiredSubfields_;
   const ColumnParseParameters columnParseParameters_;
+  const std::function<void(VectorPtr&)> postProcessor_;
 };
 
+using HiveColumnHandlePtr = std::shared_ptr<const HiveColumnHandle>;
+using HiveColumnHandleMap =
+    std::unordered_map<std::string, HiveColumnHandlePtr>;
+
 class HiveTableHandle : public ConnectorTableHandle {
  public:
+  /// @param sampleRate Sampling rate in (0, 1] range. 0.1 means 10% sampling.
+  /// 1.0 means no sampling. Default is no sampling.
   HiveTableHandle(
       std::string connectorId,
       const std::string& tableName,
@@ -141,7 +169,9 @@ class HiveTableHandle : public ConnectorTableHandle {
       common::SubfieldFilters subfieldFilters,
       const core::TypedExprPtr& remainingFilter,
       const RowTypePtr& dataColumns = nullptr,
-      const std::unordered_map<std::string, std::string>& tableParameters = {});
+      const std::unordered_map<std::string, std::string>& tableParameters = {},
+      std::vector<HiveColumnHandlePtr> filterColumnHandles = {},
+      double sampleRate = 1.0);
 
   const std::string& tableName() const {
     return tableName_;
@@ -151,27 +181,53 @@ class HiveTableHandle : public ConnectorTableHandle {
     return tableName();
   }
 
-  bool isFilterPushdownEnabled() const {
+  [[deprecated]] bool isFilterPushdownEnabled() const {
     return filterPushdownEnabled_;
   }
 
+  /// Single field filters that can be applied efficiently during file reading.
   const common::SubfieldFilters& subfieldFilters() const {
     return subfieldFilters_;
   }
 
+  /// Everything else that cannot be converted into subfield filters, but still
+  /// require the data source to filter out.  This is usually less efficient
+  /// than subfield filters but supports arbitrary boolean expression.
   const core::TypedExprPtr& remainingFilter() const {
     return remainingFilter_;
   }
 
-  // Schema of the table.  Need this for reading TEXTFILE.
+  /// Sampling rate between 0 and 1 (excluding 0). 0.1 means 10%
+  /// sampling. 1.0 means no sampling.
+  double sampleRate() const {
+    return sampleRate_;
+  }
+
+  /// Subset of schema of the table that we store in file (i.e.,
+  /// non-partitioning columns).  This must be in the exact order as columns in
+  /// file (except trailing columns), but with the table schema during read
+  /// time.
+  ///
+  /// This is needed for multiple purposes, including reading TEXTFILE and
+  /// handling schema evolution.
   const RowTypePtr& dataColumns() const {
     return dataColumns_;
   }
 
+  /// Extra parameters to pass down to file format reader layer.  Keys should be
+  /// in dwio::common::TableParameter.
   const std::unordered_map<std::string, std::string>& tableParameters() const {
     return tableParameters_;
   }
 
+  /// Extra columns that are used in filters and remaining filters, but not in
+  /// the output.  If there is overlap with data source assignments parameter,
+  /// the name and types should be the same (the required subfields are taken
+  /// from assignments).
+  const std::vector<HiveColumnHandlePtr> filterColumnHandles() const {
+    return filterColumnHandles_;
+  }
+
   std::string toString() const override;
 
   folly::dynamic serialize() const override;
@@ -187,8 +243,12 @@ class HiveTableHandle : public ConnectorTableHandle {
   const bool filterPushdownEnabled_;
   const common::SubfieldFilters subfieldFilters_;
   const core::TypedExprPtr remainingFilter_;
+  const double sampleRate_;
   const RowTypePtr dataColumns_;
   const std::unordered_map<std::string, std::string> tableParameters_;
+  const std::vector<HiveColumnHandlePtr> filterColumnHandles_;
 };
 
+using HiveTableHandlePtr = std::shared_ptr<const HiveTableHandle>;
+
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/benchmarks/CMakeLists.txt b/velox/connectors/hive/benchmarks/CMakeLists.txt
index 38c15bb9c057..aa82fc2edd0b 100644
--- a/velox/connectors/hive/benchmarks/CMakeLists.txt
+++ b/velox/connectors/hive/benchmarks/CMakeLists.txt
@@ -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.
-add_executable(velox_hive_partition_function_benchmark
-               HivePartitionFunctionBenchmark.cpp)
+add_executable(velox_hive_partition_function_benchmark HivePartitionFunctionBenchmark.cpp)
 
 target_link_libraries(
   velox_hive_partition_function_benchmark
@@ -31,4 +30,5 @@ target_link_libraries(
   velox_memory
   Folly::folly
   Folly::follybenchmark
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp b/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
index f503cb6e2e8f..b55c02d7c073 100644
--- a/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
+++ b/velox/connectors/hive/benchmarks/HivePartitionFunctionBenchmark.cpp
@@ -97,7 +97,7 @@ class HivePartitionFunctionBenchmark
   void run(HivePartitionFunction* function) {
     if (rowVectors_.find(KIND) == rowVectors_.end()) {
       throw std::runtime_error(
-          fmt::format("Unsupported type {}.", mapTypeKindToName(KIND)));
+          fmt::format("Unsupported type {}.", TypeKindName::toName(KIND)));
     }
     function->partition(*rowVectors_[KIND], partitions_);
   }
diff --git a/velox/connectors/hive/iceberg/CMakeLists.txt b/velox/connectors/hive/iceberg/CMakeLists.txt
index bc78005c91bb..fe20d16bdc44 100644
--- a/velox/connectors/hive/iceberg/CMakeLists.txt
+++ b/velox/connectors/hive/iceberg/CMakeLists.txt
@@ -12,11 +12,25 @@
 # 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_add_library(
+  velox_hive_iceberg_splitreader
+  IcebergConnector.cpp
+  IcebergDataSink.cpp
+  IcebergPartitionName.cpp
+  IcebergSplit.cpp
+  IcebergSplitReader.cpp
+  PartitionSpec.cpp
+  PositionalDeleteFileReader.cpp
+  TransformEvaluator.cpp
+  TransformExprBuilder.cpp
+)
 
-velox_link_libraries(velox_hive_iceberg_splitreader velox_connector
-                     Folly::folly)
+velox_link_libraries(
+  velox_hive_iceberg_splitreader
+  velox_connector
+  velox_functions_iceberg
+  Folly::folly
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/connectors/hive/iceberg/IcebergConnector.cpp b/velox/connectors/hive/iceberg/IcebergConnector.cpp
new file mode 100644
index 000000000000..cec2422d36d0
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergConnector.cpp
@@ -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.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
+
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/iceberg/IcebergDataSink.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+const std::string_view kIcebergFunctionPrefixConfig{"presto.iceberg-namespace"};
+const std::string_view kDefaultIcebergFunctionPrefix{"$internal$.iceberg."};
+
+namespace {
+
+// Registers Iceberg partition transform functions with prefix.
+// NOTE: These functions are registered for internal transform usage only.
+// Upstream engines such as Prestissimo and Gluten should register the same
+// functions with different prefixes to avoid conflicts.
+void registerIcebergInternalFunctions(const std::string& prefix) {
+  static std::once_flag registerFlag;
+
+  std::call_once(registerFlag, [prefix]() {
+    functions::iceberg::registerFunctions(prefix);
+  });
+}
+
+} // namespace
+
+IcebergConnector::IcebergConnector(
+    const std::string& id,
+    std::shared_ptr<const config::ConfigBase> config,
+    folly::Executor* ioExecutor)
+    : HiveConnector(id, config, ioExecutor),
+      functionPrefix_(config->get<std::string>(
+          std::string(kIcebergFunctionPrefixConfig),
+          std::string(kDefaultIcebergFunctionPrefix))) {
+  registerIcebergInternalFunctions(functionPrefix_);
+}
+
+std::unique_ptr<DataSink> IcebergConnector::createDataSink(
+    RowTypePtr inputType,
+    ConnectorInsertTableHandlePtr connectorInsertTableHandle,
+    ConnectorQueryCtx* connectorQueryCtx,
+    CommitStrategy commitStrategy) {
+  auto icebergInsertHandle = checkedPointerCast<const IcebergInsertTableHandle>(
+      connectorInsertTableHandle);
+
+  return std::make_unique<IcebergDataSink>(
+      inputType,
+      icebergInsertHandle,
+      connectorQueryCtx,
+      commitStrategy,
+      hiveConfig_,
+      functionPrefix_);
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergConnector.h b/velox/connectors/hive/iceberg/IcebergConnector.h
new file mode 100644
index 000000000000..ffe0397fa640
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergConnector.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 "velox/connectors/hive/HiveConnector.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// TODO Add IcebergConfig class and Move these configuration properties to
+/// IcebergConfig.h
+extern const std::string_view kIcebergFunctionPrefixConfig;
+extern const std::string_view kDefaultIcebergFunctionPrefix;
+
+/// Provides Iceberg table format support.
+/// - Creates HiveDataSource instances that use IcebergSplitReader for reading
+///   Iceberg tables with support for delete files and schema evolution.
+/// - Creates IcebergDataSink instances for writing data with Iceberg-specific
+///   partition transforms and commit metadata.
+class IcebergConnector final : public HiveConnector {
+ public:
+  IcebergConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor);
+
+  /// Creates IcebergDataSink for writing to Iceberg tables.
+  ///
+  /// @param inputType The schema of the input data to write.
+  /// @param connectorInsertTableHandle Must be an IcebergInsertTableHandle
+  ///        containing Iceberg-specific write configuration.
+  /// @param connectorQueryCtx Query context for the write operation.
+  /// @param commitStrategy Strategy for committing the write operation. Only
+  ///        CommitStrategy::kNoCommit is supported for Iceberg tables. Files
+  ///        are written directly with their final names and commit metadata is
+  ///        returned for the coordinator to update the Iceberg metadata tables.
+  /// @return IcebergDataSink instance configured for the write operation.
+  std::unique_ptr<DataSink> createDataSink(
+      RowTypePtr inputType,
+      ConnectorInsertTableHandlePtr connectorInsertTableHandle,
+      ConnectorQueryCtx* connectorQueryCtx,
+      CommitStrategy commitStrategy) override;
+
+ private:
+  const std::string functionPrefix_;
+};
+
+class IcebergConnectorFactory final : public ConnectorFactory {
+ public:
+  static constexpr const char* kIcebergConnectorName = "iceberg";
+
+  IcebergConnectorFactory() : ConnectorFactory(kIcebergConnectorName) {}
+
+  /// Creates a new IcebergConnector instance.
+  ///
+  /// @param id Unique identifier for this connector instance (typically the
+  /// catalog name).
+  /// @param config Connector configuration properties
+  /// @param ioExecutor Optional executor for asynchronous I/O operations such
+  /// as split preloading and file prefetching. When provided, enables
+  /// background file operations off the main driver thread. If nullptr, I/O
+  /// operations run synchronously.
+  /// @param cpuExecutor ConnectorFactory interface to support other connector
+  /// types that may need CPU-bound async work. Currently unused by
+  /// IcebergConnector.
+  /// @return Shared pointer to the newly created IcebergConnector instance
+  std::shared_ptr<Connector> newConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor = nullptr,
+      [[maybe_unused]] folly::Executor* cpuExecutor = nullptr) override {
+    return std::make_shared<IcebergConnector>(id, config, ioExecutor);
+  }
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDataSink.cpp b/velox/connectors/hive/iceberg/IcebergDataSink.cpp
new file mode 100644
index 000000000000..7297174bc650
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDataSink.cpp
@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/IcebergDataSink.h"
+
+#include <boost/lexical_cast.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include "velox/common/base/Fs.h"
+#include "velox/connectors/hive/PartitionIdGenerator.h"
+#include "velox/connectors/hive/iceberg/TransformExprBuilder.h"
+#include "velox/exec/OperatorUtils.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+template <TypeKind Kind>
+folly::dynamic extractPartitionValue(
+    const VectorPtr& child,
+    vector_size_t row) {
+  using T = typename TypeTraits<Kind>::NativeType;
+  return child->as<SimpleVector<T>>()->valueAt(row);
+}
+
+template <>
+folly::dynamic extractPartitionValue<TypeKind::VARCHAR>(
+    const VectorPtr& child,
+    vector_size_t row) {
+  return child->as<SimpleVector<StringView>>()->valueAt(row).str();
+}
+
+template <>
+folly::dynamic extractPartitionValue<TypeKind::VARBINARY>(
+    const VectorPtr& child,
+    vector_size_t row) {
+  return child->as<SimpleVector<StringView>>()->valueAt(row).str();
+}
+
+template <>
+folly::dynamic extractPartitionValue<TypeKind::TIMESTAMP>(
+    const VectorPtr& child,
+    vector_size_t row) {
+  return child->as<SimpleVector<Timestamp>>()->valueAt(row).toMicros();
+}
+
+class IcebergFileNameGenerator : public FileNameGenerator {
+ public:
+  std::pair<std::string, std::string> gen(
+      std::optional<uint32_t> bucketId,
+      const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
+      const ConnectorQueryCtx& connectorQueryCtx,
+      bool commitRequired) const override;
+
+  folly::dynamic serialize() const override;
+
+  std::string toString() const override;
+};
+
+std::string makeUuid() {
+  return boost::lexical_cast<std::string>(boost::uuids::random_generator()());
+}
+
+std::pair<std::string, std::string> IcebergFileNameGenerator::gen(
+    std::optional<uint32_t> bucketId,
+    const std::shared_ptr<const HiveInsertTableHandle> insertTableHandle,
+    const ConnectorQueryCtx& connectorQueryCtx,
+    bool commitRequired) const {
+  auto targetFileName = insertTableHandle->locationHandle()->targetFileName();
+  if (targetFileName.empty()) {
+    targetFileName = fmt::format("{}", makeUuid());
+  }
+  auto fileFormat = dwio::common::toString(insertTableHandle->storageFormat());
+  auto fileName = fmt::format("{}.{}", targetFileName, fileFormat);
+  return {fileName, fileName};
+}
+
+folly::dynamic IcebergFileNameGenerator::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "IcebergFileNameGenerator";
+  return obj;
+}
+
+std::string IcebergFileNameGenerator::toString() const {
+  return "IcebergFileNameGenerator";
+}
+
+} // namespace
+
+IcebergInsertTableHandle::IcebergInsertTableHandle(
+    std::vector<HiveColumnHandlePtr> inputColumns,
+    LocationHandlePtr locationHandle,
+    dwio::common::FileFormat tableStorageFormat,
+    IcebergPartitionSpecPtr partitionSpec,
+    std::optional<common::CompressionKind> compressionKind,
+    const std::unordered_map<std::string, std::string>& serdeParameters)
+    : HiveInsertTableHandle(
+          std::move(inputColumns),
+          std::move(locationHandle),
+          tableStorageFormat,
+          nullptr,
+          compressionKind,
+          serdeParameters,
+          nullptr,
+          false,
+          std::make_shared<const HiveInsertFileNameGenerator>()),
+      partitionSpec_(partitionSpec) {
+  VELOX_USER_CHECK(
+      !inputColumns_.empty(),
+      "Input columns cannot be empty for Iceberg tables.");
+  VELOX_USER_CHECK_NOT_NULL(
+      locationHandle_, "Location handle is required for Iceberg tables.");
+  VELOX_USER_CHECK_EQ(
+      tableStorageFormat,
+      dwio::common::FileFormat::PARQUET,
+      "Only Parquet file format is supported when writing Iceberg tables.");
+}
+
+namespace {
+
+// Creates partition channels by mapping partition spec fields to input column
+// indices. For each field in the partition spec, finds the corresponding
+// partition key column in the input columns and records its index.
+//
+// @param inputColumns The input columns from the insert table handle.
+// @param partitionSpec The Iceberg partition specification, or nullptr if
+// unpartitioned.
+// @return A vector of column indices representing the partition channels. Each
+// index corresponds to a partition field in the spec and points to the
+// matching partition key column in the input. Returns an empty vector if
+// partitionSpec is nullptr.
+std::vector<column_index_t> createPartitionChannels(
+    const std::vector<HiveColumnHandlePtr>& inputColumns,
+    const IcebergPartitionSpecPtr& partitionSpec) {
+  std::vector<column_index_t> channels;
+  if (!partitionSpec) {
+    return channels;
+  }
+
+  // Build a map from partition key column names to their indices in the input.
+  std::unordered_map<std::string, column_index_t> partitionKeyMap;
+  for (auto i = 0; i < inputColumns.size(); ++i) {
+    if (inputColumns[i]->isPartitionKey()) {
+      partitionKeyMap[inputColumns[i]->name()] = i;
+    }
+  }
+
+  // For each field in the partition spec, find its corresponding input column
+  // index.
+  channels.reserve(partitionSpec->fields.size());
+  for (const auto& field : partitionSpec->fields) {
+    if (auto it = partitionKeyMap.find(field.name);
+        it != partitionKeyMap.end()) {
+      channels.push_back(it->second);
+    }
+  }
+
+  return channels;
+}
+
+std::vector<column_index_t> createDataChannels(
+    const IcebergInsertTableHandlePtr& insertTableHandle) {
+  std::vector<column_index_t> dataChannels(
+      insertTableHandle->inputColumns().size());
+  std::iota(dataChannels.begin(), dataChannels.end(), 0);
+  return dataChannels;
+}
+
+// Creates a RowType schema for transformed partition values based on the
+// partition specification. This RowType is used to wrap the transformed
+// partition columns before passing them to the partition ID generator.
+//
+// For each partition field in the spec:
+// - The column type is the result type of the partition transform (e.g.,
+//   INTEGER for year transform, DATE for day transform).
+// - The column name is the source column name for identity transforms, or
+//   "columnName_transformName" for non-identity transforms (e.g., "birth_year"
+//   for a year transform on a birth column).
+//
+// @param partitionSpec The Iceberg partition specification, or nullptr if
+// unpartitioned.
+// @return A RowType containing one column per partition field with appropriate
+// names and types. Returns nullptr if partitionSpec is nullptr.
+RowTypePtr createPartitionRowType(
+    const IcebergPartitionSpecPtr& partitionSpec) {
+  if (!partitionSpec) {
+    return nullptr;
+  }
+
+  std::vector<TypePtr> partitionKeyTypes;
+  std::vector<std::string> partitionKeyNames;
+
+  // Build column names and types for each partition field.
+  // Identity transforms use the source column name directly.
+  // Non-identity transforms use "columnName_transformName" format.
+  for (const auto& field : partitionSpec->fields) {
+    partitionKeyTypes.emplace_back(field.resultType());
+    std::string key = field.transformType == TransformType::kIdentity
+        ? field.name
+        : fmt::format(
+              "{}_{}",
+              field.name,
+              TransformTypeName::toName(field.transformType));
+    partitionKeyNames.emplace_back(std::move(key));
+  }
+
+  return ROW(std::move(partitionKeyNames), std::move(partitionKeyTypes));
+}
+
+} // namespace
+
+IcebergDataSink::IcebergDataSink(
+    RowTypePtr inputType,
+    IcebergInsertTableHandlePtr insertTableHandle,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    CommitStrategy commitStrategy,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::string& functionPrefix)
+    : IcebergDataSink(
+          std::move(inputType),
+          insertTableHandle,
+          connectorQueryCtx,
+          commitStrategy,
+          hiveConfig,
+          createPartitionChannels(
+              insertTableHandle->inputColumns(),
+              insertTableHandle->partitionSpec()),
+          createDataChannels(insertTableHandle),
+          createPartitionRowType(insertTableHandle->partitionSpec()),
+          functionPrefix) {}
+
+IcebergDataSink::IcebergDataSink(
+    RowTypePtr inputType,
+    IcebergInsertTableHandlePtr insertTableHandle,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    CommitStrategy commitStrategy,
+    const std::shared_ptr<const HiveConfig>& hiveConfig,
+    const std::vector<column_index_t>& partitionChannels,
+    const std::vector<column_index_t>& dataChannels,
+    RowTypePtr partitionRowType,
+    const std::string& functionPrefix)
+    : HiveDataSink(
+          inputType,
+          insertTableHandle,
+          connectorQueryCtx,
+          commitStrategy,
+          hiveConfig,
+          0,
+          nullptr,
+          partitionChannels,
+          dataChannels,
+          !partitionChannels.empty()
+              ? std::make_unique<PartitionIdGenerator>(
+                    partitionRowType,
+                    [&partitionChannels]() {
+                      std::vector<column_index_t> transformedChannels(
+                          partitionChannels.size());
+                      std::iota(
+                          transformedChannels.begin(),
+                          transformedChannels.end(),
+                          0);
+                      return transformedChannels;
+                    }(),
+                    hiveConfig->maxPartitionsPerWriters(
+                        connectorQueryCtx->sessionProperties()),
+                    connectorQueryCtx->memoryPool())
+              : nullptr),
+      partitionSpec_(insertTableHandle->partitionSpec()),
+      transformEvaluator_(
+          !partitionChannels.empty() ? std::make_unique<TransformEvaluator>(
+                                           TransformExprBuilder::toExpressions(
+                                               partitionSpec_,
+                                               partitionChannels_,
+                                               inputType_,
+                                               functionPrefix),
+                                           connectorQueryCtx_)
+                                     : nullptr),
+      icebergPartitionName_(
+          partitionSpec_ != nullptr
+              ? std::make_unique<IcebergPartitionName>(partitionSpec_)
+              : nullptr),
+      partitionRowType_(std::move(partitionRowType)) {
+  commitPartitionValue_.resize(maxOpenWriters_);
+}
+
+std::vector<std::string> IcebergDataSink::commitMessage() const {
+  std::vector<std::string> commitTasks;
+  commitTasks.reserve(writerInfo_.size());
+
+  auto icebergInsertTableHandle =
+      std::dynamic_pointer_cast<const IcebergInsertTableHandle>(
+          insertTableHandle_);
+
+  for (auto i = 0; i < writerInfo_.size(); ++i) {
+    const auto& info = writerInfo_.at(i);
+    VELOX_CHECK_NOT_NULL(info);
+    // Following metadata (json format) is consumed by Presto CommitTaskData.
+    // It contains the minimal subset of metadata.
+    // TODO: Complete metrics is missing now and this could lead to suboptimal
+    // query plan, will collect full iceberg metrics in following PR.
+    // clang-format off
+    folly::dynamic commitData = folly::dynamic::object(
+    "path", (fs::path(info->writerParameters.writeDirectory()) /
+                    info->writerParameters.writeFileName()).string())
+      ("fileSizeInBytes", ioStats_.at(i)->rawBytesWritten())
+      ("metrics",
+        folly::dynamic::object("recordCount", info->numWrittenRows))
+      ("partitionSpecJson",
+        icebergInsertTableHandle->partitionSpec() ? icebergInsertTableHandle->partitionSpec()->specId : 0)
+      ("fileFormat", "PARQUET")
+      ("content", "DATA");
+    // clang-format on
+    if (!commitPartitionValue_.empty() && !commitPartitionValue_[i].isNull()) {
+      commitData["partitionDataJson"] = folly::toJson(
+          folly::dynamic::object("partitionValues", commitPartitionValue_[i]));
+    }
+    auto commitDataJson = folly::toJson(commitData);
+    commitTasks.push_back(commitDataJson);
+  }
+  return commitTasks;
+}
+
+void IcebergDataSink::computePartitionAndBucketIds(const RowVectorPtr& input) {
+  VELOX_CHECK(isPartitioned());
+  VELOX_CHECK_NOT_NULL(transformEvaluator_);
+  VELOX_CHECK_NOT_NULL(partitionIdGenerator_);
+  // Step 1: Apply transforms to input partition columns.
+  auto transformedColumns = transformEvaluator_->evaluate(input);
+
+  // Step 2: Create RowVector based on transformed columns.
+  const auto& transformedRowVector = std::make_shared<RowVector>(
+      connectorQueryCtx_->memoryPool(),
+      partitionRowType_,
+      nullptr,
+      input->size(),
+      std::move(transformedColumns));
+  partitionIdGenerator_->run(transformedRowVector, partitionIds_);
+}
+
+std::string IcebergDataSink::getPartitionName(uint32_t partitionId) const {
+  VELOX_CHECK_NOT_NULL(icebergPartitionName_);
+
+  return icebergPartitionName_->partitionName(
+      partitionId,
+      partitionIdGenerator_->partitionValues(),
+      partitionKeyAsLowerCase_);
+}
+
+uint32_t IcebergDataSink::ensureWriter(const HiveWriterId& id) {
+  auto writerId = HiveDataSink::ensureWriter(id);
+  if (commitPartitionValue_[writerId].isNull()) {
+    commitPartitionValue_[writerId] = makeCommitPartitionValue(writerId);
+  }
+  return writerId;
+}
+
+std::shared_ptr<dwio::common::WriterOptions>
+IcebergDataSink::createWriterOptions() const {
+  auto options = HiveDataSink::createWriterOptions();
+  // Per Iceberg specification (https://iceberg.apache.org/spec/#parquet):
+  // - Timestamps must be stored with microsecond precision.
+  // - Timestamps must NOT be adjusted to UTC timezone; they should be written
+  //   as-is without timezone conversion (empty string disables conversion).
+  //
+  // These settings are passed via serdeParameters to avoid including
+  // parquet-specific headers. The keys must match kParquetSerdeTimestampUnit
+  // and kParquetSerdeTimestampTimezone defined in
+  // velox/dwio/parquet/writer/Writer.h. The value "6" represents microseconds
+  // (TimestampPrecision::kMicroseconds).
+  options->serdeParameters["parquet.writer.timestamp.unit"] = "6";
+  options->serdeParameters["parquet.writer.timestamp.timezone"] = "";
+  // Re-process configs to apply the serde parameters we just set.
+  options->processConfigs(
+      *hiveConfig_->config(), *connectorQueryCtx_->sessionProperties());
+  return options;
+}
+
+folly::dynamic IcebergDataSink::makeCommitPartitionValue(
+    uint32_t writerIndex) const {
+  folly::dynamic partitionValues = folly::dynamic::array();
+  const auto& transformedValues = partitionIdGenerator_->partitionValues();
+  for (auto i = 0; i < partitionChannels_.size(); ++i) {
+    const auto& child = transformedValues->childAt(i);
+    if (child->isNullAt(writerIndex)) {
+      partitionValues.push_back(nullptr);
+    } else {
+      partitionValues.push_back(VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          extractPartitionValue, child->typeKind(), child, writerIndex));
+    }
+  }
+  return partitionValues;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergDataSink.h b/velox/connectors/hive/iceberg/IcebergDataSink.h
new file mode 100644
index 000000000000..022bd0d6b23a
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergDataSink.h
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/HiveDataSink.h"
+#include "velox/connectors/hive/iceberg/IcebergPartitionName.h"
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+#include "velox/connectors/hive/iceberg/TransformEvaluator.h"
+#include "velox/functions/iceberg/Register.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Represents a request for Iceberg write.
+class IcebergInsertTableHandle final : public HiveInsertTableHandle {
+ public:
+  /// @param inputColumns Columns from the table schema to write.
+  /// The input RowVector must have the same number of columns and matching
+  /// types in the same order.
+  /// Column names in the RowVector may differ from those in inputColumns,
+  /// only position and type must align. All columns present in the input
+  /// data must be included, mismatches can lead to write failure.
+  /// @param locationHandle Contains the target location information including:
+  /// - Base directory path where data files will be written.
+  /// - File naming scheme and temporary directory paths.
+  /// @param tableStorageFormat File format to use for writing data files.
+  /// @param partitionSpec Optional partition specification defining how to
+  /// partition the data. If nullptr, the table is unpartitioned and all data
+  /// is written to a single directory.
+  /// @param compressionKind Optional compression to apply to data files.
+  /// @param serdeParameters Additional serialization/deserialization parameters
+  /// for the file format.
+  IcebergInsertTableHandle(
+      std::vector<HiveColumnHandlePtr> inputColumns,
+      LocationHandlePtr locationHandle,
+      dwio::common::FileFormat tableStorageFormat,
+      IcebergPartitionSpecPtr partitionSpec,
+      std::optional<common::CompressionKind> compressionKind = {},
+      const std::unordered_map<std::string, std::string>& serdeParameters = {});
+
+#ifdef VELOX_ENABLE_BACKWARD_COMPATIBILITY
+  IcebergInsertTableHandle(
+      std::vector<HiveColumnHandlePtr> inputColumns,
+      LocationHandlePtr locationHandle,
+      dwio::common::FileFormat tableStorageFormat,
+      std::optional<common::CompressionKind> compressionKind = {},
+      const std::unordered_map<std::string, std::string>& serdeParameters = {})
+      : IcebergInsertTableHandle(
+            inputColumns,
+            locationHandle,
+            tableStorageFormat,
+            nullptr,
+            compressionKind,
+            serdeParameters) {}
+#endif
+
+  /// Returns the Iceberg partition specification that defines how the table
+  /// is partitioned.
+  const IcebergPartitionSpecPtr& partitionSpec() const {
+    return partitionSpec_;
+  }
+
+ private:
+  const IcebergPartitionSpecPtr partitionSpec_;
+};
+
+using IcebergInsertTableHandlePtr =
+    std::shared_ptr<const IcebergInsertTableHandle>;
+
+class IcebergDataSink : public HiveDataSink {
+ public:
+  IcebergDataSink(
+      RowTypePtr inputType,
+      IcebergInsertTableHandlePtr insertTableHandle,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      CommitStrategy commitStrategy,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const std::string& functionPrefix);
+
+  /// Generates Iceberg-specific commit messages for all writers containing
+  /// metadata about written files. Creates a JSON object for each writer
+  /// in the format expected by Presto and Spark for Iceberg tables.
+  ///
+  /// Each commit message contains:
+  /// - path: full file path where data was written.
+  /// - fileSizeInBytes: raw bytes written to disk.
+  /// - metrics: object with recordCount (number of rows written).
+  /// - partitionSpecJson: partition specification.
+  /// - fileFormat: storage format (e.g., "PARQUET").
+  /// - content: file content type ("DATA" for data files).
+  ///
+  /// See
+  /// https://github.com/prestodb/presto/blob/master/presto-iceberg/src/main/java/com/facebook/presto/iceberg/CommitTaskData.java
+  ///
+  /// Note: Complete Iceberg metrics are not yet implemented, which results in
+  /// incomplete manifest files that may lead to suboptimal query planning.
+  ///
+  /// @return Vector of JSON strings, one per writer, formatted according to
+  /// Presto and Spark Iceberg commit protocol.
+  std::vector<std::string> commitMessage() const override;
+
+ private:
+  IcebergDataSink(
+      RowTypePtr inputType,
+      IcebergInsertTableHandlePtr insertTableHandle,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      CommitStrategy commitStrategy,
+      const std::shared_ptr<const HiveConfig>& hiveConfig,
+      const std::vector<column_index_t>& partitionChannels,
+      const std::vector<column_index_t>& dataChannels,
+      RowTypePtr partitionRowType,
+      const std::string& functionPrefix);
+
+  // Computes partition IDs for each row in the input batch by applying Iceberg
+  // partition transforms and generating unique partition identifiers.
+  //
+  // Performs a two-step process:
+  // 1. Applies Iceberg partition transforms (e.g., year, month, day, hour,
+  //    bucket, truncate) to the input partition columns using
+  //    transformEvaluator_ to produce transformed partition values.
+  // 2. Wraps the transformed columns in a RowVector with partitionRowType_
+  //    schema and passes it to partitionIdGenerator_ to compute partition IDs.
+  //
+  // The resulting partition IDs are stored in partitionIds_ buffer, where each
+  // element corresponds to a row in the input. These IDs are used to:
+  // - Route rows to the appropriate writer (one writer per unique partition).
+  // - Generate partition directory names via getPartitionName().
+  //
+  // Note: Iceberg does not support bucketing, so this method only computes
+  // partition IDs, not bucket IDs.
+  //
+  // @param input The input RowVector containing rows to be partitioned.
+  void computePartitionAndBucketIds(const RowVectorPtr& input) override;
+
+  // Returns the Iceberg partition directory name for the given partition ID.
+  // Converts the transformed partition values associated with the partition ID
+  // into an Iceberg compliant directory path
+  // (e.g., "date_year=2023/id_bucket=5").
+  std::string getPartitionName(uint32_t partitionId) const override;
+
+  // Ensures a writer exists for the given writer ID and returns its index.
+  // If the writer doesn't exist, creates it by calling appendWriter().
+  // Additionally, extracts and stores the transformed partition values for
+  // the writer in commitPartitionValue_ if not already set, which will be
+  // included in the commit message as "partitionDataJson".
+  uint32_t ensureWriter(const HiveWriterId& id) override;
+
+  // Creates writer options configured for Iceberg table writes. Extends the
+  // base HiveDataSink writer options with Iceberg-specific settings:
+  // - Sets timestamp timezone to nullopt (UTC) for Iceberg compliance.
+  // - Sets timestamp precision to microseconds.
+  std::shared_ptr<dwio::common::WriterOptions> createWriterOptions()
+      const override;
+
+  // Extracts partition values for a specific writer to be included in the
+  // commit message. Converts the transformed partition values from columnar
+  // storage (partitionIdGenerator_->partitionValues() where each partition
+  // field is a separate column) to row storage (a folly::dynamic array of
+  // values for the given writer index) for JSON serialization.
+  // Returns nullptr for null partition values.
+  folly::dynamic makeCommitPartitionValue(uint32_t writerIndex) const;
+
+  // Iceberg partition specification defining how the table is partitioned.
+  // Contains partition fields with source column names, transform types
+  // (e.g., identity, year, month, day, hour, bucket, truncate), transform
+  // parameters, and result types. Null if the table is unpartitioned.
+  const IcebergPartitionSpecPtr partitionSpec_;
+
+  // Evaluates Iceberg partition transforms on input rows to produce transformed
+  // partition keys. Applies transforms defined in partitionSpec_ (e.g.,
+  // year(date_col), bucket(id, 16)) to the corresponding input columns and
+  // returns a vector of transformed columns. The transformed keys are then
+  // wrapped in a RowVector and passed to IcebergPartitionIdGenerator.
+  // Null if the table is unpartitioned.
+  const std::unique_ptr<TransformEvaluator> transformEvaluator_;
+
+  // Generates Iceberg compliant partition directory names from partition IDs.
+  // Converts transformed partition values to human-readable strings based on
+  // their transform types (e.g., year -> "2025", month -> "2025-11", hour ->
+  // "2025-11-12-13") and constructs URL-encoded partition paths.
+  // Null if the table is unpartitioned.
+  const std::unique_ptr<IcebergPartitionName> icebergPartitionName_;
+
+  // RowType schema for the transformed partition values RowVector.
+  // Contains one column per partition field in partitionSpec, where each
+  // column has:
+  // - Type: The result type of the partition transform (e.g., INTEGER for year
+  //   transform, DATE for day transform).
+  // - Name: Source column name for identity transforms, or
+  //   "columnName_transformName" for non-identity transforms (e.g.,
+  //   "date_year").
+  // Used to construct the RowVector that wraps the transformed partition
+  // columns before passing them to IcebergPartitionIdGenerator for partition ID
+  // generation and to IcebergPartitionNameGenerator for partition path name
+  // generation.
+  RowTypePtr partitionRowType_;
+
+  // Stores the transformed partition values for each writer to be included in
+  // the commit message sent to Presto. Indexed by writer index. Each entry
+  // contains the transformed partition values (as a folly::dynamic array) for
+  // that writer's partition, which are serialized to JSON as
+  // "partitionDataJson" in the commit protocol. These values represent the same
+  // transformed partition data as partitionIdGenerator_->partitionValues(), but
+  // converted from columnar storage (where each partition field is a separate
+  // column in the RowVector) to row storage (where each writer has a
+  // folly::dynamic array of values across all partition fields), ready for JSON
+  // serialization.
+  std::vector<folly::dynamic> commitPartitionValue_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergPartitionName.cpp b/velox/connectors/hive/iceberg/IcebergPartitionName.cpp
new file mode 100644
index 000000000000..97a0f565b8b7
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergPartitionName.cpp
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/IcebergPartitionName.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/dwio/catalog/fbhive/FileUtils.h"
+#include "velox/functions/prestosql/URLFunctions.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+std::string escapePathName(const std::string& name) {
+  std::string encoded;
+  // Pre-allocate for worst case: every byte is invalid UTF-8.
+  // urlEscape() writes directly into the pre-allocated buffer and
+  // calls resize() at the end to shrink to the actual size used.
+  encoded.resize(name.size() * 9);
+  functions::detail::urlEscape(encoded, name);
+  return encoded;
+}
+
+} // namespace
+
+IcebergPartitionName::IcebergPartitionName(
+    const IcebergPartitionSpecPtr& partitionSpec) {
+  VELOX_CHECK_NOT_NULL(partitionSpec);
+  transformTypes_.reserve(partitionSpec->fields.size());
+  for (const auto& field : partitionSpec->fields) {
+    transformTypes_.emplace_back(field.transformType);
+  }
+}
+
+std::string IcebergPartitionName::partitionName(
+    uint32_t partitionId,
+    const RowVectorPtr& partitionValues,
+    bool partitionKeyAsLowerCase) const {
+  auto toPartitionName = [this](
+                             auto value, const TypePtr& type, int columnIndex) {
+    return IcebergPartitionName::toName(
+        value, type, transformTypes_[columnIndex]);
+  };
+
+  return dwio::catalog::fbhive::FileUtils::makePartName(
+      HivePartitionName::partitionKeyValues(
+          partitionId,
+          partitionValues,
+          /*nullValueString=*/"null",
+          toPartitionName),
+      partitionKeyAsLowerCase,
+      /*useDefaultPartitionValue=*/false,
+      escapePathName);
+}
+
+std::string IcebergPartitionName::toName(
+    int32_t value,
+    const TypePtr& type,
+    TransformType transformType) {
+  constexpr int32_t kEpochYear = 1970;
+  switch (transformType) {
+    case TransformType::kIdentity: {
+      if (type->isDate()) {
+        return DateType::toIso8601(value);
+      }
+      return fmt::to_string(value);
+    }
+    case TransformType::kDay:
+      return DATE()->toString(value);
+    case TransformType::kYear:
+      return fmt::format("{:04d}", kEpochYear + value);
+    case TransformType::kMonth: {
+      int32_t year = kEpochYear + value / 12;
+      int32_t month = 1 + value % 12;
+      if (month <= 0) {
+        month += 12;
+        year -= 1;
+      }
+      return fmt::format("{:04d}-{:02d}", year, month);
+    }
+    case TransformType::kHour: {
+      int64_t seconds = static_cast<int64_t>(value) * 3600;
+      std::tm tmValue;
+      VELOX_USER_CHECK(
+          Timestamp::epochToCalendarUtc(seconds, tmValue),
+          "Failed to convert seconds to time: {}",
+          seconds);
+      return fmt::format(
+          "{:04d}-{:02d}-{:02d}-{:02d}",
+          tmValue.tm_year + 1900,
+          tmValue.tm_mon + 1,
+          tmValue.tm_mday,
+          tmValue.tm_hour);
+    }
+    default:
+      return fmt::to_string(value);
+  }
+}
+
+std::string IcebergPartitionName::toName(
+    Timestamp value,
+    const TypePtr& type,
+    TransformType transformType) {
+  VELOX_CHECK(transformType == TransformType::kIdentity);
+  TimestampToStringOptions options;
+  options.precision = TimestampPrecision::kMilliseconds;
+  options.zeroPaddingYear = true;
+  options.skipTrailingZeros = true;
+  options.leadingPositiveSign = true;
+  return value.toString(options);
+}
+
+std::string IcebergPartitionName::toName(
+    StringView value,
+    const TypePtr& type,
+    TransformType transformType) {
+  VELOX_CHECK(
+      transformType == TransformType::kIdentity ||
+      transformType == TransformType::kTruncate);
+  if (type->isVarbinary()) {
+    return encoding::Base64::encode(value.data(), value.size());
+  }
+  return std::string(value);
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergPartitionName.h b/velox/connectors/hive/iceberg/IcebergPartitionName.h
new file mode 100644
index 000000000000..751f3620c80d
--- /dev/null
+++ b/velox/connectors/hive/iceberg/IcebergPartitionName.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/connectors/hive/HivePartitionName.h"
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Generates Iceberg-compliant partition path names.
+/// Converts partition keys to human-readable strings based on their transform
+/// types (e.g., year, month, day, hour, identity, truncate) and constructs
+/// URL-encoded partition paths in the format "key1=value1/key2=value2/...".
+class IcebergPartitionName {
+ public:
+  /// @param partitionSpec Iceberg partition specification containing transform
+  /// definitions for each partition field. Used to get transform type and call
+  /// different format functions to convert transformed partition values to
+  /// human-readable strings.
+  IcebergPartitionName(const IcebergPartitionSpecPtr& partitionSpec);
+
+  /// Generates an Iceberg compliant partition path string for the given
+  /// partition ID.
+  ///
+  /// Constructs a partition path in the format "key1=value1/key2=value2/..."
+  /// where:
+  /// - Keys are partition column names for identity transforms, or
+  ///   "columnName_transformName" for non-identity transforms (e.g.,
+  ///   "date_year")
+  /// - Values are human-readable string representations of the transformed
+  ///   partition keys, formatted according to their transform types
+  /// - Both keys and values are URL-encoded per java.net.URLEncoder.encode()
+  ///
+  /// Example: "store_id=123/date_year=2025/address_bucket=1"
+  ///
+  /// Typically called once per partition ID when creating a new writer for that
+  /// partition.
+  ///
+  /// @param partitionId Sequential partition ID (0-based) used as the row index
+  /// into partitionValues. Must be less than partitionValues->size().
+  /// @param partitionValues RowVector containing transformed partition keys
+  /// for all partitions. Each row represents one unique partition, with
+  /// columns corresponding to partition fields in partitionSpec. Row at
+  /// partitionId contains the keys for this specific partition.
+  /// @param partitionKeyAsLowerCase Whether to convert partition keys to
+  /// lowercase in the generated partition path. When true, partition keys like
+  /// "Year" become "year" in the path "year=2025/...".
+  /// @return URL-encoded partition path string suitable for use in file paths.
+  std::string partitionName(
+      uint32_t partitionId,
+      const RowVectorPtr& partitionValues,
+      bool partitionKeyAsLowerCase) const;
+
+  /// Generic template for formatting simple types that just need string
+  /// conversion. Specialized for types that need special handling.
+  template <typename T>
+  FOLLY_ALWAYS_INLINE static std::string
+  toName(T value, const TypePtr& type, TransformType transformType) {
+    return HivePartitionName::toName(value, type);
+  }
+
+  /// Converts an int32_t partition key to its string representation based on
+  /// the transform type:
+  /// - kIdentity: For DATE type return "YYYY-MM-DD" format (e.g.,
+  ///              "2025-11-07").
+  ///              For other types return the value as-is (e.g., "-123").
+  /// - kDay: Returns date in "YYYY-MM-DD" format (e.g., "2025-11-07").
+  /// - kYear: Returns 4-digit year "YYYY" (e.g., "2025").
+  /// - kMonth: Returns "YYYY-MM" format (e.g., "2025-01").
+  /// - kHour: Returns "YYYY-MM-DD-HH" format (e.g., "2025-11-07-21").
+  static std::string
+  toName(int32_t value, const TypePtr& type, TransformType transformType);
+
+  /// Returns timestamp formatted with milliseconds precision, zero-padded
+  /// year, trailing zeros skipped, and leading positive sign for years >=
+  /// 10000. Examples:
+  /// - Timestamp(0, 0) -> "1970-01-01T00:00:00".
+  /// - Timestamp(1609459200, 999000000) -> "2021-01-01T00:00:00.999".
+  /// - Timestamp(1640995200, 500000000) -> "2022-01-01T00:00:00.5".
+  /// - Timestamp(-1, 999000000) -> "1969-12-31T23:59:59.999".
+  /// - Timestamp(253402300800, 100000000) -> "+10000-01-01T00:00:00.1".
+  static std::string
+  toName(Timestamp value, const TypePtr& type, TransformType transformType);
+
+  /// Converts a StringView partition key to its string representation.
+  /// - For VARBINARY type returns Base64-encoded string.
+  /// - For VARCHAR type returns the string value as-is.
+  static std::string
+  toName(StringView value, const TypePtr& type, TransformType transformType);
+
+ private:
+  // Cached transform types, one per partition column. Created once in
+  // constructor and reused for all formatting operations. Index corresponds to
+  // column index in partitionSpec_->fields.
+  std::vector<TransformType> transformTypes_;
+};
+
+using IcebergPartitionNamePtr = std::shared_ptr<const IcebergPartitionName>;
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplitReader.cpp b/velox/connectors/hive/iceberg/IcebergSplitReader.cpp
index 84c85d3dce0b..76b4c1fbacf1 100644
--- a/velox/connectors/hive/iceberg/IcebergSplitReader.cpp
+++ b/velox/connectors/hive/iceberg/IcebergSplitReader.cpp
@@ -26,9 +26,8 @@ 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 HiveTableHandlePtr& hiveTableHandle,
+    const std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
     const ConnectorQueryCtx* connectorQueryCtx,
     const std::shared_ptr<const HiveConfig>& hiveConfig,
     const RowTypePtr& readerOutputType,
@@ -55,7 +54,8 @@ IcebergSplitReader::IcebergSplitReader(
 
 void IcebergSplitReader::prepareSplit(
     std::shared_ptr<common::MetadataFilter> metadataFilter,
-    dwio::common::RuntimeStatistics& runtimeStats) {
+    dwio::common::RuntimeStatistics& runtimeStats,
+    const folly::F14FastMap<std::string, std::string>& fileReadOps) {
   createReader();
   if (emptySplit_) {
     return;
@@ -67,7 +67,7 @@ void IcebergSplitReader::prepareSplit(
     return;
   }
 
-  createRowReader(std::move(metadataFilter), std::move(rowType));
+  createRowReader(std::move(metadataFilter), std::move(rowType), std::nullopt);
 
   std::shared_ptr<const HiveIcebergSplit> icebergSplit =
       std::dynamic_pointer_cast<const HiveIcebergSplit>(hiveSplit_);
@@ -85,7 +85,7 @@ void IcebergSplitReader::prepareSplit(
                 hiveSplit_->filePath,
                 fileHandleFactory_,
                 connectorQueryCtx_,
-                executor_,
+                ioExecutor_,
                 hiveConfig_,
                 ioStats_,
                 fsStats_,
@@ -110,7 +110,7 @@ uint64_t IcebergSplitReader::next(uint64_t size, VectorPtr& output) {
   }
 
   const auto actualSize = baseRowReader_->nextReadSize(size);
-
+  baseReadOffset_ = baseRowReader_->nextRowNumber() - splitOffset_;
   if (actualSize == dwio::common::RowReader::kAtEnd) {
     return 0;
   }
@@ -137,9 +137,61 @@ uint64_t IcebergSplitReader::next(uint64_t size, VectorPtr& output) {
       : nullptr;
 
   auto rowsScanned = baseRowReader_->next(actualSize, output, &mutation);
-  baseReadOffset_ += rowsScanned;
 
   return rowsScanned;
 }
 
+std::vector<TypePtr> IcebergSplitReader::adaptColumns(
+    const RowTypePtr& fileType,
+    const RowTypePtr& tableSchema) const {
+  std::vector<TypePtr> columnTypes = fileType->children();
+  auto& childrenSpecs = scanSpec_->children();
+  // Iceberg table stores all column's data in data file.
+  for (const auto& childSpec : childrenSpecs) {
+    const std::string& fieldName = childSpec->fieldName();
+    if (auto iter = hiveSplit_->infoColumns.find(fieldName);
+        iter != hiveSplit_->infoColumns.end()) {
+      auto infoColumnType = readerOutputType_->findChild(fieldName);
+      auto constant = newConstantFromString(
+          infoColumnType,
+          iter->second,
+          connectorQueryCtx_->memoryPool(),
+          hiveConfig_->readTimestampPartitionValueAsLocalTime(
+              connectorQueryCtx_->sessionProperties()),
+          false);
+      childSpec->setConstantValue(constant);
+    } else {
+      auto fileTypeIdx = fileType->getChildIdxIfExists(fieldName);
+      auto outputTypeIdx = readerOutputType_->getChildIdxIfExists(fieldName);
+      if (outputTypeIdx.has_value() && fileTypeIdx.has_value()) {
+        childSpec->setConstantValue(nullptr);
+        auto& outputType = readerOutputType_->childAt(*outputTypeIdx);
+        columnTypes[*fileTypeIdx] = outputType;
+      } else if (!fileTypeIdx.has_value()) {
+        // Handle columns missing from the data file in two scenarios:
+        // 1. Schema evolution: Column was added after the data file was
+        // written and doesn't exist in older data files.
+        // 2. Partition columns: Hive migrated table. In Hive-written data
+        // files, partition column values are stored in partition metadata
+        // rather than in the data file itself, following Hive's partitioning
+        // convention.
+        if (auto it = hiveSplit_->partitionKeys.find(fieldName);
+            it != hiveSplit_->partitionKeys.end()) {
+          setPartitionValue(childSpec.get(), fieldName, it->second);
+        } else {
+          childSpec->setConstantValue(
+              BaseVector::createNullConstant(
+                  tableSchema->findChild(fieldName),
+                  1,
+                  connectorQueryCtx_->memoryPool()));
+        }
+      }
+    }
+  }
+
+  scanSpec_->resetCachedValues(false);
+
+  return columnTypes;
+}
+
 } // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/IcebergSplitReader.h b/velox/connectors/hive/iceberg/IcebergSplitReader.h
index 795912159b96..1b56aa077433 100644
--- a/velox/connectors/hive/iceberg/IcebergSplitReader.h
+++ b/velox/connectors/hive/iceberg/IcebergSplitReader.h
@@ -28,9 +28,8 @@ 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 HiveTableHandlePtr& hiveTableHandle,
+      const std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
       const ConnectorQueryCtx* connectorQueryCtx,
       const std::shared_ptr<const HiveConfig>& hiveConfig,
       const RowTypePtr& readerOutputType,
@@ -44,11 +43,56 @@ class IcebergSplitReader : public SplitReader {
 
   void prepareSplit(
       std::shared_ptr<common::MetadataFilter> metadataFilter,
-      dwio::common::RuntimeStatistics& runtimeStats) override;
+      dwio::common::RuntimeStatistics& runtimeStats,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {})
+      override;
 
   uint64_t next(uint64_t size, VectorPtr& output) override;
 
  private:
+  /// Adapts the data file schema to match the table schema expected by the
+  /// query.
+  ///
+  /// This method reconciles differences between the physical data file schema
+  /// and the logical table schema, handling various scenarios where columns may
+  /// be missing, added, or need special treatment.
+  ///
+  /// @param fileType The schema read from the data file's metadata. This
+  /// represents the actual columns physically present in the Parquet/ORC file.
+  /// @param tableSchema The logical schema defined in the catalog (e.g., from
+  /// DDL). This represents the current table schema that queries expect.
+  ///
+  /// @return A vector of column types adapted to match the query's
+  /// expectations, with appropriate type conversions and constant values set
+  /// for missing or special columns.
+  ///
+  /// The method handles the following scenarios for each column in the scan
+  /// spec:
+  ///
+  /// 1. Info columns (e.g., $path, $data_sequence_number, $deleted)
+  ///    These are virtual columns that provide metadata about the file itself.
+  ///    Values are read from hiveSplit_->infoColumns map and set as constant
+  ///    values in the scanSpec so they're materialized for all rows.
+  ///
+  /// 2. Regular columns present in File:
+  ///    Column exists in both fileType and readerOutputType. Type is adapted
+  ///    from fileType to match the expected output type, handling schema
+  ///    evolution where column types may have changed.
+  ///
+  /// 3. Columns missing from File:
+  ///    a) Partition columns (hive-migrated tables):
+  ///       Column is marked as partition key in hiveSplit_->partitionKeys.
+  ///       In Hive-written Iceberg tables, partition column values are stored
+  ///       in partition metadata, not in the data file itself. Value is read
+  ///       from partition metadata and set as a constant.
+  ///    b) Schema evolution (newly added columns):
+  ///       Column was added to the table schema after this data file was
+  ///       written. Set as NULL constant since the old file doesn't contain
+  ///       this column.
+  std::vector<TypePtr> adaptColumns(
+      const RowTypePtr& fileType,
+      const RowTypePtr& tableSchema) const override;
+
   // 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_;
diff --git a/velox/connectors/hive/iceberg/PartitionSpec.cpp b/velox/connectors/hive/iceberg/PartitionSpec.cpp
new file mode 100644
index 000000000000..4c9fae472ed0
--- /dev/null
+++ b/velox/connectors/hive/iceberg/PartitionSpec.cpp
@@ -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.
+ */
+
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+TransformCategory getTransformCategory(TransformType transformType) {
+  switch (transformType) {
+    case TransformType::kIdentity:
+      return TransformCategory::kIdentity;
+    case TransformType::kYear:
+    case TransformType::kMonth:
+    case TransformType::kDay:
+    case TransformType::kHour:
+      return TransformCategory::kTemporal;
+    case TransformType::kBucket:
+      return TransformCategory::kBucket;
+    case TransformType::kTruncate:
+      return TransformCategory::kTruncate;
+    default:
+      VELOX_UNREACHABLE("Unknown transform type");
+  }
+}
+
+bool isValidPartitionType(const TypePtr& type) {
+  return !(
+      type->isRow() || type->isArray() || type->isMap() || type->isDouble() ||
+      type->isReal() || isTimestampWithTimeZoneType(type));
+}
+
+bool canTransform(TransformType transformType, const TypePtr& type) {
+  switch (transformType) {
+    case TransformType::kIdentity:
+      return type->isTinyint() || type->isSmallint() || type->isInteger() ||
+          type->isBigint() || type->isBoolean() || type->isDecimal() ||
+          type->isDate() || type->isTimestamp() || type->isVarchar() ||
+          type->isVarbinary();
+    case TransformType::kYear:
+    case TransformType::kMonth:
+    case TransformType::kDay:
+      return type->isDate() || type->isTimestamp();
+    case TransformType::kHour:
+      return type->isTimestamp();
+    case TransformType::kBucket:
+      return type->isInteger() || type->isBigint() || type->isDecimal() ||
+          type->isVarchar() || type->isVarbinary() || type->isDate() ||
+          type->isTimestamp();
+    case TransformType::kTruncate:
+      return type->isInteger() || type->isBigint() || type->isDecimal() ||
+          type->isVarchar() || type->isVarbinary();
+    default:
+      VELOX_UNREACHABLE("Unsupported partition transform type.");
+  }
+}
+
+const auto& transformTypeNames() {
+  static const folly::F14FastMap<TransformType, std::string_view>
+      kTransformNames = {
+          {TransformType::kIdentity, "identity"},
+          {TransformType::kHour, "hour"},
+          {TransformType::kDay, "day"},
+          {TransformType::kMonth, "month"},
+          {TransformType::kYear, "year"},
+          {TransformType::kBucket, "bucket"},
+          {TransformType::kTruncate, "trunc"},
+      };
+  return kTransformNames;
+}
+
+const auto& transformCategoryNames() {
+  static const folly::F14FastMap<TransformCategory, std::string_view>
+      kTransformCategoryNames = {
+          {TransformCategory::kIdentity, "Identity"},
+          {TransformCategory::kBucket, "Bucket"},
+          {TransformCategory::kTruncate, "Truncate"},
+          {TransformCategory::kTemporal, "Temporal"},
+      };
+  return kTransformCategoryNames;
+}
+
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(TransformType, transformTypeNames);
+
+VELOX_DEFINE_ENUM_NAME(TransformCategory, transformCategoryNames);
+
+void IcebergPartitionSpec::checkCompatibility() const {
+  folly::F14FastMap<std::string_view, std::vector<TransformType>>
+      columnTransforms;
+
+  for (const auto& field : fields) {
+    const auto& type = field.type;
+    const auto& name = field.name;
+    VELOX_USER_CHECK(
+        isValidPartitionType(type),
+        "Type is not supported as a partition column: {}",
+        type->name());
+
+    VELOX_USER_CHECK(
+        canTransform(field.transformType, type),
+        "Transform is not supported for partition column. Column: '{}', Type: '{}', Transform: '{}'.",
+        name,
+        type->name(),
+        TransformTypeName::toName(field.transformType));
+
+    columnTransforms[name].emplace_back(field.transformType);
+  }
+
+  // Check for duplicate transform categories per column.
+  std::vector<std::string> errors;
+  for (const auto& [columnName, transforms] : columnTransforms) {
+    folly::F14FastSet<TransformCategory> seenCategories;
+    for (const auto& transform : transforms) {
+      auto category = getTransformCategory(transform);
+      if (!seenCategories.insert(category).second) {
+        std::vector<std::string> transformNames;
+        for (const auto& t : transforms) {
+          transformNames.emplace_back(
+              std::string(TransformTypeName::toName(t)));
+        }
+        errors.emplace_back(
+            fmt::format(
+                "Column: '{}', Category: {}, Transforms: [{}]",
+                columnName,
+                TransformCategoryName::toName(category),
+                folly::join(", ", transformNames)));
+        break;
+      }
+    }
+  }
+
+  VELOX_USER_CHECK(
+      errors.empty(),
+      "Multiple transforms of the same category on a column are not allowed. "
+      "Each transform category can appear at most once per column. {}",
+      folly::join("; ", errors));
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/PartitionSpec.h b/velox/connectors/hive/iceberg/PartitionSpec.h
new file mode 100644
index 000000000000..99297da0edc3
--- /dev/null
+++ b/velox/connectors/hive/iceberg/PartitionSpec.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 "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Partition transform types.
+/// Defines how source column values are converted into partition keys.
+/// See https://iceberg.apache.org/spec/#partition-transforms.
+enum class TransformType {
+  /// Use the source value as-is (no transformation).
+  kIdentity,
+  /// Extract a timestamp hour, as hours from 1970-01-01 00:00:00.
+  kHour,
+  /// Extract a date or timestamp day, as days from 1970-01-01.
+  kDay,
+  /// Extract a date or timestamp month, as months from 1970-01.
+  kMonth,
+  /// Extract a date or timestamp year, as years from 1970.
+  kYear,
+  /// Hash the value into N buckets for even distribution. Requires an integer
+  /// parameter specifying the bucket count.
+  kBucket,
+  /// Truncate strings or numbers to a specified width. Requires an integer
+  /// parameter specifying the truncate width.
+  kTruncate
+};
+
+VELOX_DECLARE_ENUM_NAME(TransformType);
+
+/// A single column can be used to produce multiple partition keys, but with
+/// following restrictions:
+/// - Transforms are organized into 4 categories: Identity, Temporal,
+///   Bucket, and Truncate.
+/// - Each category can appear at most once per column.
+/// - Sample valid specs on same column: ['truncate(a,2)', 'bucket(a,16)', 'a']
+///   or ['year(b)', 'bucket(b, 16)', 'b']
+enum class TransformCategory {
+  kIdentity,
+  /// Year/Month/Day/Hour
+  kTemporal,
+  kBucket,
+  kTruncate,
+};
+
+VELOX_DECLARE_ENUM_NAME(TransformCategory);
+
+/// Represents how to produce partition data for an Iceberg table.
+///
+/// This structure corresponds to the Iceberg Java PartitionSpec class but
+/// contains only the necessary fields for Velox. Partition keys are computed
+/// by transforming columns in a table.
+///
+/// The upstream engine processes this specification through the Iceberg Java
+/// library to validate column types, detect duplicates, and generate the
+/// partition spec that is passed to Velox.
+///
+/// IMPORTANT: Iceberg spec uses field IDs to identify source columns, but
+/// Velox RowType only supports matching fields by name. Therefore, Velox uses
+/// the partition field name to match against the table schema column names.
+/// Callers must ensure that partition field names exactly match the column
+/// names in the table schema.
+///
+/// The partition spec contains:
+/// - Unique ID for versioning and evolution.
+/// - Which source columns in current table schema to use for partitioning
+/// (identified by field name, not field ID as in the Iceberg spec).
+/// - What transforms to apply (identity, bucket, truncate etc.).
+/// - Transform parameters (e.g., bucket count, truncate width).
+struct IcebergPartitionSpec {
+  struct Field {
+    /// Column name as defined in table schema. This column's value is used to
+    /// compute partition key by applying 'transformType' transformation.
+    const std::string name;
+
+    /// Column type.
+    const TypePtr type;
+
+    /// Transform to apply. Callers must ensure the transform is compatible with
+    /// the column type.
+    const TransformType transformType;
+
+    /// Optional parameter for transforms that require configuration.
+    const std::optional<int32_t> parameter;
+
+    /// Returns the result type after applying this transform.
+    TypePtr resultType() const {
+      switch (transformType) {
+        case TransformType::kBucket:
+        case TransformType::kYear:
+        case TransformType::kMonth:
+        case TransformType::kHour:
+          return INTEGER();
+        case TransformType::kDay:
+          return DATE();
+        case TransformType::kIdentity:
+        case TransformType::kTruncate:
+          return type;
+      }
+      VELOX_UNREACHABLE("Unknown transform type");
+    }
+  };
+
+  const int32_t specId;
+  const std::vector<Field> fields;
+
+  /// Constructor with validation that:
+  /// - Each field's type is supported for partitioning.
+  /// - Each field's transform type is compatible with its data type.
+  /// - No transform category appears more than once per column (Identity,
+  ///   Temporal, Bucket, and Truncate are separate categories).
+  ///
+  /// @param _specId Partition specification ID.
+  /// @param _fields Vector of partition fields. When empty indicates no
+  /// partition.
+  /// @throws VeloxUserError if validation fails.
+  IcebergPartitionSpec(int32_t _specId, std::vector<Field> _fields)
+      : specId(_specId), fields(std::move(_fields)) {
+    checkCompatibility();
+  }
+
+ private:
+  // Validates partition fields for correctness.
+  // Checks type/transform compatibility and transform combination rules.
+  void checkCompatibility() const;
+};
+
+using IcebergPartitionSpecPtr = std::shared_ptr<const IcebergPartitionSpec>;
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp
index 8f0d7ad13750..346ac8fed72a 100644
--- a/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp
+++ b/velox/connectors/hive/iceberg/PositionalDeleteFileReader.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/connectors/hive/iceberg/PositionalDeleteFileReader.h"
 
+#include "velox/connectors/hive/BufferedInputBuilder.h"
 #include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/connectors/hive/iceberg/IcebergDeleteFile.h"
@@ -63,8 +64,9 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
   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));
+  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(
@@ -92,9 +94,11 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
       /*tableParameters=*/{},
       deleteReaderOpts);
 
-  auto deleteFileHandleCachePtr =
-      fileHandleFactory_->generate(deleteFile_.filePath);
-  auto deleteFileInput = createBufferedInput(
+  const FileHandleKey fileHandleKey{
+      .filename = deleteFile_.filePath,
+      .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
+  auto deleteFileHandleCachePtr = fileHandleFactory_->generate(fileHandleKey);
+  auto deleteFileInput = BufferedInputBuilder::getInstance()->create(
       *deleteFileHandleCachePtr,
       deleteReaderOpts,
       connectorQueryCtx,
@@ -135,6 +139,7 @@ PositionalDeleteFileReader::PositionalDeleteFileReader(
       deleteSplit_,
       nullptr,
       nullptr,
+      nullptr,
       deleteRowReaderOpts);
 
   deleteRowReader_.reset();
@@ -249,15 +254,17 @@ void PositionalDeleteFileReader::updateDeleteBitmap(
     deletePositionsOffset_++;
   }
 
-  deleteBitmapBuffer->setSize(std::max(
-      static_cast<uint64_t>(deleteBitmapBuffer->size()),
-      deletePositionsOffset_ == 0 ||
-              (deletePositionsOffset_ < deletePositionsVector->size() &&
-               deletePositions[deletePositionsOffset_] >= rowNumberUpperBound)
-          ? 0
-          : bits::nbytes(
-                deletePositions[deletePositionsOffset_ - 1] + 1 -
-                rowNumberLowerBound)));
+  deleteBitmapBuffer->setSize(
+      std::max(
+          static_cast<uint64_t>(deleteBitmapBuffer->size()),
+          deletePositionsOffset_ == 0 ||
+                  (deletePositionsOffset_ < deletePositionsVector->size() &&
+                   deletePositions[deletePositionsOffset_] >=
+                       rowNumberUpperBound)
+              ? 0
+              : bits::nbytes(
+                    deletePositions[deletePositionsOffset_ - 1] + 1 -
+                    rowNumberLowerBound)));
 }
 
 bool PositionalDeleteFileReader::readFinishedForBatch(
diff --git a/velox/connectors/hive/iceberg/TransformEvaluator.cpp b/velox/connectors/hive/iceberg/TransformEvaluator.cpp
new file mode 100644
index 000000000000..2744bddafa75
--- /dev/null
+++ b/velox/connectors/hive/iceberg/TransformEvaluator.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/connectors/hive/iceberg/TransformEvaluator.h"
+
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+TransformEvaluator::TransformEvaluator(
+    const std::vector<core::TypedExprPtr>& expressions,
+    const ConnectorQueryCtx* connectorQueryCtx)
+    : connectorQueryCtx_(connectorQueryCtx) {
+  VELOX_CHECK_NOT_NULL(connectorQueryCtx_);
+  exprSet_ = connectorQueryCtx_->expressionEvaluator()->compile(expressions);
+  VELOX_CHECK_NOT_NULL(exprSet_);
+}
+
+std::vector<VectorPtr> TransformEvaluator::evaluate(
+    const RowVectorPtr& input) const {
+  const auto numRows = input->size();
+  const auto numExpressions = exprSet_->exprs().size();
+
+  std::vector<VectorPtr> results(numExpressions);
+  SelectivityVector rows(numRows);
+
+  // Evaluate all expressions in one pass.
+  connectorQueryCtx_->expressionEvaluator()->evaluate(
+      exprSet_.get(), rows, *input, results);
+
+  return results;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/TransformEvaluator.h b/velox/connectors/hive/iceberg/TransformEvaluator.h
new file mode 100644
index 000000000000..ee7b26f7db8c
--- /dev/null
+++ b/velox/connectors/hive/iceberg/TransformEvaluator.h
@@ -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.
+ */
+#pragma once
+
+#include "velox/connectors/Connector.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Evaluates multiple expressions efficiently using batch evaluation.
+/// Expressions are compiled once in the constructor and reused across multiple
+/// input batches.
+class TransformEvaluator {
+ public:
+  /// Creates an evaluator with the given expressions and connector query
+  /// context. Compiles the expressions once for reuse across multiple
+  /// evaluations.
+  ///
+  /// @param expressions Vector of typed expressions to evaluate. These are
+  /// typically built using TransformExprBuilder::toExpressions() for Iceberg
+  /// partition transforms, but can be any valid Velox expressions. The
+  /// expressions are compiled once during construction.
+  /// @param connectorQueryCtx Connector query context providing access to the
+  /// expression evaluator (for compilation and evaluation) and memory pool.
+  /// Must remain valid for the lifetime of this TransformEvaluator.
+  TransformEvaluator(
+      const std::vector<core::TypedExprPtr>& expressions,
+      const ConnectorQueryCtx* connectorQueryCtx);
+
+  /// Evaluates all expressions on the input data in a single pass.
+  /// Uses the pre-compiled ExprSet from the constructor for efficiency.
+  ///
+  /// The input RowType must match the RowType used when building the
+  /// expressions (passed to TransformExprBuilder::toExpressions). The column
+  /// positions, names and types must align. Create new TransformEvaluator for
+  /// input that has different RowType with the one when building the
+  /// expressions.
+  ///
+  /// @param input Input row vector containing the source data. Must have the
+  /// same RowType (column positions, names and types) as used when building the
+  /// expressions in the constructor.
+  /// @return Vector of result columns, one for each expression, in the same
+  /// order as the expressions provided to the constructor.
+  std::vector<VectorPtr> evaluate(const RowVectorPtr& input) const;
+
+ private:
+  const ConnectorQueryCtx* connectorQueryCtx_;
+  std::unique_ptr<exec::ExprSet> exprSet_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/TransformExprBuilder.cpp b/velox/connectors/hive/iceberg/TransformExprBuilder.cpp
new file mode 100644
index 000000000000..4befbfb50b08
--- /dev/null
+++ b/velox/connectors/hive/iceberg/TransformExprBuilder.cpp
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/TransformExprBuilder.h"
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+/// Converts a single partition field to a typed expression.
+///
+/// Builds an expression tree for one partition transform. Identity transforms
+/// become FieldAccessTypedExpr, while other transforms (bucket, truncate,
+/// year, month, day, hour) become CallTypedExpr with appropriate function
+/// names and parameters.
+///
+/// @param field Partition field containing transform type, source column
+/// type, and optional parameter (e.g., bucket count, truncate width).
+/// @param inputFieldName Name of the source column in the input RowVector.
+/// @param icebergFuncPrefix Prefix of iceberg transform function names.
+/// @return Typed expression representing the transform.
+core::TypedExprPtr toExpression(
+    const IcebergPartitionSpec::Field& field,
+    const std::string& inputFieldName,
+    const std::string& icebergFuncPrefix) {
+  // For identity transform, just return a field access expression.
+  if (field.transformType == TransformType::kIdentity) {
+    return std::make_shared<core::FieldAccessTypedExpr>(
+        field.type, inputFieldName);
+  }
+
+  // For other transforms, build a CallTypedExpr with the appropriate function.
+  std::string functionName;
+  switch (field.transformType) {
+    case TransformType::kBucket:
+      functionName = icebergFuncPrefix + "bucket";
+      break;
+    case TransformType::kTruncate:
+      functionName = icebergFuncPrefix + "truncate";
+      break;
+    case TransformType::kYear:
+      functionName = icebergFuncPrefix + "years";
+      break;
+    case TransformType::kMonth:
+      functionName = icebergFuncPrefix + "months";
+      break;
+    case TransformType::kDay:
+      functionName = icebergFuncPrefix + "days";
+      break;
+    case TransformType::kHour:
+      functionName = icebergFuncPrefix + "hours";
+      break;
+    case TransformType::kIdentity:
+      break;
+  }
+
+  // Build the expression arguments.
+  std::vector<core::TypedExprPtr> exprArgs;
+  if (field.parameter.has_value()) {
+    exprArgs.emplace_back(
+        std::make_shared<core::ConstantTypedExpr>(
+            INTEGER(), Variant(field.parameter.value())));
+  }
+  exprArgs.emplace_back(
+      std::make_shared<core::FieldAccessTypedExpr>(field.type, inputFieldName));
+
+  return std::make_shared<core::CallTypedExpr>(
+      field.resultType(), std::move(exprArgs), functionName);
+}
+
+} // namespace
+
+std::vector<core::TypedExprPtr> TransformExprBuilder::toExpressions(
+    const IcebergPartitionSpecPtr& partitionSpec,
+    const std::vector<column_index_t>& partitionChannels,
+    const RowTypePtr& inputType,
+    const std::string& icebergFuncPrefix) {
+  VELOX_CHECK_EQ(
+      partitionSpec->fields.size(),
+      partitionChannels.size(),
+      "Number of partition fields must match number of partition channels");
+
+  const auto numTransforms = partitionChannels.size();
+  std::vector<core::TypedExprPtr> transformExprs;
+  transformExprs.reserve(numTransforms);
+
+  for (auto i = 0; i < numTransforms; i++) {
+    const auto channel = partitionChannels[i];
+    transformExprs.emplace_back(toExpression(
+        partitionSpec->fields.at(i),
+        inputType->nameOf(channel),
+        icebergFuncPrefix));
+  }
+
+  return transformExprs;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/TransformExprBuilder.h b/velox/connectors/hive/iceberg/TransformExprBuilder.h
new file mode 100644
index 000000000000..b583adcf97df
--- /dev/null
+++ b/velox/connectors/hive/iceberg/TransformExprBuilder.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/connectors/hive/iceberg/PartitionSpec.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+/// Converts Iceberg partition specification to Velox expressions.
+class TransformExprBuilder {
+ public:
+  /// Converts partition specification to a list of typed expressions.
+  ///
+  /// @param partitionSpec Iceberg partition specification containing transform
+  /// definitions for each partition field.
+  /// @param partitionChannels Column indices (0-based) in the input RowVector
+  /// that correspond to each partition field. Must have the same size as
+  /// partitionSpec->fields. Provides the positional mapping from partition spec
+  /// fields to input RowVector columns.
+  /// @param inputType The row type of the input data. This is necessary for
+  /// building expressions because the column names in partitionSpec reference
+  /// table schema names, which might not match the column names in inputType
+  /// (e.g., inputType may use generated names like c0, c1, c2). The
+  /// FieldAccessTypedExpr must be built using the actual column names from
+  /// inputType that will be present at runtime. The partitionChannels provide
+  /// the positional mapping to locate the correct columns.
+  /// @param icebergFuncPrefix Prefix for Iceberg transform function names.
+  /// @return Vector of typed expressions, one for each partition field.
+  static std::vector<core::TypedExprPtr> toExpressions(
+      const IcebergPartitionSpecPtr& partitionSpec,
+      const std::vector<column_index_t>& partitionChannels,
+      const RowTypePtr& inputType,
+      const std::string& icebergFuncPrefix);
+};
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/CMakeLists.txt b/velox/connectors/hive/iceberg/tests/CMakeLists.txt
index 51d1116d1845..883503bbef70 100644
--- a/velox/connectors/hive/iceberg/tests/CMakeLists.txt
+++ b/velox/connectors/hive/iceberg/tests/CMakeLists.txt
@@ -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.
-add_library(velox_dwio_iceberg_reader_benchmark_lib
-            IcebergSplitReaderBenchmark.cpp)
+add_library(velox_dwio_iceberg_reader_benchmark_lib IcebergSplitReaderBenchmark.cpp)
 target_link_libraries(
   velox_dwio_iceberg_reader_benchmark_lib
   velox_exec_test_lib
@@ -20,11 +19,11 @@ target_link_libraries(
   velox_hive_connector
   Folly::folly
   Folly::follybenchmark
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 if(VELOX_ENABLE_BENCHMARKS)
-  add_executable(velox_dwio_iceberg_reader_benchmark
-                 IcebergSplitReaderBenchmarkMain.cpp)
+  add_executable(velox_dwio_iceberg_reader_benchmark IcebergSplitReaderBenchmarkMain.cpp)
   target_link_libraries(
     velox_dwio_iceberg_reader_benchmark
     velox_dwio_iceberg_reader_benchmark_lib
@@ -33,13 +32,12 @@ if(VELOX_ENABLE_BENCHMARKS)
     velox_hive_connector
     Folly::folly
     Folly::follybenchmark
-    ${TEST_LINK_LIBS})
+    ${TEST_LINK_LIBS}
+  )
 endif()
 
 if(NOT VELOX_DISABLE_GOOGLETEST)
-
-  add_executable(velox_hive_iceberg_test IcebergReadTest.cpp
-                                         IcebergSplitReaderBenchmarkTest.cpp)
+  add_executable(velox_hive_iceberg_test IcebergReadTest.cpp IcebergSplitReaderBenchmarkTest.cpp)
   add_test(velox_hive_iceberg_test velox_hive_iceberg_test)
 
   target_link_libraries(
@@ -56,6 +54,43 @@ if(NOT VELOX_DISABLE_GOOGLETEST)
     Folly::folly
     Folly::follybenchmark
     GTest::gtest
-    GTest::gtest_main)
+    GTest::gtest_main
+  )
+
+  add_executable(
+    velox_hive_iceberg_insert_test
+    IcebergConnectorTest.cpp
+    IcebergInsertTest.cpp
+    IcebergTestBase.cpp
+    Main.cpp
+    PartitionNameTest.cpp
+    PartitionSpecTest.cpp
+    PartitionValueFormatterTest.cpp
+    TransformE2ETest.cpp
+    TransformTest.cpp
+  )
+
+  add_test(velox_hive_iceberg_insert_test velox_hive_iceberg_insert_test)
+
+  target_link_libraries(
+    velox_hive_iceberg_insert_test
+    velox_exec_test_lib
+    velox_hive_connector
+    velox_hive_iceberg_splitreader
+    velox_vector_fuzzer
+    GTest::gtest
+    GTest::gtest_main
+  )
+
+  if(VELOX_ENABLE_PARQUET)
+    target_link_libraries(velox_hive_iceberg_test velox_dwio_parquet_reader)
+
+    file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
 
+    target_link_libraries(
+      velox_hive_iceberg_insert_test
+      velox_dwio_parquet_reader
+      velox_dwio_parquet_writer
+    )
+  endif()
 endif()
diff --git a/velox/connectors/hive/iceberg/tests/IcebergConnectorTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergConnectorTest.cpp
new file mode 100644
index 000000000000..3966ccd8307b
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergConnectorTest.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/connectors/hive/iceberg/IcebergConnector.h"
+#include <gtest/gtest.h>
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+class IcebergConnectorTest : public test::IcebergTestBase {
+ protected:
+  static void resetIcebergConnector(
+      const std::shared_ptr<const config::ConfigBase>& config) {
+    unregisterConnector(test::kIcebergConnectorId);
+
+    IcebergConnectorFactory factory;
+    auto icebergConnector =
+        factory.newConnector(test::kIcebergConnectorId, config);
+    registerConnector(icebergConnector);
+  }
+};
+
+TEST_F(IcebergConnectorTest, connectorConfiguration) {
+  auto customConfig = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>{
+          {hive::HiveConfig::kEnableFileHandleCache, "true"},
+          {hive::HiveConfig::kNumCacheFileHandles, "1000"}});
+
+  resetIcebergConnector(customConfig);
+
+  // Verify connector was registered successfully with custom config.
+  auto icebergConnector = getConnector(test::kIcebergConnectorId);
+  ASSERT_NE(icebergConnector, nullptr);
+
+  auto config = icebergConnector->connectorConfig();
+  ASSERT_NE(config, nullptr);
+
+  hive::HiveConfig hiveConfig(config);
+  ASSERT_TRUE(hiveConfig.isFileHandleCacheEnabled());
+  ASSERT_EQ(hiveConfig.numCacheFileHandles(), 1000);
+}
+
+TEST_F(IcebergConnectorTest, connectorProperties) {
+  auto icebergConnector = getConnector(test::kIcebergConnectorId);
+  ASSERT_NE(icebergConnector, nullptr);
+
+  ASSERT_TRUE(icebergConnector->canAddDynamicFilter());
+  ASSERT_TRUE(icebergConnector->supportsSplitPreload());
+  ASSERT_NE(icebergConnector->ioExecutor(), nullptr);
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergInsertTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergInsertTest.cpp
new file mode 100644
index 000000000000..459a1bf83f6d
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergInsertTest.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.
+ */
+
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+namespace {
+
+#ifdef VELOX_ENABLE_PARQUET
+
+class IcebergInsertTest : public test::IcebergTestBase {
+ protected:
+  void test(const RowTypePtr& rowType, double nullRatio = 0.0) {
+    const auto outputDirectory = exec::test::TempDirectoryPath::create();
+    const auto dataPath = outputDirectory->getPath();
+    constexpr int32_t numBatches = 10;
+    constexpr int32_t vectorSize = 5'000;
+    const auto vectors =
+        createTestData(rowType, numBatches, vectorSize, nullRatio);
+    const auto dataSink = createDataSinkAndAppendData(vectors, dataPath);
+    const auto commitTasks = dataSink->close();
+
+    auto splits = createSplitsForDirectory(dataPath);
+    ASSERT_EQ(splits.size(), commitTasks.size());
+    auto plan = exec::test::PlanBuilder()
+                    .startTableScan()
+                    .connectorId(test::kIcebergConnectorId)
+                    .outputType(rowType)
+                    .endTableScan()
+                    .planNode();
+    exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+  }
+};
+
+TEST_F(IcebergInsertTest, basic) {
+  auto rowType =
+      ROW({"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11"},
+          {BIGINT(),
+           INTEGER(),
+           SMALLINT(),
+           BOOLEAN(),
+           REAL(),
+           DECIMAL(18, 5),
+           VARCHAR(),
+           VARBINARY(),
+           DATE(),
+           TIMESTAMP(),
+           ROW({"id", "name"}, {INTEGER(), VARCHAR()})});
+  test(rowType, 0.2);
+}
+
+TEST_F(IcebergInsertTest, mapAndArray) {
+  auto rowType =
+      ROW({"c1", "c2"}, {MAP(INTEGER(), VARCHAR()), ARRAY(VARCHAR())});
+  test(rowType);
+}
+
+TEST_F(IcebergInsertTest, bigDecimal) {
+  auto rowType = ROW({"c1"}, {DECIMAL(38, 5)});
+  fileFormat_ = dwio::common::FileFormat::PARQUET;
+  test(rowType);
+}
+
+TEST_F(IcebergInsertTest, singleColumnPartition) {
+  struct TestCase {
+    std::string name;
+    TypePtr type;
+  };
+
+  std::vector<TestCase> testCases = {
+      {"c1", BIGINT()},
+      {"c2", INTEGER()},
+      {"c3", SMALLINT()},
+      {"c4", DECIMAL(18, 5)},
+      {"c5", BOOLEAN()},
+      {"c6", VARCHAR()},
+      {"c7", DATE()},
+      {"c8", TIMESTAMP()}};
+
+  for (const auto& testCase : testCases) {
+    const auto outputDirectory = exec::test::TempDirectoryPath::create();
+    constexpr int32_t numBatches = 2;
+    constexpr int32_t vectorSize = 50;
+    auto rowType = ROW({testCase.name}, {testCase.type});
+
+    const auto vectors = createTestData(rowType, numBatches, vectorSize, 0.5);
+    std::vector<test::PartitionField> partitionTransforms = {
+        {0, TransformType::kIdentity, std::nullopt}};
+    const auto dataSink = createDataSinkAndAppendData(
+        vectors, outputDirectory->getPath(), partitionTransforms);
+    const auto commitTasks = dataSink->close();
+    auto splits = createSplitsForDirectory(outputDirectory->getPath());
+
+    ASSERT_GT(commitTasks.size(), 0);
+    ASSERT_EQ(splits.size(), commitTasks.size());
+
+    for (const auto& task : commitTasks) {
+      auto taskJson = folly::parseJson(task);
+      ASSERT_TRUE(taskJson.count("partitionDataJson") > 0);
+    }
+
+    auto plan = exec::test::PlanBuilder()
+                    .startTableScan()
+                    .connectorId(test::kIcebergConnectorId)
+                    .outputType(rowType)
+                    .endTableScan()
+                    .planNode();
+    exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+  }
+}
+
+TEST_F(IcebergInsertTest, partitionNullColumn) {
+  struct TestCase {
+    std::string name;
+    TypePtr type;
+  };
+
+  std::vector<TestCase> testCases = {
+      {"c1", BIGINT()},
+      {"c2", INTEGER()},
+      {"c3", SMALLINT()},
+      {"c4", DECIMAL(18, 5)},
+      {"c5", BOOLEAN()},
+      {"c6", VARCHAR()},
+      {"c7", DATE()},
+      {"c8", TIMESTAMP()}};
+
+  for (const auto& testCase : testCases) {
+    const auto outputDirectory = exec::test::TempDirectoryPath::create();
+    constexpr int32_t numBatches = 2;
+    constexpr int32_t vectorSize = 100;
+    auto rowType = ROW({testCase.name}, {testCase.type});
+    // nullRatio = 1.0
+    const auto vectors = createTestData(rowType, numBatches, vectorSize, 1.0);
+
+    std::vector<test::PartitionField> partitionTransforms = {
+        {0, TransformType::kIdentity, std::nullopt}};
+    const auto dataSink = createDataSinkAndAppendData(
+        vectors, outputDirectory->getPath(), partitionTransforms);
+
+    const auto commitTasks = dataSink->close();
+    ASSERT_EQ(1, commitTasks.size());
+    auto taskJson = folly::parseJson(commitTasks.at(0));
+    ASSERT_EQ(1, taskJson.count("partitionDataJson"));
+    auto partitionData =
+        folly::parseJson(taskJson["partitionDataJson"].asString());
+    ASSERT_EQ(1, partitionData.count("partitionValues"));
+    auto partitionValues = partitionData["partitionValues"];
+    ASSERT_TRUE(partitionValues.isArray());
+    ASSERT_TRUE(partitionValues[0].isNull());
+
+    auto files = listFiles(outputDirectory->getPath());
+    ASSERT_EQ(files.size(), 1);
+
+    for (const auto& file : files) {
+      auto partitionKeys = extractPartitionKeys(file);
+      ASSERT_EQ(partitionKeys.size(), 1);
+      ASSERT_TRUE(partitionKeys.contains(testCase.name));
+      ASSERT_FALSE(partitionKeys.at(testCase.name).has_value());
+    }
+  }
+}
+
+TEST_F(IcebergInsertTest, partitionMultiColumns) {
+  auto rowType =
+      ROW({"c1", "c2", "c3", "c4"},
+          {
+              BIGINT(),
+              INTEGER(),
+              SMALLINT(),
+              DECIMAL(18, 5),
+          });
+  std::vector<std::vector<int32_t>> columnCombinations = {
+      {0, 1}, // BIGINT, INTEGER.
+      {2, 1}, // SMALLINT, INTEGER.
+      {2, 3}, // SMALLINT, DECIMAL.
+      {0, 2, 1} // BIGINT, SMALLINT, INTEGER.
+  };
+
+  for (const auto& combination : columnCombinations) {
+    const auto outputDirectory = exec::test::TempDirectoryPath::create();
+    constexpr int32_t numBatches = 2;
+    constexpr int32_t vectorSize = 50;
+
+    std::vector<RowVectorPtr> vectors;
+    vectors.reserve(numBatches);
+    for (int32_t batch = 0; batch < numBatches; ++batch) {
+      vectors.push_back(makeRowVector(
+          rowType->names(),
+          {
+              makeFlatVector<int64_t>(
+                  vectorSize, [](auto row) { return row * 100; }),
+              makeFlatVector<int32_t>(
+                  vectorSize, [](auto row) { return row * 10; }),
+              makeFlatVector<int16_t>(vectorSize, [](auto row) { return row; }),
+              makeFlatVector<int64_t>(
+                  vectorSize,
+                  [](auto row) { return (row * 1000); },
+                  nullptr,
+                  DECIMAL(18, 5)),
+          }));
+    }
+
+    std::vector<test::PartitionField> partitionTransforms;
+    for (auto colIndex : combination) {
+      partitionTransforms.push_back(
+          {colIndex, TransformType::kIdentity, std::nullopt});
+    }
+
+    const auto dataSink = createDataSinkAndAppendData(
+        vectors, outputDirectory->getPath(), partitionTransforms);
+
+    const auto commitTasks = dataSink->close();
+    auto splits = createSplitsForDirectory(outputDirectory->getPath());
+
+    ASSERT_EQ(commitTasks.size(), vectorSize);
+    ASSERT_EQ(splits.size(), commitTasks.size());
+
+    auto plan = exec::test::PlanBuilder()
+                    .startTableScan()
+                    .connectorId(test::kIcebergConnectorId)
+                    .outputType(rowType)
+                    .endTableScan()
+                    .planNode();
+    exec::test::AssertQueryBuilder(plan).splits(splits).assertResults(vectors);
+  }
+}
+#endif
+
+} // namespace
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp b/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp
index 5ed64da321f2..34e87fc25257 100644
--- a/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp
+++ b/velox/connectors/hive/iceberg/tests/IcebergReadTest.cpp
@@ -14,17 +14,22 @@
  * limitations under the License.
  */
 
+#include <folly/Singleton.h>
 #include "velox/common/base/tests/GTestUtils.h"
 #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/dwio/common/tests/utils/DataFiles.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/PlanBuilder.h"
 
-#include <folly/Singleton.h>
+#ifdef VELOX_ENABLE_PARQUET
+#include "velox/dwio/parquet/RegisterParquetReader.h"
+#endif
 
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::exec;
@@ -35,6 +40,13 @@ namespace facebook::velox::connector::hive::iceberg {
 
 class HiveIcebergTest : public HiveConnectorTestBase {
  public:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+#ifdef VELOX_ENABLE_PARQUET
+    parquet::registerParquetReaderFactory();
+#endif
+  }
+
   HiveIcebergTest()
       : config_{std::make_shared<facebook::velox::dwrf::Config>()} {
     // Make the writers flush per batch so that we can create non-aligned
@@ -144,7 +156,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     return values;
   }
 
-  std::vector<int64_t> makeContinuousIncreasingValues(
+  static std::vector<int64_t> makeContinuousIncreasingValues(
       int64_t begin,
       int64_t end) {
     std::vector<int64_t> values;
@@ -223,13 +235,13 @@ class HiveIcebergTest : public HiveConnectorTestBase {
 
     std::string duckdbSql =
         getDuckDBQuery(rowGroupSizesForFiles, deleteFilesForBaseDatafiles);
-    auto plan = tableScanNode();
+    auto plan = PlanBuilder().tableScan(ROW({"c0"}, {BIGINT()})).planNode();
     auto task = HiveConnectorTestBase::assertQuery(
         plan, splits, duckdbSql, numPrefetchSplits);
 
     auto planStats = toPlanStats(task->taskStats());
-    auto scanNodeId = plan->id();
-    auto it = planStats.find(scanNodeId);
+
+    auto it = planStats.find(plan->id());
     ASSERT_TRUE(it != planStats.end());
     ASSERT_TRUE(it->second.peakMemoryBytes > 0);
   }
@@ -252,27 +264,100 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     auto file = filesystems::getFileSystem(dataFilePath, nullptr)
                     ->openFileForRead(dataFilePath);
     const int64_t fileSize = file->size();
-    std::vector<std::shared_ptr<ConnectorSplit>> splits;
     const uint64_t splitSize = std::floor((fileSize) / splitCount);
 
+    std::vector<std::shared_ptr<ConnectorSplit>> splits;
+    splits.reserve(splitCount);
+
     for (int i = 0; i < splitCount; ++i) {
-      splits.emplace_back(std::make_shared<HiveIcebergSplit>(
-          kHiveConnectorId,
-          dataFilePath,
-          fileFomat_,
-          i * splitSize,
-          splitSize,
-          partitionKeys,
-          std::nullopt,
-          customSplitInfo,
-          nullptr,
-          /*cacheable=*/true,
-          deleteFiles));
+      splits.emplace_back(
+          std::make_shared<HiveIcebergSplit>(
+              kHiveConnectorId,
+              dataFilePath,
+              fileFomat_,
+              i * splitSize,
+              splitSize,
+              partitionKeys,
+              std::nullopt,
+              customSplitInfo,
+              nullptr,
+              /*cacheable=*/true,
+              deleteFiles));
     }
 
     return splits;
   }
 
+  ColumnHandleMap makeColumnHandles(
+      const RowTypePtr& rowType,
+      const std::unordered_set<int>& partitionIndices = {}) {
+    ColumnHandleMap assignments;
+    for (auto i = 0; i < rowType->size(); ++i) {
+      const auto& columnName = rowType->nameOf(i);
+      const auto& columnType = rowType->childAt(i);
+      auto columnHandleType = partitionIndices.contains(i)
+          ? HiveColumnHandle::ColumnType::kPartitionKey
+          : HiveColumnHandle::ColumnType::kRegular;
+
+      assignments.insert(
+          {columnName,
+           std::make_shared<HiveColumnHandle>(
+               columnName,
+               columnHandleType,
+               columnType,
+               columnType,
+               std::vector<common::Subfield>{})});
+    }
+
+    return assignments;
+  }
+
+#ifdef VELOX_ENABLE_PARQUET
+  std::vector<std::shared_ptr<ConnectorSplit>> createParquetDeleteFileAndSplits(
+      const std::string& path,
+      const std::vector<int64_t>& deletePositionsVec,
+      int32_t deletedPositionSize,
+      const std::shared_ptr<TempFilePath>& deleteFilePath) {
+    writeToFile(
+        deleteFilePath->getPath(),
+        {makeRowVector(
+            {pathColumn_->name, posColumn_->name},
+            {
+                makeFlatVector<std::string>(
+                    static_cast<vector_size_t>(deletedPositionSize),
+                    [&](vector_size_t) { return path; }),
+                makeFlatVector<int64_t>(deletePositionsVec),
+            })});
+
+    IcebergDeleteFile icebergDeleteFile(
+        FileContent::kPositionalDeletes,
+        deleteFilePath->getPath(),
+        fileFomat_,
+        deletedPositionSize,
+        testing::internal::GetFileSize(
+            std::fopen(deleteFilePath->getPath().c_str(), "r")));
+    auto fileSize = filesystems::getFileSystem(path, nullptr)
+                        ->openFileForRead(path)
+                        ->size();
+
+    std::unordered_map<std::string, std::string> customSplitInfo{
+        {"table_format", "hive-iceberg"}};
+    std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+    return {std::make_shared<HiveIcebergSplit>(
+        kHiveConnectorId,
+        path,
+        dwio::common::FileFormat::PARQUET,
+        0,
+        fileSize,
+        partitionKeys,
+        std::nullopt,
+        customSplitInfo,
+        nullptr,
+        /*cacheable=*/true,
+        std::vector<IcebergDeleteFile>{icebergDeleteFile})};
+  }
+#endif
+
  private:
   std::map<std::string, std::shared_ptr<TempFilePath>> writeDataFiles(
       std::map<std::string, std::vector<int64_t>> rowGroupSizesForFiles) {
@@ -289,11 +374,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
       // 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_);
+      writeToFile(dataFilePaths[dataFile.first]->getPath(), dataVectors);
 
       for (int i = 0; i < dataVectors.size(); i++) {
         dataVectorsJoined.push_back(dataVectors[i]);
@@ -350,11 +431,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
         totalPositionsInDeleteFile += positionsInRowGroup.size();
       }
 
-      writeToFile(
-          deleteFilePath->getPath(),
-          deleteFileVectors,
-          config_,
-          flushPolicyFactory_);
+      writeToFile(deleteFilePath->getPath(), deleteFileVectors);
 
       deleteFilePaths[deleteFileName] =
           std::make_pair(totalPositionsInDeleteFile, deleteFilePath);
@@ -373,8 +450,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     for (int j = 0; j < vectorSizes.size(); j++) {
       auto data = makeContinuousIncreasingValues(
           startingValue, startingValue + vectorSizes[j]);
-      VectorPtr c0 = makeFlatVector<int64_t>(data);
-      vectors.push_back(makeRowVector({"c0"}, {c0}));
+      vectors.push_back(makeRowVector({makeFlatVector<int64_t>(data)}));
       startingValue += vectorSizes[j];
     }
 
@@ -401,9 +477,9 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     // Group the delete vectors by baseFileName
     std::map<std::string, std::vector<std::vector<int64_t>>>
         deletePosVectorsForAllBaseFiles;
-    for (auto deleteFile : deleteFilesForBaseDatafiles) {
+    for (auto& deleteFile : deleteFilesForBaseDatafiles) {
       auto deleteFileContent = deleteFile.second;
-      for (auto rowGroup : deleteFileContent) {
+      for (auto& rowGroup : deleteFileContent) {
         auto baseFileName = rowGroup.first;
         deletePosVectorsForAllBaseFiles[baseFileName].push_back(
             rowGroup.second);
@@ -416,7 +492,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     std::map<std::string, std::vector<int64_t>>
         flattenedDeletePosVectorsForAllBaseFiles;
     int64_t totalNumDeletePositions = 0;
-    for (auto deleteVectorsForBaseFile : deletePosVectorsForAllBaseFiles) {
+    for (auto& deleteVectorsForBaseFile : deletePosVectorsForAllBaseFiles) {
       auto baseFileName = deleteVectorsForBaseFile.first;
       auto deletePositionVectors = deleteVectorsForBaseFile.second;
       std::vector<int64_t> deletePositionVector =
@@ -429,14 +505,18 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     // Now build the DuckDB queries
     if (totalNumDeletePositions == 0) {
       return "SELECT * FROM tmp";
-    } else if (totalNumDeletePositions >= totalNumRowsInAllBaseFiles) {
+    }
+
+    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) {
+      for (auto& baseFileSize : baseFileSizes) {
         auto deletePositions =
             flattenedDeletePosVectorsForAllBaseFiles[baseFileSize.first];
 
@@ -456,7 +536,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
 
       return fmt::format(
           "SELECT * FROM tmp WHERE c0 NOT IN ({})",
-          makeNotInList(allDeleteValues));
+          folly::join(", ", allDeleteValues));
     }
   }
 
@@ -464,7 +544,7 @@ class HiveIcebergTest : public HiveConnectorTestBase {
       const std::vector<std::vector<int64_t>>& deletePositionVectors,
       int64_t baseFileSize) {
     std::vector<int64_t> deletePositionVector;
-    for (auto vec : deletePositionVectors) {
+    for (auto& vec : deletePositionVectors) {
       for (auto pos : vec) {
         if (pos >= 0 && pos < baseFileSize) {
           deletePositionVector.push_back(pos);
@@ -480,29 +560,11 @@ class HiveIcebergTest : public HiveConnectorTestBase {
     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};
 
-  RowTypePtr rowType_{ROW({"c0"}, {BIGINT()})};
   std::shared_ptr<IcebergMetadataColumn> pathColumn_ =
       IcebergMetadataColumn::icebergDeleteFilePathColumn();
+
   std::shared_ptr<IcebergMetadataColumn> posColumn_ =
       IcebergMetadataColumn::icebergDeletePosColumn();
 };
@@ -532,7 +594,7 @@ TEST_F(HiveIcebergTest, singleBaseFileSinglePositionalDeleteFile) {
 /// delete positions. The parameter passed to
 /// assertSingleBaseFileSingleDeleteFile is the delete positions.for the middle
 /// base file.
-TEST_F(HiveIcebergTest, MultipleBaseFilesSinglePositionalDeleteFile) {
+TEST_F(HiveIcebergTest, multipleBaseFilesSinglePositionalDeleteFile) {
   folly::SingletonVault::singleton()->registrationComplete();
 
   assertMultipleBaseFileSingleDeleteFile({0, 1, 2, 3});
@@ -695,7 +757,7 @@ TEST_F(HiveIcebergTest, positionalDeletesMultipleSplits) {
   assertMultipleSplits({1000, 9000, 20000}, 1, 0, 20000, 3);
 }
 
-TEST_F(HiveIcebergTest, testPartitionedRead) {
+TEST_F(HiveIcebergTest, partitionedRead) {
   RowTypePtr rowType{ROW({"c0", "ds"}, {BIGINT(), DateType::get()})};
   std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
   // Iceberg API sets partition values for dates to daysSinceEpoch, so
@@ -713,43 +775,19 @@ TEST_F(HiveIcebergTest, testPartitionedRead) {
 
     auto dataFilePath = TempFilePath::create();
     dataFilePaths.push_back(dataFilePath);
-    writeToFile(
-        dataFilePath->getPath(), dataVectors, config_, flushPolicyFactory_);
+    writeToFile(dataFilePath->getPath(), dataVectors);
     partitionKeys["ds"] = std::to_string(daysSinceEpoch);
     auto icebergSplits =
         makeIcebergSplits(dataFilePath->getPath(), {}, partitionKeys);
     splits.insert(splits.end(), icebergSplits.begin(), icebergSplits.end());
   }
 
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
-  assignments.insert(
-      {"c0",
-       std::make_shared<HiveColumnHandle>(
-           "c0",
-           HiveColumnHandle::ColumnType::kRegular,
-           rowType->childAt(0),
-           rowType->childAt(0))});
-
-  std::vector<common::Subfield> requiredSubFields;
-  HiveColumnHandle::ColumnParseParameters columnParseParameters;
-  columnParseParameters.partitionDateValueFormat =
-      HiveColumnHandle::ColumnParseParameters::kDaysSinceEpoch;
-  assignments.insert(
-      {"ds",
-       std::make_shared<HiveColumnHandle>(
-           "ds",
-           HiveColumnHandle::ColumnType::kPartitionKey,
-           rowType->childAt(1),
-           rowType->childAt(1),
-           std::move(requiredSubFields),
-           columnParseParameters)});
-
-  auto plan = PlanBuilder(pool_.get())
-                  .tableScan(rowType, {}, "", nullptr, assignments)
-                  .planNode();
+  auto assignments = makeColumnHandles(rowType, {1});
 
-  HiveConnectorTestBase::assertQuery(
+  auto plan =
+      PlanBuilder().tableScan(rowType, {}, "", nullptr, assignments).planNode();
+
+  assertQuery(
       plan,
       splits,
       "SELECT * FROM (VALUES (0, '2018-04-06'), (1, '2018-04-07'))",
@@ -757,11 +795,11 @@ TEST_F(HiveIcebergTest, testPartitionedRead) {
 
   // Test filter on non-partitioned non-date column
   std::vector<std::string> nonPartitionFilters = {"c0 = 1"};
-  plan = PlanBuilder(pool_.get())
+  plan = PlanBuilder()
              .tableScan(rowType, nonPartitionFilters, "", nullptr, assignments)
              .planNode();
 
-  HiveConnectorTestBase::assertQuery(plan, splits, "SELECT 1, '2018-04-07'");
+  assertQuery(plan, splits, "SELECT 1, '2018-04-07'");
 
   // Test filter on non-partitioned date column
   std::vector<std::string> filters = {"ds = date'2018-04-06'"};
@@ -773,6 +811,140 @@ TEST_F(HiveIcebergTest, testPartitionedRead) {
     splits.insert(splits.end(), icebergSplits.begin(), icebergSplits.end());
   }
 
-  HiveConnectorTestBase::assertQuery(plan, splits, "SELECT 0, '2018-04-06'");
+  assertQuery(plan, splits, "SELECT 0, '2018-04-06'");
+}
+
+TEST_F(HiveIcebergTest, schemaEvolutionRemoveColumn) {
+  auto oldRowType = ROW({"c0", "c1", "c2"}, {BIGINT(), INTEGER(), VARCHAR()});
+  auto newRowType = ROW({"c0", "c2"}, {BIGINT(), VARCHAR()});
+
+  // Write data file with old schema (c0, c1, c2).
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector(
+      oldRowType->names(),
+      {
+          makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+          makeFlatVector<int32_t>({10, 20, 30, 40, 50}),
+          makeFlatVector<std::string>({"a", "b", "c", "d", "e"}),
+      }));
+
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(dataFilePath->getPath(), dataVectors);
+
+  auto icebergSplits = makeIcebergSplits(dataFilePath->getPath());
+
+  // Expected result: c0 and c2 have values, c1 is not present.
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      newRowType->names(),
+      {
+          dataVectors[0]->childAt(0),
+          dataVectors[0]->childAt(2),
+      }));
+
+  // Read with new schema (c0 and c2 only, c1 removed).
+  auto plan = PlanBuilder().tableScan(newRowType).planNode();
+  AssertQueryBuilder(plan).splits(icebergSplits).assertResults(expectedVectors);
+}
+
+TEST_F(HiveIcebergTest, schemaEvolutionAddColumns) {
+  auto oldRowType = ROW({"c0"}, {BIGINT()});
+  auto newRowType = ROW({"c0", "c1", "c2"}, {BIGINT(), INTEGER(), VARCHAR()});
+
+  // Write data file with old schema (only c0).
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({
+      makeFlatVector<int64_t>({100, 200, 300}),
+  }));
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(dataFilePath->getPath(), dataVectors);
+  auto icebergSplits = makeIcebergSplits(dataFilePath->getPath());
+
+  // Expected result: c0 has values, c1 and c2 are NULL.
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector({
+      dataVectors[0]->childAt(0),
+      makeNullConstant(TypeKind::INTEGER, 3),
+      makeNullConstant(TypeKind::VARCHAR, 3),
+  }));
+
+  // Read with new schema (c0, c1, and c2).
+  auto plan =
+      PlanBuilder().tableScan(newRowType, {}, "", newRowType).planNode();
+  AssertQueryBuilder(plan).splits(icebergSplits).assertResults(expectedVectors);
+}
+
+// Test reading partition columns from Hive-migrated tables.
+// This tests the adaptColumns method handling partition columns that are not
+// stored in the data file but provided via partitionKeys map.
+// This scenario occurs when reading Hive-written data files where partition
+// column values are stored in partition metadata rather than in the data file.
+TEST_F(HiveIcebergTest, partitionColumnsFromHive) {
+  auto fileRowType = ROW({"c0", "c1"}, {BIGINT(), INTEGER()});
+  auto tableRowType =
+      ROW({"c0", "c1", "region", "year"},
+          {BIGINT(), INTEGER(), VARCHAR(), INTEGER()});
+
+  // Write data file with only non-partition columns (c0, c1).
+  std::vector<RowVectorPtr> dataVectors;
+  dataVectors.push_back(makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({10, 20, 30}),
+  }));
+  auto dataFilePath = TempFilePath::create();
+  writeToFile(dataFilePath->getPath(), dataVectors);
+
+  // Set partition keys for region and year.
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+  partitionKeys["region"] = "US";
+  partitionKeys["year"] = "2025";
+
+  auto icebergSplits =
+      makeIcebergSplits(dataFilePath->getPath(), {}, partitionKeys);
+  auto assignments = makeColumnHandles(tableRowType, {2, 3});
+
+  // Expected result: c0 and c1 from file, region and year from partition keys.
+  std::vector<RowVectorPtr> expectedVectors;
+  expectedVectors.push_back(makeRowVector(
+      tableRowType->names(),
+      {
+          dataVectors[0]->childAt(0),
+          dataVectors[0]->childAt(1),
+          makeFlatVector<std::string>({"US", "US", "US"}),
+          makeFlatVector<int32_t>({2025, 2025, 2025}),
+      }));
+
+  // Read with table schema including partition columns.
+  auto plan = PlanBuilder()
+                  .tableScan(tableRowType, {}, "", tableRowType, assignments)
+                  .planNode();
+  AssertQueryBuilder(plan).splits(icebergSplits).assertResults(expectedVectors);
+}
+
+#ifdef VELOX_ENABLE_PARQUET
+TEST_F(HiveIcebergTest, positionalDeleteFileWithRowGroupFilter) {
+  // This file contains three row groups, each with about 100 rows.
+  // Each row group has min/max values: [200, 299], [0, 99], [100, 199].
+  // The filter here is id >= 100, which will cause the parquet reader to filter
+  // out the middle row group ([0, 99]). This can lead to a mismatch between the
+  // baseReadOffset tracked by Iceberg's split reader and the actual offset,
+  // resulting in records in the position delete file being mapped to incorrect
+  // rows.
+  auto path = test::getDataFilePath(
+      "velox/connectors/hive/iceberg/test", "examples/three_groups.parquet");
+  const auto deletedPositionSize = 100;
+  std::vector<int64_t> deletePositionsVec(
+      deletedPositionSize); // allocate 100 elements, [100, 199].
+  std::iota(deletePositionsVec.begin(), deletePositionsVec.end(), 100);
+  auto deleteFilePath = TempFilePath::create();
+  HiveConnectorTestBase::assertQuery(
+      PlanBuilder()
+          .tableScan(ROW({"id"}, {BIGINT()}), {"id >= 100"})
+          .planNode(),
+      createParquetDeleteFileAndSplits(
+          path, deletePositionsVec, deletedPositionSize, deleteFilePath),
+      "SELECT i AS id FROM range(100, 300) AS t(i)",
+      0);
 }
+#endif
 } // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp
index bc9d2b4ad266..2c2c26297fd2 100644
--- a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp
+++ b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.cpp
@@ -215,7 +215,7 @@ std::shared_ptr<ScanSpec> IcebergSplitReaderBenchmark::createScanSpec(
     RowTypePtr& rowType,
     const std::vector<FilterSpec>& filterSpecs,
     std::vector<uint64_t>& hitRows,
-    std::unordered_map<Subfield, std::unique_ptr<Filter>>& filters) {
+    SubfieldFilters& filters) {
   std::unique_ptr<FilterGenerator> filterGenerator =
       std::make_unique<FilterGenerator>(rowType, 0);
   filters = filterGenerator->makeSubfieldFilters(
@@ -271,7 +271,7 @@ void IcebergSplitReaderBenchmark::readSingleColumn(
       createFilterSpec(columnName, startPct, selectPct, rowType, false, false));
 
   std::vector<uint64_t> hitRows;
-  std::unordered_map<Subfield, std::unique_ptr<Filter>> filters;
+  SubfieldFilters filters;
   auto scanSpec =
       createScanSpec(*batches, rowType, filterSpecs, hitRows, filters);
 
@@ -324,7 +324,7 @@ void IcebergSplitReaderBenchmark::readSingleColumn(
           "");
 
   FileHandleFactory fileHandleFactory(
-      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(
+      std::make_unique<SimpleLRUCache<FileHandleKey, FileHandle>>(
           hiveConfig->numCacheFileHandles()),
       std::make_unique<FileHandleGenerator>(connectorSessionProperties_));
 
diff --git a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h
index 9b6d5df9bf61..3408fa4ce837 100644
--- a/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h
+++ b/velox/connectors/hive/iceberg/tests/IcebergSplitReaderBenchmark.h
@@ -70,9 +70,7 @@ class IcebergSplitReaderBenchmark {
       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);
+      common::SubfieldFilters& filters);
 
   int read(
       const RowTypePtr& rowType,
diff --git a/velox/connectors/hive/iceberg/tests/IcebergTestBase.cpp b/velox/connectors/hive/iceberg/tests/IcebergTestBase.cpp
new file mode 100644
index 000000000000..bc8c34e761a4
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergTestBase.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 "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+#include <filesystem>
+#include "velox/connectors/hive/iceberg/IcebergConnector.h"
+#include "velox/connectors/hive/iceberg/IcebergSplit.h"
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::connector::hive::iceberg::test {
+
+const std::string kIcebergConnectorId{"test-iceberg"};
+
+void IcebergTestBase::SetUp() {
+  HiveConnectorTestBase::SetUp();
+#ifdef VELOX_ENABLE_PARQUET
+  parquet::registerParquetReaderFactory();
+  parquet::registerParquetWriterFactory();
+#endif
+  Type::registerSerDe();
+
+  // Register IcebergConnector.
+  IcebergConnectorFactory icebergFactory;
+  auto icebergConnector = icebergFactory.newConnector(
+      kIcebergConnectorId,
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()),
+      ioExecutor_.get());
+  registerConnector(icebergConnector);
+
+  connectorSessionProperties_ = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(), true);
+
+  connectorConfig_ =
+      std::make_shared<HiveConfig>(std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+
+  setupMemoryPools();
+
+  fuzzerOptions_.vectorSize = 100;
+  fuzzerOptions_.nullRatio = 0.1;
+  fuzzer_ = std::make_unique<VectorFuzzer>(fuzzerOptions_, opPool_.get(), 1);
+}
+
+void IcebergTestBase::TearDown() {
+  fuzzer_.reset();
+  connectorQueryCtx_.reset();
+  connectorPool_.reset();
+  opPool_.reset();
+  root_.reset();
+  queryCtx_.reset();
+  unregisterConnector(kIcebergConnectorId);
+  HiveConnectorTestBase::TearDown();
+}
+
+void IcebergTestBase::setupMemoryPools() {
+  root_.reset();
+  opPool_.reset();
+  connectorPool_.reset();
+  connectorQueryCtx_.reset();
+  queryCtx_.reset();
+
+  root_ = memory::memoryManager()->addRootPool(
+      "IcebergTest", 1L << 30, exec::MemoryReclaimer::create());
+  opPool_ = root_->addLeafChild("operator");
+  connectorPool_ =
+      root_->addAggregateChild("connector", exec::MemoryReclaimer::create());
+
+  queryCtx_ = core::QueryCtx::create(nullptr, core::QueryConfig({}));
+  auto expressionEvaluator = std::make_unique<exec::SimpleExpressionEvaluator>(
+      queryCtx_.get(), opPool_.get());
+
+  connectorQueryCtx_ = std::make_unique<ConnectorQueryCtx>(
+      opPool_.get(),
+      connectorPool_.get(),
+      connectorSessionProperties_.get(),
+      nullptr,
+      common::PrefixSortConfig(),
+      std::move(expressionEvaluator),
+      nullptr,
+      "query.IcebergTest",
+      "task.IcebergTest",
+      "planNodeId.IcebergTest",
+      0,
+      "");
+}
+
+std::vector<RowVectorPtr> IcebergTestBase::createTestData(
+    RowTypePtr rowType,
+    int32_t numBatches,
+    vector_size_t rowsPerBatch,
+    double nullRatio) {
+  std::vector<RowVectorPtr> vectors;
+  vectors.reserve(numBatches);
+
+  fuzzerOptions_.nullRatio = nullRatio;
+  fuzzerOptions_.allowDictionaryVector = false;
+  fuzzerOptions_.timestampPrecision =
+      fuzzer::FuzzerTimestampPrecision::kMilliSeconds;
+  fuzzer_->setOptions(fuzzerOptions_);
+
+  for (auto i = 0; i < numBatches; ++i) {
+    vectors.push_back(fuzzer_->fuzzRow(rowType, rowsPerBatch, false));
+  }
+
+  return vectors;
+}
+
+std::shared_ptr<IcebergPartitionSpec> IcebergTestBase::createPartitionSpec(
+    const RowTypePtr& rowType,
+    const std::vector<PartitionField>& partitionFields) {
+  std::vector<IcebergPartitionSpec::Field> fields;
+  for (const auto& partitionField : partitionFields) {
+    fields.push_back(
+        IcebergPartitionSpec::Field{
+            rowType->nameOf(partitionField.id),
+            rowType->childAt(partitionField.id),
+            partitionField.type,
+            partitionField.parameter});
+  }
+
+  return fields.empty() ? nullptr
+                        : std::make_shared<IcebergPartitionSpec>(1, fields);
+}
+
+void addColumnHandles(
+    const RowTypePtr& rowType,
+    const std::vector<PartitionField>& partitionFields,
+    std::vector<HiveColumnHandlePtr>& columnHandles) {
+  std::unordered_set<int32_t> partitionColumnIds;
+  for (const auto& field : partitionFields) {
+    partitionColumnIds.insert(field.id);
+  }
+
+  columnHandles.reserve(rowType->size());
+  for (auto i = 0; i < rowType->size(); ++i) {
+    const auto columnType = partitionColumnIds.contains(i)
+        ? HiveColumnHandle::ColumnType::kPartitionKey
+        : HiveColumnHandle::ColumnType::kRegular;
+
+    columnHandles.push_back(
+        std::make_shared<HiveColumnHandle>(
+            rowType->nameOf(i),
+            columnType,
+            rowType->childAt(i),
+            rowType->childAt(i)));
+  }
+}
+
+IcebergInsertTableHandlePtr IcebergTestBase::createInsertTableHandle(
+    const RowTypePtr& rowType,
+    const std::string& outputDirectoryPath,
+    const std::vector<PartitionField>& partitionFields) {
+  std::vector<HiveColumnHandlePtr> columnHandles;
+  addColumnHandles(rowType, partitionFields, columnHandles);
+
+  auto locationHandle = std::make_shared<LocationHandle>(
+      outputDirectoryPath,
+      outputDirectoryPath,
+      LocationHandle::TableType::kNew);
+
+  auto partitionSpec = createPartitionSpec(rowType, partitionFields);
+
+  return std::make_shared<const IcebergInsertTableHandle>(
+      /*inputColumns=*/columnHandles,
+      locationHandle,
+      /*tableStorageFormat=*/fileFormat_,
+      partitionSpec,
+      /*compressionKind=*/common::CompressionKind::CompressionKind_ZSTD);
+}
+
+std::shared_ptr<IcebergDataSink> IcebergTestBase::createDataSink(
+    const RowTypePtr& rowType,
+    const std::string& outputDirectoryPath,
+    const std::vector<PartitionField>& partitionFields) {
+  auto tableHandle =
+      createInsertTableHandle(rowType, outputDirectoryPath, partitionFields);
+  return std::make_shared<IcebergDataSink>(
+      rowType,
+      tableHandle,
+      connectorQueryCtx_.get(),
+      CommitStrategy::kNoCommit,
+      connectorConfig_,
+      std::string(kDefaultIcebergFunctionPrefix));
+}
+
+std::shared_ptr<IcebergDataSink> IcebergTestBase::createDataSinkAndAppendData(
+    const std::vector<RowVectorPtr>& vectors,
+    const std::string& dataPath,
+    const std::vector<PartitionField>& partitionFields) {
+  VELOX_CHECK(!vectors.empty(), "vectors cannot be empty");
+
+  auto rowType = vectors.front()->rowType();
+  auto dataSink = createDataSink(rowType, dataPath, partitionFields);
+
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+  EXPECT_TRUE(dataSink->finish());
+  return dataSink;
+}
+
+std::vector<std::string> IcebergTestBase::listFiles(
+    const std::string& dirPath) {
+  std::vector<std::string> files;
+  if (!std::filesystem::exists(dirPath)) {
+    return files;
+  }
+
+  for (auto& dirEntry :
+       std::filesystem::recursive_directory_iterator(dirPath)) {
+    if (dirEntry.is_regular_file()) {
+      files.push_back(dirEntry.path().string());
+    }
+  }
+  return files;
+}
+
+std::unordered_map<std::string, std::optional<std::string>>
+IcebergTestBase::extractPartitionKeys(const std::string& filePath) {
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+
+  std::vector<std::string> pathComponents;
+  folly::split("/", filePath, pathComponents);
+  for (const auto& component : pathComponents) {
+    if (component.find('=') != std::string::npos) {
+      std::vector<std::string> keys;
+      folly::split('=', component, keys);
+      if (keys.size() == 2) {
+        if (keys[1] == "null") {
+          partitionKeys[keys[0]] = std::nullopt;
+        } else {
+          partitionKeys[keys[0]] = keys[1];
+        }
+      }
+    }
+  }
+
+  return partitionKeys;
+}
+
+std::vector<std::shared_ptr<ConnectorSplit>>
+IcebergTestBase::createSplitsForDirectory(const std::string& directory) {
+  std::vector<std::shared_ptr<ConnectorSplit>> splits;
+  std::unordered_map<std::string, std::string> customSplitInfo;
+  customSplitInfo["table_format"] = "hive-iceberg";
+
+  auto files = listFiles(directory);
+  for (const auto& filePath : files) {
+    auto partitionKeys = extractPartitionKeys(filePath);
+
+    const auto file = filesystems::getFileSystem(filePath, nullptr)
+                          ->openFileForRead(filePath);
+    splits.push_back(
+        std::make_shared<HiveIcebergSplit>(
+            kIcebergConnectorId,
+            filePath,
+            fileFormat_,
+            0,
+            file->size(),
+            partitionKeys,
+            std::nullopt,
+            customSplitInfo,
+            nullptr,
+            /*cacheable=*/true,
+            std::vector<IcebergDeleteFile>()));
+  }
+
+  return splits;
+}
+
+} // namespace facebook::velox::connector::hive::iceberg::test
diff --git a/velox/connectors/hive/iceberg/tests/IcebergTestBase.h b/velox/connectors/hive/iceberg/tests/IcebergTestBase.h
new file mode 100644
index 000000000000..c9dd8cacdc34
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/IcebergTestBase.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 <gtest/gtest.h>
+
+#include "velox/connectors/hive/iceberg/IcebergDataSink.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#ifdef VELOX_ENABLE_PARQUET
+#include "velox/dwio/parquet/RegisterParquetWriter.h"
+#include "velox/dwio/parquet/reader/ParquetReader.h"
+#endif
+
+namespace facebook::velox::connector::hive::iceberg::test {
+
+extern const std::string kIcebergConnectorId;
+
+struct PartitionField {
+  // 0-based column index.
+  int32_t id;
+  TransformType type;
+  std::optional<int32_t> parameter;
+};
+
+class IcebergTestBase : public exec::test::HiveConnectorTestBase {
+ protected:
+  void SetUp() override;
+
+  void TearDown() override;
+
+  std::vector<RowVectorPtr> createTestData(
+      RowTypePtr rowType,
+      int32_t numBatches,
+      vector_size_t rowsPerBatch,
+      double nullRatio = 0.0);
+
+  std::shared_ptr<IcebergDataSink> createDataSink(
+      const RowTypePtr& rowType,
+      const std::string& outputDirectoryPath,
+      const std::vector<PartitionField>& partitionFields = {});
+
+  std::shared_ptr<IcebergDataSink> createDataSinkAndAppendData(
+      const std::vector<RowVectorPtr>& vectors,
+      const std::string& dataPath,
+      const std::vector<PartitionField>& partitionFields = {});
+
+  std::vector<std::shared_ptr<ConnectorSplit>> createSplitsForDirectory(
+      const std::string& directory);
+
+  std::vector<std::string> listFiles(const std::string& dirPath);
+
+  std::shared_ptr<IcebergPartitionSpec> createPartitionSpec(
+      const RowTypePtr& rowType,
+      const std::vector<PartitionField>& partitionFields);
+
+  /// Extracts partition key-value pairs from a file path.
+  /// Returns a map where keys are partition column names and values are
+  /// partition values (std::nullopt for null values).
+  /// Example: "/path/to/c1=10/c2=null/file.parquet" returns
+  /// {{"c1", "10"}, {"c2", std::nullopt}}.
+  static std::unordered_map<std::string, std::optional<std::string>>
+  extractPartitionKeys(const std::string& filePath);
+
+  dwio::common::FileFormat fileFormat_{dwio::common::FileFormat::PARQUET};
+  std::shared_ptr<memory::MemoryPool> opPool_;
+  std::unique_ptr<ConnectorQueryCtx> connectorQueryCtx_;
+
+ private:
+  IcebergInsertTableHandlePtr createInsertTableHandle(
+      const RowTypePtr& rowType,
+      const std::string& outputDirectoryPath,
+      const std::vector<PartitionField>& partitionFields = {});
+
+  std::vector<std::string> listPartitionDirectories(
+      const std::string& dataPath);
+
+  void setupMemoryPools();
+
+  std::shared_ptr<memory::MemoryPool> root_;
+  std::shared_ptr<memory::MemoryPool> connectorPool_;
+  std::shared_ptr<config::ConfigBase> connectorSessionProperties_;
+  std::shared_ptr<HiveConfig> connectorConfig_;
+  VectorFuzzer::Options fuzzerOptions_;
+  std::unique_ptr<VectorFuzzer> fuzzer_;
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+};
+
+} // namespace facebook::velox::connector::hive::iceberg::test
diff --git a/velox/connectors/hive/iceberg/tests/Main.cpp b/velox/connectors/hive/iceberg/tests/Main.cpp
new file mode 100644
index 000000000000..3c9dd6615055
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/Main.cpp
@@ -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.
+ */
+
+#include "velox/common/process/ThreadDebugInfo.h"
+
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+// 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/connectors/hive/iceberg/tests/PartitionNameTest.cpp b/velox/connectors/hive/iceberg/tests/PartitionNameTest.cpp
new file mode 100644
index 000000000000..30b74fb5ad6f
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/PartitionNameTest.cpp
@@ -0,0 +1,482 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/IcebergConnector.h"
+
+#include <numeric>
+
+#include "velox/common/encode/Base64.h"
+#include "velox/connectors/hive/iceberg/IcebergPartitionName.h"
+#include "velox/connectors/hive/iceberg/TransformEvaluator.h"
+#include "velox/connectors/hive/iceberg/TransformExprBuilder.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+using namespace facebook::velox;
+
+namespace {
+
+class PartitionNameTest : public test::IcebergTestBase {
+ protected:
+  // Generates partition IDs for the input rows and verifies that the resulting
+  // partition paths match the expected paths. Each row is processed
+  // independently, and its generated partition path is compared against the
+  // corresponding entry in expectedPaths.
+  //
+  // @param input Input data to generate partition IDs from. Must have the
+  // same size as expectedPaths.
+  // @param partitionSpec The IcebergPartitionSpec defining the partition
+  // transforms. The partition channels are determined by matching field names
+  // from the spec to column names in the input's type.
+  // @param expectedPaths Expected partition path strings, one per row. Each
+  // path should be the complete partition directory name (e.g., "col1=val1").
+  void verifyPartitionPaths(
+      const RowVectorPtr& input,
+      const std::shared_ptr<IcebergPartitionSpec>& partitionSpec,
+      const std::vector<std::string>& expectedPaths) const {
+    ASSERT_EQ(expectedPaths.size(), input->size());
+    std::vector<column_index_t> partitionChannels(partitionSpec->fields.size());
+    auto rowType = input->rowType();
+    for (auto i = 0; i < partitionSpec->fields.size(); ++i) {
+      partitionChannels[i] =
+          rowType->getChildIdx(partitionSpec->fields[i].name);
+    }
+
+    // Step 1: Build transform expressions and create evaluator.
+    auto transformExpressions = TransformExprBuilder::toExpressions(
+        partitionSpec,
+        partitionChannels,
+        rowType,
+        std::string(kDefaultIcebergFunctionPrefix));
+    auto transformEvaluator = std::make_unique<TransformEvaluator>(
+        transformExpressions, connectorQueryCtx_.get());
+
+    // Step 2: Apply transforms to input partition columns.
+    auto transformedColumns = transformEvaluator->evaluate(input);
+
+    std::vector<TypePtr> partitionKeyTypes;
+    std::vector<std::string> partitionKeyNames;
+    for (const auto& field : partitionSpec->fields) {
+      partitionKeyTypes.emplace_back(field.resultType());
+      std::string key = field.transformType == TransformType::kIdentity
+          ? field.name
+          : fmt::format(
+                "{}_{}",
+                field.name,
+                TransformTypeName::toName(field.transformType));
+      partitionKeyNames.emplace_back(std::move(key));
+    }
+
+    auto partitionRowType =
+        ROW(std::move(partitionKeyNames), std::move(partitionKeyTypes));
+    // Step 3: Create RowVector based on transformed columns.
+    auto transformedRowVector = std::make_shared<RowVector>(
+        connectorQueryCtx_->memoryPool(),
+        partitionRowType,
+        nullptr,
+        input->size(),
+        std::move(transformedColumns));
+
+    // Step 4: Generate partition IDs from transformed data.
+    // The transformed row vector has columns in the same order as partition
+    // spec fields, so channels are sequential: 0, 1, 2, ...
+    std::vector<column_index_t> transformedChannels(
+        partitionSpec->fields.size());
+    std::iota(transformedChannels.begin(), transformedChannels.end(), 0);
+
+    auto idGenerator = std::make_unique<PartitionIdGenerator>(
+        partitionRowType,
+        transformedChannels,
+        /*maxPartitions=*/128,
+        connectorQueryCtx_->memoryPool());
+
+    auto nameGenerator = std::make_unique<IcebergPartitionName>(partitionSpec);
+
+    raw_vector<uint64_t> partitionIds(input->size());
+    idGenerator->run(transformedRowVector, partitionIds);
+
+    for (auto i = 0; i < input->size(); ++i) {
+      std::string partitionName = nameGenerator->partitionName(
+          partitionIds[i], idGenerator->partitionValues(), false);
+      ASSERT_EQ(partitionName, expectedPaths[i]);
+    }
+  }
+};
+
+TEST_F(PartitionNameTest, identity) {
+  std::vector<std::tuple<TypePtr, VectorPtr, std::string>> input = {
+      {INTEGER(), makeConstant<int32_t>(42, 1), "42"},
+      {BIGINT(), makeConstant<int64_t>(9'876'543'210, 1), "9876543210"},
+      {VARCHAR(),
+       makeConstant<std::string>("test string partition column name", 1),
+       "test+string+partition+column+name"},
+      {VARBINARY(),
+       makeConstant<std::string>("\x48\x65\x6c\x6c\x6f", 1, VARBINARY()),
+       "SGVsbG8%3D"},
+      {DECIMAL(18, 4),
+       makeConstant<int64_t>(12'345'678'901'234, 1, DECIMAL(18, 4)),
+       "1234567890.1234"},
+      {BOOLEAN(), makeConstant<bool>(true, 1), "true"},
+      {DATE(), makeConstant<int32_t>(18'262, 1, DATE()), "2020-01-01"},
+  };
+
+  for (const auto& [type, value, expectedValue] : input) {
+    const auto& partitionSpec = createPartitionSpec(
+        ROW({"c0"}, {type}), {{0, TransformType::kIdentity, std::nullopt}});
+
+    verifyPartitionPaths(
+        makeRowVector({value}),
+        partitionSpec,
+        {fmt::format("c0={}", expectedValue)});
+  }
+}
+
+TEST_F(PartitionNameTest, timestamp) {
+  std::vector<Timestamp> timestamps = {
+      Timestamp(253402300800, 100000000), // +10000-01-01T00:00:00.1.
+      Timestamp(-62170000000, 0), // -0001-11-29T19:33:20.
+      Timestamp(-62135577748, 999000000), // 0001-01-01T05:17:32.999.
+      Timestamp(0, 0), // 1970-01-01T00:00.
+      Timestamp(1609459200, 999000000), // 2021-01-01T00:00.
+      Timestamp(1640995200, 500000000), // 2022-01-01T00:00:00.5.
+      Timestamp(1672531200, 123000000), // 2023-01-01T00:00:00.123.
+      Timestamp(-1, 999000000), // 1969-12-31T23:59:59.999.
+      Timestamp(1, 1000000), // 1970-01-01T00:00:01.001.
+      Timestamp(-62167219199, 0), // 0000-01-01T00:00:01.
+      Timestamp(-377716279140, 321000000), // -10000-01-01T01:01:00.321.
+      Timestamp(253402304660, 321000000), // +10000-01-01T01:01:00.321.
+      Timestamp(951782400, 0), // 2000-02-29T00:00:00 (leap year).
+      Timestamp(4107456000, 0), // 2100-02-28T00:00:00.
+      Timestamp(-86400, 0), // 1969-12-31T00:00:00.
+  };
+
+  std::vector<std::string> expectedPartitionNames = {
+      "c0=%2B10000-01-01T00%3A00%3A00.1",
+      "c0=-0001-11-29T19%3A33%3A20",
+      "c0=0001-01-01T05%3A17%3A32.999",
+      "c0=1970-01-01T00%3A00%3A00",
+      "c0=2021-01-01T00%3A00%3A00.999",
+      "c0=2022-01-01T00%3A00%3A00.5",
+      "c0=2023-01-01T00%3A00%3A00.123",
+      "c0=1969-12-31T23%3A59%3A59.999",
+      "c0=1970-01-01T00%3A00%3A01.001",
+      "c0=0000-01-01T00%3A00%3A01",
+      "c0=-10000-08-24T19%3A21%3A00.321",
+      "c0=%2B10000-01-01T01%3A04%3A20.321",
+      "c0=2000-02-29T00%3A00%3A00",
+      "c0=2100-02-28T00%3A00%3A00",
+      "c0=1969-12-31T00%3A00%3A00",
+  };
+
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}),
+      {{0, TransformType::kIdentity, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>(timestamps)}),
+      partitionSpec,
+      expectedPartitionNames);
+}
+
+TEST_F(PartitionNameTest, null) {
+  std::vector<
+      std::tuple<TypePtr, TransformType, std::optional<int32_t>, VectorPtr>>
+      input = {
+          {INTEGER(),
+           TransformType::kBucket,
+           32,
+           makeConstant<int32_t>(std::nullopt, 1)},
+          {VARCHAR(),
+           TransformType::kTruncate,
+           100,
+           makeConstant<std::string>(std::nullopt, 1)},
+          {DECIMAL(18, 3),
+           TransformType::kIdentity,
+           std::nullopt,
+           makeConstant<int64_t>(std::nullopt, 1, DECIMAL(18, 3))},
+          {TIMESTAMP(),
+           TransformType::kYear,
+           std::nullopt,
+           makeConstant<Timestamp>(std::nullopt, 1)},
+          {TIMESTAMP(),
+           TransformType::kMonth,
+           std::nullopt,
+           makeConstant<Timestamp>(std::nullopt, 1)},
+          {DATE(),
+           TransformType::kDay,
+           std::nullopt,
+           makeConstant<int32_t>(std::nullopt, 1, DATE())},
+          {TIMESTAMP(),
+           TransformType::kHour,
+           std::nullopt,
+           makeConstant<Timestamp>(std::nullopt, 1)},
+      };
+
+  for (const auto& [type, transformType, parameter, value] : input) {
+    auto rowType = ROW({"c0"}, {type});
+    const auto& partitionSpec =
+        createPartitionSpec(rowType, {{0, transformType, parameter}});
+    if (transformType == TransformType::kIdentity) {
+      verifyPartitionPaths(makeRowVector({value}), partitionSpec, {"c0=null"});
+    } else {
+      verifyPartitionPaths(
+          makeRowVector({value}),
+          partitionSpec,
+          {fmt::format(
+              "c0_{}=null", TransformTypeName::toName(transformType))});
+    }
+  }
+}
+
+// test both partition column name and partition key encoding.
+TEST_F(PartitionNameTest, specialChars) {
+  std::vector<std::pair<std::string, std::string>> inputs = {
+      {"abc123", "abc123"},
+      {"ABC123", "ABC123"},
+      {"a.b-c_d*e", "a.b-c_d*e"},
+      {"space test", "space+test"},
+      {"slash/test", "slash%2Ftest"},
+      {"question?test", "question%3Ftest"},
+      {"percent%test", "percent%25test"},
+      {"hash#test", "hash%23test"},
+      {"ampersand&test", "ampersand%26test"},
+      {"equals=test", "equals%3Dtest"},
+      {"plus+test", "plus%2Btest"},
+      {"comma,test", "comma%2Ctest"},
+      {"semicolon;test", "semicolon%3Btest"},
+      {"at@test", "at%40test"},
+      {"exclamation!test", "exclamation%21test"},
+      {"dollar$test", "dollar%24test"},
+      {"backslash\\test", "backslash%5Ctest"},
+      {"quote\"test", "quote%22test"},
+      {"apostrophe'test", "apostrophe%27test"},
+      {"paren(test", "paren%28test"},
+      {"paren)test", "paren%29test"},
+      {"less<than", "less%3Cthan"},
+      {"greater>than", "greater%3Ethan"},
+      {"colon:test", "colon%3Atest"},
+      {"pipe|test", "pipe%7Ctest"},
+      {"bracket[test", "bracket%5Btest"},
+      {"bracket]test", "bracket%5Dtest"},
+      {"brace{test", "brace%7Btest"},
+      {"brace}test", "brace%7Dtest"},
+      {"caret^test", "caret%5Etest"},
+      {"tilde~test", "tilde%7Etest"},
+      {"backtick`test", "backtick%60test"},
+      {"newline\ntest", "newline%0Atest"},
+      {"carriage\rreturn", "carriage%0Dreturn"},
+      {"tab\ttest", "tab%09test"},
+      {"unicode\u00A9test", "unicode%C2%A9test"},
+      {"email@example.com", "email%40example.com"},
+      {"user:password@host:port/path", "user%3Apassword%40host%3Aport%2Fpath"},
+      {"https://github.com/facebookincubator/velox",
+       "https%3A%2F%2Fgithub.com%2Ffacebookincubator%2Fvelox"},
+      {"a+b=c&d=e+f", "a%2Bb%3Dc%26d%3De%2Bf"},
+      {"a#b=c/d e", "a%23b%3Dc%2Fd+e"},
+      {"special!@#$%^&*()_+", "special%21%40%23%24%25%5E%26*%28%29_%2B"},
+  };
+
+  for (const auto& [input, encodedValue] : inputs) {
+    const auto& partitionSpec = createPartitionSpec(
+        ROW({input}, {VARCHAR()}),
+        {{0, TransformType::kIdentity, std::nullopt}});
+
+    verifyPartitionPaths(
+        makeRowVector(
+            {input}, {makeConstant<StringView>(StringView(input), 1)}),
+        partitionSpec,
+        {fmt::format("{}={}", encodedValue, encodedValue)});
+  }
+}
+
+TEST_F(PartitionNameTest, multipleRows) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0", "c1"}, {INTEGER(), VARCHAR()}),
+      {
+          {0, TransformType::kBucket, 8},
+          {1, TransformType::kIdentity, std::nullopt},
+      });
+
+  verifyPartitionPaths(
+      makeRowVector({
+          makeFlatVector<int32_t>({10, 20, 30, -100}),
+          makeFlatVector<std::string>({"value1", "VALue2", "VALUE3", ""}),
+      }),
+      partitionSpec,
+      {
+          "c0_bucket=4/c1=value1",
+          "c0_bucket=3/c1=VALue2",
+          "c0_bucket=3/c1=VALUE3",
+          "c0_bucket=6/c1=",
+      });
+}
+
+TEST_F(PartitionNameTest, year) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kYear, std::nullopt}});
+
+  std::vector<Timestamp> timestamps = {
+      Timestamp(0, 0),
+      Timestamp(1609459200, 0),
+      Timestamp(1640995200, 0),
+      Timestamp(-31536000, 0),
+      Timestamp(253402300800, 0),
+  };
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>(timestamps)}),
+      partitionSpec,
+      {
+          "c0_year=1970",
+          "c0_year=2021",
+          "c0_year=2022",
+          "c0_year=1969",
+          "c0_year=10000",
+      });
+}
+
+TEST_F(PartitionNameTest, yearWithDate) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {DATE()}), {{0, TransformType::kYear, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<int32_t>({0, 365, 18262, -365}, DATE())}),
+      partitionSpec,
+      {
+          "c0_year=1970",
+          "c0_year=1971",
+          "c0_year=2020",
+          "c0_year=1969",
+      });
+}
+
+TEST_F(PartitionNameTest, month) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kMonth, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>({
+          Timestamp(0, 0),
+          Timestamp(2678400, 0),
+          Timestamp(1609459200, 0),
+          Timestamp(1640995200, 0),
+          Timestamp(-2678400, 0),
+      })}),
+      partitionSpec,
+      {
+          "c0_month=1970-01",
+          "c0_month=1970-02",
+          "c0_month=2021-01",
+          "c0_month=2022-01",
+          "c0_month=1969-12",
+      });
+}
+
+TEST_F(PartitionNameTest, monthWithDate) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {DATE()}), {{0, TransformType::kMonth, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<int32_t>({0, 31, 365, -31}, DATE())}),
+      partitionSpec,
+      {
+          "c0_month=1970-01",
+          "c0_month=1970-02",
+          "c0_month=1971-01",
+          "c0_month=1969-12",
+      });
+}
+
+TEST_F(PartitionNameTest, day) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kDay, std::nullopt}});
+
+  std::vector<Timestamp> timestamps = {
+      Timestamp(0, 0),
+      Timestamp(86400, 0),
+      Timestamp(1577836800, 0),
+      Timestamp(-86400, 0),
+  };
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>(timestamps)}),
+      partitionSpec,
+      {
+          "c0_day=1970-01-01",
+          "c0_day=1970-01-02",
+          "c0_day=2020-01-01",
+          "c0_day=1969-12-31",
+      });
+}
+
+TEST_F(PartitionNameTest, dayWithDate) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {DATE()}), {{0, TransformType::kDay, std::nullopt}});
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<int32_t>({0, 1, 18262, -1}, DATE())}),
+      partitionSpec,
+      {
+          "c0_day=1970-01-01",
+          "c0_day=1970-01-02",
+          "c0_day=2020-01-01",
+          "c0_day=1969-12-31",
+      });
+}
+
+TEST_F(PartitionNameTest, hour) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kHour, std::nullopt}});
+
+  std::vector<Timestamp> timestamps = {
+      Timestamp(0, 0),
+      Timestamp(3600, 0),
+      Timestamp(86400, 0),
+      Timestamp(1577836800, 0),
+      Timestamp(-3600, 0),
+  };
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>(timestamps)}),
+      partitionSpec,
+      {
+          "c0_hour=1970-01-01-00",
+          "c0_hour=1970-01-01-01",
+          "c0_hour=1970-01-02-00",
+          "c0_hour=2020-01-01-00",
+          "c0_hour=1969-12-31-23",
+      });
+}
+
+TEST_F(PartitionNameTest, multipleTransformsSameColumn) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}),
+      {
+          {0, TransformType::kIdentity, std::nullopt},
+          {0, TransformType::kYear, std::nullopt},
+          {0, TransformType::kBucket, 10},
+      });
+
+  verifyPartitionPaths(
+      makeRowVector({makeFlatVector<Timestamp>({Timestamp(1609459200, 0)})}),
+      partitionSpec,
+      {"c0=2021-01-01T00%3A00%3A00/c0_year=2021/c0_bucket=0"});
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/PartitionSpecTest.cpp b/velox/connectors/hive/iceberg/tests/PartitionSpecTest.cpp
new file mode 100644
index 000000000000..23a06340aad3
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/PartitionSpecTest.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/connectors/hive/iceberg/PartitionSpec.h"
+
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+TEST(PartitionSpecTest, invalidColumnType) {
+  auto makeSpec = [](const TypePtr& type) {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", type, TransformType::kIdentity, std::nullopt},
+    };
+    return std::make_shared<const IcebergPartitionSpec>(1, fields);
+  };
+
+  VELOX_ASSERT_USER_THROW(
+      makeSpec(ROW({{"a", INTEGER()}})),
+      "Type is not supported as a partition column: ROW");
+  VELOX_ASSERT_USER_THROW(
+      makeSpec(ARRAY(INTEGER())),
+      "Type is not supported as a partition column: ARRAY");
+  VELOX_ASSERT_USER_THROW(
+      makeSpec(MAP(VARCHAR(), INTEGER())),
+      "Type is not supported as a partition column: MAP");
+  VELOX_ASSERT_USER_THROW(
+      makeSpec(TIMESTAMP_WITH_TIME_ZONE()),
+      "Type is not supported as a partition column: TIMESTAMP WITH TIME ZONE");
+}
+
+TEST(PartitionSpecTest, invalidMultipleTransforms) {
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", VARCHAR(), TransformType::kIdentity, std::nullopt},
+        {"c0", VARCHAR(), TransformType::kIdentity, std::nullopt},
+    };
+    VELOX_ASSERT_USER_THROW(
+        std::make_shared<const IcebergPartitionSpec>(1, fields),
+        "Column: 'c0', Category: Identity, Transforms: [identity, identity]");
+  }
+
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", VARCHAR(), TransformType::kBucket, 16},
+        {"c0", VARCHAR(), TransformType::kBucket, 32},
+    };
+    VELOX_ASSERT_USER_THROW(
+        std::make_shared<const IcebergPartitionSpec>(1, fields),
+        "Column: 'c0', Category: Bucket, Transforms: [bucket, bucket]");
+  }
+
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", VARCHAR(), TransformType::kTruncate, 2},
+        {"c0", VARCHAR(), TransformType::kTruncate, 5},
+    };
+    VELOX_ASSERT_USER_THROW(
+        std::make_shared<const IcebergPartitionSpec>(1, fields),
+        "Column: 'c0', Category: Truncate, Transforms: [trunc, trunc]");
+  }
+
+  {
+    std::vector<IcebergPartitionSpec::Field> fields4 = {
+        {"c0", TIMESTAMP(), TransformType::kYear, std::nullopt},
+        {"c0", TIMESTAMP(), TransformType::kMonth, std::nullopt},
+        {"c0", TIMESTAMP(), TransformType::kDay, std::nullopt},
+        {"c0", TIMESTAMP(), TransformType::kHour, std::nullopt},
+    };
+    VELOX_ASSERT_USER_THROW(
+        std::make_shared<const IcebergPartitionSpec>(1, fields4),
+        "Column: 'c0', Category: Temporal, Transforms: [year, month, day, hour]");
+  }
+}
+
+TEST(PartitionSpecTest, invalidMultipleTransformsMultipleColumns) {
+  std::vector<IcebergPartitionSpec::Field> fields = {
+      {"c0", DATE(), TransformType::kYear, std::nullopt},
+      {"c0", DATE(), TransformType::kMonth, std::nullopt},
+      {"c1", VARCHAR(), TransformType::kBucket, 16},
+      {"c1", VARCHAR(), TransformType::kBucket, 32},
+  };
+  // order may vary due to map iteration.
+  VELOX_ASSERT_USER_THROW(
+      std::make_shared<const IcebergPartitionSpec>(1, fields),
+      "Column: 'c0', Category: Temporal, Transforms: [year, month]");
+  VELOX_ASSERT_USER_THROW(
+      std::make_shared<const IcebergPartitionSpec>(1, fields),
+      "Column: 'c1', Category: Bucket, Transforms: [bucket, bucket]");
+}
+
+TEST(PartitionSpecTest, validMultipleTransforms) {
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", VARCHAR(), TransformType::kIdentity, std::nullopt},
+        {"c0", VARCHAR(), TransformType::kBucket, 16},
+        {"c0", VARCHAR(), TransformType::kTruncate, 10},
+    };
+    auto spec = std::make_shared<const IcebergPartitionSpec>(1, fields);
+    EXPECT_EQ(spec->fields.size(), 3);
+  }
+
+  {
+    std::vector<IcebergPartitionSpec::Field> fields = {
+        {"c0", DATE(), TransformType::kYear, std::nullopt},
+        {"c0", DATE(), TransformType::kBucket, 16},
+        {"c0", DATE(), TransformType::kIdentity, std::nullopt},
+    };
+    auto spec = std::make_shared<const IcebergPartitionSpec>(1, fields);
+    EXPECT_EQ(spec->fields.size(), 3);
+  }
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/PartitionValueFormatterTest.cpp b/velox/connectors/hive/iceberg/tests/PartitionValueFormatterTest.cpp
new file mode 100644
index 000000000000..13cda035cbfb
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/PartitionValueFormatterTest.cpp
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/connectors/hive/iceberg/IcebergPartitionName.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+template <typename T>
+std::string toPath(TransformType transform, T value, const TypePtr& type) {
+  return IcebergPartitionName::toName(value, type, transform);
+}
+
+std::string timestampToPath(const Timestamp& timestamp) {
+  return toPath(TransformType::kIdentity, timestamp, TIMESTAMP());
+}
+
+std::string testString(
+    const std::string& value,
+    const TypePtr& typePtr = VARCHAR()) {
+  auto identityResult =
+      toPath(TransformType::kIdentity, StringView(value), typePtr);
+  auto truncateResult =
+      toPath(TransformType::kTruncate, StringView(value), typePtr);
+  EXPECT_EQ(identityResult, truncateResult);
+  return identityResult;
+}
+
+std::string testVarbinary(const std::string& value) {
+  return testString(value, VARBINARY());
+}
+
+std::string testInteger(int32_t value) {
+  auto identityResult = toPath(TransformType::kIdentity, value, INTEGER());
+  auto bucketResult = toPath(TransformType::kBucket, value, INTEGER());
+  auto truncResult = toPath(TransformType::kTruncate, value, INTEGER());
+  EXPECT_EQ(identityResult, truncResult);
+  EXPECT_EQ(bucketResult, truncResult);
+  return truncResult;
+}
+
+TEST(IcebergPartitionPathTest, integer) {
+  EXPECT_EQ(testInteger(0), "0");
+  EXPECT_EQ(testInteger(1), "1");
+  EXPECT_EQ(testInteger(100), "100");
+  EXPECT_EQ(testInteger(-100), "-100");
+  EXPECT_EQ(testInteger(128), "128");
+  EXPECT_EQ(testInteger(1024), "1024");
+}
+
+TEST(IcebergPartitionPathTest, date) {
+  EXPECT_EQ(toPath(TransformType::kIdentity, 18'262, DATE()), "2020-01-01");
+  EXPECT_EQ(toPath(TransformType::kIdentity, 0, DATE()), "1970-01-01");
+  EXPECT_EQ(toPath(TransformType::kIdentity, -1, DATE()), "1969-12-31");
+  EXPECT_EQ(toPath(TransformType::kIdentity, 2'932'897, DATE()), "10000-01-01");
+}
+
+TEST(IcebergPartitionPathTest, boolean) {
+  EXPECT_EQ(toPath(TransformType::kIdentity, true, BOOLEAN()), "true");
+  EXPECT_EQ(toPath(TransformType::kIdentity, false, BOOLEAN()), "false");
+}
+
+TEST(IcebergPartitionPathTest, string) {
+  EXPECT_EQ(testString("a/b/c=d"), "a/b/c=d");
+  EXPECT_EQ(testString(""), "");
+  EXPECT_EQ(testString("abc"), "abc");
+}
+
+TEST(IcebergPartitionPathTest, varbinary) {
+  EXPECT_EQ(testVarbinary("\x48\x65\x6c\x6c\x6f"), "SGVsbG8=");
+  EXPECT_EQ(testVarbinary("\x1\x2\x3"), "AQID");
+  EXPECT_EQ(testVarbinary(""), "");
+}
+
+TEST(IcebergPartitionPathTest, timestamp) {
+  EXPECT_EQ(timestampToPath(Timestamp(0, 0)), "1970-01-01T00:00:00");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(1'609'459'200, 999'000'000)),
+      "2021-01-01T00:00:00.999");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(1'640'995'200, 500'000'000)),
+      "2022-01-01T00:00:00.5");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(-1, 999'000'000)), "1969-12-31T23:59:59.999");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(253'402'300'800, 100'000'000)),
+      "+10000-01-01T00:00:00.1");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(-62'170'000'000, 0)), "-0001-11-29T19:33:20");
+  EXPECT_EQ(
+      timestampToPath(Timestamp(-62'167'219'199, 0)), "0000-01-01T00:00:01");
+}
+
+TEST(IcebergPartitionPathTest, year) {
+  EXPECT_EQ(toPath(TransformType::kYear, 0, INTEGER()), "1970");
+  EXPECT_EQ(toPath(TransformType::kYear, 1, INTEGER()), "1971");
+  EXPECT_EQ(toPath(TransformType::kYear, 8'030, INTEGER()), "10000");
+  EXPECT_EQ(toPath(TransformType::kYear, -1, INTEGER()), "1969");
+  EXPECT_EQ(toPath(TransformType::kYear, -50, INTEGER()), "1920");
+}
+
+TEST(IcebergPartitionPathTest, month) {
+  EXPECT_EQ(toPath(TransformType::kMonth, 0, INTEGER()), "1970-01");
+  EXPECT_EQ(toPath(TransformType::kMonth, 1, INTEGER()), "1970-02");
+  EXPECT_EQ(toPath(TransformType::kMonth, 11, INTEGER()), "1970-12");
+  EXPECT_EQ(toPath(TransformType::kMonth, 612, INTEGER()), "2021-01");
+  EXPECT_EQ(toPath(TransformType::kMonth, -1, INTEGER()), "1969-12");
+  EXPECT_EQ(toPath(TransformType::kMonth, -13, INTEGER()), "1968-12");
+}
+
+TEST(IcebergPartitionPathTest, day) {
+  EXPECT_EQ(toPath(TransformType::kDay, 0, DATE()), "1970-01-01");
+  EXPECT_EQ(toPath(TransformType::kDay, 1, DATE()), "1970-01-02");
+  EXPECT_EQ(toPath(TransformType::kDay, 18'262, DATE()), "2020-01-01");
+  EXPECT_EQ(toPath(TransformType::kDay, -1, DATE()), "1969-12-31");
+}
+
+TEST(IcebergPartitionPathTest, hour) {
+  EXPECT_EQ(toPath(TransformType::kHour, 0, INTEGER()), "1970-01-01-00");
+  EXPECT_EQ(toPath(TransformType::kHour, 1, INTEGER()), "1970-01-01-01");
+  EXPECT_EQ(toPath(TransformType::kHour, 24, INTEGER()), "1970-01-02-00");
+  EXPECT_EQ(toPath(TransformType::kHour, 438'288, INTEGER()), "2020-01-01-00");
+  EXPECT_EQ(toPath(TransformType::kHour, -1, INTEGER()), "1969-12-31-23");
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/TransformE2ETest.cpp b/velox/connectors/hive/iceberg/tests/TransformE2ETest.cpp
new file mode 100644
index 000000000000..a8fba90bef0b
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/TransformE2ETest.cpp
@@ -0,0 +1,650 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <filesystem>
+
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.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/iceberg/Murmur3Hash32.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+#ifdef VELOX_ENABLE_PARQUET
+
+class TransformE2ETest : public test::IcebergTestBase {
+ protected:
+  static constexpr int32_t kDefaultNumBatches = 2;
+  static constexpr int32_t kDefaultRowsPerBatch = 100;
+
+  std::vector<RowVectorPtr> createTimestampTestData() {
+    std::vector<RowVectorPtr> batches;
+    // 1. Aligned to hour boundaries (no minutes/seconds) since hour is the
+    //    finest granularity transform tested.
+    // 2. Include negative epoch values (pre-1970) to test edge cases.
+    // 3. Span multiple years and months.
+    static const std::vector<Timestamp> timestamps = {
+        // 1969-01-01 00:00:00 (negative epoch)
+        Timestamp(-31536000, 0),
+        // 1969-12-31 00:00:00 (day before epoch)
+        Timestamp(-86400, 0),
+        // 1970-01-01 00:00:00
+        Timestamp(0, 0),
+        // 1970-01-01 01:00:00
+        Timestamp(3600, 0),
+        // 1970-01-02 00:00:00
+        Timestamp(86400, 0),
+        // 1970-01-31 00:00:00
+        Timestamp(2592000, 0),
+        // 1971-01-01 00:00:00
+        Timestamp(31536000, 0),
+        // 2021-01-01 00:00:00
+        Timestamp(1609459200, 0),
+        // 2021-01-02 00:00:00
+        Timestamp(1609545600, 0),
+        // 2021-02-01 00:00:00
+        Timestamp(1612224000, 0),
+        // 2022-01-01 00:00:00
+        Timestamp(1640995200, 0),
+        // 2023-01-01 00:00:00
+        Timestamp(1672531200, 0),
+        // 2100-01-01 00:00:00
+        Timestamp(4102444800, 0),
+    };
+
+    for (auto i = 0; i < kDefaultNumBatches; i++) {
+      auto timestampVector = makeFlatVector<Timestamp>(
+          kDefaultRowsPerBatch,
+          [](auto row) { return timestamps[row % timestamps.size()]; });
+      batches.push_back(makeRowVector({timestampVector}));
+    }
+    return batches;
+  }
+
+  std::shared_ptr<TempDirectoryPath> writeBatchesWithTransforms(
+      const std::vector<RowVectorPtr>& batches,
+      const std::vector<test::PartitionField>& partitionFields) {
+    VELOX_CHECK(!batches.empty(), "input cannot be empty");
+
+    int64_t expectedRowCount = 0;
+    for (const auto& batch : batches) {
+      expectedRowCount += batch->size();
+    }
+
+    auto rowType = batches.front()->rowType();
+    auto outputDirectory = TempDirectoryPath::create();
+    const auto dataSink = createDataSinkAndAppendData(
+        batches, outputDirectory->getPath(), partitionFields);
+    dataSink->close();
+    verifyTotalRowCount(rowType, outputDirectory->getPath(), expectedRowCount);
+    return outputDirectory;
+  }
+
+  // Generate a key from a timestamp and transform type.
+  // The key format depends on the transform type:
+  // - kMonth: "YYYY-MM"
+  // - kDay: "YYYY-MM-DD"
+  // - kHour: "YYYY-MM-DD-HH"
+  static std::string timestampToKey(
+      const Timestamp& ts,
+      TransformType transformType) {
+    std::tm tm;
+    if (!Timestamp::epochToCalendarUtc(ts.getSeconds(), tm)) {
+      return "";
+    }
+
+    int32_t year = tm.tm_year + 1900;
+    int32_t month = tm.tm_mon + 1;
+    int32_t day = tm.tm_mday;
+    int32_t hour = tm.tm_hour;
+
+    switch (transformType) {
+      case TransformType::kMonth:
+        return fmt::format("{:04d}-{:02d}", year, month);
+      case TransformType::kDay:
+        return fmt::format("{:04d}-{:02d}-{:02d}", year, month, day);
+      case TransformType::kHour:
+        return fmt::format(
+            "{:04d}-{:02d}-{:02d}-{:02d}", year, month, day, hour);
+      default:
+        VELOX_UNREACHABLE();
+    }
+  }
+
+  // Helper function to build expected counts map from timestamp batches.
+  // The key format depends on the transform type:
+  // - kMonth: "YYYY-MM"
+  // - kDay: "YYYY-MM-DD"
+  // - kHour: "YYYY-MM-DD-HH"
+  static std::unordered_map<std::string, int32_t>
+  buildExpectedCountsFromTimestamps(
+      const std::vector<RowVectorPtr>& batches,
+      TransformType transformType) {
+    std::unordered_map<std::string, int32_t> expectedCounts;
+
+    for (const auto& batch : batches) {
+      auto timestampVector = batch->childAt(0)->as<SimpleVector<Timestamp>>();
+      for (auto i = 0; i < batch->size(); i++) {
+        Timestamp ts = timestampVector->valueAt(i);
+        std::string key = timestampToKey(ts, transformType);
+        expectedCounts[key]++;
+      }
+    }
+    return expectedCounts;
+  }
+
+  static std::string dirName(const std::string& path) {
+    return std::filesystem::path(path).filename().string();
+  }
+
+  static std::vector<std::string> firstLevelDirectories(
+      const std::string& basePath) {
+    std::vector<std::string> directories;
+    for (const auto& entry : std::filesystem::directory_iterator(basePath)) {
+      if (entry.is_directory()) {
+        directories.push_back(entry.path().string());
+      }
+    }
+    return directories;
+  }
+
+  static std::vector<std::string> listDirectoriesRecursively(
+      const std::string& path) {
+    std::vector<std::string> directories;
+    auto firstLevelDirs = firstLevelDirectories(path);
+
+    for (const auto& dir : firstLevelDirs) {
+      directories.push_back(dirName(dir));
+      auto subDirs = listDirectoriesRecursively(dir);
+      directories.insert(directories.end(), subDirs.begin(), subDirs.end());
+    }
+
+    return directories;
+  }
+
+  static std::vector<std::string> verifyPartitionCount(
+      const std::string& outputPath,
+      int32_t expectedCount) {
+    const auto partitionDirs = firstLevelDirectories(outputPath);
+    EXPECT_EQ(partitionDirs.size(), expectedCount);
+    for (const auto& dir : partitionDirs) {
+      const auto name = dirName(dir);
+      EXPECT_TRUE(name.find('=') != std::string::npos)
+          << "Partition directory " << name
+          << " does not follow Iceberg naming convention";
+    }
+    return partitionDirs;
+  }
+
+  // Verify the total row count across all partitions.
+  void verifyTotalRowCount(
+      const RowTypePtr& rowType,
+      const std::string& outputPath,
+      int32_t expectedRowCount) {
+    auto splits = createSplitsForDirectory(outputPath);
+
+    const auto plan = PlanBuilder()
+                          .startTableScan()
+                          .connectorId(test::kIcebergConnectorId)
+                          .outputType(rowType)
+                          .endTableScan()
+                          .planNode();
+
+    const auto actualRowCount =
+        AssertQueryBuilder(plan).splits(splits).countResults();
+
+    ASSERT_EQ(actualRowCount, expectedRowCount);
+  }
+
+  // Verify data in a specific partition.
+  void verifyPartitionData(
+      const RowTypePtr& rowType,
+      const std::string& partitionPath,
+      const std::string& partitionFilter,
+      const int32_t expectedRowCount) {
+    auto splits = createSplitsForDirectory(partitionPath);
+
+    auto scanPlan = PlanBuilder()
+                        .startTableScan()
+                        .connectorId(test::kIcebergConnectorId)
+                        .outputType(rowType)
+                        .endTableScan()
+                        .planNode();
+
+    const auto actualRowCount =
+        AssertQueryBuilder(scanPlan).splits(splits).countResults();
+
+    ASSERT_EQ(actualRowCount, expectedRowCount);
+
+    const auto filterPlan = PlanBuilder()
+                                .startTableScan()
+                                .connectorId(test::kIcebergConnectorId)
+                                .outputType(rowType)
+                                .endTableScan()
+                                .filter(partitionFilter)
+                                .planNode();
+    const auto filteredRowCount =
+        AssertQueryBuilder(filterPlan).splits(splits).countResults();
+    ASSERT_EQ(expectedRowCount, filteredRowCount);
+  }
+
+  static std::pair<std::string, std::string> parsePartitionDirName(
+      const std::string& name) {
+    auto eq = name.find('=');
+    VELOX_CHECK(eq != std::string::npos);
+    auto us = name.rfind('_', eq - 1);
+    auto columnName = name.substr(0, us);
+    auto value = name.substr(eq + 1);
+    return {columnName, value};
+  }
+
+  static int32_t computeBucketHash(
+      const StringView& value,
+      int32_t numBuckets) {
+    int32_t hash = functions::iceberg::Murmur3Hash32::hashBytes(
+        value.data(), value.size());
+    return ((hash & 0x7FFFFFFF) % numBuckets);
+  }
+};
+
+TEST_F(TransformE2ETest, identity) {
+  constexpr auto rowsPerBatch = 10;
+  constexpr auto duplicates = 5;
+  auto rowType = ROW({"c0"}, {INTEGER()});
+  auto baseVectors = createTestData(rowType, kDefaultNumBatches, rowsPerBatch);
+
+  // Duplicate each row to create multiple rows with the same partition key.
+  std::vector<RowVectorPtr> vectors;
+  for (const auto& baseVector : baseVectors) {
+    auto duplicatedColumn = wrapInDictionary(
+        makeIndices(
+            baseVector->size() * duplicates,
+            [duplicates](auto row) { return row / duplicates; }),
+        baseVector->size() * duplicates,
+        baseVector->childAt(0));
+    vectors.push_back(makeRowVector({duplicatedColumn}));
+  }
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      vectors, {{0, TransformType::kIdentity, std::nullopt}});
+
+  auto partitionDirs = verifyPartitionCount(
+      outputDirectory->getPath(), kDefaultNumBatches * rowsPerBatch);
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    // Each partition should have duplicates rows.
+    verifyPartitionData(rowType, dir, name, duplicates);
+  }
+}
+
+TEST_F(TransformE2ETest, partitionNamingConventions) {
+  auto rowVector = makeRowVector(
+      {
+          "c_int",
+          "c_bigint",
+          "c_varchar",
+          "c_varchar2",
+          "c_decimal",
+          "c_varbinary",
+      },
+      {
+          makeConstant(42, 1, INTEGER()),
+          makeConstant(static_cast<int64_t>(9'876'543'210), 1, BIGINT()),
+          makeConstant("test string", 1, VARCHAR()),
+          makeNullConstant(TypeKind::VARCHAR, 1),
+          makeConstant(static_cast<int64_t>(1'234'567'890), 1, DECIMAL(18, 3)),
+          makeConstant("binarydata\1\2\3", 1, VARBINARY()),
+      });
+
+  std::vector<test::PartitionField> partitionTransforms = {
+      {0, TransformType::kIdentity, std::nullopt}, // c_int.
+      {1, TransformType::kIdentity, std::nullopt}, // c_bigint.
+      {2, TransformType::kIdentity, std::nullopt}, // c_varchar.
+      {4, TransformType::kIdentity, std::nullopt}, // c_decimal.
+      {5, TransformType::kIdentity, std::nullopt}, // c_varbinary.
+      {3, TransformType::kIdentity, std::nullopt}, // c_varchar2.
+  };
+
+  auto outputDirectory =
+      writeBatchesWithTransforms({rowVector}, partitionTransforms);
+
+  const auto actualPartitionNames =
+      listDirectoriesRecursively(outputDirectory->getPath());
+
+  // Build expected partition folder names.
+  std::vector<std::string> expectedPartitionNames = {
+      "c_int=42",
+      "c_bigint=9876543210",
+      "c_varchar=test+string",
+      "c_decimal=1234567.890",
+      "c_varbinary=YmluYXJ5ZGF0YQECAw%3D%3D",
+      "c_varchar2=null",
+  };
+
+  ASSERT_EQ(actualPartitionNames, expectedPartitionNames)
+      << "Partition folder names do not match expected values";
+}
+
+TEST_F(TransformE2ETest, bucket) {
+  constexpr int32_t numBuckets = 4;
+  auto rowType = ROW({"c_varchar"}, {VARCHAR()});
+  auto vectors =
+      createTestData(rowType, kDefaultNumBatches, kDefaultRowsPerBatch);
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      vectors, {{0, TransformType::kBucket, numBuckets}});
+
+  const auto partitionDirs =
+      verifyPartitionCount(outputDirectory->getPath(), numBuckets);
+
+  int32_t totalRows = 0;
+  for (const auto& dir : partitionDirs) {
+    auto splits = createSplitsForDirectory(dir);
+    auto countPlan = PlanBuilder()
+                         .startTableScan()
+                         .connectorId(test::kIcebergConnectorId)
+                         .outputType(rowType)
+                         .endTableScan()
+                         .planNode();
+    auto partitionRowCount =
+        AssertQueryBuilder(countPlan).splits(splits).countResults();
+
+    totalRows += partitionRowCount;
+    ASSERT_GT(partitionRowCount, 0);
+  }
+
+  ASSERT_EQ(totalRows, kDefaultNumBatches * kDefaultRowsPerBatch);
+
+  std::unordered_map<std::string, int32_t> valueToExpectedBucket;
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    const auto [k, v] = parsePartitionDirName(name);
+    const int32_t expectedBucket = std::stoi(v);
+
+    auto dataPlan = PlanBuilder()
+                        .startTableScan()
+                        .connectorId(test::kIcebergConnectorId)
+                        .outputType(rowType)
+                        .endTableScan()
+                        .project({"c_varchar"})
+                        .planNode();
+    const auto& dataResult = AssertQueryBuilder(dataPlan)
+                                 .splits(createSplitsForDirectory(dir))
+                                 .copyResults(opPool_.get());
+
+    auto varcharColumn = dataResult->childAt(0)->asFlatVector<StringView>();
+    for (auto i = 0; i < dataResult->size(); i++) {
+      auto value = varcharColumn->valueAt(i);
+
+      auto computedBucket = computeBucketHash(value, numBuckets);
+      ASSERT_EQ(computedBucket, expectedBucket);
+    }
+  }
+}
+
+TEST_F(TransformE2ETest, truncate) {
+  auto rowType = ROW({"c_int"}, {INTEGER()});
+
+  std::vector<RowVectorPtr> batches;
+  for (auto i = 0; i < kDefaultNumBatches; i++) {
+    std::vector<VectorPtr> columns;
+    columns.push_back(
+        makeFlatVector<int32_t>(50, [](auto row) { return row % 100; }));
+    auto vectors = makeRowVector(rowType->names(), columns);
+    batches.push_back(vectors);
+  }
+
+  auto outputDirectory =
+      writeBatchesWithTransforms(batches, {{0, TransformType::kTruncate, 10}});
+
+  auto partitionDirs = verifyPartitionCount(outputDirectory->getPath(), 5);
+
+  for (const auto& dir : partitionDirs) {
+    const std::string name = dirName(dir);
+    auto [c, v] = parsePartitionDirName(name);
+    const std::string filter = fmt::format(
+        "{}>={} AND {}<{}", c, v, c, std::to_string(std::stoi(v) + 10));
+
+    verifyPartitionData(
+        rowType, dir, filter, 20); // 10 values per batch * 2 batches.
+  }
+}
+
+TEST_F(TransformE2ETest, year) {
+  auto rowType = ROW({"c_date"}, {DATE()});
+  static const std::vector<int32_t> dates = {
+      18'262, 18'628, 18'993, 19'358, 19'723, 20'181};
+  std::vector<RowVectorPtr> batches;
+  for (auto i = 0; i < kDefaultNumBatches; i++) {
+    auto dateVector = makeFlatVector<int32_t>(
+        kDefaultRowsPerBatch,
+        [](auto row) { return dates[row % dates.size()]; },
+        nullptr,
+        DATE());
+    batches.emplace_back(makeRowVector(rowType->names(), {dateVector}));
+  }
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kYear, std::nullopt}});
+
+  auto partitionDirs = verifyPartitionCount(outputDirectory->getPath(), 6);
+
+  for (int32_t year = 2020; year <= 2025; year++) {
+    const auto expectedDirName = fmt::format("c_date_year={}", year);
+    bool foundPartition = false;
+    auto yearFilter = [](int32_t year) -> std::string {
+      return fmt::format("YEAR(DATE '{}-01-01')={}", year, year);
+    };
+
+    for (const auto& dir : partitionDirs) {
+      SCOPED_TRACE(year);
+      const auto name = dirName(dir);
+      if (name == expectedDirName) {
+        foundPartition = true;
+        auto datePlan = PlanBuilder()
+                            .startTableScan()
+                            .connectorId(test::kIcebergConnectorId)
+                            .outputType(rowType)
+                            .endTableScan()
+                            .filter(yearFilter(year))
+                            .planNode();
+
+        auto splits = createSplitsForDirectory(dir);
+        auto partitionRowCount =
+            AssertQueryBuilder(datePlan).splits(splits).countResults();
+
+        auto countPlan = PlanBuilder()
+                             .startTableScan()
+                             .connectorId(test::kIcebergConnectorId)
+                             .outputType(rowType)
+                             .endTableScan()
+                             .planNode();
+        auto totalPartitionCount =
+            AssertQueryBuilder(countPlan).splits(splits).countResults();
+        ASSERT_EQ(partitionRowCount, totalPartitionCount);
+        break;
+      }
+    }
+    ASSERT_TRUE(foundPartition);
+  }
+}
+
+TEST_F(TransformE2ETest, month) {
+  auto batches = createTimestampTestData();
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kMonth, std::nullopt}});
+
+  auto expectedCounts =
+      buildExpectedCountsFromTimestamps(batches, TransformType::kMonth);
+  const auto partitionDirs = firstLevelDirectories(outputDirectory->getPath());
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    auto [c, v] = parsePartitionDirName(name);
+    size_t dashPos = v.find('-');
+    ASSERT_NE(dashPos, std::string::npos) << "Invalid month format: " << v;
+
+    int32_t year = std::stoi(v.substr(0, dashPos));
+    int32_t month = std::stoi(v.substr(dashPos + 1));
+    std::string filter =
+        fmt::format("YEAR(c0) = {} AND MONTH(c0) = {}", year, month);
+    std::string monthKey = fmt::format("{:04d}-{:02d}", year, month);
+    verifyPartitionData(
+        ROW({"c0"}, {TIMESTAMP()}), dir, filter, expectedCounts[monthKey]);
+  }
+}
+
+TEST_F(TransformE2ETest, day) {
+  auto batches = createTimestampTestData();
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kDay, std::nullopt}});
+
+  auto expectedCounts =
+      buildExpectedCountsFromTimestamps(batches, TransformType::kDay);
+  const auto partitionDirs = firstLevelDirectories(outputDirectory->getPath());
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    auto [c, v] = parsePartitionDirName(name);
+    std::vector<std::string> dateParts;
+    folly::split('-', v, dateParts);
+    ASSERT_EQ(dateParts.size(), 3) << "Invalid day format: " << v;
+
+    int32_t year = std::stoi(dateParts[0]);
+    int32_t month = std::stoi(dateParts[1]);
+    int32_t day = std::stoi(dateParts[2]);
+
+    std::string filter = fmt::format(
+        "YEAR(c0) = {} AND MONTH(c0) = {} AND DAY(c0) = {}", year, month, day);
+    std::string dayKey = fmt::format("{:04d}-{:02d}-{:02d}", year, month, day);
+    verifyPartitionData(
+        ROW({"c0"}, {TIMESTAMP()}), dir, filter, expectedCounts[dayKey]);
+  }
+}
+
+TEST_F(TransformE2ETest, hour) {
+  auto batches = createTimestampTestData();
+
+  auto outputDirectory = writeBatchesWithTransforms(
+      batches, {{0, TransformType::kHour, std::nullopt}});
+
+  auto expectedCounts =
+      buildExpectedCountsFromTimestamps(batches, TransformType::kHour);
+  const auto partitionDirs = firstLevelDirectories(outputDirectory->getPath());
+
+  for (const auto& dir : partitionDirs) {
+    const auto name = dirName(dir);
+    auto [c, v] = parsePartitionDirName(name);
+    std::vector<std::string> dateParts;
+    folly::split('-', v, dateParts);
+    ASSERT_EQ(dateParts.size(), 4) << "Invalid hour format: " << v;
+
+    int32_t year = std::stoi(dateParts[0]);
+    int32_t month = std::stoi(dateParts[1]);
+    int32_t day = std::stoi(dateParts[2]);
+    int32_t hour = std::stoi(dateParts[3]);
+
+    std::string filter = fmt::format(
+        "YEAR(c0) = {} AND MONTH(c0) = {} AND "
+        "DAY(c0) = {} AND HOUR(c0) = {}",
+        year,
+        month,
+        day,
+        hour);
+    std::string hourKey =
+        fmt::format("{:04d}-{:02d}-{:02d}-{:02d}", year, month, day, hour);
+    verifyPartitionData(
+        ROW({"c0"}, {TIMESTAMP()}), dir, filter, expectedCounts[hourKey]);
+  }
+}
+
+TEST_F(TransformE2ETest, multipleTransformsOnSameColumn) {
+  auto rowType = ROW(
+      {
+          "c_int",
+          "c_bigint",
+      },
+      {
+          INTEGER(),
+          BIGINT(),
+      });
+
+  auto vectors = createTestData(rowType, 2, 20);
+  auto outputDirectory = writeBatchesWithTransforms(
+      vectors,
+      {
+          {0, TransformType::kIdentity, std::nullopt}, // c_int.
+          {0, TransformType::kTruncate, 10}, // truncate(c_int, 10).
+          {0, TransformType::kBucket, 4}, // bucket(c_int, 4).
+      });
+
+  auto firstLevelDirs = firstLevelDirectories(outputDirectory->getPath());
+  ASSERT_GT(firstLevelDirs.size(), 0);
+  for (const auto& dir : firstLevelDirs) {
+    const auto name = dirName(dir);
+    ASSERT_TRUE(name.find("c_int=") != std::string::npos)
+        << "First level directory " << name << " should use identity transform";
+
+    auto secondLevelDirs = firstLevelDirectories(dir);
+    ASSERT_GT(secondLevelDirs.size(), 0)
+        << "No second level directories found in " << dir;
+
+    for (const auto& secondDir : secondLevelDirs) {
+      const auto secondName = dirName(secondDir);
+      ASSERT_TRUE(secondName.find("c_int_trunc=") != std::string::npos)
+          << "Second level directory " << secondName
+          << " should use truncate transform";
+
+      auto thirdLevelDirs = firstLevelDirectories(secondDir);
+      ASSERT_GT(thirdLevelDirs.size(), 0)
+          << "No third level directories found in " << secondDir;
+
+      for (const auto& thirdDir : thirdLevelDirs) {
+        const auto thirdName = dirName(thirdDir);
+        ASSERT_TRUE(thirdName.find("c_int_bucket=") != std::string::npos)
+            << "Third level directory " << thirdName
+            << " should use bucket transform";
+
+        // Verify the partition has data.
+        auto splits = createSplitsForDirectory(thirdDir);
+        auto countPlan = PlanBuilder()
+                             .startTableScan()
+                             .connectorId(test::kIcebergConnectorId)
+                             .outputType(rowType)
+                             .endTableScan()
+                             .planNode();
+        auto rowCount =
+            AssertQueryBuilder(countPlan).splits(splits).countResults();
+        ASSERT_GT(rowCount, 0)
+            << "Leaf partition directory " << thirdDir << " has no data";
+      }
+    }
+  }
+}
+#endif
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/TransformTest.cpp b/velox/connectors/hive/iceberg/tests/TransformTest.cpp
new file mode 100644
index 000000000000..a0e19a916e62
--- /dev/null
+++ b/velox/connectors/hive/iceberg/tests/TransformTest.cpp
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/IcebergConnector.h"
+
+#include "velox/common/encode/Base64.h"
+#include "velox/connectors/hive/iceberg/PartitionSpec.h"
+#include "velox/connectors/hive/iceberg/TransformEvaluator.h"
+#include "velox/connectors/hive/iceberg/TransformExprBuilder.h"
+#include "velox/connectors/hive/iceberg/tests/IcebergTestBase.h"
+
+namespace facebook::velox::connector::hive::iceberg {
+
+namespace {
+
+class TransformTest : public test::IcebergTestBase {
+ protected:
+  void testTransform(
+      const IcebergPartitionSpecPtr& spec,
+      const RowVectorPtr& input,
+      const RowVectorPtr& expected) const {
+    std::vector<column_index_t> partitionChannels;
+    for (const auto& field : spec->fields) {
+      partitionChannels.push_back(input->rowType()->getChildIdx(field.name));
+    }
+    // Build and evaluate transform expressions.
+    auto transformExprs = TransformExprBuilder::toExpressions(
+        spec,
+        partitionChannels,
+        input->rowType(),
+        std::string(kDefaultIcebergFunctionPrefix));
+    auto transformEvaluator = std::make_unique<TransformEvaluator>(
+        transformExprs, connectorQueryCtx_.get());
+    auto result = transformEvaluator->evaluate(input);
+
+    ASSERT_EQ(result.size(), expected->childrenSize());
+    for (auto i = 0; i < result.size(); ++i) {
+      velox::test::assertEqualVectors(expected->childAt(i), result[i]);
+    }
+  }
+};
+
+TEST_F(TransformTest, identity) {
+  const auto& rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4"},
+          {INTEGER(), BIGINT(), VARCHAR(), VARBINARY(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kIdentity, std::nullopt},
+          {1, TransformType::kIdentity, std::nullopt},
+          {2, TransformType::kIdentity, std::nullopt},
+          {3, TransformType::kIdentity, std::nullopt},
+          {4, TransformType::kIdentity, std::nullopt},
+      });
+
+  const std::vector<VectorPtr> input = {
+      makeFlatVector<int32_t>({1, -1}),
+      makeFlatVector<int64_t>({1L, -1L}),
+      makeFlatVector<std::string>({("test data"), ("")}),
+      makeFlatVector<std::string>({("\x01\x02\x03"), ("")}, VARBINARY()),
+      makeFlatVector<Timestamp>({Timestamp(0, 0), Timestamp(1609459200, 0)}),
+  };
+
+  testTransform(partitionSpec, makeRowVector(input), makeRowVector(input));
+}
+
+TEST_F(TransformTest, nulls) {
+  const auto& rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6"},
+          {INTEGER(),
+           VARCHAR(),
+           VARBINARY(),
+           DATE(),
+           TIMESTAMP(),
+           TIMESTAMP(),
+           TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kIdentity, std::nullopt},
+          {1, TransformType::kBucket, 8},
+          {2, TransformType::kTruncate, 16},
+          {3, TransformType::kYear, std::nullopt},
+          {4, TransformType::kMonth, std::nullopt},
+          {5, TransformType::kDay, std::nullopt},
+          {6, TransformType::kHour, std::nullopt},
+      });
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<std::string>({std::nullopt}),
+          makeNullableFlatVector<std::string>({std::nullopt}, VARBINARY()),
+          makeNullableFlatVector<int32_t>({std::nullopt}, DATE()),
+          makeNullableFlatVector<Timestamp>({std::nullopt}),
+          makeNullableFlatVector<Timestamp>({std::nullopt}),
+          makeNullableFlatVector<Timestamp>({std::nullopt}),
+      }),
+      makeRowVector({
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<std::string>({std::nullopt}, VARBINARY()),
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+          makeNullableFlatVector<int32_t>({std::nullopt}, DATE()),
+          makeNullableFlatVector<int32_t>({std::nullopt}),
+      }));
+}
+
+TEST_F(TransformTest, bucket) {
+  const auto& rowType =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+          {INTEGER(), BIGINT(), VARCHAR(), VARBINARY(), DATE(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kBucket, 4},
+          {1, TransformType::kBucket, 8},
+          {2, TransformType::kBucket, 16},
+          {3, TransformType::kBucket, 32},
+          {4, TransformType::kBucket, 10},
+          {5, TransformType::kBucket, 8},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({8, 34, 0}),
+          makeFlatVector<int64_t>({34L, 0L, -34L}),
+          makeFlatVector<std::string>({"abcdefg", "测试", ""}),
+          makeFlatVector<std::string>(
+              {"\x61\x62\x64\x00\x00", "\x01\x02\x03\x04", "\x00"},
+              VARBINARY()),
+          makeFlatVector<int32_t>({0, 365, 18'262}),
+          makeFlatVector<Timestamp>(
+              {Timestamp(0, 0),
+               Timestamp(-31536000, 0),
+               Timestamp(1612224000, 0)}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({3, 3, 0}),
+          makeFlatVector<int32_t>({3, 4, 5}),
+          makeFlatVector<int32_t>({6, 8, 0}),
+          makeFlatVector<int32_t>({26, 5, 0}),
+          makeFlatVector<int32_t>({6, 1, 3}),
+          makeFlatVector<int32_t>({4, 3, 5}),
+      }));
+}
+
+TEST_F(TransformTest, year) {
+  const auto& rowType = ROW({"c0", "c1"}, {DATE(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kYear, std::nullopt},
+          {1, TransformType::kYear, std::nullopt},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 18'262, -365}),
+          makeFlatVector<Timestamp>(
+              {Timestamp(0, 0),
+               Timestamp(31536000, 0),
+               Timestamp(-31536000, 0)}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 50, -1}),
+          makeFlatVector<int32_t>({0, 1, -1}),
+      }));
+}
+
+TEST_F(TransformTest, month) {
+  const auto& rowType = ROW({"c0", "c1"}, {DATE(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kMonth, std::nullopt},
+          {1, TransformType::kMonth, std::nullopt},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 18'262, -365}),
+          makeFlatVector<Timestamp>(
+              {Timestamp(0, 0),
+               Timestamp(31536000, 0),
+               Timestamp(-2678400, 0)}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 600, -12}),
+          makeFlatVector<int32_t>({0, 12, -1}),
+      }));
+}
+
+TEST_F(TransformTest, day) {
+  const auto& rowType = ROW({"c0", "c1"}, {DATE(), TIMESTAMP()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kDay, std::nullopt},
+          {1, TransformType::kDay, std::nullopt},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 17532, -1}, DATE()),
+          makeFlatVector<Timestamp>(
+              {Timestamp(0, 0),
+               Timestamp(1514764800, 0),
+               Timestamp(-86400, 0)}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 17532, -1}, DATE()),
+          makeFlatVector<int32_t>({0, 17532, -1}, DATE()),
+      }));
+}
+
+TEST_F(TransformTest, hour) {
+  const auto& partitionSpec = createPartitionSpec(
+      ROW({"c0"}, {TIMESTAMP()}), {{0, TransformType::kHour, std::nullopt}});
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({makeFlatVector<Timestamp>({
+          Timestamp(0, 0),
+          Timestamp(3600, 0),
+          Timestamp(-3600, 0),
+      })}),
+      makeRowVector({makeFlatVector<int32_t>({0, 1, -1})}));
+}
+
+TEST_F(TransformTest, truncate) {
+  const auto& rowType = ROW(
+      {"c0", "c1", "c2", "c3"}, {INTEGER(), BIGINT(), VARCHAR(), VARBINARY()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kTruncate, 10},
+          {1, TransformType::kTruncate, 100},
+          {2, TransformType::kTruncate, 5},
+          {3, TransformType::kTruncate, 3},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({11, -11, 5}),
+          makeFlatVector<int64_t>({123L, -123L, 50L}),
+          makeFlatVector<std::string>({"abcdefg", "测试data", "x"}),
+          makeFlatVector<std::string>(
+              {"abcdefg", "\x01\x02\x03\x04", "\x05"}, VARBINARY()),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({10, -20, 0}),
+          makeFlatVector<int64_t>({100L, -200L, 0L}),
+          makeFlatVector<std::string>({"abcde", "测试dat", "x"}),
+          makeFlatVector<std::string>(
+              {"abc", "\x01\x02\x03", "\x05"}, VARBINARY()),
+      }));
+}
+
+TEST_F(TransformTest, multipleTransforms) {
+  const auto& rowType = ROW({"c0", "c1", "c2"}, {INTEGER(), DATE(), VARCHAR()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kBucket, 4},
+          {1, TransformType::kYear, std::nullopt},
+          {2, TransformType::kTruncate, 3},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector({
+          makeFlatVector<int32_t>({8, 34}),
+          makeFlatVector<int32_t>({0, 17532}),
+          makeFlatVector<std::string>({"abcdefg", "ab c"}),
+      }),
+      makeRowVector({
+          makeFlatVector<int32_t>({3, 3}),
+          makeFlatVector<int32_t>({0, 48}),
+          makeFlatVector<std::string>({"abc", "ab "}),
+      }));
+}
+
+TEST_F(TransformTest, multipleTransformsOnSameColumn) {
+  const auto& rowType = ROW({"c0", "c1"}, {DATE(), VARCHAR()});
+  const auto& partitionSpec = createPartitionSpec(
+      rowType,
+      {
+          {0, TransformType::kYear, std::nullopt},
+          {0, TransformType::kBucket, 10},
+          {1, TransformType::kTruncate, 5},
+          {1, TransformType::kBucket, 8},
+      });
+
+  testTransform(
+      partitionSpec,
+      makeRowVector(
+          rowType->names(),
+          {
+              makeFlatVector<int32_t>({0, 17532}),
+              makeFlatVector<std::string>({"abcdefg", "test"}),
+          }),
+      makeRowVector({
+          makeFlatVector<int32_t>({0, 48}),
+          makeFlatVector<int32_t>({6, 7}),
+          makeFlatVector<std::string>({"abcde", "test"}),
+          makeFlatVector<int32_t>({6, 3}),
+      }));
+}
+
+} // namespace
+
+} // namespace facebook::velox::connector::hive::iceberg
diff --git a/velox/connectors/hive/iceberg/tests/examples/three_groups.parquet b/velox/connectors/hive/iceberg/tests/examples/three_groups.parquet
new file mode 100644
index 000000000000..cfedba43474b
Binary files /dev/null and b/velox/connectors/hive/iceberg/tests/examples/three_groups.parquet differ
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsConfig.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsConfig.cpp
deleted file mode 100644
index 7604e3ef3b69..000000000000
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsConfig.cpp
+++ /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.
- */
-
-#include "velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h"
-
-#include "velox/common/config/Config.h"
-#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
-
-#include <azure/identity/client_secret_credential.hpp>
-
-namespace facebook::velox::filesystems {
-
-std::function<std::unique_ptr<AzureDataLakeFileClient>()>
-    AbfsConfig::testWriteClientFn_;
-
-class DataLakeFileClientWrapper final : public AzureDataLakeFileClient {
- public:
-  DataLakeFileClientWrapper(std::unique_ptr<DataLakeFileClient> client)
-      : client_(std::move(client)) {}
-
-  void create() override {
-    client_->Create();
-  }
-
-  Azure::Storage::Files::DataLake::Models::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.
-  }
-
-  std::string getUrl() const override {
-    return client_->GetUrl();
-  }
-
- private:
-  const std::unique_ptr<DataLakeFileClient> client_;
-};
-
-AbfsConfig::AbfsConfig(
-    std::string_view path,
-    const config::ConfigBase& config) {
-  std::string_view file;
-  isHttps_ = true;
-  if (path.find(kAbfssScheme) == 0) {
-    file = path.substr(kAbfssScheme.size());
-  } else if (path.find(kAbfsScheme) == 0) {
-    file = path.substr(kAbfsScheme.size());
-    isHttps_ = false;
-  } else {
-    VELOX_FAIL("Invalid ABFS Path {}", path);
-  }
-
-  auto firstAt = file.find_first_of("@");
-  fileSystem_ = file.substr(0, firstAt);
-  auto firstSep = file.find_first_of("/");
-  filePath_ = file.substr(firstSep + 1);
-  accountNameWithSuffix_ = file.substr(firstAt + 1, firstSep - firstAt - 1);
-
-  auto authTypeKey =
-      fmt::format("{}.{}", kAzureAccountAuthType, accountNameWithSuffix_);
-  authType_ = kAzureSharedKeyAuthType;
-  if (config.valueExists(authTypeKey)) {
-    authType_ = config.get<std::string>(authTypeKey).value();
-  }
-  if (authType_ == kAzureSharedKeyAuthType) {
-    auto credKey =
-        fmt::format("{}.{}", kAzureAccountKey, accountNameWithSuffix_);
-    VELOX_USER_CHECK(
-        config.valueExists(credKey), "Config {} not found", credKey);
-    auto firstDot = accountNameWithSuffix_.find_first_of(".");
-    auto accountName = accountNameWithSuffix_.substr(0, firstDot);
-    auto endpointSuffix = accountNameWithSuffix_.substr(firstDot + 5);
-    std::stringstream ss;
-    ss << "DefaultEndpointsProtocol=" << (isHttps_ ? "https" : "http");
-    ss << ";AccountName=" << accountName;
-    ss << ";AccountKey=" << config.get<std::string>(credKey).value();
-    ss << ";EndpointSuffix=" << endpointSuffix;
-
-    if (config.valueExists(kAzureBlobEndpoint)) {
-      ss << ";BlobEndpoint="
-         << config.get<std::string>(kAzureBlobEndpoint).value();
-    }
-    ss << ";";
-    connectionString_ = ss.str();
-  } else if (authType_ == kAzureOAuthAuthType) {
-    auto clientIdKey = fmt::format(
-        "{}.{}", kAzureAccountOAuth2ClientId, accountNameWithSuffix_);
-    auto clientSecretKey = fmt::format(
-        "{}.{}", kAzureAccountOAuth2ClientSecret, accountNameWithSuffix_);
-    auto clientEndpointKey = fmt::format(
-        "{}.{}", kAzureAccountOAuth2ClientEndpoint, accountNameWithSuffix_);
-    VELOX_USER_CHECK(
-        config.valueExists(clientIdKey), "Config {} not found", clientIdKey);
-    VELOX_USER_CHECK(
-        config.valueExists(clientSecretKey),
-        "Config {} not found",
-        clientSecretKey);
-    VELOX_USER_CHECK(
-        config.valueExists(clientEndpointKey),
-        "Config {} not found",
-        clientEndpointKey);
-    auto clientEndpoint = config.get<std::string>(clientEndpointKey).value();
-    auto firstSep = clientEndpoint.find_first_of("/", /* https:// */ 8);
-    authorityHost_ = clientEndpoint.substr(0, firstSep + 1);
-    auto sedondSep = clientEndpoint.find_first_of("/", firstSep + 1);
-    tenentId_ = clientEndpoint.substr(firstSep + 1, sedondSep - firstSep - 1);
-    Azure::Identity::ClientSecretCredentialOptions options;
-    options.AuthorityHost = authorityHost_;
-    tokenCredential_ =
-        std::make_shared<Azure::Identity::ClientSecretCredential>(
-            tenentId_,
-            config.get<std::string>(clientIdKey).value(),
-            config.get<std::string>(clientSecretKey).value(),
-            options);
-  } else if (authType_ == kAzureSASAuthType) {
-    auto sasKey = fmt::format("{}.{}", kAzureSASKey, accountNameWithSuffix_);
-    VELOX_USER_CHECK(config.valueExists(sasKey), "Config {} not found", sasKey);
-    sas_ = config.get<std::string>(sasKey).value();
-  } else {
-    VELOX_USER_FAIL(
-        "Unsupported auth type {}, supported auth types are SharedKey, OAuth and SAS.",
-        authType_);
-  }
-}
-
-std::unique_ptr<BlobClient> AbfsConfig::getReadFileClient() {
-  if (authType_ == kAzureSASAuthType) {
-    auto url = getUrl(true);
-    return std::make_unique<BlobClient>(fmt::format("{}?{}", url, sas_));
-  } else if (authType_ == kAzureOAuthAuthType) {
-    auto url = getUrl(true);
-    return std::make_unique<BlobClient>(url, tokenCredential_);
-  } else {
-    return std::make_unique<BlobClient>(BlobClient::CreateFromConnectionString(
-        connectionString_, fileSystem_, filePath_));
-  }
-}
-
-std::unique_ptr<AzureDataLakeFileClient> AbfsConfig::getWriteFileClient() {
-  if (testWriteClientFn_) {
-    return testWriteClientFn_();
-  }
-  std::unique_ptr<DataLakeFileClient> client;
-  if (authType_ == kAzureSASAuthType) {
-    auto url = getUrl(false);
-    client =
-        std::make_unique<DataLakeFileClient>(fmt::format("{}?{}", url, sas_));
-  } else if (authType_ == kAzureOAuthAuthType) {
-    auto url = getUrl(false);
-    client = std::make_unique<DataLakeFileClient>(url, tokenCredential_);
-  } else {
-    client = std::make_unique<DataLakeFileClient>(
-        DataLakeFileClient::CreateFromConnectionString(
-            connectionString_, fileSystem_, filePath_));
-  }
-  return std::make_unique<DataLakeFileClientWrapper>(std::move(client));
-}
-
-std::string AbfsConfig::getUrl(bool withblobSuffix) {
-  std::string accountNameWithSuffixForUrl(accountNameWithSuffix_);
-  if (withblobSuffix) {
-    // We should use correct suffix for blob client.
-    size_t start_pos = accountNameWithSuffixForUrl.find("dfs");
-    if (start_pos != std::string::npos) {
-      accountNameWithSuffixForUrl.replace(start_pos, 3, "blob");
-    }
-  }
-  return fmt::format(
-      "{}{}/{}/{}",
-      isHttps_ ? "https://" : "http://",
-      accountNameWithSuffixForUrl,
-      fileSystem_,
-      filePath_);
-}
-
-} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.cpp
index 18fbd3f2284a..e5877f74638b 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.cpp
@@ -20,198 +20,14 @@
 #include <folly/executors/IOThreadPoolExecutor.h>
 #include <glog/logging.h>
 
-#include "velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
 
 namespace facebook::velox::filesystems {
 
-class AbfsReadFile::Impl {
-  constexpr static uint64_t kNaturalReadSize = 4 << 20; // 4M
-  constexpr static uint64_t kReadConcurrency = 8;
-
- public:
-  explicit Impl(std::string_view path, const config::ConfigBase& config) {
-    auto abfsConfig = AbfsConfig(path, config);
-    filePath_ = abfsConfig.filePath();
-    fileClient_ = abfsConfig.getReadFileClient();
-  }
-
-  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", filePath_, e);
-    }
-    VELOX_CHECK_GE(length_, 0);
-  }
-
-  std::string_view pread(
-      uint64_t offset,
-      uint64_t length,
-      void* buffer,
-      File::IoStats* stats) const {
-    preadInternal(offset, length, static_cast<char*>(buffer));
-    return {static_cast<char*>(buffer), length};
-  }
-
-  std::string pread(uint64_t offset, uint64_t length, File::IoStats* stats)
-      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,
-      File::IoStats* stats) 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,
-      File::IoStats* stats) 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(), stats);
-      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 filePath_;
-  }
-
-  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 filePath_;
-  std::unique_ptr<BlobClient> fileClient_;
-  int64_t length_ = -1;
-};
-
-AbfsReadFile::AbfsReadFile(
-    std::string_view path,
-    const config::ConfigBase& config) {
-  impl_ = std::make_shared<Impl>(path, config);
-}
-
-void AbfsReadFile::initialize(const FileOptions& options) {
-  return impl_->initialize(options);
-}
-
-std::string_view AbfsReadFile::pread(
-    uint64_t offset,
-    uint64_t length,
-    void* buffer,
-    File::IoStats* stats) const {
-  return impl_->pread(offset, length, buffer, stats);
-}
-
-std::string AbfsReadFile::pread(
-    uint64_t offset,
-    uint64_t length,
-    File::IoStats* stats) const {
-  return impl_->pread(offset, length, stats);
-}
-
-uint64_t AbfsReadFile::preadv(
-    uint64_t offset,
-    const std::vector<folly::Range<char*>>& buffers,
-    File::IoStats* stats) const {
-  return impl_->preadv(offset, buffers, stats);
-}
-
-uint64_t AbfsReadFile::preadv(
-    folly::Range<const common::Region*> regions,
-    folly::Range<folly::IOBuf*> iobufs,
-    File::IoStats* stats) const {
-  return impl_->preadv(regions, iobufs, stats);
-}
-
-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();
-}
-
 AbfsFileSystem::AbfsFileSystem(std::shared_ptr<const config::ConfigBase> config)
     : FileSystem(config) {
   VELOX_CHECK_NOT_NULL(config.get());
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h b/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h
index c0d3d60ccdee..8a838ee17719 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h
@@ -19,7 +19,7 @@
 
 namespace facebook::velox::filesystems {
 
-/// Implementation of the ABS (Azure Blob Storage) filesystem and file
+/// Implementation of the ABFS (Azure Blob File 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
@@ -76,5 +76,4 @@ class AbfsFileSystem : public FileSystem {
   }
 };
 
-void registerAbfsFileSystem();
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsPath.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsPath.cpp
new file mode 100644
index 000000000000..b6ba75cbcbfe
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsPath.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/AbfsPath.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+
+namespace facebook::velox::filesystems {
+
+AbfsPath::AbfsPath(std::string_view path) {
+  std::string_view file;
+  isHttps_ = true;
+  if (path.find(kAbfssScheme) == 0) {
+    file = path.substr(kAbfssScheme.size());
+  } else if (path.find(kAbfsScheme) == 0) {
+    file = path.substr(kAbfsScheme.size());
+    isHttps_ = false;
+  } else {
+    VELOX_FAIL("Invalid ABFS Path {}", path);
+  }
+
+  auto firstAt = file.find_first_of("@");
+  fileSystem_ = file.substr(0, firstAt);
+  auto firstSep = file.find_first_of("/");
+  filePath_ = file.substr(firstSep + 1);
+  accountNameWithSuffix_ = file.substr(firstAt + 1, firstSep - firstAt - 1);
+  auto firstDot = accountNameWithSuffix_.find_first_of(".");
+  accountName_ = accountNameWithSuffix_.substr(0, firstDot);
+}
+
+std::string AbfsPath::getUrl(bool withblobSuffix) const {
+  std::string accountNameWithSuffixForUrl(accountNameWithSuffix_);
+  if (withblobSuffix) {
+    // We should use correct suffix for blob client.
+    size_t startPos = accountNameWithSuffixForUrl.find("dfs");
+    if (startPos != std::string::npos) {
+      accountNameWithSuffixForUrl.replace(startPos, 3, "blob");
+    }
+  }
+  return fmt::format(
+      "{}{}/{}/{}",
+      isHttps_ ? "https://" : "http://",
+      accountNameWithSuffixForUrl,
+      fileSystem_,
+      filePath_);
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h b/velox/connectors/hive/storage_adapters/abfs/AbfsPath.h
similarity index 65%
rename from velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h
rename to velox/connectors/hive/storage_adapters/abfs/AbfsPath.h
index af4b46708d86..3a4e0d99f097 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsPath.h
@@ -16,20 +16,13 @@
 
 #pragma once
 
-#include <azure/core/credentials/credentials.hpp>
-#include <azure/storage/blobs/blob_client.hpp>
 #include <azure/storage/files/datalake.hpp>
 #include <folly/hash/Hash.h>
 #include <string>
-#include "velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h"
 
 using namespace Azure::Storage::Blobs;
 using namespace Azure::Storage::Files::DataLake;
 
-namespace facebook::velox::config {
-class ConfigBase;
-}
-
 namespace facebook::velox::filesystems {
 
 // This is used to specify the Azurite endpoint in testing.
@@ -61,70 +54,48 @@ static constexpr const char* kAzureOAuthAuthType = "OAuth";
 
 static constexpr const char* kAzureSASAuthType = "SAS";
 
-class AbfsConfig {
- public:
-  explicit AbfsConfig(std::string_view path, const config::ConfigBase& config);
-
-  std::unique_ptr<BlobClient> getReadFileClient();
+// For performance, re - use SAS tokens until the expiry is within this number
+// of seconds.
+static constexpr const char* kAzureSasTokenRenewPeriod =
+    "fs.azure.sas.token.renew.period.for.streams";
 
-  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient();
+// Helper class to parse and extract information from a given ABFS path.
+class AbfsPath {
+ public:
+  AbfsPath(std::string_view path);
 
-  std::string filePath() const {
-    return filePath_;
+  bool isHttps() const {
+    return isHttps_;
   }
 
-  /// Test only.
   std::string fileSystem() const {
     return fileSystem_;
   }
 
-  /// Test only.
-  std::string connectionString() const {
-    return connectionString_;
-  }
-
-  /// Test only.
-  std::string tenentId() const {
-    return tenentId_;
+  std::string filePath() const {
+    return filePath_;
   }
 
-  /// Test only.
-  std::string authorityHost() const {
-    return authorityHost_;
+  std::string accountName() const {
+    return accountName_;
   }
 
-  /// Test only.
-  static void setUpTestWriteClient(
-      std::function<std::unique_ptr<AzureDataLakeFileClient>()> testClientFn) {
-    testWriteClientFn_ = testClientFn;
+  std::string accountNameWithSuffix() const {
+    return accountNameWithSuffix_;
   }
 
-  /// Test only.
-  static void tearDownTestWriteClient() {
-    testWriteClientFn_ = nullptr;
-  }
+  std::string getUrl(bool withblobSuffix) const;
 
  private:
-  std::string getUrl(bool withblobSuffix);
-
-  std::string authType_;
+  bool isHttps_;
 
   // Container name is called FileSystem in some Azure API.
   std::string fileSystem_;
   std::string filePath_;
   std::string connectionString_;
 
-  bool isHttps_;
+  std::string accountName_;
   std::string accountNameWithSuffix_;
-
-  std::string sas_;
-
-  std::string tenentId_;
-  std::string authorityHost_;
-  std::shared_ptr<Azure::Core::Credentials::TokenCredential> tokenCredential_;
-
-  static std::function<std::unique_ptr<AzureDataLakeFileClient>()>
-      testWriteClientFn_;
 };
 
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.cpp
new file mode 100644
index 000000000000..575f1f2de572
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.cpp
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/AbfsReadFile.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
+
+namespace facebook::velox::filesystems {
+
+class AbfsReadFile::Impl {
+  constexpr static uint64_t kNaturalReadSize = 4 << 20; // 4M
+  constexpr static uint64_t kReadConcurrency = 8;
+
+ public:
+  explicit Impl(std::string_view path, const config::ConfigBase& config) {
+    auto abfsPath = std::make_shared<AbfsPath>(path);
+    filePath_ = abfsPath->filePath();
+    fileClient_ =
+        AzureClientProviderFactories::getReadFileClient(abfsPath, config);
+  }
+
+  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", filePath_, e);
+    }
+    VELOX_CHECK_GE(length_, 0);
+  }
+
+  std::string_view pread(
+      uint64_t offset,
+      uint64_t length,
+      void* buffer,
+      const FileStorageContext& fileStorageContext) const {
+    preadInternal(offset, length, static_cast<char*>(buffer));
+    return {static_cast<char*>(buffer), length};
+  }
+
+  std::string pread(
+      uint64_t offset,
+      uint64_t length,
+      const FileStorageContext& fileStorageContext) 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 FileStorageContext& fileStorageContext) 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 FileStorageContext& fileStorageContext) 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(),
+          fileStorageContext);
+      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 filePath_;
+  }
+
+  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 filePath_;
+  std::unique_ptr<AzureBlobClient> fileClient_;
+  int64_t length_ = -1;
+};
+
+AbfsReadFile::AbfsReadFile(
+    std::string_view path,
+    const config::ConfigBase& config) {
+  impl_ = std::make_shared<Impl>(path, config);
+}
+
+void AbfsReadFile::initialize(const FileOptions& options) {
+  return impl_->initialize(options);
+}
+
+std::string_view AbfsReadFile::pread(
+    uint64_t offset,
+    uint64_t length,
+    void* buffer,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->pread(offset, length, buffer, fileStorageContext);
+}
+
+std::string AbfsReadFile::pread(
+    uint64_t offset,
+    uint64_t length,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->pread(offset, length, fileStorageContext);
+}
+
+uint64_t AbfsReadFile::preadv(
+    uint64_t offset,
+    const std::vector<folly::Range<char*>>& buffers,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->preadv(offset, buffers, fileStorageContext);
+}
+
+uint64_t AbfsReadFile::preadv(
+    folly::Range<const common::Region*> regions,
+    folly::Range<folly::IOBuf*> iobufs,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->preadv(regions, iobufs, fileStorageContext);
+}
+
+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();
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h
index 942439c06c1e..b682926ad1af 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsReadFile.h
@@ -35,22 +35,22 @@ class AbfsReadFile final : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      File::IoStats* stats = nullptr) const final;
+      const FileStorageContext& fileStorageContext = {}) const final;
 
   std::string pread(
       uint64_t offset,
       uint64_t length,
-      File::IoStats* stats = nullptr) const final;
+      const FileStorageContext& fileStorageContext = {}) const final;
 
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      File::IoStats* stats = nullptr) const final;
+      const FileStorageContext& fileStorageContext = {}) const final;
 
   uint64_t preadv(
       folly::Range<const common::Region*> regions,
       folly::Range<folly::IOBuf*> iobufs,
-      File::IoStats* stats = nullptr) const final;
+      const FileStorageContext& fileStorageContext = {}) const final;
 
   uint64_t size() const final;
 
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.cpp
new file mode 100644
index 000000000000..5aefc0983867
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.cpp
@@ -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 "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+#include "velox/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
+
+namespace facebook::velox::filesystems {
+
+std::vector<CacheKey> extractCacheKeyFromConfig(
+    const config::ConfigBase& config) {
+  std::vector<CacheKey> cacheKeys;
+  constexpr std::string_view authTypePrefix{kAzureAccountAuthType};
+  for (const auto& [key, value] : config.rawConfigs()) {
+    if (key.find(authTypePrefix) == 0) {
+      // Extract the accountName after "fs.azure.account.auth.type.".
+      auto remaining = std::string_view(key).substr(authTypePrefix.size() + 1);
+      auto dot = remaining.find(".");
+      VELOX_USER_CHECK_NE(
+          dot,
+          std::string_view::npos,
+          "Invalid Azure account auth type key: {}",
+          key);
+      cacheKeys.emplace_back(CacheKey{remaining.substr(0, dot), value});
+    }
+  }
+  return cacheKeys;
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h
index 925c6f91ece9..1a6cf6e0a0e7 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h
@@ -26,6 +26,16 @@ constexpr std::string_view kAbfsScheme{"abfs://"};
 constexpr std::string_view kAbfssScheme{"abfss://"};
 } // namespace
 
+class ConfigBase;
+
+struct CacheKey {
+  const std::string accountName;
+  const std::string authType;
+
+  CacheKey(std::string_view accountName, std::string_view authType)
+      : accountName(accountName), authType(authType) {}
+};
+
 inline bool isAbfsFile(const std::string_view filename) {
   return filename.find(kAbfsScheme) == 0 || filename.find(kAbfssScheme) == 0;
 }
@@ -45,4 +55,7 @@ inline std::string throwStorageExceptionWithOperationDetails(
   VELOX_FAIL(errMsg);
 }
 
+std::vector<CacheKey> extractCacheKeyFromConfig(
+    const config::ConfigBase& config);
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.cpp b/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.cpp
index 2ba015743a0d..5db3b535b386 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.cpp
@@ -15,8 +15,10 @@
  */
 
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsWriteFile.h"
-#include "velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h"
+
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
 
 namespace facebook::velox::filesystems {
 
@@ -88,8 +90,9 @@ class AbfsWriteFile::Impl {
 AbfsWriteFile::AbfsWriteFile(
     std::string_view path,
     const config::ConfigBase& config) {
-  auto abfsConfig = AbfsConfig(path, config);
-  auto client = abfsConfig.getWriteFileClient();
+  const auto abfsPath = std::make_shared<AbfsPath>(path);
+  auto client =
+      AzureClientProviderFactories::getWriteFileClient(abfsPath, config);
   impl_ = std::make_unique<Impl>(path, client);
 }
 
diff --git a/velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.h b/velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.h
new file mode 100644
index 000000000000..d633ac7fdbae
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.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 <azure/storage/blobs/blob_client.hpp>
+
+namespace facebook::velox::filesystems {
+
+// Interface for Azure Blob Storage client operations.
+class AzureBlobClient {
+ public:
+  virtual ~AzureBlobClient() {}
+
+  virtual Azure::Response<Azure::Storage::Blobs::Models::BlobProperties>
+  getProperties() = 0;
+
+  virtual Azure::Response<Azure::Storage::Blobs::Models::DownloadBlobResult>
+  download(const Azure::Storage::Blobs::DownloadBlobOptions& options) = 0;
+
+  virtual std::string getUrl() = 0;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h b/velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h
new file mode 100644
index 000000000000..1a1a68f6d87f
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.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/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h"
+
+namespace facebook::velox::filesystems {
+
+// Provider interface for creating Azure Blob and Data Lake clients.
+class AzureClientProvider {
+ public:
+  virtual ~AzureClientProvider() = default;
+
+  // Creates AzureBlobClient for file read operations.
+  virtual std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& path,
+      const config::ConfigBase& config) = 0;
+
+  // Creates AzureDataLakeFileClient for file write operations.
+  virtual std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& path,
+      const config::ConfigBase& config) = 0;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.cpp b/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.cpp
new file mode 100644
index 000000000000..cbd0ae54859f
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.cpp
@@ -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.
+ */
+
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h"
+
+#include <folly/Synchronized.h>
+
+namespace facebook::velox::filesystems {
+
+namespace {
+
+folly::Synchronized<
+    std::unordered_map<std::string, AzureClientProviderFactory>>&
+azureClientFactoryRegistry() {
+  static folly::Synchronized<
+      std::unordered_map<std::string, AzureClientProviderFactory>>
+      factories;
+  return factories;
+}
+
+} // namespace
+
+void AzureClientProviderFactories::registerFactory(
+    const std::string& account,
+    const AzureClientProviderFactory& factory) {
+  azureClientFactoryRegistry().withWLock([&](auto& factories) {
+    auto [_, inserted] = factories.insert_or_assign(account, factory);
+    LOG_IF(INFO, !inserted) << "AzureClientProviderFactory for account '"
+                            << account << "' has been overridden.";
+  });
+}
+
+AzureClientProviderFactory AzureClientProviderFactories::getClientFactory(
+    const std::string& account) {
+  return azureClientFactoryRegistry().withRLock(
+      [&](const auto& factories) -> AzureClientProviderFactory {
+        if (auto it = factories.find(account); it != factories.end()) {
+          return it->second;
+        }
+        VELOX_USER_FAIL(
+            "No AzureClientProviderFactory registered for account '{}'."
+            "Please use `registerAzureClientProvider` or "
+            "`registerAzureClientProviderFactory` to register a factory for "
+            "the account before using it.",
+            account);
+      });
+}
+
+std::unique_ptr<AzureBlobClient>
+AzureClientProviderFactories::getReadFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  auto factory = getClientFactory(abfsPath->accountName());
+  return factory(abfsPath->accountName())->getReadFileClient(abfsPath, config);
+}
+
+std::unique_ptr<AzureDataLakeFileClient>
+AzureClientProviderFactories::getWriteFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  auto factory = getClientFactory(abfsPath->accountName());
+  return factory(abfsPath->accountName())->getWriteFileClient(abfsPath, config);
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h b/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h
new file mode 100644
index 000000000000..6c2af30aa985
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.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/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h"
+
+namespace facebook::velox::filesystems {
+
+using AzureClientProviderFactory =
+    std::function<std::unique_ptr<AzureClientProvider>(
+        const std::string& account)>;
+
+/// Handles the registration of Azure client providers and the creation of
+/// AzureBlobClient and AzureDataLakeFileClient instances.
+class AzureClientProviderFactories {
+ public:
+  /// Registers a factory for creating AzureClientProvider instances.
+  /// Any existing factory registered for the specified account will be
+  /// overwritten by recalling this method with the same account name.
+  static void registerFactory(
+      const std::string& account,
+      const AzureClientProviderFactory& factory);
+
+  /// Get the registered AzureClientProviderFactory for the specified
+  /// account. Throws exception if no factory is registered for the account.
+  static AzureClientProviderFactory getClientFactory(
+      const std::string& account);
+
+  /// Uses the registered AzureClientProviderFactory to create an
+  /// AzureBlobClient for file read operations. Throws exception if no factory
+  /// is registered for the account specified in `abfsPath`.
+  static std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config);
+
+  /// Uses the registered AzureClientProviderFactory to create an
+  /// AzureDataLakeFileClient for file write operations. Throws exception if no
+  /// factory is registered for the account specified in `abfsPath`.
+  static std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config);
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.cpp b/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.cpp
new file mode 100644
index 000000000000..eec80f08f6df
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.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 "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h"
+
+#include <azure/identity/client_secret_credential.hpp>
+
+namespace facebook::velox::filesystems {
+
+namespace {
+
+class DataLakeFileClientWrapper final : public AzureDataLakeFileClient {
+ public:
+  DataLakeFileClientWrapper(std::unique_ptr<DataLakeFileClient> client)
+      : client_(std::move(client)) {}
+
+  void create() override {
+    client_->Create();
+  }
+
+  Azure::Storage::Files::DataLake::Models::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.
+  }
+
+  std::string getUrl() override {
+    return client_->GetUrl();
+  }
+
+ private:
+  const std::unique_ptr<DataLakeFileClient> client_;
+};
+
+class BlobClientWrapper : public AzureBlobClient {
+ public:
+  BlobClientWrapper(std::unique_ptr<Azure::Storage::Blobs::BlobClient> client) {
+    blobClient_ = std::move(client);
+  }
+
+  Azure::Response<Azure::Storage::Blobs::Models::BlobProperties> getProperties()
+      override {
+    return blobClient_->GetProperties();
+  }
+
+  Azure::Response<Azure::Storage::Blobs::Models::DownloadBlobResult> download(
+      const Azure::Storage::Blobs::DownloadBlobOptions& options) override {
+    return blobClient_->Download(options);
+  }
+
+  std::string getUrl() override {
+    return blobClient_->GetUrl();
+  }
+
+ private:
+  std::unique_ptr<Azure::Storage::Blobs::BlobClient> blobClient_;
+};
+
+} // namespace
+
+std::unique_ptr<AzureBlobClient>
+SharedKeyAzureClientProvider::getReadFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  auto client =
+      std::make_unique<BlobClient>(BlobClient::CreateFromConnectionString(
+          connectionString_, abfsPath->fileSystem(), abfsPath->filePath()));
+  return std::make_unique<BlobClientWrapper>(std::move(client));
+}
+
+std::unique_ptr<AzureDataLakeFileClient>
+SharedKeyAzureClientProvider::getWriteFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  auto client = std::make_unique<DataLakeFileClient>(
+      DataLakeFileClient::CreateFromConnectionString(
+          connectionString_, abfsPath->fileSystem(), abfsPath->filePath()));
+  return std::make_unique<DataLakeFileClientWrapper>(std::move(client));
+}
+
+std::string SharedKeyAzureClientProvider::connectionString(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  return connectionString_;
+}
+
+void SharedKeyAzureClientProvider::init(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  auto credKey =
+      fmt::format("{}.{}", kAzureAccountKey, abfsPath->accountNameWithSuffix());
+  VELOX_USER_CHECK(config.valueExists(credKey), "Config {} not found", credKey);
+  auto firstDot = abfsPath->accountNameWithSuffix().find_first_of(".");
+  auto endpointSuffix =
+      abfsPath->accountNameWithSuffix().substr(firstDot + 5 /* .dfs. */);
+  std::stringstream ss;
+  ss << "DefaultEndpointsProtocol=" << (abfsPath->isHttps() ? "https" : "http");
+  ss << ";AccountName=" << abfsPath->accountName();
+  ss << ";AccountKey=" << config.get<std::string>(credKey).value();
+  ss << ";EndpointSuffix=" << endpointSuffix;
+
+  if (config.valueExists(kAzureBlobEndpoint)) {
+    ss << ";BlobEndpoint="
+       << config.get<std::string>(kAzureBlobEndpoint).value();
+  }
+  ss << ";";
+  connectionString_ = ss.str();
+}
+
+std::unique_ptr<AzureBlobClient> OAuthAzureClientProvider::getReadFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  const auto url = abfsPath->getUrl(true);
+  auto client = std::make_unique<BlobClient>(url, tokenCredential_);
+  return std::make_unique<BlobClientWrapper>(std::move(client));
+}
+
+std::unique_ptr<AzureDataLakeFileClient>
+OAuthAzureClientProvider::getWriteFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  const auto url = abfsPath->getUrl(false);
+  auto client = std::make_unique<DataLakeFileClient>(url, tokenCredential_);
+  return std::make_unique<DataLakeFileClientWrapper>(std::move(client));
+}
+
+std::pair<std::string, std::string>
+OAuthAzureClientProvider::tenantIdAndAuthorityHost(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  return {tenentId_, authorityHost_};
+}
+
+void OAuthAzureClientProvider::init(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  auto clientIdKey = fmt::format(
+      "{}.{}", kAzureAccountOAuth2ClientId, abfsPath->accountNameWithSuffix());
+  auto clientSecretKey = fmt::format(
+      "{}.{}",
+      kAzureAccountOAuth2ClientSecret,
+      abfsPath->accountNameWithSuffix());
+  auto clientEndpointKey = fmt::format(
+      "{}.{}",
+      kAzureAccountOAuth2ClientEndpoint,
+      abfsPath->accountNameWithSuffix());
+  VELOX_USER_CHECK(
+      config.valueExists(clientIdKey), "Config {} not found", clientIdKey);
+  VELOX_USER_CHECK(
+      config.valueExists(clientSecretKey),
+      "Config {} not found",
+      clientSecretKey);
+  VELOX_USER_CHECK(
+      config.valueExists(clientEndpointKey),
+      "Config {} not found",
+      clientEndpointKey);
+  auto clientEndpoint = config.get<std::string>(clientEndpointKey).value();
+  // Length of "https://".
+  static const std::size_t kHttpsPrefixLen = 8;
+  auto firstSep = clientEndpoint.find_first_of("/", kHttpsPrefixLen);
+  authorityHost_ = clientEndpoint.substr(0, firstSep + 1);
+  auto sedondSep = clientEndpoint.find_first_of("/", firstSep + 1);
+  tenentId_ = clientEndpoint.substr(firstSep + 1, sedondSep - firstSep - 1);
+  Azure::Identity::ClientSecretCredentialOptions options;
+  options.AuthorityHost = authorityHost_;
+  tokenCredential_ = std::make_shared<Azure::Identity::ClientSecretCredential>(
+      tenentId_,
+      config.get<std::string>(clientIdKey).value(),
+      config.get<std::string>(clientSecretKey).value(),
+      options);
+}
+
+std::unique_ptr<AzureBlobClient> FixedSasAzureClientProvider::getReadFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  const auto url = abfsPath->getUrl(true);
+  auto client = std::make_unique<BlobClient>(fmt::format("{}?{}", url, sas_));
+  return std::make_unique<BlobClientWrapper>(std::move(client));
+}
+
+std::unique_ptr<AzureDataLakeFileClient>
+FixedSasAzureClientProvider::getWriteFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  const auto url = abfsPath->getUrl(false);
+  auto client =
+      std::make_unique<DataLakeFileClient>(fmt::format("{}?{}", url, sas_));
+  return std::make_unique<DataLakeFileClientWrapper>(std::move(client));
+}
+
+std::string FixedSasAzureClientProvider::sas(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(abfsPath, config);
+  return sas_;
+}
+
+void FixedSasAzureClientProvider::init(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  auto sasKey =
+      fmt::format("{}.{}", kAzureSASKey, abfsPath->accountNameWithSuffix());
+  VELOX_USER_CHECK(config.valueExists(sasKey), "Config {} not found", sasKey);
+  sas_ = config.get<std::string>(sasKey).value();
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h b/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h
new file mode 100644
index 000000000000..85293891fcb3
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.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/common/config/Config.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h"
+
+namespace facebook::velox::filesystems {
+
+// AzureClientProvider for Shared Key authentication.
+class SharedKeyAzureClientProvider final : public AzureClientProvider {
+ public:
+  std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+  // Test only.
+  std::string connectionString(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config);
+
+ private:
+  void init(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config);
+
+  std::string connectionString_;
+};
+
+// AzureClientProvider for OAuth authentication.
+class OAuthAzureClientProvider final : public AzureClientProvider {
+ public:
+  std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+  // Test only.
+  std::pair<std::string, std::string> tenantIdAndAuthorityHost(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config);
+
+ private:
+  void init(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config);
+
+  std::string tenentId_;
+  std::string authorityHost_;
+  std::shared_ptr<Azure::Core::Credentials::TokenCredential> tokenCredential_;
+};
+
+// AzureClientProvider for SAS authentication with a fixed SAS token.
+class FixedSasAzureClientProvider final : public AzureClientProvider {
+ public:
+  std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+  // Test only.
+  std::string sas(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config);
+
+ private:
+  void init(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config);
+
+  std::string sas_;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h b/velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h
index abd607c0d1b2..3416bab7c5d8 100644
--- a/velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h
+++ b/velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h
@@ -44,6 +44,6 @@ class AzureDataLakeFileClient {
   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;
-  virtual std::string getUrl() const = 0;
+  virtual std::string getUrl() = 0;
 };
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt
index 799e93830373..136db68d1afd 100644
--- a/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/abfs/CMakeLists.txt
@@ -20,22 +20,30 @@ if(VELOX_ENABLE_ABFS)
   velox_sources(
     velox_abfs
     PRIVATE
-    AbfsFileSystem.cpp
-    AbfsConfig.cpp
-    AbfsWriteFile.cpp)
+      AbfsFileSystem.cpp
+      AbfsPath.cpp
+      AbfsReadFile.cpp
+      AbfsUtil.cpp
+      AbfsWriteFile.cpp
+      AzureClientProviderFactories.cpp
+      AzureClientProviderImpl.cpp
+      DynamicSasTokenClientProvider.cpp
+  )
 
   velox_link_libraries(
     velox_abfs
-    PUBLIC velox_file
-           velox_core
-           velox_hive_config
-           velox_dwio_common_exception
-           Azure::azure-identity
-           Azure::azure-storage-blobs
-           Azure::azure-storage-files-datalake
-           Folly::folly
-           glog::glog
-           fmt::fmt)
+    PUBLIC
+      velox_file
+      velox_core
+      velox_hive_config
+      velox_dwio_common_exception
+      Azure::azure-identity
+      Azure::azure-storage-blobs
+      Azure::azure-storage-files-datalake
+      Folly::folly
+      glog::glog
+      fmt::fmt
+  )
 
   if(${VELOX_BUILD_TESTING})
     add_subdirectory(tests)
diff --git a/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.cpp b/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.cpp
new file mode 100644
index 000000000000..b98ae99d48ed
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.cpp
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/DynamicSasTokenClientProvider.h"
+
+#include <azure/core/datetime.hpp>
+
+namespace facebook::velox::filesystems {
+
+namespace {
+
+constexpr int64_t kDefaultSasTokenRenewPeriod = 120; // in seconds
+
+Azure::DateTime getExpiry(const std::string_view& token) {
+  if (token.empty()) {
+    return Azure::DateTime::clock::time_point::min();
+  }
+
+  static constexpr std::string_view kSignedExpiry{"se="};
+  static constexpr int32_t kSignedExpiryLen = 3;
+
+  auto start = token.find(kSignedExpiry);
+  if (start == std::string::npos) {
+    return Azure::DateTime::clock::time_point::min();
+  }
+  start += kSignedExpiryLen;
+
+  auto end = token.find("&", start);
+  auto seValue = (end == std::string::npos)
+      ? std::string(token.substr(start))
+      : std::string(token.substr(start, end - start));
+
+  seValue = Azure::Core::Url::Decode(seValue);
+  auto seDate =
+      Azure::DateTime::Parse(seValue, Azure::DateTime::DateFormat::Rfc3339);
+
+  static constexpr std::string_view kSignedKeyExpiry = "ske=";
+  static constexpr int32_t kSignedKeyExpiryLen = 4;
+
+  start = token.find(kSignedKeyExpiry);
+  if (start == std::string::npos) {
+    return seDate;
+  }
+  start += kSignedKeyExpiryLen;
+
+  end = token.find("&", start);
+  auto skeValue = (end == std::string::npos)
+      ? std::string(token.substr(start))
+      : std::string(token.substr(start, end - start));
+
+  skeValue = Azure::Core::Url::Decode(skeValue);
+  auto skeDate =
+      Azure::DateTime::Parse(skeValue, Azure::DateTime::DateFormat::Rfc3339);
+
+  return std::min(skeDate, seDate);
+}
+
+bool isNearExpiry(Azure::DateTime expiration, int64_t minExpirationInSeconds) {
+  if (expiration == Azure::DateTime::clock::time_point::min()) {
+    return true;
+  }
+  auto remaining = std::chrono::duration_cast<std::chrono::seconds>(
+                       expiration - Azure::DateTime::clock::now())
+                       .count();
+  return remaining <= minExpirationInSeconds;
+}
+
+class DynamicSasTokenDataLakeFileClient final : public AzureDataLakeFileClient {
+ public:
+  DynamicSasTokenDataLakeFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const std::shared_ptr<SasTokenProvider>& sasKeyGenerator,
+      int64_t sasTokenRenewPeriod)
+      : abfsPath_(abfsPath),
+        sasKeyGenerator_(sasKeyGenerator),
+        sasTokenRenewPeriod_(sasTokenRenewPeriod) {}
+
+  void create() override {
+    getWriteClient()->Create();
+  }
+
+  Azure::Storage::Files::DataLake::Models::PathProperties getProperties()
+      override {
+    return getReadClient()->GetProperties().Value;
+  }
+
+  void append(const uint8_t* buffer, size_t size, uint64_t offset) override {
+    auto bodyStream = Azure::Core::IO::MemoryBodyStream(buffer, size);
+    getWriteClient()->Append(bodyStream, offset);
+  }
+
+  void flush(uint64_t position) override {
+    getWriteClient()->Flush(position);
+  }
+
+  void close() override {}
+
+  std::string getUrl() override {
+    return getWriteClient()->GetUrl();
+  }
+
+ private:
+  std::shared_ptr<AbfsPath> abfsPath_;
+  std::shared_ptr<SasTokenProvider> sasKeyGenerator_;
+  int64_t sasTokenRenewPeriod_;
+
+  std::unique_ptr<DataLakeFileClient> writeClient_{nullptr};
+  Azure::DateTime writeSasExpiration_{
+      Azure::DateTime::clock::time_point::min()};
+
+  std::unique_ptr<DataLakeFileClient> readClient_{nullptr};
+  Azure::DateTime readSasExpiration_{Azure::DateTime::clock::time_point::min()};
+
+  DataLakeFileClient* getWriteClient() {
+    if (writeClient_ == nullptr ||
+        isNearExpiry(writeSasExpiration_, sasTokenRenewPeriod_)) {
+      const auto& sas = sasKeyGenerator_->getSasToken(
+          abfsPath_->fileSystem(), abfsPath_->filePath(), kAbfsWriteOperation);
+      writeSasExpiration_ = getExpiry(sas);
+      writeClient_ = std::make_unique<DataLakeFileClient>(
+          fmt::format("{}?{}", abfsPath_->getUrl(false), sas));
+    }
+    return writeClient_.get();
+  }
+
+  DataLakeFileClient* getReadClient() {
+    if (readClient_ == nullptr ||
+        isNearExpiry(readSasExpiration_, sasTokenRenewPeriod_)) {
+      const auto& sas = sasKeyGenerator_->getSasToken(
+          abfsPath_->fileSystem(), abfsPath_->filePath(), kAbfsReadOperation);
+      readSasExpiration_ = getExpiry(sas);
+      readClient_ = std::make_unique<DataLakeFileClient>(
+          fmt::format("{}?{}", abfsPath_->getUrl(false), sas));
+    }
+    return readClient_.get();
+  }
+};
+
+class DynamicSasTokenBlobClient : public AzureBlobClient {
+ public:
+  DynamicSasTokenBlobClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const std::shared_ptr<SasTokenProvider>& sasTokenProvider,
+      int64_t sasTokenRenewPeriod)
+      : abfsPath_(abfsPath),
+        sasTokenProvider_(sasTokenProvider),
+        sasTokenRenewPeriod_(sasTokenRenewPeriod) {}
+
+  Azure::Response<Azure::Storage::Blobs::Models::BlobProperties> getProperties()
+      override {
+    return getBlobClient()->GetProperties();
+  }
+
+  Azure::Response<Azure::Storage::Blobs::Models::DownloadBlobResult> download(
+      const Azure::Storage::Blobs::DownloadBlobOptions& options) override {
+    return getBlobClient()->Download(options);
+  }
+
+  std::string getUrl() override {
+    return getBlobClient()->GetUrl();
+  }
+
+ private:
+  std::shared_ptr<AbfsPath> abfsPath_;
+  std::shared_ptr<SasTokenProvider> sasTokenProvider_;
+  int64_t sasTokenRenewPeriod_;
+
+  std::unique_ptr<Azure::Storage::Blobs::BlobClient> blobClient_{nullptr};
+  Azure::DateTime sasExpiration_{Azure::DateTime::clock::time_point::min()};
+
+  BlobClient* getBlobClient() {
+    if (blobClient_ == nullptr ||
+        isNearExpiry(sasExpiration_, sasTokenRenewPeriod_)) {
+      const auto& sas = sasTokenProvider_->getSasToken(
+          abfsPath_->fileSystem(), abfsPath_->filePath(), kAbfsReadOperation);
+      sasExpiration_ = getExpiry(sas);
+      blobClient_ = std::make_unique<Azure::Storage::Blobs::BlobClient>(
+          fmt::format("{}?{}", abfsPath_->getUrl(true), sas));
+    }
+    return blobClient_.get();
+  }
+};
+
+} // namespace
+
+DynamicSasTokenClientProvider::DynamicSasTokenClientProvider(
+    const std::shared_ptr<SasTokenProvider>& sasTokenProvider)
+    : AzureClientProvider(), sasTokenProvider_(sasTokenProvider) {}
+
+void DynamicSasTokenClientProvider::init(const config::ConfigBase& config) {
+  sasTokenRenewPeriod_ = config.get<int64_t>(
+      kAzureSasTokenRenewPeriod, kDefaultSasTokenRenewPeriod);
+}
+
+std::unique_ptr<AzureBlobClient>
+DynamicSasTokenClientProvider::getReadFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(config);
+  return std::make_unique<DynamicSasTokenBlobClient>(
+      abfsPath, sasTokenProvider_, sasTokenRenewPeriod_);
+}
+
+std::unique_ptr<AzureDataLakeFileClient>
+DynamicSasTokenClientProvider::getWriteFileClient(
+    const std::shared_ptr<AbfsPath>& abfsPath,
+    const config::ConfigBase& config) {
+  init(config);
+  return std::make_unique<DynamicSasTokenDataLakeFileClient>(
+      abfsPath, sasTokenProvider_, sasTokenRenewPeriod_);
+}
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h b/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h
new file mode 100644
index 000000000000..ab1d53f0045b
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/connectors/hive/storage_adapters/abfs/AzureBlobClient.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProvider.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureDataLakeFileClient.h"
+
+namespace facebook::velox::filesystems {
+
+/// SAS permissions reference:
+/// https://learn.microsoft.com/en-us/rest/api/storageservices/create-service-sas#permissions-for-a-directory-container-or-blob
+///
+/// ReadClient uses "read" permission for Download and GetProperties.
+/// WriteClient uses "read" permission for GetProperties, and "write" permission
+/// for other operations.
+static const std::string kAbfsReadOperation{"read"};
+static const std::string kAbfsWriteOperation{"write"};
+
+/// Interface for providing SAS tokens for ABFS file system operations.
+/// Adapted from the Hadoop Azure implementation:
+/// org.apache.hadoop.fs.azurebfs.extensions.SASTokenProvider
+class SasTokenProvider {
+ public:
+  virtual ~SasTokenProvider() = default;
+
+  virtual std::string getSasToken(
+      const std::string& fileSystem,
+      const std::string& path,
+      const std::string& operation) = 0;
+};
+
+/// Client provider that dynamically refreshes SAS tokens based on the
+/// expiration time of the token. A SasTokenProvider for retrieving SAS tokens
+/// must be provided to this class. Example for generating the SAS token can be
+/// found in:
+/// https://github.com/Azure/azure-sdk-for-cpp/blob/3d917e7c178f0a49b189395a907180084857cc70/sdk/storage/azure-storage-blobs/samples/blob_sas.cpp
+class DynamicSasTokenClientProvider : public AzureClientProvider {
+ public:
+  explicit DynamicSasTokenClientProvider(
+      const std::shared_ptr<SasTokenProvider>& sasTokenProvider);
+
+  std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& abfsPath,
+      const config::ConfigBase& config) override;
+
+ private:
+  void init(const config::ConfigBase& config);
+
+  std::shared_ptr<SasTokenProvider> sasTokenProvider_;
+  int64_t sasTokenRenewPeriod_;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp
index 112aaf7f87f6..a87153928633 100644
--- a/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.cpp
@@ -14,16 +14,22 @@
  * limitations under the License.
  */
 
+#include "velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h" // @manual
+
 #ifdef VELOX_ENABLE_ABFS
+#include "velox/common/base/Exceptions.h"
 #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
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h" // @manual
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h" // @manual
 #include "velox/dwio/common/FileSink.h"
 #endif
 
 namespace facebook::velox::filesystems {
 
 #ifdef VELOX_ENABLE_ABFS
+
 folly::once_flag abfsInitiationFlag;
 
 std::shared_ptr<FileSystem> abfsFileSystemGenerator(
@@ -60,4 +66,41 @@ void registerAbfsFileSystem() {
 #endif
 }
 
+void registerAzureClientProvider(const config::ConfigBase& config) {
+#ifdef VELOX_ENABLE_ABFS
+
+  for (const auto& [accountName, authType] :
+       extractCacheKeyFromConfig(config)) {
+    if (authType == kAzureSharedKeyAuthType) {
+      AzureClientProviderFactories::registerFactory(
+          accountName, [](const std::string&) {
+            return std::make_unique<SharedKeyAzureClientProvider>();
+          });
+    } else if (authType == kAzureOAuthAuthType) {
+      AzureClientProviderFactories::registerFactory(
+          accountName, [](const std::string&) {
+            return std::make_unique<OAuthAzureClientProvider>();
+          });
+    } else if (authType == kAzureSASAuthType) {
+      AzureClientProviderFactories::registerFactory(
+          accountName, [](const std::string&) {
+            return std::make_unique<FixedSasAzureClientProvider>();
+          });
+    } else {
+      VELOX_USER_FAIL(
+          "Unsupported auth type {}, supported auth types are SharedKey, OAuth and SAS.",
+          authType);
+    }
+  }
+#endif
+}
+
+void registerAzureClientProviderFactory(
+    const std::string& account,
+    const AzureClientProviderFactory& factory) {
+#ifdef VELOX_ENABLE_ABFS
+  AzureClientProviderFactories::registerFactory(account, factory);
+#endif
+}
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h
index cbe6758808a0..3d67c6ce667f 100644
--- a/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h
@@ -16,9 +16,37 @@
 
 #pragma once
 
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace facebook::velox::config {
+
+class ConfigBase;
+
+} // namespace facebook::velox::config
+
 namespace facebook::velox::filesystems {
 
+class AzureClientProvider;
+class AbfsPath;
+
+using AzureClientProviderFactory =
+    std::function<std::unique_ptr<AzureClientProvider>(
+        const std::string& account)>;
+
 // Register the ABFS filesystem.
 void registerAbfsFileSystem();
 
+/// Register the AzureClientProvider implementation in `AzureClientProviders`
+/// based on the configuration.
+void registerAzureClientProvider(const config::ConfigBase& config);
+
+/// Registers a factory for creating AzureClientProvider instances.
+/// Any existing factory registered for the specified account will be
+/// overwritten by recalling this method with the same account name.
+void registerAzureClientProviderFactory(
+    const std::string& account,
+    const AzureClientProviderFactory& factory);
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp
index aef53c2dd68d..245c6931cb30 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsFileSystemTest.cpp
@@ -24,10 +24,15 @@
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/connectors/hive/FileHandle.h"
-#include "velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h"
 #include "velox/connectors/hive/storage_adapters/abfs/AbfsFileSystem.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
+
+#include "connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
+#include "connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h"
+#include "connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.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/RegisterAbfsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h"
 #include "velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h"
 #include "velox/dwio/common/FileSink.h"
@@ -38,8 +43,34 @@ using namespace facebook::velox;
 using namespace facebook::velox::filesystems;
 using ::facebook::velox::common::Region;
 
+namespace {
+
 constexpr int kOneMB = 1 << 20;
 
+class TestAzureClientProvider final : public AzureClientProvider {
+ public:
+  explicit TestAzureClientProvider() {
+    delegated_ = std::make_unique<SharedKeyAzureClientProvider>();
+  }
+
+  std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& path,
+      const config::ConfigBase& config) override {
+    return delegated_->getReadFileClient(path, config);
+  }
+
+  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& path,
+      const config::ConfigBase& config) override {
+    return std::make_unique<MockDataLakeFileClient>();
+  }
+
+ private:
+  std::unique_ptr<AzureClientProvider> delegated_;
+};
+
+} // namespace
+
 class AbfsFileSystemTest : public testing::Test {
  public:
   std::shared_ptr<AzuriteServer> azuriteServer_;
@@ -47,12 +78,9 @@ class AbfsFileSystemTest : public testing::Test {
 
   static void SetUpTestCase() {
     registerAbfsFileSystem();
-    AbfsConfig::setUpTestWriteClient(
-        []() { return std::make_unique<MockDataLakeFileClient>(); });
-  }
-
-  static void TearDownTestSuite() {
-    AbfsConfig::tearDownTestWriteClient();
+    registerAzureClientProviderFactory("test", [](const std::string&) {
+      return std::make_unique<TestAzureClientProvider>();
+    });
   }
 
   void SetUp() override {
@@ -163,15 +191,14 @@ TEST_F(AbfsFileSystemTest, openFileForReadWithInvalidOptions) {
 
 TEST_F(AbfsFileSystemTest, fileHandleWithProperties) {
   FileHandleFactory factory(
-      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(1),
+      std::make_unique<SimpleLRUCache<FileHandleKey, FileHandle>>(1),
       std::make_unique<FileHandleGenerator>(azuriteServer_->hiveConfig()));
   FileProperties properties = {15 + kOneMB, 1};
-  auto fileHandleProperties =
-      factory.generate(azuriteServer_->fileURI(), &properties);
+  FileHandleKey key{azuriteServer_->fileURI()};
+  auto fileHandleProperties = factory.generate(key, &properties);
   readData(fileHandleProperties->file.get());
 
-  auto fileHandleWithoutProperties =
-      factory.generate(azuriteServer_->fileURI());
+  auto fileHandleWithoutProperties = factory.generate(key);
   readData(fileHandleWithoutProperties->file.get());
 }
 
@@ -265,12 +292,12 @@ TEST_F(AbfsFileSystemTest, notImplemented) {
   VELOX_ASSERT_THROW(abfs_->rmdir("dir"), "rmdir for abfs not implemented");
 }
 
-TEST_F(AbfsFileSystemTest, credNotFOund) {
+TEST_F(AbfsFileSystemTest, clientProviderFactoryNotRegistered) {
   const std::string abfsFile =
       std::string("abfs://test@test1.dfs.core.windows.net/test");
   VELOX_ASSERT_THROW(
       abfs_->openFileForRead(abfsFile),
-      "Config fs.azure.account.key.test1.dfs.core.windows.net not found");
+      "No AzureClientProviderFactory registered for account 'test1'.");
 }
 
 TEST_F(AbfsFileSystemTest, registerAbfsFileSink) {
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 000000000000..a8f9bd602745
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AbfsUtilTest.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/storage_adapters/abfs/AbfsUtil.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox::filesystems;
+
+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"));
+}
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AzureClientProviderFactoriesTest.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/AzureClientProviderFactoriesTest.cpp
new file mode 100644
index 000000000000..c85c15ee5fbd
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AzureClientProviderFactoriesTest.cpp
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h"
+#include "velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::filesystems;
+
+namespace {
+
+class DummyAzureClientProvider final : public AzureClientProvider {
+ public:
+  std::unique_ptr<AzureBlobClient> getReadFileClient(
+      const std::shared_ptr<AbfsPath>& path,
+      const config::ConfigBase& config) override {
+    VELOX_FAIL("DummyAzureClientProvider: Not implemented.");
+  }
+
+  std::unique_ptr<AzureDataLakeFileClient> getWriteFileClient(
+      const std::shared_ptr<AbfsPath>& path,
+      const config::ConfigBase& config) override {
+    VELOX_FAIL("DummyAzureClientProvider: Not implemented.");
+  }
+};
+
+} // namespace
+
+TEST(AzureClientProviderFactoriesTest, registerFromConfig) {
+  const auto abfsPath = std::make_shared<AbfsPath>(
+      "abfss://abc@efg.dfs.core.windows.net/file/test.txt");
+
+  {
+    // OAuth auth type.
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.efg.dfs.core.windows.net", "OAuth"},
+         {"fs.azure.account.oauth2.client.id.efg.dfs.core.windows.net", "123"},
+         {"fs.azure.account.oauth2.client.secret.efg.dfs.core.windows.net",
+          "456"},
+         {"fs.azure.account.oauth2.client.endpoint.efg.dfs.core.windows.net",
+          "https://login.microsoftonline.com/{TENANTID}/oauth2/token"}},
+        false);
+    registerAzureClientProvider(config);
+
+    ASSERT_NE(
+        AzureClientProviderFactories::getReadFileClient(abfsPath, config),
+        nullptr);
+    ASSERT_NE(
+        AzureClientProviderFactories::getWriteFileClient(abfsPath, config),
+        nullptr);
+  }
+
+  {
+    // SharedKey auth type.
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.efg.dfs.core.windows.net", "SharedKey"},
+         {"fs.azure.account.key.efg.dfs.core.windows.net", "456"}},
+        false);
+    registerAzureClientProvider(config);
+
+    ASSERT_NE(
+        AzureClientProviderFactories::getReadFileClient(abfsPath, config),
+        nullptr);
+    ASSERT_NE(
+        AzureClientProviderFactories::getWriteFileClient(abfsPath, config),
+        nullptr);
+  }
+
+  {
+    // SAS auth type.
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.efg.dfs.core.windows.net", "SAS"},
+         {"fs.azure.sas.fixed.token.efg.dfs.core.windows.net", "456"}},
+        false);
+    registerAzureClientProvider(config);
+
+    ASSERT_NE(
+        AzureClientProviderFactories::getReadFileClient(abfsPath, config),
+        nullptr);
+    ASSERT_NE(
+        AzureClientProviderFactories::getWriteFileClient(abfsPath, config),
+        nullptr);
+  }
+
+  {
+    // Invalid auth type.
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.efg.dfs.core.windows.net", "Custom"},
+         {"fs.azure.account.key.efg.dfs.core.windows.net", "456"}},
+        false);
+    VELOX_ASSERT_THROW(
+        registerAzureClientProvider(config),
+        "Unsupported auth type Custom, supported auth types are SharedKey, OAuth and SAS.");
+  }
+
+  {
+    // Invalid config key.
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.efg", "SharedKey"},
+         {"fs.azure.account.key.efg.dfs.core.windows.net", "456"}},
+        false);
+    VELOX_ASSERT_THROW(
+        registerAzureClientProvider(config),
+        "Invalid Azure account auth type key: fs.azure.account.auth.type.efg");
+  }
+}
+
+TEST(AzureClientProviderFactoriesTest, registerCustomFactory) {
+  static const std::string path = "abfs://test@efg.dfs.core.windows.net/test";
+  const auto abfsPath = std::make_shared<AbfsPath>(path);
+
+  registerAzureClientProviderFactory(
+      "efg",
+      [](const std::string& account) -> std::unique_ptr<AzureClientProvider> {
+        return std::make_unique<DummyAzureClientProvider>();
+      });
+
+  ASSERT_NO_THROW(AzureClientProviderFactories::getClientFactory("efg"));
+  VELOX_ASSERT_THROW(
+      AzureClientProviderFactories::getReadFileClient(
+          abfsPath, config::ConfigBase({})),
+      "DummyAzureClientProvider: Not implemented.");
+  VELOX_ASSERT_THROW(
+      AzureClientProviderFactories::getWriteFileClient(
+          abfsPath, config::ConfigBase({})),
+      "DummyAzureClientProvider: Not implemented.");
+
+  VELOX_ASSERT_THROW(
+      AzureClientProviderFactories::getClientFactory("efg2"),
+      "No AzureClientProviderFactory registered for account 'efg2'.");
+}
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AbfsCommonTest.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/AzureClientProvidersTest.cpp
similarity index 50%
rename from velox/connectors/hive/storage_adapters/abfs/tests/AbfsCommonTest.cpp
rename to velox/connectors/hive/storage_adapters/abfs/tests/AzureClientProvidersTest.cpp
index 53fd09323b41..b9fd4346b237 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/AbfsCommonTest.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AzureClientProvidersTest.cpp
@@ -14,43 +14,21 @@
  * limitations under the License.
  */
 
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h"
+
+#include "connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/config/Config.h"
-#include "velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h"
-#include "velox/connectors/hive/storage_adapters/abfs/AbfsUtil.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
 
 #include "gtest/gtest.h"
 
 using namespace facebook::velox::filesystems;
 using namespace facebook::velox;
 
-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(AbfsConfigTest, authType) {
-  const config::ConfigBase config(
-      {{"fs.azure.account.auth.type.efg.dfs.core.windows.net", "Custom"},
-       {"fs.azure.account.key.efg.dfs.core.windows.net", "456"}},
-      false);
-  VELOX_ASSERT_USER_THROW(
-      std::make_unique<AbfsConfig>(
-          "abfss://foo@efg.dfs.core.windows.net/test.txt", config),
-      "Unsupported auth type Custom, supported auth types are SharedKey, OAuth and SAS.");
-}
-
-TEST(AbfsConfigTest, clientSecretOAuth) {
+TEST(AzureClientProvidersTest, clientSecretOAuth) {
   const config::ConfigBase config(
-      {{"fs.azure.account.auth.type.efg.dfs.core.windows.net", "OAuth"},
-       {"fs.azure.account.auth.type.bar1.dfs.core.windows.net", "OAuth"},
-       {"fs.azure.account.auth.type.bar2.dfs.core.windows.net", "OAuth"},
-       {"fs.azure.account.auth.type.bar3.dfs.core.windows.net", "OAuth"},
-       {"fs.azure.account.oauth2.client.id.efg.dfs.core.windows.net", "test"},
+      {{"fs.azure.account.oauth2.client.id.efg.dfs.core.windows.net", "test"},
        {"fs.azure.account.oauth2.client.secret.efg.dfs.core.windows.net",
         "test"},
        {"fs.azure.account.oauth2.client.endpoint.efg.dfs.core.windows.net",
@@ -60,27 +38,45 @@ TEST(AbfsConfigTest, clientSecretOAuth) {
        {"fs.azure.account.oauth2.client.secret.bar3.dfs.core.windows.net",
         "test"}},
       false);
+
+  auto clientProvider = OAuthAzureClientProvider();
+
   VELOX_ASSERT_USER_THROW(
-      std::make_unique<AbfsConfig>(
-          "abfss://foo@bar1.dfs.core.windows.net/test.txt", config),
+      clientProvider.tenantIdAndAuthorityHost(
+          std::make_shared<AbfsPath>(
+              "abfss://foo@bar1.dfs.core.windows.net/test.txt"),
+          config),
       "Config fs.azure.account.oauth2.client.id.bar1.dfs.core.windows.net not found");
   VELOX_ASSERT_USER_THROW(
-      std::make_unique<AbfsConfig>(
-          "abfss://foo@bar2.dfs.core.windows.net/test.txt", config),
+      clientProvider.tenantIdAndAuthorityHost(
+          std::make_shared<AbfsPath>(
+              "abfss://foo@bar2.dfs.core.windows.net/test.txt"),
+          config),
       "Config fs.azure.account.oauth2.client.secret.bar2.dfs.core.windows.net not found");
   VELOX_ASSERT_USER_THROW(
-      std::make_unique<AbfsConfig>(
-          "abfss://foo@bar3.dfs.core.windows.net/test.txt", config),
+      clientProvider.tenantIdAndAuthorityHost(
+          std::make_shared<AbfsPath>(
+              "abfss://foo@bar3.dfs.core.windows.net/test.txt"),
+          config),
       "Config fs.azure.account.oauth2.client.endpoint.bar3.dfs.core.windows.net not found");
-  auto abfsConfig =
-      AbfsConfig("abfss://abc@efg.dfs.core.windows.net/file/test.txt", config);
-  EXPECT_EQ(abfsConfig.tenentId(), "{TENANTID}");
-  EXPECT_EQ(abfsConfig.authorityHost(), "https://login.microsoftonline.com/");
-  auto readClient = abfsConfig.getReadFileClient();
+
+  const auto expectedTenantIdAndAuthorityHost =
+      std::make_pair<std::string, std::string>(
+          "{TENANTID}", "https://login.microsoftonline.com/");
+  EXPECT_EQ(
+      clientProvider.tenantIdAndAuthorityHost(
+          std::make_shared<AbfsPath>(
+              "abfss://abc@efg.dfs.core.windows.net/file/test.txt"),
+          config),
+      expectedTenantIdAndAuthorityHost);
+
+  const auto abfsPath = std::make_shared<AbfsPath>(
+      "abfss://abc@efg.dfs.core.windows.net/file/test.txt");
+  auto readClient = clientProvider.getReadFileClient(abfsPath, config);
   EXPECT_EQ(
-      readClient->GetUrl(),
+      readClient->getUrl(),
       "https://efg.blob.core.windows.net/abc/file/test.txt");
-  auto writeClient = abfsConfig.getWriteFileClient();
+  auto writeClient = clientProvider.getWriteFileClient(abfsPath, config);
   // GetUrl retrieves the value from the internal blob client, which represents
   // the blob's path as well.
   EXPECT_EQ(
@@ -88,23 +84,27 @@ TEST(AbfsConfigTest, clientSecretOAuth) {
       "https://efg.blob.core.windows.net/abc/file/test.txt");
 }
 
-TEST(AbfsConfigTest, sasToken) {
+TEST(AzureClientProviderTest, fixedSasToken) {
   const config::ConfigBase config(
-      {{"fs.azure.account.auth.type.efg.dfs.core.windows.net", "SAS"},
-       {"fs.azure.account.auth.type.bar.dfs.core.windows.net", "SAS"},
-       {"fs.azure.sas.fixed.token.bar.dfs.core.windows.net", "sas=test"}},
+      {{"fs.azure.sas.fixed.token.bar.dfs.core.windows.net", "sas=test"}},
       false);
+
+  auto clientProvider = FixedSasAzureClientProvider();
+
   VELOX_ASSERT_USER_THROW(
-      std::make_unique<AbfsConfig>(
-          "abfss://foo@efg.dfs.core.windows.net/test.txt", config),
+      clientProvider.sas(
+          std::make_shared<AbfsPath>(
+              "abfss://foo@efg.dfs.core.windows.net/test.txt"),
+          config),
       "Config fs.azure.sas.fixed.token.efg.dfs.core.windows.net not found");
-  auto abfsConfig =
-      AbfsConfig("abfs://abc@bar.dfs.core.windows.net/file", config);
-  auto readClient = abfsConfig.getReadFileClient();
+
+  const auto abfsPath =
+      std::make_shared<AbfsPath>("abfs://abc@bar.dfs.core.windows.net/file");
+  auto readClient = clientProvider.getReadFileClient(abfsPath, config);
   EXPECT_EQ(
-      readClient->GetUrl(),
+      readClient->getUrl(),
       "http://bar.blob.core.windows.net/abc/file?sas=test");
-  auto writeClient = abfsConfig.getWriteFileClient();
+  auto writeClient = clientProvider.getWriteFileClient(abfsPath, config);
   // GetUrl retrieves the value from the internal blob client, which represents
   // the blob's path as well.
   EXPECT_EQ(
@@ -112,43 +112,47 @@ TEST(AbfsConfigTest, sasToken) {
       "http://bar.blob.core.windows.net/abc/file?sas=test");
 }
 
-TEST(AbfsConfigTest, sharedKey) {
+TEST(AzureClientProviderTest, sharedKey) {
   const config::ConfigBase config(
       {{"fs.azure.account.key.efg.dfs.core.windows.net", "123"},
-       {"fs.azure.account.auth.type.efg.dfs.core.windows.net", "SharedKey"},
        {"fs.azure.account.key.foobar.dfs.core.windows.net", "456"},
        {"fs.azure.account.key.bar.dfs.core.windows.net", "789"}},
       false);
 
-  auto abfsConfig =
-      AbfsConfig("abfs://abc@efg.dfs.core.windows.net/file", config);
-  EXPECT_EQ(abfsConfig.fileSystem(), "abc");
-  EXPECT_EQ(abfsConfig.filePath(), "file");
+  const auto abfsPath =
+      std::make_shared<AbfsPath>("abfs://abc@efg.dfs.core.windows.net/file");
+  EXPECT_EQ(abfsPath->fileSystem(), "abc");
+  EXPECT_EQ(abfsPath->filePath(), "file");
+
+  auto clientProvider = SharedKeyAzureClientProvider();
   EXPECT_EQ(
-      abfsConfig.connectionString(),
+      clientProvider.connectionString(abfsPath, config),
       "DefaultEndpointsProtocol=http;AccountName=efg;AccountKey=123;EndpointSuffix=core.windows.net;");
 
-  auto abfssConfig = AbfsConfig(
-      "abfss://abc@foobar.dfs.core.windows.net/sf_1/store_sales/ss_sold_date_sk=2450816/part-00002-a29c25f1-4638-494e-8428-a84f51dcea41.c000.snappy.parquet",
-      config);
-  EXPECT_EQ(abfssConfig.fileSystem(), "abc");
+  const auto abfssPath = std::make_shared<AbfsPath>(
+      "abfss://abc@foobar.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(abfssPath->fileSystem(), "abc");
   EXPECT_EQ(
-      abfssConfig.filePath(),
+      abfssPath->filePath(),
       "sf_1/store_sales/ss_sold_date_sk=2450816/part-00002-a29c25f1-4638-494e-8428-a84f51dcea41.c000.snappy.parquet");
   EXPECT_EQ(
-      abfssConfig.connectionString(),
+      clientProvider.connectionString(abfssPath, config),
       "DefaultEndpointsProtocol=https;AccountName=foobar;AccountKey=456;EndpointSuffix=core.windows.net;");
 
   // Test with special character space.
-  auto abfssConfigWithSpecialCharacters = AbfsConfig(
-      "abfss://foo@bar.dfs.core.windows.net/main@dir/sub dir/test.txt", config);
-
-  EXPECT_EQ(abfssConfigWithSpecialCharacters.fileSystem(), "foo");
+  const auto abfssPathWithSpecialCharacters = std::make_shared<AbfsPath>(
+      "abfss://foo@bar.dfs.core.windows.net/main@dir/sub dir/test.txt");
+  EXPECT_EQ(abfssPathWithSpecialCharacters->fileSystem(), "foo");
+  EXPECT_EQ(
+      abfssPathWithSpecialCharacters->filePath(), "main@dir/sub dir/test.txt");
   EXPECT_EQ(
-      abfssConfigWithSpecialCharacters.filePath(), "main@dir/sub dir/test.txt");
+      clientProvider.connectionString(abfssPathWithSpecialCharacters, config),
+      "DefaultEndpointsProtocol=https;AccountName=bar;AccountKey=789;EndpointSuffix=core.windows.net;");
 
   VELOX_ASSERT_USER_THROW(
-      std::make_unique<AbfsConfig>(
-          "abfss://foo@otheraccount.dfs.core.windows.net/test.txt", config),
+      clientProvider.connectionString(
+          std::make_shared<AbfsPath>(
+              "abfss://foo@otheraccount.dfs.core.windows.net/test.txt"),
+          config),
       "Config fs.azure.account.key.otheraccount.dfs.core.windows.net not found");
 }
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.cpp
index 726c2c531be8..9213068d926a 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.cpp
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.cpp
@@ -15,7 +15,8 @@
  */
 
 #include "velox/connectors/hive/storage_adapters/abfs/tests/AzuriteServer.h"
-#include "velox/connectors/hive/storage_adapters/abfs/AbfsConfig.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AbfsPath.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderImpl.h"
 
 namespace facebook::velox::filesystems {
 
@@ -108,9 +109,10 @@ AzuriteServer::AzuriteServer(int64_t port) : port_(port) {
 }
 
 void AzuriteServer::addFile(std::string source) {
-  AbfsConfig conf(fileURI(), *hiveConfig());
+  const auto abfsPath = std::make_shared<AbfsPath>(fileURI());
+  auto clientProvider = SharedKeyAzureClientProvider();
   auto containerClient = BlobContainerClient::CreateFromConnectionString(
-      conf.connectionString(), container_);
+      clientProvider.connectionString(abfsPath, *hiveConfig()), container_);
   containerClient.CreateIfNotExists();
   auto blobClient = containerClient.GetBlockBlobClient(file_);
   blobClient.UploadFrom(source);
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt
index 2246dadd385f..c81471db9f68 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/CMakeLists.txt
@@ -12,12 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_abfs_test AbfsFileSystemTest.cpp AbfsCommonTest.cpp
-                               AzuriteServer.cpp MockDataLakeFileClient.cpp)
+add_executable(
+  velox_abfs_test
+  AbfsFileSystemTest.cpp
+  AbfsUtilTest.cpp
+  AzureClientProvidersTest.cpp
+  AzureClientProviderFactoriesTest.cpp
+  DynamicSasTokenClientProviderTest.cpp
+  AzuriteServer.cpp
+  MockDataLakeFileClient.cpp
+)
 
 add_test(velox_abfs_test velox_abfs_test)
 target_link_libraries(
   velox_abfs_test
-  PRIVATE velox_abfs velox_exec_test_lib GTest::gtest GTest::gtest_main)
+  PRIVATE velox_abfs velox_exec_test_lib GTest::gtest GTest::gtest_main
+)
 
 target_compile_options(velox_abfs_test PRIVATE -Wno-deprecated-declarations)
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/DynamicSasTokenClientProviderTest.cpp b/velox/connectors/hive/storage_adapters/abfs/tests/DynamicSasTokenClientProviderTest.cpp
new file mode 100644
index 000000000000..8793aea080b9
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/DynamicSasTokenClientProviderTest.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/connectors/hive/storage_adapters/abfs/DynamicSasTokenClientProvider.h"
+#include "velox/connectors/hive/storage_adapters/abfs/AzureClientProviderFactories.h"
+#include "velox/connectors/hive/storage_adapters/abfs/RegisterAbfsFileSystem.h"
+
+#include "gtest/gtest.h"
+
+#include <azure/storage/blobs/blob_sas_builder.hpp>
+#include <chrono>
+#include <cstdint>
+
+using namespace facebook::velox::filesystems;
+using namespace facebook::velox;
+
+namespace {
+
+class MyDynamicAbfsSasTokenProvider : public SasTokenProvider {
+ public:
+  MyDynamicAbfsSasTokenProvider(int64_t expiration)
+      : expirationSeconds_(expiration) {}
+
+  std::string getSasToken(
+      const std::string& fileSystem,
+      const std::string& path,
+      const std::string& operation) override {
+    const auto lastSlash = path.find_last_of("/");
+    const auto containerName = path.substr(0, lastSlash);
+    const auto blobName = path.substr(lastSlash + 1);
+
+    Azure::Storage::Sas::BlobSasBuilder sasBuilder;
+    sasBuilder.ExpiresOn = Azure::DateTime::clock::now() +
+        std::chrono::seconds(expirationSeconds_);
+    sasBuilder.BlobContainerName = containerName;
+    sasBuilder.BlobName = blobName;
+    sasBuilder.Resource = Azure::Storage::Sas::BlobSasResource::Blob;
+    sasBuilder.SetPermissions(
+        Azure::Storage::Sas::BlobSasPermissions::Read &
+        Azure::Storage::Sas::BlobSasPermissions::Write);
+
+    std::string sasToken = sasBuilder.GenerateSasToken(
+        Azure::Storage::StorageSharedKeyCredential(
+            "test",
+            "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw=="));
+
+    // Remove the leading '?' from the SAS token.
+    if (sasToken[0] == '?') {
+      sasToken = sasToken.substr(1);
+    }
+
+    return sasToken;
+  }
+
+ private:
+  int64_t expirationSeconds_;
+};
+
+} // namespace
+
+TEST(DynamicSasTokenClientProviderTest, dynamicSasToken) {
+  {
+    const std::string account = "account1";
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.account1.dfs.core.windows.net", "SAS"},
+         {"fs.azure.sas.token.renew.period.for.streams", "1"}},
+        false);
+    registerAzureClientProviderFactory(account, [](const std::string&) {
+      auto sasTokenProvider =
+          std::make_shared<MyDynamicAbfsSasTokenProvider>(3);
+      return std::make_unique<DynamicSasTokenClientProvider>(sasTokenProvider);
+    });
+
+    auto abfsPath = std::make_shared<AbfsPath>(
+        fmt::format("abfs://abc@{}.dfs.core.windows.net/file", account));
+    auto readClient =
+        AzureClientProviderFactories::getReadFileClient(abfsPath, config);
+    auto writeClient =
+        AzureClientProviderFactories::getWriteFileClient(abfsPath, config);
+
+    auto readUrl = readClient->getUrl();
+    auto writeUrl = writeClient->getUrl();
+
+    // Let the current time pass 3 seconds to ensure the SAS token is expired.
+    std::this_thread::sleep_for(std::chrono::seconds(3)); // NOLINT
+
+    auto newReadUrl = readClient->getUrl();
+    ASSERT_NE(readUrl, newReadUrl);
+    // The SAS token should be reused.
+    ASSERT_EQ(newReadUrl, readClient->getUrl());
+
+    auto newWriteUrl = writeClient->getUrl();
+    ASSERT_NE(writeUrl, newWriteUrl);
+    // The SAS token should be reused.
+    ASSERT_EQ(newWriteUrl, writeClient->getUrl());
+  }
+
+  {
+    // SAS token expired by setting the renewal period to 120 seconds.
+    const std::string account = "account2";
+    const config::ConfigBase config(
+        {{"fs.azure.account.auth.type.account2.dfs.core.windows.net", "SAS"},
+         {"fs.azure.sas.token.renew.period.for.streams", "120"}},
+        false);
+    registerAzureClientProviderFactory(account, [](const std::string&) {
+      auto sasTokenProvider =
+          std::make_shared<MyDynamicAbfsSasTokenProvider>(60);
+      return std::make_unique<DynamicSasTokenClientProvider>(sasTokenProvider);
+    });
+
+    auto abfsPath = std::make_shared<AbfsPath>(
+        fmt::format("abfs://abc@{}.dfs.core.windows.net/file", account));
+    auto readClient =
+        AzureClientProviderFactories::getReadFileClient(abfsPath, config);
+    auto writeClient =
+        AzureClientProviderFactories::getWriteFileClient(abfsPath, config);
+
+    auto readUrl = readClient->getUrl();
+    auto writeUrl = writeClient->getUrl();
+
+    // Let the current time pass 3 seconds to ensure the timestamp in the SAS
+    // token is updated.
+    std::this_thread::sleep_for(std::chrono::seconds(3)); // NOLINT
+
+    // Sas token should be renewed because the time left is less than the
+    // renewal period.
+    ASSERT_NE(readUrl, readClient->getUrl());
+    ASSERT_NE(writeUrl, writeClient->getUrl());
+  }
+}
diff --git a/velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h b/velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h
index 5b874fff56b5..560294414c8a 100644
--- a/velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h
+++ b/velox/connectors/hive/storage_adapters/abfs/tests/MockDataLakeFileClient.h
@@ -46,7 +46,7 @@ class MockDataLakeFileClient : public AzureDataLakeFileClient {
 
   void close() override;
 
-  std::string getUrl() const override {
+  std::string getUrl() override {
     return "testUrl";
   }
 
diff --git a/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
index e9f5f98520c0..7e110edac193 100644
--- a/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/gcs/CMakeLists.txt
@@ -17,9 +17,8 @@
 velox_add_library(velox_gcs RegisterGcsFileSystem.cpp)
 
 if(VELOX_ENABLE_GCS)
-  velox_sources(velox_gcs PRIVATE GcsFileSystem.cpp GcsUtil.cpp)
-  velox_link_libraries(velox_gcs velox_dwio_common Folly::folly
-                       google-cloud-cpp::storage)
+  velox_sources(velox_gcs PRIVATE GcsFileSystem.cpp GcsUtil.cpp GcsWriteFile.cpp GcsReadFile.cpp)
+  velox_link_libraries(velox_gcs velox_dwio_common Folly::folly google-cloud-cpp::storage)
 
   if(${VELOX_BUILD_TESTING})
     add_subdirectory(tests)
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.cpp b/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.cpp
index a2dd4e77d985..8ec4873e28de 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.cpp
@@ -17,9 +17,10 @@
 #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/GcsReadFile.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GcsUtil.h"
+#include "velox/connectors/hive/storage_adapters/gcs/GcsWriteFile.h"
 #include "velox/core/QueryConfig.h"
 
 #include <fmt/format.h>
@@ -30,244 +31,50 @@
 #include <google/cloud/storage/client.h>
 
 namespace facebook::velox {
-namespace {
+namespace filesystems {
+using namespace connector::hive;
 namespace gcs = ::google::cloud::storage;
 namespace gc = ::google::cloud;
-// Reference: https://github.com/apache/arrow/issues/29916
-// Change the default upload buffer size. In general, sending larger buffers is
-// more efficient with GCS, as each buffer requires a roundtrip to the service.
-// With formatted output (when using `operator<<`), keeping a larger buffer in
-// memory before uploading makes sense.  With unformatted output (the only
-// choice given gcs::io::OutputStream's API) it is better to let the caller
-// provide as large a buffer as they want. The GCS C++ client library will
-// upload this buffer with zero copies if possible.
-auto constexpr kUploadBufferSize = 256 * 1024;
-
-inline void checkGcsStatus(
-    const gc::Status outcome,
-    const std::string_view& errorMsgPrefix,
-    const std::string& bucket,
-    const std::string& key) {
-  if (!outcome.ok()) {
-    const auto errMsg = fmt::format(
-        "{} due to: Path:'{}', SDK Error Type:{}, GCS Status Code:{},  Message:'{}'",
-        errorMsgPrefix,
-        gcsURI(bucket, key),
-        outcome.error_info().domain(),
-        getErrorStringFromGcsError(outcome.code()),
-        outcome.message());
-    if (outcome.code() == gc::StatusCode::kNotFound) {
-      VELOX_FILE_NOT_FOUND_ERROR(errMsg);
-    }
-    VELOX_FAIL(errMsg);
-  }
-}
-
-class GcsReadFile final : public ReadFile {
- public:
-  GcsReadFile(const std::string& path, std::shared_ptr<gcs::Client> client)
-      : client_(std::move(client)) {
-    // assumption it's a proper path
-    setBucketAndKeyFromGcsPath(path, bucket_, key_);
-  }
-
-  // Gets the length of the file.
-  // Checks if there are any issues reading the file.
-  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;
-    }
-    // get metadata and initialize length
-    auto metadata = client_->GetObjectMetadata(bucket_, key_);
-    if (!metadata.ok()) {
-      checkGcsStatus(
-          metadata.status(),
-          "Failed to get metadata for GCS object",
-          bucket_,
-          key_);
-    }
-    length_ = (*metadata).size();
-    VELOX_CHECK_GE(length_, 0);
-  }
-
-  std::string_view pread(
-      uint64_t offset,
-      uint64_t length,
-      void* buffer,
-      filesystems::File::IoStats* stats = nullptr) const override {
-    preadInternal(offset, length, static_cast<char*>(buffer));
-    return {static_cast<char*>(buffer), length};
-  }
-
-  std::string pread(
-      uint64_t offset,
-      uint64_t length,
-      filesystems::File::IoStats* stats = nullptr) const override {
-    std::string result(length, 0);
-    char* position = result.data();
-    preadInternal(offset, length, position);
-    return result;
-  }
-
-  uint64_t preadv(
-      uint64_t offset,
-      const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override {
-    // 'buffers' contains Ranges(data, size)  with some gaps (data = nullptr) in
-    // between. This call must populate the ranges (except gap ranges)
-    // sequentially starting from 'offset'. If a range pointer is nullptr, the
-    // data from stream of size range.size() will be skipped.
-    size_t length = 0;
-    for (const 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 size() const override {
-    return length_;
-  }
 
-  uint64_t memoryUsage() const override {
-    return sizeof(GcsReadFile) // this class
-        + sizeof(gcs::Client) // pointee
-        + kUploadBufferSize; // buffer size
-  }
-
-  bool shouldCoalesce() const final {
-    return false;
-  }
-
-  std::string getName() const override {
-    return key_;
-  }
-
-  uint64_t getNaturalReadSize() const override {
-    return kUploadBufferSize;
-  }
-
- private:
-  // The assumption here is that "position" has space for at least "length"
-  // bytes.
-  void preadInternal(uint64_t offset, uint64_t length, char* position) const {
-    gcs::ObjectReadStream stream = client_->ReadObject(
-        bucket_, key_, gcs::ReadRange(offset, offset + length));
-    if (!stream) {
-      checkGcsStatus(
-          stream.status(), "Failed to get GCS object", bucket_, key_);
-    }
-
-    stream.read(position, length);
-    if (!stream) {
-      checkGcsStatus(
-          stream.status(), "Failed to get read object", bucket_, key_);
-    }
-    bytesRead_ += length;
-  }
-
-  std::shared_ptr<gcs::Client> client_;
-  std::string bucket_;
-  std::string key_;
-  std::atomic<int64_t> length_ = -1;
-};
-
-class GcsWriteFile final : public WriteFile {
- public:
-  explicit GcsWriteFile(
-      const std::string& path,
-      std::shared_ptr<gcs::Client> client)
-      : client_(client) {
-    setBucketAndKeyFromGcsPath(path, bucket_, key_);
-  }
-
-  ~GcsWriteFile() {
-    close();
-  }
-
-  void initialize() {
-    // Make it a no-op if invoked twice.
-    if (size_ != -1) {
-      return;
-    }
-
-    // Check that it doesn't exist, if it does throw an error
-    auto object_metadata = client_->GetObjectMetadata(bucket_, key_);
-    VELOX_CHECK(!object_metadata.ok(), "File already exists");
-
-    auto stream = client_->WriteObject(bucket_, key_);
-    checkGcsStatus(
-        stream.last_status(),
-        "Failed to open GCS object for writing",
-        bucket_,
-        key_);
-    stream_ = std::move(stream);
-    size_ = 0;
-  }
-
-  void append(const std::string_view data) override {
-    VELOX_CHECK(isFileOpen(), "File is not open");
-    stream_ << data;
-    size_ += data.size();
-  }
-
-  void flush() override {
-    if (isFileOpen()) {
-      stream_.flush();
-    }
-  }
+namespace {
 
-  void close() override {
-    if (isFileOpen()) {
-      stream_.flush();
-      stream_.Close();
-      closed_ = true;
-    }
-  }
+auto constexpr kGcsInvalidPath = "File {} is not a valid gcs file";
 
-  uint64_t size() const override {
-    return size_;
-  }
+folly::Synchronized<
+    std::unordered_map<std::string, GcsOAuthCredentialsProviderFactory>>&
+credentialsProviderFactories() {
+  static folly::Synchronized<
+      std::unordered_map<std::string, GcsOAuthCredentialsProviderFactory>>
+      factories;
+  return factories;
+}
 
- private:
-  inline bool isFileOpen() {
-    return (!closed_ && stream_.IsOpen());
-  }
+std::shared_ptr<GcsOAuthCredentialsProvider> getCredentialsProviderByName(
+    const std::string& providerName,
+    const std::shared_ptr<connector::hive::HiveConfig>& hiveConfig) {
+  VELOX_USER_CHECK(
+      !providerName.empty(),
+      "GcsOAuthCredentialsProviderFactory name cannot be empty");
+  return credentialsProviderFactories().withRLock([&](const auto& factories) {
+    const auto it = factories.find(providerName);
+    VELOX_USER_CHECK(
+        it != factories.end(),
+        "GcsOAuthCredentialsProviderFactory for '{}' not registered",
+        providerName);
+    const auto& factory = it->second;
+    return factory(hiveConfig);
+  });
+}
 
-  gcs::ObjectWriteStream stream_;
-  std::shared_ptr<gcs::Client> client_;
-  std::string bucket_;
-  std::string key_;
-  std::atomic<int64_t> size_{-1};
-  std::atomic<bool> closed_{false};
-};
 } // namespace
 
-namespace filesystems {
-using namespace connector::hive;
-
-auto constexpr kGcsInvalidPath = "File {} is not a valid gcs file";
-
 class GcsFileSystem::Impl {
  public:
-  Impl(const config::ConfigBase* config)
-      : hiveConfig_(std::make_shared<HiveConfig>(
-            std::make_shared<config::ConfigBase>(config->rawConfigsCopy()))) {}
+  Impl(const std::string& bucket, const config::ConfigBase* config)
+      : bucket_(bucket),
+        hiveConfig_(
+            std::make_shared<HiveConfig>(std::make_shared<config::ConfigBase>(
+                config->rawConfigsCopy()))) {}
 
   ~Impl() = default;
 
@@ -275,21 +82,28 @@ class GcsFileSystem::Impl {
   void initializeClient() {
     constexpr std::string_view kHttpsScheme{"https://"};
     auto options = gc::Options{};
-    auto endpointOverride = hiveConfig_->gcsEndpoint();
-    // Use secure credentials by default.
-    if (!endpointOverride.empty()) {
-      options.set<gcs::RestEndpointOption>(endpointOverride);
-      // Use Google default credentials if endpoint has https scheme.
-      if (endpointOverride.find(kHttpsScheme) == 0) {
-        options.set<gc::UnifiedCredentialsOption>(
-            gc::MakeGoogleDefaultCredentials());
+    if (auto tokenProvider = hiveConfig_->gcsAuthAccessTokenProvider()) {
+      auto credentialsProvider =
+          getCredentialsProviderByName(tokenProvider.value(), hiveConfig_);
+      auto credentials = credentialsProvider->getCredentials(bucket_);
+      options.set<gcs::Oauth2CredentialsOption>(credentials);
+    } else {
+      auto endpointOverride = hiveConfig_->gcsEndpoint();
+      // Use secure credentials by default.
+      if (!endpointOverride.empty()) {
+        options.set<gcs::RestEndpointOption>(endpointOverride);
+        // Use Google default credentials if endpoint has https scheme.
+        if (endpointOverride.find(kHttpsScheme) == 0) {
+          options.set<gc::UnifiedCredentialsOption>(
+              gc::MakeGoogleDefaultCredentials());
+        } else {
+          options.set<gc::UnifiedCredentialsOption>(
+              gc::MakeInsecureCredentials());
+        }
       } else {
         options.set<gc::UnifiedCredentialsOption>(
-            gc::MakeInsecureCredentials());
+            gc::MakeGoogleDefaultCredentials());
       }
-    } else {
-      options.set<gc::UnifiedCredentialsOption>(
-          gc::MakeGoogleDefaultCredentials());
     }
     options.set<gcs::UploadBufferSizeOption>(kUploadBufferSize);
 
@@ -332,13 +146,16 @@ class GcsFileSystem::Impl {
   }
 
  private:
+  const std::string bucket_;
   const std::shared_ptr<HiveConfig> hiveConfig_;
   std::shared_ptr<gcs::Client> client_;
 };
 
-GcsFileSystem::GcsFileSystem(std::shared_ptr<const config::ConfigBase> config)
+GcsFileSystem::GcsFileSystem(
+    const std::string& bucket,
+    std::shared_ptr<const config::ConfigBase> config)
     : FileSystem(config) {
-  impl_ = std::make_shared<Impl>(config.get());
+  impl_ = std::make_shared<Impl>(bucket, config.get());
 }
 
 void GcsFileSystem::initializeClient() {
@@ -436,18 +253,133 @@ std::string GcsFileSystem::name() const {
   return "GCS";
 }
 
-void GcsFileSystem::rename(std::string_view, std::string_view, bool) {
-  VELOX_UNSUPPORTED("rename for GCS not implemented");
+void GcsFileSystem::rename(
+    std::string_view originPath,
+    std::string_view newPath,
+    bool overwrite) {
+  if (!isGcsFile(originPath)) {
+    VELOX_FAIL(kGcsInvalidPath, originPath);
+  }
+
+  if (!isGcsFile(newPath)) {
+    VELOX_FAIL(kGcsInvalidPath, newPath);
+  }
+
+  std::string originBucket;
+  std::string originObject;
+  const auto originFile = gcsPath(originPath);
+  setBucketAndKeyFromGcsPath(originFile, originBucket, originObject);
+
+  std::string newBucket;
+  std::string newObject;
+  const auto newFile = gcsPath(newPath);
+  setBucketAndKeyFromGcsPath(newFile, newBucket, newObject);
+
+  if (!overwrite) {
+    auto objects = list(newPath);
+    if (std::find(objects.begin(), objects.end(), newObject) != objects.end()) {
+      VELOX_USER_FAIL(
+          "Failed to rename object {} to {} with as {} exists.",
+          originObject,
+          newObject,
+          newObject);
+      return;
+    }
+  }
+
+  // Copy the object to the new name.
+  auto copyStats = impl_->getClient()->CopyObject(
+      originBucket, originObject, newBucket, newObject);
+  if (!copyStats.ok()) {
+    checkGcsStatus(
+        copyStats.status(),
+        fmt::format(
+            "Failed to rename for GCS object {}/{}",
+            originBucket,
+            originObject),
+        originBucket,
+        originObject);
+  }
+
+  // Delete the original object.
+  auto delStatus = impl_->getClient()->DeleteObject(originBucket, originObject);
+  if (!delStatus.ok()) {
+    checkGcsStatus(
+        delStatus,
+        fmt::format(
+            "Failed to delete for GCS object {}/{} after copy when renaming. And the copied object is at {}/{}",
+            originBucket,
+            originObject,
+            newBucket,
+            newObject),
+        originBucket,
+        originObject);
+  }
 }
 
 void GcsFileSystem::mkdir(
     std::string_view path,
     const DirectoryOptions& options) {
-  VELOX_UNSUPPORTED("mkdir for GCS not implemented");
+  if (!isGcsFile(path)) {
+    VELOX_FAIL(kGcsInvalidPath, path);
+  }
+
+  std::string bucket;
+  std::string object;
+  const auto file = gcsPath(path);
+  setBucketAndKeyFromGcsPath(file, bucket, object);
+
+  // Create an empty object to represent the directory.
+  auto status = impl_->getClient()->InsertObject(bucket, object, "");
+
+  checkGcsStatus(
+      status.status(),
+      fmt::format("Failed to mkdir for GCS object {}/{}", bucket, object),
+      bucket,
+      object);
 }
 
 void GcsFileSystem::rmdir(std::string_view path) {
-  VELOX_UNSUPPORTED("rmdir for GCS not implemented");
+  if (!isGcsFile(path)) {
+    VELOX_FAIL(kGcsInvalidPath, path);
+  }
+
+  const auto file = gcsPath(path);
+  std::string bucket;
+  std::string object;
+  setBucketAndKeyFromGcsPath(file, bucket, object);
+  for (auto&& metadata : impl_->getClient()->ListObjects(bucket)) {
+    checkGcsStatus(
+        metadata.status(),
+        fmt::format("Failed to rmdir for GCS object {}/{}", bucket, object),
+        bucket,
+        object);
+
+    auto status = impl_->getClient()->DeleteObject(bucket, metadata->name());
+    checkGcsStatus(
+        metadata.status(),
+        fmt::format(
+            "Failed to delete for GCS object {}/{} when rmdir.",
+            bucket,
+            metadata->name()),
+        bucket,
+        metadata->name());
+  }
+}
+
+void registerOAuthCredentialsProvider(
+    const std::string& providerName,
+    const GcsOAuthCredentialsProviderFactory& factory) {
+  VELOX_CHECK(
+      !providerName.empty(),
+      "GcsOAuthCredentialsProviderFactory name cannot be empty");
+  credentialsProviderFactories().withWLock([&](auto& factories) {
+    VELOX_CHECK(
+        factories.find(providerName) == factories.end(),
+        "GcsOAuthCredentialsProviderFactory '{}' already registered",
+        providerName);
+    factories.insert({providerName, factory});
+  });
 }
 
 } // namespace filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.h b/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.h
index 34daff8d6c64..eeef856bed05 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.h
@@ -17,6 +17,8 @@
 #pragma once
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConfig.h"
+#include "velox/connectors/hive/storage_adapters/gcs/GcsOAuthCredentialsProvider.h"
 
 namespace facebook::velox::filesystems {
 
@@ -26,7 +28,9 @@ namespace facebook::velox::filesystems {
 /// (register|generate)ReadFile and (register|generate)WriteFile functions.
 class GcsFileSystem : public FileSystem {
  public:
-  explicit GcsFileSystem(std::shared_ptr<const config::ConfigBase> config);
+  explicit GcsFileSystem(
+      const std::string& bucket,
+      std::shared_ptr<const config::ConfigBase> config);
 
   /// Initialize the google::cloud::storage::Client from the input Config
   /// parameters.
@@ -66,7 +70,8 @@ class GcsFileSystem : public FileSystem {
   /// Returns the name of the adapter (GCS)
   std::string name() const override;
 
-  /// Unsupported
+  /// Removes the objects associated to a path by using
+  /// google::cloud::storage::Client::DeleteObject.
   void remove(std::string_view path) override;
 
   /// Check that the path exists by using
@@ -77,14 +82,25 @@ class GcsFileSystem : public FileSystem {
   /// google::cloud::storage::Client::ListObjects
   std::vector<std::string> list(std::string_view path) override;
 
-  /// Unsupported
-  void rename(std::string_view, std::string_view, bool) override;
-
-  /// Unsupported
+  /// Renames the original object to the new object using
+  /// google::cloud::storage::Client::CopyObject and
+  /// google::cloud::storage::Client::DeleteObject.
+  /// Note that this process involves separate copy and delete operations, which
+  /// may lead to temporary inconsistencies if either operation fails or if
+  /// there is a delay between them.
+  void rename(
+      std::string_view originPath,
+      std::string_view newPath,
+      bool overwrite) override;
+
+  /// Supports mkdir operation by using
+  /// google::cloud::storage::Client::InsertObject
   void mkdir(std::string_view path, const DirectoryOptions& options = {})
       override;
 
-  /// Unsupported
+  /// Deletes the objects associated to a path using
+  /// google::cloud::storage::Client::ListObjects and
+  /// google::cloud::storage::Client::DeleteObjects
   void rmdir(std::string_view path) override;
 
  protected:
@@ -92,4 +108,12 @@ class GcsFileSystem : public FileSystem {
   std::shared_ptr<Impl> impl_;
 };
 
+using GcsOAuthCredentialsProviderFactory =
+    std::function<std::shared_ptr<GcsOAuthCredentialsProvider>(
+        const std::shared_ptr<connector::hive::HiveConfig>& hiveConfig)>;
+
+void registerOAuthCredentialsProvider(
+    const std::string& providerName,
+    const GcsOAuthCredentialsProviderFactory& factory);
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsOAuthCredentialsProvider.h b/velox/connectors/hive/storage_adapters/gcs/GcsOAuthCredentialsProvider.h
new file mode 100644
index 000000000000..92a89d3e7321
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsOAuthCredentialsProvider.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 <google/cloud/storage/oauth2/credentials.h>
+
+namespace facebook::velox::filesystems {
+
+namespace gcs = ::google::cloud::storage;
+
+/// Interface for providing OAuth2 credentials for Google Cloud Storage (GCS).
+/// Implementations should return a GCS OAuth2 credential used for creating the
+/// GCS client for a specific bucket via `getCredentials`.
+class GcsOAuthCredentialsProvider {
+ public:
+  virtual ~GcsOAuthCredentialsProvider() = default;
+
+  virtual std::shared_ptr<gcs::oauth2::Credentials> getCredentials(
+      const std::string& bucket) = 0;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.cpp b/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.cpp
new file mode 100644
index 000000000000..e8cf14dbb2f4
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.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 "velox/connectors/hive/storage_adapters/gcs/GcsReadFile.h"
+#include "velox/connectors/hive/storage_adapters/gcs/GcsUtil.h"
+
+namespace facebook::velox::filesystems {
+
+namespace gcs = ::google::cloud::storage;
+
+class GcsReadFile::Impl {
+ public:
+  Impl(const std::string& path, std::shared_ptr<gcs::Client> client)
+      : client_(client) {
+    setBucketAndKeyFromGcsPath(path, bucket_, key_);
+  }
+
+  // Gets the length of the file.
+  // Checks if there are any issues reading the file.
+  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;
+    }
+    // get metadata and initialize length
+    auto metadata = client_->GetObjectMetadata(bucket_, key_);
+    if (!metadata.ok()) {
+      checkGcsStatus(
+          metadata.status(),
+          "Failed to get metadata for GCS object",
+          bucket_,
+          key_);
+    }
+    length_ = (*metadata).size();
+    VELOX_CHECK_GE(length_, 0);
+  }
+
+  std::string_view pread(
+      uint64_t offset,
+      uint64_t length,
+      void* buffer,
+      std::atomic<uint64_t>& bytesRead,
+      const FileStorageContext& fileStorageContext) const {
+    preadInternal(offset, length, static_cast<char*>(buffer), bytesRead);
+    return {static_cast<char*>(buffer), length};
+  }
+
+  std::string pread(
+      uint64_t offset,
+      uint64_t length,
+      std::atomic<uint64_t>& bytesRead,
+      const FileStorageContext& fileStorageContext) const {
+    std::string result(length, 0);
+    char* position = result.data();
+    preadInternal(offset, length, position, bytesRead);
+    return result;
+  }
+
+  uint64_t preadv(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers,
+      std::atomic<uint64_t>& bytesRead,
+      const FileStorageContext& fileStorageContext) const {
+    // 'buffers' contains Ranges(data, size)  with some gaps (data = nullptr) in
+    // between. This call must populate the ranges (except gap ranges)
+    // sequentially starting from 'offset'. If a range pointer is nullptr, the
+    // data from stream of size range.size() will be skipped.
+    size_t length = 0;
+    for (const auto range : buffers) {
+      length += range.size();
+    }
+    std::string result(length, 0);
+    preadInternal(offset, length, static_cast<char*>(result.data()), bytesRead);
+    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 size() const {
+    return length_;
+  }
+
+  uint64_t memoryUsage() const {
+    return sizeof(GcsReadFile) // this class
+        + sizeof(gcs::Client) // pointee
+        + kUploadBufferSize; // buffer size
+  }
+
+  std::string getName() const {
+    return key_;
+  }
+
+ private:
+  // The assumption here is that "position" has space for at least "length"
+  // bytes.
+  void preadInternal(
+      uint64_t offset,
+      uint64_t length,
+      char* position,
+      std::atomic<uint64_t>& bytesRead_) const {
+    gcs::ObjectReadStream stream = client_->ReadObject(
+        bucket_, key_, gcs::ReadRange(offset, offset + length));
+    if (!stream) {
+      checkGcsStatus(
+          stream.status(), "Failed to get GCS object", bucket_, key_);
+    }
+
+    stream.read(position, length);
+    if (!stream) {
+      checkGcsStatus(
+          stream.status(), "Failed to get read object", bucket_, key_);
+    }
+    bytesRead_ += length;
+  }
+
+  std::shared_ptr<gcs::Client> client_;
+  std::string bucket_;
+  std::string key_;
+  std::atomic<int64_t> length_ = -1;
+};
+
+GcsReadFile::GcsReadFile(
+    const std::string& path,
+    std::shared_ptr<gcs::Client> client)
+    : impl_(std::make_unique<Impl>(path, client)) {}
+
+GcsReadFile::~GcsReadFile() = default;
+
+void GcsReadFile::initialize(const filesystems::FileOptions& options) {
+  impl_->initialize(options);
+}
+
+std::string_view GcsReadFile::pread(
+    uint64_t offset,
+    uint64_t length,
+    void* buffer,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->pread(offset, length, buffer, bytesRead_, fileStorageContext);
+}
+
+std::string GcsReadFile::pread(
+    uint64_t offset,
+    uint64_t length,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->pread(offset, length, bytesRead_, fileStorageContext);
+}
+uint64_t GcsReadFile::preadv(
+    uint64_t offset,
+    const std::vector<folly::Range<char*>>& buffers,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->preadv(offset, buffers, bytesRead_, fileStorageContext);
+}
+
+uint64_t GcsReadFile::size() const {
+  return impl_->size();
+}
+
+uint64_t GcsReadFile::memoryUsage() const {
+  return impl_->memoryUsage();
+}
+
+std::string GcsReadFile::getName() const {
+  return impl_->getName();
+}
+
+uint64_t GcsReadFile::getNaturalReadSize() const {
+  return kUploadBufferSize;
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.h b/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.h
new file mode 100644
index 000000000000..6e79ee34afde
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsReadFile.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 <google/cloud/storage/client.h>
+#include "velox/common/file/File.h"
+
+namespace facebook::velox::filesystems {
+
+/**
+ * Implementation of gcs read file.
+ */
+class GcsReadFile : public ReadFile {
+ public:
+  GcsReadFile(
+      const std::string& path,
+      std::shared_ptr<::google::cloud::storage::Client> client);
+
+  ~GcsReadFile() override;
+
+  void initialize(const filesystems::FileOptions& options);
+
+  std::string_view pread(
+      uint64_t offset,
+      uint64_t length,
+      void* buffer,
+      const FileStorageContext& fileStorageContext = {}) const override;
+
+  std::string pread(
+      uint64_t offset,
+      uint64_t length,
+      const FileStorageContext& fileStorageContext = {}) const override;
+
+  uint64_t preadv(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers,
+      const FileStorageContext& fileStorageContext = {}) const override;
+
+  uint64_t size() const override;
+
+  uint64_t memoryUsage() const override;
+
+  bool shouldCoalesce() const final {
+    return false;
+  }
+
+  std::string getName() const override;
+
+  uint64_t getNaturalReadSize() const override;
+
+ protected:
+  class Impl;
+  std::shared_ptr<Impl> impl_;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsUtil.cpp b/velox/connectors/hive/storage_adapters/gcs/GcsUtil.cpp
index 8035e4a1e29f..b9fffb3fa1d4 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GcsUtil.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsUtil.cpp
@@ -34,4 +34,24 @@ std::string getErrorStringFromGcsError(const google::cloud::StatusCode& code) {
   }
 }
 
+void checkGcsStatus(
+    const google::cloud::Status outcome,
+    const std::string_view& errorMsgPrefix,
+    const std::string& bucket,
+    const std::string& key) {
+  if (!outcome.ok()) {
+    const auto errMsg = fmt::format(
+        "{} due to: Path:'{}', SDK Error Type:{}, GCS Status Code:{},  Message:'{}'",
+        errorMsgPrefix,
+        gcsURI(bucket, key),
+        outcome.error_info().domain(),
+        getErrorStringFromGcsError(outcome.code()),
+        outcome.message());
+    if (outcome.code() == google::cloud::StatusCode::kNotFound) {
+      VELOX_FILE_NOT_FOUND_ERROR(errMsg);
+    }
+    VELOX_FAIL(errMsg);
+  }
+}
+
 } // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsUtil.h b/velox/connectors/hive/storage_adapters/gcs/GcsUtil.h
index e16736fb938f..ac02793ad111 100644
--- a/velox/connectors/hive/storage_adapters/gcs/GcsUtil.h
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsUtil.h
@@ -20,6 +20,18 @@
 
 namespace facebook::velox {
 
+// Reference: https://github.com/apache/arrow/issues/29916
+// Change the default upload buffer size. In general, sending larger buffers is
+// more efficient with GCS, as each buffer requires a roundtrip to the service.
+// With formatted output (when using `operator<<`), keeping a larger buffer in
+// memory before uploading makes sense.  With unformatted output (the only
+// choice given gcs::io::OutputStream's API) it is better to let the caller
+// provide as large a buffer as they want. The GCS C++ client library will
+// upload this buffer with zero copies if possible.
+auto constexpr kUploadBufferSize = 256 * 1024;
+
+constexpr const char* kGcsDefaultCacheKeyPrefix = "gcs-default-key";
+
 namespace {
 constexpr const char* kSep{"/"};
 constexpr std::string_view kGcsScheme{"gs://"};
@@ -58,4 +70,10 @@ inline std::string gcsPath(const std::string_view& path) {
   return std::string(path.substr(kGcsScheme.length()));
 }
 
+void checkGcsStatus(
+    const google::cloud::Status outcome,
+    const std::string_view& errorMsgPrefix,
+    const std::string& bucket,
+    const std::string& key);
+
 } // namespace facebook::velox
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsWriteFile.cpp b/velox/connectors/hive/storage_adapters/gcs/GcsWriteFile.cpp
new file mode 100644
index 000000000000..d47bc64db69c
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsWriteFile.cpp
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/GcsWriteFile.h"
+#include "velox/connectors/hive/storage_adapters/gcs/GcsUtil.h"
+
+namespace facebook::velox::filesystems {
+
+namespace gcs = ::google::cloud::storage;
+
+class GcsWriteFile::Impl {
+ public:
+  Impl(const std::string& path, std::shared_ptr<gcs::Client> client)
+      : client_(client) {
+    setBucketAndKeyFromGcsPath(path, bucket_, key_);
+  }
+
+  ~Impl() {
+    close();
+  }
+
+  void initialize() {
+    // Make it a no-op if invoked twice.
+    if (size_ != -1) {
+      return;
+    }
+
+    // Check that it doesn't exist, if it does throw an error
+    auto object_metadata = client_->GetObjectMetadata(bucket_, key_);
+    VELOX_CHECK(!object_metadata.ok(), "File already exists");
+
+    auto stream = client_->WriteObject(bucket_, key_);
+    checkGcsStatus(
+        stream.last_status(),
+        "Failed to open GCS object for writing",
+        bucket_,
+        key_);
+    stream_ = std::move(stream);
+    size_ = 0;
+  }
+
+  void append(const std::string_view data) {
+    VELOX_CHECK(isFileOpen(), "File is not open");
+    stream_ << data;
+    size_ += data.size();
+  }
+
+  void flush() {
+    if (isFileOpen()) {
+      stream_.flush();
+    }
+  }
+
+  void close() {
+    if (isFileOpen()) {
+      stream_.flush();
+      stream_.Close();
+      closed_ = true;
+    }
+  }
+
+  uint64_t size() const {
+    return size_;
+  }
+
+ private:
+  inline bool isFileOpen() {
+    return (!closed_ && stream_.IsOpen());
+  }
+
+  gcs::ObjectWriteStream stream_;
+  std::shared_ptr<gcs::Client> client_;
+  std::string bucket_;
+  std::string key_;
+  std::atomic<int64_t> size_{-1};
+  std::atomic<bool> closed_{false};
+};
+
+GcsWriteFile::GcsWriteFile(
+    const std::string& path,
+    std::shared_ptr<gcs::Client> client)
+    : impl_(std::make_unique<Impl>(path, client)) {}
+
+GcsWriteFile::~GcsWriteFile() = default;
+
+void GcsWriteFile::initialize() {
+  impl_->initialize();
+}
+
+void GcsWriteFile::append(const std::string_view data) {
+  impl_->append(data);
+}
+
+void GcsWriteFile::flush() {
+  impl_->flush();
+}
+
+void GcsWriteFile::close() {
+  impl_->close();
+}
+
+uint64_t GcsWriteFile::size() const {
+  return impl_->size();
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/GcsWriteFile.h b/velox/connectors/hive/storage_adapters/gcs/GcsWriteFile.h
new file mode 100644
index 000000000000..3e6527c3cf6b
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/gcs/GcsWriteFile.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 <google/cloud/storage/client.h>
+#include "velox/common/file/File.h"
+
+namespace facebook::velox::filesystems {
+
+/**
+ * Implementation of gcs write file.
+ */
+class GcsWriteFile : public WriteFile {
+ public:
+  GcsWriteFile(
+      const std::string& path,
+      std::shared_ptr<::google::cloud::storage::Client> client);
+
+  ~GcsWriteFile() override;
+
+  void initialize();
+
+  /// Writes the data by append mode.
+  void append(std::string_view data) override;
+
+  /// Flushs the data.
+  void flush() override;
+
+  /// Closes the file.
+  void close() override;
+
+  /// Gets the file size.
+  uint64_t size() const override;
+
+ protected:
+  class Impl;
+  std::shared_ptr<Impl> impl_;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.cpp b/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.cpp
index 1622e43f6085..d1ae189c7f8b 100644
--- a/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.cpp
@@ -14,8 +14,11 @@
  * limitations under the License.
  */
 
+#include "velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h"
+
 #ifdef VELOX_ENABLE_GCS
 #include "velox/common/config/Config.h"
+#include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.h" // @manual
 #include "velox/connectors/hive/storage_adapters/gcs/GcsUtil.h" // @manual
 #include "velox/dwio/common/FileSink.h"
@@ -24,7 +27,15 @@
 namespace facebook::velox::filesystems {
 
 #ifdef VELOX_ENABLE_GCS
-folly::once_flag GcsInstantiationFlag;
+
+using FileSystemMap = folly::Synchronized<
+    std::unordered_map<std::string, std::shared_ptr<FileSystem>>>;
+
+/// Multiple GCS filesystems are supported.
+FileSystemMap& gcsFileSystems() {
+  static FileSystemMap instances;
+  return instances;
+}
 
 std::function<std::shared_ptr<
     FileSystem>(std::shared_ptr<const config::ConfigBase>, std::string_view)>
@@ -32,24 +43,52 @@ gcsFileSystemGenerator() {
   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;
+        const auto file = gcsPath(filePath);
+        std::string bucket;
+        std::string object;
+        setBucketAndKeyFromGcsPath(file, bucket, object);
+        auto cacheKey = fmt::format(
+            "{}-{}",
+            properties->get<std::string>(
+                connector::hive::HiveConfig::kGcsEndpoint,
+                kGcsDefaultCacheKeyPrefix),
+            bucket);
+
+        // Check if an instance exists with a read lock (shared).
+        auto fs = gcsFileSystems().withRLock(
+            [&](auto& instanceMap) -> std::shared_ptr<FileSystem> {
+              auto iterator = instanceMap.find(cacheKey);
+              if (iterator != instanceMap.end()) {
+                return iterator->second;
+              }
+              return nullptr;
+            });
+        if (fs != nullptr) {
+          return fs;
+        }
+
+        return gcsFileSystems().withWLock(
+            [&](auto& instanceMap) -> std::shared_ptr<FileSystem> {
+              // Repeat the checks with a write lock.
+              auto iterator = instanceMap.find(cacheKey);
+              if (iterator != instanceMap.end()) {
+                return iterator->second;
+              }
+
+              std::shared_ptr<GcsFileSystem> fs;
+              if (properties != nullptr) {
+                fs = std::make_shared<GcsFileSystem>(bucket, properties);
+              } else {
+                fs = std::make_shared<GcsFileSystem>(
+                    bucket,
+                    std::make_shared<config::ConfigBase>(
+                        std::unordered_map<std::string, std::string>()));
+              }
+              fs->initializeClient();
+
+              instanceMap.insert({cacheKey, fs});
+              return fs;
+            });
       };
   return filesystemGenerator;
 }
@@ -78,4 +117,12 @@ void registerGcsFileSystem() {
 #endif
 }
 
+void registerGcsOAuthCredentialsProvider(
+    const std::string& providerName,
+    const GcsOAuthCredentialsProviderFactory& factory) {
+#ifdef VELOX_ENABLE_GCS
+  registerOAuthCredentialsProvider(providerName, factory);
+#endif
+}
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h b/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h
index b0f668d6f413..0a6deb48dc5a 100644
--- a/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h
@@ -16,9 +16,26 @@
 
 #pragma once
 
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace facebook::velox::connector::hive {
+class HiveConfig;
+}
+
 namespace facebook::velox::filesystems {
+class GcsOAuthCredentialsProvider;
 
 // Register the GCS filesystem.
 void registerGcsFileSystem();
 
+using GcsOAuthCredentialsProviderFactory =
+    std::function<std::shared_ptr<GcsOAuthCredentialsProvider>(
+        const std::shared_ptr<connector::hive::HiveConfig>& hiveConfig)>;
+
+void registerGcsOAuthCredentialsProvider(
+    const std::string& providerName,
+    const GcsOAuthCredentialsProviderFactory& factory);
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/examples/CMakeLists.txt b/velox/connectors/hive/storage_adapters/gcs/examples/CMakeLists.txt
index 1363d688da44..9f6da5dee157 100644
--- a/velox/connectors/hive/storage_adapters/gcs/examples/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/gcs/examples/CMakeLists.txt
@@ -21,4 +21,5 @@ target_link_libraries(
   velox_core
   velox_hive_connector
   velox_dwio_common_exception
-  velox_exec)
+  velox_exec
+)
diff --git a/velox/connectors/hive/storage_adapters/gcs/examples/GcsFileSystemExample.cpp b/velox/connectors/hive/storage_adapters/gcs/examples/GcsFileSystemExample.cpp
index 08d9b83a0152..f5e19454ebd0 100644
--- a/velox/connectors/hive/storage_adapters/gcs/examples/GcsFileSystemExample.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/examples/GcsFileSystemExample.cpp
@@ -16,6 +16,7 @@
 #include "velox/common/config/Config.h"
 #include "velox/common/file/File.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GcsFileSystem.h"
+#include "velox/connectors/hive/storage_adapters/gcs/GcsUtil.h"
 
 #include <folly/init/Init.h>
 #include <gflags/gflags.h>
@@ -45,7 +46,10 @@ int main(int argc, char** argv) {
     gflags::ShowUsageWithFlags(argv[0]);
     return 1;
   }
-  filesystems::GcsFileSystem gcfs(newConfiguration());
+  std::string bucket;
+  std::string object;
+  setBucketAndKeyFromGcsPath(FLAGS_gcs_path, bucket, object);
+  filesystems::GcsFileSystem gcfs(bucket, newConfiguration());
   gcfs.initializeClient();
   std::cout << "Opening file for read " << FLAGS_gcs_path << std::endl;
   std::unique_ptr<ReadFile> file_read = gcfs.openFileForRead(FLAGS_gcs_path);
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
index 6a775a72f07d..1d848f671f60 100644
--- a/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/CMakeLists.txt
@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_gcsfile_test GcsUtilTest.cpp GcsFileSystemTest.cpp)
-add_test(velox_gcsfile_test velox_gcsfile_test)
+add_executable(velox_gcs_file_test GcsUtilTest.cpp GcsFileSystemTest.cpp)
+add_test(velox_gcs_file_test velox_gcs_file_test)
 target_link_libraries(
-  velox_gcsfile_test
+  velox_gcs_file_test
   velox_core
   velox_dwio_common_exception
   velox_exec
@@ -26,7 +26,8 @@ target_link_libraries(
   velox_temp_path
   GTest::gmock
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_gcs_insert_test GcsInsertTest.cpp)
 add_test(velox_gcs_insert_test velox_gcs_insert_test)
@@ -36,9 +37,30 @@ target_link_libraries(
   velox_gcs
   velox_hive_config
   velox_core
+  velox_dwio_parquet_reader
+  velox_dwio_parquet_writer
   velox_exec_test_lib
   velox_dwio_common_exception
   velox_exec
   GTest::gmock
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
+
+add_executable(velox_gcs_multiendpoints_test GcsMultipleEndpointsTest.cpp)
+add_test(velox_gcs_multiendpoints_test velox_gcs_multiendpoints_test)
+target_link_libraries(
+  velox_gcs_multiendpoints_test
+  velox_file
+  velox_gcs
+  velox_hive_config
+  velox_core
+  velox_exec_test_lib
+  velox_dwio_parquet_reader
+  velox_dwio_parquet_writer
+  velox_dwio_common_exception
+  velox_exec
+  GTest::gmock
+  GTest::gtest
+  GTest::gtest_main
+)
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/GcsEmulator.h b/velox/connectors/hive/storage_adapters/gcs/tests/GcsEmulator.h
index 12db0a12808f..bea464f6fe02 100644
--- a/velox/connectors/hive/storage_adapters/gcs/tests/GcsEmulator.h
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/GcsEmulator.h
@@ -22,6 +22,7 @@
 #include "gtest/gtest.h"
 
 #include "velox/common/config/Config.h"
+#include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GcsUtil.h"
 #include "velox/exec/tests/utils/PortUtil.h"
 
@@ -92,7 +93,7 @@ class GcsEmulator : public testing::Environment {
       const std::unordered_map<std::string, std::string> configOverride = {})
       const {
     std::unordered_map<std::string, std::string> config(
-        {{"hive.gcs.endpoint", endpoint_}});
+        {{connector::hive::HiveConfig::kGcsEndpoint, endpoint_}});
 
     // Update the default config map with the supplied configOverride map
     for (const auto& [configName, configValue] : configOverride) {
@@ -102,7 +103,7 @@ class GcsEmulator : public testing::Environment {
     return std::make_shared<const config::ConfigBase>(std::move(config));
   }
 
-  std::string_view preexistingBucketName() {
+  const std::string& preexistingBucketName() {
     return bucketName_;
   }
 
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/GcsFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/gcs/tests/GcsFileSystemTest.cpp
index a80842208f89..4a465cacaefb 100644
--- a/velox/connectors/hive/storage_adapters/gcs/tests/GcsFileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/GcsFileSystemTest.cpp
@@ -18,6 +18,7 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/File.h"
 #include "velox/connectors/hive/storage_adapters/gcs/GcsUtil.h"
+#include "velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/gcs/tests/GcsEmulator.h"
 #include "velox/exec/tests/utils/TempFilePath.h"
 
@@ -26,6 +27,16 @@
 namespace facebook::velox::filesystems {
 namespace {
 
+class DummyGcsOAuthCredentialsProvider : public GcsOAuthCredentialsProvider {
+ public:
+  explicit DummyGcsOAuthCredentialsProvider() : GcsOAuthCredentialsProvider() {}
+
+  std::shared_ptr<gcs::oauth2::Credentials> getCredentials(
+      const std::string&) override {
+    VELOX_FAIL("DummyGcsOAuthCredentialsProvider: Not implemented");
+  }
+};
+
 class GcsFileSystemTest : public testing::Test {
  public:
   void SetUp() {
@@ -40,7 +51,8 @@ TEST_F(GcsFileSystemTest, readFile) {
   const auto gcsFile = gcsURI(
       emulator_->preexistingBucketName(), emulator_->preexistingObjectName());
 
-  filesystems::GcsFileSystem gcfs(emulator_->hiveConfig());
+  filesystems::GcsFileSystem gcfs(
+      emulator_->preexistingBucketName(), emulator_->hiveConfig());
   gcfs.initializeClient();
   auto readFile = gcfs.openFileForRead(gcsFile);
   std::int64_t size = readFile->size();
@@ -48,8 +60,8 @@ TEST_F(GcsFileSystemTest, readFile) {
   EXPECT_EQ(size, ref_size);
   EXPECT_EQ(readFile->pread(0, size), kLoremIpsum);
 
-  char buffer1[size];
-  ASSERT_EQ(readFile->pread(0, size, &buffer1), kLoremIpsum);
+  std::vector<char> buffer1(size);
+  ASSERT_EQ(readFile->pread(0, size, buffer1.data()), kLoremIpsum);
   ASSERT_EQ(readFile->size(), ref_size);
 
   char buffer2[50];
@@ -77,7 +89,8 @@ TEST_F(GcsFileSystemTest, writeAndReadFile) {
   const std::string_view newFile = "readWriteFile.txt";
   const auto gcsFile = gcsURI(emulator_->preexistingBucketName(), newFile);
 
-  filesystems::GcsFileSystem gcfs(emulator_->hiveConfig());
+  filesystems::GcsFileSystem gcfs(
+      emulator_->preexistingBucketName(), emulator_->hiveConfig());
   gcfs.initializeClient();
   auto writeFile = gcfs.openFileForWrite(gcsFile);
   std::string_view kDataContent =
@@ -103,45 +116,84 @@ TEST_F(GcsFileSystemTest, writeAndReadFile) {
   EXPECT_EQ(readFile->pread(0, size), kDataContent);
 
   // Opening an existing file for write must be an error.
-  filesystems::GcsFileSystem newGcfs(emulator_->hiveConfig());
+  filesystems::GcsFileSystem newGcfs(
+      emulator_->preexistingBucketName(), emulator_->hiveConfig());
   newGcfs.initializeClient();
   VELOX_ASSERT_THROW(newGcfs.openFileForWrite(gcsFile), "File already exists");
 }
 
-TEST_F(GcsFileSystemTest, renameNotImplemented) {
-  const std::string_view file = "newTest.txt";
-  const auto gcsExistingFile = gcsURI(
-      emulator_->preexistingBucketName(), emulator_->preexistingObjectName());
-  const auto gcsNewFile = gcsURI(emulator_->preexistingBucketName(), file);
-  filesystems::GcsFileSystem gcfs(emulator_->hiveConfig());
+TEST_F(GcsFileSystemTest, rename) {
+  filesystems::GcsFileSystem gcfs(
+      emulator_->preexistingBucketName(), emulator_->hiveConfig());
   gcfs.initializeClient();
-  gcfs.openFileForRead(gcsExistingFile);
+
+  const std::string_view oldFile = "oldTest.txt";
+  const std::string_view newFile = "newTest.txt";
+
+  const auto gcsExistingFile =
+      gcsURI(emulator_->preexistingBucketName(), oldFile);
+  auto writeFile = gcfs.openFileForWrite(gcsExistingFile);
+  std::string_view kDataContent = "GcsFileSystemTest rename operation test";
+  writeFile->append(kDataContent.substr(0, 10));
+  writeFile->flush();
+  writeFile->close();
+
+  const auto gcsNewFile = gcsURI(emulator_->preexistingBucketName(), newFile);
+
   VELOX_ASSERT_THROW(
-      gcfs.rename(gcsExistingFile, gcsNewFile, true),
-      "rename for GCS not implemented");
+      gcfs.rename(gcsExistingFile, gcsExistingFile, false),
+      fmt::format(
+          "Failed to rename object {} to {} with as {} exists.",
+          oldFile,
+          oldFile,
+          oldFile));
+
+  gcfs.rename(gcsExistingFile, gcsNewFile, true);
+
+  auto results = gcfs.list(gcsNewFile);
+  ASSERT_TRUE(
+      std::find(results.begin(), results.end(), oldFile) == results.end());
+  ASSERT_TRUE(
+      std::find(results.begin(), results.end(), newFile) != results.end());
 }
 
-TEST_F(GcsFileSystemTest, mkdirNotImplemented) {
+TEST_F(GcsFileSystemTest, mkdir) {
   const std::string_view dir = "newDirectory";
   const auto gcsNewDirectory = gcsURI(emulator_->preexistingBucketName(), dir);
-  filesystems::GcsFileSystem gcfs(emulator_->hiveConfig());
+  filesystems::GcsFileSystem gcfs(
+      emulator_->preexistingBucketName(), emulator_->hiveConfig());
   gcfs.initializeClient();
-  VELOX_ASSERT_THROW(
-      gcfs.mkdir(gcsNewDirectory), "mkdir for GCS not implemented");
+  gcfs.mkdir(gcsNewDirectory);
+  const auto& results = gcfs.list(gcsNewDirectory);
+  ASSERT_TRUE(std::find(results.begin(), results.end(), dir) != results.end());
 }
 
-TEST_F(GcsFileSystemTest, rmdirNotImplemented) {
+TEST_F(GcsFileSystemTest, rmdir) {
   const std::string_view dir = "Directory";
   const auto gcsDirectory = gcsURI(emulator_->preexistingBucketName(), dir);
-  filesystems::GcsFileSystem gcfs(emulator_->hiveConfig());
+  filesystems::GcsFileSystem gcfs(
+      emulator_->preexistingBucketName(), emulator_->hiveConfig());
   gcfs.initializeClient();
-  VELOX_ASSERT_THROW(gcfs.rmdir(gcsDirectory), "rmdir for GCS not implemented");
+
+  auto writeFile = gcfs.openFileForWrite(gcsDirectory);
+  std::string_view kDataContent = "GcsFileSystemTest rename operation test";
+  writeFile->append(kDataContent.substr(0, 10));
+  writeFile->flush();
+  writeFile->close();
+
+  auto results = gcfs.list(gcsDirectory);
+  ASSERT_TRUE(std::find(results.begin(), results.end(), dir) != results.end());
+  gcfs.rmdir(gcsDirectory);
+
+  results = gcfs.list(gcsDirectory);
+  ASSERT_TRUE(std::find(results.begin(), results.end(), dir) == results.end());
 }
 
 TEST_F(GcsFileSystemTest, missingFile) {
   const std::string_view file = "newTest.txt";
   const auto gcsFile = gcsURI(emulator_->preexistingBucketName(), file);
-  filesystems::GcsFileSystem gcfs(emulator_->hiveConfig());
+  filesystems::GcsFileSystem gcfs(
+      emulator_->preexistingBucketName(), emulator_->hiveConfig());
   gcfs.initializeClient();
   VELOX_ASSERT_RUNTIME_THROW_CODE(
       gcfs.openFileForRead(gcsFile),
@@ -150,7 +202,8 @@ TEST_F(GcsFileSystemTest, missingFile) {
 }
 
 TEST_F(GcsFileSystemTest, missingBucket) {
-  filesystems::GcsFileSystem gcfs(emulator_->hiveConfig());
+  filesystems::GcsFileSystem gcfs(
+      emulator_->preexistingBucketName(), emulator_->hiveConfig());
   gcfs.initializeClient();
   const std::string_view gcsFile = "gs://dummy/foo.txt";
   VELOX_ASSERT_RUNTIME_THROW_CODE(
@@ -208,12 +261,77 @@ TEST_F(GcsFileSystemTest, credentialsConfig) {
       {"hive.gcs.json-key-file-path", jsonFile->getPath()}};
   auto hiveConfig = emulator_->hiveConfig(configOverride);
 
-  filesystems::GcsFileSystem gcfs(hiveConfig);
+  filesystems::GcsFileSystem gcfs(
+      emulator_->preexistingBucketName(), hiveConfig);
   gcfs.initializeClient();
   const auto gcsFile = gcsURI(
       emulator_->preexistingBucketName(), emulator_->preexistingObjectName());
   VELOX_ASSERT_THROW(
       gcfs.openFileForRead(gcsFile), "Invalid ServiceAccountCredentials");
 }
+
+TEST_F(GcsFileSystemTest, credentialsProvider) {
+  const auto providerFactory =
+      [](const std::shared_ptr<connector::hive::HiveConfig>&) {
+        return std::make_shared<DummyGcsOAuthCredentialsProvider>();
+      };
+  registerGcsOAuthCredentialsProvider("dummy_provider", providerFactory);
+
+  {
+    std::unordered_map<std::string, std::string> configOverride = {
+        {"hive.gcs.auth.access-token-provider", "dummy_provider"}};
+    auto hiveConfig = emulator_->hiveConfig(configOverride);
+
+    filesystems::GcsFileSystem gcfs(
+        emulator_->preexistingBucketName(), hiveConfig);
+    VELOX_ASSERT_THROW(
+        gcfs.initializeClient(),
+        "DummyGcsOAuthCredentialsProvider: Not implemented");
+
+    VELOX_ASSERT_THROW(
+        registerGcsOAuthCredentialsProvider("", providerFactory),
+        "GcsOAuthCredentialsProviderFactory name cannot be empty");
+
+    VELOX_ASSERT_THROW(
+        registerGcsOAuthCredentialsProvider("dummy_provider", providerFactory),
+        "GcsOAuthCredentialsProviderFactory 'dummy_provider' already registered");
+  }
+
+  // Invalid provider name.
+  {
+    std::unordered_map<std::string, std::string> configOverride = {
+        {"hive.gcs.auth.access-token-provider", ""}};
+    auto hiveConfig = emulator_->hiveConfig(configOverride);
+
+    filesystems::GcsFileSystem gcfs(
+        emulator_->preexistingBucketName(), hiveConfig);
+
+    VELOX_ASSERT_THROW(
+        gcfs.initializeClient(),
+        "GcsOAuthCredentialsProviderFactory name cannot be empty");
+  }
+}
+
+TEST_F(GcsFileSystemTest, defaultCacheKey) {
+  registerGcsFileSystem();
+  std::unordered_map<std::string, std::string> configWithoutEndpoint = {};
+  auto hiveConfigDefault = std::make_shared<const config::ConfigBase>(
+      std::move(configWithoutEndpoint));
+  const auto gcsFile1 = gcsURI(
+      emulator_->preexistingBucketName(), emulator_->preexistingObjectName());
+  // FileSystem should be cached by the default key.
+  auto defaultGcs = filesystems::getFileSystem(gcsFile1, hiveConfigDefault);
+
+  std::unordered_map<std::string, std::string> configWithEndpoint = {
+      {connector::hive::HiveConfig::kGcsEndpoint, kGcsDefaultCacheKeyPrefix}};
+  auto hiveConfigCustom =
+      std::make_shared<const config::ConfigBase>(std::move(configWithEndpoint));
+  const auto gcsFile2 = gcsURI(emulator_->preexistingBucketName(), "dummy.txt");
+  auto customGcs = filesystems::getFileSystem(gcsFile2, hiveConfigCustom);
+  // The same FileSystem should be cached by the value of key
+  // kGcsDefaultCacheKeyPrefix.
+  ASSERT_EQ(customGcs, defaultGcs);
+}
+
 } // namespace
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/gcs/tests/GcsMultipleEndpointsTest.cpp b/velox/connectors/hive/storage_adapters/gcs/tests/GcsMultipleEndpointsTest.cpp
new file mode 100644
index 000000000000..00bb3310a067
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/gcs/tests/GcsMultipleEndpointsTest.cpp
@@ -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 <folly/executors/IOThreadPoolExecutor.h>
+#include <folly/init/Init.h>
+
+#include "gtest/gtest.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/storage_adapters/gcs/RegisterGcsFileSystem.h"
+#include "velox/connectors/hive/storage_adapters/gcs/tests/GcsEmulator.h"
+#include "velox/dwio/parquet/RegisterParquetReader.h"
+#include "velox/dwio/parquet/RegisterParquetWriter.h"
+#include "velox/exec/TableWriter.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+static const std::string_view kConnectorId1 = "test-hive1";
+static const std::string_view kConnectorId2 = "test-hive2";
+static const std::string_view kBucketName = "writedata";
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::filesystems {
+namespace {
+
+class GcsMultipleEndpointsTest : public testing::Test,
+                                 public velox::test::VectorTestBase {
+ public:
+  static void SetUpTestCase() {
+    registerGcsFileSystem();
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    gcsEmulatorOne_ = std::make_unique<GcsEmulator>();
+    gcsEmulatorOne_->bootstrap();
+    gcsEmulatorTwo_ = std::make_unique<GcsEmulator>();
+    gcsEmulatorTwo_->bootstrap();
+
+    parquet::registerParquetReaderFactory();
+    parquet::registerParquetWriterFactory();
+  }
+
+  void registerConnectors(
+      std::string_view connectorId1,
+      std::string_view connectorId2,
+      const std::unordered_map<std::string, std::string> config1Override = {},
+      const std::unordered_map<std::string, std::string> config2Override = {}) {
+    connector::hive::HiveConnectorFactory factory;
+    auto hiveConnector1 = factory.newConnector(
+        std::string(connectorId1),
+        gcsEmulatorOne_->hiveConfig(config1Override),
+        ioExecutor_.get());
+    auto hiveConnector2 = factory.newConnector(
+        std::string(connectorId2),
+        gcsEmulatorTwo_->hiveConfig(config2Override),
+        ioExecutor_.get());
+    connector::registerConnector(hiveConnector1);
+    connector::registerConnector(hiveConnector2);
+  }
+
+  void TearDown() override {
+    parquet::unregisterParquetReaderFactory();
+    parquet::unregisterParquetWriterFactory();
+  }
+
+  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 connector::hive::HiveConnectorSplitBuilder(filePath)
+        .connectorId(connectorId)
+        .fileFormat(dwio::common::FileFormat::PARQUET)
+        .length(fileSize)
+        .build();
+  }
+
+  void testJoin(
+      int numRows,
+      std::string_view outputDirectory,
+      std::string_view connectorId1,
+      std::string_view connectorId2) {
+    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>(numRows, [](auto row) { return row; }),
+         makeFlatVector<int32_t>(numRows, [](auto row) { return row; }),
+         makeFlatVector<int16_t>(numRows, [](auto row) { return row; }),
+         makeFlatVector<double>(numRows, [](auto row) { return row; })});
+    auto input2 = makeRowVector(rowType2->names(), input1->children());
+
+    // Insert input data into both tables.
+    auto table1WriteInfo =
+        writeData(input1, outputDirectory.data(), std::string(connectorId1));
+    auto table2WriteInfo =
+        writeData(input2, outputDirectory.data(), std::string(connectorId2));
+
+    // 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(connectorId1))
+                          .endTableScan()
+                          .capturePlanNodeId(scan1)
+                          .planNode();
+    auto join =
+        PlanBuilder(planNodeIdGenerator, pool())
+            .startTableScan()
+            .tableName("hive_table1")
+            .outputType(rowType2)
+            .connectorId(std::string(connectorId2))
+            .endTableScan()
+            .capturePlanNodeId(scan2)
+            .hashJoin({"b0"}, {"a0"}, table1Scan, "", {"a0", "a1", "a2", "a3"})
+            .planNode();
+
+    auto split1 = createSplit(
+        table1WriteInfo, outputDirectory.data(), std::string(connectorId1));
+    auto split2 = createSplit(
+        table2WriteInfo, outputDirectory.data(), std::string(connectorId2));
+    auto results = AssertQueryBuilder(join)
+                       .split(scan1, split1)
+                       .split(scan2, split2)
+                       .copyResults(pool());
+    assertEqualResults({input1}, {results});
+  }
+
+  std::unique_ptr<GcsEmulator> gcsEmulatorOne_;
+  std::unique_ptr<GcsEmulator> gcsEmulatorTwo_;
+  std::unique_ptr<folly::IOThreadPoolExecutor> ioExecutor_;
+};
+} // namespace
+
+TEST_F(GcsMultipleEndpointsTest, baseEndpoints) {
+  const int64_t kExpectedRows = 1'000;
+
+  const auto gcsBucket = gcsURI(gcsEmulatorOne_->preexistingBucketName(), "");
+
+  registerConnectors(kConnectorId1, kConnectorId2);
+
+  testJoin(kExpectedRows, gcsBucket, kConnectorId1, kConnectorId2);
+
+  connector::unregisterConnector(std::string(kConnectorId1));
+  connector::unregisterConnector(std::string(kConnectorId2));
+}
+
+} // namespace facebook::velox::filesystems
+
+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/hdfs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
index 44aa7be3489c..8c49f3e11ed9 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/hdfs/CMakeLists.txt
@@ -17,18 +17,8 @@
 velox_add_library(velox_hdfs RegisterHdfsFileSystem.cpp)
 
 if(VELOX_ENABLE_HDFS)
-  velox_sources(
-    velox_hdfs
-    PRIVATE
-    HdfsFileSystem.cpp
-    HdfsReadFile.cpp
-    HdfsWriteFile.cpp)
-  velox_link_libraries(
-    velox_hdfs
-    velox_external_hdfs
-    velox_dwio_common
-    Folly::folly
-    xsimd)
+  velox_sources(velox_hdfs PRIVATE HdfsFileSystem.cpp HdfsReadFile.cpp HdfsWriteFile.cpp)
+  velox_link_libraries(velox_hdfs velox_external_hdfs velox_dwio_common Folly::folly 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 856f2b2526de..46522ab2a6f5 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.cpp
@@ -56,11 +56,29 @@ class HdfsFileSystem::Impl {
   }
 
   ~Impl() {
-    LOG(INFO) << "Disconnecting HDFS file system";
-    int disconnectResult = driver_->Disconnect(hdfsClient_);
-    if (disconnectResult != 0) {
-      LOG(WARNING) << "hdfs disconnect failure in HdfsReadFile close: "
-                   << errno;
+    if (!closed_) {
+      LOG(WARNING)
+          << "The HdfsFileSystem instance is not closed upon destruction. You must explicitly call the close() API before JVM termination to ensure proper disconnection.";
+    }
+  }
+
+  // The HdfsFileSystem::Disconnect operation requires the JVM method
+  // definitions to be loaded within an active JVM process.
+  // Therefore, it must be invoked before the JVM shuts down.
+
+  // To address this, we’ve introduced a new close() API that performs the
+  // disconnect operation. Third-party applications can call this close() method
+  // prior to JVM termination to ensure proper cleanup.
+  void close() {
+    if (!closed_) {
+      LOG(WARNING) << "Disconnecting HDFS file system";
+      int disconnectResult = driver_->Disconnect(hdfsClient_);
+      if (disconnectResult != 0) {
+        LOG(WARNING) << "hdfs disconnect failure in HdfsReadFile close: "
+                     << errno;
+      }
+
+      closed_ = true;
     }
   }
 
@@ -75,6 +93,7 @@ class HdfsFileSystem::Impl {
  private:
   hdfsFS hdfsClient_;
   filesystems::arrow::io::internal::LibHdfsShim* driver_;
+  bool closed_ = false;
 };
 
 HdfsFileSystem::HdfsFileSystem(
@@ -91,7 +110,7 @@ std::string HdfsFileSystem::name() const {
 std::unique_ptr<ReadFile> HdfsFileSystem::openFileForRead(
     std::string_view path,
     const FileOptions& /*unused*/) {
-  // Only remove the schema for hdfs path.
+  // Only remove the scheme for hdfs path.
   if (path.find(kScheme) == 0) {
     path.remove_prefix(kScheme.length());
     if (auto index = path.find('/')) {
@@ -109,6 +128,10 @@ std::unique_ptr<WriteFile> HdfsFileSystem::openFileForWrite(
       impl_->hdfsShim(), impl_->hdfsClient(), path);
 }
 
+void HdfsFileSystem::close() {
+  impl_->close();
+}
+
 bool HdfsFileSystem::isHdfsFile(const std::string_view filePath) {
   return (filePath.find(kScheme) == 0) || (filePath.find(kViewfsScheme) == 0);
 }
@@ -129,11 +152,11 @@ HdfsServiceEndpoint HdfsFileSystem::getServiceEndpoint(
     // Fall back to get a fixed endpoint from config.
     auto hdfsHost = config->get<std::string>("hive.hdfs.host");
     VELOX_CHECK(
-        hdfsHost.hasValue(),
+        hdfsHost.has_value(),
         "hdfsHost is empty, configuration missing for hdfs host");
     auto hdfsPort = config->get<std::string>("hive.hdfs.port");
     VELOX_CHECK(
-        hdfsPort.hasValue(),
+        hdfsPort.has_value(),
         "hdfsPort is empty, configuration missing for hdfs port");
     return HdfsServiceEndpoint{*hdfsHost, *hdfsPort};
   }
@@ -152,7 +175,131 @@ HdfsServiceEndpoint HdfsFileSystem::getServiceEndpoint(
 }
 
 void HdfsFileSystem::remove(std::string_view path) {
-  VELOX_UNSUPPORTED("Does not support removing files from hdfs");
+  // Only remove the scheme for hdfs path.
+  if (path.find(kScheme) == 0) {
+    path.remove_prefix(kScheme.length());
+    if (auto index = path.find('/')) {
+      path.remove_prefix(index);
+    }
+  }
+
+  VELOX_CHECK_EQ(
+      impl_->hdfsShim()->Delete(impl_->hdfsClient(), path.data(), 0),
+      0,
+      "Cannot delete file : {} in HDFS, error is : {}",
+      path,
+      impl_->hdfsShim()->GetLastExceptionRootCause());
+}
+
+std::vector<std::string> HdfsFileSystem::list(std::string_view path) {
+  // Only remove the scheme for hdfs path.
+  if (path.find(kScheme) == 0) {
+    path.remove_prefix(kScheme.length());
+    if (auto index = path.find('/')) {
+      path.remove_prefix(index);
+    }
+  }
+
+  std::vector<std::string> result;
+  int numEntries;
+
+  auto fileInfo = impl_->hdfsShim()->ListDirectory(
+      impl_->hdfsClient(), path.data(), &numEntries);
+
+  VELOX_CHECK_NOT_NULL(
+      fileInfo,
+      "Unable to list the files in path {}. got error: {}",
+      path,
+      impl_->hdfsShim()->GetLastExceptionRootCause());
+
+  for (auto i = 0; i < numEntries; i++) {
+    result.emplace_back(fileInfo[i].mName);
+  }
+
+  impl_->hdfsShim()->FreeFileInfo(fileInfo, numEntries);
+
+  return result;
+}
+
+bool HdfsFileSystem::exists(std::string_view path) {
+  // Only remove the scheme for hdfs path.
+  if (path.find(kScheme) == 0) {
+    path.remove_prefix(kScheme.length());
+    if (auto index = path.find('/')) {
+      path.remove_prefix(index);
+    }
+  }
+
+  return impl_->hdfsShim()->Exists(impl_->hdfsClient(), path.data()) == 0;
+}
+
+void HdfsFileSystem::mkdir(
+    std::string_view path,
+    const DirectoryOptions& options) {
+  // Only remove the scheme for hdfs path.
+  if (path.find(kScheme) == 0) {
+    path.remove_prefix(kScheme.length());
+    if (auto index = path.find('/')) {
+      path.remove_prefix(index);
+    }
+  }
+
+  VELOX_CHECK_EQ(
+      impl_->hdfsShim()->MakeDirectory(impl_->hdfsClient(), path.data()),
+      0,
+      "Cannot mkdir {} in HDFS, error is : {}",
+      path,
+      impl_->hdfsShim()->GetLastExceptionRootCause());
+}
+
+void HdfsFileSystem::rename(
+    std::string_view path,
+    std::string_view newPath,
+    bool overWrite) {
+  VELOX_CHECK_EQ(
+      overWrite, false, "HdfsFileSystem::rename doesn't support overwrite");
+  // Only remove the scheme for hdfs path.
+  if (path.find(kScheme) == 0) {
+    path.remove_prefix(kScheme.length());
+    if (auto index = path.find('/')) {
+      path.remove_prefix(index);
+    }
+  }
+
+  // Only remove the scheme for hdfs path.
+  if (newPath.find(kScheme) == 0) {
+    newPath.remove_prefix(kScheme.length());
+    if (auto index = newPath.find('/')) {
+      newPath.remove_prefix(index);
+    }
+  }
+
+  VELOX_CHECK_EQ(
+      impl_->hdfsShim()->Rename(
+          impl_->hdfsClient(), path.data(), newPath.data()),
+      0,
+      "Cannot rename file from {} to {} in HDFS, error is : {}",
+      path,
+      newPath,
+      impl_->hdfsShim()->GetLastExceptionRootCause());
+}
+
+void HdfsFileSystem::rmdir(std::string_view path) {
+  // Only remove the scheme for hdfs path.
+  if (path.find(kScheme) == 0) {
+    path.remove_prefix(kScheme.length());
+    if (auto index = path.find('/')) {
+      path.remove_prefix(index);
+    }
+  }
+
+  VELOX_CHECK_EQ(
+      impl_->hdfsShim()->Delete(
+          impl_->hdfsClient(), path.data(), /*recursive=*/true),
+      0,
+      "Cannot remove directory {} recursively in HDFS, error is : {}",
+      path,
+      impl_->hdfsShim()->GetLastExceptionRootCause());
 }
 
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
index b541ec629baf..9720bb13034b 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h
@@ -61,31 +61,25 @@ class HdfsFileSystem : public FileSystem {
       std::string_view path,
       const FileOptions& options = {}) override;
 
+  void close();
+
+  // Deletes the hdfs files.
   void remove(std::string_view path) override;
 
-  virtual void rename(
+  void rename(
       std::string_view path,
       std::string_view newPath,
-      bool overWrite = false) override {
-    VELOX_UNSUPPORTED("rename for HDFs not implemented");
-  }
+      bool overWrite = false) override;
 
-  bool exists(std::string_view path) override {
-    VELOX_UNSUPPORTED("exists for HDFS not implemented");
-  }
+  bool exists(std::string_view path) override;
 
-  virtual std::vector<std::string> list(std::string_view path) override {
-    VELOX_UNSUPPORTED("list for HDFS not implemented");
-  }
+  /// List the objects associated to a path.
+  std::vector<std::string> list(std::string_view path) override;
 
   void mkdir(std::string_view path, const DirectoryOptions& options = {})
-      override {
-    VELOX_UNSUPPORTED("mkdir for HDFS not implemented");
-  }
+      override;
 
-  void rmdir(std::string_view path) override {
-    VELOX_UNSUPPORTED("rmdir for HDFS not implemented");
-  }
+  void rmdir(std::string_view path) override;
 
   static bool isHdfsFile(std::string_view filename);
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
index affc1dfd2ede..1d320cda44b6 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.cpp
@@ -103,12 +103,19 @@ class HdfsReadFile::Impl {
     }
   }
 
-  std::string_view pread(uint64_t offset, uint64_t length, void* buf) const {
+  std::string_view pread(
+      uint64_t offset,
+      uint64_t length,
+      void* buf,
+      const FileStorageContext& fileStorageContext) const {
     preadInternal(offset, length, static_cast<char*>(buf));
     return {static_cast<char*>(buf), length};
   }
 
-  std::string pread(uint64_t offset, uint64_t length) const {
+  std::string pread(
+      uint64_t offset,
+      uint64_t length,
+      const FileStorageContext& fileStorageContext) const {
     std::string result(length, 0);
     char* pos = result.data();
     preadInternal(offset, length, pos);
@@ -163,15 +170,15 @@ std::string_view HdfsReadFile::pread(
     uint64_t offset,
     uint64_t length,
     void* buf,
-    filesystems::File::IoStats* stats) const {
-  return pImpl->pread(offset, length, buf);
+    const FileStorageContext& fileStorageContext) const {
+  return pImpl->pread(offset, length, buf, fileStorageContext);
 }
 
 std::string HdfsReadFile::pread(
     uint64_t offset,
     uint64_t length,
-    filesystems::File::IoStats* stats) const {
-  return pImpl->pread(offset, length);
+    const FileStorageContext& fileStorageContext) const {
+  return pImpl->pread(offset, length, fileStorageContext);
 }
 
 uint64_t HdfsReadFile::size() const {
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
index ddd35e511a71..a59b178909c6 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h
@@ -38,12 +38,12 @@ class HdfsReadFile final : public ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileStorageContext& fileStorageContext = {}) const final;
 
   std::string pread(
       uint64_t offset,
       uint64_t length,
-      filesystems::File::IoStats* stats = nullptr) const final;
+      const FileStorageContext& fileStorageContext = {}) const final;
 
   uint64_t size() const final;
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp b/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
index be668a3133e1..26d43ccb9100 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/HdfsWriteFile.cpp
@@ -54,12 +54,14 @@ HdfsWriteFile::~HdfsWriteFile() {
 
 void HdfsWriteFile::close() {
   int success = driver_->CloseFile(hdfsClient_, hdfsFile_);
+  common::testutil::TestValue::adjust(
+      "facebook::velox::connectors::hive::HdfsWriteFile::close", &success);
+  hdfsFile_ = nullptr;
   VELOX_CHECK_EQ(
       success,
       0,
       "Failed to close hdfs file: {}",
       driver_->GetLastExceptionRootCause());
-  hdfsFile_ = nullptr;
 }
 
 void HdfsWriteFile::flush() {
diff --git a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
index 1f23179f0a72..bb4f208c4731 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.cpp
@@ -28,44 +28,48 @@ namespace facebook::velox::filesystems {
 #ifdef VELOX_ENABLE_HDFS
 std::mutex mtx;
 
+folly::ConcurrentHashMap<std::string, std::shared_ptr<HdfsFileSystem>>
+    registeredFilesystems;
+
 std::function<std::shared_ptr<
     FileSystem>(std::shared_ptr<const config::ConfigBase>, std::string_view)>
 hdfsFileSystemGenerator() {
-  static auto filesystemGenerator = [](std::shared_ptr<const config::ConfigBase>
-                                           properties,
-                                       std::string_view filePath) {
-    static folly::ConcurrentHashMap<std::string, std::shared_ptr<FileSystem>>
-        filesystems;
-    static folly::
-        ConcurrentHashMap<std::string, std::shared_ptr<folly::once_flag>>
-            hdfsInitiationFlags;
-    HdfsServiceEndpoint endpoint =
-        HdfsFileSystem::getServiceEndpoint(filePath, properties.get());
-    std::string hdfsIdentity = endpoint.identity();
-    if (filesystems.find(hdfsIdentity) != filesystems.end()) {
-      return filesystems[hdfsIdentity];
-    }
-    std::unique_lock<std::mutex> lk(mtx, std::defer_lock);
-    /// If the init flag for a given hdfs identity is not found,
-    /// create one for init use. It's a singleton.
-    if (hdfsInitiationFlags.find(hdfsIdentity) == hdfsInitiationFlags.end()) {
-      lk.lock();
-      if (hdfsInitiationFlags.find(hdfsIdentity) == hdfsInitiationFlags.end()) {
-        std::shared_ptr<folly::once_flag> initiationFlagPtr =
-            std::make_shared<folly::once_flag>();
-        hdfsInitiationFlags.insert(hdfsIdentity, initiationFlagPtr);
-      }
-      lk.unlock();
-    }
-    folly::call_once(
-        *hdfsInitiationFlags[hdfsIdentity].get(),
-        [&properties, endpoint, hdfsIdentity]() {
-          auto filesystem =
-              std::make_shared<HdfsFileSystem>(properties, endpoint);
-          filesystems.insert(hdfsIdentity, filesystem);
-        });
-    return filesystems[hdfsIdentity];
-  };
+  static auto filesystemGenerator =
+      [](std::shared_ptr<const config::ConfigBase> properties,
+         std::string_view filePath) {
+        static folly::
+            ConcurrentHashMap<std::string, std::shared_ptr<folly::once_flag>>
+                hdfsInitiationFlags;
+        HdfsServiceEndpoint endpoint =
+            HdfsFileSystem::getServiceEndpoint(filePath, properties.get());
+        std::string hdfsIdentity = endpoint.identity();
+        if (registeredFilesystems.find(hdfsIdentity) !=
+            registeredFilesystems.end()) {
+          return registeredFilesystems[hdfsIdentity];
+        }
+        std::unique_lock<std::mutex> lk(mtx, std::defer_lock);
+        /// If the init flag for a given hdfs identity is not found,
+        /// create one for init use. It's a singleton.
+        if (hdfsInitiationFlags.find(hdfsIdentity) ==
+            hdfsInitiationFlags.end()) {
+          lk.lock();
+          if (hdfsInitiationFlags.find(hdfsIdentity) ==
+              hdfsInitiationFlags.end()) {
+            std::shared_ptr<folly::once_flag> initiationFlagPtr =
+                std::make_shared<folly::once_flag>();
+            hdfsInitiationFlags.insert(hdfsIdentity, initiationFlagPtr);
+          }
+          lk.unlock();
+        }
+        folly::call_once(
+            *hdfsInitiationFlags[hdfsIdentity].get(),
+            [&properties, endpoint, hdfsIdentity]() {
+              auto filesystem =
+                  std::make_shared<HdfsFileSystem>(properties, endpoint);
+              registeredFilesystems.insert(hdfsIdentity, filesystem);
+            });
+        return registeredFilesystems[hdfsIdentity];
+      };
   return filesystemGenerator;
 }
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h
index 6f6f0c032bd7..18eef4aca176 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h
@@ -16,8 +16,15 @@
 
 #pragma once
 
+#include "folly/concurrency/ConcurrentHashMap.h"
+
 namespace facebook::velox::filesystems {
 
+class HdfsFileSystem;
+
+extern folly::ConcurrentHashMap<std::string, std::shared_ptr<HdfsFileSystem>>
+    registeredFilesystems;
+
 // Register the HDFS.
 void registerHdfsFileSystem();
 
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
index 3e3b8b2d5a24..bdefd5b93c78 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/CMakeLists.txt
@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_hdfs_file_test HdfsFileSystemTest.cpp HdfsMiniCluster.cpp
-                                    HdfsUtilTest.cpp)
+add_executable(velox_hdfs_file_test HdfsFileSystemTest.cpp HdfsMiniCluster.cpp HdfsUtilTest.cpp)
 
 add_test(velox_hdfs_file_test velox_hdfs_file_test)
 target_link_libraries(
@@ -27,32 +26,33 @@ target_link_libraries(
   velox_exec
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
 
-target_compile_options(velox_hdfs_file_test
-                       PRIVATE -Wno-deprecated-declarations)
+target_compile_options(velox_hdfs_file_test PRIVATE -Wno-deprecated-declarations)
 
-add_executable(velox_hdfs_insert_test HdfsInsertTest.cpp HdfsMiniCluster.cpp
-                                      HdfsUtilTest.cpp)
+add_executable(velox_hdfs_insert_test HdfsInsertTest.cpp HdfsMiniCluster.cpp HdfsUtilTest.cpp)
 
 add_test(velox_hdfs_insert_test velox_hdfs_insert_test)
 
 target_link_libraries(
   velox_hdfs_insert_test
+  velox_dwio_parquet_reader
+  velox_dwio_parquet_writer
+  velox_hdfs
   velox_exec_test_lib
   velox_exec
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
 
-target_compile_options(velox_hdfs_insert_test
-                       PRIVATE -Wno-deprecated-declarations)
+target_compile_options(velox_hdfs_insert_test PRIVATE -Wno-deprecated-declarations)
 
 # velox_hdfs_insert_test and velox_hdfs_file_test two tests can't run in
 # parallel due to the port conflict in Hadoop NameNode and DataNode. The
 # namenode port conflict can be resolved using the -nnport configuration in
-# hadoop-mapreduce-client-jobclient-3.3.0-tests.jar. However the data node port
+# hadoop-mapreduce-client-jobclient-3.3.6-tests.jar. However the data node port
 # cannot be configured. Therefore, we need to make sure that
 # velox_hdfs_file_test runs only after velox_hdfs_insert_test has finished.
-set_tests_properties(velox_hdfs_insert_test PROPERTIES DEPENDS
-                                                       velox_hdfs_file_test)
+set_tests_properties(velox_hdfs_insert_test PROPERTIES DEPENDS velox_hdfs_file_test)
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
index be330b99901f..2fce65c91c55 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsFileSystemTest.cpp
@@ -21,6 +21,7 @@
 #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/connectors/hive/storage_adapters/hdfs/HdfsReadFile.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h"
@@ -36,6 +37,9 @@ using filesystems::arrow::io::internal::LibHdfsShim;
 
 constexpr int kOneMB = 1 << 20;
 static const std::string kDestinationPath = "/test_file.txt";
+static const std::string kRenamePath = "/rename_file.txt";
+static const std::string kRenameNewPath = "/rename_new_file.txt";
+static const std::string kDeletedPath = "/delete_file.txt";
 static const std::string kSimpleDestinationPath = "hdfs://" + kDestinationPath;
 static const std::string kViewfsDestinationPath =
     "viewfs://" + kDestinationPath;
@@ -50,6 +54,8 @@ class HdfsFileSystemTest : public testing::Test {
       miniCluster->start();
       auto tempFile = createFile();
       miniCluster->addFile(tempFile->getPath(), kDestinationPath);
+      miniCluster->addFile(tempFile->getPath(), kRenamePath);
+      miniCluster->addFile(tempFile->getPath(), kDeletedPath);
     }
     configurationValues.insert(
         {"hive.hdfs.host", std::string(miniCluster->host())});
@@ -67,6 +73,11 @@ class HdfsFileSystemTest : public testing::Test {
   }
 
   static void TearDownTestSuite() {
+    for (const auto& [_, filesystem] :
+         facebook::velox::filesystems::registeredFilesystems) {
+      filesystem->close();
+    }
+
     miniCluster->stop();
   }
 
@@ -212,6 +223,29 @@ TEST_F(HdfsFileSystemTest, read) {
   readData(&readFile);
 }
 
+TEST_F(HdfsFileSystemTest, rename) {
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
+  auto hdfsFileSystem =
+      filesystems::getFileSystem(fullDestinationPath_, config);
+
+  ASSERT_TRUE(hdfsFileSystem->exists(kRenamePath));
+  hdfsFileSystem->rename(kRenamePath, kRenameNewPath);
+  ASSERT_FALSE(hdfsFileSystem->exists(kRenamePath));
+  ASSERT_TRUE(hdfsFileSystem->exists(kRenameNewPath));
+}
+
+TEST_F(HdfsFileSystemTest, delete) {
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
+  auto hdfsFileSystem =
+      filesystems::getFileSystem(fullDestinationPath_, config);
+
+  ASSERT_TRUE(hdfsFileSystem->exists(kDeletedPath));
+  hdfsFileSystem->remove(kDeletedPath);
+  ASSERT_FALSE(hdfsFileSystem->exists(kDeletedPath));
+}
+
 TEST_F(HdfsFileSystemTest, viaFileSystem) {
   auto config = std::make_shared<const config::ConfigBase>(
       std::unordered_map<std::string, std::string>(configurationValues));
@@ -221,6 +255,31 @@ TEST_F(HdfsFileSystemTest, viaFileSystem) {
   readData(readFile.get());
 }
 
+TEST_F(HdfsFileSystemTest, exists) {
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
+  auto hdfsFileSystem =
+      filesystems::getFileSystem(fullDestinationPath_, config);
+  ASSERT_TRUE(hdfsFileSystem->exists(fullDestinationPath_));
+
+  const std::string_view notExistFilePath =
+      "hdfs://localhost:7777//path/that/does/not/exist";
+  ASSERT_FALSE(hdfsFileSystem->exists(notExistFilePath));
+}
+
+TEST_F(HdfsFileSystemTest, mkdirAndRmdir) {
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
+  auto hdfsFileSystem =
+      filesystems::getFileSystem(fullDestinationPath_, config);
+  const std::string newDir = "/new_directory";
+  ASSERT_FALSE(hdfsFileSystem->exists(newDir));
+  hdfsFileSystem->mkdir(newDir);
+  ASSERT_TRUE(hdfsFileSystem->exists(newDir));
+  hdfsFileSystem->rmdir(newDir);
+  ASSERT_FALSE(hdfsFileSystem->exists(newDir));
+}
+
 TEST_F(HdfsFileSystemTest, initializeFsWithEndpointInfoInFilePath) {
   // Without host/port configured.
   auto config = std::make_shared<config::ConfigBase>(
@@ -328,16 +387,6 @@ TEST_F(HdfsFileSystemTest, writeSupported) {
   hdfsFileSystem->openFileForWrite("/path");
 }
 
-TEST_F(HdfsFileSystemTest, removeNotSupported) {
-  auto config = std::make_shared<const config::ConfigBase>(
-      std::unordered_map<std::string, std::string>(configurationValues));
-  auto hdfsFileSystem =
-      filesystems::getFileSystem(fullDestinationPath_, config);
-  VELOX_ASSERT_THROW(
-      hdfsFileSystem->remove("/path"),
-      "Does not support removing files from hdfs");
-}
-
 TEST_F(HdfsFileSystemTest, multipleThreadsWithReadFile) {
   startThreads = false;
 
@@ -457,6 +506,18 @@ TEST_F(HdfsFileSystemTest, writeWithParentDirNotExist) {
   ASSERT_EQ(writeFile->size(), data.size() * 3);
 }
 
+TEST_F(HdfsFileSystemTest, list) {
+  auto config = std::make_shared<const config::ConfigBase>(
+      std::unordered_map<std::string, std::string>(configurationValues));
+  auto hdfsFileSystem =
+      filesystems::getFileSystem(fullDestinationPath_, config);
+
+  auto result = hdfsFileSystem->list(fullDestinationPath_);
+
+  ASSERT_EQ(result.size(), 1);
+  ASSERT_TRUE(result[0].find(kDestinationPath) != std::string::npos);
+}
+
 TEST_F(HdfsFileSystemTest, readFailures) {
   filesystems::arrow::io::internal::LibHdfsShim* driver;
   auto hdfs = connectHdfsDriver(
@@ -465,3 +526,34 @@ TEST_F(HdfsFileSystemTest, readFailures) {
       std::string(miniCluster->nameNodePort()));
   verifyFailures(driver, hdfs);
 }
+
+DEBUG_ONLY_TEST_F(HdfsFileSystemTest, writeFilePreventsDoubleClose) {
+  common::testutil::TestValue::enable();
+
+  int closeCallCount = 0;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::connectors::hive::HdfsWriteFile::close",
+      std::function<void(int*)>([&closeCallCount](int* success) {
+        ++closeCallCount;
+        if (closeCallCount == 1) {
+          *success = -1;
+        }
+      }));
+
+  auto writeFile = openFileForWrite("/test_double_close.txt");
+
+  writeFile->append("test data");
+  writeFile->flush();
+
+  VELOX_ASSERT_THROW(writeFile->close(), "Failed to close hdfs file:");
+
+  EXPECT_EQ(closeCallCount, 1);
+
+  // Destructor should not call close() again because hdfsFile_ is nullptr
+  // The closeCallCount should remain 1.
+  writeFile.reset();
+  EXPECT_EQ(closeCallCount, 1);
+
+  common::testutil::TestValue::disable();
+}
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsInsertTest.cpp b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsInsertTest.cpp
index 9ec9a1254154..ed2287a7c42d 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsInsertTest.cpp
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsInsertTest.cpp
@@ -17,6 +17,7 @@
 #include "gtest/gtest.h"
 
 #include "velox/common/memory/Memory.h"
+#include "velox/connectors/hive/storage_adapters/hdfs/HdfsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/RegisterHdfsFileSystem.h"
 #include "velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h"
 #include "velox/connectors/hive/storage_adapters/test_common/InsertTest.h"
@@ -47,6 +48,10 @@ class HdfsInsertTest : public testing::Test, public InsertTest {
   }
 
   void TearDown() override {
+    for (const auto& [_, filesystem] :
+         facebook::velox::filesystems::registeredFilesystems) {
+      filesystem->close();
+    }
     InsertTest::TearDown();
     miniCluster->stop();
   }
diff --git a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
index c54ae9589b3e..da07cb341a85 100644
--- a/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
+++ b/velox/connectors/hive/storage_adapters/hdfs/tests/HdfsMiniCluster.h
@@ -26,7 +26,7 @@ static const std::string kMiniClusterExecutableName{"hadoop"};
 static const std::string kHadoopSearchPath{":/usr/local/hadoop/bin"};
 static const std::string kJarCommand{"jar"};
 static const std::string kMiniclusterJar{
-    "/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.3.0-tests.jar"};
+    "/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.3.6-tests.jar"};
 static const std::string kMiniclusterCommand{"minicluster"};
 static const std::string kNoMapReduceOption{"-nomr"};
 static const std::string kFormatNameNodeOption{"-format"};
diff --git a/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt b/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
index 2b8837970bcb..741f01a61b36 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/s3fs/CMakeLists.txt
@@ -18,14 +18,11 @@ velox_add_library(velox_s3fs RegisterS3FileSystem.cpp)
 if(VELOX_ENABLE_S3)
   velox_sources(
     velox_s3fs
-    PRIVATE
-    S3FileSystem.cpp
-    S3Util.cpp
-    S3Config.cpp)
+    PRIVATE S3FileSystem.cpp S3Util.cpp S3Config.cpp S3WriteFile.cpp S3ReadFile.cpp
+  )
 
   velox_include_directories(velox_s3fs PRIVATE ${AWSSDK_INCLUDE_DIRS})
-  velox_link_libraries(velox_s3fs PRIVATE velox_dwio_common Folly::folly
-                                          ${AWSSDK_LIBRARIES})
+  velox_link_libraries(velox_s3fs PRIVATE velox_dwio_common Folly::folly ${AWSSDK_LIBRARIES})
 
   if(${VELOX_BUILD_TESTING})
     add_subdirectory(tests)
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
index 639e82b5e1cf..d0e24d984ceb 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.cpp
@@ -20,6 +20,7 @@
 #include "velox/common/file/File.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Config.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Counters.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.h"
 #include "velox/dwio/common/DataBuffer.h"
@@ -33,45 +34,16 @@
 #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>
 #include <aws/identity-management/auth/STSAssumeRoleCredentialsProvider.h>
 #include <aws/s3/S3Client.h>
-#include <aws/s3/model/CompleteMultipartUploadRequest.h>
-#include <aws/s3/model/CompletedMultipartUpload.h>
-#include <aws/s3/model/CompletedPart.h>
-#include <aws/s3/model/CreateBucketRequest.h>
-#include <aws/s3/model/CreateMultipartUploadRequest.h>
-#include <aws/s3/model/GetObjectRequest.h>
-#include <aws/s3/model/HeadBucketRequest.h>
+#include <aws/s3/model/CopyObjectRequest.h>
+#include <aws/s3/model/DeleteObjectRequest.h>
 #include <aws/s3/model/HeadObjectRequest.h>
-#include <aws/s3/model/UploadPartRequest.h>
+#include <aws/s3/model/ListObjectsRequest.h>
+#include <aws/s3/model/PutObjectRequest.h>
 
 namespace facebook::velox::filesystems {
 namespace {
-// Reference: https://issues.apache.org/jira/browse/ARROW-8692
-// https://github.com/apache/arrow/blob/master/cpp/src/arrow/filesystem/s3fs.cc#L843
-// A non-copying iostream. See
-// https://stackoverflow.com/questions/35322033/aws-c-sdk-uploadpart-times-out
-// https://stackoverflow.com/questions/13059091/creating-an-input-stream-from-constant-memory
-class StringViewStream : Aws::Utils::Stream::PreallocatedStreamBuf,
-                         public std::iostream {
- public:
-  StringViewStream(const void* data, int64_t nbytes)
-      : Aws::Utils::Stream::PreallocatedStreamBuf(
-            reinterpret_cast<unsigned char*>(const_cast<void*>(data)),
-            static_cast<size_t>(nbytes)),
-        std::iostream(this) {}
-};
-
-// By default, the AWS SDK reads object data into an auto-growing StringStream.
-// To avoid copies, read directly into a pre-allocated buffer instead.
-// See https://github.com/aws/aws-sdk-cpp/issues/64 for an alternative but
-// functionally similar recipe.
-Aws::IOStreamFactory AwsWriteableStreamFactory(void* data, int64_t nbytes) {
-  return [=]() { return Aws::New<StringViewStream>("", data, nbytes); };
-}
 
 folly::Synchronized<
     std::unordered_map<std::string, AWSCredentialsProviderFactory>>&
@@ -96,141 +68,6 @@ std::shared_ptr<Aws::Auth::AWSCredentialsProvider> getCredentialsProviderByName(
   });
 }
 
-class S3ReadFile final : public ReadFile {
- public:
-  S3ReadFile(std::string_view path, Aws::S3::S3Client* client)
-      : client_(client) {
-    getBucketAndKeyFromPath(path, bucket_, key_);
-  }
-
-  // Gets the length of the file.
-  // Checks if there are any issues reading the file.
-  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;
-    }
-
-    Aws::S3::Model::HeadObjectRequest request;
-    request.SetBucket(awsString(bucket_));
-    request.SetKey(awsString(key_));
-
-    RECORD_METRIC_VALUE(kMetricS3MetadataCalls);
-    auto outcome = client_->HeadObject(request);
-    if (!outcome.IsSuccess()) {
-      RECORD_METRIC_VALUE(kMetricS3GetMetadataErrors);
-    }
-    RECORD_METRIC_VALUE(kMetricS3GetMetadataRetries, outcome.GetRetryCount());
-    VELOX_CHECK_AWS_OUTCOME(
-        outcome, "Failed to get metadata for S3 object", bucket_, key_);
-    length_ = outcome.GetResult().GetContentLength();
-    VELOX_CHECK_GE(length_, 0);
-  }
-
-  std::string_view pread(
-      uint64_t offset,
-      uint64_t length,
-      void* buffer,
-      File::IoStats* stats) const override {
-    preadInternal(offset, length, static_cast<char*>(buffer));
-    return {static_cast<char*>(buffer), length};
-  }
-
-  std::string pread(uint64_t offset, uint64_t length, File::IoStats* stats)
-      const override {
-    std::string result(length, 0);
-    char* position = result.data();
-    preadInternal(offset, length, position);
-    return result;
-  }
-
-  uint64_t preadv(
-      uint64_t offset,
-      const std::vector<folly::Range<char*>>& buffers,
-      File::IoStats* stats) const override {
-    // 'buffers' contains Ranges(data, size)  with some gaps (data = nullptr) in
-    // between. This call must populate the ranges (except gap ranges)
-    // sequentially starting from 'offset'. AWS S3 GetObject does not support
-    // multi-range. AWS S3 also charges by number of read requests and not size.
-    // The idea here is to use a single read spanning all the ranges and then
-    // populate individual ranges. We pre-allocate a buffer to support this.
-    size_t length = 0;
-    for (const auto range : buffers) {
-      length += range.size();
-    }
-    // TODO: allocate from a memory pool
-    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 size() const override {
-    return length_;
-  }
-
-  uint64_t memoryUsage() const override {
-    // TODO: Check if any buffers are being used by the S3 library
-    return sizeof(Aws::S3::S3Client) + kS3MaxKeySize + 2 * sizeof(std::string) +
-        sizeof(int64_t);
-  }
-
-  bool shouldCoalesce() const final {
-    return false;
-  }
-
-  std::string getName() const final {
-    return fmt::format("s3://{}/{}", bucket_, key_);
-  }
-
-  uint64_t getNaturalReadSize() const final {
-    return 72 << 20;
-  }
-
- private:
-  // The assumption here is that "position" has space for at least "length"
-  // bytes.
-  void preadInternal(uint64_t offset, uint64_t length, char* position) const {
-    // Read the desired range of bytes.
-    Aws::S3::Model::GetObjectRequest request;
-    Aws::S3::Model::GetObjectResult result;
-
-    request.SetBucket(awsString(bucket_));
-    request.SetKey(awsString(key_));
-    std::stringstream ss;
-    ss << "bytes=" << offset << "-" << offset + length - 1;
-    request.SetRange(awsString(ss.str()));
-    request.SetResponseStreamFactory(
-        AwsWriteableStreamFactory(position, length));
-    RECORD_METRIC_VALUE(kMetricS3ActiveConnections);
-    RECORD_METRIC_VALUE(kMetricS3GetObjectCalls);
-    auto outcome = client_->GetObject(request);
-    if (!outcome.IsSuccess()) {
-      RECORD_METRIC_VALUE(kMetricS3GetObjectErrors);
-    }
-    RECORD_METRIC_VALUE(kMetricS3GetObjectRetries, outcome.GetRetryCount());
-    RECORD_METRIC_VALUE(kMetricS3ActiveConnections, -1);
-    VELOX_CHECK_AWS_OUTCOME(outcome, "Failed to get S3 object", bucket_, key_);
-  }
-
-  Aws::S3::S3Client* client_;
-  std::string bucket_;
-  std::string key_;
-  int64_t length_ = -1;
-};
-
 Aws::Utils::Logging::LogLevel inferS3LogLevel(std::string_view logLevel) {
   std::string level = std::string(logLevel);
   // Convert to upper case.
@@ -272,239 +109,6 @@ Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy inferPayloadSign(
 }
 } // namespace
 
-class S3WriteFile::Impl {
- public:
-  explicit Impl(
-      std::string_view path,
-      Aws::S3::S3Client* client,
-      memory::MemoryPool* pool)
-      : client_(client), pool_(pool) {
-    VELOX_CHECK_NOT_NULL(client);
-    VELOX_CHECK_NOT_NULL(pool);
-    getBucketAndKeyFromPath(path, bucket_, key_);
-    currentPart_ = std::make_unique<dwio::common::DataBuffer<char>>(*pool_);
-    currentPart_->reserve(kPartUploadSize);
-    // Check that the object doesn't exist, if it does throw an error.
-    {
-      Aws::S3::Model::HeadObjectRequest request;
-      request.SetBucket(awsString(bucket_));
-      request.SetKey(awsString(key_));
-      RECORD_METRIC_VALUE(kMetricS3MetadataCalls);
-      auto objectMetadata = client_->HeadObject(request);
-      if (!objectMetadata.IsSuccess()) {
-        RECORD_METRIC_VALUE(kMetricS3GetMetadataErrors);
-      }
-      RECORD_METRIC_VALUE(
-          kMetricS3GetObjectRetries, objectMetadata.GetRetryCount());
-      VELOX_CHECK(!objectMetadata.IsSuccess(), "S3 object already exists");
-    }
-
-    // Create bucket if not present.
-    {
-      Aws::S3::Model::HeadBucketRequest request;
-      request.SetBucket(awsString(bucket_));
-      auto bucketMetadata = client_->HeadBucket(request);
-      if (!bucketMetadata.IsSuccess()) {
-        Aws::S3::Model::CreateBucketRequest request;
-        request.SetBucket(bucket_);
-        auto outcome = client_->CreateBucket(request);
-        VELOX_CHECK_AWS_OUTCOME(
-            outcome, "Failed to create S3 bucket", bucket_, "");
-      }
-    }
-
-    // Initiate the multi-part upload.
-    {
-      Aws::S3::Model::CreateMultipartUploadRequest request;
-      request.SetBucket(awsString(bucket_));
-      request.SetKey(awsString(key_));
-
-      /// If we do not set anything then the SDK will default to application/xml
-      /// which confuses some tools
-      /// (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(
-          outcome, "Failed initiating multiple part upload", bucket_, key_);
-      uploadState_.id = outcome.GetResult().GetUploadId();
-    }
-
-    fileSize_ = 0;
-  }
-
-  // Appends data to the end of the file.
-  void append(std::string_view data) {
-    VELOX_CHECK(!closed(), "File is closed");
-    if (data.size() + currentPart_->size() >= kPartUploadSize) {
-      upload(data);
-    } else {
-      // Append to current part.
-      currentPart_->unsafeAppend(data.data(), data.size());
-    }
-    fileSize_ += data.size();
-  }
-
-  // No-op.
-  void flush() {
-    VELOX_CHECK(!closed(), "File is closed");
-    /// currentPartSize must be less than kPartUploadSize since
-    /// append() would have already flushed after reaching kUploadPartSize.
-    VELOX_CHECK_LT(currentPart_->size(), kPartUploadSize);
-  }
-
-  // Complete the multipart upload and close the file.
-  void close() {
-    if (closed()) {
-      return;
-    }
-    RECORD_METRIC_VALUE(kMetricS3StartedUploads);
-    uploadPart({currentPart_->data(), currentPart_->size()}, true);
-    VELOX_CHECK_EQ(uploadState_.partNumber, uploadState_.completedParts.size());
-    // Complete the multipart upload.
-    {
-      Aws::S3::Model::CompletedMultipartUpload completedUpload;
-      completedUpload.SetParts(uploadState_.completedParts);
-      Aws::S3::Model::CompleteMultipartUploadRequest request;
-      request.SetBucket(awsString(bucket_));
-      request.SetKey(awsString(key_));
-      request.SetUploadId(uploadState_.id);
-      request.SetMultipartUpload(std::move(completedUpload));
-
-      auto outcome = client_->CompleteMultipartUpload(request);
-      if (outcome.IsSuccess()) {
-        RECORD_METRIC_VALUE(kMetricS3SuccessfulUploads);
-      } else {
-        RECORD_METRIC_VALUE(kMetricS3FailedUploads);
-      }
-      VELOX_CHECK_AWS_OUTCOME(
-          outcome, "Failed to complete multiple part upload", bucket_, key_);
-    }
-    currentPart_->clear();
-  }
-
-  // Current file size, i.e. the sum of all previous appends.
-  uint64_t size() const {
-    return fileSize_;
-  }
-
-  int numPartsUploaded() const {
-    return uploadState_.partNumber;
-  }
-
- private:
-  static constexpr int64_t kPartUploadSize = 10 * 1024 * 1024;
-  static constexpr const char* kApplicationOctetStream =
-      "application/octet-stream";
-
-  bool closed() const {
-    return (currentPart_->capacity() == 0);
-  }
-
-  // Holds state for the multipart upload.
-  struct UploadState {
-    Aws::Vector<Aws::S3::Model::CompletedPart> completedParts;
-    int64_t partNumber = 0;
-    Aws::String id;
-  };
-  UploadState uploadState_;
-
-  // Data can be smaller or larger than the kPartUploadSize.
-  // Complete the currentPart_ and upload kPartUploadSize chunks of data.
-  // Save the remaining into currentPart_.
-  void upload(const std::string_view data) {
-    auto dataPtr = data.data();
-    auto dataSize = data.size();
-    // Fill-up the remaining currentPart_.
-    auto remainingBufferSize = currentPart_->capacity() - currentPart_->size();
-    currentPart_->unsafeAppend(dataPtr, remainingBufferSize);
-    uploadPart({currentPart_->data(), currentPart_->size()});
-    dataPtr += remainingBufferSize;
-    dataSize -= remainingBufferSize;
-    while (dataSize > kPartUploadSize) {
-      uploadPart({dataPtr, kPartUploadSize});
-      dataPtr += kPartUploadSize;
-      dataSize -= kPartUploadSize;
-    }
-    // Stash the remaining at the beginning of currentPart.
-    currentPart_->unsafeAppend(0, dataPtr, dataSize);
-  }
-
-  void uploadPart(const std::string_view part, bool isLast = false) {
-    // Only the last part can be less than kPartUploadSize.
-    VELOX_CHECK(isLast || (!isLast && (part.size() == kPartUploadSize)));
-    // Upload the part.
-    {
-      Aws::S3::Model::UploadPartRequest request;
-      request.SetBucket(bucket_);
-      request.SetKey(key_);
-      request.SetUploadId(uploadState_.id);
-      request.SetPartNumber(++uploadState_.partNumber);
-      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.
-      // This will be needed for upload completion in Close().
-      auto result = outcome.GetResult();
-      Aws::S3::Model::CompletedPart part;
-
-      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));
-    }
-  }
-
-  Aws::S3::S3Client* client_;
-  memory::MemoryPool* pool_;
-  std::unique_ptr<dwio::common::DataBuffer<char>> currentPart_;
-  std::string bucket_;
-  std::string key_;
-  size_t fileSize_ = -1;
-};
-
-S3WriteFile::S3WriteFile(
-    std::string_view path,
-    Aws::S3::S3Client* client,
-    memory::MemoryPool* pool) {
-  impl_ = std::make_shared<Impl>(path, client, pool);
-}
-
-void S3WriteFile::append(std::string_view data) {
-  return impl_->append(data);
-}
-
-void S3WriteFile::flush() {
-  impl_->flush();
-}
-
-void S3WriteFile::close() {
-  impl_->close();
-}
-
-uint64_t S3WriteFile::size() const {
-  return impl_->size();
-}
-
-int S3WriteFile::numPartsUploaded() const {
-  return impl_->numPartsUploaded();
-}
-
 // Initialize and Finalize the AWS SDK C++ library.
 // Initialization must be done before creating a S3FileSystem.
 // Finalization must be done after all S3FileSystem instances have been deleted.
@@ -628,6 +232,12 @@ class S3FileSystem::Impl {
   Impl(const S3Config& s3Config) {
     VELOX_CHECK(getAwsInstance()->isInitialized(), "S3 is not initialized");
     Aws::S3::S3ClientConfiguration clientConfig;
+    // Required for AWS CLI object operations on OCI and MinIO due to checksum
+    // handling.
+    clientConfig.checksumConfig.requestChecksumCalculation =
+        Aws::Client::RequestChecksumCalculation::WHEN_REQUIRED;
+    clientConfig.checksumConfig.responseChecksumValidation =
+        Aws::Client::ResponseChecksumValidation::WHEN_REQUIRED;
     if (s3Config.endpoint().has_value()) {
       clientConfig.endpointOverride = s3Config.endpoint().value();
     }
@@ -879,4 +489,92 @@ std::string S3FileSystem::name() const {
   return "S3";
 }
 
+std::vector<std::string> S3FileSystem::list(std::string_view path) {
+  std::string bucket;
+  std::string key;
+  getBucketAndKeyFromPath(getPath(path), bucket, key);
+
+  Aws::S3::Model::ListObjectsRequest request;
+  request.SetBucket(awsString(bucket));
+  request.SetPrefix(awsString(key));
+
+  auto outcome = impl_->s3Client()->ListObjects(request);
+  VELOX_CHECK_AWS_OUTCOME(
+      outcome, "Failed to list objects in S3 bucket", bucket, key);
+
+  std::vector<std::string> objectKeys;
+  const auto& result = outcome.GetResult();
+  for (const auto& object : result.GetContents()) {
+    objectKeys.emplace_back(object.GetKey());
+  }
+
+  return objectKeys;
+}
+
+bool S3FileSystem::exists(std::string_view path) {
+  std::string bucket;
+  std::string key;
+  getBucketAndKeyFromPath(getPath(path), bucket, key);
+
+  Aws::S3::Model::HeadObjectRequest request;
+  request.SetBucket(awsString(bucket));
+  request.SetKey(awsString(key));
+
+  return impl_->s3Client()->HeadObject(request).IsSuccess();
+}
+
+void S3FileSystem::mkdir(
+    std::string_view path,
+    const DirectoryOptions& options) {
+  std::string bucket;
+  std::string key;
+  getBucketAndKeyFromPath(getPath(path), bucket, key);
+
+  Aws::S3::Model::PutObjectRequest request;
+  request.SetBucket(awsString(bucket));
+  request.SetKey(awsString(key));
+
+  VELOX_CHECK_AWS_OUTCOME(
+      impl_->s3Client()->PutObject(request),
+      "Failed to mkdir objects in S3 bucket",
+      bucket,
+      key);
+}
+
+void S3FileSystem::rename(
+    std::string_view path,
+    std::string_view newPath,
+    bool overWrite) {
+  std::string sourceBucket;
+  std::string sourceKey;
+  getBucketAndKeyFromPath(getPath(path), sourceBucket, sourceKey);
+
+  std::string targetBucket;
+  std::string targetKey;
+  getBucketAndKeyFromPath(getPath(newPath), targetBucket, targetKey);
+
+  // Copies the object to the new location.
+  Aws::S3::Model::CopyObjectRequest copyRequest;
+  copyRequest.SetCopySource(awsString(sourceBucket + "/" + sourceKey));
+  copyRequest.SetBucket(awsString(targetBucket));
+  copyRequest.SetKey(awsString(targetKey));
+
+  VELOX_CHECK_AWS_OUTCOME(
+      impl_->s3Client()->CopyObject(copyRequest),
+      "Failed to copy object in S3 during rename",
+      sourceBucket,
+      sourceKey);
+
+  // Deletes the original object.
+  Aws::S3::Model::DeleteObjectRequest deleteRequest;
+  deleteRequest.SetBucket(awsString(sourceBucket));
+  deleteRequest.SetKey(awsString(sourceKey));
+
+  VELOX_CHECK_AWS_OUTCOME(
+      impl_->s3Client()->DeleteObject(deleteRequest),
+      "Failed to delete original object in S3 during rename",
+      sourceBucket,
+      sourceKey);
+}
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h
index 8ca6634b5b3a..f121223f0f3b 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3FileSystem.h
@@ -64,25 +64,20 @@ class S3FileSystem : public FileSystem {
     VELOX_UNSUPPORTED("remove for S3 not implemented");
   }
 
+  // Renames the path.
   void rename(
       std::string_view path,
       std::string_view newPath,
-      bool overWrite = false) override {
-    VELOX_UNSUPPORTED("rename for S3 not implemented");
-  }
+      bool overWrite = false) override;
 
-  bool exists(std::string_view path) override {
-    VELOX_UNSUPPORTED("exists for S3 not implemented");
-  }
+  /// Checks that the path exists.
+  bool exists(std::string_view path) override;
 
-  std::vector<std::string> list(std::string_view path) override {
-    VELOX_UNSUPPORTED("list for S3 not implemented");
-  }
+  /// List the objects associated to a path.
+  std::vector<std::string> list(std::string_view path) override;
 
   void mkdir(std::string_view path, const DirectoryOptions& options = {})
-      override {
-    VELOX_UNSUPPORTED("mkdir for S3 not implemented");
-  }
+      override;
 
   void rmdir(std::string_view path) override {
     VELOX_UNSUPPORTED("rmdir for S3 not implemented");
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.cpp
new file mode 100644
index 000000000000..38d66318f3e2
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.cpp
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/S3ReadFile.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/S3Counters.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
+
+#include <aws/core/Aws.h>
+#include <aws/s3/S3Client.h>
+#include <aws/s3/model/GetObjectRequest.h>
+#include <aws/s3/model/HeadObjectRequest.h>
+
+namespace facebook::velox::filesystems {
+
+namespace {
+
+// By default, the AWS SDK reads object data into an auto-growing StringStream.
+// To avoid copies, read directly into a pre-allocated buffer instead.
+// See https://github.com/aws/aws-sdk-cpp/issues/64 for an alternative but
+// functionally similar recipe.
+Aws::IOStreamFactory AwsWriteableStreamFactory(void* data, int64_t nbytes) {
+  return [=]() { return Aws::New<StringViewStream>("", data, nbytes); };
+}
+
+} // namespace
+
+class S3ReadFile ::Impl {
+ public:
+  explicit Impl(std::string_view path, Aws::S3::S3Client* client)
+      : client_(client) {
+    getBucketAndKeyFromPath(path, bucket_, key_);
+  }
+
+  // Gets the length of the file.
+  // Checks if there are any issues reading the file.
+  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;
+    }
+
+    Aws::S3::Model::HeadObjectRequest request;
+    request.SetBucket(awsString(bucket_));
+    request.SetKey(awsString(key_));
+
+    RECORD_METRIC_VALUE(kMetricS3MetadataCalls);
+    auto outcome = client_->HeadObject(request);
+    if (!outcome.IsSuccess()) {
+      RECORD_METRIC_VALUE(kMetricS3GetMetadataErrors);
+    }
+    RECORD_METRIC_VALUE(kMetricS3GetMetadataRetries, outcome.GetRetryCount());
+    VELOX_CHECK_AWS_OUTCOME(
+        outcome, "Failed to get metadata for S3 object", bucket_, key_);
+    length_ = outcome.GetResult().GetContentLength();
+    VELOX_CHECK_GE(length_, 0);
+  }
+
+  std::string_view pread(
+      uint64_t offset,
+      uint64_t length,
+      void* buffer,
+      const FileStorageContext& fileStorageContext) const {
+    preadInternal(offset, length, static_cast<char*>(buffer));
+    return {static_cast<char*>(buffer), length};
+  }
+
+  std::string pread(
+      uint64_t offset,
+      uint64_t length,
+      const FileStorageContext& fileStorageContext) const {
+    std::string result(length, 0);
+    char* position = result.data();
+    preadInternal(offset, length, position);
+    return result;
+  }
+
+  uint64_t preadv(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers,
+      const FileStorageContext& fileStorageContext) const {
+    // 'buffers' contains Ranges(data, size)  with some gaps (data = nullptr) in
+    // between. This call must populate the ranges (except gap ranges)
+    // sequentially starting from 'offset'. AWS S3 GetObject does not support
+    // multi-range. AWS S3 also charges by number of read requests and not size.
+    // The idea here is to use a single read spanning all the ranges and then
+    // populate individual ranges. We pre-allocate a buffer to support this.
+    size_t length = 0;
+    for (const auto range : buffers) {
+      length += range.size();
+    }
+    // TODO: allocate from a memory pool
+    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 size() const {
+    return length_;
+  }
+
+  uint64_t memoryUsage() const {
+    // TODO: Check if any buffers are being used by the S3 library
+    return sizeof(Aws::S3::S3Client) + kS3MaxKeySize + 2 * sizeof(std::string) +
+        sizeof(int64_t);
+  }
+
+  bool shouldCoalesce() const {
+    return false;
+  }
+
+  std::string getName() const {
+    return fmt::format("s3://{}/{}", bucket_, key_);
+  }
+
+ private:
+  // The assumption here is that "position" has space for at least "length"
+  // bytes.
+  void preadInternal(uint64_t offset, uint64_t length, char* position) const {
+    // Read the desired range of bytes.
+    Aws::S3::Model::GetObjectRequest request;
+    Aws::S3::Model::GetObjectResult result;
+
+    request.SetBucket(awsString(bucket_));
+    request.SetKey(awsString(key_));
+    std::stringstream ss;
+    ss << "bytes=" << offset << "-" << offset + length - 1;
+    request.SetRange(awsString(ss.str()));
+    request.SetResponseStreamFactory(
+        AwsWriteableStreamFactory(position, length));
+    RECORD_METRIC_VALUE(kMetricS3ActiveConnections);
+    RECORD_METRIC_VALUE(kMetricS3GetObjectCalls);
+    auto outcome = client_->GetObject(request);
+    if (!outcome.IsSuccess()) {
+      RECORD_METRIC_VALUE(kMetricS3GetObjectErrors);
+    }
+    RECORD_METRIC_VALUE(kMetricS3GetObjectRetries, outcome.GetRetryCount());
+    RECORD_METRIC_VALUE(kMetricS3ActiveConnections, -1);
+    VELOX_CHECK_AWS_OUTCOME(outcome, "Failed to get S3 object", bucket_, key_);
+  }
+
+  Aws::S3::S3Client* client_;
+  std::string bucket_;
+  std::string key_;
+  int64_t length_ = -1;
+};
+
+S3ReadFile::S3ReadFile(std::string_view path, Aws::S3::S3Client* client) {
+  impl_ = std::make_shared<Impl>(path, client);
+}
+
+S3ReadFile::~S3ReadFile() = default;
+
+void S3ReadFile::initialize(const filesystems::FileOptions& options) {
+  return impl_->initialize(options);
+}
+
+std::string_view S3ReadFile::pread(
+    uint64_t offset,
+    uint64_t length,
+    void* buf,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->pread(offset, length, buf, fileStorageContext);
+}
+
+std::string S3ReadFile::pread(
+    uint64_t offset,
+    uint64_t length,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->pread(offset, length, fileStorageContext);
+}
+
+uint64_t S3ReadFile::preadv(
+    uint64_t offset,
+    const std::vector<folly::Range<char*>>& buffers,
+    const FileStorageContext& fileStorageContext) const {
+  return impl_->preadv(offset, buffers, fileStorageContext);
+}
+
+uint64_t S3ReadFile::size() const {
+  return impl_->size();
+}
+
+uint64_t S3ReadFile::memoryUsage() const {
+  return impl_->memoryUsage();
+}
+
+bool S3ReadFile::shouldCoalesce() const {
+  return impl_->shouldCoalesce();
+}
+
+std::string S3ReadFile::getName() const {
+  return impl_->getName();
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.h b/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.h
new file mode 100644
index 000000000000..de7eb63f5ada
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3ReadFile.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 "velox/common/file/File.h"
+
+namespace Aws::S3 {
+class S3Client;
+}
+
+namespace facebook::velox::filesystems {
+
+/// Implementation of s3 read file.
+class S3ReadFile : public ReadFile {
+ public:
+  S3ReadFile(std::string_view path, Aws::S3::S3Client* client);
+
+  ~S3ReadFile() override;
+
+  std::string_view pread(
+      uint64_t offset,
+      uint64_t length,
+      void* buf,
+      const FileStorageContext& fileStorageContext = {}) const final;
+
+  std::string pread(
+      uint64_t offset,
+      uint64_t length,
+      const FileStorageContext& fileStorageContext = {}) const final;
+
+  uint64_t preadv(
+      uint64_t offset,
+      const std::vector<folly::Range<char*>>& buffers,
+      const FileStorageContext& fileStorageContext = {}) 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 {
+    return 72 << 20;
+  }
+
+  void initialize(const filesystems::FileOptions& options);
+
+ private:
+  void preadInternal(uint64_t offset, uint64_t length, char* position) const;
+
+  class Impl;
+  std::shared_ptr<Impl> impl_;
+};
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3Util.h b/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
index 966c6bfe30a7..125d9cc805b5 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3Util.h
@@ -28,6 +28,8 @@
 
 #include "velox/common/base/Exceptions.h"
 
+#include <aws/core/utils/stream/PreallocatedStreamBuf.h>
+
 namespace facebook::velox::filesystems {
 
 namespace {
@@ -202,7 +204,7 @@ std::optional<std::string> parseAWSStandardRegionName(
 class S3ProxyConfigurationBuilder {
  public:
   S3ProxyConfigurationBuilder(const std::string& s3Endpoint)
-      : s3Endpoint_(s3Endpoint){};
+      : s3Endpoint_(s3Endpoint) {}
 
   S3ProxyConfigurationBuilder& useSsl(const bool& useSsl) {
     useSsl_ = useSsl;
@@ -216,11 +218,26 @@ class S3ProxyConfigurationBuilder {
   bool useSsl_;
 };
 
+// Reference: https://issues.apache.org/jira/browse/ARROW-8692
+// https://github.com/apache/arrow/blob/master/cpp/src/arrow/filesystem/s3fs.cc#L843
+// A non-copying iostream. See
+// https://stackoverflow.com/questions/35322033/aws-c-sdk-uploadpart-times-out
+// https://stackoverflow.com/questions/13059091/creating-an-input-stream-from-constant-memory
+class StringViewStream : Aws::Utils::Stream::PreallocatedStreamBuf,
+                         public std::iostream {
+ public:
+  StringViewStream(const void* data, int64_t nbytes)
+      : Aws::Utils::Stream::PreallocatedStreamBuf(
+            reinterpret_cast<unsigned char*>(const_cast<void*>(data)),
+            static_cast<size_t>(nbytes)),
+        std::iostream(this) {}
+};
+
 } // namespace facebook::velox::filesystems
 
 template <>
 struct fmt::formatter<Aws::Http::HttpResponseCode> : formatter<int> {
-  auto format(Aws::Http::HttpResponseCode s, format_context& ctx) {
+  auto format(Aws::Http::HttpResponseCode s, format_context& ctx) const {
     return formatter<int>::format(static_cast<int>(s), ctx);
   }
 };
diff --git a/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.cpp b/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.cpp
new file mode 100644
index 000000000000..2284ad6b8ef7
--- /dev/null
+++ b/velox/connectors/hive/storage_adapters/s3fs/S3WriteFile.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/connectors/hive/storage_adapters/s3fs/S3WriteFile.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/S3Counters.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
+#include "velox/dwio/common/DataBuffer.h"
+
+#include <aws/core/Aws.h>
+#include <aws/s3/S3Client.h>
+#include <aws/s3/model/CompleteMultipartUploadRequest.h>
+#include <aws/s3/model/CompletedMultipartUpload.h>
+#include <aws/s3/model/CompletedPart.h>
+#include <aws/s3/model/CreateBucketRequest.h>
+#include <aws/s3/model/CreateMultipartUploadRequest.h>
+#include <aws/s3/model/HeadBucketRequest.h>
+#include <aws/s3/model/HeadObjectRequest.h>
+#include <aws/s3/model/UploadPartRequest.h>
+
+namespace facebook::velox::filesystems {
+
+class S3WriteFile::Impl {
+ public:
+  explicit Impl(
+      std::string_view path,
+      Aws::S3::S3Client* client,
+      memory::MemoryPool* pool)
+      : client_(client), pool_(pool) {
+    VELOX_CHECK_NOT_NULL(client);
+    VELOX_CHECK_NOT_NULL(pool);
+    getBucketAndKeyFromPath(path, bucket_, key_);
+    currentPart_ = std::make_unique<dwio::common::DataBuffer<char>>(*pool_);
+    currentPart_->reserve(kPartUploadSize);
+    // Check that the object doesn't exist, if it does throw an error.
+    {
+      Aws::S3::Model::HeadObjectRequest request;
+      request.SetBucket(awsString(bucket_));
+      request.SetKey(awsString(key_));
+      RECORD_METRIC_VALUE(kMetricS3MetadataCalls);
+      auto objectMetadata = client_->HeadObject(request);
+      if (!objectMetadata.IsSuccess()) {
+        RECORD_METRIC_VALUE(kMetricS3GetMetadataErrors);
+      }
+      RECORD_METRIC_VALUE(
+          kMetricS3GetObjectRetries, objectMetadata.GetRetryCount());
+      VELOX_CHECK(
+          !objectMetadata.IsSuccess(),
+          "S3 object already exists: bucket={}, key={}",
+          bucket_,
+          key_);
+    }
+
+    // Create bucket if not present.
+    {
+      Aws::S3::Model::HeadBucketRequest request;
+      request.SetBucket(awsString(bucket_));
+      auto bucketMetadata = client_->HeadBucket(request);
+      if (!bucketMetadata.IsSuccess()) {
+        Aws::S3::Model::CreateBucketRequest request;
+        request.SetBucket(bucket_);
+        auto outcome = client_->CreateBucket(request);
+        VELOX_CHECK_AWS_OUTCOME(
+            outcome, "Failed to create S3 bucket", bucket_, "");
+      }
+    }
+
+    // Initiate the multi-part upload.
+    {
+      Aws::S3::Model::CreateMultipartUploadRequest request;
+      request.SetBucket(awsString(bucket_));
+      request.SetKey(awsString(key_));
+
+      /// If we do not set anything then the SDK will default to application/xml
+      /// which confuses some tools
+      /// (https://github.com/apache/arrow/issues/11934). So we instead default
+      /// to application/octet-stream which is less misleading.
+      request.SetContentType(kApplicationOctetStream);
+      auto outcome = client_->CreateMultipartUpload(request);
+      VELOX_CHECK_AWS_OUTCOME(
+          outcome, "Failed initiating multiple part upload", bucket_, key_);
+      uploadState_.id = outcome.GetResult().GetUploadId();
+    }
+
+    fileSize_ = 0;
+  }
+
+  // Appends data to the end of the file.
+  void append(std::string_view data) {
+    VELOX_CHECK(!closed(), "File is closed");
+    if (data.size() + currentPart_->size() >= kPartUploadSize) {
+      upload(data);
+    } else {
+      // Append to current part.
+      currentPart_->unsafeAppend(data.data(), data.size());
+    }
+    fileSize_ += data.size();
+  }
+
+  // No-op.
+  void flush() {
+    VELOX_CHECK(!closed(), "File is closed");
+    /// currentPartSize must be less than kPartUploadSize since
+    /// append() would have already flushed after reaching kUploadPartSize.
+    VELOX_CHECK_LT(currentPart_->size(), kPartUploadSize);
+  }
+
+  // Complete the multipart upload and close the file.
+  void close() {
+    if (closed()) {
+      return;
+    }
+    RECORD_METRIC_VALUE(kMetricS3StartedUploads);
+    uploadPart({currentPart_->data(), currentPart_->size()}, true);
+    VELOX_CHECK_EQ(uploadState_.partNumber, uploadState_.completedParts.size());
+    // Complete the multipart upload.
+    {
+      Aws::S3::Model::CompletedMultipartUpload completedUpload;
+      completedUpload.SetParts(uploadState_.completedParts);
+      Aws::S3::Model::CompleteMultipartUploadRequest request;
+      request.SetBucket(awsString(bucket_));
+      request.SetKey(awsString(key_));
+      request.SetUploadId(uploadState_.id);
+      request.SetMultipartUpload(std::move(completedUpload));
+
+      auto outcome = client_->CompleteMultipartUpload(request);
+      if (outcome.IsSuccess()) {
+        RECORD_METRIC_VALUE(kMetricS3SuccessfulUploads);
+      } else {
+        RECORD_METRIC_VALUE(kMetricS3FailedUploads);
+      }
+      VELOX_CHECK_AWS_OUTCOME(
+          outcome, "Failed to complete multiple part upload", bucket_, key_);
+    }
+    currentPart_->clear();
+  }
+
+  // Current file size, i.e. the sum of all previous appends.
+  uint64_t size() const {
+    return fileSize_;
+  }
+
+  int numPartsUploaded() const {
+    return uploadState_.partNumber;
+  }
+
+ private:
+  static constexpr int64_t kPartUploadSize = 10 * 1024 * 1024;
+  static constexpr const char* kApplicationOctetStream =
+      "application/octet-stream";
+
+  bool closed() const {
+    return (currentPart_->capacity() == 0);
+  }
+
+  // Holds state for the multipart upload.
+  struct UploadState {
+    Aws::Vector<Aws::S3::Model::CompletedPart> completedParts;
+    int64_t partNumber = 0;
+    Aws::String id;
+  };
+  UploadState uploadState_;
+
+  // Data can be smaller or larger than the kPartUploadSize.
+  // Complete the currentPart_ and upload kPartUploadSize chunks of data.
+  // Save the remaining into currentPart_.
+  void upload(const std::string_view data) {
+    auto dataPtr = data.data();
+    auto dataSize = data.size();
+    // Fill-up the remaining currentPart_.
+    auto remainingBufferSize = currentPart_->capacity() - currentPart_->size();
+    currentPart_->unsafeAppend(dataPtr, remainingBufferSize);
+    uploadPart({currentPart_->data(), currentPart_->size()});
+    dataPtr += remainingBufferSize;
+    dataSize -= remainingBufferSize;
+    while (dataSize > kPartUploadSize) {
+      uploadPart({dataPtr, kPartUploadSize});
+      dataPtr += kPartUploadSize;
+      dataSize -= kPartUploadSize;
+    }
+    // Stash the remaining at the beginning of currentPart.
+    currentPart_->unsafeAppend(0, dataPtr, dataSize);
+  }
+
+  void uploadPart(const std::string_view part, bool isLast = false) {
+    // Only the last part can be less than kPartUploadSize.
+    VELOX_CHECK(isLast || (!isLast && (part.size() == kPartUploadSize)));
+    // Upload the part.
+    {
+      Aws::S3::Model::UploadPartRequest request;
+      request.SetBucket(bucket_);
+      request.SetKey(key_);
+      request.SetUploadId(uploadState_.id);
+      request.SetPartNumber(++uploadState_.partNumber);
+      request.SetContentLength(part.size());
+      request.SetBody(
+          std::make_shared<StringViewStream>(part.data(), part.size()));
+      auto outcome = client_->UploadPart(request);
+      VELOX_CHECK_AWS_OUTCOME(outcome, "Failed to upload", bucket_, key_);
+      // Append ETag and part number for this uploaded part.
+      // This will be needed for upload completion in Close().
+      auto result = outcome.GetResult();
+      Aws::S3::Model::CompletedPart part;
+
+      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));
+    }
+  }
+
+  Aws::S3::S3Client* client_;
+  memory::MemoryPool* pool_;
+  std::unique_ptr<dwio::common::DataBuffer<char>> currentPart_;
+  std::string bucket_;
+  std::string key_;
+  size_t fileSize_ = -1;
+};
+
+S3WriteFile::S3WriteFile(
+    std::string_view path,
+    Aws::S3::S3Client* client,
+    memory::MemoryPool* pool) {
+  impl_ = std::make_shared<Impl>(path, client, pool);
+}
+
+void S3WriteFile::append(std::string_view data) {
+  return impl_->append(data);
+}
+
+void S3WriteFile::flush() {
+  impl_->flush();
+}
+
+void S3WriteFile::close() {
+  impl_->close();
+}
+
+uint64_t S3WriteFile::size() const {
+  return impl_->size();
+}
+
+int S3WriteFile::numPartsUploaded() const {
+  return impl_->numPartsUploaded();
+}
+
+} // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt b/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
index f2bc59aa20f9..9d92727e7673 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/CMakeLists.txt
@@ -19,7 +19,8 @@ target_link_libraries(
   velox_common_config
   velox_s3fs
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_s3file_test S3FileSystemTest.cpp S3UtilTest.cpp)
 add_test(velox_s3file_test velox_s3file_test)
@@ -32,7 +33,8 @@ target_link_libraries(
   velox_dwio_common_exception
   velox_exec
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_s3registration_test S3FileSystemRegistrationTest.cpp)
 add_test(velox_s3registration_test velox_s3registration_test)
@@ -46,7 +48,8 @@ target_link_libraries(
   velox_dwio_common_exception
   velox_exec
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_s3finalize_test S3FileSystemFinalizeTest.cpp)
 add_test(velox_s3finalize_test velox_s3finalize_test)
@@ -56,7 +59,8 @@ target_link_libraries(
   velox_file
   velox_core
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_s3insert_test S3InsertTest.cpp)
 add_test(velox_s3insert_test velox_s3insert_test)
@@ -71,13 +75,15 @@ target_link_libraries(
   velox_dwio_common_exception
   velox_exec
   GTest::gtest
-  GTest::gtest_main)
+  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})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 target_link_libraries(
   velox_s3read_test
   velox_file
@@ -88,7 +94,8 @@ target_link_libraries(
   velox_dwio_common_exception
   velox_exec
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_s3metrics_test S3FileSystemMetricsTest.cpp)
 add_test(velox_s3metrics_test velox_s3metrics_test)
@@ -97,7 +104,8 @@ target_link_libraries(
   velox_s3fs
   velox_exec_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_s3multiendpoints_test S3MultipleEndpointsTest.cpp)
 add_test(velox_s3multiendpoints_test velox_s3multiendpoints_test)
@@ -112,4 +120,5 @@ target_link_libraries(
   velox_dwio_common_exception
   velox_exec
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemMetricsTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemMetricsTest.cpp
index ca941a5feb3b..907acf927838 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemMetricsTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemMetricsTest.cpp
@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include <folly/init/Init.h>
+#include <functional>
 
 #include "velox/common/memory/Memory.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
@@ -23,8 +25,9 @@
 
 #include <gtest/gtest.h>
 
-namespace facebook::velox::filesystems {
+namespace facebook::velox::filesystems::test {
 namespace {
+
 class S3TestReporter : public BaseStatsReporter {
  public:
   mutable std::mutex m;
@@ -39,6 +42,7 @@ class S3TestReporter : public BaseStatsReporter {
     statTypeMap.clear();
     histogramPercentilesMap.clear();
   }
+
   void registerMetricExportType(const char* key, StatType statType)
       const override {
     statTypeMap[key] = statType;
@@ -168,7 +172,7 @@ TEST_F(S3FileSystemMetricsTest, metrics) {
   EXPECT_EQ(1, s3Reporter->counterMap[std::string{kMetricS3GetObjectCalls}]);
 }
 
-} // namespace facebook::velox::filesystems
+} // namespace facebook::velox::filesystems::test
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemRegistrationTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemRegistrationTest.cpp
index c0d106c44187..256fe6e481e5 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemRegistrationTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemRegistrationTest.cpp
@@ -69,9 +69,10 @@ TEST_F(S3FileSystemRegistrationTest, fileHandle) {
   }
   auto hiveConfig = minioServer_->hiveConfig();
   FileHandleFactory factory(
-      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(1000),
+      std::make_unique<SimpleLRUCache<FileHandleKey, FileHandle>>(1000),
       std::make_unique<FileHandleGenerator>(hiveConfig));
-  auto fileHandleCachePtr = factory.generate(s3File);
+  FileHandleKey key{s3File};
+  auto fileHandleCachePtr = factory.generate(key);
   readData(fileHandleCachePtr->file.get());
 }
 
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
index 2fdc115609e1..a94e9b4c3523 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3FileSystemTest.cpp
@@ -175,7 +175,7 @@ TEST_F(S3FileSystemTest, noBackendServer) {
   minioServer_->stop();
   VELOX_ASSERT_THROW(
       s3fs.openFileForRead(kDummyPath),
-      "Failed to get metadata for S3 object due to: 'Network connection'. Path:'s3://dummy/foo.txt', SDK Error Type:99, HTTP Status Code:-1, S3 Service:'Unknown', Message:'curlCode: 7, Couldn't connect to server'");
+      "Failed to get metadata for S3 object due to: 'Network connection'. Path:'s3://dummy/foo.txt', SDK Error Type:99, HTTP Status Code:-1, S3 Service:'Unknown', Message:'curlCode: 7, Couldn't connect to server");
   // Start Minio again.
   minioServer_->start();
 }
@@ -219,6 +219,27 @@ TEST_F(S3FileSystemTest, logLocation) {
   checkLogPrefix(expected);
 }
 
+TEST_F(S3FileSystemTest, mkdirAndRename) {
+  const auto bucketName = "mkdir";
+  const auto file = "mkdir-test.txt";
+  const auto s3File = s3URI(bucketName, file);
+  addBucket(bucketName);
+
+  auto hiveConfig = minioServer_->hiveConfig();
+  filesystems::S3FileSystem s3fs(bucketName, hiveConfig);
+
+  ASSERT_FALSE(s3fs.exists(s3File));
+  s3fs.mkdir(s3File);
+  ASSERT_TRUE(s3fs.exists(s3File));
+
+  // Rename test
+  const auto renameFile = "rename-test.txt";
+  const auto s3RenameFile = s3URI(bucketName, renameFile);
+  s3fs.rename(s3File, s3RenameFile);
+  ASSERT_TRUE(s3fs.exists(s3RenameFile));
+  ASSERT_FALSE(s3fs.exists(s3File));
+}
+
 TEST_F(S3FileSystemTest, writeFileAndRead) {
   const auto bucketName = "writedata";
   const auto file = "test.txt";
@@ -290,6 +311,14 @@ TEST_F(S3FileSystemTest, writeFileAndRead) {
   }
   // Verify the last chunk.
   ASSERT_EQ(readFile->pread(contentSize * 250'000, contentSize), dataContent);
+
+  // Verify the S3 list function.
+  auto result = s3fs.list(s3File);
+
+  ASSERT_EQ(result.size(), 1);
+  ASSERT_TRUE(result[0] == file);
+
+  ASSERT_TRUE(s3fs.exists(s3File));
 }
 
 TEST_F(S3FileSystemTest, invalidConnectionSettings) {
@@ -340,4 +369,5 @@ TEST_F(S3FileSystemTest, registerCredentialProviderFactories) {
           }),
       "CredentialsProviderFactory 'my-credentials-provider' already registered");
 }
+
 } // namespace facebook::velox::filesystems
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp
index cb6e8e783473..cf446b12d2e2 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3MultipleEndpointsTest.cpp
@@ -17,6 +17,7 @@
 #include <folly/init/Init.h>
 
 #include "gtest/gtest.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/S3Util.h"
 #include "velox/connectors/hive/storage_adapters/s3fs/tests/S3Test.h"
@@ -52,8 +53,6 @@ class S3MultipleEndpoints : public S3Test, public ::test::VectorTestBase {
     minioSecondServer_->addBucket(kBucketName.data());
 
     filesystems::registerS3FileSystem();
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
     parquet::registerParquetReaderFactory();
     parquet::registerParquetWriterFactory();
   }
@@ -63,20 +62,15 @@ class S3MultipleEndpoints : public S3Test, public ::test::VectorTestBase {
       std::string_view connectorId2,
       const std::unordered_map<std::string, std::string> config1Override = {},
       const std::unordered_map<std::string, std::string> config2Override = {}) {
-    auto hiveConnector1 =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(
-                std::string(connectorId1),
-                minioServer_->hiveConfig(config1Override),
-                ioExecutor_.get());
-    auto hiveConnector2 =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(
-                std::string(connectorId2),
-                minioSecondServer_->hiveConfig(config2Override),
-                ioExecutor_.get());
+    connector::hive::HiveConnectorFactory factory;
+    auto hiveConnector1 = factory.newConnector(
+        std::string(connectorId1),
+        minioServer_->hiveConfig(config1Override),
+        ioExecutor_.get());
+    auto hiveConnector2 = factory.newConnector(
+        std::string(connectorId2),
+        minioSecondServer_->hiveConfig(config2Override),
+        ioExecutor_.get());
     connector::registerConnector(hiveConnector1);
     connector::registerConnector(hiveConnector2);
   }
@@ -84,8 +78,6 @@ class S3MultipleEndpoints : public S3Test, public ::test::VectorTestBase {
   void TearDown() override {
     parquet::unregisterParquetReaderFactory();
     parquet::unregisterParquetWriterFactory();
-    connector::unregisterConnectorFactory(
-        connector::hive::HiveConnectorFactory::kHiveConnectorName);
     S3Test::TearDown();
   }
 
diff --git a/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp b/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp
index 7abcbfb7e56b..bbd084837514 100644
--- a/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp
+++ b/velox/connectors/hive/storage_adapters/s3fs/tests/S3ReadTest.cpp
@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/memory/Memory.h"
+#include "velox/connectors/hive/HiveConnector.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"
@@ -39,12 +40,9 @@ class S3ReadTest : public S3Test, public ::test::VectorTestBase {
   void SetUp() override {
     S3Test::SetUp();
     filesystems::registerS3FileSystem();
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
+    connector::hive::HiveConnectorFactory factory;
     auto hiveConnector =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(kHiveConnectorId, minioServer_->hiveConfig());
+        factory.newConnector(kHiveConnectorId, minioServer_->hiveConfig());
     connector::registerConnector(hiveConnector);
     parquet::registerParquetReaderFactory();
   }
@@ -52,8 +50,6 @@ class S3ReadTest : public S3Test, public ::test::VectorTestBase {
   void TearDown() override {
     parquet::unregisterParquetReaderFactory();
     filesystems::finalizeS3FileSystem();
-    connector::unregisterConnectorFactory(
-        connector::hive::HiveConnectorFactory::kHiveConnectorName);
     connector::unregisterConnector(kHiveConnectorId);
     S3Test::TearDown();
   }
diff --git a/velox/connectors/hive/storage_adapters/test_common/InsertTest.h b/velox/connectors/hive/storage_adapters/test_common/InsertTest.h
index 0bef0f09b6ae..0700ca7a334e 100644
--- a/velox/connectors/hive/storage_adapters/test_common/InsertTest.h
+++ b/velox/connectors/hive/storage_adapters/test_common/InsertTest.h
@@ -18,6 +18,7 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/memory/Memory.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/parquet/RegisterParquetReader.h"
 #include "velox/dwio/parquet/RegisterParquetWriter.h"
 #include "velox/exec/TableWriter.h"
@@ -33,13 +34,9 @@ class InsertTest : public velox::test::VectorTestBase {
   void SetUp(
       std::shared_ptr<const config::ConfigBase> hiveConfig,
       folly::Executor* ioExecutor) {
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
-    auto hiveConnector =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(
-                exec::test::kHiveConnectorId, hiveConfig, ioExecutor);
+    connector::hive::HiveConnectorFactory factory;
+    auto hiveConnector = factory.newConnector(
+        exec::test::kHiveConnectorId, hiveConfig, ioExecutor);
     connector::registerConnector(hiveConnector);
 
     parquet::registerParquetReaderFactory();
@@ -49,8 +46,7 @@ class InsertTest : public velox::test::VectorTestBase {
   void TearDown() {
     parquet::unregisterParquetReaderFactory();
     parquet::unregisterParquetWriterFactory();
-    connector::unregisterConnectorFactory(
-        connector::hive::HiveConnectorFactory::kHiveConnectorName);
+
     connector::unregisterConnector(exec::test::kHiveConnectorId);
   }
 
diff --git a/velox/connectors/hive/tests/CMakeLists.txt b/velox/connectors/hive/tests/CMakeLists.txt
index 0ff796e9077e..2662fe6824fc 100644
--- a/velox/connectors/hive/tests/CMakeLists.txt
+++ b/velox/connectors/hive/tests/CMakeLists.txt
@@ -20,10 +20,11 @@ add_executable(
   HiveConnectorUtilTest.cpp
   HiveConnectorSerDeTest.cpp
   HivePartitionFunctionTest.cpp
-  HivePartitionUtilTest.cpp
+  HivePartitionNameTest.cpp
   HiveSplitTest.cpp
   PartitionIdGeneratorTest.cpp
-  TableHandleTest.cpp)
+  TableHandleTest.cpp
+)
 add_test(velox_hive_connector_test velox_hive_connector_test)
 
 target_link_libraries(
@@ -36,13 +37,14 @@ target_link_libraries(
   velox_exec
   velox_exec_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  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_parquet_writer
-                        velox_dwio_parquet_reader)
-
+  target_include_directories(velox_hive_connector_test PUBLIC ${ARROW_PREFIX}/install/include)
+  target_link_libraries(
+    velox_hive_connector_test
+    velox_dwio_parquet_writer
+    velox_dwio_parquet_reader
+  )
 endif()
diff --git a/velox/connectors/hive/tests/FileHandleTest.cpp b/velox/connectors/hive/tests/FileHandleTest.cpp
index fcbea2c0fe6e..6c3e71c42fe2 100644
--- a/velox/connectors/hive/tests/FileHandleTest.cpp
+++ b/velox/connectors/hive/tests/FileHandleTest.cpp
@@ -37,9 +37,10 @@ TEST(FileHandleTest, localFile) {
   }
 
   FileHandleFactory factory(
-      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(1000),
+      std::make_unique<SimpleLRUCache<FileHandleKey, FileHandle>>(1000),
       std::make_unique<FileHandleGenerator>());
-  auto fileHandle = factory.generate(filename);
+  FileHandleKey key{filename};
+  auto fileHandle = factory.generate(key);
   ASSERT_EQ(fileHandle->file->size(), 3);
   char buffer[3];
   ASSERT_EQ(fileHandle->file->pread(0, 3, &buffer), "foo");
@@ -61,12 +62,13 @@ TEST(FileHandleTest, localFileWithProperties) {
   }
 
   FileHandleFactory factory(
-      std::make_unique<SimpleLRUCache<std::string, FileHandle>>(1000),
+      std::make_unique<SimpleLRUCache<FileHandleKey, FileHandle>>(1000),
       std::make_unique<FileHandleGenerator>());
   FileProperties properties = {
       .fileSize = tempFile->fileSize(),
       .modificationTime = tempFile->fileModifiedTime()};
-  auto fileHandle = factory.generate(filename, &properties);
+  FileHandleKey key{filename};
+  auto fileHandle = factory.generate(key, &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
index ae76870f492f..bdba80eefb0b 100644
--- a/velox/connectors/hive/tests/HiveConfigTest.cpp
+++ b/velox/connectors/hive/tests/HiveConfigTest.cpp
@@ -23,8 +23,9 @@ 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>()));
+  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(
@@ -53,6 +54,7 @@ TEST(HiveConfigTest, defaultConfig) {
   ASSERT_TRUE(hiveConfig.isPartitionPathAsLowerCase(emptySession.get()));
   ASSERT_TRUE(hiveConfig.allowNullPartitionKeys(emptySession.get()));
   ASSERT_EQ(hiveConfig.loadQuantum(emptySession.get()), 8 << 20);
+  ASSERT_FALSE(hiveConfig.preserveFlatMapsInMemory(emptySession.get()));
 }
 
 TEST(HiveConfigTest, overrideConfig) {
@@ -74,7 +76,9 @@ TEST(HiveConfigTest, overrideConfig) {
       {HiveConfig::kSortWriterMaxOutputBytes, "100MB"},
       {HiveConfig::kSortWriterFinishTimeSliceLimitMs, "400"},
       {HiveConfig::kReadStatsBasedFilterReorderDisabled, "true"},
-      {HiveConfig::kLoadQuantum, std::to_string(4 << 20)}};
+      {HiveConfig::kLoadQuantum, std::to_string(4 << 20)},
+      {HiveConfig::kMaxBucketCount, std::to_string(100'000)},
+      {HiveConfig::kPreserveFlatMapsInMemory, "true"}};
   HiveConfig hiveConfig(
       std::make_shared<config::ConfigBase>(std::move(configFromFile)));
   auto emptySession = std::make_shared<config::ConfigBase>(
@@ -104,11 +108,14 @@ TEST(HiveConfigTest, overrideConfig) {
   ASSERT_TRUE(
       hiveConfig.readStatsBasedFilterReorderDisabled(emptySession.get()));
   ASSERT_EQ(hiveConfig.loadQuantum(emptySession.get()), 4 << 20);
+  ASSERT_EQ(hiveConfig.maxBucketCount(emptySession.get()), 100'000);
+  ASSERT_TRUE(hiveConfig.preserveFlatMapsInMemory(emptySession.get()));
 }
 
 TEST(HiveConfigTest, overrideSession) {
-  HiveConfig hiveConfig(std::make_shared<config::ConfigBase>(
-      std::unordered_map<std::string, std::string>()));
+  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"},
@@ -121,7 +128,9 @@ TEST(HiveConfigTest, overrideSession) {
       {HiveConfig::kAllowNullPartitionKeysSession, "false"},
       {HiveConfig::kIgnoreMissingFilesSession, "true"},
       {HiveConfig::kReadStatsBasedFilterReorderDisabledSession, "true"},
-      {HiveConfig::kLoadQuantumSession, std::to_string(4 << 20)}};
+      {HiveConfig::kLoadQuantumSession, std::to_string(4 << 20)},
+      {HiveConfig::kPreserveFlatMapsInMemorySession, "true"},
+  };
   const auto session =
       std::make_unique<config::ConfigBase>(std::move(sessionOverride));
   ASSERT_EQ(
@@ -147,4 +156,5 @@ TEST(HiveConfigTest, overrideSession) {
   ASSERT_TRUE(hiveConfig.ignoreMissingFiles(session.get()));
   ASSERT_TRUE(hiveConfig.readStatsBasedFilterReorderDisabled(session.get()));
   ASSERT_EQ(hiveConfig.loadQuantum(session.get()), 4 << 20);
+  ASSERT_TRUE(hiveConfig.preserveFlatMapsInMemory(session.get()));
 }
diff --git a/velox/connectors/hive/tests/HiveConnectorSerDeTest.cpp b/velox/connectors/hive/tests/HiveConnectorSerDeTest.cpp
index 4c5ce7132946..ebe71e7b4b04 100644
--- a/velox/connectors/hive/tests/HiveConnectorSerDeTest.cpp
+++ b/velox/connectors/hive/tests/HiveConnectorSerDeTest.cpp
@@ -15,10 +15,10 @@
  */
 
 #include <gtest/gtest.h>
-#include "velox/connectors/Connector.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/type/tests/SubfieldFiltersBuilder.h"
 
 namespace facebook::velox::connector::hive::test {
 namespace {
@@ -31,14 +31,7 @@ class HiveConnectorSerDeTest : public exec::test::HiveConnectorTestBase {
     Type::registerSerDe();
     common::Filter::registerSerDe();
     core::ITypedExpr::registerSerDe();
-    HiveTableHandle::registerSerDe();
-    HiveColumnHandle::registerSerDe();
-    LocationHandle::registerSerDe();
-    HiveInsertTableHandle::registerSerDe();
-    HiveBucketProperty::registerSerDe();
-    HiveSortingColumn::registerSerDe();
-    HiveConnectorSplit::registerSerDe();
-    HiveInsertFileNameGenerator::registerSerDe();
+    HiveConnector::registerSerDe();
   }
 
   template <typename T>
@@ -161,6 +154,7 @@ TEST_F(HiveConnectorSerDeTest, hiveColumnHandle) {
       HiveColumnHandle::ColumnType::kRegular,
       HiveColumnHandle::ColumnType::kSynthesized,
       HiveColumnHandle::ColumnType::kRowIndex,
+      HiveColumnHandle::ColumnType::kRowId,
   };
 
   for (auto columnHandleType : columnHandleTypes) {
diff --git a/velox/connectors/hive/tests/HiveConnectorTest.cpp b/velox/connectors/hive/tests/HiveConnectorTest.cpp
index 4834cf3b8335..1a6934077907 100644
--- a/velox/connectors/hive/tests/HiveConnectorTest.cpp
+++ b/velox/connectors/hive/tests/HiveConnectorTest.cpp
@@ -21,6 +21,7 @@
 #include "velox/connectors/hive/HiveConfig.h"
 #include "velox/connectors/hive/HiveConnectorUtil.h"
 #include "velox/connectors/hive/HiveDataSource.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 
 namespace facebook::velox::connector::hive {
@@ -64,7 +65,7 @@ groupSubfields(const std::vector<Subfield>& subfields) {
 }
 
 bool mapKeyIsNotNull(const ScanSpec& mapSpec) {
-  return dynamic_cast<IsNotNull*>(
+  return dynamic_cast<const IsNotNull*>(
       mapSpec.childByName(ScanSpec::kMapKeysFieldName)->filter());
 }
 
@@ -92,8 +93,10 @@ TEST_F(HiveConnectorTest, makeScanSpecRequiredSubfieldsMultilevel) {
   auto rowType = ROW({{"c0", columnType}});
   auto subfields = makeSubfields({"c0.c0c1[3][\"foo\"].c0c1c0"});
   for (bool statsBasedFilterReorderDisabled : {false, true}) {
-    SCOPED_TRACE(fmt::format(
-        "statsBasedFilterReorderDisabled {}", statsBasedFilterReorderDisabled));
+    SCOPED_TRACE(
+        fmt::format(
+            "statsBasedFilterReorderDisabled {}",
+            statsBasedFilterReorderDisabled));
 
     auto scanSpec = makeScanSpec(
         rowType,
@@ -581,8 +584,8 @@ TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
   auto expr = parseExpr("not (c0 > 0 or c1 > 0)", rowType);
   SubfieldFilters filters;
   double sampleRate = 1;
-  auto remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  auto remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_FALSE(remaining);
   ASSERT_EQ(sampleRate, 1);
   ASSERT_EQ(filters.size(), 2);
@@ -591,8 +594,8 @@ TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
 
   expr = parseExpr("not (c0 > 0 or c1 > c0)", rowType);
   filters.clear();
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_EQ(sampleRate, 1);
   ASSERT_EQ(filters.size(), 1);
   ASSERT_GT(filters.count(Subfield("c0")), 0);
@@ -602,14 +605,49 @@ TEST_F(HiveConnectorTest, extractFiltersFromRemainingFilter) {
   expr = parseExpr(
       "not (c2 > 1::decimal(20, 0) or c2 < 0::decimal(20, 0))", rowType);
   filters.clear();
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_EQ(sampleRate, 1);
   ASSERT_GT(filters.count(Subfield("c2")), 0);
   // Change these once HUGEINT filter merge is fixed.
   ASSERT_TRUE(remaining);
   ASSERT_EQ(
-      remaining->toString(), "not(lt(ROW[\"c2\"],cast 0 as DECIMAL(20, 0)))");
+      remaining->toString(), "not(lt(ROW[\"c2\"],cast(0 as DECIMAL(20, 0))))");
+
+  // parseExpr gives AND/OR with 2 arguments.  We need to construct the node
+  // manually to have more than 2.
+  expr = std::make_shared<core::CallTypedExpr>(
+      BOOLEAN(),
+      expression::kAnd,
+      parseExpr("c0 > 0", rowType),
+      parseExpr("c1 > 0", rowType),
+      parseExpr("c2 > 0::decimal(20, 0)", rowType));
+  filters.clear();
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
+  ASSERT_EQ(sampleRate, 1);
+  ASSERT_EQ(filters.size(), 3);
+  ASSERT_TRUE(filters.contains(Subfield("c0")));
+  ASSERT_TRUE(filters.contains(Subfield("c1")));
+  ASSERT_TRUE(filters.contains(Subfield("c2")));
+  ASSERT_FALSE(remaining);
+
+  expr = std::make_shared<core::CallTypedExpr>(
+      BOOLEAN(),
+      expression::kAnd,
+      parseExpr("c0 % 2 = 0", rowType),
+      parseExpr("c1 % 3 = 0", rowType),
+      parseExpr("c2 > 0::decimal(20, 0)", rowType));
+  filters.clear();
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
+  ASSERT_EQ(sampleRate, 1);
+  ASSERT_EQ(filters.size(), 1);
+  ASSERT_TRUE(filters.contains(Subfield("c2")));
+  ASSERT_TRUE(remaining);
+  ASSERT_EQ(
+      remaining->toString(),
+      "and(eq(mod(ROW[\"c0\"],2),0),eq(mod(ROW[\"c1\"],3),0))");
 }
 
 TEST_F(HiveConnectorTest, prestoTableSampling) {
@@ -620,8 +658,8 @@ TEST_F(HiveConnectorTest, prestoTableSampling) {
   auto expr = parseExpr("rand() < 0.5", rowType);
   SubfieldFilters filters;
   double sampleRate = 1;
-  auto remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  auto remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_FALSE(remaining);
   ASSERT_EQ(sampleRate, 0.5);
   ASSERT_TRUE(filters.empty());
@@ -629,8 +667,8 @@ TEST_F(HiveConnectorTest, prestoTableSampling) {
   expr = parseExpr("c0 > 0 and rand() < 0.5", rowType);
   filters.clear();
   sampleRate = 1;
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_FALSE(remaining);
   ASSERT_EQ(sampleRate, 0.5);
   ASSERT_EQ(filters.size(), 1);
@@ -639,8 +677,8 @@ TEST_F(HiveConnectorTest, prestoTableSampling) {
   expr = parseExpr("rand() < 0.5 and rand() < 0.5", rowType);
   filters.clear();
   sampleRate = 1;
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_FALSE(remaining);
   ASSERT_EQ(sampleRate, 0.25);
   ASSERT_TRUE(filters.empty());
@@ -648,13 +686,73 @@ TEST_F(HiveConnectorTest, prestoTableSampling) {
   expr = parseExpr("c0 > 0 or rand() < 0.5", rowType);
   filters.clear();
   sampleRate = 1;
-  remaining = extractFiltersFromRemainingFilter(
-      expr, &evaluator, false, filters, sampleRate);
+  remaining =
+      extractFiltersFromRemainingFilter(expr, &evaluator, filters, sampleRate);
   ASSERT_TRUE(remaining);
   ASSERT_EQ(*remaining, *expr);
   ASSERT_EQ(sampleRate, 1);
   ASSERT_TRUE(filters.empty());
 }
 
+#define VELOX_ASSERT_FILTER(expected, actual)   \
+  ASSERT_TRUE(expected->testingEquals(*actual)) \
+      << expected->toString() << " vs " << actual->toString();
+
+TEST_F(HiveConnectorTest, disjuncts) {
+  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("(c0 > 0 and c0 < 10) or (c0 > 5 and c0 < 15)", rowType);
+
+    SubfieldFilters filters;
+    double sampleRate = 1;
+    auto remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_TRUE(remaining == nullptr);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_EQ(filters.size(), 1);
+    VELOX_ASSERT_FILTER(exec::between(1, 14), filters.begin()->second);
+  }
+
+  {
+    auto expr = parseExpr("(c0 between -10 and 12)", rowType);
+
+    SubfieldFilters filters;
+    double sampleRate = 1;
+    auto remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_TRUE(remaining == nullptr);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_EQ(filters.size(), 1);
+    ASSERT_EQ(filters.begin()->first, Subfield("c0"));
+    VELOX_ASSERT_FILTER(exec::between(-10, 12), filters.begin()->second);
+
+    expr = parseExpr("(c0 > 0 and c0 < 10) or (c0 > 5 and c0 < 15)", rowType);
+    remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_TRUE(remaining == nullptr);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_EQ(filters.size(), 1);
+    ASSERT_EQ(filters.begin()->first, Subfield("c0"));
+    VELOX_ASSERT_FILTER(exec::between(1, 12), filters.begin()->second);
+  }
+
+  {
+    auto expr = parseExpr("c0 not in (1, 3) or c0 in (1, 2)", rowType);
+    SubfieldFilters filters;
+    double sampleRate = 1;
+    auto remaining = extractFiltersFromRemainingFilter(
+        expr, &evaluator, filters, sampleRate);
+    ASSERT_EQ(remaining, expr);
+    ASSERT_EQ(sampleRate, 1);
+    ASSERT_TRUE(filters.empty());
+  }
+}
+
+#undef VELOX_ASSERT_FILTER
+
 } // namespace
 } // namespace facebook::velox::connector::hive
diff --git a/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp b/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp
index fd4971bdff12..2c6dd76f4549 100644
--- a/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp
+++ b/velox/connectors/hive/tests/HiveConnectorUtilTest.cpp
@@ -336,18 +336,6 @@ TEST_F(HiveConnectorUtilTest, cacheRetention) {
   }
 }
 
-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, configureSstRowReaderOptions) {
   dwio::common::RowReaderOptions rowReaderOpts;
   auto hiveSplit =
@@ -364,9 +352,118 @@ TEST_F(HiveConnectorUtilTest, configureSstRowReaderOptions) {
       /*hiveSplit=*/hiveSplit,
       /*hiveConfig=*/nullptr,
       /*sessionProperties=*/nullptr,
+      /*ioExecutor=*/nullptr,
       /*rowReaderOptions=*/rowReaderOpts);
 
   EXPECT_EQ(rowReaderOpts.serdeParameters(), hiveSplit->serdeParameters);
 }
 
+TEST_F(HiveConnectorUtilTest, configureRowReaderOptionsFromConfig) {
+  // Test default behavior (preserveFlatMapsInMemory = false)
+  {
+    auto hiveConfig =
+        std::make_shared<hive::HiveConfig>(std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
+    config::ConfigBase sessionProperties({});
+
+    dwio::common::RowReaderOptions rowReaderOpts;
+    auto hiveSplit =
+        std::make_shared<hive::HiveConnectorSplit>("", "", FileFormat::DWRF);
+
+    configureRowReaderOptions(
+        /*tableParameters=*/{},
+        /*scanSpec=*/nullptr,
+        /*metadataFilter=*/nullptr,
+        /*rowType=*/nullptr,
+        /*hiveSplit=*/hiveSplit,
+        /*hiveConfig=*/hiveConfig,
+        /*sessionProperties=*/&sessionProperties,
+        /*ioExecutor=*/nullptr,
+        /*rowReaderOptions=*/rowReaderOpts);
+
+    EXPECT_FALSE(rowReaderOpts.preserveFlatMapsInMemory());
+  }
+
+  // Test with config override (preserveFlatMapsInMemory = true)
+  {
+    std::unordered_map<std::string, std::string> configProps = {
+        {hive::HiveConfig::kPreserveFlatMapsInMemory, "true"}};
+    auto hiveConfig = std::make_shared<hive::HiveConfig>(
+        std::make_shared<config::ConfigBase>(std::move(configProps)));
+    config::ConfigBase sessionProperties({});
+
+    dwio::common::RowReaderOptions rowReaderOpts;
+    auto hiveSplit =
+        std::make_shared<hive::HiveConnectorSplit>("", "", FileFormat::DWRF);
+
+    configureRowReaderOptions(
+        /*tableParameters=*/{},
+        /*scanSpec=*/nullptr,
+        /*metadataFilter=*/nullptr,
+        /*rowType=*/nullptr,
+        /*hiveSplit=*/hiveSplit,
+        /*hiveConfig=*/hiveConfig,
+        /*sessionProperties=*/&sessionProperties,
+        /*ioExecutor=*/nullptr,
+        /*rowReaderOptions=*/rowReaderOpts);
+
+    EXPECT_TRUE(rowReaderOpts.preserveFlatMapsInMemory());
+  }
+
+  // Test with session override (preserveFlatMapsInMemory = true)
+  {
+    auto hiveConfig =
+        std::make_shared<hive::HiveConfig>(std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
+    std::unordered_map<std::string, std::string> sessionProps = {
+        {hive::HiveConfig::kPreserveFlatMapsInMemorySession, "true"}};
+    config::ConfigBase sessionProperties(std::move(sessionProps));
+
+    dwio::common::RowReaderOptions rowReaderOpts;
+    auto hiveSplit =
+        std::make_shared<hive::HiveConnectorSplit>("", "", FileFormat::DWRF);
+
+    configureRowReaderOptions(
+        /*tableParameters=*/{},
+        /*scanSpec=*/nullptr,
+        /*metadataFilter=*/nullptr,
+        /*rowType=*/nullptr,
+        /*hiveSplit=*/hiveSplit,
+        /*hiveConfig=*/hiveConfig,
+        /*sessionProperties=*/&sessionProperties,
+        /*ioExecutor=*/nullptr,
+        /*rowReaderOptions=*/rowReaderOpts);
+
+    EXPECT_TRUE(rowReaderOpts.preserveFlatMapsInMemory());
+  }
+
+  // Test session override takes precedence over config
+  {
+    std::unordered_map<std::string, std::string> configProps = {
+        {hive::HiveConfig::kPreserveFlatMapsInMemory, "false"}};
+    auto hiveConfig = std::make_shared<hive::HiveConfig>(
+        std::make_shared<config::ConfigBase>(std::move(configProps)));
+    std::unordered_map<std::string, std::string> sessionProps = {
+        {hive::HiveConfig::kPreserveFlatMapsInMemorySession, "true"}};
+    config::ConfigBase sessionProperties(std::move(sessionProps));
+
+    dwio::common::RowReaderOptions rowReaderOpts;
+    auto hiveSplit =
+        std::make_shared<hive::HiveConnectorSplit>("", "", FileFormat::DWRF);
+
+    configureRowReaderOptions(
+        /*tableParameters=*/{},
+        /*scanSpec=*/nullptr,
+        /*metadataFilter=*/nullptr,
+        /*rowType=*/nullptr,
+        /*hiveSplit=*/hiveSplit,
+        /*hiveConfig=*/hiveConfig,
+        /*sessionProperties=*/&sessionProperties,
+        /*ioExecutor=*/nullptr,
+        /*rowReaderOptions=*/rowReaderOpts);
+
+    EXPECT_TRUE(rowReaderOpts.preserveFlatMapsInMemory());
+  }
+}
+
 } // namespace facebook::velox::connector
diff --git a/velox/connectors/hive/tests/HiveDataSinkTest.cpp b/velox/connectors/hive/tests/HiveDataSinkTest.cpp
index 537db9e064cb..893cec45c7fa 100644
--- a/velox/connectors/hive/tests/HiveDataSinkTest.cpp
+++ b/velox/connectors/hive/tests/HiveDataSinkTest.cpp
@@ -15,13 +15,16 @@
  */
 
 #include <gtest/gtest.h>
+#include "velox/common/caching/AsyncDataCache.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 
 #include <folly/init/Init.h>
+#include <folly/system/HardwareConcurrency.h>
 #include <re2/re2.h>
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/common/BufferedInput.h"
 #include "velox/dwio/common/Options.h"
 #include "velox/dwio/dwrf/reader/DwrfReader.h"
@@ -71,7 +74,7 @@ class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
     setupMemoryPools();
 
     spillExecutor_ = std::make_unique<folly::IOThreadPoolExecutor>(
-        std::thread::hardware_concurrency());
+        folly::hardware_concurrency());
   }
 
   void TearDown() override {
@@ -111,7 +114,8 @@ class HiveDataSinkTest : public exec::test::HiveConnectorTestBase {
         0,
         0,
         writerFlushThreshold,
-        "none");
+        "none",
+        0);
   }
 
   void setupMemoryPools() {
@@ -1314,6 +1318,108 @@ TEST_F(HiveDataSinkTest, ensureFilesUnsupported) {
           ),
       "ensureFiles is not supported with bucketing");
 }
+
+TEST_F(HiveDataSinkTest, raceWithCacheEviction) {
+  /// This test ensures that LRU cache staleness and StringIdMap cache
+  /// eviction do not cause issues with file reads.
+  std::atomic<bool> stop{false};
+  auto cacheCleaner = std::async(std::launch::async, [&] {
+    auto cache = cache::AsyncDataCache::getInstance();
+    auto hiveConnector = std::dynamic_pointer_cast<HiveConnector>(
+        getConnector(exec::test::kHiveConnectorId));
+    while (!stop) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+      cache->clear();
+      hiveConnector->clearFileHandleCache();
+    }
+  });
+
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto dataSink = createDataSink(rowType_, outputDirectory->getPath());
+  const auto vectors = createVectors(500 /*vectorSize*/, 10 /*numVectors*/);
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+  ASSERT_TRUE(dataSink->finish());
+  ASSERT_FALSE(dataSink->close().empty());
+
+  createDuckDbTable(vectors);
+  verifyWrittenData(outputDirectory->getPath());
+
+  stop = true;
+  cacheCleaner.get();
+}
+
+#ifdef VELOX_ENABLE_PARQUET
+TEST_F(HiveDataSinkTest, lazyVectorForParquet) {
+  // This test ensures that lazy vector is handled correctly in HiveDataSink.
+  VectorFuzzer::Options options{.vectorSize = 100};
+  VectorFuzzer fuzzer(options, pool());
+
+  auto lazyVector = fuzzer.wrapInLazyVector(fuzzer.fuzzFlat(BIGINT(), 100));
+  auto lazyMapVector = fuzzer.wrapInLazyVector(fuzzer.fuzzMap(
+      fuzzer.fuzzFlat(BIGINT(), 100), fuzzer.fuzzFlat(VARCHAR(), 100), 100));
+
+  auto rowType = ROW({"c0", "c1"}, {BIGINT(), MAP(BIGINT(), VARCHAR())});
+  std::vector<VectorPtr> children;
+  children.emplace_back(lazyVector);
+  children.emplace_back(lazyMapVector);
+  auto row = std::make_shared<RowVector>(
+      pool(), rowType, nullptr, 100, std::move(children));
+
+  const auto outputDirectory = TempDirectoryPath::create();
+  auto dataSink = createDataSink(
+      rowType, outputDirectory->getPath(), dwio::common::FileFormat::PARQUET);
+
+  dataSink->appendData(row);
+  ASSERT_TRUE(dataSink->finish());
+  dataSink->close();
+}
+#endif
+
+// Test to verify that each writer has its own nonReclaimableSection
+// pointer when writerOptions is shared.
+TEST_F(HiveDataSinkTest, sharedWriterOptionsWithMultipleWriters) {
+  const auto outputDirectory = TempDirectoryPath::create();
+
+  const int32_t numBuckets = 3;
+  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>>{});
+
+  // Create shared writer options (this simulates the scenario where
+  // insertTableHandle_->writerOptions() returns a shared object)
+  auto sharedWriterOptions = std::make_shared<dwrf::WriterOptions>();
+
+  // Create a data sink with multiple writers (one for each bucket)
+  auto dataSink = createDataSink(
+      rowType_,
+      outputDirectory->getPath(),
+      dwio::common::FileFormat::DWRF,
+      {},
+      bucketProperty,
+      sharedWriterOptions);
+
+  const auto vectors = createVectors(200, 3);
+
+  // Write data - this should work without throwing exceptions
+  for (const auto& vector : vectors) {
+    dataSink->appendData(vector);
+  }
+
+  while (!dataSink->finish()) {
+  }
+  const auto partitions = dataSink->close();
+
+  ASSERT_GT(partitions.size(), 1);
+  createDuckDbTable(vectors);
+  verifyWrittenData(
+      outputDirectory->getPath(), static_cast<int32_t>(partitions.size()));
+}
+
 } // namespace
 } // namespace facebook::velox::connector::hive
 
diff --git a/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp b/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
index 4fdf68684b04..1adfb3874458 100644
--- a/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
+++ b/velox/connectors/hive/tests/HivePartitionFunctionTest.cpp
@@ -832,10 +832,11 @@ TEST_F(HivePartitionFunctionTest, skew) {
   }
   std::vector<VectorPtr> partitionedInputs;
   for (int partition = 0; partition < numRemotePartitions; ++partition) {
-    partitionedInputs.push_back(exec::wrap(
-        partitionSizeVectors[partition],
-        partitionIndicesVector[partition],
-        input));
+    partitionedInputs.push_back(
+        exec::wrap(
+            partitionSizeVectors[partition],
+            partitionIndicesVector[partition],
+            input));
   }
 
   // Checks that the bad hive partition function (using round-robin map from
diff --git a/velox/connectors/hive/tests/HivePartitionUtilTest.cpp b/velox/connectors/hive/tests/HivePartitionNameTest.cpp
similarity index 58%
rename from velox/connectors/hive/tests/HivePartitionUtilTest.cpp
rename to velox/connectors/hive/tests/HivePartitionNameTest.cpp
index 7942233b615a..b236951946f4 100644
--- a/velox/connectors/hive/tests/HivePartitionUtilTest.cpp
+++ b/velox/connectors/hive/tests/HivePartitionNameTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "velox/connectors/hive/HivePartitionUtil.h"
+#include "velox/connectors/hive/HivePartitionName.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/catalog/fbhive/FileUtils.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -26,9 +26,13 @@ using namespace facebook::velox;
 using namespace facebook::velox::connector::hive;
 using namespace facebook::velox::dwio::catalog::fbhive;
 
-class HivePartitionUtilTest : public ::testing::Test,
+class HivePartitionNameTest : public ::testing::Test,
                               public velox::test::VectorTestBase {
  protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
   template <typename T>
   VectorPtr makeDictionary(const std::vector<T>& data) {
     auto base = makeFlatVector(data);
@@ -58,9 +62,26 @@ class HivePartitionUtilTest : public ::testing::Test,
         input->size(),
         partitions);
   }
+
+  static auto toPartitionName() {
+    return [](auto value, const TypePtr& type, int /*columnIndex*/) {
+      return HivePartitionName::toName(value, type);
+    };
+  }
+
+  std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
+      RowVectorPtr input,
+      const std::vector<column_index_t>& partitionChannels,
+      vector_size_t rowIndex = 0) {
+    return HivePartitionName::partitionKeyValues(
+        rowIndex,
+        makePartitionsVector(input, partitionChannels),
+        /*nullValueString=*/"",
+        toPartitionName());
+  }
 };
 
-TEST_F(HivePartitionUtilTest, partitionName) {
+TEST_F(HivePartitionNameTest, partitionName) {
   {
     RowVectorPtr input = makeRowVector(
         {"flat_bool_col",
@@ -69,14 +90,17 @@ TEST_F(HivePartitionUtilTest, partitionName) {
          "flat_int_col",
          "flat_bigint_col",
          "dict_string_col",
-         "const_date_col"},
+         "const_date_col",
+         "flat_timestamp_col"},
         {makeFlatVector<bool>(std::vector<bool>{false}),
          makeFlatVector<int8_t>(std::vector<int8_t>{10}),
          makeFlatVector<int16_t>(std::vector<int16_t>{100}),
          makeFlatVector<int32_t>(std::vector<int32_t>{1000}),
          makeFlatVector<int64_t>(std::vector<int64_t>{10000}),
          makeDictionary<StringView>(std::vector<StringView>{"str1000"}),
-         makeConstant<int32_t>(10000, 1, DATE())});
+         makeConstant<int32_t>(10000, 1, DATE()),
+         makeFlatVector<Timestamp>(
+             std::vector<Timestamp>{Timestamp::fromMillis(1577836800000)})});
 
     std::vector<std::string> expectedPartitionKeyValues{
         "flat_bool_col=false",
@@ -85,7 +109,8 @@ TEST_F(HivePartitionUtilTest, partitionName) {
         "flat_int_col=1000",
         "flat_bigint_col=10000",
         "dict_string_col=str1000",
-        "const_date_col=1997-05-19"};
+        "const_date_col=1997-05-19",
+        "flat_timestamp_col=2019-12-31 16%3A00%3A00.0"};
 
     std::vector<column_index_t> partitionChannels;
     for (auto i = 1; i <= expectedPartitionKeyValues.size(); i++) {
@@ -94,9 +119,7 @@ TEST_F(HivePartitionUtilTest, partitionName) {
 
       EXPECT_EQ(
           FileUtils::makePartName(
-              extractPartitionKeyValues(
-                  makePartitionsVector(input, partitionChannels), 0),
-              true),
+              extractPartitionKeyValues(input, partitionChannels), true),
           folly::join(
               "/",
               std::vector<std::string>(
@@ -116,14 +139,12 @@ TEST_F(HivePartitionUtilTest, partitionName) {
 
     VELOX_ASSERT_THROW(
         FileUtils::makePartName(
-            extractPartitionKeyValues(
-                makePartitionsVector(input, partitionChannels), 0),
-            true),
+            extractPartitionKeyValues(input, partitionChannels), true),
         "Unsupported partition type: MAP");
   }
 }
 
-TEST_F(HivePartitionUtilTest, partitionNameForNull) {
+TEST_F(HivePartitionNameTest, partitionNameForNull) {
   std::vector<std::string> partitionColumnNames{
       "flat_bool_col",
       "flat_tinyint_col",
@@ -131,7 +152,8 @@ TEST_F(HivePartitionUtilTest, partitionNameForNull) {
       "flat_int_col",
       "flat_bigint_col",
       "flat_string_col",
-      "const_date_col"};
+      "const_date_col",
+      "flat_timestamp_col"};
 
   RowVectorPtr input = makeRowVector(
       partitionColumnNames,
@@ -141,14 +163,56 @@ TEST_F(HivePartitionUtilTest, partitionNameForNull) {
        makeNullableFlatVector<int32_t>({std::nullopt}),
        makeNullableFlatVector<int64_t>({std::nullopt}),
        makeNullableFlatVector<StringView>({std::nullopt}),
-       makeConstant<int32_t>(std::nullopt, 1, DATE())});
+       makeConstant<int32_t>(std::nullopt, 1, DATE()),
+       makeNullableFlatVector<Timestamp>({std::nullopt})});
 
   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);
+    auto partitionEntries = extractPartitionKeyValues(input, partitionChannels);
     EXPECT_EQ(1, partitionEntries.size());
     EXPECT_EQ(partitionColumnNames[i], partitionEntries[0].first);
     EXPECT_EQ("", partitionEntries[0].second);
   }
 }
+
+TEST_F(HivePartitionNameTest, timestampPartitionValueFormatting) {
+  // Test timestamp partition value formatting to match Presto's
+  // java.sql.Timestamp.toString() behavior: removes trailing zeros but keeps at
+  // least one decimal place
+  std::vector<Timestamp> timestamps = {
+      // Test case 1: All zeros in fractional seconds -> should become ".0"
+      Timestamp(
+          0, 0), // 1970-01-01 00:00:00.000 UTC -> 1969-12-31 16:00:00.0 PST
+
+      // Test case 2: Trailing zeros should be removed
+      Timestamp(0, 980000000), // 1970-01-01 00:00:00.980 UTC -> 1969-12-31
+      // 16:00:00.98 PST
+
+      // Test case 3: No trailing zeros, should remain unchanged
+      Timestamp(0, 123000000), // 1970-01-01 00:00:00.123 UTC -> 1969-12-31
+      // 16:00:00.123 PST
+  };
+
+  // Expected values account for timezone conversion to PST (UTC-8)
+  std::vector<std::string> expectedValues = {
+      "1969-12-31 16:00:00.0", // .000 -> .0 (converted to PST)
+      "1969-12-31 16:00:00.98", // .980 -> .98 (converted to PST)
+      "1969-12-31 16:00:00.123", // .123 -> .123 (converted to PST)
+  };
+
+  RowVectorPtr input =
+      makeRowVector({"timestamp_col"}, {makeFlatVector<Timestamp>(timestamps)});
+
+  std::vector<column_index_t> partitionChannels{0};
+
+  for (size_t i = 0; i < timestamps.size(); i++) {
+    auto partitionEntries =
+        extractPartitionKeyValues(input, partitionChannels, i);
+
+    EXPECT_EQ(1, partitionEntries.size());
+    EXPECT_EQ("timestamp_col", partitionEntries[0].first);
+    EXPECT_EQ(expectedValues[i], partitionEntries[0].second)
+        << "Failed for timestamp index " << i << " with value "
+        << timestamps[i].toString();
+  }
+}
diff --git a/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp b/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
index e91782666878..7dcb0d5e1959 100644
--- a/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
+++ b/velox/connectors/hive/tests/PartitionIdGeneratorTest.cpp
@@ -16,6 +16,8 @@
 
 #include "velox/connectors/hive/PartitionIdGenerator.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/connectors/hive/HivePartitionName.h"
+#include "velox/type/TimestampConversion.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include "gtest/gtest.h"
@@ -33,7 +35,7 @@ class PartitionIdGeneratorTest : public ::testing::Test,
 TEST_F(PartitionIdGeneratorTest, consecutiveIdsSingleKey) {
   auto numPartitions = 100;
 
-  PartitionIdGenerator idGenerator(ROW({VARCHAR()}), {0}, 100, pool(), true);
+  PartitionIdGenerator idGenerator(ROW({VARCHAR()}), {0}, 100, pool());
 
   auto input = makeRowVector(
       {makeFlatVector<StringView>(numPartitions * 3, [&](auto row) {
@@ -55,7 +57,7 @@ TEST_F(PartitionIdGeneratorTest, consecutiveIdsSingleKey) {
 
 TEST_F(PartitionIdGeneratorTest, consecutiveIdsMultipleKeys) {
   PartitionIdGenerator idGenerator(
-      ROW({VARCHAR(), INTEGER()}), {0, 1}, 100, pool(), true);
+      ROW({VARCHAR(), INTEGER()}), {0, 1}, 100, pool());
 
   auto input = makeRowVector({
       makeFlatVector<StringView>(
@@ -82,7 +84,7 @@ TEST_F(PartitionIdGeneratorTest, consecutiveIdsMultipleKeys) {
 
 TEST_F(PartitionIdGeneratorTest, multipleBoolKeys) {
   PartitionIdGenerator idGenerator(
-      ROW({BOOLEAN(), BOOLEAN()}), {0, 1}, 100, pool(), true);
+      ROW({BOOLEAN(), BOOLEAN()}), {0, 1}, 100, pool());
 
   auto input = makeRowVector({
       makeFlatVector<bool>(
@@ -108,7 +110,7 @@ TEST_F(PartitionIdGeneratorTest, multipleBoolKeys) {
 }
 
 TEST_F(PartitionIdGeneratorTest, stableIdsSingleKey) {
-  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool(), true);
+  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool());
 
   auto numPartitions = 40;
   auto input = makeRowVector({
@@ -135,7 +137,7 @@ TEST_F(PartitionIdGeneratorTest, stableIdsSingleKey) {
 
 TEST_F(PartitionIdGeneratorTest, stableIdsMultipleKeys) {
   PartitionIdGenerator idGenerator(
-      ROW({BIGINT(), VARCHAR(), INTEGER()}), {1, 2}, 100, pool(), true);
+      ROW({BIGINT(), VARCHAR(), INTEGER()}), {1, 2}, 100, pool());
 
   const vector_size_t size = 1'000;
   auto input = makeRowVector({
@@ -174,7 +176,7 @@ TEST_F(PartitionIdGeneratorTest, stableIdsMultipleKeys) {
 
 TEST_F(PartitionIdGeneratorTest, partitionKeysCaseSensitive) {
   PartitionIdGenerator idGenerator(
-      ROW({"cc0", "Cc1"}, {BIGINT(), VARCHAR()}), {1}, 100, pool(), false);
+      ROW({"cc0", "Cc+1"}, {BIGINT(), VARCHAR()}), {1}, 100, pool());
 
   auto input = makeRowVector({
       makeFlatVector<int64_t>({1, 2, 3}),
@@ -183,12 +185,19 @@ TEST_F(PartitionIdGeneratorTest, partitionKeysCaseSensitive) {
 
   raw_vector<uint64_t> firstTimeIds;
   idGenerator.run(input, firstTimeIds);
-  EXPECT_EQ("Cc1=apple", idGenerator.partitionName(0));
-  EXPECT_EQ("Cc1=orange", idGenerator.partitionName(1));
+
+  EXPECT_EQ(
+      "Cc+1=apple",
+      HivePartitionName::partitionName(
+          0, idGenerator.partitionValues(), /*partitionKeyAsLowerCase=*/false));
+  EXPECT_EQ(
+      "Cc+1=orange",
+      HivePartitionName::partitionName(
+          1, idGenerator.partitionValues(), /*partitionKeyAsLowerCase=*/false));
 }
 
 TEST_F(PartitionIdGeneratorTest, numPartitions) {
-  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool(), true);
+  PartitionIdGenerator idGenerator(ROW({BIGINT()}), {0}, 100, pool());
 
   // First run to process partition 0,..,9. Total num of partitions processed by
   // far is 10.
@@ -223,7 +232,7 @@ TEST_F(PartitionIdGeneratorTest, limitOfPartitionNumber) {
   auto maxPartitions = 100;
 
   PartitionIdGenerator idGenerator(
-      ROW({INTEGER()}), {0}, maxPartitions, pool(), true);
+      ROW({INTEGER()}), {0}, maxPartitions, pool());
 
   auto input = makeRowVector({
       makeFlatVector<int32_t>(maxPartitions + 1, [](auto row) { return row; }),
@@ -236,6 +245,82 @@ TEST_F(PartitionIdGeneratorTest, limitOfPartitionNumber) {
       fmt::format("Exceeded limit of {} distinct partitions.", maxPartitions));
 }
 
+TEST_F(PartitionIdGeneratorTest, timestampPartitionKeyComparasion) {
+  PartitionIdGenerator idGenerator(
+      ROW({"timestamp_col"}, {TIMESTAMP()}), {0}, 100, pool());
+  auto timestampResult = util::fromTimestampString(
+      "2025-01-02 00:00:00.0", util::TimestampParseMode::kPrestoCast);
+  auto input = makeRowVector({
+      makeFlatVector<Timestamp>({timestampResult.value()}),
+  });
+  raw_vector<uint64_t> testTimeIds;
+  idGenerator.run(input, testTimeIds);
+
+  EXPECT_EQ(
+      HivePartitionName::partitionName(
+          testTimeIds[0],
+          idGenerator.partitionValues(),
+          /*partitionKeyAsLowerCase=*/true),
+      "timestamp_col=2025-01-01 16%3A00%3A00.0");
+}
+
+TEST_F(PartitionIdGeneratorTest, timestampPartitionKey) {
+  PartitionIdGenerator idGenerator(ROW({TIMESTAMP()}), {0}, 100, pool());
+
+  auto numPartitions = 50;
+  auto input = makeRowVector({
+      makeFlatVector<Timestamp>(
+          numPartitions,
+          [](auto row) {
+            return Timestamp::fromMillis(
+                1639426440000 + static_cast<int64_t>(row) * 100);
+          }),
+  });
+
+  raw_vector<uint64_t> firstTimeIds;
+  idGenerator.run(input, firstTimeIds);
+
+  std::unordered_set<uint64_t> distinctIds(
+      firstTimeIds.begin(), firstTimeIds.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);
+
+  raw_vector<uint64_t> secondTimeIds;
+  idGenerator.run(input, secondTimeIds);
+
+  for (auto i = 0; i < input->size(); ++i) {
+    EXPECT_EQ(firstTimeIds[i], secondTimeIds[i]) << "at " << i;
+  }
+
+  auto otherNumPartitions = 30;
+  auto otherInput = makeRowVector({
+      makeFlatVector<Timestamp>(
+          otherNumPartitions,
+          [](auto row) {
+            return Timestamp::fromMillis(
+                1639426440000 + static_cast<int64_t>(row) * 500);
+          }),
+  });
+
+  raw_vector<uint64_t> otherIds;
+  idGenerator.run(otherInput, otherIds);
+
+  std::unordered_set<uint64_t> otherDistinctIds(
+      otherIds.begin(), otherIds.end());
+  EXPECT_EQ(otherDistinctIds.size(), otherNumPartitions);
+
+  // Run the original input again and verify stable IDs
+  raw_vector<uint64_t> thirdTimeIds;
+  idGenerator.run(input, thirdTimeIds);
+
+  for (auto i = 0; i < input->size(); ++i) {
+    EXPECT_EQ(firstTimeIds[i], thirdTimeIds[i]) << "at " << i;
+  }
+}
+
 TEST_F(PartitionIdGeneratorTest, supportedPartitionKeyTypes) {
   // Test on supported key types.
   {
@@ -248,23 +333,26 @@ TEST_F(PartitionIdGeneratorTest, supportedPartitionKeyTypes) {
             SMALLINT(),
             INTEGER(),
             BIGINT(),
+            TIMESTAMP(),
         }),
-        {0, 1, 2, 3, 4, 5, 6},
+        {0, 1, 2, 3, 4, 5, 6, 7},
         100,
-        pool(),
-        true);
-
-    auto input = makeRowVector({
-        makeNullableFlatVector<StringView>(
-            {"Left", std::nullopt, "Right"}, VARCHAR()),
-        makeNullableFlatVector<bool>({true, false, std::nullopt}),
-        makeFlatVector<StringView>(
-            {"proton", "neutron", "electron"}, VARBINARY()),
-        makeNullableFlatVector<int8_t>({1, 2, std::nullopt}),
-        makeNullableFlatVector<int16_t>({1, 2, std::nullopt}),
-        makeNullableFlatVector<int32_t>({1, std::nullopt, 2}),
-        makeNullableFlatVector<int64_t>({std::nullopt, 1, 2}),
-    });
+        pool());
+
+    auto input = makeRowVector(
+        {makeNullableFlatVector<StringView>(
+             {"Left", std::nullopt, "Right"}, VARCHAR()),
+         makeNullableFlatVector<bool>({true, false, std::nullopt}),
+         makeFlatVector<StringView>(
+             {"proton", "neutron", "electron"}, VARBINARY()),
+         makeNullableFlatVector<int8_t>({1, 2, std::nullopt}),
+         makeNullableFlatVector<int16_t>({1, 2, std::nullopt}),
+         makeNullableFlatVector<int32_t>({1, std::nullopt, 2}),
+         makeNullableFlatVector<int64_t>({std::nullopt, 1, 2}),
+         makeNullableFlatVector<Timestamp>(
+             {std::nullopt,
+              Timestamp::fromMillis(1639426440001),
+              Timestamp::fromMillis(1639426440002)})});
 
     raw_vector<uint64_t> ids;
     idGenerator.run(input, ids);
@@ -279,15 +367,13 @@ TEST_F(PartitionIdGeneratorTest, supportedPartitionKeyTypes) {
     auto input = makeRowVector({
         makeConstant<float>(1.0, 1),
         makeConstant<double>(1.0, 1),
-        makeConstant<Timestamp>(Timestamp::fromMillis(1639426440000), 1),
         makeArrayVector<int32_t>({{1, 2, 3}}),
         makeMapVector<int16_t, int16_t>({{{1, 2}}}),
     });
 
     for (column_index_t i = 1; i < input->childrenSize(); i++) {
       VELOX_ASSERT_THROW(
-          PartitionIdGenerator(
-              asRowType(input->type()), {i}, 100, pool(), true),
+          PartitionIdGenerator(asRowType(input->type()), {i}, 100, pool()),
           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 0021b6a56900..b70f227b41eb 100644
--- a/velox/connectors/tests/CMakeLists.txt
+++ b/velox/connectors/tests/CMakeLists.txt
@@ -20,4 +20,5 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
   glog::glog
-  Folly::folly)
+  Folly::folly
+)
diff --git a/velox/connectors/tests/ConnectorTest.cpp b/velox/connectors/tests/ConnectorTest.cpp
index 88690fdb2c75..90de53198ad1 100644
--- a/velox/connectors/tests/ConnectorTest.cpp
+++ b/velox/connectors/tests/ConnectorTest.cpp
@@ -15,15 +15,11 @@
  */
 
 #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 {
-
-class ConnectorTest : public testing::Test {};
-
 namespace {
 
 class TestConnector : public connector::Connector {
@@ -32,18 +28,15 @@ class TestConnector : public connector::Connector {
 
   std::unique_ptr<connector::DataSource> createDataSource(
       const RowTypePtr& /* outputType */,
-      const std::shared_ptr<ConnectorTableHandle>& /* tableHandle */,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& /* columnHandles */,
+      const ConnectorTableHandlePtr& /* tableHandle */,
+      const connector::ColumnHandleMap& /* columnHandles */,
       connector::ConnectorQueryCtx* connectorQueryCtx) override {
     VELOX_NYI();
   }
 
   std::unique_ptr<connector::DataSink> createDataSink(
       RowTypePtr /*inputType*/,
-      std::shared_ptr<
-          ConnectorInsertTableHandle> /*connectorInsertTableHandle*/,
+      ConnectorInsertTableHandlePtr /*connectorInsertTableHandle*/,
       ConnectorQueryCtx* /*connectorQueryCtx*/,
       CommitStrategy /*commitStrategy*/) override final {
     VELOX_NYI();
@@ -52,9 +45,7 @@ class TestConnector : public connector::Connector {
 
 class TestConnectorFactory : public connector::ConnectorFactory {
  public:
-  static constexpr const char* kConnectorFactoryName = "test-factory";
-
-  TestConnectorFactory() : ConnectorFactory(kConnectorFactoryName) {}
+  TestConnectorFactory() : ConnectorFactory("test-factory") {}
 
   std::shared_ptr<Connector> newConnector(
       const std::string& id,
@@ -65,39 +56,30 @@ class TestConnectorFactory : public connector::ConnectorFactory {
   }
 };
 
-} // namespace
+TEST(ConnectorTest, getAllConnectors) {
+  TestConnectorFactory factory;
 
-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(
-        getConnectorFactory(TestConnectorFactory::kConnectorFactoryName)
-            ->newConnector(
-                fmt::format("connector-{}", i),
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>())));
+    registerConnector(factory.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);
   for (int32_t i = 0; i < numConnectors; i++) {
     EXPECT_EQ(connectors.count(fmt::format("connector-{}", i)), 1);
   }
+
   for (int32_t i = 0; i < numConnectors; i++) {
     unregisterConnector(fmt::format("connector-{}", i));
   }
   EXPECT_EQ(getAllConnectors().size(), 0);
-  EXPECT_TRUE(
-      unregisterConnectorFactory(TestConnectorFactory::kConnectorFactoryName));
-  EXPECT_FALSE(
-      unregisterConnectorFactory(TestConnectorFactory::kConnectorFactoryName));
 }
 
-TEST_F(ConnectorTest, connectorSplit) {
+TEST(ConnectorTest, connectorSplit) {
   {
     const ConnectorSplit split("test", 100, true);
     ASSERT_EQ(split.connectorId, "test");
@@ -117,4 +99,5 @@ TEST_F(ConnectorTest, connectorSplit) {
         "[split: connector id test, weight 50, cacheable false]");
   }
 }
+} // namespace
 } // namespace facebook::velox::connector
diff --git a/velox/connectors/tpcds/CMakeLists.txt b/velox/connectors/tpcds/CMakeLists.txt
new file mode 100644
index 000000000000..4c92a290f13c
--- /dev/null
+++ b/velox/connectors/tpcds/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.
+
+velox_add_library(velox_tpcds_connector TpcdsConnector.cpp)
+velox_link_libraries(velox_tpcds_connector PUBLIC velox_connector velox_tpcds_gen PRIVATE fmt::fmt)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/connectors/tpcds/TpcdsConnector.cpp b/velox/connectors/tpcds/TpcdsConnector.cpp
new file mode 100644
index 000000000000..b981bda903ad
--- /dev/null
+++ b/velox/connectors/tpcds/TpcdsConnector.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 <fmt/format.h>
+
+#include "velox/connectors/tpcds/TpcdsConnector.h"
+#include "velox/tpcds/gen/DSDGenIterator.h"
+
+using namespace facebook::velox;
+
+namespace facebook::velox::connector::tpcds {
+
+std::string TpcdsTableHandle::toString() const {
+  return fmt::format(
+      "table: {}, scale factor: {}", toTableName(table_), scaleFactor_);
+}
+
+TpcdsDataSource::TpcdsDataSource(
+    const std::shared_ptr<const RowType>& outputType,
+    const std::shared_ptr<const velox::connector::ConnectorTableHandle>&
+        tableHandle,
+    const std::unordered_map<
+        std::string,
+        std::shared_ptr<const velox::connector::ColumnHandle>>& columnHandles,
+    velox::memory::MemoryPool* FOLLY_NONNULL pool)
+    : pool_(pool) {
+  const auto tpcdsTableHandle =
+      std::dynamic_pointer_cast<const TpcdsTableHandle>(tableHandle);
+  VELOX_CHECK_NOT_NULL(
+      tpcdsTableHandle, "TableHandle must be an instance of TpcdsTableHandle");
+  table_ = tpcdsTableHandle->getTpcdsTable();
+  scaleFactor_ = tpcdsTableHandle->getScaleFactor();
+  velox::tpcds::DSDGenIterator dsdGenIterator(scaleFactor_, 1, 1);
+  rowCount_ = dsdGenIterator.getRowCount(static_cast<int>(table_));
+
+  auto tpcdsTableSchema = getTableSchema(tpcdsTableHandle->getTpcdsTable());
+  VELOX_CHECK_NOT_NULL(tpcdsTableSchema, "TpcdsSchema can't be null.");
+
+  outputColumnMappings_.reserve(outputType->size());
+
+  for (const auto& outputName : outputType->names()) {
+    auto it = columnHandles.find(outputName);
+    VELOX_CHECK(
+        it != columnHandles.end(),
+        "ColumnHandle is missing for output column '{}' on table '{}'",
+        outputName,
+        toTableName(table_));
+
+    const auto handle =
+        std::dynamic_pointer_cast<const TpcdsColumnHandle>(it->second);
+    VELOX_CHECK_NOT_NULL(
+        handle,
+        "ColumnHandle must be an instance of TpcdsColumnHandle "
+        "for '{}' on table '{}'",
+        it->second->name(),
+        toTableName(table_));
+
+    auto idx = tpcdsTableSchema->getChildIdxIfExists(handle->name());
+    VELOX_CHECK(
+        idx != std::nullopt,
+        "Column '{}' not found on TPC-DS table '{}'.",
+        handle->name(),
+        toTableName(table_));
+    outputColumnMappings_.emplace_back(*idx);
+  }
+  outputType_ = outputType;
+}
+
+RowVectorPtr TpcdsDataSource::projectOutputColumns(RowVectorPtr inputVector) {
+  std::vector<VectorPtr> children;
+  children.reserve(outputColumnMappings_.size());
+
+  for (const auto channel : outputColumnMappings_) {
+    children.emplace_back(inputVector->childAt(channel));
+  }
+
+  return std::make_shared<RowVector>(
+      pool_,
+      outputType_,
+      BufferPtr(),
+      inputVector->size(),
+      std::move(children));
+}
+
+void TpcdsDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
+  VELOX_CHECK_EQ(
+      currentSplit_,
+      nullptr,
+      "Previous split has not been processed yet. Call next() to process the split.");
+  currentSplit_ = std::dynamic_pointer_cast<tpcds::TpcdsConnectorSplit>(split);
+  VELOX_CHECK(currentSplit_, "Wrong type of split for TpcdsDataSource.");
+
+  size_t partSize = std::ceil(
+      static_cast<double>(rowCount_) /
+      static_cast<double>(currentSplit_->totalParts_));
+
+  splitOffset_ = partSize * currentSplit_->partNumber_;
+  splitEnd_ = splitOffset_ + partSize;
+}
+
+std::optional<RowVectorPtr> TpcdsDataSource::next(
+    uint64_t size,
+    velox::ContinueFuture& /*future*/) {
+  VELOX_CHECK_NOT_NULL(
+      currentSplit_, "No split to process. Call addSplit() first.");
+
+  size_t maxRows = std::min(size, (splitEnd_ - splitOffset_));
+  vector_size_t parallel = currentSplit_->totalParts_;
+  vector_size_t child = currentSplit_->partNumber_;
+  auto outputVector = genTpcdsData(
+      table_, maxRows, splitOffset_, pool_, scaleFactor_, parallel, child);
+
+  // If the split is exhausted.
+  if (!outputVector || outputVector->size() == 0) {
+    currentSplit_ = nullptr;
+    return nullptr;
+  }
+
+  // splitOffset needs to advance based on maxRows passed to getTpcdsData(), and
+  // not the actual number of returned rows in the output vector, as they are
+  // not the same for lineitem.
+  splitOffset_ += maxRows;
+  completedRows_ += outputVector->size();
+  completedBytes_ += outputVector->retainedSize();
+
+  return projectOutputColumns(outputVector);
+}
+} // namespace facebook::velox::connector::tpcds
diff --git a/velox/connectors/tpcds/TpcdsConnector.h b/velox/connectors/tpcds/TpcdsConnector.h
new file mode 100644
index 000000000000..329114d90057
--- /dev/null
+++ b/velox/connectors/tpcds/TpcdsConnector.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/tpcds/TpcdsConnectorSplit.h"
+#include "velox/tpcds/gen/TpcdsGen.h"
+
+namespace facebook::velox::connector::tpcds {
+
+class TpcdsConnector;
+
+// TPC-DS column handle only needs the column name (all columns are generated in
+// the same way).
+class TpcdsColumnHandle : public velox::connector::ColumnHandle {
+ public:
+  explicit TpcdsColumnHandle(const std::string& name) : name_(name) {}
+
+  const std::string& name() const {
+    return name_;
+  }
+
+ private:
+  const std::string name_;
+};
+
+// TPC-DS table handle uses the underlying enum to describe the target table.
+class TpcdsTableHandle : public ConnectorTableHandle {
+ public:
+  explicit TpcdsTableHandle(
+      std::string connectorId,
+      velox::tpcds::Table table,
+      double scaleFactor = 0.01)
+      : ConnectorTableHandle(std::move(connectorId)),
+        table_(table),
+        name_(toTableName(table)),
+        scaleFactor_(scaleFactor) {
+    VELOX_CHECK_GT(scaleFactor, 0.0, "Tpcds scale factor must be non-negative");
+  }
+
+  const std::string& name() const override {
+    return name_;
+  }
+
+  std::string toString() const override;
+
+  velox::tpcds::Table getTpcdsTable() const {
+    return table_;
+  }
+
+  double getScaleFactor() const {
+    return scaleFactor_;
+  }
+
+ private:
+  const velox::tpcds::Table table_;
+  const std::string name_;
+  const double scaleFactor_;
+};
+
+class TpcdsDataSource : public velox::connector::DataSource {
+ public:
+  TpcdsDataSource(
+      const std::shared_ptr<const RowType>& outputType,
+      const std::shared_ptr<const velox::connector::ConnectorTableHandle>&
+          tableHandle,
+      const std::unordered_map<
+          std::string,
+          std::shared_ptr<const velox::connector::ColumnHandle>>& columnHandles,
+      velox::memory::MemoryPool* FOLLY_NONNULL pool);
+
+  void addSplit(std::shared_ptr<ConnectorSplit> split) override;
+
+  void addDynamicFilter(
+      column_index_t /*outputChannel*/,
+      const std::shared_ptr<common::Filter>& /*filter*/) override {
+    VELOX_NYI("Dynamic filters not supported by TpcdsConnector.");
+  }
+
+  std::optional<RowVectorPtr> next(uint64_t size, velox::ContinueFuture& future)
+      override;
+
+  uint64_t getCompletedRows() override {
+    return completedRows_;
+  }
+
+  uint64_t getCompletedBytes() override {
+    return completedBytes_;
+  }
+
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
+    return {};
+  }
+
+ private:
+  RowVectorPtr projectOutputColumns(RowVectorPtr vector);
+
+  velox::tpcds::Table table_;
+  double scaleFactor_{0.01};
+  size_t rowCount_{0};
+  RowTypePtr outputType_;
+
+  // Mapping between output columns and their indices (column_index_t) in the
+  // dsdgen generated datasets.
+  std::vector<column_index_t> outputColumnMappings_;
+
+  std::shared_ptr<connector::tpcds::TpcdsConnectorSplit> currentSplit_;
+
+  // Offset of the first row in current split.
+  uint64_t splitOffset_{0};
+  // Offset of the last row in current split.
+  uint64_t splitEnd_{0};
+
+  size_t completedRows_{0};
+  size_t completedBytes_{0};
+
+  memory::MemoryPool* FOLLY_NONNULL pool_;
+};
+
+class TpcdsConnector final : public velox::connector::Connector {
+ public:
+  TpcdsConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* FOLLY_NULLABLE /*executor*/)
+      : Connector(id) {}
+
+  std::unique_ptr<DataSource> createDataSource(
+      const std::shared_ptr<const RowType>& outputType,
+      const std::shared_ptr<const ConnectorTableHandle>& tableHandle,
+      const std::unordered_map<
+          std::string,
+          std::shared_ptr<const velox::connector::ColumnHandle>>& columnHandles,
+      ConnectorQueryCtx* FOLLY_NONNULL connectorQueryCtx) override final {
+    return std::make_unique<TpcdsDataSource>(
+        outputType,
+        tableHandle,
+        columnHandles,
+        connectorQueryCtx->memoryPool());
+  }
+
+  std::unique_ptr<DataSink> createDataSink(
+      RowTypePtr /*inputType*/,
+      std::shared_ptr<
+          const ConnectorInsertTableHandle> /*connectorInsertTableHandle*/,
+      ConnectorQueryCtx* /*connectorQueryCtx*/,
+      CommitStrategy /*commitStrategy*/) override final {
+    VELOX_NYI("TpcdsConnector does not support data sink.");
+  }
+};
+
+class TpcdsConnectorFactory : public ConnectorFactory {
+ public:
+  static constexpr const char* kTpcdsConnectorName{"tpcds"};
+
+  TpcdsConnectorFactory() : ConnectorFactory(kTpcdsConnectorName) {}
+
+  explicit TpcdsConnectorFactory(const char* connectorName)
+      : ConnectorFactory(connectorName) {}
+
+  std::shared_ptr<Connector> newConnector(
+      const std::string& id,
+      std::shared_ptr<const config::ConfigBase> config,
+      folly::Executor* ioExecutor = nullptr,
+      folly::Executor* cpuExecutor = nullptr) override {
+    return std::make_shared<TpcdsConnector>(id, config, ioExecutor);
+  }
+};
+
+} // namespace facebook::velox::connector::tpcds
diff --git a/velox/connectors/tpcds/TpcdsConnectorSplit.h b/velox/connectors/tpcds/TpcdsConnectorSplit.h
new file mode 100644
index 000000000000..80fb8863e76a
--- /dev/null
+++ b/velox/connectors/tpcds/TpcdsConnectorSplit.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 <fmt/format.h>
+#include "velox/connectors/Connector.h"
+
+namespace facebook::velox::connector::tpcds {
+
+struct TpcdsConnectorSplit : public velox::connector::ConnectorSplit {
+  explicit TpcdsConnectorSplit(
+      const std::string& connectorId,
+      size_t totalParts,
+      size_t partNumber)
+      : TpcdsConnectorSplit(connectorId, true, totalParts, partNumber) {}
+
+  TpcdsConnectorSplit(
+      const std::string& connectorId,
+      bool cacheable,
+      size_t totalParts,
+      size_t partNumber)
+      : ConnectorSplit(connectorId, /*splitWeight=*/0, cacheable),
+        totalParts_(totalParts),
+        partNumber_(partNumber) {
+    VELOX_CHECK_GE(totalParts, 1, "totalParts must be >= 1");
+    VELOX_CHECK_GT(totalParts, partNumber, "totalParts must be > partNumber");
+  }
+
+  // In how many parts the generated TPC-DS table will be segmented, roughly
+  // `rowCount / totalParts`
+  const vector_size_t totalParts_{1};
+
+  // Which of these parts will be read by this split.
+  const vector_size_t partNumber_{0};
+};
+
+} // namespace facebook::velox::connector::tpcds
+
+template <>
+struct fmt::formatter<facebook::velox::connector::tpcds::TpcdsConnectorSplit>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::connector::tpcds::TpcdsConnectorSplit const& s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(s.toString(), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<
+    std::shared_ptr<facebook::velox::connector::tpcds::TpcdsConnectorSplit>>
+    : formatter<std::string> {
+  auto format(
+      std::shared_ptr<
+          facebook::velox::connector::tpcds::TpcdsConnectorSplit> const& s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(s->toString(), ctx);
+  }
+};
diff --git a/velox/runner/tests/CMakeLists.txt b/velox/connectors/tpcds/tests/CMakeLists.txt
similarity index 71%
rename from velox/runner/tests/CMakeLists.txt
rename to velox/connectors/tpcds/tests/CMakeLists.txt
index 863f572fa828..e214822539c5 100644
--- a/velox/runner/tests/CMakeLists.txt
+++ b/velox/connectors/tpcds/tests/CMakeLists.txt
@@ -11,15 +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_executable(velox_tpcds_connector_test TpcdsConnectorTest.cpp)
 
-add_executable(velox_local_runner_test LocalRunnerTest.cpp Main.cpp)
-
-add_test(velox_local_runner_test velox_local_runner_test)
+add_test(velox_tpcds_connector_test velox_tpcds_connector_test)
 
 target_link_libraries(
-  velox_local_runner_test
-  velox_exec_runner_test_util
+  velox_tpcds_connector_test
+  velox_tpcds_connector
+  velox_vector_test_lib
   velox_exec_test_lib
-  velox_parse_parser
-  velox_parse_expression
-  GTest::gtest)
+  velox_aggregates
+  GTest::gtest
+  GTest::gtest_main
+)
diff --git a/velox/connectors/tpcds/tests/TpcdsConnectorTest.cpp b/velox/connectors/tpcds/tests/TpcdsConnectorTest.cpp
new file mode 100644
index 000000000000..67462ec7ca9d
--- /dev/null
+++ b/velox/connectors/tpcds/tests/TpcdsConnectorTest.cpp
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/tpcds/TpcdsConnector.h"
+#include <folly/init/Init.h>
+#include "gtest/gtest.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::connector::tpcds::test {
+
+namespace {
+class TpcdsConnectorTest : public exec::test::OperatorTestBase {
+ public:
+  const std::string kTpcdsConnectorId = "test-tpcds";
+
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    connector::tpcds::TpcdsConnectorFactory factory;
+    auto connector = factory.newConnector(
+        kTpcdsConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
+    connector::registerConnector(connector);
+  }
+
+  void TearDown() override {
+    connector::unregisterConnector(kTpcdsConnectorId);
+    OperatorTestBase::TearDown();
+  }
+
+  exec::Split makeTpcdsSplit(size_t totalParts = 1, size_t partNumber = 0)
+      const {
+    return exec::Split(
+        std::make_shared<TpcdsConnectorSplit>(
+            kTpcdsConnectorId, /*cacheable=*/true, totalParts, partNumber));
+  }
+
+  RowVectorPtr getResults(
+      const core::PlanNodePtr& planNode,
+      std::vector<exec::Split>&& splits) {
+    return exec::test::AssertQueryBuilder(planNode)
+        .splits(std::move(splits))
+        .copyResults(pool());
+  }
+};
+
+// Simple scan of first 5 rows of table 'warehouse'.
+TEST_F(TpcdsConnectorTest, simple) {
+  auto plan =
+      exec::test::PlanBuilder()
+          .tpcdsTableScan(
+              velox::tpcds::Table::TBL_WAREHOUSE,
+              {"w_warehouse_sk", "w_warehouse_name", "w_city", "w_state"},
+              1)
+          .limit(0, 5, false)
+          .planNode();
+
+  auto output = getResults(plan, {makeTpcdsSplit()});
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+      makeNullableFlatVector<StringView>(
+          {"Conventional childr",
+           "Important issues liv",
+           "Doors canno",
+           "Bad cards must make.",
+           std::nullopt}),
+      makeConstant<StringView>("Fairview", 5),
+      makeConstant<StringView>("TN", 5),
+  });
+  velox::test::assertEqualVectors(expected, output);
+}
+
+// Extract single column from table 'store'.
+TEST_F(TpcdsConnectorTest, singleColumn) {
+  auto plan =
+      exec::test::PlanBuilder()
+          .tpcdsTableScan(velox::tpcds::Table::TBL_STORE, {"s_store_name"}, 1)
+          .planNode();
+
+  auto output = getResults(plan, {makeTpcdsSplit()});
+  auto expected = makeRowVector({makeFlatVector<StringView>({
+      "ought",
+      "able",
+      "able",
+      "ese",
+      "anti",
+      "cally",
+      "ation",
+      "eing",
+      "eing",
+      "bar",
+      "ought",
+      "ought",
+  })});
+  velox::test::assertEqualVectors(expected, output);
+  EXPECT_EQ("s_store_name", output->type()->asRow().nameOf(0));
+}
+
+// Check that aliases are correctly resolved.
+TEST_F(TpcdsConnectorTest, singleColumnWithAlias) {
+  const std::string aliasedName = "my_aliased_column_name";
+
+  auto outputType = ROW({aliasedName}, {VARCHAR()});
+  auto plan = exec::test::PlanBuilder()
+                  .startTableScan()
+                  .outputType(outputType)
+                  .tableHandle(
+                      std::make_shared<TpcdsTableHandle>(
+                          kTpcdsConnectorId, velox::tpcds::Table::TBL_ITEM))
+                  .assignments({
+                      {aliasedName,
+                       std::make_shared<TpcdsColumnHandle>("i_product_name")},
+                      {"other_name",
+                       std::make_shared<TpcdsColumnHandle>("i_product_name")},
+                      {"third_column",
+                       std::make_shared<TpcdsColumnHandle>("i_manager_id")},
+                  })
+                  .endTableScan()
+                  .limit(0, 1, false)
+                  .planNode();
+
+  auto output = getResults(plan, {makeTpcdsSplit()});
+  auto expected = makeRowVector({makeFlatVector<StringView>({
+      "ought",
+  })});
+  velox::test::assertEqualVectors(expected, output);
+
+  EXPECT_EQ(aliasedName, output->type()->asRow().nameOf(0));
+  EXPECT_EQ(1, output->childrenSize());
+}
+
+TEST_F(TpcdsConnectorTest, unknownColumn) {
+  EXPECT_THROW(
+      {
+        exec::test::PlanBuilder()
+            .tpcdsTableScan(velox::tpcds::Table::TBL_ITEM, {"invalid_column"})
+            .planNode();
+      },
+      VeloxUserError);
+}
+
+// Join warehouse and store on state.
+TEST_F(TpcdsConnectorTest, join) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId itemScanId;
+  core::PlanNodeId inventoryScanId;
+  auto plan = exec::test::PlanBuilder(planNodeIdGenerator)
+                  .tpcdsTableScan(
+                      velox::tpcds::Table::TBL_WAREHOUSE,
+                      {"w_warehouse_id", "w_state"},
+                      1)
+                  .capturePlanNodeId(itemScanId)
+                  .hashJoin(
+                      {"w_state"},
+                      {"s_state"},
+                      exec::test::PlanBuilder(planNodeIdGenerator)
+                          .tpcdsTableScan(
+                              velox::tpcds::Table::TBL_STORE, {"s_state"}, 1)
+                          .capturePlanNodeId(inventoryScanId)
+                          .planNode(),
+                      "",
+                      {"w_warehouse_id"})
+                  // Get distinct values of warehouse_id
+                  .partialAggregation({"w_warehouse_id"}, {})
+                  .finalAggregation()
+                  .orderBy({"w_warehouse_id"}, false)
+                  .planNode();
+
+  auto output = exec::test::AssertQueryBuilder(plan)
+                    .split(itemScanId, makeTpcdsSplit())
+                    .split(inventoryScanId, makeTpcdsSplit())
+                    .copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeFlatVector<StringView>(
+          {"AAAAAAAABAAAAAAA",
+           "AAAAAAAACAAAAAAA",
+           "AAAAAAAADAAAAAAA",
+           "AAAAAAAAEAAAAAAA",
+           "AAAAAAAAFAAAAAAA"}),
+  });
+  velox::test::assertEqualVectors(expected, output);
+}
+
+TEST_F(TpcdsConnectorTest, inventoryDateCount) {
+  auto plan =
+      exec::test::PlanBuilder()
+          .tpcdsTableScan(
+              velox::tpcds::Table::TBL_WEB_SITE, {"web_rec_start_date"}, 1)
+          .filter("web_rec_start_date = '1997-08-16'::DATE")
+          .limit(0, 10, false)
+          .planNode();
+
+  auto output = getResults(plan, {makeTpcdsSplit()});
+  auto inventoryDate = output->childAt(0)->asFlatVector<int32_t>();
+  EXPECT_EQ("1997-08-16", DATE()->toString(inventoryDate->valueAt(0)));
+  EXPECT_EQ(10, inventoryDate->size());
+}
+} // namespace
+} // namespace facebook::velox::connector::tpcds::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/connectors/tpch/CMakeLists.txt b/velox/connectors/tpch/CMakeLists.txt
index b8373349e7d0..43ebe514b283 100644
--- a/velox/connectors/tpch/CMakeLists.txt
+++ b/velox/connectors/tpch/CMakeLists.txt
@@ -14,8 +14,16 @@
 
 velox_add_library(velox_tpch_connector OBJECT TpchConnector.cpp)
 
-velox_link_libraries(velox_tpch_connector velox_connector velox_tpch_gen
-                     fmt::fmt)
+velox_link_libraries(
+  velox_tpch_connector
+  velox_connector
+  velox_tpch_gen
+  velox_core
+  velox_exec
+  velox_expression
+  velox_vector
+  fmt::fmt
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/connectors/tpch/TpchConnector.cpp b/velox/connectors/tpch/TpchConnector.cpp
index b2317774fe74..cf70061aada3 100644
--- a/velox/connectors/tpch/TpchConnector.cpp
+++ b/velox/connectors/tpch/TpchConnector.cpp
@@ -15,12 +15,20 @@
  */
 
 #include "velox/connectors/tpch/TpchConnector.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/expression/Expr.h"
 #include "velox/tpch/gen/TpchGen.h"
 
 namespace facebook::velox::connector::tpch {
 
 using facebook::velox::tpch::Table;
 
+TpchConnector::TpchConnector(
+    const std::string& id,
+    std::shared_ptr<const config::ConfigBase> config,
+    folly::Executor* /*executor*/)
+    : Connector(id, std::move(config)) {}
+
 namespace {
 
 RowVectorPtr getTpchData(
@@ -53,20 +61,23 @@ RowVectorPtr getTpchData(
 } // namespace
 
 std::string TpchTableHandle::toString() const {
-  return fmt::format(
-      "table: {}, scale factor: {}", toTableName(table_), scaleFactor_);
+  std::stringstream out;
+  out << "table: " << toTableName(table_) << ", scale factor: " << scaleFactor_;
+  if (filterExpression_ != nullptr) {
+    out << ", filter: " << filterExpression_->toString();
+  }
+  return out.str();
 }
 
 TpchDataSource::TpchDataSource(
-    const std::shared_ptr<const RowType>& outputType,
-    const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& columnHandles,
-    velox::memory::MemoryPool* pool)
-    : pool_(pool) {
+    const RowTypePtr& outputType,
+    const connector::ConnectorTableHandlePtr& tableHandle,
+    const connector::ColumnHandleMap& columnHandles,
+    ConnectorQueryCtx* connectorQueryCtx)
+    : connectorQueryCtx_(connectorQueryCtx),
+      pool_(connectorQueryCtx->memoryPool()) {
   auto tpchTableHandle =
-      std::dynamic_pointer_cast<TpchTableHandle>(tableHandle);
+      std::dynamic_pointer_cast<const TpchTableHandle>(tableHandle);
   VELOX_CHECK_NOT_NULL(
       tpchTableHandle, "TableHandle must be an instance of TpchTableHandle");
   tpchTable_ = tpchTableHandle->getTable();
@@ -77,7 +88,6 @@ TpchDataSource::TpchDataSource(
   VELOX_CHECK_NOT_NULL(tpchTableSchema, "TpchSchema can't be null.");
 
   outputColumnMappings_.reserve(outputType->size());
-
   for (const auto& outputName : outputType->names()) {
     auto it = columnHandles.find(outputName);
     VELOX_CHECK(
@@ -86,7 +96,7 @@ TpchDataSource::TpchDataSource(
         outputName,
         toTableName(tpchTable_));
 
-    auto handle = std::dynamic_pointer_cast<TpchColumnHandle>(it->second);
+    auto handle = std::dynamic_pointer_cast<const TpchColumnHandle>(it->second);
     VELOX_CHECK_NOT_NULL(
         handle,
         "ColumnHandle must be an instance of TpchColumnHandle "
@@ -103,6 +113,11 @@ TpchDataSource::TpchDataSource(
     outputColumnMappings_.emplace_back(*idx);
   }
   outputType_ = outputType;
+
+  if (tpchTableHandle->filterExpression()) {
+    filterExpression_ = connectorQueryCtx_->expressionEvaluator()->compile(
+        tpchTableHandle->filterExpression());
+  }
 }
 
 RowVectorPtr TpchDataSource::projectOutputColumns(RowVectorPtr inputVector) {
@@ -143,6 +158,55 @@ void TpchDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
   splitEnd_ = splitOffset_ + partSize;
 }
 
+RowVectorPtr TpchDataSource::applyFilter(
+    RowVectorPtr& vector,
+    exec::ExprSet* filter) {
+  if (!filter) {
+    return projectOutputColumns(vector);
+  }
+
+  filterSelectivityVector_.resize(vector->size());
+  filterSelectivityVector_.setAll();
+  filterEvalCtx_.selectedIndices =
+      allocateIndices(vector->size(), vector->pool());
+
+  if (!filterMask_ || filterMask_->size() < vector->size()) {
+    filterMask_ = BaseVector::create(BOOLEAN(), vector->size(), pool_);
+  }
+  connectorQueryCtx_->expressionEvaluator()->evaluate(
+      filter, filterSelectivityVector_, *vector, filterMask_);
+
+  auto filterResults = filterMask_->as<SimpleVector<bool>>();
+  filterSelectivityVector_.applyToSelected([&](vector_size_t row) {
+    if (filterResults->isNullAt(row) || !filterResults->valueAt(row)) {
+      filterSelectivityVector_.setValid(row, false);
+    }
+  });
+  filterSelectivityVector_.updateBounds();
+
+  if (filterSelectivityVector_.isAllSelected()) {
+    return projectOutputColumns(vector);
+  }
+
+  auto* selected = filterEvalCtx_.getRawSelectedIndices(
+      filterSelectivityVector_.size(), pool_);
+  vector_size_t remaining = 0;
+  filterSelectivityVector_.applyToSelected(
+      [&selected, &remaining](int32_t row) { selected[remaining++] = row; });
+
+  std::vector<VectorPtr> children;
+  children.reserve(outputType_->size());
+  for (int i = 0; i < outputType_->size(); ++i) {
+    auto& child = vector->childAt(outputColumnMappings_[i]);
+    children.emplace_back(
+        exec::wrapChild(remaining, filterEvalCtx_.selectedIndices, child));
+  }
+
+  filterEvalCtx_.selectedIndices.reset();
+  return std::make_shared<RowVector>(
+      vector->pool(), outputType_, BufferPtr(), remaining, std::move(children));
+}
+
 std::optional<RowVectorPtr> TpchDataSource::next(
     uint64_t size,
     velox::ContinueFuture& /*future*/) {
@@ -175,7 +239,8 @@ std::optional<RowVectorPtr> TpchDataSource::next(
   completedRows_ += outputVector->size();
   completedBytes_ += outputVector->retainedSize();
 
-  return projectOutputColumns(outputVector);
+  // Apply any filters pushed down into the DataSource
+  return applyFilter(outputVector, filterExpression_.get());
 }
 
 bool TpchDataSource::isLineItem() const {
diff --git a/velox/connectors/tpch/TpchConnector.h b/velox/connectors/tpch/TpchConnector.h
index 64fc4abf1be0..1ec4aad0a551 100644
--- a/velox/connectors/tpch/TpchConnector.h
+++ b/velox/connectors/tpch/TpchConnector.h
@@ -18,7 +18,11 @@
 #include "velox/common/config/Config.h"
 #include "velox/connectors/Connector.h"
 #include "velox/connectors/tpch/TpchConnectorSplit.h"
+#include "velox/core/ITypedExpr.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/expression/Expr.h"
 #include "velox/tpch/gen/TpchGen.h"
+#include "velox/vector/BaseVector.h"
 
 namespace facebook::velox::connector::tpch {
 
@@ -44,21 +48,37 @@ class TpchTableHandle : public ConnectorTableHandle {
   explicit TpchTableHandle(
       std::string connectorId,
       velox::tpch::Table table,
-      double scaleFactor = 1.0)
+      double scaleFactor = 1.0,
+      velox::core::TypedExprPtr filterExpression = nullptr)
       : ConnectorTableHandle(std::move(connectorId)),
         table_(table),
-        scaleFactor_(scaleFactor) {
+        scaleFactor_(scaleFactor),
+        filterExpression_(std::move(filterExpression)) {
     VELOX_CHECK_GE(scaleFactor, 0, "Tpch scale factor must be non-negative");
+    auto sf = static_cast<int>(scaleFactor_);
+    if (sf > 0) {
+      name_ = fmt::format("sf{}.{}", sf, velox::tpch::toTableName(table));
+    } else {
+      name_ = fmt::format("tiny.{}", velox::tpch::toTableName(table));
+    }
   }
 
   ~TpchTableHandle() override {}
 
   std::string toString() const override;
 
+  const std::string& name() const override {
+    return name_;
+  }
+
   velox::tpch::Table getTable() const {
     return table_;
   }
 
+  const velox::core::TypedExprPtr& filterExpression() const {
+    return filterExpression_;
+  }
+
   double getScaleFactor() const {
     return scaleFactor_;
   }
@@ -66,17 +86,17 @@ class TpchTableHandle : public ConnectorTableHandle {
  private:
   const velox::tpch::Table table_;
   double scaleFactor_;
+  std::string name_;
+  const velox::core::TypedExprPtr filterExpression_;
 };
 
 class TpchDataSource : public DataSource {
  public:
   TpchDataSource(
-      const std::shared_ptr<const RowType>& outputType,
-      const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
-      velox::memory::MemoryPool* pool);
+      const RowTypePtr& outputType,
+      const connector::ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& columnHandles,
+      ConnectorQueryCtx* connectorQueryCtx);
 
   void addSplit(std::shared_ptr<ConnectorSplit> split) override;
 
@@ -97,7 +117,7 @@ class TpchDataSource : public DataSource {
     return completedBytes_;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
     // TODO: Which stats do we want to expose here?
     return {};
   }
@@ -106,6 +126,7 @@ class TpchDataSource : public DataSource {
   bool isLineItem() const;
 
   RowVectorPtr projectOutputColumns(RowVectorPtr vector);
+  RowVectorPtr applyFilter(RowVectorPtr& vector, exec::ExprSet* filter);
 
   velox::tpch::Table tpchTable_;
   double scaleFactor_{1.0};
@@ -126,6 +147,12 @@ class TpchDataSource : public DataSource {
   size_t completedRows_{0};
   size_t completedBytes_{0};
 
+  SelectivityVector filterSelectivityVector_;
+  exec::FilterEvalCtx filterEvalCtx_;
+  std::shared_ptr<BaseVector> filterMask_;
+  std::unique_ptr<exec::ExprSet> filterExpression_;
+
+  ConnectorQueryCtx* connectorQueryCtx_;
   memory::MemoryPool* pool_;
 };
 
@@ -134,27 +161,20 @@ class TpchConnector final : public Connector {
   TpchConnector(
       const std::string& id,
       std::shared_ptr<const config::ConfigBase> config,
-      folly::Executor* /*executor*/)
-      : Connector(id) {}
+      folly::Executor* /*executor*/);
 
   std::unique_ptr<DataSource> createDataSource(
-      const std::shared_ptr<const RowType>& outputType,
-      const std::shared_ptr<ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& columnHandles,
       ConnectorQueryCtx* connectorQueryCtx) override final {
     return std::make_unique<TpchDataSource>(
-        outputType,
-        tableHandle,
-        columnHandles,
-        connectorQueryCtx->memoryPool());
+        outputType, tableHandle, columnHandles, connectorQueryCtx);
   }
 
   std::unique_ptr<DataSink> createDataSink(
       RowTypePtr /*inputType*/,
-      std::shared_ptr<
-          ConnectorInsertTableHandle> /*connectorInsertTableHandle*/,
+      ConnectorInsertTableHandlePtr /*connectorInsertTableHandle*/,
       ConnectorQueryCtx* /*connectorQueryCtx*/,
       CommitStrategy /*commitStrategy*/) override final {
     VELOX_NYI("TpchConnector does not support data sink.");
diff --git a/velox/connectors/tpch/TpchConnectorSplit.h b/velox/connectors/tpch/TpchConnectorSplit.h
index bfb112db5619..b4b5420d1f92 100644
--- a/velox/connectors/tpch/TpchConnectorSplit.h
+++ b/velox/connectors/tpch/TpchConnectorSplit.h
@@ -32,7 +32,7 @@ struct TpchConnectorSplit : public connector::ConnectorSplit {
       bool cacheable,
       size_t totalParts,
       size_t partNumber)
-      : ConnectorSplit(connectorId, /*splitWeight=*/0, cacheable),
+      : ConnectorSplit(connectorId, /*_splitWeight=*/0, cacheable),
         totalParts(totalParts),
         partNumber(partNumber) {
     VELOX_CHECK_GE(totalParts, 1, "totalParts must be >= 1");
diff --git a/velox/connectors/tpch/tests/CMakeLists.txt b/velox/connectors/tpch/tests/CMakeLists.txt
index 5474de3cfa90..eb4f27185160 100644
--- a/velox/connectors/tpch/tests/CMakeLists.txt
+++ b/velox/connectors/tpch/tests/CMakeLists.txt
@@ -22,7 +22,8 @@ target_link_libraries(
   velox_exec_test_lib
   velox_aggregates
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_tpch_speed_test SpeedTest.cpp)
 
@@ -32,4 +33,5 @@ target_link_libraries(
   velox_exec
   velox_exec_test_lib
   velox_memory
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/connectors/tpch/tests/SpeedTest.cpp b/velox/connectors/tpch/tests/SpeedTest.cpp
index 0e8216260a90..e3a55e53aaad 100644
--- a/velox/connectors/tpch/tests/SpeedTest.cpp
+++ b/velox/connectors/tpch/tests/SpeedTest.cpp
@@ -56,22 +56,16 @@ using std::chrono::system_clock;
 class TpchSpeedTest {
  public:
   TpchSpeedTest() {
-    connector::registerConnectorFactory(
-        std::make_shared<connector::tpch::TpchConnectorFactory>());
-    auto tpchConnector =
-        connector::getConnectorFactory(
-            connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(
-                kTpchConnectorId_,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()));
+    connector::tpch::TpchConnectorFactory factory;
+    auto tpchConnector = factory.newConnector(
+        kTpchConnectorId_,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
     connector::registerConnector(tpchConnector);
   }
 
   ~TpchSpeedTest() {
     connector::unregisterConnector(kTpchConnectorId_);
-    connector::unregisterConnectorFactory(
-        connector::tpch::TpchConnectorFactory::kTpchConnectorName);
   }
 
   void run(tpch::Table table, size_t scaleFactor, size_t numSplits) {
@@ -123,8 +117,9 @@ class TpchSpeedTest {
     for (size_t i = 0; i < numSplits; ++i) {
       task.addSplit(
           scanId,
-          exec::Split(std::make_shared<connector::tpch::TpchConnectorSplit>(
-              kTpchConnectorId_, /*cacheable=*/true, numSplits, i)));
+          exec::Split(
+              std::make_shared<connector::tpch::TpchConnectorSplit>(
+                  kTpchConnectorId_, /*cacheable=*/true, numSplits, i)));
     }
 
     task.noMoreSplits(scanId);
diff --git a/velox/connectors/tpch/tests/TpchConnectorTest.cpp b/velox/connectors/tpch/tests/TpchConnectorTest.cpp
index 65d0a1e09bce..1ccd9017b318 100644
--- a/velox/connectors/tpch/tests/TpchConnectorTest.cpp
+++ b/velox/connectors/tpch/tests/TpchConnectorTest.cpp
@@ -39,29 +39,24 @@ class TpchConnectorTest : public exec::test::OperatorTestBase {
   void SetUp() override {
     FLAGS_velox_tpch_text_pool_size_mb = 10;
     OperatorTestBase::SetUp();
-    connector::registerConnectorFactory(
-        std::make_shared<connector::tpch::TpchConnectorFactory>());
-    auto tpchConnector =
-        connector::getConnectorFactory(
-            connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(
-                kTpchConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()));
+    connector::tpch::TpchConnectorFactory factory;
+    auto tpchConnector = factory.newConnector(
+        kTpchConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
     connector::registerConnector(tpchConnector);
   }
 
   void TearDown() override {
     connector::unregisterConnector(kTpchConnectorId);
-    connector::unregisterConnectorFactory(
-        connector::tpch::TpchConnectorFactory::kTpchConnectorName);
     OperatorTestBase::TearDown();
   }
 
   exec::Split makeTpchSplit(size_t totalParts = 1, size_t partNumber = 0)
       const {
-    return exec::Split(std::make_shared<TpchConnectorSplit>(
-        kTpchConnectorId, /*cacheable=*/true, totalParts, partNumber));
+    return exec::Split(
+        std::make_shared<TpchConnectorSplit>(
+            kTpchConnectorId, /*cacheable=*/true, totalParts, partNumber));
   }
 
   RowVectorPtr getResults(
@@ -138,8 +133,9 @@ TEST_F(TpchConnectorTest, singleColumnWithAlias) {
       PlanBuilder()
           .startTableScan()
           .outputType(outputType)
-          .tableHandle(std::make_shared<TpchTableHandle>(
-              kTpchConnectorId, Table::TBL_NATION))
+          .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")},
@@ -164,8 +160,9 @@ void TpchConnectorTest::runScaleFactorTest(double scaleFactor) {
   auto plan = PlanBuilder()
                   .startTableScan()
                   .outputType(ROW({}, {}))
-                  .tableHandle(std::make_shared<TpchTableHandle>(
-                      kTpchConnectorId, Table::TBL_SUPPLIER, scaleFactor))
+                  .tableHandle(
+                      std::make_shared<TpchTableHandle>(
+                          kTpchConnectorId, Table::TBL_SUPPLIER, scaleFactor))
                   .endTableScan()
                   .singleAggregation({}, {"count(1)"})
                   .planNode();
@@ -193,8 +190,9 @@ TEST_F(TpchConnectorTest, lineitemTinyRowCount) {
   auto plan = PlanBuilder()
                   .startTableScan()
                   .outputType(ROW({}, {}))
-                  .tableHandle(std::make_shared<TpchTableHandle>(
-                      kTpchConnectorId, Table::TBL_LINEITEM, 0.01))
+                  .tableHandle(
+                      std::make_shared<TpchTableHandle>(
+                          kTpchConnectorId, Table::TBL_LINEITEM, 0.01))
                   .endTableScan()
                   .singleAggregation({}, {"count(1)"})
                   .planNode();
@@ -249,6 +247,147 @@ TEST_F(TpchConnectorTest, multipleSplits) {
   }
 }
 
+// Test filtering in the TpchConnector.
+TEST_F(TpchConnectorTest, filterPushdown) {
+  // Test equality filter
+  auto plan = PlanBuilder(pool())
+                  .tpchTableScan(
+                      Table::TBL_NATION,
+                      {"n_nationkey", "n_name", "n_regionkey"},
+                      1.0,
+                      kTpchConnectorId,
+                      "n_regionkey = 1")
+                  .planNode();
+
+  auto output = getResults(plan, {makeTpchSplit()});
+
+  // Should only return nations with regionkey = 1
+  auto expected = makeRowVector({
+      // n_nationkey
+      makeFlatVector<int64_t>({1, 2, 3, 17, 24}),
+      // n_name
+      makeFlatVector<StringView>({
+          "ARGENTINA",
+          "BRAZIL",
+          "CANADA",
+          "PERU",
+          "UNITED STATES",
+      }),
+      // n_regionkey
+      makeFlatVector<int64_t>({1, 1, 1, 1, 1}),
+  });
+  test::assertEqualVectors(expected, output);
+}
+
+// Test more complex filters in the TpchConnector.
+TEST_F(TpchConnectorTest, complexFilterPushdown) {
+  // Test range filter
+  auto plan = PlanBuilder(pool())
+                  .tpchTableScan(
+                      Table::TBL_NATION,
+                      {"n_nationkey", "n_name", "n_regionkey"},
+                      1.0,
+                      kTpchConnectorId,
+                      "n_nationkey < 5 AND n_regionkey > 0")
+                  .planNode();
+
+  auto output = getResults(plan, {makeTpchSplit()});
+
+  // Should only return nations with nationkey < 5 AND regionkey > 0
+  auto expected = makeRowVector({
+      // n_nationkey
+      makeFlatVector<int64_t>({1, 2, 3, 4}),
+      // n_name
+      makeFlatVector<StringView>({
+          "ARGENTINA",
+          "BRAZIL",
+          "CANADA",
+          "EGYPT",
+      }),
+      // n_regionkey
+      makeFlatVector<int64_t>({1, 1, 1, 4}),
+  });
+  test::assertEqualVectors(expected, output);
+}
+
+// Test filtering with LIKE operator
+TEST_F(TpchConnectorTest, likeFilterPushdown) {
+  // Test LIKE filter
+  auto plan = PlanBuilder(pool())
+                  .tpchTableScan(
+                      Table::TBL_NATION,
+                      {"n_nationkey", "n_name", "n_regionkey"},
+                      1.0,
+                      kTpchConnectorId,
+                      "n_name LIKE 'A%'")
+                  .planNode();
+
+  auto output = getResults(plan, {makeTpchSplit()});
+
+  // Should only return nations with names starting with 'A'
+  auto expected = makeRowVector({
+      // n_nationkey
+      makeFlatVector<int64_t>({0, 1}),
+      // n_name
+      makeFlatVector<StringView>({
+          "ALGERIA",
+          "ARGENTINA",
+      }),
+      // n_regionkey
+      makeFlatVector<int64_t>({0, 1}),
+  });
+  test::assertEqualVectors(expected, output);
+}
+
+// Test filtering with IN operator
+TEST_F(TpchConnectorTest, inFilterPushdown) {
+  // Test IN filter
+  auto plan = PlanBuilder(pool())
+                  .tpchTableScan(
+                      Table::TBL_NATION,
+                      {"n_nationkey", "n_name", "n_regionkey"},
+                      1.0,
+                      kTpchConnectorId,
+                      "n_nationkey IN (0, 5, 10, 15, 20)")
+                  .planNode();
+
+  auto output = getResults(plan, {makeTpchSplit()});
+
+  // Should only return nations with nationkey in the specified list
+  auto expected = makeRowVector({
+      // n_nationkey
+      makeFlatVector<int64_t>({0, 5, 10, 15, 20}),
+      // n_name
+      makeFlatVector<StringView>({
+          "ALGERIA",
+          "ETHIOPIA",
+          "IRAN",
+          "MOROCCO",
+          "SAUDI ARABIA",
+      }),
+      // n_regionkey
+      makeFlatVector<int64_t>({0, 0, 4, 0, 4}),
+  });
+  test::assertEqualVectors(expected, output);
+}
+
+TEST_F(TpchConnectorTest, namespaceInfer) {
+  std::vector<std::pair<double, std::string>> expect = {
+      {0.05, "tiny.customer"},
+      {1.0, "sf1.customer"},
+      {5.0, "sf5.customer"},
+      {10.0, "sf10.customer"},
+      {100.0, "sf100.customer"},
+      {300.0, "sf300.customer"},
+      {10000.0, "sf10000.customer"},
+  };
+  for (const auto& expectpair : expect) {
+    auto handle = std::make_shared<TpchTableHandle>(
+        kTpchConnectorId, Table::TBL_CUSTOMER, expectpair.first);
+    EXPECT_EQ(handle->name(), expectpair.second);
+  }
+}
+
 // Join nation and region.
 TEST_F(TpchConnectorTest, join) {
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -302,6 +441,20 @@ TEST_F(TpchConnectorTest, orderDateCount) {
   EXPECT_EQ(9, orderDate->size());
 }
 
+TEST_F(TpchConnectorTest, config) {
+  std::unordered_map<std::string, std::string> properties = {
+      {"property", "value"}};
+  connector::tpch::TpchConnectorFactory factory;
+  auto connector = factory.newConnector(
+      kTpchConnectorId,
+      std::make_shared<config::ConfigBase>(std::move(properties)));
+
+  const auto& config = connector->connectorConfig();
+  auto val = config->get<std::string>("property");
+  EXPECT_TRUE(val.has_value());
+  EXPECT_EQ(val.value(), "value");
+}
+
 } // namespace
 
 int main(int argc, char** argv) {
diff --git a/velox/core/CMakeLists.txt b/velox/core/CMakeLists.txt
index 33c2bb537043..5957c440b942 100644
--- a/velox/core/CMakeLists.txt
+++ b/velox/core/CMakeLists.txt
@@ -18,24 +18,30 @@ endif()
 velox_add_library(
   velox_core
   Expressions.cpp
+  ITypedExpr.cpp
+  PlanConsistencyChecker.cpp
   PlanFragment.cpp
   PlanNode.cpp
   QueryConfig.cpp
   QueryCtx.cpp
-  SimpleFunctionMetadata.cpp)
+  SimpleFunctionMetadata.cpp
+  TableWriteTraits.cpp
+)
 
 velox_link_libraries(
   velox_core
-  PUBLIC velox_arrow_bridge
-         velox_caching
-         velox_common_config
-         velox_connector
-         velox_exception
-         velox_expression_functions
-         velox_memory
-         velox_type
-         velox_vector
-         Boost::headers
-         Folly::folly
-         fmt::fmt
-  PRIVATE velox_encode)
+  PUBLIC
+    velox_arrow_bridge
+    velox_caching
+    velox_common_config
+    velox_connector
+    velox_exception
+    velox_expression_functions
+    velox_memory
+    velox_type
+    velox_vector
+    Boost::headers
+    Folly::folly
+    fmt::fmt
+  PRIVATE velox_encode
+)
diff --git a/velox/core/ExpressionEvaluator.h b/velox/core/ExpressionEvaluator.h
index b10b113c8b25..1309d8ed8b2a 100644
--- a/velox/core/ExpressionEvaluator.h
+++ b/velox/core/ExpressionEvaluator.h
@@ -41,6 +41,9 @@ class ExpressionEvaluator {
   virtual std::unique_ptr<exec::ExprSet> compile(
       const std::shared_ptr<const ITypedExpr>& expression) = 0;
 
+  virtual std::unique_ptr<exec::ExprSet> compile(
+      const std::vector<std::shared_ptr<const ITypedExpr>>& expressions) = 0;
+
   // Evaluates previously compiled expression on the specified rows.
   // Re-uses result vector if it is not null.
   virtual void evaluate(
@@ -49,6 +52,12 @@ class ExpressionEvaluator {
       const RowVector& input,
       VectorPtr& result) = 0;
 
+  virtual void evaluate(
+      exec::ExprSet* exprSet,
+      const SelectivityVector& rows,
+      const RowVector& input,
+      std::vector<VectorPtr>& results) = 0;
+
   // Memory pool used to construct input or output vectors.
   virtual memory::MemoryPool* pool() = 0;
 };
diff --git a/velox/core/Expressions.cpp b/velox/core/Expressions.cpp
index 75c34c74feca..289d6f3e9b46 100644
--- a/velox/core/Expressions.cpp
+++ b/velox/core/Expressions.cpp
@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 #include "velox/core/Expressions.h"
+#include "velox/common/Casts.h"
 #include "velox/common/encode/Base64.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/ConstantVector.h"
+#include "velox/vector/SimpleVector.h"
 #include "velox/vector/VectorSaver.h"
 
 namespace facebook::velox::core {
@@ -84,6 +88,19 @@ TypedExprPtr InputTypedExpr::create(const folly::dynamic& obj, void* context) {
   return std::make_shared<InputTypedExpr>(std::move(type));
 }
 
+std::optional<bool> ConstantTypedExpr::toBool() const {
+  VELOX_CHECK(
+      this->type()->isBoolean(),
+      "Expected boolean expression, but got {}",
+      this->type()->toString());
+
+  if (!isNull()) {
+    return valueVector_ ? valueVector_->as<ConstantVector<bool>>()->valueAt(0)
+                        : value_.value<TypeKind::BOOLEAN>();
+  }
+  return std::nullopt;
+}
+
 void ConstantTypedExpr::accept(
     const ITypedExprVisitor& visitor,
     ITypedExprVisitorContext& context) const {
@@ -112,7 +129,7 @@ TypedExprPtr ConstantTypedExpr::create(
   auto type = core::deserializeType(obj, context);
 
   if (obj.count("value")) {
-    auto value = variant::create(obj["value"]);
+    auto value = Variant::create(obj["value"]);
     return std::make_shared<ConstantTypedExpr>(std::move(type), value);
   }
 
@@ -125,6 +142,316 @@ TypedExprPtr ConstantTypedExpr::create(
   return std::make_shared<ConstantTypedExpr>(restoreVector(dataStream, pool));
 }
 
+// static
+TypedExprPtr ConstantTypedExpr::makeNull(const TypePtr& type) {
+  return std::make_shared<core::ConstantTypedExpr>(
+      type, Variant::null(type->kind()));
+}
+
+std::string ConstantTypedExpr::toString() const {
+  if (hasValueVector()) {
+    return valueVector_->toString(0);
+  }
+
+  return value_.toStringAsVector(type());
+}
+
+namespace {
+
+bool equalsImpl(
+    const VectorPtr& vector,
+    vector_size_t index,
+    const Variant& value);
+
+template <TypeKind Kind>
+bool equalsNoNulls(
+    const VectorPtr& vector,
+    vector_size_t index,
+    const Variant& value) {
+  using T = typename TypeTraits<Kind>::NativeType;
+
+  const auto thisValue = vector->as<SimpleVector<T>>()->valueAt(index);
+  const auto otherValue = T(value.value<Kind>());
+
+  const auto& type = vector->type();
+
+  auto result = type->providesCustomComparison()
+      ? SimpleVector<T>::comparePrimitiveAscWithCustomComparison(
+            type.get(), thisValue, otherValue)
+      : SimpleVector<T>::comparePrimitiveAsc(thisValue, otherValue);
+  return result == 0;
+}
+
+template <>
+bool equalsNoNulls<TypeKind::OPAQUE>(
+    const VectorPtr& vector,
+    vector_size_t index,
+    const Variant& value) {
+  using T = std::shared_ptr<void>;
+  const auto thisValue = vector->as<SimpleVector<T>>()->valueAt(index);
+  const auto& otherValue = value.value<TypeKind::OPAQUE>().obj;
+
+  const auto& type = vector->type();
+
+  auto result = type->providesCustomComparison()
+      ? SimpleVector<T>::comparePrimitiveAscWithCustomComparison(
+            type.get(), thisValue, otherValue)
+      : SimpleVector<T>::comparePrimitiveAsc(thisValue, otherValue);
+  return result == 0;
+}
+
+template <>
+bool equalsNoNulls<TypeKind::ARRAY>(
+    const VectorPtr& vector,
+    vector_size_t index,
+    const Variant& value) {
+  auto* wrappedVector = vector->wrappedVector();
+  VELOX_CHECK_EQ(VectorEncoding::Simple::ARRAY, wrappedVector->encoding());
+
+  auto* arrayVector = wrappedVector->asUnchecked<ArrayVector>();
+
+  index = vector->wrappedIndex(index);
+
+  const auto offset = arrayVector->offsetAt(index);
+  const auto size = arrayVector->sizeAt(index);
+
+  const auto& arrayValue = value.value<TypeKind::ARRAY>();
+  if (size != arrayValue.size()) {
+    return false;
+  }
+
+  for (auto i = 0; i < size; ++i) {
+    if (!equalsImpl(arrayVector->elements(), offset + i, arrayValue.at(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+template <>
+bool equalsNoNulls<TypeKind::MAP>(
+    const VectorPtr& vector,
+    vector_size_t index,
+    const Variant& value) {
+  auto* wrappedVector = vector->wrappedVector();
+  VELOX_CHECK_EQ(VectorEncoding::Simple::MAP, wrappedVector->encoding());
+
+  auto* mapVector = wrappedVector->asUnchecked<MapVector>();
+
+  index = vector->wrappedIndex(index);
+
+  const auto size = mapVector->sizeAt(index);
+
+  const auto& mapValue = value.value<TypeKind::MAP>();
+  if (size != mapValue.size()) {
+    return false;
+  }
+
+  const auto sortedIndices = mapVector->sortedKeyIndices(index);
+
+  size_t i = 0;
+  for (const auto& [key, value] : mapValue) {
+    if (!equalsImpl(mapVector->mapKeys(), sortedIndices[i], key)) {
+      return false;
+    }
+
+    if (!equalsImpl(mapVector->mapValues(), sortedIndices[i], value)) {
+      return false;
+    }
+
+    ++i;
+  }
+
+  return true;
+}
+
+template <>
+bool equalsNoNulls<TypeKind::ROW>(
+    const VectorPtr& vector,
+    vector_size_t index,
+    const Variant& value) {
+  auto* wrappedVector = vector->wrappedVector();
+  VELOX_CHECK_EQ(VectorEncoding::Simple::ROW, wrappedVector->encoding());
+
+  auto* rowVector = wrappedVector->asUnchecked<RowVector>();
+
+  index = vector->wrappedIndex(index);
+
+  const auto size = rowVector->type()->size();
+
+  const auto& rowValue = value.value<TypeKind::ROW>();
+  if (size != rowValue.size()) {
+    return false;
+  }
+
+  for (auto i = 0; i < size; ++i) {
+    if (rowVector->childAt(i) == nullptr) {
+      return false;
+    }
+
+    if (!equalsImpl(rowVector->childAt(i), index, rowValue.at(i))) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool equalsImpl(
+    const VectorPtr& vector,
+    vector_size_t index,
+    const Variant& value) {
+  static constexpr CompareFlags kEqualValueAtFlags =
+      CompareFlags::equality(CompareFlags::NullHandlingMode::kNullAsValue);
+
+  bool thisNull = vector->isNullAt(index);
+  bool otherNull = value.isNull();
+
+  if (otherNull || thisNull) {
+    return BaseVector::compareNulls(thisNull, otherNull, kEqualValueAtFlags)
+               .value() == 0;
+  }
+
+  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+      equalsNoNulls, vector->typeKind(), vector, index, value);
+}
+} // namespace
+
+bool ConstantTypedExpr::equals(const ITypedExpr& other) const {
+  const auto* casted = dynamic_cast<const ConstantTypedExpr*>(&other);
+  if (!casted) {
+    return false;
+  }
+
+  if (*this->type() != *casted->type()) {
+    return false;
+  }
+
+  if (this->hasValueVector() != casted->hasValueVector()) {
+    return this->hasValueVector()
+        ? equalsImpl(this->valueVector_, 0, casted->value_)
+        : equalsImpl(casted->valueVector_, 0, this->value_);
+  }
+
+  if (this->hasValueVector()) {
+    return this->valueVector_->equalValueAt(casted->valueVector_.get(), 0, 0);
+  }
+
+  return this->value_ == casted->value_;
+}
+
+namespace {
+
+uint64_t hashImpl(const TypePtr& type, const Variant& value);
+
+template <TypeKind Kind>
+uint64_t hashImpl(const TypePtr& type, const Variant& value) {
+  using T = typename TypeTraits<Kind>::NativeType;
+
+  const auto& v = value.value<Kind>();
+
+  if (type->providesCustomComparison()) {
+    return SimpleVector<T>::hashValueAtWithCustomType(type, T(v));
+  }
+
+  if constexpr (std::is_floating_point_v<T>) {
+    return util::floating_point::NaNAwareHash<T>{}(T(v));
+  } else {
+    return folly::hasher<T>{}(T(v));
+  }
+}
+
+template <>
+uint64_t hashImpl<TypeKind::OPAQUE>(const TypePtr& type, const Variant& value) {
+  return value.hash();
+}
+
+template <>
+uint64_t hashImpl<TypeKind::ARRAY>(const TypePtr& type, const Variant& value) {
+  const auto& arrayValue = value.value<TypeKind::ARRAY>();
+
+  const auto& elementType = type->childAt(0);
+
+  uint64_t hash = BaseVector::kNullHash;
+  for (auto i = 0; i < arrayValue.size(); ++i) {
+    hash = bits::hashMix(hash, hashImpl(elementType, arrayValue.at(i)));
+  }
+  return hash;
+}
+
+template <>
+uint64_t hashImpl<TypeKind::MAP>(const TypePtr& type, const Variant& value) {
+  const auto& mapValue = value.value<TypeKind::MAP>();
+
+  const auto& keyType = type->childAt(0);
+  const auto& valueType = type->childAt(1);
+
+  uint64_t hash = BaseVector::kNullHash;
+  for (const auto& [key, value] : mapValue) {
+    const auto keyValueHash =
+        bits::hashMix(hashImpl(keyType, key), hashImpl(valueType, value));
+    hash = bits::commutativeHashMix(hash, keyValueHash);
+  }
+
+  return hash;
+}
+
+template <>
+uint64_t hashImpl<TypeKind::ROW>(const TypePtr& type, const Variant& value) {
+  const auto& rowValue = value.value<TypeKind::ROW>();
+
+  uint64_t hash = BaseVector::kNullHash;
+  for (auto i = 0; i < rowValue.size(); ++i) {
+    const auto value = hashImpl(type->childAt(i), rowValue.at(i));
+    if (i == 0) {
+      hash = value;
+    } else {
+      hash = bits::hashMix(hash, value);
+    }
+  }
+  return hash;
+}
+
+uint64_t hashImpl(const TypePtr& type, const Variant& value) {
+  if (value.isNull()) {
+    return BaseVector::kNullHash;
+  }
+
+  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(hashImpl, type->kind(), type, value);
+}
+
+} // namespace
+
+size_t ConstantTypedExpr::localHash() const {
+  static const size_t kBaseHash = std::hash<const char*>()("ConstantTypedExpr");
+
+  uint64_t h;
+
+  if (hasValueVector()) {
+    h = valueVector_->hashValueAt(0);
+  } else {
+    h = hashImpl(type(), value_);
+  }
+
+  return bits::hashMix(kBaseHash, h);
+}
+
+std::string CallTypedExpr::toString() const {
+  std::string str{};
+  str += name();
+  str += "(";
+  for (size_t i = 0; i < inputs().size(); ++i) {
+    auto& input = inputs().at(i);
+    if (i != 0) {
+      str += ",";
+    }
+    str += input->toString();
+  }
+  str += ")";
+  return str;
+}
+
 void CallTypedExpr::accept(
     const ITypedExprVisitor& visitor,
     ITypedExprVisitorContext& context) const {
@@ -146,6 +473,43 @@ TypedExprPtr CallTypedExpr::create(const folly::dynamic& obj, void* context) {
       std::move(type), std::move(inputs), obj["functionName"].asString());
 }
 
+TypedExprPtr FieldAccessTypedExpr::rewriteInputNames(
+    const std::unordered_map<std::string, TypedExprPtr>& mapping) const {
+  if (inputs().empty()) {
+    auto it = mapping.find(name_);
+    return it != mapping.end()
+        ? it->second
+        : std::make_shared<FieldAccessTypedExpr>(type(), name_);
+  }
+
+  auto newInputs = rewriteInputsRecursive(mapping);
+  VELOX_CHECK_EQ(1, newInputs.size());
+  // Only rewrite name if input in InputTypedExpr. Rewrite in other
+  // cases(like dereference) is unsound.
+  if (!newInputs[0]->isInputKind()) {
+    return std::make_shared<FieldAccessTypedExpr>(type(), newInputs[0], name_);
+  }
+  auto it = mapping.find(name_);
+  auto newName = name_;
+  if (it != mapping.end()) {
+    if (auto name =
+            std::dynamic_pointer_cast<const FieldAccessTypedExpr>(it->second)) {
+      newName = name->name();
+    }
+  }
+  return std::make_shared<FieldAccessTypedExpr>(type(), newInputs[0], newName);
+}
+
+std::string FieldAccessTypedExpr::toString() const {
+  std::stringstream ss;
+  ss << std::quoted(name(), '"', '"');
+  if (inputs().empty()) {
+    return fmt::format("{}", ss.str());
+  }
+
+  return fmt::format("{}[{}]", inputs()[0]->toString(), ss.str());
+}
+
 void FieldAccessTypedExpr::accept(
     const ITypedExprVisitor& visitor,
     ITypedExprVisitorContext& context) const {
@@ -202,6 +566,40 @@ TypedExprPtr DereferenceTypedExpr::create(
       std::move(type), std::move(inputs[0]), index);
 }
 
+namespace {
+TypePtr toRowType(
+    const std::vector<std::string>& names,
+    const std::vector<TypedExprPtr>& expressions) {
+  std::vector<TypePtr> types;
+  types.reserve(expressions.size());
+  for (const auto& expr : expressions) {
+    types.push_back(expr->type());
+  }
+
+  auto namesCopy = names;
+  return ROW(std::move(namesCopy), std::move(types));
+}
+} // namespace
+
+ConcatTypedExpr::ConcatTypedExpr(
+    const std::vector<std::string>& names,
+    const std::vector<TypedExprPtr>& inputs)
+    : ITypedExpr{ExprKind::kConcat, toRowType(names, inputs), inputs} {}
+
+std::string ConcatTypedExpr::toString() const {
+  std::string str{};
+  str += "CONCAT(";
+  for (size_t i = 0; i < inputs().size(); ++i) {
+    auto& input = inputs().at(i);
+    if (i != 0) {
+      str += ",";
+    }
+    str += input->toString();
+  }
+  str += ")";
+  return str;
+}
+
 void ConcatTypedExpr::accept(
     const ITypedExprVisitor& visitor,
     ITypedExprVisitorContext& context) const {
@@ -221,6 +619,17 @@ TypedExprPtr ConcatTypedExpr::create(const folly::dynamic& obj, void* context) {
       type->asRow().names(), std::move(inputs));
 }
 
+TypedExprPtr LambdaTypedExpr::rewriteInputNames(
+    const std::unordered_map<std::string, TypedExprPtr>& mapping) const {
+  for (const auto& name : signature_->names()) {
+    if (mapping.count(name)) {
+      VELOX_USER_FAIL("Ambiguous variable: {}", name);
+    }
+  }
+  return std::make_shared<LambdaTypedExpr>(
+      signature_, body_->rewriteInputNames(mapping));
+}
+
 void LambdaTypedExpr::accept(
     const ITypedExprVisitor& visitor,
     ITypedExprVisitorContext& context) const {
@@ -243,6 +652,16 @@ TypedExprPtr LambdaTypedExpr::create(const folly::dynamic& obj, void* context) {
       asRowType(signature), std::move(body));
 }
 
+std::string CastTypedExpr::toString() const {
+  if (isTryCast_) {
+    return fmt::format(
+        "try_cast({} as {})", inputs()[0]->toString(), type()->toString());
+  } else {
+    return fmt::format(
+        "cast({} as {})", inputs()[0]->toString(), type()->toString());
+  }
+}
+
 void CastTypedExpr::accept(
     const ITypedExprVisitor& visitor,
     ITypedExprVisitorContext& context) const {
@@ -251,7 +670,7 @@ void CastTypedExpr::accept(
 
 folly::dynamic CastTypedExpr::serialize() const {
   auto obj = ITypedExpr::serializeBase("CastTypedExpr");
-  obj["nullOnFailure"] = nullOnFailure_;
+  obj["isTryCast"] = isTryCast_;
   return obj;
 }
 
@@ -261,7 +680,7 @@ TypedExprPtr CastTypedExpr::create(const folly::dynamic& obj, void* context) {
   auto inputs = deserializeInputs(obj, context);
 
   return std::make_shared<CastTypedExpr>(
-      std::move(type), std::move(inputs), obj["nullOnFailure"].asBool());
+      std::move(type), std::move(inputs), obj["isTryCast"].asBool());
 }
 
 } // namespace facebook::velox::core
diff --git a/velox/core/Expressions.h b/velox/core/Expressions.h
index 582dbce8b7ef..ba97846c53b6 100644
--- a/velox/core/Expressions.h
+++ b/velox/core/Expressions.h
@@ -15,7 +15,7 @@
  */
 #pragma once
 
-#include <iomanip>
+#include "velox/common/Casts.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/core/ITypedExpr.h"
 #include "velox/vector/BaseVector.h"
@@ -24,11 +24,11 @@ namespace facebook::velox::core {
 
 class InputTypedExpr : public ITypedExpr {
  public:
-  explicit InputTypedExpr(TypePtr type) : ITypedExpr{std::move(type)} {}
+  explicit InputTypedExpr(TypePtr type)
+      : ITypedExpr{ExprKind::kInput, std::move(type)} {}
 
   bool operator==(const ITypedExpr& other) const final {
-    const auto* casted = dynamic_cast<const InputTypedExpr*>(&other);
-    return casted != nullptr;
+    return other.isInputKind();
   }
 
   std::string toString() const override {
@@ -58,41 +58,36 @@ class InputTypedExpr : public ITypedExpr {
 class ConstantTypedExpr : public ITypedExpr {
  public:
   // Creates constant expression. For complex types, only
-  // variant::null() value is supported.
-  ConstantTypedExpr(TypePtr type, variant value)
-      : ITypedExpr{std::move(type)}, value_{std::move(value)} {}
+  // Variant::null() value is supported.
+  ConstantTypedExpr(TypePtr type, Variant value)
+      : ITypedExpr{ExprKind::kConstant, std::move(type)},
+        value_{std::move(value)} {
+    VELOX_CHECK(
+        value_.isTypeCompatible(ITypedExpr::type()),
+        "Expression type {} does not match variant type {}",
+        ITypedExpr::type()->toString(),
+        value_.inferType()->toString());
+  }
 
   // Creates constant expression of scalar or complex type. The value comes from
   // index zero.
   explicit ConstantTypedExpr(const VectorPtr& value)
-      : ITypedExpr{value->type()},
+      : ITypedExpr{ExprKind::kConstant, value->type()},
         valueVector_{
             value->isConstantEncoding()
                 ? value
                 : BaseVector::wrapInConstant(1, 0, value)} {}
 
-  std::string toString() const override {
-    if (hasValueVector()) {
-      return valueVector_->toString(0);
-    }
-    return value_.toJson(type());
-  }
-
-  size_t localHash() const override {
-    static const size_t kBaseHash =
-        std::hash<const char*>()("ConstantTypedExpr");
+  std::string toString() const override;
 
-    return bits::hashMix(
-        kBaseHash,
-        hasValueVector() ? valueVector_->hashValueAt(0) : value_.hash());
-  }
+  size_t localHash() const override;
 
   bool hasValueVector() const {
     return valueVector_ != nullptr;
   }
 
-  /// Returns scalar value as variant if hasValueVector() is false.
-  const variant& value() const {
+  /// Returns scalar value as Variant if hasValueVector() is false.
+  const Variant& value() const {
     return value_;
   }
 
@@ -119,6 +114,10 @@ class ConstantTypedExpr : public ITypedExpr {
     return BaseVector::createConstant(type(), value_, 1, pool);
   }
 
+  /// Returns value of boolean expression, std::nullopt for null booleans.
+  /// Throws an error if expression is not of boolean type.
+  std::optional<bool> toBool() const;
+
   const std::vector<TypedExprPtr>& inputs() const {
     static const std::vector<TypedExprPtr> kEmpty{};
     return kEmpty;
@@ -138,26 +137,7 @@ class ConstantTypedExpr : public ITypedExpr {
       const ITypedExprVisitor& visitor,
       ITypedExprVisitorContext& context) const override;
 
-  bool equals(const ITypedExpr& other) const {
-    const auto* casted = dynamic_cast<const ConstantTypedExpr*>(&other);
-    if (!casted) {
-      return false;
-    }
-
-    if (*this->type() != *casted->type()) {
-      return false;
-    }
-
-    if (this->hasValueVector() != casted->hasValueVector()) {
-      return false;
-    }
-
-    if (this->hasValueVector()) {
-      return this->valueVector_->equalValueAt(casted->valueVector_.get(), 0, 0);
-    }
-
-    return this->value_ == casted->value_;
-  }
+  bool equals(const ITypedExpr& other) const;
 
   bool operator==(const ITypedExpr& other) const final {
     return this->equals(other);
@@ -171,8 +151,11 @@ class ConstantTypedExpr : public ITypedExpr {
 
   static TypedExprPtr create(const folly::dynamic& obj, void* context);
 
+  /// Returns a NULL constant expression of given type.
+  static TypedExprPtr makeNull(const TypePtr& type);
+
  private:
-  const variant value_;
+  const Variant value_;
   const VectorPtr valueVector_;
 };
 
@@ -180,15 +163,15 @@ 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
+/// 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.
+/// 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.
@@ -198,11 +181,11 @@ using ConstantTypedExprPtr = std::shared_ptr<const ConstantTypedExpr>;
 /// - 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.
+/// 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
@@ -216,9 +199,19 @@ class CallTypedExpr : public ITypedExpr {
       TypePtr type,
       std::vector<TypedExprPtr> inputs,
       std::string name)
-      : ITypedExpr{std::move(type), std::move(inputs)},
+      : ITypedExpr{ExprKind::kCall, std::move(type), std::move(inputs)},
         name_(std::move(name)) {}
 
+  /// @param type Return type.
+  /// @param name Name of the function or special form.
+  /// @param inputs List of input expressions.
+  template <typename... TypedExprs>
+  CallTypedExpr(TypePtr type, std::string name, TypedExprs... inputs)
+      : CallTypedExpr(
+            std::move(type),
+            std::vector<TypedExprPtr>{std::forward<TypedExprs>(inputs)...},
+            std::move(name)) {}
+
   virtual const std::string& name() const {
     return name_;
   }
@@ -230,20 +223,7 @@ class CallTypedExpr : public ITypedExpr {
         type(), rewriteInputsRecursive(mapping), name_);
   }
 
-  std::string toString() const override {
-    std::string str{};
-    str += name();
-    str += "(";
-    for (size_t i = 0; i < inputs().size(); ++i) {
-      auto& input = inputs().at(i);
-      if (i != 0) {
-        str += ",";
-      }
-      str += input->toString();
-    }
-    str += ")";
-    return str;
-  }
+  std::string toString() const override;
 
   size_t localHash() const override {
     static const size_t kBaseHash = std::hash<const char*>()("CallTypedExpr");
@@ -270,10 +250,10 @@ class CallTypedExpr : public ITypedExpr {
       return false;
     }
     return std::equal(
-        this->inputs().begin(),
-        this->inputs().end(),
-        other.inputs().begin(),
-        other.inputs().end(),
+        this->inputs().cbegin(),
+        this->inputs().cend(),
+        other.inputs().cbegin(),
+        other.inputs().cend(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -292,17 +272,16 @@ class FieldAccessTypedExpr : public ITypedExpr {
  public:
   /// Used as a leaf in an expression tree specifying input column by name.
   FieldAccessTypedExpr(TypePtr type, std::string name)
-      : ITypedExpr{std::move(type)},
+      : ITypedExpr{ExprKind::kFieldAccess, std::move(type)},
         name_(std::move(name)),
         isInputColumn_(true) {}
 
   /// Used as a dereference expression which selects a subfield in a struct by
   /// name.
   FieldAccessTypedExpr(TypePtr type, TypedExprPtr input, std::string name)
-      : ITypedExpr{std::move(type), {std::move(input)}},
+      : ITypedExpr{ExprKind::kFieldAccess, std::move(type), {std::move(input)}},
         name_(std::move(name)),
-        isInputColumn_(dynamic_cast<const InputTypedExpr*>(inputs()[0].get())) {
-  }
+        isInputColumn_(inputs()[0]->isInputKind()) {}
 
   const std::string& name() const {
     return name_;
@@ -310,43 +289,9 @@ class FieldAccessTypedExpr : public ITypedExpr {
 
   TypedExprPtr rewriteInputNames(
       const std::unordered_map<std::string, TypedExprPtr>& mapping)
-      const override {
-    if (inputs().empty()) {
-      auto it = mapping.find(name_);
-      return it != mapping.end()
-          ? it->second
-          : std::make_shared<FieldAccessTypedExpr>(type(), name_);
-    }
-
-    auto newInputs = rewriteInputsRecursive(mapping);
-    VELOX_CHECK_EQ(1, newInputs.size());
-    // Only rewrite name if input in InputTypedExpr. Rewrite in other
-    // cases(like dereference) is unsound.
-    if (!std::dynamic_pointer_cast<const InputTypedExpr>(newInputs[0])) {
-      return std::make_shared<FieldAccessTypedExpr>(
-          type(), newInputs[0], name_);
-    }
-    auto it = mapping.find(name_);
-    auto newName = name_;
-    if (it != mapping.end()) {
-      if (auto name = std::dynamic_pointer_cast<const FieldAccessTypedExpr>(
-              it->second)) {
-        newName = name->name();
-      }
-    }
-    return std::make_shared<FieldAccessTypedExpr>(
-        type(), newInputs[0], newName);
-  }
-
-  std::string toString() const override {
-    std::stringstream ss;
-    ss << std::quoted(name(), '"', '"');
-    if (inputs().empty()) {
-      return fmt::format("{}", ss.str());
-    }
+      const override;
 
-    return fmt::format("{}[{}]", inputs()[0]->toString(), ss.str());
-  }
+  std::string toString() const override;
 
   size_t localHash() const override {
     static const size_t kBaseHash =
@@ -374,10 +319,10 @@ class FieldAccessTypedExpr : public ITypedExpr {
       return false;
     }
     return std::equal(
-        this->inputs().begin(),
-        this->inputs().end(),
-        other.inputs().begin(),
-        other.inputs().end(),
+        this->inputs().cbegin(),
+        this->inputs().cend(),
+        other.inputs().cbegin(),
+        other.inputs().cend(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -397,15 +342,17 @@ class FieldAccessTypedExpr : public ITypedExpr {
 
 using FieldAccessTypedExprPtr = std::shared_ptr<const FieldAccessTypedExpr>;
 
-/// Represents a dereference expression which selects a subfield in a struct by
-/// name.
+/// Represents a dereference expression which selects a subfield in a struct
+/// by name.
 class DereferenceTypedExpr : public ITypedExpr {
  public:
   DereferenceTypedExpr(TypePtr type, TypedExprPtr input, uint32_t index)
-      : ITypedExpr{std::move(type), {std::move(input)}}, index_(index) {
+      : ITypedExpr{ExprKind::kDereference, std::move(type), {std::move(input)}},
+        index_(index) {
     // Make sure this isn't being used to access a top level column.
-    VELOX_USER_CHECK_NULL(
-        std::dynamic_pointer_cast<const InputTypedExpr>(inputs()[0]));
+    VELOX_USER_CHECK(
+        !inputs()[0]->isInputKind(),
+        "DereferenceTypedExpr select a subfeild cannot be used to access a top level column");
   }
 
   uint32_t index() const {
@@ -452,10 +399,10 @@ class DereferenceTypedExpr : public ITypedExpr {
       return false;
     }
     return std::equal(
-        this->inputs().begin(),
-        this->inputs().end(),
-        other.inputs().begin(),
-        other.inputs().end(),
+        this->inputs().cbegin(),
+        this->inputs().cend(),
+        other.inputs().cbegin(),
+        other.inputs().cend(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
@@ -474,8 +421,7 @@ class ConcatTypedExpr : public ITypedExpr {
  public:
   ConcatTypedExpr(
       const std::vector<std::string>& names,
-      const std::vector<TypedExprPtr>& inputs)
-      : ITypedExpr{toType(names, inputs), inputs} {}
+      const std::vector<TypedExprPtr>& inputs);
 
   TypedExprPtr rewriteInputNames(
       const std::unordered_map<std::string, TypedExprPtr>& mapping)
@@ -484,19 +430,7 @@ class ConcatTypedExpr : public ITypedExpr {
         type()->asRow().names(), rewriteInputsRecursive(mapping));
   }
 
-  std::string toString() const override {
-    std::string str{};
-    str += "CONCAT(";
-    for (size_t i = 0; i < inputs().size(); ++i) {
-      auto& input = inputs().at(i);
-      if (i != 0) {
-        str += ",";
-      }
-      str += input->toString();
-    }
-    str += ")";
-    return str;
-  }
+  std::string toString() const override;
 
   size_t localHash() const override {
     static const size_t kBaseHash = std::hash<const char*>()("ConcatTypedExpr");
@@ -520,29 +454,16 @@ class ConcatTypedExpr : public ITypedExpr {
       return false;
     }
     return std::equal(
-        this->inputs().begin(),
-        this->inputs().end(),
-        other.inputs().begin(),
-        other.inputs().end(),
+        this->inputs().cbegin(),
+        this->inputs().cend(),
+        other.inputs().cbegin(),
+        other.inputs().cend(),
         [](const auto& p1, const auto& p2) { return *p1 == *p2; });
   }
 
   folly::dynamic serialize() const override;
 
   static TypedExprPtr create(const folly::dynamic& obj, void* context);
-
- private:
-  static TypePtr toType(
-      const std::vector<std::string>& names,
-      const std::vector<TypedExprPtr>& expressions) {
-    std::vector<TypePtr> children{};
-    std::vector<std::string> namesCopy{};
-    for (size_t i = 0; i < names.size(); ++i) {
-      namesCopy.push_back(names.at(i));
-      children.push_back(expressions.at(i)->type());
-    }
-    return ROW(std::move(namesCopy), std::move(children));
-  }
 };
 
 using ConcatTypedExprPtr = std::shared_ptr<const ConcatTypedExpr>;
@@ -550,9 +471,11 @@ using ConcatTypedExprPtr = std::shared_ptr<const ConcatTypedExpr>;
 class LambdaTypedExpr : public ITypedExpr {
  public:
   LambdaTypedExpr(RowTypePtr signature, TypedExprPtr body)
-      : ITypedExpr(std::make_shared<FunctionType>(
-            std::vector<TypePtr>(signature->children()),
-            body->type())),
+      : ITypedExpr(
+            ExprKind::kLambda,
+            std::make_shared<FunctionType>(
+                std::vector<TypePtr>(signature->children()),
+                body->type())),
         signature_(std::move(signature)),
         body_(std::move(body)) {}
 
@@ -566,15 +489,7 @@ class LambdaTypedExpr : public ITypedExpr {
 
   TypedExprPtr rewriteInputNames(
       const std::unordered_map<std::string, TypedExprPtr>& mapping)
-      const override {
-    for (const auto& name : signature_->names()) {
-      if (mapping.count(name)) {
-        VELOX_USER_FAIL("Ambiguous variable: {}", name);
-      }
-    }
-    return std::make_shared<LambdaTypedExpr>(
-        signature_, body_->rewriteInputNames(mapping));
-  }
+      const override;
 
   std::string toString() const override {
     return fmt::format(
@@ -623,18 +538,15 @@ class CastTypedExpr : public ITypedExpr {
   /// 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 TypePtr& type,
-      const TypedExprPtr& input,
-      bool nullOnFailure)
-      : ITypedExpr{type, {input}}, nullOnFailure_(nullOnFailure) {}
+  /// @param isTryCast Whether this expression is used for `try_cast`.
+  CastTypedExpr(const TypePtr& type, const TypedExprPtr& input, bool isTryCast)
+      : ITypedExpr{ExprKind::kCast, type, {input}}, isTryCast_(isTryCast) {}
 
   CastTypedExpr(
       const TypePtr& type,
       const std::vector<TypedExprPtr>& inputs,
-      bool nullOnFailure)
-      : ITypedExpr{type, inputs}, nullOnFailure_(nullOnFailure) {
+      bool isTryCast)
+      : ITypedExpr{ExprKind::kCast, type, inputs}, isTryCast_(isTryCast) {
     VELOX_USER_CHECK_EQ(
         1, inputs.size(), "Cast expression requires exactly one input");
   }
@@ -643,22 +555,14 @@ class CastTypedExpr : public ITypedExpr {
       const std::unordered_map<std::string, TypedExprPtr>& mapping)
       const override {
     return std::make_shared<CastTypedExpr>(
-        type(), rewriteInputsRecursive(mapping), nullOnFailure_);
+        type(), rewriteInputsRecursive(mapping), isTryCast_);
   }
 
-  std::string toString() const override {
-    if (nullOnFailure_) {
-      return fmt::format(
-          "try_cast {} as {}", inputs()[0]->toString(), type()->toString());
-    } else {
-      return fmt::format(
-          "cast {} as {}", inputs()[0]->toString(), type()->toString());
-    }
-  }
+  std::string toString() const override;
 
   size_t localHash() const override {
     static const size_t kBaseHash = std::hash<const char*>()("CastTypedExpr");
-    return bits::hashMix(kBaseHash, std::hash<bool>()(nullOnFailure_));
+    return bits::hashMix(kBaseHash, std::hash<bool>()(isTryCast_));
   }
 
   void accept(
@@ -672,15 +576,15 @@ class CastTypedExpr : public ITypedExpr {
     }
     if (inputs().empty()) {
       return type() == otherCast->type() && otherCast->inputs().empty() &&
-          nullOnFailure_ == otherCast->nullOnFailure();
+          isTryCast_ == otherCast->isTryCast();
     }
     return *type() == *otherCast->type() &&
         *inputs()[0] == *otherCast->inputs()[0] &&
-        nullOnFailure_ == otherCast->nullOnFailure();
+        isTryCast_ == otherCast->isTryCast();
   }
 
-  bool nullOnFailure() const {
-    return nullOnFailure_;
+  bool isTryCast() const {
+    return isTryCast_;
   }
 
   folly::dynamic serialize() const override;
@@ -688,8 +592,9 @@ class CastTypedExpr : public ITypedExpr {
   static TypedExprPtr create(const folly::dynamic& obj, void* context);
 
  private:
-  // Suppress exception and return null on failure to cast.
-  const bool nullOnFailure_;
+  // Whether this expression is used for `try_cast`. When true, Presto cast
+  // suppresses exception and return null on failure to case.
+  const bool isTryCast_;
 };
 
 using CastTypedExprPtr = std::shared_ptr<const CastTypedExpr>;
@@ -699,7 +604,7 @@ 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;
+    return expr->isFieldAccessKind();
   }
 
   /// Returns 'expr' as FieldAccessTypedExprPtr or null if not field access
@@ -710,7 +615,7 @@ class TypedExprs {
 
   /// Returns true if 'expr' is a constant expression.
   static bool isConstant(const TypedExprPtr& expr) {
-    return dynamic_cast<const ConstantTypedExpr*>(expr.get()) != nullptr;
+    return expr->isConstantKind();
   }
 
   /// Returns 'expr' as ConstantTypedExprPtr or null if not a constant
@@ -721,7 +626,7 @@ class TypedExprs {
 
   /// Returns true if 'expr' is a lambda expression.
   static bool isLambda(const TypedExprPtr& expr) {
-    return dynamic_cast<const LambdaTypedExpr*>(expr.get()) != nullptr;
+    return expr->isLambdaKind();
   }
 
   /// Returns 'expr' as LambdaTypedExprPtr or null if not a lambda expression.
diff --git a/velox/core/ITypedExpr.cpp b/velox/core/ITypedExpr.cpp
new file mode 100644
index 000000000000..f0b11d8af809
--- /dev/null
+++ b/velox/core/ITypedExpr.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/core/ITypedExpr.h"
+
+namespace facebook::velox::core {
+
+namespace {
+const auto& exprKindNames() {
+  static const folly::F14FastMap<ExprKind, std::string_view> kNames = {
+      {ExprKind::kInput, "INPUT"},
+      {ExprKind::kFieldAccess, "FIELD"},
+      {ExprKind::kDereference, "DEREFERENCE"},
+      {ExprKind::kCall, "CALL"},
+      {ExprKind::kCast, "CAST"},
+      {ExprKind::kConstant, "CONSTANT"},
+      {ExprKind::kConcat, "CONCAT"},
+      {ExprKind::kLambda, "LAMBDA"},
+  };
+  return kNames;
+}
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(ExprKind, exprKindNames);
+
+size_t ITypedExprHasher::operator()(const ITypedExpr* expr) const {
+  return expr->hash();
+}
+
+bool ITypedExprComparer::operator()(
+    const ITypedExpr* lhs,
+    const ITypedExpr* rhs) const {
+  return *lhs == *rhs;
+}
+} // namespace facebook::velox::core
diff --git a/velox/core/ITypedExpr.h b/velox/core/ITypedExpr.h
index b0f96623aaf1..b1e705ff7f58 100644
--- a/velox/core/ITypedExpr.h
+++ b/velox/core/ITypedExpr.h
@@ -19,30 +19,93 @@
 
 namespace facebook::velox::core {
 
+enum class ExprKind : int32_t {
+  kInput = 0,
+  kFieldAccess = 1,
+  kDereference = 2,
+  kCall = 3,
+  kCast = 5,
+  kConstant = 6,
+  kConcat = 7,
+  kLambda = 8,
+};
+
+VELOX_DECLARE_ENUM_NAME(ExprKind);
+
 class ITypedExpr;
 class ITypedExprVisitor;
 class ITypedExprVisitorContext;
 
 using TypedExprPtr = std::shared_ptr<const ITypedExpr>;
 
+struct ITypedExprHasher {
+  size_t operator()(const ITypedExpr* expr) const;
+};
+
+struct ITypedExprComparer {
+  bool operator()(const ITypedExpr* lhs, const ITypedExpr* rhs) const;
+};
+
 /// Strongly-typed expression, e.g. literal, function call, etc.
 class ITypedExpr : public ISerializable {
  public:
-  explicit ITypedExpr(TypePtr type) : type_{std::move(type)}, inputs_{} {}
+  ITypedExpr(ExprKind kind, TypePtr type)
+      : kind_{kind}, type_{std::move(type)}, inputs_{} {}
+
+  ITypedExpr(ExprKind kind, TypePtr type, std::vector<TypedExprPtr> inputs)
+      : kind_{kind}, type_{std::move(type)}, inputs_{std::move(inputs)} {}
 
-  ITypedExpr(TypePtr type, std::vector<TypedExprPtr> inputs)
-      : type_{std::move(type)}, inputs_{std::move(inputs)} {}
+  virtual ~ITypedExpr() = default;
+
+  ExprKind kind() const {
+    return kind_;
+  }
 
   const TypePtr& type() const {
     return type_;
   }
 
-  virtual ~ITypedExpr() = default;
-
   const std::vector<TypedExprPtr>& inputs() const {
     return inputs_;
   }
 
+  bool isInputKind() const {
+    return kind_ == ExprKind::kInput;
+  }
+
+  bool isFieldAccessKind() const {
+    return kind_ == ExprKind::kFieldAccess;
+  }
+
+  bool isDereferenceKind() const {
+    return kind_ == ExprKind::kDereference;
+  }
+
+  bool isCallKind() const {
+    return kind_ == ExprKind::kCall;
+  }
+
+  bool isCastKind() const {
+    return kind_ == ExprKind::kCast;
+  }
+
+  bool isConstantKind() const {
+    return kind_ == ExprKind::kConstant;
+  }
+
+  bool isConcatKind() const {
+    return kind_ == ExprKind::kConcat;
+  }
+
+  bool isLambdaKind() const {
+    return kind_ == ExprKind::kLambda;
+  }
+
+  template <typename T>
+  const T* asUnchecked() const {
+    return dynamic_cast<const T*>(this);
+  }
+
   /// Returns a copy of this expression with input fields replaced according
   /// to specified 'mapping'. Fields specified in the 'mapping' are replaced
   /// by the corresponding expression in 'mapping'.
@@ -64,7 +127,7 @@ class ITypedExpr : public ISerializable {
 
   size_t hash() const {
     size_t hash = bits::hashMix(type_->hashKind(), localHash());
-    for (int32_t i = 0; i < inputs_.size(); ++i) {
+    for (size_t i = 0; i < inputs_.size(); ++i) {
       hash = bits::hashMix(hash, inputs_[i]->hash());
     }
     return hash;
@@ -88,8 +151,9 @@ class ITypedExpr : public ISerializable {
   }
 
  private:
-  TypePtr type_;
-  std::vector<TypedExprPtr> inputs_;
+  const ExprKind kind_;
+  const TypePtr type_;
+  const std::vector<TypedExprPtr> inputs_;
 };
 
 } // namespace facebook::velox::core
diff --git a/velox/core/Metaprogramming.h b/velox/core/Metaprogramming.h
index 955ea4122b46..95906ef21406 100644
--- a/velox/core/Metaprogramming.h
+++ b/velox/core/Metaprogramming.h
@@ -124,11 +124,10 @@ 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/PlanConsistencyChecker.cpp b/velox/core/PlanConsistencyChecker.cpp
new file mode 100644
index 000000000000..fa20ce268aee
--- /dev/null
+++ b/velox/core/PlanConsistencyChecker.cpp
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/PlanConsistencyChecker.h"
+
+namespace facebook::velox::core {
+
+namespace {
+
+class Checker : public PlanNodeVisitor {
+ public:
+  void visit(const AggregationNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    const auto& rowType = node.sources().at(0)->outputType();
+    for (const auto& expr : node.groupingKeys()) {
+      checkInputs(expr, rowType);
+    }
+
+    for (const auto& expr : node.preGroupedKeys()) {
+      checkInputs(expr, rowType);
+    }
+
+    for (const auto& aggregate : node.aggregates()) {
+      checkInputs(aggregate.call, rowType);
+
+      for (const auto& expr : aggregate.sortingKeys) {
+        checkInputs(expr, rowType);
+      }
+
+      if (aggregate.mask) {
+        checkInputs(aggregate.mask, rowType);
+      }
+    }
+
+    verifyOutputNames(node);
+
+    visitSources(&node, ctx);
+  }
+
+  void visit(const ArrowStreamNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const AssignUniqueIdNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const EnforceSingleRowNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const ExchangeNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const ExpandNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const FilterNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    checkInputs(node.filter(), node.sources().at(0)->outputType());
+
+    visitSources(&node, ctx);
+  }
+
+  void visit(const GroupIdNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const HashJoinNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    std::unordered_set<std::pair<std::string, std::string>> keyNames;
+    for (auto i = 0; i < node.leftKeys().size(); ++i) {
+      const auto& leftKey = node.leftKeys().at(i);
+      const auto& rightKey = node.rightKeys().at(i);
+
+      bool unique = keyNames.emplace(leftKey->name(), rightKey->name()).second;
+      VELOX_CHECK(
+          unique,
+          "Duplicate join condition: {} = {}",
+          leftKey->toString(),
+          rightKey->toString());
+    }
+
+    if (node.filter() != nullptr) {
+      const auto& leftRowType = node.sources().at(0)->outputType();
+      const auto& rightRowType = node.sources().at(1)->outputType();
+      auto rowType = leftRowType->unionWith(rightRowType);
+      checkInputs(node.filter(), rowType);
+    }
+
+    visitSources(&node, ctx);
+  }
+
+  void visit(const IndexLookupJoinNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const LimitNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const LocalMergeNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const LocalPartitionNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const MarkDistinctNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const MergeExchangeNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const MergeJoinNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const NestedLoopJoinNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const SpatialJoinNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const OrderByNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const PartitionedOutputNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const ProjectNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    const auto& rowType = node.sources().at(0)->outputType();
+    for (const auto& expr : node.projections()) {
+      checkInputs(expr, rowType);
+    }
+
+    verifyOutputNames(node);
+
+    visitSources(&node, ctx);
+  }
+
+  void visit(const ParallelProjectNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    const auto& rowType = node.sources().at(0)->outputType();
+    for (const auto& group : node.exprGroups()) {
+      for (const auto& expr : group) {
+        checkInputs(expr, rowType);
+      }
+    }
+    visitSources(&node, ctx);
+  }
+
+  void visit(const RowNumberNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const TableScanNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    verifyOutputNames(node);
+
+    // Verify assignments match outputType 1:1.
+    const auto& names = node.outputType()->names();
+    VELOX_USER_CHECK_EQ(
+        names.size(),
+        node.assignments().size(),
+        "Column assignments must match output type 1:1.");
+
+    for (const auto& name : names) {
+      VELOX_USER_CHECK(
+          node.assignments().contains(name),
+          "Column assignment is missing for {}",
+          name);
+    }
+  }
+
+  void visit(const TableWriteNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const TableWriteMergeNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const TopNNode& node, PlanNodeVisitorContext& ctx) const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const TopNRowNumberNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const TraceScanNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const UnnestNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const ValuesNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const WindowNode& node, PlanNodeVisitorContext& ctx)
+      const override {
+    visitSources(&node, ctx);
+  }
+
+  void visit(const PlanNode& node, PlanNodeVisitorContext& ctx) const override {
+    visitSources(&node, ctx);
+  }
+
+ private:
+  void visitSources(const PlanNode* node, PlanNodeVisitorContext& ctx) const {
+    for (auto& source : node->sources()) {
+      source->accept(*this, ctx);
+    }
+  }
+
+  // Verify that output column names are not empty and unique.
+  static void verifyOutputNames(const PlanNode& node) {
+    folly::F14FastSet<std::string_view> names;
+    for (const auto& name : node.outputType()->names()) {
+      VELOX_USER_CHECK(!name.empty(), "Output column name cannot be empty");
+      VELOX_USER_CHECK(
+          names.emplace(name).second, "Duplicate output column: {}", name);
+    }
+  }
+
+  static void checkInputs(
+      const core::TypedExprPtr& expr,
+      const RowTypePtr& rowType) {
+    if (expr->isFieldAccessKind()) {
+      auto fieldAccess = expr->asUnchecked<core::FieldAccessTypedExpr>();
+      if (fieldAccess->isInputColumn()) {
+        // Verify that field name points to an existing column in the input and
+        // the type matches.
+        const auto& name = fieldAccess->name();
+        const auto& type = fieldAccess->type();
+        const auto& expectedType = rowType->findChild(fieldAccess->name());
+        VELOX_USER_CHECK(
+            *type == *expectedType,
+            "Wrong type of input column: {}, {} vs. {}",
+            name,
+            type->toString(),
+            expectedType->toString());
+      }
+    }
+
+    if (expr->isLambdaKind()) {
+      const auto& lambda = expr->asUnchecked<core::LambdaTypedExpr>();
+      checkInputs(lambda->body(), lambda->signature()->unionWith(rowType));
+    }
+
+    for (const auto& input : expr->inputs()) {
+      checkInputs(input, rowType);
+    }
+  }
+};
+} // namespace
+
+void PlanConsistencyChecker::check(const core::PlanNodePtr& plan) {
+  PlanNodeVisitorContext ctx;
+  Checker checker;
+  plan->accept(checker, ctx);
+}
+}; // namespace facebook::velox::core
diff --git a/velox/core/PlanConsistencyChecker.h b/velox/core/PlanConsistencyChecker.h
new file mode 100644
index 000000000000..1268a3cc65f5
--- /dev/null
+++ b/velox/core/PlanConsistencyChecker.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 "velox/core/PlanNode.h"
+
+namespace facebook::velox::core {
+
+/// Verify integrity of the plan. Specifically, verify that expressions used in
+/// Filter, Project and ParallelProject nodes reference input columns using
+/// valid names and types.
+class PlanConsistencyChecker {
+ public:
+  static void check(const core::PlanNodePtr& plan);
+};
+} // namespace facebook::velox::core
diff --git a/velox/core/PlanFragment.cpp b/velox/core/PlanFragment.cpp
index cfed635dc1c0..1799ca8be1ec 100644
--- a/velox/core/PlanFragment.cpp
+++ b/velox/core/PlanFragment.cpp
@@ -28,11 +28,10 @@ bool PlanFragment::canSpill(const QueryConfig& queryConfig) const {
              }) != nullptr;
 }
 
-bool PlanFragment::supportsBarrier() const {
+const PlanNode* PlanFragment::firstNodeNotSupportingBarrier() const {
   return PlanNode::findFirstNode(
-             planNode.get(), [&](const core::PlanNode* node) {
-               return !node->supportsBarrier();
-             }) == nullptr;
+      planNode.get(),
+      [&](const core::PlanNode* node) { return !node->supportsBarrier(); });
 }
 
 std::string executionStrategyToString(ExecutionStrategy strategy) {
diff --git a/velox/core/PlanFragment.h b/velox/core/PlanFragment.h
index 98cd64f0405b..4724a0d62eec 100644
--- a/velox/core/PlanFragment.h
+++ b/velox/core/PlanFragment.h
@@ -62,8 +62,9 @@ struct PlanFragment {
         groupedExecutionLeafNodeIds.end();
   }
 
-  /// Returns true if all plan nodes support barrier.
-  bool supportsBarrier() const;
+  /// Returns first node that does not support barrier.
+  /// Returns nullptr if all nodes support barrier.
+  const PlanNode* firstNodeNotSupportingBarrier() const;
 
   /// Returns true if the spilling is enabled and there is at least one node in
   /// the plan, whose operator can spill. Returns false otherwise.
diff --git a/velox/core/PlanNode.cpp b/velox/core/PlanNode.cpp
index d4e94654f614..2f0e0a7aff42 100644
--- a/velox/core/PlanNode.cpp
+++ b/velox/core/PlanNode.cpp
@@ -15,12 +15,12 @@
  */
 #include <folly/container/F14Set.h>
 
+#include "velox/common/Casts.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) {
@@ -51,12 +51,19 @@ IndexLookupConditionPtr createIndexJoinCondition(
   if (obj["type"] == "between") {
     return BetweenIndexLookupCondition::create(obj, context);
   }
+  if (obj["type"] == "equal") {
+    return EqualIndexLookupCondition::create(obj, context);
+  }
   VELOX_USER_FAIL(
       "Unknown index join condition type {}", obj["type"].asString());
 }
 } // namespace
 
-std::vector<IndexLookupConditionPtr> deserializeJoinConditions(
+/// Deserializes lookup conditions from dynamic object for index lookup joins.
+/// These conditions are more complex than simple equality join conditions and
+/// can include IN, BETWEEN, and EQUAL conditions that involve both left and
+/// right side columns.
+std::vector<IndexLookupConditionPtr> deserializejoinConditions(
     const folly::dynamic& obj,
     void* context) {
   if (obj.count("joinConditions") == 0) {
@@ -81,6 +88,15 @@ PlanNodePtr deserializeSingleSource(const folly::dynamic& obj, void* context) {
 PlanNodeId deserializePlanNodeId(const folly::dynamic& obj) {
   return obj["id"].asString();
 }
+
+template <typename K, typename V>
+std::unordered_map<V, K> invertMap(const std::unordered_map<K, V>& mapping) {
+  std::unordered_map<V, K> inverted;
+  for (const auto& [key, value] : mapping) {
+    inverted.emplace(value, key);
+  }
+  return inverted;
+}
 } // namespace
 
 const SortOrder kAscNullsFirst(true, true);
@@ -150,6 +166,7 @@ AggregationNode::AggregationNode(
     const std::vector<vector_size_t>& globalGroupingSets,
     const std::optional<FieldAccessTypedExprPtr>& groupId,
     bool ignoreNullKeys,
+    bool noGroupsSpanBatches,
     PlanNodePtr source)
     : PlanNode(id),
       step_(step),
@@ -160,6 +177,7 @@ AggregationNode::AggregationNode(
       ignoreNullKeys_(ignoreNullKeys),
       groupId_(groupId),
       globalGroupingSets_(globalGroupingSets),
+      noGroupsSpanBatches_(noGroupsSpanBatches),
       sources_{source},
       outputType_(getAggregationOutputType(
           groupingKeys_,
@@ -204,6 +222,10 @@ AggregationNode::AggregationNode(
     VELOX_USER_CHECK(
         groupId_.has_value(), "Global grouping sets require GroupId key");
   }
+
+  VELOX_USER_CHECK(
+      !noGroupsSpanBatches_ || isPreGrouped(),
+      "noGroupsSpanBatches can only be set for streaming aggregation (pre-grouped)");
 }
 
 AggregationNode::AggregationNode(
@@ -214,6 +236,7 @@ AggregationNode::AggregationNode(
     const std::vector<std::string>& aggregateNames,
     const std::vector<Aggregate>& aggregates,
     bool ignoreNullKeys,
+    bool noGroupsSpanBatches,
     PlanNodePtr source)
     : AggregationNode(
           id,
@@ -225,6 +248,7 @@ AggregationNode::AggregationNode(
           kDefaultGlobalGroupingSets,
           kDefaultGroupId,
           ignoreNullKeys,
+          noGroupsSpanBatches,
           source) {}
 
 namespace {
@@ -281,7 +305,7 @@ bool AggregationNode::canSpill(const QueryConfig& queryConfig) const {
 }
 
 void AggregationNode::addDetails(std::stringstream& stream) const {
-  stream << stepName(step_) << " ";
+  stream << toName(step_) << " ";
 
   if (isPreGrouped()) {
     stream << "STREAMING ";
@@ -319,47 +343,31 @@ void AggregationNode::addDetails(std::stringstream& stream) const {
   if (groupId_.has_value()) {
     stream << " Group Id key: " << groupId_.value()->name();
   }
+
+  if (noGroupsSpanBatches_) {
+    stream << " noGroupsSpanBatches";
+  }
 }
 
 namespace {
-std::unordered_map<AggregationNode::Step, std::string> stepNames() {
-  return {
-      {AggregationNode::Step::kPartial, "PARTIAL"},
-      {AggregationNode::Step::kFinal, "FINAL"},
-      {AggregationNode::Step::kIntermediate, "INTERMEDIATE"},
-      {AggregationNode::Step::kSingle, "SINGLE"},
-  };
+const auto& stepNames() {
+  static const folly::F14FastMap<AggregationNode::Step, std::string_view>
+      kNames = {
+          {AggregationNode::Step::kPartial, "PARTIAL"},
+          {AggregationNode::Step::kFinal, "FINAL"},
+          {AggregationNode::Step::kIntermediate, "INTERMEDIATE"},
+          {AggregationNode::Step::kSingle, "SINGLE"},
+      };
+  return kNames;
 }
 
-template <typename K, typename V>
-std::unordered_map<V, K> invertMap(const std::unordered_map<K, V>& mapping) {
-  std::unordered_map<V, K> inverted;
-  for (const auto& [key, value] : mapping) {
-    inverted.emplace(value, key);
-  }
-  return inverted;
-}
 } // namespace
 
-// static
-const char* AggregationNode::stepName(AggregationNode::Step step) {
-  static const auto kSteps = stepNames();
-  auto it = kSteps.find(step);
-  VELOX_CHECK(it != kSteps.end(), "Invalid step {}", static_cast<int>(step));
-  return it->second.c_str();
-}
-
-// static
-AggregationNode::Step AggregationNode::stepFromName(const std::string& name) {
-  static const auto kSteps = invertMap(stepNames());
-  auto it = kSteps.find(name);
-  VELOX_CHECK(it != kSteps.end(), "Invalid step " + name);
-  return it->second;
-}
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(AggregationNode, Step, stepNames)
 
 folly::dynamic AggregationNode::serialize() const {
   auto obj = PlanNode::serialize();
-  obj["step"] = stepName(step_);
+  obj["step"] = toName(step_);
   obj["groupingKeys"] = ISerializable::serialize(groupingKeys_);
   obj["preGroupedKeys"] = ISerializable::serialize(preGroupedKeys_);
   obj["aggregateNames"] = ISerializable::serialize(aggregateNames_);
@@ -377,6 +385,7 @@ folly::dynamic AggregationNode::serialize() const {
     obj["groupId"] = ISerializable::serialize(groupId_.value());
   }
   obj["ignoreNullKeys"] = ignoreNullKeys_;
+  obj["noGroupsSpanBatches"] = noGroupsSpanBatches_;
   return obj;
 }
 
@@ -394,6 +403,10 @@ std::vector<FieldAccessTypedExprPtr> deserializeFields(
       array, context);
 }
 
+FieldAccessTypedExprPtr deserializeField(const folly::dynamic& obj) {
+  return ISerializable::deserialize<FieldAccessTypedExpr>(obj);
+}
+
 std::vector<std::string> deserializeStrings(const folly::dynamic& array) {
   return ISerializable::deserialize<std::vector<std::string>>(array);
 }
@@ -439,12 +452,13 @@ folly::dynamic AggregationNode::Aggregate::serialize() const {
 AggregationNode::Aggregate AggregationNode::Aggregate::deserialize(
     const folly::dynamic& obj,
     void* context) {
-  auto call = ISerializable::deserialize<CallTypedExpr>(obj["call"]);
+  auto call = ISerializable::deserialize<CallTypedExpr>(obj["call"], context);
   auto rawInputTypes =
       ISerializable::deserialize<std::vector<Type>>(obj["rawInputTypes"]);
   FieldAccessTypedExprPtr mask;
   if (obj.count("mask")) {
-    mask = ISerializable::deserialize<FieldAccessTypedExpr>(obj["mask"]);
+    mask =
+        ISerializable::deserialize<FieldAccessTypedExpr>(obj["mask"], context);
   }
   auto sortingKeys = deserializeFields(obj["sortingKeys"], context);
   auto sortingOrders = deserializeSortingOrders(obj["sortingOrders"]);
@@ -484,7 +498,7 @@ PlanNodePtr AggregationNode::create(const folly::dynamic& obj, void* context) {
 
   return std::make_shared<AggregationNode>(
       deserializePlanNodeId(obj),
-      stepFromName(obj["step"].asString()),
+      toStep(obj["step"].asString()),
       groupingKeys,
       preGroupedKeys,
       aggregateNames,
@@ -492,6 +506,8 @@ PlanNodePtr AggregationNode::create(const folly::dynamic& obj, void* context) {
       globalGroupingSets,
       groupId,
       obj["ignoreNullKeys"].asBool(),
+      obj.count("noGroupsSpanBatches") ? obj["noGroupsSpanBatches"].asBool()
+                                       : false,
       deserializeSingleSource(obj, context));
 }
 
@@ -701,7 +717,8 @@ PlanNodePtr GroupIdNode::create(const folly::dynamic& obj, void* context) {
   for (const auto& info : obj["groupingKeyInfos"]) {
     groupingKeyInfos.push_back(
         {info["output"].asString(),
-         ISerializable::deserialize<FieldAccessTypedExpr>(info["input"])});
+         ISerializable::deserialize<FieldAccessTypedExpr>(
+             info["input"], context)});
   }
 
   auto groupingSets =
@@ -783,6 +800,22 @@ PlanNodePtr ValuesNode::create(const folly::dynamic& obj, void* context) {
       obj["repeatTimes"].asInt());
 }
 
+// static
+RowTypePtr AbstractProjectNode::makeOutputType(
+    const std::vector<std::string>& names,
+    const std::vector<TypedExprPtr>& projections) {
+  VELOX_USER_CHECK_EQ(names.size(), projections.size());
+
+  std::vector<TypePtr> types;
+  types.reserve(projections.size());
+  for (const auto& projection : projections) {
+    types.push_back(projection->type());
+  }
+
+  auto namesCopy = names;
+  return ROW(std::move(namesCopy), std::move(types));
+}
+
 void AbstractProjectNode::addDetails(std::stringstream& stream) const {
   stream << "expressions: ";
   for (auto i = 0; i < projections_.size(); i++) {
@@ -863,7 +896,11 @@ class SummarizeExprVisitor : public ITypedExprVisitor {
   void visit(const FieldAccessTypedExpr& expr, ITypedExprVisitorContext& ctx)
       const override {
     auto& myCtx = static_cast<Context&>(ctx);
-    myCtx.expressionCounts()["field"]++;
+    if (expr.isInputColumn()) {
+      myCtx.expressionCounts()["field"]++;
+    } else {
+      myCtx.expressionCounts()["dereference"]++;
+    }
     visitInputs(expr, ctx);
   }
 
@@ -992,6 +1029,12 @@ void AbstractProjectNode::addSummaryDetails(
   SummarizeExprVisitor::Context exprCtx;
   SummarizeExprVisitor visitor;
   for (const auto& projection : projections_) {
+    // Skip identity projections.
+    if (projection->isFieldAccessKind() &&
+        projection->asUnchecked<FieldAccessTypedExpr>()->isInputColumn()) {
+      continue;
+    }
+
     projection->accept(visitor, exprCtx);
   }
 
@@ -1006,12 +1049,17 @@ void AbstractProjectNode::addSummaryDetails(
   std::vector<size_t> dereferences;
   dereferences.reserve(numFields);
 
+  std::vector<size_t> constants;
+  constants.reserve(numFields);
+
   for (auto i = 0; i < numFields; ++i) {
     const auto& expr = projections_[i];
-    if (dynamic_cast<const DereferenceTypedExpr*>(expr.get())) {
+    if (expr->isDereferenceKind()) {
       dereferences.push_back(i);
+    } else if (expr->isConstantKind()) {
+      constants.push_back(i);
     } else {
-      auto fae = dynamic_cast<const FieldAccessTypedExpr*>(expr.get());
+      auto fae = expr->asUnchecked<FieldAccessTypedExpr>();
       if (fae == nullptr) {
         projections.push_back(i);
       } else if (!fae->isInputColumn()) {
@@ -1021,33 +1069,53 @@ void AbstractProjectNode::addSummaryDetails(
   }
 
   // projections: 4 out of 10
-  stream << indentation << "projections: " << projections.size() << " out of "
-         << numFields << std::endl;
-  {
-    const auto cnt =
-        std::min(options.project.maxProjections, projections.size());
-    appendProjections(
-        indentation + "   ",
-        *this,
-        projections,
-        cnt,
-        stream,
-        options.maxLength);
+  if (!projections.empty()) {
+    stream << indentation << "projections: " << projections.size() << " out of "
+           << numFields << std::endl;
+    {
+      const auto cnt =
+          std::min(options.project.maxProjections, projections.size());
+      appendProjections(
+          indentation + "   ",
+          *this,
+          projections,
+          cnt,
+          stream,
+          options.maxLength);
+    }
   }
 
   // dereferences: 2 out of 10
-  stream << indentation << "dereferences: " << dereferences.size() << " out of "
-         << numFields << std::endl;
-  {
-    const auto cnt =
-        std::min(options.project.maxDereferences, dereferences.size());
-    appendProjections(
-        indentation + "   ",
-        *this,
-        dereferences,
-        cnt,
-        stream,
-        options.maxLength);
+  if (!dereferences.empty()) {
+    stream << indentation << "dereferences: " << dereferences.size()
+           << " out of " << numFields << std::endl;
+    {
+      const auto cnt =
+          std::min(options.project.maxDereferences, dereferences.size());
+      appendProjections(
+          indentation + "   ",
+          *this,
+          dereferences,
+          cnt,
+          stream,
+          options.maxLength);
+    }
+  }
+
+  // constants: 1 out of 10
+  if (!constants.empty()) {
+    stream << indentation << "constant projections: " << constants.size()
+           << " out of " << numFields << std::endl;
+    {
+      const auto cnt = std::min(options.project.maxConstants, constants.size());
+      appendProjections(
+          indentation + "   ",
+          *this,
+          constants,
+          cnt,
+          stream,
+          options.maxLength);
+    }
   }
 }
 
@@ -1078,6 +1146,122 @@ PlanNodePtr ProjectNode::create(const folly::dynamic& obj, void* context) {
       std::move(source));
 }
 
+namespace {
+// makes a list of all names for use in the ProjectNode.
+std::vector<std::string> allNames(
+    const std::vector<std::string>& names,
+    const std::vector<std::string>& moreNames) {
+  auto result = names;
+  result.insert(result.cend(), moreNames.cbegin(), moreNames.cend());
+  return result;
+}
+
+// Flattens out projection exprs and adds dummy  exprs for noLoadIdentities.
+// Used to fill in ProjectNode members for use in the summary functions.
+std::vector<TypedExprPtr> flattenExprs(
+    const std::vector<std::vector<TypedExprPtr>>& exprs,
+    const std::vector<std::string>& moreNames,
+    const PlanNodePtr& input) {
+  std::vector<TypedExprPtr> result;
+  for (auto& group : exprs) {
+    result.insert(result.cend(), group.cbegin(), group.cend());
+  }
+
+  const auto& sourceType = input->outputType();
+  for (auto& name : moreNames) {
+    result.push_back(
+        std::make_shared<FieldAccessTypedExpr>(
+            sourceType->findChild(name), name));
+  }
+  return result;
+}
+} // namespace
+
+ParallelProjectNode::ParallelProjectNode(
+    const PlanNodeId& id,
+    std::vector<std::string> names,
+    std::vector<std::vector<TypedExprPtr>> exprGroups,
+    std::vector<std::string> noLoadIdentities,
+    PlanNodePtr input)
+    : AbstractProjectNode(
+          id,
+          allNames(names, noLoadIdentities),
+          flattenExprs(exprGroups, noLoadIdentities, input),
+          input),
+      exprNames_(std::move(names)),
+      exprGroups_(std::move(exprGroups)),
+      noLoadIdentities_(std::move(noLoadIdentities)) {
+  VELOX_USER_CHECK(!exprNames_.empty());
+  VELOX_USER_CHECK(!exprGroups_.empty());
+
+  for (const auto& group : exprGroups_) {
+    VELOX_USER_CHECK(!group.empty());
+  }
+}
+
+void ParallelProjectNode::addDetails(std::stringstream& stream) const {
+  AbstractProjectNode::addDetails(stream);
+  stream << " Parallel expr groups: ";
+  int32_t start = 0;
+  for (auto i = 0; i < exprGroups_.size(); ++i) {
+    if (i > 0) {
+      stream << ", ";
+    }
+    stream << fmt::format("[{}-{}]", start, start + exprGroups_[i].size() - 1);
+    start += exprGroups_[i].size();
+  }
+  stream << std::endl;
+}
+
+folly::dynamic ParallelProjectNode::serialize() const {
+  auto obj = PlanNode::serialize();
+  obj["names"] = ISerializable::serialize(exprNames_);
+  obj["projections"] = ISerializable::serialize(exprGroups_);
+  obj["noLoadIdentities"] = ISerializable::serialize(noLoadIdentities_);
+  return obj;
+}
+
+void ParallelProjectNode::accept(
+    const PlanNodeVisitor& visitor,
+    PlanNodeVisitorContext& context) const {
+  visitor.visit(*this, context);
+}
+
+// static
+PlanNodePtr ParallelProjectNode::create(
+    const folly::dynamic& obj,
+    void* context) {
+  auto source = deserializeSingleSource(obj, context);
+
+  auto names = deserializeStrings(obj["names"]);
+  auto projections =
+      ISerializable::deserialize<std::vector<std::vector<ITypedExpr>>>(
+          obj["projections"], context);
+  auto noLoadIdentities = deserializeStrings(obj["noLoadIdentities"]);
+  return std::make_shared<ParallelProjectNode>(
+      deserializePlanNodeId(obj),
+      std::move(names),
+      std::move(projections),
+      std::move(noLoadIdentities),
+      std::move(source));
+}
+
+// static
+PlanNodePtr LazyDereferenceNode::create(
+    const folly::dynamic& obj,
+    void* context) {
+  auto source = deserializeSingleSource(obj, context);
+
+  auto names = deserializeStrings(obj["names"]);
+  auto projections = ISerializable::deserialize<std::vector<ITypedExpr>>(
+      obj["projections"], context);
+  return std::make_shared<LazyDereferenceNode>(
+      deserializePlanNodeId(obj),
+      std::move(names),
+      std::move(projections),
+      std::move(source));
+}
+
 const std::vector<PlanNodePtr>& TableScanNode::sources() const {
   return kEmptySources;
 }
@@ -1092,6 +1276,13 @@ void TableScanNode::addDetails(std::stringstream& stream) const {
   stream << tableHandle_->toString();
 }
 
+void TableScanNode::addSummaryDetails(
+    const std::string& indentation,
+    const PlanSummaryOptions& /* options */,
+    std::stringstream& stream) const {
+  stream << indentation << tableHandle_->toString() << std::endl;
+}
+
 folly::dynamic TableScanNode::serialize() const {
   auto obj = PlanNode::serialize();
   obj["outputType"] = outputType_->serialize();
@@ -1111,18 +1302,16 @@ folly::dynamic TableScanNode::serialize() const {
 PlanNodePtr TableScanNode::create(const folly::dynamic& obj, void* context) {
   auto planNodeId = obj["id"].asString();
   auto outputType = deserializeRowType(obj["outputType"]);
-  auto tableHandle = std::const_pointer_cast<connector::ConnectorTableHandle>(
+  auto tableHandle =
       ISerializable::deserialize<connector::ConnectorTableHandle>(
-          obj["tableHandle"], context));
+          obj["tableHandle"], context);
 
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
   for (const auto& pair : obj["assignments"]) {
     auto assign = pair["assign"].asString();
     auto columnHandle = ISerializable::deserialize<connector::ColumnHandle>(
-        pair["columnHandle"]);
-    assignments[assign] =
-        std::const_pointer_cast<connector::ColumnHandle>(columnHandle);
+        pair["columnHandle"], context);
+    assignments[assign] = std::move(columnHandle);
   }
 
   return std::make_shared<const TableScanNode>(
@@ -1178,12 +1367,14 @@ UnnestNode::UnnestNode(
     std::vector<FieldAccessTypedExprPtr> unnestVariables,
     std::vector<std::string> unnestNames,
     std::optional<std::string> ordinalityName,
+    std::optional<std::string> markerName,
     const PlanNodePtr& source)
     : PlanNode(id),
       replicateVariables_{std::move(replicateVariables)},
       unnestVariables_{std::move(unnestVariables)},
       unnestNames_{std::move(unnestNames)},
       ordinalityName_{std::move(ordinalityName)},
+      markerName_(std::move(markerName)),
       sources_{source} {
   // Calculate output type. First come "replicate" columns, followed by
   // "unnest" columns, followed by an optional ordinality column.
@@ -1219,6 +1410,12 @@ UnnestNode::UnnestNode(
     names.emplace_back(ordinalityName_.value());
     types.emplace_back(BIGINT());
   }
+
+  if (markerName_.has_value()) {
+    names.emplace_back(markerName_.value());
+    types.emplace_back(BOOLEAN());
+  }
+
   outputType_ = ROW(std::move(names), std::move(types));
 }
 
@@ -1235,6 +1432,9 @@ folly::dynamic UnnestNode::serialize() const {
   if (ordinalityName_.has_value()) {
     obj["ordinalityName"] = ordinalityName_.value();
   }
+  if (markerName_.has_value()) {
+    obj["markerName"] = markerName_.value();
+  }
   return obj;
 }
 
@@ -1255,13 +1455,17 @@ PlanNodePtr UnnestNode::create(const folly::dynamic& obj, void* context) {
   if (obj.count("ordinalityName")) {
     ordinalityName = obj["ordinalityName"].asString();
   }
-
+  std::optional<std::string> markerName = std::nullopt;
+  if (obj.count("markerName")) {
+    markerName = obj["markerName"].asString();
+  }
   return std::make_shared<UnnestNode>(
       deserializePlanNodeId(obj),
       std::move(replicateVariables),
       std::move(unnestVariables),
       std::move(unnestNames),
-      ordinalityName,
+      std::move(ordinalityName),
+      std::move(markerName),
       std::move(source));
 }
 
@@ -1280,21 +1484,23 @@ AbstractJoinNode::AbstractJoinNode(
       rightKeys_(rightKeys),
       filter_(std::move(filter)),
       sources_({std::move(left), std::move(right)}),
-      outputType_(std::move(outputType)) {
+      outputType_(std::move(outputType)) {}
+
+void AbstractJoinNode::validate() const {
   VELOX_CHECK(!leftKeys_.empty(), "JoinNode requires at least one join key");
   VELOX_CHECK_EQ(
       leftKeys_.size(),
       rightKeys_.size(),
       "JoinNode requires same number of join keys on left and right sides");
   auto leftType = sources_[0]->outputType();
-  for (auto key : leftKeys_) {
+  for (const auto& key : leftKeys_) {
     VELOX_CHECK(
         leftType->containsChild(key->name()),
         "Left side join key not found in left side output: {}",
         key->name());
   }
   auto rightType = sources_[1]->outputType();
-  for (auto key : rightKeys_) {
+  for (const auto& key : rightKeys_) {
     VELOX_CHECK(
         rightType->containsChild(key->name()),
         "Right side join key not found in right side output: {}",
@@ -1307,32 +1513,29 @@ AbstractJoinNode::AbstractJoinNode(
         "Join key types on the left and right sides must match");
   }
 
-  auto numOutputColumms = outputType_->size();
-  if (core::isLeftSemiProjectJoin(joinType) ||
-      core::isRightSemiProjectJoin(joinType)) {
+  auto numOutputColumns = outputType_->size();
+  if (isLeftSemiProjectJoin() || isRightSemiProjectJoin()) {
     // Last output column must be a boolean 'match'.
-    --numOutputColumms;
-    VELOX_CHECK_EQ(outputType_->childAt(numOutputColumms), BOOLEAN());
+    --numOutputColumns;
+    VELOX_CHECK_EQ(outputType_->childAt(numOutputColumns), BOOLEAN());
 
     // Verify that 'match' column name doesn't match any column from left or
     // right source.
-    const auto& name = outputType_->nameOf(numOutputColumms);
+    const auto& name = outputType_->nameOf(numOutputColumns);
     VELOX_CHECK(!leftType->containsChild(name));
     VELOX_CHECK(!rightType->containsChild(name));
   }
 
   // Output of right semi join cannot include columns from the left side.
   bool outputMayIncludeLeftColumns =
-      !(core::isRightSemiFilterJoin(joinType) ||
-        core::isRightSemiProjectJoin(joinType));
+      !(isRightSemiFilterJoin() || isRightSemiProjectJoin());
 
   // Output of left semi and anti joins cannot include columns from the right
   // side.
   bool outputMayIncludeRightColumns =
-      !(core::isLeftSemiFilterJoin(joinType) ||
-        core::isLeftSemiProjectJoin(joinType) || core::isAntiJoin(joinType));
+      !(isLeftSemiFilterJoin() || isLeftSemiProjectJoin() || isAntiJoin());
 
-  for (auto i = 0; i < numOutputColumms; ++i) {
+  for (auto i = 0; i < numOutputColumns; ++i) {
     auto name = outputType_->nameOf(i);
     if (outputMayIncludeLeftColumns && leftType->containsChild(name)) {
       VELOX_CHECK(
@@ -1353,7 +1556,7 @@ AbstractJoinNode::AbstractJoinNode(
 }
 
 void AbstractJoinNode::addDetails(std::stringstream& stream) const {
-  stream << joinTypeName(joinType_) << " ";
+  stream << JoinTypeName::toName(joinType_) << " ";
 
   for (auto i = 0; i < leftKeys_.size(); ++i) {
     if (i > 0) {
@@ -1369,7 +1572,7 @@ void AbstractJoinNode::addDetails(std::stringstream& stream) const {
 
 folly::dynamic AbstractJoinNode::serializeBase() const {
   auto obj = PlanNode::serialize();
-  obj["joinType"] = joinTypeName(joinType_);
+  obj["joinType"] = JoinTypeName::toName(joinType_);
   obj["leftKeys"] = ISerializable::serialize(leftKeys_);
   obj["rightKeys"] = ISerializable::serialize(rightKeys_);
   if (filter_) {
@@ -1380,8 +1583,8 @@ folly::dynamic AbstractJoinNode::serializeBase() const {
 }
 
 namespace {
-std::unordered_map<JoinType, std::string> joinTypeNames() {
-  return {
+const auto& joinTypeNames() {
+  static const folly::F14FastMap<JoinType, std::string_view> kNames = {
       {JoinType::kInner, "INNER"},
       {JoinType::kLeft, "LEFT"},
       {JoinType::kRight, "RIGHT"},
@@ -1392,25 +1595,33 @@ std::unordered_map<JoinType, std::string> joinTypeNames() {
       {JoinType::kRightSemiProject, "RIGHT SEMI (PROJECT)"},
       {JoinType::kAnti, "ANTI"},
   };
+  return kNames;
 }
-} // namespace
 
-const char* joinTypeName(JoinType joinType) {
-  static const auto kJoinTypes = joinTypeNames();
-  auto it = kJoinTypes.find(joinType);
-  VELOX_CHECK(
-      it != kJoinTypes.end(),
-      "Invalid join type {}",
-      static_cast<int>(joinType));
-  return it->second.c_str();
+// Check that each output of the join is in exactly one of the inputs.
+void checkJoinColumnNames(
+    const RowTypePtr& leftType,
+    const RowTypePtr& rightType,
+    const RowTypePtr& outputType,
+    uint32_t numColumnsToCheck) {
+  for (auto i = 0; i < numColumnsToCheck; ++i) {
+    const auto name = outputType->nameOf(i);
+    const bool leftContains = leftType->containsChild(name);
+    const bool rightContains = rightType->containsChild(name);
+    VELOX_USER_CHECK(
+        !(leftContains && rightContains),
+        "Duplicate column name found on join's left and right sides: {}",
+        name);
+    VELOX_USER_CHECK(
+        leftContains || rightContains,
+        "Join's output column not found in either left or right sides: {}",
+        name);
+  }
 }
 
-JoinType joinTypeFromName(const std::string& name) {
-  static const auto kJoinTypes = invertMap(joinTypeNames());
-  auto it = kJoinTypes.find(name);
-  VELOX_CHECK(it != kJoinTypes.end(), "Invalid join type " + name);
-  return it->second;
-}
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(JoinType, joinTypeNames)
 
 void HashJoinNode::addDetails(std::stringstream& stream) const {
   AbstractJoinNode::addDetails(stream);
@@ -1422,6 +1633,7 @@ void HashJoinNode::addDetails(std::stringstream& stream) const {
 folly::dynamic HashJoinNode::serialize() const {
   auto obj = serializeBase();
   obj["nullAware"] = nullAware_;
+  obj["useHashTableCache"] = useHashTableCache_;
   return obj;
 }
 
@@ -1437,26 +1649,28 @@ PlanNodePtr HashJoinNode::create(const folly::dynamic& obj, void* context) {
   VELOX_CHECK_EQ(2, sources.size());
 
   auto nullAware = obj["nullAware"].asBool();
+  auto useHashTableCache = obj.getDefault("useHashTableCache", false).asBool();
   auto leftKeys = deserializeFields(obj["leftKeys"], context);
   auto rightKeys = deserializeFields(obj["rightKeys"], context);
 
   TypedExprPtr filter;
   if (obj.count("filter")) {
-    filter = ISerializable::deserialize<ITypedExpr>(obj["filter"]);
+    filter = ISerializable::deserialize<ITypedExpr>(obj["filter"], context);
   }
 
   auto outputType = deserializeRowType(obj["outputType"]);
 
   return std::make_shared<HashJoinNode>(
       deserializePlanNodeId(obj),
-      joinTypeFromName(obj["joinType"].asString()),
+      JoinTypeName::toJoinType(obj["joinType"].asString()),
       nullAware,
       std::move(leftKeys),
       std::move(rightKeys),
       filter,
       sources[0],
       sources[1],
-      outputType);
+      outputType,
+      useHashTableCache);
 }
 
 MergeJoinNode::MergeJoinNode(
@@ -1477,10 +1691,11 @@ MergeJoinNode::MergeJoinNode(
           std::move(left),
           std::move(right),
           std::move(outputType)) {
+  validate();
   VELOX_USER_CHECK(
       isSupported(joinType_),
-      "The join type is not supported by merge join: ",
-      joinTypeName(joinType_));
+      "The join type is not supported by merge join: {}",
+      JoinTypeName::toName(joinType_));
 }
 
 folly::dynamic MergeJoinNode::serialize() const {
@@ -1488,15 +1703,15 @@ folly::dynamic MergeJoinNode::serialize() const {
 }
 
 // static
-bool MergeJoinNode::isSupported(core::JoinType joinType) {
+bool MergeJoinNode::isSupported(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:
+    case JoinType::kInner:
+    case JoinType::kLeft:
+    case JoinType::kRight:
+    case JoinType::kLeftSemiFilter:
+    case JoinType::kRightSemiFilter:
+    case JoinType::kAnti:
+    case JoinType::kFull:
       return true;
 
     default:
@@ -1520,14 +1735,14 @@ PlanNodePtr MergeJoinNode::create(const folly::dynamic& obj, void* context) {
 
   TypedExprPtr filter;
   if (obj.count("filter")) {
-    filter = ISerializable::deserialize<ITypedExpr>(obj["filter"]);
+    filter = ISerializable::deserialize<ITypedExpr>(obj["filter"], context);
   }
 
   auto outputType = deserializeRowType(obj["outputType"]);
 
   return std::make_shared<MergeJoinNode>(
       deserializePlanNodeId(obj),
-      joinTypeFromName(obj["joinType"].asString()),
+      JoinTypeName::toJoinType(obj["joinType"].asString()),
       std::move(leftKeys),
       std::move(rightKeys),
       filter,
@@ -1536,30 +1751,125 @@ PlanNodePtr MergeJoinNode::create(const folly::dynamic& obj, void* context) {
       outputType);
 }
 
+IndexLookupJoinNode::IndexLookupJoinNode(
+    const PlanNodeId& id,
+    JoinType joinType,
+    const std::vector<FieldAccessTypedExprPtr>& leftKeys,
+    const std::vector<FieldAccessTypedExprPtr>& rightKeys,
+    const std::vector<IndexLookupConditionPtr>& joinConditions,
+    TypedExprPtr filter,
+    bool hasMarker,
+    PlanNodePtr left,
+    TableScanNodePtr right,
+    RowTypePtr outputType)
+    : AbstractJoinNode(
+          id,
+          joinType,
+          leftKeys,
+          rightKeys,
+          std::move(filter),
+          std::move(left),
+          right,
+          outputType),
+      lookupSourceNode_(std::move(right)),
+      joinConditions_(joinConditions),
+      hasMarker_(hasMarker) {
+  VELOX_USER_CHECK(
+      !leftKeys.empty(),
+      "The index lookup join node requires at least one join key");
+  VELOX_USER_CHECK_EQ(
+      leftKeys_.size(),
+      rightKeys_.size(),
+      "The index lookup join node requires same number of join keys on left and right sides");
+
+  // TODO: add check that (1) 'rightKeys_' form an index prefix. each of
+  // 'joinConditions_' uses columns from both sides and uses exactly one index
+  // column from the right side.
+  VELOX_USER_CHECK(
+      lookupSourceNode_->tableHandle()->supportsIndexLookup(),
+      "The lookup table handle {} from connector {} doesn't support index lookup",
+      lookupSourceNode_->tableHandle()->name(),
+      lookupSourceNode_->tableHandle()->connectorId());
+  VELOX_USER_CHECK(
+      isSupported(joinType_),
+      "Unsupported index lookup join type {}",
+      JoinTypeName::toName(joinType_));
+
+  auto leftType = sources_[0]->outputType();
+  for (const auto& key : leftKeys_) {
+    VELOX_USER_CHECK(
+        leftType->containsChild(key->name()),
+        "Left side join key not found in left side output: {}",
+        key->name());
+  }
+  auto rightType = sources_[1]->outputType();
+  for (const auto& key : rightKeys_) {
+    VELOX_USER_CHECK(
+        rightType->containsChild(key->name()),
+        "Right side join key not found in right side output: {}",
+        key->name());
+  }
+  for (auto i = 0; i < leftKeys_.size(); ++i) {
+    VELOX_USER_CHECK_EQ(
+        leftKeys_[i]->type()->kind(),
+        rightKeys_[i]->type()->kind(),
+        "Index lookup koin key types on the left and right sides must match");
+  }
+
+  auto numOutputColumns = outputType_->size();
+  if (hasMarker_) {
+    VELOX_USER_CHECK(
+        isLeftJoin(),
+        "Index join match column can only present for {} but not {}",
+        JoinTypeName::toName(JoinType::kLeft),
+        JoinTypeName::toName(joinType_));
+    // Last output column must be a boolean 'match'.
+    --numOutputColumns;
+    VELOX_USER_CHECK_EQ(
+        outputType_->childAt(numOutputColumns),
+        BOOLEAN(),
+        "The last output column must be boolean type if match column is present");
+
+    // Verify that 'match' column name doesn't match any column from left or
+    // right source.
+    const auto& name = outputType_->nameOf(numOutputColumns);
+    VELOX_USER_CHECK(!leftType->containsChild(name));
+    VELOX_USER_CHECK(!rightType->containsChild(name));
+  }
+
+  checkJoinColumnNames(leftType, rightType, outputType_, numOutputColumns);
+}
+
 PlanNodePtr IndexLookupJoinNode::create(
     const folly::dynamic& obj,
     void* context) {
   auto sources = deserializeSources(obj, context);
   VELOX_CHECK_EQ(2, sources.size());
   TableScanNodePtr lookupSource =
-      std::dynamic_pointer_cast<const TableScanNode>(sources[1]);
-  VELOX_CHECK_NOT_NULL(lookupSource);
+      checkedPointerCast<const TableScanNode>(sources[1]);
 
   auto leftKeys = deserializeFields(obj["leftKeys"], context);
   auto rightKeys = deserializeFields(obj["rightKeys"], context);
 
-  VELOX_CHECK_EQ(obj.count("filter"), 0);
+  TypedExprPtr filter;
+  if (obj.count("filter")) {
+    filter = ISerializable::deserialize<ITypedExpr>(obj["filter"], context);
+  }
+
+  auto joinConditions = deserializejoinConditions(obj, context);
 
-  auto joinConditions = deserializeJoinConditions(obj, context);
+  const bool hasMarker = obj["hasMarker"].asBool();
 
   auto outputType = deserializeRowType(obj["outputType"]);
 
   return std::make_shared<IndexLookupJoinNode>(
       deserializePlanNodeId(obj),
-      joinTypeFromName(obj["joinType"].asString()),
+      JoinTypeName::toJoinType(obj["joinType"].asString()),
       std::move(leftKeys),
       std::move(rightKeys),
       std::move(joinConditions),
+      filter,
+      hasMarker,
       sources[0],
       std::move(lookupSource),
       std::move(outputType));
@@ -1574,6 +1884,10 @@ folly::dynamic IndexLookupJoinNode::serialize() const {
     }
     obj["joinConditions"] = std::move(serializedJoins);
   }
+  if (filter_) {
+    obj["filter"] = filter_->serialize();
+  }
+  obj["hasMarker"] = hasMarker_;
   return obj;
 }
 
@@ -1583,13 +1897,15 @@ void IndexLookupJoinNode::addDetails(std::stringstream& stream) const {
     return;
   }
 
-  std::vector<std::string> joinConditionStrs;
-  joinConditionStrs.reserve(joinConditions_.size());
+  std::vector<std::string> joinConditionstrs;
+  joinConditionstrs.reserve(joinConditions_.size());
   for (const auto& joinCondition : joinConditions_) {
-    joinConditionStrs.push_back(joinCondition->toString());
+    joinConditionstrs.push_back(joinCondition->toString());
   }
-  stream << ", joinConditions: [" << folly::join(", ", joinConditionStrs)
-         << " ]";
+  stream << ", joinConditions: [" << folly::join(", ", joinConditionstrs)
+         << " ], filter: ["
+         << (filter_ == nullptr ? "null" : filter_->toString())
+         << "], hasMarker: [" << (hasMarker_ ? "true" : "false") << "]";
 }
 
 void IndexLookupJoinNode::accept(
@@ -1599,21 +1915,19 @@ void IndexLookupJoinNode::accept(
 }
 
 // static
-bool IndexLookupJoinNode::isSupported(core::JoinType joinType) {
+bool IndexLookupJoinNode::isSupported(JoinType joinType) {
   switch (joinType) {
-    case core::JoinType::kInner:
+    case JoinType::kInner:
       [[fallthrough]];
-    case core::JoinType::kLeft:
+    case JoinType::kLeft:
       return true;
     default:
       return false;
   }
 }
 
-bool isIndexLookupJoin(const core::PlanNode* planNode) {
-  const auto* indexLookupJoin =
-      dynamic_cast<const core::IndexLookupJoinNode*>(planNode);
-  return indexLookupJoin != nullptr;
+bool isIndexLookupJoin(const PlanNode* planNode) {
+  return isInstanceOf<IndexLookupJoinNode>(planNode);
 }
 
 // static
@@ -1635,16 +1949,16 @@ NestedLoopJoinNode::NestedLoopJoinNode(
       outputType_(std::move(outputType)) {
   VELOX_USER_CHECK(
       isSupported(joinType_),
-      "The join type is not supported by nested loop join: ",
-      joinTypeName(joinType_));
+      "The join type is not supported by nested loop join: {}",
+      JoinTypeName::toName(joinType_));
 
   auto leftType = sources_[0]->outputType();
   auto rightType = sources_[1]->outputType();
-  auto numOutputColumms = outputType_->size();
-  if (core::isLeftSemiProjectJoin(joinType)) {
-    --numOutputColumms;
-    VELOX_CHECK_EQ(outputType_->childAt(numOutputColumms), BOOLEAN());
-    const auto& name = outputType_->nameOf(numOutputColumms);
+  auto numOutputColumns = outputType_->size();
+  if (isLeftSemiProjectJoin(joinType)) {
+    --numOutputColumns;
+    VELOX_CHECK_EQ(outputType_->childAt(numOutputColumns), BOOLEAN());
+    const auto& name = outputType_->nameOf(numOutputColumns);
     VELOX_CHECK(
         !leftType->containsChild(name),
         "Match column '{}' cannot be present in left source.",
@@ -1655,19 +1969,7 @@ NestedLoopJoinNode::NestedLoopJoinNode(
         name);
   }
 
-  for (auto i = 0; i < numOutputColumms; ++i) {
-    const auto name = outputType_->nameOf(i);
-    const bool leftContains = leftType->containsChild(name);
-    const bool rightContains = rightType->containsChild(name);
-    VELOX_USER_CHECK(
-        !(leftContains && rightContains),
-        "Duplicate column name found on join's left and right sides: {}",
-        name);
-    VELOX_USER_CHECK(
-        leftContains || rightContains,
-        "Join's output column not found in either left or right sides: {}",
-        name);
-  }
+  checkJoinColumnNames(leftType, rightType, outputType_, numOutputColumns);
 }
 
 NestedLoopJoinNode::NestedLoopJoinNode(
@@ -1679,18 +1981,18 @@ NestedLoopJoinNode::NestedLoopJoinNode(
           id,
           kDefaultJoinType,
           kDefaultJoinCondition,
-          left,
-          right,
-          outputType) {}
+          std::move(left),
+          std::move(right),
+          std::move(outputType)) {}
 
 // static
-bool NestedLoopJoinNode::isSupported(core::JoinType joinType) {
+bool NestedLoopJoinNode::isSupported(JoinType joinType) {
   switch (joinType) {
-    case core::JoinType::kInner:
-    case core::JoinType::kLeft:
-    case core::JoinType::kRight:
-    case core::JoinType::kFull:
-    case core::JoinType::kLeftSemiProject:
+    case JoinType::kInner:
+    case JoinType::kLeft:
+    case JoinType::kRight:
+    case JoinType::kFull:
+    case JoinType::kLeftSemiProject:
       return true;
 
     default:
@@ -1699,7 +2001,7 @@ bool NestedLoopJoinNode::isSupported(core::JoinType joinType) {
 }
 
 void NestedLoopJoinNode::addDetails(std::stringstream& stream) const {
-  stream << joinTypeName(joinType_);
+  stream << JoinTypeName::toName(joinType_);
   if (joinCondition_) {
     stream << ", joinCondition: " << joinCondition_->toString();
   }
@@ -1707,7 +2009,7 @@ void NestedLoopJoinNode::addDetails(std::stringstream& stream) const {
 
 folly::dynamic NestedLoopJoinNode::serialize() const {
   auto obj = PlanNode::serialize();
-  obj["joinType"] = joinTypeName(joinType_);
+  obj["joinType"] = JoinTypeName::toName(joinType_);
   if (joinCondition_) {
     obj["joinCondition"] = joinCondition_->serialize();
   }
@@ -1737,7 +2039,7 @@ PlanNodePtr NestedLoopJoinNode::create(
 
   return std::make_shared<NestedLoopJoinNode>(
       deserializePlanNodeId(obj),
-      joinTypeFromName(obj["joinType"].asString()),
+      JoinTypeName::toJoinType(obj["joinType"].asString()),
       joinCondition,
       sources[0],
       sources[1],
@@ -1824,17 +2126,17 @@ void addWindowFunction(
     VELOX_USER_FAIL("Window frame end cannot be UNBOUNDED PRECEDING");
   }
 
-  stream << WindowNode::windowTypeName(frame.type) << " between ";
+  stream << WindowNode::toName(frame.type) << " between ";
   if (frame.startValue) {
     addKeys(stream, {frame.startValue});
     stream << " ";
   }
-  stream << WindowNode::boundTypeName(frame.startType) << " and ";
+  stream << WindowNode::toName(frame.startType) << " and ";
   if (frame.endValue) {
     addKeys(stream, {frame.endValue});
     stream << " ";
   }
-  stream << WindowNode::boundTypeName(frame.endType);
+  stream << WindowNode::toName(frame.endType);
 }
 
 } // namespace
@@ -1926,70 +2228,42 @@ void WindowNode::addDetails(std::stringstream& stream) const {
 }
 
 namespace {
-std::unordered_map<WindowNode::BoundType, std::string> boundTypeNames() {
-  return {
-      {WindowNode::BoundType::kCurrentRow, "CURRENT ROW"},
-      {WindowNode::BoundType::kPreceding, "PRECEDING"},
-      {WindowNode::BoundType::kFollowing, "FOLLOWING"},
-      {WindowNode::BoundType::kUnboundedPreceding, "UNBOUNDED PRECEDING"},
-      {WindowNode::BoundType::kUnboundedFollowing, "UNBOUNDED FOLLOWING"},
-  };
+const auto& boundTypeNames() {
+  static const folly::F14FastMap<WindowNode::BoundType, std::string_view>
+      kNames = {
+          {WindowNode::BoundType::kCurrentRow, "CURRENT ROW"},
+          {WindowNode::BoundType::kPreceding, "PRECEDING"},
+          {WindowNode::BoundType::kFollowing, "FOLLOWING"},
+          {WindowNode::BoundType::kUnboundedPreceding, "UNBOUNDED PRECEDING"},
+          {WindowNode::BoundType::kUnboundedFollowing, "UNBOUNDED FOLLOWING"},
+      };
+  return kNames;
 }
 } // namespace
 
-// static
-const char* WindowNode::boundTypeName(WindowNode::BoundType type) {
-  static const auto kTypes = boundTypeNames();
-  auto it = kTypes.find(type);
-  VELOX_CHECK(
-      it != kTypes.end(),
-      "Invalid window bound type {}",
-      static_cast<int>(type));
-  return it->second.c_str();
-}
-
-// static
-WindowNode::BoundType WindowNode::boundTypeFromName(const std::string& name) {
-  static const auto kTypes = invertMap(boundTypeNames());
-  auto it = kTypes.find(name);
-  VELOX_CHECK(it != kTypes.end(), "Invalid window bound type " + name);
-  return it->second;
-}
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(WindowNode, BoundType, boundTypeNames)
 
 namespace {
-std::unordered_map<WindowNode::WindowType, std::string> windowTypeNames() {
-  return {
-      {WindowNode::WindowType::kRows, "ROWS"},
-      {WindowNode::WindowType::kRange, "RANGE"},
-  };
+const auto& windowTypeNames() {
+  static const folly::F14FastMap<WindowNode::WindowType, std::string_view>
+      kNames = {
+          {WindowNode::WindowType::kRows, "ROWS"},
+          {WindowNode::WindowType::kRange, "RANGE"},
+      };
+  return kNames;
 }
 } // namespace
 
-// static
-const char* WindowNode::windowTypeName(WindowNode::WindowType type) {
-  static const auto kTypes = windowTypeNames();
-  auto it = kTypes.find(type);
-  VELOX_CHECK(
-      it != kTypes.end(), "Invalid window type {}", static_cast<int>(type));
-  return it->second.c_str();
-}
-
-// static
-WindowNode::WindowType WindowNode::windowTypeFromName(const std::string& name) {
-  static const auto kTypes = invertMap(windowTypeNames());
-  auto it = kTypes.find(name);
-  VELOX_CHECK(it != kTypes.end(), "Invalid window type " + name);
-  return it->second;
-}
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(WindowNode, WindowType, windowTypeNames)
 
 folly::dynamic WindowNode::Frame::serialize() const {
   folly::dynamic obj = folly::dynamic::object();
-  obj["type"] = windowTypeName(type);
-  obj["startType"] = boundTypeName(startType);
+  obj["type"] = toName(type);
+  obj["startType"] = toName(startType);
   if (startValue) {
     obj["startValue"] = startValue->serialize();
   }
-  obj["endType"] = boundTypeName(endType);
+  obj["endType"] = toName(endType);
   if (endValue) {
     obj["endValue"] = endValue->serialize();
   }
@@ -2009,10 +2283,10 @@ WindowNode::Frame WindowNode::Frame::deserialize(const folly::dynamic& obj) {
   }
 
   return {
-      windowTypeFromName(obj["type"].asString()),
-      boundTypeFromName(obj["startType"].asString()),
+      toWindowType(obj["type"].asString()),
+      toBoundType(obj["startType"].asString()),
       startValue,
-      boundTypeFromName(obj["endType"].asString()),
+      toBoundType(obj["endType"].asString()),
       endValue};
 }
 
@@ -2228,8 +2502,41 @@ PlanNodePtr RowNumberNode::create(const folly::dynamic& obj, void* context) {
       source);
 }
 
+namespace {
+std::unordered_map<TopNRowNumberNode::RankFunction, std::string>
+rankFunctionNames() {
+  return {
+      {TopNRowNumberNode::RankFunction::kRowNumber, "row_number"},
+      {TopNRowNumberNode::RankFunction::kRank, "rank"},
+      {TopNRowNumberNode::RankFunction::kDenseRank, "dense_rank"},
+  };
+}
+} // namespace
+
+// static
+const char* TopNRowNumberNode::rankFunctionName(
+    TopNRowNumberNode::RankFunction function) {
+  static const auto kFunctionNames = rankFunctionNames();
+  auto it = kFunctionNames.find(function);
+  VELOX_CHECK(
+      it != kFunctionNames.cend(),
+      "Invalid rank function {}",
+      static_cast<int>(function));
+  return it->second.c_str();
+}
+
+// static
+TopNRowNumberNode::RankFunction TopNRowNumberNode::rankFunctionFromName(
+    std::string_view name) {
+  static const auto kFunctionNames = invertMap(rankFunctionNames());
+  auto it = kFunctionNames.find(name.data());
+  VELOX_CHECK(it != kFunctionNames.cend(), "Invalid rank function {}", name);
+  return it->second;
+}
+
 TopNRowNumberNode::TopNRowNumberNode(
     PlanNodeId id,
+    RankFunction function,
     std::vector<FieldAccessTypedExprPtr> partitionKeys,
     std::vector<FieldAccessTypedExprPtr> sortingKeys,
     std::vector<SortOrder> sortingOrders,
@@ -2237,6 +2544,7 @@ TopNRowNumberNode::TopNRowNumberNode(
     int32_t limit,
     PlanNodePtr source)
     : PlanNode(std::move(id)),
+      function_(function),
       partitionKeys_{std::move(partitionKeys)},
       sortingKeys_{std::move(sortingKeys)},
       sortingOrders_{std::move(sortingOrders)},
@@ -2274,6 +2582,8 @@ TopNRowNumberNode::TopNRowNumberNode(
 }
 
 void TopNRowNumberNode::addDetails(std::stringstream& stream) const {
+  stream << rankFunctionName(function_) << " ";
+
   if (!partitionKeys_.empty()) {
     stream << "partition by (";
     addFields(stream, partitionKeys_);
@@ -2289,6 +2599,7 @@ void TopNRowNumberNode::addDetails(std::stringstream& stream) const {
 
 folly::dynamic TopNRowNumberNode::serialize() const {
   auto obj = PlanNode::serialize();
+  obj["function"] = rankFunctionName(function_);
   obj["partitionKeys"] = ISerializable::serialize(partitionKeys_);
   obj["sortingKeys"] = ISerializable::serialize(sortingKeys_);
   obj["sortingOrders"] = serializeSortingOrders(sortingOrders_);
@@ -2310,6 +2621,7 @@ PlanNodePtr TopNRowNumberNode::create(
     const folly::dynamic& obj,
     void* context) {
   auto source = deserializeSingleSource(obj, context);
+  auto function = rankFunctionFromName(obj["function"].asString());
   auto partitionKeys = deserializeFields(obj["partitionKeys"], context);
   auto sortingKeys = deserializeFields(obj["sortingKeys"], context);
 
@@ -2322,6 +2634,7 @@ PlanNodePtr TopNRowNumberNode::create(
 
   return std::make_shared<TopNRowNumberNode>(
       deserializePlanNodeId(obj),
+      function,
       partitionKeys,
       sortingKeys,
       sortingOrders,
@@ -2364,19 +2677,79 @@ void TableWriteNode::addDetails(std::stringstream& stream) const {
   stream << insertTableHandle_->connectorInsertTableHandle()->toString();
 }
 
+RowTypePtr ColumnStatsSpec::outputType() const {
+  // Create output type based on the column stats collection specs.
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+
+  const auto numAggregates = aggregates.size();
+  const auto outputTypeSize = groupingKeys.size() + numAggregates;
+
+  names.reserve(outputTypeSize);
+  types.reserve(outputTypeSize);
+
+  for (const auto& key : groupingKeys) {
+    names.push_back(key->name());
+    types.push_back(key->type());
+  }
+
+  for (auto i = 0; i < numAggregates; ++i) {
+    names.push_back(aggregateNames[i]);
+    types.push_back(aggregates[i].call->type());
+  }
+  return ROW(std::move(names), std::move(types));
+}
+
+folly::dynamic ColumnStatsSpec::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["groupingKeys"] = ISerializable::serialize(groupingKeys);
+  obj["aggregationStep"] = AggregationNode::toName(aggregationStep);
+  obj["aggregateNames"] = ISerializable::serialize(aggregateNames);
+  obj["aggregates"] = folly::dynamic::array;
+  for (const auto& aggregate : aggregates) {
+    obj["aggregates"].push_back(aggregate.serialize());
+  }
+  return obj;
+}
+
+// static
+ColumnStatsSpec ColumnStatsSpec::create(
+    const folly::dynamic& obj,
+    void* context) {
+  auto groupingKeys = deserializeFields(obj["groupingKeys"], context);
+  const auto aggregationStep =
+      AggregationNode::toStep(obj["aggregationStep"].asString());
+  auto aggregateNames = ISerializable::deserialize<std::vector<std::string>>(
+      obj["aggregateNames"]);
+
+  std::vector<AggregationNode::Aggregate> aggregates;
+  aggregates.reserve(obj["aggregates"].size());
+  for (const auto& aggregate : obj["aggregates"]) {
+    aggregates.push_back(
+        AggregationNode::Aggregate::deserialize(aggregate, context));
+  }
+
+  return ColumnStatsSpec{
+      std::move(groupingKeys),
+      aggregationStep,
+      std::move(aggregateNames),
+      std::move(aggregates)};
+}
+
 folly::dynamic TableWriteNode::serialize() const {
   auto obj = PlanNode::serialize();
   obj["columns"] = columns_->serialize();
   obj["columnNames"] = ISerializable::serialize(columnNames_);
-  if (aggregationNode_ != nullptr) {
-    obj["aggregationNode"] = aggregationNode_->serialize();
+  if (columnStatsSpec_.has_value()) {
+    obj["columnStatsSpec"] = columnStatsSpec_->serialize();
   }
   obj["connectorId"] = insertTableHandle_->connectorId();
   obj["connectorInsertTableHandle"] =
       insertTableHandle_->connectorInsertTableHandle()->serialize();
   obj["hasPartitioningScheme"] = hasPartitioningScheme_;
   obj["outputType"] = outputType_->serialize();
-  obj["commitStrategy"] = connector::commitStrategyToString(commitStrategy_);
+  obj["commitStrategy"] =
+      std::string(connector::CommitStrategyName::toName(commitStrategy_));
   return obj;
 }
 
@@ -2392,26 +2765,23 @@ PlanNodePtr TableWriteNode::create(const folly::dynamic& obj, void* context) {
   auto columns = deserializeRowType(obj["columns"]);
   auto columnNames =
       ISerializable::deserialize<std::vector<std::string>>(obj["columnNames"]);
-  std::shared_ptr<AggregationNode> aggregationNode;
-  if (obj.count("aggregationNode") != 0) {
-    aggregationNode = std::const_pointer_cast<AggregationNode>(
-        ISerializable::deserialize<AggregationNode>(
-            obj["aggregationNode"], context));
-  }
   auto connectorId = obj["connectorId"].asString();
   auto connectorInsertTableHandle =
-      std::const_pointer_cast<connector::ConnectorInsertTableHandle>(
-          ISerializable::deserialize<connector::ConnectorInsertTableHandle>(
-              obj["connectorInsertTableHandle"]));
+      ISerializable::deserialize<connector::ConnectorInsertTableHandle>(
+          obj["connectorInsertTableHandle"]);
   const bool hasPartitioningScheme = obj["hasPartitioningScheme"].asBool();
   auto outputType = deserializeRowType(obj["outputType"]);
-  auto commitStrategy =
-      connector::stringToCommitStrategy(obj["commitStrategy"].asString());
+  auto commitStrategy = connector::CommitStrategyName::toCommitStrategy(
+      obj["commitStrategy"].asString());
+  std::optional<ColumnStatsSpec> columnStatsSpec;
+  if (obj.count("columnStatsSpec") != 0) {
+    columnStatsSpec = ColumnStatsSpec::create(obj["columnStatsSpec"], context);
+  }
   return std::make_shared<TableWriteNode>(
       id,
       columns,
       columnNames,
-      std::move(aggregationNode),
+      std::move(columnStatsSpec),
       std::make_shared<InsertTableHandle>(
           connectorId, connectorInsertTableHandle),
       hasPartitioningScheme,
@@ -2426,8 +2796,8 @@ folly::dynamic TableWriteMergeNode::serialize() const {
   auto obj = PlanNode::serialize();
   VELOX_CHECK_EQ(
       sources_.size(), 1, "TableWriteMergeNode can only have one source");
-  if (aggregationNode_ != nullptr) {
-    obj["aggregationNode"] = aggregationNode_->serialize();
+  if (columnStatsSpec_.has_value()) {
+    obj["columnStatsSpec"] = columnStatsSpec_->serialize();
   }
   obj["outputType"] = outputType_->serialize();
   return obj;
@@ -2445,13 +2815,15 @@ PlanNodePtr TableWriteMergeNode::create(
     void* context) {
   auto id = obj["id"].asString();
   auto outputType = deserializeRowType(obj["outputType"]);
-  std::shared_ptr<AggregationNode> aggregationNode;
-  if (obj.count("aggregationNode") != 0) {
-    aggregationNode = std::const_pointer_cast<AggregationNode>(
-        ISerializable::deserialize<AggregationNode>(obj["aggregationNode"]));
+  std::optional<ColumnStatsSpec> columnStatsSpec;
+  if (obj.count("columnStatsSpec") != 0) {
+    columnStatsSpec = ColumnStatsSpec::create(obj["columnStatsSpec"], context);
   }
   return std::make_shared<TableWriteMergeNode>(
-      id, outputType, aggregationNode, deserializeSingleSource(obj, context));
+      id,
+      outputType,
+      std::move(columnStatsSpec),
+      deserializeSingleSource(obj, context));
 }
 
 MergeExchangeNode::MergeExchangeNode(
@@ -2502,7 +2874,7 @@ PlanNodePtr MergeExchangeNode::create(
 }
 
 void LocalPartitionNode::addDetails(std::stringstream& stream) const {
-  stream << typeName(type_);
+  stream << toName(type_);
   if (type_ != Type::kGather) {
     stream << " " << partitionFunctionSpec_->toString();
   }
@@ -2513,7 +2885,7 @@ void LocalPartitionNode::addDetails(std::stringstream& stream) const {
 
 folly::dynamic LocalPartitionNode::serialize() const {
   auto obj = PlanNode::serialize();
-  obj["type"] = typeName(type_);
+  obj["type"] = toName(type_);
   obj["scaleWriter"] = scaleWriter_;
   obj["partitionFunctionSpec"] = partitionFunctionSpec_->serialize();
   return obj;
@@ -2531,42 +2903,28 @@ PlanNodePtr LocalPartitionNode::create(
     void* context) {
   return std::make_shared<LocalPartitionNode>(
       deserializePlanNodeId(obj),
-      typeFromName(obj["type"].asString()),
+      toType(obj["type"].asString()),
       obj["scaleWriter"].asBool(),
       ISerializable::deserialize<PartitionFunctionSpec>(
-          obj["partitionFunctionSpec"]),
+          obj["partitionFunctionSpec"], context),
       deserializeSources(obj, context));
 }
 
 namespace {
-std::unordered_map<LocalPartitionNode::Type, std::string>
-localPartitionTypeNames() {
-  return {
-      {LocalPartitionNode::Type::kGather, "GATHER"},
-      {LocalPartitionNode::Type::kRepartition, "REPARTITION"},
-  };
+const auto& localPartitionTypeNames() {
+  static const folly::F14FastMap<LocalPartitionNode::Type, std::string_view>
+      kNames = {
+          {LocalPartitionNode::Type::kGather, "GATHER"},
+          {LocalPartitionNode::Type::kRepartition, "REPARTITION"},
+      };
+  return kNames;
 }
 } // namespace
 
-// static
-const char* LocalPartitionNode::typeName(Type type) {
-  static const auto kTypes = localPartitionTypeNames();
-  auto it = kTypes.find(type);
-  VELOX_CHECK(
-      it != kTypes.end(),
-      "Invalid LocalPartitionNode type {}",
-      static_cast<int>(type));
-  return it->second.c_str();
-}
-
-// static
-LocalPartitionNode::Type LocalPartitionNode::typeFromName(
-    const std::string& name) {
-  static const auto kTypes = invertMap(localPartitionTypeNames());
-  auto it = kTypes.find(name);
-  VELOX_CHECK(it != kTypes.end(), "Invalid LocalPartitionNode type " + name);
-  return it->second;
-}
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(
+    LocalPartitionNode,
+    Type,
+    localPartitionTypeNames)
 
 PartitionedOutputNode::PartitionedOutputNode(
     const PlanNodeId& id,
@@ -2592,12 +2950,16 @@ PartitionedOutputNode::PartitionedOutputNode(
     VELOX_USER_CHECK(
         keys_.empty(),
         "Non-empty partitioning keys require more than one partition");
+  } else {
+    VELOX_USER_CHECK_NOT_NULL(
+        partitionFunctionSpec_,
+        "Partition function spec must be specified when the number of destinations is more than 1.");
   }
   if (!isPartitioned()) {
     VELOX_USER_CHECK(
         keys_.empty(),
         "{} partitioning doesn't allow for partitioning keys",
-        kindString(kind_));
+        toName(kind_));
   }
 }
 
@@ -2682,36 +3044,18 @@ PlanNodePtr EnforceSingleRowNode::create(
 }
 
 namespace {
-std::unordered_map<PartitionedOutputNode::Kind, std::string>
-partitionKindNames() {
-  return {
-      {PartitionedOutputNode::Kind::kPartitioned, "PARTITIONED"},
-      {PartitionedOutputNode::Kind::kBroadcast, "BROADCAST"},
-      {PartitionedOutputNode::Kind::kArbitrary, "ARBITRARY"},
-  };
+const auto& partitionKindNames() {
+  static const folly::F14FastMap<PartitionedOutputNode::Kind, std::string_view>
+      kNames = {
+          {PartitionedOutputNode::Kind::kPartitioned, "PARTITIONED"},
+          {PartitionedOutputNode::Kind::kBroadcast, "BROADCAST"},
+          {PartitionedOutputNode::Kind::kArbitrary, "ARBITRARY"},
+      };
+  return kNames;
 }
-
 } // namespace
 
-// static
-std::string PartitionedOutputNode::kindString(Kind kind) {
-  static const auto kPartitionNames = partitionKindNames();
-  auto it = kPartitionNames.find(kind);
-  VELOX_CHECK(
-      it != kPartitionNames.end(),
-      "Invalid Output Kind {}",
-      static_cast<int>(kind));
-  return it->second;
-}
-
-// static
-PartitionedOutputNode::Kind PartitionedOutputNode::stringToKind(
-    const std::string& name) {
-  static const auto kPartitionKinds = invertMap(partitionKindNames());
-  auto it = kPartitionKinds.find(name);
-  VELOX_CHECK(it != kPartitionKinds.end(), "Invalid Output Kind " + name);
-  return it->second;
-}
+VELOX_DEFINE_EMBEDDED_ENUM_NAME(PartitionedOutputNode, Kind, partitionKindNames)
 
 void PartitionedOutputNode::addDetails(std::stringstream& stream) const {
   if (kind_ == Kind::kBroadcast) {
@@ -2739,7 +3083,7 @@ void PartitionedOutputNode::addDetails(std::stringstream& stream) const {
 
 folly::dynamic PartitionedOutputNode::serialize() const {
   auto obj = PlanNode::serialize();
-  obj["kind"] = kindString(kind_);
+  obj["kind"] = toName(kind_);
   obj["numPartitions"] = numPartitions_;
   obj["keys"] = ISerializable::serialize(keys_);
   obj["replicateNullsAndAny"] = replicateNullsAndAny_;
@@ -2761,7 +3105,7 @@ PlanNodePtr PartitionedOutputNode::create(
     void* context) {
   return std::make_shared<PartitionedOutputNode>(
       deserializePlanNodeId(obj),
-      stringToKind(obj["kind"].asString()),
+      toKind(obj["kind"].asString()),
       ISerializable::deserialize<std::vector<ITypedExpr>>(obj["keys"], context),
       obj["numPartitions"].asInt(),
       obj["replicateNullsAndAny"].asBool(),
@@ -2772,6 +3116,123 @@ PlanNodePtr PartitionedOutputNode::create(
       deserializeSingleSource(obj, context));
 }
 
+SpatialJoinNode::SpatialJoinNode(
+    const PlanNodeId& id,
+    JoinType joinType,
+    TypedExprPtr joinCondition,
+    FieldAccessTypedExprPtr probeGeometry,
+    FieldAccessTypedExprPtr buildGeometry,
+    std::optional<FieldAccessTypedExprPtr> radius,
+    PlanNodePtr left,
+    PlanNodePtr right,
+    RowTypePtr outputType)
+    : PlanNode(id),
+      joinType_(joinType),
+      joinCondition_(std::move(joinCondition)),
+      probeGeometry_(std::move(probeGeometry)),
+      buildGeometry_(std::move(buildGeometry)),
+      radius_(std::move(radius)),
+      sources_({std::move(left), std::move(right)}),
+      outputType_(std::move(outputType)) {
+  VELOX_USER_CHECK(
+      isSupported(joinType_),
+      "The join type is not supported by spatial join: {}",
+      JoinTypeName::toName(joinType_));
+  VELOX_USER_CHECK_NOT_NULL(
+      joinCondition_, "The join condition must not be null for spatial join");
+  VELOX_USER_CHECK_NOT_NULL(
+      probeGeometry_, "Probe geometery must not be null for spatial joins");
+  VELOX_USER_CHECK_NOT_NULL(
+      buildGeometry_, "Build geometery must not be null for spatial joins");
+  VELOX_USER_CHECK_EQ(
+      sources_.size(), 2, "Must have 2 sources for spatial joins");
+  VELOX_USER_CHECK(
+      sources_[0] != nullptr, "Left source must not be null for spatial joins");
+  VELOX_USER_CHECK(
+      sources_[1] != nullptr,
+      "Right source must not be null for spatial joins");
+
+  checkJoinColumnNames(
+      sources_[0]->outputType(),
+      sources_[1]->outputType(),
+      outputType_,
+      outputType_->size());
+}
+
+bool SpatialJoinNode::isSupported(JoinType joinType) {
+  switch (joinType) {
+    case JoinType::kInner:
+      [[fallthrough]];
+    case JoinType::kLeft:
+      return true;
+    default:
+      return false;
+  }
+}
+
+void SpatialJoinNode::addDetails(std::stringstream& stream) const {
+  stream << JoinTypeName::toName(joinType_);
+  if (joinCondition_) {
+    stream << ", joinCondition: " << joinCondition_->toString();
+  }
+  stream << ", probeGeometry: " << probeGeometry_->name();
+  stream << ", buildGeometry: " << buildGeometry_->name();
+  if (radius_) {
+    stream << ", radius: " << radius_.value()->name();
+  }
+}
+
+folly::dynamic SpatialJoinNode::serialize() const {
+  auto obj = PlanNode::serialize();
+  obj["joinType"] = JoinTypeName::toName(joinType_);
+  if (joinCondition_) {
+    obj["joinCondition"] = joinCondition_->serialize();
+  }
+  obj["outputType"] = outputType_->serialize();
+  obj["probeGeometry"] = probeGeometry_->serialize();
+  obj["buildGeometry"] = buildGeometry_->serialize();
+  if (radius_) {
+    obj["radius"] = radius_.value()->serialize();
+  }
+  return obj;
+}
+
+void SpatialJoinNode::accept(
+    const PlanNodeVisitor& visitor,
+    PlanNodeVisitorContext& context) const {
+  visitor.visit(*this, context);
+}
+
+PlanNodePtr SpatialJoinNode::create(const folly::dynamic& obj, void* context) {
+  auto sources = deserializeSources(obj, context);
+  VELOX_CHECK_EQ(2, sources.size());
+
+  TypedExprPtr joinCondition;
+  if (obj.count("joinCondition")) {
+    joinCondition =
+        ISerializable::deserialize<ITypedExpr>(obj["joinCondition"], context);
+  }
+
+  auto outputType = deserializeRowType(obj["outputType"]);
+  auto probeGeometry = deserializeField(obj["probeGeometry"]);
+  auto buildGeometry = deserializeField(obj["buildGeometry"]);
+  std::optional<FieldAccessTypedExprPtr> radius;
+  if (obj.count("radius")) {
+    radius = deserializeField(obj["radius"]);
+  }
+
+  return std::make_shared<SpatialJoinNode>(
+      deserializePlanNodeId(obj),
+      JoinTypeName::toJoinType(obj["joinType"].asString()),
+      joinCondition,
+      probeGeometry,
+      buildGeometry,
+      radius,
+      sources[0],
+      sources[1],
+      outputType);
+}
+
 TopNNode::TopNNode(
     const PlanNodeId& id,
     const std::vector<FieldAccessTypedExprPtr>& sortingKeys,
@@ -2921,10 +3382,7 @@ void PlanNode::toString(
     bool detailed,
     bool recursive,
     size_t indentationSize,
-    const std::function<void(
-        const PlanNodeId& planNodeId,
-        const std::string& indentation,
-        std::stringstream& stream)>& addContext) const {
+    const AddContextFunc& addContext) const {
   const std::string indentation(indentationSize, ' ');
 
   stream << indentation << "-- " << name() << "[" << id() << "]";
@@ -2939,10 +3397,8 @@ void PlanNode::toString(
   stream << std::endl;
 
   if (addContext) {
-    auto contextIndentation = indentation + "   ";
-    stream << contextIndentation;
+    const auto contextIndentation = indentation + "   ";
     addContext(id(), contextIndentation, stream);
-    stream << std::endl;
   }
 
   if (recursive) {
@@ -2994,16 +3450,22 @@ void PlanNode::accept(
 void PlanNode::toSummaryString(
     const PlanSummaryOptions& options,
     std::stringstream& stream,
-    size_t indentationSize) const {
+    size_t indentationSize,
+    const AddContextFunc& addContext) const {
   const std::string indentation(indentationSize, ' ');
 
+  const auto detailsIndentation = indentation + std::string(6, ' ');
+
   stream << indentation << "-- " << name() << "[" << id()
          << "]: " << summarizeOutputType(outputType(), options) << std::endl;
+  addSummaryDetails(detailsIndentation, options, stream);
 
-  addSummaryDetails(indentation + "      ", options, stream);
+  if (addContext != nullptr) {
+    addContext(id(), detailsIndentation, stream);
+  }
 
   for (auto& source : sources()) {
-    source->toSummaryString(options, stream, indentationSize + 2);
+    source->toSummaryString(options, stream, indentationSize + 2, addContext);
   }
 }
 
@@ -3017,10 +3479,54 @@ void PlanNode::addSummaryDetails(
   stream << indentation << truncate(out.str(), options.maxLength) << std::endl;
 }
 
+void PlanNode::toSkeletonString(
+    std::stringstream& stream,
+    size_t indentationSize) const {
+  // Skip Project nodes.
+  if (const auto* project = dynamic_cast<const ProjectNode*>(this)) {
+    project->sources().at(0)->toSkeletonString(stream, indentationSize);
+    return;
+  }
+
+  const std::string indentation(indentationSize, ' ');
+
+  stream << indentation << "-- " << name() << "[" << id()
+         << "]: " << outputType()->size() << " fields" << std::endl;
+
+  // Include table scan details.
+  if (const auto* scan = dynamic_cast<const TableScanNode*>(this)) {
+    stream << indentation << std::string(6, ' ')
+           << scan->tableHandle()->toString() << std::endl;
+  }
+
+  for (const auto& source : sources()) {
+    source->toSkeletonString(stream, indentationSize + 2);
+  }
+}
+
+// static
+const PlanNode* PlanNode::findFirstNode(
+    const PlanNode* root,
+    const std::function<bool(const PlanNode* node)>& predicate) {
+  VELOX_CHECK_NOT_NULL(root);
+  if (predicate(root)) {
+    return root;
+  }
+
+  // Recursively go further through the sources.
+  for (const auto& source : root->sources()) {
+    const auto* ret = PlanNode::findFirstNode(source.get(), predicate);
+    if (ret != nullptr) {
+      return ret;
+    }
+  }
+  return nullptr;
+}
+
 namespace {
 void collectLeafPlanNodeIds(
-    const core::PlanNode& planNode,
-    std::unordered_set<core::PlanNodeId>& leafIds) {
+    const PlanNode& planNode,
+    std::unordered_set<PlanNodeId>& leafIds) {
   if (planNode.sources().empty()) {
     leafIds.insert(planNode.id());
     return;
@@ -3034,8 +3540,8 @@ void collectLeafPlanNodeIds(
 }
 } // namespace
 
-std::unordered_set<core::PlanNodeId> PlanNode::leafPlanNodeIds() const {
-  std::unordered_set<core::PlanNodeId> leafIds;
+std::unordered_set<PlanNodeId> PlanNode::leafPlanNodeIds() const {
+  std::unordered_set<PlanNodeId> leafIds;
   collectLeafPlanNodeIds(*this, leafIds);
   return leafIds;
 }
@@ -3062,7 +3568,9 @@ void PlanNode::registerSerDe() {
   registry.Register("OrderByNode", OrderByNode::create);
   registry.Register("PartitionedOutputNode", PartitionedOutputNode::create);
   registry.Register("ProjectNode", ProjectNode::create);
+  registry.Register("ParallelProjectNode", ParallelProjectNode::create);
   registry.Register("RowNumberNode", RowNumberNode::create);
+  registry.Register("SpatialJoinNode", SpatialJoinNode::create);
   registry.Register("TableScanNode", TableScanNode::create);
   registry.Register("TableWriteNode", TableWriteNode::create);
   registry.Register("TableWriteMergeNode", TableWriteMergeNode::create);
@@ -3165,7 +3673,7 @@ void AggregationNode::addSummaryDetails(
 PlanNodePtr FilterNode::create(const folly::dynamic& obj, void* context) {
   auto source = deserializeSingleSource(obj, context);
 
-  auto filter = ISerializable::deserialize<ITypedExpr>(obj["filter"]);
+  auto filter = ISerializable::deserialize<ITypedExpr>(obj["filter"], context);
   return std::make_shared<FilterNode>(
       deserializePlanNodeId(obj), filter, std::move(source));
 }
@@ -3177,7 +3685,7 @@ folly::dynamic IndexLookupCondition::serialize() const {
 }
 
 bool InIndexLookupCondition::isFilter() const {
-  return std::dynamic_pointer_cast<const ConstantTypedExpr>(list) != nullptr;
+  return list->isConstantKind();
 }
 
 folly::dynamic InIndexLookupCondition::serialize() const {
@@ -3195,16 +3703,13 @@ void InIndexLookupCondition::validate() const {
   VELOX_CHECK_NOT_NULL(key);
   VELOX_CHECK_NOT_NULL(list);
   VELOX_CHECK(
-      std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(list) ||
-          std::dynamic_pointer_cast<const core::ConstantTypedExpr>(list),
+      list->isFieldAccessKind() || list->isConstantKind(),
       "Invalid condition list {}",
       list->toString());
-  const auto listType =
-      std::dynamic_pointer_cast<const ArrayType>(list->type());
-  VELOX_CHECK_NOT_NULL(listType);
+  const auto& listType = list->type()->asArray();
   VELOX_CHECK_EQ(
       key->type()->kind(),
-      listType->elementType()->kind(),
+      listType.elementType()->kind(),
       "In condition key and list condition element must have the same type");
 }
 
@@ -3222,9 +3727,7 @@ IndexLookupConditionPtr InIndexLookupCondition::create(
 }
 
 bool BetweenIndexLookupCondition::isFilter() const {
-  return (std::dynamic_pointer_cast<const ConstantTypedExpr>(lower) !=
-          nullptr) &&
-      (std::dynamic_pointer_cast<const ConstantTypedExpr>(upper) != nullptr);
+  return lower->isConstantKind() && upper->isConstantKind();
 }
 
 folly::dynamic BetweenIndexLookupCondition::serialize() const {
@@ -3259,14 +3762,12 @@ void BetweenIndexLookupCondition::validate() const {
   VELOX_CHECK_NOT_NULL(lower);
   VELOX_CHECK_NOT_NULL(upper);
   VELOX_CHECK(
-      std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(lower) ||
-          std::dynamic_pointer_cast<const core::ConstantTypedExpr>(lower),
+      lower->isFieldAccessKind() || lower->isConstantKind(),
       "Invalid lower between condition {}",
       lower->toString());
 
   VELOX_CHECK(
-      std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(upper) ||
-          std::dynamic_pointer_cast<const core::ConstantTypedExpr>(upper),
+      upper->isFieldAccessKind() || upper->isConstantKind(),
       "Invalid upper between condition {}",
       upper->toString());
 
@@ -3280,4 +3781,44 @@ void BetweenIndexLookupCondition::validate() const {
       upper->type()->kind(),
       "Index key and upper condition must have the same type");
 }
+
+bool EqualIndexLookupCondition::isFilter() const {
+  return value->isConstantKind();
+}
+
+folly::dynamic EqualIndexLookupCondition::serialize() const {
+  folly::dynamic obj = IndexLookupCondition::serialize();
+  obj["type"] = "equal";
+  obj["value"] = value->serialize();
+  return obj;
+}
+
+std::string EqualIndexLookupCondition::toString() const {
+  return fmt::format("{} = {}", key->toString(), value->toString());
+}
+
+IndexLookupConditionPtr EqualIndexLookupCondition::create(
+    const folly::dynamic& obj,
+    void* context) {
+  auto key =
+      ISerializable::deserialize<FieldAccessTypedExpr>(obj["key"], context);
+  return std::make_shared<EqualIndexLookupCondition>(
+      key, ISerializable::deserialize<ITypedExpr>(obj["value"], context));
+}
+
+void EqualIndexLookupCondition::validate() const {
+  VELOX_CHECK_NOT_NULL(key);
+  VELOX_CHECK_NOT_NULL(value);
+  VELOX_CHECK_NOT_NULL(
+      checkedPointerCast<const ConstantTypedExpr>(value),
+      "Equal condition value must be a constant expression: {}",
+      value->toString());
+
+  VELOX_CHECK_EQ(
+      key->type()->kind(),
+      value->type()->kind(),
+      "Equal condition key and value must have compatible types: {} vs {}",
+      key->type()->toString(),
+      value->type()->toString());
+}
 } // namespace facebook::velox::core
diff --git a/velox/core/PlanNode.h b/velox/core/PlanNode.h
index 873aa032675b..24f954d8f0b3 100644
--- a/velox/core/PlanNode.h
+++ b/velox/core/PlanNode.h
@@ -19,6 +19,7 @@
 
 #include <utility>
 
+#include "velox/common/Enums.h"
 #include "velox/connectors/Connector.h"
 #include "velox/core/Expressions.h"
 #include "velox/core/QueryConfig.h"
@@ -31,14 +32,14 @@ namespace facebook::velox::core {
 class PlanNodeVisitor;
 class PlanNodeVisitorContext;
 
-typedef std::string PlanNodeId;
+using PlanNodeId = std::string;
 
 /// Generic representation of InsertTable
 struct InsertTableHandle {
  public:
   InsertTableHandle(
       const std::string& connectorId,
-      const std::shared_ptr<connector::ConnectorInsertTableHandle>&
+      const connector::ConnectorInsertTableHandlePtr&
           connectorInsertTableHandle)
       : connectorId_(connectorId),
         connectorInsertTableHandle_(connectorInsertTableHandle) {}
@@ -47,8 +48,8 @@ struct InsertTableHandle {
     return connectorId_;
   }
 
-  const std::shared_ptr<connector::ConnectorInsertTableHandle>&
-  connectorInsertTableHandle() const {
+  const connector::ConnectorInsertTableHandlePtr& connectorInsertTableHandle()
+      const {
     return connectorInsertTableHandle_;
   }
 
@@ -57,8 +58,7 @@ struct InsertTableHandle {
   const std::string connectorId_;
 
   // Write request to a DataSink of that connector type
-  const std::shared_ptr<connector::ConnectorInsertTableHandle>
-      connectorInsertTableHandle_;
+  const connector::ConnectorInsertTableHandlePtr connectorInsertTableHandle_;
 };
 
 class SortOrder {
@@ -74,14 +74,7 @@ class SortOrder {
     return nullsFirst_;
   }
 
-  bool operator==(const SortOrder& other) const {
-    return std::tie(ascending_, nullsFirst_) ==
-        std::tie(other.ascending_, other.nullsFirst_);
-  }
-
-  bool operator!=(const SortOrder& other) const {
-    return !(*this == other);
-  }
+  bool operator==(const SortOrder& other) const = default;
 
   std::string toString() const {
     return fmt::format(
@@ -114,15 +107,19 @@ extern const SortOrder kDescNullsLast;
 struct PlanSummaryOptions {
   /// Options that apply specifically to PROJECT nodes.
   struct ProjectOptions {
-    /// For a given PROJECT node, maximum number of non-identity projection
-    /// expressions to include in the summary. By default, no expression is
-    /// included.
+    /// For a given PROJECT node, maximum number of non-identity and
+    /// non-constant projection expressions to include in the summary. By
+    /// default, no expression is included.
     size_t maxProjections = 0;
 
     /// For a given PROJECT node, maximum number of dereference (access of a
     /// struct field) expressions to include in the summary. By default, no
     /// expression is included.
     size_t maxDereferences = 0;
+
+    /// For a given PROJECT node, maximum number of constant expressions to
+    /// include in the summary. By default, no expression is included.
+    size_t maxConstants = 0;
   };
 
   ProjectOptions project = {};
@@ -157,7 +154,7 @@ struct PlanSummaryOptions {
 
 class PlanNode : public ISerializable {
  public:
-  explicit PlanNode(const PlanNodeId& id) : id_{id} {}
+  explicit PlanNode(PlanNodeId id) : id_{std::move(id)} {}
 
   virtual ~PlanNode() {}
 
@@ -220,6 +217,14 @@ class PlanNode : public ISerializable {
   /// Returns a set of leaf plan node IDs.
   std::unordered_set<core::PlanNodeId> leafPlanNodeIds() const;
 
+  /// Lambda to add context for a given plan node. Receives plan node ID,
+  /// indentation and std::ostream where to append the context. Start each line
+  /// of context with 'indentation' and end with a new-line character.
+  using AddContextFunc = std::function<void(
+      const PlanNodeId& planNodeId,
+      const std::string& indentation,
+      std::ostream& stream)>;
+
   /// Returns human-friendly representation of the plan. By default, returns the
   /// plan node name. Includes plan node details such as join keys and aggregate
   /// function names if 'detailed' is true. Returns the whole sub-tree if
@@ -227,48 +232,55 @@ 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::stringstream where to append
-  /// the context. Use indentation for second and subsequent lines of a
-  /// 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,
-      const std::function<void(
-          const PlanNodeId& planNodeId,
-          const std::string& indentation,
-          std::stringstream& stream)>& addContext = nullptr) const {
+      const AddContextFunc& addContext = nullptr) const {
     std::stringstream stream;
     toString(stream, detailed, recursive, 0, addContext);
     return stream.str();
   }
 
-  std::string toSummaryString(PlanSummaryOptions options = {}) const {
+  /// @param addContext Optional lambda to add context for a given plan node.
+  std::string toSummaryString(
+      PlanSummaryOptions options = {},
+      const AddContextFunc& addContext = nullptr) const {
     std::stringstream stream;
-    toSummaryString(options, stream, 0);
+    toSummaryString(options, stream, 0, addContext);
+    return stream.str();
+  }
+
+  std::string toSkeletonString() const {
+    std::stringstream stream;
+    toSkeletonString(stream, 0);
     return stream.str();
   }
 
   /// The name of the plan node, used in toString.
   virtual std::string_view name() const = 0;
 
+  template <typename T>
+  bool is() const {
+    return dynamic_cast<const T*>(this) != nullptr;
+  }
+
+  template <typename T>
+  const T* as() const {
+    return dynamic_cast<const T*>(this);
+  }
+
   /// Recursively checks the node tree for a first node that satisfy a given
   /// condition. Returns pointer to the node if found, nullptr if not.
   static const PlanNode* findFirstNode(
-      const PlanNode* node,
-      const std::function<bool(const PlanNode* node)>& predicate) {
-    if (predicate(node)) {
-      return node;
-    }
+      const PlanNode* root,
+      const std::function<bool(const PlanNode* node)>& predicate);
 
-    // Recursively go further through the sources.
-    for (const auto& source : node->sources()) {
-      const auto* ret = PlanNode::findFirstNode(source.get(), predicate);
-      if (ret != nullptr) {
-        return ret;
-      }
-    }
-    return nullptr;
+  /// @return PlanNode with matching ID or nullptr if not found.
+  static const PlanNode* findNodeById(
+      const PlanNode* root,
+      const PlanNodeId& id) {
+    return findFirstNode(
+        root, [&](const auto* node) { return node->id() == id; });
   }
 
  private:
@@ -286,11 +298,9 @@ class PlanNode : public ISerializable {
       bool detailed,
       bool recursive,
       size_t indentationSize,
-      const std::function<void(
-          const PlanNodeId& planNodeId,
-          const std::string& indentation,
-          std::stringstream& stream)>& addContext) const;
+      const AddContextFunc& addContext) const;
 
+  // The default implementation calls 'addDetails' and truncates the result.
   virtual void addSummaryDetails(
       const std::string& indentation,
       const PlanSummaryOptions& options,
@@ -299,9 +309,16 @@ class PlanNode : public ISerializable {
   void toSummaryString(
       const PlanSummaryOptions& options,
       std::stringstream& stream,
-      size_t indentationSize) const;
+      size_t indentationSize,
+      const AddContextFunc& addContext) const;
 
-  const std::string id_;
+  // Even shorter summary of the plan. Hides all Project nodes. Shows only
+  // number of output columns, but no names or types. Doesn't show any details
+  // of the nodes, except for table scan.
+  void toSkeletonString(std::stringstream& stream, size_t indentationSize)
+      const;
+
+  const PlanNodeId id_;
 };
 
 using PlanNodePtr = std::shared_ptr<const PlanNode>;
@@ -315,10 +332,7 @@ class ValuesNode : public PlanNode {
       size_t repeatTimes = kDefaultRepeatTimes)
       : PlanNode(id),
         values_(std::move(values)),
-        outputType_(
-            values_.empty()
-                ? ROW({})
-                : std::dynamic_pointer_cast<const RowType>(values_[0]->type())),
+        outputType_(values_.empty() ? ROW({}) : values_[0]->rowType()),
         parallelizable_(parallelizable),
         repeatTimes_(repeatTimes) {}
 
@@ -498,6 +512,8 @@ class ArrowStreamNode : public PlanNode {
   std::shared_ptr<ArrowArrayStream> arrowStream_;
 };
 
+using ArrowStreamNodePtr = std::shared_ptr<const ArrowStreamNode>;
+
 class TraceScanNode final : public PlanNode {
  public:
   TraceScanNode(
@@ -614,6 +630,8 @@ class TraceScanNode final : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using TraceScanNodePtr = std::shared_ptr<const TraceScanNode>;
+
 class FilterNode : public PlanNode {
  public:
   FilterNode(const PlanNodeId& id, TypedExprPtr filter, PlanNodePtr source)
@@ -706,6 +724,8 @@ class FilterNode : public PlanNode {
   const TypedExprPtr filter_;
 };
 
+using FilterNodePtr = std::shared_ptr<const FilterNode>;
+
 class AbstractProjectNode : public PlanNode {
  public:
   AbstractProjectNode(
@@ -809,15 +829,7 @@ class AbstractProjectNode : public PlanNode {
 
   static RowTypePtr makeOutputType(
       const std::vector<std::string>& names,
-      const std::vector<TypedExprPtr>& projections) {
-    std::vector<TypePtr> types;
-    for (auto& projection : projections) {
-      types.push_back(projection->type());
-    }
-
-    auto namesCopy = names;
-    return std::make_shared<RowType>(std::move(namesCopy), std::move(types));
-  }
+      const std::vector<TypedExprPtr>& projections);
 
   const std::vector<PlanNodePtr> sources_;
   const std::vector<std::string> names_;
@@ -876,15 +888,92 @@ class ProjectNode : public AbstractProjectNode {
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
 };
 
+using ProjectNodePtr = std::shared_ptr<const ProjectNode>;
+
+/// Variant of ProjectNode that computes projections in
+/// parallel. The exprs are given in groups, so that all exprs in
+/// one group run together and all groups run in parallel. If lazies
+/// are loaded, each lazy must be loaded by exactly one group. If
+/// there are identity projections in the groups, possible lazies
+/// are loaded as part of processing the group. One can additionally
+/// specify 'noLoadIdentities' which are identity projected through
+/// without loading. This last set must be disjoint from all columns
+/// accessed by the exprs. The output type has 'names' first and
+/// then 'noLoadIdentities'. The ith name corresponds to the ith
+/// expr when exprs is flattened. Inherits core::ProjectNode in order to reuse
+/// the summary functions.
+class ParallelProjectNode : public core::AbstractProjectNode {
+ public:
+  ParallelProjectNode(
+      const core::PlanNodeId& id,
+      std::vector<std::string> names,
+      std::vector<std::vector<core::TypedExprPtr>> exprGroups,
+      std::vector<std::string> noLoadIdentities,
+      core::PlanNodePtr input);
+
+  std::string_view name() const override {
+    return "ParallelProject";
+  }
+
+  const std::vector<std::string>& exprNames() const {
+    return exprNames_;
+  }
+
+  const std::vector<std::vector<core::TypedExprPtr>>& exprGroups() const {
+    return exprGroups_;
+  }
+
+  const std::vector<std::string> noLoadIdentities() const {
+    return noLoadIdentities_;
+  }
+
+  folly::dynamic serialize() const override;
+
+  void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
+      const override;
+
+  static PlanNodePtr create(const folly::dynamic& obj, void* context);
+
+ private:
+  void addDetails(std::stringstream& stream) const override;
+
+  const std::vector<std::string> exprNames_;
+  const std::vector<std::vector<core::TypedExprPtr>> exprGroups_;
+  const std::vector<std::string> noLoadIdentities_;
+};
+
+/// Variant of project node that contains only field accesses and dereferences,
+/// and does not materialize the input columns.  Used to split subfields of
+/// struct columns for later parallel processing.
+class LazyDereferenceNode : public core::ProjectNode {
+ public:
+  LazyDereferenceNode(
+      const PlanNodeId& id,
+      std::vector<std::string> names,
+      std::vector<TypedExprPtr> projections,
+      PlanNodePtr source)
+      : ProjectNode(
+            id,
+            std::move(names),
+            std::move(projections),
+            std::move(source)) {}
+
+  std::string_view name() const override {
+    return "LazyDereference";
+  }
+
+  static PlanNodePtr create(const folly::dynamic& obj, void* context);
+};
+
+using ParallelProjectNodePtr = std::shared_ptr<const ParallelProjectNode>;
+
 class TableScanNode : public PlanNode {
  public:
   TableScanNode(
       const PlanNodeId& id,
       RowTypePtr outputType,
-      const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& assignments)
+      const connector::ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& assignments)
       : PlanNode(id),
         outputType_(std::move(outputType)),
         tableHandle_(tableHandle),
@@ -911,16 +1000,12 @@ class TableScanNode : public PlanNode {
       return *this;
     }
 
-    Builder& tableHandle(
-        std::shared_ptr<connector::ConnectorTableHandle> tableHandle) {
+    Builder& tableHandle(connector::ConnectorTableHandlePtr tableHandle) {
       tableHandle_ = std::move(tableHandle);
       return *this;
     }
 
-    Builder& assignments(
-        std::unordered_map<
-            std::string,
-            std::shared_ptr<connector::ColumnHandle>> assignments) {
+    Builder& assignments(connector::ColumnHandleMap assignments) {
       assignments_ = std::move(assignments);
       return *this;
     }
@@ -944,12 +1029,8 @@ class TableScanNode : public PlanNode {
    private:
     std::optional<PlanNodeId> id_;
     std::optional<RowTypePtr> outputType_;
-    std::optional<std::shared_ptr<connector::ConnectorTableHandle>>
-        tableHandle_;
-    std::optional<std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>>
-        assignments_;
+    std::optional<connector::ConnectorTableHandlePtr> tableHandle_;
+    std::optional<connector::ColumnHandleMap> assignments_;
   };
 
   bool supportsBarrier() const override {
@@ -969,13 +1050,11 @@ class TableScanNode : public PlanNode {
     return true;
   }
 
-  const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle() const {
+  const connector::ConnectorTableHandlePtr& tableHandle() const {
     return tableHandle_;
   }
 
-  const std::
-      unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>&
-      assignments() const {
+  const connector::ColumnHandleMap& assignments() const {
     return assignments_;
   }
 
@@ -990,11 +1069,14 @@ class TableScanNode : public PlanNode {
  private:
   void addDetails(std::stringstream& stream) const override;
 
+  void addSummaryDetails(
+      const std::string& indentation,
+      const PlanSummaryOptions& options,
+      std::stringstream& stream) const override;
+
   const RowTypePtr outputType_;
-  const std::shared_ptr<connector::ConnectorTableHandle> tableHandle_;
-  const std::
-      unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-          assignments_;
+  const connector::ConnectorTableHandlePtr tableHandle_;
+  const connector::ColumnHandleMap assignments_;
 };
 
 using TableScanNodePtr = std::shared_ptr<const TableScanNode>;
@@ -1012,9 +1094,7 @@ class AggregationNode : public PlanNode {
     kSingle
   };
 
-  static const char* stepName(Step step);
-
-  static Step stepFromName(const std::string& name);
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(Step);
 
   /// Aggregate function call.
   struct Aggregate {
@@ -1028,14 +1108,14 @@ class AggregationNode : public PlanNode {
 
     /// Optional name of input column to use as a mask. Column type must be
     /// BOOLEAN.
-    FieldAccessTypedExprPtr mask;
+    FieldAccessTypedExprPtr mask{};
 
     /// Optional list of input columns to sort by before applying aggregate
     /// function.
-    std::vector<FieldAccessTypedExprPtr> sortingKeys;
+    std::vector<FieldAccessTypedExprPtr> sortingKeys{};
 
     /// A list of sorting orders that goes together with 'sortingKeys'.
-    std::vector<SortOrder> sortingOrders;
+    std::vector<SortOrder> sortingOrders{};
 
     /// Boolean indicating whether inputs must be de-duplicated before
     /// aggregating.
@@ -1054,8 +1134,29 @@ class AggregationNode : public PlanNode {
       const std::vector<std::string>& aggregateNames,
       const std::vector<Aggregate>& aggregates,
       bool ignoreNullKeys,
+      bool noGroupsSpanBatches,
       PlanNodePtr source);
 
+  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,
+            ignoreNullKeys,
+            /*noGroupsSpanBatches=*/false,
+            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
@@ -1075,8 +1176,33 @@ class AggregationNode : public PlanNode {
       const std::vector<vector_size_t>& globalGroupingSets,
       const std::optional<FieldAccessTypedExprPtr>& groupId,
       bool ignoreNullKeys,
+      bool noGroupsSpanBatches,
       PlanNodePtr source);
 
+  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)
+      : AggregationNode(
+            id,
+            step,
+            groupingKeys,
+            preGroupedKeys,
+            aggregateNames,
+            aggregates,
+            globalGroupingSets,
+            groupId,
+            ignoreNullKeys,
+            /*noGroupsSpanBatches=*/false,
+            source) {}
+
   class Builder {
    public:
     Builder() = default;
@@ -1091,6 +1217,7 @@ class AggregationNode : public PlanNode {
       globalGroupingSets_ = other.globalGroupingSets();
       groupId_ = other.groupId();
       ignoreNullKeys_ = other.ignoreNullKeys();
+      noGroupsSpanBatches_ = other.noGroupsSpanBatches();
       VELOX_CHECK_EQ(other.sources().size(), 1);
       source_ = other.sources()[0];
     }
@@ -1141,6 +1268,11 @@ class AggregationNode : public PlanNode {
       return *this;
     }
 
+    Builder& noGroupsSpanBatches(bool noGroupsSpanBatches) {
+      noGroupsSpanBatches_ = noGroupsSpanBatches;
+      return *this;
+    }
+
     Builder& source(PlanNodePtr source) {
       source_ = std::move(source);
       return *this;
@@ -1175,6 +1307,7 @@ class AggregationNode : public PlanNode {
           globalGroupingSets_,
           groupId_,
           ignoreNullKeys_.value(),
+          noGroupsSpanBatches_,
           source_.value());
     }
 
@@ -1188,6 +1321,7 @@ class AggregationNode : public PlanNode {
     std::vector<vector_size_t> globalGroupingSets_ = kDefaultGlobalGroupingSets;
     std::optional<FieldAccessTypedExprPtr> groupId_ = kDefaultGroupId;
     std::optional<bool> ignoreNullKeys_;
+    bool noGroupsSpanBatches_{false};
     std::optional<PlanNodePtr> source_;
   };
 
@@ -1221,10 +1355,10 @@ class AggregationNode : public PlanNode {
   bool isPreGrouped() const {
     return !preGroupedKeys_.empty() &&
         std::equal(
-            preGroupedKeys_.begin(),
-            preGroupedKeys_.end(),
-            groupingKeys_.begin(),
-            groupingKeys_.end(),
+            preGroupedKeys_.cbegin(),
+            preGroupedKeys_.cend(),
+            groupingKeys_.cbegin(),
+            groupingKeys_.cend(),
             [](const FieldAccessTypedExprPtr& x,
                const FieldAccessTypedExprPtr& y) -> bool {
               return (*x == *y);
@@ -1247,10 +1381,19 @@ class AggregationNode : public PlanNode {
     return globalGroupingSets_;
   }
 
-  std::optional<FieldAccessTypedExprPtr> groupId() const {
+  const std::optional<FieldAccessTypedExprPtr>& groupId() const {
     return groupId_;
   }
 
+  /// When true, indicates that for streaming aggregation, no sort group spans
+  /// across input batches. Each input batch contains complete data for its
+  /// groups - no group will appear in any subsequent input batch. This allows
+  /// the streaming aggregation operator to immediately produce the aggregation
+  /// result for all the groups in each input batch.
+  bool noGroupsSpanBatches() const {
+    return noGroupsSpanBatches_;
+  }
+
   std::string_view name() const override {
     return "Aggregation";
   }
@@ -1287,13 +1430,22 @@ class AggregationNode : public PlanNode {
   const std::vector<Aggregate> aggregates_;
   const bool ignoreNullKeys_;
 
-  std::optional<FieldAccessTypedExprPtr> groupId_;
-  std::vector<vector_size_t> globalGroupingSets_;
+  const std::optional<FieldAccessTypedExprPtr> groupId_;
+  const std::vector<vector_size_t> globalGroupingSets_;
+
+  // When true, indicates that for streaming aggregation, no sort group spans
+  // across input batches. Each input batch contains complete data for its
+  // groups - no group will appear in any subsequent input batch. This allows
+  // the streaming aggregation operator to immediately produce the aggregation
+  // result for all the groups in each input batch.
+  const bool noGroupsSpanBatches_;
 
   const std::vector<PlanNodePtr> sources_;
   const RowTypePtr outputType_;
 };
 
+using AggregationNodePtr = std::shared_ptr<const AggregationNode>;
+
 inline std::ostream& operator<<(
     std::ostream& out,
     const AggregationNode::Step& step) {
@@ -1316,14 +1468,64 @@ inline std::string mapAggregationStepToName(const AggregationNode::Step& step) {
   return ss.str();
 }
 
+/// Specify the column stats collection by aggregation. This is used by table
+/// writer plan nodes.
+struct ColumnStatsSpec : public ISerializable {
+  /// Grouping keys of the aggregation. It is set to partitioning keys for the
+  /// partitioned table. It is empty for unpartitioned table.
+  std::vector<FieldAccessTypedExprPtr> groupingKeys;
+
+  /// Step of the aggregation. Specifies the stage of multi-step aggregation
+  /// processing for column statistics collection:
+  /// - kSingle: used by TableWrite to complete aggregation in one step when no
+  ///   multi-stage processing needed.
+  /// - kPartial: used by TableWrite for the first stage of multi-step
+  ///   aggregation, produces intermediate results that need further processing
+  ///   (used in distributed scenarios)
+  /// - kIntermediate: used by TableWriteMerge in middle stage that processes
+  ///   partial results and produces more refined intermediate results for
+  ///   further aggregation
+  /// - kFinal: used by TableWriteMerge Final stage that processes intermediate
+  ///   results to produce the complete aggregated statistics.
+  AggregationNode::Step aggregationStep{AggregationNode::Step::kSingle};
+
+  /// Names of the aggregations.
+  std::vector<std::string> aggregateNames;
+
+  /// Aggregations.
+  std::vector<AggregationNode::Aggregate> aggregates;
+
+  ColumnStatsSpec(
+      std::vector<FieldAccessTypedExprPtr> _groupingKeys,
+      AggregationNode::Step _aggregationStep,
+      std::vector<std::string> _aggregateNames,
+      std::vector<AggregationNode::Aggregate> _aggregates)
+      : groupingKeys(std::move(_groupingKeys)),
+        aggregationStep(_aggregationStep),
+        aggregateNames(std::move(_aggregateNames)),
+        aggregates(std::move(_aggregates)) {
+    VELOX_CHECK(!aggregates.empty());
+    VELOX_CHECK_EQ(aggregates.size(), aggregateNames.size());
+  }
+
+  /// Returns the output row type that will be produced by this column stats
+  /// spec. The output type is determined by the grouping keys and aggregate
+  /// functions specified in the object.
+  RowTypePtr outputType() const;
+
+  folly::dynamic serialize() const override;
+
+  static ColumnStatsSpec create(const folly::dynamic& obj, void* context);
+};
+
 class TableWriteNode : public PlanNode {
  public:
   TableWriteNode(
       const PlanNodeId& id,
       const RowTypePtr& columns,
       const std::vector<std::string>& columnNames,
-      std::shared_ptr<AggregationNode> aggregationNode,
-      std::shared_ptr<InsertTableHandle> insertTableHandle,
+      std::optional<ColumnStatsSpec> columnStatsSpec,
+      std::shared_ptr<const InsertTableHandle> insertTableHandle,
       bool hasPartitioningScheme,
       RowTypePtr outputType,
       connector::CommitStrategy commitStrategy,
@@ -1332,7 +1534,7 @@ class TableWriteNode : public PlanNode {
         sources_{source},
         columns_{columns},
         columnNames_{columnNames},
-        aggregationNode_(std::move(aggregationNode)),
+        columnStatsSpec_(std::move(columnStatsSpec)),
         insertTableHandle_(std::move(insertTableHandle)),
         hasPartitioningScheme_(hasPartitioningScheme),
         outputType_(std::move(outputType)),
@@ -1355,7 +1557,7 @@ class TableWriteNode : public PlanNode {
       id_ = other.id();
       columns_ = other.columns();
       columnNames_ = other.columnNames();
-      aggregationNode_ = other.aggregationNode();
+      columnStatsSpec_ = other.columnStatsSpec();
       insertTableHandle_ = other.insertTableHandle();
       hasPartitioningScheme_ = other.hasPartitioningScheme();
       outputType_ = other.outputType();
@@ -1379,8 +1581,8 @@ class TableWriteNode : public PlanNode {
       return *this;
     }
 
-    Builder& aggregationNode(std::shared_ptr<AggregationNode> aggregationNode) {
-      aggregationNode_ = std::move(aggregationNode);
+    Builder& columnStatsSpec(std::optional<ColumnStatsSpec> columnStatsSpec) {
+      columnStatsSpec_ = std::move(columnStatsSpec);
       return *this;
     }
 
@@ -1417,10 +1619,6 @@ class TableWriteNode : public PlanNode {
       VELOX_USER_CHECK(
           columnNames_.has_value(), "TableWriteNode columnNames is not set");
       VELOX_USER_CHECK(
-          aggregationNode_.has_value(),
-          "TableWriteNode aggregationNode is not set");
-      VELOX_USER_CHECK(
-
           insertTableHandle_.has_value(),
           "TableWriteNode insertTableHandle is not set");
       VELOX_USER_CHECK(
@@ -1437,7 +1635,7 @@ class TableWriteNode : public PlanNode {
           id_.value(),
           columns_.value(),
           columnNames_.value(),
-          aggregationNode_.value(),
+          columnStatsSpec_,
           insertTableHandle_.value(),
           hasPartitioningScheme_.value(),
           outputType_.value(),
@@ -1449,8 +1647,8 @@ class TableWriteNode : public PlanNode {
     std::optional<PlanNodeId> id_;
     std::optional<RowTypePtr> columns_;
     std::optional<std::vector<std::string>> columnNames_;
-    std::optional<std::shared_ptr<AggregationNode>> aggregationNode_;
-    std::optional<std::shared_ptr<InsertTableHandle>> insertTableHandle_;
+    std::optional<ColumnStatsSpec> columnStatsSpec_;
+    std::optional<std::shared_ptr<const InsertTableHandle>> insertTableHandle_;
     std::optional<bool> hasPartitioningScheme_;
     std::optional<RowTypePtr> outputType_;
     std::optional<connector::CommitStrategy> commitStrategy_;
@@ -1480,7 +1678,7 @@ class TableWriteNode : public PlanNode {
     return columnNames_;
   }
 
-  const std::shared_ptr<InsertTableHandle>& insertTableHandle() const {
+  const std::shared_ptr<const InsertTableHandle>& insertTableHandle() const {
     return insertTableHandle_;
   }
 
@@ -1497,9 +1695,15 @@ class TableWriteNode : public PlanNode {
     return commitStrategy_;
   }
 
-  /// Optional aggregation node for column statistics collection
-  std::shared_ptr<AggregationNode> aggregationNode() const {
-    return aggregationNode_;
+  /// Returns true of this table write plan node has configured column
+  /// statistics collection.
+  bool hasColumnStatsSpec() const {
+    return columnStatsSpec_.has_value();
+  }
+
+  /// Optional spec for column statistics collection.
+  const std::optional<ColumnStatsSpec>& columnStatsSpec() const {
+    return columnStatsSpec_;
   }
 
   bool canSpill(const QueryConfig& queryConfig) const override {
@@ -1520,13 +1724,15 @@ class TableWriteNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
   const RowTypePtr columns_;
   const std::vector<std::string> columnNames_;
-  const std::shared_ptr<AggregationNode> aggregationNode_;
-  const std::shared_ptr<InsertTableHandle> insertTableHandle_;
+  const std::optional<ColumnStatsSpec> columnStatsSpec_;
+  const std::shared_ptr<const InsertTableHandle> insertTableHandle_;
   const bool hasPartitioningScheme_;
   const RowTypePtr outputType_;
   const connector::CommitStrategy commitStrategy_;
 };
 
+using TableWriteNodePtr = std::shared_ptr<const TableWriteNode>;
+
 class TableWriteMergeNode : public PlanNode {
  public:
   /// 'outputType' specifies the type to store the metadata of table write
@@ -1535,12 +1741,21 @@ class TableWriteMergeNode : public PlanNode {
   TableWriteMergeNode(
       const PlanNodeId& id,
       RowTypePtr outputType,
-      std::shared_ptr<AggregationNode> aggregationNode,
+      std::optional<ColumnStatsSpec> columnStatsSpec,
       PlanNodePtr source)
       : PlanNode(id),
-        aggregationNode_(std::move(aggregationNode)),
+        columnStatsSpec_(std::move(columnStatsSpec)),
         sources_{std::move(source)},
-        outputType_(std::move(outputType)) {}
+        outputType_(std::move(outputType)) {
+    if (hasColumnStatsSpec()) {
+      VELOX_USER_CHECK(
+          columnStatsSpec_->aggregationStep ==
+                  core::AggregationNode::Step::kFinal ||
+              columnStatsSpec_->aggregationStep ==
+                  core::AggregationNode::Step::kIntermediate,
+          "TableWriteMergeNode requires aggregation step to be intermediate or final");
+    }
+  }
 
   class Builder {
    public:
@@ -1549,7 +1764,7 @@ class TableWriteMergeNode : public PlanNode {
     explicit Builder(const TableWriteMergeNode& other) {
       id_ = other.id();
       outputType_ = other.outputType();
-      aggregationNode_ = other.aggregationNode();
+      columnStatsSpec_ = other.columnStatsSpec();
       VELOX_CHECK_EQ(other.sources().size(), 1);
       source_ = other.sources()[0];
     }
@@ -1564,8 +1779,8 @@ class TableWriteMergeNode : public PlanNode {
       return *this;
     }
 
-    Builder& aggregationNode(std::shared_ptr<AggregationNode> aggregationNode) {
-      aggregationNode_ = std::move(aggregationNode);
+    Builder& columnStatsSpec(std::optional<ColumnStatsSpec> columnStatsSpec) {
+      columnStatsSpec_ = std::move(columnStatsSpec);
       return *this;
     }
 
@@ -1578,29 +1793,29 @@ class TableWriteMergeNode : public PlanNode {
       VELOX_USER_CHECK(id_.has_value(), "TableWriteMergeNode id is not set");
       VELOX_USER_CHECK(
           outputType_.has_value(), "TableWriteMergeNode outputType is not set");
-      VELOX_USER_CHECK(
-          aggregationNode_.has_value(),
-          "TableWriteMergeNode aggregationNode is not set");
       VELOX_USER_CHECK(
           source_.has_value(), "TableWriteMergeNode source is not set");
 
       return std::make_shared<TableWriteMergeNode>(
-          id_.value(),
-          outputType_.value(),
-          aggregationNode_.value(),
-          source_.value());
+          id_.value(), outputType_.value(), columnStatsSpec_, source_.value());
     }
 
    private:
     std::optional<PlanNodeId> id_;
     std::optional<RowTypePtr> outputType_;
-    std::optional<std::shared_ptr<AggregationNode>> aggregationNode_;
+    std::optional<ColumnStatsSpec> columnStatsSpec_;
     std::optional<PlanNodePtr> source_;
   };
 
-  /// Optional aggregation node for column statistics collection
-  std::shared_ptr<AggregationNode> aggregationNode() const {
-    return aggregationNode_;
+  /// Returns true of this table write merge plan node has configured column
+  /// statistics collection.
+  bool hasColumnStatsSpec() const {
+    return columnStatsSpec_.has_value();
+  }
+
+  /// Optional spec for column statistics collection.
+  const std::optional<ColumnStatsSpec>& columnStatsSpec() const {
+    return columnStatsSpec_;
   }
 
   const std::vector<PlanNodePtr>& sources() const override {
@@ -1625,11 +1840,13 @@ class TableWriteMergeNode : public PlanNode {
  private:
   void addDetails(std::stringstream& stream) const override;
 
-  const std::shared_ptr<AggregationNode> aggregationNode_;
+  const std::optional<ColumnStatsSpec> columnStatsSpec_;
   const std::vector<PlanNodePtr> sources_;
   const RowTypePtr outputType_;
 };
 
+using TableWriteMergeNodePtr = std::shared_ptr<const TableWriteMergeNode>;
+
 /// 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
@@ -1733,6 +1950,8 @@ class ExpandNode : public PlanNode {
   const std::vector<std::vector<TypedExprPtr>> projections_;
 };
 
+using ExpandNodePtr = std::shared_ptr<const ExpandNode>;
+
 /// 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
@@ -1901,6 +2120,8 @@ class GroupIdNode : public PlanNode {
   const std::string groupIdName_;
 };
 
+using GroupIdNodePtr = std::shared_ptr<const GroupIdNode>;
+
 class ExchangeNode : public PlanNode {
  public:
   ExchangeNode(
@@ -1987,6 +2208,8 @@ class ExchangeNode : public PlanNode {
   const VectorSerde::Kind serdeKind_;
 };
 
+using ExchangeNodePtr = std::shared_ptr<const ExchangeNode>;
+
 class MergeExchangeNode : public ExchangeNode {
  public:
   MergeExchangeNode(
@@ -2087,6 +2310,8 @@ class MergeExchangeNode : public ExchangeNode {
   const std::vector<SortOrder> sortingOrders_;
 };
 
+using MergeExchangeNodePtr = std::shared_ptr<const MergeExchangeNode>;
+
 class LocalMergeNode : public PlanNode {
  public:
   LocalMergeNode(
@@ -2169,6 +2394,10 @@ class LocalMergeNode : public PlanNode {
     return sortingKeys_;
   }
 
+  bool canSpill(const QueryConfig& queryConfig) const override {
+    return !sortingKeys_.empty() && queryConfig.localMergeSpillEnabled();
+  }
+
   const std::vector<SortOrder>& sortingOrders() const {
     return sortingOrders_;
   }
@@ -2189,6 +2418,8 @@ class LocalMergeNode : public PlanNode {
   const std::vector<SortOrder> sortingOrders_;
 };
 
+using LocalMergeNodePtr = std::shared_ptr<const LocalMergeNode>;
+
 /// Calculates partition number for each row of the specified vector.
 class PartitionFunction {
  public:
@@ -2258,9 +2489,7 @@ class LocalPartitionNode : public PlanNode {
     kRepartition,
   };
 
-  static const char* typeName(Type type);
-
-  static Type typeFromName(const std::string& name);
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(Type);
 
   /// If 'scaleWriter' is true, the local partition is used to scale the table
   /// writer prcessing.
@@ -2282,7 +2511,7 @@ class LocalPartitionNode : public PlanNode {
 
     VELOX_USER_CHECK_NOT_NULL(partitionFunctionSpec_);
 
-    for (auto i = 1; i < sources_.size(); ++i) {
+    for (size_t i = 1; i < sources_.size(); ++i) {
       VELOX_USER_CHECK(
           *sources_[i]->outputType() == *sources_[0]->outputType(),
           "All sources of the LocalPartitionedNode must have the same output type: {} vs. {}.",
@@ -2412,6 +2641,8 @@ class LocalPartitionNode : public PlanNode {
   const PartitionFunctionSpecPtr partitionFunctionSpec_;
 };
 
+using LocalPartitionNodePtr = std::shared_ptr<const LocalPartitionNode>;
+
 class PartitionedOutputNode : public PlanNode {
  public:
   enum class Kind {
@@ -2419,8 +2650,8 @@ class PartitionedOutputNode : public PlanNode {
     kBroadcast,
     kArbitrary,
   };
-  static std::string kindString(Kind kind);
-  static Kind stringToKind(const std::string& str);
+
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(Kind)
 
   PartitionedOutputNode(
       const PlanNodeId& id,
@@ -2617,6 +2848,7 @@ class PartitionedOutputNode : public PlanNode {
   }
 
   const PartitionFunctionSpec& partitionFunctionSpec() const {
+    VELOX_CHECK_NOT_NULL(partitionFunctionSpec_);
     return *partitionFunctionSpec_;
   }
 
@@ -2641,10 +2873,12 @@ class PartitionedOutputNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using PartitionedOutputNodePtr = std::shared_ptr<const PartitionedOutputNode>;
+
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
     std::ostream& out,
     const PartitionedOutputNode::Kind kind) {
-  out << PartitionedOutputNode::kindString(kind);
+  out << PartitionedOutputNode::toName(kind);
   return out;
 }
 
@@ -2652,81 +2886,75 @@ enum class JoinType {
   // For each row on the left, find all matching rows on the right and return
   // all combinations.
   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 = 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
+  // 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 = 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
-  // match on the right with right-side columns filled with nulls. Also,
-  // return
-  // all rows from the
-  // right that have no match on the left with left-side columns filled with
-  // nulls.
+  // 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. Also, return all rows from the right that have
+  // no match on the left with left-side columns filled with nulls.
   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.
+  // right side. For this join type, cardinality of the output is less than or
+  // equal to the cardinality of the left side.
   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.
+  // of the output equals the cardinality of the left side.
   //
   // The handling of the rows with nulls in the join key depends on the
   // 'nullAware' boolean specified separately.
   //
-  // Null-aware join follows IN semantic. Regular join follows EXISTS
-  // semantic.
+  // Null-aware join follows IN semantic. Regular join follows EXISTS semantic.
   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.
+  // the output is less than or equal to the cardinality of the right side.
   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
+  // For this join type, cardinality of the output equals the cardinality of the
   // right side.
   //
   // The handling of the rows with nulls in the join key depends on the
   // 'nullAware' boolean specified separately.
   //
-  // Null-aware join follows IN semantic. Regular join follows EXISTS
-  // semantic.
+  // Null-aware join follows IN semantic. Regular join follows EXISTS semantic.
   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.
   //
   // Null-aware join follows NOT IN semantic:
-  // (1) return empty result if the right side contains a record with a null
-  // in
+  // (1) return empty result if the right side contains a record with a null in
   // the join key;
-  // (2) return left-side row with null in the join key only when
-  // the right side is empty.
+  // (2) return left-side row with null in the join key only when the right side
+  // is empty.
   //
   // 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 = 8,
+
   kNumJoinTypes = 9,
 };
 
-const char* joinTypeName(JoinType joinType);
-
-JoinType joinTypeFromName(const std::string& name);
+VELOX_DECLARE_ENUM_NAME(JoinType);
 
 inline bool isInnerJoin(JoinType joinType) {
   return joinType == JoinType::kInner;
@@ -2906,6 +3134,15 @@ class AbstractJoinNode : public PlanNode {
     return isInnerJoin() || isLeftJoin() || isAntiJoin();
   }
 
+  /// Indicates if this joinNode can drop duplicate rows with same join key.
+  /// For left semi and anti join, it is not necessary to store duplicate rows.
+  bool canDropDuplicates() const {
+    // Left semi and anti join with no extra filter only needs to know whether
+    // there is a match. Hence, no need to store entries with duplicate keys.
+    return !filter() &&
+        (isLeftSemiFilterJoin() || isLeftSemiProjectJoin() || isAntiJoin());
+  }
+
   const std::vector<FieldAccessTypedExprPtr>& leftKeys() const {
     return leftKeys_;
   }
@@ -2919,6 +3156,7 @@ class AbstractJoinNode : public PlanNode {
   }
 
  protected:
+  void validate() const;
   void addDetails(std::stringstream& stream) const override;
 
   folly::dynamic serializeBase() const;
@@ -2953,7 +3191,8 @@ class HashJoinNode : public AbstractJoinNode {
       TypedExprPtr filter,
       PlanNodePtr left,
       PlanNodePtr right,
-      RowTypePtr outputType)
+      RowTypePtr outputType,
+      bool useHashTableCache = false)
       : AbstractJoinNode(
             id,
             joinType,
@@ -2963,7 +3202,10 @@ class HashJoinNode : public AbstractJoinNode {
             std::move(left),
             std::move(right),
             std::move(outputType)),
-        nullAware_{nullAware} {
+        nullAware_{nullAware},
+        useHashTableCache_{useHashTableCache} {
+    validate();
+
     if (nullAware) {
       VELOX_USER_CHECK(
           isNullAwareSupported(joinType),
@@ -2986,6 +3228,7 @@ class HashJoinNode : public AbstractJoinNode {
     explicit Builder(const HashJoinNode& other)
         : AbstractJoinNode::Builder<HashJoinNode, Builder>(other) {
       nullAware_ = other.isNullAware();
+      useHashTableCache_ = other.useHashTableCache();
     }
 
     Builder& nullAware(bool value) {
@@ -2993,6 +3236,11 @@ class HashJoinNode : public AbstractJoinNode {
       return *this;
     }
 
+    Builder& useHashTableCache(bool value) {
+      useHashTableCache_ = value;
+      return *this;
+    }
+
     std::shared_ptr<HashJoinNode> build() const {
       VELOX_USER_CHECK(id_.has_value(), "HashJoinNode id is not set");
       VELOX_USER_CHECK(
@@ -3019,11 +3267,13 @@ class HashJoinNode : public AbstractJoinNode {
           filter_.value_or(nullptr),
           left_.value(),
           right_.value(),
-          outputType_.value());
+          outputType_.value(),
+          useHashTableCache_.value_or(false));
     }
 
    private:
     std::optional<bool> nullAware_;
+    std::optional<bool> useHashTableCache_;
   };
 
   std::string_view name() const override {
@@ -3046,6 +3296,12 @@ class HashJoinNode : public AbstractJoinNode {
     return nullAware_;
   }
 
+  /// Returns whether hash table caching is enabled for broadcast joins.
+  /// Only used by Presto-on-Spark.
+  bool useHashTableCache() const {
+    return useHashTableCache_;
+  }
+
   folly::dynamic serialize() const override;
 
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
@@ -3054,8 +3310,11 @@ class HashJoinNode : public AbstractJoinNode {
   void addDetails(std::stringstream& stream) const override;
 
   const bool nullAware_;
+  const bool useHashTableCache_;
 };
 
+using HashJoinNodePtr = std::shared_ptr<const HashJoinNode>;
+
 /// Represents inner/outer/semi/anti merge joins. Translates to an
 /// exec::MergeJoin operator. Assumes that both left and right input data is
 /// sorted on the join keys. A separate pipeline that puts its output into
@@ -3126,6 +3385,8 @@ class MergeJoinNode : public AbstractJoinNode {
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
 };
 
+using MergeJoinNodePtr = std::shared_ptr<const MergeJoinNode>;
+
 struct IndexLookupCondition : public ISerializable {
   /// References to an index table column.
   FieldAccessTypedExprPtr key;
@@ -3145,6 +3406,7 @@ struct IndexLookupCondition : public ISerializable {
 
   virtual std::string toString() const = 0;
 };
+
 using IndexLookupConditionPtr = std::shared_ptr<IndexLookupCondition>;
 
 /// Represents IN-LIST index lookup condition: contains('list', 'key'). 'list'
@@ -3172,6 +3434,7 @@ struct InIndexLookupCondition : public IndexLookupCondition {
  private:
   void validate() const;
 };
+
 using InIndexLookupConditionPtr = std::shared_ptr<InIndexLookupCondition>;
 
 /// Represents BETWEEN index lookup condition: 'key' between 'lower' and
@@ -3207,9 +3470,37 @@ struct BetweenIndexLookupCondition : public IndexLookupCondition {
  private:
   void validate() const;
 };
+
 using BetweenIndexLookupConditionPtr =
     std::shared_ptr<BetweenIndexLookupCondition>;
 
+/// Represents EQUAL index lookup condition: 'key' = 'value'. 'value' must be a
+/// constant value with the same type as 'key'.
+struct EqualIndexLookupCondition : public IndexLookupCondition {
+  /// The value to compare against.
+  TypedExprPtr value;
+
+  EqualIndexLookupCondition(FieldAccessTypedExprPtr _key, TypedExprPtr _value)
+      : IndexLookupCondition(std::move(_key)), value(std::move(_value)) {
+    validate();
+  }
+
+  bool isFilter() const override;
+
+  folly::dynamic serialize() const override;
+
+  std::string toString() const override;
+
+  static IndexLookupConditionPtr create(
+      const folly::dynamic& obj,
+      void* context);
+
+ private:
+  void validate() const;
+};
+
+using EqualIndexLookupConditionPtr = std::shared_ptr<EqualIndexLookupCondition>;
+
 /// Represents index lookup join. Translates to an exec::IndexLookupJoin
 /// operator. Assumes the right input is a table scan source node that provides
 /// indexed table lookup for the left input with the specified join keys and
@@ -3246,46 +3537,28 @@ class IndexLookupJoinNode : public AbstractJoinNode {
  public:
   /// @param joinType Specifies the lookup join type. Only INNER and LEFT joins
   /// are supported.
+  /// @param leftKeys Left side join keys used for index lookup.
+  /// @param rightKeys Right side join keys that form the index prefix.
+  /// @param joinConditions Additional conditions for index lookup that can't
+  /// be converted into simple equality join conditions. These conditions use
+  /// columns from both left and right  and exactly one index column from
+  /// the right side.sides
+  /// @param filter Additional filter to apply on join results. This supports
+  /// filters that can't be converted into join conditions.
+  /// @param hasMarker if true, the output type includes a boolean
+  /// column at the end to indicate if a join output row has a match or not.
+  /// This only applies for left join.
   IndexLookupJoinNode(
       const PlanNodeId& id,
       JoinType joinType,
       const std::vector<FieldAccessTypedExprPtr>& leftKeys,
       const std::vector<FieldAccessTypedExprPtr>& rightKeys,
       const std::vector<IndexLookupConditionPtr>& joinConditions,
+      TypedExprPtr filter,
+      bool hasMarker,
       PlanNodePtr left,
       TableScanNodePtr right,
-      RowTypePtr outputType)
-      : AbstractJoinNode(
-            id,
-            joinType,
-            leftKeys,
-            rightKeys,
-            /*filter=*/nullptr,
-            std::move(left),
-            right,
-            outputType),
-        lookupSourceNode_(std::move(right)),
-        joinConditions_(joinConditions) {
-    VELOX_USER_CHECK(
-        !leftKeys.empty(),
-        "The lookup join node requires at least one join key");
-    VELOX_USER_CHECK_EQ(
-        leftKeys_.size(),
-        rightKeys_.size(),
-        "The lookup join node requires same number of join keys on left and right sides");
-    // TODO: add check that (1) 'rightKeys_' form an index prefix. each of
-    // 'joinConditions_' uses columns from both sides and uses exactly one index
-    // column from the right side.
-    VELOX_USER_CHECK(
-        lookupSourceNode_->tableHandle()->supportsIndexLookup(),
-        "The lookup table handle {} from connector {} doesn't support index lookup",
-        lookupSourceNode_->tableHandle()->name(),
-        lookupSourceNode_->tableHandle()->connectorId());
-    VELOX_USER_CHECK(
-        isSupported(joinType_),
-        "Unsupported index lookup join type {}",
-        joinTypeName(joinType_));
-  }
+      RowTypePtr outputType);
 
   class Builder
       : public AbstractJoinNode::Builder<IndexLookupJoinNode, Builder> {
@@ -3295,14 +3568,30 @@ class IndexLookupJoinNode : public AbstractJoinNode {
     explicit Builder(const IndexLookupJoinNode& other)
         : AbstractJoinNode::Builder<IndexLookupJoinNode, Builder>(other) {
       joinConditions_ = other.joinConditions();
+      filter_ = other.filter();
+      hasMarker_ = other.hasMarker();
     }
 
+    /// Set lookup conditions for index lookup that can't be converted into
+    /// simple equality join conditions.
     Builder& joinConditions(
         std::vector<IndexLookupConditionPtr> joinConditions) {
       joinConditions_ = std::move(joinConditions);
       return *this;
     }
 
+    /// Set additional filter to apply on join results.
+    Builder& filter(TypedExprPtr filter) {
+      filter_ = std::move(filter);
+      return *this;
+    }
+
+    /// Set whether to include a marker column for left joins.
+    Builder& hasMarker(bool hasMarker) {
+      hasMarker_ = hasMarker;
+      return *this;
+    }
+
     std::shared_ptr<IndexLookupJoinNode> build() const {
       VELOX_USER_CHECK(id_.has_value(), "IndexLookupJoinNode id is not set");
       VELOX_USER_CHECK(
@@ -3317,23 +3606,23 @@ class IndexLookupJoinNode : public AbstractJoinNode {
           right_.has_value(), "IndexLookupJoinNode right source is not set");
       VELOX_USER_CHECK(
           outputType_.has_value(), "IndexLookupJoinNode outputType is not set");
-      VELOX_USER_CHECK(
-          joinConditions_.has_value(),
-          "IndexLookupJoinNode join conditions are not set");
 
       return std::make_shared<IndexLookupJoinNode>(
           id_.value(),
           joinType_.value(),
           leftKeys_.value(),
           rightKeys_.value(),
-          joinConditions_.value(),
+          joinConditions_,
+          filter_.value_or(nullptr),
+          hasMarker_,
           left_.value(),
           std::dynamic_pointer_cast<const TableScanNode>(right_.value()),
           outputType_.value());
     }
 
    private:
-    std::optional<std::vector<IndexLookupConditionPtr>> joinConditions_;
+    std::vector<IndexLookupConditionPtr> joinConditions_;
+    bool hasMarker_{false};
   };
 
   bool supportsBarrier() const override {
@@ -3344,6 +3633,8 @@ class IndexLookupJoinNode : public AbstractJoinNode {
     return lookupSourceNode_;
   }
 
+  /// Returns the join conditions for index lookup that can't be converted into
+  /// simple equality join conditions.
   const std::vector<IndexLookupConditionPtr>& joinConditions() const {
     return joinConditions_;
   }
@@ -3352,6 +3643,11 @@ class IndexLookupJoinNode : public AbstractJoinNode {
     return "IndexLookupJoin";
   }
 
+  /// Returns whether this node includes a marker column for left joins.
+  bool hasMarker() const {
+    return hasMarker_;
+  }
+
   void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
       const override;
 
@@ -3365,11 +3661,20 @@ class IndexLookupJoinNode : public AbstractJoinNode {
  private:
   void addDetails(std::stringstream& stream) const override;
 
+  /// The table scan node that provides the lookup source for index operations.
   const TableScanNodePtr lookupSourceNode_;
 
+  /// Join conditions that can't be converted into simple equality join
+  /// conditions. These conditions involve columns from both left and right
+  /// sides and exactly one index column from the right side.
   const std::vector<IndexLookupConditionPtr> joinConditions_;
+
+  /// Whether to include a marker column for left joins to indicate matches.
+  const bool hasMarker_;
 };
 
+using IndexLookupJoinNodePtr = std::shared_ptr<const IndexLookupJoinNode>;
+
 /// Returns true if 'planNode' is index lookup join node.
 bool isIndexLookupJoin(const core::PlanNode* planNode);
 
@@ -3514,6 +3819,8 @@ class NestedLoopJoinNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using NestedLoopJoinNodePtr = std::shared_ptr<const NestedLoopJoinNode>;
+
 // Represents the 'SortBy' node in the plan.
 class OrderByNode : public PlanNode {
  public:
@@ -3655,6 +3962,228 @@ class OrderByNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
 };
 
+using OrderByNodePtr = std::shared_ptr<const OrderByNode>;
+
+/// Represents a spatial join between two geometries. Translates to an
+/// exec::SpatialJoinProbe and exec::SpatialJoinBuild. A separate
+/// pipeline is produced for the build side when generating exec::Operators.
+///
+/// Spatial join supports "local" spatial predicates, i.e. predicates that
+/// require defined proximity.  Examples include ST_Intersects or any of
+/// the DE-9IM predicates except for ST_Disjoint.  It also supports
+/// `ST_Distance(g1, g2) <= d`.
+///
+/// The local join index is a collection of bounding boxes for a quick
+/// check (either "no" or "maybe"), and the actual predicate must be
+/// checked for each candidate.
+///
+/// Currently only INNER joins are supported, but LEFT joins are planned.
+class SpatialJoinNode : public PlanNode {
+ public:
+  SpatialJoinNode(
+      const PlanNodeId& id,
+      JoinType joinType,
+      TypedExprPtr joinCondition,
+      FieldAccessTypedExprPtr probeGeometry,
+      FieldAccessTypedExprPtr buildGeometry,
+      std::optional<FieldAccessTypedExprPtr> radius,
+      PlanNodePtr left,
+      PlanNodePtr right,
+      RowTypePtr outputType);
+
+  SpatialJoinNode(
+      const PlanNodeId& id,
+      JoinType joinType,
+      TypedExprPtr joinCondition,
+      PlanNodePtr left,
+      PlanNodePtr right,
+      RowTypePtr outputType);
+
+  PlanNodePtr leftNode() const {
+    return sources()[0];
+  }
+
+  PlanNodePtr rightNode() const {
+    return sources()[1];
+  }
+
+  class Builder {
+   public:
+    Builder() = default;
+
+    explicit Builder(const SpatialJoinNode& other) {
+      id_ = other.id();
+      joinType_ = other.joinType();
+      joinCondition_ = other.joinCondition();
+      probeGeometry_ = other.probeGeometry();
+      buildGeometry_ = other.buildGeometry();
+      radius_ = other.radius();
+      VELOX_CHECK_EQ(other.sources().size(), 2);
+      left_ = other.sources()[0];
+      right_ = other.sources()[1];
+      outputType_ = other.outputType();
+    }
+
+    Builder& id(PlanNodeId id) {
+      id_ = std::move(id);
+      return *this;
+    }
+
+    Builder& joinType(JoinType joinType) {
+      joinType_ = joinType;
+      return *this;
+    }
+
+    Builder& joinCondition(TypedExprPtr joinCondition) {
+      joinCondition_ = std::move(joinCondition);
+      return *this;
+    }
+
+    Builder& probeGeometry(FieldAccessTypedExprPtr probeGeometry) {
+      probeGeometry_ = std::move(probeGeometry);
+      return *this;
+    }
+
+    Builder& buildGeometry(FieldAccessTypedExprPtr buildGeometry) {
+      buildGeometry_ = std::move(buildGeometry);
+      return *this;
+    }
+
+    Builder& radius(FieldAccessTypedExprPtr radius) {
+      radius_ = std::move(radius);
+      return *this;
+    }
+
+    Builder& left(PlanNodePtr left) {
+      left_ = std::move(left);
+      return *this;
+    }
+
+    Builder& right(PlanNodePtr right) {
+      right_ = std::move(right);
+      return *this;
+    }
+
+    Builder& outputType(RowTypePtr outputType) {
+      outputType_ = std::move(outputType);
+      return *this;
+    }
+
+    std::shared_ptr<SpatialJoinNode> build() const {
+      VELOX_USER_CHECK(id_.has_value(), "SpatialJoinNode id is not set");
+      VELOX_USER_CHECK(
+          left_.has_value(), "SpatialJoinNode left source is not set");
+      VELOX_USER_CHECK(
+          right_.has_value(), "SpatialJoinNode right source is not set");
+      VELOX_USER_CHECK(
+          outputType_.has_value(), "SpatialJoinNode outputType is not set");
+      VELOX_USER_CHECK(
+          probeGeometry_.has_value(),
+          "SpatialJoinNode probe geometry is not set");
+      VELOX_USER_CHECK(
+          buildGeometry_.has_value(),
+          "SpatialJoinNode build geometry is not set");
+
+      VELOX_USER_CHECK(
+          (probeGeometry_.has_value() && buildGeometry_.has_value()) ||
+              (!probeGeometry_.has_value() && !buildGeometry_.has_value()),
+          "Either probe and build geometry must both be set, or neither");
+
+      if (probeGeometry_.has_value() && buildGeometry_.has_value()) {
+        return std::make_shared<SpatialJoinNode>(
+            id_.value(),
+            joinType_,
+            joinCondition_,
+            probeGeometry_.value(),
+            buildGeometry_.value(),
+            radius_,
+            left_.value(),
+            right_.value(),
+            outputType_.value());
+      }
+
+      return std::make_shared<SpatialJoinNode>(
+          id_.value(),
+          joinType_,
+          joinCondition_,
+          probeGeometry_.value(),
+          buildGeometry_.value(),
+          radius_,
+          left_.value(),
+          right_.value(),
+          outputType_.value());
+    }
+
+   private:
+    std::optional<PlanNodeId> id_;
+    JoinType joinType_ = kDefaultJoinType;
+    TypedExprPtr joinCondition_;
+    std::optional<FieldAccessTypedExprPtr> probeGeometry_;
+    std::optional<FieldAccessTypedExprPtr> buildGeometry_;
+    std::optional<FieldAccessTypedExprPtr> radius_;
+    std::optional<PlanNodePtr> left_;
+    std::optional<PlanNodePtr> right_;
+    std::optional<RowTypePtr> outputType_;
+  };
+
+  const std::vector<PlanNodePtr>& sources() const override {
+    return sources_;
+  }
+
+  void accept(const PlanNodeVisitor& visitor, PlanNodeVisitorContext& context)
+      const override;
+
+  const RowTypePtr& outputType() const override {
+    return outputType_;
+  }
+
+  std::string_view name() const override {
+    return "SpatialJoin";
+  }
+
+  const TypedExprPtr& joinCondition() const {
+    return joinCondition_;
+  }
+
+  const FieldAccessTypedExprPtr& probeGeometry() const {
+    return probeGeometry_;
+  }
+
+  const FieldAccessTypedExprPtr& buildGeometry() const {
+    return buildGeometry_;
+  }
+
+  const std::optional<FieldAccessTypedExprPtr>& radius() const {
+    return radius_;
+  }
+
+  JoinType joinType() const {
+    return joinType_;
+  }
+
+  folly::dynamic serialize() const override;
+
+  /// If spatial join supports this join type.
+  static bool isSupported(JoinType joinType);
+
+  static PlanNodePtr create(const folly::dynamic& obj, void* context);
+
+ private:
+  constexpr static JoinType kDefaultJoinType = JoinType::kInner;
+
+  void addDetails(std::stringstream& stream) const override;
+
+  const JoinType joinType_;
+  const TypedExprPtr joinCondition_;
+  const FieldAccessTypedExprPtr probeGeometry_;
+  const FieldAccessTypedExprPtr buildGeometry_;
+  const std::optional<FieldAccessTypedExprPtr> radius_;
+  const std::vector<PlanNodePtr> sources_;
+  const RowTypePtr outputType_;
+};
+
+using SpatialJoinNodePtr = std::shared_ptr<const SpatialJoinNode>;
+
 class TopNNode : public PlanNode {
  public:
   TopNNode(
@@ -3782,6 +4311,8 @@ class TopNNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
 };
 
+using TopNNodePtr = std::shared_ptr<const TopNNode>;
+
 class LimitNode : public PlanNode {
  public:
   // @param isPartial Boolean indicating whether Limit node generates partial
@@ -3866,6 +4397,10 @@ class LimitNode : public PlanNode {
     std::optional<PlanNodePtr> source_;
   };
 
+  bool supportsBarrier() const override {
+    return true;
+  }
+
   const RowTypePtr& outputType() const override {
     return sources_[0]->outputType();
   }
@@ -3906,6 +4441,8 @@ class LimitNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
 };
 
+using LimitNodePtr = std::shared_ptr<const LimitNode>;
+
 /// Expands arrays and maps into separate columns. Arrays are expanded into a
 /// single column, and maps are expanded into two columns (key, value). Can be
 /// used to expand multiple columns. In this case will produce as many rows as
@@ -3922,12 +4459,17 @@ class UnnestNode : public PlanNode {
   /// names must appear in the same order as unnestVariables.
   /// @param ordinalityName Optional name for the ordinality columns. If not
   /// present, ordinality column is not produced.
+  /// @param markerName Optional name for column which indicates whether an
+  /// output row has non-empty unnested value. If not present, marker column is
+  /// not provided and the unnest operator also skips producing output rows
+  /// with empty unnest value.
   UnnestNode(
       const PlanNodeId& id,
       std::vector<FieldAccessTypedExprPtr> replicateVariables,
       std::vector<FieldAccessTypedExprPtr> unnestVariables,
       std::vector<std::string> unnestNames,
       std::optional<std::string> ordinalityName,
+      std::optional<std::string> markerName,
       const PlanNodePtr& source);
 
   class Builder {
@@ -3976,6 +4518,11 @@ class UnnestNode : public PlanNode {
       return *this;
     }
 
+    Builder& markerName(std::optional<std::string> markerName) {
+      markerName_ = std::move(markerName);
+      return *this;
+    }
+
     std::shared_ptr<UnnestNode> build() const {
       VELOX_USER_CHECK(id_.has_value(), "UnnestNode id is not set");
       VELOX_USER_CHECK(
@@ -3994,6 +4541,7 @@ class UnnestNode : public PlanNode {
           unnestVariables_.value(),
           unnestNames_.value(),
           ordinalityName_,
+          markerName_,
           source_.value());
     }
 
@@ -4003,6 +4551,7 @@ class UnnestNode : public PlanNode {
     std::optional<std::vector<FieldAccessTypedExprPtr>> unnestVariables_;
     std::optional<std::vector<std::string>> unnestNames_;
     std::optional<std::string> ordinalityName_;
+    std::optional<std::string> markerName_;
     std::optional<PlanNodePtr> source_;
   };
 
@@ -4032,10 +4581,26 @@ class UnnestNode : public PlanNode {
     return unnestVariables_;
   }
 
-  bool withOrdinality() const {
+  const std::vector<std::string>& unnestNames() const {
+    return unnestNames_;
+  }
+
+  const std::optional<std::string>& ordinalityName() const {
+    return ordinalityName_;
+  }
+
+  bool hasOrdinality() const {
     return ordinalityName_.has_value();
   }
 
+  const std::optional<std::string>& markerName() const {
+    return markerName_;
+  }
+
+  bool hasMarker() const {
+    return markerName_.has_value();
+  }
+
   std::string_view name() const override {
     return "Unnest";
   }
@@ -4051,10 +4616,13 @@ class UnnestNode : public PlanNode {
   const std::vector<FieldAccessTypedExprPtr> unnestVariables_;
   const std::vector<std::string> unnestNames_;
   const std::optional<std::string> ordinalityName_;
+  const std::optional<std::string> markerName_;
   const std::vector<PlanNodePtr> sources_;
   RowTypePtr outputType_;
 };
 
+using UnnestNodePtr = std::shared_ptr<const UnnestNode>;
+
 /// Checks that input contains at most one row. Return that row as is. If
 /// input is empty, returns a single row with all values set to null. If input
 /// contains more than one row raises an exception.
@@ -4124,6 +4692,8 @@ class EnforceSingleRowNode : public PlanNode {
   const std::vector<PlanNodePtr> sources_;
 };
 
+using EnforceSingleRowNodePtr = std::shared_ptr<const EnforceSingleRowNode>;
+
 /// Adds a new column named `idName` at the end of the input columns
 /// with unique int64_t value per input row.
 ///
@@ -4142,6 +4712,10 @@ class AssignUniqueIdNode : public PlanNode {
       const int32_t taskUniqueId,
       PlanNodePtr source);
 
+  bool supportsBarrier() const override {
+    return true;
+  }
+
   class Builder {
    public:
     Builder() = default;
@@ -4230,6 +4804,8 @@ class AssignUniqueIdNode : public PlanNode {
   std::shared_ptr<std::atomic_int64_t> uniqueIdCounter_;
 };
 
+using AssignUniqueIdNodePtr = std::shared_ptr<const AssignUniqueIdNode>;
+
 /// PlanNode used for evaluating Sql window functions.
 /// All window functions evaluated in the operator have the same
 /// window spec (partition keys + order columns).
@@ -4249,9 +4825,7 @@ class WindowNode : public PlanNode {
  public:
   enum class WindowType { kRange, kRows };
 
-  static const char* windowTypeName(WindowType type);
-
-  static WindowType windowTypeFromName(const std::string& name);
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(WindowType)
 
   enum class BoundType {
     kUnboundedPreceding,
@@ -4261,9 +4835,7 @@ class WindowNode : public PlanNode {
     kUnboundedFollowing
   };
 
-  static const char* boundTypeName(BoundType type);
-
-  static BoundType boundTypeFromName(const std::string& name);
+  VELOX_DECLARE_EMBEDDED_ENUM_NAME(BoundType)
 
   /// Window frames can be ROW or RANGE type.
   /// Frame bounds can be CURRENT ROW, UNBOUNDED PRECEDING(FOLLOWING)
@@ -4451,6 +5023,10 @@ class WindowNode : public PlanNode {
     return "Window";
   }
 
+  const std::vector<std::string>& windowColumnNames() const {
+    return windowColumnNames_;
+  }
+
   folly::dynamic serialize() const override;
 
   static PlanNodePtr create(const folly::dynamic& obj, void* context);
@@ -4473,6 +5049,8 @@ class WindowNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using WindowNodePtr = std::shared_ptr<const WindowNode>;
+
 /// Optimized version of a WindowNode for a single row_number function with an
 /// optional limit and no sorting.
 /// The output of this node contains all input columns followed by an optional
@@ -4607,6 +5185,8 @@ class RowNumberNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using RowNumberNodePtr = std::shared_ptr<const RowNumberNode>;
+
 /// The MarkDistinct operator marks unique rows based on distinctKeys.
 /// The result is put in a new markerName column alongside the original input.
 /// @param markerName Name of the output mask channel.
@@ -4717,24 +5297,40 @@ class MarkDistinctNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
-/// Optimized version of a WindowNode for a single row_number function with a
-/// limit over sorted partitions.
-/// The output of this node contains all input columns followed by an optional
+using MarkDistinctNodePtr = std::shared_ptr<const MarkDistinctNode>;
+
+/// Optimized version of a WindowNode for a single row_number, rank or
+/// dense_rank function with a limit over sorted partitions. The output of this
+/// node contains all input columns followed by an optional
 /// 'rowNumberColumnName' BIGINT column.
+/// TODO: This node will be renamed to TopNRank or TopNRowNode once all the
+/// support for handling rank and dense_rank is committed to Velox.
 class TopNRowNumberNode : public PlanNode {
  public:
+  enum class RankFunction {
+    kRowNumber,
+    kRank,
+    kDenseRank,
+  };
+
+  static const char* rankFunctionName(RankFunction function);
+
+  static RankFunction rankFunctionFromName(std::string_view name);
+
+  /// @param rankFunction RanksFunction (row_number, rank, dense_rank) for TopN.
   /// @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.
+  /// numbers or rank or dense_rank. If not specified, the output doesn't
+  /// include 'row_number' column. This is used when computing partial results.
   /// @param limit Per-partition limit. The number of
   /// rows produced by this node will not exceed this value for any given
   /// partition. Extra rows will be dropped.
   TopNRowNumberNode(
       PlanNodeId id,
+      RankFunction function,
       std::vector<FieldAccessTypedExprPtr> partitionKeys,
       std::vector<FieldAccessTypedExprPtr> sortingKeys,
       std::vector<SortOrder> sortingOrders,
@@ -4757,6 +5353,7 @@ class TopNRowNumberNode : public PlanNode {
       limit_ = other.limit();
       VELOX_CHECK_EQ(other.sources().size(), 1);
       source_ = other.sources()[0];
+      function_ = other.rankFunction();
     }
 
     Builder& id(PlanNodeId id) {
@@ -4764,6 +5361,11 @@ class TopNRowNumberNode : public PlanNode {
       return *this;
     }
 
+    Builder& function(RankFunction function) {
+      function_ = function;
+      return *this;
+    }
+
     Builder& partitionKeys(std::vector<FieldAccessTypedExprPtr> partitionKeys) {
       partitionKeys_ = std::move(partitionKeys);
       return *this;
@@ -4815,6 +5417,7 @@ class TopNRowNumberNode : public PlanNode {
 
       return std::make_shared<TopNRowNumberNode>(
           id_.value(),
+          function_.has_value() ? function_.value() : RankFunction::kRowNumber,
           partitionKeys_.value(),
           sortingKeys_.value(),
           sortingOrders_.value(),
@@ -4825,6 +5428,7 @@ class TopNRowNumberNode : public PlanNode {
 
    private:
     std::optional<PlanNodeId> id_;
+    std::optional<RankFunction> function_;
     std::optional<std::vector<FieldAccessTypedExprPtr>> partitionKeys_;
     std::optional<std::vector<FieldAccessTypedExprPtr>> sortingKeys_;
     std::optional<std::vector<SortOrder>> sortingOrders_;
@@ -4868,6 +5472,10 @@ class TopNRowNumberNode : public PlanNode {
     return limit_;
   }
 
+  RankFunction rankFunction() const {
+    return function_;
+  }
+
   bool generateRowNumber() const {
     return outputType_->size() > sources_[0]->outputType()->size();
   }
@@ -4883,6 +5491,8 @@ class TopNRowNumberNode : public PlanNode {
  private:
   void addDetails(std::stringstream& stream) const override;
 
+  const RankFunction function_;
+
   const std::vector<FieldAccessTypedExprPtr> partitionKeys_;
 
   const std::vector<FieldAccessTypedExprPtr> sortingKeys_;
@@ -4895,6 +5505,8 @@ class TopNRowNumberNode : public PlanNode {
   const RowTypePtr outputType_;
 };
 
+using TopNRowNumberNodePtr = std::shared_ptr<const TopNRowNumberNode>;
+
 class PlanNodeVisitorContext {
  public:
   virtual ~PlanNodeVisitorContext() = default;
@@ -4960,6 +5572,9 @@ class PlanNodeVisitor {
       const NestedLoopJoinNode& node,
       PlanNodeVisitorContext& ctx) const = 0;
 
+  virtual void visit(const SpatialJoinNode& node, PlanNodeVisitorContext& ctx)
+      const = 0;
+
   virtual void visit(const OrderByNode& node, PlanNodeVisitorContext& ctx)
       const = 0;
 
@@ -4970,6 +5585,10 @@ class PlanNodeVisitor {
   virtual void visit(const ProjectNode& node, PlanNodeVisitorContext& ctx)
       const = 0;
 
+  virtual void visit(
+      const ParallelProjectNode& node,
+      PlanNodeVisitorContext& ctx) const = 0;
+
   virtual void visit(const RowNumberNode& node, PlanNodeVisitorContext& ctx)
       const = 0;
 
@@ -5017,12 +5636,12 @@ class PlanNodeVisitor {
 
 template <>
 struct fmt::formatter<facebook::velox::core::PartitionedOutputNode::Kind>
-    : formatter<std::string> {
+    : formatter<std::string_view> {
   auto format(
       facebook::velox::core::PartitionedOutputNode::Kind s,
       format_context& ctx) const {
-    return formatter<std::string>::format(
-        facebook::velox::core::PartitionedOutputNode::kindString(s), ctx);
+    return formatter<std::string_view>::format(
+        facebook::velox::core::PartitionedOutputNode::toName(s), ctx);
   }
 };
 
@@ -5032,3 +5651,25 @@ struct fmt::formatter<facebook::velox::core::JoinType> : formatter<int> {
     return formatter<int>::format(static_cast<int>(s), ctx);
   }
 };
+
+template <>
+struct fmt::formatter<facebook::velox::core::TopNRowNumberNode::RankFunction>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::core::TopNRowNumberNode::RankFunction f,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::core::TopNRowNumberNode::rankFunctionName(f), ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<facebook::velox::core::AggregationNode::Step>
+    : formatter<std::string_view> {
+  auto format(
+      facebook::velox::core::AggregationNode::Step s,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::core::AggregationNode::toName(s), ctx);
+  }
+};
diff --git a/velox/core/QueryConfig.cpp b/velox/core/QueryConfig.cpp
index 3d5b25ff9487..736332280bb6 100644
--- a/velox/core/QueryConfig.cpp
+++ b/velox/core/QueryConfig.cpp
@@ -22,29 +22,26 @@
 
 namespace facebook::velox::core {
 
-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();
-}
+QueryConfig::QueryConfig(std::unordered_map<std::string, std::string> values)
+    : QueryConfig{
+          ConfigTag{},
+          std::make_shared<config::ConfigBase>(std::move(values))} {}
 
-QueryConfig::QueryConfig(std::unordered_map<std::string, std::string>&& values)
-    : config_{std::make_unique<config::ConfigBase>(std::move(values))} {
+QueryConfig::QueryConfig(
+    ConfigTag /*tag*/,
+    std::shared_ptr<const config::IConfig> config)
+    : config_{std::move(config)} {
   validateConfig();
 }
 
 void QueryConfig::validateConfig() {
   // Validate if timezone name can be recognized.
-  if (config_->valueExists(QueryConfig::kSessionTimezone)) {
+  if (auto tz = config_->get<std::string>(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()));
+        tz::getTimeZoneID(*tz, false) != -1,
+        "session '{}' set with invalid value '{}'",
+        QueryConfig::kSessionTimezone,
+        *tz);
   }
 }
 
diff --git a/velox/core/QueryConfig.h b/velox/core/QueryConfig.h
index c86058f844e5..f5b9a7fe19ab 100644
--- a/velox/core/QueryConfig.h
+++ b/velox/core/QueryConfig.h
@@ -21,16 +21,21 @@
 
 namespace facebook::velox::core {
 
-/// A simple wrapper around velox::ConfigBase. Defines constants for query
+/// A simple wrapper around velox::IConfig. 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.
 class QueryConfig {
  public:
-  explicit QueryConfig(
-      const std::unordered_map<std::string, std::string>& values);
+  explicit QueryConfig(std::unordered_map<std::string, std::string> values);
+
+  // This is needed only to resolve correct ctor for cases like
+  // QueryConfig{{}} or QueryConfig({}).
+  struct ConfigTag {};
 
-  explicit QueryConfig(std::unordered_map<std::string, std::string>&& values);
+  explicit QueryConfig(
+      ConfigTag /*tag*/,
+      std::shared_ptr<const config::IConfig> config);
 
   /// Maximum memory that a query can use on a single host.
   static constexpr const char* kQueryMaxMemoryPerNode =
@@ -40,6 +45,11 @@ class QueryConfig {
   /// name, e.g: "America/Los_Angeles".
   static constexpr const char* kSessionTimezone = "session_timezone";
 
+  /// Session start time in milliseconds since Unix epoch. This represents when
+  /// the query session began execution. Used for functions that need to know
+  /// the session start time (e.g., current_date, localtime).
+  static constexpr const char* kSessionStartTime = "start_time";
+
   /// If true, timezone-less timestamp conversions (e.g. string to timestamp,
   /// when the string does not specify a timezone) will be adjusted to the user
   /// provided session timezone (if any).
@@ -64,6 +74,26 @@ class QueryConfig {
   static constexpr const char* kExprTrackCpuUsage =
       "expression.track_cpu_usage";
 
+  /// Takes a comma separated list of function names to track CPU usage for.
+  /// Only applicable when kExprTrackCpuUsage is set to false. Is empty by
+  /// default. This allows fine-grained control over CPU tracking overhead when
+  /// only specific functions need to be monitored.
+  static constexpr const char* kExprTrackCpuUsageForFunctions =
+      "expression.track_cpu_usage_for_functions";
+
+  /// Controls whether non-deterministic expressions are deduplicated during
+  /// compilation. This is intended for testing and debugging purposes. By
+  /// default, this is set to true to preserve standard behavior. If set to
+  /// false, non-deterministic functions (such as rand()) will not be
+  /// deduplicated. Since non-deterministic functions may yield different
+  /// outputs on each call, disabling deduplication guarantees that the function
+  /// is executed only when the original expression is evaluated, rather than
+  /// being triggered for every deduplicated instance. This ensures each
+  /// invocation corresponds directly to the actual expression, maintaining
+  /// independent behavior for each call.
+  static constexpr const char* kExprDedupNonDeterministic =
+      "expression.dedup_non_deterministic";
+
   /// Whether to track CPU usage for stages of individual operators. True by
   /// default. Can be expensive when processing small batches, e.g. < 10K rows.
   static constexpr const char* kOperatorTrackCpuUsage =
@@ -139,6 +169,11 @@ class QueryConfig {
   static constexpr const char* kLocalExchangePartitionBufferPreserveEncoding =
       "local_exchange_partition_buffer_preserve_encoding";
 
+  /// Maximum number of vectors buffered in each local merge source before
+  /// blocking to wait for consumers.
+  static constexpr const char* kLocalMergeSourceQueueSize =
+      "local_merge_source_queue_size";
+
   /// Maximum size in bytes to accumulate in ExchangeQueue. Enforced
   /// approximately, not strictly.
   static constexpr const char* kMaxExchangeBufferSize =
@@ -170,12 +205,42 @@ class QueryConfig {
   static constexpr const char* kAbandonPartialAggregationMinPct =
       "abandon_partial_aggregation_min_pct";
 
+  /// Memory threshold in bytes for triggering string compaction during
+  /// global aggregation. When total string storage exceeds this limit with
+  /// high unused memory ratio, compaction is triggered to reclaim dead strings.
+  /// Disabled by default (0).
+  ///
+  /// NOTE: currently only applies to approx_most_frequent aggregate with
+  /// StringView type during global aggregation. May extend to other types.
+  static constexpr const char* kAggregationCompactionBytesThreshold =
+      "aggregation_compaction_bytes_threshold";
+
+  /// Ratio of unused (evicted) bytes to total bytes that triggers compaction.
+  /// Value is between 0.0 and 1.0. Default is 0.25.
+  ///
+  /// NOTE: currently only applies to approx_most_frequent aggregate with
+  /// StringView type during global aggregation. May extend to other types.
+  static constexpr const char* kAggregationCompactionUnusedMemoryRatio =
+      "aggregation_compaction_unused_memory_ratio";
+
   static constexpr const char* kAbandonPartialTopNRowNumberMinRows =
       "abandon_partial_topn_row_number_min_rows";
 
   static constexpr const char* kAbandonPartialTopNRowNumberMinPct =
       "abandon_partial_topn_row_number_min_pct";
 
+  /// Number of input rows to receive before starting to check whether to
+  /// abandon building a HashTable without duplicates in HashBuild for left
+  /// semi/anti join.
+  static constexpr const char* kAbandonDedupHashMapMinRows =
+      "abandon_dedup_hashmap_min_rows";
+
+  /// Abandons building a HashTable without duplicates in HashBuild for left
+  /// semi/anti join if the percentage of distinct keys in the HashTable exceeds
+  /// this threshold. Zero means 'disable this optimization'.
+  static constexpr const char* kAbandonDedupHashMapMinPct =
+      "abandon_dedup_hashmap_min_pct";
+
   static constexpr const char* kMaxElementsSizeInRepeatAndSequence =
       "max_elements_size_in_repeat_and_sequence";
 
@@ -230,6 +295,10 @@ class QueryConfig {
   static constexpr const char* kAdaptiveFilterReorderingEnabled =
       "adaptive_filter_reordering_enabled";
 
+  /// If true, allow hash probe drivers to generate build-side rows in parallel.
+  static constexpr const char* kParallelOutputJoinBuildRowsEnabled =
+      "parallel_output_join_build_rows_enabled";
+
   /// Global enable spilling flag.
   static constexpr const char* kSpillEnabled = "spill_enabled";
 
@@ -250,6 +319,13 @@ class QueryConfig {
   /// Window spilling flag, only applies if "spill_enabled" flag is set.
   static constexpr const char* kWindowSpillEnabled = "window_spill_enabled";
 
+  /// When processing spilled window data, read batches of whole partitions
+  /// having at least that many rows. Set to 1 to read one whole partition at a
+  /// time. Each driver processing the Window operator will process that much
+  /// data at once.
+  static constexpr const char* kWindowSpillMinReadBatchRows =
+      "window_spill_min_read_batch_rows";
+
   /// If true, the memory arbitrator will reclaim memory from table writer by
   /// flushing its buffered data to disk. only applies if "spill_enabled" flag
   /// is set.
@@ -263,6 +339,14 @@ class QueryConfig {
   static constexpr const char* kTopNRowNumberSpillEnabled =
       "topn_row_number_spill_enabled";
 
+  /// LocalMerge spilling flag, only applies if "spill_enabled" flag is set.
+  static constexpr const char* kLocalMergeSpillEnabled =
+      "local_merge_spill_enabled";
+
+  /// Specify the max number of local sources to merge at a time.
+  static constexpr const char* kLocalMergeMaxNumMergeSources =
+      "local_merge_max_num_merge_sources";
+
   /// 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.
@@ -291,6 +375,14 @@ class QueryConfig {
   static constexpr const char* kSpillCompressionKind =
       "spill_compression_codec";
 
+  /// The max number of files to merge at a time when merging sorted files into
+  /// a single ordered stream. 0 means unlimited. This is used to reduce memory
+  /// pressure by capping the number of open files when merging spilled sorted
+  /// files to avoid using too much memory and causing OOM. Note that this is
+  /// only applicable for ordered spill.
+  static constexpr const char* kSpillNumMaxMergeFiles =
+      "spill_num_max_merge_files";
+
   /// Enable the prefix sort or fallback to timsort in spill. The prefix sort is
   /// faster than std::sort but requires the memory to build normalized prefix
   /// keys, which might have potential risk of running out of server memory.
@@ -316,7 +408,7 @@ class QueryConfig {
       "spill_file_create_config";
 
   /// Default offset spill start partition bit. It is used with
-  /// 'kJoinSpillPartitionBits' or 'kAggregationSpillPartitionBits' together to
+  /// 'kSpillNumPartitionBits' together to
   /// calculate the spilling partition number for join spill or aggregation
   /// spill.
   static constexpr const char* kSpillStartPartitionBit =
@@ -356,6 +448,14 @@ class QueryConfig {
   static constexpr const char* kPrestoArrayAggIgnoreNulls =
       "presto.array_agg.ignore_nulls";
 
+  /// If true, Spark function's behavior is ANSI-compliant, e.g. throws runtime
+  /// exception instead of returning null on invalid inputs. It affects only
+  /// functions explicitly marked as "ANSI compliant".
+  /// Note: This feature is still under development to achieve full ANSI
+  /// compliance. Users can refer to the Spark function documentation to verify
+  /// the current support status of a specific function.
+  static constexpr const char* kSparkAnsiEnabled = "spark.ansi_enabled";
+
   /// The default number of expected items for the bloomfilter.
   static constexpr const char* kSparkBloomFilterExpectedNumItems =
       "spark.bloom_filter.expected_num_items";
@@ -383,6 +483,11 @@ class QueryConfig {
   static constexpr const char* kSparkLegacyStatisticalAggregate =
       "spark.legacy_statistical_aggregate";
 
+  /// If true, ignore null fields when generating JSON string.
+  /// If false, null fields are included with a null value.
+  static constexpr const char* kSparkJsonIgnoreNullFields =
+      "spark.json_ignore_null_fields";
+
   /// The number of local parallel table writer operators per task.
   static constexpr const char* kTaskWriterCount = "task_writer_count";
 
@@ -396,6 +501,18 @@ class QueryConfig {
   static constexpr const char* kHashProbeFinishEarlyOnEmptyBuild =
       "hash_probe_finish_early_on_empty_build";
 
+  /// Whether hash probe can generate any dynamic filter (including Bloom
+  /// filter) and push down to upstream operators.
+  static constexpr const char* kHashProbeDynamicFilterPushdownEnabled =
+      "hash_probe_dynamic_filter_pushdown_enabled";
+
+  /// The maximum byte size of Bloom filter that can be generated from hash
+  /// probe.  When set to 0, no Bloom filter will be generated.  To achieve
+  /// optimal performance, this should not be too larger than the CPU cache size
+  /// on the host.
+  static constexpr const char* kHashProbeBloomFilterPushdownMaxSize =
+      "hash_probe_bloom_filter_pushdown_max_size";
+
   /// The minimum number of table rows that can trigger the parallel hash join
   /// table build.
   static constexpr const char* kMinTableRowsForParallelJoinBuild =
@@ -434,6 +551,12 @@ class QueryConfig {
   static constexpr const char* kDriverCpuTimeSliceLimitMs =
       "driver_cpu_time_slice_limit_ms";
 
+  /// Window operator can be configured to sub-divide window partitions on each
+  /// thread of execution into groups of partitions for sequential processing.
+  /// This setting specifies how many sub-partitions to create for each thread.
+  static constexpr const char* kWindowNumSubPartitions =
+      "window_num_sub_partitions";
+
   /// Maximum number of bytes to use for the normalized key in prefix-sort. Use
   /// 0 to disable prefix-sort.
   static constexpr const char* kPrefixSortNormalizedKeyMaxBytes =
@@ -454,9 +577,9 @@ class QueryConfig {
   /// 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.
+  /// The plan node id 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";
+  static constexpr const char* kQueryTraceNodeId = "query_trace_node_id";
 
   /// The max trace bytes limit. Tracing is disabled if zero.
   static constexpr const char* kQueryTraceMaxBytes = "query_trace_max_bytes";
@@ -466,6 +589,10 @@ class QueryConfig {
   static constexpr const char* kQueryTraceTaskRegExp =
       "query_trace_task_reg_exp";
 
+  /// If true, we only collect the input trace for a given operator but without
+  /// the actual execution.
+  static constexpr const char* kQueryTraceDryRun = "query_trace_dry_run";
+
   /// Config used to create operator trace directory. This config is provided to
   /// underlying file system and the config is free form. The form should be
   /// defined by the underlying file system.
@@ -506,15 +633,35 @@ class QueryConfig {
   static constexpr const char* kDebugMemoryPoolNameRegex =
       "debug_memory_pool_name_regex";
 
+  /// Warning threshold in bytes for debug memory pools. When set to a
+  /// non-zero value, a warning will be logged once per memory pool when
+  /// allocations cause the pool to exceed this threshold. This is useful for
+  /// identifying memory usage patterns during debugging. Requires allocation
+  /// tracking to be enabled via `debug_memory_pool_name_regex` for the pool. A
+  /// value of 0 means no warning threshold is enforced.
+  static constexpr const char* kDebugMemoryPoolWarnThresholdBytes =
+      "debug_memory_pool_warn_threshold_bytes";
+
   /// Some lambda functions over arrays and maps are evaluated in batches of the
   /// underlying elements that comprise the arrays/maps. This is done to make
-  /// the batch size managable as array vectors can have thousands of elements
+  /// the batch size manageable as array vectors can have thousands of elements
   /// each and hit scaling limits as implementations typically expect
   /// BaseVectors to a couple of thousand entries. This lets up tune those batch
   /// sizes.
   static constexpr const char* kDebugLambdaFunctionEvaluationBatchSize =
       "debug_lambda_function_evaluation_batch_size";
 
+  /// The UDF `bing_tile_children` generates the children of a Bing tile based
+  /// on a specified target zoom level. The number of children produced is
+  /// determined by the difference between the target zoom level and the zoom
+  /// level of the input tile. This configuration limits the number of children
+  /// by capping the maximum zoom level difference, with a default value set
+  /// to 5. This cap is necessary to prevent excessively large array outputs,
+  /// which can exceed the size limits of the elements vector in the Velox array
+  /// vector.
+  static constexpr const char* kDebugBingTileChildrenMaxZoomShift =
+      "debug_bing_tile_children_max_zoom_shift";
+
   /// 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.
@@ -580,6 +727,12 @@ class QueryConfig {
   static constexpr const char* kIndexLookupJoinMaxPrefetchBatches =
       "index_lookup_join_max_prefetch_batches";
 
+  /// If this is true, then the index join operator might split output for each
+  /// input batch based on the output batch size control. Otherwise, it tries to
+  /// produce a single output for each input batch.
+  static constexpr const char* kIndexLookupJoinSplitOutput =
+      "index_lookup_join_split_output";
+
   // Max wait time for exchange request in seconds.
   static constexpr const char* kRequestDataSizesMaxWaitSec =
       "request_data_sizes_max_wait_sec";
@@ -594,15 +747,86 @@ class QueryConfig {
   static constexpr const char* kStreamingAggregationEagerFlush =
       "streaming_aggregation_eager_flush";
 
+  // If true, skip request data size if there is only single source.
+  // This is used to optimize the Presto-on-Spark use case where each
+  // exchange client has only one shuffle partition source.
+  static constexpr const char* kSkipRequestDataSizeWithSingleSourceEnabled =
+      "skip_request_data_size_with_single_source_enabled";
+
+  /// If true, exchange clients defer data fetching until next() is called.
+  /// This enables waiter tasks using cached hash tables to skip I/O entirely
+  /// when the table is already cached. If false (default), exchange clients
+  /// start fetching data immediately when remote tasks are added.
+  static constexpr const char* kExchangeLazyFetchingEnabled =
+      "exchange_lazy_fetching_enabled";
+
   /// If this is true, then it allows you to get the struct field names
   /// as json element names when casting a row to json.
   static constexpr const char* kFieldNamesInJsonCastEnabled =
       "field_names_in_json_cast_enabled";
 
+  /// If this is true, then operators that evaluate expressions will track
+  /// stats for expressions that are not special forms and return them as
+  /// part of their operator stats. Tracking these stats can be expensive
+  /// (especially if operator stats are retrieved frequently) and this allows
+  /// the user to explicitly enable it.
+  static constexpr const char* kOperatorTrackExpressionStats =
+      "operator_track_expression_stats";
+
+  /// If this is true, enable the operator input/output batch size stats
+  /// collection in driver execution. This can be expensive for data types with
+  /// a large number of columns (e.g., ROW types) as it calls estimateFlatSize()
+  /// which recursively calculates sizes for all child vectors.
+  static constexpr const char* kEnableOperatorBatchSizeStats =
+      "enable_operator_batch_size_stats";
+
+  /// If this is true, then the unnest operator might split output for each
+  /// input batch based on the output batch size control. Otherwise, it produces
+  /// a single output for each input batch.
+  static constexpr const char* kUnnestSplitOutput = "unnest_split_output";
+
+  /// Priority of the query in the memory pool reclaimer. Lower value means
+  /// higher priority. This is used in global arbitration victim selection.
+  static constexpr const char* kQueryMemoryReclaimerPriority =
+      "query_memory_reclaimer_priority";
+
+  /// The max number of input splits to listen to by SplitListener per table
+  /// scan node per worker. It's up to the SplitListener implementation to
+  /// respect this config.
+  static constexpr const char* kMaxNumSplitsListenedTo =
+      "max_num_splits_listened_to";
+
+  /// Source of the query. Used by Presto to identify the file system username.
+  static constexpr const char* kSource = "source";
+
+  /// Client tags of the query. Used by Presto to identify the file system
+  /// username.
+  static constexpr const char* kClientTags = "client_tags";
+
+  /// Enable (reader) row size tracker as a fallback to file level row size
+  /// estimates.
+  static constexpr const char* kRowSizeTrackingMode = "row_size_tracking_mode";
+
+  /// Maximum number of distinct values to keep when merging vector hashers in
+  /// join HashBuild.
+  static constexpr const char* kJoinBuildVectorHasherMaxNumDistinct =
+      "join_build_vector_hasher_max_num_distinct";
+
+  enum class RowSizeTrackingMode {
+    DISABLED = 0,
+    EXCLUDE_DELTA_SPLITS = 1,
+    ENABLED_FOR_ALL = 2,
+  };
+
   bool selectiveNimbleReaderEnabled() const {
     return get<bool>(kSelectiveNimbleReaderEnabled, false);
   }
 
+  RowSizeTrackingMode rowSizeTrackingMode() const {
+    return get<RowSizeTrackingMode>(
+        kRowSizeTrackingMode, RowSizeTrackingMode::ENABLED_FOR_ALL);
+  }
+
   bool debugDisableExpressionsWithPeeling() const {
     return get<bool>(kDebugDisableExpressionWithPeeling, false);
   }
@@ -623,6 +847,12 @@ class QueryConfig {
     return get<std::string>(kDebugMemoryPoolNameRegex, "");
   }
 
+  uint64_t debugMemoryPoolWarnThresholdBytes() const {
+    return config::toCapacity(
+        get<std::string>(kDebugMemoryPoolWarnThresholdBytes, "0B"),
+        config::CapacityUnit::BYTE);
+  }
+
   std::optional<uint32_t> debugAggregationApproxPercentileFixedRandomSeed()
       const {
     return get<uint32_t>(kDebugAggregationApproxPercentileFixedRandomSeed);
@@ -632,6 +862,10 @@ class QueryConfig {
     return get<int32_t>(kDebugLambdaFunctionEvaluationBatchSize, 10'000);
   }
 
+  uint8_t debugBingTileChildrenMaxZoomShift() const {
+    return get<uint8_t>(kDebugBingTileChildrenMaxZoomShift, 7);
+  }
+
   uint64_t queryMaxMemoryPerNode() const {
     return config::toCapacity(
         get<std::string>(kQueryMaxMemoryPerNode, "0B"),
@@ -656,6 +890,14 @@ class QueryConfig {
     return get<int32_t>(kAbandonPartialAggregationMinPct, 80);
   }
 
+  uint64_t aggregationCompactionBytesThreshold() const {
+    return get<uint64_t>(kAggregationCompactionBytesThreshold, 0);
+  }
+
+  double aggregationCompactionUnusedMemoryRatio() const {
+    return get<double>(kAggregationCompactionUnusedMemoryRatio, 0.25);
+  }
+
   int32_t abandonPartialTopNRowNumberMinRows() const {
     return get<int32_t>(kAbandonPartialTopNRowNumberMinRows, 100'000);
   }
@@ -664,6 +906,14 @@ class QueryConfig {
     return get<int32_t>(kAbandonPartialTopNRowNumberMinPct, 80);
   }
 
+  int32_t abandonHashBuildDedupMinRows() const {
+    return get<int32_t>(kAbandonDedupHashMapMinRows, 100'000);
+  }
+
+  int32_t abandonHashBuildDedupMinPct() const {
+    return get<int32_t>(kAbandonDedupHashMapMinPct, 0);
+  }
+
   int32_t maxElementsSizeInRepeatAndSequence() const {
     return get<int32_t>(kMaxElementsSizeInRepeatAndSequence, 10'000);
   }
@@ -720,6 +970,10 @@ class QueryConfig {
     return get<bool>(kLocalExchangePartitionBufferPreserveEncoding, false);
   }
 
+  uint32_t localMergeSourceQueueSize() const {
+    return get<uint32_t>(kLocalMergeSourceQueueSize, 2);
+  }
+
   uint64_t maxExchangeBufferSize() const {
     static constexpr uint64_t kDefault = 32UL << 20;
     return get<uint64_t>(kMaxExchangeBufferSize, kDefault);
@@ -799,10 +1053,20 @@ class QueryConfig {
     return get<std::string>(kSessionTimezone, "");
   }
 
+  /// Returns the session start time in milliseconds since Unix epoch.
+  /// If not set, returns 0 (or epoch).
+  int64_t sessionStartTimeMs() const {
+    return get<int64_t>(kSessionStartTime, 0);
+  }
+
   bool exprEvalSimplified() const {
     return get<bool>(kExprEvalSimplified, false);
   }
 
+  bool parallelOutputJoinBuildRowsEnabled() const {
+    return get<bool>(kParallelOutputJoinBuildRowsEnabled, false);
+  }
+
   bool spillEnabled() const {
     return get<bool>(kSpillEnabled, false);
   }
@@ -827,6 +1091,10 @@ class QueryConfig {
     return get<bool>(kWindowSpillEnabled, true);
   }
 
+  uint32_t windowSpillMinReadBatchRows() const {
+    return get<uint32_t>(kWindowSpillMinReadBatchRows, 1'000);
+  }
+
   bool writerSpillEnabled() const {
     return get<bool>(kWriterSpillEnabled, true);
   }
@@ -839,6 +1107,17 @@ class QueryConfig {
     return get<bool>(kTopNRowNumberSpillEnabled, true);
   }
 
+  bool localMergeSpillEnabled() const {
+    return get<bool>(kLocalMergeSpillEnabled, false);
+  }
+
+  uint32_t localMergeMaxNumMergeSources() const {
+    const auto maxNumMergeSources = get<uint32_t>(
+        kLocalMergeMaxNumMergeSources, std::numeric_limits<uint32_t>::max());
+    VELOX_CHECK_GT(maxNumMergeSources, 0);
+    return maxNumMergeSources;
+  }
+
   int32_t maxSpillLevel() const {
     return get<int32_t>(kMaxSpillLevel, 1);
   }
@@ -868,6 +1147,11 @@ class QueryConfig {
     return get<std::string>(kSpillCompressionKind, "none");
   }
 
+  uint32_t spillNumMaxMergeFiles() const {
+    constexpr uint32_t kDefaultMergeFiles = 0;
+    return get<uint32_t>(kSpillNumMaxMergeFiles, kDefaultMergeFiles);
+  }
+
   bool spillPrefixSortEnabled() const {
     return get<bool>(kSpillPrefixSortEnabled, false);
   }
@@ -905,9 +1189,9 @@ class QueryConfig {
     return get<std::string>(kQueryTraceDir, "");
   }
 
-  std::string queryTraceNodeIds() const {
-    // The default query trace nodes, empty by default.
-    return get<std::string>(kQueryTraceNodeIds, "");
+  std::string queryTraceNodeId() const {
+    // The default query trace node ID, empty by default.
+    return get<std::string>(kQueryTraceNodeId, "");
   }
 
   uint64_t queryTraceMaxBytes() const {
@@ -919,6 +1203,10 @@ class QueryConfig {
     return get<std::string>(kQueryTraceTaskRegExp, "");
   }
 
+  bool queryTraceDryRun() const {
+    return get<bool>(kQueryTraceDryRun, false);
+  }
+
   std::string opTraceDirectoryCreateConfig() const {
     return get<std::string>(kOpTraceDirectoryCreateConfig, "");
   }
@@ -927,6 +1215,10 @@ class QueryConfig {
     return get<bool>(kPrestoArrayAggIgnoreNulls, false);
   }
 
+  bool sparkAnsiEnabled() const {
+    return get<bool>(kSparkAnsiEnabled, false);
+  }
+
   int64_t sparkBloomFilterExpectedNumItems() const {
     constexpr int64_t kDefault = 1'000'000L;
     return get<int64_t>(kSparkBloomFilterExpectedNumItems, kDefault);
@@ -966,10 +1258,22 @@ class QueryConfig {
     return get<bool>(kSparkLegacyStatisticalAggregate, false);
   }
 
+  bool sparkJsonIgnoreNullFields() const {
+    return get<bool>(kSparkJsonIgnoreNullFields, true);
+  }
+
   bool exprTrackCpuUsage() const {
     return get<bool>(kExprTrackCpuUsage, false);
   }
 
+  std::string exprTrackCpuUsageForFunctions() const {
+    return get<std::string>(kExprTrackCpuUsageForFunctions, "");
+  }
+
+  bool exprDedupNonDeterministic() const {
+    return get<bool>(kExprDedupNonDeterministic, true);
+  }
+
   bool operatorTrackCpuUsage() const {
     return get<bool>(kOperatorTrackCpuUsage, true);
   }
@@ -987,6 +1291,14 @@ class QueryConfig {
     return get<bool>(kHashProbeFinishEarlyOnEmptyBuild, false);
   }
 
+  bool hashProbeDynamicFilterPushdownEnabled() const {
+    return get<bool>(kHashProbeDynamicFilterPushdownEnabled, true);
+  }
+
+  uint64_t hashProbeBloomFilterPushdownMaxSize() const {
+    return get<uint64_t>(kHashProbeBloomFilterPushdownMaxSize, 0);
+  }
+
   uint32_t minTableRowsForParallelJoinBuild() const {
     return get<uint32_t>(kMinTableRowsForParallelJoinBuild, 1'000);
   }
@@ -1023,6 +1335,10 @@ class QueryConfig {
     return get<uint32_t>(kDriverCpuTimeSliceLimitMs, 0);
   }
 
+  uint32_t windowNumSubPartitions() const {
+    return get<uint32_t>(kWindowNumSubPartitions, 1);
+  }
+
   uint32_t prefixSortNormalizedKeyMaxBytes() const {
     return get<uint32_t>(kPrefixSortNormalizedKeyMaxBytes, 128);
   }
@@ -1065,6 +1381,10 @@ class QueryConfig {
     return get<uint32_t>(kIndexLookupJoinMaxPrefetchBatches, 0);
   }
 
+  bool indexLookupJoinSplitOutput() const {
+    return get<bool>(kIndexLookupJoinSplitOutput, true);
+  }
+
   std::string shuffleCompressionKind() const {
     return get<std::string>(kShuffleCompressionKind, "none");
   }
@@ -1086,17 +1406,63 @@ class QueryConfig {
     return get<int32_t>(kStreamingAggregationMinOutputBatchRows, 0);
   }
 
+  bool singleSourceExchangeOptimizationEnabled() const {
+    return get<bool>(kSkipRequestDataSizeWithSingleSourceEnabled, false);
+  }
+
+  bool exchangeLazyFetchingEnabled() const {
+    return get<bool>(kExchangeLazyFetchingEnabled, false);
+  }
+
   bool isFieldNamesInJsonCastEnabled() const {
     return get<bool>(kFieldNamesInJsonCastEnabled, false);
   }
 
+  bool operatorTrackExpressionStats() const {
+    return get<bool>(kOperatorTrackExpressionStats, false);
+  }
+
+  bool enableOperatorBatchSizeStats() const {
+    return get<bool>(kEnableOperatorBatchSizeStats, true);
+  }
+
+  bool unnestSplitOutput() const {
+    return get<bool>(kUnnestSplitOutput, true);
+  }
+
+  int32_t queryMemoryReclaimerPriority() const {
+    return get<int32_t>(
+        kQueryMemoryReclaimerPriority, std::numeric_limits<int32_t>::max());
+  }
+
+  int32_t maxNumSplitsListenedTo() const {
+    return get<int32_t>(kMaxNumSplitsListenedTo, 0);
+  }
+
+  std::string source() const {
+    return get<std::string>(kSource, "");
+  }
+
+  std::string clientTags() const {
+    return get<std::string>(kClientTags, "");
+  }
+
+  uint32_t joinBuildVectorHasherMaxNumDistinct() const {
+    return get<uint32_t>(kJoinBuildVectorHasherMaxNumDistinct, 1'000'000);
+  }
+
   template <typename T>
   T get(const std::string& key, const T& defaultValue) const {
     return config_->get<T>(key, defaultValue);
   }
+
   template <typename T>
   std::optional<T> get(const std::string& key) const {
-    return std::optional<T>(config_->get<T>(key));
+    return config_->get<T>(key);
+  }
+
+  const std::shared_ptr<const config::IConfig>& config() const {
+    return config_;
   }
 
   /// Test-only method to override the current query config properties.
@@ -1109,6 +1475,6 @@ class QueryConfig {
  private:
   void validateConfig();
 
-  std::unique_ptr<velox::config::ConfigBase> config_;
+  std::shared_ptr<const config::IConfig> config_;
 };
 } // namespace facebook::velox::core
diff --git a/velox/core/QueryCtx.cpp b/velox/core/QueryCtx.cpp
index b65309d7d9b8..0c1c961a9e92 100644
--- a/velox/core/QueryCtx.cpp
+++ b/velox/core/QueryCtx.cpp
@@ -30,16 +30,34 @@ std::shared_ptr<QueryCtx> QueryCtx::create(
     cache::AsyncDataCache* cache,
     std::shared_ptr<memory::MemoryPool> pool,
     folly::Executor* spillExecutor,
-    const std::string& queryId) {
+    std::string queryId,
+    std::shared_ptr<filesystems::TokenProvider> tokenProvider) {
+  return QueryCtx::Builder()
+      .executor(executor)
+      .queryConfig(std::move(queryConfig))
+      .connectorConfigs(std::move(connectorConfigs))
+      .asyncDataCache(cache)
+      .pool(std::move(pool))
+      .spillExecutor(spillExecutor)
+      .queryId(std::move(queryId))
+      .tokenProvider(std::move(tokenProvider))
+      .build();
+}
+
+std::shared_ptr<QueryCtx> QueryCtx::Builder::build() {
   std::shared_ptr<QueryCtx> queryCtx(new QueryCtx(
-      executor,
-      std::move(queryConfig),
-      std::move(connectorConfigs),
-      cache,
-      std::move(pool),
-      spillExecutor,
-      queryId));
+      executor_,
+      std::move(queryConfig_),
+      std::move(connectorConfigs_),
+      cache_,
+      std::move(pool_),
+      spillExecutor_,
+      std::move(queryId_),
+      std::move(tokenProvider_)));
   queryCtx->maybeSetReclaimer();
+  for (auto& cb : releaseCallbacks_) {
+    queryCtx->addReleaseCallback(std::move(cb));
+  }
   return queryCtx;
 }
 
@@ -51,22 +69,37 @@ QueryCtx::QueryCtx(
     cache::AsyncDataCache* cache,
     std::shared_ptr<memory::MemoryPool> pool,
     folly::Executor* spillExecutor,
-    const std::string& queryId)
+    const std::string& queryId,
+    std::shared_ptr<filesystems::TokenProvider> tokenProvider)
     : queryId_(queryId),
       executor_(executor),
       spillExecutor_(spillExecutor),
       cache_(cache),
       connectorSessionProperties_(connectorSessionProperties),
       pool_(std::move(pool)),
-      queryConfig_{std::move(queryConfig)} {
+      queryConfig_{std::move(queryConfig)},
+      fsTokenProvider_(std::move(tokenProvider)) {
   initPool(queryId);
 }
 
+QueryCtx::~QueryCtx() {
+  for (auto& cb : releaseCallbacks_) {
+    try {
+      cb();
+    } catch (const std::exception& e) {
+      LOG(ERROR) << "Release callback threw exception: " << e.what();
+    } catch (...) {
+      LOG(ERROR) << "Release callback threw unknown exception";
+    }
+  }
+  VELOX_CHECK(!underArbitration_);
+}
+
 /*static*/ std::string QueryCtx::generatePoolName(const std::string& queryId) {
   // We attach a monotonically increasing sequence number to ensure the pool
   // name is unique.
   static std::atomic<int64_t> seqNum{0};
-  return fmt::format("query.{}.{}", queryId.c_str(), seqNum++);
+  return fmt::format("query.{}.{}", queryId, seqNum++);
 }
 
 void QueryCtx::maybeSetReclaimer() {
@@ -82,26 +115,30 @@ 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())));
+    VELOX_SPILL_LIMIT_EXCEEDED(
+        fmt::format(
+            "Query exceeded per-query local spill limit of {}",
+            succinctBytes(queryConfig_.maxSpillBytes())));
   }
 }
 
 void QueryCtx::updateTracedBytesAndCheckLimit(uint64_t bytes) {
   if (numTracedBytes_.fetch_add(bytes) + bytes >=
       queryConfig_.queryTraceMaxBytes()) {
-    VELOX_TRACE_LIMIT_EXCEEDED(fmt::format(
-        "Query exceeded per-query local trace limit of {}",
-        succinctBytes(queryConfig_.queryTraceMaxBytes())));
+    VELOX_TRACE_LIMIT_EXCEEDED(
+        fmt::format(
+            "Query exceeded per-query local trace limit of {}",
+            succinctBytes(queryConfig_.queryTraceMaxBytes())));
   }
 }
 
 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));
+  return std::unique_ptr<memory::MemoryReclaimer>(new QueryCtx::MemoryReclaimer(
+      queryCtx->shared_from_this(),
+      pool,
+      queryCtx->queryConfig().queryMemoryReclaimerPriority()));
 }
 
 uint64_t QueryCtx::MemoryReclaimer::reclaim(
diff --git a/velox/core/QueryCtx.h b/velox/core/QueryCtx.h
index b9ebee5d706a..7303a3e0591f 100644
--- a/velox/core/QueryCtx.h
+++ b/velox/core/QueryCtx.h
@@ -18,31 +18,84 @@
 
 #include <folly/Executor.h>
 #include <folly/executors/CPUThreadPoolExecutor.h>
+#include <deque>
+#include <functional>
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/core/QueryConfig.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/VectorPool.h"
 
-namespace facebook::velox {
-class Config;
-};
-
 namespace facebook::velox::core {
 
+/// Query execution context that manages resources and configuration for a
+/// query.
+///
+/// QueryCtx encapsulates query-level state and resources including:
+///
+/// - Memory pool management and memory arbitration.
+/// - Query and connector-specific configuration.
+/// - Executor for parallel task execution.
+/// - Async data cache for IO operations.
+/// - Spill executor for disk-based operations.
+/// - Query tracing and metrics tracking.
+///
+/// Usage Contexts:
+///
+/// - Multi-threaded execution: Used with Task::start() where an executor must
+///   be provided and its lifetime must outlive all tasks using this context.
+/// - Single-threaded execution: Used with ExecCtx or Task::next() for
+///   expression evaluation where no executor is required.
+///
+/// Construction:
+///
+/// To construct a QueryCtx, prefer to use the builder pattern:
+///
+/// @code
+///   auto queryCtx = QueryCtx::Builder()
+///       .executor(myExecutor)
+///       .queryConfig(configMap)
+///       .queryId("query-123")
+///       .pool(myMemoryPool)
+///       .build();
+/// @endcode
+///
+/// Memory Management:
+///
+/// - Automatically creates a root memory pool if not provided
+/// - Supports memory arbitration and reclamation under memory pressure
+/// - Tracks spilled bytes with configurable limits
+/// - Thread-safe memory pool operations
+///
+/// Thread-safety: QueryCtx is thread-safe for concurrent access across
+/// multiple tasks and operators within a query execution.
 class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
  public:
-  ~QueryCtx() {
-    VELOX_CHECK(!underArbitration_);
-  }
+  using ReleaseCallback = std::function<void()>;
 
-  /// 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();
+
+  /// Creates a new QueryCtx instance with the specified configuration.
+  ///
+  /// This factory method constructs a QueryCtx with all necessary resources
+  /// and automatically sets up memory reclamation if not already configured.
+  ///
+  /// @param executor Optional executor for parallel task execution. Required
+  ///                 when used with Task::start(), but not needed for
+  ///                 expression evaluation or single-threaded execution.
+  /// @param queryConfig Query-level configuration settings.
+  /// @param connectorConfigs Connector-specific configuration mappings.
+  /// @param cache Async data cache for IO operations (defaults to global
+  ///              instance).
+  /// @param pool Memory pool for query execution (auto-created if nullptr).
+  /// @param spillExecutor Optional executor for spilling operations.
+  /// @param queryId Unique identifier for this query.
+  /// @param tokenProvider Optional filesystem token provider for
+  ///                      authentication.
+  /// @return Shared pointer to the newly created QueryCtx.
+  ///
+  /// Note: The caller must ensure the executor's lifetime outlives all tasks
+  /// using this QueryCtx when executor is provided.
   static std::shared_ptr<QueryCtx> create(
       folly::Executor* executor = nullptr,
       QueryConfig&& queryConfig = QueryConfig{{}},
@@ -51,8 +104,103 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
       cache::AsyncDataCache* cache = cache::AsyncDataCache::getInstance(),
       std::shared_ptr<memory::MemoryPool> pool = nullptr,
       folly::Executor* spillExecutor = nullptr,
-      const std::string& queryId = "");
+      std::string queryId = "",
+      std::shared_ptr<filesystems::TokenProvider> tokenProvider = {});
+
+  /// Builder pattern for constructing QueryCtx instances.
+  ///
+  /// Provides a fluent interface for creating QueryCtx with optional
+  /// parameters. This is the recommended approach for improved readability,
+  /// especially when only setting a subset of configuration options.
+  ///
+  /// Example:
+  /// @code
+  ///   auto ctx = QueryCtx::Builder()
+  ///                  .queryId("my-query")
+  ///                  .executor(myExecutor)
+  ///                  .queryConfig(QueryConfig{mySettings})
+  ///                  .build();
+  /// @endcode
+  class Builder {
+   public:
+    Builder& executor(folly::Executor* executor) {
+      executor_ = executor;
+      return *this;
+    }
+
+    Builder& queryConfig(QueryConfig queryConfig) {
+      queryConfig_ = std::move(queryConfig);
+      return *this;
+    }
+
+    Builder& connectorConfigs(
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
+            connectorConfigs) {
+      connectorConfigs_ = std::move(connectorConfigs);
+      return *this;
+    }
+
+    Builder& asyncDataCache(cache::AsyncDataCache* cache) {
+      cache_ = cache;
+      return *this;
+    }
+
+    Builder& pool(std::shared_ptr<memory::MemoryPool> pool) {
+      pool_ = std::move(pool);
+      return *this;
+    }
+
+    Builder& spillExecutor(folly::Executor* spillExecutor) {
+      spillExecutor_ = spillExecutor;
+      return *this;
+    }
+
+    Builder& queryId(std::string queryId) {
+      queryId_ = std::move(queryId);
+      return *this;
+    }
+
+    Builder& tokenProvider(
+        std::shared_ptr<filesystems::TokenProvider> tokenProvider) {
+      tokenProvider_ = std::move(tokenProvider);
+      return *this;
+    }
+
+    /// Adds a callback to be invoked when the QueryCtx is destroyed.
+    /// Multiple callbacks can be added by calling this method multiple times.
+    Builder& releaseCallback(ReleaseCallback callback) {
+      releaseCallbacks_.push_back(std::move(callback));
+      return *this;
+    }
+
+    /// Constructs and returns a QueryCtx with the configured parameters.
+    ///
+    /// @return Shared pointer to the newly created QueryCtx instance
+    std::shared_ptr<QueryCtx> build();
+
+   private:
+    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_;
+    folly::Executor* spillExecutor_{nullptr};
+    std::string queryId_;
+    std::shared_ptr<filesystems::TokenProvider> tokenProvider_;
+    std::deque<ReleaseCallback> releaseCallbacks_;
+  };
 
+  /// Generates a unique memory pool name for a query.
+  ///
+  /// Creates a pool name by combining the provided query ID with a
+  /// monotonically increasing sequence number to ensure uniqueness across
+  /// multiple pool creations, even for the same query ID.
+  ///
+  /// @param queryId The query identifier to incorporate into the pool name
+  /// @return A unique pool name in the format "query.{queryId}.{seqNum}"
+  ///
+  /// Thread-safe: Uses atomic operations for sequence number generation.
   static std::string generatePoolName(const std::string& queryId);
 
   memory::MemoryPool* pool() const {
@@ -89,6 +237,26 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
     return connectorSessionProperties_;
   }
 
+  std::shared_ptr<filesystems::TokenProvider> fsTokenProvider() const {
+    return fsTokenProvider_;
+  }
+
+  /// Registers a callback to be invoked when this QueryCtx is destroyed.
+  /// This allows external resources tied to the query's lifetime to be cleaned
+  /// up before the QueryCtx and its members are destructed. For example,
+  /// resources that have allocations in the query's memory pool.
+  ///
+  /// Example: HashTableCache uses this to remove cached hash tables when a
+  /// query completes. The cache entry holds a child memory pool of the query
+  /// pool, so it must be released before the query pool is destroyed.
+  ///
+  /// Note: Callbacks are invoked in registration order. Exceptions thrown by
+  /// callbacks are caught and logged; they do not prevent subsequent callbacks
+  /// from running.
+  void addReleaseCallback(ReleaseCallback callback) {
+    releaseCallbacks_.push_back(std::move(callback));
+  }
+
   /// Overrides the previous configuration. Note that this function is NOT
   /// thread-safe and should probably only be used in tests.
   void testingOverrideConfigUnsafe(
@@ -153,7 +321,8 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
       cache::AsyncDataCache* cache = cache::AsyncDataCache::getInstance(),
       std::shared_ptr<memory::MemoryPool> pool = nullptr,
       folly::Executor* spillExecutor = nullptr,
-      const std::string& queryId = "");
+      const std::string& queryId = "",
+      std::shared_ptr<filesystems::TokenProvider> tokenProvider = {});
 
   class MemoryReclaimer : public memory::MemoryReclaimer {
    public:
@@ -208,6 +377,7 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
 
   // Invoked to start memory arbitration on this query.
   void startArbitration();
+
   // Invoked to stop memory arbitration on this query.
   void finishArbitration();
 
@@ -224,9 +394,13 @@ class QueryCtx : public std::enable_shared_from_this<QueryCtx> {
   std::atomic<uint64_t> numTracedBytes_{0};
 
   mutable std::mutex mutex_;
+
   // Indicates if this query is under memory arbitration or not.
   std::atomic_bool underArbitration_{false};
   std::vector<ContinuePromise> arbitrationPromises_;
+  std::shared_ptr<filesystems::TokenProvider> fsTokenProvider_;
+  // Callbacks invoked before destruction to clean up external resources.
+  std::deque<ReleaseCallback> releaseCallbacks_;
 };
 
 // Represents the state of one thread of query execution.
diff --git a/velox/core/SimpleFunctionMetadata.h b/velox/core/SimpleFunctionMetadata.h
index 0bf202827038..633553069a48 100644
--- a/velox/core/SimpleFunctionMetadata.h
+++ b/velox/core/SimpleFunctionMetadata.h
@@ -15,7 +15,6 @@
  */
 #pragma once
 
-#include <boost/algorithm/string.hpp>
 #include <folly/Likely.h>
 #include <optional>
 
@@ -28,7 +27,6 @@
 #include "velox/expression/SignatureBinder.h"
 #include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
-#include "velox/type/Variant.h"
 
 namespace facebook::velox::core {
 
@@ -122,22 +120,24 @@ struct TypeAnalysisResults {
     size_t concreteCount = 0;
 
     // Set a priority based on the collected information. Lower priorities are
-    // picked first during function resolution. Each signature get a rank out
-    // of 4, those ranks form a Lattice ordering.
+    // picked first during function resolution. Each signature receives a rank
+    // from 1 to 4. Those ranks provice a lattice ordering.
+    //
     // rank 1: generic free and variadic free.
-    //    e.g: int, int, int -> int.
+    //          e.g: int, int, int -> int.
     // rank 2: has variadic but generic free.
-    //    e.g: Variadic<int> -> int.
+    //          e.g: Variadic<int> -> int.
     // rank 3: has generic but no variadic of generic.
-    //    e.g: Any, Any, -> int.
+    //          e.g: Any, Any, -> int.
     // rank 4: has variadic of generic.
-    //    e.g: Variadic<Any> -> int.
-
+    //          e.g: Variadic<Any> -> int.
+    //
     // If two functions have the same rank, then concreteCount is used to
     // to resolve the ordering.
-    // e.g: consider the two functions:
-    //    1. int, Any, Variadic<int> -> has rank 3. concreteCount =2
-    //    2. int, Any, Any     -> has rank 3. concreteCount =1
+    //
+    // E.g. consider the two functions:
+    //    1. int, Any, Variadic<int> -> rank 3; concreteCount 2
+    //    2. int, Any, Any           -> rank 3; concreteCount 1
     // in this case (1) is picked.
     // e.g: (Any, int) will be picked before (Any, Any)
     // e.g: Variadic<Array<Any>> is picked before Variadic<Any>.
@@ -243,13 +243,14 @@ struct TypeAnalysis<Generic<T, comparable, orderable>> {
     } else {
       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.addVariable(
+          exec::SignatureVariable(
+              typeVariableName,
+              std::nullopt,
+              exec::ParameterType::kTypeParameter,
+              false,
+              orderable,
+              comparable));
     }
     results.stats.hasGeneric = true;
     results.physicalType = UNKNOWN();
@@ -264,10 +265,12 @@ struct TypeAnalysis<ShortDecimal<P, S>> {
     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.addVariable(
+        exec::SignatureVariable(
+            p, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.addVariable(
+        exec::SignatureVariable(
+            s, std::nullopt, exec::ParameterType::kIntegerParameter));
     results.physicalType = BIGINT();
   }
 };
@@ -280,14 +283,44 @@ struct TypeAnalysis<LongDecimal<P, S>> {
     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.addVariable(
+        exec::SignatureVariable(
+            p, std::nullopt, exec::ParameterType::kIntegerParameter));
+    results.addVariable(
+        exec::SignatureVariable(
+            s, std::nullopt, exec::ParameterType::kIntegerParameter));
     results.physicalType = HUGEINT();
   }
 };
 
+template <typename E>
+struct TypeAnalysis<facebook::velox::BigintEnumT<E>> {
+  void run(TypeAnalysisResults& results) {
+    results.stats.concreteCount++;
+
+    const auto e = E::name();
+    results.out << fmt::format("bigint_enum({})", e);
+    results.addVariable(
+        exec::SignatureVariable(
+            e, std::nullopt, exec::ParameterType::kEnumParameter));
+    results.physicalType = BIGINT();
+  }
+};
+
+template <typename E>
+struct TypeAnalysis<facebook::velox::VarcharEnumT<E>> {
+  void run(TypeAnalysisResults& results) {
+    results.stats.concreteCount++;
+
+    const auto e = E::name();
+    results.out << fmt::format("varchar_enum({})", e);
+    results.addVariable(
+        exec::SignatureVariable(
+            e, std::nullopt, exec::ParameterType::kEnumParameter));
+    results.physicalType = VARCHAR();
+  }
+};
+
 template <typename K, typename V>
 struct TypeAnalysis<Map<K, V>> {
   void run(TypeAnalysisResults& results) {
@@ -377,6 +410,24 @@ struct TypeAnalysis<CustomType<T, providesCustomComparison>> {
   }
 };
 
+template <typename E>
+struct TypeAnalysis<BigintEnum<E>> {
+  void run(TypeAnalysisResults& results) {
+    // Need to call the TypeAnalysis on T, not T::type for BigintEnum type (on
+    // BigintEnumT, not Bigint).
+    TypeAnalysis<facebook::velox::BigintEnumT<E>>().run(results);
+  }
+};
+
+template <typename E>
+struct TypeAnalysis<VarcharEnum<E>> {
+  void run(TypeAnalysisResults& results) {
+    // Need to call the TypeAnalysis on T, not T::type for VarcharEnum type (on
+    // VarcharEnumT, not Varchar).
+    TypeAnalysis<facebook::velox::VarcharEnumT<E>>().run(results);
+  }
+};
+
 class ISimpleFunctionMetadata {
  public:
   virtual ~ISimpleFunctionMetadata() = default;
@@ -598,11 +649,12 @@ class SimpleFunctionMetadata : public ISimpleFunctionMetadata {
         ...);
 
     for (const auto& constraint : constraints) {
-      VELOX_CHECK(
-          !constraint.constraint().empty(),
-          "Constraint must be set for variable {}",
-          constraint.name());
-
+      if (constraint.isIntegerParameter()) {
+        VELOX_CHECK(
+            !constraint.constraint().empty(),
+            "Constraint must be set for variable {}",
+            constraint.name());
+      }
       results.variablesInformation.erase(constraint.name());
       results.variablesInformation.emplace(constraint.name(), constraint);
     }
@@ -829,8 +881,28 @@ class UDFHolder {
         (udf_has_callAscii_return_void && udf_has_call_return_bool)),
       "The return type for callAscii() must match the return type for call().");
 
-  // initialize():
-  static constexpr bool udf_has_initialize = util::has_method<
+  // Detects if initialize() is a template method using SFINAE.
+  // Template methods can match any signature via template parameter deduction,
+  // causing false positives in trait detection. We probe with a dummy type
+  // that's not in our expected signature to identify templates.
+  struct DummyProbeType {};
+
+  template <typename U, typename = void>
+  struct has_template_initialize : std::false_type {};
+
+  template <typename U>
+  struct has_template_initialize<
+      U,
+      util::detail::void_t<decltype(std::declval<U>().initialize(
+          std::declval<const std::vector<TypePtr>&>(),
+          std::declval<const core::QueryConfig&>(),
+          std::declval<const DummyProbeType*>()))>> : std::true_type {};
+
+  static constexpr bool is_initialize_template =
+      has_template_initialize<Fun>::value;
+
+  // Check for initialize() without MemoryPool parameter.
+  static constexpr bool udf_has_initialize_without_pool = util::has_method<
       Fun,
       initialize_method_resolver,
       void,
@@ -838,6 +910,25 @@ class UDFHolder {
       const core::QueryConfig&,
       const exec_arg_type<TArgs>*...>::value;
 
+  // Check for initialize() with MemoryPool parameter.
+  // Excludes template methods to prevent them from incorrectly matching
+  // via template parameter substitution (e.g., T=MemoryPool).
+  static constexpr bool udf_has_initialize_with_pool =
+      !is_initialize_template &&
+      util::has_method<
+          Fun,
+          initialize_method_resolver,
+          void,
+          const std::vector<TypePtr>&,
+          const core::QueryConfig&,
+          memory::MemoryPool*,
+          const exec_arg_type<TArgs>*...>::value;
+
+  // Combined trait for backward compatibility: true if ANY initialize exists
+  // This preserves the original meaning of udf_has_initialize
+  static constexpr bool udf_has_initialize =
+      udf_has_initialize_with_pool || udf_has_initialize_without_pool;
+
   // TODO Remove
   static constexpr bool udf_has_legacy_initialize = util::has_method<
       Fun,
@@ -921,11 +1012,29 @@ class UDFHolder {
     }
   }
 
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      memory::MemoryPool* memoryPool,
+      const typename exec_resolver<TArgs>::in_type*... constantArgs) {
+    // Prefer non-MemoryPool signature first to handle template methods
+    // correctly. Template initialize() methods can match any signature via
+    // template parameter deduction, so we avoid passing MemoryPool to them.
+    if constexpr (udf_has_initialize_without_pool) {
+      return instance_.initialize(inputTypes, config, constantArgs...);
+    } else if constexpr (udf_has_initialize_with_pool) {
+      return instance_.initialize(
+          inputTypes, config, memoryPool, constantArgs...);
+    }
+  }
+
+  // Overload for backward compatibility with callers that don't pass
+  // MemoryPool (e.g., Koski batch functions).
   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) {
+    if constexpr (udf_has_initialize_without_pool) {
       return instance_.initialize(inputTypes, config, constantArgs...);
     }
   }
diff --git a/velox/core/TableWriteTraits.cpp b/velox/core/TableWriteTraits.cpp
new file mode 100644
index 000000000000..f2520987a90c
--- /dev/null
+++ b/velox/core/TableWriteTraits.cpp
@@ -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 "velox/core/TableWriteTraits.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/ConstantVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::core {
+
+// static
+RowVectorPtr TableWriteTraits::createAggregationStatsOutput(
+    RowTypePtr outputType,
+    RowVectorPtr aggregationOutput,
+    StringView tableCommitContext,
+    velox::memory::MemoryPool* pool) {
+  // TODO: record aggregation stats output time.
+  if (aggregationOutput == nullptr) {
+    return nullptr;
+  }
+  VELOX_CHECK_GT(aggregationOutput->childrenSize(), 0);
+  const vector_size_t numOutputRows = aggregationOutput->childAt(0)->size();
+  std::vector<VectorPtr> columns;
+  for (int channel = 0; channel < outputType->size(); channel++) {
+    if (channel < TableWriteTraits::kContextChannel) {
+      // 1. Set null rows column.
+      // 2. Set null fragments column.
+      columns.push_back(
+          BaseVector::createNullConstant(
+              outputType->childAt(channel), numOutputRows, pool));
+      continue;
+    }
+    if (channel == TableWriteTraits::kContextChannel) {
+      // 3. Set commitcontext column.
+      columns.push_back(
+          std::make_shared<ConstantVector<StringView>>(
+              pool,
+              numOutputRows,
+              false /*isNull*/,
+              VARBINARY(),
+              // Note that we move tableCommitContext here, so ensure this
+              // branch is only executed once in the loop.
+              std::move(tableCommitContext)));
+      continue;
+    }
+    // 4. Set statistics columns.
+    columns.push_back(
+        aggregationOutput->childAt(channel - TableWriteTraits::kStatsChannel));
+  }
+  return std::make_shared<RowVector>(
+      pool, outputType, nullptr, numOutputRows, columns);
+}
+
+std::string TableWriteTraits::rowCountColumnName() {
+  static const std::string kRowCountName = "rows";
+  return kRowCountName;
+}
+
+std::string TableWriteTraits::fragmentColumnName() {
+  static const std::string kFragmentName = "fragments";
+  return kFragmentName;
+}
+
+std::string TableWriteTraits::contextColumnName() {
+  static const std::string kContextName = "commitcontext";
+  return kContextName;
+}
+
+const TypePtr& TableWriteTraits::rowCountColumnType() {
+  static const TypePtr kRowCountType = BIGINT();
+  return kRowCountType;
+}
+
+const TypePtr& TableWriteTraits::fragmentColumnType() {
+  static const TypePtr kFragmentType = VARBINARY();
+  return kFragmentType;
+}
+
+const TypePtr& TableWriteTraits::contextColumnType() {
+  static const TypePtr kContextType = VARBINARY();
+  return kContextType;
+}
+
+// static.
+RowTypePtr TableWriteTraits::outputType(
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec) {
+  static const auto kOutputTypeWithoutStats =
+      ROW({rowCountColumnName(), fragmentColumnName(), contextColumnName()},
+          {rowCountColumnType(), fragmentColumnType(), contextColumnType()});
+  if (!columnStatsSpec.has_value()) {
+    return kOutputTypeWithoutStats;
+  }
+  return kOutputTypeWithoutStats->unionWith(columnStatsSpec->outputType());
+}
+
+folly::dynamic TableWriteTraits::getTableCommitContext(
+    const RowVectorPtr& input) {
+  VELOX_CHECK_GT(input->size(), 0);
+  auto* contextVector =
+      input->childAt(kContextChannel)->as<SimpleVector<StringView>>();
+  return folly::parseJson(
+      std::string_view(contextVector->valueAt(input->size() - 1)));
+}
+
+int64_t TableWriteTraits::getRowCount(const RowVectorPtr& output) {
+  VELOX_CHECK_GT(output->size(), 0);
+  auto rowCountVector =
+      output->childAt(kRowCountChannel)->asFlatVector<int64_t>();
+  VELOX_CHECK_NOT_NULL(rowCountVector);
+  int64_t rowCount{0};
+  for (int i = 0; i < output->size(); ++i) {
+    if (!rowCountVector->isNullAt(i)) {
+      rowCount += rowCountVector->valueAt(i);
+    }
+  }
+  return rowCount;
+}
+
+} // namespace facebook::velox::core
diff --git a/velox/core/TableWriteTraits.h b/velox/core/TableWriteTraits.h
new file mode 100644
index 000000000000..3147294528d6
--- /dev/null
+++ b/velox/core/TableWriteTraits.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 <string>
+
+#include "velox/core/PlanNode.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::core {
+
+/// Defines table writer output related config properties that are shared
+/// between TableWriter and TableWriteMerger.
+///
+/// TODO: the table write output processing is Prestissimo specific. Consider
+/// move these part logic to Prestissimo and pass to Velox through a customized
+/// output processing callback.
+class TableWriteTraits {
+ public:
+  /// Defines the column names/types in table write output.
+  static std::string rowCountColumnName();
+  static std::string fragmentColumnName();
+  static std::string contextColumnName();
+
+  static const TypePtr& rowCountColumnType();
+  static const TypePtr& fragmentColumnType();
+  static const TypePtr& contextColumnType();
+
+  /// Defines the column channels in table write output.
+  /// Both the statistics and the row_count + fragments are transferred over the
+  /// same communication link between the TableWriter and TableFinish. Thus the
+  /// multiplexing is needed.
+  ///
+  ///  The transferred page layout looks like:
+  /// [row_count_channel], [fragment_channel], [context_channel],
+  /// [statistic_channel_1] ... [statistic_channel_N]]
+  ///
+  /// [row_count_channel] - contains number of rows processed by a TableWriter
+  /// [fragment_channel] - contains data provided by the DataSink#finish
+  /// [statistic_channel_1] ...[statistic_channel_N] -
+  /// contain aggregated statistics computed by the statistics aggregation
+  /// within the TableWriter
+  ///
+  /// For convenience, we never set both: [row_count_channel] +
+  /// [fragment_channel] and the [statistic_channel_1] ...
+  /// [statistic_channel_N].
+  ///
+  /// If this is a row that holds statistics - the [row_count_channel] +
+  /// [fragment_channel] will be NULL.
+  ///
+  /// If this is a row that holds the row count
+  /// or the fragment - all the statistics channels will be set to NULL.
+  static constexpr int32_t kRowCountChannel = 0;
+  static constexpr int32_t kFragmentChannel = 1;
+  static constexpr int32_t kContextChannel = 2;
+  static constexpr int32_t kStatsChannel = 3;
+
+  /// Defines the names of metadata in commit context in table writer output.
+  static constexpr std::string_view kLifeSpanContextKey = "lifespan";
+  static constexpr std::string_view kTaskIdContextKey = "taskId";
+  static constexpr std::string_view kCommitStrategyContextKey =
+      "pageSinkCommitStrategy";
+  static constexpr std::string_view klastPageContextKey = "lastPage";
+
+  static RowTypePtr outputType(
+      const std::optional<core::ColumnStatsSpec>& columnStatsSpec);
+
+  /// Returns the parsed commit context from table writer 'output'.
+  static folly::dynamic getTableCommitContext(const RowVectorPtr& output);
+
+  /// Returns the sum of row counts from table writer 'output'.
+  static int64_t getRowCount(const RowVectorPtr& output);
+
+  /// Creates the statistics output.
+  /// Statistics page layout (aggregate by partition):
+  /// row     fragments     context     [partition]   stats1     stats2 ...
+  /// null       null          X          [X]            X          X
+  /// null       null          X          [X]            X          X
+  static RowVectorPtr createAggregationStatsOutput(
+      RowTypePtr outputType,
+      RowVectorPtr aggregationOutput,
+      StringView tableCommitContext,
+      velox::memory::MemoryPool* pool);
+};
+
+} // namespace facebook::velox::core
diff --git a/velox/core/tests/CMakeLists.txt b/velox/core/tests/CMakeLists.txt
index 6092bb4b98f6..7b45ae059137 100644
--- a/velox/core/tests/CMakeLists.txt
+++ b/velox/core/tests/CMakeLists.txt
@@ -16,11 +16,14 @@ add_executable(
   velox_core_test
   ConstantTypedExprTest.cpp
   PlanFragmentTest.cpp
+  PlanNodeBuilderTest.cpp
   PlanNodeTest.cpp
   QueryConfigTest.cpp
+  QueryCtxTest.cpp
   StringTest.cpp
   TypeAnalysisTest.cpp
-  TypedExprSerdeTest.cpp)
+  TypedExprSerdeTest.cpp
+)
 
 add_test(velox_core_test velox_core_test)
 
@@ -34,4 +37,14 @@ target_link_libraries(
     velox_type
     velox_vector_test_lib
     GTest::gtest
-    GTest::gtest_main)
+    GTest::gtest_main
+)
+
+add_executable(velox_core_plan_consistency_checker_test PlanConsistencyCheckerTest.cpp)
+
+add_test(velox_core_plan_consistency_checker_test velox_core_plan_consistency_checker_test)
+
+target_link_libraries(
+  velox_core_plan_consistency_checker_test
+  PRIVATE velox_core GTest::gtest GTest::gtest_main
+)
diff --git a/velox/core/tests/ConstantTypedExprTest.cpp b/velox/core/tests/ConstantTypedExprTest.cpp
index 3d067f9ede87..2107d373e8ae 100644
--- a/velox/core/tests/ConstantTypedExprTest.cpp
+++ b/velox/core/tests/ConstantTypedExprTest.cpp
@@ -15,15 +15,179 @@
  */
 #include <gtest/gtest.h>
 
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/Memory.h"
 #include "velox/core/Expressions.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Variant.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 namespace facebook::velox::core::test {
 
-TEST(ConstantTypedExprTest, null) {
+namespace {
+struct TestOpaqueStruct {
+  int value;
+  std::string name;
+
+  TestOpaqueStruct(int v, std::string n) : value(v), name(std::move(n)) {}
+
+  bool operator==(const TestOpaqueStruct& other) const {
+    return value == other.value && name == other.name;
+  }
+};
+
+} // namespace
+
+class ConstantTypedExprTest : public ::testing::Test,
+                              public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addLeafPool();
+
+    // Register serialization/deserialization functions needed for the tests
+    Type::registerSerDe();
+    ITypedExpr::registerSerDe();
+
+    // Register OPAQUE type serialization for TestOpaqueStruct
+    static folly::once_flag once;
+    folly::call_once(once, []() {
+      OpaqueType::registerSerialization<TestOpaqueStruct>(
+          "TestOpaqueStruct",
+          [](const std::shared_ptr<TestOpaqueStruct>& obj) -> std::string {
+            return folly::json::serialize(
+                folly::dynamic::object("value", obj->value)("name", obj->name),
+                folly::json::serialization_opts{});
+          },
+          [](const std::string& json) -> std::shared_ptr<TestOpaqueStruct> {
+            folly::dynamic obj = folly::parseJson(json);
+            return std::make_shared<TestOpaqueStruct>(
+                obj["value"].asInt(), obj["name"].asString());
+          });
+    });
+  }
+
+  // Helper functions
+  std::shared_ptr<ConstantTypedExpr> createVariantExpr(
+      const TypePtr& type,
+      const Variant& value) {
+    return std::make_shared<ConstantTypedExpr>(type, value);
+  }
+
+  std::shared_ptr<ConstantTypedExpr> createNullVariantExpr(
+      const TypePtr& type) {
+    return std::make_shared<ConstantTypedExpr>(
+        type, variant::null(type->kind()));
+  }
+
+  std::shared_ptr<ConstantTypedExpr> createVectorExpr(const VectorPtr& vector) {
+    return std::make_shared<ConstantTypedExpr>(vector);
+  }
+
+  template <typename T>
+  VectorPtr createConstantVector(const TypePtr& type, const T& value) {
+    return BaseVector::createConstant(type, variant(value), 1, pool_.get());
+  }
+
+  VectorPtr createNullConstantVector(const TypePtr& type) {
+    return BaseVector::createNullConstant(type, 1, pool_.get());
+  }
+
+  // Test Data
+  struct TestValues {
+    variant nullValue;
+    std::vector<variant> nonNullValues;
+
+    TestValues(TypeKind kind) : nullValue(variant::null(kind)) {}
+  };
+
+  TestValues getTestValues(TypeKind kind) {
+    TestValues values(kind);
+
+    switch (kind) {
+      case TypeKind::BOOLEAN:
+        values.nonNullValues = {variant(true), variant(false)};
+        break;
+      case TypeKind::TINYINT:
+        values.nonNullValues = {
+            variant(int8_t(0)), variant(int8_t(127)), variant(int8_t(-128))};
+        break;
+      case TypeKind::SMALLINT:
+        values.nonNullValues = {
+            variant(int16_t(0)),
+            variant(int16_t(32767)),
+            variant(int16_t(-32768))};
+        break;
+      case TypeKind::INTEGER:
+        values.nonNullValues = {
+            variant(int32_t(0)),
+            variant(int32_t(2147483647)),
+            variant(int32_t(-2147483648))};
+        break;
+      case TypeKind::BIGINT:
+        values.nonNullValues = {
+            variant(int64_t(0)),
+            variant(int64_t(9223372036854775807LL)),
+            variant(int64_t(-9223372036854775808ULL))};
+        break;
+      case TypeKind::REAL:
+        values.nonNullValues = {variant(0.0f), variant(3.14f), variant(-1.5f)};
+        break;
+      case TypeKind::DOUBLE:
+        values.nonNullValues = {
+            variant(0.0), variant(3.14159), variant(-2.71828)};
+        break;
+      case TypeKind::VARCHAR:
+        values.nonNullValues = {
+            variant(""), variant("hello"), variant("test string")};
+        break;
+      case TypeKind::VARBINARY:
+        values.nonNullValues = {
+            variant::binary(""),
+            variant::binary("binary data"),
+            variant::binary("\x00\x01\x02")};
+        break;
+      case TypeKind::TIMESTAMP:
+        values.nonNullValues = {
+            variant(Timestamp(0, 0)),
+            variant(Timestamp(1234567890, 123456789))};
+        break;
+      case TypeKind::HUGEINT:
+        values.nonNullValues = {
+            variant(int128_t(0)),
+            variant(int128_t(123)),
+            variant(int128_t(-456))};
+        break;
+      default:
+        // For complex types, we'll handle them within individual tests.
+        break;
+    }
+    return values;
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  const std::vector<TypeKind> scalarTypes_ = {
+      TypeKind::BOOLEAN,
+      TypeKind::TINYINT,
+      TypeKind::SMALLINT,
+      TypeKind::INTEGER,
+      TypeKind::BIGINT,
+      TypeKind::REAL,
+      TypeKind::DOUBLE,
+      TypeKind::VARCHAR,
+      TypeKind::VARBINARY,
+      TypeKind::TIMESTAMP,
+      TypeKind::HUGEINT};
+};
+
+TEST_F(ConstantTypedExprTest, null) {
   auto makeNull = [](const TypePtr& type) {
     return std::make_shared<ConstantTypedExpr>(
         type, variant::null(type->kind()));
@@ -67,4 +231,386 @@ TEST(ConstantTypedExprTest, null) {
       *makeNull(ROW({"x", "y"}, {INTEGER(), REAL()})));
 }
 
+TEST_F(ConstantTypedExprTest, hashScalarTypes) {
+  // Tests the consistency of the hash value returned by the ConstantTypedExpr
+  // between its construction using variant and Velox vectors.
+  for (auto kind : scalarTypes_) {
+    auto type = createScalarType(kind);
+    auto testValues = getTestValues(kind);
+
+    // null values
+    auto nullVariantExpr = createNullVariantExpr(type);
+    auto nullVectorExpr = createVectorExpr(createNullConstantVector(type));
+    EXPECT_EQ(nullVariantExpr->hash(), nullVectorExpr->hash())
+        << "Hash mismatch for null " << TypeKindName::toName(kind);
+
+    // non-null values
+    for (const auto& value : testValues.nonNullValues) {
+      auto variantExpr = std::make_shared<ConstantTypedExpr>(type, value);
+      auto vectorExpr = createVectorExpr(
+          BaseVector::createConstant(type, value, 1, pool_.get()));
+      EXPECT_EQ(variantExpr->hash(), vectorExpr->hash())
+          << "Hash mismatch for non-null " << TypeKindName::toName(kind)
+          << " with value " << value.toJson(type);
+    }
+  }
+}
+
+TEST_F(ConstantTypedExprTest, hashComplexTypes) {
+  // ARRAY
+  auto arrayType = ARRAY(INTEGER());
+
+  // null values
+  auto nullArrayVariantExpr = createNullVariantExpr(arrayType);
+  auto nullArrayVectorExpr =
+      createVectorExpr(createNullConstantVector(arrayType));
+  EXPECT_EQ(nullArrayVariantExpr->hash(), nullArrayVectorExpr->hash())
+      << "Hash mismatch for null ARRAY variant vs vector";
+
+  // non-null values
+  auto arrayVariant = Variant::array({1, 2, 3});
+  auto arrayVariantExpr =
+      std::make_shared<ConstantTypedExpr>(arrayType, arrayVariant);
+  auto arrayVector = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto arrayVectorExpr = createVectorExpr(arrayVector);
+  EXPECT_EQ(arrayVariantExpr->hash(), arrayVectorExpr->hash())
+      << "Hash mismatch for non-null ARRAY variant vs vector";
+
+  // MAP
+  auto mapType = MAP(VARCHAR(), INTEGER());
+
+  // null values
+  auto nullMapVariantExpr = createNullVariantExpr(mapType);
+  auto nullMapVectorExpr = createVectorExpr(createNullConstantVector(mapType));
+  EXPECT_EQ(nullMapVariantExpr->hash(), nullMapVectorExpr->hash())
+      << "Hash mismatch for null MAP variant vs vector";
+
+  // non-null values
+  std::map<Variant, Variant> mapData = {{"key1", 1}, {"key2", 2}};
+  auto mapVariant = Variant::map(mapData);
+  auto mapVariantExpr =
+      std::make_shared<ConstantTypedExpr>(mapType, mapVariant);
+  auto mapVector =
+      makeMapVector<std::string, int32_t>({{{"key1", 1}, {"key2", 2}}});
+  auto mapVectorExpr = createVectorExpr(mapVector);
+  EXPECT_EQ(mapVariantExpr->hash(), mapVectorExpr->hash())
+      << "Hash mismatch for non-null MAP variant vs vector";
+
+  // ROW
+  auto rowType = ROW({{"a", INTEGER()}, {"b", VARCHAR()}});
+
+  // null values
+  auto nullRowVariantExpr = createNullVariantExpr(rowType);
+  auto nullRowVectorExpr = createVectorExpr(createNullConstantVector(rowType));
+  EXPECT_EQ(nullRowVariantExpr->hash(), nullRowVectorExpr->hash())
+      << "Hash mismatch for null ROW variant vs vector";
+
+  // non-null values
+  auto rowVariant = Variant::row({42, "hello"});
+  auto rowVariantExpr =
+      std::make_shared<ConstantTypedExpr>(rowType, rowVariant);
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>({42}), makeFlatVector<std::string>({"hello"})});
+  auto rowVectorExpr = createVectorExpr(rowVector);
+  EXPECT_EQ(rowVariantExpr->hash(), rowVectorExpr->hash())
+      << "Hash mismatch for non-null ROW variant vs vector";
+
+  // OPAQUE
+  auto testObj = std::make_shared<TestOpaqueStruct>(42, "test_data");
+  auto opaqueType = OPAQUE<TestOpaqueStruct>();
+
+  // null values
+  auto nullOpaqueVariantExpr = createNullVariantExpr(opaqueType);
+  auto nullOpaqueVectorExpr =
+      createVectorExpr(createNullConstantVector(opaqueType));
+  EXPECT_EQ(nullOpaqueVariantExpr->hash(), nullOpaqueVectorExpr->hash())
+      << "Hash mismatch for null OPAQUE";
+
+  // non-null values
+  auto opaqueVariant = Variant::opaque(testObj);
+  auto opaqueVariantExpr =
+      std::make_shared<ConstantTypedExpr>(opaqueType, opaqueVariant);
+  auto opaqueVectorExpr = createVectorExpr(
+      BaseVector::createConstant(opaqueType, opaqueVariant, 1, pool_.get()));
+  EXPECT_EQ(opaqueVariantExpr->hash(), opaqueVectorExpr->hash())
+      << "Hash mismatch for non-null OPAQUE";
+}
+
+TEST_F(ConstantTypedExprTest, serdeScalarTypes) {
+  // Test serialize/deserialize APIs for scalar types to ensure backward
+  // compatibility.
+  for (auto kind : scalarTypes_) {
+    auto type = createScalarType(kind);
+    auto testValues = getTestValues(kind);
+
+    // null values
+    auto nullVariantExpr = createNullVariantExpr(type);
+    auto serialized = nullVariantExpr->serialize();
+    auto deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+    EXPECT_TRUE(*nullVariantExpr == *deserialized)
+        << "Serialize/deserialize mismatch for null variant "
+        << TypeKindName::toName(kind);
+    auto nullVectorExpr = createVectorExpr(createNullConstantVector(type));
+    serialized = nullVectorExpr->serialize();
+    deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+    EXPECT_TRUE(*nullVectorExpr == *deserialized)
+        << "Serialize/deserialize mismatch for null vector "
+        << TypeKindName::toName(kind);
+
+    // non-null values
+    for (const auto& value : testValues.nonNullValues) {
+      auto variantExpr = std::make_shared<ConstantTypedExpr>(type, value);
+      serialized = variantExpr->serialize();
+      deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+      EXPECT_TRUE(*variantExpr == *deserialized)
+          << "Serialize/deserialize mismatch for variant "
+          << TypeKindName::toName(kind);
+
+      auto vectorExpr = createVectorExpr(
+          BaseVector::createConstant(type, value, 1, pool_.get()));
+      serialized = vectorExpr->serialize();
+      deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+      EXPECT_TRUE(*vectorExpr == *deserialized)
+          << "Serialize/deserialize mismatch for vector "
+          << TypeKindName::toName(kind) << " with value " << value.toJson(type);
+    }
+  }
+}
+
+TEST_F(ConstantTypedExprTest, serdeComplexTypes) {
+  // ARRAY
+  auto arrayType = ARRAY(INTEGER());
+
+  // null values
+  auto nullArrayVariantExpr = createNullVariantExpr(arrayType);
+  auto serialized = nullArrayVariantExpr->serialize();
+  auto deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*nullArrayVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null ARRAY variant";
+  auto nullArrayVectorExpr =
+      createVectorExpr(createNullConstantVector(arrayType));
+  serialized = nullArrayVectorExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+  EXPECT_TRUE(*nullArrayVectorExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null ARRAY vector";
+
+  // non-null values
+  auto arrayVariant = Variant::array({1, 2, 3});
+  auto arrayVariantExpr =
+      std::make_shared<ConstantTypedExpr>(arrayType, arrayVariant);
+  serialized = arrayVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*arrayVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for ARRAY variant with data";
+  auto arrayVector = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto arrayVectorExpr = createVectorExpr(arrayVector);
+  serialized = arrayVectorExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+  EXPECT_TRUE(*arrayVectorExpr == *deserialized)
+      << "Serialize/deserialize mismatch for ARRAY vector with data";
+
+  // MAP
+  auto mapType = MAP(VARCHAR(), INTEGER());
+  // null values
+  auto nullMapVariantExpr = createNullVariantExpr(mapType);
+  serialized = nullMapVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*nullMapVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null MAP variant";
+
+  // non-null values
+  std::map<Variant, Variant> mapData = {{"key1", 1}, {"key2", 2}};
+  auto mapVariant = Variant::map(mapData);
+  auto mapVariantExpr =
+      std::make_shared<ConstantTypedExpr>(mapType, mapVariant);
+  serialized = mapVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*mapVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for MAP variant with data";
+
+  // ROW
+  auto rowType = ROW({{"a", INTEGER()}, {"b", VARCHAR()}});
+  // null values
+  auto nullRowVariantExpr = createNullVariantExpr(rowType);
+  serialized = nullRowVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*nullRowVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null ROW variant";
+
+  // non-null values
+  auto rowVariant = Variant::row({42, "hello"});
+  auto rowVariantExpr =
+      std::make_shared<ConstantTypedExpr>(rowType, rowVariant);
+  serialized = rowVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*rowVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for ROW variant with data";
+
+  // OPAQUE
+  auto opaqueType = OPAQUE<TestOpaqueStruct>();
+
+  // null values
+  auto nullOpaqueVariantExpr = createNullVariantExpr(opaqueType);
+  serialized = nullOpaqueVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  EXPECT_TRUE(*nullOpaqueVariantExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null OPAQUE variant";
+  auto nullOpaqueVectorExpr =
+      createVectorExpr(createNullConstantVector(opaqueType));
+  serialized = nullOpaqueVectorExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, pool_.get());
+  EXPECT_TRUE(*nullOpaqueVectorExpr == *deserialized)
+      << "Serialize/deserialize mismatch for null OPAQUE vector";
+
+  // non-null values
+  auto testObj = std::make_shared<TestOpaqueStruct>(42, "test_data");
+  auto opaqueVariant = Variant::opaque(testObj);
+  auto opaqueVariantExpr =
+      std::make_shared<ConstantTypedExpr>(opaqueType, opaqueVariant);
+  serialized = opaqueVariantExpr->serialize();
+  deserialized = ConstantTypedExpr::create(serialized, nullptr);
+  auto actualObj = static_pointer_cast<const ConstantTypedExpr>(deserialized)
+                       ->value()
+                       .value<TypeKind::OPAQUE>()
+                       .obj;
+  EXPECT_EQ(*testObj, *static_pointer_cast<TestOpaqueStruct>(actualObj));
+}
+
+TEST_F(ConstantTypedExprTest, toStringScalarTypes) {
+  for (auto kind : scalarTypes_) {
+    auto type = createScalarType(kind);
+    auto testValues = getTestValues(kind);
+
+    // null values
+    auto nullVariantExpr = createNullVariantExpr(type);
+    auto nullVectorExpr = createVectorExpr(createNullConstantVector(type));
+    EXPECT_EQ(nullVariantExpr->toString(), nullVectorExpr->toString())
+        << "toString mismatch for null " << TypeKindName::toName(kind);
+
+    // non-null values
+    for (const auto& value : testValues.nonNullValues) {
+      auto variantExpr = std::make_shared<ConstantTypedExpr>(type, value);
+      auto vectorExpr = createVectorExpr(
+          BaseVector::createConstant(type, value, 1, pool_.get()));
+      EXPECT_EQ(variantExpr->toString(), vectorExpr->toString())
+          << "toString mismatch for " << TypeKindName::toName(kind)
+          << " with value " << value.toJson(type);
+    }
+  }
+}
+
+TEST_F(ConstantTypedExprTest, toStringComplexTypes) {
+  // ARRAY
+  auto arrayType = ARRAY(INTEGER());
+
+  // null values
+  auto nullArrayVariantExpr = createNullVariantExpr(arrayType);
+  auto nullArrayVectorExpr =
+      createVectorExpr(createNullConstantVector(arrayType));
+  EXPECT_EQ(nullArrayVariantExpr->toString(), nullArrayVectorExpr->toString())
+      << "toString mismatch for null ARRAY";
+
+  // non-null values
+  auto arrayVariant = Variant::array({1, 2, 3});
+  auto arrayVariantExpr =
+      std::make_shared<ConstantTypedExpr>(arrayType, arrayVariant);
+  auto arrayVector = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto arrayVectorExpr = createVectorExpr(arrayVector);
+  EXPECT_EQ(arrayVariantExpr->toString(), arrayVectorExpr->toString())
+      << "toString mismatch for ARRAY variant vs vector";
+
+  // MAP
+  auto mapType = MAP(VARCHAR(), INTEGER());
+
+  // null values
+  auto nullMapVariantExpr = createNullVariantExpr(mapType);
+  auto nullMapVectorExpr = createVectorExpr(createNullConstantVector(mapType));
+  EXPECT_EQ(nullMapVariantExpr->toString(), nullMapVectorExpr->toString())
+      << "toString mismatch for null MAP";
+
+  // non-null values
+  std::map<Variant, Variant> mapData = {{"key1", 1}, {"key2", 2}};
+  auto mapVariant = Variant::map(mapData);
+  auto mapVariantExpr =
+      std::make_shared<ConstantTypedExpr>(mapType, mapVariant);
+  auto mapVector =
+      makeMapVector<std::string, int32_t>({{{"key1", 1}, {"key2", 2}}});
+  auto mapVectorExpr = createVectorExpr(mapVector);
+  EXPECT_EQ(mapVariantExpr->toString(), mapVectorExpr->toString())
+      << "toString mismatch for MAP variant vs vector";
+
+  // ROW
+  auto rowType = ROW({{"a", INTEGER()}, {"b", VARCHAR()}});
+
+  // null values
+  auto nullRowVariantExpr = createNullVariantExpr(rowType);
+  auto nullRowVectorExpr = createVectorExpr(createNullConstantVector(rowType));
+  EXPECT_EQ(nullRowVariantExpr->toString(), nullRowVectorExpr->toString())
+      << "toString mismatch for null ROW";
+
+  // non-null values
+  auto rowVariant = Variant::row({42, "hello"});
+  auto rowVariantExpr =
+      std::make_shared<ConstantTypedExpr>(rowType, rowVariant);
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int32_t>({42}), makeFlatVector<std::string>({"hello"})});
+  auto rowVectorExpr = createVectorExpr(rowVector);
+  EXPECT_EQ(rowVariantExpr->toString(), rowVectorExpr->toString())
+      << "toString mismatch for ROW variant vs vector";
+
+  // OPAQUE
+  auto opaqueType = OPAQUE<TestOpaqueStruct>();
+
+  // null values
+  auto nullOpaqueVariantExpr = createNullVariantExpr(opaqueType);
+  auto nullOpaqueVectorExpr =
+      createVectorExpr(createNullConstantVector(opaqueType));
+  EXPECT_EQ(nullOpaqueVariantExpr->toString(), nullOpaqueVectorExpr->toString())
+      << "toString mismatch for null OPAQUE";
+
+  // non-null values
+  auto testObj = std::make_shared<TestOpaqueStruct>(42, "test_data");
+  auto opaqueVariant = Variant::opaque(testObj);
+  auto opaqueVariantExpr =
+      std::make_shared<ConstantTypedExpr>(opaqueType, opaqueVariant);
+  auto opaqueVectorExpr = createVectorExpr(
+      BaseVector::createConstant(opaqueType, opaqueVariant, 1, pool_.get()));
+  EXPECT_EQ(opaqueVariantExpr->toString(), opaqueVectorExpr->toString())
+      << "toString mismatch for OPAQUE variant vs vector";
+}
+
+TEST_F(ConstantTypedExprTest, variantTypeCheck) {
+  auto testVariantExpr = [&](const Variant& value,
+                             const TypePtr& type,
+                             const TypePtr& expectedType) {
+    VELOX_ASSERT_THROW(
+        createVariantExpr(type, value),
+        fmt::format(
+            "Expression type {} does not match variant type {}",
+            type->toString(),
+            expectedType->toString()));
+    if (type->isPrimitiveType()) {
+      VELOX_ASSERT_THROW(
+          createVariantExpr(type, Variant::null(expectedType->kind())),
+          fmt::format(
+              "Expression type {} does not match variant type {}",
+              type->toString(),
+              expectedType->toString()));
+    } else {
+      ASSERT_NO_THROW(
+          createVariantExpr(type, Variant::null(expectedType->kind())));
+    }
+  };
+
+  testVariantExpr("abc", INTEGER(), VARCHAR());
+  testVariantExpr(variant(123LL), INTEGER(), BIGINT());
+  testVariantExpr(2.0, BIGINT(), DOUBLE());
+  testVariantExpr(
+      variant::array({1, 2, 3}), ARRAY(VARCHAR()), ARRAY(INTEGER()));
+  testVariantExpr(
+      variant::map({{2.0, "xyz"}}),
+      MAP(INTEGER(), VARCHAR()),
+      MAP(DOUBLE(), VARCHAR()));
+}
+
 } // namespace facebook::velox::core::test
diff --git a/velox/core/tests/PlanConsistencyCheckerTest.cpp b/velox/core/tests/PlanConsistencyCheckerTest.cpp
new file mode 100644
index 000000000000..7faad88f4e37
--- /dev/null
+++ b/velox/core/tests/PlanConsistencyCheckerTest.cpp
@@ -0,0 +1,406 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/core/PlanConsistencyChecker.h"
+#include "velox/parse/PlanNodeIdGenerator.h"
+
+namespace facebook::velox::core {
+
+namespace {
+class PlanConsistencyCheckerTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    idGenerator_.reset();
+  }
+
+  std::string nextId() {
+    return idGenerator_.next();
+  }
+
+  PlanNodeIdGenerator idGenerator_;
+};
+
+TypedExprPtr Lit(Variant value) {
+  auto type = value.inferType();
+  return std::make_shared<ConstantTypedExpr>(std::move(type), std::move(value));
+}
+
+FieldAccessTypedExprPtr Col(TypePtr type, std::string name) {
+  return std::make_shared<FieldAccessTypedExpr>(
+      std::move(type), std::move(name));
+}
+
+TEST_F(PlanConsistencyCheckerTest, filter) {
+  auto valuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto projectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"a", "b", "c"},
+      std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
+      valuesNode);
+
+  auto filterNode =
+      std::make_shared<FilterNode>(nextId(), Col(BOOLEAN(), "a"), projectNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(filterNode));
+
+  // Wrong type.
+  filterNode =
+      std::make_shared<FilterNode>(nextId(), Col(BOOLEAN(), "b"), projectNode);
+
+  VELOX_ASSERT_THROW(
+      PlanConsistencyChecker::check(filterNode),
+      "Wrong type of input column: b, BOOLEAN vs. INTEGER");
+
+  // Wrong name.
+  filterNode =
+      std::make_shared<FilterNode>(nextId(), Col(BOOLEAN(), "x"), projectNode);
+
+  VELOX_ASSERT_THROW(
+      PlanConsistencyChecker::check(filterNode), "Field not found: x");
+
+  // Non-existent column referenced in a lambda expression.
+  filterNode = std::make_shared<FilterNode>(
+      nextId(),
+      std::make_shared<CallTypedExpr>(
+          BOOLEAN(),
+          "any_match",
+          Lit(Variant::array({1, 2, 3})),
+          std::make_shared<LambdaTypedExpr>(
+              ROW("x", INTEGER()),
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(),
+                  "lt",
+                  Col(INTEGER(), "x"),
+                  Col(INTEGER(), "blah")))),
+      projectNode);
+
+  VELOX_ASSERT_THROW(
+      PlanConsistencyChecker::check(filterNode), "Field not found: blah");
+}
+
+TEST_F(PlanConsistencyCheckerTest, project) {
+  auto valuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto projectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"a", "b", "c"},
+      std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
+      valuesNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(projectNode));
+
+  // Duplicate output name.
+  projectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"a", "a", "c"},
+      std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
+      valuesNode);
+
+  VELOX_ASSERT_THROW(
+      PlanConsistencyChecker::check(projectNode), "Duplicate output column: a");
+
+  // Wrong column name.
+  projectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"a", "a", "c"},
+      std::vector<TypedExprPtr>{Lit(true), Col(REAL(), "x"), Lit(0.1)},
+      valuesNode);
+
+  VELOX_ASSERT_THROW(
+      PlanConsistencyChecker::check(projectNode), "Field not found: x");
+}
+
+TEST_F(PlanConsistencyCheckerTest, aggregation) {
+  auto valuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto projectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"a", "b", "c"},
+      std::vector<TypedExprPtr>{Lit(true), Lit(1), Lit(0.1)},
+      valuesNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(projectNode));
+
+  {
+    auto aggregationNode = std::make_shared<AggregationNode>(
+        nextId(),
+        AggregationNode::Step::kPartial,
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"sum", "cnt"},
+        std::vector<AggregationNode::Aggregate>{
+            {
+                .call = std::make_shared<CallTypedExpr>(
+                    BIGINT(), "sum", Col(INTEGER(), "x")),
+                .rawInputTypes = {BIGINT()},
+            },
+            {
+                .call = std::make_shared<CallTypedExpr>(BIGINT(), "count"),
+                .rawInputTypes = {},
+            },
+        },
+        /*ignoreNullKeys*/ false,
+        projectNode);
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(aggregationNode), "Field not found: x");
+  }
+
+  {
+    auto aggregationNode = std::make_shared<AggregationNode>(
+        nextId(),
+        AggregationNode::Step::kPartial,
+        std::vector<FieldAccessTypedExprPtr>{Col(INTEGER(), "y")},
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"sum", "cnt"},
+        std::vector<AggregationNode::Aggregate>{
+            {
+                .call = std::make_shared<CallTypedExpr>(
+                    BIGINT(), "sum", Col(INTEGER(), "b")),
+                .rawInputTypes = {BIGINT()},
+            },
+            {
+                .call = std::make_shared<CallTypedExpr>(BIGINT(), "count"),
+                .rawInputTypes = {},
+            },
+        },
+        /*ignoreNullKeys*/ false,
+        projectNode);
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(aggregationNode), "Field not found: y");
+  }
+
+  {
+    auto aggregationNode = std::make_shared<AggregationNode>(
+        nextId(),
+        AggregationNode::Step::kPartial,
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"sum", "cnt"},
+        std::vector<AggregationNode::Aggregate>{
+            {
+                .call = std::make_shared<CallTypedExpr>(
+                    BIGINT(), "sum", Col(INTEGER(), "b")),
+                .rawInputTypes = {BIGINT()},
+                .mask = Col(BOOLEAN(), "z"),
+            },
+            {
+                .call = std::make_shared<CallTypedExpr>(BIGINT(), "count"),
+                .rawInputTypes = {},
+            },
+        },
+        /*ignoreNullKeys*/ false,
+        projectNode);
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(aggregationNode), "Field not found: z");
+  }
+
+  {
+    auto aggregationNode = std::make_shared<AggregationNode>(
+        nextId(),
+        AggregationNode::Step::kPartial,
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"sum", "sum"},
+        std::vector<AggregationNode::Aggregate>{
+            {
+                .call = std::make_shared<CallTypedExpr>(
+                    BIGINT(), "sum", Col(INTEGER(), "b")),
+                .rawInputTypes = {BIGINT()},
+            },
+            {
+                .call = std::make_shared<CallTypedExpr>(BIGINT(), "count"),
+                .rawInputTypes = {},
+            },
+        },
+        /*ignoreNullKeys*/ false,
+        projectNode);
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(aggregationNode),
+        "Duplicate output column: sum");
+  }
+}
+
+TEST_F(PlanConsistencyCheckerTest, hashJoin) {
+  auto leftValuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto leftProjectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{Lit(1), Lit(2)},
+      leftValuesNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(leftValuesNode));
+
+  auto rightValuesNode =
+      std::make_shared<ValuesNode>(nextId(), std::vector<RowVectorPtr>{});
+
+  auto rightProjectNode = std::make_shared<ProjectNode>(
+      nextId(),
+      std::vector<std::string>{"c", "d"},
+      std::vector<TypedExprPtr>{Lit(1), Lit(2)},
+      leftValuesNode);
+  ASSERT_NO_THROW(PlanConsistencyChecker::check(rightProjectNode));
+
+  // Invalid reference in the filter.
+  {
+    auto joinNode = std::make_shared<HashJoinNode>(
+        nextId(),
+        JoinType::kLeft,
+        /*nullAware=*/false,
+        std::vector<FieldAccessTypedExprPtr>{Col(INTEGER(), "a")},
+        std::vector<FieldAccessTypedExprPtr>{Col(INTEGER(), "c")},
+        std::make_shared<CallTypedExpr>(
+            BOOLEAN(), "lt", Col(INTEGER(), "b"), Col(INTEGER(), "blah")),
+        leftProjectNode,
+        rightProjectNode,
+        ROW({}));
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(joinNode),
+        "Field not found: blah. Available fields are: a, b, c, d.");
+  }
+
+  // Duplicate join condition.
+  {
+    auto joinNode = std::make_shared<HashJoinNode>(
+        nextId(),
+        JoinType::kLeft,
+        /*nullAware=*/false,
+        std::vector<FieldAccessTypedExprPtr>{
+            Col(INTEGER(), "a"), Col(INTEGER(), "a")},
+        std::vector<FieldAccessTypedExprPtr>{
+            Col(INTEGER(), "c"), Col(INTEGER(), "c")},
+        /*filter=*/nullptr,
+        leftProjectNode,
+        rightProjectNode,
+        ROW({}));
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(joinNode),
+        "Duplicate join condition: \"a\" = \"c\"");
+  }
+}
+
+namespace {
+class TestTableHandle : public connector::ConnectorTableHandle {
+ public:
+  explicit TestTableHandle(std::string connectorId, std::string name)
+      : connector::ConnectorTableHandle(std::move(connectorId)),
+        name_{std::move(name)} {}
+
+  const std::string& name() const override {
+    return name_;
+  }
+
+ private:
+  const std::string name_;
+};
+
+class TestColumnHandle : public connector::ColumnHandle {
+ public:
+  explicit TestColumnHandle(std::string name) : name_{std::move(name)} {}
+
+  const std::string& name() const override {
+    return name_;
+  }
+
+ private:
+  const std::string name_;
+};
+} // namespace
+
+TEST_F(PlanConsistencyCheckerTest, tableScan) {
+  // Empty output column name.
+  {
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"", "b"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        connector::ColumnHandleMap{});
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(scanNode),
+        "Output column name cannot be empty");
+  }
+
+  // Duplicate output column name.
+  {
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"a", "b", "a"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        connector::ColumnHandleMap{});
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(scanNode), "Duplicate output column: a");
+  }
+
+  // Missing assignments.
+  {
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"a", "b", "c"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        connector::ColumnHandleMap{});
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(scanNode),
+        "Column assignments must match output type");
+  }
+
+  {
+    connector::ColumnHandleMap assignments{
+        {"a", std::make_shared<TestColumnHandle>("x")},
+        {"b", std::make_shared<TestColumnHandle>("y")},
+        {"blah", std::make_shared<TestColumnHandle>("z")},
+    };
+
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"a", "b", "c"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        assignments);
+
+    VELOX_ASSERT_THROW(
+        PlanConsistencyChecker::check(scanNode),
+        "Column assignment is missing for c");
+  }
+
+  // No issues.
+  {
+    connector::ColumnHandleMap assignments{
+        {"a", std::make_shared<TestColumnHandle>("x")},
+        {"b", std::make_shared<TestColumnHandle>("y")},
+        {"c", std::make_shared<TestColumnHandle>("z")},
+    };
+
+    auto scanNode = std::make_shared<TableScanNode>(
+        nextId(),
+        ROW({"a", "b", "c"}, INTEGER()),
+        std::make_shared<TestTableHandle>("test", "t"),
+        assignments);
+
+    ASSERT_NO_THROW(PlanConsistencyChecker::check(scanNode));
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::core
diff --git a/velox/core/tests/PlanFragmentTest.cpp b/velox/core/tests/PlanFragmentTest.cpp
index e5ddab00fbf7..64bc4e587dfd 100644
--- a/velox/core/tests/PlanFragmentTest.cpp
+++ b/velox/core/tests/PlanFragmentTest.cpp
@@ -129,10 +129,9 @@ TEST_F(PlanFragmentTest, aggregationCanSpill) {
   const std::vector<FieldAccessTypedExprPtr> emptyPreGroupingKeys;
   std::vector<std::string> aggregateNames{"sum"};
   std::vector<std::string> emptyAggregateNames{};
-  std::vector<TypedExprPtr> aggregateInputs{
-      std::make_shared<InputTypedExpr>(BIGINT())};
+  auto aggregateInput = std::make_shared<InputTypedExpr>(BIGINT());
   const std::vector<AggregationNode::Aggregate> aggregates{
-      {std::make_shared<core::CallTypedExpr>(BIGINT(), aggregateInputs, "sum"),
+      {std::make_shared<core::CallTypedExpr>(BIGINT(), "sum", aggregateInput),
        {},
        nullptr,
        {},
@@ -149,8 +148,9 @@ TEST_F(PlanFragmentTest, aggregationCanSpill) {
 
     std::string debugString() const {
       return fmt::format(
-          "aggregationStep:{} isSpillEnabled:{} isAggregationSpillEnabled:{} isDistinct:{} hasPreAggregation:{} expectedCanSpill:{}",
-          AggregationNode::stepName(aggregationStep),
+          "aggregationStep:{} isSpillEnabled:{} isAggregationSpillEnabled:{} "
+          "isDistinct:{} hasPreAggregation:{} expectedCanSpill:{}",
+          AggregationNode::toName(aggregationStep),
           isSpillEnabled,
           isAggregationSpillEnabled,
           isDistinct,
@@ -188,7 +188,8 @@ TEST_F(PlanFragmentTest, aggregationCanSpill) {
         testData.hasPreAggregation ? preGroupingKeys : emptyPreGroupingKeys,
         testData.isDistinct ? emptyAggregateNames : aggregateNames,
         testData.isDistinct ? emptyAggregates : aggregates,
-        false,
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
         valueNode_);
     auto queryCtx = getSpillQueryCtx(
         testData.isSpillEnabled,
@@ -354,7 +355,7 @@ TEST_F(PlanFragmentTest, supportsBarrier) {
                               core::JoinType::kAnti)
                           .planNode();
     const PlanFragment planFragment{plan};
-    ASSERT_FALSE(planFragment.supportsBarrier());
+    ASSERT_TRUE(planFragment.firstNodeNotSupportingBarrier() != nullptr);
   }
   // Plan fragment with plan node supporting barrier.
   {
@@ -374,6 +375,6 @@ TEST_F(PlanFragmentTest, supportsBarrier) {
                         core::JoinType::kInner)
                     .planNode();
     const PlanFragment planFragment{plan};
-    ASSERT_TRUE(planFragment.supportsBarrier());
+    ASSERT_TRUE(planFragment.firstNodeNotSupportingBarrier() == nullptr);
   }
 }
diff --git a/velox/core/tests/PlanNodeBuilderTest.cpp b/velox/core/tests/PlanNodeBuilderTest.cpp
index 59b588df7f15..00d9d034075e 100644
--- a/velox/core/tests/PlanNodeBuilderTest.cpp
+++ b/velox/core/tests/PlanNodeBuilderTest.cpp
@@ -17,6 +17,9 @@
 
 #include "velox/common/memory/Memory.h"
 #include "velox/core/PlanNode.h"
+#include "velox/duckdb/conversion/DuckParser.h"
+#include "velox/exec/tests/utils/AggregationResolver.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace ::facebook::velox;
@@ -31,11 +34,82 @@ class PlanNodeBuilderTest : public testing::Test, public test::VectorTestBase {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    aggregate::prestosql::registerAllAggregateFunctions();
+  }
+
+  core::ColumnStatsSpec createStatsSpec(
+      const RowTypePtr& type,
+      const std::vector<std::string>& groupingKeys,
+      core::AggregationNode::Step step,
+      const std::vector<std::string>& aggregates,
+      const std::vector<std::vector<TypePtr>>& rawInputArgs = {}) {
+    std::vector<core::AggregationNode::Aggregate> aggs;
+    aggs.reserve(aggregates.size());
+    std::vector<std::string> names;
+    names.reserve(aggregates.size());
+
+    duckdb::ParseOptions options;
+    options.parseIntegerAsBigint = true;
+    exec::test::AggregateTypeResolver resolver(step);
+
+    for (auto i = 0; i < aggregates.size(); ++i) {
+      const auto& aggregate = aggregates[i];
+      const auto untypedExpr = duckdb::parseAggregateExpr(aggregate, options);
+
+      if (!rawInputArgs.empty()) {
+        resolver.setRawInputTypes(rawInputArgs[i]);
+      }
+
+      core::AggregationNode::Aggregate agg;
+      agg.call = std::dynamic_pointer_cast<const core::CallTypedExpr>(
+          core::Expressions::inferTypes(untypedExpr.expr, type, pool()));
+
+      if (step == core::AggregationNode::Step::kPartial ||
+          step == core::AggregationNode::Step::kSingle) {
+        VELOX_CHECK(rawInputArgs.empty());
+        for (const auto& input : agg.call->inputs()) {
+          agg.rawInputTypes.push_back(input->type());
+        }
+      } else {
+        agg.rawInputTypes = rawInputArgs[i];
+      }
+
+      VELOX_CHECK_NULL(untypedExpr.maskExpr);
+      VELOX_CHECK(!untypedExpr.distinct);
+      VELOX_CHECK(untypedExpr.orderBy.empty());
+
+      aggs.emplace_back(agg);
+
+      if (untypedExpr.expr->alias().has_value()) {
+        names.push_back(untypedExpr.expr->alias().value());
+      } else {
+        names.push_back(fmt::format("a{}", i));
+      }
+    }
+    VELOX_CHECK_EQ(aggs.size(), names.size());
+
+    std::vector<core::FieldAccessTypedExprPtr> groupingKeyExprs;
+    groupingKeyExprs.reserve(groupingKeys.size());
+    for (const auto& groupingKey : groupingKeys) {
+      auto untypedGroupingKeyExpr = duckdb::parseExpr(groupingKey, options);
+      auto groupingKeyExpr =
+          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+              core::Expressions::inferTypes(
+                  untypedGroupingKeyExpr, type, pool()));
+      VELOX_CHECK_NOT_NULL(
+          groupingKeyExpr,
+          "Grouping key must use a column name, not an expression: {}",
+          groupingKey);
+      groupingKeyExprs.emplace_back(std::move(groupingKeyExpr));
+    }
+
+    return core::ColumnStatsSpec(
+        std::move(groupingKeyExprs), step, std::move(names), std::move(aggs));
   }
 
   // A default source node, these are frequently needed when construting
   // PlanNodes, so providing one here.
-  const std::shared_ptr<const ValuesNode> source =
+  const std::shared_ptr<const ValuesNode> source_ =
       ValuesNode::Builder()
           .id("values_node_id")
           .values({makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})})
@@ -49,13 +123,17 @@ class TestConnectorTableHandleForLookupJoin
   explicit TestConnectorTableHandleForLookupJoin(std::string connectorId)
       : connector::ConnectorTableHandle(std::move(connectorId)) {}
 
+  const std::string& name() const override {
+    VELOX_NYI();
+  }
+
   bool supportsIndexLookup() const override {
     return true;
   }
 };
 } // namespace
 
-TEST_F(PlanNodeBuilderTest, ValuesNode) {
+TEST_F(PlanNodeBuilderTest, valuesNode) {
   const PlanNodeId id = "values_node_id";
   const std::vector<RowVectorPtr> values{
       makeRowVector(
@@ -87,7 +165,7 @@ TEST_F(PlanNodeBuilderTest, ValuesNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, ArrowStreamNode) {
+TEST_F(PlanNodeBuilderTest, arrowStreamNode) {
   const PlanNodeId id = "arrow_stream_node_id";
   const RowTypePtr outputType = ROW({"c0", "c1"}, {INTEGER(), VARCHAR()});
   auto arrowStream = std::make_shared<ArrowArrayStream>();
@@ -109,7 +187,7 @@ TEST_F(PlanNodeBuilderTest, ArrowStreamNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, TraceScanNode) {
+TEST_F(PlanNodeBuilderTest, traceScanNode) {
   const PlanNodeId id = "trace_scan_node_id";
   const std::string traceDir = "/tmp/trace";
   const uint32_t pipelineId = 7;
@@ -137,7 +215,7 @@ TEST_F(PlanNodeBuilderTest, TraceScanNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, FilterNode) {
+TEST_F(PlanNodeBuilderTest, filterNode) {
   const PlanNodeId id = "filter_node_id";
   const auto filter =
       std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "col0");
@@ -145,18 +223,18 @@ TEST_F(PlanNodeBuilderTest, FilterNode) {
   const auto verify = [&](const std::shared_ptr<const FilterNode>& node) {
     EXPECT_EQ(node->id(), id);
     EXPECT_EQ(node->filter(), filter);
-    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
   };
 
   const auto node =
-      FilterNode::Builder().id(id).filter(filter).source(source).build();
+      FilterNode::Builder().id(id).filter(filter).source(source_).build();
   verify(node);
 
   const auto node2 = FilterNode::Builder(*node).build();
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, ProjectNode) {
+TEST_F(PlanNodeBuilderTest, projectNode) {
   const PlanNodeId id = "project_node_id";
   const std::vector<std::string> names{"out_col"};
   const std::vector<TypedExprPtr> projections{
@@ -166,14 +244,14 @@ TEST_F(PlanNodeBuilderTest, ProjectNode) {
     EXPECT_EQ(node->id(), id);
     EXPECT_EQ(node->names(), names);
     EXPECT_EQ(node->projections(), projections);
-    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
   };
 
   const auto node = ProjectNode::Builder()
                         .id(id)
                         .names(names)
                         .projections(projections)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -181,16 +259,30 @@ TEST_F(PlanNodeBuilderTest, ProjectNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, TableScanNode) {
+class DummyTableHandle : public connector::ConnectorTableHandle {
+ public:
+  DummyTableHandle(const std::string& connectorId)
+      : connector::ConnectorTableHandle(connectorId) {}
+
+  const std::string& name() const override {
+    VELOX_NYI();
+  }
+};
+
+class DummyColumnHandle : public connector::ColumnHandle {
+ public:
+  const std::string& name() const override {
+    VELOX_NYI();
+  }
+};
+
+TEST_F(PlanNodeBuilderTest, tableScanNode) {
   const PlanNodeId id = "table_scan_node_id";
   const RowTypePtr outputType = ROW({"c0", "c1"}, {INTEGER(), VARCHAR()});
-  const auto tableHandle =
-      std::make_shared<connector::ConnectorTableHandle>("connector_id");
-  const std::
-      unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-          assignments{
-              {"c0", std::make_shared<connector::ColumnHandle>()},
-              {"c1", std::make_shared<connector::ColumnHandle>()}};
+  const auto tableHandle = std::make_shared<DummyTableHandle>("connector_id");
+  const connector::ColumnHandleMap assignments{
+      {"c0", std::make_shared<DummyColumnHandle>()},
+      {"c1", std::make_shared<DummyColumnHandle>()}};
 
   const auto verify = [&](const std::shared_ptr<const TableScanNode>& node) {
     EXPECT_EQ(node->id(), id);
@@ -211,7 +303,7 @@ TEST_F(PlanNodeBuilderTest, TableScanNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, AggregationNode) {
+TEST_F(PlanNodeBuilderTest, aggregationNode) {
   const PlanNodeId id = "aggregation_node_id";
   const auto step = AggregationNode::Step::kSingle;
   const auto rowType = ROW({"c0"}, {INTEGER()});
@@ -223,8 +315,7 @@ TEST_F(PlanNodeBuilderTest, AggregationNode) {
   const std::vector<std::string> aggregateNames{"a0"};
   const std::vector<AggregationNode::Aggregate> aggregates{
       AggregationNode::Aggregate{
-          .call = std::make_shared<core::CallTypedExpr>(
-              INTEGER(), std::vector<TypedExprPtr>{}, "sum"),
+          .call = std::make_shared<core::CallTypedExpr>(INTEGER(), "sum"),
           .rawInputTypes = {INTEGER()}}};
   const std::vector<vector_size_t> globalGroupingSets{0};
   const std::optional<FieldAccessTypedExprPtr> groupId{
@@ -242,7 +333,7 @@ TEST_F(PlanNodeBuilderTest, AggregationNode) {
     EXPECT_EQ(node->globalGroupingSets(), globalGroupingSets);
     EXPECT_EQ(node->groupId(), groupId);
     EXPECT_EQ(node->ignoreNullKeys(), ignoreNullKeys);
-    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
   };
 
   const auto node = AggregationNode::Builder()
@@ -255,7 +346,7 @@ TEST_F(PlanNodeBuilderTest, AggregationNode) {
                         .globalGroupingSets(globalGroupingSets)
                         .groupId(groupId)
                         .ignoreNullKeys(ignoreNullKeys)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -263,7 +354,7 @@ TEST_F(PlanNodeBuilderTest, AggregationNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, TableWriteNode) {
+TEST_F(PlanNodeBuilderTest, tableWriteNode) {
   const PlanNodeId id = "table_write_node_id";
   const RowTypePtr columns = ROW({"c0"}, {INTEGER()});
   const std::vector<std::string> columnNames{"c0"};
@@ -271,16 +362,11 @@ TEST_F(PlanNodeBuilderTest, TableWriteNode) {
   const bool hasPartitioningScheme = true;
   const auto commitStrategy = connector::CommitStrategy::kNoCommit;
 
-  const auto aggregationNode = AggregationNode::Builder()
-                                   .id("aggregation_node_id")
-                                   .step(AggregationNode::Step::kPartial)
-                                   .groupingKeys({})
-                                   .preGroupedKeys({})
-                                   .aggregateNames({})
-                                   .aggregates({})
-                                   .ignoreNullKeys(true)
-                                   .source(source)
-                                   .build();
+  const auto statsSpec = createStatsSpec(
+      columns,
+      std::vector<std::string>{},
+      AggregationNode::Step::kPartial,
+      std::vector<std::string>{"sum(c0)"});
 
   const auto insertTableHandle =
       std::make_shared<InsertTableHandle>("connector_id", nullptr);
@@ -289,24 +375,24 @@ TEST_F(PlanNodeBuilderTest, TableWriteNode) {
     EXPECT_EQ(node->id(), id);
     EXPECT_EQ(node->columns(), columns);
     EXPECT_EQ(node->columnNames(), columnNames);
-    EXPECT_EQ(node->aggregationNode(), aggregationNode);
     EXPECT_EQ(node->insertTableHandle(), insertTableHandle);
+    EXPECT_TRUE(node->hasColumnStatsSpec());
     EXPECT_EQ(node->hasPartitioningScheme(), hasPartitioningScheme);
     EXPECT_EQ(node->outputType(), outputType);
     EXPECT_EQ(node->commitStrategy(), commitStrategy);
-    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
   };
 
   const auto node = TableWriteNode::Builder()
                         .id(id)
                         .columns(columns)
                         .columnNames(columnNames)
-                        .aggregationNode(aggregationNode)
+                        .columnStatsSpec(statsSpec)
                         .insertTableHandle(insertTableHandle)
                         .hasPartitioningScheme(hasPartitioningScheme)
                         .outputType(outputType)
                         .commitStrategy(commitStrategy)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -314,34 +400,30 @@ TEST_F(PlanNodeBuilderTest, TableWriteNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, TableWriteMergeNode) {
+TEST_F(PlanNodeBuilderTest, tableWriteMergeNode) {
   const PlanNodeId id = "table_write_merge_node_id";
   const RowTypePtr outputType = ROW({"c0"}, {BIGINT()});
 
-  const auto aggregationNode = AggregationNode::Builder()
-                                   .id("aggregation_node_id")
-                                   .step(AggregationNode::Step::kPartial)
-                                   .groupingKeys({})
-                                   .preGroupedKeys({})
-                                   .aggregateNames({})
-                                   .aggregates({})
-                                   .ignoreNullKeys(true)
-                                   .source(source)
-                                   .build();
+  const auto statsSpec = createStatsSpec(
+      outputType,
+      std::vector<std::string>{},
+      AggregationNode::Step::kIntermediate,
+      std::vector<std::string>{"sum(c0)"},
+      {{BIGINT()}});
 
   const auto verify =
       [&](const std::shared_ptr<const TableWriteMergeNode>& node) {
         EXPECT_EQ(node->id(), id);
         EXPECT_EQ(node->outputType(), outputType);
-        EXPECT_EQ(node->aggregationNode(), aggregationNode);
-        EXPECT_EQ(node->sources()[0], source);
+        EXPECT_TRUE(node->hasColumnStatsSpec());
+        EXPECT_EQ(node->sources()[0], source_);
       };
 
   const auto node = TableWriteMergeNode::Builder()
                         .id(id)
                         .outputType(outputType)
-                        .aggregationNode(aggregationNode)
-                        .source(source)
+                        .columnStatsSpec(statsSpec)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -349,7 +431,7 @@ TEST_F(PlanNodeBuilderTest, TableWriteMergeNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, ExpandNode) {
+TEST_F(PlanNodeBuilderTest, expandNode) {
   const PlanNodeId id = "expand_node_id";
   std::vector<std::vector<TypedExprPtr>> projections{
       {std::make_shared<FieldAccessTypedExpr>(INTEGER(), "col0")}};
@@ -359,14 +441,14 @@ TEST_F(PlanNodeBuilderTest, ExpandNode) {
     EXPECT_EQ(node->id(), id);
     EXPECT_EQ(node->projections(), projections);
     EXPECT_EQ(node->names(), names);
-    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
   };
 
   const auto node = ExpandNode::Builder()
                         .id(id)
                         .projections(projections)
                         .names(names)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -374,7 +456,7 @@ TEST_F(PlanNodeBuilderTest, ExpandNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, GroupIdNode) {
+TEST_F(PlanNodeBuilderTest, groupIdNode) {
   const PlanNodeId id = "group_id_node_id";
   const std::vector<std::vector<std::string>> groupingSets{{"a"}, {"b"}};
   const std::vector<GroupIdNode::GroupingKeyInfo> groupingKeyInfos{
@@ -394,7 +476,7 @@ TEST_F(PlanNodeBuilderTest, GroupIdNode) {
         groupingKeyInfos[0].serialize());
     EXPECT_EQ(node->aggregationInputs(), aggregationInputs);
     EXPECT_EQ(node->groupIdName(), groupIdName);
-    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
   };
 
   const auto node = GroupIdNode::Builder()
@@ -403,7 +485,7 @@ TEST_F(PlanNodeBuilderTest, GroupIdNode) {
                         .groupingKeyInfos(groupingKeyInfos)
                         .aggregationInputs(aggregationInputs)
                         .groupIdName(groupIdName)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -411,7 +493,7 @@ TEST_F(PlanNodeBuilderTest, GroupIdNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, ExchangeNode) {
+TEST_F(PlanNodeBuilderTest, exchangeNode) {
   const PlanNodeId id = "exchange_node_id";
   const RowTypePtr type = ROW({"c0"}, {BIGINT()});
   const auto serdeKind = VectorSerde::Kind::kPresto;
@@ -433,7 +515,7 @@ TEST_F(PlanNodeBuilderTest, ExchangeNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, MergeExchangeNode) {
+TEST_F(PlanNodeBuilderTest, mergeExchangeNode) {
   const PlanNodeId id = "merge_exchange_node_id";
   const RowTypePtr type = ROW({"c0"}, {BIGINT()});
   const auto serdeKind = VectorSerde::Kind::kPresto;
@@ -463,7 +545,7 @@ TEST_F(PlanNodeBuilderTest, MergeExchangeNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, LocalMergeNode) {
+TEST_F(PlanNodeBuilderTest, localMergeNode) {
   const PlanNodeId id = "local_merge_node_id";
   std::vector<FieldAccessTypedExprPtr> sortingKeys = {
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
@@ -473,14 +555,14 @@ TEST_F(PlanNodeBuilderTest, LocalMergeNode) {
     EXPECT_EQ(node->id(), id);
     EXPECT_EQ(node->sortingKeys(), sortingKeys);
     EXPECT_EQ(node->sortingOrders(), sortingOrders);
-    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+    EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
   };
 
   const auto node = LocalMergeNode::Builder()
                         .id(id)
                         .sortingKeys(sortingKeys)
                         .sortingOrders(sortingOrders)
-                        .sources({source})
+                        .sources({source_})
                         .build();
   verify(node);
 
@@ -488,7 +570,7 @@ TEST_F(PlanNodeBuilderTest, LocalMergeNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, LocalPartitionNode) {
+TEST_F(PlanNodeBuilderTest, localPartitionNode) {
   const PlanNodeId id = "local_partition_node_id";
   const auto type = LocalPartitionNode::Type::kGather;
   const bool scaleWriter = true;
@@ -500,7 +582,7 @@ TEST_F(PlanNodeBuilderTest, LocalPartitionNode) {
         EXPECT_EQ(node->id(), id);
         EXPECT_EQ(node->type(), type);
         EXPECT_EQ(node->scaleWriter(), scaleWriter);
-        EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+        EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
         EXPECT_EQ(
             node->partitionFunctionSpec().serialize(),
             partitionFunctionSpec->serialize());
@@ -511,7 +593,7 @@ TEST_F(PlanNodeBuilderTest, LocalPartitionNode) {
                         .type(type)
                         .scaleWriter(scaleWriter)
                         .partitionFunctionSpec(partitionFunctionSpec)
-                        .sources({source})
+                        .sources({source_})
                         .build();
   verify(node);
 
@@ -519,7 +601,7 @@ TEST_F(PlanNodeBuilderTest, LocalPartitionNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, PartitionedOutputNode) {
+TEST_F(PlanNodeBuilderTest, partitionedOutputNode) {
   const PlanNodeId id = "partitioned_output_node_id";
   const auto kind = PartitionedOutputNode::Kind::kPartitioned;
   std::vector<TypedExprPtr> keys{
@@ -541,7 +623,7 @@ TEST_F(PlanNodeBuilderTest, PartitionedOutputNode) {
         EXPECT_EQ(node->outputType(), outputType);
         EXPECT_EQ(node->serdeKind(), serdeKind);
         EXPECT_EQ(node->partitionFunctionSpecPtr(), partitionFunctionSpec);
-        EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source});
+        EXPECT_EQ(node->sources(), std::vector<PlanNodePtr>{source_});
       };
 
   const auto node = PartitionedOutputNode::Builder()
@@ -553,7 +635,7 @@ TEST_F(PlanNodeBuilderTest, PartitionedOutputNode) {
                         .partitionFunctionSpec(partitionFunctionSpec)
                         .outputType(outputType)
                         .serdeKind(serdeKind)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -561,7 +643,7 @@ TEST_F(PlanNodeBuilderTest, PartitionedOutputNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, HashJoinNode) {
+TEST_F(PlanNodeBuilderTest, hashJoinNode) {
   const PlanNodeId id = "hash_join_node_id";
   const auto joinType = JoinType::kLeftSemiProject;
   const bool nullAware = true;
@@ -614,7 +696,7 @@ TEST_F(PlanNodeBuilderTest, HashJoinNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, MergeJoinNode) {
+TEST_F(PlanNodeBuilderTest, mergeJoinNode) {
   const PlanNodeId id = "merge_join_node_id";
   const auto joinType = JoinType::kInner;
   const std::vector<FieldAccessTypedExprPtr> leftKeys{
@@ -664,7 +746,7 @@ TEST_F(PlanNodeBuilderTest, MergeJoinNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, IndexLookupJoinNode) {
+TEST_F(PlanNodeBuilderTest, indexLookupJoinNode) {
   const PlanNodeId id = "index_lookup_join_node_id";
   const auto joinType = JoinType::kInner;
   const std::vector<FieldAccessTypedExprPtr> leftKeys{
@@ -674,8 +756,8 @@ TEST_F(PlanNodeBuilderTest, IndexLookupJoinNode) {
   const std::vector<IndexLookupConditionPtr> joinConditions{
       std::make_shared<BetweenIndexLookupCondition>(
           std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0"),
-          std::make_shared<ConstantTypedExpr>(BIGINT(), variant(1)),
-          std::make_shared<ConstantTypedExpr>(BIGINT(), variant(2)))};
+          std::make_shared<ConstantTypedExpr>(BIGINT(), Variant(1LL)),
+          std::make_shared<ConstantTypedExpr>(BIGINT(), Variant(2LL)))};
   const auto left =
       ValuesNode::Builder()
           .id("values_node_id_1")
@@ -686,9 +768,10 @@ TEST_F(PlanNodeBuilderTest, IndexLookupJoinNode) {
       TableScanNode::Builder()
           .id("values_node_id_2")
           .outputType(ROW({"c1"}, {VARCHAR()}))
-          .tableHandle(std::make_shared<TestConnectorTableHandleForLookupJoin>(
-              "connector_id"))
-          .assignments({{"c1", std::make_shared<connector::ColumnHandle>()}})
+          .tableHandle(
+              std::make_shared<TestConnectorTableHandleForLookupJoin>(
+                  "connector_id"))
+          .assignments({{"c1", std::make_shared<DummyColumnHandle>()}})
           .build();
   const auto outputType = ROW({"c0"}, {BIGINT()});
 
@@ -723,11 +806,11 @@ TEST_F(PlanNodeBuilderTest, IndexLookupJoinNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, NestedLoopJoinNode) {
+TEST_F(PlanNodeBuilderTest, nestedLoopJoinNode) {
   const PlanNodeId id = "nested_loop_join_node_id";
   const auto joinType = JoinType::kLeft;
   const auto joinCondition =
-      std::make_shared<ConstantTypedExpr>(BOOLEAN(), variant(true));
+      std::make_shared<ConstantTypedExpr>(BOOLEAN(), Variant(true));
   const auto left =
       ValuesNode::Builder()
           .id("values_node_id_1")
@@ -766,7 +849,7 @@ TEST_F(PlanNodeBuilderTest, NestedLoopJoinNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, OrderByNode) {
+TEST_F(PlanNodeBuilderTest, orderByNode) {
   const PlanNodeId id = "order_by_node_id";
   const std::vector<FieldAccessTypedExprPtr> sortingKeys{
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
@@ -779,7 +862,7 @@ TEST_F(PlanNodeBuilderTest, OrderByNode) {
     EXPECT_EQ(node->sortingOrders(), sortingOrders);
     EXPECT_EQ(node->isPartial(), isPartial);
     EXPECT_EQ(node->sources().size(), 1);
-    EXPECT_EQ(node->sources()[0], source);
+    EXPECT_EQ(node->sources()[0], source_);
   };
 
   const auto node = OrderByNode::Builder()
@@ -787,7 +870,7 @@ TEST_F(PlanNodeBuilderTest, OrderByNode) {
                         .sortingKeys(sortingKeys)
                         .sortingOrders(sortingOrders)
                         .isPartial(isPartial)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -795,7 +878,61 @@ TEST_F(PlanNodeBuilderTest, OrderByNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, TopNNode) {
+TEST_F(PlanNodeBuilderTest, spatialJoinNode) {
+  const PlanNodeId id = "spatial_join_node_id";
+  const auto joinType = JoinType::kInner;
+  const auto joinCondition =
+      std::make_shared<ConstantTypedExpr>(BOOLEAN(), Variant(true));
+  const auto left = ValuesNode::Builder()
+                        .id("values_node_id_1")
+                        .values({makeRowVector(
+                            {"c0", "g0"},
+                            {makeFlatVector<int64_t>(std::vector<int64_t>{1}),
+                             makeFlatVector<std::string>(
+                                 std::vector<std::string>{"POINT(0 0)"})})})
+                        .build();
+  const auto right = ValuesNode::Builder()
+                         .id("values_node_id_2")
+                         .values({makeRowVector(
+                             {"c1", "g1"},
+                             {makeFlatVector<int64_t>(std::vector<int64_t>{2}),
+                              makeFlatVector<std::string>(
+                                  std::vector<std::string>{"POINT(0 0)"})})})
+                         .build();
+  const auto outputType = ROW({"c0"}, {BIGINT()});
+  const auto probeGeom =
+      std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "g0");
+  const auto buildGeom =
+      std::make_shared<FieldAccessTypedExpr>(VARCHAR(), "g1");
+
+  const auto verify = [&](const std::shared_ptr<const SpatialJoinNode>& node) {
+    EXPECT_EQ(node->id(), id);
+    EXPECT_EQ(node->joinType(), joinType);
+    EXPECT_EQ(node->joinCondition(), joinCondition);
+    EXPECT_EQ(node->probeGeometry(), probeGeom);
+    EXPECT_EQ(node->buildGeometry(), buildGeom);
+    EXPECT_EQ(node->sources()[0], left);
+    EXPECT_EQ(node->sources()[1], right);
+    EXPECT_EQ(node->outputType(), outputType);
+  };
+
+  const auto node = SpatialJoinNode::Builder()
+                        .id(id)
+                        .joinType(joinType)
+                        .joinCondition(joinCondition)
+                        .left(left)
+                        .right(right)
+                        .probeGeometry(probeGeom)
+                        .buildGeometry(buildGeom)
+                        .outputType(outputType)
+                        .build();
+  verify(node);
+
+  const auto node2 = SpatialJoinNode::Builder(*node).build();
+  verify(node2);
+}
+
+TEST_F(PlanNodeBuilderTest, topNNode) {
   const PlanNodeId id = "topn_node_id";
   const std::vector<FieldAccessTypedExprPtr> sortingKeys{
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
@@ -810,7 +947,7 @@ TEST_F(PlanNodeBuilderTest, TopNNode) {
     EXPECT_EQ(node->count(), count);
     EXPECT_EQ(node->isPartial(), isPartial);
     EXPECT_EQ(node->sources().size(), 1);
-    EXPECT_EQ(node->sources()[0], source);
+    EXPECT_EQ(node->sources()[0], source_);
   };
 
   const auto node = TopNNode::Builder()
@@ -819,7 +956,7 @@ TEST_F(PlanNodeBuilderTest, TopNNode) {
                         .sortingOrders(sortingOrders)
                         .count(count)
                         .isPartial(isPartial)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -827,7 +964,7 @@ TEST_F(PlanNodeBuilderTest, TopNNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, LimitNode) {
+TEST_F(PlanNodeBuilderTest, limitNode) {
   const PlanNodeId id = "limit_node_id";
   const int64_t offset = 1;
   const int64_t count = 5;
@@ -839,7 +976,7 @@ TEST_F(PlanNodeBuilderTest, LimitNode) {
     EXPECT_EQ(node->count(), count);
     EXPECT_EQ(node->isPartial(), isPartial);
     EXPECT_EQ(node->sources().size(), 1);
-    EXPECT_EQ(node->sources()[0], source);
+    EXPECT_EQ(node->sources()[0], source_);
   };
 
   const auto node = LimitNode::Builder()
@@ -847,7 +984,7 @@ TEST_F(PlanNodeBuilderTest, LimitNode) {
                         .offset(offset)
                         .count(count)
                         .isPartial(isPartial)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -855,7 +992,7 @@ TEST_F(PlanNodeBuilderTest, LimitNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, UnnestNode) {
+TEST_F(PlanNodeBuilderTest, unnestNode) {
   const PlanNodeId id = "unnest_node_id";
   std::vector<FieldAccessTypedExprPtr> replicateVariables{
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a")};
@@ -869,8 +1006,8 @@ TEST_F(PlanNodeBuilderTest, UnnestNode) {
     EXPECT_EQ(node->id(), id);
     EXPECT_EQ(node->replicateVariables(), replicateVariables);
     EXPECT_EQ(node->unnestVariables(), unnestVariables);
-    EXPECT_TRUE(node->withOrdinality());
-    EXPECT_EQ(node->sources()[0], source);
+    EXPECT_TRUE(node->hasOrdinality());
+    EXPECT_EQ(node->sources()[0], source_);
 
     for (int i = 0; i < node->outputType()->size(); ++i) {
       if (i < replicateVariables.size()) {
@@ -892,7 +1029,7 @@ TEST_F(PlanNodeBuilderTest, UnnestNode) {
                         .unnestVariables(unnestVariables)
                         .unnestNames(unnestNames)
                         .ordinalityName(ordinalityName)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -900,25 +1037,25 @@ TEST_F(PlanNodeBuilderTest, UnnestNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, EnforceSingleRowNode) {
+TEST_F(PlanNodeBuilderTest, enforceSingleRowNode) {
   const PlanNodeId id = "enforce_single_row_id";
 
   const auto verify =
       [&](const std::shared_ptr<const EnforceSingleRowNode>& node) {
         EXPECT_EQ(node->id(), id);
         EXPECT_EQ(node->sources().size(), 1);
-        EXPECT_EQ(node->sources()[0], source);
+        EXPECT_EQ(node->sources()[0], source_);
       };
 
   const auto node =
-      EnforceSingleRowNode::Builder().id(id).source(source).build();
+      EnforceSingleRowNode::Builder().id(id).source(source_).build();
   verify(node);
 
   const auto node2 = EnforceSingleRowNode::Builder(*node).build();
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, AssignUniqueIdNode) {
+TEST_F(PlanNodeBuilderTest, assignUniqueIdNode) {
   const PlanNodeId id = "assign_unique_id_id";
   const std::string idName = "unique_id";
   const int32_t taskUniqueId = 42;
@@ -929,14 +1066,14 @@ TEST_F(PlanNodeBuilderTest, AssignUniqueIdNode) {
         EXPECT_EQ(node->outputType()->names().back(), idName);
         EXPECT_EQ(node->taskUniqueId(), taskUniqueId);
         EXPECT_EQ(node->sources().size(), 1);
-        EXPECT_EQ(node->sources()[0], source);
+        EXPECT_EQ(node->sources()[0], source_);
       };
 
   const auto node = AssignUniqueIdNode::Builder()
                         .id(id)
                         .idName(idName)
                         .taskUniqueId(taskUniqueId)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -944,7 +1081,7 @@ TEST_F(PlanNodeBuilderTest, AssignUniqueIdNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, WindowNode) {
+TEST_F(PlanNodeBuilderTest, windowNode) {
   const PlanNodeId id = "window_node_id";
   const std::vector<FieldAccessTypedExprPtr> partitionKeys{
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a")};
@@ -955,8 +1092,7 @@ TEST_F(PlanNodeBuilderTest, WindowNode) {
   const bool inputsSorted = true;
 
   // Create a dummy window function.
-  const auto functionCall = std::make_shared<CallTypedExpr>(
-      BIGINT(), std::vector<TypedExprPtr>{}, "rank");
+  const auto functionCall = std::make_shared<CallTypedExpr>(BIGINT(), "rank");
   WindowNode::Frame frame{
       WindowNode::WindowType::kRows,
       WindowNode::BoundType::kUnboundedPreceding,
@@ -975,13 +1111,13 @@ TEST_F(PlanNodeBuilderTest, WindowNode) {
 
     EXPECT_EQ(
         node->outputType()->size(),
-        source->outputType()->size() + windowColumnNames.size());
-    for (size_t i = source->outputType()->size();
+        source_->outputType()->size() + windowColumnNames.size());
+    for (size_t i = source_->outputType()->size();
          i < node->outputType()->size();
          ++i) {
       EXPECT_EQ(
           node->outputType()->nameOf(i),
-          windowColumnNames[i - source->outputType()->size()]);
+          windowColumnNames[i - source_->outputType()->size()]);
     }
 
     EXPECT_EQ(node->windowFunctions().size(), 1);
@@ -989,7 +1125,7 @@ TEST_F(PlanNodeBuilderTest, WindowNode) {
         node->windowFunctions()[0].serialize(), windowFunctions[0].serialize());
     EXPECT_EQ(node->inputsSorted(), inputsSorted);
     EXPECT_EQ(node->sources().size(), 1);
-    EXPECT_EQ(node->sources()[0], source);
+    EXPECT_EQ(node->sources()[0], source_);
   };
 
   const auto node = WindowNode::Builder()
@@ -1000,7 +1136,7 @@ TEST_F(PlanNodeBuilderTest, WindowNode) {
                         .windowColumnNames(windowColumnNames)
                         .windowFunctions(windowFunctions)
                         .inputsSorted(inputsSorted)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -1008,7 +1144,7 @@ TEST_F(PlanNodeBuilderTest, WindowNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, RowNumberNode) {
+TEST_F(PlanNodeBuilderTest, rowNumberNode) {
   const PlanNodeId id = "row_number_node_id";
   const std::vector<FieldAccessTypedExprPtr> partitionKeys{
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
@@ -1021,7 +1157,7 @@ TEST_F(PlanNodeBuilderTest, RowNumberNode) {
     EXPECT_EQ(node->limit(), limit);
     EXPECT_TRUE(node->generateRowNumber());
     EXPECT_EQ(node->outputType()->names().back(), rowNumberColumnName);
-    EXPECT_EQ(node->sources()[0], source);
+    EXPECT_EQ(node->sources()[0], source_);
   };
 
   const auto node = RowNumberNode::Builder()
@@ -1029,7 +1165,7 @@ TEST_F(PlanNodeBuilderTest, RowNumberNode) {
                         .partitionKeys(partitionKeys)
                         .rowNumberColumnName(rowNumberColumnName)
                         .limit(limit)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -1037,7 +1173,7 @@ TEST_F(PlanNodeBuilderTest, RowNumberNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, MarkDistinctNode) {
+TEST_F(PlanNodeBuilderTest, markDistinctNode) {
   const PlanNodeId id = "mark_distinct_node_id";
   const std::string markerName = "is_distinct";
   const std::vector<FieldAccessTypedExprPtr> distinctKeys{
@@ -1048,14 +1184,14 @@ TEST_F(PlanNodeBuilderTest, MarkDistinctNode) {
     EXPECT_EQ(node->markerName(), markerName);
     EXPECT_EQ(node->distinctKeys(), distinctKeys);
     EXPECT_EQ(node->sources().size(), 1);
-    EXPECT_EQ(node->sources()[0], source);
+    EXPECT_EQ(node->sources()[0], source_);
   };
 
   const auto node = MarkDistinctNode::Builder()
                         .id(id)
                         .markerName(markerName)
                         .distinctKeys(distinctKeys)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
@@ -1063,7 +1199,7 @@ TEST_F(PlanNodeBuilderTest, MarkDistinctNode) {
   verify(node2);
 }
 
-TEST_F(PlanNodeBuilderTest, TopNRowNumberNode) {
+TEST_F(PlanNodeBuilderTest, topNRowNumberNode) {
   const PlanNodeId id = "topn_row_number_node_id";
   const std::vector<FieldAccessTypedExprPtr> partitionKeys{
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
@@ -1083,7 +1219,7 @@ TEST_F(PlanNodeBuilderTest, TopNRowNumberNode) {
         EXPECT_TRUE(node->generateRowNumber());
         EXPECT_EQ(node->outputType()->names().back(), rowNumberColumnName);
         EXPECT_EQ(node->sources().size(), 1);
-        EXPECT_EQ(node->sources()[0], source);
+        EXPECT_EQ(node->sources()[0], source_);
       };
 
   const auto node = TopNRowNumberNode::Builder()
@@ -1093,7 +1229,7 @@ TEST_F(PlanNodeBuilderTest, TopNRowNumberNode) {
                         .sortingOrders(sortingOrders)
                         .rowNumberColumnName(rowNumberColumnName)
                         .limit(limit)
-                        .source(source)
+                        .source(source_)
                         .build();
   verify(node);
 
diff --git a/velox/core/tests/PlanNodeTest.cpp b/velox/core/tests/PlanNodeTest.cpp
index b1026300c0dd..fa39d0927d90 100644
--- a/velox/core/tests/PlanNodeTest.cpp
+++ b/velox/core/tests/PlanNodeTest.cpp
@@ -46,8 +46,7 @@ TEST_F(PlanNodeTest, findFirstNode) {
   auto rowType = ROW({"name1"}, {BIGINT()});
 
   std::shared_ptr<connector::ConnectorTableHandle> tableHandle;
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
 
   std::shared_ptr<PlanNode> tableScan3 =
       std::make_shared<TableScanNode>("3", rowType, tableHandle, assignments);
@@ -86,6 +85,55 @@ TEST_F(PlanNodeTest, findFirstNode) {
       }));
 }
 
+TEST_F(PlanNodeTest, findNodeById) {
+  auto values = std::make_shared<ValuesNode>("1", std::vector<RowVectorPtr>{});
+  auto project = std::make_shared<ProjectNode>(
+      "2",
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{
+          std::make_shared<CallTypedExpr>(DOUBLE(), "rand"),
+          std::make_shared<CallTypedExpr>(DOUBLE(), "rand"),
+      },
+      values);
+
+  auto filter = std::make_shared<FilterNode>(
+      "3",
+      std::make_shared<CallTypedExpr>(
+          BOOLEAN(),
+          "gt",
+          std::make_shared<FieldAccessTypedExpr>(DOUBLE(), "a"),
+          std::make_shared<ConstantTypedExpr>(DOUBLE(), 0.5)),
+      project);
+
+  auto limit = std::make_shared<LimitNode>("4", 0, 10, false, filter);
+
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "1"), values.get());
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "2"), project.get());
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "3"), filter.get());
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "4"), limit.get());
+
+  ASSERT_EQ(PlanNode::findNodeById(limit.get(), "5"), nullptr);
+  ASSERT_EQ(PlanNode::findNodeById(project.get(), "4"), nullptr);
+}
+
+TEST_F(PlanNodeTest, is) {
+  auto values = std::make_shared<ValuesNode>("1", std::vector<RowVectorPtr>{});
+  auto project = std::make_shared<ProjectNode>(
+      "2",
+      std::vector<std::string>{"a", "b"},
+      std::vector<TypedExprPtr>{
+          std::make_shared<CallTypedExpr>(DOUBLE(), "rand"),
+          std::make_shared<CallTypedExpr>(DOUBLE(), "rand"),
+      },
+      values);
+
+  ASSERT_TRUE(values->is<ValuesNode>());
+  ASSERT_FALSE(values->is<ProjectNode>());
+
+  ASSERT_FALSE(project->is<ValuesNode>());
+  ASSERT_TRUE(project->is<ProjectNode>());
+}
+
 TEST_F(PlanNodeTest, sortOrder) {
   struct {
     SortOrder order1;
@@ -133,6 +181,7 @@ TEST_F(PlanNodeTest, duplicateSortKeys) {
           "orderBy", sortingKeys, sortingOrders, false, nullptr),
       "Duplicate sorting keys are not allowed: c0");
 }
+
 class TestIndexTableHandle : public connector::ConnectorTableHandle {
  public:
   TestIndexTableHandle()
@@ -164,7 +213,7 @@ class TestIndexTableHandle : public connector::ConnectorTableHandle {
   }
 };
 
-TEST_F(PlanNodeTest, isIndexLookupJoin) {
+TEST_F(PlanNodeTest, indexLookupJoin) {
   const auto rowType = ROW({"name"}, {BIGINT()});
   const auto valueNode = std::make_shared<ValuesNode>("orderBy", rowData_);
   ASSERT_FALSE(isIndexLookupJoin(valueNode.get()));
@@ -174,34 +223,326 @@ TEST_F(PlanNodeTest, isIndexLookupJoin) {
   const RowTypePtr outputType = ROW({"c0", "c1"}, {BIGINT(), BIGINT()});
   auto indexTableHandle = std::make_shared<TestIndexTableHandle>();
   const auto probeNode = std::make_shared<TableScanNode>(
-      "tableScan-probe",
-      probeType,
-      nullptr,
-      std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>{});
+      "tableScan-probe", probeType, nullptr, connector::ColumnHandleMap{});
   ASSERT_FALSE(isIndexLookupJoin(probeNode.get()));
   const auto buildNode = std::make_shared<TableScanNode>(
       "tableScan-build",
       buildType,
       indexTableHandle,
-      std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>{});
+      connector::ColumnHandleMap{});
   ASSERT_FALSE(isIndexLookupJoin(buildNode.get()));
   const std::vector<FieldAccessTypedExprPtr> leftKeys{
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
   const std::vector<FieldAccessTypedExprPtr> rightKeys{
       std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c1")};
-  const auto indexJoinNode = std::make_shared<IndexLookupJoinNode>(
-      "indexJoinNode",
-      core::JoinType::kInner,
-      leftKeys,
-      rightKeys,
-      std::vector<IndexLookupConditionPtr>{},
-      probeNode,
-      buildNode,
-      outputType);
-  ASSERT_TRUE(isIndexLookupJoin(indexJoinNode.get()));
+  {
+    const auto indexJoinNodeWithInnerJoin =
+        std::make_shared<IndexLookupJoinNode>(
+            "indexJoinNode",
+            core::JoinType::kInner,
+            leftKeys,
+            rightKeys,
+            std::vector<IndexLookupConditionPtr>{},
+            /*filter=*/nullptr,
+            /*hasMarker=*/false,
+            probeNode,
+            buildNode,
+            outputType);
+    ASSERT_TRUE(isIndexLookupJoin(indexJoinNodeWithInnerJoin.get()));
+    ASSERT_FALSE(indexJoinNodeWithInnerJoin->hasMarker());
+    ASSERT_EQ(indexJoinNodeWithInnerJoin->filter(), nullptr);
+    ASSERT_EQ(
+        indexJoinNodeWithInnerJoin->toString(/*detailed=*/true),
+        "-- IndexLookupJoin[indexJoinNode][INNER c0=c1] -> c0:BIGINT, c1:BIGINT\n");
+  }
+  {
+    const RowTypePtr outputTypeWithMatchColumn =
+        ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), BOOLEAN()});
+    const auto indexJoinNodeWithLeftJoin =
+        std::make_shared<IndexLookupJoinNode>(
+            "indexJoinNode",
+            core::JoinType::kLeft,
+            leftKeys,
+            rightKeys,
+            std::vector<IndexLookupConditionPtr>{},
+            /*filter=*/nullptr,
+            /*hasMarker=*/true,
+            probeNode,
+            buildNode,
+            outputTypeWithMatchColumn);
+    ASSERT_TRUE(isIndexLookupJoin(indexJoinNodeWithLeftJoin.get()));
+    ASSERT_TRUE(indexJoinNodeWithLeftJoin->hasMarker());
+    ASSERT_EQ(indexJoinNodeWithLeftJoin->filter(), nullptr);
+    ASSERT_EQ(
+        indexJoinNodeWithLeftJoin->toString(/*detailed=*/true),
+        "-- IndexLookupJoin[indexJoinNode][LEFT c0=c1] -> c0:BIGINT, c1:BIGINT, c2:BOOLEAN\n");
+  }
+  {
+    // Test IndexLookupJoinNode with filter
+    const auto filterExpr = std::make_shared<core::FieldAccessTypedExpr>(
+        BOOLEAN(), "filter_column");
+    const auto indexJoinNodeWithFilter = std::make_shared<IndexLookupJoinNode>(
+        "indexJoinNodeWithFilter",
+        core::JoinType::kInner,
+        leftKeys,
+        rightKeys,
+        std::vector<IndexLookupConditionPtr>{},
+        /*filter=*/filterExpr,
+        /*hasMarker=*/false,
+        probeNode,
+        buildNode,
+        outputType);
+    ASSERT_TRUE(isIndexLookupJoin(indexJoinNodeWithFilter.get()));
+    ASSERT_FALSE(indexJoinNodeWithFilter->hasMarker());
+    ASSERT_EQ(indexJoinNodeWithFilter->filter(), filterExpr);
+    ASSERT_EQ(
+        indexJoinNodeWithFilter->toString(/*detailed=*/true),
+        "-- IndexLookupJoin[indexJoinNodeWithFilter][INNER c0=c1, filter: \"filter_column\"] -> c0:BIGINT, c1:BIGINT\n");
+  }
+  // Error case.
+  {
+    VELOX_ASSERT_THROW(
+        std::make_shared<IndexLookupJoinNode>(
+            "indexJoinNode",
+            core::JoinType::kInner,
+            leftKeys,
+            rightKeys,
+            std::vector<IndexLookupConditionPtr>{},
+            /*filter=*/nullptr,
+            /*hasMarker=*/true,
+            probeNode,
+            buildNode,
+            outputType),
+        "Index join match column can only present for LEFT but not INNER");
+  }
+  {
+    VELOX_ASSERT_THROW(
+        std::make_shared<IndexLookupJoinNode>(
+            "indexJoinNode",
+            core::JoinType::kLeft,
+            leftKeys,
+            rightKeys,
+            std::vector<IndexLookupConditionPtr>{},
+            /*filter=*/nullptr,
+            /*hasMarker=*/true,
+            probeNode,
+            buildNode,
+            outputType),
+        "The last output column must be boolean type if match column is present");
+  }
+  {
+    const RowTypePtr outputTypeWithDuplicateMatchColumn =
+        ROW({"c0", "c1", "c0"}, {BIGINT(), BIGINT(), BOOLEAN()});
+    VELOX_ASSERT_THROW(
+        std::make_shared<IndexLookupJoinNode>(
+            "indexJoinNode",
+            core::JoinType::kLeft,
+            leftKeys,
+            rightKeys,
+            std::vector<IndexLookupConditionPtr>{},
+            /*filter=*/nullptr,
+            /*hasMarker=*/true,
+            probeNode,
+            buildNode,
+            outputTypeWithDuplicateMatchColumn),
+        "");
+  }
+}
+
+TEST_F(PlanNodeTest, partitionedOutputNode) {
+  const PlanNodeId id{"partitionedOutputNode"};
+  const PartitionedOutputNode::Kind kind =
+      PartitionedOutputNode::Kind::kPartitioned;
+  const std::vector<TypedExprPtr> keys = {
+      std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
+  const PartitionFunctionSpecPtr partitionFunctionSpec =
+      std::make_shared<GatherPartitionFunctionSpec>();
+  const VectorSerde::Kind serdeKind = VectorSerde::Kind::kPresto;
+  PlanNodePtr source = std::make_shared<ValuesNode>("source", rowData_);
+
+  {
+    // Creating a PartitionedOutputNode with a single partition, empty keys, and
+    // a null partition function should succeed.
+    PartitionedOutputNode node(
+        id,
+        kind,
+        {},
+        1, // numPartitions
+        true, // replicateNullsAndAny
+        nullptr, // partitionFunctionSpec
+        rowType_,
+        serdeKind,
+        source);
+    // Attempting to dereference the nullptr should fail.
+    ASSERT_EQ(node.partitionFunctionSpecPtr(), nullptr);
+    VELOX_ASSERT_THROW(node.partitionFunctionSpec(), "");
+  }
+
+  // Creating a PartitionedOutputNode that is not partitioned and has empty keys
+  // and a partition function (even kinds other than partitioned still use a
+  // partition function) should succeed.
+  {
+    PartitionedOutputNode node(
+        id,
+        PartitionedOutputNode::Kind::kArbitrary,
+        {},
+        10, // numPartitions
+        true, // replicateNullsAndAny
+        partitionFunctionSpec,
+        rowType_,
+        serdeKind,
+        source);
+    // We should be able to dereference the partition function spec.
+    ASSERT_EQ(node.partitionFunctionSpecPtr(), partitionFunctionSpec);
+    ASSERT_EQ(
+        node.partitionFunctionSpec().toString(),
+        partitionFunctionSpec->toString());
+  }
+
+  // Creating a PartitionedOutputNode with numPartitions = 0 should throw.
+  VELOX_ASSERT_THROW(
+      PartitionedOutputNode(
+          id,
+          kind,
+          keys,
+          0, // numPartitions
+          true, // replicateNullsAndAny
+          partitionFunctionSpec,
+          rowType_,
+          serdeKind,
+          source),
+      "");
+
+  // Creating a PartitionedOutputNode with numPartitions = 1 and non-empty
+  // keys should throw.
+  VELOX_ASSERT_THROW(
+      PartitionedOutputNode(
+          id,
+          kind,
+          keys,
+          1, // numPartitions
+          true, // replicateNullsAndAny
+          partitionFunctionSpec,
+          rowType_,
+          serdeKind,
+          source),
+      "Non-empty partitioning keys require more than one partition");
+
+  // Creating a PartitionedOutputNode with numPartitions > 1 and no partition
+  // function should throw.
+  VELOX_ASSERT_THROW(
+      PartitionedOutputNode(
+          id,
+          kind,
+          keys,
+          5, // numPartitions
+          true, // replicateNullsAndAny
+          nullptr, // partitionFunctionSpec
+          rowType_,
+          serdeKind,
+          source),
+      "Partition function spec must be specified when the number of destinations is more than 1.");
+
+  // Creating a PartitionedOutputNode that is not partitioned with non-empty
+  // keys should throw.
+  VELOX_ASSERT_THROW(
+      PartitionedOutputNode(
+          id,
+          PartitionedOutputNode::Kind::kArbitrary,
+          keys,
+          5, // numPartitions
+          true, // replicateNullsAndAny
+          partitionFunctionSpec,
+          rowType_,
+          serdeKind,
+          source),
+      "partitioning doesn't allow for partitioning keys");
+}
+
+TEST_F(PlanNodeTest, aggregationNodeNoGroupsSpanBatches) {
+  auto values = std::make_shared<ValuesNode>("values", rowData_);
+
+  const std::vector<FieldAccessTypedExprPtr> groupingKeys{
+      std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
+  const std::vector<FieldAccessTypedExprPtr> preGroupedKeys{
+      std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c0")};
+  const std::vector<std::string> aggregateNames{"sum"};
+  const std::vector<AggregationNode::Aggregate> aggregates{
+      {.call = std::make_shared<CallTypedExpr>(BIGINT(), "sum"),
+       .rawInputTypes = {BIGINT()}}};
+
+  // noGroupsSpanBatches=true with preGroupedKeys (streaming aggregation) should
+  // succeed and the accessor should return true.
+  {
+    auto aggNode = std::make_shared<AggregationNode>(
+        "agg",
+        AggregationNode::Step::kSingle,
+        groupingKeys,
+        preGroupedKeys,
+        aggregateNames,
+        aggregates,
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/true,
+        values);
+    ASSERT_TRUE(aggNode->noGroupsSpanBatches());
+    ASSERT_TRUE(aggNode->isPreGrouped());
+    ASSERT_EQ(
+        aggNode->toString(true),
+        "-- Aggregation[agg][SINGLE STREAMING [c0] sum := sum() noGroupsSpanBatches] -> c0:BIGINT, sum:BIGINT\n");
+  }
+
+  // noGroupsSpanBatches=false with preGroupedKeys should succeed and the
+  // accessor should return false.
+  {
+    auto aggNode = std::make_shared<AggregationNode>(
+        "agg",
+        AggregationNode::Step::kSingle,
+        groupingKeys,
+        preGroupedKeys,
+        aggregateNames,
+        aggregates,
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        values);
+    ASSERT_FALSE(aggNode->noGroupsSpanBatches());
+    ASSERT_TRUE(aggNode->isPreGrouped());
+    ASSERT_EQ(
+        aggNode->toString(true),
+        "-- Aggregation[agg][SINGLE STREAMING [c0] sum := sum()] -> c0:BIGINT, sum:BIGINT\n");
+  }
+
+  // noGroupsSpanBatches=true without preGroupedKeys (non-streaming aggregation)
+  // should fail.
+  VELOX_ASSERT_THROW(
+      std::make_shared<AggregationNode>(
+          "agg",
+          AggregationNode::Step::kSingle,
+          groupingKeys,
+          /*preGroupedKeys=*/std::vector<FieldAccessTypedExprPtr>{},
+          aggregateNames,
+          aggregates,
+          /*ignoreNullKeys=*/false,
+          /*noGroupsSpanBatches=*/true,
+          values),
+      "noGroupsSpanBatches can only be set for streaming aggregation (pre-grouped)");
+
+  // noGroupsSpanBatches=false without preGroupedKeys should succeed.
+  {
+    auto aggNode = std::make_shared<AggregationNode>(
+        "agg",
+        AggregationNode::Step::kSingle,
+        groupingKeys,
+        /*preGroupedKeys=*/std::vector<FieldAccessTypedExprPtr>{},
+        aggregateNames,
+        aggregates,
+        /*ignoreNullKeys=*/false,
+        /*noGroupsSpanBatches=*/false,
+        values);
+    ASSERT_FALSE(aggNode->noGroupsSpanBatches());
+    ASSERT_FALSE(aggNode->isPreGrouped());
+    ASSERT_EQ(
+        aggNode->toString(true),
+        "-- Aggregation[agg][SINGLE [c0] sum := sum()] -> c0:BIGINT, sum:BIGINT\n");
+  }
 }
 } // namespace
diff --git a/velox/core/tests/QueryConfigTest.cpp b/velox/core/tests/QueryConfigTest.cpp
index 599c1ce65338..8dec2d31aea6 100644
--- a/velox/core/tests/QueryConfigTest.cpp
+++ b/velox/core/tests/QueryConfigTest.cpp
@@ -33,6 +33,7 @@ TEST_F(QueryConfigTest, emptyConfig) {
   const QueryConfig& config = queryCtx->queryConfig();
 
   ASSERT_FALSE(config.isLegacyCast());
+  EXPECT_EQ(config.maxNumSplitsListenedTo(), 0);
 }
 
 TEST_F(QueryConfigTest, setConfig) {
@@ -204,4 +205,79 @@ TEST_F(QueryConfigTest, expressionEvaluationRelatedConfigs) {
   testConfig(createConfig(false, false, false, true));
 }
 
+TEST_F(QueryConfigTest, sessionStartTime) {
+  // Test with no session start time set
+  {
+    auto queryCtx = QueryCtx::create(nullptr, QueryConfig{{}});
+    const QueryConfig& config = queryCtx->queryConfig();
+
+    EXPECT_EQ(config.sessionStartTimeMs(), 0);
+  }
+
+  // Test with session start time set
+  {
+    int64_t startTimeMs = 1674123456789; // Some timestamp in milliseconds
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSessionStartTime, std::to_string(startTimeMs)}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+
+    EXPECT_EQ(config.sessionStartTimeMs(), startTimeMs);
+  }
+
+  // Test with negative session start time (should be valid)
+  {
+    int64_t negativeStartTime = -1000;
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSessionStartTime, std::to_string(negativeStartTime)}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+
+    EXPECT_EQ(config.sessionStartTimeMs(), negativeStartTime);
+  }
+
+  // Test with maximum int64_t value
+  {
+    int64_t maxTime = std::numeric_limits<int64_t>::max();
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSessionStartTime, std::to_string(maxTime)}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+
+    EXPECT_EQ(config.sessionStartTimeMs(), maxTime);
+  }
+}
+
+TEST_F(QueryConfigTest, singleSourceExchangeOptimizationConfig) {
+  // Test default value (should be false)
+  {
+    auto queryCtx = QueryCtx::create(nullptr, QueryConfig{{}});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_FALSE(config.singleSourceExchangeOptimizationEnabled());
+  }
+
+  // Test with optimization enabled
+  {
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSkipRequestDataSizeWithSingleSourceEnabled, "true"}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_TRUE(config.singleSourceExchangeOptimizationEnabled());
+  }
+
+  // Test with optimization explicitly disabled
+  {
+    std::unordered_map<std::string, std::string> configData(
+        {{QueryConfig::kSkipRequestDataSizeWithSingleSourceEnabled, "false"}});
+    auto queryCtx =
+        QueryCtx::create(nullptr, QueryConfig{std::move(configData)});
+    const QueryConfig& config = queryCtx->queryConfig();
+    EXPECT_FALSE(config.singleSourceExchangeOptimizationEnabled());
+  }
+}
+
 } // namespace facebook::velox::core::test
diff --git a/velox/core/tests/QueryCtxTest.cpp b/velox/core/tests/QueryCtxTest.cpp
new file mode 100644
index 000000000000..44dbc5927c47
--- /dev/null
+++ b/velox/core/tests/QueryCtxTest.cpp
@@ -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.
+ */
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/QueryCtx.h"
+
+namespace facebook::velox::core::test {
+
+class QueryCtxTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+};
+
+TEST_F(QueryCtxTest, withSysRootPool) {
+  auto queryCtx = QueryCtx::create(
+      nullptr,
+      QueryConfig{{}},
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      nullptr,
+      memory::deprecatedRootPool().shared_from_this());
+  auto* queryPool = queryCtx->pool();
+  ASSERT_EQ(&memory::deprecatedRootPool(), queryPool);
+  ASSERT_NE(queryPool->reclaimer(), nullptr);
+  try {
+    VELOX_FAIL("Trigger Error");
+  } catch (const velox::VeloxRuntimeError&) {
+    VELOX_ASSERT_THROW(
+        queryPool->reclaimer()->abort(queryPool, std::current_exception()),
+        "SysMemoryReclaimer::abort is not supported");
+  }
+  ASSERT_EQ(queryPool->reclaimer()->priority(), 0);
+  memory::MemoryReclaimer::Stats stats;
+  ASSERT_EQ(queryPool->reclaimer()->reclaim(queryPool, 1'000, 1'000, stats), 0);
+  uint64_t reclaimableBytes{0};
+  ASSERT_FALSE(
+      queryPool->reclaimer()->reclaimableBytes(*queryPool, reclaimableBytes));
+}
+
+TEST_F(QueryCtxTest, releaseCallbacks) {
+  int callbackCount = 0;
+  std::string capturedQueryId;
+
+  {
+    auto queryCtx = QueryCtx::create(
+        nullptr,
+        QueryConfig{{}},
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+        nullptr,
+        nullptr,
+        nullptr,
+        "test_query_id");
+
+    // Add multiple callbacks.
+    queryCtx->addReleaseCallback([&callbackCount]() { ++callbackCount; });
+
+    queryCtx->addReleaseCallback(
+        [&callbackCount, &capturedQueryId, id = queryCtx->queryId()]() {
+          ++callbackCount;
+          capturedQueryId = id;
+        });
+
+    // Callbacks should not be invoked yet.
+    ASSERT_EQ(callbackCount, 0);
+  }
+
+  // After QueryCtx destruction, all callbacks should have been invoked.
+  ASSERT_EQ(callbackCount, 2);
+  ASSERT_EQ(capturedQueryId, "test_query_id");
+}
+
+TEST_F(QueryCtxTest, releaseCallbackException) {
+  int callbackCount = 0;
+
+  {
+    auto queryCtx = QueryCtx::create(
+        nullptr,
+        QueryConfig{{}},
+        std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+        nullptr,
+        nullptr,
+        nullptr,
+        "test_query_id");
+
+    // First callback succeeds.
+    queryCtx->addReleaseCallback([&callbackCount]() { ++callbackCount; });
+
+    // Second callback throws an exception.
+    queryCtx->addReleaseCallback(
+        []() { throw std::runtime_error("Test exception"); });
+
+    // Third callback should still execute despite the previous exception.
+    queryCtx->addReleaseCallback([&callbackCount]() { ++callbackCount; });
+  }
+
+  // All callbacks should have been attempted, with exception caught and logged.
+  // First and third callbacks should have incremented the counter.
+  ASSERT_EQ(callbackCount, 2);
+}
+
+TEST_F(QueryCtxTest, builderReleaseCallbacks) {
+  int callbackCount = 0;
+  std::string capturedQueryId;
+
+  {
+    // Use builder to add release callbacks during construction.
+    auto queryCtx =
+        QueryCtx::Builder()
+            .queryId("builder_test_query_id")
+            .releaseCallback([&callbackCount]() { ++callbackCount; })
+            .releaseCallback([&callbackCount, &capturedQueryId]() {
+              ++callbackCount;
+              capturedQueryId = "builder_test_query_id";
+            })
+            .build();
+
+    // Callbacks should not be invoked yet.
+    ASSERT_EQ(callbackCount, 0);
+  }
+
+  // After QueryCtx destruction, all callbacks should have been invoked.
+  ASSERT_EQ(callbackCount, 2);
+  ASSERT_EQ(capturedQueryId, "builder_test_query_id");
+}
+} // namespace facebook::velox::core::test
diff --git a/velox/core/tests/TypedExprSerdeTest.cpp b/velox/core/tests/TypedExprSerdeTest.cpp
index b49e36222140..62c6ae93006e 100644
--- a/velox/core/tests/TypedExprSerdeTest.cpp
+++ b/velox/core/tests/TypedExprSerdeTest.cpp
@@ -87,33 +87,25 @@ TEST_F(TypedExprSerDeTest, call) {
   // a + b
   auto expression = std::make_shared<CallTypedExpr>(
       BIGINT(),
-      std::vector<TypedExprPtr>{
-          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a"),
-          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "b"),
-      },
-      "plus");
+      "plus",
+      std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a"),
+      std::make_shared<FieldAccessTypedExpr>(BIGINT(), "b"));
 
   testSerde(expression);
 
   // f(g(h(a, b), c))
   expression = std::make_shared<CallTypedExpr>(
       VARCHAR(),
-      std::vector<TypedExprPtr>{
+      "f",
+      std::make_shared<CallTypedExpr>(
+          DOUBLE(),
+          "g",
           std::make_shared<CallTypedExpr>(
-              DOUBLE(),
-              std::vector<TypedExprPtr>{
-                  std::make_shared<CallTypedExpr>(
-                      BIGINT(),
-                      std::vector<TypedExprPtr>{
-                          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a"),
-                          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "b"),
-                      },
-                      "h"),
-                  std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c"),
-              },
-              "g"),
-      },
-      "f");
+              BIGINT(),
+              "h",
+              std::make_shared<FieldAccessTypedExpr>(BIGINT(), "a"),
+              std::make_shared<FieldAccessTypedExpr>(BIGINT(), "b")),
+          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "c")));
   testSerde(expression);
 }
 
@@ -144,13 +136,11 @@ TEST_F(TypedExprSerDeTest, lambda) {
       ROW({"x"}, {BIGINT()}),
       std::make_shared<CallTypedExpr>(
           BOOLEAN(),
-          std::vector<TypedExprPtr>{
-              std::make_shared<FieldAccessTypedExpr>(BIGINT(), "x"),
-              std::make_shared<ConstantTypedExpr>(makeArrayVector<int64_t>({
-                  {1, 2, 3, 4, 5},
-              })),
-          },
-          "in"));
+          "in",
+          std::make_shared<FieldAccessTypedExpr>(BIGINT(), "x"),
+          std::make_shared<ConstantTypedExpr>(makeArrayVector<int64_t>({
+              {1, 2, 3, 4, 5},
+          }))));
   testSerde(expression);
 }
 
diff --git a/velox/docs/conf.py b/velox/docs/conf.py
index d9dd62e7450b..a87507e85dae 100644
--- a/velox/docs/conf.py
+++ b/velox/docs/conf.py
@@ -50,6 +50,8 @@
     "issue",
     "pr",
     "spark",
+    "iceberg",
+    "delta",
     "sphinx.ext.autodoc",
     "sphinx.ext.doctest",
     "sphinx.ext.mathjax",
diff --git a/velox/docs/configs.rst b/velox/docs/configs.rst
index aee9aa327981..ba71a407a65c 100644
--- a/velox/docs/configs.rst
+++ b/velox/docs/configs.rst
@@ -43,6 +43,16 @@ Generic Configuration
      - integer
      - 80
      - Abandons partial TopNRowNumber if number of output rows equals or exceeds this percentage of the number of input rows.
+   * - abandon_dedup_hashmap_min_rows
+     - integer
+     - 100,000
+     - Number of input rows to receive before starting to check whether to abandon building a HashTable without
+       duplicates in HashBuild for left semi/anti join.
+   * - abandon_dedup_hashmap_min_pct
+     - integer
+     - 0
+     - Abandons building a HashTable without duplicates in HashBuild for left semi/anti join if the percentage of
+       distinct keys in the HashTable exceeds this threshold. Zero means 'disable this optimization'.
    * - session_timezone
      - string
      -
@@ -60,6 +70,11 @@ Generic Configuration
      - true
      - Whether to track CPU usage for stages of individual operators. Can be expensive when processing small batches,
        e.g. < 10K rows.
+   * - operator_batch_size_stats_enabled
+     - bool
+     - true
+     - If true, the driver will collect the operator's input/output batch size through vector flat size estimation, otherwise not.
+       We might turn this off in use cases which have very wide column width and batch size estimation has non-trivial cpu cost.
    * - hash_adaptivity_enabled
      - bool
      - true
@@ -68,6 +83,11 @@ Generic Configuration
      - bool
      - true
      - If true, the conjunction expression can reorder inputs based on the time taken to calculate them.
+   * - parallel_join_build_rows_enabled
+     - bool
+     - false
+     - If true, the hash probe drivers can output build-side rows in parallel for full and right joins (only when spilling is not
+     - enabled by hash probe). If false, only the last prober is allowed to output build-side rows.
    * - max_local_exchange_buffer_size
      - integer
      - 32MB
@@ -101,6 +121,16 @@ Generic Configuration
        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.
+   * - skip_request_data_size_with_single_source_enabled
+     - bool
+     - false
+     -  If true, skip request data size if there is only single source.
+        This is used to optimize the Presto-on-Spark use case where each exchange client
+        has only one shuffle partition source.
+   * - local_merge_source_queue_size
+     - integer
+     - 2
+     - Maximum number of vectors buffered in each local merge source before blocking to wait for consumers.
    * - max_page_partitioning_buffer_size
      - integer
      - 32MB
@@ -117,6 +147,17 @@ Generic Configuration
      - integer
      - 1000
      - The minimum number of table rows that can trigger the parallel hash join table build.
+   * - hash_probe_dynamic_filter_pushdown_enabled
+     - bool
+     - true
+     - Whether hash probe can generate any dynamic filter (including Bloom filter) and push down to upstream operators.
+   * - hash_probe_bloom_filter_pushdown_max_size
+     - integer
+     - 0
+     - The maximum byte size of Bloom filter that can be generated from hash
+       probe.  When set to 0, no Bloom filter will be generated.  To achieve
+       optimal performance, this should not be too larger than the CPU cache
+       size on the host.
    * - debug.validate_output_from_operators
      - bool
      - false
@@ -139,6 +180,12 @@ Generic Configuration
      - 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.
+   * - window_num_sub_partitions
+     - integer
+     - 1
+     - Window operator can be configured to sub-divide window partitions on each thread of execution into groups of
+       sub partitions for sequential processing. This setting specifies how many sub-partitions to create for each
+       thread. Use 1 to disable sub partitioning.
    * - prefixsort_normalized_key_max_bytes
      - integer
      - 128
@@ -167,8 +214,30 @@ Generic Configuration
      - 0
      - Specifies the max number of input batches to prefetch to do index lookup ahead. If it is zero,
        then process one input batch at a time.
+   * - index_lookup_join_split_output
+     - bool
+     - true
+     - If this is true, then the index join operator might split output for each input batch based
+       on the output batch size control. Otherwise, it tries to produce a single output for each input
+       batch.
+   * - unnest_split_output_batch
+     - bool
+     - true
+     - If this is true, then the unnest operator might split output for each input batch based on the
+       output batch size control. Otherwise, it produces a single output for each input batch.
+   * - max_num_splits_listened_to
+     - integer
+     - 0
+     - Specifies The max number of input splits to listen to by SplitListener per table scan node per
+       worker. It's up to the SplitListener implementation to respect this config.
+   * - operator_track_expression_stats
+     - bool
+     - false
+     - If this is true, then operators that evaluate expressions will track stats for expressions that
+       are not special forms and return them as part of their operator stats. Tracking these stats can
+       be expensive (especially if operator stats are retrieved frequently) and this allows the user to
+       explicitly enable it.
 
-.. _expression-evaluation-conf:
 
 Expression Evaluation Configuration
 -----------------------------------
@@ -189,6 +258,13 @@ 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.
+   * - expression.track_cpu_usage_for_functions
+     - string
+     - ""
+     - Comma-separated list of function names to selectively track CPU usage for. Only applicable when
+       ``expression.track_cpu_usage`` is set to false. Function names are case-insensitive and will be normalized
+       to lowercase. This allows fine-grained control over CPU tracking overhead when only specific functions need to
+       be monitored.
    * - legacy_cast
      - bool
      - false
@@ -226,6 +302,11 @@ Expression Evaluation Configuration
      - integer
      - 10000
      - Some lambda functions over arrays and maps are evaluated in batches of the underlying elements that comprise the arrays/maps. This is done to make the batch size managable as array vectors can have thousands of elements each and hit scaling limits as implementations typically expect BaseVectors to a couple of thousand entries. This lets up tune those batch sizes. Setting this to zero is setting unlimited batch size.
+   * - debug_bing_tile_children_max_zoom_shift
+     - integer
+     - 5
+     - The UDF `bing_tile_children` generates the children of a Bing tile based on a specified target zoom level. The number of children produced is determined by the difference between the target zoom level and the zoom level of the input tile. This configuration limits the number of children by capping the maximum zoom level difference, with a default value set to 5. This cap is necessary to prevent excessively large array outputs, which can exceed the size limits of the elements vector in the Velox array vector.
+
 
 Memory Management
 -----------------
@@ -254,6 +335,11 @@ Memory Management
        memory limit for partial aggregation is automatically doubled up to `max_extended_partial_aggregation_memory`.
        This adaptation is disabled by default, since the value of `max_extended_partial_aggregation_memory` equals the
        value of `max_partial_aggregation_memory`. Specify higher value for `max_extended_partial_aggregation_memory` to enable.
+   * - query_memory_reclaimer_priority
+     - integer
+     - 2147483647
+     - Priority of the query in the memory pool reclaimer. Lower value means higher priority. This is used in
+       global arbitration victim selection.
 
 Spilling
 --------
@@ -277,6 +363,10 @@ Spilling
      - boolean
      - true
      - When `spill_enabled` is true, determines whether HashBuild and HashProbe operators can spill to disk under memory pressure.
+   * - local_merge_spill_enabled
+     - boolean
+     - false
+     - When `spill_enabled` is true, determines whether LocalMerge operators can spill to disk to cap memory usage.
    * - mixed_grouped_mode_hash_join_spill_enabled
      - boolean
      - false
@@ -289,6 +379,12 @@ Spilling
      - boolean
      - true
      - When `spill_enabled` is true, determines whether Window operator can spill to disk under memory pressure.
+   * - window_spill_min_read_batch_rows
+     - integer
+     - 1000
+     - When processing spilled window data, read batches of whole partitions having at least that many rows. Set to 1 to
+       read one whole partition at a time. Each driver processing the Window operator will process that much data at
+       once.
    * - row_number_spill_enabled
      - boolean
      - true
@@ -382,6 +478,12 @@ Spilling
      - Specifies the compression algorithm type to compress the spilled data before write to disk to trade CPU for IO
        efficiency. The supported compression codecs are: zlib, snappy, lzo, zstd, lz4 and gzip.
        none means no compression.
+   * - spill_num_max_merge_files
+     - integer
+     - 0
+     - The max number of files to merge at a time when merging sorted files into a single ordered stream. 0 means unlimited.
+       This is used to reduce memory pressure by capping the number of open files when merging spilled sorted files to
+       avoid using too much memory and causing OOM. Note that this is only applicable for ordered spill.
    * - spill_prefixsort_enabled
      - bool
      - false
@@ -390,7 +492,7 @@ Spilling
    * - spiller_start_partition_bit
      - integer
      - 29
-     - The start partition bit which is used with `spiller_partition_bits` together to calculate the spilling partition number.
+     - The start partition bit which is used with `spiller_num_partition_bits` together to calculate the spilling partition number.
    * - spiller_num_partition_bits
      - integer
      - 3
@@ -419,6 +521,21 @@ Aggregation
      - integer
      - 80
      - Abandons partial aggregation if number of groups equals or exceeds this percentage of the number of input rows.
+   * - aggregation_compaction_bytes_threshold
+     - integer
+     - 0
+     - Memory threshold in bytes for triggering string compaction during global
+       aggregation. When total string storage exceeds this limit with high unused
+       memory ratio, compaction is triggered to reclaim dead strings. Disabled by
+       default (0). Currently only applies to approx_most_frequent aggregate with
+       StringView type during global aggregation.
+   * - aggregation_compaction_unused_memory_ratio
+     - double
+     - 0.25
+     - Ratio of unused (evicted) bytes to total bytes that triggers compaction.
+       The value is in the range of [0, 1). Currently only applies to approx_most_frequent
+       aggregate with StringView type during global aggregation. May be extended
+       to other aggregation types on-demand.
    * - streaming_aggregation_min_output_batch_rows
      - integer
      - 0
@@ -502,6 +619,31 @@ Table Writer
      - Minimum amount of data processed by all the logical table partitions to
        trigger skewed partition rebalancing by scale writer exchange.
 
+Connector Config
+----------------
+Connector config is initialized on velox runtime startup and is shared among queries as the default config across all connectors.
+Each query can override the config by setting corresponding query session properties such as in Prestissimo.
+
+.. list-table::
+   :widths: 20 20 10 10 70
+   :header-rows: 1
+
+   * - user
+     -
+     - string
+     - ""
+     - The user of the query. Used for storage logging.
+   * - source
+     -
+     - string
+     - ""
+     - The source of the query. Used for storage access and logging.
+   * - schema
+     -
+     - string
+     - ""
+     - The schema of the query. Used for storage logging.
+
 Hive Connector
 --------------
 Hive Connector config is initialized on velox runtime startup and is shared among queries as the default config.
@@ -521,6 +663,11 @@ Each query can override the config by setting corresponding query session proper
      - integer
      - 100
      - Maximum number of (bucketed) partitions per a single table writer instance.
+   * - hive.max-bucket-count
+     - hive.max_bucket_count
+     - integer
+     - 100000
+     - Maximum number of buckets that a table writer is allowed to write to.
    * - insert-existing-partitions-behavior
      - insert_existing_partitions_behavior
      - string
@@ -629,6 +776,11 @@ Each query can override the config by setting corresponding query session proper
      - bool
      - true
      - Reads timestamp partition value as local time if true. Otherwise, reads as UTC.
+   * - hive.preserve-flat-maps-in-memory
+     - hive.preserve_flat_maps_in_memory
+     - bool
+     - false
+     - Whether to preserve flat maps in memory as FlatMapVectors instead of converting them to MapVectors. This is only applied during data reading inside the DWRF and Nimble readers, not during downstream processing like expression evaluation etc.
 
 ``ORC File Format Configuration``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -720,6 +872,11 @@ Each query can override the config by setting corresponding query session proper
      - integer
      - 1024
      - Batch size used when writing into Parquet through Arrow bridge.
+   * - hive.parquet.writer.created-by
+     -
+     - string
+     - parquet-cpp-velox version 0.0.0
+     - Created-by value used when writing to Parquet.
 
 ``Amazon S3 Configuration``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -852,6 +1009,12 @@ These semantics are similar to the `Apache Hadoop-Aws module <https://hadoop.apa
      - string
      -
      - The GCS maximum time allowed to retry transient errors.
+   * - hive.gcs.auth.access-token-provider
+     - string
+     -
+     - A custom OAuth credential provider, if specified, will be used to create the client in favor of other
+       authentication mechanisms.
+       The provider must be registered using "registerGcsOAuthCredentialsProvider" before it can be used.
 
 ``Azure Blob Storage Configuration``
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -865,12 +1028,15 @@ These semantics are similar to the `Apache Hadoop-Aws module <https://hadoop.apa
      - Description
    * - fs.azure.account.auth.type.<storage-account>.dfs.core.windows.net
      - string
-     - SharedKey
+     -
      - Specifies the authentication mechanism to use for Azure storage accounts.
        **Allowed values:** "SharedKey", "OAuth", "SAS".
        "SharedKey": Uses the storage account name and key for authentication.
        "OAuth": Utilizes OAuth tokens for secure authentication.
        "SAS": Employs Shared Access Signatures for granular access control.
+       To create Azure clients with the configured authentication type, the caller must
+       register the corresponding Azure client provider from the configuration by calling
+       `registerAzureClientProvider`.
    * - fs.azure.account.key.<storage-account>.dfs.core.windows.net
      - string
      -
@@ -899,6 +1065,12 @@ These semantics are similar to the `Apache Hadoop-Aws module <https://hadoop.apa
      - Specifies the OAuth 2.0 token endpoint URL for the Azure AD application.
        This endpoint is used to acquire access tokens for authenticating with Azure storage.
        The URL follows the format: `https://login.microsoftonline.com/<tenant-id>/oauth2/token`.
+   * - fs.azure.sas.token.renew.period.for.streams
+     - string
+     - 120
+     - Specifies the period in seconds to re-use SAS tokens until the expiry is within this number of seconds.
+       This configuration is used together with `registerSasTokenProvider` for dynamic SAS token renewal.
+       When a SAS token is close to expiry, it will be renewed by getting a new token from the provider.
 
 CLP Connector
 -----------------------------
@@ -973,6 +1145,14 @@ Spark-specific Configuration
      - Type
      - Default Value
      - Description
+   * - spark.ansi_enabled
+     - bool
+     - false
+     - If true, Spark function's behavior is ANSI-compliant, e.g. throws runtime exception instead
+       of returning null on invalid inputs. It affects only functions explicitly marked as "ANSI compliant".
+       Note: This feature is still under development to achieve full ANSI compliance. Users can
+       refer to the Spark function documentation to verify the current support status of a specific
+       function.
    * - spark.legacy_size_of_null
      - bool
      - true
@@ -1006,6 +1186,10 @@ Spark-specific Configuration
      - false
      - If true, Spark statistical aggregation functions including skewness, kurtosis, stddev, stddev_samp, variance,
        var_samp, covar_samp and corr will return NaN instead of NULL when dividing by zero during expression evaluation.
+   * - spark.json_ignore_null_fields
+     - bool
+     - true
+     - If true, ignore null fields when generating JSON string. If false, null fields are included with a null value.
 
 Tracing
 --------
@@ -1025,10 +1209,10 @@ Tracing
      - string
      -
      - The root directory to store the tracing data and metadata for a query.
-   * - query_trace_node_ids
+   * - query_trace_node_id
      - string
      -
-     - A comma-separated list of plan node ids whose input data will be trace. If it is empty, then we only trace the
+     - The plan node id 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.
    * - query_trace_task_reg_exp
      - string
@@ -1038,3 +1222,60 @@ Tracing
      - integer
      - 0
      - The max trace bytes limit. Tracing is disabled if zero.
+   * - query_trace_dry_run
+     - boolean
+     - false
+     - If true, we only collect the input trace for a given operator but without the actual
+       execution. This is used for crash debugging.
+
+Cudf-specific Configuration (Experimental)
+------------------------------------------
+These configurations are available when `compiled with cuDF <https://github.com/facebookincubator/velox/blob/main/velox/experimental/cudf/README.md#getting-started-with-velox-cudf>`_.
+Note: These configurations are experimental and subject to change.
+
+.. list-table::
+   :widths: 30 10 10 70
+   :header-rows: 1
+
+   * - Property Name
+     - Type
+     - Default Value
+     - Description
+   * - cudf.enabled
+     - bool
+     - true
+     - If true, enable cuDF. By default, it is enabled if compiled with cuDF.
+   * - cudf.memory_resource
+     - string
+     - async
+     - The memory resource to use for cuDF. Possible values are (cuda, pool, async, arena, managed, managed_pool, prefetch_managed, prefetch_managed_pool).
+       The prefetch options enable automatic prefetching for better GPU memory performance: prefetch_managed uses CUDA unified memory with prefetching,
+       prefetch_managed_pool uses a pooled version of CUDA unified memory with prefetching.
+   * - cudf.memory_percent
+     - integer
+     - 50
+     - The initial percent of GPU memory to allocate for pool or arena memory resources.
+   * - cudf.function_name_prefix
+     - string
+     - ""
+     - The prefix to use for the function names in cuDF.
+   * - cudf.ast_expression_enabled
+     - bool
+     - true
+     - If true, enable using cuDF AST-based expression evaluation when supported.
+   * - cudf.ast_expression_priority
+     - integer
+     - 100
+     - Priority of cuDF AST expressions. Higher value wins when multiple cuDF execution options are available for the same Velox expression. Standalone cuDF functions have priority 50. If enabled, with a default priority of 100, AST will be chosen as replacement for cudf execution.
+   * - cudf.allow_cpu_fallback
+     - bool
+     - true
+     - If true, allow falling back to Velox CPU execution when an operation is not supported in cuDF execution. If false, an error will be thrown if an operation is not supported in cuDF execution.
+   * - cudf.debug_enabled
+     - bool
+     - false
+     - If true, enable debug printing.
+   * - cudf.log_fallback
+     - bool
+     - true
+     - If true, log a reason for falling back to Velox CPU execution, when an operation is not supported in cuDF execution.
diff --git a/velox/docs/develop/aggregations.rst b/velox/docs/develop/aggregations.rst
index 934252f7c14a..86c7f31293ff 100644
--- a/velox/docs/develop/aggregations.rst
+++ b/velox/docs/develop/aggregations.rst
@@ -112,6 +112,27 @@ encounters a row with a different values in pre-grouped keys. This helps reduce
 the total amount of memory used and allows to unblock downstream operators
 faster.
 
+noGroupsSpanBatches Optimization
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+AggregationNode supports an optional ``noGroupsSpanBatches`` flag that can be set
+to true for streaming aggregations. When enabled, this flag indicates that no
+sort group spans across input batches - each input batch contains complete data
+for its groups, and no group will appear in any subsequent input batch.
+
+This optimization allows the StreamingAggregation operator to immediately produce
+aggregation results for all groups in each input batch without waiting to see if
+more data for those groups will arrive in subsequent batches. This can
+significantly improve output latency and reduce memory usage since the operator
+doesn't need to hold onto partial aggregation state across batches.
+
+The ``noGroupsSpanBatches`` flag can only be set when the aggregation is
+pre-grouped (streaming). Setting it on a non-streaming aggregation will result
+in an error.
+
+This optimization is typically set automatically by query optimizers when they can
+guarantee that the input data meets the required properties.
+
 Push-Down into Table Scan
 -------------------------
 
diff --git a/velox/docs/develop/connectors.rst b/velox/docs/develop/connectors.rst
index 22886134e3b2..b4c4275cdb85 100644
--- a/velox/docs/develop/connectors.rst
+++ b/velox/docs/develop/connectors.rst
@@ -29,13 +29,13 @@ Connector Interface
    * - Connector Factory
      - Enables creating instances of a particular connector.
 
-Velox provides Hive, CLP, and TPC-H Connectors out of the box.
-Let's examine the implementation details of both the Hive and CLP Connectors as examples.
+Velox provides Hive and TPC-H Connectors out of the box.
+Let's see how the above connector interfaces are implemented in the Hive Connector in detail below.
 
 Hive Connector
 --------------
 The Hive Connector is used to read and write data files (Parquet, DWRF) residing on
-an external storage (S3, HDFS, GCS, Linux FS).
+an external storage. Supported external "Storage Adapters" are listed below.
 
 HiveConnectorSplit
 ~~~~~~~~~~~~~~~~~~
@@ -80,7 +80,7 @@ sources and each require a different configuration.
 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.
+The supported storage API are S3 (Amazon S3 Compatible Storage), HDFS (Hadoop Distributed File System), GCS (Google Cloud Storage), ABFS (Azure Blob File Storage), Linux File System.
 
 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.
@@ -89,7 +89,7 @@ S3 is supported using the `AWS SDK for C++ <https://github.com/aws/aws-sdk-cpp>`
 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).
 
-HDFS is supported using the
+HDFS is supported using the `Apache Hadoop libhdfs.so <https://github.com/apache/hadoop>`_ and
 `Apache Hawk libhdfs3 <https://github.com/apache/hawq/tree/master/depends/libhdfs3>`_ library. HDFS supported schemes
 are `hdfs://`.
 
@@ -97,8 +97,8 @@ GCS is supported using the
 `Google Cloud Platform C++ Client Libraries <https://github.com/googleapis/google-cloud-cpp>`_. GCS supported schemes
 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)://`.
+ABFS is supported using the
+`Azure SDK for C++ <https://github.com/Azure/azure-sdk-for-cpp>`_ library. ABFS supported schemes are `abfs(s)://`.
 
 S3 Storage adapter using a proxy
 ********************************
@@ -122,57 +122,7 @@ This is the behavior when the proxy settings are enabled:
 5. Use . or \*. to indicate domain suffix matching, e.g. `.foobar.com` will
    match `test.foobar.com` or `foo.foobar.com`.
 
-CLP Connector
--------------
-The CLP Connector is used to read CLP splits stored on a local file system or S3. It implements similar interfaces as
-the Hive Connector except for the ``DataSink`` interface. Here we only describe the ``DataSource`` interface and the
-``ConnectorSplit`` interface implementation since ``Connector`` and ``ConnectorFactory`` are similar to the Hive
-Connector. We also describe ``ClpS3AuthProviderBase``, an interface that allows users to customize S3 authentication.
-
-ClpConnectorSplit
-~~~~~~~~~~~~~~~~~
-``ClpConnectorSplit`` describes a data chunk using ``path``. This path may be the absolute file path to the split file
-if it is stored on a local file system, or the complete (or partial) URL of the split if it is stored on S3. In the
-latter case, when only a partial URL is provided, ``ClpS3AuthProviderBase`` provides a hook in ``ClpDataSource`` to
-assist in constructing the full URL. Refer to :ref:`ClpS3AuthProviderBase<ClpS3AuthProviderBase>` for details.
-``ClpConnectorSplit`` also includes a ``type`` property that specifies whether the split is an archive or an IR
-(Internal Representation) stream.
-
-BaseClpCursor
-~~~~~~~~~~~~~
-``BaseClpCursor`` is responsible for preparing pushdown operations, loading splits, filtering data, and returning
-results. Each split type (archive or IR stream) has its own corresponding subclass (``ClpArchiveCursor`` and
-``ClpIrCursor``).
+HDFS Storage adapter
+********************
 
-ClpDataSource
-~~~~~~~~~~~~~
-``ClpDataSource`` implements the ``addSplit`` API that consumes a ``ClpConnectorSplit`` and ``next`` API that
-processes the split and returns a batch of rows.
-
-During initialization, it records the KQL query and split source (S3 or local). It then iterates through
-each output column, accessing its handle to get its type and original name. For row types, it recursively
-traverses the nested structure to process each field; for non-row types, it directly maps the Velox column
-type to a CLP column type.
-
-When a split is added, a ``BaseClpCursor`` instance is created with the split path and input source (which
-may be either a ``ClpArchiveCursor`` or a ``ClpIrCursor``). The query is parsed and simplified into an AST.
-On ``next``, the cursor finds matching row indices and, if any exist, ``ClpDataSource`` recursively creates
-a row vector composed of lazy vectors, which use CLP column readers to decode and load data as needed during
-execution.
-
-.. _ClpS3AuthProviderBase:
-
-ClpS3AuthProviderBase
-~~~~~~~~~~~~~~~~~~~~~
-``ClpS3AuthProviderBase`` defines an interface for obtaining S3 authentication information and constructing the
-complete split URL from the current URL stored in ``ClpConnectorSplit``. It provides the following two functions:
-
-1. ``exportAuthEnvironmentVariables()`` – Parses user-defined configuration options and exports the three environment
-   variables required by CLP-s to the system. This ensures that, at runtime, CLP-s can execute S3-related operations
-   correctly. This function is invoked immediately after the configuration is parsed.
-2. ``constructS3Url()`` – Builds the full S3 URL for a split. It takes the ``path`` property of ``ClpConnectorSplit``
-    as its argument, allowing customization in URL construction. For example, the ``path`` could be ``"prefix/split"``,
-    which must be prefixed with ``"https://bucket.s3.region.amazonaws.com/"`` to form the complete URL.
-
-Additionally, this interface maintains a reference to ``config_``, enabling users to define custom configuration
-options for passing any required information.
+Velox currently supports HDFS by dynamically loading libhdfs.so from the environment's ${HADOOP_HOME}/native/lib directory. If you prefer to use libhdfs3 instead, you can create a symbolic link from libhdfs.so to libhdfs3.so within the same directory.
diff --git a/velox/docs/develop/debugging/tracing.rst b/velox/docs/develop/debugging/tracing.rst
index 6966e97ca0b2..aad6e836f147 100644
--- a/velox/docs/develop/debugging/tracing.rst
+++ b/velox/docs/develop/debugging/tracing.rst
@@ -101,7 +101,7 @@ to the following simplified, pretty-printed JSON string (with some content remov
         "name":"HashJoinNode"
       },
       "connectorProperties":{...},
-      "queryConfig":{"query_trace_node_ids":"2", ...}
+      "queryConfig":{"query_trace_node_id":"2", ...}
     }
 
 **OperatorTraceInputWriter**
@@ -301,7 +301,7 @@ It would show something as the follows:
 
   ++++++Query configs++++++
   	query_trace_task_reg_exp: .*
-  	query_trace_node_ids: 2
+  	query_trace_node_id: 2
   	query_trace_max_bytes: 107374182400
   	query_trace_dir: /tmp/velox_test_aJqeFd/basic/traceRoot/
   	query_trace_enabled: 1
diff --git a/velox/docs/develop/joins.rst b/velox/docs/develop/joins.rst
index 0a1bf3d6a5c5..07b35462f085 100644
--- a/velox/docs/develop/joins.rst
+++ b/velox/docs/develop/joins.rst
@@ -198,6 +198,11 @@ 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.
 
+HashJoinNode supports a ``useHashTableCache`` flag (used only by Presto-on-Spark)
+that enables caching of the hash table built for broadcast joins. When enabled,
+the first task to build the hash table stores it in a global cache, and subsequent
+tasks from same query reuse the cached table instead of rebuilding it.
+
 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.
diff --git a/velox/docs/develop/memory.rst b/velox/docs/develop/memory.rst
index 06ff5fe667ed..df4bc5a96a12 100644
--- a/velox/docs/develop/memory.rst
+++ b/velox/docs/develop/memory.rst
@@ -122,14 +122,14 @@ Memory Manager
     :alt: Memory Manager
 
 The memory manager is created on server startup with the provided
-*MemoryManagerOption*. It creates a memory allocator instance to manage the
+*MemoryManager::Options*. 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
+*MemoryManager::Options::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
+query memory limit (specified by *MemoryManager::Options::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
@@ -171,8 +171,8 @@ 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>`_
+memory limit (*MemoryManager::Options::arbitratorCapacity*) to be smaller than the system memory
+limit (*MemoryManager::Options::allocatorCapacity*) (refer to `OOM prevention section <#server-oom-prevention>`_
 for detail).
 
 Memory System Setup
@@ -186,7 +186,7 @@ Here is the code block from Prestissimo that initializes the Velox memory system
    void PrestoServer::initializeVeloxMemory() {
      auto* systemConfig = SystemConfig::instance();
      const uint64_t memoryGb = systemConfig->systemMemoryGb();
-     MemoryManagerOptions options;
+     MemoryManager::Options options;
      options.allocatorCapacity = memoryGb << 30;
      options.useMmapAllocator = systemConfig->useMmapAllocator();
      if (!systemConfig->memoryArbitratorKind().empty()) {
@@ -217,7 +217,7 @@ Here is the code block from Prestissimo that initializes the Velox memory system
 * 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
+  allocator and arbitrator inside based on MemoryManager::Options initialized from previous steps
 * L15-19: creates the file cache if it is enabled in Prestissimo system
   config
 
@@ -334,7 +334,7 @@ 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 1MB if size < 16MB
 - round up to next 4MB if size < 64MB
 - round up to next 8MB if size >= 64MB
 
@@ -539,10 +539,10 @@ between queries by adjusting their memory pool’s capacities accordingly (see
 
 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
+Prestissimo and Prestissimo-on-Spark. `Gluten <https://github.com/apache/incubator-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
+(*MemoryManager::Options::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,
@@ -700,7 +700,7 @@ 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
+application by setting *MemoryManager::Options::useMmapAllocator* (see
 `memory system setup section <#memory-system-setup>`_ for example).
 
 Non-Contiguous Allocation
diff --git a/velox/docs/develop/operators.rst b/velox/docs/develop/operators.rst
index 9af21bcdacd1..108213e1b9c6 100644
--- a/velox/docs/develop/operators.rst
+++ b/velox/docs/develop/operators.rst
@@ -547,6 +547,8 @@ and emitting results.
      - Join type: inner, left, right, full, left semi filter, left semi project, right semi filter, right semi project, anti. You can read about different join types in this `blog post <https://dataschool.com/how-to-teach-people-sql/sql-join-types-explained-visually/>`_.
    * - nullAware
      - Applies to anti and semi project joins only. Indicates whether the join semantic is IN (nullAware = true) or EXISTS (nullAware = false).
+   * - useHashTableCache
+     - Optional. Used only by Presto-on-Spark. When true, enables caching of the hash table built for broadcast joins so that subsequent tasks can reuse it.
    * - leftKeys
      - Columns from the left hand side input that are part of the equality condition. At least one must be specified.
    * - rightKeys
@@ -652,8 +654,12 @@ The unnest operation expands arrays and maps into separate columns. Arrays are
 expanded into a single column, and maps are expanded into two columns
 (key, value). Can be used to expand multiple columns. In this case produces as
 many rows as the highest cardinality array or map (the other columns are padded
-with nulls). Optionally can produce an ordinality column that specifies the row
-number starting with 1.
+with nulls). Optionally, it can include an ordinality column to indicate the row
+number starting from 1, and an emptyUnnestValue column to indicate whether an
+output row has empty unnest value or not. If the ordinality column is specified
+along with the emptyUnnestValue column, the ordinality for the output row with
+empty unnest values is set to zero. If the emptyUnnestValue column is not specified,
+output rows with empty unnest values are not produced.
 
 .. list-table::
    :widths: 10 30
@@ -670,6 +676,8 @@ number starting with 1.
      - Names to use for expanded columns. One name per array column. Two names per map column.
    * - ordinalityName
      - Optional name for the ordinality column.
+   * - emptyUnnestValueName
+     - Optional name for the emptyUnnestValue column.
 
 .. _TableWriteNode:
 
@@ -941,7 +949,7 @@ results available before seeing all input.
 TopNRowNumberNode
 ~~~~~~~~~~~~~~~~~
 
-An optimized version of a WindowNode with a single row_number function and a
+An optimized version of a WindowNode with a single row_number, rank or dense_rank function and a
 limit over sorted partitions.
 
 Partitions the input using specified partitioning keys and maintains up to
@@ -949,11 +957,11 @@ a 'limit' number of top rows for each partition. After receiving all input,
 assigns row numbers within each partition starting from 1.
 
 This operator accumulates state: a hash table mapping partition keys to a list
-of top 'limit' rows within that partition.  Returning the row numbers as
+of top 'limit' rows within that partition.  Returning the row number or rank as
 a column in the output is optional. This operator supports spilling as well.
 
 This operator is logically equivalent to a WindowNode followed by
-FilterNode(row_number <= limit), but it uses less memory and CPU.
+FilterNode(rank/row_number <= limit), but it uses less memory and CPU.
 
 .. list-table::
   :widths: 10 30
diff --git a/velox/docs/develop/scalar-functions.rst b/velox/docs/develop/scalar-functions.rst
index 19688defb94a..663aa6bd0a79 100644
--- a/velox/docs/develop/scalar-functions.rst
+++ b/velox/docs/develop/scalar-functions.rst
@@ -722,7 +722,7 @@ cardinality function for maps:
 
       BaseVector::ensureWritable(rows, BIGINT(), context.pool(), result);
       BufferPtr resultValues =
-           result->as<FlatVector<int64_t>>()->mutableValues(rows.size());
+           result->as<FlatVector<int64_t>>()->mutableValues();
       auto rawResult = resultValues->asMutable<int64_t>();
 
       auto mapVector = args[0]->as<MapVector>();
diff --git a/velox/docs/develop/testing.rst b/velox/docs/develop/testing.rst
index 93f92b50a04e..e9dabed5229a 100644
--- a/velox/docs/develop/testing.rst
+++ b/velox/docs/develop/testing.rst
@@ -11,5 +11,6 @@ Testing Tools
     testing/join-fuzzer
     testing/memory-arbitration-fuzzer
     testing/row-number-fuzzer
+    testing/spatial-join-fuzzer
     testing/writer-fuzzer
     testing/spark-query-runner.rst
diff --git a/velox/docs/develop/testing/memory-arbitration-fuzzer.rst b/velox/docs/develop/testing/memory-arbitration-fuzzer.rst
index 2895138a6faf..005b80d4ddb1 100644
--- a/velox/docs/develop/testing/memory-arbitration-fuzzer.rst
+++ b/velox/docs/develop/testing/memory-arbitration-fuzzer.rst
@@ -9,8 +9,8 @@ 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.
+2. Plan Generation: Generate multiple plans with different query shapes. Currently, it supports HashJoin,
+   HashAggregation, RowNumber, TopNRowNumber, and OrderBy 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.
@@ -19,11 +19,11 @@ It works as follows:
 How to run
 ----------
 
-Use velox_memory_arbitration_fuzzer_test binary to run this fuzzer:
+Use velox_memory_arbitration_fuzzer binary to run this fuzzer:
 
 ::
 
-    velox/exec/tests/velox_memory_arbitration_fuzzer_test --seed 123 --duration_sec 60
+    velox/exec/tests/velox_memory_arbitration_fuzzer --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
diff --git a/velox/docs/develop/testing/row-number-fuzzer.rst b/velox/docs/develop/testing/row-number-fuzzer.rst
index f90b33f76210..f90edce12ed5 100644
--- a/velox/docs/develop/testing/row-number-fuzzer.rst
+++ b/velox/docs/develop/testing/row-number-fuzzer.rst
@@ -1,14 +1,16 @@
-================
-RowNumber Fuzzer
-================
+==================================
+RowNumber and TopNRowNumber 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:
+The RowNumberFuzzer and TopNRowNumberFuzzer are testing tools that automatically generate equivalent query plans that
+use the RowNumber and TopNRowNumber Velox plan nodes, and then execute these plans to validate the consistency of
+the results. They works as follows:
 
-1. Data Generation: It starts by generating a random set of input data, also known as a vector. This data can
+1. Data Generation: Generate 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.
+2. Plan Generation: Generate two equivalent query plans: one is RowNumber over ValuesNode as
+   the base plan and the other is over TableScanNode as the alternative plan. The TopNRowNumberFuzzer generates similar
+   plans with TopNRowNumber node instead.
 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.
@@ -19,12 +21,16 @@ to validate the consistency of the results. It works as follows:
 How to run
 ----------
 
-Use velox_row_number_fuzzer binary to run rowNumber fuzzer:
-
+Use velox_row_number_fuzzer to run RowNumberFuzzer
 ::
 
     velox/exec/fuzzer/velox_row_number_fuzzer --seed 123 --duration_sec 60
 
+Similarly, use velox_topn_row_number_fuzzer to run TopNRowNumberFuzzer
+::
+
+    velox/exec/fuzzer/velox_topn_row_number_fuzzer --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.
diff --git a/velox/docs/develop/testing/spatial-join-fuzzer.rst b/velox/docs/develop/testing/spatial-join-fuzzer.rst
new file mode 100644
index 000000000000..519ab3590932
--- /dev/null
+++ b/velox/docs/develop/testing/spatial-join-fuzzer.rst
@@ -0,0 +1,118 @@
+====================
+Spatial Join Fuzzer
+====================
+
+Overview
+========
+
+The Spatial Join Fuzzer tests the correctness of the SpatialJoin operator by generating random geometry data and spatial join plans. It verifies that SpatialJoin produces the same results as NestedLoopJoin for equivalent queries.
+
+
+Supported Features
+==================
+
+Join Types
+----------
+
+The fuzzer tests the two join types supported by SpatialJoin (as defined in ``SpatialJoinNode::isSupported()``):
+
+* **INNER** - Only matching rows from both sides
+* **LEFT** - All rows from left side, matched rows from right side
+
+Spatial Predicates
+------------------
+
+The fuzzer tests these spatial predicates:
+
+* ``ST_Intersects(geometry1, geometry2)`` - Tests if geometries intersect
+* ``ST_Contains(geometry1, geometry2)`` - Tests if one geometry contains another
+* ``ST_Within(geometry1, geometry2)`` - Tests if one geometry is within another
+* ``ST_Distance(geometry1, geometry2) < threshold`` - Tests distance with threshold
+
+Geometry Types
+--------------
+
+The fuzzer generates Well-Known Text (WKT) strings for three geometry types:
+
+* **POINT** - Single coordinate point (e.g., ``POINT (10.5 20.3)``)
+* **POLYGON** - Closed shape with vertices
+* **LINESTRING** - Line segment between two points
+
+Distribution Patterns
+---------------------
+
+Geometries are generated using three distribution patterns:
+
+* **Uniform** - Geometries uniformly distributed in space (0-1000 range)
+* **Clustered** - Geometries grouped in 5 specific regions to test overlap scenarios
+* **Sparse** - Geometries widely spread (0-2000 range) with low overlap probability
+
+Implementation Details
+======================
+
+
+Geometry Generation
+-------------------
+
+Geometries are generated using ``AbstractInputGenerator`` subclasses:
+
+* ``PointInputGenerator`` - Generates POINT WKT strings
+* ``PolygonInputGenerator`` - Generates POLYGON WKT strings
+* ``LineStringInputGenerator`` - Generates LINESTRING WKT strings
+
+Each generator implements the ``generate(vector_size_t index)`` method to produce geometry strings based on the distribution pattern.
+
+**Uniform Distribution**::
+
+    x = random(0, 1000)
+    y = random(0, 1000)
+    POINT (x y)
+
+**Clustered Distribution**::
+
+    cluster = row % 5  // 5 clusters
+    centerX = cluster * 200 + 100
+    centerY = cluster * 200 + 100
+    x = centerX + random(-50, 50)
+    y = centerY + random(-50, 50)
+    POINT (x y)
+
+**Sparse Distribution**::
+
+    x = random(0, 2000)  // Larger Range
+    y = random(0, 2000)
+    POINT (x y)
+
+Data Matching Strategy
+----------------------
+
+To ensure some matches occur during joins:
+
+* Build side copies ~30% of geometries from probe side
+* 10% chance of empty build side to test edge cases
+
+Verification
+------------
+
+The fuzzer compares results from two equivalent plans:
+
+1. **SpatialJoin plan** - Using the specialized SpatialJoin operator
+2. **NestedLoopJoin plan** - Using NestedLoopJoin with the same spatial predicate as a filter
+
+Results must match exactly, validating that SpatialJoin implements spatial predicates correctly.
+
+Key Differences from JoinFuzzer
+================================
+
+Join Conditions
+---------------
+
+Unlike regular joins with simple equality predicates::
+
+    // Regular join
+    probe.id = build.id
+
+    // Spatial join
+    ST_Intersects(probe_geom, build_geom)
+
+Spatial joins use **function call expressions** as join conditions rather than simple column references.
diff --git a/velox/docs/develop/types.rst b/velox/docs/develop/types.rst
index 0253c9266c3a..9a420bf7a607 100644
--- a/velox/docs/develop/types.rst
+++ b/velox/docs/develop/types.rst
@@ -115,6 +115,7 @@ DATE                    INTEGER
 DECIMAL                 BIGINT if precision <= 18, HUGEINT if precision >= 19
 INTERVAL DAY TO SECOND  BIGINT
 INTERVAL YEAR TO MONTH  INTEGER
+TIME                    BIGINT
 ======================  ======================================================
 
 DECIMAL type carries additional `precision`,
@@ -130,6 +131,9 @@ 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.
 
+TIME type represents time in milliseconds from midnight UTC. Thus min/max value can  range from UTC-14:00 at 00:00:00 to UTC+14:00 at 23:59:59.999 modulo 24 hours.
+TIME type is backed by BIGINT physical type.
+
 Custom Types
 ~~~~~~~~~~~~
 Most custom types can be represented as logical types and can be built by extending
@@ -173,7 +177,14 @@ TIMESTAMP WITH TIME ZONE  BIGINT
 UUID                      HUGEINT
 IPADDRESS                 HUGEINT
 IPPREFIX                  ROW(HUGEINT,TINYINT)
+BINGTILE                  BIGINT
 GEOMETRY                  VARBINARY
+SPHERICALGEOGRAPHY        VARBINARY
+TDIGEST                   VARBINARY
+QDIGEST                   VARBINARY
+BIGINT_ENUM               BIGINT
+VARCHAR_ENUM              VARCHAR
+TIME WITH TIME ZONE       BIGINT
 ========================  =====================
 
 TIMESTAMP WITH TIME ZONE represents a time point in milliseconds precision
@@ -209,6 +220,53 @@ As a result the IPPREFIX object stores *FFFF:FFFF::* and the length 32 for both
    IPPREFIX 'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF/32' -- IPPREFIX 'FFFF:FFFF:0000:0000:0000:0000:0000:0000/32'
    IPPREFIX 'FFFF:FFFF:4455:6677:8899:AABB:CCDD:EEFF/32' -- IPPREFIX 'FFFF:FFFF:0000:0000:0000:0000:0000:0000/32'
 
+TDIGEST(DOUBLE) is a data sketch for estimating rank-based metrics.
+T-digests may be merged without losing precision, and for storage and retrieval
+they may be cast to/from VARBINARY. The T-digest accepts a parameter of type
+DOUBLE which represents the set of numbers to be ingested by the T-digest.
+
+QDIGEST(BIGINT), QDIGEST(REAL), QDIGEST(DOUBLE) are data sketches for
+estimating rank-based metrics. A quantile digest captures the approximate distribution of
+data for a given input set, and can be queried to retrieve approximate quantile values from the
+distribution. They may be merged without losing precision, and for storage and retrieval they may
+be cast to/from VARBINARY. The parameter type (BIGINT, REAL, or DOUBLE) represents
+the set of numbers that may be ingested by the quantile digest.
+
+BIGINT_ENUM(LongEnumParameter) type represents an enumerated value where the physical type is BIGINT.
+It takes one LongEnumParameter as parameter, which consists of a string name and a mapping of
+string keys to BIGINT values.
+There is a static cache which stores instances of different BIGINT_ENUM types. This is to treat each
+different enum type as a singleton. The LongEnumParameter is used as the key to retrieve the cached instance,
+and a new instance is only created if it has not been created with the given LongEnumParameter.
+Casting is permitted from any integer type to an enum type. Casting is only permitted from an enum type
+to a BIGINT type. Casting between different enum types is not permitted.
+Comparison operations are only allowed between values of the same enum type.
+
+VARCHAR_ENUM(VarcharEnumParameter) type represents an enumerated value where the physical type is VARCHAR.
+It takes one VarcharEnumParameter as parameter, which consists of a string name and a mapping of
+string keys to VARCHAR values.
+Similar to BIGINT_ENUM, there is a static cache which stores instances of different VARCHAR_ENUM types, with the
+VarcharEnumParameter as the key.
+Casting is only permitted to and from VARCHAR type, and is case-sensitive. Casting between different enum types is not permitted.
+Comparison operations are only allowed between values of the same enum type.
+
+TIME WITH TIME ZONE represents time from midnight in milliseconds precision at a particular timezone.
+Its physical type is BIGINT. The high 52 bits of bigint store signed integer for milliseconds in UTC.
+The lower 12 bits store the time zone offsets minutes. This allows the time to be converted at any point of
+time without ambiguity of daylight savings time. Time zone offsets range from -14:00 hours to +14:00 hours.
+
+BINGTILE represents a `Bing tile <https://learn.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system>`_.
+It is a quadtree in the Web Mercator projection, where each tile is 256x256 pixels. Its physical type is BIGINT.
+
+GEOMETRY represents a geometry as defined in `Simple Feature Access <https://en.wikipedia.org/wiki/Simple_Features>`_.
+Subtypes include Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon, and GeometryCollection. They
+are often stored as `Well-Known Text <https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry>`_ or
+`Well-Known Binary <https://en.wikipedia.org/wiki/Well-known_binary>`_.
+
+SPHERICALGEOGRAPHY represents a geometry on a spherical model of the Earth. It is internally represented the same
+way as GEOMETRY, but only certain functions are supported.  Moreover, these functions will return values in meters
+as opposed to the units of the coordinate space.
+
 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
diff --git a/velox/docs/ext/delta.py b/velox/docs/ext/delta.py
new file mode 100644
index 000000000000..40a76426a2e0
--- /dev/null
+++ b/velox/docs/ext/delta.py
@@ -0,0 +1,773 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generating delta function link :delta:func:`<name>`"""
+
+from __future__ import annotations
+
+from function import (
+    function_sig_re,
+    pairindextypes,
+    parse_arglist,
+    pseudo_parse_arglist,
+    parse_annotation,
+    ObjectEntry,
+    ModuleEntry,
+)
+from typing import Any, Iterable, Iterator, Tuple, cast
+
+from docutils import nodes
+from docutils.nodes import Element, Node
+from docutils.parsers.rst import directives
+from sphinx import addnodes
+from sphinx.addnodes import desc_signature, pending_xref
+from sphinx.application import Sphinx
+from sphinx.builders import Builder
+from sphinx.directives import ObjectDescription
+from sphinx.domains import Domain, Index, IndexEntry, ObjType
+from sphinx.environment import BuildEnvironment
+from sphinx.locale import _, __
+from sphinx.roles import XRefRole
+from sphinx.util import logging
+from sphinx.util.docfields import Field
+from sphinx.util.nodes import (
+    find_pending_xref_condition,
+    make_id,
+    make_refnode,
+)
+from sphinx.util.typing import OptionSpec
+
+logger = logging.getLogger(__name__)
+
+function_module = "delta"
+
+
+class DeltaObject(ObjectDescription[Tuple[str, str]]):
+    """
+    Description of a general Delta object.
+
+    :cvar allow_nesting: Class is an object that allows for nested namespaces
+    :vartype allow_nesting: bool
+    """
+
+    option_spec: OptionSpec = {
+        "noindex": directives.flag,
+        "noindexentry": directives.flag,
+        "nocontentsentry": directives.flag,
+        "module": directives.unchanged,
+        "canonical": directives.unchanged,
+        "annotation": directives.unchanged,
+    }
+
+    doc_field_types = [
+        Field(
+            "returnvalue",
+            label=_("Returns"),
+            has_arg=False,
+            names=("returns", "return"),
+        ),
+    ]
+
+    allow_nesting = False
+
+    def get_signature_prefix(self, sig: str) -> list[nodes.Node]:
+        """May return a prefix to put before the object name in the
+        signature.
+        """
+        return []
+
+    def needs_arglist(self) -> bool:
+        """May return true if an empty argument list is to be generated even if
+        the document contains none.
+        """
+        return False
+
+    def handle_signature(self, sig: str, signode: desc_signature) -> tuple[str, str]:
+        """Transform a Delta signature into RST nodes.
+        Return (fully qualified name of the thing, classname if any).
+        If inside a class, the current class name is handled intelligently:
+        * it is stripped from the displayed name if present
+        * it is added to the full name (return value) if not present
+        """
+        m = function_sig_re.match(sig)
+        if m is None:
+            raise ValueError
+        prefix, name, arglist, retann = m.groups()
+
+        # determine module and class name (if applicable), as well as full name
+        modname = self.options.get("module", self.env.ref_context.get("delta:module"))
+        classname = self.env.ref_context.get("delta:class")
+        if classname:
+            add_module = False
+            if prefix and (prefix == classname or prefix.startswith(classname + ".")):
+                fullname = prefix + name
+                # class name is given again in the signature
+                prefix = prefix[len(classname) :].lstrip(".")
+            elif prefix:
+                # class name is given in the signature, but different
+                # (shouldn't happen)
+                fullname = classname + "." + prefix + name
+            else:
+                # class name is not given in the signature
+                fullname = classname + "." + name
+        else:
+            add_module = True
+            if prefix:
+                classname = prefix.rstrip(".")
+                fullname = prefix + name
+            else:
+                classname = ""
+                fullname = name
+
+        signode["module"] = modname
+        signode["class"] = classname
+        signode["fullname"] = fullname
+
+        sig_prefix = self.get_signature_prefix(sig)
+        if sig_prefix:
+            if type(sig_prefix) is str:
+                raise TypeError(
+                    "Python directive method get_signature_prefix()"
+                    " must return a list of nodes."
+                    f" Return value was '{sig_prefix}'."
+                )
+            else:
+                signode += addnodes.desc_annotation(str(sig_prefix), "", *sig_prefix)
+
+        if prefix:
+            signode += addnodes.desc_addname(prefix, prefix)
+        elif modname and add_module and self.env.config.add_module_names:
+            nodetext = modname + "."
+            signode += addnodes.desc_addname(nodetext, nodetext)
+
+        signode += addnodes.desc_name(name, name)
+        if arglist:
+            try:
+                signode += parse_arglist(function_module, arglist, self.env)
+            except SyntaxError:
+                # fallback to parse arglist original parser.
+                # it supports to represent optional arguments (ex. "func(foo [, bar])")
+                pseudo_parse_arglist(signode, arglist)
+            except NotImplementedError as exc:
+                logger.warning(
+                    "could not parse arglist (%r): %s", arglist, exc, location=signode
+                )
+                pseudo_parse_arglist(signode, arglist)
+        else:
+            if self.needs_arglist():
+                # for callables, add an empty parameter list
+                signode += addnodes.desc_parameterlist()
+
+        if retann:
+            children = parse_annotation(function_module, retann, self.env)
+            signode += addnodes.desc_returns(retann, "", *children)
+
+        anno = self.options.get("annotation")
+        if anno:
+            signode += addnodes.desc_annotation(
+                " " + anno, "", addnodes.desc_sig_space(), nodes.Text(anno)
+            )
+
+        return fullname, prefix
+
+    def _object_hierarchy_parts(self, sig_node: desc_signature) -> tuple[str, ...]:
+        if "fullname" not in sig_node:
+            return ()
+        modname = sig_node.get("module")
+        fullname = sig_node["fullname"]
+
+        if modname:
+            return (modname, *fullname.split("."))
+        else:
+            return tuple(fullname.split("."))
+
+    def get_index_text(self, modname: str, name: tuple[str, str]) -> str:
+        """Return the text for the index entry of the object."""
+        raise NotImplementedError("must be implemented in subclasses")
+
+    def add_target_and_index(
+        self, name_cls: tuple[str, str], sig: str, signode: desc_signature
+    ) -> None:
+        modname = self.options.get("module", self.env.ref_context.get("delta:module"))
+        fullname = (modname + "." if modname else "") + name_cls[0]
+        node_id = make_id(self.env, self.state.document, "", fullname)
+        signode["ids"].append(node_id)
+        self.state.document.note_explicit_target(signode)
+
+        domain = cast(DeltaDomain, self.env.get_domain("delta"))
+        domain.note_object(fullname, self.objtype, node_id, location=signode)
+
+        canonical_name = self.options.get("canonical")
+        if canonical_name:
+            domain.note_object(
+                canonical_name, self.objtype, node_id, aliased=True, location=signode
+            )
+
+        if "noindexentry" not in self.options:
+            indextext = self.get_index_text(modname, name_cls)
+            if indextext:
+                self.indexnode["entries"].append(
+                    ("single", indextext, node_id, "", None)
+                )
+
+    def before_content(self) -> None:
+        """Handle object nesting before content
+
+        For constructs that aren't nestable, the stack is bypassed, and instead
+        only the most recent object is tracked. This object prefix name will be
+        removed with :delta:meth:`after_content`.
+        """
+        prefix = None
+        if self.names:
+            # fullname and name_prefix come from the `handle_signature` method.
+            # fullname represents the full object name that is constructed using
+            # object nesting and explicit prefixes. `name_prefix` is the
+            # explicit prefix given in a signature
+            (fullname, name_prefix) = self.names[-1]
+            if self.allow_nesting:
+                prefix = fullname
+            elif name_prefix:
+                prefix = name_prefix.strip(".")
+        if prefix:
+            self.env.ref_context["delta:class"] = prefix
+            if self.allow_nesting:
+                classes = self.env.ref_context.setdefault("delta:classes", [])
+                classes.append(prefix)
+        if "module" in self.options:
+            modules = self.env.ref_context.setdefault("delta:modules", [])
+            modules.append(self.env.ref_context.get("delta:module"))
+            self.env.ref_context["delta:module"] = self.options["module"]
+
+    def after_content(self) -> None:
+        """Handle object de-nesting after content
+
+        If this class is a nestable object, removing the last nested class prefix
+        ends further nesting in the object.
+
+        If this class is not a nestable object, the list of classes should not
+        be altered as we didn't affect the nesting levels in
+        :delta:meth:`before_content`.
+        """
+        classes = self.env.ref_context.setdefault("delta:classes", [])
+        if self.allow_nesting:
+            try:
+                classes.pop()
+            except IndexError:
+                pass
+        self.env.ref_context["delta:class"] = classes[-1] if len(classes) > 0 else None
+        if "module" in self.options:
+            modules = self.env.ref_context.setdefault("delta:modules", [])
+            if modules:
+                self.env.ref_context["delta:module"] = modules.pop()
+            else:
+                self.env.ref_context.pop("delta:module")
+
+    def _toc_entry_name(self, sig_node: desc_signature) -> str:
+        if not sig_node.get("_toc_parts"):
+            return ""
+
+        config = self.env.app.config
+        objtype = sig_node.parent.get("objtype")
+        if config.add_function_parentheses and objtype in {"function", "method"}:
+            parens = "()"
+        else:
+            parens = ""
+        *parents, name = sig_node["_toc_parts"]
+        if config.toc_object_entries_show_parents == "domain":
+            return sig_node.get("fullname", name) + parens
+        if config.toc_object_entries_show_parents == "hide":
+            return name + parens
+        if config.toc_object_entries_show_parents == "all":
+            return ".".join(parents + [name + parens])
+        return ""
+
+
+class DeltaFunction(DeltaObject):
+    """Description of a function."""
+
+    option_spec: OptionSpec = DeltaObject.option_spec.copy()
+    option_spec.update(
+        {
+            "async": directives.flag,
+        }
+    )
+
+    def get_signature_prefix(self, sig: str) -> list[nodes.Node]:
+        if "async" in self.options:
+            return [addnodes.desc_sig_keyword("", "async"), addnodes.desc_sig_space()]
+        else:
+            return []
+
+    def needs_arglist(self) -> bool:
+        return True
+
+    def add_target_and_index(
+        self, name_cls: tuple[str, str], sig: str, signode: desc_signature
+    ) -> None:
+        super().add_target_and_index(name_cls, sig, signode)
+        if "noindexentry" not in self.options:
+            modname = self.options.get(
+                "module", self.env.ref_context.get("delta:module")
+            )
+            node_id = signode["ids"][0]
+
+            name, cls = name_cls
+            if modname:
+                text = _("%s() (in module %s)") % (name, modname)
+                self.indexnode["entries"].append(("single", text, node_id, "", None))
+            else:
+                text = f"{pairindextypes['builtin']}; {name}()"
+                self.indexnode["entries"].append(("pair", text, node_id, "", None))
+
+    def get_index_text(self, modname: str, name_cls: tuple[str, str]) -> str | None:
+        # add index in own add_target_and_index() instead.
+        return None
+
+
+class DeltaXRefRole(XRefRole):
+    def process_link(
+        self,
+        env: BuildEnvironment,
+        refnode: Element,
+        has_explicit_title: bool,
+        title: str,
+        target: str,
+    ) -> tuple[str, str]:
+        refnode["delta:module"] = env.ref_context.get("delta:module")
+        refnode["delta:class"] = env.ref_context.get("delta:class")
+        if not has_explicit_title:
+            title = title.lstrip(".")  # only has a meaning for the target
+            target = target.lstrip("~")  # only has a meaning for the title
+            # if the first character is a tilde, don't display the module/class
+            # parts of the contents
+            if title[0:1] == "~":
+                title = title[1:]
+                dot = title.rfind(".")
+                if dot != -1:
+                    title = title[dot + 1 :]
+        # if the first character is a dot, search more specific namespaces first
+        # else search builtins first
+        if target[0:1] == ".":
+            target = target[1:]
+            refnode["refspecific"] = True
+        return title, target
+
+
+class DeltaModuleIndex(Index):
+    """
+    Index subclass to provide the Delta module index.
+    """
+
+    name = "modindex"
+    localname = _("Delta Module Index")
+    shortname = _("modules")
+
+    def generate(
+        self, docnames: Iterable[str] | None = None
+    ) -> tuple[list[tuple[str, list[IndexEntry]]], bool]:
+        content: dict[str, list[IndexEntry]] = {}
+        # list of prefixes to ignore
+        ignores: list[str] = self.domain.env.config["modindex_common_prefix"]
+        ignores = sorted(ignores, key=len, reverse=True)
+        # list of all modules, sorted by module name
+        modules = sorted(
+            self.domain.data["modules"].items(), key=lambda x: x[0].lower()
+        )
+        # sort out collapsible modules
+        prev_modname = ""
+        num_toplevels = 0
+        for modname, (docname, node_id, synopsis, platforms, deprecated) in modules:
+            if docnames and docname not in docnames:
+                continue
+
+            for ignore in ignores:
+                if modname.startswith(ignore):
+                    modname = modname[len(ignore) :]
+                    stripped = ignore
+                    break
+            else:
+                stripped = ""
+
+            # we stripped the whole module name?
+            if not modname:
+                modname, stripped = stripped, ""
+
+            entries = content.setdefault(modname[0].lower(), [])
+
+            package = modname.split(".")[0]
+            if package != modname:
+                # it's a submodule
+                if prev_modname == package:
+                    # first submodule - make parent a group head
+                    if entries:
+                        last = entries[-1]
+                        entries[-1] = IndexEntry(
+                            last[0], 1, last[2], last[3], last[4], last[5], last[6]
+                        )
+                elif not prev_modname.startswith(package):
+                    # submodule without parent in list, add dummy entry
+                    entries.append(
+                        IndexEntry(stripped + package, 1, "", "", "", "", "")
+                    )
+                subtype = 2
+            else:
+                num_toplevels += 1
+                subtype = 0
+
+            qualifier = _("Deprecated") if deprecated else ""
+            entries.append(
+                IndexEntry(
+                    stripped + modname,
+                    subtype,
+                    docname,
+                    node_id,
+                    platforms,
+                    qualifier,
+                    synopsis,
+                )
+            )
+            prev_modname = modname
+
+        # apply heuristics when to collapse modindex at page load:
+        # only collapse if number of toplevel modules is larger than
+        # number of submodules
+        collapse = len(modules) - num_toplevels < num_toplevels
+
+        # sort by first letter
+        sorted_content = sorted(content.items())
+
+        return sorted_content, collapse
+
+
+class DeltaDomain(Domain):
+    """Delta domain."""
+
+    name = "delta"
+    label = "Delta"
+    object_types: dict[str, ObjType] = {
+        "function": ObjType(_("function"), "func", "obj"),
+    }
+
+    directives = {
+        "function": DeltaFunction,
+    }
+    roles = {
+        "func": DeltaXRefRole(fix_parens=True),
+    }
+    initial_data: dict[str, dict[str, tuple[Any]]] = {
+        "objects": {},  # fullname -> docname, objtype
+        "modules": {},  # modname -> docname, synopsis, platform, deprecated
+    }
+    indices = [
+        DeltaModuleIndex,
+    ]
+
+    @property
+    def objects(self) -> dict[str, ObjectEntry]:
+        return self.data.setdefault("objects", {})  # fullname -> ObjectEntry
+
+    def note_object(
+        self,
+        name: str,
+        objtype: str,
+        node_id: str,
+        aliased: bool = False,
+        location: Any = None,
+    ) -> None:
+        """Note a delta object for cross reference.
+
+        .. versionadded:: 2.1
+        """
+        if name in self.objects:
+            other = self.objects[name]
+            if other.aliased and aliased is False:
+                # The original definition found. Override it!
+                pass
+            elif other.aliased is False and aliased:
+                # The original definition is already registered.
+                return
+            else:
+                # duplicated
+                logger.warning(
+                    __(
+                        "duplicate object description of %s, "
+                        "other instance in %s, use :noindex: for one of them"
+                    ),
+                    name,
+                    other.docname,
+                    location=location,
+                )
+        self.objects[name] = ObjectEntry(self.env.docname, node_id, objtype, aliased)
+
+    @property
+    def modules(self) -> dict[str, ModuleEntry]:
+        return self.data.setdefault("modules", {})  # modname -> ModuleEntry
+
+    def note_module(
+        self, name: str, node_id: str, synopsis: str, platform: str, deprecated: bool
+    ) -> None:
+        """Note a delta module for cross reference.
+
+        .. versionadded:: 2.1
+        """
+        self.modules[name] = ModuleEntry(
+            self.env.docname, node_id, synopsis, platform, deprecated
+        )
+
+    def clear_doc(self, docname: str) -> None:
+        for fullname, obj in list(self.objects.items()):
+            if obj.docname == docname:
+                del self.objects[fullname]
+        for modname, mod in list(self.modules.items()):
+            if mod.docname == docname:
+                del self.modules[modname]
+
+    def merge_domaindata(self, docnames: list[str], otherdata: dict[str, Any]) -> None:
+        # XXX check duplicates?
+        for fullname, obj in otherdata["objects"].items():
+            if obj.docname in docnames:
+                self.objects[fullname] = obj
+        for modname, mod in otherdata["modules"].items():
+            if mod.docname in docnames:
+                self.modules[modname] = mod
+
+    def find_obj(
+        self,
+        env: BuildEnvironment,
+        modname: str,
+        classname: str,
+        name: str,
+        type: str | None,
+        searchmode: int = 0,
+    ) -> list[tuple[str, ObjectEntry]]:
+        """Find a Delta object for "name", perhaps using the given module
+        and/or classname.  Returns a list of (name, object entry) tuples.
+        """
+        # skip parens
+        if name[-2:] == "()":
+            name = name[:-2]
+
+        if not name:
+            return []
+
+        matches: list[tuple[str, ObjectEntry]] = []
+
+        newname = None
+        if searchmode == 1:
+            if type is None:
+                objtypes = list(self.object_types)
+            else:
+                objtypes = self.objtypes_for_role(type)
+            if objtypes is not None:
+                if modname and classname:
+                    fullname = modname + "." + classname + "." + name
+                    if (
+                        fullname in self.objects
+                        and self.objects[fullname].objtype in objtypes
+                    ):
+                        newname = fullname
+                if not newname:
+                    if (
+                        modname
+                        and modname + "." + name in self.objects
+                        and self.objects[modname + "." + name].objtype in objtypes
+                    ):
+                        newname = modname + "." + name
+                    elif (
+                        name in self.objects and self.objects[name].objtype in objtypes
+                    ):
+                        newname = name
+                    else:
+                        # "fuzzy" searching mode
+                        searchname = "." + name
+                        matches = [
+                            (oname, self.objects[oname])
+                            for oname in self.objects
+                            if oname.endswith(searchname)
+                            and self.objects[oname].objtype in objtypes
+                        ]
+        else:
+            # NOTE: searching for exact match, object type is not considered
+            if name in self.objects:
+                newname = name
+            elif type == "mod":
+                # only exact matches allowed for modules
+                return []
+            elif classname and classname + "." + name in self.objects:
+                newname = classname + "." + name
+            elif modname and modname + "." + name in self.objects:
+                newname = modname + "." + name
+            elif (
+                modname
+                and classname
+                and modname + "." + classname + "." + name in self.objects
+            ):
+                newname = modname + "." + classname + "." + name
+        if newname is not None:
+            matches.append((newname, self.objects[newname]))
+        return matches
+
+    def resolve_xref(
+        self,
+        env: BuildEnvironment,
+        fromdocname: str,
+        builder: Builder,
+        type: str,
+        target: str,
+        node: pending_xref,
+        contnode: Element,
+    ) -> Element | None:
+        modname = node.get("delta:module")
+        clsname = node.get("delta:class")
+        searchmode = 1 if node.hasattr("refspecific") else 0
+        matches = self.find_obj(env, modname, clsname, target, type, searchmode)
+
+        if not matches and type == "attr":
+            # fallback to meth (for property; Sphinx-2.4.x)
+            # this ensures that `:attr:` role continues to refer to the old property entry
+            # that defined by ``method`` directive in old reST files.
+            matches = self.find_obj(env, modname, clsname, target, "meth", searchmode)
+        if not matches and type == "meth":
+            # fallback to attr (for property)
+            # this ensures that `:meth:` in the old reST files can refer to the property
+            # entry that defined by ``property`` directive.
+            #
+            # Note: _prop is a secret role only for internal look-up.
+            matches = self.find_obj(env, modname, clsname, target, "_prop", searchmode)
+
+        if not matches:
+            return None
+        elif len(matches) > 1:
+            canonicals = [m for m in matches if not m[1].aliased]
+            if len(canonicals) == 1:
+                matches = canonicals
+            else:
+                logger.warning(
+                    __("more than one target found for cross-reference %r: %s"),
+                    target,
+                    ", ".join(match[0] for match in matches),
+                    type="ref",
+                    subtype="python",
+                    location=node,
+                )
+        name, obj = matches[0]
+
+        if obj[2] == "module":
+            return self._make_module_refnode(builder, fromdocname, name, contnode)
+        else:
+            # determine the content of the reference by conditions
+            content = find_pending_xref_condition(node, "resolved")
+            if content:
+                children = content.children
+            else:
+                # if not found, use contnode
+                children = [contnode]
+
+            return make_refnode(builder, fromdocname, obj[0], obj[1], children, name)
+
+    def resolve_any_xref(
+        self,
+        env: BuildEnvironment,
+        fromdocname: str,
+        builder: Builder,
+        target: str,
+        node: pending_xref,
+        contnode: Element,
+    ) -> list[tuple[str, Element]]:
+        modname = node.get("delta:module")
+        clsname = node.get("delta:class")
+        results: list[tuple[str, Element]] = []
+
+        # always search in "refspecific" mode with the :any: role
+        matches = self.find_obj(env, modname, clsname, target, None, 1)
+        multiple_matches = len(matches) > 1
+
+        for name, obj in matches:
+            if multiple_matches and obj.aliased:
+                # Skip duplicated matches
+                continue
+
+            if obj[2] == "module":
+                results.append(
+                    (
+                        "delta:mod",
+                        self._make_module_refnode(builder, fromdocname, name, contnode),
+                    )
+                )
+            else:
+                # determine the content of the reference by conditions
+                content = find_pending_xref_condition(node, "resolved")
+                if content:
+                    children = content.children
+                else:
+                    # if not found, use contnode
+                    children = [contnode]
+
+                results.append(
+                    (
+                        "delta:" + self.role_for_objtype(obj[2]),
+                        make_refnode(
+                            builder, fromdocname, obj[0], obj[1], children, name
+                        ),
+                    )
+                )
+        return results
+
+    def _make_module_refnode(
+        self, builder: Builder, fromdocname: str, name: str, contnode: Node
+    ) -> Element:
+        # get additional info for modules
+        module = self.modules[name]
+        title = name
+        if module.synopsis:
+            title += ": " + module.synopsis
+        if module.deprecated:
+            title += _(" (deprecated)")
+        if module.platform:
+            title += " (" + module.platform + ")"
+        return make_refnode(
+            builder, fromdocname, module.docname, module.node_id, contnode, title
+        )
+
+    def get_objects(self) -> Iterator[tuple[str, str, str, str, str, int]]:
+        for modname, mod in self.modules.items():
+            yield (modname, modname, "module", mod.docname, mod.node_id, 0)
+        for refname, obj in self.objects.items():
+            if obj.objtype != "module":  # modules are already handled
+                if obj.aliased:
+                    # aliased names are not full-text searchable.
+                    yield (refname, refname, obj.objtype, obj.docname, obj.node_id, -1)
+                else:
+                    yield (refname, refname, obj.objtype, obj.docname, obj.node_id, 1)
+
+    def get_full_qualified_name(self, node: Element) -> str | None:
+        modname = node.get("delta:module")
+        clsname = node.get("delta:class")
+        target = node.get("reftarget")
+        if target is None:
+            return None
+        else:
+            return ".".join(filter(None, [modname, clsname, target]))
+
+
+def setup(app: Sphinx) -> dict[str, Any]:
+    app.setup_extension("sphinx.directives")
+    app.add_domain(DeltaDomain)
+
+    return {
+        "version": "builtin",
+        "env_version": 3,
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }
diff --git a/velox/docs/ext/function.py b/velox/docs/ext/function.py
new file mode 100644
index 000000000000..c89f888f0f28
--- /dev/null
+++ b/velox/docs/ext/function.py
@@ -0,0 +1,374 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""The Function common functions."""
+
+from __future__ import annotations
+
+import ast
+import re
+from inspect import Parameter
+from typing import NamedTuple
+
+from docutils import nodes
+from docutils.nodes import Element, Node
+from sphinx import addnodes
+from sphinx.addnodes import desc_signature, pending_xref
+
+from sphinx.environment import BuildEnvironment
+from sphinx.locale import _
+from sphinx.util.inspect import signature_from_str
+
+# REs for Function signatures
+function_sig_re = re.compile(
+    r"""^ ([\w.]*\.)?            # class name(s)
+          (\w+)  \s*             # thing name
+          (?: \(\s*(.*)\s*\)     # optional: arguments
+           (?:\s* -> \s* (.*))?  #           return annotation
+          )? $                   # and nothing more
+          """,
+    re.VERBOSE,
+)
+
+pairindextypes = {
+    "module": _("module"),
+    "keyword": _("keyword"),
+    "operator": _("operator"),
+    "object": _("object"),
+    "exception": _("exception"),
+    "statement": _("statement"),
+    "builtin": _("built-in function"),
+}
+
+
+class ObjectEntry(NamedTuple):
+    docname: str
+    node_id: str
+    objtype: str
+    aliased: bool
+
+
+class ModuleEntry(NamedTuple):
+    docname: str
+    node_id: str
+    synopsis: str
+    platform: str
+    deprecated: bool
+
+
+def parse_reftarget(
+    reftarget: str, suppress_prefix: bool = False
+) -> tuple[str, str, str, bool]:
+    """Parse a type string and return (reftype, reftarget, title, refspecific flag)"""
+    refspecific = False
+    if reftarget.startswith("."):
+        reftarget = reftarget[1:]
+        title = reftarget
+        refspecific = True
+    elif reftarget.startswith("~"):
+        reftarget = reftarget[1:]
+        title = reftarget.split(".")[-1]
+    elif suppress_prefix:
+        title = reftarget.split(".")[-1]
+    elif reftarget.startswith("typing."):
+        title = reftarget[7:]
+    else:
+        title = reftarget
+
+    if reftarget == "None" or reftarget.startswith("typing."):
+        # typing module provides non-class types.  Obj reference is good to refer them.
+        reftype = "obj"
+    else:
+        reftype = "class"
+
+    return reftype, reftarget, title, refspecific
+
+
+def type_to_xref(
+    function_module: str,
+    target: str,
+    env: BuildEnvironment | None = None,
+    suppress_prefix: bool = False,
+) -> addnodes.pending_xref:
+    """Convert a type string to a cross reference node."""
+    if env:
+        kwargs = {
+            function_module + ":module": env.ref_context.get(
+                function_module + ":module"
+            ),
+            function_module + ":class": env.ref_context.get(function_module + ":class"),
+        }
+    else:
+        kwargs = {}
+
+    reftype, target, title, refspecific = parse_reftarget(target, suppress_prefix)
+    contnodes = [nodes.Text(title)]
+
+    return pending_xref(
+        "",
+        *contnodes,
+        refdomain=function_module,
+        reftype=reftype,
+        reftarget=target,
+        refspecific=refspecific,
+        **kwargs,
+    )
+
+
+def parse_annotation(
+    function_module: str, annotation: str, env: BuildEnvironment | None
+) -> list[Node]:
+    """Parse type annotation."""
+
+    def unparse(node: ast.AST) -> list[Node]:
+        if isinstance(node, ast.Attribute):
+            return [nodes.Text(f"{unparse(node.value)[0]}.{node.attr}")]
+        elif isinstance(node, ast.BinOp):
+            result: list[Node] = unparse(node.left)
+            result.extend(unparse(node.op))
+            result.extend(unparse(node.right))
+            return result
+        elif isinstance(node, ast.BitOr):
+            return [
+                addnodes.desc_sig_space(),
+                addnodes.desc_sig_punctuation("", "|"),
+                addnodes.desc_sig_space(),
+            ]
+        elif isinstance(node, ast.Constant):
+            if node.value is Ellipsis:
+                return [addnodes.desc_sig_punctuation("", "...")]
+            elif isinstance(node.value, bool):
+                return [addnodes.desc_sig_keyword("", repr(node.value))]
+            elif isinstance(node.value, int):
+                return [addnodes.desc_sig_literal_number("", repr(node.value))]
+            elif isinstance(node.value, str):
+                return [addnodes.desc_sig_literal_string("", repr(node.value))]
+            else:
+                # handles None, which is further handled by type_to_xref later
+                # and fallback for other types that should be converted
+                return [nodes.Text(repr(node.value))]
+        elif isinstance(node, ast.Expr):
+            return unparse(node.value)
+        elif isinstance(node, ast.Index):
+            return unparse(node.value)
+        elif isinstance(node, ast.Invert):
+            return [addnodes.desc_sig_punctuation("", "~")]
+        elif isinstance(node, ast.List):
+            result = [addnodes.desc_sig_punctuation("", "[")]
+            if node.elts:
+                # check if there are elements in node.elts to only pop the
+                # last element of result if the for-loop was run at least
+                # once
+                for elem in node.elts:
+                    result.extend(unparse(elem))
+                    result.append(addnodes.desc_sig_punctuation("", ","))
+                    result.append(addnodes.desc_sig_space())
+                result.pop()
+                result.pop()
+            result.append(addnodes.desc_sig_punctuation("", "]"))
+            return result
+        elif isinstance(node, ast.Module):
+            return sum((unparse(e) for e in node.body), [])
+        elif isinstance(node, ast.Name):
+            return [nodes.Text(node.id)]
+        elif isinstance(node, ast.Subscript):
+            if getattr(node.value, "id", "") in {"Optional", "Union"}:
+                return _unparse_pep_604_annotation(node)
+            result = unparse(node.value)
+            result.append(addnodes.desc_sig_punctuation("", "]"))
+            result.extend(unparse(node.slice))
+            result.append(addnodes.desc_sig_punctuation("", "]"))
+
+            # Wrap the Text nodes inside brackets by literal node if the subscript is a Literal
+            if result[0] in ("Literal", "typing.Literal"):
+                for i, subnode in enumerate(result[1:], start=1):
+                    if isinstance(subnode, nodes.Text):
+                        result[i] = nodes.literal("", "", subnode)
+            return result
+        elif isinstance(node, ast.UnaryOp):
+            return unparse(node.op) + unparse(node.operand)
+        elif isinstance(node, ast.Tuple):
+            if node.elts:
+                result = []
+                for elem in node.elts:
+                    result.extend(unparse(elem))
+                    result.append(addnodes.desc_sig_punctuation("", ","))
+                    result.append(addnodes.desc_sig_space())
+                result.pop()
+                result.pop()
+            else:
+                result = [
+                    addnodes.desc_sig_punctuation("", "("),
+                    addnodes.desc_sig_punctuation("", ")"),
+                ]
+
+            return result
+        else:
+            raise SyntaxError  # unsupported syntax
+
+    def _unparse_pep_604_annotation(node: ast.Subscript) -> list[Node]:
+        subscript = node.slice
+        if isinstance(subscript, ast.Index):
+            subscript = subscript.value  # type: ignore[assignment]
+
+        flattened: list[Node] = []
+        if isinstance(subscript, ast.Tuple):
+            flattened.extend(unparse(subscript.elts[0]))
+            for elt in subscript.elts[1:]:
+                flattened.extend(unparse(ast.BitOr()))
+                flattened.extend(unparse(elt))
+        else:
+            # e.g. a Union[] inside an Optional[]
+            flattened.extend(unparse(subscript))
+
+        if getattr(node.value, "id", "") == "Optional":
+            flattened.extend(unparse(ast.BitOr()))
+            flattened.append(nodes.Text("None"))
+
+        return flattened
+
+    try:
+        tree = ast.parse(annotation)
+        result: list[Node] = []
+        for node in unparse(tree):
+            if isinstance(node, nodes.literal):
+                result.append(node[0])
+            elif isinstance(node, nodes.Text) and node.strip():
+                if (
+                    result
+                    and isinstance(result[-1], addnodes.desc_sig_punctuation)
+                    and result[-1].astext() == "~"
+                ):
+                    result.pop()
+                    result.append(
+                        type_to_xref(
+                            function_module, str(node), env, suppress_prefix=True
+                        )
+                    )
+                else:
+                    result.append(type_to_xref(function_module, str(node), env))
+            else:
+                result.append(node)
+        return result
+    except SyntaxError:
+        return [type_to_xref(function_module, annotation, env)]
+
+
+def parse_arglist(
+    function_module: str, arglist: str, env: BuildEnvironment | None = None
+) -> addnodes.desc_parameterlist:
+    """Parse a list of arguments using AST parser"""
+    params = addnodes.desc_parameterlist(arglist)
+    sig = signature_from_str("(%s)" % arglist)
+    last_kind = None
+    for param in sig.parameters.values():
+        if param.kind != param.POSITIONAL_ONLY and last_kind == param.POSITIONAL_ONLY:
+            # PEP-570: Separator for Positional Only Parameter: /
+            params += addnodes.desc_parameter(
+                "", "", addnodes.desc_sig_operator("", "/")
+            )
+        if param.kind == param.KEYWORD_ONLY and last_kind in (
+            param.POSITIONAL_OR_KEYWORD,
+            param.POSITIONAL_ONLY,
+            None,
+        ):
+            # PEP-3102: Separator for Keyword Only Parameter: *
+            params += addnodes.desc_parameter(
+                "", "", addnodes.desc_sig_operator("", "*")
+            )
+
+        node = addnodes.desc_parameter()
+        if param.kind == param.VAR_POSITIONAL:
+            node += addnodes.desc_sig_operator("", "*")
+            node += addnodes.desc_sig_name("", param.name)
+        elif param.kind == param.VAR_KEYWORD:
+            node += addnodes.desc_sig_operator("", "**")
+            node += addnodes.desc_sig_name("", param.name)
+        else:
+            node += addnodes.desc_sig_name("", param.name)
+
+        if param.annotation is not param.empty:
+            children = parse_annotation(function_module, param.annotation, env)
+            node += addnodes.desc_sig_punctuation("", ":")
+            node += addnodes.desc_sig_space()
+            node += addnodes.desc_sig_name("", "", *children)  # type: ignore
+        if param.default is not param.empty:
+            if param.annotation is not param.empty:
+                node += addnodes.desc_sig_space()
+                node += addnodes.desc_sig_operator("", "=")
+                node += addnodes.desc_sig_space()
+            else:
+                node += addnodes.desc_sig_operator("", "=")
+            node += nodes.inline(
+                "", param.default, classes=["default_value"], support_smartquotes=False
+            )
+
+        params += node
+        last_kind = param.kind
+
+    if last_kind == Parameter.POSITIONAL_ONLY:
+        # PEP-570: Separator for Positional Only Parameter: /
+        params += addnodes.desc_parameter("", "", addnodes.desc_sig_operator("", "/"))
+
+    return params
+
+
+def pseudo_parse_arglist(signode: desc_signature, arglist: str) -> None:
+    """ "Parse" a list of arguments separated by commas.
+
+    Arguments can have "optional" annotations given by enclosing them in
+    brackets.  Currently, this will split at any comma, even if it's inside a
+    string literal (e.g. default argument value).
+    """
+    paramlist = addnodes.desc_parameterlist()
+    stack: list[Element] = [paramlist]
+    try:
+        for argument in arglist.split(","):
+            argument = argument.strip()
+            ends_open = ends_close = 0
+            while argument.startswith("["):
+                stack.append(addnodes.desc_optional())
+                stack[-2] += stack[-1]
+                argument = argument[1:].strip()
+            while argument.startswith("]"):
+                stack.pop()
+                argument = argument[1:].strip()
+            while argument.endswith("]") and not argument.endswith("[]"):
+                ends_close += 1
+                argument = argument[:-1].strip()
+            while argument.endswith("["):
+                ends_open += 1
+                argument = argument[:-1].strip()
+            if argument:
+                stack[-1] += addnodes.desc_parameter(
+                    "", "", addnodes.desc_sig_name(argument, argument)
+                )
+            while ends_open:
+                stack.append(addnodes.desc_optional())
+                stack[-2] += stack[-1]
+                ends_open -= 1
+            while ends_close:
+                stack.pop()
+                ends_close -= 1
+        if len(stack) != 1:
+            raise IndexError
+    except IndexError:
+        # if there are too few or too many elements on the stack, just give up
+        # and treat the whole argument list as one argument, discarding the
+        # already partially populated paramlist node
+        paramlist = addnodes.desc_parameterlist()
+        paramlist += addnodes.desc_parameter(arglist, arglist)
+        signode += paramlist
+    else:
+        signode += paramlist
diff --git a/velox/docs/ext/iceberg.py b/velox/docs/ext/iceberg.py
new file mode 100644
index 000000000000..1b2b746a30e1
--- /dev/null
+++ b/velox/docs/ext/iceberg.py
@@ -0,0 +1,775 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Generating iceberg function link :iceberg:func:`<name>`"""
+
+from __future__ import annotations
+
+from function import (
+    function_sig_re,
+    pairindextypes,
+    parse_arglist,
+    pseudo_parse_arglist,
+    parse_annotation,
+    ObjectEntry,
+    ModuleEntry,
+)
+from typing import Any, Iterable, Iterator, Tuple, cast
+
+from docutils import nodes
+from docutils.nodes import Element, Node
+from docutils.parsers.rst import directives
+from sphinx import addnodes
+from sphinx.addnodes import desc_signature, pending_xref
+from sphinx.application import Sphinx
+from sphinx.builders import Builder
+from sphinx.directives import ObjectDescription
+from sphinx.domains import Domain, Index, IndexEntry, ObjType
+from sphinx.environment import BuildEnvironment
+from sphinx.locale import _, __
+from sphinx.roles import XRefRole
+from sphinx.util import logging
+from sphinx.util.docfields import Field
+from sphinx.util.nodes import (
+    find_pending_xref_condition,
+    make_id,
+    make_refnode,
+)
+from sphinx.util.typing import OptionSpec
+
+logger = logging.getLogger(__name__)
+
+function_module = "iceberg"
+
+
+class IcebergObject(ObjectDescription[Tuple[str, str]]):
+    """
+    Description of a general Iceberg object.
+
+    :cvar allow_nesting: Class is an object that allows for nested namespaces
+    :vartype allow_nesting: bool
+    """
+
+    option_spec: OptionSpec = {
+        "noindex": directives.flag,
+        "noindexentry": directives.flag,
+        "nocontentsentry": directives.flag,
+        "module": directives.unchanged,
+        "canonical": directives.unchanged,
+        "annotation": directives.unchanged,
+    }
+
+    doc_field_types = [
+        Field(
+            "returnvalue",
+            label=_("Returns"),
+            has_arg=False,
+            names=("returns", "return"),
+        ),
+    ]
+
+    allow_nesting = False
+
+    def get_signature_prefix(self, sig: str) -> list[nodes.Node]:
+        """May return a prefix to put before the object name in the
+        signature.
+        """
+        return []
+
+    def needs_arglist(self) -> bool:
+        """May return true if an empty argument list is to be generated even if
+        the document contains none.
+        """
+        return False
+
+    def handle_signature(self, sig: str, signode: desc_signature) -> tuple[str, str]:
+        """Transform a Iceberg signature into RST nodes.
+        Return (fully qualified name of the thing, classname if any).
+        If inside a class, the current class name is handled intelligently:
+        * it is stripped from the displayed name if present
+        * it is added to the full name (return value) if not present
+        """
+        m = function_sig_re.match(sig)
+        if m is None:
+            raise ValueError
+        prefix, name, arglist, retann = m.groups()
+
+        # determine module and class name (if applicable), as well as full name
+        modname = self.options.get("module", self.env.ref_context.get("iceberg:module"))
+        classname = self.env.ref_context.get("iceberg:class")
+        if classname:
+            add_module = False
+            if prefix and (prefix == classname or prefix.startswith(classname + ".")):
+                fullname = prefix + name
+                # class name is given again in the signature
+                prefix = prefix[len(classname) :].lstrip(".")
+            elif prefix:
+                # class name is given in the signature, but different
+                # (shouldn't happen)
+                fullname = classname + "." + prefix + name
+            else:
+                # class name is not given in the signature
+                fullname = classname + "." + name
+        else:
+            add_module = True
+            if prefix:
+                classname = prefix.rstrip(".")
+                fullname = prefix + name
+            else:
+                classname = ""
+                fullname = name
+
+        signode["module"] = modname
+        signode["class"] = classname
+        signode["fullname"] = fullname
+
+        sig_prefix = self.get_signature_prefix(sig)
+        if sig_prefix:
+            if type(sig_prefix) is str:
+                raise TypeError(
+                    "Python directive method get_signature_prefix()"
+                    " must return a list of nodes."
+                    f" Return value was '{sig_prefix}'."
+                )
+            else:
+                signode += addnodes.desc_annotation(str(sig_prefix), "", *sig_prefix)
+
+        if prefix:
+            signode += addnodes.desc_addname(prefix, prefix)
+        elif modname and add_module and self.env.config.add_module_names:
+            nodetext = modname + "."
+            signode += addnodes.desc_addname(nodetext, nodetext)
+
+        signode += addnodes.desc_name(name, name)
+        if arglist:
+            try:
+                signode += parse_arglist(function_module, arglist, self.env)
+            except SyntaxError:
+                # fallback to parse arglist original parser.
+                # it supports to represent optional arguments (ex. "func(foo [, bar])")
+                pseudo_parse_arglist(signode, arglist)
+            except NotImplementedError as exc:
+                logger.warning(
+                    "could not parse arglist (%r): %s", arglist, exc, location=signode
+                )
+                pseudo_parse_arglist(signode, arglist)
+        else:
+            if self.needs_arglist():
+                # for callables, add an empty parameter list
+                signode += addnodes.desc_parameterlist()
+
+        if retann:
+            children = parse_annotation(function_module, retann, self.env)
+            signode += addnodes.desc_returns(retann, "", *children)
+
+        anno = self.options.get("annotation")
+        if anno:
+            signode += addnodes.desc_annotation(
+                " " + anno, "", addnodes.desc_sig_space(), nodes.Text(anno)
+            )
+
+        return fullname, prefix
+
+    def _object_hierarchy_parts(self, sig_node: desc_signature) -> tuple[str, ...]:
+        if "fullname" not in sig_node:
+            return ()
+        modname = sig_node.get("module")
+        fullname = sig_node["fullname"]
+
+        if modname:
+            return (modname, *fullname.split("."))
+        else:
+            return tuple(fullname.split("."))
+
+    def get_index_text(self, modname: str, name: tuple[str, str]) -> str:
+        """Return the text for the index entry of the object."""
+        raise NotImplementedError("must be implemented in subclasses")
+
+    def add_target_and_index(
+        self, name_cls: tuple[str, str], sig: str, signode: desc_signature
+    ) -> None:
+        modname = self.options.get("module", self.env.ref_context.get("iceberg:module"))
+        fullname = (modname + "." if modname else "") + name_cls[0]
+        node_id = make_id(self.env, self.state.document, "", fullname)
+        signode["ids"].append(node_id)
+        self.state.document.note_explicit_target(signode)
+
+        domain = cast(IcebergDomain, self.env.get_domain("iceberg"))
+        domain.note_object(fullname, self.objtype, node_id, location=signode)
+
+        canonical_name = self.options.get("canonical")
+        if canonical_name:
+            domain.note_object(
+                canonical_name, self.objtype, node_id, aliased=True, location=signode
+            )
+
+        if "noindexentry" not in self.options:
+            indextext = self.get_index_text(modname, name_cls)
+            if indextext:
+                self.indexnode["entries"].append(
+                    ("single", indextext, node_id, "", None)
+                )
+
+    def before_content(self) -> None:
+        """Handle object nesting before content
+
+        For constructs that aren't nestable, the stack is bypassed, and instead
+        only the most recent object is tracked. This object prefix name will be
+        removed with :iceberg:meth:`after_content`.
+        """
+        prefix = None
+        if self.names:
+            # fullname and name_prefix come from the `handle_signature` method.
+            # fullname represents the full object name that is constructed using
+            # object nesting and explicit prefixes. `name_prefix` is the
+            # explicit prefix given in a signature
+            (fullname, name_prefix) = self.names[-1]
+            if self.allow_nesting:
+                prefix = fullname
+            elif name_prefix:
+                prefix = name_prefix.strip(".")
+        if prefix:
+            self.env.ref_context["iceberg:class"] = prefix
+            if self.allow_nesting:
+                classes = self.env.ref_context.setdefault("iceberg:classes", [])
+                classes.append(prefix)
+        if "module" in self.options:
+            modules = self.env.ref_context.setdefault("iceberg:modules", [])
+            modules.append(self.env.ref_context.get("iceberg:module"))
+            self.env.ref_context["iceberg:module"] = self.options["module"]
+
+    def after_content(self) -> None:
+        """Handle object de-nesting after content
+
+        If this class is a nestable object, removing the last nested class prefix
+        ends further nesting in the object.
+
+        If this class is not a nestable object, the list of classes should not
+        be altered as we didn't affect the nesting levels in
+        :iceberg:meth:`before_content`.
+        """
+        classes = self.env.ref_context.setdefault("iceberg:classes", [])
+        if self.allow_nesting:
+            try:
+                classes.pop()
+            except IndexError:
+                pass
+        self.env.ref_context["iceberg:class"] = (
+            classes[-1] if len(classes) > 0 else None
+        )
+        if "module" in self.options:
+            modules = self.env.ref_context.setdefault("iceberg:modules", [])
+            if modules:
+                self.env.ref_context["iceberg:module"] = modules.pop()
+            else:
+                self.env.ref_context.pop("iceberg:module")
+
+    def _toc_entry_name(self, sig_node: desc_signature) -> str:
+        if not sig_node.get("_toc_parts"):
+            return ""
+
+        config = self.env.app.config
+        objtype = sig_node.parent.get("objtype")
+        if config.add_function_parentheses and objtype in {"function", "method"}:
+            parens = "()"
+        else:
+            parens = ""
+        *parents, name = sig_node["_toc_parts"]
+        if config.toc_object_entries_show_parents == "domain":
+            return sig_node.get("fullname", name) + parens
+        if config.toc_object_entries_show_parents == "hide":
+            return name + parens
+        if config.toc_object_entries_show_parents == "all":
+            return ".".join(parents + [name + parens])
+        return ""
+
+
+class IcebergFunction(IcebergObject):
+    """Description of a function."""
+
+    option_spec: OptionSpec = IcebergObject.option_spec.copy()
+    option_spec.update(
+        {
+            "async": directives.flag,
+        }
+    )
+
+    def get_signature_prefix(self, sig: str) -> list[nodes.Node]:
+        if "async" in self.options:
+            return [addnodes.desc_sig_keyword("", "async"), addnodes.desc_sig_space()]
+        else:
+            return []
+
+    def needs_arglist(self) -> bool:
+        return True
+
+    def add_target_and_index(
+        self, name_cls: tuple[str, str], sig: str, signode: desc_signature
+    ) -> None:
+        super().add_target_and_index(name_cls, sig, signode)
+        if "noindexentry" not in self.options:
+            modname = self.options.get(
+                "module", self.env.ref_context.get("iceberg:module")
+            )
+            node_id = signode["ids"][0]
+
+            name, cls = name_cls
+            if modname:
+                text = _("%s() (in module %s)") % (name, modname)
+                self.indexnode["entries"].append(("single", text, node_id, "", None))
+            else:
+                text = f"{pairindextypes['builtin']}; {name}()"
+                self.indexnode["entries"].append(("pair", text, node_id, "", None))
+
+    def get_index_text(self, modname: str, name_cls: tuple[str, str]) -> str | None:
+        # add index in own add_target_and_index() instead.
+        return None
+
+
+class IcebergXRefRole(XRefRole):
+    def process_link(
+        self,
+        env: BuildEnvironment,
+        refnode: Element,
+        has_explicit_title: bool,
+        title: str,
+        target: str,
+    ) -> tuple[str, str]:
+        refnode["iceberg:module"] = env.ref_context.get("iceberg:module")
+        refnode["iceberg:class"] = env.ref_context.get("iceberg:class")
+        if not has_explicit_title:
+            title = title.lstrip(".")  # only has a meaning for the target
+            target = target.lstrip("~")  # only has a meaning for the title
+            # if the first character is a tilde, don't display the module/class
+            # parts of the contents
+            if title[0:1] == "~":
+                title = title[1:]
+                dot = title.rfind(".")
+                if dot != -1:
+                    title = title[dot + 1 :]
+        # if the first character is a dot, search more specific namespaces first
+        # else search builtins first
+        if target[0:1] == ".":
+            target = target[1:]
+            refnode["refspecific"] = True
+        return title, target
+
+
+class IcebergModuleIndex(Index):
+    """
+    Index subclass to provide the Iceberg module index.
+    """
+
+    name = "modindex"
+    localname = _("Iceberg Module Index")
+    shortname = _("modules")
+
+    def generate(
+        self, docnames: Iterable[str] | None = None
+    ) -> tuple[list[tuple[str, list[IndexEntry]]], bool]:
+        content: dict[str, list[IndexEntry]] = {}
+        # list of prefixes to ignore
+        ignores: list[str] = self.domain.env.config["modindex_common_prefix"]
+        ignores = sorted(ignores, key=len, reverse=True)
+        # list of all modules, sorted by module name
+        modules = sorted(
+            self.domain.data["modules"].items(), key=lambda x: x[0].lower()
+        )
+        # sort out collapsible modules
+        prev_modname = ""
+        num_toplevels = 0
+        for modname, (docname, node_id, synopsis, platforms, deprecated) in modules:
+            if docnames and docname not in docnames:
+                continue
+
+            for ignore in ignores:
+                if modname.startswith(ignore):
+                    modname = modname[len(ignore) :]
+                    stripped = ignore
+                    break
+            else:
+                stripped = ""
+
+            # we stripped the whole module name?
+            if not modname:
+                modname, stripped = stripped, ""
+
+            entries = content.setdefault(modname[0].lower(), [])
+
+            package = modname.split(".")[0]
+            if package != modname:
+                # it's a submodule
+                if prev_modname == package:
+                    # first submodule - make parent a group head
+                    if entries:
+                        last = entries[-1]
+                        entries[-1] = IndexEntry(
+                            last[0], 1, last[2], last[3], last[4], last[5], last[6]
+                        )
+                elif not prev_modname.startswith(package):
+                    # submodule without parent in list, add dummy entry
+                    entries.append(
+                        IndexEntry(stripped + package, 1, "", "", "", "", "")
+                    )
+                subtype = 2
+            else:
+                num_toplevels += 1
+                subtype = 0
+
+            qualifier = _("Deprecated") if deprecated else ""
+            entries.append(
+                IndexEntry(
+                    stripped + modname,
+                    subtype,
+                    docname,
+                    node_id,
+                    platforms,
+                    qualifier,
+                    synopsis,
+                )
+            )
+            prev_modname = modname
+
+        # apply heuristics when to collapse modindex at page load:
+        # only collapse if number of toplevel modules is larger than
+        # number of submodules
+        collapse = len(modules) - num_toplevels < num_toplevels
+
+        # sort by first letter
+        sorted_content = sorted(content.items())
+
+        return sorted_content, collapse
+
+
+class IcebergDomain(Domain):
+    """Iceberg domain."""
+
+    name = "iceberg"
+    label = "Iceberg"
+    object_types: dict[str, ObjType] = {
+        "function": ObjType(_("function"), "func", "obj"),
+    }
+
+    directives = {
+        "function": IcebergFunction,
+    }
+    roles = {
+        "func": IcebergXRefRole(fix_parens=True),
+    }
+    initial_data: dict[str, dict[str, tuple[Any]]] = {
+        "objects": {},  # fullname -> docname, objtype
+        "modules": {},  # modname -> docname, synopsis, platform, deprecated
+    }
+    indices = [
+        IcebergModuleIndex,
+    ]
+
+    @property
+    def objects(self) -> dict[str, ObjectEntry]:
+        return self.data.setdefault("objects", {})  # fullname -> ObjectEntry
+
+    def note_object(
+        self,
+        name: str,
+        objtype: str,
+        node_id: str,
+        aliased: bool = False,
+        location: Any = None,
+    ) -> None:
+        """Note a iceberg object for cross reference.
+
+        .. versionadded:: 2.1
+        """
+        if name in self.objects:
+            other = self.objects[name]
+            if other.aliased and aliased is False:
+                # The original definition found. Override it!
+                pass
+            elif other.aliased is False and aliased:
+                # The original definition is already registered.
+                return
+            else:
+                # duplicated
+                logger.warning(
+                    __(
+                        "duplicate object description of %s, "
+                        "other instance in %s, use :noindex: for one of them"
+                    ),
+                    name,
+                    other.docname,
+                    location=location,
+                )
+        self.objects[name] = ObjectEntry(self.env.docname, node_id, objtype, aliased)
+
+    @property
+    def modules(self) -> dict[str, ModuleEntry]:
+        return self.data.setdefault("modules", {})  # modname -> ModuleEntry
+
+    def note_module(
+        self, name: str, node_id: str, synopsis: str, platform: str, deprecated: bool
+    ) -> None:
+        """Note a iceberg module for cross reference.
+
+        .. versionadded:: 2.1
+        """
+        self.modules[name] = ModuleEntry(
+            self.env.docname, node_id, synopsis, platform, deprecated
+        )
+
+    def clear_doc(self, docname: str) -> None:
+        for fullname, obj in list(self.objects.items()):
+            if obj.docname == docname:
+                del self.objects[fullname]
+        for modname, mod in list(self.modules.items()):
+            if mod.docname == docname:
+                del self.modules[modname]
+
+    def merge_domaindata(self, docnames: list[str], otherdata: dict[str, Any]) -> None:
+        # XXX check duplicates?
+        for fullname, obj in otherdata["objects"].items():
+            if obj.docname in docnames:
+                self.objects[fullname] = obj
+        for modname, mod in otherdata["modules"].items():
+            if mod.docname in docnames:
+                self.modules[modname] = mod
+
+    def find_obj(
+        self,
+        env: BuildEnvironment,
+        modname: str,
+        classname: str,
+        name: str,
+        type: str | None,
+        searchmode: int = 0,
+    ) -> list[tuple[str, ObjectEntry]]:
+        """Find a Iceberg object for "name", perhaps using the given module
+        and/or classname.  Returns a list of (name, object entry) tuples.
+        """
+        # skip parens
+        if name[-2:] == "()":
+            name = name[:-2]
+
+        if not name:
+            return []
+
+        matches: list[tuple[str, ObjectEntry]] = []
+
+        newname = None
+        if searchmode == 1:
+            if type is None:
+                objtypes = list(self.object_types)
+            else:
+                objtypes = self.objtypes_for_role(type)
+            if objtypes is not None:
+                if modname and classname:
+                    fullname = modname + "." + classname + "." + name
+                    if (
+                        fullname in self.objects
+                        and self.objects[fullname].objtype in objtypes
+                    ):
+                        newname = fullname
+                if not newname:
+                    if (
+                        modname
+                        and modname + "." + name in self.objects
+                        and self.objects[modname + "." + name].objtype in objtypes
+                    ):
+                        newname = modname + "." + name
+                    elif (
+                        name in self.objects and self.objects[name].objtype in objtypes
+                    ):
+                        newname = name
+                    else:
+                        # "fuzzy" searching mode
+                        searchname = "." + name
+                        matches = [
+                            (oname, self.objects[oname])
+                            for oname in self.objects
+                            if oname.endswith(searchname)
+                            and self.objects[oname].objtype in objtypes
+                        ]
+        else:
+            # NOTE: searching for exact match, object type is not considered
+            if name in self.objects:
+                newname = name
+            elif type == "mod":
+                # only exact matches allowed for modules
+                return []
+            elif classname and classname + "." + name in self.objects:
+                newname = classname + "." + name
+            elif modname and modname + "." + name in self.objects:
+                newname = modname + "." + name
+            elif (
+                modname
+                and classname
+                and modname + "." + classname + "." + name in self.objects
+            ):
+                newname = modname + "." + classname + "." + name
+        if newname is not None:
+            matches.append((newname, self.objects[newname]))
+        return matches
+
+    def resolve_xref(
+        self,
+        env: BuildEnvironment,
+        fromdocname: str,
+        builder: Builder,
+        type: str,
+        target: str,
+        node: pending_xref,
+        contnode: Element,
+    ) -> Element | None:
+        modname = node.get("iceberg:module")
+        clsname = node.get("iceberg:class")
+        searchmode = 1 if node.hasattr("refspecific") else 0
+        matches = self.find_obj(env, modname, clsname, target, type, searchmode)
+
+        if not matches and type == "attr":
+            # fallback to meth (for property; Sphinx-2.4.x)
+            # this ensures that `:attr:` role continues to refer to the old property entry
+            # that defined by ``method`` directive in old reST files.
+            matches = self.find_obj(env, modname, clsname, target, "meth", searchmode)
+        if not matches and type == "meth":
+            # fallback to attr (for property)
+            # this ensures that `:meth:` in the old reST files can refer to the property
+            # entry that defined by ``property`` directive.
+            #
+            # Note: _prop is a secret role only for internal look-up.
+            matches = self.find_obj(env, modname, clsname, target, "_prop", searchmode)
+
+        if not matches:
+            return None
+        elif len(matches) > 1:
+            canonicals = [m for m in matches if not m[1].aliased]
+            if len(canonicals) == 1:
+                matches = canonicals
+            else:
+                logger.warning(
+                    __("more than one target found for cross-reference %r: %s"),
+                    target,
+                    ", ".join(match[0] for match in matches),
+                    type="ref",
+                    subtype="python",
+                    location=node,
+                )
+        name, obj = matches[0]
+
+        if obj[2] == "module":
+            return self._make_module_refnode(builder, fromdocname, name, contnode)
+        else:
+            # determine the content of the reference by conditions
+            content = find_pending_xref_condition(node, "resolved")
+            if content:
+                children = content.children
+            else:
+                # if not found, use contnode
+                children = [contnode]
+
+            return make_refnode(builder, fromdocname, obj[0], obj[1], children, name)
+
+    def resolve_any_xref(
+        self,
+        env: BuildEnvironment,
+        fromdocname: str,
+        builder: Builder,
+        target: str,
+        node: pending_xref,
+        contnode: Element,
+    ) -> list[tuple[str, Element]]:
+        modname = node.get("iceberg:module")
+        clsname = node.get("iceberg:class")
+        results: list[tuple[str, Element]] = []
+
+        # always search in "refspecific" mode with the :any: role
+        matches = self.find_obj(env, modname, clsname, target, None, 1)
+        multiple_matches = len(matches) > 1
+
+        for name, obj in matches:
+            if multiple_matches and obj.aliased:
+                # Skip duplicated matches
+                continue
+
+            if obj[2] == "module":
+                results.append(
+                    (
+                        "iceberg:mod",
+                        self._make_module_refnode(builder, fromdocname, name, contnode),
+                    )
+                )
+            else:
+                # determine the content of the reference by conditions
+                content = find_pending_xref_condition(node, "resolved")
+                if content:
+                    children = content.children
+                else:
+                    # if not found, use contnode
+                    children = [contnode]
+
+                results.append(
+                    (
+                        "iceberg:" + self.role_for_objtype(obj[2]),
+                        make_refnode(
+                            builder, fromdocname, obj[0], obj[1], children, name
+                        ),
+                    )
+                )
+        return results
+
+    def _make_module_refnode(
+        self, builder: Builder, fromdocname: str, name: str, contnode: Node
+    ) -> Element:
+        # get additional info for modules
+        module = self.modules[name]
+        title = name
+        if module.synopsis:
+            title += ": " + module.synopsis
+        if module.deprecated:
+            title += _(" (deprecated)")
+        if module.platform:
+            title += " (" + module.platform + ")"
+        return make_refnode(
+            builder, fromdocname, module.docname, module.node_id, contnode, title
+        )
+
+    def get_objects(self) -> Iterator[tuple[str, str, str, str, str, int]]:
+        for modname, mod in self.modules.items():
+            yield (modname, modname, "module", mod.docname, mod.node_id, 0)
+        for refname, obj in self.objects.items():
+            if obj.objtype != "module":  # modules are already handled
+                if obj.aliased:
+                    # aliased names are not full-text searchable.
+                    yield (refname, refname, obj.objtype, obj.docname, obj.node_id, -1)
+                else:
+                    yield (refname, refname, obj.objtype, obj.docname, obj.node_id, 1)
+
+    def get_full_qualified_name(self, node: Element) -> str | None:
+        modname = node.get("iceberg:module")
+        clsname = node.get("iceberg:class")
+        target = node.get("reftarget")
+        if target is None:
+            return None
+        else:
+            return ".".join(filter(None, [modname, clsname, target]))
+
+
+def setup(app: Sphinx) -> dict[str, Any]:
+    app.setup_extension("sphinx.directives")
+    app.add_domain(IcebergDomain)
+
+    return {
+        "version": "builtin",
+        "env_version": 3,
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }
diff --git a/velox/docs/ext/spark.py b/velox/docs/ext/spark.py
index 134a882db99f..8781aee89418 100644
--- a/velox/docs/ext/spark.py
+++ b/velox/docs/ext/spark.py
@@ -16,10 +16,16 @@
 
 from __future__ import annotations
 
-import ast
-import re
-from inspect import Parameter
-from typing import Any, Iterable, Iterator, NamedTuple, Tuple, cast
+from function import (
+    function_sig_re,
+    pairindextypes,
+    parse_arglist,
+    pseudo_parse_arglist,
+    parse_annotation,
+    ObjectEntry,
+    ModuleEntry,
+)
+from typing import Any, Iterable, Iterator, Tuple, cast
 
 from docutils import nodes
 from docutils.nodes import Element, Node
@@ -35,7 +41,6 @@
 from sphinx.roles import XRefRole
 from sphinx.util import logging
 from sphinx.util.docfields import Field
-from sphinx.util.inspect import signature_from_str
 from sphinx.util.nodes import (
     find_pending_xref_condition,
     make_id,
@@ -45,338 +50,7 @@
 
 logger = logging.getLogger(__name__)
 
-
-# REs for Spark signatures
-spark_sig_re = re.compile(
-    r"""^ ([\w.]*\.)?            # class name(s)
-          (\w+)  \s*             # thing name
-          (?: \(\s*(.*)\s*\)     # optional: arguments
-           (?:\s* -> \s* (.*))?  #           return annotation
-          )? $                   # and nothing more
-          """,
-    re.VERBOSE,
-)
-
-pairindextypes = {
-    "module": _("module"),
-    "keyword": _("keyword"),
-    "operator": _("operator"),
-    "object": _("object"),
-    "exception": _("exception"),
-    "statement": _("statement"),
-    "builtin": _("built-in function"),
-}
-
-
-class ObjectEntry(NamedTuple):
-    docname: str
-    node_id: str
-    objtype: str
-    aliased: bool
-
-
-class ModuleEntry(NamedTuple):
-    docname: str
-    node_id: str
-    synopsis: str
-    platform: str
-    deprecated: bool
-
-
-def parse_reftarget(
-    reftarget: str, suppress_prefix: bool = False
-) -> tuple[str, str, str, bool]:
-    """Parse a type string and return (reftype, reftarget, title, refspecific flag)"""
-    refspecific = False
-    if reftarget.startswith("."):
-        reftarget = reftarget[1:]
-        title = reftarget
-        refspecific = True
-    elif reftarget.startswith("~"):
-        reftarget = reftarget[1:]
-        title = reftarget.split(".")[-1]
-    elif suppress_prefix:
-        title = reftarget.split(".")[-1]
-    elif reftarget.startswith("typing."):
-        title = reftarget[7:]
-    else:
-        title = reftarget
-
-    if reftarget == "None" or reftarget.startswith("typing."):
-        # typing module provides non-class types.  Obj reference is good to refer them.
-        reftype = "obj"
-    else:
-        reftype = "class"
-
-    return reftype, reftarget, title, refspecific
-
-
-def type_to_xref(
-    target: str, env: BuildEnvironment | None = None, suppress_prefix: bool = False
-) -> addnodes.pending_xref:
-    """Convert a type string to a cross reference node."""
-    if env:
-        kwargs = {
-            "spark:module": env.ref_context.get("spark:module"),
-            "spark:class": env.ref_context.get("spark:class"),
-        }
-    else:
-        kwargs = {}
-
-    reftype, target, title, refspecific = parse_reftarget(target, suppress_prefix)
-    contnodes = [nodes.Text(title)]
-
-    return pending_xref(
-        "",
-        *contnodes,
-        refdomain="spark",
-        reftype=reftype,
-        reftarget=target,
-        refspecific=refspecific,
-        **kwargs,
-    )
-
-
-def _parse_annotation(annotation: str, env: BuildEnvironment | None) -> list[Node]:
-    """Parse type annotation."""
-
-    def unparse(node: ast.AST) -> list[Node]:
-        if isinstance(node, ast.Attribute):
-            return [nodes.Text(f"{unparse(node.value)[0]}.{node.attr}")]
-        elif isinstance(node, ast.BinOp):
-            result: list[Node] = unparse(node.left)
-            result.extend(unparse(node.op))
-            result.extend(unparse(node.right))
-            return result
-        elif isinstance(node, ast.BitOr):
-            return [
-                addnodes.desc_sig_space(),
-                addnodes.desc_sig_punctuation("", "|"),
-                addnodes.desc_sig_space(),
-            ]
-        elif isinstance(node, ast.Constant):
-            if node.value is Ellipsis:
-                return [addnodes.desc_sig_punctuation("", "...")]
-            elif isinstance(node.value, bool):
-                return [addnodes.desc_sig_keyword("", repr(node.value))]
-            elif isinstance(node.value, int):
-                return [addnodes.desc_sig_literal_number("", repr(node.value))]
-            elif isinstance(node.value, str):
-                return [addnodes.desc_sig_literal_string("", repr(node.value))]
-            else:
-                # handles None, which is further handled by type_to_xref later
-                # and fallback for other types that should be converted
-                return [nodes.Text(repr(node.value))]
-        elif isinstance(node, ast.Expr):
-            return unparse(node.value)
-        elif isinstance(node, ast.Index):
-            return unparse(node.value)
-        elif isinstance(node, ast.Invert):
-            return [addnodes.desc_sig_punctuation("", "~")]
-        elif isinstance(node, ast.List):
-            result = [addnodes.desc_sig_punctuation("", "[")]
-            if node.elts:
-                # check if there are elements in node.elts to only pop the
-                # last element of result if the for-loop was run at least
-                # once
-                for elem in node.elts:
-                    result.extend(unparse(elem))
-                    result.append(addnodes.desc_sig_punctuation("", ","))
-                    result.append(addnodes.desc_sig_space())
-                result.pop()
-                result.pop()
-            result.append(addnodes.desc_sig_punctuation("", "]"))
-            return result
-        elif isinstance(node, ast.Module):
-            return sum((unparse(e) for e in node.body), [])
-        elif isinstance(node, ast.Name):
-            return [nodes.Text(node.id)]
-        elif isinstance(node, ast.Subscript):
-            if getattr(node.value, "id", "") in {"Optional", "Union"}:
-                return _unparse_pep_604_annotation(node)
-            result = unparse(node.value)
-            result.append(addnodes.desc_sig_punctuation("", "]"))
-            result.extend(unparse(node.slice))
-            result.append(addnodes.desc_sig_punctuation("", "]"))
-
-            # Wrap the Text nodes inside brackets by literal node if the subscript is a Literal
-            if result[0] in ("Literal", "typing.Literal"):
-                for i, subnode in enumerate(result[1:], start=1):
-                    if isinstance(subnode, nodes.Text):
-                        result[i] = nodes.literal("", "", subnode)
-            return result
-        elif isinstance(node, ast.UnaryOp):
-            return unparse(node.op) + unparse(node.operand)
-        elif isinstance(node, ast.Tuple):
-            if node.elts:
-                result = []
-                for elem in node.elts:
-                    result.extend(unparse(elem))
-                    result.append(addnodes.desc_sig_punctuation("", ","))
-                    result.append(addnodes.desc_sig_space())
-                result.pop()
-                result.pop()
-            else:
-                result = [
-                    addnodes.desc_sig_punctuation("", "("),
-                    addnodes.desc_sig_punctuation("", ")"),
-                ]
-
-            return result
-        else:
-            raise SyntaxError  # unsupported syntax
-
-    def _unparse_pep_604_annotation(node: ast.Subscript) -> list[Node]:
-        subscript = node.slice
-        if isinstance(subscript, ast.Index):
-            subscript = subscript.value  # type: ignore[assignment]
-
-        flattened: list[Node] = []
-        if isinstance(subscript, ast.Tuple):
-            flattened.extend(unparse(subscript.elts[0]))
-            for elt in subscript.elts[1:]:
-                flattened.extend(unparse(ast.BitOr()))
-                flattened.extend(unparse(elt))
-        else:
-            # e.g. a Union[] inside an Optional[]
-            flattened.extend(unparse(subscript))
-
-        if getattr(node.value, "id", "") == "Optional":
-            flattened.extend(unparse(ast.BitOr()))
-            flattened.append(nodes.Text("None"))
-
-        return flattened
-
-    try:
-        tree = ast.parse(annotation)
-        result: list[Node] = []
-        for node in unparse(tree):
-            if isinstance(node, nodes.literal):
-                result.append(node[0])
-            elif isinstance(node, nodes.Text) and node.strip():
-                if (
-                    result
-                    and isinstance(result[-1], addnodes.desc_sig_punctuation)
-                    and result[-1].astext() == "~"
-                ):
-                    result.pop()
-                    result.append(type_to_xref(str(node), env, suppress_prefix=True))
-                else:
-                    result.append(type_to_xref(str(node), env))
-            else:
-                result.append(node)
-        return result
-    except SyntaxError:
-        return [type_to_xref(annotation, env)]
-
-
-def _parse_arglist(
-    arglist: str, env: BuildEnvironment | None = None
-) -> addnodes.desc_parameterlist:
-    """Parse a list of arguments using AST parser"""
-    params = addnodes.desc_parameterlist(arglist)
-    sig = signature_from_str("(%s)" % arglist)
-    last_kind = None
-    for param in sig.parameters.values():
-        if param.kind != param.POSITIONAL_ONLY and last_kind == param.POSITIONAL_ONLY:
-            # PEP-570: Separator for Positional Only Parameter: /
-            params += addnodes.desc_parameter(
-                "", "", addnodes.desc_sig_operator("", "/")
-            )
-        if param.kind == param.KEYWORD_ONLY and last_kind in (
-            param.POSITIONAL_OR_KEYWORD,
-            param.POSITIONAL_ONLY,
-            None,
-        ):
-            # PEP-3102: Separator for Keyword Only Parameter: *
-            params += addnodes.desc_parameter(
-                "", "", addnodes.desc_sig_operator("", "*")
-            )
-
-        node = addnodes.desc_parameter()
-        if param.kind == param.VAR_POSITIONAL:
-            node += addnodes.desc_sig_operator("", "*")
-            node += addnodes.desc_sig_name("", param.name)
-        elif param.kind == param.VAR_KEYWORD:
-            node += addnodes.desc_sig_operator("", "**")
-            node += addnodes.desc_sig_name("", param.name)
-        else:
-            node += addnodes.desc_sig_name("", param.name)
-
-        if param.annotation is not param.empty:
-            children = _parse_annotation(param.annotation, env)
-            node += addnodes.desc_sig_punctuation("", ":")
-            node += addnodes.desc_sig_space()
-            node += addnodes.desc_sig_name("", "", *children)  # type: ignore
-        if param.default is not param.empty:
-            if param.annotation is not param.empty:
-                node += addnodes.desc_sig_space()
-                node += addnodes.desc_sig_operator("", "=")
-                node += addnodes.desc_sig_space()
-            else:
-                node += addnodes.desc_sig_operator("", "=")
-            node += nodes.inline(
-                "", param.default, classes=["default_value"], support_smartquotes=False
-            )
-
-        params += node
-        last_kind = param.kind
-
-    if last_kind == Parameter.POSITIONAL_ONLY:
-        # PEP-570: Separator for Positional Only Parameter: /
-        params += addnodes.desc_parameter("", "", addnodes.desc_sig_operator("", "/"))
-
-    return params
-
-
-def _pseudo_parse_arglist(signode: desc_signature, arglist: str) -> None:
-    """ "Parse" a list of arguments separated by commas.
-
-    Arguments can have "optional" annotations given by enclosing them in
-    brackets.  Currently, this will split at any comma, even if it's inside a
-    string literal (e.g. default argument value).
-    """
-    paramlist = addnodes.desc_parameterlist()
-    stack: list[Element] = [paramlist]
-    try:
-        for argument in arglist.split(","):
-            argument = argument.strip()
-            ends_open = ends_close = 0
-            while argument.startswith("["):
-                stack.append(addnodes.desc_optional())
-                stack[-2] += stack[-1]
-                argument = argument[1:].strip()
-            while argument.startswith("]"):
-                stack.pop()
-                argument = argument[1:].strip()
-            while argument.endswith("]") and not argument.endswith("[]"):
-                ends_close += 1
-                argument = argument[:-1].strip()
-            while argument.endswith("["):
-                ends_open += 1
-                argument = argument[:-1].strip()
-            if argument:
-                stack[-1] += addnodes.desc_parameter(
-                    "", "", addnodes.desc_sig_name(argument, argument)
-                )
-            while ends_open:
-                stack.append(addnodes.desc_optional())
-                stack[-2] += stack[-1]
-                ends_open -= 1
-            while ends_close:
-                stack.pop()
-                ends_close -= 1
-        if len(stack) != 1:
-            raise IndexError
-    except IndexError:
-        # if there are too few or too many elements on the stack, just give up
-        # and treat the whole argument list as one argument, discarding the
-        # already partially populated paramlist node
-        paramlist = addnodes.desc_parameterlist()
-        paramlist += addnodes.desc_parameter(arglist, arglist)
-        signode += paramlist
-    else:
-        signode += paramlist
+function_module = "spark"
 
 
 class SparkObject(ObjectDescription[Tuple[str, str]]):
@@ -426,7 +100,7 @@ def handle_signature(self, sig: str, signode: desc_signature) -> tuple[str, str]
         * it is stripped from the displayed name if present
         * it is added to the full name (return value) if not present
         """
-        m = spark_sig_re.match(sig)
+        m = function_sig_re.match(sig)
         if m is None:
             raise ValueError
         prefix, name, arglist, retann = m.groups()
@@ -480,23 +154,23 @@ def handle_signature(self, sig: str, signode: desc_signature) -> tuple[str, str]
         signode += addnodes.desc_name(name, name)
         if arglist:
             try:
-                signode += _parse_arglist(arglist, self.env)
+                signode += parse_arglist(function_module, arglist, self.env)
             except SyntaxError:
                 # fallback to parse arglist original parser.
                 # it supports to represent optional arguments (ex. "func(foo [, bar])")
-                _pseudo_parse_arglist(signode, arglist)
+                pseudo_parse_arglist(signode, arglist)
             except NotImplementedError as exc:
                 logger.warning(
                     "could not parse arglist (%r): %s", arglist, exc, location=signode
                 )
-                _pseudo_parse_arglist(signode, arglist)
+                pseudo_parse_arglist(signode, arglist)
         else:
             if self.needs_arglist():
                 # for callables, add an empty parameter list
                 signode += addnodes.desc_parameterlist()
 
         if retann:
-            children = _parse_annotation(retann, self.env)
+            children = parse_annotation(function_module, retann, self.env)
             signode += addnodes.desc_returns(retann, "", *children)
 
         anno = self.options.get("annotation")
diff --git a/velox/docs/functions.rst b/velox/docs/functions.rst
index 9c9baa9e849f..38dc1b24c9af 100644
--- a/velox/docs/functions.rst
+++ b/velox/docs/functions.rst
@@ -21,7 +21,12 @@ Presto Functions
     functions/presto/aggregate
     functions/presto/window
     functions/presto/hyperloglog
+    functions/presto/tdigest
+    functions/presto/qdigest
+    functions/presto/geospatial
+    functions/presto/ipaddress
     functions/presto/uuid
+    functions/presto/enum
     functions/presto/misc
 
 Here is a list of all scalar and aggregate Presto functions available in Velox.
@@ -62,99 +67,143 @@ for :doc:`all <functions/presto/coverage>` and :doc:`most used
     :widths: auto
     :class: rows
 
-    ========================================  ========================================  ========================================  ==  ========================================  ==  ========================================
-    Scalar Functions                                                                                                                  Aggregate Functions                           Window Functions
-    ============================================================================================================================  ==  ========================================  ==  ========================================
-    :func:`$internal$split_to_map`            :func:`format_datetime`                   :func:`plus`                                  :func:`any_value`                             :func:`cume_dist`
-    :func:`abs`                               :func:`from_base`                         :func:`poisson_cdf`                           :func:`approx_distinct`                       :func:`dense_rank`
-    :func:`acos`                              :func:`from_base64`                       :func:`pow`                                   :func:`approx_most_frequent`                  :func:`first_value`
-    :func:`all_keys_match`                    :func:`from_base64url`                    :func:`power`                                 :func:`approx_percentile`                     :func:`lag`
-    :func:`all_match`                         :func:`from_big_endian_32`                :func:`quarter`                               :func:`approx_set`                            :func:`last_value`
-    :func:`any_keys_match`                    :func:`from_big_endian_64`                :func:`radians`                               :func:`arbitrary`                             :func:`lead`
-    :func:`any_match`                         :func:`from_hex`                          :func:`rand`                                  :func:`array_agg`                             :func:`nth_value`
-    :func:`any_values_match`                  :func:`from_ieee754_32`                   :func:`random`                                :func:`avg`                                   :func:`ntile`
-    :func:`array_average`                     :func:`from_ieee754_64`                   :func:`reduce`                                :func:`bitwise_and_agg`                       :func:`percent_rank`
-    :func:`array_constructor`                 :func:`from_iso8601_date`                 :func:`regexp_extract`                        :func:`bitwise_or_agg`                        :func:`rank`
-    :func:`array_cum_sum`                     :func:`from_iso8601_timestamp`            :func:`regexp_extract_all`                    :func:`bitwise_xor_agg`                       :func:`row_number`
-    :func:`array_distinct`                    :func:`from_unixtime`                     :func:`regexp_like`                           :func:`bool_and`
-    :func:`array_duplicates`                  :func:`from_utf8`                         :func:`regexp_replace`                        :func:`bool_or`
-    :func:`array_except`                      :func:`gamma_cdf`                         :func:`regexp_split`                          :func:`checksum`
-    :func:`array_frequency`                   :func:`greatest`                          :func:`remove_nulls`                          :func:`classification_fall_out`
-    :func:`array_has_duplicates`              :func:`gt`                                :func:`repeat`                                :func:`classification_miss_rate`
-    :func:`array_intersect`                   :func:`gte`                               :func:`replace`                               :func:`classification_precision`
-    :func:`array_join`                        :func:`hamming_distance`                  :func:`replace_first`                         :func:`classification_recall`
-    :func:`array_max`                         :func:`hmac_md5`                          :func:`reverse`                               :func:`classification_thresholds`
-    :func:`array_min`                         :func:`hmac_sha1`                         :func:`round`                                 :func:`corr`
-    :func:`array_normalize`                   :func:`hmac_sha256`                       :func:`rpad`                                  :func:`count`
-    :func:`array_position`                    :func:`hmac_sha512`                       :func:`rtrim`                                 :func:`count_if`
-    :func:`array_remove`                      :func:`hour`                              :func:`second`                                :func:`covar_pop`
-    :func:`array_sort`                        in                                        :func:`secure_rand`                           :func:`covar_samp`
-    :func:`array_sort_desc`                   :func:`infinity`                          :func:`secure_random`                         :func:`entropy`
-    :func:`array_sum`                         :func:`inverse_beta_cdf`                  :func:`sequence`                              :func:`every`
-    :func:`array_sum_propagate_element_null`  :func:`inverse_cauchy_cdf`                :func:`sha1`                                  :func:`geometric_mean`
-    :func:`array_union`                       :func:`inverse_laplace_cdf`               :func:`sha256`                                :func:`histogram`
-    :func:`arrays_overlap`                    :func:`inverse_normal_cdf`                :func:`sha512`                                :func:`kurtosis`
-    :func:`asin`                              :func:`inverse_weibull_cdf`               :func:`shuffle`                               :func:`map_agg`
-    :func:`at_timezone`                       :func:`ip_prefix`                         :func:`sign`                                  :func:`map_union`
-    :func:`atan`                              :func:`is_finite`                         :func:`sin`                                   :func:`map_union_sum`
-    :func:`atan2`                             :func:`is_infinite`                       :func:`slice`                                 :func:`max`
-    :func:`beta_cdf`                          :func:`is_json_scalar`                    :func:`split`                                 :func:`max_by`
-    :func:`between`                           :func:`is_nan`                            :func:`split_part`                            :func:`max_data_size_for_stats`
-    :func:`binomial_cdf`                      :func:`is_null`                           :func:`split_to_map`                          :func:`merge`
-    :func:`bit_count`                         :func:`json_array_contains`               :func:`spooky_hash_v2_32`                     :func:`min`
-    :func:`bitwise_and`                       :func:`json_array_get`                    :func:`spooky_hash_v2_64`                     :func:`min_by`
-    :func:`bitwise_arithmetic_shift_right`    :func:`json_array_length`                 :func:`sqrt`                                  :func:`multimap_agg`
-    :func:`bitwise_left_shift`                :func:`json_extract`                      :func:`starts_with`                           :func:`reduce_agg`
-    :func:`bitwise_logical_shift_right`       :func:`json_extract_scalar`               :func:`strpos`                                :func:`regr_avgx`
-    :func:`bitwise_not`                       :func:`json_format`                       :func:`strrpos`                               :func:`regr_avgy`
-    :func:`bitwise_or`                        :func:`json_parse`                        :func:`subscript`                             :func:`regr_count`
-    :func:`bitwise_right_shift`               :func:`json_size`                         :func:`substr`                                :func:`regr_intercept`
-    :func:`bitwise_right_shift_arithmetic`    :func:`laplace_cdf`                       :func:`tan`                                   :func:`regr_r2`
-    :func:`bitwise_shift_left`                :func:`last_day_of_month`                 :func:`tanh`                                  :func:`regr_slope`
-    :func:`bitwise_xor`                       :func:`least`                             :func:`timezone_hour`                         :func:`regr_sxx`
-    :func:`cardinality`                       :func:`length`                            :func:`timezone_minute`                       :func:`regr_sxy`
-    :func:`cauchy_cdf`                        :func:`levenshtein_distance`              :func:`to_base`                               :func:`regr_syy`
-    :func:`cbrt`                              :func:`like`                              :func:`to_base64`                             :func:`set_agg`
-    :func:`ceil`                              :func:`ln`                                :func:`to_base64url`                          :func:`set_union`
-    :func:`ceiling`                           :func:`log10`                             :func:`to_big_endian_32`                      :func:`skewness`
-    :func:`chi_squared_cdf`                   :func:`log2`                              :func:`to_big_endian_64`                      :func:`stddev`
-    :func:`chr`                               :func:`lower`                             :func:`to_hex`                                :func:`stddev_pop`
-    :func:`clamp`                             :func:`lpad`                              :func:`to_ieee754_32`                         :func:`stddev_samp`
-    :func:`codepoint`                         :func:`lt`                                :func:`to_ieee754_64`                         :func:`sum`
-    :func:`combinations`                      :func:`lte`                               :func:`to_iso8601`                            :func:`sum_data_size_for_stats`
-    :func:`concat`                            :func:`ltrim`                             :func:`to_milliseconds`                       :func:`var_pop`
-    :func:`contains`                          :func:`map`                               :func:`to_unixtime`                           :func:`var_samp`
-    :func:`cos`                               :func:`map_concat`                        :func:`to_utf8`                               :func:`variance`
-    :func:`cosh`                              :func:`map_entries`                       :func:`trail`
-    :func:`cosine_similarity`                 :func:`map_filter`                        :func:`transform`
-    :func:`crc32`                             :func:`map_from_entries`                  :func:`transform_keys`
-    :func:`current_date`                      :func:`map_key_exists`                    :func:`transform_values`
-    :func:`date`                              :func:`map_keys`                          :func:`trim`
-    :func:`date_add`                          :func:`map_normalize`                     :func:`trim_array`
-    :func:`date_diff`                         :func:`map_remove_null_values`            :func:`truncate`
-    :func:`date_format`                       :func:`map_subset`                        :func:`typeof`
-    :func:`date_parse`                        :func:`map_top_n`                         :func:`upper`
-    :func:`date_trunc`                        :func:`map_top_n_keys`                    :func:`url_decode`
-    :func:`day`                               :func:`map_values`                        :func:`url_encode`
-    :func:`day_of_month`                      :func:`map_zip_with`                      :func:`url_extract_fragment`
-    :func:`day_of_week`                       :func:`md5`                               :func:`url_extract_host`
-    :func:`day_of_year`                       :func:`millisecond`                       :func:`url_extract_parameter`
-    :func:`degrees`                           :func:`minus`                             :func:`url_extract_path`
-    :func:`distinct_from`                     :func:`minute`                            :func:`url_extract_port`
-    :func:`divide`                            :func:`mod`                               :func:`url_extract_protocol`
-    :func:`dow`                               :func:`month`                             :func:`url_extract_query`
-    :func:`doy`                               :func:`multimap_from_entries`             :func:`uuid`
-    :func:`e`                                 :func:`multiply`                          :func:`week`
-    :func:`element_at`                        :func:`nan`                               :func:`week_of_year`
-    :func:`empty_approx_set`                  :func:`negate`                            :func:`weibull_cdf`
-    :func:`ends_with`                         :func:`neq`                               :func:`width_bucket`
-    :func:`eq`                                :func:`ngrams`                            :func:`wilson_interval_lower`
-    :func:`exp`                               :func:`no_keys_match`                     :func:`wilson_interval_upper`
-    :func:`f_cdf`                             :func:`no_values_match`                   :func:`word_stem`
-    :func:`fail`                              :func:`none_match`                        :func:`xxhash64`
-    :func:`filter`                            :func:`normal_cdf`                        :func:`year`
-    :func:`find_first`                        :func:`normalize`                         :func:`year_of_week`
-    :func:`find_first_index`                  not                                       :func:`yow`
-    :func:`flatten`                           :func:`parse_datetime`                    :func:`zip`
-    :func:`floor`                             :func:`pi`                                :func:`zip_with`
-    ========================================  ========================================  ========================================  ==  ========================================  ==  ========================================
+    =================================================  =================================================  =================================================  ==  =================================================  ==  =================================================
+    Scalar Functions                                                                                                                                             Aggregate Functions                                    Window Functions
+    =======================================================================================================================================================  ==  =================================================  ==  =================================================
+    :func:`$internal$json_string_to_array_cast`        :func:`geometry_to_dissolved_bing_tiles`           :func:`secure_rand`                                    :func:`any_value`                                      :func:`cume_dist`
+    :func:`$internal$json_string_to_map_cast`          :func:`geometry_union`                             :func:`secure_random`                                  :func:`approx_distinct`                                :func:`dense_rank`
+    :func:`$internal$json_string_to_row_cast`          :func:`great_circle_distance`                      :func:`sequence`                                       :func:`approx_most_frequent`                           :func:`first_value`
+    :func:`$internal$split_to_map`                     :func:`greatest`                                   :func:`sha1`                                           :func:`approx_percentile`                              :func:`lag`
+    :func:`abs`                                        :func:`gt`                                         :func:`sha256`                                         :func:`approx_set`                                     :func:`last_value`
+    :func:`acos`                                       :func:`gte`                                        :func:`sha512`                                         :func:`arbitrary`                                      :func:`lead`
+    :func:`all_keys_match`                             :func:`hamming_distance`                           :func:`shuffle`                                        :func:`array_agg`                                      :func:`nth_value`
+    :func:`all_match`                                  :func:`hmac_md5`                                   :func:`sign`                                           :func:`avg`                                            :func:`ntile`
+    :func:`any_keys_match`                             :func:`hmac_sha1`                                  :func:`simplify_geometry`                              :func:`bitwise_and_agg`                                :func:`percent_rank`
+    :func:`any_match`                                  :func:`hmac_sha256`                                :func:`sin`                                            :func:`bitwise_or_agg`                                 :func:`rank`
+    :func:`any_values_match`                           :func:`hmac_sha512`                                :func:`slice`                                          :func:`bitwise_xor_agg`                                :func:`row_number`
+    :func:`array_average`                              :func:`hour`                                       :func:`split`                                          :func:`bool_and`
+    :func:`array_constructor`                          in                                                 :func:`split_part`                                     :func:`bool_or`
+    :func:`array_cum_sum`                              :func:`infinity`                                   :func:`split_to_map`                                   :func:`checksum`
+    :func:`array_distinct`                             :func:`inverse_beta_cdf`                           :func:`split_to_multimap`                              :func:`classification_fall_out`
+    :func:`array_duplicates`                           :func:`inverse_binomial_cdf`                       :func:`spooky_hash_v2_32`                              :func:`classification_miss_rate`
+    :func:`array_except`                               :func:`inverse_cauchy_cdf`                         :func:`spooky_hash_v2_64`                              :func:`classification_precision`
+    :func:`array_frequency`                            :func:`inverse_chi_squared_cdf`                    :func:`sqrt`                                           :func:`classification_recall`
+    :func:`array_has_duplicates`                       :func:`inverse_f_cdf`                              :func:`st_area`                                        :func:`classification_thresholds`
+    :func:`array_intersect`                            :func:`inverse_gamma_cdf`                          :func:`st_asbinary`                                    :func:`corr`
+    :func:`array_join`                                 :func:`inverse_laplace_cdf`                        :func:`st_astext`                                      :func:`count`
+    :func:`array_max`                                  :func:`inverse_normal_cdf`                         :func:`st_boundary`                                    :func:`count_if`
+    :func:`array_max_by`                               :func:`inverse_poisson_cdf`                        :func:`st_buffer`                                      :func:`covar_pop`
+    :func:`array_min`                                  :func:`inverse_t_cdf`                              :func:`st_centroid`                                    :func:`covar_samp`
+    :func:`array_min_by`                               :func:`inverse_weibull_cdf`                        :func:`st_contains`                                    :func:`entropy`
+    :func:`array_normalize`                            :func:`ip_prefix`                                  :func:`st_convexhull`                                  :func:`every`
+    :func:`array_position`                             :func:`ip_prefix_collapse`                         :func:`st_coorddim`                                    :func:`geometric_mean`
+    :func:`array_remove`                               :func:`ip_prefix_subnets`                          :func:`st_crosses`                                     :func:`histogram`
+    :func:`array_sort`                                 :func:`ip_subnet_max`                              :func:`st_difference`                                  :func:`kurtosis`
+    :func:`array_sort_desc`                            :func:`ip_subnet_min`                              :func:`st_dimension`                                   :func:`map_agg`
+    :func:`array_subset`                               :func:`ip_subnet_range`                            :func:`st_disjoint`                                    :func:`map_union`
+    :func:`array_sum`                                  :func:`is_finite`                                  :func:`st_distance`                                    :func:`map_union_sum`
+    :func:`array_sum_propagate_element_null`           :func:`is_infinite`                                :func:`st_endpoint`                                    :func:`max`
+    :func:`array_top_n`                                :func:`is_json_scalar`                             :func:`st_envelope`                                    :func:`max_by`
+    :func:`array_union`                                :func:`is_nan`                                     :func:`st_envelopeaspts`                               :func:`max_data_size_for_stats`
+    :func:`arrays_overlap`                             :func:`is_null`                                    :func:`st_equals`                                      :func:`merge`
+    :func:`asin`                                       :func:`is_private_ip`                              :func:`st_exteriorring`                                :func:`min`
+    :func:`at_timezone`                                :func:`is_subnet_of`                               :func:`st_geometries`                                  :func:`min_by`
+    :func:`atan`                                       :func:`json_array_contains`                        :func:`st_geometryfromtext`                            :func:`multimap_agg`
+    :func:`atan2`                                      :func:`json_array_get`                             :func:`st_geometryn`                                   :func:`noisy_approx_distinct_sfm`
+    :func:`beta_cdf`                                   :func:`json_array_length`                          :func:`st_geometrytype`                                :func:`noisy_approx_set_sfm`
+    :func:`between`                                    :func:`json_extract`                               :func:`st_geomfrombinary`                              :func:`noisy_approx_set_sfm_from_index_and_zeros`
+    :func:`bing_tile`                                  :func:`json_extract_scalar`                        :func:`st_interiorringn`                               :func:`noisy_avg_gaussian`
+    :func:`bing_tile_at`                               :func:`json_format`                                :func:`st_interiorrings`                               :func:`noisy_count_gaussian`
+    :func:`bing_tile_children`                         :func:`json_parse`                                 :func:`st_intersection`                                :func:`noisy_count_if_gaussian`
+    :func:`bing_tile_coordinates`                      :func:`json_size`                                  :func:`st_intersects`                                  :func:`noisy_sum_gaussian`
+    :func:`bing_tile_parent`                           :func:`laplace_cdf`                                :func:`st_isclosed`                                    :func:`numeric_histogram`
+    :func:`bing_tile_polygon`                          :func:`last_day_of_month`                          :func:`st_isempty`                                     :func:`qdigest_agg`
+    :func:`bing_tile_quadkey`                          :func:`least`                                      :func:`st_isring`                                      :func:`reduce_agg`
+    :func:`bing_tile_zoom_level`                       :func:`length`                                     :func:`st_issimple`                                    :func:`regr_avgx`
+    :func:`bing_tiles_around`                          :func:`levenshtein_distance`                       :func:`st_isvalid`                                     :func:`regr_avgy`
+    :func:`binomial_cdf`                               :func:`like`                                       :func:`st_length`                                      :func:`regr_count`
+    :func:`bit_count`                                  :func:`line_interpolate_point`                     :func:`st_linefromtext`                                :func:`regr_intercept`
+    :func:`bit_length`                                 :func:`line_locate_point`                          :func:`st_linestring`                                  :func:`regr_r2`
+    :func:`bitwise_and`                                :func:`ln`                                         :func:`st_multipoint`                                  :func:`regr_slope`
+    :func:`bitwise_arithmetic_shift_right`             :func:`localtime`                                  :func:`st_numgeometries`                               :func:`regr_sxx`
+    :func:`bitwise_left_shift`                         :func:`log10`                                      :func:`st_numinteriorring`                             :func:`regr_sxy`
+    :func:`bitwise_logical_shift_right`                :func:`log2`                                       :func:`st_numpoints`                                   :func:`regr_syy`
+    :func:`bitwise_not`                                :func:`longest_common_prefix`                      :func:`st_overlaps`                                    :func:`set_agg`
+    :func:`bitwise_or`                                 :func:`lower`                                      :func:`st_point`                                       :func:`set_union`
+    :func:`bitwise_right_shift`                        :func:`lpad`                                       :func:`st_pointn`                                      :func:`skewness`
+    :func:`bitwise_right_shift_arithmetic`             :func:`lt`                                         :func:`st_points`                                      :func:`stddev`
+    :func:`bitwise_shift_left`                         :func:`lte`                                        :func:`st_polygon`                                     :func:`stddev_pop`
+    :func:`bitwise_xor`                                :func:`ltrim`                                      :func:`st_relate`                                      :func:`stddev_samp`
+    :func:`cardinality`                                :func:`map`                                        :func:`st_startpoint`                                  :func:`sum`
+    :func:`cauchy_cdf`                                 :func:`map_concat`                                 :func:`st_symdifference`                               :func:`sum_data_size_for_stats`
+    :func:`cbrt`                                       :func:`map_entries`                                :func:`st_touches`                                     :func:`tdigest_agg`
+    :func:`ceil`                                       :func:`map_filter`                                 :func:`st_union`                                       :func:`var_pop`
+    :func:`ceiling`                                    :func:`map_from_entries`                           :func:`st_within`                                      :func:`var_samp`
+    :func:`chi_squared_cdf`                            :func:`map_intersect`                              :func:`st_x`                                           :func:`variance`
+    :func:`chr`                                        :func:`map_key_exists`                             :func:`st_xmax`
+    :func:`clamp`                                      :func:`map_keys`                                   :func:`st_xmin`
+    :func:`codepoint`                                  :func:`map_keys_by_top_n_values`                   :func:`st_y`
+    :func:`combinations`                               :func:`map_normalize`                              :func:`st_ymax`
+    :func:`combine_hash_internal`                      :func:`map_remove_null_values`                     :func:`st_ymin`
+    :func:`concat`                                     :func:`map_subset`                                 :func:`starts_with`
+    :func:`construct_tdigest`                          :func:`map_top_n`                                  :func:`strpos`
+    :func:`contains`                                   :func:`map_top_n_keys`                             :func:`strrpos`
+    :func:`cos`                                        :func:`map_top_n_values`                           :func:`subscript`
+    :func:`cosh`                                       :func:`map_values`                                 :func:`substr`
+    :func:`cosine_similarity`                          :func:`map_zip_with`                               :func:`substring`
+    :func:`crc32`                                      :func:`md5`                                        :func:`t_cdf`
+    :func:`current_date`                               :func:`merge_hll`                                  :func:`tan`
+    :func:`date`                                       :func:`merge_sfm`                                  :func:`tanh`
+    :func:`date_add`                                   :func:`merge_tdigest`                              :func:`timezone_hour`
+    :func:`date_diff`                                  :func:`millisecond`                                :func:`timezone_minute`
+    :func:`date_format`                                :func:`minus`                                      :func:`to_base`
+    :func:`date_parse`                                 :func:`minute`                                     :func:`to_base64`
+    :func:`date_trunc`                                 :func:`mod`                                        :func:`to_base64url`
+    :func:`day`                                        :func:`month`                                      :func:`to_big_endian_32`
+    :func:`day_of_month`                               :func:`multimap_from_entries`                      :func:`to_big_endian_64`
+    :func:`day_of_week`                                :func:`multiply`                                   :func:`to_hex`
+    :func:`day_of_year`                                :func:`murmur3_x64_128`                            :func:`to_ieee754_32`
+    :func:`degrees`                                    :func:`nan`                                        :func:`to_ieee754_64`
+    :func:`destructure_tdigest`                        :func:`negate`                                     :func:`to_iso8601`
+    :func:`distinct_from`                              :func:`neq`                                        :func:`to_milliseconds`
+    :func:`divide`                                     :func:`ngrams`                                     :func:`to_unixtime`
+    :func:`dot_product`                                :func:`no_keys_match`                              :func:`to_utf8`
+    :func:`dow`                                        :func:`no_values_match`                            :func:`trail`
+    :func:`doy`                                        :func:`noisy_empty_approx_set_sfm`                 :func:`transform`
+    :func:`e`                                          :func:`none_match`                                 :func:`transform_keys`
+    :func:`element_at`                                 :func:`normal_cdf`                                 :func:`transform_values`
+    :func:`empty_approx_set`                           :func:`normalize`                                  :func:`trim`
+    :func:`ends_with`                                  not                                                :func:`trim_array`
+    :func:`enum_key`                                   :func:`parse_datetime`                             :func:`trimmed_mean`
+    :func:`eq`                                         :func:`parse_duration`                             :func:`truncate`
+    :func:`exp`                                        :func:`parse_presto_data_size`                     :func:`typeof`
+    :func:`expand_envelope`                            :func:`pi`                                         :func:`upper`
+    :func:`f_cdf`                                      :func:`plus`                                       :func:`url_decode`
+    :func:`fail`                                       :func:`poisson_cdf`                                :func:`url_encode`
+    :func:`filter`                                     :func:`pow`                                        :func:`url_extract_fragment`
+    :func:`find_first`                                 :func:`power`                                      :func:`url_extract_host`
+    :func:`find_first_index`                           :func:`quantile_at_value`                          :func:`url_extract_parameter`
+    :func:`flatten`                                    :func:`quantiles_at_values`                        :func:`url_extract_path`
+    :func:`flatten_geometry_collections`               :func:`quarter`                                    :func:`url_extract_port`
+    :func:`floor`                                      :func:`radians`                                    :func:`url_extract_protocol`
+    :func:`format_datetime`                            :func:`rand`                                       :func:`url_extract_query`
+    :func:`from_base`                                  :func:`random`                                     :func:`uuid`
+    :func:`from_base32`                                :func:`reduce`                                     :func:`value_at_quantile`
+    :func:`from_base64`                                :func:`regexp_extract`                             :func:`values_at_quantiles`
+    :func:`from_base64url`                             :func:`regexp_extract_all`                         :func:`week`
+    :func:`from_big_endian_32`                         :func:`regexp_like`                                :func:`week_of_year`
+    :func:`from_big_endian_64`                         :func:`regexp_replace`                             :func:`weibull_cdf`
+    :func:`from_hex`                                   :func:`regexp_split`                               :func:`width_bucket`
+    :func:`from_ieee754_32`                            :func:`remap_keys`                                 :func:`wilson_interval_lower`
+    :func:`from_ieee754_64`                            :func:`remove_nulls`                               :func:`wilson_interval_upper`
+    :func:`from_iso8601_date`                          :func:`repeat`                                     :func:`word_stem`
+    :func:`from_iso8601_timestamp`                     :func:`replace`                                    :func:`xxhash64`
+    :func:`from_unixtime`                              :func:`replace_first`                              :func:`xxhash64_internal`
+    :func:`from_utf8`                                  :func:`reverse`                                    :func:`year`
+    :func:`gamma_cdf`                                  :func:`round`                                      :func:`year_of_week`
+    :func:`geometry_as_geojson`                        :func:`rpad`                                       :func:`yow`
+    :func:`geometry_from_geojson`                      :func:`rtrim`                                      :func:`zip`
+    :func:`geometry_invalid_reason`                    :func:`scale_qdigest`                              :func:`zip_with`
+    :func:`geometry_nearest_points`                    :func:`scale_tdigest`
+    :func:`geometry_to_bing_tiles`                     :func:`second`
+    =================================================  =================================================  =================================================  ==  =================================================  ==  =================================================
diff --git a/velox/docs/functions/delta/functions.rst b/velox/docs/functions/delta/functions.rst
new file mode 100644
index 000000000000..e1b3de5673fb
--- /dev/null
+++ b/velox/docs/functions/delta/functions.rst
@@ -0,0 +1,13 @@
+********************
+Delta Lake Functions
+********************
+
+Here is a list of all scalar Delta Lake functions available in Velox.
+Function names link to function description.
+
+These functions are used in deletion vector read.
+Refer to `Delta Lake documentation <https://docs.delta.io/delta-deletion-vectors/#_top>`_ and `Delta Lake deletion vector blog <https://delta.io/blog/2023-07-05-deletion-vectors/>`_ for details.
+
+.. delta:function:: bitmap_array_contains(bitmap_array: varbinary, input: bigint) -> bool
+
+    Not implemented.
diff --git a/velox/docs/functions/iceberg/functions.rst b/velox/docs/functions/iceberg/functions.rst
new file mode 100644
index 000000000000..a878f8c40ea8
--- /dev/null
+++ b/velox/docs/functions/iceberg/functions.rst
@@ -0,0 +1,79 @@
+*****************
+Iceberg Functions
+*****************
+
+Here is a list of all scalar Iceberg functions available in Velox.
+Function names link to function description.
+
+These functions are used in partition transform.
+Refer to `Iceberg documenation <https://iceberg.apache.org/spec/#partition-transforms>`_ for details.
+
+.. iceberg:function:: bucket(numBuckets, input) -> integer
+
+   Returns an integer between 0 and numBuckets - 1, indicating the assigned bucket.
+   Bucket partitioning is based on a 32-bit hash of the input, specifically using the x86
+   variant of the Murmur3 hash function with a seed of 0.
+
+   The function can be expressed in pseudo-code as below. ::
+
+       def bucket(numBuckets, input)= (murmur3_x86_32_hash(input) & Integer.MAX_VALUE) % numBuckets
+
+   The ``numBuckets`` is of type INTEGER and must be greater than 0. Otherwise, an exception is thrown.
+   Supported types for ``input`` are INTEGER, BIGINT, DECIMAL, DATE, TIMESTAMP, VARCHAR, VARBINARY. ::
+       SELECT bucket(128, 'abcd'); -- 4
+       SELECT bucket(100, 34L); -- 79
+
+.. iceberg:function:: days(input) -> date
+
+   Returns the date. ::
+
+       SELECT days(DATE '2017-12-01'); -- 2017-12-01
+       SELECT days(TIMESTAMP '2017-12-01 10:12:55.038194'); -- 2017-12-01
+       SELECT days(DATE '1969-12-31'); -- 1969-12-31
+
+.. iceberg:function:: hours(input) -> integer
+
+   Returns the number of hours since epoch (1970-01-01 00:00:00). Returns 0 for '1970-01-01 00:00:00' timestamps.
+   Returns negative value for timestamps before '1970-01-01 00:00:00'. ::
+
+       SELECT hours(TIMESTAMP '2017-12-01 10:12:55.038194'); -- 420034
+       SELECT hours(TIMESTAMP '1969-12-31 23:59:58.999999'); -- -1
+
+.. iceberg:function:: months(input) -> integer
+
+   Returns the number of months since epoch (1970-01-01). Returns 0 for '1970-01-01' date and timestamps.
+   Returns negative value for dates and timestamps before '1970-01-01'.  ::
+
+       SELECT months(DATE '2017-12-01'); -- 575
+       SELECT months(TIMESTAMP '2017-12-01 10:12:55.038194'); -- 575
+       SELECT months(DATE '1960-01-01'); -- -120
+
+.. iceberg:function:: truncate(width, input) -> same type as input
+
+   Returns the truncated value of the input based on the specified width.
+   For numeric values, truncate to the nearest lower multiple of ``width``, the truncate function is: input - (((input % width) + width) % width).
+   The ``width`` is used to truncate decimal values is applied using unscaled value to avoid additional (and potentially conflicting) parameters.
+   For string values, it truncates a valid UTF-8 string with no more than ``width`` code points.
+   In contrast to strings, binary values do not have an assumed encoding and are truncated to ``width`` bytes.
+
+   Argument ``width`` must be a positive integer.
+   Supported types for ``input`` are: SHORTINT, TYNYINT, SMALLINT, INTEGER, BIGINT, DECIMAL, VARCHAR, VARBINARY. ::
+
+       SELECT truncate(10, 11); -- 10
+       SELECT truncate(10, -11); -- -20
+       SELECT truncate(7, 22); -- 21
+       SELECT truncate(0, 11); -- error: Reason: (0 vs. 0) Invalid truncate width\nExpression: width <= 0
+       SELECT truncate(-3, 11); -- error: Reason: (-3 vs. 0) Invalid truncate width\nExpression: width <= 0
+       SELECT truncate(4, 'iceberg'); -- 'iceb'
+       SELECT truncate(1, '测试'); -- 测
+       SELECT truncate(6, '测试'); -- 测试
+       SELECT truncate(6, cast('测试' as binary)); -- 测试_
+
+.. iceberg:function:: years(input) -> integer
+
+   Returns the number of years since epoch (1970-01-01). Returns 0 for '1970-01-01' date and timestamps.
+   Returns negative value for dates and timestamps before '1970-01-01'.  ::
+
+       SELECT years(DATE '2017-12-01'); -- 47
+       SELECT years(TIMESTAMP '2017-12-01 10:12:55.038194'); -- 47
+       SELECT years(DATE '1960-01-01'); -- -10
diff --git a/velox/docs/functions/presto/aggregate.rst b/velox/docs/functions/presto/aggregate.rst
index 89ce72189634..8212675c328d 100644
--- a/velox/docs/functions/presto/aggregate.rst
+++ b/velox/docs/functions/presto/aggregate.rst
@@ -31,11 +31,20 @@ General Aggregate Functions
     inputs if :doc:`presto.array_agg.ignore_nulls <../../configs>` is set
     to false.
 
-.. function:: avg(x) -> double|real
+.. function:: avg(x) -> double|real|decimal
 
     Returns the average (arithmetic mean) of all non-null input values.
     When x is of type REAL, the result type is REAL.
-    For all other input types, the result type is DOUBLE.
+    When x is an integer or a DOUBLE, the result is DOUBLE.
+    When x is of type DECIMAL(p, s), the result type is DECIMAL(p, s).
+    Note: For the overflow cases, Velox returns a result when Presto throws "Decimal overflow". ::
+        SELECT AVG(col)
+        FROM ( VALUES
+        	  (CAST(9999999999999999999999999999999.9999999 AS DECIMAL(38,7))),
+              (CAST(9999999999999999999999999999999.9999999 AS DECIMAL(38,7)))
+             ) AS t(col);
+        -- Velox: 9999999999999999999999999999999.9999999
+        -- Presto: Decimal overflow
 
 .. function:: bool_and(boolean) -> boolean
 
@@ -709,20 +718,223 @@ Statistical Aggregate Functions
 Noisy Aggregate Functions
 -------------------------
 
-.. function:: noisy_count_if_gaussian(col, noise_scale) -> bigint
+Overview
+~~~~~~~~
+
+Noisy aggregate functions provide random, noisy approximations of common
+aggregations like ``sum()``, ``count()``, and ``approx_distinct()`` as well as sketches like
+``approx_set()``. By injecting random noise into results, noisy aggregation functions make it
+more difficult to determine or confirm the exact data that was aggregated.
+
+While many of these functions resemble `differential privacy <https://en.wikipedia.org/wiki/Differential_privacy>`_
+mechanisms, neither the values returned by these functions nor the query results that incorporate
+these functions are differentially private in general. See Limitations_ below for more details.
+Users who wish to support a strong privacy guarantee should discuss with a suitable technical
+expert first.
+
+Counts, Sums, and Averages
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. function:: noisy_count_if_gaussian(col, noise_scale[, random_seed]) -> bigint
 
     Counts the ``TRUE`` values in ``col`` and then adds a normally distributed random double
     value with 0 mean and standard deviation of ``noise_scale`` to the true count.
     The noisy count is post-processed to be non-negative and rounded to bigint.
 
+    If provided, ``random_seed`` is used to seed the random number generator.
+    Otherwise, noise is drawn from a secure random. (*Note: ``random_seed`` is a constant and shared across all groups in a query.
+    It is kept in each accmulator to ensure the ``random_seed`` is accessible in the final aggregation step.*)
+
     ::
 
-        SELECT noisy_count_if_gaussian(orderkey > 10000, 20.0) FROM tpch.tiny.lineitem; -- 50180 (1 row)
-        SELECT noisy_count_if_gaussian(orderkey > 10000, 20.0) FROM tpch.tiny.lineitem WHERE false; -- NULL (1 row)
+        SELECT noisy_count_if_gaussian(orderkey > 10000, 20.0) FROM lineitem; -- 50180 (1 row)
+        SELECT noisy_count_if_gaussian(orderkey > 10000, 20.0) FROM lineitem WHERE false; -- NULL (1 row)
 
     .. note::
 
-        Unlike :func:`!count_if`, this function returns ``NULL`` when the (true) count is 0.
+        Unlike :func:`count_if`, this function returns ``NULL`` when the (true) count is 0.
+
+.. function:: noisy_count_gaussian(col, noise_scale[, random_seed]) -> bigint
+
+    Counts the non-null values in ``col`` and then adds a normally distributed random double
+    value with 0 mean and standard deviation of ``noise_scale`` to the true count.
+    The noisy count is post-processed to be non-negative and rounded to bigint.
+
+    If provided, ``random_seed`` is used to seed the random number generator.
+    Otherwise, noise is drawn from a secure random.
+
+    ::
+
+        SELECT noisy_count_gaussian(orderkey, 20.0) FROM lineitem; -- 60181 (1 row)
+        SELECT noisy_count_gaussian(orderkey, 20.0) FROM lineitem WHERE false; -- NULL (1 row)
+
+    .. note::
+
+        Unlike :func:`!count`, this function returns ``NULL`` when the (true) count is 0.
+
+    Distinct counting can be performed using :func:`noisy_count_gaussian` ``(DISTINCT col, ...)``, or with ``noisy_approx_distinct_sfm()``.
+    Generally speaking, :func:`noisy_count_gaussian` returns more accurate results but at a larger computational cost.
+
+.. function:: noisy_sum_gaussian(col, noise_scale[, random_seed]) -> double
+
+    Calculates the sum over the input values in ``col`` and then adds a normally distributed
+    random double value with 0 mean and standard deviation of ``noise_scale``.
+
+    If provided, ``random_seed`` is used to seed the random number generator.
+    Otherwise, noise is drawn from a secure random.
+
+.. function:: noisy_sum_gaussian(col, noise_scale, lower, upper[, random_seed]) -> double
+
+    Calculates the sum over the input values in ``col`` and then adds a normally distributed
+    random double value with 0 mean and standard deviation of ``noise_scale``.
+    Each value is clipped to the range of [``lower``, ``upper``] before adding to the sum.
+
+    If provided, ``random_seed`` is used to seed the random number generator.
+    Otherwise, noise is drawn from a secure random.
+
+.. function:: noisy_avg_gaussian(col, noise_scale[, random_seed]) -> double
+
+    Calculates the average (arithmetic mean) of all the input values in col and then adds a
+    normally distributed random double value with 0 mean and standard deviation of noise_scale.
+
+    If provided, ``random_seed`` is used to seed the random number generator.
+    Otherwise, noise is drawn from a secure random.
+
+.. function:: noisy_avg_gaussian(col, noise_scale, lower, upper[, random_seed]) -> double
+
+    Calculates the average (arithmetic mean) of all the input values in ``col`` and then adds a
+    normally distributed random double value with 0 mean and standard deviation of ``noise_scale``.
+    Each value is clipped to the range of [``lower``, ``upper``] before averaging.
+
+    If provided, ``random_seed`` is used to seed the random number generator.
+    Otherwise, noise is drawn from a secure random.
+
+.. function:: noisy_approx_set_sfm(col, epsilon[, buckets[, precision]]) -> SfmSketch
+
+    Returns an SFM sketch of the input values in ``col``. This is analogous to the ``approx_set()`` function,
+    which returns a (deterministic) HyperLogLog sketch.
+
+    * ``col`` currently supports types: "bigint", "double", "string", "varbinary".
+    * ``epsilon`` (double) is a positive number that controls the level of noise in the sketch, as described in [Hehir2023]_.
+      Smaller values of epsilon correspond to noisier sketches.
+    * ``buckets`` (int) defaults to 4096.
+    * ``precision`` (int) defaults to 24.
+
+    .. note::
+
+        Unlike ``approx_set()``, this function returns ``NULL`` when ``col`` is empty.
+        If this behavior is undesirable, use ``coalesce()`` with :func:`noisy_empty_approx_set_sfm`.
+
+.. function:: noisy_approx_distinct_sfm(col, epsilon[, buckets[, precision]]) -> bigint
+
+    Equivalent to ``cardinality(noisy_approx_set_sfm(col, epsilon, buckets, precision))``,
+    this returns the approximate cardinality (distinct count) of the column col.
+    This is analogous to the (deterministic) :func:`approx_distinct` function.
+
+    .. note::
+
+        Unlike :func:`approx_distinct`, this function returns ``NULL`` when ``col`` is empty.
+
+.. function:: noisy_empty_approx_set_sfm(epsilon[, buckets[, precision]]) -> SfmSketch
+
+    Returns an SFM sketch with no items in it. This is analogous to the ``empty_approx_set()`` function,
+    which returns an empty (deterministic) ``HyperLogLog`` sketch.
+
+    * ``epsilon`` (double) is a positive number that controls the level of noise in the sketch, as described in [Hehir2023]_. Smaller values of epsilon correspond to noisier sketches.
+    * ``buckets`` (int) defaults to 4096.
+    * ``precision`` (int) defaults to 24.
+
+.. function:: noisy_approx_set_sfm_from_index_and_zeros(col_index, col_zeros, epsilon, buckets[, precision]) -> SfmSketch
+
+    Returns an SFM sketch of the input values in ``col_index`` and ``col_zeros``.
+
+    This is similar to :func:`noisy_approx_set_sfm` except that function calculates a ``xxhash64()`` of ``col``,
+    and calculates the SFM PCSA bucket index and number of trailing zeros as described in
+    [FlajoletMartin1985]_. In this function, the caller must explicitly calculate the hash bucket index
+    and zeros themselves and pass them as arguments ``col_index`` and ``col_zeros``.
+
+    - ``col_index`` (bigint) must be in the range ``0..buckets-1``.
+    - ``col_zeros`` (bigint) must be in the range ``0..64``. If it exceeds ``precision``, it
+      is cropped to ``precision-1``.
+    - ``epsilon`` (double) is a positive number that controls the level of noise in
+      the sketch, as described in [Hehir2023]_. Smaller values of epsilon correspond
+      to noisier sketches.
+    - ``buckets`` (int) is the number of buckets in the SFM PCSA sketch as described in [Hehir2023]_.
+    - ``precision`` (int) defaults to 24.
+
+    .. note::
+
+        Like  :func:`noisy_approx_set_sfm`, this function returns ``NULL`` when ``col_index``
+        or ``col_zeros`` is ``NULL``.
+        If this behavior is undesirable, use :func:`!coalesce` with :func:`noisy_empty_approx_set_sfm`.
+
+.. function:: cardinality(SfmSketch) -> bigint
+
+    Returns the estimated cardinality (distinct count) of an ``SfmSketch`` object.
+
+.. function:: merge(SfmSketch) -> SfmSketch
+
+    An aggregator function that returns a merged ``SfmSketch`` of the set union of
+    individual ``SfmSketch`` objects, similar to ``merge(HyperLogLog)``.
+
+    ::
+
+        SELECT year, cardinality(merge(sketch)) AS annual_distinct_count
+        FROM monthly_sketches
+        GROUP BY 1
+
+.. function:: merge_sfm(ARRAY[SfmSketch, ...]) -> SfmSketch
+
+    A scalar function that returns a merged ``SfmSketch`` of the set union of an array of ``SfmSketch`` objects, similar to ``merge_hll()``.
+
+    ::
+
+        SELECT cardinality(merge_sfm(ARRAY[
+            noisy_approx_set_sfm(col_1, 5.0),
+            noisy_approx_set_sfm(col_2, 5.0),
+            noisy_approx_set_sfm(col_3, 5.0)
+        ])) AS distinct_count_over_3_cols
+        FROM my_table
+
+Limitations
+~~~~~~~~~~~
+
+While these functions resemble differential privacy mechanisms, the values returned by these
+functions are not differentially private in general. There are several important limitations
+to keep in mind if using these functions for privacy-preserving purposes, including:
+
+* All noisy aggregate functions return ``NULL`` when aggregating empty sets. This means a ``NULL``
+  return value noiselessly indicates the absence of data.
+
+* ``GROUP BY`` clauses used in combination with noisy aggregation functions reveal non-noisy
+  information: the presence or absence of a group noiselessly indicates the presence or
+  absence of data. See, e.g., [Wilkins2024]_.
+
+* Functions relying on floating-point noise may be susceptible to inference attacks such as
+  those identified in [Mironov2012]_ and [Casacuberta2022]_.
+
+References
+~~~~~~~~~~
+
+.. [Casacuberta2022] Casacuberta, S., Shoemate, M., Vadhan, S., & Wagaman, C. (2022).
+   `Widespread Underestimation of Sensitivity in Differentially Private Libraries and How to Fix It <https://arxiv.org/pdf/2207.10635>`_.
+   In Proceedings of the 2022 ACM SIGSAC Conference on Computer and Communications Security (pp. 471-484).
+
+.. [Hehir2023] Hehir, J., Ting, D., & Cormode, G. (2023).
+   `Sketch-Flip-Merge: Mergeable Sketches for Private Distinct Counting <https://proceedings.mlr.press/v202/hehir23a/hehir23a.pdf>`_.
+   In Proceedings of the 40th International Conference on Machine Learning (Vol. 202).
+
+.. [Mironov2012] Mironov, I. (2012).
+   `On significance of the least significant bits for differential privacy <https://www.microsoft.com/en-us/research/wp-content/uploads/2012/10/lsbs.pdf>`_.
+   In Proceedings of the 2012 ACM Conference on Computer and Communications Security (pp. 650-661).
+
+.. [Wilkins2024] Wilkins, A., Kifer, D., Zhang, D., & Karrer, B. (2024).
+   `Exact Privacy Analysis of the Gaussian Sparse Histogram Mechanism <https://journalprivacyconfidentiality.org/index.php/jpc/article/view/823/755>`_.
+   Journal of Privacy and Confidentiality, 14 (1).
+
+.. [FlajoletMartin1985] Flajolet, P, Martin, G. N. (1985).
+   `Probabilistic Counting Algorithms for Data Base Applications <https://algo.inria.fr/flajolet/Publications/src/FlMa85.pdf>`_.
+   In Journal of Computer and System Sciences, 31:182-209, 1985
 
 Miscellaneous
 -------------
diff --git a/velox/docs/functions/presto/array.rst b/velox/docs/functions/presto/array.rst
index ffc691c44458..bcb355ed6f56 100644
--- a/velox/docs/functions/presto/array.rst
+++ b/velox/docs/functions/presto/array.rst
@@ -34,8 +34,11 @@ 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. ::
+    … + input[i]. If there there is null elements in the array, the cumulative sum at and after the element is null.
+    The following types are supported: int8_t, int16_t, int32_t, int64_t, int128_t, float, double, ShortDecimal,
+    and LongDecimal. ::
 
         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]
@@ -129,6 +132,13 @@ Array Functions
         SELECT array_min(ARRAY[{-1, -2, -3, nan()]); -- -1
         SELECT array_min(ARRAY[{infinity(), nan()]); -- Infinity
 
+.. function:: array_max_by(array(T), function(T, U)) -> T()
+
+    Applies the provided function to each element, and returns the element that gives the maximum value.
+    ``U`` can be any orderable type. ::
+
+        SELECT array_max_by(ARRAY ['a', 'bbb', 'cc'], x -> LENGTH(x)) -- 'bbb'
+
 .. function:: array_normalize(array(E), E) -> array(E)
 
     Normalizes array ``x`` by dividing each element by the p-norm of the array. It is equivalent to ``TRANSFORM(array, v -> v / REDUCE(array, 0, (a, v) -> a + POW(ABS(v), p), a -> POW(a, 1 / p))``, but the reduce part is only executed once. Returns null if the array is null or there are null array elements. If ``p`` is 0, then the input array is returned. Only REAL and DOUBLE types are supported.
@@ -207,7 +217,7 @@ Array Functions
         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:
+      :noindex:
 
     Returns the array sorted by values computed using specified lambda in descending
     order. U must be an orderable type. Null elements will be placed at the end of
@@ -215,7 +225,20 @@ Array Functions
     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']
+          SELECT array_sort_desc(ARRAY ['cat', 'leopard', 'mouse'], x -> length(x)); -- ['leopard', 'mouse', 'cat']
+
+.. function:: array_subset(array(T), array(int)) -> array(T)
+
+    Returns an array containing elements from the input array at the specified 1-based indices.
+    Indices must be positive integers. Invalid indices (out of bounds, zero, or negative) are ignored.
+    Null elements at valid indices are preserved in the output. Duplicate indices result in duplicate elements in the output.
+    The output maintains the order of the indices array. ::
+
+          SELECT array_subset(ARRAY[1, 2, 3, 4, 5], ARRAY[1, 3, 5]); -- [1, 3, 5]
+          SELECT array_subset(ARRAY['a', 'b', 'c'], ARRAY[3, 1, 2]); -- ['c', 'a', 'b']
+          SELECT array_subset(ARRAY[1, NULL, 3], ARRAY[2]); -- [NULL]
+          SELECT array_subset(ARRAY[1, 2, 3], ARRAY[1, 1, 2]); -- [1, 1, 2]
+          SELECT array_subset(ARRAY[1, 2, 3], ARRAY[5, 0, -1]); -- []
 
 .. function:: array_sum(array(T)) -> bigint/double
 
diff --git a/velox/docs/functions/presto/binary.rst b/velox/docs/functions/presto/binary.rst
index 1e9ee252b135..315ba71be2c3 100644
--- a/velox/docs/functions/presto/binary.rst
+++ b/velox/docs/functions/presto/binary.rst
@@ -150,3 +150,7 @@ Binary Functions
 .. function:: xxhash64(binary) -> varbinary
 
     Computes the xxhash64 hash of ``binary``.
+
+.. function:: xxhash64(binary, bigint) -> varbinary
+
+    Computes the xxhash64 hash of ``binary`` with ``bigint`` seed.
diff --git a/velox/docs/functions/presto/conversion.rst b/velox/docs/functions/presto/conversion.rst
index b04dd316918d..d33e6c492d4c 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 25 25 25 25
+   :widths: 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25
    :header-rows: 1
 
    * -
@@ -50,6 +50,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - decimal
      - ipaddress
      - ipprefix
+     - tdigest
+     - qdigest
    * - tinyint
      - Y
      - Y
@@ -67,6 +69,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - smallint
      - Y
      - Y
@@ -84,6 +88,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - integer
      - Y
      - Y
@@ -101,6 +107,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - bigint
      - Y
      - Y
@@ -118,6 +126,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - boolean
      - Y
      - Y
@@ -135,6 +145,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - real
      - Y
      - Y
@@ -152,6 +164,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - double
      - Y
      - Y
@@ -169,6 +183,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - varchar
      - Y
      - Y
@@ -186,6 +202,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      - Y
      - Y
+     -
+     -
    * - varbinary
      -
      -
@@ -202,7 +220,9 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      - Y
-     -
+     - Y
+     - Y
+     - Y
    * - timestamp
      -
      -
@@ -220,6 +240,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - timestamp with time zone
      -
      -
@@ -237,6 +259,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - date
      -
      -
@@ -254,6 +278,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - interval day to second
      -
      -
@@ -271,6 +297,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      -
+     -
+     -
    * - decimal
      - Y
      - Y
@@ -288,6 +316,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      - Y
      -
      -
+     -
+     -
    * - ipaddress
      -
      -
@@ -305,6 +335,8 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      -
      - Y
+     -
+     -
    * - ipprefix
      -
      -
@@ -322,6 +354,47 @@ supported conversions to/from JSON are listed in :doc:`json`.
      -
      - Y
      - Y
+     -
+     -
+   * - tdigest
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     - Y
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+   * - qdigest
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     - Y
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+     -
+
 Cast to Integral Types
 ----------------------
 
@@ -570,7 +643,7 @@ Invalid example
   SELECT cast(decimal '300.001' as tinyint); -- Out of range
 
 Cast to VARCHAR
---------------
+---------------
 
 Casting from scalar types to string is allowed.
 
@@ -777,6 +850,26 @@ IPV4 mapped IPV6:
 
   SELECT cast('::ffff:ffff:ffff' as ipaddress); -- 0x00000000000000000000ffffffffffff
 
+From TDIGEST(DOUBLE)
+^^^^^^^^^^^^^^^^^^^^
+
+Returns the T-digest as a varbinary string containing the serialized representation of the T-digest data structure.
+This allows T-digests to be stored and retrieved for later use.
+
+::
+
+  SELECT cast(tdigest_agg(cast(1.0 as double)) as varbinary); -- AQAAAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAABZQAAAAAAAAPA/AQAAAAAAAAAAAPA/AAAAAAAA8D8=
+
+From QDIGEST(BIGINT), QDIGEST(REAL), QDIGEST(DOUBLE)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Returns the quantile digest as a varbinary string containing the serialized representation of the quantile digest data structure.
+This allows quantile digests to be stored and retrieved for later use.
+
+::
+
+  SELECT cast(qdigest_agg(cast(1.0 as double)) as varbinary); -- AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPA/AAAAAAAA8D8BAAAAAAAAAAAAAPA/AAAAAAAA8L8=
+
 Cast to TIMESTAMP
 -----------------
 
@@ -1203,6 +1296,34 @@ Examples:
   SELECT cast(ipprefix '1.2.3.4/24' as ipaddress) -- ipaddress '1.2.3.0'
   SELECT cast(ipprefix '2001:db8::ff00:42:8329/64' as ipaddress) -- ipaddress '2001:db8::'
 
+Cast to TDIGEST(DOUBLE)
+-----------------------
+
+From VARBINARY
+^^^^^^^^^^^^^^
+
+Returns a T-digest reconstructed from the varbinary string containing the serialized representation.
+This allows previously stored T-digests to be restored for use.
+
+::
+
+  SELECT cast(stored_tdigest_binary as tdigest(double));
+
+Cast to QDIGEST(BIGINT), QDIGEST(REAL), QDIGEST(DOUBLE)
+-------------------------------------------------------
+
+From VARBINARY
+^^^^^^^^^^^^^^
+
+Returns a quantile digest reconstructed from the varbinary string containing the serialized representation.
+This allows previously stored quantile digests to be restored for use.
+
+::
+
+  SELECT cast(stored_qdigest_binary as qdigest(bigint));
+  SELECT cast(stored_qdigest_binary as qdigest(real));
+  SELECT cast(stored_qdigest_binary as qdigest(double));
+
 Cast to IPPREFIX
 ----------------
 
diff --git a/velox/docs/functions/presto/coverage.rst b/velox/docs/functions/presto/coverage.rst
index ab1c906785bc..c6698306a2fa 100644
--- a/velox/docs/functions/presto/coverage.rst
+++ b/velox/docs/functions/presto/coverage.rst
@@ -13,97 +13,127 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     table.coverage td:nth-child(8) {background-color: lightblue;}
     table.coverage tr:nth-child(1) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(1) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(1) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(1) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(1) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(1) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(1) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(2) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(2) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(2) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(2) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(2) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(2) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(2) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(3) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(3) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(3) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(3) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(3) td:nth-child(5) {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;}
+    table.coverage tr:nth-child(4) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(4) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(4) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(5) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(5) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(5) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(5) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(5) td:nth-child(5) {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(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(6) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(6) td:nth-child(5) {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;}
     table.coverage tr:nth-child(7) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(7) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(7) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(7) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(7) td:nth-child(5) {background-color: #6BA81E;}
     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(1) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(8) td:nth-child(5) {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;}
     table.coverage tr:nth-child(9) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(9) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(9) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(9) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(10) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(11) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(9) {background-color: #6BA81E;}
     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(5) {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(13) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(13) td:nth-child(7) {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(14) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(14) td:nth-child(7) {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(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(15) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(15) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(15) td:nth-child(7) {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(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(16) td:nth-child(7) {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(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(17) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(17) td:nth-child(7) {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(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(18) td:nth-child(2) {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(18) td:nth-child(7) {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(3) {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(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;}
@@ -119,40 +149,48 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     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(3) {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(3) {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(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(3) {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(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(29) td:nth-child(7) {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(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(31) td:nth-child(7) {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;}
@@ -162,6 +200,7 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     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(33) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(34) td:nth-child(2) {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;}
@@ -169,166 +208,262 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     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(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(36) td:nth-child(1) {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(1) {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(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(37) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(37) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(37) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(38) td:nth-child(1) {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(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(5) {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(1) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(39) td:nth-child(4) {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(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(40) td:nth-child(1) {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(4) {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(1) {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(4) {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(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(42) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(42) td:nth-child(4) {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(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(4) {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;}
     table.coverage tr:nth-child(44) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(44) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(44) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(44) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(44) td:nth-child(7) {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(4) {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(4) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(47) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(47) td:nth-child(4) {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(2) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(48) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(48) td:nth-child(7) {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(2) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(49) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(49) td:nth-child(7) {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(2) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(50) td:nth-child(7) {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(2) {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(4) {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(2) {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(4) {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(2) {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(4) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(54) td:nth-child(4) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(55) td:nth-child(4) {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(2) {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(4) {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(4) {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(4) {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(4) {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(4) {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(4) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(62) td:nth-child(4) {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(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(63) td:nth-child(1) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(63) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(63) td:nth-child(5) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(64) td:nth-child(5) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(65) td:nth-child(1) {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(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(4) {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(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(66) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(66) td:nth-child(4) {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(2) {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(4) {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(2) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(68) td:nth-child(5) {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(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(69) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(69) td:nth-child(4) {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(2) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(70) td:nth-child(5) {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(2) {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(4) {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(2) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(72) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(72) td:nth-child(7) {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(2) {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(4) {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(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(74) td:nth-child(2) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(74) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(74) td:nth-child(4) {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(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(75) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(75) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(75) td:nth-child(4) {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(2) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(76) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(76) td:nth-child(7) {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(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(77) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(77) td:nth-child(7) {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(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(78) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(78) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(78) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(78) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(79) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(79) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(79) td:nth-child(3) {background-color: #6BA81E;}
-    table.coverage tr:nth-child(79) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(79) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(80) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(80) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(80) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(80) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(81) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(81) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(81) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(81) td:nth-child(4) {background-color: #6BA81E;}
     </style>
 
 .. table::
@@ -338,83 +473,85 @@ Here is a list of all scalar, aggregate, and window functions from Presto, with
     ========================================  ========================================  ========================================  ========================================  ========================================  ==  ========================================  ==  ========================================
     Scalar Functions                                                                                                                                                                                                      Aggregate Functions                           Window Functions
     ================================================================================================================================================================================================================  ==  ========================================  ==  ========================================
-    :func:`abs`                               :func:`date_diff`                         ip_subnet_range                           :func:`random`                            st_numgeometries                              :func:`approx_distinct`                       :func:`cume_dist`
-    :func:`acos`                              :func:`date_format`                       :func:`is_finite`                         :func:`reduce`                            st_numinteriorring                            :func:`approx_most_frequent`                  :func:`dense_rank`
-    :func:`all_match`                         :func:`date_parse`                        :func:`is_infinite`                       :func:`regexp_extract`                    st_numpoints                                  :func:`approx_percentile`                     :func:`first_value`
-    :func:`any_keys_match`                    :func:`date_trunc`                        :func:`is_json_scalar`                    :func:`regexp_extract_all`                st_overlaps                                   :func:`approx_set`                            :func:`lag`
-    :func:`any_match`                         :func:`day`                               :func:`is_nan`                            :func:`regexp_like`                       st_point                                      :func:`arbitrary`                             :func:`last_value`
-    :func:`any_values_match`                  :func:`day_of_month`                      is_private_ip                             :func:`regexp_replace`                    st_pointn                                     :func:`array_agg`                             :func:`lead`
-    :func:`array_average`                     :func:`day_of_week`                       is_subnet_of                              :func:`regexp_split`                      st_points                                     :func:`avg`                                   :func:`nth_value`
-    :func:`array_cum_sum`                     :func:`day_of_year`                       jaccard_index                             regress                                   st_polygon                                    :func:`bitwise_and_agg`                       :func:`ntile`
-    :func:`array_distinct`                    :func:`degrees`                           :func:`json_array_contains`               reidentification_potential                st_relate                                     :func:`bitwise_or_agg`                        :func:`percent_rank`
-    :func:`array_duplicates`                  :func:`dow`                               :func:`json_array_get`                    :func:`remove_nulls`                      st_startpoint                                 :func:`bool_and`                              :func:`rank`
-    :func:`array_except`                      :func:`doy`                               :func:`json_array_length`                 render                                    st_symdifference                              :func:`bool_or`                               :func:`row_number`
-    :func:`array_frequency`                   :func:`e`                                 :func:`json_extract`                      :func:`repeat`                            st_touches                                    :func:`checksum`
-    :func:`array_has_duplicates`              :func:`element_at`                        :func:`json_extract_scalar`               :func:`replace`                           st_union                                      :func:`classification_fall_out`
-    :func:`array_intersect`                   :func:`empty_approx_set`                  :func:`json_format`                       :func:`replace_first`                     st_within                                     :func:`classification_miss_rate`
-    :func:`array_join`                        :func:`ends_with`                         :func:`json_parse`                        :func:`reverse`                           st_x                                          :func:`classification_precision`
-    array_least_frequent                      enum_key                                  :func:`json_size`                         rgb                                       st_xmax                                       :func:`classification_recall`
-    :func:`array_max`                         :func:`exp`                               key_sampling_percent                      :func:`round`                             st_xmin                                       :func:`classification_thresholds`
-    array_max_by                              expand_envelope                           :func:`laplace_cdf`                       :func:`rpad`                              st_y                                          convex_hull_agg
-    :func:`array_min`                         :func:`f_cdf`                             :func:`last_day_of_month`                 :func:`rtrim`                             st_ymax                                       :func:`corr`
-    array_min_by                              features                                  :func:`least`                             scale_qdigest                             st_ymin                                       :func:`count`
-    :func:`array_normalize`                   :func:`filter`                            :func:`length`                            :func:`second`                            :func:`starts_with`                           :func:`count_if`
-    :func:`array_position`                    :func:`filter`                            :func:`levenshtein_distance`              :func:`secure_rand`                       :func:`strpos`                                :func:`covar_pop`
-    :func:`array_remove`                      :func:`find_first`                        line_interpolate_point                    :func:`secure_random`                     :func:`strrpos`                               :func:`covar_samp`
-    :func:`array_sort`                        :func:`find_first_index`                  line_locate_point                         :func:`sequence`                          :func:`substr`                                differential_entropy
-    :func:`array_sort_desc`                   :func:`flatten`                           :func:`ln`                                :func:`sha1`                              :func:`tan`                                   :func:`entropy`
-    array_split_into_chunks                   flatten_geometry_collections              localtime                                 :func:`sha256`                            :func:`tanh`                                  evaluate_classifier_predictions
-    :func:`array_sum`                         :func:`floor`                             localtimestamp                            :func:`sha512`                            tdigest_agg                                   :func:`every`
-    array_top_n                               fnv1_32                                   :func:`log10`                             :func:`shuffle`                           :func:`timezone_hour`                         :func:`geometric_mean`
-    :func:`array_union`                       fnv1_64                                   :func:`log2`                              :func:`sign`                              :func:`timezone_minute`                       geometry_union_agg
-    :func:`arrays_overlap`                    fnv1a_32                                  :func:`lower`                             simplify_geometry                         :func:`to_base`                               :func:`histogram`
-    :func:`asin`                              fnv1a_64                                  :func:`lpad`                              :func:`sin`                               to_base32                                     khyperloglog_agg
-    :func:`atan`                              :func:`format_datetime`                   :func:`ltrim`                             sketch_kll_quantile                       :func:`to_base64`                             :func:`kurtosis`
-    :func:`atan2`                             :func:`from_base`                         :func:`map`                               sketch_kll_rank                           :func:`to_base64url`                          learn_classifier
-    bar                                       from_base32                               :func:`map_concat`                        :func:`slice`                             :func:`to_big_endian_32`                      learn_libsvm_classifier
-    :func:`beta_cdf`                          :func:`from_base64`                       :func:`map_entries`                       spatial_partitions                        :func:`to_big_endian_64`                      learn_libsvm_regressor
-    bing_tile                                 :func:`from_base64url`                    :func:`map_filter`                        :func:`split`                             to_geometry                                   learn_regressor
-    bing_tile_at                              :func:`from_big_endian_32`                :func:`map_from_entries`                  :func:`split_part`                        :func:`to_hex`                                make_set_digest
-    bing_tile_children                        :func:`from_big_endian_64`                :func:`map_keys`                          :func:`split_to_map`                      :func:`to_ieee754_32`                         :func:`map_agg`
-    bing_tile_coordinates                     :func:`from_hex`                          map_keys_by_top_n_values                  split_to_multimap                         :func:`to_ieee754_64`                         :func:`map_union`
-    bing_tile_parent                          :func:`from_ieee754_32`                   :func:`map_normalize`                     :func:`spooky_hash_v2_32`                 :func:`to_iso8601`                            :func:`map_union_sum`
-    bing_tile_polygon                         :func:`from_ieee754_64`                   :func:`map_remove_null_values`            :func:`spooky_hash_v2_64`                 :func:`to_milliseconds`                       :func:`max`
-    bing_tile_quadkey                         :func:`from_iso8601_date`                 :func:`map_subset`                        :func:`sqrt`                              to_spherical_geography                        :func:`max_by`
-    bing_tile_zoom_level                      :func:`from_iso8601_timestamp`            :func:`map_top_n`                         st_area                                   :func:`to_unixtime`                           :func:`merge`
-    bing_tiles_around                         :func:`from_unixtime`                     :func:`map_top_n_keys`                    st_asbinary                               :func:`to_utf8`                               merge_set_digest
-    :func:`binomial_cdf`                      :func:`from_utf8`                         map_top_n_keys_by_value                   st_astext                                 :func:`trail`                                 :func:`min`
-    :func:`bit_count`                         :func:`gamma_cdf`                         map_top_n_values                          st_boundary                               :func:`transform`                             :func:`min_by`
-    :func:`bitwise_and`                       geometry_as_geojson                       :func:`map_values`                        st_buffer                                 :func:`transform_keys`                        :func:`multimap_agg`
-    :func:`bitwise_arithmetic_shift_right`    geometry_from_geojson                     :func:`map_zip_with`                      st_centroid                               :func:`transform_values`                      noisy_avg_gaussian
-    :func:`bitwise_left_shift`                geometry_invalid_reason                   :func:`md5`                               st_contains                               :func:`trim`                                  noisy_count_gaussian
-    :func:`bitwise_logical_shift_right`       geometry_nearest_points                   merge_hll                                 st_convexhull                             :func:`trim_array`                            noisy_count_if_gaussian
-    :func:`bitwise_not`                       geometry_to_bing_tiles                    merge_khll                                st_coorddim                               :func:`truncate`                              noisy_sum_gaussian
-    :func:`bitwise_or`                        geometry_to_dissolved_bing_tiles          :func:`millisecond`                       st_crosses                                :func:`typeof`                                numeric_histogram
-    :func:`bitwise_right_shift`               geometry_union                            :func:`minute`                            st_difference                             uniqueness_distribution                       qdigest_agg
-    :func:`bitwise_right_shift_arithmetic`    great_circle_distance                     :func:`mod`                               st_dimension                              :func:`upper`                                 :func:`reduce_agg`
-    :func:`bitwise_shift_left`                :func:`greatest`                          :func:`month`                             st_disjoint                               :func:`url_decode`                            :func:`regr_avgx`
-    :func:`bitwise_xor`                       :func:`hamming_distance`                  :func:`multimap_from_entries`             st_distance                               :func:`url_encode`                            :func:`regr_avgy`
-    :func:`cardinality`                       hash_counts                               murmur3_x64_128                           st_endpoint                               :func:`url_extract_fragment`                  :func:`regr_count`
-    :func:`cauchy_cdf`                        :func:`hmac_md5`                          myanmar_font_encoding                     st_envelope                               :func:`url_extract_host`                      :func:`regr_intercept`
-    :func:`cbrt`                              :func:`hmac_sha1`                         myanmar_normalize_unicode                 st_envelopeaspts                          :func:`url_extract_parameter`                 :func:`regr_r2`
-    :func:`ceil`                              :func:`hmac_sha256`                       :func:`nan`                               st_equals                                 :func:`url_extract_path`                      :func:`regr_slope`
-    :func:`ceiling`                           :func:`hmac_sha512`                       :func:`ngrams`                            st_exteriorring                           :func:`url_extract_port`                      :func:`regr_sxx`
-    :func:`chi_squared_cdf`                   :func:`hour`                              :func:`no_keys_match`                     st_geometries                             :func:`url_extract_protocol`                  :func:`regr_sxy`
-    :func:`chr`                               :func:`infinity`                          :func:`no_values_match`                   st_geometryfromtext                       :func:`url_extract_query`                     :func:`regr_syy`
-    classify                                  intersection_cardinality                  :func:`none_match`                        st_geometryn                              :func:`uuid`                                  reservoir_sample
-    :func:`codepoint`                         :func:`inverse_beta_cdf`                  :func:`normal_cdf`                        st_geometrytype                           value_at_quantile                             :func:`set_agg`
-    color                                     inverse_binomial_cdf                      :func:`normalize`                         st_geomfrombinary                         values_at_quantiles                           :func:`set_union`
-    :func:`combinations`                      :func:`inverse_cauchy_cdf`                now                                       st_interiorringn                          :func:`week`                                  sketch_kll
-    :func:`concat`                            inverse_chi_squared_cdf                   :func:`parse_datetime`                    st_interiorrings                          :func:`week_of_year`                          sketch_kll_with_k
-    :func:`contains`                          inverse_f_cdf                             parse_duration                            st_intersection                           :func:`weibull_cdf`                           :func:`skewness`
-    :func:`cos`                               inverse_gamma_cdf                         parse_presto_data_size                    st_intersects                             :func:`width_bucket`                          spatial_partitioning
-    :func:`cosh`                              :func:`inverse_laplace_cdf`               :func:`pi`                                st_isclosed                               :func:`wilson_interval_lower`                 :func:`stddev`
-    :func:`cosine_similarity`                 :func:`inverse_normal_cdf`                pinot_binary_decimal_to_double            st_isempty                                :func:`wilson_interval_upper`                 :func:`stddev_pop`
-    :func:`crc32`                             inverse_poisson_cdf                       :func:`poisson_cdf`                       st_isring                                 :func:`word_stem`                             :func:`stddev_samp`
-    :func:`current_date`                      :func:`inverse_weibull_cdf`               :func:`pow`                               st_issimple                               :func:`xxhash64`                              :func:`sum`
-    current_time                              :func:`ip_prefix`                         :func:`power`                             st_isvalid                                :func:`year`                                  tdigest_agg
-    current_timestamp                         ip_prefix_collapse                        quantile_at_value                         st_length                                 :func:`year_of_week`                          :func:`var_pop`
-    current_timezone                          ip_prefix_subnets                         :func:`quarter`                           st_linefromtext                           :func:`yow`                                   :func:`var_samp`
-    :func:`date`                              ip_subnet_max                             :func:`radians`                           st_linestring                             :func:`zip`                                   :func:`variance`
-    :func:`date_add`                          ip_subnet_min                             :func:`rand`                              st_multipoint                             :func:`zip_with`
+    :func:`abs`                               :func:`date_format`                       :func:`ip_subnet_range`                   :func:`random`                            :func:`st_numpoints`                          :func:`approx_distinct`                       :func:`cume_dist`
+    :func:`acos`                              :func:`date_parse`                        :func:`is_finite`                         :func:`reduce`                            :func:`st_overlaps`                           :func:`approx_most_frequent`                  :func:`dense_rank`
+    :func:`all_match`                         :func:`date_trunc`                        :func:`is_infinite`                       :func:`regexp_extract`                    :func:`st_point`                              :func:`approx_percentile`                     :func:`first_value`
+    :func:`any_keys_match`                    :func:`day`                               :func:`is_json_scalar`                    :func:`regexp_extract_all`                :func:`st_pointn`                             :func:`approx_set`                            :func:`lag`
+    :func:`any_match`                         :func:`day_of_month`                      :func:`is_nan`                            :func:`regexp_like`                       :func:`st_points`                             :func:`arbitrary`                             :func:`last_value`
+    :func:`any_values_match`                  :func:`day_of_week`                       :func:`is_private_ip`                     :func:`regexp_replace`                    :func:`st_polygon`                            :func:`array_agg`                             :func:`lead`
+    :func:`array_average`                     :func:`day_of_year`                       :func:`is_subnet_of`                      :func:`regexp_split`                      :func:`st_relate`                             :func:`avg`                                   :func:`nth_value`
+    :func:`array_cum_sum`                     :func:`degrees`                           :func:`jaccard_index`                     regress                                   :func:`st_startpoint`                         :func:`bitwise_and_agg`                       :func:`ntile`
+    :func:`array_distinct`                    :func:`dot_product`                       :func:`json_array_contains`               :func:`reidentification_potential`        :func:`st_symdifference`                      :func:`bitwise_or_agg`                        :func:`percent_rank`
+    :func:`array_duplicates`                  :func:`dow`                               :func:`json_array_get`                    :func:`remove_nulls`                      :func:`st_touches`                            :func:`bool_and`                              :func:`rank`
+    :func:`array_except`                      :func:`doy`                               :func:`json_array_length`                 render                                    :func:`st_union`                              :func:`bool_or`                               :func:`row_number`
+    :func:`array_frequency`                   :func:`e`                                 :func:`json_extract`                      :func:`repeat`                            :func:`st_within`                             :func:`checksum`
+    :func:`array_has_duplicates`              :func:`element_at`                        :func:`json_extract_scalar`               :func:`replace`                           :func:`st_x`                                  :func:`classification_fall_out`
+    :func:`array_intersect`                   :func:`empty_approx_set`                  :func:`json_format`                       :func:`replace_first`                     :func:`st_xmax`                               :func:`classification_miss_rate`
+    :func:`array_join`                        :func:`ends_with`                         :func:`json_parse`                        :func:`reverse`                           :func:`st_xmin`                               :func:`classification_precision`
+    array_least_frequent                      :func:`enum_key`                          :func:`json_size`                         rgb                                       :func:`st_y`                                  :func:`classification_recall`
+    :func:`array_max`                         :func:`exp`                               key_sampling_percent                      :func:`round`                             :func:`st_ymax`                               :func:`classification_thresholds`
+    :func:`array_max_by`                      :func:`expand_envelope`                   l2_squared                                :func:`rpad`                              :func:`st_ymin`                               :func:`convex_hull_agg`
+    :func:`array_min`                         :func:`f_cdf`                             :func:`laplace_cdf`                       :func:`rtrim`                             :func:`starts_with`                           :func:`corr`
+    :func:`array_min_by`                      features                                  :func:`last_day_of_month`                 :func:`scale_qdigest`                     :func:`strpos`                                :func:`count`
+    :func:`array_normalize`                   :func:`filter`                            :func:`least`                             :func:`second`                            :func:`strrpos`                               :func:`count_if`
+    :func:`array_position`                    :func:`filter`                            :func:`length`                            :func:`secure_rand`                       :func:`substr`                                :func:`covar_pop`
+    :func:`array_remove`                      :func:`find_first`                        :func:`levenshtein_distance`              :func:`secure_random`                     :func:`tan`                                   :func:`covar_samp`
+    :func:`array_sort`                        :func:`find_first_index`                  :func:`line_interpolate_point`            :func:`sequence`                          :func:`tanh`                                  differential_entropy
+    :func:`array_sort_desc`                   :func:`flatten`                           :func:`line_locate_point`                 :func:`sha1`                              tdigest_agg                                   :func:`entropy`
+    array_split_into_chunks                   :func:`flatten_geometry_collections`      :func:`ln`                                :func:`sha256`                            :func:`timezone_hour`                         evaluate_classifier_predictions
+    :func:`array_sum`                         :func:`floor`                             :func:`localtime`                         :func:`sha512`                            :func:`timezone_minute`                       :func:`every`
+    :func:`array_top_n`                       fnv1_32                                   localtimestamp                            :func:`shuffle`                           :func:`to_base`                               :func:`geometric_mean`
+    :func:`array_union`                       fnv1_64                                   :func:`log10`                             :func:`sign`                              to_base32                                     :func:`geometry_union_agg`
+    :func:`arrays_overlap`                    fnv1a_32                                  :func:`log2`                              :func:`simplify_geometry`                 :func:`to_base64`                             :func:`histogram`
+    :func:`asin`                              fnv1a_64                                  :func:`longest_common_prefix`             :func:`sin`                               :func:`to_base64url`                          :func:`khyperloglog_agg`
+    :func:`atan`                              :func:`format_datetime`                   :func:`lower`                             sketch_kll_quantile                       :func:`to_big_endian_32`                      :func:`kurtosis`
+    :func:`atan2`                             :func:`from_base`                         :func:`lpad`                              sketch_kll_rank                           :func:`to_big_endian_64`                      learn_classifier
+    bar                                       :func:`from_base32`                       :func:`ltrim`                             :func:`slice`                             :func:`to_geometry`                           learn_libsvm_classifier
+    :func:`beta_cdf`                          :func:`from_base64`                       :func:`map`                               spatial_partitions                        :func:`to_hex`                                learn_libsvm_regressor
+    :func:`bing_tile`                         :func:`from_base64url`                    :func:`map_concat`                        :func:`split`                             :func:`to_ieee754_32`                         learn_regressor
+    :func:`bing_tile_at`                      :func:`from_big_endian_32`                :func:`map_entries`                       :func:`split_part`                        :func:`to_ieee754_64`                         :func:`make_set_digest`
+    :func:`bing_tile_children`                :func:`from_big_endian_64`                :func:`map_filter`                        :func:`split_to_map`                      :func:`to_iso8601`                            :func:`map_agg`
+    :func:`bing_tile_coordinates`             :func:`from_hex`                          :func:`map_from_entries`                  :func:`split_to_multimap`                 :func:`to_milliseconds`                       :func:`map_union`
+    :func:`bing_tile_parent`                  :func:`from_ieee754_32`                   :func:`map_keys`                          :func:`spooky_hash_v2_32`                 :func:`to_spherical_geography`                :func:`map_union_sum`
+    :func:`bing_tile_polygon`                 :func:`from_ieee754_64`                   :func:`map_keys_by_top_n_values`          :func:`spooky_hash_v2_64`                 :func:`to_unixtime`                           :func:`max`
+    :func:`bing_tile_quadkey`                 :func:`from_iso8601_date`                 :func:`map_normalize`                     :func:`sqrt`                              :func:`to_utf8`                               :func:`max_by`
+    :func:`bing_tile_zoom_level`              :func:`from_iso8601_timestamp`            :func:`map_remove_null_values`            :func:`st_area`                           :func:`trail`                                 :func:`merge`
+    :func:`bing_tiles_around`                 :func:`from_unixtime`                     :func:`map_subset`                        :func:`st_asbinary`                       :func:`transform`                             :func:`merge_set_digest`
+    :func:`binomial_cdf`                      :func:`from_utf8`                         :func:`map_top_n`                         :func:`st_astext`                         :func:`transform_keys`                        :func:`min`
+    :func:`bit_count`                         :func:`gamma_cdf`                         :func:`map_top_n_keys`                    :func:`st_boundary`                       :func:`transform_values`                      :func:`min_by`
+    :func:`bit_length`                        :func:`geometry_as_geojson`               map_top_n_keys_by_value                   :func:`st_buffer`                         :func:`trim`                                  :func:`multimap_agg`
+    :func:`bitwise_and`                       :func:`geometry_from_geojson`             :func:`map_top_n_values`                  :func:`st_centroid`                       :func:`trim_array`                            :func:`noisy_avg_gaussian`
+    :func:`bitwise_arithmetic_shift_right`    :func:`geometry_invalid_reason`           :func:`map_values`                        :func:`st_contains`                       :func:`truncate`                              :func:`noisy_count_gaussian`
+    :func:`bitwise_left_shift`                :func:`geometry_nearest_points`           :func:`map_zip_with`                      :func:`st_convexhull`                     :func:`typeof`                                :func:`noisy_count_if_gaussian`
+    :func:`bitwise_logical_shift_right`       :func:`geometry_to_bing_tiles`            :func:`md5`                               :func:`st_coorddim`                       :func:`uniqueness_distribution`               :func:`noisy_sum_gaussian`
+    :func:`bitwise_not`                       :func:`geometry_to_dissolved_bing_tiles`  :func:`merge_hll`                         :func:`st_crosses`                        :func:`upper`                                 :func:`numeric_histogram`
+    :func:`bitwise_or`                        :func:`geometry_union`                    :func:`merge_khll`                        :func:`st_difference`                     :func:`url_decode`                            :func:`qdigest_agg`
+    :func:`bitwise_right_shift`               google_polyline_decode                    :func:`millisecond`                       :func:`st_dimension`                      :func:`url_encode`                            :func:`reduce_agg`
+    :func:`bitwise_right_shift_arithmetic`    google_polyline_encode                    :func:`minute`                            :func:`st_disjoint`                       :func:`url_extract_fragment`                  :func:`regr_avgx`
+    :func:`bitwise_shift_left`                :func:`great_circle_distance`             :func:`mod`                               :func:`st_distance`                       :func:`url_extract_host`                      :func:`regr_avgy`
+    :func:`bitwise_xor`                       :func:`greatest`                          :func:`month`                             :func:`st_endpoint`                       :func:`url_extract_parameter`                 :func:`regr_count`
+    :func:`cardinality`                       :func:`hamming_distance`                  :func:`multimap_from_entries`             :func:`st_envelope`                       :func:`url_extract_path`                      :func:`regr_intercept`
+    :func:`cauchy_cdf`                        :func:`hash_counts`                       :func:`murmur3_x64_128`                   :func:`st_envelopeaspts`                  :func:`url_extract_port`                      :func:`regr_r2`
+    :func:`cbrt`                              :func:`hmac_md5`                          myanmar_font_encoding                     :func:`st_equals`                         :func:`url_extract_protocol`                  :func:`regr_slope`
+    :func:`ceil`                              :func:`hmac_sha1`                         myanmar_normalize_unicode                 :func:`st_exteriorring`                   :func:`url_extract_query`                     :func:`regr_sxx`
+    :func:`ceiling`                           :func:`hmac_sha256`                       :func:`nan`                               :func:`st_geometries`                     :func:`uuid`                                  :func:`regr_sxy`
+    :func:`chi_squared_cdf`                   :func:`hmac_sha512`                       :func:`ngrams`                            :func:`st_geometryfromtext`               :func:`value_at_quantile`                     :func:`regr_syy`
+    :func:`chr`                               :func:`hour`                              :func:`no_keys_match`                     :func:`st_geometryn`                      :func:`values_at_quantiles`                   :func:`reservoir_sample`
+    classify                                  :func:`infinity`                          :func:`no_values_match`                   :func:`st_geometrytype`                   :func:`week`                                  :func:`set_agg`
+    :func:`codepoint`                         :func:`intersection_cardinality`          :func:`none_match`                        :func:`st_geomfrombinary`                 :func:`week_of_year`                          :func:`set_union`
+    color                                     :func:`inverse_beta_cdf`                  :func:`normal_cdf`                        :func:`st_interiorringn`                  :func:`weibull_cdf`                           sketch_kll
+    :func:`combinations`                      :func:`inverse_binomial_cdf`              :func:`normalize`                         :func:`st_interiorrings`                  :func:`width_bucket`                          sketch_kll_with_k
+    :func:`concat`                            :func:`inverse_cauchy_cdf`                :func:`now`                               :func:`st_intersection`                   :func:`wilson_interval_lower`                 :func:`skewness`
+    :func:`contains`                          :func:`inverse_chi_squared_cdf`           :func:`parse_datetime`                    :func:`st_intersects`                     :func:`wilson_interval_upper`                 spatial_partitioning
+    :func:`cos`                               :func:`inverse_f_cdf`                     :func:`parse_duration`                    :func:`st_isclosed`                       :func:`word_stem`                             :func:`stddev`
+    :func:`cosh`                              :func:`inverse_gamma_cdf`                 :func:`parse_presto_data_size`            :func:`st_isempty`                        :func:`xxhash64`                              :func:`stddev_pop`
+    :func:`cosine_similarity`                 :func:`inverse_laplace_cdf`               :func:`pi`                                :func:`st_isring`                         :func:`year`                                  :func:`stddev_samp`
+    :func:`crc32`                             :func:`inverse_normal_cdf`                pinot_binary_decimal_to_double            :func:`st_issimple`                       :func:`year_of_week`                          :func:`sum`
+    :func:`current_date`                      :func:`inverse_poisson_cdf`               :func:`poisson_cdf`                       :func:`st_isvalid`                        :func:`yow`                                   :func:`tdigest_agg`
+    current_time                              :func:`inverse_weibull_cdf`               :func:`pow`                               :func:`st_length`                         :func:`zip`                                   :func:`var_pop`
+    :func:`current_timestamp`                 :func:`ip_prefix`                         :func:`power`                             :func:`st_linefromtext`                   :func:`zip_with`                              :func:`var_samp`
+    :func:`current_timezone`                  :func:`ip_prefix_collapse`                :func:`quantile_at_value`                 :func:`st_linestring`                                                                   :func:`variance`
+    :func:`date`                              :func:`ip_prefix_subnets`                 :func:`quarter`                           :func:`st_multipoint`
+    :func:`date_add`                          :func:`ip_subnet_max`                     :func:`radians`                           :func:`st_numgeometries`
+    :func:`date_diff`                         :func:`ip_subnet_min`                     :func:`rand`                              :func:`st_numinteriorring`
     ========================================  ========================================  ========================================  ========================================  ========================================  ==  ========================================  ==  ========================================
diff --git a/velox/docs/functions/presto/datetime.rst b/velox/docs/functions/presto/datetime.rst
index 98e42dac552b..cb19b2f75da8 100644
--- a/velox/docs/functions/presto/datetime.rst
+++ b/velox/docs/functions/presto/datetime.rst
@@ -144,7 +144,10 @@ Date and Time Functions
 
 .. function:: from_unixtime(unixtime) -> timestamp
 
-    Returns the UNIX timestamp ``unixtime`` as a timestamp.
+    Returns the UNIX timestamp ``unixtime`` as a timestamp.  If the
+    :doc:`adjust_timestamp_to_session_timezone <../../configs>` property is set
+    to true, then the timestamp is adjusted to the time zone specified in
+    :doc:`session_timezone <../../configs>`.
 
 .. function:: from_unixtime(unixtime, string) -> timestamp with time zone
     :noindex:
@@ -177,6 +180,27 @@ Date and Time Functions
 
     Returns ``timestamp`` as a UNIX timestamp.
 
+.. function:: current_timezone() -> varchar
+
+    Returns the current session time zone as a varchar.
+
+    Example::
+
+        SELECT current_timezone;   -- Asia/Kolkata
+
+.. function:: current_timestamp() -> timestamp with time zone
+.. function:: now() -> timestamp with time zone
+
+    Returns the current timestamp with session time zone applied.
+    The timestamp is captured once at the start of query execution and remains
+    constant throughout the query. This matches the standard SQL behavior for
+    ``CURRENT_TIMESTAMP`` and ``NOW()``.
+
+    Example::
+
+        SELECT current_timestamp;  -- 2025-07-17 14:53:12.123 Asia/Kolkata
+        SELECT now();              -- 2025-07-17 14:53:12.123 Asia/Kolkata
+
 Truncation Function
 -------------------
 
diff --git a/velox/docs/functions/presto/enum.rst b/velox/docs/functions/presto/enum.rst
new file mode 100644
index 000000000000..8e1a11d82b87
--- /dev/null
+++ b/velox/docs/functions/presto/enum.rst
@@ -0,0 +1,11 @@
+==============
+Enum Functions
+==============
+
+.. function:: enum_key(x) -> varchar
+
+    Returns the string key of the enum value, where ``x`` is either a BigintEnum or VarcharEnum value. ::
+
+        SELECT enum_key(alpha.A); -- "A"
+
+    where alpha is a BigintEnum type with name "alpha" and values {"A": 1, "B": 2}
diff --git a/velox/docs/functions/presto/geospatial.rst b/velox/docs/functions/presto/geospatial.rst
index 63a80da47c33..4ae9f461a333 100644
--- a/velox/docs/functions/presto/geospatial.rst
+++ b/velox/docs/functions/presto/geospatial.rst
@@ -43,9 +43,6 @@ the coordinate order is (x, y). The details of both WKT and WKB can be found
 `here
 <https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry>`_.
 
-.. _OpenGIS Specifications: https://www.ogc.org/standards/ogcapi-features/
-.. _SQL/MM Part 3: Spatial: https://www.iso.org/standard/31369.html
-
 Geometry Constructors
 ---------------------
 
@@ -72,6 +69,44 @@ Geometry Constructors
     Returns the Point geometry at the given coordinates.  This will raise an
     error if ``x`` or ``y`` is ``NaN`` or ``infinity``.
 
+.. function:: ST_Polygon(wkt: varchar) -> polygon: Geometry
+
+    Returns a geometry type polygon object from WKT representation.
+
+.. function:: ST_LineFromText(wkt: varchar) -> linestring: Geometry
+
+    Returns a geometry type linestring object from WKT representation.
+    An error is returned if the input WKT represents a valid non-LineString
+    geometry. Null input returns null output.
+
+.. function:: ST_LineString(points: array(Geometry)) -> linestring: Geometry
+
+    Returns a LineString formed from an array of points. If there are fewer
+    than two non-empty points in the input array, an empty LineString will
+    be returned. Throws an exception if any element in the array is null or
+    empty or same as the previous one. The returned geometry may not be simple,
+    e.g. may self-intersect or may contain duplicate vertexes depending on the
+    input.
+
+.. function:: ST_MultiPoint(points: array(Geometry)) -> multipoint: Geometry
+
+    Returns a MultiPoint geometry object formed from the specified points.
+    Return null if input array is empty. Throws an exception if any element
+    in the array is null or empty. The returned geometry may not be simple
+    and may contain duplicate points if input array has duplicates.
+
+.. function:: to_spherical_geography(input: Geometry) -> output: SphericalGeography
+
+    Converts a ``Geometry`` object to a SphericalGeography object on the sphere
+    of the Earth’s radius. For each point of the input geometry, it verifies that
+    point.x is within [-180.0, 180.0] and point.y is within [-90.0, 90.0],
+    and uses them as (longitude, latitude) degrees to construct the shape
+    of the ``SphericalGeography`` result.
+
+.. function:: to_geometry(input: SphericalGeography) -> output: Geometry
+
+    Converts a SphericalGeography object to a Geometry object.
+
 Spatial Predicates
 ------------------
 
@@ -113,7 +148,7 @@ function you are using.
     Returns ``true`` if the given geometries share space, are of the same
     dimension, but are not completely contained by each other.
 
-.. function:: ST_Relat(geometry1: Geometry, geometry2: Geometry, relation: varchar) -> boolean
+.. function:: ST_Relate(geometry1: Geometry, geometry2: Geometry, relation: varchar) -> boolean
 
     Returns true if first geometry is spatially related to second geometry as
     described by the relation.  The relation is a string like ``'"1*T***T**'``:
@@ -134,6 +169,11 @@ function you are using.
 Spatial Operations
 ------------------
 
+.. function:: ST_Boundary(geometry: Geometry) -> boundary: Geometry
+
+    Returns the closure of the combinatorial boundary of ``geometry``.
+     Empty geometry inputs result in empty output.
+
 .. function:: ST_Difference(geometry1: Geometry, geometry2: Geometry) -> difference: Geometry
 
     Returns the geometry that represents the portion of ``geometry1`` that is
@@ -155,8 +195,119 @@ Spatial Operations
     Returns the geometry that represents the all points in either ``geometry1``
     or ``geometry2``.
 
+.. function:: ST_Envelope(geometry: Geometry) -> envelope: Geometry
+
+    Returns the bounding rectangular polygon of a ``geometry``. Empty input will
+    result in empty output.
+
+.. function:: ST_ExteriorRing(geometry: Geometry) -> output: Geometry
+
+    Returns a LineString representing the exterior ring of the input polygon.
+    Empty or null inputs result in null output. Non-polygon types will return
+    an error.
+
+.. function:: expand_envelope(geometry: Geometry, distance: double) -> output: Geometry
+
+    Returns the bounding rectangular polygon of a geometry, expanded by a distance.
+    Empty geometries will return an empty polygon. Negative or NaN distances will
+    return an error. Positive infinity distances may lead to undefined results.
+
+.. function:: geometry_union(geometries: array(Geometry)) -> union: Geometry
+
+    Returns a geometry that represents the point set union of the input geometries.
+    Performance of this function, in conjunction with array_agg() to first
+    aggregate the input geometries, may be better than geometry_union_agg(),
+    at the expense of higher memory utilization. Null elements in the input
+    array are ignored. Empty array input returns null.
+
+.. function:: geometry_union_agg(geometry: Geometry) -> union: Geometry
+
+    Returns a geometry that represents the point set union of the aggregated
+    input geometries. Null geometries are ignored. Empty input returns null.
+
+.. function:: convex_hull_agg(geometry: Geometry) -> union: Geometry
+
+    Returns a geometry that represents the convex hull of the points in the
+    aggregated input geometries.  Null geometries are ignored. Empty input
+    returns null.
+
 Accessors
 ---------
+.. function:: ST_IsValid(geometry: Geometry) -> valid: bool
+
+    Returns if ``geometry`` is valid, according to `SQL/MM Part 3: Spatial`_.
+    Examples of non-valid geometries include Polygons with self-intersecting shells.
+
+.. function:: ST_IsSimple(geometry: Geometry) -> simple: bool
+
+    Returns if ``geometry`` is simple, according to `SQL/MM Part 3: Spatial`_.
+    Examples of non-simple geometries include LineStrings with self-intersections,
+    Polygons with empty rings for holes, and more.
+
+.. function:: ST_IsClosed(geometry: Geometry) -> closed: bool
+
+    Returns true if the LineString’s start and end points are coincident. Will
+    return an error if the input geometry is not a LineString or MultiLineString.
+
+.. function:: ST_IsRing(geometry: Geometry) -> ring: bool
+
+   Returns true if and only if the line is closed and simple. Will return an error
+   if input geometry is not a LineString.
+
+.. function:: ST_IsEmpty(geometry: Geometry) -> empty: bool
+
+   Returns true if and only if this Geometry is an empty GeometryCollection, Polygon,
+   Point etc.
+
+.. function:: ST_Length(geometry: Geometry) -> length: double
+
+   Returns the length of a LineString or MultiLineString using Euclidean measurement
+   on a two dimensional plane (based on spatial ref) in projected units. Will
+   return an error if the input geometry is not a LineString or MultiLineString.
+
+.. function:: ST_Length(sphericalgeography: SphericalGeography) -> length: double
+
+    Returns the length of a ``LineString`` or ``MultiLineString`` on a spherical model of the
+    Earth. This is equivalent to the sum of great-circle distances between adjacent points
+    on the ``LineString``.
+
+.. function:: ST_PointN(linestring: Geometry, index: integer) -> point: geometry
+
+   Returns the vertex of a LineString at a given index (indices start at 1).
+   If the given index is less than 1 or greater than the total number of elements
+   in the collection, returns NULL.
+
+.. function:: ST_Points(geometry: Geometry) -> points: array(geometry)
+
+   Returns an array of points in a geometry. Empty or null inputs
+   return null.
+
+.. function:: ST_NumPoints(geometry: Geometry) -> points: bigint
+
+   Returns the number of points in a geometry. This is an extension
+   to the SQL/MM ``ST_NumPoints`` function which only applies to
+   point and linestring.
+
+.. function:: geometry_nearest_points(geometry1: Geometry, geometry2: Geometry) -> points: array(geometry)
+
+   Returns the points on each geometry nearest the other. If either geometry
+   is empty, return null. Otherwise, return an array of two Points that have
+   the minimum distance of any two points on the geometries. The first Point
+   will be from the first Geometry argument, the second from the second Geometry
+   argument. If there are multiple pairs with the minimum distance, one pair
+   is chosen arbitrarily.
+
+.. function:: ST_EnvelopeAsPts(geometry: Geometry) -> points: array(geometry)
+
+   Returns an array of two points: the lower left and upper right corners
+   of the bounding rectangular polygon of a geometry. Empty or null inputs
+   return null.
+
+.. function:: geometry_invalid_reason(geometry: Geometry) -> reason: varchar
+
+    If ``geometry`` is not valid or not simple, return a description of the
+    reason. If the geometry is valid and simple (or ``NULL``), return ``NULL``.
+    This function is relatively expensive.
 
 .. function:: ST_Area(geometry: Geometry) -> area: double
 
@@ -165,6 +316,40 @@ Accessors
     returns the sum of the areas of the individual geometries. Empty geometries
     return 0.
 
+.. function:: ST_Area(sphericalgeography: SphericalGeography) -> area: double
+
+    Returns the area of a polygon or multi-polygon in square meters using a spherical model for Earth.
+
+.. function:: ST_Centroid(geometry: Geometry) -> geometry: Geometry
+
+    Returns the point value that is the mathematical centroid of ``geometry``.
+    Empty geometry inputs result in empty output.
+
+.. function:: ST_Centroid(SphericalGeography) -> Point
+
+    Returns the point value that is the mathematical centroid of a spherical geometry.
+    Empty geometry inputs result in null output.
+
+    It supports Points and MultiPoints as input and returns the three-dimensional
+    centroid projected onto the surface of the (spherical) Earth.
+    For example, MULTIPOINT (0 -45, 0 45, 30 0, -30 0) returns Point(0, 0).
+    Note: In the case that the three-dimensional centroid is at (0, 0, 0)
+    (e.g. MULTIPOINT (0 0, -180 0)), the spherical centroid is undefined and an
+    arbitrary point will be returned.
+
+.. function:: ST_Distance(geometry1: Geometry, geometry2: Geometry) -> distance: double
+
+    Returns the 2-dimensional cartesian minimum distance (based on spatial ref)
+    between two geometries in projected units. Empty geometries result in null output.
+
+.. function:: ST_Distance(sphericalgeography1: SphericalGeography, sphericalgeography2: SphericalGeography) -> distance: double
+
+    Returns the great-circle distance in meters between two SphericalGeography points.
+
+.. function:: ST_GeometryType(geometry: Geometry) -> type: varchar
+
+    Returns the type of the geometry.
+
 .. function:: ST_X(geometry: Geometry) -> x: double
 
     Returns the ``x`` coordinate of the geometry if it is a Point.  Returns
@@ -177,6 +362,162 @@ Accessors
     ``null`` if the geometry is empty.  Raises an error if the geometry is
     not a Point and not empty.
 
+.. function:: ST_XMin(geometry: Geometry) -> x: double
+
+    Returns the minimum ``x`` coordinate of the geometries bounding box.
+    Returns ``null`` if the geometry is empty.
+
+.. function:: ST_YMin(geometry: Geometry) -> y: double
+
+    Returns the minimum ``y`` coordinate of the geometries bounding box.
+    Returns ``null`` if the geometry is empty.
+
+.. function:: ST_XMax(geometry: Geometry) -> x: double
+
+    Returns the maximum ``x`` coordinate of the geometries bounding box.
+    Returns ``null`` if the geometry is empty.
+
+.. function:: ST_YMax(geometry: Geometry) -> y: double
+
+    Returns the maximum ``y`` coordinate of the geometries bounding box.
+    Returns ``null`` if the geometry is empty.
+
+.. function:: ST_StartPoint(geometry: Geometry) -> point: Geometry
+
+    Returns the first point of a LineString geometry as a Point.
+    This is a shortcut for ``ST_PointN(geometry, 1)``. Empty
+    input will return ``null``.
+
+.. function:: ST_EndPoint(geometry: Geometry) -> point: Geometry
+
+    Returns the last point of a LineString geometry as a Point.
+    This is a shortcut for ``ST_PointN(geometry, ST_NumPoints(geometry))``.
+    Empty input will return ``null``.
+
+.. function:: ST_GeometryN(geometry: Geometry, index: integer) -> geometry: Geometry
+
+    Returns the ``geometry`` element at a given index (indices start at 1).
+    If the ``geometry`` is a collection of geometries (e.g., GeometryCollection or
+    Multi*), returns the ``geometry`` at a given index. If the given index is less
+    than 1 or greater than the total number of elements in the collection, returns
+    NULL. Use ``:func:ST_NumGeometries`` to find out the total number of elements.
+    Singular geometries (e.g., Point, LineString, Polygon), are treated as
+    collections of one element. Empty geometries are treated as empty collections.
+
+.. function:: ST_InteriorRingN(geometry: Geometry, index: integer) -> geometry: Geometry
+
+    Returns the interior ring element at the specified index (indices start at 1).
+    If the given index is less than 1 or greater than the total number of interior
+    rings in the input ``geometry``, returns NULL. Throws an error if the input geometry
+    is not a polygon. Use ``:func:ST_NumInteriorRing`` to find out the total number of
+    elements.
+
+.. function:: ST_NumGeometries(geometry: Geometry) -> output: integer
+
+    Returns the number of geometries in the collection. If the geometry is a
+    collection of geometries (e.g., GeometryCollection or Multi*),
+    returns the number of geometries, for single geometries returns 1,
+    for empty geometries returns 0. Note that empty geometries inside of a
+    GeometryCollection will count as a geometry if and only if there is at
+    least 1 non-empty geometry in the collection. e.g.
+    ``ST_NumGeometries(ST_GeometryFromText('GEOMETRYCOLLECTION(POINT EMPTY)'))``
+    will evaluate to 0, but
+    ``ST_NumGeometries(ST_GeometryFromText('GEOMETRYCOLLECTION(POINT EMPTY, POINT (1 2))'))``
+    will evaluate to 1.
+
+.. function:: ST_InteriorRings(geometry: Geometry) -> output: array(geometry)
+
+    Returns an array of all interior rings found in the input geometry,
+    or an empty array if the polygon has no interior rings. Returns
+    null if the input geometry is empty.
+    Throws an error if the input geometry is not a polygon.
+
+.. function:: ST_Geometries(geometry: Geometry) -> output: array(geometry)
+
+    Returns an array of geometries in the specified collection. Returns
+    a one-element array if the input geometry is not a multi-geometry.
+    Returns null if input geometry is empty. For example, a MultiLineString
+    will create an array of LineStrings. A GeometryCollection will
+    produce an un-flattened array of its constituents:
+    GEOMETRYCOLLECTION (MULTIPOINT(0 0, 1 1),
+    GEOMETRYCOLLECTION (MULTILINESTRING((2 2, 3 3))) ) would produce
+    array[MULTIPOINT(0 0, 1 1), GEOMETRYCOLLECTION( MULTILINESTRING((2 2, 3 3)) )]
+
+.. function:: flatten_geometry_collections(geometry: Geometry) -> output: array(geometry)
+
+    Recursively flattens any GeometryCollections in Geometry, returning an array
+    of constituent non-GeometryCollection geometries. The order of the array
+    is arbitrary and should not be relied upon. null input results in null output.
+    Examples:
+
+    POINT (0 0) -> [POINT (0 0)], MULTIPOINT (0 0, 1 1) -> [MULTIPOINT (0 0, 1 1)],
+    GEOMETRYCOLLECTION (POINT (0 0), GEOMETRYCOLLECTION (POINT (1 1))) ->
+    [POINT (0 0), POINT (1 1)], GEOMETRYCOLLECTION EMPTY -> [].
+
+.. function:: ST_NumInteriorRing(geometry: Geometry) -> output: bigint
+
+    Returns the cardinality of the collection of interior rings of a polygon.
+
+.. function:: ST_ConvexHull(geometry: Geometry) -> output: Geometry
+
+    Returns the minimum convex geometry that encloses all input geometries.
+
+.. function:: ST_CoordDim(geometry: Geometry) -> output: tinyint
+
+    Return the coordinate dimension of the geometry.
+
+.. function:: ST_Dimension(geometry: Geometry) -> output: tinyint
+
+    Returns the inherent dimension of this geometry object, which
+    must be less than or equal to the coordinate dimension.
+
+.. function:: ST_ExteriorRing(geometry: Geometry) -> output: Geometry
+
+    Returns a line string representing the exterior ring of the input polygon.
+
+.. function:: ST_Buffer(geometry: Geometry, distance: double) -> output: Geometry
+
+    Returns the geometry that represents all points whose distance from the
+    specified ``geometry`` is less than or equal to the specified ``distance``.
+    If the points of the ``geometry`` are extremely close together
+    (delta < 1e-8), this might return an empty geometry. Empty inputs return
+    null.
+
+.. function:: simplify_geometry(geometry: Geometry, tolerance: double) -> output: Geometry
+
+    Returns a "simplified" version of the input geometry using the
+    Douglas-Peucker algorithm. Will avoid creating geometries (polygons in
+    particular) that are invalid. Tolerance must be a non-negative finite value.
+    Using tolerance of 0 will return the original geometry.  Empty geometries
+    will also be returned as-is.
+
+.. function:: line_locate_point(linestring: Geometry, point: Geometry) -> output: double
+
+    Returns a float between 0 and 1 representing the location of the closest
+    point on the LineString to the given Point, as a fraction of total 2d line length.
+
+    Returns null if a LineString or a Point is empty or null.
+
+.. function:: line_interpolate_point(linestring: Geometry, fraction: double) -> output: geometry
+
+    Returns the Point on the LineString at a fractional distance given by
+    the double argument. Throws an exception if the distance is not between 0 and 1.
+
+    Returns an empty Point if the LineString is empty.
+    Returns null if either the LineString or double is null.
+
+.. function:: geometry_as_geojson(geometry: Geometry) -> output: varchar
+
+    Returns the GeoJSON encoded defined by the input geometry. If the
+    geometry is atomic (non-multi) empty, this function would return null.
+    Null input returns null output.
+
+.. function:: geometry_from_geojson(geometry: varchar) -> output: geometry
+
+    Returns the geometry type object from the GeoJSON representation.
+    The geometry cannot be empty if it is an atomic (non-multi) geometry type.
+    Null input returns null output.
+
 Bing Tile Functions
 -------------------
 
@@ -243,3 +584,20 @@ for more details.
 .. function:: bing_tile_quadkey() -> quadKey: varchar
 
     Returns the quadkey representing the provided bing tile.
+
+.. function:: geometry_to_bing_tiles(geometry: Geometry, zoom_level: tinyint) -> tiles: array(BingTile)
+
+    Returns the minimum set of Bing tiles that fully covers a given geometry at a
+    given zoom level. Empty inputs return an empty array, and null inputs return
+    null.
+
+.. function:: geometry_to_dissolved_bing_tiles(geometry: Geometry, max_zoom_level: tinyint) -> tile: array(BingTile)
+
+    Returns the minimum set of Bing tiles that fully covers a given geometry at a
+    given zoom level, recursively dissolving full sets of children into parents.
+    This results in a smaller array of tiles of different zoom levels.
+    For example, if the non-dissolved covering is [“00”, “01”, “02”, “03”, “10”],
+    the dissolved covering would be [“0”, “10”]. Zoom levels from 0 to 23 are supported.
+
+.. _OpenGIS Specifications: https://www.ogc.org/standards/ogcapi-features/
+.. _SQL/MM Part 3: Spatial: https://www.iso.org/standard/31369.html
diff --git a/velox/docs/functions/presto/hyperloglog.rst b/velox/docs/functions/presto/hyperloglog.rst
index ecd8e6d384ab..fd10739f5a53 100644
--- a/velox/docs/functions/presto/hyperloglog.rst
+++ b/velox/docs/functions/presto/hyperloglog.rst
@@ -70,3 +70,10 @@ Functions
 
     Returns the ``HyperLogLog`` of the aggregate union of the individual ``hll``
     HyperLogLog structures.
+
+.. function:: merge_hll(array(HyperLogLog)) -> HyperLogLog
+
+    Returns the ``HyperLogLog`` of the union of an array of ``HyperLogLog`` structures.
+
+    * Returns ``NULL`` if the input array is ``NULL``, empty, or contains only ``NULL`` elements
+    * Ignores ``NULL`` elements and merges only valid ``HyperLogLog`` structures when the array contains a mix of ``NULL`` and non-null elements
diff --git a/velox/docs/functions/presto/map.rst b/velox/docs/functions/presto/map.rst
index c81d7eba948b..51c74d2bdc84 100644
--- a/velox/docs/functions/presto/map.rst
+++ b/velox/docs/functions/presto/map.rst
@@ -46,6 +46,18 @@ Map Functions
 
     See also :func:`map_agg` for creating a map as an aggregation.
 
+.. function:: map_append(map(K,V), array(K), array(V)) -> map(K,V)
+
+    Returns a map with new key-value pairs appended to the input map. The new keys are provided in the first array parameter and corresponding values in the second array parameter.
+    Keys and values arrays must have the same length. New keys must not already exist in the input map. Duplicate keys in the new keys array are not allowed.
+    Null keys are ignored. Null values are preserved in the output map. For REAL and DOUBLE, NaNs (Not-a-Number) are considered equal. ::
+
+        SELECT map_append(MAP(ARRAY[1, 2], ARRAY[10, 20]), ARRAY[3, 4], ARRAY[30, 40]); -- {1 -> 10, 2 -> 20, 3 -> 30, 4 -> 40}
+        SELECT map_append(MAP(ARRAY['a', 'b'], ARRAY[1, 2]), ARRAY['c'], ARRAY[3]); -- {'a' -> 1, 'b' -> 2, 'c' -> 3}
+        SELECT map_append(MAP(ARRAY[1], ARRAY[10]), ARRAY[2, null, 3], ARRAY[20, 30, 40]); -- {1 -> 10, 2 -> 20, 3 -> 40}
+        SELECT map_append(MAP(ARRAY[1], ARRAY[10]), ARRAY[2, 3], ARRAY[null, 30]); -- {1 -> 10, 2 -> null, 3 -> 30}
+        SELECT map_append(MAP(ARRAY[1], ARRAY[10]), ARRAY[], ARRAY[]); -- {1 -> 10}
+
 .. function:: map_concat(map1(K,V), map2(K,V), ..., mapN(K,V)) -> map(K,V)
 
    Returns the union of all the given maps. If a key is found in multiple given maps,
@@ -94,6 +106,16 @@ Map Functions
         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:: remap_keys(map(K,V), array(K), array(K)) -> map(K,V)
+
+      Returns a map with keys remapped according to the oldKeys and newKeys arrays.
+      Unmapped keys remain unchanged. Values are preserved. Null keys are ignored. ::
+
+          SELECT remap_keys(MAP(ARRAY[1, 2, 3], ARRAY[10, 20, 30]), ARRAY[1, 3], ARRAY[100, 300]); -- {100 -> 10, 2 -> 20, 300 -> 30}
+          SELECT remap_keys(MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]), ARRAY['a', 'c'], ARRAY['alpha', 'charlie']); -- {alpha -> 1, b -> 2, charlie -> 3}
+          SELECT remap_keys(MAP(ARRAY[1, 2, 3], ARRAY[10, null, 30]), ARRAY[1, 2], ARRAY[100, 200]); -- {100 -> 10, 200 -> null, 3 -> 30}
+          SELECT remap_keys(MAP(ARRAY[1, 2], ARRAY[10, 20]), ARRAY[], ARRAY[]); -- {1 -> 10, 2 -> 20}
+
 .. 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
@@ -102,8 +124,40 @@ Map Functions
         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]); -- {}
+        SELECT map_subset(MAP(ARRAY[], ARRAY[]), ARRAY[]); -- {}
+
+.. function:: map_intersect(map(K,V), array(K)) -> map(K,V)
+
+    Returns a map containing only the entries from the input map whose keys are present in the given array.
+    This function is equivalent to map_subset. Null keys in the array are ignored.
+    For keys containing REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
+
+        SELECT map_intersect(MAP(ARRAY[1,2,3], ARRAY['a','b','c']), ARRAY[1,3]); -- {1->'a', 3->'c'}
+        SELECT map_intersect(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[10]); -- {}
+        SELECT map_intersect(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[]); -- {}
+        SELECT map_intersect(MAP(ARRAY[], ARRAY[]), ARRAY[1,2]); -- {}
+
+.. function:: map_except(map(K,V), array(k)) -> map(K,V)
+
+    Constructs a map from those entries of ``map`` for which the key is not in the array given.
+    For keys containing REAL and DOUBLE, NANs (Not-a-Number) are considered equal. ::
+
+        SELECT map_except(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[10]); -- {1->'a', 2->'b'}
+        SELECT map_except(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1]); -- {2->'b'}
+        SELECT map_except(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[1,3]); -- {2->'b'}
+        SELECT map_except(MAP(ARRAY[1,2], ARRAY['a','b']), ARRAY[]); -- {1->'a', 2->'b'}
+        SELECT map_except(MAP(ARRAY[], ARRAY[]), ARRAY[1,2]); -- {}
+
+.. function:: map_keys_overlap(map(K,V), array(K)) -> boolean
+
+    Returns true if any key in the map matches any element in the given array, false otherwise.
+    Returns false if either the map or array is empty. Null keys in the array are ignored. ::
+
+        SELECT map_keys_overlap(MAP(ARRAY[1, 2, 3], ARRAY[10, 20, 30]), ARRAY[1, 5]); -- true
+        SELECT map_keys_overlap(MAP(ARRAY[1, 2, 3], ARRAY[10, 20, 30]), ARRAY[4, 5]); -- false
+        SELECT map_keys_overlap(MAP(ARRAY['a', 'b'], ARRAY[1, 2]), ARRAY['a']); -- true
+        SELECT map_keys_overlap(MAP(ARRAY[], ARRAY[]), ARRAY[1]); -- false
 
 .. function:: map_top_n(map(K,V), n) -> map(K, V)
 
diff --git a/velox/docs/functions/presto/math.rst b/velox/docs/functions/presto/math.rst
index 7de371d10249..91e3cc7e6a20 100644
--- a/velox/docs/functions/presto/math.rst
+++ b/velox/docs/functions/presto/math.rst
@@ -51,6 +51,47 @@ Mathematical Functions
 
         SELECT cosine_similarity(ARRAY[], ARRAY[]); -- NaN
 
+.. function:: cosine_similarity(array(real), array(real)) -> real
+
+    Returns the `cosine similarity <https://en.wikipedia.org/wiki/Cosine_similarity>`_ between the vectors represented as array(real).
+    If any input array is empty, the function returns NaN. If the input arrays have different sizes, the function throws VeloxUserError.
+
+.. function:: l2_squared(array(real), array(real)) -> real
+
+    Returns the squared `Euclidean distance <https://en.wikipedia.org/wiki/Euclidean_distance>`_ between the vectors represented as array(real).
+    If any input array is empty, the function returns NaN. If the input arrays have different sizes, the function throws VeloxUserError.
+
+        SELECT l2_squared(ARRAY[1], ARRAY[2]); -- 1.0
+
+        SELECT l2_squared(ARRAY[1.0, 2.0], ARRAY[NULL, 3.0]); -- NULL
+
+        SELECT l2_squared(ARRAY[], ARRAY[2, 3]); -- Throws VeloxUserError
+
+        SELECT l2_squared(ARRAY[], ARRAY[]); -- NaN
+
+.. function:: l2_squared(array(double), array(double)) -> double
+
+    Returns the squared `Euclidean distance <https://en.wikipedia.org/wiki/Euclidean_distance>`_ between the vectors represented as array(double).
+    If any input array is empty, the function returns NaN. If the input arrays have different sizes, the function throws VeloxUserError.
+
+.. function:: dot_product(array(real), array(real)) -> real
+
+    Returns the `Dot Product <https://en.wikipedia.org/wiki/Dot_product>`_ between the vectors represented as array(real).
+    If any input array is empty, the function returns NaN. If the input arrays have different sizes, the function throws VeloxUserError.
+
+        SELECT dot_product(ARRAY[1], ARRAY[2]); -- 2.0
+
+        SELECT dot_product(ARRAY[1.0, 2.0], ARRAY[NULL, 3.0]); -- NULL
+
+        SELECT dot_product(ARRAY[], ARRAY[2, 3]); -- Throws VeloxUserError
+
+        SELECT dot_product(ARRAY[], ARRAY[]); -- NaN
+
+.. function:: dot_product(array(double), array(double)) -> double
+
+    Returns the `Dot Product <https://en.wikipedia.org/wiki/Dot_product>`_ between the vectors represented as array(double).
+    If any input array is empty, the function returns NaN. If the input arrays have different sizes, the function throws VeloxUserError.
+
 .. function:: degrees(x) -> double
 
     Converts angle x in radians to degrees.
@@ -342,6 +383,10 @@ Probability Functions: cdf
     Compute the Poisson cdf with given lambda (mean) parameter:  P(N <= value; lambda).
     The lambda parameter must be a positive real number (of type DOUBLE) and value must be a non-negative integer.
 
+.. function:: t_cdf(df, value) -> double
+
+    Compute the Student's t cdf with given degrees of freedom:  P(N < value; df).
+    The degrees of freedom must be a positive real number and value must be a real value.
 
 .. function:: weibull_cdf(a, b, value) -> double
 
@@ -375,6 +420,51 @@ Probability Functions: inverse_cdf
     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].
 
+.. function:: inverse_f_cdf(df1, df2, p) -> double
+
+    Compute the inverse of the Fisher F cdf with a given ``df1`` (numerator degrees of freedom) and ``df2`` (denominator degrees of freedom) parameters
+    for the cumulative probability (p): P(N < n). The numerator and denominator df parameters must be positive real numbers.
+    The probability ``p`` must lie on the interval [0, 1].
+
+.. 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:: inverse_gamma_cdf(shape, scale, p) -> double
+
+    Compute the inverse of the Gamma cdf with given shape and scale parameters for the cumulative
+    probability (p): P(N < n). The shape and scale parameters must be positive real values.
+    The probability p must lie on the interval [0, 1].
+
+.. function:: inverse_binomial_cdf(numberOfTrials, successProbability, p) -> int
+
+    Compute the inverse of the Binomial cdf with given numberOfTrials and successProbability (of a single trial) the
+    cumulative probability (p):  P(N <= n).
+    The successProbability and p must be real values in [0, 1] and the numberOfTrials must be
+    a positive integer.
+
+.. function:: inverse_poisson_cdf(lambda, p) -> integer
+
+    Compute the inverse of the Poisson cdf with given lambda (mean) parameter for the cumulative
+    probability (p). It returns the value of n so that: P(N <= n; lambda) = p.
+    The lambda parameter must be a positive real number (of type DOUBLE).
+    The probability p must lie on the interval [0, 1).
+
+.. function:: inverse_chi_squared_cdf(df, p) -> double
+
+    Compute the inverse of the Chi-square cdf with given df (degrees of freedom) parameter for the cumulative
+    probability (p): P(N < n). The df parameter must be positive real values.
+    The probability p must lie on the interval [0, 1].
+
+.. function:: inverse_t_cdf(df, p) -> double
+
+    Compute the inverse of the Student's t cdf with given degrees of freedom for the cumulative
+    probability (p): P(N < n). The degrees of freedom must be a positive real value.
+    The probability p must lie on the interval [0, 1].
+
 ====================================
 Statistical Functions
 ====================================
diff --git a/velox/docs/functions/presto/most_used_coverage.rst b/velox/docs/functions/presto/most_used_coverage.rst
index 9a9e42a40a92..50e52edd5493 100644
--- a/velox/docs/functions/presto/most_used_coverage.rst
+++ b/velox/docs/functions/presto/most_used_coverage.rst
@@ -54,6 +54,7 @@ Here is a list of most used scalar and aggregate Presto functions with functions
     table.coverage tr:nth-child(7) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(7) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(7) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(7) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(7) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(8) td:nth-child(2) {background-color: #6BA81E;}
@@ -71,10 +72,13 @@ Here is a list of most used scalar and aggregate Presto functions with functions
     table.coverage tr:nth-child(10) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(10) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(11) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(11) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(7) {background-color: #6BA81E;}
     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;}
@@ -100,6 +104,7 @@ Here is a list of most used scalar and aggregate Presto functions with functions
     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(16) td:nth-child(7) {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;}
@@ -126,16 +131,16 @@ Here is a list of most used scalar and aggregate Presto functions with functions
     :func:`upper`                :func:`transform_values`     :func:`map_filter`           :func:`map_zip_with`         :func:`xxhash64`                 :func:`array_agg`
     :func:`split`                :func:`map_entries`          :func:`regexp_extract`       :func:`year`                 :func:`to_hex`                   :func:`arbitrary`
     :func:`random`               :func:`concat`               :func:`map_values`           :func:`slice`                :func:`transform_keys`           :func:`min`
-    :func:`floor`                :func:`cardinality`          :func:`map_keys`             :func:`month`                bing_tile_quadkey                :func:`max_by`
+    :func:`floor`                :func:`cardinality`          :func:`map_keys`             :func:`month`                :func:`bing_tile_quadkey`        :func:`max_by`
     :func:`contains`             :func:`sequence`             :func:`reduce`               :func:`any_match`            :func:`to_utf8`                  :func:`approx_distinct`
     :func:`map_concat`           :func:`substr`               :func:`greatest`             :func:`bitwise_and`          :func:`crc32`                    :func:`count_if`
-    :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:`length`               :func:`date`                 :func:`date_trunc`           :func:`date_parse`           :func:`st_y`                     :func:`approx_percentile`
+    :func:`from_unixtime`        :func:`is_nan`               :func:`date_diff`            :func:`bing_tile_at`         :func:`st_x`                     :func:`avg`
     :func:`transform`            :func:`rand`                 :func:`array_max`            :func:`array_union`          now                              :func:`map_agg`
     :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`
+    :func:`replace`              :func:`json_parse`           :func:`array_distinct`       :func:`st_geometryfromtext`                                   :func:`histogram`
     :func:`regexp_replace`       :func:`map_from_entries`     :func:`pow`                  :func:`split_part`                                            :func:`set_union`
     :func:`parse_datetime`       :func:`date_add`             :func:`power`                :func:`log10`                                                 :func:`merge`
     ===========================  ===========================  ===========================  ===========================  ===========================  ==  ===========================  ==  ===========================
diff --git a/velox/docs/functions/presto/qdigest.rst b/velox/docs/functions/presto/qdigest.rst
new file mode 100644
index 000000000000..9b7b00dabb05
--- /dev/null
+++ b/velox/docs/functions/presto/qdigest.rst
@@ -0,0 +1,65 @@
+=========================
+Quantile Digest Functions
+=========================
+
+Quantile digest and `T-digest <https://doi.org/10.1016/j.simpa.2020.100049>`_ are two
+older algorithms for estimating rank-based metrics. While T-digest generally has `better
+performance <https://arxiv.org/abs/1902.04023>`_ and better accuracy at the tails,
+quantile digest supports more numeric types (``bigint``, ``double``, ``real``) and
+provides a maximum rank error guarantee, which ensures relative uniformity of precision
+along the quantiles. Quantile digests are also formally proven to support lossless merges,
+while T-digest is not (though it does empirically demonstrate lossless merges).
+
+Velox uses the modern KLL sketch algorithm for the ``approx_percentile`` function, which
+provides stronger accuracy guarantees than both quantile digest and T-digest.
+The quantile digest functions documented here exist primarily to support
+pre-existing workloads that have data stored using the `quantile
+digest <http://dx.doi.org/10.1145/347090.347195>`_ format for backward compatibility.
+
+Data Structures
+---------------
+
+A quantile digest is a data sketch which stores approximate percentile
+information. The Velox type for this data structure is called ``qdigest``,
+and it takes a parameter which must be one of ``bigint``, ``double`` or
+``real`` which represent the set of numbers that may be ingested by the
+``qdigest``. They may be merged without losing precision, and for storage
+and retrieval they may be cast to/from ``VARBINARY``.
+
+In the function signatures below, ``T`` represents the parameterized type of the qdigest,
+which can be ``bigint``, ``double``, or ``real``.
+
+Functions
+---------
+
+.. function:: merge(qdigest<T>) -> qdigest<T>
+
+    Merges all input ``qdigest``\ s into a single ``qdigest``.
+
+.. function:: qdigest_agg(x: T) -> qdigest<T>
+
+    Returns the ``qdigest`` which summarizes the approximate distribution of all input values of ``x``.
+
+.. function:: qdigest_agg(x: T, w: bigint) -> qdigest<T>
+   :noindex:
+
+    Returns the ``qdigest`` which summarizes the approximate distribution of all input values of ``x`` using
+    the per-item weight ``w``.
+
+.. function:: qdigest_agg(x: T, w: bigint, accuracy: double) -> qdigest<T>
+   :noindex:
+
+    Returns the ``qdigest`` which summarizes the approximate distribution of all input values of ``x`` using
+    the per-item weight ``w`` and maximum error of ``accuracy``. ``accuracy``
+    must be a value greater than zero and less than one, and it must be constant
+    for all input rows.
+
+.. function:: value_at_quantile(digest: qdigest<T>, quantile: double) -> T
+
+    Returns the approximate percentile values from the quantile digest ``digest`` given the ``quantile``.
+    The ``quantile`` must be between zero and one (inclusive).
+
+.. function:: values_at_quantiles(digest: qdigest<T>, quantiles: array<double>) -> array<T>
+
+    Returns the approximate percentile values as an array from the quantile digest ``digest`` at each of the specified quantiles given in the ``quantiles`` array.
+    All quantile values must be between zero and one (inclusive).
diff --git a/velox/docs/functions/presto/regexp.rst b/velox/docs/functions/presto/regexp.rst
index e9b8914c8d60..dee06e7d0157 100644
--- a/velox/docs/functions/presto/regexp.rst
+++ b/velox/docs/functions/presto/regexp.rst
@@ -114,3 +114,8 @@ limited to 20 different expressions per instance and thread of execution.
     array. Trailing empty strings are preserved::
 
         SELECT regexp_split('1a 2b 14m', '\s*[a-z]+\s*'); -- [1, 2, 14, ]
+
+    Note: When the regular expression ``pattern`` matches an empty string, the result array contains an
+    empty string, a single-character string for each character in the input string, and another empty string::
+
+        SELECT regexp_split('1a 2b 14m', ''); -- [, 1, 'a', ' ', 2, 'b', ' ', 1, 4, 'm', ]
diff --git a/velox/docs/functions/presto/string.rst b/velox/docs/functions/presto/string.rst
index 7806bd646ee0..d9ffbe0c8b2d 100644
--- a/velox/docs/functions/presto/string.rst
+++ b/velox/docs/functions/presto/string.rst
@@ -60,6 +60,10 @@ String Functions
     i.e. the number of positions at which the corresponding characters are different.
     Note that the two strings must have the same length.
 
+.. function:: jarowinkler_similarity(string1, string2) -> double
+
+    Returns the Jaro-Winkler similarity of ``string1`` and ``string2``.
+
 .. function:: length(string) -> bigint
 
     Returns the length of ``string`` in characters.
diff --git a/velox/docs/functions/presto/tdigest.rst b/velox/docs/functions/presto/tdigest.rst
new file mode 100644
index 000000000000..b43be2f3de6c
--- /dev/null
+++ b/velox/docs/functions/presto/tdigest.rst
@@ -0,0 +1,116 @@
+==================
+T-Digest Functions
+==================
+
+T-digest and `quantile digest <http://dx.doi.org/10.1145/347090.347195>`_ are two
+older algorithms for estimating rank-based metrics. T-digest generally has `better
+performance <https://arxiv.org/abs/1902.04023>`_ than quantile digest and better accuracy
+at the tails (often dramatically better), but may have worse accuracy at the median
+depending on the compression factor used. In comparison, quantile digest supports more
+numeric types and provides a maximum rank error guarantee, which ensures relative uniformity
+of precision along the quantiles. Quantile digests are also formally proven to support
+lossless merges, while T-digest is not (though it does empirically demonstrate lossless merges).
+
+T-digest was developed by Ted Dunning and is more restrictive in its type support,
+accepting only ``double`` type parameters. This contrasts with quantile digest, which
+supports a broader range of numeric types including ``bigint``, ``double``, and ``real``,
+making quantile digest more versatile for different data types.
+
+Velox uses the modern KLL sketch algorithm for the ``approx_percentile`` function, which
+provides stronger accuracy guarantees than both T-digest and quantile digest.
+The T-digest functions documented here exist primarily to support
+pre-existing workloads that have data stored using the `T-digest
+<https://doi.org/10.1016/j.simpa.2020.100049>`_ format for backward compatibility.
+
+Data Structures
+---------------
+
+A T-digest is a data sketch which stores approximate percentile information.
+The Velox type for this data structure is called ``tdigest``,
+and it accepts a parameter of type ``double`` which represents the set of
+numbers to be ingested by the ``tdigest``.
+
+T-digests may be merged without losing precision, and for storage and retrieval
+they may be cast to/from ``VARBINARY``.
+
+Functions
+---------
+
+.. function:: construct_tdigest(means: array<double>, counts: array<integer>, compression: double, min: double, max: double, sum: double, count: bigint) -> tdigest<double>
+
+    Constructs a T-digest from the given parameters:
+
+    * ``means`` - array of centroid means
+    * ``counts`` - array of centroid counts (weights)
+    * ``compression`` - compression factor
+    * ``min`` - minimum value
+    * ``max`` - maximum value
+    * ``sum`` - sum of all values
+    * ``count`` - total count of values
+
+.. function:: destructure_tdigest(digest: tdigest<double>) -> row(means array<double>, counts array<integer>, compression double, min double, max double, sum double, count bigint)
+
+    Destructures a T-digest into its component parts, returning a row containing:
+
+    * ``means`` - array of centroid means
+    * ``counts`` - array of centroid counts
+    * ``compression`` - compression factor
+    * ``min`` - minimum value
+    * ``max`` - maximum value
+    * ``sum`` - sum of all values
+    * ``count`` - total count of values
+
+.. function:: merge(tdigest<double>) -> tdigest<double>
+
+    Merges all input ``tdigest``\ s into a single ``tdigest``.
+
+.. function:: merge_tdigest(digests: array<tdigest<double>>) -> tdigest<double>
+
+    Merges an array of T-digests into a single T-digest.
+
+.. function:: quantile_at_value(digest: tdigest<double>, value: double) -> double
+
+    Returns the approximate quantile (percentile) of the given ``value`` based on the T-digest ``digest``.
+    The result will be between zero and one (inclusive).
+
+.. function:: quantiles_at_values(digest: tdigest<double>, values: array<double>) -> array<double>
+
+    Returns the approximate quantiles (percentiles) as an array for each of the given ``values`` based on the T-digest ``digest``.
+    All results will be between zero and one (inclusive).
+
+.. function:: scale_tdigest(digest: tdigest<double>, scale: double) -> tdigest<double>
+
+    Scales the T-digest ``digest`` by the given ``scale`` factor.
+    This multiplies all the centroid values in the T-digest by the scale factor.
+
+.. function:: tdigest_agg(x: double) -> tdigest<double>
+
+    Returns the ``tdigest`` which summarizes the approximate distribution of all input values of ``x``.
+    The default compression factor is ``100``.
+
+.. function:: tdigest_agg(x: double, w: double) -> tdigest<double>
+   :noindex:
+
+    Returns the ``tdigest`` which summarizes the approximate distribution of all input values of ``x`` using per-item weight ``w``.
+    The default compression factor is ``100``.
+
+.. function:: tdigest_agg(x: double, w: double, compression: double) -> tdigest<double>
+   :noindex:
+
+    Returns the ``tdigest`` which summarizes the approximate distribution of all input values of ``x`` using per-item weight ``w`` and the specified compression factor.
+    ``compression`` must be a positive constant for all input rows. The default is ``100``, maximum is ``1000``, and values lower than ``10`` are rounded to ``10``. Higher compression means more accuracy at the cost of more memory.
+
+.. function:: trimmed_mean(digest: tdigest<double>, low_quantile: double, high_quantile: double) -> double
+
+    Returns the mean of values between ``low_quantile`` and ``high_quantile`` (inclusive) from the T-digest ``digest``.
+    Both quantile values must be between zero and one (inclusive), and ``low_quantile`` must be less than or equal to ``high_quantile``.
+
+.. function:: value_at_quantile(digest: tdigest<double>, quantile: double) -> double
+
+    Returns the approximate percentile value from the T-digest ``digest`` at the given ``quantile``.
+    The ``quantile`` must be between zero and one (inclusive).
+
+.. function:: values_at_quantiles(digest: tdigest<double>, quantiles: array<double>) -> array<double>
+
+    Returns the approximate percentile values as an array from the T-digest ``digest`` at each of the specified quantiles given in the ``quantiles`` array.
+    All quantile values must be between zero and one (inclusive).
diff --git a/velox/docs/functions/spark/aggregate.rst b/velox/docs/functions/spark/aggregate.rst
index a9ac2bd001c5..9c5e90c6dd43 100644
--- a/velox/docs/functions/spark/aggregate.rst
+++ b/velox/docs/functions/spark/aggregate.rst
@@ -10,11 +10,12 @@ General Aggregate Functions
 .. spark:function:: avg(x) -> double|decimal
 
     Returns the average (arithmetic mean) of all non-null input values.
-    When x is of type DECIMAL, the result type is DECIMAL,
-    and the intermediate results are varbinarys or (sum, count) pairs represented as row(decimal, bigint).
+    When ``x`` is of type DECIMAL(p, s), the result type is DECIMAL(p + 4, s + 4),
+    and the intermediate results are (sum, count) pairs represented as ROW(DECIMAL(p + 10, s), BIGINT).
+    The current implementation for DECIMAL matches Spark avg's default behavior with spark.sql.decimalOperations.allowPrecisionLoss=true.
     For all other input types, the result type is DOUBLE,
-    and the intermediate results are (sum, count) pairs represented as row(double, bigint).
-    When all inputs are nulls, the intermediate result is row(0, 0),
+    and the intermediate results are (sum, count) pairs represented as ROW(DOUBLE, BIGINT).
+    When all inputs are nulls, the intermediate result is ROW(0, 0),
     and the final result is null.
 
 .. spark:function:: bit_xor(x) -> bigint
diff --git a/velox/docs/functions/spark/array.rst b/velox/docs/functions/spark/array.rst
index 88689787c3b4..42039e6c636d 100644
--- a/velox/docs/functions/spark/array.rst
+++ b/velox/docs/functions/spark/array.rst
@@ -1,6 +1,6 @@
-=============================
+===============
 Array Functions
-=============================
+===============
 
 .. spark:function:: aggregate(array(E), start, merge, finish) -> array(E)
 
@@ -171,13 +171,35 @@ Array Functions
 .. 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. ::
+    be orderable. NULL and NaN elements will be placed at the end of the returned array, with NaN elements appearing before NULL elements for floating-point types. ::
 
         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(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(4.0, NULL, float('nan'), 3.0)); -- [3.0, 4.0, NaN, NULL]
+        SELECT array_sort(array(array(), array(1, 3, NULL), array(NULL, 6), NULL, array(2, 1))); -- [[], [NULL, 6], [1, 3, NULL], [2, 1], NULL]
+
+.. spark:function:: array_sort(array(E), function(E,U)) -> array(E)
+    :noindex:
+
+    Returns the array sorted by values computed using specified lambda in ascending order. ``U`` must be an orderable type.
+    NULL and NaN elements returned by the lambda function will be placed at the end of the returned array, with NaN elements appearing before NULL elements.
+    This function is not supported in Spark and is only used inside Velox for rewriting :spark:func:`array_sort(array(E), function(E,E,U)) -> array(E)` as :spark:func:`array_sort(array(E), function(E,U)) -> array(E)`. ::
+
+.. spark:function:: array_sort(array(E), function(E,E,U)) -> array(E)
+    :noindex:
+
+    Returns the array sorted by values computed using specified lambda in ascending
+    order. ``U`` must be an orderable type.
+    The function attempts to analyze the lambda function and rewrite it into a simpler call that
+    specifies the sort-by expression (like :spark:func:`array_sort(array(E), function(E,U)) -> array(E)`). For example, ``(left, right) -> if(length(left) > length(right), 1, if(length(left) < length(right), -1, 0))`` will be rewritten to ``x -> length(x)``. If rewrite is not possible, a user error will be thrown.
+    If the rewritten function returns NULL, the corresponding element will be placed at the end the returned array. Please note that due to this rewrite optimization, the NULL handling logics between Spark and Velox differ. In Spark, the position of NULL element is determined by the comparison of NULL with other elements. ::
+
+        SELECT array_sort(array('cat', 'leopard', 'mouse'), (left, right) -> if(length(left) > length(right), 1, if(length(left) < length(right), -1, 0))); -- ['cat', 'mouse', 'leopard']
+        select array_sort(array("abcd123", "abcd", NULL, "abc"), (left, right) -> if(length(left) > length(right), 1, if(length(left) < length(right), -1, 0))); -- ["abc", "abcd", "abcd123", NULL]
+        select array_sort(array("abcd123", "abcd", NULL, "abc"), (left, right) -> if(length(left) > length(right), 1, if(length(left) = length(right), 0, -1))); -- ["abc", "abcd", "abcd123", NULL] different with Spark: ["abc", NULL, "abcd", "abcd123"]
 
 .. spark:function:: array_union(array(E) x, array(E) y) -> array(E)
 
diff --git a/velox/docs/functions/spark/binary.rst b/velox/docs/functions/spark/binary.rst
index ab594134d870..4b49e6e36f8f 100644
--- a/velox/docs/functions/spark/binary.rst
+++ b/velox/docs/functions/spark/binary.rst
@@ -16,16 +16,6 @@ Binary Functions
     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. For
-    multiple arguments, their types can be different.
-
 .. spark:function:: md5(x) -> varbinary
 
     Computes the md5 of x.
@@ -50,3 +40,13 @@ Binary Functions
     have a value of 224, 256, 384, 512, or 0 (which is equivalent to 256). If asking
     for an unsupported bitLength, the return value is NULL.
     Note: x can only be varbinary type.
+
+.. 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. For
+    multiple arguments, their types can be different.
diff --git a/velox/docs/functions/spark/comparison.rst b/velox/docs/functions/spark/comparison.rst
index 7dc953930299..11a89738dd85 100644
--- a/velox/docs/functions/spark/comparison.rst
+++ b/velox/docs/functions/spark/comparison.rst
@@ -1,6 +1,6 @@
-=====================================
+====================
 Comparison Functions
-=====================================
+====================
 
 .. spark:function:: between(x, min, max) -> boolean
 
@@ -86,33 +86,3 @@ 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
index 3661dd023c07..6ea90482f8cd 100644
--- a/velox/docs/functions/spark/conversion.rst
+++ b/velox/docs/functions/spark/conversion.rst
@@ -2,6 +2,38 @@
 Conversion Functions
 ====================
 
+.. spark:function:: cast(value AS type) -> type
+
+    Explicitly cast a ``value`` to a specified ``type``.
+    Follows the behavior when Spark ANSI mode is disabled, and does not support
+    the behavior when ANSI is turned on:
+
+    * If the ``value`` exceeds the range of the ``type``, no error is raised.
+      Instead, the ``value`` is "wrapped" around.
+
+    * If the ``value`` has an invalid format or contains characters incompatible
+      with the target ``type``, the cast function returns NULL. ::
+
+        SELECT cast(128 as tinyint); -- -128
+        SELECT cast('2012-Oct-23' as date); -- NULL
+
+.. spark:function:: try_cast(value AS type) -> type
+
+    Returns the ``value`` cast to ``type`` if possible, or NULL if not possible.
+    Its behavior is independent of the ANSI mode setting, and it acts identically
+    to cast with ANSI mode enabled but returns NULL rather than throwing errors
+    for failure to cast.
+    ``try_cast`` differs from ``cast`` function with ANSI mode disabled in following case:
+
+    * If the ``value`` cannot fit within the domain of ``type``, the result is NULL. ::
+
+        SELECT try_cast(128 as tinyint); -- NULL
+        SELECT try_cast(cast(550000.0 as DECIMAL(8, 1)) as smallint); -- NULL
+        SELECT try_cast(1e12 as int); -- NULL
+
+Cast from UNKNOWN Type
+----------------------
+
 Casting from UNKNOWN type to all other scalar types is supported, e.g., cast(NULL as int).
 
 Cast to Integral Types
@@ -74,13 +106,13 @@ 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
+  SELECT cast('1234567' as tinyint); -- NULL // Reason: Out of range
+  SELECT cast('1a' as tinyint); -- NULL // Invalid argument
+  SELECT cast('' as tinyint); -- NULL // Invalid argument
+  SELECT cast('1,234,567' as bigint); -- NULL // Invalid argument
+  SELECT cast('1'234'567' as bigint); -- NULL // Invalid argument
+  SELECT cast('nan' as bigint); -- NULL // Invalid argument
+  SELECT cast('infinity' as bigint); -- NULL // Invalid argument
 
 From decimal
 ^^^^^^^^^^^^
@@ -100,7 +132,7 @@ Valid examples
   SELECT cast(cast(2147483648.90 as DECIMAL(12, 2)) as bigint); -- 2147483648
 
 From timestamp
-^^^^^^^^^^^^^
+^^^^^^^^^^^^^^
 
 Casting timestamp as integral types returns the number of seconds by converting timestamp as microseconds, dividing by the number of microseconds in a second, and then rounding down to the nearest second since the epoch (1970-01-01 00:00:00 UTC).
 
@@ -145,13 +177,13 @@ 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
+  SELECT cast('1.7E308' as boolean); -- NULL // Invalid argument
+  SELECT cast('nan' as boolean); -- NULL // Invalid argument
+  SELECT cast('infinity' as boolean); -- NULL // Invalid argument
+  SELECT cast('12' as boolean); -- NULL // Invalid argument
+  SELECT cast('-1' as boolean); -- NULL // Invalid argument
+  SELECT cast('tr' as boolean); -- NULL // Invalid argument
+  SELECT cast('tru' as boolean); -- NULL // Invalid argument
 
 Cast to String
 --------------
@@ -215,9 +247,9 @@ 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
+  SELECT cast('2012-Oct-23' as date); -- NULL // Invalid argument
+  SELECT cast('2012/10/23' as date); -- NULL // Invalid argument
+  SELECT cast('2012.10.23' as date); -- NULL // Invalid argument
 
 Cast to Decimal
 ---------------
diff --git a/velox/docs/functions/spark/coverage.rst b/velox/docs/functions/spark/coverage.rst
index f721415c82ab..f8fe4e00fd20 100644
--- a/velox/docs/functions/spark/coverage.rst
+++ b/velox/docs/functions/spark/coverage.rst
@@ -1,3 +1,9 @@
+=================
+Function Coverage
+=================
+
+Here is a list of all scalar, aggregate, and window functions from Spark, with functions that are available in Velox highlighted.
+
 .. raw:: html
 
     <style>
@@ -6,71 +12,192 @@
     table.coverage td:nth-child(6) {background-color: lightblue;}
     table.coverage td:nth-child(8) {background-color: lightblue;}
     table.coverage tr:nth-child(1) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(1) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(2) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(2) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(3) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(4) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(5) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(5) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(5) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(5) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(6) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(7) td:nth-child(5) {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(3) {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(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(10) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(10) td:nth-child(9) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(11) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(11) td:nth-child(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(11) td:nth-child(9) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(12) td:nth-child(1) {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(5) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(13) td:nth-child(7) {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(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(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(17) td:nth-child(1) {background-color: #6BA81E;}
     table.coverage tr:nth-child(17) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(17) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(18) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(18) td:nth-child(2) {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(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(18) td:nth-child(7) {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(4) {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(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(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(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(22) td:nth-child(4) {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(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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(24) td:nth-child(4) {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(3) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(26) td:nth-child(5) {background-color: #6BA81E;}
     table.coverage tr:nth-child(26) td:nth-child(7) {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(5) {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(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(7) {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(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(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(31) td:nth-child(7) {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(3) {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(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(36) td:nth-child(1) {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(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(37) td:nth-child(5) {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(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(39) td:nth-child(1) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(39) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(39) td:nth-child(4) {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(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(40) td:nth-child(1) {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(41) td:nth-child(1) {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(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(41) 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(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(42) td:nth-child(4) {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(7) {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(44) td:nth-child(2) {background-color: #6BA81E;}
     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(44) td:nth-child(7) {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(4) {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(47) td:nth-child(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(47) td:nth-child(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(48) td:nth-child(3) {background-color: #6BA81E;}
     table.coverage tr:nth-child(49) td:nth-child(2) {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(7) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(50) td:nth-child(2) {background-color: #6BA81E;}
     table.coverage tr:nth-child(50) td:nth-child(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(50) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(50) td:nth-child(7) {background-color: #6BA81E;}
     table.coverage tr:nth-child(51) td:nth-child(4) {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(4) {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(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(53) td:nth-child(5) {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(4) {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(3) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(56) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(57) td:nth-child(2) {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(3) {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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(60) td:nth-child(4) {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(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(63) td:nth-child(2) {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(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(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(65) td:nth-child(5) {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(4) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(66) td:nth-child(5) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(67) td:nth-child(1) {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(2) {background-color: #6BA81E;}
+    table.coverage tr:nth-child(68) td:nth-child(4) {background-color: #6BA81E;}
     table.coverage tr:nth-child(69) td:nth-child(4) {background-color: #6BA81E;}
     </style>
 
@@ -81,73 +208,73 @@
     =========================================  =========================================  =========================================  =========================================  =========================================  ==  =========================================  ==  =========================================
     Scalar Functions                                                                                                                                                                                                           Aggregate Functions                            Window Functions
     =====================================================================================================================================================================================================================  ==  =========================================  ==  =========================================
-    :spark:func:`abs`                          count_if                                   inline                                     nvl                                        sqrt                                           any                                            cume_dist
-    :spark:func:`acos                          count_min_sketch                           inline_outer                               nvl2                                       stack                                          approx_count_distinct                          dense_rank
+    :spark:func:`abs`                          count_if                                   inline                                     nvl                                        :spark:func:`sqrt`                             any                                            cume_dist
+    :spark:func:`acos`                         count_min_sketch                           inline_outer                               nvl2                                       stack                                          approx_count_distinct                          :spark:func:`dense_rank`
     :spark:func:`acosh`                        covar_pop                                  input_file_block_length                    octet_length                               std                                            approx_percentile                              first_value
-    add_months                                 covar_samp                                 input_file_block_start                     or                                         stddev                                         array_agg                                      lag
-    :spark:func:`aggregate`                    crc32                                      input_file_name                            overlay                                    stddev_pop                                     avg                                            last_value
+    :spark:func:`add_months`                   covar_samp                                 input_file_block_start                     or                                         stddev                                         array_agg                                      lag
+    :spark:func:`aggregate`                    :spark:func:`crc32`                        input_file_name                            :spark:func:`overlay`                      stddev_pop                                     :spark:func:`avg`                              last_value
     and                                        cume_dist                                  :spark:func:`instr`                        parse_url                                  stddev_samp                                    bit_and                                        lead
-    any                                        current_catalog                            int                                        percent_rank                               str_to_map                                     bit_or                                         :spark:func:`nth_value`
-    approx_count_distinct                      current_database                           isnan                                      percentile                                 string                                         :spark:func:`bit_xor`                          ntile
+    any                                        current_catalog                            int                                        percent_rank                               :spark:func:`str_to_map`                       bit_or                                         :spark:func:`nth_value`
+    approx_count_distinct                      current_database                           :spark:func:`isnan`                        percentile                                 string                                         :spark:func:`bit_xor`                          :spark:func:`ntile`
     approx_percentile                          current_date                               :spark:func:`isnotnull`                    percentile_approx                          struct                                         bool_and                                       percent_rank
-    :spark:func:`array`                        current_timestamp                          :spark:func:`isnull`                       pi                                         substr                                         bool_or                                        rank
-    :spark:func:`array_contains`               current_timezone                           java_method                                :spark:func:`pmod`                         :spark:func:`substring`                        collect_list                                   row_number
-    array_distinct                             current_user                               json_array_length                          posexplode                                 substring_index                                collect_set
-    array_except                               date                                       json_object_keys                           posexplode_outer                           sum                                            corr
-    :spark:func:`array_intersect`              date_add                                   json_tuple                                 position                                   tan                                            count
-    array_join                                 date_format                                kurtosis                                   positive                                   tanh                                           count_if
-    array_max                                  date_from_unix_date                        lag                                        pow                                        timestamp                                      count_min_sketch
-    array_min                                  date_part                                  last                                       :spark:func:`power`                        timestamp_micros                               covar_pop
-    array_position                             date_sub                                   last_day                                   printf                                     timestamp_millis                               covar_samp
-    array_remove                               date_trunc                                 last_value                                 quarter                                    timestamp_seconds                              every
-    array_repeat                               datediff                                   lcase                                      radians                                    tinyint                                        :spark:func:`first`
-    :spark:func:`array_sort`                   day                                        lead                                       raise_error                                to_csv                                         first_value
-    array_union                                dayofmonth                                 :spark:func:`least`                        :spark:func:`rand`                         to_date                                        grouping
-    arrays_overlap                             dayofweek                                  :spark:func:`left`                         randn                                      to_json                                        grouping_id
-    arrays_zip                                 dayofyear                                  :spark:func:`length`                       random                                     to_timestamp                                   histogram_numeric
-    :spark:func:`ascii`                        decimal                                    levenshtein                                range                                      :spark:func:`to_unix_timestamp`                kurtosis
-    asin                                       decode                                     like                                       rank                                       to_utc_timestamp                               :spark:func:`last`
-    :spark:func:`asinh`                        degrees                                    ln                                         reflect                                    :spark:func:`transform`                        last_value
-    assert_true                                dense_rank                                 locate                                     regexp                                     transform_keys                                 max
-    atan                                       div                                        log                                        :spark:func:`regexp_extract`               transform_values                               max_by
-    atan2                                      double                                     log10                                      regexp_extract_all                         translate                                      mean
-    :spark:func:`atanh`                        e                                          :spark:func:`log1p`                        regexp_like                                :spark:func:`trim`                             min
-    avg                                        :spark:func:`element_at`                   log2                                       regexp_replace                             trunc                                          min_by
-    base64                                     elt                                        :spark:func:`lower`                        repeat                                     try_add                                        percentile
-    :spark:func:`between`                      encode                                     lpad                                       :spark:func:`replace`                      try_divide                                     percentile_approx
-    bigint                                     every                                      :spark:func:`ltrim`                        reverse                                    typeof                                         regr_avgx
-    :spark:func:`bin`                          exists                                     make_date                                  right                                      ucase                                          regr_avgy
-    binary                                     :spark:func:`exp`                          make_dt_interval                           rint                                       unbase64                                       regr_count
-    bit_and                                    explode                                    make_interval                              :spark:func:`rlike`                        unhex                                          regr_r2
-    bit_count                                  explode_outer                              make_timestamp                             :spark:func:`round`                        unix_date                                      skewness
-    bit_get                                    expm1                                      make_ym_interval                           row_number                                 unix_micros                                    some
-    bit_length                                 extract                                    :spark:func:`map`                          rpad                                       unix_millis                                    std
-    bit_or                                     factorial                                  map_concat                                 :spark:func:`rtrim`                        unix_seconds                                   stddev
-    bit_xor                                    :spark:func:`filter`                       map_entries                                schema_of_csv                              :spark:func:`unix_timestamp`                   stddev_pop
-    bool_and                                   find_in_set                                :spark:func:`map_filter`                   schema_of_json                             :spark:func:`upper`                            stddev_samp
-    bool_or                                    first                                      :spark:func:`map_from_arrays`              second                                     uuid                                           sum
+    :spark:func:`array`                        current_timestamp                          :spark:func:`isnull`                       pi                                         substr                                         bool_or                                        :spark:func:`rank`
+    :spark:func:`array_contains`               current_timezone                           java_method                                :spark:func:`pmod`                         :spark:func:`substring`                        :spark:func:`collect_list`                     :spark:func:`row_number`
+    :spark:func:`array_distinct`               current_user                               :spark:func:`json_array_length`            posexplode                                 :spark:func:`substring_index`                  :spark:func:`collect_set`
+    :spark:func:`array_except`                 date                                       :spark:func:`json_object_keys`             posexplode_outer                           sum                                            :spark:func:`corr`
+    :spark:func:`array_intersect`              :spark:func:`date_add`                     json_tuple                                 position                                   tan                                            count
+    :spark:func:`array_join`                   :spark:func:`date_format`                  kurtosis                                   positive                                   tanh                                           count_if
+    :spark:func:`array_max`                    :spark:func:`date_from_unix_date`          lag                                        pow                                        timestamp                                      count_min_sketch
+    :spark:func:`array_min`                    date_part                                  last                                       :spark:func:`power`                        :spark:func:`timestamp_micros`                 covar_pop
+    :spark:func:`array_position`               :spark:func:`date_sub`                     :spark:func:`last_day`                     printf                                     :spark:func:`timestamp_millis`                 :spark:func:`covar_samp`
+    :spark:func:`array_remove`                 :spark:func:`date_trunc`                   last_value                                 :spark:func:`quarter`                      timestamp_seconds                              every
+    :spark:func:`array_repeat`                 :spark:func:`datediff`                     lcase                                      radians                                    tinyint                                        :spark:func:`first`
+    :spark:func:`array_sort`                   :spark:func:`day`                          lead                                       :spark:func:`raise_error`                  to_csv                                         first_value
+    :spark:func:`array_union`                  :spark:func:`dayofmonth`                   :spark:func:`least`                        :spark:func:`rand`                         to_date                                        grouping
+    arrays_overlap                             :spark:func:`dayofweek`                    :spark:func:`left`                         randn                                      to_json                                        grouping_id
+    :spark:func:`arrays_zip`                   :spark:func:`dayofyear`                    :spark:func:`length`                       :spark:func:`random`                       to_timestamp                                   histogram_numeric
+    :spark:func:`ascii`                        decimal                                    :spark:func:`levenshtein`                  range                                      :spark:func:`to_unix_timestamp`                :spark:func:`kurtosis`
+    :spark:func:`asin`                         decode                                     :spark:func:`like`                         rank                                       :spark:func:`to_utc_timestamp`                 :spark:func:`last`
+    :spark:func:`asinh`                        :spark:func:`degrees`                      ln                                         reflect                                    :spark:func:`transform`                        last_value
+    assert_true                                dense_rank                                 :spark:func:`locate`                       regexp                                     transform_keys                                 :spark:func:`max`
+    :spark:func:`atan`                         div                                        :spark:func:`log`                          :spark:func:`regexp_extract`               transform_values                               :spark:func:`max_by`
+    :spark:func:`atan2`                        double                                     :spark:func:`log10`                        :spark:func:`regexp_extract_all`           :spark:func:`translate`                        mean
+    :spark:func:`atanh`                        e                                          :spark:func:`log1p`                        regexp_like                                :spark:func:`trim`                             :spark:func:`min`
+    avg                                        :spark:func:`element_at`                   :spark:func:`log2`                         :spark:func:`regexp_replace`               :spark:func:`trunc`                            :spark:func:`min_by`
+    base64                                     elt                                        :spark:func:`lower`                        :spark:func:`repeat`                       try_add                                        percentile
+    :spark:func:`between`                      encode                                     :spark:func:`lpad`                         :spark:func:`replace`                      try_divide                                     percentile_approx
+    bigint                                     every                                      :spark:func:`ltrim`                        :spark:func:`reverse`                      typeof                                         regr_avgx
+    :spark:func:`bin`                          :spark:func:`exists`                       :spark:func:`make_date`                    right                                      ucase                                          regr_avgy
+    binary                                     :spark:func:`exp`                          make_dt_interval                           :spark:func:`rint`                         :spark:func:`unbase64`                         regr_count
+    bit_and                                    explode                                    make_interval                              :spark:func:`rlike`                        :spark:func:`unhex`                            regr_r2
+    :spark:func:`bit_count`                    explode_outer                              :spark:func:`make_timestamp`               :spark:func:`round`                        :spark:func:`unix_date`                        :spark:func:`skewness`
+    :spark:func:`bit_get`                      :spark:func:`expm1`                        :spark:func:`make_ym_interval`             row_number                                 :spark:func:`unix_micros`                      some
+    :spark:func:`bit_length`                   extract                                    :spark:func:`map`                          :spark:func:`rpad`                         :spark:func:`unix_millis`                      std
+    bit_or                                     :spark:func:`factorial`                    :spark:func:`map_concat`                   :spark:func:`rtrim`                        :spark:func:`unix_seconds`                     :spark:func:`stddev`
+    bit_xor                                    :spark:func:`filter`                       :spark:func:`map_entries`                  schema_of_csv                              :spark:func:`unix_timestamp`                   stddev_pop
+    bool_and                                   :spark:func:`find_in_set`                  :spark:func:`map_filter`                   schema_of_json                             :spark:func:`upper`                            :spark:func:`stddev_samp`
+    bool_or                                    first                                      :spark:func:`map_from_arrays`              :spark:func:`second`                       :spark:func:`uuid`                             :spark:func:`sum`
     boolean                                    first_value                                map_from_entries                           sentences                                  var_pop                                        try_avg
-    bround                                     flatten                                    map_keys                                   sequence                                   var_samp                                       try_sum
-    btrim                                      float                                      map_values                                 session_window                             variance                                       var_pop
-    cardinality                                :spark:func:`floor`                        map_zip_with                               sha                                        version                                        var_samp
-    case                                       forall                                     max                                        :spark:func:`sha1`                         weekday                                        variance
+    bround                                     :spark:func:`flatten`                      :spark:func:`map_keys`                     sequence                                   var_samp                                       try_sum
+    btrim                                      float                                      :spark:func:`map_values`                   session_window                             variance                                       var_pop
+    cardinality                                :spark:func:`floor`                        :spark:func:`map_zip_with`                 sha                                        version                                        :spark:func:`var_samp`
+    case                                       :spark:func:`forall`                       max                                        :spark:func:`sha1`                         :spark:func:`weekday`                          :spark:func:`variance`
     cast                                       format_number                              max_by                                     :spark:func:`sha2`                         weekofyear
-    cbrt                                       format_string                              :spark:func:`md5`                          :spark:func:`shiftleft`                    when
-    :spark:func:`ceil`                         from_csv                                   mean                                       :spark:func:`shiftright`                   width_bucket
+    :spark:func:`cbrt`                         format_string                              :spark:func:`md5`                          :spark:func:`shiftleft`                    when
+    :spark:func:`ceil`                         from_csv                                   mean                                       :spark:func:`shiftright`                   :spark:func:`width_bucket`
     ceiling                                    from_json                                  min                                        shiftrightunsigned                         window
-    char                                       from_unixtime                              min_by                                     shuffle                                    xpath
-    char_length                                from_utc_timestamp                         minute                                     sign                                       xpath_boolean
+    char                                       :spark:func:`from_unixtime`                min_by                                     :spark:func:`shuffle`                      xpath
+    char_length                                :spark:func:`from_utc_timestamp`           :spark:func:`minute`                       :spark:func:`sign`                         xpath_boolean
     character_length                           :spark:func:`get_json_object`              mod                                        signum                                     xpath_double
-    :spark:func:`chr`                          getbit                                     monotonically_increasing_id                sin                                        xpath_float
-    coalesce                                   :spark:func:`greatest`                     month                                      :spark:func:`sinh`                         xpath_int
+    :spark:func:`chr`                          getbit                                     :spark:func:`monotonically_increasing_id`  sin                                        xpath_float
+    coalesce                                   :spark:func:`greatest`                     :spark:func:`month`                        :spark:func:`sinh`                         xpath_int
     collect_list                               grouping                                   months_between                             :spark:func:`size`                         xpath_long
     collect_set                                grouping_id                                named_struct                               skewness                                   xpath_number
-    :spark:func:`concat`                       :spark:func:`hash`                         nanvl                                      slice                                      xpath_short
-    concat_ws                                  hex                                        negative                                   smallint                                   xpath_string
-    conv                                       hour                                       next_day                                   some                                       :spark:func:`xxhash64`
+    :spark:func:`concat`                       :spark:func:`hash`                         nanvl                                      :spark:func:`slice`                        xpath_short
+    concat_ws                                  :spark:func:`hex`                          negative                                   smallint                                   xpath_string
+    :spark:func:`conv`                         :spark:func:`hour`                         :spark:func:`next_day`                     some                                       :spark:func:`xxhash64`
     corr                                       :spark:func:`hypot`                        :spark:func:`not`                          :spark:func:`sort_array`                   :spark:func:`year`
-    cos                                        if                                         now                                        soundex                                    zip_with
-    cosh                                       ifnull                                     nth_value                                  space
-    cot                                        :spark:func:`in`                           ntile                                      spark_partition_id
+    :spark:func:`cos`                          if                                         now                                        :spark:func:`soundex`                      :spark:func:`zip_with`
+    :spark:func:`cosh`                         ifnull                                     nth_value                                  space
+    :spark:func:`cot`                          :spark:func:`in`                           ntile                                      :spark:func:`spark_partition_id`
     count                                      initcap                                    nullif                                     :spark:func:`split`
     =========================================  =========================================  =========================================  =========================================  =========================================  ==  =========================================  ==  =========================================
diff --git a/velox/docs/functions/spark/datetime.rst b/velox/docs/functions/spark/datetime.rst
index e94004cd56b1..97e6f2b25166 100644
--- a/velox/docs/functions/spark/datetime.rst
+++ b/velox/docs/functions/spark/datetime.rst
@@ -1,6 +1,6 @@
-=====================================
+=======================
 Date and Time Functions
-=====================================
+=======================
 
 Convenience Extraction Functions
 --------------------------------
@@ -183,35 +183,6 @@ 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.
@@ -244,12 +215,49 @@ These functions support TIMESTAMP and DATE input types.
         SELECT make_timestamp(2014, 12, 28, 6, 30, 60.000001); -- NULL
         SELECT make_timestamp(2014, 13, 28, 6, 30, 45.887); -- NULL
 
+.. 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:: month(date) -> integer
 
     Returns the month of ``date``. ::
 
         SELECT month('2009-07-30'); -- 7
 
+.. spark:function:: months_between(timestamp1, timestamp2, roundOff) -> double
+
+    Returns number of months between times ``timestamp1`` and ``timestamp2``.
+    If ``timestamp1`` is later than ``timestamp2``, the result is positive.
+    If ``timestamp1`` and ``timestamp2`` are on the same day of month, or both are the
+    last day of month, time of day will be ignored. Otherwise, the difference is calculated
+    based on 31 days per month, and rounded to 8 digits unless ``roundOff`` is false. ::
+
+        SELECT months_between('1997-02-28 10:30:00', '1996-10-30', true); -- 3.94959677
+        SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false); -- 3.9495967741935485
+        SELECT months_between('1997-02-28 10:30:00', '1996-03-31 11:00:00', true); -- 11.0
+        SELECT months_between('1997-02-28 10:30:00', '1996-03-28 11:00:00', true); -- 11.0
+        SELECT months_between('1997-02-21 10:30:00', '1996-03-21 11:00:00', true); -- 11.0
+
 .. spark:function:: next_day(startDate, dayOfWeek) -> date
 
     Returns the first date which is later than ``startDate`` and named as ``dayOfWeek``.
@@ -265,12 +273,47 @@ These functions support TIMESTAMP and DATE input types.
         SELECT next_day('2015-07-23', "tu"); -- '2015-07-28'
         SELECT next_day('2015-07-23', "we"); -- '2015-07-29'
 
+.. 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:: second(timestamp) -> integer
 
     Returns the seconds of ``timestamp``. ::
 
         SELECT second('2009-07-30 12:58:59'); -- 59
 
+.. spark:function:: timestampadd(unit, value, timestamp) -> timestamp
+
+    Adds an int or bigint interval ``value`` of type ``unit`` to ``timestamp``.
+    Subtraction can be performed by using a negative ``value``.
+    Throws exception if ``unit`` is invalid.
+    ``unit`` is case insensitive and must be one of the following:
+    ``YEAR``, ``QUARTER``, ``MONTH``, ``WEEK``, ``DAY``, ``DAYOFYEAR``, ``HOUR``, ``MINUTE``, ``SECOND``,
+    ``MILLISECOND``, ``MICROSECOND``. ::
+
+        SELECT timestampadd(YEAR, 1, '2030-02-28 10:00:00.500'); -- 2031-02-28 10:00:00.500
+        SELECT timestampadd(DAY, 1, '2020-02-29 10:00:00.500'); -- 2020-03-01 10:00:00.500
+        SELECT timestampadd(DAYOFYEAR, 1, '2020-02-29 10:00:00.500'); -- 2020-03-01 10:00:00.500
+        SELECT timestampadd(SECOND, 10, '2019-03-01 10:00:00.500'); -- 2019-03-01 10:00:10.500
+        SELECT timestampadd(MICROSECOND, 500, '2019-02-28 10:01:00.500999'); -- 2019-02-28 10:01:00.501499
+
+.. spark:function:: timestampdiff(unit, timestamp1, timestamp2) -> bigint
+
+    Returns ``timestamp2`` - ``timestamp1`` expressed in terms of ``unit``, the fraction
+    part is truncated.
+    Throws exception if ``unit`` is invalid.
+    ``unit`` is case insensitive and must be one of the following:
+    ``YEAR``, ``QUARTER``, ``MONTH``, ``WEEK``, ``DAY``, ``HOUR``, ``MINUTE``, ``SECOND``,
+    ``MILLISECOND``, ``MICROSECOND``. ::
+
+        SELECT timestampdiff(YEAR, '2020-02-29 10:00:00.500', '2030-02-28 10:00:00.500'); -- 9
+        SELECT timestampdiff(DAY, '2019-01-30 10:00:00.500', '2020-02-29 10:00:00.500'); -- 395
+        SELECT timestampdiff(SECOND, '2019-02-28 10:00:00.500', '2019-03-01 10:00:00.500'); -- 86400
+        SELECT timestampdiff(MICROSECOND, '2019-02-28 10:00:00.000000', '2019-02-28 10:01:00.500999'); -- 60500999
+
 .. spark:function:: timestamp_micros(x) -> timestamp
 
     Returns timestamp from the number of microseconds since UTC epoch.
@@ -285,6 +328,23 @@ These functions support TIMESTAMP and DATE input types.
 
         SELECT timestamp_millis(1230219000123); -- '2008-12-25 15:30:00.123'
 
+.. spark:function:: timestamp_seconds(x) -> timestamp
+
+    Returns timestamp from the number of seconds (can be fractional) since UTC epoch.
+    Supported types are: TINYINT, SMALLINT, INTEGER, BIGINT, FLOAT, and DOUBLE.
+    For integral types (TINYINT, SMALLINT, INTEGER, BIGINT), the function directly
+    converts the number of seconds to a timestamp. For floating-point types
+    (FLOAT, DOUBLE), the function scales the input to microseconds, truncates
+    towards zero, and saturates the result to the minimum and maximum values allowed
+    in Spark. Returns NULL when ``x`` is NaN or Infinity. ::
+
+        SELECT timestamp_seconds(1230219000); -- '2008-12-25 15:30:00'
+        SELECT timestamp_seconds(1230219000.123); -- '2008-12-25 15:30:00.123'
+        SELECT timestamp_seconds(double(1.1234567)); -- '1970-01-01 00:00:01.123456'
+        SELECT timestamp_seconds(double('inf')); -- NULL
+        SELECT timestamp_seconds(float(3.4028235E+38)); -- '+294247-01-10 04:00:54.775807'
+        SELECT timestamp_seconds(float('nan')); -- NULL
+
 .. spark:function:: to_unix_timestamp(date) -> bigint
    :noindex:
 
@@ -310,6 +370,26 @@ These functions support TIMESTAMP and DATE input types.
 
         SELECT to_utc_timestamp('2015-07-24 00:00:00', 'America/Los_Angeles'); -- '2015-07-24 07:00:00'
 
+.. spark:function:: trunc(date, fmt) -> date
+
+    Returns ``date`` truncated to the unit specified by the format model ``fmt``.
+    Returns NULL if ``fmt`` is invalid.
+
+    ``fmt`` is case insensitive and must be one of the following:
+        * "YEAR", "YYYY", "YY" - truncate to the first date of the year that the ``date`` falls in
+        * "QUARTER" - truncate to the first date of the quarter that the ``date`` falls in
+        * "MONTH", "MM", "MON" - truncate to the first date of the month that the ``date`` falls in
+        * "WEEK" - truncate to the Monday of the week that the ``date`` falls in
+
+    ::
+
+        SELECT trunc('2019-08-04', 'week'); -- 2019-07-29
+        SELECT trunc('2019-08-04', 'quarter'); -- 2019-07-01
+        SELECT trunc('2009-02-12', 'MM'); -- 2009-02-01
+        SELECT trunc('2015-10-27', 'YEAR'); -- 2015-01-01
+        SELECT trunc('2015-10-27', ''); -- NULL
+        SELECT trunc('2015-10-27', 'day'); -- NULL
+
 .. spark:function:: unix_date(date) -> integer
 
     Returns the number of days since 1970-01-01. ::
diff --git a/velox/docs/functions/spark/decimal.rst b/velox/docs/functions/spark/decimal.rst
index 3d1c1c18fc23..9573e3aecb7e 100644
--- a/velox/docs/functions/spark/decimal.rst
+++ b/velox/docs/functions/spark/decimal.rst
@@ -38,7 +38,7 @@ The HiveQL behavior:
 https://cwiki.apache.org/confluence/download/attachments/27362075/Hive_Decimal_Precision_Scale_Support.pdf
 
 Additionally, the computation of decimal division adapts to the allow-precision-loss flag,
-while the decimal addition, subtraction, and multiplication do not.
+while the decimal addition, subtraction, multiplication and integer division do not.
 
 Addition and Subtraction
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -74,6 +74,15 @@ When allow-precision-loss is false:
     p = wholeDigits + fractionalDigits
     s = fractionalDigits
 
+Integer Division
+~~~~~~~~~~~~~~~~
+
+::
+
+    precision = p1 - s1 + s2
+    p = precision == 0 ? 1 : min(38,  precision)
+    s = 0
+
 Decimal Precision and Scale Adjustment
 --------------------------------------
 
@@ -112,6 +121,28 @@ Decimal division uses a different formula:
 
 Returns NULL when the actual result cannot be represented with the calculated decimal type.
 
+Arithmetic Functions
+--------------------
+
+.. spark:function:: div(x: decimal(p1, s1), y: decimal(p2, s2)) -> bigint
+
+    Performs integer division and returns the bigint result of dividing ``x`` by ``y``, truncating toward zero.
+    Truncation occurs if the result is within the result precision but exceeds the BIGINT range.
+    Division by zero or overflow results in NULL. Does not respect the ``allow-precision-loss`` configuration.
+    Corresponds to Spark's operator ``div`` with ``spark.sql.ansi.enabled`` set to false.  ::
+
+        SELECT CAST(1 as DECIMAL(17, 3)) div CAST(2 as DECIMAL(17, 3)); -- 0
+        SELECT CAST(21 as DECIMAL(20, 3)) div CAST(20 as DECIMAL(20, 2)); -- 1
+        SELECT CAST(1 as DECIMAL(20, 3)) div CAST(0 as DECIMAL(20, 3)); -- NULL
+        SELECT CAST(99999999999999999999999999999999999 as DECIMAL(38, 1)) div CAST(0.001 as DECIMAL(7, 4)); -- 687399551400672280 // Result is truncated to int64_t.
+
+.. spark:function:: checked_div(x: decimal(p1, s1), y: decimal(p2, s2)) -> bigint
+
+    Performs integer division and returns the bigint result of dividing ``x`` by ``y``, truncating toward zero.
+    Truncation occurs if the result is within the result precision but exceeds the BIGINT range.
+    Division by zero or overflow results in an error.
+    Corresponds to Spark's operator ``div`` with ``spark.sql.ansi.enabled`` set to true.
+
 Decimal Functions
 -----------------
 .. spark:function:: ceil(x: decimal(p, s)) -> r: decimal(pr, 0)
@@ -122,6 +153,36 @@ Decimal Functions
 
         SELECT ceil(cast(1.23 as DECIMAL(3, 2))); -- 2 // Output type: decimal(2,0)
 
+.. 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_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 ``>=``.
+
+.. 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_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:: floor(x: decimal(p, s)) -> r: decimal(pr, 0)
 
     Returns ``x`` rounded down to the type ``decimal(min(38, p - s + min(1, s)), 0)``.
@@ -150,12 +211,6 @@ Decimal Functions
 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.
@@ -195,3 +250,9 @@ Decimal Special Forms
         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
+
+.. 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.
diff --git a/velox/docs/functions/spark/json.rst b/velox/docs/functions/spark/json.rst
index 5ffe3af0fca5..c7f37a7ffa51 100644
--- a/velox/docs/functions/spark/json.rst
+++ b/velox/docs/functions/spark/json.rst
@@ -24,9 +24,9 @@ JSON Functions
     Casts ``jsonString`` to an ARRAY, MAP, or ROW type, with the output type
     determined by the expression. Returns NULL, if the input string is unparsable.
     Supported element types include BOOLEAN, TINYINT, SMALLINT, INTEGER, BIGINT,
-    REAL, DOUBLE, DATE, VARCHAR, ARRAY, MAP and ROW. When casting to ARRAY or MAP,
-    the element type of the array or the value type of the map must be one of
-    these supported types, and for maps, the key type must be VARCHAR. Casting
+    REAL, DOUBLE, DECIMAL, DATE, VARCHAR, ARRAY, MAP and ROW. When casting to ARRAY
+    or MAP, the element type of the array or the value type of the map must be one
+    of these supported types, and for maps, the key type must be VARCHAR. Casting
     to ROW supports only JSON objects.
     Note that since the result type can be inferred from the expression, in Velox we
     do not need to provide the ``schema`` parameter as required by Spark's from_json
@@ -35,6 +35,7 @@ JSON Functions
         SELECT from_json('{"a": true}', 'a BOOLEAN'); -- {'a'=true}
         SELECT from_json('{"a": 1}', 'a INT'); -- {'a'=1}
         SELECT from_json('{"a": 1.0}', 'a DOUBLE'); -- {'a'=1.0}
+        SELECT from_json('{"a": 5.321E2}', 'a DECIMAL(7, 2)'); -- {'a'=532.10}
         SELECT from_json('{"a":"2021-7-1T"}', 'a DATE'); -- {'a'="2021-07-01"}
         SELECT from_json('{"a":"1"}', 'a DATE'); -- {'a'="1970-01-02"}
         SELECT from_json('["name", "age", "id"]', 'ARRAY<STRING>'); -- ['name', 'age', 'id']
@@ -58,10 +59,7 @@ JSON Functions
 .. spark:function:: get_json_object(jsonString, path) -> varchar
 
     Returns a json object, represented by VARCHAR, from ``jsonString`` by searching ``path``.
-    Valid ``path`` should start with '$' and then contain "[index]", "['field']" or ".field"
-    to define a JSON path. Here are some examples: "$.a" "$.a.b", "$[0]['a'].b". Returns
-    ``jsonString`` if ``path`` is "$". Returns NULL if ``jsonString`` or ``path`` is malformed.
-    Returns NULL if ``path`` does not exist. ::
+    Returns NULL if ``jsonString`` or ``path`` is malformed or ``path`` does not exist. ::
 
         SELECT get_json_object('{"a":"b"}', '$.a'); -- 'b'
         SELECT get_json_object('{"a":{"b":"c"}}', '$.a'); -- '{"b":"c"}'
@@ -69,6 +67,12 @@ JSON Functions
         SELECT get_json_object('{"a"-3}'', '$.a'); -- NULL (malformed JSON string)
         SELECT get_json_object('{"a":3}'', '.a'); -- NULL (malformed JSON path)
 
+    Valid ``path`` syntax:
+        * Must start with '$'.
+        * Using "[index]", "['field']" or ".field" to navigate to the desired JSON object.
+        * Whitespace is allowed **after the dot** and **before the field name**, e.g., "$.  field".
+        * Trailing whitespace after '$' is allowed, e.g., "$   ".
+
 .. spark:function:: json_array_length(jsonString) -> integer
 
     Returns the number of elements in the outermost JSON array from ``jsonString``.
@@ -90,3 +94,21 @@ JSON Functions
         SELECT json_object_keys(1); -- NULL
         SELECT json_object_keys('"hello"'); -- NULL
         SELECT json_object_keys("invalid json"); -- NULL
+
+.. spark:function:: to_json(jsonObject) -> jsonString
+
+    Converts a Json object (ROW, ARRAY or MAP) into a JSON string. ::
+
+        SELECT to_json(named_struct('c0', 1, 'c1', 'a')); -- {"c0":1,"c1":"a"}
+        SELECT to_json(ARRAY(1, 2, 3)); -- [1,2,3]
+        SELECT to_json(MAP('x', 1, 'y', 2)); -- {"x":1,"y":2}
+
+    The current implementation has following limitations.
+
+    * Does not support user provided options. ::
+
+        to_json(MAP(1, 'a'), map('option', 'value'))
+
+    * MAP key type cannot be/contain MAP. ::
+
+        to_json(MAP(MAP('a', 1), 10))
diff --git a/velox/docs/functions/spark/map.rst b/velox/docs/functions/spark/map.rst
index 0efb77da7ce6..85532a6a12a8 100644
--- a/velox/docs/functions/spark/map.rst
+++ b/velox/docs/functions/spark/map.rst
@@ -1,6 +1,6 @@
-===========================
+=============
 Map Functions
-===========================
+=============
 
 .. spark:function:: element_at(map(K,V), key) -> V
 
@@ -8,9 +8,14 @@ Map Functions
 
 .. spark:function:: map(K, V, K, V, ...) -> map(K,V)
 
-    Returns a map created using the given key/value pairs. Keys are not allowed to be null. ::
+    Returns a map created using the given key/value pairs. If there is duplicate key, by default that
+    key's value comes from last value for that key in the arguments.
+    If configuration `throw_exception_on_duplicate_map_keys` is set true,
+    throws exception for duplicate keys. Keys are not allowed to be null. ::
 
         SELECT map(1, 2, 3, 4); -- {1 -> 2, 3 -> 4}
+        SELECT map(1, 2, 3, 4, 1, 5); -- {1 -> 5, 3 -> 4} (LAST_WIN behavior)
+        SELECT map(1, 2, 3, 4, 1, 5); -- "Duplicate map key (1) was found" (EXCEPTION behavior)
 
         SELECT map(array(1, 2), array(3, 4)); -- {[1, 2] -> [3, 4]}
 
@@ -70,7 +75,7 @@ Map Functions
                             (k, v1, v2) -> k || CAST(v1/v2 AS VARCHAR));
 
 .. spark:function:: size(map(K,V), legacySizeOfNull) -> integer
-   :noindex:
+    :noindex:
 
     Returns the size of the input map. Returns null for null input if ``legacySizeOfNull``
     is set to false. Otherwise, returns -1 for null input. ::
diff --git a/velox/docs/functions/spark/math.rst b/velox/docs/functions/spark/math.rst
index dcc088d756fa..4bdc0d58fd65 100644
--- a/velox/docs/functions/spark/math.rst
+++ b/velox/docs/functions/spark/math.rst
@@ -1,11 +1,18 @@
-====================================
+======================
 Mathematical Functions
-====================================
+======================
 
-.. spark:function:: abs(x) -> [same as x]
+.. spark:function:: abs(x) -> [same as x] (ANSI compliant)
 
-    Returns the absolute value of ``x``.
+    Returns the absolute value of ``x``. When ``x`` is negative minimum
+    value of integral type returns the same value as ``x`` following
+    the behavior when Spark ANSI mode is disabled and throws exception
+    when Spark ANSI mode is enabled. ::
 
+        SELECT abs(-42); -- 42
+        SELECT abs(3.14); -- 3.14
+        SELECT abs(-128); -- 128 (with ANSI mode disabled)
+        SELECT abs(-128); -- Overflow exception (with ANSI mode enabled for TINYINT)
 .. spark:function:: acos(x) -> double
 
     Returns the inverse cosine (a.k.a. arc cosine) of ``x``.
@@ -62,6 +69,10 @@ Mathematical Functions
 
     Returns the string representation of the long value ``x`` represented in binary.
 
+.. spark:function:: cbrt(x) -> double
+
+    Returns the cube root of ``x``.
+
 .. spark:function:: ceil(x) -> [same as x]
 
     Returns ``x`` rounded up to the nearest integer.
@@ -72,7 +83,14 @@ Mathematical Functions
     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]
+.. function:: checked_div(x, y) -> bigint
+
+    Returns the result of integer division of ``x`` by ``y``, truncating toward zero.
+    Supported types are integral types, ``x`` and ``y`` must have the same type.
+    Division by zero or overflow results in an error. This function operates in ANSI mode (error on invalid input).
+    Corresponds to Spark's operator ``div`` with ``spark.sql.ansi.enabled`` set to true.
+
+.. spark: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.
@@ -107,6 +125,16 @@ Mathematical Functions
 
     Converts angle x in radians to degrees.
 
+.. spark:function:: div(x, y) -> bigint
+
+    Returns the results of dividing x by y. Performs the integer division truncates toward zero.
+    Supported types are integral types, x and y must have the same type.
+    Division by zero or overflow results in null. ::
+
+        SELECT 3 div 2; -- 1
+        SELECT 1L div 2L; -- 0
+        SELECT 3 div 0; -- NULL
+
 .. spark:function:: divide(x, y) -> double
 
     Returns the results of dividing x by y. Performs floating point division.
diff --git a/velox/docs/functions/spark/misc.rst b/velox/docs/functions/spark/misc.rst
index de826e35b140..311586faa6f9 100644
--- a/velox/docs/functions/spark/misc.rst
+++ b/velox/docs/functions/spark/misc.rst
@@ -1,6 +1,6 @@
-====================================
+=======================
 Miscellaneous Functions
-====================================
+=======================
 
 .. spark:function:: at_least_n_non_nulls(n, value1, value2, ..., valueN) -> bool
 
@@ -15,6 +15,16 @@ Miscellaneous Functions
         SELECT at_least_n_non_nulls(2, 0, 1.0, NULL);  -- true
         SELECT at_least_n_non_nulls(2, 0, array(NULL), NULL);  -- true
 
+.. spark:function:: get_array_struct_fields(array, ordinal) -> array(T)
+
+    Extracts the ``ordinal``-th fields of all array elements, and returns them as a new array.
+    The first input must be of array(strcut) type and nested complex type is allowed.
+    The ``ordinal`` is 0-based, and if ``ordinal`` is negative or no less than
+    the children size of strcut, exception is thrown. ::
+
+        SELECT items.col1 FROM VALUES (array(struct(100,'foo'), struct(200,'bar'))) AS t(items); -- array(100, 200)
+        SELECT items.col2 FROM VALUES (array(struct(100,'foo'), struct(200,'bar'))) AS t(items); -- array('foo', 'bar')
+
 .. spark:function:: get_struct_field(struct, ordinal) -> T
 
     Returns the value of nested subfield at position ``ordinal`` in the input ``struct``.
diff --git a/velox/docs/functions/spark/regexp.rst b/velox/docs/functions/spark/regexp.rst
index 0552e2a4678f..ab994e738f2d 100644
--- a/velox/docs/functions/spark/regexp.rst
+++ b/velox/docs/functions/spark/regexp.rst
@@ -32,7 +32,7 @@ See https://github.com/google/re2/wiki/Syntax for more information.
     '%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.
+    regular expressions are counted towards the limit. ::
 
         SELECT like('abc', '%b%'); -- true
         SELECT like('a_c', '%#_%', '#'); -- true
@@ -48,7 +48,7 @@ See https://github.com/google/re2/wiki/Syntax for more information.
         SELECT regexp_extract('1a 2b 14m', '\d+'); -- 1
 
 .. spark: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``.
diff --git a/velox/docs/functions/spark/string.rst b/velox/docs/functions/spark/string.rst
index e788f1d2ddb2..6e8c5f96de86 100644
--- a/velox/docs/functions/spark/string.rst
+++ b/velox/docs/functions/spark/string.rst
@@ -1,6 +1,6 @@
-====================================
+================
 String Functions
-====================================
+================
 
 .. note::
 
@@ -13,12 +13,37 @@ String Functions
 
     Returns unicode code point of the first character of ``string``. Returns 0 if ``string`` is empty.
 
+.. spark:function:: base64(expr) -> varchar
+
+    Converts ``expr`` to a base 64 string using RFC2045 Base64 transfer encoding for MIME. ::
+
+        SELECT base64('Spark SQL'); -- 'U3BhcmsgU1FM'
+
 .. spark:function:: bit_length(string/binary) -> integer
 
     Returns the bit length for the specified string column. ::
 
         SELECT bit_length('123'); -- 24
 
+.. spark:function:: char_type_write_side_check(string, limit) -> varchar
+
+    Ensures that input ``string`` fits within the specified length ``limit`` in characters by padding or trimming spaces as needed.
+    If the length of ``string`` is less than ``limit``, it is padded with trailing spaces (ASCII 32) to reach ``limit``.
+    If the length of ``string`` is greater than ``limit``, trailing spaces are trimmed to fit within ``limit``.
+    Throws exception when ``string`` still exceeds ``limit`` after trimming trailing spaces or when ``limit`` is not greater than 0.
+    Note: This function is not directly callable in Spark SQL, but internally used for length check when writing char type columns. ::
+
+        -- Function call examples (this function is not directly callable in Spark SQL).
+        char_type_write_side_check("abc", 3) -- "abc"
+        char_type_write_side_check("ab", 3) -- "ab "
+        char_type_write_side_check("a", 3) -- "a  "
+        char_type_write_side_check("abc  ", 3) -- "abc"
+        char_type_write_side_check("abcd", 3) -- VeloxUserError: "Exceeds allowed length limitation: '3'"
+        char_type_write_side_check("世界", 2) -- "世界"
+        char_type_write_side_check("世", 3) -- "世  "
+        char_type_write_side_check("世界人", 2) -- VeloxUserError: "Exceeds allowed length limitation: '2'"
+        char_type_write_side_check("abc", 0) -- VeloxUserError: "The length limit must be greater than 0."
+
 .. spark:function:: chr(n) -> varchar
 
     Returns the Unicode code point ``n`` as a single character string.
@@ -108,6 +133,20 @@ String Functions
         SELECT find_in_set(NULL, ',123'); -- NULL
         SELECT find_in_set("abc", NULL); -- NULL
 
+.. spark:function:: initcap(string) -> varchar
+
+   The ``initcap`` function converts the first character of each word to uppercase
+   and all other characters in the word to lowercase. It supports UTF-8 multibyte
+   characters, up to four bytes per character.
+
+   A *word* is defined as a sequence of characters separated by whitespace. ::
+
+        SELECT initcap('spark sql'); -- Spark Sql
+        SELECT initcap('spARK sQL'); -- Spark Sql
+        SELECT initcap('123abc DEF!ghi'); -- 123abc Def!ghi
+        SELECT initcap('élan vital für alle'); -- Élan Vital Für Alle
+        SELECT initcap('hello-world test_case'); -- Hello-world Test_case
+
 .. spark:function:: instr(string, substring) -> integer
 
     Returns the starting position of the first instance of ``substring`` in
@@ -184,7 +223,7 @@ String Functions
         SELECT ltrim('  data  '); -- "data  "
 
 .. spark:function:: ltrim(trimCharacters, string) -> varchar
-   :noindex:
+    :noindex:
 
     Removes specified leading characters from ``string``. The specified character
     is any character contained in ``trimCharacters``.
@@ -247,6 +286,24 @@ String Functions
         SELECT overlay('Spark SQL', 'tructured', 2, 4); -- "Structured SQL"
         SELECT overlay('Spark SQL', '_', -6, 3); -- "_Sql"
 
+.. spark:function:: read_side_padding(string, limit) -> varchar
+
+    Right-pads the given string with spaces to the specified length ``limit``.
+    If the string's length is already greater than or equal to ``limit``, it is returned as-is.
+    Throws an exception if ``limit`` is not greater than 0.
+    Note: This function is not directly callable in Spark SQL, but is used internally for reading CHAR type columns. ::
+
+        -- Function call examples (this function is not directly callable in Spark SQL).
+        read_side_padding("a", 3) -- "a  "
+        read_side_padding("abc", 3) -- "abc"
+        read_side_padding("abcd", 3) -- "abcd"
+        read_side_padding("世", 3) -- "世  "
+        read_side_padding("世界", 2) -- "世界"
+        read_side_padding("Привет", 8) -- "Привет  "
+        read_side_padding("Γειά", 5) -- "Γειά "
+        read_side_padding("Приветик", 6) -- "Приветик"
+        read_side_padding("a", 0) -- VeloxUserError: "The length limit must be greater than 0."
+
 .. spark:function:: repeat(input, n) -> varchar
 
     Returns the string which repeats ``input`` ``n`` times.
@@ -294,7 +351,7 @@ String Functions
         SELECT rtrim('  data  '); -- "  data"
 
 .. spark:function:: rtrim(trimCharacters, string) -> varchar
-   :noindex:
+    :noindex:
 
     Removes specified trailing characters from ``string``. The specified character
     is any character contained in ``trimCharacters``.
@@ -360,7 +417,7 @@ String Functions
     the meaning is to refer to the first character.Type of 'start' must be an INTEGER.
 
 .. spark:function:: substring(string, start, length) -> varchar
-   :noindex:
+    :noindex:
 
     Returns a substring from ``string`` of length ``length`` from the starting
     position ``start``. Positions start with ``1``. A negative starting
@@ -425,7 +482,7 @@ String Functions
         SELECT trim('  data  '); -- "data"
 
 .. spark:function:: trim(trimCharacters, string) -> varchar
-   :noindex:
+    :noindex:
 
     Removes specified leading and trailing characters from ``string``.
     The specified character is any character contained in ``trimCharacters``.
@@ -433,13 +490,17 @@ String Functions
 
         SELECT trim('sprk', 'spark'); -- "a"
 
+.. spark:function:: unbase64(expr) -> varbinary
+
+    Returns a decoded base64 string as binary. ::
+
+        SELECT cast(unbase64('U3BhcmsgU1FM') AS STRING); -- 'Spark SQL'
+
 .. spark:function:: upper(string) -> string
 
     Returns string with all characters changed to uppercase. ::
 
         SELECT upper('SparkSql'); -- SPARKSQL
-<<<<<<< HEAD
-=======
 
 .. spark:function:: varchar_type_write_side_check(string, limit) -> varchar
 
@@ -456,4 +517,3 @@ String Functions
         varchar_type_write_side_check("中文中国", 3) -- VeloxUserError: "Exceeds allowed length limitation: '3'"
         varchar_type_write_side_check("   ", 0) -- VeloxUserError: "The length limit must be greater than 0."
         varchar_type_write_side_check("", 3) -- ""
->>>>>>> 7c73c1106 (misc: Use pre-commit for quality checks (#13361))
diff --git a/velox/docs/functions/spark/url.rst b/velox/docs/functions/spark/url.rst
index a6eaf70edba9..26544fb4a184 100644
--- a/velox/docs/functions/spark/url.rst
+++ b/velox/docs/functions/spark/url.rst
@@ -48,6 +48,11 @@ digits after the percent character "%". All the url extract functions will retur
 Encoding Functions
 ------------------
 
+.. spark:function:: url_decode(value) -> varchar
+
+    Unescapes the URL encoded ``value``.
+    This function is the inverse of :spark:func:`url_encode`.
+
 .. spark:function:: url_encode(value) -> varchar
 
     Escapes ``value`` by encoding it so that it can be safely included in
@@ -59,8 +64,3 @@ Encoding Functions
     * 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 2a4d7921c95a..2420e9f07f71 100644
--- a/velox/docs/functions/spark/window.rst
+++ b/velox/docs/functions/spark/window.rst
@@ -3,7 +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`
+More details about window functions can be found at :doc:`/develop/window`.
 
 Value functions
 ---------------
@@ -18,14 +18,6 @@ in the window, null is returned. It is an error for the offset to be zero or neg
 Rank functions
 ---------------
 
-.. spark:function:: row_number() -> integer
-
-Returns a unique, sequential number to each row, starting with one, according to the ordering of rows within the window partition.
-
-.. spark:function:: rank() -> integer
-
-Returns the rank of a value in a group of values. The rank is one plus the number of rows preceding the row that are not peer with the row. Thus, the values in the ordering will produce gaps in the sequence. The ranking is performed for each window partition.
-
 .. spark:function:: dense_rank() -> integer
 
 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.
@@ -35,3 +27,11 @@ Returns the rank of a value in a group of values. This is similar to rank(), exc
 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``
+
+.. spark:function:: rank() -> integer
+
+Returns the rank of a value in a group of values. The rank is one plus the number of rows preceding the row that are not peer with the row. Thus, the values in the ordering will produce gaps in the sequence. The ranking is performed for each window partition.
+
+.. spark:function:: row_number() -> integer
+
+Returns a unique, sequential number to each row, starting with one, according to the ordering of rows within the window partition.
diff --git a/velox/docs/index.rst b/velox/docs/index.rst
index 37b9470c0d24..f1d65f2065e0 100644
--- a/velox/docs/index.rst
+++ b/velox/docs/index.rst
@@ -9,6 +9,8 @@ Velox Documentation
     monthly-updates
     functions
     spark_functions
+    functions/iceberg/functions
+    functions/delta/functions
     configs
     monitoring
     bindings/python/index
diff --git a/velox/docs/mailmap_base64 b/velox/docs/mailmap_base64
index 40240370d949..5f2e47c368f7 100644
--- a/velox/docs/mailmap_base64
+++ b/velox/docs/mailmap_base64
@@ -1 +1,3 @@
-Q2hyaXN0aWFuIFplbnRncmFmIDxJQk0+IDxraXRnb2N6QGdtYWlsLmNvbT4KSmFjb2IgV3VqY2lhay1KZW5zIDxWb2x0cm9uIERhdGE+IDxqYWNvYkB3dWpjaWFrLmRlPgpQcmFtb2QgU2F0eWEgPElCTT4gPHByYW1vZEBhaGFuYS5pbz4KUHJhbW9kIFNhdHlhIDxJQk0+IDxwcmFtb2Quc2F0eWFAaWJtLmNvbT4K
+Q2hyaXN0aWFuIFplbnRncmFmIDxJQk0+IDxraXRnb2N6QGdtYWlsLmNvbT4KSmFjb2IgV3VqY2lh
+ay1KZW5zIDwudHh0PiA8amFjb2JAd3VqY2lhay5kZT4KUHJhbW9kIFNhdHlhIDxJQk0+IDxwcmFt
+b2RAYWhhbmEuaW8+ClByYW1vZCBTYXR5YSA8SUJNPiA8cHJhbW9kLnNhdHlhQGlibS5jb20+Cg==
diff --git a/velox/docs/monitoring/metrics.rst b/velox/docs/monitoring/metrics.rst
index 63961e46e920..25d42af25cc2 100644
--- a/velox/docs/monitoring/metrics.rst
+++ b/velox/docs/monitoring/metrics.rst
@@ -9,14 +9,17 @@ 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.
+**Define**: define the name and type for the metric through DEFINE_METRIC,
+DEFINE_HISTOGRAM_METRIC, DEFINE_QUANTILE_STAT, and DEFINE_DYNAMIC_QUANTILE_STAT
+macros. DEFINE_HISTOGRAM_METRIC is used for histogram metric type,
+DEFINE_QUANTILE_STAT for quantile metrics, DEFINE_DYNAMIC_QUANTILE_STAT for
+dynamic quantile metrics, 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,
+RECORD_HISTOGRAM_METRIC_VALUE, RECORD_QUANTILE_STAT_VALUE, and
+RECORD_DYNAMIC_QUANTILE_STAT_VALUE macros when the corresponding event happens.
 BaseStatsReporter provides methods for metric recording.
 
 **Export**: aggregates the collected data points based on the defined metrics,
@@ -26,7 +29,7 @@ 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:
+Velox supports seven metric types:
 
 **Count**: tracks the count of events, such as the number of query failures.
 
@@ -49,6 +52,23 @@ 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.
 
+**Quantile**: tracks quantile statistics (percentiles) of event data point values
+over configurable sliding time windows, such as P50, P95, and P99 latencies over
+the last 60 seconds. Unlike histograms which use fixed buckets, quantile metrics
+dynamically calculate percentiles from the actual data distribution.
+DEFINE_QUANTILE_STAT specifies the stat types to export (e.g., AVG, COUNT, SUM),
+the percentiles to track (as values between 0.0 and 1.0), and the sliding window
+periods in seconds. This provides more accurate percentile calculations compared
+to histogram approximations, especially for metrics with varying distributions.
+
+**Dynamic Quantile**: extends quantile metrics to support dynamic key patterns
+with runtime substitution using format placeholders (e.g., "latency.{}.{}" where
+placeholders are replaced with actual values like database names or endpoint names).
+DEFINE_DYNAMIC_QUANTILE_STAT registers a pattern template, and
+RECORD_DYNAMIC_QUANTILE_STAT_VALUE substitutes the placeholders to create specific
+metric instances. This enables efficient tracking of quantile metrics across
+multiple dimensions without pre-registering every possible combination.
+
 Task Execution
 --------------
 .. list-table::
@@ -73,13 +93,16 @@ Task Execution
        30 buckets. It is configured to report the latency at P50, P90, P99,
        and P100 percentiles.
    * - task_batch_process_time_ms
-     - Average
+     - Avg
      - Tracks the averaged task batch processing time. This only applies for
        sequential task execution mode.
    * - task_barrier_process_time_ms
      - Histogram
      - Tracks task barrier execution time in range of [0, 30s] with 30 buckets
        and each bucket with time window of 1s. We report P50, P90, P99, and P100.
+   * - task_splits_count
+     - Count
+     - The total number of splits received by all tasks.
 
 Memory Management
 -----------------
@@ -140,9 +163,6 @@ Memory Management
    * - task_memory_reclaim_wait_timeout_count
      - Count
      - The number of times that the task memory reclaim wait timeouts.
-   * - task_splits_count
-     - Count
-     - The total number of splits received by all tasks.
    * - memory_non_reclaimable_count
      - Count
      - The number of times that the memory reclaim fails because the operator is executing a
@@ -206,11 +226,11 @@ Memory Management
        arbitration operation 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
+     - Avg
      - The average of total free memory capacity which is managed by the
        memory arbitrator.
    * - arbitrator_free_reserved_capacity_bytes
-     - Average
+     - Avg
      - The average of free memory capacity reserved to ensure each query has
        the minimal required capacity to run.
    * - memory_pool_initial_capacity_bytes
@@ -243,15 +263,14 @@ Memory Management
        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
+   * - memory_allocator_allocated_bytes
      - Avg
      - Number of bytes currently allocated (used) from MemoryAllocator in the form
        of 'Allocation' or 'ContiguousAllocation'.
-   * - mmap_allocator_external_mapped_bytes
+   * - memory_allocator_external_mapped_bytes
      - Avg
-     - Number of bytes currently mapped in MmapAllocator, in the form of
+     - Number of bytes currently mapped in MemoryAllocator, 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
@@ -273,9 +292,12 @@ Cache
      - Avg
      - Max possible age of AsyncDataCache and SsdCache entries since the raw file
        was opened to load the cache.
-   * - memory_cache_num_entries
+   * - memory_cache_num_large_entries
+     - Avg
+     - Total number of large cache entries.
+   * - memory_cache_num_tiny_entries
      - Avg
-     - Total number of cache entries.
+     - Total number of tiny cache entries.
    * - memory_cache_num_empty_entries
      - Avg
      - Total number of cache entries that do not cache anything.
@@ -397,9 +419,15 @@ Cache
    * - ssd_cache_write_ssd_errors
      - Sum
      - Total number of error while writing to SSD cache files.
+   * - ssd_cache_write_no_space_errors
+     - Sum
+     - Total number of errors due to SSD no space for writes.
    * - ssd_cache_write_ssd_dropped
      - Sum
      - Total number of writes dropped due to no cache space.
+   * - ssd_cache_write_exceed_entry_limit
+     - Sum
+     - Total number of writes dropped due to entry limit exceeded.
    * - ssd_cache_write_checkpoint_errors
      - Sum
      - Total number of errors while writing SSD checkpoint file.
@@ -600,6 +628,9 @@ Index Join
      - The distribution of index lookup result bytes in range of [0, 128MB] with
        128 buckets. It is configured to report the capacity at P50, P90, P99, and
        P100 percentiles.
+   * - index_lookup_error_result_count
+     - Count
+     - The number of results with error.
 
 Table Scan
 ----------
@@ -612,12 +643,11 @@ Table Scan
      - Type
      - Description
    * - table_scan_batch_process_time_ms
-     - Histogram
-     - The time distribution of table scan batch processing time in range of [0,
-       16s] with 512 buckets and reports P50, P90, P99, and P100.
+     - Avg
+     - Tracks the averaged table scan batch processing time in milliseconds.
    * - table_scan_batch_bytes
-     - Histogram
-     - The size distribution of table scan output batch in range of [0, 512MB]
+     - Avg
+     - Tracks the averaged table scan output batch size in bytes.
        with 512 buckets and reports P50, P90, P99, and P100
 
 S3 FileSystem
diff --git a/velox/docs/monitoring/stats.rst b/velox/docs/monitoring/stats.rst
index 818902b58c13..e2ff1db8db69 100644
--- a/velox/docs/monitoring/stats.rst
+++ b/velox/docs/monitoring/stats.rst
@@ -189,6 +189,31 @@ These stats are reported only by IndexLookupJoin operator
      - bytes
      - The byte size of the result data in velox vectors that are decoded from the raw data
        received from the remote storage lookup.
+   * - clientNumLazyDecodedResultBatches
+     -
+     - The number of lazy decoded result batches returned from the storage client.
+
+Merge
+-----
+These stats are reported only by Merge operator
+
+.. list-table::
+   :widths: 50 25 50
+   :header-rows: 1
+
+   * - Stats
+     - Unit
+     - Description
+   * - streamingSourceReadWallNanos
+     - nanos
+     - The number of a spillable operators that don't support spill because of
+       spill limitation. For instance, a window operator do not support spill
+       if there is no partitioning.
+   * - spilledSourceReadWallNanos
+     - nanos
+     - The running wall time of the merge operator reading from the spilled source to
+       produce the final output. This only applies when spilling is enabled for local
+       merge.
 
 Spilling
 --------
@@ -305,3 +330,24 @@ These stats are reported by IterativeVectorSerializer.
    * - compressionSkippedBytes
      -
      - The number of bytes that skip in-efficient compression.
+
+Connector
+---------
+These stats are reported only by connector data or index sources.
+
+.. list-table::
+   :widths: 50 25 50
+   :header-rows: 1
+
+   * - Stats
+     - Unit
+     - Description
+   * - totalRemainingFilterWallNanos
+     - nanos
+     - The total walltime in nanoseconds that the data or index connector do the remaining filtering.
+   * - numIndexFilterConversions
+     -
+     - The number of index columns that were converted from ScanSpec filters to
+       index bounds for index-based filtering (e.g., cluster index pruning in
+       Nimble). A value greater than zero indicates filters were successfully
+       converted to leverage file index structures for row pruning.
diff --git a/velox/docs/monthly-updates.rst b/velox/docs/monthly-updates.rst
index 34830dbb3ac3..fa1abeafaeed 100644
--- a/velox/docs/monthly-updates.rst
+++ b/velox/docs/monthly-updates.rst
@@ -5,14 +5,10 @@ Monthly Updates
 .. toctree::
     :maxdepth: 1
 
-    monthly-updates/august-2024
-    monthly-updates/july-2024
-    monthly-updates/june-2024
-    monthly-updates/may-2024
-    monthly-updates/april-2024
-    monthly-updates/march-2024
-    monthly-updates/february-2024
-    monthly-updates/january-2024
+    monthly-updates/july-2025
+    monthly-updates/june-2025
+    monthly-updates/may-2025
+    monthly-updates/2024/index
     monthly-updates/2023/index
     monthly-updates/2022/index
     monthly-updates/2021/index
diff --git a/velox/docs/monthly-updates/april-2024.rst b/velox/docs/monthly-updates/2024/april-2024.rst
similarity index 100%
rename from velox/docs/monthly-updates/april-2024.rst
rename to velox/docs/monthly-updates/2024/april-2024.rst
diff --git a/velox/docs/monthly-updates/august-2024.rst b/velox/docs/monthly-updates/2024/august-2024.rst
similarity index 100%
rename from velox/docs/monthly-updates/august-2024.rst
rename to velox/docs/monthly-updates/2024/august-2024.rst
diff --git a/velox/docs/monthly-updates/february-2024.rst b/velox/docs/monthly-updates/2024/february-2024.rst
similarity index 100%
rename from velox/docs/monthly-updates/february-2024.rst
rename to velox/docs/monthly-updates/2024/february-2024.rst
diff --git a/velox/docs/monthly-updates/2024/index.rst b/velox/docs/monthly-updates/2024/index.rst
new file mode 100644
index 000000000000..b098f4799151
--- /dev/null
+++ b/velox/docs/monthly-updates/2024/index.rst
@@ -0,0 +1,15 @@
+***************
+2024
+***************
+
+.. toctree::
+    :maxdepth: 1
+
+    august-2024
+    july-2024
+    june-2024
+    may-2024
+    april-2024
+    march-2024
+    february-2024
+    january-2024
diff --git a/velox/docs/monthly-updates/january-2024.rst b/velox/docs/monthly-updates/2024/january-2024.rst
similarity index 100%
rename from velox/docs/monthly-updates/january-2024.rst
rename to velox/docs/monthly-updates/2024/january-2024.rst
diff --git a/velox/docs/monthly-updates/july-2024.rst b/velox/docs/monthly-updates/2024/july-2024.rst
similarity index 100%
rename from velox/docs/monthly-updates/july-2024.rst
rename to velox/docs/monthly-updates/2024/july-2024.rst
diff --git a/velox/docs/monthly-updates/june-2024.rst b/velox/docs/monthly-updates/2024/june-2024.rst
similarity index 100%
rename from velox/docs/monthly-updates/june-2024.rst
rename to velox/docs/monthly-updates/2024/june-2024.rst
diff --git a/velox/docs/monthly-updates/march-2024.rst b/velox/docs/monthly-updates/2024/march-2024.rst
similarity index 100%
rename from velox/docs/monthly-updates/march-2024.rst
rename to velox/docs/monthly-updates/2024/march-2024.rst
diff --git a/velox/docs/monthly-updates/may-2024.rst b/velox/docs/monthly-updates/2024/may-2024.rst
similarity index 100%
rename from velox/docs/monthly-updates/may-2024.rst
rename to velox/docs/monthly-updates/2024/may-2024.rst
diff --git a/velox/docs/monthly-updates/july-2025.rst b/velox/docs/monthly-updates/july-2025.rst
new file mode 100644
index 000000000000..0146c286aa5c
--- /dev/null
+++ b/velox/docs/monthly-updates/july-2025.rst
@@ -0,0 +1,83 @@
+****************
+July 2025 Update
+****************
+
+This update was generated with the assistance of AI. While we strive for accuracy, please note
+that AI-generated content may not always be error-free. We encourage you to verify any information
+that you deem important.
+
+Core Library
+============
+
+* Switch to C++20 standard. :pr:`10866`
+* Add ParallelProject node and operator from Verax. :pr:`14220`
+* Add barriered execution support to AssignUniqueId. :pr:`14224`
+* Add support for left join semantics to Unnest. :pr:`14095`
+* Add support for converting OPAQUE vectors to variant. :pr:`14235`
+* Add basic support for coercions to help with function type resolution. :pr:`14113`
+* Optimize streaming aggregation by removing max output batch size limit, reducing peak memory 4x. :pr:`14238`
+* Fix deadlock when dropping non-existent child memory pools. :pr:`14202`
+* Fix Variant::hash and BaseVector::hashValueAt for arrays and maps. :pr:`14019`
+* Fix ConstantTypedExpr equals/hash/toString methods for various data types. :pr:`14055`
+* Fix AssignUniqueId needsInput logic. :pr:`14127`
+
+Presto Functions
+================
+
+* Add :func:`dot_product` function for embedding similarity calculations.
+* Add seeded version of :func:`xxhash64` function.
+* Add SFM sketch functions: :func:`merge`, :func:`noisy_approx_set_sfm_from_index_and_zeros`, :func:`noisy_approx_distinct_sfm` and :func:`noisy_approx_set_sfm` aggregate functions.
+* Add :func:`quantile_at_value` and :func:`scale_qdigest` functions.
+* Add :func:`geometry_nearest_points`, :func:`ST_NumPoints`, :func:`ST_EnvelopeAsPts`, :func:`ST_Points` functions.
+* Add :func:`ST_Buffer`, :func:`ST_CoordDim`, :func:`ST_Envelope`, :func:`ST_ExteriorRing` functions.
+* Add :func:`ST_ConvexHull`, :func:`ST_Dimension`, :func:`ST_NumInteriorRing`, :func:`ST_NumGeometries` functions.
+* Add :func:`ST_GeometryN`, :func:`ST_InteriorRingN`, :func:`ST_StartPoint`, :func:`ST_EndPoint` functions.
+* Add :func:`ST_PointN`, :func:`ST_Length`, :func:`ST_IsClosed`, :func:`ST_Empty`, :func:`ST_IsRing` functions.
+* Add :func:`ST_Polygon` function.
+* Fix Geometry serialization/deserialization errors for GeometryCollections with empty geometries. :pr:`14243`
+* Optimize :func:`flatten` as a VectorFunction to enable zero copy. :pr:`14215`
+
+Spark Functions
+===============
+
+* Add :spark:func:`base64` and :spark:func:`initcap` functions.
+* Add support for decimal type in :spark:func:`from_json` function.
+* Add :spark:func:`abs` function to handle ANSI mode differences from Presto.
+* Fix :spark:func:`corr` aggregate function to return NaN instead of NULL when variance is zero. :pr:`13956`
+* Fix :spark:func:`covar_samp` aggregate function to return NaN instead of Inf when c2 is infinite. :pr:`13990`
+* Fix :spark:func:`get_json_object` function to normalize JSON paths properly. :pr:`13854`
+
+Connectors
+==========
+
+* Add metadata support and filter pushdown to TpchConnector. :pr:`14099`
+* Add HDFS filesystem operations: remove, rmdir, rename, mkdir. :pr:`13948`
+* Add S3 filesystem operations: exists and list. :pr:`13893`
+* Add TokenProvider support to ConnectorQueryCtx for authentication. :pr:`13919`
+* Add support for timestamp as Hive partition ID. :pr:`13494`
+* Add text format write support for complex types: ROW, MAP, and ARRAY. :pr:`14064`
+* Add escape character support for text parsing. :pr:`14130`
+* Add backward compatibility support for TIMESTAMP in TextReader. :pr:`14063`
+* Fix HiveDataSink to materialize input before writes to prevent lazy vector errors. :pr:`14085`
+
+Performance and Correctness
+===========================
+
+* Make BingTile and other custom types non-orderable to match Presto behavior. :pr:`14100`
+* Fix Cast to JSON output size estimation for invalid Unicode input. :pr:`14062`
+* Fix constant input size validation in streaming aggregation. :pr:`13933`
+* Fix hash aggregation row container cleanup crash on abort. :pr:`13979`
+
+Credits
+=======
+
+Amit Dutta, Bikramjeet Vig, Bowen Wu, Chengcheng Jin, Christian Zentgraf,
+Elodie Li, Eric Jia, Heidi Han, Henry Edwin Dikeman, Hongze Zhang, Jacob
+Khaliqi, Jacob Wujciak-Jens, James Gill, Jialiang Tan, Jimmy Lu, Joe Abraham,
+Ke Jia, Ke Wang, Kevin Wilfong, Konstantinos Karatsenidis, Krishna Pai, Libin
+Bai, Manikanta Loya, Masha Basmanova, Natasha Sehgal, Oliver Xu, Orri Erling,
+Patrick Sullivan, Pedro Eugenio Rocha Pedreira, Peter Enescu, Pramod Satya,
+Raaghav Ravishankar, Rajeev Dharmendra Singh, Rui Mo, Sutou Kouhei, Tony Liu,
+Vincent Crabtree, Xiao Du, Xiaoxuan Meng, Yi Cheng Lee, Yuxuan Chen, Zhen Li,
+Zhiying Liang, aditi-pandit, lingbin, nimesh.k, wecharyu, wraymo, zhli1142015,
+zml1206
diff --git a/velox/docs/monthly-updates/june-2025.rst b/velox/docs/monthly-updates/june-2025.rst
new file mode 100644
index 000000000000..caa55f9202a4
--- /dev/null
+++ b/velox/docs/monthly-updates/june-2025.rst
@@ -0,0 +1,74 @@
+****************
+June 2025 Update
+****************
+
+This update was generated with the assistance of AI. While we strive for accuracy, please note
+that AI-generated content may not always be error-free. We encourage you to verify any information
+that is important to you.
+
+Core Library
+============
+
+* Add null key support for index join. :pr:`13891`
+* Add Async SpillMerger in LocalMerge. :pr:`13634`
+* Share filter among drivers for improved efficiency. :pr:`13784`
+* Make global arbitration consider query priority. :pr:`13827`
+* Fix anti and semi join result mismatch with filter and multiple matches. :pr:`13123`
+* Fix the server crash caused by remote exchange error. :pr:`13905`
+* Fix resource release for memoizing constant folding expression. :pr:`13755`
+* Fix Expr::isDeterministic for lambda functions. :pr:`13647`
+* Enable constant folding for lambda functions. :pr:`13642`
+
+Presto Functions
+================
+
+* Add :func:`noisy_avg_gaussian`, :func:`noisy_sum_gaussian`, :func:`noisy_count_gaussian`, :func:`noisy_count_if_gaussian` functions.
+* Add :func:`tdigest_agg`, :func:`value_at_quatile`, :func:`values_at_quantiles`, :func:`quantile_at_value` functions.
+* Add :func:`inverse_chi_squared_cdf`, :func:`inverse_f_cdf` functions.
+* Add :func:`l2_squared` function.
+* Add :func:`ST_Distance`, :func:`ST_GeometryType`, :func:`St_Centroid`, :func:`St_Boundary`, :func:`ST_XMin`, :func:`ST_XMax`, :func:`ST_YMin`, :func:`ST_YMax` functions.
+* Add serialization and deserialization of Geometry type to/from WKT and WKB. :pr:`12771`
+* Fix :func:`values_at_quantiles` function to throw error on null input. :pr:`13810`
+* Optimize :func:`array_remove` to avoid unnecessary string copies.
+
+Spark Functions
+===============
+
+* Add :spark:func:`unbase64`, :spark:func:`trunc`, :spark:func:`varchar_type_write_side_check`, :spark:func:`cbrt` functions.
+* Fix try_cast and cast function error case handling. :pr:`12993`
+* Fix :spark:func:`lower` function on unicode character. :pr:`13158`
+* Fix handling of extreme floating-point values in :spark:func:`from_json`. :pr:`13378`
+
+Connectors
+==========
+
+* Add support for exist and list functions in HdfsFileSystem. :pr:`13813`
+* Add GCS filesystem operations: rmdir, mkdir, and rename. :pr:`13533`, :pr:`13532`, :pr:`13490`
+* Flatten complex-type vectors when writing to Parquet. :pr:`13338`
+* Fix multi range filter in timestamp reader for Parquet. :pr:`12926`
+* Fix NPE when reading complex type data from Parquet v2. :pr:`13512`
+
+Performance and Correctness
+===========================
+
+* Optimize getStringView performance. :pr:`13870`
+* Optimize streaming aggregation performance. :pr:`13812`
+* Reduce HashTable load factor from 0.875 to 0.7 for better performance. :pr:`13694`
+* Improve fillNewMemory tight loop performance. :pr:`13883`
+* Increase readBatchSize when the last batch is empty in TableScan. :pr:`13626`
+
+Credits
+=======
+
+aditi-pandit, Anders Dellien, Andrii Rosa, Artem Selishchev, Bikramjeet Vig,
+Bowen Wu, Chandrashekhar Kumar Singh, Chengcheng Jin, Christian Zentgraf,
+David Reveman, Deepak Majeti, Devavret Makkar, Dharan Aditya, duanmeng,
+Eric Jia, Huameng (Michael) Jiang, iiFeung, Jacob Khaliqi, Jacob Wujciak-Jens,
+Jialiang Tan, Jim Meyering, Jimmy Lu, Jin Chengcheng, Joe Giardino, joey.ljy,
+Ke Jia, Ke Wang, Kent Yao, Kevin Wilfong, Konstantinos Karatsenidis,
+Kostas Xirogiannopoulos, Krishna Pai, lingbin, Luis Garcés-Erice, Mario Ruiz,
+Masha Basmanova, Natasha Sehgal, Oliver Xu, Orri Erling, Patrick Sullivan,
+Paul Meng, Peter Enescu, Ping Liu, Richard Barnes, Rui Mo, Shakyan Kushwaha,
+Wei He, wraymo, xhs7700, Xiao Du, xiaodou, Xiaoxuan Meng, Xin Zhang, Yabin Ma,
+Yi Cheng Lee, yingsu00, Yoav Helfman, yumwang@ebay.com, Zhichen Xu,
+zhli1142015, zml1206, Zoltan Arnold Nagy
diff --git a/velox/docs/monthly-updates/may-2025.rst b/velox/docs/monthly-updates/may-2025.rst
new file mode 100644
index 000000000000..d049377a9a52
--- /dev/null
+++ b/velox/docs/monthly-updates/may-2025.rst
@@ -0,0 +1,83 @@
+***************
+May 2025 Update
+***************
+
+This update was generated with the assistance of AI. While we strive for accuracy, please note
+that AI-generated content may not always be error-free. We encourage you to verify any information
+that is important to you.
+
+Core Library
+============
+
+* Add task barrier. :pr:`13087`
+* Add task barrier support for streaming aggregation, unnest and index join. :pr:`13273`, :pr:`13293`, :pr:`13244`
+* Add support for memory pool priority. :pr:`13386`
+* Support buffering in local exchange operator. :pr:`13234`
+* Add PageSpill for OutputBuffer spill. :pr:`13305`
+* Add lazy start with spill for LocalMerge. :pr:`13337`
+* Add support for leftSemiProject join in nested loop join. :pr:`12172`
+* Fix crash when aggregate push down applied on updated column with sparse row set. :pr:`13503`
+* Fix the timing order of CpuWallTimer. :pr:`13313`
+* Fix overflow in NegatedBigintValuesUsingHashTable::testInt64Range. :pr:`13523`
+
+Presto Functions
+================
+
+* Add :func:`simplify_geometry`, :func:`geometry_invalid_reason`, :func:`ST_IsValid`, :func:`ST_IsSimple`, :func:`ST_Point`, :func:`ST_X`, :func:`ST_Y`, :func:`ST_area` functions.
+* Add :func:`bing_tile_at`, :func:`bing_tiles_around` functions.
+* Add :func:`qdigest_agg`, :func:`cosine_similarity` functions.
+* Add :func:`noisy_count_if_gaussian` function.
+* Add :func:`quantile_at_value`, :func:`trimmed_mean` functions.
+* Add geometry functions for WKT/WKB conversion.
+* Add :func:`xxhash64_internal` with extended type support.
+* Fix undefined behavior in qdigest when total weight exceeds int64_t max. :pr:`13336`
+* Fix handing of empty arrays in :func:`array_min`, :func:`array_max_by` functions. :pr:`13272`
+* Fix overflow check in timestamp addition. :pr:`13444`
+* Fix overflow in :func:`from_unixtime`. :pr:`13262`
+
+Spark Functions
+===============
+
+* Add :spark:func:`sqrt`, :spark:func:`luhn_check` functions.
+* Add CAST(bool as timestamp) support.
+* Add support for legacy behavior in covariance functions. :pr:`12994`
+* Fix casting complex types to only cast recursively if child type changes. :pr:`13245`
+* Fix unescape json elements in :spark:func:`array_join`. :pr:`13222`
+* Fix the duplicate map key handling for :spark:func:`map` function. :pr:`13183`
+
+Connectors
+==========
+
+* Support bucket write with non-partitioned table. :pr:`13283`
+* Support delta update on bucket column. :pr:`13404`
+* Support Null Column Projection in Batch Reader Adapter. :pr:`13430`
+* Add ColumnReaderOptions for better reader configuration. :pr:`12840`
+* Add support for float-to-double schema evolution. :pr:`13317`
+* Fix selective flatmap column reader read offset when all rows filtered out. :pr:`13350`
+* Fix access after buffer boundary causing crash in selective reader. :pr:`13344`
+* Fix crash if table column type does not match file column type. :pr:`12350`
+* Fix incorrect filter result during schema evolution when range is outside of old type. :pr:`13459`
+
+Performance and Correctness
+===========================
+
+* Optimize selective ARRAY and MAP reader. :pr:`13240`
+* Avoid decompressing data when estimating row size. :pr:`13365`
+* Clear hash table as soon as probe finish. :pr:`13254`
+* Allow empty file in table scan. :pr:`13241`
+
+Credits
+=======
+
+aditi-pandit, ajeyabsf, Ali LeClerc, alileclerc, Amit Dutta, Anders Dellien,
+Andrii Rosa, arnavb, Artem Selishchev, Bikramjeet Vig, Chandrashekhar Kumar Singh,
+Chengcheng Jin, Christian Zentgraf, Deepak Majeti, Devavret Makkar, duanmeng,
+Eric Jia, Haiping Xue, Heidi Han, Jacob Khaliqi, Jacob Wujciak-Jens, James Gill,
+Jialiang Tan, Jimmy Lu, Ke Jia, Ke Wang, Kent Yao, Kevin Wilfong, Kien Nguyen,
+Kk Pulla, Kostas Xirogiannopoulos, Krishna Pai, lingbin, Lukas Krenz,
+MacVincent Agha-Oko, Mario Ruiz, Mingyu Zhang, Natasha Sehgal, Nathan Phan,
+NEUpanning, Oliver Xu, Patrick Sullivan, Pedro Eugenio Rocha Pedreira,
+Peter Enescu, Pradeep Vaka, Qian Sun, Rui Mo, Serge Druzkin, Shakyan Kushwaha,
+Soumya Duriseti, Surbhi Vijayvargeeya, Tanay Bhartia, Wei He, Xiao Du,
+Xiaoxuan Meng, Yabin Ma, Yenda Li, Yi Cheng Lee, Zhenyuan Zhao, Zhiguo Wu,
+Zhiying Liang
diff --git a/velox/docs/spark_functions.rst b/velox/docs/spark_functions.rst
index 24c825ac1ef5..e6944a702a9e 100644
--- a/velox/docs/spark_functions.rst
+++ b/velox/docs/spark_functions.rst
@@ -2,7 +2,11 @@
 Spark Functions
 ***********************
 
-The semantics of Spark functions match Spark 3.5 with ANSI OFF.
+The semantics of Spark functions align with
+`Spark 3.5 <https://spark.apache.org/docs/3.5.0/api/sql/index.html>`_.
+In the function descriptions, a function is marked as *ANSI compliant*
+if it adheres to ANSI standard, subject to the :doc:`spark.ansi_enabled <configs>`
+configuration. Otherwise, it simply follows Spark's semantics in ANSI OFF mode.
 
 .. toctree::
     :maxdepth: 1
@@ -61,35 +65,80 @@ for :doc:`all <functions/spark/coverage>` functions.
     :widths: auto
     :class: rows
 
-    ================================  ================================  ================================  ==  ================================  ==  ================================
-    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`
-    ================================  ================================  ================================  ==  ================================  ==  ================================
+    ===========================================  ===========================================  ===========================================  ==  ===========================================  ==  ===========================================
+    Scalar Functions                                                                                                                           Aggregate Functions                              Window Functions
+    =====================================================================================================================================  ==  ===========================================  ==  ===========================================
+    :spark:func:`abs`                            :spark:func:`divide_deny_precision_loss`     :spark:func:`not`                                :spark:func:`avg`                                :spark:func:`dense_rank`
+    :spark:func:`acos`                           :spark:func:`doy`                            :spark:func:`overlay`                            :spark:func:`bit_xor`                            :spark:func:`nth_value`
+    :spark:func:`acosh`                          :spark:func:`element_at`                     :spark:func:`pmod`                               :spark:func:`bloom_filter_agg`                   :spark:func:`ntile`
+    :spark:func:`add`                            :spark:func:`empty2null`                     :spark:func:`power`                              :spark:func:`collect_list`                       :spark:func:`rank`
+    :spark:func:`add_deny_precision_loss`        :spark:func:`endswith`                       :spark:func:`quarter`                            :spark:func:`collect_set`                        :spark:func:`row_number`
+    :spark:func:`add_months`                     :spark:func:`equalnullsafe`                  :spark:func:`raise_error`                        :spark:func:`corr`
+    :spark:func:`aggregate`                      :spark:func:`equalto`                        :spark:func:`rand`                               :spark:func:`covar_samp`
+    :spark:func:`array`                          :spark:func:`exists`                         :spark:func:`random`                             :spark:func:`first`
+    :spark:func:`array_append`                   :spark:func:`exp`                            :spark:func:`regexp_extract`                     :spark:func:`first_ignore_null`
+    :spark:func:`array_compact`                  :spark:func:`expm1`                          :spark:func:`regexp_extract_all`                 :spark:func:`kurtosis`
+    :spark:func:`array_contains`                 :spark:func:`factorial`                      :spark:func:`regexp_replace`                     :spark:func:`last`
+    :spark:func:`array_distinct`                 :spark:func:`filter`                         :spark:func:`remainder`                          :spark:func:`last_ignore_null`
+    :spark:func:`array_except`                   :spark:func:`find_in_set`                    :spark:func:`repeat`                             :spark:func:`max`
+    :spark:func:`array_insert`                   :spark:func:`flatten`                        :spark:func:`replace`                            :spark:func:`max_by`
+    :spark:func:`array_intersect`                :spark:func:`floor`                          :spark:func:`reverse`                            :spark:func:`min`
+    :spark:func:`array_join`                     :spark:func:`forall`                         :spark:func:`rint`                               :spark:func:`min_by`
+    :spark:func:`array_max`                      :spark:func:`from_unixtime`                  :spark:func:`rlike`                              :spark:func:`mode`
+    :spark:func:`array_min`                      :spark:func:`from_utc_timestamp`             :spark:func:`round`                              :spark:func:`regr_replacement`
+    :spark:func:`array_position`                 :spark:func:`get`                            :spark:func:`rpad`                               :spark:func:`skewness`
+    :spark:func:`array_prepend`                  :spark:func:`get_json_object`                :spark:func:`rtrim`                              :spark:func:`stddev`
+    :spark:func:`array_remove`                   :spark:func:`get_timestamp`                  :spark:func:`sec`                                :spark:func:`stddev_samp`
+    :spark:func:`array_repeat`                   :spark:func:`greaterthan`                    :spark:func:`second`                             :spark:func:`sum`
+    :spark:func:`array_sort`                     :spark:func:`greaterthanorequal`             :spark:func:`sha1`                               :spark:func:`var_samp`
+    :spark:func:`array_union`                    :spark:func:`greatest`                       :spark:func:`sha2`                               :spark:func:`variance`
+    :spark:func:`arrays_zip`                     :spark:func:`hash`                           :spark:func:`shiftleft`
+    :spark:func:`ascii`                          :spark:func:`hash_with_seed`                 :spark:func:`shiftright`
+    :spark:func:`asin`                           :spark:func:`hex`                            :spark:func:`shuffle`
+    :spark:func:`asinh`                          :spark:func:`hour`                           :spark:func:`sign`
+    :spark:func:`atan`                           :spark:func:`hypot`                          :spark:func:`sinh`
+    :spark:func:`atan2`                          :spark:func:`in`                             :spark:func:`size`
+    :spark:func:`atanh`                          :spark:func:`instr`                          :spark:func:`slice`
+    :spark:func:`between`                        :spark:func:`isnan`                          :spark:func:`sort_array`
+    :spark:func:`bin`                            :spark:func:`isnotnull`                      :spark:func:`soundex`
+    :spark:func:`bit_count`                      :spark:func:`isnull`                         :spark:func:`spark_partition_id`
+    :spark:func:`bit_get`                        :spark:func:`json_array_length`              :spark:func:`split`
+    :spark:func:`bit_length`                     :spark:func:`json_object_keys`               :spark:func:`sqrt`
+    :spark:func:`bitwise_and`                    :spark:func:`last_day`                       :spark:func:`startswith`
+    :spark:func:`bitwise_not`                    :spark:func:`least`                          :spark:func:`str_to_map`
+    :spark:func:`bitwise_or`                     :spark:func:`left`                           :spark:func:`substring`
+    :spark:func:`bitwise_xor`                    :spark:func:`length`                         :spark:func:`substring_index`
+    :spark:func:`cbrt`                           :spark:func:`lessthan`                       :spark:func:`subtract`
+    :spark:func:`ceil`                           :spark:func:`lessthanorequal`                :spark:func:`subtract_deny_precision_loss`
+    :spark:func:`checked_add`                    :spark:func:`levenshtein`                    :spark:func:`timestamp_micros`
+    :spark:func:`checked_divide`                 :spark:func:`like`                           :spark:func:`timestamp_millis`
+    :spark:func:`checked_multiply`               :spark:func:`locate`                         :spark:func:`to_unix_timestamp`
+    :spark:func:`checked_subtract`               :spark:func:`log`                            :spark:func:`to_utc_timestamp`
+    :spark:func:`chr`                            :spark:func:`log10`                          :spark:func:`transform`
+    :spark:func:`concat`                         :spark:func:`log1p`                          :spark:func:`translate`
+    :spark:func:`contains`                       :spark:func:`log2`                           :spark:func:`trim`
+    :spark:func:`conv`                           :spark:func:`lower`                          :spark:func:`trunc`
+    :spark:func:`cos`                            :spark:func:`lpad`                           :spark:func:`unaryminus`
+    :spark:func:`cosh`                           :spark:func:`ltrim`                          :spark:func:`unbase64`
+    :spark:func:`cot`                            :spark:func:`luhn_check`                     :spark:func:`unhex`
+    :spark:func:`crc32`                          :spark:func:`make_date`                      :spark:func:`unix_date`
+    :spark:func:`csc`                            :spark:func:`make_timestamp`                 :spark:func:`unix_micros`
+    :spark:func:`date_add`                       :spark:func:`make_ym_interval`               :spark:func:`unix_millis`
+    :spark:func:`date_format`                    :spark:func:`map`                            :spark:func:`unix_seconds`
+    :spark:func:`date_from_unix_date`            :spark:func:`map_concat`                     :spark:func:`unix_timestamp`
+    :spark:func:`date_sub`                       :spark:func:`map_entries`                    :spark:func:`unscaled_value`
+    :spark:func:`date_trunc`                     :spark:func:`map_filter`                     :spark:func:`upper`
+    :spark:func:`datediff`                       :spark:func:`map_from_arrays`                :spark:func:`url_decode`
+    :spark:func:`day`                            :spark:func:`map_keys`                       :spark:func:`url_encode`
+    :spark:func:`dayofmonth`                     :spark:func:`map_values`                     :spark:func:`uuid`
+    :spark:func:`dayofweek`                      :spark:func:`map_zip_with`                   :spark:func:`varchar_type_write_side_check`
+    :spark:func:`dayofyear`                      :spark:func:`mask`                           :spark:func:`week_of_year`
+    :spark:func:`decimal_equalto`                :spark:func:`md5`                            :spark:func:`weekday`
+    :spark:func:`decimal_greaterthan`            :spark:func:`might_contain`                  :spark:func:`width_bucket`
+    :spark:func:`decimal_greaterthanorequal`     :spark:func:`minute`                         :spark:func:`xxhash64`
+    :spark:func:`decimal_lessthan`               :spark:func:`monotonically_increasing_id`    :spark:func:`xxhash64_with_seed`
+    :spark:func:`decimal_lessthanorequal`        :spark:func:`month`                          :spark:func:`year`
+    :spark:func:`decimal_notequalto`             :spark:func:`multiply`                       :spark:func:`year_of_week`
+    :spark:func:`degrees`                        :spark:func:`multiply_deny_precision_loss`   :spark:func:`zip_with`
+    :spark:func:`divide`                         :spark:func:`next_day`
+    ===========================================  ===========================================  ===========================================  ==  ===========================================  ==  ===========================================
diff --git a/velox/duckdb/conversion/CMakeLists.txt b/velox/duckdb/conversion/CMakeLists.txt
index 8361cb68e20f..010f13f8f358 100644
--- a/velox/duckdb/conversion/CMakeLists.txt
+++ b/velox/duckdb/conversion/CMakeLists.txt
@@ -13,13 +13,16 @@
 # limitations under the License.
 velox_add_library(velox_duckdb_conversion DuckConversion.cpp)
 
-velox_link_libraries(velox_duckdb_conversion velox_core velox_vector
-                     duckdb_static)
+velox_link_libraries(velox_duckdb_conversion velox_core velox_vector duckdb_static)
 
 velox_add_library(velox_duckdb_parser DuckParser.cpp)
 
-velox_link_libraries(velox_duckdb_parser velox_duckdb_conversion
-                     velox_parse_expression duckdb_static)
+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 912e0746243d..e1b23eda4e70 100644
--- a/velox/duckdb/conversion/DuckConversion.cpp
+++ b/velox/duckdb/conversion/DuckConversion.cpp
@@ -32,21 +32,21 @@ using ::duckdb::dtime_t;
 using ::duckdb::string_t;
 using ::duckdb::timestamp_t;
 
-variant decimalVariant(const Value& val) {
+Variant decimalVariant(const Value& val) {
   VELOX_DCHECK(val.type().id() == LogicalTypeId::DECIMAL);
   switch (val.type().InternalType()) {
     case ::duckdb::PhysicalType::INT128: {
       auto unscaledValue = val.GetValueUnsafe<::duckdb::hugeint_t>();
-      return variant(HugeInt::build(unscaledValue.upper, unscaledValue.lower));
+      return Variant(HugeInt::build(unscaledValue.upper, unscaledValue.lower));
     }
     case ::duckdb::PhysicalType::INT16: {
-      return variant(static_cast<int64_t>(val.GetValueUnsafe<int16_t>()));
+      return Variant(static_cast<int64_t>(val.GetValueUnsafe<int16_t>()));
     }
     case ::duckdb::PhysicalType::INT32: {
-      return variant(static_cast<int64_t>(val.GetValueUnsafe<int32_t>()));
+      return Variant(static_cast<int64_t>(val.GetValueUnsafe<int32_t>()));
     }
     case ::duckdb::PhysicalType::INT64: {
-      return variant(val.GetValueUnsafe<int64_t>());
+      return Variant(val.GetValueUnsafe<int64_t>());
     }
     default:
       VELOX_UNSUPPORTED();
@@ -192,6 +192,9 @@ TypePtr toVeloxType(LogicalType type, bool fileColumnNamesReadAsLowerCase) {
       if (auto customType = getCustomType(name, {})) {
         return customType;
       }
+      if (name == "OPAQUE<void>") {
+        return OPAQUE<void>();
+      }
       [[fallthrough]];
     }
     default:
@@ -201,37 +204,37 @@ TypePtr toVeloxType(LogicalType type, bool fileColumnNamesReadAsLowerCase) {
   }
 }
 
-variant duckValueToVariant(const Value& val) {
+Variant duckValueToVariant(const Value& val) {
   switch (val.type().id()) {
     case LogicalTypeId::SQLNULL:
-      return variant(TypeKind::UNKNOWN);
+      return Variant(TypeKind::UNKNOWN);
     case LogicalTypeId::BOOLEAN:
-      return variant(val.GetValue<bool>());
+      return Variant(val.GetValue<bool>());
     case LogicalTypeId::TINYINT:
-      return variant(val.GetValue<int8_t>());
+      return Variant(val.GetValue<int8_t>());
     case LogicalTypeId::SMALLINT:
-      return variant(val.GetValue<int16_t>());
+      return Variant(val.GetValue<int16_t>());
     case LogicalTypeId::INTEGER:
-      return variant(val.GetValue<int32_t>());
+      return Variant(val.GetValue<int32_t>());
     case LogicalTypeId::BIGINT:
-      return variant(val.GetValue<int64_t>());
+      return Variant(val.GetValue<int64_t>());
     case LogicalTypeId::FLOAT:
-      return variant(val.GetValue<float>());
+      return Variant(val.GetValue<float>());
     case LogicalTypeId::DOUBLE:
-      return variant(val.GetValue<double>());
+      return Variant(val.GetValue<double>());
     case LogicalTypeId::TIMESTAMP:
-      return variant(duckdbTimestampToVelox(val.GetValue<timestamp_t>()));
+      return Variant(duckdbTimestampToVelox(val.GetValue<timestamp_t>()));
     case LogicalTypeId::DECIMAL:
       return decimalVariant(val);
     case LogicalTypeId::VARCHAR:
-      return variant(val.GetValue<std::string>());
+      return Variant(val.GetValue<std::string>());
     case LogicalTypeId::BLOB:
-      return variant::binary(val.GetValue<std::string>());
+      return Variant::binary(val.GetValue<std::string>());
     case LogicalTypeId::DATE:
-      return variant(val.GetValue<::duckdb::date_t>().days);
+      return Variant(val.GetValue<::duckdb::date_t>().days);
     default:
       throw std::runtime_error(
-          "unsupported type for duckdb value -> velox  variant conversion: " +
+          "unsupported type for duckdb value -> velox variant conversion: " +
           val.type().ToString());
   }
 }
diff --git a/velox/duckdb/conversion/DuckConversion.h b/velox/duckdb/conversion/DuckConversion.h
index 9888a0cb66a8..c4ffa51ef776 100644
--- a/velox/duckdb/conversion/DuckConversion.h
+++ b/velox/duckdb/conversion/DuckConversion.h
@@ -20,7 +20,7 @@
 #include <duckdb.hpp> // @manual
 
 namespace facebook::velox {
-class variant;
+class Variant;
 }
 
 namespace facebook::velox::duckdb {
@@ -57,16 +57,16 @@ static Timestamp duckdbTimestampToVelox(
 }
 
 // Converts a duckDB Value (class that holds an arbitrary data type) into
-// Velox variant.
-variant duckValueToVariant(const ::duckdb::Value& val);
+// Velox Variant.
+Variant duckValueToVariant(const ::duckdb::Value& val);
 
-// Converts duckDB decimal Value into appropriate decimal variant.
+// Converts duckDB decimal Value into appropriate decimal Variant.
 // The duckdb::Value::GetValue() call for decimal type returns a double value.
 // To avoid this, this method uses the duckdb::Value::GetUnsafeValue<int>()
 // method.
 // @param val duckdb decimal value.
-// @return decimal variant.
-variant decimalVariant(const ::duckdb::Value& val);
+// @return decimal Variant.
+Variant decimalVariant(const ::duckdb::Value& val);
 
 // value conversion routines
 template <class T>
diff --git a/velox/duckdb/conversion/DuckParser.cpp b/velox/duckdb/conversion/DuckParser.cpp
index b5427b7f33fa..dcbbfcb48962 100644
--- a/velox/duckdb/conversion/DuckParser.cpp
+++ b/velox/duckdb/conversion/DuckParser.cpp
@@ -15,7 +15,6 @@
  */
 #include "velox/duckdb/conversion/DuckParser.h"
 #include "velox/common/base/Exceptions.h"
-#include "velox/core/PlanNode.h"
 #include "velox/duckdb/conversion/DuckConversion.h"
 #include "velox/parse/Expressions.h"
 #include "velox/type/Variant.h"
@@ -59,9 +58,7 @@ using ::duckdb::WindowExpression;
 
 namespace {
 
-std::shared_ptr<const core::IExpr> parseExpr(
-    ParsedExpression& expr,
-    const ParseOptions& options);
+core::ExprPtr parseExpr(ParsedExpression& expr, const ParseOptions& options);
 
 std::string normalizeFuncName(std::string input) {
   static std::map<std::string, std::string> kLookup{
@@ -133,7 +130,7 @@ std::optional<std::string> getAlias(const ParsedExpression& expr) {
 
 std::shared_ptr<const core::CallExpr> callExpr(
     std::string name,
-    std::vector<std::shared_ptr<const core::IExpr>> params,
+    std::vector<core::ExprPtr> params,
     std::optional<std::string> alias,
     const ParseOptions& options) {
   return std::make_shared<const core::CallExpr>(
@@ -144,10 +141,10 @@ std::shared_ptr<const core::CallExpr> callExpr(
 
 std::shared_ptr<const core::CallExpr> callExpr(
     std::string name,
-    const std::shared_ptr<const core::IExpr>& param,
+    const core::ExprPtr& param,
     std::optional<std::string> alias,
     const ParseOptions& options) {
-  std::vector<std::shared_ptr<const core::IExpr>> params = {param};
+  std::vector<core::ExprPtr> params = {param};
   return std::make_shared<const core::CallExpr>(
       toFullFunctionName(name, options.functionPrefix),
       std::move(params),
@@ -155,7 +152,7 @@ std::shared_ptr<const core::CallExpr> callExpr(
 }
 
 // Parse a constant (1, 99.8, "string", etc).
-std::shared_ptr<const core::IExpr> parseConstantExpr(
+core::ExprPtr parseConstantExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   auto& constantExpr = dynamic_cast<ConstantExpression&>(expr);
@@ -179,7 +176,7 @@ std::shared_ptr<const core::IExpr> parseConstantExpr(
 }
 
 // Parse a column reference (col1, "col2", tbl.col, etc).
-std::shared_ptr<const core::IExpr> parseColumnRefExpr(
+core::ExprPtr parseColumnRefExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& colRefExpr = dynamic_cast<ColumnRefExpression&>(expr);
@@ -190,9 +187,8 @@ std::shared_ptr<const core::IExpr> parseColumnRefExpr(
   return std::make_shared<const core::FieldAccessExpr>(
       colRefExpr.GetColumnName(),
       getAlias(expr),
-      std::vector<std::shared_ptr<const core::IExpr>>{
-          std::make_shared<const core::FieldAccessExpr>(
-              colRefExpr.GetTableName(), std::nullopt)});
+      std::vector<core::ExprPtr>{std::make_shared<const core::FieldAccessExpr>(
+          colRefExpr.GetTableName(), std::nullopt)});
 }
 
 namespace {
@@ -213,7 +209,7 @@ std::optional<int64_t> extractInteger(const core::ConstantExpr& constInput) {
 
 std::shared_ptr<const core::ConstantExpr> tryParseInterval(
     const std::string& functionName,
-    const std::shared_ptr<const core::IExpr>& input,
+    const core::ExprPtr& input,
     std::optional<std::string> alias) {
   std::optional<int64_t> value;
 
@@ -221,8 +217,8 @@ std::shared_ptr<const core::ConstantExpr> tryParseInterval(
     value = extractInteger(*constInput);
   } else if (
       auto castInput = dynamic_cast<const core::CastExpr*>(input.get())) {
-    if (auto constInput = dynamic_cast<const core::ConstantExpr*>(
-            castInput->getInput().get())) {
+    if (auto constInput =
+            dynamic_cast<const core::ConstantExpr*>(castInput->input().get())) {
       value = extractInteger(*constInput);
     }
   }
@@ -256,20 +252,20 @@ std::shared_ptr<const core::ConstantExpr> tryParseInterval(
     }
     return std::make_shared<core::ConstantExpr>(
         INTERVAL_YEAR_MONTH(),
-        variant((int32_t)(value.value() * multiplier)),
+        Variant((int32_t)(value.value() * multiplier)),
         alias);
   }
   return std::make_shared<core::ConstantExpr>(
-      INTERVAL_DAY_TIME(), variant(value.value() * multiplier), alias);
+      INTERVAL_DAY_TIME(), Variant(value.value() * multiplier), alias);
 }
 
 // Parse a function call (avg(a), func(1, b), etc).
 // Arithmetic operators also follow this path (a + b, a * b, etc).
-std::shared_ptr<const core::IExpr> parseFunctionExpr(
+core::ExprPtr parseFunctionExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& functionExpr = dynamic_cast<FunctionExpression&>(expr);
-  std::vector<std::shared_ptr<const core::IExpr>> params;
+  std::vector<core::ExprPtr> params;
   params.reserve(functionExpr.children.size());
 
   for (const auto& c : functionExpr.children) {
@@ -295,11 +291,11 @@ std::shared_ptr<const core::IExpr> parseFunctionExpr(
 }
 
 // Parse a comparison (a > b, a = b, etc).
-std::shared_ptr<const core::IExpr> parseComparisonExpr(
+core::ExprPtr parseComparisonExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& compExpr = dynamic_cast<ComparisonExpression&>(expr);
-  std::vector<std::shared_ptr<const core::IExpr>> params{
+  std::vector<core::ExprPtr> params{
       parseExpr(*compExpr.left, options), parseExpr(*compExpr.right, options)};
   return callExpr(
       normalizeFuncName(ExpressionTypeToOperator(expr.GetExpressionType())),
@@ -309,7 +305,7 @@ std::shared_ptr<const core::IExpr> parseComparisonExpr(
 }
 
 // Parse x between lower and upper
-std::shared_ptr<const core::IExpr> parseBetweenExpr(
+core::ExprPtr parseBetweenExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& betweenExpr = dynamic_cast<BetweenExpression&>(expr);
@@ -323,7 +319,7 @@ std::shared_ptr<const core::IExpr> parseBetweenExpr(
 }
 
 // Parse a conjunction (AND or OR).
-std::shared_ptr<const core::IExpr> parseConjunctionExpr(
+core::ExprPtr parseConjunctionExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& conjExpr = dynamic_cast<ConjunctionExpression&>(expr);
@@ -331,19 +327,20 @@ std::shared_ptr<const core::IExpr> parseConjunctionExpr(
       StringUtil::Lower(ExpressionTypeToOperator(expr.GetExpressionType()));
 
   if (conjExpr.children.size() < 2) {
-    throw std::invalid_argument(folly::sformat(
-        "Malformed conjunction expression "
-        "(expected at least 2 input columns, got {}).",
-        conjExpr.children.size()));
+    throw std::invalid_argument(
+        folly::sformat(
+            "Malformed conjunction expression "
+            "(expected at least 2 input columns, got {}).",
+            conjExpr.children.size()));
   }
 
   // DuckDB's parser returns conjunction involving multiple input in a flat
   // expression, in the form `AND(a, b, d, e)`, but internally we expect
   // conjunctions to have exactly 2 input. This code converts that input into
   // `AND(AND(AND(a, b), d), e)` (so it's executed in the same order).
-  std::shared_ptr<const core::IExpr> current;
+  core::ExprPtr current;
   for (size_t i = 1; i < conjExpr.children.size(); ++i) {
-    std::vector<std::shared_ptr<const core::IExpr>> params;
+    std::vector<core::ExprPtr> params;
     params.reserve(2);
 
     if (current == nullptr) {
@@ -368,7 +365,7 @@ static bool areAllChildrenConstant(const OperatorExpression& operExpr) {
 }
 
 // Parse an "operator", like NOT.
-std::shared_ptr<const core::IExpr> parseOperatorExpr(
+core::ExprPtr parseOperatorExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& operExpr = dynamic_cast<OperatorExpression&>(expr);
@@ -376,7 +373,7 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
   // Code for array literal parsing (e.g. "ARRAY[1, 2, 3]")
   if (expr.GetExpressionType() == ExpressionType::ARRAY_CONSTRUCTOR) {
     if (areAllChildrenConstant(operExpr)) {
-      std::vector<variant> arrayElements;
+      std::vector<Variant> arrayElements;
       arrayElements.reserve(operExpr.children.size());
 
       TypePtr valueType = UNKNOWN();
@@ -397,9 +394,9 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
         }
       }
       return std::make_shared<const core::ConstantExpr>(
-          ARRAY(valueType), variant::array(arrayElements), getAlias(expr));
+          ARRAY(valueType), Variant::array(arrayElements), getAlias(expr));
     } else {
-      std::vector<std::shared_ptr<const core::IExpr>> params;
+      std::vector<core::ExprPtr> params;
       params.reserve(operExpr.children.size());
 
       for (const auto& child : operExpr.children) {
@@ -415,8 +412,16 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
       expr.GetExpressionType() == ExpressionType::COMPARE_NOT_IN) {
     auto numValues = operExpr.children.size() - 1;
 
-    std::vector<variant> values;
-    values.reserve(numValues);
+    std::vector<Variant> values;
+    if (options.parseInListAsArray) {
+      values.reserve(numValues);
+    }
+
+    std::vector<core::ExprPtr> params;
+    if (!options.parseInListAsArray) {
+      params.reserve(numValues + 1);
+    }
+    params.emplace_back(parseExpr(*operExpr.children[0], options));
 
     TypePtr valueType = UNKNOWN();
     for (auto i = 0; i < numValues; i++) {
@@ -428,21 +433,29 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
               dynamic_cast<ConstantExpression*>(castExpr->child.get());
           auto value = constExpr->value.DefaultCastAs(
               castExpr->cast_type, !castExpr->try_cast);
-          values.emplace_back(duckValueToVariant(value));
-          valueType = toVeloxType(castExpr->cast_type);
+          if (options.parseInListAsArray) {
+            values.emplace_back(duckValueToVariant(value));
+            valueType = toVeloxType(castExpr->cast_type);
+          } else {
+            params.emplace_back(parseExpr(*castExpr->child, options));
+          }
           continue;
         }
       }
 
       if (auto constantExpr = dynamic_cast<ConstantExpression*>(valueExpr)) {
-        auto& value = constantExpr->value;
-        if (options.parseDecimalAsDouble &&
-            value.type().id() == duckdb::LogicalTypeId::DECIMAL) {
-          value = Value::DOUBLE(value.GetValue<double>());
-        }
-        values.emplace_back(duckValueToVariant(value));
-        if (!value.IsNull()) {
-          valueType = toVeloxType(value.type());
+        if (options.parseInListAsArray) {
+          auto& value = constantExpr->value;
+          if (options.parseDecimalAsDouble &&
+              value.type().id() == duckdb::LogicalTypeId::DECIMAL) {
+            value = Value::DOUBLE(value.GetValue<double>());
+          }
+          values.emplace_back(duckValueToVariant(value));
+          if (!value.IsNull()) {
+            valueType = toVeloxType(value.type());
+          }
+        } else {
+          params.emplace_back(parseExpr(*constantExpr, options));
         }
         continue;
       }
@@ -450,10 +463,11 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
       VELOX_UNSUPPORTED("IN list values need to be constant");
     }
 
-    std::vector<std::shared_ptr<const core::IExpr>> params;
-    params.emplace_back(parseExpr(*operExpr.children[0], options));
-    params.emplace_back(std::make_shared<const core::ConstantExpr>(
-        ARRAY(valueType), variant::array(values), std::nullopt));
+    if (options.parseInListAsArray) {
+      params.emplace_back(
+          std::make_shared<const core::ConstantExpr>(
+              ARRAY(valueType), Variant::array(values), std::nullopt));
+    }
     auto inExpr = callExpr("in", std::move(params), getAlias(expr), options);
     // Translate COMPARE_NOT_IN into NOT(IN()).
     return (expr.GetExpressionType() == ExpressionType::COMPARE_IN)
@@ -461,7 +475,7 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
         : callExpr("not", inExpr, std::nullopt, options);
   }
 
-  std::vector<std::shared_ptr<const core::IExpr>> params;
+  std::vector<core::ExprPtr> params;
   params.reserve(operExpr.children.size());
 
   for (const auto& child : operExpr.children) {
@@ -472,7 +486,7 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
   // (a).b.c, (a.b).c
   if (expr.GetExpressionType() == ExpressionType::STRUCT_EXTRACT) {
     VELOX_CHECK_EQ(params.size(), 2);
-    std::vector<std::shared_ptr<const core::IExpr>> input = {params[0]};
+    std::vector<core::ExprPtr> input = {params[0]};
 
     if (auto constantExpr =
             std::dynamic_pointer_cast<const core::ConstantExpr>(params[1])) {
@@ -501,7 +515,7 @@ std::shared_ptr<const core::IExpr> parseOperatorExpr(
 }
 
 namespace {
-bool isNullConstant(const std::shared_ptr<const core::IExpr>& expr) {
+bool isNullConstant(const core::ExprPtr& expr) {
   if (auto constExpr =
           std::dynamic_pointer_cast<const core::ConstantExpr>(expr)) {
     return constExpr->value().isNull();
@@ -512,7 +526,7 @@ bool isNullConstant(const std::shared_ptr<const core::IExpr>& expr) {
 } // namespace
 
 // Parse an IF()/CASE expression.
-std::shared_ptr<const core::IExpr> parseCaseExpr(
+core::ExprPtr parseCaseExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& caseExpr = dynamic_cast<CaseExpression&>(expr);
@@ -521,7 +535,7 @@ std::shared_ptr<const core::IExpr> parseCaseExpr(
   if (checks.size() == 1) {
     const auto& check = checks.front();
 
-    std::vector<std::shared_ptr<const core::IExpr>> params{
+    std::vector<core::ExprPtr> params{
         parseExpr(*check.when_expr, options),
         parseExpr(*check.then_expr, options),
         parseExpr(*caseExpr.else_expr, options),
@@ -529,7 +543,7 @@ std::shared_ptr<const core::IExpr> parseCaseExpr(
     return callExpr("if", std::move(params), getAlias(expr), options);
   }
 
-  std::vector<std::shared_ptr<const core::IExpr>> inputs;
+  std::vector<core::ExprPtr> inputs;
   inputs.reserve(checks.size() * 2 + 1);
   for (auto& check : checks) {
     inputs.emplace_back(parseExpr(*check.when_expr, options));
@@ -545,12 +559,11 @@ std::shared_ptr<const core::IExpr> parseCaseExpr(
 }
 
 // Parse an CAST expression.
-std::shared_ptr<const core::IExpr> parseCastExpr(
+core::ExprPtr parseCastExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& castExpr = dynamic_cast<CastExpression&>(expr);
-  std::vector<std::shared_ptr<const core::IExpr>> params{
-      parseExpr(*castExpr.child, options)};
+  std::vector<core::ExprPtr> params{parseExpr(*castExpr.child, options)};
   // We may need to expand toVeloxType in the future to support
   // Map and Array and Struct properly.
   auto targetType = toVeloxType(castExpr.cast_type);
@@ -561,7 +574,7 @@ std::shared_ptr<const core::IExpr> parseCastExpr(
           dynamic_cast<const core::ConstantExpr*>(params[0].get())) {
     if (constant->value().isNull()) {
       return std::make_shared<const core::ConstantExpr>(
-          targetType, variant::null(targetType->kind()), getAlias(expr));
+          targetType, Variant::null(targetType->kind()), getAlias(expr));
     }
 
     // DuckDB parses BOOLEAN literal as cast expression.  Try to restore it back
@@ -573,25 +586,25 @@ std::shared_ptr<const core::IExpr> parseCastExpr(
       if (s == "t") {
         return std::make_shared<const core::ConstantExpr>(
             BOOLEAN(),
-            variant::create<TypeKind::BOOLEAN>(true),
+            Variant::create<TypeKind::BOOLEAN>(true),
             getAlias(expr));
       }
 
       if (s == "f") {
         return std::make_shared<const core::ConstantExpr>(
             BOOLEAN(),
-            variant::create<TypeKind::BOOLEAN>(false),
+            Variant::create<TypeKind::BOOLEAN>(false),
             getAlias(expr));
       }
     }
   }
 
-  const bool nullOnFailure = castExpr.try_cast;
+  const bool isTryCast = castExpr.try_cast;
   return std::make_shared<const core::CastExpr>(
-      targetType, params[0], nullOnFailure, getAlias(expr));
+      targetType, params[0], isTryCast, getAlias(expr));
 }
 
-std::shared_ptr<const core::IExpr> parseLambdaExpr(
+core::ExprPtr parseLambdaExpr(
     ParsedExpression& expr,
     const ParseOptions& options) {
   const auto& lambdaExpr = dynamic_cast<::duckdb::LambdaExpression&>(expr);
@@ -604,18 +617,17 @@ std::shared_ptr<const core::IExpr> parseLambdaExpr(
   std::vector<std::string> names;
   if (auto fieldExpr =
           std::dynamic_pointer_cast<const core::FieldAccessExpr>(capture)) {
-    names.push_back(fieldExpr->getFieldName());
+    names.push_back(fieldExpr->name());
   } else if (
       auto callExpr =
           std::dynamic_pointer_cast<const core::CallExpr>(capture)) {
     VELOX_CHECK_EQ(
-        toFullFunctionName("row", options.functionPrefix),
-        callExpr->getFunctionName());
-    for (auto& input : callExpr->getInputs()) {
+        toFullFunctionName("row", options.functionPrefix), callExpr->name());
+    for (auto& input : callExpr->inputs()) {
       auto fieldExpr =
           std::dynamic_pointer_cast<const core::FieldAccessExpr>(input);
       VELOX_CHECK_NOT_NULL(fieldExpr);
-      names.push_back(fieldExpr->getFieldName());
+      names.push_back(fieldExpr->name());
     }
   } else {
     VELOX_FAIL(
@@ -627,9 +639,7 @@ std::shared_ptr<const core::IExpr> parseLambdaExpr(
       std::move(names), std::move(body));
 }
 
-std::shared_ptr<const core::IExpr> parseExpr(
-    ParsedExpression& expr,
-    const ParseOptions& options) {
+core::ExprPtr parseExpr(ParsedExpression& expr, const ParseOptions& options) {
   switch (expr.GetExpressionClass()) {
     case ExpressionClass::CONSTANT:
       return parseConstantExpr(expr, options);
@@ -689,19 +699,19 @@ std::unique_ptr<::duckdb::ParsedExpression> parseSingleExpression(
 }
 } // namespace
 
-std::shared_ptr<const core::IExpr> parseExpr(
+core::ExprPtr parseExpr(
     const std::string& exprString,
     const ParseOptions& options) {
   auto parsed = parseSingleExpression(exprString);
   return parseExpr(*parsed, options);
 }
 
-std::vector<std::shared_ptr<const core::IExpr>> parseMultipleExpressions(
+std::vector<core::ExprPtr> parseMultipleExpressions(
     const std::string& exprString,
     const ParseOptions& options) {
   auto parsedExpressions = parseExpression(exprString);
   VELOX_CHECK_GT(parsedExpressions.size(), 0);
-  std::vector<std::shared_ptr<const core::IExpr>> exprs;
+  std::vector<core::ExprPtr> exprs;
   exprs.reserve(parsedExpressions.size());
   for (const auto& parsedExpr : parsedExpressions) {
     exprs.push_back(parseExpr(*parsedExpr, options));
@@ -745,8 +755,7 @@ bool isNullsFirst(
 }
 } // namespace
 
-std::pair<std::shared_ptr<const core::IExpr>, core::SortOrder> parseOrderByExpr(
-    const std::string& exprString) {
+OrderByClause parseOrderByExpr(const std::string& exprString) {
   ParserOptions options;
   ParseOptions parseOptions;
   options.preserve_identifier_case = false;
@@ -763,8 +772,9 @@ std::pair<std::shared_ptr<const core::IExpr>, core::SortOrder> parseOrderByExpr(
   const bool nullsFirst = isNullsFirst(orderByNode.null_order, exprString);
 
   return {
-      parseExpr(*orderByNode.expression, parseOptions),
-      core::SortOrder(ascending, nullsFirst)};
+      .expr = parseExpr(*orderByNode.expression, parseOptions),
+      .ascending = ascending,
+      .nullsFirst = nullsFirst};
 }
 
 AggregateExpr parseAggregateExpr(
@@ -783,8 +793,10 @@ AggregateExpr parseAggregateExpr(
       const bool ascending = isAscending(orderByNode.type, exprString);
       const bool nullsFirst = isNullsFirst(orderByNode.null_order, exprString);
       aggregateExpr.orderBy.emplace_back(
-          parseExpr(*orderByNode.expression, options),
-          core::SortOrder(ascending, nullsFirst));
+          OrderByClause{
+              parseExpr(*orderByNode.expression, options),
+              ascending,
+              nullsFirst});
     }
   }
 
@@ -856,11 +868,13 @@ IExprWindowFunction parseWindowExpr(
     const bool ascending = isAscending(orderByNode.type, windowString);
     const bool nullsFirst = isNullsFirst(orderByNode.null_order, windowString);
     windowIExpr.orderBy.emplace_back(
-        parseExpr(*orderByNode.expression, options),
-        core::SortOrder(ascending, nullsFirst));
+        OrderByClause{
+            parseExpr(*orderByNode.expression, options),
+            ascending,
+            nullsFirst});
   }
 
-  std::vector<std::shared_ptr<const core::IExpr>> params;
+  std::vector<core::ExprPtr> params;
   params.reserve(windowExpr.children.size());
   for (const auto& c : windowExpr.children) {
     params.emplace_back(parseExpr(*c, options));
@@ -894,4 +908,12 @@ IExprWindowFunction parseWindowExpr(
   return windowIExpr;
 }
 
+std::string OrderByClause::toString() const {
+  return fmt::format(
+      "{} {} NULLS {}",
+      expr->toString(),
+      (ascending ? "ASC" : "DESC"),
+      (nullsFirst ? "FIRST" : "LAST"));
+}
+
 } // namespace facebook::velox::duckdb
diff --git a/velox/duckdb/conversion/DuckParser.h b/velox/duckdb/conversion/DuckParser.h
index 05d5d5a91bae..413e9280561a 100644
--- a/velox/duckdb/conversion/DuckParser.h
+++ b/velox/duckdb/conversion/DuckParser.h
@@ -15,21 +15,27 @@
  */
 #pragma once
 
-#include <memory>
 #include <string>
-#include <vector>
-
-namespace facebook::velox::core {
-class IExpr;
-class SortOrder;
-} // namespace facebook::velox::core
+#include "velox/parse/IExpr.h"
 
 namespace facebook::velox::duckdb {
+
+struct OrderByClause {
+  core::ExprPtr expr;
+  bool ascending;
+  bool nullsFirst;
+
+  std::string toString() const;
+};
+
 /// Hold parsing options.
 struct ParseOptions {
   // Retain legacy behavior by default.
   bool parseDecimalAsDouble = true;
   bool parseIntegerAsBigint = true;
+  // Whether to parse the values in an IN list as separate arguments or as a
+  // single array argument.
+  bool parseInListAsArray = true;
 
   /// SQL functions could be registered with different prefixes by the user.
   /// This parameter is the registered prefix of presto or spark functions,
@@ -44,20 +50,19 @@ struct ParseOptions {
 // are lower-cased, what prevents you to use functions and column names
 // containing upper case letters (e.g: "concatRow" will be parsed as
 // "concatrow").
-std::shared_ptr<const core::IExpr> parseExpr(
+core::ExprPtr parseExpr(
     const std::string& exprString,
     const ParseOptions& options);
 
-std::vector<std::shared_ptr<const core::IExpr>> parseMultipleExpressions(
+std::vector<core::ExprPtr> parseMultipleExpressions(
     const std::string& exprString,
     const ParseOptions& options);
 
 struct AggregateExpr {
-  std::shared_ptr<const core::IExpr> expr;
-  std::vector<std::pair<std::shared_ptr<const core::IExpr>, core::SortOrder>>
-      orderBy;
+  core::ExprPtr expr;
+  std::vector<OrderByClause> orderBy;
   bool distinct{false};
-  std::shared_ptr<const core::IExpr> maskExpr{nullptr};
+  core::ExprPtr maskExpr{nullptr};
 };
 
 /// Parses aggregate function call expression with optional ORDER by clause.
@@ -69,11 +74,9 @@ AggregateExpr parseAggregateExpr(
     const std::string& exprString,
     const ParseOptions& options);
 
-// Parses an ORDER BY clause using DuckDB's internal postgresql-based parser,
-// converting it to a pair of an IExpr tree and a core::SortOrder. Uses ASC
-// NULLS LAST as the default sort order.
-std::pair<std::shared_ptr<const core::IExpr>, core::SortOrder> parseOrderByExpr(
-    const std::string& exprString);
+// Parses an ORDER BY clause using DuckDB's internal postgresql-based parser.
+// Uses ASC NULLS LAST as the default sort order.
+OrderByClause parseOrderByExpr(const std::string& exprString);
 
 // Parses a WINDOW function SQL string using DuckDB's internal postgresql-based
 // parser. Window Functions are executed by Velox Window PlanNodes and not the
@@ -93,19 +96,18 @@ enum class BoundType {
 struct IExprWindowFrame {
   WindowType type;
   BoundType startType;
-  std::shared_ptr<const core::IExpr> startValue;
+  core::ExprPtr startValue;
   BoundType endType;
-  std::shared_ptr<const core::IExpr> endValue;
+  core::ExprPtr endValue;
 };
 
 struct IExprWindowFunction {
-  std::shared_ptr<const core::IExpr> functionCall;
+  core::ExprPtr functionCall;
   IExprWindowFrame frame;
   bool ignoreNulls;
 
-  std::vector<std::shared_ptr<const core::IExpr>> partitionBy;
-  std::vector<std::pair<std::shared_ptr<const core::IExpr>, core::SortOrder>>
-      orderBy;
+  std::vector<core::ExprPtr> partitionBy;
+  std::vector<OrderByClause> orderBy;
 };
 
 IExprWindowFunction parseWindowExpr(
diff --git a/velox/duckdb/conversion/tests/CMakeLists.txt b/velox/duckdb/conversion/tests/CMakeLists.txt
index 3a4607dd8a89..afe10aa20fa5 100644
--- a/velox/duckdb/conversion/tests/CMakeLists.txt
+++ b/velox/duckdb/conversion/tests/CMakeLists.txt
@@ -12,18 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_duckdb_conversion_test DuckConversionTest.cpp
-                                            DuckParserTest.cpp)
+add_executable(velox_duckdb_conversion_test DuckConversionTest.cpp DuckParserTest.cpp)
 
 add_test(velox_duckdb_conversion_test velox_duckdb_conversion_test)
 
 target_link_libraries(
   velox_duckdb_conversion_test
   velox_duckdb_parser
+  velox_common_base
   velox_parse_expression
   velox_functions_prestosql
   velox_functions_lib
   velox_functions_test_lib
   GTest::gtest
   GTest::gtest_main
-  gflags::gflags)
+  gflags::gflags
+)
diff --git a/velox/duckdb/conversion/tests/DuckParserTest.cpp b/velox/duckdb/conversion/tests/DuckParserTest.cpp
index 85fb67cbb219..f4b4044e016a 100644
--- a/velox/duckdb/conversion/tests/DuckParserTest.cpp
+++ b/velox/duckdb/conversion/tests/DuckParserTest.cpp
@@ -43,8 +43,8 @@ TEST(DuckParserTest, constants) {
   EXPECT_EQ("-303.1234", parseExpr("-303.1234")->toString());
 
   // Strings.
-  EXPECT_EQ("\"\"", parseExpr("''")->toString());
-  EXPECT_EQ("\"hello world\"", parseExpr("'hello world'")->toString());
+  EXPECT_EQ("", parseExpr("''")->toString());
+  EXPECT_EQ("hello world", parseExpr("'hello world'")->toString());
 
   // Nulls
   EXPECT_EQ("null", parseExpr("NULL")->toString());
@@ -57,16 +57,15 @@ TEST(DuckParserTest, constants) {
 
 TEST(DuckParserTest, arrays) {
   // Literal arrays with different types.
-  EXPECT_EQ("[1,2,-33]", parseExpr("ARRAY[1, 2, -33]")->toString());
+  EXPECT_EQ("{1, 2, -33}", parseExpr("ARRAY[1, 2, -33]")->toString());
   EXPECT_EQ(
-      "[1.99,-8.3,0.878]", parseExpr("ARRAY[1.99, -8.3, 0.878]")->toString());
+      "{1.99, -8.3, 0.878}", parseExpr("ARRAY[1.99, -8.3, 0.878]")->toString());
   EXPECT_EQ(
-      "[\"asd\",\"qwe\",\"ewqq\"]",
-      parseExpr("ARRAY['asd', 'qwe', 'ewqq']")->toString());
-  EXPECT_EQ("[null,1]", parseExpr("ARRAY[NULL, 1]")->toString());
+      "{asd, qwe, ewqq}", parseExpr("ARRAY['asd', 'qwe', 'ewqq']")->toString());
+  EXPECT_EQ("{null, 1}", parseExpr("ARRAY[NULL, 1]")->toString());
 
   // Empty array.
-  EXPECT_EQ("[]", parseExpr("ARRAY[]")->toString());
+  EXPECT_EQ("<empty>", parseExpr("ARRAY[]")->toString());
 
   // Expressions with variables and without.
   EXPECT_EQ(
@@ -92,8 +91,7 @@ TEST(DuckParserTest, variables) {
 
 TEST(DuckParserTest, functions) {
   EXPECT_EQ("avg(\"col1\")", parseExpr("avg(col1)")->toString());
-  EXPECT_EQ(
-      "func(1,3.4,\"str\")", parseExpr("func(1, 3.4, 'str')")->toString());
+  EXPECT_EQ("func(1,3.4,str)", parseExpr("func(1, 3.4, 'str')")->toString());
 
   // Nested calls.
   EXPECT_EQ(
@@ -101,10 +99,7 @@ TEST(DuckParserTest, functions) {
 }
 
 namespace {
-std::string toString(
-    const std::vector<
-        std::pair<std::shared_ptr<const core::IExpr>, core::SortOrder>>&
-        orderBy) {
+std::string toString(const std::vector<OrderByClause>& orderBy) {
   std::stringstream out;
   if (!orderBy.empty()) {
     out << "ORDER BY ";
@@ -112,8 +107,7 @@ std::string toString(
       if (i > 0) {
         out << ", ";
       }
-      out << orderBy[i].first->toString() << " "
-          << orderBy[i].second.toString();
+      out << orderBy[i].toString();
     }
   }
 
@@ -176,11 +170,10 @@ TEST(DuckParserTest, subscript) {
       "subscript(\"col\",plus(10,99))", parseExpr("col[10 + 99]")->toString());
   EXPECT_EQ("subscript(\"m1\",34)", parseExpr("m1[34]")->toString());
   EXPECT_EQ(
-      "subscript(\"m2\",\"key str\")", parseExpr("m2['key str']")->toString());
+      "subscript(\"m2\",key str)", parseExpr("m2['key str']")->toString());
 
   EXPECT_EQ(
-      "subscript(func(),\"key str\")",
-      parseExpr("func()['key str']")->toString());
+      "subscript(func(),key str)", parseExpr("func()['key str']")->toString());
 }
 
 TEST(DuckParserTest, coalesce) {
@@ -191,52 +184,105 @@ TEST(DuckParserTest, coalesce) {
 }
 
 TEST(DuckParserTest, in) {
-  EXPECT_EQ("in(\"col1\",[1,2,3])", parseExpr("col1 in (1, 2, 3)")->toString());
   EXPECT_EQ(
-      "in(\"col1\",[1,2,null,3])",
+      "in(\"col1\",{1, 2, 3})", parseExpr("col1 in (1, 2, 3)")->toString());
+  EXPECT_EQ(
+      "in(\"col1\",{1, 2, null, 3})",
       parseExpr("col1 in (1, 2, null, 3)")->toString());
   EXPECT_EQ(
-      "in(\"col1\",[\"a\",\"b\",\"c\"])",
+      "in(\"col1\",{a, b, c})",
       parseExpr("col1 in ('a', 'b', 'c')")->toString());
   EXPECT_EQ(
-      "in(\"col1\",[\"a\",null,\"b\",\"c\"])",
+      "in(\"col1\",{a, null, b, c})",
       parseExpr("col1 in ('a', null, 'b', 'c')")->toString());
 }
 
-TEST(DuckParserTest, notin) {
+TEST(DuckParserTest, inListAsArray) {
+  ParseOptions parseOptions{.parseInListAsArray = false, .functionPrefix = ""};
+  EXPECT_EQ(
+      "in(\"col1\",1,2,3)",
+      parseExpr("col1 in (1, 2, 3)", parseOptions)->toString());
+  EXPECT_EQ(
+      "in(\"col1\",1,2,null,3)",
+      parseExpr("col1 in (1, 2, null, 3)", parseOptions)->toString());
+  EXPECT_EQ(
+      "in(\"col1\",a,b,c)",
+      parseExpr("col1 in ('a', 'b', 'c')", parseOptions)->toString());
+  EXPECT_EQ(
+      "in(\"col1\",a,null,b,c)",
+      parseExpr("col1 in ('a', null, 'b', 'c')", parseOptions)->toString());
+}
+
+TEST(DuckParserTest, notIn) {
   EXPECT_EQ(
-      "not(in(\"col1\",[1,2,3]))",
+      "not(in(\"col1\",{1, 2, 3}))",
       parseExpr("col1 not in (1, 2, 3)")->toString());
 
   EXPECT_EQ(
-      "not(in(\"col1\",[1,2,3]))",
+      "not(in(\"col1\",{1, 2, 3}))",
       parseExpr("not(col1 in (1, 2, 3))")->toString());
 
   EXPECT_EQ(
-      "not(in(\"col1\",[1,2,null,3]))",
+      "not(in(\"col1\",{1, 2, null, 3}))",
       parseExpr("col1 not in (1, 2, null, 3)")->toString());
 
   EXPECT_EQ(
-      "not(in(\"col1\",[1,2,null,3]))",
+      "not(in(\"col1\",{1, 2, null, 3}))",
       parseExpr("not(col1 in (1, 2, null, 3))")->toString());
 
   EXPECT_EQ(
-      "not(in(\"col1\",[\"a\",\"b\",\"c\"]))",
+      "not(in(\"col1\",{a, b, c}))",
       parseExpr("col1 not in ('a', 'b', 'c')")->toString());
 
   EXPECT_EQ(
-      "not(in(\"col1\",[\"a\",\"b\",\"c\"]))",
+      "not(in(\"col1\",{a, b, c}))",
       parseExpr("not(col1 in ('a', 'b', 'c'))")->toString());
 
   EXPECT_EQ(
-      "not(in(\"col1\",[\"a\",null,\"b\",\"c\"]))",
+      "not(in(\"col1\",{a, null, b, c}))",
       parseExpr("col1 not in ('a', null, 'b', 'c')")->toString());
 
   EXPECT_EQ(
-      "not(in(\"col1\",[\"a\",null,\"b\",\"c\"]))",
+      "not(in(\"col1\",{a, null, b, c}))",
       parseExpr("not(col1 in ('a', null, 'b', 'c'))")->toString());
 }
 
+TEST(DuckParserTest, notInListAsArray) {
+  ParseOptions parseOptions{.parseInListAsArray = false, .functionPrefix = ""};
+  EXPECT_EQ(
+      "not(in(\"col1\",1,2,3))",
+      parseExpr("col1 not in (1, 2, 3)", parseOptions)->toString());
+
+  EXPECT_EQ(
+      "not(in(\"col1\",1,2,3))",
+      parseExpr("not(col1 in (1, 2, 3))", parseOptions)->toString());
+
+  EXPECT_EQ(
+      "not(in(\"col1\",1,2,null,3))",
+      parseExpr("col1 not in (1, 2, null, 3)", parseOptions)->toString());
+
+  EXPECT_EQ(
+      "not(in(\"col1\",1,2,null,3))",
+      parseExpr("not(col1 in (1, 2, null, 3))", parseOptions)->toString());
+
+  EXPECT_EQ(
+      "not(in(\"col1\",a,b,c))",
+      parseExpr("col1 not in ('a', 'b', 'c')", parseOptions)->toString());
+
+  EXPECT_EQ(
+      "not(in(\"col1\",a,b,c))",
+      parseExpr("not(col1 in ('a', 'b', 'c'))", parseOptions)->toString());
+
+  EXPECT_EQ(
+      "not(in(\"col1\",a,null,b,c))",
+      parseExpr("col1 not in ('a', null, 'b', 'c')", parseOptions)->toString());
+
+  EXPECT_EQ(
+      "not(in(\"col1\",a,null,b,c))",
+      parseExpr("not(col1 in ('a', null, 'b', 'c'))", parseOptions)
+          ->toString());
+}
+
 TEST(DuckParserTest, expressions) {
   // Comparisons.
   EXPECT_EQ("eq(1,0)", parseExpr("1 = 0")->toString());
@@ -338,36 +384,34 @@ TEST(DuckParserTest, intervalYearMonth) {
 }
 
 TEST(DuckParserTest, cast) {
+  EXPECT_EQ("cast(1 as BIGINT)", parseExpr("cast('1' as bigint)")->toString());
   EXPECT_EQ(
-      "cast(\"1\", BIGINT)", parseExpr("cast('1' as bigint)")->toString());
+      "cast(0.99 as INTEGER)", parseExpr("cast(0.99 as integer)")->toString());
   EXPECT_EQ(
-      "cast(0.99, INTEGER)", parseExpr("cast(0.99 as integer)")->toString());
+      "cast(0.99 as SMALLINT)",
+      parseExpr("cast(0.99 as smallint)")->toString());
   EXPECT_EQ(
-      "cast(0.99, SMALLINT)", parseExpr("cast(0.99 as smallint)")->toString());
+      "cast(0.99 as TINYINT)", parseExpr("cast(0.99 as tinyint)")->toString());
+  EXPECT_EQ("cast(1 as DOUBLE)", parseExpr("cast(1 as double)")->toString());
   EXPECT_EQ(
-      "cast(0.99, TINYINT)", parseExpr("cast(0.99 as tinyint)")->toString());
-  EXPECT_EQ("cast(1, DOUBLE)", parseExpr("cast(1 as double)")->toString());
+      "cast(\"col1\" as REAL)", parseExpr("cast(col1 as real)")->toString());
   EXPECT_EQ(
-      "cast(\"col1\", REAL)", parseExpr("cast(col1 as real)")->toString());
+      "cast(\"col1\" as REAL)", parseExpr("cast(col1 as float)")->toString());
   EXPECT_EQ(
-      "cast(\"col1\", REAL)", parseExpr("cast(col1 as float)")->toString());
+      "cast(0.99 as VARCHAR)", parseExpr("cast(0.99 as string)")->toString());
   EXPECT_EQ(
-      "cast(0.99, VARCHAR)", parseExpr("cast(0.99 as string)")->toString());
+      "cast(0.99 as VARCHAR)", parseExpr("cast(0.99 as varchar)")->toString());
+  EXPECT_EQ("abc", parseExpr("cast('abc' as varbinary)")->toString());
   EXPECT_EQ(
-      "cast(0.99, VARCHAR)", parseExpr("cast(0.99 as varchar)")->toString());
-  // Cast varchar to varbinary produces a varbinary value which is serialized
-  // using base64 encoding.
-  EXPECT_EQ("\"YWJj\"", parseExpr("cast('abc' as varbinary)")->toString());
-  EXPECT_EQ(
-      "cast(\"str_col\", TIMESTAMP)",
+      "cast(\"str_col\" as TIMESTAMP)",
       parseExpr("cast(str_col as timestamp)")->toString());
 
   EXPECT_EQ(
-      "cast(\"str_col\", DATE)",
+      "cast(\"str_col\" as DATE)",
       parseExpr("cast(str_col as date)")->toString());
 
   EXPECT_EQ(
-      "cast(\"str_col\", INTERVAL DAY TO SECOND)",
+      "cast(\"str_col\" as INTERVAL DAY TO SECOND)",
       parseExpr("cast(str_col as interval day to second)")->toString());
 
   // Unsupported casts for now.
@@ -375,39 +419,39 @@ TEST(DuckParserTest, cast) {
 
   // Complex types.
   EXPECT_EQ(
-      "cast(\"c0\", ARRAY<BIGINT>)", parseExpr("c0::bigint[]")->toString());
+      "cast(\"c0\" as ARRAY<BIGINT>)", parseExpr("c0::bigint[]")->toString());
   EXPECT_EQ(
-      "cast(\"c0\", ARRAY<BIGINT>)",
+      "cast(\"c0\" as ARRAY<BIGINT>)",
       parseExpr("cast(c0 as bigint[])")->toString());
 
   EXPECT_EQ(
-      "cast(\"c0\", MAP<VARCHAR,BIGINT>)",
+      "cast(\"c0\" as MAP<VARCHAR,BIGINT>)",
       parseExpr("c0::map(varchar, bigint)")->toString());
   EXPECT_EQ(
-      "cast(\"c0\", MAP<VARCHAR,BIGINT>)",
+      "cast(\"c0\" as MAP<VARCHAR,BIGINT>)",
       parseExpr("cast(c0 as map(varchar, bigint))")->toString());
 
   EXPECT_EQ(
-      "cast(\"c0\", ROW<a:BIGINT,b:REAL,c:VARCHAR>)",
+      "cast(\"c0\" as ROW<a:BIGINT,b:REAL,c:VARCHAR>)",
       parseExpr("c0::struct(a bigint, b real, c varchar)")->toString());
   EXPECT_EQ(
-      "cast(\"c0\", ROW<a:BIGINT,b:REAL,c:VARCHAR>)",
+      "cast(\"c0\" as ROW<a:BIGINT,b:REAL,c:VARCHAR>)",
       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());
+  EXPECT_EQ("cast(\"c0\" as JSON)", parseExpr("cast(c0 as json)")->toString());
+  EXPECT_EQ("cast(\"c0\" as JSON)", parseExpr("cast(c0 as JSON)")->toString());
 }
 
 TEST(DuckParserTest, castToTimestampWithTimeZone) {
   registerTimestampWithTimeZoneType();
   EXPECT_EQ(
-      "cast(\"c0\", TIMESTAMP WITH TIME ZONE)",
+      "cast(\"c0\" as TIMESTAMP WITH TIME ZONE)",
       parseExpr("cast(c0 as timestamp with time zone)")->toString());
   EXPECT_EQ(
-      "cast(\"c0\", TIMESTAMP WITH TIME ZONE)",
+      "cast(\"c0\" as TIMESTAMP WITH TIME ZONE)",
       parseExpr("cast(c0 as TIMESTAMP WITH TIME ZONE)")->toString());
 }
 
@@ -438,7 +482,7 @@ TEST(DuckParserTest, switchCase) {
       parseExpr("case when a > 0 then 1 when a < 0 then -1end")->toString());
 
   EXPECT_EQ(
-      "switch(eq(\"a\",1),\"x\",eq(\"a\",5),\"y\",\"z\")",
+      "switch(eq(\"a\",1),x,eq(\"a\",5),y,z)",
       parseExpr("case a when 1 then 'x' when 5 then 'y' else 'z' end")
           ->toString());
 }
@@ -479,24 +523,23 @@ TEST(DuckParserTest, alias) {
       "gt(\"a\",\"b\") AS result", parseExpr("a > b AS result")->toString());
   EXPECT_EQ("2 AS multiplier", parseExpr("2 AS multiplier")->toString());
   EXPECT_EQ(
-      "cast(\"a\", DOUBLE) AS a_double",
+      "cast(\"a\" as DOUBLE) AS a_double",
       parseExpr("cast(a AS DOUBLE) AS a_double")->toString());
   EXPECT_EQ("\"a\" AS b", parseExpr("a AS b")->toString());
 }
 
 TEST(DuckParserTest, like) {
-  EXPECT_EQ("like(\"name\",\"%b%\")", parseExpr("name LIKE '%b%'")->toString());
+  EXPECT_EQ("like(\"name\",%b%)", parseExpr("name LIKE '%b%'")->toString());
   EXPECT_EQ(
-      "like(\"name\",\"%#_%\",\"#\")",
+      "like(\"name\",%#_%,#)",
       parseExpr("name LIKE '%#_%' ESCAPE '#'")->toString());
 }
 
 TEST(DuckParserTest, notLike) {
   EXPECT_EQ(
-      "not(like(\"name\",\"%b%\"))",
-      parseExpr("name NOT LIKE '%b%'")->toString());
+      "not(like(\"name\",%b%))", parseExpr("name NOT LIKE '%b%'")->toString());
   EXPECT_EQ(
-      "not(like(\"name\",\"%#_%\",\"#\"))",
+      "not(like(\"name\",%#_%,#))",
       parseExpr("name NOT LIKE '%#_%' ESCAPE '#'")->toString());
 }
 
@@ -509,9 +552,7 @@ TEST(DuckParserTest, count) {
 
 TEST(DuckParserTest, orderBy) {
   auto parse = [](const auto& expr) {
-    auto orderBy = parseOrderByExpr(expr);
-    return fmt::format(
-        "{} {}", orderBy.first->toString(), orderBy.second.toString());
+    return parseOrderByExpr(expr).toString();
   };
 
   EXPECT_EQ("\"c1\" ASC NULLS LAST", parse("c1"));
@@ -612,8 +653,9 @@ TEST(DuckParserTest, window) {
   EXPECT_EQ(
       "row_number() OVER (PARTITION BY \"a\" ORDER BY \"b\" ASC NULLS LAST "
       "ROWS BETWEEN plus(\"a\",10) PRECEDING AND 10 FOLLOWING)",
-      parseWindow("row_number() over (partition by a order by b "
-                  "rows between a + 10 preceding and 10 following)"));
+      parseWindow(
+          "row_number() over (partition by a order by b "
+          "rows between a + 10 preceding and 10 following)"));
   EXPECT_EQ(
       "row_number() OVER (PARTITION BY \"a\" ORDER BY \"b\" DESC NULLS FIRST "
       "ROWS BETWEEN plus(\"a\",10) PRECEDING AND 10 FOLLOWING)",
@@ -645,8 +687,8 @@ TEST(DuckParserTest, windowWithIntegerConstant) {
       std::dynamic_pointer_cast<const core::CallExpr>(windowExpr.functionCall);
   ASSERT_TRUE(func != nullptr)
       << windowExpr.functionCall->toString() << " is not a call expr";
-  EXPECT_EQ(func->getInputs().size(), 2);
-  auto param = func->getInputs()[1];
+  EXPECT_EQ(func->inputs().size(), 2);
+  auto param = func->inputs()[1];
   auto constant = std::dynamic_pointer_cast<const core::ConstantExpr>(param);
   ASSERT_TRUE(constant != nullptr) << param->toString() << " is not a constant";
   EXPECT_EQ(*constant->type(), *INTEGER());
@@ -686,13 +728,13 @@ TEST(DuckParserTest, parseWithPrefix) {
   ParseOptions options;
   options.functionPrefix = "prefix.";
   EXPECT_EQ(
-      "prefix.in(\"col1\",[1,2,3])",
+      "prefix.in(\"col1\",{1, 2, 3})",
       parseExpr("col1 in (1, 2, 3)", options)->toString());
   EXPECT_EQ(
-      "prefix.like(\"name\",\"%b%\")",
+      "prefix.like(\"name\",%b%)",
       parseExpr("name LIKE '%b%'", options)->toString());
   EXPECT_EQ(
-      "prefix.not(prefix.like(\"name\",\"%b%\"))",
+      "prefix.not(prefix.like(\"name\",%b%))",
       parseExpr("name NOT LIKE '%b%'", options)->toString());
 
   // Arithmetic operators.
@@ -748,7 +790,7 @@ TEST(DuckParserTest, parseWithPrefix) {
   EXPECT_EQ(
       "coalesce(null,0)", parseExpr("coalesce(NULL, 0)", options)->toString());
   EXPECT_EQ(
-      "cast(\"1\", BIGINT)",
+      "cast(1 as BIGINT)",
       parseExpr("cast('1' as bigint)", options)->toString());
   EXPECT_EQ(
       "try(prefix.plus(\"c0\",\"c1\"))",
diff --git a/velox/dwio/CMakeLists.txt b/velox/dwio/CMakeLists.txt
index d4a879e8f680..13a22460e902 100644
--- a/velox/dwio/CMakeLists.txt
+++ b/velox/dwio/CMakeLists.txt
@@ -28,7 +28,8 @@ velox_link_libraries(
     velox_type_fbhive
     velox_vector
     Folly::folly
-    fmt::fmt)
+    fmt::fmt
+)
 
 add_subdirectory(common)
 add_subdirectory(catalog)
diff --git a/velox/dwio/catalog/fbhive/CMakeLists.txt b/velox/dwio/catalog/fbhive/CMakeLists.txt
index cb6a0d30b50f..17a778f41c3c 100644
--- a/velox/dwio/catalog/fbhive/CMakeLists.txt
+++ b/velox/dwio/catalog/fbhive/CMakeLists.txt
@@ -13,8 +13,7 @@
 # limitations under the License.
 
 velox_add_library(velox_dwio_catalog_fbhive FileUtils.cpp)
-velox_link_libraries(velox_dwio_catalog_fbhive velox_exception fmt::fmt
-                     Folly::folly)
+velox_link_libraries(velox_dwio_catalog_fbhive velox_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 36d1b29d98e5..621ee20bbbf4 100644
--- a/velox/dwio/catalog/fbhive/FileUtils.cpp
+++ b/velox/dwio/catalog/fbhive/FileUtils.cpp
@@ -112,9 +112,10 @@ std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
         std::vector<std::string> tokens;
         folly::split('=', partitionPart, tokens);
         if (tokens.size() == 2) {
-          parsedParts.emplace_back(std::make_pair(
-              FileUtils::unescapePathName(tokens[0]),
-              FileUtils::unescapePathName(tokens[1])));
+          parsedParts.emplace_back(
+              std::make_pair(
+                  FileUtils::unescapePathName(tokens[0]),
+                  FileUtils::unescapePathName(tokens[1])));
         }
       });
 }
@@ -157,46 +158,29 @@ std::string FileUtils::unescapePathName(const std::string& data) {
 
 std::string FileUtils::makePartName(
     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) {
-    auto keySize = pair.first.size();
-    VELOX_CHECK_GT(keySize, 0);
-    size += keySize;
-    escapeCount += countEscape(pair.first);
-
-    auto valSize = pair.second.size();
-    if (valSize == 0) {
-      size += kDefaultPartitionValue.size();
-    } else {
-      size += valSize;
-      escapeCount += countEscape(pair.second);
+    bool partitionPathAsLowerCase,
+    bool useDefaultPartitionValue,
+    const EncodeFunction& encodeFunc) {
+  VELOX_CHECK(!entries.empty());
+  std::ostringstream out;
+
+  for (const auto& [key, value] : entries) {
+    VELOX_CHECK(!key.empty());
+    if (out.tellp() > 0) {
+      out << '/';
     }
-  });
 
-  std::string ret;
-  ret.reserve(size + escapeCount * HEX_WIDTH + entries.size() - 1);
-
-  std::for_each(entries.begin(), entries.end(), [&](auto& pair) {
-    if (ret.size() > 0) {
-      ret += "/";
-    }
-    if (partitionPathAsLowerCase) {
-      ret += escapePathName(toLower(pair.first));
-    } else {
-      ret += escapePathName(pair.first);
-    }
+    std::string keyToEncode = partitionPathAsLowerCase ? toLower(key) : key;
+    out << encodeFunc(keyToEncode) << '=';
 
-    ret += "=";
-    if (pair.second.size() == 0) {
-      ret += kDefaultPartitionValue;
+    if (value.empty() && useDefaultPartitionValue) {
+      out << kDefaultPartitionValue;
     } else {
-      ret += escapePathName(pair.second);
+      out << encodeFunc(value);
     }
-  });
+  }
 
-  return ret;
+  return out.str();
 }
 
 std::vector<std::pair<std::string, std::string>> FileUtils::parsePartKeyValues(
diff --git a/velox/dwio/catalog/fbhive/FileUtils.h b/velox/dwio/catalog/fbhive/FileUtils.h
index a8ca8bf07efd..519c274fc6f1 100644
--- a/velox/dwio/catalog/fbhive/FileUtils.h
+++ b/velox/dwio/catalog/fbhive/FileUtils.h
@@ -29,6 +29,10 @@ namespace fbhive {
 
 class FileUtils {
  public:
+  /// Function type for encoding partition key/value strings.
+  /// Takes a string to encode and returns the encoded string.
+  using EncodeFunction = std::function<std::string(const std::string&)>;
+
   /// Converts the path name to be hive metastore compliant, will do
   /// url-encoding when needed.
   static std::string escapePathName(const std::string& data);
@@ -39,9 +43,19 @@ class FileUtils {
 
   /// Creates the partition directory path from the list of partition key/value
   /// pairs, will do url-encoding when needed.
+  /// @param entries Vector of (key, value) pairs for partition columns. Cannot
+  ///        be empty.
+  /// @param partitionPathAsLowerCase Whether to convert keys to lowercase
+  /// @param useDefaultPartitionValue If true, empty values are replaced with
+  ///        kDefaultPartitionValue. If false, empty values are encoded as-is.
+  ///        Defaults to true for Hive compatibility.
+  /// @param encodeFunc Function to use for encoding keys and values.
+  ///                   Defaults to escapePathName.
   static std::string makePartName(
       const std::vector<std::pair<std::string, std::string>>& entries,
-      bool partitionPathAsLowerCase);
+      bool partitionPathAsLowerCase,
+      bool useDefaultPartitionValue = true,
+      const EncodeFunction& encodeFunc = escapePathName);
 
   /// Converts the hive-metastore-compliant path name back to the corresponding
   /// partition key/value pairs.
diff --git a/velox/dwio/catalog/fbhive/test/CMakeLists.txt b/velox/dwio/catalog/fbhive/test/CMakeLists.txt
index d7fb52887727..fede218f0acb 100644
--- a/velox/dwio/catalog/fbhive/test/CMakeLists.txt
+++ b/velox/dwio/catalog/fbhive/test/CMakeLists.txt
@@ -20,4 +20,5 @@ target_link_libraries(
   velox_exception
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
diff --git a/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp b/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
index 042c5ba93080..579c7533ecd0 100644
--- a/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
+++ b/velox/dwio/catalog/fbhive/test/FileUtilsTests.cpp
@@ -19,10 +19,12 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/dwio/catalog/fbhive/FileUtils.h"
 
+namespace facebook::velox::dwio::catalog::fbhive {
+namespace {
+
 using namespace ::testing;
-using namespace facebook::velox::dwio::catalog::fbhive;
 
-TEST(FileUtilsTests, MakePartName) {
+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(
@@ -31,9 +33,22 @@ TEST(FileUtilsTests, MakePartName) {
   ASSERT_EQ(
       FileUtils::makePartName(pairs, false),
       "ds=2016-01-01/FOO=__HIVE_DEFAULT_PARTITION__/a%0Ab%3Ac=a%23b%3Dc");
+  ASSERT_THROW(FileUtils::makePartName({}, false), VeloxException);
+}
+
+TEST(FileUtilsTests, makePartNameWithoutDefaultPartitionValue) {
+  std::vector<std::pair<std::string, std::string>> pairs{
+      {"ds", "2016-01-01"}, {"FOO", ""}, {"a\nb:c", "a#b=c"}};
+  // Test with useDefaultPartitionValue = false.
+  ASSERT_EQ(
+      FileUtils::makePartName(pairs, true, false),
+      "ds=2016-01-01/foo=/a%0Ab%3Ac=a%23b%3Dc");
+  ASSERT_EQ(
+      FileUtils::makePartName(pairs, false, false),
+      "ds=2016-01-01/FOO=/a%0Ab%3Ac=a%23b%3Dc");
 }
 
-TEST(FileUtilsTests, ParsePartKeyValues) {
+TEST(FileUtilsTests, parsePartKeyValues) {
   EXPECT_THROW(
       FileUtils::parsePartKeyValues("ds"), facebook::velox::VeloxRuntimeError);
   EXPECT_THROW(
@@ -60,7 +75,7 @@ TEST(FileUtilsTests, ParsePartKeyValues) {
           std::make_pair("a\nb:c", "a#b=c/")));
 }
 
-TEST(FileUtilsTests, ExtractPartitionName) {
+TEST(FileUtilsTests, extractPartitionName) {
   struct TestCase {
    public:
     TestCase(const std::string& filePath, const std::string& partitionName)
@@ -88,3 +103,6 @@ TEST(FileUtilsTests, ExtractPartitionName) {
         FileUtils::extractPartitionName(testCase.filePath));
   }
 }
+
+} // namespace
+} // namespace facebook::velox::dwio::catalog::fbhive
diff --git a/velox/dwio/common/Adaptor.h b/velox/dwio/common/Adaptor.h
index 2fef0a96655c..ae89074808fd 100644
--- a/velox/dwio/common/Adaptor.h
+++ b/velox/dwio/common/Adaptor.h
@@ -27,7 +27,7 @@
 #define DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
 #define DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
 #else
-#error("Unknown compiler")
+#error ("Unknown compiler")
 #endif
 
 #define PRAGMA(TXT) _Pragma(#TXT)
diff --git a/velox/dwio/common/Arena.h b/velox/dwio/common/Arena.h
new file mode 100644
index 000000000000..9690ce727d35
--- /dev/null
+++ b/velox/dwio/common/Arena.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 <google/protobuf/arena.h>
+#include <google/protobuf/stubs/common.h>
+
+namespace facebook::velox::dwio::common {
+
+/// Wrapper over protobuf's arena allocation.  The API changes from
+/// CreateMessage() to Create() in newer protobuf versions.
+template <class T, class... Args>
+T* ArenaCreate(google::protobuf::Arena* arena, Args&&... args) {
+#if GOOGLE_PROTOBUF_VERSION >= 5030000
+  return google::protobuf::Arena::Create<T>(arena, std::forward<Args>(args)...);
+#else
+  return google::protobuf::Arena::CreateMessage<T>(
+      arena, std::forward<Args>(args)...);
+#endif
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/BitPackDecoder.h b/velox/dwio/common/BitPackDecoder.h
index 2aa785e2d29f..5f31267026d8 100644
--- a/velox/dwio/common/BitPackDecoder.h
+++ b/velox/dwio/common/BitPackDecoder.h
@@ -109,7 +109,7 @@ static inline uint32_t unpackNaive(
     uint64_t inputBufferLen,
     uint64_t numValues,
     uint8_t bitWidth,
-    T* FOLLY_NONNULL& result);
+    T * FOLLY_NONNULL & result);
 
 /// Unpack numValues number of input values from inputBuffer. The results
 /// will be written to result. numValues must be a multiple of 8. The
@@ -122,7 +122,7 @@ inline void unpack(
     uint64_t inputBufferLen,
     uint64_t numValues,
     uint8_t bitWidth,
-    T* FOLLY_NONNULL& result) {
+    T * FOLLY_NONNULL & result) {
   unpackNaive<T>(inputBits, inputBufferLen, numValues, bitWidth, result);
 }
 
@@ -159,7 +159,7 @@ static inline uint32_t unpackNaive(
     uint64_t inputBufferLen,
     uint64_t numValues,
     uint8_t bitWidth,
-    T* FOLLY_NONNULL& result) {
+    T * FOLLY_NONNULL & result) {
   VELOX_CHECK(bitWidth >= 1 && bitWidth <= sizeof(T) * 8);
   VELOX_CHECK(inputBufferLen * 8 >= bitWidth * numValues);
 
diff --git a/velox/dwio/common/BufferedInput.cpp b/velox/dwio/common/BufferedInput.cpp
index 8791e418f49e..6062bcfd22ad 100644
--- a/velox/dwio/common/BufferedInput.cpp
+++ b/velox/dwio/common/BufferedInput.cpp
@@ -114,8 +114,9 @@ std::unique_ptr<SeekableInputStream> BufferedInput::enqueue(
       // help faster lookup using enqueuedToBufferOffset_ later.
       [region, this, i = regions_.size() - 1]() {
         auto result = readInternal(region.offset, region.length, i);
-        VELOX_CHECK(
-            std::get<1>(result) != MAX_UINT64,
+        VELOX_CHECK_NE(
+            std::get<1>(result),
+            MAX_UINT64,
             "Fail to read region offset={} length={}",
             region.offset,
             region.length);
diff --git a/velox/dwio/common/BufferedInput.h b/velox/dwio/common/BufferedInput.h
index 1f877b3fa8d0..e2089c42a799 100644
--- a/velox/dwio/common/BufferedInput.h
+++ b/velox/dwio/common/BufferedInput.h
@@ -37,13 +37,15 @@ class BufferedInput {
       IoStatistics* stats = nullptr,
       filesystems::File::IoStats* fsStats = nullptr,
       uint64_t maxMergeDistance = kMaxMergeDistance,
-      std::optional<bool> wsVRLoad = std::nullopt)
+      std::optional<bool> wsVRLoad = std::nullopt,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {})
       : BufferedInput(
             std::make_shared<ReadFileInputStream>(
                 std::move(readFile),
                 metricsLog,
                 stats,
-                fsStats),
+                fsStats,
+                std::move(fileReadOps)),
             pool,
             maxMergeDistance,
             wsVRLoad) {}
diff --git a/velox/dwio/common/CMakeLists.txt b/velox/dwio/common/CMakeLists.txt
index 55fadf6c2f21..2023728686bc 100644
--- a/velox/dwio/common/CMakeLists.txt
+++ b/velox/dwio/common/CMakeLists.txt
@@ -14,6 +14,7 @@
 add_subdirectory(compression)
 add_subdirectory(encryption)
 add_subdirectory(exception)
+add_subdirectory(wrap)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
@@ -45,6 +46,7 @@ velox_add_library(
   MetadataFilter.cpp
   Options.cpp
   OutputStream.cpp
+  ParallelUnitLoader.cpp
   ParallelFor.cpp
   Range.cpp
   Reader.cpp
@@ -53,6 +55,7 @@ velox_add_library(
   SeekableInputStream.cpp
   SelectiveByteRleColumnReader.cpp
   SelectiveColumnReader.cpp
+  SelectiveFlatMapColumnReader.cpp
   SelectiveRepeatedColumnReader.cpp
   SelectiveStructColumnReader.cpp
   SortingWriter.cpp
@@ -61,7 +64,8 @@ velox_add_library(
   TypeUtils.cpp
   TypeWithId.cpp
   Writer.cpp
-  WriterFactory.cpp)
+  WriterFactory.cpp
+)
 
 velox_include_directories(velox_dwio_common PRIVATE ${Protobuf_INCLUDE_DIRS})
 
@@ -78,7 +82,7 @@ velox_link_libraries(
   velox_expression
   velox_memory
   velox_type_tz
-  Boost::regex
   Folly::folly
   glog::glog
-  protobuf::libprotobuf)
+  protobuf::libprotobuf
+)
diff --git a/velox/dwio/common/CacheInputStream.cpp b/velox/dwio/common/CacheInputStream.cpp
index dedda0c72f6a..cbf1f6ecf609 100644
--- a/velox/dwio/common/CacheInputStream.cpp
+++ b/velox/dwio/common/CacheInputStream.cpp
@@ -142,8 +142,8 @@ bool CacheInputStream::SkipInt64(int64_t count) {
   return false;
 }
 
-google::protobuf::int64 CacheInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(position_);
+int64_t CacheInputStream::ByteCount() const {
+  return static_cast<int64_t>(position_);
 }
 
 void CacheInputStream::seekToPosition(PositionProvider& seekPosition) {
@@ -394,7 +394,7 @@ velox::common::Region CacheInputStream::nextQuantizedLoadRegion(
   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>(
+  nextRegion.length = std::min<uint64_t>(
       loadQuantum_, region_.length - (nextRegion.offset - region_.offset));
   return nextRegion;
 }
diff --git a/velox/dwio/common/CacheInputStream.h b/velox/dwio/common/CacheInputStream.h
index 195bdbdd1351..1e1dab8d47a9 100644
--- a/velox/dwio/common/CacheInputStream.h
+++ b/velox/dwio/common/CacheInputStream.h
@@ -51,7 +51,7 @@ class CacheInputStream : public SeekableInputStream {
   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;
+  int64_t ByteCount() const override;
   void seekToPosition(PositionProvider& position) override;
   std::string getName() const override;
   size_t positionSize() const override;
diff --git a/velox/dwio/common/CachedBufferedInput.cpp b/velox/dwio/common/CachedBufferedInput.cpp
index 55ee71e49468..a6255a87c234 100644
--- a/velox/dwio/common/CachedBufferedInput.cpp
+++ b/velox/dwio/common/CachedBufferedInput.cpp
@@ -48,20 +48,20 @@ std::unique_ptr<SeekableInputStream> CachedBufferedInput::enqueue(
   }
   VELOX_CHECK_LE(region.offset + region.length, fileSize_);
   requests_.emplace_back(
-      RawFileCacheKey{fileNum_, region.offset}, region.length, id);
+      RawFileCacheKey{fileNum_.id(), region.offset}, region.length, id);
   if (tracker_ != nullptr) {
-    tracker_->recordReference(id, region.length, fileNum_, groupId_);
+    tracker_->recordReference(id, region.length, fileNum_.id(), groupId_.id());
   }
   auto stream = std::make_unique<CacheInputStream>(
       this,
       ioStats_.get(),
       region,
       input_,
-      fileNum_,
+      fileNum_.id(),
       options_.noCacheRetention(),
       tracker_,
       id,
-      groupId_,
+      groupId_.id(),
       options_.loadQuantum());
   requests_.back().stream = stream.get();
   return stream;
@@ -127,10 +127,11 @@ std::vector<CacheRequest*> makeRequestParts(
   std::vector<CacheRequest*> parts;
   for (uint64_t offset = 0; offset < request.size; offset += loadQuantum) {
     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,
-        request.trackingId));
+    extraRequests.push_back(
+        std::make_unique<CacheRequest>(
+            RawFileCacheKey{request.key.fileNum, request.key.offset + offset},
+            size,
+            request.trackingId));
     parts.push_back(extraRequests.back().get());
     parts.back()->coalesces = prefetch;
     if (prefetchOne) {
@@ -166,7 +167,7 @@ void CachedBufferedInput::load(const LogType /*unused*/) {
   cache::SsdFile* ssdFile{nullptr};
   auto* ssdCache = cache_->ssdCache();
   if (ssdCache != nullptr) {
-    ssdFile = &ssdCache->file(fileNum_);
+    ssdFile = &ssdCache->file(fileNum_.id());
   }
 
   // Extra requests made for pre-loadable regions that are larger than
@@ -467,14 +468,14 @@ void CachedBufferedInput::readRegion(
   std::shared_ptr<cache::CoalescedLoad> load;
   if (!requests[0]->ssdPin.empty()) {
     load = std::make_shared<SsdLoad>(
-        *cache_, ioStats_, fsStats_, groupId_, requests);
+        *cache_, ioStats_, fsStats_, groupId_.id(), requests);
   } else {
     load = std::make_shared<DwioCoalescedLoad>(
         *cache_,
         input_,
         ioStats_,
         fsStats_,
-        groupId_,
+        groupId_.id(),
         requests,
         options_.maxCoalesceDistance());
   }
@@ -553,7 +554,7 @@ std::unique_ptr<SeekableInputStream> CachedBufferedInput::read(
       ioStats_.get(),
       Region{offset, length},
       input_,
-      fileNum_,
+      fileNum_.id(),
       options_.noCacheRetention(),
       nullptr,
       TrackingId(),
diff --git a/velox/dwio/common/CachedBufferedInput.h b/velox/dwio/common/CachedBufferedInput.h
index 6782c2dacf54..4fb2475f5c85 100644
--- a/velox/dwio/common/CachedBufferedInput.h
+++ b/velox/dwio/common/CachedBufferedInput.h
@@ -27,8 +27,6 @@
 #include "velox/dwio/common/CacheInputStream.h"
 #include "velox/dwio/common/InputStream.h"
 
-DECLARE_int32(cache_load_quantum);
-
 namespace facebook::velox::dwio::common {
 
 struct CacheRequest {
@@ -57,24 +55,28 @@ class CachedBufferedInput : public BufferedInput {
   CachedBufferedInput(
       std::shared_ptr<ReadFile> readFile,
       const MetricsLogPtr& metricsLog,
-      uint64_t fileNum,
+      StringIdLease fileNum,
       cache::AsyncDataCache* cache,
       std::shared_ptr<cache::ScanTracker> tracker,
-      uint64_t groupId,
+      StringIdLease groupId,
       std::shared_ptr<IoStatistics> ioStats,
       std::shared_ptr<filesystems::File::IoStats> fsStats,
       folly::Executor* executor,
-      const io::ReaderOptions& readerOptions)
+      const io::ReaderOptions& readerOptions,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {})
       : BufferedInput(
             std::move(readFile),
             readerOptions.memoryPool(),
             metricsLog,
             ioStats.get(),
-            fsStats.get()),
+            fsStats.get(),
+            kMaxMergeDistance,
+            std::nullopt,
+            std::move(fileReadOps)),
         cache_(cache),
-        fileNum_(fileNum),
+        fileNum_(std::move(fileNum)),
         tracker_(std::move(tracker)),
-        groupId_(groupId),
+        groupId_(std::move(groupId)),
         ioStats_(std::move(ioStats)),
         fsStats_(std::move(fsStats)),
         executor_(executor),
@@ -85,19 +87,19 @@ class CachedBufferedInput : public BufferedInput {
 
   CachedBufferedInput(
       std::shared_ptr<ReadFileInputStream> input,
-      uint64_t fileNum,
+      StringIdLease fileNum,
       cache::AsyncDataCache* cache,
       std::shared_ptr<cache::ScanTracker> tracker,
-      uint64_t groupId,
+      StringIdLease groupId,
       std::shared_ptr<IoStatistics> ioStats,
       std::shared_ptr<filesystems::File::IoStats> fsStats,
       folly::Executor* executor,
       const io::ReaderOptions& readerOptions)
       : BufferedInput(std::move(input), readerOptions.memoryPool()),
         cache_(cache),
-        fileNum_(fileNum),
+        fileNum_(std::move(fileNum)),
         tracker_(std::move(tracker)),
-        groupId_(groupId),
+        groupId_(std::move(groupId)),
         ioStats_(std::move(ioStats)),
         fsStats_(std::move(fsStats)),
         executor_(executor),
@@ -140,7 +142,7 @@ class CachedBufferedInput : public BufferedInput {
   void setNumStripes(int32_t numStripes) override {
     auto stats = tracker_->fileGroupStats();
     if (stats) {
-      stats->recordFile(fileNum_, groupId_, numStripes);
+      stats->recordFile(fileNum_.id(), groupId_.id(), numStripes);
     }
   }
 
@@ -210,9 +212,9 @@ class CachedBufferedInput : public BufferedInput {
   }
 
   cache::AsyncDataCache* const cache_;
-  const uint64_t fileNum_;
+  const StringIdLease fileNum_;
   const std::shared_ptr<cache::ScanTracker> tracker_;
-  const uint64_t groupId_;
+  const StringIdLease groupId_;
   const std::shared_ptr<IoStatistics> ioStats_;
   const std::shared_ptr<filesystems::File::IoStats> fsStats_;
   folly::Executor* const executor_;
diff --git a/velox/dwio/common/ChainedBuffer.h b/velox/dwio/common/ChainedBuffer.h
index 7b514d6b460b..38ba8d7c269c 100644
--- a/velox/dwio/common/ChainedBuffer.h
+++ b/velox/dwio/common/ChainedBuffer.h
@@ -20,10 +20,7 @@
 #include "velox/common/base/GTestMacros.h"
 #include "velox/dwio/common/DataBuffer.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 namespace {
 
@@ -228,7 +225,4 @@ class ChainedBuffer {
   VELOX_FRIEND_TEST(ChainedBufferTests, testClearAll);
 };
 
-} // 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 e4a000f295f5..7d62008440b9 100644
--- a/velox/dwio/common/ColumnLoader.cpp
+++ b/velox/dwio/common/ColumnLoader.cpp
@@ -87,61 +87,6 @@ void scatter(RowSet rows, vector_size_t resultSize, VectorPtr* result) {
   *result = BaseVector::wrapInDictionary(nullptr, indices, resultSize, *result);
 }
 
-template <typename T>
-void addToHookImpl(
-    const DecodedVector& decoded,
-    const RowSet& rows,
-    ValueHook& hook) {
-  if (decoded.isIdentityMapping()) {
-    auto* values = decoded.data<T>();
-    hook.addValues(rows.data(), values, rows.size());
-    return;
-  }
-  for (auto i : rows) {
-    if (!decoded.isNullAt(i)) {
-      hook.addValueTyped(i, decoded.valueAt<T>(i));
-    } else if (hook.acceptsNulls()) {
-      hook.addNull(i);
-    }
-  }
-}
-
-void addToHook(
-    const DecodedVector& decoded,
-    const RowSet& rows,
-    ValueHook& hook) {
-  switch (decoded.base()->typeKind()) {
-    case TypeKind::BOOLEAN:
-      addToHookImpl<bool>(decoded, rows, hook);
-      break;
-    case TypeKind::TINYINT:
-      addToHookImpl<int8_t>(decoded, rows, hook);
-      break;
-    case TypeKind::SMALLINT:
-      addToHookImpl<int16_t>(decoded, rows, hook);
-      break;
-    case TypeKind::INTEGER:
-      addToHookImpl<int32_t>(decoded, rows, hook);
-      break;
-    case TypeKind::BIGINT:
-      addToHookImpl<int64_t>(decoded, rows, hook);
-      break;
-    case TypeKind::REAL:
-      addToHookImpl<float>(decoded, rows, hook);
-      break;
-    case TypeKind::DOUBLE:
-      addToHookImpl<double>(decoded, rows, hook);
-      break;
-    case TypeKind::VARCHAR:
-    case TypeKind::VARBINARY:
-      addToHookImpl<StringView>(decoded, rows, hook);
-      break;
-    default:
-      VELOX_FAIL(
-          "Unsupported type kind for hook: {}", decoded.base()->typeKind());
-  }
-}
-
 } // namespace
 
 void ColumnLoader::loadInternal(
@@ -156,7 +101,7 @@ void ColumnLoader::loadInternal(
              ->debugString();
        },
        structReader_});
-  raw_vector<vector_size_t> selectedRows;
+  raw_vector<vector_size_t> selectedRows(fieldReader_->memoryPool());
   auto effectiveRows =
       read(structReader_, fieldReader_, version_, rows, selectedRows, hook);
   if (!hook) {
@@ -189,17 +134,14 @@ void DeltaUpdateColumnLoader::loadInternal(
   // method return.
   VELOX_CHECK(!scanSpec->hasFilter());
   scanSpec->setValueHook(nullptr);
-  raw_vector<vector_size_t> selectedRows;
+  raw_vector<vector_size_t> selectedRows(fieldReader_->memoryPool());
   RowSet effectiveRows;
   effectiveRows =
       read(structReader_, fieldReader_, version_, rows, selectedRows, nullptr);
   fieldReader_->getValues(effectiveRows, result);
   scanSpec->deltaUpdate()->update(effectiveRows, *result);
-  if (hook) {
-    DecodedVector decoded(**result);
-    addToHook(decoded, effectiveRows, *hook);
-  } else if (
-      rows.back() + 1 < resultSize ||
+  VELOX_CHECK_NULL(hook);
+  if (rows.back() + 1 < resultSize ||
       rows.size() != structReader_->outputRows().size()) {
     scatter(rows, resultSize, result);
   }
diff --git a/velox/dwio/common/ColumnLoader.h b/velox/dwio/common/ColumnLoader.h
index 2a2109f35cf0..71d86c7e0aaf 100644
--- a/velox/dwio/common/ColumnLoader.h
+++ b/velox/dwio/common/ColumnLoader.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "velox/dwio/common/SelectiveStructColumnReader.h"
+#include "velox/vector/LazyVector.h"
 
 namespace facebook::velox::dwio::common {
 
@@ -30,7 +31,13 @@ class ColumnLoader : public VectorLoader {
         fieldReader_(fieldReader),
         version_(version) {}
 
- private:
+  virtual ~ColumnLoader() = default;
+
+  bool supportsHook() const override {
+    return true;
+  }
+
+ protected:
   void loadInternal(
       RowSet rows,
       ValueHook* hook,
diff --git a/velox/dwio/common/ColumnSelector.h b/velox/dwio/common/ColumnSelector.h
index 62408e55a213..9bef521d99a1 100644
--- a/velox/dwio/common/ColumnSelector.h
+++ b/velox/dwio/common/ColumnSelector.h
@@ -388,8 +388,10 @@ class ColumnSelector {
     // expect a runtime_error rather than fault.
     // Do-Not change the message as expected by client in failure case
     if (!notFound.empty()) {
-      throw std::runtime_error(folly::to<std::string>(
-          "Columns not found in hive table: ", folly::join(", ", notFound)));
+      throw std::runtime_error(
+          folly::to<std::string>(
+              "Columns not found in hive table: ",
+              folly::join(", ", notFound)));
     }
   }
 
diff --git a/velox/dwio/common/ColumnVisitors.h b/velox/dwio/common/ColumnVisitors.h
index 85798ee5bdf3..6e5f0db8187f 100644
--- a/velox/dwio/common/ColumnVisitors.h
+++ b/velox/dwio/common/ColumnVisitors.h
@@ -21,7 +21,6 @@
 #include "velox/dwio/common/DecoderUtil.h"
 #include "velox/dwio/common/SelectiveColumnReader.h"
 #include "velox/dwio/common/TypeUtil.h"
-
 namespace facebook::velox::dwio::common {
 
 // structs for extractValues in ColumnVisitor.
@@ -164,7 +163,7 @@ class ColumnVisitor {
   static constexpr bool kFilterOnly = std::is_same_v<Extract, DropValues>;
 
   ColumnVisitor(
-      TFilter& filter,
+      const TFilter& filter,
       SelectiveColumnReader* reader,
       const RowSet& rows,
       ExtractValues values)
@@ -409,7 +408,7 @@ class ColumnVisitor {
   inline void addNull();
   inline void addOutputRow(vector_size_t row);
 
-  TFilter& filter() {
+  const TFilter& filter() {
     return filter_;
   }
 
@@ -491,8 +490,8 @@ class ColumnVisitor {
   }
 
  protected:
-  TFilter& filter_;
-  SelectiveColumnReader* reader_;
+  const TFilter& filter_;
+  SelectiveColumnReader* const reader_;
   const bool allowNulls_;
   const vector_size_t* rows_;
   vector_size_t numRows_;
@@ -724,7 +723,15 @@ inline xsimd::batch<int64_t> cvtU32toI64(
     xsimd::batch<int32_t, xsimd::sse2> values) {
   return _mm256_cvtepu32_epi64(values);
 }
-#elif XSIMD_WITH_SSE2 || XSIMD_WITH_NEON
+#elif (XSIMD_WITH_SVE && SVE_BITS == 256)
+inline xsimd::batch<int64_t> cvtU32toI64(simd::Batch128<int32_t> values) {
+  int64_t element_1 = static_cast<uint32_t>(values.data[0]);
+  int64_t element_2 = static_cast<uint32_t>(values.data[1]);
+  int64_t element_3 = static_cast<uint32_t>(values.data[2]);
+  int64_t element_4 = static_cast<uint32_t>(values.data[3]);
+  return xsimd::batch<int64_t>(element_1, element_2, element_3, element_4);
+}
+#elif XSIMD_WITH_SSE2 || XSIMD_WITH_NEON || (XSIMD_WITH_SVE && SVE_BITS == 128)
 inline xsimd::batch<int64_t> cvtU32toI64(simd::Batch64<int32_t> values) {
   int64_t lo = static_cast<uint32_t>(values.data[0]);
   int64_t hi = static_cast<uint32_t>(values.data[1]);
@@ -741,7 +748,7 @@ class DictionaryColumnVisitor
 
  public:
   DictionaryColumnVisitor(
-      TFilter& filter,
+      const TFilter& filter,
       SelectiveColumnReader* reader,
       const RowSet& rows,
       ExtractValues values)
@@ -913,10 +920,20 @@ class DictionaryColumnVisitor
           dictMask,
           reinterpret_cast<const int32_t*>(filterCache() - 3),
           indices);
-      auto unknowns = simd::toBitMask(xsimd::batch_bool<int32_t>(
-          simd::reinterpretBatch<uint32_t>((cache & (kUnknown << 24)) << 1)));
+#ifdef SVE_BITS
+      auto unknowns = simd::toBitMask(
+          simd::reinterpretBatch<uint32_t>((cache & (kUnknown << 24)) << 1) !=
+          xsimd::batch<uint32_t>(0));
+      auto passed = simd::toBitMask(
+          (simd::reinterpretBatch<uint32_t>(cache) &
+           xsimd::batch<uint32_t>(1)) != xsimd::batch<uint32_t>(0));
+#else
+      auto unknowns = simd::toBitMask(
+          xsimd::batch_bool<int32_t>(simd::reinterpretBatch<uint32_t>(
+              (cache & (kUnknown << 24)) << 1)));
       auto passed = simd::toBitMask(
           xsimd::batch_bool<int32_t>(simd::reinterpretBatch<uint32_t>(cache)));
+#endif
       if (UNLIKELY(unknowns)) {
         uint16_t bits = unknowns;
         // Ranges only over inputs that are in dictionary, the not in dictionary
@@ -1159,7 +1176,7 @@ ColumnVisitor<T, TFilter, ExtractValues, isDense, hasBulkPath>::
   }
   auto result = DictionaryColumnVisitor<T, TFilter, ExtractValues, isDense>(
       filter_, reader_, RowSet(rows_ + rowIndex_, numRows_), values_);
-  result.numValuesBias_ = numValuesBias_;
+  result.setNumValuesBias(numValuesBias_);
   return result;
 }
 
@@ -1192,7 +1209,7 @@ class StringDictionaryColumnVisitor
 
  public:
   StringDictionaryColumnVisitor(
-      TFilter& filter,
+      const TFilter& filter,
       SelectiveColumnReader* reader,
       RowSet rows,
       ExtractValues values)
@@ -1305,10 +1322,20 @@ class StringDictionaryColumnVisitor
       } else {
         cache = simd::gather<int32_t, int32_t, 1>(base, indices);
       }
-      auto unknowns = simd::toBitMask(xsimd::batch_bool<int32_t>(
-          simd::reinterpretBatch<uint32_t>((cache & (kUnknown << 24)) << 1)));
+#ifdef SVE_BITS
+      auto unknowns = simd::toBitMask(
+          simd::reinterpretBatch<uint32_t>((cache & (kUnknown << 24)) << 1) !=
+          xsimd::batch<uint32_t>(0));
+      auto passed = simd::toBitMask(
+          (simd::reinterpretBatch<uint32_t>(cache) &
+           xsimd::batch<uint32_t>(1)) != xsimd::batch<uint32_t>(0));
+#else
+      auto unknowns = simd::toBitMask(
+          xsimd::batch_bool<int32_t>(simd::reinterpretBatch<uint32_t>(
+              (cache & (kUnknown << 24)) << 1)));
       auto passed = simd::toBitMask(
           xsimd::batch_bool<int32_t>(simd::reinterpretBatch<uint32_t>(cache)));
+#endif
       if (UNLIKELY(unknowns)) {
         uint16_t bits = unknowns;
         while (bits) {
@@ -1394,7 +1421,7 @@ class StringDictionaryColumnVisitor
     }
   }
 
-  folly::StringPiece valueInDictionary(int64_t index) {
+  StringView valueInDictionary(int64_t index) {
     auto stripeDictSize = DictSuper::state_.dictionary.numValues;
     if (index < stripeDictSize) {
       return reinterpret_cast<const StringView*>(
@@ -1412,7 +1439,7 @@ class DirectRleColumnVisitor
 
  public:
   DirectRleColumnVisitor(
-      TFilter& filter,
+      const TFilter& filter,
       SelectiveColumnReader* reader,
       RowSet rows,
       ExtractValues values)
@@ -1547,12 +1574,15 @@ class StringColumnReadWithVisitorHelper {
  private:
   template <typename TFilter, bool kIsDense, typename ExtractValues, typename F>
   void readHelper(
-      velox::common::Filter* filter,
+      const velox::common::Filter* filter,
       ExtractValues extractValues,
       F readWithVisitor) {
     readWithVisitor(
-        ColumnVisitor<folly::StringPiece, TFilter, ExtractValues, kIsDense>(
-            *static_cast<TFilter*>(filter), &reader_, rows_, extractValues));
+        ColumnVisitor<std::string_view, TFilter, ExtractValues, kIsDense>(
+            *static_cast<const TFilter*>(filter),
+            &reader_,
+            rows_,
+            extractValues));
   }
 
   template <bool kIsDense, typename ExtractValues, typename F>
diff --git a/velox/dwio/common/DataBuffer.h b/velox/dwio/common/DataBuffer.h
index ba84cb45a219..1f2964c1a61e 100644
--- a/velox/dwio/common/DataBuffer.h
+++ b/velox/dwio/common/DataBuffer.h
@@ -23,10 +23,7 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 template <typename T, typename = std::enable_if_t<std::is_trivial_v<T>>>
 class DataBuffer {
@@ -34,8 +31,9 @@ class DataBuffer {
   explicit DataBuffer(velox::memory::MemoryPool& pool, uint64_t size = 0)
       : pool_(&pool),
         // Initial allocation uses calloc, to avoid memset.
-        buf_(reinterpret_cast<T*>(
-            pool_->allocateZeroFilled(1, sizeInBytes(size)))),
+        buf_(
+            reinterpret_cast<T*>(
+                pool_->allocateZeroFilled(1, sizeInBytes(size)))),
         size_(size),
         capacity_(size) {
     VELOX_CHECK(buf_ != nullptr || size_ == 0);
@@ -233,7 +231,5 @@ class DataBuffer {
   // Maximum capacity of items of type T.
   uint64_t capacity_;
 };
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/DataBufferHolder.cpp b/velox/dwio/common/DataBufferHolder.cpp
index f6ff2757a352..0f5b246f062b 100644
--- a/velox/dwio/common/DataBufferHolder.cpp
+++ b/velox/dwio/common/DataBufferHolder.cpp
@@ -21,7 +21,7 @@ using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::dwio::common {
 
-void DataBufferHolder::take(const std::vector<folly::StringPiece>& buffers) {
+void DataBufferHolder::take(const std::vector<std::string_view>& buffers) {
   // compute size
   uint64_t totalSize = 0;
   for (auto& buf : buffers) {
@@ -38,7 +38,7 @@ void DataBufferHolder::take(const std::vector<folly::StringPiece>& buffers) {
   auto* data = buf.data();
   for (auto& buffer : buffers) {
     const auto size = buffer.size();
-    ::memcpy(data, buffer.begin(), size);
+    ::memcpy(data, buffer.cbegin(), size);
     data += size;
   }
   // If possibly, write content of the data to output immediately. Otherwise,
diff --git a/velox/dwio/common/DataBufferHolder.h b/velox/dwio/common/DataBufferHolder.h
index 1c291f13328b..91f4fe56007b 100644
--- a/velox/dwio/common/DataBufferHolder.h
+++ b/velox/dwio/common/DataBufferHolder.h
@@ -47,14 +47,14 @@ class DataBufferHolder {
 
   /// Takes content of the incoming data buffer. It is the caller's
   /// responsibility to resize the buffer (if required).
-  void take(const std::vector<folly::StringPiece>& buffers);
+  void take(const std::vector<std::string_view>& buffers);
 
-  void take(folly::StringPiece buffer) {
-    take(std::vector<folly::StringPiece>{buffer});
+  void take(std::string_view buffer) {
+    take(std::vector<std::string_view>{buffer});
   }
 
   void take(const dwio::common::DataBuffer<char>& buffer) {
-    take(folly::StringPiece{buffer.data(), buffer.size()});
+    take(std::string_view{buffer.data(), buffer.size()});
   }
 
   std::vector<dwio::common::DataBuffer<char>>& getBuffers() {
diff --git a/velox/dwio/common/DecoderUtil.h b/velox/dwio/common/DecoderUtil.h
index a79f3bce6365..9527915e0998 100644
--- a/velox/dwio/common/DecoderUtil.h
+++ b/velox/dwio/common/DecoderUtil.h
@@ -162,7 +162,7 @@ void fixedWidthScan(
     dwio::common::SeekableInputStream& input,
     const char*& bufferStart,
     const char*& bufferEnd,
-    TFilter& filter,
+    const TFilter& filter,
     THook& hook) {
   constexpr int32_t kWidth = xsimd::batch<T>::size;
   constexpr bool is16 = sizeof(T) == 2;
@@ -473,7 +473,7 @@ void processFixedWidthRun(
     T* values,
     int32_t* filterHits,
     int32_t& numValues,
-    TFilter& filter,
+    const TFilter& filter,
     THook& hook) {
   constexpr int32_t kWidth = xsimd::batch<T>::size;
   constexpr bool hasFilter =
diff --git a/velox/dwio/common/DirectBufferedInput.cpp b/velox/dwio/common/DirectBufferedInput.cpp
index 5b35f8b942d2..a7ebe5300bd0 100644
--- a/velox/dwio/common/DirectBufferedInput.cpp
+++ b/velox/dwio/common/DirectBufferedInput.cpp
@@ -51,17 +51,17 @@ std::unique_ptr<SeekableInputStream> DirectBufferedInput::enqueue(
   VELOX_CHECK_LE(region.offset + region.length, fileSize_);
   requests_.emplace_back(region, id);
   if (tracker_) {
-    tracker_->recordReference(id, region.length, fileNum_, groupId_);
+    tracker_->recordReference(id, region.length, fileNum_.id(), groupId_.id());
   }
   auto stream = std::make_unique<DirectInputStream>(
       this,
       ioStats_.get(),
       region,
       input_,
-      fileNum_,
+      fileNum_.id(),
       tracker_,
       id,
-      groupId_,
+      groupId_.id(),
       options_.loadQuantum());
   requests_.back().stream = stream.get();
   return stream;
@@ -189,7 +189,7 @@ void DirectBufferedInput::readRegion(
       input_,
       ioStats_,
       fsStats_,
-      groupId_,
+      groupId_.id(),
       requests,
       pool_,
       options_.loadQuantum());
@@ -235,7 +235,7 @@ std::shared_ptr<DirectCoalescedLoad> DirectBufferedInput::coalescedLoad(
   return streamToCoalescedLoad_.withWLock(
       [&](auto& loads) -> std::shared_ptr<DirectCoalescedLoad> {
         auto it = loads.find(stream);
-        if (it == loads.end()) {
+        if (it == loads.cend()) {
           return nullptr;
         }
         auto load = std::move(it->second);
@@ -254,7 +254,7 @@ std::unique_ptr<SeekableInputStream> DirectBufferedInput::read(
       ioStats_.get(),
       Region{offset, length},
       input_,
-      fileNum_,
+      fileNum_.id(),
       nullptr,
       TrackingId(),
       0,
@@ -286,10 +286,11 @@ std::vector<cache::CachePin> DirectCoalescedLoad::loadData(bool prefetch) {
   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))));
+      buffers.push_back(
+          folly::Range<char*>(
+              nullptr,
+              reinterpret_cast<char*>(
+                  static_cast<uint64_t>(region.offset - lastEnd))));
       overread += buffers.back().size();
     }
 
@@ -342,7 +343,7 @@ int32_t DirectCoalescedLoad::getData(
       requests_.begin(), requests_.end(), offset, [](auto& x, auto offset) {
         return x.region.offset < offset;
       });
-  if (it == requests_.end() || it->region.offset != offset) {
+  if (it == requests_.cend() || it->region.offset != offset) {
     return 0;
   }
   data = std::move(it->data);
diff --git a/velox/dwio/common/DirectBufferedInput.h b/velox/dwio/common/DirectBufferedInput.h
index 4485f2c4cd81..ae1ff124ef73 100644
--- a/velox/dwio/common/DirectBufferedInput.h
+++ b/velox/dwio/common/DirectBufferedInput.h
@@ -71,9 +71,10 @@ class DirectCoalescedLoad : public cache::CoalescedLoad {
         pool_(pool) {
     VELOX_DCHECK_NOT_NULL(pool_);
     VELOX_DCHECK(
-        std::is_sorted(requests.begin(), requests.end(), [](auto* x, auto* y) {
-          return x->region.offset < y->region.offset;
-        }));
+        std::is_sorted(
+            requests.cbegin(), requests.cend(), [](auto* x, auto* y) {
+              return x->region.offset < y->region.offset;
+            }));
     requests_.reserve(requests.size());
     for (auto i = 0; i < requests.size(); ++i) {
       requests_.push_back(std::move(*requests[i]));
@@ -117,22 +118,26 @@ class DirectBufferedInput : public BufferedInput {
   DirectBufferedInput(
       std::shared_ptr<ReadFile> readFile,
       const MetricsLogPtr& metricsLog,
-      uint64_t fileNum,
+      StringIdLease fileNum,
       std::shared_ptr<cache::ScanTracker> tracker,
-      uint64_t groupId,
+      StringIdLease groupId,
       std::shared_ptr<IoStatistics> ioStats,
       std::shared_ptr<filesystems::File::IoStats> fsStats,
       folly::Executor* executor,
-      const io::ReaderOptions& readerOptions)
+      const io::ReaderOptions& readerOptions,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {})
       : BufferedInput(
             std::move(readFile),
             readerOptions.memoryPool(),
             metricsLog,
             ioStats.get(),
-            fsStats.get()),
-        fileNum_(fileNum),
+            fsStats.get(),
+            kMaxMergeDistance,
+            std::nullopt,
+            std::move(fileReadOps)),
+        fileNum_(std::move(fileNum)),
         tracker_(std::move(tracker)),
-        groupId_(groupId),
+        groupId_(std::move(groupId)),
         ioStats_(std::move(ioStats)),
         fsStats_(std::move(fsStats)),
         executor_(executor),
@@ -166,7 +171,7 @@ class DirectBufferedInput : public BufferedInput {
   void setNumStripes(int32_t numStripes) override {
     auto* stats = tracker_->fileGroupStats();
     if (stats) {
-      stats->recordFile(fileNum_, groupId_, numStripes);
+      stats->recordFile(fileNum_.id(), groupId_.id(), numStripes);
     }
   }
 
@@ -208,17 +213,17 @@ class DirectBufferedInput : public BufferedInput {
   /// Constructor used by clone().
   DirectBufferedInput(
       std::shared_ptr<ReadFileInputStream> input,
-      uint64_t fileNum,
+      StringIdLease fileNum,
       std::shared_ptr<cache::ScanTracker> tracker,
-      uint64_t groupId,
+      StringIdLease groupId,
       std::shared_ptr<IoStatistics> ioStats,
       std::shared_ptr<filesystems::File::IoStats> fsStats,
       folly::Executor* executor,
       const io::ReaderOptions& readerOptions)
       : BufferedInput(std::move(input), readerOptions.memoryPool()),
-        fileNum_(fileNum),
+        fileNum_(std::move(fileNum)),
         tracker_(std::move(tracker)),
-        groupId_(groupId),
+        groupId_(std::move(groupId)),
         ioStats_(std::move(ioStats)),
         fsStats_(std::move(fsStats)),
         executor_(executor),
@@ -261,9 +266,9 @@ class DirectBufferedInput : public BufferedInput {
     }
   };
 
-  const uint64_t fileNum_;
+  const StringIdLease fileNum_;
   const std::shared_ptr<cache::ScanTracker> tracker_;
-  const uint64_t groupId_;
+  const StringIdLease groupId_;
   const std::shared_ptr<IoStatistics> ioStats_;
   const std::shared_ptr<filesystems::File::IoStats> fsStats_;
   folly::Executor* const executor_;
diff --git a/velox/dwio/common/DirectInputStream.cpp b/velox/dwio/common/DirectInputStream.cpp
index 68173b40f259..8840768854c0 100644
--- a/velox/dwio/common/DirectInputStream.cpp
+++ b/velox/dwio/common/DirectInputStream.cpp
@@ -91,8 +91,8 @@ bool DirectInputStream::SkipInt64(int64_t count) {
   return false;
 }
 
-google::protobuf::int64 DirectInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(offsetInRegion_);
+int64_t DirectInputStream::ByteCount() const {
+  return static_cast<int64_t>(offsetInRegion_);
 }
 
 void DirectInputStream::seekToPosition(PositionProvider& seekPosition) {
diff --git a/velox/dwio/common/DirectInputStream.h b/velox/dwio/common/DirectInputStream.h
index 3d75b4459568..45fb465f37ab 100644
--- a/velox/dwio/common/DirectInputStream.h
+++ b/velox/dwio/common/DirectInputStream.h
@@ -44,7 +44,7 @@ class DirectInputStream : public SeekableInputStream {
   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;
+  int64_t ByteCount() const override;
 
   void seekToPosition(PositionProvider& position) override;
   std::string getName() const override;
diff --git a/velox/dwio/common/ErrorTolerance.h b/velox/dwio/common/ErrorTolerance.h
index db186084cea1..4f2aafd6111f 100644
--- a/velox/dwio/common/ErrorTolerance.h
+++ b/velox/dwio/common/ErrorTolerance.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 {
 
 /**
  * Error tolerance level for readers
@@ -63,7 +60,4 @@ struct ErrorTolerance {
   }
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/FileSink.cpp b/velox/dwio/common/FileSink.cpp
index 3dcc44186182..6654dfb64070 100644
--- a/velox/dwio/common/FileSink.cpp
+++ b/velox/dwio/common/FileSink.cpp
@@ -26,8 +26,8 @@
 
 namespace facebook::velox::dwio::common {
 namespace {
-constexpr std::string_view kFileScheme("file:");
-constexpr std::string_view kFileSep("/");
+constexpr std::string_view kFileScheme{"file:"};
+constexpr char kFileSep{'/'};
 
 std::vector<FileSink::Factory>& factories() {
   static std::vector<FileSink::Factory> factories;
@@ -37,10 +37,10 @@ std::vector<FileSink::Factory>& factories() {
 std::unique_ptr<FileSink> localFileSink(
     const std::string& filePath,
     const FileSink::Options& options) {
-  if (filePath.find(kFileScheme) == 0) {
+  if (filePath.starts_with(kFileScheme)) {
     return std::make_unique<LocalFileSink>(filePath.substr(5), options);
   }
-  if (filePath.find(kFileSep) == 0) {
+  if (filePath.starts_with(kFileSep)) {
     return std::make_unique<LocalFileSink>(filePath, options);
   }
   return nullptr;
diff --git a/velox/dwio/common/FileSink.h b/velox/dwio/common/FileSink.h
index 6fe559790279..914d06055f1a 100644
--- a/velox/dwio/common/FileSink.h
+++ b/velox/dwio/common/FileSink.h
@@ -46,6 +46,7 @@ class FileSink : public Closeable {
     memory::MemoryPool* pool{nullptr};
     MetricsLogPtr metricLogger{MetricsLog::voidLog()};
     IoStatistics* stats{nullptr};
+    filesystems::File::IoStats* fileSystemStats{nullptr};
   };
 
   FileSink(std::string name, const Options& options)
@@ -54,6 +55,7 @@ class FileSink : public Closeable {
         pool_(options.pool),
         metricLogger_{options.metricLogger},
         stats_{options.stats},
+        fileSystemStats_{options.fileSystemStats},
         size_{0} {}
 
   ~FileSink() override {
@@ -117,6 +119,7 @@ class FileSink : public Closeable {
   memory::MemoryPool* const pool_;
   const MetricsLogPtr metricLogger_;
   IoStatistics* const stats_;
+  filesystems::File::IoStats* const fileSystemStats_;
 
   uint64_t size_;
 };
diff --git a/velox/dwio/common/FlatMapHelper.cpp b/velox/dwio/common/FlatMapHelper.cpp
index 5d48887af475..e392bf60a65f 100644
--- a/velox/dwio/common/FlatMapHelper.cpp
+++ b/velox/dwio/common/FlatMapHelper.cpp
@@ -21,11 +21,20 @@
 namespace facebook::velox::dwio::common::flatmap {
 namespace detail {
 
-void reset(VectorPtr& vector, vector_size_t size, bool hasNulls) {
+void reset(
+    VectorPtr& vector,
+    VectorEncoding::Simple desiredEncoding,
+    vector_size_t size,
+    bool hasNulls) {
   if (!vector) {
     return;
   }
 
+  if (vector->encoding() != desiredEncoding) {
+    vector.reset();
+    return;
+  }
+
   if (vector.use_count() > 1) {
     vector.reset();
     return;
@@ -39,6 +48,9 @@ void reset(VectorPtr& vector, vector_size_t size, bool hasNulls) {
     }
   }
   vector->resize(size);
+  // Reside BaseVector::length_ as it will be updated in the subsequent copy()
+  // calls.
+  vector->BaseVector::resize(0);
 }
 
 void initializeStringVector(
@@ -162,7 +174,7 @@ void initializeVectorImpl<TypeKind::ARRAY>(
     }
   }
 
-  detail::reset(vector, size, hasNulls);
+  detail::reset(vector, VectorEncoding::Simple::ARRAY, size, hasNulls);
   VectorPtr origElementsVector;
   if (vector) {
     auto& arrayVector = dynamic_cast<ArrayVector&>(*vector);
@@ -226,7 +238,7 @@ void initializeMapVector(
     size = sizeOverride.value();
   }
 
-  detail::reset(vector, size, hasNulls);
+  detail::reset(vector, VectorEncoding::Simple::MAP, size, hasNulls);
   VectorPtr origKeysVector;
   VectorPtr origValuesVector;
   if (vector) {
@@ -298,7 +310,7 @@ void initializeVectorImpl<TypeKind::ROW>(
     }
   }
 
-  detail::reset(vector, size, hasNulls);
+  detail::reset(vector, VectorEncoding::Simple::ROW, size, hasNulls);
   std::vector<VectorPtr> origChildren;
   if (vector) {
     auto& rowVector = dynamic_cast<RowVector&>(*vector);
@@ -359,8 +371,9 @@ vector_size_t copyNulls(
   vector_size_t nulls = 0;
   // it's assumed that initVector is called before calling this method to
   // properly allocate/clear nulls buffer. So we only need to check against
-  // target vector here.
-  target.resize(targetIndex + count, false);
+  // target vector here.  We only call BaseVector::resize here to make sure
+  // BaseVector::size() is only updated.
+  target.BaseVector::resize(targetIndex + count, false);
   if (target.mayHaveNulls()) {
     auto tgtNulls = const_cast<uint64_t*>(target.rawNulls());
     if (source.isConstantEncoding()) {
@@ -485,7 +498,10 @@ vector_size_t copyOffsets(
     vector_size_t sourceIndex,
     vector_size_t count,
     vector_size_t& childOffset) {
-  target.resize(targetIndex + count);
+  // Its expected that initVector is called before calling this method so the
+  // offsets and sizes buffers are properly allocated. We only call
+  // BaseVector::resize here to make sure BaseVector::size() is only updated.
+  target.BaseVector::resize(targetIndex + count);
   auto tgtOffsets = const_cast<vector_size_t*>(target.rawOffsets());
   auto tgtSizes = const_cast<vector_size_t*>(target.rawSizes());
   auto srcSizes = source.rawSizes();
@@ -701,8 +717,9 @@ bool copyNull(
     vector_size_t sourceIndex) {
   // it's assumed that initVector is called before calling this method to
   // properly allocate/clear nulls buffer. So we only need to check against
-  // target vector here.
-  target.resize(targetIndex + 1, false);
+  // target vector here. We only call BaseVector::resize here to make sure
+  // BaseVector::size() is only updated.
+  target.BaseVector::resize(targetIndex + 1, false);
   if (target.mayHaveNulls()) {
     bool srcIsNull =
         (source.isConstantEncoding() ||
@@ -792,7 +809,10 @@ vector_size_t copyOffset(
     const T& source,
     vector_size_t sourceIndex,
     vector_size_t& childOffset) {
-  target.resize(targetIndex + 1);
+  // Its expected that initVector is called before calling this method so the
+  // offsets and sizes buffers are properly allocated. We only call
+  // BaseVector::resize here to make sure BaseVector::size() is only updated.
+  target.BaseVector::resize(targetIndex + 1);
   auto tgtSizes = const_cast<vector_size_t*>(target.rawSizes());
   childOffset = nextChildOffset(target, targetIndex);
   const_cast<vector_size_t*>(target.rawOffsets())[targetIndex] = childOffset;
diff --git a/velox/dwio/common/FlatMapHelper.h b/velox/dwio/common/FlatMapHelper.h
index ac97b5c3b134..404e7891a089 100644
--- a/velox/dwio/common/FlatMapHelper.h
+++ b/velox/dwio/common/FlatMapHelper.h
@@ -24,7 +24,11 @@ namespace facebook::velox::dwio::common::flatmap {
 namespace detail {
 
 // Reset vector with the desired size/hasNulls properties
-void reset(VectorPtr& vector, vector_size_t size, bool hasNulls);
+void reset(
+    VectorPtr& vector,
+    VectorEncoding::Simple desiredEncoding,
+    vector_size_t size,
+    bool hasNulls);
 
 // Reset vector smart pointer if any of the buffers is not single referenced.
 template <typename... T>
@@ -39,6 +43,14 @@ void resetIfNotWritable(VectorPtr& vector, const T&... buffer) {
 
 } // namespace detail
 
+// Output type of flat map column reader, indicates the in memory representation
+// the flat map should be read into.
+enum class FlatMapOutput : uint8_t {
+  kMap = 0, // MapVector
+  kStruct = 1, // RowVector
+  kFlatMap = 2, // FlatMapVector
+};
+
 // Struct for keeping track flatmap key stream metrics.
 // Used by keySelectionCallback_ in FlatMapColumnReader
 struct FlatMapKeySelectionStats {
@@ -55,7 +67,7 @@ void initializeFlatVector(
     vector_size_t size,
     bool hasNulls,
     std::vector<BufferPtr>&& stringBuffers = {}) {
-  detail::reset(vector, size, hasNulls);
+  detail::reset(vector, VectorEncoding::Simple::FLAT, size, hasNulls);
   if (vector) {
     auto& flatVector = dynamic_cast<FlatVector<T>&>(*vector);
     detail::resetIfNotWritable(vector, flatVector.nulls(), flatVector.values());
@@ -122,6 +134,7 @@ class KeyValue {
   const T& get() const {
     return value_;
   }
+
   std::size_t hash() const {
     return h_;
   }
@@ -223,14 +236,14 @@ KeyPredicate<T> prepareKeyPredicate(std::string_view expression) {
   // You cannot mix allow key and reject key.
   VELOX_CHECK(
       modes.empty() ||
-      std::all_of(modes.begin(), modes.end(), [&modes](const auto& v) {
+      std::all_of(modes.cbegin(), modes.cend(), [&modes](const auto& v) {
         return v == modes.front();
       }));
 
   auto mode = modes.empty() ? KeyProjectionMode::ALLOW : modes.front();
 
   return KeyPredicate<T>(
-      mode, typename KeyPredicate<T>::Lookup(keys.begin(), keys.end()));
+      mode, typename KeyPredicate<T>::Lookup(keys.cbegin(), keys.cend()));
 }
 
 } // namespace facebook::velox::dwio::common::flatmap
diff --git a/velox/dwio/common/FormatData.h b/velox/dwio/common/FormatData.h
index 4e8a5548fb06..d045f36cb4a2 100644
--- a/velox/dwio/common/FormatData.h
+++ b/velox/dwio/common/FormatData.h
@@ -131,8 +131,8 @@ class FormatData {
 /// Base class for format-specific reader initialization arguments.
 class FormatParams {
  public:
-  explicit FormatParams(memory::MemoryPool& pool, ColumnReaderStatistics& stats)
-      : pool_(pool), stats_(stats) {}
+  FormatParams(memory::MemoryPool& pool, ColumnReaderStatistics& stats)
+      : pool_(&pool), stats_(&stats) {}
 
   virtual ~FormatParams() = default;
 
@@ -143,16 +143,16 @@ class FormatParams {
       const velox::common::ScanSpec& scanSpec) = 0;
 
   memory::MemoryPool& pool() {
-    return pool_;
+    return *pool_;
   }
 
   ColumnReaderStatistics& runtimeStatistics() {
-    return stats_;
+    return *stats_;
   }
 
  private:
-  memory::MemoryPool& pool_;
-  ColumnReaderStatistics& stats_;
+  memory::MemoryPool* const pool_;
+  ColumnReaderStatistics* const stats_;
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/InputStream.cpp b/velox/dwio/common/InputStream.cpp
index cc20a5fc55e5..c25a7b0be772 100644
--- a/velox/dwio/common/InputStream.cpp
+++ b/velox/dwio/common/InputStream.cpp
@@ -64,8 +64,10 @@ ReadFileInputStream::ReadFileInputStream(
     std::shared_ptr<velox::ReadFile> readFile,
     const MetricsLogPtr& metricsLog,
     IoStatistics* stats,
-    filesystems::File::IoStats* fsStats)
+    filesystems::File::IoStats* fsStats,
+    folly::F14FastMap<std::string, std::string> fileReadOps)
     : InputStream(readFile->getName(), metricsLog, stats, fsStats),
+      fileStorageContext_(fsStats, std::move(fileReadOps)),
       readFile_(std::move(readFile)) {}
 
 void ReadFileInputStream::read(
@@ -79,7 +81,7 @@ void ReadFileInputStream::read(
   std::string_view readData;
   {
     MicrosecondTimer timer(&readTimeUs);
-    readData = readFile_->pread(offset, length, buf, fsStats_);
+    readData = readFile_->pread(offset, length, buf, fileStorageContext_);
   }
   if (stats_) {
     stats_->incRawBytesRead(length);
@@ -102,7 +104,7 @@ void ReadFileInputStream::read(
     LogType logType) {
   const int64_t bufferSize = totalBufferSize(buffers);
   logRead(offset, bufferSize, logType);
-  const auto size = readFile_->preadv(offset, buffers, fsStats_);
+  const auto size = readFile_->preadv(offset, buffers, fileStorageContext_);
   VELOX_CHECK_EQ(
       size,
       bufferSize,
@@ -119,7 +121,7 @@ folly::SemiFuture<uint64_t> ReadFileInputStream::readAsync(
     LogType logType) {
   const int64_t bufferSize = totalBufferSize(buffers);
   logRead(offset, bufferSize, logType);
-  return readFile_->preadvAsync(offset, buffers, fsStats_);
+  return readFile_->preadvAsync(offset, buffers, fileStorageContext_);
 }
 
 bool ReadFileInputStream::hasReadAsync() const {
@@ -138,7 +140,7 @@ void ReadFileInputStream::vread(
       [&](size_t acc, const auto& r) { return acc + r.length; });
   logRead(regions[0].offset, length, purpose);
   auto readStartMicros = getCurrentTimeMicro();
-  readFile_->preadv(regions, iobufs, fsStats_);
+  readFile_->preadv(regions, iobufs, fileStorageContext_);
   if (stats_) {
     stats_->incRawBytesRead(length);
     stats_->incTotalScanTime((getCurrentTimeMicro() - readStartMicros) * 1000);
diff --git a/velox/dwio/common/InputStream.h b/velox/dwio/common/InputStream.h
index 30210cb31a96..34dc948550c0 100644
--- a/velox/dwio/common/InputStream.h
+++ b/velox/dwio/common/InputStream.h
@@ -16,10 +16,6 @@
 
 #pragma once
 
-#include <array>
-#include <atomic>
-#include <condition_variable>
-#include <cstddef>
 #include <cstdint>
 #include <exception>
 #include <functional>
@@ -30,6 +26,7 @@
 #include <utility>
 #include <vector>
 
+#include <folly/container/F14Map.h>
 #include "velox/common/file/File.h"
 #include "velox/common/file/Region.h"
 #include "velox/common/io/IoStatistics.h"
@@ -147,7 +144,8 @@ class ReadFileInputStream final : public InputStream {
       std::shared_ptr<velox::ReadFile>,
       const MetricsLogPtr& metricsLog = MetricsLog::voidLog(),
       IoStatistics* stats = nullptr,
-      filesystems::File::IoStats* fsStats = nullptr);
+      filesystems::File::IoStats* fsStats = nullptr,
+      folly::F14FastMap<std::string, std::string> fileReadOps = {});
 
   ~ReadFileInputStream() override = default;
 
@@ -183,6 +181,7 @@ class ReadFileInputStream final : public InputStream {
   }
 
  private:
+  FileStorageContext fileStorageContext_;
   std::shared_ptr<velox::ReadFile> readFile_;
 };
 
diff --git a/velox/dwio/common/MeasureTime.h b/velox/dwio/common/MeasureTime.h
index c4eaf1281f37..1b7de305a032 100644
--- a/velox/dwio/common/MeasureTime.h
+++ b/velox/dwio/common/MeasureTime.h
@@ -20,10 +20,7 @@
 #include <functional>
 #include <optional>
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class MeasureTime {
  public:
@@ -61,7 +58,4 @@ inline std::optional<MeasureTime> measureTimeIfCallback(
   return std::nullopt;
 }
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/MetadataFilter.cpp b/velox/dwio/common/MetadataFilter.cpp
index 374a2d861082..88e3a5481e28 100644
--- a/velox/dwio/common/MetadataFilter.cpp
+++ b/velox/dwio/common/MetadataFilter.cpp
@@ -18,6 +18,7 @@
 
 #include <folly/container/F14Map.h>
 #include "velox/dwio/common/ScanSpec.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 
 namespace facebook::velox::common {
@@ -67,86 +68,118 @@ class MetadataFilter::LeafNode : public Node {
   std::unique_ptr<Filter> filter_;
 };
 
-struct MetadataFilter::AndNode : Node {
+struct MetadataFilter::ConditionNode : Node {
   static std::unique_ptr<Node> create(
-      std::unique_ptr<Node> lhs,
-      std::unique_ptr<Node> rhs) {
-    if (!lhs) {
-      return rhs;
-    }
-    if (!rhs) {
-      return lhs;
+      bool conjuction,
+      std::vector<std::unique_ptr<Node>> args);
+
+  static std::unique_ptr<Node> fromExpression(
+      const std::vector<core::TypedExprPtr>& inputs,
+      core::ExpressionEvaluator* evaluator,
+      bool conjunction,
+      bool negated) {
+    conjunction = negated ? !conjunction : conjunction;
+    std::vector<std::unique_ptr<Node>> args;
+    args.reserve(inputs.size());
+    for (const auto& input : inputs) {
+      auto node = Node::fromExpression(*input, evaluator, negated);
+      if (node) {
+        args.push_back(std::move(node));
+      } else if (!conjunction) {
+        return nullptr;
+      }
     }
-    return std::make_unique<AndNode>(std::move(lhs), std::move(rhs));
+    return create(conjunction, std::move(args));
   }
 
-  AndNode(std::unique_ptr<Node> lhs, std::unique_ptr<Node> rhs)
-      : lhs_(std::move(lhs)), rhs_(std::move(rhs)) {}
+  explicit ConditionNode(std::vector<std::unique_ptr<Node>> args)
+      : args_{std::move(args)} {}
 
-  void addToScanSpec(ScanSpec& scanSpec) const override {
-    lhs_->addToScanSpec(scanSpec);
-    rhs_->addToScanSpec(scanSpec);
-  }
-
-  uint64_t* eval(LeafResults& leafResults, int size) const override {
-    auto* l = lhs_->eval(leafResults, size);
-    auto* r = rhs_->eval(leafResults, size);
-    if (!l) {
-      return r;
-    }
-    if (!r) {
-      return l;
+  void addToScanSpec(ScanSpec& scanSpec) const final {
+    for (const auto& arg : args_) {
+      arg->addToScanSpec(scanSpec);
     }
-    bits::orBits(l, r, 0, size);
-    return l;
   }
 
-  std::string toString() const override {
-    return "and(" + lhs_->toString() + "," + rhs_->toString() + ")";
+ protected:
+  std::string ToStringImpl(std::string_view prefix) const {
+    std::string result{prefix};
+    for (size_t i = 0; i < args_.size(); ++i) {
+      if (i != 0) {
+        result += ",";
+      }
+      result += args_[i]->toString();
+    }
+    result += ")";
+    return result;
   }
 
- private:
-  std::unique_ptr<Node> lhs_;
-  std::unique_ptr<Node> rhs_;
+  std::vector<std::unique_ptr<Node>> args_;
 };
 
-struct MetadataFilter::OrNode : Node {
-  static std::unique_ptr<Node> create(
-      std::unique_ptr<Node> lhs,
-      std::unique_ptr<Node> rhs) {
-    if (!lhs || !rhs) {
-      return nullptr;
+struct MetadataFilter::AndNode final : ConditionNode {
+  using ConditionNode::ConditionNode;
+
+  uint64_t* eval(LeafResults& leafResults, int size) const final {
+    uint64_t* result = nullptr;
+    for (const auto& arg : args_) {
+      auto* a = arg->eval(leafResults, size);
+      if (!a) {
+        continue;
+      }
+      if (!result) {
+        result = a;
+      } else {
+        bits::orBits(result, a, 0, size);
+      }
     }
-    return std::make_unique<OrNode>(std::move(lhs), std::move(rhs));
+    return result;
   }
 
-  OrNode(std::unique_ptr<Node> lhs, std::unique_ptr<Node> rhs)
-      : lhs_(std::move(lhs)), rhs_(std::move(rhs)) {}
-
-  void addToScanSpec(ScanSpec& scanSpec) const override {
-    lhs_->addToScanSpec(scanSpec);
-    rhs_->addToScanSpec(scanSpec);
+  std::string toString() const final {
+    return ToStringImpl("and(");
   }
+};
 
-  uint64_t* eval(LeafResults& leafResults, int size) const override {
-    auto* l = lhs_->eval(leafResults, size);
-    auto* r = rhs_->eval(leafResults, size);
-    if (!l || !r) {
-      return nullptr;
+struct MetadataFilter::OrNode final : ConditionNode {
+  using ConditionNode::ConditionNode;
+
+  uint64_t* eval(LeafResults& leafResults, int size) const final {
+    uint64_t* result = nullptr;
+    for (const auto& arg : args_) {
+      auto* a = arg->eval(leafResults, size);
+      if (!a) {
+        return nullptr;
+      }
+      if (!result) {
+        result = a;
+      } else {
+        bits::andBits(result, a, 0, size);
+      }
     }
-    bits::andBits(l, r, 0, size);
-    return l;
+    return result;
   }
 
-  std::string toString() const override {
-    return "or(" + lhs_->toString() + "," + rhs_->toString() + ")";
+  std::string toString() const final {
+    return ToStringImpl("or(");
   }
-
- private:
-  std::unique_ptr<Node> lhs_;
-  std::unique_ptr<Node> rhs_;
 };
 
+std::unique_ptr<MetadataFilter::Node> MetadataFilter::ConditionNode::create(
+    bool conjunction,
+    std::vector<std::unique_ptr<Node>> args) {
+  if (args.empty()) {
+    return nullptr;
+  }
+  if (args.size() == 1) {
+    return std::move(args[0]);
+  }
+  if (conjunction) {
+    return std::make_unique<AndNode>(std::move(args));
+  }
+  return std::make_unique<OrNode>(std::move(args));
+}
+
 namespace {
 
 const core::CallTypedExpr* asCall(const core::ITypedExpr* expr) {
@@ -163,29 +196,26 @@ std::unique_ptr<MetadataFilter::Node> MetadataFilter::Node::fromExpression(
   if (!call) {
     return nullptr;
   }
-  if (call->name() == "and") {
-    auto lhs = fromExpression(*call->inputs()[0], evaluator, negated);
-    auto rhs = fromExpression(*call->inputs()[1], evaluator, negated);
-    return negated ? OrNode::create(std::move(lhs), std::move(rhs))
-                   : AndNode::create(std::move(lhs), std::move(rhs));
+  if (call->name() == expression::kAnd) {
+    return ConditionNode::fromExpression(
+        call->inputs(), evaluator, true, negated);
   }
-  if (call->name() == "or") {
-    auto lhs = fromExpression(*call->inputs()[0], evaluator, negated);
-    auto rhs = fromExpression(*call->inputs()[1], evaluator, negated);
-    return negated ? AndNode::create(std::move(lhs), std::move(rhs))
-                   : OrNode::create(std::move(lhs), std::move(rhs));
+  if (call->name() == expression::kOr) {
+    return ConditionNode::fromExpression(
+        call->inputs(), evaluator, false, negated);
   }
   if (call->name() == "not") {
     return fromExpression(*call->inputs()[0], evaluator, !negated);
   }
   try {
-    Subfield subfield;
-    auto filter =
+    auto subfieldAndFilter =
         exec::ExprToSubfieldFilterParser::getInstance()
-            ->leafCallToSubfieldFilter(*call, subfield, evaluator, negated);
-    if (!filter) {
+            ->leafCallToSubfieldFilter(*call, evaluator, negated);
+    if (!subfieldAndFilter.has_value()) {
       return nullptr;
     }
+
+    auto& [subfield, filter] = subfieldAndFilter.value();
     VELOX_CHECK(
         subfield.valid(),
         "Invalid subfield from expression: {}",
diff --git a/velox/dwio/common/MetadataFilter.h b/velox/dwio/common/MetadataFilter.h
index 62b604b14407..d626bbdd9675 100644
--- a/velox/dwio/common/MetadataFilter.h
+++ b/velox/dwio/common/MetadataFilter.h
@@ -50,6 +50,7 @@ class MetadataFilter {
 
  private:
   struct Node;
+  struct ConditionNode;
   struct AndNode;
   struct OrNode;
 
diff --git a/velox/dwio/common/MetricsLog.h b/velox/dwio/common/MetricsLog.h
index 555e92f24d63..db54c36821e6 100644
--- a/velox/dwio/common/MetricsLog.h
+++ b/velox/dwio/common/MetricsLog.h
@@ -19,15 +19,12 @@
 #include "velox/dwio/common/FilterNode.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class MetricsLog {
  public:
   static constexpr std::string_view LIB_VERSION_STRING{"1.1"};
-  static constexpr folly::StringPiece WRITE_OPERATION{"WRITE"};
+  static constexpr std::string_view WRITE_OPERATION{"WRITE"};
 
   enum class MetricsType {
     HEADER,
@@ -128,8 +125,8 @@ class MetricsLog {
   virtual void logFileClose(const FileCloseMetrics& /* metrics */) const {}
 
   static std::shared_ptr<const MetricsLog> voidLog() {
-    static std::shared_ptr<const MetricsLog> log{new MetricsLog("")};
-    return log;
+    static const MetricsLog kInstance{{}};
+    return {std::shared_ptr<const MetricsLog>{}, &kInstance};
   }
 
  protected:
@@ -178,7 +175,4 @@ void registerMetricsLogFactory(std::shared_ptr<DwioMetricsLogFactory> factory);
 
 DwioMetricsLogFactory& getMetricsLogFactory();
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/OnDemandUnitLoader.cpp b/velox/dwio/common/OnDemandUnitLoader.cpp
index d4ef4f0a5ef2..6a5616a31e53 100644
--- a/velox/dwio/common/OnDemandUnitLoader.cpp
+++ b/velox/dwio/common/OnDemandUnitLoader.cpp
@@ -15,12 +15,12 @@
  */
 
 #include "velox/dwio/common/OnDemandUnitLoader.h"
+#include "velox/common/time/Timer.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;
 
@@ -42,6 +42,7 @@ class OnDemandUnitLoader : public UnitLoader {
   LoadUnit& getLoadedUnit(uint32_t unit) override {
     VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
 
+    processedUnits_.insert(unit);
     if (loadedUnit_.has_value()) {
       if (loadedUnit_.value() == unit) {
         return *loadUnits_[unit];
@@ -51,11 +52,14 @@ class OnDemandUnitLoader : public UnitLoader {
       loadedUnit_.reset();
     }
 
+    uint64_t unitLoadNanos{0};
     {
+      NanosecondTimer timer{&unitLoadNanos};
       auto measure = measureTimeIfCallback(blockedOnIoCallback_);
       loadUnits_[unit]->load();
     }
     loadedUnit_ = unit;
+    unitLoadNanos_ += unitLoadNanos;
 
     return *loadUnits_[unit];
   }
@@ -73,11 +77,28 @@ class OnDemandUnitLoader : public UnitLoader {
         rowOffsetInUnit, loadUnits_[unit]->getNumRows(), "Row out of range");
   }
 
+  UnitLoaderStats stats() override {
+    UnitLoaderStats stats;
+    stats.addCounter("processedUnits", RuntimeCounter(processedUnits_.size()));
+    stats.addCounter(
+        "unitLoadNanos",
+        RuntimeCounter(
+            unitLoadNanos_ > std::numeric_limits<int64_t>::max()
+                ? std::numeric_limits<int64_t>::max()
+                : unitLoadNanos_,
+            RuntimeCounter::Unit::kNanos));
+    return stats;
+  }
+
  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_;
+
+  // Stats
+  std::unordered_set<uint32_t> processedUnits_;
+  uint64_t unitLoadNanos_{0};
 };
 
 } // namespace
diff --git a/velox/dwio/common/Options.h b/velox/dwio/common/Options.h
index 0526cfbd9dd7..ccfd6e78eb62 100644
--- a/velox/dwio/common/Options.h
+++ b/velox/dwio/common/Options.h
@@ -17,7 +17,8 @@
 #pragma once
 
 #include <limits>
-#include <unordered_set>
+#include <string>
+#include <unordered_map>
 
 #include <folly/Executor.h>
 #include "velox/common/base/RandomUtil.h"
@@ -51,6 +52,7 @@ enum class FileFormat {
   NIMBLE = 8,
   ORC = 9,
   SST = 10, // rocksdb sst format
+  FLUX = 11,
 };
 
 FileFormat toFileFormat(std::string_view s);
@@ -72,7 +74,34 @@ enum class SerDeSeparator {
 
 class SerDeOptions {
  public:
+  /// The following members control how data is separated in TEXT format files:
+  ///
+  /// - 'separators': An array of separator characters used to delimit columns
+  ///   and nested data.
+  ///     - 'separators[0]' defines the delimiter that separates top-level
+  ///     columns.
+  ///     - 'separators[1 to depth_-1]' defines the delimiters that separate
+  ///     nested data within a ComplexType column.
+  /// - 'newLine': The character used to separate rows in the file.
+  ///
+  /// Suppose we have a schema: ROW(MAP(VARCHAR(), ARRAY(BIGINT())), BOOLEAN())
+  /// With the following configuration:
+  ///   - separators = [',', '@', ':', '#]
+  ///   - newLine = '\n'
+  ///   - nullString = "NULL"
+  ///
+  /// With the following data to be written:
+  ///   - row1: {key1:[10, 20, 30], key2:[40, 50, 60]}, true
+  ///   - row2: {key3:[100, 2, 30], key4:[80, 40, 45]}, true
+  ///
+  /// A sample text file with the 2 rows of data above would look like this:
+  /// key1:10#20#30@key2:40#50#60,true\n
+  /// key3:100#2#30@key4:80#40#45,true\n
+
   std::array<uint8_t, 8> separators;
+  uint8_t newLine;
+
+  /// Null values are represented by 'nullString'
   std::string nullString;
   bool lastColumnTakesRest;
   uint8_t escapeChar;
@@ -88,8 +117,10 @@ class SerDeOptions {
       uint8_t collectionDelim = '\2',
       uint8_t mapKeyDelim = '\3',
       uint8_t escape = '\\',
-      bool isEscapedFlag = false)
+      bool isEscapedFlag = false,
+      uint8_t newLine = '\n')
       : separators{{fieldDelim, collectionDelim, mapKeyDelim, 4, 5, 6, 7, 8}},
+        newLine(newLine),
         nullString("\\N"),
         lastColumnTakesRest(false),
         escapeChar(escape),
@@ -253,6 +284,22 @@ class RowReaderOptions {
     scanSpec_ = std::move(scanSpec);
   }
 
+  folly::Executor* ioExecutor() const {
+    return ioExecutor_;
+  }
+
+  void setIOExecutor(folly::Executor* const ioExecutor) {
+    ioExecutor_ = ioExecutor;
+  }
+
+  const size_t parallelUnitLoadCount() const {
+    return parallelUnitLoadCount_;
+  }
+
+  void setParallelUnitLoadCount(size_t parallelUnitLoadCount) {
+    parallelUnitLoadCount_ = parallelUnitLoadCount;
+  }
+
   const std::shared_ptr<velox::common::MetadataFilter>& metadataFilter() const {
     return metadataFilter_;
   }
@@ -267,8 +314,8 @@ class RowReaderOptions {
           flatmapNodeIdsAsStruct) {
     VELOX_CHECK(
         std::all_of(
-            flatmapNodeIdsAsStruct.begin(),
-            flatmapNodeIdsAsStruct.end(),
+            flatmapNodeIdsAsStruct.cbegin(),
+            flatmapNodeIdsAsStruct.cend(),
             [](const auto& kv) { return !kv.second.empty(); }),
         "To use struct encoding for flatmap, keys to project must be specified");
     flatmapNodeIdAsStruct_ = std::move(flatmapNodeIdsAsStruct);
@@ -279,6 +326,10 @@ class RowReaderOptions {
     return flatmapNodeIdAsStruct_;
   }
 
+  void setPreserveFlatMapsInMemory(bool preserveFlatMapsInMemory) {
+    preserveFlatMapsInMemory_ = preserveFlatMapsInMemory;
+  }
+
   void setDecodingExecutor(std::shared_ptr<folly::Executor> executor) {
     decodingExecutor_ = executor;
   }
@@ -348,6 +399,10 @@ class RowReaderOptions {
     return skipRows_;
   }
 
+  bool preserveFlatMapsInMemory() const {
+    return preserveFlatMapsInMemory_;
+  }
+
   void setUnitLoaderFactory(
       std::shared_ptr<UnitLoaderFactory> unitLoaderFactory) {
     unitLoaderFactory_ = std::move(unitLoaderFactory);
@@ -391,19 +446,43 @@ class RowReaderOptions {
     serdeParameters_ = std::move(serdeParameters);
   }
 
+  bool trackRowSize() const {
+    return trackRowSize_;
+  }
+
+  void setTrackRowSize(bool trackRowSize) {
+    trackRowSize_ = trackRowSize;
+  }
+
+  bool passStringBuffersFromDecoder() const {
+    return passStringBuffersFromDecoder_;
+  }
+
+  void setPassStringBuffersFromDecoder(bool passStringBuffersFromDecoder) {
+    passStringBuffersFromDecoder_ = passStringBuffersFromDecoder;
+  }
+
  private:
   uint64_t dataStart_;
   uint64_t dataLength_;
   bool preloadStripe_;
   bool projectSelectedType_;
   bool returnFlatVector_ = false;
+  size_t parallelUnitLoadCount_ = 0;
   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_;
+
+  // Whether to generate FlatMapVectors when reading flat maps from the file. By
+  // default, converts flat maps in the file to MapVectors.
+  bool preserveFlatMapsInMemory_ = false;
+  // Optional io executor to enable parallel unit loader.
+  folly::Executor* ioExecutor_{nullptr};
   // Optional executors to enable internal reader parallelism.
   // 'decodingExecutor' allow parallelising the vector decoding process.
   // 'ioExecutor' enables parallelism when performing file system read
@@ -411,6 +490,7 @@ class RowReaderOptions {
   std::shared_ptr<folly::Executor> decodingExecutor_;
   size_t decodingParallelismFactor_{0};
   std::optional<RowNumberColumnInfo> rowNumberColumnInfo_{std::nullopt};
+
   // Parameters that are provided as the physical storage properties.
   std::unordered_map<std::string, std::string> storageParameters_{};
   // Parameters that are provided as the serialization/deserialization
@@ -441,6 +521,8 @@ class RowReaderOptions {
   TimestampPrecision timestampPrecision_ = TimestampPrecision::kMilliseconds;
 
   std::shared_ptr<FormatSpecificOptions> formatSpecificOptions_;
+  bool trackRowSize_{false};
+  bool passStringBuffersFromDecoder_{true};
 };
 
 /// Options for creating a Reader.
@@ -463,6 +545,13 @@ class ReaderOptions : public io::ReaderOptions {
     return *this;
   }
 
+  /// Sets the property bag.
+  ReaderOptions& setProperties(
+      std::unordered_map<std::string, std::string> properties) {
+    properties_ = std::move(properties);
+    return *this;
+  }
+
   /// Sets the current table schema of the file (a Type tree).  This could be
   /// different from the actual schema in file if schema evolution happened.
   /// For "dwrf" format, a default schema is derived from the file. For "rc"
@@ -536,6 +625,11 @@ class ReaderOptions : public io::ReaderOptions {
     return fileFormat_;
   }
 
+  /// Gets the property bag.
+  const std::unordered_map<std::string, std::string>& properties() const {
+    return properties_;
+  }
+
   /// Gets the file schema.
   const std::shared_ptr<const velox::RowType>& fileSchema() const {
     return fileSchema_;
@@ -626,6 +720,7 @@ class ReaderOptions : public io::ReaderOptions {
   FileFormat fileFormat_;
   RowTypePtr fileSchema_;
   SerDeOptions serDeOptions_;
+  std::unordered_map<std::string, std::string> properties_{};
   std::shared_ptr<encryption::DecrypterFactory> decrypterFactory_;
   uint64_t footerEstimatedSize_{kDefaultFooterEstimatedSize};
   uint64_t filePreloadThreshold_{kDefaultFilePreloadThreshold};
diff --git a/velox/dwio/common/OutputStream.h b/velox/dwio/common/OutputStream.h
index 46e90410ab18..d106cd4c9f3b 100644
--- a/velox/dwio/common/OutputStream.h
+++ b/velox/dwio/common/OutputStream.h
@@ -47,8 +47,8 @@ class BufferedOutputStream : public google::protobuf::io::ZeroCopyOutputStream {
 
   void BackUp(int32_t count) override;
 
-  google::protobuf::int64 ByteCount() const override {
-    return static_cast<google::protobuf::int64>(size());
+  int64_t ByteCount() const override {
+    return static_cast<int64_t>(size());
   }
 
   bool WriteAliasedRaw(const void* /* unused */, int32_t /* unused */)
@@ -116,7 +116,7 @@ class BufferedOutputStream : public google::protobuf::io::ZeroCopyOutputStream {
       void** buffer,
       int32_t* size,
       uint64_t headerSize,
-      const std::vector<folly::StringPiece>& bufferToFlush) {
+      const std::vector<std::string_view>& bufferToFlush) {
     bufferHolder_.take(bufferToFlush);
     *buffer = buffer_.data() + headerSize;
     *size = static_cast<int32_t>(buffer_.size() - headerSize);
diff --git a/velox/dwio/common/ParallelUnitLoader.cpp b/velox/dwio/common/ParallelUnitLoader.cpp
new file mode 100644
index 000000000000..2ef6718e8fcf
--- /dev/null
+++ b/velox/dwio/common/ParallelUnitLoader.cpp
@@ -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.
+ */
+
+#include "velox/dwio/common/ParallelUnitLoader.h"
+#include <numeric>
+#include "velox/common/base/AsyncSource.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/common/time/Timer.h"
+
+namespace facebook::velox::dwio::common {
+
+class ParallelUnitLoader : public UnitLoader {
+ public:
+  /// Enables concurrent loading of multiple units (stripes, row groups, etc.)
+  /// using asynchronous I/O to improve throughput and reduce read latency.
+  ///
+  /// **Loading Strategy:**
+  /// - Initialization: Preloads up to `maxConcurrentLoads` units concurrently
+  /// - Access pattern: On each getLoadedUnit() call, ensures the requested unit
+  ///   is loaded and triggers loading of subsequent units within the window
+  /// - Memory management: Unloads all previous units to control memory usage
+  ///
+  /// **Performance Characteristics:**
+  /// - Best suited for sequential access patterns
+  /// - Memory usage: O(maxConcurrentLoads * average_unit_size)
+  /// - I/O parallelism: Up to `maxConcurrentLoads` concurrent load operations
+  ///
+  /// **Parameters:**
+  /// @param units All units to be loaded
+  /// @param ioExecutor Thread pool for asynchronous unit loading operations
+  /// @param maxConcurrentLoads Maximum units to load concurrently (sliding
+  /// window size)
+  ///
+  /// **Example with maxConcurrentLoads=3:**
+  /// ```
+  /// Units: [0,1,2,3,4,5,6,7,8,9]
+  /// Init:  Load [0,1,2] concurrently
+  /// Get(0): Wait for unit 0, trigger load of units [0,1,2], unload none
+  /// Get(1): Wait for unit 1, trigger load of units [1,2,3], unload [0]
+  /// Get(2): Wait for unit 2, trigger load of units [2,3,4], unload [0,1]
+  /// ```
+  ParallelUnitLoader(
+      std::vector<std::unique_ptr<LoadUnit>> units,
+      folly::Executor* ioExecutor,
+      uint16_t maxConcurrentLoads)
+      : loadUnits_(
+            std::make_move_iterator(units.begin()),
+            std::make_move_iterator(units.end())),
+        ioExecutor_(ioExecutor),
+        maxConcurrentLoads_(maxConcurrentLoads) {
+    VELOX_CHECK_NOT_NULL(ioExecutor, "ParallelUnitLoader ioExecutor is null");
+    VELOX_CHECK_GT(
+        maxConcurrentLoads_,
+        0,
+        "ParallelUnitLoader maxConcurrentLoads should be larger than 0");
+    asyncSources_.resize(loadUnits_.size());
+    unitsLoaded_.resize(loadUnits_.size());
+  }
+
+  /// Destructor ensures all pending load operations are properly cancelled
+  /// and waited for to prevent resource leaks and dangling references.
+  ~ParallelUnitLoader() override {
+    for (auto& source : asyncSources_) {
+      if (source) {
+        source->cancel();
+      }
+    }
+  }
+
+  LoadUnit& getLoadedUnit(uint32_t unit) override {
+    VELOX_CHECK_LT(unit, loadUnits_.size(), "Unit out of range");
+
+    processedUnits_.insert(unit);
+    // Ensure sliding window of units [unit, unit + maxConcurrentLoads_) is
+    // loading
+    for (size_t i = unit;
+         i < loadUnits_.size() && i < unit + maxConcurrentLoads_;
+         ++i) {
+      if (!unitsLoaded_[i]) {
+        load(i);
+      }
+    }
+
+    uint64_t unitLoadNanos{0};
+    try {
+      NanosecondTimer timer{&unitLoadNanos};
+      asyncSources_[unit]->move();
+    } catch (const std::exception& e) {
+      VELOX_FAIL("Failed to load unit {}: {}", unit, e.what());
+    }
+    waitForUnitReadyNanos_ += unitLoadNanos;
+
+    // Unload the previous units
+    unloadUntil(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");
+  }
+
+  UnitLoaderStats stats() override {
+    UnitLoaderStats stats;
+    stats.addCounter("processedUnits", RuntimeCounter(processedUnits_.size()));
+    stats.addCounter(
+        "waitForUnitReadyNanos",
+        RuntimeCounter(
+            waitForUnitReadyNanos_ > std::numeric_limits<int64_t>::max()
+                ? std::numeric_limits<int64_t>::max()
+                : waitForUnitReadyNanos_,
+            RuntimeCounter::Unit::kNanos));
+    return stats;
+  }
+
+ private:
+  /// Submits the unit's load() to the I/O thread pool
+  void load(uint32_t unitIndex) {
+    VELOX_CHECK_LT(unitIndex, loadUnits_.size(), "Unit index out of bounds");
+    VELOX_CHECK_NOT_NULL(ioExecutor_, "ParallelUnitLoader ioExecutor is null");
+    VELOX_DCHECK(!loadUnits_.empty(), "loadUnits_ should not be empty");
+
+    // Capture shared_ptr by value to prevent use-after-free if
+    // ParallelUnitLoader is destroyed while async operation is running
+    auto unit = loadUnits_[unitIndex];
+    auto asyncSource = std::make_shared<AsyncSource<folly::Unit>>([unit] {
+      unit->load();
+      return std::make_unique<folly::Unit>();
+    });
+    asyncSources_[unitIndex] = asyncSource;
+    ioExecutor_->add([asyncSource] {
+      velox::common::testutil::TestValue::adjust(
+          "facebook::velox::dwio::common::ParallelUnitLoader::load",
+          asyncSource.get());
+      asyncSource->prepare();
+    });
+    unitsLoaded_[unitIndex] = true;
+  }
+
+  /// Unloads all the units before 'unitIndex'
+  void unloadUntil(uint32_t unitIndex) {
+    for (size_t i = 0; i < unitIndex; ++i) {
+      if (unitsLoaded_[i]) {
+        loadUnits_[i]->unload();
+        unitsLoaded_[i] = false;
+      }
+    }
+  }
+
+  std::vector<bool> unitsLoaded_;
+  std::vector<std::shared_ptr<LoadUnit>> loadUnits_;
+  std::vector<std::shared_ptr<AsyncSource<folly::Unit>>> asyncSources_;
+  folly::Executor* ioExecutor_;
+  size_t maxConcurrentLoads_;
+
+  // Stats
+  std::unordered_set<uint32_t> processedUnits_;
+  uint64_t waitForUnitReadyNanos_{0};
+};
+
+std::unique_ptr<UnitLoader> ParallelUnitLoaderFactory::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<ParallelUnitLoader>(
+      std::move(loadUnits), ioExecutor_, maxConcurrentLoads_);
+}
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ParallelUnitLoader.h b/velox/dwio/common/ParallelUnitLoader.h
new file mode 100644
index 000000000000..0ba89028326c
--- /dev/null
+++ b/velox/dwio/common/ParallelUnitLoader.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 <folly/Executor.h>
+#include <folly/futures/Future.h>
+
+#include <vector>
+#include "velox/dwio/common/UnitLoader.h"
+
+namespace facebook::velox::dwio::common {
+class ParallelUnitLoaderFactory : public UnitLoaderFactory {
+ public:
+  ParallelUnitLoaderFactory(
+      folly::Executor* ioExecutor,
+      size_t maxConcurrentLoads)
+      : ioExecutor_(ioExecutor), maxConcurrentLoads_(maxConcurrentLoads) {}
+
+  std::unique_ptr<UnitLoader> create(
+      std::vector<std::unique_ptr<LoadUnit>> loadUnits,
+      uint64_t rowsToSkip) override;
+
+ private:
+  folly::Executor* ioExecutor_;
+  size_t maxConcurrentLoads_;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/PositionProvider.h b/velox/dwio/common/PositionProvider.h
index 7be3bc7a1602..c99655a87e7c 100644
--- a/velox/dwio/common/PositionProvider.h
+++ b/velox/dwio/common/PositionProvider.h
@@ -23,7 +23,7 @@ namespace facebook::velox::dwio::common {
 class PositionProvider {
  public:
   explicit PositionProvider(const std::vector<uint64_t>& positions)
-      : position_{positions.begin()}, end_{positions.end()} {}
+      : position_{positions.cbegin()}, end_{positions.cend()} {}
 
   uint64_t next();
 
diff --git a/velox/dwio/common/RandGen.h b/velox/dwio/common/RandGen.h
index b83743bbcca1..a1fc53e8dc7a 100644
--- a/velox/dwio/common/RandGen.h
+++ b/velox/dwio/common/RandGen.h
@@ -19,10 +19,7 @@
 #include <folly/Conv.h>
 #include <random>
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class RandGen {
  public:
@@ -68,7 +65,4 @@ class RandGen {
   std::uniform_int_distribution<int32_t> dist_;
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/Range.h b/velox/dwio/common/Range.h
index 8f12abff182f..d63a6506e47a 100644
--- a/velox/dwio/common/Range.h
+++ b/velox/dwio/common/Range.h
@@ -63,14 +63,8 @@ class Ranges {
       }
     }
 
-    bool operator==(const Iterator& other) const {
-      return std::tie(cur_, end_, val_) ==
-          std::tie(other.cur_, other.end_, other.val_);
-    }
-
-    bool operator!=(const Iterator& other) const {
-      return !operator==(other);
-    }
+    // TODO: Maybe only cur_ or cur_ with end_ should be compared?
+    bool operator==(const Iterator& other) const = default;
 
     Iterator& operator++() {
       VELOX_DCHECK(cur_ != end_);
diff --git a/velox/dwio/common/Reader.cpp b/velox/dwio/common/Reader.cpp
index 55066e979629..559dab5ae80e 100644
--- a/velox/dwio/common/Reader.cpp
+++ b/velox/dwio/common/Reader.cpp
@@ -61,7 +61,7 @@ VectorPtr RowReader::projectColumns(
       childType = inputRowType.childAt(childIdx);
       child = inputRow->childAt(childIdx);
       if (child) {
-        childSpec->applyFilter(*child, passed.data());
+        childSpec->applyFilter(*child, inputRow->size(), passed.data());
       }
     }
     if (!childSpec->projectOut()) {
diff --git a/velox/dwio/common/Reader.h b/velox/dwio/common/Reader.h
index 9dddfaeaca08..3a2fb37808f8 100644
--- a/velox/dwio/common/Reader.h
+++ b/velox/dwio/common/Reader.h
@@ -44,6 +44,13 @@ class RowReader {
  public:
   static constexpr int64_t kAtEnd = -1;
 
+  /// Runtime stat names.
+  /// Tracks the number of index columns that were converted from ScanSpec
+  /// filters to index bounds for index-based filtering (e.g., cluster index
+  /// pruning in Nimble).
+  static inline const std::string kNumIndexFilterConversions =
+      "numIndexFilterConversions";
+
   virtual ~RowReader() = default;
 
   /**
diff --git a/velox/dwio/common/Retry.h b/velox/dwio/common/Retry.h
index d4d52c120f28..9ea087d4361f 100644
--- a/velox/dwio/common/Retry.h
+++ b/velox/dwio/common/Retry.h
@@ -28,10 +28,7 @@
 #include "velox/dwio/common/RandGen.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class retriable_error : public std::runtime_error {
  public:
@@ -61,25 +58,24 @@ namespace retrypolicy {
 class IRetryPolicy {
  public:
   virtual ~IRetryPolicy() = default;
-  virtual folly::Optional<RetryDuration> nextWaitTime() = 0;
+  virtual std::optional<RetryDuration> nextWaitTime() = 0;
   virtual void start() {}
 };
 
 class KAttempts : public IRetryPolicy {
  public:
   explicit KAttempts(std::vector<RetryDuration> durations)
-      : index_(0), durations_(std::move(durations)) {}
+      : durations_{std::move(durations)} {}
 
-  folly::Optional<RetryDuration> nextWaitTime() override {
+  std::optional<RetryDuration> nextWaitTime() override {
     if (index_ < durations_.size()) {
-      return folly::Optional<RetryDuration>(durations_[index_++]);
-    } else {
-      return folly::Optional<RetryDuration>();
+      return durations_[index_++];
     }
+    return std::nullopt;
   }
 
  private:
-  size_t index_;
+  size_t index_{0};
   const std::vector<RetryDuration> durations_;
 };
 
@@ -105,16 +101,16 @@ class ExponentialBackoff : public IRetryPolicy {
     startTime_ = std::chrono::system_clock::now();
   }
 
-  folly::Optional<RetryDuration> nextWaitTime() override {
+  std::optional<RetryDuration> nextWaitTime() override {
     if (retriesLeft_ == 0 || (maxTotal_.count() > 0 && total() >= maxTotal_)) {
-      return folly::Optional<RetryDuration>();
+      return std::nullopt;
     }
 
     RetryDuration waitTime = nextWait_ + jitter();
     nextWait_ = std::min(nextWait_ + nextWait_, maxWait_);
     --retriesLeft_;
     totalWait_ += waitTime;
-    return folly::Optional<RetryDuration>(waitTime);
+    return waitTime;
   }
 
  private:
@@ -204,7 +200,7 @@ class RetryModule {
         return func();
       } catch (const retriable_error& error) {
         LOG(INFO) << "RetryModule caught retriable exception. " << error.what();
-        folly::Optional<RetryDuration> wait = policy->nextWaitTime();
+        auto wait = policy->nextWaitTime();
         if (wait.has_value()) {
           auto ms = wait.value().count();
           LOG(INFO) << "RetryModule : Waiting for " << ms
@@ -230,7 +226,4 @@ class RetryModule {
   }
 };
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/ScanSpec.cpp b/velox/dwio/common/ScanSpec.cpp
index fc247ba4dd2a..6e3d7ae4b131 100644
--- a/velox/dwio/common/ScanSpec.cpp
+++ b/velox/dwio/common/ScanSpec.cpp
@@ -21,6 +21,21 @@
 
 namespace facebook::velox::common {
 
+// static
+std::string_view ScanSpec::columnTypeString(ScanSpec::ColumnType columnType) {
+  switch (columnType) {
+    case ScanSpec::ColumnType::kRegular:
+      return "REGULAR";
+    case ScanSpec::ColumnType::kRowIndex:
+      return "ROW_INDEX";
+    case ScanSpec::ColumnType::kComposite:
+      return "COMPOSITE";
+    default:
+      VELOX_UNREACHABLE(
+          "Unrecognized ColumnType: {}", static_cast<int8_t>(columnType));
+  }
+}
+
 ScanSpec* ScanSpec::getOrCreateChild(const std::string& name) {
   if (auto it = this->childByFieldName_.find(name);
       it != this->childByFieldName_.end()) {
@@ -37,7 +52,7 @@ ScanSpec* ScanSpec::getOrCreateChild(const Subfield& subfield) {
   const auto& path = subfield.path();
   for (size_t depth = 0; depth < path.size(); ++depth) {
     const auto element = path[depth].get();
-    VELOX_CHECK_EQ(element->kind(), kNestedField);
+    VELOX_CHECK_EQ(element->kind(), SubfieldKind::kNestedField);
     auto* nestedField = static_cast<const Subfield::NestedField*>(element);
     container = container->getOrCreateChild(nestedField->name());
   }
@@ -89,8 +104,8 @@ uint64_t ScanSpec::newRead() {
   if (numReads_ == 0 ||
       (!disableStatsBasedFilterReorder_ &&
        !std::is_sorted(
-           children_.begin(),
-           children_.end(),
+           children_.cbegin(),
+           children_.cend(),
            [this](
                const std::shared_ptr<ScanSpec>& left,
                const std::shared_ptr<ScanSpec>& right) {
@@ -204,7 +219,7 @@ void ScanSpec::moveAdaptationFrom(ScanSpec& other) {
 
 namespace {
 bool testIntFilter(
-    common::Filter* filter,
+    const common::Filter* filter,
     dwio::common::IntegerColumnStatistics* intStats,
     bool mayHaveNull) {
   if (!intStats) {
@@ -239,7 +254,7 @@ bool testIntFilter(
 }
 
 bool testDoubleFilter(
-    common::Filter* filter,
+    const common::Filter* filter,
     dwio::common::DoubleColumnStatistics* doubleStats,
     bool mayHaveNull) {
   if (!doubleStats) {
@@ -274,7 +289,7 @@ bool testDoubleFilter(
 }
 
 bool testStringFilter(
-    common::Filter* filter,
+    const common::Filter* filter,
     dwio::common::StringColumnStatistics* stringStats,
     bool mayHaveNull) {
   if (!stringStats) {
@@ -304,7 +319,7 @@ bool testStringFilter(
 }
 
 bool testBoolFilter(
-    common::Filter* filter,
+    const common::Filter* filter,
     dwio::common::BooleanColumnStatistics* boolStats) {
   const auto trueCount = boolStats->getTrueCount();
   const auto falseCount = boolStats->getFalseCount();
@@ -325,7 +340,7 @@ bool testBoolFilter(
 } // namespace
 
 bool testFilter(
-    common::Filter* filter,
+    const common::Filter* filter,
     dwio::common::ColumnStatistics* stats,
     uint64_t totalRows,
     const TypePtr& type) {
@@ -428,10 +443,6 @@ std::string ScanSpec::toString() const {
   return out.str();
 }
 
-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(name);
   child->setProjectOut(true);
@@ -510,7 +521,7 @@ namespace {
 template <TypeKind kKind>
 void filterSimpleVectorRows(
     const BaseVector& vector,
-    Filter& filter,
+    const Filter& filter,
     vector_size_t size,
     uint64_t* result) {
   VELOX_CHECK(size == 0 || result);
@@ -529,9 +540,10 @@ void filterSimpleVectorRows(
 
 void filterRows(
     const BaseVector& vector,
-    Filter& filter,
+    const Filter& filter,
     vector_size_t size,
     uint64_t* result) {
+  VELOX_CHECK_LE(size, vector.size());
   switch (vector.typeKind()) {
     case TypeKind::ARRAY:
     case TypeKind::MAP:
@@ -562,20 +574,39 @@ void filterRows(
 
 } // namespace
 
-void ScanSpec::applyFilter(const BaseVector& vector, uint64_t* result) const {
+void ScanSpec::applyFilter(
+    const BaseVector& vector,
+    vector_size_t size,
+    uint64_t* result) const {
   if (filter_) {
-    filterRows(vector, *filter_, vector.size(), result);
+    filterRows(vector, *filter_, size, result);
   }
   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.asChecked<RowVector>();
-  for (int i = 0; i < rowType.size(); ++i) {
-    if (auto* child = childByName(rowType.nameOf(i))) {
-      child->applyFilter(*rowVector->childAt(i), result);
+  if (vector.encoding() == VectorEncoding::Simple::ROW) {
+    auto rowVector = vector.asUnchecked<RowVector>();
+    for (int i = 0; i < rowType.size(); ++i) {
+      if (auto* child = childByName(rowType.nameOf(i))) {
+        child->applyFilter(*rowVector->childAt(i), size, result);
+      }
+    }
+  } else {
+    DecodedVector decoded{vector};
+    auto rowVector = decoded.base()->asUnchecked<RowVector>();
+
+    for (int i = 0; i < rowType.size(); ++i) {
+      if (auto* child = childByName(rowType.nameOf(i))) {
+        child->applyFilter(
+            *(decoded.wrap(
+                rowVector->childAt(i), *vector.pool(), vector.size())),
+            size,
+            result);
+      }
     }
   }
 }
diff --git a/velox/dwio/common/ScanSpec.h b/velox/dwio/common/ScanSpec.h
index a040fc5316bd..bee9ef5b89e1 100644
--- a/velox/dwio/common/ScanSpec.h
+++ b/velox/dwio/common/ScanSpec.h
@@ -28,17 +28,16 @@
 
 #include <vector>
 
-namespace facebook {
-namespace velox {
+namespace facebook::velox {
 namespace dwio::common {
 class ColumnStatistics;
 }
 namespace common {
 
-// Describes the filtering and value extraction for a
-// SelectiveColumnReader. This is owned by the TableScan Operator and
-// is passed to SelectiveColumnReaders at construction.  This is
-// mutable by readers to reflect filter order and other adaptation.
+/// Describes the filtering and value extraction for a
+/// SelectiveColumnReader. This is owned by the TableScan Operator and
+/// is passed to SelectiveColumnReaders at construction.  This is
+/// mutable by readers to reflect filter order and other adaptations.
 class ScanSpec {
  public:
   enum class ColumnType : int8_t {
@@ -47,6 +46,9 @@ class ScanSpec {
     kComposite, // A struct with all children not read from file
   };
 
+  /// Convert ColumnType to its string name representation.
+  static std::string_view columnTypeString(ColumnType columnType);
+
   static constexpr column_index_t kNoChannel = ~0;
   static constexpr const char* kMapKeysFieldName = "keys";
   static constexpr const char* kMapValuesFieldName = "values";
@@ -54,21 +56,19 @@ class ScanSpec {
 
   explicit ScanSpec(const std::string& name) : fieldName_(name) {}
 
-  // Filter to apply. If 'this' corresponds to a struct/list/map, this
-  // can only be isNull or isNotNull, other filtering is given by
-  // 'children'.
-  common::Filter* filter() const {
+  /// Filter to apply. If 'this' corresponds to a struct/list/map, this
+  /// can only be isNull or isNotNull, other filtering is given by
+  /// 'children'.
+  const common::Filter* filter() const {
     return filterDisabled_ ? nullptr : filter_.get();
   }
 
   // Sets 'filter_'. May be used at initialization or when adding a
   // pushed down filter, e.g. top k cutoff.
-  void setFilter(std::unique_ptr<Filter> filter) {
+  void setFilter(std::shared_ptr<Filter> filter) {
     filter_ = std::move(filter);
   }
 
-  void addFilter(const Filter&);
-
   void setMaxArrayElementsCount(vector_size_t count) {
     maxArrayElementsCount_ = count;
   }
@@ -148,7 +148,9 @@ class ScanSpec {
   }
 
   void setSubscript(int64_t subscript) {
-    subscript_ = subscript;
+    if (subscript_ != subscript) {
+      subscript_ = subscript;
+    }
   }
 
   // True if the value is returned from scan.  A runtime pushdown of a filter
@@ -165,8 +167,8 @@ class ScanSpec {
     return projectOut_ || deltaUpdate_;
   }
 
-  // Position in the RowVector returned by the top level scan. Applies
-  // only to children of the root struct where projectOut_ is true.
+  /// Position in the RowVector returned by the top level scan. Applies
+  /// only to children of the root struct where projectOut_ is true.
   column_index_t channel() const {
     return channel_;
   }
@@ -357,10 +359,17 @@ class ScanSpec {
     }
   }
 
-  /// Apply filter to the input `vector' and set the passed bits in `result'.
+  /// Apply filter to the first `size' rows of input `vector' and set the passed
+  /// bits in `result'.  `size' is usually the size of top most RowVector, since
+  /// the child could be larger in some suboptimal/corrupted cases and we do not
+  /// want to crash the process for it.
+  ///
   /// This method is used by non-selective reader and delta update, so it
   /// ignores the filterDisabled_ state.
-  void applyFilter(const BaseVector& vector, uint64_t* result) const;
+  void applyFilter(
+      const BaseVector& vector,
+      vector_size_t size,
+      uint64_t* result) const;
 
   bool isFlatMapAsStruct() const {
     return isFlatMapAsStruct_;
@@ -399,30 +408,30 @@ class ScanSpec {
   // Number of times read is called on the corresponding reader. This
   // is used for setup on first use and to produce a read sequence
   // number for LazyVectors.
-  uint64_t numReads_ = 0;
+  uint64_t numReads_{0};
 
   // Ordinal position of 'this' in its containing spec. For a struct
   // member this is the position of the reader in the child
   // readers. If this describes an operation on an array element or a
   // map with numeric key, this is the subscript as defined for array
   // or map.
-  int64_t subscript_ = -1;
+  int64_t subscript_{-1};
   // Column name if this is a struct mamber. String key if this
   // describes an operation on a map value.
   std::string fieldName_;
   // Ordinal position of the extracted value in the containing
   // RowVector. Set only when this describes a struct member.
-  column_index_t channel_ = kNoChannel;
+  column_index_t channel_{kNoChannel};
 
   VectorPtr constantValue_;
-  bool projectOut_ = false;
+  bool projectOut_{false};
 
-  ColumnType columnType_ = ColumnType::kRegular;
+  ColumnType columnType_{ColumnType::kRegular};
 
   // True if a string dictionary or flat map in this field should be
   // returned as flat.
-  bool makeFlat_ = false;
-  std::unique_ptr<common::Filter> filter_;
+  bool makeFlat_{false};
+  std::shared_ptr<const common::Filter> filter_;
   bool filterDisabled_ = false;
   dwio::common::DeltaColumnUpdater* deltaUpdate_ = nullptr;
 
@@ -437,6 +446,7 @@ class ScanSpec {
   SelectivityInfo selectivity_;
 
   std::vector<std::shared_ptr<ScanSpec>> children_;
+
   // Read-only copy of children, not subject to reordering. Used when
   // asynchronously constructing reader trees for read-ahead, while
   // 'children_' is reorderable by a running scan.
@@ -495,11 +505,21 @@ void ScanSpec::visit(const Type& type, F&& f) {
 // Returns false if no value from a range defined by stats can pass the
 // filter. True, otherwise.
 bool testFilter(
-    common::Filter* filter,
+    const common::Filter* filter,
     dwio::common::ColumnStatistics* stats,
     uint64_t totalRows,
     const TypePtr& type);
 
 } // namespace common
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox
+
+template <>
+struct fmt::formatter<facebook::velox::common::ScanSpec::ColumnType>
+    : formatter<std::string_view> {
+  auto format(
+      facebook::velox::common::ScanSpec::ColumnType columnType,
+      format_context& ctx) const {
+    return formatter<std::string_view>::format(
+        facebook::velox::common::ScanSpec::columnTypeString(columnType), ctx);
+  }
+};
diff --git a/velox/dwio/common/SeekableInputStream.cpp b/velox/dwio/common/SeekableInputStream.cpp
index 2f461551626b..db3c7f4a5028 100644
--- a/velox/dwio/common/SeekableInputStream.cpp
+++ b/velox/dwio/common/SeekableInputStream.cpp
@@ -163,8 +163,8 @@ bool SeekableArrayInputStream::SkipInt64(int64_t count) {
   return false;
 }
 
-google::protobuf::int64 SeekableArrayInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(position_);
+int64_t SeekableArrayInputStream::ByteCount() const {
+  return static_cast<int64_t>(position_);
 }
 
 void SeekableArrayInputStream::seekToPosition(PositionProvider& position) {
@@ -241,8 +241,8 @@ bool SeekableFileInputStream::SkipInt64(int64_t signedCount) {
   return position_ < length_;
 }
 
-google::protobuf::int64 SeekableFileInputStream::ByteCount() const {
-  return static_cast<google::protobuf::int64>(position_);
+int64_t SeekableFileInputStream::ByteCount() const {
+  return static_cast<int64_t>(position_);
 }
 
 void SeekableFileInputStream::seekToPosition(PositionProvider& location) {
diff --git a/velox/dwio/common/SeekableInputStream.h b/velox/dwio/common/SeekableInputStream.h
index c53347a6204f..f4e33008523c 100644
--- a/velox/dwio/common/SeekableInputStream.h
+++ b/velox/dwio/common/SeekableInputStream.h
@@ -79,7 +79,7 @@ class SeekableArrayInputStream : public SeekableInputStream {
   virtual bool Next(const void** data, int32_t* size) override;
   virtual void BackUp(int32_t count) override;
   virtual bool SkipInt64(int64_t count) override;
-  virtual google::protobuf::int64 ByteCount() const override;
+  virtual int64_t ByteCount() const override;
   virtual void seekToPosition(PositionProvider& position) override;
   virtual std::string getName() const override;
   virtual size_t positionSize() const override;
@@ -120,7 +120,7 @@ class SeekableFileInputStream : public SeekableInputStream {
   virtual bool Next(const void** data, int32_t* size) override;
   virtual void BackUp(int32_t count) override;
   virtual bool SkipInt64(int64_t count) override;
-  virtual google::protobuf::int64 ByteCount() const override;
+  virtual int64_t ByteCount() const override;
   virtual void seekToPosition(PositionProvider& position) override;
   virtual std::string getName() const override;
   virtual size_t positionSize() const override;
diff --git a/velox/dwio/common/SelectiveByteRleColumnReader.h b/velox/dwio/common/SelectiveByteRleColumnReader.h
index 3c437aba973b..c276e31fb22d 100644
--- a/velox/dwio/common/SelectiveByteRleColumnReader.h
+++ b/velox/dwio/common/SelectiveByteRleColumnReader.h
@@ -41,7 +41,7 @@ class SelectiveByteRleColumnReader : public SelectiveColumnReader {
       bool kEncodingHasNulls,
       typename ExtractValues>
   void processFilter(
-      velox::common::Filter* filter,
+      const velox::common::Filter* filter,
       ExtractValues extractValues,
       const RowSet& rows);
 
@@ -54,7 +54,7 @@ class SelectiveByteRleColumnReader : public SelectiveColumnReader {
       bool isDense,
       typename ExtractValues>
   void readHelper(
-      velox::common::Filter* filter,
+      const velox::common::Filter* filter,
       const RowSet& rows,
       ExtractValues extractValues);
 
@@ -69,13 +69,13 @@ template <
     bool isDense,
     typename ExtractValues>
 void SelectiveByteRleColumnReader::readHelper(
-    velox::common::Filter* filter,
+    const velox::common::Filter* filter,
     const RowSet& rows,
     ExtractValues extractValues) {
   reinterpret_cast<Reader*>(this)->readWithVisitor(
       rows,
       ColumnVisitor<int8_t, TFilter, ExtractValues, isDense>(
-          *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
+          *static_cast<const TFilter*>(filter), this, rows, extractValues));
 }
 
 template <
@@ -84,7 +84,7 @@ template <
     bool kEncodingHasNulls,
     typename ExtractValues>
 void SelectiveByteRleColumnReader::processFilter(
-    velox::common::Filter* filter,
+    const velox::common::Filter* filter,
     ExtractValues extractValues,
     const RowSet& rows) {
   using velox::common::FilterKind;
@@ -162,7 +162,7 @@ void SelectiveByteRleColumnReader::readCommon(
     const uint64_t* incomingNulls) {
   prepareRead<int8_t>(offset, rows, incomingNulls);
   const bool isDense = rows.back() == rows.size() - 1;
-  velox::common::Filter* filter =
+  auto* filter =
       scanSpec_->filter() ? scanSpec_->filter() : &dwio::common::alwaysTrue();
   if (scanSpec_->keepValues()) {
     if (scanSpec_->valueHook()) {
diff --git a/velox/dwio/common/SelectiveColumnReader.cpp b/velox/dwio/common/SelectiveColumnReader.cpp
index 17b2207d65af..df67694643f1 100644
--- a/velox/dwio/common/SelectiveColumnReader.cpp
+++ b/velox/dwio/common/SelectiveColumnReader.cpp
@@ -410,7 +410,7 @@ void SelectiveColumnReader::compactScalarValues<bool, bool>(
   values_->setSize(bits::nbytes(numValues_));
 }
 
-char* SelectiveColumnReader::copyStringValue(folly::StringPiece value) {
+char* SelectiveColumnReader::copyStringValue(std::string_view value) {
   uint64_t size = value.size();
   if (stringBuffers_.empty() || rawStringUsed_ + size > rawStringSize_) {
     auto bytes = std::max(size, kStringBufferSize);
@@ -431,7 +431,7 @@ char* SelectiveColumnReader::copyStringValue(folly::StringPiece value) {
   return rawStringBuffer_ + start;
 }
 
-void SelectiveColumnReader::addStringValue(folly::StringPiece value) {
+void SelectiveColumnReader::addStringValue(std::string_view value) {
   auto copy = copyStringValue(value);
   reinterpret_cast<StringView*>(rawValues_)[numValues_++] =
       StringView(copy, value.size());
@@ -449,8 +449,11 @@ void SelectiveColumnReader::setNulls(BufferPtr resultNulls) {
 
 void SelectiveColumnReader::resetFilterCaches() {
   if (scanState_.filterCache.empty() && scanSpec_->hasFilter()) {
-    scanState_.filterCache.resize(std::max<int32_t>(
-        1, scanState_.dictionary.numValues + scanState_.dictionary2.numValues));
+    scanState_.filterCache.resize(
+        std::max<int32_t>(
+            1,
+            scanState_.dictionary.numValues +
+                scanState_.dictionary2.numValues));
     scanState_.updateRawState();
   }
   if (!scanState_.filterCache.empty()) {
@@ -476,7 +479,7 @@ void SelectiveColumnReader::addSkippedParentNulls(
     int64_t from,
     int64_t to,
     int32_t numNulls) {
-  auto rowsPerRowGroup = formatData_->rowsPerRowGroup();
+  const auto rowsPerRowGroup = formatData_->rowsPerRowGroup();
   if (rowsPerRowGroup.has_value() &&
       from / rowsPerRowGroup.value() >
           parentNullsRecordedTo_ / rowsPerRowGroup.value()) {
@@ -484,7 +487,7 @@ void SelectiveColumnReader::addSkippedParentNulls(
     parentNullsRecordedTo_ = from;
     numParentNulls_ = 0;
   }
-  if (parentNullsRecordedTo_) {
+  if (parentNullsRecordedTo_ > 0) {
     VELOX_CHECK_EQ(parentNullsRecordedTo_, from);
   }
   numParentNulls_ += numNulls;
diff --git a/velox/dwio/common/SelectiveColumnReader.h b/velox/dwio/common/SelectiveColumnReader.h
index 8352c9b388d1..dbbbd55ec938 100644
--- a/velox/dwio/common/SelectiveColumnReader.h
+++ b/velox/dwio/common/SelectiveColumnReader.h
@@ -27,6 +27,8 @@
 
 namespace facebook::velox::dwio::common {
 
+using ScanSpec = velox::common::ScanSpec;
+
 /// Generalized representation of a set of distinct values for dictionary
 /// encodings.
 struct DictionaryValues {
@@ -161,12 +163,11 @@ class SelectiveColumnReader {
   // from a downstream operator.
   virtual void resetFilterCaches();
 
-  // Seeks to offset and reads the rows in 'rows' and applies
-  // filters and value processing as given by 'scanSpec supplied at
-  // construction. 'offset' is relative to start of stripe. 'rows' are
-  // relative to 'offset', so that row 0 is the 'offset'th row from
-  // start of stripe. 'rows' is expected to stay constant
-  // between this and the next call to read.
+  // Seeks to offset and reads the rows in 'rows' and applies filters and value
+  // processing as given by 'scanSpec supplied at construction. 'offset' is
+  // relative to start of stripe. 'rows' are relative to 'offset', so that row 0
+  // is the 'offset'th row from start of stripe. 'rows' is expected to stay
+  // constant between this and the next call to read.
   virtual void
   read(int64_t offset, const RowSet& rows, const uint64_t* incomingNulls) = 0;
 
@@ -335,7 +336,7 @@ class SelectiveColumnReader {
   template <typename T>
   inline void addValue(T value) {
     static_assert(
-        std::is_pod_v<T>,
+        std::is_standard_layout_v<T>,
         "General case of addValue is only for primitive types");
     VELOX_DCHECK_NOT_NULL(rawValues_);
     VELOX_DCHECK_LE((numValues_ + 1) * sizeof(T), values_->capacity());
@@ -483,7 +484,7 @@ class SelectiveColumnReader {
     return false;
   }
 
-  StringView copyStringValueIfNeed(folly::StringPiece value) {
+  StringView copyStringValueIfNeed(std::string_view value) {
     if (value.size() <= StringView::kInlineSize) {
       return StringView(value);
     }
@@ -495,6 +496,10 @@ class SelectiveColumnReader {
     VELOX_UNREACHABLE("Only struct reader supports this method");
   }
 
+  memory::MemoryPool* memoryPool() const {
+    return memoryPool_;
+  }
+
  protected:
   template <typename T>
   void prepareRead(
@@ -578,11 +583,11 @@ class SelectiveColumnReader {
   // Checks consistency of nulls-related state.
   const uint64_t* shouldMoveNulls(const RowSet& rows);
 
-  void addStringValue(folly::StringPiece value);
+  void addStringValue(std::string_view value);
 
   // Copies 'value' to buffers owned by 'this' and returns the start of the
   // copy.
-  char* copyStringValue(folly::StringPiece value);
+  char* copyStringValue(std::string_view value);
 
   virtual bool hasDeletion() const {
     return false;
@@ -729,7 +734,7 @@ class SelectiveColumnReader {
 };
 
 template <>
-inline void SelectiveColumnReader::addValue(const folly::StringPiece value) {
+inline void SelectiveColumnReader::addValue(const std::string_view value) {
   const uint64_t size = value.size();
   if (size <= StringView::kInlineSize) {
     reinterpret_cast<StringView*>(rawValues_)[numValues_++] =
@@ -763,7 +768,7 @@ struct NoHook final : public ValueHook {
 
   void addValue(vector_size_t /*row*/, double /*value*/) final {}
 
-  void addValue(vector_size_t /*row*/, folly::StringPiece /*value*/) final {}
+  void addValue(vector_size_t /*row*/, std::string_view /*value*/) final {}
 };
 
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveColumnReaderInternal.h b/velox/dwio/common/SelectiveColumnReaderInternal.h
index f491870bfff9..c2ff5b0b0e84 100644
--- a/velox/dwio/common/SelectiveColumnReaderInternal.h
+++ b/velox/dwio/common/SelectiveColumnReaderInternal.h
@@ -21,8 +21,8 @@
 #include "velox/dwio/common/DirectDecoder.h"
 #include "velox/dwio/common/SelectiveColumnReader.h"
 #include "velox/dwio/common/TypeUtils.h"
-#include "velox/exec/AggregationHook.h"
 #include "velox/type/Timestamp.h"
+#include "velox/vector/AggregationHook.h"
 #include "velox/vector/ConstantVector.h"
 #include "velox/vector/DictionaryVector.h"
 #include "velox/vector/FlatVector.h"
diff --git a/velox/dwio/common/SelectiveFlatMapColumnReader.cpp b/velox/dwio/common/SelectiveFlatMapColumnReader.cpp
new file mode 100644
index 000000000000..05bf1a7a9915
--- /dev/null
+++ b/velox/dwio/common/SelectiveFlatMapColumnReader.cpp
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/SelectiveFlatMapColumnReader.h"
+
+namespace facebook::velox::dwio::common {
+namespace {
+
+// Check if `result` can be reused to prevent allocation of a new vector.
+FlatMapVector* tryReuseResult(
+    const VectorPtr& result,
+    const VectorPtr& distinctKeys,
+    vector_size_t size) {
+  if (result.use_count() != 1) {
+    return nullptr;
+  }
+
+  if (result->encoding() == VectorEncoding::Simple::FLAT_MAP) {
+    auto* flatMap = static_cast<FlatMapVector*>(result.get());
+    if (flatMap->distinctKeys() != distinctKeys) {
+      flatMap->setDistinctKeys(distinctKeys);
+    }
+    flatMap->resize(size);
+    return flatMap;
+  }
+  return nullptr;
+}
+} // namespace
+
+void SelectiveFlatMapColumnReader::getValues(
+    const RowSet& rows,
+    VectorPtr* result) {
+  VELOX_CHECK(!scanSpec_->children().empty());
+  VELOX_CHECK_NOT_NULL(
+      *result, "SelectiveFlatMapColumnReader expects a non-null result");
+  VELOX_CHECK(
+      result->get()->type()->isMap(),
+      "Struct reader expects a result of type MAP.");
+
+  if (rows.empty()) {
+    return;
+  }
+
+  auto* resultFlatMap = prepareResult(*result, keysVector_, rows.size());
+  setComplexNulls(rows, *result);
+
+  for (const auto& childSpec : scanSpec_->children()) {
+    VELOX_TRACE_HISTORY_PUSH("getValues %s", childSpec->fieldName().c_str());
+    if (!childSpec->keepValues()) {
+      continue;
+    }
+
+    VELOX_CHECK(
+        childSpec->readFromFile(),
+        "Flatmap children must always be read from file.");
+
+    if (childSpec->subscript() == kConstantChildSpecSubscript) {
+      continue;
+    }
+
+    const auto channel = childSpec->channel();
+    const auto index = childSpec->subscript();
+    auto& childResult = resultFlatMap->mapValuesAt(channel);
+
+    VELOX_CHECK(
+        !childSpec->deltaUpdate(),
+        "Delta update not supported in flat map yet");
+    VELOX_CHECK(
+        !childSpec->isConstant(),
+        "Flat map values cannot be constant in scanSpec.");
+    VELOX_CHECK_EQ(
+        childSpec->columnType(),
+        velox::common::ScanSpec::ColumnType::kRegular,
+        "Flat map only supports regular column types in scan spec.");
+
+    children_[index]->getValues(rows, &childResult);
+
+    for (size_t i = 0; i < children_.size(); ++i) {
+      const auto& inMap = inMapBuffer(i);
+      if (inMap) {
+        resultFlatMap->inMapsAt(i, true) = inMap;
+      }
+    }
+  }
+}
+
+FlatMapVector* SelectiveFlatMapColumnReader::prepareResult(
+    VectorPtr& result,
+    const VectorPtr& distinctKeys,
+    vector_size_t size) const {
+  if (auto reused = tryReuseResult(result, distinctKeys, size)) {
+    return reused;
+  }
+
+  auto flatMap = std::make_shared<FlatMapVector>(
+      result->pool(),
+      result->type(),
+      nullptr,
+      size,
+      distinctKeys,
+      std::vector<VectorPtr>(distinctKeys->size()),
+      std::vector<BufferPtr>{});
+  result = flatMap;
+  return flatMap.get();
+}
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveFlatMapColumnReader.h b/velox/dwio/common/SelectiveFlatMapColumnReader.h
new file mode 100644
index 000000000000..8a939ffa7bbe
--- /dev/null
+++ b/velox/dwio/common/SelectiveFlatMapColumnReader.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.
+ */
+
+#pragma once
+
+#include "velox/dwio/common/SelectiveStructColumnReader.h"
+#include "velox/vector/FlatMapVector.h"
+
+namespace facebook::velox::dwio::common {
+
+class SelectiveFlatMapColumnReader : public SelectiveStructColumnReaderBase {
+ protected:
+  SelectiveFlatMapColumnReader(
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      FormatParams& params,
+      velox::common::ScanSpec& scanSpec)
+      : SelectiveStructColumnReaderBase(
+            requestedType,
+            fileType,
+            params,
+            scanSpec,
+            false,
+            false) {}
+
+  void getValues(const RowSet& rows, VectorPtr* result) override;
+
+  void seekTo(int64_t offset, bool /*readsNullsOnly*/) override {
+    seekToPropagateNullsToChildren(offset);
+  }
+
+  virtual const BufferPtr& inMapBuffer(column_index_t childIndex) const = 0;
+
+  VectorPtr keysVector_;
+
+ private:
+  FlatMapVector* prepareResult(
+      VectorPtr& result,
+      const VectorPtr& distinctKeys,
+      vector_size_t size) const;
+};
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveFloatingPointColumnReader.h b/velox/dwio/common/SelectiveFloatingPointColumnReader.h
index 7de695fee86e..1f3445918b6d 100644
--- a/velox/dwio/common/SelectiveFloatingPointColumnReader.h
+++ b/velox/dwio/common/SelectiveFloatingPointColumnReader.h
@@ -35,9 +35,11 @@ class SelectiveFloatingPointColumnReader : public SelectiveColumnReader {
             params,
             scanSpec) {}
 
-  // Offers fast path only if data and result widths match.
+  // Offers a fast path only if data and result widths match.
+  static constexpr bool kHasBulkPath = std::is_same_v<TData, TRequested>;
+
   bool hasBulkPath() const override {
-    return std::is_same_v<TData, TRequested>;
+    return kHasBulkPath;
   }
 
   template <typename Reader, bool kEncodingHasNulls>
@@ -55,7 +57,7 @@ class SelectiveFloatingPointColumnReader : public SelectiveColumnReader {
       bool isDense,
       typename ExtractValues>
   void readHelper(
-      velox::common::Filter* filter,
+      const velox::common::Filter* filter,
       const RowSet& rows,
       ExtractValues values);
 
@@ -65,7 +67,7 @@ class SelectiveFloatingPointColumnReader : public SelectiveColumnReader {
       bool kEncodingHasNulls,
       typename ExtractValues>
   void processFilter(
-      velox::common::Filter* filter,
+      const velox::common::Filter* filter,
       const RowSet& rows,
       ExtractValues extractValues);
 
@@ -80,7 +82,7 @@ template <
     bool isDense,
     typename ExtractValues>
 void SelectiveFloatingPointColumnReader<TData, TRequested>::readHelper(
-    velox::common::Filter* filter,
+    const velox::common::Filter* filter,
     const RowSet& rows,
     ExtractValues extractValues) {
   reinterpret_cast<Reader*>(this)->readWithVisitor(
@@ -90,8 +92,8 @@ void SelectiveFloatingPointColumnReader<TData, TRequested>::readHelper(
           TFilter,
           ExtractValues,
           isDense,
-          std::is_same_v<TData, TRequested>>(
-          *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
+          Reader::kHasBulkPath>(
+          *static_cast<const TFilter*>(filter), this, rows, extractValues));
 }
 
 template <typename TData, typename TRequested>
@@ -101,7 +103,7 @@ template <
     bool kEncodingHasNulls,
     typename ExtractValues>
 void SelectiveFloatingPointColumnReader<TData, TRequested>::processFilter(
-    velox::common::Filter* filter,
+    const velox::common::Filter* filter,
     const RowSet& rows,
     ExtractValues extractValues) {
   if (filter == nullptr) {
diff --git a/velox/dwio/common/SelectiveIntegerColumnReader.h b/velox/dwio/common/SelectiveIntegerColumnReader.h
index c94b5a60d789..d9ba805167a8 100644
--- a/velox/dwio/common/SelectiveIntegerColumnReader.h
+++ b/velox/dwio/common/SelectiveIntegerColumnReader.h
@@ -47,7 +47,7 @@ class SelectiveIntegerColumnReader : public SelectiveColumnReader {
       bool kEncodingHasNulls,
       typename ExtractValues>
   void processFilter(
-      velox::common::Filter* filter,
+      const velox::common::Filter* filter,
       ExtractValues extractValues,
       const RowSet& rows);
 
@@ -63,7 +63,7 @@ class SelectiveIntegerColumnReader : public SelectiveColumnReader {
       bool isDense,
       typename ExtractValues>
   void readHelper(
-      velox::common::Filter* filter,
+      const velox::common::Filter* filter,
       const RowSet& rows,
       ExtractValues extractValues);
 
@@ -80,7 +80,7 @@ template <
     bool isDense,
     typename ExtractValues>
 void SelectiveIntegerColumnReader::readHelper(
-    velox::common::Filter* filter,
+    const velox::common::Filter* filter,
     const RowSet& rows,
     ExtractValues extractValues) {
   switch (valueSize_) {
@@ -88,28 +88,28 @@ void SelectiveIntegerColumnReader::readHelper(
       reinterpret_cast<Reader*>(this)->Reader::readWithVisitor(
           rows,
           ColumnVisitor<int16_t, TFilter, ExtractValues, isDense>(
-              *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
+              *static_cast<const TFilter*>(filter), this, rows, extractValues));
       break;
 
     case 4:
       reinterpret_cast<Reader*>(this)->Reader::readWithVisitor(
           rows,
           ColumnVisitor<int32_t, TFilter, ExtractValues, isDense>(
-              *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
+              *static_cast<const TFilter*>(filter), this, rows, extractValues));
       break;
 
     case 8:
       reinterpret_cast<Reader*>(this)->Reader::readWithVisitor(
           rows,
           ColumnVisitor<int64_t, TFilter, ExtractValues, isDense>(
-              *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
+              *static_cast<const TFilter*>(filter), this, rows, extractValues));
       break;
 
     case 16:
       reinterpret_cast<Reader*>(this)->Reader::readWithVisitor(
           rows,
           ColumnVisitor<int128_t, TFilter, ExtractValues, isDense>(
-              *reinterpret_cast<TFilter*>(filter), this, rows, extractValues));
+              *static_cast<const TFilter*>(filter), this, rows, extractValues));
       break;
 
     default:
@@ -123,7 +123,7 @@ template <
     bool kEncodingHasNulls,
     typename ExtractValues>
 void SelectiveIntegerColumnReader::processFilter(
-    velox::common::Filter* filter,
+    const velox::common::Filter* filter,
     ExtractValues extractValues,
     const RowSet& rows) {
   if (filter == nullptr) {
@@ -200,6 +200,13 @@ void SelectiveIntegerColumnReader::processFilter(
               velox::common::NegatedBigintValuesUsingBitmask,
               isDense>(filter, rows, extractValues);
       break;
+    case velox::common::FilterKind::kBigintValuesUsingBloomFilter:
+      static_cast<Reader*>(this)
+          ->template readHelper<
+              Reader,
+              velox::common::BigintValuesUsingBloomFilter,
+              isDense>(filter, rows, extractValues);
+      break;
     default:
       static_cast<Reader*>(this)
           ->template readHelper<Reader, velox::common::Filter, isDense>(
@@ -246,8 +253,7 @@ void SelectiveIntegerColumnReader::processValueHook(
 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();
+  auto* filter = scanSpec_->filter() ? scanSpec_->filter() : &alwaysTrue();
   if (scanSpec_->keepValues()) {
     if (scanSpec_->valueHook()) {
       if (isDense) {
diff --git a/velox/dwio/common/SelectiveRepeatedColumnReader.cpp b/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
index ba6600002651..cee47f445c5f 100644
--- a/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
+++ b/velox/dwio/common/SelectiveRepeatedColumnReader.cpp
@@ -254,6 +254,9 @@ void SelectiveListColumnReader::read(
   makeNestedRowSet(activeRows, rows.back());
   if (child_ && !nestedRows_.empty()) {
     child_->read(child_->readOffset(), nestedRows_, nullptr);
+    nestedRowsAllSelected_ = nestedRowsAllSelected_ &&
+        nestedRows_.size() == child_->outputRows().size();
+    nestedRows_ = child_->outputRows();
   }
   numValues_ = activeRows.size();
   readOffset_ = offset + rows.back() + 1;
@@ -274,15 +277,7 @@ void SelectiveListColumnReader::getValues(
   }
 }
 
-SelectiveMapColumnReader::SelectiveMapColumnReader(
-    const TypePtr& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
-    FormatParams& params,
-    velox::common::ScanSpec& scanSpec)
-    : SelectiveRepeatedColumnReader(requestedType, params, scanSpec, fileType) {
-}
-
-uint64_t SelectiveMapColumnReader::skip(uint64_t numValues) {
+uint64_t SelectiveMapColumnReaderBase::skip(uint64_t numValues) {
   numValues = formatData_->skipNulls(numValues);
   if (keyReader_ || elementReader_) {
     std::array<int32_t, kBufferSize> buffer;
@@ -312,7 +307,7 @@ uint64_t SelectiveMapColumnReader::skip(uint64_t numValues) {
   return numValues;
 }
 
-void SelectiveMapColumnReader::read(
+void SelectiveMapColumnReaderBase::read(
     int64_t offset,
     const RowSet& rows,
     const uint64_t* incomingNulls) {
@@ -338,12 +333,34 @@ void SelectiveMapColumnReader::read(
     nestedRows_ = keyReader_->outputRows();
     if (!nestedRows_.empty()) {
       elementReader_->read(elementReader_->readOffset(), nestedRows_, nullptr);
+      nestedRowsAllSelected_ = nestedRowsAllSelected_ &&
+          nestedRows_.size() == elementReader_->outputRows().size();
+      nestedRows_ = elementReader_->outputRows();
     }
   }
   numValues_ = activeRows.size();
   readOffset_ = offset + rows.back() + 1;
 }
 
+SelectiveMapColumnReader::SelectiveMapColumnReader(
+    const TypePtr& requestedType,
+    const TypeWithIdPtr& fileType,
+    FormatParams& params,
+    ScanSpec& scanSpec)
+    : SelectiveMapColumnReaderBase(requestedType, params, scanSpec, fileType) {
+  VELOX_CHECK(!scanSpec_->isFlatMapAsStruct());
+  // We should not need this anymore.  Is there a safe way to find out if there
+  // is any prod usages that forget to set up the map children in scan spec?
+  // This should be only possible when user bypasses the connector interface and
+  // create file readers directly.
+  if (scanSpec_->children().empty()) {
+    scanSpec_->getOrCreateChild(ScanSpec::kMapKeysFieldName);
+    scanSpec_->getOrCreateChild(ScanSpec::kMapValuesFieldName);
+  }
+  scanSpec_->children()[0]->setProjectOut(true);
+  scanSpec_->children()[1]->setProjectOut(true);
+}
+
 void SelectiveMapColumnReader::getValues(
     const RowSet& rows,
     VectorPtr* result) {
@@ -368,4 +385,110 @@ void SelectiveMapColumnReader::getValues(
   }
 }
 
+SelectiveMapAsStructColumnReader::SelectiveMapAsStructColumnReader(
+    const TypePtr& requestedType,
+    const TypeWithIdPtr& fileType,
+    FormatParams& params,
+    ScanSpec& scanSpec)
+    : SelectiveMapColumnReaderBase(requestedType, params, scanSpec, fileType) {
+  VELOX_CHECK(scanSpec_->isFlatMapAsStruct() && requestedType_->isMap());
+  mapScanSpec_.addMapKeyFieldRecursively(*requestedType_->childAt(0));
+  mapScanSpec_.addMapValueFieldRecursively(*requestedType_->childAt(1));
+  column_index_t maxChannel = 0;
+  for (auto& childSpec : scanSpec_->children()) {
+    auto field = folly::tryTo<int64_t>(childSpec->fieldName());
+    VELOX_CHECK(
+        field.hasValue(),
+        "Fail to parse field name: {}",
+        childSpec->fieldName());
+    keyToIndex_[*field] = childSpec->channel();
+    maxChannel = std::max(maxChannel, childSpec->channel());
+  }
+  copyRanges_.resize(maxChannel + 1);
+}
+
+void SelectiveMapAsStructColumnReader::getValues(
+    const RowSet& rows,
+    VectorPtr* result) {
+  VELOX_CHECK_NOT_NULL(*result);
+  VELOX_CHECK(
+      result->get()->type()->isRow(),
+      "Expect ROW, got {}",
+      result->get()->type()->toString());
+  BaseVector::prepareForReuse(*result, rows.size());
+  auto* resultRow = result->get()->asChecked<RowVector>();
+  setComplexNulls(rows, *result);
+  for (auto& child : resultRow->children()) {
+    bits::fillBits(child->mutableRawNulls(), 0, rows.size(), bits::kNull);
+  }
+  numValues_ = rows.size();
+  if (nestedRows_.empty()) {
+    return;
+  }
+  keyReader_->getValues(nestedRows_, &mapKeys_);
+  prepareStructResult(requestedType_->childAt(1), &mapValues_);
+  elementReader_->getValues(nestedRows_, &mapValues_);
+  decodedKeys_.decode(*mapKeys_);
+  for (auto& ranges : copyRanges_) {
+    ranges.clear();
+  }
+  switch (mapKeys_->type()->kind()) {
+    case TypeKind::TINYINT:
+      makeCopyRanges<int8_t>(rows);
+      break;
+    case TypeKind::SMALLINT:
+      makeCopyRanges<int16_t>(rows);
+      break;
+    case TypeKind::INTEGER:
+      makeCopyRanges<int32_t>(rows);
+      break;
+    case TypeKind::BIGINT:
+      makeCopyRanges<int64_t>(rows);
+      break;
+    default:
+      VELOX_UNSUPPORTED(
+          "Unsupported key type: {}", mapKeys_->type()->toString());
+  }
+  for (column_index_t i = 0; i < resultRow->childrenSize(); ++i) {
+    resultRow->childAt(i)->copyRanges(mapValues_.get(), copyRanges_[i]);
+  }
+}
+
+template <typename T>
+void SelectiveMapAsStructColumnReader::makeCopyRanges(const RowSet& rows) {
+  auto* nulls = nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
+  for (vector_size_t i = 0,
+                     currentOffset = 0,
+                     currentRow = 0,
+                     nestedRowIndex = 0;
+       i < rows.size();
+       ++i) {
+    const auto row = rows[i];
+    if (nulls && bits::isBitNull(nulls, row)) {
+      anyNulls_ = true;
+      continue;
+    }
+    currentOffset += sumLengths(allLengths_, nulls, currentRow, row);
+    currentRow = row + 1;
+    nestedRowIndex =
+        advanceNestedRows(nestedRows_, nestedRowIndex, currentOffset);
+    currentOffset += allLengths_[row];
+    const auto newNestedRowIndex =
+        advanceNestedRows(nestedRows_, nestedRowIndex, currentOffset);
+    for (auto j = nestedRowIndex; j < newNestedRowIndex; ++j) {
+      VELOX_CHECK(!decodedKeys_.isNullAt(j));
+      auto it = keyToIndex_.find(decodedKeys_.valueAt<T>(j));
+      if (it == keyToIndex_.end()) {
+        continue;
+      }
+      copyRanges_[it->second].push_back({
+          .sourceIndex = j,
+          .targetIndex = i,
+          .count = 1,
+      });
+    }
+    nestedRowIndex = newNestedRowIndex;
+  }
+}
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveRepeatedColumnReader.h b/velox/dwio/common/SelectiveRepeatedColumnReader.h
index f1792ff9511e..de072b8d028b 100644
--- a/velox/dwio/common/SelectiveRepeatedColumnReader.h
+++ b/velox/dwio/common/SelectiveRepeatedColumnReader.h
@@ -128,13 +128,9 @@ class SelectiveListColumnReader : public SelectiveRepeatedColumnReader {
   std::unique_ptr<SelectiveColumnReader> child_;
 };
 
-class SelectiveMapColumnReader : public SelectiveRepeatedColumnReader {
+class SelectiveMapColumnReaderBase : public SelectiveRepeatedColumnReader {
  public:
-  SelectiveMapColumnReader(
-      const TypePtr& requestedType,
-      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
-      FormatParams& params,
-      velox::common::ScanSpec& scanSpec);
+  using SelectiveRepeatedColumnReader::SelectiveRepeatedColumnReader;
 
   void resetFilterCaches() override {
     keyReader_->resetFilterCaches();
@@ -146,11 +142,53 @@ class SelectiveMapColumnReader : public SelectiveRepeatedColumnReader {
   void read(int64_t offset, const RowSet& rows, const uint64_t* incomingNulls)
       override;
 
-  void getValues(const RowSet& rows, VectorPtr* result) override;
+  void seekToRowGroup(int64_t index) override {
+    SelectiveRepeatedColumnReader::seekToRowGroup(index);
+    keyReader_->seekToRowGroup(index);
+    keyReader_->setReadOffsetRecursive(0);
+    elementReader_->seekToRowGroup(index);
+    elementReader_->setReadOffsetRecursive(0);
+    childTargetReadOffset_ = 0;
+  }
 
  protected:
   std::unique_ptr<SelectiveColumnReader> keyReader_;
   std::unique_ptr<SelectiveColumnReader> elementReader_;
 };
 
+class SelectiveMapColumnReader : public SelectiveMapColumnReaderBase {
+ public:
+  SelectiveMapColumnReader(
+      const TypePtr& requestedType,
+      const TypeWithIdPtr& fileType,
+      FormatParams& params,
+      ScanSpec& scanSpec);
+
+  void getValues(const RowSet& rows, VectorPtr* result) override;
+};
+
+class SelectiveMapAsStructColumnReader : public SelectiveMapColumnReaderBase {
+ public:
+  SelectiveMapAsStructColumnReader(
+      const TypePtr& requestedType,
+      const TypeWithIdPtr& fileType,
+      FormatParams& params,
+      ScanSpec& scanSpec);
+
+  void getValues(const RowSet& rows, VectorPtr* result) override;
+
+ protected:
+  ScanSpec mapScanSpec_{"<mapScanSpec>"};
+
+ private:
+  template <typename T>
+  void makeCopyRanges(const RowSet& rows);
+
+  folly::F14FastMap<int64_t, column_index_t> keyToIndex_;
+  std::vector<std::vector<BaseVector::CopyRange>> copyRanges_;
+  VectorPtr mapKeys_;
+  VectorPtr mapValues_;
+  DecodedVector decodedKeys_;
+};
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/SelectiveStructColumnReader.cpp b/velox/dwio/common/SelectiveStructColumnReader.cpp
index 4401e73977bb..e1a990fee89c 100644
--- a/velox/dwio/common/SelectiveStructColumnReader.cpp
+++ b/velox/dwio/common/SelectiveStructColumnReader.cpp
@@ -20,7 +20,6 @@
 #include "velox/dwio/common/ColumnLoader.h"
 
 namespace facebook::velox::dwio::common {
-
 namespace {
 
 bool testFilterOnConstant(const velox::common::ScanSpec& spec) {
@@ -224,6 +223,74 @@ uint64_t SelectiveStructColumnReaderBase::skip(uint64_t numValues) {
   return numValues;
 }
 
+void SelectiveStructColumnReaderBase::seekToPropagateNullsToChildren(
+    int64_t offset) {
+  if (offset == readOffset_) {
+    return;
+  }
+  if (readOffset_ < offset) {
+    if (numParentNulls_) {
+      VELOX_CHECK_LE(
+          parentNullsRecordedTo_,
+          offset,
+          "Must not seek to before parentNullsRecordedTo_");
+    }
+    auto distance = offset - readOffset_ - numParentNulls_;
+    auto numNonNulls = formatData_->skipNulls(distance);
+    // We inform children how many nulls there were between original position
+    // and destination. The children will seek this many less. The
+    // nulls include the nulls found here as well as the enclosing
+    // level nulls reported to this by parents.
+    for (auto& child : children_) {
+      if (child) {
+        child->addSkippedParentNulls(
+            readOffset_, offset, numParentNulls_ + distance - numNonNulls);
+      }
+    }
+    numParentNulls_ = 0;
+    parentNullsRecordedTo_ = 0;
+    readOffset_ = offset;
+  } else {
+    VELOX_FAIL("Seeking backward on a ColumnReader");
+  }
+}
+
+void SelectiveStructColumnReaderBase::seekToRowGroupFixedRowsPerRowGroup(
+    const int64_t index,
+    const int32_t rowsPerRowGroup) {
+  dwio::common::SelectiveStructColumnReaderBase::seekToRowGroup(index);
+  if (isTopLevel_ && !formatData_->hasNulls()) {
+    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.
+  setReadOffsetRecursive(index * rowsPerRowGroup);
+  for (auto& child : children_) {
+    child->seekToRowGroup(index);
+  }
+}
+
+/// Advance field reader to the row group closest to specified offset by
+/// calling seekToRowGroup.
+void SelectiveStructColumnReaderBase::advanceFieldReaderFixedRowsPerRowGroup(
+    dwio::common::SelectiveColumnReader* reader,
+    const int64_t offset,
+    const int32_t rowsPerRowGroup) {
+  if (!reader->isTopLevel()) {
+    return;
+  }
+  const auto rowGroup = reader->readOffset() / rowsPerRowGroup;
+  const auto nextRowGroup = offset / rowsPerRowGroup;
+  if (nextRowGroup > rowGroup) {
+    reader->seekToRowGroup(nextRowGroup);
+    reader->setReadOffset(nextRowGroup * rowsPerRowGroup);
+  }
+}
+
 void SelectiveStructColumnReaderBase::fillOutputRowsFromMutation(
     vector_size_t size) {
   if (mutation_->deletedRows) {
@@ -339,8 +406,7 @@ void SelectiveStructColumnReaderBase::read(
     activeRows = outputRows_;
   }
 
-  const uint64_t* structNulls =
-      nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr;
+  const uint64_t* structNulls = nulls();
   // A struct reader may have a null/non-null filter
   if (scanSpec_->filter()) {
     const auto kind = scanSpec_->filter()->kind();
@@ -362,7 +428,6 @@ void SelectiveStructColumnReaderBase::read(
   VELOX_CHECK(!childSpecs.empty());
   for (size_t i = 0; i < childSpecs.size(); ++i) {
     const auto& childSpec = childSpecs[i];
-    VELOX_TRACE_HISTORY_PUSH("read %s", childSpec->fieldName().c_str());
 
     if (childSpec->deltaUpdate()) {
       // Will make LazyVector.
@@ -385,7 +450,7 @@ void SelectiveStructColumnReaderBase::read(
     const auto fieldIndex = childSpec->subscript();
     auto* reader = children_.at(fieldIndex);
     if (reader->isTopLevel() && childSpec->projectOut() &&
-        !childSpec->hasFilter()) {
+        !childSpec->hasFilter() && generateLazyChildren_) {
       // Will make a LazyVector.
       continue;
     }
@@ -441,10 +506,7 @@ void SelectiveStructColumnReaderBase::recordParentNullsInChildren(
 
     const auto fieldIndex = childSpec->subscript();
     auto* reader = children_.at(fieldIndex);
-    reader->addParentNulls(
-        offset,
-        nullsInReadRange_ ? nullsInReadRange_->as<uint64_t>() : nullptr,
-        rows);
+    reader->addParentNulls(offset, nulls(), rows);
   }
 }
 
@@ -467,6 +529,12 @@ bool SelectiveStructColumnReaderBase::isChildMissing(
        childSpec.channel() >= fileType_->size());
 }
 
+std::unique_ptr<velox::dwio::common::ColumnLoader>
+SelectiveStructColumnReaderBase::makeColumnLoader(vector_size_t index) {
+  return std::make_unique<velox::dwio::common::ColumnLoader>(
+      this, children_[index], numReads_);
+}
+
 void SelectiveStructColumnReaderBase::getValues(
     const RowSet& rows,
     VectorPtr* result) {
@@ -486,7 +554,6 @@ void SelectiveStructColumnReaderBase::getValues(
 
   setComplexNulls(rows, *result);
   for (const auto& childSpec : scanSpec_->children()) {
-    VELOX_TRACE_HISTORY_PUSH("getValues %s", childSpec->fieldName().c_str());
     if (!childSpec->keepValues()) {
       continue;
     }
@@ -543,7 +610,8 @@ void SelectiveStructColumnReaderBase::getValues(
       continue;
     }
 
-    if (childSpec->hasFilter() || !children_[index]->isTopLevel()) {
+    if (childSpec->hasFilter() || !children_[index]->isTopLevel() ||
+        !generateLazyChildren_) {
       children_[index]->getValues(rows, &childResult);
       continue;
     }
@@ -551,7 +619,7 @@ void SelectiveStructColumnReaderBase::getValues(
     // LazyVector result.
     setOutputRowsForLazy(rows);
     setLazyField(
-        std::make_unique<ColumnLoader>(this, children_[index], numReads_),
+        makeColumnLoader(index),
         resultRow->type()->childAt(channel),
         rows.size(),
         memoryPool_,
diff --git a/velox/dwio/common/SelectiveStructColumnReader.h b/velox/dwio/common/SelectiveStructColumnReader.h
index 6aa21cae9c4f..5b8e8f720475 100644
--- a/velox/dwio/common/SelectiveStructColumnReader.h
+++ b/velox/dwio/common/SelectiveStructColumnReader.h
@@ -20,6 +20,8 @@
 
 namespace facebook::velox::dwio::common {
 
+class ColumnLoader;
+
 template <typename T, typename KeyNode, typename FormatData>
 class SelectiveFlatMapColumnReaderHelper;
 
@@ -108,18 +110,20 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
 
   // 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;
+  static constexpr int32_t kConstantChildSpecSubscript{-1};
 
   SelectiveStructColumnReaderBase(
       const TypePtr& requestedType,
       const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       FormatParams& params,
       velox::common::ScanSpec& scanSpec,
-      bool isRoot = false)
+      bool isRoot = false,
+      bool generateLazyChildren = true)
       : SelectiveColumnReader(requestedType, fileType, params, scanSpec),
         debugString_(
             getExceptionContext().message(VeloxException::Type::kSystem)),
         isRoot_(isRoot),
+        generateLazyChildren_(generateLazyChildren),
         rows_(memoryPool_) {}
 
   bool hasDeletion() const final {
@@ -136,17 +140,40 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
         isChildMissing(childSpec);
   }
 
-  std::vector<SelectiveColumnReader*> children_;
-
- private:
-  void fillOutputRowsFromMutation(vector_size_t size);
-
   /// 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(int64_t offset, const RowSet& rows);
 
+  /// An implementation of seekTo that calls addSkippedParentNulls on each
+  /// child. Available as a helper function to formats that need it.
+  void seekToPropagateNullsToChildren(const int64_t offset);
+
+  /// A helper function that implements seekToRowGroup for formats that support
+  /// a fixed number of rows per row group.
+  void seekToRowGroupFixedRowsPerRowGroup(
+      const int64_t index,
+      const int32_t rowsPerRowGroup);
+
+  /// A helper function that implements advanceFieldReader for formats that
+  /// support a fixed number of rows per row group
+  void advanceFieldReaderFixedRowsPerRowGroup(
+      SelectiveColumnReader* reader,
+      const int64_t offset,
+      const int32_t rowsPerRowGroup);
+
+  virtual std::unique_ptr<velox::dwio::common::ColumnLoader> makeColumnLoader(
+      vector_size_t index);
+
+  // Sequence number of output batch. Checked against ColumnLoaders
+  // created by 'this' to verify they are still valid at load.
+  uint64_t numReads_ = 0;
+  std::vector<SelectiveColumnReader*> children_;
+
+ private:
+  void fillOutputRowsFromMutation(vector_size_t size);
+
   void setOutputRowsForLazy(const RowSet& rows) {
     if (useOutputRows() && rows.size() != outputRows_.size()) {
       setOutputRows(rows);
@@ -164,16 +191,15 @@ class SelectiveStructColumnReaderBase : public SelectiveColumnReader {
   // table.
   const bool isRoot_;
 
+  // Whether or not this should produce lazy vectors for children.
+  const bool generateLazyChildren_;
+
   // Dense set of rows to read in next().
   raw_vector<vector_size_t> rows_;
 
-  // Sequence number of output batch. Checked against ColumnLoaders
-  // created by 'this' to verify they are still valid at load.
-  uint64_t numReads_ = 0;
-
   int64_t lazyVectorReadOffset_;
 
-  int64_t currentRowNumber_ = -1;
+  int64_t currentRowNumber_{-1};
 
   const Mutation* mutation_ = nullptr;
 
diff --git a/velox/dwio/common/SortingWriter.cpp b/velox/dwio/common/SortingWriter.cpp
index 00bab4ee5360..d67efd6ec223 100644
--- a/velox/dwio/common/SortingWriter.cpp
+++ b/velox/dwio/common/SortingWriter.cpp
@@ -142,8 +142,9 @@ vector_size_t SortingWriter::outputBatchRows() {
       std::numeric_limits<vector_size_t>::max();
   if (sortBuffer_->estimateOutputRowSize().has_value() &&
       sortBuffer_->estimateOutputRowSize().value() != 0) {
-    const uint64_t maxOutputRows =
-        maxOutputBytesConfig_ / sortBuffer_->estimateOutputRowSize().value();
+    const auto maxOutputRows = std::max<size_t>(
+        static_cast<size_t>(1),
+        maxOutputBytesConfig_ / sortBuffer_->estimateOutputRowSize().value());
     if (UNLIKELY(maxOutputRows > std::numeric_limits<vector_size_t>::max())) {
       return maxOutputRowsConfig_;
     }
diff --git a/velox/dwio/common/Statistics.h b/velox/dwio/common/Statistics.h
index 1c6965d6d71c..95beba497df9 100644
--- a/velox/dwio/common/Statistics.h
+++ b/velox/dwio/common/Statistics.h
@@ -18,9 +18,11 @@
 
 #include <folly/Hash.h>
 #include <folly/container/F14Map.h>
+#include "velox/dwio/common/UnitLoader.h"
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/RuntimeMetrics.h"
+#include "velox/common/io/IoStatistics.h"
 #include "velox/dwio/common/exception/Exception.h"
 
 namespace facebook::velox::dwio::common {
@@ -493,10 +495,11 @@ class MapColumnStatistics : public virtual ColumnStatistics {
     values.reserve(entryStatistics_.size());
     for (const auto& entry : entryStatistics_) {
       auto& stats = *entry.second;
-      values.push_back(fmt::format(
-          "{{ Key: {}, Stats: {},}}",
-          entry.first.toString(),
-          stats.toString()));
+      values.push_back(
+          fmt::format(
+              "{{ Key: {}, Stats: {},}}",
+              entry.first.toString(),
+              stats.toString()));
     }
     std::string repr;
     folly::join(",", values, repr);
@@ -536,6 +539,9 @@ struct ColumnReaderStatistics {
   // Number of rows returned by string dictionary reader that is flattened
   // instead of keeping dictionary encoding.
   int64_t flattenStringDictionaryValues{0};
+
+  // Total time spent in loading pages, in nanoseconds.
+  io::IoCounter pageLoadTimeNs;
 };
 
 struct RuntimeStatistics {
@@ -558,39 +564,53 @@ struct RuntimeStatistics {
 
   int64_t numStripes{0};
 
+  UnitLoaderStats unitLoaderStats;
   ColumnReaderStatistics columnReaderStatistics;
 
-  std::unordered_map<std::string, RuntimeCounter> toMap() {
-    std::unordered_map<std::string, RuntimeCounter> result;
+  std::unordered_map<std::string, RuntimeMetric> toRuntimeMetricMap() {
+    std::unordered_map<std::string, RuntimeMetric> result;
+    for (const auto& [name, metric] : unitLoaderStats.stats()) {
+      result.emplace(name, RuntimeMetric(metric.sum, metric.unit));
+    }
     if (skippedSplits > 0) {
-      result.emplace("skippedSplits", RuntimeCounter(skippedSplits));
+      result.emplace("skippedSplits", RuntimeMetric(skippedSplits));
     }
     if (processedSplits > 0) {
-      result.emplace("processedSplits", RuntimeCounter(processedSplits));
+      result.emplace("processedSplits", RuntimeMetric(processedSplits));
     }
     if (skippedSplitBytes > 0) {
       result.emplace(
           "skippedSplitBytes",
-          RuntimeCounter(skippedSplitBytes, RuntimeCounter::Unit::kBytes));
+          RuntimeMetric(skippedSplitBytes, RuntimeCounter::Unit::kBytes));
     }
     if (skippedStrides > 0) {
-      result.emplace("skippedStrides", RuntimeCounter(skippedStrides));
+      result.emplace("skippedStrides", RuntimeMetric(skippedStrides));
     }
     if (processedStrides > 0) {
-      result.emplace("processedStrides", RuntimeCounter(processedStrides));
+      result.emplace("processedStrides", RuntimeMetric(processedStrides));
     }
     if (footerBufferOverread > 0) {
       result.emplace(
           "footerBufferOverread",
-          RuntimeCounter(footerBufferOverread, RuntimeCounter::Unit::kBytes));
+          RuntimeMetric(footerBufferOverread, RuntimeCounter::Unit::kBytes));
     }
     if (numStripes > 0) {
-      result.emplace("numStripes", RuntimeCounter(numStripes));
+      result.emplace("numStripes", RuntimeMetric(numStripes));
     }
     if (columnReaderStatistics.flattenStringDictionaryValues > 0) {
       result.emplace(
           "flattenStringDictionaryValues",
-          RuntimeCounter(columnReaderStatistics.flattenStringDictionaryValues));
+          RuntimeMetric(columnReaderStatistics.flattenStringDictionaryValues));
+    }
+    if (columnReaderStatistics.pageLoadTimeNs.sum() > 0) {
+      result.emplace(
+          "pageLoadTimeNs",
+          RuntimeMetric(
+              columnReaderStatistics.pageLoadTimeNs.sum(),
+              columnReaderStatistics.pageLoadTimeNs.count(),
+              columnReaderStatistics.pageLoadTimeNs.min(),
+              columnReaderStatistics.pageLoadTimeNs.max(),
+              RuntimeCounter::Unit::kNanos));
     }
     return result;
   }
diff --git a/velox/dwio/common/StreamUtil.h b/velox/dwio/common/StreamUtil.h
index 0a0a2b2b0e86..77b0d429ab76 100644
--- a/velox/dwio/common/StreamUtil.h
+++ b/velox/dwio/common/StreamUtil.h
@@ -144,7 +144,7 @@ inline void readContiguous(
 
 // Returns the number of elements in rows that are < limit.
 inline int32_t numBelow(folly::Range<const int32_t*> rows, int32_t limit) {
-  return std::lower_bound(rows.begin(), rows.end(), limit) - rows.begin();
+  return std::lower_bound(rows.cbegin(), rows.cend(), limit) - rows.cbegin();
 }
 
 template <typename T, typename SingleValue, typename SparseRange>
diff --git a/velox/dwio/common/TypeUtils.cpp b/velox/dwio/common/TypeUtils.cpp
index 29e22046196f..b0220b9acdc2 100644
--- a/velox/dwio/common/TypeUtils.cpp
+++ b/velox/dwio/common/TypeUtils.cpp
@@ -131,11 +131,13 @@ void checkTypeCompatibility(
     const FShouldRead& shouldRead,
     const std::function<std::string()>& exceptionMessageCreator) {
   if (shouldRead(to) && !isCompatible(from.kind(), kind(to))) {
-    VELOX_SCHEMA_MISMATCH_ERROR(fmt::format(
-        "{}, From Kind: {}, To Kind: {}",
-        exceptionMessageCreator ? exceptionMessageCreator() : "Schema mismatch",
-        mapTypeKindToName(from.kind()),
-        mapTypeKindToName(kind(to))));
+    VELOX_SCHEMA_MISMATCH_ERROR(
+        fmt::format(
+            "{}, From Kind: {}, To Kind: {}",
+            exceptionMessageCreator ? exceptionMessageCreator()
+                                    : "Schema mismatch",
+            TypeKindName::toName(from.kind()),
+            TypeKindName::toName(kind(to))));
   }
 
   if (recurse) {
diff --git a/velox/dwio/common/TypeWithId.h b/velox/dwio/common/TypeWithId.h
index a147cfe5066f..80084dbfb535 100644
--- a/velox/dwio/common/TypeWithId.h
+++ b/velox/dwio/common/TypeWithId.h
@@ -97,4 +97,6 @@ class TypeWithId : public velox::Tree<std::shared_ptr<const TypeWithId>> {
   const std::vector<std::shared_ptr<const TypeWithId>> children_;
 };
 
+using TypeWithIdPtr = std::shared_ptr<const TypeWithId>;
+
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/UnitLoader.h b/velox/dwio/common/UnitLoader.h
index d3125dacc4be..d1fc54ab2407 100644
--- a/velox/dwio/common/UnitLoader.h
+++ b/velox/dwio/common/UnitLoader.h
@@ -16,9 +16,13 @@
 
 #pragma once
 
+#include <folly/Synchronized.h>
+#include <folly/container/F14Map.h>
 #include <cstdint>
 #include <memory>
 #include <vector>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/RuntimeMetrics.h"
 
 namespace facebook::velox::dwio::common {
 
@@ -39,6 +43,44 @@ class LoadUnit {
   virtual uint64_t getIoSize() = 0;
 };
 
+class UnitLoaderStats {
+ public:
+  UnitLoaderStats() = default;
+
+  void addCounter(const std::string& name, RuntimeCounter counter) {
+    auto locked = stats_.wlock();
+    auto it = locked->find(name);
+    if (it == locked->end()) {
+      auto [ptr, inserted] = locked->emplace(name, RuntimeMetric(counter.unit));
+      VELOX_CHECK(inserted);
+      ptr->second.addValue(counter.value);
+    } else {
+      VELOX_CHECK_EQ(it->second.unit, counter.unit);
+      it->second.addValue(counter.value);
+    }
+  }
+
+  void merge(const UnitLoaderStats& other) {
+    auto otherStats = other.stats();
+    auto locked = stats_.wlock();
+    for (const auto& [name, metric] : otherStats) {
+      auto it = locked->find(name);
+      if (it == locked->end()) {
+        locked->emplace(name, metric);
+      } else {
+        it->second.merge(metric);
+      }
+    }
+  }
+
+  folly::F14FastMap<std::string, RuntimeMetric> stats() const {
+    return stats_.copy();
+  }
+
+ private:
+  folly::Synchronized<folly::F14FastMap<std::string, RuntimeMetric>> stats_;
+};
+
 class UnitLoader {
  public:
   virtual ~UnitLoader() = default;
@@ -56,6 +98,10 @@ class UnitLoader {
   /// 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;
+
+  virtual UnitLoaderStats stats() {
+    return UnitLoaderStats();
+  };
 };
 
 class UnitLoaderFactory {
diff --git a/velox/dwio/common/Writer.cpp b/velox/dwio/common/Writer.cpp
index 87951cad7c59..10384341fc2b 100644
--- a/velox/dwio/common/Writer.cpp
+++ b/velox/dwio/common/Writer.cpp
@@ -80,6 +80,13 @@ bool Writer::isFinishing() const {
 }
 
 void Writer::checkRunning() const {
+  // Typically represents writer misuse.
+  VELOX_USER_CHECK_NE(
+      state_,
+      State::kClosed,
+      "Writer is not running: {}. Write operations are not allowed on a closed writer.",
+      Writer::stateString(state_));
+
   VELOX_CHECK_EQ(
       state_,
       State::kRunning,
diff --git a/velox/dwio/common/compression/CMakeLists.txt b/velox/dwio/common/compression/CMakeLists.txt
index e1f1d0ac60cf..ed39366b3a54 100644
--- a/velox/dwio/common/compression/CMakeLists.txt
+++ b/velox/dwio/common/compression/CMakeLists.txt
@@ -12,12 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_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
+)
 
 velox_link_libraries(
   velox_dwio_common_compression
   velox_dwio_common
   xsimd
   Folly::folly
-  Snappy::snappy)
+  Snappy::snappy
+)
diff --git a/velox/dwio/common/compression/Compression.cpp b/velox/dwio/common/compression/Compression.cpp
index 1b66c17df041..376f2994b9f6 100644
--- a/velox/dwio/common/compression/Compression.cpp
+++ b/velox/dwio/common/compression/Compression.cpp
@@ -35,6 +35,8 @@ using memory::MemoryPool;
 
 namespace {
 
+constexpr int kGzipCodec = 16;
+
 class ZstdCompressor : public Compressor {
  public:
   explicit ZstdCompressor(int32_t level) : Compressor{level} {}
@@ -57,7 +59,7 @@ ZstdCompressor::compress(const void* src, void* dest, uint64_t length) {
 
 class ZlibCompressor : public Compressor {
  public:
-  explicit ZlibCompressor(int32_t level);
+  explicit ZlibCompressor(int32_t level, int32_t windowBits, bool isGzip);
 
   ~ZlibCompressor() override;
 
@@ -68,13 +70,17 @@ class ZlibCompressor : public Compressor {
   z_stream stream_;
 };
 
-ZlibCompressor::ZlibCompressor(int32_t level)
+ZlibCompressor::ZlibCompressor(int32_t level, int32_t windowBits, bool isGzip)
     : Compressor{level}, isCompressCalled_{false} {
   stream_.zalloc = Z_NULL;
   stream_.zfree = Z_NULL;
   stream_.opaque = Z_NULL;
+  if (isGzip) {
+    windowBits = (windowBits < 0 ? -windowBits : windowBits) | kGzipCodec;
+  }
   DWIO_ENSURE_EQ(
-      deflateInit2(&stream_, level_, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY),
+      deflateInit2(
+          &stream_, level_, Z_DEFLATED, windowBits, 8, Z_DEFAULT_STRATEGY),
       Z_OK,
       "Error while calling deflateInit2() for zlib.");
 }
@@ -150,9 +156,9 @@ ZlibDecompressor::ZlibDecompressor(
   zstream_.next_out = Z_NULL;
   zstream_.avail_out = folly::to<uInt>(blockSize);
   int zlibWindowBits = windowBits;
-  constexpr int GZIP_DETECT_CODE = 32;
   if (isGzip) {
-    zlibWindowBits = zlibWindowBits | GZIP_DETECT_CODE;
+    zlibWindowBits =
+        (zlibWindowBits < 0 ? -zlibWindowBits : zlibWindowBits) | kGzipCodec;
   }
   const auto result = inflateInit2(&zstream_, zlibWindowBits);
   DWIO_ENSURE_EQ(
@@ -392,9 +398,6 @@ uint64_t Lz4Decompressor::decompressInternal(
   return static_cast<uint64_t>(result);
 }
 
-// NOTE: We do not keep `ZSTD_DCtx' around on purpose, because if we keep it
-// around, in flat map column reader we have hundreds of thousands of
-// decompressors at same time and causing OOM.
 class ZstdDecompressor : public Decompressor {
  public:
   explicit ZstdDecompressor(
@@ -418,7 +421,10 @@ uint64_t ZstdDecompressor::decompress(
     uint64_t srcLength,
     char* dest,
     uint64_t destLength) {
-  auto ret = ZSTD_decompress(dest, destLength, src, srcLength);
+  // Reuse 'ZSTD_DCtx' per-thread to avoid repeated allocations.
+  thread_local std::unique_ptr<ZSTD_DCtx, size_t (*)(ZSTD_DCtx*)> ctx{
+      ZSTD_createDCtx(), ZSTD_freeDCtx};
+  auto ret = ZSTD_decompressDCtx(ctx.get(), dest, destLength, src, srcLength);
   DWIO_ENSURE(
       !ZSTD_isError(ret),
       "ZSTD returned an error: ",
@@ -549,6 +555,8 @@ bool ZlibDecompressionStream::readOrSkip(const void** data, int32_t* size) {
     *size = static_cast<int32_t>(availSize);
     outputBufferPtr_ = inputBufferPtr_ + availSize;
     outputBufferLength_ = 0;
+    inputBufferPtr_ += availSize;
+    remainingLength_ -= availSize;
   } else {
     DWIO_ENSURE_EQ(
         state_,
@@ -561,42 +569,49 @@ bool ZlibDecompressionStream::readOrSkip(const void** data, int32_t* size) {
         getDecompressedLength(inputBufferPtr_, availSize).first);
 
     reset();
-    zstream_.next_in =
-        reinterpret_cast<Bytef*>(const_cast<char*>(inputBufferPtr_));
-    zstream_.avail_in = folly::to<uInt>(availSize);
-    outputBufferPtr_ = outputBuffer_->data();
-    zstream_.next_out =
-        reinterpret_cast<Bytef*>(const_cast<char*>(outputBufferPtr_));
-    zstream_.avail_out = folly::to<uInt>(blockSize_);
     int32_t result;
+    *size = 0;
     do {
-      result = inflate(
-          &zstream_, availSize == remainingLength_ ? Z_FINISH : Z_SYNC_FLUSH);
-      switch (result) {
-        case Z_OK:
-          remainingLength_ -= availSize;
-          inputBufferPtr_ += availSize;
-          readBuffer(true);
-          availSize = std::min(
-              static_cast<size_t>(inputBufferPtrEnd_ - inputBufferPtr_),
-              remainingLength_);
-          zstream_.next_in =
-              reinterpret_cast<Bytef*>(const_cast<char*>(inputBufferPtr_));
-          zstream_.avail_in = static_cast<uInt>(availSize);
-          break;
-        case Z_STREAM_END:
-          break;
-        default:
-          DWIO_RAISE(
-              "Error in ZlibDecompressionStream::Next in ",
-              getName(),
-              ". error: ",
-              result,
-              " Info: ",
-              ZlibDecompressor::streamDebugInfo_);
+      if (inputBufferPtr_ == inputBufferPtrEnd_) {
+        readBuffer(true);
       }
+      zstream_.next_in =
+          reinterpret_cast<Bytef*>(const_cast<char*>(inputBufferPtr_));
+      zstream_.avail_in =
+          static_cast<size_t>(inputBufferPtrEnd_ - inputBufferPtr_);
+
+      do {
+        // size_ of outputBuffer_ is not updated in inflate, so *size is used
+        // here to ensure enough capacity for the output data.
+        outputBuffer_->extend(*size);
+        outputBufferPtr_ = outputBuffer_->data();
+        zstream_.next_out = reinterpret_cast<Bytef*>(
+            const_cast<char*>(outputBufferPtr_ + *size));
+        zstream_.avail_out = folly::to<uInt>(blockSize_);
+        result = inflate(&zstream_, Z_SYNC_FLUSH);
+        // Result handling adapted from https://zlib.net/zlib_how.html
+        switch (result) {
+          case Z_NEED_DICT:
+            result = Z_DATA_ERROR;
+            [[fallthrough]];
+          case Z_DATA_ERROR:
+            [[fallthrough]];
+          case Z_MEM_ERROR:
+            [[fallthrough]];
+          case Z_STREAM_ERROR:
+            DWIO_RAISE("Failed to inflate input data. error: ", result);
+          default:
+            *size += static_cast<int32_t>(
+                blockSize_ - static_cast<int64_t>(zstream_.avail_out));
+            const size_t inputConsumed =
+                reinterpret_cast<const char*>(zstream_.next_in) -
+                inputBufferPtr_;
+            remainingLength_ -= inputConsumed;
+            inputBufferPtr_ += inputConsumed;
+        }
+      } while (zstream_.avail_out == 0);
     } while (result != Z_STREAM_END);
-    *size = static_cast<int32_t>(blockSize_ - zstream_.avail_out);
+
     if (data) {
       *data = outputBufferPtr_;
     }
@@ -604,8 +619,6 @@ bool ZlibDecompressionStream::readOrSkip(const void** data, int32_t* size) {
     outputBufferPtr_ += *size;
   }
 
-  inputBufferPtr_ += availSize;
-  remainingLength_ -= availSize;
   bytesReturned_ += *size;
   return true;
 }
@@ -623,7 +636,18 @@ std::unique_ptr<Compressor> createCompressor(
           "Initialized zlib compressor with compression level {}",
           options.format.zlib.compressionLevel);
       return std::make_unique<ZlibCompressor>(
+          options.format.zlib.compressionLevel,
+          options.format.zlib.windowBits,
+          false);
+    }
+    case CompressionKind::CompressionKind_GZIP: {
+      XLOG_FIRST_N(INFO, 1) << fmt::format(
+          "Initialized zlib compressor with compression level {}",
           options.format.zlib.compressionLevel);
+      return std::make_unique<ZlibCompressor>(
+          options.format.zlib.compressionLevel,
+          options.format.zlib.windowBits,
+          true);
     }
     case CompressionKind::CompressionKind_ZSTD: {
       XLOG_FIRST_N(INFO, 1) << fmt::format(
diff --git a/velox/dwio/common/compression/PagedInputStream.cpp b/velox/dwio/common/compression/PagedInputStream.cpp
index 08357298cf57..66aa8ffb156d 100644
--- a/velox/dwio/common/compression/PagedInputStream.cpp
+++ b/velox/dwio/common/compression/PagedInputStream.cpp
@@ -165,7 +165,7 @@ bool PagedInputStream::readOrSkip(const void** data, int32_t* size) {
   // perform decryption
   if (decrypter_) {
     decryptionBuffer_ =
-        decrypter_->decrypt(folly::StringPiece{input, remainingLength_});
+        decrypter_->decrypt(std::string_view{input, remainingLength_});
     input = reinterpret_cast<const char*>(decryptionBuffer_->data());
     remainingLength_ = decryptionBuffer_->length();
     if (data) {
diff --git a/velox/dwio/common/compression/PagedInputStream.h b/velox/dwio/common/compression/PagedInputStream.h
index 15b1acd630a0..39d48cbb6869 100644
--- a/velox/dwio/common/compression/PagedInputStream.h
+++ b/velox/dwio/common/compression/PagedInputStream.h
@@ -56,7 +56,7 @@ class PagedInputStream : public dwio::common::SeekableInputStream {
   // NOTE: This always returns true.
   bool SkipInt64(int64_t count) override;
 
-  google::protobuf::int64 ByteCount() const override {
+  int64_t ByteCount() const override {
     return bytesReturned_ + pendingSkip_;
   }
 
diff --git a/velox/dwio/common/compression/PagedOutputStream.cpp b/velox/dwio/common/compression/PagedOutputStream.cpp
index 18d993bf74f0..2519893be4bf 100644
--- a/velox/dwio/common/compression/PagedOutputStream.cpp
+++ b/velox/dwio/common/compression/PagedOutputStream.cpp
@@ -18,7 +18,7 @@
 
 namespace facebook::velox::dwio::common::compression {
 
-std::vector<folly::StringPiece> PagedOutputStream::createPage() {
+std::vector<std::string_view> PagedOutputStream::createPage() {
   auto origSize = buffer_.size();
   VELOX_CHECK_GT(origSize, pageHeaderSize_);
   origSize -= pageHeaderSize_;
@@ -34,15 +34,15 @@ std::vector<folly::StringPiece> PagedOutputStream::createPage() {
         origSize);
   }
 
-  folly::StringPiece compressed;
+  std::string_view compressed;
   if (compressedSize >= origSize) {
     // write orig
     writeHeader(buffer_.data(), origSize, true);
-    compressed = folly::StringPiece(buffer_.data(), origSize + pageHeaderSize_);
+    compressed = std::string_view(buffer_.data(), origSize + pageHeaderSize_);
   } else {
     // write compressed
     writeHeader(compressionBuffer_->data(), compressedSize, false);
-    compressed = folly::StringPiece(
+    compressed = std::string_view(
         compressionBuffer_->data(), compressedSize + pageHeaderSize_);
   }
 
@@ -50,13 +50,13 @@ std::vector<folly::StringPiece> PagedOutputStream::createPage() {
     return {compressed};
   }
 
-  encryptionBuffer_ = encryptor_->encrypt(folly::StringPiece(
-      compressed.begin() + pageHeaderSize_, compressed.end()));
+  encryptionBuffer_ = encryptor_->encrypt(
+      std::string_view(compressed.begin() + pageHeaderSize_, compressed.end()));
   updateSize(
       const_cast<char*>(compressed.begin()), encryptionBuffer_->length());
   return {
-      folly::StringPiece(compressed.begin(), pageHeaderSize_),
-      folly::StringPiece(
+      std::string_view(compressed.begin(), pageHeaderSize_),
+      std::string_view(
           reinterpret_cast<const char*>(encryptionBuffer_->data()),
           encryptionBuffer_->length())};
 }
diff --git a/velox/dwio/common/compression/PagedOutputStream.h b/velox/dwio/common/compression/PagedOutputStream.h
index 498bba3c781c..415d2961ecad 100644
--- a/velox/dwio/common/compression/PagedOutputStream.h
+++ b/velox/dwio/common/compression/PagedOutputStream.h
@@ -64,8 +64,8 @@ class PagedOutputStream : public BufferedOutputStream {
       int32_t strideIndex = -1) const override;
 
  private:
-  // create page using compressor and encryptor
-  std::vector<folly::StringPiece> createPage();
+  // Create page using compressor and encryptor.
+  std::vector<std::string_view> createPage();
 
   void writeHeader(char* buffer, size_t compressedSize, bool original);
 
diff --git a/velox/dwio/common/encryption/Encryption.cpp b/velox/dwio/common/encryption/Encryption.cpp
index 2e7df9a47932..1db5b8c24dee 100644
--- a/velox/dwio/common/encryption/Encryption.cpp
+++ b/velox/dwio/common/encryption/Encryption.cpp
@@ -16,19 +16,11 @@
 
 #include "velox/dwio/common/encryption/Encryption.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace encryption {
+namespace facebook::velox::dwio::common::encryption {
 
 bool operator==(const EncryptionProperties& a, const EncryptionProperties& b) {
   return std::addressof(a) == std::addressof(b) ||
       (typeid(a) == typeid(b) && a.equals(b));
 }
 
-} // namespace encryption
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common::encryption
diff --git a/velox/dwio/common/encryption/Encryption.h b/velox/dwio/common/encryption/Encryption.h
index db3c2196d954..798f67d3c9fa 100644
--- a/velox/dwio/common/encryption/Encryption.h
+++ b/velox/dwio/common/encryption/Encryption.h
@@ -20,11 +20,7 @@
 #include "folly/io/IOBuf.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace encryption {
+namespace facebook::velox::dwio::common::encryption {
 
 enum class EncryptionProvider { Unknown = 0, CryptoService };
 
@@ -64,7 +60,7 @@ class Encrypter {
   virtual const std::string& getKey() const = 0;
 
   virtual std::unique_ptr<folly::IOBuf> encrypt(
-      folly::StringPiece input) const = 0;
+      std::string_view input) const = 0;
 
   virtual std::unique_ptr<Encrypter> clone() const = 0;
 };
@@ -87,7 +83,7 @@ class Decrypter {
   virtual bool isKeyLoaded() const = 0;
 
   virtual std::unique_ptr<folly::IOBuf> decrypt(
-      folly::StringPiece input) const = 0;
+      std::string_view input) const = 0;
 
   virtual std::unique_ptr<Decrypter> clone() const = 0;
 };
@@ -108,7 +104,7 @@ class DummyDecrypter : public Decrypter {
   }
 
   std::unique_ptr<folly::IOBuf> decrypt(
-      folly::StringPiece /* unused */) const override {
+      std::string_view /* unused */) const override {
     DWIO_RAISE("Failed to access encrypted data");
   }
 
@@ -127,8 +123,4 @@ class DummyDecrypterFactory : public DecrypterFactory {
   }
 };
 
-} // namespace encryption
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common::encryption
diff --git a/velox/dwio/common/encryption/TestProvider.h b/velox/dwio/common/encryption/TestProvider.h
index 7ef41de8e574..b50f727a1e92 100644
--- a/velox/dwio/common/encryption/TestProvider.h
+++ b/velox/dwio/common/encryption/TestProvider.h
@@ -20,12 +20,7 @@
 #include "velox/dwio/common/encryption/Encryption.h"
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace encryption {
-namespace test {
+namespace facebook::velox::dwio::common::encryption::test {
 
 class TestEncryption {
  public:
@@ -37,18 +32,19 @@ class TestEncryption {
     return key_;
   }
 
-  std::unique_ptr<folly::IOBuf> encrypt(folly::StringPiece input) const {
+  std::unique_ptr<folly::IOBuf> encrypt(std::string_view input) const {
     ++count_;
     auto encoded = velox::encoding::Base64::encodeUrl(input);
     return folly::IOBuf::copyBuffer(key_ + encoded);
   }
 
-  std::unique_ptr<folly::IOBuf> decrypt(folly::StringPiece input) const {
+  std::unique_ptr<folly::IOBuf> decrypt(std::string_view input) const {
     ++count_;
-    std::string key{input.begin(), key_.size()};
+    std::string key{input.cbegin(), key_.size()};
     DWIO_ENSURE_EQ(key_, key);
-    auto decoded = velox::encoding::Base64::decodeUrl(folly::StringPiece{
-        input.begin() + key_.size(), input.size() - key_.size()});
+    auto decoded = velox::encoding::Base64::decodeUrl(
+        std::string_view{
+            input.begin() + key_.size(), input.size() - key_.size()});
     return folly::IOBuf::copyBuffer(decoded);
   }
 
@@ -67,8 +63,7 @@ class TestEncrypter : public TestEncryption, public Encrypter {
     return TestEncryption::getKey();
   }
 
-  std::unique_ptr<folly::IOBuf> encrypt(
-      folly::StringPiece input) const override {
+  std::unique_ptr<folly::IOBuf> encrypt(std::string_view input) const override {
     return TestEncryption::encrypt(input);
   }
 
@@ -89,8 +84,7 @@ class TestDecrypter : public TestEncryption, public Decrypter {
     return !getKey().empty();
   }
 
-  std::unique_ptr<folly::IOBuf> decrypt(
-      folly::StringPiece input) const override {
+  std::unique_ptr<folly::IOBuf> decrypt(std::string_view input) const override {
     return TestEncryption::decrypt(input);
   }
 
@@ -144,9 +138,4 @@ class TestDecrypterFactory : public DecrypterFactory {
   }
 };
 
-} // namespace test
-} // namespace encryption
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common::encryption::test
diff --git a/velox/dwio/common/exception/CMakeLists.txt b/velox/dwio/common/exception/CMakeLists.txt
index 43d2d8a067b2..c30b1577c29f 100644
--- a/velox/dwio/common/exception/CMakeLists.txt
+++ b/velox/dwio/common/exception/CMakeLists.txt
@@ -14,5 +14,4 @@
 
 velox_add_library(velox_dwio_common_exception Exception.cpp Exceptions.cpp)
 
-velox_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/Exception.cpp b/velox/dwio/common/exception/Exception.cpp
index 97b0b78fd3cf..e15f503d3ee0 100644
--- a/velox/dwio/common/exception/Exception.cpp
+++ b/velox/dwio/common/exception/Exception.cpp
@@ -17,11 +17,7 @@
 #include "velox/dwio/common/exception/Exception.h"
 #include "velox/common/base/Exceptions.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace exception {
+namespace facebook::velox::dwio::common::exception {
 
 std::unique_ptr<ExceptionLogger>& exceptionLogger() {
   static std::unique_ptr<ExceptionLogger> logger(nullptr);
@@ -40,8 +36,4 @@ ExceptionLogger* getExceptionLogger() {
   return exceptionLogger().get();
 }
 
-} // namespace exception
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common::exception
diff --git a/velox/dwio/common/exception/Exception.h b/velox/dwio/common/exception/Exception.h
index 814d25b728e6..140df90e1959 100644
--- a/velox/dwio/common/exception/Exception.h
+++ b/velox/dwio/common/exception/Exception.h
@@ -18,11 +18,8 @@
 
 #include "velox/common/base/VeloxException.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
-namespace exception {
+namespace facebook::velox::dwio {
+namespace common::exception {
 
 class ExceptionLogger {
  public:
@@ -52,7 +49,7 @@ class LoggedException : public velox::VeloxException {
   explicit LoggedException(
       const std::string& errorMessage,
       const std::string& errorSource =
-          ::facebook::velox::error_source::kErrorSourceRuntime,
+          ::facebook::velox::error_source::kErrorSourceExternal,
       const std::string& errorCode = ::facebook::velox::error_code::kUnknown,
       const bool isRetriable = false)
       : VeloxException(
@@ -101,8 +98,7 @@ class LoggedException : public velox::VeloxException {
   }
 };
 
-} // namespace exception
-} // namespace common
+} // namespace common::exception
 
 #define DWIO_WARN_IF(e, ...)                                                \
   ({                                                                        \
@@ -181,7 +177,7 @@ containing information about the file, line, and function where it happened.
 #define DWIO_RAISE(...)                                          \
   DWIO_EXCEPTION_CUSTOM(                                         \
       facebook::velox::dwio::common::exception::LoggedException, \
-      ::facebook::velox::error_source::kErrorSourceRuntime,      \
+      ::facebook::velox::error_source::kErrorSourceExternal,     \
       ::facebook::velox::error_code::kUnknown,                   \
       ##__VA_ARGS__)
 
@@ -189,7 +185,7 @@ containing information about the file, line, and function where it happened.
   DWIO_ENFORCE_CUSTOM(                                           \
       facebook::velox::dwio::common::exception::LoggedException, \
       expr,                                                      \
-      ::facebook::velox::error_source::kErrorSourceRuntime,      \
+      ::facebook::velox::error_source::kErrorSourceExternal,     \
       ::facebook::velox::error_code::kUnknown,                   \
       ##__VA_ARGS__)
 
@@ -256,6 +252,4 @@ containing information about the file, line, and function where it happened.
       "]: ",                           \
       ##__VA_ARGS__);
 
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio
diff --git a/velox/dwio/common/exception/Exceptions.cpp b/velox/dwio/common/exception/Exceptions.cpp
index 04835dc5ac1a..6c1bc5818e3e 100644
--- a/velox/dwio/common/exception/Exceptions.cpp
+++ b/velox/dwio/common/exception/Exceptions.cpp
@@ -22,10 +22,7 @@
 #include <cstdio>
 #include <string>
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 void verify_range(uint64_t v, uint64_t rangeMask) {
   auto mv = (v & rangeMask);
@@ -67,7 +64,4 @@ std::string format_error_string(std::string fmt...) {
   return s;
 }
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/exception/Exceptions.h b/velox/dwio/common/exception/Exceptions.h
index d6963468ea40..c241e5788f43 100644
--- a/velox/dwio/common/exception/Exceptions.h
+++ b/velox/dwio/common/exception/Exceptions.h
@@ -22,10 +22,7 @@
 #include <string>
 #include "velox/dwio/common/exception/Exception.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class NotImplementedYet : public std::logic_error {
  public:
@@ -117,7 +114,4 @@ using logic_error = exception_error<std::logic_error>;
 using runtime_error = exception_error<std::runtime_error>;
 using EOF_error = exception_error<EOFError>;
 
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/CMakeLists.txt b/velox/dwio/common/tests/CMakeLists.txt
index 30efa1be5125..873814eec418 100644
--- a/velox/dwio/common/tests/CMakeLists.txt
+++ b/velox/dwio/common/tests/CMakeLists.txt
@@ -14,8 +14,7 @@
 
 add_subdirectory(utils)
 add_library(velox_dwio_faulty_file_sink FaultyFileSink.cpp)
-target_link_libraries(
-  velox_dwio_faulty_file_sink velox_file_test_utils velox_dwio_common)
+target_link_libraries(velox_dwio_faulty_file_sink velox_file_test_utils velox_dwio_common)
 
 # There is an issue with the VTT symbol for the InlineExecutor from folly when
 # building on Linux with Clang15. It is not created and results in a SEGV when
@@ -26,10 +25,7 @@ target_link_libraries(
 # optimization level to 0 results in proper creation/linkage and successful
 # execution of the test. Review if this is still necessary when upgrading Clang.
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  set_property(
-    SOURCE ParallelForTest.cpp
-    APPEND
-    PROPERTY COMPILE_OPTIONS -O0)
+  set_property(SOURCE ParallelForTest.cpp APPEND PROPERTY COMPILE_OPTIONS -O0)
 endif()
 
 add_executable(
@@ -42,6 +38,7 @@ add_executable(
   DecoderUtilTest.cpp
   ExecutorBarrierTest.cpp
   OnDemandUnitLoaderTests.cpp
+  ParallelUnitLoaderTest.cpp
   LocalFileSinkTest.cpp
   MemorySinkTest.cpp
   LoggedExceptionTest.cpp
@@ -51,20 +48,23 @@ add_executable(
   ReadFileInputStreamTests.cpp
   ReaderTest.cpp
   RetryTests.cpp
+  ScanSpecTest.cpp
+  SortingWriterTest.cpp
   TestBufferedInput.cpp
   ThrottlerTest.cpp
   TypeTests.cpp
   UnitLoaderToolsTests.cpp
   WriterTest.cpp
-  OptionsTests.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
+  velox_hive_connector
   Folly::folly
   ${TEST_LINK_LIBS}
   GTest::gtest
@@ -72,11 +72,11 @@ target_link_libraries(
   GTest::gmock
   glog::glog
   fmt::fmt
-  protobuf::libprotobuf)
+  protobuf::libprotobuf
+)
 
 if(VELOX_ENABLE_BENCHMARKS)
-  add_executable(velox_dwio_common_data_buffer_benchmark
-                 DataBufferBenchmark.cpp)
+  add_executable(velox_dwio_common_data_buffer_benchmark DataBufferBenchmark.cpp)
 
   target_link_libraries(
     velox_dwio_common_data_buffer_benchmark
@@ -84,25 +84,27 @@ if(VELOX_ENABLE_BENCHMARKS)
     velox_memory
     velox_dwio_common_exception
     Folly::folly
-    Folly::follybenchmark)
+    Folly::follybenchmark
+  )
 
-  add_executable(velox_dwio_common_int_decoder_benchmark
-                 IntDecoderBenchmark.cpp)
+  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::follybenchmark)
+    Folly::follybenchmark
+  )
 
   if(VELOX_ENABLE_ARROW)
     add_subdirectory(Lemire/FastPFor)
-    add_executable(velox_dwio_common_bitpack_decoder_benchmark
-                   BitPackDecoderBenchmark.cpp)
+    add_executable(velox_dwio_common_bitpack_decoder_benchmark BitPackDecoderBenchmark.cpp)
 
-    target_compile_options(velox_dwio_common_bitpack_decoder_benchmark
-                           PRIVATE -Wno-deprecated-declarations)
+    target_compile_options(
+      velox_dwio_common_bitpack_decoder_benchmark
+      PRIVATE -Wno-deprecated-declarations
+    )
 
     target_link_libraries(
       velox_dwio_common_bitpack_decoder_benchmark
@@ -111,6 +113,7 @@ if(VELOX_ENABLE_BENCHMARKS)
       velox_fastpforlib
       duckdb_static
       Folly::folly
-      Folly::follybenchmark)
+      Folly::follybenchmark
+    )
   endif()
 endif()
diff --git a/velox/dwio/common/tests/ChainedBufferTests.cpp b/velox/dwio/common/tests/ChainedBufferTests.cpp
index 0612f4341ff9..43820bc0c77c 100644
--- a/velox/dwio/common/tests/ChainedBufferTests.cpp
+++ b/velox/dwio/common/tests/ChainedBufferTests.cpp
@@ -23,10 +23,7 @@
 
 using namespace ::testing;
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
 
 class ChainedBufferTests : public Test {
  protected:
@@ -64,8 +61,9 @@ TEST_F(ChainedBufferTests, testCreate) {
 
 TEST_F(ChainedBufferTests, testReserve) {
   for (const uint32_t initialCapacityBytes : {0, 16}) {
-    SCOPED_TRACE(fmt::format(
-        "initialCapacityBytes ", succinctBytes(initialCapacityBytes)));
+    SCOPED_TRACE(
+        fmt::format(
+            "initialCapacityBytes ", succinctBytes(initialCapacityBytes)));
     ChainedBuffer<int32_t> buf{*pool_, initialCapacityBytes, 1024};
     ASSERT_EQ(buf.capacity(), initialCapacityBytes);
     ASSERT_EQ(buf.size(), 0);
@@ -252,8 +250,9 @@ TEST_F(ChainedBufferTests, testTrailingZeros) {
 
 TEST_F(ChainedBufferTests, testClearAll) {
   for (const uint32_t initialCapacityBytes : {0, 128}) {
-    SCOPED_TRACE(fmt::format(
-        "initialCapacityBytes ", succinctBytes(initialCapacityBytes)));
+    SCOPED_TRACE(
+        fmt::format(
+            "initialCapacityBytes ", succinctBytes(initialCapacityBytes)));
     ChainedBuffer<int32_t> buf{*pool_, initialCapacityBytes, 1024};
     ASSERT_EQ(buf.capacity(), initialCapacityBytes);
     ASSERT_EQ(buf.size(), 0);
@@ -321,7 +320,5 @@ TEST_F(ChainedBufferTests, testClearAll) {
     ASSERT_EQ(buf.pages_.size(), 9);
   }
 }
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/ColumnSelectorTests.cpp b/velox/dwio/common/tests/ColumnSelectorTests.cpp
index f0176b3824dd..b65411d0e6fb 100644
--- a/velox/dwio/common/tests/ColumnSelectorTests.cpp
+++ b/velox/dwio/common/tests/ColumnSelectorTests.cpp
@@ -394,17 +394,19 @@ TEST(ColumnSelectorTests, testFlatMapKeyFilterAllowed) {
 }
 
 TEST(ColumnSelectorTests, testPartitionKeysMark) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "memo:string"
-                             "ds:string"
-                             "key:string>"));
-
-  const auto physicalSchema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "memo:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "memo:string"
+          "ds:string"
+          "key:string>"));
+
+  const auto physicalSchema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "memo:string>"));
 
   // use schema and physical schema to initialize a column selector
   // without filtering
@@ -456,14 +458,16 @@ TEST(ColumnSelectorTests, testPartitionKeysMark) {
     EXPECT_EQ(root->childAt(3)->getNode().expression, "gold");
 
     // test apply to real data file disk schema
-    const auto schemaMore = std::dynamic_pointer_cast<const RowType>(
-        HiveTypeParser().parse("struct<"
-                               "id:bigint"
-                               "memo:string"
-                               "extra:array<float>>"));
-    const auto schemaLess = std::dynamic_pointer_cast<const RowType>(
-        HiveTypeParser().parse("struct<"
-                               "id:bigint>"));
+    const auto schemaMore =
+        std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+            "struct<"
+            "id:bigint"
+            "memo:string"
+            "extra:array<float>>"));
+    const auto schemaLess =
+        std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+            "struct<"
+            "id:bigint>"));
 
     auto csMore = ColumnSelector::apply(cs, schemaMore);
     LOG(INFO) << "CS filter size: " << cs->getProjection().size();
@@ -510,14 +514,15 @@ TEST(ColumnSelectorTests, testPartitionKeysMark) {
 }
 
 TEST(ColumnSelectorTests, testProjectionUnchangedWhenReadSetChanged) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "values:array<float>"
-                             "tags:map<int, string>"
-                             "notes:struct<f1:int, f2:double, f3:string>"
-                             "memo:string"
-                             "extra:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "values:array<float>"
+          "tags:map<int, string>"
+          "notes:struct<f1:int, f2:double, f3:string>"
+          "memo:string"
+          "extra:string>"));
   ColumnSelector cs(schema, std::vector<std::string>{"id", "values"});
   cs.setRead(cs.findColumn("notes"));
 
@@ -559,13 +564,14 @@ TEST(ColumnSelectorTests, testProjectionUnchangedWhenReadSetChanged) {
 }
 
 TEST(ColumnSelectorTests, testProjectOrder) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "values:array<float>"
-                             "tags:map<int, string>"
-                             "notes:struct<f1:int, f2:double, f3:string>"
-                             "memo:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "values:array<float>"
+          "tags:map<int, string>"
+          "notes:struct<f1:int, f2:double, f3:string>"
+          "memo:string>"));
 
   // test filter with names with order of tags, memo and id
   {
@@ -642,14 +648,15 @@ TEST(ColumnSelectorTests, testProjectOrder) {
 }
 
 TEST(ColumnSelectorTests, testNonexistingColFilters) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "values:array<float>"
-                             "tags:map<int, string>"
-                             "notes:struct<f1:int, f2:double, f3:string>"
-                             "memo:string"
-                             "extra:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "values:array<float>"
+          "tags:map<int, string>"
+          "notes:struct<f1:int, f2:double, f3:string>"
+          "memo:string"
+          "extra:string>"));
 
   EXPECT_THROW(
       ColumnSelector cs(
@@ -659,15 +666,16 @@ TEST(ColumnSelectorTests, testNonexistingColFilters) {
 }
 
 TEST(TestColumnSelector, fileColumnNamesReadAsLowerCaseDuplicateColFilters) {
-  const auto schema = std::dynamic_pointer_cast<const RowType>(
-      HiveTypeParser().parse("struct<"
-                             "id:bigint"
-                             "id:bigint"
-                             "values:array<float>"
-                             "tags:map<int, string>"
-                             "notes:struct<f1:int, f2:double, f3:string>"
-                             "memo:string"
-                             "extra:string>"));
+  const auto schema =
+      std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
+          "struct<"
+          "id:bigint"
+          "id:bigint"
+          "values:array<float>"
+          "tags:map<int, string>"
+          "notes:struct<f1:int, f2:double, f3:string>"
+          "memo:string"
+          "extra:string>"));
 
   EXPECT_THROW(
       ColumnSelector cs(schema, std::vector<std::string>{"id"}, nullptr, true),
diff --git a/velox/dwio/common/tests/DataBufferTests.cpp b/velox/dwio/common/tests/DataBufferTests.cpp
index a6ddee1afab6..c5e7b816cbc6 100644
--- a/velox/dwio/common/tests/DataBufferTests.cpp
+++ b/velox/dwio/common/tests/DataBufferTests.cpp
@@ -21,10 +21,8 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/dwio/common/DataBuffer.h"
 
-namespace facebook {
-namespace velox {
-namespace dwio {
-namespace common {
+namespace facebook::velox::dwio::common {
+
 using namespace facebook::velox::memory;
 using namespace testing;
 using MemoryPool = facebook::velox::memory::MemoryPool;
@@ -175,7 +173,5 @@ TEST_F(DataBufferTest, Move) {
   }
   ASSERT_EQ(0, pool_->usedBytes());
 }
-} // namespace common
-} // namespace dwio
-} // namespace velox
-} // namespace facebook
+
+} // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt b/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt
index 5f6ff7652e32..d74b5b7af666 100644
--- a/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt
+++ b/velox/dwio/common/tests/Lemire/FastPFor/CMakeLists.txt
@@ -13,5 +13,4 @@
 # limitations under the License.
 add_library(velox_fastpforlib STATIC bitpacking.cpp)
 
-target_include_directories(
-  velox_fastpforlib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+target_include_directories(velox_fastpforlib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
diff --git a/velox/dwio/common/tests/LoggedExceptionTest.cpp b/velox/dwio/common/tests/LoggedExceptionTest.cpp
index 6eea7e8b5c78..0f17e1f50a33 100644
--- a/velox/dwio/common/tests/LoggedExceptionTest.cpp
+++ b/velox/dwio/common/tests/LoggedExceptionTest.cpp
@@ -34,11 +34,12 @@ void testTraceCollectionSwitchControl(bool enabled) {
   try {
     throw LoggedException("Test error message");
   } catch (VeloxException& e) {
-    SCOPED_TRACE(fmt::format(
-        "enabled: {}, user flag: {}, sys flag: {}",
-        enabled,
-        FLAGS_velox_exception_user_stacktrace_enabled,
-        FLAGS_velox_exception_system_stacktrace_enabled));
+    SCOPED_TRACE(
+        fmt::format(
+            "enabled: {}, user flag: {}, sys flag: {}",
+            enabled,
+            FLAGS_velox_exception_user_stacktrace_enabled,
+            FLAGS_velox_exception_system_stacktrace_enabled));
     ASSERT_TRUE(e.exceptionType() == VeloxException::Type::kSystem);
     ASSERT_EQ(enabled, e.stackTrace() != nullptr);
   }
diff --git a/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp b/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp
index 178ad21f9b2d..245c7d6186de 100644
--- a/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp
+++ b/velox/dwio/common/tests/OnDemandUnitLoaderTests.cpp
@@ -17,9 +17,8 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/dwio/common/OnDemandUnitLoader.h"
-#include "velox/dwio/common/UnitLoaderTools.h"
+#include "velox/dwio/common/tests/UnitLoaderBaseTest.h"
 #include "velox/dwio/common/tests/utils/UnitLoaderTestTools.h"
 
 using namespace ::testing;
@@ -31,6 +30,38 @@ using facebook::velox::dwio::common::test::getUnitsLoadedWithFalse;
 using facebook::velox::dwio::common::test::LoadUnitMock;
 using facebook::velox::dwio::common::test::ReaderMock;
 
+class OnDemandUnitLoaderCommonTests
+    : public UnitLoaderBaseTest<OnDemandUnitLoaderFactory> {
+ protected:
+  OnDemandUnitLoaderFactory createFactory() override {
+    return OnDemandUnitLoaderFactory(nullptr);
+  }
+};
+
+TEST_F(OnDemandUnitLoaderCommonTests, NoUnitButSkip) {
+  testNoUnitButSkip();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, InitialSkip) {
+  testInitialSkip();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, CanRequestUnitMultipleTimes) {
+  testCanRequestUnitMultipleTimes();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, UnitOutOfRange) {
+  testUnitOutOfRange();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, SeekOutOfRange) {
+  testSeekOutOfRange();
+}
+
+TEST_F(OnDemandUnitLoaderCommonTests, SeekOutOfRangeReaderError) {
+  testSeekOutOfRangeReaderError();
+}
+
 TEST(OnDemandUnitLoaderTests, LoadsCorrectlyWithReader) {
   size_t blockedOnIoCount = 0;
   OnDemandUnitLoaderFactory factory([&](auto) { ++blockedOnIoCount; });
@@ -127,96 +158,3 @@ TEST(OnDemandUnitLoaderTests, CanSeek) {
   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);
-
-  VELOX_ASSERT_THROW(
-      readerMock.seek(61),
-      "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);
-
-  VELOX_ASSERT_THROW(unitLoader->onSeek(0, 11), "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);
-
-  VELOX_ASSERT_THROW(unitLoader->getLoadedUnit(1), "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));
-  VELOX_ASSERT_THROW(
-      getFactoryWithSkip(61),
-      "Can only skip up to the past-the-end row of the file.");
-  VELOX_ASSERT_THROW(
-      getFactoryWithSkip(100),
-      "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;
-  VELOX_ASSERT_THROW(
-      factory.create(std::move(units2), 1),
-      "Can only skip up to the past-the-end row of the file.");
-}
diff --git a/velox/dwio/common/tests/ParallelUnitLoaderTest.cpp b/velox/dwio/common/tests/ParallelUnitLoaderTest.cpp
new file mode 100644
index 000000000000..690acd9fc119
--- /dev/null
+++ b/velox/dwio/common/tests/ParallelUnitLoaderTest.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/ParallelUnitLoader.h"
+#include "velox/dwio/common/OnDemandUnitLoader.h"
+#include "velox/dwio/common/tests/UnitLoaderBaseTest.h"
+#include "velox/dwio/common/tests/utils/UnitLoaderTestTools.h"
+
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/futures/Future.h>
+#include <gtest/gtest.h>
+
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::dwio::common::test;
+
+class ParallelUnitLoaderTest
+    : public UnitLoaderBaseTest<ParallelUnitLoaderFactory> {
+ protected:
+  ParallelUnitLoaderFactory createFactory() override {
+    return ParallelUnitLoaderFactory(ioExecutor_.get(), 2);
+  }
+
+  std::unique_ptr<folly::CPUThreadPoolExecutor> ioExecutor_ =
+      std::make_unique<folly::CPUThreadPoolExecutor>(10);
+};
+
+TEST_F(ParallelUnitLoaderTest, NoUnitButSkip) {
+  testNoUnitButSkip();
+}
+
+TEST_F(ParallelUnitLoaderTest, InitialSkip) {
+  testInitialSkip();
+}
+
+TEST_F(ParallelUnitLoaderTest, CanRequestUnitMultipleTimes) {
+  testCanRequestUnitMultipleTimes();
+}
+
+TEST_F(ParallelUnitLoaderTest, UnitOutOfRange) {
+  testUnitOutOfRange();
+}
+
+TEST_F(ParallelUnitLoaderTest, SeekOutOfRange) {
+  testSeekOutOfRange();
+}
+
+TEST_F(ParallelUnitLoaderTest, SeekOutOfRangeReaderError) {
+  testSeekOutOfRangeReaderError();
+}
+
+TEST_F(ParallelUnitLoaderTest, LoadsCorrectlyWithReader) {
+  auto factory = createFactory();
+  ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 0-2, load(0)
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, true, false}));
+
+  EXPECT_TRUE(readerMock.read(3)); // Unit: 0, rows: 3-5
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, true, false}));
+
+  EXPECT_TRUE(readerMock.read(4)); // Unit: 0, rows: 6-9
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({true, true, false}));
+
+  EXPECT_TRUE(readerMock.read(14)); // Unit: 1, rows: 0-13, unload(0), load(1)
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+  EXPECT_EQ(readerMock.unitsLoaded(), std::vector<bool>({false, true, true}));
+
+  // 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, true}));
+
+  EXPECT_TRUE(readerMock.read(30)); // Unit: 2, rows: 0-29, unload(1), load(2)
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+  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}));
+}
+
+// Performance comparison test
+TEST_F(ParallelUnitLoaderTest, PerformanceComparison) {
+  std::vector<uint64_t> rowsPerUnit = {100, 100, 100, 100, 100, 100, 100, 100};
+  std::vector<uint64_t> ioSizes = {
+      1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024};
+
+  // Measure ParallelUnitLoader performance
+  auto parallelStart = std::chrono::high_resolution_clock::now();
+  {
+    auto factory = createFactory();
+    ReaderMock reader(rowsPerUnit, ioSizes, factory, 0);
+
+    for (size_t i = 0; i < rowsPerUnit.size(); ++i) {
+      uint64_t totalRowsRead = 0;
+      while (totalRowsRead < rowsPerUnit[i]) {
+        reader.read(25);
+        int nextRead = rowsPerUnit[i] - totalRowsRead;
+        totalRowsRead += std::min(25, nextRead);
+      }
+    }
+  }
+  auto parallelEnd = std::chrono::high_resolution_clock::now();
+
+  // Measure OnDemandUnitLoader performance
+  auto onDemandStart = std::chrono::high_resolution_clock::now();
+  {
+    auto factory = std::make_shared<OnDemandUnitLoaderFactory>(nullptr);
+    ReaderMock reader(rowsPerUnit, ioSizes, *factory, 0);
+
+    for (size_t i = 0; i < rowsPerUnit.size(); ++i) {
+      uint64_t totalRowsRead = 0;
+      while (totalRowsRead < rowsPerUnit[i]) {
+        reader.read(25);
+        int nextRead = rowsPerUnit[i] - totalRowsRead;
+        totalRowsRead += std::min(25, nextRead);
+      }
+    }
+  }
+  auto onDemandEnd = std::chrono::high_resolution_clock::now();
+
+  auto parallelDuration = std::chrono::duration_cast<std::chrono::milliseconds>(
+      parallelEnd - parallelStart);
+  auto onDemandDuration = std::chrono::duration_cast<std::chrono::milliseconds>(
+      onDemandEnd - onDemandStart);
+
+  // ParallelUnitLoader should be faster
+  EXPECT_GT(onDemandDuration.count(), parallelDuration.count());
+}
diff --git a/velox/dwio/common/tests/ReaderTest.cpp b/velox/dwio/common/tests/ReaderTest.cpp
index 59a870e3c8a8..780e178c32a3 100644
--- a/velox/dwio/common/tests/ReaderTest.cpp
+++ b/velox/dwio/common/tests/ReaderTest.cpp
@@ -148,24 +148,67 @@ TEST_F(ReaderTest, projectColumnsMutation) {
       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);
-#if FOLLY_HAVE_EXTRANDOM_SFMT19937
-  expected = makeRowVector({
-      makeFlatVector<int64_t>({0, 1, 3, 5, 6, 8}),
-  });
-#elif __APPLE__
-  expected = makeRowVector({
-      makeFlatVector<int64_t>({1, 5, 6, 7, 8, 9}),
-  });
-#else
-  expected = makeRowVector({
-      makeFlatVector<int64_t>({3, 4, 7, 9}),
-  });
-#endif
-  test::assertEqualVectors(expected, actual);
+
+  constexpr auto kNumRounds = 1U << 6;
+
+  size_t numNonZero = 0;
+  size_t numNonMax = 0;
+
+  // Test with random skip - use property-based testing instead of hardcoded
+  // outputs to avoid brittleness when folly::Random implementation changes.
+  std::mt19937 seeds;
+  for (size_t round = 0; round < kNumRounds; ++round) {
+    const auto seed = seeds();
+
+    random::setSeed(folly::to_narrow(seed));
+    random::RandomSkipTracker randomSkip(0.5);
+    mutation.randomSkip = &randomSkip;
+    actual = RowReader::projectColumns(input, spec, &mutation);
+
+    // Property 1: Result size should be less than input size (some rows
+    // skipped). With 0.5 sample rate and 9 eligible rows (excluding deleted row
+    // 2), we expect roughly 4-5 rows, but allow wider range for RNG variance.
+    EXPECT_GE(actual->size(), 0);
+    EXPECT_LE(actual->size(), kSize - 1);
+
+    numNonZero += actual->size() > 0;
+    numNonMax += actual->size() < kSize - 1;
+
+    // The result is a RowVector with one child column. Assume it.
+    auto res = actual->as<RowVector>()->childAt(0)->as<SimpleVector<int64_t>>();
+    std::vector<int64_t> vec;
+    vec.reserve(actual->size());
+    for (vector_size_t i = 0; i < actual->size(); ++i) {
+      vec.push_back(res->valueAt(i));
+    }
+
+    // Property 2: All values in result must be from original input.
+    for (auto val : vec) {
+      // Each value must be in valid range
+      EXPECT_GE(val, 0);
+      EXPECT_LT(val, kSize);
+      // Deleted row should never appear
+      EXPECT_NE(val, 2);
+    }
+
+    // Property 3: Values should be in ascending order (projectColumns preserves
+    // order).
+    EXPECT_TRUE(std::is_sorted(vec.begin(), vec.end()));
+
+    // Property 4: No duplicate values (each input row appears at most once).
+    EXPECT_TRUE(std::adjacent_find(vec.begin(), vec.end()) == vec.end());
+
+    // Property 5: With a fixed seed, the result should be deterministic
+    // (same seed = same output, even if we don't know what that output is)
+    random::setSeed(folly::to_narrow(seed));
+    random::RandomSkipTracker randomSkip2(0.5);
+    mutation.randomSkip = &randomSkip2;
+    auto actual2 = RowReader::projectColumns(input, spec, &mutation);
+    test::assertEqualVectors(actual, actual2);
+  }
+
+  EXPECT_NE(0, numNonZero);
+  EXPECT_NE(0, numNonMax);
 }
 
 } // namespace
diff --git a/velox/dwio/common/tests/ScanSpecTest.cpp b/velox/dwio/common/tests/ScanSpecTest.cpp
new file mode 100644
index 000000000000..d61675878d27
--- /dev/null
+++ b/velox/dwio/common/tests/ScanSpecTest.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/ScanSpec.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::common {
+namespace {
+
+class ScanSpecTest : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+};
+
+TEST_F(ScanSpecTest, applyFilter) {
+  auto rowVector = makeRowVector({
+      makeFlatVector<int64_t>(64, folly::identity),
+      makeFlatVector<int64_t>(128, folly::identity),
+  });
+  ASSERT_EQ(rowVector->size(), 64);
+  ScanSpec scanSpec("<root>");
+  scanSpec.addAllChildFields(*rowVector->type());
+  scanSpec.childByName("c1")->setFilter(createBigintValues({63, 64}, false));
+  uint64_t result = -1ll;
+  scanSpec.applyFilter(*rowVector, rowVector->size(), &result);
+  ASSERT_EQ(result, 1ull << 63);
+  result = -1ll;
+  scanSpec.childByName("c1")->applyFilter(
+      *rowVector->childAt("c1"), rowVector->size(), &result);
+  ASSERT_EQ(result, 1ull << 63);
+  rowVector = makeRowVector({
+      makeFlatVector<int64_t>(128, folly::identity),
+      makeFlatVector<int64_t>(64, folly::identity),
+  });
+  ASSERT_THROW(
+      scanSpec.applyFilter(*rowVector, rowVector->size(), &result),
+      VeloxRuntimeError);
+}
+
+class TypedScanSpecTest : public testing::TestWithParam<TypePtr>,
+                          public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  VectorPtr makeConstNullVector(TypePtr type, vector_size_t size) {
+    return BaseVector::createNullConstant(type, size, pool());
+  }
+
+  void addIsNullFilterRecursive(ScanSpec& scanSpec) {
+    scanSpec.setFilter(std::make_shared<velox::common::IsNull>());
+    for (auto& child : scanSpec.children()) {
+      addIsNullFilterRecursive(*child);
+    }
+  }
+
+  void addIsNotNullFilterRecursive(ScanSpec& scanSpec) {
+    scanSpec.setFilter(std::make_shared<velox::common::IsNotNull>());
+    for (auto& child : scanSpec.children()) {
+      addIsNullFilterRecursive(*child);
+    }
+  }
+
+  void addIsNullFilterToLeaf(ScanSpec& scanSpec) {
+    if (scanSpec.children().empty()) {
+      scanSpec.setFilter(std::make_shared<velox::common::IsNull>());
+    } else {
+      for (auto& child : scanSpec.children()) {
+        addIsNullFilterToLeaf(*child);
+      }
+    }
+  }
+
+  void addIsNotNullFilterToLeaf(ScanSpec& scanSpec) {
+    if (scanSpec.children().empty()) {
+      scanSpec.setFilter(std::make_shared<velox::common::IsNotNull>());
+    } else {
+      for (auto& child : scanSpec.children()) {
+        addIsNotNullFilterToLeaf(*child);
+      }
+    }
+  }
+};
+
+// Due to how subfield filters of maps and arrays are pruning
+// and can't affect the row selectivity, the current test skips
+// cases when maps and arrays are the lone child of (nested) structs.
+INSTANTIATE_TEST_SUITE_P(
+    TypedScanSpecTestSuite,
+    TypedScanSpecTest,
+    testing::Values(
+        TINYINT(),
+        SMALLINT(),
+        INTEGER(),
+        BIGINT(),
+        REAL(),
+        DOUBLE(),
+        VARCHAR(),
+        VARBINARY(),
+        ROW({"int", "real"}, {INTEGER(), REAL()}),
+        // TODO: the test cases fail when not specifying names for
+        // the struct fields. This indicates bug in internal topology
+        // when finding children of nested scan specs.
+        ROW({"int", "map"}, {INTEGER(), MAP(INTEGER(), REAL())}),
+        ROW({"int", "array"}, {INTEGER(), ARRAY(INTEGER())}),
+        ROW({"int0", "array0", "row0"},
+            {INTEGER(),
+             ARRAY(INTEGER()),
+             ROW({"int1", "real1", "row1"},
+                 {INTEGER(),
+                  REAL(),
+                  ROW({"int2", "real2"}, {INTEGER(), REAL()})})})));
+
+TEST_P(TypedScanSpecTest, applyFilterSchemaEvolution) {
+  auto rowVector = makeRowVector({
+      makeFlatVector<int64_t>(64, folly::identity),
+      makeConstNullVector(GetParam(), 64),
+  });
+  ASSERT_EQ(rowVector->size(), 64);
+  LOG(INFO) << "Testing with type: " << rowVector->type()->toString();
+
+  {
+    ScanSpec scanSpec("<root>");
+    scanSpec.addAllChildFields(*rowVector->type());
+
+    ASSERT_TRUE(scanSpec.childByName("c0"));
+    scanSpec.childByName("c0")->setFilter(
+        std::make_shared<BigintRange>(32, 64, false));
+
+    ASSERT_TRUE(scanSpec.childByName("c1"));
+    addIsNullFilterRecursive(*scanSpec.childByName("c1"));
+
+    uint64_t result = -1ll;
+    scanSpec.applyFilter(*rowVector, rowVector->size(), &result);
+    ASSERT_EQ(result, -1ll << 32);
+
+    // Now add a non-null filter on the missing column.
+    ASSERT_TRUE(scanSpec.childByName("c1"));
+    addIsNotNullFilterRecursive(*scanSpec.childByName("c1"));
+    result = -1ll;
+    scanSpec.applyFilter(*rowVector, rowVector->size(), &result);
+    ASSERT_EQ(result, 0);
+  }
+
+  {
+    ScanSpec scanSpec("<root>");
+    scanSpec.addAllChildFields(*rowVector->type());
+
+    ASSERT_TRUE(scanSpec.childByName("c0"));
+    scanSpec.childByName("c0")->setFilter(
+        std::make_shared<BigintRange>(32, 64, false));
+
+    // Now add a null filter only on the innermost node of the missing column.
+    // Should have the same result as recursive filters.
+    ASSERT_TRUE(scanSpec.childByName("c1"));
+    addIsNullFilterToLeaf(*scanSpec.childByName("c1"));
+    uint64_t result = -1ll;
+    scanSpec.applyFilter(*rowVector, rowVector->size(), &result);
+    ASSERT_EQ(result, -1ll << 32);
+
+    // Now add is not null filter only on the innermost node of the missing
+    // column. Should have the same result as recursive filters.
+    ASSERT_TRUE(scanSpec.childByName("c1"));
+    addIsNotNullFilterToLeaf(*scanSpec.childByName("c1"));
+    result = -1ll;
+    scanSpec.applyFilter(*rowVector, rowVector->size(), &result);
+    ASSERT_EQ(result, 0);
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::common
diff --git a/velox/dwio/common/tests/SortingWriterTest.cpp b/velox/dwio/common/tests/SortingWriterTest.cpp
new file mode 100644
index 000000000000..4beadc61e1ad
--- /dev/null
+++ b/velox/dwio/common/tests/SortingWriterTest.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/dwio/common/SortingWriter.h"
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/SortBuffer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::memory;
+
+namespace facebook::velox::dwio::common::test {
+
+class MockWriter : public Writer {
+ public:
+  MockWriter() {
+    setState(State::kRunning);
+  }
+
+  void write(const VectorPtr& data) override {
+    writtenData_.push_back(data);
+    totalRowsWritten_ += data->size();
+  }
+
+  bool finish() override {
+    return true;
+  }
+
+  void flush() override {}
+
+  void close() override {
+    setState(State::kClosed);
+  }
+
+  void abort() override {
+    setState(State::kAborted);
+  }
+
+  uint64_t getTotalRowsWritten() const {
+    return totalRowsWritten_;
+  }
+
+ private:
+  std::vector<VectorPtr> writtenData_;
+  uint64_t totalRowsWritten_ = 0;
+};
+
+class SortingWriterTest : public testing::Test,
+                          public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  std::unique_ptr<SortBuffer> createSortBuffer() {
+    const RowTypePtr inputType =
+        ROW({{"c0", BIGINT()}, {"c1", INTEGER()}, {"c2", VARCHAR()}});
+
+    const std::vector<column_index_t> sortColumnIndices{1};
+    const std::vector<CompareFlags> sortCompareFlags{
+        {true, true, false, CompareFlags::NullHandlingMode::kNullAsValue}};
+
+    const velox::common::PrefixSortConfig prefixSortConfig{
+        std::numeric_limits<uint32_t>::max(),
+        std::numeric_limits<uint32_t>::max(),
+        12};
+
+    return std::make_unique<SortBuffer>(
+        inputType,
+        sortColumnIndices,
+        sortCompareFlags,
+        pool_.get(),
+        &nonReclaimableSection_,
+        prefixSortConfig);
+  }
+
+  RowVectorPtr createTestData(uint64_t numRows = 1000) {
+    return makeRowVector(
+        {makeFlatVector<int64_t>(
+             numRows, [](vector_size_t row) { return row; }),
+         makeFlatVector<int32_t>(
+             numRows, [numRows](vector_size_t row) { return numRows - row; }),
+         makeFlatVector<std::string>(numRows, [](vector_size_t row) {
+           return fmt::format("row_{}", row);
+         })});
+  }
+
+  tsan_atomic<bool> nonReclaimableSection_{false};
+};
+
+TEST_F(SortingWriterTest, largeRowSizeExceedsMaxOutputBytes) {
+  auto mockWriter = std::make_unique<MockWriter>();
+  auto mockWriterPtr = mockWriter.get();
+
+  auto sortBuffer = createSortBuffer();
+
+  const vector_size_t maxOutputRowsConfig = 1000;
+  const uint64_t maxOutputBytesConfig = 1;
+  const uint64_t outputTimeSliceLimitMs = 1000;
+
+  SortingWriter sortingWriter(
+      std::move(mockWriter),
+      std::move(sortBuffer),
+      maxOutputRowsConfig,
+      maxOutputBytesConfig,
+      outputTimeSliceLimitMs);
+
+  RowVectorPtr testData = createTestData(10);
+  sortingWriter.write(testData);
+  ASSERT_TRUE(sortingWriter.finish());
+  ASSERT_GT(mockWriterPtr->getTotalRowsWritten(), 0);
+}
+
+} // namespace facebook::velox::dwio::common::test
diff --git a/velox/dwio/common/tests/TestBufferedInput.cpp b/velox/dwio/common/tests/TestBufferedInput.cpp
index 6fa5be8da000..39461993bd24 100644
--- a/velox/dwio/common/tests/TestBufferedInput.cpp
+++ b/velox/dwio/common/tests/TestBufferedInput.cpp
@@ -16,6 +16,8 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/connectors/hive/BufferedInputBuilder.h"
 #include "velox/dwio/common/BufferedInput.h"
 
 using namespace facebook::velox::dwio::common;
@@ -29,13 +31,25 @@ class ReadFileMock : public ::facebook::velox::ReadFile {
  public:
   virtual ~ReadFileMock() override = default;
 
+// On Centos9 the gtest mock header doesn't initialize the
+// buffer_ member in MatcherBase correctly - the default constructor only
+// initializes one: /usr/include/gtest/gtest-matchers.h:302:33 resulting in
+// error:
+// '<unnamed>.testing::Matcher<const
+// facebook::velox::FileStorageContext&>::<unnamed>.testing::internal::MatcherBase<const
+// facebook::velox::FileStorageContext&>::buffer_' is used uninitialized
+// [-Werror=uninitialized]
+//  302 |       : vtable_(other.vtable_), buffer_(other.buffer_) {
+// Fix: https://github.com/google/googletest/pull/3797
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
   MOCK_METHOD(
       std::string_view,
       pread,
       (uint64_t offset,
        uint64_t length,
        void* buf,
-       facebook::velox::filesystems::File::IoStats* stats),
+       (const facebook::velox::FileStorageContext&)fileStorageContext),
       (const, override));
 
   MOCK_METHOD(bool, shouldCoalesce, (), (const, override));
@@ -48,7 +62,7 @@ class ReadFileMock : public ::facebook::velox::ReadFile {
       preadv,
       (folly::Range<const Region*> regions,
        folly::Range<folly::IOBuf*> iobufs,
-       facebook::velox::filesystems::File::IoStats* stats),
+       (const facebook::velox::FileStorageContext&)fileStorageContext),
       (const, override));
 };
 
@@ -60,14 +74,14 @@ void expectPreads(
   EXPECT_CALL(file, size()).WillRepeatedly(Return(content.size()));
   for (auto& read : reads) {
     ASSERT_GE(content.size(), read.offset + read.length);
-    EXPECT_CALL(file, pread(read.offset, read.length, _, nullptr))
+    EXPECT_CALL(file, pread(read.offset, read.length, _, _))
         .Times(1)
         .WillOnce(
             [content](
                 uint64_t offset,
                 uint64_t length,
                 void* buf,
-                facebook::velox::filesystems::File::IoStats* stats)
+                const facebook::velox::FileStorageContext& fileStorageContext)
                 -> std::string_view {
               memcpy(buf, content.data() + offset, length);
               return {content.data() + offset, length};
@@ -81,13 +95,14 @@ void expectPreadvs(
     std::vector<Region> reads) {
   EXPECT_CALL(file, getName()).WillRepeatedly(Return("mock_name"));
   EXPECT_CALL(file, size()).WillRepeatedly(Return(content.size()));
-  EXPECT_CALL(file, preadv(_, _, nullptr))
+  EXPECT_CALL(file, preadv(_, _, _))
       .Times(1)
       .WillOnce(
           [content, reads](
               folly::Range<const Region*> regions,
               folly::Range<folly::IOBuf*> iobufs,
-              facebook::velox::filesystems::File::IoStats* stats) -> uint64_t {
+              const facebook::velox::FileStorageContext& fileStorageContext)
+              -> uint64_t {
             EXPECT_EQ(regions.size(), reads.size());
             uint64_t length = 0;
             for (size_t i = 0; i < reads.size(); ++i) {
@@ -110,6 +125,7 @@ void expectPreadvs(
             return length;
           });
 }
+#pragma GCC diagnostic pop
 
 std::optional<std::string> getNext(SeekableInputStream& input) {
   const void* buf = nullptr;
@@ -130,7 +146,6 @@ class TestBufferedInput : public testing::Test {
 
   const std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
 };
-} // namespace
 
 TEST_F(TestBufferedInput, ZeroLengthStream) {
   auto readFile =
@@ -377,3 +392,45 @@ TEST_F(TestBufferedInput, VReadSortingWithLabels) {
     EXPECT_EQ(next.value(), r.second);
   }
 }
+
+class CustomBufferedInputBuilder
+    : public facebook::velox::connector::hive::BufferedInputBuilder {
+ public:
+  std::unique_ptr<facebook::velox::dwio::common::BufferedInput> create(
+      const facebook::velox::FileHandle& fileHandle,
+      const facebook::velox::dwio::common::ReaderOptions& readerOpts,
+      const facebook::velox::connector::ConnectorQueryCtx* connectorQueryCtx,
+      std::shared_ptr<facebook::velox::io::IoStatistics> ioStats,
+      std::shared_ptr<facebook::velox::filesystems::File::IoStats> fsStats,
+      folly::Executor* executor,
+      const folly::F14FastMap<std::string, std::string>& fileReadOps = {})
+      override {
+    VELOX_NYI("Not implemented in CustomBufferedInputBuilder");
+  }
+};
+
+class CustomBufferedInputTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    MemoryManager::testingSetInstance(MemoryManager::Options{});
+    facebook::velox::connector::hive::BufferedInputBuilder::registerBuilder(
+        std::make_shared<CustomBufferedInputBuilder>());
+  }
+
+  const std::shared_ptr<MemoryPool> pool_ = memoryManager()->addLeafPool();
+};
+
+} // namespace
+
+TEST_F(CustomBufferedInputTest, basic) {
+  facebook::velox::FileHandle fileHandle;
+  facebook::velox::dwio::common::ReaderOptions readerOpts(pool_.get());
+  auto ioStats = std::make_shared<facebook::velox::io::IoStatistics>();
+  auto fsStats =
+      std::make_shared<facebook::velox::filesystems::File::IoStats>();
+
+  VELOX_ASSERT_THROW(
+      facebook::velox::connector::hive::BufferedInputBuilder::getInstance()
+          ->create(fileHandle, readerOpts, nullptr, ioStats, fsStats, nullptr),
+      "Not implemented in CustomBufferedInputBuilder");
+}
diff --git a/velox/dwio/common/tests/ThrottlerTest.cpp b/velox/dwio/common/tests/ThrottlerTest.cpp
index 773e8d0dd70e..12ea0c86d75b 100644
--- a/velox/dwio/common/tests/ThrottlerTest.cpp
+++ b/velox/dwio/common/tests/ThrottlerTest.cpp
@@ -110,14 +110,15 @@ TEST_F(ThrottlerTest, throttle) {
     SCOPED_TRACE(fmt::format("signal: {}", Throttler::signalTypeName(signal)));
 
     Throttler::testingReset();
-    Throttler::init(Throttler::Config(
-        true,
-        minThrottleBackoffMs,
-        maxThrottleBackoffMs,
-        2.0,
-        signal == Throttler::SignalType::kLocal ? 2 : 1'000,
-        signal == Throttler::SignalType::kGlobal ? 2 : 1'000,
-        signal == Throttler::SignalType::kNetwork ? 2 : 1'000));
+    Throttler::init(
+        Throttler::Config(
+            true,
+            minThrottleBackoffMs,
+            maxThrottleBackoffMs,
+            2.0,
+            signal == Throttler::SignalType::kLocal ? 2 : 1'000,
+            signal == Throttler::SignalType::kGlobal ? 2 : 1'000,
+            signal == Throttler::SignalType::kNetwork ? 2 : 1'000));
     auto* instance = Throttler::instance();
     const auto& stats = instance->stats();
     ASSERT_EQ(stats.localThrottled, 0);
@@ -186,16 +187,17 @@ TEST_F(ThrottlerTest, expire) {
   for (const auto signal : kSignalTypes) {
     SCOPED_TRACE(fmt::format("signal: {}", Throttler::signalTypeName(signal)));
     Throttler::testingReset();
-    Throttler::init(Throttler::Config(
-        true,
-        minThrottleBackoffMs,
-        maxThrottleBackoffMs,
-        2.0,
-        signal == Throttler::SignalType::kLocal ? 2 : 1'000,
-        signal == Throttler::SignalType::kGlobal ? 2 : 1'000,
-        signal == Throttler::SignalType::kNetwork ? 2 : 1'000,
-        1'000,
-        1'000));
+    Throttler::init(
+        Throttler::Config(
+            true,
+            minThrottleBackoffMs,
+            maxThrottleBackoffMs,
+            2.0,
+            signal == Throttler::SignalType::kLocal ? 2 : 1'000,
+            signal == Throttler::SignalType::kGlobal ? 2 : 1'000,
+            signal == Throttler::SignalType::kNetwork ? 2 : 1'000,
+            1'000,
+            1'000));
     auto* instance = Throttler::instance();
     const auto& stats = instance->stats();
     ASSERT_EQ(stats.localThrottled, 0);
@@ -228,8 +230,9 @@ TEST_F(ThrottlerTest, expire) {
 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));
+  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);
@@ -320,8 +323,9 @@ TEST_F(ThrottlerTest, differentLocals) {
 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));
+  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);
@@ -409,14 +413,15 @@ TEST_F(ThrottlerTest, differentGlobals) {
 TEST_F(ThrottlerTest, differentNetworks) {
   const uint64_t minThrottleBackoffMs = 1'000;
   const uint64_t maxThrottleBackoffMs = 2'000;
-  Throttler::init(Throttler::Config(
-      true,
-      minThrottleBackoffMs,
-      maxThrottleBackoffMs,
-      2.0,
-      1'0000,
-      1'0000,
-      2));
+  Throttler::init(
+      Throttler::Config(
+          true,
+          minThrottleBackoffMs,
+          maxThrottleBackoffMs,
+          2.0,
+          1'0000,
+          1'0000,
+          2));
   auto* instance = Throttler::instance();
   const auto& stats = instance->stats();
   ASSERT_EQ(stats.localThrottled, 0);
@@ -511,8 +516,9 @@ TEST_F(ThrottlerTest, maxOfGlobalAndLocal) {
   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));
+    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);
@@ -627,16 +633,17 @@ TEST_F(ThrottlerTest, fuzz) {
   const uint32_t maxCacheEntries = 64;
   const uint32_t cacheTTLMs = 10;
   Throttler::testingReset();
-  Throttler::init(Throttler::Config(
-      true,
-      minThrottleBackoffMs,
-      maxThrottleBackoffMs,
-      backoffScaleFactor,
-      minLocalThrottledSignals,
-      minGlobalThrottledSignals,
-      minNetworkThrottledSignals,
-      maxCacheEntries,
-      cacheTTLMs));
+  Throttler::init(
+      Throttler::Config(
+          true,
+          minThrottleBackoffMs,
+          maxThrottleBackoffMs,
+          backoffScaleFactor,
+          minLocalThrottledSignals,
+          minGlobalThrottledSignals,
+          minNetworkThrottledSignals,
+          maxCacheEntries,
+          cacheTTLMs));
   auto* instance = Throttler::instance();
 
   const auto seed = getCurrentTimeMs();
diff --git a/velox/dwio/common/tests/UnitLoaderBaseTest.h b/velox/dwio/common/tests/UnitLoaderBaseTest.h
new file mode 100644
index 000000000000..9faf9bc91b3e
--- /dev/null
+++ b/velox/dwio/common/tests/UnitLoaderBaseTest.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 <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/UnitLoaderTools.h"
+#include "velox/dwio/common/tests/utils/UnitLoaderTestTools.h"
+
+using facebook::velox::dwio::common::LoadUnit;
+using facebook::velox::dwio::common::test::getUnitsLoadedWithFalse;
+using facebook::velox::dwio::common::test::LoadUnitMock;
+using facebook::velox::dwio::common::test::ReaderMock;
+
+/// Base test class template that provides common test functionality for
+/// different UnitLoader implementations. This template class can be inherited
+/// by specific test classes to get access to common test methods. Each derived
+/// class should provide a createFactory() method that returns the appropriate
+/// factory instance.
+template <typename UnitLoaderFactoryType>
+class UnitLoaderBaseTest : public ::testing::Test {
+ protected:
+  /// Factory method to create the appropriate UnitLoaderFactory instance.
+  /// This method should be implemented by derived classes.
+  virtual UnitLoaderFactoryType createFactory() = 0;
+
+  /// Test that UnitLoader factory handles the case where no units exist but
+  /// skip is requested
+  void testNoUnitButSkip() {
+    UnitLoaderFactoryType factory = createFactory();
+    std::vector<std::unique_ptr<LoadUnit>> units;
+
+    EXPECT_NO_THROW(factory.create(std::move(units), 0));
+
+    std::vector<std::unique_ptr<LoadUnit>> units2;
+    VELOX_ASSERT_THROW(
+        factory.create(std::move(units2), 1),
+        "Can only skip up to the past-the-end row of the file.");
+  }
+
+  /// Test that UnitLoader factory handles initial skip correctly for various
+  /// skip values
+  void testInitialSkip() {
+    auto getFactoryWithSkip = [this](uint64_t skipToRow) {
+      auto factory = createFactory();
+      std::vector<std::atomic_bool> unitsLoaded(getUnitsLoadedWithFalse(3));
+      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));
+    VELOX_ASSERT_THROW(
+        getFactoryWithSkip(61),
+        "Can only skip up to the past-the-end row of the file.");
+    VELOX_ASSERT_THROW(
+        getFactoryWithSkip(100),
+        "Can only skip up to the past-the-end row of the file.");
+  }
+
+  /// Test that the same unit can be requested multiple times without issues
+  void testCanRequestUnitMultipleTimes() {
+    auto factory = createFactory();
+    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 that requesting a unit index out of range throws an exception
+  void testUnitOutOfRange() {
+    auto factory = createFactory();
+    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);
+
+    VELOX_ASSERT_THROW(unitLoader->getLoadedUnit(1), "Unit out of range");
+  }
+
+  /// Test that seeking out of range throws an exception
+  void testSeekOutOfRange() {
+    auto factory = createFactory();
+    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);
+
+    VELOX_ASSERT_THROW(unitLoader->onSeek(0, 11), "Row out of range");
+  }
+
+  /// Test that seeking out of range in ReaderMock throws appropriate exception
+  void testSeekOutOfRangeReaderError() {
+    auto factory = createFactory();
+    ReaderMock readerMock{{10, 20, 30}, {0, 0, 0}, factory, 0};
+
+    readerMock.seek(59);
+    readerMock.seek(60);
+
+    VELOX_ASSERT_THROW(
+        readerMock.seek(61),
+        "Can't seek to possition 61 in file. Must be up to 60.");
+  }
+};
diff --git a/velox/dwio/common/tests/WriterTest.cpp b/velox/dwio/common/tests/WriterTest.cpp
index 51e68de59d08..8fbb5a444b96 100644
--- a/velox/dwio/common/tests/WriterTest.cpp
+++ b/velox/dwio/common/tests/WriterTest.cpp
@@ -22,6 +22,32 @@ using namespace ::testing;
 
 namespace facebook::velox::dwio::common {
 namespace {
+
+class MockWriter : public Writer {
+ public:
+  MockWriter() = default;
+
+  void setStateForTest(State state) {
+    setState(state);
+  }
+
+  void callCheckRunning() const {
+    checkRunning();
+  }
+
+  void write(const VectorPtr& /*data*/) override {}
+
+  void flush() override {}
+
+  bool finish() override {
+    return true;
+  }
+
+  void abort() override {}
+
+  void close() override {}
+};
+
 TEST(WriterTest, stateString) {
   ASSERT_EQ(Writer::stateString(Writer::State::kInit), "INIT");
   ASSERT_EQ(Writer::stateString(Writer::State::kRunning), "RUNNING");
@@ -31,5 +57,16 @@ TEST(WriterTest, stateString) {
   VELOX_ASSERT_THROW(
       Writer::stateString(static_cast<Writer::State>(100)), "BAD STATE: 100");
 }
+
+TEST(WriterTest, checkRunning) {
+  MockWriter writer;
+  VELOX_ASSERT_THROW(writer.callCheckRunning(), "Writer is not running: INIT");
+  writer.setStateForTest(Writer::State::kRunning);
+  ASSERT_NO_THROW(writer.callCheckRunning());
+  writer.setStateForTest(Writer::State::kClosed);
+  VELOX_ASSERT_USER_THROW(
+      writer.callCheckRunning(),
+      "Writer is not running: CLOSED. Write operations are not allowed on a closed writer.");
+}
 } // namespace
 } // namespace facebook::velox::dwio::common
diff --git a/velox/dwio/common/tests/utils/CMakeLists.txt b/velox/dwio/common/tests/utils/CMakeLists.txt
index 2765c1091d6a..bbbd5c2ebe54 100644
--- a/velox/dwio/common/tests/utils/CMakeLists.txt
+++ b/velox/dwio/common/tests/utils/CMakeLists.txt
@@ -19,7 +19,8 @@ add_library(
   DataSetBuilder.cpp
   FilterGenerator.cpp
   UnitLoaderTestTools.cpp
-  E2EFilterTestBase.cpp)
+  E2EFilterTestBase.cpp
+)
 
 target_link_libraries(
   velox_dwio_common_test_utils
@@ -36,7 +37,8 @@ target_link_libraries(
   velox_type
   velox_type_fbhive
   velox_vector
-  velox_vector_test_lib)
+  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 85c508dd0a3b..27ecb8a9ffea 100644
--- a/velox/dwio/common/tests/utils/DataSetBuilder.cpp
+++ b/velox/dwio/common/tests/utils/DataSetBuilder.cpp
@@ -47,8 +47,9 @@ DataSetBuilder& DataSetBuilder::makeDataset(
 
   for (size_t i = 0; i < batchCount; ++i) {
     if (withRecursiveNulls) {
-      batches_->push_back(std::static_pointer_cast<RowVector>(
-          BatchMaker::createBatch(rowType, numRows, pool_, nullptr, i)));
+      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(
@@ -207,7 +208,7 @@ DataSetBuilder& DataSetBuilder::withUniqueStringsForField(
       if (strings->isNullAt(row)) {
         continue;
       }
-      std::string value = strings->valueAt(row);
+      auto value = std::string(strings->valueAt(row));
       value += fmt::format("{}", row);
       strings->set(row, StringView(value));
     }
@@ -282,7 +283,7 @@ DataSetBuilder& DataSetBuilder::makeMapStringValues(
             continue;
           }
           if (!keys->isNullAt(i) && i % 3 == 0) {
-            std::string str = keys->valueAt(i);
+            auto str = std::string(keys->valueAt(i));
             str += "----123456789";
             keys->set(i, StringView(str));
           }
@@ -304,7 +305,7 @@ DataSetBuilder& DataSetBuilder::makeMapStringValues(
             continue;
           }
           if (!values->isNullAt(i) && i % 3 == 0) {
-            std::string str = values->valueAt(i);
+            auto str = std::string(values->valueAt(i));
             str += "----123456789";
             values->set(i, StringView(str));
           }
diff --git a/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp b/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
index 446aaceee766..4c6e2dd70f2c 100644
--- a/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
+++ b/velox/dwio/common/tests/utils/E2EFilterTestBase.cpp
@@ -18,6 +18,7 @@
 
 #include "velox/dwio/common/tests/utils/DataSetBuilder.h"
 #include "velox/expression/Expr.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/Expressions.h"
@@ -167,7 +168,7 @@ void E2EFilterTestBase::readWithFilter(
   auto resultBatch = BaseVector::create(rowType_, 1, leafPool_.get());
   resetReadBatchSizes();
   int32_t clearCnt = 0;
-  auto deletedRowsIter = mutationSpec.deletedRows.begin();
+  auto deletedRowsIter = mutationSpec.deletedRows.cbegin();
   while (true) {
     {
       MicrosecondTimer timer(&time);
@@ -181,7 +182,7 @@ void E2EFilterTestBase::readWithFilter(
       auto readSize = rowReader->nextReadSize(nextReadBatchSize());
       std::vector<uint64_t> isDeleted(bits::nwords(readSize));
       bool haveDelete = false;
-      for (; deletedRowsIter != mutationSpec.deletedRows.end();
+      for (; deletedRowsIter != mutationSpec.deletedRows.cend();
            ++deletedRowsIter) {
         auto i = *deletedRowsIter;
         if (i < nextRowNumber) {
@@ -491,15 +492,31 @@ void E2EFilterTestBase::testMetadataFilterImpl(
     core::ExpressionEvaluator* evaluator,
     const std::string& remainingFilter,
     std::function<bool(int64_t, int64_t)> validationFilter) {
-  SCOPED_TRACE(fmt::format("remainingFilter={}", remainingFilter));
+  SCOPED_TRACE(fmt::format("remainingFilter='{}'", remainingFilter));
+  auto untypedExpr = parse::parseExpr(remainingFilter, {});
+  auto typedExpr = core::Expressions::inferTypes(
+      untypedExpr, batches[0]->type(), leafPool_.get());
+  testMetadataFilterImpl(
+      batches,
+      std::move(filterField),
+      std::move(filter),
+      evaluator,
+      std::move(typedExpr),
+      std::move(validationFilter));
+}
+
+void E2EFilterTestBase::testMetadataFilterImpl(
+    const std::vector<RowVectorPtr>& batches,
+    common::Subfield filterField,
+    std::unique_ptr<common::Filter> filter,
+    core::ExpressionEvaluator* evaluator,
+    core::TypedExprPtr typedExpr,
+    std::function<bool(int64_t, int64_t)> validationFilter) {
   auto spec = std::make_shared<common::ScanSpec>("<root>");
   if (filter) {
     spec->getOrCreateChild(std::move(filterField))
         ->setFilter(std::move(filter));
   }
-  auto untypedExpr = parse::parseExpr(remainingFilter, {});
-  auto typedExpr = core::Expressions::inferTypes(
-      untypedExpr, batches[0]->type(), leafPool_.get());
   auto metadataFilter =
       std::make_shared<MetadataFilter>(*spec, *typedExpr, evaluator);
   auto specA = spec->getOrCreateChild(common::Subfield("a"));
@@ -580,12 +597,13 @@ void E2EFilterTestBase::testMetadataFilter() {
         nullptr,
         c->size(),
         std::vector<VectorPtr>({c}));
-    batches.push_back(std::make_shared<RowVector>(
-        leafPool_.get(),
-        ROW({{"a", a->type()}, {"b", b->type()}}),
-        nullptr,
-        a->size(),
-        std::vector<VectorPtr>({a, b})));
+    batches.push_back(
+        std::make_shared<RowVector>(
+            leafPool_.get(),
+            ROW({{"a", a->type()}, {"b", b->type()}}),
+            nullptr,
+            a->size(),
+            std::vector<VectorPtr>({a, b})));
   }
   writeToMemory(batches[0]->type(), batches, false);
 
@@ -621,6 +639,56 @@ void E2EFilterTestBase::testMetadataFilter() {
       [](int64_t a, int64_t) {
         return !!(a == 2 || a == 3 || a == 5 || a == 7);
       });
+  {
+    SCOPED_TRACE("remainingFilter='a == 1 or a == 3 or a == 8'");
+    auto typedExpr1 = core::Expressions::inferTypes(
+        parse::parseExpr("a == 1", {}), batches[0]->type(), leafPool_.get());
+    auto typedExpr2 = core::Expressions::inferTypes(
+        parse::parseExpr("a == 3", {}), batches[0]->type(), leafPool_.get());
+    auto typedExpr3 = core::Expressions::inferTypes(
+        parse::parseExpr("a == 8", {}), batches[0]->type(), leafPool_.get());
+
+    auto typedExpr = std::make_shared<core::CallTypedExpr>(
+        velox::BOOLEAN(),
+        std::vector{
+            std::move(typedExpr1),
+            std::move(typedExpr2),
+            std::move(typedExpr3),
+        },
+        expression::kOr);
+    testMetadataFilterImpl(
+        batches,
+        common::Subfield("a"),
+        nullptr,
+        &evaluator,
+        std::move(typedExpr),
+        [](int64_t a, int64_t) { return a == 1 || a == 3 || a == 8; });
+  }
+  {
+    SCOPED_TRACE("remainingFilter='a >= 1 and a <= 100 and a == 8'");
+    auto typedExpr1 = core::Expressions::inferTypes(
+        parse::parseExpr("a >= 1", {}), batches[0]->type(), leafPool_.get());
+    auto typedExpr2 = core::Expressions::inferTypes(
+        parse::parseExpr("a <= 100", {}), batches[0]->type(), leafPool_.get());
+    auto typedExpr3 = core::Expressions::inferTypes(
+        parse::parseExpr("b.c != 8", {}), batches[0]->type(), leafPool_.get());
+
+    auto typedExpr = std::make_shared<core::CallTypedExpr>(
+        velox::BOOLEAN(),
+        std::vector{
+            std::move(typedExpr1),
+            std::move(typedExpr2),
+            std::move(typedExpr3),
+        },
+        expression::kAnd);
+    testMetadataFilterImpl(
+        batches,
+        common::Subfield("a"),
+        nullptr,
+        &evaluator,
+        std::move(typedExpr),
+        [](int64_t a, int64_t c) { return a >= 1 && a <= 100 && c != 8; });
+  }
 
   {
     SCOPED_TRACE("Values not unique in row group");
@@ -681,8 +749,18 @@ void E2EFilterTestBase::testSubfieldsPruning() {
         [](auto) { return 1; },
         [](auto) { return 0; },
         [](auto) { return "foofoofoofoofoo"_sv; });
-    batches.push_back(
-        vectorMaker.rowVector({"a", "b", "c", "d"}, {a, b, c, d}));
+    auto e = vectorMaker.mapVector<int64_t, int64_t>(
+        batchSize_,
+        [&](auto) { return kMapSize; },
+        [](auto j) { return j; },
+        [&](auto j) { return j % kMapSize; });
+    auto f = vectorMaker.arrayVector<int64_t>(
+        batchSize_,
+        [&](auto j) { return kMapSize; },
+        [&](auto j) { return j % kMapSize; },
+        [&](auto j) { return j >= i + 1 && j % 23 == (i + 1) % 23; });
+    batches.push_back(vectorMaker.rowVector(
+        {"a", "b", "c", "d", "e", "f"}, {a, b, c, d, e, f}));
   }
   writeToMemory(batches[0]->type(), batches, false);
   auto spec = std::make_shared<common::ScanSpec>("<root>");
@@ -707,6 +785,12 @@ void E2EFilterTestBase::testSubfieldsPruning() {
   auto specD = spec->addFieldRecursively("d", *MAP(BIGINT(), VARCHAR()), 3);
   specD->childByName(common::ScanSpec::kMapKeysFieldName)
       ->setFilter(common::createBigintValues({1}, false));
+  auto specE = spec->addFieldRecursively("e", *MAP(BIGINT(), BIGINT()), 4);
+  specE->childByName(common::ScanSpec::kMapValuesFieldName)
+      ->setFilter(common::createBigintValues({0, 2, 4}, false));
+  auto specF = spec->addFieldRecursively("f", *ARRAY(BIGINT()), 5);
+  specF->childByName(common::ScanSpec::kArrayElementsFieldName)
+      ->setFilter(common::createBigintValues({0, 2, 4}, false));
   ReaderOptions readerOpts{leafPool_.get()};
   RowReaderOptions rowReaderOpts;
   auto input = std::make_unique<BufferedInput>(
@@ -756,6 +840,31 @@ void E2EFilterTestBase::testSubfieldsPruning() {
       auto* dd = actual->childAt(3)->loadedVector()->asUnchecked<MapVector>();
       ASSERT_FALSE(dd->isNullAt(ii));
       ASSERT_EQ(dd->sizeAt(ii), 0);
+      auto* e = expected->childAt(4)->asUnchecked<MapVector>();
+      auto* ee = actual->childAt(4)->loadedVector()->asUnchecked<MapVector>();
+      ASSERT_FALSE(ee->isNullAt(ii));
+      ASSERT_EQ(ee->sizeAt(ii), (kMapSize + 1) / 2);
+      for (int k = 0; k < kMapSize; k += 2) {
+        int k1 = ee->offsetAt(ii) + k / 2;
+        int k2 = e->offsetAt(j) + k;
+        ASSERT_TRUE(ee->mapKeys()->equalValueAt(e->mapKeys().get(), k1, k2));
+        ASSERT_TRUE(
+            ee->mapValues()->equalValueAt(e->mapValues().get(), k1, k2));
+      }
+      auto* f = expected->childAt(5)->asUnchecked<ArrayVector>();
+      auto* ff = actual->childAt(5)->loadedVector()->asUnchecked<ArrayVector>();
+      if (f->isNullAt(j)) {
+        ASSERT_TRUE(ff->isNullAt(ii));
+      } else {
+        ASSERT_FALSE(ff->isNullAt(ii));
+        for (int k = 0; k < kMapSize; k += 2) {
+          int k1 = ff->offsetAt(ii) + k / 2;
+          int k2 = f->offsetAt(j) + k;
+
+          ASSERT_TRUE(
+              ff->elements()->equalValueAt(f->elements().get(), k1, k2));
+        }
+      }
       ++ii;
     }
   }
diff --git a/velox/dwio/common/tests/utils/E2EFilterTestBase.h b/velox/dwio/common/tests/utils/E2EFilterTestBase.h
index 16d30e36a7b7..eada6837f60d 100644
--- a/velox/dwio/common/tests/utils/E2EFilterTestBase.h
+++ b/velox/dwio/common/tests/utils/E2EFilterTestBase.h
@@ -64,7 +64,7 @@ class TestingHook : public ValueHook {
     }
   }
 
-  void addValue(vector_size_t row, folly::StringPiece value) override {
+  void addValue(vector_size_t row, std::string_view value) override {
     if constexpr (std::is_same_v<T, StringView>) {
       result_->set(row, StringView(value));
     } else {
@@ -336,6 +336,14 @@ class E2EFilterTestBase : public testing::Test {
       const std::string& remainingFilter,
       std::function<bool(int64_t a, int64_t c)> validationFilter);
 
+  void testMetadataFilterImpl(
+      const std::vector<RowVectorPtr>& batches,
+      common::Subfield filterField,
+      std::unique_ptr<common::Filter> filter,
+      core::ExpressionEvaluator* evaluator,
+      core::TypedExprPtr typedExpr,
+      std::function<bool(int64_t, int64_t)> validationFilter);
+
  protected:
   void testMetadataFilter();
 
diff --git a/velox/dwio/common/tests/utils/FilterGenerator.cpp b/velox/dwio/common/tests/utils/FilterGenerator.cpp
index d532b4cec8f3..63fc29e33e56 100644
--- a/velox/dwio/common/tests/utils/FilterGenerator.cpp
+++ b/velox/dwio/common/tests/utils/FilterGenerator.cpp
@@ -447,7 +447,9 @@ void FilterGenerator::addToScanSpec(
     const SubfieldFilters& filters,
     ScanSpec& spec) {
   for (auto& pair : filters) {
-    spec.getOrCreateChild(pair.first)->addFilter(*pair.second);
+    auto* child = spec.getOrCreateChild(pair.first);
+    VELOX_CHECK_NULL(child->filter());
+    child->setFilter(pair.second);
   }
 }
 
@@ -661,7 +663,7 @@ void pruneRandomSubfield(
                 break;
               case TypeKind::VARCHAR:
               case TypeKind::VARBINARY:
-                stringKeys.push_back(
+                stringKeys.emplace_back(
                     keys->asUnchecked<SimpleVector<StringView>>()->valueAt(jj));
                 break;
               default:
diff --git a/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp b/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp
index e2ec87ae605c..0342d0d530e3 100644
--- a/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp
+++ b/velox/dwio/common/tests/utils/UnitLoaderTestTools.cpp
@@ -90,8 +90,9 @@ bool ReaderMock::loadUnit() {
 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));
+    units.emplace_back(
+        std::make_unique<LoadUnitMock>(
+            rowsPerUnit_[i], ioSizes_[i], unitsLoaded_, i));
   }
   return units;
 }
diff --git a/velox/dwio/common/tests/utils/UnitLoaderTestTools.h b/velox/dwio/common/tests/utils/UnitLoaderTestTools.h
index 9eae97f575c2..6c36c10c8651 100644
--- a/velox/dwio/common/tests/utils/UnitLoaderTestTools.h
+++ b/velox/dwio/common/tests/utils/UnitLoaderTestTools.h
@@ -32,16 +32,20 @@ class LoadUnitMock : public LoadUnit {
       uint64_t rowCount,
       uint64_t ioSize,
       std::vector<std::atomic_bool>& unitsLoaded,
-      size_t unitId)
+      size_t unitId,
+      std::chrono::milliseconds loadDelay = std::chrono::milliseconds(100))
       : rowCount_{rowCount},
         ioSize_{ioSize},
         unitsLoaded_{unitsLoaded},
-        unitId_{unitId} {}
+        unitId_{unitId},
+        loadDelay_(loadDelay) {}
 
   ~LoadUnitMock() override = default;
 
   void load() override {
     VELOX_CHECK(!isLoaded());
+    // Simulate loading time
+    std::this_thread::sleep_for(loadDelay_);
     unitsLoaded_[unitId_] = true;
   }
 
@@ -67,6 +71,7 @@ class LoadUnitMock : public LoadUnit {
   uint64_t ioSize_;
   std::vector<std::atomic_bool>& unitsLoaded_;
   size_t unitId_;
+  std::chrono::milliseconds loadDelay_;
 };
 
 class ReaderMock {
@@ -82,7 +87,7 @@ class ReaderMock {
   void seek(uint64_t rowNumber);
 
   std::vector<bool> unitsLoaded() const {
-    return {unitsLoaded_.begin(), unitsLoaded_.end()};
+    return {unitsLoaded_.cbegin(), unitsLoaded_.cend()};
   }
 
  private:
diff --git a/velox/dwio/common/wrap/CMakeLists.txt b/velox/dwio/common/wrap/CMakeLists.txt
new file mode 100644
index 000000000000..a598690b32e5
--- /dev/null
+++ b/velox/dwio/common/wrap/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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_install_library_headers()
diff --git a/velox/dwio/dwrf/CMakeLists.txt b/velox/dwio/dwrf/CMakeLists.txt
index 613f69ad2f06..65188eb58d64 100644
--- a/velox/dwio/dwrf/CMakeLists.txt
+++ b/velox/dwio/dwrf/CMakeLists.txt
@@ -22,3 +22,5 @@ elseif(${VELOX_BUILD_TEST_UTILS})
 endif()
 add_subdirectory(utils)
 add_subdirectory(writer)
+
+velox_install_library_headers()
diff --git a/velox/dwio/dwrf/common/CMakeLists.txt b/velox/dwio/dwrf/common/CMakeLists.txt
index bb6356c94e57..3f8f38028eaa 100644
--- a/velox/dwio/dwrf/common/CMakeLists.txt
+++ b/velox/dwio/dwrf/common/CMakeLists.txt
@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+add_subdirectory(wrap)
+
 velox_add_library(
   velox_dwio_dwrf_common
   ByteRLE.cpp
@@ -26,7 +28,8 @@ velox_add_library(
   RLEv2.cpp
   Statistics.cpp
   wrap/orc-proto-wrapper.cpp
-  wrap/dwrf-proto-wrapper.cpp)
+  wrap/dwrf-proto-wrapper.cpp
+)
 
 velox_link_libraries(
   velox_dwio_dwrf_common
@@ -38,10 +41,14 @@ velox_link_libraries(
   velox_caching
   Snappy::snappy
   zstd::zstd
-  protobuf::libprotobuf)
+  protobuf::libprotobuf
+)
 
 # required for the wrapped protobuf headers/sources
-velox_include_directories(velox_dwio_dwrf_common PUBLIC ${PROJECT_BINARY_DIR})
+velox_include_directories(
+  velox_dwio_dwrf_common
+  PUBLIC "$<BUILD_LOCAL_INTERFACE:${PROJECT_BINARY_DIR}>"
+)
 
 if(NOT VELOX_MONO_LIBRARY)
   # trigger generation of pb files
diff --git a/velox/dwio/dwrf/common/Common.h b/velox/dwio/dwrf/common/Common.h
index 783f8a0329d7..ae467654c1fa 100644
--- a/velox/dwio/dwrf/common/Common.h
+++ b/velox/dwio/dwrf/common/Common.h
@@ -29,11 +29,11 @@
 namespace facebook::velox::dwrf {
 
 // Writer version
-constexpr folly::StringPiece WRITER_NAME_KEY{"orc.writer.name"};
-constexpr folly::StringPiece WRITER_VERSION_KEY{"orc.writer.version"};
-constexpr folly::StringPiece WRITER_HOSTNAME_KEY{"orc.writer.host"};
-constexpr folly::StringPiece kDwioWriter{"dwio"};
-constexpr folly::StringPiece kPrestoWriter{"presto"};
+constexpr std::string_view kWriterNameKey{"orc.writer.name"};
+constexpr std::string_view kWriterVersionKey{"orc.writer.version"};
+constexpr std::string_view kWriterHostnameKey{"orc.writer.host"};
+constexpr std::string_view kDwioWriter{"dwio"};
+constexpr std::string_view kPrestoWriter{"presto"};
 
 enum class DwrfFormat : uint8_t {
   kDwrf = 0,
diff --git a/velox/dwio/dwrf/common/Config.cpp b/velox/dwio/dwrf/common/Config.cpp
index 8ce1ad5f2155..b9c556d8a88c 100644
--- a/velox/dwio/dwrf/common/Config.cpp
+++ b/velox/dwio/dwrf/common/Config.cpp
@@ -130,7 +130,7 @@ Config::Entry<const std::vector<uint32_t>> Config::MAP_FLAT_COLS(
     [](const std::string& /* key */, const std::string& val) {
       std::vector<uint32_t> result;
       if (!val.empty()) {
-        std::vector<folly::StringPiece> pieces;
+        std::vector<std::string_view> pieces;
         folly::split(',', val, pieces, true);
         for (const auto& p : pieces) {
           const auto& trimmedCol = folly::trimWhitespace(p);
@@ -182,7 +182,7 @@ Config::Entry<const std::vector<std::vector<std::string>>>
 
 Config::Entry<uint32_t> Config::MAP_FLAT_MAX_KEYS(
     "orc.map.flat.max.keys",
-    20000);
+    30000);
 
 Config::Entry<uint64_t> Config::MAX_DICTIONARY_SIZE(
     "hive.exec.orc.max.dictionary.size",
diff --git a/velox/dwio/dwrf/common/FileMetadata.cpp b/velox/dwio/dwrf/common/FileMetadata.cpp
index ccb9f6faa7f5..2b3f2f80d499 100644
--- a/velox/dwio/dwrf/common/FileMetadata.cpp
+++ b/velox/dwio/dwrf/common/FileMetadata.cpp
@@ -37,6 +37,29 @@ CompressionKind orcCompressionToCompressionKind(
   }
   VELOX_FAIL("Unknown compression kind: {}", CompressionKind_Name(compression));
 }
+
+static proto::orc::CompressionKind compressionKindToOrcCompression(
+    CompressionKind compressionKind) {
+  switch (compressionKind) {
+    case CompressionKind::CompressionKind_NONE:
+      return proto::orc::CompressionKind::NONE;
+    case CompressionKind::CompressionKind_ZLIB:
+      return proto::orc::CompressionKind::ZLIB;
+    case CompressionKind::CompressionKind_SNAPPY:
+      return proto::orc::CompressionKind::SNAPPY;
+    case CompressionKind::CompressionKind_LZO:
+      return proto::orc::CompressionKind::LZO;
+    case CompressionKind::CompressionKind_ZSTD:
+      return proto::orc::CompressionKind::ZSTD;
+    case CompressionKind::CompressionKind_LZ4:
+      return proto::orc::CompressionKind::LZ4;
+    case CompressionKind::CompressionKind_GZIP:
+    default:
+      VELOX_FAIL(
+          "Unknown compression kind: {}",
+          compressionKindToString(compressionKind));
+  }
+}
 } // namespace detail
 
 TypeKind TypeWrapper::kind() const {
@@ -102,9 +125,10 @@ TypeKind TypeWrapper::kind() const {
     }
     case proto::orc::Type_Kind_CHAR:
     case proto::orc::Type_Kind_TIMESTAMP_INSTANT:
-      VELOX_FAIL(fmt::format(
-          "{} not supported yet.",
-          proto::orc::Type_Kind_Name(orcPtr()->kind())));
+      VELOX_FAIL(
+          fmt::format(
+              "{} not supported yet.",
+              proto::orc::Type_Kind_Name(orcPtr()->kind())));
     default:
       VELOX_FAIL("Unknown type kind: {}", Type_Kind_Name(orcPtr()->kind()));
   }
@@ -116,4 +140,13 @@ common::CompressionKind PostScript::compression() const {
       : detail::orcCompressionToCompressionKind(orcPtr()->compression());
 }
 
+void PostScriptWriteWrapper::setCompression(
+    common::CompressionKind compressionKind) {
+  format_ == DwrfFormat::kDwrf
+      ? dwrfPtr()->set_compression(
+            static_cast<proto::CompressionKind>(compressionKind))
+      : orcPtr()->set_compression(
+            detail::compressionKindToOrcCompression(compressionKind));
+}
+
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/common/FileMetadata.h b/velox/dwio/dwrf/common/FileMetadata.h
index 87e8c12719fe..3665d4b91201 100644
--- a/velox/dwio/dwrf/common/FileMetadata.h
+++ b/velox/dwio/dwrf/common/FileMetadata.h
@@ -19,6 +19,7 @@
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/compression/Compression.h"
+#include "velox/dwio/common/OutputStream.h"
 #include "velox/dwio/dwrf/common/Common.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 #include "velox/dwio/dwrf/common/wrap/orc-proto-wrapper.h"
@@ -43,6 +44,24 @@ class ProtoWrapperBase {
   const void* const impl_;
 };
 
+class ProtoWriteWrapperBase {
+ protected:
+  ProtoWriteWrapperBase(DwrfFormat format, void* impl)
+      : format_{format}, impl_{impl} {}
+
+  DwrfFormat format_;
+  void* impl_;
+
+ public:
+  DwrfFormat format() const {
+    return format_;
+  }
+
+  inline void* rawProtoPtr() const {
+    return impl_;
+  }
+};
+
 /***
  * PostScript that takes the ownership of proto::PostScript /
  *proto::orc::PostScript and provides access to the attributes
@@ -93,6 +112,10 @@ class PostScript {
                                         : orcPtr()->footerlength();
   }
 
+  uint64_t metadataLength() const {
+    return format_ == DwrfFormat::kDwrf ? 0 : orcPtr()->metadatalength();
+  }
+
   bool hasCompression() const {
     return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_compression()
                                         : orcPtr()->has_compression();
@@ -244,6 +267,46 @@ class StripeInformationWrapper : public ProtoWrapperBase {
   }
 };
 
+class ColumnEncodingKindWrapper : public ProtoWrapperBase {
+ public:
+  explicit ColumnEncodingKindWrapper(proto::ColumnEncoding_Kind* stream)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, stream) {}
+
+  explicit ColumnEncodingKindWrapper(proto::orc::ColumnEncoding_Kind* stream)
+      : ProtoWrapperBase(DwrfFormat::kOrc, stream) {}
+};
+
+class ColumnEncodingWrapper : public ProtoWrapperBase {
+ public:
+  explicit ColumnEncodingWrapper(const proto::ColumnEncoding* columnEncoding)
+      : ProtoWrapperBase(DwrfFormat::kDwrf, columnEncoding) {}
+  explicit ColumnEncodingWrapper(
+      const proto::orc::ColumnEncoding* columnEncoding)
+      : ProtoWrapperBase(DwrfFormat::kOrc, columnEncoding) {}
+
+  void Clear() {}
+
+  proto::ColumnEncoding_Kind kind() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->kind();
+  }
+
+  uint32_t node() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->node();
+  }
+
+ private:
+  // private helper with no format checking
+  inline const proto::ColumnEncoding* dwrfPtr() const {
+    return reinterpret_cast<const proto::ColumnEncoding*>(rawProtoPtr());
+  }
+
+  inline const proto::orc::ColumnEncoding* orcPtr() const {
+    return reinterpret_cast<const proto::orc::ColumnEncoding*>(rawProtoPtr());
+  }
+};
+
 class TypeWrapper : public ProtoWrapperBase {
  public:
   explicit TypeWrapper(const proto::Type* t)
@@ -940,6 +1003,1027 @@ class StripeFooterWrapper : public ProtoWrapperBase {
   std::shared_ptr<const proto::orc::StripeFooter> orcStripeFooter_ = nullptr;
 };
 
+class StripeInformationWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StripeInformationWriteWrapper(
+      proto::StripeInformation* stripeInformation)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stripeInformation) {}
+
+  explicit StripeInformationWriteWrapper(
+      proto::orc::StripeInformation* stripeInformation)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stripeInformation) {}
+
+  uint64_t numberOfRows() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->numberofrows()
+                                        : orcPtr()->numberofrows();
+  }
+
+  uint64_t rawDataSize() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->rawdatasize() : 0;
+  }
+
+  bool hasChecksum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_checksum() : false;
+  }
+
+  uint64_t checksum() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->checksum() : 0;
+  }
+
+  void setNumberOfRows(uint64_t stripeRowCount) {
+    return format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_numberofrows(stripeRowCount)
+        : orcPtr()->set_numberofrows(stripeRowCount);
+  }
+
+  void setRawDataSize(uint64_t rawDataSize) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_rawdatasize(rawDataSize);
+    }
+  }
+
+  void setChecksum(int64_t checksum) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_checksum(checksum);
+  }
+
+  void setGroupSize(uint64_t groupSize) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_groupsize(groupSize);
+  }
+
+  uint64_t groupSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->groupsize();
+  }
+
+  void setOffset(uint64_t offset) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_offset(offset)
+                                 : orcPtr()->set_offset(offset);
+  }
+
+  uint64_t offset() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->offset()
+                                        : orcPtr()->offset();
+  }
+
+  void setIndexLength(uint64_t indexLength) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_indexlength(indexLength)
+                                 : orcPtr()->set_indexlength(indexLength);
+  }
+
+  uint64_t indexLength() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->indexlength()
+                                        : orcPtr()->indexlength();
+  }
+
+  void setDataLength(uint64_t dataLength) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_datalength(dataLength)
+                                 : orcPtr()->set_datalength(dataLength);
+  }
+
+  uint64_t dataLength() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->datalength()
+                                        : orcPtr()->datalength();
+  }
+
+  void setFooterLength(uint64_t footerLength) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_footerlength(footerLength)
+                                 : orcPtr()->set_footerlength(footerLength);
+  }
+
+  uint64_t footerLength() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->footerlength()
+                                        : orcPtr()->footerlength();
+  }
+
+  std::string* addKeyMetadata() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->add_keymetadata();
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::StripeInformation* dwrfPtr() const {
+    return reinterpret_cast<proto::StripeInformation*>(rawProtoPtr());
+  }
+  inline proto::orc::StripeInformation* orcPtr() const {
+    return reinterpret_cast<proto::orc::StripeInformation*>(rawProtoPtr());
+  }
+};
+
+class TypeKindWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit TypeKindWrapper(proto::Type_Kind* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, footer) {}
+
+  explicit TypeKindWrapper(proto::orc::Type_Kind* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, footer) {}
+};
+
+class TypeWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit TypeWriteWrapper(proto::Type* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, footer) {}
+
+  explicit TypeWriteWrapper(proto::orc::Type* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, footer) {}
+
+  const proto::Type* getDwrfPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return reinterpret_cast<proto::Type*>(rawProtoPtr());
+  }
+
+  const proto::orc::Type* getOrcPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return reinterpret_cast<proto::orc::Type*>(rawProtoPtr());
+  }
+
+  void setKind(TypeKindWrapper typeKindWrapper) {
+    format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_kind(*reinterpret_cast<proto::Type_Kind*>(
+              typeKindWrapper.rawProtoPtr()))
+        : orcPtr()->set_kind(*reinterpret_cast<proto::orc::Type_Kind*>(
+              typeKindWrapper.rawProtoPtr()));
+  }
+
+  void setScale(uint32_t scale) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    orcPtr()->set_scale(scale);
+  }
+
+  void setPrecision(uint32_t precision) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    orcPtr()->set_precision(precision);
+  }
+
+  void addFieldnames(const std::string& fieldName) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->add_fieldnames(fieldName)
+                                 : orcPtr()->add_fieldnames(fieldName);
+  }
+
+  void addSubtypes(int fieldName) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->add_subtypes(fieldName)
+                                 : orcPtr()->add_subtypes(fieldName);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::Type* dwrfPtr() const {
+    return reinterpret_cast<proto::Type*>(rawProtoPtr());
+  }
+  inline proto::orc::Type* orcPtr() const {
+    return reinterpret_cast<proto::orc::Type*>(rawProtoPtr());
+  }
+};
+
+class UserMetadataItemWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit UserMetadataItemWriteWrapper(
+      proto::UserMetadataItem* userMetadataItem)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, userMetadataItem) {}
+
+  explicit UserMetadataItemWriteWrapper(
+      proto::orc::UserMetadataItem* userMetadataItem)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, userMetadataItem) {}
+
+  void setName(const std::string& name) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_name(name)
+                                 : orcPtr()->set_name(name);
+  }
+
+  void setValue(const std::string& value) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_value(value)
+                                 : orcPtr()->set_value(value);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::UserMetadataItem* dwrfPtr() const {
+    return reinterpret_cast<proto::UserMetadataItem*>(rawProtoPtr());
+  }
+  inline proto::orc::UserMetadataItem* orcPtr() const {
+    return reinterpret_cast<proto::orc::UserMetadataItem*>(rawProtoPtr());
+  }
+};
+
+class BucketStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit BucketStatisticsWriteWrapper(
+      proto::BucketStatistics* bucketStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, bucketStatistics) {}
+
+  explicit BucketStatisticsWriteWrapper(
+      proto::orc::BucketStatistics* bucketStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, bucketStatistics) {}
+
+  int countSize() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->count_size()
+                                        : orcPtr()->count_size();
+  }
+
+  void addCount(uint64_t count) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->add_count(count)
+                                 : orcPtr()->add_count(count);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::BucketStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::BucketStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::BucketStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::BucketStatistics*>(rawProtoPtr());
+  }
+};
+
+class IntegerStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit IntegerStatisticsWriteWrapper(
+      proto::IntegerStatistics* integerStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, integerStatistics) {}
+
+  explicit IntegerStatisticsWriteWrapper(
+      proto::orc::IntegerStatistics* integerStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, integerStatistics) {}
+
+  void setSum(int64_t sum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_sum(sum)
+                                 : orcPtr()->set_sum(sum);
+  }
+
+  void setMinimum(int64_t minimum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_minimum(minimum)
+                                 : orcPtr()->set_minimum(minimum);
+  }
+
+  void setMaximum(int64_t maximum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_maximum(maximum)
+                                 : orcPtr()->set_maximum(maximum);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::IntegerStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::IntegerStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::IntegerStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::IntegerStatistics*>(rawProtoPtr());
+  }
+};
+
+class DoubleStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit DoubleStatisticsWriteWrapper(
+      proto::DoubleStatistics* doubleStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, doubleStatistics) {}
+
+  explicit DoubleStatisticsWriteWrapper(
+      proto::orc::DoubleStatistics* doubleStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, doubleStatistics) {}
+
+  void setSum(double sum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_sum(sum)
+                                 : orcPtr()->set_sum(sum);
+  }
+
+  void setMinimum(double minimum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_minimum(minimum)
+                                 : orcPtr()->set_minimum(minimum);
+  }
+
+  void setMaximum(double maximum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_maximum(maximum)
+                                 : orcPtr()->set_maximum(maximum);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::DoubleStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::DoubleStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::DoubleStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::DoubleStatistics*>(rawProtoPtr());
+  }
+};
+
+class StringStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StringStatisticsWriteWrapper(
+      proto::StringStatistics* stringStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stringStatistics) {}
+
+  explicit StringStatisticsWriteWrapper(
+      proto::orc::StringStatistics* stringStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stringStatistics) {}
+
+  void setSum(uint64_t sum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_sum(sum)
+                                 : orcPtr()->set_sum(sum);
+  }
+
+  void setMinimum(std::string minimum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_minimum(minimum)
+                                 : orcPtr()->set_minimum(minimum);
+  }
+
+  void setMaximum(std::string maximum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_maximum(maximum)
+                                 : orcPtr()->set_maximum(maximum);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::StringStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::StringStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::StringStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::StringStatistics*>(rawProtoPtr());
+  }
+};
+
+class BinaryStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit BinaryStatisticsWriteWrapper(
+      proto::BinaryStatistics* binaryStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, binaryStatistics) {}
+
+  explicit BinaryStatisticsWriteWrapper(
+      proto::orc::BinaryStatistics* binaryStatistics)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, binaryStatistics) {}
+
+  void setSum(uint64_t sum) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_sum(sum)
+                                 : orcPtr()->set_sum(sum);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::BinaryStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::BinaryStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::BinaryStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::BinaryStatistics*>(rawProtoPtr());
+  }
+};
+
+class ColumnStatisticsWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit ColumnStatisticsWriteWrapper(proto::ColumnStatistics* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, footer) {}
+
+  explicit ColumnStatisticsWriteWrapper(proto::orc::ColumnStatistics* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, footer) {}
+
+  void setSize(uint64_t size) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_size(size);
+    }
+  }
+
+  void setHasNull(bool hasNull) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_hasnull(hasNull)
+                                 : orcPtr()->set_hasnull(hasNull);
+  }
+
+  void setNumberOfValues(uint64_t numberOfValues) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_numberofvalues(numberOfValues)
+                                 : orcPtr()->set_numberofvalues(numberOfValues);
+  }
+
+  void setRawSize(uint64_t rawSize) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_rawsize(rawSize);
+    }
+  }
+
+  uint64_t getRawSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->rawsize();
+  }
+
+  uint64_t getSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->size();
+  }
+
+  bool hasMapStatistics() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->has_mapstatistics();
+  }
+
+  proto::MapStatistics* mutableMapStatistics() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->mutable_mapstatistics();
+  }
+
+  BinaryStatisticsWriteWrapper mutableBinaryStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? BinaryStatisticsWriteWrapper(dwrfPtr()->mutable_binarystatistics())
+        : BinaryStatisticsWriteWrapper(orcPtr()->mutable_binarystatistics());
+  }
+
+  StringStatisticsWriteWrapper mutableStringStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? StringStatisticsWriteWrapper(dwrfPtr()->mutable_stringstatistics())
+        : StringStatisticsWriteWrapper(orcPtr()->mutable_stringstatistics());
+  }
+
+  DoubleStatisticsWriteWrapper mutableDoubleStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? DoubleStatisticsWriteWrapper(dwrfPtr()->mutable_doublestatistics())
+        : DoubleStatisticsWriteWrapper(orcPtr()->mutable_doublestatistics());
+  }
+
+  IntegerStatisticsWriteWrapper mutableIntegerStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? IntegerStatisticsWriteWrapper(dwrfPtr()->mutable_intstatistics())
+        : IntegerStatisticsWriteWrapper(orcPtr()->mutable_intstatistics());
+  }
+
+  proto::orc::DateStatistics* mutableDateStatistics() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return orcPtr()->mutable_datestatistics();
+  }
+
+  proto::orc::TimestampStatistics* mutableTimestampStatistics() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return orcPtr()->mutable_timestampstatistics();
+  }
+
+  proto::orc::DecimalStatistics* mutableDecimalStatistics() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return orcPtr()->mutable_decimalstatistics();
+  }
+
+  BucketStatisticsWriteWrapper mutableBucketStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? BucketStatisticsWriteWrapper(dwrfPtr()->mutable_bucketstatistics())
+        : BucketStatisticsWriteWrapper(orcPtr()->mutable_bucketstatistics());
+  }
+
+  void reset(const proto::ColumnStatistics* dwrfStatistics) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    VELOX_CHECK_NOT_NULL(dwrfStatistics);
+    dwrfPtr()->CopyFrom(*dwrfStatistics);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::ColumnStatistics* dwrfPtr() const {
+    return reinterpret_cast<proto::ColumnStatistics*>(rawProtoPtr());
+  }
+  inline proto::orc::ColumnStatistics* orcPtr() const {
+    return reinterpret_cast<proto::orc::ColumnStatistics*>(rawProtoPtr());
+  }
+};
+
+class FooterWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit FooterWriteWrapper(proto::Footer* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, footer) {}
+
+  explicit FooterWriteWrapper(proto::orc::Footer* footer)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, footer) {}
+
+  const proto::Footer* getDwrfPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return reinterpret_cast<proto::Footer*>(rawProtoPtr());
+  }
+
+  proto::Footer* getMutableDwrfPtr() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return reinterpret_cast<proto::Footer*>(rawProtoPtr());
+  }
+
+  const proto::orc::Footer* getOrcPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kOrc);
+    return reinterpret_cast<proto::orc::Footer*>(rawProtoPtr());
+  }
+
+  const StripeInformationWriteWrapper addStripes() const {
+    return format_ == DwrfFormat::kDwrf
+        ? StripeInformationWriteWrapper(dwrfPtr()->add_stripes())
+        : StripeInformationWriteWrapper(orcPtr()->add_stripes());
+  }
+
+  void setHeaderLength(uint64_t headerLength) const {
+    return format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_headerlength(headerLength)
+        : orcPtr()->set_headerlength(headerLength);
+  }
+
+  void setContentLength(uint64_t contentLength) const {
+    return format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_contentlength(contentLength)
+        : orcPtr()->set_contentlength(contentLength);
+  }
+
+  void setRowIndexStride(uint32_t rowIndexStride) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_rowindexstride(rowIndexStride)
+                                 : orcPtr()->set_rowindexstride(rowIndexStride);
+  }
+
+  void setNumberOfRows(uint64_t numberOfRows) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_numberofrows(numberOfRows)
+                                 : orcPtr()->set_numberofrows(numberOfRows);
+  }
+
+  void setRawDataSize(uint64_t numberOfRows) const {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_rawdatasize(numberOfRows);
+    }
+  }
+
+  void setWriter(uint32_t writer) const {
+    if (format_ == DwrfFormat::kOrc) {
+      orcPtr()->set_writer(writer);
+    }
+  }
+
+  void setCheckSumAlgorithm(proto::ChecksumAlgorithm checksum) const {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_checksumalgorithm(checksum);
+    }
+  }
+
+  void addStripeCacheOffsets(uint32_t stripeCacheOffsets) const {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->add_stripecacheoffsets(stripeCacheOffsets);
+    } else {
+      //
+    }
+  }
+
+  TypeWriteWrapper addTypes() const {
+    return format_ == DwrfFormat::kDwrf
+        ? TypeWriteWrapper(dwrfPtr()->add_types())
+        : TypeWriteWrapper(orcPtr()->add_types());
+  }
+
+  UserMetadataItemWriteWrapper addMetadata() const {
+    return format_ == DwrfFormat::kDwrf
+        ? UserMetadataItemWriteWrapper(dwrfPtr()->add_metadata())
+        : UserMetadataItemWriteWrapper(orcPtr()->add_metadata());
+  }
+
+  ColumnStatisticsWriteWrapper addStatistics() const {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnStatisticsWriteWrapper(dwrfPtr()->add_statistics())
+        : ColumnStatisticsWriteWrapper(orcPtr()->add_statistics());
+  }
+
+  const ::google::protobuf::RepeatedPtrField<
+      ::facebook::velox::dwrf::proto::ColumnStatistics>&
+  statistics() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->statistics();
+  }
+
+  int typesSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->types_size()
+                                        : orcPtr()->types_size();
+  }
+
+  int statisticsSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->statistics_size()
+                                        : orcPtr()->statistics_size();
+  }
+
+  uint64_t contentLength() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->contentlength()
+                                        : orcPtr()->contentlength();
+  }
+
+  uint64_t numberOfRows() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->numberofrows()
+                                        : orcPtr()->numberofrows();
+  }
+
+  // DWRF-specific fields
+  inline uint64_t rawDataSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->rawdatasize();
+  }
+
+  inline int stripesSize() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->stripes_size();
+  }
+
+  inline proto::Encryption* mutableEncryption() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->mutable_encryption();
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::Footer* dwrfPtr() const {
+    return reinterpret_cast<proto::Footer*>(rawProtoPtr());
+  }
+  inline proto::orc::Footer* orcPtr() const {
+    return reinterpret_cast<proto::orc::Footer*>(rawProtoPtr());
+  }
+};
+
+class RowIndexEntryWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit RowIndexEntryWriteWrapper(proto::RowIndexEntry* rowIndexEntry)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, rowIndexEntry) {}
+
+  explicit RowIndexEntryWriteWrapper(proto::orc::RowIndexEntry* rowIndexEntry)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, rowIndexEntry) {}
+
+  ColumnStatisticsWriteWrapper mutableStatistics() {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnStatisticsWriteWrapper(dwrfPtr()->mutable_statistics())
+        : ColumnStatisticsWriteWrapper(orcPtr()->mutable_statistics());
+  }
+
+  bool hasStatistics() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->has_statistics()
+                                        : orcPtr()->has_statistics();
+  }
+
+  void mutablePositions(int start, int num) {
+    return format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->mutable_positions()->ExtractSubrange(start, num, nullptr)
+        : orcPtr()->mutable_positions()->ExtractSubrange(start, num, nullptr);
+  }
+
+  void addPositions(uint64_t pos) {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->add_positions(pos)
+                                        : orcPtr()->add_positions(pos);
+  }
+
+  uint64_t positionsSize() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->positions_size()
+                                        : orcPtr()->positions_size();
+  }
+
+  const ::google::protobuf::RepeatedField<uint64_t> positions() const {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->positions()
+                                        : orcPtr()->positions();
+  }
+
+  void clear() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->Clear()
+                                        : orcPtr()->Clear();
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::RowIndexEntry* dwrfPtr() const {
+    return reinterpret_cast<proto::RowIndexEntry*>(rawProtoPtr());
+  }
+  inline proto::orc::RowIndexEntry* orcPtr() const {
+    return reinterpret_cast<proto::orc::RowIndexEntry*>(rawProtoPtr());
+  }
+};
+
+class RowIndexWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit RowIndexWriteWrapper(proto::RowIndex* rowIndex)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, rowIndex) {}
+
+  explicit RowIndexWriteWrapper(proto::orc::RowIndex* rowIndex)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, rowIndex) {}
+
+  void addEntry(std::unique_ptr<RowIndexEntryWriteWrapper>& entry) {
+    if (format_ == DwrfFormat::kDwrf) {
+      auto e = reinterpret_cast<proto::RowIndexEntry*>(entry->rawProtoPtr());
+      *dwrfPtr()->add_entry() = *e;
+    } else {
+      auto e =
+          reinterpret_cast<proto::orc::RowIndexEntry*>(entry->rawProtoPtr());
+      *orcPtr()->add_entry() = *e;
+    }
+  }
+
+  int32_t entrySize() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->entry_size()
+                                        : orcPtr()->entry_size();
+  }
+
+  RowIndexEntryWriteWrapper mutableEntry(int32_t index) {
+    return format_ == DwrfFormat::kDwrf
+        ? RowIndexEntryWriteWrapper(dwrfPtr()->mutable_entry(index))
+        : RowIndexEntryWriteWrapper(orcPtr()->mutable_entry(index));
+  }
+
+  void SerializeToZeroCopyStream(
+      dwio::common::BufferedOutputStream* out) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->SerializeToZeroCopyStream(out)
+                                 : orcPtr()->SerializeToZeroCopyStream(out);
+  }
+
+  void clear() {
+    return format_ == DwrfFormat::kDwrf ? dwrfPtr()->Clear()
+                                        : orcPtr()->Clear();
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::RowIndex* dwrfPtr() const {
+    return reinterpret_cast<proto::RowIndex*>(rawProtoPtr());
+  }
+  inline proto::orc::RowIndex* orcPtr() const {
+    return reinterpret_cast<proto::orc::RowIndex*>(rawProtoPtr());
+  }
+};
+
+class ColumnEncodingWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit ColumnEncodingWriteWrapper(proto::ColumnEncoding* stream)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stream) {}
+
+  explicit ColumnEncodingWriteWrapper(proto::orc::ColumnEncoding* stream)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stream) {}
+
+  void setKind(ColumnEncodingKindWrapper columnEncodingKindWrapper) {
+    format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_kind(
+              *reinterpret_cast<const proto::ColumnEncoding_Kind*>(
+                  columnEncodingKindWrapper.rawProtoPtr()))
+        : orcPtr()->set_kind(
+              *reinterpret_cast<const proto::orc::ColumnEncoding_Kind*>(
+                  columnEncodingKindWrapper.rawProtoPtr()));
+  }
+
+  void setDictionarySize(uint32_t dictionarySize) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_dictionarysize(dictionarySize)
+                                 : orcPtr()->set_dictionarysize(dictionarySize);
+  }
+
+  void setNode(uint32_t node) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_node(node);
+    }
+  }
+
+  void setSequence(uint32_t sequence) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_sequence(sequence);
+    }
+  }
+
+  proto::KeyInfo* mutableKey() {
+    return dwrfPtr()->mutable_key();
+  }
+
+  void Clear() {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->Clear() : orcPtr()->Clear();
+  }
+
+  void reset(const proto::ColumnEncoding* dwrfEncoding) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    VELOX_CHECK_NOT_NULL(dwrfEncoding);
+    dwrfPtr()->CopyFrom(*dwrfEncoding);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::ColumnEncoding* dwrfPtr() const {
+    return reinterpret_cast<proto::ColumnEncoding*>(rawProtoPtr());
+  }
+  inline proto::orc::ColumnEncoding* orcPtr() const {
+    return reinterpret_cast<proto::orc::ColumnEncoding*>(rawProtoPtr());
+  }
+};
+
+class StreamWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StreamWriteWrapper(proto::Stream* stream)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stream) {}
+
+  explicit StreamWriteWrapper(proto::orc::Stream* stream)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stream) {}
+
+  void setOffset(uint64_t offset) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_offset(offset);
+  }
+
+  void setKind(const StreamKind& kind) {
+    format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_kind(static_cast<proto::Stream_Kind>(kind))
+        : orcPtr()->set_kind(static_cast<proto::orc::Stream_Kind>(kind));
+  }
+
+  void setColumn(uint32_t column) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_column(column)
+                                 : orcPtr()->set_column(column);
+  }
+
+  void setLength(uint64_t length) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_length(length)
+                                 : orcPtr()->set_length(length);
+  }
+
+  void setNode(uint32_t node) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_node(node);
+  }
+
+  void setSequence(uint32_t sequence) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_sequence(sequence);
+  }
+
+  void setUseVints(bool useVints) {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    dwrfPtr()->set_usevints(useVints);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::Stream* dwrfPtr() const {
+    return reinterpret_cast<proto::Stream*>(rawProtoPtr());
+  }
+  inline proto::orc::Stream* orcPtr() const {
+    return reinterpret_cast<proto::orc::Stream*>(rawProtoPtr());
+  }
+};
+
+class StripeEncryptionGroupWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StripeEncryptionGroupWriteWrapper(
+      proto::StripeEncryptionGroup* stripeFooter = nullptr)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stripeFooter) {}
+
+  // See https://orc.apache.org/specification/ORCv1/
+  explicit StripeEncryptionGroupWriteWrapper(
+      proto::orc::StripeEncryptionVariant* stripeFooter)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stripeFooter) {}
+
+  void encoding(
+      std::vector<ColumnEncodingWrapper>& columnEncodingWrappers) const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    for (const proto::ColumnEncoding& encoding : dwrfPtr()->encoding()) {
+      auto ce = ColumnEncodingWrapper(&encoding);
+      columnEncodingWrappers.emplace_back(ce);
+    }
+  }
+
+  ColumnEncodingWriteWrapper addEncoding() {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnEncodingWriteWrapper(dwrfPtr()->add_encoding())
+        : ColumnEncodingWriteWrapper(orcPtr()->add_encoding());
+  }
+
+  StreamWriteWrapper addStreams() {
+    return format_ == DwrfFormat::kDwrf
+        ? StreamWriteWrapper(dwrfPtr()->add_streams())
+        : StreamWriteWrapper(orcPtr()->add_streams());
+  }
+
+  void SerializeToZeroCopyStream(
+      dwio::common::BufferedOutputStream* output) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->SerializeToZeroCopyStream(output)
+                                 : orcPtr()->SerializeToZeroCopyStream(output);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::StripeEncryptionGroup* dwrfPtr() const {
+    return reinterpret_cast<proto::StripeEncryptionGroup*>(rawProtoPtr());
+  }
+  inline proto::orc::StripeEncryptionVariant* orcPtr() const {
+    return reinterpret_cast<proto::orc::StripeEncryptionVariant*>(
+        rawProtoPtr());
+  }
+};
+
+class StripeFooterWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit StripeFooterWriteWrapper(proto::StripeFooter* stripeFooter)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, stripeFooter) {}
+
+  explicit StripeFooterWriteWrapper(proto::orc::StripeFooter* stripeFooter)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, stripeFooter) {}
+
+  void encoding(
+      std::vector<ColumnEncodingWrapper>& columnEncodingWrappers) const {
+    if (format_ == DwrfFormat::kDwrf) {
+      for (const proto::ColumnEncoding& encoding : dwrfPtr()->encoding()) {
+        auto ce = ColumnEncodingWrapper(&encoding);
+        columnEncodingWrappers.emplace_back(ce);
+      }
+    } else {
+      for (const proto::orc::ColumnEncoding& encoding : orcPtr()->columns()) {
+        auto ce = ColumnEncodingWrapper(&encoding);
+        columnEncodingWrappers.emplace_back(ce);
+      }
+    }
+  }
+
+  void setWriterTimezone() const {
+    if (format_ == DwrfFormat::kOrc) {
+      // orcPtr()->set_writertimezone("Asia/Shanghai");
+    }
+  }
+
+  StreamWriteWrapper addStreams() {
+    return format_ == DwrfFormat::kDwrf
+        ? StreamWriteWrapper(dwrfPtr()->add_streams())
+        : StreamWriteWrapper(orcPtr()->add_streams());
+  }
+
+  std::string* addEncryptionGroups() {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return dwrfPtr()->add_encryptiongroups();
+  }
+
+  ColumnEncodingWriteWrapper addEncoding() {
+    return format_ == DwrfFormat::kDwrf
+        ? ColumnEncodingWriteWrapper(dwrfPtr()->add_encoding())
+        : ColumnEncodingWriteWrapper(orcPtr()->add_columns());
+  }
+
+  void SerializeToZeroCopyStream(
+      dwio::common::BufferedOutputStream* output) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->SerializeToZeroCopyStream(output)
+                                 : orcPtr()->SerializeToZeroCopyStream(output);
+  }
+
+  inline proto::StripeFooter* dwrfPtr() const {
+    VELOX_CHECK_EQ(format_, DwrfFormat::kDwrf);
+    return reinterpret_cast<proto::StripeFooter*>(rawProtoPtr());
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::orc::StripeFooter* orcPtr() const {
+    return reinterpret_cast<proto::orc::StripeFooter*>(rawProtoPtr());
+  }
+};
+
+class PostScriptWriteWrapper : public ProtoWriteWrapperBase {
+ public:
+  explicit PostScriptWriteWrapper(proto::PostScript* postScript)
+      : ProtoWriteWrapperBase(DwrfFormat::kDwrf, postScript) {}
+
+  explicit PostScriptWriteWrapper(proto::orc::PostScript* postScript)
+      : ProtoWriteWrapperBase(DwrfFormat::kOrc, postScript) {}
+
+  void setWriterVersion(uint32_t writerVersion) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_writerversion(writerVersion)
+                                 : orcPtr()->set_writerversion(6);
+  }
+
+  void addVersion(uint32_t version) {
+    if (format_ == DwrfFormat::kOrc) {
+      orcPtr()->add_version(version);
+    }
+  }
+
+  void setFooterLength(uint64_t footerLength) {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->set_footerlength(footerLength)
+                                 : orcPtr()->set_footerlength(footerLength);
+  }
+
+  void setCompression(common::CompressionKind compressionKind);
+
+  void setCompressionBlockSize(uint64_t compressionBlockSize) {
+    format_ == DwrfFormat::kDwrf
+        ? dwrfPtr()->set_compressionblocksize(compressionBlockSize)
+        : orcPtr()->set_compressionblocksize(compressionBlockSize);
+  }
+
+  void setCacheMode(StripeCacheMode cacheMode) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_cachemode(static_cast<proto::StripeCacheMode>(cacheMode));
+    }
+  }
+
+  void setCacheSize(uint32_t cacheSize) {
+    if (format_ == DwrfFormat::kDwrf) {
+      dwrfPtr()->set_cachesize(cacheSize);
+    }
+  }
+
+  void setMetaDataLength(uint64_t metaDataLength) {
+    if (format_ == DwrfFormat::kOrc) {
+      orcPtr()->set_metadatalength(metaDataLength);
+    }
+  }
+
+  void SerializeToZeroCopyStream(
+      dwio::common::BufferedOutputStream* out) const {
+    format_ == DwrfFormat::kDwrf ? dwrfPtr()->SerializeToZeroCopyStream(out)
+                                 : orcPtr()->SerializeToZeroCopyStream(out);
+  }
+
+ private:
+  // private helper with no format checking
+  inline proto::PostScript* dwrfPtr() const {
+    return reinterpret_cast<proto::PostScript*>(rawProtoPtr());
+  }
+  inline proto::orc::PostScript* orcPtr() const {
+    return reinterpret_cast<proto::orc::PostScript*>(rawProtoPtr());
+  }
+};
+
 } // namespace facebook::velox::dwrf
 
 template <>
diff --git a/velox/dwio/dwrf/common/IntEncoder.h b/velox/dwio/dwrf/common/IntEncoder.h
index 1051967bb39b..bba9060a1839 100644
--- a/velox/dwio/dwrf/common/IntEncoder.h
+++ b/velox/dwio/dwrf/common/IntEncoder.h
@@ -341,8 +341,9 @@ template <bool isSigned>
     case 57 ... 63:
       return writeVarint<1>(value, buffer);
   }
-  DWIO_RAISE(folly::sformat(
-      "Unexpected leading zeros {} for value {}", leadingZeros, value));
+  DWIO_RAISE(
+      folly::sformat(
+          "Unexpected leading zeros {} for value {}", leadingZeros, value));
 }
 
 template <bool isSigned>
diff --git a/velox/dwio/dwrf/common/RLEv1.h b/velox/dwio/dwrf/common/RLEv1.h
index 082b57c10e08..62ab5d444f1a 100644
--- a/velox/dwio/dwrf/common/RLEv1.h
+++ b/velox/dwio/dwrf/common/RLEv1.h
@@ -417,7 +417,7 @@ class RleDecoderV1 : public dwio::common::IntDecoder<isSigned> {
         rows + rowIndex,
         std::min<int32_t>(remainingValues_, numRows - rowIndex));
     const auto endOfRun = currentRow + remainingValues_;
-    const auto bound = std::lower_bound(range.begin(), range.end(), endOfRun);
+    const auto bound = std::lower_bound(range.cbegin(), range.cend(), endOfRun);
     return std::make_pair(bound - range.begin(), bound[-1] - currentRow + 1);
   }
 
diff --git a/velox/dwio/dwrf/common/wrap/CMakeLists.txt b/velox/dwio/dwrf/common/wrap/CMakeLists.txt
new file mode 100644
index 000000000000..a598690b32e5
--- /dev/null
+++ b/velox/dwio/dwrf/common/wrap/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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_install_library_headers()
diff --git a/velox/dwio/dwrf/proto/CMakeLists.txt b/velox/dwio/dwrf/proto/CMakeLists.txt
index 2f0de359d08a..fd2ade2dac98 100644
--- a/velox/dwio/dwrf/proto/CMakeLists.txt
+++ b/velox/dwio/dwrf/proto/CMakeLists.txt
@@ -13,19 +13,13 @@
 # limitations under the License.
 
 # Set up Proto
-file(
-  GLOB PROTO_FILES
-  RELATIVE ${PROJECT_SOURCE_DIR}
-  ${CMAKE_CURRENT_SOURCE_DIR}/*.proto)
+file(GLOB PROTO_FILES RELATIVE ${PROJECT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.proto)
 foreach(PROTO ${PROTO_FILES})
   get_filename_component(PROTO_DIR ${PROTO} DIRECTORY)
   get_filename_component(PROTO_NAME ${PROTO} NAME_WE)
-  list(APPEND PROTO_SRCS
-       "${PROJECT_BINARY_DIR}/${PROTO_DIR}/${PROTO_NAME}.pb.cc")
-  list(APPEND PROTO_HDRS
-       "${PROJECT_BINARY_DIR}/${PROTO_DIR}/${PROTO_NAME}.pb.h")
-  list(APPEND PROTO_FILES_FULL
-       "${PROJECT_SOURCE_DIR}/${PROTO_DIR}/${PROTO_NAME}.proto")
+  list(APPEND PROTO_SRCS "${PROJECT_BINARY_DIR}/${PROTO_DIR}/${PROTO_NAME}.pb.cc")
+  list(APPEND PROTO_HDRS "${PROJECT_BINARY_DIR}/${PROTO_DIR}/${PROTO_NAME}.pb.h")
+  list(APPEND PROTO_FILES_FULL "${PROJECT_SOURCE_DIR}/${PROTO_DIR}/${PROTO_NAME}.proto")
 endforeach()
 set(PROTO_OUTPUT_FILES ${PROTO_HDRS} ${PROTO_SRCS})
 set_source_files_properties(${PROTO_OUTPUT_FILES} PROPERTIES GENERATED TRUE)
@@ -37,11 +31,11 @@ endforeach()
 
 add_custom_command(
   OUTPUT ${PROTO_OUTPUT_FILES}
-  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${PROJECT_BINARY_DIR}
-          ${PROTO_FILES_FULL}
+  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${PROJECT_BINARY_DIR} ${PROTO_FILES_FULL}
   DEPENDS protobuf::protoc
   COMMENT "Running PROTO compiler"
-  VERBATIM)
+  VERBATIM
+)
 add_custom_target(dwio_proto ALL DEPENDS ${PROTO_OUTPUT_FILES})
 
 if(VELOX_MONO_LIBRARY)
diff --git a/velox/dwio/dwrf/proto/dwrf_proto.proto b/velox/dwio/dwrf/proto/dwrf_proto.proto
index aaf69dcf1555..ba0f3350a26d 100644
--- a/velox/dwio/dwrf/proto/dwrf_proto.proto
+++ b/velox/dwio/dwrf/proto/dwrf_proto.proto
@@ -284,6 +284,7 @@ enum CompressionKind {
   LZO = 3;
   ZSTD = 4;
   LZ4 = 5;
+  GZIP = 6;
 }
 
 enum StripeCacheMode {
diff --git a/velox/dwio/dwrf/proto/fb_protobuf.sh b/velox/dwio/dwrf/proto/fb_protobuf.sh
index c7367f75d8e7..0212d8c890af 100755
--- a/velox/dwio/dwrf/proto/fb_protobuf.sh
+++ b/velox/dwio/dwrf/proto/fb_protobuf.sh
@@ -16,6 +16,6 @@
 set -e
 
 (
-    "${PROTOC:-protoc}" dwrf_proto.proto --cpp_out="$INSTALL_DIR"
-    "${PROTOC:-protoc}" orc_proto.proto --cpp_out="$INSTALL_DIR"
+  "${PROTOC:-protoc}" dwrf_proto.proto --cpp_out="$INSTALL_DIR"
+  "${PROTOC:-protoc}" orc_proto.proto --cpp_out="$INSTALL_DIR"
 )
diff --git a/velox/dwio/dwrf/reader/CMakeLists.txt b/velox/dwio/dwrf/reader/CMakeLists.txt
index cae8fcc24bbe..8b6f04ec9625 100644
--- a/velox/dwio/dwrf/reader/CMakeLists.txt
+++ b/velox/dwio/dwrf/reader/CMakeLists.txt
@@ -33,7 +33,8 @@ velox_add_library(
   StreamLabels.cpp
   StripeDictionaryCache.cpp
   StripeReaderBase.cpp
-  StripeStream.cpp)
+  StripeStream.cpp
+)
 
 velox_link_libraries(
   velox_dwio_dwrf_reader
@@ -42,4 +43,5 @@ velox_link_libraries(
   velox_caching
   velox_dwio_dwrf_utils
   velox_test_util
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/dwio/dwrf/reader/ColumnReader.cpp b/velox/dwio/dwrf/reader/ColumnReader.cpp
index 919ebf61af4e..0e20372722cc 100644
--- a/velox/dwio/dwrf/reader/ColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/ColumnReader.cpp
@@ -302,7 +302,7 @@ void ByteRleColumnReader<FileType, RequestedType>::next(
 
   BufferPtr values;
   if (flatVector) {
-    values = flatVector->mutableValues(numValues);
+    values = flatVector->mutableValues();
   }
 
   if (flatVector) {
@@ -475,7 +475,7 @@ void DecimalColumnReader<DataT>::next(
   }
   BufferPtr values;
   if (flatVector) {
-    values = flatVector->mutableValues(numValues);
+    values = flatVector->mutableValues();
   }
 
   BufferPtr nulls = readNulls(numValues, result, incomingNulls);
@@ -585,8 +585,8 @@ void IntegerDirectColumnReader<ReqT>::next(
   auto flatVector = resetIfWrongFlatVectorType<ReqT>(result);
   BufferPtr values;
   if (flatVector) {
-    values = flatVector->mutableValues(numValues);
     result->resize(numValues, false);
+    values = flatVector->mutableValues();
   }
 
   BufferPtr nulls = readNulls(numValues, result, incomingNulls);
@@ -743,7 +743,7 @@ void IntegerDictionaryColumnReader<ReqT>::next(
   BufferPtr values;
   if (result) {
     result->resize(numValues, false);
-    values = flatVector->mutableValues(numValues);
+    values = flatVector->mutableValues();
   }
 
   BufferPtr nulls = readNulls(numValues, result, incomingNulls);
@@ -869,7 +869,7 @@ void TimestampColumnReader::next(
   BufferPtr values;
   if (flatVector) {
     result->resize(numValues, false);
-    values = flatVector->mutableValues(numValues);
+    values = flatVector->mutableValues();
   }
 
   BufferPtr nulls = readNulls(numValues, result, incomingNulls);
@@ -1023,7 +1023,7 @@ void FloatingPointColumnReader<DataT, ReqT>::next(
   }
   BufferPtr values;
   if (flatVector) {
-    values = flatVector->mutableValues(numValues);
+    values = flatVector->mutableValues();
   }
 
   BufferPtr nulls = readNulls(numValues, result, incomingNulls);
@@ -1311,7 +1311,7 @@ void StringDictionaryColumnReader::loadStrideDictionary() {
   if (strideDictCount_ > 0) {
     // seek stride dictionary related streams
     std::vector<uint64_t> pos(
-        positions.begin() + positionOffset_, positions.end());
+        positions.cbegin() + positionOffset_, positions.cend());
     dwio::common::PositionProvider pp(pos);
     strideDictStream_->seekToPosition(pp);
     strideDictLengthDecoder_->seekToRowGroup(pp);
@@ -1544,7 +1544,7 @@ void StringDictionaryColumnReader::readFlatVector(
 
   BufferPtr data;
   if (flatVector) {
-    data = flatVector->mutableValues(numValues);
+    data = flatVector->mutableValues();
   }
 
   BufferPtr nulls = readNulls(numValues, result, incomingNulls);
@@ -1773,7 +1773,7 @@ void StringDirectColumnReader::next(
   BufferPtr values;
   if (flatVector) {
     flatVector->resize(numValues, false);
-    values = flatVector->mutableValues(numValues);
+    values = flatVector->mutableValues();
   }
 
   BufferPtr nulls = readNulls(numValues, result, incomingNulls);
@@ -2461,8 +2461,9 @@ std::unique_ptr<ColumnReader> buildByteRleColumnReader(
           RleDecoderFactory<DataT>::get(),
           std::move(flatMapContext));
     default:
-      DWIO_RAISE(fmt::format(
-          "Unsupported upcast to typekind: {}", requestedType->toString()));
+      DWIO_RAISE(
+          fmt::format(
+              "Unsupported upcast to typekind: {}", requestedType->toString()));
   }
 }
 
@@ -2502,9 +2503,10 @@ std::unique_ptr<ColumnReader> buildTypedIntegerColumnReader(
           numBytes,
           std::move(flatMapContext));
     default:
-      DWIO_RAISE(fmt::format(
-          "Unsupported requested integral type: {}",
-          requestedType->toString()));
+      DWIO_RAISE(
+          fmt::format(
+              "Unsupported requested integral type: {}",
+              requestedType->toString()));
   }
 }
 
diff --git a/velox/dwio/dwrf/reader/DwrfData.cpp b/velox/dwio/dwrf/reader/DwrfData.cpp
index 509791b44d12..afbf5b4ee3bb 100644
--- a/velox/dwio/dwrf/reader/DwrfData.cpp
+++ b/velox/dwio/dwrf/reader/DwrfData.cpp
@@ -101,6 +101,7 @@ void DwrfData::ensureRowGroupIndex() {
 
 dwio::common::PositionProvider DwrfData::seekToRowGroup(int64_t index) {
   ensureRowGroupIndex();
+  VELOX_CHECK_LT(index, index_->entry_size(), "RowGroup index is corrupted");
 
   positionsHolder_ = toPositionsInner(index_->entry(index));
   dwio::common::PositionProvider positionProvider(positionsHolder_);
diff --git a/velox/dwio/dwrf/reader/DwrfData.h b/velox/dwio/dwrf/reader/DwrfData.h
index 5c17cd77aafc..04fa978a96e8 100644
--- a/velox/dwio/dwrf/reader/DwrfData.h
+++ b/velox/dwio/dwrf/reader/DwrfData.h
@@ -72,6 +72,10 @@ class DwrfData : public dwio::common::FormatData {
     return flatMapContext_.inMapDecoder ? inMap_->as<uint64_t>() : nullptr;
   }
 
+  const velox::BufferPtr& inMapBuffer() {
+    return inMap_;
+  }
+
   /// 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(int64_t index) override;
@@ -96,7 +100,7 @@ class DwrfData : public dwio::common::FormatData {
   static std::vector<uint64_t> toPositionsInner(
       const proto::RowIndexEntry& entry) {
     return std::vector<uint64_t>(
-        entry.positions().begin(), entry.positions().end());
+        entry.positions().cbegin(), entry.positions().cend());
   }
 
   memory::MemoryPool& memoryPool_;
diff --git a/velox/dwio/dwrf/reader/DwrfReader.cpp b/velox/dwio/dwrf/reader/DwrfReader.cpp
index 637247e1a685..f311d3953a6f 100644
--- a/velox/dwio/dwrf/reader/DwrfReader.cpp
+++ b/velox/dwio/dwrf/reader/DwrfReader.cpp
@@ -19,6 +19,7 @@
 #include <chrono>
 
 #include "velox/dwio/common/OnDemandUnitLoader.h"
+#include "velox/dwio/common/ParallelUnitLoader.h"
 #include "velox/dwio/common/TypeUtils.h"
 #include "velox/dwio/common/exception/Exception.h"
 #include "velox/dwio/dwrf/reader/ColumnReader.h"
@@ -38,24 +39,26 @@ using dwio::common::UnitLoaderFactory;
 class DwrfUnit : public LoadUnit {
  public:
   DwrfUnit(
-      const StripeReaderBase& stripeReaderBase,
+      std::shared_ptr<ReaderBase> readerBase,
       const StrideIndexProvider& strideIndexProvider,
-      dwio::common::ColumnReaderStatistics& columnReaderStatistics,
+      std::shared_ptr<dwio::common::ColumnReaderStatistics>
+          columnReaderStatistics,
       uint32_t stripeIndex,
       std::shared_ptr<dwio::common::ColumnSelector> columnSelector,
-      const std::shared_ptr<BitSet>& projectedNodes,
+      std::shared_ptr<BitSet> projectedNodes,
       RowReaderOptions options,
-      const dwio::common::ColumnReaderOptions& columnReaderOptions)
-      : stripeReaderBase_{stripeReaderBase},
+      dwio::common::ColumnReaderOptions columnReaderOptions)
+      : stripeReaderBase_{readerBase},
+        memoryPool_(readerBase->memoryPool().shared_from_this()),
         strideIndexProvider_{strideIndexProvider},
-        columnReaderStatistics_{&columnReaderStatistics},
+        columnReaderStatistics_{std::move(columnReaderStatistics)},
         stripeIndex_{stripeIndex},
         columnSelector_{std::move(columnSelector)},
-        projectedNodes_{projectedNodes},
+        projectedNodes_{std::move(projectedNodes)},
         options_{std::move(options)},
-        columnReaderOptions_{columnReaderOptions},
+        columnReaderOptions_{std::move(columnReaderOptions)},
         stripeInfo_{
-            stripeReaderBase.getReader().footer().stripes(stripeIndex_)} {}
+            stripeReaderBase_.getReader().footer().stripes(stripeIndex_)} {}
 
   ~DwrfUnit() override = default;
 
@@ -85,14 +88,25 @@ class DwrfUnit : public LoadUnit {
   void loadDecoders();
 
   // Immutables
-  const StripeReaderBase& stripeReaderBase_;
+  const StripeReaderBase stripeReaderBase_;
+  // Not used in DwrfUnit directly, it is to keep memory pool alive for
+  // readerBase
+  const std::shared_ptr<memory::MemoryPool> memoryPool_;
+
+  // SAFETY: This reference is safe despite DwrfUnit potentially outliving
+  // DwrfRowReader during async operations. The reference is only STORED (not
+  // dereferenced) during load() path. Actual dereferencing via
+  // getStrideIndex() only happens during synchronous data reading in
+  // ColumnReader::next(), where DwrfRowReader is guaranteed to be alive.
   const StrideIndexProvider& strideIndexProvider_;
-  dwio::common::ColumnReaderStatistics* const columnReaderStatistics_;
+
+  const std::shared_ptr<dwio::common::ColumnReaderStatistics>
+      columnReaderStatistics_;
   const uint32_t stripeIndex_;
   const std::shared_ptr<dwio::common::ColumnSelector> columnSelector_;
   const std::shared_ptr<BitSet> projectedNodes_;
   const RowReaderOptions options_;
-  const dwio::common::ColumnReaderOptions& columnReaderOptions_;
+  const dwio::common::ColumnReaderOptions columnReaderOptions_;
   const StripeInformationWrapper stripeInfo_;
 
   // Mutables
@@ -242,6 +256,8 @@ DwrfRowReader::DwrfRowReader(
                     reader->schema()))},
       decodingTimeCallback_{options_.decodingTimeCallback()},
       strideIndex_{0},
+      columnReaderStatistics_{
+          std::make_shared<dwio::common::ColumnReaderStatistics>()},
       currentUnit_{nullptr} {
   const auto& fileFooter = getReader().footer();
   const uint32_t numberOfStripes = fileFooter.stripesSize();
@@ -328,22 +344,30 @@ 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_,
-        columnReaderOptions_));
+    loadUnits.emplace_back(
+        std::make_unique<DwrfUnit>(
+            /*readerBase=*/readerBaseShared(),
+            /*strideIndexProvider=*/*this,
+            columnReaderStatistics_,
+            stripe,
+            columnSelector_,
+            projectedNodes_,
+            options_,
+            columnReaderOptions_));
   }
   std::shared_ptr<UnitLoaderFactory> unitLoaderFactory =
       options_.unitLoaderFactory();
   if (!unitLoaderFactory) {
-    unitLoaderFactory =
-        std::make_shared<dwio::common::OnDemandUnitLoaderFactory>(
-            options_.blockedOnIoCallback());
+    if (loadUnits.size() > 1 && options_.parallelUnitLoadCount() > 1 &&
+        options_.ioExecutor() != nullptr) {
+      unitLoaderFactory =
+          std::make_shared<dwio::common::ParallelUnitLoaderFactory>(
+              options_.ioExecutor(), options_.parallelUnitLoadCount());
+    } else {
+      unitLoaderFactory =
+          std::make_shared<dwio::common::OnDemandUnitLoaderFactory>(
+              options_.blockedOnIoCallback());
+    }
   }
   return unitLoaderFactory->create(std::move(loadUnits), 0);
 }
@@ -632,6 +656,8 @@ uint64_t DwrfRowReader::next(
     } else {
       previousRow_ = 0;
     }
+    // Collect unit loader stats at the end.
+    unitLoadStats_ = unitLoader_->stats();
     return 0;
   }
 
@@ -752,8 +778,10 @@ std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
     case TypeKind::ARRAY:
     case TypeKind::MAP:
     case TypeKind::ROW: {
-      // start the estimate with the offsets and hasNulls vectors sizes
-      size_t totalEstimate = valueCount * (sizeof(uint8_t) + sizeof(uint64_t));
+      // Start the estimate with the offsets and sizes buffers.
+      size_t totalEstimate = nodeType.kind() == TypeKind::ROW
+          ? 0
+          : 2 * valueCount * sizeof(vector_size_t);
       for (int32_t i = 0; i < nodeType.subtypesSize(); ++i) {
         if (!shouldReadNode(nodeType.subtypes(i))) {
           continue;
@@ -774,15 +802,23 @@ std::optional<size_t> DwrfRowReader::estimatedRowSizeHelper(
 }
 
 std::optional<size_t> DwrfRowReader::estimatedRowSize() const {
+  if (hasRowEstimate_) {
+    return estimatedRowSize_;
+  }
+
   const auto& reader = getReader();
   const auto& fileFooter = reader.footer();
 
+  hasRowEstimate_ = true;
+
   if (!fileFooter.hasNumberOfRows()) {
-    return std::nullopt;
+    estimatedRowSize_ = std::nullopt;
+    return estimatedRowSize_;
   }
 
   if (fileFooter.numberOfRows() < 1) {
-    return 0;
+    estimatedRowSize_ = 0;
+    return estimatedRowSize_;
   }
 
   // Estimate with projections.
@@ -791,9 +827,12 @@ std::optional<size_t> DwrfRowReader::estimatedRowSize() const {
   const auto projectedSize =
       estimatedRowSizeHelper(fileFooter, *stats, ROOT_NODE_ID);
   if (projectedSize.has_value()) {
-    return projectedSize.value() / fileFooter.numberOfRows();
+    estimatedRowSize_ = projectedSize.value() / fileFooter.numberOfRows();
+    return estimatedRowSize_;
   }
-  return std::nullopt;
+
+  estimatedRowSize_ = std::nullopt;
+  return estimatedRowSize_;
 }
 
 DwrfReader::DwrfReader(
@@ -815,8 +854,9 @@ DwrfReader::DwrfReader(
 void DwrfReader::updateColumnNamesFromTableSchema() {
   const auto& tableSchema = readerBase_->readerOptions().fileSchema();
   const auto& fileSchema = readerBase_->schema();
-  readerBase_->setSchema(std::dynamic_pointer_cast<const RowType>(
-      updateColumnNames(fileSchema, tableSchema)));
+  readerBase_->setSchema(
+      std::dynamic_pointer_cast<const RowType>(
+          updateColumnNames(fileSchema, tableSchema)));
 }
 
 std::unique_ptr<StripeInformation> DwrfReader::getStripe(
diff --git a/velox/dwio/dwrf/reader/DwrfReader.h b/velox/dwio/dwrf/reader/DwrfReader.h
index dcb38dbb5a1d..e5bb7380f8c3 100644
--- a/velox/dwio/dwrf/reader/DwrfReader.h
+++ b/velox/dwio/dwrf/reader/DwrfReader.h
@@ -112,7 +112,8 @@ class DwrfRowReader : public StrideIndexProvider,
     stats.footerBufferOverread += getReader().footerBufferOverread();
     stats.numStripes += stripeCeiling_ - firstStripe_;
     stats.columnReaderStatistics.flattenStringDictionaryValues +=
-        columnReaderStatistics_.flattenStringDictionaryValues;
+        columnReaderStatistics_->flattenStringDictionaryValues;
+    stats.unitLoaderStats.merge(unitLoadStats_);
   }
 
   void resetFilterCaches() override;
@@ -210,17 +211,22 @@ class DwrfRowReader : public StrideIndexProvider,
   // Number of processed strides.
   int64_t processedStrides_{0};
 
+  dwio::common::UnitLoaderStats unitLoadStats_;
+
   // 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_;
+  std::shared_ptr<dwio::common::ColumnReaderStatistics> columnReaderStatistics_;
 
   std::optional<int64_t> nextRowNumber_;
 
   std::unique_ptr<dwio::common::UnitLoader> unitLoader_;
   DwrfUnit* currentUnit_;
+
+  mutable std::optional<size_t> estimatedRowSize_;
+  mutable bool hasRowEstimate_{false};
 };
 
 class DwrfReader : public dwio::common::Reader {
diff --git a/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp b/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
index 22f7220e8533..d1a611755bf4 100644
--- a/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/FlatMapColumnReader.cpp
@@ -163,12 +163,13 @@ std::vector<std::unique_ptr<KeyNode<T>>> getKeyNodesFiltered(
                 .inMapDecoder = inMapDecoder.get(),
                 .keySelectionCallback = nullptr});
 
-        keyNodes.push_back(std::make_unique<KeyNode<T>>(
-            std::move(valueReader),
-            std::move(inMapDecoder),
-            key,
-            sequence,
-            memoryPool));
+        keyNodes.push_back(
+            std::make_unique<KeyNode<T>>(
+                std::move(valueReader),
+                std::move(inMapDecoder),
+                key,
+                sequence,
+                memoryPool));
       });
 
   keySelectionStats.selectedKeys = keyNodes.size();
diff --git a/velox/dwio/dwrf/reader/ReaderBase.cpp b/velox/dwio/dwrf/reader/ReaderBase.cpp
index 71dbc2e41510..e227a219e3c9 100644
--- a/velox/dwio/dwrf/reader/ReaderBase.cpp
+++ b/velox/dwio/dwrf/reader/ReaderBase.cpp
@@ -19,11 +19,14 @@
 #include <fmt/format.h>
 
 #include "velox/common/process/TraceContext.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/Mutation.h"
 #include "velox/dwio/common/exception/Exception.h"
+#include "velox/functions/lib/string/StringImpl.h"
 
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
 using dwio::common::ColumnStatistics;
 using dwio::common::FileFormat;
 using dwio::common::LogType;
@@ -95,7 +98,7 @@ template <typename T>
 std::unique_ptr<FooterWrapper> parseFooter(
     dwio::common::SeekableInputStream* input,
     google::protobuf::Arena* arena) {
-  auto* impl = google::protobuf::Arena::CreateMessage<T>(arena);
+  auto* impl = ArenaCreate<T>(arena);
   VELOX_CHECK(impl->ParseFromZeroCopyStream(input));
   return std::make_unique<FooterWrapper>(impl);
 }
@@ -329,7 +332,7 @@ std::shared_ptr<const Type> ReaderBase::convertType(
     const FooterWrapper& footer,
     uint32_t index,
     bool fileColumnNamesReadAsLowerCase) {
-  VELOX_CHECK_LT(
+  VELOX_USER_CHECK_LT(
       index,
       folly::to<uint32_t>(footer.typesSize()),
       "Corrupted file, invalid types");
@@ -385,7 +388,7 @@ std::shared_ptr<const Type> ReaderBase::convertType(
             footer, type.subtypes(i), fileColumnNamesReadAsLowerCase);
         auto childName = type.fieldNames(i);
         if (fileColumnNamesReadAsLowerCase) {
-          folly::toLowerAscii(childName);
+          childName = functions::stringImpl::utf8StrToLowerCopy(childName);
         }
         names.push_back(std::move(childName));
         types.push_back(std::move(childType));
diff --git a/velox/dwio/dwrf/reader/ReaderBase.h b/velox/dwio/dwrf/reader/ReaderBase.h
index 561d88e56841..ba560165068d 100644
--- a/velox/dwio/dwrf/reader/ReaderBase.h
+++ b/velox/dwio/dwrf/reader/ReaderBase.h
@@ -199,7 +199,7 @@ class ReaderBase {
   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) {
+      if (entry.name() == kWriterNameKey) {
         return entry.value();
       }
     }
diff --git a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
index ec570ae05b7f..095a93ca7a9b 100644
--- a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.cpp
@@ -75,16 +75,17 @@ void SelectiveDecimalColumnReader<DataT>::seekToRowGroup(int64_t index) {
 
 template <typename DataT>
 template <bool kDense>
-void SelectiveDecimalColumnReader<DataT>::readHelper(RowSet rows) {
-  vector_size_t numRows = rows.back() + 1;
+void SelectiveDecimalColumnReader<DataT>::readHelper(
+    const common::Filter* filter,
+    RowSet rows) {
   ExtractToReader extractValues(this);
-  common::AlwaysTrue filter;
+  common::AlwaysTrue alwaysTrue;
   DirectRleColumnVisitor<
       int64_t,
       common::AlwaysTrue,
       decltype(extractValues),
       kDense>
-      visitor(filter, this, rows, extractValues);
+      visitor(alwaysTrue, this, rows, extractValues);
 
   // decode scale stream
   if (version_ == velox::dwrf::RleVersion_1) {
@@ -104,14 +105,135 @@ void SelectiveDecimalColumnReader<DataT>::readHelper(RowSet rows) {
   // reset numValues_ before reading values
   numValues_ = 0;
   valueSize_ = sizeof(DataT);
+  vector_size_t numRows = rows.back() + 1;
   ensureValuesCapacity<DataT>(numRows);
 
   // decode value stream
   facebook::velox::dwio::common::
       ColumnVisitor<DataT, common::AlwaysTrue, decltype(extractValues), kDense>
-          valueVisitor(filter, this, rows, extractValues);
+          valueVisitor(alwaysTrue, this, rows, extractValues);
   decodeWithVisitor<DirectDecoder<true>>(valueDecoder_.get(), valueVisitor);
   readOffset_ += numRows;
+
+  // Fill decimals before applying filter.
+  fillDecimals();
+
+  // 'nullsInReadRange_' is the nulls for the entire read range, and if the row
+  // set is not dense, result nulls should be allocated, which represents the
+  // nulls for the selected rows before filtering.
+  const auto rawNulls = nullsInReadRange_
+      ? (kDense ? nullsInReadRange_->as<uint64_t>() : rawResultNulls_)
+      : nullptr;
+  // Process filter.
+  process(filter, rows, rawNulls);
+}
+
+template <typename DataT>
+void SelectiveDecimalColumnReader<DataT>::processNulls(
+    bool isNull,
+    const RowSet& rows,
+    const uint64_t* rawNulls) {
+  if (!rawNulls) {
+    return;
+  }
+  returnReaderNulls_ = false;
+  anyNulls_ = !isNull;
+  allNull_ = isNull;
+
+  auto rawDecimal = values_->asMutable<DataT>();
+  auto rawScale = scaleBuffer_->asMutable<int64_t>();
+
+  vector_size_t idx = 0;
+  if (isNull) {
+    for (vector_size_t i = 0; i < numValues_; i++) {
+      if (bits::isBitNull(rawNulls, i)) {
+        bits::setNull(rawResultNulls_, idx);
+        addOutputRow(rows[i]);
+        idx++;
+      }
+    }
+  } else {
+    for (vector_size_t i = 0; i < numValues_; i++) {
+      if (!bits::isBitNull(rawNulls, i)) {
+        bits::setNull(rawResultNulls_, idx, false);
+        rawDecimal[idx] = rawDecimal[i];
+        rawScale[idx] = rawScale[i];
+        addOutputRow(rows[i]);
+        idx++;
+      }
+    }
+  }
+}
+
+template <typename DataT>
+void SelectiveDecimalColumnReader<DataT>::processFilter(
+    const common::Filter* filter,
+    const RowSet& rows,
+    const uint64_t* rawNulls) {
+  VELOX_CHECK_NOT_NULL(filter, "Filter must not be null.");
+  returnReaderNulls_ = false;
+  anyNulls_ = false;
+  allNull_ = true;
+
+  vector_size_t idx = 0;
+  auto rawDecimal = values_->asMutable<DataT>();
+  for (vector_size_t i = 0; i < numValues_; i++) {
+    if (rawNulls && bits::isBitNull(rawNulls, i)) {
+      if (filter->testNull()) {
+        bits::setNull(rawResultNulls_, idx);
+        addOutputRow(rows[i]);
+        anyNulls_ = true;
+        idx++;
+      }
+    } else {
+      bool tested;
+      if constexpr (std::is_same_v<DataT, int64_t>) {
+        tested = filter->testInt64(rawDecimal[i]);
+      } else {
+        tested = filter->testInt128(rawDecimal[i]);
+      }
+
+      if (tested) {
+        if (rawNulls) {
+          bits::setNull(rawResultNulls_, idx, false);
+        }
+        rawDecimal[idx] = rawDecimal[i];
+        addOutputRow(rows[i]);
+        allNull_ = false;
+        idx++;
+      }
+    }
+  }
+}
+
+template <typename DataT>
+void SelectiveDecimalColumnReader<DataT>::process(
+    const common::Filter* filter,
+    const RowSet& rows,
+    const uint64_t* rawNulls) {
+  if (!filter) {
+    // No filter and "hasDeletion" is false so input rows will be
+    // reused.
+    return;
+  }
+
+  switch (filter->kind()) {
+    case common::FilterKind::kIsNull:
+      processNulls(true, rows, rawNulls);
+      break;
+    case common::FilterKind::kIsNotNull: {
+      if (rawNulls) {
+        processNulls(false, rows, rawNulls);
+      } else {
+        for (vector_size_t i = 0; i < numValues_; i++) {
+          addOutputRow(rows[i]);
+        }
+      }
+      break;
+    }
+    default:
+      processFilter(filter, rows, rawNulls);
+  }
 }
 
 template <typename DataT>
@@ -119,14 +241,23 @@ void SelectiveDecimalColumnReader<DataT>::read(
     int64_t offset,
     const RowSet& rows,
     const uint64_t* incomingNulls) {
-  VELOX_CHECK(!scanSpec_->filter());
   VELOX_CHECK(!scanSpec_->valueHook());
   prepareRead<int64_t>(offset, rows, incomingNulls);
+  if (!scanSpec_->keepValues() && scanSpec_->filter() &&
+      (!resultNulls_ || !resultNulls_->unique() ||
+       resultNulls_->capacity() * 8 < rows.size())) {
+    // Make sure a dedicated resultNulls_ is allocated with enough capacity as
+    // RleDecoder always assumes it is available and 'prepareRead' skips
+    // allocation when the column is not projected.
+    resultNulls_ = AlignedBuffer::allocate<bool>(rows.size(), memoryPool_);
+    rawResultNulls_ = resultNulls_->asMutable<uint64_t>();
+  }
+  rawValues_ = values_->asMutable<char>();
   bool isDense = rows.back() == rows.size() - 1;
   if (isDense) {
-    readHelper<true>(rows);
+    readHelper<true>(scanSpec_->filter(), rows);
   } else {
-    readHelper<false>(rows);
+    readHelper<false>(scanSpec_->filter(), rows);
   }
 }
 
@@ -134,16 +265,17 @@ template <typename DataT>
 void SelectiveDecimalColumnReader<DataT>::getValues(
     const RowSet& rows,
     VectorPtr* result) {
+  getIntValues(rows, requestedType_, result);
+}
+
+template <typename DataT>
+void SelectiveDecimalColumnReader<DataT>::fillDecimals() {
   auto nullsPtr =
       resultNulls() ? resultNulls()->template as<uint64_t>() : nullptr;
   auto scales = scaleBuffer_->as<int64_t>();
   auto values = values_->asMutable<DataT>();
-
   DecimalUtil::fillDecimals<DataT>(
       values, nullsPtr, values, scales, numValues_, scale_);
-
-  rawValues_ = values_->asMutable<char>();
-  getIntValues(rows, requestedType_, result);
 }
 
 template class SelectiveDecimalColumnReader<int64_t>;
diff --git a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
index 67a82b051e36..338d8ac4756f 100644
--- a/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveDecimalColumnReader.h
@@ -49,7 +49,24 @@ class SelectiveDecimalColumnReader : public SelectiveColumnReader {
 
  private:
   template <bool kDense>
-  void readHelper(RowSet rows);
+  void readHelper(const common::Filter* filter, RowSet rows);
+
+  // Process IsNull and IsNotNull filters.
+  void processNulls(bool isNull, const RowSet& rows, const uint64_t* rawNulls);
+
+  // Process filters on decimal values.
+  void processFilter(
+      const common::Filter* filter,
+      const RowSet& rows,
+      const uint64_t* rawNulls);
+
+  // Dispatch to the respective filter processing based on the filter type.
+  void process(
+      const common::Filter* filter,
+      const RowSet& rows,
+      const uint64_t* rawNulls);
+
+  void fillDecimals();
 
   std::unique_ptr<IntDecoder<true>> valueDecoder_;
   std::unique_ptr<IntDecoder<true>> scaleDecoder_;
diff --git a/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp b/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
index 05c16970ad9a..da57c358ebd5 100644
--- a/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveDwrfReader.cpp
@@ -99,6 +99,10 @@ std::unique_ptr<SelectiveColumnReader> SelectiveDwrfReader::build(
         return createSelectiveFlatMapColumnReader(
             columnReaderOptions, requestedType, fileType, params, scanSpec);
       }
+      if (scanSpec.isFlatMapAsStruct()) {
+        return std::make_unique<SelectiveMapAsStructColumnReader>(
+            columnReaderOptions, requestedType, fileType, params, scanSpec);
+      }
       return std::make_unique<SelectiveMapColumnReader>(
           columnReaderOptions, requestedType, fileType, params, scanSpec);
     case TypeKind::REAL:
@@ -152,7 +156,7 @@ std::unique_ptr<SelectiveColumnReader> SelectiveDwrfReader::build(
     default:
       VELOX_FAIL(
           "buildReader unhandled type: " +
-          mapTypeKindToName(fileType->type()->kind()));
+          std::string(TypeKindName::toName(fileType->type()->kind())));
   }
 }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
index 3f7b30c0d6a9..670fe3bea89b 100644
--- a/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.cpp
@@ -17,11 +17,12 @@
 #include "velox/dwio/dwrf/reader/SelectiveFlatMapColumnReader.h"
 
 #include "velox/dwio/common/FlatMapHelper.h"
+#include "velox/dwio/common/SelectiveFlatMapColumnReader.h"
 #include "velox/dwio/dwrf/reader/SelectiveDwrfReader.h"
 #include "velox/dwio/dwrf/reader/SelectiveStructColumnReader.h"
+#include "velox/vector/FlatMapVector.h"
 
 namespace facebook::velox::dwrf {
-
 namespace {
 
 template <typename T>
@@ -39,7 +40,7 @@ inline dwio::common::flatmap::KeyValue<StringView> extractKey<StringView>(
 template <typename T>
 std::string toString(const T& x) {
   if constexpr (std::is_same_v<T, StringView>) {
-    return x;
+    return std::string(x);
   } else {
     return std::to_string(x);
   }
@@ -72,7 +73,7 @@ std::vector<KeyNode<T>> getKeyNodes(
     const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec,
-    bool asStruct) {
+    dwio::common::flatmap::FlatMapOutput outputType) {
   using namespace dwio::common::flatmap;
 
   std::vector<KeyNode<T>> keyNodes;
@@ -86,23 +87,43 @@ std::vector<KeyNode<T>> getKeyNodes(
   common::ScanSpec* valuesSpec = nullptr;
   std::unordered_map<KeyValue<T>, common::ScanSpec*, KeyValueHash<T>>
       childSpecs;
-  if (!asStruct) {
-    keysSpec = scanSpec.getOrCreateChild(common::ScanSpec::kMapKeysFieldName);
-    valuesSpec =
-        scanSpec.getOrCreateChild(common::ScanSpec::kMapValuesFieldName);
-    VELOX_CHECK(!valuesSpec->hasFilter());
-    keysSpec->setProjectOut(true);
-    valuesSpec->setProjectOut(true);
-  } else {
-    for (auto& c : scanSpec.children()) {
-      T key;
-      if constexpr (std::is_same_v<T, StringView>) {
-        key = StringView(c->fieldName());
-      } else {
-        key = folly::to<T>(c->fieldName());
+
+  // Adjust the scan spec according to the output type.
+  switch (outputType) {
+    // For a kMap output, just need a scan spec for map keys and one for map
+    // values.
+    case FlatMapOutput::kMap: {
+      keysSpec = scanSpec.getOrCreateChild(common::ScanSpec::kMapKeysFieldName);
+      valuesSpec =
+          scanSpec.getOrCreateChild(common::ScanSpec::kMapValuesFieldName);
+      VELOX_CHECK(!valuesSpec->hasFilter());
+      keysSpec->setProjectOut(true);
+      valuesSpec->setProjectOut(true);
+      break;
+    }
+    // For a kStruct output, the streams to be read are part of the scan spec
+    // already.
+    case FlatMapOutput::kStruct: {
+      for (auto& c : scanSpec.children()) {
+        T key;
+        if constexpr (std::is_same_v<T, StringView>) {
+          key = StringView(c->fieldName());
+        } else {
+          key = folly::to<T>(c->fieldName());
+        }
+        childSpecs[KeyValue<T>(key)] = c.get();
       }
-      childSpecs[KeyValue<T>(key)] = c.get();
+      break;
     }
+    case FlatMapOutput::kFlatMap:
+      // Remove on filters on keys stream since it doesn't exist (it's common to
+      // filter out nulls).
+      keysSpec = scanSpec.getOrCreateChild(common::ScanSpec::kMapKeysFieldName);
+      valuesSpec =
+          scanSpec.getOrCreateChild(common::ScanSpec::kMapValuesFieldName);
+      keysSpec->setFilter(nullptr);
+      VELOX_CHECK(!valuesSpec->hasFilter());
+      break;
   }
 
   // Load all sub streams.
@@ -119,10 +140,14 @@ std::vector<KeyNode<T>> getKeyNodes(
         const auto& keyInfo = stripe.getEncoding(seqEk).key();
         auto key = extractKey<T>(keyInfo);
         common::ScanSpec* childSpec;
-        if (auto it = childSpecs.find(key);
-            it != childSpecs.end() && !it->second->isConstant()) {
+        if (outputType == FlatMapOutput::kFlatMap) {
+          childSpec = scanSpec.getOrCreateChild(toString(key.get()));
+          childSpec->setProjectOut(true);
+          childSpec->setChannel(sequence - 1);
+        } else if (auto it = childSpecs.find(key);
+                   it != childSpecs.end() && !it->second->isConstant()) {
           childSpec = it->second;
-        } else if (asStruct) {
+        } else if (outputType == FlatMapOutput::kStruct) {
           // Column not selected in 'scanSpec', skipping it.
           return;
         } else {
@@ -159,7 +184,7 @@ std::vector<KeyNode<T>> getKeyNodes(
           << fileType->id() << ", keys=" << keyNodes.size()
           << ", streams=" << streams;
 
-  if (!asStruct) {
+  if (outputType != FlatMapOutput::kStruct) {
     std::sort(keyNodes.begin(), keyNodes.end(), [](auto& x, auto& y) {
       return x.sequence < y.sequence;
     });
@@ -181,13 +206,14 @@ class SelectiveFlatMapAsStructReader : public SelectiveStructColumnReaderBase {
             fileType,
             params,
             scanSpec),
-        keyNodes_(getKeyNodes<T>(
-            columnReaderOptions,
-            requestedType,
-            fileType,
-            params,
-            scanSpec,
-            true)) {
+        keyNodes_(
+            getKeyNodes<T>(
+                columnReaderOptions,
+                requestedType,
+                fileType,
+                params,
+                scanSpec,
+                dwio::common::flatmap::FlatMapOutput::kStruct)) {
     VELOX_CHECK(
         !keyNodes_.empty(),
         "For struct encoding, keys to project must be configured");
@@ -206,9 +232,9 @@ class SelectiveFlatMapAsStructReader : public SelectiveStructColumnReaderBase {
 };
 
 template <typename T>
-class SelectiveFlatMapReader : public SelectiveStructColumnReaderBase {
+class SelectiveFlatMapAsMapReader : public SelectiveStructColumnReaderBase {
  public:
-  SelectiveFlatMapReader(
+  SelectiveFlatMapAsMapReader(
       const dwio::common::ColumnReaderOptions& columnReaderOptions,
       const TypePtr& requestedType,
       const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
@@ -227,7 +253,12 @@ class SelectiveFlatMapReader : public SelectiveStructColumnReaderBase {
                 fileType,
                 params,
                 scanSpec,
-                false)) {}
+                dwio::common::flatmap::FlatMapOutput::kMap)) {}
+
+  void setIsTopLevel() override {
+    // Children are not considered top level since this is materialized as MAP.
+    SelectiveColumnReader::setIsTopLevel();
+  }
 
   void read(int64_t offset, const RowSet& rows, const uint64_t* incomingNulls)
       override {
@@ -243,6 +274,68 @@ class SelectiveFlatMapReader : public SelectiveStructColumnReaderBase {
       flatMap_;
 };
 
+template <typename T>
+class SelectiveFlatMapReader
+    : public dwio::common::SelectiveFlatMapColumnReader {
+ public:
+  SelectiveFlatMapReader(
+      const dwio::common::ColumnReaderOptions& columnReaderOptions,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      DwrfParams& params,
+      common::ScanSpec& scanSpec)
+      : dwio::common::SelectiveFlatMapColumnReader(
+            requestedType,
+            fileType,
+            params,
+            scanSpec),
+        keyNodes_(
+            getKeyNodes<T>(
+                columnReaderOptions,
+                requestedType,
+                fileType,
+                params,
+                scanSpec,
+                dwio::common::flatmap::FlatMapOutput::kFlatMap)),
+        rowsPerRowGroup_(formatData_->rowsPerRowGroup().value()) {
+    // Instantiate and populate distinct keys vector.
+    keysVector_ = BaseVector::create(
+        CppToType<T>::create(),
+        (vector_size_t)keyNodes_.size(),
+        &params.pool());
+    auto rawKeys = keysVector_->values()->asMutable<T>();
+    children_.resize(keyNodes_.size());
+
+    for (int i = 0; i < keyNodes_.size(); ++i) {
+      keyNodes_[i].reader->scanSpec()->setSubscript(i);
+      children_[i] = keyNodes_[i].reader.get();
+
+      rawKeys[i] = keyNodes_[i].key.get();
+    }
+  }
+
+  const BufferPtr& inMapBuffer(column_index_t childIndex) const override {
+    return children_[childIndex]
+        ->formatData()
+        .template as<DwrfData>()
+        .inMapBuffer();
+  }
+
+  void seekToRowGroup(int64_t index) override {
+    seekToRowGroupFixedRowsPerRowGroup(index, rowsPerRowGroup_);
+  }
+
+  void advanceFieldReader(
+      dwio::common::SelectiveColumnReader* reader,
+      int64_t offset) override {
+    advanceFieldReaderFixedRowsPerRowGroup(reader, offset, rowsPerRowGroup_);
+  }
+
+ private:
+  std::vector<KeyNode<T>> keyNodes_;
+  const int32_t rowsPerRowGroup_;
+};
+
 template <typename T>
 std::unique_ptr<dwio::common::SelectiveColumnReader> createReader(
     const dwio::common::ColumnReaderOptions& columnReaderOptions,
@@ -253,9 +346,14 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> createReader(
   if (scanSpec.isFlatMapAsStruct()) {
     return std::make_unique<SelectiveFlatMapAsStructReader<T>>(
         columnReaderOptions, requestedType, fileType, params, scanSpec);
-  } else {
+  } else if (params.stripeStreams()
+                 .rowReaderOptions()
+                 .preserveFlatMapsInMemory()) {
     return std::make_unique<SelectiveFlatMapReader<T>>(
         columnReaderOptions, requestedType, fileType, params, scanSpec);
+  } else {
+    return std::make_unique<SelectiveFlatMapAsMapReader<T>>(
+        columnReaderOptions, requestedType, fileType, params, scanSpec);
   }
 }
 
@@ -268,7 +366,8 @@ createSelectiveFlatMapColumnReader(
     const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
     DwrfParams& params,
     common::ScanSpec& scanSpec) {
-  auto kind = fileType->childAt(0)->type()->kind();
+  VELOX_DCHECK(requestedType->isMap());
+  auto kind = requestedType->childAt(0)->kind();
   switch (kind) {
     case TypeKind::TINYINT:
       return createReader<int8_t>(
diff --git a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
index 6cbfd654a4a2..e7ba8206754b 100644
--- a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.cpp
@@ -60,7 +60,6 @@ SelectiveListColumnReader::SelectiveListColumnReader(
           params,
           scanSpec),
       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
@@ -84,54 +83,88 @@ SelectiveListColumnReader::SelectiveListColumnReader(
   children_ = {child_.get()};
 }
 
-SelectiveMapColumnReader::SelectiveMapColumnReader(
-    const dwio::common::ColumnReaderOptions& columnReaderOptions,
-    const TypePtr& requestedType,
-    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+namespace {
+
+void makeMapChildrenReaders(
+    const dwio::common::TypeWithId& fileType,
+    const Type& requestedType,
     DwrfParams& params,
-    common::ScanSpec& scanSpec)
-    : dwio::common::SelectiveMapColumnReader(
-          requestedType,
-          fileType,
-          params,
-          scanSpec),
-      length_(makeLengthDecoder(*fileType_, params, *memoryPool_)) {
-  VELOX_CHECK_EQ(fileType_->id(), fileType->id(), "working on the same node");
+    const dwio::common::ColumnReaderOptions& columnReaderOptions,
+    const common::ScanSpec& scanSpec,
+    std::unique_ptr<dwio::common::SelectiveColumnReader>& keyReader,
+    std::unique_ptr<dwio::common::SelectiveColumnReader>& elementReader) {
   const EncodingKey encodingKey{
-      fileType_->id(), params.flatMapContext().sequence};
+      fileType.id(), params.flatMapContext().sequence};
   auto& stripe = params.stripeStreams();
-  if (scanSpec_->children().empty()) {
-    scanSpec_->getOrCreateChild(common::ScanSpec::kMapKeysFieldName);
-    scanSpec_->getOrCreateChild(common::ScanSpec::kMapValuesFieldName);
-  }
-  scanSpec_->children()[0]->setProjectOut(true);
-  scanSpec_->children()[1]->setProjectOut(true);
-
-  auto& keyType = requestedType_->childAt(0);
-  auto keyParams = DwrfParams(
+  DwrfParams keyParams(
       stripe,
       params.streamLabels(),
       params.runtimeStatistics(),
       flatMapContextFromEncodingKey(encodingKey));
-  keyReader_ = SelectiveDwrfReader::build(
+  keyReader = SelectiveDwrfReader::build(
       columnReaderOptions,
-      keyType,
-      fileType_->childAt(0),
+      requestedType.childAt(0),
+      fileType.childAt(0),
       keyParams,
-      *scanSpec_->children()[0].get());
-
-  auto& valueType = requestedType_->childAt(1);
-  auto elementParams = DwrfParams(
+      *scanSpec.children()[0]);
+  DwrfParams elementParams = DwrfParams(
       stripe,
       params.streamLabels(),
       params.runtimeStatistics(),
       flatMapContextFromEncodingKey(encodingKey));
-  elementReader_ = SelectiveDwrfReader::build(
+  elementReader = SelectiveDwrfReader::build(
       columnReaderOptions,
-      valueType,
-      fileType_->childAt(1),
+      requestedType.childAt(1),
+      fileType.childAt(1),
       elementParams,
-      *scanSpec_->children()[1]);
+      *scanSpec.children()[1]);
+}
+
+} // namespace
+
+SelectiveMapColumnReader::SelectiveMapColumnReader(
+    const dwio::common::ColumnReaderOptions& columnReaderOptions,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+    DwrfParams& params,
+    common::ScanSpec& scanSpec)
+    : dwio::common::SelectiveMapColumnReader(
+          requestedType,
+          fileType,
+          params,
+          scanSpec),
+      length_(makeLengthDecoder(*fileType_, params, *memoryPool_)) {
+  makeMapChildrenReaders(
+      *fileType_,
+      *requestedType_,
+      params,
+      columnReaderOptions,
+      *scanSpec_,
+      keyReader_,
+      elementReader_);
+  children_ = {keyReader_.get(), elementReader_.get()};
+}
+
+SelectiveMapAsStructColumnReader::SelectiveMapAsStructColumnReader(
+    const dwio::common::ColumnReaderOptions& columnReaderOptions,
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+    DwrfParams& params,
+    common::ScanSpec& scanSpec)
+    : dwio::common::SelectiveMapAsStructColumnReader(
+          requestedType,
+          fileType,
+          params,
+          scanSpec),
+      length_(makeLengthDecoder(*fileType_, params, *memoryPool_)) {
+  makeMapChildrenReaders(
+      *fileType_,
+      *requestedType_,
+      params,
+      columnReaderOptions,
+      mapScanSpec_,
+      keyReader_,
+      elementReader_);
   children_ = {keyReader_.get(), elementReader_.get()};
 }
 
diff --git a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
index ad6e8575bdd9..05e836244f0b 100644
--- a/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveRepeatedColumnReader.h
@@ -34,10 +34,6 @@ class SelectiveListColumnReader
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
-  void resetFilterCaches() override {
-    child_->resetFilterCaches();
-  }
-
   void seekToRowGroup(int64_t index) override {
     dwio::common::SelectiveListColumnReader::seekToRowGroup(index);
     auto positionsProvider = formatData_->seekToRowGroup(index);
@@ -68,24 +64,37 @@ class SelectiveMapColumnReader : public dwio::common::SelectiveMapColumnReader {
       DwrfParams& params,
       common::ScanSpec& scanSpec);
 
-  void resetFilterCaches() override {
-    keyReader_->resetFilterCaches();
-    elementReader_->resetFilterCaches();
-  }
-
   void seekToRowGroup(int64_t index) override {
     dwio::common::SelectiveMapColumnReader::seekToRowGroup(index);
     auto positionsProvider = formatData_->seekToRowGroup(index);
-
     length_->seekToRowGroup(positionsProvider);
-
     VELOX_CHECK(!positionsProvider.hasNext());
+  }
 
-    keyReader_->seekToRowGroup(index);
-    keyReader_->setReadOffsetRecursive(0);
-    elementReader_->seekToRowGroup(index);
-    elementReader_->setReadOffsetRecursive(0);
-    childTargetReadOffset_ = 0;
+  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_;
+};
+
+class SelectiveMapAsStructColumnReader
+    : public dwio::common::SelectiveMapAsStructColumnReader {
+ public:
+  SelectiveMapAsStructColumnReader(
+      const dwio::common::ColumnReaderOptions& columnReaderOptions,
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      DwrfParams& params,
+      common::ScanSpec& scanSpec);
+
+  void seekToRowGroup(int64_t index) override {
+    dwio::common::SelectiveMapAsStructColumnReader::seekToRowGroup(index);
+    auto positionsProvider = formatData_->seekToRowGroup(index);
+    length_->seekToRowGroup(positionsProvider);
+    VELOX_CHECK(!positionsProvider.hasNext());
   }
 
   void readLengths(int32_t* lengths, int32_t numLengths, const uint64_t* nulls)
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
index d88b8c24e404..d6914a47b94e 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStringDictionaryColumnReader.cpp
@@ -156,7 +156,7 @@ void SelectiveStringDictionaryColumnReader::loadStrideDictionary() {
   if (scanState_.dictionary2.numValues > 0) {
     // seek stride dictionary related streams
     std::vector<uint64_t> pos(
-        positions.begin() + positionOffset_, positions.end());
+        positions.cbegin() + positionOffset_, positions.cend());
     PositionProvider pp(pos);
     strideDictStream_->seekToPosition(pp);
     strideDictLengthDecoder_->seekToRowGroup(pp);
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
index 657470e92676..c4777ea43be5 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.cpp
@@ -362,20 +362,19 @@ void SelectiveStringDirectColumnReader::skipInDecode(
   lengthIndex_ += numValues;
 }
 
-folly::StringPiece SelectiveStringDirectColumnReader::readValue(
-    int32_t length) {
+std::string_view SelectiveStringDirectColumnReader::readValue(int32_t length) {
   skipBytes(bytesToSkip_, blobStream_.get(), bufferStart_, bufferEnd_);
   bytesToSkip_ = 0;
   // bufferStart_ may be null if length is 0 and this is the first string
   // we're reading.
   if (bufferEnd_ - bufferStart_ >= length) {
     bytesToSkip_ = length;
-    return folly::StringPiece(bufferStart_, length);
+    return std::string_view(bufferStart_, length);
   }
   tempString_.resize(length);
   readBytes(
       length, blobStream_.get(), tempString_.data(), bufferStart_, bufferEnd_);
-  return folly::StringPiece(tempString_);
+  return std::string_view(tempString_);
 }
 
 template <bool kHasNulls, typename Visitor>
@@ -474,7 +473,7 @@ void SelectiveStringDirectColumnReader::read(
     int64_t offset,
     const RowSet& rows,
     const uint64_t* incomingNulls) {
-  prepareRead<folly::StringPiece>(offset, rows, incomingNulls);
+  prepareRead<std::string_view>(offset, rows, incomingNulls);
   auto numRows = rows.back() + 1;
   auto numNulls = nullsInReadRange_
       ? BaseVector::countNulls(nullsInReadRange_, 0, numRows)
diff --git a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
index 8da1e77401d2..e0a2369ceb57 100644
--- a/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveStringDirectColumnReader.h
@@ -58,7 +58,7 @@ class SelectiveStringDirectColumnReader
   template <bool hasNulls>
   void skipInDecode(int32_t numValues, int32_t current, const uint64_t* nulls);
 
-  folly::StringPiece readValue(int32_t length);
+  std::string_view readValue(int32_t length);
 
   template <bool hasNulls, typename Visitor>
   void decode(const uint64_t* nulls, Visitor visitor);
diff --git a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
index b1f47289505e..364270e53911 100644
--- a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.cpp
@@ -86,12 +86,13 @@ SelectiveStructColumnReader::SelectiveStructColumnReader(
             .sequence = encodingKey.sequence(),
             .inMapDecoder = nullptr,
             .keySelectionCallback = nullptr});
-    addChild(SelectiveDwrfReader::build(
-        columnReaderOptions,
-        childRequestedType,
-        childFileType,
-        childParams,
-        *childSpec));
+    addChild(
+        SelectiveDwrfReader::build(
+            columnReaderOptions,
+            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 a334f5b7ca9e..6e323b67fe39 100644
--- a/velox/dwio/dwrf/reader/SelectiveStructColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveStructColumnReader.h
@@ -29,13 +29,15 @@ class SelectiveStructColumnReaderBase
       const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
       DwrfParams& params,
       common::ScanSpec& scanSpec,
-      bool isRoot = false)
+      bool isRoot = false,
+      bool generateLazyChildren = true)
       : dwio::common::SelectiveStructColumnReaderBase(
             requestedType,
             fileType,
             params,
             scanSpec,
-            isRoot),
+            isRoot,
+            generateLazyChildren),
         rowsPerRowGroup_(formatData_->rowsPerRowGroup().value()) {
     VELOX_CHECK_EQ(fileType_->id(), fileType->id(), "working on the same node");
   }
@@ -43,35 +45,14 @@ class SelectiveStructColumnReaderBase
   void seekTo(int64_t offset, bool readsNullsOnly) override;
 
   void seekToRowGroup(int64_t index) override {
-    dwio::common::SelectiveStructColumnReaderBase::seekToRowGroup(index);
-    if (isTopLevel_ && !formatData_->hasNulls()) {
-      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.
-    setReadOffsetRecursive(index * rowsPerRowGroup_);
-    for (auto& child : children_) {
-      child->seekToRowGroup(index);
-    }
+    seekToRowGroupFixedRowsPerRowGroup(index, rowsPerRowGroup_);
   }
 
   /// Advance field reader to the row group closest to specified offset by
   /// calling seekToRowGroup.
   void advanceFieldReader(SelectiveColumnReader* reader, int64_t offset)
       override {
-    if (!reader->isTopLevel()) {
-      return;
-    }
-    const auto rowGroup = reader->readOffset() / rowsPerRowGroup_;
-    const auto nextRowGroup = offset / rowsPerRowGroup_;
-    if (nextRowGroup > rowGroup) {
-      reader->seekToRowGroup(nextRowGroup);
-      reader->setReadOffset(nextRowGroup * rowsPerRowGroup_);
-    }
+    advanceFieldReaderFixedRowsPerRowGroup(reader, offset, rowsPerRowGroup_);
   }
 
  private:
diff --git a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
index 99f790851e97..10f9be96a57b 100644
--- a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
+++ b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.cpp
@@ -100,7 +100,7 @@ void SelectiveTimestampColumnReader::read(
 
 template <bool isDense>
 void SelectiveTimestampColumnReader::readHelper(
-    common::Filter* filter,
+    const common::Filter* filter,
     const RowSet& rows) {
   ExtractToReader extractValues(this);
   common::AlwaysTrue alwaysTrue;
diff --git a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.h b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.h
index 44ba1feb113d..b9817b71f3aa 100644
--- a/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.h
+++ b/velox/dwio/dwrf/reader/SelectiveTimestampColumnReader.h
@@ -42,7 +42,7 @@ class SelectiveTimestampColumnReader
 
  private:
   template <bool isDense>
-  void readHelper(common::Filter* filter, const RowSet& rows);
+  void readHelper(const common::Filter* filter, const RowSet& rows);
 
   void
   processNulls(const bool isNull, const RowSet& rows, const uint64_t* rawNulls);
diff --git a/velox/dwio/dwrf/reader/StripeMetadataCache.h b/velox/dwio/dwrf/reader/StripeMetadataCache.h
index 4a7a1125610d..9cd5507932dd 100644
--- a/velox/dwio/dwrf/reader/StripeMetadataCache.h
+++ b/velox/dwio/dwrf/reader/StripeMetadataCache.h
@@ -95,7 +95,7 @@ class StripeMetadataCache {
     std::vector<uint32_t> offsets;
     offsets.reserve(footer.stripeCacheOffsetsSize());
     const auto& from = footer.stripeCacheOffsets();
-    offsets.assign(from.begin(), from.end());
+    offsets.assign(from.cbegin(), from.cend());
     return offsets;
   }
 
diff --git a/velox/dwio/dwrf/reader/StripeReaderBase.cpp b/velox/dwio/dwrf/reader/StripeReaderBase.cpp
index 44ba6aa81e8b..9bc5549d9237 100644
--- a/velox/dwio/dwrf/reader/StripeReaderBase.cpp
+++ b/velox/dwio/dwrf/reader/StripeReaderBase.cpp
@@ -16,8 +16,11 @@
 
 #include "velox/dwio/dwrf/reader/StripeReaderBase.h"
 
+#include "velox/dwio/common/Arena.h"
+
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
 using dwio::common::LogType;
 
 // preload is not considered or mutated if stripe has already been fetched. e.g.
@@ -95,9 +98,7 @@ std::unique_ptr<const StripeMetadata> StripeReaderBase::fetchStripe(
   };
 
   if (fileFooter.format() == DwrfFormat::kDwrf) {
-    auto* rawFooter =
-        google::protobuf::Arena::CreateMessage<proto::StripeFooter>(
-            arena.get());
+    auto* rawFooter = ArenaCreate<proto::StripeFooter>(arena.get());
     ProtoUtils::readProtoInto(
         reader_->createDecompressedStream(
             std::move(footerStream), streamDebugInfo),
@@ -110,9 +111,7 @@ std::unique_ptr<const StripeMetadata> StripeReaderBase::fetchStripe(
 
     return createStripeMetadata(std::move(stripeFooter));
   } else {
-    auto* rawFooter =
-        google::protobuf::Arena::CreateMessage<proto::orc::StripeFooter>(
-            arena.get());
+    auto* rawFooter = ArenaCreate<proto::orc::StripeFooter>(arena.get());
     ProtoUtils::readProtoInto(
         reader_->createDecompressedStream(
             std::move(footerStream), streamDebugInfo),
diff --git a/velox/dwio/dwrf/test/CMakeLists.txt b/velox/dwio/dwrf/test/CMakeLists.txt
index e8da27a642e0..cbd29a9ac2f8 100644
--- a/velox/dwio/dwrf/test/CMakeLists.txt
+++ b/velox/dwio/dwrf/test/CMakeLists.txt
@@ -14,42 +14,47 @@
 
 add_subdirectory(utils)
 
-set(TEST_LINK_LIBS
-    velox_dwio_common_test_utils
-    velox_dwio_dwrf_reader
-    velox_dwio_dwrf_writer
-    velox_row_fast
-    GTest::gtest
-    GTest::gtest_main
-    GTest::gmock
-    glog::glog)
+set(
+  TEST_LINK_LIBS
+  velox_dwio_common_test_utils
+  velox_dwio_dwrf_reader
+  velox_dwio_dwrf_writer
+  velox_row_fast
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
+  glog::glog
+)
 
-add_executable(velox_dwio_dwrf_buffered_output_stream_test
-               TestBufferedOutputStream.cpp)
-add_test(velox_dwio_dwrf_buffered_output_stream_test
-         velox_dwio_dwrf_buffered_output_stream_test)
+add_executable(velox_dwio_dwrf_buffered_output_stream_test TestBufferedOutputStream.cpp)
+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})
+  velox_dwio_dwrf_buffered_output_stream_test
+  velox_link_libs
+  Folly::folly
+  ${TEST_LINK_LIBS}
+)
 
-add_executable(velox_dwio_dwrf_column_statistics_test
-               TestDwrfColumnStatistics.cpp)
-add_test(velox_dwio_dwrf_column_statistics_test
-         velox_dwio_dwrf_column_statistics_test)
+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})
+  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_orc_column_statistics_test TestOrcColumnStatistics.cpp)
+add_test(velox_dwio_orc_column_statistics_test velox_dwio_orc_column_statistics_test)
 
 target_link_libraries(
-  velox_dwio_orc_column_statistics_test velox_link_libs Folly::folly
-  ${TEST_LINK_LIBS})
+  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)
@@ -60,26 +65,27 @@ target_link_libraries(
   Folly::folly
   glog::glog
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwio_dwrf_decompression_test TestDecompression.cpp)
 add_test(
   NAME velox_dwio_dwrf_decompression_test
   COMMAND velox_dwio_dwrf_decompression_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_dwio_dwrf_decompression_test
   velox_link_libs
   Folly::folly
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwio_dwrf_stripe_stream_test TestStripeStream.cpp)
 add_test(velox_dwio_dwrf_stripe_stream_test velox_dwio_dwrf_stripe_stream_test)
@@ -90,10 +96,10 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwio_dwrf_stream_labels_test StreamLabelsTests.cpp)
 add_test(velox_dwio_dwrf_stream_labels_test velox_dwio_dwrf_stream_labels_test)
@@ -104,15 +110,13 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
-add_executable(velox_dwio_dwrf_stripe_dictionary_cache_test
-               TestStripeDictionaryCache.cpp)
-add_test(velox_dwio_dwrf_stripe_dictionary_cache_test
-         velox_dwio_dwrf_stripe_dictionary_cache_test)
+add_executable(velox_dwio_dwrf_stripe_dictionary_cache_test TestStripeDictionaryCache.cpp)
+add_test(velox_dwio_dwrf_stripe_dictionary_cache_test velox_dwio_dwrf_stripe_dictionary_cache_test)
 
 target_link_libraries(
   velox_dwio_dwrf_stripe_dictionary_cache_test
@@ -120,46 +124,58 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
-add_executable(velox_dwio_dwrf_dictionary_encoder_test
-               TestIntegerDictionaryEncoder.cpp TestStringDictionaryEncoder.cpp)
-add_test(velox_dwio_dwrf_dictionary_encoder_test
-         velox_dwio_dwrf_dictionary_encoder_test)
+add_executable(
+  velox_dwio_dwrf_dictionary_encoder_test
+  TestIntegerDictionaryEncoder.cpp
+  TestStringDictionaryEncoder.cpp
+)
+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
   gflags::gflags
-  ${TEST_LINK_LIBS})
+  ${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)
+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})
+  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})
+  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)
+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})
+  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)
@@ -169,7 +185,8 @@ target_link_libraries(
   velox_link_libs
   Folly::folly
   Boost::headers
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwio_dwrf_writer_test WriterTest.cpp)
 add_test(velox_dwio_dwrf_writer_test velox_dwio_dwrf_writer_test)
@@ -179,110 +196,112 @@ target_link_libraries(
   velox_link_libs
   Folly::folly
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwio_dwrf_writer_context_test WriterContextTest.cpp)
-add_test(velox_dwio_dwrf_writer_context_test
-         velox_dwio_dwrf_writer_context_test)
+add_test(velox_dwio_dwrf_writer_context_test velox_dwio_dwrf_writer_context_test)
 
 target_link_libraries(
   velox_dwio_dwrf_writer_context_test
   velox_link_libs
   Folly::folly
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
-add_executable(velox_dwio_dwrf_writer_encoding_manager_test
-               EncodingManagerTests.cpp)
-add_test(velox_dwio_dwrf_writer_encoding_manager_test
-         velox_dwio_dwrf_writer_encoding_manager_test)
+add_executable(velox_dwio_dwrf_writer_encoding_manager_test EncodingManagerTests.cpp)
+add_test(velox_dwio_dwrf_writer_encoding_manager_test velox_dwio_dwrf_writer_encoding_manager_test)
 
 target_link_libraries(
   velox_dwio_dwrf_writer_encoding_manager_test
   velox_link_libs
   Folly::folly
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 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})
+  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)
+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})
+  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
-         velox_dwio_dwrf_layout_planner_test)
+add_test(velox_dwio_dwrf_layout_planner_test velox_dwio_dwrf_layout_planner_test)
 
 target_link_libraries(
   velox_dwio_dwrf_layout_planner_test
   velox_link_libs
   Folly::folly
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 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})
+  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})
+  velox_dwio_dwrf_encryption_test
+  velox_link_libs
+  Folly::folly
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_filemetadata_test FileMetadataTest.cpp)
 add_test(velox_filemetadata_test velox_filemetadata_test)
 
-target_link_libraries(
-  velox_filemetadata_test velox_link_libs ${TEST_LINK_LIBS})
+target_link_libraries(velox_filemetadata_test velox_link_libs ${TEST_LINK_LIBS})
 
 add_executable(velox_common_test CommonTests.cpp)
 add_test(velox_common_test velox_common_test)
 
-target_link_libraries(
-  velox_common_test velox_link_libs ${TEST_LINK_LIBS})
+target_link_libraries(velox_common_test velox_link_libs ${TEST_LINK_LIBS})
 
-add_executable(velox_dwio_dwrf_stripe_reader_base_test
-               StripeReaderBaseTests.cpp)
-add_test(velox_dwio_dwrf_stripe_reader_base_test
-         velox_dwio_dwrf_stripe_reader_base_test)
+add_executable(velox_dwio_dwrf_stripe_reader_base_test StripeReaderBaseTests.cpp)
+add_test(velox_dwio_dwrf_stripe_reader_base_test velox_dwio_dwrf_stripe_reader_base_test)
 
 target_link_libraries(
   velox_dwio_dwrf_stripe_reader_base_test
   velox_link_libs
   Folly::folly
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwio_dwrf_reader_base_test ReaderBaseTests.cpp)
 add_test(velox_dwio_dwrf_reader_base_test velox_dwio_dwrf_reader_base_test)
@@ -293,10 +312,10 @@ target_link_libraries(
   Folly::folly
   glog::glog
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwio_dwrf_config_test ConfigTests.cpp)
 add_test(velox_dwio_dwrf_config_test velox_dwio_dwrf_config_test)
@@ -306,21 +325,28 @@ target_link_libraries(
   velox_link_libs
   velox_row_fast
   Folly::folly
-  ${TEST_LINK_LIBS})
+  ${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})
+  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})
+  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)
@@ -330,31 +356,34 @@ target_link_libraries(
   velox_link_libs
   fmt::fmt
   Folly::folly
-  ${TEST_LINK_LIBS})
+  ${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)
+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})
+  ${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})
+  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)
@@ -364,14 +393,18 @@ target_link_libraries(
   velox_link_libs
   fmt::fmt
   Folly::folly
-  ${TEST_LINK_LIBS})
+  ${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})
+  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)
@@ -381,13 +414,15 @@ target_link_libraries(
   velox_link_libs
   Folly::folly
   fmt::fmt
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwio_dwrf_reader_test ReaderTest.cpp)
 add_test(
   NAME velox_dwio_dwrf_reader_test
   COMMAND velox_dwio_dwrf_reader_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_dwio_dwrf_reader_test
@@ -397,10 +432,10 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwrf_e2e_filter_test E2EFilterTest.cpp)
 add_test(velox_dwrf_e2e_filter_test velox_dwrf_e2e_filter_test)
@@ -413,19 +448,20 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
-add_executable(velox_dwrf_statistics_builder_utils_test
-               TestStatisticsBuilderUtils.cpp)
-add_test(velox_dwrf_statistics_builder_utils_test
-         velox_dwrf_statistics_builder_utils_test)
+add_executable(velox_dwrf_statistics_builder_utils_test TestStatisticsBuilderUtils.cpp)
+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})
+  velox_dwrf_statistics_builder_utils_test
+  velox_link_libs
+  Folly::folly
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwrf_column_writer_test ColumnWriterTest.cpp)
 add_test(velox_dwrf_column_writer_test velox_dwrf_column_writer_test)
@@ -438,14 +474,13 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwrf_column_writer_index_test ColumnWriterIndexTest.cpp)
-add_test(velox_dwrf_column_writer_index_test
-         velox_dwrf_column_writer_index_test)
+add_test(velox_dwrf_column_writer_index_test velox_dwrf_column_writer_index_test)
 
 target_link_libraries(
   velox_dwrf_column_writer_index_test
@@ -454,10 +489,10 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwrf_writer_flush_test WriterFlushTest.cpp)
 add_test(velox_dwrf_writer_flush_test velox_dwrf_writer_flush_test)
@@ -469,10 +504,10 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwrf_e2e_writer_test E2EWriterTest.cpp)
 add_test(velox_dwrf_e2e_writer_test velox_dwrf_e2e_writer_test)
@@ -486,10 +521,10 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwrf_e2e_reader_test E2EReaderTest.cpp)
 add_test(velox_dwrf_e2e_reader_test velox_dwrf_e2e_reader_test)
@@ -503,10 +538,10 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwrf_writer_extended_test WriterExtendedTests.cpp)
 
@@ -517,14 +552,13 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_dwrf_column_writer_stats_test ColumnWriterStatsTests.cpp)
-add_test(velox_dwrf_column_writer_stats_test
-         velox_dwrf_column_writer_stats_test)
+add_test(velox_dwrf_column_writer_stats_test velox_dwrf_column_writer_stats_test)
 
 target_link_libraries(
   velox_dwrf_column_writer_stats_test
@@ -533,10 +567,10 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(physical_size_aggregator_test PhysicalSizeAggregatorTest.cpp)
 add_test(physical_size_aggregator_test physical_size_aggregator_test)
@@ -548,10 +582,10 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 if(VELOX_ENABLE_BENCHMARKS)
   add_executable(velox_dwrf_int_encoder_benchmark IntEncoderBenchmark.cpp)
@@ -561,10 +595,10 @@ if(VELOX_ENABLE_BENCHMARKS)
     velox_memory
     velox_dwio_common_exception
     Folly::folly
-    Folly::follybenchmark)
+    Folly::follybenchmark
+  )
 
-  add_executable(velox_dwrf_float_column_writer_benchmark
-                 FloatColumnWriterBenchmark.cpp)
+  add_executable(velox_dwrf_float_column_writer_benchmark FloatColumnWriterBenchmark.cpp)
   target_link_libraries(
     velox_dwrf_float_column_writer_benchmark
     velox_vector
@@ -572,11 +606,11 @@ if(VELOX_ENABLE_BENCHMARKS)
     velox_dwio_dwrf_writer
     Folly::folly
     Folly::follybenchmark
-    fmt::fmt)
+    fmt::fmt
+  )
 endif()
 
-add_executable(velox_dwio_cache_test CacheInputTest.cpp
-                                     DirectBufferedInputTest.cpp)
+add_executable(velox_dwio_cache_test CacheInputTest.cpp DirectBufferedInputTest.cpp)
 
 add_test(velox_dwio_cache_test velox_dwio_cache_test)
 
@@ -588,7 +622,7 @@ target_link_libraries(
   Folly::folly
   fmt::fmt
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
diff --git a/velox/dwio/dwrf/test/CacheInputTest.cpp b/velox/dwio/dwrf/test/CacheInputTest.cpp
index 39ac5ff92aa1..c43d6dc1f884 100644
--- a/velox/dwio/dwrf/test/CacheInputTest.cpp
+++ b/velox/dwio/dwrf/test/CacheInputTest.cpp
@@ -121,8 +121,9 @@ class CacheTest : public ::testing::Test {
         std::make_unique<test::AsyncDataCacheTestHelper>(cache_.get());
     cache_->setVerifyHook(checkEntry);
     for (auto i = 0; i < kMaxStreams; ++i) {
-      streamIds_.push_back(std::make_unique<dwrf::DwrfStreamIdentifier>(
-          i, i, 0, dwrf::StreamKind_DATA));
+      streamIds_.push_back(
+          std::make_unique<dwrf::DwrfStreamIdentifier>(
+              i, i, 0, dwrf::StreamKind_DATA));
     }
     streamStarts_.resize(kMaxStreams + 1);
     streamStarts_[0] = 0;
@@ -187,25 +188,23 @@ class CacheTest : public ::testing::Test {
     return lease.id();
   }
 
-  std::shared_ptr<TestReadFile>
-  inputByPath(const std::string& path, uint64_t& fileId, uint64_t& groupId) {
+  std::shared_ptr<TestReadFile> inputByPath(
+      const std::string& path,
+      StringIdLease& fileId,
+      StringIdLease& groupId) {
     std::lock_guard<std::mutex> l(mutex_);
-    StringIdLease fileLease(fileIds(), path);
-    fileId = fileLease.id();
-    StringIdLease groupLease(fileIds(), fmt::format("group{}", fileId / 2));
-    groupId = groupLease.id();
-    auto it = pathToInput_.find(fileId);
+    fileId = StringIdLease{fileIds(), path};
+    groupId = StringIdLease{fileIds(), fmt::format("group{}", fileId.id() / 2)};
+    auto it = pathToInput_.find(fileId.id());
     if (it != pathToInput_.end()) {
       return it->second;
     }
-    fileIds_.push_back(fileLease);
-    fileIds_.push_back(groupLease);
+    fileIds_.push_back(fileId);
+    fileIds_.push_back(groupId);
     // Creates an extremely large read file for test.
     auto stream = std::make_shared<TestReadFile>(
-        fileLease.id(),
-        1UL << 63,
-        std::make_shared<filesystems::File::IoStats>());
-    pathToInput_[fileLease.id()] = stream;
+        fileId.id(), 1UL << 63, std::make_shared<filesystems::File::IoStats>());
+    pathToInput_[fileId.id()] = stream;
     return stream;
   }
 
@@ -215,8 +214,8 @@ class CacheTest : public ::testing::Test {
       std::shared_ptr<TestReadFile> readFile,
       int32_t numColumns,
       std::shared_ptr<ScanTracker> tracker,
-      uint64_t fileId,
-      uint64_t groupId,
+      const StringIdLease& fileId,
+      const StringIdLease& groupId,
       int64_t offset,
       bool noCacheRetention,
       const IoStatisticsPtr& ioStats,
@@ -356,11 +355,11 @@ class CacheTest : public ::testing::Test {
         io::ReaderOptions::kDefaultLoadQuantum,
         groupStats_);
     std::vector<std::unique_ptr<StripeData>> stripes;
-    uint64_t fileId;
-    uint64_t groupId;
+    StringIdLease fileId;
+    StringIdLease groupId;
     auto readFile = inputByPath(filename, fileId, groupId);
     if (groupStats_) {
-      groupStats_->recordFile(fileId, groupId, numStripes);
+      groupStats_->recordFile(fileId.id(), groupId.id(), numStripes);
     }
     for (auto stripeIndex = 0; stripeIndex < numStripes; ++stripeIndex) {
       const auto firstPrefetchStripe = stripeIndex + stripes.size();
@@ -473,8 +472,8 @@ TEST_F(CacheTest, window) {
       nullptr,
       io::ReaderOptions::kDefaultLoadQuantum,
       groupStats_);
-  uint64_t fileId;
-  uint64_t groupId;
+  StringIdLease fileId;
+  StringIdLease groupId;
   auto file = inputByPath("test_for_window", fileId, groupId);
   auto input = std::make_unique<CachedBufferedInput>(
       file,
@@ -685,21 +684,22 @@ TEST_F(CacheTest, ssdThreads) {
   for (int i = 0; i < kNumThreads; ++i) {
     stats.push_back(std::make_shared<io::IoStatistics>());
     fsStats.push_back(std::make_shared<filesystems::File::IoStats>());
-    threads.push_back(std::thread(
-        [i, this, threadStats = stats.back(), fsStat = fsStats.back()]() {
-          for (auto counter = 0; counter < 4; ++counter) {
-            readLoop(
-                fmt::format("testfile{}", i / 2),
-                10,
-                70,
-                10,
-                20,
-                2,
-                /*noCacheRetention=*/false,
-                threadStats,
-                fsStat);
-          }
-        }));
+    threads.push_back(
+        std::thread(
+            [i, this, threadStats = stats.back(), fsStat = fsStats.back()]() {
+              for (auto counter = 0; counter < 4; ++counter) {
+                readLoop(
+                    fmt::format("testfile{}", i / 2),
+                    10,
+                    70,
+                    10,
+                    20,
+                    2,
+                    /*noCacheRetention=*/false,
+                    threadStats,
+                    fsStat);
+              }
+            }));
   }
   for (int i = 0; i < kNumThreads; ++i) {
     threads[i].join();
@@ -737,18 +737,19 @@ class FileWithReadAhead {
     bufferedInput_ = std::make_unique<CachedBufferedInput>(
         file_,
         MetricsLog::voidLog(),
-        fileId_->id(),
+        *fileId_,
         cache,
         nullptr,
-        0,
+        StringIdLease{},
         stats,
         fsStats,
         executor,
         options_);
     auto sequential = StreamIdentifier::sequentialFile();
     stream_ = bufferedInput_->enqueue(Region{0, file_->size()}, &sequential);
-    VELOX_CHECK(reinterpret_cast<CacheInputStream*>(stream_.get())
-                    ->testingNoCacheRetention());
+    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);
@@ -790,58 +791,67 @@ TEST_F(CacheTest, readAhead) {
   for (int threadIndex = 0; threadIndex < kNumThreads; ++threadIndex) {
     stats.push_back(std::make_shared<io::IoStatistics>());
     fsStats.push_back(std::make_shared<filesystems::File::IoStats>());
-    threads.push_back(std::thread([threadIndex,
-                                   this,
-                                   threadStats = stats.back(),
-                                   fsStat = fsStats.back()]() {
-      std::vector<std::unique_ptr<FileWithReadAhead>> files;
-      auto firstFileNumber = threadIndex * kFilesPerThread;
-      for (auto i = 0; i < kFilesPerThread; ++i) {
-        auto name = fmt::format("prefetch_{}", i + firstFileNumber);
-        files.push_back(std::make_unique<FileWithReadAhead>(
-            name, cache_.get(), threadStats, fsStat, *pool_, executor_.get()));
-      }
-      std::vector<int64_t> totalRead(kFilesPerThread);
-      std::vector<int64_t> bytesLeft(kFilesPerThread);
-      for (auto counter = 0; counter < 100; ++counter) {
-        for (auto i = 0; i < kFilesPerThread; ++i) {
-          if (!files[i]) {
-            continue; // This set of files is finished.
+    threads.push_back(
+        std::thread([threadIndex,
+                     this,
+                     threadStats = stats.back(),
+                     fsStat = fsStats.back()]() {
+          std::vector<std::unique_ptr<FileWithReadAhead>> files;
+          auto firstFileNumber = threadIndex * kFilesPerThread;
+          for (auto i = 0; i < kFilesPerThread; ++i) {
+            auto name = fmt::format("prefetch_{}", i + firstFileNumber);
+            files.push_back(
+                std::make_unique<FileWithReadAhead>(
+                    name,
+                    cache_.get(),
+                    threadStats,
+                    fsStat,
+                    *pool_,
+                    executor_.get()));
           }
-          // Read from the next file. Different files advance at slightly
-          // different rates.
-          auto bytesNeeded = kMinRead + i * 1000;
-          while (bytesLeft[i] < bytesNeeded) {
-            const void* buffer;
-            int32_t size;
-            if (!files[i]->next(buffer, size)) {
-              // End of file. Check that a multiple of file size has been read.
-              EXPECT_EQ(0, totalRead[i] % FileWithReadAhead::kFileSize);
-              if (totalRead[i] >= 3 * FileWithReadAhead::kFileSize) {
-                files[i] = nullptr;
-                break;
+          std::vector<int64_t> totalRead(kFilesPerThread);
+          std::vector<int64_t> bytesLeft(kFilesPerThread);
+          for (auto counter = 0; counter < 100; ++counter) {
+            for (auto i = 0; i < kFilesPerThread; ++i) {
+              if (!files[i]) {
+                continue; // This set of files is finished.
+              }
+              // Read from the next file. Different files advance at slightly
+              // different rates.
+              auto bytesNeeded = kMinRead + i * 1000;
+              while (bytesLeft[i] < bytesNeeded) {
+                const void* buffer;
+                int32_t size;
+                if (!files[i]->next(buffer, size)) {
+                  // End of file. Check that a multiple of file size has been
+                  // read.
+                  EXPECT_EQ(0, totalRead[i] % FileWithReadAhead::kFileSize);
+                  if (totalRead[i] >= 3 * FileWithReadAhead::kFileSize) {
+                    files[i] = nullptr;
+                    break;
+                  }
+                  // Open a new file with a different unique name.
+                  auto newName = fmt::format(
+                      "prefetch_{}",
+                      (static_cast<int64_t>(firstFileNumber) + i + i) *
+                              1000000000 +
+                          totalRead[i]);
+                  files[i] = std::make_unique<FileWithReadAhead>(
+                      newName,
+                      cache_.get(),
+                      threadStats,
+                      fsStat,
+                      *pool_,
+                      executor_.get());
+                  continue;
+                }
+                totalRead[i] += size;
+                bytesLeft[i] += size;
               }
-              // Open a new file with a different unique name.
-              auto newName = fmt::format(
-                  "prefetch_{}",
-                  (static_cast<int64_t>(firstFileNumber) + i + i) * 1000000000 +
-                      totalRead[i]);
-              files[i] = std::make_unique<FileWithReadAhead>(
-                  newName,
-                  cache_.get(),
-                  threadStats,
-                  fsStat,
-                  *pool_,
-                  executor_.get());
-              continue;
+              bytesLeft[i] -= bytesNeeded;
             }
-            totalRead[i] += size;
-            bytesLeft[i] += size;
           }
-          bytesLeft[i] -= bytesNeeded;
-        }
-      }
-    }));
+        }));
   }
   int64_t bytes = 0;
   int32_t count = 0;
@@ -935,19 +945,19 @@ TEST_F(CacheTest, noCacheRetention) {
 
 TEST_F(CacheTest, loadQuotumTooLarge) {
   initializeCache(64 << 20, 256 << 20);
-  auto fileId = std::make_unique<StringIdLease>(fileIds(), "foo");
+  StringIdLease fileId{fileIds(), "foo"};
   auto readFile =
-      std::make_shared<TestReadFile>(fileId->id(), 10 << 20, nullptr);
+      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(),
+          fileId,
           cache_.get(),
           nullptr,
-          0,
+          StringIdLease{},
           nullptr,
           nullptr,
           executor_.get(),
@@ -961,8 +971,8 @@ TEST_F(CacheTest, ssdReadVerification) {
   // 32 RAM, 256MB SSD, with checksumWrite/checksumReadVerification enabled.
   initializeCache(kMemoryBytes, kSsdBytes, true);
 
-  uint64_t fileId;
-  uint64_t groupId;
+  StringIdLease fileId;
+  StringIdLease groupId;
   auto file = inputByPath("test_file", fileId, groupId);
   auto tracker = std::make_shared<ScanTracker>(
       "testTracker", nullptr, io::ReaderOptions::kDefaultLoadQuantum);
diff --git a/velox/dwio/dwrf/test/ColumnStatisticsBase.h b/velox/dwio/dwrf/test/ColumnStatisticsBase.h
index 32b09aacfcf0..e1264cd9f27e 100644
--- a/velox/dwio/dwrf/test/ColumnStatisticsBase.h
+++ b/velox/dwio/dwrf/test/ColumnStatisticsBase.h
@@ -18,10 +18,14 @@
 
 #include <gtest/gtest.h>
 
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/Statistics.h"
 #include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
 
 namespace facebook::velox::dwrf {
+
+using dwio::common::ArenaCreate;
+
 class ColumnStatisticsBase {
  public:
   ColumnStatisticsBase()
@@ -752,8 +756,7 @@ class ColumnStatisticsBase {
 
       if (format == DwrfFormat::kDwrf) {
         auto columnStatistics =
-            google::protobuf::Arena::CreateMessage<proto::ColumnStatistics>(
-                arena_.get());
+            ArenaCreate<proto::ColumnStatistics>(arena_.get());
         if (from == State::kFalse) {
           columnStatistics->set_hasnull(false);
         } else if (from == State::kTrue) {
@@ -762,8 +765,8 @@ class ColumnStatisticsBase {
         target.merge(*buildColumnStatisticsFromProto(
             ColumnStatisticsWrapper(columnStatistics), context()));
       } else {
-        auto columnStatistics = google::protobuf::Arena::CreateMessage<
-            proto::orc::ColumnStatistics>(arena_.get());
+        auto columnStatistics =
+            ArenaCreate<proto::orc::ColumnStatistics>(arena_.get());
         if (from == State::kFalse) {
           columnStatistics->set_hasnull(false);
         } else if (from == State::kTrue) {
diff --git a/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp b/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp
index a8abecaed2fb..abf23b57b67b 100644
--- a/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp
+++ b/velox/dwio/dwrf/test/ColumnWriterIndexTest.cpp
@@ -371,9 +371,10 @@ class WriterEncodingIndexTest2 {
         }
       }
       proto::StripeFooter stripeFooter;
+      auto sfw = StripeFooterWriteWrapper(&stripeFooter);
       columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
+          [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+            return sfw.addEncoding();
           });
 
       // Simulate continue writing to next stripe, so internally buffered data
@@ -821,9 +822,10 @@ class IntegerColumnWriterDirectEncodingIndexTest : public testing::Test {
         // *all* streams
         EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
         proto::StripeFooter stripeFooter;
+        auto sfw = StripeFooterWriteWrapper(&stripeFooter);
         columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
+            [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+              return sfw.addEncoding();
             });
       } else {
         for (size_t i = 0; i != pageCount; ++i) {
@@ -847,9 +849,10 @@ class IntegerColumnWriterDirectEncodingIndexTest : public testing::Test {
         EXPECT_CALL(*mockIndexBuilderPtr, flush());
         EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
         proto::StripeFooter stripeFooter;
+        auto sfw = StripeFooterWriteWrapper(&stripeFooter);
         columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
+            [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+              return sfw.addEncoding();
             });
       }
 
@@ -972,9 +975,10 @@ class StringColumnWriterDictionaryEncodingIndexTest : public testing::Test {
       // Recording PRESENT stream starting positions for the new stripe.
       EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(4);
       proto::StripeFooter stripeFooter;
+      auto sfw = StripeFooterWriteWrapper(&stripeFooter);
       columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
+          [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+            return sfw.addEncoding();
           });
 
       // Simulate continue writing to next stripe, so internally buffered data
@@ -1128,9 +1132,10 @@ class StringColumnWriterDirectEncodingIndexTest : public testing::Test {
         // *all* streams
         EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
         proto::StripeFooter stripeFooter;
+        auto sfw = StripeFooterWriteWrapper(&stripeFooter);
         columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
+            [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+              return sfw.addEncoding();
             });
       } else {
         for (size_t i = 0; i != pageCount; ++i) {
@@ -1154,9 +1159,10 @@ class StringColumnWriterDirectEncodingIndexTest : public testing::Test {
         EXPECT_CALL(*mockIndexBuilderPtr, flush());
         EXPECT_CALL(*mockIndexBuilderPtr, add(0, -1)).Times(positionCount);
         proto::StripeFooter stripeFooter;
+        auto sfw = StripeFooterWriteWrapper(&stripeFooter);
         columnWriter->flush(
-            [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-              return *stripeFooter.add_encoding();
+            [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+              return sfw.addEncoding();
             });
       }
 
@@ -1208,7 +1214,7 @@ class ListColumnWriterEncodingIndexTest : public testing::Test,
                                           public WriterEncodingIndexTest2 {
  public:
   ListColumnWriterEncodingIndexTest()
-      : WriterEncodingIndexTest2(ARRAY(REAL())){};
+      : WriterEncodingIndexTest2(ARRAY(REAL())) {};
 
  protected:
   static void SetUpTestCase() {
diff --git a/velox/dwio/dwrf/test/ColumnWriterTest.cpp b/velox/dwio/dwrf/test/ColumnWriterTest.cpp
index 2cf83e888804..88bb5d65c686 100644
--- a/velox/dwio/dwrf/test/ColumnWriterTest.cpp
+++ b/velox/dwio/dwrf/test/ColumnWriterTest.cpp
@@ -31,7 +31,6 @@
 #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;
@@ -214,7 +213,7 @@ VectorPtr populateBatch(
   auto valuesPtr = values->asMutableRange<T>();
 
   const size_t nulloptCount =
-      std::count(data.begin(), data.end(), std::nullopt);
+      std::count(data.cbegin(), data.cend(), std::nullopt);
   if (nulloptCount == 0) {
     size_t index = 0;
     for (auto val : data) {
@@ -355,12 +354,13 @@ void testDataTypeWriter(
 
   for (auto stripeI = 0; stripeI < stripeCount; ++stripeI) {
     proto::StripeFooter sf;
+    auto sfw = StripeFooterWriteWrapper(&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();
+    writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+      return sfw.addEncoding();
     });
 
     TestStripeStreams streams(context, sf, rowType, pool.get());
@@ -804,6 +804,30 @@ void printRow(const std::string& title, const VectorPtr& batch) {
   }
 }
 
+void printFlatMap(const std::string& title, const VectorPtr& batch) {
+  auto mv = std::dynamic_pointer_cast<FlatMapVector>(batch);
+  if (!mv) {
+    VLOG(3) << "To be implemented for encoded vector";
+    return;
+  }
+
+  VLOG(3) << "*******" << title << "*******";
+  VLOG(3) << "Size: " << mv->size() << ", Null count: " << getNullCountStr(*mv);
+
+  VLOG(3) << "Keys:";
+  for (int i = 0; i < mv->numDistinctKeys(); i++) {
+    VLOG(3) << "  Key:[" << i << "] " << mv->distinctKeys()->toString(i);
+    const auto& inMaps = mv->inMaps();
+    for (int j = 0; j < mv->size(); j++) {
+      if (inMaps[i] == nullptr ||
+          bits::isBitSet(inMaps[i]->as<uint64_t>(), j)) {
+        VLOG(3) << "    Value:[" << j << "] "
+                << mv->mapValues()[i]->toString(j);
+      }
+    }
+  }
+}
+
 VectorPtr
 wrapInDictionary(const VectorPtr& batch, size_t stride, MemoryPool& pool) {
   VectorPtr ret = batch;
@@ -846,10 +870,8 @@ wrapInDictionary(const VectorPtr& batch, size_t stride, MemoryPool& pool) {
   return ret;
 }
 
-VectorPtr wrapInDictionaryRow(const VectorPtr& batch, MemoryPool& pool) {
-  auto row = batch->as<RowVector>();
-
-  auto size = row->size();
+VectorPtr wrapInDictionary(const VectorPtr& batch, MemoryPool& pool) {
+  auto size = batch->size();
   auto indices = AlignedBuffer::allocate<vector_size_t>(size, &pool);
   auto rawIndices = indices->asMutable<vector_size_t>();
   for (auto i = 0; i < size; i++) {
@@ -937,48 +959,72 @@ void mapToStruct(
   }
 }
 
-template <typename TKEY, typename TVALUE, bool useStruct = false>
+enum class MapWriterInputType { kMap, kStruct, kFlatMap };
+
+template <typename TKEY, typename TVALUE>
 void testMapWriter(
     MemoryPool& pool,
     const std::vector<VectorPtr>& batches,
     bool useFlatMap,
+    MapWriterInputType inputType,
     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 std::shared_ptr<const TypeWithId> 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" : "");
+          << (useFlatMap && inputType == MapWriterInputType::kStruct
+                  ? " - Struct"
+                  : "")
+          << (useFlatMap && inputType == MapWriterInputType::kFlatMap
+                  ? " - FlatMap"
+                  : "");
 
   const auto config = std::make_shared<Config>();
   auto* pBatches = &batches;
-  std::vector<VectorPtr> structs;
+  std::vector<VectorPtr> transformedInput;
   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;
+    if (inputType == MapWriterInputType::kStruct) {
+      if constexpr (!CppToType<TVALUE>::isPrimitiveType) {
+      } else {
+        transformedInput = batches;
+        pBatches = &transformedInput;
+        std::vector<TKEY> uniqueKeys;
+        ASSERT_NO_FATAL_FAILURE(getUniqueKeys<TKEY>(uniqueKeys, batches));
+        ASSERT_NO_FATAL_FAILURE(
+            (mapToStruct<TKEY, TVALUE>(pool, transformedInput, 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;
+      }
+    } else if (inputType == MapWriterInputType::kFlatMap) {
+      transformedInput = batches;
+      pBatches = &transformedInput;
+      VectorMaker maker(&pool);
+
+      for (size_t i = 0; i < transformedInput.size(); i++) {
+        auto mapBatch =
+            std::dynamic_pointer_cast<MapVector>(transformedInput[i]);
+        ASSERT_TRUE(mapBatch);
+
+        transformedInput[i] = maker.flatMapVector<TKEY>(mapBatch);
+      }
     }
 
     config->set(Config::FLATTEN_MAP, true);
@@ -998,24 +1044,27 @@ void testMapWriter(
 
   // Each batch represents an input for a separate stripe
   for (auto batch : *pBatches) {
-    auto isStruct = useFlatMap && useStruct;
+    auto isStruct = useFlatMap && inputType == MapWriterInputType::kStruct;
     if (printMaps) {
       if (isStruct) {
         printRow("Input", batch);
+      } else if (inputType == MapWriterInputType::kFlatMap) {
+        printFlatMap("Input", batch);
       } else {
         printMap<TKEY, TVALUE>("Input", batch);
       }
     }
 
     proto::StripeFooter sf;
+    auto sfw = StripeFooterWriteWrapper(&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);
+        if (inputType != MapWriterInputType::kMap) {
+          toWrite = wrapInDictionary(toWrite, pool);
         } else {
           toWrite = wrapInDictionary(toWrite, strideI, pool);
         }
@@ -1025,8 +1074,8 @@ void testMapWriter(
       writtenBatches.push_back(toWrite);
     }
 
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
+    writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+      return sfw.addEncoding();
     });
 
     auto validate = [&](bool returnFlatVector = false) {
@@ -1047,6 +1096,8 @@ void testMapWriter(
         if (printMaps) {
           if (isStruct) {
             printRow("Result", batch);
+          } else if (inputType == MapWriterInputType::kFlatMap) {
+            printFlatMap("Result", out);
           } else {
             printMap<TKEY, TVALUE>("Result", out);
           }
@@ -1150,19 +1201,20 @@ void testMapWriterRow(
     }
 
     proto::StripeFooter sf;
+    auto sfw = StripeFooterWriteWrapper(&sf);
     std::vector<VectorPtr> writtenBatches;
 
     // Write map/row
     auto toWrite = batch;
     if (testEncoded) {
-      toWrite = wrapInDictionaryRow(toWrite, pool);
+      toWrite = wrapInDictionary(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();
+    writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+      return sfw.addEncoding();
     });
 
     auto validate = [&](bool returnFlatVector = false) {
@@ -1253,25 +1305,38 @@ TEST_F(ColumnWriterTest, TestMapWriterNestedRow) {
   testMapWriterRowImpl<Row<int32_t, bool, StringView>>();
 }
 
-template <typename TKEY, typename TVALUE, bool useStruct = false>
+template <typename TKEY, typename TVALUE>
 void testMapWriter(
     MemoryPool& pool,
     const VectorPtr& batch,
     bool useFlatMap,
+    MapWriterInputType inputType = MapWriterInputType::kMap,
     bool printMaps = true) {
-  std::vector<VectorPtr> batches{batch, batch};
-  testMapWriter<TKEY, TVALUE, useStruct>(
-      pool, batches, useFlatMap, true, false, printMaps);
+  testMapWriter<TKEY, TVALUE>(
+      pool, {batch, batch}, useFlatMap, inputType, printMaps);
+}
+
+template <typename TKEY, typename TVALUE>
+void testMapWriter(
+    MemoryPool& pool,
+    const std::vector<VectorPtr>& batches,
+    bool useFlatMap,
+    MapWriterInputType inputType = MapWriterInputType::kMap,
+    bool printMaps = true) {
+  testMapWriter<TKEY, TVALUE>(
+      pool, batches, useFlatMap, inputType, 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);
+    testMapWriter<TKEY, TVALUE>(
+        pool, batches, useFlatMap, inputType, false, false, printMaps);
+    testMapWriter<TKEY, TVALUE>(
+        pool, batches, useFlatMap, inputType, true, true, printMaps);
   }
 }
 
-template <typename T, bool useStruct = false>
-void testMapWriterNumericKey(bool useFlatMap) {
+template <typename T>
+void testMapWriterNumericKey(
+    bool useFlatMap,
+    MapWriterInputType inputType = MapWriterInputType::kMap) {
   using b = MapBuilder<T, T>;
 
   auto pool = memory::memoryManager()->addLeafPool();
@@ -1285,14 +1350,19 @@ void testMapWriterNumericKey(bool useFlatMap) {
            typename b::pair{
                std::numeric_limits<T>::min(), std::numeric_limits<T>::min()}}});
 
-  testMapWriter<T, T, useStruct>(*pool, batch, useFlatMap, true);
+  testMapWriter<T, T>(*pool, batch, useFlatMap, inputType, true);
 }
 
-// Workaround to avoid issues with two template arguments when wrapped in gtest
-// EXPECT macros.
+// 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);
+  testMapWriterNumericKey<T>(useFlatMap, MapWriterInputType::kStruct);
+}
+
+template <typename T>
+void testMapWriterNumericKeyUseFlatMap(bool useFlatMap) {
+  testMapWriterNumericKey<T>(useFlatMap, MapWriterInputType::kFlatMap);
 }
 
 TEST_F(ColumnWriterTest, TestMapWriterFloatKey) {
@@ -1308,12 +1378,20 @@ TEST_F(ColumnWriterTest, TestMapWriterFloatKey) {
             /* useFlatMap */ true);
       },
       exception::LoggedException);
+
+  EXPECT_THROW(
+      {
+        testMapWriterNumericKeyUseFlatMap<float>(
+            /* useFlatMap */ true);
+      },
+      exception::LoggedException);
 }
 
 TEST_F(ColumnWriterTest, TestMapWriterInt64Key) {
   testMapWriterNumericKey<int64_t>(/* useFlatMap */ false);
   testMapWriterNumericKey<int64_t>(/* useFlatMap */ true);
   testMapWriterNumericKeyUseStruct<int64_t>(/* useFlatMap */ true);
+  testMapWriterNumericKeyUseFlatMap<int64_t>(/* useFlatMap */ true);
 }
 
 TEST_F(ColumnWriterTest, TestMapWriterDuplicatedInt64Key) {
@@ -1333,18 +1411,21 @@ TEST_F(ColumnWriterTest, TestMapWriterInt32Key) {
   testMapWriterNumericKey<int32_t>(/* useFlatMap */ false);
   testMapWriterNumericKey<int32_t>(/* useFlatMap */ true);
   testMapWriterNumericKeyUseStruct<int32_t>(/* useFlatMap */ true);
+  testMapWriterNumericKeyUseFlatMap<int32_t>(/* useFlatMap */ true);
 }
 
 TEST_F(ColumnWriterTest, TestMapWriterInt16Key) {
   testMapWriterNumericKey<int16_t>(/* useFlatMap */ false);
   testMapWriterNumericKey<int16_t>(/* useFlatMap */ true);
   testMapWriterNumericKeyUseStruct<int16_t>(/* useFlatMap */ true);
+  testMapWriterNumericKeyUseFlatMap<int16_t>(/* useFlatMap */ true);
 }
 
 TEST_F(ColumnWriterTest, TestMapWriterInt8Key) {
   testMapWriterNumericKey<int8_t>(/* useFlatMap */ false);
   testMapWriterNumericKey<int8_t>(/* useFlatMap */ true);
   testMapWriterNumericKeyUseStruct<int8_t>(/* useFlatMap */ true);
+  testMapWriterNumericKeyUseFlatMap<int8_t>(/* useFlatMap */ true);
 }
 
 TEST_F(ColumnWriterTest, TestMapWriterStringKey) {
@@ -1360,8 +1441,104 @@ TEST_F(ColumnWriterTest, TestMapWriterStringKey) {
 
   testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
   testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ true);
-  testMapWriter<keyType, valueType, /* useStruct */ true>(
-      *pool_, batch, /* useFlatMap */ true, true);
+  testMapWriter<keyType, valueType>(
+      *pool_,
+      batch,
+      /* useFlatMap */ true,
+      MapWriterInputType::kStruct,
+      true);
+  testMapWriter<keyType, valueType>(
+      *pool_,
+      batch,
+      /* useFlatMap */ true,
+      MapWriterInputType::kFlatMap,
+      true);
+}
+
+void testFlatMapWriter(
+    const std::vector<RowVectorPtr>& batches,
+    MemoryPool* pool) {
+  const auto rowType =
+      std::dynamic_pointer_cast<const RowType>(batches[0]->type());
+  const auto dataType = rowType->childAt(0);
+  const std::shared_ptr<const TypeWithId> rowTypeWithId =
+      TypeWithId::create(rowType);
+  const auto dataTypeWithId = rowTypeWithId->childAt(0);
+  const auto writerSchema = TypeWithId::create(rowType);
+  const auto writerDataTypeWithId = writerSchema->childAt(0);
+
+  const auto config = std::make_shared<Config>();
+  config->set(Config::FLATTEN_MAP, true);
+  config->set(Config::MAP_FLAT_COLS, {writerDataTypeWithId->column()});
+  config->set(Config::MAP_FLAT_DISABLE_DICT_ENCODING, true);
+
+  WriterContext context{config, memory::memoryManager()->addRootPool()};
+  context.initBuffer();
+  const auto writer = BaseColumnWriter::create(context, *writerDataTypeWithId);
+
+  for (auto batch : batches) {
+    writer->write(batch->childAt(0), common::Ranges::of(0, batch->size()));
+  }
+  writer->createIndexEntry();
+
+  proto::StripeFooter sf;
+  auto sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](uint32_t /*unused*/) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
+  });
+
+  // Reading the vector out
+  TestStripeStreams streams(context, sf, rowType, pool);
+  EXPECT_CALL(streams.getMockStrideIndexProvider(), getStrideIndex())
+      .WillRepeatedly(Return(0));
+  auto reqType = rowTypeWithId->childAt(0);
+  memory::AllocationPool allocPool(pool);
+  StreamLabels labels(allocPool);
+  auto reader =
+      ColumnReader::build(reqType, reqType, streams, labels, nullptr, 0);
+  VectorPtr out;
+
+  for (const auto& batch : batches) {
+    reader->next(batch->size(), out);
+    for (int32_t i = 0; i < batch->size(); ++i) {
+      ASSERT_TRUE(batch->childAt(0)->equalValueAt(out.get(), i, i))
+          << "Row mismatch at index " << i;
+    }
+  }
+}
+
+TEST_F(ColumnWriterTest, TestFlatMapKeyNotInAllBatches) {
+  VectorMaker maker(pool_.get());
+  // Test the case where not all keys appear in all batches.
+  const std::vector<RowVectorPtr> batches{
+      maker.rowVector({maker.flatMapVector<StringView, StringView>(
+          {{{"1", "3"}, {"2", "2"}}, {{"2", "5"}, {"3", "8"}}})}),
+      maker.rowVector({maker.flatMapVector<StringView, StringView>(
+          {{{"4", "3"}, {"5", "2"}}, {{"6", "5"}, {"7", "8"}}})}),
+      maker.rowVector({maker.flatMapVector<StringView, StringView>(
+          {{{"1", "3"}, {"2", "2"}}, {{"2", "5"}, {"3", "8"}}})})};
+
+  testFlatMapWriter(batches, pool_.get());
+}
+
+TEST_F(ColumnWriterTest, TesFlatMapDuplicatedKey) {
+  const size_t size = 3;
+  const BufferPtr inMaps = AlignedBuffer::allocate<bool>(size, pool_.get());
+  bits::fillBits(inMaps->asMutable<uint64_t>(), 1, size, pool_.get());
+
+  VectorMaker maker(pool_.get());
+  RowVectorPtr batch = maker.rowVector({std::make_shared<FlatMapVector>(
+      pool_.get(),
+      MAP(VARCHAR(), VARCHAR()),
+      nullptr,
+      3,
+      maker.flatVector({"2", "2"}),
+      std::vector<VectorPtr>{
+          maker.flatVector({"1", "2", "3"}), maker.flatVector({"4", "5", "6"})},
+      std::vector<BufferPtr>{inMaps, inMaps})});
+
+  VELOX_ASSERT_THROW(
+      testFlatMapWriter({batch}, pool_.get()), "Duplicated key in map: 2");
 }
 
 TEST_F(ColumnWriterTest, TestMapWriterDuplicatedStringKey) {
@@ -1434,7 +1611,7 @@ TEST_F(ColumnWriterTest, TestMapWriterMixedBatchTypeHandling) {
           *pool_,
           batches,
           /* useFlatMap */ true,
-
+          MapWriterInputType::kMap,
           true,
           false)),
       "");
@@ -1453,8 +1630,18 @@ TEST_F(ColumnWriterTest, TestMapWriterBinaryKey) {
 
   testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ false);
   testMapWriter<keyType, valueType>(*pool_, batch, /* useFlatMap */ true);
-  testMapWriter<keyType, valueType, /* useStruct */ true>(
-      *pool_, batch, /* useFlatMap */ true, true);
+  testMapWriter<keyType, valueType>(
+      *pool_,
+      batch,
+      /* useFlatMap */ true,
+      MapWriterInputType::kStruct,
+      true);
+  testMapWriter<keyType, valueType>(
+      *pool_,
+      batch,
+      /* useFlatMap */ true,
+      MapWriterInputType::kFlatMap,
+      true);
 }
 
 template <typename keyType, typename valueType>
@@ -1504,12 +1691,14 @@ TEST_F(ColumnWriterTest, TestMapWriterDifferentStripeBatches) {
       *pool_,
       batches,
       /* useFlatMap */ false,
+      MapWriterInputType::kMap,
       false,
       false);
   testMapWriter<keyType, valueType>(
       *pool_,
       batches,
       /* useFlatMap */ true,
+      MapWriterInputType::kMap,
       false,
       false);
 }
@@ -2179,6 +2368,7 @@ struct IntegerColumnWriterTypedTestCase {
 
     for (size_t i = 0; i != flushCount; ++i) {
       proto::StripeFooter stripeFooter;
+      auto sfw = StripeFooterWriteWrapper(&stripeFooter);
       for (size_t j = 0; j != repetitionCount; ++j) {
         columnWriter->write(batch, common::Ranges::of(0, batch->size()));
         postProcess(*columnWriter, i, j);
@@ -2186,8 +2376,8 @@ struct IntegerColumnWriterTypedTestCase {
       }
       // We only flush once per stripe.
       columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
+          [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+            return sfw.addEncoding();
           });
 
       // Read and verify.
@@ -3339,7 +3529,7 @@ struct StringColumnWriterTestCase {
         postProcess{postProcess},
         repetitionCount{repetitionCount},
         flushCount{flushCount},
-        type{CppToType<folly::StringPiece>::create()} {}
+        type{CppToType<std::string_view>::create()} {}
 
   virtual ~StringColumnWriterTestCase() = default;
 
@@ -3413,6 +3603,7 @@ struct StringColumnWriterTestCase {
 
     for (size_t i = 0; i != flushCount; ++i) {
       proto::StripeFooter stripeFooter;
+      auto sfw = StripeFooterWriteWrapper(&stripeFooter);
       // Write Stride
       for (size_t j = 0; j != repetitionCount; ++j) {
         // TODO: break the batch into multiple strides.
@@ -3423,8 +3614,8 @@ struct StringColumnWriterTestCase {
 
       // Flush when all strides are written (once per stripe).
       columnWriter->flush(
-          [&stripeFooter](uint32_t /* unused */) -> proto::ColumnEncoding& {
-            return *stripeFooter.add_encoding();
+          [&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+            return sfw.addEncoding();
           });
 
       // Read and verify.
@@ -4253,8 +4444,9 @@ TEST_F(ColumnWriterTest, IntDictWriterDirectValueOverflow) {
   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 sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](auto /* unused */) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
   auto& enc = sf.encoding(0);
   ASSERT_EQ(enc.kind(), proto::ColumnEncoding_Kind_DICTIONARY);
@@ -4298,8 +4490,9 @@ TEST_F(ColumnWriterTest, ShortDictWriterDictValueOverflow) {
   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 sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
   auto& enc = sf.encoding(0);
   ASSERT_EQ(enc.kind(), proto::ColumnEncoding_Kind_DICTIONARY);
@@ -4339,8 +4532,9 @@ TEST_F(ColumnWriterTest, RemovePresentStream) {
   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 sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
 
   // get data stream
@@ -4377,8 +4571,9 @@ TEST_F(ColumnWriterTest, ColumnIdInStream) {
   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 sfw = StripeFooterWriteWrapper(&sf);
+  writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+    return sfw.addEncoding();
   });
 
   // get data stream
@@ -4506,8 +4701,9 @@ struct DictColumnWriterTestCase {
     writer->createIndexEntry();
 
     proto::StripeFooter sf;
-    writer->flush([&sf](uint32_t /* unused */) -> proto::ColumnEncoding& {
-      return *sf.add_encoding();
+    auto sfw = StripeFooterWriteWrapper(&sf);
+    writer->flush([&sfw](uint32_t /* unused */) -> ColumnEncodingWriteWrapper {
+      return sfw.addEncoding();
     });
 
     // Reading the vector out
diff --git a/velox/dwio/dwrf/test/CompressionTest.cpp b/velox/dwio/dwrf/test/CompressionTest.cpp
index 33ba45cbf20a..9343af57e6dc 100644
--- a/velox/dwio/dwrf/test/CompressionTest.cpp
+++ b/velox/dwio/dwrf/test/CompressionTest.cpp
@@ -291,6 +291,8 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     Values(
         std::make_tuple(CompressionKind_ZLIB, nullptr, nullptr),
         std::make_tuple(CompressionKind_ZLIB, &testEncrypter, &testDecrypter),
+        std::make_tuple(CompressionKind_GZIP, nullptr, nullptr),
+        std::make_tuple(CompressionKind_GZIP, &testEncrypter, &testDecrypter),
         std::make_tuple(CompressionKind_ZSTD, nullptr, nullptr),
         std::make_tuple(CompressionKind_ZSTD, &testEncrypter, &testDecrypter),
         std::make_tuple(CompressionKind_NONE, nullptr, nullptr),
@@ -399,10 +401,11 @@ TEST_P(CompressionTest, getCompressionBufferOOM) {
       {true, true}, {true, false}, {false, true}, {false, false}};
 
   for (const auto& testData : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "{} compression {}",
-        testData.debugString(),
-        compressionKindToString(kind_)));
+    SCOPED_TRACE(
+        fmt::format(
+            "{} compression {}",
+            testData.debugString(),
+            compressionKindToString(kind_)));
 
     auto config = std::make_shared<Config>();
     config->set<CompressionKind>(Config::COMPRESSION, kind_);
@@ -456,6 +459,8 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     Values(
         std::make_tuple(CompressionKind_ZLIB, nullptr),
         std::make_tuple(CompressionKind_ZLIB, &testEncrypter),
+        std::make_tuple(CompressionKind_GZIP, nullptr),
+        std::make_tuple(CompressionKind_GZIP, &testEncrypter),
         std::make_tuple(CompressionKind_ZSTD, nullptr),
         std::make_tuple(CompressionKind_ZSTD, &testEncrypter),
         std::make_tuple(CompressionKind_NONE, &testEncrypter)));
diff --git a/velox/dwio/dwrf/test/DataBufferHolderTests.cpp b/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
index 6b53cbfab22e..d4b5f6e1238a 100644
--- a/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
+++ b/velox/dwio/dwrf/test/DataBufferHolderTests.cpp
@@ -36,9 +36,15 @@ TEST_F(DataBufferHolderTest, InputCheck) {
   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}; }
+  {
+    DataBufferHolder holder{*pool_, 1024};
+  }
+  {
+    DataBufferHolder holder{*pool_, 1024, 512};
+  }
+  {
+    DataBufferHolder holder{*pool_, 1024, 512, 3.0f};
+  }
 }
 
 TEST_F(DataBufferHolderTest, TakeAndGetBuffer) {
diff --git a/velox/dwio/dwrf/test/DecryptionTests.cpp b/velox/dwio/dwrf/test/DecryptionTests.cpp
index 6a19a41c4846..7cff7a4acb26 100644
--- a/velox/dwio/dwrf/test/DecryptionTests.cpp
+++ b/velox/dwio/dwrf/test/DecryptionTests.cpp
@@ -32,7 +32,8 @@ TEST(Decryption, NotEncrypted) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   TestDecrypterFactory factory;
   auto handler = DecryptionHandler::create(footer, &factory);
   ASSERT_FALSE(handler->isEncrypted());
@@ -42,7 +43,8 @@ TEST(Decryption, NoKeyProvider) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   footer.mutable_encryption();
   TestDecrypterFactory factory;
   ASSERT_THROW(
@@ -53,7 +55,8 @@ TEST(Decryption, EmptyGroup) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   TestDecrypterFactory factory;
@@ -65,7 +68,8 @@ TEST(Decryption, EmptyNodes) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -79,7 +83,8 @@ TEST(Decryption, StatsMismatch) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -96,7 +101,8 @@ TEST(Decryption, KeyExistenceMismatch) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   for (size_t i = 0; i < 2; ++i) {
@@ -116,7 +122,8 @@ TEST(Decryption, ReuseStripeKey) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -135,7 +142,8 @@ TEST(Decryption, StripeKeyMismatch) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -153,7 +161,8 @@ TEST(Decryption, Basic) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int,b:float,c:string,d:double>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   for (auto i = 0; i < 5; ++i) {
@@ -183,7 +192,8 @@ TEST(Decryption, NestedType) {
   auto type = parser.parse(
       "struct<a:int,b:map<float,map<int,double>>,c:struct<a:string,b:int>,d:array<double>>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
 
@@ -222,7 +232,8 @@ TEST(Decryption, RootNode) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:int,b:int>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   auto group = enc->add_encryptiongroups();
@@ -238,7 +249,8 @@ TEST(Decryption, GroupOverlap) {
   HiveTypeParser parser;
   auto type = parser.parse("struct<a:struct<a:float,b:double>>");
   proto::Footer footer;
-  ProtoUtils::writeType(*type, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto enc = footer.mutable_encryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
 
diff --git a/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp b/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp
index 076e871ce88f..e3ddd5b457d9 100644
--- a/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp
+++ b/velox/dwio/dwrf/test/DirectBufferedInputTest.cpp
@@ -71,9 +71,9 @@ class DirectBufferedInputTest : public testing::Test {
     return std::make_unique<DirectBufferedInput>(
         file_,
         dwio::common::MetricsLog::voidLog(),
-        1,
+        StringIdLease{},
         tracker_,
-        2,
+        StringIdLease{},
         ioStats_,
         fsStats,
         executor_.get(),
diff --git a/velox/dwio/dwrf/test/E2EFilterTest.cpp b/velox/dwio/dwrf/test/E2EFilterTest.cpp
index 43b67e91e550..d9ebb9f52e62 100644
--- a/velox/dwio/dwrf/test/E2EFilterTest.cpp
+++ b/velox/dwio/dwrf/test/E2EFilterTest.cpp
@@ -241,6 +241,62 @@ TEST_F(E2EFilterTest, floatAndDouble) {
       false);
 }
 
+TEST_F(E2EFilterTest, DISABLED_shortDecimal) {
+  // ORC write functionality is not yet supported. Enable this test once it
+  // becomes available and set the file format to ORC at that time.
+  // options.format = DwrfFormat::kOrc;
+  const std::unordered_map<std::string, TypePtr> types = {
+      {"shortdecimal_val:decimal(8, 5)", DECIMAL(8, 5)},
+      {"shortdecimal_val:decimal(10, 5)", DECIMAL(10, 5)},
+      {"shortdecimal_val:decimal(17, 5)", DECIMAL(17, 5)}};
+
+  for (const auto& pair : types) {
+    testWithTypes(
+        pair.first,
+        [&]() {
+          makeIntDistribution<int64_t>(
+              "shortdecimal_val",
+              10, // min
+              100, // max
+              22, // repeats
+              19, // rareFrequency
+              -999, // rareMin
+              30000, // rareMax
+              true);
+        },
+        false,
+        {"shortdecimal_val"},
+        20);
+  }
+}
+
+TEST_F(E2EFilterTest, DISABLED_longDecimal) {
+  // ORC write functionality is not yet supported. Enable this test once it
+  // becomes available and set the file format to ORC at that time.
+  // options.format = DwrfFormat::kOrc;
+  const std::unordered_map<std::string, TypePtr> types = {
+      {"longdecimal_val:decimal(30, 10)", DECIMAL(30, 10)},
+      {"longdecimal_val:decimal(37, 15)", DECIMAL(37, 15)}};
+  for (const auto& pair : types) {
+    testWithTypes(
+        pair.first,
+        [&]() {
+          makeIntDistribution<int128_t>(
+              "longdecimal_val",
+              10, // min
+              100, // max
+              22, // repeats
+              19, // rareFrequency
+              -999, // rareMin
+              30000, // rareMax
+              true);
+        },
+        false,
+        {"longdecimal_val"},
+        20);
+  }
+}
+
 TEST_F(E2EFilterTest, stringDirect) {
   testutil::TestValue::enable();
   bool coverage[2][2]{};
diff --git a/velox/dwio/dwrf/test/E2EReaderTest.cpp b/velox/dwio/dwrf/test/E2EReaderTest.cpp
index 6b696392910e..9ba378ea9da6 100644
--- a/velox/dwio/dwrf/test/E2EReaderTest.cpp
+++ b/velox/dwio/dwrf/test/E2EReaderTest.cpp
@@ -73,11 +73,11 @@ class ValueTypes {
   }
 
   auto begin() const {
-    return values_.begin();
+    return values_.cbegin();
   }
 
   auto end() const {
-    return values_.end();
+    return values_.cend();
   }
 
   const std::shared_ptr<folly::Executor>& decodingExecutor() const {
@@ -244,127 +244,159 @@ TEST_P(E2EReaderTest, SharedDictionaryFlatmapReadAsStruct) {
 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>"})}));
+    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>"})}));
+    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>"})}));
+    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>"})}));
+    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>"})}));
+    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>"})}));
+    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>"})}));
+    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>"})}));
+    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
index e069d56c8644..771a8078f707 100644
--- a/velox/dwio/dwrf/test/E2EWriterTest.cpp
+++ b/velox/dwio/dwrf/test/E2EWriterTest.cpp
@@ -261,7 +261,8 @@ class E2EWriterTest : public testing::Test {
         0,
         0,
         writerFlushThresholdSize,
-        "none");
+        "none",
+        0);
   }
 
   std::shared_ptr<MemoryPool> rootPool_;
@@ -980,7 +981,7 @@ TEST_F(E2EWriterTest, OversizeRows) {
       config,
       /*flushPolicyFactory=*/nullptr,
       /*layoutPlannerFactory=*/nullptr,
-      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
+      /*writerMemoryCap=*/std::numeric_limits<int64_t>::max(),
       false);
 }
 
@@ -1012,7 +1013,7 @@ TEST_F(E2EWriterTest, OversizeBatches) {
       config,
       /*flushPolicyFactory=*/nullptr,
       /*layoutPlannerFactory=*/nullptr,
-      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
+      /*writerMemoryCap=*/std::numeric_limits<int64_t>::max(),
       false);
 
   // Test splitting multiple huge batches.
@@ -1028,7 +1029,7 @@ TEST_F(E2EWriterTest, OversizeBatches) {
       config,
       /*flushPolicyFactory=*/nullptr,
       /*layoutPlannerFactory=*/nullptr,
-      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
+      /*writerMemoryCap=*/std::numeric_limits<int64_t>::max(),
       false);
 }
 
@@ -1088,7 +1089,7 @@ TEST_F(E2EWriterTest, OverflowLengthIncrements) {
       config,
       /*flushPolicyFactory=*/nullptr,
       /*layoutPlannerFactory=*/nullptr,
-      /*memoryBudget=*/std::numeric_limits<int64_t>::max(),
+      /*writerMemoryCap=*/std::numeric_limits<int64_t>::max(),
       false);
 }
 
@@ -1634,6 +1635,76 @@ TEST_F(E2EWriterTest, fuzzFlatmap) {
   }
 }
 
+TEST_F(E2EWriterTest, fuzzFlatmapWithFlatmapInput) {
+  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 genFlatMap = [&](auto type) {
+    auto& mapType = type->asMap();
+
+    std::vector<BufferPtr> inMaps;
+    std::vector<VectorPtr> values;
+    for (size_t key = 0; key < batchSize; ++key) {
+      inMaps.push_back(AlignedBuffer::allocate<bool>(batchSize, pool.get(), 0));
+      auto* rawInMaps = inMaps.back()->asMutable<uint64_t>();
+      for (size_t row = 0; row < batchSize; ++row) {
+        bits::setBit(rawInMaps, row, folly::Random::oneIn(2, rng));
+      }
+
+      values.push_back(fuzzer.fuzz(mapType.valueType()));
+    }
+
+    return std::make_shared<FlatMapVector>(
+        pool.get(),
+        type,
+        nullptr,
+        batchSize,
+        createKeys(mapType.keyType(), *pool, rng, batchSize, batchSize),
+        std::move(values),
+        std::move(inMaps));
+  };
+
+  auto gen = [&]() {
+    std::vector<VectorPtr> children(type->size());
+    for (auto i = 0; i < type->size(); ++i) {
+      children[i] = genFlatMap(type->childAt(i));
+    }
+
+    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()},
@@ -2070,9 +2141,10 @@ DEBUG_ONLY_TEST_F(E2EWriterTest, memoryReclaimThreshold) {
   }
   const std::vector<uint64_t> writerFlushThresholdSizes = {0, 1L << 30};
   for (uint64_t writerFlushThresholdSize : writerFlushThresholdSizes) {
-    SCOPED_TRACE(fmt::format(
-        "writerFlushThresholdSize {}",
-        succinctBytes(writerFlushThresholdSize)));
+    SCOPED_TRACE(
+        fmt::format(
+            "writerFlushThresholdSize {}",
+            succinctBytes(writerFlushThresholdSize)));
 
     const common::SpillConfig spillConfig =
         getSpillConfig(10, 20, writerFlushThresholdSize);
diff --git a/velox/dwio/dwrf/test/EncodingManagerTests.cpp b/velox/dwio/dwrf/test/EncodingManagerTests.cpp
index 681e0908157b..e53c276e29c5 100644
--- a/velox/dwio/dwrf/test/EncodingManagerTests.cpp
+++ b/velox/dwio/dwrf/test/EncodingManagerTests.cpp
@@ -34,10 +34,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().begin(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cbegin(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   {
     // A valid end iterator.
@@ -45,10 +45,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().end(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cend(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   footer.add_encoding();
   // footer [e]
@@ -58,10 +58,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().begin(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cbegin(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   {
     // A valid end iterator.
@@ -69,10 +69,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().end(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cend(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   proto::StripeEncryptionGroup group1;
   proto::StripeEncryptionGroup group2;
@@ -85,10 +85,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().begin(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cbegin(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   {
     // A valid end iterator.
@@ -96,10 +96,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         1,
-        encryptionGroups.at(1).encoding().end(),
-        encryptionGroups.at(1).encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        encryptionGroups.at(1).encoding().cend(),
+        encryptionGroups.at(1).encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted end iterator.
@@ -107,10 +107,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   encryptionGroups[1].add_encoding();
   // footer [e]
@@ -120,10 +120,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(footer.encoding().begin(), iter.current_);
-    EXPECT_EQ(footer.encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(footer.encoding().cbegin(), iter.current_);
+    EXPECT_EQ(footer.encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted iterator.
@@ -131,10 +131,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().begin(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cbegin(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted iterator.
@@ -142,10 +142,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         0,
-        encryptionGroups.at(0).encoding().begin(),
-        encryptionGroups.at(0).encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().begin(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        encryptionGroups.at(0).encoding().cbegin(),
+        encryptionGroups.at(0).encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cbegin(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // A valid end iterator.
@@ -153,10 +153,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         1,
-        encryptionGroups.at(1).encoding().end(),
-        encryptionGroups.at(1).encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        encryptionGroups.at(1).encoding().cend(),
+        encryptionGroups.at(1).encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   footer.Clear();
   // footer []
@@ -167,10 +167,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().begin(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().begin(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cbegin(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cbegin(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted iterator further back.
@@ -178,10 +178,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().begin(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cbegin(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   encryptionGroups.at(1).Clear();
   // footer []
@@ -192,10 +192,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         0,
-        encryptionGroups.at(0).encoding().end(),
-        encryptionGroups.at(0).encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        encryptionGroups.at(0).encoding().cend(),
+        encryptionGroups.at(0).encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
   {
     // An adjusted end iterator further back.
@@ -203,10 +203,10 @@ TEST(TestEncodingIter, Ctor) {
         footer,
         encryptionGroups,
         -1,
-        footer.encoding().end(),
-        footer.encoding().end()};
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.current_);
-    EXPECT_EQ(encryptionGroups.at(1).encoding().end(), iter.currentEnd_);
+        footer.encoding().cend(),
+        footer.encoding().cend()};
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.current_);
+    EXPECT_EQ(encryptionGroups.at(1).encoding().cend(), iter.currentEnd_);
   }
 }
 
@@ -227,15 +227,15 @@ TEST(TestEncodingIter, EncodingIterBeginAndEnd) {
       footer,
       encryptionGroups,
       -1,
-      footer.encoding().begin(),
-      footer.encoding().end()};
+      footer.encoding().cbegin(),
+      footer.encoding().cend()};
   EXPECT_EQ(begin, EncodingIter::begin(footer, encryptionGroups));
   EncodingIter end{
       footer,
       encryptionGroups,
       1,
-      encryptionGroups.at(1).encoding().end(),
-      encryptionGroups.at(1).encoding().end()};
+      encryptionGroups.at(1).encoding().cend(),
+      encryptionGroups.at(1).encoding().cend()};
   EXPECT_EQ(end, EncodingIter::end(footer, encryptionGroups));
 }
 
diff --git a/velox/dwio/dwrf/test/FlushPolicyTest.cpp b/velox/dwio/dwrf/test/FlushPolicyTest.cpp
index ed10f458aa2b..b045326664e9 100644
--- a/velox/dwio/dwrf/test/FlushPolicyTest.cpp
+++ b/velox/dwio/dwrf/test/FlushPolicyTest.cpp
@@ -51,8 +51,9 @@ TEST_F(DefaultFlushPolicyTest, StripeProgressTest) {
         testCase.stripeSizeThreshold, /*dictionarySizeThreshold=*/0};
     EXPECT_EQ(
         testCase.shouldFlush,
-        policy.shouldFlush(dwio::common::StripeProgress{
-            .stripeSizeEstimate = testCase.stripeSize}));
+        policy.shouldFlush(
+            dwio::common::StripeProgress{
+                .stripeSizeEstimate = testCase.stripeSize}));
   }
 }
 
@@ -115,8 +116,8 @@ TEST_F(DefaultFlushPolicyTest, AdditionalCriteriaTest) {
           .dictionarySize = 42,
           .decision = FlushDecision::SKIP}};
   for (const auto& testCase : testCases) {
-    DefaultFlushPolicy policy{
-        /*stripeSizeThreshold=*/1000, testCase.dictionarySizeThreshold};
+    DefaultFlushPolicy policy{/*stripeSizeThreshold=*/1000,
+                              testCase.dictionarySizeThreshold};
     EXPECT_EQ(
         testCase.decision,
         policy.shouldFlushDictionary(
diff --git a/velox/dwio/dwrf/test/IndexBuilderTests.cpp b/velox/dwio/dwrf/test/IndexBuilderTests.cpp
index 66969d007905..ee5914e236af 100644
--- a/velox/dwio/dwrf/test/IndexBuilderTests.cpp
+++ b/velox/dwio/dwrf/test/IndexBuilderTests.cpp
@@ -25,17 +25,17 @@ namespace facebook::velox::dwrf {
 
 class IndexBuilderTest : public testing::Test {
  protected:
-  static const proto::RowIndexEntry& getEntry(
+  static const RowIndexEntryWriteWrapper getEntry(
       IndexBuilder& builder,
       size_t index) {
-    return *builder.getEntry(index);
+    return builder.getEntry(index);
   }
 
   static std::vector<uint64_t> getPositions(
       IndexBuilder& builder,
       size_t index) {
-    auto& positions = builder.getEntry(index)->positions();
-    return std::vector<uint64_t>{positions.begin(), positions.end()};
+    auto& positions = builder.getEntry(index).positions();
+    return std::vector<uint64_t>{positions.cbegin(), positions.cend()};
   }
 
   StatisticsBuilderOptions options_{16};
@@ -45,7 +45,7 @@ TEST_F(IndexBuilderTest, Constructor) {
   IndexBuilder builder{nullptr};
   EXPECT_EQ(1, builder.getEntrySize());
   // Ensure a clean start.
-  EXPECT_EQ(0, getEntry(builder, 0).positions_size());
+  EXPECT_EQ(0, getEntry(builder, 0).positionsSize());
 }
 
 TEST_F(IndexBuilderTest, AddEntry) {
@@ -65,8 +65,8 @@ TEST_F(IndexBuilderTest, AddEntry) {
   ASSERT_EQ(51, builder.getEntrySize());
   for (size_t i = 0; i != 50; ++i) {
     // The newly added entries should be empty.
-    EXPECT_EQ(0, getEntry(builder, i + 1).positions_size());
-    EXPECT_TRUE(getEntry(builder, i).has_statistics());
+    EXPECT_EQ(0, getEntry(builder, i + 1).positionsSize());
+    EXPECT_TRUE(getEntry(builder, i).hasStatistics());
   }
 }
 
@@ -94,9 +94,9 @@ TEST_F(IndexBuilderTest, Backfill) {
   IndexBuilder builder{nullptr};
   StatisticsBuilder sb{options_};
   builder.addEntry(sb);
-  ASSERT_EQ(0, getEntry(builder, 0).positions_size());
+  ASSERT_EQ(0, getEntry(builder, 0).positionsSize());
   builder.add(0uL);
-  ASSERT_EQ(0, getEntry(builder, 0).positions_size());
+  ASSERT_EQ(0, getEntry(builder, 0).positionsSize());
   ASSERT_THAT(getPositions(builder, 1), ElementsAreArray({0uL}));
 
   builder.add(42uL, 0);
@@ -112,16 +112,16 @@ TEST_F(IndexBuilderTest, Backfill) {
     builder.addEntry(sb);
   }
   for (size_t i = 2; i != 7; ++i) {
-    ASSERT_EQ(0, getEntry(builder, i).positions_size());
+    ASSERT_EQ(0, getEntry(builder, i).positionsSize());
   }
   builder.add(144uL, 4);
   EXPECT_THAT(getPositions(builder, 0), ElementsAreArray({42uL}));
   EXPECT_THAT(getPositions(builder, 1), ElementsAreArray({0uL, 0uL, 7uL}));
-  ASSERT_EQ(0, getEntry(builder, 2).positions_size());
-  ASSERT_EQ(0, getEntry(builder, 3).positions_size());
+  ASSERT_EQ(0, getEntry(builder, 2).positionsSize());
+  ASSERT_EQ(0, getEntry(builder, 3).positionsSize());
   EXPECT_THAT(getPositions(builder, 4), ElementsAreArray({144uL}));
-  ASSERT_EQ(0, getEntry(builder, 5).positions_size());
-  ASSERT_EQ(0, getEntry(builder, 6).positions_size());
+  ASSERT_EQ(0, getEntry(builder, 5).positionsSize());
+  ASSERT_EQ(0, getEntry(builder, 6).positionsSize());
 }
 
 TEST_F(IndexBuilderTest, RemovePresentStreamPositions) {
diff --git a/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp b/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
index 644ddab0c587..e79fa02bf759 100644
--- a/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
+++ b/velox/dwio/dwrf/test/IntEncoderBenchmark.cpp
@@ -117,8 +117,9 @@ FOLLY_ALWAYS_INLINE static int32_t findSetBitsNew(uint64_t value) {
     case 57 ... 63:
       return 1;
   }
-  DWIO_RAISE(folly::sformat(
-      "Unexpected leading zeros {} for value {}", leadingZeros, value));
+  DWIO_RAISE(
+      folly::sformat(
+          "Unexpected leading zeros {} for value {}", leadingZeros, value));
 }
 
 size_t iters = 2000;
diff --git a/velox/dwio/dwrf/test/LayoutPlannerTests.cpp b/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
index a2de14e8e91f..32cf1a5062bd 100644
--- a/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
+++ b/velox/dwio/dwrf/test/LayoutPlannerTests.cpp
@@ -128,12 +128,12 @@ TEST_F(LayoutPlannerTest, Basic) {
                          uint32_t seq,
                          proto::ColumnEncoding_Kind kind,
                          std::optional<int64_t> key = std::nullopt) {
-    auto& encoding = encodingManager.addEncodingToFooter(node);
-    encoding.set_node(node);
-    encoding.set_sequence(seq);
-    encoding.set_kind(kind);
+    auto encoding = encodingManager.addEncodingToFooter(node);
+    encoding.setNode(node);
+    encoding.setSequence(seq);
+    encoding.setKind(ColumnEncodingKindWrapper(&kind));
     if (key.has_value()) {
-      encoding.mutable_key()->set_intkey(*key);
+      encoding.mutableKey()->set_intkey(*key);
     }
   };
 
diff --git a/velox/dwio/dwrf/test/OrcTest.h b/velox/dwio/dwrf/test/OrcTest.h
index 3bd87c45f075..6b0b3987ac2c 100644
--- a/velox/dwio/dwrf/test/OrcTest.h
+++ b/velox/dwio/dwrf/test/OrcTest.h
@@ -28,8 +28,6 @@
 
 namespace facebook::velox::dwrf {
 
-#define VELOX_ARRAY_SIZE(array) (sizeof(array) / sizeof(*array))
-
 using MemoryPool = memory::MemoryPool;
 
 inline std::string getExampleFilePath(const std::string& fileName) {
diff --git a/velox/dwio/dwrf/test/ReaderBaseTests.cpp b/velox/dwio/dwrf/test/ReaderBaseTests.cpp
index 04f0685c2521..8afd8b5e643e 100644
--- a/velox/dwio/dwrf/test/ReaderBaseTests.cpp
+++ b/velox/dwio/dwrf/test/ReaderBaseTests.cpp
@@ -16,7 +16,9 @@
 
 #include <gtest/gtest.h>
 #include <cstring>
+
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/InputStream.h"
 #include "velox/dwio/common/encryption/TestProvider.h"
 #include "velox/dwio/common/exception/Exception.h"
@@ -72,14 +74,14 @@ class EncryptedStatsTest : public Test {
     TestEncrypter encrypter;
     HiveTypeParser parser;
     auto type = parser.parse("struct<a:int,b:struct<a:int,b:int>,c:int,d:int>");
-    auto footer =
-        google::protobuf::Arena::CreateMessage<proto::Footer>(&arena_);
+    auto footer = ArenaCreate<proto::Footer>(&arena_);
+    auto footerWrapper = FooterWriteWrapper(footer);
     // add empty stats to the file
     for (size_t i = 0; i < 7; ++i) {
-      footer->add_statistics()->set_numberofvalues(i);
+      footerWrapper.addStatistics().setNumberOfValues(i);
     }
-    ProtoUtils::writeType(*type, *footer);
-    auto enc = footer->mutable_encryption();
+    ProtoUtils::writeType(*type, footerWrapper);
+    auto enc = footerWrapper.mutableEncryption();
     enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
     auto group = enc->add_encryptiongroups();
     group->add_nodes(1);
@@ -107,7 +109,7 @@ class EncryptedStatsTest : public Test {
         *readerPool_,
         std::make_unique<BufferedInput>(readFile, *readerPool_),
         std::make_unique<PostScript>(std::move(ps)),
-        footer,
+        footerWrapper.getDwrfPtr(),
         nullptr,
         std::move(handler));
   }
diff --git a/velox/dwio/dwrf/test/ReaderTest.cpp b/velox/dwio/dwrf/test/ReaderTest.cpp
index b132757ee54f..6dcb1896e8b2 100644
--- a/velox/dwio/dwrf/test/ReaderTest.cpp
+++ b/velox/dwio/dwrf/test/ReaderTest.cpp
@@ -18,8 +18,11 @@
 #include <gtest/gtest.h>
 #include "folly/Random.h"
 #include "folly/executors/CPUThreadPoolExecutor.h"
+#include "folly/executors/IOThreadPoolExecutor.h"
 #include "folly/lang/Assume.h"
+#include "folly/synchronization/Baton.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/ExecutorBarrier.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
@@ -27,6 +30,7 @@
 #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/ComplexVector.h"
 #include "velox/vector/FlatVector.h"
@@ -38,14 +42,14 @@
 #include <memory>
 #include <numeric>
 
+namespace facebook::velox::dwrf {
+namespace {
+
 using namespace ::testing;
 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 {
 const std::string& getStructFile() {
   static const std::string structFile_ = getExampleFilePath("struct.orc");
   return structFile_;
@@ -80,6 +84,7 @@ class TestReaderP
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    facebook::velox::common::testutil::TestValue::enable();
   }
 
   folly::Executor* executor() {
@@ -102,6 +107,7 @@ class TestReader : public testing::Test, public VectorTestBase {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    facebook::velox::common::testutil::TestValue::enable();
   }
 
   std::vector<VectorPtr> createBatches(
@@ -116,8 +122,6 @@ class TestReader : public testing::Test, public VectorTestBase {
   }
 };
 
-} // namespace
-
 TEST_F(TestReader, testWriterVersions) {
   EXPECT_EQ("original", writerVersionToString(ORIGINAL));
   EXPECT_EQ("dwrf-4.9", writerVersionToString(DWRF_4_9));
@@ -823,7 +827,7 @@ TEST_F(TestReader, testEstimatedSize) {
     rowReaderOpts.select(cs);
 
     auto rowReader = reader->createRowReader(rowReaderOpts);
-    ASSERT_EQ(rowReader->estimatedRowSize(), 79);
+    ASSERT_EQ(rowReader->estimatedRowSize(), 67);
   }
 
   {
@@ -835,7 +839,7 @@ TEST_F(TestReader, testEstimatedSize) {
     RowReaderOptions rowReaderOpts;
     rowReaderOpts.select(cs);
     auto rowReader = reader->createRowReader(rowReaderOpts);
-    ASSERT_EQ(rowReader->estimatedRowSize(), 13);
+    ASSERT_EQ(rowReader->estimatedRowSize(), 4);
   }
 }
 
@@ -1053,8 +1057,9 @@ TEST_F(TestReader, testMismatchSchemaMoreFields) {
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:int,b:struct<a:int,b:float,c:string>,c:float,d:string>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<uint64_t>{1, 2, 3}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<uint64_t>{1, 2, 3}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -1098,8 +1103,9 @@ TEST_F(TestReader, testMismatchSchemaFewerFields) {
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:int,b:struct<a:int,b:float,c:string>>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<uint64_t>{1}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<uint64_t>{1}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -1140,8 +1146,9 @@ TEST_F(TestReader, testMismatchSchemaNestedMoreFields) {
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:int,b:struct<a:int,b:float,c:string,d:binary>,c:float>"));
   LOG(INFO) << requestedType->toString();
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<std::string>{"b.b", "b.c", "b.d", "c"}));
+  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.memoryPool()),
       readerOpts);
@@ -1205,8 +1212,9 @@ TEST_F(TestReader, testMismatchSchemaNestedFewerFields) {
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:int,b:struct<a:int,b:float>,c:float>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<std::string>{"b.b", "c"}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<std::string>{"b.b", "c"}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -1262,8 +1270,9 @@ TEST_F(TestReader, testMismatchSchemaIncompatibleNotSelected) {
   std::shared_ptr<const RowType> requestedType =
       std::dynamic_pointer_cast<const RowType>(HiveTypeParser().parse(
           "struct<a:float,b:struct<a:string,b:float>,c:int>"));
-  rowReaderOpts.select(std::make_shared<ColumnSelector>(
-      requestedType, std::vector<std::string>{"b.b"}));
+  rowReaderOpts.select(
+      std::make_shared<ColumnSelector>(
+          requestedType, std::vector<std::string>{"b.b"}));
   auto reader = DwrfReader::create(
       createFileBufferedInput(getStructFile(), readerOpts.memoryPool()),
       readerOpts);
@@ -2269,24 +2278,25 @@ TEST_F(TestReader, failToReuseReaderNulls) {
 TEST_F(TestReader, readFlatMapsSomeEmpty) {
   // Test reading a flat map where the key filter means that some maps are
   // empty.
-  auto keys = makeFlatVector(std::vector<int64_t>{
-      1,
-      2,
-      3,
-      4,
-      5,
-      6, // map 1 has more than just the selected keys.
-      1,
-      2,
-      3, // map 2 has only selected keys.
-      4,
-      5,
-      6, // map 3 has no selected keys.
-      1,
-      2,
-      5,
-      6 // map 4 has some selected keys.
-  });
+  auto keys = makeFlatVector(
+      std::vector<int64_t>{
+          1,
+          2,
+          3,
+          4,
+          5,
+          6, // map 1 has more than just the selected keys.
+          1,
+          2,
+          3, // map 2 has only selected keys.
+          4,
+          5,
+          6, // map 3 has no selected keys.
+          1,
+          2,
+          5,
+          6 // map 4 has some selected keys.
+      });
   auto values = makeFlatVector<int64_t>(16, folly::identity);
   auto maps =
       makeMapVector(std::vector<vector_size_t>{0, 6, 9, 12, 16}, keys, values);
@@ -2412,6 +2422,66 @@ TEST_F(TestReader, readFlatMapsWithNullMaps) {
   }
 }
 
+TEST_F(TestReader, readFlatMapsAsFlatMaps) {
+  auto testRoundTrip = [&](const FlatMapVectorPtr& flatMap) {
+    auto input = makeRowVector({flatMap->toMapVector()});
+
+    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({input}, pool(), config);
+
+    auto schema = asRowType(input->type());
+    auto spec = std::make_shared<common::ScanSpec>("<root>");
+    spec->addAllChildFields(*schema);
+
+    RowReaderOptions rowReaderOpts;
+    rowReaderOpts.setScanSpec(spec);
+    rowReaderOpts.setPreserveFlatMapsInMemory(true);
+
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+    VectorPtr batch = BaseVector::create(schema, 0, pool());
+
+    rowReader->next(flatMap->size(), batch);
+    auto rowVector = batch->as<RowVector>();
+    auto resultMaps = rowVector->childAt(0);
+
+    assertEqualVectors(flatMap, resultMaps);
+  };
+
+  testRoundTrip(
+      makeFlatMapVector<int16_t, float>({
+          {},
+          {{1, 1.9}, {2, 2.1}, {0, 3.12}},
+          {{127, 0.12}},
+      }));
+
+  testRoundTrip(
+      makeFlatMapVector<StringView, StringView>({
+          {{"a", "a1"}},
+          {{"b", "b1"}},
+          {{"c", "c1"}},
+          {{"d", "d1"}},
+      }));
+
+  testRoundTrip(
+      makeNullableFlatMapVector<int32_t, int32_t>({
+          {{{101, 1}, {102, 2}, {103, 3}}},
+          {{{105, 0}, {106, 0}}},
+          {std::nullopt},
+          {{{101, 11}, {103, 13}, {105, std::nullopt}}},
+          {{{101, 1}, {102, 2}, {103, 3}}},
+      }));
+
+  testRoundTrip(
+      makeFlatMapVector<int64_t, int64_t>(
+          {{{0, 0}, {1, 1}, {2, 2}, {3, 3}},
+           {{0, 4}, {1, 5}, {2, 6}, {3, 7}},
+           {{0, 8}, {1, 9}, {2, 10}, {3, 11}},
+           {{0, 12}, {1, 13}, {2, 14}, {3, 15}}}));
+}
+
 TEST_F(TestReader, readStructWithWholeBatchFiltered) {
   // Test reading a struct with a pushdown filter that filters out all rows
   // for a certain batch.
@@ -2511,8 +2581,9 @@ TEST_F(TestReader, readStringDictionaryAsFlat) {
   dwio::common::RuntimeStatistics stats;
   rowReader->updateRuntimeStats(stats);
   ASSERT_EQ(stats.columnReaderStatistics.flattenStringDictionaryValues, 0);
-  spec->childByName("c0")->setFilter(std::make_unique<common::BytesValues>(
-      std::vector<std::string>{"aaaaaaaaaaaaaaaaaaaa"}, false));
+  spec->childByName("c0")->setFilter(
+      std::make_unique<common::BytesValues>(
+          std::vector<std::string>{"aaaaaaaaaaaaaaaaaaaa"}, false));
   spec->resetCachedValues(true);
   rowReader = reader->createRowReader(rowReaderOpts);
   ASSERT_EQ(rowReader->next(20, actual), 20);
@@ -2665,3 +2736,188 @@ TEST_F(TestReader, skipLongString) {
     validate(batch);
   }
 }
+
+TEST_F(TestReader, mapAsStruct) {
+  auto row = makeRowVector({
+      makeMapVector<int32_t, int64_t>({{{1, 4}, {2, 5}}, {{1, 6}, {3, 7}}}),
+  });
+  auto [writer, reader] = createWriterReader({row}, pool());
+  auto outType = ROW({"c0"}, {ROW({"3", "1"}, BIGINT())});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*outType);
+  spec->childByName("c0")->setFlatMapAsStruct(true);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr batch = BaseVector::create(outType, 0, pool());
+  ASSERT_EQ(rowReader->next(10, batch), 2);
+  auto expected = makeRowVector({
+      makeRowVector(
+          {"3", "1"},
+          {
+              makeNullableFlatVector<int64_t>({std::nullopt, 7}),
+              makeFlatVector<int64_t>({4, 6}),
+          }),
+  });
+  assertEqualVectors(expected, batch);
+}
+
+TEST_F(TestReader, mapAsStructFilterAfterRead) {
+  auto row = makeRowVector({
+      makeMapVector<int32_t, int64_t>({{{1, 4}, {2, 5}}, {}, {{1, 6}, {3, 7}}}),
+      makeRowVector(
+          {makeConstant<int64_t>(0, 3)}, [](auto i) { return i == 0; }),
+  });
+  auto [writer, reader] = createWriterReader({row}, pool());
+  auto outType =
+      ROW({"c0", "c1"}, {ROW({"3", "1"}, BIGINT()), ROW({"c0"}, BIGINT())});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*outType);
+  auto* c0Spec = spec->childByName("c0");
+  c0Spec->setFlatMapAsStruct(true);
+  c0Spec->setFilter(std::make_shared<common::IsNotNull>());
+  spec->childByName("c1")->setFilter(std::make_shared<common::IsNotNull>());
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr batch = BaseVector::create(outType, 0, pool());
+  ASSERT_EQ(rowReader->next(10, batch), 3);
+  auto expected = makeRowVector({
+      makeRowVector(
+          {"3", "1"},
+          {
+              makeNullableFlatVector<int64_t>({std::nullopt, 7}),
+              makeNullableFlatVector<int64_t>({std::nullopt, 6}),
+          }),
+      makeRowVector({makeConstant<int64_t>(0, 2)}),
+  });
+  assertEqualVectors(expected, batch);
+}
+
+TEST_F(TestReader, mapAsStructAllEmpty) {
+  auto row = makeRowVector({makeMapVector<int32_t, int64_t>({{}, {}})});
+  auto [writer, reader] = createWriterReader({row}, pool());
+  auto outType = ROW({"c0"}, {ROW({"1"}, BIGINT())});
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addAllChildFields(*outType);
+  spec->childByName("c0")->setFlatMapAsStruct(true);
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.setScanSpec(spec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+  VectorPtr batch = BaseVector::create(outType, 0, pool());
+  ASSERT_EQ(rowReader->next(10, batch), 2);
+  auto expected = makeRowVector({
+      makeRowVector({"1"}, {makeNullConstant(TypeKind::BIGINT, 2)}),
+  });
+  assertEqualVectors(expected, batch);
+}
+
+// Verify DwrfRowReader can be destroyed while ParallelUnitLoader async load()
+// are in progress. This regression test ensures that:
+// 1. ParallelUnitLoader destructor doesn't wait for async load() operations
+// 2. Async load() from DwrfUnit can still function after ParallelUnitLoader
+// destruction and DwrfRowReader destruction, which means all dependencies in
+// DwrfUnit remain valid (eg ReaderBase)
+//
+// If a future change adds an unsafe raw pointer to DwrfUnit's dependencies that
+// would be freed by ParallelUnitLoader or DwrfRowReader's destruction, this
+// test may crash due to use-after-free.
+DEBUG_ONLY_TEST_F(TestReader, asyncLoadSurvivesReaderDestruction) {
+  const int kNumStripes = 2;
+  const int kRowsPerStripe = 100;
+  std::vector<VectorPtr> batches;
+  batches.reserve(kNumStripes);
+  for (int stripe = 0; stripe < kNumStripes; ++stripe) {
+    batches.push_back(makeRowVector({
+        makeFlatVector<int64_t>(
+            kRowsPerStripe,
+            [stripe](auto row) { return stripe * kRowsPerStripe + row; }),
+    }));
+  }
+
+  // Write the DWRF file - force each batch into its own stripe
+  auto config = std::make_shared<dwrf::Config>();
+
+  auto sink =
+      std::make_unique<MemorySink>(1 << 20, FileSink::Options{.pool = pool()});
+  auto* sinkPtr = sink.get();
+  auto writer = E2EWriterTestUtil::writeData(
+      std::move(sink),
+      asRowType(batches[0]->type()),
+      batches,
+      config,
+      // Force flush after each batch to create separate stripes
+      E2EWriterTestUtil::simpleFlushPolicyFactory(true));
+
+  std::string data(sinkPtr->data(), sinkPtr->size());
+  auto input = std::make_unique<BufferedInput>(
+      std::make_shared<InMemoryReadFile>(std::move(data)), *pool());
+
+  std::atomic<int> asyncLoadsStarted{0};
+  std::atomic<int> asyncLoadsCompleted{0};
+  folly::Baton<> readerDestroyed;
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::dwio::common::ParallelUnitLoader::load",
+      std::function<void(void*)>([&](void*) {
+        // Only block the second stripe (index 1) - let the first stripe load
+        // normally so rowReader->next() can complete
+        // fetch_add returns the value before increment: 0 for first, 1 for
+        // second, etc.
+        if (asyncLoadsStarted.fetch_add(1) == 1) {
+          // Block here until reader is destroyed
+          readerDestroyed.wait();
+        }
+        asyncLoadsCompleted.fetch_add(1);
+      }));
+
+  auto ioExecutor = std::make_shared<folly::IOThreadPoolExecutor>(2);
+
+  // Make sure ReaderOptions and DwrfRowReader are freed after {} scope
+  {
+    dwio::common::ReaderOptions readerOpts(pool());
+    readerOpts.setFileFormat(FileFormat::DWRF);
+    auto reader = DwrfReader::create(std::move(input), readerOpts);
+
+    // Enable parallel unit load
+    RowReaderOptions rowReaderOpts;
+    rowReaderOpts.setParallelUnitLoadCount(2);
+    rowReaderOpts.setIOExecutor(ioExecutor.get());
+    auto rowReader = reader->createRowReader(rowReaderOpts);
+
+    VectorPtr batch;
+    rowReader->next(50, batch); // Read first stripe
+
+    auto start = std::chrono::steady_clock::now();
+    rowReader.reset();
+    auto duration = std::chrono::steady_clock::now() - start;
+    // Verify destruction was fast (didn't wait for async operations)
+    EXPECT_LT(duration, std::chrono::seconds(1))
+        << "Destruction should not wait for async loads";
+  }
+
+  // Now signal that reader is destroyed
+  readerDestroyed.post();
+
+  // Wait for async loads to complete
+  int maxWaitMs = 2000;
+  int waitedMs = 0;
+  while (asyncLoadsCompleted.load() < 2 && waitedMs < maxWaitMs) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    waitedMs += 100;
+  }
+
+  // Verify that both async loads completed successfully after reader
+  // destruction This proves the fix works: async operations can complete even
+  // after DwrfRowReader is destroyed because LoadUnit is captured as shared_ptr
+  EXPECT_EQ(asyncLoadsCompleted.load(), 2)
+      << "Both async loads should complete even after reader destruction. "
+      << "If this fails, it means async operations are being cancelled or "
+      << "crashing after DwrfRowReader destruction, indicating unsafe pointers.";
+
+  // Clean up
+  ioExecutor->join();
+}
+
+} // namespace
+} // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp b/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
index 4091204ba960..acce6cbf5cdd 100644
--- a/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
+++ b/velox/dwio/dwrf/test/StripeReaderBaseTests.cpp
@@ -42,7 +42,8 @@ class StripeLoadKeysTest : public Test {
     HiveTypeParser parser;
     auto type = parser.parse("struct<a:int>");
     footer_ = std::make_unique<proto::Footer>();
-    ProtoUtils::writeType(*type, *footer_);
+    auto footerWrapper = FooterWriteWrapper(footer_.get());
+    ProtoUtils::writeType(*type, footerWrapper);
     auto enc = footer_->mutable_encryption();
     enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
     auto group = enc->add_encryptiongroups();
@@ -93,8 +94,8 @@ class StripeLoadKeysTest : public Test {
 
     handler_ = std::move(handler);
 
-    enc_ = const_cast<TestEncryption*>(
-        std::addressof(dynamic_cast<const TestEncryption&>(
+    enc_ = const_cast<TestEncryption*>(std::addressof(
+        dynamic_cast<const TestEncryption&>(
             handler_->getEncryptionProviderByIndex(0))));
   }
 
diff --git a/velox/dwio/dwrf/test/TestByteRle.cpp b/velox/dwio/dwrf/test/TestByteRle.cpp
index ad19d341a50a..94f8ecf9da68 100644
--- a/velox/dwio/dwrf/test/TestByteRle.cpp
+++ b/velox/dwio/dwrf/test/TestByteRle.cpp
@@ -39,9 +39,9 @@ std::unique_ptr<ByteRleDecoder> createBooleanDecoder(
 
 TEST(ByteRle, simpleTest) {
   const unsigned char buffer[] = {0x61, 0x00, 0xfd, 0x44, 0x45, 0x46};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer))));
   std::vector<char> data(103);
   rle->next(data.data(), data.size(), nullptr);
 
@@ -54,9 +54,9 @@ TEST(ByteRle, simpleTest) {
 }
 
 TEST(ByteRle, nullTest) {
-  char buffer[258];
-  uint64_t nulls[5];
-  char result[266];
+  char buffer[258] = {'\0'};
+  uint64_t nulls[5] = {'\0'};
+  char result[266] = {'\0'};
   buffer[0] = -128;
   buffer[129] = -128;
   for (int32_t i = 0; i < 128; ++i) {
@@ -66,8 +66,8 @@ TEST(ByteRle, nullTest) {
   for (int32_t i = 0; i < 266; ++i) {
     bits::setNull(nulls, i, i < 10);
   }
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
           new SeekableArrayInputStream(buffer, sizeof(buffer))));
   rle->next(result, sizeof(result), nulls);
   for (size_t i = 0; i < sizeof(result); ++i) {
@@ -93,9 +93,9 @@ TEST(ByteRle, literalCrossBuffer) {
       0x09,
       0x07,
       0x10};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 6)));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer), 6)));
   std::vector<char> data(20);
   rle->next(data.data(), data.size(), nullptr);
 
@@ -109,9 +109,9 @@ TEST(ByteRle, literalCrossBuffer) {
 
 TEST(ByteRle, skipLiteralBufferUnderflowTest) {
   const unsigned char buffer[] = {0xf8, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 4)));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer), 4)));
   std::vector<char> data(8);
   rle->next(data.data(), 3, nullptr);
   EXPECT_EQ(0x0, data[0]);
@@ -127,9 +127,9 @@ TEST(ByteRle, skipLiteralBufferUnderflowTest) {
 
 TEST(ByteRle, simpleRuns) {
   const unsigned char buffer[] = {0x0d, 0xff, 0x0d, 0xfe, 0x0d, 0xfd};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer))));
   std::vector<char> data(16);
   for (size_t i = 0; i < 3; ++i) {
     rle->next(data.data(), data.size(), nullptr);
@@ -145,9 +145,9 @@ TEST(ByteRle, splitHeader) {
       0x00, 0x01, 0xe0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
       0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
       0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 1)));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer), 1)));
   std::vector<char> data(35);
   rle->next(data.data(), data.size(), nullptr);
   for (size_t i = 0; i < 3; ++i) {
@@ -179,9 +179,9 @@ TEST(ByteRle, splitRuns) {
       0x0e,
       0x0f,
       0x10};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer))));
   std::vector<char> data(5);
   for (size_t i = 0; i < 3; ++i) {
     rle->next(data.data(), data.size(), nullptr);
@@ -227,9 +227,9 @@ TEST(ByteRle, testNulls) {
       0x0f,
       0x3d,
       0xdc};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 3)));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer), 3)));
   std::vector<char> data(16, -1);
   std::vector<uint64_t> nulls(1);
   for (size_t i = 0; i < data.size(); ++i) {
@@ -276,9 +276,9 @@ TEST(ByteRle, testAllNulls) {
       0x0f,
       0x3d,
       0xdc};
-  std::unique_ptr<ByteRleDecoder> rle =
-      createByteDecoder(std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+  std::unique_ptr<ByteRleDecoder> rle = createByteDecoder(
+      std::unique_ptr<SeekableInputStream>(
+          new SeekableArrayInputStream(buffer, std::size(buffer))));
   std::vector<char> data(16, -1);
   std::vector<uint64_t> allNull(1, bits::kNull64);
   std::vector<uint64_t> noNull(1, bits::kNotNull64);
@@ -413,7 +413,7 @@ TEST(ByteRle, testSkip) {
       0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
   };
   SeekableInputStream* const stream =
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer));
+      new SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<ByteRleDecoder> rle =
       createByteDecoder(std::unique_ptr<SeekableInputStream>(stream));
   std::vector<char> data(1);
@@ -570,7 +570,7 @@ TEST(ByteRle, testSeek) {
       0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
   };
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   const uint64_t fileLocs[] = {
       0,    0,    0,    0,    0,    2,    2,    2,    2,    4,    4,    4,
       4,    6,    6,    6,    6,    8,    8,    8,    8,    10,   10,   10,
@@ -907,7 +907,7 @@ TEST(ByteRle, testSeek) {
 
   // Seek to end
   std::vector<uint64_t> position;
-  position.push_back(VELOX_ARRAY_SIZE(buffer));
+  position.push_back(std::size(buffer));
   position.push_back(0);
   PositionProvider pp{position};
   rle->seekToRowGroup(pp);
@@ -916,7 +916,7 @@ TEST(ByteRle, testSeek) {
 
   // Seek to end + 1
   position.clear();
-  position.push_back(VELOX_ARRAY_SIZE(buffer));
+  position.push_back(std::size(buffer));
   position.push_back(1);
   PositionProvider pp2{position};
   rle->seekToRowGroup(pp2);
@@ -926,7 +926,7 @@ TEST(ByteRle, testSeek) {
 TEST(BooleanRle, simpleTest) {
   const unsigned char buffer[] = {0x61, 0xf0, 0xfd, 0x55, 0xAA, 0x55};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(50);
   for (size_t i = 0; i < 16; ++i) {
@@ -951,7 +951,7 @@ TEST(BooleanRle, runsTest) {
   const unsigned char buffer[] = {
       0xf7, 0xff, 0x80, 0x3f, 0xe0, 0x0f, 0xf8, 0x03, 0xfe, 0x00};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(72);
   rle->next(data.data(), data.size(), nullptr);
@@ -973,7 +973,7 @@ TEST(BooleanRle, runsTestWithNull) {
   const unsigned char buffer[] = {
       0xf7, 0xff, 0x80, 0x3f, 0xe0, 0x0f, 0xf8, 0x03, 0xfe, 0x00};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(72);
   std::vector<uint64_t> nulls(bits::nwords(data.size()), bits::kNotNull64);
@@ -1089,7 +1089,7 @@ TEST(BooleanRle, skipTest) {
       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)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(1);
   for (size_t i = 0; i < 16384; i += 5) {
@@ -1200,7 +1200,7 @@ TEST(BooleanRle, skipTestWithNulls) {
       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)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   raw_vector<char> data;
   data.resize(3);
@@ -1365,7 +1365,7 @@ TEST(BooleanRle, seekTest) {
       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)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
 
   // Read all 16384 values and validate them.
@@ -1501,7 +1501,7 @@ 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};
-  auto* stream = new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer));
+  auto* stream = new SeekableArrayInputStream(buffer, std::size(buffer));
   auto rle = createBooleanDecoder(std::unique_ptr<SeekableInputStream>(stream));
   ASSERT_EQ(stream->totalRead(), 0);
   auto lastTotalReadBytes = stream->totalRead();
@@ -1519,7 +1519,7 @@ TEST(BooleanRle, seekTestWithNulls) {
     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));
+  ASSERT_EQ(getNumReadBytes(), std::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;
@@ -1573,7 +1573,7 @@ TEST(BooleanRle, seekBoolAndByteRLE) {
       0xf9, 0xf0, 0xf0, 0xf7, 0x1c, 0x71, 0xc1, 0x80};
 
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   std::vector<char> data(sizeof(num) / sizeof(char));
   rle->next(data.data(), data.size(), nullptr);
@@ -1596,7 +1596,7 @@ TEST(BooleanRle, seekBoolAndByteRLE) {
 TEST(BooleanRle, skipToEnd) {
   const unsigned char buffer[] = {0xfe, 0xff, 0xff};
   std::unique_ptr<SeekableInputStream> stream(
-      new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer)));
+      new SeekableArrayInputStream(buffer, std::size(buffer)));
   std::unique_ptr<ByteRleDecoder> rle = createBooleanDecoder(std::move(stream));
   char value[1];
   rle->next(value, 1, nullptr);
diff --git a/velox/dwio/dwrf/test/TestColumnReader.cpp b/velox/dwio/dwrf/test/TestColumnReader.cpp
index da7b9f743f61..def2f28ea979 100644
--- a/velox/dwio/dwrf/test/TestColumnReader.cpp
+++ b/velox/dwio/dwrf/test/TestColumnReader.cpp
@@ -517,14 +517,14 @@ TEST_P(TestColumnReader, testBooleanWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(512 / 8)]
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // [0x0f for x in range(256 / 8)]
   const unsigned char buffer2[] = {0x1d, 0x0f};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:boolean>");
@@ -628,13 +628,13 @@ TEST_P(TestColumnReader, testBooleanSkipsWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(512 / 8)]
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
   // [0x0f for x in range(128 / 8)]
   const unsigned char buffer2[] = {0x1d, 0x0f};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:boolean>");
@@ -683,8 +683,8 @@ TEST_P(TestColumnReader, testByteWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(512 / 8)]
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // range(256)
   char buffer[258];
@@ -697,8 +697,8 @@ TEST_P(TestColumnReader, testByteWithNulls) {
     buffer[i + 2] = static_cast<char>(i);
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:tinyint>");
@@ -778,8 +778,8 @@ TEST_P(TestColumnReader, testByteSkipsWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(512 / 8)]
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // range(256)
   char buffer[258];
@@ -792,8 +792,8 @@ TEST_P(TestColumnReader, testByteSkipsWithNulls) {
     buffer[i + 2] = static_cast<char>(i);
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:tinyint>");
@@ -856,7 +856,7 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
   int32_t expects_col0[] = {2110, 2120, 2130, 2140};
   int32_t expects_col1[] = {11, 12, 13, 14};
   int32_t expects_col2[] = {32, 34, 36, 38};
-  int32_t size = VELOX_ARRAY_SIZE(col0);
+  int32_t size = std::size(col0);
 
   // set format
   streams_.setFormat(DwrfFormat::kOrc);
@@ -884,8 +884,8 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
   // col_0's DATA stream
   EXPECT_CALL(
       streams_, getStreamOrcProxy(1, proto::orc::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer0, VELOX_ARRAY_SIZE(buffer0))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer0, std::size(buffer0))));
   // col_1's DATA stream
   std::array<char, 1024> data;
   std::vector<int64_t> v;
@@ -903,8 +903,8 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
   // col_2's DATA stream
   EXPECT_CALL(
       streams_, getStreamOrcProxy(3, proto::orc::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType =
@@ -929,7 +929,7 @@ TEST_P(TestColumnReader, testIntegerRLEv2) {
     auto colBatch = getChild<FlatVector<int32_t>>(batch, 0);
     auto colBatch2 = getChild<FlatVector<int32_t>>(batch, 1);
     auto colBatch3 = getChild<FlatVector<int32_t>>(batch, 2);
-    ASSERT_EQ(VELOX_ARRAY_SIZE(expects_col0), colBatch->size());
+    ASSERT_EQ(std::size(expects_col0), colBatch->size());
     ASSERT_EQ(colBatch->size(), colBatch2->size());
     ASSERT_EQ(colBatch2->size(), colBatch3->size());
     for (size_t i = 0; i < batch->size(); ++i) {
@@ -972,8 +972,8 @@ TEST_P(TestColumnReader, testIntegerWithNulls) {
       .WillRepeatedly(Return(nullptr));
   const unsigned char buffer1[] = {0x16, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   char buffer2[1024];
   size_t size = writeRange(buffer2, 0, 100);
@@ -1091,8 +1091,8 @@ TEST_P(TestColumnReader, testIntDictSkipWithNulls) {
       .WillRepeatedly(Return(nullptr));
   const unsigned char buffer1[] = {0x16, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // even row points to dictionary.
   char buffer2[1024];
@@ -1108,8 +1108,8 @@ TEST_P(TestColumnReader, testIntDictSkipWithNulls) {
   const unsigned char buffer3[] = {0x0a, 0xaa};
   EXPECT_CALL(
       streams_, getStreamProxy(1, proto::Stream_Kind_IN_DICTIONARY, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   EXPECT_CALL(streams_, genMockDictDataSetter(1, 0))
       .WillRepeatedly(Return([&](BufferPtr& buffer, MemoryPool* pool) {
@@ -1249,21 +1249,21 @@ TEST_P(StringReaderTests, testDictionaryWithNulls) {
       .WillRepeatedly(Return(nullptr));
   const unsigned char buffer1[] = {0x19, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
   const unsigned char buffer2[] = {0x2f, 0x00, 0x00, 0x2f, 0x00, 0x01};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
   const unsigned char buffer3[] = {0x4f, 0x52, 0x43, 0x4f, 0x77, 0x65, 0x6e};
   EXPECT_CALL(
       streams_, getStreamProxy(1, proto::Stream_Kind_DICTIONARY_DATA, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
   const unsigned char buffer4[] = {0x02, 0x01, 0x03};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer4, VELOX_ARRAY_SIZE(buffer4))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer4, std::size(buffer4))));
 
   TestStrideIndexProvider provider(10000);
   EXPECT_CALL(streams_, getStrideIndexProviderProxy())
@@ -1395,8 +1395,8 @@ TEST_P(StringReaderTests, testStringDictSkipNoNulls) {
   const unsigned char inDict[] = {0x0a, 0xaa};
   EXPECT_CALL(
       streams_, getStreamProxy(1, proto::Stream_Kind_IN_DICTIONARY, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(inDict, VELOX_ARRAY_SIZE(inDict))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(inDict, std::size(inDict))));
 
   auto indexData = index.SerializePartialAsString();
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_ROW_INDEX, _))
@@ -1484,8 +1484,8 @@ TEST_P(StringReaderTests, testStringDictSkipWithNulls) {
       .WillRepeatedly(Return(nullptr));
   const unsigned char present[] = {0x16, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(present, VELOX_ARRAY_SIZE(present))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(present, std::size(present))));
 
   char data[1024];
   data[0] = 0x9c;
@@ -1565,8 +1565,8 @@ TEST_P(StringReaderTests, testStringDictSkipWithNulls) {
   const unsigned char inDict[] = {0x0a, 0xaa};
   EXPECT_CALL(
       streams_, getStreamProxy(1, proto::Stream_Kind_IN_DICTIONARY, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(inDict, VELOX_ARRAY_SIZE(inDict))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(inDict, std::size(inDict))));
 
   auto indexData = index.SerializePartialAsString();
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_ROW_INDEX, _))
@@ -1637,18 +1637,18 @@ TEST_P(TestNonSelectiveColumnReader, testSubstructsWithNulls) {
 
   const unsigned char buffer1[] = {0x16, 0x0f};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const unsigned char buffer2[] = {0x0a, 0x55};
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   const unsigned char buffer3[] = {0x04, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(3, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   char buffer4[256];
   size_t size = writeRange(buffer4, 0, 26);
@@ -1723,13 +1723,13 @@ TEST_P(TestColumnReader, testSkipWithNulls) {
   const unsigned char buffer1[] = {
       0x03, 0x00, 0xff, 0x3f, 0x08, 0xff, 0xff, 0xfc, 0x03, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
   EXPECT_CALL(streams_, getStreamProxy(2, _, _))
       .WillRepeatedly(Return(nullptr));
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   TestStrideIndexProvider provider(10000);
   EXPECT_CALL(streams_, getStrideIndexProviderProxy())
@@ -1741,8 +1741,8 @@ TEST_P(TestColumnReader, testSkipWithNulls) {
       .WillRepeatedly(Return(new SeekableArrayInputStream(buffer2, size)));
   const unsigned char buffer3[] = {0x61, 0x01, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   // fill the dictionary with '00' to '99'
   char digits[200];
@@ -1754,12 +1754,12 @@ TEST_P(TestColumnReader, testSkipWithNulls) {
   }
   EXPECT_CALL(
       streams_, getStreamProxy(2, proto::Stream_Kind_DICTIONARY_DATA, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(digits, VELOX_ARRAY_SIZE(digits))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(digits, std::size(digits))));
   const unsigned char buffer4[] = {0x61, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_LENGTH, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer4, VELOX_ARRAY_SIZE(buffer4))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer4, std::size(buffer4))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myInt:int,myString:string>");
@@ -1838,12 +1838,12 @@ TEST_P(StringReaderTests, testBinaryDirect) {
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(
-          Return(new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob))));
+          Return(new SeekableArrayInputStream(blob, std::size(blob))));
 
   const unsigned char buffer[] = {0x61, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:binary>");
@@ -1892,8 +1892,8 @@ TEST_P(StringReaderTests, testBinaryDirectWithNulls) {
 
   const unsigned char buffer1[] = {0x1d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   char blob[256];
   for (size_t i = 0; i < 8; ++i) {
@@ -1904,12 +1904,12 @@ TEST_P(StringReaderTests, testBinaryDirectWithNulls) {
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(
-          Return(new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob))));
+          Return(new SeekableArrayInputStream(blob, std::size(blob))));
 
   const unsigned char buffer2[] = {0x7d, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:binary>");
@@ -1969,12 +1969,12 @@ TEST_P(TestColumnReader, testShortBlobError) {
   char blob[100];
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(
-          Return(new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob))));
+          Return(new SeekableArrayInputStream(blob, std::size(blob))));
 
   const unsigned char buffer1[] = {0x61, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2020,13 +2020,13 @@ TEST_P(StringReaderTests, testStringDirectShortBuffer) {
     }
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob), 3)));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(blob, std::size(blob), 3)));
 
   const unsigned char buffer1[] = {0x61, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2075,8 +2075,8 @@ TEST_P(StringReaderTests, testStringDirectShortBufferWithNulls) {
 
   const unsigned char buffer1[] = {0x3d, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   char blob[512];
   for (size_t i = 0; i < 16; ++i) {
@@ -2086,13 +2086,13 @@ TEST_P(StringReaderTests, testStringDirectShortBufferWithNulls) {
     }
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob), 30)));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(blob, std::size(blob), 30)));
 
   const unsigned char buffer2[] = {0x7d, 0x00, 0x02, 0x7d, 0x00, 0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2154,19 +2154,19 @@ TEST_P(StringReaderTests, testStringDirectNullAcrossWindow) {
 
   const unsigned char isNull[2] = {0xff, 0x7f};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(isNull, VELOX_ARRAY_SIZE(isNull))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(isNull, std::size(isNull))));
 
   const char blob[] = "abcdefg";
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(blob, VELOX_ARRAY_SIZE(blob), 4)));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(blob, std::size(blob), 4)));
 
   // [1] * 7
   const unsigned char lenData[] = {0x04, 0x00, 0x01};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(lenData, VELOX_ARRAY_SIZE(lenData))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(lenData, std::size(lenData))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2250,8 +2250,8 @@ TEST_P(StringReaderTests, testStringDirectSkip) {
       0x01, 0x8a, 0x05, 0x7f, 0x01, 0x8c, 0x06, 0x7f, 0x01, 0x8e,
       0x07, 0x7f, 0x01, 0x90, 0x08, 0x1b, 0x01, 0x92, 0x09};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2298,8 +2298,8 @@ TEST_P(StringReaderTests, testStringDirectSkipWithNulls) {
   // alternate 4 non-null and 4 null via [0xf0 for x in range(2400 / 8)]
   const unsigned char buffer1[] = {0x7f, 0xf0, 0x7f, 0xf0, 0x25, 0xf0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // sum(range(1200))
   const size_t BLOB_SIZE = 719400;
@@ -2323,8 +2323,8 @@ TEST_P(StringReaderTests, testStringDirectSkipWithNulls) {
       0x01, 0x8a, 0x05, 0x7f, 0x01, 0x8c, 0x06, 0x7f, 0x01, 0x8e,
       0x07, 0x7f, 0x01, 0x90, 0x08, 0x1b, 0x01, 0x92, 0x09};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:string>");
@@ -2386,8 +2386,8 @@ TEST_P(TestColumnReader, testList) {
       0x00,
       0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // range(1200)
   char buffer2[8192];
@@ -2435,8 +2435,8 @@ TEST_P(TestNonSelectiveColumnReader, testListPropagateNulls) {
   // set getStream
   const unsigned char buffer[] = {0xff, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_LENGTH, true))
       .WillRepeatedly(Return(new SeekableArrayInputStream(buffer, 0)));
@@ -2477,8 +2477,8 @@ TEST_P(TestNonSelectiveColumnReader, testListWithNulls) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(nullptr));
@@ -2493,8 +2493,8 @@ TEST_P(TestNonSelectiveColumnReader, testListWithNulls) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // range(2048)
   char buffer3[8192];
@@ -2636,8 +2636,8 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNulls) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(nullptr));
@@ -2652,8 +2652,8 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNulls) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // range(2048)
   char buffer3[8192];
@@ -2737,8 +2737,8 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNullsNoData) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(nullptr));
@@ -2753,8 +2753,8 @@ TEST_P(TestNonSelectiveColumnReader, testListSkipWithNullsNoData) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(Return(nullptr));
@@ -2815,8 +2815,8 @@ TEST_P(TestNonSelectiveColumnReader, testListWithAllNulls) {
   // set getStream
   const unsigned char buffer[] = {0xff, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer, std::size(buffer))));
 
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
       .WillRepeatedly(Return(new SeekableArrayInputStream(buffer, 0)));
@@ -2869,8 +2869,8 @@ TEST_P(TestColumnReader, testMap) {
       0x00,
       0x02};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // range(1200)
   char buffer2[8192];
@@ -2926,8 +2926,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithNulls) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(2, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(nullptr));
@@ -2935,8 +2935,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithNulls) {
   // [0x55 for x in range(2048/8)]
   const unsigned char buffer2[] = {0x7f, 0x55, 0x7b, 0x55};
   EXPECT_CALL(streams_, getStreamProxy(3, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // [1 for x in range(260)] +
   // [4 for x in range(260)] +
@@ -2948,8 +2948,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithNulls) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   // range(2048)
   char buffer4[8192];
@@ -3131,8 +3131,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNulls) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // [1 for x in range(260)] +
   // [4 for x in range(260)] +
@@ -3144,8 +3144,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNulls) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // range(2048)
   char buffer3[8192];
@@ -3254,8 +3254,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNullsNoData) {
   // [0xaa for x in range(2048/8)]
   const unsigned char buffer1[] = {0x7f, 0xaa, 0x7b, 0xaa};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // [1 for x in range(260)] +
   // [4 for x in range(260)] +
@@ -3267,8 +3267,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapSkipWithNullsNoData) {
                                    0x00, 0x7f, 0x00, 0x00, 0x7f, 0x00, 0x03,
                                    0x6e, 0x00, 0x03, 0xff, 0x13};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col0:map<bigint,bigint>>");
@@ -3322,8 +3322,8 @@ TEST_P(TestNonSelectiveColumnReader, testMapWithAllNulls) {
 
   const unsigned char buffer1[] = {0xff, 0x00};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
       .WillRepeatedly(Return(new SeekableArrayInputStream(buffer1, 0)));
@@ -3365,9 +3365,7 @@ TEST_P(TestColumnReader, testFloatBatchNotAligned) {
 
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
       .WillRepeatedly(Return(new SeekableArrayInputStream(
-          byteValues,
-          VELOX_ARRAY_SIZE(byteValues),
-          VELOX_ARRAY_SIZE(byteValues) / 2)));
+          byteValues, std::size(byteValues), std::size(byteValues) / 2)));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myFloat:float>");
@@ -3403,8 +3401,8 @@ TEST_P(TestColumnReader, testFloatWithNulls) {
   // 13 non-nulls followed by 19 nulls
   const unsigned char buffer1[] = {0xfc, 0xff, 0xf8, 0x0, 0x0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const float test_vals[] = {
       1.0f,
@@ -3427,8 +3425,8 @@ TEST_P(TestColumnReader, testFloatWithNulls) {
       0x0,  0x80, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0xff, 0xff, 0x7f, 0xff,
       0x1,  0x0,  0x0,  0x0,  0x1,  0x0,  0x0,  0x80};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myFloat:float>");
@@ -3472,8 +3470,8 @@ TEST_P(TestColumnReader, testFloatSkipWithNulls) {
   // 2 non-nulls, 2 nulls, 2 non-nulls, 2 nulls
   const unsigned char buffer1[] = {0xff, 0xcc};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // 1, 2.5, -100.125, 10000
   const unsigned char buffer2[] = {
@@ -3494,8 +3492,8 @@ TEST_P(TestColumnReader, testFloatSkipWithNulls) {
       0x1c,
       0x46};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myFloat:float>");
@@ -3563,8 +3561,8 @@ TEST_P(TestColumnReader, testDoubleWithNulls) {
   // 13 non-nulls followed by 19 nulls
   const unsigned char buffer1[] = {0xfc, 0xff, 0xf8, 0x0, 0x0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const double test_vals[] = {
       1.0,
@@ -3591,8 +3589,8 @@ TEST_P(TestColumnReader, testDoubleWithNulls) {
       0xff, 0xff, 0xef, 0xff, 0x1,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
       0x1,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x80};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myDouble:double>");
@@ -3637,16 +3635,16 @@ TEST_P(TestColumnReader, testDoubleSkipWithNulls) {
   // 1 non-null, 5 nulls, 2 non-nulls
   const unsigned char buffer1[] = {0xff, 0x83};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // 1, 2, -2
   const unsigned char buffer2[] = {
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myDouble:double>");
@@ -3713,8 +3711,8 @@ TEST_P(TestColumnReader, testTimestampSkipWithNulls) {
   // 2 non-nulls, 2 nulls, 2 non-nulls, 2 nulls
   const unsigned char buffer1[] = {0xff, 0xcc};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const unsigned char buffer2[] = {
       0xfc,
@@ -3735,13 +3733,13 @@ TEST_P(TestColumnReader, testTimestampSkipWithNulls) {
       0xd4,
       0x30};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   const unsigned char buffer3[] = {0x1, 0x8, 0x5e};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer3, VELOX_ARRAY_SIZE(buffer3))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer3, std::size(buffer3))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myTimestamp:timestamp>");
@@ -3831,15 +3829,15 @@ TEST_P(TestColumnReader, testTimestamp) {
       0xba, 0xa0, 0x1a, 0x9d, 0x88, 0xa6, 0x82, 0x1a, 0x9d, 0xba, 0x9c,
       0xe4, 0x19, 0x9d, 0xee, 0xe1, 0xcd, 0x18};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   const unsigned char buffer2[] = {
       0xf6, 0x00, 0xa8, 0xd1, 0xf9, 0xd6, 0x03, 0x00, 0x9e, 0x01, 0xec,
       0x76, 0xf4, 0x76, 0xfc, 0x76, 0x84, 0x77, 0x8c, 0x77, 0xfd, 0x0b};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<myTimestamp:timestamp>");
@@ -3909,13 +3907,13 @@ TEST_P(TestColumnReader, testDecimal64) {
     }
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(new SeekableArrayInputStream(
-          numBuffer, VELOX_ARRAY_SIZE(numBuffer), 3)));
+      .WillRepeatedly(Return(
+          new SeekableArrayInputStream(numBuffer, std::size(numBuffer), 3)));
   // col_0's Secondary Stream
   const unsigned char buffer2[] = {0x3e, 0x00, 0x04}; // [0x02] * 65
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer2, VELOX_ARRAY_SIZE(buffer2))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer2, std::size(buffer2))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col_0:decimal(12, 2)>");
@@ -3948,19 +3946,19 @@ TEST_P(TestColumnReader, testDecimal64WithSkip) {
   const unsigned char presentBuffer[] = {0xfe, 0xff, 0x80}; // [0xff]
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(new SeekableArrayInputStream(
-          presentBuffer, VELOX_ARRAY_SIZE(presentBuffer))));
+          presentBuffer, std::size(presentBuffer))));
   const unsigned char numBuffer[] = {
       0xf8, 0xe8, 0xe2, 0xcf, 0xf4, 0xcb, 0xb6, 0xda, 0x0d, 0x86, 0xc1, 0xcc,
       0xcd, 0x9e, 0xd5, 0xc5, 0x11, 0xb4, 0xf6, 0xfc, 0xf3, 0xb9, 0xba, 0x16,
       0xca, 0xe7, 0xa3, 0xa6, 0xdf, 0x1c, 0xea, 0xad, 0xc0, 0xe5, 0x24, 0xf8,
       0x94, 0x8c, 0x2f, 0x86, 0xa4, 0x3c, 0x94, 0x4d, 0x62};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(new SeekableArrayInputStream(
-          numBuffer, VELOX_ARRAY_SIZE(numBuffer))));
+      .WillRepeatedly(Return(
+          new SeekableArrayInputStream(numBuffer, std::size(numBuffer))));
   const unsigned char buffer1[] = {0x06, 0x00, 0x14}; // [0x0a] * 9
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col_0:decimal(12, 10)>");
@@ -4004,7 +4002,7 @@ TEST_P(TestColumnReader, testDecimal128WithSkip) {
   const unsigned char presentBuffer[] = {0xfe, 0xff, 0xf8};
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_PRESENT, false))
       .WillRepeatedly(Return(new SeekableArrayInputStream(
-          presentBuffer, VELOX_ARRAY_SIZE(presentBuffer))));
+          presentBuffer, std::size(presentBuffer))));
   const unsigned char numBuffer[] = {
       0xf8, 0xe8, 0xe2, 0xcf, 0xf4, 0xcb, 0xb6, 0xda, 0x0d, 0x86, 0xc1, 0xcc,
       0xcd, 0x9e, 0xd5, 0xc5, 0x11, 0xb4, 0xf6, 0xfc, 0xf3, 0xb9, 0xba, 0x16,
@@ -4018,12 +4016,12 @@ TEST_P(TestColumnReader, testDecimal128WithSkip) {
       0x93, 0xe8, 0xa3, 0xec, 0xd0, 0x96, 0xd4, 0xcc, 0xf6, 0xac, 0x02,
   };
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_DATA, true))
-      .WillRepeatedly(Return(new SeekableArrayInputStream(
-          numBuffer, VELOX_ARRAY_SIZE(numBuffer))));
+      .WillRepeatedly(Return(
+          new SeekableArrayInputStream(numBuffer, std::size(numBuffer))));
   const unsigned char buffer1[] = {0x0a, 0x00, 0x4a}; // [0x02] * 13
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_NANO_DATA, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(buffer1, VELOX_ARRAY_SIZE(buffer1))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(buffer1, std::size(buffer1))));
 
   // create the row type
   auto rowType = HiveTypeParser().parse("struct<col_0:decimal(38, 37)>");
@@ -4087,8 +4085,8 @@ TEST_P(TestColumnReader, testLargeSkip) {
     length[pos + 2] = 0x01;
   }
   EXPECT_CALL(streams_, getStreamProxy(1, proto::Stream_Kind_LENGTH, true))
-      .WillRepeatedly(Return(
-          new SeekableArrayInputStream(length, VELOX_ARRAY_SIZE(length))));
+      .WillRepeatedly(
+          Return(new SeekableArrayInputStream(length, std::size(length))));
 
   char data[1024 * 1024];
   size_t size = writeRange(data, 0, 73200);
diff --git a/velox/dwio/dwrf/test/TestDecompression.cpp b/velox/dwio/dwrf/test/TestDecompression.cpp
index 3dcf5f68e46b..7a4d6b283773 100644
--- a/velox/dwio/dwrf/test/TestDecompression.cpp
+++ b/velox/dwio/dwrf/test/TestDecompression.cpp
@@ -336,7 +336,7 @@ TEST_F(DecompressionTest, testLzoSmall) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZO,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       128 * 1024);
   const void* ptr;
   int32_t length;
@@ -353,7 +353,7 @@ TEST_F(DecompressionTest, testLzoSmall) {
 TEST_F(DecompressionTest, testLzoLong) {
   // set up a framed lzo buffer with 100,000 'a'
   unsigned char buffer[482];
-  bzero(buffer, VELOX_ARRAY_SIZE(buffer));
+  bzero(buffer, std::size(buffer));
   // header
   buffer[0] = 190;
   buffer[1] = 3;
@@ -378,7 +378,7 @@ TEST_F(DecompressionTest, testLzoLong) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZO,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       128 * 1024);
   const void* ptr;
   int32_t length;
@@ -413,7 +413,7 @@ TEST_F(DecompressionTest, testLz4Small) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZ4,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       128 * 1024);
   const void* ptr;
   int32_t length;
@@ -430,7 +430,7 @@ TEST_F(DecompressionTest, testLz4Small) {
 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));
+  memset(buffer, 255, std::size(buffer));
   // header
   buffer[0] = 38;
   buffer[1] = 3;
@@ -448,7 +448,7 @@ TEST_F(DecompressionTest, testLz4Long) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_LZ4,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       128 * 1024);
   const void* ptr;
   int32_t length;
@@ -465,7 +465,7 @@ TEST_F(DecompressionTest, testCreateZlib) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       32768);
   EXPECT_EQ(
       "PagedInputStream StreamInfo (Test Decompression) input stream (SeekableArrayInputStream 0 of 8) State (0) remaining length (0)",
@@ -497,7 +497,7 @@ TEST_F(DecompressionTest, testLiteralBlocks) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 5)),
+          new SeekableArrayInputStream(buffer, std::size(buffer), 5)),
       5);
   EXPECT_EQ(
       "PagedInputStream StreamInfo (Test Decompression) input stream (SeekableArrayInputStream 0 of 23) State (0) remaining length (0)",
@@ -539,7 +539,7 @@ TEST_F(DecompressionTest, testInflate) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer))),
+          new SeekableArrayInputStream(buffer, std::size(buffer))),
       1000);
   const void* ptr;
   int32_t length;
@@ -552,6 +552,25 @@ TEST_F(DecompressionTest, testInflate) {
   }
 }
 
+TEST_F(DecompressionTest, testSmallBufferInflate) {
+  const unsigned char buffer[] = {
+      0xe, 0x0, 0x0, 0x63, 0x60, 0x64, 0x62, 0xc0, 0x8d, 0x0};
+  const std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
+      CompressionKind_ZLIB,
+      std::make_unique<SeekableArrayInputStream>(buffer, std::size(buffer)),
+      1 // blockSize 1 to test multiple inflate calls during decompression.
+  );
+  const void* ptr;
+  int32_t length;
+  ASSERT_EQ(true, result->Next(&ptr, &length));
+  ASSERT_EQ(30, length);
+  for (int32_t i = 0; i < 10; ++i) {
+    for (int32_t j = 0; j < 3; ++j) {
+      EXPECT_EQ(j, static_cast<const char*>(ptr)[i * 3 + j]);
+    }
+  }
+}
+
 TEST_F(DecompressionTest, testInflateSequence) {
   const unsigned char buffer[] = {0xe,  0x0,  0x0,  0x63, 0x60, 0x64, 0x62,
                                   0xc0, 0x8d, 0x0,  0xe,  0x0,  0x0,  0x63,
@@ -559,7 +578,7 @@ TEST_F(DecompressionTest, testInflateSequence) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 3)),
+          new SeekableArrayInputStream(buffer, std::size(buffer), 3)),
       1000);
   const void* ptr;
   int32_t length;
@@ -594,7 +613,7 @@ TEST_F(DecompressionTest, testSkipZlib) {
   std::unique_ptr<SeekableInputStream> result = createTestDecompressor(
       CompressionKind_ZLIB,
       std::unique_ptr<SeekableInputStream>(
-          new SeekableArrayInputStream(buffer, VELOX_ARRAY_SIZE(buffer), 5)),
+          new SeekableArrayInputStream(buffer, std::size(buffer), 5)),
       5);
   const void* ptr;
   int32_t length;
@@ -906,7 +925,7 @@ class TestSeek : public ::testing::Test {
     size_t arr[][2]{{0, 0}, {0, seekPos}, {offset1, seekPos}, {offset1, 0}};
     char* input[]{input1, input1, input2, input2};
 
-    for (size_t i = 0; i < VELOX_ARRAY_SIZE(arr); ++i) {
+    for (size_t i = 0; i < std::size(arr); ++i) {
       auto pos = arr[i];
       std::vector<uint64_t> list{pos[0], pos[1]};
       PositionProvider pp(list);
@@ -1046,8 +1065,8 @@ class TestingSeekableInputStream : public SeekableInputStream {
     return true;
   }
 
-  google::protobuf::int64 ByteCount() const override {
-    return position_;
+  int64_t ByteCount() const override {
+    return static_cast<int64_t>(position_);
   }
 
   void seekToPosition(PositionProvider& position) override {
@@ -1097,7 +1116,7 @@ TEST_F(TestSeek, uncompressedLarge) {
       entry.getCompressed()[i] = static_cast<char>(i);
     }
     written += runSize + kHeaderSize;
-    data.insert(data.end(), entry.data().begin(), entry.data().end());
+    data.insert(data.end(), entry.data().cbegin(), entry.data().cend());
   }
   auto stream = createTestDecompressor(
       CompressionKind_SNAPPY,
diff --git a/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp b/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
index dc42b6941b15..0fb09b43fa43 100644
--- a/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
+++ b/velox/dwio/dwrf/test/TestDictionaryEncodingUtils.cpp
@@ -22,7 +22,9 @@
 using namespace testing;
 using namespace facebook::velox::memory;
 
-namespace facebook::velox::dwrf {
+namespace facebook::velox::dwrf::test {
+namespace {
+
 class DictionaryEncodingUtilsTest : public testing::Test {
  protected:
   static void SetUpTestCase() {
@@ -36,7 +38,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringGetSortedIndexLookupTable) {
         bool sort,
         std::function<bool(const StringDictionaryEncoder&, size_t, size_t)>
             ordering,
-        const std::vector<folly::StringPiece>& addKeySequence,
+        const std::vector<std::string_view>& addKeySequence,
         const std::vector<uint32_t>& lookupTable)
         : sort{sort},
           ordering{ordering},
@@ -45,7 +47,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringGetSortedIndexLookupTable) {
     bool sort;
     std::function<bool(const StringDictionaryEncoder&, size_t, size_t)>
         ordering;
-    std::vector<folly::StringPiece> addKeySequence;
+    std::vector<std::string_view> addKeySequence;
     std::vector<uint32_t> lookupTable;
   };
 
@@ -151,7 +153,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
         bool sort,
         std::function<bool(const StringDictionaryEncoder&, size_t, size_t)>
             ordering,
-        const std::vector<folly::StringPiece>& addKeySequence,
+        const std::vector<std::string_view>& addKeySequence,
         const std::vector<uint32_t>& lookupTable,
         const std::vector<bool>& inDict,
         size_t finalDictSize,
@@ -166,7 +168,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
     bool sort;
     std::function<bool(const StringDictionaryEncoder&, size_t, size_t)>
         ordering;
-    std::vector<folly::StringPiece> addKeySequence;
+    std::vector<std::string_view> addKeySequence;
     std::vector<uint32_t> lookupTable;
     std::vector<bool> inDict;
     size_t finalDictSize;
@@ -315,7 +317,7 @@ TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
     dwio::common::DataBuffer<uint32_t> strideDictSizes{
         *pool, rowCount / kStrideSize + 1};
 
-    std::vector<folly::StringPiece> expected{testCase.finalDictSize};
+    std::vector<std::string_view> expected{testCase.finalDictSize};
     std::vector<uint32_t> expectedSize(testCase.finalDictSize);
     for (size_t i = 0; i < testCase.lookupTable.size(); ++i) {
       if (testCase.inDict[i]) {
@@ -368,4 +370,5 @@ TEST_F(DictionaryEncodingUtilsTest, StringStrideDictOptimization) {
   }
 }
 
-} // namespace facebook::velox::dwrf
+} // namespace
+} // namespace facebook::velox::dwrf::test
diff --git a/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp b/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp
index cf13c6df826b..a71ddc8a4bc4 100644
--- a/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp
+++ b/velox/dwio/dwrf/test/TestDwrfColumnStatistics.cpp
@@ -195,12 +195,12 @@ void checkEntries(
   for (const auto& entry : entries) {
     EXPECT_NE(
         std::find_if(
-            expectedEntries.begin(),
-            expectedEntries.end(),
+            expectedEntries.cbegin(),
+            expectedEntries.cend(),
             [&](const ColumnStatistics& expectedStats) {
               return expectedStats == entry;
             }),
-        expectedEntries.end());
+        expectedEntries.cend());
   }
 }
 
@@ -490,11 +490,11 @@ TEST(MapStatisticsBuilderTest, mergeKeyStats) {
   statsBuilder.increaseRawSize(8);
   mapStatsBuilder.addValues(createKeyInfo(1), statsBuilder);
 
-  keyStats = dynamic_cast<StatisticsBuilder&>(
+  auto& keyStats1 = 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());
+  ASSERT_EQ(2, keyStats1.getNumberOfValues());
+  ASSERT_TRUE(keyStats1.getRawSize().has_value());
+  ASSERT_EQ(8, keyStats1.getRawSize().value());
+  EXPECT_TRUE(keyStats1.getSize().has_value());
+  EXPECT_EQ(42, keyStats1.getSize().value());
 }
diff --git a/velox/dwio/dwrf/test/TestReadFile.h b/velox/dwio/dwrf/test/TestReadFile.h
index 8501b231ed84..e47d83224182 100644
--- a/velox/dwio/dwrf/test/TestReadFile.h
+++ b/velox/dwio/dwrf/test/TestReadFile.h
@@ -42,15 +42,15 @@ class TestReadFile : public velox::ReadFile {
       uint64_t offset,
       uint64_t length,
       void* buffer,
-      filesystems::File::IoStats* stats = nullptr) const override {
+      const FileStorageContext& fileStorageContext = {}) 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;
     }
-    if (stats) {
-      stats->addCounter(
+    if (fileStorageContext.ioStats) {
+      fileStorageContext.ioStats->addCounter(
           "read", RuntimeCounter(fill, RuntimeCounter::Unit::kBytes));
     }
     return std::string_view(static_cast<const char*>(buffer), fill);
@@ -59,10 +59,10 @@ class TestReadFile : public velox::ReadFile {
   uint64_t preadv(
       uint64_t offset,
       const std::vector<folly::Range<char*>>& buffers,
-      filesystems::File::IoStats* stats = nullptr) const override {
-    auto res = ReadFile::preadv(offset, buffers, stats);
-    if (stats) {
-      stats->addCounter(
+      const FileStorageContext& fileStorageContext = {}) const override {
+    auto res = ReadFile::preadv(offset, buffers, fileStorageContext);
+    if (fileStorageContext.ioStats) {
+      fileStorageContext.ioStats->addCounter(
           "read",
           RuntimeCounter(
               static_cast<int64_t>(res), RuntimeCounter::Unit::kBytes));
diff --git a/velox/dwio/dwrf/test/TestRle.cpp b/velox/dwio/dwrf/test/TestRle.cpp
index b779dedff8e8..d1fe6f2c813d 100644
--- a/velox/dwio/dwrf/test/TestRle.cpp
+++ b/velox/dwio/dwrf/test/TestRle.cpp
@@ -88,7 +88,7 @@ TEST_F(RLEv2Test, basicDelta0) {
   }
 
   const unsigned char bytes[] = {0xc0, 0x13, 0x00, 0x02};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
@@ -106,7 +106,7 @@ TEST_F(RLEv2Test, basicDelta1) {
 
   const unsigned char bytes[] = {
       0xce, 0x04, 0xe7, 0x07, 0xc8, 0x01, 0x32, 0x19, 0x0f};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -127,7 +127,7 @@ TEST_F(RLEv2Test, basicDelta2) {
 
   const unsigned char bytes[] = {
       0xce, 0x04, 0xe7, 0x07, 0xc7, 0x01, 0x32, 0x19, 0x23};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -148,7 +148,7 @@ TEST_F(RLEv2Test, basicDelta3) {
 
   const unsigned char bytes[] = {
       0xce, 0x04, 0xe8, 0x07, 0xc7, 0x01, 0x32, 0x19, 0x0f};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -169,7 +169,7 @@ TEST_F(RLEv2Test, basicDelta4) {
 
   const unsigned char bytes[] = {
       0xce, 0x04, 0xe8, 0x07, 0xc8, 0x01, 0x32, 0x19, 0x23};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -188,7 +188,7 @@ TEST_F(RLEv2Test, delta0Width) {
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(
               new dwio::common::SeekableArrayInputStream(
-                  buffer, VELOX_ARRAY_SIZE(buffer))),
+                  buffer, std::size(buffer))),
           RleVersion_2,
           *pool,
           true /* doesn't matter */,
@@ -219,7 +219,7 @@ TEST_F(RLEv2Test, basicDelta0WithNulls) {
   }
 
   const unsigned char bytes[] = {0xc0, 0x13, 0x00, 0x02};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   const size_t count = values.size();
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count, nulls), 1, nulls);
@@ -243,7 +243,7 @@ TEST_F(RLEv2Test, shortRepeats) {
   const unsigned char bytes[] = {0x04, 0x00, 0x04, 0x02, 0x04, 0x04, 0x04,
                                  0x06, 0x04, 0x08, 0x04, 0x0a, 0x04, 0x0c,
                                  0x04, 0x0e, 0x04, 0x10, 0x04, 0x12};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
@@ -266,7 +266,7 @@ TEST_F(RLEv2Test, multiByteShortRepeats) {
                                  0x00, 0x00, 0x3c, 0x80, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x02, 0x3c, 0x80, 0x00,
                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x04};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
@@ -280,7 +280,7 @@ TEST_F(RLEv2Test, 0to2Repeat1Direct) {
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
           new dwio::common::SeekableArrayInputStream(
-              buffer, VELOX_ARRAY_SIZE(buffer))),
+              buffer, std::size(buffer))),
       RleVersion_2,
       *pool,
       true /* doesn't matter */,
@@ -302,7 +302,7 @@ TEST_F(RLEv2Test, bitSize2Direct) {
   }
 
   const unsigned char bytes[] = {0x42, 0x13, 0x22, 0x22, 0x22, 0x22, 0x22};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, count), 3);
@@ -320,7 +320,7 @@ TEST_F(RLEv2Test, bitSize4Direct) {
 
   const unsigned char bytes[] = {
       0x46, 0x13, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
 
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, count), 1);
@@ -360,7 +360,7 @@ TEST_F(RLEv2Test, multipleRunsDirect) {
       0x04,
       0x04,
       0x04};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
 
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
@@ -382,7 +382,7 @@ TEST_F(RLEv2Test, largeNegativesDirect) {
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
           new dwio::common::SeekableArrayInputStream(
-              buffer, VELOX_ARRAY_SIZE(buffer))),
+              buffer, std::size(buffer))),
       RleVersion_2,
       *pool,
       true /* doesn't matter */,
@@ -408,7 +408,7 @@ TEST_F(RLEv2Test, overflowDirect) {
       0x7e, 0x03, 0x7d, 0x45, 0x3c, 0x12, 0x41, 0x48, 0xf4, 0xbe, 0x7d, 0x45,
       0x3c, 0x12, 0x41, 0x48, 0xf4, 0xae, 0x50, 0xce, 0xad, 0x2a, 0x30, 0x0e,
       0xd2, 0x96, 0xfe, 0xd8, 0xd2, 0x38, 0x54, 0x6e, 0x3d, 0x81};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -445,7 +445,7 @@ TEST_F(RLEv2Test, basicPatched0) {
       0x5a,
       0xfc,
       0xe8};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -484,7 +484,7 @@ TEST_F(RLEv2Test, basicPatched1) {
       0xe0, 0x78, 0x00, 0x1c, 0x0f, 0x08, 0x06, 0x81, 0xc6, 0x90, 0x80, 0x68,
       0x24, 0x1b, 0x0b, 0x26, 0x83, 0x21, 0x30, 0xe0, 0x98, 0x3c, 0x6f, 0x06,
       0xb7, 0x03, 0x70};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -544,7 +544,7 @@ TEST_F(RLEv2Test, mixedPatchedAndShortRepeats) {
       0x00, 0x0c, 0x02, 0x08, 0x18, 0x00, 0x40, 0x00, 0x01, 0x00, 0x00, 0x08,
       0x30, 0x33, 0x80, 0x00, 0x02, 0x0c, 0x10, 0x20, 0x20, 0x47, 0x80, 0x13,
       0x4c};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
   // Read 1 at a time, then 3 at a time, etc.
   checkResults(values, decodeRLEv2(bytes, l, 1, values.size()), 1);
   checkResults(values, decodeRLEv2(bytes, l, 3, values.size()), 3);
@@ -579,7 +579,7 @@ TEST_F(RLEv2Test, basicDirectSeek) {
       0x04,
       0x04,
       0x04};
-  unsigned long l = sizeof(bytes) / sizeof(char);
+  unsigned long l = sizeof(bytes);
 
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
@@ -688,7 +688,7 @@ TEST_F(RLEv1Test, simpleTest) {
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(
               new dwio::common::SeekableArrayInputStream(
-                  buffer, VELOX_ARRAY_SIZE(buffer))),
+                  buffer, std::size(buffer))),
           RleVersion_1,
           *pool,
           true,
@@ -712,7 +712,7 @@ TEST_F(RLEv1Test, signedNullLiteralTest) {
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(
           new dwio::common::SeekableArrayInputStream(
-              buffer, VELOX_ARRAY_SIZE(buffer))),
+              buffer, std::size(buffer))),
       RleVersion_1,
       *pool,
       true,
@@ -733,7 +733,7 @@ TEST_F(RLEv1Test, splitHeader) {
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(
               new dwio::common::SeekableArrayInputStream(
-                  buffer, VELOX_ARRAY_SIZE(buffer), 4)),
+                  buffer, std::size(buffer), 4)),
           RleVersion_1,
           *pool,
           true,
@@ -751,8 +751,7 @@ TEST_F(RLEv1Test, splitRuns) {
   const unsigned char buffer[] = {
       0x7d, 0x01, 0xff, 0x01, 0xfb, 0x01, 0x02, 0x03, 0x04, 0x05};
   dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<false>> rle =
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(stream),
@@ -784,8 +783,7 @@ 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(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(stream),
       RleVersion_1,
@@ -808,8 +806,7 @@ 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(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(stream),
       RleVersion_1,
@@ -842,8 +839,7 @@ TEST_F(RLEv1Test, testAllNulls) {
                                   0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
                                   0x0d, 0x0e, 0x0f, 0x3d, 0x00, 0x12};
   dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<false>> rle =
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(stream),
@@ -1095,8 +1091,7 @@ TEST_F(RLEv1Test, skipTest) {
       128, 228, 63,  128, 232, 63,  128, 236, 63,  128, 240, 63,  128, 244, 63,
       128, 248, 63,  128, 252, 63};
   dwio::common::SeekableInputStream* const stream =
-      new dwio::common::SeekableArrayInputStream(
-          buffer, VELOX_ARRAY_SIZE(buffer));
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   std::unique_ptr<dwio::common::IntDecoder<true>> rle = createRleDecoder<true>(
       std::unique_ptr<dwio::common::SeekableInputStream>(stream),
       RleVersion_1,
@@ -1872,8 +1867,8 @@ TEST_F(RLEv1Test, 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};
-  auto* stream = new dwio::common::SeekableArrayInputStream(
-      buffer, VELOX_ARRAY_SIZE(buffer));
+  auto* stream =
+      new dwio::common::SeekableArrayInputStream(buffer, std::size(buffer));
   const long junk[] = {
       -1192035722, 1672896916,  1491444859,  -1244121273, -791680696,
       1681943525,  -571055948,  -1744759283, -998345856,  240559198,
@@ -2991,7 +2986,7 @@ TEST_F(RLEv1Test, seekTest) {
   };
   std::vector<int64_t> data(2048);
   rle->next(data.data(), data.size(), nullptr);
-  ASSERT_EQ(getNumReadBytes(), VELOX_ARRAY_SIZE(buffer));
+  ASSERT_EQ(getNumReadBytes(), std::size(buffer));
   for (size_t i = 0; i < data.size(); ++i) {
     if (i < 1024) {
       EXPECT_EQ(i / 4, data[i]) << "Wrong output at " << i;
@@ -3023,7 +3018,7 @@ TEST_F(RLEv1Test, seekTest) {
 
   // Seek to end
   std::vector<uint64_t> position;
-  position.push_back(VELOX_ARRAY_SIZE(buffer));
+  position.push_back(std::size(buffer));
   position.push_back(0);
   dwio::common::PositionProvider pp{position};
   rle->seekToRowGroup(pp);
@@ -3033,7 +3028,7 @@ TEST_F(RLEv1Test, seekTest) {
 
   // Seek to end + 1
   position.clear();
-  position.push_back(VELOX_ARRAY_SIZE(buffer));
+  position.push_back(std::size(buffer));
   position.push_back(1);
   dwio::common::PositionProvider pp2{position};
   // Seek is fine (because it's lazy), but read should fail
@@ -3049,7 +3044,7 @@ TEST_F(RLEv1Test, testLeadingNulls) {
       createRleDecoder<false>(
           std::unique_ptr<dwio::common::SeekableInputStream>(
               new dwio::common::SeekableArrayInputStream(
-                  buffer, VELOX_ARRAY_SIZE(buffer))),
+                  buffer, std::size(buffer))),
           RleVersion_1,
           *pool,
           true,
diff --git a/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp b/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
index 2dfd93797ec0..f8c33d91ff6d 100644
--- a/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
+++ b/velox/dwio/dwrf/test/TestStringDictionaryEncoder.cpp
@@ -20,8 +20,6 @@
 
 DECLARE_bool(velox_enable_memory_usage_track_in_default_memory_pool);
 
-using namespace facebook::velox::memory;
-
 namespace facebook::velox::dwrf {
 
 class TestStringDictionaryEncoder : public ::testing::Test {
@@ -35,10 +33,10 @@ class TestStringDictionaryEncoder : public ::testing::Test {
 TEST_F(TestStringDictionaryEncoder, AddKey) {
   struct TestCase {
     explicit TestCase(
-        const std::vector<folly::StringPiece>& addKeySequence,
+        const std::vector<std::string_view>& addKeySequence,
         const std::vector<size_t>& encodedSequence)
         : addKeySequence{addKeySequence}, encodedSequence{encodedSequence} {}
-    std::vector<folly::StringPiece> addKeySequence;
+    std::vector<std::string_view> addKeySequence;
     std::vector<size_t> encodedSequence;
   };
 
@@ -50,7 +48,7 @@ TEST_F(TestStringDictionaryEncoder, AddKey) {
       TestCase{{"doe", "sow", "sow", "doe", "sow"}, {0, 1, 1, 0, 1}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = memoryManager()->addLeafPool();
+    auto pool = memory::memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     std::vector<size_t> actualEncodedSequence{};
     for (const auto& key : testCase.addKeySequence) {
@@ -63,14 +61,14 @@ TEST_F(TestStringDictionaryEncoder, AddKey) {
 TEST_F(TestStringDictionaryEncoder, GetIndex) {
   struct TestCase {
     explicit TestCase(
-        const std::vector<folly::StringPiece>& addKeySequence,
-        const std::vector<folly::StringPiece>& getIndexSequence,
+        const std::vector<std::string_view>& addKeySequence,
+        const std::vector<std::string_view>& getIndexSequence,
         const std::vector<size_t>& encodedSequence)
         : addKeySequence{addKeySequence},
           getIndexSequence{getIndexSequence},
           encodedSequence{encodedSequence} {}
-    std::vector<folly::StringPiece> addKeySequence;
-    std::vector<folly::StringPiece> getIndexSequence;
+    std::vector<std::string_view> addKeySequence;
+    std::vector<std::string_view> getIndexSequence;
     std::vector<size_t> encodedSequence;
   };
 
@@ -94,7 +92,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 = memoryManager()->addLeafPool();
+    auto pool = memory::memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       stringDictEncoder.addKey(key, 0);
@@ -111,14 +109,14 @@ TEST_F(TestStringDictionaryEncoder, GetIndex) {
 TEST_F(TestStringDictionaryEncoder, GetCount) {
   struct TestCase {
     explicit TestCase(
-        const std::vector<folly::StringPiece>& addKeySequence,
-        const std::vector<folly::StringPiece>& getCountSequence,
+        const std::vector<std::string_view>& addKeySequence,
+        const std::vector<std::string_view>& getCountSequence,
         const std::vector<size_t>& countSequence)
         : addKeySequence{addKeySequence},
           getCountSequence{getCountSequence},
           countSequence{countSequence} {}
-    std::vector<folly::StringPiece> addKeySequence;
-    std::vector<folly::StringPiece> getCountSequence;
+    std::vector<std::string_view> addKeySequence;
+    std::vector<std::string_view> getCountSequence;
     std::vector<size_t> countSequence;
   };
 
@@ -143,7 +141,7 @@ TEST_F(TestStringDictionaryEncoder, GetCount) {
           {3, 2, 3, 3, 2}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = memoryManager()->addLeafPool();
+    auto pool = memory::memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& key : testCase.addKeySequence) {
       stringDictEncoder.addKey(key, 0);
@@ -161,15 +159,14 @@ TEST_F(TestStringDictionaryEncoder, GetCount) {
 TEST_F(TestStringDictionaryEncoder, GetStride) {
   struct TestCase {
     explicit TestCase(
-        const std::vector<std::pair<folly::StringPiece, size_t>>&
-            addKeySequence,
-        const std::vector<folly::StringPiece>& getStrideSequence,
+        const std::vector<std::pair<std::string_view, size_t>>& addKeySequence,
+        const std::vector<std::string_view>& getStrideSequence,
         const std::vector<size_t>& strideSequence)
         : addKeySequence{addKeySequence},
           getStrideSequence{getStrideSequence},
           strideSequence{strideSequence} {}
-    std::vector<std::pair<folly::StringPiece, size_t>> addKeySequence;
-    std::vector<folly::StringPiece> getStrideSequence;
+    std::vector<std::pair<std::string_view, size_t>> addKeySequence;
+    std::vector<std::string_view> getStrideSequence;
     std::vector<size_t> strideSequence;
   };
 
@@ -197,7 +194,7 @@ TEST_F(TestStringDictionaryEncoder, GetStride) {
           {1, 1, 6, 3, 4}}};
 
   for (const auto& testCase : testCases) {
-    auto pool = memoryManager()->addLeafPool();
+    auto pool = memory::memoryManager()->addLeafPool();
     StringDictionaryEncoder stringDictEncoder{*pool, *pool};
     for (const auto& kv : testCase.addKeySequence) {
       stringDictEncoder.addKey(kv.first, kv.second);
@@ -220,7 +217,7 @@ std::string genPaddedIntegerString(size_t integer, size_t length) {
 }
 
 TEST_F(TestStringDictionaryEncoder, Clear) {
-  auto pool = memoryManager()->addLeafPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   StringDictionaryEncoder stringDictEncoder{*pool, *pool};
   std::string baseString{"jjkkll"};
   for (size_t i = 0; i != 2500; ++i) {
@@ -242,7 +239,7 @@ TEST_F(TestStringDictionaryEncoder, Clear) {
 }
 
 TEST_F(TestStringDictionaryEncoder, MemBenchmark) {
-  auto pool = memoryManager()->addLeafPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   StringDictionaryEncoder stringDictEncoder{*pool, *pool};
   std::string baseString{"jjkkll"};
   for (size_t i = 0; i != 10000; ++i) {
@@ -253,15 +250,15 @@ TEST_F(TestStringDictionaryEncoder, MemBenchmark) {
 }
 
 TEST_F(TestStringDictionaryEncoder, Limit) {
-  auto pool = memoryManager()->addLeafPool();
+  auto pool = memory::memoryManager()->addLeafPool();
   StringDictionaryEncoder encoder{*pool, *pool};
-  encoder.addKey(folly::StringPiece{"abc"}, 0);
+  encoder.addKey(std::string_view{"abc"}, 0);
   dwio::common::DataBuffer<char> buf{*pool};
   buf.resize(std::numeric_limits<uint32_t>::max());
 
   ASSERT_THROW(
       encoder.addKey(
-          folly::StringPiece{
+          std::string_view{
               buf.data(), std::numeric_limits<uint32_t>::max() - 3},
           0),
       dwio::common::exception::LoggedException);
diff --git a/velox/dwio/dwrf/test/TestStripeStream.cpp b/velox/dwio/dwrf/test/TestStripeStream.cpp
index 2e9132aeb5fb..9dff9261c386 100644
--- a/velox/dwio/dwrf/test/TestStripeStream.cpp
+++ b/velox/dwio/dwrf/test/TestStripeStream.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/encryption/TestProvider.h"
 #include "velox/dwio/dwrf/reader/StripeStream.h"
 #include "velox/dwio/dwrf/test/OrcTest.h"
@@ -42,8 +43,8 @@ class RecordingInputStream : public facebook::velox::InMemoryReadFile {
       uint64_t offset,
       uint64_t length,
       void* buf,
-      facebook::velox::filesystems::File::IoStats* stats =
-          nullptr) const override {
+      const facebook::velox::FileStorageContext& fileStorageContext = {})
+      const override {
     reads_.push_back({offset, length});
     return {static_cast<char*>(buf), length};
   }
@@ -158,10 +159,11 @@ INSTANTIATE_TEST_SUITE_P(
 
 TEST_P(StripeStreamFormatTypeTest, planReads) {
   google::protobuf::Arena arena;
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
-  footer->set_rowindexstride(100);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
+  footerWrapper.setRowIndexStride(100);
   auto type = HiveTypeParser().parse("struct<a:int,b:float>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto is = std::make_unique<RecordingInputStream>();
   auto isPtr = is.get();
   auto readerBase = std::make_shared<ReaderBase>(
@@ -247,10 +249,11 @@ TEST_P(StripeStreamFormatTypeTest, planReads) {
 
 TEST_F(StripeStreamTest, filterSequences) {
   google::protobuf::Arena arena;
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
-  footer->set_rowindexstride(100);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
+  footerWrapper.setRowIndexStride(100);
   auto type = HiveTypeParser().parse("struct<a:map<int,float>>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   auto is = std::make_unique<RecordingInputStream>();
   auto isPtr = is.get();
   auto readerBase = std::make_shared<ReaderBase>(
@@ -311,10 +314,11 @@ TEST_F(StripeStreamTest, filterSequences) {
 
 TEST_P(StripeStreamFormatTypeTest, zeroLength) {
   google::protobuf::Arena arena;
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
-  footer->set_rowindexstride(100);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
+  footerWrapper.setRowIndexStride(100);
   auto type = HiveTypeParser().parse("struct<a:int>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
   proto::PostScript ps;
   ps.set_compressionblocksize(1024);
   ps.set_compression(proto::CompressionKind::ZSTD);
@@ -437,12 +441,13 @@ TEST_P(StripeStreamFormatTypeTest, planReadsIndex) {
   index.SerializeToOstream(&buffer);
 
   // build footer
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
-  footer->set_rowindexstride(100);
-  footer->add_stripecacheoffsets(0);
-  footer->add_stripecacheoffsets(buffer.tellp());
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
+  footerWrapper.setRowIndexStride(100);
+  footerWrapper.addStripeCacheOffsets(0);
+  footerWrapper.addStripeCacheOffsets(buffer.tellp());
   auto type = HiveTypeParser().parse("struct<a:int>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
 
   // build cache
   std::string str(buffer.str());
@@ -596,23 +601,24 @@ TEST_F(StripeStreamTest, readEncryptedStreams) {
   proto::PostScript ps;
   ps.set_compression(proto::CompressionKind::ZSTD);
   ps.set_compressionblocksize(256 * 1024);
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
   // a: not encrypted, projected
   // encryption group 1: b, c. projected b.
   // group 2: d. projected d.
   // group 3: e. not projected
   auto type = HiveTypeParser().parse("struct<a:int,b:int,c:int,d:int,e:int>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
 
-  auto enc = footer->mutable_encryption();
+  auto enc = footerWrapper.mutableEncryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   addEncryptionGroup(*enc, {2, 3});
   addEncryptionGroup(*enc, {4});
   addEncryptionGroup(*enc, {5});
 
-  auto stripe = footer->add_stripes();
+  auto stripe = footerWrapper.addStripes();
   for (auto i = 0; i < 3; ++i) {
-    *stripe->add_keymetadata() = folly::to<std::string>("key", i);
+    *stripe.addKeyMetadata() = folly::to<std::string>("key", i);
   }
   TestDecrypterFactory factory;
   auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
@@ -689,19 +695,20 @@ TEST_F(StripeStreamTest, schemaMismatch) {
   proto::PostScript ps;
   ps.set_compression(proto::CompressionKind::ZSTD);
   ps.set_compressionblocksize(256 * 1024);
-  auto footer = google::protobuf::Arena::CreateMessage<proto::Footer>(&arena);
+  auto footer = ArenaCreate<proto::Footer>(&arena);
+  auto footerWrapper = FooterWriteWrapper(footer);
   // a: not encrypted, has schema change
   // b: encrypted
   // c: not encrypted
   auto type = HiveTypeParser().parse("struct<a:struct<a:int>,b:int,c:int>");
-  ProtoUtils::writeType(*type, *footer);
+  ProtoUtils::writeType(*type, footerWrapper);
 
-  auto enc = footer->mutable_encryption();
+  auto enc = footerWrapper.mutableEncryption();
   enc->set_keyprovider(proto::Encryption_KeyProvider_UNKNOWN);
   addEncryptionGroup(*enc, {3});
 
-  auto stripe = footer->add_stripes();
-  *stripe->add_keymetadata() = "key";
+  auto stripe = footerWrapper.addStripes();
+  *stripe.addKeyMetadata() = "key";
   TestDecrypterFactory factory;
   auto handler = DecryptionHandler::create(FooterWrapper(footer), &factory);
   TestEncrypter encrypter;
diff --git a/velox/dwio/dwrf/test/WriterFlushTest.cpp b/velox/dwio/dwrf/test/WriterFlushTest.cpp
index b8dfcac394f1..f55d3bc44495 100644
--- a/velox/dwio/dwrf/test/WriterFlushTest.cpp
+++ b/velox/dwio/dwrf/test/WriterFlushTest.cpp
@@ -146,8 +146,9 @@ class MockMemoryPool : public velox::memory::MemoryPool {
     VELOX_UNSUPPORTED("allocateContiguous unsupported");
   }
 
-  void freeContiguous(velox::memory::ContiguousAllocation&
-                      /*unused*/) override {
+  void freeContiguous(
+      velox::memory::ContiguousAllocation&
+      /*unused*/) override {
     VELOX_UNSUPPORTED("freeContiguous unsupported");
   }
 
diff --git a/velox/dwio/dwrf/test/WriterTest.cpp b/velox/dwio/dwrf/test/WriterTest.cpp
index 7126ef0b4ecd..82488fb39f28 100644
--- a/velox/dwio/dwrf/test/WriterTest.cpp
+++ b/velox/dwio/dwrf/test/WriterTest.cpp
@@ -75,7 +75,7 @@ class WriterTest : public Test {
     return writer_->getFooter();
   }
 
-  auto& addStripeInfo() {
+  StripeInformationWriteWrapper addStripeInfo() {
     return writer_->addStripeInfo();
   }
 
@@ -168,13 +168,12 @@ TEST_P(AllWriterCompressionTest, compression) {
         folly::to<std::string>(i), folly::to<std::string>(i + 1));
   }
   for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
+    getFooter()->addStatistics();
   }
 
   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),
@@ -231,7 +230,7 @@ TEST_P(SupportedCompressionTest, WriteFooter) {
         folly::to<std::string>(i), folly::to<std::string>(i + 1));
   }
   for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
+    getFooter()->addStatistics();
   }
   writeFooter(*schema);
   writer.close();
@@ -263,11 +262,11 @@ TEST_P(SupportedCompressionTest, WriteFooter) {
   ASSERT_EQ(footer.metadataSize(), 5);
   for (size_t i = 0; i < 4; ++i) {
     auto item = footer.metadata(i);
-    if (item.name() == WRITER_NAME_KEY) {
+    if (item.name() == kWriterNameKey) {
       ASSERT_EQ(item.value(), kDwioWriter);
-    } else if (item.name() == WRITER_VERSION_KEY) {
+    } else if (item.name() == kWriterVersionKey) {
       ASSERT_EQ(item.value(), folly::to<std::string>(reader->writerVersion()));
-    } else if (item.name() == WRITER_HOSTNAME_KEY) {
+    } else if (item.name() == kWriterHostnameKey) {
       ASSERT_EQ(item.value(), process::getHostName());
     } else {
       ASSERT_EQ(
@@ -307,9 +306,9 @@ TEST_P(SupportedCompressionTest, AddStripeInfo) {
   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);
+  auto ret = addStripeInfo();
+  ASSERT_EQ(ret.numberOfRows(), 101);
+  ASSERT_EQ(ret.rawDataSize(), 202);
   ASSERT_EQ(ret.checksum(), 8963334039576633799);
   writer.close();
 }
@@ -327,14 +326,14 @@ TEST_P(SupportedCompressionTest, NoChecksum) {
   writerSink.addBuffer(*pool_, data.data(), data.size());
   writerSink.setMode(WriterSink::Mode::None);
 
-  auto& ret = addStripeInfo();
-  ASSERT_FALSE(ret.has_checksum());
+  auto ret = addStripeInfo();
+  ASSERT_FALSE(ret.hasChecksum());
 
   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();
+    getFooter()->addStatistics();
   }
   writeFooter(*schema);
   writer.close();
@@ -369,7 +368,7 @@ TEST_P(SupportedCompressionTest, NoCache) {
   HiveTypeParser parser;
   auto schema = parser.parse(typeStr);
   for (size_t i = 0; i < 4; ++i) {
-    getFooter().add_statistics();
+    getFooter()->addStatistics();
   }
   writeFooter(*schema);
   writer.close();
@@ -457,7 +456,20 @@ class MockFileSink : public dwio::common::FileSink {
 
   MOCK_METHOD(uint64_t, size, (), (const override));
   MOCK_METHOD(bool, isBuffered, (), (const override));
+// On Centos9 the gtest mock header doesn't initialize the
+// buffer_ member in MatcherBase correctly - the default constructor only
+// initializes one: /usr/include/gtest/gtest-matchers.h:302:33 resulting in
+// error:
+// '<unnamed>.testing::Matcher<const
+// facebook::velox::FileStorageContext&>::<unnamed>.testing::internal::MatcherBase<const
+// facebook::velox::FileStorageContext&>::buffer_' is used uninitialized
+// [-Werror=uninitialized]
+//  302 |       : vtable_(other.vtable_), buffer_(other.buffer_) {
+// Fix: https://github.com/google/googletest/pull/3797
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
   MOCK_METHOD(void, write, (std::vector<DataBuffer<char>>&));
+#pragma GCC diagnostic pop
 };
 
 TEST_F(WriterTest, FlushWriterSinkUponClose) {
diff --git a/velox/dwio/dwrf/test/utils/CMakeLists.txt b/velox/dwio/dwrf/test/utils/CMakeLists.txt
index 16f035f7670a..617b90490771 100644
--- a/velox/dwio/dwrf/test/utils/CMakeLists.txt
+++ b/velox/dwio/dwrf/test/utils/CMakeLists.txt
@@ -27,4 +27,5 @@ target_link_libraries(
   velox_type
   velox_vector
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/dwio/dwrf/utils/CMakeLists.txt b/velox/dwio/dwrf/utils/CMakeLists.txt
index 9fff6d39972b..74655a9b0b1d 100644
--- a/velox/dwio/dwrf/utils/CMakeLists.txt
+++ b/velox/dwio/dwrf/utils/CMakeLists.txt
@@ -17,5 +17,4 @@ if(${VELOX_BUILD_TESTING})
 endif()
 
 velox_add_library(velox_dwio_dwrf_utils ProtoUtils.cpp BitIterator.h)
-velox_link_libraries(velox_dwio_dwrf_utils velox_dwio_dwrf_common velox_type
-                     velox_memory)
+velox_link_libraries(velox_dwio_dwrf_utils velox_dwio_dwrf_common velox_type velox_memory)
diff --git a/velox/dwio/dwrf/utils/ProtoUtils.cpp b/velox/dwio/dwrf/utils/ProtoUtils.cpp
index 405d2e79ddfb..8cfbf4594405 100644
--- a/velox/dwio/dwrf/utils/ProtoUtils.cpp
+++ b/velox/dwio/dwrf/utils/ProtoUtils.cpp
@@ -51,31 +51,34 @@ CREATE_TYPE_TRAIT(ROW, STRUCT)
 
 void ProtoUtils::writeType(
     const Type& type,
-    proto::Footer& footer,
-    proto::Type* parent) {
-  auto self = footer.add_types();
+    FooterWriteWrapper& footer,
+    TypeWriteWrapper* parent) {
+  auto self = footer.addTypes();
   if (parent) {
-    parent->add_subtypes(footer.types_size() - 1);
+    parent->addSubtypes(footer.typesSize() - 1);
   }
+
   auto kind =
       VELOX_STATIC_FIELD_DYNAMIC_DISPATCH(SchemaType, kind, type.kind());
-  self->set_kind(kind);
+  auto typeKindWrapper = TypeKindWrapper(&kind);
+  self.setKind(typeKindWrapper);
+
   switch (type.kind()) {
     case TypeKind::ROW: {
       auto& row = type.asRow();
       for (size_t i = 0; i < row.size(); ++i) {
-        self->add_fieldnames(row.nameOf(i));
-        writeType(*row.childAt(i), footer, self);
+        self.addFieldnames(row.nameOf(i));
+        writeType(*row.childAt(i), footer, &self);
       }
       break;
     }
     case TypeKind::ARRAY:
-      writeType(*type.asArray().elementType(), footer, self);
+      writeType(*type.asArray().elementType(), footer, &self);
       break;
     case TypeKind::MAP: {
       auto& map = type.asMap();
-      writeType(*map.keyType(), footer, self);
-      writeType(*map.valueType(), footer, self);
+      writeType(*map.keyType(), footer, &self);
+      writeType(*map.valueType(), footer, &self);
       break;
     }
     default:
diff --git a/velox/dwio/dwrf/utils/ProtoUtils.h b/velox/dwio/dwrf/utils/ProtoUtils.h
index bea1d1003303..310aaf7eb18b 100644
--- a/velox/dwio/dwrf/utils/ProtoUtils.h
+++ b/velox/dwio/dwrf/utils/ProtoUtils.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "velox/dwio/common/SeekableInputStream.h"
+#include "velox/dwio/dwrf/common/FileMetadata.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 #include "velox/type/Type.h"
 
@@ -26,8 +27,8 @@ class ProtoUtils final {
  public:
   static void writeType(
       const Type& type,
-      proto::Footer& footer,
-      proto::Type* parent = nullptr);
+      FooterWriteWrapper&,
+      TypeWriteWrapper* parent = nullptr);
 
   static std::shared_ptr<const Type> fromFooter(
       const proto::Footer& footer,
diff --git a/velox/dwio/dwrf/utils/test/CMakeLists.txt b/velox/dwio/dwrf/utils/test/CMakeLists.txt
index 9da234fd235e..982d47bb2ea2 100644
--- a/velox/dwio/dwrf/utils/test/CMakeLists.txt
+++ b/velox/dwio/dwrf/utils/test/CMakeLists.txt
@@ -12,8 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_dwio_dwrf_utils_test
-               ProtoUtilsTests.cpp BitIteratorTests.cpp BufferedWriterTest.cpp)
+add_executable(
+  velox_dwio_dwrf_utils_test
+  ProtoUtilsTests.cpp
+  BitIteratorTests.cpp
+  BufferedWriterTest.cpp
+)
 
 add_test(velox_dwio_dwrf_utils_test velox_dwio_dwrf_utils_test)
 
@@ -25,4 +29,5 @@ target_link_libraries(
   velox_type_fbhive
   GTest::gtest
   GTest::gtest_main
-  glog::glog)
+  glog::glog
+)
diff --git a/velox/dwio/dwrf/utils/test/ProtoUtilsTests.cpp b/velox/dwio/dwrf/utils/test/ProtoUtilsTests.cpp
index 92c6d01b00a4..f32700513d24 100644
--- a/velox/dwio/dwrf/utils/test/ProtoUtilsTests.cpp
+++ b/velox/dwio/dwrf/utils/test/ProtoUtilsTests.cpp
@@ -31,7 +31,8 @@ TEST(ProtoUtilsTests, AllTypes) {
     HiveTypeParser parser;
     auto schema = parser.parse(type);
     proto::Footer footer;
-    ProtoUtils::writeType(*schema, footer);
+    auto footerWrapper = FooterWriteWrapper(&footer);
+    ProtoUtils::writeType(*schema, footerWrapper);
 
     auto out = ProtoUtils::fromFooter(footer);
     auto str = HiveTypeSerializer::serialize(out);
@@ -45,7 +46,8 @@ TEST(ProtoUtilsTests, Projection) {
   auto schema = parser.parse(
       "struct<a:boolean,b:tinyint,c:smallint,d:struct<a:int,b:int,c:int>>");
   proto::Footer footer;
-  ProtoUtils::writeType(*schema, footer);
+  auto footerWrapper = FooterWriteWrapper(&footer);
+  ProtoUtils::writeType(*schema, footerWrapper);
 
   auto type = ProtoUtils::fromFooter(
       footer, [](auto id) { return id != 2 && id != 5; });
diff --git a/velox/dwio/dwrf/writer/CMakeLists.txt b/velox/dwio/dwrf/writer/CMakeLists.txt
index 3150c30e55b8..ec121ef6aaed 100644
--- a/velox/dwio/dwrf/writer/CMakeLists.txt
+++ b/velox/dwio/dwrf/writer/CMakeLists.txt
@@ -24,7 +24,8 @@ velox_add_library(
   Writer.cpp
   WriterBase.cpp
   WriterContext.cpp
-  WriterSink.cpp)
+  WriterSink.cpp
+)
 
 velox_link_libraries(
   velox_dwio_dwrf_writer
@@ -38,6 +39,6 @@ velox_link_libraries(
   velox_vector
   Boost::headers
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
-  ZLIB::ZLIB)
+  ZLIB::ZLIB
+)
diff --git a/velox/dwio/dwrf/writer/ColumnWriter.cpp b/velox/dwio/dwrf/writer/ColumnWriter.cpp
index 2a4cf2077961..2100d18fd8a4 100644
--- a/velox/dwio/dwrf/writer/ColumnWriter.cpp
+++ b/velox/dwio/dwrf/writer/ColumnWriter.cpp
@@ -68,8 +68,9 @@ class ByteRleColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     data_->flush();
   }
@@ -248,8 +249,9 @@ class IntegerColumnWriter : public BaseColumnWriter {
   }
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     tryAbandonDictionaries(false);
     initStreamWriters(useDictionaryEncoding_);
 
@@ -287,12 +289,14 @@ class IntegerColumnWriter : public BaseColumnWriter {
 
   // FIXME: call base class set encoding first to deal with sequence and
   // whatnot.
-  void setEncoding(proto::ColumnEncoding& encoding) const override {
+  void setEncoding(ColumnEncodingWriteWrapper& encoding) const override {
     BaseColumnWriter::setEncoding(encoding);
     if (useDictionaryEncoding_) {
-      encoding.set_kind(
-          proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY);
-      encoding.set_dictionarysize(finalDictionarySize_);
+      auto columnEncodingKind =
+          proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY;
+      encoding.setKind(ColumnEncodingKindWrapper(&columnEncodingKind));
+
+      encoding.setDictionarySize(finalDictionarySize_);
     }
   }
 
@@ -679,8 +683,9 @@ class TimestampColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     seconds_->flush();
     nanos_->flush();
@@ -788,8 +793,9 @@ class DecimalColumnWriter : public BaseColumnWriter {
   }
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     unscaledValues_->flush();
     scales_->flush();
@@ -954,8 +960,9 @@ class StringColumnWriter : public BaseColumnWriter {
   }
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     tryAbandonDictionaries(false);
     initStreamWriters(useDictionaryEncoding_);
 
@@ -1000,12 +1007,13 @@ class StringColumnWriter : public BaseColumnWriter {
 
   // FIXME: call base class set encoding first to deal with sequence and
   // whatnot.
-  void setEncoding(proto::ColumnEncoding& encoding) const override {
+  void setEncoding(ColumnEncodingWriteWrapper& encoding) const override {
     BaseColumnWriter::setEncoding(encoding);
     if (useDictionaryEncoding_) {
-      encoding.set_kind(
-          proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY);
-      encoding.set_dictionarysize(finalDictionarySize_);
+      auto columnEncodingKind =
+          proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DICTIONARY;
+      encoding.setKind(ColumnEncodingKindWrapper(&columnEncodingKind));
+      encoding.setDictionarySize(finalDictionarySize_);
     }
   }
 
@@ -1230,10 +1238,12 @@ uint64_t StringColumnWriter::writeDict(
   size_t strideIndex = strideOffsets_.size() - 1;
   uint64_t rawSize = 0;
   auto processRow = [&](size_t pos) {
-    auto sp = decodedVector.valueAt<StringView>(pos);
-    rows_.unsafeAppend(dictEncoder_.addKey(sp, strideIndex));
-    statsBuilder.addValues(sp);
-    rawSize += sp.size();
+    auto sv = decodedVector.valueAt<StringView>(pos);
+    // TODO: Remove explicit std::string_view cast.
+    rows_.unsafeAppend(dictEncoder_.addKey(std::string_view(sv), strideIndex));
+    // TODO: Remove explicit std::string_view cast.
+    statsBuilder.addValues(std::string_view(sv));
+    rawSize += sv.size();
   };
 
   uint64_t nullCount = 0;
@@ -1274,10 +1284,11 @@ uint64_t StringColumnWriter::writeDirect(
 
   uint64_t rawSize = 0;
   auto processRow = [&](size_t pos) {
-    auto sp = decodedVector.valueAt<StringView>(pos);
-    auto size = sp.size();
-    dataDirect_->write(sp.data(), size);
-    statsBuilder.addValues(sp);
+    auto sv = decodedVector.valueAt<StringView>(pos);
+    auto size = sv.size();
+    dataDirect_->write(sv.data(), size);
+    // TODO: Remove explicit std::string_view cast.
+    statsBuilder.addValues(std::string_view(sv));
     rawSize += size;
     lengths.unsafeAppend(size);
   };
@@ -1481,8 +1492,9 @@ class FloatColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     data_.flush();
   }
@@ -1612,8 +1624,9 @@ class BinaryColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     data_.flush();
     lengths_->flush();
@@ -1726,8 +1739,9 @@ class StructColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     for (auto& c : children_) {
       c->flush(encodingFactory);
@@ -1855,8 +1869,9 @@ class ListColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     lengths_->flush();
     children_.at(0)->flush(encodingFactory);
@@ -1982,8 +1997,9 @@ class MapColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override {
     BaseColumnWriter::flush(encodingFactory, encodingOverride);
     lengths_->flush();
     children_.at(0)->flush(encodingFactory);
@@ -2119,7 +2135,7 @@ std::unique_ptr<BaseColumnWriter> BaseColumnWriter::create(
           "MAP_FLAT_COLS contains column {}, but the root type of this column is {}."
           " Column root types must be of type MAP",
           type.column(),
-          mapTypeKindToName(type.type()->kind()));
+          TypeKindName::toName(type.type()->kind()));
     }
     const auto structColumnKeys =
         context.getConfig(Config::MAP_FLAT_COLS_STRUCT_KEYS);
@@ -2212,7 +2228,7 @@ std::unique_ptr<BaseColumnWriter> BaseColumnWriter::create(
     }
     default:
       VELOX_FAIL(
-          "not supported yet: {}", mapTypeKindToName(type.type()->kind()));
+          "not supported yet: {}", TypeKindName::toName(type.type()->kind()));
   }
 }
 } // namespace facebook::velox::dwrf
diff --git a/velox/dwio/dwrf/writer/ColumnWriter.h b/velox/dwio/dwrf/writer/ColumnWriter.h
index 98c5691babb9..ec7c8f09ab19 100644
--- a/velox/dwio/dwrf/writer/ColumnWriter.h
+++ b/velox/dwio/dwrf/writer/ColumnWriter.h
@@ -45,12 +45,31 @@ class ColumnWriter {
   virtual void reset() = 0;
 
   virtual void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride =
-          [](auto& /* e */) {}) = 0;
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride =
+          [](auto /* e */) {}) {
+    VELOX_NYI();
+  }
+
+  virtual void flush(
+      std::function<velox::dwrf::proto::ColumnEncoding&(uint32_t)>
+          encodingFactory,
+      std::function<void(velox::dwrf::proto::ColumnEncoding&)>
+          encodingOverride = [](auto& /* e */) {}) {
+    VELOX_NYI();
+  }
 
   virtual uint64_t writeFileStats(
-      std::function<proto::ColumnStatistics&(uint32_t)> statsFactory) const = 0;
+      std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory)
+      const {
+    VELOX_NYI();
+  }
+
+  virtual uint64_t writeFileStats(
+      std::function<velox::dwrf::proto::ColumnStatistics&(uint32_t)>
+          statsFactory) const {
+    VELOX_NYI();
+  }
 
   virtual bool tryAbandonDictionaries(bool force) = 0;
 
@@ -61,11 +80,13 @@ class ColumnWriter {
       const uint32_t sequence)
       : id_{id}, sequence_{sequence}, context_{context} {}
 
-  virtual void setEncoding(proto::ColumnEncoding& encoding) const {
-    encoding.set_kind(proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DIRECT);
-    encoding.set_dictionarysize(0);
-    encoding.set_node(id_);
-    encoding.set_sequence(sequence_);
+  virtual void setEncoding(ColumnEncodingWriteWrapper& columnEncoding) const {
+    auto columnEncodingKind =
+        proto::ColumnEncoding_Kind::ColumnEncoding_Kind_DIRECT;
+    columnEncoding.setKind(ColumnEncodingKindWrapper(&columnEncodingKind));
+    columnEncoding.setDictionarySize(0);
+    columnEncoding.setNode(id_);
+    columnEncoding.setSequence(sequence_);
   }
 
   const uint32_t id_;
@@ -99,9 +120,9 @@ class BaseColumnWriter : public ColumnWriter {
   }
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride =
-          [](auto& /* e */) {}) override {
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride =
+          [](auto /* e */) {}) override {
     if (!isRoot()) {
       present_->flush();
 
@@ -113,21 +134,22 @@ class BaseColumnWriter : public ColumnWriter {
       }
     }
 
-    auto& encoding = encodingFactory(id_);
+    auto encoding = encodingFactory(id_);
     setEncoding(encoding);
     encodingOverride(encoding);
     indexBuilder_->flush();
   }
 
-  uint64_t writeFileStats(std::function<proto::ColumnStatistics&(uint32_t)>
-                              statsFactory) const override {
-    auto& stats = statsFactory(id_);
+  uint64_t writeFileStats(
+      std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory)
+      const override {
+    auto stats = statsFactory(id_);
     fileStatsBuilder_->toProto(stats);
     const uint64_t size = context_.getPhysicalSizeAggregator(id_).getResult();
     for (auto& child : children_) {
       child->writeFileStats(statsFactory);
     }
-    stats.set_size(size);
+    stats.setSize(size);
     return size;
   }
 
diff --git a/velox/dwio/dwrf/writer/FlatMapColumnWriter.cpp b/velox/dwio/dwrf/writer/FlatMapColumnWriter.cpp
index 09297b38be61..65bea8d379fb 100644
--- a/velox/dwio/dwrf/writer/FlatMapColumnWriter.cpp
+++ b/velox/dwio/dwrf/writer/FlatMapColumnWriter.cpp
@@ -18,10 +18,9 @@
 #include <velox/dwio/dwrf/writer/StatisticsBuilder.h>
 #include "velox/type/Type.h"
 #include "velox/vector/ComplexVector.h"
-#include "velox/vector/FlatVector.h"
+#include "velox/vector/FlatMapVector.h"
 
 namespace facebook::velox::dwrf {
-
 namespace {
 
 template <typename T>
@@ -84,15 +83,17 @@ FlatMapColumnWriter<K>::FlatMapColumnWriter(
 
 template <TypeKind K>
 void FlatMapColumnWriter<K>::setEncoding(
-    proto::ColumnEncoding& encoding) const {
+    ColumnEncodingWriteWrapper& encoding) const {
   BaseColumnWriter::setEncoding(encoding);
-  encoding.set_kind(proto::ColumnEncoding_Kind::ColumnEncoding_Kind_MAP_FLAT);
+  auto columnEncodingKind =
+      proto::ColumnEncoding_Kind::ColumnEncoding_Kind_MAP_FLAT;
+  encoding.setKind(ColumnEncodingKindWrapper(&columnEncodingKind));
 }
 
 template <TypeKind K>
 void FlatMapColumnWriter<K>::flush(
-    std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-    std::function<void(proto::ColumnEncoding&)> encodingOverride) {
+    std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+    std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride) {
   BaseColumnWriter::flush(encodingFactory, encodingOverride);
 
   for (auto& pair : valueWriters_) {
@@ -136,18 +137,18 @@ void FlatMapColumnWriter<K>::createIndexEntry() {
 
 template <TypeKind K>
 uint64_t FlatMapColumnWriter<K>::writeFileStats(
-    std::function<proto::ColumnStatistics&(uint32_t)> statsFactory) const {
-  auto& stats = statsFactory(id_);
+    std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory) const {
+  auto stats = statsFactory(id_);
   fileStatsBuilder_->toProto(stats);
   uint64_t size = context_.getPhysicalSizeAggregator(id_).getResult();
 
-  auto& keyStats = statsFactory(keyType_.id());
+  auto keyStats = statsFactory(keyType_.id());
   keyFileStatsBuilder_->toProto(keyStats);
   auto keySize = context_.getPhysicalSizeAggregator(keyType_.id()).getResult();
-  keyStats.set_size(keySize);
+  keyStats.setSize(keySize);
 
   valueFileStatsBuilder_->writeFileStats(statsFactory);
-  stats.set_size(size);
+  stats.setSize(size);
   return size;
 }
 
@@ -175,6 +176,7 @@ void FlatMapColumnWriter<K>::reset() {
   valueWriters_.clear();
   rowsInStrides_.clear();
   rowsInCurrentStride_ = 0;
+  totalRows_ = 0;
 }
 
 KeyInfo getKeyInfo(int64_t key) {
@@ -199,11 +201,12 @@ ValueWriter& FlatMapColumnWriter<K>::getValueWriter(
   }
 
   if (valueWriters_.size() >= maxKeyCount_) {
-    DWIO_RAISE(fmt::format(
-        "Too many map keys requested in (node {}, column {}). Allowed: {}",
-        id_,
-        type_.column(),
-        maxKeyCount_));
+    DWIO_RAISE(
+        fmt::format(
+            "Too many map keys requested in (node {}, column {}). Allowed: {}",
+            id_,
+            type_.column(),
+            maxKeyCount_));
   }
 
   auto keyInfo = getKeyInfo(key);
@@ -239,27 +242,30 @@ ValueWriter& FlatMapColumnWriter<K>::getValueWriter(
 template <TypeKind K>
 uint32_t updateKeyStatistics(
     typename TypeInfo<K>::StatisticsBuilder& keyStatsBuilder,
-    typename TypeTraits<K>::NativeType value) {
-  keyStatsBuilder.addValues(value);
-  return sizeof(typename TypeTraits<K>::NativeType);
+    typename TypeTraits<K>::NativeType value,
+    uint64_t count = 1) {
+  keyStatsBuilder.addValues(value, count);
+  return sizeof(typename TypeTraits<K>::NativeType) * count;
 }
 
 template <>
 uint32_t updateKeyStatistics<TypeKind::VARCHAR>(
     StringStatisticsBuilder& keyStatsBuilder,
-    StringView value) {
+    StringView value,
+    uint64_t count) {
   auto size = value.size();
-  keyStatsBuilder.addValues(folly::StringPiece{value.data(), size});
-  return size;
+  keyStatsBuilder.addValues(std::string_view{value.data(), size}, count);
+  return size * count;
 }
 
 template <>
 uint32_t updateKeyStatistics<TypeKind::VARBINARY>(
     BinaryStatisticsBuilder& keyStatsBuilder,
-    StringView value) {
+    StringView value,
+    uint64_t count) {
   auto size = value.size();
-  keyStatsBuilder.addValues(size);
-  return size;
+  keyStatsBuilder.addValues(size, count);
+  return size * count;
 }
 
 namespace {
@@ -351,6 +357,11 @@ uint64_t FlatMapColumnWriter<K>::write(
     const common::Ranges& ranges) {
   switch (slice->typeKind()) {
     case TypeKind::MAP:
+      if (slice->wrappedVector()->encoding() ==
+          VectorEncoding::Simple::FLAT_MAP) {
+        return writeFlatMap(slice, ranges);
+      }
+
       return writeMap(slice, ranges);
     case TypeKind::ROW:
       if (!structKeys_.empty()) {
@@ -466,6 +477,7 @@ uint64_t FlatMapColumnWriter<K>::writeMap(
     rawSize += nullCount * NULL_SIZE;
   }
   rowsInCurrentStride_ += mapCount;
+  totalRows_ += mapCount;
   indexStatsBuilder_->increaseValueCount(mapCount);
   indexStatsBuilder_->increaseRawSize(rawSize);
   return rawSize;
@@ -486,6 +498,88 @@ common::Ranges getNonNullRanges(const common::Ranges& ranges, const Row& row) {
   return nonNullRanges;
 }
 
+template <TypeKind K>
+uint64_t FlatMapColumnWriter<K>::writeFlatMap(
+    const VectorPtr& vector,
+    const common::Ranges& ranges) {
+  uint64_t rawSize = 0;
+  common::Ranges nonNullRanges;
+
+  const FlatMapVector* flatMap = vector->as<FlatMapVector>();
+  if (flatMap) {
+    // FlatMap has no additional encodings.
+    writeNulls(vector, ranges);
+    nonNullRanges = getNonNullRanges(ranges, Flat{vector});
+  } else {
+    // FlatMap has additional encodings, we need to decode.
+    auto localDecodedFlatMap = decode(vector, ranges);
+    auto& decodedFlatMap = localDecodedFlatMap.get();
+    writeNulls(decodedFlatMap, ranges);
+    flatMap = decodedFlatMap.base()->template as<FlatMapVector>();
+    nonNullRanges = getNonNullRanges(ranges, Decoded{decodedFlatMap});
+  }
+
+  auto processFlatMap = [&](const auto& keys) {
+    const auto& inMaps = flatMap->inMaps();
+    const auto& values = flatMap->mapValues();
+
+    for (size_t i = 0; i < flatMap->numDistinctKeys(); i++) {
+      const uint64_t* inMapsForKey = nullptr;
+      auto nonNullRangesForKey = nonNullRanges;
+
+      if (i < inMaps.size() && inMaps[i] != nullptr) {
+        inMapsForKey = inMaps[i]->as<uint64_t>();
+
+        // Filter out only values where the key is present in the map.
+        nonNullRangesForKey = nonNullRanges.filter([&inMapsForKey](auto i) {
+          return bits::isBitSet(inMapsForKey, i);
+        });
+      }
+      const auto& valuesForKey = values[i];
+      const auto& key = keys.valueAt(i);
+
+      auto keySize = updateKeyStatistics<K>(
+          *keyFileStatsBuilder_, key, nonNullRangesForKey.size());
+      keyFileStatsBuilder_->increaseRawSize(keySize);
+      rawSize += keySize;
+
+      ValueWriter& valueWriter = getValueWriter(key, nonNullRanges.size());
+      valueWriter.writeBuffers(
+          nonNullRangesForKey, valuesForKey, nonNullRanges, inMapsForKey);
+    }
+  };
+
+  if (flatMap->distinctKeys()->isFlatEncoding()) {
+    processFlatMap(Flat<KeyType>{flatMap->distinctKeys()});
+  } else {
+    auto localDecodedKeys = decode(
+        flatMap->distinctKeys(),
+        common::Ranges::of(0, flatMap->distinctKeys()->size()));
+    processFlatMap(Decoded<KeyType>{localDecodedKeys.get()});
+  }
+
+  totalRows_ += nonNullRanges.size();
+
+  for (auto& pair : valueWriters_) {
+    if (totalRows_ != pair.second.writtenValues()) {
+      if (pair.second.writtenValues() > totalRows_) {
+        DWIO_RAISE("Duplicated key in map: ", pair.first);
+      }
+      pair.second.backfill(nonNullRanges.size());
+    }
+  }
+
+  size_t numNullRows = ranges.size() - nonNullRanges.size();
+  if (numNullRows > 0) {
+    indexStatsBuilder_->setHasNull();
+    rawSize += numNullRows * NULL_SIZE;
+  }
+  rowsInCurrentStride_ += nonNullRanges.size();
+  indexStatsBuilder_->increaseValueCount(nonNullRanges.size());
+  indexStatsBuilder_->increaseRawSize(rawSize);
+  return rawSize;
+}
+
 template <TypeKind K>
 uint64_t FlatMapColumnWriter<K>::writeRow(
     const VectorPtr& slice,
@@ -536,6 +630,7 @@ uint64_t FlatMapColumnWriter<K>::writeRow(
     rawSize += numNullRows * NULL_SIZE;
   }
   rowsInCurrentStride_ += nonNullRanges.size();
+  totalRows_ += nonNullRanges.size();
   indexStatsBuilder_->increaseValueCount(nonNullRanges.size());
   indexStatsBuilder_->increaseRawSize(rawSize);
   return rawSize;
diff --git a/velox/dwio/dwrf/writer/FlatMapColumnWriter.h b/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
index 6e50a0e435ac..ab92e520b76d 100644
--- a/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
+++ b/velox/dwio/dwrf/writer/FlatMapColumnWriter.h
@@ -53,14 +53,15 @@ class ValueStatisticsBuilder {
   }
 
   uint64_t writeFileStats(
-      std::function<proto::ColumnStatistics&(uint32_t)> statsFactory) const {
-    auto& stats = statsFactory(id_);
+      std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory)
+      const {
+    auto stats = statsFactory(id_);
     statisticsBuilder_->toProto(stats);
     uint64_t size = context_.getPhysicalSizeAggregator(id_).getResult();
     for (int32_t i = 0; i < children_.size(); ++i) {
       children_[i]->writeFileStats(statsFactory);
     }
-    stats.set_size(size);
+    stats.setSize(size);
     return size;
   }
 
@@ -137,6 +138,7 @@ class ValueWriter {
     if (mapCount) {
       inMap_->add(
           inMapBuffer_.data(), common::Ranges::of(0, mapCount), nullptr);
+      writtenValues_ += mapCount;
     }
 
     if (values) {
@@ -146,7 +148,7 @@ class ValueWriter {
   }
 
   // used for struct encoding writer
-  uint64_t writeBuffers(
+  void writeBuffers(
       const VectorPtr& values,
       const common::Ranges& nonNullRanges,
       const BufferPtr& inMapBuffer /* all 1 */) {
@@ -155,12 +157,28 @@ class ValueWriter {
           inMapBuffer->as<char>(),
           common::Ranges::of(0, nonNullRanges.size()),
           nullptr);
+      writtenValues_ += nonNullRanges.size();
     }
 
     if (values) {
-      return columnWriter_->write(values, nonNullRanges);
+      columnWriter_->write(values, nonNullRanges);
+    }
+  }
+
+  // used for flat map encoding writer
+  void writeBuffers(
+      const common::Ranges& valuesRanges,
+      const VectorPtr& values,
+      const common::Ranges& inMapRanges,
+      const uint64_t* inMapBuffer) {
+    if (inMapRanges.size()) {
+      inMap_->addBits(inMapBuffer, inMapRanges, nullptr, false);
+      writtenValues_ += inMapRanges.size();
+    }
+
+    if (valuesRanges.size()) {
+      columnWriter_->write(values, valuesRanges);
     }
-    return 0;
   }
 
   void backfill(uint32_t count) {
@@ -171,6 +189,7 @@ class ValueWriter {
     inMapBuffer_.reserve(count);
     std::memset(inMapBuffer_.data(), 0, count);
     inMap_->add(inMapBuffer_.data(), common::Ranges::of(0, count), nullptr);
+    writtenValues_ += count;
   }
 
   uint32_t getSequence() const {
@@ -191,15 +210,17 @@ class ValueWriter {
     columnWriter_->createIndexEntry();
   }
 
-  void flush(std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory) {
+  void flush(
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory) {
     inMap_->flush();
-    columnWriter_->flush(encodingFactory, [&](auto& encoding) {
-      *encoding.mutable_key() = keyInfo_;
+    columnWriter_->flush(encodingFactory, [&](auto encoding) {
+      *encoding.mutableKey() = keyInfo_;
     });
   }
 
   void reset() {
     columnWriter_->reset();
+    writtenValues_ = 0;
   }
 
   void resizeBuffers(size_t inMap) {
@@ -208,6 +229,10 @@ class ValueWriter {
     ranges_.clear();
   }
 
+  size_t writtenValues() const {
+    return writtenValues_;
+  }
+
  private:
   uint32_t sequence_;
   const proto::KeyInfo keyInfo_;
@@ -216,6 +241,7 @@ class ValueWriter {
   dwio::common::DataBuffer<char> inMapBuffer_;
   common::Ranges ranges_;
   const bool collectMapStats_;
+  size_t writtenValues_{0};
 };
 
 namespace {
@@ -266,25 +292,29 @@ class FlatMapColumnWriter : public BaseColumnWriter {
   uint64_t write(const VectorPtr& slice, const common::Ranges& ranges) override;
 
   void flush(
-      std::function<proto::ColumnEncoding&(uint32_t)> encodingFactory,
-      std::function<void(proto::ColumnEncoding&)> encodingOverride) override;
+      std::function<ColumnEncodingWriteWrapper(uint32_t)> encodingFactory,
+      std::function<void(ColumnEncodingWriteWrapper&)> encodingOverride)
+      override;
 
   void createIndexEntry() override;
 
   void reset() override;
 
-  uint64_t writeFileStats(std::function<proto::ColumnStatistics&(uint32_t)>
-                              statsFactory) const override;
+  uint64_t writeFileStats(
+      std::function<ColumnStatisticsWriteWrapper(uint32_t)> statsFactory)
+      const override;
 
  private:
   using KeyType = typename TypeTraits<K>::NativeType;
 
-  void setEncoding(proto::ColumnEncoding& encoding) const override;
+  void setEncoding(ColumnEncodingWriteWrapper& encoding) const override;
 
   ValueWriter& getValueWriter(KeyType key, uint32_t inMapSize);
 
-  // write() calls writeMap() or writeRow() depending on input type
+  // write() calls writeMap(), writeFlatMap(), or writeRow() depending on input
+  // type and encoding
   uint64_t writeMap(const VectorPtr& slice, const common::Ranges& ranges);
+  uint64_t writeFlatMap(const VectorPtr& slice, const common::Ranges& ranges);
   uint64_t writeRow(const VectorPtr& slice, const common::Ranges& ranges);
 
   void clearNodes();
@@ -300,6 +330,10 @@ class FlatMapColumnWriter : public BaseColumnWriter {
   // Captures current row count for current (incomplete) stride
   size_t rowsInCurrentStride_{0};
 
+  // Captures current row count for current stripe (sum of rowsInStrides_ +
+  // rowsInCurrentStride_)
+  size_t totalRows_{0};
+
   // Remember key and value types. Needed for constructing value writers
   const dwio::common::TypeWithId& keyType_;
   const dwio::common::TypeWithId& valueType_;
diff --git a/velox/dwio/dwrf/writer/IndexBuilder.h b/velox/dwio/dwrf/writer/IndexBuilder.h
index 57582199fc56..88cbade7dc35 100644
--- a/velox/dwio/dwrf/writer/IndexBuilder.h
+++ b/velox/dwio/dwrf/writer/IndexBuilder.h
@@ -16,12 +16,14 @@
 
 #pragma once
 
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/OutputStream.h"
 #include "velox/dwio/dwrf/common/wrap/dwrf-proto-wrapper.h"
 #include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
 
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
 using dwio::common::BufferedOutputStream;
 using dwio::common::PositionRecorder;
 
@@ -35,41 +37,50 @@ constexpr int32_t PRESENT_STREAM_INDEX_ENTRIES_PAGED =
 
 class IndexBuilder : public PositionRecorder {
  public:
-  IndexBuilder(std::unique_ptr<BufferedOutputStream> out)
-      : out_{std::move(out)} {}
+  IndexBuilder(
+      std::unique_ptr<BufferedOutputStream> out,
+      dwio::common::FileFormat fileFormat = dwio::common::FileFormat::DWRF)
+      : out_{std::move(out)},
+        arena_(std::make_unique<google::protobuf::Arena>()) {
+    auto rowIndex = ArenaCreate<proto::RowIndex>(arena_.get());
+    auto rowIndexEntry = ArenaCreate<proto::RowIndexEntry>(arena_.get());
+
+    index_ = std::make_unique<RowIndexWriteWrapper>(rowIndex);
+    entry_ = std::make_unique<RowIndexEntryWriteWrapper>(rowIndexEntry);
+  }
 
   virtual ~IndexBuilder() = default;
 
   void add(uint64_t pos, int32_t index = -1) override {
-    getEntry(index)->add_positions(pos);
+    getEntry(index).addPositions(pos);
   }
 
   virtual void addEntry(const StatisticsBuilder& writer) {
-    auto* stats = entry_.mutable_statistics();
-    writer.toProto(*stats);
-    *index_.add_entry() = entry_;
-    entry_.Clear();
+    auto stats = entry_->mutableStatistics();
+    writer.toProto(stats);
+    index_->addEntry(entry_);
+    entry_->clear();
   }
 
   virtual size_t getEntrySize() const {
-    const int32_t size = index_.entry_size() + 1;
+    const int32_t size = index_->entrySize() + 1;
     VELOX_CHECK_GT(size, 0, "Invalid entry size or missing current entry.");
     return size;
   }
 
   virtual void flush() {
     // remove isPresent positions if none is null
-    index_.SerializeToZeroCopyStream(out_.get());
+    index_->SerializeToZeroCopyStream(out_.get());
     out_->flush();
-    index_.Clear();
-    entry_.Clear();
+    index_->clear();
+    entry_->clear();
   }
 
   void capturePresentStreamOffset() {
     if (!presentStreamOffset_.has_value()) {
-      presentStreamOffset_ = entry_.positions_size();
+      presentStreamOffset_ = entry_->positionsSize();
     } else {
-      DWIO_ENSURE_EQ(presentStreamOffset_.value(), entry_.positions_size());
+      DWIO_ENSURE_EQ(presentStreamOffset_.value(), entry_->positionsSize());
     }
   }
 
@@ -79,27 +90,28 @@ class IndexBuilder : public PositionRecorder {
                                      : PRESENT_STREAM_INDEX_ENTRIES_UNPAGED;
 
     // Only need to process entries that have been added to the row index
-    for (uint32_t i = 0; i < index_.entry_size(); ++i) {
-      index_.mutable_entry(i)->mutable_positions()->ExtractSubrange(
-          presentStreamOffset_.value(), streamCount, nullptr);
+    for (uint32_t i = 0; i < index_->entrySize(); ++i) {
+      index_->mutableEntry(i).mutablePositions(
+          presentStreamOffset_.value(), streamCount);
     }
   }
 
  private:
-  proto::RowIndexEntry* getEntry(int32_t index) {
+  RowIndexEntryWriteWrapper getEntry(int32_t index) {
     if (index < 0) {
-      return &entry_;
-    } else if (index < index_.entry_size()) {
-      return index_.mutable_entry(index);
+      return *entry_;
+    } else if (index < index_->entrySize()) {
+      return index_->mutableEntry(index);
     } else {
-      VELOX_CHECK_EQ(index, index_.entry_size());
-      return &entry_;
+      VELOX_CHECK_EQ(index, index_->entrySize());
+      return *entry_;
     }
   }
 
   const std::unique_ptr<BufferedOutputStream> out_;
-  proto::RowIndex index_;
-  proto::RowIndexEntry entry_;
+  std::unique_ptr<RowIndexWriteWrapper> index_;
+  std::unique_ptr<RowIndexEntryWriteWrapper> entry_;
+  std::unique_ptr<google::protobuf::Arena> arena_;
   std::optional<int32_t> presentStreamOffset_;
 
   friend class IndexBuilderTest;
diff --git a/velox/dwio/dwrf/writer/LayoutPlanner.cpp b/velox/dwio/dwrf/writer/LayoutPlanner.cpp
index 9ef2fb6223c9..334097a435f4 100644
--- a/velox/dwio/dwrf/writer/LayoutPlanner.cpp
+++ b/velox/dwio/dwrf/writer/LayoutPlanner.cpp
@@ -16,14 +16,19 @@
 
 #include "velox/dwio/dwrf/writer/LayoutPlanner.h"
 
+#include "velox/dwio/common/Arena.h"
+
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
+
 StreamList getStreamList(WriterContext& context) {
   StreamList streams;
   streams.reserve(context.getStreamCount());
   context.iterateUnSuppressedStreams([&](auto& pair) {
-    streams.push_back(std::make_pair(
-        std::addressof(pair.first), std::addressof(pair.second)));
+    streams.push_back(
+        std::make_pair(
+            std::addressof(pair.first), std::addressof(pair.second)));
   });
   return streams;
 }
@@ -114,10 +119,6 @@ bool EncodingIter::operator==(const EncodingIter& other) const {
   return current_ == other.current_;
 }
 
-bool EncodingIter::operator!=(const EncodingIter& other) const {
-  return current_ != other.current_;
-}
-
 EncodingIter::reference EncodingIter::operator*() const {
   return *current_;
 }
@@ -128,49 +129,54 @@ EncodingIter::pointer EncodingIter::operator->() const {
 
 EncodingManager::EncodingManager(
     const encryption::EncryptionHandler& encryptionHandler)
-    : encryptionHandler_{encryptionHandler} {
+    : encryptionHandler_{encryptionHandler},
+      arena_{std::make_unique<google::protobuf::Arena>()} {
   initEncryptionGroups();
+  auto dwrfStripeFooter = ArenaCreate<proto::StripeFooter>(arena_.get());
+  footer_ = std::make_unique<StripeFooterWriteWrapper>(dwrfStripeFooter);
 }
 
-proto::ColumnEncoding& EncodingManager::addEncodingToFooter(uint32_t nodeId) {
+ColumnEncodingWriteWrapper EncodingManager::addEncodingToFooter(
+    uint32_t nodeId) {
   if (encryptionHandler_.isEncrypted(nodeId)) {
     auto index = encryptionHandler_.getEncryptionGroupIndex(nodeId);
-    return *encryptionGroups_.at(index).add_encoding();
+    return ColumnEncodingWriteWrapper(
+        encryptionGroups_.at(index).add_encoding());
   } else {
-    return *footer_.add_encoding();
+    return footer_->addEncoding();
   }
 }
 
-proto::Stream* EncodingManager::addStreamToFooter(
+StreamWriteWrapper EncodingManager::addStreamToFooter(
     uint32_t nodeId,
     uint32_t& currentIndex) {
   if (encryptionHandler_.isEncrypted(nodeId)) {
     currentIndex = encryptionHandler_.getEncryptionGroupIndex(nodeId);
-    return encryptionGroups_.at(currentIndex).add_streams();
+    return StreamWriteWrapper(encryptionGroups_.at(currentIndex).add_streams());
   } else {
     currentIndex = std::numeric_limits<uint32_t>::max();
-    return footer_.add_streams();
+    return footer_->addStreams();
   }
 }
 
 std::string* EncodingManager::addEncryptionGroupToFooter() {
-  return footer_.add_encryptiongroups();
+  return footer_->addEncryptionGroups();
 }
 
 proto::StripeEncryptionGroup EncodingManager::getEncryptionGroup(uint32_t i) {
   return encryptionGroups_.at(i);
 }
 
-const proto::StripeFooter& EncodingManager::getFooter() const {
-  return footer_;
+const StripeFooterWriteWrapper& EncodingManager::getFooter() const {
+  return *footer_;
 }
 
 EncodingIter EncodingManager::begin() const {
-  return EncodingIter::begin(footer_, encryptionGroups_);
+  return EncodingIter::begin(*footer_->dwrfPtr(), encryptionGroups_);
 }
 
 EncodingIter EncodingManager::end() const {
-  return EncodingIter::end(footer_, encryptionGroups_);
+  return EncodingIter::end(*footer_->dwrfPtr(), encryptionGroups_);
 }
 
 void EncodingManager::initEncryptionGroups() {
diff --git a/velox/dwio/dwrf/writer/LayoutPlanner.h b/velox/dwio/dwrf/writer/LayoutPlanner.h
index 558c1467bccb..ac22f9d736f2 100644
--- a/velox/dwio/dwrf/writer/LayoutPlanner.h
+++ b/velox/dwio/dwrf/writer/LayoutPlanner.h
@@ -48,7 +48,6 @@ class EncodingIter {
   EncodingIter& operator++();
   EncodingIter operator++(int);
   bool operator==(const EncodingIter& other) const;
-  bool operator!=(const EncodingIter& other) const;
   reference operator*() const;
   pointer operator->() const;
 
@@ -90,11 +89,11 @@ class EncodingManager : public EncodingContainer {
       const encryption::EncryptionHandler& encryptionHandler);
   virtual ~EncodingManager() override = default;
 
-  proto::ColumnEncoding& addEncodingToFooter(uint32_t nodeId);
-  proto::Stream* addStreamToFooter(uint32_t nodeId, uint32_t& currentIndex);
+  ColumnEncodingWriteWrapper addEncodingToFooter(uint32_t nodeId);
+  StreamWriteWrapper addStreamToFooter(uint32_t nodeId, uint32_t& currentIndex);
   std::string* addEncryptionGroupToFooter();
   proto::StripeEncryptionGroup getEncryptionGroup(uint32_t i);
-  const proto::StripeFooter& getFooter() const;
+  const StripeFooterWriteWrapper& getFooter() const;
 
   EncodingIter begin() const override;
   EncodingIter end() const override;
@@ -103,7 +102,8 @@ class EncodingManager : public EncodingContainer {
   void initEncryptionGroups();
 
   const encryption::EncryptionHandler& encryptionHandler_;
-  proto::StripeFooter footer_;
+  std::unique_ptr<StripeFooterWriteWrapper> footer_;
+  std::unique_ptr<google::protobuf::Arena> arena_;
   std::vector<proto::StripeEncryptionGroup> encryptionGroups_;
 };
 
diff --git a/velox/dwio/dwrf/writer/StatisticsBuilder.cpp b/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
index 3000230c1156..b716d1aa71aa 100644
--- a/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
+++ b/velox/dwio/dwrf/writer/StatisticsBuilder.cpp
@@ -16,8 +16,12 @@
 
 #include "velox/dwio/dwrf/writer/StatisticsBuilder.h"
 
+#include "velox/dwio/common/Arena.h"
+
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
+
 namespace {
 
 static bool isValidLength(const std::optional<uint64_t>& length) {
@@ -101,28 +105,30 @@ void StatisticsBuilder::merge(
   }
 }
 
-void StatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
+void StatisticsBuilder::toProto(ColumnStatisticsWriteWrapper& stats) const {
   if (hasNull_.has_value()) {
-    stats.set_hasnull(hasNull_.value());
+    stats.setHasNull(hasNull_.value());
   }
   if (valueCount_.has_value()) {
-    stats.set_numberofvalues(valueCount_.value());
+    stats.setNumberOfValues(valueCount_.value());
   }
   if (rawSize_.has_value()) {
-    stats.set_rawsize(rawSize_.value());
+    stats.setRawSize(rawSize_.value());
   }
   if (size_.has_value()) {
-    stats.set_size(size_.value());
+    stats.setSize(size_.value());
   }
 }
 
 std::unique_ptr<dwio::common::ColumnStatistics> StatisticsBuilder::build()
     const {
-  proto::ColumnStatistics stats;
+  auto columnStatistics = ArenaCreate<proto::ColumnStatistics>(arena_.get());
+  auto stats = ColumnStatisticsWriteWrapper(columnStatistics);
   toProto(stats);
+
   StatsContext context{WriterVersion_CURRENT};
-  auto result =
-      buildColumnStatisticsFromProto(ColumnStatisticsWrapper(&stats), context);
+  auto result = buildColumnStatisticsFromProto(
+      ColumnStatisticsWrapper(columnStatistics), context);
   // We do not alter the proto since this is part of the file format
   // and the file format. The distinct count does not exist in the
   // file format but is added here for use in on demand sampling.
@@ -230,13 +236,14 @@ void BooleanStatisticsBuilder::merge(
   mergeCount(trueCount_, stats->getTrueCount());
 }
 
-void BooleanStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
+void BooleanStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
   StatisticsBuilder::toProto(stats);
   // Serialize type specific stats only if there is non-null values
   if (!isEmpty(*this) && trueCount_.has_value()) {
-    auto bStats = stats.mutable_bucketstatistics();
-    DWIO_ENSURE_EQ(bStats->count_size(), 0);
-    bStats->add_count(trueCount_.value());
+    auto bStats = stats.mutableBucketStatistics();
+    DWIO_ENSURE_EQ(bStats.countSize(), 0);
+    bStats.addCount(trueCount_.value());
   }
 }
 
@@ -263,20 +270,21 @@ void IntegerStatisticsBuilder::merge(
   mergeWithOverflowCheck(sum_, stats->getSum());
 }
 
-void IntegerStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
+void IntegerStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
   StatisticsBuilder::toProto(stats);
   // Serialize type specific stats only if there is non-null values
   if (!isEmpty(*this) &&
       (min_.has_value() || max_.has_value() || sum_.has_value())) {
-    auto iStats = stats.mutable_intstatistics();
+    auto iStats = stats.mutableIntegerStatistics();
     if (min_.has_value()) {
-      iStats->set_minimum(min_.value());
+      iStats.setMinimum(min_.value());
     }
     if (max_.has_value()) {
-      iStats->set_maximum(max_.value());
+      iStats.setMaximum(max_.value());
     }
     if (sum_.has_value()) {
-      iStats->set_sum(sum_.value());
+      iStats.setSum(sum_.value());
     }
   }
 }
@@ -305,20 +313,21 @@ void DoubleStatisticsBuilder::merge(
   }
 }
 
-void DoubleStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
+void DoubleStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
   StatisticsBuilder::toProto(stats);
   // Serialize type specific stats only if there is non-null values
   if (!isEmpty(*this) &&
       (min_.has_value() || max_.has_value() || sum_.has_value())) {
-    auto dStats = stats.mutable_doublestatistics();
+    auto dStats = stats.mutableDoubleStatistics();
     if (min_.has_value()) {
-      dStats->set_minimum(min_.value());
+      dStats.setMinimum(min_.value());
     }
     if (max_.has_value()) {
-      dStats->set_maximum(max_.value());
+      dStats.setMaximum(max_.value());
     }
     if (sum_.has_value()) {
-      dStats->set_sum(sum_.value());
+      dStats.setSum(sum_.value());
     }
   }
 }
@@ -361,22 +370,23 @@ void StringStatisticsBuilder::merge(
   mergeWithOverflowCheck(length_, stats->getTotalLength());
 }
 
-void StringStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
+void StringStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
   StatisticsBuilder::toProto(stats);
   // If string value is too long, drop it and fall back to basic stats
   if (!isEmpty(*this) &&
       (shouldKeep(min_) || shouldKeep(max_) || isValidLength(length_))) {
-    auto dStats = stats.mutable_stringstatistics();
+    auto dStats = stats.mutableStringStatistics();
     if (isValidLength(length_)) {
-      dStats->set_sum(length_.value());
+      dStats.setSum(length_.value());
     }
 
     if (shouldKeep(min_)) {
-      dStats->set_minimum(min_.value());
+      dStats.setMinimum(min_.value());
     }
 
     if (shouldKeep(max_)) {
-      dStats->set_maximum(max_.value());
+      dStats.setMaximum(max_.value());
     }
   }
 }
@@ -399,12 +409,13 @@ void BinaryStatisticsBuilder::merge(
   mergeWithOverflowCheck(length_, stats->getTotalLength());
 }
 
-void BinaryStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
+void BinaryStatisticsBuilder::toProto(
+    ColumnStatisticsWriteWrapper& stats) const {
   StatisticsBuilder::toProto(stats);
   // Serialize type specific stats only if there is non-null values
   if (!isEmpty(*this) && isValidLength(length_)) {
-    auto bStats = stats.mutable_binarystatistics();
-    bStats->set_sum(length_.value());
+    auto bStats = stats.mutableBinaryStatistics();
+    bStats.setSum(length_.value());
   }
 }
 
@@ -427,10 +438,10 @@ void MapStatisticsBuilder::merge(
   }
 }
 
-void MapStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
+void MapStatisticsBuilder::toProto(ColumnStatisticsWriteWrapper& stats) const {
   StatisticsBuilder::toProto(stats);
   if (!isEmpty(*this) && !entryStatistics_.empty()) {
-    auto mapStats = stats.mutable_mapstatistics();
+    auto mapStats = stats.mutableMapStatistics();
     for (const auto& entry : entryStatistics_) {
       auto entryStatistics = mapStats->add_stats();
       const auto& key = entry.first;
@@ -440,8 +451,8 @@ void MapStatisticsBuilder::toProto(proto::ColumnStatistics& stats) const {
       } else if (key.bytesKey.has_value()) {
         entryStatistics->mutable_key()->set_byteskey(key.bytesKey.value());
       }
-      dynamic_cast<const StatisticsBuilder&>(*entry.second)
-          .toProto(*entryStatistics->mutable_stats());
+      auto c = ColumnStatisticsWriteWrapper(entryStatistics->mutable_stats());
+      dynamic_cast<const StatisticsBuilder&>(*entry.second).toProto(c);
     }
   }
 }
diff --git a/velox/dwio/dwrf/writer/StatisticsBuilder.h b/velox/dwio/dwrf/writer/StatisticsBuilder.h
index 3441a5ddf9a1..497d78377468 100644
--- a/velox/dwio/dwrf/writer/StatisticsBuilder.h
+++ b/velox/dwio/dwrf/writer/StatisticsBuilder.h
@@ -109,7 +109,7 @@ class StatisticsBuilder : public virtual dwio::common::ColumnStatistics {
  public:
   /// Constructs with 'options'.
   explicit StatisticsBuilder(const StatisticsBuilderOptions& options)
-      : options_{options} {
+      : options_{options}, arena_(std::make_unique<google::protobuf::Arena>()) {
     init();
   }
 
@@ -177,7 +177,7 @@ class StatisticsBuilder : public virtual dwio::common::ColumnStatistics {
   /*
    * Write stats to proto
    */
-  virtual void toProto(proto::ColumnStatistics& stats) const;
+  virtual void toProto(ColumnStatisticsWriteWrapper& stats) const;
 
   std::unique_ptr<dwio::common::ColumnStatistics> build() const;
 
@@ -198,13 +198,14 @@ class StatisticsBuilder : public virtual dwio::common::ColumnStatistics {
     rawSize_ = 0;
     size_ = options_.initialSize;
     if (options_.countDistincts) {
-      hll_ = std::make_shared<common::hll::SparseHll>(options_.allocator);
+      hll_ = std::make_shared<common::hll::SparseHll<>>(options_.allocator);
     }
   }
 
  protected:
   StatisticsBuilderOptions options_;
-  std::shared_ptr<common::hll::SparseHll> hll_;
+  std::shared_ptr<common::hll::SparseHll<>> hll_;
+  std::unique_ptr<google::protobuf::Arena> arena_;
 };
 
 class BooleanStatisticsBuilder : public StatisticsBuilder,
@@ -233,7 +234,7 @@ class BooleanStatisticsBuilder : public StatisticsBuilder,
     init();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 
  private:
   void init() {
@@ -272,7 +273,7 @@ class IntegerStatisticsBuilder : public StatisticsBuilder,
     init();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 
  private:
   void init() {
@@ -332,7 +333,7 @@ class DoubleStatisticsBuilder : public StatisticsBuilder,
     init();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 
  private:
   void init() {
@@ -358,7 +359,7 @@ class StringStatisticsBuilder : public StatisticsBuilder,
 
   ~StringStatisticsBuilder() override = default;
 
-  void addValues(folly::StringPiece value, uint64_t count = 1) {
+  void addValues(std::string_view value, uint64_t count = 1) {
     // min_/max_ is not initialized with default that can be compared against
     // easily. So we need to capture whether self is empty and handle
     // differently.
@@ -368,10 +369,10 @@ class StringStatisticsBuilder : public StatisticsBuilder,
       min_ = value;
       max_ = value;
     } else {
-      if (min_.has_value() && value < folly::StringPiece{min_.value()}) {
+      if (min_.has_value() && value < std::string_view{min_.value()}) {
         min_ = value;
       }
-      if (max_.has_value() && value > folly::StringPiece{max_.value()}) {
+      if (max_.has_value() && value > std::string_view{max_.value()}) {
         max_ = value;
       }
     }
@@ -389,7 +390,7 @@ class StringStatisticsBuilder : public StatisticsBuilder,
     init();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 
  private:
   uint32_t lengthLimit_;
@@ -429,7 +430,7 @@ class BinaryStatisticsBuilder : public StatisticsBuilder,
     init();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 
  private:
   void init() {
@@ -477,7 +478,7 @@ class MapStatisticsBuilder : public StatisticsBuilder,
     init();
   }
 
-  void toProto(proto::ColumnStatistics& stats) const override;
+  void toProto(ColumnStatisticsWriteWrapper& stats) const override;
 
  private:
   void init() {
diff --git a/velox/dwio/dwrf/writer/StatisticsBuilderUtils.cpp b/velox/dwio/dwrf/writer/StatisticsBuilderUtils.cpp
index 3babe373db2a..89dbcd1cfefb 100644
--- a/velox/dwio/dwrf/writer/StatisticsBuilderUtils.cpp
+++ b/velox/dwio/dwrf/writer/StatisticsBuilderUtils.cpp
@@ -81,18 +81,18 @@ void StatisticsBuilderUtils::addValues(
     const VectorPtr& vector,
     const common::Ranges& ranges) {
   auto nulls = vector->rawNulls();
-  auto data = vector->asFlatVector<StringView>()->rawValues();
+  auto* data = vector->asFlatVector<StringView>()->rawValues();
   if (vector->mayHaveNulls()) {
     for (auto& pos : ranges) {
       if (bits::isBitNull(nulls, pos)) {
         builder.setHasNull();
       } else {
-        builder.addValues(folly::StringPiece{data[pos]});
+        builder.addValues(std::string_view{data[pos]});
       }
     }
   } else {
     for (auto& pos : ranges) {
-      builder.addValues(folly::StringPiece{data[pos]});
+      builder.addValues(std::string_view{data[pos]});
     }
   }
 }
diff --git a/velox/dwio/dwrf/writer/StringDictionaryEncoder.h b/velox/dwio/dwrf/writer/StringDictionaryEncoder.h
index 8ecb635f8655..20abfaac8582 100644
--- a/velox/dwio/dwrf/writer/StringDictionaryEncoder.h
+++ b/velox/dwio/dwrf/writer/StringDictionaryEncoder.h
@@ -30,22 +30,22 @@ namespace detail {
 
 // Each new string inserted into dictionary is assigned an incrementing id.
 // A set is maintained with all of the DictStringId created. Using
-// Heterogeneous lookup techniques, incoming StringPiece is first looked for
+// Heterogeneous lookup techniques, incoming string_view is first looked for
 // a match in the set. If no match exists a new id is generated and inserted
 // into the set. What is Heterogeneous lookup ?
 // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0919r1.html
 // Heterogeneous lookup is not available in standard CPP and proposed for CPP20.
 // Follys:F14* variant supports it, so leveraging folly for now.
 struct StringLookupKey {
-  StringLookupKey(folly::StringPiece sp, uint32_t index)
-      : sp{sp},
+  StringLookupKey(std::string_view sv, uint32_t index)
+      : sv{sv},
         index{index},
         hash{folly::crc32c(
-            reinterpret_cast<const uint8_t*>(sp.data()),
-            sp.size(),
+            reinterpret_cast<const uint8_t*>(sv.data()),
+            sv.size(),
             0 /* seed */)} {}
 
-  const folly::StringPiece sp;
+  const std::string_view sv;
   const uint32_t index;
   const uint32_t hash;
 };
@@ -117,9 +117,9 @@ class StringDictionaryEncoder {
   }
 
   uint32_t
-  addKey(folly::StringPiece sp, uint32_t strideIndex, uint32_t count = 1) {
+  addKey(std::string_view sv, uint32_t strideIndex, uint32_t count = 1) {
     auto newIndex = size();
-    detail::StringLookupKey key{sp, newIndex};
+    detail::StringLookupKey key{sv, newIndex};
     auto result = keyIndex_.insert(key);
     if (!result.second) {
       auto index = result.first->getIndex();
@@ -130,12 +130,12 @@ class StringDictionaryEncoder {
     auto bytesCount = keyBytes_.size();
     if (UNLIKELY(
             newIndex == std::numeric_limits<uint32_t>::max() ||
-            (std::numeric_limits<uint32_t>::max() - bytesCount <= sp.size()))) {
+            (std::numeric_limits<uint32_t>::max() - bytesCount <= sv.size()))) {
       DWIO_RAISE("exceeds dictionary size limit");
     }
 
     // append keys
-    keyBytes_.extendAppend(bytesCount, sp.data(), sp.size());
+    keyBytes_.extendAppend(bytesCount, sv.data(), sv.size());
     keyOffsets_.append(keyBytes_.size());
     hash_.append(key.hash);
     counts_.append(count);
@@ -153,11 +153,11 @@ class StringDictionaryEncoder {
     return firstSeenStrideIndex_[index];
   }
 
-  folly::StringPiece getKey(uint32_t index) const {
+  std::string_view getKey(uint32_t index) const {
     DCHECK(index < keyOffsets_.size() - 1);
     auto startOffset = keyOffsets_[index];
     auto endOffset = keyOffsets_[index + 1];
-    return folly::StringPiece{
+    return std::string_view{
         keyBytes_.data() + startOffset, endOffset - startOffset};
   }
 
@@ -178,8 +178,8 @@ class StringDictionaryEncoder {
   VELOX_FRIEND_TEST(TestStringDictionaryEncoder, Clear);
 
   // Intended for testing only.
-  uint32_t getIndex(folly::StringPiece sp) {
-    detail::StringLookupKey key{sp, 0};
+  uint32_t getIndex(std::string_view sv) {
+    detail::StringLookupKey key{sv, 0};
     auto result = keyIndex_.find(key);
     if (result != keyIndex_.end()) {
       return result->getIndex();
@@ -221,7 +221,7 @@ FOLLY_ALWAYS_INLINE bool DictStringIdEquality::operator()(
 FOLLY_ALWAYS_INLINE bool DictStringIdEquality::operator()(
     detail::StringLookupKey key,
     detail::DictStringId lhs) const {
-  return encoder_.getKey(lhs.getIndex()) == key.sp;
+  return encoder_.getKey(lhs.getIndex()) == key.sv;
 }
 
 FOLLY_ALWAYS_INLINE uint32_t
diff --git a/velox/dwio/dwrf/writer/Writer.cpp b/velox/dwio/dwrf/writer/Writer.cpp
index d6011c38f8de..26edce0d9105 100644
--- a/velox/dwio/dwrf/writer/Writer.cpp
+++ b/velox/dwio/dwrf/writer/Writer.cpp
@@ -213,10 +213,11 @@ Writer::Writer(
     : Writer{
           std::move(sink),
           options,
-          options.memoryPool->addAggregateChild(fmt::format(
-              "{}.dwrf.{}",
-              options.memoryPool->name(),
-              folly::to<std::string>(folly::Random::rand64())))} {}
+          options.memoryPool->addAggregateChild(
+              fmt::format(
+                  "{}.dwrf.{}",
+                  options.memoryPool->name(),
+                  folly::to<std::string>(folly::Random::rand64())))} {}
 
 void Writer::setMemoryReclaimers(
     const std::shared_ptr<memory::MemoryPool>& pool) {
@@ -521,7 +522,7 @@ void Writer::flushStripe(bool close) {
   const auto& handler = context.getEncryptionHandler();
   EncodingManager encodingManager{handler};
 
-  writer_->flush([&](uint32_t nodeId) -> proto::ColumnEncoding& {
+  writer_->flush([&](uint32_t nodeId) -> ColumnEncodingWriteWrapper {
     return encodingManager.addEncodingToFooter(nodeId);
   });
 
@@ -546,7 +547,8 @@ void Writer::flushStripe(bool close) {
                              const DataBufferHolder& out) {
     uint32_t currentIndex = 0;
     const auto nodeId = stream.encodingKey().node();
-    proto::Stream* s = encodingManager.addStreamToFooter(nodeId, currentIndex);
+    StreamWriteWrapper s =
+        encodingManager.addStreamToFooter(nodeId, currentIndex);
 
     // set offset only when needed, ie. when offset of current stream cannot be
     // calculated based on offset and length of previous stream. In that case,
@@ -554,19 +556,19 @@ void Writer::flushStripe(bool close) {
     // encryption group or neither are encrypted. So the logic is simplified to
     // check if group index are the same for current and previous stream
     if (offset > 0 && lastIndex != currentIndex) {
-      s->set_offset(offset);
+      s.setOffset(offset);
     }
     lastIndex = currentIndex;
 
     // Jolly/Presto readers can't read streams bigger than 2GB.
     writerBase_->validateStreamSize(stream, out.size());
 
-    s->set_kind(static_cast<proto::Stream_Kind>(stream.kind()));
-    s->set_node(nodeId);
-    s->set_column(stream.column());
-    s->set_sequence(stream.encodingKey().sequence());
-    s->set_length(out.size());
-    s->set_usevints(context.getConfig(Config::USE_VINTS));
+    s.setKind(stream.kind());
+    s.setNode(nodeId);
+    s.setColumn(stream.column());
+    s.setSequence(stream.encodingKey().sequence());
+    s.setLength(out.size());
+    s.setUseVints(context.getConfig(Config::USE_VINTS));
     offset += out.size();
 
     context.recordPhysicalSize(stream, out.size());
@@ -619,19 +621,20 @@ void Writer::flushStripe(bool close) {
   VELOX_CHECK_EQ(footerOffset, stripeOffset + dataLength + indexLength);
 
   sink.setMode(WriterSink::Mode::Footer);
-  writerBase_->writeProto(encodingManager.getFooter());
+  encodingManager.getFooter().setWriterTimezone();
+  writerBase_->writeProto(&encodingManager.getFooter());
   sink.setMode(WriterSink::Mode::None);
 
-  auto& stripe = writerBase_->addStripeInfo();
-  stripe.set_offset(stripeOffset);
-  stripe.set_indexlength(indexLength);
-  stripe.set_datalength(dataLength);
-  stripe.set_footerlength(sink.size() - footerOffset);
+  auto stripe = writerBase_->addStripeInfo();
+  stripe.setOffset(stripeOffset);
+  stripe.setIndexLength(indexLength);
+  stripe.setDataLength(dataLength);
+  stripe.setFooterLength(sink.size() - footerOffset);
 
   // set encryption key metadata
   if (handler.isEncrypted() && context.stripeIndex() == 0) {
     for (uint32_t i = 0; i < handler.getEncryptionGroupCount(); ++i) {
-      *stripe.add_keymetadata() =
+      *stripe.addKeyMetadata() =
           handler.getEncryptionProviderByIndex(i).getKey();
     }
   }
@@ -694,10 +697,10 @@ void Writer::flushInternal(bool close) {
       proto::Encryption* encryption = nullptr;
 
       // initialize encryption related metadata only when there is data written
-      if (handler.isEncrypted() && footer.stripes_size() > 0) {
+      if (handler.isEncrypted() && footer->stripesSize() > 0) {
         const auto count = handler.getEncryptionGroupCount();
         stats.resize(count);
-        encryption = footer.mutable_encryption();
+        encryption = footer->mutableEncryption();
         encryption->set_keyprovider(
             encryption::toProto(handler.getKeyProviderType()));
         for (uint32_t i = 0; i < count; ++i) {
@@ -708,25 +711,28 @@ void Writer::flushInternal(bool close) {
       std::optional<uint32_t> lastRoot;
       std::unordered_map<proto::ColumnStatistics*, proto::ColumnStatistics*>
           statsMap;
-      writer_->writeFileStats([&](uint32_t nodeId) -> proto::ColumnStatistics& {
-        auto entry = footer.add_statistics();
-        if (!encryption || !handler.isEncrypted(nodeId)) {
-          return *entry;
-        }
+      writer_->writeFileStats(
+          [&](uint32_t nodeId) -> ColumnStatisticsWriteWrapper {
+            auto entry = footer->addStatistics();
+            if (!encryption || !handler.isEncrypted(nodeId)) {
+              return entry;
+            }
 
-        auto root = handler.getEncryptionRoot(nodeId);
-        auto groupIndex = handler.getEncryptionGroupIndex(nodeId);
-        auto& group = stats.at(groupIndex);
-        if (!lastRoot || root != lastRoot.value()) {
-          // this is a new root, add to the footer, and use a new slot
-          group.emplace_back();
-          encryption->mutable_encryptiongroups(groupIndex)->add_nodes(root);
-        }
-        lastRoot = root;
-        auto encryptedStats = group.back().add_statistics();
-        statsMap[entry] = encryptedStats;
-        return *encryptedStats;
-      });
+            auto root = handler.getEncryptionRoot(nodeId);
+            auto groupIndex = handler.getEncryptionGroupIndex(nodeId);
+            auto& group = stats.at(groupIndex);
+            if (!lastRoot || root != lastRoot.value()) {
+              // this is a new root, add to the footer, and use a new slot
+              group.emplace_back();
+              encryption->mutable_encryptiongroups(groupIndex)->add_nodes(root);
+            }
+            lastRoot = root;
+            auto encryptedStats = group.back().add_statistics();
+            auto cs =
+                reinterpret_cast<proto::ColumnStatistics*>(entry.rawProtoPtr());
+            statsMap[cs] = encryptedStats;
+            return ColumnStatisticsWriteWrapper(encryptedStats);
+          });
 
 #define COPY_STAT(from, to, stat) \
   if (from->has_##stat()) {       \
@@ -770,7 +776,7 @@ void Writer::flushInternal(bool close) {
         dwio::common::MetricsLog::FileCloseMetrics{
             .writerVersion = writerVersionToString(
                 context.getConfig(Config::WRITER_VERSION)),
-            .footerLength = footer.contentlength(),
+            .footerLength = footer->contentLength(),
             .fileSize = sink.size(),
             .cacheSize = sink.getCacheSize(),
             .numCacheBlocks = sink.getCacheOffsets().size() - 1,
diff --git a/velox/dwio/dwrf/writer/Writer.h b/velox/dwio/dwrf/writer/Writer.h
index 3864b57790d1..4a7d1ab540b5 100644
--- a/velox/dwio/dwrf/writer/Writer.h
+++ b/velox/dwio/dwrf/writer/Writer.h
@@ -60,10 +60,11 @@ class Writer : public dwio::common::Writer {
       : Writer{
             std::move(sink),
             options,
-            parentPool.addAggregateChild(fmt::format(
-                "{}.dwrf_{}",
-                parentPool.name(),
-                folly::to<std::string>(folly::Random::rand64())))} {}
+            parentPool.addAggregateChild(
+                fmt::format(
+                    "{}.dwrf_{}",
+                    parentPool.name(),
+                    folly::to<std::string>(folly::Random::rand64())))} {}
 
   Writer(
       std::unique_ptr<dwio::common::FileSink> sink,
@@ -134,7 +135,7 @@ class Writer : public dwio::common::Writer {
     return writerBase_->getContext();
   }
 
-  const proto::Footer& getFooter() const {
+  const std::unique_ptr<FooterWriteWrapper>& getFooter() const {
     return writerBase_->getFooter();
   }
 
diff --git a/velox/dwio/dwrf/writer/WriterBase.cpp b/velox/dwio/dwrf/writer/WriterBase.cpp
index 6fd51477d048..dd182917661d 100644
--- a/velox/dwio/dwrf/writer/WriterBase.cpp
+++ b/velox/dwio/dwrf/writer/WriterBase.cpp
@@ -22,8 +22,8 @@ namespace facebook::velox::dwrf {
 
 void WriterBase::writeFooter(const Type& type) {
   auto pos = writerSink_->size();
-  footer_.set_headerlength(ORC_MAGIC_LEN);
-  footer_.set_contentlength(pos - ORC_MAGIC_LEN);
+  footer_->setHeaderLength(ORC_MAGIC_LEN);
+  footer_->setContentLength(pos - ORC_MAGIC_LEN);
   writerSink_->setMode(WriterSink::Mode::None);
 
   // write cache when available
@@ -31,45 +31,46 @@ void WriterBase::writeFooter(const Type& type) {
   if (cacheSize > 0) {
     writerSink_->writeCache();
     for (auto& i : writerSink_->getCacheOffsets()) {
-      footer_.add_stripecacheoffsets(i);
+      footer_->addStripeCacheOffsets(i);
     }
     pos = writerSink_->size();
   }
 
-  ProtoUtils::writeType(type, footer_);
-  DWIO_ENSURE_EQ(footer_.types_size(), footer_.statistics_size());
+  ProtoUtils::writeType(type, *footer_);
+  DWIO_ENSURE_EQ(footer_->typesSize(), footer_->statisticsSize());
   auto writerVersion =
       static_cast<uint32_t>(context_->getConfig(Config::WRITER_VERSION));
   writeUserMetadata(writerVersion);
-  footer_.set_numberofrows(context_->fileRowCount());
-  footer_.set_rowindexstride(context_->indexStride());
+  footer_->setNumberOfRows(context_->fileRowCount());
+  footer_->setRowIndexStride(context_->indexStride());
 
   if (context_->fileRawSize() > 0 || context_->fileRowCount() == 0) {
     // ColumnTransformWriter, when rewriting presto written file does not have
     // rawSize.
-    footer_.set_rawdatasize(context_->fileRawSize());
+    footer_->setRawDataSize(context_->fileRawSize());
   }
   auto* checksum = writerSink_->getChecksum();
-  footer_.set_checksumalgorithm(
+  footer_->setCheckSumAlgorithm(
       (checksum != nullptr) ? checksum->getType()
                             : proto::ChecksumAlgorithm::NULL_);
-  writeProto(footer_);
+  writeProto(footer_->getDwrfPtr());
   const auto footerLength = writerSink_->size() - pos;
 
   // write postscript
   pos = writerSink_->size();
-  proto::PostScript ps;
-  ps.set_writerversion(writerVersion);
-  ps.set_footerlength(footerLength);
-  ps.set_compression(
-      static_cast<proto::CompressionKind>(context_->compression()));
+  auto dwrfPostScript = ArenaCreate<proto::PostScript>(arena_.get());
+  std::unique_ptr<PostScriptWriteWrapper> ps =
+      std::make_unique<PostScriptWriteWrapper>(dwrfPostScript);
+  ps->setWriterVersion(writerVersion);
+  ps->setFooterLength(footerLength);
+  ps->setCompression(context_->compression());
   if (context_->compression() !=
       common::CompressionKind::CompressionKind_NONE) {
-    ps.set_compressionblocksize(context_->compressionBlockSize());
+    ps->setCompressionBlockSize(context_->compressionBlockSize());
   }
-  ps.set_cachemode(
-      static_cast<proto::StripeCacheMode>(writerSink_->getCacheMode()));
-  ps.set_cachesize(cacheSize);
+
+  ps->setCacheMode(writerSink_->getCacheMode());
+  ps->setCacheSize(cacheSize);
   writeProto(ps, common::CompressionKind::CompressionKind_NONE);
   auto psLength = writerSink_->size() - pos;
   DWIO_ENSURE_LE(psLength, 0xff, "PostScript is too large: ", psLength);
@@ -80,14 +81,14 @@ void WriterBase::writeFooter(const Type& type) {
 
 void WriterBase::writeUserMetadata(uint32_t writerVersion) {
   // add writer version
-  userMetadata_[std::string{WRITER_NAME_KEY}] = kDwioWriter;
-  userMetadata_[std::string{WRITER_VERSION_KEY}] =
+  userMetadata_[std::string{kWriterNameKey}] = kDwioWriter;
+  userMetadata_[std::string{kWriterVersionKey}] =
       folly::to<std::string>(writerVersion);
-  userMetadata_[std::string{WRITER_HOSTNAME_KEY}] = process::getHostName();
+  userMetadata_[std::string{kWriterHostnameKey}] = process::getHostName();
   std::for_each(userMetadata_.begin(), userMetadata_.end(), [&](auto& pair) {
-    auto item = footer_.add_metadata();
-    item->set_name(pair.first);
-    item->set_value(pair.second);
+    auto item = footer_->addMetadata();
+    item.setName(pair.first);
+    item.setValue(pair.second);
   });
 }
 
diff --git a/velox/dwio/dwrf/writer/WriterBase.h b/velox/dwio/dwrf/writer/WriterBase.h
index e79b9293db9b..abb9d4f16c78 100644
--- a/velox/dwio/dwrf/writer/WriterBase.h
+++ b/velox/dwio/dwrf/writer/WriterBase.h
@@ -17,15 +17,19 @@
 #pragma once
 
 #include "velox/common/base/GTestMacros.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/dwrf/writer/WriterContext.h"
 #include "velox/dwio/dwrf/writer/WriterSink.h"
 
 namespace facebook::velox::dwrf {
 
+using dwio::common::ArenaCreate;
+
 class WriterBase {
  public:
   explicit WriterBase(std::unique_ptr<dwio::common::FileSink> sink)
-      : sink_{std::move(sink)} {
+      : sink_{std::move(sink)},
+        arena_(std::make_unique<google::protobuf::Arena>()) {
     VELOX_CHECK_NOT_NULL(sink_);
   }
 
@@ -88,6 +92,8 @@ class WriterBase {
         *sink_,
         context_->getMemoryPool(MemoryUsageCategory::OUTPUT_STREAM),
         context_->getConfigs());
+    auto dwrfFooter_ = ArenaCreate<proto::Footer>(arena_.get());
+    footer_ = std::make_unique<FooterWriteWrapper>(dwrfFooter_);
   }
 
   void initBuffers();
@@ -107,7 +113,7 @@ class WriterBase {
     auto holder = context_->newDataBufferHolder();
     auto stream = context_->newStream(kind, *holder);
 
-    t.SerializeToZeroCopyStream(stream.get());
+    t->SerializeToZeroCopyStream(stream.get());
     stream->flush();
 
     writerSink_->addBuffers(*holder);
@@ -131,23 +137,23 @@ class WriterBase {
     }
   }
 
-  proto::StripeInformation& addStripeInfo() {
-    auto stripe = footer_.add_stripes();
-    stripe->set_numberofrows(context_->stripeRowCount());
+  StripeInformationWriteWrapper addStripeInfo() {
+    auto stripe = footer_->addStripes();
+    stripe.setNumberOfRows(context_->stripeRowCount());
     if (context_->stripeRawSize() > 0 || context_->stripeRowCount() == 0) {
       // ColumnTransformWriter, when rewriting presto written
       // file does not have rawSize.
-      stripe->set_rawdatasize(context_->stripeRawSize());
+      stripe.setRawDataSize(context_->stripeRawSize());
     }
 
     auto* checksum = writerSink_->getChecksum();
     if (checksum != nullptr) {
-      stripe->set_checksum(checksum->getDigest());
+      stripe.setChecksum(checksum->getDigest());
     }
-    return *stripe;
+    return stripe;
   }
 
-  proto::Footer& getFooter() {
+  std::unique_ptr<FooterWriteWrapper>& getFooter() {
     return footer_;
   }
 
@@ -170,8 +176,10 @@ class WriterBase {
   std::unique_ptr<WriterContext> context_;
   std::unique_ptr<dwio::common::FileSink> sink_;
   std::unique_ptr<WriterSink> writerSink_;
-  proto::Footer footer_;
+  std::unique_ptr<FooterWriteWrapper> footer_;
+  proto::orc::Metadata metadata_;
   std::unordered_map<std::string, std::string> userMetadata_;
+  std::unique_ptr<google::protobuf::Arena> arena_;
 
   friend class WriterTest;
   VELOX_FRIEND_TEST(WriterBaseTest, FlushWriterSinkUponClose);
diff --git a/velox/dwio/dwrf/writer/WriterContext.h b/velox/dwio/dwrf/writer/WriterContext.h
index 9ba444d53175..d31d1813e3e7 100644
--- a/velox/dwio/dwrf/writer/WriterContext.h
+++ b/velox/dwio/dwrf/writer/WriterContext.h
@@ -30,6 +30,7 @@
 #include "velox/vector/DecodedVector.h"
 
 namespace facebook::velox::dwrf {
+
 using dwio::common::BufferedOutputStream;
 using dwio::common::DataBufferHolder;
 using dwio::common::compression::CompressionBufferPool;
@@ -50,16 +51,14 @@ class WriterContext : public CompressionBufferPool {
   ~WriterContext() override;
 
   bool hasStream(const DwrfStreamIdentifier& stream) const {
-    return streams_.find(stream) != streams_.end();
+    return streams_.find(stream) != streams_.cend();
   }
 
   const DataBufferHolder& getStream(const DwrfStreamIdentifier& stream) const {
     return streams_.at(stream);
   }
 
-  void addBuffer(
-      const DwrfStreamIdentifier& stream,
-      folly::StringPiece buffer) {
+  void addBuffer(const DwrfStreamIdentifier& stream, std::string_view buffer) {
     streams_.at(stream).take(buffer);
   }
 
@@ -115,7 +114,7 @@ class WriterContext : public CompressionBufferPool {
       velox::memory::MemoryPool& dictionaryPool,
       velox::memory::MemoryPool& generalPool) {
     auto result = dictEncoders_.find(encodingKey);
-    if (result == dictEncoders_.end()) {
+    if (result == dictEncoders_.cend()) {
       auto emplaceResult = dictEncoders_.emplace(
           encodingKey,
           std::make_unique<IntegerDictionaryEncoder<T>>(
@@ -233,7 +232,7 @@ class WriterContext : public CompressionBufferPool {
   void removeAllIntDictionaryEncodersOnNode(
       std::function<bool(uint32_t)> predicate) {
     auto iter = dictEncoders_.begin();
-    while (iter != dictEncoders_.end()) {
+    while (iter != dictEncoders_.cend()) {
       if (predicate(iter->first.node())) {
         iter = dictEncoders_.erase(iter);
       } else {
diff --git a/velox/dwio/orc/test/CMakeLists.txt b/velox/dwio/orc/test/CMakeLists.txt
index 3d93874d12aa..dca4b326a525 100644
--- a/velox/dwio/orc/test/CMakeLists.txt
+++ b/velox/dwio/orc/test/CMakeLists.txt
@@ -16,7 +16,8 @@ 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})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_dwio_orc_reader_test
@@ -24,13 +25,15 @@ target_link_libraries(
   velox_dwio_common_test_utils
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
 
 add_executable(velox_dwio_orc_reader_filter_test ReaderFilterTest.cpp)
 add_test(
   NAME velox_dwio_orc_reader_filter_test
   COMMAND velox_dwio_orc_reader_filter_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_dwio_orc_reader_filter_test
@@ -38,7 +41,7 @@ target_link_libraries(
   velox_dwio_common_test_utils
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
 
-file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples
-     DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+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
index cad607b5761d..a357acd0798e 100644
--- a/velox/dwio/orc/test/ReaderTest.cpp
+++ b/velox/dwio/orc/test/ReaderTest.cpp
@@ -239,9 +239,7 @@ TEST_F(OrcReaderTest, testOrcReadAllType) {
     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(mapCol->toString(0, 2, ",", false), "{foo => 1, bar => 2}");
 
     EXPECT_EQ(structCol->size(), 1);
     EXPECT_EQ(structCol->type()->toString(), "ROW<x:BIGINT,y:DOUBLE>");
@@ -392,8 +390,8 @@ TEST_P(
   auto rowReader = reader->createRowReader(rowReaderOptions);
 
   for (std::map<std::string, std::string>::const_iterator itr =
-           GetParam().userMeta.begin();
-       itr != GetParam().userMeta.end();
+           GetParam().userMeta.cbegin();
+       itr != GetParam().userMeta.cend();
        ++itr) {
     ASSERT_EQ(true, reader->hasMetadataValue(itr->first));
     std::string val = reader->getMetadataValue(itr->first);
diff --git a/velox/dwio/parquet/CMakeLists.txt b/velox/dwio/parquet/CMakeLists.txt
index 2baaaeee11f5..c40f352d0bbe 100644
--- a/velox/dwio/parquet/CMakeLists.txt
+++ b/velox/dwio/parquet/CMakeLists.txt
@@ -27,8 +27,6 @@ velox_add_library(velox_dwio_parquet_reader RegisterParquetReader.cpp)
 velox_add_library(velox_dwio_parquet_writer RegisterParquetWriter.cpp)
 
 if(VELOX_ENABLE_PARQUET)
-  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)
+  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/common/BloomFilter.cpp b/velox/dwio/parquet/common/BloomFilter.cpp
index 6a59a1962327..211b842cf9ee 100644
--- a/velox/dwio/parquet/common/BloomFilter.cpp
+++ b/velox/dwio/parquet/common/BloomFilter.cpp
@@ -30,8 +30,6 @@
 
 namespace facebook::velox::parquet {
 
-constexpr uint32_t BlockSplitBloomFilter::SALT[kBitsSetPerBlock];
-
 BlockSplitBloomFilter::BlockSplitBloomFilter(memory::MemoryPool* pool)
     : pool_(pool),
       hashStrategy_(HashStrategy::XXHASH),
diff --git a/velox/dwio/parquet/common/CMakeLists.txt b/velox/dwio/parquet/common/CMakeLists.txt
index 4e3edf6687ce..159067602e9e 100644
--- a/velox/dwio/parquet/common/CMakeLists.txt
+++ b/velox/dwio/parquet/common/CMakeLists.txt
@@ -17,7 +17,8 @@ velox_add_library(
   BloomFilter.cpp
   XxHasher.cpp
   LevelComparison.cpp
-  LevelConversion.cpp)
+  LevelConversion.cpp
+)
 
 velox_link_libraries(
   velox_dwio_parquet_common
@@ -30,4 +31,5 @@ velox_link_libraries(
   Folly::folly
   Snappy::snappy
   thrift
-  zstd::zstd)
+  zstd::zstd
+)
diff --git a/velox/dwio/parquet/reader/CMakeLists.txt b/velox/dwio/parquet/reader/CMakeLists.txt
index 2bda9d61d06b..292285da9b53 100644
--- a/velox/dwio/parquet/reader/CMakeLists.txt
+++ b/velox/dwio/parquet/reader/CMakeLists.txt
@@ -25,7 +25,8 @@ velox_add_library(
   RleBpDecoder.cpp
   StructColumnReader.cpp
   StringColumnReader.cpp
-  SemanticVersion.cpp)
+  SemanticVersion.cpp
+)
 
 velox_link_libraries(
   velox_dwio_native_parquet_reader
@@ -38,4 +39,5 @@ velox_link_libraries(
   arrow
   Snappy::snappy
   thrift
-  zstd::zstd)
+  zstd::zstd
+)
diff --git a/velox/dwio/parquet/reader/FloatingPointColumnReader.h b/velox/dwio/parquet/reader/FloatingPointColumnReader.h
index cac475c0ee94..1a3fc9c4c58c 100644
--- a/velox/dwio/parquet/reader/FloatingPointColumnReader.h
+++ b/velox/dwio/parquet/reader/FloatingPointColumnReader.h
@@ -36,6 +36,13 @@ class FloatingPointColumnReader
       ParquetParams& params,
       common::ScanSpec& scanSpec);
 
+  // Parquet floating point reader always supports a bulk path
+  static constexpr bool kHasBulkPath = true;
+
+  bool hasBulkPath() const override {
+    return kHasBulkPath;
+  }
+
   void seekToRowGroup(int64_t index) override {
     base::seekToRowGroup(index);
     this->scanState().clear();
@@ -66,7 +73,16 @@ FloatingPointColumnReader<TData, TRequested>::FloatingPointColumnReader(
           requestedType,
           std::move(fileType),
           params,
-          scanSpec) {}
+          scanSpec) {
+  VELOX_DCHECK(
+      (this->requestedType_->kind() == TypeKind::REAL &&
+       std::is_same_v<TRequested, float>) ||
+          (this->requestedType_->kind() == TypeKind::DOUBLE &&
+           std::is_same_v<TRequested, double>),
+      "TRequested type mismatch: template parameter is {}, but requestedType is {}",
+      folly::demangle(typeid(TRequested)),
+      this->requestedType_->toString());
+}
 
 template <typename TData, typename TRequested>
 uint64_t FloatingPointColumnReader<TData, TRequested>::skip(
diff --git a/velox/dwio/parquet/reader/Metadata.cpp b/velox/dwio/parquet/reader/Metadata.cpp
index 8920b0ea400f..7c5c1c1a6893 100644
--- a/velox/dwio/parquet/reader/Metadata.cpp
+++ b/velox/dwio/parquet/reader/Metadata.cpp
@@ -156,22 +156,16 @@ common::CompressionKind thriftCodecToCompressionKind(
   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:
@@ -321,8 +315,9 @@ 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]));
+  return RowGroupMetaDataPtr(
+      reinterpret_cast<const void*>(
+          &thriftFileMetaDataPtr(ptr_)->row_groups[i]));
 }
 
 int64_t FileMetaDataPtr::numRows() const {
@@ -359,4 +354,8 @@ std::string FileMetaDataPtr::keyValueMetadataValue(
   VELOX_FAIL(fmt::format("Input key {} is not in the key value metadata", key));
 }
 
+std::string FileMetaDataPtr::createdBy() const {
+  return thriftFileMetaDataPtr(ptr_)->created_by;
+}
+
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/reader/Metadata.h b/velox/dwio/parquet/reader/Metadata.h
index a0241828b546..69fee1e5bdc4 100644
--- a/velox/dwio/parquet/reader/Metadata.h
+++ b/velox/dwio/parquet/reader/Metadata.h
@@ -153,6 +153,9 @@ class FileMetaDataPtr {
   /// Returns the value inside the key/value metadata if the key is present.
   std::string keyValueMetadataValue(const std::string_view key) const;
 
+  /// Return the Parquet writer created_by string.
+  std::string createdBy() const;
+
  private:
   const void* ptr_;
 };
diff --git a/velox/dwio/parquet/reader/PageReader.cpp b/velox/dwio/parquet/reader/PageReader.cpp
index 115a77b7bf36..d0c6a0fcf7d5 100644
--- a/velox/dwio/parquet/reader/PageReader.cpp
+++ b/velox/dwio/parquet/reader/PageReader.cpp
@@ -17,11 +17,11 @@
 #include "velox/dwio/parquet/reader/PageReader.h"
 
 #include "velox/common/testutil/TestValue.h"
+#include "velox/common/time/Timer.h"
 #include "velox/dwio/common/BufferUtil.h"
 #include "velox/dwio/common/ColumnVisitors.h"
 #include "velox/dwio/parquet/common/LevelConversion.h"
 #include "velox/dwio/parquet/thrift/ThriftTransport.h"
-
 #include "velox/vector/FlatVector.h"
 
 #include <thrift/protocol/TCompactProtocol.h> // @manual
@@ -87,7 +87,12 @@ PageHeader PageReader::readPageHeader() {
   if (bufferEnd_ == bufferStart_) {
     const void* buffer;
     int32_t size;
-    inputStream_->Next(&buffer, &size);
+    uint64_t readUs{0};
+    {
+      MicrosecondTimer timer(&readUs);
+      inputStream_->Next(&buffer, &size);
+    }
+    stats_.pageLoadTimeNs.increment(readUs * 1'000);
     bufferStart_ = reinterpret_cast<const char*>(buffer);
     bufferEnd_ = bufferStart_ + size;
   }
@@ -106,26 +111,31 @@ PageHeader PageReader::readPageHeader() {
 }
 
 const char* PageReader::readBytes(int32_t size, BufferPtr& copy) {
-  if (bufferEnd_ == bufferStart_) {
-    const void* buffer = nullptr;
-    int32_t bufferSize = 0;
-    if (!inputStream_->Next(&buffer, &bufferSize)) {
-      VELOX_FAIL("Read past end");
+  uint64_t readUs{0};
+  {
+    MicrosecondTimer timer(&readUs);
+    if (bufferEnd_ == bufferStart_) {
+      const void* buffer = nullptr;
+      int32_t bufferSize = 0;
+      if (!inputStream_->Next(&buffer, &bufferSize)) {
+        VELOX_FAIL("Read past end");
+      }
+      bufferStart_ = reinterpret_cast<const char*>(buffer);
+      bufferEnd_ = bufferStart_ + bufferSize;
     }
-    bufferStart_ = reinterpret_cast<const char*>(buffer);
-    bufferEnd_ = bufferStart_ + bufferSize;
-  }
-  if (bufferEnd_ - bufferStart_ >= size) {
-    bufferStart_ += size;
-    return bufferStart_ - size;
-  }
-  dwio::common::ensureCapacity<char>(copy, size, &pool_);
-  dwio::common::readBytes(
-      size,
-      inputStream_.get(),
-      copy->asMutable<char>(),
-      bufferStart_,
-      bufferEnd_);
+    if (bufferEnd_ - bufferStart_ >= size) {
+      bufferStart_ += size;
+      return bufferStart_ - size;
+    }
+    dwio::common::ensureCapacity<char>(copy, size, &pool_);
+    dwio::common::readBytes(
+        size,
+        inputStream_.get(),
+        copy->asMutable<char>(),
+        bufferStart_,
+        bufferEnd_);
+  }
+  stats_.pageLoadTimeNs.increment(readUs * 1'000);
   return copy->as<char>();
 }
 
@@ -288,9 +298,15 @@ void PageReader::prepareDataPageV2(const PageHeader& pageHeader, int64_t row) {
   }
 
   if (maxDefine_ > 0) {
-    defineDecoder_ = std::make_unique<RleBpDecoder>(
-        pageData_ + repeatLength,
-        pageData_ + repeatLength + defineLength,
+    if (maxDefine_ == 1) {
+      defineDecoder_ = std::make_unique<RleBpDecoder>(
+          pageData_ + repeatLength,
+          pageData_ + repeatLength + defineLength,
+          ::arrow::bit_util::NumRequiredBits(maxDefine_));
+    }
+    wideDefineDecoder_ = std::make_unique<RleDecoder>(
+        reinterpret_cast<const uint8_t*>(pageData_ + repeatLength),
+        defineLength,
         ::arrow::bit_util::NumRequiredBits(maxDefine_));
   }
   auto levelsSize = repeatLength + defineLength;
@@ -362,12 +378,17 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       if (pageData_) {
         memcpy(dictionary_.values->asMutable<char>(), pageData_, numBytes);
       } else {
-        dwio::common::readBytes(
-            numBytes,
-            inputStream_.get(),
-            dictionary_.values->asMutable<char>(),
-            bufferStart_,
-            bufferEnd_);
+        uint64_t readUs{0};
+        {
+          MicrosecondTimer timer(&readUs);
+          dwio::common::readBytes(
+              numBytes,
+              inputStream_.get(),
+              dictionary_.values->asMutable<char>(),
+              bufferStart_,
+              bufferEnd_);
+        }
+        stats_.pageLoadTimeNs.increment(readUs * 1'000);
       }
       if (type_->type()->isShortDecimal() &&
           parquetType == thrift::Type::INT32) {
@@ -397,12 +418,17 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       if (pageData_) {
         memcpy(dictionary_.values->asMutable<char>(), pageData_, numBytes);
       } else {
-        dwio::common::readBytes(
-            numBytes,
-            inputStream_.get(),
-            dictionary_.values->asMutable<char>(),
-            bufferStart_,
-            bufferEnd_);
+        uint64_t readUs{0};
+        {
+          MicrosecondTimer timer(&readUs);
+          dwio::common::readBytes(
+              numBytes,
+              inputStream_.get(),
+              dictionary_.values->asMutable<char>(),
+              bufferStart_,
+              bufferEnd_);
+        }
+        stats_.pageLoadTimeNs.increment(readUs * 1'000);
       }
       // Expand the Parquet type length values to Velox type length.
       // We start from the end to allow in-place expansion.
@@ -429,8 +455,13 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       if (pageData_) {
         memcpy(strings, pageData_, numBytes);
       } else {
-        dwio::common::readBytes(
-            numBytes, inputStream_.get(), strings, bufferStart_, bufferEnd_);
+        uint64_t readUs{0};
+        {
+          MicrosecondTimer timer(&readUs);
+          dwio::common::readBytes(
+              numBytes, inputStream_.get(), strings, bufferStart_, bufferEnd_);
+        }
+        stats_.pageLoadTimeNs.increment(readUs * 1'000);
       }
       auto header = strings;
       for (auto i = 0; i < dictionary_.numValues; ++i) {
@@ -452,12 +483,17 @@ void PageReader::prepareDictionary(const PageHeader& pageHeader) {
       if (pageData_) {
         memcpy(data, pageData_, numParquetBytes);
       } else {
-        dwio::common::readBytes(
-            numParquetBytes,
-            inputStream_.get(),
-            data,
-            bufferStart_,
-            bufferEnd_);
+        uint64_t readUs{0};
+        {
+          MicrosecondTimer timer(&readUs);
+          dwio::common::readBytes(
+              numParquetBytes,
+              inputStream_.get(),
+              data,
+              bufferStart_,
+              bufferEnd_);
+        }
+        stats_.pageLoadTimeNs.increment(readUs * 1'000);
       }
       if (type_->type()->isShortDecimal()) {
         // Parquet decimal values have a fixed typeLength_ and are in big-endian
@@ -745,7 +781,7 @@ void PageReader::makeDecoder() {
             std::make_unique<DeltaByteArrayDecoder>(pageData_);
         break;
       }
-      FMT_FALLTHROUGH;
+      [[fallthrough]];
     default:
       VELOX_UNSUPPORTED("Encoding not supported yet: {}", encoding_);
   }
diff --git a/velox/dwio/parquet/reader/PageReader.h b/velox/dwio/parquet/reader/PageReader.h
index c377100428a7..423added8930 100644
--- a/velox/dwio/parquet/reader/PageReader.h
+++ b/velox/dwio/parquet/reader/PageReader.h
@@ -42,6 +42,7 @@ class PageReader {
       ParquetTypeWithIdPtr fileType,
       common::CompressionKind codec,
       int64_t chunkSize,
+      dwio::common::ColumnReaderStatistics& stats,
       const tz::TimeZone* sessionTimezone)
       : pool_(pool),
         inputStream_(std::move(stream)),
@@ -52,6 +53,7 @@ class PageReader {
         codec_(codec),
         chunkSize_(chunkSize),
         nullConcatenation_(pool_),
+        stats_(stats),
         sessionTimezone_(sessionTimezone) {
     type_->makeLevelInfo(leafInfo_);
   }
@@ -62,6 +64,7 @@ class PageReader {
       memory::MemoryPool& pool,
       common::CompressionKind codec,
       int64_t chunkSize,
+      dwio::common::ColumnReaderStatistics& stats,
       const tz::TimeZone* sessionTimezone = nullptr)
       : pool_(pool),
         inputStream_(std::move(stream)),
@@ -71,6 +74,7 @@ class PageReader {
         codec_(codec),
         chunkSize_(chunkSize),
         nullConcatenation_(pool_),
+        stats_(stats),
         sessionTimezone_(sessionTimezone) {}
 
   /// Advances 'numRows' top level rows.
@@ -264,7 +268,7 @@ class PageReader {
   template <
       typename Visitor,
       typename std::enable_if<
-          !std::is_same_v<typename Visitor::DataType, folly::StringPiece> &&
+          !std::is_same_v<typename Visitor::DataType, std::string_view> &&
               !std::is_same_v<typename Visitor::DataType, int8_t>,
           int>::type = 0>
   void
@@ -300,7 +304,7 @@ class PageReader {
   template <
       typename Visitor,
       typename std::enable_if<
-          std::is_same_v<typename Visitor::DataType, folly::StringPiece>,
+          std::is_same_v<typename Visitor::DataType, std::string_view>,
           int>::type = 0>
   void
   callDecoder(const uint64_t* nulls, bool& nullsFromFastPath, Visitor visitor) {
@@ -359,14 +363,17 @@ class PageReader {
   // Returns the number of passed rows/values gathered by
   // 'reader'. Only numRows() is set for a filter-only case, only
   // numValues() is set for a non-filtered case.
-  template <bool hasFilter>
-  static int32_t numRowsInReader(
-      const dwio::common::SelectiveColumnReader& reader) {
+  template <bool hasFilter, bool hasHook>
+  static int32_t numValuesRead(
+      const dwio::common::SelectiveColumnReader& reader,
+      const int32_t numPageRowsRead) {
+    if (hasHook) {
+      return numPageRowsRead;
+    }
     if (hasFilter) {
       return reader.numRows();
-    } else {
-      return reader.numValues();
     }
+    return reader.numValues();
   }
 
   memory::MemoryPool& pool_;
@@ -502,6 +509,8 @@ class PageReader {
   // Base values of dictionary when reading a string dictionary.
   VectorPtr dictionaryValues_;
 
+  dwio::common::ColumnReaderStatistics& stats_;
+
   const tz::TimeZone* sessionTimezone_{nullptr};
 
   // Decoders. Only one will be set at a time.
@@ -537,6 +546,10 @@ void PageReader::readWithVisitor(Visitor& visitor) {
       !std::is_same_v<typename Visitor::FilterType, common::AlwaysTrue>;
   constexpr bool filterOnly =
       std::is_same_v<typename Visitor::Extract, dwio::common::DropValues>;
+  constexpr bool hasHook = Visitor::kHasHook;
+  static_assert(
+      !(hasFilter && hasHook), "hasFilter and hasHook cannot both be true");
+
   bool mayProduceNulls = !filterOnly && visitor.allowNulls();
   auto rows = visitor.rows();
   auto numRows = visitor.numRows();
@@ -544,11 +557,13 @@ void PageReader::readWithVisitor(Visitor& visitor) {
   startVisit(folly::Range<const vector_size_t*>(rows, numRows));
   rowsCopy_ = &visitor.rowsCopy();
   folly::Range<const vector_size_t*> pageRows;
+  int32_t numPageRowsRead = 0;
   const uint64_t* nulls = nullptr;
   bool isMultiPage = false;
   while (rowsForPage(reader, hasFilter, mayProduceNulls, pageRows, nulls)) {
     bool nullsFromFastPath = false;
-    int32_t numValuesBeforePage = numRowsInReader<hasFilter>(reader);
+    const int32_t numValuesBeforePage =
+        numValuesRead<hasFilter, hasHook>(reader, numPageRowsRead);
     visitor.setNumValuesBias(numValuesBeforePage);
     visitor.setRows(pageRows);
     callDecoder(nulls, nullsFromFastPath, visitor);
@@ -571,20 +586,23 @@ void PageReader::readWithVisitor(Visitor& visitor) {
         }
         if (!nulls) {
           nullConcatenation_.appendOnes(
-              numRowsInReader<hasFilter>(reader) - numValuesBeforePage);
+              numValuesRead<hasFilter, hasHook>(reader, numPageRowsRead) -
+              numValuesBeforePage);
         } else if (reader.returnReaderNulls()) {
           // Nulls from decoding go directly to result.
           nullConcatenation_.append(
               reader.nullsInReadRange()->template as<uint64_t>(),
               0,
-              numRowsInReader<hasFilter>(reader) - numValuesBeforePage);
+              numValuesRead<hasFilter, hasHook>(reader, numPageRowsRead) -
+                  numValuesBeforePage);
         } else {
           // Add the nulls produced from the decoder to the result.
           auto firstNullIndex = nullsFromFastPath ? 0 : numValuesBeforePage;
           nullConcatenation_.append(
               reader.mutableNulls(0),
               firstNullIndex,
-              firstNullIndex + numRowsInReader<hasFilter>(reader) -
+              firstNullIndex +
+                  numValuesRead<hasFilter, hasHook>(reader, numPageRowsRead) -
                   numValuesBeforePage);
         }
       }
@@ -598,6 +616,7 @@ void PageReader::readWithVisitor(Visitor& visitor) {
     if (hasFilter && rowNumberBias_) {
       reader.offsetOutputRows(numValuesBeforePage, rowNumberBias_);
     }
+    numPageRowsRead += pageRows.size();
   }
   if (isMultiPage) {
     reader.setNulls(mayProduceNulls ? nullConcatenation_.buffer() : nullptr);
diff --git a/velox/dwio/parquet/reader/ParquetColumnReader.cpp b/velox/dwio/parquet/reader/ParquetColumnReader.cpp
index 0b69f446280d..ef3ff4c9d467 100644
--- a/velox/dwio/parquet/reader/ParquetColumnReader.cpp
+++ b/velox/dwio/parquet/reader/ParquetColumnReader.cpp
@@ -51,8 +51,13 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> ParquetColumnReader::build(
           requestedType, fileType, params, scanSpec);
 
     case TypeKind::REAL:
-      return std::make_unique<FloatingPointColumnReader<float, float>>(
-          requestedType, fileType, params, scanSpec);
+      if (requestedType->kind() == TypeKind::REAL) {
+        return std::make_unique<FloatingPointColumnReader<float, float>>(
+            requestedType, fileType, params, scanSpec);
+      } else {
+        return std::make_unique<FloatingPointColumnReader<float, double>>(
+            requestedType, fileType, params, scanSpec);
+      }
     case TypeKind::DOUBLE:
       return std::make_unique<FloatingPointColumnReader<double, double>>(
           requestedType, fileType, params, scanSpec);
@@ -65,9 +70,11 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> ParquetColumnReader::build(
     case TypeKind::VARCHAR:
       return std::make_unique<StringColumnReader>(fileType, params, scanSpec);
 
-    case TypeKind::ARRAY:
+    case TypeKind::ARRAY: {
+      VELOX_CHECK(requestedType->isArray(), "Requested type must be array");
       return std::make_unique<ListColumnReader>(
           columnReaderOptions, requestedType, fileType, params, scanSpec);
+    }
 
     case TypeKind::MAP:
       return std::make_unique<MapColumnReader>(
@@ -97,7 +104,7 @@ std::unique_ptr<dwio::common::SelectiveColumnReader> ParquetColumnReader::build(
     default:
       VELOX_FAIL(
           "buildReader unhandled type: " +
-          mapTypeKindToName(fileType->type()->kind()));
+          std::string(TypeKindName::toName(fileType->type()->kind())));
   }
 }
 
diff --git a/velox/dwio/parquet/reader/ParquetData.cpp b/velox/dwio/parquet/reader/ParquetData.cpp
index 29a593da414c..572c53acc2db 100644
--- a/velox/dwio/parquet/reader/ParquetData.cpp
+++ b/velox/dwio/parquet/reader/ParquetData.cpp
@@ -25,7 +25,7 @@ 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_, pool(), sessionTimezone_);
+      type, metaData_, pool(), runtimeStatistics(), sessionTimezone_);
 }
 
 void ParquetData::filterRowGroups(
@@ -70,7 +70,9 @@ void ParquetData::filterRowGroups(
   }
 }
 
-bool ParquetData::rowGroupMatches(uint32_t rowGroupId, common::Filter* filter) {
+bool ParquetData::rowGroupMatches(
+    uint32_t rowGroupId,
+    const common::Filter* filter) {
   auto column = type_->column();
   auto type = type_->type();
   auto rowGroup = fileMetaDataPtr_.rowGroup(rowGroupId);
@@ -126,6 +128,7 @@ dwio::common::PositionProvider ParquetData::seekToRowGroup(int64_t index) {
       type_,
       metadata.compression(),
       metadata.totalCompressedSize(),
+      stats_,
       sessionTimezone_);
   return dwio::common::PositionProvider(empty);
 }
diff --git a/velox/dwio/parquet/reader/ParquetData.h b/velox/dwio/parquet/reader/ParquetData.h
index fe8020f57c65..9926202491d6 100644
--- a/velox/dwio/parquet/reader/ParquetData.h
+++ b/velox/dwio/parquet/reader/ParquetData.h
@@ -63,6 +63,7 @@ class ParquetData : public dwio::common::FormatData {
       const std::shared_ptr<const dwio::common::TypeWithId>& type,
       const FileMetaDataPtr fileMetadataPtr,
       memory::MemoryPool& pool,
+      dwio::common::ColumnReaderStatistics& stats,
       const tz::TimeZone* sessionTimezone)
       : pool_(pool),
         type_(std::static_pointer_cast<const ParquetTypeWithId>(type)),
@@ -70,6 +71,7 @@ class ParquetData : public dwio::common::FormatData {
         maxDefine_(type_->maxDefine_),
         maxRepeat_(type_->maxRepeat_),
         rowsInRowGroup_(-1),
+        stats_(stats),
         sessionTimezone_(sessionTimezone) {}
 
   /// Prepares to read data for 'index'th row group.
@@ -90,8 +92,9 @@ class ParquetData : public dwio::common::FormatData {
     return reader_.get();
   }
 
-  // Reads null flags for 'numValues' next top level rows. The first 'numValues'
-  // bits of 'nulls' are set and the reader is advanced by numValues'.
+  // Reads null flags for 'numValues' next top level rows. The first
+  // 'numValues' bits of 'nulls' are set and the reader is advanced by
+  // numValues'.
   void readNullsOnly(int32_t numValues, BufferPtr& nulls) {
     reader_->readNullsOnly(numValues, nulls);
   }
@@ -100,8 +103,9 @@ class ParquetData : public dwio::common::FormatData {
     return maxDefine_ > 0;
   }
 
-  /// Sets nulls to be returned by readNulls(). Nulls for non-leaf readers come
-  /// from leaf repdefs which are gathered before descending the reader tree.
+  /// Sets nulls to be returned by readNulls(). Nulls for non-leaf readers
+  /// come from leaf repdefs which are gathered before descending the reader
+  /// tree.
   void setNulls(BufferPtr& nulls, int32_t numValues) {
     if (nulls || numValues) {
       VELOX_CHECK_EQ(presetNullsConsumed_, presetNullsSize_);
@@ -120,8 +124,8 @@ class ParquetData : public dwio::common::FormatData {
       const uint64_t* incomingNulls,
       BufferPtr& nulls,
       bool nullsOnly = false) override {
-    // If the query accesses only nulls, read the nulls from the pages in range.
-    // If nulls are preread, return those minus any skipped.
+    // If the query accesses only nulls, read the nulls from the pages in
+    // range. If nulls are preread, return those minus any skipped.
     if (presetNulls_) {
       VELOX_CHECK_LE(numValues, presetNullsSize_ - presetNullsConsumed_);
       if (!presetNullsConsumed_ && numValues == presetNullsSize_) {
@@ -144,8 +148,8 @@ class ParquetData : public dwio::common::FormatData {
       readNullsOnly(numValues, nulls);
       return;
     }
-    // There are no column-level nulls in Parquet, only page-level ones, so this
-    // is always non-null.
+    // There are no column-level nulls in Parquet, only page-level ones, so
+    // this is always non-null.
     nulls = nullptr;
   }
 
@@ -206,7 +210,7 @@ class ParquetData : public dwio::common::FormatData {
  private:
   /// True if 'filter' may have hits for the column of 'this' according to the
   /// stats in 'rowGroup'.
-  bool rowGroupMatches(uint32_t rowGroupId, common::Filter* filter);
+  bool rowGroupMatches(uint32_t rowGroupId, const common::Filter* filter);
 
  protected:
   memory::MemoryPool& pool_;
@@ -219,6 +223,7 @@ class ParquetData : public dwio::common::FormatData {
   const uint32_t maxDefine_;
   const uint32_t maxRepeat_;
   int64_t rowsInRowGroup_;
+  dwio::common::ColumnReaderStatistics& stats_;
   const tz::TimeZone* sessionTimezone_;
   std::unique_ptr<PageReader> reader_;
 
diff --git a/velox/dwio/parquet/reader/ParquetReader.cpp b/velox/dwio/parquet/reader/ParquetReader.cpp
index 325713272bb5..63700fa6bfe3 100644
--- a/velox/dwio/parquet/reader/ParquetReader.cpp
+++ b/velox/dwio/parquet/reader/ParquetReader.cpp
@@ -21,6 +21,7 @@
 #include "velox/dwio/parquet/reader/ParquetColumnReader.h"
 #include "velox/dwio/parquet/reader/StructColumnReader.h"
 #include "velox/dwio/parquet/thrift/ThriftTransport.h"
+#include "velox/functions/lib/string/StringImpl.h"
 
 namespace facebook::velox::parquet {
 
@@ -30,12 +31,30 @@ bool isParquetReservedKeyword(
     std::string name,
     uint32_t parentSchemaIdx,
     uint32_t curSchemaIdx) {
-  return ((parentSchemaIdx == 0 && curSchemaIdx == 0) || name == "key_value" ||
-          name == "key" || name == "value" || name == "list" ||
-          name == "element" || name == "bag" || name == "array_element")
+  // We skip this for the top-level nodes.
+  return ((parentSchemaIdx == 0 && curSchemaIdx == 0) ||
+          (parentSchemaIdx != 0 &&
+           (name == "key_value" || name == "key" || name == "value" ||
+            name == "list" || name == "element" || name == "bag" ||
+            name == "array_element")))
       ? true
       : false;
 }
+
+// An unannotated array in Parquet is a repeated field that is not explicitly
+// marked as a LIST logical type. If current schema element is a repeated field
+// and the requested type is an array, we treat the current schema element as an
+// unannotated array, and returns true if the element type is compatible with
+// the physical type.
+bool isCompatible(
+    const TypePtr& requestedType,
+    bool isRepeated,
+    const std::function<bool(const TypePtr&)>& isCompatibleFunc) {
+  return isCompatibleFunc(requestedType) ||
+      (requestedType->isArray() && isRepeated &&
+       isCompatibleFunc(requestedType->asArray().elementType()));
+}
+
 } // namespace
 
 /// Metadata and options for reading Parquet.
@@ -304,11 +323,10 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
 
   auto name = schemaElement.name;
   if (isFileColumnNamesReadAsLowerCase()) {
-    folly::toLowerAscii(name);
+    name = functions::stringImpl::utf8StrToLowerCopy(name);
   }
 
-  if ((!options_.useColumnNamesForColumnMapping()) &&
-      (options_.fileSchema() != nullptr)) {
+  if (!options_.useColumnNamesForColumnMapping() && options_.fileSchema()) {
     if (isParquetReservedKeyword(name, parentSchemaIdx, curSchemaIdx)) {
       columnNames.push_back(name);
     }
@@ -331,26 +349,42 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
       ++schemaIdx;
       auto childName = schema[schemaIdx].name;
       if (isFileColumnNamesReadAsLowerCase()) {
-        folly::toLowerAscii(childName);
+        childName = functions::stringImpl::utf8StrToLowerCopy(childName);
       }
 
       TypePtr childRequestedType = nullptr;
       bool followChild = true;
-      if (requestedType && requestedType->isRow()) {
-        auto requestedRowType =
-            std::dynamic_pointer_cast<const velox::RowType>(requestedType);
-        if (options_.useColumnNamesForColumnMapping()) {
-          auto fileTypeIdx = requestedRowType->getChildIdxIfExists(childName);
-          if (fileTypeIdx.has_value()) {
-            childRequestedType = requestedRowType->childAt(*fileTypeIdx);
+
+      {
+        RowTypePtr requestedRowType = nullptr;
+        if (requestedType) {
+          if (requestedType->isRow()) {
+            requestedRowType =
+                std::dynamic_pointer_cast<const velox::RowType>(requestedType);
+          } else if (
+              requestedType->isArray() && isRepeated &&
+              requestedType->asArray().elementType()->isRow()) {
+            // Handle the case of unannotated array of structs (repeated group
+            // without LIST annotation).
+            requestedRowType = std::dynamic_pointer_cast<const velox::RowType>(
+                requestedType->asArray().elementType());
           }
-        } else {
-          // Handle schema evolution.
-          if (i < requestedRowType->size()) {
-            columnNames.push_back(requestedRowType->nameOf(i));
-            childRequestedType = requestedRowType->childAt(i);
+        }
+
+        if (requestedRowType) {
+          if (options_.useColumnNamesForColumnMapping()) {
+            auto fileTypeIdx = requestedRowType->getChildIdxIfExists(childName);
+            if (fileTypeIdx.has_value()) {
+              childRequestedType = requestedRowType->childAt(*fileTypeIdx);
+            }
           } else {
-            followChild = false;
+            // Handle schema evolution.
+            if (i < requestedRowType->size()) {
+              columnNames.push_back(requestedRowType->nameOf(i));
+              childRequestedType = requestedRowType->childAt(i);
+            } else {
+              followChild = false;
+            }
           }
         }
       }
@@ -533,20 +567,21 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
             // 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,
-                std::nullopt,
-                maxRepeat,
-                maxDefine,
-                isOptional,
-                isRepeated));
+            rowChildren.emplace_back(
+                std::make_unique<ParquetTypeWithId>(
+                    childrenRowType,
+                    std::move(children),
+                    curSchemaIdx,
+                    maxSchemaElementIdx,
+                    ParquetTypeWithId::kNonLeaf,
+                    "dummy",
+                    std::nullopt,
+                    std::nullopt,
+                    std::nullopt,
+                    maxRepeat,
+                    maxDefine,
+                    isOptional,
+                    isRepeated));
             auto res = std::make_unique<ParquetTypeWithId>(
                 TypeFactory<TypeKind::ARRAY>::create(childrenRowType),
                 std::move(rowChildren),
@@ -597,20 +632,21 @@ std::unique_ptr<ParquetTypeWithId> ReaderBase::getParquetColumnInfo(
           // 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,
-              std::nullopt,
-              maxRepeat,
-              maxDefine,
-              isOptional,
-              isRepeated));
+          rowChildren.emplace_back(
+              std::make_unique<ParquetTypeWithId>(
+                  childrenRowType,
+                  std::move(children),
+                  curSchemaIdx,
+                  maxSchemaElementIdx,
+                  ParquetTypeWithId::kNonLeaf,
+                  "dummy",
+                  std::nullopt,
+                  std::nullopt,
+                  std::nullopt,
+                  maxRepeat,
+                  maxDefine,
+                  isOptional,
+                  isRepeated));
           return std::make_unique<ParquetTypeWithId>(
               TypeFactory<TypeKind::ARRAY>::create(childrenRowType),
               std::move(rowChildren),
@@ -721,6 +757,8 @@ TypePtr ReaderBase::convertType(
 
   static std::string_view kTypeMappingErrorFmtStr =
       "Converted type {} is not allowed for requested type {}";
+  const bool isRepeated = schemaElement.__isset.repetition_type &&
+      schemaElement.repetition_type == thrift::FieldRepetitionType::REPEATED;
   if (schemaElement.__isset.converted_type) {
     switch (schemaElement.converted_type) {
       case thrift::ConvertedType::INT_8:
@@ -731,10 +769,16 @@ TypePtr ReaderBase::convertType(
             "{} converted type can only be set for value of thrift::Type::INT32",
             schemaElement.converted_type);
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::TINYINT ||
-                requestedType->kind() == TypeKind::SMALLINT ||
-                requestedType->kind() == TypeKind::INTEGER ||
-                requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::TINYINT ||
+                          type->kind() == TypeKind::SMALLINT ||
+                          type->kind() == TypeKind::INTEGER ||
+                          type->kind() == TypeKind::BIGINT;
+                    }),
             kTypeMappingErrorFmtStr,
             "TINYINT",
             requestedType->toString());
@@ -748,9 +792,15 @@ TypePtr ReaderBase::convertType(
             "{} converted type can only be set for value of thrift::Type::INT32",
             schemaElement.converted_type);
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::SMALLINT ||
-                requestedType->kind() == TypeKind::INTEGER ||
-                requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::SMALLINT ||
+                          type->kind() == TypeKind::INTEGER ||
+                          type->kind() == TypeKind::BIGINT;
+                    }),
             kTypeMappingErrorFmtStr,
             "SMALLINT",
             requestedType->toString());
@@ -764,8 +814,14 @@ TypePtr ReaderBase::convertType(
             "{} converted type can only be set for value of thrift::Type::INT32",
             schemaElement.converted_type);
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::INTEGER ||
-                requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::INTEGER ||
+                          type->kind() == TypeKind::BIGINT;
+                    }),
             kTypeMappingErrorFmtStr,
             "INTEGER",
             requestedType->toString());
@@ -779,7 +835,13 @@ TypePtr ReaderBase::convertType(
             "{} converted type can only be set for value of thrift::Type::INT32",
             schemaElement.converted_type);
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::BIGINT;
+                    }),
             kTypeMappingErrorFmtStr,
             "BIGINT",
             requestedType->toString());
@@ -791,7 +853,11 @@ TypePtr ReaderBase::convertType(
             thrift::Type::INT32,
             "DATE converted type can only be set for value of thrift::Type::INT32");
         VELOX_CHECK(
-            !requestedType || requestedType->isDate(),
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) { return type->isDate(); }),
             kTypeMappingErrorFmtStr,
             "DATE",
             requestedType->toString());
@@ -804,7 +870,13 @@ TypePtr ReaderBase::convertType(
             thrift::Type::INT64,
             "TIMESTAMP_MICROS or TIMESTAMP_MILLIS converted type can only be set for value of thrift::Type::INT64");
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::TIMESTAMP,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::TIMESTAMP;
+                    }),
             kTypeMappingErrorFmtStr,
             "TIMESTAMP",
             requestedType->toString());
@@ -822,7 +894,10 @@ TypePtr ReaderBase::convertType(
         auto type = DECIMAL(schemaElementPrecision, schemaElementScale);
         if (requestedType) {
           VELOX_CHECK(
-              requestedType->isDecimal(),
+              isCompatible(
+                  requestedType,
+                  isRepeated,
+                  [](const TypePtr& type) { return type->isDecimal(); }),
               kTypeMappingErrorFmtStr,
               "DECIMAL",
               requestedType->toString());
@@ -831,20 +906,30 @@ TypePtr ReaderBase::convertType(
           // the scale of the file type and requested type must match while
           // precision may be larger.
           if (requestedType->isShortDecimal()) {
-            const auto& shortDecimalType = requestedType->asShortDecimal();
             VELOX_CHECK(
-                type->isShortDecimal() &&
-                    shortDecimalType.precision() >= schemaElementPrecision &&
-                    shortDecimalType.scale() == schemaElementScale,
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [&](const TypePtr& type) {
+                      return type->isShortDecimal() &&
+                          type->asShortDecimal().precision() >=
+                          schemaElementPrecision &&
+                          type->asShortDecimal().scale() == schemaElementScale;
+                    }),
                 kTypeMappingErrorFmtStr,
                 type->toString(),
                 requestedType->toString());
           } else {
-            const auto& longDecimalType = requestedType->asLongDecimal();
             VELOX_CHECK(
-                type->isLongDecimal() &&
-                    longDecimalType.precision() >= schemaElementPrecision &&
-                    longDecimalType.scale() == schemaElementScale,
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [&](const TypePtr& type) {
+                      return type->isLongDecimal() &&
+                          type->asLongDecimal().precision() >=
+                          schemaElementPrecision &&
+                          type->asLongDecimal().scale() == schemaElementScale;
+                    }),
                 kTypeMappingErrorFmtStr,
                 type->toString(),
                 requestedType->toString());
@@ -858,7 +943,13 @@ TypePtr ReaderBase::convertType(
           case thrift::Type::BYTE_ARRAY:
           case thrift::Type::FIXED_LEN_BYTE_ARRAY:
             VELOX_CHECK(
-                !requestedType || requestedType->kind() == TypeKind::VARCHAR,
+                !requestedType ||
+                    isCompatible(
+                        requestedType,
+                        isRepeated,
+                        [](const TypePtr& type) {
+                          return type->kind() == TypeKind::VARCHAR;
+                        }),
                 kTypeMappingErrorFmtStr,
                 "VARCHAR",
                 requestedType->toString());
@@ -873,7 +964,13 @@ TypePtr ReaderBase::convertType(
             thrift::Type::BYTE_ARRAY,
             "ENUM converted type can only be set for value of thrift::Type::BYTE_ARRAY");
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::VARCHAR,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::VARCHAR;
+                    }),
             kTypeMappingErrorFmtStr,
             "VARCHAR",
             requestedType->toString());
@@ -896,15 +993,27 @@ TypePtr ReaderBase::convertType(
     switch (schemaElement.type) {
       case thrift::Type::type::BOOLEAN:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::BOOLEAN,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::BOOLEAN;
+                    }),
             kTypeMappingErrorFmtStr,
             "BOOLEAN",
             requestedType->toString());
         return BOOLEAN();
       case thrift::Type::type::INT32:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::INTEGER ||
-                requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::INTEGER ||
+                          type->kind() == TypeKind::BIGINT;
+                    }),
             kTypeMappingErrorFmtStr,
             "INTEGER",
             requestedType->toString());
@@ -914,47 +1023,84 @@ TypePtr ReaderBase::convertType(
         if (schemaElement.__isset.logicalType &&
             schemaElement.logicalType.__isset.TIMESTAMP) {
           VELOX_CHECK(
-              !requestedType || requestedType->kind() == TypeKind::TIMESTAMP,
+              !requestedType ||
+                  isCompatible(
+                      requestedType,
+                      isRepeated,
+                      [](const TypePtr& type) {
+                        return type->kind() == TypeKind::TIMESTAMP;
+                      }),
               kTypeMappingErrorFmtStr,
               "TIMESTAMP",
               requestedType->toString());
           return TIMESTAMP();
         }
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::BIGINT,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::BIGINT;
+                    }),
             kTypeMappingErrorFmtStr,
             "BIGINT",
             requestedType->toString());
         return BIGINT();
       case thrift::Type::type::INT96:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::TIMESTAMP,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::TIMESTAMP;
+                    }),
             kTypeMappingErrorFmtStr,
             "TIMESTAMP",
             requestedType->toString());
         return TIMESTAMP(); // INT96 only maps to a timestamp
       case thrift::Type::type::FLOAT:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::REAL ||
-                requestedType->kind() == TypeKind::DOUBLE,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::REAL ||
+                          type->kind() == TypeKind::DOUBLE;
+                    }),
             kTypeMappingErrorFmtStr,
             "REAL",
             requestedType->toString());
         return REAL();
       case thrift::Type::type::DOUBLE:
         VELOX_CHECK(
-            !requestedType || requestedType->kind() == TypeKind::DOUBLE,
+            !requestedType ||
+                isCompatible(
+                    requestedType,
+                    isRepeated,
+                    [](const TypePtr& type) {
+                      return type->kind() == TypeKind::DOUBLE;
+                    }),
             kTypeMappingErrorFmtStr,
             "DOUBLE",
             requestedType->toString());
         return DOUBLE();
       case thrift::Type::type::BYTE_ARRAY:
       case thrift::Type::type::FIXED_LEN_BYTE_ARRAY:
-        if (requestedType && requestedType->isVarchar()) {
+        if (requestedType &&
+            isCompatible(requestedType, isRepeated, [](const TypePtr& type) {
+              return type->isVarchar();
+            })) {
           return VARCHAR();
         } else {
           VELOX_CHECK(
-              !requestedType || requestedType->isVarbinary(),
+              !requestedType ||
+                  isCompatible(
+                      requestedType,
+                      isRepeated,
+                      [](const TypePtr& type) { return type->isVarbinary(); }),
               kTypeMappingErrorFmtStr,
               "VARBINARY",
               requestedType->toString());
@@ -977,7 +1123,7 @@ std::shared_ptr<const RowType> ReaderBase::createRowType(
   for (auto& child : children) {
     auto childName = static_cast<const ParquetTypeWithId&>(*child).name_;
     if (fileColumnNamesReadAsLowerCase) {
-      folly::toLowerAscii(childName);
+      childName = functions::stringImpl::utf8StrToLowerCopy(childName);
     }
     childNames.push_back(std::move(childName));
     childTypes.push_back(child->type());
@@ -1177,14 +1323,21 @@ class ParquetRowReader::Impl {
   std::optional<size_t> estimatedRowSize() const {
     auto index =
         nextRowGroupIdsIdx_ < 1 ? 0 : rowGroupIds_[nextRowGroupIdsIdx_ - 1];
-    return readerBase_->rowGroupUncompressedSize(
-               index, *readerBase_->schemaWithId()) /
+    if (index == lastRowGroupWithRowEstimate_) {
+      return estimatedRowSize_;
+    }
+    estimatedRowSize_ = readerBase_->rowGroupUncompressedSize(
+                            index, *readerBase_->schemaWithId()) /
         rowGroups_[index].num_rows;
+    lastRowGroupWithRowEstimate_ = index;
+    return estimatedRowSize_;
   }
 
   void updateRuntimeStats(dwio::common::RuntimeStatistics& stats) const {
     stats.skippedStrides += skippedStrides_;
     stats.processedStrides += rowGroupIds_.size();
+    stats.columnReaderStatistics.pageLoadTimeNs.merge(
+        columnReaderStats_.pageLoadTimeNs);
   }
 
   void resetFilterCaches() {
@@ -1236,6 +1389,9 @@ class ParquetRowReader::Impl {
   ParquetStatsContext parquetStatsContext_;
 
   dwio::common::ColumnReaderStatistics columnReaderStats_;
+
+  mutable std::optional<size_t> estimatedRowSize_;
+  mutable int32_t lastRowGroupWithRowEstimate_{-1};
 };
 
 ParquetRowReader::ParquetRowReader(
diff --git a/velox/dwio/parquet/reader/ParquetTypeWithId.cpp b/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
index 1581fa639348..aab2e71fba7e 100644
--- a/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
+++ b/velox/dwio/parquet/reader/ParquetTypeWithId.cpp
@@ -53,23 +53,24 @@ ParquetTypeWithId::moveChildren() const&& {
     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),
-        std::move(convertedType),
-        maxRepeat,
-        maxDefine,
-        isOptional,
-        isRepeated,
-        precision,
-        scale,
-        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),
+            std::move(convertedType),
+            maxRepeat,
+            maxDefine,
+            isOptional,
+            isRepeated,
+            precision,
+            scale,
+            typeLength));
   }
   return children;
 }
diff --git a/velox/dwio/parquet/reader/RepeatedColumnReader.cpp b/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
index 8cd75156747a..e10dd4182a8f 100644
--- a/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
+++ b/velox/dwio/parquet/reader/RepeatedColumnReader.cpp
@@ -153,8 +153,6 @@ void MapColumnReader::seekToRowGroup(int64_t index) {
   BufferPtr noBuffer;
   formatData_->as<ParquetData>().setNulls(noBuffer, 0);
   lengths_.setLengths(nullptr);
-  keyReader_->seekToRowGroup(index);
-  elementReader_->seekToRowGroup(index);
 }
 
 void MapColumnReader::skipUnreadLengths() {
diff --git a/velox/dwio/parquet/reader/RleBpDecoder.h b/velox/dwio/parquet/reader/RleBpDecoder.h
index ac07ed76ad0c..5856de775e2b 100644
--- a/velox/dwio/parquet/reader/RleBpDecoder.h
+++ b/velox/dwio/parquet/reader/RleBpDecoder.h
@@ -37,7 +37,7 @@ class RleBpDecoder {
   /// Decode @param numValues number of values and copy the decoded values into
   /// @param outputBuffer
   template <typename T>
-  void next(T* FOLLY_NONNULL& outputBuffer, uint64_t numValues) {
+  void next(T * FOLLY_NONNULL & outputBuffer, uint64_t numValues) {
     while (numValues > 0) {
       if (numRemainingUnpackedValues_ > 0) {
         auto numValuesToRead =
@@ -103,7 +103,7 @@ class RleBpDecoder {
 
   template <typename T>
   inline void copyRemainingUnpackedValues(
-      T* FOLLY_NONNULL& outputBuffer,
+      T * FOLLY_NONNULL & outputBuffer,
       int8_t numValues) {
     VELOX_CHECK_LE(numValues, numRemainingUnpackedValues_);
 
diff --git a/velox/dwio/parquet/reader/StringColumnReader.cpp b/velox/dwio/parquet/reader/StringColumnReader.cpp
index ac678b7f0a39..7ce4f68d41ae 100644
--- a/velox/dwio/parquet/reader/StringColumnReader.cpp
+++ b/velox/dwio/parquet/reader/StringColumnReader.cpp
@@ -35,7 +35,7 @@ void StringColumnReader::read(
     int64_t offset,
     const RowSet& rows,
     const uint64_t* incomingNulls) {
-  prepareRead<folly::StringPiece>(offset, rows, incomingNulls);
+  prepareRead<std::string_view>(offset, rows, incomingNulls);
   dwio::common::StringColumnReadWithVisitorHelper<true, false>(
       *this, rows)([&](auto visitor) {
     formatData_->as<ParquetData>().readWithVisitor(visitor);
@@ -83,7 +83,7 @@ void StringColumnReader::dedictionarize() {
       }
       auto& view = dict->valueAt(indices[i]);
       numValues_ = i;
-      addStringValue(folly::StringPiece(view.data(), view.size()));
+      addStringValue(std::string_view(view.data(), view.size()));
     }
     numValues_ = numValues;
   }
diff --git a/velox/dwio/parquet/reader/StringDecoder.h b/velox/dwio/parquet/reader/StringDecoder.h
index 2bff5285e3c4..03805b5659fb 100644
--- a/velox/dwio/parquet/reader/StringDecoder.h
+++ b/velox/dwio/parquet/reader/StringDecoder.h
@@ -90,15 +90,15 @@ class StringDecoder {
     return *reinterpret_cast<const int32_t*>(buffer);
   }
 
-  folly::StringPiece readString() {
+  std::string_view readString() {
     auto length = lengthAt(bufferStart_);
     bufferStart_ += length + sizeof(int32_t);
-    return folly::StringPiece(bufferStart_ - length, length);
+    return std::string_view(bufferStart_ - length, length);
   }
 
-  folly::StringPiece readFixedString() {
+  std::string_view readFixedString() {
     bufferStart_ += fixedLength_;
-    return folly::StringPiece(bufferStart_ - fixedLength_, fixedLength_);
+    return std::string_view(bufferStart_ - fixedLength_, fixedLength_);
   }
 
   const char* bufferStart_;
diff --git a/velox/dwio/parquet/reader/StructColumnReader.cpp b/velox/dwio/parquet/reader/StructColumnReader.cpp
index 694f334c51a2..64740bf04108 100644
--- a/velox/dwio/parquet/reader/StructColumnReader.cpp
+++ b/velox/dwio/parquet/reader/StructColumnReader.cpp
@@ -46,12 +46,13 @@ StructColumnReader::StructColumnReader(
     auto childFileType = fileType_->childByName(childSpec->fieldName());
     auto childRequestedType =
         requestedType_->asRow().findChild(childSpec->fieldName());
-    addChild(ParquetColumnReader::build(
-        columnReaderOptions,
-        childRequestedType,
-        childFileType,
-        params,
-        *childSpec));
+    addChild(
+        ParquetColumnReader::build(
+            columnReaderOptions,
+            childRequestedType,
+            childFileType,
+            params,
+            *childSpec));
 
     childSpecs[i]->setSubscript(children_.size() - 1);
   }
diff --git a/velox/dwio/parquet/reader/TimestampColumnReader.h b/velox/dwio/parquet/reader/TimestampColumnReader.h
index df832d3daeac..6ee0cf7fc5ef 100644
--- a/velox/dwio/parquet/reader/TimestampColumnReader.h
+++ b/velox/dwio/parquet/reader/TimestampColumnReader.h
@@ -163,10 +163,10 @@ class TimestampColumnReader : public IntegerColumnReader {
       bool isDense,
       typename ExtractValues>
   void readHelper(
-      velox::common::Filter* filter,
+      const velox::common::Filter* filter,
       const RowSet& rows,
       ExtractValues extractValues) {
-    if (auto* range = dynamic_cast<common::TimestampRange*>(filter)) {
+    if (auto* range = dynamic_cast<const common::TimestampRange*>(filter)) {
       ParquetTimestampRange<T> newRange{
           range->lower(), range->upper(), range->nullAllowed(), filePrecision_};
       this->readWithVisitor(
@@ -176,12 +176,37 @@ class TimestampColumnReader : public IntegerColumnReader {
               common::TimestampRange,
               ExtractValues,
               isDense>(newRange, this, rows, extractValues));
+    } else if (
+        auto* multiRange = dynamic_cast<const common::MultiRange*>(filter)) {
+      std::vector<std::unique_ptr<common::Filter>> filters;
+      filters.reserve(multiRange->filters().size());
+      for (const auto& filter : multiRange->filters()) {
+        if (auto* range = dynamic_cast<common::TimestampRange*>(filter.get())) {
+          filters.emplace_back(
+              std::make_unique<ParquetTimestampRange<T>>(
+                  range->lower(),
+                  range->upper(),
+                  range->nullAllowed(),
+                  filePrecision_));
+        } else {
+          filters.emplace_back(filter->clone(range->nullAllowed()));
+        }
+      }
+      auto newMultiRange =
+          common::MultiRange(std::move(filters), multiRange->nullAllowed());
+      this->readWithVisitor(
+          rows,
+          dwio::common::ColumnVisitor<
+              int128_t,
+              common::MultiRange,
+              ExtractValues,
+              isDense>(newMultiRange, this, rows, extractValues));
     } else {
       this->readWithVisitor(
           rows,
           dwio::common::
               ColumnVisitor<int128_t, TFilter, ExtractValues, isDense>(
-                  *reinterpret_cast<TFilter*>(filter),
+                  *static_cast<const TFilter*>(filter),
                   this,
                   rows,
                   extractValues));
diff --git a/velox/dwio/parquet/tests/CMakeLists.txt b/velox/dwio/parquet/tests/CMakeLists.txt
index feeff62cb789..dc09a85c4fdc 100644
--- a/velox/dwio/parquet/tests/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/CMakeLists.txt
@@ -12,18 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(TEST_LINK_LIBS
-    velox_dwio_common_test_utils
-    velox_vector_test_lib
-    velox_exec_test_lib
-    velox_dwio_parquet_reader
-    velox_dwio_parquet_writer
-    velox_temp_path
-    GTest::gtest
-    GTest::gtest_main
-    GTest::gmock
-    gflags::gflags
-    glog::glog)
+set(
+  TEST_LINK_LIBS
+  velox_dwio_common_test_utils
+  velox_vector_test_lib
+  velox_exec_test_lib
+  velox_dwio_parquet_reader
+  velox_dwio_parquet_writer
+  velox_temp_path
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
+  gflags::gflags
+  glog::glog
+)
 
 add_subdirectory(common)
 add_subdirectory(reader)
@@ -34,13 +36,14 @@ add_executable(velox_dwio_parquet_tpch_test ParquetTpchTest.cpp)
 add_test(
   NAME velox_dwio_parquet_tpch_test
   COMMAND velox_dwio_parquet_tpch_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 target_link_libraries(
   velox_dwio_parquet_tpch_test
   velox_tpch_connector
   velox_aggregates
   velox_tpch_gen
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
-file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples
-     DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/velox/dwio/parquet/tests/ParquetTestBase.h b/velox/dwio/parquet/tests/ParquetTestBase.h
index c867978a0a5c..77662eb625da 100644
--- a/velox/dwio/parquet/tests/ParquetTestBase.h
+++ b/velox/dwio/parquet/tests/ParquetTestBase.h
@@ -19,6 +19,7 @@
 #include <gtest/gtest.h>
 #include <string>
 #include "velox/common/base/Fs.h"
+#include "velox/common/file/File.h"
 #include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/common/Reader.h"
 #include "velox/dwio/common/tests/utils/DataFiles.h"
@@ -191,10 +192,51 @@ class ParquetTestBase : public testing::Test,
         "velox/dwio/parquet/tests/reader", "../examples/" + fileName);
   }
 
+  dwio::common::MemorySink* write(
+      const RowVectorPtr& data,
+      const WriterOptions& writerOptions) {
+    auto sink = std::make_unique<dwio::common::MemorySink>(
+        200 * 1024 * 1024,
+        dwio::common::FileSink::Options{.pool = leafPool_.get()});
+    auto* sinkPtr = sink.get();
+    auto writer = std::make_unique<Writer>(
+        std::move(sink), writerOptions, data->rowType());
+    writer->write(data);
+    writer->close();
+    writers_.push_back(std::move(writer));
+    return sinkPtr;
+  }
+
+  dwio::common::MemorySink* write(
+      const RowVectorPtr& data,
+      std::unordered_map<std::string, std::string> configFromFile = {},
+      std::unordered_map<std::string, std::string> sessionProperties = {}) {
+    parquet::WriterOptions writerOptions;
+    writerOptions.memoryPool = rootPool_.get();
+    auto connectorConfig = config::ConfigBase(std::move(configFromFile));
+    auto connectorSessionProperties =
+        config::ConfigBase(std::move(sessionProperties));
+    writerOptions.processConfigs(connectorConfig, connectorSessionProperties);
+    return write(data, writerOptions);
+  }
+
+  std::unique_ptr<ParquetReader> createReaderInMemory(
+      const dwio::common::MemorySink& sink,
+      const dwio::common::ReaderOptions& opts) {
+    std::string data(sink.data(), sink.size());
+    return std::make_unique<ParquetReader>(
+        std::make_unique<dwio::common::BufferedInput>(
+            std::make_shared<InMemoryReadFile>(std::move(data)),
+            opts.memoryPool()),
+        opts);
+  }
+
   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_;
+  // Stores writers created by write() helper to keep sinks alive for reading.
+  std::vector<std::unique_ptr<Writer>> writers_;
 };
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/tests/ParquetTpchTest.cpp b/velox/dwio/parquet/tests/ParquetTpchTest.cpp
index 1ef7a9775b65..0a728abe8d4f 100644
--- a/velox/dwio/parquet/tests/ParquetTpchTest.cpp
+++ b/velox/dwio/parquet/tests/ParquetTpchTest.cpp
@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/dwio/parquet/RegisterParquetReader.h"
 #include "velox/dwio/parquet/RegisterParquetWriter.h"
@@ -54,26 +55,18 @@ class ParquetTpchTest : public testing::Test {
     parquet::registerParquetReaderFactory();
     parquet::registerParquetWriterFactory();
 
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
-    auto hiveConnector =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(
-                kHiveConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()));
+    connector::hive::HiveConnectorFactory hiveFactory;
+    auto hiveConnector = hiveFactory.newConnector(
+        kHiveConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
     connector::registerConnector(hiveConnector);
 
-    connector::registerConnectorFactory(
-        std::make_shared<connector::tpch::TpchConnectorFactory>());
-    auto tpchConnector =
-        connector::getConnectorFactory(
-            connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(
-                kTpchConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()));
+    connector::tpch::TpchConnectorFactory tpchFactory;
+    auto tpchConnector = tpchFactory.newConnector(
+        kTpchConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
     connector::registerConnector(tpchConnector);
 
     saveTpchTablesAsParquet();
@@ -81,10 +74,6 @@ class ParquetTpchTest : public testing::Test {
   }
 
   static void TearDownTestSuite() {
-    connector::unregisterConnectorFactory(
-        connector::hive::HiveConnectorFactory::kHiveConnectorName);
-    connector::unregisterConnectorFactory(
-        connector::tpch::TpchConnectorFactory::kTpchConnectorName);
     connector::unregisterConnector(kHiveConnectorId);
     connector::unregisterConnector(kTpchConnectorId);
     parquet::unregisterParquetReaderFactory();
@@ -105,8 +94,8 @@ class ParquetTpchTest : public testing::Test {
       auto plan = PlanBuilder()
                       .tpchTableScan(table, std::move(columnNames), 0.01)
                       .planNode();
-      auto split =
-          exec::Split(std::make_shared<connector::tpch::TpchConnectorSplit>(
+      auto split = exec::Split(
+          std::make_shared<connector::tpch::TpchConnectorSplit>(
               kTpchConnectorId, /*cacheable=*/true, 1, 0));
 
       auto rows =
diff --git a/velox/dwio/parquet/tests/common/CMakeLists.txt b/velox/dwio/parquet/tests/common/CMakeLists.txt
index c6d2593e9219..19cf296e68fa 100644
--- a/velox/dwio/parquet/tests/common/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/common/CMakeLists.txt
@@ -21,6 +21,8 @@ target_link_libraries(
   arrow
   thrift
   velox_link_libs
+  velox_exec
   GTest::gtest
   GTest::gmock
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/dwio/parquet/tests/common/LevelConversionTest.cpp b/velox/dwio/parquet/tests/common/LevelConversionTest.cpp
index e3ff3a7e6e9c..f7274b7c9744 100644
--- a/velox/dwio/parquet/tests/common/LevelConversionTest.cpp
+++ b/velox/dwio/parquet/tests/common/LevelConversionTest.cpp
@@ -160,38 +160,37 @@ MultiLevelTestData TriplyNestedList() {
   // [[[]], [[], [1, 2]], null, [[3]]],
   // null,
   // []
-  return MultiLevelTestData{
-      /*defLevels=*/std::vector<int16_t>{
-          2,
-          7,
-          6,
-          7,
-          5,
-          3, // first row
-          5,
-          5,
-          7,
-          7,
-          2,
-          7, // second row
-          0, // third row
-          1},
-      /*repLevels=*/
-      std::vector<int16_t>{
-          0,
-          1,
-          3,
-          3,
-          2,
-          1, // first row
-          0,
-          1,
-          2,
-          3,
-          1,
-          1, // second row
-          0,
-          0}};
+  return MultiLevelTestData{/*defLevels=*/std::vector<int16_t>{
+                                2,
+                                7,
+                                6,
+                                7,
+                                5,
+                                3, // first row
+                                5,
+                                5,
+                                7,
+                                7,
+                                2,
+                                7, // second row
+                                0, // third row
+                                1},
+                            /*repLevels=*/
+                            std::vector<int16_t>{
+                                0,
+                                1,
+                                3,
+                                3,
+                                2,
+                                1, // first row
+                                0,
+                                1,
+                                2,
+                                3,
+                                1,
+                                1, // second row
+                                0,
+                                0}};
 }
 
 template <typename ConverterType>
diff --git a/velox/dwio/parquet/tests/examples/complex_type_v2_page.parquet b/velox/dwio/parquet/tests/examples/complex_type_v2_page.parquet
new file mode 100644
index 000000000000..5b2af2256e8a
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/complex_type_v2_page.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/nested_array_struct.parquet b/velox/dwio/parquet/tests/examples/nested_array_struct.parquet
new file mode 100644
index 000000000000..41a43fa35d39
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/nested_array_struct.parquet differ
diff --git a/velox/dwio/parquet/tests/examples/proto_repeated_string.parquet b/velox/dwio/parquet/tests/examples/proto_repeated_string.parquet
new file mode 100644
index 000000000000..8a7eea601d01
Binary files /dev/null and b/velox/dwio/parquet/tests/examples/proto_repeated_string.parquet differ
diff --git a/velox/dwio/parquet/tests/reader/CMakeLists.txt b/velox/dwio/parquet/tests/reader/CMakeLists.txt
index 0402842a4ceb..ef72bf26b99f 100644
--- a/velox/dwio/parquet/tests/reader/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/reader/CMakeLists.txt
@@ -16,10 +16,14 @@ add_executable(velox_dwio_parquet_page_reader_test ParquetPageReaderTest.cpp)
 add_test(
   NAME velox_dwio_parquet_page_reader_test
   COMMAND velox_dwio_parquet_page_reader_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 target_link_libraries(
-  velox_dwio_parquet_page_reader_test velox_dwio_native_parquet_reader
-  velox_link_libs ${TEST_LINK_LIBS})
+  velox_dwio_parquet_page_reader_test
+  velox_dwio_native_parquet_reader
+  velox_link_libs
+  ${TEST_LINK_LIBS}
+)
 
 add_executable(velox_parquet_e2e_filter_test E2EFilterTest.cpp)
 add_test(velox_parquet_e2e_filter_test velox_parquet_e2e_filter_test)
@@ -29,10 +33,10 @@ target_link_libraries(
   velox_dwio_parquet_writer
   velox_dwio_native_parquet_reader
   lz4::lz4
-  lzo2::lzo2
   zstd::zstd
   ZLIB::ZLIB
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 add_library(velox_dwio_parquet_reader_benchmark_lib ParquetReaderBenchmark.cpp)
 target_link_libraries(
@@ -44,49 +48,62 @@ target_link_libraries(
   velox_hive_connector
   ${TEST_LINK_LIBS}
   Folly::follybenchmark
-  Folly::folly)
+  Folly::folly
+)
 
 if(VELOX_ENABLE_BENCHMARKS)
-  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_benchmark ParquetReaderBenchmarkMain.cpp)
+  target_link_libraries(velox_dwio_parquet_reader_benchmark velox_dwio_parquet_reader_benchmark_lib)
 endif()
 
 add_executable(
   velox_dwio_parquet_reader_test
-  ParquetReaderTest.cpp ParquetReaderBenchmarkTest.cpp BloomFilterTest.cpp)
+  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})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 target_link_libraries(
-  velox_dwio_parquet_reader_test velox_dwio_parquet_common
-  velox_dwio_parquet_reader_benchmark_lib velox_link_libs)
+  velox_dwio_parquet_reader_test
+  velox_dwio_parquet_common
+  velox_dwio_parquet_reader_benchmark_lib
+  velox_hive_connector
+  velox_link_libs
+)
 
-add_executable(velox_dwio_parquet_structure_decoder_test
-               NestedStructureDecoderTest.cpp)
+add_executable(velox_dwio_parquet_structure_decoder_test NestedStructureDecoderTest.cpp)
 add_test(
   NAME velox_dwio_parquet_structure_decoder_test
   COMMAND velox_dwio_parquet_structure_decoder_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 target_link_libraries(
-  velox_dwio_parquet_structure_decoder_test velox_dwio_native_parquet_reader
-  velox_link_libs ${TEST_LINK_LIBS})
+  velox_dwio_parquet_structure_decoder_test
+  velox_dwio_native_parquet_reader
+  velox_link_libs
+  ${TEST_LINK_LIBS}
+)
 
 if(VELOX_ENABLE_BENCHMARKS)
-  add_executable(velox_dwio_parquet_structure_decoder_benchmark
-                 NestedStructureDecoderBenchmark.cpp)
+  add_executable(velox_dwio_parquet_structure_decoder_benchmark NestedStructureDecoderBenchmark.cpp)
   target_link_libraries(
     velox_dwio_parquet_structure_decoder_benchmark
-    velox_dwio_native_parquet_reader Folly::folly Folly::follybenchmark)
+    velox_dwio_native_parquet_reader
+    Folly::folly
+    Folly::follybenchmark
+  )
 endif()
 
 add_executable(velox_dwio_parquet_table_scan_test ParquetTableScanTest.cpp)
 add_test(
   NAME velox_dwio_parquet_table_scan_test
   COMMAND velox_dwio_parquet_table_scan_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 target_link_libraries(
   velox_dwio_parquet_table_scan_test
   velox_dwio_parquet_reader
@@ -96,20 +113,21 @@ target_link_libraries(
   velox_hive_connector
   velox_link_libs
   velox_type_tz
-  ${TEST_LINK_LIBS})
+  ${TEST_LINK_LIBS}
+)
 
 if(${VELOX_ENABLE_ARROW})
-
   add_executable(velox_dwio_parquet_rlebp_decoder_test RleBpDecoderTest.cpp)
   add_test(
     NAME velox_dwio_parquet_rlebp_decoder_test
     COMMAND velox_dwio_parquet_rlebp_decoder_test
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    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})
-
+    ${TEST_LINK_LIBS}
+  )
 endif()
diff --git a/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp b/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
index f5f608d812aa..b8d4e324b784 100644
--- a/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
+++ b/velox/dwio/parquet/tests/reader/E2EFilterTest.cpp
@@ -99,8 +99,9 @@ class E2EFilterTest : public E2EFilterTestBase,
 TEST_F(E2EFilterTest, writerMagic) {
   rowType_ = ROW({"c0"}, {INTEGER()});
   std::vector<RowVectorPtr> batches;
-  batches.push_back(std::static_pointer_cast<RowVector>(
-      test::BatchMaker::createBatch(rowType_, 20000, *leafPool_, nullptr, 0)));
+  batches.push_back(
+      std::static_pointer_cast<RowVector>(test::BatchMaker::createBatch(
+          rowType_, 20000, *leafPool_, nullptr, 0)));
   writeToMemory(rowType_, batches, false);
   auto data = sinkData_.data();
   auto size = sinkData_.size();
@@ -657,8 +658,9 @@ TEST_F(E2EFilterTest, largeMetadata) {
 
   rowType_ = ROW({"c0"}, {INTEGER()});
   std::vector<RowVectorPtr> batches;
-  batches.push_back(std::static_pointer_cast<RowVector>(
-      test::BatchMaker::createBatch(rowType_, 1000, *leafPool_, nullptr, 0)));
+  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.setFooterEstimatedSize(1024);
@@ -694,8 +696,9 @@ TEST_F(E2EFilterTest, combineRowGroup) {
   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)));
+    batches.push_back(
+        std::static_pointer_cast<RowVector>(test::BatchMaker::createBatch(
+            rowType_, 1, *leafPool_, nullptr, 0)));
   }
   writeToMemory(rowType_, batches, false);
   dwio::common::ReaderOptions readerOpts{leafPool_.get()};
@@ -711,7 +714,7 @@ 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))});
+       makeFlatVector<int128_t>({1, 2}, DECIMAL(19, 2))});
   writeToMemory(rowVector->type(), {rowVector}, false);
   dwio::common::ReaderOptions readerOpts{leafPool_.get()};
   auto input = std::make_unique<BufferedInput>(
diff --git a/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp b/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
index 5145dcfdc8ca..d037cf44b91a 100644
--- a/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetPageReaderTest.cpp
@@ -31,11 +31,13 @@ TEST_F(ParquetPageReaderTest, smallPage) {
   auto headerSize = file->getLength();
   auto inputStream = std::make_unique<SeekableFileInputStream>(
       std::move(file), 0, headerSize, *leafPool_, LogType::TEST);
+  dwio::common::ColumnReaderStatistics stats;
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
       *leafPool_,
       common::CompressionKind::CompressionKind_GZIP,
-      headerSize);
+      headerSize,
+      stats);
   auto header = pageReader->readPageHeader();
   EXPECT_EQ(header.type, thrift::PageType::type::DATA_PAGE);
   EXPECT_EQ(header.uncompressed_page_size, 16950);
@@ -50,6 +52,7 @@ TEST_F(ParquetPageReaderTest, smallPage) {
   auto maxValue = header.data_page_header.statistics.max_value;
   EXPECT_EQ(minValue, expectedMinValue);
   EXPECT_EQ(maxValue, expectedMaxValue);
+  EXPECT_GT(stats.pageLoadTimeNs.sum(), 0);
 }
 
 TEST_F(ParquetPageReaderTest, largePage) {
@@ -59,11 +62,13 @@ TEST_F(ParquetPageReaderTest, largePage) {
   auto headerSize = file->getLength();
   auto inputStream = std::make_unique<SeekableFileInputStream>(
       std::move(file), 0, headerSize, *leafPool_, LogType::TEST);
+  dwio::common::ColumnReaderStatistics stats;
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
       *leafPool_,
       common::CompressionKind::CompressionKind_GZIP,
-      headerSize);
+      headerSize,
+      stats);
   auto header = pageReader->readPageHeader();
 
   EXPECT_EQ(header.type, thrift::PageType::type::DATA_PAGE);
@@ -79,6 +84,7 @@ TEST_F(ParquetPageReaderTest, largePage) {
   auto maxValue = header.data_page_header.statistics.max_value;
   EXPECT_EQ(minValue, expectedMinValue);
   EXPECT_EQ(maxValue, expectedMaxValue);
+  EXPECT_GT(stats.pageLoadTimeNs.sum(), 0);
 }
 
 TEST_F(ParquetPageReaderTest, corruptedPageHeader) {
@@ -92,11 +98,13 @@ TEST_F(ParquetPageReaderTest, corruptedPageHeader) {
   // 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.
+  dwio::common::ColumnReaderStatistics stats;
   auto pageReader = std::make_unique<PageReader>(
       std::move(inputStream),
       *leafPool_,
       common::CompressionKind::CompressionKind_GZIP,
-      headerSize);
+      headerSize,
+      stats);
 
   EXPECT_THROW(pageReader->readPageHeader(), VeloxException);
 }
diff --git a/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp b/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
index f1ee25766dbf..adb6ffc7ab55 100644
--- a/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetReaderTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/Mutation.h"
 #include "velox/dwio/parquet/tests/ParquetTestBase.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
@@ -595,8 +596,9 @@ TEST_F(ParquetReaderTest, parseUnsignedInt1) {
           {TINYINT(), SMALLINT(), INTEGER(), BIGINT()});
 
   RowReaderOptions rowReaderOpts;
-  rowReaderOpts.select(std::make_shared<dwio::common::ColumnSelector>(
-      rowType, rowType->names()));
+  rowReaderOpts.select(
+      std::make_shared<dwio::common::ColumnSelector>(
+          rowType, rowType->names()));
   rowReaderOpts.setScanSpec(makeScanSpec(rowType));
   auto rowReader = reader->createRowReader(rowReaderOpts);
 
@@ -1456,7 +1458,6 @@ TEST_F(ParquetReaderTest, readFixedLenBinaryAsStringFromUuid) {
 }
 
 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()};
@@ -1480,6 +1481,31 @@ TEST_F(ParquetReaderTest, testV2PageWithZeroMaxDefRep) {
       outputRowType, *rowReader, expected, *leafPool_);
 }
 
+TEST_F(ParquetReaderTest, readComplexTypeWithV2Page) {
+  const std::string sample(getExampleFilePath("complex_type_v2_page.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(), 2ULL);
+
+  auto outputRowType =
+      ROW({"nums", "props"}, {ARRAY(INTEGER()), MAP(VARCHAR(), INTEGER())});
+  auto rowReaderOpts = getReaderOpts(outputRowType);
+  rowReaderOpts.setScanSpec(makeScanSpec(outputRowType));
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  auto expected = makeRowVector(
+      {makeArrayVectorFromJson<int32_t>({"[4 ,5]"}),
+       makeMapVectorFromJson<std::string, int32_t>(
+           {"{\"x\": 99, \"y\": 100}"})});
+  assertReadWithReaderAndExpected(
+      outputRowType, *rowReader, expected, *leafPool_);
+}
+
 TEST_F(ParquetReaderTest, arrayOfMapOfIntKeyArrayValue) {
   //  The Schema is of type
   //  message hive_schema {
@@ -1733,3 +1759,355 @@ TEST_F(ParquetReaderTest, fileColumnVarcharToMetadataColumnMismatchTest) {
     runVarcharColTest(type);
   }
 }
+
+TEST_F(ParquetReaderTest, readerWithSchema) {
+  // Create an in-memory writer.
+  auto sink = std::make_unique<MemorySink>(
+      1024 * 1024, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto sinkPtr = sink.get();
+  const auto data = makeRowVector(
+      {makeFlatVector<int64_t>({1}),
+       makeArrayVectorFromJson<int32_t>({"[4 ,5]"})});
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = leafPool_.get();
+
+  // key, element are Parquet reserved keywords.
+  // Ensure we handle them properly during the schema inference.
+  auto schema = ROW({"key", "element"}, {BIGINT(), ARRAY(INTEGER())});
+
+  auto writer = std::make_unique<facebook::velox::parquet::Writer>(
+      std::move(sink), writerOptions, rootPool_, schema);
+  writer->write(data);
+  writer->close();
+
+  // Create the reader.
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  readerOptions.setFileSchema(schema);
+  std::string dataBuf(sinkPtr->data(), sinkPtr->size());
+  auto file = std::make_shared<InMemoryReadFile>(std::move(dataBuf));
+  auto buffer = std::make_unique<dwio::common::BufferedInput>(
+      file, readerOptions.memoryPool());
+  ParquetReader reader(std::move(buffer), readerOptions);
+
+  EXPECT_EQ(reader.rowType()->toString(), schema->toString());
+}
+
+// Comprehensive test matrix covering all combinations:
+// - Nulls: No nulls, With nulls
+// - Dictionary: Enabled, Disabled
+// - Filter: None, IsNull, IsNotNull, Value filter
+// - Density: Dense (no deletions), Non-dense (with deletions/mutations)
+
+enum class FloatToDoubleFilter {
+  kNone,
+  kIsNull,
+  kIsNotNull,
+  kGreaterThanOrEqual, // Value filter: greater than or equal to a threshold
+  kMultiRange, // MultiRange filter: a < X OR a > Y
+};
+
+struct FloatToDoubleSpec {
+  std::vector<std::optional<float>> values;
+  std::vector<int64_t> ids;
+  bool enableDictionary{true};
+  FloatToDoubleFilter filter{FloatToDoubleFilter::kNone};
+  std::optional<double> filterValue; // Value for value-based filters
+  std::optional<double> filterLowerValue; // Lower bound for MultiRange filter
+  std::optional<double> filterUpperValue; // Upper bound for MultiRange filter
+  std::vector<vector_size_t> deletedRows;
+};
+
+struct FloatToDoubleTestParam {
+  bool hasNulls;
+  bool enableDictionary;
+  FloatToDoubleFilter filter;
+  bool isDense;
+
+  std::string toString() const {
+    return fmt::format(
+        "Nulls_{}_Dict_{}_Filter_{}_Dense_{}",
+        hasNulls ? "Yes" : "No",
+        enableDictionary ? "Yes" : "No",
+        filterName(filter),
+        isDense ? "Yes" : "No");
+  }
+
+  static std::string filterName(FloatToDoubleFilter filter) {
+    switch (filter) {
+      case FloatToDoubleFilter::kNone:
+        return "None";
+      case FloatToDoubleFilter::kIsNull:
+        return "IsNull";
+      case FloatToDoubleFilter::kIsNotNull:
+        return "IsNotNull";
+      case FloatToDoubleFilter::kGreaterThanOrEqual:
+        return "GreaterThanOrEqual";
+      case FloatToDoubleFilter::kMultiRange:
+        return "MultiRange";
+      default:
+        return "Unknown";
+    }
+  }
+};
+
+class FloatToDoubleEvolutionTest
+    : public ParquetReaderTest,
+      public testing::WithParamInterface<FloatToDoubleTestParam> {
+ public:
+  static std::vector<FloatToDoubleTestParam> getTestParams() {
+    std::vector<FloatToDoubleTestParam> params;
+    for (bool hasNulls : {false, true}) {
+      for (bool enableDictionary : {false, true}) {
+        // When hasNulls is false, only test kNone, kGreaterThanOrEqual, and
+        // kMultiRange filter (kIsNull would match nothing, kIsNotNull is
+        // equivalent to kNone)
+        std::vector<FloatToDoubleFilter> filters;
+        if (hasNulls) {
+          filters = {
+              FloatToDoubleFilter::kNone,
+              FloatToDoubleFilter::kIsNull,
+              FloatToDoubleFilter::kIsNotNull,
+              FloatToDoubleFilter::kGreaterThanOrEqual,
+              FloatToDoubleFilter::kMultiRange};
+        } else {
+          filters = {
+              FloatToDoubleFilter::kNone,
+              FloatToDoubleFilter::kGreaterThanOrEqual,
+              FloatToDoubleFilter::kMultiRange};
+        }
+
+        for (auto filter : filters) {
+          for (bool isDense : {true, false}) {
+            params.push_back({hasNulls, enableDictionary, filter, isDense});
+          }
+        }
+      }
+    }
+    return params;
+  }
+
+  void runFloatToDoubleScenario(const FloatToDoubleSpec& spec);
+};
+
+void FloatToDoubleEvolutionTest::runFloatToDoubleScenario(
+    const FloatToDoubleSpec& spec) {
+  ASSERT_EQ(spec.values.size(), spec.ids.size());
+  const vector_size_t numRows = spec.ids.size();
+
+  auto floatVector = makeNullableFlatVector<float>(spec.values);
+  auto idVector =
+      makeFlatVector<int64_t>(numRows, [&](auto row) { return spec.ids[row]; });
+
+  RowVectorPtr writeData = makeRowVector({floatVector, idVector});
+  RowTypePtr writeSchema = ROW({"float_col", "id"}, {REAL(), BIGINT()});
+
+  auto sink = std::make_unique<MemorySink>(
+      1024 * 1024, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto sinkPtr = sink.get();
+
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.enableDictionary = spec.enableDictionary;
+
+  auto writer = std::make_unique<facebook::velox::parquet::Writer>(
+      std::move(sink), writerOptions, rootPool_, writeSchema);
+  writer->write(writeData);
+  writer->close();
+
+  RowTypePtr readSchema = ROW({"float_col", "id"}, {DOUBLE(), BIGINT()});
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  readerOptions.setFileSchema(readSchema);
+
+  std::string dataBuf(sinkPtr->data(), sinkPtr->size());
+  auto file = std::make_shared<InMemoryReadFile>(std::move(dataBuf));
+  auto buffer = std::make_unique<dwio::common::BufferedInput>(
+      file, readerOptions.memoryPool());
+  auto reader =
+      std::make_unique<ParquetReader>(std::move(buffer), readerOptions);
+
+  RowReaderOptions rowReaderOpts;
+  rowReaderOpts.select(
+      std::make_shared<facebook::velox::dwio::common::ColumnSelector>(
+          readSchema, readSchema->names()));
+  auto scanSpec = makeScanSpec(readSchema);
+
+  // Apply IsNull or IsNotNull filter if specified
+  switch (spec.filter) {
+    case FloatToDoubleFilter::kNone:
+      break;
+    case FloatToDoubleFilter::kIsNull: {
+      auto* floatChild =
+          scanSpec->getOrCreateChild(common::Subfield("float_col"));
+      floatChild->setFilter(exec::isNull());
+      break;
+    }
+    case FloatToDoubleFilter::kIsNotNull: {
+      auto* floatChild =
+          scanSpec->getOrCreateChild(common::Subfield("float_col"));
+      floatChild->setFilter(exec::isNotNull());
+      break;
+    }
+    case FloatToDoubleFilter::kGreaterThanOrEqual: {
+      ASSERT_TRUE(spec.filterValue.has_value());
+      auto* floatChild =
+          scanSpec->getOrCreateChild(common::Subfield("float_col"));
+      floatChild->setFilter(
+          exec::greaterThanOrEqualDouble(spec.filterValue.value()));
+      break;
+    }
+    case FloatToDoubleFilter::kMultiRange: {
+      ASSERT_TRUE(spec.filterLowerValue.has_value());
+      ASSERT_TRUE(spec.filterUpperValue.has_value());
+      auto* floatChild =
+          scanSpec->getOrCreateChild(common::Subfield("float_col"));
+      // Create a MultiRange filter: a < lower OR a > upper
+      floatChild->setFilter(
+          exec::orFilter(
+              exec::lessThanDouble(spec.filterLowerValue.value()),
+              exec::greaterThanDouble(spec.filterUpperValue.value())));
+      break;
+    }
+  }
+
+  rowReaderOpts.setScanSpec(scanSpec);
+  auto rowReader = reader->createRowReader(rowReaderOpts);
+
+  std::vector<bool> deletedFlags(numRows, false);
+  for (auto index : spec.deletedRows) {
+    ASSERT_LT(index, numRows);
+    deletedFlags[index] = true;
+  }
+
+  std::vector<vector_size_t> expectedIndices;
+  expectedIndices.reserve(numRows);
+  for (vector_size_t row = 0; row < numRows; ++row) {
+    if (deletedFlags[row]) {
+      continue;
+    }
+
+    bool passes = false;
+    switch (spec.filter) {
+      case FloatToDoubleFilter::kNone:
+        passes = true;
+        break;
+      case FloatToDoubleFilter::kIsNull:
+        passes = !spec.values[row].has_value();
+        break;
+      case FloatToDoubleFilter::kIsNotNull:
+        passes = spec.values[row].has_value();
+        break;
+      case FloatToDoubleFilter::kGreaterThanOrEqual:
+        passes = spec.values[row].has_value() &&
+            static_cast<double>(*spec.values[row]) >= spec.filterValue.value();
+        break;
+      case FloatToDoubleFilter::kMultiRange:
+        passes = spec.values[row].has_value() &&
+            (static_cast<double>(*spec.values[row]) <
+                 spec.filterLowerValue.value() ||
+             static_cast<double>(*spec.values[row]) >
+                 spec.filterUpperValue.value());
+        break;
+    }
+
+    if (passes) {
+      expectedIndices.push_back(row);
+    }
+  }
+
+  std::vector<std::optional<double>> expectedDoubles(expectedIndices.size());
+  for (size_t i = 0; i < expectedIndices.size(); ++i) {
+    const auto originalIndex = expectedIndices[i];
+    if (!spec.values[originalIndex].has_value()) {
+      expectedDoubles[i] = std::nullopt;
+    } else {
+      expectedDoubles[i] = static_cast<double>(*spec.values[originalIndex]);
+    }
+  }
+
+  auto expectedFloat = makeNullableFlatVector<double>(expectedDoubles);
+  auto expectedId = makeFlatVector<int64_t>(
+      expectedIndices.size(),
+      [&](auto row) { return spec.ids[expectedIndices[row]]; });
+  RowVectorPtr expected = makeRowVector({expectedFloat, expectedId});
+
+  if (spec.deletedRows.empty() && spec.filter != FloatToDoubleFilter::kIsNull &&
+      spec.filter != FloatToDoubleFilter::kIsNotNull &&
+      spec.filter != FloatToDoubleFilter::kGreaterThanOrEqual &&
+      spec.filter != FloatToDoubleFilter::kMultiRange) {
+    assertReadWithReaderAndExpected(
+        readSchema, *rowReader, expected, *leafPool_);
+    return;
+  }
+
+  VectorPtr result = BaseVector::create(readSchema, 0, leafPool_.get());
+  vector_size_t scanned = 0;
+  std::vector<uint64_t> deleted(bits::nwords(numRows), 0);
+  if (spec.deletedRows.empty()) {
+    scanned = rowReader->next(numRows, result);
+  } else {
+    for (auto index : spec.deletedRows) {
+      bits::setBit(deleted.data(), index);
+    }
+    dwio::common::Mutation mutation;
+    mutation.deletedRows = deleted.data();
+    scanned = rowReader->next(numRows, result, &mutation);
+  }
+
+  EXPECT_GT(scanned, 0);
+  EXPECT_GE(scanned, expected->size());
+  ASSERT_TRUE(result != nullptr);
+  auto rowVector = result->as<RowVector>();
+  ASSERT_TRUE(rowVector != nullptr);
+  ASSERT_EQ(rowVector->size(), expected->size());
+  assertEqualVectorPart(expected, result, 0);
+}
+
+TEST_P(FloatToDoubleEvolutionTest, readFloatToDouble) {
+  const auto& param = GetParam();
+  FloatToDoubleSpec spec;
+  constexpr vector_size_t kSize = 200;
+  spec.enableDictionary = param.enableDictionary;
+  spec.values.resize(kSize);
+  spec.ids.resize(kSize);
+
+  for (vector_size_t row = 0; row < kSize; ++row) {
+    if (param.hasNulls && row % 5 == 0) {
+      spec.values[row] = std::nullopt;
+    } else {
+      // Use a value pattern that works for both dictionary and direct encoding
+      float val =
+          static_cast<float>(row % 10) * 1.1f + static_cast<float>(row) * 0.01f;
+      spec.values[row] = val;
+    }
+    spec.ids[row] = row;
+  }
+
+  spec.filter = param.filter;
+
+  // Set filter value for value-based filters
+  if (param.filter == FloatToDoubleFilter::kGreaterThanOrEqual) {
+    // Filter values greater than or equal to 5.0 (this should match
+    // approximately half the rows)
+    spec.filterValue = 5.0;
+  } else if (param.filter == FloatToDoubleFilter::kMultiRange) {
+    // Filter values < 3.0 OR > 7.0
+    spec.filterLowerValue = 3.0;
+    spec.filterUpperValue = 7.0;
+  }
+
+  if (!param.isDense) {
+    // Add some deleted rows scattered throughout
+    spec.deletedRows = {5, 20, 55, 99, 150, 199};
+  }
+
+  runFloatToDoubleScenario(spec);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    FloatToDoubleEvolution,
+    FloatToDoubleEvolutionTest,
+    testing::ValuesIn(FloatToDoubleEvolutionTest::getTestParams()),
+    [](const testing::TestParamInfo<FloatToDoubleTestParam>& info) {
+      return info.param.toString();
+    });
diff --git a/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp b/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
index c272fa43a8bc..9a2690e79a63 100644
--- a/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
+++ b/velox/dwio/parquet/tests/reader/ParquetTableScanTest.cpp
@@ -69,8 +69,7 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
 
   void assertSelectWithAssignments(
       std::vector<std::string>&& outputColumnNames,
-      std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>&
-          assignments,
+      const connector::ColumnHandleMap& assignments,
       const std::string& sql) {
     auto rowType = getRowType(std::move(outputColumnNames));
     auto plan = PlanBuilder()
@@ -84,9 +83,7 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
       const std::vector<std::string>& subfieldFilters,
       const std::string& remainingFilter,
       const std::string& sql,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& assignments = {}) {
+      const connector::ColumnHandleMap& assignments = {}) {
     auto rowType = getRowType(std::move(outputColumnNames));
     parse::ParseOptions options;
     options.parseDecimalAsDouble = false;
@@ -293,6 +290,11 @@ class ParquetTableScanTest : public HiveConnectorTestBase {
         {},
         "t == TIMESTAMP '2022-12-23 03:56:01'",
         "SELECT t from tmp where t == TIMESTAMP '2022-12-23 03:56:01'");
+    assertSelectWithFilter(
+        {"t"},
+        {},
+        "not(eq(t, TIMESTAMP '2000-09-12 22:36:29'))",
+        "SELECT t from tmp where t != TIMESTAMP '2000-09-12 22:36:29'");
   }
 
  private:
@@ -426,6 +428,39 @@ TEST_F(ParquetTableScanTest, aggregatePushdown) {
   assertEqualVectors(rows->childAt(1), valuesVector);
 }
 
+TEST_F(ParquetTableScanTest, aggregatePushdownToSmallPages) {
+  const std::vector<std::string> columnNames = {"a", "b", "c"};
+  const auto expectedRowVector = makeRowVector(
+      {makeFlatVector<int16_t>({1, 2, 4}),
+       makeFlatVector<int64_t>({7, 9, 13})});
+  const auto outputType = ROW(columnNames, {SMALLINT(), SMALLINT(), VARCHAR()});
+  std::vector<RowVectorPtr> data;
+  for (auto row = 0; row < 10; ++row) {
+    data.emplace_back(makeRowVector(
+        columnNames,
+        {
+            makeFlatVector<int16_t>({static_cast<int16_t>(row % 5)}),
+            makeFlatVector<int16_t>({static_cast<int16_t>(row)}),
+            makeFlatVector<std::string>({std::to_string(row)}),
+        }));
+  }
+  const auto filePath = TempFilePath::create();
+  WriterOptions options;
+  options.dataPageSize = 1;
+  writeToParquetFile(filePath->getPath(), data, options);
+  const auto plan =
+      PlanBuilder(pool())
+          .tableScan(
+              outputType,
+              {},
+              "c <> '' AND a in (1::smallint, 2::smallint, 4::smallint)")
+          .singleAggregation({"a"}, {"sum(b) as s"})
+          .planNode();
+  AssertQueryBuilder(plan)
+      .split(makeSplit(filePath->getPath()))
+      .assertResults(expectedRowVector);
+}
+
 TEST_F(ParquetTableScanTest, countStar) {
   // sample.parquet holds two columns (a: BIGINT, b: DOUBLE) and
   // 20 rows.
@@ -537,8 +572,77 @@ TEST_F(ParquetTableScanTest, array) {
               vector,
           }));
 
-  assertSelectWithFilter(
-      {"repeatedInt"}, {}, "", "SELECT UNNEST(array[array[1,2,3]])");
+  assertSelectWithFilter({"repeatedInt"}, {}, "", "SELECT [1,2,3]");
+
+  // Set the requested type for unannotated array.
+  auto rowType = ROW({"repeatedInt"}, {ARRAY(INTEGER())});
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(rowType, {}, "", rowType, {})
+                  .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .splits({makeSplit(getExampleFilePath("old_repeated_int.parquet"))})
+      .assertResults("SELECT [1,2,3]");
+
+  // Throws when reading repeated values as scalar type.
+  rowType = ROW({"repeatedInt"}, {INTEGER()});
+  plan = PlanBuilder(pool_.get())
+             .tableScan(rowType, {}, "", rowType, {})
+             .planNode();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .splits({makeSplit(getExampleFilePath("old_repeated_int.parquet"))})
+          .assertResults(""),
+      "Requested type must be array");
+
+  rowType = ROW({"mystring"}, {ARRAY(VARCHAR())});
+  plan = PlanBuilder(pool_.get())
+             .tableScan(rowType, {}, "", rowType, {})
+             .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .splits({makeSplit(getExampleFilePath("proto_repeated_string.parquet"))})
+      .assertResults(
+          "SELECT UNNEST(array[array['hello', 'world'], array['good','bye'], array['one', 'two', 'three']])");
+
+  rowType =
+      ROW({"primitive", "myComplex"},
+          {INTEGER(),
+           ARRAY(
+               ROW({"id", "repeatedMessage"},
+                   {INTEGER(), ARRAY(ROW({"someId"}, {INTEGER()}))}))});
+  plan = PlanBuilder(pool_.get())
+             .tableScan(rowType, {}, "", rowType, {})
+             .planNode();
+
+  // Construct the expected vector.
+  auto someIdVector = makeArrayOfRowVector(
+      ROW({"someId"}, {INTEGER()}),
+      {
+          {variant::row({3})},
+          {variant::row({6})},
+          {variant::row({9})},
+      });
+  auto rowVector = makeRowVector(
+      {"id", "repeatedMessage"},
+      {
+          makeFlatVector<int32_t>({1, 4, 7}),
+          someIdVector,
+      });
+  auto expected = makeRowVector(
+      {"primitive", "myComplex"},
+      {
+          makeFlatVector<int32_t>({2, 5, 8}),
+          makeArrayVector({0, 1, 2}, rowVector),
+      });
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kParquetUseColumnNamesSession,
+          "true")
+      .splits({makeSplit(getExampleFilePath("nested_array_struct.parquet"))})
+      .assertResults(expected);
 }
 
 // Optional array with required elements.
@@ -655,44 +759,55 @@ TEST_F(ParquetTableScanTest, filterOnNestedArray) {
 }
 
 TEST_F(ParquetTableScanTest, readAsLowerCase) {
-  auto plan = PlanBuilder(pool_.get())
-                  .tableScan(ROW({"a"}, {BIGINT()}), {}, "")
-                  .planNode();
-  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::kFileColumnNamesReadAsLowerCaseSession),
-       "true"}};
-  queryCtx->setConnectorSessionOverridesUnsafe(
-      kHiveConnectorId, std::move(session));
-  params.queryCtx = queryCtx;
-  params.planNode = plan;
-  const int numSplitsPerFile = 1;
-
-  auto addSplits = [&](exec::TaskCursor* taskCursor) {
-    if (taskCursor->noMoreSplits()) {
-      return;
-    }
-    auto& task = taskCursor->task();
-    auto const splits = HiveConnectorTestBase::makeHiveConnectorSplits(
-        {getExampleFilePath("upper.parquet")},
-        numSplitsPerFile,
-        dwio::common::FileFormat::PARQUET);
-    for (const auto& split : splits) {
-      task->addSplit("0", exec::Split(split));
-    }
-    task->noMoreSplits("0");
-    taskCursor->setNoMoreSplits();
-  };
-  auto result = readCursor(params, addSplits);
-  ASSERT_TRUE(waitForTaskCompletion(result.first->task().get()));
-  assertEqualResults(
-      result.second, {makeRowVector({"a"}, {makeFlatVector<int64_t>({0, 1})})});
+  auto vectors = {makeRowVector(
+      {"A", "b"},
+      {
+          makeFlatVector<int64_t>(20, [](auto row) { return row + 1; }),
+          makeFlatVector<double>(20, [](auto row) { return row + 1; }),
+      })};
+  auto filePath = TempFilePath::create();
+  WriterOptions options;
+  writeToParquetFile(filePath->getPath(), vectors, options);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder().tableScan(ROW({"a"}, {BIGINT()})).planNode();
+  auto split = makeSplit(filePath->getPath());
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kFileColumnNamesReadAsLowerCaseSession,
+          "true")
+      .split(split)
+      .assertResults("SELECT A FROM tmp");
+
+  // Test reading table with non-ascii names.
+  auto vectorsNonAsciiNames = {makeRowVector(
+      {"Товары", "国Ⅵ", "\uFF21", "\uFF22"},
+      {
+          makeFlatVector<int64_t>(20, [](auto row) { return row + 1; }),
+          makeFlatVector<double>(20, [](auto row) { return row + 1; }),
+          makeFlatVector<float>(20, [](auto row) { return row + 1; }),
+          makeFlatVector<int32_t>(20, [](auto row) { return row + 1; }),
+      })};
+  filePath = TempFilePath::create();
+  writeToParquetFile(filePath->getPath(), vectorsNonAsciiNames, options);
+  createDuckDbTable(vectorsNonAsciiNames);
+
+  plan = PlanBuilder()
+             .tableScan(
+                 ROW({"товары", "国ⅵ", "\uFF41", "\uFF42"},
+                     {BIGINT(), DOUBLE(), REAL(), INTEGER()}))
+             .planNode();
+  split = makeSplit(filePath->getPath());
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kFileColumnNamesReadAsLowerCaseSession,
+          "true")
+      .split(split)
+      .assertResults("SELECT * FROM tmp");
 }
 
 TEST_F(ParquetTableScanTest, rowIndex) {
@@ -714,8 +829,7 @@ TEST_F(ParquetTableScanTest, rowIndex) {
           }),
       std::nullopt,
       std::unordered_map<std::string, std::string>{{kPath, filePath}});
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
   assignments["a"] = std::make_shared<connector::hive::HiveColumnHandle>(
       "a",
       connector::hive::HiveColumnHandle::ColumnType::kRegular,
@@ -812,16 +926,14 @@ TEST_F(ParquetTableScanTest, filterNullIcebergPartition) {
       {"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}});
+      connector::ColumnHandleMap{{"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}});
+      connector::ColumnHandleMap{{"c0", c0}, {"c1", c1}});
 }
 
 TEST_F(ParquetTableScanTest, sessionTimezone) {
@@ -1334,6 +1446,43 @@ TEST_F(ParquetTableScanTest, shortAndLongDecimalReadWithLargerPrecision) {
   assertEqualVectors(expectedDecimalVectors->childAt(1), rows->childAt(1));
 }
 
+TEST_F(ParquetTableScanTest, inFilter) {
+  auto vectors = {makeRowVector(
+      {"name"},
+      {
+          makeNullableFlatVector<std::string>(
+              {"mary", "martin", "lucy", "alex", std::nullopt, "mary", "dan"}),
+      })};
+  auto filePath = TempFilePath::create();
+  WriterOptions options;
+  writeToParquetFile(filePath->getPath(), vectors, options);
+  createDuckDbTable(vectors);
+
+  // Test in.
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(
+                      ROW({"name"}, {VARCHAR()}),
+                      {"name in ('alex', 'leo', 'mary', null, 'victor')"},
+                      "")
+                  .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .split(makeSplit(filePath->getPath()))
+      .assertResults(
+          "SELECT name FROM tmp where name in ('alex', 'leo', 'mary', null, 'victor')");
+
+  // Test not in.
+  plan = PlanBuilder(pool_.get())
+             .tableScan(
+                 ROW({"name"}, {VARCHAR()}),
+                 {"name not in ('alex', 'leo', 'mary', null, 'victor')"},
+                 "")
+             .planNode();
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .split(makeSplit(filePath->getPath()))
+      .assertResults(
+          "SELECT name FROM tmp where name not in ('alex', 'leo', 'mary', null, 'victor')");
+}
+
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   folly::Init init{&argc, &argv, false};
diff --git a/velox/dwio/parquet/tests/thrift/CMakeLists.txt b/velox/dwio/parquet/tests/thrift/CMakeLists.txt
index 3c3af4113645..65f89cc69357 100644
--- a/velox/dwio/parquet/tests/thrift/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/thrift/CMakeLists.txt
@@ -21,4 +21,5 @@ target_link_libraries(
   thrift
   velox_link_libs
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/dwio/parquet/tests/writer/CMakeLists.txt b/velox/dwio/parquet/tests/writer/CMakeLists.txt
index 93a0538650c7..6948dbfcf70e 100644
--- a/velox/dwio/parquet/tests/writer/CMakeLists.txt
+++ b/velox/dwio/parquet/tests/writer/CMakeLists.txt
@@ -17,35 +17,40 @@ add_executable(velox_parquet_writer_sink_test SinkTests.cpp)
 add_test(
   NAME velox_parquet_writer_sink_test
   COMMAND velox_parquet_writer_sink_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_parquet_writer_sink_test
   velox_dwio_parquet_writer
   velox_dwio_common_test_utils
   velox_vector_fuzzer
-  Boost::regex
+  velox_caching
   velox_link_libs
   Folly::folly
   ${TEST_LINK_LIBS}
   GTest::gtest
-  fmt::fmt)
+  fmt::fmt
+)
 
-add_executable(velox_parquet_writer_test ParquetWriterTest.cpp)
+add_executable(velox_parquet_writer_test ParquetWriterFieldIdTest.cpp ParquetWriterTest.cpp)
 
 add_test(
   NAME velox_parquet_writer_test
   COMMAND velox_parquet_writer_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_parquet_writer_test
+  velox_dwio_arrow_parquet_writer_test_lib
   velox_dwio_parquet_writer
   velox_dwio_parquet_reader
   velox_dwio_common_test_utils
+  velox_caching
   velox_link_libs
-  Boost::regex
   Folly::folly
   ${TEST_LINK_LIBS}
   GTest::gtest
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/dwio/parquet/tests/writer/ParquetWriterFieldIdTest.cpp b/velox/dwio/parquet/tests/writer/ParquetWriterFieldIdTest.cpp
new file mode 100644
index 000000000000..d81aac342939
--- /dev/null
+++ b/velox/dwio/parquet/tests/writer/ParquetWriterFieldIdTest.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 "velox/dwio/parquet/writer/arrow/tests/TestUtil.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/parquet/tests/ParquetTestBase.h"
+#include "velox/dwio/parquet/writer/arrow/Schema.h"
+#include "velox/dwio/parquet/writer/arrow/tests/FileReader.h"
+
+namespace {
+
+using namespace facebook::velox;
+using namespace facebook::velox::dwio::common;
+using namespace facebook::velox::parquet;
+
+class ParquetWriterFieldIdTest : public ParquetTestBase,
+                                 public ::testing::WithParamInterface<bool> {};
+
+TEST_P(ParquetWriterFieldIdTest, fieldIds) {
+  auto schema =
+      ROW({"p", "s", "a", "m"},
+          {BIGINT(),
+           ROW({"x", "y"}, {INTEGER(), VARCHAR()}),
+           ARRAY(INTEGER()),
+           MAP(VARCHAR(), INTEGER())});
+  constexpr int32_t kRows = 10;
+  auto data = makeRowVector(
+      {"p", "s", "a", "m"},
+      {makeFlatVector<int64_t>(kRows, [](auto row) { return row; }),
+       makeRowVector(
+           {"x", "y"},
+           {makeFlatVector<int32_t>(kRows, [](auto row) { return row; }),
+            makeFlatVector<std::string>(kRows, [](auto) { return "z"; })}),
+       makeArrayVectorFromJson<int32_t>(std::vector<std::string>(kRows, "[3]")),
+       makeMapVectorFromJson<std::string, int32_t>(
+           std::vector<std::string>(kRows, R"({"k": 4})"))});
+
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  if (GetParam()) {
+    // Provide Parquet field IDs aligned with the Velox schema tree.
+    // p -> 10.
+    // s -> 20, children: x -> 21, y -> 22.
+    // a -> 30, list element -> 31.
+    // m -> 40, children: key -> 41, value -> 42.
+    writerOptions.parquetFieldIds = {
+        ParquetFieldId{10, {}},
+        ParquetFieldId{20, {ParquetFieldId{21, {}}, ParquetFieldId{22, {}}}},
+        ParquetFieldId{30, {ParquetFieldId{31, {}}}},
+        ParquetFieldId{40, {ParquetFieldId{41, {}}, ParquetFieldId{42, {}}}},
+    };
+  }
+
+  auto* sinkPtr = write(data, writerOptions);
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto parquetReader = createReaderInMemory(*sinkPtr, readerOptions);
+  EXPECT_EQ(parquetReader->numberOfRows(), kRows);
+  auto veloxRowType = parquetReader->rowType();
+  EXPECT_EQ(*veloxRowType, *schema);
+
+  std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
+  auto arrowBufferReader = std::make_shared<::arrow::io::BufferReader>(
+      std::make_shared<::arrow::Buffer>(
+          reinterpret_cast<const uint8_t*>(sinkData.data()), sinkData.size()));
+
+  auto fileReader = parquet::arrow::ParquetFileReader::Open(arrowBufferReader);
+  auto metadata = fileReader->metadata();
+  auto* descr = metadata->schema();
+  auto* root = descr->group_node();
+
+  ASSERT_EQ(root->field_count(), 4);
+
+  auto exp = [&](int32_t expectedFieldId) {
+    return GetParam() ? expectedFieldId : -1;
+  };
+
+  // Top-level field IDs.
+  EXPECT_EQ(root->field(0)->field_id(), exp(10));
+  EXPECT_EQ(root->field(1)->field_id(), exp(20));
+  EXPECT_EQ(root->field(2)->field_id(), exp(30));
+  EXPECT_EQ(root->field(3)->field_id(), exp(40));
+
+  using GroupNode = parquet::arrow::schema::GroupNode;
+  auto* s = static_cast<const GroupNode*>(root->field(1).get());
+  EXPECT_EQ(s->field(0)->field_id(), exp(21));
+  EXPECT_EQ(s->field(1)->field_id(), exp(22));
+
+  auto* a = static_cast<const GroupNode*>(root->field(2).get());
+  // LIST logical group has one repeated child (the array entries); dive once
+  // more to the element.
+  auto* listEntries = a->field(0).get();
+  auto* listGroup = static_cast<const GroupNode*>(listEntries);
+  auto* element = listGroup->field(0).get();
+  EXPECT_EQ(element->field_id(), exp(31));
+
+  auto* m = static_cast<const GroupNode*>(root->field(3).get());
+  auto* keyValue = m->field(0).get();
+  auto* keyValueGroup = static_cast<const GroupNode*>(keyValue);
+  EXPECT_EQ(keyValueGroup->field(0)->field_id(), exp(41));
+  EXPECT_EQ(keyValueGroup->field(1)->field_id(), exp(42));
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    ParquetWriterFieldIdTest,
+    ParquetWriterFieldIdTest,
+    ::testing::Values(false, true));
+
+} // namespace
diff --git a/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp b/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp
index 3dc9f93990eb..8f666f6aa350 100644
--- a/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp
+++ b/velox/dwio/parquet/tests/writer/ParquetWriterTest.cpp
@@ -22,6 +22,7 @@
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConnector.h" // @manual
 #include "velox/core/QueryCtx.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/parquet/RegisterParquetWriter.h" // @manual
 #include "velox/dwio/parquet/reader/PageReader.h"
 #include "velox/dwio/parquet/tests/ParquetTestBase.h"
@@ -45,19 +46,19 @@ class ParquetWriterTest : public ParquetTestBase {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
     testutil::TestValue::enable();
     filesystems::registerLocalFileSystem();
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
-    auto hiveConnector =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(
-                kHiveConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()));
+    connector::hive::HiveConnectorFactory factory;
+    auto hiveConnector = factory.newConnector(
+        kHiveConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
     connector::registerConnector(hiveConnector);
     parquet::registerParquetWriterFactory();
   }
 
+  void TearDown() override {
+    writers_.clear();
+  }
+
   std::unique_ptr<RowReader> createRowReaderWithSchema(
       const std::unique_ptr<Reader> reader,
       const RowTypePtr& rowType) {
@@ -66,20 +67,109 @@ class ParquetWriterTest : public ParquetTestBase {
     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);
-  };
+  RowVectorPtr makeSmallintTestData(int64_t rows) {
+    auto data = makeRowVector({
+        makeFlatVector<int16_t>(rows, [](auto row) { return row + 1; }),
+    });
+    return data;
+  }
+
+  RowVectorPtr makeTimestampTestData(int64_t rows) {
+    auto data = makeRowVector({makeFlatVector<Timestamp>(
+        rows, [](auto row) { return Timestamp(row, row); })});
+    return data;
+  }
+
+  thrift::PageHeader readPageHeader(
+      MemorySink* sinkPtr,
+      int64_t offsetFromDataPage) {
+    dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+    auto reader = createReaderInMemory(*sinkPtr, readerOptions);
+
+    auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
+    std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
+
+    auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
+    auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
+
+    auto inputStream = std::make_unique<SeekableFileInputStream>(
+        std::move(file),
+        colChunkPtr.dataPageOffset() + offsetFromDataPage,
+        150,
+        *leafPool_,
+        LogType::TEST);
+    auto pageReader = std::make_unique<PageReader>(
+        std::move(inputStream),
+        *leafPool_,
+        colChunkPtr.compression(),
+        colChunkPtr.totalCompressedSize(),
+        stats);
+    return pageReader->readPageHeader();
+  }
 
   inline static const std::string kHiveConnectorId = "test-hive";
+  dwio::common::ColumnReaderStatistics stats;
+};
+
+class ArrowMemoryPool final : public ::arrow::MemoryPool {
+ public:
+  explicit ArrowMemoryPool() : allocated_(0) {}
+
+  ~ArrowMemoryPool() = default;
+
+  ::arrow::Status Allocate(int64_t size, int64_t alignment, uint8_t** out)
+      override {
+    *out = reinterpret_cast<uint8_t*>(malloc(size));
+    VELOX_CHECK_NOT_NULL(*out, "Failed to allocate memory in ArrowMemoryPool.");
+
+    allocated_ += size;
+    return ::arrow::Status::OK();
+  }
+
+  ::arrow::Status Reallocate(
+      int64_t oldSize,
+      int64_t newSize,
+      int64_t alignment,
+      uint8_t** ptr) override {
+    uint8_t* newBuffer = reinterpret_cast<uint8_t*>(realloc(*ptr, newSize));
+    VELOX_CHECK_NOT_NULL(
+        newBuffer, "Failed to reallocate memory in ArrowMemoryPool.");
+
+    *ptr = newBuffer;
+    allocated_ = allocated_ - oldSize + newSize;
+    return ::arrow::Status::OK();
+  }
+
+  void Free(uint8_t* buffer, int64_t size, int64_t alignment) override {
+    free(buffer);
+    allocated_ -= size;
+  }
+
+  int64_t bytes_allocated() const override {
+    return allocated_;
+    ;
+  }
+
+  int64_t max_memory() const override {
+    VELOX_UNSUPPORTED("ArrowMemoryPool#max_memory() unsupported");
+  }
+
+  int64_t total_bytes_allocated() const override {
+    VELOX_UNSUPPORTED("ArrowMemoryPool#total_bytes_allocated() unsupported");
+  }
+
+  int64_t num_allocations() const override {
+    VELOX_UNSUPPORTED("ArrowMemoryPool#num_allocations() unsupported");
+  }
+
+  std::string backend_name() const override {
+    return "arrow memory pool";
+  }
+
+ private:
+  int64_t allocated_;
 };
 
 std::vector<CompressionKind> params = {
@@ -91,76 +181,24 @@ std::vector<CompressionKind> params = {
 };
 
 TEST_F(ParquetWriterTest, dictionaryEncodingWithDictionaryPageSize) {
-  const auto schema = ROW({"c0"}, {SMALLINT()});
   constexpr int64_t kRows = 10'000;
-  const auto data = makeRowVector({
-      makeFlatVector<int16_t>(kRows, [](auto row) { return row + 1; }),
-  });
+  const auto data = makeSmallintTestData(kRows);
 
   // Write Parquet test data, then read and return the DataPage
   // (thrift::PageType::type) used.
   const auto testEnableDictionaryAndDictionaryPageSizeToGetPageHeader =
       [&](std::unordered_map<std::string, std::string> configFromFile,
           std::unordered_map<std::string, std::string> sessionProperties,
-          bool isFirstPageOrSecondPage) {
-        // 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();
-        parquet::WriterOptions writerOptions;
-        writerOptions.memoryPool = leafPool_.get();
-
-        auto connectorConfig = config::ConfigBase(std::move(configFromFile));
-        auto connectorSessionProperties =
-            config::ConfigBase(std::move(sessionProperties));
-
-        writerOptions.processConfigs(
-            connectorConfig, connectorSessionProperties);
-        auto writer = std::make_unique<parquet::Writer>(
-            std::move(sink), writerOptions, rootPool_, schema);
-        writer->write(data);
-        writer->close();
-
-        // Read to identify DataPage used.
-        dwio::common::ReaderOptions readerOptions{leafPool_.get()};
-        auto reader = createReaderInMemory(*sinkPtr, readerOptions);
-
-        auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
-        std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
-
-        auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
-        auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-
-        if (isFirstPageOrSecondPage) {
-          auto inputStream = std::make_unique<SeekableFileInputStream>(
-              std::move(file),
-              colChunkPtr.dataPageOffset(),
-              150,
-              *leafPool_,
-              LogType::TEST);
-          auto pageReader = std::make_unique<PageReader>(
-              std::move(inputStream),
-              *leafPool_,
-              colChunkPtr.compression(),
-              colChunkPtr.totalCompressedSize());
-          return pageReader->readPageHeader();
+          bool isFirstPage) {
+        auto* sinkPtr = write(
+            data, std::move(configFromFile), std::move(sessionProperties));
+        if (isFirstPage) {
+          return readPageHeader(sinkPtr, 0);
         }
         constexpr int64_t kFirstDataPageCompressedSize = 1291;
         constexpr int64_t kFirstDataPageHeaderSize = 48;
-        auto inputStream = std::make_unique<SeekableFileInputStream>(
-            std::move(file),
-            colChunkPtr.dataPageOffset() + kFirstDataPageCompressedSize +
-                kFirstDataPageHeaderSize,
-            150,
-            *leafPool_,
-            LogType::TEST);
-        auto pageReader = std::make_unique<PageReader>(
-            std::move(inputStream),
-            *leafPool_,
-            colChunkPtr.compression(),
-            colChunkPtr.totalCompressedSize());
-        return pageReader->readPageHeader();
+        return readPageHeader(
+            sinkPtr, kFirstDataPageCompressedSize + kFirstDataPageHeaderSize);
       };
 
   // Test default config (i.e., no explicit config)
@@ -261,58 +299,17 @@ TEST_F(ParquetWriterTest, dictionaryEncodingWithDictionaryPageSize) {
 }
 
 TEST_F(ParquetWriterTest, dictionaryEncodingOff) {
-  const auto schema = ROW({"c0"}, {SMALLINT()});
   constexpr int64_t kRows = 10'000;
-  const auto data = makeRowVector({
-      makeFlatVector<int16_t>(kRows, [](auto row) { return row + 1; }),
-  });
+  const auto data = makeSmallintTestData(kRows);
 
   // Write Parquet test data, then read and return the DataPage
   // (thrift::PageType::type) used.
   const auto testEnableDictionaryAndDictionaryPageSizeToGetPageHeader =
       [&](std::unordered_map<std::string, std::string> configFromFile,
           std::unordered_map<std::string, std::string> sessionProperties) {
-        // 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();
-        parquet::WriterOptions writerOptions;
-        writerOptions.memoryPool = leafPool_.get();
-
-        auto connectorConfig = config::ConfigBase(std::move(configFromFile));
-        auto connectorSessionProperties =
-            config::ConfigBase(std::move(sessionProperties));
-
-        writerOptions.processConfigs(
-            connectorConfig, connectorSessionProperties);
-        auto writer = std::make_unique<parquet::Writer>(
-            std::move(sink), writerOptions, rootPool_, schema);
-        writer->write(data);
-        writer->close();
-
-        // Read to identify DataPage used.
-        dwio::common::ReaderOptions readerOptions{leafPool_.get()};
-        auto reader = createReaderInMemory(*sinkPtr, readerOptions);
-
-        auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
-        std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
-
-        auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
-        auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-
-        auto inputStream = std::make_unique<SeekableFileInputStream>(
-            std::move(file),
-            colChunkPtr.dataPageOffset(),
-            150,
-            *leafPool_,
-            LogType::TEST);
-        auto pageReader = std::make_unique<PageReader>(
-            std::move(inputStream),
-            *leafPool_,
-            colChunkPtr.compression(),
-            colChunkPtr.totalCompressedSize());
-        return pageReader->readPageHeader();
+        auto* sinkPtr = write(
+            data, std::move(configFromFile), std::move(sessionProperties));
+        return readPageHeader(sinkPtr, 0);
       };
 
   // Test only dictionary off without dictionary page size configured
@@ -390,25 +387,16 @@ TEST_F(ParquetWriterTest, compression) {
       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();
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.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();
+  auto* sinkPtr = write(data, writerOptions);
 
   dwio::common::ReaderOptions readerOptions{leafPool_.get()};
   auto reader = createReaderInMemory(*sinkPtr, readerOptions);
@@ -425,61 +413,20 @@ TEST_F(ParquetWriterTest, compression) {
 
   auto rowReader = createRowReaderWithSchema(std::move(reader), schema);
   assertReadWithReaderAndExpected(schema, *rowReader, data, *leafPool_);
-};
+}
 
 TEST_F(ParquetWriterTest, testPageSizeAndBatchSizeConfiguration) {
-  const auto schema = ROW({"c0"}, {SMALLINT()});
   constexpr int64_t kRows = 10'000;
-  const auto data = makeRowVector({
-      makeFlatVector<int16_t>(kRows, [](auto row) { return row + 1; }),
-  });
+  const auto data = makeSmallintTestData(kRows);
 
   // Write Parquet test data, then read and return the DataPage
   // (thrift::PageType::type) used.
   const auto testPageSizeAndBatchSizeToGetPageHeader =
       [&](std::unordered_map<std::string, std::string> configFromFile,
           std::unordered_map<std::string, std::string> sessionProperties) {
-        // 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();
-        parquet::WriterOptions writerOptions;
-        writerOptions.memoryPool = leafPool_.get();
-
-        auto connectorConfig = config::ConfigBase(std::move(configFromFile));
-        auto connectorSessionProperties =
-            config::ConfigBase(std::move(sessionProperties));
-
-        writerOptions.processConfigs(
-            connectorConfig, connectorSessionProperties);
-        auto writer = std::make_unique<parquet::Writer>(
-            std::move(sink), writerOptions, rootPool_, schema);
-        writer->write(data);
-        writer->close();
-
-        // Read to identify DataPage used.
-        dwio::common::ReaderOptions readerOptions{leafPool_.get()};
-        auto reader = createReaderInMemory(*sinkPtr, readerOptions);
-
-        auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
-        std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
-
-        auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
-        auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-
-        auto inputStream = std::make_unique<SeekableFileInputStream>(
-            std::move(file),
-            colChunkPtr.dataPageOffset(),
-            150,
-            *leafPool_,
-            LogType::TEST);
-        auto pageReader = std::make_unique<PageReader>(
-            std::move(inputStream),
-            *leafPool_,
-            colChunkPtr.compression(),
-            colChunkPtr.totalCompressedSize());
-        return pageReader->readPageHeader();
+        auto* sinkPtr = write(
+            data, std::move(configFromFile), std::move(sessionProperties));
+        return readPageHeader(sinkPtr, 0);
       };
 
   // Test default config (i.e., no explicit config)
@@ -573,7 +520,6 @@ TEST_F(ParquetWriterTest, testPageSizeAndBatchSizeConfiguration) {
 }
 
 TEST_F(ParquetWriterTest, toggleDataPageVersion) {
-  auto schema = ROW({"c0"}, {INTEGER()});
   const int64_t kRows = 1;
   const auto data = makeRowVector({
       makeFlatVector<int32_t>(kRows, [](auto row) { return 987; }),
@@ -584,50 +530,9 @@ TEST_F(ParquetWriterTest, toggleDataPageVersion) {
   const auto testDataPageVersion =
       [&](std::unordered_map<std::string, std::string> configFromFile,
           std::unordered_map<std::string, std::string> sessionProperties) {
-        // 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();
-        parquet::WriterOptions writerOptions;
-        writerOptions.memoryPool = leafPool_.get();
-
-        // Simulate setting of Hive config & connector session properties, then
-        // write test data.
-        auto connectorConfig = config::ConfigBase(std::move(configFromFile));
-        auto connectorSessionProperties =
-            config::ConfigBase(std::move(sessionProperties));
-
-        writerOptions.processConfigs(
-            connectorConfig, connectorSessionProperties);
-        auto writer = std::make_unique<parquet::Writer>(
-            std::move(sink), writerOptions, rootPool_, schema);
-        writer->write(data);
-        writer->close();
-
-        // Read to identify DataPage used.
-        dwio::common::ReaderOptions readerOptions{leafPool_.get()};
-        auto reader = createReaderInMemory(*sinkPtr, readerOptions);
-
-        auto colChunkPtr = reader->fileMetaData().rowGroup(0).columnChunk(0);
-        std::string_view sinkData(sinkPtr->data(), sinkPtr->size());
-
-        auto readFile = std::make_shared<InMemoryReadFile>(sinkData);
-        auto file = std::make_shared<ReadFileInputStream>(std::move(readFile));
-
-        auto inputStream = std::make_unique<SeekableFileInputStream>(
-            std::move(file),
-            colChunkPtr.dataPageOffset(),
-            150,
-            *leafPool_,
-            LogType::TEST);
-        auto pageReader = std::make_unique<PageReader>(
-            std::move(inputStream),
-            *leafPool_,
-            colChunkPtr.compression(),
-            colChunkPtr.totalCompressedSize());
-
-        return pageReader->readPageHeader().type;
+        auto* sinkPtr = write(
+            data, std::move(configFromFile), std::move(sessionProperties));
+        return readPageHeader(sinkPtr, 0).type;
       };
 
   // Test default behavior - DataPage should be V1.
@@ -702,24 +607,16 @@ DEBUG_ONLY_TEST_F(ParquetWriterTest, unitFromWriterOptions) {
             ASSERT_EQ(tsType->timezone(), "America/Los_Angeles");
           })));
 
-  const auto data = makeRowVector({makeFlatVector<Timestamp>(
-      10'000, [](auto row) { return Timestamp(row, row); })});
+  const auto data = makeTimestampTestData(10'000);
   parquet::WriterOptions writerOptions;
-  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.memoryPool = rootPool_.get();
   writerOptions.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
   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();
-};
+  write(data, writerOptions);
+}
 
-TEST_F(ParquetWriterTest, parquetWriteTimestampTimeZoneWithDefault) {
+DEBUG_ONLY_TEST_F(ParquetWriterTest, parquetWriteTimestampTimeZoneWithDefault) {
   SCOPED_TESTVALUE_SET(
       "facebook::velox::parquet::Writer::write",
       std::function<void(const ::arrow::Schema*)>(
@@ -731,25 +628,26 @@ TEST_F(ParquetWriterTest, parquetWriteTimestampTimeZoneWithDefault) {
             ASSERT_EQ(tsType->timezone(), "");
           })));
 
-  const auto data = makeRowVector({makeFlatVector<Timestamp>(
-      10'000, [](auto row) { return Timestamp(row, row); })});
+  const auto data = makeTimestampTestData(10'000);
   parquet::WriterOptions writerOptions;
-  writerOptions.memoryPool = leafPool_.get();
+  writerOptions.memoryPool = rootPool_.get();
   writerOptions.parquetWriteTimestampUnit = TimestampPrecision::kMicroseconds;
 
-  // 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();
-};
+  write(data, writerOptions);
+}
+
+TEST_F(ParquetWriterTest, parquetWriteWithArrowMemoryPool) {
+  const auto data = makeTimestampTestData(10'000);
+  parquet::WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  writerOptions.arrowMemoryPool = std::make_shared<ArrowMemoryPool>();
+
+  write(data, writerOptions);
+}
 
 TEST_F(ParquetWriterTest, updateWriterOptionsFromHiveConfig) {
   std::unordered_map<std::string, std::string> configFromFile = {
-      {parquet::WriterOptions::kParquetSessionWriteTimestampUnit, "3"}};
+      {parquet::WriterOptions::kParquetHiveConnectorWriteTimestampUnit, "3"}};
   const config::ConfigBase connectorConfig(std::move(configFromFile));
   const config::ConfigBase connectorSessionProperties({});
 
@@ -804,6 +702,91 @@ DEBUG_ONLY_TEST_F(ParquetWriterTest, timestampUnitAndTimeZone) {
 }
 #endif
 
+TEST_F(ParquetWriterTest, dictionaryEncodedVector) {
+  const auto randomIndices = [this](vector_size_t size) {
+    BufferPtr indices =
+        AlignedBuffer::allocate<vector_size_t>(size, leafPool_.get());
+    auto rawIndices = indices->asMutable<vector_size_t>();
+    for (int32_t i = 0; i < size; i++) {
+      rawIndices[i] = folly::Random::rand32(size);
+    }
+    return indices;
+  };
+
+  const auto wrapDictionaryVectors =
+      [&](const std::vector<VectorPtr>& vectors) {
+        std::vector<VectorPtr> wrappedVectors;
+        wrappedVectors.reserve(vectors.size());
+
+        for (const auto& vector : vectors) {
+          auto wrappedVector = BaseVector::wrapInDictionary(
+              BufferPtr(nullptr),
+              randomIndices(vector->size()),
+              vector->size(),
+              vector);
+          EXPECT_EQ(
+              wrappedVector->encoding(), VectorEncoding::Simple::DICTIONARY);
+          wrappedVectors.emplace_back(wrappedVector);
+        }
+        return wrappedVectors;
+      };
+
+  // Dictionary encoded vectors with complex type.
+  const auto size = 10'000;
+  auto wrappedVectors = wrapDictionaryVectors({
+      facebook::velox::test::BatchMaker::createVector<TypeKind::MAP>(
+          MAP(VARCHAR(), INTEGER()), size, *leafPool_),
+      facebook::velox::test::BatchMaker::createVector<TypeKind::ARRAY>(
+          ARRAY(VARCHAR()), size, *leafPool_),
+      facebook::velox::test::BatchMaker::createVector<TypeKind::ROW>(
+          ROW({"c0", "c1"},
+              {BIGINT(), ROW({"id", "name"}, {INTEGER(), VARCHAR()})}),
+          size,
+          *leafPool_),
+  });
+
+  auto data = makeRowVector(wrappedVectors);
+  write(data);
+
+  // Dictionary encoded constant vector of scalar type.
+  const auto constantVector = makeConstant(static_cast<int64_t>(123'456), size);
+  const auto wrappedVector = std::make_shared<DictionaryVector<int64_t>>(
+      leafPool_.get(), nullptr, size, constantVector, randomIndices(size));
+  EXPECT_EQ(wrappedVector->encoding(), VectorEncoding::Simple::DICTIONARY);
+  VELOX_CHECK_NOT_NULL(wrappedVector->valueVector());
+  EXPECT_FALSE(wrappedVector->wrappedVector()->isFlatEncoding());
+
+  data = makeRowVector({wrappedVector});
+  write(data);
+}
+
+TEST_F(ParquetWriterTest, allNulls) {
+  auto schema = ROW({"c0"}, {INTEGER()});
+  const int64_t kRows = 4096;
+  // Create a column with all elements being null.
+  auto nulls = makeNulls(kRows, [](auto /*row*/) { return true; });
+  auto flatVector = std::make_shared<FlatVector<int32_t>>(
+      pool_.get(),
+      schema->childAt(0),
+      nulls,
+      kRows,
+      /*values=*/nullptr,
+      std::vector<BufferPtr>());
+  auto data = std::make_shared<RowVector>(
+      pool_.get(), schema, nullptr, kRows, std::vector<VectorPtr>{flatVector});
+
+  auto* sinkPtr = write(data);
+
+  dwio::common::ReaderOptions readerOptions{leafPool_.get()};
+  auto reader = createReaderInMemory(*sinkPtr, readerOptions);
+
+  ASSERT_EQ(reader->numberOfRows(), kRows);
+  ASSERT_EQ(*reader->rowType(), *schema);
+
+  auto rowReader = createRowReaderWithSchema(std::move(reader), schema);
+  assertReadWithReaderAndExpected(schema, *rowReader, data, *leafPool_);
+}
+
 } // namespace
 
 int main(int argc, char** argv) {
diff --git a/velox/dwio/parquet/thrift/CMakeLists.txt b/velox/dwio/parquet/thrift/CMakeLists.txt
index cb0b6ea91881..ee6fe26e8c80 100644
--- a/velox/dwio/parquet/thrift/CMakeLists.txt
+++ b/velox/dwio/parquet/thrift/CMakeLists.txt
@@ -13,9 +13,4 @@
 # limitations under the License.
 
 velox_add_library(velox_dwio_parquet_thrift ParquetThriftTypes.cpp)
-velox_link_libraries(
-  velox_dwio_parquet_thrift
-  arrow
-  thrift
-  Boost::headers
-  fmt::fmt)
+velox_link_libraries(velox_dwio_parquet_thrift arrow thrift Boost::headers fmt::fmt)
diff --git a/velox/dwio/parquet/writer/CMakeLists.txt b/velox/dwio/parquet/writer/CMakeLists.txt
index 6d2e42434c4b..b2bc9c96703a 100644
--- a/velox/dwio/parquet/writer/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/CMakeLists.txt
@@ -22,5 +22,7 @@ velox_link_libraries(
   velox_dwio_arrow_parquet_writer_util_lib
   velox_dwio_common
   velox_arrow_bridge
+  velox_exec
   arrow
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/dwio/parquet/writer/Writer.cpp b/velox/dwio/parquet/writer/Writer.cpp
index 895f88a57ae9..053ee290c39a 100644
--- a/velox/dwio/parquet/writer/Writer.cpp
+++ b/velox/dwio/parquet/writer/Writer.cpp
@@ -22,6 +22,7 @@
 #include "velox/common/config/Config.h"
 #include "velox/common/testutil/TestValue.h"
 #include "velox/core/QueryConfig.h"
+#include "velox/dwio/parquet/writer/arrow/ArrowSchema.h"
 #include "velox/dwio/parquet/writer/arrow/Properties.h"
 #include "velox/dwio/parquet/writer/arrow/Writer.h"
 #include "velox/exec/MemoryReclaimer.h"
@@ -164,12 +165,17 @@ std::shared_ptr<WriterProperties> getArrowParquetWriterOptions(
     properties =
         properties->data_page_version(arrow::ParquetDataPageVersion::V1);
   }
+  if (options.createdBy.has_value()) {
+    properties = properties->created_by(options.createdBy.value());
+  }
   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.");
+void validateSchemaRecursive(
+    const RowTypePtr& schema,
+    const std::vector<ParquetFieldId>& parquetFieldIds) {
+  // Check the schema's field names are not empty and unique.
+  VELOX_USER_CHECK_NOT_NULL(schema, "Schema must not be empty.");
   const auto& fieldNames = schema->names();
 
   folly::F14FastSet<std::string> uniqueNames;
@@ -182,55 +188,100 @@ void validateSchemaRecursive(const RowTypePtr& schema) {
         name);
   }
 
+  if (!parquetFieldIds.empty()) {
+    VELOX_USER_CHECK_EQ(parquetFieldIds.size(), schema->size());
+  }
+
   for (auto i = 0; i < schema->size(); ++i) {
-    if (auto childSchema =
-            std::dynamic_pointer_cast<const RowType>(schema->childAt(i))) {
-      validateSchemaRecursive(childSchema);
+    const auto& childType = schema->childAt(i);
+    const auto& childFieldIds =
+        parquetFieldIds.empty() ? parquetFieldIds : parquetFieldIds[i].children;
+
+    if (childType->isRow()) {
+      validateSchemaRecursive(
+          std::dynamic_pointer_cast<const RowType>(childType), childFieldIds);
+    } else if (childType->isArray()) {
+      if (!parquetFieldIds.empty()) {
+        VELOX_USER_CHECK_EQ(parquetFieldIds[i].children.size(), 1);
+      }
+      const auto& elementType = childType->asArray().elementType();
+      if (elementType->isRow()) {
+        validateSchemaRecursive(
+            std::dynamic_pointer_cast<const RowType>(elementType),
+            childFieldIds.empty() ? childFieldIds : childFieldIds[0].children);
+      }
+    } else if (childType->isMap()) {
+      if (!parquetFieldIds.empty()) {
+        VELOX_USER_CHECK_EQ(parquetFieldIds[i].children.size(), 2);
+      }
+      const auto& mapType = childType->asMap();
+      if (mapType.keyType()->isRow()) {
+        validateSchemaRecursive(
+            std::dynamic_pointer_cast<const RowType>(mapType.keyType()),
+            childFieldIds.empty() ? childFieldIds : childFieldIds[0].children);
+      }
+      if (mapType.valueType()->isRow()) {
+        validateSchemaRecursive(
+            std::dynamic_pointer_cast<const RowType>(mapType.valueType()),
+            childFieldIds.empty() ? childFieldIds : childFieldIds[1].children);
+      }
     }
   }
 }
 
-std::shared_ptr<::arrow::Field> updateFieldNameRecursive(
+std::shared_ptr<::arrow::Field> updateFieldNameAndIdRecursive(
     const std::shared_ptr<::arrow::Field>& field,
     const Type& type,
+    const ParquetFieldId* fieldId,
     const std::string& name = "") {
+  auto newField = name.empty() ? field : field->WithName(name);
+
+  if (fieldId) {
+    newField =
+        newField->WithMetadata(arrow::arrow::fieldIdMetadata(fieldId->fieldId));
+  }
+
   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();
+    VELOX_CHECK(!fieldId || childrenSize <= fieldId->children.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)));
+    for (auto i = 0; i < childrenSize; ++i) {
+      const auto* childSetting = fieldId ? &fieldId->children.at(i) : nullptr;
+      newFields.push_back(updateFieldNameAndIdRecursive(
+          structType->fields()[i],
+          *rowType.childAt(i),
+          childSetting,
+          rowType.nameOf(i)));
     }
-    return newField->WithType(::arrow::struct_(newFields));
+    newField = 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)));
+    const auto* childSetting = fieldId ? &fieldId->children.at(0) : nullptr;
+    auto updatedElementField =
+        updateFieldNameAndIdRecursive(elementField, *elementType, childSetting);
+    newField = newField->WithType(::arrow::list(updatedElementField));
   } 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;
+    const auto* keySetting = fieldId ? &fieldId->children.at(0) : nullptr;
+    const auto* valueSetting = fieldId ? &fieldId->children.at(1) : nullptr;
+    auto newKeyField = updateFieldNameAndIdRecursive(
+        arrowMapType->key_field(), *mapType.keyType(), keySetting);
+    auto newValueField = updateFieldNameAndIdRecursive(
+        arrowMapType->item_field(), *mapType.valueType(), valueSetting);
+    newField = newField->WithType(
+        std::make_shared<::arrow::MapType>(newKeyField, newValueField));
   }
+
+  return newField;
 }
 
 std::optional<TimestampPrecision> getTimestampUnit(
@@ -246,6 +297,17 @@ std::optional<TimestampPrecision> getTimestampUnit(
   return std::nullopt;
 }
 
+// Converts a string to TimestampPrecision. Accepts numeric values "3" (milli),
+// "6" (micro), or "9" (nano).
+TimestampPrecision stringToTimestampPrecision(const std::string& value) {
+  auto unit = folly::to<uint8_t>(value);
+  VELOX_CHECK(
+      unit == 3 /*milli*/ || unit == 6 /*micro*/ || unit == 9 /*nano*/,
+      "Invalid timestamp unit: {}",
+      unit);
+  return static_cast<TimestampPrecision>(unit);
+}
+
 std::optional<std::string> getTimestampTimeZone(
     const config::ConfigBase& config,
     const char* configKey) {
@@ -306,6 +368,15 @@ std::optional<int64_t> getParquetBatchSize(
   return std::nullopt;
 }
 
+std::optional<std::string> getParquetCreatedBy(
+    const config::ConfigBase& config,
+    const char* configKey) {
+  if (config.get<std::string>(configKey).has_value()) {
+    return config.get<std::string>(configKey).value();
+  }
+  return std::nullopt;
+}
+
 } // namespace
 
 Writer::Writer(
@@ -315,13 +386,14 @@ Writer::Writer(
     RowTypePtr schema)
     : pool_(std::move(pool)),
       generalPool_{pool_->addLeafChild(".general")},
-      stream_(std::make_shared<ArrowDataBufferSink>(
-          std::move(sink),
-          *generalPool_,
-          options.bufferGrowRatio)),
+      stream_(
+          std::make_shared<ArrowDataBufferSink>(
+              std::move(sink),
+              *generalPool_,
+              options.bufferGrowRatio)),
       arrowContext_(std::make_shared<ArrowContext>()),
       schema_(std::move(schema)) {
-  validateSchemaRecursive(schema_);
+  validateSchemaRecursive(schema_, options.parquetFieldIds);
 
   if (options.flushPolicyFactory) {
     castUniquePointer(options.flushPolicyFactory(), flushPolicy_);
@@ -338,6 +410,8 @@ Writer::Writer(
       getArrowParquetWriterOptions(options, flushPolicy_);
   setMemoryReclaimers();
   writeInt96AsTimestamp_ = options.writeInt96AsTimestamp;
+  arrowMemoryPool_ = options.arrowMemoryPool;
+  parquetFieldIds_ = std::move(options.parquetFieldIds);
 }
 
 Writer::Writer(
@@ -347,9 +421,10 @@ Writer::Writer(
     : Writer{
           std::move(sink),
           options,
-          options.memoryPool->addAggregateChild(fmt::format(
-              "writer_node_{}",
-              folly::to<std::string>(folly::Random::rand64()))),
+          options.memoryPool->addAggregateChild(
+              fmt::format(
+                  "writer_node_{}",
+                  folly::to<std::string>(folly::Random::rand64()))),
           std::move(schema)} {}
 
 void Writer::flush() {
@@ -364,7 +439,7 @@ void Writer::flush() {
           arrowContext_->writer,
           FileWriter::Open(
               *arrowContext_->schema.get(),
-              ::arrow::default_memory_pool(),
+              arrowMemoryPool_.get(),
               stream_,
               arrowContext_->properties,
               arrowProperties));
@@ -415,10 +490,15 @@ void Writer::write(const VectorPtr& data) {
       data->type()->equivalent(*schema_),
       "The file schema type should be equal with the input rowvector type.");
 
+  VectorPtr exportData = data;
+  if (needFlatten(exportData)) {
+    BaseVector::flattenVector(exportData);
+  }
+
   ArrowArray array;
   ArrowSchema schema;
-  exportToArrow(data, array, generalPool_.get(), options_);
-  exportToArrow(data, schema, options_);
+  exportToArrow(exportData, array, generalPool_.get(), options_);
+  exportToArrow(exportData, schema, options_);
 
   // Convert the arrow schema to Schema and then update the column names based
   // on schema_.
@@ -427,9 +507,15 @@ void Writer::write(const VectorPtr& data) {
       "facebook::velox::parquet::Writer::write", arrowSchema.get());
   std::vector<std::shared_ptr<::arrow::Field>> newFields;
   auto childSize = schema_->size();
+  if (!parquetFieldIds_.empty()) {
+    VELOX_CHECK(childSize == parquetFieldIds_.size());
+  }
   for (auto i = 0; i < childSize; i++) {
-    newFields.push_back(updateFieldNameRecursive(
-        arrowSchema->fields()[i], *schema_->childAt(i), schema_->nameOf(i)));
+    newFields.push_back(updateFieldNameAndIdRecursive(
+        arrowSchema->fields()[i],
+        *schema_->childAt(i),
+        !parquetFieldIds_.empty() ? &parquetFieldIds_.at(i) : nullptr,
+        schema_->nameOf(i)));
   }
 
   PARQUET_ASSIGN_OR_THROW(
@@ -502,6 +588,22 @@ void Writer::setMemoryReclaimers() {
   generalPool_->setReclaimer(exec::MemoryReclaimer::create());
 }
 
+bool Writer::needFlatten(const VectorPtr& data) const {
+  auto rowVector = std::dynamic_pointer_cast<RowVector>(data);
+  VELOX_CHECK_NOT_NULL(
+      rowVector, "Arrow export expects a RowVector as input data.");
+
+  const auto& children = rowVector->children();
+  return std::any_of(children.begin(), children.end(), [](const auto& child) {
+    bool isNestedWrapped =
+        (child->encoding() == VectorEncoding::Simple::DICTIONARY ||
+         child->encoding() == VectorEncoding::Simple::CONSTANT) &&
+        child->valueVector() && !child->wrappedVector()->isFlatEncoding();
+    bool isComplex = !child->isScalar();
+    return isNestedWrapped || isComplex;
+  });
+}
+
 std::unique_ptr<dwio::common::Writer> ParquetWriterFactory::createWriter(
     std::unique_ptr<dwio::common::FileSink> sink,
     const std::shared_ptr<dwio::common::WriterOptions>& options) {
@@ -526,11 +628,30 @@ void WriterOptions::processConfigs(
   VELOX_CHECK_NOT_NULL(
       parquetWriterOptions, "Expected a Parquet WriterOptions object.");
 
+  // Check serdeParameters for timestamp settings first (highest priority).
+  auto serdeTimestampUnitIt = serdeParameters.find(kParquetSerdeTimestampUnit);
+  if (serdeTimestampUnitIt != serdeParameters.end()) {
+    parquetWriteTimestampUnit =
+        stringToTimestampPrecision(serdeTimestampUnitIt->second);
+  }
+
+  auto serdeTimestampTimezoneIt =
+      serdeParameters.find(kParquetSerdeTimestampTimezone);
+  if (serdeTimestampTimezoneIt != serdeParameters.end()) {
+    // Empty string means no timezone conversion (nullopt).
+    if (serdeTimestampTimezoneIt->second.empty()) {
+      parquetWriteTimestampTimeZone = std::nullopt;
+    } else {
+      parquetWriteTimestampTimeZone = serdeTimestampTimezoneIt->second;
+    }
+  }
+
   if (!parquetWriteTimestampUnit) {
     parquetWriteTimestampUnit =
         getTimestampUnit(session, kParquetSessionWriteTimestampUnit).has_value()
         ? getTimestampUnit(session, kParquetSessionWriteTimestampUnit)
-        : getTimestampUnit(connectorConfig, kParquetSessionWriteTimestampUnit);
+        : getTimestampUnit(
+              connectorConfig, kParquetHiveConnectorWriteTimestampUnit);
   }
   if (!parquetWriteTimestampTimeZone) {
     parquetWriteTimestampTimeZone = parquetWriterOptions->sessionTimezoneName;
@@ -578,6 +699,11 @@ void WriterOptions::processConfigs(
         : getParquetBatchSize(
               connectorConfig, kParquetHiveConnectorWriteBatchSize);
   }
+
+  if (!createdBy) {
+    createdBy =
+        getParquetCreatedBy(connectorConfig, kParquetHiveConnectorCreatedBy);
+  }
 }
 
 } // namespace facebook::velox::parquet
diff --git a/velox/dwio/parquet/writer/Writer.h b/velox/dwio/parquet/writer/Writer.h
index 460f01a7f240..922e56110820 100644
--- a/velox/dwio/parquet/writer/Writer.h
+++ b/velox/dwio/parquet/writer/Writer.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "arrow/memory_pool.h"
 #include "velox/common/compression/Compression.h"
 #include "velox/common/config/Config.h"
 #include "velox/dwio/common/DataBuffer.h"
@@ -87,6 +88,14 @@ class LambdaFlushPolicy : public DefaultFlushPolicy {
   std::function<bool()> lambda_;
 };
 
+/// Parquet field IDs during write operations. Each ID must be unique positive
+/// number, do not need to be sequential.
+/// Used to explicitly control field ID assignment in the Parquet schema.
+struct ParquetFieldId {
+  int32_t fieldId;
+  std::vector<ParquetFieldId> children;
+};
+
 struct WriterOptions : public dwio::common::WriterOptions {
   // Growth ratio passed to ArrowDataBufferSink. The default value is a
   // heuristic borrowed from
@@ -111,6 +120,15 @@ struct WriterOptions : public dwio::common::WriterOptions {
   std::optional<int64_t> dictionaryPageSizeLimit;
   std::optional<bool> enableDictionary;
   std::optional<bool> useParquetDataPageV2;
+  std::optional<std::string> createdBy;
+
+  std::shared_ptr<arrow::MemoryPool> arrowMemoryPool;
+
+  /// Optional field IDs to assign to columns in the Parquet schema.
+  /// If provided, the writer will use these IDs for the schema fields.
+  /// If not provided, the field_id will be -1.
+  /// The structure should match the schema hierarchy with nested children.
+  std::vector<ParquetFieldId> parquetFieldIds;
 
   // Parsing session and hive configs.
 
@@ -140,6 +158,17 @@ struct WriterOptions : public dwio::common::WriterOptions {
       "hive.parquet.writer.batch_size";
   static constexpr const char* kParquetHiveConnectorWriteBatchSize =
       "hive.parquet.writer.batch-size";
+  static constexpr const char* kParquetHiveConnectorCreatedBy =
+      "hive.parquet.writer.created-by";
+
+  // Serde parameter keys for timestamp settings. These can be set via
+  // serdeParameters map to override the default timestamp behavior.
+  // The timezone key accepts a timezone string or empty string to disable
+  // timezone conversion.
+  static constexpr const char* kParquetSerdeTimestampUnit =
+      "parquet.writer.timestamp.unit";
+  static constexpr const char* kParquetSerdeTimestampTimezone =
+      "parquet.writer.timestamp.timezone";
 
   // Process hive connector and session configs.
   void processConfigs(
@@ -193,15 +222,23 @@ class Writer : public dwio::common::Writer {
   // Sets the memory reclaimers for all the memory pools used by this writer.
   void setMemoryReclaimers();
 
+  // Checks if the input data contains a nested wrapped vector or complex
+  // vector. If so, flatten the input to make it compatible with
+  // 'exportFlattenedVector' in Arrow export.
+  bool needFlatten(const VectorPtr& data) const;
+
   // Pool for 'stream_'.
   std::shared_ptr<memory::MemoryPool> pool_;
   std::shared_ptr<memory::MemoryPool> generalPool_;
+  std::shared_ptr<arrow::MemoryPool> arrowMemoryPool_;
 
   // Temporary Arrow stream for capturing the output.
   std::shared_ptr<ArrowDataBufferSink> stream_;
 
   std::shared_ptr<ArrowContext> arrowContext_;
 
+  std::vector<ParquetFieldId> parquetFieldIds_;
+
   std::unique_ptr<DefaultFlushPolicy> flushPolicy_;
 
   const RowTypePtr schema_;
diff --git a/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp b/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
index de5a2382198a..d4a7193a6646 100644
--- a/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
+++ b/velox/dwio/parquet/writer/arrow/ArrowSchema.cpp
@@ -346,14 +346,6 @@ static Status GetTimestampMetadata(
 
 static constexpr char FIELD_ID_KEY[] = "PARQUET:field_id";
 
-std::shared_ptr<::arrow::KeyValueMetadata> FieldIdMetadata(int field_id) {
-  if (field_id >= 0) {
-    return ::arrow::key_value_metadata({FIELD_ID_KEY}, {ToChars(field_id)});
-  } else {
-    return nullptr;
-  }
-}
-
 int FieldIdFromMetadata(
     const std::shared_ptr<const ::arrow::KeyValueMetadata>& metadata) {
   if (!metadata) {
@@ -676,7 +668,7 @@ Status GroupToStruct(
       node.name(),
       struct_type,
       node.is_optional(),
-      FieldIdMetadata(node.field_id()));
+      fieldIdMetadata(node.field_id()));
   out->level_info = current_levels;
   return Status::OK();
 }
@@ -761,14 +753,14 @@ Status MapToSchemaField(
       group.name(),
       ::arrow::struct_({key_field->field, value_field->field}),
       /*nullable=*/false,
-      FieldIdMetadata(key_value.field_id()));
+      fieldIdMetadata(key_value.field_id()));
   key_value_field->level_info = current_levels;
 
   out->field = ::arrow::field(
       group.name(),
       std::make_shared<::arrow::MapType>(key_value_field->field),
       group.is_optional(),
-      FieldIdMetadata(group.field_id()));
+      fieldIdMetadata(group.field_id()));
   out->level_info = current_levels;
   // At this point current levels contains the def level for this list,
   // we need to reset to the prior parent.
@@ -854,7 +846,7 @@ Status ListToSchemaField(
         list_node.name(),
         type,
         /*nullable=*/false,
-        FieldIdMetadata(list_node.field_id()));
+        fieldIdMetadata(list_node.field_id()));
     RETURN_NOT_OK(PopulateLeaf(
         column_index, item_field, current_levels, ctx, out, child_field));
   }
@@ -862,7 +854,7 @@ Status ListToSchemaField(
       group.name(),
       ::arrow::list(child_field->field),
       group.is_optional(),
-      FieldIdMetadata(group.field_id()));
+      fieldIdMetadata(group.field_id()));
   out->level_info = current_levels;
   // At this point current levels contains the def level for this list,
   // we need to reset to the prior parent.
@@ -898,7 +890,7 @@ Status GroupToSchemaField(
         node.name(),
         ::arrow::list(out->children[0].field),
         /*nullable=*/false,
-        FieldIdMetadata(node.field_id()));
+        fieldIdMetadata(node.field_id()));
 
     ctx->LinkParent(&out->children[0], out);
     out->level_info = current_levels;
@@ -961,7 +953,7 @@ Status NodeToSchemaField(
           node.name(),
           ::arrow::list(child_field),
           /*nullable=*/false,
-          FieldIdMetadata(node.field_id()));
+          fieldIdMetadata(node.field_id()));
       out->level_info = current_levels;
       // At this point current_levels has consider this list the ancestor so
       // restore the actual ancestor.
@@ -976,7 +968,7 @@ Status NodeToSchemaField(
               node.name(),
               type,
               node.is_optional(),
-              FieldIdMetadata(node.field_id())),
+              fieldIdMetadata(node.field_id())),
           current_levels,
           ctx,
           parent,
@@ -1155,8 +1147,9 @@ Result<bool> ApplyOriginalStorageMetadata(
     // so no need to recurse on value types.
     const auto& dict_origin_type =
         checked_cast<const ::arrow::DictionaryType&>(*origin_type);
-    inferred->field = inferred->field->WithType(::arrow::dictionary(
-        ::arrow::int32(), inferred_type, dict_origin_type.ordered()));
+    inferred->field = inferred->field->WithType(
+        ::arrow::dictionary(
+            ::arrow::int32(), inferred_type, dict_origin_type.ordered()));
     modified = true;
   }
 
@@ -1222,6 +1215,14 @@ Result<bool> ApplyOriginalMetadata(
 
 } // namespace
 
+std::shared_ptr<::arrow::KeyValueMetadata> fieldIdMetadata(int field_id) {
+  if (field_id >= 0) {
+    return ::arrow::key_value_metadata({FIELD_ID_KEY}, {ToChars(field_id)});
+  } else {
+    return nullptr;
+  }
+}
+
 Status FieldToNode(
     const std::shared_ptr<Field>& field,
     const WriterProperties& properties,
diff --git a/velox/dwio/parquet/writer/arrow/ArrowSchema.h b/velox/dwio/parquet/writer/arrow/ArrowSchema.h
index 8302bc1cdb19..394e51d339fe 100644
--- a/velox/dwio/parquet/writer/arrow/ArrowSchema.h
+++ b/velox/dwio/parquet/writer/arrow/ArrowSchema.h
@@ -195,5 +195,7 @@ struct PARQUET_EXPORT SchemaManifest {
   }
 };
 
+std::shared_ptr<::arrow::KeyValueMetadata> fieldIdMetadata(int32_t field_id);
+
 } // namespace arrow
 } // namespace facebook::velox::parquet::arrow
diff --git a/velox/dwio/parquet/writer/arrow/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/CMakeLists.txt
index fb0e4a4bb7df..b70c5f25e9b6 100644
--- a/velox/dwio/parquet/writer/arrow/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/CMakeLists.txt
@@ -38,7 +38,8 @@ velox_add_library(
   Schema.cpp
   Statistics.cpp
   Types.cpp
-  Writer.cpp)
+  Writer.cpp
+)
 
 velox_link_libraries(
   velox_dwio_arrow_parquet_writer_lib
@@ -48,4 +49,5 @@ velox_link_libraries(
   velox_dwio_common
   velox_arrow_bridge
   arrow
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp b/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
index 55825c5957ce..320b1bc03786 100644
--- a/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
+++ b/velox/dwio/parquet/writer/arrow/ColumnWriter.cpp
@@ -628,12 +628,13 @@ class SerializedPageWriter : public PageWriter {
   void UpdateEncryption(int8_t module_type) {
     switch (module_type) {
       case encryption::kColumnMetaData: {
-        meta_encryptor_->UpdateAad(encryption::CreateModuleAad(
-            meta_encryptor_->file_aad(),
-            module_type,
-            row_group_ordinal_,
-            column_ordinal_,
-            kNonPageOrdinal));
+        meta_encryptor_->UpdateAad(
+            encryption::CreateModuleAad(
+                meta_encryptor_->file_aad(),
+                module_type,
+                row_group_ordinal_,
+                column_ordinal_,
+                kNonPageOrdinal));
         break;
       }
       case encryption::kDataPage: {
@@ -647,21 +648,23 @@ class SerializedPageWriter : public PageWriter {
         break;
       }
       case encryption::kDictionaryPageHeader: {
-        meta_encryptor_->UpdateAad(encryption::CreateModuleAad(
-            meta_encryptor_->file_aad(),
-            module_type,
-            row_group_ordinal_,
-            column_ordinal_,
-            kNonPageOrdinal));
+        meta_encryptor_->UpdateAad(
+            encryption::CreateModuleAad(
+                meta_encryptor_->file_aad(),
+                module_type,
+                row_group_ordinal_,
+                column_ordinal_,
+                kNonPageOrdinal));
         break;
       }
       case encryption::kDictionaryPage: {
-        data_encryptor_->UpdateAad(encryption::CreateModuleAad(
-            data_encryptor_->file_aad(),
-            module_type,
-            row_group_ordinal_,
-            column_ordinal_,
-            kNonPageOrdinal));
+        data_encryptor_->UpdateAad(
+            encryption::CreateModuleAad(
+                data_encryptor_->file_aad(),
+                module_type,
+                row_group_ordinal_,
+                column_ordinal_,
+                kNonPageOrdinal));
         break;
       }
       default:
@@ -1575,7 +1578,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl,
             batch_num_values,
             batch_num_spaced_values,
             bits_buffer_->data(),
-            /*offset=*/0,
+            /*valid_bits_offset=*/0,
             /*num_levels=*/batch_size,
             null_count);
       } else {
@@ -1867,8 +1870,12 @@ class TypedColumnWriterImpl : public ColumnWriterImpl,
     if (array->data()->offset > 0) {
       RETURN_NOT_OK(util::VisitArrayInline(*array, &slicer, &buffers[1]));
     }
-    return ::arrow::MakeArray(std::make_shared<ArrayData>(
-        array->type(), array->length(), std::move(buffers), new_null_count));
+    return ::arrow::MakeArray(
+        std::make_shared<ArrayData>(
+            array->type(),
+            array->length(),
+            std::move(buffers),
+            new_null_count));
   }
 
   void WriteLevelsSpaced(
diff --git a/velox/dwio/parquet/writer/arrow/Encoding.cpp b/velox/dwio/parquet/writer/arrow/Encoding.cpp
index 14125875e389..f4a5990e5f4b 100644
--- a/velox/dwio/parquet/writer/arrow/Encoding.cpp
+++ b/velox/dwio/parquet/writer/arrow/Encoding.cpp
@@ -1315,7 +1315,7 @@ int PlainBooleanDecoder::DecodeArrow(
       null_count,
       [&]() {
         bool value;
-        ARROW_IGNORE_EXPR(bit_reader_->GetValue(1, &value));
+        ((void)(bit_reader_->GetValue(1, &value)));
         builder->UnsafeAppend(value);
       },
       [&]() { builder->UnsafeAppendNull(); });
@@ -1378,8 +1378,9 @@ struct ArrowBinaryHelper<ByteArrayType> {
   Status Prepare(std::optional<int64_t> estimated_data_length = {}) {
     RETURN_NOT_OK(acc_->builder->Reserve(entries_remaining_));
     if (estimated_data_length.has_value()) {
-      RETURN_NOT_OK(acc_->builder->ReserveData(std::min<int64_t>(
-          *estimated_data_length, ::arrow::kBinaryMemoryLimit)));
+      RETURN_NOT_OK(acc_->builder->ReserveData(
+          std::min<int64_t>(
+              *estimated_data_length, ::arrow::kBinaryMemoryLimit)));
     }
     return Status::OK();
   }
@@ -1392,8 +1393,9 @@ struct ArrowBinaryHelper<ByteArrayType> {
       RETURN_NOT_OK(PushChunk());
       RETURN_NOT_OK(acc_->builder->Reserve(entries_remaining_));
       if (estimated_remaining_data_length.has_value()) {
-        RETURN_NOT_OK(acc_->builder->ReserveData(std::min<int64_t>(
-            *estimated_remaining_data_length, chunk_space_remaining_)));
+        RETURN_NOT_OK(acc_->builder->ReserveData(
+            std::min<int64_t>(
+                *estimated_remaining_data_length, chunk_space_remaining_)));
       }
     }
     return Status::OK();
@@ -1737,7 +1739,7 @@ class DictDecoderImpl : public DecoderImpl, virtual public DictDecoder<Type> {
     num_values_ = num_values;
     if (len == 0) {
       // Initialize dummy decoder to avoid crashes later on
-      idx_decoder_ = RleDecoder(data, len, /*bit_width=*/1);
+      idx_decoder_ = RleDecoder(data, len, /*bitWidth=*/1);
       return;
     }
     uint8_t bit_width = *data;
@@ -3330,13 +3332,14 @@ class RleBooleanEncoder final : public EncoderImpl,
         buffered_append_values_.push_back(boolean_array.Value(i));
       }
     } else {
-      PARQUET_THROW_NOT_OK(::arrow::VisitArraySpanInline<::arrow::BooleanType>(
-          *boolean_array.data(),
-          [&](bool value) {
-            buffered_append_values_.push_back(value);
-            return Status::OK();
-          },
-          []() { return Status::OK(); }));
+      PARQUET_THROW_NOT_OK(
+          ::arrow::VisitArraySpanInline<::arrow::BooleanType>(
+              *boolean_array.data(),
+              [&](bool value) {
+                buffered_append_values_.push_back(value);
+                return Status::OK();
+              },
+              []() { return Status::OK(); }));
     }
   }
 
diff --git a/velox/dwio/parquet/writer/arrow/Encryption.h b/velox/dwio/parquet/writer/arrow/Encryption.h
index df310589a433..82fd6f104083 100644
--- a/velox/dwio/parquet/writer/arrow/Encryption.h
+++ b/velox/dwio/parquet/writer/arrow/Encryption.h
@@ -300,8 +300,9 @@ class PARQUET_EXPORT FileDecryptionProperties {
     /// invocation of the retriever callback.
     /// If an explicit key is available for a footer or a column,
     /// its key metadata will be ignored.
-    Builder* column_keys(const ColumnPathToDecryptionPropertiesMap&
-                             column_decryption_properties);
+    Builder* column_keys(
+        const ColumnPathToDecryptionPropertiesMap&
+            column_decryption_properties);
 
     /// Set a key retriever callback. Its also possible to
     /// set explicit footer or column keys on this file property object.
diff --git a/velox/dwio/parquet/writer/arrow/Exception.h b/velox/dwio/parquet/writer/arrow/Exception.h
index 927df3407464..b71cfc926aba 100644
--- a/velox/dwio/parquet/writer/arrow/Exception.h
+++ b/velox/dwio/parquet/writer/arrow/Exception.h
@@ -154,9 +154,10 @@ class ParquetInvalidOrCorruptedFileException : public ParquetStatusException {
           int>::type = 0,
       typename... Args>
   explicit ParquetInvalidOrCorruptedFileException(Arg arg, Args&&... args)
-      : ParquetStatusException(::arrow::Status::Invalid(
-            std::forward<Arg>(arg),
-            std::forward<Args>(args)...)) {}
+      : ParquetStatusException(
+            ::arrow::Status::Invalid(
+                std::forward<Arg>(arg),
+                std::forward<Args>(args)...)) {}
 };
 
 template <typename StatusReturnBlock>
diff --git a/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.cpp b/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.cpp
index 6192156c7b27..cf02fa99c679 100644
--- a/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/FileEncryptorInternal.cpp
@@ -172,8 +172,9 @@ encryption::AesEncryptor* InternalFileEncryptor::GetMetaAesEncryptor(
   int key_len = static_cast<int>(key_size);
   int index = MapKeyLenToEncryptorArrayIndex(key_len);
   if (meta_encryptor_[index] == nullptr) {
-    meta_encryptor_[index].reset(encryption::AesEncryptor::Make(
-        algorithm, key_len, true, &all_encryptors_));
+    meta_encryptor_[index].reset(
+        encryption::AesEncryptor::Make(
+            algorithm, key_len, true, &all_encryptors_));
   }
   return meta_encryptor_[index].get();
 }
@@ -184,8 +185,9 @@ encryption::AesEncryptor* InternalFileEncryptor::GetDataAesEncryptor(
   int key_len = static_cast<int>(key_size);
   int index = MapKeyLenToEncryptorArrayIndex(key_len);
   if (data_encryptor_[index] == nullptr) {
-    data_encryptor_[index].reset(encryption::AesEncryptor::Make(
-        algorithm, key_len, false, &all_encryptors_));
+    data_encryptor_[index].reset(
+        encryption::AesEncryptor::Make(
+            algorithm, key_len, false, &all_encryptors_));
   }
   return data_encryptor_[index].get();
 }
diff --git a/velox/dwio/parquet/writer/arrow/FileWriter.cpp b/velox/dwio/parquet/writer/arrow/FileWriter.cpp
index ea89c4838eba..1123db370a09 100644
--- a/velox/dwio/parquet/writer/arrow/FileWriter.cpp
+++ b/velox/dwio/parquet/writer/arrow/FileWriter.cpp
@@ -492,8 +492,9 @@ class FileSerializer : public ParquetFileWriter::Contents {
     return AppendRowGroup(true);
   }
 
-  void AddKeyValueMetadata(const std::shared_ptr<const KeyValueMetadata>&
-                               key_value_metadata) override {
+  void AddKeyValueMetadata(
+      const std::shared_ptr<const KeyValueMetadata>& key_value_metadata)
+      override {
     if (key_value_metadata_ == nullptr) {
       key_value_metadata_ = key_value_metadata;
     } else if (key_value_metadata != nullptr) {
diff --git a/velox/dwio/parquet/writer/arrow/Metadata.cpp b/velox/dwio/parquet/writer/arrow/Metadata.cpp
index ef978a01a747..a56c40e5fdf9 100644
--- a/velox/dwio/parquet/writer/arrow/Metadata.cpp
+++ b/velox/dwio/parquet/writer/arrow/Metadata.cpp
@@ -182,10 +182,10 @@ std::unique_ptr<ColumnCryptoMetaData> ColumnCryptoMetaData::Make(
 }
 
 ColumnCryptoMetaData::ColumnCryptoMetaData(const uint8_t* metadata)
-    : impl_(std::make_unique<ColumnCryptoMetaDataImpl>(
-          reinterpret_cast<
-              const facebook::velox::parquet::thrift::ColumnCryptoMetaData*>(
-              metadata))) {}
+    : impl_(
+          std::make_unique<ColumnCryptoMetaDataImpl>(
+              reinterpret_cast<const facebook::velox::parquet::thrift::
+                                   ColumnCryptoMetaData*>(metadata))) {}
 
 ColumnCryptoMetaData::~ColumnCryptoMetaData() = default;
 
@@ -389,6 +389,10 @@ class ColumnChunkMetaData::ColumnChunkMetaDataImpl {
     return std::nullopt;
   }
 
+  inline int32_t field_id() const {
+    return descr_->schema_node()->field_id();
+  }
+
  private:
   mutable std::shared_ptr<Statistics> possible_stats_;
   std::vector<Encoding::type> encodings_;
@@ -535,6 +539,10 @@ int64_t ColumnChunkMetaData::total_compressed_size() const {
   return impl_->total_compressed_size();
 }
 
+int32_t ColumnChunkMetaData::field_id() const {
+  return impl_->field_id();
+}
+
 std::unique_ptr<ColumnCryptoMetaData> ColumnChunkMetaData::crypto_metadata()
     const {
   return impl_->crypto_metadata();
@@ -1021,8 +1029,9 @@ class FileMetaData::FileMetaDataImpl {
     if (metadata_->schema.empty()) {
       throw ParquetException("Empty file schema (no root)");
     }
-    schema_.Init(schema::Unflatten(
-        &metadata_->schema[0], static_cast<int>(metadata_->schema.size())));
+    schema_.Init(
+        schema::Unflatten(
+            &metadata_->schema[0], static_cast<int>(metadata_->schema.size())));
   }
 
   void InitColumnOrders() {
@@ -1745,8 +1754,8 @@ class ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilderImpl {
         [&thrift_encodings](
             facebook::velox::parquet::thrift::Encoding::type value) {
           auto it = std::find(
-              thrift_encodings.begin(), thrift_encodings.end(), value);
-          if (it == thrift_encodings.end()) {
+              thrift_encodings.cbegin(), thrift_encodings.cend(), value);
+          if (it == thrift_encodings.cend()) {
             thrift_encodings.push_back(value);
           }
         };
diff --git a/velox/dwio/parquet/writer/arrow/Metadata.h b/velox/dwio/parquet/writer/arrow/Metadata.h
index c69ee5a03d41..7cb7670a0387 100644
--- a/velox/dwio/parquet/writer/arrow/Metadata.h
+++ b/velox/dwio/parquet/writer/arrow/Metadata.h
@@ -187,6 +187,7 @@ class PARQUET_EXPORT ColumnChunkMetaData {
   int64_t index_page_offset() const;
   int64_t total_compressed_size() const;
   int64_t total_uncompressed_size() const;
+  int32_t field_id() const;
   std::unique_ptr<ColumnCryptoMetaData> crypto_metadata() const;
   std::optional<IndexLocation> GetColumnIndexLocation() const;
   std::optional<IndexLocation> GetOffsetIndexLocation() const;
diff --git a/velox/dwio/parquet/writer/arrow/PageIndex.cpp b/velox/dwio/parquet/writer/arrow/PageIndex.cpp
index 465d6e1afecd..2af2a6535a43 100644
--- a/velox/dwio/parquet/writer/arrow/PageIndex.cpp
+++ b/velox/dwio/parquet/writer/arrow/PageIndex.cpp
@@ -201,10 +201,11 @@ class OffsetIndexImpl : public OffsetIndex {
       const facebook::velox::parquet::thrift::OffsetIndex& offset_index) {
     page_locations_.reserve(offset_index.page_locations.size());
     for (const auto& page_location : offset_index.page_locations) {
-      page_locations_.emplace_back(PageLocation{
-          page_location.offset,
-          page_location.compressed_page_size,
-          page_location.first_row_index});
+      page_locations_.emplace_back(
+          PageLocation{
+              page_location.offset,
+              page_location.compressed_page_size,
+              page_location.first_row_index});
     }
   }
 
diff --git a/velox/dwio/parquet/writer/arrow/PathInternal.cpp b/velox/dwio/parquet/writer/arrow/PathInternal.cpp
index 885a8254edd4..f43736067334 100644
--- a/velox/dwio/parquet/writer/arrow/PathInternal.cpp
+++ b/velox/dwio/parquet/writer/arrow/PathInternal.cpp
@@ -888,10 +888,10 @@ class PathBuilder {
     return VisitInline(*array.storage());
   }
 
-#define NOT_IMPLEMENTED_VISIT(ArrowTypePrefix)                             \
-  Status Visit(const ::arrow::ArrowTypePrefix##Array& array) {             \
-    return Status::NotImplemented("Level generation for " #ArrowTypePrefix \
-                                  " not supported yet");                   \
+#define NOT_IMPLEMENTED_VISIT(ArrowTypePrefix)                          \
+  Status Visit(const ::arrow::ArrowTypePrefix##Array& array) {          \
+    return Status::NotImplemented(                                      \
+        "Level generation for " #ArrowTypePrefix " not supported yet"); \
   }
 
   // Types not yet supported in Parquet.
diff --git a/velox/dwio/parquet/writer/arrow/Properties.h b/velox/dwio/parquet/writer/arrow/Properties.h
index 356d88066079..815e2c7d6f5f 100644
--- a/velox/dwio/parquet/writer/arrow/Properties.h
+++ b/velox/dwio/parquet/writer/arrow/Properties.h
@@ -36,6 +36,8 @@
 
 // Define the parquet created by version.
 #define CREATED_BY_VERSION "parquet-cpp-velox"
+// Velox has no versioning yet. Set default 0.0.0.
+#define VELOX_VERSION "0.0.0"
 
 namespace facebook::velox::parquet::arrow {
 
@@ -326,8 +328,7 @@ class PARQUET_EXPORT WriterProperties {
           version_(ParquetVersion::PARQUET_2_6),
           data_page_version_(ParquetDataPageVersion::V1),
           created_by_(
-              std::string("parquet-mr version 2.6.0 (build ") +
-              DEFAULT_CREATED_BY + ")"),
+              DEFAULT_CREATED_BY + std::string(" version ") + VELOX_VERSION),
           store_decimal_as_integer_(false),
           page_checksum_enabled_(false) {}
     virtual ~Builder() {}
diff --git a/velox/dwio/parquet/writer/arrow/Statistics.cpp b/velox/dwio/parquet/writer/arrow/Statistics.cpp
index 757ac36b62e8..4a3ef281befd 100644
--- a/velox/dwio/parquet/writer/arrow/Statistics.cpp
+++ b/velox/dwio/parquet/writer/arrow/Statistics.cpp
@@ -94,10 +94,16 @@ struct CompareHelper {
       "T is an unsigned numeric");
 
   constexpr static T DefaultMin() {
+    if constexpr (std::is_floating_point_v<T>) {
+      return std::numeric_limits<T>::infinity();
+    }
     return std::numeric_limits<T>::max();
   }
   constexpr static T DefaultMax() {
-    return std::numeric_limits<T>::lowest();
+    if constexpr (std::is_floating_point_v<T>) {
+      return -std::numeric_limits<T>::infinity();
+    }
+    return std::numeric_limits<T>::min();
   }
 
   // MSVC17 fix, isnan is not overloaded for IntegralType as per C++11
@@ -361,6 +367,7 @@ CleanStatistic(std::pair<T, T> min_max) {
 // In case of floating point types, the following rules are applied (as per
 // upstream parquet-mr):
 // - If any of min/max is NaN, return nothing.
+// - If min is infinity and max is -infinity, return nothing.
 // - If min is 0.0f, replace with -0.0f
 // - If max is -0.0f, replace with 0.0f
 template <typename T>
@@ -375,8 +382,8 @@ ::arrow::
     return ::std::nullopt;
   }
 
-  if (min == std::numeric_limits<T>::max() &&
-      max == std::numeric_limits<T>::lowest()) {
+  if (min == std::numeric_limits<T>::infinity() &&
+      max == -std::numeric_limits<T>::infinity()) {
     return ::std::nullopt;
   }
 
diff --git a/velox/dwio/parquet/writer/arrow/Types.cpp b/velox/dwio/parquet/writer/arrow/Types.cpp
index 929f664f3097..9f1baec35125 100644
--- a/velox/dwio/parquet/writer/arrow/Types.cpp
+++ b/velox/dwio/parquet/writer/arrow/Types.cpp
@@ -771,8 +771,10 @@ class LogicalType::Impl::Compatible : public virtual LogicalType::Impl {
     }                                                \
   }
 
-#define reset_decimal_metadata(m___) \
-  { set_decimal_metadata(m___, false, -1, -1); }
+#define reset_decimal_metadata(m___)           \
+  {                                            \
+    set_decimal_metadata(m___, false, -1, -1); \
+  }
 
 // For logical types that always translate to the same converted type
 class LogicalType::Impl::SimpleCompatible
diff --git a/velox/dwio/parquet/writer/arrow/Types.h b/velox/dwio/parquet/writer/arrow/Types.h
index 2645a883a4df..24727b1c05cf 100644
--- a/velox/dwio/parquet/writer/arrow/Types.h
+++ b/velox/dwio/parquet/writer/arrow/Types.h
@@ -603,10 +603,6 @@ inline bool operator==(const SortingColumn& left, const SortingColumn& right) {
       left.column_idx == right.column_idx;
 }
 
-inline bool operator!=(const SortingColumn& left, const SortingColumn& right) {
-  return !(left == right);
-}
-
 // ----------------------------------------------------------------------
 
 struct ByteArray {
@@ -631,10 +627,6 @@ inline bool operator==(const ByteArray& left, const ByteArray& right) {
       (left.len == 0 || std::memcmp(left.ptr, right.ptr, left.len) == 0);
 }
 
-inline bool operator!=(const ByteArray& left, const ByteArray& right) {
-  return !(left == right);
-}
-
 struct FixedLenByteArray {
   FixedLenByteArray() : ptr(NULLPTR) {}
   explicit FixedLenByteArray(const uint8_t* ptr) : ptr(ptr) {}
@@ -665,10 +657,6 @@ inline bool operator==(const Int96& left, const Int96& right) {
   return std::equal(left.value, left.value + 3, right.value);
 }
 
-inline bool operator!=(const Int96& left, const Int96& right) {
-  return !(left == right);
-}
-
 static inline std::string ByteArrayToString(const ByteArray& a) {
   return std::string(reinterpret_cast<const char*>(a.ptr), a.len);
 }
diff --git a/velox/dwio/parquet/writer/arrow/Writer.cpp b/velox/dwio/parquet/writer/arrow/Writer.cpp
index e6572bb764dc..f3a101a02810 100644
--- a/velox/dwio/parquet/writer/arrow/Writer.cpp
+++ b/velox/dwio/parquet/writer/arrow/Writer.cpp
@@ -480,12 +480,13 @@ class FileWriterImpl : public FileWriter {
 
       if (arrow_properties_->use_threads()) {
         VELOX_DCHECK_EQ(parallel_column_write_contexts_.size(), writers.size());
-        RETURN_NOT_OK(::arrow::internal::ParallelFor(
-            static_cast<int>(writers.size()),
-            [&](int i) {
-              return writers[i]->Write(&parallel_column_write_contexts_[i]);
-            },
-            arrow_properties_->executor()));
+        RETURN_NOT_OK(
+            ::arrow::internal::ParallelFor(
+                static_cast<int>(writers.size()),
+                [&](int i) {
+                  return writers[i]->Write(&parallel_column_write_contexts_[i]);
+                },
+                arrow_properties_->executor()));
       }
 
       return Status::OK();
@@ -658,16 +659,18 @@ Result<std::unique_ptr<FileWriter>> FileWriter::Open(
 Status WriteFileMetaData(
     const FileMetaData& file_metadata,
     ::arrow::io::OutputStream* sink) {
-  PARQUET_CATCH_NOT_OK(::facebook::velox::parquet::arrow::WriteFileMetaData(
-      file_metadata, sink));
+  PARQUET_CATCH_NOT_OK(
+      ::facebook::velox::parquet::arrow::WriteFileMetaData(
+          file_metadata, sink));
   return Status::OK();
 }
 
 Status WriteMetaDataFile(
     const FileMetaData& file_metadata,
     ::arrow::io::OutputStream* sink) {
-  PARQUET_CATCH_NOT_OK(::facebook::velox::parquet::arrow::WriteMetaDataFile(
-      file_metadata, sink));
+  PARQUET_CATCH_NOT_OK(
+      ::facebook::velox::parquet::arrow::WriteMetaDataFile(
+          file_metadata, sink));
   return Status::OK();
 }
 
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp b/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
index eeae731f9d0f..866aa8ada61f 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilter.cpp
@@ -31,8 +31,6 @@
 
 namespace facebook::velox::parquet::arrow {
 
-constexpr uint32_t BlockSplitBloomFilter::SALT[kBitsSetPerBlock];
-
 BlockSplitBloomFilter::BlockSplitBloomFilter(::arrow::MemoryPool* pool)
     : pool_(pool),
       hash_strategy_(HashStrategy::XXHASH),
diff --git a/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp b/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
index 644fda5a678f..03b56d5c9bc9 100644
--- a/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/BloomFilterTest.cpp
@@ -425,10 +425,12 @@ TYPED_TEST(TestBatchBloomFilter, Basic) {
 
   // Bloom filter fpp parameter
   const double fpp = 0.05;
-  filter.Init(BlockSplitBloomFilter::OptimalNumOfBytes(
-      TestFixture::kTestDataSize, fpp));
-  batch_insert_filter.Init(BlockSplitBloomFilter::OptimalNumOfBytes(
-      TestFixture::kTestDataSize, fpp));
+  filter.Init(
+      BlockSplitBloomFilter::OptimalNumOfBytes(
+          TestFixture::kTestDataSize, fpp));
+  batch_insert_filter.Init(
+      BlockSplitBloomFilter::OptimalNumOfBytes(
+          TestFixture::kTestDataSize, fpp));
 
   std::vector<uint64_t> hashes;
   for (const Type& value : test_data) {
diff --git a/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
index c8c6e24c33fa..5906a75516d4 100644
--- a/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/tests/CMakeLists.txt
@@ -25,10 +25,10 @@ add_executable(
   PropertiesTest.cpp
   SchemaTest.cpp
   StatisticsTest.cpp
-  TypesTest.cpp)
+  TypesTest.cpp
+)
 
-add_test(velox_dwio_arrow_parquet_writer_test
-         velox_dwio_arrow_parquet_writer_test)
+add_test(velox_dwio_arrow_parquet_writer_test velox_dwio_arrow_parquet_writer_test)
 
 target_link_libraries(
   velox_dwio_arrow_parquet_writer_test
@@ -39,7 +39,8 @@ target_link_libraries(
   arrow
   arrow_testing
   velox_dwio_native_parquet_reader
-  velox_temp_path)
+  velox_temp_path
+)
 
 add_library(
   velox_dwio_arrow_parquet_writer_test_lib
@@ -49,8 +50,12 @@ add_library(
   ColumnScanner.cpp
   FileReader.cpp
   TestUtil.cpp
-  XxHasher.cpp)
+  XxHasher.cpp
+)
 
 target_link_libraries(
-  velox_dwio_arrow_parquet_writer_test_lib arrow
-  velox_dwio_arrow_parquet_writer_lib GTest::gtest)
+  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/ColumnReaderTest.cpp b/velox/dwio/parquet/writer/arrow/tests/ColumnReaderTest.cpp
index e22c8fcad530..0deb1540244c 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnReaderTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnReaderTest.cpp
@@ -506,7 +506,7 @@ TEST_F(TestPrimitiveReader, TestReadValuesMissing) {
   std::shared_ptr<DataPageV1> data_page = MakeDataPage<BooleanType>(
       &descr,
       values,
-      /*num_values=*/2,
+      /*num_vals=*/2,
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -600,7 +600,7 @@ TEST_F(TestPrimitiveReader, TestReadValuesMissingWithDictionary) {
   std::shared_ptr<DataPageV1> data_page = MakeDataPage<Int32Type>(
       &descr,
       {},
-      /*num_values=*/2,
+      /*num_vals=*/2,
       Encoding::RLE_DICTIONARY,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -915,7 +915,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, ReadRequired) {
   std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_values=*/static_cast<int>(def_levels.size()),
+      /*num_vals=*/static_cast<int>(def_levels.size()),
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -985,7 +985,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, ReadOptional) {
   std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_values=*/static_cast<int>(def_levels.size()),
+      /*num_vals=*/static_cast<int>(def_levels.size()),
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -1113,7 +1113,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, ReadRequiredRepeated) {
   std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_values=*/static_cast<int>(def_levels.size()),
+      /*num_vals=*/static_cast<int>(def_levels.size()),
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -1191,7 +1191,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, ReadNullableRepeated) {
   std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_values=*/static_cast<int>(def_levels.size()),
+      /*num_vals=*/static_cast<int>(def_levels.size()),
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -1320,7 +1320,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, SkipRequiredTopLevel) {
   std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_values=*/static_cast<int>(values.size()),
+      /*num_vals=*/static_cast<int>(values.size()),
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -1371,7 +1371,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, SkipOptional) {
   std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_values=*/static_cast<int>(values.size()),
+      /*num_vals=*/static_cast<int>(values.size()),
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -1485,7 +1485,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, SkipRepeated) {
   std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_values=*/static_cast<int>(values.size()),
+      /*num_vals=*/static_cast<int>(values.size()),
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -1590,7 +1590,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, SkipRepeatedConsumeBufferFirst) {
   std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
       descr_,
       values,
-      /*num_values=*/static_cast<int>(values.size()),
+      /*num_vals=*/static_cast<int>(values.size()),
       Encoding::PLAIN,
       /*indices=*/{},
       /*indices_size=*/0,
@@ -1647,7 +1647,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, ReadPartialRecord) {
     std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
         descr_,
         /*values=*/{10, 20, 20, 20},
-        /*num_values=*/4,
+        /*num_vals=*/4,
         Encoding::PLAIN,
         /*indices=*/{},
         /*indices_size=*/0,
@@ -1663,7 +1663,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, ReadPartialRecord) {
     std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
         descr_,
         /*values=*/{20, 20},
-        /*num_values=*/2,
+        /*num_vals=*/2,
         Encoding::PLAIN,
         /*indices=*/{},
         /*indices_size=*/0,
@@ -1679,7 +1679,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, ReadPartialRecord) {
     std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
         descr_,
         /*values=*/{20, 30},
-        /*num_values=*/2,
+        /*num_vals=*/2,
         Encoding::PLAIN,
         /*indices=*/{},
         /*indices_size=*/0,
@@ -1751,7 +1751,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, SkipPartialRecord) {
     std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
         descr_,
         /*values=*/{10, 20, 20, 20},
-        /*num_values=*/4,
+        /*num_vals=*/4,
         Encoding::PLAIN,
         /*indices=*/{},
         /*indices_size=*/0,
@@ -1767,7 +1767,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, SkipPartialRecord) {
     std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
         descr_,
         /*values=*/{20, 20},
-        /*num_values=*/2,
+        /*num_vals=*/2,
         Encoding::PLAIN,
         /*indices=*/{},
         /*indices_size=*/0,
@@ -1783,7 +1783,7 @@ TEST_P(RecordReaderPrimitiveTypeTest, SkipPartialRecord) {
     std::shared_ptr<DataPageV1> page = MakeDataPage<Int32Type>(
         descr_,
         /*values=*/{20, 30},
-        /*num_values=*/2,
+        /*num_vals=*/2,
         Encoding::PLAIN,
         /*indices=*/{},
         /*indices_size=*/0,
diff --git a/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp b/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
index 4d9b10f35686..cb9f85196f5d 100644
--- a/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/ColumnWriterTest.cpp
@@ -226,7 +226,7 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
     ASSERT_EQ(this->values_, this->values_out_);
     std::vector<Encoding::type> encodings_vector = this->metadata_encodings();
     std::set<Encoding::type> encodings(
-        encodings_vector.begin(), encodings_vector.end());
+        encodings_vector.cbegin(), encodings_vector.cend());
 
     if (this->type_num() == Type::BOOLEAN) {
       // Dictionary encoding is not allowed for boolean type
diff --git a/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp b/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
index b18c9bb7dc45..47d501aef905 100644
--- a/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/EncodingTest.cpp
@@ -1706,7 +1706,7 @@ class DictDecoderImpl : public DecoderImpl, virtual public DictDecoder<Type> {
     num_values_ = num_values;
     if (len == 0) {
       // Initialize dummy decoder to avoid crashes later on
-      idx_decoder_ = RleDecoder(data, len, /*bit_width=*/1);
+      idx_decoder_ = RleDecoder(data, len, /*bitWidth=*/1);
       return;
     }
     uint8_t bit_width = *data;
@@ -3295,13 +3295,14 @@ class RleBooleanEncoder final : public EncoderImpl,
         buffered_append_values_.push_back(boolean_array.Value(i));
       }
     } else {
-      PARQUET_THROW_NOT_OK(::arrow::VisitArraySpanInline<::arrow::BooleanType>(
-          *boolean_array.data(),
-          [&](bool value) {
-            buffered_append_values_.push_back(value);
-            return Status::OK();
-          },
-          []() { return Status::OK(); }));
+      PARQUET_THROW_NOT_OK(
+          ::arrow::VisitArraySpanInline<::arrow::BooleanType>(
+              *boolean_array.data(),
+              [&](bool value) {
+                buffered_append_values_.push_back(value);
+                return Status::OK();
+              },
+              []() { return Status::OK(); }));
     }
   }
 
@@ -3411,7 +3412,7 @@ class RleBooleanDecoder : public DecoderImpl, virtual public BooleanDecoder {
           num_bytes,
           /*bit_width=*/1);
     } else {
-      decoder_->Reset(decoder_data, num_bytes, /*bit_width=*/1);
+      decoder_->Reset(decoder_data, num_bytes, /*bitWidth=*/1);
     }
   }
 
diff --git a/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp b/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
index 9c1447391584..e4beb4ef077b 100644
--- a/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp
@@ -57,8 +57,9 @@ AddDummyStats(int stat_size, H& header, bool fill_all_stats = false) {
       std::string(reinterpret_cast<const char*>(stat_bytes.data()), stat_size));
 
   if (fill_all_stats) {
-    header.statistics.__set_min(std::string(
-        reinterpret_cast<const char*>(stat_bytes.data()), stat_size));
+    header.statistics.__set_min(
+        std::string(
+            reinterpret_cast<const char*>(stat_bytes.data()), stat_size));
     header.statistics.__set_null_count(42);
     header.statistics.__set_distinct_count(1);
   }
diff --git a/velox/dwio/parquet/writer/arrow/tests/MetadataTest.cpp b/velox/dwio/parquet/writer/arrow/tests/MetadataTest.cpp
index 32aac3599582..a0d0d2e5cb55 100644
--- a/velox/dwio/parquet/writer/arrow/tests/MetadataTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/MetadataTest.cpp
@@ -428,6 +428,9 @@ TEST(Metadata, TestAddKeyValueMetadata) {
   }
   // Verify keys that were added after file writer was closed are not present.
   EXPECT_FALSE(reader->fileMetaData().keyValueMetadataContains("test_key_4"));
+  ASSERT_EQ(
+      CREATED_BY_VERSION + std::string(" version ") + VELOX_VERSION,
+      reader->fileMetaData().createdBy());
 }
 
 // TODO: disabled as they require Arrow parquet data dir.
@@ -502,10 +505,12 @@ TEST(Metadata, TestSortingColumns) {
     sortingColumns.push_back(sortingColumn);
   }
 
+  auto createdBy = CREATED_BY_VERSION + std::string(" version 1.0");
   auto sink = CreateOutputStream();
   auto writerProps = WriterProperties::Builder()
                          .disable_dictionary()
                          ->set_sorting_columns(sortingColumns)
+                         ->created_by(createdBy)
                          ->build();
 
   EXPECT_EQ(sortingColumns, writerProps->sorting_columns());
@@ -537,6 +542,7 @@ TEST(Metadata, TestSortingColumns) {
   EXPECT_EQ(sortingColumns[0].column_idx, rowGroup.sortingColumnIdx(0));
   EXPECT_EQ(sortingColumns[0].descending, rowGroup.sortingColumnDescending(0));
   EXPECT_EQ(sortingColumns[0].nulls_first, rowGroup.sortingColumnNullsFirst(0));
+  ASSERT_EQ(createdBy, reader->fileMetaData().createdBy());
 }
 
 TEST(ApplicationVersion, Basics) {
diff --git a/velox/dwio/parquet/writer/arrow/tests/PageIndexTest.cpp b/velox/dwio/parquet/writer/arrow/tests/PageIndexTest.cpp
index fd175e2a8213..28f13a40f588 100644
--- a/velox/dwio/parquet/writer/arrow/tests/PageIndexTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/PageIndexTest.cpp
@@ -270,10 +270,11 @@ TEST(PageIndex, WriteOffsetIndex) {
   auto sink = CreateOutputStream();
   builder->WriteTo(sink.get());
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
-  offset_indexes.emplace_back(OffsetIndex::Make(
-      buffer->data(),
-      static_cast<uint32_t>(buffer->size()),
-      default_reader_properties()));
+  offset_indexes.emplace_back(
+      OffsetIndex::Make(
+          buffer->data(),
+          static_cast<uint32_t>(buffer->size()),
+          default_reader_properties()));
 
   /// Verify the data of the offset index.
   for (const auto& offset_index : offset_indexes) {
@@ -309,11 +310,12 @@ void TestWriteTypedColumnIndex(
   auto sink = CreateOutputStream();
   builder->WriteTo(sink.get());
   PARQUET_ASSIGN_OR_THROW(auto buffer, sink->Finish());
-  column_indexes.emplace_back(ColumnIndex::Make(
-      *descr,
-      buffer->data(),
-      static_cast<uint32_t>(buffer->size()),
-      default_reader_properties()));
+  column_indexes.emplace_back(
+      ColumnIndex::Make(
+          *descr,
+          buffer->data(),
+          static_cast<uint32_t>(buffer->size()),
+          default_reader_properties()));
 
   /// Verify the data of the column index.
   for (const auto& column_index : column_indexes) {
@@ -666,10 +668,9 @@ TEST_F(PageIndexBuilderTest, SingleRowGroup) {
        EncodedStatistics().set_null_count(0).set_min("A").set_max("B")}};
   const std::vector<std::vector<PageLocation>> page_locations = {
       /*row_group_id=0*/
-      {/*column_id=0*/ {
-           /*offset=*/128,
-           /*compressed_page_size=*/512,
-           /*first_row_index=*/0},
+      {/*column_id=0*/ {/*offset=*/128,
+                        /*compressed_page_size=*/512,
+                        /*first_row_index=*/0},
        /*column_id=1*/
        {/*offset=*/1024,
         /*compressed_page_size=*/512,
@@ -713,19 +714,17 @@ TEST_F(PageIndexBuilderTest, TwoRowGroups) {
        EncodedStatistics().set_null_count(0).set_min("bar").set_max("foo")}};
   const std::vector<std::vector<PageLocation>> page_locations = {
       /*row_group_id=0*/
-      {/*column_id=0*/ {
-           /*offset=*/128,
-           /*compressed_page_size=*/512,
-           /*first_row_index=*/0},
+      {/*column_id=0*/ {/*offset=*/128,
+                        /*compressed_page_size=*/512,
+                        /*first_row_index=*/0},
        /*column_id=1*/
        {/*offset=*/1024,
         /*compressed_page_size=*/512,
         /*first_row_index=*/0}},
       /*row_group_id=0*/
-      {/*column_id=0*/ {
-           /*offset=*/128,
-           /*compressed_page_size=*/512,
-           /*first_row_index=*/0},
+      {/*column_id=0*/ {/*offset=*/128,
+                        /*compressed_page_size=*/512,
+                        /*first_row_index=*/0},
        /*column_id=1*/
        {/*offset=*/1024,
         /*compressed_page_size=*/512,
diff --git a/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp b/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
index f312ec7e7b47..2c8980898220 100644
--- a/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/SchemaTest.cpp
@@ -310,19 +310,22 @@ TEST_F(TestPrimitiveNode, Equals) {
 }
 
 TEST_F(TestPrimitiveNode, PhysicalLogicalMapping) {
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo", Repetition::REQUIRED, Type::INT32, ConvertedType::INT_32));
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo", Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::JSON));
+  ASSERT_NO_THROW(
+      PrimitiveNode::Make(
+          "foo", Repetition::REQUIRED, Type::INT32, ConvertedType::INT_32));
+  ASSERT_NO_THROW(
+      PrimitiveNode::Make(
+          "foo", Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::JSON));
   ASSERT_THROW(
       PrimitiveNode::Make(
           "foo", Repetition::REQUIRED, Type::INT32, ConvertedType::JSON),
       ParquetException);
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo",
-      Repetition::REQUIRED,
-      Type::INT64,
-      ConvertedType::TIMESTAMP_MILLIS));
+  ASSERT_NO_THROW(
+      PrimitiveNode::Make(
+          "foo",
+          Repetition::REQUIRED,
+          Type::INT64,
+          ConvertedType::TIMESTAMP_MILLIS));
   ASSERT_THROW(
       PrimitiveNode::Make(
           "foo", Repetition::REQUIRED, Type::INT32, ConvertedType::INT_64),
@@ -345,8 +348,9 @@ TEST_F(TestPrimitiveNode, PhysicalLogicalMapping) {
           Type::FIXED_LEN_BYTE_ARRAY,
           ConvertedType::ENUM),
       ParquetException);
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo", Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::ENUM));
+  ASSERT_NO_THROW(
+      PrimitiveNode::Make(
+          "foo", Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::ENUM));
   ASSERT_THROW(
       PrimitiveNode::Make(
           "foo",
@@ -407,20 +411,22 @@ TEST_F(TestPrimitiveNode, PhysicalLogicalMapping) {
           2,
           4),
       ParquetException);
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
-      10,
-      6,
-      4));
-  ASSERT_NO_THROW(PrimitiveNode::Make(
-      "foo",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::INTERVAL,
-      12));
+  ASSERT_NO_THROW(
+      PrimitiveNode::Make(
+          "foo",
+          Repetition::REQUIRED,
+          Type::FIXED_LEN_BYTE_ARRAY,
+          ConvertedType::DECIMAL,
+          10,
+          6,
+          4));
+  ASSERT_NO_THROW(
+      PrimitiveNode::Make(
+          "foo",
+          Repetition::REQUIRED,
+          Type::FIXED_LEN_BYTE_ARRAY,
+          ConvertedType::INTERVAL,
+          12));
   ASSERT_THROW(
       PrimitiveNode::Make(
           "foo",
@@ -602,10 +608,12 @@ TEST_F(TestSchemaConverter, NestedExample) {
 
   // 3-level list encoding
   NodePtr item = Int64("item", Repetition::OPTIONAL, 4);
-  NodePtr list(GroupNode::Make(
-      "b", Repetition::REPEATED, {item}, ConvertedType::LIST, 3));
-  NodePtr bag(GroupNode::Make(
-      "bag", Repetition::OPTIONAL, {list}, /*logical_type=*/nullptr, 2));
+  NodePtr list(
+      GroupNode::Make(
+          "b", Repetition::REPEATED, {item}, ConvertedType::LIST, 3));
+  NodePtr bag(
+      GroupNode::Make(
+          "bag", Repetition::OPTIONAL, {list}, /*logical_type=*/nullptr, 2));
   fields.push_back(bag);
 
   NodePtr schema = GroupNode::Make(
@@ -751,14 +759,16 @@ TEST_F(TestSchemaFlatten, NestedExample) {
 
   // 3-level list encoding
   NodePtr item = Int64("item", Repetition::OPTIONAL, 4);
-  NodePtr list(GroupNode::Make(
-      "b", Repetition::REPEATED, {item}, ConvertedType::LIST, 3));
-  NodePtr bag(GroupNode::Make(
-      "bag",
-      Repetition::OPTIONAL,
-      {list},
-      /*logical_type=*/nullptr,
-      2));
+  NodePtr list(
+      GroupNode::Make(
+          "b", Repetition::REPEATED, {item}, ConvertedType::LIST, 3));
+  NodePtr bag(
+      GroupNode::Make(
+          "bag",
+          Repetition::OPTIONAL,
+          {list},
+          /*logical_type=*/nullptr,
+          2));
   fields.push_back(bag);
 
   NodePtr schema = GroupNode::Make(
@@ -853,11 +863,12 @@ TEST_F(TestSchemaDescriptor, Equals) {
   NodePtr item1 = Int64("item1", Repetition::REQUIRED);
   NodePtr item2 = Boolean("item2", Repetition::OPTIONAL);
   NodePtr item3 = Int32("item3", Repetition::REPEATED);
-  NodePtr list(GroupNode::Make(
-      "records",
-      Repetition::REPEATED,
-      {item1, item2, item3},
-      ConvertedType::LIST));
+  NodePtr list(
+      GroupNode::Make(
+          "records",
+          Repetition::REPEATED,
+          {item1, item2, item3},
+          ConvertedType::LIST));
 
   NodePtr bag(GroupNode::Make("bag", Repetition::OPTIONAL, {list}));
   NodePtr bag2(GroupNode::Make("bag", Repetition::REQUIRED, {list}));
@@ -869,13 +880,15 @@ TEST_F(TestSchemaDescriptor, Equals) {
   ASSERT_TRUE(descr1.Equals(descr1));
 
   SchemaDescriptor descr2;
-  descr2.Init(GroupNode::Make(
-      "schema", Repetition::REPEATED, {inta, intb, intc, bag2}));
+  descr2.Init(
+      GroupNode::Make(
+          "schema", Repetition::REPEATED, {inta, intb, intc, bag2}));
   ASSERT_FALSE(descr1.Equals(descr2));
 
   SchemaDescriptor descr3;
-  descr3.Init(GroupNode::Make(
-      "schema", Repetition::REPEATED, {inta, intb2, intc, bag}));
+  descr3.Init(
+      GroupNode::Make(
+          "schema", Repetition::REPEATED, {inta, intb2, intc, bag}));
   ASSERT_FALSE(descr1.Equals(descr3));
 
   // Robust to name of parent node
@@ -885,8 +898,9 @@ TEST_F(TestSchemaDescriptor, Equals) {
   ASSERT_TRUE(descr1.Equals(descr4));
 
   SchemaDescriptor descr5;
-  descr5.Init(GroupNode::Make(
-      "schema", Repetition::REPEATED, {inta, intb, intc, bag, intb2}));
+  descr5.Init(
+      GroupNode::Make(
+          "schema", Repetition::REPEATED, {inta, intb, intc, bag, intb2}));
   ASSERT_FALSE(descr1.Equals(descr5));
 
   // Different max repetition / definition levels
@@ -912,11 +926,12 @@ TEST_F(TestSchemaDescriptor, BuildTree) {
   NodePtr item1 = Int64("item1", Repetition::REQUIRED);
   NodePtr item2 = Boolean("item2", Repetition::OPTIONAL);
   NodePtr item3 = Int32("item3", Repetition::REPEATED);
-  NodePtr list(GroupNode::Make(
-      "records",
-      Repetition::REPEATED,
-      {item1, item2, item3},
-      ConvertedType::LIST));
+  NodePtr list(
+      GroupNode::Make(
+          "records",
+          Repetition::REPEATED,
+          {item1, item2, item3},
+          ConvertedType::LIST));
   NodePtr bag(GroupNode::Make("bag", Repetition::OPTIONAL, {list}));
   fields.push_back(bag);
 
@@ -994,11 +1009,12 @@ TEST_F(TestSchemaDescriptor, HasRepeatedFields) {
   NodePtr item1 = Int64("item1", Repetition::REQUIRED);
   NodePtr item2 = Boolean("item2", Repetition::OPTIONAL);
   NodePtr item3 = Int32("item3", Repetition::REPEATED);
-  NodePtr list(GroupNode::Make(
-      "records",
-      Repetition::REPEATED,
-      {item1, item2, item3},
-      ConvertedType::LIST));
+  NodePtr list(
+      GroupNode::Make(
+          "records",
+          Repetition::REPEATED,
+          {item1, item2, item3},
+          ConvertedType::LIST));
   NodePtr bag(GroupNode::Make("bag", Repetition::OPTIONAL, {list}));
   fields.push_back(bag);
 
@@ -1009,8 +1025,12 @@ TEST_F(TestSchemaDescriptor, HasRepeatedFields) {
   // 3-level list encoding
   NodePtr item_key = Int64("key", Repetition::REQUIRED);
   NodePtr item_value = Boolean("value", Repetition::OPTIONAL);
-  NodePtr map(GroupNode::Make(
-      "map", Repetition::REPEATED, {item_key, item_value}, ConvertedType::MAP));
+  NodePtr map(
+      GroupNode::Make(
+          "map",
+          Repetition::REPEATED,
+          {item_key, item_value},
+          ConvertedType::MAP));
   NodePtr my_map(GroupNode::Make("my_map", Repetition::OPTIONAL, {map}));
   fields.push_back(my_map);
 
@@ -1034,29 +1054,33 @@ TEST(TestSchemaPrinter, Examples) {
   // 3-level list encoding
   NodePtr item1 = Int64("item1", Repetition::OPTIONAL, 4);
   NodePtr item2 = Boolean("item2", Repetition::REQUIRED, 5);
-  NodePtr list(GroupNode::Make(
-      "b", Repetition::REPEATED, {item1, item2}, ConvertedType::LIST, 3));
-  NodePtr bag(GroupNode::Make(
-      "bag", Repetition::OPTIONAL, {list}, /*logical_type=*/nullptr, 2));
+  NodePtr list(
+      GroupNode::Make(
+          "b", Repetition::REPEATED, {item1, item2}, ConvertedType::LIST, 3));
+  NodePtr bag(
+      GroupNode::Make(
+          "bag", Repetition::OPTIONAL, {list}, /*logical_type=*/nullptr, 2));
   fields.push_back(bag);
 
-  fields.push_back(PrimitiveNode::Make(
-      "c",
-      Repetition::REQUIRED,
-      Type::INT32,
-      ConvertedType::DECIMAL,
-      -1,
-      3,
-      2,
-      6));
+  fields.push_back(
+      PrimitiveNode::Make(
+          "c",
+          Repetition::REQUIRED,
+          Type::INT32,
+          ConvertedType::DECIMAL,
+          -1,
+          3,
+          2,
+          6));
 
-  fields.push_back(PrimitiveNode::Make(
-      "d",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 5),
-      Type::INT64,
-      /*length=*/-1,
-      7));
+  fields.push_back(
+      PrimitiveNode::Make(
+          "d",
+          Repetition::REQUIRED,
+          DecimalLogicalType::Make(10, 5),
+          Type::INT64,
+          /*length=*/-1,
+          7));
 
   NodePtr schema = GroupNode::Make(
       "schema",
@@ -2059,86 +2083,100 @@ TEST(TestSchemaNodeCreation, FactoryExceptions) {
   // create an object if compatibility conditions are not met
 
   // Nested logical type on non-group node ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "map", Repetition::REQUIRED, MapLogicalType::Make(), Type::INT64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "map", Repetition::REQUIRED, MapLogicalType::Make(), Type::INT64));
   // Incompatible primitive type ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "string",
-      Repetition::REQUIRED,
-      StringLogicalType::Make(),
-      Type::BOOLEAN));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "string",
+          Repetition::REQUIRED,
+          StringLogicalType::Make(),
+          Type::BOOLEAN));
   // Incompatible primitive length ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "interval",
-      Repetition::REQUIRED,
-      IntervalLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      11));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "interval",
+          Repetition::REQUIRED,
+          IntervalLogicalType::Make(),
+          Type::FIXED_LEN_BYTE_ARRAY,
+          11));
   // Scale is greater than precision.
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 11),
-      Type::INT64));
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(17, 18),
-      Type::INT64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "decimal",
+          Repetition::REQUIRED,
+          DecimalLogicalType::Make(10, 11),
+          Type::INT64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "decimal",
+          Repetition::REQUIRED,
+          DecimalLogicalType::Make(17, 18),
+          Type::INT64));
   // Primitive too small for given precision ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(16, 6),
-      Type::INT32));
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 9),
-      Type::INT32));
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(19, 17),
-      Type::INT64));
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(308, 6),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      128));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "decimal",
+          Repetition::REQUIRED,
+          DecimalLogicalType::Make(16, 6),
+          Type::INT32));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "decimal",
+          Repetition::REQUIRED,
+          DecimalLogicalType::Make(10, 9),
+          Type::INT32));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "decimal",
+          Repetition::REQUIRED,
+          DecimalLogicalType::Make(19, 17),
+          Type::INT64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "decimal",
+          Repetition::REQUIRED,
+          DecimalLogicalType::Make(308, 6),
+          Type::FIXED_LEN_BYTE_ARRAY,
+          128));
   // Length is too long
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "decimal",
-      Repetition::REQUIRED,
-      DecimalLogicalType::Make(10, 6),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      891723283));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "decimal",
+          Repetition::REQUIRED,
+          DecimalLogicalType::Make(10, 6),
+          Type::FIXED_LEN_BYTE_ARRAY,
+          891723283));
 
   // Incompatible primitive length ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "uuid",
-      Repetition::REQUIRED,
-      UUIDLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      64));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "uuid",
+          Repetition::REQUIRED,
+          UUIDLogicalType::Make(),
+          Type::FIXED_LEN_BYTE_ARRAY,
+          64));
   // Non-positive length argument for fixed length binary ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "negative_length",
-      Repetition::REQUIRED,
-      NoLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      -16));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "negative_length",
+          Repetition::REQUIRED,
+          NoLogicalType::Make(),
+          Type::FIXED_LEN_BYTE_ARRAY,
+          -16));
   // Non-positive length argument for fixed length binary ...
-  ASSERT_ANY_THROW(PrimitiveNode::Make(
-      "zero_length",
-      Repetition::REQUIRED,
-      NoLogicalType::Make(),
-      Type::FIXED_LEN_BYTE_ARRAY,
-      0));
+  ASSERT_ANY_THROW(
+      PrimitiveNode::Make(
+          "zero_length",
+          Repetition::REQUIRED,
+          NoLogicalType::Make(),
+          Type::FIXED_LEN_BYTE_ARRAY,
+          0));
   // Non-nested logical type on group node ...
-  ASSERT_ANY_THROW(GroupNode::Make(
-      "list", Repetition::REPEATED, {}, JSONLogicalType::Make()));
+  ASSERT_ANY_THROW(
+      GroupNode::Make(
+          "list", Repetition::REPEATED, {}, JSONLogicalType::Make()));
 
   // nullptr logical type arguments convert to NoLogicalType/ConvertedType::NONE
   std::shared_ptr<const LogicalType> empty;
diff --git a/velox/dwio/parquet/writer/arrow/tests/StatisticsTest.cpp b/velox/dwio/parquet/writer/arrow/tests/StatisticsTest.cpp
index 85603e04b15f..14814ba42c39 100644
--- a/velox/dwio/parquet/writer/arrow/tests/StatisticsTest.cpp
+++ b/velox/dwio/parquet/writer/arrow/tests/StatisticsTest.cpp
@@ -464,7 +464,7 @@ class TestStatistics : public PrimitiveTypedTest<TestType> {
       std::vector<int16_t> definitionLevels(batchNullCount, 0);
       definitionLevels.insert(
           definitionLevels.end(), batchNumValues - batchNullCount, 1);
-      auto beg = this->values_.begin() + i * numValues / 2;
+      auto beg = this->values_.cbegin() + i * numValues / 2;
       auto end = beg + batchNumValues;
       std::vector<c_type> batch = GetDeepCopy(std::vector<c_type>(beg, end));
       c_type* batchValuesPtr = GetValuesPointer(batch);
@@ -892,23 +892,29 @@ TEST(CorruptStatistics, Basics) {
   schema::NodePtr node;
   std::vector<schema::NodePtr> fields;
   // Test Physical Types
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col1", Repetition::OPTIONAL, Type::INT32, ConvertedType::NONE));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col2", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::NONE));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col1", Repetition::OPTIONAL, Type::INT32, ConvertedType::NONE));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col2", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::NONE));
   // Test Logical Types
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col3", Repetition::OPTIONAL, Type::INT32, ConvertedType::DATE));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col4", Repetition::OPTIONAL, Type::INT32, ConvertedType::UINT_32));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col5",
-      Repetition::OPTIONAL,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::INTERVAL,
-      12));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col6", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::UTF8));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col3", Repetition::OPTIONAL, Type::INT32, ConvertedType::DATE));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col4", Repetition::OPTIONAL, Type::INT32, ConvertedType::UINT_32));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col5",
+          Repetition::OPTIONAL,
+          Type::FIXED_LEN_BYTE_ARRAY,
+          ConvertedType::INTERVAL,
+          12));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col6", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::UTF8));
   node = schema::GroupNode::Make("schema", Repetition::REQUIRED, fields);
   schema.Init(node);
 
@@ -932,23 +938,29 @@ TEST(CorrectStatistics, Basics) {
   schema::NodePtr node;
   std::vector<schema::NodePtr> fields;
   // Test Physical Types
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col1", Repetition::OPTIONAL, Type::INT32, ConvertedType::NONE));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col2", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::NONE));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col1", Repetition::OPTIONAL, Type::INT32, ConvertedType::NONE));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col2", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::NONE));
   // Test Logical Types
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col3", Repetition::OPTIONAL, Type::INT32, ConvertedType::DATE));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col4", Repetition::OPTIONAL, Type::INT32, ConvertedType::UINT_32));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col5",
-      Repetition::OPTIONAL,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::INTERVAL,
-      12));
-  fields.push_back(schema::PrimitiveNode::Make(
-      "col6", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::UTF8));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col3", Repetition::OPTIONAL, Type::INT32, ConvertedType::DATE));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col4", Repetition::OPTIONAL, Type::INT32, ConvertedType::UINT_32));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col5",
+          Repetition::OPTIONAL,
+          Type::FIXED_LEN_BYTE_ARRAY,
+          ConvertedType::INTERVAL,
+          12));
+  fields.push_back(
+      schema::PrimitiveNode::Make(
+          "col6", Repetition::OPTIONAL, Type::BYTE_ARRAY, ConvertedType::UTF8));
   node = schema::GroupNode::Make("schema", Repetition::REQUIRED, fields);
   schema.Init(node);
 
@@ -973,8 +985,12 @@ class TestStatisticsSortOrder : public ::testing::Test {
   using c_type = typename TestType::c_type;
 
   void AddNodes(std::string name) {
-    fields_.push_back(schema::PrimitiveNode::Make(
-        name, Repetition::REQUIRED, TestType::type_num, ConvertedType::NONE));
+    fields_.push_back(
+        schema::PrimitiveNode::Make(
+            name,
+            Repetition::REQUIRED,
+            TestType::type_num,
+            ConvertedType::NONE));
   }
 
   void SetUpSchema() {
@@ -1053,11 +1069,13 @@ using CompareTestTypes = ::testing::
 template <>
 void TestStatisticsSortOrder<Int32Type>::AddNodes(std::string name) {
   // UINT_32 logical type to set Unsigned Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::INT32, ConvertedType::UINT_32));
+  fields_.push_back(
+      schema::PrimitiveNode::Make(
+          name, Repetition::REQUIRED, Type::INT32, ConvertedType::UINT_32));
   // INT_32 logical type to set Signed Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::INT32, ConvertedType::INT_32));
+  fields_.push_back(
+      schema::PrimitiveNode::Make(
+          name, Repetition::REQUIRED, Type::INT32, ConvertedType::INT_32));
 }
 
 template <>
@@ -1068,28 +1086,34 @@ void TestStatisticsSortOrder<Int32Type>::SetValues() {
 
   // Write UINT32 min/max values
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[5]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[4]), sizeof(c_type)));
+      .set_min(
+          std::string(
+              reinterpret_cast<const char*>(&values_[5]), sizeof(c_type)))
+      .set_max(
+          std::string(
+              reinterpret_cast<const char*>(&values_[4]), sizeof(c_type)));
 
   // Write INT32 min/max values
   stats_[1]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
+      .set_min(
+          std::string(
+              reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
+      .set_max(
+          std::string(
+              reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
 }
 
 // TYPE::INT64
 template <>
 void TestStatisticsSortOrder<Int64Type>::AddNodes(std::string name) {
   // UINT_64 logical type to set Unsigned Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::INT64, ConvertedType::UINT_64));
+  fields_.push_back(
+      schema::PrimitiveNode::Make(
+          name, Repetition::REQUIRED, Type::INT64, ConvertedType::UINT_64));
   // INT_64 logical type to set Signed Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::INT64, ConvertedType::INT_64));
+  fields_.push_back(
+      schema::PrimitiveNode::Make(
+          name, Repetition::REQUIRED, Type::INT64, ConvertedType::INT_64));
 }
 
 template <>
@@ -1100,17 +1124,21 @@ void TestStatisticsSortOrder<Int64Type>::SetValues() {
 
   // Write UINT64 min/max values
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[5]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[4]), sizeof(c_type)));
+      .set_min(
+          std::string(
+              reinterpret_cast<const char*>(&values_[5]), sizeof(c_type)))
+      .set_max(
+          std::string(
+              reinterpret_cast<const char*>(&values_[4]), sizeof(c_type)));
 
   // Write INT64 min/max values
   stats_[1]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
+      .set_min(
+          std::string(
+              reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
+      .set_max(
+          std::string(
+              reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
 }
 
 // TYPE::FLOAT
@@ -1123,10 +1151,12 @@ void TestStatisticsSortOrder<FloatType>::SetValues() {
 
   // Write Float min/max values
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
+      .set_min(
+          std::string(
+              reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
+      .set_max(
+          std::string(
+              reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
 }
 
 // TYPE::DOUBLE
@@ -1139,18 +1169,21 @@ void TestStatisticsSortOrder<DoubleType>::SetValues() {
 
   // Write Double min/max values
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
+      .set_min(
+          std::string(
+              reinterpret_cast<const char*>(&values_[0]), sizeof(c_type)))
+      .set_max(
+          std::string(
+              reinterpret_cast<const char*>(&values_[9]), sizeof(c_type)));
 }
 
 // TYPE::ByteArray
 template <>
 void TestStatisticsSortOrder<ByteArrayType>::AddNodes(std::string name) {
   // UTF8 logical type to set Unsigned Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name, Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::UTF8));
+  fields_.push_back(
+      schema::PrimitiveNode::Make(
+          name, Repetition::REQUIRED, Type::BYTE_ARRAY, ConvertedType::UTF8));
 }
 
 template <>
@@ -1180,22 +1213,26 @@ void TestStatisticsSortOrder<ByteArrayType>::SetValues() {
 
   // Write String min/max values
   stats_[0]
-      .set_min(std::string(
-          reinterpret_cast<const char*>(vals[2].c_str()), vals[2].length()))
-      .set_max(std::string(
-          reinterpret_cast<const char*>(vals[9].c_str()), vals[9].length()));
+      .set_min(
+          std::string(
+              reinterpret_cast<const char*>(vals[2].c_str()), vals[2].length()))
+      .set_max(
+          std::string(
+              reinterpret_cast<const char*>(vals[9].c_str()),
+              vals[9].length()));
 }
 
 // TYPE::FLBAArray
 template <>
 void TestStatisticsSortOrder<FLBAType>::AddNodes(std::string name) {
   // FLBA has only Unsigned Statistics
-  fields_.push_back(schema::PrimitiveNode::Make(
-      name,
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::NONE,
-      FLBA_LENGTH));
+  fields_.push_back(
+      schema::PrimitiveNode::Make(
+          name,
+          Repetition::REQUIRED,
+          Type::FIXED_LEN_BYTE_ARRAY,
+          ConvertedType::NONE,
+          FLBA_LENGTH));
 }
 
 template <>
@@ -1274,14 +1311,15 @@ TEST(TestByteArrayStatisticsFromArrow, LargeStringType) {
 using TestStatisticsSortOrderFLBA = TestStatisticsSortOrder<FLBAType>;
 
 TEST_F(TestStatisticsSortOrderFLBA, decimalSortOrder) {
-  this->fields_.push_back(schema::PrimitiveNode::Make(
-      "Column 0",
-      Repetition::REQUIRED,
-      Type::FIXED_LEN_BYTE_ARRAY,
-      ConvertedType::DECIMAL,
-      FLBA_LENGTH,
-      12,
-      2));
+  this->fields_.push_back(
+      schema::PrimitiveNode::Make(
+          "Column 0",
+          Repetition::REQUIRED,
+          Type::FIXED_LEN_BYTE_ARRAY,
+          ConvertedType::DECIMAL,
+          FLBA_LENGTH,
+          12,
+          2));
   this->SetUpSchema();
   this->WriteParquet();
 
@@ -1598,6 +1636,172 @@ TEST(TestStatistics, DoubleNegativeZero) {
   CheckNegativeZeroStats<DoubleType>();
 }
 
+// Test infinity handling in statistics.
+template <typename ParquetType>
+void CheckInfinityStats() {
+  using T = typename ParquetType::c_type;
+
+  constexpr int32_t kNumValues = 8;
+  NodePtr node = PrimitiveNode::Make(
+      "infinity_test", Repetition::OPTIONAL, ParquetType::type_num);
+  ColumnDescriptor descr(node, 1, 1);
+
+  constexpr T posInf = std::numeric_limits<T>::infinity();
+  constexpr T negInf = -std::numeric_limits<T>::infinity();
+  constexpr T min = -1.0f;
+  constexpr T max = 1.0f;
+
+  {
+    std::array<T, kNumValues> allPosInf{
+        posInf, posInf, posInf, posInf, posInf, posInf, posInf, posInf};
+    auto stats = MakeStatistics<ParquetType>(&descr);
+    AssertMinMaxAre(stats, allPosInf, posInf, posInf);
+  }
+
+  {
+    std::array<T, kNumValues> allNegInf{
+        negInf, negInf, negInf, negInf, negInf, negInf, negInf, negInf};
+    auto stats = MakeStatistics<ParquetType>(&descr);
+    AssertMinMaxAre(stats, allNegInf, negInf, negInf);
+  }
+
+  {
+    std::array<T, kNumValues> mixedInf{
+        posInf, negInf, posInf, negInf, posInf, negInf, posInf, negInf};
+    auto stats = MakeStatistics<ParquetType>(&descr);
+    AssertMinMaxAre(stats, mixedInf, negInf, posInf);
+  }
+
+  {
+    std::array<T, kNumValues> mixedValues{
+        posInf, max, min, min, negInf, max, min, posInf};
+    auto stats = MakeStatistics<ParquetType>(&descr);
+    AssertMinMaxAre(stats, mixedValues, negInf, posInf);
+  }
+
+  {
+    constexpr T nan = std::numeric_limits<T>::quiet_NaN();
+    std::array<T, kNumValues> mixedWithNan{
+        posInf, nan, max, negInf, nan, min, posInf, nan};
+    auto stats = MakeStatistics<ParquetType>(&descr);
+    AssertMinMaxAre(stats, mixedWithNan, negInf, posInf);
+  }
+}
+
+TEST(TestStatistics, FloatInfinityValues) {
+  CheckInfinityStats<FloatType>();
+}
+
+TEST(TestStatistics, DoubleInfinityValues) {
+  CheckInfinityStats<DoubleType>();
+}
+
+// Test infinity values with validity bitmap.
+TEST(TestStatistics, InfinityWithNullBitmap) {
+  constexpr int kNumValues = 8;
+  NodePtr node = PrimitiveNode::Make(
+      "infinity_null_test", Repetition::OPTIONAL, Type::FLOAT);
+  ColumnDescriptor descr(node, 1, 1);
+
+  constexpr float posInf = std::numeric_limits<float>::infinity();
+  constexpr float negInf = -std::numeric_limits<float>::infinity();
+
+  // Test with some infinity values marked as null.
+  std::array<float, kNumValues> valuesWithNulls{
+      posInf, negInf, 1.0f, 2.0f, posInf, -1.0f, 3.0f, negInf};
+
+  // Bitmap: exclude first posInf and last negInf (01111110 = 0x7E).
+  uint8_t validBitmap = 0x7E;
+
+  auto stats = MakeStatistics<FloatType>(&descr);
+  AssertMinMaxAre(stats, valuesWithNulls, &validBitmap, negInf, posInf);
+  valuesWithNulls = {posInf, 0.0f, 1.0f, 2.0f, -2.0f, -1.0f, 3.0f, negInf};
+
+  stats = MakeStatistics<FloatType>(&descr);
+  AssertMinMaxAre(stats, valuesWithNulls, &validBitmap, -2.0f, 3.0f);
+}
+
+// Test merging statistics with infinity values.
+TEST(TestStatistics, MergeInfinityStatistics) {
+  NodePtr node =
+      PrimitiveNode::Make("merge_infinity", Repetition::OPTIONAL, Type::DOUBLE);
+  ColumnDescriptor descr(node, 1, 1);
+
+  constexpr double posInf = std::numeric_limits<double>::infinity();
+  constexpr double negInf = -std::numeric_limits<double>::infinity();
+
+  auto stats1 = MakeStatistics<DoubleType>(&descr);
+  std::array<double, 3> normalValues{-1.0f, 0.0f, 1.0f};
+  AssertMinMaxAre(stats1, normalValues, -1.0f, 1.0f);
+
+  auto stats2 = MakeStatistics<DoubleType>(&descr);
+  std::array<double, 2> infinityValues{negInf, posInf};
+  AssertMinMaxAre(stats2, infinityValues, negInf, posInf);
+
+  auto mergedStats = MakeStatistics<DoubleType>(&descr);
+  mergedStats->Merge(*stats1);
+  mergedStats->Merge(*stats2);
+
+  // Result should have infinity bounds.
+  ASSERT_TRUE(mergedStats->HasMinMax());
+  ASSERT_EQ(negInf, mergedStats->min());
+  ASSERT_EQ(posInf, mergedStats->max());
+}
+
+TEST(TestStatistics, CleanInfinityStatistics) {
+  constexpr int kNumValues = 4;
+  NodePtr node = PrimitiveNode::Make(
+      "clean_stat_nullopt", Repetition::OPTIONAL, Type::FLOAT);
+  ColumnDescriptor descr(node, 1, 1);
+
+  constexpr float nan = std::numeric_limits<float>::quiet_NaN();
+
+  {
+    std::array<float, kNumValues> allNans{nan, nan, nan, nan};
+    auto stats = MakeStatistics<FloatType>(&descr);
+    AssertUnsetMinMax(stats, allNans);
+  }
+
+  {
+    std::array<float, kNumValues> values{1.0f, 2.0f, 3.0f, 4.0f};
+    uint8_t allNullBitmap = 0x00;
+
+    auto stats = MakeStatistics<FloatType>(&descr);
+    AssertUnsetMinMax(stats, values, &allNullBitmap);
+  }
+
+  {
+    std::array<float, kNumValues> mixedNans{nan, 1.0f, nan, 2.0f};
+    uint8_t partialNullBitmap = 0x05;
+
+    auto stats = MakeStatistics<FloatType>(&descr);
+    AssertUnsetMinMax(stats, mixedNans, &partialNullBitmap);
+  }
+}
+
+TEST(TestStatistics, InfinityCleanStatisticValid) {
+  constexpr int kNumValues = 4;
+  NodePtr node = PrimitiveNode::Make(
+      "clean_stat_valid", Repetition::OPTIONAL, Type::DOUBLE);
+  ColumnDescriptor descr(node, 1, 1);
+
+  constexpr double posInf = std::numeric_limits<double>::infinity();
+  constexpr double negInf = -std::numeric_limits<double>::infinity();
+  constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+
+  {
+    std::array<double, kNumValues> mixedValues{posInf, nan, negInf, nan};
+    auto stats = MakeStatistics<DoubleType>(&descr);
+    AssertMinMaxAre(stats, mixedValues, negInf, posInf);
+  }
+
+  {
+    std::array<double, 1> singleInf{negInf};
+    auto stats = MakeStatistics<DoubleType>(&descr);
+    AssertMinMaxAre(stats, singleInf, negInf, negInf);
+  }
+}
+
 // TODO: disabled as it requires Arrow parquet data dir.
 // Test statistics for binary column with UNSIGNED sort order
 /*
diff --git a/velox/dwio/parquet/writer/arrow/tests/TestUtil.h b/velox/dwio/parquet/writer/arrow/tests/TestUtil.h
index 79f3dc3992cc..4b4c11002aff 100644
--- a/velox/dwio/parquet/writer/arrow/tests/TestUtil.h
+++ b/velox/dwio/parquet/writer/arrow/tests/TestUtil.h
@@ -366,8 +366,9 @@ class DataPageBuilder {
       ParquetException::NYI("only rle encoding currently implemented");
     }
 
-    std::vector<uint8_t> encode_buffer(LevelEncoder::MaxBufferSize(
-        Encoding::RLE, max_level, static_cast<int>(levels.size())));
+    std::vector<uint8_t> encode_buffer(
+        LevelEncoder::MaxBufferSize(
+            Encoding::RLE, max_level, static_cast<int>(levels.size())));
 
     // We encode into separate memory from the output stream because the
     // RLE-encoded bytes have to be preceded in the stream by their absolute
@@ -807,12 +808,13 @@ class PrimitiveTypedTest : public ::testing::Test {
 
     for (int i = 0; i < num_columns; ++i) {
       std::string name = TestColumnName(i);
-      fields.push_back(schema::PrimitiveNode::Make(
-          name,
-          repetition,
-          TestType::type_num,
-          ConvertedType::NONE,
-          FLBA_LENGTH));
+      fields.push_back(
+          schema::PrimitiveNode::Make(
+              name,
+              repetition,
+              TestType::type_num,
+              ConvertedType::NONE,
+              FLBA_LENGTH));
     }
     node_ = schema::GroupNode::Make("schema", Repetition::REQUIRED, fields);
     schema_.Init(node_);
diff --git a/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h b/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h
index 45e5b025ff1e..bf30c6dd5d4f 100644
--- a/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h
+++ b/velox/dwio/parquet/writer/arrow/util/ByteStreamSplitInternal.h
@@ -78,8 +78,9 @@ void ByteStreamSplitDecodeSse2(
 
   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]));
+      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) {
@@ -227,8 +228,9 @@ void ByteStreamSplitDecodeAvx2(
 
   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]));
+      stage[0][j] = _mm256_loadu_si256(
+          reinterpret_cast<const __m256i*>(
+              &data[i * sizeof(__m256i) + j * stride]));
     }
 
     for (size_t step = 0; step < kNumStreamsLog2; ++step) {
@@ -405,8 +407,9 @@ void ByteStreamSplitDecodeAvx512(
 
   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]));
+      stage[0][j] = _mm512_loadu_si512(
+          reinterpret_cast<const __m512i*>(
+              &data[i * sizeof(__m512i) + j * stride]));
     }
 
     for (size_t step = 0; step < kNumStreamsLog2; ++step) {
diff --git a/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt b/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
index b971d33c25c4..2aff416fcdb3 100644
--- a/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
+++ b/velox/dwio/parquet/writer/arrow/util/CMakeLists.txt
@@ -20,7 +20,8 @@ velox_add_library(
   CompressionZlib.cpp
   CompressionLZ4.cpp
   Hashing.cpp
-  Crc32.cpp)
+  Crc32.cpp
+)
 
 velox_link_libraries(
   velox_dwio_arrow_parquet_writer_util_lib
@@ -29,4 +30,5 @@ velox_link_libraries(
   Snappy::snappy
   zstd::zstd
   ZLIB::ZLIB
-  lz4::lz4)
+  lz4::lz4
+)
diff --git a/velox/dwio/parquet/writer/arrow/util/Compression.cpp b/velox/dwio/parquet/writer/arrow/util/Compression.cpp
index f5f77313d101..d61f557a2a1f 100644
--- a/velox/dwio/parquet/writer/arrow/util/Compression.cpp
+++ b/velox/dwio/parquet/writer/arrow/util/Compression.cpp
@@ -24,7 +24,6 @@
 
 #include "arrow/result.h"
 #include "arrow/status.h"
-#include "arrow/util/logging.h"
 #include "velox/dwio/parquet/writer/arrow/util/CompressionInternal.h"
 
 namespace facebook::velox::parquet::arrow::util {
diff --git a/velox/dwio/parquet/writer/arrow/util/Hashing.h b/velox/dwio/parquet/writer/arrow/util/Hashing.h
index cc8c0ff07701..cadca7c68900 100644
--- a/velox/dwio/parquet/writer/arrow/util/Hashing.h
+++ b/velox/dwio/parquet/writer/arrow/util/Hashing.h
@@ -41,7 +41,6 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_builders.h"
 #include "arrow/util/endian.h"
-#include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/ubsan.h"
 
diff --git a/velox/dwio/parquet/writer/arrow/util/safe-math.h b/velox/dwio/parquet/writer/arrow/util/safe-math.h
index 661b62887bc7..70506eefec60 100644
--- a/velox/dwio/parquet/writer/arrow/util/safe-math.h
+++ b/velox/dwio/parquet/writer/arrow/util/safe-math.h
@@ -156,13 +156,13 @@
 
 #define PSNIP_SAFE_DEFINE_LARGER_BINARY_OP(T, name, op_name, op)             \
   PSNIP_SAFE__FUNCTION psnip_safe_##name##_larger                            \
-      psnip_safe_larger_##name##_##op_name(T a, T b) {                       \
+  psnip_safe_larger_##name##_##op_name(T a, T b) {                           \
     return ((psnip_safe_##name##_larger)a)op((psnip_safe_##name##_larger)b); \
   }
 
 #define PSNIP_SAFE_DEFINE_LARGER_UNARY_OP(T, name, op_name, op) \
   PSNIP_SAFE__FUNCTION psnip_safe_##name##_larger               \
-      psnip_safe_larger_##name##_##op_name(T value) {           \
+  psnip_safe_larger_##name##_##op_name(T value) {               \
     return (op((psnip_safe_##name##_larger)value));             \
   }
 
diff --git a/velox/dwio/text/CMakeLists.txt b/velox/dwio/text/CMakeLists.txt
index 844a12ffd601..d11825c4e30d 100644
--- a/velox/dwio/text/CMakeLists.txt
+++ b/velox/dwio/text/CMakeLists.txt
@@ -21,3 +21,9 @@ add_subdirectory(writer)
 velox_add_library(velox_dwio_text_writer_register RegisterTextWriter.cpp)
 
 velox_link_libraries(velox_dwio_text_writer_register velox_dwio_text_writer)
+
+add_subdirectory(reader)
+
+velox_add_library(velox_dwio_text_reader_register RegisterTextReader.cpp)
+
+velox_link_libraries(velox_dwio_text_reader_register velox_dwio_text_reader)
diff --git a/velox/dwio/text/RegisterTextReader.cpp b/velox/dwio/text/RegisterTextReader.cpp
new file mode 100644
index 000000000000..6f631880809e
--- /dev/null
+++ b/velox/dwio/text/RegisterTextReader.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/dwio/text/RegisterTextReader.h"
+#include "velox/dwio/text/reader/TextReader.h"
+
+namespace facebook::velox::text {
+
+std::unique_ptr<dwio::common::Reader> TextReaderFactory::createReader(
+    std::unique_ptr<BufferedInput> input,
+    const ReaderOptions& options) {
+  return std::make_unique<text::TextReader>(options, std::move(input));
+}
+
+void registerTextReaderFactory() {
+  registerReaderFactory(std::make_shared<TextReaderFactory>());
+}
+
+void unregisterTextReaderFactory() {
+  unregisterReaderFactory(dwio::common::FileFormat::TEXT);
+}
+
+} // namespace facebook::velox::text
diff --git a/velox/dwio/text/RegisterTextReader.h b/velox/dwio/text/RegisterTextReader.h
new file mode 100644
index 000000000000..65b9aeb8ae1b
--- /dev/null
+++ b/velox/dwio/text/RegisterTextReader.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/dwio/common/ReaderFactory.h"
+
+namespace facebook::velox::text {
+
+class TextReaderFactory : public dwio::common::ReaderFactory {
+ public:
+  TextReaderFactory() : ReaderFactory(dwio::common::FileFormat::TEXT) {}
+
+  std::unique_ptr<dwio::common::Reader> createReader(
+      std::unique_ptr<dwio::common::BufferedInput>,
+      const dwio::common::ReaderOptions&) override;
+};
+
+void registerTextReaderFactory();
+
+void unregisterTextReaderFactory();
+
+} // namespace facebook::velox::text
diff --git a/velox/dwio/text/reader/CMakeLists.txt b/velox/dwio/text/reader/CMakeLists.txt
new file mode 100644
index 000000000000..d65f1ffbc227
--- /dev/null
+++ b/velox/dwio/text/reader/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_dwio_text_reader TextReader.cpp)
+
+velox_link_libraries(
+  velox_dwio_text_reader
+  velox_type_fbhive
+  velox_dwio_common_compression
+  velox_encode
+  fmt::fmt
+)
diff --git a/velox/dwio/text/reader/TextReader.cpp b/velox/dwio/text/reader/TextReader.cpp
new file mode 100644
index 000000000000..d382dbae491b
--- /dev/null
+++ b/velox/dwio/text/reader/TextReader.cpp
@@ -0,0 +1,1645 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/text/reader/TextReader.h"
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <string>
+
+#include "velox/common/encode/Base64.h"
+#include "velox/dwio/common/exception/Exceptions.h"
+#include "velox/type/fbhive/HiveTypeParser.h"
+
+namespace facebook::velox::text {
+namespace {
+
+using common::CompressionKind;
+
+using dwio::common::EOFError;
+using dwio::common::RowReader;
+using dwio::common::verify;
+
+static constexpr std::string_view kTextfileCompressionExtensionGzip{".gz"};
+static constexpr std::string_view kTextfileCompressionExtensionDeflate{
+    ".deflate"};
+static constexpr std::string_view kTextfileCompressionExtensionZst{".zst"};
+static constexpr std::string_view kTextfileCompressionExtensionLz4{".lz4"};
+static constexpr std::string_view kTextfileCompressionExtensionLzo{".lzo"};
+static constexpr std::string_view kTextfileCompressionExtensionSnappy{
+    ".snappy"};
+
+static std::string emptyString = std::string();
+
+constexpr const int32_t kDecompressionBufferFactor = 3;
+
+void resizeVector(
+    BaseVector* FOLLY_NULLABLE data,
+    const vector_size_t insertionIdx) {
+  if (data == nullptr) {
+    return;
+  }
+
+  auto dataSize = data->size();
+  if (dataSize == 0) {
+    data->resize(10);
+  } else if (dataSize <= insertionIdx) {
+    if (data->type()->kind() == TypeKind::ARRAY) {
+      auto oldSize = dataSize;
+      auto newSize = dataSize * 2;
+      data->resize(newSize);
+
+      auto arrayVector = data->asChecked<ArrayVector>();
+      auto rawOffsets = arrayVector->offsets()->asMutable<vector_size_t>();
+      auto rawSizes = arrayVector->sizes()->asMutable<vector_size_t>();
+
+      auto lastOffset = oldSize > 0 ? rawOffsets[oldSize - 1] : 0;
+      auto lastSize = oldSize > 0 ? rawSizes[oldSize - 1] : 0;
+      auto newOffset = oldSize > 0 ? lastOffset + lastSize : 0;
+
+      for (auto i = oldSize; i < newSize; ++i) {
+        rawSizes[i] = 0;
+        rawOffsets[i] = newOffset;
+      }
+    } else if (data->type()->kind() == TypeKind::MAP) {
+      auto oldSize = dataSize;
+      auto newSize = dataSize * 2;
+      data->resize(newSize);
+
+      auto mapVector = data->asChecked<MapVector>();
+      auto rawOffsets = mapVector->offsets()->asMutable<vector_size_t>();
+      auto rawSizes = mapVector->sizes()->asMutable<vector_size_t>();
+
+      auto lastOffset = oldSize > 0 ? rawOffsets[oldSize - 1] : 0;
+      auto lastSize = oldSize > 0 ? rawSizes[oldSize - 1] : 0;
+      auto newOffset = oldSize > 0 ? lastOffset + lastSize : 0;
+
+      for (auto i = oldSize; i < newSize; ++i) {
+        rawSizes[i] = 0;
+        rawOffsets[i] = newOffset;
+      }
+    } else {
+      data->resize(dataSize * 2);
+    }
+  }
+}
+
+void setCompressionSettings(
+    const std::string& filename,
+    CompressionKind& kind,
+    dwio::common::compression::CompressionOptions& compressionOptions) {
+  if (filename.ends_with(kTextfileCompressionExtensionLz4) ||
+      filename.ends_with(kTextfileCompressionExtensionLzo) ||
+      filename.ends_with(kTextfileCompressionExtensionSnappy)) {
+    VELOX_FAIL("Unsupported compression extension for file: {}", filename);
+  }
+  if (filename.ends_with(kTextfileCompressionExtensionGzip)) {
+    kind = CompressionKind::CompressionKind_GZIP;
+    compressionOptions.format.zlib.windowBits =
+        15; // 2^15-byte deflate window size
+  } else if (filename.ends_with(kTextfileCompressionExtensionDeflate)) {
+    kind = CompressionKind::CompressionKind_ZLIB;
+    compressionOptions.format.zlib.windowBits =
+        -15; // raw deflate, 2^15-byte window size
+  } else if (filename.ends_with(kTextfileCompressionExtensionZst)) {
+    kind = CompressionKind::CompressionKind_ZSTD;
+  } else {
+    kind = CompressionKind::CompressionKind_NONE;
+  }
+}
+
+} // namespace
+
+FileContents::FileContents(
+    MemoryPool& pool,
+    const std::shared_ptr<const RowType>& t)
+    : schema{t},
+      input{nullptr},
+      pool{pool},
+      fileLength{0},
+      compression{CompressionKind::CompressionKind_NONE},
+      compressionOptions{},
+      needsEscape{} {
+  needsEscape.fill(false);
+  needsEscape.at(0) = true;
+}
+
+TextRowReader::TextRowReader(
+    std::shared_ptr<FileContents> fileContents,
+    const RowReaderOptions& opts)
+    : RowReader(),
+      contents_{fileContents},
+      schemaWithId_{TypeWithId::create(fileContents->schema)},
+      scanSpec_{opts.scanSpec()},
+      selectedSchema_{nullptr},
+      options_{opts},
+      columnSelector_{
+          ColumnSelector::apply(opts.selector(), contents_->schema)},
+      currentRow_{0},
+      pos_{opts.offset()},
+      atEOL_{false},
+      atEOF_{false},
+      atSOL_{false},
+      atPhysicalEOF_{false},
+      depth_{0},
+      unreadIdx_{0},
+      limit_{opts.limit()},
+      fileLength_{getStreamLength()},
+      varBinBuf_{
+          std::make_shared<dwio::common::DataBuffer<char>>(contents_->pool)} {
+  // Seek to first line at or after the specified region.
+  if (contents_->compression == CompressionKind::CompressionKind_NONE) {
+    // TODO: Inconsistent row skipping behavior (kept for Presto compatibility)
+    // Issue: When reading from byte offset > 0, we skip rows inclusively at the
+    // start position, but when reading from byte 0, no rows are skipped. This
+    // creates inconsistent behavior where a row at the boundary may be skipped
+    // when it should be included.
+    //
+    // Example: If pos_ = 10 is the first byte of row 2, that entire row gets
+    // skipped, even though it should be read.
+    //
+    // Proposed fix: streamPosition_ = (pos_ == 0) ? 0 : --pos_;
+    // This would skip rows exclusively of pos_, ensuring consistent behavior.
+    const auto streamPosition_ = pos_;
+
+    contents_->inputStream = contents_->input->read(
+        streamPosition_,
+        contents_->fileLength - streamPosition_,
+        dwio::common::LogType::STREAM);
+
+    if (pos_ != 0) {
+      unreadData_.clear();
+      (void)skipLine();
+    }
+    if (opts.skipRows() > 0) {
+      (void)seekToRow(opts.skipRows());
+    }
+  } else {
+    // compressed text files, the first split reads the whole file, rest read 0
+    if (pos_ != 0) {
+      atEOF_ = true;
+    }
+    limit_ = std::numeric_limits<uint64_t>::max();
+
+    contents_->inputStream = contents_->input->loadCompleteFile();
+    auto name = contents_->inputStream->getName();
+    contents_->decompressedInputStream = createDecompressor(
+        contents_->compression,
+        std::move(contents_->inputStream),
+        // An estimated value used as the output buffer size for the zlib
+        // decompressor, and as the fallback value of the decompressed length
+        // for other decompressors.
+        kDecompressionBufferFactor * contents_->fileLength,
+        contents_->pool,
+        contents_->compressionOptions,
+        fmt::format("Text Reader: Stream {}", name),
+        nullptr,
+        true,
+        contents_->fileLength);
+
+    if (opts.skipRows() > 0) {
+      (void)seekToRow(opts.skipRows());
+    }
+  }
+}
+
+uint64_t TextRowReader::next(
+    uint64_t rows,
+    VectorPtr& result,
+    const Mutation* mutation) {
+  if (atEOF_) {
+    return 0;
+  }
+
+  auto& t = schemaWithId_;
+  verify(
+      t->type()->isRow(),
+      "Top-level TypeKind of schema is not Row for file %s",
+      getStreamNameData());
+
+  auto projectSelectedType = options_.projectSelectedType();
+  auto reqT =
+      (projectSelectedType ? getSelectedType() : TypeWithId::create(getType()));
+  verify(
+      reqT->type()->isRow(),
+      "Top-level TypeKind of schema is not Row for file %s",
+      getStreamNameData());
+
+  auto childCount = t->size();
+  auto reqChildCount = reqT->size();
+
+  // create top level RowVector
+  auto rowVecPtr = BaseVector::create<RowVector>(
+      reqT->type(), (vector_size_t)rows, &contents_->pool);
+
+  vector_size_t rowsRead = 0;
+  const auto initialPos = pos_;
+  while (!atEOF_ && rowsRead < rows) {
+    resetLine();
+    uint64_t colIndex = 0;
+    for (vector_size_t i = 0; i < childCount; i++) {
+      if (colIndex >= reqT->size()) {
+        break;
+      }
+
+      DelimType delim = DelimTypeNone;
+      const auto& ct = t->childAt(i);
+      const auto& rct = reqT->childAt(i);
+      auto childVector = rowVecPtr->childAt(i).get();
+
+      if (isSelectedField(ct)) {
+        ++colIndex;
+      } else if (colIndex < reqChildCount && !projectSelectedType) {
+        // not selected and not projecting: set to null
+        if (childVector != nullptr) {
+          rowVecPtr->setNull(i, true);
+          childVector = nullptr;
+        }
+        ++colIndex;
+      } else {
+        // not selected and projecting: just discard the field
+        childVector = nullptr;
+      }
+
+      resizeVector(childVector, rowsRead);
+      readElement(ct->type(), rct->type(), childVector, rowsRead, delim);
+    }
+
+    // set null property
+    for (uint64_t i = colIndex; i < reqChildCount; i++) {
+      auto childVector = rowVecPtr->childAt(i).get();
+
+      if (childVector != nullptr) {
+        rowVecPtr->setNull(static_cast<vector_size_t>(i), true);
+      }
+    }
+    (void)skipLine();
+    ++currentRow_;
+    ++rowsRead;
+
+    bool eof = false;
+    if (contents_->compression == CompressionKind::CompressionKind_NONE) {
+      eof = pos_ >= getLength();
+    } else if (atPhysicalEOF_) {
+      eof = pos_ >= contents_->decompressedInputStream->ByteCount();
+    }
+
+    if (eof) {
+      setEOF();
+    }
+
+    // handle empty file
+    if (initialPos == pos_ && atEOF_) {
+      currentRow_ = 0;
+      rowsRead = 0;
+    }
+  }
+
+  // Resize the row vector to the actual number of rows read.
+  // Handled here for both cases: pos_ > fileLength_ and pos_ > limit_
+  rowVecPtr->resize(rowsRead);
+  result = projectColumns(rowVecPtr, *scanSpec_, mutation);
+
+  return rowsRead;
+}
+
+int64_t TextRowReader::nextRowNumber() {
+  return atEOF_ ? -1 : static_cast<int64_t>(currentRow_) + 1;
+}
+
+int64_t TextRowReader::nextReadSize(uint64_t size) {
+  return static_cast<int64_t>(std::min(fileLength_ - currentRow_, size));
+}
+
+void TextRowReader::updateRuntimeStats(
+    dwio::common::RuntimeStatistics& /*stats*/) const {
+  // No-op for non-selective reader.
+}
+
+void TextRowReader::resetFilterCaches() {
+  // No-op for non-selective reader.
+}
+
+std::optional<size_t> TextRowReader::estimatedRowSize() const {
+  return std::nullopt;
+}
+
+const ColumnSelector& TextRowReader::getColumnSelector() const {
+  return columnSelector_;
+}
+
+std::shared_ptr<const TypeWithId> TextRowReader::getSelectedType() const {
+  if (!selectedSchema_) {
+    selectedSchema_ = columnSelector_.buildSelected();
+  }
+  return selectedSchema_;
+}
+
+uint64_t TextRowReader::getRowNumber() const {
+  return currentRow_;
+}
+
+uint64_t TextRowReader::seekToRow(uint64_t rowNumber) {
+  VELOX_CHECK_GT(
+      rowNumber, currentRow_, "Text file cannot seek to earlier row");
+
+  while (currentRow_ < rowNumber && !skipLine()) {
+    currentRow_++;
+    resetLine();
+  }
+
+  return currentRow_;
+}
+
+const RowReaderOptions& TextRowReader::getDefaultOpts() {
+  static RowReaderOptions defaultOpts;
+  return defaultOpts;
+}
+
+bool TextRowReader::isSelectedField(
+    const std::shared_ptr<const TypeWithId>& type) {
+  auto ci = type->id();
+  return columnSelector_.shouldReadNode(ci);
+}
+
+const char* TextRowReader::getStreamNameData() const {
+  return contents_->input->getName().data();
+}
+
+uint64_t TextRowReader::getLength() {
+  if (fileLength_ == std::numeric_limits<uint64_t>::max()) {
+    fileLength_ = getStreamLength();
+  }
+  return fileLength_;
+}
+
+uint64_t TextRowReader::getStreamLength() const {
+  return contents_->input->getInputStream()->getLength();
+}
+
+void TextRowReader::setEOF() {
+  atEOF_ = true;
+  atEOL_ = true;
+}
+
+/// TODO: Update maximum depth after fixing issue with deeply nested complex
+/// types
+void TextRowReader::incrementDepth() {
+  if (depth_ > 4) {
+    dwio::common::parse_error("Schema nesting too deep");
+  }
+  depth_++;
+}
+
+void TextRowReader::decrementDepth(DelimType& delim) {
+  if (depth_ == 0) {
+    dwio::common::logic_error("Attempt to decrement nesting depth of 0");
+  }
+  depth_--;
+  auto d = depth_ + DelimTypeEOR;
+  if (delim > d) {
+    setNone(delim);
+  }
+}
+
+void TextRowReader::setEOE(DelimType& delim) {
+  // Set delim if it is currently None or a more deeply
+  // delimiter, to simply the code where aggregates
+  // parse nested aggregates.
+  auto d = depth_ + DelimTypeEOE;
+  if (isNone(delim) || d < delim) {
+    delim = d;
+  }
+}
+
+void TextRowReader::resetEOE(DelimType& delim) {
+  // Reset delim it is EOE or above.
+  auto d = depth_ + DelimTypeEOE;
+  if (delim >= d) {
+    setNone(delim);
+  }
+}
+
+bool TextRowReader::isEOE(DelimType delim) {
+  // Test if delim is the EOE at the current depth.
+  return (delim == (depth_ + DelimTypeEOE));
+}
+
+void TextRowReader::setEOR(DelimType& delim) {
+  // Set delim if it is currently None or a more
+  // deeply nested delimiter.
+  auto d = depth_ + DelimTypeEOR;
+  if (isNone(delim) || delim > d) {
+    delim = d;
+  }
+}
+
+bool TextRowReader::isEOR(DelimType delim) {
+  // Return true if delim is the EOR for the current depth
+  // or a less deeply nested depth.
+  return (delim != DelimTypeNone && delim <= (depth_ + DelimTypeEOR));
+}
+
+bool TextRowReader::isOuterEOR(DelimType delim) {
+  // Return true if delim is the EOR for the enclosing object.
+  // For example, when parsing ARRAY elements, which leave delim
+  // set to the EOR for their depth on return, isOuterEOR will
+  // return true if we have reached the ARRAY EOR delimiter at
+  // the end of the latest element.
+  return (delim != DelimTypeNone && delim < (depth_ + DelimTypeEOR));
+}
+
+bool TextRowReader::isEOEorEOR(DelimType delim) {
+  return (!isNone(delim) && delim <= (depth_ + DelimTypeEOE));
+}
+
+void TextRowReader::setNone(DelimType& delim) {
+  delim = DelimTypeNone;
+}
+
+bool TextRowReader::isNone(DelimType delim) {
+  return (delim == DelimTypeNone);
+}
+
+std::string&
+TextRowReader::getString(TextRowReader& th, bool& isNull, DelimType& delim) {
+  if (th.atEOL_) {
+    delim = DelimTypeEOR; // top-level EOR
+  }
+
+  if (th.isEOEorEOR(delim)) {
+    isNull = true;
+    return emptyString;
+  }
+
+  bool wasEscaped = false;
+  th.ownedString_.clear();
+
+  // Processing has to be done character by characater instad of chunk by chunk.
+  // This is to avoid edge case handling if escape character(s) are cut off at
+  // the end of the chunk.
+  while (true) {
+    auto v = th.getByteOptimized(delim);
+    if (!th.isNone(delim)) {
+      break;
+    }
+
+    if (th.contents_->serDeOptions.isEscaped &&
+        v == th.contents_->serDeOptions.escapeChar) {
+      wasEscaped = true;
+      th.ownedString_.append(1, static_cast<char>(v));
+      v = th.getByteUncheckedOptimized(delim);
+      if (!th.isNone(delim)) {
+        break;
+      }
+    }
+    th.ownedString_.append(1, static_cast<char>(v));
+  }
+
+  if (th.ownedString_ == th.contents_->serDeOptions.nullString) {
+    isNull = true;
+    return emptyString;
+  }
+
+  if (wasEscaped) {
+    // We need to copy the data byte by byte only if there is at least one
+    // escaped byte.
+    uint64_t j = 0;
+    for (uint64_t i = 0; i < th.ownedString_.length(); i++) {
+      if (th.ownedString_[i] == th.contents_->serDeOptions.escapeChar &&
+          i < th.ownedString_.length() - 1) {
+        // Check if it's '\r' or '\n'.
+        i++;
+        if (th.ownedString_[i] == 'r') {
+          th.ownedString_[j++] = '\r';
+        } else if (th.ownedString_[i] == 'n') {
+          th.ownedString_[j++] = '\n';
+        } else {
+          // Keep the next byte.
+          th.ownedString_[j++] = th.ownedString_[i];
+        }
+      } else {
+        th.ownedString_[j++] = th.ownedString_[i];
+      }
+    }
+    th.ownedString_.resize(j);
+  }
+
+  return th.ownedString_;
+}
+
+template <class T>
+void TextRowReader::setValueFromString(
+    const std::string& str,
+    BaseVector* data,
+    vector_size_t insertionRow,
+    std::function<std::optional<T>(const std::string&)> convert) {
+  if ((atEOF_ && atSOL_) || data == nullptr) {
+    return;
+  }
+  auto flatVector = data->asChecked<FlatVector<T>>();
+  auto result = str.empty() ? std::nullopt : convert(str);
+  if (result) {
+    flatVector->set(insertionRow, *result);
+  } else {
+    flatVector->setNull(insertionRow, true);
+  }
+}
+
+uint8_t TextRowReader::getByteOptimized(DelimType& delim) {
+  setNone(delim);
+  auto v = getByteUncheckedOptimized(delim);
+  if (isNone(delim)) {
+    if (v == '\r') {
+      v = getByteUncheckedOptimized<true>(
+          delim); // always returns '\n' in this case
+    }
+    delim = getDelimType(v);
+  }
+  return v;
+}
+
+DelimType TextRowReader::getDelimType(uint8_t v) {
+  DelimType delim = DelimTypeNone;
+
+  if (v == '\n') {
+    atEOL_ = true;
+    delim = DelimTypeEOR; // top level EOR
+
+    /// TODO: Logically should be >=, kept as it is to align with presto reader.
+    if (pos_ > limit_) {
+      atEOF_ = true;
+      delim = DelimTypeEOR;
+    }
+  } else if (v == contents_->serDeOptions.separators.at(depth_)) {
+    setEOE(delim);
+  } else {
+    setNone(delim);
+    uint64_t i = depth_;
+    while (i > 0) {
+      i--;
+      if (v == contents_->serDeOptions.separators.at(i)) {
+        delim = i + DelimTypeEOR; // level-based EOR
+        break;
+      }
+    }
+  }
+  return delim;
+}
+
+template <bool skipLF>
+char TextRowReader::getByteUncheckedOptimized(DelimType& delim) {
+  if (atEOL_) {
+    if (!skipLF) {
+      delim = DelimTypeEOR; // top level EOR
+    }
+    return '\n';
+  }
+
+  try {
+    char v;
+    if (contents_->compression != CompressionKind::CompressionKind_NONE &&
+        preLoadedUnreadData_.empty()) {
+      int length = 0;
+      const void* buffer = nullptr;
+      atPhysicalEOF_ =
+          !contents_->decompressedInputStream->Next(&buffer, &length);
+      if (!atPhysicalEOF_) {
+        preLoadedUnreadData_ =
+            std::string_view(reinterpret_cast<const char*>(buffer), length);
+      }
+    }
+
+    if (unreadData_.empty() || unreadIdx_ >= unreadData_.size()) {
+      bool updated = false;
+      if (contents_->compression != CompressionKind::CompressionKind_NONE) {
+        unreadData_.assign(
+            preLoadedUnreadData_.data(), preLoadedUnreadData_.size());
+        preLoadedUnreadData_ = {};
+        updated = !unreadData_.empty();
+      } else {
+        int length = 0;
+        const void* buffer = nullptr;
+        if (contents_->inputStream->Next(&buffer, &length) && length > 0) {
+          VELOX_CHECK_NOT_NULL(buffer);
+          unreadData_.assign(reinterpret_cast<const char*>(buffer), length);
+          updated = true;
+        }
+      }
+
+      if (!updated) {
+        setEOF();
+        delim = DelimTypeEOR;
+        return '\0';
+      }
+      unreadIdx_ = 0;
+    }
+
+    v = unreadData_[unreadIdx_++];
+    pos_++;
+
+    // only when previous char == '\r'
+    if (skipLF) {
+      if (v != '\n') {
+        pos_--;
+        return '\n';
+      }
+    } else {
+      atSOL_ = false;
+    }
+    return v;
+  } catch (EOFError&) {
+  } catch (std::runtime_error& e) {
+    if (std::string(e.what()).find("Short read of") != 0 && !skipLF) {
+      throw;
+    }
+  }
+  if (!skipLF) {
+    setEOF();
+    delim = DelimTypeEOR;
+  }
+  return '\n';
+}
+
+bool TextRowReader::getEOR(DelimType& delim, bool& isNull) {
+  if (isEOR(delim)) {
+    isNull = true;
+    return true;
+  }
+  if (atEOL_) {
+    delim = DelimTypeEOR; // top-level EOR
+    isNull = true;
+    return true;
+  }
+  bool wasAtSOL = atSOL_;
+  setNone(delim);
+  ownedString_.clear();
+  const auto& ns = contents_->serDeOptions.nullString;
+  uint8_t v = 0;
+  while (true) {
+    v = getByteUncheckedOptimized(delim);
+    if (isNone(delim)) {
+      if (v == '\r') {
+        // always returns '\n' in this case
+        v = getByteUncheckedOptimized<true>(delim);
+      }
+      delim = getDelimType(v);
+    }
+
+    if (isEOR(delim) || atEOL_) {
+      if (ownedString_ == ns) {
+        isNull = true;
+      } else if (!ownedString_.empty()) {
+        break;
+      }
+      setEOR(delim);
+      return true;
+    }
+    if (ownedString_.size() >= ns.size() ||
+        static_cast<char>(v) != ns[ownedString_.size()]) {
+      break;
+    }
+    ownedString_.push_back(static_cast<char>(v));
+  }
+
+  unreadData_.insert(0, 1, static_cast<char>(v));
+  pos_--;
+  if (!ownedString_.empty()) {
+    unreadData_.insert(0, ownedString_);
+    pos_ -= ownedString_.size();
+  }
+  atEOL_ = false;
+  atSOL_ = wasAtSOL;
+  setNone(delim);
+  return false;
+}
+
+bool TextRowReader::skipLine() {
+  DelimType delim = DelimTypeNone;
+  while (!atEOL_) {
+    (void)getByteOptimized(delim);
+  }
+  /// TODO: Logically should be >=, kept as it is to align with presto reader
+  if (pos_ > limit_) {
+    setEOF();
+    delim = DelimTypeEOR;
+  }
+  return atEOF_;
+}
+
+void TextRowReader::resetLine() {
+  if (!atEOF_) {
+    atEOL_ = false;
+    VELOX_CHECK_EQ(depth_, 0);
+  }
+  atSOL_ = true;
+}
+
+template <typename T>
+T TextRowReader::getInteger(TextRowReader& th, bool& isNull, DelimType& delim) {
+  const std::string& str = getString(th, isNull, delim);
+
+  if (str.empty()) {
+    isNull = true;
+  }
+  if (isNull) {
+    return 0;
+  }
+
+  // Test if s is not acceptable integer format for
+  // the warehouse, for cases accepted by stol().
+  char c = str[0];
+  if (c != '-' && !std::isdigit(static_cast<unsigned char>(c))) {
+    isNull = true;
+    return 0;
+  }
+
+  int64_t v = 0;
+  unsigned long long scanPos = 0;
+  errno = 0;
+  auto scanCount = sscanf(str.c_str(), "%" SCNd64 "%lln", &v, &scanPos);
+  if (scanCount != 1 || errno == ERANGE) {
+    isNull = true;
+    return 0;
+  }
+  if (scanPos < str.size()) {
+    // Check if the string is a valid decimal.
+    for (uint64_t i = scanPos; i < str.size(); i++) {
+      if (i == scanPos && str[i] == '.') {
+        continue;
+      }
+      if (str[i] >= '0' && str[i] <= '9') {
+        continue;
+      }
+      isNull = true;
+      return 0;
+    }
+  }
+
+  if (!std::is_same<T, int64_t>::value) {
+    if (static_cast<int64_t>(static_cast<T>(v)) != v) {
+      isNull = true;
+      return 0;
+    }
+  }
+  return static_cast<T>(v);
+}
+
+namespace {
+
+static constexpr std::string_view kTrueStringView{"TRUE"};
+static constexpr std::string_view kFalseStringView{"FALSE"};
+
+} // namespace
+
+bool TextRowReader::getBoolean(
+    TextRowReader& th,
+    bool& isNull,
+    DelimType& delim) {
+  const std::string& str = getString(th, isNull, delim);
+  if (str.empty()) {
+    isNull = true;
+  }
+  if (isNull) {
+    return false;
+  }
+  if (str.compare(kTrueStringView) == 0) {
+    return true;
+  }
+  if (str.compare(kFalseStringView) == 0) {
+    return false;
+  }
+
+  switch (str.size()) {
+    case 4:
+      if (boost::algorithm::iequals(str, kTrueStringView)) {
+        return true;
+      }
+      break;
+    case 5:
+      if (boost::algorithm::iequals(str, kFalseStringView)) {
+        return false;
+      }
+      break;
+    default:
+      break;
+  }
+
+  isNull = true;
+  return false;
+}
+
+namespace {
+
+static constexpr std::string_view kNaNStringView{"NaN"};
+static constexpr std::string_view kInfinityStringView{"Infinity"};
+static constexpr std::string_view kShortInfinityStringView{"Inf"};
+static constexpr std::string_view kNegInfinityStringView{"-Infinity"};
+static constexpr std::string_view kShortNegInfinityStringView{"-Inf"};
+
+bool unacceptableFloatingPoint(std::string& s) {
+  for (int i = 0; i < s.size(); ++i) {
+    char c = s.data()[i];
+    if (!(std::isalpha(c) || c == '-')) {
+      return false;
+    }
+  }
+
+  bool isNaN = boost::algorithm::iequals(s, kNaNStringView);
+
+  bool isInf = boost::algorithm::iequals(s, kInfinityStringView);
+  bool isShortInf = boost::algorithm::iequals(s, kShortInfinityStringView);
+
+  bool isNegInf = boost::algorithm::iequals(s, kNegInfinityStringView);
+  bool isShortNegInf =
+      boost::algorithm::iequals(s, kShortNegInfinityStringView);
+
+  return (!isNaN && !isInf && !isShortInf && !isNegInf && !isShortNegInf);
+}
+
+void trimStringInPlace(std::string& s) {
+  const auto isNotSpace = [](unsigned char ch) { return ch > 0x20; };
+  size_t start = 0;
+  size_t end = s.size();
+
+  // Find first non-whitespace character
+  while (start < end && !isNotSpace(s[start])) {
+    ++start;
+  }
+
+  // If the string is all whitespace
+  if (start == end) {
+    s.clear();
+    return;
+  }
+
+  // Find last non-whitespace character
+  size_t last = end - 1;
+  while (last > start && !isNotSpace(s[last])) {
+    --last;
+  }
+
+  // Erase leading and trailing whitespace
+  s = s.substr(start, last - start + 1);
+}
+
+} // namespace
+
+float TextRowReader::getFloat(
+    TextRowReader& th,
+    bool& isNull,
+    DelimType& delim) {
+  std::string& str = getString(th, isNull, delim);
+  if (str.empty()) {
+    isNull = true;
+  }
+  if (isNull) {
+    return 0;
+  }
+
+  trimStringInPlace(str);
+
+  if (str.data()[0] == '.') {
+    th.ownedString_.insert(th.ownedString_.begin(), '0');
+    str = th.ownedString_;
+  }
+
+  if (unacceptableFloatingPoint(str)) {
+    isNull = true;
+    return 0.0;
+  }
+
+  float v = 0.0;
+  unsigned long long scanPos = 0;
+  // We ignore ERANGE, since denormalized floats and
+  // infinities are acceptable.
+  auto scanCount = sscanf(str.c_str(), "%f%lln", &v, &scanPos);
+  if (scanCount != 1 || scanPos < str.size()) {
+    isNull = true;
+    return 0.0;
+  }
+  return v;
+}
+
+double
+TextRowReader::getDouble(TextRowReader& th, bool& isNull, DelimType& delim) {
+  std::string& str = getString(th, isNull, delim);
+  if (str.empty()) {
+    isNull = true;
+  }
+
+  if (isNull) {
+    return 0.0;
+  }
+
+  trimStringInPlace(str);
+
+  if (str.data()[0] == '.') {
+    th.ownedString_.insert(th.ownedString_.begin(), '0');
+    str = th.ownedString_;
+  }
+
+  // Filter out values from non-warehouse sources which
+  // other readers translate to null. Warehouse
+  // readers require upper-case values.
+  if (unacceptableFloatingPoint(str)) {
+    isNull = true;
+    return 0.0;
+  }
+
+  double v = 0.0;
+  unsigned long long scanPos = 0;
+  // We ignore ERANGE, since denormalized doubles and
+  // infinities are acceptable.
+  auto scanCount = sscanf(str.c_str(), "%lf%lln", &v, &scanPos);
+  if (scanCount != 1 || scanPos < str.size()) {
+    isNull = true;
+    return 0.0;
+  }
+  return v;
+}
+
+/// TODO: Reconsider error handling strategy for malformed data
+/// Currently, all read functions convert invalid/malformed data to NULL values.
+/// This approach may produce incorrect query results, particularly for
+/// aggregate operations where a high volume of NULLs can significantly skew
+/// calculations (e.g., COUNT, AVG, SUM). Consider alternative strategies such
+/// as throwing exceptions, logging warnings, or providing configurable error
+/// handling modes.
+void TextRowReader::readElement(
+    const std::shared_ptr<const Type>& t,
+    const std::shared_ptr<const Type>& reqT,
+    BaseVector* FOLLY_NULLABLE data,
+    vector_size_t insertionRow,
+    DelimType& delim) {
+  bool isNull = false;
+  switch (t->kind()) {
+    case TypeKind::INTEGER:
+      switch (reqT->kind()) {
+        case TypeKind::BIGINT:
+          putValue<int32_t, int64_t>(
+              getInteger<int32_t>, data, insertionRow, delim);
+          break;
+        case TypeKind::INTEGER:
+          if (reqT->isDate()) {
+            const std::string& str = getString(*this, isNull, delim);
+            setValueFromString<int32_t>(
+                str,
+                data,
+                insertionRow,
+                [](const std::string& s) -> std::optional<int32_t> {
+                  return DATE()->toDays(s);
+                });
+          } else {
+            putValue<int32_t, int32_t>(
+                getInteger<int32_t>, data, insertionRow, delim);
+          }
+          break;
+        default:
+          VELOX_FAIL(
+              "Requested type {} is not supported to be read as type {}",
+              reqT->toString(),
+              t->toString());
+          break;
+      }
+      break;
+
+    case TypeKind::BIGINT:
+      if (reqT->isShortDecimal()) {
+        const std::string& str = getString(*this, isNull, delim);
+        auto decimalParams = getDecimalPrecisionScale(*reqT);
+        const auto precision = decimalParams.first;
+        const auto scale = decimalParams.second;
+        setValueFromString<int64_t>(
+            str,
+            data,
+            insertionRow,
+            [precision, scale](const std::string& s) -> std::optional<int64_t> {
+              int64_t v = 0;
+              const auto status = DecimalUtil::castFromString(
+                  StringView(s.data(), static_cast<int32_t>(s.size())),
+                  precision,
+                  scale,
+                  v);
+              return status.ok() ? std::optional<int64_t>(v) : std::nullopt;
+            });
+      } else {
+        putValue<int64_t, int64_t>(
+            getInteger<int64_t>, data, insertionRow, delim);
+      }
+      break;
+
+    case TypeKind::HUGEINT: {
+      const std::string& str = getString(*this, isNull, delim);
+      if (reqT->isLongDecimal()) {
+        auto decimalParams = getDecimalPrecisionScale(*reqT);
+        const auto precision = decimalParams.first;
+        const auto scale = decimalParams.second;
+        setValueFromString<int128_t>(
+            str,
+            data,
+            insertionRow,
+            [precision,
+             scale](const std::string& s) -> std::optional<int128_t> {
+              int128_t v = 0;
+              const auto status = DecimalUtil::castFromString(
+                  StringView(s.data(), static_cast<int32_t>(s.size())),
+                  precision,
+                  scale,
+                  v);
+              return status.ok() ? std::optional<int128_t>(v) : std::nullopt;
+            });
+      } else {
+        setValueFromString<int128_t>(
+            str,
+            data,
+            insertionRow,
+            [](const std::string& s) -> std::optional<int128_t> {
+              return HugeInt::parse(s);
+            });
+      }
+      break;
+    }
+    case TypeKind::SMALLINT:
+      switch (reqT->kind()) {
+        case TypeKind::BIGINT:
+          putValue<int16_t, int64_t>(
+              getInteger<int16_t>, data, insertionRow, delim);
+          break;
+        case TypeKind::INTEGER:
+          putValue<int16_t, int32_t>(
+              getInteger<int16_t>, data, insertionRow, delim);
+          break;
+        case TypeKind::SMALLINT:
+          putValue<int16_t, int16_t>(
+              getInteger<int16_t>, data, insertionRow, delim);
+          break;
+        default:
+          VELOX_FAIL(
+              "Requested type {} is not supported to be read as type {}",
+              reqT->toString(),
+              t->toString());
+          break;
+      }
+      break;
+
+    case TypeKind::VARBINARY: {
+      const std::string& str = getString(*this, isNull, delim);
+
+      // Early return if no data vector or at EOF
+      if ((atEOF_ && atSOL_) || (data == nullptr)) {
+        return;
+      }
+
+      const auto& flatVector = data->asChecked<FlatVector<StringView>>();
+      if (!flatVector) {
+        VELOX_FAIL(
+            "Vector for column type does not match: expected FlatVector<StringView>, got {}",
+            data ? data->type()->toString() : "null");
+        return;
+      }
+
+      // Allocate a blob buffer
+      size_t len = str.size();
+      const auto blen = encoding::Base64::calculateDecodedSize(str.data(), len);
+      varBinBuf_->resize(blen.value_or(0));
+
+      // decode from base64 to the blob buffer.
+      Status status = encoding::Base64::decode(
+          str.data(), str.size(), varBinBuf_->data(), blen.value_or(0));
+
+      if (status.code() == StatusCode::kOK) {
+        flatVector->set(
+            insertionRow,
+            StringView(varBinBuf_->data(), static_cast<int32_t>(blen.value())));
+      } else {
+        // Not valid base64:  just copy as-is for compatibility.
+        //
+        // Note that some warehouse file have simply binary data
+        // in what should be a base64-encoded field, and which
+        // may result in extra rows.  Other readers behave as
+        // below, so this provides compatibility, even if  all
+        // readers should really reject these files.
+        varBinBuf_->resize(str.size());
+
+        VELOX_CHECK_NOT_NULL(str.data());
+
+        len = str.size();
+        memcpy(varBinBuf_->data(), str.data(), str.size());
+
+        // Use StringView, set(vector_size_t idx, T value) fails because
+        // strlen(varBinBuf_->data()) is undefined due to lack of null
+        // terminator
+        flatVector->set(
+            insertionRow,
+            StringView(varBinBuf_->data(), static_cast<int32_t>(str.size())));
+      }
+
+      if (isNull) {
+        flatVector->setNull(insertionRow, true);
+      }
+
+      break;
+    }
+    case TypeKind::VARCHAR: {
+      const std::string& str = getString(*this, isNull, delim);
+
+      // Early return if no data vector or at EOF
+      if ((atEOF_ && atSOL_) || (data == nullptr)) {
+        return;
+      }
+
+      const auto& flatVector = data->asChecked<FlatVector<StringView>>();
+      if (!flatVector) {
+        VELOX_FAIL(
+            "Vector for column type does not match: expected FlatVector<StringView>, got {}",
+            data ? data->type()->toString() : "null");
+        return;
+      }
+
+      flatVector->set(
+          insertionRow,
+          StringView(str.data(), static_cast<int32_t>(str.size())));
+
+      if (isNull) {
+        flatVector->setNull(insertionRow, true);
+      }
+
+      break;
+    }
+
+    case TypeKind::BOOLEAN:
+      switch (reqT->kind()) {
+        case TypeKind::BIGINT:
+          putValue<bool, int64_t>(getBoolean, data, insertionRow, delim);
+          break;
+        case TypeKind::INTEGER:
+          putValue<bool, int32_t>(getBoolean, data, insertionRow, delim);
+          break;
+        case TypeKind::SMALLINT:
+          putValue<bool, int16_t>(getBoolean, data, insertionRow, delim);
+          break;
+        case TypeKind::TINYINT:
+          putValue<bool, int8_t>(getBoolean, data, insertionRow, delim);
+          break;
+        case TypeKind::BOOLEAN:
+          putValue<bool, bool>(getBoolean, data, insertionRow, delim);
+          break;
+        default:
+          VELOX_FAIL(
+              "Requested type {} is not supported to be read as type {}",
+              reqT->toString(),
+              t->toString());
+          break;
+      }
+      break;
+
+    case TypeKind::TINYINT:
+      switch (reqT->kind()) {
+        case TypeKind::BIGINT:
+          putValue<int8_t, int64_t>(
+              getInteger<int8_t>, data, insertionRow, delim);
+          break;
+        case TypeKind::INTEGER:
+          putValue<int8_t, int32_t>(
+              getInteger<int8_t>, data, insertionRow, delim);
+          break;
+        case TypeKind::SMALLINT:
+          putValue<int8_t, int16_t>(
+              getInteger<int8_t>, data, insertionRow, delim);
+          break;
+        case TypeKind::TINYINT:
+          putValue<int8_t, int8_t>(
+              getInteger<int8_t>, data, insertionRow, delim);
+          break;
+        default:
+          VELOX_FAIL(
+              "Requested type {} is not supported to be read as type {}",
+              reqT->toString(),
+              t->toString());
+          break;
+      }
+      break;
+
+    case TypeKind::ARRAY: {
+      const auto& ct = t->childAt(0);
+      const auto& arrayVector = data ? data->asChecked<ArrayVector>() : nullptr;
+
+      incrementDepth();
+      (void)getEOR(delim, isNull);
+
+      if (arrayVector != nullptr) {
+        auto rawSizes = arrayVector->sizes()->asMutable<vector_size_t>();
+        auto rawOffsets = arrayVector->offsets()->asMutable<vector_size_t>();
+
+        rawOffsets[insertionRow] = insertionRow > 0
+            ? rawOffsets[insertionRow - 1] + rawSizes[insertionRow - 1]
+            : 0;
+        const int startElementIdx = rawOffsets[insertionRow];
+
+        vector_size_t elementCount = 0;
+        if (isNull) {
+          arrayVector->setNull(insertionRow, isNull);
+          rawSizes[insertionRow] = 0;
+        } else {
+          // Read elements until we reach the end of the array.
+          while (!isOuterEOR(delim)) {
+            setNone(delim);
+            auto elementsVector = arrayVector->elements().get();
+            resizeVector(elementsVector, startElementIdx + elementCount);
+
+            readElement(
+                ct,
+                reqT->childAt(0),
+                elementsVector,
+                startElementIdx + elementCount,
+                delim);
+
+            // Update size on every iteration to allow the right size
+            // inheritance in resizeVector.
+            rawSizes[insertionRow] = ++elementCount;
+
+            if (atEOF_ && atSOL_) {
+              decrementDepth(delim);
+              return;
+            }
+          }
+        }
+
+      } else {
+        // Skip over array data to maintain correct stream position.
+        while (!isOuterEOR(delim)) {
+          setNone(delim);
+          readElement(ct, reqT->childAt(0), nullptr, 0, delim);
+        }
+      }
+      decrementDepth(delim);
+      break;
+    }
+
+    case TypeKind::ROW: {
+      const auto& childCount = t->size();
+      const auto& rowVector = data ? data->asChecked<RowVector>() : nullptr;
+      incrementDepth();
+
+      if (rowVector != nullptr) {
+        if (isNull) {
+          rowVector->setNull(insertionRow, isNull);
+        } else {
+          for (uint64_t j = 0; j < childCount; j++) {
+            if (!isOuterEOR(delim)) {
+              setNone(delim);
+            }
+
+            // Get the child vector for this field.
+            BaseVector* childVector = nullptr;
+            if (j < reqT->size()) {
+              childVector = rowVector->childAt(j).get();
+            }
+            resizeVector(childVector, insertionRow);
+            readElement(
+                t->childAt(j),
+                j < reqT->size() ? reqT->childAt(j) : t->childAt(j),
+                childVector,
+                insertionRow,
+                delim);
+
+            if (atEOF_ && atSOL_) {
+              decrementDepth(delim);
+              return;
+            }
+          }
+        }
+      } else {
+        // Skip over row data to maintain correct stream position.
+        for (uint64_t j = 0; j < childCount; j++) {
+          if (!isOuterEOR(delim)) {
+            setNone(delim);
+          }
+          readElement(t->childAt(j), reqT->childAt(j), nullptr, 0, delim);
+        }
+      }
+
+      decrementDepth(delim);
+      setEOE(delim);
+      break;
+    }
+
+    case TypeKind::MAP: {
+      const auto& mapt = t->asMap();
+      const auto& key = mapt.keyType();
+      const auto& value = mapt.valueType();
+      const auto& mapVector = data ? data->asChecked<MapVector>() : nullptr;
+      incrementDepth();
+      (void)getEOR(delim, isNull);
+
+      if (mapVector != nullptr) {
+        auto rawOffsets = mapVector->offsets()->asMutable<vector_size_t>();
+        auto rawSizes = mapVector->sizes()->asMutable<vector_size_t>();
+
+        rawOffsets[insertionRow] = insertionRow > 0
+            ? rawOffsets[insertionRow - 1] + rawSizes[insertionRow - 1]
+            : 0;
+        const int startElementIdx = rawOffsets[insertionRow];
+
+        vector_size_t elementCount = 0;
+        if (isNull) {
+          mapVector->setNull(insertionRow, isNull);
+          rawSizes[insertionRow] = 0;
+        } else {
+          while (!isOuterEOR(delim)) {
+            // Decode another element.
+            setNone(delim);
+            incrementDepth();
+
+            // insert key
+            auto keysVector = mapVector->mapKeys().get();
+            resizeVector(keysVector, startElementIdx + elementCount);
+
+            readElement(
+                key,
+                reqT->childAt(0),
+                keysVector,
+                startElementIdx + elementCount,
+                delim);
+
+            // Case for no value key.
+            if (atEOF_ && atSOL_) {
+              rawSizes[insertionRow] = elementCount;
+              rawOffsets[insertionRow + 1] = startElementIdx + elementCount;
+              decrementDepth(delim);
+              decrementDepth(delim);
+              return;
+            }
+            resetEOE(delim);
+
+            // insert value
+            auto valsVector = mapVector->mapValues().get();
+            resizeVector(valsVector, startElementIdx + elementCount);
+
+            readElement(
+                value,
+                reqT->childAt(1),
+                valsVector,
+                startElementIdx + elementCount,
+                delim);
+
+            rawSizes[insertionRow] = ++elementCount;
+
+            decrementDepth(delim);
+          }
+        }
+
+      } else {
+        // Skip over map data to maintain correct stream position.
+        while (!isOuterEOR(delim)) {
+          setNone(delim);
+          incrementDepth();
+          readElement(key, reqT->childAt(0), nullptr, 0, delim);
+          resetEOE(delim);
+          readElement(value, reqT->childAt(1), nullptr, 0, delim);
+          decrementDepth(delim);
+        }
+      }
+      decrementDepth(delim);
+      break;
+    }
+
+    case TypeKind::REAL:
+      switch (reqT->kind()) {
+        case TypeKind::REAL:
+          putValue<float, float>(getFloat, data, insertionRow, delim);
+          break;
+        case TypeKind::DOUBLE:
+          putValue<float, double>(getDouble, data, insertionRow, delim);
+          break;
+        default:
+          VELOX_FAIL(
+              "Requested type {} is not supported to be read as type {}",
+              reqT->toString(),
+              t->toString());
+          break;
+      }
+      break;
+
+    case TypeKind::DOUBLE:
+      putValue<double, double>(getDouble, data, insertionRow, delim);
+      break;
+
+    case TypeKind::TIMESTAMP: {
+      const std::string& s = getString(*this, isNull, delim);
+
+      // Early return if no data vector or at EOF
+      if ((atEOF_ && atSOL_) || (data == nullptr)) {
+        return;
+      }
+
+      auto flatVector = data->asChecked<FlatVector<Timestamp>>();
+      if (!flatVector) {
+        VELOX_FAIL(
+            "Vector for column type does not match: expected FlatVector<Timestamp>, got {}",
+            data ? data->type()->toString() : "null");
+        return;
+      }
+
+      if (s.empty()) {
+        isNull = true;
+        flatVector->setNull(insertionRow, true);
+      } else {
+        auto ts = util::Converter<TypeKind::TIMESTAMP>::tryCast(s).thenOrThrow(
+            folly::identity,
+            [&](const Status& status) { VELOX_USER_FAIL(status.message()); });
+        ts.toGMT(Timestamp::defaultTimezone());
+        flatVector->set(
+            insertionRow, Timestamp{ts.getSeconds(), ts.getNanos()});
+      }
+
+      break;
+    }
+
+    default:
+      VELOX_NYI("readElement unhandled type (kind code {})", t->kind());
+  }
+
+  ownedString_.clear();
+}
+
+uint64_t maxStreamsForType(const std::shared_ptr<const Type>& type) {
+  switch (type->kind()) {
+    case TypeKind::ROW:
+    case TypeKind::REAL:
+    case TypeKind::DOUBLE:
+    case TypeKind::BOOLEAN:
+    case TypeKind::TINYINT:
+    case TypeKind::ARRAY:
+    case TypeKind::MAP:
+    case TypeKind::VARBINARY:
+    case TypeKind::TIMESTAMP:
+    case TypeKind::INTEGER:
+    case TypeKind::BIGINT:
+    case TypeKind::SMALLINT:
+    case TypeKind::VARCHAR:
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+template <class T, class reqT>
+void TextRowReader::putValue(
+    const std::function<T(TextRowReader& th, bool& isNull, DelimType& delim)>&
+        f,
+    BaseVector* FOLLY_NULLABLE data,
+    vector_size_t insertionRow,
+    DelimType& delim) {
+  bool isNull = false;
+  T v;
+  if (isEOR(delim)) {
+    isNull = true;
+    v = 0;
+  } else {
+    v = f(*this, isNull, delim);
+  }
+
+  // Early return if no data vector or at EOF
+  if ((atEOF_ && atSOL_) || (data == nullptr)) {
+    return;
+  }
+
+  // Cast to FlatVector<reqT>
+  auto flatVector = data ? data->asChecked<FlatVector<reqT>>() : nullptr;
+  if (!flatVector) {
+    VELOX_FAIL("Vector for column type does not match");
+    return;
+  }
+
+  // Handle null property.
+  if (isNull) {
+    flatVector->setNull(insertionRow, isNull);
+    return;
+  }
+
+  flatVector->set(insertionRow, v);
+}
+
+const std::shared_ptr<const RowType>& TextRowReader::getType() const {
+  return contents_->schema;
+}
+
+TextReader::TextReader(
+    const ReaderOptions& options,
+    std::unique_ptr<BufferedInput> input)
+    : options_{options} {
+  auto schema = options_.fileSchema();
+  VELOX_USER_CHECK_NOT_NULL(schema, "File schema for TEXT must be set.");
+
+  if (!schema) {
+    // Create dummy for testing.
+    internalSchema_ = std::dynamic_pointer_cast<const RowType>(
+        type::fbhive::HiveTypeParser().parse("struct<col0:string>"));
+    DWIO_ENSURE_NOT_NULL(internalSchema_.get());
+    schema = internalSchema_;
+  }
+  schemaWithId_ = TypeWithId::create(schema);
+  contents_ = std::make_shared<FileContents>(options_.memoryPool(), schema);
+
+  if (!contents_->schema->isRow()) {
+    throw std::invalid_argument("file schema must be a ROW type");
+  }
+
+  contents_->input = std::move(input);
+
+  // Find the size of the file using the option or filesystem.
+  contents_->fileLength = std::min(
+      options_.tailLocation(),
+      static_cast<uint64_t>(contents_->input->getInputStream()->getLength()));
+
+  /**
+   * We are now allowing delimiters/separators and escape characters to be the
+   * same. This could be error prone because we are checking for delimiters
+   * before escape characters.
+   *
+   * Example:
+   * delim = ','; escapeChar = ','
+   * dataToParse = "1,,2"
+   * Schema = ROW(ARRAY(VARCHAR()))
+   *
+   * Scenario 1: Check delimiter before escape (current implementation)
+   * Output: ["1", NULL, "2"]
+   *
+   * Scenario 2: Check escape before delim
+   * Output: ["1,2"]
+   *
+   * TODO: This is not a bug but would be good to be able to handle this
+   * ambiguity
+   */
+
+  // Set the SerDe options.
+  contents_->serDeOptions = options_.serDeOptions();
+  if (contents_->serDeOptions.isEscaped) {
+    for (auto delim : contents_->serDeOptions.separators) {
+      contents_->needsEscape.at(delim) = true;
+    }
+    contents_->needsEscape.at(contents_->serDeOptions.escapeChar) = true;
+  }
+
+  // Validate SerDe options.
+  VELOX_CHECK(
+      contents_->serDeOptions.nullString.compare("\r") != 0,
+      "\'\\r\' is not allowed to be nullString");
+  VELOX_CHECK(
+      contents_->serDeOptions.nullString.compare("\n") != 0,
+      "\'\\n\n is not allowed to be nullString");
+
+  setCompressionSettings(
+      contents_->input->getName(),
+      contents_->compression,
+      contents_->compressionOptions);
+}
+
+std::optional<uint64_t> TextReader::numberOfRows() const {
+  return std::nullopt;
+}
+
+std::unique_ptr<ColumnStatistics> TextReader::columnStatistics(
+    uint32_t /*index*/) const {
+  return nullptr;
+}
+
+const std::shared_ptr<const RowType>& TextReader::rowType() const {
+  return contents_->schema;
+}
+
+CompressionKind TextReader::getCompression() const {
+  return contents_->compression;
+}
+
+const std::shared_ptr<const TypeWithId>& TextReader::typeWithId() const {
+  if (!typeWithId_) {
+    typeWithId_ = TypeWithId::create(rowType());
+  }
+  return typeWithId_;
+}
+
+std::unique_ptr<RowReader> TextReader::createRowReader(
+    const RowReaderOptions& opts) const {
+  return std::make_unique<TextRowReader>(contents_, opts);
+}
+
+uint64_t TextReader::getFileLength() const {
+  return contents_->fileLength;
+}
+
+} // namespace facebook::velox::text
diff --git a/velox/dwio/text/reader/TextReader.h b/velox/dwio/text/reader/TextReader.h
new file mode 100644
index 000000000000..435de81c35a7
--- /dev/null
+++ b/velox/dwio/text/reader/TextReader.h
@@ -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.
+ */
+
+#pragma once
+
+#include <array>
+#include <limits>
+#include <string>
+
+#include "folly/CppAttributes.h"
+#include "velox/dwio/common/BufferedInput.h"
+#include "velox/dwio/common/Reader.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/dwio/common/compression/Compression.h"
+
+namespace facebook::velox::text {
+
+using common::CompressionKind;
+using common::ScanSpec;
+using dwio::common::BufferedInput;
+using dwio::common::ColumnSelector;
+using dwio::common::ColumnStatistics;
+using dwio::common::Mutation;
+using dwio::common::ReaderOptions;
+using dwio::common::RowReaderOptions;
+using dwio::common::SerDeOptions;
+using dwio::common::TypeWithId;
+using memory::MemoryPool;
+
+// Shared state for a file between TextReader and TextRowReader
+struct FileContents {
+  FileContents(MemoryPool& pool, const std::shared_ptr<const RowType>& t);
+
+  const size_t COLUMN_POSITION_INVALID = std::numeric_limits<size_t>::max();
+  const std::shared_ptr<const RowType> schema;
+
+  std::unique_ptr<BufferedInput> input;
+  std::unique_ptr<dwio::common::SeekableInputStream> inputStream;
+  std::unique_ptr<dwio::common::SeekableInputStream> decompressedInputStream;
+  MemoryPool& pool;
+  uint64_t fileLength;
+  CompressionKind compression;
+  dwio::common::compression::CompressionOptions compressionOptions;
+  SerDeOptions serDeOptions;
+  std::array<bool, 128> needsEscape;
+};
+
+using DelimType = uint8_t;
+constexpr DelimType DelimTypeNone = 0;
+constexpr DelimType DelimTypeEOR = 1;
+constexpr DelimType DelimTypeEOE = 2;
+
+class TextReader : public dwio::common::Reader {
+ public:
+  TextReader(
+      const ReaderOptions& options,
+      std::unique_ptr<BufferedInput> input);
+
+  std::optional<uint64_t> numberOfRows() const override;
+
+  std::unique_ptr<ColumnStatistics> columnStatistics(
+      uint32_t index) const override;
+
+  const RowTypePtr& rowType() const override;
+
+  CompressionKind getCompression() const;
+
+  const std::shared_ptr<const TypeWithId>& typeWithId() const override;
+
+  std::unique_ptr<dwio::common::RowReader> createRowReader(
+      const RowReaderOptions& options) const override;
+
+  uint64_t getFileLength() const;
+
+ private:
+  ReaderOptions options_;
+  mutable std::shared_ptr<const TypeWithId> typeWithId_;
+  std::shared_ptr<FileContents> contents_;
+  std::shared_ptr<const TypeWithId> schemaWithId_;
+  std::shared_ptr<const RowType> internalSchema_;
+};
+
+class TextRowReader : public dwio::common::RowReader {
+ public:
+  TextRowReader(
+      std::shared_ptr<FileContents> fileContents,
+      const RowReaderOptions& options);
+
+  uint64_t next(
+      uint64_t size,
+      VectorPtr& result,
+      const Mutation* mutation = nullptr) override;
+
+  int64_t nextRowNumber() override;
+
+  int64_t nextReadSize(uint64_t size) override;
+
+  void updateRuntimeStats(
+      dwio::common::RuntimeStatistics& stats) const override;
+
+  void resetFilterCaches() override;
+
+  std::optional<size_t> estimatedRowSize() const override;
+
+  const ColumnSelector& getColumnSelector() const;
+
+  std::shared_ptr<const TypeWithId> getSelectedType() const;
+
+  uint64_t getRowNumber() const;
+
+  uint64_t seekToRow(uint64_t rowNumber);
+
+ private:
+  const RowReaderOptions& getDefaultOpts();
+
+  const std::shared_ptr<const RowType>& getType() const;
+
+  bool isSelectedField(const std::shared_ptr<const TypeWithId>& t);
+
+  const char* getStreamNameData() const;
+
+  uint64_t getLength();
+
+  uint64_t getStreamLength() const;
+
+  void setEOF();
+
+  void incrementDepth();
+
+  void decrementDepth(DelimType& delim);
+
+  void setEOE(DelimType& delim);
+
+  void resetEOE(DelimType& delim);
+
+  bool isEOE(DelimType delim);
+
+  void setEOR(DelimType& delim);
+
+  bool isEOR(DelimType delim);
+
+  bool isOuterEOR(DelimType delim);
+
+  bool isEOEorEOR(DelimType delim);
+
+  void setNone(DelimType& delim);
+
+  bool isNone(DelimType delim);
+
+  DelimType getDelimType(uint8_t v);
+
+  template <bool skipLF = false>
+  char getByteUnchecked(DelimType& delim);
+
+  template <bool skipLF = false>
+  char getByteUncheckedOptimized(DelimType& delim);
+
+  uint8_t getByte(DelimType& delim);
+  uint8_t getByteOptimized(DelimType& delim);
+
+  bool getEOR(DelimType& delim, bool& isNull);
+
+  bool skipLine();
+
+  void resetLine();
+
+  static std::string&
+  getString(TextRowReader& th, bool& isNull, DelimType& delim);
+
+  template <typename T>
+  static T getInteger(TextRowReader& th, bool& isNull, DelimType& delim);
+
+  static bool getBoolean(TextRowReader& th, bool& isNull, DelimType& delim);
+
+  static float getFloat(TextRowReader& th, bool& isNull, DelimType& delim);
+
+  static double getDouble(TextRowReader& th, bool& isNull, DelimType& delim);
+
+  void readElement(
+      const std::shared_ptr<const Type>& t,
+      const std::shared_ptr<const Type>& reqT,
+      BaseVector* FOLLY_NULLABLE data,
+      vector_size_t insertionRow,
+      DelimType& delim);
+
+  template <class T, class reqT>
+  void putValue(
+      const std::function<T(TextRowReader& th, bool& isNull, DelimType& delim)>&
+          f,
+      BaseVector* FOLLY_NULLABLE data,
+      vector_size_t insertionRow,
+      DelimType& delim);
+
+  template <class T>
+  void setValueFromString(
+      const std::string& str,
+      BaseVector* FOLLY_NULLABLE data,
+      vector_size_t insertionRow,
+      std::function<std::optional<T>(const std::string&)> convert);
+
+  const std::shared_ptr<FileContents> contents_;
+  const std::shared_ptr<const TypeWithId> schemaWithId_;
+  const std::shared_ptr<velox::common::ScanSpec>& scanSpec_;
+
+  mutable std::shared_ptr<const TypeWithId> selectedSchema_;
+
+  RowReaderOptions options_;
+  ColumnSelector columnSelector_;
+  uint64_t currentRow_;
+  uint64_t pos_;
+  bool atEOL_;
+  bool atEOF_;
+  bool atSOL_;
+  bool atPhysicalEOF_;
+  uint8_t depth_;
+  std::string unreadData_;
+  std::string_view preLoadedUnreadData_;
+  int unreadIdx_;
+  uint64_t limit_; // lowest offset not in the range
+  uint64_t fileLength_;
+  std::string ownedString_;
+  std::shared_ptr<dwio::common::DataBuffer<char>> varBinBuf_;
+};
+
+} // namespace facebook::velox::text
diff --git a/velox/dwio/text/tests/CMakeLists.txt b/velox/dwio/text/tests/CMakeLists.txt
index 34a05424d366..032c209e75a7 100644
--- a/velox/dwio/text/tests/CMakeLists.txt
+++ b/velox/dwio/text/tests/CMakeLists.txt
@@ -12,15 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(TEST_LINK_LIBS
-    velox_dwio_common_test_utils
-    velox_vector_test_lib
-    velox_exec_test_lib
-    velox_temp_path
-    GTest::gtest
-    GTest::gtest_main
-    GTest::gmock
-    gflags::gflags
-    glog::glog)
+set(
+  TEST_LINK_LIBS
+  velox_dwio_common_test_utils
+  velox_vector_test_lib
+  velox_exec_test_lib
+  velox_temp_path
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
+  gflags::gflags
+  glog::glog
+)
+
+add_subdirectory(reader)
 
 add_subdirectory(writer)
diff --git a/velox/dwio/text/tests/reader/CMakeLists.txt b/velox/dwio/text/tests/reader/CMakeLists.txt
new file mode 100644
index 000000000000..55ec4ff35ed1
--- /dev/null
+++ b/velox/dwio/text/tests/reader/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_text_reader_test TextReaderTest.cpp)
+
+add_test(
+  NAME velox_text_reader_test
+  COMMAND velox_text_reader_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(velox_text_reader_test velox_dwio_text_reader_register ${TEST_LINK_LIBS})
+
+file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/examples DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/velox/dwio/text/tests/reader/TextReaderTest.cpp b/velox/dwio/text/tests/reader/TextReaderTest.cpp
new file mode 100644
index 000000000000..15e4e595af8a
--- /dev/null
+++ b/velox/dwio/text/tests/reader/TextReaderTest.cpp
@@ -0,0 +1,1940 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/DataFiles.h"
+#include "velox/dwio/text/RegisterTextReader.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+extern int daylight;
+extern long timezone;
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::text {
+
+namespace {
+
+int32_t parseDate(const std::string& text) {
+  return DATE()->toDays(text);
+}
+
+class TextReaderTest : public testing::Test,
+                       public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    registerTextReaderFactory();
+  }
+
+  void TearDown() override {
+    unregisterTextReaderFactory();
+  }
+
+  memory::MemoryPool& poolRef() {
+    return *pool();
+  }
+
+  void setScanSpec(const Type& type, dwio::common::RowReaderOptions& options) {
+    auto spec = std::make_shared<common::ScanSpec>("root");
+    spec->addAllChildFields(type);
+    options.setScanSpec(spec);
+  }
+
+ private:
+  std::shared_ptr<LocalReadFile> readFile_;
+};
+
+struct TestCompressionParam {
+  std::string filepath;
+  std::string compression;
+};
+
+class TextReaderDecompressionTest
+    : public TextReaderTest,
+      public testing::WithParamInterface<TestCompressionParam> {};
+
+TEST_F(TextReaderTest, basic) {
+  auto expected = makeRowVector({
+      makeFlatVector<std::string>(
+          {"FOO",
+           "FOO",
+           "FOO",
+           "FOO",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAZ",
+           "BAZ",
+           "BAZ",
+           "BAZ"}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
+      makeFlatVector<double>(
+          {1.123,
+           2.333,
+           -6.1,
+           4.2,
+           47.2,
+           79.5,
+           3.1415926,
+           -221.145,
+           93.12,
+           -4123.11,
+           950.2,
+           43.66}),
+      makeFlatVector<bool>(
+          {true,
+           true,
+           false,
+           true,
+           false,
+           false,
+           true,
+           true,
+           false,
+           false,
+           false,
+           true}),
+  });
+
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/",
+      "examples/simple_types_compressed_file.gz");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  // Try reading 10 rows each time.
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 2);
+  for (int i = 0; i < 2; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 10 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+
+  input = std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  reader = factory->createReader(std::move(input), readerOptions);
+  rowReader = reader->createRowReader(rowReaderOptions);
+  // Try reading 2, 3, 4, 5 rows at a time.
+  ASSERT_EQ(rowReader->next(2, result), 2);
+  for (int i = 0; i < 2; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(3, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 2 + i));
+  }
+  ASSERT_EQ(rowReader->next(4, result), 4);
+  for (int i = 0; i < 4; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 5 + i));
+  }
+  ASSERT_EQ(rowReader->next(5, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 9 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, headerAndCustomNullString) {
+  tzset();
+  const auto tzOffsetPST = 28'800;
+  const auto tzOffsetPDT = 25'200;
+  auto expected = makeRowVector({
+      makeFlatVector<std::string>(
+          {"FOO",
+           "FOO",
+           "FOO",
+           "FOO",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAZ",
+           "BAZ",
+           "BAZ",
+           "BAZ",
+           ""}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}),
+      makeNullableFlatVector<double>(
+          {1.123,
+           2.333,
+           -6.1,
+           4.2,
+           47.2,
+           79.5,
+           3.1415926,
+           -221.145,
+           93.12,
+           -4123.11,
+           950.2,
+           43.66,
+           std::nullopt}),
+      makeNullableFlatVector<Timestamp>({
+          Timestamp{1'695'378'095 + tzOffsetPDT, 148'000'000},
+          Timestamp{1'695'690'351 + tzOffsetPDT, 0},
+          Timestamp{1'695'686'400 + tzOffsetPDT, 0},
+          Timestamp{1'695'083'400 + tzOffsetPDT, 0},
+          std::nullopt,
+          Timestamp{1'695'657'091 + tzOffsetPDT, 209'000'000},
+          Timestamp{1'695'690'437 + tzOffsetPDT, 469'123'000},
+          Timestamp{1'696'540'679 + tzOffsetPDT, 976'000'000},
+          Timestamp{1'695'657'171 + tzOffsetPDT, 637'000'000},
+          Timestamp{1'695'693'225 + tzOffsetPDT, 745'123'000},
+          std::nullopt,
+          Timestamp{1'695'406'246 + tzOffsetPDT, 0},
+          Timestamp{1'699'392'124 + tzOffsetPST, 736'000'000},
+      }),
+  });
+
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_ts", TIMESTAMP()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/simple_types_with_header");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  setScanSpec(*type, rowReaderOptions);
+  rowReaderOptions.setSkipRows(1);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  // Try reading 10 rows each time.
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 10 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+
+  input = std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  reader = factory->createReader(std::move(input), readerOptions);
+  rowReader = reader->createRowReader(rowReaderOptions);
+  // Try reading 2, 3, 4, 5 rows at a time.
+  ASSERT_EQ(rowReader->next(2, result), 2);
+  for (int i = 0; i < 2; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(3, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 2 + i));
+  }
+  ASSERT_EQ(rowReader->next(4, result), 4);
+  for (int i = 0; i < 4; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 5 + i));
+  }
+  ASSERT_EQ(rowReader->next(5, result), 4);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 9 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+
+  // Try reading with an empty NULL string.
+  auto serDeOptions = readerOptions.serDeOptions();
+  serDeOptions.nullString = "";
+  readerOptions.setSerDeOptions(serDeOptions);
+  input = std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  reader = factory->createReader(std::move(input), readerOptions);
+  rowReader = reader->createRowReader(rowReaderOptions);
+  ASSERT_EQ(rowReader->next(15, result), 13);
+  expected->childAt(0)->setNull(12, true);
+  for (int i = 0; i < 13; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+
+  // Try reading with a custom NULL string.
+  serDeOptions.nullString = "BAR";
+  readerOptions.setSerDeOptions(serDeOptions);
+  input = std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  reader = factory->createReader(std::move(input), readerOptions);
+  rowReader = reader->createRowReader(rowReaderOptions);
+  ASSERT_EQ(rowReader->next(15, result), 13);
+  expected->childAt(0)->setNull(12, false);
+  expected->childAt(0)->setNull(4, true);
+  expected->childAt(0)->setNull(5, true);
+  expected->childAt(0)->setNull(6, true);
+  expected->childAt(0)->setNull(7, true);
+  for (int i = 0; i < 13; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(TextReaderTest, complexTypesWithCustomDelimiters) {
+  const vector_size_t length = 13;
+  const auto keyVector = makeFlatVector<int64_t>(
+      {1,   111,  22, 22222, 333, 33, 44,    5,   555, 66, 7777,     7,
+       777, 8888, 88, 9,     99,  10, 10000, 111, 1,   11, 11122222, 123142});
+  const auto valueVector = makeFlatVector<bool>(
+      {false, true, true,  false, false, true,  false, true,
+       false, true, false, true,  false, false, true,  true,
+       false, true, false, true,  false, true,  true,  true});
+  BufferPtr sizes = facebook::velox::allocateOffsets(length, pool());
+  BufferPtr offsets = facebook::velox::allocateOffsets(length, pool());
+  auto rawSizes = sizes->asMutable<vector_size_t>();
+  auto rawOffsets = offsets->asMutable<vector_size_t>();
+  rawSizes[0] = 2;
+  rawSizes[1] = 2;
+  rawSizes[2] = 2;
+  rawSizes[3] = 1;
+  rawSizes[4] = 2;
+  rawSizes[5] = 1;
+  rawSizes[6] = 3;
+  rawSizes[7] = 2;
+  rawSizes[8] = 2;
+  rawSizes[9] = 2;
+  rawSizes[10] = 3;
+  rawSizes[11] = 1;
+  rawSizes[12] = 1;
+  for (int i = 1; i < length; i++) {
+    rawOffsets[i] = rawOffsets[i - 1] + rawSizes[i - 1];
+  }
+
+  const auto expected = makeRowVector({
+      makeFlatVector<std::string>(
+          {"FOO",
+           "FOO",
+           "FOO",
+           "FOO",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAZ",
+           "BAZ",
+           "BAZ",
+           "FOO\\nBAZ",
+           "FOO\n\nBAR\nBAZ"}),
+      makeArrayVector<int64_t>(
+          {{1, 11, 111},
+           {22, 22222},
+           {333, 33},
+           {4444, 44},
+           {5, 555},
+           {666, 66, 66},
+           {7777, 7, 777},
+           {8888, 88},
+           {9, 99},
+           {10, 10000},
+           {111, 1, 111},
+           {12, 11122222, 222},
+           {13, 11133333, 333}}),
+      makeArrayVector<double>(
+          {{1.123, 1.3123},
+           {2.333, -5512, 1.23},
+           {-6.1, 65.777},
+           {4.2, 24, 324.11},
+           {47.2, 213.23},
+           {79.5, -44.11},
+           {3.1415926, 441.124},
+           {-221.145, 878.43, -11},
+           {93.12, 632},
+           {-4123.11, -177.1},
+           {950.2, -4412},
+           {43.66, 33121.43},
+           {-42.11, -123.43}}),
+      std::make_shared<MapVector>(
+          pool(),
+          MAP(keyVector->type(), valueVector->type()),
+          nullptr,
+          length,
+          offsets,
+          sizes,
+          keyVector,
+          valueVector),
+  });
+
+  const auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_bigint_arr", ARRAY(BIGINT())},
+       {"col_double_arr", ARRAY(DOUBLE())},
+       {"col_map", MAP(BIGINT(), BOOLEAN())}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/custom_delimiters_file");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '|', '#', '\\', true);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  setScanSpec(*type, rowReaderOptions);
+  rowReaderOptions.range(0, 544);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  // Try reading 10 rows each time.
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 10 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+
+  input = std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReaderOptions2 = dwio::common::RowReaderOptions();
+  setScanSpec(*type, rowReaderOptions2);
+  rowReader = reader->createRowReader(rowReaderOptions2);
+  // Try reading 2, 3, 4, 5 rows at a time.
+  ASSERT_EQ(rowReader->next(2, result), 2);
+  for (int i = 0; i < 2; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(3, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 2 + i));
+  }
+  ASSERT_EQ(rowReader->next(4, result), 4);
+  for (int i = 0; i < 4; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 5 + i));
+  }
+  ASSERT_EQ(rowReader->next(5, result), 4);
+  for (int i = 0; i < 4; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 9 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, projectComplexTypesWithCustomDelimiters) {
+  const auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_bigint_arr", ARRAY(BIGINT())},
+       {"col_double_arr", ARRAY(DOUBLE())},
+       {"col_map", MAP(BIGINT(), BOOLEAN())}});
+
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/custom_delimiters_file");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '|', '#', '\\', true);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addField("ds", 0)->setConstantValue(
+      BaseVector::createConstant(VARCHAR(), "2023-07-18", 1, pool()));
+  spec->addField("col_string", 1);
+  spec->addField("col_map", 2);
+
+  dwio::common::RowReaderOptions rowOptions;
+  rowOptions.setScanSpec(spec);
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(
+          type, std::vector<std::string>({"col_string", "col_map"})));
+  auto rowReader = reader->createRowReader(rowOptions);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(13, result), 13);
+  ASSERT_EQ(
+      *result->type(),
+      *ROW(
+          {"ds", "col_string", "col_map"},
+          {VARCHAR(), VARCHAR(), MAP(BIGINT(), BOOLEAN())}));
+
+  const vector_size_t length = 13;
+  const auto keyVector = makeFlatVector<int64_t>(
+      {1,   111,  22, 22222, 333, 33, 44,    5,   555, 66, 7777,     7,
+       777, 8888, 88, 9,     99,  10, 10000, 111, 1,   11, 11122222, 123142});
+  const auto valueVector = makeFlatVector<bool>(
+      {false, true, true,  false, false, true,  false, true,
+       false, true, false, true,  false, false, true,  true,
+       false, true, false, true,  false, true,  true,  true});
+  BufferPtr sizes = facebook::velox::allocateOffsets(length, pool());
+  BufferPtr offsets = facebook::velox::allocateOffsets(length, pool());
+  auto rawSizes = sizes->asMutable<vector_size_t>();
+  auto rawOffsets = offsets->asMutable<vector_size_t>();
+  rawSizes[0] = 2;
+  rawSizes[1] = 2;
+  rawSizes[2] = 2;
+  rawSizes[3] = 1;
+  rawSizes[4] = 2;
+  rawSizes[5] = 1;
+  rawSizes[6] = 3;
+  rawSizes[7] = 2;
+  rawSizes[8] = 2;
+  rawSizes[9] = 2;
+  rawSizes[10] = 3;
+  rawSizes[11] = 1;
+  rawSizes[12] = 1;
+  for (int i = 1; i < length; i++) {
+    rawOffsets[i] = rawOffsets[i - 1] + rawSizes[i - 1];
+  }
+
+  auto expected = makeRowVector({
+      std::make_shared<ConstantVector<StringView>>(
+          pool(), 13, false, VARCHAR(), "2023-07-18"),
+      makeFlatVector<std::string>(
+          {"FOO",
+           "FOO",
+           "FOO",
+           "FOO",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAZ",
+           "BAZ",
+           "BAZ",
+           "FOO\\nBAZ",
+           "FOO\n\nBAR\nBAZ"}),
+      std::make_shared<MapVector>(
+          pool(),
+          MAP(keyVector->type(), valueVector->type()),
+          nullptr,
+          length,
+          offsets,
+          sizes,
+          keyVector,
+          valueVector),
+  });
+
+  ASSERT_EQ(result->size(), expected->size());
+  for (int i = 0; i < 13; ++i) {
+    ASSERT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(TextReaderTest, projectPrimitiveTypes) {
+  auto type = ROW(
+      {{"col_int", INTEGER()},
+       {"col_huge", BIGINT()},
+       {"col_tiny", TINYINT()},
+       {"col_double", DOUBLE()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/simple_types");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  // Test projection of multiple primitive types: VARCHAR, INTEGER, and BOOLEAN
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addField("col_tiny", 0);
+  spec->addField("col_int", 1);
+  spec->addField("col_double", 2);
+
+  dwio::common::RowReaderOptions rowOptions;
+  rowOptions.setScanSpec(spec);
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(
+          type,
+          std::vector<std::string>({"col_tiny", "col_int", "col_double"})));
+  auto rowReader = reader->createRowReader(rowOptions);
+
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(20, result), 16);
+  ASSERT_EQ(
+      *result->type(),
+      *ROW(
+          {"col_tiny", "col_int", "col_double"},
+          {TINYINT(), INTEGER(), DOUBLE()}));
+
+  auto expected = makeRowVector({
+      makeFlatVector<int8_t>({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}),
+      makeFlatVector<int32_t>(
+          {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26}),
+      makeNullableFlatVector<double>(
+          {1.123,
+           2.333,
+           -6.1,
+           4.2,
+           0.0000513,
+           79.5,
+           std::nullopt,
+           3.1415926,
+           93.12,
+           -221.145,
+           std::nullopt,
+           950.2,
+           -4123.11,
+           43.66,
+           std::nullopt,
+           std::nullopt}),
+  });
+
+  ASSERT_EQ(result->size(), expected->size());
+  for (int i = 0; i < 16; ++i) {
+    ASSERT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(TextReaderTest, projectColumns) {
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/",
+      "examples/simple_types_compressed_file.gz");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addField("ds", 0)->setConstantValue(
+      BaseVector::createConstant(VARCHAR(), "2023-07-18", 1, pool()));
+  spec->addField("col_float", 1);
+  dwio::common::RowReaderOptions rowOptions;
+  rowOptions.setScanSpec(spec);
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(
+          type, std::vector<std::string>({"col_float"})));
+  auto rowReader = reader->createRowReader(rowOptions);
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  ASSERT_EQ(*result->type(), *ROW({"ds", "col_float"}, {VARCHAR(), DOUBLE()}));
+  auto expected = makeRowVector({
+      std::make_shared<ConstantVector<StringView>>(
+          pool(), 10, false, VARCHAR(), "2023-07-18"),
+      makeFlatVector<double>(
+          {1.123,
+           2.333,
+           -6.1,
+           4.2,
+           47.2,
+           79.5,
+           3.1415926,
+           -221.145,
+           93.12,
+           -4123.11,
+           950.2,
+           43.66}),
+  });
+  ASSERT_EQ(result->size(), expected->size());
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(TextReaderTest, projectNone) {
+  // Tests the case where none of the columns are projected, e.g. a basic
+  // count(*) query.
+  auto type = ROW(
+      {{"col_int", INTEGER()},
+       {"col_big_int", BIGINT()},
+       {"col_tiny_int", TINYINT()},
+       {"col_double", DOUBLE()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/simple_types");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  // Project none of the columns.
+  setScanSpec(*ROW({}, {}), rowReaderOptions);
+  rowReaderOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(ROW({}, {})));
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr result;
+  // We expect to get 16 rows.
+  ASSERT_EQ(rowReader->next(16, result), 16);
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, compressedProjectNone) {
+  // Tests the case where none of the columns are projected, e.g. a basic
+  // count(*) query.
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/",
+      "examples/simple_types_compressed_file.gz");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  // Project none of the columns.
+  setScanSpec(*ROW({}, {}), rowReaderOptions);
+  rowReaderOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(ROW({}, {})));
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  VectorPtr result;
+  // We expect to get 12 rows.
+  ASSERT_EQ(rowReader->next(12, result), 12);
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, compressedFilter) {
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/",
+      "examples/simple_types_compressed_file.gz");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addField("ds", 0)->setConstantValue(
+      BaseVector::createConstant(VARCHAR(), "2023-07-18", 1, pool()));
+  spec->addField("col_int", 1);
+  spec->getOrCreateChild(common::Subfield("col_string"))
+      ->setFilter(
+          std::make_unique<common::BytesValues>(
+              std::vector<std::string>({"BAR"}), false));
+  dwio::common::RowReaderOptions rowOptions;
+  rowOptions.setScanSpec(spec);
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(type, type->names()));
+  auto rowReader = reader->createRowReader(rowOptions);
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  ASSERT_EQ(*result->type(), *ROW({"ds", "col_int"}, {VARCHAR(), INTEGER()}));
+  auto expected = makeRowVector({
+      std::make_shared<ConstantVector<StringView>>(
+          pool(), 4, false, VARCHAR(), "2023-07-18"),
+      makeFlatVector<int32_t>({5, 6, 7, 8}),
+  });
+  ASSERT_EQ(result->size(), expected->size());
+  for (int i = 0; i < expected->size(); ++i) {
+    ASSERT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(TextReaderTest, filter) {
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_big_int", BIGINT()},
+       {"col_bool", BOOLEAN()},
+       {"col_timestamp", TIMESTAMP()}});
+
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/more_simple_types");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  spec->addField("ds", 0)->setConstantValue(
+      BaseVector::createConstant(VARCHAR(), "2023-07-18", 1, pool()));
+  spec->addField("col_big_int", 1);
+  spec->getOrCreateChild(common::Subfield("col_string"))
+      ->setFilter(
+          std::make_unique<common::BytesValues>(
+              std::vector<std::string>({"BAR", "BAZ"}), false));
+
+  dwio::common::RowReaderOptions rowOptions;
+  rowOptions.setScanSpec(spec);
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(type, type->names()));
+
+  auto rowReader = reader->createRowReader(rowOptions);
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(15, result), 13);
+
+  ASSERT_EQ(
+      *result->type(), *ROW({"ds", "col_big_int"}, {VARCHAR(), BIGINT()}));
+  auto expected = makeRowVector({
+      std::make_shared<ConstantVector<StringView>>(
+          pool(), 7, false, VARCHAR(), "2023-07-18"),
+      makeFlatVector<int64_t>({
+          4192,
+          4193,
+          4192,
+          4192,
+          4194,
+          4192,
+          4195,
+      }),
+  });
+
+  ASSERT_EQ(result->size(), expected->size());
+  for (int i = 0; i < expected->size(); ++i) {
+    ASSERT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(TextReaderTest, shrinkBatch) {
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/simple_types");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  dwio::common::RowReaderOptions rowOptions;
+  rowOptions.setScanSpec(spec);
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(ROW({}, {})));
+  auto rowReader = reader->createRowReader(rowOptions);
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(6, result), 6);
+  ASSERT_EQ(result->size(), 6);
+  ASSERT_EQ(rowReader->next(4, result), 4);
+  ASSERT_EQ(result->size(), 4);
+  ASSERT_EQ(rowReader->next(6, result), 6);
+  ASSERT_EQ(result->size(), 6);
+  ASSERT_EQ(rowReader->next(4, result), 0);
+}
+
+TEST_F(TextReaderTest, compressedShrinkBatch) {
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/",
+      "examples/simple_types_compressed_file.gz");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto spec = std::make_shared<common::ScanSpec>("<root>");
+  dwio::common::RowReaderOptions rowOptions;
+  rowOptions.setScanSpec(spec);
+  rowOptions.select(
+      std::make_shared<dwio::common::ColumnSelector>(ROW({}, {})));
+  auto rowReader = reader->createRowReader(rowOptions);
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(6, result), 6);
+  ASSERT_EQ(result->size(), 6);
+  ASSERT_EQ(rowReader->next(4, result), 4);
+  ASSERT_EQ(result->size(), 4);
+  ASSERT_EQ(rowReader->next(4, result), 2);
+  ASSERT_EQ(result->size(), 2);
+  ASSERT_EQ(rowReader->next(4, result), 0);
+}
+
+TEST_F(TextReaderTest, emptyFile) {
+  auto type = ROW({
+      {"transaction_id", VARCHAR()},
+      {"serial_number", VARCHAR()},
+  });
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/empty.gz");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  setScanSpec(*type, rowReaderOptions);
+  rowReaderOptions.setSkipRows(1);
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+  EXPECT_EQ(*reader->rowType(), *type);
+  VectorPtr result;
+  // Try reading 10 rows each time.
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, readRanges) {
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>(
+           {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25}),
+       makeFlatVector<int64_t>({
+           4191,
+           4192,
+           4192,
+           4196,
+           4192,
+           4193,
+           4192,
+           4192,
+           4194,
+           4192,
+           4195,
+           4192,
+           4192,
+           4192,
+           4192,
+       }),
+       makeFlatVector<int8_t>({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})});
+
+  auto type =
+      ROW({{"id", BIGINT()}, {"org_id", BIGINT()}, {"deleted", TINYINT()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/",
+      "examples/simple_types_10_bytes_per_row");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  const int bytesPerRows = 10;
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  VectorPtr result;
+
+  // read from 1st row to 6th row
+  rowReaderOptions.range(0, 5 * bytesPerRows);
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  uint64_t scanned = rowReader->next(1024, result);
+  EXPECT_EQ(scanned, 6);
+  for (int i = 0; i < 6; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+
+  // read from 6th row to 10th row
+  rowReaderOptions.range(5 * bytesPerRows, 5 * bytesPerRows);
+  setScanSpec(*type, rowReaderOptions);
+  rowReader = reader->createRowReader(rowReaderOptions);
+  scanned = rowReader->next(1024, result);
+  EXPECT_EQ(scanned, 5);
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 6 + i));
+  }
+
+  // read from 11th row to 15th row
+  rowReaderOptions.range(10 * bytesPerRows, 5 * bytesPerRows);
+  setScanSpec(*type, rowReaderOptions);
+  rowReader = reader->createRowReader(rowReaderOptions);
+  scanned = rowReader->next(1024, result);
+  EXPECT_EQ(scanned, 4);
+  for (int i = 0; i < 4; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 11 + i));
+  }
+}
+
+TEST_F(TextReaderTest, readFloatAsInt) {
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>(
+          {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26}),
+      makeFlatVector<int64_t>(
+          {4191,
+           4192,
+           4192,
+           4196,
+           4192,
+           4193,
+           4192,
+           4192,
+           4194,
+           4192,
+           4195,
+           4192,
+           4192,
+           4192,
+           4192,
+           4192,
+           4192}),
+      makeFlatVector<int8_t>({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}),
+      makeNullableFlatVector<int32_t>(
+          {1,
+           2,
+           -6,
+           4,
+           std::nullopt,
+           79,
+           std::nullopt,
+           3,
+           93,
+           -221,
+           std::nullopt,
+           950,
+           -4123,
+           43,
+           std::nullopt,
+           std::nullopt}),
+  });
+
+  auto type = ROW(
+      {{"id", INTEGER()},
+       {"org_id", BIGINT()},
+       {"deleted", TINYINT()},
+       {"ratio", INTEGER()}});
+
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/simple_types");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(6, result), 6);
+  for (int i = 0; i < 6; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 10 + i));
+  }
+}
+
+TEST_F(TextReaderTest, simpleTypes) {
+  const auto tzOffsetPST = 28'800;
+  const auto tzOffsetPDT = 25'200;
+
+  auto expected = makeRowVector({
+      makeFlatVector<std::string>(
+          {"FOO",
+           "FOO",
+           "FOO",
+           "FOO",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAZ",
+           "BAZ",
+           "BAZ",
+           "FOO",
+           "FOOBARBAZ"}),
+      makeFlatVector<int64_t>(
+          {4191,
+           4192,
+           4192,
+           4196,
+           4192,
+           4193,
+           4192,
+           4192,
+           4194,
+           4192,
+           4195,
+           4192,
+           4192}),
+      makeFlatVector<bool>(
+          {true,
+           true,
+           true,
+           true,
+           true,
+           true,
+           false,
+           false,
+           false,
+           false,
+           true,
+           false,
+           true}),
+      makeNullableFlatVector<Timestamp>(
+          {Timestamp{1'695'378'095 + tzOffsetPDT, 148'000'000},
+           Timestamp{1'695'690'351 + tzOffsetPDT, 0},
+           Timestamp{1'695'686'400 + tzOffsetPDT, 0},
+           Timestamp{1'695'083'400 + tzOffsetPDT, 0},
+           std::nullopt,
+           Timestamp{1'695'657'091 + tzOffsetPDT, 209'000'000},
+           Timestamp{1'695'690'437 + tzOffsetPDT, 469'123'000},
+           Timestamp{1'696'540'679 + tzOffsetPDT, 976'000'000},
+           Timestamp{1'695'657'171 + tzOffsetPDT, 637'000'000},
+           Timestamp{1'695'693'225 + tzOffsetPDT, 745'123'000},
+           std::nullopt,
+           Timestamp{1'695'406'246 + tzOffsetPDT, 0},
+           Timestamp{1'699'392'124 + tzOffsetPST, 736'000'000}}),
+  });
+
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_big_int", BIGINT()},
+       {"col_bool", BOOLEAN()},
+       {"col_timestamp", TIMESTAMP()}});
+
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/more_simple_types");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(11, result), 11);
+  for (int i = 0; i < 11; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(6, result), 2);
+  for (int i = 0; i < 2; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 11 + i));
+  }
+}
+
+TEST_F(TextReaderTest, primitiveLimitsStressTest) {
+  // Create expected vectors with 100 min values followed by 100 max values
+  std::vector<int8_t> tinyintValues;
+  std::vector<int32_t> integerValues;
+  std::vector<int64_t> bigintValues;
+
+  // Add 100 minimum values
+  for (int i = 0; i < 100; ++i) {
+    tinyintValues.push_back(std::numeric_limits<int8_t>::min());
+    integerValues.push_back(std::numeric_limits<int32_t>::min());
+    bigintValues.push_back(std::numeric_limits<int64_t>::min());
+  }
+
+  // Add 100 maximum values
+  for (int i = 0; i < 100; ++i) {
+    tinyintValues.push_back(std::numeric_limits<int8_t>::max());
+    integerValues.push_back(std::numeric_limits<int32_t>::max());
+    bigintValues.push_back(std::numeric_limits<int64_t>::max());
+  }
+
+  auto expected = makeRowVector(
+      {makeFlatVector<int8_t>(tinyintValues),
+       makeFlatVector<int32_t>(integerValues),
+       makeFlatVector<int64_t>(bigintValues)});
+
+  auto type = ROW(
+      {{"col_tinyint", TINYINT()},
+       {"col_integer", INTEGER()},
+       {"col_bigint", BIGINT()}});
+
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/primitive_limits");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '=', '|', '\\', true);
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  // Test reading all 200 rows at once
+  ASSERT_EQ(rowReader->next(250, result), 200);
+  for (int i = 0; i < 200; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+
+  // Test reading in smaller batches
+  input = std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  reader = factory->createReader(std::move(input), readerOptions);
+  rowReader = reader->createRowReader(rowReaderOptions);
+
+  ASSERT_EQ(rowReader->next(50, result), 50);
+  for (int i = 0; i < 50; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(75, result), 75);
+  for (int i = 0; i < 75; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 50 + i));
+  }
+  ASSERT_EQ(rowReader->next(100, result), 75);
+  for (int i = 0; i < 75; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 125 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, DISABLED_nestedComplexTypesWithCustomDelimiters) {
+  // Inner maps for the arrays
+  const auto innerMapKeys1 = makeFlatVector<int64_t>({1, 11, 22});
+  const auto innerMapValues1 = makeFlatVector<bool>({true, false, true});
+  const auto innerMapKeys2 = makeFlatVector<int64_t>({33, 44});
+  const auto innerMapValues2 = makeFlatVector<bool>({false, true});
+  const auto innerMapKeys3 = makeFlatVector<int64_t>({55, 66, 77, 88});
+  const auto innerMapValues3 = makeFlatVector<bool>({true, true, false, true});
+  const auto innerMapKeys4 = makeFlatVector<int64_t>(std::vector<int64_t>{99});
+  const auto innerMapValues4 = makeFlatVector<bool>(std::vector<bool>{false});
+  const auto innerMapKeys5 = makeFlatVector<int64_t>({100, 200});
+  const auto innerMapValues5 = makeFlatVector<bool>({true, false});
+  const auto innerMapKeys6 = makeFlatVector<int64_t>({300, 400, 500});
+  const auto innerMapValues6 = makeFlatVector<bool>({false, false, true});
+
+  // Combine all inner map keys and values
+  const auto allInnerMapKeys = makeFlatVector<int64_t>(
+      {1, 11, 22, 33, 44, 55, 66, 77, 88, 99, 100, 200, 300, 400, 500});
+  const auto allInnerMapValues = makeFlatVector<bool>(
+      {true,
+       false,
+       true,
+       false,
+       true,
+       true,
+       true,
+       false,
+       true,
+       false,
+       true,
+       false,
+       false,
+       false,
+       true});
+
+  // Create inner maps with proper offsets and sizes
+  BufferPtr innerMapSizes = allocateOffsets(6, pool());
+  BufferPtr innerMapOffsets = allocateOffsets(6, pool());
+  auto rawInnerMapSizes = innerMapSizes->asMutable<vector_size_t>();
+  auto rawInnerMapOffsets = innerMapOffsets->asMutable<vector_size_t>();
+
+  rawInnerMapSizes[0] = 3; // {1:true, 11:false, 22:true}
+  rawInnerMapSizes[1] = 2; // {33:false, 44:true}
+  rawInnerMapSizes[2] = 4; // {55:true, 66:true, 77:false, 88:true}
+  rawInnerMapSizes[3] = 1; // {99:false}
+  rawInnerMapSizes[4] = 2; // {100:true, 200:false}
+  rawInnerMapSizes[5] = 3; // {300:false, 400:false, 500:true}
+
+  rawInnerMapOffsets[0] = 0;
+  for (int i = 1; i < 6; i++) {
+    rawInnerMapOffsets[i] = rawInnerMapOffsets[i - 1] + rawInnerMapSizes[i - 1];
+  }
+
+  auto innerMapsVector = std::make_shared<MapVector>(
+      pool(),
+      MAP(BIGINT(), BOOLEAN()),
+      nullptr,
+      6,
+      innerMapOffsets,
+      innerMapSizes,
+      allInnerMapKeys,
+      allInnerMapValues);
+
+  // Create arrays containing the inner maps
+  // Array 1: [innerMap0, innerMap1] (maps at indices 0, 1)
+  // Array 2: [innerMap2, innerMap3, innerMap4] (maps at indices 2, 3, 4)
+  // Array 3: [innerMap5] (map at index 5)
+  auto arrayVector = makeArrayVector({0, 2, 5, 6}, innerMapsVector);
+
+  // Create the outer map keys
+  const auto outerMapKeys = makeFlatVector<int64_t>({10, 20, 30});
+
+  // Create the final data structure
+  auto outerMapOffsets = allocateOffsets(3, pool());
+  auto outerMapSizes = allocateOffsets(3, pool());
+  auto rawOuterMapOffsets = outerMapOffsets->asMutable<vector_size_t>();
+  auto rawOuterMapSizes = outerMapSizes->asMutable<vector_size_t>();
+
+  // Set offsets: [0, 1, 2]
+  rawOuterMapOffsets[0] = 0;
+  rawOuterMapOffsets[1] = 1;
+  rawOuterMapOffsets[2] = 2;
+
+  // Set sizes: [1, 1, 1] (each outer map entry contains 1 array)
+  rawOuterMapSizes[0] = 1;
+  rawOuterMapSizes[1] = 1;
+  rawOuterMapSizes[2] = 1;
+
+  const auto expected = makeRowVector({std::make_shared<MapVector>(
+      pool(),
+      MAP(BIGINT(), ARRAY(MAP(BIGINT(), BOOLEAN()))),
+      nullptr,
+      3,
+      outerMapOffsets,
+      outerMapSizes,
+      outerMapKeys,
+      arrayVector)});
+
+  const auto type =
+      ROW({{"col_nested_map", MAP(BIGINT(), ARRAY(MAP(BIGINT(), BOOLEAN())))}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/",
+      "examples/custom_delimiter_nested_complex_types");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  // Set up custom delimiters:
+  // - Tab ('\t') for field separation (depth 0)
+  // - Pipe ('|') for array element separation (depth 1)
+  // - Hash ('#') for map key-value separation (depth 2)
+  // - ',' for inner map key-value pair separation (depth 3)
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '=', '|', '\\', true);
+  serDeOptions.separators[3] = ',';
+  serDeOptions.separators[4] = ':';
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  // Read all 3 rows
+  ASSERT_EQ(rowReader->next(10, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, nestedArraysWithCustomDelimiters) {
+  // Create expected nested array structure
+  // Row 1: [[1,2,3], [4,5], [6,7,8,9]]
+  // Row 2: [[10,20], [30,40,50], [60]]
+  // Row 3: [[100], [200,300,400], [500,600]]
+
+  // Create inner arrays for each row
+  auto innerArraysRow1 =
+      makeArrayVector<int64_t>({{1, 2, 3}, {4, 5}, {6, 7, 8, 9}});
+  auto innerArraysRow2 =
+      makeArrayVector<int64_t>({{10, 20}, {30, 40, 50}, {60}});
+  auto innerArraysRow3 =
+      makeArrayVector<int64_t>({{100}, {200, 300, 400}, {500, 600}});
+
+  // Combine all inner arrays into a single vector
+  auto allInnerArrays = makeArrayVector<int64_t>({
+      {1, 2, 3},
+      {4, 5},
+      {6, 7, 8, 9}, // Row 1 inner arrays
+      {10, 20},
+      {30, 40, 50},
+      {60}, // Row 2 inner arrays
+      {100},
+      {200, 300, 400},
+      {500, 600} // Row 3 inner arrays
+  });
+
+  // Create the outer array structure with proper offsets
+  // Row 1: uses inner arrays 0, 1, 2
+  // Row 2: uses inner arrays 3, 4, 5
+  // Row 3: uses inner arrays 6, 7, 8
+  auto outerArray = makeArrayVector({0, 3, 6, 9}, allInnerArrays);
+
+  const auto expected = makeRowVector({outerArray});
+
+  const auto type = ROW({{"col_nested_array", ARRAY(ARRAY(BIGINT()))}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/nested_arrays_file");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  // Set up custom delimiters for nested arrays:
+  // - Tab ('\t') for field separation (depth 0) - not used in single-column
+  // case
+  // - Pipe ('|') for outer array element separation (depth 1)
+  // - Comma (',') for inner array element separation (depth 2)
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '|', ',', '\\', true);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  // Read all 3 rows
+  ASSERT_EQ(rowReader->next(10, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, tripleNestedArraysWithCustomDelimiters) {
+  // Create expected triple nested array structure
+  // Row 1: [[[1,2], [3,4]], [[5,6,7], [8,9]], [[10,11,12,13], [14,15]]]
+  // Row 2: [[[20,21], [22,23,24]], [[25,26]], [[27,28,29], [30,31,32]]]
+  // Row 3: [[[100,101,102]], [[200,201], [300,301,302,303]], [[400,401,402],
+  // [500,501]]]
+
+  // Create the innermost arrays (level 3)
+  auto innermostArrays = makeArrayVector<int64_t>({
+      {1, 2},
+      {3, 4}, // Row 1, outer array 0
+      {5, 6, 7},
+      {8, 9}, // Row 1, outer array 1
+      {10, 11, 12, 13},
+      {14, 15}, // Row 1, outer array 2
+      {20, 21},
+      {22, 23, 24}, // Row 2, outer array 0
+      {25, 26}, // Row 2, outer array 1
+      {27, 28, 29},
+      {30, 31, 32}, // Row 2, outer array 2
+      {100, 101, 102}, // Row 3, outer array 0
+      {200, 201},
+      {300, 301, 302, 303}, // Row 3, outer array 1
+      {400, 401, 402},
+      {500, 501} // Row 3, outer array 2
+  });
+
+  // Create middle level arrays (level 2) - each contains innermost arrays
+  auto middleArrays = makeArrayVector(
+      {
+          0, // Row 1, outer array 0: contains innermost arrays [0,1]
+          2, // Row 1, outer array 1: contains innermost arrays [2,3]
+          4, // Row 1, outer array 2: contains innermost arrays [4,5]
+          6, // Row 2, outer array 0: contains innermost arrays [6,7]
+          8, // Row 2, outer array 1: contains innermost arrays [8]
+          9, // Row 2, outer array 2: contains innermost arrays [9,10]
+          11, // Row 3, outer array 0: contains innermost arrays [11]
+          12, // Row 3, outer array 1: contains innermost arrays [12,13]
+          14, // Row 3, outer array 2: contains innermost arrays [14,15]
+          16 // End marker
+      },
+      innermostArrays);
+
+  // Create outermost arrays (level 1) - each row contains middle arrays
+  auto outerArray = makeArrayVector(
+      {
+          0, 3, 6, 9 // Row boundaries: Row 1 [0-2], Row 2 [3-5], Row 3 [6-8]
+      },
+      middleArrays);
+
+  const auto expected = makeRowVector({outerArray});
+
+  const auto type =
+      ROW({{"col_triple_nested_array", ARRAY(ARRAY(ARRAY(BIGINT())))}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/triple_nested_arrays_file");
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  // Set up custom delimiters for triple nested arrays:
+  // - Tab ('\t') for field separation (depth 0) - not used in single-column
+  // case
+  // - Pipe ('|') for outermost array element separation (depth 1)
+  // - Comma (',') for middle array element separation (depth 2)
+  // - Hash ('#') for innermost array element separation (depth 3)
+  auto serDeOptions = dwio::common::SerDeOptions('\t', '|', ',', '\\', true);
+  serDeOptions.separators[3] = '#';
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  auto rowReaderOptions = dwio::common::RowReaderOptions();
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  // Read all 3 rows
+  ASSERT_EQ(rowReader->next(10, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextReaderTest, varbinarySuccessfulDecoding) {
+  // Test successful Base64 decoding for VARBINARY type
+
+  auto type = ROW({{"col_binary", VARBINARY()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/varbinary");
+
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(10, result), 2);
+
+  auto rowVector = std::static_pointer_cast<RowVector>(result);
+  auto binaryVector = rowVector->childAt(0)->as<FlatVector<StringView>>();
+
+  // Verify the decoded binary data
+  EXPECT_EQ(binaryVector->valueAt(0), StringView("Hello World"));
+  EXPECT_EQ(binaryVector->valueAt(1), StringView("TestData"));
+}
+
+TEST_F(TextReaderTest, varbinaryUnsuccessfulDecoding) {
+  // Test unsuccessful Base64 decoding for VARBINARY type
+
+  auto type = ROW({{"col_binary", VARBINARY()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/varbinary_unsuccessful");
+
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(10, result), 2);
+
+  auto rowVector = std::static_pointer_cast<RowVector>(result);
+  auto binaryVector = rowVector->childAt(0)->as<FlatVector<StringView>>();
+
+  // Verify the data was copied as-is (fallback behavior)
+  // When Base64 decoding fails, the original string is copied directly
+  EXPECT_EQ(binaryVector->valueAt(0), StringView("InvalidBase64!"));
+  EXPECT_EQ(binaryVector->valueAt(1), StringView("Another@Invalid#String"));
+}
+
+TEST_F(TextReaderTest, logicalTypes) {
+  auto expected = makeRowVector(
+      {makeNullableFlatVector<int64_t>(
+           {0,
+            123,
+            -1234567,
+            999999999999999,
+            std::nullopt,
+            4242,
+            -1,
+            std::nullopt,
+            314159265358979,
+            77777,
+            100000000000000,
+            -5432199,
+            std::nullopt,
+            1234,
+            -999999999999999,
+            999999999999999},
+           DECIMAL(15, 2)),
+       makeNullableFlatVector<int128_t>(
+           {0,
+            HugeInt::parse("999999999999999999999"),
+            HugeInt::parse("123456789012345678901234567890"),
+            HugeInt::parse("-99999999999999999999999999"),
+            HugeInt::parse("88888888888888888888"),
+            std::nullopt,
+            1,
+            std::nullopt,
+            HugeInt::parse("27182818284590452353612"),
+            HugeInt::parse("-123456789012345678999"),
+            HugeInt::parse("12345678901234567890123456789012345678"),
+            987654321012,
+            std::nullopt,
+            5678,
+            -123,
+            HugeInt::parse("99999999999999999999999999999999")},
+           DECIMAL(38, 2)),
+       makeNullableFlatVector<int32_t>(
+           {
+               parseDate("1970-01-01"),
+               parseDate("2024-02-29"),
+               parseDate("1900-01-01"),
+               parseDate("2099-12-31"),
+               parseDate("2001-09-11"),
+               parseDate("2025-09-10"),
+               std::nullopt,
+               std::nullopt,
+               parseDate("1999-12-31"),
+               parseDate("2012-12-21"),
+               parseDate("2200-01-01"),
+               parseDate("1988-08-08"),
+               parseDate("1969-07-20"),
+               parseDate("2000-01-01"),
+               parseDate("1800-06-15"),
+               parseDate("2500-12-31"),
+           },
+           DATE())});
+
+  auto type =
+      ROW({{"c0", DECIMAL(15, 2)}, {"c1", DECIMAL(38, 2)}, {"c2", DATE()}});
+
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/logical_types.gz");
+
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 6);
+  for (int i = 0; i < 6; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 10 + i));
+  }
+}
+
+TEST_F(TextReaderTest, nestedRows) {
+  auto nestedRowChildren = std::vector<VectorPtr>{
+      makeFlatVector<int32_t>({42, 100, -5, 0, 999}),
+      makeFlatVector<bool>({true, false, true, false, true}),
+      makeArrayVector<double>(
+          {{3.14159, 2.71828},
+           {2.71828, 1.41421, 0.0},
+           {1.41421, -123.456},
+           {0.0, 999.999},
+           {-123.456, 42.0, 3.14159}})};
+  auto nestedRowVector = makeRowVector(
+      {"nested_int", "nested_bool", "nested_arr_double"}, nestedRowChildren);
+
+  const auto expected = makeRowVector(
+      {makeFlatVector<std::string>(
+           {"hello", "world", "test", "sample", "data"}),
+       nestedRowVector,
+       makeFlatVector<bool>({false, true, false, true, false})});
+
+  auto type = ROW(
+      {{"col_varchar", VARCHAR()},
+       {"col_nested_row",
+        ROW(
+            {{"nested_int", INTEGER()},
+             {"nested_bool", BOOLEAN()},
+             {"nested_arr_double", ARRAY(DOUBLE())}})},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path = velox::test::getDataFilePath(
+      "velox/dwio/text/tests/reader/", "examples/nested_row");
+
+  auto readFile = std::make_shared<LocalReadFile>(path);
+  auto serDeOptions = dwio::common::SerDeOptions('&', ',', '#', '\\', true);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(10, result), 5);
+
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_P(TextReaderDecompressionTest, tests) {
+  auto [filepath, format] = GetParam();
+  auto expected = makeRowVector({
+      makeFlatVector<std::string>(
+          {"FOO",
+           "FOO",
+           "FOO",
+           "FOO",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAR",
+           "BAZ",
+           "BAZ",
+           "BAZ",
+           "BAZ"}),
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
+      makeFlatVector<double>(
+          {1.123,
+           2.333,
+           -6.1,
+           4.2,
+           47.2,
+           79.5,
+           3.1415926,
+           -221.145,
+           93.12,
+           -4123.11,
+           950.2,
+           43.66}),
+      makeFlatVector<bool>(
+          {true,
+           true,
+           false,
+           true,
+           false,
+           false,
+           true,
+           true,
+           false,
+           false,
+           false,
+           true}),
+  });
+
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+
+  auto path =
+      velox::test::getDataFilePath("velox/dwio/text/tests/reader/", filepath);
+  auto readFile = std::make_shared<LocalReadFile>(path);
+
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(type);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = factory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*type, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *type);
+
+  VectorPtr result;
+
+  // Try reading 10 rows each time.
+  ASSERT_EQ(rowReader->next(10, result), 10);
+  for (int i = 0; i < 10; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 2);
+  for (int i = 0; i < 2; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 10 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+
+  input = std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  reader = factory->createReader(std::move(input), readerOptions);
+  rowReader = reader->createRowReader(rowReaderOptions);
+  // Try reading 2, 3, 4, 5 rows at a time.
+  ASSERT_EQ(rowReader->next(2, result), 2);
+  for (int i = 0; i < 2; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(3, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 2 + i));
+  }
+  ASSERT_EQ(rowReader->next(4, result), 4);
+  for (int i = 0; i < 4; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 5 + i));
+  }
+  ASSERT_EQ(rowReader->next(5, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, 9 + i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+std::vector<TestCompressionParam> params = {
+    {"examples/simple_types_compressed_file.deflate", "deflate"},
+    {"examples/simple_types_compressed_file.zst", "zstd"}};
+
+INSTANTIATE_TEST_SUITE_P(
+    TextReaderDecompressionTests,
+    TextReaderDecompressionTest,
+    testing::ValuesIn(params),
+    [](const auto& paramInfo) { return paramInfo.param.compression; });
+
+TEST_F(TextReaderTest, unsupportedCompressedKind) {
+  auto type = ROW(
+      {{"col_string", VARCHAR()},
+       {"col_int", INTEGER()},
+       {"col_float", DOUBLE()},
+       {"col_bool", BOOLEAN()}});
+  auto factory = dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  const std::string kBaseDir = "velox/dwio/text/tests/reader/";
+  std::vector paths = {
+      getDataFilePath(kBaseDir, "examples/simple_types_compressed_file.lz4"),
+      getDataFilePath(kBaseDir, "examples/simple_types_compressed_file.lzo"),
+      getDataFilePath(
+          kBaseDir, "examples/simple_types_compressed_file.snappy")};
+  for (const auto& path : paths) {
+    auto readFile = std::make_shared<LocalReadFile>(path);
+    auto readerOptions = dwio::common::ReaderOptions(pool());
+    readerOptions.setFileSchema(type);
+    auto input =
+        std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+    EXPECT_THROW(
+        factory->createReader(std::move(input), readerOptions),
+        VeloxRuntimeError);
+  }
+}
+
+} // namespace
+
+} // namespace facebook::velox::text
diff --git a/velox/dwio/text/tests/reader/examples/custom_delimiter_nested_complex_types b/velox/dwio/text/tests/reader/examples/custom_delimiter_nested_complex_types
new file mode 100644
index 000000000000..3e8ef4177cc7
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/custom_delimiter_nested_complex_types
@@ -0,0 +1,3 @@
+10=1:true,11:false,22:true|33:false,44:true
+20=55:true,66:true,77:false,88:true|99:false|100:true,200:false
+30=300:false,400:false,500:true
diff --git a/velox/dwio/text/tests/reader/examples/custom_delimiters_file b/velox/dwio/text/tests/reader/examples/custom_delimiters_file
new file mode 100644
index 000000000000..6913c764383f
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/custom_delimiters_file
@@ -0,0 +1,13 @@
+FOO	1|11|111	1.123|1.3123	1#false|111#true
+FOO	22|22222	2.333|-5512|1.23	22#true|22222#false
+FOO	333|33	-6.1|65.777	333#false|33#true
+FOO	4444|44	4.2|24|324.11	44#false
+BAR	5|555	47.2|213.23	5#true|555#false
+BAR	666|66|66	79.5|-44.11	66#true
+BAR	7777|7|777	3.1415926|441.124	7777#false|7#true|777#false
+BAR	8888|88	-221.145|878.43|-11	8888#false|88#true
+BAZ	9|99	93.12|632	9#true|99#false
+BAZ	10|10000	-4123.11|-177.1	10#true|10000#false
+BAZ	111|1|111	950.2|-4412	111#true|1#false|11#true
+FOO\\nBAZ	12|11122222|222	43.66|33121.43	11122222#true
+FOO\n\nBAR\nBAZ	13|11133333|333	-42.11|-123.43	123142#true
diff --git a/velox/dwio/text/tests/reader/examples/empty.gz b/velox/dwio/text/tests/reader/examples/empty.gz
new file mode 100644
index 000000000000..048927fa6500
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/empty.gz differ
diff --git a/velox/dwio/text/tests/reader/examples/logical_types.gz b/velox/dwio/text/tests/reader/examples/logical_types.gz
new file mode 100644
index 000000000000..3a20dc8ceeef
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/logical_types.gz differ
diff --git a/velox/dwio/text/tests/reader/examples/more_simple_types b/velox/dwio/text/tests/reader/examples/more_simple_types
new file mode 100644
index 000000000000..674f64b8725a
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/more_simple_types
@@ -0,0 +1,13 @@
+FOO
4191
true
2023-09-22 10:21:35.148
+FOO
4192
true
2023-09-26 01:05:51.000
+FOO
4192
true
2023-09-26
+FOO
4196
true
2023-09-19 00:30:00
+BAR
4192
true

+BAR
4193
true
2023-09-25 15:51:31.209
+BAR
4192
false
2023-09-26 01:07:17.469123
+BAR
4192
false
2023-10-05 21:17:59.976
+BAZ
4194
false
2023-09-25 15:52:51.637
+BAZ
4192
false
2023-09-26 01:53:45.745123456
+BAZ
4195
TRUE

+FOO
4192
FALSE
2023-09-22 18:10:46.000000001
+FOOBARBAZ
4192
TRUE
2023-11-07 21:22:04.736
diff --git a/velox/dwio/text/tests/reader/examples/nested_arrays_file b/velox/dwio/text/tests/reader/examples/nested_arrays_file
new file mode 100644
index 000000000000..af9a7919a099
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/nested_arrays_file
@@ -0,0 +1,3 @@
+1,2,3|4,5|6,7,8,9
+10,20|30,40,50|60
+100|200,300,400|500,600
diff --git a/velox/dwio/text/tests/reader/examples/nested_row b/velox/dwio/text/tests/reader/examples/nested_row
new file mode 100644
index 000000000000..98c65a885aa7
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/nested_row
@@ -0,0 +1,5 @@
+hello&42,true,3.14159#2.71828&false
+world&100,false,2.71828#1.41421#.0&true
+test&-5,true,1.41421#-123.456&false
+sample&0,false,.0#999.999&true
+data&999,true,-123.456#42.0#3.14159&false
diff --git a/velox/dwio/text/tests/reader/examples/primitive_limits b/velox/dwio/text/tests/reader/examples/primitive_limits
new file mode 100644
index 000000000000..064cd7799ba5
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/primitive_limits
@@ -0,0 +1,200 @@
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+-128	-2147483648	-9223372036854775808
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
+127	2147483647	9223372036854775807
diff --git a/velox/dwio/text/tests/reader/examples/simple_types b/velox/dwio/text/tests/reader/examples/simple_types
new file mode 100644
index 000000000000..6a102f6446bb
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/simple_types
@@ -0,0 +1,16 @@
+11
4191
0
1.123
+12
4192
0
2.333
+13
4192
0
-6.1
+14
4196
0
4.2
+15
4192
0
5.13e-05
+16
4193
0
79.5
+17
4192
0

+18
4192
0
3.1415926
+19
4194
0
93.12
+20
4192
0
-221.145
+21
4195
0

+22
4192
0
950.2
+23
4192
0
-4123.11
+24
4192
0
43.66
+25
4192
0

+26
4192
0
54.aa
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_10_bytes_per_row b/velox/dwio/text/tests/reader/examples/simple_types_10_bytes_per_row
new file mode 100644
index 000000000000..bef0c0eafb8e
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/simple_types_10_bytes_per_row
@@ -0,0 +1,15 @@
+11
4191
0
+12
4192
0
+13
4192
0
+14
4196
0
+15
4192
0
+16
4193
0
+17
4192
0
+18
4192
0
+19
4194
0
+20
4192
0
+21
4195
0
+22
4192
0
+23
4192
0
+24
4192
0
+25
4192
0
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.deflate b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.deflate
new file mode 100644
index 000000000000..5f34cf5e6e46
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.deflate
@@ -0,0 +1,2 @@
+U�I�0P�m����l%�B�Tʦ�?F
5,�<|�m��Eq���B�(R&F[�#��u��u� �T�

+��ث�k�$��?;QQc�u�g$���yTF������
o
\ No newline at end of file
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.gz b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.gz
new file mode 100644
index 000000000000..fd1eb227accf
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.gz differ
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lz4 b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lz4
new file mode 100644
index 000000000000..fa1adc4234d1
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lz4 differ
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lzo b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lzo
new file mode 100644
index 000000000000..951ed722424a
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.lzo differ
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.snappy b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.snappy
new file mode 100644
index 000000000000..3343cdfc53ea
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.snappy differ
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.zst b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.zst
new file mode 100644
index 000000000000..fbeda9616019
Binary files /dev/null and b/velox/dwio/text/tests/reader/examples/simple_types_compressed_file.zst differ
diff --git a/velox/dwio/text/tests/reader/examples/simple_types_with_header b/velox/dwio/text/tests/reader/examples/simple_types_with_header
new file mode 100644
index 000000000000..6403c7678819
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/simple_types_with_header
@@ -0,0 +1,14 @@
+name
id
price
date
+FOO
1
 1.123 
2023-09-22 10:21:35.148
+FOO
2
  2.333
2023-09-26 01:05:51.000
+FOO
3
-6.1
2023-09-26
+FOO
4
4.2
2023-09-19 00:30:00
+BAR
5
 47.2 

+BAR
6
79.5
2023-09-25 15:51:31.209
+BAR
7
3.1415926		  
2023-09-26 01:07:17.469123
+BAR
8
-221.145
2023-10-05 21:17:59.976
+BAZ
9
93.12
2023-09-25 15:52:51.637
+BAZ
10
 	-4123.11  
2023-09-26 01:53:45.745123456
+BAZ
11
950.2

+BAZ
12
43.66
2023-09-22 18:10:46.000000001
+
13

2023-11-07 21:22:04.736
diff --git a/velox/dwio/text/tests/reader/examples/triple_nested_arrays_file b/velox/dwio/text/tests/reader/examples/triple_nested_arrays_file
new file mode 100644
index 000000000000..6f0e3e5b9a86
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/triple_nested_arrays_file
@@ -0,0 +1,3 @@
+1#2,3#4|5#6#7,8#9|10#11#12#13,14#15
+20#21,22#23#24|25#26|27#28#29,30#31#32
+100#101#102|200#201,300#301#302#303|400#401#402,500#501
diff --git a/velox/dwio/text/tests/reader/examples/varbinary b/velox/dwio/text/tests/reader/examples/varbinary
new file mode 100644
index 000000000000..5888f62049e9
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/varbinary
@@ -0,0 +1,2 @@
+SGVsbG8gV29ybGQ=
+VGVzdERhdGE=
diff --git a/velox/dwio/text/tests/reader/examples/varbinary_unsuccessful b/velox/dwio/text/tests/reader/examples/varbinary_unsuccessful
new file mode 100644
index 000000000000..3bf6b863db2b
--- /dev/null
+++ b/velox/dwio/text/tests/reader/examples/varbinary_unsuccessful
@@ -0,0 +1,2 @@
+InvalidBase64!
+Another@Invalid#String
diff --git a/velox/dwio/text/tests/writer/BufferedWriterSinkTest.cpp b/velox/dwio/text/tests/writer/BufferedWriterSinkTest.cpp
index fb86463f36ea..a7372b7b6a74 100644
--- a/velox/dwio/text/tests/writer/BufferedWriterSinkTest.cpp
+++ b/velox/dwio/text/tests/writer/BufferedWriterSinkTest.cpp
@@ -15,10 +15,8 @@
  */
 
 #include <gtest/gtest.h>
-#include "velox/common/base/Fs.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/dwio/text/tests/writer/FileReaderUtil.h"
-#include "velox/dwio/text/writer/TextWriter.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -46,30 +44,40 @@ class BufferedWriterSinkTest : public testing::Test,
 };
 
 TEST_F(BufferedWriterSinkTest, write) {
-  auto filePath = fs::path(
-      fmt::format("{}/test_buffered_writer.txt", tempPath_->getPath()));
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_buffered_writer.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
   auto sink = std::make_unique<dwio::common::LocalFileSink>(
       filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
   auto bufferedWriterSink = std::make_unique<BufferedWriterSink>(
       std::move(sink), rootPool_->addLeafChild("bufferedWriterSinkTest"), 15);
+
   bufferedWriterSink->write("hello world", 10);
   bufferedWriterSink->write("this is writer", 10);
   bufferedWriterSink->close();
-  std::string result = readFile(filePath);
-  EXPECT_EQ(result.size(), 20);
+
+  uint64_t result = readFile(tempPath, filename);
+  EXPECT_EQ(result, 20);
 }
 
 TEST_F(BufferedWriterSinkTest, abort) {
-  auto filePath =
-      fs::path(fmt::format("{}/test_buffered_abort.txt", tempPath_->getPath()));
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_buffered_abort.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
   auto sink = std::make_unique<dwio::common::LocalFileSink>(
       filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
   auto bufferedWriterSink = std::make_unique<BufferedWriterSink>(
       std::move(sink), rootPool_->addLeafChild("bufferedWriterSinkTest"), 15);
+
   bufferedWriterSink->write("hello world", 10);
   bufferedWriterSink->write("this is writer", 10);
   bufferedWriterSink->abort();
-  std::string result = readFile(filePath);
-  EXPECT_EQ(result.size(), 10);
+
+  uint64_t result = readFile(tempPath_->getPath(), filename);
+  EXPECT_EQ(result, 10);
 }
 } // namespace facebook::velox::text
diff --git a/velox/dwio/text/tests/writer/CMakeLists.txt b/velox/dwio/text/tests/writer/CMakeLists.txt
index ec3b2127b132..2d42a84a7f91 100644
--- a/velox/dwio/text/tests/writer/CMakeLists.txt
+++ b/velox/dwio/text/tests/writer/CMakeLists.txt
@@ -12,21 +12,29 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_text_writer_test
-               TextWriterTest.cpp BufferedWriterSinkTest.cpp FileReaderUtil.cpp)
+add_executable(
+  velox_text_writer_test
+  TextWriterTest.cpp
+  BufferedWriterSinkTest.cpp
+  FileReaderUtil.cpp
+)
 
 add_test(
   NAME velox_text_writer_test
   COMMAND velox_text_writer_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_text_writer_test
   velox_dwio_text_writer
+  velox_dwio_text_reader
   velox_dwio_common_test_utils
+  velox_dwio_text_reader_register
+  velox_dwio_text_writer_register
   velox_link_libs
-  Boost::regex
   Folly::folly
   ${TEST_LINK_LIBS}
   GTest::gtest
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/dwio/text/tests/writer/FileReaderUtil.cpp b/velox/dwio/text/tests/writer/FileReaderUtil.cpp
index db5a62f96498..a7d20e661f90 100644
--- a/velox/dwio/text/tests/writer/FileReaderUtil.cpp
+++ b/velox/dwio/text/tests/writer/FileReaderUtil.cpp
@@ -15,29 +15,46 @@
  */
 
 #include "velox/dwio/text/tests/writer/FileReaderUtil.h"
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileSystems.h"
 
 namespace facebook::velox::text {
 
-std::string readFile(const std::string& name) {
-  std::ifstream file(name);
-  std::string line;
+using dwio::common::SerDeOptions;
 
-  std::stringstream ss;
-  while (std::getline(file, line)) {
-    ss << line;
-  }
-  return ss.str();
+uint64_t readFile(const std::string& path, const std::string& name) {
+  const auto fs = filesystems::getFileSystem(path, nullptr);
+  auto filepath = fs::path(fmt::format("{}/{}", path, name));
+  const auto& file = fs->openFileForRead(filepath.string());
+
+  return file->size();
 }
 
-std::vector<std::vector<std::string>> parseTextFile(const std::string& name) {
-  std::ifstream file(name);
+std::vector<std::vector<std::string>> parseTextFile(
+    const std::string& path,
+    const std::string& name,
+    void* buffer,
+    SerDeOptions serDeOptions) {
+  const auto fs = filesystems::getFileSystem(path, nullptr);
+  auto filepath = fs::path(fmt::format("{}/{}", path, name));
+  const auto& file = fs->openFileForRead(filepath.string());
+
   std::string line;
   std::vector<std::vector<std::string>> table;
 
-  while (std::getline(file, line)) {
-    std::vector<std::string> row = splitTextLine(line, TextFileTraits::kSOH);
-    table.push_back(row);
+  auto fileSize = file->size();
+  if (fileSize > 0) {
+    file->pread(0, fileSize, buffer);
+    std::string content(static_cast<char*>(buffer), fileSize);
+
+    std::istringstream stream(content);
+    while (std::getline(stream, line)) {
+      std::vector<std::string> row =
+          splitTextLine(line, serDeOptions.separators[0]);
+      table.push_back(row);
+    }
   }
+
   return table;
 }
 
diff --git a/velox/dwio/text/tests/writer/FileReaderUtil.h b/velox/dwio/text/tests/writer/FileReaderUtil.h
index 42113c1a4bcd..65de295ef4d7 100644
--- a/velox/dwio/text/tests/writer/FileReaderUtil.h
+++ b/velox/dwio/text/tests/writer/FileReaderUtil.h
@@ -19,7 +19,16 @@
 #include "velox/dwio/text/writer/TextWriter.h"
 
 namespace facebook::velox::text {
-std::string readFile(const std::string& name);
-std::vector<std::vector<std::string>> parseTextFile(const std::string& name);
+
+using dwio::common::SerDeOptions;
+
+uint64_t readFile(const std::string& filepath, const std::string& name);
+
+std::vector<std::vector<std::string>> parseTextFile(
+    const std::string& path,
+    const std::string& name,
+    void* buffer,
+    SerDeOptions serDeOptions = SerDeOptions());
+
 std::vector<std::string> splitTextLine(const std::string& str, char delimiter);
 } // namespace facebook::velox::text
diff --git a/velox/dwio/text/tests/writer/TextWriterTest.cpp b/velox/dwio/text/tests/writer/TextWriterTest.cpp
index b1bc16bb243a..d007c9323624 100644
--- a/velox/dwio/text/tests/writer/TextWriterTest.cpp
+++ b/velox/dwio/text/tests/writer/TextWriterTest.cpp
@@ -15,31 +15,51 @@
  */
 
 #include "velox/dwio/text/writer/TextWriter.h"
-#include <gtest/gtest.h>
-#include "velox/common/base/Fs.h"
+#include "velox/buffer/Buffer.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/dwio/text/RegisterTextReader.h"
+#include "velox/dwio/text/RegisterTextWriter.h"
 #include "velox/dwio/text/tests/writer/FileReaderUtil.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
+#include <gtest/gtest.h>
+
+/// TODO: Add fuzzer test.
+
 namespace facebook::velox::text {
-// TODO: add fuzzer test once text reader is move in OSS
 class TextWriterTest : public testing::Test,
                        public velox::test::VectorTestBase {
  public:
   void SetUp() override {
     velox::filesystems::registerLocalFileSystem();
-    dwio::common::LocalFileSink::registerFactory();
+    registerTextWriterFactory();
+    registerTextReaderFactory();
     rootPool_ = memory::memoryManager()->addRootPool("TextWriterTests");
     leafPool_ = rootPool_->addLeafChild("TextWriterTests");
     tempPath_ = exec::test::TempDirectoryPath::create();
   }
 
+  void TearDown() override {
+    unregisterTextWriterFactory();
+    unregisterTextReaderFactory();
+  }
+
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
+  void setScanSpec(const Type& type, dwio::common::RowReaderOptions& options) {
+    auto spec = std::make_shared<common::ScanSpec>("root");
+    spec->addAllChildFields(type);
+    options.setScanSpec(spec);
+  }
+
+  memory::MemoryPool& poolRef() {
+    return *pool();
+  }
+
   constexpr static float kInf = std::numeric_limits<float>::infinity();
   constexpr static double kNaN = std::numeric_limits<double>::quiet_NaN();
   std::shared_ptr<memory::MemoryPool> rootPool_;
@@ -78,8 +98,10 @@ TEST_F(TextWriterTest, write) {
 
   WriterOptions writerOptions;
   writerOptions.memoryPool = rootPool_.get();
-  auto filePath =
-      fs::path(fmt::format("{}/test_text_writer.txt", tempPath_->getPath()));
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_text_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
   auto sink = std::make_unique<dwio::common::LocalFileSink>(
       filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
   auto writer = std::make_unique<TextWriter>(
@@ -89,9 +111,18 @@ TEST_F(TextWriterTest, write) {
   writer->write(data);
   writer->close();
 
-  std::vector<std::vector<std::string>> result = parseTextFile(filePath);
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf);
+
   EXPECT_EQ(result.size(), 3);
   EXPECT_EQ(result[0].size(), 10);
+
   // bool type
   EXPECT_EQ(result[0][0], "true");
   EXPECT_EQ(result[1][0], "true");
@@ -128,9 +159,9 @@ TEST_F(TextWriterTest, write) {
   EXPECT_EQ(result[2][6], "3.100000");
 
   // timestamp
-  EXPECT_EQ(result[0][7], "1970-01-01 00:00:00.000");
-  EXPECT_EQ(result[1][7], "1970-01-01 00:00:01.001");
-  EXPECT_EQ(result[2][7], "1970-01-01 00:00:02.002");
+  EXPECT_EQ(result[0][7], "1969-12-31 16:00:00.000");
+  EXPECT_EQ(result[1][7], "1969-12-31 16:00:01.001");
+  EXPECT_EQ(result[2][7], "1969-12-31 16:00:02.002");
 
   // varchar
   EXPECT_EQ(result[0][8], "hello");
@@ -143,6 +174,1088 @@ TEST_F(TextWriterTest, write) {
   EXPECT_EQ(result[2][9], "Y3Bw");
 }
 
+TEST_F(TextWriterTest, verifyWriteWithTextReader) {
+  auto schema =
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9"},
+          {
+              TIMESTAMP(),
+              BOOLEAN(),
+              TINYINT(),
+              SMALLINT(),
+              INTEGER(),
+              BIGINT(),
+              REAL(),
+              DOUBLE(),
+              VARCHAR(),
+              VARBINARY(),
+          });
+  auto data = makeRowVector(
+      {"c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9"},
+      {
+          makeFlatVector<Timestamp>(
+              3, [](auto i) { return Timestamp(i, i * 1'000'000); }),
+          makeConstant(true, 3),
+          makeFlatVector<int8_t>({1, 2, 3}),
+          makeFlatVector<int16_t>({1, 2, 3}), // TODO null
+          makeFlatVector<int32_t>({1, 2, 3}),
+          makeFlatVector<int64_t>({1, 2, 3}),
+          makeFlatVector<float>({1.1, kInf, 3.1}),
+          makeFlatVector<double>({1.1, kNaN, 3.1}),
+          makeFlatVector<StringView>({"hello", "world", "cpp"}, VARCHAR()),
+          makeFlatVector<StringView>({"hello", "world", "cpp"}, VARBINARY()),
+      });
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_text_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath.string(),
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions));
+  writer->write(data);
+  writer->close();
+
+  // Set up reader.
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*schema, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(3, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(data.get(), i, i));
+  }
+}
+
+TEST_F(TextWriterTest, mapAndArrayComplexTypes) {
+  const vector_size_t length = 13;
+  const auto keyVector = makeFlatVector<int64_t>(
+      {1,   111,  22, 22222, 333, 33, 44,    5,   555, 66, 7777,     7,
+       777, 8888, 88, 9,     99,  10, 10000, 111, 1,   11, 11122222, 123142});
+  const auto valueVector = makeFlatVector<bool>(
+      {false, true, true,  false, false, true,  false, true,
+       false, true, false, true,  false, false, true,  true,
+       false, true, false, true,  false, true,  true,  true});
+  BufferPtr sizes = facebook::velox::allocateOffsets(length, pool());
+  BufferPtr offsets = facebook::velox::allocateOffsets(length, pool());
+  auto rawSizes = sizes->asMutable<vector_size_t>();
+  auto rawOffsets = offsets->asMutable<vector_size_t>();
+  rawSizes[0] = 2;
+  rawSizes[1] = 2;
+  rawSizes[2] = 2;
+  rawSizes[3] = 1;
+  rawSizes[4] = 2;
+  rawSizes[5] = 1;
+  rawSizes[6] = 3;
+  rawSizes[7] = 2;
+  rawSizes[8] = 2;
+  rawSizes[9] = 2;
+  rawSizes[10] = 3;
+  rawSizes[11] = 1;
+  rawSizes[12] = 1;
+  for (int i = 1; i < length; i++) {
+    rawOffsets[i] = rawOffsets[i - 1] + rawSizes[i - 1];
+  }
+
+  const auto data = makeRowVector(
+      {makeArrayVector<int64_t>(
+           {{1, 11, 111},
+            {22, 22222},
+            {333, 33},
+            {4444, 44},
+            {5, 555},
+            {666, 66, 66},
+            {7777, 7, 777},
+            {8888, 88},
+            {9, 99},
+            {10, 10000},
+            {111, 1, 111},
+            {12, 11122222, 222},
+            {13, 11133333, 333}}),
+       makeArrayVector<double>(
+           {{1.123, 1.3123},
+            {2.333, -5512, 1.23},
+            {-6.1, 65.777},
+            {4.2, 24, 324.11},
+            {47.2, 213.23},
+            {79.5, -44.11},
+            {3.1415926, 441.124},
+            {-221.145, 878.43, -11},
+            {93.12, 632},
+            {-4123.11, -177.1},
+            {950.2, -4412},
+            {43.66, 33121.43},
+            {-42.11, -123.43}}),
+       std::make_shared<MapVector>(
+           pool(),
+           MAP(keyVector->type(), valueVector->type()),
+           nullptr,
+           length,
+           offsets,
+           sizes,
+           keyVector,
+           valueVector)});
+
+  const auto schema = ROW(
+      {{"col_bigint_arr", ARRAY(BIGINT())},
+       {"col_double_arr", ARRAY(DOUBLE())},
+       {"col_map", MAP(BIGINT(), BOOLEAN())}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_text_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath.string(),
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // use traits to specify delimiters when it is not nested
+  const auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf, serDeOptions);
+
+  EXPECT_EQ(result.size(), 13);
+  EXPECT_EQ(result[0].size(), 3);
+
+  // col_bigint_arr
+  EXPECT_EQ(result[0][0], "1|11|111");
+  EXPECT_EQ(result[1][0], "22|22222");
+  EXPECT_EQ(result[2][0], "333|33");
+  EXPECT_EQ(result[3][0], "4444|44");
+  EXPECT_EQ(result[4][0], "5|555");
+  EXPECT_EQ(result[5][0], "666|66|66");
+  EXPECT_EQ(result[6][0], "7777|7|777");
+  EXPECT_EQ(result[7][0], "8888|88");
+  EXPECT_EQ(result[8][0], "9|99");
+  EXPECT_EQ(result[9][0], "10|10000");
+  EXPECT_EQ(result[10][0], "111|1|111");
+  EXPECT_EQ(result[11][0], "12|11122222|222");
+  EXPECT_EQ(result[12][0], "13|11133333|333");
+
+  // col_double_arr
+  EXPECT_EQ(result[0][1], "1.123000|1.312300");
+  EXPECT_EQ(result[1][1], "2.333000|-5512.000000|1.230000");
+  EXPECT_EQ(result[2][1], "-6.100000|65.777000");
+  EXPECT_EQ(result[3][1], "4.200000|24.000000|324.110000");
+  EXPECT_EQ(result[4][1], "47.200000|213.230000");
+  EXPECT_EQ(result[5][1], "79.500000|-44.110000");
+  EXPECT_EQ(result[6][1], "3.141593|441.124000");
+  EXPECT_EQ(result[7][1], "-221.145000|878.430000|-11.000000");
+  EXPECT_EQ(result[8][1], "93.120000|632.000000");
+  EXPECT_EQ(result[9][1], "-4123.110000|-177.100000");
+  EXPECT_EQ(result[10][1], "950.200000|-4412.000000");
+  EXPECT_EQ(result[11][1], "43.660000|33121.430000");
+  EXPECT_EQ(result[12][1], "-42.110000|-123.430000");
+
+  // col_map
+  EXPECT_EQ(result[0][2], "1#false|111#true");
+  EXPECT_EQ(result[1][2], "22#true|22222#false");
+  EXPECT_EQ(result[2][2], "333#false|33#true");
+  EXPECT_EQ(result[3][2], "44#false");
+  EXPECT_EQ(result[4][2], "5#true|555#false");
+  EXPECT_EQ(result[5][2], "66#true");
+  EXPECT_EQ(result[6][2], "7777#false|7#true|777#false");
+  EXPECT_EQ(result[7][2], "8888#false|88#true");
+  EXPECT_EQ(result[8][2], "9#true|99#false");
+  EXPECT_EQ(result[9][2], "10#true|10000#false");
+  EXPECT_EQ(result[10][2], "111#true|1#false|11#true");
+  EXPECT_EQ(result[11][2], "11122222#true");
+  EXPECT_EQ(result[12][2], "123142#true");
+}
+
+TEST_F(TextWriterTest, verifyMapAndArrayComplexTypesWithTextReader) {
+  const vector_size_t length = 13;
+  const auto keyVector = makeFlatVector<int64_t>(
+      {1,   111,  22, 22222, 333, 33, 44,    5,   555, 66, 7777,     7,
+       777, 8888, 88, 9,     99,  10, 10000, 111, 1,   11, 11122222, 123142});
+  const auto valueVector = makeFlatVector<bool>(
+      {false, true, true,  false, false, true,  false, true,
+       false, true, false, true,  false, false, true,  true,
+       false, true, false, true,  false, true,  true,  true});
+  BufferPtr sizes = facebook::velox::allocateOffsets(length, pool());
+  BufferPtr offsets = facebook::velox::allocateOffsets(length, pool());
+  auto rawSizes = sizes->asMutable<vector_size_t>();
+  auto rawOffsets = offsets->asMutable<vector_size_t>();
+  rawSizes[0] = 2;
+  rawSizes[1] = 2;
+  rawSizes[2] = 2;
+  rawSizes[3] = 1;
+  rawSizes[4] = 2;
+  rawSizes[5] = 1;
+  rawSizes[6] = 3;
+  rawSizes[7] = 2;
+  rawSizes[8] = 2;
+  rawSizes[9] = 2;
+  rawSizes[10] = 3;
+  rawSizes[11] = 1;
+  rawSizes[12] = 1;
+  for (int i = 1; i < length; i++) {
+    rawOffsets[i] = rawOffsets[i - 1] + rawSizes[i - 1];
+  }
+
+  const auto data = makeRowVector(
+      {makeArrayVector<int64_t>(
+           {{1, 11, 111},
+            {22, 22222},
+            {333, 33},
+            {4444, 44},
+            {5, 555},
+            {666, 66, 66},
+            {7777, 7, 777},
+            {8888, 88},
+            {9, 99},
+            {10, 10000},
+            {111, 1, 111},
+            {12, 11122222, 222},
+            {13, 11133333, 333}}),
+       makeArrayVector<double>(
+           {{1.123, 1.3123},
+            {2.333, -5512, 1.23},
+            {-6.1, 65.777},
+            {4.2, 24, 324.11},
+            {47.2, 213.23},
+            {79.5, -44.11},
+            {3.1415926, 441.124},
+            {-221.145, 878.43, -11},
+            {93.12, 632},
+            {-4123.11, -177.1},
+            {950.2, -4412},
+            {43.66, 33121.43},
+            {-42.11, -123.43}}),
+       std::make_shared<MapVector>(
+           pool(),
+           MAP(keyVector->type(), valueVector->type()),
+           nullptr,
+           length,
+           offsets,
+           sizes,
+           keyVector,
+           valueVector)});
+
+  const auto schema = ROW(
+      {{"col_bigint_arr", ARRAY(BIGINT())},
+       {"col_double_arr", ARRAY(DOUBLE())},
+       {"col_map", MAP(BIGINT(), BOOLEAN())}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  auto filePath =
+      fs::path(fmt::format("{}/test_text_writer.txt", tempPath_->getPath()));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath.string(),
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // use traits to specify delimiters when it is not nested
+  const auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  // Set up reader.
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  readerOptions.setSerDeOptions(serDeOptions);
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*schema, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  // Change the expected value
+  const auto expected = makeRowVector(
+      {makeArrayVector<int64_t>(
+           {{1, 11, 111},
+            {22, 22222},
+            {333, 33},
+            {4444, 44},
+            {5, 555},
+            {666, 66, 66},
+            {7777, 7, 777},
+            {8888, 88},
+            {9, 99},
+            {10, 10000},
+            {111, 1, 111},
+            {12, 11122222, 222},
+            {13, 11133333, 333}}),
+       makeArrayVector<double>(
+           {{1.123, 1.3123},
+            {2.333, -5512, 1.23},
+            {-6.1, 65.777},
+            {4.2, 24, 324.11},
+            {47.2, 213.23},
+            {79.5, -44.11},
+            {3.141593, 441.124},
+            {-221.145, 878.43, -11},
+            {93.12, 632},
+            {-4123.11, -177.1},
+            {950.2, -4412},
+            {43.66, 33121.43},
+            {-42.11, -123.43}}),
+       std::make_shared<MapVector>(
+           pool(),
+           MAP(keyVector->type(), valueVector->type()),
+           nullptr,
+           length,
+           offsets,
+           sizes,
+           keyVector,
+           valueVector)});
+
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(13, result), 13);
+  for (int i = 0; i < 13; ++i) {
+    EXPECT_TRUE(result->equalValueAt(expected.get(), i, i));
+  }
+}
+
+TEST_F(TextWriterTest, arrayTypes) {
+  // Test specifically for ARRAY types with various element types
+  const auto data = makeRowVector({
+      makeArrayVector<int32_t>(
+          {{1, 2, 3},
+           {10, 20},
+           {100, 200, 300, 400},
+           {}, // empty array
+           {42}}),
+      makeArrayVector<std::string>(
+          {{"hello", "world"},
+           {"foo", "bar", "baz"},
+           {"single"},
+           {}, // empty array
+           {"test", "array", "string"}}),
+      makeArrayVector<double>(
+          {{1.1, 2.2, 3.3},
+           {10.5, 20.7},
+           {}, // empty array
+           {99.99},
+           {1.0, 2.0, 3.0, 4.0, 5.0}}),
+  });
+
+  const auto schema = ROW(
+      {{"int_array", ARRAY(INTEGER())},
+       {"string_array", ARRAY(VARCHAR())},
+       {"double_array", ARRAY(DOUBLE())}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_array_writer.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  const auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf, serDeOptions);
+
+  EXPECT_EQ(result.size(), 5);
+  EXPECT_EQ(result[0].size(), 3);
+
+  // int array type
+  EXPECT_EQ(result[0][0], "1|2|3");
+  EXPECT_EQ(result[1][0], "10|20");
+  EXPECT_EQ(result[2][0], "100|200|300|400");
+  EXPECT_EQ(result[3][0], "");
+  EXPECT_EQ(result[4][0], "42");
+
+  // varchar array type
+  EXPECT_EQ(result[0][1], "hello|world");
+  EXPECT_EQ(result[1][1], "foo|bar|baz");
+  EXPECT_EQ(result[2][1], "single");
+  EXPECT_EQ(result[3][1], "");
+  EXPECT_EQ(result[4][1], "test|array|string");
+
+  // double array type
+  EXPECT_EQ(result[0][2], "1.100000|2.200000|3.300000");
+  EXPECT_EQ(result[1][2], "10.500000|20.700000");
+  EXPECT_EQ(result[2][2], "");
+  EXPECT_EQ(result[3][2], "99.990000");
+  EXPECT_EQ(result[4][2], "1.000000|2.000000|3.000000|4.000000|5.000000");
+}
+
+TEST_F(TextWriterTest, verifyArrayTypesWithTextReader) {
+  // Test specifically for ARRAY types with various element types
+  const auto data = makeRowVector({
+      makeArrayVector<int32_t>(
+          {{1, 2, 3},
+           {10, 20},
+           {100, 200, 300, 400},
+           {}, // empty array
+           {42}}),
+      makeArrayVector<std::string>(
+          {{"hello", "world"},
+           {"foo", "bar", "baz"},
+           {"single"},
+           {}, // empty array
+           {"test", "array", "string"}}),
+      makeArrayVector<double>(
+          {{1.1, 2.2, 3.3},
+           {10.5, 20.7},
+           {}, // empty array
+           {99.99},
+           {1.0, 2.0, 3.0, 4.0, 5.0}}),
+  });
+
+  const auto schema = ROW(
+      {{"int_array", ARRAY(INTEGER())},
+       {"string_array", ARRAY(VARCHAR())},
+       {"double_array", ARRAY(DOUBLE())}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_array_writer.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  const auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  // Set up reader.
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*schema, rowReaderOptions);
+
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(5, result), 5);
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_TRUE(result->equalValueAt(data.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextWriterTest, mapTypes) {
+  // Test specifically for MAP types with various key-value combinations
+  const vector_size_t length = 5;
+
+  // Create key and value vectors for the maps
+  const auto keyVector =
+      makeFlatVector<int64_t>({1, 2, 3, 10, 20, 100, 42, 99, 123, 456});
+  const auto valueVector = makeFlatVector<bool>(
+      {true, false, true, false, true, true, false, true, false, true});
+
+  // Set up offsets and sizes for each row
+  BufferPtr sizes = facebook::velox::allocateOffsets(length, pool());
+  BufferPtr offsets = facebook::velox::allocateOffsets(length, pool());
+  auto rawSizes = sizes->asMutable<vector_size_t>();
+  auto rawOffsets = offsets->asMutable<vector_size_t>();
+
+  rawSizes[0] = 3; // Row 0: 3 key-value pairs
+  rawSizes[1] = 2; // Row 1: 2 key-value pairs
+  rawSizes[2] = 1; // Row 2: 1 key-value pair
+  rawSizes[3] = 0; // Row 3: 0 key-value pairs (empty map)
+  rawSizes[4] = 4; // Row 4: 4 key-value pairs
+
+  rawOffsets[0] = 0;
+  for (int i = 1; i < length; i++) {
+    rawOffsets[i] = rawOffsets[i - 1] + rawSizes[i - 1];
+  }
+
+  // Create string keys for a second map column
+  const auto stringKeyVector = makeFlatVector<std::string>(
+      {"key1", "key2", "foo", "bar", "baz", "qux", "test"});
+  const auto intValueVector =
+      makeFlatVector<int32_t>({10, 20, 100, 1, 2, 3, 999});
+
+  // Set up offsets and sizes for string key map
+  BufferPtr stringSizes = facebook::velox::allocateOffsets(length, pool());
+  BufferPtr stringOffsets = facebook::velox::allocateOffsets(length, pool());
+  auto rawStringSizes = stringSizes->asMutable<vector_size_t>();
+  auto rawStringOffsets = stringOffsets->asMutable<vector_size_t>();
+
+  rawStringSizes[0] = 2; // Row 0: 2 key-value pairs
+  rawStringSizes[1] = 1; // Row 1: 1 key-value pair
+  rawStringSizes[2] = 3; // Row 2: 3 key-value pairs
+  rawStringSizes[3] = 0; // Row 3: 0 key-value pairs (empty map)
+  rawStringSizes[4] = 1; // Row 4: 1 key-value pair
+
+  rawStringOffsets[0] = 0;
+  for (int i = 1; i < length; i++) {
+    rawStringOffsets[i] = rawStringOffsets[i - 1] + rawStringSizes[i - 1];
+  }
+
+  const auto data = makeRowVector(
+      {std::make_shared<MapVector>(
+           pool(),
+           MAP(BIGINT(), BOOLEAN()),
+           nullptr,
+           length,
+           offsets,
+           sizes,
+           keyVector,
+           valueVector),
+       std::make_shared<MapVector>(
+           pool(),
+           MAP(VARCHAR(), INTEGER()),
+           nullptr,
+           length,
+           stringOffsets,
+           stringSizes,
+           stringKeyVector,
+           intValueVector)});
+
+  const auto schema = ROW(
+      {{"int_bool_map", MAP(BIGINT(), BOOLEAN())},
+       {"string_int_map", MAP(VARCHAR(), INTEGER())}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_map_writer.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  const auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf, serDeOptions);
+
+  EXPECT_EQ(result.size(), 5);
+  EXPECT_EQ(result[0].size(), 2);
+
+  // int_bool_map
+  EXPECT_EQ(result[0][0], "1#true|2#false|3#true");
+  EXPECT_EQ(result[1][0], "10#false|20#true");
+  EXPECT_EQ(result[2][0], "100#true");
+  EXPECT_EQ(result[3][0], "");
+  EXPECT_EQ(result[4][0], "42#false|99#true|123#false|456#true");
+
+  // string_int_map
+  EXPECT_EQ(result[0][1], "key1#10|key2#20");
+  EXPECT_EQ(result[1][1], "foo#100");
+  EXPECT_EQ(result[2][1], "bar#1|baz#2|qux#3");
+  EXPECT_EQ(result[3][1], "");
+  EXPECT_EQ(result[4][1], "test#999");
+}
+
+TEST_F(TextWriterTest, verifyMapTypesWithTextReader) {
+  // Test specifically for MAP types with various key-value combinations
+  const vector_size_t length = 5;
+
+  // Create key and value vectors for the maps
+  const auto keyVector =
+      makeFlatVector<int64_t>({1, 2, 3, 10, 20, 100, 42, 99, 123, 456});
+  const auto valueVector = makeFlatVector<bool>(
+      {true, false, true, false, true, true, false, true, false, true});
+
+  // Set up offsets and sizes for each row
+  BufferPtr sizes = facebook::velox::allocateOffsets(length, pool());
+  BufferPtr offsets = facebook::velox::allocateOffsets(length, pool());
+  auto rawSizes = sizes->asMutable<vector_size_t>();
+  auto rawOffsets = offsets->asMutable<vector_size_t>();
+
+  rawSizes[0] = 3; // Row 0: 3 key-value pairs
+  rawSizes[1] = 2; // Row 1: 2 key-value pairs
+  rawSizes[2] = 1; // Row 2: 1 key-value pair
+  rawSizes[3] = 0; // Row 3: 0 key-value pairs (empty map)
+  rawSizes[4] = 4; // Row 4: 4 key-value pairs
+
+  rawOffsets[0] = 0;
+  for (int i = 1; i < length; i++) {
+    rawOffsets[i] = rawOffsets[i - 1] + rawSizes[i - 1];
+  }
+
+  // Create string keys for a second map column
+  const auto stringKeyVector = makeFlatVector<std::string>(
+      {"key1", "key2", "foo", "bar", "baz", "qux", "test"});
+  const auto intValueVector =
+      makeFlatVector<int32_t>({10, 20, 100, 1, 2, 3, 999});
+
+  // Set up offsets and sizes for string key map
+  BufferPtr stringSizes = facebook::velox::allocateOffsets(length, pool());
+  BufferPtr stringOffsets = facebook::velox::allocateOffsets(length, pool());
+  auto rawStringSizes = stringSizes->asMutable<vector_size_t>();
+  auto rawStringOffsets = stringOffsets->asMutable<vector_size_t>();
+
+  rawStringSizes[0] = 2; // Row 0: 2 key-value pairs
+  rawStringSizes[1] = 1; // Row 1: 1 key-value pair
+  rawStringSizes[2] = 3; // Row 2: 3 key-value pairs
+  rawStringSizes[3] = 0; // Row 3: 0 key-value pairs (empty map)
+  rawStringSizes[4] = 1; // Row 4: 1 key-value pair
+
+  rawStringOffsets[0] = 0;
+  for (int i = 1; i < length; i++) {
+    rawStringOffsets[i] = rawStringOffsets[i - 1] + rawStringSizes[i - 1];
+  }
+
+  const auto data = makeRowVector(
+      {std::make_shared<MapVector>(
+           pool(),
+           MAP(BIGINT(), BOOLEAN()),
+           nullptr,
+           length,
+           offsets,
+           sizes,
+           keyVector,
+           valueVector),
+       std::make_shared<MapVector>(
+           pool(),
+           MAP(VARCHAR(), INTEGER()),
+           nullptr,
+           length,
+           stringOffsets,
+           stringSizes,
+           stringKeyVector,
+           intValueVector)});
+
+  const auto schema = ROW(
+      {{"int_bool_map", MAP(BIGINT(), BOOLEAN())},
+       {"string_int_map", MAP(VARCHAR(), INTEGER())}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_map_writer.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  const auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  // Set up reader
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*schema, rowReaderOptions);
+
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(5, result), 5);
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_TRUE(result->equalValueAt(data.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextWriterTest, nestedRowTypes) {
+  // Test specifically for nested ROW types
+  auto nestedRowChildren = std::vector<VectorPtr>{
+      makeFlatVector<int32_t>({42, 100, -5, 0, 999}),
+      makeFlatVector<bool>({true, false, true, false, true}),
+      makeArrayVector<double>(
+          {{3.14159, 2.71828},
+           {2.71828, 1.41421, 0.0},
+           {1.41421, -123.456},
+           {0.0, 999.999},
+           {-123.456, 42.0, 3.14159}})};
+  auto nestedRowVector = makeRowVector(
+      {"nested_int", "nested_bool", "nested_arr_double"}, nestedRowChildren);
+
+  const auto data = makeRowVector(
+      {makeFlatVector<std::string>(
+           {"hello", "world", "test", "sample", "data"}),
+       nestedRowVector,
+       makeFlatVector<bool>({false, true, false, true, false})});
+
+  const auto schema = ROW(
+      {{"col_varchar", VARCHAR()},
+       {"col_nested_row",
+        ROW(
+            {{"nested_int", INTEGER()},
+             {"nested_bool", BOOLEAN()},
+             {"nested_arr_double", ARRAY(DOUBLE())}})},
+       {"col_bool", BOOLEAN()}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_nested_row_writer.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  const auto serDeOptions = dwio::common::SerDeOptions(',', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf, serDeOptions);
+
+  EXPECT_EQ(result.size(), 5);
+  EXPECT_EQ(result[0].size(), 3);
+
+  EXPECT_EQ(result[0][0], "hello");
+  EXPECT_EQ(result[1][0], "world");
+  EXPECT_EQ(result[2][0], "test");
+  EXPECT_EQ(result[3][0], "sample");
+  EXPECT_EQ(result[4][0], "data");
+
+  // nested row
+  EXPECT_EQ(result[0][1], "42|true|3.141590#2.718280");
+  EXPECT_EQ(result[1][1], "100|false|2.718280#1.414210#0.000000");
+  EXPECT_EQ(result[2][1], "-5|true|1.414210#-123.456000");
+  EXPECT_EQ(result[3][1], "0|false|0.000000#999.999000");
+  EXPECT_EQ(result[4][1], "999|true|-123.456000#42.000000#3.141590");
+
+  EXPECT_EQ(result[0][2], "false");
+  EXPECT_EQ(result[1][2], "true");
+  EXPECT_EQ(result[2][2], "false");
+  EXPECT_EQ(result[3][2], "true");
+  EXPECT_EQ(result[4][2], "false");
+}
+
+TEST_F(TextWriterTest, verifyNestedRowTypesWithTextReader) {
+  // Test specifically for nested ROW types
+  auto nestedRowChildren = std::vector<VectorPtr>{
+      makeFlatVector<int32_t>({42, 100, -5, 0, 999}),
+      makeFlatVector<bool>({true, false, true, false, true}),
+      makeArrayVector<double>(
+          {{3.14159, 2.71828},
+           {2.71828, 1.41421, 0.0},
+           {1.41421, -123.456},
+           {0.0, 999.999},
+           {-123.456, 42.0, 3.14159}})};
+  auto nestedRowVector = makeRowVector(
+      {"nested_int", "nested_bool", "nested_arr_double"}, nestedRowChildren);
+
+  const auto data = makeRowVector(
+      {makeFlatVector<std::string>(
+           {"hello", "world", "test", "sample", "data"}),
+       nestedRowVector,
+       makeFlatVector<bool>({false, true, false, true, false})});
+
+  const auto schema = ROW(
+      {{"col_varchar", VARCHAR()},
+       {"col_nested_row",
+        ROW(
+            {{"nested_int", INTEGER()},
+             {"nested_bool", BOOLEAN()},
+             {"nested_arr_double", ARRAY(DOUBLE())}})},
+       {"col_bool", BOOLEAN()}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_nested_row_writer.txt";
+
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // Use custom delimiters: field separator '\x01', nested row field separator
+  // '\x02'
+  const auto serDeOptions = dwio::common::SerDeOptions('\x01', '\x02', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  // Set up reader
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*schema, rowReaderOptions);
+
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(5, result), 5);
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_TRUE(result->equalValueAt(data.get(), i, i));
+  }
+}
+
+TEST_F(TextWriterTest, DISABLED_deeplyNestedComplexTypes) {
+  // Inner maps for the arrays
+  const auto innerMapKeys1 = makeFlatVector<int64_t>({1, 11, 22});
+  const auto innerMapValues1 = makeFlatVector<bool>({true, false, true});
+  const auto innerMapKeys2 = makeFlatVector<int64_t>({33, 44});
+  const auto innerMapValues2 = makeFlatVector<bool>({false, true});
+  const auto innerMapKeys3 = makeFlatVector<int64_t>({55, 66, 77, 88});
+  const auto innerMapValues3 = makeFlatVector<bool>({true, true, false, true});
+  const auto innerMapKeys4 = makeFlatVector<int64_t>(std::vector<int64_t>{99});
+  const auto innerMapValues4 = makeFlatVector<bool>(std::vector<bool>{false});
+  const auto innerMapKeys5 = makeFlatVector<int64_t>({100, 200});
+  const auto innerMapValues5 = makeFlatVector<bool>({true, false});
+  const auto innerMapKeys6 = makeFlatVector<int64_t>({300, 400, 500});
+  const auto innerMapValues6 = makeFlatVector<bool>({false, false, true});
+
+  // Combine all inner map keys and values
+  const auto allInnerMapKeys = makeFlatVector<int64_t>(
+      {1, 11, 22, 33, 44, 55, 66, 77, 88, 99, 100, 200, 300, 400, 500});
+  const auto allInnerMapValues = makeFlatVector<bool>(
+      {true,
+       false,
+       true,
+       false,
+       true,
+       true,
+       true,
+       false,
+       true,
+       false,
+       true,
+       false,
+       false,
+       false,
+       true});
+
+  // Create inner maps with proper offsets and sizes
+  BufferPtr innerMapSizes = allocateOffsets(6, pool());
+  BufferPtr innerMapOffsets = allocateOffsets(6, pool());
+  auto rawInnerMapSizes = innerMapSizes->asMutable<vector_size_t>();
+  auto rawInnerMapOffsets = innerMapOffsets->asMutable<vector_size_t>();
+
+  rawInnerMapSizes[0] = 3; // {1:true, 11:false, 22:true}
+  rawInnerMapSizes[1] = 2; // {33:false, 44:true}
+  rawInnerMapSizes[2] = 4; // {55:true, 66:true, 77:false, 88:true}
+  rawInnerMapSizes[3] = 1; // {99:false}
+  rawInnerMapSizes[4] = 2; // {100:true, 200:false}
+  rawInnerMapSizes[5] = 3; // {300:false, 400:false, 500:true}
+
+  rawInnerMapOffsets[0] = 0;
+  for (int i = 1; i < 6; i++) {
+    rawInnerMapOffsets[i] = rawInnerMapOffsets[i - 1] + rawInnerMapSizes[i - 1];
+  }
+
+  auto innerMapsVector = std::make_shared<MapVector>(
+      pool(),
+      MAP(BIGINT(), BOOLEAN()),
+      nullptr,
+      6,
+      innerMapOffsets,
+      innerMapSizes,
+      allInnerMapKeys,
+      allInnerMapValues);
+
+  // Create arrays containing the inner maps
+  // Array 1: [innerMap0, innerMap1] (maps at indices 0, 1)
+  // Array 2: [innerMap2, innerMap3, innerMap4] (maps at indices 2, 3, 4)
+  // Array 3: [innerMap5] (map at index 5)
+  auto arrayVector = makeArrayVector({0, 2, 5, 6}, innerMapsVector);
+
+  // Create the outer map keys
+  const auto outerMapKeys = makeFlatVector<int64_t>({10, 20, 30});
+
+  // Create the final data structure
+  auto outerMapOffsets = allocateOffsets(3, pool());
+  auto outerMapSizes = allocateOffsets(3, pool());
+  auto rawOuterMapOffsets = outerMapOffsets->asMutable<vector_size_t>();
+  auto rawOuterMapSizes = outerMapSizes->asMutable<vector_size_t>();
+
+  // Set offsets: [0, 1, 2]
+  rawOuterMapOffsets[0] = 0;
+  rawOuterMapOffsets[1] = 1;
+  rawOuterMapOffsets[2] = 2;
+
+  // Set sizes: [1, 1, 1] (each outer map entry contains 1 array)
+  rawOuterMapSizes[0] = 1;
+  rawOuterMapSizes[1] = 1;
+  rawOuterMapSizes[2] = 1;
+
+  const auto data = makeRowVector({std::make_shared<MapVector>(
+      pool(),
+      MAP(BIGINT(), ARRAY(MAP(BIGINT(), BOOLEAN()))),
+      nullptr,
+      3,
+      outerMapOffsets,
+      outerMapSizes,
+      outerMapKeys,
+      arrayVector)});
+
+  const auto schema =
+      ROW({{"col_nested_map", MAP(BIGINT(), ARRAY(MAP(BIGINT(), BOOLEAN())))}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_text_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath.string(),
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // Define hierarchical delimiters for nested data structures:
+  // '\x01' - field separator (between columns)
+  // '|' - nesting level 1
+  // '#' - nesting level 2
+  // '!', '@', '$', '%', '^' - separators for deeper nesting levels
+  // This creates a delimiter hierarchy to properly serialize complex nested
+  // types
+  auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', '#');
+  serDeOptions.separators[3] = '!';
+  serDeOptions.separators[4] = '@';
+  serDeOptions.separators[5] = '$';
+  serDeOptions.separators[6] = '%';
+  serDeOptions.separators[7] = '^';
+
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+
+  writer->write(data);
+  writer->close();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(1024, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf, serDeOptions);
+
+  EXPECT_EQ(result.size(), 3);
+  EXPECT_EQ(result[0].size(), 1);
+  EXPECT_EQ(result[1].size(), 1);
+  EXPECT_EQ(result[2].size(), 1);
+
+  // Row 0: {10: [{1:true, 11:false, 22:true}, {33:false, 44:true}]}
+  EXPECT_EQ(result[0][0], "10#1@true!11@false!22@true#33@false!44@true");
+
+  // Row 1: {20: [{55:true, 66:true, 77:false, 88:true}, {99:false}, {100:true,
+  // 200:false}]}
+  EXPECT_EQ(
+      result[1][0],
+      "20#55@true!66@true!77@false!88@true#99@false#100@true!200@false");
+
+  // Row 2: {30: [{300:false, 400:false, 500:true}]}
+  EXPECT_EQ(result[2][0], "30#300@false!400@false!500@true");
+}
+
 TEST_F(TextWriterTest, abort) {
   auto schema = ROW({"c0", "c1"}, {BIGINT(), BOOLEAN()});
   auto data = makeRowVector(
@@ -155,10 +1268,14 @@ TEST_F(TextWriterTest, abort) {
   WriterOptions writerOptions;
   writerOptions.memoryPool = rootPool_.get();
   writerOptions.defaultFlushCount = 10;
-  auto filePath = fs::path(
-      fmt::format("{}/test_text_writer_abort.txt", tempPath_->getPath()));
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_text_writer_abort.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
   auto sink = std::make_unique<dwio::common::LocalFileSink>(
-      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+      filePath.string(),
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
   auto writer = std::make_unique<TextWriter>(
       schema,
       std::move(sink),
@@ -166,13 +1283,592 @@ TEST_F(TextWriterTest, abort) {
   writer->write(data);
   writer->abort();
 
-  std::string result = readFile(filePath);
+  uint64_t result = readFile(tempPath, filePath.filename().string());
+
   // With defaultFlushCount as 10, it will trigger two times of flushes before
   // abort, and abort will discard the remaining 5 characters in buffer. The
   // written file would have:
-  // 1^Atrue
-  // 2^Atrue
+  // 1^Atrue\n
+  // 2^Atrue\n
   // 3^A
-  EXPECT_EQ(result.size(), 14);
+  EXPECT_EQ(result, 16);
 }
+
+TEST_F(TextWriterTest, tripleNestedArraysWithCustomDelimiters) {
+  // Create expected triple nested array structure
+  // Row 1: [[[1,2], [3,4]], [[5,6,7], [8,9]], [[10,11,12,13], [14,15]]]
+  // Row 2: [[[20,21], [22,23,24]], [[25,26]], [[27,28,29], [30,31,32]]]
+  // Row 3: [[[100,101,102]], [[200,201], [300,301,302,303]], [[400,401,402],
+  // [500,501]]]
+
+  // Create the innermost arrays (level 3)
+  auto innermostArrays = makeArrayVector<int64_t>({
+      {1, 2},
+      {3, 4}, // Row 1, outer array 0
+      {5, 6, 7},
+      {8, 9}, // Row 1, outer array 1
+      {10, 11, 12, 13},
+      {14, 15}, // Row 1, outer array 2
+      {20, 21},
+      {22, 23, 24}, // Row 2, outer array 0
+      {25, 26}, // Row 2, outer array 1
+      {27, 28, 29},
+      {30, 31, 32}, // Row 2, outer array 2
+      {100, 101, 102}, // Row 3, outer array 0
+      {200, 201},
+      {300, 301, 302, 303}, // Row 3, outer array 1
+      {400, 401, 402},
+      {500, 501} // Row 3, outer array 2
+  });
+
+  // Create middle level arrays (level 2) - each contains innermost arrays
+  auto middleArrays = makeArrayVector(
+      {
+          0, // Row 1, outer array 0: contains innermost arrays [0,1]
+          2, // Row 1, outer array 1: contains innermost arrays [2,3]
+          4, // Row 1, outer array 2: contains innermost arrays [4,5]
+          6, // Row 2, outer array 0: contains innermost arrays [6,7]
+          8, // Row 2, outer array 1: contains innermost arrays [8]
+          9, // Row 2, outer array 2: contains innermost arrays [9,10]
+          11, // Row 3, outer array 0: contains innermost arrays [11]
+          12, // Row 3, outer array 1: contains innermost arrays [12,13]
+          14, // Row 3, outer array 2: contains innermost arrays [14,15]
+      },
+      innermostArrays);
+
+  // Create outermost arrays (level 1) - each row contains middle arrays
+  auto outerArray = makeArrayVector({0, 3, 6}, middleArrays);
+
+  const auto data = makeRowVector({outerArray});
+
+  const auto schema =
+      ROW({{"col_triple_nested_array", ARRAY(ARRAY(ARRAY(BIGINT())))}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_text_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath.string(),
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', ',');
+  serDeOptions.separators[3] = '#';
+
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf, serDeOptions);
+
+  EXPECT_EQ(result.size(), 3);
+  EXPECT_EQ(result[0].size(), 1);
+
+  EXPECT_EQ(result[0][0], "1#2,3#4|5#6#7,8#9|10#11#12#13,14#15");
+  EXPECT_EQ(result[1][0], "20#21,22#23#24|25#26|27#28#29,30#31#32");
+  EXPECT_EQ(
+      result[2][0], "100#101#102|200#201,300#301#302#303|400#401#402,500#501");
+}
+
+TEST_F(
+    TextWriterTest,
+    verifyTripleNestedArraysWithCustomDelimitersWithTextReader) {
+  // Create expected triple nested array structure
+  // Row 1: [[[1,2], [3,4]], [[5,6,7], [8,9]], [[10,11,12,13], [14,15]]]
+  // Row 2: [[[20,21], [22,23,24]], [[25,26]], [[27,28,29], [30,31,32]]]
+  // Row 3: [[[100,101,102]], [[200,201], [300,301,302,303]], [[400,401,402],
+  // [500,501]]]
+
+  // Create the innermost arrays (level 3)
+  auto innermostArrays = makeArrayVector<int64_t>({
+      {1, 2},
+      {3, 4}, // Row 1, outer array 0
+      {5, 6, 7},
+      {8, 9}, // Row 1, outer array 1
+      {10, 11, 12, 13},
+      {14, 15}, // Row 1, outer array 2
+      {20, 21},
+      {22, 23, 24}, // Row 2, outer array 0
+      {25, 26}, // Row 2, outer array 1
+      {27, 28, 29},
+      {30, 31, 32}, // Row 2, outer array 2
+      {100, 101, 102}, // Row 3, outer array 0
+      {200, 201},
+      {300, 301, 302, 303}, // Row 3, outer array 1
+      {400, 401, 402},
+      {500, 501} // Row 3, outer array 2
+  });
+
+  // Create middle level arrays (level 2) - each contains innermost arrays
+  auto middleArrays = makeArrayVector(
+      {
+          0, // Row 1, outer array 0: contains innermost arrays [0,1]
+          2, // Row 1, outer array 1: contains innermost arrays [2,3]
+          4, // Row 1, outer array 2: contains innermost arrays [4,5]
+          6, // Row 2, outer array 0: contains innermost arrays [6,7]
+          8, // Row 2, outer array 1: contains innermost arrays [8]
+          9, // Row 2, outer array 2: contains innermost arrays [9,10]
+          11, // Row 3, outer array 0: contains innermost arrays [11]
+          12, // Row 3, outer array 1: contains innermost arrays [12,13]
+          14, // Row 3, outer array 2: contains innermost arrays [14,15]
+          //   16 // End marker
+      },
+      innermostArrays);
+
+  // Create outermost arrays (level 1) - each row contains middle arrays
+  auto outerArray = makeArrayVector(
+      {
+          0, 3, 6
+          //   , 9 // Row boundaries: Row 1 [0-2], Row 2 [3-5], Row 3 [6-8]
+      },
+      middleArrays);
+
+  const auto data = makeRowVector({outerArray});
+
+  const auto schema =
+      ROW({{"col_triple_nested_array", ARRAY(ARRAY(ARRAY(BIGINT())))}});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  auto filePath =
+      fs::path(fmt::format("{}/test_text_writer.txt", tempPath_->getPath()));
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath.string(),
+      dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  auto serDeOptions = dwio::common::SerDeOptions('\x01', '|', ',');
+  serDeOptions.separators[3] = '#';
+
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+  writer->write(data);
+  writer->close();
+
+  // Set up reader.
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*schema, rowReaderOptions);
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+  ASSERT_EQ(rowReader->next(3, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(data.get(), i, i));
+  }
+}
+
+TEST_F(TextWriterTest, simpleEscapeCharTest) {
+  auto schema = ROW({"col_string", "col_array"}, {VARCHAR(), ARRAY(VARCHAR())});
+
+  // Create test data with strings containing comma delimiter characters
+  // Field delimiter: ',', Collection delimiter: '|', Escape char: '\'
+  auto data = makeRowVector(
+      {"col_string", "col_array"},
+      {makeFlatVector<StringView>(
+           {"engineer,manager", "developer,senior", "analyst,junior"},
+           VARCHAR()),
+       // Array column with strings containing comma delimiters
+       makeArrayVector<StringView>(
+           {{"role,title", "position,level"}, // Array with comma delimiters
+            {"job,description", "work,type"},
+            {"career,path", "skill,set"}})});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_escape_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // Configure SerDeOptions with comma as field delimiter and escaping enabled
+  auto serDeOptions = dwio::common::SerDeOptions(
+      ',', // field delimiter (comma)
+      '|', // collection delimiter
+      '#', // map key delimiter
+      '\\', // escape character
+      true // isEscaped = true
+  );
+
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+
+  writer->write(data);
+  writer->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf);
+  EXPECT_EQ(result.size(), 3);
+
+  // Verify that commas in strings are properly escaped with backslashes
+  // Temporary parse because parseTextFile is not handling escape characters
+  EXPECT_EQ(result[0][0], "engineer\\,manager,role\\,title|position\\,level");
+  EXPECT_EQ(result[1][0], "developer\\,senior,job\\,description|work\\,type");
+  EXPECT_EQ(result[2][0], "analyst\\,junior,career\\,path|skill\\,set");
+}
+
+TEST_F(TextWriterTest, verifySimpleEscapeCharTestWithTextReader) {
+  auto schema = ROW({"col_string", "col_array"}, {VARCHAR(), ARRAY(VARCHAR())});
+
+  // Create test data with strings containing comma delimiter characters
+  // Field delimiter: ',', Collection delimiter: '|', Escape char: '\'
+  auto data = makeRowVector(
+      {"col_string", "col_array"},
+      {makeFlatVector<StringView>(
+           {"engineer,manager", "developer,senior", "analyst,junior"},
+           VARCHAR()),
+       // Array column with strings containing comma delimiters
+       makeArrayVector<StringView>(
+           {{"role,title", "position,level"}, // Array with comma delimiters
+            {"job,description", "work,type"},
+            {"career,path", "skill,set"}})});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_escape_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // Configure SerDeOptions with comma as field delimiter and escaping enabled
+  auto serDeOptions = dwio::common::SerDeOptions(
+      ',', // field delimiter (comma)
+      '|', // collection delimiter
+      '#', // map key delimiter
+      '\\', // escape character
+      true // isEscaped = true
+  );
+
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+
+  writer->write(data);
+  writer->close();
+
+  // Set up reader
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*schema, rowReaderOptions);
+
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(5, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(data.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextWriterTest, customEscapeCharTest) {
+  auto schema = ROW({"col_string", "col_array"}, {VARCHAR(), ARRAY(VARCHAR())});
+
+  // Create test data with strings containing comma delimiter characters
+  // Field delimiter: ',', Collection delimiter: '|', Escape char: '\'
+  auto data = makeRowVector(
+      {"col_string", "col_array"},
+      {makeFlatVector<StringView>(
+           {"engineer,manager", "developer,senior", "analyst,junior"},
+           VARCHAR()),
+       // Array column with strings containing comma delimiters
+       makeArrayVector<StringView>(
+           {{"role,title", "position,level"}, // Array with comma delimiters
+            {"job,description", "work,type"},
+            {"career,path", "skill,set"}})});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_escape_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // Configure SerDeOptions with comma as field delimiter and escaping enabled
+  const auto serDeOptions = dwio::common::SerDeOptions(
+      ',', // field delimiter (comma)
+      '|', // collection delimiter
+      '#', // map key delimiter
+      '@', // escape character
+      true // isEscaped = true
+  );
+
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+
+  writer->write(data);
+  writer->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf);
+
+  EXPECT_EQ(result.size(), 3);
+
+  // Verify that commas in strings are properly escaped with @ character
+  EXPECT_EQ(result[0][0], "engineer@,manager,role@,title|position@,level");
+  EXPECT_EQ(result[1][0], "developer@,senior,job@,description|work@,type");
+  EXPECT_EQ(result[2][0], "analyst@,junior,career@,path|skill@,set");
+}
+
+TEST_F(TextWriterTest, verifyCustomEscapeCharTestWithTextReader) {
+  auto schema = ROW({"col_string", "col_array"}, {VARCHAR(), ARRAY(VARCHAR())});
+
+  // Create test data with strings containing comma delimiter characters
+  // Field delimiter: ',', Collection delimiter: '|', Escape char: '\'
+  auto data = makeRowVector(
+      {"col_string", "col_array"},
+      {makeFlatVector<StringView>(
+           {"engineer,manager", "developer,senior", "analyst,junior"},
+           VARCHAR()),
+       // Array column with strings containing comma delimiters
+       makeArrayVector<StringView>(
+           {{"role,title", "position,level"}, // Array with comma delimiters
+            {"job,description", "work,type"},
+            {"career,path", "skill,set"}})});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_escape_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // Configure SerDeOptions with comma as field delimiter and escaping enabled
+  const auto serDeOptions = dwio::common::SerDeOptions(
+      ',', // field delimiter (comma)
+      '|', // collection delimiter
+      '#', // map key delimiter
+      '@', // escape character
+      true // isEscaped = true
+  );
+
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+
+  writer->write(data);
+  writer->close();
+
+  // Set up reader
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  setScanSpec(*schema, rowReaderOptions);
+
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(3, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(data.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
+TEST_F(TextWriterTest, headerTest) {
+  auto schema = ROW({"name", "age", "city"}, {VARCHAR(), INTEGER(), VARCHAR()});
+
+  // Create simple test data with 3 rows
+  auto data = makeRowVector(
+      {"name", "age", "city"},
+      {makeFlatVector<StringView>({"Alice", "Bob", "Charlie"}, VARCHAR()),
+       makeFlatVector<int32_t>({25, 30, 35}),
+       makeFlatVector<StringView>({"NYC", "LA", "Chicago"}, VARCHAR())});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  writerOptions.headerLineCount = 1;
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_header_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // Use comma as field delimiter to match header format
+  const auto serDeOptions = dwio::common::SerDeOptions(',', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+
+  writer->write(data);
+  writer->close();
+
+  const auto fs = filesystems::getFileSystem(tempPath, nullptr);
+  const auto& file = fs->openFileForRead(filePath.string());
+  auto fileSize = file->size();
+
+  BufferPtr charBuf = AlignedBuffer::allocate<char>(fileSize, pool());
+  auto rawCharBuf = charBuf->asMutable<char>();
+  std::vector<std::vector<std::string>> result =
+      parseTextFile(tempPath, filename, rawCharBuf, serDeOptions);
+
+  EXPECT_EQ(result.size(), 4); // Header + 3 data rows
+  EXPECT_EQ(result[0].size(), 3);
+
+  // Verify header is first row
+  EXPECT_EQ(result[0][0], "name");
+  EXPECT_EQ(result[0][1], "age");
+  EXPECT_EQ(result[0][2], "city");
+
+  // Verify data rows
+  EXPECT_EQ(result[1][0], "Alice");
+  EXPECT_EQ(result[1][1], "25");
+  EXPECT_EQ(result[1][2], "NYC");
+
+  EXPECT_EQ(result[2][0], "Bob");
+  EXPECT_EQ(result[2][1], "30");
+  EXPECT_EQ(result[2][2], "LA");
+
+  EXPECT_EQ(result[3][0], "Charlie");
+  EXPECT_EQ(result[3][1], "35");
+  EXPECT_EQ(result[3][2], "Chicago");
+}
+
+TEST_F(TextWriterTest, verifyHeaderTestWithTextReader) {
+  auto schema = ROW({"name", "age", "city"}, {VARCHAR(), INTEGER(), VARCHAR()});
+
+  // Create simple test data with 3 rows
+  auto data = makeRowVector(
+      {"name", "age", "city"},
+      {makeFlatVector<StringView>({"Alice", "Bob", "Charlie"}, VARCHAR()),
+       makeFlatVector<int32_t>({25, 30, 35}),
+       makeFlatVector<StringView>({"NYC", "LA", "Chicago"}, VARCHAR())});
+
+  WriterOptions writerOptions;
+  writerOptions.memoryPool = rootPool_.get();
+  writerOptions.headerLineCount = 1;
+
+  const auto tempPath = tempPath_->getPath();
+  const auto filename = "test_header_writer.txt";
+  auto filePath = fs::path(fmt::format("{}/{}", tempPath, filename));
+
+  auto sink = std::make_unique<dwio::common::LocalFileSink>(
+      filePath, dwio::common::FileSink::Options{.pool = leafPool_.get()});
+
+  // Use comma as field delimiter to match header format
+  const auto serDeOptions = dwio::common::SerDeOptions(',', '|', '#');
+  auto writer = std::make_unique<TextWriter>(
+      schema,
+      std::move(sink),
+      std::make_shared<text::WriterOptions>(writerOptions),
+      serDeOptions);
+
+  writer->write(data);
+  writer->close();
+
+  // Set up reader
+  auto readerFactory =
+      dwio::common::getReaderFactory(dwio::common::FileFormat::TEXT);
+  auto readFile = std::make_shared<LocalReadFile>(filePath.string());
+  auto readerOptions = dwio::common::ReaderOptions(pool());
+  readerOptions.setFileSchema(schema);
+  readerOptions.setSerDeOptions(serDeOptions);
+
+  auto input =
+      std::make_unique<dwio::common::BufferedInput>(readFile, poolRef());
+  auto reader = readerFactory->createReader(std::move(input), readerOptions);
+  dwio::common::RowReaderOptions rowReaderOptions;
+  rowReaderOptions.setSkipRows(1);
+  setScanSpec(*schema, rowReaderOptions);
+
+  auto rowReader = reader->createRowReader(rowReaderOptions);
+  EXPECT_EQ(*reader->rowType(), *schema);
+
+  VectorPtr result;
+
+  ASSERT_EQ(rowReader->next(3, result), 3);
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_TRUE(result->equalValueAt(data.get(), i, i));
+  }
+  ASSERT_EQ(rowReader->next(10, result), 0);
+}
+
 } // namespace facebook::velox::text
diff --git a/velox/dwio/text/writer/TextWriter.cpp b/velox/dwio/text/writer/TextWriter.cpp
index 2b3c79ab9a90..0293fa4ee832 100644
--- a/velox/dwio/text/writer/TextWriter.cpp
+++ b/velox/dwio/text/writer/TextWriter.cpp
@@ -15,13 +15,14 @@
  */
 
 #include "velox/dwio/text/writer/TextWriter.h"
+#include "velox/common/encode/Base64.h"
 
 #include <utility>
-#include "velox/common/base/Pointers.h"
-#include "velox/common/encode/Base64.h"
-#include "velox/exec/MemoryReclaimer.h"
 
 namespace facebook::velox::text {
+
+using dwio::common::SerDeOptions;
+
 template <typename T>
 std::optional<std::string> toTextStr(T val) {
   return std::optional(std::to_string(val));
@@ -57,6 +58,7 @@ std::optional<std::string> toTextStr<double>(double val) {
 template <>
 std::optional<std::string> toTextStr<Timestamp>(Timestamp val) {
   TimestampToStringOptions options;
+  val.toTimezone(Timestamp::defaultTimezone());
   options.dateTimeSeparator = ' ';
   options.precision = TimestampPrecision::kMilliseconds;
   return {val.toString(options)};
@@ -65,24 +67,83 @@ std::optional<std::string> toTextStr<Timestamp>(Timestamp val) {
 TextWriter::TextWriter(
     RowTypePtr schema,
     std::unique_ptr<dwio::common::FileSink> sink,
-    const std::shared_ptr<text::WriterOptions>& options)
+    const std::shared_ptr<text::WriterOptions>& options,
+    const SerDeOptions& serDeOptions)
     : schema_(std::move(schema)),
-      bufferedWriterSink_(std::make_unique<BufferedWriterSink>(
-          std::move(sink),
-          options->memoryPool->addLeafChild(fmt::format(
-              "{}.text_writer_node.{}",
-              options->memoryPool->name(),
-              folly::to<std::string>(folly::Random::rand64()))),
-          options->defaultFlushCount)) {}
+      bufferedWriterSink_(
+          std::make_unique<BufferedWriterSink>(
+              std::move(sink),
+              options->memoryPool->addLeafChild(
+                  fmt::format(
+                      "{}.text_writer_node.{}",
+                      options->memoryPool->name(),
+                      folly::to<std::string>(folly::Random::rand64()))),
+              options->defaultFlushCount)),
+      headerLineCount_(options->headerLineCount),
+      serDeOptions_(serDeOptions) {
+  VELOX_CHECK_LE(headerLineCount_, 1, "Header line count must be <= 1");
+}
+
+uint8_t TextWriter::getDelimiterForDepth(uint8_t depth) const {
+  VELOX_CHECK_LT(
+      depth,
+      serDeOptions_.separators.size(),
+      "Depth {} exceeds maximum supported depth",
+      depth);
+  return serDeOptions_.separators[depth];
+}
+
+// Adds escape characters before separator/delimiting characters in the input
+// string.
+std::string TextWriter::addEscapeChar(std::string&& data, uint8_t depth) {
+  if (!serDeOptions_.isEscaped) {
+    return std::move(data);
+  }
+
+  std::string escapedData;
+  escapedData.reserve(data.length() * 2);
+
+  for (size_t i = 0; i < data.length(); ++i) {
+    // Break out of the loop earlier if we count down.
+    for (int j = depth - 1; j >= 0; --j) {
+      if (data[i] == serDeOptions_.separators[j]) {
+        escapedData += static_cast<char>(serDeOptions_.escapeChar);
+        break;
+      }
+    }
+    escapedData += data[i];
+  }
+
+  return escapedData;
+}
 
 void TextWriter::write(const VectorPtr& data) {
   VELOX_CHECK_EQ(
       data->encoding(),
       VectorEncoding::Simple::ROW,
       "Text writer expects row vector input");
+
   VELOX_CHECK(
       data->type()->equivalent(*schema_),
       "The file schema type should be equal with the input row vector type.");
+
+  // write 1 row of header
+  if (headerLineCount_ == 1) {
+    const auto numCols = schema_->size();
+    for (column_index_t col = 0; col < numCols; ++col) {
+      if (col != 0) {
+        bufferedWriterSink_->write((char)serDeOptions_.separators[0]);
+      }
+
+      std::string escapedcolName =
+          addEscapeChar(std::string(schema_->nameOf(col)), 0);
+      bufferedWriterSink_->write(
+          escapedcolName.data(), escapedcolName.length());
+    }
+
+    bufferedWriterSink_->write((char)serDeOptions_.newLine);
+  }
+
   const RowVector* dataRowVector = data->as<RowVector>();
 
   std::vector<std::shared_ptr<DecodedVector>> decodedColumnVectors;
@@ -94,15 +155,19 @@ void TextWriter::write(const VectorPtr& data) {
     decodedColumnVectors.push_back(std::move(decodedColumnVector));
   }
 
+  std::optional<uint8_t> delimiter;
   for (vector_size_t row = 0; row < data->size(); ++row) {
     for (size_t column = 0; column < numColumns; ++column) {
-      if (column != 0) {
-        bufferedWriterSink_->write(TextFileTraits::kSOH);
-      }
+      delimiter = (column == 0) ? std::nullopt
+                                : std::optional(serDeOptions_.separators[0]);
       writeCellValue(
-          decodedColumnVectors.at(column), schema_->childAt(column), row);
+          decodedColumnVectors.at(column),
+          schema_->childAt(column)->kind(),
+          row,
+          0,
+          delimiter);
     }
-    bufferedWriterSink_->write(TextFileTraits::kNewLine);
+    bufferedWriterSink_->write((char)serDeOptions_.newLine);
   }
 }
 
@@ -120,73 +185,186 @@ void TextWriter::abort() {
 
 void TextWriter::writeCellValue(
     const std::shared_ptr<DecodedVector>& decodedColumnVector,
-    const TypePtr& type,
-    vector_size_t row) {
-  std::optional<std::string> dataStr;
-  std::optional<StringView> dataSV;
+    const TypeKind type,
+    vector_size_t row,
+    uint8_t depth,
+    std::optional<uint8_t> delimiter) {
+  if (delimiter.has_value()) {
+    bufferedWriterSink_->write((char)delimiter.value());
+  }
 
   if (decodedColumnVector->isNullAt(row)) {
+    std::string escapedNullString =
+        addEscapeChar(std::string(serDeOptions_.nullString), depth);
     bufferedWriterSink_->write(
-        TextFileTraits::kNullData.data(), TextFileTraits::kNullData.length());
+        escapedNullString.data(), escapedNullString.length());
     return;
   }
-  switch (type->kind()) {
-    case TypeKind::BOOLEAN:
+
+  ++depth;
+
+  /// TODO: Increase supported depth in future
+  VELOX_CHECK_LE(depth, 4, "Depth {} exceeds maximum supported depth", 4);
+
+  std::optional<std::string> dataStr = std::nullopt;
+  std::optional<StringView> dataSV = std::nullopt;
+
+  switch (type) {
+    case TypeKind::BOOLEAN: {
       dataStr =
           toTextStr(folly::to<bool>(decodedColumnVector->valueAt<bool>(row)));
       break;
-    case TypeKind::TINYINT:
+    }
+    case TypeKind::TINYINT: {
       dataStr = toTextStr(decodedColumnVector->valueAt<int8_t>(row));
       break;
-    case TypeKind::SMALLINT:
+    }
+    case TypeKind::SMALLINT: {
       dataStr = toTextStr(decodedColumnVector->valueAt<int16_t>(row));
       break;
-    case TypeKind::INTEGER:
+    }
+    case TypeKind::INTEGER: {
       dataStr = toTextStr(decodedColumnVector->valueAt<int32_t>(row));
       break;
-    case TypeKind::BIGINT:
+    }
+    case TypeKind::BIGINT: {
       dataStr = toTextStr(decodedColumnVector->valueAt<int64_t>(row));
       break;
-    case TypeKind::REAL:
+    }
+    case TypeKind::REAL: {
       dataStr = toTextStr(decodedColumnVector->valueAt<float>(row));
       break;
-    case TypeKind::DOUBLE:
+    }
+    case TypeKind::DOUBLE: {
       dataStr = toTextStr(decodedColumnVector->valueAt<double>(row));
       break;
-    case TypeKind::TIMESTAMP:
+    }
+    case TypeKind::TIMESTAMP: {
       dataStr = toTextStr(decodedColumnVector->valueAt<Timestamp>(row));
       break;
-    case TypeKind::VARCHAR:
+    }
+    case TypeKind::VARCHAR: {
       dataSV = std::optional(decodedColumnVector->valueAt<StringView>(row));
       break;
+    }
     case TypeKind::VARBINARY: {
       auto data = decodedColumnVector->valueAt<StringView>(row);
       dataStr =
           std::optional(encoding::Base64::encode(data.data(), data.size()));
       break;
     }
-    // TODO Add support for complex types
-    case TypeKind::ARRAY:
+    case TypeKind::ARRAY: {
+      // ARRAY vector members
+      const auto& arrVecPtr = decodedColumnVector->base()->as<ArrayVector>();
+      const auto& indices = decodedColumnVector->indices();
+      const auto& size = arrVecPtr->sizeAt(indices[row]);
+      const auto& offset = arrVecPtr->offsetAt(indices[row]);
+
+      auto slice = arrVecPtr->elements()->slice(offset, size);
+      auto decodedElement =
+          std::make_shared<DecodedVector>(DecodedVector(*slice));
+      for (int i = 0; i < size; ++i) {
+        delimiter = (i == 0) ? std::nullopt
+                             : std::optional(getDelimiterForDepth(depth));
+        writeCellValue(
+            decodedElement,
+            arrVecPtr->elements().get()->typeKind(),
+            i,
+            depth,
+            delimiter);
+      }
+      return;
+    }
+    case TypeKind::MAP: {
+      // MAP vector members
+      const auto& mapVecPtr = decodedColumnVector->base()->as<MapVector>();
+      const auto& indices = decodedColumnVector->indices();
+      const auto& size = mapVecPtr->sizeAt(indices[row]);
+      const auto& offset = mapVecPtr->offsetAt(indices[row]);
+
+      auto keySlice = mapVecPtr->mapKeys()->slice(offset, size);
+      auto decodedKeys =
+          std::make_shared<DecodedVector>(DecodedVector(*keySlice));
+
+      auto valSlice = mapVecPtr->mapValues()->slice(offset, size);
+      auto decodedValues =
+          std::make_shared<DecodedVector>(DecodedVector(*valSlice));
+
+      for (int i = 0; i < size; ++i) {
+        delimiter = (i == 0) ? std::nullopt
+                             : std::optional(getDelimiterForDepth(depth));
+        writeCellValue(
+            decodedKeys,
+            mapVecPtr->mapKeys().get()->typeKind(),
+            i,
+            depth,
+            delimiter);
+
+        delimiter = std::optional(getDelimiterForDepth(depth + 1));
+        writeCellValue(
+            decodedValues,
+            mapVecPtr->mapValues().get()->typeKind(),
+            i,
+            depth,
+            delimiter);
+      }
+
+      return;
+    }
+    case TypeKind::ROW: {
+      const RowVector* rowVecPtr = decodedColumnVector->base()->as<RowVector>();
+      const auto& indices = decodedColumnVector->indices();
+      const auto actualRowIndex = indices[row];
+
+      std::vector<std::shared_ptr<DecodedVector>> decodedColumnVectors;
+      const auto numColumns = rowVecPtr->childrenSize();
+      for (size_t column = 0; column < numColumns; ++column) {
+        auto decodedColumnVector =
+            std::make_shared<DecodedVector>(DecodedVector(
+                *rowVecPtr->childAt(column),
+                SelectivityVector(rowVecPtr->size())));
+        decodedColumnVectors.push_back(std::move(decodedColumnVector));
+      }
+
+      std::optional<char> nestedRowDelimiter;
+      for (size_t column = 0; column < numColumns; ++column) {
+        nestedRowDelimiter = (column == 0)
+            ? std::nullopt
+            : std::optional(getDelimiterForDepth(depth));
+        writeCellValue(
+            decodedColumnVectors.at(column),
+            rowVecPtr->childAt(column)->typeKind(),
+            actualRowIndex,
+            depth,
+            nestedRowDelimiter);
+      }
+      return;
+    }
+    case TypeKind::UNKNOWN:
       [[fallthrough]];
-    case TypeKind::MAP:
+    case TypeKind::FUNCTION:
       [[fallthrough]];
-    case TypeKind::ROW:
+    case TypeKind::OPAQUE:
       [[fallthrough]];
-    case TypeKind::UNKNOWN:
+    case TypeKind::INVALID:
       [[fallthrough]];
     default:
-      VELOX_NYI("{} is not supported yet in TextWriter", type->kind());
+      VELOX_NYI(
+          "Text writer does not support type {}", TypeKindName::toName(type));
   }
 
-  if (dataStr.has_value()) {
-    VELOX_CHECK(!dataSV.has_value());
-    bufferedWriterSink_->write(
-        dataStr.value().data(), dataStr.value().length());
-    return;
-  }
+  VELOX_CHECK(
+      dataStr.has_value() ^ dataSV.has_value(),
+      "Exactly one of dataStr or dataSV must be set. Currently dataStr is {} and dataSV is {}",
+      dataStr.has_value(),
+      dataSV.has_value());
+
+  std::string data = dataStr.has_value()
+      ? dataStr.value()
+      : std::string(dataSV.value().data(), dataSV.value().size());
 
-  VELOX_CHECK(dataSV.has_value());
-  bufferedWriterSink_->write(dataSV.value().data(), dataSV.value().size());
+  std::string escapedData = addEscapeChar(std::move(data), depth);
+  bufferedWriterSink_->write(escapedData.data(), escapedData.length());
 }
 
 std::unique_ptr<dwio::common::Writer> TextWriterFactory::createWriter(
diff --git a/velox/dwio/text/writer/TextWriter.h b/velox/dwio/text/writer/TextWriter.h
index 43389a6fbf06..2ec11b82685b 100644
--- a/velox/dwio/text/writer/TextWriter.h
+++ b/velox/dwio/text/writer/TextWriter.h
@@ -16,38 +16,20 @@
 
 #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/text/writer/BufferedWriterSink.h"
-#include "velox/vector/ComplexVector.h"
 
 namespace facebook::velox::text {
 
+using dwio::common::SerDeOptions;
+
 struct WriterOptions : public dwio::common::WriterOptions {
   int64_t defaultFlushCount = 10 << 10;
-};
-
-// TODO: move to a separate file to be shared with text reader once it is in oss
-class TextFileTraits {
- public:
-  //// The following constants define the delimiters used by TextFile format.
-  /// Each row is separated by 'kNewLine'.
-  /// Each column is separated by 'kSOH' within each row.
-
-  /// String for null data.
-  static inline const std::string kNullData = "\\N";
-
-  /// Delimiter between columns.
-  static const char kSOH = '\x01';
-
-  /// Delimiter between rows.
-  static const char kNewLine = '\n';
+  uint8_t headerLineCount =
+      0; // number of lines in the header, currently only support 0 or 1
 };
 
 /// Encodes Velox vectors in TextFormat and writes into a FileSink.
@@ -58,10 +40,12 @@ class TextWriter : public dwio::common::Writer {
   /// non-null.
   /// @param sink output sink
   /// @param options writer options
+  /// @param serDeOptions specifies the serialization options
   TextWriter(
       RowTypePtr schema,
       std::unique_ptr<dwio::common::FileSink> sink,
-      const std::shared_ptr<text::WriterOptions>& options);
+      const std::shared_ptr<text::WriterOptions>& options,
+      const SerDeOptions& serDeOptions = SerDeOptions());
 
   ~TextWriter() override = default;
 
@@ -79,13 +63,22 @@ class TextWriter : public dwio::common::Writer {
   void abort() override;
 
  private:
+  uint8_t getDelimiterForDepth(uint8_t depth) const;
+
   void writeCellValue(
       const std::shared_ptr<DecodedVector>& decodedColumnVector,
-      const TypePtr& type,
-      vector_size_t row);
+      TypeKind type,
+      vector_size_t row,
+      uint8_t depth,
+      std::optional<uint8_t> delimiter);
+
+  std::string addEscapeChar(std::string&& dataToWrite, uint8_t depth);
 
   const RowTypePtr schema_;
   const std::unique_ptr<BufferedWriterSink> bufferedWriterSink_;
+
+  uint8_t headerLineCount_;
+  SerDeOptions serDeOptions_;
 };
 
 class TextWriterFactory : public dwio::common::WriterFactory {
diff --git a/velox/examples/CMakeLists.txt b/velox/examples/CMakeLists.txt
index bdad72ce9d4d..a4b29fc0efef 100644
--- a/velox/examples/CMakeLists.txt
+++ b/velox/examples/CMakeLists.txt
@@ -20,7 +20,8 @@ target_link_libraries(
   velox_core
   velox_expression
   re2::re2
-  simdjson::simdjson)
+  simdjson::simdjson
+)
 
 add_executable(velox_example_expression_eval ExpressionEval.cpp)
 
@@ -30,7 +31,8 @@ target_link_libraries(
   velox_vector
   velox_caching
   velox_memory
-  velox_expression)
+  velox_expression
+)
 
 add_executable(velox_example_opaque_type OpaqueType.cpp)
 target_link_libraries(
@@ -39,7 +41,8 @@ target_link_libraries(
   velox_vector
   velox_caching
   velox_expression
-  velox_memory)
+  velox_memory
+)
 
 # This is disabled temporarily until we figure out why g++ is crashing linking
 # it on linux builds.
@@ -59,12 +62,12 @@ target_link_libraries(
   velox_exec
   velox_exec_test_lib
   velox_hive_connector
-  velox_memory)
+  velox_memory
+)
 
 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(
@@ -74,4 +77,5 @@ target_link_libraries(
   velox_exec
   velox_exec_test_lib
   velox_memory
-  velox_vector_test_lib)
+  velox_vector_test_lib
+)
diff --git a/velox/examples/ExpressionEval.cpp b/velox/examples/ExpressionEval.cpp
index 4fcf101ee599..ef12f250b7e3 100644
--- a/velox/examples/ExpressionEval.cpp
+++ b/velox/examples/ExpressionEval.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/memory/Memory.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/Udf.h"
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
@@ -102,9 +103,7 @@ int main(int argc, char** argv) {
   // would be automatically and recursively generated based on some input IDL
   // (or by a SQL string parser).
   auto exprTree = std::make_shared<core::CallTypedExpr>(
-      BIGINT(),
-      std::vector<core::TypedExprPtr>{fieldAccessExprNode},
-      "times_two");
+      BIGINT(), "times_two", fieldAccessExprNode);
 
   // Lastly, ExprSet contains the main expression evaluation logic. It takes a
   // vector of expression trees (if there are multiple expressions to be
diff --git a/velox/examples/OpaqueType.cpp b/velox/examples/OpaqueType.cpp
index 2ed05105e6e9..96757c08e1e5 100644
--- a/velox/examples/OpaqueType.cpp
+++ b/velox/examples/OpaqueType.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/memory/Memory.h"
+#include "velox/core/Expressions.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/Udf.h"
 #include "velox/type/Type.h"
@@ -323,9 +324,9 @@ VectorPtr evaluate(
 
   auto exprPlan = std::make_shared<core::CallTypedExpr>(
       OPAQUE<UserDefinedOutput>(),
-      std::vector<core::TypedExprPtr>{
-          fieldAccessExprNode1, fieldAccessExprNode2},
-      functionName);
+      functionName,
+      fieldAccessExprNode1,
+      fieldAccessExprNode2);
 
   exec::ExprSet exprSet({exprPlan}, &execCtx);
   exec::EvalCtx evalCtx(&execCtx, &exprSet, rowVector.get());
diff --git a/velox/examples/OperatorExtensibility.cpp b/velox/examples/OperatorExtensibility.cpp
index 6f48b4e9bbd6..a6e4aaec682b 100644
--- a/velox/examples/OperatorExtensibility.cpp
+++ b/velox/examples/OperatorExtensibility.cpp
@@ -124,8 +124,9 @@ class DuplicateRowOperator : public exec::Operator {
     outputChildren.reserve(input->childrenSize());
 
     for (const auto& child : input->children()) {
-      outputChildren.push_back(BaseVector::wrapInDictionary(
-          BufferPtr(), indices, outputSize, child));
+      outputChildren.push_back(
+          BaseVector::wrapInDictionary(
+              BufferPtr(), indices, outputSize, child));
     }
     return std::make_shared<RowVector>(
         pool(),
diff --git a/velox/examples/ScanAndSort.cpp b/velox/examples/ScanAndSort.cpp
index 67aa80c67a32..6e27f5d01db6 100644
--- a/velox/examples/ScanAndSort.cpp
+++ b/velox/examples/ScanAndSort.cpp
@@ -23,13 +23,13 @@
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h"
 #include "velox/exec/Task.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"
 #include "velox/vector/BaseVector.h"
 
 #include <folly/init/Init.h>
+#include <folly/system/HardwareConcurrency.h>
 #include <algorithm>
 
 using namespace facebook::velox;
@@ -85,18 +85,12 @@ int main(int argc, char** argv) {
   // We need a connector id string to identify the connector.
   const std::string kHiveConnectorId = "test-hive";
 
-  // Register the Hive Connector Factory.
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
-  // Create a new connector instance from the connector factory and register
-  // it:
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              kHiveConnectorId,
-              std::make_shared<config::ConfigBase>(
-                  std::unordered_map<std::string, std::string>()));
+  // Create a new connector instance and register it.
+  connector::hive::HiveConnectorFactory factory;
+  auto hiveConnector = factory.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
@@ -131,7 +125,7 @@ int main(int argc, char** argv) {
 
   std::shared_ptr<folly::Executor> executor(
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency()));
+          folly::hardware_concurrency()));
 
   // Task is the top-level execution concept. A task needs a taskId (as a
   // string), the plan fragment to execute, a destination (only used for
@@ -141,7 +135,8 @@ int main(int argc, char** argv) {
       writerPlanFragment,
       /*destination=*/0,
       core::QueryCtx::create(executor.get()),
-      exec::Task::ExecutionMode::kSerial);
+      exec::Task::ExecutionMode::kSerial,
+      exec::Consumer{});
 
   // next() starts execution using the client thread. The loop pumps output
   // vectors out of the task (there are none in this query fragment).
@@ -171,7 +166,8 @@ int main(int argc, char** argv) {
       readPlanFragment,
       /*destination=*/0,
       core::QueryCtx::create(executor.get()),
-      exec::Task::ExecutionMode::kSerial);
+      exec::Task::ExecutionMode::kSerial,
+      exec::Consumer{});
 
   // Now that we have the query fragment and Task structure set up, we will
   // add data to it via `splits`.
diff --git a/velox/examples/SimpleFunctions.cpp b/velox/examples/SimpleFunctions.cpp
index 4c12cb4bf510..e34b0598a227 100644
--- a/velox/examples/SimpleFunctions.cpp
+++ b/velox/examples/SimpleFunctions.cpp
@@ -341,7 +341,7 @@ struct MyRegexpMatchFunction {
     // quite expensive to compile it on a per-row basis. In this example we
     // support both modes (const and non-const).
     if (pattern != nullptr) {
-      re_.emplace(*pattern);
+      re_.emplace(std::string_view(*pattern));
     }
 
     // Optionally, one could also inspect the session configs in `QueryConfig`.
@@ -359,7 +359,8 @@ struct MyRegexpMatchFunction {
     // > `my_regexp_match(col1, col2)`
     result = re_.has_value()
         ? RE2::PartialMatch(toStringPiece(input), *re_)
-        : RE2::PartialMatch(toStringPiece(input), ::re2::RE2(pattern));
+        : RE2::PartialMatch(
+              toStringPiece(input), ::re2::RE2(std::string_view(pattern)));
     return true;
   }
 
diff --git a/velox/exec/Aggregate.cpp b/velox/exec/Aggregate.cpp
index b56158145d88..003f669e66ae 100644
--- a/velox/exec/Aggregate.cpp
+++ b/velox/exec/Aggregate.cpp
@@ -20,7 +20,6 @@
 #include "velox/exec/AggregateCompanionAdapter.h"
 #include "velox/exec/AggregateCompanionSignatures.h"
 #include "velox/exec/AggregateWindow.h"
-#include "velox/expression/SignatureBinder.h"
 
 namespace facebook::velox::exec {
 
@@ -244,32 +243,6 @@ std::vector<CompanionSignatureEntry> getCompanionSignaturesWithSuffix(
   return entries;
 }
 
-// Selects the signature by name and argument types. Returns the resolved result
-// type for the type signature retrieved by the callback. Throws a user
-// exception if the corresponding signature isn't found.
-TypePtr resolveResultType(
-    const std::string& name,
-    const std::vector<TypePtr>& argTypes,
-    const std::function<const TypeSignature&(
-        const AggregateFunctionSignature&)>& getResultType) {
-  auto signatures = exec::getAggregateFunctionSignatures(name);
-  if (!signatures.has_value()) {
-    VELOX_USER_FAIL("Aggregate function not registered: {}", name);
-  }
-  for (auto& signature : signatures.value()) {
-    SignatureBinder binder(*signature, argTypes);
-    if (binder.tryBind()) {
-      return binder.tryResolveType(getResultType(*signature));
-    }
-  }
-
-  std::stringstream error;
-  error << "Aggregate function signature is not supported: "
-        << toString(name, argTypes)
-        << ". Supported signatures: " << toString(signatures.value()) << ".";
-  VELOX_USER_FAIL(error.str());
-}
-
 } // namespace
 
 std::optional<CompanionFunctionSignatureMap> getCompanionFunctionSignatures(
@@ -321,24 +294,6 @@ std::unique_ptr<Aggregate> Aggregate::create(
     const std::vector<TypePtr>& argTypes,
     const TypePtr& resultType,
     const core::QueryConfig& config) {
-  // TODO(timaou, kletkavrubashku): Reneable the validation once "regr_slope"
-  // signature is fixed
-  //
-  // Validate the result type. if (isPartialOutput(step)) {
-  //   auto intermediateType = Aggregate::intermediateType(name, argTypes);
-  //   VELOX_CHECK(
-  //       resultType->equivalent(*intermediateType),
-  //       "Intermediate type mismatch. Expected: {}, actual: {}",
-  //       intermediateType->toString(),
-  //       resultType->toString());
-  // } else {
-  //   auto finalType = Aggregate::finalType(name, argTypes);
-  //   VELOX_CHECK(
-  //       resultType->equivalent(*finalType),
-  //       "Final type mismatch. Expected: {}, actual: {}",
-  //       finalType->toString(),
-  //       resultType->toString());
-  // }
   // Lookup the function in the new registry first.
   if (auto func = getAggregateFunctionEntry(name)) {
     return func->factory(step, argTypes, resultType, config);
@@ -347,40 +302,6 @@ std::unique_ptr<Aggregate> Aggregate::create(
   VELOX_USER_FAIL("Aggregate function not registered: {}", name);
 }
 
-// static
-TypePtr Aggregate::intermediateType(
-    const std::string& name,
-    const std::vector<TypePtr>& argTypes) {
-  auto type = resolveResultType(
-      name,
-      argTypes,
-      [](const AggregateFunctionSignature& signature) -> const TypeSignature& {
-        return signature.intermediateType();
-      });
-  VELOX_USER_CHECK(
-      type,
-      "Cannot resolve intermediate type for aggregate function {}",
-      toString(name, argTypes));
-  return type;
-}
-
-// static
-TypePtr Aggregate::finalType(
-    const std::string& name,
-    const std::vector<TypePtr>& argTypes) {
-  auto type = resolveResultType(
-      name,
-      argTypes,
-      [](const AggregateFunctionSignature& signature) -> const TypeSignature& {
-        return signature.returnType();
-      });
-  VELOX_USER_CHECK(
-      type,
-      "Cannot resolve final type for aggregate function {}",
-      toString(name, argTypes));
-  return type;
-}
-
 void Aggregate::setLambdaExpressions(
     std::vector<core::LambdaTypedExprPtr> lambdaExpressions,
     std::shared_ptr<core::ExpressionEvaluator> expressionEvaluator) {
diff --git a/velox/exec/Aggregate.h b/velox/exec/Aggregate.h
index 8ed6c88a02e4..a3052ea9daca 100644
--- a/velox/exec/Aggregate.h
+++ b/velox/exec/Aggregate.h
@@ -341,18 +341,6 @@ class Aggregate {
       const TypePtr& resultType,
       const core::QueryConfig& config);
 
-  // Returns the intermediate type for 'name' with signature
-  // 'argTypes'. Throws if cannot resolve.
-  static TypePtr intermediateType(
-      const std::string& name,
-      const std::vector<TypePtr>& argTypes);
-
-  // Returns the final type for 'name' with signature
-  // 'argTypes'. Throws if cannot resolve.
-  static TypePtr finalType(
-      const std::string& name,
-      const std::vector<TypePtr>& argTypes);
-
  protected:
   virtual void setAllocatorInternal(HashStringAllocator* allocator);
 
@@ -446,7 +434,7 @@ class Aggregate {
     if (isInitialized(group)) {
       auto accumulator = value<T>(group);
       std::destroy_at(accumulator);
-      ::memset(accumulator, 0, sizeof(T));
+      ::memset(static_cast<void*>(accumulator), 0, sizeof(T));
     }
   }
 
@@ -517,6 +505,10 @@ using AggregateFunctionFactory = std::function<std::unique_ptr<Aggregate>(
     const core::QueryConfig& config)>;
 
 struct AggregateFunctionMetadata {
+  /// True if results of the aggregation ignore duplicate values.
+  /// For example, min and max ignore duplicates while sum does not.
+  bool ignoreDuplicates{false};
+
   /// 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};
diff --git a/velox/exec/AggregateCompanionAdapter.cpp b/velox/exec/AggregateCompanionAdapter.cpp
index ea3c64c5c9ea..9aab4fbac9b0 100644
--- a/velox/exec/AggregateCompanionAdapter.cpp
+++ b/velox/exec/AggregateCompanionAdapter.cpp
@@ -340,25 +340,35 @@ bool registerMergeExtractFunctionInternal(
              mergeExtractFunctionName,
              std::move(mergeExtractSignatures),
              [name, mergeExtractFunctionName](
-                 core::AggregationNode::Step /*step*/,
+                 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 resolvable given
-                 // intermediate type of the original UDAF.
-                 VELOX_UNREACHABLE(
-                     "Signatures whose result types are not resolvable given intermediate types should have been excluded.");
+               TypePtr functionResultType;
+               if (step == core::AggregationNode::Step::kFinal ||
+                   step == core::AggregationNode::Step::kSingle) {
+                 functionResultType = resultType;
+               } else {
+                 // When step is kPartial or kIntermediate, 'resultType' is
+                 // the intermediate type and the original result type needs to
+                 // be resolved for the aggregate function creation.
+                 const auto& originalResultType =
+                     resolveResultType(mergeExtractFunctionName, argTypes);
+                 if (!originalResultType) {
+                   // Result type must be resolvable given intermediate type of
+                   // the original UDAF.
+                   VELOX_FAIL(
+                       "Signatures' result types must be resolvable given intermediate types.");
+                 }
+                 functionResultType = originalResultType;
                }
 
                if (auto func = getAggregateFunctionEntry(name)) {
                  auto fn = func->factory(
                      core::AggregationNode::Step::kFinal,
                      argTypes,
-                     originalResultType,
+                     functionResultType,
                      config);
                  VELOX_CHECK_NOT_NULL(fn);
                  return std::make_unique<
diff --git a/velox/exec/AggregateCompanionAdapter.h b/velox/exec/AggregateCompanionAdapter.h
index 8a6af66ff514..fc0a5909f8a6 100644
--- a/velox/exec/AggregateCompanionAdapter.h
+++ b/velox/exec/AggregateCompanionAdapter.h
@@ -169,21 +169,35 @@ struct AggregateCompanionAdapter {
   };
 };
 
+/// In Velox, "Step" is a property of the aggregate operator, whereas in
+/// Spark, it is tied to individual aggregate functions. Spark executes
+/// aggregates using a mix of partial, intermediate, and final aggregate
+/// functions. To bridge the two systems, the planner translates Spark's
+/// aggregate modes into corresponding Velox companion functions and assigns
+/// the "single" step to Velox’s AggregationNode. These companion functions
+/// are intended for internal use within the aggregate operator and are not
+/// designed to be used as standalone functions, and their result types
+/// may not always be inferable from intermediate types. More details can be
+/// found in
+/// https://github.com/facebookincubator/velox/pull/11999#issuecomment-3274577979
+/// and https://github.com/facebookincubator/velox/issues/12830.
 class CompanionFunctionsRegistrar {
  public:
-  // Register the partial companion function for an aggregation function of
-  // `name` and `signatures`. When there is already a function of the same name,
-  // if `overwrite` is true, the registration is replaced. Otherwise, return
-  // false without overwriting the registry.
+  /// Register the partial companion function for an aggregate function of
+  /// `name` and `signatures`. When there is already a function of the same
+  /// name, if `overwrite` is true, the registration is replaced. Otherwise,
+  /// return false without overwriting the registry. This function supports
+  /// generating Spark compatible companion functions.
   static bool registerPartialFunction(
       const std::string& name,
       const std::vector<AggregateFunctionSignaturePtr>& signatures,
       const AggregateFunctionMetadata& metadata,
       bool overwrite = false);
 
-  // When there is already a function of the same name as the merge companion
-  // function, if `overwrite` is true, the registration is replaced. Otherwise,
-  // return false without overwriting the registry.
+  /// When there is already a function of the same name as the merge companion
+  /// function, if `overwrite` is true, the registration is replaced. Otherwise,
+  /// return false without overwriting the registry. This function supports
+  /// generating Spark compatible companion functions.
   static bool registerMergeFunction(
       const std::string& name,
       const std::vector<AggregateFunctionSignaturePtr>& signatures,
@@ -204,14 +218,16 @@ class CompanionFunctionsRegistrar {
       const std::vector<AggregateFunctionSignaturePtr>& signatures,
       bool overwrite = false);
 
-  // Similar to registerExtractFunction(), the result type of the original
-  // aggregation function is required to be resolvable given its intermediate
-  // type. If there are multiple signatures of the original aggregation function
-  // with the same intermediate type, register merge-extract functions with
+  /// If there are multiple signatures of the original aggregate function
+  /// with the same intermediate type, register merge-extract functions with
   // suffix of their result types in the function names for each of them. When
-  // there is already a function of the same name as the merge-extract companion
-  // function, if `overwrite` is true, the registration is replaced. Otherwise,
-  // return false without overwriting the registry.
+  /// there is already a function of the same name as the merge-extract
+  /// companion function, if `overwrite` is true, the registration is replaced.
+  /// Otherwise, return false without overwriting the registry. This function
+  /// supports generating Spark compatible companion functions only when the
+  /// return types are explicitly specified (typically in "single" or "final"
+  /// steps). It will throw an exception if return types are not provided and
+  /// cannot be resolved from the intermediate types.
   static bool registerMergeExtractFunction(
       const std::string& name,
       const std::vector<AggregateFunctionSignaturePtr>& signatures,
diff --git a/velox/exec/AggregateCompanionSignatures.cpp b/velox/exec/AggregateCompanionSignatures.cpp
index 2fa7e8d11dc6..c6da4488dc62 100644
--- a/velox/exec/AggregateCompanionSignatures.cpp
+++ b/velox/exec/AggregateCompanionSignatures.cpp
@@ -102,20 +102,18 @@ CompanionSignatures::partialFunctionSignatures(
     const std::vector<AggregateFunctionSignaturePtr>& signatures) {
   std::vector<AggregateFunctionSignaturePtr> partialSignatures;
   for (const auto& signature : signatures) {
-    if (!isResultTypeResolvableGivenIntermediateType(signature)) {
-      continue;
-    }
     std::vector<TypeSignature> usedTypes = signature->argumentTypes();
     usedTypes.push_back(signature->intermediateType());
     auto variables = usedTypeVariables(usedTypes, signature->variables());
 
-    partialSignatures.push_back(std::make_shared<AggregateFunctionSignature>(
-        /*variables*/ variables,
-        /*returnType*/ signature->intermediateType(),
-        /*intermediateType*/ signature->intermediateType(),
-        /*argumentTypes*/ signature->argumentTypes(),
-        /*constantArguments*/ signature->constantArguments(),
-        /*variableArity*/ signature->variableArity()));
+    partialSignatures.push_back(
+        std::make_shared<AggregateFunctionSignature>(
+            /*variables*/ variables,
+            /*returnType*/ signature->intermediateType(),
+            /*intermediateType*/ signature->intermediateType(),
+            /*argumentTypes*/ signature->argumentTypes(),
+            /*constantArguments*/ signature->constantArguments(),
+            /*variableArity*/ signature->variableArity()));
   }
   return partialSignatures;
 }
@@ -126,10 +124,6 @@ std::string CompanionSignatures::partialFunctionName(const std::string& name) {
 
 AggregateFunctionSignaturePtr CompanionSignatures::mergeFunctionSignature(
     const AggregateFunctionSignaturePtr& signature) {
-  if (!isResultTypeResolvableGivenIntermediateType(signature)) {
-    return nullptr;
-  }
-
   std::vector<TypeSignature> usedTypes = {signature->intermediateType()};
   auto variables = usedTypeVariables(usedTypes, signature->variables());
   return std::make_shared<AggregateFunctionSignature>(
@@ -172,10 +166,6 @@ bool CompanionSignatures::hasSameIntermediateTypesAcrossSignatures(
 AggregateFunctionSignaturePtr
 CompanionSignatures::mergeExtractFunctionSignature(
     const AggregateFunctionSignaturePtr& signature) {
-  if (!isResultTypeResolvableGivenIntermediateType(signature)) {
-    return nullptr;
-  }
-
   std::vector<TypeSignature> usedTypes = {
       signature->intermediateType(), signature->returnType()};
   auto variables = usedTypeVariables(usedTypes, signature->variables());
diff --git a/velox/exec/AggregateCompanionSignatures.h b/velox/exec/AggregateCompanionSignatures.h
index ea7d4b2d6ce7..c0557adc0917 100644
--- a/velox/exec/AggregateCompanionSignatures.h
+++ b/velox/exec/AggregateCompanionSignatures.h
@@ -106,8 +106,9 @@ class CompanionSignatures {
           normalizeType(signature->intermediateType(), signature->variables());
       auto normalizedReturnType =
           normalizeType(signature->returnType(), signature->variables());
-      if (distinctIntermediateAndResultTypes.count(std::make_pair(
-              normalizedIntermediateType, normalizedReturnType))) {
+      if (distinctIntermediateAndResultTypes.count(
+              std::make_pair(
+                  normalizedIntermediateType, normalizedReturnType))) {
         continue;
       }
 
diff --git a/velox/exec/AggregateFunctionRegistry.cpp b/velox/exec/AggregateFunctionRegistry.cpp
index 4214c8490f7b..d1ec1dd987d9 100644
--- a/velox/exec/AggregateFunctionRegistry.cpp
+++ b/velox/exec/AggregateFunctionRegistry.cpp
@@ -16,28 +16,125 @@
 #include "velox/exec/AggregateFunctionRegistry.h"
 
 #include "velox/exec/Aggregate.h"
-#include "velox/expression/FunctionSignature.h"
 #include "velox/expression/SignatureBinder.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::exec {
 
-std::pair<TypePtr, TypePtr> resolveAggregateFunction(
-    const std::string& functionName,
+namespace {
+std::string makeSignatureNotSupportedError(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>&
+        signatures) {
+  std::stringstream error;
+  error << "Aggregate function signature is not supported: "
+        << toString(name, argTypes)
+        << ". Supported signatures: " << toString(signatures) << ".";
+  return error.str();
+}
+} // namespace
+
+TypePtr resolveResultType(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes) {
+  if (auto signatures = getAggregateFunctionSignatures(name)) {
+    for (const auto& signature : signatures.value()) {
+      SignatureBinder binder(*signature, argTypes);
+      if (binder.tryBind()) {
+        return binder.tryResolveReturnType();
+      }
+    }
+
+    VELOX_USER_FAIL(
+        makeSignatureNotSupportedError(name, argTypes, signatures.value()));
+  } else {
+    VELOX_USER_FAIL("Aggregate function not registered: {}", name);
+  }
+}
+
+namespace {
+bool hasCoercion(const std::vector<Coercion>& coercions) {
+  for (const auto& coercion : coercions) {
+    if (coercion.type != nullptr) {
+      return true;
+    }
+  }
+
+  return false;
+}
+} // namespace
+
+TypePtr resolveResultTypeWithCoercions(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  coercions.clear();
+
+  std::vector<std::pair<std::vector<Coercion>, TypePtr>> candidates;
+  if (auto signatures = getAggregateFunctionSignatures(name)) {
+    for (const auto& signature : signatures.value()) {
+      exec::SignatureBinder binder(*signature, argTypes);
+      std::vector<Coercion> requiredCoercions;
+      if (binder.tryBindWithCoercions(requiredCoercions)) {
+        auto type = binder.tryResolveReturnType();
+        if (!hasCoercion(requiredCoercions)) {
+          coercions.resize(argTypes.size(), nullptr);
+          return type;
+        }
+
+        candidates.emplace_back(requiredCoercions, type);
+      }
+    }
+
+    if (auto index = Coercion::pickLowestCost(candidates)) {
+      const auto& requiredCoercions = candidates[index.value()].first;
+      coercions.reserve(requiredCoercions.size());
+      for (const auto& coercion : requiredCoercions) {
+        coercions.push_back(coercion.type);
+      }
+
+      return candidates[index.value()].second;
+    }
+
+    VELOX_USER_FAIL(
+        makeSignatureNotSupportedError(name, argTypes, signatures.value()));
+  } else {
+    VELOX_USER_FAIL("Aggregate function not registered: {}", name);
+  }
+}
+
+TypePtr resolveIntermediateType(
+    const std::string& name,
     const std::vector<TypePtr>& argTypes) {
-  if (auto aggregateFunctionSignatures =
-          getAggregateFunctionSignatures(functionName)) {
-    for (const auto& signature : aggregateFunctionSignatures.value()) {
+  if (auto signatures = getAggregateFunctionSignatures(name)) {
+    for (const auto& signature : signatures.value()) {
       SignatureBinder binder(*signature, argTypes);
       if (binder.tryBind()) {
-        return std::make_pair(
-            binder.tryResolveReturnType(),
-            binder.tryResolveType(signature->intermediateType()));
+        return binder.tryResolveType(signature->intermediateType());
       }
     }
+
+    std::stringstream error;
+    error << "Aggregate function signature is not supported: "
+          << toString(name, argTypes)
+          << ". Supported signatures: " << toString(signatures.value()) << ".";
+    VELOX_USER_FAIL(error.str());
+  } else {
+    VELOX_USER_FAIL("Aggregate function not registered: {}", name);
   }
+}
+
+std::vector<std::string> getAggregateFunctionNames() {
+  std::vector<std::string> names;
+  exec::aggregateFunctions().withRLock([&](const auto& map) {
+    names.reserve(map.size());
+    for (const auto& function : map) {
+      names.push_back(function.first);
+    }
+  });
 
-  return std::make_pair(nullptr, nullptr);
+  return names;
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/AggregateFunctionRegistry.h b/velox/exec/AggregateFunctionRegistry.h
index b8d116989480..4adea534887b 100644
--- a/velox/exec/AggregateFunctionRegistry.h
+++ b/velox/exec/AggregateFunctionRegistry.h
@@ -22,11 +22,41 @@
 
 namespace facebook::velox::exec {
 
-/// Given a name of aggregate function and argument types, returns a pair of the
-/// return type and intermediate type if the function exists. Returns a pair of
-/// nullptr otherwise.
-std::pair<TypePtr, TypePtr> resolveAggregateFunction(
-    const std::string& functionName,
+/// Given a name of aggregate function and argument types, returns the result
+/// type if the function exists. Throws if function doesn't exist or doesn't
+/// support specified argument types. Since aggregate functions can be
+/// integrated into internal steps of an aggregate operator — rather than
+/// always being used as standalone functions at the SQL level — their result
+/// types may not always be inferable from the intermediate types. As a
+/// result, an exception might be thrown during the type resolution process. In
+/// such cases, the caller should explicitly specify the result type. More
+/// details can be found in
+/// https://github.com/facebookincubator/velox/pull/11999#issuecomment-3274577979
+/// and https://github.com/facebookincubator/velox/issues/12830.
+TypePtr resolveResultType(
+    const std::string& name,
     const std::vector<TypePtr>& argTypes);
 
+/// Like 'resolveResultType', but with support for applying type conversions if
+/// a function signature doesn't match 'argTypes' exactly.
+///
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve a function successfully. Contains one entry per argument. The entry
+/// is null if no coercion is required for that argument. The entry is not null
+/// if coercion is necessary.
+TypePtr resolveResultTypeWithCoercions(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions);
+
+/// Given a name of aggregate function and argument types, returns the
+/// intermediate type if the function exists. Throws if function doesn't exist
+/// or doesn't support specified argument types.
+TypePtr resolveIntermediateType(
+    const std::string& name,
+    const std::vector<TypePtr>& argTypes);
+
+/// Returns all the registered aggregation function names.
+std::vector<std::string> getAggregateFunctionNames();
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/AggregateInfo.cpp b/velox/exec/AggregateInfo.cpp
index 9b19ab687965..27a7ae551961 100644
--- a/velox/exec/AggregateInfo.cpp
+++ b/velox/exec/AggregateInfo.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/exec/AggregateInfo.h"
 #include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateFunctionRegistry.h"
 #include "velox/exec/Operator.h"
 #include "velox/expression/Expr.h"
 
@@ -80,10 +81,10 @@ std::vector<AggregateInfo> toAggregateInfo(
             arg->toString());
       }
     }
+    const auto& name = aggregate.call->name();
 
-    info.distinct = aggregate.distinct;
-    info.intermediateType = Aggregate::intermediateType(
-        aggregate.call->name(), aggregate.rawInputTypes);
+    info.intermediateType =
+        resolveIntermediateType(name, aggregate.rawInputTypes);
 
     // Setup aggregation mask: convert the Variable Reference name to the
     // channel (projection) index, if there is a mask.
@@ -96,7 +97,7 @@ std::vector<AggregateInfo> toAggregateInfo(
     auto index = numKeys + i;
     const auto& aggResultType = outputType->childAt(index);
     info.function = Aggregate::create(
-        aggregate.call->name(),
+        name,
         isPartialOutput(step) ? core::AggregationNode::Step::kPartial
                               : core::AggregationNode::Step::kSingle,
         aggregate.rawInputTypes,
@@ -112,10 +113,13 @@ std::vector<AggregateInfo> toAggregateInfo(
       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());
+    // 1. Ignore duplicates property
+    //    if aggregate function is not sensitive to duplicates.
+    // 2. Ignore sorting properties
+    //    if aggregate function is not sensitive to the order of inputs.
+    auto* entry = getAggregateFunctionEntry(name);
     const auto& metadata = entry->metadata;
+    info.distinct = !metadata.ignoreDuplicates && aggregate.distinct;
     if (metadata.orderSensitive) {
       // Sorting keys and orders.
       const auto numSortingKeys = aggregate.sortingKeys.size();
diff --git a/velox/exec/AssignUniqueId.h b/velox/exec/AssignUniqueId.h
index 7ce3daffe8d9..a26d3da68687 100644
--- a/velox/exec/AssignUniqueId.h
+++ b/velox/exec/AssignUniqueId.h
@@ -37,7 +37,7 @@ class AssignUniqueId : public Operator {
   }
 
   bool needsInput() const override {
-    return true;
+    return input_ == nullptr;
   }
 
   void addInput(RowVectorPtr input) override;
@@ -48,6 +48,11 @@ class AssignUniqueId : public Operator {
     return BlockingReason::kNotBlocked;
   }
 
+  bool startDrain() override {
+    // No need to drain for assignUniqueId operator.
+    return false;
+  }
+
   bool isFinished() override;
 
  private:
diff --git a/velox/exec/BlockingReason.cpp b/velox/exec/BlockingReason.cpp
new file mode 100644
index 000000000000..ffe07aa41d84
--- /dev/null
+++ b/velox/exec/BlockingReason.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 "velox/exec/BlockingReason.h"
+
+namespace facebook::velox::exec {
+
+namespace {
+const auto& blockingReasonNames() {
+  static const folly::F14FastMap<BlockingReason, std::string_view> kNames = {
+      {BlockingReason::kNotBlocked, "kNotBlocked"},
+      {BlockingReason::kWaitForConsumer, "kWaitForConsumer"},
+      {BlockingReason::kWaitForSplit, "kWaitForSplit"},
+      {BlockingReason::kWaitForProducer, "kWaitForProducer"},
+      {BlockingReason::kWaitForJoinBuild, "kWaitForJoinBuild"},
+      {BlockingReason::kWaitForJoinProbe, "kWaitForJoinProbe"},
+      {BlockingReason::kWaitForMergeJoinRightSide,
+       "kWaitForMergeJoinRightSide"},
+      {BlockingReason::kWaitForMemory, "kWaitForMemory"},
+      {BlockingReason::kWaitForConnector, "kWaitForConnector"},
+      {BlockingReason::kYield, "kYield"},
+      {BlockingReason::kWaitForArbitration, "kWaitForArbitration"},
+      {BlockingReason::kWaitForScanScaleUp, "kWaitForScanScaleUp"},
+      {BlockingReason::kWaitForIndexLookup, "kWaitForIndexLookup"},
+  };
+  return kNames;
+}
+
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(BlockingReason, blockingReasonNames)
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/BlockingReason.h b/velox/exec/BlockingReason.h
new file mode 100644
index 000000000000..f89e808b0999
--- /dev/null
+++ b/velox/exec/BlockingReason.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 "velox/common/Enums.h"
+
+namespace facebook::velox::exec {
+
+enum class BlockingReason {
+  kNotBlocked,
+  kWaitForConsumer,
+  kWaitForSplit,
+  /// Some operators can get blocked due to the producer(s) (they are
+  /// currently waiting data from) not having anything produced. Used by
+  /// LocalExchange, LocalMergeExchange, Exchange and MergeExchange operators.
+  kWaitForProducer,
+  kWaitForJoinBuild,
+  /// For a build operator, it is blocked waiting for the probe operators to
+  /// finish probing before build the next hash table from one of the
+  /// previously spilled partition data. For a probe operator, it is blocked
+  /// waiting for all its peer probe operators to finish probing before
+  /// notifying the build operators to build the next hash table from the
+  /// previously spilled data.
+  kWaitForJoinProbe,
+  /// Used by MergeJoin operator, indicating that it was blocked by the right
+  /// side input being unavailable.
+  kWaitForMergeJoinRightSide,
+  kWaitForMemory,
+  kWaitForConnector,
+  /// 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,
+  /// For a table scan operator, it is blocked waiting for the scan controller
+  /// to increase the number of table scan processing threads to start
+  /// processing.
+  kWaitForScanScaleUp,
+  /// Used by IndexLookupJoin operator, indicating that it was blocked by the
+  /// async index lookup.
+  kWaitForIndexLookup,
+};
+
+VELOX_DECLARE_ENUM_NAME(BlockingReason);
+} // namespace facebook::velox::exec
+
+template <>
+struct fmt::formatter<facebook::velox::exec::BlockingReason>
+    : formatter<std::string_view> {
+  auto format(facebook::velox::exec::BlockingReason b, format_context& ctx)
+      const {
+    return formatter<std::string_view>::format(
+        facebook::velox::exec::BlockingReasonName::toName(b), ctx);
+  }
+};
diff --git a/velox/exec/CMakeLists.txt b/velox/exec/CMakeLists.txt
index 7ad8f77e1166..9dd6d4ad065c 100644
--- a/velox/exec/CMakeLists.txt
+++ b/velox/exec/CMakeLists.txt
@@ -19,11 +19,13 @@ velox_add_library(
   AggregateCompanionSignatures.cpp
   AggregateFunctionRegistry.cpp
   AggregateInfo.cpp
-  AggregationMasks.cpp
   AggregateWindow.cpp
+  AggregationMasks.cpp
   ArrowStream.cpp
   AssignUniqueId.cpp
+  BlockingReason.cpp
   CallbackSink.cpp
+  ColumnStatsCollector.cpp
   ContainerRowSerde.cpp
   DistinctAggregations.cpp
   Driver.cpp
@@ -32,6 +34,7 @@ velox_add_library(
   ExchangeClient.cpp
   ExchangeQueue.cpp
   ExchangeSource.cpp
+  SerializedPage.cpp
   Expand.cpp
   FilterProject.cpp
   GroupId.cpp
@@ -42,6 +45,7 @@ velox_add_library(
   HashPartitionFunction.cpp
   HashProbe.cpp
   HashTable.cpp
+  HashTableCache.cpp
   IndexLookupJoin.cpp
   JoinBridge.cpp
   Limit.cpp
@@ -54,32 +58,35 @@ velox_add_library(
   MergeSource.cpp
   NestedLoopJoinBuild.cpp
   NestedLoopJoinProbe.cpp
+  SpatialIndex.cpp
+  SpatialJoinBuild.cpp
+  SpatialJoinProbe.cpp
   Operator.cpp
+  OperatorTraceReader.cpp
+  OperatorTraceScan.cpp
+  OperatorTraceWriter.cpp
   OperatorUtils.cpp
   OrderBy.cpp
   OutputBuffer.cpp
   OutputBufferManager.cpp
-  OperatorTraceReader.cpp
-  OperatorTraceScan.cpp
-  OperatorTraceWriter.cpp
-  TaskTraceReader.cpp
-  TaskTraceWriter.cpp
-  Trace.cpp
-  TraceUtil.cpp
-  PartitionedOutput.cpp
+  ParallelProject.cpp
   PartitionFunction.cpp
   PartitionStreamingWindowBuild.cpp
+  PartitionedOutput.cpp
   PlanNodeStats.cpp
   PrefixSort.cpp
   ProbeOperatorState.cpp
-  RowsStreamingWindowBuild.cpp
+  SubPartitionedSortWindowBuild.cpp
   RowContainer.cpp
   RowNumber.cpp
-  ScaledScanController.cpp
+  RowsStreamingWindowBuild.cpp
   ScaleWriterLocalPartition.cpp
+  ScaledScanController.cpp
   SortBuffer.cpp
-  SortedAggregations.cpp
   SortWindowBuild.cpp
+  SortedAggregations.cpp
+  SpatialJoinBuild.cpp
+  SpatialJoinProbe.cpp
   Spill.cpp
   SpillFile.cpp
   Spiller.cpp
@@ -89,44 +96,40 @@ velox_add_library(
   TableWriteMerge.cpp
   TableWriter.cpp
   Task.cpp
+  TaskStructs.cpp
+  TaskTraceReader.cpp
+  TaskTraceWriter.cpp
   TopN.cpp
   TopNRowNumber.cpp
+  Trace.cpp
+  TraceUtil.cpp
   Unnest.cpp
   Values.cpp
   VectorHasher.cpp
   Window.cpp
   WindowBuild.cpp
   WindowFunction.cpp
-  WindowPartition.cpp)
+  WindowPartition.cpp
+)
 
 velox_link_libraries(
   velox_exec
-  velox_file
+  velox_arrow_bridge
+  velox_common_base
+  velox_common_compression
   velox_core
-  velox_vector
   velox_connector
   velox_expression
+  velox_file
+  velox_presto_serializer
   velox_time
-  velox_common_base
   velox_test_util
-  velox_arrow_bridge
-  velox_common_compression)
+  velox_vector
+)
 
 velox_add_library(velox_cursor Cursor.cpp)
-velox_link_libraries(
-  velox_cursor
-  velox_core
-  velox_exception
-  velox_expression
-  velox_dwio_common
-  velox_dwio_dwrf_reader
-  velox_dwio_dwrf_writer
-  velox_type_fbhive
-  velox_hive_connector
-  velox_tpch_connector
-  velox_presto_serializer
-  velox_functions_prestosql
-  velox_aggregates)
+
+velox_link_libraries(velox_cursor velox_core velox_exception velox_expression)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(fuzzer)
diff --git a/velox/exec/CallbackSink.h b/velox/exec/CallbackSink.h
index dc8afd64763a..775592e2242c 100644
--- a/velox/exec/CallbackSink.h
+++ b/velox/exec/CallbackSink.h
@@ -26,8 +26,9 @@ class CallbackSink : public Operator {
       int32_t operatorId,
       DriverCtx* driverCtx,
       Consumer consumeCb,
-      std::function<BlockingReason(ContinueFuture*)> startedCb = nullptr)
-      : Operator(driverCtx, nullptr, operatorId, "N/A", "CallbackSink"),
+      std::function<BlockingReason(ContinueFuture*)> startedCb = nullptr,
+      const std::string& planNodeId = "N/A")
+      : Operator(driverCtx, nullptr, operatorId, planNodeId, "CallbackSink"),
         startedCb_{std::move(startedCb)},
         consumeCb_{std::move(consumeCb)} {}
 
diff --git a/velox/exec/ColumnStatsCollector.cpp b/velox/exec/ColumnStatsCollector.cpp
new file mode 100644
index 000000000000..d1bc68b1fa9f
--- /dev/null
+++ b/velox/exec/ColumnStatsCollector.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/exec/ColumnStatsCollector.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateFunctionRegistry.h"
+#include "velox/exec/AggregateInfo.h"
+#include "velox/exec/VectorHasher.h"
+
+namespace facebook::velox::exec {
+
+ColumnStatsCollector::ColumnStatsCollector(
+    const core::ColumnStatsSpec& statsSpec,
+    const RowTypePtr& inputType,
+    const core::QueryConfig* queryConfig,
+    memory::MemoryPool* pool,
+    tsan_atomic<bool>* nonReclaimableSection)
+    : statsSpec_(statsSpec),
+      inputType_(inputType),
+      queryConfig_(queryConfig),
+      pool_(pool),
+      nonReclaimableSection_(nonReclaimableSection),
+      maxOutputBatchRows_(
+          statsSpec_.groupingKeys.empty() ? 1 : kMaxOutputBatchRows) {
+  VELOX_CHECK_NOT_NULL(inputType_);
+  VELOX_CHECK_NOT_NULL(queryConfig_);
+  VELOX_CHECK_NOT_NULL(pool_);
+  VELOX_CHECK_NOT_NULL(nonReclaimableSection_);
+}
+
+void ColumnStatsCollector::initialize() {
+  if (initialized_) {
+    return;
+  }
+  SCOPE_EXIT {
+    initialized_ = true;
+  };
+  setOutputType();
+  VELOX_CHECK_NOT_NULL(outputType_);
+  createGroupingSet();
+  VELOX_CHECK_NOT_NULL(groupingSet_);
+}
+
+void ColumnStatsCollector::setOutputType() {
+  VELOX_CHECK_NULL(outputType_);
+  outputType_ = statsSpec_.outputType();
+}
+
+std::pair<std::vector<column_index_t>, std::vector<column_index_t>>
+ColumnStatsCollector::setupGroupingKeyChannelProjections() const {
+  const auto& groupingKeys = statsSpec_.groupingKeys;
+  std::vector<column_index_t> groupingKeyInputChannels;
+  groupingKeyInputChannels.reserve(groupingKeys.size());
+  for (auto i = 0; i < groupingKeys.size(); ++i) {
+    groupingKeyInputChannels.push_back(
+        exprToChannel(groupingKeys[i].get(), inputType_));
+  }
+
+  std::vector<column_index_t> groupingKeyOutputChannels(groupingKeys.size());
+  std::iota(
+      groupingKeyOutputChannels.begin(), groupingKeyOutputChannels.end(), 0);
+  return std::make_pair(groupingKeyInputChannels, groupingKeyOutputChannels);
+}
+
+std::vector<AggregateInfo> ColumnStatsCollector::createAggregates(
+    size_t numGroupingKeys) {
+  VELOX_CHECK_NOT_NULL(outputType_);
+  const auto step = statsSpec_.aggregationStep;
+  const auto numAggregates = statsSpec_.aggregates.size();
+  std::vector<AggregateInfo> aggregateInfos;
+  aggregateInfos.reserve(numAggregates);
+  for (auto i = 0; i < numAggregates; ++i) {
+    const auto& aggregate = statsSpec_.aggregates[i];
+    AggregateInfo info;
+    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 {
+        VELOX_FAIL(
+            "Aggregation expression must be field access for column stats collection: {}",
+            arg->toString());
+      }
+    }
+    VELOX_CHECK(!aggregate.distinct);
+    info.intermediateType = resolveIntermediateType(
+        aggregate.call->name(), aggregate.rawInputTypes);
+    // Column stats collection doesn't support aggregation mask.
+    VELOX_CHECK_NULL(aggregate.mask);
+    info.mask = std::nullopt;
+    const auto outputChannel = numGroupingKeys + i;
+    const auto& aggResultType = outputType_->childAt(outputChannel);
+    info.function = Aggregate::create(
+        aggregate.call->name(),
+        isPartialOutput(step) ? core::AggregationNode::Step::kPartial
+                              : core::AggregationNode::Step::kSingle,
+        aggregate.rawInputTypes,
+        aggResultType,
+        *queryConfig_);
+    VELOX_CHECK(aggregate.sortingKeys.empty());
+    VELOX_CHECK(aggregate.sortingOrders.empty());
+    info.output = outputChannel;
+    aggregateInfos.emplace_back(std::move(info));
+  }
+  return aggregateInfos;
+}
+
+void ColumnStatsCollector::createGroupingSet() {
+  VELOX_CHECK_NULL(groupingSet_);
+
+  auto [groupingKeyInputChannels, groupingKeyOutputChannels] =
+      setupGroupingKeyChannelProjections();
+
+  auto hashers = createVectorHashers(inputType_, groupingKeyInputChannels);
+  const auto numHashers = hashers.size();
+
+  // Setup aggregates based on the column stats specifications
+  auto aggregateInfos = createAggregates(numHashers);
+  // Create the grouping set for aggregation execution.
+  groupingSet_ = std::make_unique<GroupingSet>(
+      inputType_,
+      std::move(hashers),
+      /*preGroupedKeys=*/std::vector<column_index_t>{},
+      std::move(groupingKeyOutputChannels),
+      std::move(aggregateInfos),
+      /*ignoreNullKey=*/false,
+      /*isPartial=*/isPartialOutput(statsSpec_.aggregationStep),
+      /*isRawInput=*/isRawInput(statsSpec_.aggregationStep),
+      /*globalGroupingSets=*/std::vector<vector_size_t>{},
+      /*groupIdChannel=*/std::nullopt,
+      /*spillConfig=*/nullptr,
+      nonReclaimableSection_,
+      queryConfig_,
+      pool_,
+      /*spillStats=*/nullptr);
+}
+
+void ColumnStatsCollector::addInput(RowVectorPtr input) {
+  VELOX_CHECK_NOT_NULL(input);
+  VELOX_CHECK(initialized_);
+
+  if (input->size() == 0) {
+    return;
+  }
+
+  // Add input to the grouping set
+  groupingSet_->addInput(input, /*mayPushdown=*/false);
+}
+
+void ColumnStatsCollector::noMoreInput() {
+  if (!noMoreInput_) {
+    noMoreInput_ = true;
+    if (groupingSet_) {
+      groupingSet_->noMoreInput();
+    }
+  }
+}
+
+void ColumnStatsCollector::prepareOutput() {
+  if (output_) {
+    VectorPtr output = std::move(output_);
+    BaseVector::prepareForReuse(output, maxOutputBatchRows_);
+    output_ = std::static_pointer_cast<RowVector>(output);
+  } else {
+    output_ = std::static_pointer_cast<RowVector>(
+        BaseVector::create(outputType_, maxOutputBatchRows_, pool_));
+  }
+}
+
+RowVectorPtr ColumnStatsCollector::getOutput() {
+  VELOX_CHECK(initialized_);
+
+  if (!groupingSet_ || !noMoreInput_ || finished_) {
+    return nullptr;
+  }
+
+  prepareOutput();
+  const bool hasMoreOutput = groupingSet_->getOutput(
+      maxOutputBatchRows_, kMaxOutputBatchBytes, outputIterator_, output_);
+  if (!hasMoreOutput) {
+    finished_ = true;
+    return nullptr;
+  }
+  return output_;
+}
+
+bool ColumnStatsCollector::finished() const {
+  return finished_;
+}
+
+void ColumnStatsCollector::close() {
+  if (groupingSet_) {
+    groupingSet_.reset();
+  }
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/ColumnStatsCollector.h b/velox/exec/ColumnStatsCollector.h
new file mode 100644
index 000000000000..5c76f9af3915
--- /dev/null
+++ b/velox/exec/ColumnStatsCollector.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 "velox/core/PlanNode.h"
+#include "velox/exec/GroupingSet.h"
+
+namespace facebook::velox::exec {
+
+/// ColumnStatsCollector collects column statistics during table write
+/// operations by leveraging the GroupingSet aggregation framework. It supports
+/// both partitioned and unpartitioned tables, computing aggregated statistics
+/// such as min, max, count, etc. for specified columns.
+///
+/// Usage pattern:
+/// 1. Create instance with ColumnStatsSpec defining desired statistics
+/// 2. Call initialize() once before processing any input
+/// 3. Call addInput() repeatedly with data batches
+/// 4. Call noMoreInput() when all input has been provided
+/// 5. Call getOutput() until finished() returns true to retrieve all results
+/// 6. Call close() to cleanup resources
+class ColumnStatsCollector {
+ public:
+  /// Constructs a ColumnStatsCollector for collecting statistics during table
+  /// writes.
+  /// @param statsSpec Specification defining grouping keys, aggregation step,
+  /// and aggregation functions to compute
+  /// @param inputType Schema of the input data that will be processed
+  /// @param queryConfig Query configuration settings
+  /// @param pool Memory pool for allocations
+  /// @param nonReclaimableSection Atomic flag indicating non-reclaimable memory
+  /// section
+  ColumnStatsCollector(
+      const core::ColumnStatsSpec& statsSpec,
+      const RowTypePtr& inputType,
+      const core::QueryConfig* queryConfig,
+      memory::MemoryPool* pool,
+      tsan_atomic<bool>* nonReclaimableSection);
+
+  /// Initializes the stats collector. Must be called exactly once before
+  /// adding any input data. Sets up internal aggregation structures based
+  /// on the provided ColumnStatsSpec.
+  void initialize();
+
+  /// Adds a batch of input data for statistics collection. Can be called
+  /// multiple times with different batches until all input data has been
+  /// processed.
+  /// @param input Batch of input data to process for statistics collection
+  void addInput(RowVectorPtr input);
+
+  /// Signals that no more input data will be provided. Must be called after
+  /// all addInput() calls to finalize the aggregation computation.
+  void noMoreInput();
+
+  /// Retrieves the computed column statistics. For partitioned tables, results
+  /// are returned one partition at a time, so this method may need to be called
+  /// multiple times until finished() returns true.
+  RowVectorPtr getOutput();
+
+  /// Checks whether all computed statistics have been returned. For partitioned
+  /// tables, there is one output row per partition, so multiple getOutput()
+  /// calls may be required. Returns true when all statistics have been
+  /// retrieved.
+  bool finished() const;
+
+  /// Cleans up and releases all resources used by the stats collector.
+  /// Should be called after all statistics have been retrieved and the
+  /// collector is no longer needed.
+  void close();
+
+ private:
+  void setOutputType();
+
+  // Creates the grouping key channel projections for the column stats
+  // collection for partitioned table write with one group per each table
+  // partition.
+  std::pair<std::vector<column_index_t>, std::vector<column_index_t>>
+  setupGroupingKeyChannelProjections() const;
+
+  void createGroupingSet();
+
+  std::vector<AggregateInfo> createAggregates(size_t numGroupingKeys);
+
+  void prepareOutput();
+
+  static const int kMaxOutputBatchRows = 512;
+  static const int kMaxOutputBatchBytes = 128 << 20;
+
+  const core::ColumnStatsSpec statsSpec_;
+  const RowTypePtr inputType_;
+  const core::QueryConfig* const queryConfig_;
+  memory::MemoryPool* const pool_;
+  tsan_atomic<bool>* const nonReclaimableSection_;
+  const vector_size_t maxOutputBatchRows_;
+
+  bool initialized_{false};
+  bool noMoreInput_{false};
+  bool finished_{false};
+
+  std::unique_ptr<GroupingSet> groupingSet_;
+  RowTypePtr outputType_;
+  RowVectorPtr output_;
+  RowContainerIterator outputIterator_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/ContainerRowSerde.cpp b/velox/exec/ContainerRowSerde.cpp
index fc85ad61327e..b571a0a7b95c 100644
--- a/velox/exec/ContainerRowSerde.cpp
+++ b/velox/exec/ContainerRowSerde.cpp
@@ -388,11 +388,8 @@ std::optional<int32_t> compareSwitch(
 template <
     bool typeProvidesCustomComparison,
     TypeKind Kind,
-    std::enable_if_t<
-        Kind != TypeKind::VARCHAR && Kind != TypeKind::VARBINARY &&
-            Kind != TypeKind::ARRAY && Kind != TypeKind::MAP &&
-            Kind != TypeKind::ROW,
-        int32_t> = 0>
+    std::enable_if_t<!is_string_kind(Kind) && !is_nested_kind(Kind), int32_t> =
+        0>
 std::optional<int32_t> compare(
     ByteInputStream& left,
     const BaseVector& right,
@@ -693,11 +690,8 @@ std::optional<int32_t> compareSwitch(
 template <
     bool typeProvidesCustomComparison,
     TypeKind Kind,
-    std::enable_if_t<
-        Kind != TypeKind::VARCHAR && Kind != TypeKind::VARBINARY &&
-            Kind != TypeKind::ARRAY && Kind != TypeKind::MAP &&
-            Kind != TypeKind::ROW,
-        int32_t> = 0>
+    std::enable_if_t<!is_string_kind(Kind) && !is_nested_kind(Kind), int32_t> =
+        0>
 std::optional<int32_t> compare(
     ByteInputStream& left,
     ByteInputStream& right,
@@ -898,11 +892,8 @@ uint64_t hashSwitch(ByteInputStream& stream, const Type* type);
 template <
     bool typeProvidesCustomComparison,
     TypeKind Kind,
-    std::enable_if_t<
-        Kind != TypeKind::VARBINARY && Kind != TypeKind::VARCHAR &&
-            Kind != TypeKind::ARRAY && Kind != TypeKind::MAP &&
-            Kind != TypeKind::ROW,
-        int32_t> = 0>
+    std::enable_if_t<!is_string_kind(Kind) && !is_nested_kind(Kind), int32_t> =
+        0>
 uint64_t hashOne(ByteInputStream& stream, const Type* type) {
   using T = typename TypeTraits<Kind>::NativeType;
 
@@ -936,21 +927,22 @@ uint64_t hashOne(ByteInputStream& stream, const Type* /*type*/) {
   return folly::hasher<StringView>()(readStringView(stream, storage));
 }
 
-template <bool elementTypeProvidesCustomComparison>
-uint64_t
-hashArray(ByteInputStream& in, uint64_t hash, const Type* elementType) {
-  auto size = in.read<int32_t>();
+template <bool elementTypeProvidesCustomComparison, typename TFunc>
+void hashArray(
+    ByteInputStream& in,
+    int32_t size,
+    const Type* elementType,
+    const TFunc& consumer) {
   NullsReader nulls(in, size);
   for (auto i = 0; i < size; ++i) {
-    uint64_t value;
+    uint64_t hash;
     if (bits::isBitSet(nulls.data(), i)) {
-      value = BaseVector::kNullHash;
+      hash = BaseVector::kNullHash;
     } else {
-      value = hashSwitch<elementTypeProvidesCustomComparison>(in, elementType);
+      hash = hashSwitch<elementTypeProvidesCustomComparison>(in, elementType);
     }
-    hash = bits::commutativeHashMix(hash, value);
+    consumer(hash);
   }
-  return hash;
 }
 
 template <
@@ -985,11 +977,20 @@ template <
 uint64_t hashOne(ByteInputStream& in, const Type* type) {
   const auto& elementType = type->childAt(0);
 
+  auto size = in.read<int32_t>();
+
+  uint64_t hash = BaseVector::kNullHash;
   if (elementType->providesCustomComparison()) {
-    return hashArray<true>(in, BaseVector::kNullHash, elementType.get());
+    hashArray<true>(in, size, elementType.get(), [&](uint64_t value) {
+      hash = bits::hashMix(hash, value);
+    });
   } else {
-    return hashArray<false>(in, BaseVector::kNullHash, elementType.get());
+    hashArray<false>(in, size, elementType.get(), [&](uint64_t value) {
+      hash = bits::hashMix(hash, value);
+    });
   }
+
+  return hash;
 }
 
 template <
@@ -1000,18 +1001,39 @@ uint64_t hashOne(ByteInputStream& in, const Type* type) {
   const auto& keyType = type->childAt(0);
   const auto& valueType = type->childAt(1);
 
-  uint64_t hash;
+  auto size = in.read<int32_t>();
+
+  std::vector<uint64_t> keyHashes;
+  keyHashes.reserve(size);
   if (keyType->providesCustomComparison()) {
-    hash = hashArray<true>(in, BaseVector::kNullHash, keyType.get());
+    hashArray<true>(in, size, keyType.get(), [&](uint64_t value) {
+      keyHashes.push_back(value);
+    });
   } else {
-    hash = hashArray<false>(in, BaseVector::kNullHash, keyType.get());
+    hashArray<false>(in, size, keyType.get(), [&](uint64_t value) {
+      keyHashes.push_back(value);
+    });
   }
 
+  uint64_t hash = BaseVector::kNullHash;
+  size_t i = 0;
+
+  auto updateHash = [&](uint64_t valueHash) {
+    hash = bits::commutativeHashMix(
+        hash, bits::hashMix(keyHashes.at(i), valueHash));
+    ++i;
+  };
+
+  auto valuesSize = in.read<int32_t>();
+  VELOX_CHECK_EQ(size, valuesSize);
+
   if (valueType->providesCustomComparison()) {
-    return hashArray<true>(in, hash, valueType.get());
+    hashArray<true>(in, size, valueType.get(), updateHash);
   } else {
-    return hashArray<false>(in, hash, valueType.get());
+    hashArray<false>(in, size, valueType.get(), updateHash);
   }
+
+  return hash;
 }
 
 template <bool typeProvidesCustomComparison>
diff --git a/velox/exec/Cursor.cpp b/velox/exec/Cursor.cpp
index 1e3de91686c1..a81d74f2ac5c 100644
--- a/velox/exec/Cursor.cpp
+++ b/velox/exec/Cursor.cpp
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 #include "velox/exec/Cursor.h"
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/file/FileSystems.h"
-#include "velox/exec/Operator.h"
 
 #include <filesystem>
 
@@ -68,7 +68,8 @@ exec::BlockingReason TaskQueue::enqueue(
     consumerPromise_.setValue();
   }
   if (totalBytes_ > maxBytes_) {
-    auto [unblockPromise, unblockFuture] = makeVeloxContinuePromiseContract();
+    auto [unblockPromise, unblockFuture] =
+        makeVeloxContinuePromiseContract("TaskQueue::enqueue");
     producerUnblockPromises_.emplace_back(std::move(unblockPromise));
     *future = std::move(unblockFuture);
     return exec::BlockingReason::kWaitForConsumer;
@@ -100,7 +101,7 @@ RowVectorPtr TaskQueue::dequeue() {
       }
       if (!vector) {
         consumerBlocked_ = true;
-        consumerPromise_ = ContinuePromise();
+        consumerPromise_ = ContinuePromise("TaskQueue::dequeue");
         consumerFuture_ = consumerPromise_.getFuture();
       }
     }
@@ -175,22 +176,25 @@ class TaskCursorBase : public TaskCursor {
 
     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());
-      }
+      taskSpillDirectoryCb_ = params.spillDirectoryCallback;
+      if (taskSpillDirectoryCb_ == nullptr) {
+        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";
+        LOG(INFO) << "Task spill directory[" << taskSpillDirectory_
+                  << "] created";
+      }
     }
   }
 
@@ -199,6 +203,7 @@ class TaskCursorBase : public TaskCursor {
   std::shared_ptr<core::QueryCtx> queryCtx_;
   core::PlanFragment planFragment_;
   std::string taskSpillDirectory_;
+  std::function<std::string()> taskSpillDirectoryCb_;
 
  private:
   std::shared_ptr<folly::Executor> executor_;
@@ -210,7 +215,7 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
       : TaskCursorBase(
             params,
             std::make_shared<folly::CPUThreadPoolExecutor>(
-                std::thread::hardware_concurrency())),
+                folly::hardware_concurrency())),
         maxDrivers_{params.maxDrivers},
         numConcurrentSplitGroups_{params.numConcurrentSplitGroups},
         numSplitGroups_{params.numSplitGroups} {
@@ -223,7 +228,14 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
         std::make_shared<TaskQueue>(params.bufferedBytes, params.outputPool);
 
     // Captured as a shared_ptr by the consumer callback of task_.
-    auto queue = queue_;
+    auto queueHolder = std::weak_ptr(queue_);
+    std::optional<common::SpillDiskOptions> spillDiskOpts;
+    if (!taskSpillDirectory_.empty()) {
+      spillDiskOpts = common::SpillDiskOptions{
+          .spillDirPath = taskSpillDirectory_,
+          .spillDirCreated = taskSpillDirectoryCb_ == nullptr,
+          .spillDirCreateCb = taskSpillDirectoryCb_};
+    }
     task_ = Task::create(
         taskId_,
         std::move(planFragment_),
@@ -231,10 +243,15 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
         std::move(queryCtx_),
         Task::ExecutionMode::kParallel,
         // consumer
-        [queue, copyResult = params.copyResult](
+        [queueHolder, copyResult = params.copyResult, taskId = taskId_](
             const RowVectorPtr& vector,
             bool drained,
             velox::ContinueFuture* future) {
+          auto queue = queueHolder.lock();
+          if (queue == nullptr) {
+            LOG(ERROR) << "TaskQueue has been destroyed, taskId: " << taskId;
+            return exec::BlockingReason::kNotBlocked;
+          }
           VELOX_CHECK(
               !drained, "Unexpected drain in multithreaded task cursor");
           if (!vector || !copyResult) {
@@ -250,16 +267,18 @@ class MultiThreadedTaskCursor : public TaskCursorBase {
           return queue->enqueue(std::move(copy), future);
         },
         0,
-        [queue](std::exception_ptr) {
+        std::move(spillDiskOpts),
+        [queueHolder, taskId = taskId_](std::exception_ptr) {
           // onError close the queue to unblock producers and consumers.
           // moveNext will handle rethrowing the error once it's
           // unblocked.
+          auto queue = queueHolder.lock();
+          if (queue == nullptr) {
+            LOG(ERROR) << "TaskQueue has been destroyed, taskId: " << taskId;
+            return;
+          }
           queue->close();
         });
-
-    if (!taskSpillDirectory_.empty()) {
-      task_->setSpillDirectory(taskSpillDirectory_);
-    }
   }
 
   ~MultiThreadedTaskCursor() override {
@@ -372,17 +391,22 @@ class SingleThreadedTaskCursor : public TaskCursorBase {
     VELOX_CHECK(
         !queryCtx_->isExecutorSupplied(),
         "Executor should not be set in serial task cursor");
-
+    std::optional<common::SpillDiskOptions> spillDiskOpts;
+    if (!taskSpillDirectory_.empty()) {
+      spillDiskOpts = common::SpillDiskOptions{
+          .spillDirPath = taskSpillDirectory_,
+          .spillDirCreated = true,
+          .spillDirCreateCb = taskSpillDirectoryCb_};
+    }
     task_ = Task::create(
         taskId_,
         std::move(planFragment_),
         params.destination,
         std::move(queryCtx_),
-        Task::ExecutionMode::kSerial);
-
-    if (!taskSpillDirectory_.empty()) {
-      task_->setSpillDirectory(taskSpillDirectory_);
-    }
+        Task::ExecutionMode::kSerial,
+        std::function<BlockingReason(RowVectorPtr, bool, ContinueFuture*)>{},
+        0,
+        std::move(spillDiskOpts));
 
     VELOX_CHECK(
         task_->supportSerialExecutionMode(),
diff --git a/velox/exec/Cursor.h b/velox/exec/Cursor.h
index ac067703f85d..7e5f48802c02 100644
--- a/velox/exec/Cursor.h
+++ b/velox/exec/Cursor.h
@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 #pragma once
-#include <velox/exec/Driver.h>
+
 #include "velox/core/PlanNode.h"
+#include "velox/exec/Driver.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
@@ -70,6 +71,12 @@ struct CursorParameters {
   /// would be built from it.
   std::string spillDirectory;
 
+  /// Callback function to dynamically create or determine the spill directory
+  /// path at runtime. If provided, this callback is invoked when spilling is
+  /// needed and must return a valid directory path. This allows for dynamic
+  /// spill directory creation or path resolution based on runtime conditions.
+  std::function<std::string()> spillDirectoryCallback;
+
   bool copyResult = true;
 
   /// If true, use serial execution mode. Use parallel execution mode
@@ -134,7 +141,7 @@ class TaskQueue {
   std::mutex mutex_;
   std::vector<ContinuePromise> producerUnblockPromises_;
   bool consumerBlocked_ = false;
-  ContinuePromise consumerPromise_;
+  ContinuePromise consumerPromise_{ContinuePromise::makeEmpty()};
   ContinueFuture consumerFuture_;
   bool closed_ = false;
 };
diff --git a/velox/exec/DistinctAggregations.cpp b/velox/exec/DistinctAggregations.cpp
index f6f9db5a2454..f29cb91d8f3e 100644
--- a/velox/exec/DistinctAggregations.cpp
+++ b/velox/exec/DistinctAggregations.cpp
@@ -32,9 +32,10 @@ class TypedDistinctAggregations : public DistinctAggregations {
       : pool_{pool},
         aggregates_{std::move(aggregates)},
         inputs_{aggregates_[0]->inputs},
-        inputType_(TypedDistinctAggregations::makeInputTypeForAccumulator(
-            inputType,
-            inputs_)) {}
+        inputType_(
+            TypedDistinctAggregations::makeInputTypeForAccumulator(
+                inputType,
+                inputs_)) {}
 
   /// Returns metadata about the accumulator used to store unique inputs.
   Accumulator accumulator() const override {
@@ -49,6 +50,9 @@ class TypedDistinctAggregations : public DistinctAggregations {
         },
         [this](folly::Range<char**> groups) {
           for (auto* group : groups) {
+            if (!isInitialized(group)) {
+              continue;
+            }
             auto* accumulator =
                 reinterpret_cast<AccumulatorType*>(group + offset_);
             accumulator->free(*allocator_);
@@ -126,11 +130,11 @@ class TypedDistinctAggregations : public DistinctAggregations {
 
       // Overwrite empty groups over the destructed groups to keep the container
       // in a well formed state.
-      raw_vector<int32_t> temp;
+      raw_vector<int32_t> indices(pool_);
       aggregate.function->initializeNewGroups(
           groups.data(),
           folly::Range<const int32_t*>(
-              iota(groups.size(), temp), groups.size()));
+              iota(groups.size(), indices), groups.size()));
     }
   }
 
diff --git a/velox/exec/DistinctAggregations.h b/velox/exec/DistinctAggregations.h
index ffb6d1b1a4c3..fdd13a89fd02 100644
--- a/velox/exec/DistinctAggregations.h
+++ b/velox/exec/DistinctAggregations.h
@@ -101,6 +101,10 @@ class DistinctAggregations {
       char** groups,
       folly::Range<const vector_size_t*> indices) = 0;
 
+  bool isInitialized(char* group) const {
+    return group[initializedByte_] & initializedMask_;
+  }
+
   HashStringAllocator* allocator_;
   int32_t offset_;
   int32_t nullByte_;
diff --git a/velox/exec/Driver.cpp b/velox/exec/Driver.cpp
index 7a9d3654ae9a..ae96bc6c1bdc 100644
--- a/velox/exec/Driver.cpp
+++ b/velox/exec/Driver.cpp
@@ -18,6 +18,7 @@
 
 #include "velox/common/process/TraceContext.h"
 #include "velox/exec/Task.h"
+#include "velox/vector/LazyVector.h"
 
 using facebook::velox::common::testutil::TestValue;
 
@@ -141,10 +142,12 @@ std::optional<common::SpillConfig> DriverCtx::makeSpillConfig(
       queryConfig.maxSpillRunRows(),
       queryConfig.writerFlushThresholdBytes(),
       queryConfig.spillCompressionKind(),
+      queryConfig.spillNumMaxMergeFiles(),
       queryConfig.spillPrefixSortEnabled()
           ? std::optional<common::PrefixSortConfig>(prefixSortConfig())
           : std::nullopt,
-      queryConfig.spillFileCreateConfig());
+      queryConfig.spillFileCreateConfig(),
+      queryConfig.windowSpillMinReadBatchRows());
 }
 
 std::atomic_uint64_t BlockingState::numBlockedDrivers_{0};
@@ -158,9 +161,10 @@ BlockingState::BlockingState(
       future_(std::move(future)),
       operator_(op),
       reason_(reason),
-      sinceUs_(std::chrono::duration_cast<std::chrono::microseconds>(
-                   std::chrono::high_resolution_clock::now().time_since_epoch())
-                   .count()) {
+      sinceUs_(
+          std::chrono::duration_cast<std::chrono::microseconds>(
+              std::chrono::high_resolution_clock::now().time_since_epoch())
+              .count()) {
   // Set before leaving the thread.
   driver_->state().hasBlockingFuture = true;
   numBlockedDrivers_++;
@@ -247,6 +251,8 @@ void Driver::init(
     std::vector<std::unique_ptr<Operator>> operators) {
   VELOX_CHECK_NULL(ctx_);
   ctx_ = std::move(ctx);
+  enableOperatorBatchSizeStats_ =
+      ctx_->queryConfig().enableOperatorBatchSizeStats();
   cpuSliceMs_ = task()->driverCpuTimeSliceLimitMs();
   VELOX_CHECK(operators_.empty());
   operators_ = std::move(operators);
@@ -264,55 +270,6 @@ void Driver::initializeOperators() {
   }
 }
 
-void Driver::pushdownFilters(int operatorIndex) {
-  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()));
-
-  // Walk operator list upstream and find a place to install the filters.
-  for (const auto& entry : filters) {
-    auto channel = entry.first;
-    for (auto i = operatorIndex - 1; i >= 0; --i) {
-      auto prevOp = operators_[i].get();
-
-      if (i == 0) {
-        // Source operator.
-        VELOX_CHECK(
-            prevOp->canAddDynamicFilter(),
-            "Cannot push down dynamic filters produced by {}",
-            op->toString());
-        prevOp->addDynamicFilter(planNodeId, channel, entry.second);
-        prevOp->addRuntimeStat("dynamicFiltersAccepted", RuntimeCounter(1));
-        break;
-      }
-
-      const auto& identityProjections = prevOp->identityProjections();
-      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(planNodeId, channel, entry.second);
-        prevOp->addRuntimeStat("dynamicFiltersAccepted", RuntimeCounter(1));
-        break;
-      }
-
-      // Continue walking upstream.
-      channel = inputChannel.value();
-    }
-  }
-
-  op->clearDynamicFilters();
-}
-
 RowVectorPtr Driver::next(
     ContinueFuture* future,
     Operator*& blockingOp,
@@ -456,11 +413,12 @@ CpuWallTiming Driver::processLazyIoStats(
   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),
-  });
+  lockStats->getOutputTiming.add(
+      CpuWallTiming{
+          1,
+          static_cast<uint64_t>(wallDelta),
+          static_cast<uint64_t>(cpuDelta),
+      });
   lockStats->inputBytes += inputBytesDelta;
   lockStats->outputBytes += inputBytesDelta;
   return CpuWallTiming{
@@ -482,6 +440,12 @@ bool Driver::checkUnderArbitration(ContinueFuture* future) {
 }
 
 namespace {
+inline void addInput(Operator* op, const RowVectorPtr& input) {
+  if (FOLLY_LIKELY(!op->dryRun())) {
+    op->addInput(input);
+  }
+}
+
 inline void getOutput(Operator* op, RowVectorPtr& result) {
   result = op->getOutput();
   if (FOLLY_UNLIKELY(op->shouldDropOutput())) {
@@ -618,15 +582,14 @@ StopReason Driver::runInternal(
                   kOpMethodGetOutput);
               if (intermediateResult) {
                 validateOperatorOutputResult(intermediateResult, *op);
-                resultBytes = intermediateResult->estimateFlatSize();
-                {
-                  auto lockedStats = op->stats().wlock();
-                  lockedStats->addOutputVector(
-                      resultBytes, intermediateResult->size());
+                if (enableOperatorBatchSizeStats()) {
+                  resultBytes = intermediateResult->estimateFlatSize();
                 }
+                auto lockedStats = op->stats().wlock();
+                lockedStats->addOutputVector(
+                    resultBytes, intermediateResult->size());
               }
             });
-            pushdownFilters(i);
             if (intermediateResult) {
               withDeltaCpuWallTimer(
                   nextOp, &OperatorStats::addInputTiming, [&]() {
@@ -641,7 +604,7 @@ StopReason Driver::runInternal(
                         nextOp);
 
                     CALL_OPERATOR(
-                        nextOp->addInput(intermediateResult),
+                        addInput(nextOp, intermediateResult),
                         nextOp,
                         curOperatorId_ + 1,
                         kOpMethodAddInput);
@@ -708,12 +671,12 @@ StopReason Driver::runInternal(
                 getOutput(op, result), op, curOperatorId_, kOpMethodGetOutput);
             if (result) {
               validateOperatorOutputResult(result, *op);
-
-              {
-                auto lockedStats = op->stats().wlock();
-                lockedStats->addOutputVector(
-                    result->estimateFlatSize(), result->size());
+              vector_size_t resultByteSize{0};
+              if (enableOperatorBatchSizeStats()) {
+                resultByteSize = result->estimateFlatSize();
               }
+              auto lockedStats = op->stats().wlock();
+              lockedStats->addOutputVector(resultByteSize, result->size());
             }
           });
 
@@ -737,14 +700,13 @@ StopReason Driver::runInternal(
             close();
             return StopReason::kAtEnd;
           }
-          pushdownFilters(i);
           continue;
         }
       }
     }
   } catch (velox::VeloxException&) {
     task()->setError(std::current_exception());
-    // The CancelPoolGuard will close 'self' and remove from Task.
+    // The CancelGuard will close 'self' and remove from Task.
     return StopReason::kAlreadyTerminated;
   } catch (std::exception&) {
     task()->setError(std::current_exception());
@@ -840,6 +802,19 @@ void Driver::closeOperators() {
   for (auto& op : operators_) {
     auto stats = op->stats(true);
     stats.numDrivers = 1;
+
+    // Calculate this driver's CPU time for this specific operator and add it as
+    // a runtime stat. This will be aggregated across all drivers, with the max
+    // field containing the CPU time from the longest running driver.
+    uint64_t operatorCpuNanos = stats.addInputTiming.cpuNanos +
+        stats.getOutputTiming.cpuNanos + stats.finishTiming.cpuNanos +
+        stats.isBlockedTiming.cpuNanos;
+
+    if (operatorCpuNanos > 0) {
+      stats.runtimeStats[OperatorStats::kDriverCpuTime] =
+          RuntimeMetric(operatorCpuNanos, RuntimeCounter::Unit::kNanos);
+    }
+
     task()->addOperatorStats(stats);
   }
 }
@@ -968,22 +943,23 @@ bool Driver::mayPushdownAggregation(Operator* aggregation) const {
       aggregation->toString());
 }
 
-std::unordered_set<column_index_t> Driver::canPushdownFilters(
-    const Operator* filterSource,
-    const std::vector<column_index_t>& channels) const {
-  int filterSourceIndex = -1;
+int Driver::operatorIndex(const Operator* op) const {
+  int index = -1;
   for (auto i = 0; i < operators_.size(); ++i) {
-    auto op = operators_[i].get();
-    if (filterSource == op) {
-      filterSourceIndex = i;
+    if (op == operators_[i].get()) {
+      index = i;
       break;
     }
   }
   VELOX_CHECK_GE(
-      filterSourceIndex,
-      0,
-      "Operator not found in its Driver: {}",
-      filterSource->toString());
+      index, 0, "Operator not found in its Driver: {}", op->toString());
+  return index;
+}
+
+std::unordered_set<column_index_t> Driver::canPushdownFilters(
+    const Operator* filterSource,
+    const std::vector<column_index_t>& channels) const {
+  const int filterSourceIndex = operatorIndex(filterSource);
 
   std::unordered_set<column_index_t> supportedChannels;
   for (auto i = 0; i < channels.size(); ++i) {
@@ -1018,6 +994,73 @@ std::unordered_set<column_index_t> Driver::canPushdownFilters(
   return supportedChannels;
 }
 
+int Driver::pushdownFilters(
+    Operator* filterSource,
+    const std::vector<column_index_t>& channels,
+    const std::function<bool(column_index_t, common::FilterPtr&)>& makeFilter) {
+  const int filterSourceIndex = operatorIndex(filterSource);
+  int numFiltersProduced = 0;
+  std::vector<int> numFiltersAccepted(filterSourceIndex);
+  for (auto i = 0; i < channels.size(); ++i) {
+    auto channel = channels[i];
+    int j = -1;
+    for (j = filterSourceIndex - 1; j >= 0; --j) {
+      auto* prevOp = operators_[j].get();
+      if (j == 0) {
+        // Source operator.
+        break;
+      }
+      const auto& identityProjections = prevOp->identityProjections();
+      const auto inputChannel =
+          getIdentityProjection(identityProjections, channel);
+      if (!inputChannel.has_value()) {
+        // Filter channel is not an identity projection.
+        break;
+      }
+      // Continue walking upstream.
+      channel = inputChannel.value();
+    }
+    if (!(j >= 0 && operators_[j]->canAddDynamicFilter())) {
+      continue;
+    }
+    common::FilterPtr filter;
+    auto lkSource = pushdownFilters_->at(filterSourceIndex).wlock();
+    if (makeFilter(i, filter)) {
+      if (filter) {
+        // A new filter is generated.
+        auto lkTarget = pushdownFilters_->at(j).wlock();
+        common::Filter::merge(filter, lkTarget->filters[channel]);
+        lkTarget->dynamicFilteredColumns.insert(channel);
+      } else {
+        // Same filter is already generated by another operator on the same
+        // node.  Just do some sanity check here.
+        auto lkTarget = pushdownFilters_->at(j).rlock();
+        VELOX_CHECK(
+            lkTarget->filters.at(channel) &&
+            lkTarget->dynamicFilteredColumns.contains(channel));
+      }
+      ++numFiltersProduced;
+      ++numFiltersAccepted[j];
+    }
+  }
+  for (int j = 0; j < filterSourceIndex; ++j) {
+    if (numFiltersAccepted[j] == 0) {
+      continue;
+    }
+    {
+      auto lk = pushdownFilters_->at(j).rlock();
+      operators_[j]->addDynamicFilterLocked(filterSource->planNodeId(), *lk);
+    }
+    operators_[j]->addRuntimeStat(
+        "dynamicFiltersAccepted", RuntimeCounter(numFiltersAccepted[j]));
+  }
+  if (numFiltersProduced > 0) {
+    filterSource->addRuntimeStat(
+        "dynamicFiltersProduced", RuntimeCounter(numFiltersProduced));
+  }
+  return numFiltersProduced;
+}
+
 Operator* Driver::findOperator(std::string_view planNodeId) const {
   for (auto& op : operators_) {
     if (op->planNodeId() == planNodeId) {
@@ -1065,7 +1108,7 @@ std::string Driver::toString() const {
     std::string blockedOp = (blockedOperatorId_ < operators_.size())
         ? operators_[blockedOperatorId_]->toString()
         : "<unknown op>";
-    out << "blocked (" << blockingReasonToString(blockingReason_) << " "
+    out << "blocked (" << BlockingReasonName::toName(blockingReason_) << " "
         << blockedOp << "), ";
   } else if (state_.isEnqueued) {
     out << "enqueued ";
@@ -1076,9 +1119,13 @@ std::string Driver::toString() const {
   }
 
   out << "{Operators: ";
-  for (auto& op : operators_) {
-    out << op->toString() << ", ";
-  }
+  std::vector<std::string> opStrs;
+  opStrs.reserve(operators_.size());
+  std::ranges::transform(
+      operators_, std::back_inserter(opStrs), [](const auto& op) {
+        return op->toString();
+      });
+  out << folly::join(", ", opStrs);
   out << "}";
   const auto ocs = opCallStatus();
   if (!ocs.empty()) {
@@ -1103,7 +1150,7 @@ Driver::CancelGuard::~CancelGuard() {
 
 folly::dynamic Driver::toJson() const {
   folly::dynamic obj = folly::dynamic::object;
-  obj["blockingReason"] = blockingReasonToString(blockingReason_);
+  obj["blockingReason"] = BlockingReasonName::toName(blockingReason_);
   obj["state"] = state_.toJson();
   obj["closed"] = closed_.load();
   obj["queueTimeStartMicros"] = queueTimeStartUs_;
@@ -1198,40 +1245,6 @@ std::string Driver::label() const {
   return fmt::format("<Driver {}:{}>", task()->taskId(), ctx_->driverId);
 }
 
-std::string blockingReasonToString(BlockingReason reason) {
-  switch (reason) {
-    case BlockingReason::kNotBlocked:
-      return "kNotBlocked";
-    case BlockingReason::kWaitForConsumer:
-      return "kWaitForConsumer";
-    case BlockingReason::kWaitForSplit:
-      return "kWaitForSplit";
-    case BlockingReason::kWaitForProducer:
-      return "kWaitForProducer";
-    case BlockingReason::kWaitForJoinBuild:
-      return "kWaitForJoinBuild";
-    case BlockingReason::kWaitForJoinProbe:
-      return "kWaitForJoinProbe";
-    case BlockingReason::kWaitForMergeJoinRightSide:
-      return "kWaitForMergeJoinRightSide";
-    case BlockingReason::kWaitForMemory:
-      return "kWaitForMemory";
-    case BlockingReason::kWaitForConnector:
-      return "kWaitForConnector";
-    case BlockingReason::kYield:
-      return "kYield";
-    case BlockingReason::kWaitForArbitration:
-      return "kWaitForArbitration";
-    case BlockingReason::kWaitForScanScaleUp:
-      return "kWaitForScanScaleUp";
-    case BlockingReason::kWaitForIndexLookup:
-      return "kWaitForIndexLookup";
-    default:
-      VELOX_UNREACHABLE(
-          fmt::format("Unknown blocking reason {}", static_cast<int>(reason)));
-  }
-}
-
 DriverThreadContext* driverThreadContext() {
   return driverThreadCtx;
 }
diff --git a/velox/exec/Driver.h b/velox/exec/Driver.h
index b59457fc77e5..517bf3df9a89 100644
--- a/velox/exec/Driver.h
+++ b/velox/exec/Driver.h
@@ -27,7 +27,7 @@
 #include "velox/common/base/TraceConfig.h"
 #include "velox/common/time/CpuWallTimer.h"
 #include "velox/core/PlanFragment.h"
-#include "velox/core/QueryCtx.h"
+#include "velox/exec/BlockingReason.h"
 
 namespace facebook::velox::exec {
 
@@ -61,14 +61,6 @@ std::string stopReasonString(StopReason reason);
 
 std::ostream& operator<<(std::ostream& out, const StopReason& reason);
 
-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.
@@ -94,7 +86,7 @@ struct DriverStats {
 ///  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
+/// Task 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,
@@ -182,45 +174,6 @@ struct ThreadState {
   }
 };
 
-enum class BlockingReason {
-  kNotBlocked,
-  kWaitForConsumer,
-  kWaitForSplit,
-  /// Some operators can get blocked due to the producer(s) (they are
-  /// currently waiting data from) not having anything produced. Used by
-  /// LocalExchange, LocalMergeExchange, Exchange and MergeExchange operators.
-  kWaitForProducer,
-  kWaitForJoinBuild,
-  /// For a build operator, it is blocked waiting for the probe operators to
-  /// finish probing before build the next hash table from one of the
-  /// previously spilled partition data. For a probe operator, it is blocked
-  /// waiting for all its peer probe operators to finish probing before
-  /// notifying the build operators to build the next hash table from the
-  /// previously spilled data.
-  kWaitForJoinProbe,
-  /// Used by MergeJoin operator, indicating that it was blocked by the right
-  /// side input being unavailable.
-  kWaitForMergeJoinRightSide,
-  kWaitForMemory,
-  kWaitForConnector,
-  /// 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,
-  /// For a table scan operator, it is blocked waiting for the scan controller
-  /// to increase the number of table scan processing threads to start
-  /// processing.
-  kWaitForScanScaleUp,
-  /// Used by IndexLookupJoin operator, indicating that it was blocked by the
-  /// async index lookup.
-  kWaitForIndexLookup,
-};
-
-std::string blockingReasonToString(BlockingReason reason);
-
 class BlockingState {
  public:
   BlockingState(
@@ -363,6 +316,26 @@ struct OpCallStatus {
   std::atomic<const char*> method{kOpMethodNone};
 };
 
+struct PushdownFilters {
+  /// Keep a single instance across drivers so that we do not need to repeatedly
+  /// merge them in different drivers.
+  folly::F14FastMap<column_index_t, common::FilterPtr> filters;
+
+  /// Indices added here will never be removed.
+  folly::F14FastSet<column_index_t> dynamicFilteredColumns;
+
+  /// Whether static filters has been added to filters.  This only needs to be
+  /// done once per node by the first driver.
+  bool staticFiltersInitialized = false;
+};
+
+/// Pushdown filters on nodes in the pipeline.  Locks must be acquired in the
+/// order from downstream to upstream (i.e. it's forbidden that we acquire the
+/// upstream node lock first, and then acquire the downstream node lock while we
+/// hold the upstream lock).
+using PipelinePushdownFilters =
+    std::vector<folly::Synchronized<PushdownFilters>>;
+
 class Driver : public std::enable_shared_from_this<Driver> {
  public:
   static void enqueue(std::shared_ptr<Driver> instance);
@@ -411,6 +384,11 @@ class Driver : public std::enable_shared_from_this<Driver> {
   /// time slice limit if set.
   bool shouldYield() const;
 
+  /// Inline function to check if operator batch size stats are enabled.
+  inline bool enableOperatorBatchSizeStats() const {
+    return enableOperatorBatchSizeStats_;
+  }
+
   /// 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
   /// memory arbitration finishes.
@@ -431,6 +409,30 @@ class Driver : public std::enable_shared_from_this<Driver> {
       const Operator* filterSource,
       const std::vector<column_index_t>& channels) const;
 
+  /// Try to add new dynamic filters from `filterSource' to its upstream
+  /// operator which accept dynamic filters.  `channels' are the inputs for
+  /// `filterSource'.
+  ///
+  /// `makeFilter' is called with a lock held on the node of `filterSource' in
+  /// `pushdownFilters_'.  It should return whether a filter should be added,
+  /// and set the FilterPtr output parameter with a new filter if one is
+  /// generated.  If `makeFilter' returns true but FilterPtr is not set, it
+  /// means a filter is already generated by another operator on the same node,
+  /// and we just need to set the new merged filter on the accepting operator.
+  ///
+  /// Return the number of filters produced.
+  int pushdownFilters(
+      Operator* filterSource,
+      const std::vector<column_index_t>& channels,
+      const std::function<bool(column_index_t, common::FilterPtr&)>&
+          makeFilter);
+
+  int operatorIndex(const Operator* op) const;
+
+  const std::shared_ptr<PipelinePushdownFilters>& pushdownFilters() const {
+    return pushdownFilters_;
+  }
+
   /// Returns the Operator with 'planNodeId' or nullptr if not found. For
   /// example, hash join probe accesses the corresponding build by id.
   Operator* findOperator(std::string_view planNodeId) const;
@@ -600,10 +602,6 @@ class Driver : public std::enable_shared_from_this<Driver> {
 
   void close();
 
-  // Push down dynamic filters produced by the operator at the specified
-  // position in the pipeline.
-  void pushdownFilters(int operatorIndex);
-
   using TimingMemberPtr = CpuWallTiming OperatorStats::*;
   template <typename Func>
   void withDeltaCpuWallTimer(
@@ -631,6 +629,10 @@ class Driver : public std::enable_shared_from_this<Driver> {
 
   std::unique_ptr<DriverCtx> ctx_;
 
+  // If set, the operator output batch size stats will be collected during
+  // driver execution.
+  bool enableOperatorBatchSizeStats_{false};
+
   // If not zero, specifies the driver cpu time slice.
   size_t cpuSliceMs_{0};
 
@@ -664,6 +666,10 @@ class Driver : public std::enable_shared_from_this<Driver> {
   // of DriverFactory::createDriver().
   bool isAdaptable_{true};
 
+  // Pushdown filters on the pipeline.  This is generated per split group per
+  // pipeline.
+  std::shared_ptr<PipelinePushdownFilters> pushdownFilters_;
+
   friend struct DriverFactory;
 };
 
@@ -728,6 +734,7 @@ struct DriverFactory {
   std::shared_ptr<Driver> createDriver(
       std::unique_ptr<DriverCtx> ctx,
       std::shared_ptr<ExchangeClient> exchangeClient,
+      std::shared_ptr<PipelinePushdownFilters> filters,
       std::function<int(int pipelineId)> numDrivers);
 
   /// Replaces operators at indices 'begin' to 'end - 1' with
@@ -811,6 +818,10 @@ struct DriverFactory {
   /// based on this pipeline.
   std::vector<core::PlanNodeId> needsNestedLoopJoinBridges() const;
 
+  /// Returns plan node IDs for which Spatial Join Bridges must be created
+  /// based on this pipeline.
+  std::vector<core::PlanNodeId> needsSpatialJoinBridges() const;
+
   static std::vector<DriverAdapter> adapters;
 };
 
@@ -850,16 +861,6 @@ DriverThreadContext* driverThreadContext();
 
 } // namespace facebook::velox::exec
 
-template <>
-struct fmt::formatter<facebook::velox::exec::BlockingReason>
-    : formatter<std::string> {
-  auto format(facebook::velox::exec::BlockingReason b, format_context& ctx)
-      const {
-    return formatter<std::string>::format(
-        facebook::velox::exec::blockingReasonToString(b), ctx);
-  }
-};
-
 template <>
 struct fmt::formatter<facebook::velox::exec::StopReason>
     : formatter<std::string> {
diff --git a/velox/exec/DriverStats.h b/velox/exec/DriverStats.h
new file mode 100644
index 000000000000..3b047f4c9e07
--- /dev/null
+++ b/velox/exec/DriverStats.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 <unordered_map>
+#include "velox/common/base/RuntimeMetrics.h"
+
+namespace facebook::velox::exec {
+
+struct DriverStats {
+  static constexpr const char* kTotalPauseTime = "totalDriverPauseWallNanos";
+  static constexpr const char* kTotalOffThreadTime =
+      "totalDriverOffThreadWallNanos";
+
+  std::unordered_map<std::string, RuntimeMetric> runtimeStats;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/Exchange.cpp b/velox/exec/Exchange.cpp
index 8582c804124f..6585961cb915 100644
--- a/velox/exec/Exchange.cpp
+++ b/velox/exec/Exchange.cpp
@@ -14,23 +14,47 @@
  * limitations under the License.
  */
 #include "velox/exec/Exchange.h"
-
+#include "velox/common/Casts.h"
+#include "velox/common/serialization/Serializable.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/serializers/CompactRowSerializer.h"
 
 namespace facebook::velox::exec {
 
+folly::dynamic RemoteConnectorSplit::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "RemoteConnectorSplit";
+  obj["taskId"] = taskId;
+  return obj;
+}
+
+// static
+std::shared_ptr<RemoteConnectorSplit> RemoteConnectorSplit::create(
+    const folly::dynamic& obj) {
+  const auto taskId = obj["taskId"].asString();
+  return std::make_shared<RemoteConnectorSplit>(taskId);
+}
+
+// static
+void RemoteConnectorSplit::registerSerDe() {
+  auto& registry = DeserializationRegistryForSharedPtr();
+  registry.Register("RemoteConnectorSplit", RemoteConnectorSplit::create);
+}
+
 namespace {
-std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
-    const core::QueryConfig& queryConfig,
-    VectorSerde::Kind kind) {
-  std::unique_ptr<VectorSerde::Options> options =
-      kind == VectorSerde::Kind::kPresto
-      ? std::make_unique<serializer::presto::PrestoVectorSerde::PrestoOptions>()
-      : std::make_unique<VectorSerde::Options>();
-  options->compressionKind =
-      common::stringToCompressionKind(queryConfig.shuffleCompressionKind());
-  return options;
+std::unique_ptr<folly::IOBuf> mergePages(
+    std::vector<std::unique_ptr<SerializedPageBase>>& pages) {
+  VELOX_CHECK(!pages.empty());
+  std::unique_ptr<folly::IOBuf> mergedBufs;
+  for (const auto& page : pages) {
+    if (mergedBufs == nullptr) {
+      mergedBufs = page->getIOBuf();
+    } else {
+      mergedBufs->appendToChain(page->getIOBuf());
+    }
+  }
+  return mergedBufs;
 }
 } // namespace
 
@@ -50,7 +74,9 @@ Exchange::Exchange(
           driverCtx->queryConfig().preferredOutputBatchBytes()},
       serdeKind_{exchangeNode->serdeKind()},
       serdeOptions_{getVectorSerdeOptions(
-          operatorCtx_->driverCtx()->queryConfig(),
+          common::stringToCompressionKind(operatorCtx_->driverCtx()
+                                              ->queryConfig()
+                                              .shuffleCompressionKind()),
           serdeKind_)},
       processSplits_{operatorCtx_->driverCtx()->driverId == 0},
       driverId_{driverCtx->driverId},
@@ -64,39 +90,42 @@ void Exchange::addRemoteTaskIds(std::vector<std::string>& remoteTaskIds) {
   stats_.wlock()->numSplits += remoteTaskIds.size();
 }
 
-bool Exchange::getSplits(ContinueFuture* future) {
+void Exchange::getSplits(ContinueFuture* future) {
   if (!processSplits_) {
-    return false;
+    return;
   }
   if (noMoreSplits_) {
-    return false;
+    return;
   }
   std::vector<std::string> remoteTaskIds;
   for (;;) {
     exec::Split split;
-    auto reason = operatorCtx_->task()->getSplitOrFuture(
+    const auto reason = operatorCtx_->task()->getSplitOrFuture(
         operatorCtx_->driverCtx()->splitGroupId, planNodeId(), split, *future);
-    if (reason == BlockingReason::kNotBlocked) {
-      if (split.hasConnectorSplit()) {
-        auto remoteSplit = std::dynamic_pointer_cast<RemoteConnectorSplit>(
-            split.connectorSplit);
-        VELOX_CHECK_NOT_NULL(remoteSplit, "Wrong type of split");
-        remoteTaskIds.push_back(remoteSplit->taskId);
-      } else {
-        addRemoteTaskIds(remoteTaskIds);
-        exchangeClient_->noMoreRemoteTasks();
-        noMoreSplits_ = true;
-        if (atEnd_) {
-          operatorCtx_->task()->multipleSplitsFinished(
-              false, stats_.rlock()->numSplits, 0);
-          recordExchangeClientStats();
-        }
-        return false;
-      }
-    } else {
+    if (reason != BlockingReason::kNotBlocked) {
       addRemoteTaskIds(remoteTaskIds);
-      return true;
+      return;
+    }
+
+    if (split.hasConnectorSplit()) {
+      auto remoteSplit =
+          checkedPointerCast<RemoteConnectorSplit>(split.connectorSplit);
+      if (FOLLY_UNLIKELY(splitTracer_ != nullptr)) {
+        splitTracer_->write(split);
+      }
+      remoteTaskIds.push_back(remoteSplit->taskId);
+      continue;
+    }
+
+    addRemoteTaskIds(remoteTaskIds);
+    exchangeClient_->noMoreRemoteTasks();
+    noMoreSplits_ = true;
+    if (atEnd_) {
+      operatorCtx_->task()->multipleSplitsFinished(
+          false, stats_.rlock()->numSplits, 0);
+      recordExchangeClientStats();
     }
+    return;
   }
 }
 
@@ -106,7 +135,6 @@ BlockingReason Exchange::isBlocked(ContinueFuture* future) {
   }
 
   // Start fetching data right away. Do not wait for all splits to be available.
-
   if (!splitFuture_.valid()) {
     getSplits(&splitFuture_);
   }
@@ -135,6 +163,7 @@ BlockingReason Exchange::isBlocked(ContinueFuture* future) {
   }
 
   // Block until data becomes available.
+  VELOX_CHECK(dataFuture.valid());
   *future = std::move(dataFuture);
   return BlockingReason::kWaitForProducer;
 }
@@ -143,102 +172,142 @@ bool Exchange::isFinished() {
   return atEnd_ && currentPages_.empty();
 }
 
-namespace {
-std::unique_ptr<folly::IOBuf> mergePages(
-    std::vector<std::unique_ptr<SerializedPage>>& pages) {
-  VELOX_CHECK(!pages.empty());
-  std::unique_ptr<folly::IOBuf> mergedBufs;
-  for (const auto& page : pages) {
-    if (mergedBufs == nullptr) {
-      mergedBufs = page->getIOBuf();
-    } else {
-      mergedBufs->appendToChain(page->getIOBuf());
-    }
-  }
-  return mergedBufs;
-}
-} // namespace
-
 RowVectorPtr Exchange::getOutput() {
   auto* serde = getSerde();
   if (serde->supportsAppendInDeserialize()) {
-    uint64_t rawInputBytes{0};
-    if (currentPages_.empty()) {
-      return nullptr;
-    }
-    vector_size_t resultOffset = 0;
-    for (const auto& page : currentPages_) {
+    return getOutputFromColumnarPages(serde);
+  }
+  return getOutputFromRowPages(serde);
+}
+
+RowVectorPtr Exchange::getOutputFromColumnarPages(VectorSerde* serde) {
+  if (currentPages_.empty()) {
+    return nullptr;
+  }
+
+  // Calculate target row count based on estimated row size, similar to
+  // getOutputFromRowPages.
+  // Start conservatively, then use estimates.
+  const auto numRows = estimatedRowSize_.has_value()
+      ? std::max(
+            (preferredOutputBatchBytes_ / estimatedRowSize_.value()),
+            kInitialOutputRows)
+      : kInitialOutputRows;
+
+  // Process pages one-by-one from currentPages_ pointed by columnarPageIdx_.
+  // Within each page, deserialize vectors incrementally until we hit the target
+  // batch size.
+  uint64_t rawInputBytes = 0;
+  vector_size_t resultOffset{0};
+
+  // Should be either starting fresh or continuing from a previous partial page
+  VELOX_CHECK(
+      inputStream_ == nullptr || columnarPageIdx_ < currentPages_.size());
+
+  // Iterate through pages
+  while (columnarPageIdx_ < currentPages_.size()) {
+    auto& page = currentPages_[columnarPageIdx_];
+
+    if (!inputStream_) {
+      // NOTE: 'rawInputBytes' only counts bytes from pages processed from the
+      // beginning in this call. If processing resumes from the middle of a
+      // page, that page's bytes are not counted. This ensures each page is
+      // counted only once in 'rawInputBytes' across multiple calls.
       rawInputBytes += page->size();
+      inputStream_ = page->prepareStreamForDeserialize();
+    }
 
-      auto inputStream = page->prepareStreamForDeserialize();
-      while (!inputStream->atEnd()) {
-        serde->deserialize(
-            inputStream.get(),
-            pool(),
-            outputType_,
-            &result_,
-            resultOffset,
-            serdeOptions_.get());
-        resultOffset = result_->size();
-      }
+    // Inner loop: deserialize vectors from current page until batch is full
+    // or page is exhausted.
+    while (!inputStream_->atEnd() && resultOffset < numRows) {
+      serde->deserialize(
+          inputStream_.get(),
+          pool(),
+          outputType_,
+          &result_,
+          resultOffset,
+          serdeOptions_.get());
+
+      resultOffset = result_->size();
+    }
+
+    if (inputStream_->atEnd()) {
+      // Page is fully consumed, free memory immediately, and move to the next.
+      inputStream_ = nullptr;
+      page.reset();
+      ++columnarPageIdx_;
+    }
+
+    // Stop if accumulated enough rows for this batch.
+    if (resultOffset >= numRows) {
+      break;
     }
-    currentPages_.clear();
-    recordInputStats(rawInputBytes);
-    return result_;
-  }
-  if (serde->kind() == VectorSerde::Kind::kCompactRow) {
-    return getOutputFromCompactRows(serde);
   }
-  if (serde->kind() == VectorSerde::Kind::kUnsafeRow) {
-    return getOutputFromUnsafeRows(serde);
+
+  const auto numOutputRows = result_->size();
+  VELOX_CHECK_GT(numOutputRows, 0);
+
+  estimatedRowSize_ = std::max(
+      result_->estimateFlatSize() / numOutputRows,
+      estimatedRowSize_.value_or(1L));
+
+  // If processed all pages, clear the vector and reset state.
+  if (columnarPageIdx_ >= currentPages_.size()) {
+    VELOX_CHECK_NULL(inputStream_);
+    currentPages_.clear();
+    columnarPageIdx_ = 0;
   }
-  VELOX_UNREACHABLE(
-      "Unsupported serde kind: {}", VectorSerde::kindName(serde->kind()));
+
+  recordInputStats(rawInputBytes);
+  return result_;
 }
 
-RowVectorPtr Exchange::getOutputFromCompactRows(VectorSerde* serde) {
+RowVectorPtr Exchange::getOutputFromRowPages(VectorSerde* serde) {
   uint64_t rawInputBytes{0};
   if (currentPages_.empty()) {
-    VELOX_CHECK_NULL(compactRowInputStream_);
-    VELOX_CHECK_NULL(compactRowIterator_);
+    VELOX_CHECK_NULL(inputStream_);
+    VELOX_CHECK_NULL(rowIterator_);
     return nullptr;
   }
 
-  if (compactRowInputStream_ == nullptr) {
+  if (inputStream_ == nullptr) {
     std::unique_ptr<folly::IOBuf> mergedBufs = mergePages(currentPages_);
     rawInputBytes += mergedBufs->computeChainDataLength();
-    compactRowPages_ = std::make_unique<SerializedPage>(std::move(mergedBufs));
-    compactRowInputStream_ = compactRowPages_->prepareStreamForDeserialize();
+    mergedRowPage_ =
+        std::make_unique<PrestoSerializedPage>(std::move(mergedBufs));
+    inputStream_ = mergedRowPage_->prepareStreamForDeserialize();
   }
 
-  auto numRows = kInitialOutputCompactRows;
-  if (estimatedCompactRowSize_.has_value()) {
+  auto numRows = kInitialOutputRows;
+  if (estimatedRowSize_.has_value()) {
     numRows = std::max(
-        (preferredOutputBatchBytes_ / estimatedCompactRowSize_.value()),
-        kInitialOutputCompactRows);
+        (preferredOutputBatchBytes_ / estimatedRowSize_.value()),
+        kInitialOutputRows);
   }
 
+  // Check if the serde supports batched deserialization
   serde->deserialize(
-      compactRowInputStream_.get(),
-      compactRowIterator_,
+      inputStream_.get(),
+      rowIterator_,
       numRows,
       outputType_,
       &result_,
       pool(),
       serdeOptions_.get());
+
   const auto numOutputRows = result_->size();
   VELOX_CHECK_GT(numOutputRows, 0);
 
-  estimatedCompactRowSize_ = std::max(
+  estimatedRowSize_ = std::max(
       result_->estimateFlatSize() / numOutputRows,
-      estimatedCompactRowSize_.value_or(1L));
+      estimatedRowSize_.value_or(1L));
 
-  if (compactRowInputStream_->atEnd() && compactRowIterator_ == nullptr) {
+  if (inputStream_->atEnd() && rowIterator_ == nullptr) {
     // only clear the input stream if we have reached the end of the row
     // iterator because row iterator may depend on input stream if serialized
     // rows are not compressed.
-    compactRowInputStream_ = nullptr;
-    compactRowPages_ = nullptr;
+    inputStream_ = nullptr;
+    mergedRowPage_ = nullptr;
     currentPages_.clear();
   }
 
@@ -246,22 +315,6 @@ RowVectorPtr Exchange::getOutputFromCompactRows(VectorSerde* serde) {
   return result_;
 }
 
-RowVectorPtr Exchange::getOutputFromUnsafeRows(VectorSerde* serde) {
-  uint64_t rawInputBytes{0};
-  if (currentPages_.empty()) {
-    return nullptr;
-  }
-  std::unique_ptr<folly::IOBuf> mergedBufs = mergePages(currentPages_);
-  rawInputBytes += mergedBufs->computeChainDataLength();
-  auto mergedPages = std::make_unique<SerializedPage>(std::move(mergedBufs));
-  auto source = mergedPages->prepareStreamForDeserialize();
-  serde->deserialize(
-      source.get(), pool(), outputType_, &result_, serdeOptions_.get());
-  currentPages_.clear();
-  recordInputStats(rawInputBytes);
-  return result_;
-}
-
 void Exchange::recordInputStats(uint64_t rawInputBytes) {
   auto lockedStats = stats_.wlock();
   lockedStats->rawInputBytes += rawInputBytes;
@@ -273,6 +326,13 @@ void Exchange::close() {
   SourceOperator::close();
   currentPages_.clear();
   result_ = nullptr;
+
+  // Clean up stateful deserialization state
+  inputStream_ = nullptr;
+  mergedRowPage_ = nullptr;
+  rowIterator_ = nullptr;
+  columnarPageIdx_ = 0;
+
   if (exchangeClient_) {
     recordExchangeClientStats();
     exchangeClient_->close();
@@ -301,14 +361,12 @@ void Exchange::recordExchangeClientStats() {
     lockedStats->runtimeStats.insert({name, value});
   }
 
-  auto backgroundCpuTimeMs =
-      exchangeClientStats.find(ExchangeClient::kBackgroundCpuTimeMs);
-  if (backgroundCpuTimeMs != exchangeClientStats.end()) {
+  const auto iter = exchangeClientStats.find(Operator::kBackgroundCpuTimeNanos);
+  if (iter != exchangeClientStats.end()) {
     const CpuWallTiming backgroundTiming{
-        static_cast<uint64_t>(backgroundCpuTimeMs->second.count),
+        static_cast<uint64_t>(iter->second.count),
         0,
-        static_cast<uint64_t>(backgroundCpuTimeMs->second.sum) *
-            Timestamp::kNanosecondsInMillisecond};
+        static_cast<uint64_t>(iter->second.sum)};
     lockedStats->backgroundTiming.clear();
     lockedStats->backgroundTiming.add(backgroundTiming);
   }
diff --git a/velox/exec/Exchange.h b/velox/exec/Exchange.h
index a6f7c261d50f..ea4bc95f19c6 100644
--- a/velox/exec/Exchange.h
+++ b/velox/exec/Exchange.h
@@ -31,6 +31,13 @@ struct RemoteConnectorSplit : public connector::ConnectorSplit {
   explicit RemoteConnectorSplit(const std::string& remoteTaskId)
       : ConnectorSplit(""), taskId(remoteTaskId) {}
 
+  static std::shared_ptr<RemoteConnectorSplit> create(
+      const folly::dynamic& obj);
+
+  static void registerSerDe();
+
+  folly::dynamic serialize() const override;
+
   std::string toString() const override {
     return fmt::format("Remote: {}", taskId);
   }
@@ -60,12 +67,11 @@ class Exchange : public SourceOperator {
  protected:
   virtual VectorSerde* getSerde();
 
- private:
-  // When 'estimatedCompactRowSize_' is unset, meaning we haven't materialized
+  // When 'estimatedRowSize_' is unset, meaning we haven't materialized
   // and returned any output from this exchange operator, we return this
   // conservative number of output rows, to make sure memory does not grow too
   // much.
-  static constexpr uint64_t kInitialOutputCompactRows = 64;
+  static constexpr uint64_t kInitialOutputRows = 64;
 
   // 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.
@@ -75,11 +81,8 @@ class Exchange : public SourceOperator {
 
   // 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 and sets
-  // the 'future' parameter. Returns false if fetched all splits or if this
-  // operator is not the first operator in the pipeline and therefore is not
-  // responsible for fetching splits and adding them to the exchangeClient_.
-  bool getSplits(ContinueFuture* future);
+  // exchangeClient_.
+  void getSplits(ContinueFuture* future);
 
   // Fetches runtime stats from ExchangeClient and replaces these in this
   // operator's stats.
@@ -87,9 +90,9 @@ class Exchange : public SourceOperator {
 
   void recordInputStats(uint64_t rawInputBytes);
 
-  RowVectorPtr getOutputFromCompactRows(VectorSerde* serde);
+  RowVectorPtr getOutputFromColumnarPages(VectorSerde* serde);
 
-  RowVectorPtr getOutputFromUnsafeRows(VectorSerde* serde);
+  RowVectorPtr getOutputFromRowPages(VectorSerde* serde);
 
   const uint64_t preferredOutputBatchBytes_;
 
@@ -114,19 +117,25 @@ class Exchange : public SourceOperator {
   // Reusable result vector.
   RowVectorPtr result_;
 
-  std::vector<std::unique_ptr<SerializedPage>> currentPages_;
+  std::vector<std::unique_ptr<SerializedPageBase>> currentPages_;
   bool atEnd_{false};
   std::default_random_engine rng_{std::random_device{}()};
 
-  // Memory holders needed by compact row serde to perform cursor like reads
-  // across 'getOutputFromCompactRows' calls.
-  std::unique_ptr<SerializedPage> compactRowPages_;
-  std::unique_ptr<ByteInputStream> compactRowInputStream_;
-  std::unique_ptr<RowIterator> compactRowIterator_;
+  // Memory holders for deserialization across 'getOutput' calls.
+  // The merged pages for row serialization.
+  std::unique_ptr<SerializedPageBase> mergedRowPage_;
+  std::unique_ptr<RowIterator> rowIterator_;
+
+  // State for columnar page deserialization.
+  // Index of the current page in 'currentPages_' being processed.
+  size_t columnarPageIdx_{0};
+
+  // Stream for deserialization used by both row and columnar.
+  std::unique_ptr<ByteInputStream> inputStream_;
 
   // The estimated bytes per row of the output of this exchange operator
   // computed from the last processed output.
-  std::optional<uint64_t> estimatedCompactRowSize_;
+  std::optional<uint64_t> estimatedRowSize_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/ExchangeClient.cpp b/velox/exec/ExchangeClient.cpp
index 0a8b92b2f018..a138f0552045 100644
--- a/velox/exec/ExchangeClient.cpp
+++ b/velox/exec/ExchangeClient.cpp
@@ -53,7 +53,16 @@ void ExchangeClient::addRemoteTaskId(const std::string& remoteTaskId) {
       sources_.push_back(source);
       queue_->addSourceLocked();
       emptySources_.push(source);
-      requestSpecs = pickSourcesToRequestLocked();
+      // When lazyFetching_ is true, I/O will be triggered lazily when next() is
+      // called from Exchange::isBlocked(). This allows waiter tasks using
+      // cached hash tables to skip I/O entirely when the table is already
+      // cached - the HashBuild operator will finish before
+      // Exchange::isBlocked() is ever called, so no unnecessary data fetching
+      // occurs.
+      if (!lazyFetching_) {
+        // Start fetching data immediately.
+        requestSpecs = pickSourcesToRequestLocked();
+      }
     }
   }
 
@@ -78,6 +87,11 @@ void ExchangeClient::close() {
     if (closed_) {
       return;
     }
+
+    // Capture stats BEFORE clearing sources_.
+    // This allows stats() to return meaningful data even after close().
+    stats_ = collectStatsLocked();
+
     closed_ = true;
     sources = std::move(sources_);
     producingSources = std::move(producingSources_);
@@ -91,9 +105,17 @@ void ExchangeClient::close() {
   queue_->close();
 }
 
-folly::F14FastMap<std::string, RuntimeMetric> ExchangeClient::stats() const {
-  folly::F14FastMap<std::string, RuntimeMetric> stats;
+folly::F14FastMap<std::string, RuntimeMetric> ExchangeClient::stats() {
   std::lock_guard<std::mutex> l(queue_->mutex());
+  if (stats_.empty()) {
+    stats_ = collectStatsLocked();
+  }
+  return stats_;
+}
+
+folly::F14FastMap<std::string, RuntimeMetric>
+ExchangeClient::collectStatsLocked() const {
+  folly::F14FastMap<std::string, RuntimeMetric> stats;
 
   for (const auto& source : sources_) {
     if (source->supportsMetrics()) {
@@ -119,13 +141,13 @@ folly::F14FastMap<std::string, RuntimeMetric> ExchangeClient::stats() const {
   return stats;
 }
 
-std::vector<std::unique_ptr<SerializedPage>> ExchangeClient::next(
+std::vector<std::unique_ptr<SerializedPageBase>> ExchangeClient::next(
     int consumerId,
     uint32_t maxBytes,
     bool* atEnd,
     ContinueFuture* future) {
   std::vector<RequestSpec> requestSpecs;
-  std::vector<std::unique_ptr<SerializedPage>> pages;
+  std::vector<std::unique_ptr<SerializedPageBase>> pages;
   ContinuePromise stalePromise = ContinuePromise::makeEmpty();
   {
     std::lock_guard<std::mutex> l(queue_->mutex());
@@ -185,7 +207,7 @@ void ExchangeClient::request(std::vector<RequestSpec>&& requestSpecs) {
                 RECORD_METRIC_VALUE(kMetricExchangeDataCount);
               }
 
-              bool pauseCurrentSource = false;
+              bool pauseCurrentSource{false};
               std::vector<RequestSpec> requestSpecs;
               std::shared_ptr<ExchangeSource> currentSource = spec.source;
               {
@@ -232,6 +254,9 @@ ExchangeClient::pickSourcesToRequestLocked() {
   if (closed_) {
     return {};
   }
+  if (skipRequestDataSizeWithSingleSource()) {
+    return pickupSingleSourceToRequestLocked();
+  }
   std::vector<RequestSpec> requestSpecs;
   while (!emptySources_.empty()) {
     auto& source = emptySources_.front();
@@ -283,6 +308,43 @@ ExchangeClient::pickSourcesToRequestLocked() {
   return requestSpecs;
 }
 
+std::vector<ExchangeClient::RequestSpec>
+ExchangeClient::pickupSingleSourceToRequestLocked() {
+  VELOX_CHECK_EQ(sources_.size(), 1);
+  VELOX_CHECK(!closed_);
+  if (emptySources_.empty() && producingSources_.empty()) {
+    return {};
+  }
+
+  VELOX_CHECK_EQ(totalPendingBytes_, 0);
+  VELOX_CHECK_LE(!!emptySources_.empty() + !!producingSources_.empty(), 1);
+  const auto requestBytes = maxQueuedBytes_ - queue_->totalBytes();
+
+  if (requestBytes <= 0) {
+    return {};
+  }
+  std::vector<RequestSpec> requestSpecs;
+  SCOPE_EXIT {
+    totalPendingBytes_ += requestBytes;
+  };
+  if (!emptySources_.empty()) {
+    VELOX_CHECK_EQ(emptySources_.size(), 1);
+    auto& source = emptySources_.front();
+    VELOX_CHECK(source->shouldRequestLocked());
+    requestSpecs.push_back({std::move(source), requestBytes});
+    emptySources_.pop();
+    return requestSpecs;
+  }
+
+  VELOX_CHECK_EQ(producingSources_.size(), 1);
+  auto& source = producingSources_.front().source;
+  VELOX_CHECK(source->shouldRequestLocked());
+  VELOX_CHECK(!producingSources_.front().remainingBytes.empty());
+  requestSpecs.push_back({std::move(source), requestBytes});
+  producingSources_.pop();
+  return requestSpecs;
+}
+
 ExchangeClient::~ExchangeClient() {
   close();
 }
diff --git a/velox/exec/ExchangeClient.h b/velox/exec/ExchangeClient.h
index b99fc49e8851..3b8e3df3bdb7 100644
--- a/velox/exec/ExchangeClient.h
+++ b/velox/exec/ExchangeClient.h
@@ -26,7 +26,6 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
  public:
   static constexpr int32_t kDefaultMaxQueuedBytes = 32 << 20; // 32 MB.
   static constexpr std::chrono::milliseconds kRequestDataMaxWait{100};
-  static inline const std::string kBackgroundCpuTimeMs = "backgroundCpuTimeMs";
 
   ExchangeClient(
       std::string taskId,
@@ -36,23 +35,29 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
       uint64_t minOutputBatchBytes,
       memory::MemoryPool* pool,
       folly::Executor* executor,
-      int32_t requestDataSizesMaxWaitSec = 10)
+      int32_t requestDataSizesMaxWaitSec = 10,
+      bool skipRequestDataSizeWithSingleSource = false,
+      bool lazyFetching = false)
       : taskId_{std::move(taskId)},
         destination_(destination),
         maxQueuedBytes_{maxQueuedBytes},
         kRequestDataSizesMaxWaitSec_{requestDataSizesMaxWaitSec},
         pool_(pool),
         executor_(executor),
-        queue_(std::make_shared<ExchangeQueue>(
-            numberOfConsumers,
-            minOutputBatchBytes)),
+        queue_(
+            std::make_shared<ExchangeQueue>(
+                numberOfConsumers,
+                minOutputBatchBytes)),
         // See comment in 'pickSourcesToRequestLocked' for why this is needed
         // for 'minOutputBatchBytes_'. Note: ExchangeQueue does not need max(1,
         // minOutputBatchBytes) because for 'MergeExchangeSource', we want
         // ExchangeQueue 'minOutputBatchBytes' to be be 0 so that it always
         // unblocks. In short, 0 has a special meaning for ExchangeQueue
         minOutputBatchBytes_(
-            std::max(static_cast<uint64_t>(1), minOutputBatchBytes)) {
+            std::max(static_cast<uint64_t>(1), minOutputBatchBytes)),
+        skipRequestDataSizeWithSingleSource_(
+            skipRequestDataSizeWithSingleSource),
+        lazyFetching_(lazyFetching) {
     VELOX_CHECK_NOT_NULL(pool_);
     VELOX_CHECK_NOT_NULL(executor_);
     // NOTE: the executor is used to run async response callback from the
@@ -87,8 +92,8 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
 
   // Returns runtime statistics aggregated across all of the exchange sources.
   // ExchangeClient is expected to report background CPU time by including a
-  // runtime metric named ExchangeClient::kBackgroundCpuTimeMs.
-  folly::F14FastMap<std::string, RuntimeMetric> stats() const;
+  // runtime metric named Operator::kBackgroundCpuTimeNanos.
+  folly::F14FastMap<std::string, RuntimeMetric> stats();
 
   const std::shared_ptr<ExchangeQueue>& queue() const {
     return queue_;
@@ -102,7 +107,7 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
   ///
   /// The data may be compressed, in which case 'maxBytes' applies to compressed
   /// size.
-  std::vector<std::unique_ptr<SerializedPage>>
+  std::vector<std::unique_ptr<SerializedPageBase>>
   next(int consumerId, uint32_t maxBytes, bool* atEnd, ContinueFuture* future);
 
   std::string toString() const;
@@ -131,10 +136,37 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
     std::vector<int64_t> remainingBytes;
   };
 
+  // Selects exchange sources to request data from based on available queue
+  // capacity. Handles multiple sources by first requesting data sizes from all
+  // empty sources, then requesting actual data from producing sources based on
+  // their remaining bytes and available capacity. May initiate out-of-band
+  // transfers for large pages that exceed capacity to avoid deadlock
+  // situations. For single source case, delegates to
+  // pickupSingleSourceToRequestLocked which sets max request bytes based on
+  // available queue space instead of reported remaining bytes from exchange
+  // sources.
   std::vector<RequestSpec> pickSourcesToRequestLocked();
 
+  // Specialized single-source request picker for single-source exchange
+  // clients. Sets the max request bytes based on available space in the queue
+  // rather than the reported remaining bytes from exchange sources. The reason
+  // is that single source has no other alternative so just fetch as much as
+  // possible from that source. Returns a request spec for the single source
+  // when there is available capacity in the queue and no pending requests. If
+  // capacity is unavailable or requests are already pending, returns empty
+  // vector.
+  std::vector<RequestSpec> pickupSingleSourceToRequestLocked();
   void request(std::vector<RequestSpec>&& requestSpecs);
 
+  /// Returns true if skip request data size optimization is enabled for single
+  /// source exchanges.
+  bool skipRequestDataSizeWithSingleSource() const {
+    return skipRequestDataSizeWithSingleSource_ && queue_->hasNoMoreSources() &&
+        sources_.size() == 1;
+  }
+
+  folly::F14FastMap<std::string, RuntimeMetric> collectStatsLocked() const;
+
   // Handy for ad-hoc logging.
   const std::string taskId_;
   const int destination_;
@@ -149,10 +181,21 @@ class ExchangeClient : public std::enable_shared_from_this<ExchangeClient> {
   std::vector<std::shared_ptr<ExchangeSource>> sources_;
   bool closed_{false};
 
+  folly::F14FastMap<std::string, RuntimeMetric> stats_;
+
   // The minimum byte size the consumer is expected to consume from
   // the exchange queue.
   const uint64_t minOutputBatchBytes_;
 
+  // Enable single source exchange optimization query config flag
+  // when there is only one exchange source.
+  const bool skipRequestDataSizeWithSingleSource_;
+
+  // If true, defer fetching until next() is called.
+  // If false (default), start fetching data immediately when remote tasks are
+  // added.
+  const bool lazyFetching_;
+
   // Total number of bytes in flight.
   int64_t totalPendingBytes_{0};
 
diff --git a/velox/exec/ExchangeQueue.cpp b/velox/exec/ExchangeQueue.cpp
index b7d1100dbbbb..9a9114ae2c43 100644
--- a/velox/exec/ExchangeQueue.cpp
+++ b/velox/exec/ExchangeQueue.cpp
@@ -16,42 +16,18 @@
 #include "velox/exec/ExchangeQueue.h"
 #include <algorithm>
 
-namespace facebook::velox::exec {
-
-SerializedPage::SerializedPage(
-    std::unique_ptr<folly::IOBuf> iobuf,
-    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_) {
-    int32_t bufSize = buf.size();
-    ranges_.push_back(ByteRange{
-        const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buf.data())),
-        bufSize,
-        0});
-  }
-}
+#include "velox/common/testutil/TestValue.h"
 
-SerializedPage::~SerializedPage() {
-  if (onDestructionCb_) {
-    onDestructionCb_(*iobuf_.get());
-  }
-}
+using facebook::velox::common::testutil::TestValue;
 
-std::unique_ptr<ByteInputStream> SerializedPage::prepareStreamForDeserialize() {
-  return std::make_unique<BufferInputStream>(std::move(ranges_));
-}
+namespace facebook::velox::exec {
 
 void ExchangeQueue::noMoreSources() {
   std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::mutex> l(mutex_);
     noMoreSources_ = true;
-    promises = checkCompleteLocked();
+    promises = checkNoMoreInput();
   }
   clearPromises(promises);
 }
@@ -66,20 +42,21 @@ void ExchangeQueue::close() {
 }
 
 int64_t ExchangeQueue::minOutputBatchBytesLocked() const {
-  // always allow to unblock when at end
-  if (atEnd_) {
+  // Allow to unblock if no more input.
+  if (noMoreInput_) {
     return 0;
   }
-  // At most 1% of received bytes so far to minimize latency for small exchanges
+  // At most 1% of received bytes so far to minimize latency for small
+  // exchanges.
   return std::min<int64_t>(minOutputBatchBytes_, receivedBytes_ / 100);
 }
 
 void ExchangeQueue::enqueueLocked(
-    std::unique_ptr<SerializedPage>&& page,
+    std::unique_ptr<SerializedPageBase>&& page,
     std::vector<ContinuePromise>& promises) {
   if (page == nullptr) {
     ++numCompleted_;
-    auto completedPromises = checkCompleteLocked();
+    auto completedPromises = checkNoMoreInput();
     promises.reserve(promises.size() + completedPromises.size());
     for (auto& promise : completedPromises) {
       promises.push_back(std::move(promise));
@@ -124,18 +101,20 @@ void ExchangeQueue::addPromiseLocked(
     *stalePromise = std::move(it->second);
     it->second = std::move(promise);
   } else {
-    promises_[consumerId] = std::move(promise);
+    promises_.emplace(consumerId, std::move(promise));
   }
   VELOX_CHECK_LE(promises_.size(), numberOfConsumers_);
 }
 
-std::vector<std::unique_ptr<SerializedPage>> ExchangeQueue::dequeueLocked(
+std::vector<std::unique_ptr<SerializedPageBase>> ExchangeQueue::dequeueLocked(
     int consumerId,
     uint32_t maxBytes,
     bool* atEnd,
     ContinueFuture* future,
     ContinuePromise* stalePromise) {
   VELOX_CHECK_NOT_NULL(future);
+  TestValue::adjust(
+      "facebook::velox::exec::ExchangeQueue::dequeueLocked", this);
   if (!error_.empty()) {
     *atEnd = true;
     VELOX_FAIL(error_);
@@ -150,11 +129,11 @@ std::vector<std::unique_ptr<SerializedPage>> ExchangeQueue::dequeueLocked(
     return {};
   }
 
-  std::vector<std::unique_ptr<SerializedPage>> pages;
+  std::vector<std::unique_ptr<SerializedPageBase>> pages;
   uint32_t pageBytes = 0;
   for (;;) {
     if (queue_.empty()) {
-      if (atEnd_) {
+      if (noMoreInput_) {
         *atEnd = true;
       } else if (pages.empty()) {
         addPromiseLocked(consumerId, future, stalePromise);
@@ -183,9 +162,9 @@ void ExchangeQueue::setError(const std::string& error) {
       return;
     }
     error_ = error;
-    atEnd_ = true;
-    // NOTE: clear the serialized page queue as we won't consume from an
-    // errored queue.
+    noMoreInput_ = true;
+    // NOTE: clear the serialized page queue as we won't consume from an errored
+    // queue.
     queue_.clear();
     promises = clearAllPromisesLocked();
   }
diff --git a/velox/exec/ExchangeQueue.h b/velox/exec/ExchangeQueue.h
index 4f77360fdbc7..91a633d5366b 100644
--- a/velox/exec/ExchangeQueue.h
+++ b/velox/exec/ExchangeQueue.h
@@ -15,66 +15,11 @@
  */
 #pragma once
 
-#include "velox/common/memory/ByteStream.h"
+#include "velox/exec/SerializedPage.h"
 
-namespace facebook::velox::exec {
-
-/// Corresponds to Presto SerializedPage, i.e. a container for serialize vectors
-/// in Presto wire format.
-class SerializedPage {
- public:
-  /// Construct from IOBuf chain.
-  explicit SerializedPage(
-      std::unique_ptr<folly::IOBuf> iobuf,
-      std::function<void(folly::IOBuf&)> onDestructionCb = nullptr,
-      std::optional<int64_t> numRows = std::nullopt);
-
-  ~SerializedPage();
+#include <mutex>
 
-  /// Returns the size of the serialized data in bytes.
-  uint64_t size() const {
-    return iobufBytes_;
-  }
-
-  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();
-  }
-
- private:
-  static int64_t chainBytes(folly::IOBuf& iobuf) {
-    int64_t size = 0;
-    for (auto& range : iobuf) {
-      size += range.size();
-    }
-    return size;
-  }
-
-  // Buffers containing the serialized data. The memory is owned by 'iobuf_'.
-  std::vector<ByteRange> ranges_;
-
-  // IOBuf holding the data in 'ranges_.
-  std::unique_ptr<folly::IOBuf> iobuf_;
-
-  // 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
-  // prevent any memory leak.
-  std::function<void(folly::IOBuf&)> onDestructionCb_;
-};
+namespace facebook::velox::exec {
 
 /// Queue of results retrieved from source. Owned by shared_ptr by
 /// Exchange and client threads and registered callbacks waiting
@@ -108,7 +53,7 @@ class ExchangeQueue {
   /// 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::unique_ptr<SerializedPageBase>&& page,
       std::vector<ContinuePromise>& promises);
 
   /// If data is permanently not available, e.g. the source cannot be
@@ -127,7 +72,7 @@ class ExchangeQueue {
   ///
   /// The data may be compressed, in which case 'maxBytes' applies to compressed
   /// size.
-  std::vector<std::unique_ptr<SerializedPage>> dequeueLocked(
+  std::vector<std::unique_ptr<SerializedPageBase>> dequeueLocked(
       int consumerId,
       uint32_t maxBytes,
       bool* atEnd,
@@ -162,6 +107,10 @@ class ExchangeQueue {
 
   void noMoreSources();
 
+  bool hasNoMoreSources() const {
+    return noMoreSources_;
+  }
+
   void close();
 
  private:
@@ -170,9 +119,9 @@ class ExchangeQueue {
     return clearAllPromisesLocked();
   }
 
-  std::vector<ContinuePromise> checkCompleteLocked() {
+  std::vector<ContinuePromise> checkNoMoreInput() {
     if (noMoreSources_ && numCompleted_ == numSources_) {
-      atEnd_ = true;
+      noMoreInput_ = true;
       return clearAllPromisesLocked();
     }
     return {};
@@ -193,7 +142,9 @@ class ExchangeQueue {
   }
 
   std::vector<ContinuePromise> clearAllPromisesLocked() {
-    std::vector<ContinuePromise> promises(promises_.size());
+    std::vector<ContinuePromise> promises;
+    promises.reserve(promises_.size());
+
     auto it = promises_.begin();
     while (it != promises_.end()) {
       promises.push_back(std::move(it->second));
@@ -216,11 +167,14 @@ class ExchangeQueue {
 
   int numCompleted_{0};
   int numSources_{0};
-  bool noMoreSources_{false};
-  bool atEnd_{false};
+  tsan_atomic<bool> noMoreSources_{false};
+  // True if no more pages will be enqueued. This can be due to all sources
+  // completing normally or an error. Note that the queue itself may still
+  // contain data to be consumed.
+  bool noMoreInput_{false};
 
   std::mutex mutex_;
-  std::deque<std::unique_ptr<SerializedPage>> queue_;
+  std::deque<std::unique_ptr<SerializedPageBase>> queue_;
   // The map from consumer id to the waiting promise
   folly::F14FastMap<int, ContinuePromise> promises_;
 
diff --git a/velox/exec/ExchangeSource.h b/velox/exec/ExchangeSource.h
index 2b0f74fa2057..79ec65781b89 100644
--- a/velox/exec/ExchangeSource.h
+++ b/velox/exec/ExchangeSource.h
@@ -106,7 +106,7 @@ 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.
+  // Operator::kBackgroundCpuTimeNanos.
   virtual folly::F14FastMap<std::string, int64_t> stats() const {
     VELOX_UNREACHABLE();
   }
diff --git a/velox/exec/Expand.cpp b/velox/exec/Expand.cpp
index 5d866b888c18..44b6215819e0 100644
--- a/velox/exec/Expand.cpp
+++ b/velox/exec/Expand.cpp
@@ -31,6 +31,7 @@ Expand::Expand(
   const auto numRows = expandNode->projections().size();
   fieldProjections_.reserve(numRows);
   constantProjections_.reserve(numRows);
+  constantOutputs_.reserve(numRows);
   const auto numColumns = expandNode->names().size();
   for (const auto& rowProjections : expandNode->projections()) {
     std::vector<column_index_t> rowProjection;
@@ -58,6 +59,25 @@ Expand::Expand(
   }
 }
 
+void Expand::initialize() {
+  if (constantProjections_.empty()) {
+    return;
+  }
+  const auto numColumns = constantProjections_[0].size();
+  for (const auto& projections : constantProjections_) {
+    std::vector<VectorPtr> constantOutput;
+    constantOutput.reserve(numColumns);
+    for (const auto& constant : projections) {
+      if (constant) {
+        constantOutput.push_back(constant->toConstantVector(pool()));
+      } else {
+        constantOutput.push_back(nullptr);
+      }
+    }
+    constantOutputs_.emplace_back(std::move(constantOutput));
+  }
+}
+
 bool Expand::needsInput() const {
   return !noMoreInput_ && input_ == nullptr;
 }
@@ -81,21 +101,13 @@ RowVectorPtr Expand::getOutput() {
   std::vector<VectorPtr> outputColumns(outputType_->size());
 
   const auto& rowProjection = fieldProjections_[rowIndex_];
-  const auto& constantProjection = constantProjections_[rowIndex_];
+  const auto& constantProjection = constantOutputs_[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());
-      }
+      outputColumns[i] =
+          BaseVector::wrapInConstant(numInput, 0, constantProjection[i]);
     } else {
       outputColumns[i] = input_->childAt(rowProjection[i]);
     }
diff --git a/velox/exec/Expand.h b/velox/exec/Expand.h
index 97c737c1d1f3..adf87a715268 100644
--- a/velox/exec/Expand.h
+++ b/velox/exec/Expand.h
@@ -42,11 +42,15 @@ class Expand : public Operator {
   }
 
  private:
+  void initialize() override;
+
   std::vector<std::vector<column_index_t>> fieldProjections_;
 
   std::vector<std::vector<std::shared_ptr<const core::ConstantTypedExpr>>>
       constantProjections_;
 
+  std::vector<std::vector<VectorPtr>> constantOutputs_;
+
   // Used to indicate the index of fieldProjections_.
   int32_t rowIndex_{0};
 };
diff --git a/velox/exec/FilterProject.cpp b/velox/exec/FilterProject.cpp
index 4b095f3fb55c..b8189539d8f4 100644
--- a/velox/exec/FilterProject.cpp
+++ b/velox/exec/FilterProject.cpp
@@ -86,10 +86,15 @@ FilterProject::FilterProject(
           project ? project->id() : filter->id(),
           "FilterProject"),
       hasFilter_(filter != nullptr),
+      lazyDereference_(
+          dynamic_cast<const core::LazyDereferenceNode*>(project.get()) !=
+          nullptr),
       project_(project),
       filter_(filter) {
+  VELOX_CHECK(!(lazyDereference_ && filter));
   if (filter_ != nullptr && project_ != nullptr) {
-    stats().withWLock([&](auto& stats) {
+    folly::Synchronized<OperatorStats>& opStats = Operator::stats();
+    opStats.withWLock([&](auto& stats) {
       stats.setStatSplitter(
           [filterId = filter_->id()](const auto& combinedStats) {
             return splitStats(combinedStats, filterId);
@@ -123,7 +128,8 @@ void FilterProject::initialize() {
     isIdentityProjection_ = true;
   }
   numExprs_ = allExprs.size();
-  exprs_ = makeExprSetFromFlag(std::move(allExprs), operatorCtx_->execCtx());
+  exprs_ = makeExprSetFromFlag(
+      std::move(allExprs), operatorCtx_->execCtx(), lazyDereference_);
 
   if (numExprs_ > 0 && !identityProjections_.empty()) {
     const auto inputType = project_ ? project_->sources()[0]->outputType()
@@ -146,44 +152,37 @@ void FilterProject::initialize() {
 
 void FilterProject::addInput(RowVectorPtr input) {
   input_ = std::move(input);
-  numProcessedInputRows_ = 0;
-}
-
-bool FilterProject::allInputProcessed() {
-  if (!input_) {
-    return true;
-  }
-  if (numProcessedInputRows_ == input_->size()) {
-    input_ = nullptr;
-    return true;
-  }
-  return false;
 }
 
 bool FilterProject::isFinished() {
-  return noMoreInput_ && allInputProcessed();
+  return noMoreInput_ && !input_;
 }
 
 RowVectorPtr FilterProject::getOutput() {
-  if (allInputProcessed()) {
+  if (!input_) {
     return nullptr;
   }
+  SCOPE_EXIT {
+    input_.reset();
+  };
 
   vector_size_t size = input_->size();
   LocalSelectivityVector localRows(*operatorCtx_->execCtx(), size);
   auto* rows = localRows.get();
   VELOX_DCHECK_NOT_NULL(rows);
   rows->setAll();
-  EvalCtx evalCtx(operatorCtx_->execCtx(), exprs_.get(), input_.get());
-
-  // Pre-load lazy vectors which are referenced by both expressions and identity
-  // projections.
-  for (auto fieldIdx : multiplyReferencedFieldIndices_) {
-    evalCtx.ensureFieldLoaded(fieldIdx, *rows);
+  EvalCtx evalCtx(
+      operatorCtx_->execCtx(), exprs_.get(), input_.get(), lazyDereference_);
+
+  if (!lazyDereference_) {
+    // Pre-load lazy vectors which are referenced by both expressions and
+    // identity projections.
+    for (auto fieldIdx : multiplyReferencedFieldIndices_) {
+      evalCtx.ensureFieldLoaded(fieldIdx, *rows);
+    }
   }
 
   if (!hasFilter_) {
-    numProcessedInputRows_ = size;
     VELOX_CHECK(!isIdentityProjection_);
     auto results = project(*rows, evalCtx);
     return fillOutput(size, nullptr, results);
@@ -191,7 +190,6 @@ RowVectorPtr FilterProject::getOutput() {
 
   // evaluate filter
   auto numOut = filter(evalCtx, *rows);
-  numProcessedInputRows_ = size;
   if (numOut == 0) { // no rows passed the filer
     input_ = nullptr;
     return nullptr;
@@ -229,4 +227,16 @@ vector_size_t FilterProject::filter(
   exprs_->eval(0, 1, true, allRows, evalCtx, results);
   return processFilterResults(results[0], allRows, filterEvalCtx_, pool());
 }
+
+OperatorStats FilterProject::stats(bool clear) {
+  auto stats = Operator::stats(clear);
+  if (operatorCtx()
+          ->driverCtx()
+          ->queryConfig()
+          .operatorTrackExpressionStats() &&
+      exprs_ != nullptr) {
+    stats.expressionStats = exprs_->stats(true /*excludeSpecialForm*/);
+  }
+  return stats;
+}
 } // namespace facebook::velox::exec
diff --git a/velox/exec/FilterProject.h b/velox/exec/FilterProject.h
index d82f2cb2a400..b5ae557e0fd6 100644
--- a/velox/exec/FilterProject.h
+++ b/velox/exec/FilterProject.h
@@ -78,12 +78,17 @@ class FilterProject : public Operator {
 
   void initialize() override;
 
- private:
-  // Tests if 'numProcessedRows_' equals to the length of input_ and clears
-  // outstanding references to input_ if done. Returns true if getOutput
-  // should return nullptr.
-  bool allInputProcessed();
+  /// Ensures that expression stats are added to the operator stats if their
+  /// tracking is enabled via query config.
+  OperatorStats stats(bool clear) override;
+
+  /// Returns the filterNode, call this function before initialize the operator,
+  /// this field is reset in function initialize.
+  const std::shared_ptr<const core::FilterNode>& filterNode() const {
+    return filter_;
+  }
 
+ private:
   // Evaluate filter on all rows. Return number of rows that passed the filter.
   // Populate filterEvalCtx_.selectedBits and selectedIndices with the indices
   // of the passing rows if only some rows pass the filter. If all or no rows
@@ -100,6 +105,8 @@ class FilterProject : public Operator {
   // If true exprs_[0] is a filter and the other expressions are projections
   const bool hasFilter_{false};
 
+  const bool lazyDereference_;
+
   // Cached filter and project node for lazy initialization. After
   // initialization, they will be reset, and initialized_ will be set to true.
   std::shared_ptr<const core::ProjectNode> project_;
@@ -111,8 +118,6 @@ class FilterProject : public Operator {
 
   FilterEvalCtx filterEvalCtx_;
 
-  vector_size_t numProcessedInputRows_{0};
-
   // Indices for fields/input columns that are both an identity projection and
   // are referenced by either a filter or project expression. This is used to
   // identify fields that need to be preloaded before evaluating filters or
diff --git a/velox/exec/GroupingSet.cpp b/velox/exec/GroupingSet.cpp
index c9da8832986c..152290f9f283 100644
--- a/velox/exec/GroupingSet.cpp
+++ b/velox/exec/GroupingSet.cpp
@@ -15,6 +15,7 @@
  */
 #include "velox/exec/GroupingSet.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 
 using facebook::velox::common::testutil::TestValue;
@@ -53,7 +54,8 @@ GroupingSet::GroupingSet(
     const std::optional<column_index_t>& groupIdChannel,
     const common::SpillConfig* spillConfig,
     tsan_atomic<bool>* nonReclaimableSection,
-    OperatorCtx* operatorCtx,
+    const core::QueryConfig* queryConfig,
+    memory::MemoryPool* pool,
     folly::Synchronized<common::SpillStats>* spillStats)
     : preGroupedKeyChannels_(std::move(preGroupedKeys)),
       groupingKeyOutputProjections_(std::move(groupingKeyOutputProjections)),
@@ -61,7 +63,8 @@ GroupingSet::GroupingSet(
       isGlobal_(hashers_.empty()),
       isPartial_(isPartial),
       isRawInput_(isRawInput),
-      queryConfig_(operatorCtx->task()->queryCtx()->queryConfig()),
+      queryConfig_(queryConfig),
+      pool_(pool),
       aggregates_(std::move(aggregates)),
       masks_(extractMaskChannels(aggregates_)),
       ignoreNullKeys_(ignoreNullKeys),
@@ -69,13 +72,12 @@ GroupingSet::GroupingSet(
       groupIdChannel_(groupIdChannel),
       spillConfig_(spillConfig),
       nonReclaimableSection_(nonReclaimableSection),
-      stringAllocator_(operatorCtx->pool()),
-      rows_(operatorCtx->pool()),
-      isAdaptive_(queryConfig_.hashAdaptivityEnabled()),
-      pool_(*operatorCtx->pool()),
+      stringAllocator_(pool_),
+      rows_(pool_),
+      isAdaptive_(queryConfig_->hashAdaptivityEnabled()),
       spillStats_(spillStats) {
   VELOX_CHECK_NOT_NULL(nonReclaimableSection_);
-  VELOX_CHECK(pool_.trackUsage());
+  VELOX_CHECK(pool_->trackUsage());
 
   for (auto& hasher : hashers_) {
     keyChannels_.push_back(hasher->channel());
@@ -104,7 +106,7 @@ GroupingSet::GroupingSet(
   }
 
   sortedAggregations_ =
-      SortedAggregations::create(aggregates_, inputType, &pool_);
+      SortedAggregations::create(aggregates_, inputType, pool_);
   if (isPartial_) {
     VELOX_USER_CHECK_NULL(
         sortedAggregations_,
@@ -117,7 +119,7 @@ GroupingSet::GroupingSet(
           !isPartial_,
           "Partial aggregations over distinct inputs are not supported");
       distinctAggregations_.emplace_back(
-          DistinctAggregations::create({&aggregate}, inputType, &pool_));
+          DistinctAggregations::create({&aggregate}, inputType, pool_));
     } else {
       distinctAggregations_.push_back(nullptr);
     }
@@ -148,7 +150,8 @@ std::unique_ptr<GroupingSet> GroupingSet::createForMarkDistinct(
       /*groupIdColumn=*/std::nullopt,
       /*spillConfig=*/nullptr,
       nonReclaimableSection,
-      operatorCtx,
+      &operatorCtx->driverCtx()->queryConfig(),
+      operatorCtx->pool(),
       /*spillStats=*/nullptr);
 };
 
@@ -374,10 +377,10 @@ std::vector<Accumulator> GroupingSet::accumulators(bool excludeToIntermediate) {
 void GroupingSet::createHashTable() {
   if (ignoreNullKeys_) {
     table_ = HashTable<true>::createForAggregation(
-        std::move(hashers_), accumulators(false), &pool_);
+        std::move(hashers_), accumulators(false), pool_);
   } else {
     table_ = HashTable<false>::createForAggregation(
-        std::move(hashers_), accumulators(false), &pool_);
+        std::move(hashers_), accumulators(false), pool_);
   }
 
   RowContainer& rows = *table_->rows();
@@ -416,7 +419,7 @@ void GroupingSet::createHashTable() {
     }
   }
 
-  lookup_ = std::make_unique<HashLookup>(table_->hashers(), &pool_);
+  lookup_ = std::make_unique<HashLookup>(table_->hashers(), pool_);
   if (!isAdaptive_ && table_->hashMode() != BaseHashTable::HashMode::kHash) {
     table_->forceGenericHashMode(BaseHashTable::kNoSpillInputStartPartitionBit);
   }
@@ -427,7 +430,7 @@ void GroupingSet::initializeGlobalAggregation() {
     return;
   }
 
-  lookup_ = std::make_unique<HashLookup>(hashers_, &pool_);
+  lookup_ = std::make_unique<HashLookup>(hashers_, pool_);
   lookup_->reset(1);
 
   // Row layout is:
@@ -642,7 +645,7 @@ bool GroupingSet::getDefaultGlobalGroupingSetOutput(
   }
 
   auto globalAggregatesRow =
-      BaseVector::create<RowVector>(result->type(), 1, &pool_);
+      BaseVector::create<RowVector>(result->type(), 1, pool_);
 
   VELOX_CHECK(getGlobalAggregationOutput(iterator, globalAggregatesRow));
 
@@ -878,16 +881,16 @@ void GroupingSet::ensureInputFits(const RowVectorPtr& input) {
   const int64_t flatBytes = input->estimateFlatSize();
 
   // Test-only spill path.
-  if (testingTriggerSpill(pool_.name())) {
+  if (testingTriggerSpill(pool_->name())) {
     memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
-    memory::testingRunArbitration(&pool_);
+    memory::testingRunArbitration(pool_);
     return;
   }
 
-  const auto currentUsage = pool_.usedBytes();
+  const auto currentUsage = pool_->usedBytes();
   const auto minReservationBytes =
       currentUsage * spillConfig_->minSpillableReservationPct / 100;
-  const auto availableReservationBytes = pool_.availableReservation();
+  const auto availableReservationBytes = pool_->availableReservation();
   const auto tableIncrementBytes = table_->hashTableSizeIncrease(input->size());
   const auto incrementBytes =
       rows->sizeIncrement(input->size(), outOfLineBytes ? flatBytes * 2 : 0) +
@@ -924,14 +927,14 @@ void GroupingSet::ensureInputFits(const RowVectorPtr& input) {
       currentUsage * spillConfig_->spillableReservationGrowthPct / 100);
   {
     memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
-    if (pool_.maybeReserve(targetIncrementBytes)) {
+    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());
+               << " for memory pool " << pool_->name()
+               << ", usage: " << succinctBytes(pool_->usedBytes())
+               << ", reservation: " << succinctBytes(pool_->reservedBytes());
 }
 
 void GroupingSet::ensureOutputFits() {
@@ -945,33 +948,33 @@ void GroupingSet::ensureOutputFits() {
   }
 
   // Test-only spill path.
-  if (testingTriggerSpill(pool_.name())) {
+  if (testingTriggerSpill(pool_->name())) {
     memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
-    memory::testingRunArbitration(&pool_);
+    memory::testingRunArbitration(pool_);
     return;
   }
 
   const uint64_t outputBufferSizeToReserve =
-      queryConfig_.preferredOutputBatchBytes() * 1.2;
+      queryConfig_->preferredOutputBatchBytes() * 1.2;
   {
     memory::ReclaimableSectionGuard guard(nonReclaimableSection_);
-    if (pool_.maybeReserve(outputBufferSizeToReserve)) {
+    if (pool_->maybeReserve(outputBufferSizeToReserve)) {
       if (hasSpilled()) {
         // If reservation triggers spilling on the 'GroupingSet' itself, we will
         // no longer need the reserved memory for output processing as the
         // output processing will be conducted from unspilled data through
         // 'getOutputWithSpill()', and it does not require this amount of memory
         // to process.
-        pool_.release();
+        pool_->release();
       }
       return;
     }
   }
   LOG(WARNING) << "Failed to reserve "
                << succinctBytes(outputBufferSizeToReserve)
-               << " for memory pool " << pool_.name()
-               << ", usage: " << succinctBytes(pool_.usedBytes())
-               << ", reservation: " << succinctBytes(pool_.reservedBytes());
+               << " for memory pool " << pool_->name()
+               << ", usage: " << succinctBytes(pool_->usedBytes())
+               << ", reservation: " << succinctBytes(pool_->reservedBytes());
 }
 
 RowTypePtr GroupingSet::makeSpillType() const {
@@ -1013,7 +1016,7 @@ void GroupingSet::spill() {
   auto* rows = table_->rows();
   VELOX_CHECK_NULL(outputSpiller_);
   if (inputSpiller_ == nullptr) {
-    VELOX_DCHECK(pool_.trackUsage());
+    VELOX_DCHECK(pool_->trackUsage());
     VELOX_CHECK(numDistinctSpillFilesPerPartition_.empty());
     const auto sortingKeys = SpillState::makeSortingKeys(
         std::vector<CompareFlags>(rows->keyTypes().size()));
@@ -1061,7 +1064,7 @@ void GroupingSet::spill(const RowContainerIterator& rowIterator) {
   }
 
   auto* rows = table_->rows();
-  VELOX_CHECK(pool_.trackUsage());
+  VELOX_CHECK(pool_->trackUsage());
   outputSpiller_ = std::make_unique<AggregationOutputSpiller>(
       rows, makeSpillType(), spillConfig_, spillStats_);
 
@@ -1099,7 +1102,8 @@ bool GroupingSet::getOutputWithSpill(
           false,
           false,
           false,
-          &pool_);
+          false,
+          pool_);
 
       initializeAggregates(aggregates_, *mergeRows_, false);
     }
@@ -1134,8 +1138,7 @@ bool GroupingSet::prepareNextSpillPartitionOutput() {
   auto it = spillPartitionSet_.begin();
   VELOX_CHECK_NE(outputSpillPartition_, it->first.partitionNumber());
   outputSpillPartition_ = it->first.partitionNumber();
-  merge_ = it->second->createOrderedReader(
-      spillConfig_->readBufferSize, &pool_, spillStats_);
+  merge_ = it->second->createOrderedReader(*spillConfig_, pool_, spillStats_);
   spillPartitionSet_.erase(it);
   return true;
 }
@@ -1230,7 +1233,7 @@ void GroupingSet::prepareSpillResultWithoutAggregates(
     spillResultWithoutAggregates_ = BaseVector::create<RowVector>(
         std::make_shared<RowType>(std::move(names), std::move(types)),
         maxOutputRows,
-        &pool_);
+        pool_);
   } else {
     VectorPtr spillResultWithoutAggregates =
         std::move(spillResultWithoutAggregates_);
@@ -1244,6 +1247,9 @@ void GroupingSet::prepareSpillResultWithoutAggregates(
     spillResultWithoutAggregates_->childAt(groupingKeyOutputProjections_[i]) =
         std::move(result->childAt(i));
   }
+
+  spillSources_.resize(maxOutputRows);
+  spillSourceRows_.resize(maxOutputRows);
 }
 
 void GroupingSet::projectResult(const RowVectorPtr& result) {
@@ -1264,6 +1270,7 @@ bool GroupingSet::mergeNextWithoutAggregates(
   VELOX_CHECK_EQ(
       numDistinctSpillFilesPerPartition_.size(),
       1 << spillConfig_->numPartitionBits);
+  VELOX_CHECK(pool_ == result->pool());
 
   // 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
@@ -1278,12 +1285,15 @@ bool GroupingSet::mergeNextWithoutAggregates(
   // less than 'numDistinctSpillFilesPerPartition_'.
   bool newDistinct{true};
   int32_t numOutputRows{0};
+  int32_t outputSize{0};
+  bool endOfBatch = false;
   prepareSpillResultWithoutAggregates(maxOutputRows, result);
 
-  while (numOutputRows < maxOutputRows) {
+  while (numOutputRows + outputSize < maxOutputRows) {
     const auto next = merge_->nextWithEquals();
     auto* stream = next.first;
     if (stream == nullptr) {
+      VELOX_CHECK_EQ(outputSize, 0);
       if (numOutputRows > 0) {
         break;
       }
@@ -1298,17 +1308,40 @@ bool GroupingSet::mergeNextWithoutAggregates(
         numDistinctSpillFilesPerPartition_[outputSpillPartition_]) {
       newDistinct = false;
     }
-    if (next.second) {
-      stream->pop();
-      continue;
-    }
-    if (newDistinct) {
+    auto index = stream->currentIndex(&endOfBatch);
+    if (!next.second && newDistinct) {
       // Yield result for new distinct.
-      spillResultWithoutAggregates_->copy(
-          &stream->current(), numOutputRows++, stream->currentIndex(), 1);
+      spillSources_[outputSize] = &stream->current();
+      spillSourceRows_[outputSize] = index;
+      ++outputSize;
+    }
+
+    if (FOLLY_UNLIKELY(endOfBatch)) {
+      // The stream is at end of input batch. Need to copy out the rows before
+      // fetching next batch in 'pop'.
+      gatherCopy(
+          spillResultWithoutAggregates_.get(),
+          numOutputRows,
+          outputSize,
+          spillSources_,
+          spillSourceRows_);
+      numOutputRows += outputSize;
+      outputSize = 0;
     }
     stream->pop();
-    newDistinct = true;
+    // Reset newDistinct flag for new row.
+    if (!next.second) {
+      newDistinct = true;
+    }
+  }
+  if (FOLLY_LIKELY(outputSize != 0)) {
+    gatherCopy(
+        spillResultWithoutAggregates_.get(),
+        numOutputRows,
+        outputSize,
+        spillSources_,
+        spillSourceRows_);
+    numOutputRows += outputSize;
   }
   spillResultWithoutAggregates_->resize(numOutputRows);
   projectResult(result);
@@ -1405,7 +1438,8 @@ void GroupingSet::abandonPartialAggregation() {
       false,
       false,
       false,
-      &pool_);
+      false,
+      pool_);
   initializeAggregates(aggregates_, *intermediateRows_, true);
   table_.reset();
 }
@@ -1500,8 +1534,9 @@ void GroupingSet::toIntermediate(
         &aggregateVector);
   }
   if (intermediateRows_) {
-    intermediateRows_->eraseRows(folly::Range<char**>(
-        intermediateGroups_.data(), intermediateGroups_.size()));
+    intermediateRows_->eraseRows(
+        folly::Range<char**>(
+            intermediateGroups_.data(), intermediateGroups_.size()));
   }
 
   // It's unnecessary to call function->clear() to reset the internal states of
diff --git a/velox/exec/GroupingSet.h b/velox/exec/GroupingSet.h
index a599fb9b628d..f84a327f5f71 100644
--- a/velox/exec/GroupingSet.h
+++ b/velox/exec/GroupingSet.h
@@ -15,13 +15,13 @@
  */
 #pragma once
 
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/exec/AggregateInfo.h"
 #include "velox/exec/AggregationMasks.h"
 #include "velox/exec/DistinctAggregations.h"
 #include "velox/exec/HashTable.h"
 #include "velox/exec/SortedAggregations.h"
 #include "velox/exec/Spiller.h"
-#include "velox/exec/TreeOfLosers.h"
 #include "velox/exec/VectorHasher.h"
 
 namespace facebook::velox::exec {
@@ -43,7 +43,8 @@ class GroupingSet {
       const std::optional<column_index_t>& groupIdChannel,
       const common::SpillConfig* spillConfig,
       tsan_atomic<bool>* nonReclaimableSection,
-      OperatorCtx* operatorCtx,
+      const core::QueryConfig* queryConfig,
+      memory::MemoryPool* pool,
       folly::Synchronized<common::SpillStats>* spillStats);
 
   ~GroupingSet();
@@ -148,7 +149,7 @@ class GroupingSet {
       RowContainerIterator& iterator,
       RowVectorPtr& result);
 
-  memory::MemoryPool& testingPool() const {
+  memory::MemoryPool* testingPool() const {
     return pool_;
   }
 
@@ -302,7 +303,8 @@ class GroupingSet {
   const bool isGlobal_;
   const bool isPartial_;
   const bool isRawInput_;
-  const core::QueryConfig& queryConfig_;
+  const core::QueryConfig* const queryConfig_;
+  memory::MemoryPool* const pool_;
 
   std::vector<AggregateInfo> aggregates_;
   AggregationMasks masks_;
@@ -358,6 +360,11 @@ class GroupingSet {
   // result.
   RowVectorPtr spillResultWithoutAggregates_{nullptr};
 
+  // Records the source rows to copy to 'output_' in order.
+  std::vector<const RowVector*> spillSources_;
+
+  std::vector<vector_size_t> spillSourceRows_;
+
   // The value of mayPushdown flag specified in addInput() for the
   // 'remainingInput_'.
   bool remainingMayPushdown_;
@@ -391,9 +398,6 @@ class GroupingSet {
   // to merge.
   SelectivityVector mergeSelection_;
 
-  // Pool of the OperatorCtx. Used for spilling.
-  memory::MemoryPool& pool_;
-
   // True if partial aggregation has been given up as non-productive.
   bool abandonedPartialAggregation_{false};
 
diff --git a/velox/exec/HashAggregation.cpp b/velox/exec/HashAggregation.cpp
index 14e87f336ec2..bcc3b4b97cbd 100644
--- a/velox/exec/HashAggregation.cpp
+++ b/velox/exec/HashAggregation.cpp
@@ -84,7 +84,7 @@ void HashAggregation::initialize() {
         "Unexpected result type for an aggregation: {}, expected {}, step {}",
         aggResultType->toString(),
         expectedType->toString(),
-        core::AggregationNode::stepName(aggregationNode_->step()));
+        core::AggregationNode::toName(aggregationNode_->step()));
   }
 
   for (auto i = 0; i < hashers.size(); ++i) {
@@ -112,8 +112,9 @@ void HashAggregation::initialize() {
       groupIdChannel,
       spillConfig_.has_value() ? &spillConfig_.value() : nullptr,
       &nonReclaimableSection_,
-      operatorCtx_.get(),
-      &spillStats_);
+      &operatorCtx_->driverCtx()->queryConfig(),
+      operatorCtx_->pool(),
+      spillStats_.get());
 
   aggregationNode_.reset();
 }
diff --git a/velox/exec/HashBitRange.h b/velox/exec/HashBitRange.h
index b4ebcd30a597..3d2af0f57dcb 100644
--- a/velox/exec/HashBitRange.h
+++ b/velox/exec/HashBitRange.h
@@ -55,14 +55,10 @@ class HashBitRange {
     return 1 << numBits();
   }
 
-  inline bool operator==(const HashBitRange& other) const {
+  bool operator==(const HashBitRange& other) const {
     return std::tie(begin_, end_) == std::tie(other.begin_, other.end_);
   }
 
-  inline bool operator!=(const HashBitRange& other) const {
-    return !(*this == other);
-  }
-
  private:
   // Low bit number of hash number bit range.
   uint8_t begin_;
diff --git a/velox/exec/HashBuild.cpp b/velox/exec/HashBuild.cpp
index 3cd021bbb7ec..389065a448c2 100644
--- a/velox/exec/HashBuild.cpp
+++ b/velox/exec/HashBuild.cpp
@@ -18,8 +18,10 @@
 #include "velox/common/base/Counters.h"
 #include "velox/common/base/StatsReporter.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/HashTableCache.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
+#include "velox/exec/VectorHasher.h"
 #include "velox/expression/FieldReference.h"
 
 using facebook::velox::common::testutil::TestValue;
@@ -62,6 +64,13 @@ HashBuild::HashBuild(
       joinType_{joinNode_->joinType()},
       nullAware_{joinNode_->isNullAware()},
       needProbedFlagSpill_{needRightSideJoin(joinType_)},
+      dropDuplicates_(joinNode_->canDropDuplicates()),
+      vectorHasherMaxNumDistinct_(
+          driverCtx->queryConfig().joinBuildVectorHasherMaxNumDistinct()),
+      abandonHashBuildDedupMinRows_(
+          driverCtx->queryConfig().abandonHashBuildDedupMinRows()),
+      abandonHashBuildDedupMinPct_(
+          driverCtx->queryConfig().abandonHashBuildDedupMinPct()),
       joinBridge_(operatorCtx_->task()->getHashJoinBridgeLocked(
           operatorCtx_->driverCtx()->splitGroupId,
           planNodeId())),
@@ -85,36 +94,127 @@ HashBuild::HashBuild(
 
   // Identify the non-key build side columns and make a decoder for each.
   const int32_t numDependents = inputType->size() - numKeys;
-  if (numDependents > 0) {
-    // Number of join keys (numKeys) may be less then number of input columns
-    // (inputType->size()). In this case numDependents is negative and cannot be
-    // used to call 'reserve'. This happens when we join different probe side
-    // keys with the same build side key: SELECT * FROM t LEFT JOIN u ON t.k1 =
-    // u.k AND t.k2 = u.k.
-    dependentChannels_.reserve(numDependents);
-    decoders_.reserve(numDependents);
-  }
-  for (auto i = 0; i < inputType->size(); ++i) {
-    if (keyChannelMap_.find(i) == keyChannelMap_.end()) {
-      dependentChannels_.emplace_back(i);
-      decoders_.emplace_back(std::make_unique<DecodedVector>());
+  if (!dropDuplicates_) {
+    if (numDependents > 0) {
+      // Number of join keys (numKeys) may be less then number of input columns
+      // (inputType->size()). In this case numDependents is negative and cannot
+      // be used to call 'reserve'. This happens when we join different probe
+      // side keys with the same build side key: SELECT * FROM t LEFT JOIN u ON
+      // t.k1 = u.k AND t.k2 = u.k.
+      dependentChannels_.reserve(numDependents);
+      decoders_.reserve(numDependents);
+    }
+
+    for (auto i = 0; i < inputType->size(); ++i) {
+      if (keyChannelMap_.find(i) == keyChannelMap_.end()) {
+        dependentChannels_.emplace_back(i);
+        decoders_.emplace_back(std::make_unique<DecodedVector>());
+      }
     }
   }
 
   tableType_ = hashJoinTableType(joinNode_);
-  setupTable();
-  setupSpiller();
+
   stateCleared_ = false;
 }
 
 void HashBuild::initialize() {
   Operator::initialize();
 
+  if (setupCachedHashTable()) {
+    return;
+  }
+
+  // Set up table and spiller now that cache state is initialized.
+  // This ensures tableMemoryPool() returns the cache's tablePool when enabled.
+  setupTable();
+  setupSpiller();
+
   if (isAntiJoin(joinType_) && joinNode_->filter()) {
     setupFilterForAntiJoins(keyChannelMap_);
   }
 }
 
+bool HashBuild::setupCachedHashTable() {
+  if (!joinNode_->useHashTableCache()) {
+    return false;
+  }
+
+  const auto& queryId = operatorCtx_->task()->queryCtx()->queryId();
+  cacheKey_ = fmt::format("{}:{}", queryId, planNodeId());
+
+  // Get or create the cache entry (which includes the pool).
+  // If another task is already building, future_ will be set.
+  auto* cache = HashTableCache::instance();
+  auto* queryCtx = operatorCtx_->task()->queryCtx().get();
+  cacheEntry_ = cache->get(cacheKey_, taskId(), queryCtx, &future_);
+  VELOX_CHECK_NOT_NULL(cacheEntry_);
+  VELOX_CHECK_NOT_NULL(cacheEntry_->tablePool);
+
+  // Check if table is already built.
+  if (cacheEntry_->buildComplete) {
+    noMoreInput();
+    return true;
+  }
+
+  // Check if we're a waiter task (future was set by get).
+  if (future_.valid()) {
+    setState(State::kWaitForBuild);
+    return true;
+  }
+
+  // This is the builder task - proceed with building.
+  return false;
+}
+
+bool HashBuild::getHashTableFromCache() {
+  if (!useHashTableCache()) {
+    return false;
+  }
+
+  if (!cacheEntry_->buildComplete) {
+    // Cache miss - we need to build the table.
+    stats_.wlock()->addRuntimeStat(
+        BaseHashTable::kHashTableCacheMiss, RuntimeCounter(1));
+    return false;
+  }
+
+  // Table already built by a previous task! Use it directly.
+  // Notify the bridge with the cached table.
+  // We pass a shared_ptr copy (not std::move) since the cache retains
+  // ownership.
+  joinBridge_->setHashTable(
+      cacheEntry_->table, {}, cacheEntry_->hasNullKeys, nullptr);
+  // Record cache hit metric.
+  stats_.wlock()->addRuntimeStat(
+      BaseHashTable::kHashTableCacheHit, RuntimeCounter(1));
+  return true;
+}
+
+void HashBuild::maybeSetHashTableInCache(
+    const std::shared_ptr<BaseHashTable>& table) {
+  if (!useHashTableCache()) {
+    return;
+  }
+  auto* cache = HashTableCache::instance();
+  cache->put(cacheKey(), table, joinHasNullKeys_);
+}
+
+bool HashBuild::receivedCachedHashTable() {
+  if (!useHashTableCache() || future_.valid()) {
+    return false;
+  }
+  // We were waiting on cached table from another task.
+  // Ensure that table is ready.
+  VELOX_CHECK(
+      cacheEntry_->buildComplete,
+      "Signalled that cache table is ready but it is not built yet.");
+  // Proceed through normal noMoreInput flow which will use the cache.
+  setRunning();
+  noMoreInput();
+  return true;
+}
+
 void HashBuild::setupTable() {
   VELOX_CHECK_NULL(table_);
 
@@ -132,6 +232,7 @@ void HashBuild::setupTable() {
   for (int i = numKeys; i < tableType_->size(); ++i) {
     dependentTypes.emplace_back(tableType_->childAt(i));
   }
+  auto& queryConfig = operatorCtx_->driverCtx()->queryConfig();
   if (joinNode_->isRightJoin() || joinNode_->isFullJoin() ||
       joinNode_->isRightSemiProjectJoin()) {
     // Do not ignore null keys.
@@ -140,16 +241,9 @@ void HashBuild::setupTable() {
         dependentTypes,
         true, // allowDuplicates
         true, // hasProbedFlag
-        operatorCtx_->driverCtx()
-            ->queryConfig()
-            .minTableRowsForParallelJoinBuild(),
-        pool());
+        queryConfig.minTableRowsForParallelJoinBuild(),
+        tableMemoryPool());
   } else {
-    // (Left) semi and anti join with no extra filter only needs to know whether
-    // there is a match. Hence, no need to store entries with duplicate keys.
-    const bool dropDuplicates = !joinNode_->filter() &&
-        (joinNode_->isLeftSemiFilterJoin() ||
-         joinNode_->isLeftSemiProjectJoin() || isAntiJoin(joinType_));
     // Right semi join needs to tag build rows that were probed.
     const bool needProbedFlag = joinNode_->isRightSemiFilterJoin();
     if (isLeftNullAwareJoinWithFilter(joinNode_)) {
@@ -158,26 +252,32 @@ void HashBuild::setupTable() {
       table_ = HashTable<false>::createForJoin(
           std::move(keyHashers),
           dependentTypes,
-          !dropDuplicates, // allowDuplicates
+          !dropDuplicates_, // allowDuplicates
           needProbedFlag, // hasProbedFlag
-          operatorCtx_->driverCtx()
-              ->queryConfig()
-              .minTableRowsForParallelJoinBuild(),
-          pool());
+          queryConfig.minTableRowsForParallelJoinBuild(),
+          tableMemoryPool());
     } else {
       // Ignore null keys
       table_ = HashTable<true>::createForJoin(
           std::move(keyHashers),
           dependentTypes,
-          !dropDuplicates, // allowDuplicates
+          !dropDuplicates_, // allowDuplicates
           needProbedFlag, // hasProbedFlag
-          operatorCtx_->driverCtx()
-              ->queryConfig()
-              .minTableRowsForParallelJoinBuild(),
-          pool());
+          queryConfig.minTableRowsForParallelJoinBuild(),
+          tableMemoryPool(),
+          queryConfig.hashProbeBloomFilterPushdownMaxSize());
     }
   }
   analyzeKeys_ = table_->hashMode() != BaseHashTable::HashMode::kHash;
+  if (abandonHashBuildDedupMinPct_ == 0) {
+    // Building a HashTable without duplicates is disabled if
+    // abandonBuildNoDupHashMinPct_ is 0.
+    abandonHashBuildDedup_ = true;
+    table_->setAllowDuplicates(true);
+    return;
+  }
+  // Only create HashLookup when dedup is enabled.
+  lookup_ = std::make_unique<HashLookup>(table_->hashers(), pool());
 }
 
 void HashBuild::setupSpiller(SpillPartition* spillPartition) {
@@ -203,7 +303,7 @@ void HashBuild::setupSpiller(SpillPartition* spillPartition) {
   uint8_t startPartitionBit = config->startPartitionBit;
   if (spillPartition != nullptr) {
     spillInputReader_ = spillPartition->createUnorderedReader(
-        config->readBufferSize, pool(), &spillStats_);
+        config->readBufferSize, pool(), spillStats_.get());
     VELOX_CHECK(!restoringPartitionId_.has_value());
     restoringPartitionId_ = spillPartition->id();
     const auto numPartitionBits = config->numPartitionBits;
@@ -218,7 +318,7 @@ void HashBuild::setupSpiller(SpillPartition* spillPartition) {
       LOG(WARNING) << "Exceeded spill level limit: " << config->maxSpillLevel
                    << ", and disable spilling for memory pool: "
                    << pool()->name();
-      ++spillStats_.wlock()->spillMaxLevelExceededCount;
+      ++spillStats_->wlock()->spillMaxLevelExceededCount;
       exceededMaxSpillLevelLimit_ = true;
       return;
     }
@@ -233,7 +333,7 @@ void HashBuild::setupSpiller(SpillPartition* spillPartition) {
       HashBitRange(
           startPartitionBit, startPartitionBit + config->numPartitionBits),
       config,
-      &spillStats_);
+      spillStats_.get());
 
   const int32_t numPartitions = spiller_->hashBits().numPartitions();
   spillInputIndicesBuffers_.resize(numPartitions);
@@ -308,6 +408,11 @@ void HashBuild::removeInputRowsForAntiJoinFilter() {
 
 void HashBuild::addInput(RowVectorPtr input) {
   checkRunning();
+
+  VELOX_CHECK(
+      !useHashTableCache() ||
+      (cacheEntry_->builderTaskId == taskId() && !cacheEntry_->buildComplete));
+
   ensureInputFits(input);
 
   TestValue::adjust("facebook::velox::exec::HashBuild::addInput", this);
@@ -376,6 +481,25 @@ void HashBuild::addInput(RowVectorPtr input) {
     return;
   }
 
+  if (dropDuplicates_ && !abandonHashBuildDedup_) {
+    const bool abandonEarly = abandonHashBuildDedupEarly(table_->numDistinct());
+    if (!abandonEarly) {
+      numHashInputRows_ += activeRows_.countSelected();
+      table_->prepareForGroupProbe(
+          *lookup_,
+          input,
+          activeRows_,
+          BaseHashTable::kNoSpillInputStartPartitionBit);
+      if (lookup_->rows.empty()) {
+        return;
+      }
+      table_->groupProbe(
+          *lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
+      return;
+    }
+    abandonHashBuildDedup();
+  }
+
   if (analyzeKeys_ && hashes_.size() < activeRows_.end()) {
     hashes_.resize(activeRows_.end());
   }
@@ -626,6 +750,7 @@ void HashBuild::noMoreInput() {
   if (noMoreInput_) {
     return;
   }
+
   Operator::noMoreInput();
 
   noMoreInputInternal();
@@ -670,6 +795,10 @@ bool HashBuild::finishHashBuild() {
     }
   };
 
+  if (getHashTableFromCache()) {
+    return true;
+  }
+
   if (joinHasNullKeys_ && isAntiJoin(joinType_) && nullAware_ &&
       !joinNode_->filter()) {
     joinBridge_->setAntiJoinHasNullKeys();
@@ -754,6 +883,8 @@ bool HashBuild::finishHashBuild() {
         std::move(otherTables),
         isInputFromSpill() ? spillConfig()->startPartitionBit
                            : BaseHashTable::kNoSpillInputStartPartitionBit,
+        vectorHasherMaxNumDistinct_,
+        dropDuplicates_,
         allowParallelJoinBuild ? operatorCtx_->task()->queryCtx()->executor()
                                : nullptr);
   }
@@ -768,26 +899,31 @@ bool HashBuild::finishHashBuild() {
   HashJoinTableSpillFunc tableSpillFunc;
   if (canReclaim()) {
     VELOX_CHECK_NOT_NULL(spiller_);
-    tableSpillFunc = [hashBitRange = spiller_->hashBits(),
-                      restoringPartitionId = restoringPartitionId_,
-                      joinNode = joinNode_,
-                      spillConfig = spillConfig(),
-                      spillStats =
-                          &spillStats_](std::shared_ptr<BaseHashTable> table) {
-      return spillHashJoinTable(
-          table,
-          restoringPartitionId,
-          hashBitRange,
-          joinNode,
-          spillConfig,
-          spillStats);
-    };
-  }
+    tableSpillFunc =
+        [hashBitRange = spiller_->hashBits(),
+         restoringPartitionId = restoringPartitionId_,
+         joinNode = joinNode_,
+         spillConfig = spillConfig(),
+         spillStats = spillStats_.get()](std::shared_ptr<BaseHashTable> table) {
+          return spillHashJoinTable(
+              table,
+              restoringPartitionId,
+              hashBitRange,
+              joinNode,
+              spillConfig,
+              spillStats);
+        };
+  }
+
+  // For hash table caching: the last driver caches the merged table.
+  std::shared_ptr<BaseHashTable> table = std::move(table_);
+  maybeSetHashTableInCache(table);
   joinBridge_->setHashTable(
-      std::move(table_),
+      table,
       std::move(spillPartitions),
       joinHasNullKeys_,
       std::move(tableSpillFunc));
+
   if (canSpill()) {
     stateCleared_ = true;
   }
@@ -839,7 +975,6 @@ void HashBuild::ensureTableFits(uint64_t numRows) {
 
 void HashBuild::postHashBuildProcess() {
   checkRunning();
-
   if (!canSpill()) {
     setState(State::kFinish);
     return;
@@ -878,6 +1013,7 @@ void HashBuild::setupSpillInput(HashJoinBridge::SpillInput spillInput) {
   setupTable();
   setupSpiller(spillInput.spillPartition.get());
   stateCleared_ = false;
+  numHashInputRows_ = 0;
 
   // Start to process spill input.
   processSpillInput();
@@ -891,7 +1027,7 @@ void HashBuild::processSpillInput() {
     if (!isRunning()) {
       return;
     }
-    if (operatorCtx_->driver()->shouldYield()) {
+    if (shouldYield()) {
       state_ = State::kYield;
       future_ = ContinueFuture{folly::Unit{}};
       return;
@@ -928,6 +1064,36 @@ void HashBuild::addRuntimeStats() {
         RuntimeCounter(timing.cpuNanos, RuntimeCounter::Unit::kNanos));
   }
 
+  for (const auto& timing :
+       table_->parallelJoinBuildStats().bloomFilterPartitionTimings) {
+    lockedStats->getOutputTiming.add(timing);
+    if (timing.wallNanos > 0) {
+      lockedStats->addRuntimeStat(
+          BaseHashTable::kParallelJoinBloomFilterPartitionWallNanos,
+          RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos));
+    }
+    if (timing.cpuNanos > 0) {
+      lockedStats->addRuntimeStat(
+          BaseHashTable::kParallelJoinBloomFilterPartitionCpuNanos,
+          RuntimeCounter(timing.cpuNanos, RuntimeCounter::Unit::kNanos));
+    }
+  }
+
+  for (const auto& timing :
+       table_->parallelJoinBuildStats().bloomFilterBuildTimings) {
+    lockedStats->getOutputTiming.add(timing);
+    if (timing.wallNanos > 0) {
+      lockedStats->addRuntimeStat(
+          BaseHashTable::kParallelJoinBloomFilterBuildWallNanos,
+          RuntimeCounter(timing.wallNanos, RuntimeCounter::Unit::kNanos));
+    }
+    if (timing.cpuNanos > 0) {
+      lockedStats->addRuntimeStat(
+          BaseHashTable::kParallelJoinBloomFilterBuildCpuNanos,
+          RuntimeCounter(timing.cpuNanos, RuntimeCounter::Unit::kNanos));
+    }
+  }
+
   for (auto i = 0; i < hashers.size(); i++) {
     hashers[i]->cardinality(0, asRange, asDistinct);
     if (asRange != VectorHasher::kRangeTooLarge) {
@@ -958,6 +1124,12 @@ void HashBuild::addRuntimeStats() {
         RuntimeCounter(
             spillConfig()->spillLevel(spiller_->hashBits().begin())));
   }
+
+  lockedStats->addRuntimeStat(
+      BaseHashTable::kVectorHasherMergeCpuNanos,
+      RuntimeCounter(
+          table_->vectorHasherMergeTiming().cpuNanos,
+          RuntimeCounter::Unit::kNanos));
 }
 
 BlockingReason HashBuild::isBlocked(ContinueFuture* future) {
@@ -975,6 +1147,11 @@ BlockingReason HashBuild::isBlocked(ContinueFuture* future) {
     case State::kFinish:
       break;
     case State::kWaitForBuild:
+      if (receivedCachedHashTable()) {
+        break;
+      }
+      // We were waiting for peer drivers to finish - fall through to
+      // kWaitForProbe which has the same logic.
       [[fallthrough]];
     case State::kWaitForProbe:
       if (!future_.valid()) {
@@ -1058,6 +1235,11 @@ bool HashBuild::canSpill() const {
   if (!Operator::canSpill()) {
     return false;
   }
+  // For Cached hash table, we don't support spill either by the
+  // task thats building or by the task that is re-using it
+  if (useHashTableCache()) {
+    return false;
+  }
   if (operatorCtx_->task()->hasMixedExecutionGroupJoin(joinNode_.get())) {
     return operatorCtx_->driverCtx()
                ->queryConfig()
@@ -1149,6 +1331,19 @@ void HashBuild::reclaim(
   }
 }
 
+memory::MemoryPool* HashBuild::tableMemoryPool() const {
+  if (useHashTableCache()) {
+    // Cached hash tables use a leaf pool under the query pool (from cache
+    // entry). This allows the table to outlive the task while still supporting
+    // allocations.
+    VELOX_CHECK_NOT_NULL(cacheEntry_);
+    VELOX_CHECK_NOT_NULL(cacheEntry_->tablePool);
+    return cacheEntry_->tablePool.get();
+  }
+  // Regular joins use operator pool
+  return pool();
+}
+
 bool HashBuild::nonReclaimableState() const {
   // Apart from being in the nonReclaimable section, it's also not reclaimable
   // if:
@@ -1239,4 +1434,21 @@ void HashBuildSpiller::extractSpill(
         rows.data(), rows.size(), false, false, result->childAt(types.size()));
   }
 }
+
+bool HashBuild::abandonHashBuildDedupEarly(int64_t numDistinct) const {
+  VELOX_CHECK(dropDuplicates_);
+  return numHashInputRows_ > abandonHashBuildDedupMinRows_ &&
+      100 * numDistinct / numHashInputRows_ >= abandonHashBuildDedupMinPct_;
+}
+
+void HashBuild::abandonHashBuildDedup() {
+  // The hash table is no longer directly constructed in addInput. The data
+  // that was previously inserted into the hash table is already in the
+  // RowContainer.
+  addRuntimeStat("abandonBuildNoDupHash", RuntimeCounter(1));
+  abandonHashBuildDedup_ = true;
+  table_->setAllowDuplicates(true);
+  lookup_.reset();
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/HashBuild.h b/velox/exec/HashBuild.h
index b2df3dc4a283..61315d15f9d2 100644
--- a/velox/exec/HashBuild.h
+++ b/velox/exec/HashBuild.h
@@ -17,12 +17,11 @@
 
 #include "velox/exec/HashJoinBridge.h"
 #include "velox/exec/HashTable.h"
+#include "velox/exec/HashTableCache.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/Spiller.h"
 #include "velox/exec/UnorderedStreamReader.h"
-#include "velox/exec/VectorHasher.h"
-#include "velox/expression/Expr.h"
 
 namespace facebook::velox::exec {
 class HashBuildSpiller;
@@ -109,6 +108,25 @@ class HashBuild final : public Operator {
   // Invoked to set up hash table to build.
   void setupTable();
 
+  // Sets up hash table caching if enabled. Returns true if the cached table
+  // is already available or if this operator should wait for another task
+  // to build it, in which case further initialization should be skipped.
+  // Returns false if this operator should proceed with building the table.
+  bool setupCachedHashTable();
+
+  // Checks if a cached hash table is available and uses it if so.
+  // Returns true if the cached table was used (build can be skipped).
+  // Returns false if we need to build the table (cache miss).
+  bool getHashTableFromCache();
+
+  // Called when waiting for a cached hash table from another task.
+  // Returns true if the cached table was received and noMoreInput was called.
+  bool receivedCachedHashTable();
+
+  // Stores the built hash table in the cache for reuse by other tasks.
+  // No-op if hash table caching is not enabled.
+  void maybeSetHashTableInCache(const std::shared_ptr<BaseHashTable>& table);
+
   // 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
@@ -206,6 +224,35 @@ class HashBuild final : public Operator {
   // not.
   bool nonReclaimableState() const;
 
+  // True if we have enough rows and not enough duplicate join keys, i.e. more
+  // than 'abandonHashBuildDedupMinRows_' rows and more than
+  // 'abandonHashBuildDedupMinPct_' % of rows are unique.
+  bool abandonHashBuildDedupEarly(int64_t numDistinct) const;
+
+  // Invoked to abandon build deduped hash table.
+  void abandonHashBuildDedup();
+
+  // Returns true if this operator is using a cached hash table.
+  // When enabled, the hash table is built once and cached for reuse
+  // by other tasks within the same query and stage.
+  bool useHashTableCache() const {
+    return !cacheKey_.empty();
+  }
+
+  // Returns the hash table cache key for this operator.
+  // Only valid if useHashTableCache() returns true.
+  const std::string& cacheKey() const {
+    VELOX_CHECK(
+        useHashTableCache(),
+        "cacheKey() called when table caching is not enabled");
+    return cacheKey_;
+  }
+
+  // Determines the memory pool to use for the hash table.
+  // For cached hash tables, uses query-level pool so the table can
+  // outlive the task. For regular joins, uses operator pool.
+  memory::MemoryPool* tableMemoryPool() const;
+
   const std::shared_ptr<const core::HashJoinNode> joinNode_;
 
   const core::JoinType joinType_;
@@ -219,12 +266,37 @@ class HashBuild final : public Operator {
   // not.
   const bool needProbedFlagSpill_;
 
+  // Indicates whether drop duplicate rows. Rows containing duplicate keys
+  // can be removed for left semi and anti join.
+  const bool dropDuplicates_;
+
+  // Maximum number of distinct values to keep when merging vector hashers
+  const size_t vectorHasherMaxNumDistinct_;
+
+  // Minimum number of rows to see before deciding to give up build no
+  // duplicates hash table.
+  const int32_t abandonHashBuildDedupMinRows_;
+
+  // Min unique rows pct for give up build deduped hash table. If more
+  // than this many rows are unique, build hash table in addInput phase is not
+  // worthwhile.
+  const int32_t abandonHashBuildDedupMinPct_;
+
   std::shared_ptr<HashJoinBridge> joinBridge_;
 
   tsan_atomic<bool> exceededMaxSpillLevelLimit_{false};
 
   State state_{State::kRunning};
 
+  // For hash table caching: the cache key passed in at construction.
+  // If set, this operator coordinates via HashTableCache.
+  // Key format: "queryId:planNodeId"
+  std::string cacheKey_;
+
+  // For hash table caching: cached entry containing the shared table and pool.
+  // Retrieved from HashTableCache.
+  std::shared_ptr<HashTableCacheEntry> cacheEntry_;
+
   // The row type used for hash table build and disk spilling.
   RowTypePtr tableType_;
 
@@ -244,6 +316,9 @@ class HashBuild final : public Operator {
   // Container for the rows being accumulated.
   std::unique_ptr<BaseHashTable> table_;
 
+  // Used for building hash table while adding input rows.
+  std::unique_ptr<HashLookup> lookup_;
+
   // Key channels in 'input_'
   std::vector<column_index_t> keyChannels_;
 
@@ -271,6 +346,10 @@ class HashBuild final : public Operator {
   // at least one entry with null join keys.
   bool joinHasNullKeys_{false};
 
+  // Whether to abandon building a HashTable without duplicates in HashBuild
+  // addInput phase for left semi/anti join.
+  bool abandonHashBuildDedup_{false};
+
   // The type used to spill hash table which might attach a boolean column to
   // record the probed flag if 'needProbedFlagSpill_' is true.
   RowTypePtr spillType_;
@@ -312,6 +391,10 @@ class HashBuild final : public Operator {
 
   // Maps key channel in 'input_' to channel in key.
   folly::F14FastMap<column_index_t, column_index_t> keyChannelMap_;
+
+  // Count the number of hash table input rows for building deduped
+  // hash table. It will not be updated after abandonBuildNoDupHash_ is true.
+  int64_t numHashInputRows_ = 0;
 };
 
 inline std::ostream& operator<<(std::ostream& os, HashBuild::State state) {
diff --git a/velox/exec/HashJoinBridge.cpp b/velox/exec/HashJoinBridge.cpp
index 7c359c924c3e..8fe29d0e61b2 100644
--- a/velox/exec/HashJoinBridge.cpp
+++ b/velox/exec/HashJoinBridge.cpp
@@ -15,7 +15,6 @@
  */
 
 #include "velox/exec/HashJoinBridge.h"
-#include "velox/common/memory/MemoryArbitrator.h"
 #include "velox/exec/HashBuild.h"
 
 namespace facebook::velox::exec {
@@ -43,13 +42,18 @@ RowTypePtr hashJoinTableType(
     types.emplace_back(inputType->childAt(channel));
   }
 
+  if (joinNode->canDropDuplicates()) {
+    // For left semi and anti join with no extra filter, hash table does not
+    // store dependent columns.
+    return ROW(std::move(names), std::move(types));
+  }
+
   for (auto i = 0; i < inputType->size(); ++i) {
     if (keyChannelSet.find(i) == keyChannelSet.end()) {
       names.emplace_back(inputType->nameOf(i));
       types.emplace_back(inputType->childAt(i));
     }
   }
-
   return ROW(std::move(names), std::move(types));
 }
 
@@ -212,7 +216,7 @@ SpillPartitionSet spillHashJoinTable(
 }
 
 void HashJoinBridge::setHashTable(
-    std::unique_ptr<BaseHashTable> table,
+    std::shared_ptr<BaseHashTable> table,
     SpillPartitionSet spillPartitionSet,
     bool hasNullKeys,
     HashJoinTableSpillFunc&& tableSpillFunc) {
@@ -453,11 +457,11 @@ uint64_t HashJoinMemoryReclaimer::reclaim(
 }
 
 bool isHashBuildMemoryPool(const memory::MemoryPool& pool) {
-  return folly::StringPiece(pool.name()).endsWith("HashBuild");
+  return pool.name().ends_with("HashBuild");
 }
 
 bool isHashProbeMemoryPool(const memory::MemoryPool& pool) {
-  return folly::StringPiece(pool.name()).endsWith("HashProbe");
+  return pool.name().ends_with("HashProbe");
 }
 
 bool needRightSideJoin(core::JoinType joinType) {
diff --git a/velox/exec/HashJoinBridge.h b/velox/exec/HashJoinBridge.h
index 879eab6801f8..a79e6b5c754f 100644
--- a/velox/exec/HashJoinBridge.h
+++ b/velox/exec/HashJoinBridge.h
@@ -53,8 +53,9 @@ class HashJoinBridge : public JoinBridge {
   /// Invoked by the build operator to set the built hash table.
   /// 'spillPartitionSet' contains the spilled partitions while building
   /// 'table' which only applies if the disk spilling is enabled.
+  /// Accepts both unique_ptr (regular joins) and shared_ptr (broadcast joins).
   void setHashTable(
-      std::unique_ptr<BaseHashTable> table,
+      std::shared_ptr<BaseHashTable> table,
       SpillPartitionSet spillPartitionSet,
       bool hasNullKeys,
       HashJoinTableSpillFunc&& tableSpillFunc);
@@ -143,6 +144,17 @@ class HashJoinBridge : public JoinBridge {
 
   bool testingHasMoreSpilledPartitions();
 
+  /// Return the next unclaimed row container id in the current hash table for
+  /// HashProbe drivers to output build-side rows.
+  int getAndIncrementUnclaimedRowContainerId() {
+    return unclaimedRowContainerId_.fetch_add(1);
+  }
+
+  /// Reset the next unclaimed row container id to 0.
+  void resetUnclaimedRowContainerId() {
+    unclaimedRowContainerId_.store(0);
+  }
+
  private:
   void appendSpilledHashTablePartitionsLocked(
       SpillPartitionSet&& spillPartitionSet);
@@ -183,6 +195,13 @@ class HashJoinBridge : public JoinBridge {
   // processing.
   bool probeStarted_;
 
+  // Keep track of the next row container id in a hash table that has not been
+  // processed by any hash probe driver. This is used when hash probe drivers
+  // output build-side rows. When drivers are allowed to output build-side rows
+  // in parallel, drivers call getAndIncrementClaimedRowContainerId() to ensure
+  // the row containers they process do not overlap with each other.
+  std::atomic<int> unclaimedRowContainerId_{0};
+
   friend test::HashJoinBridgeTestHelper;
 };
 
diff --git a/velox/exec/HashProbe.cpp b/velox/exec/HashProbe.cpp
index d6dd38926564..155b2946b0db 100644
--- a/velox/exec/HashProbe.cpp
+++ b/velox/exec/HashProbe.cpp
@@ -21,6 +21,7 @@
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/FieldReference.h"
+#include "velox/vector/LazyVector.h"
 
 using facebook::velox::common::testutil::TestValue;
 
@@ -130,7 +131,9 @@ HashProbe::HashProbe(
           operatorCtx_->driverCtx()->splitGroupId,
           planNodeId())),
       filterResult_(1),
-      outputTableRowsCapacity_(outputBatchSize_) {
+      outputTableRowsCapacity_(outputBatchSize_),
+      parallelJoinBuildRowsEnabled_(
+          driverCtx->queryConfig().parallelOutputJoinBuildRowsEnabled()) {
   VELOX_CHECK_NOT_NULL(joinBridge_);
 }
 
@@ -249,7 +252,7 @@ void HashProbe::maybeSetupInputSpiller(
       restoringPartitionId_,
       HashBitRange(bitOffset, bitOffset + spillConfig()->numPartitionBits),
       spillConfig(),
-      &spillStats_);
+      spillStats_.get());
 
   // Set the spill partitions to the corresponding ones at the build side. We
   // only spill the seen partitions from the build side. For the ones not seen
@@ -288,7 +291,7 @@ void HashProbe::maybeSetupSpillInputReader(
   VELOX_CHECK_EQ(partition->id(), restoredPartitionId.value());
   restoringPartitionId_ = restoredPartitionId;
   spillInputReader_ = partition->createUnorderedReader(
-      spillConfig_->readBufferSize, pool(), &spillStats_);
+      spillConfig_->readBufferSize, pool(), spillStats_.get());
   inputSpillPartitionSet_.erase(iter);
 }
 
@@ -373,6 +376,46 @@ void HashProbe::initializeResultIter() {
       rowSizeEstimation);
 }
 
+void HashProbe::pushdownDynamicFilters() {
+  auto* driver = operatorCtx_->driverCtx()->driver;
+  auto numFilters = driver->pushdownFilters(
+      this,
+      keyChannels_,
+      [&](column_index_t sourceChannel,
+          std::shared_ptr<common::Filter>& filter) {
+        if (dynamicFiltersProducedOnChannels_.contains(sourceChannel)) {
+          return true;
+        }
+        auto& hasher = *table_->hashers()[sourceChannel];
+        filter = hasher.getFilter(false);
+        if (!filter) {
+          filter = hasher.getBloomFilter();
+          if (!filter) {
+            return false;
+          }
+          auto* bloomFilter =
+              checkedPointerCast<const common::BigintValuesUsingBloomFilter>(
+                  filter.get());
+          addRuntimeStat(
+              "bloomFilterSize", RuntimeCounter(bloomFilter->blocksByteSize()));
+        }
+        dynamicFiltersProducedOnChannels_.insert(sourceChannel);
+        for (auto* peer : findPeerOperators()) {
+          peer->dynamicFiltersProducedOnChannels_.insert(sourceChannel);
+        }
+        return true;
+      });
+  // 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() &&
+      tableOutputProjections_.empty() && !filter_ && numFilters > 0 &&
+      !table_->hashers()[0]->getBloomFilter() && !isRightJoin(joinType_)) {
+    canReplaceWithDynamicFilter_ = true;
+  }
+}
+
 void HashProbe::asyncWaitForHashTable() {
   checkRunning();
   VELOX_CHECK_NULL(table_);
@@ -429,6 +472,9 @@ void HashProbe::asyncWaitForHashTable() {
        (isRightSemiProjectJoin(joinType_) && !nullAware_) ||
        isRightJoin(joinType_)) &&
       table_->hashMode() != BaseHashTable::HashMode::kHash && !isSpillInput() &&
+      operatorCtx_->driverCtx()
+          ->queryConfig()
+          .hashProbeDynamicFilterPushdownEnabled() &&
       !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
@@ -438,18 +484,7 @@ void HashProbe::asyncWaitForHashTable() {
     // 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();
-    const auto channels = operatorCtx_->driverCtx()->driver->canPushdownFilters(
-        this, keyChannels_);
-
-    for (auto i = 0; i < keyChannels_.size(); ++i) {
-      if (channels.find(keyChannels_[i]) != channels.end()) {
-        if (auto filter = buildHashers[i]->getFilter(/*nullAllowed=*/false)) {
-          dynamicFilters_.emplace(keyChannels_[i], std::move(filter));
-        }
-      }
-    }
-    hasGeneratedDynamicFilters_ = !dynamicFilters_.empty();
+    pushdownDynamicFilters();
   }
 }
 
@@ -473,7 +508,6 @@ void HashProbe::prepareForSpillRestore() {
   restoringPartitionId_.reset();
   spillInputPartitionIds_.clear();
   spillOutputReader_.reset();
-  lastProbeIterator_.reset();
 
   VELOX_CHECK(promises_.empty() || lastProber_);
   if (!lastProber_) {
@@ -614,7 +648,6 @@ BlockingReason HashProbe::isBlocked(ContinueFuture* future) {
       }
       break;
     case ProbeOperatorState::kWaitForPeers:
-      VELOX_CHECK(canSpill());
       if (!future_.valid()) {
         setRunning();
       }
@@ -633,20 +666,6 @@ BlockingReason HashProbe::isBlocked(ContinueFuture* future) {
   return fromStateToBlockingReason(state_);
 }
 
-void HashProbe::clearDynamicFilters() {
-  // 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() &&
-      tableOutputProjections_.empty() && !filter_ && !dynamicFilters_.empty() &&
-      !isRightJoin(joinType_)) {
-    canReplaceWithDynamicFilter_ = true;
-  }
-
-  Operator::clearDynamicFilters();
-}
-
 void HashProbe::decodeAndDetectNonNullKeys() {
   nonNullInputRows_.resize(input_->size());
   nonNullInputRows_.setAll();
@@ -857,28 +876,49 @@ void HashProbe::fillOutput(vector_size_t size) {
 }
 
 RowVectorPtr HashProbe::getBuildSideOutput() {
-  auto* outputTableRows =
+  if (buildSideOutputRowContainerId_ == -1) {
+    buildSideOutputRowContainerId_ =
+        joinBridge_->getAndIncrementUnclaimedRowContainerId();
+    lastProbeIterator_.reset();
+  }
+  if (buildSideOutputRowContainerId_ >= table_->numRowContainers()) {
+    return nullptr;
+  }
+
+  char** outputTableRows =
       initBuffer<char*>(outputTableRows_, outputTableRowsCapacity_, pool());
-  int32_t numOut;
-  if (isRightSemiFilterJoin(joinType_)) {
-    numOut = table_->listProbedRows(
-        &lastProbeIterator_,
-        outputTableRowsCapacity_,
-        RowContainer::kUnlimited,
-        outputTableRows);
-  } else if (isRightSemiProjectJoin(joinType_)) {
-    numOut = table_->listAllRows(
-        &lastProbeIterator_,
-        outputTableRowsCapacity_,
-        RowContainer::kUnlimited,
-        outputTableRows);
-  } else {
-    // Must be a right join or full join.
-    numOut = table_->listNotProbedRows(
-        &lastProbeIterator_,
-        outputTableRowsCapacity_,
-        RowContainer::kUnlimited,
-        outputTableRows);
+  int32_t numOut{0};
+  while (numOut == 0 &&
+         buildSideOutputRowContainerId_ < table_->numRowContainers()) {
+    if (isRightSemiFilterJoin(joinType_)) {
+      numOut = table_->listProbedRows(
+          lastProbeIterator_,
+          buildSideOutputRowContainerId_,
+          outputTableRowsCapacity_,
+          RowContainer::kUnlimited,
+          outputTableRows);
+    } else if (isRightSemiProjectJoin(joinType_)) {
+      numOut = table_->listAllRows(
+          lastProbeIterator_,
+          buildSideOutputRowContainerId_,
+          outputTableRowsCapacity_,
+          RowContainer::kUnlimited,
+          outputTableRows);
+
+    } else {
+      // Must be a right join or full join.
+      numOut = table_->listNotProbedRows(
+          lastProbeIterator_,
+          buildSideOutputRowContainerId_,
+          outputTableRowsCapacity_,
+          RowContainer::kUnlimited,
+          outputTableRows);
+    }
+    if (numOut == 0) {
+      buildSideOutputRowContainerId_ =
+          joinBridge_->getAndIncrementUnclaimedRowContainerId();
+      lastProbeIterator_.reset();
+    }
   }
   if (numOut == 0) {
     return nullptr;
@@ -902,9 +942,9 @@ RowVectorPtr HashProbe::getBuildSideOutput() {
 
   if (isRightSemiProjectJoin(joinType_)) {
     // Populate 'match' column.
-    if (noInput_) {
+    if (noInput_ && nullAware_) {
       // Probe side is empty. All rows should return 'match = false', even ones
-      // with a null join key.
+      // with a null join key. (This applies to null-aware joins only.)
       matchColumn() = createConstantFalse(numOut, pool());
     } else {
       table_->rows()->extractProbedFlags(
@@ -942,6 +982,12 @@ bool HashProbe::canSpill() const {
   if (!Operator::canSpill()) {
     return false;
   }
+  // Hash table caching is incompatible with spilling. When the table is
+  // cached and shared across tasks, clearing it after probe would corrupt
+  // the cache for subsequent tasks.
+  if (joinNode_->useHashTableCache()) {
+    return false;
+  }
   if (operatorCtx_->task()->hasMixedExecutionGroupJoin(joinNode_.get())) {
     return operatorCtx_->driverCtx()
                ->queryConfig()
@@ -972,16 +1018,11 @@ void HashProbe::checkStateTransition(ProbeOperatorState state) {
   VELOX_CHECK_NE(state_, state);
   switch (state) {
     case ProbeOperatorState::kRunning:
-      if (!canSpill()) {
-        VELOX_CHECK_EQ(state_, ProbeOperatorState::kWaitForBuild);
-      } else {
-        VELOX_CHECK(
-            state_ == ProbeOperatorState::kWaitForBuild ||
-            state_ == ProbeOperatorState::kWaitForPeers);
-      }
+      VELOX_CHECK(
+          state_ == ProbeOperatorState::kWaitForBuild ||
+          state_ == ProbeOperatorState::kWaitForPeers);
       break;
     case ProbeOperatorState::kWaitForPeers:
-      VELOX_CHECK(canSpill());
       [[fallthrough]];
     case ProbeOperatorState::kWaitForBuild:
       [[fallthrough]];
@@ -1027,7 +1068,7 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
       return nullptr;
     }
 
-    if (needLastProbe() && lastProber_) {
+    if (needLastProbe() && (outputBuildRowsInParallel_ || lastProber_)) {
       auto output = getBuildSideOutput();
       if (output != nullptr) {
         return output;
@@ -1170,6 +1211,13 @@ RowVectorPtr HashProbe::getOutputInternal(bool toSpillOutput) {
     numOut = evalFilter(numOut);
 
     if (numOut == 0) {
+      // The hash probe might get stuck in the output loop if the filter is
+      // highly selective. This does not apply if the call is made during
+      // spilling, because we cannot break out and resume when the operator is
+      // undergoing spilling.
+      if (!toSpillOutput && shouldYield()) {
+        return nullptr;
+      }
       continue;
     }
 
@@ -1694,21 +1742,34 @@ void HashProbe::noMoreInputInternal() {
         spillInputPartitionIds_.size(),
         inputSpiller_->state().spilledPartitionIdSet().size());
     inputSpiller_->finishSpill(inputSpillPartitionSet_);
-    VELOX_CHECK_EQ(spillStats_.rlock()->spillSortTimeNanos, 0);
+    VELOX_CHECK_EQ(spillStats_->rlock()->spillSortTimeNanos, 0);
   }
 
   const bool hasSpillEnabled = canSpill();
   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.
+
+  // Reset flags about outputing build-side rows in parallel.
+  buildSideOutputRowContainerId_ = -1;
+  outputBuildRowsInParallel_ =
+      parallelJoinBuildRowsEnabled_ && needLastProbe() && !hasSpillEnabled;
+
+  // NOTE: if 'hasSpillEnabled' is false and 'outputBuildRowsInParallel_' is
+  // false too, then a hash probe operator doesn't need to wait for all the
+  // other peers to finish probe processing. If 'hasSpillEnabled' is true, 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. If 'outputBuildRowsInParallel_', it needs to wait to all drivers
+  // start outputing build-side rows in parallel only after all drivers finish
+  // probe processing.
+  const bool shouldBlock = hasSpillEnabled || outputBuildRowsInParallel_;
   if (!operatorCtx_->task()->allPeersFinished(
           planNodeId(),
           operatorCtx_->driver(),
-          hasSpillEnabled ? &future_ : nullptr,
-          hasSpillEnabled ? promises_ : promises,
+          shouldBlock ? &future_ : nullptr,
+          shouldBlock ? promises_ : promises,
           peers)) {
-    if (hasSpillEnabled) {
+    if (shouldBlock) {
       VELOX_CHECK(future_.valid());
       setState(ProbeOperatorState::kWaitForPeers);
       VELOX_DCHECK(promises_.empty());
@@ -1719,13 +1780,14 @@ void HashProbe::noMoreInputInternal() {
   }
 
   VELOX_CHECK(promises.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;
+  joinBridge_->resetUnclaimedRowContainerId();
+  // If 'outputBuildRowsInParallel_' is true, wake up all peers to start
+  // outputing build-side rows in parallel. Otherwise, only let the last prober
+  // proceed.
+  if (outputBuildRowsInParallel_) {
+    wakeupPeerOperators();
+  }
 }
 
 bool HashProbe::isFinished() {
@@ -1769,8 +1831,9 @@ void HashProbe::ensureOutputFits() {
   }
 
   // We only need to reserve memory for output if need.
-  if (input_ == nullptr &&
-      (hasMoreInput() || !(needLastProbe() && lastProber_))) {
+  bool outputBuildSideRows =
+      outputBuildRowsInParallel_ || (needLastProbe() && lastProber_);
+  if (input_ == nullptr && (hasMoreInput() || !outputBuildSideRows)) {
     return;
   }
 
@@ -1888,7 +1951,7 @@ void HashProbe::reclaim(
         tableSpillHashBits_,
         joinNode_,
         spillConfig(),
-        &spillStats_);
+        spillStats_.get());
     VELOX_CHECK(!spillPartitionSet.empty());
   }
   const auto spillPartitionIdSet = toSpillPartitionIdSet(spillPartitionSet);
@@ -1970,7 +2033,11 @@ void HashProbe::spillOutput() {
   }
   // We spill all the outputs produced from 'input_' into a single partition.
   auto outputSpiller = std::make_unique<NoRowContainerSpiller>(
-      outputType_, std::nullopt, HashBitRange{}, spillConfig(), &spillStats_);
+      outputType_,
+      std::nullopt,
+      HashBitRange{},
+      spillConfig(),
+      spillStats_.get());
   outputSpiller->setPartitionsSpilled({SpillPartitionId(0)});
 
   RowVectorPtr output{nullptr};
@@ -2012,7 +2079,7 @@ void HashProbe::maybeSetupSpillOutputReader() {
 
   spillOutputReader_ =
       spillOutputPartitionSet_.begin()->second->createUnorderedReader(
-          spillConfig_->readBufferSize, pool(), &spillStats_);
+          spillConfig_->readBufferSize, pool(), spillStats_.get());
   spillOutputPartitionSet_.clear();
 }
 
@@ -2038,7 +2105,7 @@ void HashProbe::checkMaxSpillLevel(
           << "Exceeded spill level limit: " << config->maxSpillLevel
           << ", and disable spilling for memory pool: " << pool()->name();
       exceededMaxSpillLevelLimit_ = true;
-      ++spillStats_.wlock()->spillMaxLevelExceededCount;
+      ++spillStats_->wlock()->spillMaxLevelExceededCount;
       return;
     }
   }
@@ -2060,7 +2127,7 @@ void HashProbe::close() {
   spillOutputReader_.reset();
   clearBuffers();
 
-  // Fullfill any pending promises
+  // Fulfill any pending promises
   if (lastProber_) {
     wakeupPeerOperators();
   }
diff --git a/velox/exec/HashProbe.h b/velox/exec/HashProbe.h
index 4eeaf0f3a25a..a45ab7d8b555 100644
--- a/velox/exec/HashProbe.h
+++ b/velox/exec/HashProbe.h
@@ -16,7 +16,6 @@
 #pragma once
 
 #include "velox/exec/HashBuild.h"
-#include "velox/exec/HashPartitionFunction.h"
 #include "velox/exec/HashTable.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/ProbeOperatorState.h"
@@ -64,8 +63,6 @@ class HashProbe : public Operator {
 
   void close() override;
 
-  void clearDynamicFilters() override;
-
   bool canReclaim() const override;
 
   const std::vector<IdentityProjection>& tableOutputProjections() const {
@@ -130,6 +127,8 @@ class HashProbe : public Operator {
   // Applies only for mixed grouped execution mode.
   bool allProbeGroupFinished() const;
 
+  void pushdownDynamicFilters();
+
   // Invoked to wait for the hash table to be built by the hash build operators
   // asynchronously. The function also sets up the internal state for
   // potentially spilling input or reading spilled input or recursively spill
@@ -413,11 +412,7 @@ 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};
+  folly::F14FastSet<column_index_t> dynamicFiltersProducedOnChannels_;
 
   // True if the join can become a no-op starting with the next batch of input.
   bool canReplaceWithDynamicFilter_{false};
@@ -635,7 +630,7 @@ class HashProbe : public Operator {
     std::optional<bool> currentRowPassed;
   };
 
-  BaseHashTable::RowsIterator lastProbeIterator_;
+  RowContainerIterator 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.
@@ -733,6 +728,23 @@ class HashProbe : public Operator {
 
   // Input vector used for listing rows with null keys.
   VectorPtr nullKeyProbeInput_;
+
+  // Flag to indicate whether the query config allows hash probe drivers to
+  // output build-side rows in parallel.
+  const bool parallelJoinBuildRowsEnabled_;
+
+  // Flag to indicate whether this hash probe operator is outputing build-side
+  // rows in parallel with the peer operators for the current hash table.
+  // Outputing build-side rows in parallel is not enabled in either of the
+  // following cases:
+  // 1. parallelJoinBuildRowsEnabled_ is false.
+  // 2. This join type does not need build-side rows.
+  // 3. There are more spilled data to restore.
+  bool outputBuildRowsInParallel_{false};
+
+  // The index of the row container in the current hash table that this hash
+  // probe oprator is processing to output build-side rows.
+  int buildSideOutputRowContainerId_{-1};
 };
 
 inline std::ostream& operator<<(std::ostream& os, ProbeOperatorState state) {
diff --git a/velox/exec/HashTable.cpp b/velox/exec/HashTable.cpp
index 3717d6631c08..6dd4f967346f 100644
--- a/velox/exec/HashTable.cpp
+++ b/velox/exec/HashTable.cpp
@@ -28,6 +28,7 @@
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
+
 // static
 std::string BaseHashTable::modeString(HashMode mode) {
   switch (mode) {
@@ -52,16 +53,20 @@ HashTable<ignoreNullKeys>::HashTable(
     bool isJoinBuild,
     bool hasProbedFlag,
     uint32_t minTableSizeForParallelJoinBuild,
-    memory::MemoryPool* pool)
+    memory::MemoryPool* pool,
+    uint64_t bloomFilterMaxSize)
     : BaseHashTable(std::move(hashers)),
       pool_(pool),
       minTableSizeForParallelJoinBuild_(minTableSizeForParallelJoinBuild),
+      bloomFilterMaxSize_(bloomFilterMaxSize),
       isJoinBuild_(isJoinBuild),
+      allowDuplicates_(allowDuplicates),
       buildPartitionBounds_(raw_vector<PartitionBoundIndexType>(pool)) {
+  VELOX_CHECK(bloomFilterMaxSize_ == 0 || (isJoinBuild && ignoreNullKeys));
   std::vector<TypePtr> keys;
   for (auto& hasher : hashers_) {
     keys.push_back(hasher->type());
-    if (!VectorHasher::typeKindSupportsValueIds(hasher->typeKind())) {
+    if (!hasher->typeSupportsValueIds()) {
       hashMode_ = HashMode::kHash;
     }
   }
@@ -75,6 +80,7 @@ HashTable<ignoreNullKeys>::HashTable(
       isJoinBuild,
       hasProbedFlag,
       hashMode_ != HashMode::kHash,
+      /*useListRowIndex=*/false,
       pool);
   nextOffset_ = rows_->nextOffset();
 }
@@ -332,6 +338,8 @@ char* HashTable<ignoreNullKeys>::insertEntry(
     HashLookup& lookup,
     uint64_t index,
     vector_size_t row) {
+  TestValue::adjust(
+      "facebook::velox::exec::HashTable::insertEntry", rows_->pool());
   char* group = rows_->newRow();
   lookup.hits[row] = group; // NOLINT
   storeKeys(lookup, row);
@@ -358,8 +366,13 @@ bool HashTable<ignoreNullKeys>::compareKeys(
   int32_t i = 0;
   do {
     auto& hasher = lookup.hashers[i];
-    if (!rows_->equals<!ignoreNullKeys>(
-            group, rows_->columnAt(i), hasher->decodedVector(), row)) {
+    if (rows_->compare<!ignoreNullKeys>(
+            group,
+            rows_->columnAt(i),
+            hasher->decodedVector(),
+            row,
+            CompareFlags::equality(
+                CompareFlags::NullHandlingMode::kNullAsValue)) != 0) {
       return false;
     }
   } while (++i < numKeys);
@@ -417,9 +430,12 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::fullProbe(
 }
 
 namespace {
+
 // Group prefetch size for join build & probe.
 constexpr int32_t kPrefetchSize = 64;
 
+constexpr int32_t kHashBatchSize = 1024;
+
 // 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.
@@ -834,12 +850,87 @@ bool HashTable<ignoreNullKeys>::hashRows(
 }
 
 namespace {
+
+template <typename T>
+void partitionBloomFilterRowsImpl(
+    int32_t offset,
+    const common::BigintValuesUsingBloomFilter& filter,
+    const RowContainer& rowContainer,
+    uint8_t partitionMask,
+    RowPartitions& rowPartitions) {
+  char* rows[kHashBatchSize];
+  uint8_t partitions[kHashBatchSize];
+  RowContainerIterator iter;
+  while (auto numRows = rowContainer.listRows(
+             &iter, kHashBatchSize, RowContainer::kUnlimited, rows)) {
+    for (int i = 0; i < numRows; ++i) {
+      auto value = folly::loadUnaligned<T>(rows[i] + offset);
+      partitions[i] = filter.blockIndex(value) & partitionMask;
+    }
+    rowPartitions.appendPartitions(
+        folly::Range<const uint8_t*>(partitions, numRows));
+  }
+}
+
+void partitionBloomFilterRows(
+    const VectorHasher& hasher,
+    int32_t offset,
+    const common::BigintValuesUsingBloomFilter& filter,
+    const RowContainer& rowContainer,
+    uint8_t numPartitions,
+    RowPartitions& rowPartitions) {
+  VELOX_DCHECK(hasher.supportsBloomFilter());
+  VELOX_DCHECK(bits::isPowerOfTwo(numPartitions));
+  switch (hasher.typeKind()) {
+    case TypeKind::INTEGER:
+      partitionBloomFilterRowsImpl<int32_t>(
+          offset, filter, rowContainer, numPartitions - 1, rowPartitions);
+      break;
+    case TypeKind::BIGINT:
+      partitionBloomFilterRowsImpl<int64_t>(
+          offset, filter, rowContainer, numPartitions - 1, rowPartitions);
+      break;
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
+template <typename T>
+void buildBloomFilterImpl(
+    int32_t offset,
+    char** rows,
+    int numRows,
+    common::BigintValuesUsingBloomFilter& filter) {
+  for (int i = 0; i < numRows; ++i) {
+    filter.insert(folly::loadUnaligned<T>(rows[i] + offset));
+  }
+}
+
+void buildBloomFilter(
+    const VectorHasher& hasher,
+    int32_t offset,
+    char** rows,
+    int numRows,
+    common::BigintValuesUsingBloomFilter& filter) {
+  VELOX_DCHECK(hasher.supportsBloomFilter());
+  switch (hasher.typeKind()) {
+    case TypeKind::INTEGER:
+      buildBloomFilterImpl<int32_t>(offset, rows, numRows, filter);
+      break;
+    case TypeKind::BIGINT:
+      buildBloomFilterImpl<int64_t>(offset, rows, numRows, filter);
+      break;
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
 template <typename Source>
 void syncWorkItems(
     std::vector<std::shared_ptr<Source>>& items,
-    std::exception_ptr& error,
     std::vector<CpuWallTiming>& timings,
-    bool log = false) {
+    bool throwError) {
+  std::exception_ptr error;
   // All items must be synced also in case of error because the items
   // hold references to the table and rows which could be destructed
   // if unwinding the stack did not pause to sync.
@@ -850,15 +941,42 @@ void syncWorkItems(
         timings.push_back(item->prepareTiming());
       }
     } catch (const std::exception& e) {
-      if (log) {
+      if (!throwError) {
         LOG(ERROR) << "Error in async hash build: " << e.what();
+      } else {
+        error = std::current_exception();
       }
-      error = std::current_exception();
     }
   }
+  if (error) {
+    std::rethrow_exception(error);
+  }
 }
+
 } // namespace
 
+template <>
+bool HashTable<true>::bloomFilterSupported() const {
+  if (!(bloomFilterMaxSize_ > 0 &&
+        common::BigintValuesUsingBloomFilter::numBlocks(numDistinct_) *
+                sizeof(SplitBlockBloomFilter::Block) <=
+            bloomFilterMaxSize_)) {
+    return false;
+  }
+  for (auto& hasher : hashers_) {
+    if (hasher->supportsBloomFilter()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template <>
+bool HashTable<false>::bloomFilterSupported() const {
+  VELOX_CHECK_EQ(bloomFilterMaxSize_, 0);
+  return false;
+}
+
 template <bool ignoreNullKeys>
 bool HashTable<ignoreNullKeys>::canApplyParallelJoinBuild() const {
   if (!isJoinBuild_ || buildExecutor_ == nullptr) {
@@ -908,23 +1026,56 @@ void HashTable<ignoreNullKeys>::parallelJoinBuild() {
   buildPartitionBounds_.back() = sizeMask_ + 1;
   std::vector<std::shared_ptr<AsyncSource<bool>>> partitionSteps;
   std::vector<std::shared_ptr<AsyncSource<bool>>> buildSteps;
+  std::vector<std::shared_ptr<AsyncSource<bool>>> bloomFilterPartitionSteps;
+  std::vector<std::shared_ptr<AsyncSource<bool>>> bloomFilterBuildSteps;
   // rowPartitions are used in the async threads, so declare them before the
   // sync guard.
   std::vector<std::unique_ptr<RowPartitions>> rowPartitions;
   auto sync = folly::makeGuard([&]() {
     // This is executed on returning path, possibly in unwinding, so must not
     // throw.
-    std::exception_ptr error;
     syncWorkItems(
-        partitionSteps, error, parallelJoinBuildStats_.partitionTimings, true);
+        partitionSteps, parallelJoinBuildStats_.partitionTimings, false);
+    syncWorkItems(buildSteps, parallelJoinBuildStats_.buildTimings, false);
     syncWorkItems(
-        buildSteps, error, parallelJoinBuildStats_.buildTimings, true);
+        bloomFilterPartitionSteps,
+        parallelJoinBuildStats_.bloomFilterPartitionTimings,
+        false);
+    syncWorkItems(
+        bloomFilterBuildSteps,
+        parallelJoinBuildStats_.bloomFilterBuildTimings,
+        false);
+    // Release the partition bounds to reduce memory usage.
+    buildPartitionBounds_ = raw_vector<PartitionBoundIndexType>(pool_);
   });
 
+  // Passing driver context directly to avoid cross thread access to thread
+  // local driver thread context.
+  const DriverCtx* driverCtx{nullptr};
+  if (const auto* driverThreadCtx = driverThreadContext()) {
+    driverCtx = driverThreadCtx->driverCtx();
+  }
+
   const auto getTable = [this](size_t i) INLINE_LAMBDA {
     return i == 0 ? this : otherTables_[i - 1].get();
   };
 
+  const auto runStep = [&](auto& steps, auto&& work, bool runInCurrentThread) {
+    auto step = std::make_shared<AsyncSource<bool>>([work = std::move(work)] {
+      work();
+      return std::make_unique<bool>(true);
+    });
+    steps.push_back(step);
+    if (runInCurrentThread) {
+      step->prepare();
+    } else {
+      buildExecutor_->add([driverCtx, step]() {
+        ScopedDriverThreadContext scopedDriverThreadContext(driverCtx);
+        step->prepare();
+      });
+    }
+  };
+
   // This step can involve large memory allocations, so there is a chance of
   // OOMs here. Do it before any async work is started to reduce the chances of
   // concurrency issues.
@@ -934,63 +1085,102 @@ void HashTable<ignoreNullKeys>::parallelJoinBuild() {
     rowPartitions.push_back(table->rows()->createRowPartitions(*rows_->pool()));
   }
 
-  // Passing driver context directly to avoid cross thread access to thread
-  // local driver thread context.
-  const DriverCtx* driverCtx{nullptr};
-  if (const auto* driverThreadCtx = driverThreadContext()) {
-    driverCtx = driverThreadCtx->driverCtx();
-  }
-
   // The parallel table partitioning step.
   for (auto i = 0; i < numPartitions; ++i) {
     auto* table = getTable(i);
-    partitionSteps.push_back(std::make_shared<AsyncSource<bool>>(
-        [this, table, rawRowPartitions = rowPartitions[i].get()]() {
+    bool last = i == numPartitions - 1;
+    runStep(
+        partitionSteps,
+        [this, table, rawRowPartitions = rowPartitions[i].get()] {
           partitionRows(*table, *rawRowPartitions);
-          return std::make_unique<bool>(true);
-        }));
-    VELOX_CHECK(!partitionSteps.empty());
-    buildExecutor_->add([driverCtx, step = partitionSteps.back()]() {
-      ScopedDriverThreadContext scopedDriverThreadContext(driverCtx);
-      step->prepare();
-    });
-  }
-
-  std::exception_ptr error;
-  syncWorkItems(
-      partitionSteps, error, parallelJoinBuildStats_.partitionTimings);
-  if (error != nullptr) {
-    std::rethrow_exception(error);
+        },
+        // run last partition on current thread to avoid wasting current thread
+        // on just waiting
+        last);
   }
+  syncWorkItems(partitionSteps, parallelJoinBuildStats_.partitionTimings, true);
 
   // The parallel table building step.
   std::vector<std::vector<char*>> overflowPerPartition(numPartitions);
   for (auto i = 0; i < numPartitions; ++i) {
-    buildSteps.push_back(std::make_shared<AsyncSource<bool>>(
-        [this, i, &overflowPerPartition, &rowPartitions]() {
+    bool last = i == numPartitions - 1;
+    runStep(
+        buildSteps,
+        [this, i, &overflowPerPartition, &rowPartitions] {
           buildJoinPartition(i, rowPartitions, overflowPerPartition[i]);
-          return std::make_unique<bool>(true);
-        }));
-    VELOX_CHECK(!buildSteps.empty());
-    buildExecutor_->add([driverCtx, step = buildSteps.back()]() {
-      ScopedDriverThreadContext scopedDriverThreadContext(driverCtx);
-      step->prepare();
-    });
-  }
-  syncWorkItems(buildSteps, error, parallelJoinBuildStats_.buildTimings);
-
-  if (error != nullptr) {
-    std::rethrow_exception(error);
+        },
+        // run last partition on current thread to avoid wasting current thread
+        // on just waiting
+        last);
+  }
+  syncWorkItems(buildSteps, parallelJoinBuildStats_.buildTimings, true);
+
+  if (bloomFilterSupported()) {
+    const auto numBloomFilterPartitions = bits::isPowerOfTwo(numPartitions)
+        ? numPartitions
+        : bits::nextPowerOfTwo(numPartitions) / 2;
+    VELOX_CHECK_GT(numBloomFilterPartitions, 0);
+    for (int i = 0; i < hashers_.size(); ++i) {
+      if (!hashers_[i]->supportsBloomFilter()) {
+        continue;
+      }
+      auto filter = std::make_shared<common::BigintValuesUsingBloomFilter>(
+          numDistinct_, false);
+      hashers_[i]->setBloomFilter(filter);
+      for (auto j = 0; j < numPartitions; ++j) {
+        bool last = j == numPartitions - 1;
+        auto* rows = getTable(j)->rows();
+        rowPartitions[j]->reset();
+        runStep(
+            bloomFilterPartitionSteps,
+            [hasher = hashers_[i].get(),
+             offset = rows->columnAt(i).offset(),
+             filter,
+             rows,
+             numBloomFilterPartitions,
+             rowPartitions = rowPartitions[j].get()] {
+              partitionBloomFilterRows(
+                  *hasher,
+                  offset,
+                  *filter,
+                  *rows,
+                  numBloomFilterPartitions,
+                  *rowPartitions);
+            },
+            // run last partition on current thread to avoid wasting current
+            // thread on just waiting
+            last);
+      }
+      syncWorkItems(
+          bloomFilterPartitionSteps,
+          parallelJoinBuildStats_.bloomFilterPartitionTimings,
+          true);
+      for (auto j = 0; j < numBloomFilterPartitions; ++j) {
+        bool last = j == numBloomFilterPartitions - 1;
+        runStep(
+            bloomFilterBuildSteps,
+            [this, i, j, &rowPartitions] {
+              buildBloomFilterPartition(i, j, rowPartitions);
+            },
+            // run last partition on current thread to avoid wasting current
+            // thread on just waiting
+            last);
+      }
+      syncWorkItems(
+          bloomFilterBuildSteps,
+          parallelJoinBuildStats_.bloomFilterBuildTimings,
+          true);
+    }
   }
 
-  raw_vector<uint64_t> hashes;
+  raw_vector<uint64_t> hashes(pool_);
   for (auto i = 0; i < numPartitions; ++i) {
     auto& overflows = overflowPerPartition[i];
     hashes.resize(overflows.size());
-    hashRows(
+    VELOX_CHECK(hashRows(
         folly::Range<char**>(overflows.data(), overflows.size()),
         false,
-        hashes);
+        hashes));
     auto table = i == 0 ? this : otherTables_[i - 1].get();
     insertForJoin(overflows.data(), hashes.data(), overflows.size(), nullptr);
     VELOX_CHECK_EQ(table->rows()->numRows(), table->numParallelBuildRows_);
@@ -1023,14 +1213,14 @@ template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::partitionRows(
     HashTable<ignoreNullKeys>& subtable,
     RowPartitions& rowPartitions) {
-  constexpr int32_t kBatch = 1024;
-  raw_vector<char*> rows(kBatch);
-  raw_vector<uint64_t> hashes(kBatch);
-  raw_vector<uint8_t> partitions(kBatch);
+  raw_vector<char*> rows(kHashBatchSize, pool_);
+  raw_vector<uint64_t> hashes(kHashBatchSize, pool_);
+  raw_vector<uint8_t> partitions(kHashBatchSize, pool_);
   RowContainerIterator iter;
   while (auto numRows = subtable.rows_->listRows(
-             &iter, kBatch, RowContainer::kUnlimited, rows.data())) {
-    hashRows(folly::Range<char**>(rows.data(), numRows), true, hashes);
+             &iter, kHashBatchSize, RowContainer::kUnlimited, rows.data())) {
+    VELOX_CHECK(
+        hashRows(folly::Range<char**>(rows.data(), numRows), true, hashes));
     VELOX_DCHECK_EQ(
         0,
         buildPartitionBounds_.capacity() %
@@ -1051,9 +1241,8 @@ void HashTable<ignoreNullKeys>::buildJoinPartition(
     uint8_t partition,
     const std::vector<std::unique_ptr<RowPartitions>>& rowPartitions,
     std::vector<char*>& overflow) {
-  constexpr int32_t kBatch = 1024;
-  raw_vector<char*> rows(kBatch);
-  raw_vector<uint64_t> hashes(kBatch);
+  raw_vector<char*> rows(kHashBatchSize, pool_);
+  raw_vector<uint64_t> hashes(kHashBatchSize, pool_);
   const int32_t numPartitions = 1 + otherTables_.size();
   TableInsertPartitionInfo partitionInfo{
       buildPartitionBounds_[partition],
@@ -1062,15 +1251,44 @@ void HashTable<ignoreNullKeys>::buildJoinPartition(
   for (auto i = 0; i < numPartitions; ++i) {
     auto* table = i == 0 ? this : otherTables_[i - 1].get();
     RowContainerIterator iter;
-    while (const auto numRows = table->rows_->listPartitionRows(
-               iter, partition, kBatch, *rowPartitions[i], rows.data())) {
-      hashRows(folly::Range(rows.data(), numRows), false, hashes);
+    while (
+        const auto numRows = table->rows_->listPartitionRows(
+            iter, partition, kHashBatchSize, *rowPartitions[i], rows.data())) {
+      VELOX_CHECK(hashRows(folly::Range(rows.data(), numRows), false, hashes));
       insertForJoin(rows.data(), hashes.data(), numRows, &partitionInfo);
       table->numParallelBuildRows_ += numRows;
     }
   }
 }
 
+template <>
+void HashTable<true>::buildBloomFilterPartition(
+    column_index_t columnIndex,
+    uint8_t partition,
+    const std::vector<std::unique_ptr<RowPartitions>>& rowPartitions) {
+  char* rows[kHashBatchSize];
+  for (auto i = 0; i < 1 + otherTables_.size(); ++i) {
+    auto* table = i == 0 ? this : otherTables_[i - 1].get();
+    auto rowColumn = table->rows_->columnAt(columnIndex);
+    auto* filter = checkedPointerCast<common::BigintValuesUsingBloomFilter>(
+        hashers_[columnIndex]->getBloomFilter().get());
+    RowContainerIterator iter;
+    while (auto numRows = table->rows_->listPartitionRows(
+               iter, partition, kHashBatchSize, *rowPartitions[i], rows)) {
+      buildBloomFilter(
+          *hashers_[columnIndex], rowColumn.offset(), rows, numRows, *filter);
+    }
+  }
+}
+
+template <>
+void HashTable<false>::buildBloomFilterPartition(
+    column_index_t /*columnIndex*/,
+    uint8_t /*partition*/,
+    const std::vector<std::unique_ptr<RowPartitions>>& /*rowPartitions*/) {
+  VELOX_UNREACHABLE();
+}
+
 template <bool ignoreNullKeys>
 bool HashTable<ignoreNullKeys>::insertBatch(
     char** groups,
@@ -1091,7 +1309,7 @@ bool HashTable<ignoreNullKeys>::insertBatch(
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::insertForGroupBy(
     char** groups,
-    uint64_t* hashes,
+    const uint64_t* hashes,
     int32_t numGroups) {
   if (hashMode_ == HashMode::kArray) {
     for (auto i = 0; i < numGroups; ++i) {
@@ -1225,7 +1443,7 @@ template <bool ignoreNullKeys>
 template <bool isNormailizedKeyMode>
 FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::insertForJoinWithPrefetch(
     char** groups,
-    uint64_t* hashes,
+    const uint64_t* hashes,
     int32_t numGroups,
     TableInsertPartitionInfo* partitionInfo) {
   auto i = 0;
@@ -1261,7 +1479,7 @@ FOLLY_ALWAYS_INLINE void HashTable<ignoreNullKeys>::insertForJoinWithPrefetch(
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::insertForJoin(
     char** groups,
-    uint64_t* hashes,
+    const uint64_t* hashes,
     int32_t numGroups,
     TableInsertPartitionInfo* partitionInfo) {
   // The insertable rows are in the table, all get put in the hash table or
@@ -1286,30 +1504,55 @@ void HashTable<ignoreNullKeys>::rehash(
     bool initNormalizedKeys,
     int8_t spillInputStartPartitionBit) {
   ++numRehashes_;
-  constexpr int32_t kHashBatchSize = 1024;
   if (canApplyParallelJoinBuild()) {
     parallelJoinBuild();
     return;
   }
-  raw_vector<uint64_t> hashes;
+  raw_vector<uint64_t> hashes(pool_);
   hashes.resize(kHashBatchSize);
   char* groups[kHashBatchSize];
+  const bool shouldBuildBloomFilter = bloomFilterSupported();
+  std::vector<common::BigintValuesUsingBloomFilter*> bloomFilters;
+  if (shouldBuildBloomFilter) {
+    bloomFilters.resize(hashers_.size());
+    for (int i = 0; i < hashers_.size(); ++i) {
+      if (!hashers_[i]->supportsBloomFilter()) {
+        continue;
+      }
+      auto filter = std::make_shared<common::BigintValuesUsingBloomFilter>(
+          numDistinct_, false);
+      bloomFilters[i] = filter.get();
+      hashers_[i]->setBloomFilter(filter);
+    }
+  }
   // A join build can have multiple payload tables. Loop over 'this'
   // and the possible other tables and put all the data in the table
   // of 'this'.
   for (int32_t i = 0; i <= otherTables_.size(); ++i) {
     RowContainerIterator iterator;
     int32_t numGroups;
+    auto* table = i == 0 ? this : otherTables_[i - 1].get();
     do {
-      numGroups = (i == 0 ? this : otherTables_[i - 1].get())
-                      ->rows()
-                      ->listRows(&iterator, kHashBatchSize, groups);
+      numGroups = table->rows()->listRows(&iterator, kHashBatchSize, groups);
       if (!insertBatch(
               groups, numGroups, hashes, initNormalizedKeys || i != 0)) {
         VELOX_CHECK_NE(hashMode_, HashMode::kHash);
         setHashMode(HashMode::kHash, 0, spillInputStartPartitionBit);
         return;
       }
+      if (shouldBuildBloomFilter) {
+        for (int j = 0; j < hashers_.size(); ++j) {
+          if (!hashers_[j]->supportsBloomFilter()) {
+            continue;
+          }
+          buildBloomFilter(
+              *hashers_[j],
+              table->rows()->columnAt(j).offset(),
+              groups,
+              numGroups,
+              *bloomFilters[j]);
+        }
+      }
     } while (numGroups > 0);
   }
 }
@@ -1348,7 +1591,6 @@ void HashTable<ignoreNullKeys>::setHashMode(
 
 template <bool ignoreNullKeys>
 bool HashTable<ignoreNullKeys>::analyze() {
-  constexpr int32_t kHashBatchSize = 1024;
   // @lint-ignore CLANGTIDY
   char* groups[kHashBatchSize];
   RowContainerIterator iterator;
@@ -1485,7 +1727,9 @@ void HashTable<ignoreNullKeys>::decideHashMode(
     return;
   }
   disableRangeArrayHash_ |= disableRangeArrayHash;
-  if (numDistinct_ && !isJoinBuild_) {
+  if (numDistinct_ && (!isJoinBuild_ || joinBuildNoDuplicates())) {
+    // If the join type is left semi and anti, allowDuplicates_ will be false,
+    // and join build is building hash table while adding input rows.
     if (!analyze()) {
       setHashMode(HashMode::kHash, numNew, spillInputStartPartitionBit);
       return;
@@ -1572,7 +1816,10 @@ void HashTable<ignoreNullKeys>::checkHashBitsOverlap(
     int8_t spillInputStartPartitionBit) {
   if (spillInputStartPartitionBit != kNoSpillInputStartPartitionBit &&
       hashMode() != HashMode::kArray) {
-    VELOX_CHECK_LT(sizeBits_ - 1, spillInputStartPartitionBit);
+    VELOX_CHECK_LT(
+        sizeBits_ - 1,
+        spillInputStartPartitionBit,
+        "The size bits of the hash table must be lower than the spilling partition bits to avoid overlap");
   }
 }
 
@@ -1704,12 +1951,26 @@ template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::prepareJoinTable(
     std::vector<std::unique_ptr<BaseHashTable>> tables,
     int8_t spillInputStartPartitionBit,
+    size_t vectorHasherMaxNumDistinct,
+    bool dropDuplicates,
     folly::Executor* executor) {
   buildExecutor_ = executor;
+  if (dropDuplicates) {
+    if (table_ != nullptr) {
+      // Reset table_ and capacity_ to trigger rehash.
+      rows_->pool()->freeContiguous(tableAllocation_);
+      table_ = nullptr;
+      capacity_ = 0;
+    }
+    // Call analyze to insert all unique values in row container to the
+    // table hashers' uniqueValues_;
+    analyze();
+  }
   otherTables_.reserve(tables.size());
   for (auto& table : tables) {
-    otherTables_.emplace_back(std::unique_ptr<HashTable<ignoreNullKeys>>(
-        dynamic_cast<HashTable<ignoreNullKeys>*>(table.release())));
+    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
@@ -1727,6 +1988,7 @@ void HashTable<ignoreNullKeys>::prepareJoinTable(
 
   bool useValueIds = mayUseValueIds(*this);
   if (useValueIds) {
+    CpuWallTimer timer(vectorHasherMergeTiming_);
     for (auto& other : otherTables_) {
       if (!mayUseValueIds(*other)) {
         useValueIds = false;
@@ -1735,8 +1997,13 @@ void HashTable<ignoreNullKeys>::prepareJoinTable(
     }
     if (useValueIds) {
       for (auto& other : otherTables_) {
+        if (dropDuplicates) {
+          // Before merging with the current hashers, all values in the row
+          // containers of other table need to be inserted into uniqueValues_.
+          other->analyze();
+        }
         for (auto i = 0; i < hashers_.size(); ++i) {
-          hashers_[i]->merge(*other->hashers_[i]);
+          hashers_[i]->merge(*other->hashers_[i], vectorHasherMaxNumDistinct);
           if (!hashers_[i]->mayUseValueIds()) {
             useValueIds = false;
             break;
@@ -1797,7 +2064,7 @@ int32_t HashTable<ignoreNullKeys>::listJoinResults(
   uint64_t totalBytes{0};
   while (iter.lastRowIndex < iter.rows->size()) {
     if (!iter.nextHit) {
-      auto row = (*iter.rows)[iter.lastRowIndex];
+      const auto row = (*iter.rows)[iter.lastRowIndex];
       iter.nextHit = (*iter.hits)[row]; // NOLINT
       if (!iter.nextHit) {
         ++iter.lastRowIndex;
@@ -1962,6 +2229,58 @@ int32_t HashTable<ignoreNullKeys>::listAllRows(
   return listRows<RowContainer::ProbeType::kAll>(iter, maxRows, maxBytes, rows);
 }
 
+template <bool ignoreNullKeys>
+template <RowContainer::ProbeType probeType>
+int32_t HashTable<ignoreNullKeys>::listRows(
+    RowContainerIterator& rowContainerIterator,
+    int rowContainerId,
+    int32_t maxRows,
+    uint64_t maxBytes,
+    char** rows) {
+  const auto& rowContainer = rowContainerId == 0
+      ? rows_.get()
+      : otherTables_[rowContainerId - 1]->rows();
+  const auto numRows = rowContainer->template listRows<probeType>(
+      &rowContainerIterator, maxRows, maxBytes, rows);
+  if (numRows > 0) {
+    return numRows;
+  }
+  return 0;
+}
+
+template <bool ignoreNullKeys>
+int32_t HashTable<ignoreNullKeys>::listNotProbedRows(
+    RowContainerIterator& rowContainerIterator,
+    int rowContainerId,
+    int32_t maxRows,
+    uint64_t maxBytes,
+    char** rows) {
+  return listRows<RowContainer::ProbeType::kNotProbed>(
+      rowContainerIterator, rowContainerId, maxRows, maxBytes, rows);
+}
+
+template <bool ignoreNullKeys>
+int32_t HashTable<ignoreNullKeys>::listProbedRows(
+    RowContainerIterator& rowContainerIterator,
+    int rowContainerId,
+    int32_t maxRows,
+    uint64_t maxBytes,
+    char** rows) {
+  return listRows<RowContainer::ProbeType::kProbed>(
+      rowContainerIterator, rowContainerId, maxRows, maxBytes, rows);
+}
+
+template <bool ignoreNullKeys>
+int32_t HashTable<ignoreNullKeys>::listAllRows(
+    RowContainerIterator& rowContainerIterator,
+    int rowContainerId,
+    int32_t maxRows,
+    uint64_t maxBytes,
+    char** rows) {
+  return listRows<RowContainer::ProbeType::kAll>(
+      rowContainerIterator, rowContainerId, maxRows, maxBytes, rows);
+}
+
 template <>
 int32_t HashTable<false>::listNullKeyRows(
     NullKeyRowsIterator* iter,
@@ -2007,7 +2326,7 @@ int32_t HashTable<true>::listNullKeyRows(
 template <bool ignoreNullKeys>
 void HashTable<ignoreNullKeys>::erase(folly::Range<char**> rows) {
   auto numRows = rows.size();
-  raw_vector<uint64_t> hashes;
+  raw_vector<uint64_t> hashes(pool_);
   hashes.resize(numRows);
 
   for (int32_t i = 0; i < hashers_.size(); ++i) {
@@ -2063,7 +2382,7 @@ void HashTable<ignoreNullKeys>::eraseWithHashes(
   }
   numDistinct_ -= numRows;
   if (!otherTables_.empty()) {
-    raw_vector<char*> containerRows;
+    raw_vector<char*> containerRows(pool_);
     containerRows.resize(rows.size());
     for (auto& other : otherTables_) {
       const auto numContainerRows =
diff --git a/velox/exec/HashTable.h b/velox/exec/HashTable.h
index 870ab7f01db0..8bcf3df5bd42 100644
--- a/velox/exec/HashTable.h
+++ b/velox/exec/HashTable.h
@@ -115,6 +115,8 @@ struct HashTableStats {
 struct ParallelJoinBuildStats {
   std::vector<CpuWallTiming> partitionTimings;
   std::vector<CpuWallTiming> buildTimings;
+  std::vector<CpuWallTiming> bloomFilterPartitionTimings;
+  std::vector<CpuWallTiming> bloomFilterBuildTimings;
 };
 
 class BaseHashTable {
@@ -127,6 +129,9 @@ class BaseHashTable {
 
   using MaskType = uint16_t;
 
+  /// The load factor of the hash table.
+  static constexpr double kHashTableLoadFactor = 0.7;
+
   /// 2M entries, i.e. 16MB is the largest array based hash table.
   static constexpr uint64_t kArrayHashMaxSize = 2L << 20;
 
@@ -152,6 +157,18 @@ class BaseHashTable {
       "hashtable.parallelJoinBuildWallNanos"};
   static inline const std::string kParallelJoinBuildCpuNanos{
       "hashtable.parallelJoinBuildCpuNanos"};
+  static inline const std::string kParallelJoinBloomFilterPartitionWallNanos{
+      "hashtable.parallelJoinBloomFilterPartitionWallNanos"};
+  static inline const std::string kParallelJoinBloomFilterPartitionCpuNanos{
+      "hashtable.parallelJoinBloomFilterPartitionCpuNanos"};
+  static inline const std::string kParallelJoinBloomFilterBuildWallNanos{
+      "hashtable.parallelJoinBloomFilterBuildWallNanos"};
+  static inline const std::string kParallelJoinBloomFilterBuildCpuNanos{
+      "hashtable.parallelJoinBloomFilterBuildCpuNanos"};
+  static inline const std::string kVectorHasherMergeCpuNanos{
+      "hashtable.vectorHasherMergeCpuNanos"};
+  static inline const std::string kHashTableCacheHit{"hashtable.cacheHit"};
+  static inline const std::string kHashTableCacheMiss{"hashtable.cacheMiss"};
 
   /// Returns the string of the given 'mode'.
   static std::string modeString(HashMode mode);
@@ -282,6 +299,15 @@ class BaseHashTable {
       uint64_t maxBytes,
       char** rows) = 0;
 
+  /// Same as above, but only return rows from the row container of
+  /// 'rowContainerId'.
+  virtual int32_t listNotProbedRows(
+      RowContainerIterator& rowContainerIterator,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) = 0;
+
   /// Returns rows with 'probed' flag set. Used by the right semi join.
   virtual int32_t listProbedRows(
       RowsIterator* iter,
@@ -289,6 +315,15 @@ class BaseHashTable {
       uint64_t maxBytes,
       char** rows) = 0;
 
+  /// Same as above, but only return rows from the row container of
+  /// 'rowContainerId'.
+  virtual int32_t listProbedRows(
+      RowContainerIterator& rowContainerIterator,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) = 0;
+
   /// Returns all rows. Used by the right semi join project.
   virtual int32_t listAllRows(
       RowsIterator* iter,
@@ -296,6 +331,15 @@ class BaseHashTable {
       uint64_t maxBytes,
       char** rows) = 0;
 
+  /// Same as above, but only return rows from the row container of
+  /// 'rowContainerId'.
+  virtual int32_t listAllRows(
+      RowContainerIterator& rowContainerIterator,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) = 0;
+
   /// Returns all rows with null keys.  Used by null-aware joins (e.g. anti or
   /// left semi project).
   virtual int32_t listNullKeyRows(
@@ -307,8 +351,22 @@ class BaseHashTable {
   virtual void prepareJoinTable(
       std::vector<std::unique_ptr<BaseHashTable>> tables,
       int8_t spillInputStartPartitionBit,
+      size_t vectorHasherMaxNumDistinct,
+      bool dropDuplicates = false,
       folly::Executor* executor = nullptr) = 0;
 
+  /// The hash table used for join build in left semi and anti join may not
+  /// retain duplicate join keys when allowDuplicates_ is false. This is
+  /// achieved by constructing the hash table in the addInput phase to eliminate
+  /// duplicate join keys. When the percentage of duplicate data is small, it
+  /// will adaptively adjust to not build the hash table in the addInput phase.
+  /// Instead, it operates like other join types by reading all the data before
+  /// building the hash table. This function is used to change the behavior of
+  /// building hash table, if allowDuplicates is true, the join hash table will
+  /// not be built during the addInput phase, and the input data will also not
+  /// be deduplicated, but it will not impact the containing row container.
+  virtual void setAllowDuplicates(bool allowDuplicates) = 0;
+
   /// Returns the memory footprint in bytes for any data structures
   /// owned by 'this'.
   virtual int64_t allocatedBytes() const = 0;
@@ -325,6 +383,9 @@ class BaseHashTable {
   /// side. This is used for sizing the internal hash table.
   virtual uint64_t numDistinct() const = 0;
 
+  /// Returns the number of row containers in this hash table.
+  virtual int32_t numRowContainers() const = 0;
+
   /// Return a number of current stats that can help with debugging and
   /// profiling.
   virtual HashTableStats stats() const = 0;
@@ -411,8 +472,7 @@ class BaseHashTable {
   __attribute__((__no_sanitize__("thread")))
 #endif
 #endif
-  static TagVector
-  loadTags(uint8_t* tags, int64_t tagIndex) {
+  static TagVector loadTags(uint8_t* tags, int64_t tagIndex) {
     // Cannot use xsimd::batch::unaligned here because we need to skip TSAN.
     auto src = tags + tagIndex;
 #if XSIMD_WITH_SSE2
@@ -426,6 +486,10 @@ class BaseHashTable {
     return parallelJoinBuildStats_;
   }
 
+  const CpuWallTiming& vectorHasherMergeTiming() const {
+    return vectorHasherMergeTiming_;
+  }
+
   /// 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.
@@ -449,6 +513,7 @@ class BaseHashTable {
   std::unique_ptr<RowContainer> rows_;
 
   ParallelJoinBuildStats parallelJoinBuildStats_;
+  CpuWallTiming vectorHasherMergeTiming_;
 };
 
 FOLLY_ALWAYS_INLINE std::ostream& operator<<(
@@ -482,7 +547,8 @@ class HashTable : public BaseHashTable {
       bool isJoinBuild,
       bool hasProbedFlag,
       uint32_t minTableSizeForParallelJoinBuild,
-      memory::MemoryPool* pool);
+      memory::MemoryPool* pool,
+      uint64_t bloomFilterMaxSize = 0);
 
   ~HashTable() override = default;
 
@@ -507,7 +573,8 @@ class HashTable : public BaseHashTable {
       bool allowDuplicates,
       bool hasProbedFlag,
       uint32_t minTableSizeForParallelJoinBuild,
-      memory::MemoryPool* pool) {
+      memory::MemoryPool* pool,
+      uint64_t bloomFilterMaxSize = 0) {
     return std::make_unique<HashTable>(
         std::move(hashers),
         std::vector<Accumulator>{},
@@ -516,7 +583,8 @@ class HashTable : public BaseHashTable {
         true, // isJoinBuild
         hasProbedFlag,
         minTableSizeForParallelJoinBuild,
-        pool);
+        pool,
+        bloomFilterMaxSize);
   }
 
   void groupProbe(HashLookup& lookup, int8_t spillInputStartPartitionBit)
@@ -549,6 +617,27 @@ class HashTable : public BaseHashTable {
       uint64_t maxBytes,
       char** rows) override;
 
+  int32_t listNotProbedRows(
+      RowContainerIterator& rowContainerIterator,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) override;
+
+  int32_t listProbedRows(
+      RowContainerIterator& rowContainerIterator,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) override;
+
+  int32_t listAllRows(
+      RowContainerIterator& rowContainerIterator,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows) override;
+
   int32_t listNullKeyRows(
       NullKeyRowsIterator* iter,
       int32_t maxRows,
@@ -575,6 +664,10 @@ class HashTable : public BaseHashTable {
     return numDistinct_;
   }
 
+  int32_t numRowContainers() const override {
+    return otherTables_.size() + 1;
+  }
+
   HashTableStats stats() const override {
     return HashTableStats{
         capacity_, numRehashes_, numDistinct_, numTombstones_};
@@ -584,6 +677,10 @@ class HashTable : public BaseHashTable {
     return hasDuplicates_.check();
   }
 
+  void setAllowDuplicates(const bool allowDuplicates) override {
+    allowDuplicates_ = allowDuplicates;
+  }
+
   HashMode hashMode() const override {
     return hashMode_;
   }
@@ -608,6 +705,8 @@ class HashTable : public BaseHashTable {
   void prepareJoinTable(
       std::vector<std::unique_ptr<BaseHashTable>> tables,
       int8_t spillInputStartPartitionBit,
+      size_t vectorHasherMaxNumDistinct,
+      bool dropDuplicates = false,
       folly::Executor* executor = nullptr) override;
 
   void prepareForJoinProbe(
@@ -742,8 +841,7 @@ class HashTable : public BaseHashTable {
 
   // Returns the number of entries after which the table gets rehashed.
   static uint64_t rehashSize(int64_t size) {
-    // This implements the F14 load factor: Resize if less than 1/8 unoccupied.
-    return size - (size / 8);
+    return size * kHashTableLoadFactor;
   }
 
   // Returns the number of entries with 'numNew' and existing 'numDistincts'
@@ -764,6 +862,14 @@ class HashTable : public BaseHashTable {
   int32_t
   listRows(RowsIterator* iter, int32_t maxRows, uint64_t maxBytes, char** rows);
 
+  template <RowContainer::ProbeType probeType>
+  int32_t listRows(
+      RowContainerIterator& rowContainerIterator,
+      int rowContainerId,
+      int32_t maxRows,
+      uint64_t maxBytes,
+      char** rows);
+
   char*& nextRow(char* row) {
     return *reinterpret_cast<char**>(row + nextOffset_);
   }
@@ -844,7 +950,7 @@ class HashTable : public BaseHashTable {
   // to the end of 'overflows' in 'partitionInfo'.
   void insertForJoin(
       char** groups,
-      uint64_t* hashes,
+      const uint64_t* hashes,
       int32_t numGroups,
       TableInsertPartitionInfo* partitionInfo);
 
@@ -852,7 +958,8 @@ class HashTable : public BaseHashTable {
   // contents in a RowContainer owned by 'this'. 'hashes' are the hash
   // numbers or array indices (if kArray mode) for each
   // group. 'groups' is expected to have no duplicate keys.
-  void insertForGroupBy(char** groups, uint64_t* hashes, int32_t numGroups);
+  void
+  insertForGroupBy(char** groups, const uint64_t* hashes, int32_t numGroups);
 
   // Checks if we can apply parallel table build optimization for hash join.
   // The function returns true if all of the following conditions:
@@ -888,6 +995,20 @@ class HashTable : public BaseHashTable {
       HashTable<ignoreNullKeys>& subtable,
       RowPartitions& rowPartitions);
 
+  // Whether we should build Bloom filters.  If Bloom filter pushdown is
+  // enabled, and the size fits, this returns true if any of the key columns
+  // support it.  The actual build should build a Bloom filter for each key
+  // column that supports it, and skip the ones that do not.
+  bool bloomFilterSupported() const;
+
+  // Populate the Bloom filter for the key column with `columnIndex` and rows
+  // with certain `partition`.  The partitions information is stored in
+  // `rowPartitions`.
+  void buildBloomFilterPartition(
+      column_index_t columnIndex,
+      uint8_t partition,
+      const std::vector<std::unique_ptr<RowPartitions>>& rowPartitions);
+
   // Calculates hashes for 'rows' and returns them in 'hashes'. If
   // 'initNormalizedKeys' is true, the normalized keys are stored below each row
   // in the container. If 'initNormalizedKeys' is false and the table is in
@@ -948,7 +1069,7 @@ class HashTable : public BaseHashTable {
   template <bool isNormailizedKeyMode>
   void insertForJoinWithPrefetch(
       char** groups,
-      uint64_t* hashes,
+      const uint64_t* hashes,
       int32_t numGroups,
       TableInsertPartitionInfo* partitionInfo);
 
@@ -965,7 +1086,13 @@ class HashTable : public BaseHashTable {
   // or distinct mode VectorHashers in a group by hash table. 0 for
   // join build sides.
   int32_t reservePct() const {
-    return isJoinBuild_ ? 0 : 50;
+    return (isJoinBuild_ && allowDuplicates_) ? 0 : 50;
+  }
+
+  // Used to indicate whether it is a HashTable that does not contain duplicate
+  // join keys.
+  bool joinBuildNoDuplicates() const {
+    return isJoinBuild_ && !allowDuplicates_;
   }
 
   // Returns the byte offset of the bucket for 'hash' starting from 'table_'.
@@ -1033,8 +1160,11 @@ class HashTable : public BaseHashTable {
   // The min table size in row to trigger parallel join table build.
   const uint32_t minTableSizeForParallelJoinBuild_;
 
+  const uint64_t bloomFilterMaxSize_;
+
   int8_t sizeBits_;
   bool isJoinBuild_ = false;
+  bool allowDuplicates_ = true;
 
   // Set at join build time if the table has duplicates, meaning that
   // the join can be cardinality increasing. Atomic for tsan because
diff --git a/velox/exec/HashTableCache.cpp b/velox/exec/HashTableCache.cpp
new file mode 100644
index 000000000000..1bb0048bf38e
--- /dev/null
+++ b/velox/exec/HashTableCache.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/HashTableCache.h"
+
+#include <fmt/format.h>
+
+#include "velox/core/QueryCtx.h"
+
+namespace facebook::velox::exec {
+
+HashTableCache* HashTableCache::instance() {
+  static HashTableCache instance;
+  return &instance;
+}
+
+std::shared_ptr<HashTableCacheEntry> HashTableCache::get(
+    const std::string& key,
+    const std::string& taskId,
+    core::QueryCtx* queryCtx,
+    ContinueFuture* future) {
+  VELOX_CHECK_NOT_NULL(future, "future parameter must not be null");
+  VELOX_CHECK_NOT_NULL(queryCtx, "queryCtx parameter must not be null");
+
+  std::lock_guard<std::mutex> guard(lock_);
+
+  auto it = tables_.find(key);
+  if (it == tables_.end()) {
+    // No entry exists - create a placeholder for this task to build the table.
+    auto* queryPool = queryCtx->pool();
+    auto entry = std::make_shared<HashTableCacheEntry>(
+        key,
+        taskId,
+        queryPool->addLeafChild(fmt::format("cached_table_{}", key)));
+    tables_.insert({key, entry});
+
+    // Register callback to clean up this cache entry when QueryCtx is
+    // destroyed. This ensures tablePool memory is freed before the query
+    // pool is destroyed.
+    queryCtx->addReleaseCallback(
+        [cacheKey = key]() { HashTableCache::instance()->drop(cacheKey); });
+
+    // Return entry with pool, table will be filled later.
+    return entry;
+  }
+
+  auto& entry = it->second;
+
+  // Check if build is complete
+  if (entry->buildComplete) {
+    return entry;
+  }
+
+  // If this is the builder task, don't wait - all drivers of the builder task
+  // should proceed to build (they coordinate via JoinBridge, not here).
+  if (entry->builderTaskId == taskId) {
+    return entry;
+  }
+
+  auto [promise, _future] =
+      makeVeloxContinuePromiseContract(fmt::format("HashTableCache::{}", key));
+  entry->buildPromises.push_back(std::move(promise));
+  *future = std::move(_future);
+
+  return entry;
+}
+
+void HashTableCache::put(
+    const std::string& key,
+    std::shared_ptr<BaseHashTable> table,
+    bool hasNullKeys) {
+  std::vector<ContinuePromise> promises;
+
+  {
+    std::lock_guard<std::mutex> guard(lock_);
+
+    auto it = tables_.find(key);
+    VELOX_CHECK(
+        it != tables_.end(),
+        "Cache entry for key '{}' must be created by get() before put()",
+        key);
+
+    auto& entry = it->second;
+    VELOX_CHECK(!entry->buildComplete);
+    VELOX_CHECK_NULL(entry->table);
+    // Update the entry with the built table
+    entry->table = std::move(table);
+    entry->hasNullKeys = hasNullKeys;
+    entry->buildComplete = true;
+
+    // Collect promises to notify waiters
+    promises = std::move(entry->buildPromises);
+  }
+
+  // Notify all waiting tasks outside the lock
+  for (auto& promise : promises) {
+    promise.setValue();
+  }
+}
+
+void HashTableCache::drop(const std::string& key) {
+  std::shared_ptr<HashTableCacheEntry> entry;
+  {
+    std::lock_guard<std::mutex> guard(lock_);
+    auto it = tables_.find(key);
+    if (it != tables_.end()) {
+      entry = std::move(it->second);
+      tables_.erase(it);
+    }
+  }
+
+  // Clear the table outside the lock to free memory before the entry
+  // is destroyed. This ensures the tablePool's memory is released
+  // before any parent pools are destroyed.
+  if (entry) {
+    entry->table.reset();
+  }
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/HashTableCache.h b/velox/exec/HashTableCache.h
new file mode 100644
index 000000000000..e1d9717e89e6
--- /dev/null
+++ b/velox/exec/HashTableCache.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 <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "velox/exec/HashTable.h"
+
+namespace facebook::velox::core {
+class QueryCtx;
+}
+
+namespace facebook::velox::exec {
+
+/// Cached hash table entry with build coordination metadata.
+struct HashTableCacheEntry {
+  HashTableCacheEntry(
+      std::string _cacheKey,
+      std::string _builderTaskId,
+      std::shared_ptr<memory::MemoryPool> _tablePool)
+      : cacheKey(std::move(_cacheKey)),
+        builderTaskId(std::move(_builderTaskId)),
+        tablePool(std::move(_tablePool)) {}
+
+  const std::string cacheKey;
+  const std::string builderTaskId;
+  const std::shared_ptr<memory::MemoryPool> tablePool;
+  std::shared_ptr<BaseHashTable> table;
+  bool hasNullKeys{false};
+  tsan_atomic<bool> buildComplete{false};
+  std::vector<ContinuePromise> buildPromises;
+};
+
+/// Global cache for hash tables shared across tasks within the same query.
+/// First task builds the table, subsequent tasks wait and reuse it.
+class HashTableCache {
+ public:
+  static HashTableCache* instance();
+
+  /// Gets or creates a cache entry. First caller becomes the builder.
+  /// Subsequent callers from different tasks get a future to wait on.
+  /// When a new entry is created, a release callback is registered on queryCtx
+  /// to clean up the entry when the query completes.
+  /// @param future Must be non-null; set if caller needs to wait.
+  std::shared_ptr<HashTableCacheEntry> get(
+      const std::string& key,
+      const std::string& taskId,
+      core::QueryCtx* queryCtx,
+      ContinueFuture* future);
+
+  /// Stores a built hash table and notifies waiting tasks.
+  void put(
+      const std::string& key,
+      std::shared_ptr<BaseHashTable> table,
+      bool hasNullKeys);
+
+  /// Removes a cache entry.
+  void drop(const std::string& key);
+
+ private:
+  HashTableCache() = default;
+
+  std::mutex lock_;
+  std::unordered_map<std::string, std::shared_ptr<HashTableCacheEntry>> tables_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/HilbertIndex.h b/velox/exec/HilbertIndex.h
new file mode 100644
index 000000000000..9d8fd096f953
--- /dev/null
+++ b/velox/exec/HilbertIndex.h
@@ -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.
+ */
+// Based off of https://threadlocalmutex.com/?p=126
+
+#pragma once
+
+#include <cstdint>
+#include <limits>
+
+#include "velox/common/base/Exceptions.h"
+
+namespace facebook::velox::exec {
+
+class HilbertIndex {
+ public:
+  /// Construct a Hilber index. If a min value is greater than the max value,
+  /// this will panic.
+  HilbertIndex(float minX, float minY, float maxX, float maxY)
+      : minX_(minX), minY_(minY), maxX_(maxX), maxY_(maxY) {
+    VELOX_CHECK(minX_ <= maxX_);
+    VELOX_CHECK(minY_ <= maxY_);
+
+    float deltaX = maxX_ - minX_;
+    // Subnormals cause numerical instability.
+    // NOLINTNEXTLINE(facebook-hte-FloatingPointMin)
+    if (deltaX < std::numeric_limits<float>::min()) {
+      xScale_ = 0;
+    } else {
+      xScale_ = kHilbertMax / deltaX;
+    }
+
+    float deltaY = maxY_ - minY_;
+    // Subnormals cause numerical instability.
+    // NOLINTNEXTLINE(facebook-hte-FloatingPointMin)
+    if (deltaY < std::numeric_limits<float>::min()) {
+      yScale_ = 0;
+    } else {
+      yScale_ = kHilbertMax / deltaY;
+    }
+  }
+
+  uint32_t inline indexOf(float x, float y) const {
+    if (!(x >= minX_ && x <= maxX_ && y >= minY_ && y <= maxY_)) {
+      // Put things outside the bounds at the end of the Hilbert curve.
+      // Negation handles NaNs
+      return std::numeric_limits<uint32_t>::max();
+    }
+
+    float maxFloat = static_cast<float>(std::numeric_limits<uint32_t>::max());
+
+    uint32_t xInt = static_cast<uint32_t>(
+        std::clamp(xScale_ * (x - minX_), 0.0f, maxFloat));
+    uint32_t yInt = static_cast<uint32_t>(
+        std::clamp(yScale_ * (y - minY_), 0.0f, maxFloat));
+    return discreteIndexOf(xInt, yInt);
+  }
+
+ private:
+  static inline uint32_t interleave(uint32_t x) {
+    x = (x | (x << 8)) & 0x00FF00FF;
+    x = (x | (x << 4)) & 0x0F0F0F0F;
+    x = (x | (x << 2)) & 0x33333333;
+    x = (x | (x << 1)) & 0x55555555;
+    return x;
+  }
+
+  static inline uint32_t discreteIndexOf(uint32_t x, uint32_t y) {
+    uint32_t A, B, C, D;
+
+    // Initial prefix scan round, prime with x and y
+    {
+      uint32_t a = x ^ y;
+      uint32_t b = 0xFFFF ^ a;
+      uint32_t c = 0xFFFF ^ (x | y);
+      uint32_t d = x & (y ^ 0xFFFF);
+
+      A = a | (b >> 1);
+      B = (a >> 1) ^ a;
+
+      C = ((c >> 1) ^ (b & (d >> 1))) ^ c;
+      D = ((a & (c >> 1)) ^ (d >> 1)) ^ d;
+    }
+
+    {
+      uint32_t a = A;
+      uint32_t b = B;
+      uint32_t c = C;
+      uint32_t d = D;
+
+      A = ((a & (a >> 2)) ^ (b & (b >> 2)));
+      B = ((a & (b >> 2)) ^ (b & ((a ^ b) >> 2)));
+
+      C ^= ((a & (c >> 2)) ^ (b & (d >> 2)));
+      D ^= ((b & (c >> 2)) ^ ((a ^ b) & (d >> 2)));
+    }
+
+    {
+      uint32_t a = A;
+      uint32_t b = B;
+      uint32_t c = C;
+      uint32_t d = D;
+
+      A = ((a & (a >> 4)) ^ (b & (b >> 4)));
+      B = ((a & (b >> 4)) ^ (b & ((a ^ b) >> 4)));
+
+      C ^= ((a & (c >> 4)) ^ (b & (d >> 4)));
+      D ^= ((b & (c >> 4)) ^ ((a ^ b) & (d >> 4)));
+    }
+
+    // Final round and projection
+    {
+      uint32_t a = A;
+      uint32_t b = B;
+      uint32_t c = C;
+      uint32_t d = D;
+
+      C ^= ((a & (c >> 8)) ^ (b & (d >> 8)));
+      D ^= ((b & (c >> 8)) ^ ((a ^ b) & (d >> 8)));
+    }
+
+    // Undo transformation prefix scan
+    uint32_t a = C ^ (C >> 1);
+    uint32_t b = D ^ (D >> 1);
+
+    // Recover index bits
+    uint32_t i0 = x ^ y;
+    uint32_t i1 = b | (0xFFFF ^ (i0 | a));
+
+    return (interleave(i1) << 1) | interleave(i0);
+  }
+
+  static const int8_t kHilbertBits = 16;
+  static constexpr float kHilbertMax = (1 << kHilbertBits) - 1;
+
+  const float minX_;
+  const float minY_;
+  const float maxX_;
+  const float maxY_;
+  float xScale_;
+  float yScale_;
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/IndexLookupJoin.cpp b/velox/exec/IndexLookupJoin.cpp
index 1fe92ce84416..bfcf0868b80b 100644
--- a/velox/exec/IndexLookupJoin.cpp
+++ b/velox/exec/IndexLookupJoin.cpp
@@ -17,6 +17,7 @@
 
 #include "velox/buffer/Buffer.h"
 #include "velox/connectors/Connector.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/FieldReference.h"
@@ -85,8 +86,9 @@ bool addBetweenConditionBound(
         lookupInputChannels,
         lookupInputNameSet);
   } else {
-    VELOX_USER_CHECK(core::TypedExprs::asConstant(typeExpr)->type()->equivalent(
-        *indexKeyType));
+    VELOX_USER_CHECK(
+        core::TypedExprs::asConstant(typeExpr)->type()->equivalent(
+            *indexKeyType));
   }
   return isConstant;
 }
@@ -138,15 +140,20 @@ IndexLookupJoin::IndexLookupJoin(
           operatorId,
           joinNode->id(),
           "IndexLookupJoin"),
+      splitOutput_{driverCtx->queryConfig().indexLookupJoinSplitOutput()},
       // TODO: support to update output batch size with output size stats during
       // the lookup processing.
-      outputBatchSize_{outputBatchRows()},
+      outputBatchSize_{
+          driverCtx->queryConfig().indexLookupJoinSplitOutput()
+              ? outputBatchRows()
+              : std::numeric_limits<vector_size_t>::max()},
       joinType_{joinNode->joinType()},
+      hasMarker_(joinNode->hasMarker()),
       numKeys_{joinNode->leftKeys().size()},
       probeType_{joinNode->sources()[0]->outputType()},
       lookupType_{joinNode->lookupSource()->outputType()},
       lookupTableHandle_{joinNode->lookupSource()->tableHandle()},
-      lookupConditions_{joinNode->joinConditions()},
+      joinConditions_{joinNode->joinConditions()},
       lookupColumnHandles_(joinNode->lookupSource()->assignments()),
       connectorQueryCtx_{operatorCtx_->createConnectorQueryCtx(
           lookupTableHandle_->connectorId(),
@@ -179,11 +186,12 @@ void IndexLookupJoin::initialize() {
   initLookupInput();
   initLookupOutput();
   initOutputProjections();
+  initFilter();
 
   indexSource_ = connector_->createIndexSource(
       lookupInputType_,
       numKeys_,
-      lookupConditions_,
+      joinConditions_,
       lookupOutputType_,
       lookupTableHandle_,
       lookupColumnHandles_,
@@ -194,10 +202,7 @@ void IndexLookupJoin::ensureInputLoaded(const InputBatchState& batch) {
   VELOX_CHECK_GT(numInputBatches(), 0);
   // Ensure each input vector are lazy loaded before process next batch. This is
   // to ensure the ordered lazy materialization in the source readers.
-  auto& input = batch.input;
-  for (auto i = 0; i < input->childrenSize(); ++i) {
-    input->childAt(i)->loadedVector();
-  }
+  loadColumns(batch.input, *operatorCtx_->execCtx());
 }
 
 void IndexLookupJoin::initInputBatches() {
@@ -213,14 +218,13 @@ void IndexLookupJoin::initLookupInput() {
   VELOX_CHECK(lookupInputChannels_.empty());
 
   std::vector<std::string> lookupInputNames;
-  lookupInputNames.reserve(numKeys_ + lookupConditions_.size());
+  lookupInputNames.reserve(numKeys_ + joinConditions_.size());
   std::vector<TypePtr> lookupInputTypes;
-  lookupInputTypes.reserve(numKeys_ + lookupConditions_.size());
-  lookupInputChannels_.reserve(numKeys_ + lookupConditions_.size());
+  lookupInputTypes.reserve(numKeys_ + joinConditions_.size());
+  lookupInputChannels_.reserve(numKeys_ + joinConditions_.size());
 
   SCOPE_EXIT {
-    VELOX_CHECK_GE(
-        lookupInputNames.size(), numKeys_ + lookupConditions_.size());
+    VELOX_CHECK_GE(lookupInputNames.size(), numKeys_ + joinConditions_.size());
     VELOX_CHECK_EQ(lookupInputNames.size(), lookupInputChannels_.size());
     lookupInputType_ =
         ROW(std::move(lookupInputNames), std::move(lookupInputTypes));
@@ -249,19 +253,25 @@ void IndexLookupJoin::initLookupInput() {
         lookupInputColumnSet);
   }
 
-  if (lookupConditions_.empty()) {
+  SCOPE_EXIT {
+    VELOX_CHECK(lookupKeyOrConditionHashers_.empty());
+    VELOX_CHECK(!lookupInputChannels_.empty());
+    lookupKeyOrConditionHashers_ =
+        createVectorHashers(probeType_, lookupInputChannels_);
+  };
+  if (joinConditions_.empty()) {
     return;
   }
 
-  for (const auto& lookupCondition : lookupConditions_) {
-    const auto indexKeyName = getColumnName(lookupCondition->key);
+  for (const auto& joinCondition : joinConditions_) {
+    const auto indexKeyName = getColumnName(joinCondition->key);
     VELOX_USER_CHECK_EQ(lookupIndexColumnSet.count(indexKeyName), 0);
     lookupIndexColumnSet.insert(indexKeyName);
     const auto indexKeyType = lookupType_->findChild(indexKeyName);
 
     if (const auto inCondition =
             std::dynamic_pointer_cast<const core::InIndexLookupCondition>(
-                lookupCondition)) {
+                joinCondition)) {
       const auto conditionInputName = getColumnName(inCondition->list);
       const auto conditionInputChannel =
           probeType_->getChildIdx(conditionInputName);
@@ -282,7 +292,7 @@ void IndexLookupJoin::initLookupInput() {
 
     if (const auto betweenCondition =
             std::dynamic_pointer_cast<core::BetweenIndexLookupCondition>(
-                lookupCondition)) {
+                joinCondition)) {
       addBetweenCondition(
           betweenCondition,
           probeType_,
@@ -292,6 +302,21 @@ void IndexLookupJoin::initLookupInput() {
           lookupInputChannels_,
           lookupInputColumnSet);
     }
+
+    if (const auto equalCondition =
+            std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(
+                joinCondition)) {
+      // Process an equal join condition by validating that the value is
+      // constant. Equal conditions only support constant values for filtering.
+      VELOX_USER_CHECK(
+          core::TypedExprs::isConstant(equalCondition->value),
+          "Equal condition value must be constant: {}",
+          equalCondition->toString());
+      VELOX_USER_CHECK(
+          core::TypedExprs::asConstant(equalCondition->value)
+              ->type()
+              ->equivalent(*indexKeyType));
+    }
   }
 }
 
@@ -349,11 +374,63 @@ void IndexLookupJoin::initOutputProjections() {
     }
     lookupOutputProjections_.emplace_back(i, outputChannelOpt.value());
   }
+  if (hasMarker_) {
+    matchOutputChannel_ = outputType_->size() - 1;
+  }
+
   VELOX_USER_CHECK_EQ(
-      probeOutputProjections_.size() + lookupOutputProjections_.size(),
+      probeOutputProjections_.size() + lookupOutputProjections_.size() +
+          !!matchOutputChannel_.has_value(),
       outputType_->size());
 }
 
+void IndexLookupJoin::initFilter() {
+  VELOX_CHECK_NULL(filter_);
+
+  if (joinNode_->filter() == nullptr) {
+    return;
+  }
+
+  std::vector<core::TypedExprPtr> filters = {joinNode_->filter()};
+  filter_ =
+      std::make_unique<ExprSet>(std::move(filters), operatorCtx_->execCtx());
+
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+  const auto numFields = filter_->expr(0)->distinctFields().size();
+  names.reserve(numFields);
+  types.reserve(numFields);
+
+  column_index_t filterChannel{0};
+  const auto addChannel = [&](column_index_t channel,
+                              const RowTypePtr& inputType,
+                              std::vector<IdentityProjection>& projections) {
+    names.emplace_back(inputType->nameOf(channel));
+    types.emplace_back(inputType->childAt(channel));
+    projections.emplace_back(channel, filterChannel++);
+  };
+
+  for (const auto& field : filter_->expr(0)->distinctFields()) {
+    const auto& name = field->field();
+    auto channel = probeType_->getChildIdxIfExists(name);
+    if (channel.has_value()) {
+      addChannel(channel.value(), probeType_, filterProbeInputProjections_);
+      continue;
+    }
+    channel = lookupOutputType_->getChildIdxIfExists(name);
+    if (channel.has_value()) {
+      addChannel(
+          channel.value(), lookupOutputType_, filterLookupInputProjections_);
+      continue;
+    }
+    VELOX_FAIL(
+        "Index lookup join filter field not found in either left or right input: {}",
+        field->toString());
+  }
+
+  filterInputType_ = ROW(std::move(names), std::move(types));
+}
+
 bool IndexLookupJoin::startDrain() {
   return numInputBatches() != 0;
 }
@@ -415,11 +492,10 @@ void IndexLookupJoin::addInput(RowVectorPtr input) {
   auto& batch = nextInputBatch();
   VELOX_CHECK_LE(numInputBatches(), maxNumInputBatches_);
   batch.input = std::move(input);
-  if (numInputBatches() > 0) {
-    ensureInputLoaded(batch);
-    prepareLookup(batch);
-    startLookup(batch);
-  }
+  ensureInputLoaded(batch);
+  decodeAndDetectNonNullKeys(batch);
+  prepareLookup(batch);
+  startLookup(batch);
 }
 
 RowVectorPtr IndexLookupJoin::getOutput() {
@@ -450,19 +526,175 @@ RowVectorPtr IndexLookupJoin::getOutput() {
 void IndexLookupJoin::prepareLookup(InputBatchState& batch) {
   VELOX_CHECK_GT(numInputBatches(), 0);
   VELOX_CHECK_NOT_NULL(batch.input);
+  const size_t numLookupRows = batch.lookupInputHasNullKeys
+      ? batch.nonNullInputRows.countSelected()
+      : batch.input->size();
   if (batch.lookupInput == nullptr) {
-    batch.lookupInput = BaseVector::create<RowVector>(
-        lookupInputType_, batch.input->size(), pool());
+    batch.lookupInput =
+        BaseVector::create<RowVector>(lookupInputType_, numLookupRows, pool());
   } else {
     VectorPtr lookupInputVector = std::move(batch.lookupInput);
-    BaseVector::prepareForReuse(lookupInputVector, batch.input->size());
+    BaseVector::prepareForReuse(lookupInputVector, numLookupRows);
     batch.lookupInput = std::static_pointer_cast<RowVector>(lookupInputVector);
   }
 
+  if (!batch.lookupInputHasNullKeys) {
+    for (auto i = 0; i < lookupInputType_->size(); ++i) {
+      batch.input->childAt(lookupInputChannels_[i])->loadedVector();
+      batch.lookupInput->childAt(i) =
+          batch.input->childAt(lookupInputChannels_[i]);
+    }
+    return;
+  }
+
+  if (batch.lookupInput->size() == 0) {
+    return;
+  }
+
+  const auto mappingByteSize = numLookupRows * sizeof(vector_size_t);
+  if ((batch.nonNullInputMappings == nullptr) ||
+      !batch.nonNullInputMappings->unique() ||
+      (batch.nonNullInputMappings->capacity() < mappingByteSize)) {
+    batch.nonNullInputMappings = allocateIndices(numLookupRows, pool());
+    batch.rawNonNullInputMappings =
+        batch.nonNullInputMappings->asMutable<vector_size_t>();
+  }
+  batch.nonNullInputMappings->setSize(mappingByteSize);
+
+  size_t lookupRow = 0;
+  batch.nonNullInputRows.applyToSelected(
+      [&](auto row) { batch.rawNonNullInputMappings[lookupRow++] = row; });
+  VELOX_CHECK_EQ(lookupRow, numLookupRows);
+
   for (auto i = 0; i < lookupInputType_->size(); ++i) {
-    batch.lookupInput->childAt(i) =
-        batch.input->childAt(lookupInputChannels_[i]);
-    batch.lookupInput->childAt(i)->loadedVector();
+    batch.input->childAt(lookupInputChannels_[i])->loadedVector();
+    batch.lookupInput->childAt(i) = BaseVector::wrapInDictionary(
+        nullptr,
+        batch.nonNullInputMappings,
+        numLookupRows,
+        batch.input->childAt(lookupInputChannels_[i]));
+  }
+}
+
+void IndexLookupJoin::mergeLookupResults(InputBatchState& batch) {
+  VELOX_CHECK(!batch.partialOutputs.empty());
+  VELOX_CHECK_NULL(batch.lookupResult);
+
+  if (batch.partialOutputs.size() == 1) {
+    batch.lookupResult = std::move(batch.partialOutputs[0]);
+    SCOPE_EXIT {
+      VELOX_CHECK_NOT_NULL(batch.lookupResult);
+      batch.partialOutputs.clear();
+    };
+    return;
+  }
+
+  // Calculate total size.
+  vector_size_t totalSize = 0;
+  for (const auto& result : batch.partialOutputs) {
+    totalSize += static_cast<vector_size_t>(result->size());
+  }
+
+  // Merge inputHits buffers.
+  auto mergedInputHits = allocateIndices(totalSize, pool());
+  auto* rawMergedInputHits = mergedInputHits->asMutable<vector_size_t>();
+  vector_size_t offset = 0;
+  for (const auto& result : batch.partialOutputs) {
+    std::memcpy(
+        rawMergedInputHits + offset,
+        result->inputHits->as<const vector_size_t>(),
+        result->size() * sizeof(vector_size_t));
+    offset += static_cast<vector_size_t>(result->size());
+  }
+
+  // Merge output RowVectors.
+  // NOTE: Uncommon path for connectors that do not respect output batch size
+  // properly
+  auto mergedOutput = BaseVector::create<RowVector>(
+      batch.partialOutputs[0]->output->type(), totalSize, pool());
+  vector_size_t outputOffset = 0;
+  for (const auto& result : batch.partialOutputs) {
+    mergedOutput->copy(result->output.get(), outputOffset, 0, result->size());
+    outputOffset += static_cast<vector_size_t>(result->size());
+  }
+
+  batch.lookupResult = std::make_unique<connector::IndexSource::LookupResult>(
+      std::move(mergedInputHits), std::move(mergedOutput));
+  batch.partialOutputs.clear();
+}
+
+bool IndexLookupJoin::getLookupResults(InputBatchState& batch) {
+  VELOX_CHECK_NOT_NULL(batch.lookupInput);
+  VELOX_CHECK_NOT_NULL(batch.lookupResultIter);
+  VELOX_CHECK(!batch.lookupFuture.valid());
+
+  // Result is ready.
+  if (batch.lookupResult != nullptr) {
+    return true;
+  }
+
+  // Fetch the first result if not already fetched.
+  if (batch.lookupResult == nullptr && batch.partialOutputs.empty()) {
+    auto lookupResultOr =
+        batch.lookupResultIter->next(outputBatchSize_, batch.lookupFuture);
+    if (!lookupResultOr.has_value()) {
+      VELOX_CHECK(batch.lookupFuture.valid());
+      return false;
+    }
+    VELOX_CHECK(!batch.lookupFuture.valid());
+
+    // Either splitOutput_ is true, or no more results, or first result is null.
+    if (splitOutput_ || !lookupResultOr.has_value() ||
+        !batch.lookupResultIter->hasNext()) {
+      batch.lookupResult = std::move(lookupResultOr).value();
+      return true;
+    }
+
+    // Otherwise start accumulating results.
+    batch.partialOutputs.push_back(std::move(lookupResultOr).value());
+  }
+
+  // Continue accumulating remaining results when splitOutput_ is false.
+  // This handles both initial accumulation and resuming after async
+  // interruption.
+  VELOX_CHECK(!splitOutput_);
+  VELOX_CHECK(!batch.partialOutputs.empty());
+  VELOX_CHECK_NULL(batch.lookupResult);
+
+  while (batch.lookupResultIter->hasNext()) {
+    auto nextResultOr =
+        batch.lookupResultIter->next(outputBatchSize_, batch.lookupFuture);
+    if (!nextResultOr.has_value()) {
+      // Need to wait for async operation.
+      VELOX_CHECK(batch.lookupFuture.valid());
+      return false;
+    }
+    VELOX_CHECK(!batch.lookupFuture.valid());
+    auto nextResult = std::move(nextResultOr).value();
+    if (nextResult != nullptr) {
+      batch.partialOutputs.push_back(std::move(nextResult));
+    }
+  }
+
+  // All results accumulated, merge them.
+  mergeLookupResults(batch);
+  return true;
+}
+
+void IndexLookupJoin::decodeAndDetectNonNullKeys(InputBatchState& batch) {
+  const auto numRows = batch.input->size();
+  batch.nonNullInputRows.resize(numRows);
+  batch.nonNullInputRows.setAll();
+
+  for (auto i = 0; i < lookupKeyOrConditionHashers_.size(); ++i) {
+    const auto* key =
+        batch.input->childAt(lookupKeyOrConditionHashers_[i]->channel())
+            ->loadedVector();
+    lookupKeyOrConditionHashers_[i]->decode(*key, batch.nonNullInputRows);
+  }
+  deselectRowsWithNulls(lookupKeyOrConditionHashers_, batch.nonNullInputRows);
+  if (batch.nonNullInputRows.countSelected() < numRows) {
+    batch.lookupInputHasNullKeys = true;
   }
 }
 
@@ -470,21 +702,25 @@ void IndexLookupJoin::startLookup(InputBatchState& batch) {
   VELOX_CHECK_GT(numInputBatches(), 0);
   VELOX_CHECK_NOT_NULL(batch.input);
   VELOX_CHECK_NOT_NULL(batch.lookupInput);
-  VELOX_CHECK_EQ(batch.lookupInput->size(), batch.input->size());
+  if (batch.lookupInputHasNullKeys) {
+    VELOX_CHECK_LT(batch.lookupInput->size(), batch.input->size());
+  } else {
+    VELOX_CHECK_EQ(batch.lookupInput->size(), batch.input->size());
+  }
   VELOX_CHECK_NULL(batch.lookupResultIter);
   VELOX_CHECK_NULL(batch.lookupResult);
   VELOX_CHECK(!batch.lookupFuture.valid());
 
-  batch.lookupResultIter = indexSource_->lookup(
-      connector::IndexSource::LookupRequest{batch.lookupInput});
-  auto lookupResultOr =
-      batch.lookupResultIter->next(outputBatchSize_, batch.lookupFuture);
-  if (!lookupResultOr.has_value()) {
-    VELOX_CHECK(batch.lookupFuture.valid());
+  if (batch.lookupInput->size() == 0) {
+    // No need to start lookup for empty lookup input.
     return;
   }
-  VELOX_CHECK(!batch.lookupFuture.valid());
-  batch.lookupResult = std::move(lookupResultOr).value();
+
+  // Create the lookup result iterator.
+  batch.lookupResultIter = indexSource_->lookup(
+      connector::IndexSource::LookupRequest{batch.lookupInput});
+
+  getLookupResults(batch);
 }
 
 RowVectorPtr IndexLookupJoin::getOutputFromLookupResult(
@@ -492,33 +728,38 @@ RowVectorPtr IndexLookupJoin::getOutputFromLookupResult(
   VELOX_CHECK(!batch.empty());
   VELOX_CHECK(!batch.lookupFuture.valid() || batch.lookupFuture.isReady());
   batch.lookupFuture = ContinueFuture::makeEmpty();
-  VELOX_CHECK_NOT_NULL(batch.lookupResultIter);
 
-  if (batch.lookupResult == nullptr) {
-    auto resultOptional =
-        batch.lookupResultIter->next(outputBatchSize_, batch.lookupFuture);
-    if (!resultOptional.has_value()) {
-      VELOX_CHECK(batch.lookupFuture.valid());
-      return nullptr;
-    }
-    VELOX_CHECK(!batch.lookupFuture.valid());
+  if (batch.lookupInput->size() == 0) {
+    return produceRemainingOutput(batch);
+  }
 
-    batch.lookupResult = std::move(resultOptional).value();
-    if (batch.lookupResult == nullptr) {
-      if (hasRemainingOutputForLeftJoin(batch)) {
-        return produceRemainingOutputForLeftJoin(batch);
-      }
-      finishInput(batch);
-      return nullptr;
+  if (!getLookupResults(batch)) {
+    // Async operation pending, need to wait.
+    VELOX_CHECK(batch.lookupFuture.valid());
+    return nullptr;
+  }
+
+  VELOX_CHECK(!batch.lookupFuture.valid());
+  VELOX_CHECK(batch.partialOutputs.empty());
+
+  if (batch.lookupResult == nullptr) {
+    if (hasRemainingOutputForLeftJoin(batch)) {
+      return produceRemainingOutputForLeftJoin(batch);
     }
-    rawLookupInputHitIndices_ =
-        batch.lookupResult->inputHits->as<const vector_size_t>();
-  } else if (rawLookupInputHitIndices_ == nullptr) {
-    rawLookupInputHitIndices_ =
-        batch.lookupResult->inputHits->as<const vector_size_t>();
+    finishInput(batch);
+    return nullptr;
   }
+
+  prepareLookupResult(batch);
   VELOX_CHECK_NOT_NULL(batch.lookupResult);
 
+  if (!applyFilterOnLookupResult(batch)) {
+    VELOX_CHECK_NULL(batch.lookupResult);
+    // All rows in lookup result are filtered out, and fetch next lookup result
+    // batch.
+    return nullptr;
+  }
+
   SCOPE_EXIT {
     maybeFinishLookupResult(batch);
   };
@@ -528,15 +769,79 @@ RowVectorPtr IndexLookupJoin::getOutputFromLookupResult(
   return produceOutputForLeftJoin(batch);
 }
 
+RowVectorPtr IndexLookupJoin::produceRemainingOutput(InputBatchState& batch) {
+  if (hasRemainingOutputForLeftJoin(batch)) {
+    return produceRemainingOutputForLeftJoin(batch);
+  }
+  finishInput(batch);
+  return nullptr;
+}
+
+void IndexLookupJoin::prepareLookupResult(InputBatchState& batch) {
+  VELOX_CHECK_NOT_NULL(batch.lookupResult);
+  if (rawLookupInputHitIndices_ != nullptr) {
+    return;
+  }
+
+  if (!batch.lookupInputHasNullKeys) {
+    rawLookupInputHitIndices_ =
+        batch.lookupResult->inputHits->as<const vector_size_t>();
+    return;
+  }
+  VELOX_CHECK_NOT_NULL(batch.nonNullInputMappings);
+  vector_size_t* rawLookupInputHitIndices =
+      batch.ensureInputHitsWritable(pool());
+  for (auto i = 0; i < batch.lookupResult->size(); ++i) {
+    rawLookupInputHitIndices[i] =
+        batch.rawNonNullInputMappings[rawLookupInputHitIndices[i]];
+#ifdef NDEBUG
+    if (i > 0) {
+      VELOX_DCHECK_LE(
+          rawLookupInputHitIndices[i - 1], rawLookupInputHitIndices[i]);
+    }
+#endif
+  }
+  rawLookupInputHitIndices_ = rawLookupInputHitIndices;
+}
+
+vector_size_t* IndexLookupJoin::InputBatchState::ensureInputHitsWritable(
+    memory::MemoryPool* pool) {
+  VELOX_CHECK_NOT_NULL(lookupResult);
+  if (lookupResult->inputHits->isMutable()) {
+    return lookupResult->inputHits->asMutable<vector_size_t>();
+  }
+
+  const auto indicesByteSize = lookupResult->size() * sizeof(vector_size_t);
+  if ((resultInputHitIndices == nullptr) ||
+      !resultInputHitIndices->isMutable() ||
+      (resultInputHitIndices->capacity() < indicesByteSize)) {
+    resultInputHitIndices = allocateIndices(indicesByteSize, pool);
+  } else {
+    resultInputHitIndices->setSize(indicesByteSize);
+  }
+  auto* rawLookupInputHitIndices =
+      resultInputHitIndices->asMutable<vector_size_t>();
+  std::memcpy(
+      rawLookupInputHitIndices,
+      lookupResult->inputHits->as<const vector_size_t>(),
+      indicesByteSize);
+  lookupResult->inputHits = resultInputHitIndices;
+  return rawLookupInputHitIndices;
+}
+
 void IndexLookupJoin::maybeFinishLookupResult(InputBatchState& batch) {
   VELOX_CHECK_NOT_NULL(batch.lookupResult);
   if (nextOutputResultRow_ == batch.lookupResult->size()) {
-    batch.lookupResult = nullptr;
-    nextOutputResultRow_ = 0;
-    rawLookupInputHitIndices_ = nullptr;
+    finishLookupResult(batch);
   }
 }
 
+void IndexLookupJoin::finishLookupResult(InputBatchState& batch) {
+  batch.lookupResult = nullptr;
+  nextOutputResultRow_ = 0;
+  rawLookupInputHitIndices_ = nullptr;
+}
+
 bool IndexLookupJoin::hasRemainingOutputForLeftJoin(
     const InputBatchState& batch) const {
   if (joinType_ != core::JoinType::kLeft) {
@@ -550,12 +855,14 @@ bool IndexLookupJoin::hasRemainingOutputForLeftJoin(
 
 void IndexLookupJoin::finishInput(InputBatchState& batch) {
   VELOX_CHECK_NOT_NULL(batch.input);
-  VELOX_CHECK_NOT_NULL(batch.lookupResultIter);
+  VELOX_CHECK_EQ(
+      batch.lookupInput->size() == 0, batch.lookupResultIter == nullptr);
   VELOX_CHECK(!batch.lookupFuture.valid());
 
   batch.input = nullptr;
   batch.lookupResultIter = nullptr;
   batch.lookupResult = nullptr;
+  batch.lookupInputHasNullKeys = false;
   lastProcessedInputRow_ = std::nullopt;
   nextOutputResultRow_ = 0;
   ++startBatchIndex_;
@@ -565,10 +872,9 @@ void IndexLookupJoin::finishInput(InputBatchState& batch) {
     VELOX_CHECK(!nextBatch.empty());
     if (nextBatch.lookupResult != nullptr) {
       VELOX_CHECK(!nextBatch.lookupFuture.valid());
-      rawLookupInputHitIndices_ =
-          nextBatch.lookupResult->inputHits->as<const vector_size_t>();
     } else {
-      VELOX_CHECK(nextBatch.lookupFuture.valid());
+      VELOX_CHECK_EQ(
+          nextBatch.lookupInput->size() != 0, nextBatch.lookupFuture.valid());
     }
   }
 }
@@ -622,12 +928,28 @@ RowVectorPtr IndexLookupJoin::produceOutputForInnerJoin(
               ->slice(nextOutputResultRow_, numOutputRows);
     }
   }
-
   nextOutputResultRow_ += numOutputRows;
   VELOX_CHECK_LE(nextOutputResultRow_, batch.lookupResult->size());
   return output_;
 }
 
+void IndexLookupJoin::fillOutputMatchRows(
+    vector_size_t offset,
+    vector_size_t size,
+    bool match) {
+  VELOX_CHECK_EQ(joinType_, core::JoinType::kLeft);
+  bits::fillBits(
+      rawLookupOutputNulls_,
+      offset,
+      offset + size,
+      match ? bits::kNotNull : bits::kNull);
+  if (!hasMarker_) {
+    return;
+  }
+  VELOX_CHECK_NOT_NULL(rawMatchValues_);
+  bits::fillBits(rawMatchValues_, offset, offset + size, match);
+}
+
 RowVectorPtr IndexLookupJoin::produceOutputForLeftJoin(
     const InputBatchState& batch) {
   VELOX_CHECK_EQ(joinType_, core::JoinType::kLeft);
@@ -636,32 +958,39 @@ RowVectorPtr IndexLookupJoin::produceOutputForLeftJoin(
   VELOX_CHECK_NOT_NULL(rawLookupInputHitIndices_);
   VELOX_CHECK_NOT_NULL(batch.input);
 
-  prepareOutputRowMappings(outputBatchSize_);
+  const auto startOutputRow = nextOutputResultRow_;
+  int32_t lastProcessedInputRow = lastProcessedInputRow_.value_or(-1);
+  const auto startProcessInputRow = lastProcessedInputRow + 1;
+  // Set 'maxOutputRows' to max number of output rows that can be produced
+  // considering the possible missed input rows.
+  const size_t maxOutputRows = std::min<size_t>(
+      outputBatchSize_,
+      batch.lookupResult->size() - nextOutputResultRow_ + batch.input->size() -
+          startProcessInputRow);
+  prepareOutputRowMappings(maxOutputRows);
   VELOX_CHECK_NOT_NULL(rawLookupOutputNulls_);
-
   size_t numOutputRows{0};
   size_t totalMissedInputRows{0};
-  int32_t lastProcessedInputRow = lastProcessedInputRow_.value_or(-1);
-  for (; numOutputRows < outputBatchSize_ &&
+  for (; numOutputRows < maxOutputRows &&
        nextOutputResultRow_ < batch.lookupResult->size();) {
     VELOX_CHECK_GE(
-        rawLookupInputHitIndices_[nextOutputResultRow_], lastProcessedInputRow);
+        rawLookupInputHitIndices_[nextOutputResultRow_],
+        lastProcessedInputRow,
+        "nextOutputResultRow_ {}, batch.lookupResult->size() {}",
+        nextOutputResultRow_,
+        batch.lookupResult->size());
     const vector_size_t numMissedInputRows =
         rawLookupInputHitIndices_[nextOutputResultRow_] -
         lastProcessedInputRow - 1;
     VELOX_CHECK_GE(numMissedInputRows, -1);
     if (numMissedInputRows > 0) {
       if (totalMissedInputRows == 0) {
-        bits::fillBits(
-            rawLookupOutputNulls_, 0, outputBatchSize_, bits::kNotNull);
+        ensureMatchColumn(maxOutputRows);
+        fillOutputMatchRows(0, maxOutputRows, true);
       }
       const auto numOutputMissedInputRows = std::min<vector_size_t>(
-          numMissedInputRows, outputBatchSize_ - numOutputRows);
-      bits::fillBits(
-          rawLookupOutputNulls_,
-          numOutputRows,
-          numOutputRows + numOutputMissedInputRows,
-          bits::kNull);
+          numMissedInputRows, maxOutputRows - numOutputRows);
+      fillOutputMatchRows(numOutputRows, numOutputMissedInputRows, false);
       for (auto i = 0; i < numOutputMissedInputRows; ++i) {
         rawProbeOutputRowIndices_[numOutputRows++] = ++lastProcessedInputRow;
       }
@@ -677,13 +1006,14 @@ RowVectorPtr IndexLookupJoin::produceOutputForLeftJoin(
     ++numOutputRows;
   }
   VELOX_CHECK(
-      numOutputRows == outputBatchSize_ ||
+      numOutputRows == maxOutputRows ||
       nextOutputResultRow_ == batch.lookupResult->size());
   VELOX_CHECK_LE(nextOutputResultRow_, batch.lookupResult->size());
   lastProcessedInputRow_ = lastProcessedInputRow;
 
   if (totalMissedInputRows > 0) {
     lookupOutputNulls_->setSize(bits::nbytes(numOutputRows));
+    setMatchColumnSize(numOutputRows);
   }
   probeOutputRowMapping_->setSize(numOutputRows * sizeof(vector_size_t));
   lookupOutputRowMapping_->setSize(numOutputRows * sizeof(vector_size_t));
@@ -693,63 +1023,124 @@ RowVectorPtr IndexLookupJoin::produceOutputForLeftJoin(
   }
 
   prepareOutput(numOutputRows);
-  for (const auto& projection : probeOutputProjections_) {
-    output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
-        nullptr,
-        probeOutputRowMapping_,
-        numOutputRows,
-        batch.input->childAt(projection.inputChannel));
+  const auto numInputRows = lastProcessedInputRow - startProcessInputRow + 1;
+  if (numInputRows == numOutputRows) {
+    if (startProcessInputRow == 0 && numInputRows == batch.input->size()) {
+      for (const auto& projection : probeOutputProjections_) {
+        output_->childAt(projection.outputChannel) =
+            batch.input->childAt(projection.inputChannel);
+      }
+    } else {
+      for (const auto& projection : probeOutputProjections_) {
+        output_->childAt(projection.outputChannel) =
+            batch.input->childAt(projection.inputChannel)
+                ->slice(startProcessInputRow, numInputRows);
+      }
+    }
+  } else {
+    for (const auto& projection : probeOutputProjections_) {
+      output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
+          nullptr,
+          probeOutputRowMapping_,
+          numOutputRows,
+          batch.input->childAt(projection.inputChannel));
+    }
   }
-  for (const auto& projection : lookupOutputProjections_) {
-    output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
-        totalMissedInputRows > 0 ? lookupOutputNulls_ : nullptr,
-        lookupOutputRowMapping_,
-        numOutputRows,
-        batch.lookupResult->output->childAt(projection.inputChannel));
+
+  if (totalMissedInputRows > 0) {
+    for (const auto& projection : lookupOutputProjections_) {
+      output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
+          lookupOutputNulls_,
+          lookupOutputRowMapping_,
+          numOutputRows,
+          batch.lookupResult->output->childAt(projection.inputChannel));
+    }
+    if (hasMarker_) {
+      output_->childAt(matchOutputChannel_.value()) = matchColumn_;
+    }
+  } else {
+    if (startOutputRow == 0 &&
+        numOutputRows == batch.lookupResult->output->size()) {
+      for (const auto& projection : lookupOutputProjections_) {
+        output_->childAt(projection.outputChannel) =
+            batch.lookupResult->output->childAt(projection.inputChannel);
+      }
+    } else {
+      for (const auto& projection : lookupOutputProjections_) {
+        output_->childAt(projection.outputChannel) =
+            batch.lookupResult->output->childAt(projection.inputChannel)
+                ->slice(startOutputRow, numOutputRows);
+      }
+    }
+    if (hasMarker_) {
+      output_->childAt(matchOutputChannel_.value()) =
+          BaseVector::createConstant(BOOLEAN(), true, numOutputRows, pool());
+    }
   }
   return output_;
 }
 
+void IndexLookupJoin::ensureMatchColumn(vector_size_t maxOutputRows) {
+  if (!hasMarker_) {
+    return;
+  }
+  if (matchColumn_) {
+    VectorPtr matchColumn = std::move(matchColumn_);
+    BaseVector::prepareForReuse(matchColumn, maxOutputRows);
+    matchColumn_ = std::dynamic_pointer_cast<FlatVector<bool>>(matchColumn);
+  } else {
+    matchColumn_ =
+        BaseVector::create<FlatVector<bool>>(BOOLEAN(), maxOutputRows, pool());
+  }
+  VELOX_CHECK_NOT_NULL(matchColumn_);
+  rawMatchValues_ = matchColumn_->mutableRawValues<uint64_t>();
+}
+
+void IndexLookupJoin::setMatchColumnSize(vector_size_t numOutputRows) {
+  if (!hasMarker_) {
+    return;
+  }
+  VELOX_CHECK_NOT_NULL(matchColumn_);
+  matchColumn_->resize(numOutputRows);
+}
+
 RowVectorPtr IndexLookupJoin::produceRemainingOutputForLeftJoin(
     const InputBatchState& batch) {
   VELOX_CHECK_EQ(joinType_, core::JoinType::kLeft);
   VELOX_CHECK(!batch.empty());
   VELOX_CHECK(hasRemainingOutputForLeftJoin(batch));
   VELOX_CHECK_NULL(rawLookupInputHitIndices_);
-  prepareOutputRowMappings(outputBatchSize_);
-  VELOX_CHECK_NOT_NULL(rawLookupOutputNulls_);
 
   size_t lastProcessedInputRow = lastProcessedInputRow_.value_or(-1);
+  const auto startProcessInputRow = lastProcessedInputRow + 1;
   const size_t numOutputRows = std::min<size_t>(
-      outputBatchSize_, batch.input->size() - lastProcessedInputRow - 1);
+      outputBatchSize_, batch.input->size() - startProcessInputRow);
   VELOX_CHECK_GT(numOutputRows, 0);
-  bits::fillBits(rawLookupOutputNulls_, 0, numOutputRows, bits::kNull);
-  for (auto outputRow = 0; outputRow < numOutputRows; ++outputRow) {
-    rawProbeOutputRowIndices_[outputRow] = ++lastProcessedInputRow;
-  }
-  lookupOutputNulls_->setSize(bits::nbytes(numOutputRows));
-  probeOutputRowMapping_->setSize(numOutputRows * sizeof(vector_size_t));
-  lookupOutputRowMapping_->setSize(numOutputRows * sizeof(vector_size_t));
-
+  VELOX_CHECK_LE(numOutputRows, batch.input->size());
   prepareOutput(numOutputRows);
-  for (const auto& projection : probeOutputProjections_) {
-    output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
-        nullptr,
-        probeOutputRowMapping_,
-        numOutputRows,
-        batch.input->childAt(projection.inputChannel));
+  if (numOutputRows != batch.input->size()) {
+    for (const auto& projection : probeOutputProjections_) {
+      output_->childAt(projection.outputChannel) =
+          batch.input->childAt(projection.inputChannel)
+              ->slice(startProcessInputRow, numOutputRows);
+    }
+  } else {
+    for (const auto& projection : probeOutputProjections_) {
+      output_->childAt(projection.outputChannel) =
+          batch.input->childAt(projection.inputChannel);
+    }
   }
   for (const auto& projection : lookupOutputProjections_) {
-    output_->childAt(projection.outputChannel) = BaseVector::wrapInDictionary(
-        lookupOutputNulls_,
-        lookupOutputRowMapping_,
+    output_->childAt(projection.outputChannel) = BaseVector::createNullConstant(
+        output_->type()->childAt(projection.outputChannel),
         numOutputRows,
-        BaseVector::createNullConstant(
-            output_->type()->childAt(projection.outputChannel),
-            numOutputRows,
-            pool()));
+        pool());
   }
-  lastProcessedInputRow_ = lastProcessedInputRow;
+  if (hasMarker_) {
+    output_->childAt(matchOutputChannel_.value()) =
+        BaseVector::createConstant(BOOLEAN(), false, numOutputRows, pool());
+  }
+  lastProcessedInputRow_ = lastProcessedInputRow + numOutputRows;
   return output_;
 }
 
@@ -798,6 +1189,111 @@ void IndexLookupJoin::close() {
   Operator::close();
 }
 
+bool IndexLookupJoin::applyFilterOnLookupResult(InputBatchState& batch) {
+  VELOX_CHECK_NOT_NULL(batch.lookupResult);
+  if (!filter_) {
+    return true;
+  }
+  if (batch.lookupResult->size() == 0) {
+    return true;
+  }
+
+  const auto numResultRows = batch.lookupResult->size();
+
+  // Prepare filter input vector
+  filterRows_.resize(numResultRows);
+  filterRows_.setAll();
+
+  if (!filterInput_) {
+    filterInput_ =
+        BaseVector::create<RowVector>(filterInputType_, numResultRows, pool());
+  } else {
+    VectorPtr filterInputVector = std::move(filterInput_);
+    BaseVector::prepareForReuse(filterInputVector, numResultRows);
+    filterInput_ = std::static_pointer_cast<RowVector>(filterInputVector);
+  }
+
+  // Populate filter input from probe input.
+  for (const auto& projection : filterProbeInputProjections_) {
+    // Get the probe input column and dictionary-wrap it with hit indices
+    filterInput_->childAt(projection.outputChannel) =
+        BaseVector::wrapInDictionary(
+            nullptr,
+            batch.lookupResult->inputHits,
+            numResultRows,
+            batch.input->childAt(projection.inputChannel));
+  }
+
+  // Populate filter input from lookup result.
+  for (const auto& projection : filterLookupInputProjections_) {
+    filterInput_->childAt(projection.outputChannel) =
+        batch.lookupResult->output->childAt(projection.inputChannel);
+  }
+
+  // Evaluate filter
+  filterResult_.resize(1);
+  EvalCtx evalCtx(operatorCtx_->execCtx(), filter_.get(), filterInput_.get());
+  filter_->eval(filterRows_, evalCtx, filterResult_);
+  decodedFilterResult_.decode(*filterResult_[0], filterRows_);
+
+  const auto indicesByteSize = numResultRows * sizeof(vector_size_t);
+  if (!filteredIndices_ || !filteredIndices_->isMutable() ||
+      filteredIndices_->capacity() < indicesByteSize) {
+    filteredIndices_ = allocateIndices(numResultRows, pool());
+  } else {
+    filteredIndices_->setSize(indicesByteSize);
+  }
+  auto* rawFilteredIndices = filteredIndices_->asMutable<vector_size_t>();
+
+  vector_size_t numPassed{0};
+  for (auto i = 0; i < numResultRows; ++i) {
+    if (!decodedFilterResult_.isNullAt(i) &&
+        decodedFilterResult_.valueAt<bool>(i)) {
+      rawFilteredIndices[numPassed++] = i;
+    }
+  }
+
+  if (numPassed == 0) {
+    finishLookupResult(batch);
+    return false;
+  }
+
+  if (numPassed == numResultRows) {
+    return true;
+  }
+
+  // Some rows passed - create filtered lookup result.
+  filteredIndices_->setSize(numPassed * sizeof(vector_size_t));
+
+  // Update the inputHits buffer.
+  auto* rawLookupInputHitIndices = batch.ensureInputHitsWritable(pool());
+  for (auto i = 0; i < numPassed; ++i) {
+    rawLookupInputHitIndices[i] =
+        rawLookupInputHitIndices_[rawFilteredIndices[i]];
+#ifdef NDEBUG
+    if (i > 0) {
+      VELOX_DCHECK_LE(
+          rawLookupInputHitIndices[i - 1], rawLookupInputHitIndices[i]);
+    }
+#endif
+  }
+  batch.lookupResult->inputHits->setSize(numPassed * sizeof(vector_size_t));
+  rawLookupInputHitIndices_ = rawLookupInputHitIndices;
+
+  // Create the filtered result vector.
+  auto filteredOutput = BaseVector::create<RowVector>(
+      batch.lookupResult->output->type(), numPassed, pool());
+  for (auto i = 0; i < batch.lookupResult->output->childrenSize(); ++i) {
+    filteredOutput->childAt(i) = BaseVector::wrapInDictionary(
+        nullptr,
+        filteredIndices_,
+        numPassed,
+        batch.lookupResult->output->childAt(i));
+  }
+  batch.lookupResult->output = std::move(filteredOutput);
+  return true;
+}
+
 void IndexLookupJoin::recordConnectorStats() {
   if (indexSource_ == nullptr) {
     // NOTE: index join might fail to create index source so skip record stats
@@ -814,8 +1310,8 @@ void IndexLookupJoin::recordConnectorStats() {
     const CpuWallTiming backgroundTiming{
         static_cast<uint64_t>(connectorStats[kConnectorLookupWallTime].count),
         static_cast<uint64_t>(connectorStats[kConnectorLookupWallTime].sum),
-        // NOTE: this might not be accurate as it doesn't include the time spent
-        // inside the index storage client.
+        // NOTE: this might not be accurate as it doesn't include the time
+        // spent inside the index storage client.
         static_cast<uint64_t>(connectorStats[kConnectorResultPrepareTime].sum) +
             connectorStats[kClientRequestProcessTime].sum +
             connectorStats[kClientResultProcessTime].sum};
diff --git a/velox/exec/IndexLookupJoin.h b/velox/exec/IndexLookupJoin.h
index 30860f032e89..73700b830bb5 100644
--- a/velox/exec/IndexLookupJoin.h
+++ b/velox/exec/IndexLookupJoin.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 #include "velox/exec/Operator.h"
+#include "velox/exec/VectorHasher.h"
 
 namespace facebook::velox::exec {
 
@@ -77,6 +78,9 @@ class IndexLookupJoin : public Operator {
   /// the raw data received from the remote storage lookup.
   static inline const std::string kClientLookupResultSize{
       "clientLookupResultSize"};
+  /// The number of lookup results received from remote storage with error.
+  static inline const std::string kClientNumErrorResults{
+      "clientNumErrorResults"};
 
  private:
   using LookupResultIter = connector::IndexSource::LookupResultIterator;
@@ -86,6 +90,16 @@ class IndexLookupJoin : public Operator {
   struct InputBatchState {
     // The input batch to process.
     RowVectorPtr input;
+
+    // If true, it indicates that the probe input has null join keys.
+    bool lookupInputHasNullKeys{false};
+    // Select input rows with non-null join keys.
+    SelectivityVector nonNullInputRows;
+    // The map from lookup input row to the corresponding probe input row. It is
+    // used to handle the case that probe input has null keys.
+    BufferPtr nonNullInputMappings;
+    vector_size_t* rawNonNullInputMappings{nullptr};
+
     // The reusable vector projected from 'input' as index lookup input.
     RowVectorPtr lookupInput;
     // Used to fetch lookup results for an input batch.
@@ -97,6 +111,19 @@ class IndexLookupJoin : public Operator {
     // output processing. We might split the output result into multiple output
     // batches based on the operator's output batch size limit.
     std::unique_ptr<LookupResult> lookupResult;
+    // Specifies the indices of input row in 'input' that have matches in
+    // 'output' from 'lookupResult'. This is only used in case
+    // 'lookupInputHasNullKeys' is true in which 'inputHits' in 'lookupResult'
+    // points to rows in 'lookupInput' which might be different from 'input'.
+    // To ease the rest of index lookup join result processing, we need to
+    // redirect the lookup input hit row from 'lookupInput' to the corresponding
+    // row in 'input' through the mapping specified by 'nonNullInputMappings'.
+    // The redirect input hit indices are stored in 'resultInputHitIndices'.
+    BufferPtr resultInputHitIndices;
+    // When splitOutput_ is false, this tracks partially accumulated results
+    // that are waiting for async operations to complete before continuing
+    // accumulation.
+    std::vector<std::unique_ptr<LookupResult>> partialOutputs;
 
     InputBatchState() : lookupFuture(ContinueFuture::makeEmpty()) {}
 
@@ -105,12 +132,20 @@ class IndexLookupJoin : public Operator {
       lookupResultIter = nullptr;
       lookupFuture = ContinueFuture::makeEmpty();
       lookupResult = nullptr;
+      partialOutputs.clear();
     }
 
     // Indicates if this input batch is empty.
     bool empty() const {
       return input == nullptr;
     }
+
+    // Ensures that the lookup result's inputHits buffer is writable and returns
+    // a mutable pointer. If the buffer is already mutable, returns it directly.
+    // Otherwise, creates a new writable buffer by copying the existing data and
+    // returns a pointer to the new buffer. This is needed when filters or null
+    // key handling requires modifying the input hit indices.
+    vector_size_t* ensureInputHitsWritable(memory::MemoryPool* pool);
   };
 
   void initInputBatches();
@@ -118,17 +153,40 @@ class IndexLookupJoin : public Operator {
   void initLookupInput();
   void initLookupOutput();
   void initOutputProjections();
+  void initFilter();
+
+  // Applies the join filter directly on the lookup result, updating the
+  // lookup result to only include rows that pass the filter. Returns true if
+  // some rows passed the filter, otherwise false.
+  bool applyFilterOnLookupResult(InputBatchState& batch);
+
   void ensureInputLoaded(const InputBatchState& batch);
   // Prepare index source lookup for a given 'input_'.
   void prepareLookup(InputBatchState& batch);
   void startLookup(InputBatchState& batch);
 
+  // Helper function to merge batch.partialOutputs into a single
+  // batch.lookupResult. This is used when splitOutput_ is false to ensure all
+  // results from an iterator are combined into one output batch.
+  void mergeLookupResults(InputBatchState& batch);
+  // Helper function to get all lookup results. Fetches the first result if not
+  // already fetched, and when splitOutput_ is false, accumulates all remaining
+  // results into a single batch. Handles both initial lookup and resuming
+  // accumulation after async interruption. Returns true if results are ready,
+  // false if an async operation is pending.
+  bool getLookupResults(InputBatchState& batch);
+
   void startLookupBlockWait();
   void endLookupBlockWait();
 
   RowVectorPtr getOutputFromLookupResult(InputBatchState& batch);
   RowVectorPtr produceOutputForInnerJoin(const InputBatchState& batch);
   RowVectorPtr produceOutputForLeftJoin(const InputBatchState& batch);
+  // Handles production of remaining output after lookup result processing is
+  // complete. For left joins, this ensures unmatched rows from the probe side
+  // are included in the output with null values for lookup columns. For inner
+  // joins, this simply finishes the input batch.
+  RowVectorPtr produceRemainingOutput(InputBatchState& batch);
   // Produces output for the remaining input rows that has no matches from the
   // lookup at the end of current input batch processing.
   RowVectorPtr produceRemainingOutputForLeftJoin(const InputBatchState& batch);
@@ -140,8 +198,10 @@ class IndexLookupJoin : public Operator {
   bool hasRemainingOutputForLeftJoin(const InputBatchState& batch) const;
 
   // Checks if we have finished processing the current 'lookupResult_'. If so,
-  // we reset 'lookupResult_' and corresponding processing state.
+  // call 'finishLookupResult' to reset 'lookupResult_' and corresponding
+  // processing state.
   void maybeFinishLookupResult(InputBatchState& batch);
+  void finishLookupResult(InputBatchState& batch);
 
   // Invoked after finished processing the current 'input_' batch. The function
   // resets the input batch and the lookup result states.
@@ -151,9 +211,31 @@ class IndexLookupJoin : public Operator {
   // 'outputBatchSize'. This is only used by left join which needs to fill nulls
   // for output rows without lookup matches.
   void prepareOutputRowMappings(size_t outputBatchSize);
+
   // Prepare 'output_' for the next output batch with size of 'numOutputRows'.
   void prepareOutput(vector_size_t numOutputRows);
 
+  // Invoked to ensure the match column is created to store the output match
+  // result for the left join.
+  void ensureMatchColumn(vector_size_t maxOutputRows);
+
+  // Invoked to fill the match column and output nulls with the match result for
+  // the left join.
+  void
+  fillOutputMatchRows(vector_size_t offset, vector_size_t size, bool match);
+
+  // Invoked to set the match column with the actual output size.
+  void setMatchColumnSize(vector_size_t numOutputRows);
+
+  // Invoked to decode the probe input keys to detect if there are any null
+  // keys.
+  void decodeAndDetectNonNullKeys(InputBatchState& batch);
+
+  // Invoked to prepare the lookup result for processing. If the probe input has
+  // null keys, it maps the hit rows in lookup result to the corresponding probe
+  // input rows.
+  void prepareLookupResult(InputBatchState& batch);
+
   // Invoked at operator close to record the lookup stats.
   void recordConnectorStats();
 
@@ -186,17 +268,20 @@ class IndexLookupJoin : public Operator {
     return inputBatches_[startBatchIndex_ % maxNumInputBatches_];
   }
 
+  // If true, allows one input row to produce multiple output rows.
+  // If false, enforces one-to-one mapping.
+  const bool splitOutput_;
   // Maximum number of rows in the output batch.
   const vector_size_t outputBatchSize_;
   // Type of join.
   const core::JoinType joinType_;
+  const bool hasMarker_;
   const size_t numKeys_;
   const RowTypePtr probeType_;
   const RowTypePtr lookupType_;
-  const std::shared_ptr<connector::ConnectorTableHandle> lookupTableHandle_;
-  const std::vector<core::IndexLookupConditionPtr> lookupConditions_;
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      lookupColumnHandles_;
+  const connector::ConnectorTableHandlePtr lookupTableHandle_;
+  const std::vector<core::IndexLookupConditionPtr> joinConditions_;
+  const connector::ColumnHandleMap lookupColumnHandles_;
   const std::shared_ptr<connector::ConnectorQueryCtx> connectorQueryCtx_;
   const std::shared_ptr<connector::Connector> connector_;
   const size_t maxNumInputBatches_;
@@ -211,6 +296,10 @@ class IndexLookupJoin : public Operator {
   // The column channels in probe 'input_' referenced by 'lookupInputType_'.
   std::vector<column_index_t> lookupInputChannels_;
 
+  // Used to decode and check if any probe-side input key or condition columns
+  // have nulls.
+  std::vector<std::unique_ptr<VectorHasher>> lookupKeyOrConditionHashers_;
+
   // The input batches to process with ranges pointed by 'startBatchIndex_' and
   // 'endBatchIndex_'.
   std::vector<InputBatchState> inputBatches_;
@@ -227,6 +316,7 @@ class IndexLookupJoin : public Operator {
   // Used to project output columns from the probe input and lookup output.
   std::vector<IdentityProjection> probeOutputProjections_;
   std::vector<IdentityProjection> lookupOutputProjections_;
+  std::optional<column_index_t> matchOutputChannel_;
 
   std::shared_ptr<connector::IndexSource> indexSource_;
 
@@ -253,8 +343,28 @@ class IndexLookupJoin : public Operator {
   BufferPtr lookupOutputNulls_;
   uint64_t* rawLookupOutputNulls_{nullptr};
 
+  // Join filter.
+  std::unique_ptr<ExprSet> filter_;
+
+  // Join filter input type.
+  RowTypePtr filterInputType_;
+
+  // Maps probe-side input channels to channels in 'filterInputType_'.
+  std::vector<IdentityProjection> filterProbeInputProjections_;
+  // Maps lookup-side input channels to channels in 'filterInputType_',
+  std::vector<IdentityProjection> filterLookupInputProjections_;
+
+  // Reusable memory for filter evaluations.
+  RowVectorPtr filterInput_;
+  SelectivityVector filterRows_;
+  std::vector<VectorPtr> filterResult_;
+  DecodedVector decodedFilterResult_;
+  BufferPtr filteredIndices_;
+
   // The reusable output vector for the join output.
   RowVectorPtr output_;
+  FlatVectorPtr<bool> matchColumn_{nullptr};
+  uint64_t* rawMatchValues_{nullptr};
 
   // The start time of the current lookup driver block wait, and reset after the
   // driver wait completes.
diff --git a/velox/exec/Limit.cpp b/velox/exec/Limit.cpp
index adab0530b30d..0ed5bbf73861 100644
--- a/velox/exec/Limit.cpp
+++ b/velox/exec/Limit.cpp
@@ -37,6 +37,10 @@ Limit::Limit(
   }
 }
 
+bool Limit::startDrain() {
+  return false;
+}
+
 bool Limit::needsInput() const {
   return !finished_ && input_ == nullptr;
 }
@@ -47,15 +51,19 @@ void Limit::addInput(RowVectorPtr input) {
 }
 
 RowVectorPtr Limit::getOutput() {
-  if (input_ == nullptr || (remainingOffset_ == 0 && remainingLimit_ == 0)) {
+  VELOX_DCHECK(!isDraining());
+
+  if ((input_ == nullptr) || (remainingOffset_ == 0 && remainingLimit_ == 0)) {
     return nullptr;
   }
 
+  SCOPE_EXIT {
+    input_ = nullptr;
+  };
   const auto inputSize = input_->size();
 
   if (remainingOffset_ >= inputSize) {
     remainingOffset_ -= inputSize;
-    input_ = nullptr;
     return nullptr;
   }
 
@@ -71,7 +79,6 @@ RowVectorPtr Limit::getOutput() {
     auto output = fillOutput(outputSize, indices);
     remainingOffset_ = 0;
     remainingLimit_ -= outputSize;
-    input_ = nullptr;
     if (remainingLimit_ == 0) {
       finished_ = true;
     }
@@ -85,7 +92,6 @@ RowVectorPtr Limit::getOutput() {
   if (remainingLimit_ >= inputSize) {
     remainingLimit_ -= inputSize;
     auto output = input_;
-    input_.reset();
     return output;
   }
 
@@ -95,7 +101,6 @@ RowVectorPtr Limit::getOutput() {
       input_->nulls(),
       remainingLimit_,
       input_->children());
-  input_.reset();
   remainingLimit_ = 0;
   return output;
 }
diff --git a/velox/exec/Limit.h b/velox/exec/Limit.h
index 7e38eda64090..24a5c00fc508 100644
--- a/velox/exec/Limit.h
+++ b/velox/exec/Limit.h
@@ -28,6 +28,8 @@ class Limit : public Operator {
 
   void addInput(RowVectorPtr input) override;
 
+  bool startDrain() override;
+
   RowVectorPtr getOutput() override;
 
   BlockingReason isBlocked(ContinueFuture* /*future*/) override {
diff --git a/velox/exec/LocalPartition.cpp b/velox/exec/LocalPartition.cpp
index 1fbce8b8960c..ec682dabf59f 100644
--- a/velox/exec/LocalPartition.cpp
+++ b/velox/exec/LocalPartition.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/exec/LocalPartition.h"
+#include "velox/common/Casts.h"
 #include "velox/exec/Task.h"
 #include "velox/vector/EncodedVectorCopy.h"
 
@@ -420,6 +421,7 @@ RowVectorPtr LocalPartition::wrapChildren(
 void LocalPartition::copy(
     const RowVectorPtr& input,
     const folly::Range<const BaseVector::CopyRange*>& ranges,
+    const size_t partition,
     VectorPtr& target) {
   if (ranges.empty()) {
     return;
@@ -432,57 +434,153 @@ void LocalPartition::copy(
   }
 
   if (!target) {
-    target = BaseVector::create<RowVector>(outputType_, 0, pool());
+    target = getOrCreateVector(partition);
   }
   target->resize(target->size() + ranges.size());
   target->copyRanges(input.get(), ranges);
 }
 
-RowVectorPtr LocalPartition::processPartition(
+VectorPtr LocalPartition::getOrCreateVector(const size_t partition) {
+  auto reusable = queues_[partition]->getVector();
+  if (reusable) {
+    VELOX_CHECK_EQ(reusable->type(), outputType_);
+    reusable->unsafeResize(0);
+    for (auto i = 0; i < reusable->childrenSize(); ++i) {
+      reusable->childAt(i) = nullptr;
+    }
+    return reusable;
+  } else {
+    return BaseVector::create<RowVector>(outputType_, 0, pool());
+  }
+}
+
+void LocalPartition::populatePartitionBuffer(
     const RowVectorPtr& input,
-    vector_size_t size,
-    int partition,
-    const BufferPtr& indices,
-    const vector_size_t* rawIndices) {
+    const vector_size_t numPartitionRows,
+    const size_t partition,
+    const vector_size_t* rawIndices,
+    uint64_t& totalPartitionBufferSizeExcludingString,
+    uint64_t& totalPartitionStringBufferSize) {
+  VELOX_CHECK_GT(singlePartitionBufferSize_, 0);
+  copyRanges_.resize(numPartitionRows);
+
+  auto& partitionBuffer = partitionBuffers_[partition];
+  auto targetIndex = 0;
+  if (partitionBuffer) {
+    targetIndex = partitionBuffer->size();
+  }
+  for (int i = 0; i < numPartitionRows; i++) {
+    copyRanges_[i] = {rawIndices[i], targetIndex, 1};
+    targetIndex++;
+  }
+
+  copy(input, copyRanges_, partition, partitionBuffer);
+
+  if (partitionBuffer) {
+    uint64_t stringBufferSize{0};
+    auto totalSize = partitionBuffer->retainedSize(stringBufferSize);
+    totalPartitionBufferSizeExcludingString += totalSize - stringBufferSize;
+    totalPartitionStringBufferSize += stringBufferSize;
+  }
+}
+
+RowVectorPtr LocalPartition::createPartition(
+    const RowVectorPtr& input,
+    const vector_size_t numPartitionRows,
+    const size_t partition,
+    const BufferPtr& indices) {
   RowVectorPtr partitionData{nullptr};
   if (singlePartitionBufferSize_ > 0) {
-    if (partitionBuffers_.empty()) {
-      partitionBuffers_.resize(numPartitions_);
-    }
-    if (copyRanges_.size() < size) {
-      copyRanges_.resize(size);
-    }
-
     auto& partitionBuffer = partitionBuffers_[partition];
-    auto targetIndex = 0;
     if (partitionBuffer) {
-      targetIndex = partitionBuffer->size();
-    }
-    for (int i = 0; i < size; i++) {
-      copyRanges_[i] = {rawIndices[i], targetIndex, 1};
-      targetIndex++;
+      partitionData =
+          checkedPointerCast<RowVector, BaseVector>(partitionBuffer);
+      partitionBuffers_[partition] = nullptr;
     }
+  } else if (numPartitionRows > 0) {
+    partitionData = wrapChildren(
+        input, numPartitionRows, indices, queues_[partition]->getVector());
+  }
+  return partitionData;
+}
 
-    copy(
-        input,
-        folly::Range{copyRanges_.data(), static_cast<size_t>(size)},
-        partitionBuffer);
-
-    if (partitionBuffer &&
-        partitionBuffer->retainedSize() >= singlePartitionBufferSize_) {
-      partitionData = std::dynamic_pointer_cast<RowVector>(partitionBuffer);
-      VELOX_CHECK(partitionData);
-      partitionBuffers_[partition] = nullptr;
+void LocalPartition::populateAndEnqueuePartitions(
+    RowVectorPtr input,
+    const std::vector<vector_size_t>& numRowsPerPartition,
+    const std::vector<BufferPtr>& indexBuffers,
+    const std::vector<vector_size_t*>& rawIndicesBuffers) {
+  uint64_t totalPartitionBufferSizeExcludingString = 0;
+  uint64_t totalPartitionStringBufferSize = 0;
+  uint16_t nonEmptyPartitionCount = 0;
+
+  // Populate partition buffers if in buffer mode.
+  if (singlePartitionBufferSize_ > 0) {
+    if (partitionBuffers_.empty()) {
+      partitionBuffers_.resize(numPartitions_);
+    }
+    for (auto partition = 0; partition < numPartitions_; partition++) {
+      populatePartitionBuffer(
+          input,
+          numRowsPerPartition[partition],
+          partition,
+          rawIndicesBuffers[partition],
+          totalPartitionBufferSizeExcludingString,
+          totalPartitionStringBufferSize);
+      if (partitionBuffers_[partition]) {
+        nonEmptyPartitionCount++;
+      }
     }
   } else {
-    partitionData =
-        wrapChildren(input, size, indices, queues_[partition]->getVector());
+    nonEmptyPartitionCount = numPartitions_ -
+        std::count(numRowsPerPartition.begin(), numRowsPerPartition.end(), 0);
+  }
+  VELOX_CHECK_GT(
+      nonEmptyPartitionCount,
+      0,
+      "Input rows should be assigned to at least one partition");
+
+  // Calculate the partition buffer size across all partitions with amortized
+  // string buffer sizes.
+  auto balancedTotalPartitionBufferSize =
+      totalPartitionBufferSizeExcludingString +
+      (totalPartitionStringBufferSize / nonEmptyPartitionCount);
+  auto inputRetainedSize = input->retainedSize();
+
+  // Enqueue all partitions if one of the following conditions is met:
+  // 1. This operator is not in buffer mode.
+  // 2. This operator is in buffer mode and the total buffer size across all
+  // partitions exceeds 'singlePartitionBufferSize_ * numPartitions_'.
+  if (singlePartitionBufferSize_ == 0 ||
+      balancedTotalPartitionBufferSize >=
+          singlePartitionBufferSize_ * numPartitions_) {
+    auto perPartitionAmortizedSize =
+        (singlePartitionBufferSize_ > 0 ? balancedTotalPartitionBufferSize
+                                        : inputRetainedSize) /
+        nonEmptyPartitionCount;
+    for (auto partition = 0; partition < numPartitions_; partition++) {
+      auto partitionSize = numRowsPerPartition[partition];
+      auto partitionData = createPartition(
+          input, partitionSize, partition, indexBuffers[partition]);
+      if (!partitionData) {
+        continue;
+      }
+
+      ContinueFuture future;
+      auto reason = queues_[partition]->enqueue(
+          std::move(partitionData), perPartitionAmortizedSize, &future);
+      if (reason != BlockingReason::kNotBlocked) {
+        blockingReasons_.push_back(reason);
+        futures_.push_back(std::move(future));
+      }
+    }
   }
-  return partitionData;
 }
 
 void LocalPartition::addInput(RowVectorPtr input) {
   prepareForInput(input);
+  if (input->size() == 0) {
+    return;
+  }
 
   const auto singlePartition = numPartitions_ == 1
       ? 0
@@ -512,31 +610,7 @@ void LocalPartition::addInput(RowVectorPtr input) {
     ++maxIndex[partition];
   }
 
-  const int64_t totalSize = input->retainedSize();
-  for (auto partition = 0; partition < numPartitions_; partition++) {
-    auto partitionSize = maxIndex[partition];
-    if (partitionSize == 0) {
-      // Do not enqueue empty partitions.
-      continue;
-    }
-
-    auto partitionData = processPartition(
-        input,
-        partitionSize,
-        partition,
-        indexBuffers_[partition],
-        rawIndices_[partition]);
-
-    if (partitionData) {
-      ContinueFuture future;
-      auto reason = queues_[partition]->enqueue(
-          partitionData, totalSize * partitionSize / numInput, &future);
-      if (reason != BlockingReason::kNotBlocked) {
-        blockingReasons_.push_back(reason);
-        futures_.push_back(std::move(future));
-      }
-    }
-  }
+  populateAndEnqueuePartitions(input, maxIndex, indexBuffers_, rawIndices_);
 }
 
 void LocalPartition::prepareForInput(RowVectorPtr& input) {
@@ -566,19 +640,36 @@ BlockingReason LocalPartition::isBlocked(ContinueFuture* future) {
 void LocalPartition::noMoreInput() {
   Operator::noMoreInput();
   if (!partitionBuffers_.empty()) {
+    uint64_t totalPartitionBufferSizeExcludingString = 0;
+    uint64_t totalPartitionStringBufferSize = 0;
+    uint16_t nonEmptyPartitionCount = 0;
     for (auto partition = 0; partition < numPartitions_; partition++) {
-      if (partitionBuffers_[partition] &&
-          partitionBuffers_[partition]->size() > 0) {
-        auto partitionData =
-            std::dynamic_pointer_cast<RowVector>(partitionBuffers_[partition]);
-        VELOX_CHECK(partitionData);
-        ContinueFuture future;
-        queues_[partition]->enqueue(
-            partitionData,
-            partitionBuffers_[partition]->retainedSize(),
-            &future);
+      if (partitionBuffers_[partition]) {
+        uint64_t stringBufferSize{0};
+        auto totalSize =
+            partitionBuffers_[partition]->retainedSize(stringBufferSize);
+        totalPartitionBufferSizeExcludingString += totalSize - stringBufferSize;
+        totalPartitionStringBufferSize += stringBufferSize;
+        nonEmptyPartitionCount++;
+      }
+    }
+    if (nonEmptyPartitionCount > 0) {
+      auto balancedPartitionBufferSize =
+          totalPartitionBufferSizeExcludingString +
+          (totalPartitionStringBufferSize / nonEmptyPartitionCount);
+      for (auto partition = 0; partition < numPartitions_; partition++) {
+        if (partitionBuffers_[partition]) {
+          auto partitionData = checkedPointerCast<RowVector, BaseVector>(
+              partitionBuffers_[partition]);
+          ContinueFuture future;
+
+          queues_[partition]->enqueue(
+              partitionData,
+              balancedPartitionBufferSize / nonEmptyPartitionCount,
+              &future);
+        }
+        partitionBuffers_[partition] = nullptr;
       }
-      partitionBuffers_[partition] = nullptr;
     }
     partitionBuffers_.resize(0);
     copyRanges_.resize(0);
diff --git a/velox/exec/LocalPartition.h b/velox/exec/LocalPartition.h
index bdf7ab42df5e..f2b1da8de504 100644
--- a/velox/exec/LocalPartition.h
+++ b/velox/exec/LocalPartition.h
@@ -240,12 +240,21 @@ class LocalPartition : public Operator {
 
   void allocateIndexBuffers(const std::vector<vector_size_t>& sizes);
 
-  RowVectorPtr processPartition(
-      const RowVectorPtr& input,
-      vector_size_t size,
-      int partition,
-      const BufferPtr& indices,
-      const vector_size_t* rawIndices);
+  /// Create partitions from 'input' according to 'numRowsPerPartition' and
+  /// 'indexBuffers', and enqueue the partitions to LocalExchangeQueues. The
+  /// behavior of partition vector creation varies depending on
+  /// 'singlePartitionBufferSize_'. If 'singlePartitionBufferSize_' is non-zero,
+  /// append rows from 'input' to 'partitionBuffers_' for every partition. When
+  /// the total size of all partition buffer vectors exceeds
+  /// 'singlePartitionBufferSize_ * numPartitions_', flush all partitionBuffers_
+  /// vectors to LocalExchangeQueues. If 'singlePartitionBufferSize_' is zero,
+  /// create partition vectors by wrapping 'input' with indexBuffers and flush
+  /// them to LocalExchangeQueues immediately.
+  void populateAndEnqueuePartitions(
+      RowVectorPtr input,
+      const std::vector<vector_size_t>& numRowsPerPartition,
+      const std::vector<BufferPtr>& indexBuffers,
+      const std::vector<vector_size_t*>& rawIndicesBuffers);
 
   const std::vector<std::shared_ptr<LocalExchangeQueue>> queues_;
   const size_t numPartitions_;
@@ -261,6 +270,11 @@ class LocalPartition : public Operator {
   std::vector<vector_size_t*> rawIndices_;
 
  private:
+  // Try getting a reusable vector for 'partition' from the corresponding
+  // local-exchange vector pool of this partition. If none is available, create
+  // a new vector.
+  VectorPtr getOrCreateVector(const size_t partition);
+
   RowVectorPtr wrapChildren(
       const RowVectorPtr& input,
       vector_size_t size,
@@ -270,8 +284,30 @@ class LocalPartition : public Operator {
   void copy(
       const RowVectorPtr& input,
       const folly::Range<const BaseVector::CopyRange*>& ranges,
+      const size_t partition,
       VectorPtr& target);
 
+  /// Add rows from 'input' to 'partitionBuffers_' that every row belongs to.
+  /// Also set 'totalPartitionBufferSizeExcludingString' to be the total size of
+  /// all partition buffer vectors excluding string buffers inside them, and set
+  /// 'totalPartitionStringBufferSize' to be the total size of all string
+  /// buffers in all partition buffer vectors.
+  void populatePartitionBuffer(
+      const RowVectorPtr& input,
+      const vector_size_t numPartitionRows,
+      const size_t partition,
+      const vector_size_t* rawIndices,
+      uint64_t& totalPartitionBufferSizeExcludingString,
+      uint64_t& totalPartitionStringBufferSize);
+
+  /// Return the partition vector to be added to LocalExchangeQueue. This method
+  /// returns nullptr if no row belongs to 'partition'
+  RowVectorPtr createPartition(
+      const RowVectorPtr& input,
+      const vector_size_t numPartitionRows,
+      const size_t partition,
+      const BufferPtr& indices);
+
   const uint64_t singlePartitionBufferSize_;
   std::vector<BaseVector::CopyRange> copyRanges_;
   std::vector<VectorPtr> partitionBuffers_;
diff --git a/velox/exec/LocalPlanner.cpp b/velox/exec/LocalPlanner.cpp
index ae0361d3a8e7..10525a92917e 100644
--- a/velox/exec/LocalPlanner.cpp
+++ b/velox/exec/LocalPlanner.cpp
@@ -35,10 +35,13 @@
 #include "velox/exec/NestedLoopJoinProbe.h"
 #include "velox/exec/OperatorTraceScan.h"
 #include "velox/exec/OrderBy.h"
+#include "velox/exec/ParallelProject.h"
 #include "velox/exec/PartitionedOutput.h"
 #include "velox/exec/RoundRobinPartitionFunction.h"
 #include "velox/exec/RowNumber.h"
 #include "velox/exec/ScaleWriterLocalPartition.h"
+#include "velox/exec/SpatialJoinBuild.h"
+#include "velox/exec/SpatialJoinProbe.h"
 #include "velox/exec/StreamingAggregation.h"
 #include "velox/exec/TableScan.h"
 #include "velox/exec/TableWriteMerge.h"
@@ -121,7 +124,10 @@ OperatorSupplier makeOperatorSupplier(
           std::dynamic_pointer_cast<const core::LocalMergeNode>(planNode)) {
     return [localMerge](int32_t operatorId, DriverCtx* ctx) {
       auto mergeSource = ctx->task->addLocalMergeSource(
-          ctx->splitGroupId, localMerge->id(), localMerge->outputType());
+          ctx->splitGroupId,
+          localMerge->id(),
+          localMerge->outputType(),
+          ctx->queryConfig().localMergeSourceQueueSize());
       auto consumerCb =
           [mergeSource](
               RowVectorPtr input, bool drained, ContinueFuture* future) {
@@ -160,7 +166,7 @@ OperatorSupplier makeOperatorSupplier(
         VELOX_UNSUPPORTED(
             "Hash join currently does not support mixed grouped execution for join "
             "type {}",
-            core::joinTypeName(join->joinType()));
+            core::JoinTypeName::toName(join->joinType()));
       }
       return std::make_unique<HashBuild>(operatorId, ctx, join);
     };
@@ -173,6 +179,13 @@ OperatorSupplier makeOperatorSupplier(
     };
   }
 
+  if (auto join =
+          std::dynamic_pointer_cast<const core::SpatialJoinNode>(planNode)) {
+    return [join](int32_t operatorId, DriverCtx* ctx) {
+      return std::make_unique<SpatialJoinBuild>(operatorId, ctx, join);
+    };
+  }
+
   if (auto join =
           std::dynamic_pointer_cast<const core::MergeJoinNode>(planNode)) {
     auto planNodeId = planNode->id();
@@ -190,7 +203,15 @@ OperatorSupplier makeOperatorSupplier(
               return source->enqueue(std::move(input), future);
             }
           };
-      return std::make_unique<CallbackSink>(operatorId, ctx, consumer);
+      // NOTE: Pass planNodeId to associate CallbackSink with the MergeJoin
+      // node for proper operator identification and input collection.
+      // Operator::maybeSetTracer() uses this to enable tracing.
+      return std::make_unique<CallbackSink>(
+          operatorId,
+          ctx,
+          consumer,
+          nullptr,
+          ctx->queryConfig().queryTraceEnabled() ? planNodeId : "N/A");
     };
   }
 
@@ -204,10 +225,11 @@ void plan(
     OperatorSupplier operatorSupplier,
     std::vector<std::unique_ptr<DriverFactory>>* driverFactories) {
   if (!currentPlanNodes) {
-    driverFactories->push_back(std::make_unique<DriverFactory>());
-    currentPlanNodes = &driverFactories->back()->planNodes;
-    driverFactories->back()->operatorSupplier = std::move(operatorSupplier);
-    driverFactories->back()->consumerNode = consumerNode;
+    auto driverFactory = std::make_unique<DriverFactory>();
+    currentPlanNodes = &driverFactory->planNodes;
+    driverFactory->operatorSupplier = std::move(operatorSupplier);
+    driverFactory->consumerNode = consumerNode;
+    driverFactories->push_back(std::move(driverFactory));
   }
 
   const auto& sources = planNode->sources();
@@ -298,8 +320,9 @@ uint32_t maxDrivers(
       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()) {
+      // Null-aware right semi project doesn't support multi-threaded
+      // execution.
+      if (join->isRightSemiProjectJoin() && join->isNullAware()) {
         return 1;
       }
     } else if (
@@ -351,7 +374,7 @@ void LocalPlanner::plan(
       planFragment.planNode,
       nullptr,
       nullptr,
-      detail::makeOperatorSupplier(consumerSupplier),
+      detail::makeOperatorSupplier(std::move(consumerSupplier)),
       driverFactories);
 
   (*driverFactories)[0]->outputDriver = true;
@@ -401,14 +424,14 @@ void LocalPlanner::determineGroupedExecutionPipelines(
       size_t numGroupedExecutionSources{0};
       for (const auto& sourceNode : localPartitionNode->sources()) {
         for (auto& anotherFactory : driverFactories) {
-          if (sourceNode == anotherFactory->planNodes.back() and
+          if (sourceNode == anotherFactory->planNodes.back() &&
               anotherFactory->groupedExecution) {
             ++numGroupedExecutionSources;
             break;
           }
         }
       }
-      if (numGroupedExecutionSources > 0 and
+      if (numGroupedExecutionSources > 0 &&
           numGroupedExecutionSources == localPartitionNode->sources().size()) {
         factory->groupedExecution = true;
       }
@@ -456,6 +479,11 @@ void LocalPlanner::markMixedJoinBridges(
             break;
           }
         }
+      } else if (
+          auto spatialJoinNode =
+              std::dynamic_pointer_cast<const core::SpatialJoinNode>(
+                  planNode)) {
+        VELOX_FAIL("Spatial joins do not support grouped execution.");
       }
     }
   }
@@ -464,6 +492,7 @@ void LocalPlanner::markMixedJoinBridges(
 std::shared_ptr<Driver> DriverFactory::createDriver(
     std::unique_ptr<DriverCtx> ctx,
     std::shared_ptr<ExchangeClient> exchangeClient,
+    std::shared_ptr<PipelinePushdownFilters> filters,
     std::function<int(int pipelineId)> numDrivers) {
   auto driver = std::shared_ptr<Driver>(new Driver());
   ctx->driver = driver.get();
@@ -481,8 +510,9 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto next = planNodes[i + 1];
         if (auto projectNode =
                 std::dynamic_pointer_cast<const core::ProjectNode>(next)) {
-          operators.push_back(std::make_unique<FilterProject>(
-              id, ctx.get(), filterNode, projectNode));
+          operators.push_back(
+              std::make_unique<FilterProject>(
+                  id, ctx.get(), filterNode, projectNode));
           i++;
           continue;
         }
@@ -494,6 +524,12 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
             std::dynamic_pointer_cast<const core::ProjectNode>(planNode)) {
       operators.push_back(
           std::make_unique<FilterProject>(id, ctx.get(), nullptr, projectNode));
+    } else if (
+        auto projectNode =
+            std::dynamic_pointer_cast<const core::ParallelProjectNode>(
+                planNode)) {
+      operators.push_back(
+          std::make_unique<ParallelProject>(id, ctx.get(), projectNode));
     } else if (
         auto valuesNode =
             std::dynamic_pointer_cast<const core::ValuesNode>(planNode)) {
@@ -517,8 +553,9 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto tableWriteMergeNode =
             std::dynamic_pointer_cast<const core::TableWriteMergeNode>(
                 planNode)) {
-      operators.push_back(std::make_unique<TableWriteMerge>(
-          id, ctx.get(), tableWriteMergeNode));
+      operators.push_back(
+          std::make_unique<TableWriteMerge>(
+              id, ctx.get(), tableWriteMergeNode));
     } else if (
         auto mergeExchangeNode =
             std::dynamic_pointer_cast<const core::MergeExchangeNode>(
@@ -530,14 +567,16 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
             std::dynamic_pointer_cast<const core::ExchangeNode>(planNode)) {
       // NOTE: the exchange client can only be used by one operator in a driver.
       VELOX_CHECK_NOT_NULL(exchangeClient);
-      operators.push_back(std::make_unique<Exchange>(
-          id, ctx.get(), exchangeNode, std::move(exchangeClient)));
+      operators.push_back(
+          std::make_unique<Exchange>(
+              id, ctx.get(), exchangeNode, std::move(exchangeClient)));
     } else if (
         auto partitionedOutputNode =
             std::dynamic_pointer_cast<const core::PartitionedOutputNode>(
                 planNode)) {
-      operators.push_back(std::make_unique<PartitionedOutput>(
-          id, ctx.get(), partitionedOutputNode, eagerFlush(*planNode)));
+      operators.push_back(
+          std::make_unique<PartitionedOutput>(
+              id, ctx.get(), partitionedOutputNode, eagerFlush(*planNode)));
     } else if (
         auto joinNode =
             std::dynamic_pointer_cast<const core::HashJoinNode>(planNode)) {
@@ -548,6 +587,11 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
                 planNode)) {
       operators.push_back(
           std::make_unique<NestedLoopJoinProbe>(id, ctx.get(), joinNode));
+    } else if (
+        auto spatialJoinNode =
+            std::dynamic_pointer_cast<const core::SpatialJoinNode>(planNode)) {
+      operators.push_back(
+          std::make_unique<SpatialJoinProbe>(id, ctx.get(), spatialJoinNode));
     } else if (
         auto joinNode =
             std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(
@@ -558,8 +602,9 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto aggregationNode =
             std::dynamic_pointer_cast<const core::AggregationNode>(planNode)) {
       if (aggregationNode->isPreGrouped()) {
-        operators.push_back(std::make_unique<StreamingAggregation>(
-            id, ctx.get(), aggregationNode));
+        operators.push_back(
+            std::make_unique<StreamingAggregation>(
+                id, ctx.get(), aggregationNode));
       } else {
         operators.push_back(
             std::make_unique<HashAggregation>(id, ctx.get(), aggregationNode));
@@ -622,12 +667,13 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto localPartitionNode =
             std::dynamic_pointer_cast<const core::LocalPartitionNode>(
                 planNode)) {
-      operators.push_back(std::make_unique<LocalExchange>(
-          id,
-          ctx.get(),
-          localPartitionNode->outputType(),
-          localPartitionNode->id(),
-          ctx->partitionId));
+      operators.push_back(
+          std::make_unique<LocalExchange>(
+              id,
+              ctx.get(),
+              localPartitionNode->outputType(),
+              localPartitionNode->id(),
+              ctx->partitionId));
     } else if (
         auto unnest =
             std::dynamic_pointer_cast<const core::UnnestNode>(planNode)) {
@@ -642,17 +688,19 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
         auto assignUniqueIdNode =
             std::dynamic_pointer_cast<const core::AssignUniqueIdNode>(
                 planNode)) {
-      operators.push_back(std::make_unique<AssignUniqueId>(
-          id,
-          ctx.get(),
-          assignUniqueIdNode,
-          assignUniqueIdNode->taskUniqueId(),
-          assignUniqueIdNode->uniqueIdCounter()));
+      operators.push_back(
+          std::make_unique<AssignUniqueId>(
+              id,
+              ctx.get(),
+              assignUniqueIdNode,
+              assignUniqueIdNode->taskUniqueId(),
+              assignUniqueIdNode->uniqueIdCounter()));
     } else if (
         const auto traceScanNode =
             std::dynamic_pointer_cast<const core::TraceScanNode>(planNode)) {
-      operators.push_back(std::make_unique<trace::OperatorTraceScan>(
-          id, ctx.get(), traceScanNode));
+      operators.push_back(
+          std::make_unique<trace::OperatorTraceScan>(
+              id, ctx.get(), traceScanNode));
     } else {
       std::unique_ptr<Operator> extended;
       if (planNode->requiresExchangeClient()) {
@@ -672,6 +720,11 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
     operators.push_back(operatorSupplier(operators.size(), ctx.get()));
   }
 
+  if (filters->empty()) {
+    filters->resize(operators.size());
+  } else {
+    VELOX_CHECK_EQ(filters->size(), operators.size());
+  }
   driver->init(std::move(ctx), std::move(operators));
   for (auto& adapter : adapters) {
     if (adapter.adapt(*this, *driver)) {
@@ -679,6 +732,7 @@ std::shared_ptr<Driver> DriverFactory::createDriver(
     }
   }
   driver->isAdaptable_ = false;
+  driver->pushdownFilters_ = std::move(filters);
   return driver;
 }
 
@@ -762,6 +816,19 @@ std::vector<core::PlanNodeId> DriverFactory::needsNestedLoopJoinBridges()
   return planNodeIds;
 }
 
+std::vector<core::PlanNodeId> DriverFactory::needsSpatialJoinBridges() const {
+  std::vector<core::PlanNodeId> planNodeIds;
+  for (const auto& planNode : planNodes) {
+    if (auto joinNode =
+            std::dynamic_pointer_cast<const core::SpatialJoinNode>(planNode)) {
+      // Grouped execution pipelines should not create cross-mode bridges.
+      planNodeIds.emplace_back(joinNode->id());
+    }
+  }
+
+  return planNodeIds;
+}
+
 // static
 void DriverFactory::registerAdapter(DriverAdapter adapter) {
   adapters.push_back(std::move(adapter));
diff --git a/velox/exec/MemoryReclaimer.cpp b/velox/exec/MemoryReclaimer.cpp
index 4aee429883db..1837da7881b9 100644
--- a/velox/exec/MemoryReclaimer.cpp
+++ b/velox/exec/MemoryReclaimer.cpp
@@ -108,9 +108,10 @@ uint64_t ParallelMemoryReclaimer::reclaim(
         if (!reclaimableBytesOpt.has_value()) {
           continue;
         }
-        candidates.push_back(Candidate{
-            std::move(child),
-            static_cast<int64_t>(reclaimableBytesOpt.value())});
+        candidates.push_back(
+            Candidate{
+                std::move(child),
+                static_cast<int64_t>(reclaimableBytesOpt.value())});
       }
     }
   }
@@ -134,21 +135,23 @@ uint64_t ParallelMemoryReclaimer::reclaim(
     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());
-          }
-        }));
+    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(); });
     }
diff --git a/velox/exec/Merge.cpp b/velox/exec/Merge.cpp
index 51b46fdcaca7..fda9deb44cc0 100644
--- a/velox/exec/Merge.cpp
+++ b/velox/exec/Merge.cpp
@@ -15,25 +15,15 @@
  */
 
 #include "velox/exec/Merge.h"
+#include <folly/Traits.h>
+#include <exception>
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
-namespace {
-std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
-    const core::QueryConfig& queryConfig,
-    VectorSerde::Kind kind) {
-  std::unique_ptr<VectorSerde::Options> options =
-      kind == VectorSerde::Kind::kPresto
-      ? std::make_unique<serializer::presto::PrestoVectorSerde::PrestoOptions>()
-      : std::make_unique<VectorSerde::Options>();
-  options->compressionKind =
-      common::stringToCompressionKind(queryConfig.shuffleCompressionKind());
-  return options;
-}
-} // namespace
 
 Merge::Merge(
     int32_t operatorId,
@@ -43,47 +33,42 @@ Merge::Merge(
         sortingKeys,
     const std::vector<core::SortOrder>& sortingOrders,
     const std::string& planNodeId,
-    const std::string& operatorType)
+    const std::string& operatorType,
+    const std::optional<common::SpillConfig>& spillConfig)
     : SourceOperator(
           driverCtx,
           std::move(outputType),
           operatorId,
           planNodeId,
-          operatorType),
-      outputBatchSize_{outputBatchRows()} {
-  auto numKeys = sortingKeys.size();
-  sortingKeys_.reserve(numKeys);
-  for (int i = 0; i < numKeys; ++i) {
-    auto channel = exprToChannel(sortingKeys[i].get(), outputType_);
-    VELOX_CHECK_NE(
-        channel,
-        kConstantChannel,
-        "Merge doesn't allow constant grouping keys");
-    sortingKeys_.emplace_back(
-        channel,
-        CompareFlags{
-            sortingOrders[i].isNullsFirst(),
-            sortingOrders[i].isAscending(),
-            false});
-  }
-}
-
-void Merge::initializeTreeOfLosers() {
-  std::vector<std::unique_ptr<SourceStream>> sourceCursors;
-  sourceCursors.reserve(sources_.size());
-  for (auto& source : sources_) {
-    sourceCursors.push_back(std::make_unique<SourceStream>(
-        source.get(), sortingKeys_, outputBatchSize_));
-  }
-
-  // Save the pointers to cursors before moving these into the TreeOfLosers.
-  streams_.reserve(sources_.size());
-  for (auto& cursor : sourceCursors) {
-    streams_.push_back(cursor.get());
-  }
-
-  treeOfLosers_ =
-      std::make_unique<TreeOfLosers<SourceStream>>(std::move(sourceCursors));
+          operatorType,
+          spillConfig),
+      maxOutputBatchRows_{outputBatchRows()},
+      maxOutputBatchBytes_{
+          driverCtx->queryConfig().preferredOutputBatchBytes()},
+      sortingKeys_([&]() {
+        auto numKeys = sortingKeys.size();
+        std::vector<SpillSortKey> keys;
+        keys.reserve(numKeys);
+        for (int i = 0; i < numKeys; ++i) {
+          auto channel = exprToChannel(sortingKeys[i].get(), outputType_);
+          VELOX_CHECK_NE(
+              channel,
+              kConstantChannel,
+              "Merge doesn't allow constant grouping keys");
+          keys.emplace_back(
+              channel,
+              CompareFlags{
+                  sortingOrders[i].isNullsFirst(),
+                  sortingOrders[i].isAscending(),
+                  false});
+        }
+        return keys;
+      }()) {}
+
+void Merge::initialize() {
+  Operator::initialize();
+  VELOX_CHECK_EQ(mergeStats_.streamingSourceReadStartTimeUs, 0);
+  mergeStats_.streamingSourceReadStartTimeUs = getCurrentTimeMicro();
 }
 
 BlockingReason Merge::isBlocked(ContinueFuture* future) {
@@ -101,17 +86,10 @@ BlockingReason Merge::isBlocked(ContinueFuture* future) {
     return BlockingReason::kNotBlocked;
   }
 
-  startSources();
+  maybeStartNextMergeSourceGroup();
 
-  // No merging is needed if there is only one source.
-  if (streams_.empty() && sources_.size() > 1) {
-    initializeTreeOfLosers();
-  }
-
-  if (sourceBlockingFutures_.empty()) {
-    for (auto& cursor : streams_) {
-      cursor->isBlocked(sourceBlockingFutures_);
-    }
+  if (sourceMerger_ != nullptr) {
+    sourceMerger_->isBlocked(sourceBlockingFutures_);
   }
 
   if (sourceBlockingFutures_.empty()) {
@@ -123,25 +101,171 @@ BlockingReason Merge::isBlocked(ContinueFuture* future) {
   return BlockingReason::kWaitForProducer;
 }
 
-void Merge::startSources() {
-  VELOX_CHECK_LE(numStartedSources_, sources_.size());
-  // Start the merge source once.
-  if (numStartedSources_ >= sources_.size()) {
+bool Merge::isFinished() {
+  return finished_;
+}
+
+void Merge::maybeSetupOutputSpiller() {
+  VELOX_CHECK(canSpill());
+  VELOX_CHECK(spillConfig_.has_value());
+  if (mergeOutputSpiller_ != nullptr) {
     return;
   }
-  VELOX_CHECK_EQ(numStartedSources_, 0);
-  VELOX_CHECK(streams_.empty());
-  VELOX_CHECK(sourceBlockingFutures_.empty());
-  // TODO: support lazy start for local merge with a large number of sources
-  // to cap the memory usage.
-  for (auto& source : sources_) {
+
+  mergeOutputSpiller_ = std::make_unique<MergeSpiller>(
+      outputType_,
+      std::nullopt,
+      HashBitRange{},
+      sortingKeys_,
+      &spillConfig_.value(),
+      spillStats_.get());
+}
+
+void Merge::spill() {
+  if (output_ == nullptr) {
+    return;
+  }
+  maybeSetupOutputSpiller();
+  numSpilledRows_ += output_->size();
+  mergeOutputSpiller_->spill(SpillPartitionId{0}, output_);
+  output_ = nullptr;
+}
+
+void Merge::finishMergeSourceGroup() {
+  sourceMerger_ = nullptr;
+  if (mergeOutputSpiller_ == nullptr) {
+    return;
+  }
+  VELOX_CHECK(needSpill());
+  VELOX_CHECK_GT(numSpilledRows_, 0);
+  // Finishes spill if it has happened and setup spill merger if no more source
+  // to merge.
+  SpillPartitionSet spillPartitionSet;
+  mergeOutputSpiller_->finishSpill(spillPartitionSet);
+  mergeOutputSpiller_ = nullptr;
+  VELOX_CHECK_EQ(spillPartitionSet.size(), 1);
+  auto spillFiles = spillPartitionSet.begin()->second->files();
+  VELOX_CHECK(!spillFiles.empty());
+  spillFileGroups_.push_back(std::move(spillFiles));
+}
+
+void Merge::setupSpillMerger() {
+  VELOX_CHECK(!spillFileGroups_.empty());
+  VELOX_CHECK_NULL(spillMerger_);
+  VELOX_CHECK(spillConfig_.has_value());
+  std::vector<std::vector<std::unique_ptr<SpillReadFile>>> spillReadFilesGroups;
+  spillReadFilesGroups.reserve(spillFileGroups_.size());
+  for (const auto& spillFiles : spillFileGroups_) {
+    std::vector<std::unique_ptr<SpillReadFile>> spillReadFiles;
+    spillReadFiles.reserve(spillFiles.size());
+    for (const auto& spillFile : spillFiles) {
+      spillReadFiles.emplace_back(
+          SpillReadFile::create(
+              spillFile,
+              spillConfig_->readBufferSize,
+              pool(),
+              spillStats_.get()));
+    }
+    spillReadFilesGroups.push_back(std::move(spillReadFiles));
+  }
+  spillFileGroups_.clear();
+  spillMerger_ = std::make_shared<SpillMerger>(
+      sortingKeys_,
+      outputType_,
+      std::move(spillReadFilesGroups),
+      maxOutputBatchRows_,
+      maxOutputBatchBytes_,
+      operatorCtx_->driverCtx()->queryConfig().localMergeSourceQueueSize(),
+      &spillConfig_.value(),
+      spillStats_,
+      pool());
+  spillMerger_->start();
+}
+
+void Merge::maybeStartNextMergeSourceGroup() {
+  if (sourceMerger_ != nullptr || numStartedSources_ >= sources_.size()) {
+    return;
+  }
+
+  // Gets the merge sources for the next partial merge run.
+  std::vector<MergeSource*> sources;
+  for (auto i = numStartedSources_; i <
+       (std::min(sources_.size(), numStartedSources_ + maxNumMergeSources_));
+       ++i) {
+    sources.push_back(sources_[i].get());
+  }
+
+  // Initializes the source merger.
+  std::vector<std::unique_ptr<SourceStream>> cursors;
+  cursors.reserve(sources.size());
+  for (auto* source : sources) {
+    cursors.push_back(
+        std::make_unique<SourceStream>(
+            source, sortingKeys_, maxOutputBatchRows_));
+  }
+
+  // TODO: consider to provide a config other than the regular operator batch
+  // size to tune the batch size of the streaming source merge output as the
+  // merge operator is single threaded.
+  sourceMerger_ = std::make_unique<SourceMerger>(
+      outputType_,
+      std::move(cursors),
+      maxOutputBatchRows_,
+      maxOutputBatchBytes_,
+      pool());
+  // Start sources.
+  for (const auto& source : sources) {
     source->start();
   }
-  numStartedSources_ = sources_.size();
+  numStartedSources_ += sources.size();
 }
 
-bool Merge::isFinished() {
-  return finished_;
+RowVectorPtr Merge::getOutputFromSpill() {
+  VELOX_CHECK_NOT_NULL(spillMerger_);
+  VELOX_CHECK_NULL(sourceMerger_);
+  bool atEnd = false;
+  output_ = spillMerger_->getOutput(sourceBlockingFutures_, atEnd);
+  SCOPE_EXIT {
+    if (!atEnd) {
+      return;
+    }
+    finished_ = true;
+    VELOX_CHECK_EQ(mergeStats_.spilledSourceReadEndTimeUs, 0);
+    mergeStats_.spilledSourceReadEndTimeUs = getCurrentTimeMicro();
+  };
+  return std::move(output_);
+}
+
+RowVectorPtr Merge::getOutputFromSource() {
+  VELOX_CHECK_NULL(spillMerger_);
+  bool atEnd = false;
+  output_ = sourceMerger_->getOutput(sourceBlockingFutures_, atEnd);
+  if (needSpill()) {
+    spill();
+    VELOX_CHECK_NULL(output_);
+  }
+
+  if (!atEnd) {
+    return std::move(output_);
+  }
+
+  finishMergeSourceGroup();
+  if (numStartedSources_ < sources_.size()) {
+    VELOX_CHECK_NULL(output_);
+    return nullptr;
+  }
+
+  VELOX_CHECK_EQ(mergeStats_.streamingSourceReadEndTimeUs, 0);
+  mergeStats_.streamingSourceReadEndTimeUs = getCurrentTimeMicro();
+
+  if (numSpilledRows_ > 0) {
+    setupSpillMerger();
+    VELOX_CHECK_NULL(output_);
+    return nullptr;
+  }
+
+  finished_ = true;
+  return std::move(output_);
 }
 
 RowVectorPtr Merge::getOutput() {
@@ -149,78 +273,167 @@ RowVectorPtr Merge::getOutput() {
     return nullptr;
   }
 
-  VELOX_CHECK_EQ(numStartedSources_, sources_.size());
+  // Read from spill.
+  if (spillMerger_ != nullptr) {
+    return getOutputFromSpill();
+  }
 
-  // No merging is needed if there is only one source.
-  if (sources_.size() == 1) {
-    ContinueFuture future;
-    RowVectorPtr data;
-    auto reason = sources_[0]->next(data, &future);
-    if (reason != BlockingReason::kNotBlocked) {
-      sourceBlockingFutures_.emplace_back(std::move(future));
-      return nullptr;
+  return getOutputFromSource();
+}
+
+void Merge::close() {
+  recordMergeStats();
+  for (auto& source : sources_) {
+    source->close();
+  }
+  Operator::close();
+}
+
+void Merge::recordMergeStats() {
+  auto lockedStats = stats_.wlock();
+  if (mergeStats_.streamingSourceReadEndTimeUs > 0) {
+    VELOX_CHECK_GT(mergeStats_.streamingSourceReadStartTimeUs, 0);
+    VELOX_CHECK_GE(
+        mergeStats_.streamingSourceReadEndTimeUs,
+        mergeStats_.streamingSourceReadStartTimeUs);
+    lockedStats->addRuntimeStat(
+        kStreamingSourceReadWallNanos,
+        RuntimeCounter(
+            (mergeStats_.streamingSourceReadEndTimeUs -
+             mergeStats_.streamingSourceReadStartTimeUs) *
+                1'000,
+            RuntimeCounter::Unit::kNanos));
+  }
+  if (mergeStats_.spilledSourceReadEndTimeUs > 0) {
+    VELOX_CHECK_GT(mergeStats_.streamingSourceReadEndTimeUs, 0);
+    VELOX_CHECK_GE(
+        mergeStats_.spilledSourceReadEndTimeUs,
+        mergeStats_.streamingSourceReadEndTimeUs);
+    VELOX_CHECK_GT(numSpilledRows_, 0);
+    lockedStats->addRuntimeStat(
+        kSpilledSourceReadWallNanos,
+        RuntimeCounter(
+            (mergeStats_.spilledSourceReadEndTimeUs -
+             mergeStats_.streamingSourceReadEndTimeUs) *
+                1'000,
+            RuntimeCounter::Unit::kNanos));
+  }
+}
+
+SourceMerger::SourceMerger(
+    const RowTypePtr& type,
+    std::vector<std::unique_ptr<SourceStream>> sourceStreams,
+    vector_size_t maxOutputBatchRows,
+    uint64_t maxOutputBatchBytes,
+    velox::memory::MemoryPool* pool)
+    : type_(type),
+      maxOutputBatchRows_(maxOutputBatchRows),
+      maxOutputBatchBytes_(maxOutputBatchBytes),
+      streams_([&sourceStreams]() {
+        std::vector<SourceStream*> streams;
+        for (auto& cursor : sourceStreams) {
+          streams.push_back(cursor.get());
+        }
+        return streams;
+      }()),
+      merger_(
+          std::make_unique<TreeOfLosers<SourceStream>>(
+              std::move(sourceStreams))),
+      pool_(pool) {}
+
+void SourceMerger::isBlocked(
+    std::vector<ContinueFuture>& sourceBlockingFutures) const {
+  if (sourceBlockingFutures.empty()) {
+    for (auto* stream : streams_) {
+      stream->isBlocked(sourceBlockingFutures);
     }
+  }
+}
 
-    finished_ = data == nullptr;
-    return data;
+void SourceMerger::setOutputBatchSize() {
+  if (outputBatchRows_ != 0) {
+    return;
+  }
+  size_t numEstimations{0};
+  int64_t estimateRowSizeSum{0};
+  for (auto* stream : streams_) {
+    const auto estimateRowSize = stream->estimateRowSize();
+    if (estimateRowSize.has_value()) {
+      ++numEstimations;
+      estimateRowSizeSum += estimateRowSize.value();
+    }
   }
 
+  if (numEstimations == 0) {
+    outputBatchRows_ = maxOutputBatchRows_;
+    return;
+  }
+
+  const auto estimateRowSize =
+      std::max<vector_size_t>(1, estimateRowSizeSum / numEstimations);
+  outputBatchRows_ = std::min<vector_size_t>(
+      std::max<vector_size_t>(1, maxOutputBatchBytes_ / estimateRowSize),
+      maxOutputBatchRows_);
+}
+
+RowVectorPtr SourceMerger::getOutput(
+    std::vector<ContinueFuture>& sourceBlockingFutures,
+    bool& atEnd) {
+  VELOX_CHECK_NOT_NULL(merger_);
+  atEnd = false;
+  setOutputBatchSize();
+  VELOX_CHECK_GT(outputBatchRows_, 0);
+
   if (!output_) {
-    output_ = BaseVector::create<RowVector>(
-        outputType_, outputBatchSize_, operatorCtx_->pool());
+    output_ = BaseVector::create<RowVector>(type_, outputBatchRows_, pool_);
     for (auto& child : output_->children()) {
-      child->resize(outputBatchSize_);
+      child->resize(outputBatchRows_);
     }
   }
 
   for (;;) {
-    auto stream = treeOfLosers_->next();
+    auto stream = merger_->next();
 
     if (!stream) {
-      finished_ = true;
+      atEnd = true;
 
       // Return nullptr if there is no data.
-      if (outputSize_ == 0) {
+      if (outputRows_ == 0) {
         return nullptr;
       }
-
-      output_->resize(outputSize_);
+      output_->resize(outputRows_);
       return std::move(output_);
     }
 
-    if (stream->setOutputRow(outputSize_)) {
+    if (stream->setOutputRow(outputRows_)) {
       // The stream is at end of input batch. Need to copy out the rows before
       // fetching next batch in 'pop'.
       stream->copyToOutput(output_);
+      TestValue::adjust(
+          "facebook::velox::exec::SourceMerger::getOutput",
+          &sourceBlockingFutures);
     }
 
-    ++outputSize_;
+    ++outputRows_;
 
     // Advance the stream.
-    stream->pop(sourceBlockingFutures_);
+    stream->pop(sourceBlockingFutures);
 
-    if (outputSize_ == outputBatchSize_) {
+    if (outputRows_ == outputBatchRows_) {
       // Copy out data from all sources.
       for (auto& s : streams_) {
         s->copyToOutput(output_);
       }
-
-      outputSize_ = 0;
+      outputRows_ = 0;
       return std::move(output_);
     }
 
-    if (!sourceBlockingFutures_.empty()) {
+    if (!sourceBlockingFutures.empty()) {
       return nullptr;
     }
   }
 }
 
-void Merge::close() {
-  for (auto& source : sources_) {
-    source->close();
-  }
-}
-
 bool SourceStream::operator<(const MergeStream& other) const {
   const auto& otherCursor = static_cast<const SourceStream&>(other);
   for (auto i = 0; i < sortingKeys_.size(); ++i) {
@@ -301,6 +514,205 @@ bool SourceStream::fetchMoreData(std::vector<ContinueFuture>& futures) {
   return false;
 }
 
+SpillMerger::SpillMerger(
+    const std::vector<SpillSortKey>& sortingKeys,
+    const RowTypePtr& type,
+    std::vector<std::vector<std::unique_ptr<SpillReadFile>>>
+        spillReadFilesGroup,
+    vector_size_t maxOutputBatchRows,
+    uint64_t maxOutputBatchBytes,
+    int mergeSourceQueueSize,
+    const common::SpillConfig* spillConfig,
+    const std::shared_ptr<folly::Synchronized<common::SpillStats>>& spillStats,
+    velox::memory::MemoryPool* pool)
+    : executor_(spillConfig->executor),
+      spillStats_(spillStats),
+      pool_(pool->shared_from_this()),
+      sources_(
+          createMergeSources(spillReadFilesGroup.size(), mergeSourceQueueSize)),
+      batchStreams_(createBatchStreams(std::move(spillReadFilesGroup))),
+      // TODO: consider to provide a config other than the regular operator
+      // batch size to tune the batch size of the spilled source merge output as
+      // the merge operator is single threaded.
+      sourceMerger_(createSourceMerger(
+          sortingKeys,
+          type,
+          sources_,
+          maxOutputBatchRows,
+          maxOutputBatchBytes,
+          pool)) {}
+
+SpillMerger::~SpillMerger() {
+  sourceMerger_.reset();
+  batchStreams_.clear();
+  sources_.clear();
+}
+
+void SpillMerger::start() {
+  VELOX_CHECK_NOT_NULL(
+      executor_,
+      "SpillMerge require configure executor to run async spill file stream producer");
+  scheduleAsyncSpillFileStreamReads();
+}
+
+RowVectorPtr SpillMerger::getOutput(
+    std::vector<ContinueFuture>& sourceBlockingFutures,
+    bool& atEnd) {
+  TestValue::adjust(
+      "facebook::velox::exec::SpillMerger::getOutput", &sourceBlockingFutures);
+  sourceMerger_->isBlocked(sourceBlockingFutures);
+  if (!sourceBlockingFutures.empty()) {
+    return nullptr;
+  }
+  // SpillMerger::getOutput waits for all readers to finish, reaches EOF,
+  // and rethrows any captured error. Centralizing error propagation here
+  // helps prevent potential resource leaks.
+  auto output = sourceMerger_->getOutput(sourceBlockingFutures, atEnd);
+  if (atEnd) {
+    checkError();
+  }
+  return output;
+}
+
+std::vector<std::shared_ptr<MergeSource>> SpillMerger::createMergeSources(
+    size_t numSpillSources,
+    int queueSize) {
+  std::vector<std::shared_ptr<MergeSource>> sources;
+  sources.reserve(numSpillSources);
+  for (auto i = 0; i < numSpillSources; ++i) {
+    sources.push_back(MergeSource::createLocalMergeSource(queueSize));
+  }
+  for (const auto& source : sources) {
+    source->start();
+  }
+  return sources;
+}
+
+std::vector<std::unique_ptr<BatchStream>> SpillMerger::createBatchStreams(
+    std::vector<std::vector<std::unique_ptr<SpillReadFile>>>
+        spillReadFilesGroup) {
+  const auto numStreams = spillReadFilesGroup.size();
+  std::vector<std::unique_ptr<BatchStream>> batchStreams;
+  batchStreams.reserve(numStreams);
+  for (auto i = 0; i < numStreams; ++i) {
+    batchStreams.emplace_back(
+        ConcatFilesSpillBatchStream::create(std::move(spillReadFilesGroup[i])));
+  }
+  return batchStreams;
+}
+
+std::unique_ptr<SourceMerger> SpillMerger::createSourceMerger(
+    const std::vector<SpillSortKey>& sortingKeys,
+    const RowTypePtr& type,
+    const std::vector<std::shared_ptr<MergeSource>>& sources,
+    vector_size_t maxOutputBatchRows,
+    uint64_t maxOutputBatchBytes,
+    velox::memory::MemoryPool* pool) {
+  std::vector<std::unique_ptr<SourceStream>> streams;
+  streams.reserve(sources.size());
+  for (const auto& source : sources) {
+    streams.push_back(
+        std::make_unique<SourceStream>(
+            source.get(), sortingKeys, maxOutputBatchRows));
+  }
+  return std::make_unique<SourceMerger>(
+      type, std::move(streams), maxOutputBatchRows, maxOutputBatchBytes, pool);
+}
+
+void SpillMerger::finishSource(size_t streamIdx) const {
+  ContinueFuture future{ContinueFuture::makeEmpty()};
+  sources_[streamIdx]->enqueue(nullptr, &future);
+  VELOX_CHECK(!future.valid());
+}
+
+void SpillMerger::readFromSpillFileStream(
+    const std::weak_ptr<SpillMerger>& mergeHolder,
+    size_t streamIdx) {
+  TestValue::adjust(
+      "facebook::velox::exec::SpillMerger::readFromSpillFileStream", nullptr);
+  const auto merger = mergeHolder.lock();
+  if (merger == nullptr) {
+    LOG(ERROR) << "SpillMerger is destroyed, abandon reading from batch stream";
+    return;
+  }
+
+  try {
+    if (hasError()) {
+      finishSource(streamIdx);
+      return;
+    }
+
+    RowVectorPtr vector;
+    if (!batchStreams_[streamIdx]->nextBatch(vector)) {
+      VELOX_CHECK_NULL(vector);
+      finishSource(streamIdx);
+      return;
+    }
+
+    ContinueFuture future{ContinueFuture::makeEmpty()};
+    const auto blockingReason =
+        sources_[streamIdx]->enqueue(std::move(vector), &future);
+    if (blockingReason == BlockingReason::kNotBlocked) {
+      VELOX_CHECK(!future.valid());
+      readFromSpillFileStream(mergeHolder, streamIdx);
+    } else {
+      VELOX_CHECK(future.valid());
+      std::move(future)
+          .via(executor_)
+          .thenValue([this, mergeHolder, streamIdx](auto&&) {
+            readFromSpillFileStream(mergeHolder, streamIdx);
+          })
+          .thenError(
+              folly::tag_t<std::exception>{},
+              [this, mergeHolder, streamIdx](const std::exception& e) {
+                const auto merger = mergeHolder.lock();
+                if (merger != nullptr) {
+                  LOG(ERROR) << "Stop the " << streamIdx
+                             << " th source on error: " << e.what();
+                  setError(std::make_exception_ptr(e));
+                  finishSource(streamIdx);
+                }
+              });
+    }
+  } catch (const std::exception& e) {
+    LOG(ERROR) << "The " << streamIdx
+               << " spill stream failed with error: " << e.what();
+    setError(std::current_exception());
+    finishSource(streamIdx);
+  }
+}
+
+void SpillMerger::scheduleAsyncSpillFileStreamReads() {
+  VELOX_CHECK_EQ(batchStreams_.size(), sources_.size());
+  for (auto i = 0; i < batchStreams_.size(); ++i) {
+    executor_->add([&, streamIdx = i]() {
+      readFromSpillFileStream(std::weak_ptr(shared_from_this()), streamIdx);
+    });
+  }
+}
+
+void SpillMerger::setError(const std::exception_ptr& exception) {
+  std::lock_guard l(mutex_);
+  if (exception_ != nullptr) {
+    return;
+  }
+  exception_ = exception;
+}
+
+bool SpillMerger::hasError() const {
+  std::lock_guard l(mutex_);
+  return exception_ != nullptr;
+}
+
+void SpillMerger::checkError() {
+  if (hasError()) {
+    sourceMerger_.reset();
+    batchStreams_.clear();
+    sources_.clear();
+    std::rethrow_exception(exception_);
+  }
+}
+
 LocalMerge::LocalMerge(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -312,11 +724,22 @@ LocalMerge::LocalMerge(
           localMergeNode->sortingKeys(),
           localMergeNode->sortingOrders(),
           localMergeNode->id(),
-          "LocalMerge") {
+          "LocalMerge",
+          localMergeNode->canSpill(driverCtx->queryConfig())
+              ? driverCtx->makeSpillConfig(operatorId)
+              : std::nullopt) {
   VELOX_CHECK_EQ(
       operatorCtx_->driverCtx()->driverId,
       0,
       "LocalMerge needs to run single-threaded");
+  // Enable local merge spill iff spill is enabled and the spill executor is
+  // provided.
+  if (spillConfig_.has_value() && spillConfig_->executor != nullptr) {
+    maxNumMergeSources_ = operatorCtx_->task()
+                              ->queryCtx()
+                              ->queryConfig()
+                              .localMergeMaxNumMergeSources();
+  }
 }
 
 BlockingReason LocalMerge::addMergeSources(ContinueFuture* /* future */) {
@@ -341,7 +764,8 @@ MergeExchange::MergeExchange(
           "MergeExchange"),
       serde_(getNamedVectorSerde(mergeExchangeNode->serdeKind())),
       serdeOptions_(getVectorSerdeOptions(
-          driverCtx->queryConfig(),
+          common::stringToCompressionKind(
+              driverCtx->queryConfig().shuffleCompressionKind()),
           mergeExchangeNode->serdeKind())) {}
 
 BlockingReason MergeExchange::addMergeSources(ContinueFuture* future) {
@@ -386,13 +810,14 @@ BlockingReason MergeExchange::addMergeSources(ContinueFuture* future) {
             operatorCtx_->planNodeId(),
             operatorCtx_->driverCtx()->pipelineId,
             remoteSourceIndex);
-        sources_.emplace_back(MergeSource::createMergeExchangeSource(
-            this,
-            remoteSourceTaskIds_[remoteSourceIndex],
-            operatorCtx_->task()->destination(),
-            maxQueuedBytesPerSource,
-            pool,
-            operatorCtx_->task()->queryCtx()->executor()));
+        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.
diff --git a/velox/exec/Merge.h b/velox/exec/Merge.h
index 841988d5f799..b688b42cf268 100644
--- a/velox/exec/Merge.h
+++ b/velox/exec/Merge.h
@@ -15,14 +15,17 @@
  */
 #pragma once
 
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/exec/Exchange.h"
 #include "velox/exec/MergeSource.h"
 #include "velox/exec/Spill.h"
-#include "velox/exec/TreeOfLosers.h"
+#include "velox/exec/Spiller.h"
 
 namespace facebook::velox::exec {
 
 class SourceStream;
+class SourceMerger;
+class SpillMerger;
 
 // Merge operator Implementation: This implementation uses priority queue
 // to perform a k-way merge of its inputs. It stops merging if any one of
@@ -37,7 +40,10 @@ class Merge : public SourceOperator {
           sortingKeys,
       const std::vector<core::SortOrder>& sortingOrders,
       const std::string& planNodeId,
-      const std::string& operatorType);
+      const std::string& operatorType,
+      const std::optional<common::SpillConfig>& spillConfig = std::nullopt);
+
+  void initialize() override;
 
   BlockingReason isBlocked(ContinueFuture* future) override;
 
@@ -51,39 +57,132 @@ class Merge : public SourceOperator {
     return outputType_;
   }
 
+  /// The name of runtime stats specific to merge.
+  /// The running wall time of the merge operator reading from the streaming
+  /// source. If spilling is enabled for local merge, this also includes the
+  /// time that writes to the spilled source.
+  static inline const std::string kStreamingSourceReadWallNanos{
+      "streamingSourceReadWallNanos"};
+  /// The running wall time of the merge operator reading from the spilled
+  /// source to produce the final output. This only applies when spilling is
+  /// enabled for local merge.
+  static inline const std::string kSpilledSourceReadWallNanos{
+      "spilledSourceReadWallNanos"};
+
  protected:
   virtual BlockingReason addMergeSources(ContinueFuture* future) = 0;
 
   std::vector<std::shared_ptr<MergeSource>> sources_;
   size_t numStartedSources_{0};
+  /// Maximum number of merge sources per run.
+  uint32_t maxNumMergeSources_{std::numeric_limits<uint32_t>::max()};
 
  private:
-  void startSources();
+  // Tracks the internal execution stats for a merge operator.
+  struct Stats {
+    // The time point that a merge operator starts reading from the streaming
+    // source.
+    uint64_t streamingSourceReadStartTimeUs{0};
+    // The time point that a merge operator finishes read from the streaming
+    // source. This includes the time that writes to the spilled source for
+    // recursive merge when spilling is enabled for local merge.
+    uint64_t streamingSourceReadEndTimeUs{0};
+    // The time point that a merge operator finishes read from the spilled
+    // source. This only applies when spilling is enabled for local merge.
+    uint64_t spilledSourceReadEndTimeUs{0};
+  };
+  void recordMergeStats();
+
+  // Start sources for this merge run, it may start either all the sources at
+  // once or a portion of the sources at a time to cap the memory usage.
+  void maybeStartNextMergeSourceGroup();
+
+  // Returns true if needs to spill the merged source output if all sources can
+  // not be merged at once.
+  bool needSpill() const {
+    return maxNumMergeSources_ < sources_.size();
+  }
 
-  void initializeTreeOfLosers();
+  void maybeSetupOutputSpiller();
 
-  /// Maximum number of rows in the output batch.
-  const vector_size_t outputBatchSize_;
+  // Spill the output of a partial merge sources.
+  void spill();
 
-  std::vector<SpillSortKey> sortingKeys_;
+  // Invoked at the end for each partial merge run to ensure the order within
+  // each spill file.
+  void finishMergeSourceGroup();
 
-  /// A list of cursors over batches of ordered source data. One per source.
-  /// Aligned with 'sources'.
-  std::vector<SourceStream*> streams_;
+  // Create spillMerger_ exactly once if spill has happened.
+  void setupSpillMerger();
 
-  /// Used to merge data from two or more sources.
-  std::unique_ptr<TreeOfLosers<SourceStream>> treeOfLosers_;
+  RowVectorPtr getOutputFromSpill();
 
-  RowVectorPtr output_;
+  RowVectorPtr getOutputFromSource();
+
+  // Maximum number of rows in the output batch.
+  const vector_size_t maxOutputBatchRows_;
+  // Maximum number of bytes in the output batch.
+  const uint64_t maxOutputBatchBytes_;
+  const std::vector<SpillSortKey> sortingKeys_;
+
+  Stats mergeStats_;
 
+  RowVectorPtr output_;
   /// Number of rows accumulated in 'output_' so far.
   vector_size_t outputSize_{0};
-
   bool finished_{false};
 
   /// A list of blocking futures for sources. These are populates when a given
   /// source is blocked waiting for the next batch of data.
   std::vector<ContinueFuture> sourceBlockingFutures_;
+
+  std::unique_ptr<SourceMerger> sourceMerger_;
+  std::shared_ptr<SpillMerger> spillMerger_;
+  std::unique_ptr<MergeSpiller> mergeOutputSpiller_;
+  // Number of total spilled rows, it must be equal to the input rows.
+  uint64_t numSpilledRows_{0};
+  // SpillFiles group for all the partial merge runs.
+  std::vector<SpillFiles> spillFileGroups_;
+};
+
+/// A utility class for sort-merging data from upstream sources of the
+/// `LocalMerge` operator. The `LocalMerge` operator may start only a portion of
+/// the sources at a time to cap the memory usage, hence it might perform
+/// multiple sort-merge operations with a subset of merge sources.
+class SourceMerger {
+ public:
+  SourceMerger(
+      const RowTypePtr& type,
+      std::vector<std::unique_ptr<SourceStream>> sourceStreams,
+      vector_size_t maxOutputBatchRows,
+      uint64_t maxOutputBatchBytes,
+      velox::memory::MemoryPool* pool);
+
+  void isBlocked(std::vector<ContinueFuture>& sourceBlockingFutures) const;
+
+  RowVectorPtr getOutput(
+      std::vector<ContinueFuture>& sourceBlockingFutures,
+      bool& atEnd);
+
+ private:
+  void setOutputBatchSize();
+
+  const RowTypePtr type_;
+  const vector_size_t maxOutputBatchRows_;
+  const uint64_t maxOutputBatchBytes_;
+  const std::vector<SourceStream*> streams_;
+  const std::unique_ptr<TreeOfLosers<SourceStream>> merger_;
+  velox::memory::MemoryPool* const pool_;
+
+  // The max number of rows in an output vector which is determined by
+  // 'setOutputBatchSize'. The calculation is based on the actual estimated row
+  // size and capped by 'maxOutputBatchRows_' and 'maxOutputBatchBytes_'.
+  vector_size_t outputBatchRows_{0};
+
+  // Reusable output vector.
+  RowVectorPtr output_;
+  // The number of rows in 'output_' vector.
+  uint64_t outputRows_{0};
 };
 
 class SourceStream final : public MergeStream {
@@ -112,6 +211,15 @@ class SourceStream final : public MergeStream {
     return !atEnd_;
   }
 
+  // Returns the estimated row size based on the vector received from the
+  // merge source.
+  std::optional<int64_t> estimateRowSize() const {
+    if (data_ == nullptr || data_->size() == 0) {
+      return std::nullopt;
+    }
+    return data_->estimateFlatSize() / data_->size();
+  }
+
   /// Returns true if current source row is less then current source row in
   /// 'other'.
   bool operator<(const MergeStream& other) const override;
@@ -171,6 +279,76 @@ class SourceStream final : public MergeStream {
   std::vector<vector_size_t> sourceRows_;
 };
 
+/// A utility class for sort-merging data from data spilled by the `LocalMerge`
+/// operator.
+class SpillMerger : public std::enable_shared_from_this<SpillMerger> {
+ public:
+  SpillMerger(
+      const std::vector<SpillSortKey>& sortingKeys,
+      const RowTypePtr& type,
+      std::vector<std::vector<std::unique_ptr<SpillReadFile>>>
+          spillReadFilesGroup,
+      vector_size_t maxOutputBatchRows,
+      uint64_t maxOutputBatchBytes,
+      int mergeSourceQueueSize,
+      const common::SpillConfig* spillConfig,
+      const std::shared_ptr<folly::Synchronized<common::SpillStats>>&
+          spillStats,
+      velox::memory::MemoryPool* pool);
+
+  ~SpillMerger();
+
+  void start();
+
+  RowVectorPtr getOutput(
+      std::vector<ContinueFuture>& sourceBlockingFutures,
+      bool& atEnd);
+
+ private:
+  static std::vector<std::shared_ptr<MergeSource>> createMergeSources(
+      size_t numSpillSources,
+      int queueSize);
+
+  static std::vector<std::unique_ptr<BatchStream>> createBatchStreams(
+      std::vector<std::vector<std::unique_ptr<SpillReadFile>>>
+          spillReadFilesGroup);
+
+  static std::unique_ptr<SourceMerger> createSourceMerger(
+      const std::vector<SpillSortKey>& sortingKeys,
+      const RowTypePtr& type,
+      const std::vector<std::shared_ptr<MergeSource>>& sources,
+      vector_size_t maxOutputBatchRows,
+      uint64_t maxOutputBatchBytes,
+      velox::memory::MemoryPool* pool);
+
+  void finishSource(size_t streamIdx) const;
+
+  void readFromSpillFileStream(
+      const std::weak_ptr<SpillMerger>& mergeHolder,
+      size_t streamIdx);
+
+  void scheduleAsyncSpillFileStreamReads();
+
+  // Sets 'exception_' when an async reader throws.
+  void setError(const std::exception_ptr& exception);
+
+  // Returns true if any async reader has thrown an exception.
+  bool hasError() const;
+
+  // If any async reader has thrown an exception, rethrows it.
+  void checkError();
+
+  folly::Executor* const executor_;
+  const std::shared_ptr<folly::Synchronized<common::SpillStats>> spillStats_;
+  const std::shared_ptr<memory::MemoryPool> pool_;
+
+  std::vector<std::shared_ptr<MergeSource>> sources_;
+  std::vector<std::unique_ptr<BatchStream>> batchStreams_;
+  std::unique_ptr<SourceMerger> sourceMerger_;
+  mutable std::timed_mutex mutex_;
+  std::exception_ptr exception_ = nullptr;
+};
+
 // LocalMerge merges its source's output into a single stream of
 // sorted rows. It runs single threaded. The sources may run multi-threaded and
 // in the same task.
diff --git a/velox/exec/MergeJoin.cpp b/velox/exec/MergeJoin.cpp
index 550c059cc81f..382448465121 100644
--- a/velox/exec/MergeJoin.cpp
+++ b/velox/exec/MergeJoin.cpp
@@ -20,6 +20,25 @@
 
 namespace facebook::velox::exec {
 
+namespace {
+void copyRow(
+    const RowVectorPtr& source,
+    vector_size_t sourceIndex,
+    const RowVectorPtr& target,
+    vector_size_t targetIndex,
+    const std::vector<IdentityProjection>& projections) {
+  for (const auto& projection : projections) {
+    const auto& sourceChild = source->childAt(projection.inputChannel);
+    const auto& targetChild = target->childAt(projection.outputChannel);
+    targetChild->copy(sourceChild.get(), targetIndex, sourceIndex, 1);
+  }
+}
+
+bool isSemiFilterJoin(core::JoinType joinType) {
+  return isLeftSemiFilterJoin(joinType) || isRightSemiFilterJoin(joinType);
+}
+} // namespace
+
 MergeJoin::MergeJoin(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -36,9 +55,9 @@ MergeJoin::MergeJoin(
       rightNodeId_{joinNode->sources()[1]->id()},
       joinNode_(joinNode) {
   VELOX_USER_CHECK(
-      core::MergeJoinNode::isSupported(joinNode_->joinType()),
-      "The join type is not supported by merge join: ",
-      joinTypeName(joinNode_->joinType()));
+      core::MergeJoinNode::isSupported(joinType_),
+      "The join type is not supported by merge join: {}",
+      core::JoinTypeName::toName(joinType_));
 }
 
 void MergeJoin::initialize() {
@@ -90,7 +109,8 @@ void MergeJoin::initialize() {
     initializeFilter(joinNode_->filter(), leftType, rightType);
 
     if (joinNode_->isLeftJoin() || joinNode_->isAntiJoin() ||
-        joinNode_->isRightJoin() || joinNode_->isFullJoin()) {
+        joinNode_->isRightJoin() || joinNode_->isFullJoin() ||
+        isSemiFilterJoin(joinType_)) {
       joinTracker_ = JoinTracker(outputBatchSize_, pool());
     }
   } else if (joinNode_->isAntiJoin()) {
@@ -181,8 +201,8 @@ void MergeJoin::initializeFilter(
 }
 
 BlockingReason MergeJoin::isBlocked(ContinueFuture* future) {
-  if (futureRightSideInput_.valid()) {
-    *future = std::move(futureRightSideInput_);
+  if (rightSideInputFuture_.valid()) {
+    *future = std::move(rightSideInputFuture_);
     return BlockingReason::kWaitForMergeJoinRightSide;
   }
 
@@ -190,16 +210,15 @@ BlockingReason MergeJoin::isBlocked(ContinueFuture* future) {
 }
 
 bool MergeJoin::needsInput() const {
-  if (isRightJoin(joinType_)) {
-    return (input_ == nullptr || rightInput_ == nullptr);
-  }
   return input_ == nullptr;
 }
 
 void MergeJoin::addInput(RowVectorPtr input) {
+  VELOX_CHECK_NULL(input_);
   input_ = std::move(input);
+  // TODO: support selective lazy loading both sides.
+  loadColumns(input_, *operatorCtx_->execCtx());
   leftRowIndex_ = 0;
-
   if (joinTracker_) {
     joinTracker_->resetLastVector();
   }
@@ -207,28 +226,37 @@ void MergeJoin::addInput(RowVectorPtr input) {
 
 // static
 int32_t MergeJoin::compare(
-    const std::vector<column_index_t>& keys,
-    const RowVectorPtr& batch,
-    vector_size_t index,
-    const std::vector<column_index_t>& otherKeys,
-    const RowVectorPtr& otherBatch,
-    vector_size_t otherIndex) {
-  for (auto i = 0; i < keys.size(); ++i) {
+    const std::vector<column_index_t>& leftKeys,
+    const RowVectorPtr& leftBatch,
+    vector_size_t leftIndex,
+    const std::vector<column_index_t>& rightKeys,
+    const RowVectorPtr& rightBatch,
+    vector_size_t rightIndex) {
+  for (auto i = 0; i < leftKeys.size(); ++i) {
     static const CompareFlags kCompareFlags = {
         .equalsOnly = true,
         .nullHandlingMode =
             CompareFlags::NullHandlingMode::kNullAsIndeterminate};
-    const auto compare = batch->childAt(keys[i])->compare(
-        otherBatch->childAt(otherKeys[i]).get(),
-        index,
-        otherIndex,
-        kCompareFlags);
+    const auto compare = leftBatch->childAt(leftKeys[i])
+                             ->compare(
+                                 rightBatch->childAt(rightKeys[i]).get(),
+                                 leftIndex,
+                                 rightIndex,
+                                 kCompareFlags);
 
-    // 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;
+      // Under CompareFlags::NullHandlingMode::kNullAsIndeterminate,
+      // std::nullopt is returned in three cases:
+      //   1) Both the left key and the right key are null.
+      //   2) The left key is null, and the right key is not null.
+      //   3) The left key is not null, and the right key is null.
+      //
+      // However, the comparison result semantics differ:
+      // - Cases (1) and (2): return -1, meaning input_ should catch up with
+      // rightInput_.
+      // - Case (3): return 1, indicating the left key is considered greater,
+      //   so rightInput_ should catch up with input_ in the subsequent steps.
+      return leftBatch->childAt(leftKeys[i])->isNullAt(leftIndex) ? -1 : 1;
     } else if (compare.value() != 0) {
       return compare.value();
     }
@@ -245,9 +273,8 @@ bool MergeJoin::findEndOfMatch(
     return true;
   }
 
-  auto prevInput = match.inputs.back();
-  auto prevIndex = prevInput->size() - 1;
-
+  const auto prevInput = match.inputs.back();
+  const auto prevIndex = prevInput->size() - 1;
   const auto numInputRows = input->size();
 
   vector_size_t endRow = 0;
@@ -257,9 +284,6 @@ bool MergeJoin::findEndOfMatch(
   }
 
   if (endRow == numInputRows) {
-    // Inputs are kept past getting a new batch of inputs. LazyVectors
-    // must be loaded before advancing to the next batch.
-    loadColumns(input, *operatorCtx_->execCtx());
     match.inputs.push_back(input);
     match.endRowIndex = endRow;
     return false;
@@ -274,21 +298,6 @@ bool MergeJoin::findEndOfMatch(
   return true;
 }
 
-namespace {
-void copyRow(
-    const RowVectorPtr& source,
-    vector_size_t sourceIndex,
-    const RowVectorPtr& target,
-    vector_size_t targetIndex,
-    const std::vector<IdentityProjection>& projections) {
-  for (const auto& projection : projections) {
-    const auto& sourceChild = source->childAt(projection.inputChannel);
-    const auto& targetChild = target->childAt(projection.outputChannel);
-    targetChild->copy(sourceChild.get(), targetIndex, sourceIndex, 1);
-  }
-}
-} // namespace
-
 inline void addNull(
     VectorPtr& target,
     vector_size_t index,
@@ -338,17 +347,23 @@ bool MergeJoin::tryAddOutputRowForLeftJoin() {
   }
 
   ++outputSize_;
-
   return true;
 }
 
 bool MergeJoin::tryAddOutputRowForRightJoin() {
-  VELOX_USER_CHECK(isRightJoin(joinType_) || isFullJoin(joinType_));
+  VELOX_CHECK(isRightJoin(joinType_) || isFullJoin(joinType_));
   if (outputSize_ == outputBatchSize_) {
     return false;
   }
 
-  rawRightOutputIndices_[outputSize_] = rightRowIndex_++;
+  if (!isRightFlattened_) {
+    // All right side projections share the same dictionary indices
+    // (rightIndices_).
+    rawRightOutputIndices_[outputSize_] = rightRowIndex_++;
+  } else {
+    copyRow(
+        rightInput_, rightRowIndex_++, output_, outputSize_, rightProjections_);
+  }
 
   for (const auto& projection : leftProjections_) {
     auto& target = output_->childAt(projection.outputChannel);
@@ -366,7 +381,6 @@ bool MergeJoin::tryAddOutputRowForRightJoin() {
   }
 
   ++outputSize_;
-
   return true;
 }
 
@@ -421,7 +435,7 @@ bool MergeJoin::tryAddOutputRow(
         filterRightInputProjections_);
 
     if (joinTracker_) {
-      if (isRightJoin(joinType_)) {
+      if (isRightJoin(joinType_) || isRightSemiFilterJoin(joinType_)) {
         // Record right-side row with a match on the left-side.
         joinTracker_->addMatch(rightBatch, rightRow, outputSize_);
       } else {
@@ -440,7 +454,6 @@ bool MergeJoin::tryAddOutputRow(
   }
 
   ++outputSize_;
-
   return true;
 }
 
@@ -548,17 +561,16 @@ bool MergeJoin::prepareOutput(
 
   if (filter_ != nullptr && filterInput_ == nullptr) {
     std::vector<VectorPtr> inputs(filterInputType_->size());
-    for (const auto [filterInputChannel, outputChannel] :
-         filterInputToOutputChannel_) {
-      inputs[filterInputChannel] = output_->childAt(outputChannel);
-    }
     for (auto i = 0; i < filterInputType_->size(); ++i) {
       if (filterInputToOutputChannel_.find(i) !=
           filterInputToOutputChannel_.end()) {
-        continue;
+        inputs[i] = output_->childAt(filterInputToOutputChannel_[i]);
+      } else {
+        inputs[i] = BaseVector::create(
+            filterInputType_->childAt(i),
+            outputBatchSize_,
+            operatorCtx_->pool());
       }
-      inputs[i] = BaseVector::create(
-          filterInputType_->childAt(i), outputBatchSize_, operatorCtx_->pool());
     }
 
     filterInput_ = std::make_shared<RowVector>(
@@ -579,69 +591,98 @@ bool MergeJoin::addToOutput() {
   }
 }
 
-bool MergeJoin::addToOutputForLeftJoin() {
-  size_t firstLeftBatch;
-  vector_size_t leftStartRowIndex;
-  if (leftMatch_->cursor) {
-    firstLeftBatch = leftMatch_->cursor->batchIndex;
-    leftStartRowIndex = leftMatch_->cursor->rowIndex;
+template <bool IsLeftJoin>
+bool MergeJoin::addToOutputImpl() {
+  // For left join: outerMatch=left, innerMatch=right
+  // For right join: outerMatch=right, innerMatch=left
+  auto& outerMatch = IsLeftJoin ? leftMatch_ : rightMatch_;
+  auto& innerMatch = IsLeftJoin ? rightMatch_ : leftMatch_;
+
+  size_t outerFirstBatch;
+  vector_size_t outerStartRowIndex;
+  if (outerMatch->cursor) {
+    outerFirstBatch = outerMatch->cursor->batchIndex;
+    outerStartRowIndex = outerMatch->cursor->rowIndex;
   } else {
-    firstLeftBatch = 0;
-    leftStartRowIndex = leftMatch_->startRowIndex;
+    outerFirstBatch = 0;
+    outerStartRowIndex = outerMatch->startRowIndex;
   }
 
-  const size_t numLeftBatches = leftMatch_->inputs.size();
-  for (size_t l = firstLeftBatch; l < numLeftBatches; ++l) {
-    const auto leftBatch = leftMatch_->inputs[l];
-    const auto leftStartRow = l == firstLeftBatch ? leftStartRowIndex : 0;
-    const auto leftEndRow =
-        l == numLeftBatches - 1 ? leftMatch_->endRowIndex : leftBatch->size();
-
-    for (auto i = leftStartRow; i < leftEndRow; ++i) {
-      const auto firstRightBatch =
-          (l == firstLeftBatch && i == leftStartRow && rightMatch_->cursor)
-          ? rightMatch_->cursor->batchIndex
+  const size_t numOuterBatches = outerMatch->inputs.size();
+  for (size_t outerBatchIndex = outerFirstBatch;
+       outerBatchIndex < numOuterBatches;
+       ++outerBatchIndex) {
+    const auto& outerBatch = outerMatch->inputs[outerBatchIndex];
+    const auto outerStartRow =
+        outerBatchIndex == outerFirstBatch ? outerStartRowIndex : 0;
+    const auto outerEndRow = outerBatchIndex == numOuterBatches - 1
+        ? outerMatch->endRowIndex
+        : outerBatch->size();
+
+    for (auto outerRow = outerStartRow; outerRow < outerEndRow; ++outerRow) {
+      const bool outerFirstRow =
+          outerBatchIndex == outerFirstBatch && outerRow == outerStartRow;
+      const auto innerFirstBatch = (outerFirstRow && innerMatch->cursor)
+          ? innerMatch->cursor->batchIndex
           : 0;
 
-      const auto rightStartRowIndex =
-          (l == firstLeftBatch && i == leftStartRow && rightMatch_->cursor)
-          ? rightMatch_->cursor->rowIndex
-          : rightMatch_->startRowIndex;
+      const auto innerStartRowIndex = (outerFirstRow && innerMatch->cursor)
+          ? innerMatch->cursor->rowIndex
+          : innerMatch->startRowIndex;
 
-      const auto numRightBatches = rightMatch_->inputs.size();
+      const auto numInnerBatches = innerMatch->inputs.size();
       // 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.
-      for (size_t r = isLeftSemiFilterJoin(joinType_) ? numRightBatches - 1
-                                                      : firstRightBatch;
-           r < numRightBatches;
-           ++r) {
-        const auto rightBatch = rightMatch_->inputs[r];
-        auto rightStartRow = r == firstRightBatch ? rightStartRowIndex : 0;
-        const auto rightEndRow = r == numRightBatches - 1
-            ? rightMatch_->endRowIndex
-            : rightBatch->size();
-        if (isLeftSemiFilterJoin(joinType_)) {
-          rightStartRow = rightEndRow - 1;
+      // Handle semi-filter join optimization
+      const bool isSemiFilter = IsLeftJoin
+          ? (isLeftSemiFilterJoin(joinType_) && !filter_)
+          : (isRightSemiFilterJoin(joinType_) && !filter_);
+
+      for (size_t innerBatchIndex = isSemiFilter ? numInnerBatches - 1
+                                                 : innerFirstBatch;
+           innerBatchIndex < numInnerBatches;
+           ++innerBatchIndex) {
+        const auto& innerBatch = innerMatch->inputs[innerBatchIndex];
+        auto innerStartRow =
+            innerBatchIndex == innerFirstBatch ? innerStartRowIndex : 0;
+        const auto innerEndRow = innerBatchIndex == numInnerBatches - 1
+            ? innerMatch->endRowIndex
+            : innerBatch->size();
+
+        if (isSemiFilter) {
+          innerStartRow = innerEndRow - 1;
         }
+
+        // Determine the correct order for prepareOutput and tryAddOutputRow
+        const auto& leftBatch = IsLeftJoin ? outerBatch : innerBatch;
+        const auto& rightBatch = IsLeftJoin ? innerBatch : outerBatch;
+
         if (prepareOutput(leftBatch, rightBatch)) {
           output_->resize(outputSize_);
-          leftMatch_->setCursor(l, i);
-          rightMatch_->setCursor(r, rightStartRow);
+          outerMatch->setCursor(outerBatchIndex, outerRow);
+          innerMatch->setCursor(innerBatchIndex, innerStartRow);
           return true;
         }
 
-        for (auto j = rightStartRow; j < rightEndRow; ++j) {
-          if (!tryAddOutputRow(leftBatch, i, rightBatch, j)) {
-            // 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;
+        if (IsLeftJoin) {
+          for (auto innerRow = innerStartRow; innerRow < innerEndRow;
+               ++innerRow) {
+            if (!tryAddOutputRow(leftBatch, outerRow, rightBatch, innerRow)) {
+              outerMatch->setCursor(outerBatchIndex, outerRow);
+              innerMatch->setCursor(innerBatchIndex, innerRow);
+              return true;
+            }
+          }
+        } else {
+          for (auto innerRow = innerStartRow; innerRow < innerEndRow;
+               ++innerRow) {
+            if (!tryAddOutputRow(leftBatch, innerRow, rightBatch, outerRow)) {
+              outerMatch->setCursor(outerBatchIndex, outerRow);
+              innerMatch->setCursor(innerBatchIndex, innerRow);
+              return true;
+            }
           }
         }
       }
@@ -650,100 +691,15 @@ bool MergeJoin::addToOutputForLeftJoin() {
 
   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_ && leftRowIndex_ != input_->size()) {
-    loadColumns(currentLeft_, *operatorCtx_->execCtx());
-  }
   return outputSize_ == outputBatchSize_;
 }
 
-bool MergeJoin::addToOutputForRightJoin() {
-  size_t firstRightBatch;
-  vector_size_t rightStartRowIndex;
-  if (rightMatch_->cursor) {
-    firstRightBatch = rightMatch_->cursor->batchIndex;
-    rightStartRowIndex = rightMatch_->cursor->rowIndex;
-  } else {
-    firstRightBatch = 0;
-    rightStartRowIndex = rightMatch_->startRowIndex;
-  }
-
-  const size_t numRightBatches = rightMatch_->inputs.size();
-  for (size_t r = firstRightBatch; r < numRightBatches; ++r) {
-    const auto rightBatch = rightMatch_->inputs[r];
-    const auto rightStartRow = r == firstRightBatch ? rightStartRowIndex : 0;
-    const auto rightEndRow = r == numRightBatches - 1 ? rightMatch_->endRowIndex
-                                                      : rightBatch->size();
-
-    for (auto i = rightStartRow; i < rightEndRow; ++i) {
-      const auto firstLeftBatch =
-          (r == firstRightBatch && i == rightStartRow && leftMatch_->cursor)
-          ? leftMatch_->cursor->batchIndex
-          : 0;
-
-      const auto leftStartRowIndex =
-          (r == firstRightBatch && i == rightStartRow && leftMatch_->cursor)
-          ? leftMatch_->cursor->rowIndex
-          : leftMatch_->startRowIndex;
-
-      const auto numLeftBatches = leftMatch_->inputs.size();
-      // 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.
-      for (size_t l = isRightSemiFilterJoin(joinType_) ? numLeftBatches - 1
-                                                       : firstLeftBatch;
-           l < numLeftBatches;
-           ++l) {
-        const auto leftBatch = leftMatch_->inputs[l];
-        auto leftStartRow = l == firstLeftBatch ? leftStartRowIndex : 0;
-        const auto leftEndRow = l == numLeftBatches - 1
-            ? leftMatch_->endRowIndex
-            : leftBatch->size();
-        if (isRightSemiFilterJoin(joinType_)) {
-          // RightSemiFilter produce each row from the right at most once.
-          leftStartRow = leftEndRow - 1;
-        }
-
-        if (prepareOutput(leftBatch, rightBatch)) {
-          // Differently from left joins, for right joins we need to load lazies
-          // (from the left) whenever we detect we have to move to the next
-          // right batch, since this means that we will produce this buffer, but
-          // we may have subsequent matches.
-          loadColumns(leftBatch, *operatorCtx_->execCtx());
-          output_->resize(outputSize_);
-          leftMatch_->setCursor(l, leftStartRow);
-          rightMatch_->setCursor(r, i);
-          return true;
-        }
-
-        for (auto j = leftStartRow; j < leftEndRow; ++j) {
-          if (!tryAddOutputRow(leftBatch, j, rightBatch, i)) {
-            // 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());
-            rightMatch_->setCursor(r, i);
-            leftMatch_->setCursor(l, j);
-            return true;
-          }
-        }
-      }
-    }
-  }
-
-  leftMatch_.reset();
-  rightMatch_.reset();
+bool MergeJoin::addToOutputForLeftJoin() {
+  return addToOutputImpl<true>();
+}
 
-  // 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 (rightInput_ && rightRowIndex_ != rightInput_->size()) {
-    loadColumns(currentLeft_, *operatorCtx_->execCtx());
-  }
-  return outputSize_ == outputBatchSize_;
+bool MergeJoin::addToOutputForRightJoin() {
+  return addToOutputImpl<false>();
 }
 
 namespace {
@@ -751,19 +707,18 @@ vector_size_t firstNonNull(
     const RowVectorPtr& rowVector,
     const std::vector<column_index_t>& keys,
     vector_size_t start = 0) {
-  for (auto i = start; i < rowVector->size(); ++i) {
+  for (auto row = start; row < rowVector->size(); ++row) {
     bool hasNull = false;
     for (auto key : keys) {
-      if (rowVector->childAt(key)->isNullAt(i)) {
+      if (rowVector->childAt(key)->isNullAt(row)) {
         hasNull = true;
         break;
       }
     }
     if (!hasNull) {
-      return i;
+      return row;
     }
   }
-
   return rowVector->size();
 }
 } // namespace
@@ -813,104 +768,125 @@ RowVectorPtr MergeJoin::getOutput() {
           }
           return output;
         }
-
         // 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 {
+      if (!isAntiJoin(joinType_)) {
         return output;
       }
+
+      output = filterOutputForAntiJoin(output);
+      if (output != nullptr && output->size() > 0) {
+        return output;
+      }
+      // No rows survived the filter for anti join. Get more rows.
+      continue;
     }
 
-    if (rightHasDrained_ && leftHasDrained_) {
-      finishDrain();
+    if (processDrain()) {
       return nullptr;
     }
-    if (leftHasDrained_ && !input_) {
-      if (isInnerJoin(joinType_) && (!rightMatch_ || rightMatch_->complete)) {
-        operatorCtx_->task()->dropInput(rightNodeId_);
-      }
-      if (isLeftJoin(joinType_) || isAntiJoin(joinType_)) {
-        operatorCtx_->task()->dropInput(rightNodeId_);
+
+    // Check if we need to get more data from the right side.
+    if (needsInputFromRightSide()) {
+      if (!getNextFromRightSide()) {
+        return nullptr;
       }
+      continue;
     }
-    if (rightHasDrained_ && !rightInput_) {
-      if (isInnerJoin(joinType_) && (!leftMatch_ || leftMatch_->complete)) {
-        operatorCtx_->task()->dropInput(this);
-      }
-      if (isRightJoin(joinType_)) {
-        operatorCtx_->task()->dropInput(this);
-      }
+
+    return nullptr;
+  }
+  VELOX_UNREACHABLE();
+}
+
+bool MergeJoin::processDrain() {
+  if (rightHasDrained_ && leftHasDrained_) {
+    finishDrain();
+    return true;
+  }
+
+  if (leftHasDrained_ && !input_) {
+    if (isInnerJoin(joinType_) && (!rightMatch_ || rightMatch_->complete)) {
+      operatorCtx_->task()->dropInput(rightNodeId_);
     }
-    // Check if we need to get more data from the right side.
-    if (!rightHasNoInput() && !futureRightSideInput_.valid() && !rightInput_) {
-      if (!rightSource_) {
-        rightSource_ = operatorCtx_->task()->getMergeJoinSource(
-            operatorCtx_->driverCtx()->splitGroupId, planNodeId());
-      }
+    if (isLeftJoin(joinType_) || isAntiJoin(joinType_)) {
+      operatorCtx_->task()->dropInput(rightNodeId_);
+    }
+  }
 
-      while (!rightHasNoInput() && !rightInput_) {
-        const auto blockingReason = rightSource_->next(
-            &futureRightSideInput_, &rightInput_, rightHasDrained_);
-        if (blockingReason != BlockingReason::kNotBlocked) {
-          VELOX_CHECK(!rightHasDrained_);
-          return nullptr;
-        }
+  if (rightHasDrained_ && !rightInput_) {
+    if (isInnerJoin(joinType_) && (!leftMatch_ || leftMatch_->complete)) {
+      operatorCtx_->task()->dropInput(this);
+    }
+    if (isRightJoin(joinType_)) {
+      operatorCtx_->task()->dropInput(this);
+    }
+  }
+  return false;
+}
 
-        if (rightInput_) {
-          if (isFullJoin(joinType_) || isRightJoin(joinType_)) {
-            rightRowIndex_ = 0;
-          } else {
-            rightRowIndex_ = firstNonNull(rightInput_, rightKeyChannels_);
-            if (finishedRightBatch()) {
-              // Ran out of rows on the right side.
-              rightInput_ = nullptr;
-            }
-          }
-        } else if (!rightHasDrained_) {
-          noMoreRightInput_ = true;
+bool MergeJoin::needsInputFromRightSide() const {
+  return !rightHasNoInput() && !rightSideInputFuture_.valid() && !rightInput_;
+}
+
+bool MergeJoin::getNextFromRightSide() {
+  VELOX_CHECK(needsInputFromRightSide());
+  if (rightSource_ == nullptr) {
+    rightSource_ = operatorCtx_->task()->getMergeJoinSource(
+        operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+  }
+
+  while (!rightHasNoInput() && !rightInput_) {
+    const auto blockingReason = rightSource_->next(
+        &rightSideInputFuture_, &rightInput_, rightHasDrained_);
+    if (blockingReason != BlockingReason::kNotBlocked) {
+      VELOX_CHECK(!rightHasDrained_);
+      return false;
+    }
+
+    if (rightInput_) {
+      if (isFullJoin(joinType_) || isRightJoin(joinType_)) {
+        rightRowIndex_ = 0;
+      } else {
+        rightRowIndex_ = firstNonNull(rightInput_, rightKeyChannels_);
+        if (rightBatchFinished()) {
+          // Ran out of rows on the right side.
+          clearRightInput();
         }
       }
-      continue;
+    } else if (!rightHasDrained_) {
+      noMoreRightInput_ = true;
     }
-
-    return nullptr;
   }
-  VELOX_UNREACHABLE();
+  return true;
 }
 
 RowVectorPtr MergeJoin::handleRightSideNullRows() {
+  if (!isRightJoin(joinType_) && !isFullJoin(joinType_)) {
+    return nullptr;
+  }
   const auto rightFirstNonNullIndex =
-      firstNonNull(rightInput_, rightKeyChannels_);
-  if ((isRightJoin(joinType_) || isFullJoin(joinType_)) &&
-      rightFirstNonNullIndex > rightRowIndex_) {
-    if (prepareOutput(nullptr, rightInput_)) {
+      firstNonNull(rightInput_, rightKeyChannels_, rightRowIndex_);
+  if (rightFirstNonNullIndex <= rightRowIndex_) {
+    return nullptr;
+  }
+  if (prepareOutput(nullptr, rightInput_)) {
+    output_->resize(outputSize_);
+    return std::move(output_);
+  }
+  for (int row = rightRowIndex_; row < rightFirstNonNullIndex; ++row) {
+    if (!tryAddOutputRowForRightJoin()) {
       output_->resize(outputSize_);
       return std::move(output_);
     }
-    for (int i = rightRowIndex_; i < rightFirstNonNullIndex; ++i) {
-      if (!tryAddOutputRowForRightJoin()) {
-        rightRowIndex_ = i;
-        return std::move(output_);
-      }
-
-      if (finishedRightBatch()) {
-        // Ran out of rows on the right side.
-        rightInput_ = nullptr;
-        return nullptr;
-      }
-    }
-
-    rightRowIndex_ = rightFirstNonNullIndex;
   }
-
+  VELOX_CHECK_EQ(rightRowIndex_, rightFirstNonNullIndex);
+  if (rightBatchFinished()) {
+    // Ran out of rows on the right side.
+    clearRightInput();
+  }
   return nullptr;
 }
 
@@ -933,53 +909,11 @@ RowVectorPtr MergeJoin::doGetOutput() {
   // match.
   if (leftMatch_) {
     VELOX_CHECK(rightMatch_);
-
-    if (input_) {
-      // Look for continuation of a match on the left and/or right sides.
-      if (!findEndOfMatch(input_, leftKeyChannels_, leftMatch_.value())) {
-        // Continue looking for the end of the match.
-        input_ = nullptr;
-        return nullptr;
-      }
-      VELOX_CHECK(leftMatch_->complete);
-
-      if (leftMatch_->inputs.back() == input_) {
-        leftRowIndex_ = leftMatch_->endRowIndex;
-      }
-    } else if (leftHasNoInput()) {
-      leftMatch_->complete = true;
-    } else {
-      // Need more input.
-      return nullptr;
-    }
-
-    if (rightInput_) {
-      if (!findEndOfMatch(
-              rightInput_, rightKeyChannels_, rightMatch_.value())) {
-        VELOX_CHECK(!rightMatch_->complete);
-        // Continue looking for the end of the match.
-        rightInput_ = nullptr;
-        return nullptr;
-      }
-      VELOX_CHECK(rightMatch_->complete);
-
-      if (rightMatch_->inputs.back() == rightInput_) {
-        if (isFullJoin(joinType_) || isRightJoin(joinType_)) {
-          rightRowIndex_ = rightMatch_->endRowIndex;
-        } else {
-          rightRowIndex_ = firstNonNull(
-              rightInput_, rightKeyChannels_, rightMatch_->endRowIndex);
-          if (rightRowIndex_ == rightInput_->size()) {
-            rightInput_ = nullptr;
-          }
-        }
-      }
-    } else if (rightHasNoInput()) {
-      rightMatch_->complete = true;
-    } else {
-      // Need more input.
+    if (!advanceMatch()) {
       return nullptr;
     }
+    VELOX_CHECK(leftMatch_->complete);
+    VELOX_CHECK(rightMatch_->complete);
   }
 
   // There is no output-in-progress match, but there can be a complete match
@@ -994,131 +928,10 @@ RowVectorPtr MergeJoin::doGetOutput() {
   }
 
   if (!input_ || !rightInput_) {
-    if (isLeftJoin(joinType_) || isAntiJoin(joinType_)) {
-      if (input_ && rightHasNoInput()) {
-        // 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 (!tryAddOutputRowForLeftJoin()) {
-            return std::move(output_);
-          }
-
-          if (finishedLeftBatch()) {
-            input_ = nullptr;
-            return produceOutput();
-          }
-        }
-        VELOX_UNREACHABLE();
-      }
-
-      if (leftHasNoInput()) {
-        if (output_ != nullptr) {
-          output_->resize(outputSize_);
-          return std::move(output_);
-        }
-        if (input_ == nullptr) {
-          rightInput_ = nullptr;
-        }
-      }
-    } else if (isRightJoin(joinType_)) {
-      if (rightInput_ && leftHasNoInput()) {
-        // 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 (!tryAddOutputRowForRightJoin()) {
-            return std::move(output_);
-          }
-
-          if (finishedRightBatch()) {
-            // Ran out of rows on the right side.
-            rightInput_ = nullptr;
-            return nullptr;
-          }
-        }
-        VELOX_UNREACHABLE();
-      }
-
-      if (rightHasNoInput() && output_) {
-        output_->resize(outputSize_);
-        return std::move(output_);
-      }
-    } else if (isFullJoin(joinType_)) {
-      if (input_ && rightHasNoInput()) {
-        // 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 (!tryAddOutputRowForLeftJoin()) {
-            return std::move(output_);
-          }
-
-          if (finishedLeftBatch()) {
-            input_ = nullptr;
-            return produceOutput();
-          }
-        }
-        VELOX_UNREACHABLE();
-      }
-
-      if (leftHasNoInput() && output_) {
-        output_->resize(outputSize_);
-        return std::move(output_);
-      }
-
-      if (rightInput_ && leftHasNoInput()) {
-        // 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 (!tryAddOutputRowForRightJoin()) {
-            return std::move(output_);
-          }
-
-          if (finishedRightBatch()) {
-            // Ran out of rows on the right side.
-            rightInput_ = nullptr;
-            return nullptr;
-          }
-        }
-        VELOX_UNREACHABLE();
-      }
-
-      if (rightHasNoInput() && output_) {
-        output_->resize(outputSize_);
-        return std::move(output_);
-      }
-    } else {
-      if (leftHasNoInput() || rightHasNoInput()) {
-        if (output_) {
-          output_->resize(outputSize_);
-          return std::move(output_);
-        }
-        input_ = nullptr;
-        rightInput_ = nullptr;
-      }
-    }
-
-    return nullptr;
+    return handleSingleSideOutput();
   }
 
-  const auto output = handleRightSideNullRows();
+  auto output = handleRightSideNullRows();
   if (output != nullptr || rightInput_ == nullptr) {
     return output;
   }
@@ -1147,8 +960,8 @@ RowVectorPtr MergeJoin::doGetOutput() {
             firstNonNull(input_, leftKeyChannels_, leftRowIndex_ + 1);
       }
 
-      if (finishedLeftBatch()) {
-        input_ = nullptr;
+      if (leftBatchFinished()) {
+        clearLeftInput();
         return produceOutput();
       }
       compareResult = compare();
@@ -1163,7 +976,6 @@ RowVectorPtr MergeJoin::doGetOutput() {
           output_->resize(outputSize_);
           return std::move(output_);
         }
-
         if (!tryAddOutputRowForRightJoin()) {
           return std::move(output_);
         }
@@ -1172,9 +984,9 @@ RowVectorPtr MergeJoin::doGetOutput() {
             firstNonNull(rightInput_, rightKeyChannels_, rightRowIndex_ + 1);
       }
 
-      if (finishedRightBatch()) {
-        rightInput_ = nullptr;
-        return produceOutput();
+      if (rightBatchFinished()) {
+        clearRightInput();
+        return nullptr;
       }
       compareResult = compare();
     }
@@ -1186,11 +998,6 @@ RowVectorPtr MergeJoin::doGetOutput() {
       while (leftEndRow < input_->size() && compareLeft(leftEndRow) == 0) {
         ++leftEndRow;
       }
-
-      if (leftEndRow == input_->size()) {
-        // Matches continue in subsequent input. Load all lazies.
-        loadColumns(input_, *operatorCtx_->execCtx());
-      }
       leftMatch_ = Match{
           {input_},
           leftRowIndex_,
@@ -1198,43 +1005,47 @@ RowVectorPtr MergeJoin::doGetOutput() {
           leftEndRow < input_->size(),
           std::nullopt};
 
-      vector_size_t endRightRow = rightRowIndex_ + 1;
-      while (endRightRow < rightInput_->size() &&
-             compareRight(endRightRow) == 0) {
-        ++endRightRow;
+      vector_size_t rightEndRow = rightRowIndex_ + 1;
+      while (rightEndRow < rightInput_->size() &&
+             compareRight(rightEndRow) == 0) {
+        ++rightEndRow;
       }
 
       rightMatch_ = Match{
           {rightInput_},
           rightRowIndex_,
-          endRightRow,
-          endRightRow < rightInput_->size(),
+          rightEndRow,
+          rightEndRow < rightInput_->size(),
           std::nullopt};
 
+      // Track matched rows for this key match.
+      matchedLeftRows_ += leftEndRow - leftMatch_->startRowIndex;
+      matchedRightRows_ += rightEndRow - rightMatch_->startRowIndex;
+
       if (!leftMatch_->complete || !rightMatch_->complete) {
         if (!leftMatch_->complete) {
           // Need to continue looking for the end of match.
-          input_ = nullptr;
+          clearLeftInput();
         }
 
         if (!rightMatch_->complete) {
           // Need to continue looking for the end of match.
-          rightInput_ = nullptr;
+          clearRightInput();
         }
         return nullptr;
       }
 
       leftRowIndex_ = leftEndRow;
       if (isFullJoin(joinType_) || isRightJoin(joinType_)) {
-        rightRowIndex_ = endRightRow;
+        rightRowIndex_ = rightEndRow;
       } else {
         rightRowIndex_ =
-            firstNonNull(rightInput_, rightKeyChannels_, endRightRow);
+            firstNonNull(rightInput_, rightKeyChannels_, rightEndRow);
       }
 
-      if (finishedRightBatch()) {
+      if (rightBatchFinished()) {
         // Ran out of rows on the right side.
-        rightInput_ = nullptr;
+        clearRightInput();
       }
 
       if (addToOutput()) {
@@ -1252,6 +1063,223 @@ RowVectorPtr MergeJoin::doGetOutput() {
   VELOX_UNREACHABLE();
 }
 
+RowVectorPtr MergeJoin::handleSingleSideOutput() {
+  VELOX_CHECK(!input_ || !rightInput_);
+
+  if (isLeftJoin(joinType_) || isAntiJoin(joinType_)) {
+    if (input_ && rightHasNoInput()) {
+      // 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 (!tryAddOutputRowForLeftJoin()) {
+          return std::move(output_);
+        }
+
+        if (leftBatchFinished()) {
+          clearLeftInput();
+          return produceOutput();
+        }
+      }
+      VELOX_UNREACHABLE();
+    }
+
+    if (leftHasNoInput()) {
+      if (output_ != nullptr) {
+        output_->resize(outputSize_);
+        return std::move(output_);
+      }
+      if (input_ == nullptr) {
+        clearRightInput();
+      }
+    }
+  } else if (isRightJoin(joinType_)) {
+    if (rightInput_ && leftHasNoInput()) {
+      // 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 (!tryAddOutputRowForRightJoin()) {
+          return std::move(output_);
+        }
+
+        if (rightBatchFinished()) {
+          // Ran out of rows on the right side.
+          clearRightInput();
+          return nullptr;
+        }
+      }
+      VELOX_UNREACHABLE();
+    }
+
+    if (rightHasNoInput()) {
+      if (output_ != nullptr) {
+        output_->resize(outputSize_);
+        return std::move(output_);
+      }
+      if (rightInput_ == nullptr) {
+        clearLeftInput();
+      }
+    }
+  } else if (isFullJoin(joinType_)) {
+    if (input_ && rightHasNoInput()) {
+      // 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 (!tryAddOutputRowForLeftJoin()) {
+          return std::move(output_);
+        }
+
+        if (leftBatchFinished()) {
+          clearLeftInput();
+          return produceOutput();
+        }
+      }
+      VELOX_UNREACHABLE();
+    }
+
+    if (leftHasNoInput() && output_) {
+      output_->resize(outputSize_);
+      return std::move(output_);
+    }
+
+    if (rightInput_ && leftHasNoInput()) {
+      // 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 (!tryAddOutputRowForRightJoin()) {
+          return std::move(output_);
+        }
+
+        if (rightBatchFinished()) {
+          // Ran out of rows on the right side.
+          clearRightInput();
+          return nullptr;
+        }
+      }
+      VELOX_UNREACHABLE();
+    }
+
+    if (rightHasNoInput() && output_) {
+      output_->resize(outputSize_);
+      return std::move(output_);
+    }
+  } else {
+    if (leftHasNoInput() || rightHasNoInput()) {
+      if (output_) {
+        output_->resize(outputSize_);
+        return std::move(output_);
+      }
+      clearLeftInput();
+      clearRightInput();
+    }
+  }
+  return nullptr;
+}
+
+bool MergeJoin::advanceMatch() {
+  VELOX_CHECK(leftMatch_);
+  VELOX_CHECK(rightMatch_);
+
+  if (!advanceLeftMatch()) {
+    return false;
+  }
+  return advanceRightMatch();
+}
+
+// Template implementation for advancing left or right match completion.
+// Consolidates logic for finding the end of incomplete matches.
+template <bool IsLeft>
+bool MergeJoin::advanceMatchImpl() {
+  auto& match = IsLeft ? leftMatch_ : rightMatch_;
+  auto& input = IsLeft ? input_ : rightInput_;
+  auto& keyChannels = IsLeft ? leftKeyChannels_ : rightKeyChannels_;
+  auto& rowIndex = IsLeft ? leftRowIndex_ : rightRowIndex_;
+
+  VELOX_CHECK(match);
+
+  if (input) {
+    // Look for continuation of a match.
+    if (!findEndOfMatch(input, keyChannels, match.value())) {
+      VELOX_CHECK(!match->complete);
+      // Continue looking for the end of the match.
+      if constexpr (IsLeft) {
+        clearLeftInput();
+      } else {
+        clearRightInput();
+      }
+      return false;
+    }
+    VELOX_CHECK(match->complete);
+
+    if (match->inputs.back() == input) {
+      if (IsLeft || isFullJoin(joinType_) || isRightJoin(joinType_)) {
+        rowIndex = match->endRowIndex;
+      } else {
+        rowIndex = firstNonNull(input, keyChannels, match->endRowIndex);
+        if (rowIndex == input->size()) {
+          if constexpr (IsLeft) {
+            clearLeftInput();
+          } else {
+            clearRightInput();
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  if constexpr (IsLeft) {
+    if (leftHasNoInput()) {
+      match->complete = true;
+      return true;
+    }
+  } else {
+    if (rightHasNoInput()) {
+      match->complete = true;
+      return true;
+    }
+  }
+
+  // Need more input.
+  return false;
+}
+
+// Delegates to the template implementation for left match advancement.
+bool MergeJoin::advanceLeftMatch() {
+  return advanceMatchImpl<true>();
+}
+
+// Delegates to the template implementation for right match advancement.
+bool MergeJoin::advanceRightMatch() {
+  return advanceMatchImpl<false>();
+}
+
+void MergeJoin::clearLeftInput() {
+  input_ = nullptr;
+}
+
+void MergeJoin::clearRightInput() {
+  rightInput_ = nullptr;
+}
+
 RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
   const auto numRows = output->size();
 
@@ -1274,7 +1302,7 @@ 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.
     const auto onMiss = [&](auto row) {
-      if (isAntiJoin(joinType_)) {
+      if (isSemiFilterJoin(joinType_)) {
         return;
       }
       rawIndices[numPassed++] = row;
@@ -1346,22 +1374,21 @@ RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
       }
     };
 
+    auto onMatch = [&](auto row, bool firstMatch) {
+      const bool isNonSemiAntiJoin =
+          !isSemiFilterJoin(joinType_) && !isAntiJoin(joinType_);
+
+      if ((isSemiFilterJoin(joinType_) && firstMatch) || isNonSemiAntiJoin) {
+        rawIndices[numPassed++] = row;
+      }
+    };
+
     for (auto i = 0; i < numRows; ++i) {
       if (filterRows.isValid(i)) {
         const bool passed = !decodedFilterResult_.isNullAt(i) &&
             decodedFilterResult_.valueAt<bool>(i);
 
-        joinTracker_->processFilterResult(i, passed, onMiss);
-
-        if (isAntiJoin(joinType_)) {
-          if (!passed) {
-            rawIndices[numPassed++] = i;
-          }
-        } else {
-          if (passed) {
-            rawIndices[numPassed++] = i;
-          }
-        }
+        joinTracker_->processFilterResult(i, passed, onMiss, onMatch);
       } else {
         // This row doesn't have a match on the right side. Keep it
         // unconditionally.
@@ -1371,19 +1398,19 @@ RowVectorPtr MergeJoin::applyFilter(const RowVectorPtr& output) {
 
     // 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.
+    // 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).
+    // 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:
+    // 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.
+    // 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
@@ -1450,6 +1477,14 @@ bool MergeJoin::isFinished() {
 }
 
 void MergeJoin::close() {
+  // Report match ratio statistics.
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->addRuntimeStat(
+        "matchedLeftRows", RuntimeCounter(matchedLeftRows_));
+    lockedStats->addRuntimeStat(
+        "matchedRightRows", RuntimeCounter(matchedRightRows_));
+  }
   if (rightSource_) {
     rightSource_->close();
   }
@@ -1468,8 +1503,8 @@ void MergeJoin::finishDrain() {
 
   leftHasDrained_ = false;
   rightHasDrained_ = false;
-  input_ = nullptr;
-  rightInput_ = nullptr;
+  clearLeftInput();
+  clearRightInput();
   leftMatch_.reset();
   rightMatch_.reset();
   if (joinTracker_.has_value()) {
diff --git a/velox/exec/MergeJoin.h b/velox/exec/MergeJoin.h
index 47dea482554d..67dfadf917fe 100644
--- a/velox/exec/MergeJoin.h
+++ b/velox/exec/MergeJoin.h
@@ -235,6 +235,12 @@ class MergeJoin : public Operator {
   // right.
   bool addToOutputForRightJoin();
 
+ private:
+  // Template function to consolidate addToOutputForLeftJoin and
+  // addToOutputForRightJoin
+  template <bool IsLeftJoin>
+  bool addToOutputImpl();
+
   // Tries to add 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
@@ -274,16 +280,62 @@ class MergeJoin : public Operator {
   // rightRowIndex_ are unchanged.
   bool tryAddOutputRowForRightJoin();
 
+  // Checks if we need to fetch more input from the right side of the join.
+  // Returns true if the right side has not been exhausted and we don't have
+  // a pending future for right side input and there's no current right input
+  // batch available for processing.
+  bool needsInputFromRightSide() const;
+
+  // Attempts to get the next batch of input from the right side. This method
+  // will keep trying to get input until either:
+  // 1. A right input batch is received
+  // 2. The right side is exhausted
+  // 3. A blocking operation is encountered
+  // Returns true if successful (got input or exhausted), false if blocked.
+  bool getNextFromRightSide();
+
+  // Processes the draining state when one or both sides of the join have been
+  // exhausted. Handles cleanup operations like dropping input sources for
+  // different join types (inner, left, right, anti) when appropriate.
+  // Returns true if draining is complete and the operator should return
+  // nullptr, false if draining is still in progress or there is no draining.
+  bool processDrain();
+
   // If all rows from the current left batch have been processed.
-  bool finishedLeftBatch() const {
+  bool leftBatchFinished() const {
     return leftRowIndex_ == input_->size();
   }
 
   // If all rows from the current right batch have been processed.
-  bool finishedRightBatch() const {
+  bool rightBatchFinished() const {
     return rightRowIndex_ == rightInput_->size();
   }
 
+  // Tries to complete incomplete matches on both left and right sides.
+  // Returns true if both matches are complete, false if more input is needed.
+  bool advanceMatch();
+
+  // Tries to complete an incomplete match on the left side by finding the end
+  // of matching key sequence. Returns true if complete, false if more input
+  // needed.
+  bool advanceLeftMatch();
+
+  // Tries to complete an incomplete match on the right side by finding the end
+  // of matching key sequence. Returns true if complete, false if more input
+  // needed.
+  bool advanceRightMatch();
+
+  // Template function to consolidate advanceLeftMatch and advanceRightMatch
+  // logic. Uses compile-time template parameter to handle left vs right
+  // differences.
+  template <bool IsLeft>
+  bool advanceMatchImpl();
+
+  // Handles output generation when only one side of the join has data
+  // available. Processes unmatched rows for outer joins when the other side is
+  // exhausted.
+  RowVectorPtr handleSingleSideOutput();
+
   // Properly resizes and produces the current output vector if one is
   // available.
   RowVectorPtr produceOutput() {
@@ -310,6 +362,16 @@ class MergeJoin : public Operator {
   // rows from the left side that have a match on the right.
   RowVectorPtr filterOutputForAntiJoin(const RowVectorPtr& output);
 
+  // Clears the current left input batch (input_) by setting it to nullptr.
+  // Called when the left batch has been fully processed or when resetting
+  // state during match processing.
+  void clearLeftInput();
+
+  // Clears the current right input batch (rightInput_) by setting it to
+  // nullptr. Called when the right batch has been fully processed or when
+  // resetting state during match processing.
+  void clearRightInput();
+
   // 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 JoinTracker::addMatch and addMiss methods for that.
@@ -394,11 +456,12 @@ class MergeJoin : public Operator {
     // rows that correspond to a single left-side row. Use
     // 'noMoreFilterResults' to make sure 'onMiss' is called for the last
     // left-side row.
-    template <typename TOnMiss>
+    template <typename TOnMiss, typename TOnMatch>
     void processFilterResult(
         vector_size_t outputIndex,
         bool passed,
-        TOnMiss onMiss) {
+        const TOnMiss& onMiss,
+        const TOnMatch& onMatch) {
       const auto rowNumber = rawLeftRowNumbers_[outputIndex];
       if (currentLeftRowNumber_ != rowNumber) {
         if (currentRow_ != -1 && !currentRowPassed_) {
@@ -412,6 +475,7 @@ class MergeJoin : public Operator {
       }
 
       if (passed) {
+        onMatch(outputIndex, /*firstMatch=*/!currentRowPassed_);
         currentRowPassed_ = true;
       }
     }
@@ -561,12 +625,18 @@ class MergeJoin : public Operator {
   vector_size_t outputSize_;
 
   // A future that will be completed when right side input becomes available.
-  ContinueFuture futureRightSideInput_{ContinueFuture::makeEmpty()};
+  ContinueFuture rightSideInputFuture_{ContinueFuture::makeEmpty()};
 
   // True if all the right side data has been received.
   bool noMoreRightInput_{false};
 
   bool leftHasDrained_{false};
   bool rightHasDrained_{false};
+
+  // Stats for tracking matched rows from the left side
+  uint64_t matchedLeftRows_{0};
+
+  // Stats for tracking matched rows from the right side
+  uint64_t matchedRightRows_{0};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/MergeSource.cpp b/velox/exec/MergeSource.cpp
index 411decd83e6e..b2e4005ebf62 100644
--- a/velox/exec/MergeSource.cpp
+++ b/velox/exec/MergeSource.cpp
@@ -198,15 +198,16 @@ class MergeExchangeSource : public MergeSource {
       memory::MemoryPool* pool,
       folly::Executor* executor)
       : mergeExchange_(mergeExchange),
-        client_(std::make_shared<ExchangeClient>(
-            mergeExchange->taskId(),
-            destination,
-            maxQueuedBytes,
-            1,
-            // Deliver right away to avoid blocking other sources
-            0,
-            pool,
-            executor)) {
+        client_(
+            std::make_shared<ExchangeClient>(
+                mergeExchange->taskId(),
+                destination,
+                maxQueuedBytes,
+                1,
+                // Deliver right away to avoid blocking other sources
+                0,
+                pool,
+                executor)) {
     client_->addRemoteTaskId(taskId);
     client_->noMoreRemoteTasks();
   }
@@ -286,16 +287,14 @@ class MergeExchangeSource : public MergeSource {
 
   std::shared_ptr<ExchangeClient> client_;
   std::unique_ptr<ByteInputStream> inputStream_;
-  std::unique_ptr<SerializedPage> currentPage_;
+  std::unique_ptr<SerializedPageBase> currentPage_;
   bool atEnd_ = false;
 };
 } // namespace
 
-std::shared_ptr<MergeSource> MergeSource::createLocalMergeSource() {
-  // Buffer up to 2 vectors from each source before blocking to wait
-  // for consumers.
-  static const int kDefaultQueueSize = 2;
-  return std::make_shared<LocalMergeSource>(kDefaultQueueSize);
+std::shared_ptr<MergeSource> MergeSource::createLocalMergeSource(
+    int queueSize) {
+  return std::make_shared<LocalMergeSource>(queueSize);
 }
 
 std::shared_ptr<MergeSource> MergeSource::createMergeExchangeSource(
diff --git a/velox/exec/MergeSource.h b/velox/exec/MergeSource.h
index e5892add6ed9..ed9f3d1f37fa 100644
--- a/velox/exec/MergeSource.h
+++ b/velox/exec/MergeSource.h
@@ -46,7 +46,7 @@ class MergeSource {
   virtual void close() = 0;
 
   // Factory methods to create MergeSources.
-  static std::shared_ptr<MergeSource> createLocalMergeSource();
+  static std::shared_ptr<MergeSource> createLocalMergeSource(int queueSize);
 
   static std::shared_ptr<MergeSource> createMergeExchangeSource(
       MergeExchange* mergeExchange,
diff --git a/velox/exec/NestedLoopJoinProbe.cpp b/velox/exec/NestedLoopJoinProbe.cpp
index 370c57ac103a..3c72407796cc 100644
--- a/velox/exec/NestedLoopJoinProbe.cpp
+++ b/velox/exec/NestedLoopJoinProbe.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/NestedLoopJoinProbe.h"
+#include "velox/exec/DriverStats.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/FieldReference.h"
@@ -250,6 +251,17 @@ RowVectorPtr NestedLoopJoinProbe::getOutput() {
     // Generate actual join output by processing probe and build matches, and
     // probe mismaches (for left joins).
     output = generateOutput();
+
+    // generateOutput() can be computationally expensive when
+    // processing large buildVectors_, as it iterates through all build rows for
+    // each probe row. The probe moves slowly through buildVectors_, making the
+    // numOutputRows_ >= outputBatchSize_ check harder to reach, which can cause
+    // driver threads to get stuck in long-running processing loops that exceed
+    // their allocated CPU time slice limits, preventing other tasks from being
+    // scheduled and degrading overall system responsiveness.
+    if (FOLLY_UNLIKELY(shouldYield())) {
+      break;
+    }
   }
   return output;
 }
diff --git a/velox/exec/NestedLoopJoinProbe.h b/velox/exec/NestedLoopJoinProbe.h
index aa2a0f6b4080..cbec6cc4dae0 100644
--- a/velox/exec/NestedLoopJoinProbe.h
+++ b/velox/exec/NestedLoopJoinProbe.h
@@ -124,7 +124,7 @@ class NestedLoopJoinProbe : public Operator {
   // 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 if it returns true, it's the caller's responsiblity to deicide when to
+  // Also if it returns true, it's the caller's responsiblity to decide when to
   // set `output_` size.
   //
   // Also updates `buildMatched_` if the build records that received a match, so
diff --git a/velox/exec/OneWayStatusFlag.h b/velox/exec/OneWayStatusFlag.h
index 8610585d155f..4eea37c24713 100644
--- a/velox/exec/OneWayStatusFlag.h
+++ b/velox/exec/OneWayStatusFlag.h
@@ -16,53 +16,28 @@
 
 #pragma once
 
-#include <folly/synchronization/SanitizeThread.h>
 #include <atomic>
 
 namespace facebook::velox::exec {
 
-/// A simple one way status flag that uses a non atomic flag to avoid
-/// unnecessary atomic operations.
 class OneWayStatusFlag {
  public:
-  bool check() const {
-#if defined(__x86_64__)
-    /// This flag is can only go from false to true, and must is only checked at
-    /// the end of a loop. Given that once a flag is true it can never go back
-    /// to false, we are ok to use this in a non synchronized manner to avoid
-    /// the overhead. As such we consciously exempt ourselves here from TSAN
-    /// detection.
-    folly::annotate_ignore_thread_sanitizer_guard g(__FILE__, __LINE__);
-    return fastStatus_ || atomicStatus_.load();
-#else
-    return atomicStatus_.load(std::memory_order_relaxed) ||
-        atomicStatus_.load();
-#endif
+  bool check() const noexcept {
+    return status_.load(std::memory_order_acquire);
   }
 
-  void set() {
-#if defined(__x86_64__)
-    if (!fastStatus_) {
-      atomicStatus_.store(true);
-      fastStatus_ = true;
+  void set() noexcept {
+    if (!status_.load(std::memory_order_relaxed)) {
+      status_.store(true, std::memory_order_release);
     }
-#else
-    if (!atomicStatus_.load(std::memory_order_relaxed)) {
-      atomicStatus_.store(true);
-    }
-#endif
   }
 
-  /// Operator overload to convert OneWayStatusFlag to bool
-  operator bool() const {
+  explicit operator bool() const noexcept {
     return check();
   }
 
  private:
-#if defined(__x86_64__)
-  bool fastStatus_{false};
-#endif
-  std::atomic_bool atomicStatus_{false};
+  std::atomic_bool status_{false};
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Operator.cpp b/velox/exec/Operator.cpp
index 29bfbef7cb5e..1729247854f7 100644
--- a/velox/exec/Operator.cpp
+++ b/velox/exec/Operator.cpp
@@ -68,9 +68,12 @@ OperatorCtx::createConnectorQueryCtx(
       driverCtx_->driverId,
       driverCtx_->queryConfig().sessionTimezone(),
       driverCtx_->queryConfig().adjustTimestampToTimezone(),
-      task->getCancellationToken());
+      task->getCancellationToken(),
+      task->queryCtx()->fsTokenProvider());
   connectorQueryCtx->setSelectiveNimbleReaderEnabled(
       driverCtx_->queryConfig().selectiveNimbleReaderEnabled());
+  connectorQueryCtx->setRowSizeTrackingMode(
+      driverCtx_->queryConfig().rowSizeTrackingMode());
   return connectorQueryCtx;
 }
 
@@ -81,18 +84,23 @@ Operator::Operator(
     std::string planNodeId,
     std::string operatorType,
     std::optional<common::SpillConfig> spillConfig)
-    : operatorCtx_(std::make_unique<OperatorCtx>(
-          driverCtx,
-          planNodeId,
-          operatorId,
-          operatorType)),
+    : operatorCtx_(
+          std::make_unique<OperatorCtx>(
+              driverCtx,
+              planNodeId,
+              operatorId,
+              operatorType)),
       outputType_(std::move(outputType)),
       spillConfig_(std::move(spillConfig)),
-      stats_(OperatorStats{
-          operatorId,
-          driverCtx->pipelineId,
-          std::move(planNodeId),
-          std::move(operatorType)}) {}
+      dryRun_(
+          operatorCtx_->driverCtx()->traceConfig().has_value() &&
+          operatorCtx_->driverCtx()->traceConfig()->dryRun),
+      stats_(
+          OperatorStats{
+              operatorId,
+              driverCtx->pipelineId,
+              std::move(planNodeId),
+              std::move(operatorType)}) {}
 
 void Operator::maybeSetReclaimer() {
   VELOX_CHECK_NULL(pool()->reclaimer());
@@ -111,7 +119,7 @@ void Operator::maybeSetTracer() {
   }
 
   const auto nodeId = planNodeId();
-  if (traceConfig->queryNodes.count(nodeId) == 0) {
+  if (traceConfig->queryNodeId.empty() || traceConfig->queryNodeId != nodeId) {
     return;
   }
 
@@ -141,7 +149,7 @@ void Operator::maybeSetTracer() {
       opTraceDirPath,
       operatorCtx_->driverCtx()->queryConfig().opTraceDirectoryCreateConfig());
 
-  if (operatorType() == "TableScan") {
+  if (dynamic_cast<SourceOperator*>(this) != nullptr) {
     setupSplitTracer(opTraceDirPath);
   } else {
     setupInputTracer(opTraceDirPath);
@@ -375,7 +383,7 @@ void Operator::recordBlockingTime(uint64_t start, BlockingReason reason) {
           std::chrono::high_resolution_clock::now().time_since_epoch())
           .count();
   const auto wallNanos = (now - start) * 1000;
-  const auto blockReason = blockingReasonToString(reason).substr(1);
+  const auto blockReason = BlockingReasonName::toName(reason).substr(1);
 
   auto lockedStats = stats_.wlock();
   lockedStats->blockedWallNanos += wallNanos;
@@ -387,7 +395,7 @@ void Operator::recordBlockingTime(uint64_t start, BlockingReason reason) {
 }
 
 void Operator::recordSpillStats() {
-  const auto lockedSpillStats = spillStats_.wlock();
+  const auto lockedSpillStats = spillStats_->wlock();
   auto lockedStats = stats_.wlock();
   lockedStats->spilledInputBytes += lockedSpillStats->spilledInputBytes;
   lockedStats->spilledBytes += lockedSpillStats->spilledBytes;
@@ -589,6 +597,14 @@ void OperatorStats::add(const OperatorStats& other) {
     }
   }
 
+  for (const auto& [name, exprStats] : other.expressionStats) {
+    if (UNLIKELY(expressionStats.count(name) == 0)) {
+      expressionStats.insert(std::make_pair(name, exprStats));
+    } else {
+      expressionStats.at(name).add(exprStats);
+    }
+  }
+
   numDrivers += other.numDrivers;
   spilledInputBytes += other.spilledInputBytes;
   spilledBytes += other.spilledBytes;
@@ -625,6 +641,7 @@ void OperatorStats::clear() {
   memoryStats.clear();
 
   runtimeStats.clear();
+  expressionStats.clear();
 
   numDrivers = 0;
   spilledInputBytes = 0;
diff --git a/velox/exec/Operator.h b/velox/exec/Operator.h
index fd3bb3234ac5..7af6e4cd34d5 100644
--- a/velox/exec/Operator.h
+++ b/velox/exec/Operator.h
@@ -17,11 +17,11 @@
 
 #include <folly/Synchronized.h>
 #include "velox/core/PlanNode.h"
+#include "velox/core/QueryCtx.h"
 #include "velox/exec/Driver.h"
 #include "velox/exec/JoinBridge.h"
 #include "velox/exec/OperatorStats.h"
 #include "velox/exec/OperatorTraceWriter.h"
-#include "velox/type/Filter.h"
 
 namespace facebook::velox::exec {
 
@@ -152,6 +152,11 @@ class Operator : public BaseRuntimeStatWriter {
     }
   };
 
+  /// The name for background cpu time metric if operator has background cpu
+  /// usages outside its driver thread.
+  static inline const std::string kBackgroundCpuTimeNanos =
+      "backgroundCpuTimeNanos";
+
   /// The name of the runtime spill stats collected and reported by operators
   /// that support spilling.
 
@@ -283,40 +288,31 @@ class Operator : public BaseRuntimeStatWriter {
   /// build side is empty.
   virtual bool isFinished() = 0;
 
+  /// True if the operator is in dry run mode which is only used by input
+  /// trace collection for crash debugging.
+  bool dryRun() const {
+    return dryRun_;
+  }
+
   /// Traces input batch of the operator.
   virtual void traceInput(const RowVectorPtr&);
 
   /// Finishes tracing of the operator.
   virtual void finishTrace();
 
-  /// Returns single-column dynamically generated filters to be pushed down to
-  /// upstream operators. Used to push down filters on join keys from broadcast
-  /// hash join into probe-side table scan. Can also be used to push down TopN
-  /// cutoff.
-  virtual const std::
-      unordered_map<column_index_t, std::shared_ptr<common::Filter>>&
-      getDynamicFilters() const {
-    return dynamicFilters_;
-  }
-
-  /// Clears dynamically generated filters. Called after filters were pushed
-  /// down.
-  virtual void clearDynamicFilters() {
-    dynamicFilters_.clear();
-  }
-
   /// Returns true if this operator would accept a filter dynamically generated
   /// by a downstream operator.
   virtual bool canAddDynamicFilter() const {
     return false;
   }
 
-  /// Adds a filter dynamically generated by a downstream operator. Called only
-  /// if canAddFilter() returns true.
-  virtual void addDynamicFilter(
+  /// Adds pending filters dynamically generated by a downstream
+  /// operator. Called only if canAddDynamicFilter() returns true. Shared lock
+  /// on the PushdownFilters is already held by current thread when this method
+  /// is called by driver.
+  virtual void addDynamicFilterLocked(
       const core::PlanNodeId& /*producer*/,
-      column_index_t /*outputChannel*/,
-      const std::shared_ptr<common::Filter>& /*filter*/) {
+      const PushdownFilters& /*filters*/) {
     VELOX_UNSUPPORTED(
         "This operator doesn't support dynamic filter pushdown: {}",
         toString());
@@ -632,10 +628,13 @@ class Operator : public BaseRuntimeStatWriter {
   /// the fs dir path to store spill files), otherwise null.
   const std::optional<common::SpillConfig> spillConfig_;
 
+  const bool dryRun_;
+
   bool initialized_{false};
 
   folly::Synchronized<OperatorStats> stats_;
-  folly::Synchronized<common::SpillStats> spillStats_;
+  std::shared_ptr<folly::Synchronized<common::SpillStats>> spillStats_ =
+      std::make_shared<folly::Synchronized<common::SpillStats>>();
 
   /// NOTE: only one of the two could be set for an operator for tracing .
   /// 'splitTracer_' is only set for table scan to record the processed split
@@ -664,8 +663,14 @@ class Operator : public BaseRuntimeStatWriter {
   /// could copy directly from input to output if no cardinality change.
   bool isIdentityProjection_ = false;
 
-  std::unordered_map<column_index_t, std::shared_ptr<common::Filter>>
-      dynamicFilters_;
+  /// Returns true if the driver should yield execution to prevent getting
+  /// stuck in long processing loops that exceed their allocated CPU time
+  /// slice limits. Operators should call this method as yield points during
+  /// time-consuming operations to allow other tasks to be scheduled and
+  /// maintain system responsiveness.
+  bool shouldYield() const {
+    return operatorCtx_->driverCtx()->driver->shouldYield();
+  }
 
  private:
   // Setup 'inputTracer_' to record the processed input vectors.
@@ -698,13 +703,15 @@ class SourceOperator : public Operator {
       RowTypePtr outputType,
       int32_t operatorId,
       const std::string& planNodeId,
-      const std::string& operatorType)
+      const std::string& operatorType,
+      const std::optional<common::SpillConfig>& spillConfig = std::nullopt)
       : Operator(
             driverCtx,
             std::move(outputType),
             operatorId,
             planNodeId,
-            operatorType) {}
+            operatorType,
+            spillConfig) {}
 
   bool needsInput() const override {
     return false;
diff --git a/velox/exec/OperatorStats.h b/velox/exec/OperatorStats.h
index f833b1b10403..9c95bf25eb41 100644
--- a/velox/exec/OperatorStats.h
+++ b/velox/exec/OperatorStats.h
@@ -15,8 +15,11 @@
  */
 #pragma once
 
+#include "velox/common/base/RuntimeMetrics.h"
 #include "velox/common/memory/MemoryPool.h"
 #include "velox/common/time/CpuWallTimer.h"
+#include "velox/core/PlanNode.h"
+#include "velox/expression/ExprStats.h"
 
 namespace facebook::velox::exec {
 
@@ -86,6 +89,11 @@ struct DynamicFilterStats {
 };
 
 struct OperatorStats {
+  /// Runtime stat name for per-driver CPU time (actual work time, not including
+  /// blocked time) for this operator. The max field will contain the CPU time
+  /// from the longest running single driver.
+  static constexpr const char* kDriverCpuTime = "driverCpuTimeNanos";
+
   /// Initial ordinal position in the operator's pipeline.
   int32_t operatorId = 0;
   int32_t pipelineId = 0;
@@ -181,6 +189,11 @@ struct OperatorStats {
 
   std::unordered_map<std::string, RuntimeMetric> runtimeStats;
 
+  // A map of expression name to its respective stats.
+  // These are only populated when a copy of the stats is returned via
+  // Operator::stats(bool) API.
+  std::unordered_map<std::string, ExprStats> expressionStats;
+
   int numDrivers = 0;
 
   OperatorStats() = default;
diff --git a/velox/exec/OperatorTraceWriter.h b/velox/exec/OperatorTraceWriter.h
index 437f43daba0b..189577dee1f0 100644
--- a/velox/exec/OperatorTraceWriter.h
+++ b/velox/exec/OperatorTraceWriter.h
@@ -59,7 +59,7 @@ class OperatorTraceInputWriter {
       true,
       common::CompressionKind::CompressionKind_ZSTD,
       0.8,
-      /*nullsFirst=*/true};
+      /*_nullsFirst=*/true};
   const std::shared_ptr<filesystems::FileSystem> fs_;
   memory::MemoryPool* const pool_;
   VectorSerde* const serde_;
diff --git a/velox/exec/OperatorUtils.cpp b/velox/exec/OperatorUtils.cpp
index 89f2eb1d0322..ba386ade1192 100644
--- a/velox/exec/OperatorUtils.cpp
+++ b/velox/exec/OperatorUtils.cpp
@@ -14,10 +14,13 @@
  * limitations under the License.
  */
 #include "velox/exec/OperatorUtils.h"
+#include "velox/exec/PartitionedOutput.h"
 #include "velox/exec/VectorHasher.h"
 #include "velox/expression/EvalCtx.h"
+#include "velox/serializers/PrestoSerializer.h"
 #include "velox/vector/ConstantVector.h"
 #include "velox/vector/FlatVector.h"
+#include "velox/vector/LazyVector.h"
 
 namespace facebook::velox::exec {
 
@@ -100,7 +103,11 @@ void gatherCopy(
     const std::vector<const RowVector*>& sources,
     const std::vector<vector_size_t>& sourceIndices,
     column_index_t sourceChannel) {
-  if (target->isScalar()) {
+  const bool flattenSources =
+      std::all_of(sources.begin(), sources.end(), [](const auto& source) {
+        return source->isFlatEncoding();
+      });
+  if (target->isScalar() && flattenSources) {
     VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
         scalarGatherCopy,
         target->type()->kind(),
@@ -121,10 +128,11 @@ void gatherCopy(
 bool shouldAggregateRuntimeMetric(const std::string& name) {
   static const folly::F14FastSet<std::string> metricNames{
       "dataSourceAddSplitWallNanos",
-      "dataSourceReadWallNanos",
       "dataSourceLazyWallNanos",
       "queuedWallNanos",
-      "flushTimes"};
+      "flushTimes",
+      "driverCpuTimeNanos",
+      "ioWaitWallNanos"};
   if (metricNames.contains(name)) {
     return true;
   }
@@ -230,7 +238,7 @@ vector_size_t processEncodedFilterResults(
     const SelectivityVector& rows,
     FilterEvalCtx& filterEvalCtx,
     memory::MemoryPool* pool) {
-  auto size = rows.size();
+  const auto size = rows.size();
 
   DecodedVector& decoded = filterEvalCtx.decodedResult;
   decoded.decode(*filterResult.get(), rows);
@@ -456,6 +464,14 @@ std::string makeOperatorSpillPath(
   return fmt::format("{}/{}_{}_{}", spillDir, pipelineId, driverId, operatorId);
 }
 
+void setOperatorRuntimeStats(
+    const std::string& name,
+    const RuntimeCounter& value,
+    std::unordered_map<std::string, RuntimeMetric>& stats) {
+  stats[name] = RuntimeMetric(value.unit);
+  stats[name].addValue(value.value);
+}
+
 void addOperatorRuntimeStats(
     const std::string& name,
     const RuntimeCounter& value,
@@ -505,12 +521,24 @@ void projectChildren(
     const std::vector<IdentityProjection>& projections,
     int32_t size,
     const BufferPtr& mapping) {
+  int maxInputChannel = -1;
+  int maxOutputChannel = -1;
   for (auto [inputChannel, outputChannel] : projections) {
-    if (outputChannel >= projectedChildren.size()) {
-      projectedChildren.resize(outputChannel + 1);
+    maxInputChannel = std::max<int>(maxInputChannel, inputChannel);
+    maxOutputChannel = std::max<int>(maxOutputChannel, outputChannel);
+  }
+  // Cache for already wrapped children to avoid wrapping the same child
+  // multiple times.
+  std::vector<VectorPtr> wrappedChildren(1 + maxInputChannel);
+  if (1 + maxOutputChannel > projectedChildren.size()) {
+    projectedChildren.resize(1 + maxOutputChannel);
+  }
+  for (auto [inputChannel, outputChannel] : projections) {
+    auto& wrapped = wrappedChildren[inputChannel];
+    if (!wrapped) {
+      wrapped = wrapChild(size, mapping, src[inputChannel]);
     }
-    projectedChildren[outputChannel] =
-        wrapChild(size, mapping, src[inputChannel]);
+    projectedChildren[outputChannel] = wrapped;
   }
 }
 
@@ -549,4 +577,20 @@ std::unique_ptr<Operator> BlockedOperatorFactory::toOperator(
   }
   return nullptr;
 }
+
+std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
+    common::CompressionKind compressionKind,
+    VectorSerde::Kind kind,
+    std::optional<float> minCompressionRatio) {
+  std::unique_ptr<VectorSerde::Options> options =
+      kind == VectorSerde::Kind::kPresto
+      ? std::make_unique<serializer::presto::PrestoVectorSerde::PrestoOptions>()
+      : std::make_unique<VectorSerde::Options>();
+  options->compressionKind = compressionKind;
+  if (minCompressionRatio.has_value()) {
+    options->minCompressionRatio = minCompressionRatio.value();
+  }
+  return options;
+}
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/OperatorUtils.h b/velox/exec/OperatorUtils.h
index 1f7c25efda32..605edba4a288 100644
--- a/velox/exec/OperatorUtils.h
+++ b/velox/exec/OperatorUtils.h
@@ -15,8 +15,11 @@
  */
 #pragma once
 
+#include <optional>
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/Spiller.h"
+#include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::exec {
 
@@ -145,6 +148,12 @@ std::string makeOperatorSpillPath(
     int driverId,
     int32_t operatorId);
 
+/// Set a named runtime metric in operator 'stats'.
+void setOperatorRuntimeStats(
+    const std::string& name,
+    const RuntimeCounter& value,
+    std::unordered_map<std::string, RuntimeMetric>& stats);
+
 /// Add a named runtime metric to operator 'stats'.
 void addOperatorRuntimeStats(
     const std::string& name,
@@ -168,7 +177,8 @@ folly::Range<vector_size_t*> initializeRowNumberMapping(
 /// 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. Dictionary wrapping of the same child vector is cached for
+/// reuse. 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(
@@ -300,4 +310,12 @@ class BlockedOperatorFactory : public Operator::PlanNodeTranslator {
  private:
   BlockedOperatorCb blockedCb_{nullptr};
 };
+
+/// Creates VectorSerde::Options for the given VectorSerde kind with compression
+/// settings. Optionally configures minimum compression ratio.
+std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
+    common::CompressionKind compressionKind,
+    VectorSerde::Kind kind,
+    std::optional<float> minCompressionRatio = std::nullopt);
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/OrderBy.cpp b/velox/exec/OrderBy.cpp
index 93fd410c3307..dc6b5d54809b 100644
--- a/velox/exec/OrderBy.cpp
+++ b/velox/exec/OrderBy.cpp
@@ -67,7 +67,7 @@ OrderBy::OrderBy(
       &nonReclaimableSection_,
       driverCtx->prefixSortConfig(),
       spillConfig_.has_value() ? &(spillConfig_.value()) : nullptr,
-      &spillStats_);
+      spillStats_.get());
 }
 
 void OrderBy::addInput(RowVectorPtr input) {
diff --git a/velox/exec/OutputBuffer.cpp b/velox/exec/OutputBuffer.cpp
index eb00d51852f4..f43fab2b8cc3 100644
--- a/velox/exec/OutputBuffer.cpp
+++ b/velox/exec/OutputBuffer.cpp
@@ -30,10 +30,10 @@ void ArbitraryBuffer::noMoreData() {
   pages_.push_back(nullptr);
 }
 
-void ArbitraryBuffer::enqueue(std::unique_ptr<SerializedPage> page) {
+void ArbitraryBuffer::enqueue(std::unique_ptr<SerializedPageBase> 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()));
+  pages_.push_back(std::shared_ptr<SerializedPageBase>(page.release()));
 }
 
 void ArbitraryBuffer::getAvailablePageSizes(std::vector<int64_t>& out) const {
@@ -45,7 +45,7 @@ void ArbitraryBuffer::getAvailablePageSizes(std::vector<int64_t>& out) const {
   }
 }
 
-std::vector<std::shared_ptr<SerializedPage>> ArbitraryBuffer::getPages(
+std::vector<std::shared_ptr<SerializedPageBase>> 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
@@ -57,7 +57,7 @@ std::vector<std::shared_ptr<SerializedPage>> ArbitraryBuffer::getPages(
     VELOX_CHECK_EQ(pages_.size(), 1);
     return {nullptr};
   }
-  std::vector<std::shared_ptr<SerializedPage>> pages;
+  std::vector<std::shared_ptr<SerializedPageBase>> pages;
   uint64_t bytesRemoved{0};
   while (bytesRemoved < maxBytes && !pages_.empty()) {
     if (pages_.front() == nullptr) {
@@ -81,7 +81,7 @@ std::string ArbitraryBuffer::toString() const {
       hasNoMoreData());
 }
 
-void DestinationBuffer::Stats::recordEnqueue(const SerializedPage& data) {
+void DestinationBuffer::Stats::recordEnqueue(const SerializedPageBase& data) {
   const auto numRows = data.numRows();
   VELOX_CHECK(numRows.has_value(), "SerializedPage's numRows must be valid");
   bytesBuffered += data.size();
@@ -89,7 +89,8 @@ void DestinationBuffer::Stats::recordEnqueue(const SerializedPage& data) {
   ++pagesBuffered;
 }
 
-void DestinationBuffer::Stats::recordAcknowledge(const SerializedPage& data) {
+void DestinationBuffer::Stats::recordAcknowledge(
+    const SerializedPageBase& data) {
   const auto numRows = data.numRows();
   VELOX_CHECK(numRows.has_value(), "SerializedPage's numRows must be valid");
   const int64_t size = data.size();
@@ -104,7 +105,7 @@ void DestinationBuffer::Stats::recordAcknowledge(const SerializedPage& data) {
   ++pagesSent;
 }
 
-void DestinationBuffer::Stats::recordDelete(const SerializedPage& data) {
+void DestinationBuffer::Stats::recordDelete(const SerializedPageBase& data) {
   recordAcknowledge(data);
 }
 
@@ -185,7 +186,7 @@ DestinationBuffer::Data DestinationBuffer::getData(
   return {std::move(data), std::move(remainingBytes), true};
 }
 
-void DestinationBuffer::enqueue(std::shared_ptr<SerializedPage> data) {
+void DestinationBuffer::enqueue(std::shared_ptr<SerializedPageBase> data) {
   // Drop duplicate end markers.
   if (data == nullptr && !data_.empty() && data_.back() == nullptr) {
     return;
@@ -245,7 +246,7 @@ void DestinationBuffer::loadData(ArbitraryBuffer* buffer, uint64_t maxBytes) {
   }
 }
 
-std::vector<std::shared_ptr<SerializedPage>> DestinationBuffer::acknowledge(
+std::vector<std::shared_ptr<SerializedPageBase>> DestinationBuffer::acknowledge(
     int64_t sequence,
     bool fromGetData) {
   const int64_t numDeleted = sequence - sequence_;
@@ -268,7 +269,7 @@ std::vector<std::shared_ptr<SerializedPage>> DestinationBuffer::acknowledge(
 
   VELOX_CHECK_LE(
       numDeleted, data_.size(), "Ack received for a not yet produced item");
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> 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");
@@ -282,9 +283,9 @@ std::vector<std::shared_ptr<SerializedPage>> DestinationBuffer::acknowledge(
   return freed;
 }
 
-std::vector<std::shared_ptr<SerializedPage>>
+std::vector<std::shared_ptr<SerializedPageBase>>
 DestinationBuffer::deleteResults() {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> 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");
@@ -314,7 +315,7 @@ namespace {
 // 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<std::shared_ptr<SerializedPageBase>>& freed,
     std::vector<ContinuePromise>& promises) {
   freed.clear();
   for (auto& promise : promises) {
@@ -445,7 +446,7 @@ void OutputBuffer::updateTotalBufferedBytesMsLocked() {
 
 bool OutputBuffer::enqueue(
     int destination,
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     ContinueFuture* future) {
   VELOX_CHECK_NOT_NULL(data);
   VELOX_CHECK(
@@ -471,8 +472,6 @@ bool OutputBuffer::enqueue(
         enqueuePartitionedOutputLocked(
             destination, std::move(data), dataAvailableCallbacks);
         break;
-      default:
-        VELOX_UNREACHABLE(PartitionedOutputNode::kindString(kind_));
     }
 
     if (bufferedBytes_ >= maxSize_ && future) {
@@ -494,13 +493,13 @@ bool OutputBuffer::enqueue(
 }
 
 void OutputBuffer::enqueueBroadcastOutputLocked(
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     std::vector<DataAvailable>& dataAvailableCbs) {
   VELOX_DCHECK(isBroadcast());
   VELOX_CHECK_NULL(arbitraryBuffer_);
   VELOX_DCHECK(dataAvailableCbs.empty());
 
-  std::shared_ptr<SerializedPage> sharedData(data.release());
+  std::shared_ptr<SerializedPageBase> sharedData(data.release());
   for (auto& buffer : buffers_) {
     if (buffer != nullptr) {
       buffer->enqueue(sharedData);
@@ -516,7 +515,7 @@ void OutputBuffer::enqueueBroadcastOutputLocked(
 }
 
 void OutputBuffer::enqueueArbitraryOutputLocked(
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     std::vector<DataAvailable>& dataAvailableCbs) {
   VELOX_DCHECK(isArbitrary());
   VELOX_DCHECK_NOT_NULL(arbitraryBuffer_);
@@ -543,7 +542,7 @@ void OutputBuffer::enqueueArbitraryOutputLocked(
 
 void OutputBuffer::enqueuePartitionedOutputLocked(
     int destination,
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     std::vector<DataAvailable>& dataAvailableCbs) {
   VELOX_DCHECK(isPartitioned());
   VELOX_CHECK_NULL(arbitraryBuffer_);
@@ -633,7 +632,7 @@ bool OutputBuffer::isFinishedLocked() {
 }
 
 void OutputBuffer::acknowledge(int destination, int64_t sequence) {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> freed;
   std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::mutex> l(mutex_);
@@ -651,7 +650,7 @@ void OutputBuffer::acknowledge(int destination, int64_t sequence) {
 }
 
 void OutputBuffer::updateAfterAcknowledgeLocked(
-    const std::vector<std::shared_ptr<SerializedPage>>& freed,
+    const std::vector<std::shared_ptr<SerializedPageBase>>& freed,
     std::vector<ContinuePromise>& promises) {
   uint64_t freedBytes{0};
   int freedPages{0};
@@ -675,7 +674,7 @@ void OutputBuffer::updateAfterAcknowledgeLocked(
 }
 
 bool OutputBuffer::deleteResults(int destination) {
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> freed;
   std::vector<ContinuePromise> promises;
   bool isFinished;
   DataAvailable dataAvailable;
@@ -719,7 +718,7 @@ void OutputBuffer::getData(
     DataAvailableCallback notify,
     DataConsumerActiveCheckCallback activeCheck) {
   DestinationBuffer::Data data;
-  std::vector<std::shared_ptr<SerializedPage>> freed;
+  std::vector<std::shared_ptr<SerializedPageBase>> freed;
   std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::mutex> l(mutex_);
diff --git a/velox/exec/OutputBuffer.h b/velox/exec/OutputBuffer.h
index 640c1bfcd8e7..6b9667fece62 100644
--- a/velox/exec/OutputBuffer.h
+++ b/velox/exec/OutputBuffer.h
@@ -75,11 +75,11 @@ class ArbitraryBuffer {
   /// appends a null page at the end of 'pages_' as end marker.
   void noMoreData();
 
-  void enqueue(std::unique_ptr<SerializedPage> page);
+  void enqueue(std::unique_ptr<SerializedPageBase> 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::vector<std::shared_ptr<SerializedPageBase>> getPages(uint64_t maxBytes);
 
   /// Append the available page sizes to `out'.
   void getAvailablePageSizes(std::vector<int64_t>& out) const;
@@ -87,7 +87,7 @@ class ArbitraryBuffer {
   std::string toString() const;
 
  private:
-  std::deque<std::shared_ptr<SerializedPage>> pages_;
+  std::deque<std::shared_ptr<SerializedPageBase>> pages_;
 };
 
 class DestinationBuffer {
@@ -98,11 +98,11 @@ class DestinationBuffer {
   /// 2. Sent: the data is removed from the buffer after it is acked or
   ///          deleted.
   struct Stats {
-    void recordEnqueue(const SerializedPage& data);
+    void recordEnqueue(const SerializedPageBase& data);
 
-    void recordAcknowledge(const SerializedPage& data);
+    void recordAcknowledge(const SerializedPageBase& data);
 
-    void recordDelete(const SerializedPage& data);
+    void recordDelete(const SerializedPageBase& data);
 
     bool finished{false};
 
@@ -117,7 +117,7 @@ class DestinationBuffer {
     int64_t pagesSent{0};
   };
 
-  void enqueue(std::shared_ptr<SerializedPage> data);
+  void enqueue(std::shared_ptr<SerializedPageBase> data);
 
   /// Invoked to load data with up to 'notifyMaxBytes_' bytes from arbitrary
   /// 'buffer' if there is pending fetch from this destination in which case
@@ -165,12 +165,12 @@ class DestinationBuffer {
   /// 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(
+  std::vector<std::shared_ptr<SerializedPageBase>> 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();
+  std::vector<std::shared_ptr<SerializedPageBase>> deleteResults();
 
   /// Returns and clears the notify callback, if any, along with arguments for
   /// the callback.
@@ -187,7 +187,7 @@ class DestinationBuffer {
  private:
   void clearNotify();
 
-  std::vector<std::shared_ptr<SerializedPage>> data_;
+  std::vector<std::shared_ptr<SerializedPageBase>> data_;
   // The sequence number of the first in 'data_'.
   int64_t sequence_ = 0;
   DataAvailableCallback notify_{nullptr};
@@ -280,7 +280,7 @@ class OutputBuffer {
 
   bool enqueue(
       int destination,
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       ContinueFuture* future);
 
   void noMoreData();
@@ -345,7 +345,7 @@ class OutputBuffer {
   // Updates buffered size and returns possibly continuable producer promises
   // in 'promises'.
   void updateAfterAcknowledgeLocked(
-      const std::vector<std::shared_ptr<SerializedPage>>& freed,
+      const std::vector<std::shared_ptr<SerializedPageBase>>& freed,
       std::vector<ContinuePromise>& promises);
 
   /// Given an updated total number of broadcast buffers, add any missing ones
@@ -353,16 +353,16 @@ class OutputBuffer {
   void addOutputBuffersLocked(int numBuffers);
 
   void enqueueBroadcastOutputLocked(
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       std::vector<DataAvailable>& dataAvailableCbs);
 
   void enqueueArbitraryOutputLocked(
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       std::vector<DataAvailable>& dataAvailableCbs);
 
   void enqueuePartitionedOutputLocked(
       int destination,
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       std::vector<DataAvailable>& dataAvailableCbs);
 
   std::string toStringLocked() const;
@@ -401,7 +401,7 @@ class OutputBuffer {
   // 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::vector<std::shared_ptr<SerializedPageBase>> dataToBroadcast_;
 
   std::mutex mutex_;
   // Actual data size in 'buffers_'.
diff --git a/velox/exec/OutputBufferManager.cpp b/velox/exec/OutputBufferManager.cpp
index 4773911a530d..f8183218fb4f 100644
--- a/velox/exec/OutputBufferManager.cpp
+++ b/velox/exec/OutputBufferManager.cpp
@@ -57,7 +57,7 @@ uint64_t OutputBufferManager::numBuffers() const {
 bool OutputBufferManager::enqueue(
     const std::string& taskId,
     int destination,
-    std::unique_ptr<SerializedPage> data,
+    std::unique_ptr<SerializedPageBase> data,
     ContinueFuture* future) {
   return getBuffer(taskId)->enqueue(destination, std::move(data), future);
 }
diff --git a/velox/exec/OutputBufferManager.h b/velox/exec/OutputBufferManager.h
index 8affa6f90512..ef9487ee87b5 100644
--- a/velox/exec/OutputBufferManager.h
+++ b/velox/exec/OutputBufferManager.h
@@ -53,7 +53,7 @@ class OutputBufferManager {
   bool enqueue(
       const std::string& taskId,
       int destination,
-      std::unique_ptr<SerializedPage> data,
+      std::unique_ptr<SerializedPageBase> data,
       ContinueFuture* future);
 
   void noMoreData(const std::string& taskId);
diff --git a/velox/exec/ParallelProject.cpp b/velox/exec/ParallelProject.cpp
new file mode 100644
index 000000000000..d632553968a9
--- /dev/null
+++ b/velox/exec/ParallelProject.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 "velox/exec/ParallelProject.h"
+#include "velox/common/base/AsyncSource.h"
+#include "velox/exec/Operator.h"
+#include "velox/exec/Task.h"
+
+namespace facebook::velox::exec {
+
+ParallelProject::ParallelProject(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    const core::ParallelProjectNodePtr& node)
+    : Operator(
+          driverCtx,
+          node->outputType(),
+          operatorId,
+          node->id(),
+          "ParallelProject"),
+      node_(node) {}
+
+namespace {
+bool checkAddIdentityProjection(
+    const core::TypedExprPtr& projection,
+    const RowTypePtr& inputType,
+    column_index_t outputChannel,
+    std::vector<IdentityProjection>& identityProjections) {
+  if (auto field = core::TypedExprs::asFieldAccess(projection)) {
+    const auto& inputs = field->inputs();
+    if (inputs.empty() ||
+        (inputs.size() == 1 &&
+         dynamic_cast<const core::InputTypedExpr*>(inputs[0].get()))) {
+      const auto inputChannel = inputType->getChildIdx(field->name());
+      identityProjections.emplace_back(inputChannel, outputChannel);
+      return true;
+    }
+  }
+
+  return false;
+}
+} // namespace
+
+void ParallelProject::initialize() {
+  Operator::initialize();
+  std::vector<core::TypedExprPtr> allExprs;
+
+  const auto& inputType = node_->sources()[0]->outputType();
+  const auto& exprGroups = node_->exprGroups();
+
+  int32_t unitIdx = 0;
+  int32_t exprIdx = 0;
+  int32_t unitSize = exprGroups[unitIdx].size();
+  work_.emplace_back();
+  work_.back().execCtx = std::make_unique<core::ExecCtx>(
+      operatorCtx_->pool(), operatorCtx_->driverCtx()->task->queryCtx().get());
+
+  std::vector<core::TypedExprPtr> unitExprs;
+  for (column_index_t i = 0; i < node_->exprNames().size(); i++) {
+    const auto& projection = exprGroups[unitIdx][exprIdx];
+    bool identityProjection = checkAddIdentityProjection(
+        projection, inputType, i, identityProjections_);
+    if (!identityProjection) {
+      unitExprs.push_back(projection);
+      work_.back().resultProjections.emplace_back(unitExprs.size() - 1, i);
+    } else {
+      work_.back().loadOnly.push_back(identityProjections_.back().inputChannel);
+    }
+    ++exprIdx;
+    if (exprIdx == unitSize) {
+      // It may be that the only work is loading lazies.
+      auto tempExprs =
+          makeExprSetFromFlag(std::move(unitExprs), operatorCtx_->execCtx());
+      std::shared_ptr<ExprSet> shared(tempExprs.release());
+      work_.back().exprSet = std::move(shared);
+      ++unitIdx;
+      exprIdx = 0;
+      if (unitIdx == exprGroups.size()) {
+        break;
+      }
+      unitSize = exprGroups[unitIdx].size();
+      work_.emplace_back();
+      work_.back().execCtx = std::make_unique<core::ExecCtx>(
+          operatorCtx_->pool(),
+          operatorCtx_->driverCtx()->task->queryCtx().get());
+    }
+  }
+
+  int32_t outputIdx = node_->exprNames().size();
+  auto sourceType = node_->sources()[0]->outputType();
+  for (auto& name : node_->noLoadIdentities()) {
+    auto idx = sourceType->getChildIdx(name);
+    identityProjections_.emplace_back(idx, outputIdx++);
+  }
+}
+
+void ParallelProject::addInput(RowVectorPtr input) {
+  input_ = std::move(input);
+  numProcessedInputRows_ = 0;
+}
+
+bool ParallelProject::allInputProcessed() {
+  if (!input_) {
+    return true;
+  }
+  if (numProcessedInputRows_ == input_->size()) {
+    input_ = nullptr;
+    return true;
+  }
+  return false;
+}
+
+bool ParallelProject::isFinished() {
+  return noMoreInput_ && allInputProcessed();
+}
+
+RowVectorPtr ParallelProject::getOutput() {
+  if (allInputProcessed()) {
+    return nullptr;
+  }
+
+  vector_size_t size = input_->size();
+  allRows_.resize(size);
+  allRows_.setAll();
+  std::vector<std::shared_ptr<AsyncSource<WorkResult>>> pending;
+  std::vector<VectorPtr> results(outputType_->size());
+
+  for (auto i = 0; i < work_.size(); ++i) {
+    pending.push_back(
+        std::make_shared<AsyncSource<WorkResult>>(
+            [i, &results, this]() { return doWork(i, results); }));
+    auto item = pending.back();
+    operatorCtx_->task()->queryCtx()->executor()->add(
+        [item]() { item->prepare(); });
+  }
+  std::exception_ptr error;
+  for (auto i = 0; i < pending.size(); ++i) {
+    auto result = pending[i]->move();
+    stats_.wlock()->getOutputTiming.add(pending[i]->prepareTiming());
+    if (!error && result->error) {
+      error = result->error;
+    }
+  }
+  if (error) {
+    std::rethrow_exception(error);
+  }
+
+  for (auto& projection : identityProjections_) {
+    results[projection.outputChannel] =
+        input_->childAt(projection.inputChannel);
+  }
+  numProcessedInputRows_ = size;
+  input_.reset();
+  return std::make_shared<RowVector>(
+      operatorCtx_->pool(), outputType_, nullptr, size, std::move(results));
+}
+
+std::unique_ptr<ParallelProject::WorkResult> ParallelProject::doWork(
+    int32_t workIdx,
+    std::vector<VectorPtr>& results) {
+  auto& work = work_[workIdx];
+  EvalCtx evalCtx(work.execCtx.get(), work.exprSet.get(), input_.get());
+  try {
+    for (auto channel : work.loadOnly) {
+      evalCtx.ensureFieldLoaded(channel, allRows_);
+    }
+
+    std::vector<VectorPtr> localResults;
+    work.exprSet->eval(
+        0, work.exprSet->exprs().size(), true, allRows_, evalCtx, localResults);
+    for (auto& projection : work.resultProjections) {
+      results[projection.outputChannel] =
+          std::move(localResults[projection.inputChannel]);
+    }
+  } catch (const std::exception&) {
+    return std::make_unique<WorkResult>(std::current_exception());
+  }
+  return std::make_unique<WorkResult>(nullptr);
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/ParallelProject.h b/velox/exec/ParallelProject.h
new file mode 100644
index 000000000000..55be1c4002e6
--- /dev/null
+++ b/velox/exec/ParallelProject.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 "velox/exec/Driver.h"
+#include "velox/exec/Operator.h"
+#include "velox/expression/Expr.h"
+
+namespace facebook::velox::exec {
+
+class ParallelProject : public Operator {
+ public:
+  ParallelProject(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const core::ParallelProjectNodePtr& node);
+
+  bool isFilter() const override {
+    return false;
+  }
+
+  bool preservesOrder() const override {
+    return true;
+  }
+
+  bool needsInput() const override {
+    return !input_;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  BlockingReason isBlocked(ContinueFuture* /* unused */) override {
+    return BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+  void close() override {
+    Operator::close();
+    for (auto& work : work_) {
+      if (work.exprSet) {
+        work.exprSet->clear();
+      }
+    }
+  }
+
+  void initialize() override;
+
+ private:
+  struct WorkUnit {
+    // Maps from result channel of exprSet to channel in the node's output type.
+    std::vector<IdentityProjection> resultProjections;
+    // Positions in input which are to be loaded by this group.
+    std::vector<column_index_t> loadOnly;
+    std::unique_ptr<core::ExecCtx> execCtx;
+    std::shared_ptr<ExprSet> exprSet;
+  };
+
+  struct WorkResult {
+    WorkResult(std::exception_ptr e) : error(std::move(e)) {}
+    std::exception_ptr error;
+  };
+
+  // Tests if 'numProcessedRows_' equals to the length of input_ and clears
+  // outstanding references to input_ if done. Returns true if getOutput
+  // should return nullptr.
+  bool allInputProcessed();
+
+  std::unique_ptr<WorkResult> doWork(
+      int32_t workIdx,
+      std::vector<VectorPtr>& result);
+
+  // Cached ParallelProject node for lazy initialization. After
+  // initialization, they will be reset, and initialized_ will be set to true.
+  const core::ParallelProjectNodePtr node_;
+
+  bool initialized_{false};
+
+  std::vector<WorkUnit> work_;
+  SelectivityVector allRows_;
+  int32_t numProcessedInputRows_{0};
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/PartitionedOutput.cpp b/velox/exec/PartitionedOutput.cpp
index 28878ef21d15..86fd98db7961 100644
--- a/velox/exec/PartitionedOutput.cpp
+++ b/velox/exec/PartitionedOutput.cpp
@@ -15,24 +15,11 @@
  */
 
 #include "velox/exec/PartitionedOutput.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
-namespace {
-std::unique_ptr<VectorSerde::Options> getVectorSerdeOptions(
-    const core::QueryConfig& queryConfig,
-    VectorSerde::Kind kind) {
-  std::unique_ptr<VectorSerde::Options> options =
-      kind == VectorSerde::Kind::kPresto
-      ? std::make_unique<serializer::presto::PrestoVectorSerde::PrestoOptions>()
-      : std::make_unique<VectorSerde::Options>();
-  options->compressionKind =
-      common::stringToCompressionKind(queryConfig.shuffleCompressionKind());
-  options->minCompressionRatio = PartitionedOutput::minCompressionRatio();
-  return options;
-}
-} // namespace
 
 namespace detail {
 Destination::Destination(
@@ -145,7 +132,7 @@ BlockingReason Destination::flush(
   bool blocked = bufferManager.enqueue(
       taskId_,
       destination_,
-      std::make_unique<SerializedPage>(
+      std::make_unique<PrestoSerializedPage>(
           stream.getIOBuf(bufferReleaseFn), nullptr, flushedRows),
       future);
 
@@ -203,8 +190,11 @@ PartitionedOutput::PartitionedOutput(
       eagerFlush_(eagerFlush),
       serde_(getNamedVectorSerde(planNode->serdeKind())),
       serdeOptions_(getVectorSerdeOptions(
-          operatorCtx_->driverCtx()->queryConfig(),
-          planNode->serdeKind())) {
+          common::stringToCompressionKind(operatorCtx_->driverCtx()
+                                              ->queryConfig()
+                                              .shuffleCompressionKind()),
+          planNode->serdeKind(),
+          PartitionedOutput::minCompressionRatio())) {
   if (!planNode->isPartitioned()) {
     VELOX_USER_CHECK_EQ(numDestinations_, 1);
   }
@@ -256,17 +246,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,
-          serde_,
-          serdeOptions_.get(),
-          pool(),
-          eagerFlush_,
-          [&](uint64_t bytes, uint64_t rows) {
-            auto lockedStats = stats_.wlock();
-            lockedStats->addOutputVector(bytes, rows);
-          }));
+      destinations_.push_back(
+          std::make_unique<detail::Destination>(
+              taskId,
+              i,
+              serde_,
+              serdeOptions_.get(),
+              pool(),
+              eagerFlush_,
+              [&](uint64_t bytes, uint64_t rows) {
+                auto lockedStats = stats_.wlock();
+                lockedStats->addOutputVector(bytes, rows);
+              }));
     }
   }
 }
@@ -286,7 +277,7 @@ void PartitionedOutput::initializeSizeBuffers() {
 void PartitionedOutput::estimateRowSizes() {
   const auto numInput = input_->size();
   std::fill(rowSize_.begin(), rowSize_.end(), 0);
-  raw_vector<vector_size_t> storage;
+  raw_vector<vector_size_t> storage(pool());
   const auto numbers = iota(numInput, storage);
   const auto rows = folly::Range(numbers, numInput);
   if (serde_->kind() == VectorSerde::Kind::kCompactRow) {
diff --git a/velox/exec/PlanNodeStats.cpp b/velox/exec/PlanNodeStats.cpp
index 5306a642b5a0..76c47b3db399 100644
--- a/velox/exec/PlanNodeStats.cpp
+++ b/velox/exec/PlanNodeStats.cpp
@@ -59,6 +59,14 @@ PlanNodeStats& PlanNodeStats::operator+=(const PlanNodeStats& another) {
     }
   }
 
+  for (const auto& [name, exprStats] : another.expressionStats) {
+    auto const [it, inserted] =
+        this->expressionStats.try_emplace(name, exprStats);
+    if (!inserted) {
+      it->second.add(exprStats);
+    }
+  }
+
   // Populating number of drivers for plan nodes with multiple operators is not
   // useful. Each operator could have been executed in different pipelines with
   // different number of drivers.
@@ -131,6 +139,14 @@ void PlanNodeStats::addTotals(const OperatorStats& stats) {
     }
   }
 
+  for (const auto& [name, exprStats] : stats.expressionStats) {
+    if (UNLIKELY(this->expressionStats.count(name) == 0)) {
+      this->expressionStats.insert(std::make_pair(name, exprStats));
+    } else {
+      this->expressionStats.at(name).add(exprStats);
+    }
+  }
+
   // Populating number of drivers for plan nodes with multiple operators is not
   // useful. Each operator could have been executed in different pipelines with
   // different number of drivers.
@@ -290,7 +306,7 @@ namespace {
 void printCustomStats(
     const std::unordered_map<std::string, RuntimeMetric>& stats,
     const std::string& indentation,
-    std::stringstream& stream) {
+    std::ostream& stream) {
   int width = 0;
   for (const auto& entry : stats) {
     if (width < entry.first.size()) {
@@ -306,9 +322,9 @@ void printCustomStats(
   }
 
   for (const auto& [name, metric] : orderedStats) {
-    stream << std::endl;
     stream << indentation << std::left << std::setw(width) << name;
     metric.printMetric(stream);
+    stream << std::endl;
   }
 }
 } // namespace
@@ -330,16 +346,15 @@ std::string printPlanWithStats(
         // Print input rows and sizes only for leaf plan nodes. Including this
         // information for other plan nodes is redundant as it is the same as
         // output of the source nodes.
-        const bool includeInputStats = leafPlanNodes.count(planNodeId) > 0;
-        stream << stats.toString(includeInputStats);
+        const bool includeInputStats = leafPlanNodes.contains(planNodeId);
+        stream << indentation << stats.toString(includeInputStats) << std::endl;
 
         // Include break down by operator type for plan nodes with multiple
         // operators. Print input rows and sizes for all such nodes.
         if (stats.isMultiOperatorTypeNode()) {
           for (const auto& entry : stats.operatorStats) {
-            stream << std::endl;
             stream << indentation << entry.first << ": "
-                   << entry.second->toString(true);
+                   << entry.second->toString(true) << std::endl;
 
             if (includeCustomStats) {
               printCustomStats(
diff --git a/velox/exec/PlanNodeStats.h b/velox/exec/PlanNodeStats.h
index 8c41d7a0a46d..c1c6dbc00ee9 100644
--- a/velox/exec/PlanNodeStats.h
+++ b/velox/exec/PlanNodeStats.h
@@ -18,6 +18,7 @@
 #include <folly/dynamic.h>
 #include "velox/common/time/CpuWallTimer.h"
 #include "velox/exec/Operator.h"
+#include "velox/expression/ExprStats.h"
 
 namespace facebook::velox::exec {
 struct TaskStats;
@@ -142,6 +143,9 @@ struct PlanNodeStats {
   /// Total spilled files.
   uint32_t spilledFiles{0};
 
+  /// A map of expression name to its respective stats.
+  std::unordered_map<std::string, ExprStats> expressionStats;
+
   /// Add stats for a single operator instance.
   void add(const OperatorStats& stats);
 
diff --git a/velox/exec/PrefixSort.cpp b/velox/exec/PrefixSort.cpp
index 45bafec927eb..6578429a02e4 100644
--- a/velox/exec/PrefixSort.cpp
+++ b/velox/exec/PrefixSort.cpp
@@ -101,7 +101,7 @@ FOLLY_ALWAYS_INLINE void extractRowColumnToPrefix(
     default:
       VELOX_UNSUPPORTED(
           "prefix-sort does not support type kind: {}",
-          mapTypeKindToName(typeKind));
+          TypeKindName::toName(typeKind));
   }
 }
 
@@ -310,7 +310,7 @@ void PrefixSort::extractRowAndEncodePrefixKeys(char* row, char* prefixBuffer) {
 }
 
 // static.
-uint32_t PrefixSort::maxRequiredBytes(
+uint64_t PrefixSort::maxRequiredBytes(
     const RowContainer* rowContainer,
     const std::vector<CompareFlags>& compareFlags,
     const velox::common::PrefixSortConfig& config,
@@ -345,14 +345,15 @@ void PrefixSort::stdSort(
       });
 }
 
-uint32_t PrefixSort::maxRequiredBytes() const {
+uint64_t PrefixSort::maxRequiredBytes() const {
   const auto numRows = rowContainer_->numRows();
   const auto numPages =
       memory::AllocationTraits::numPages(numRows * sortLayout_.entrySize);
   // Prefix data size + swap buffer size.
   return memory::AllocationTraits::pageBytes(numPages) +
-      pool_->preferredSize(checkedPlus<size_t>(
-          sortLayout_.entrySize, AlignedBuffer::kPaddedSize)) +
+      pool_->preferredSize(
+          checkedPlus<size_t>(
+              sortLayout_.entrySize, AlignedBuffer::kPaddedSize)) +
       2 * pool_->alignment();
 }
 
diff --git a/velox/exec/PrefixSort.h b/velox/exec/PrefixSort.h
index 3d1fa46c2a5d..0bd888412c19 100644
--- a/velox/exec/PrefixSort.h
+++ b/velox/exec/PrefixSort.h
@@ -153,7 +153,7 @@ class PrefixSort {
   /// The std::sort won't require bytes while prefix sort may require buffers
   /// such as prefix data. The logic is similar to the above function
   /// PrefixSort::sort but returns the maximum buffer the sort may need.
-  static uint32_t maxRequiredBytes(
+  static uint64_t maxRequiredBytes(
       const RowContainer* rowContainer,
       const std::vector<CompareFlags>& compareFlags,
       const velox::common::PrefixSortConfig& config,
@@ -205,7 +205,7 @@ class PrefixSort {
 
   // Estimates the memory required for prefix sort such as prefix buffer and
   // swap buffer.
-  uint32_t maxRequiredBytes() const;
+  uint64_t maxRequiredBytes() const;
 
   void sortInternal(std::vector<char*, memory::StlAllocator<char*>>& rows);
 
diff --git a/velox/exec/RowContainer.cpp b/velox/exec/RowContainer.cpp
index d2c76d7c11d3..9671b6bf57a1 100644
--- a/velox/exec/RowContainer.cpp
+++ b/velox/exec/RowContainer.cpp
@@ -42,8 +42,7 @@ static int32_t typeKindSize(TypeKind kind) {
 __attribute__((__no_sanitize__("thread")))
 #endif
 #endif
-inline void
-setBit(char* bits, uint32_t idx) {
+inline void setBit(char* bits, uint32_t idx) {
   auto bitsAs8Bit = reinterpret_cast<uint8_t*>(bits);
   bitsAs8Bit[idx / 8] |= (1 << (idx % 8));
 }
@@ -137,14 +136,17 @@ RowContainer::RowContainer(
     bool isJoinBuild,
     bool hasProbedFlag,
     bool hasNormalizedKeys,
+    bool useListRowIndex,
     memory::MemoryPool* pool)
     : keyTypes_(keyTypes),
       nullableKeys_(nullableKeys),
       isJoinBuild_(isJoinBuild),
       hasNormalizedKeys_(hasNormalizedKeys),
+      useListRowIndex_(useListRowIndex),
       stringAllocator_(std::make_unique<HashStringAllocator>(pool)),
       accumulators_(accumulators),
-      rows_(pool) {
+      rows_(pool),
+      rowPointers_(StlAllocator<char*>(stringAllocator_.get())) {
   // 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
@@ -174,17 +176,17 @@ RowContainer::RowContainer(
   // bits. 'numRowsWithNormalizedKey_' gives the number of rows with
   // the extra field.
   int32_t offset = 0;
-  int32_t nullOffset = 0;
+  int32_t flagOffset = 0;
   bool isVariableWidth = false;
   for (auto& type : keyTypes_) {
     typeKinds_.push_back(type->kind());
     types_.push_back(type);
     offsets_.push_back(offset);
     offset += typeKindSize(type->kind());
-    nullOffsets_.push_back(nullOffset);
+    nullOffsets_.push_back(flagOffset);
     isVariableWidth |= !type->isFixedWidth();
     if (nullableKeys_) {
-      ++nullOffset;
+      ++flagOffset;
     }
   }
   // Make offset at least sizeof pointer so that there is space for a
@@ -192,18 +194,16 @@ RowContainer::RowContainer(
   offset = std::max<int32_t>(offset, sizeof(void*));
   const int32_t firstAggregateOffset = offset;
   if (!accumulators.empty()) {
-    // This moves nullOffset to the start of the next byte.
+    // This moves flagOffset 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;
+    flagOffset = (flagOffset + 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;
+    nullOffsets_.push_back(flagOffset);
+    // Increment for two bits: null bit and following initialized bit.
+    flagOffset += kNumAccumulatorFlags;
     isVariableWidth |= !accumulator.isFixedSize();
     usesExternalMemory_ |= accumulator.usesExternalMemory();
     alignment_ = combineAlignments(accumulator.alignment(), alignment_);
@@ -211,21 +211,19 @@ RowContainer::RowContainer(
   for (auto& type : dependentTypes) {
     types_.push_back(type);
     typeKinds_.push_back(type->kind());
-    nullOffsets_.push_back(nullOffset);
-    ++nullOffset;
+    nullOffsets_.push_back(flagOffset);
+    ++flagOffset;
     isVariableWidth |= !type->isFixedWidth();
   }
   if (hasProbedFlag) {
-    nullOffsets_.push_back(nullOffset);
-    probedFlagOffset_ = nullOffset + firstAggregateOffset * 8;
-    ++nullOffset;
+    probedFlagOffset_ = flagOffset + firstAggregateOffset * 8;
+    ++flagOffset;
   }
   // Free flag.
-  nullOffsets_.push_back(nullOffset);
-  freeFlagOffset_ = nullOffset + firstAggregateOffset * 8;
-  ++nullOffset;
+  freeFlagOffset_ = flagOffset + firstAggregateOffset * 8;
+  ++flagOffset;
   // Add 1 to the last null offset to get the number of bits.
-  flagBytes_ = bits::nbytes(nullOffsets_.back() + 1);
+  flagBytes_ = bits::nbytes(flagOffset);
   // 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;
@@ -250,14 +248,6 @@ RowContainer::RowContainer(
     offset += sizeof(void*);
   }
   fixedRowSize_ = bits::roundUp(offset, alignment_);
-  // 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. 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;
@@ -268,16 +258,7 @@ RowContainer::RowContainer(
         offsets_[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;
-    }
+    ++nullOffsetsPos;
   }
   rowColumnsStats_.resize(types_.size());
 }
@@ -301,10 +282,24 @@ char* RowContainer::newRow() {
     if (normalizedKeySize_) {
       ++numRowsWithNormalizedKey_;
     }
+
+    if (useListRowIndex_) {
+      rowPointers_.push_back(row);
+    }
   }
   return initializeRow(row, false /* reuse */);
 }
 
+void RowContainer::setAllNull(char* row) {
+  VELOX_CHECK(!bits::isBitSet(row, freeFlagOffset_));
+  removeOrUpdateRowColumnStats(row, /*setToNull=*/true);
+  if (!nullOffsets_.empty()) {
+    for (auto i : nullOffsets_) {
+      row[nullByte(i)] |= nullMask(i);
+    }
+  }
+}
+
 char* RowContainer::initializeRow(char* row, bool reuse) {
   if (reuse) {
     auto rows = folly::Range<char**>(&row, 1);
@@ -317,10 +312,9 @@ char* RowContainer::initializeRow(char* row, bool reuse) {
     ::memset(row, 0, fixedRowSize_);
   }
   if (!nullOffsets_.empty()) {
-    ::memcpy(
-        row + nullByte(nullOffsets_[0]),
-        initialNulls_.data(),
-        initialNulls_.size());
+    // Sets all null and initialized bits to 0 (for each accumulator,
+    // initialized bit follows the null bit).
+    ::memset(row + nullByte(nullOffsets_[0]), 0x0, flagBytes_);
   }
   if (rowSizeOffset_) {
     variableRowSize(row) = 0;
@@ -361,7 +355,7 @@ void RowContainer::eraseRows(folly::Range<char**> rows) {
 }
 
 int32_t RowContainer::findRows(folly::Range<char**> rows, char** result) const {
-  raw_vector<folly::Range<char*>> ranges;
+  raw_vector<folly::Range<char*>> ranges(pool());
   ranges.resize(rows_.numRanges());
   for (auto i = 0; i < rows_.numRanges(); ++i) {
     ranges[i] = rows_.rangeAt(i);
@@ -370,8 +364,8 @@ int32_t RowContainer::findRows(folly::Range<char**> rows, char** result) const {
       ranges.begin(), ranges.end(), [](const auto& left, const auto& right) {
         return left.data() < right.data();
       });
-  raw_vector<uint64_t> starts;
-  raw_vector<uint64_t> sizes;
+  raw_vector<uint64_t> starts(pool());
+  raw_vector<uint64_t> sizes(pool());
   starts.reserve(ranges.size());
   sizes.reserve(ranges.size());
   for (const auto& range : ranges) {
@@ -599,7 +593,7 @@ int32_t RowContainer::variableSizeAt(const char* row, column_index_t column)
   }
 
   const auto typeKind = typeKinds_[column];
-  if (typeKind == TypeKind::VARCHAR || typeKind == TypeKind::VARBINARY) {
+  if (is_string_kind(typeKind)) {
     return reinterpret_cast<const StringView*>(row + rowColumn.offset())
         ->size();
   } else {
@@ -625,7 +619,7 @@ int32_t RowContainer::extractVariableSizeAt(
   }
 
   const auto typeKind = typeKinds_[column];
-  if (typeKind == TypeKind::VARCHAR || typeKind == TypeKind::VARBINARY) {
+  if (is_string_kind(typeKind)) {
     const auto value = valueAt<StringView>(row, rowColumn.offset());
     const auto size = value.size();
     ::memcpy(output, &size, 4);
@@ -663,7 +657,7 @@ int32_t RowContainer::storeVariableSizeAt(
   // 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 (is_string_kind(typeKind)) {
     if (size > 0) {
       stringAllocator_->copyMultipart(
           StringView(data + 4, size), row, rowColumn.offset());
@@ -901,13 +895,11 @@ void RowContainer::hashTyped(
                       : BaseVector::kNullHash;
     } else {
       uint64_t hash;
-      if constexpr (Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+      if constexpr (is_string_kind(Kind)) {
         hash =
             folly::hasher<StringView>()(HashStringAllocator::contiguousString(
                 valueAt<StringView>(row, offset), storage));
-      } else if constexpr (
-          Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
-          Kind == TypeKind::MAP) {
+      } else if constexpr (is_nested_kind(Kind)) {
         auto in = prepareRead(row, offset);
         hash = ContainerRowSerde::hash(in, type);
       } else if constexpr (typeProvidesCustomComparison) {
@@ -977,6 +969,8 @@ void RowContainer::clear() {
   hasDuplicateRows_ = false;
 
   rows_.clear();
+  rowPointers_.clear();
+  rowPointers_.shrink_to_fit();
   stringAllocator_->clear();
   numRows_ = 0;
   numRowsWithNormalizedKey_ = 0;
@@ -1038,7 +1032,8 @@ std::optional<int64_t> RowContainer::estimateRowSize() const {
   }
   int64_t freeBytes = rows_.freeBytes() + fixedRowSize_ * numFreeRows_;
   int64_t usedSize = rows_.allocatedBytes() - freeBytes +
-      stringAllocator_->retainedSize() - stringAllocator_->freeSpace();
+      stringAllocator_->retainedSize() - stringAllocator_->freeSpace() -
+      rowPointers_.capacity() * sizeof(char*);
   int64_t rowSize = usedSize / numRows_;
   VELOX_CHECK_GT(
       rowSize, 0, "Estimated row size of the RowContainer must be positive.");
@@ -1275,9 +1270,9 @@ RowComparator::RowComparator(
   }
 }
 
-bool RowComparator::operator()(const char* lhs, const char* rhs) {
+int32_t RowComparator::compare(const char* lhs, const char* rhs) {
   if (lhs == rhs) {
-    return false;
+    return 0;
   }
   for (auto& key : keyInfo_) {
     if (auto result = rowContainer_->compare(
@@ -1285,26 +1280,37 @@ bool RowComparator::operator()(const char* lhs, const char* rhs) {
             rhs,
             key.first,
             {key.second.isNullsFirst(), key.second.isAscending(), false})) {
-      return result < 0;
+      return result;
     }
   }
-  return false;
+  return 0;
 }
 
-bool RowComparator::operator()(
+bool RowComparator::operator()(const char* lhs, const char* rhs) {
+  return compare(lhs, rhs) < 0;
+}
+
+int32_t RowComparator::compare(
     const std::vector<DecodedVector>& decodedVectors,
     vector_size_t index,
-    const char* rhs) {
+    const char* other) {
   for (auto& key : keyInfo_) {
     if (auto result = rowContainer_->compare(
-            rhs,
+            other,
             rowContainer_->columnAt(key.first),
             decodedVectors[key.first],
             index,
             {key.second.isNullsFirst(), key.second.isAscending(), false})) {
-      return result > 0;
+      return -result;
     }
   }
-  return false;
+  return 0;
+}
+
+bool RowComparator::operator()(
+    const std::vector<DecodedVector>& decodedVectors,
+    vector_size_t index,
+    const char* other) {
+  return compare(decodedVectors, index, other) < 0;
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/RowContainer.h b/velox/exec/RowContainer.h
index 84783a19ee97..db336a2d9aef 100644
--- a/velox/exec/RowContainer.h
+++ b/velox/exec/RowContainer.h
@@ -83,6 +83,8 @@ struct RowContainerIterator {
   char* rowBegin{nullptr};
   /// First byte after the end of the range containing 'currentRow'.
   char* endOfRun{nullptr};
+  /// Cursor of the list row operation.
+  int32_t listRowCursor{0};
 
   /// Returns the current row, skipping a possible normalized key below the
   /// first byte of row.
@@ -118,6 +120,10 @@ class RowPartitions {
     return size_;
   }
 
+  void reset() {
+    size_ = 0;
+  }
+
  private:
   const int32_t capacity_;
 
@@ -273,6 +279,21 @@ class RowContainer {
       const std::vector<TypePtr>& keyTypes,
       const std::vector<TypePtr>& dependentTypes,
       memory::MemoryPool* pool)
+      : RowContainer(
+            keyTypes,
+            dependentTypes,
+            /*useListRowIndex=*/false,
+            pool) {}
+
+  /// If 'useListRowIndex' is true, the container maintains an internal array of
+  /// row pointers so that listRowsFast() can return rows without scanning
+  /// underlying allocations or checking free/probe flags. It is intended to be
+  /// used in SortBuffer and SortInputSpiller to improve performance.
+  RowContainer(
+      const std::vector<TypePtr>& keyTypes,
+      const std::vector<TypePtr>& dependentTypes,
+      bool useListRowIndex,
+      memory::MemoryPool* pool)
       : RowContainer(
             keyTypes,
             true, // nullableKeys
@@ -282,6 +303,7 @@ class RowContainer {
             false, // isJoinBuild
             false, // hasProbedFlag
             false, // hasNormalizedKey
+            useListRowIndex,
             pool) {}
 
   ~RowContainer();
@@ -313,6 +335,7 @@ class RowContainer {
       bool isJoinBuild,
       bool hasProbedFlag,
       bool hasNormalizedKey,
+      bool useListRowIndex,
       memory::MemoryPool* pool);
 
   /// Allocates a new row and initializes possible aggregates to null.
@@ -328,13 +351,7 @@ class RowContainer {
   /// 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) {
-    removeOrUpdateRowColumnStats(row, /*setToNull=*/true);
-    if (!nullOffsets_.empty()) {
-      memset(row + nullByte(nullOffsets_[0]), 0xff, initialNulls_.size());
-      bits::clearBit(row, freeFlagOffset_);
-    }
-  }
+  void setAllNull(char* row);
 
   /// The row size excluding any out-of-line stored variable length values.
   int32_t fixedRowSize() const {
@@ -579,8 +596,7 @@ class RowContainer {
   __attribute__((__no_sanitize__("thread")))
 #endif
 #endif
-  int32_t
-  listRows(
+  int32_t listRows(
       RowContainerIterator* iter,
       int32_t maxRows,
       uint64_t maxBytes,
@@ -644,6 +660,20 @@ class RowContainer {
     return count;
   }
 
+  /// Fast path for `listRows` that returns `rowPointers_` directly. Used by
+  /// `SortBuffer` and `SortInputSpiller`, so it skips checking the free and
+  /// probe flags.
+  int32_t listRowsFast(RowContainerIterator* iter, int32_t maxRows, char** rows)
+      const {
+    int32_t count = 0;
+    while (count < maxRows && iter->listRowCursor < rowPointers_.size()) {
+      char* row = rowPointers_[iter->listRowCursor];
+      rows[count++] = row;
+      ++iter->listRowCursor;
+    }
+    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
@@ -658,6 +688,9 @@ class RowContainer {
 
   int32_t listRows(RowContainerIterator* iter, int32_t maxRows, char** rows)
       const {
+    if (useListRowIndex_) {
+      return listRowsFast(iter, maxRows, rows);
+    }
     return listRows<ProbeType::kAll>(iter, maxRows, kUnlimited, rows);
   }
 
@@ -674,21 +707,13 @@ class RowContainer {
   __attribute__((__no_sanitize__("thread")))
 #endif
 #endif
-  void
-  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().
-  template <bool mayHaveNulls>
-  bool equals(
-      const char* row,
-      RowColumn column,
-      const DecodedVector& decoded,
-      vector_size_t index) const;
+  void setProbedFlag(char** rows, int32_t numRows);
 
   /// Compares the value at 'column' in 'row' with the value at 'index' in
   /// 'decoded'. Returns 0 for equal, < 0 for 'row' < 'decoded', > 0 otherwise.
+  /// 'mayHaveNulls' specifies if nulls need to be checked. This is a fast path
+  /// for compare().
+  template <bool mayHaveNulls = true>
   int32_t compare(
       const char* row,
       RowColumn column,
@@ -806,6 +831,10 @@ class RowContainer {
     return 0;
   }
 
+  const std::vector<char*, StlAllocator<char*>>& testingRowPointers() const {
+    return rowPointers_;
+  }
+
   memory::MemoryPool* pool() const {
     return stringAllocator_->pool();
   }
@@ -1102,7 +1131,7 @@ class RowContainer {
 
     BufferPtr& nullBuffer = result->mutableNulls(maxRows, true);
     auto nulls = nullBuffer->asMutable<uint64_t>();
-    BufferPtr valuesBuffer = result->mutableValues(maxRows);
+    BufferPtr valuesBuffer = result->mutableValues();
     [[maybe_unused]] auto values = valuesBuffer->asMutableRange<T>();
     for (int32_t i = 0; i < numRows; ++i) {
       const char* row;
@@ -1134,9 +1163,9 @@ class RowContainer {
       int32_t offset,
       int32_t resultOffset,
       FlatVector<T>* result) {
-    auto maxRows = numRows + resultOffset;
+    [[maybe_unused]] auto maxRows = numRows + resultOffset;
     VELOX_DCHECK_LE(maxRows, result->size());
-    BufferPtr valuesBuffer = result->mutableValues(maxRows);
+    BufferPtr valuesBuffer = result->mutableValues();
     [[maybe_unused]] auto values = valuesBuffer->asMutableRange<T>();
     for (int32_t i = 0; i < numRows; ++i) {
       const char* row;
@@ -1173,56 +1202,29 @@ class RowContainer {
       bool mix,
       uint64_t* result) const;
 
-  template <bool typeProvidesCustomComparison, TypeKind Kind>
-  inline bool equalsWithNulls(
-      const char* row,
-      int32_t offset,
-      int32_t nullByte,
-      uint8_t nullMask,
-      const DecodedVector& decoded,
-      vector_size_t index) const {
-    bool rowIsNull = isNullAt(row, nullByte, nullMask);
-    bool indexIsNull = decoded.isNullAt(index);
-    if (rowIsNull || indexIsNull) {
-      return rowIsNull == indexIsNull;
-    }
-
-    return equalsNoNulls<typeProvidesCustomComparison, Kind>(
-        row, offset, decoded, index);
-  }
-
-  template <bool typeProvidesCustomComparison, TypeKind Kind>
-  inline bool equalsNoNulls(
+  template <bool mayHaveNulls, TypeKind Kind>
+  inline int compare(
       const char* row,
-      int32_t offset,
+      RowColumn column,
       const DecodedVector& decoded,
-      vector_size_t index) const {
-    using T = typename KindToFlatVector<Kind>::HashRowType;
-
-    if constexpr (
-        Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
-        Kind == TypeKind::MAP) {
-      return compareComplexType(row, offset, decoded, index) == 0;
-    } else if constexpr (
-        Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
-      return compareStringAsc(
-                 valueAt<StringView>(row, offset), decoded, index) == 0;
-    } else if constexpr (typeProvidesCustomComparison) {
-      return SimpleVector<T>::template comparePrimitiveAscWithCustomComparison<
-                 Kind>(
-                 decoded.base()->type().get(),
-                 decoded.valueAt<T>(index),
-                 valueAt<T>(row, offset)) == 0;
+      vector_size_t index,
+      CompareFlags flags) const {
+    if (decoded.base()->typeUsesCustomComparison()) {
+      return compare<true, Kind, mayHaveNulls>(
+          row, column, decoded, index, flags);
     } else {
-      return SimpleVector<T>::comparePrimitiveAsc(
-                 decoded.valueAt<T>(index), valueAt<T>(row, offset)) == 0;
+      return compare<false, Kind, mayHaveNulls>(
+          row, column, decoded, index, flags);
     }
   }
 
   template <
       bool typeProvidesCustomComparison,
       TypeKind Kind,
-      std::enable_if_t<Kind != TypeKind::OPAQUE, int32_t> = 0>
+      bool mayHaveNulls,
+      std::enable_if_t<
+          Kind != TypeKind::OPAQUE && Kind != TypeKind::UNKNOWN,
+          int32_t> = 0>
   inline int compare(
       const char* row,
       RowColumn column,
@@ -1230,20 +1232,23 @@ class RowContainer {
       vector_size_t index,
       CompareFlags flags) const {
     using T = typename KindToFlatVector<Kind>::HashRowType;
-    bool rowIsNull = isNullAt(row, column.nullByte(), column.nullMask());
-    bool indexIsNull = decoded.isNullAt(index);
-    if (rowIsNull) {
-      return indexIsNull ? 0 : flags.nullsFirst ? -1 : 1;
-    }
-    if (indexIsNull) {
-      return flags.nullsFirst ? 1 : -1;
+
+    if constexpr (mayHaveNulls) {
+      bool rowIsNull = isNullAt(row, column.nullByte(), column.nullMask());
+      bool indexIsNull = decoded.isNullAt(index);
+      if (rowIsNull) {
+        return indexIsNull ? 0 : flags.nullsFirst ? -1 : 1;
+      }
+      if (indexIsNull) {
+        return flags.nullsFirst ? 1 : -1;
+      }
     }
+
     if constexpr (
         Kind == TypeKind::ROW || Kind == TypeKind::ARRAY ||
         Kind == TypeKind::MAP) {
       return compareComplexType(row, column.offset(), decoded, index, flags);
-    } else if constexpr (
-        Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    } else if constexpr (is_string_kind(Kind)) {
       auto result = compareStringAsc(
           valueAt<StringView>(row, column.offset()), decoded, index);
       return flags.ascending ? result : result * -1;
@@ -1267,6 +1272,22 @@ class RowContainer {
   template <
       bool typeProvidesCustomComparison,
       TypeKind Kind,
+      bool mayHaveNulls,
+      std::enable_if_t<Kind == TypeKind::UNKNOWN, int32_t> = 0>
+  inline int compare(
+      const char* row,
+      RowColumn column,
+      const DecodedVector& /*decoded*/,
+      vector_size_t /*index*/,
+      CompareFlags flags) const {
+    const bool rowIsNull = isNullAt(row, column.nullByte(), column.nullMask());
+    return rowIsNull ? 0 : flags.nullsFirst ? 1 : -1;
+  }
+
+  template <
+      bool typeProvidesCustomComparison,
+      TypeKind Kind,
+      bool mayHaveNulls,
       std::enable_if_t<Kind == TypeKind::OPAQUE, int32_t> = 0>
   inline int compare(
       const char* /*row*/,
@@ -1307,8 +1328,7 @@ class RowContainer {
         Kind == TypeKind::MAP) {
       return compareComplexType(
           left, right, type, leftOffset, rightOffset, flags);
-    } else if constexpr (
-        Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    } else if constexpr (is_string_kind(Kind)) {
       auto leftValue = valueAt<StringView>(left, leftOffset);
       auto rightValue = valueAt<StringView>(right, rightOffset);
       auto result = compareStringAsc(leftValue, rightValue);
@@ -1493,7 +1513,8 @@ class RowContainer {
   const bool isJoinBuild_;
   // True if normalized keys are enabled in initial state.
   const bool hasNormalizedKeys_;
-
+  // True if use 'listRowsFast'.
+  const bool useListRowIndex_;
   const std::unique_ptr<HashStringAllocator> stringAllocator_;
 
   // Indicates if we can add new row to this row container. It is set to false
@@ -1512,7 +1533,7 @@ class RowContainer {
   // 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,
+  // Bit position of null bit in the row. 0 if no null flag. Order is keys,
   // accumulators, dependent.
   std::vector<int32_t> nullOffsets_;
   // Position of field or accumulator. Corresponds 1:1 to 'nullOffset_'.
@@ -1543,15 +1564,13 @@ class RowContainer {
   // Extra bytes to reserve before  each added row for a normalized key. Set to
   // 0 after deciding not to use normalized keys.
   int normalizedKeySize_;
-  // Copied over the null bits of each row on initialization. Keys are
-  // not null, aggregates are null.
-  std::vector<uint8_t> initialNulls_;
   uint64_t numRows_ = 0;
   // Head of linked list of free rows.
   char* firstFreeRow_ = nullptr;
   uint64_t numFreeRows_ = 0;
 
   memory::AllocationPool rows_;
+  std::vector<char*, StlAllocator<char*>> rowPointers_;
 
   int alignment_ = 1;
 
@@ -1739,60 +1758,21 @@ inline void RowContainer::extractNulls(
 }
 
 template <bool mayHaveNulls>
-inline bool RowContainer::equals(
-    const char* row,
-    RowColumn column,
-    const DecodedVector& decoded,
-    vector_size_t index) const {
-  auto typeKind = decoded.base()->typeKind();
-  if (typeKind == TypeKind::UNKNOWN) {
-    return isNullAt(row, column.nullByte(), column.nullMask());
-  }
-
-  if constexpr (!mayHaveNulls) {
-    return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
-        equalsNoNulls, false, typeKind, row, column.offset(), decoded, index);
-  } else {
-    return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
-        equalsWithNulls,
-        false,
-        typeKind,
-        row,
-        column.offset(),
-        column.nullByte(),
-        column.nullMask(),
-        decoded,
-        index);
-  }
-}
-
 inline int RowContainer::compare(
     const char* row,
     RowColumn column,
     const DecodedVector& decoded,
     vector_size_t index,
     CompareFlags flags) const {
-  if (decoded.base()->typeUsesCustomComparison()) {
-    return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(
-        compare,
-        true,
-        decoded.base()->typeKind(),
-        row,
-        column,
-        decoded,
-        index,
-        flags);
-  } else {
-    return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(
-        compare,
-        false,
-        decoded.base()->typeKind(),
-        row,
-        column,
-        decoded,
-        index,
-        flags);
-  }
+  return VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(
+      compare,
+      mayHaveNulls,
+      decoded.base()->typeKind(),
+      row,
+      column,
+      decoded,
+      index,
+      flags);
 }
 
 inline int RowContainer::compare(
@@ -1873,11 +1853,21 @@ class RowComparator {
   /// Returns true if lhs < rhs, false otherwise.
   bool operator()(const char* lhs, const char* rhs);
 
-  /// Returns true if decodeVectors[index] < rhs, false otherwise.
+  /// Returns 0 for equal, < 0 for lhs < rhs, > 0 otherwise.
+  int compare(const char* lhs, const char* rhs);
+
+  /// Returns true if decodedVectors[index] < other, false otherwise.
   bool operator()(
       const std::vector<DecodedVector>& decodedVectors,
       vector_size_t index,
-      const char* rhs);
+      const char* other);
+
+  /// Returns 0 for equal, < 0 for decodedVectors[index] < other,
+  /// > 0 otherwise.
+  int32_t compare(
+      const std::vector<DecodedVector>& decodedVectors,
+      vector_size_t index,
+      const char* other);
 
  private:
   std::vector<std::pair<column_index_t, core::SortOrder>> keyInfo_;
diff --git a/velox/exec/RowNumber.cpp b/velox/exec/RowNumber.cpp
index 31421d0d29b5..e57424da59df 100644
--- a/velox/exec/RowNumber.cpp
+++ b/velox/exec/RowNumber.cpp
@@ -120,13 +120,13 @@ void RowNumber::restoreNextSpillPartition() {
   auto it = spillInputPartitionSet_.begin();
   restoringPartitionId_ = it->first;
   spillInputReader_ = it->second->createUnorderedReader(
-      spillConfig_->readBufferSize, pool(), &spillStats_);
+      spillConfig_->readBufferSize, pool(), spillStats_.get());
 
   // 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_);
+        spillConfig_->readBufferSize, pool(), spillStats_.get());
 
     setSpillPartitionBits(&(it->first));
 
@@ -388,7 +388,7 @@ void RowNumber::reclaim(
                  << spillConfig_->maxSpillLevel
                  << ", and abandon spilling for memory pool: "
                  << pool()->name();
-    ++spillStats_.wlock()->spillMaxLevelExceededCount;
+    ++spillStats_->wlock()->spillMaxLevelExceededCount;
     return;
   }
 
@@ -408,7 +408,7 @@ SpillPartitionIdSet RowNumber::spillHashTable() {
       tableType,
       spillPartitionBits_,
       &spillConfig,
-      &spillStats_);
+      spillStats_.get());
 
   hashTableSpiller->spill();
   hashTableSpiller->finishSpill(spillHashTablePartitionSet_);
@@ -429,7 +429,7 @@ void RowNumber::setupInputSpiller(
       restoringPartitionId_,
       spillPartitionBits_,
       &spillConfig,
-      &spillStats_);
+      spillStats_.get());
 
   const auto& hashers = table_->hashers();
 
@@ -509,7 +509,7 @@ void RowNumber::recursiveSpillInput() {
   while (spillInputReader_->nextBatch(unspilledInput)) {
     spillInput(unspilledInput, pool());
 
-    if (operatorCtx_->driver()->shouldYield()) {
+    if (shouldYield()) {
       yield_ = true;
       return;
     }
diff --git a/velox/exec/RowsStreamingWindowBuild.cpp b/velox/exec/RowsStreamingWindowBuild.cpp
index a3dedd8a60cd..7f03a465b6c3 100644
--- a/velox/exec/RowsStreamingWindowBuild.cpp
+++ b/velox/exec/RowsStreamingWindowBuild.cpp
@@ -50,8 +50,9 @@ bool RowsStreamingWindowBuild::needsInput() {
 
 void RowsStreamingWindowBuild::ensureInputPartition() {
   if (windowPartitions_.empty() || windowPartitions_.back()->complete()) {
-    windowPartitions_.emplace_back(std::make_shared<WindowPartition>(
-        data_.get(), inversedInputChannels_, sortKeyInfo_));
+    windowPartitions_.emplace_back(
+        std::make_shared<WindowPartition>(
+            data_.get(), inversedInputChannels_, sortKeyInfo_));
   }
 }
 
diff --git a/velox/exec/ScaleWriterLocalPartition.cpp b/velox/exec/ScaleWriterLocalPartition.cpp
index 08e3b3bad311..7530ff403a0c 100644
--- a/velox/exec/ScaleWriterLocalPartition.cpp
+++ b/velox/exec/ScaleWriterLocalPartition.cpp
@@ -174,28 +174,11 @@ void ScaleWriterPartitioningLocalPartition::addInput(RowVectorPtr input) {
                                              row;
     }
 
-    for (auto i = 0; i < numPartitions_; ++i) {
-      const auto writerRowCount = writerAssignmentCounts_[i];
-      if (writerRowCount == 0) {
-        continue;
-      }
-
-      auto writerInput = processPartition(
-          input,
-          writerRowCount,
-          i,
-          std::move(writerAssignmmentIndicesBuffers_[i]),
-          rawWriterAssignmmentIndicesBuffers_[i]);
-      if (writerInput != nullptr) {
-        ContinueFuture future;
-        auto reason = queues_[i]->enqueue(
-            writerInput, totalInputBytes * writerRowCount / numInput, &future);
-        if (reason != BlockingReason::kNotBlocked) {
-          blockingReasons_.push_back(reason);
-          futures_.push_back(std::move(future));
-        }
-      }
-    }
+    populateAndEnqueuePartitions(
+        input,
+        writerAssignmentCounts_,
+        writerAssignmmentIndicesBuffers_,
+        rawWriterAssignmmentIndicesBuffers_);
   }
 
   // Only update the scaling state if the memory used is below the
@@ -223,10 +206,9 @@ uint32_t ScaleWriterPartitioningLocalPartition::getNextWriterId(
 void ScaleWriterPartitioningLocalPartition::close() {
   LocalPartition::close();
 
-  // The last driver operator reports the shared table partition rebalancer
-  // stats. We expect one reference hold by this operator and one referenced by
-  // the task.
-  if (tablePartitionRebalancer_.use_count() != 2) {
+  // The first driver operator instance reports the shared table partition
+  // rebalancer stats.
+  if (operatorCtx_->driverCtx()->driverId != 0) {
     return;
   }
 
diff --git a/velox/exec/SerializedPage.cpp b/velox/exec/SerializedPage.cpp
new file mode 100644
index 000000000000..7ba6a3af0f7f
--- /dev/null
+++ b/velox/exec/SerializedPage.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/exec/SerializedPage.h"
+
+namespace facebook::velox::exec {
+
+PrestoSerializedPage::PrestoSerializedPage(
+    std::unique_ptr<folly::IOBuf> iobuf,
+    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_) {
+    int32_t bufSize = buf.size();
+    ranges_.push_back(
+        ByteRange{
+            const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buf.data())),
+            bufSize,
+            0});
+  }
+}
+
+PrestoSerializedPage::~PrestoSerializedPage() {
+  if (onDestructionCb_) {
+    onDestructionCb_(*iobuf_.get());
+  }
+}
+
+std::unique_ptr<ByteInputStream>
+PrestoSerializedPage::prepareStreamForDeserialize() {
+  return std::make_unique<BufferInputStream>(std::move(ranges_));
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SerializedPage.h b/velox/exec/SerializedPage.h
new file mode 100644
index 000000000000..3f93de8012ad
--- /dev/null
+++ b/velox/exec/SerializedPage.h
@@ -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.
+ */
+#pragma once
+
+#include "velox/common/memory/ByteStream.h"
+
+namespace facebook::velox::exec {
+
+/// Interface for serialized pages.
+class SerializedPageBase {
+ public:
+  virtual ~SerializedPageBase() = default;
+
+  /// Returns the size of the serialized data in bytes.
+  virtual uint64_t size() const = 0;
+
+  /// Returns the number of rows if available.
+  virtual std::optional<int64_t> numRows() const = 0;
+
+  /// Makes 'input' ready for deserializing 'this' with
+  /// VectorStreamGroup::read().
+  virtual std::unique_ptr<ByteInputStream> prepareStreamForDeserialize() = 0;
+
+  /// Returns a clone of the IOBuf.
+  virtual std::unique_ptr<folly::IOBuf> getIOBuf() const = 0;
+};
+
+/// Corresponds to Presto SerializedPage, i.e. a container for serialized
+/// vectors in Presto wire format.
+class PrestoSerializedPage : public SerializedPageBase {
+ public:
+  /// Construct from IOBuf chain.
+  explicit PrestoSerializedPage(
+      std::unique_ptr<folly::IOBuf> iobuf,
+      std::function<void(folly::IOBuf&)> onDestructionCb = nullptr,
+      std::optional<int64_t> numRows = std::nullopt);
+
+  ~PrestoSerializedPage() override;
+
+  uint64_t size() const override {
+    return iobufBytes_;
+  }
+
+  std::optional<int64_t> numRows() const override {
+    return numRows_;
+  }
+
+  std::unique_ptr<ByteInputStream> prepareStreamForDeserialize() override;
+
+  std::unique_ptr<folly::IOBuf> getIOBuf() const override {
+    return iobuf_->clone();
+  }
+
+ private:
+  static int64_t chainBytes(folly::IOBuf& iobuf) {
+    int64_t size = 0;
+    for (auto& range : iobuf) {
+      size += range.size();
+    }
+    return size;
+  }
+
+  // Buffers containing the serialized data. The memory is owned by 'iobuf_'.
+  std::vector<ByteRange> ranges_;
+
+  // IOBuf holding the data in 'ranges_.
+  std::unique_ptr<folly::IOBuf> iobuf_;
+
+  // 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 PrestoSerializedPage,
+  // primarily used to free externally allocated memory backing folly::IOBuf
+  // from caller. Caller is responsible to pass in proper cleanup logic to
+  // prevent any memory leak.
+  std::function<void(folly::IOBuf&)> onDestructionCb_;
+};
+
+// TODO: Remove after fully migration to new SerializedPageBase and
+// PrestoSerializedPage API.
+using SerializedPage = PrestoSerializedPage;
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SerializedPageSpiller.cpp b/velox/exec/SerializedPageSpiller.cpp
deleted file mode 100644
index b565968c1c97..000000000000
--- a/velox/exec/SerializedPageSpiller.cpp
+++ /dev/null
@@ -1,227 +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/SerializedPageSpiller.h"
-#include "velox/exec/SpillFile.h"
-
-namespace facebook::velox::exec {
-
-void SerializedPageSpiller::spill(
-    const std::vector<std::shared_ptr<SerializedPage>>& pages) {
-  writeWithBufferControl([&]() {
-    if (pages.empty()) {
-      return 0UL;
-    }
-
-    if (bufferStream_ == nullptr) {
-      bufferStream_ = std::make_unique<IOBufOutputStream>(*pool_);
-    }
-
-    // Spill file layout:
-    //  --- Page 0 ---
-    //
-    //  (1 Byte) is null page
-    //  (8 Bytes) payload size
-    //  (1 Bytes) has num rows
-    //  (8 Bytes) num rows
-    //  (x Bytes) payload
-    //
-    //  --- Page 1 ---
-    //        ...
-    //  --- Page n ---
-    //        ...
-    const auto totalBytesBeforeSpill = totalBytes_;
-    uint64_t totalRows{0};
-    for (const auto& page : pages) {
-      if (page != nullptr) {
-        const auto pageSize = page->size();
-        totalBytes_ += pageSize;
-        totalRows += page->numRows().value_or(0);
-      }
-
-      // Spill payload headers.
-      const uint8_t isNull = (page == nullptr) ? 1 : 0;
-      bufferStream_->write(
-          reinterpret_cast<const char*>(&isNull), sizeof(uint8_t));
-      if (page == nullptr) {
-        continue;
-      }
-
-      auto pageBytes = static_cast<int64_t>(page->size());
-      bufferStream_->write(
-          reinterpret_cast<char*>(&pageBytes), sizeof(int64_t));
-
-      const auto numRowsOpt = page->numRows();
-      uint8_t hasNumRows = numRowsOpt.has_value() ? 1 : 0;
-      bufferStream_->write(reinterpret_cast<const char*>(&hasNumRows), 1);
-      if (numRowsOpt.has_value()) {
-        const int64_t numRows = numRowsOpt.value();
-        bufferStream_->write(
-            reinterpret_cast<const char*>(&numRows), sizeof(int64_t));
-      }
-
-      // Spill payload.
-      auto iobuf = page->getIOBuf();
-      for (auto range = iobuf->begin(); range != iobuf->end(); ++range) {
-        bufferStream_->write(
-            reinterpret_cast<const char*>(range->data()),
-            static_cast<int64_t>(range->size()));
-      }
-    }
-
-    VELOX_CHECK_GE(totalBytes_, totalBytesBeforeSpill);
-    totalPages_ += pages.size();
-    return totalRows;
-  });
-}
-
-SerializedPageSpiller::Result SerializedPageSpiller::finishSpill() {
-  auto spillFiles = finish();
-  return {std::move(spillFiles), totalPages_};
-}
-
-void SerializedPageSpiller::flushBuffer(
-    SpillWriteFile* file,
-    uint64_t& writtenBytes,
-    uint64_t& flushTimeNs,
-    uint64_t& writeTimeNs) {
-  flushTimeNs = 0;
-  {
-    NanosecondTimer timer(&writeTimeNs);
-    writtenBytes = file->write(bufferStream_->getIOBuf());
-  }
-}
-
-bool SerializedPageSpiller::bufferEmpty() const {
-  return bufferStream_ == nullptr;
-}
-
-uint64_t SerializedPageSpiller::bufferSize() const {
-  return bufferStream_ == nullptr
-      ? 0
-      : static_cast<uint64_t>(bufferStream_->tellp());
-}
-
-void SerializedPageSpiller::addFinishedFile(SpillWriteFile* file) {
-  SpillFileInfo spillFileInfo;
-  spillFileInfo.path = file->path();
-  finishedFiles_.push_back(std::move(spillFileInfo));
-}
-
-bool SerializedPageSpillReader::empty() const {
-  return numPages_ == 0;
-}
-
-uint64_t SerializedPageSpillReader::numPages() const {
-  return numPages_;
-}
-
-std::shared_ptr<SerializedPage> SerializedPageSpillReader::at(uint64_t index) {
-  ensurePages(index);
-  return bufferedPages_[index];
-}
-
-void SerializedPageSpillReader::deleteAll() {
-  spillFilePaths_.clear();
-  curFileStream_.reset();
-  bufferedPages_.clear();
-  numPages_ = 0;
-}
-
-void SerializedPageSpillReader::deleteFront(uint64_t numPages) {
-  if (numPages == 0) {
-    return;
-  }
-  ensurePages(numPages - 1);
-  bufferedPages_.erase(
-      bufferedPages_.begin(), bufferedPages_.begin() + numPages);
-  numPages_ -= numPages;
-}
-
-void SerializedPageSpillReader::ensureSpillFile() {
-  if (curFileStream_ != nullptr) {
-    return;
-  }
-  VELOX_CHECK(!spillFilePaths_.empty());
-  auto filePath = spillFilePaths_.front();
-  auto fs = filesystems::getFileSystem(filePath, nullptr);
-  auto file = fs->openFileForRead(filePath);
-  curFileStream_ = std::make_unique<common::FileInputStream>(
-      std::move(file), readBufferSize_, pool_);
-  spillFilePaths_.pop_front();
-}
-
-void SerializedPageSpillReader::ensurePages(uint64_t index) {
-  VELOX_CHECK_LT(index, numPages_);
-  if (index < bufferedPages_.size()) {
-    return;
-  }
-
-  while (index >= bufferedPages_.size()) {
-    bufferedPages_.push_back(unspillNextPage());
-  }
-}
-
-namespace {
-struct FreeData {
-  const std::shared_ptr<memory::MemoryPool> pool;
-  int64_t bytesToFree{0};
-};
-
-void freeFunc(void* data, void* userData) {
-  auto* freeData = reinterpret_cast<FreeData*>(userData);
-  freeData->pool->free(data, freeData->bytesToFree);
-  delete freeData;
-}
-} // namespace
-
-std::shared_ptr<SerializedPage> SerializedPageSpillReader::unspillNextPage() {
-  VELOX_CHECK(!empty());
-  ensureSpillFile();
-
-  SCOPE_EXIT {
-    if (curFileStream_->atEnd()) {
-      curFileStream_.reset();
-    }
-  };
-
-  // Read payload headers
-  const auto isNull = !!(curFileStream_->read<uint8_t>());
-  if (isNull) {
-    return nullptr;
-  }
-  const auto iobufBytes = curFileStream_->read<int64_t>();
-  const auto hasNumRows = curFileStream_->read<uint8_t>() == 0 ? false : true;
-  int64_t numRows{0};
-  if (hasNumRows) {
-    numRows = curFileStream_->read<int64_t>();
-  }
-
-  // Read payload
-  VELOX_CHECK_GE(curFileStream_->remainingSize(), iobufBytes);
-  void* rawBuf = pool_->allocate(iobufBytes);
-  curFileStream_->readBytes(reinterpret_cast<uint8_t*>(rawBuf), iobufBytes);
-
-  auto* userData = new FreeData{pool_->shared_from_this(), iobufBytes};
-  auto iobuf =
-      folly::IOBuf::takeOwnership(rawBuf, iobufBytes, freeFunc, userData, true);
-
-  return std::make_shared<SerializedPage>(
-      std::move(iobuf),
-      nullptr,
-      hasNumRows ? std::optional(numRows) : std::nullopt);
-}
-} // namespace facebook::velox::exec
diff --git a/velox/exec/SerializedPageSpiller.h b/velox/exec/SerializedPageSpiller.h
deleted file mode 100644
index b1974f5bc66b..000000000000
--- a/velox/exec/SerializedPageSpiller.h
+++ /dev/null
@@ -1,151 +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/base/SpillStats.h"
-#include "velox/common/file/FileInputStream.h"
-#include "velox/exec/ExchangeQueue.h"
-#include "velox/exec/SpillFile.h"
-
-namespace facebook::velox::exec {
-namespace test {
-class SerializedPageSpillerHelper;
-class SerializedPageSpillReaderHelper;
-} // namespace test
-
-/// Used for spilling a sequence of 'SerializedPage'. The spiller preserves the
-/// order of the pages.
-class SerializedPageSpiller : public SpillWriterBase {
- public:
-  struct Result {
-    SpillFiles spillFiles;
-    uint64_t totalPages;
-  };
-
-  SerializedPageSpiller(
-      uint64_t writeBufferSize,
-      uint64_t targetFileSize,
-      const std::string& pathPrefix,
-      const std::string& fileCreateConfig,
-      common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
-      memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* stats)
-      : SpillWriterBase(
-            writeBufferSize,
-            targetFileSize,
-            pathPrefix,
-            fileCreateConfig,
-            updateAndCheckSpillLimitCb,
-            pool,
-            stats) {
-    VELOX_CHECK_NOT_NULL(pool_);
-  }
-
-  /// Spill 'pages' to disk. The method does not free the original in-memory
-  /// structure of 'pages'. It is caller's responsibility to free them.
-  void spill(const std::vector<std::shared_ptr<SerializedPage>>& pages);
-
-  /// Finishes the spilling and return the spilled result.
-  Result finishSpill();
-
- private:
-  void flushBuffer(
-      SpillWriteFile* file,
-      uint64_t& writtenBytes,
-      uint64_t& flushTimeNs,
-      uint64_t& writeTimeNs) override;
-
-  bool bufferEmpty() const override;
-
-  uint64_t bufferSize() const override;
-
-  void addFinishedFile(SpillWriteFile* file) override;
-
-  uint64_t totalBytes_{0};
-
-  uint64_t totalPages_{0};
-
-  std::unique_ptr<IOBufOutputStream> bufferStream_;
-
-  friend class test::SerializedPageSpillerHelper;
-};
-
-/// Used for reading a sequence of 'SerializedPage' that were spilled by
-/// 'SerializedPageSpiller'. The reader preserves the page order, and provides
-/// random index access functionality in a load-on-read manner. It is used by
-/// 'DestinationBuffer' and provides convenient APIs for reading and deleting
-/// the pages, with unspilling handled transparently.
-class SerializedPageSpillReader {
- public:
-  SerializedPageSpillReader(
-      SerializedPageSpiller::Result&& spillResult,
-      uint64_t readBufferSize,
-      memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* spillStats)
-      : readBufferSize_(readBufferSize),
-        pool_(pool),
-        spillStats_(spillStats),
-        numPages_(spillResult.totalPages) {
-    for (const auto& spillFileInfo : spillResult.spillFiles) {
-      spillFilePaths_.push_back(spillFileInfo.path);
-    }
-  }
-
-  /// Returns true if there are any remaining pages left to read.
-  bool empty() const;
-
-  /// Returns the current number of pages in the reader.
-  uint64_t numPages() const;
-
-  /// Returns the page at 'index' in the reader.
-  std::shared_ptr<SerializedPage> at(uint64_t index);
-
-  /// Delete 'numPages' from the front.
-  void deleteFront(uint64_t numPages);
-
-  /// Delete all pages from the reader.
-  void deleteAll();
-
- private:
-  // Ensures the current file stream is open. If not, opens the next file.
-  void ensureSpillFile();
-
-  // Ensures all pages up to 'index' are loaded in memory.
-  void ensurePages(uint64_t index);
-
-  // Unspills one serialized page and returns it.
-  std::shared_ptr<SerializedPage> unspillNextPage();
-
-  const uint64_t readBufferSize_;
-
-  memory::MemoryPool* const pool_;
-
-  folly::Synchronized<common::SpillStats>* const spillStats_;
-
-  // The current file stream.
-  std::unique_ptr<common::FileInputStream> curFileStream_;
-
-  // A small number of front pages buffered in memory from spilled pages.
-  // These pages will be kept in memory and won't be spilled again.
-  std::vector<std::shared_ptr<SerializedPage>> bufferedPages_;
-
-  std::deque<std::string> spillFilePaths_;
-
-  uint64_t numPages_;
-
-  friend class test::SerializedPageSpillReaderHelper;
-};
-} // namespace facebook::velox::exec
diff --git a/velox/exec/SortBuffer.cpp b/velox/exec/SortBuffer.cpp
index d64f858d95f1..15bf8890b5bf 100644
--- a/velox/exec/SortBuffer.cpp
+++ b/velox/exec/SortBuffer.cpp
@@ -37,7 +37,7 @@ SortBuffer::SortBuffer(
       spillConfig_(spillConfig),
       spillStats_(spillStats),
       sortedRows_(0, memory::StlAllocator<char*>(*pool)) {
-  VELOX_CHECK_GE(input_->size(), sortCompareFlags_.size());
+  VELOX_CHECK_GE(input_->children().size(), sortCompareFlags_.size());
   VELOX_CHECK_GT(sortCompareFlags_.size(), 0);
   VELOX_CHECK_EQ(sortColumnIndices.size(), sortCompareFlags_.size());
   VELOX_CHECK_NOT_NULL(nonReclaimableSection_);
@@ -74,7 +74,7 @@ SortBuffer::SortBuffer(
   }
 
   data_ = std::make_unique<RowContainer>(
-      sortedColumnTypes, nonSortedColumnTypes, pool_);
+      sortedColumnTypes, nonSortedColumnTypes, /*useListRowIndex=*/true, pool_);
   spillerStoreType_ =
       ROW(std::move(sortedSpillColumnNames), std::move(sortedSpillColumnTypes));
 }
@@ -90,12 +90,12 @@ void SortBuffer::addInput(const VectorPtr& input) {
   VELOX_CHECK(!noMoreInput_);
   ensureInputFits(input);
 
-  SelectivityVector allRows(input->size());
+  const SelectivityVector allRows(input->size());
   std::vector<char*> rows(input->size());
   for (int row = 0; row < input->size(); ++row) {
     rows[row] = data_->newRow();
   }
-  auto* inputRow = input->as<RowVector>();
+  const auto* inputRow = input->as<RowVector>();
   for (const auto& columnProjection : columnMap_) {
     DecodedVector decoded(
         *inputRow->childAt(columnProjection.outputChannel), allRows);
@@ -128,6 +128,7 @@ void SortBuffer::noMoreInput() {
     updateEstimatedOutputRowSize();
     // Sort the pointers to the rows in RowContainer (data_) instead of sorting
     // the rows.
+    // TODO: Reuse 'RowContainer::rowPointers_'.
     sortedRows_.resize(numInputRows_);
     RowContainerIterator iter;
     data_->listRows(&iter, numInputRows_, sortedRows_.data());
@@ -310,7 +311,7 @@ void SortBuffer::ensureSortFits() {
   }
 
   // The memory for std::vector sorted rows and prefix sort required buffer.
-  uint64_t sortBufferToReserve =
+  const auto sortBufferToReserve =
       numInputRows_ * sizeof(char*) +
       PrefixSort::maxRequiredBytes(
           data_.get(), sortCompareFlags_, prefixSortConfig_, pool_);
@@ -389,10 +390,6 @@ void SortBuffer::prepareOutput(vector_size_t batchSize) {
         BaseVector::create(input_, batchSize, pool_));
   }
 
-  for (auto& child : output_->children()) {
-    child->resize(batchSize);
-  }
-
   if (hasSpilled()) {
     spillSources_.resize(batchSize);
     spillSourceRows_.resize(batchSize);
@@ -488,7 +485,7 @@ void SortBuffer::prepareOutputWithSpill() {
 
   VELOX_CHECK_EQ(spillPartitionSet_.size(), 1);
   spillMerger_ = spillPartitionSet_.begin()->second->createOrderedReader(
-      spillConfig_->readBufferSize, pool(), spillStats_);
+      *spillConfig_, pool(), spillStats_);
   spillPartitionSet_.clear();
 }
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SortWindowBuild.cpp b/velox/exec/SortWindowBuild.cpp
index f25175cc2cfa..eeadc8b6d9a7 100644
--- a/velox/exec/SortWindowBuild.cpp
+++ b/velox/exec/SortWindowBuild.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/exec/SortWindowBuild.h"
 #include "velox/exec/MemoryReclaimer.h"
+#include "velox/exec/Window.h"
 
 namespace facebook::velox::exec {
 
@@ -45,16 +46,19 @@ SortWindowBuild::SortWindowBuild(
     common::PrefixSortConfig&& prefixSortConfig,
     const common::SpillConfig* spillConfig,
     tsan_atomic<bool>* nonReclaimableSection,
+    folly::Synchronized<OperatorStats>* opStats,
     folly::Synchronized<common::SpillStats>* spillStats)
     : WindowBuild(node, pool, spillConfig, nonReclaimableSection),
       numPartitionKeys_{node->partitionKeys().size()},
       compareFlags_{makeCompareFlags(numPartitionKeys_, node->sortingOrders())},
       pool_(pool),
       prefixSortConfig_(prefixSortConfig),
+      opStats_(opStats),
       spillStats_(spillStats),
       sortedRows_(0, memory::StlAllocator<char*>(*pool)),
       partitionStartRows_(0, memory::StlAllocator<char*>(*pool)) {
   VELOX_CHECK_NOT_NULL(pool_);
+  VELOX_CHECK_NOT_NULL(opStats_);
   allKeyInfo_.reserve(partitionKeyInfo_.size() + sortKeyInfo_.size());
   allKeyInfo_.insert(
       allKeyInfo_.cend(), partitionKeyInfo_.begin(), partitionKeyInfo_.end());
@@ -72,13 +76,20 @@ void SortWindowBuild::addInput(RowVectorPtr input) {
 
   // Add all the rows into the RowContainer.
   for (auto row = 0; row < input->size(); ++row) {
-    char* newRow = data_->newRow();
+    addDecodedInputRow(decodedInputVectors_, row);
+  }
+}
 
-    for (auto col = 0; col < input->childrenSize(); ++col) {
-      data_->store(decodedInputVectors_[col], row, newRow, col);
-    }
+void SortWindowBuild::addDecodedInputRow(
+    std::vector<DecodedVector>& decodedInputVectors,
+    vector_size_t row) {
+  char* newRow = data_->newRow();
+
+  for (auto col = 0; col < inputChannels_.size(); ++col) {
+    data_->store(decodedInputVectors[col], row, newRow, col);
   }
-  numRows_ += input->size();
+
+  numRows_++;
 }
 
 void SortWindowBuild::ensureInputFits(const RowVectorPtr& input) {
@@ -280,7 +291,7 @@ void SortWindowBuild::noMoreInput() {
     spiller_->finishSpill(spillPartitionSet);
     VELOX_CHECK_EQ(spillPartitionSet.size(), 1);
     merge_ = spillPartitionSet.begin()->second->createOrderedReader(
-        spillConfig_->readBufferSize, pool_, spillStats_);
+        *spillConfig_, pool_, spillStats_);
   } else {
     // At this point we have seen all the input rows. The operator is
     // being prepared to output rows now.
@@ -294,14 +305,31 @@ void SortWindowBuild::noMoreInput() {
   pool_->release();
 }
 
-void SortWindowBuild::loadNextPartitionFromSpill() {
+void SortWindowBuild::loadNextPartitionBatchFromSpill() {
+  // Check if current partition batch still has available partitions. If so,
+  // return directly.
+  if (currentPartition_ < static_cast<int>(partitionStartRows_.size() - 2)) {
+    return;
+  }
+
+  const int minReadBatchRows = spillConfig_->windowMinReadBatchRows;
   sortedRows_.clear();
-  sortedRows_.shrink_to_fit();
+  sortedRows_.reserve(minReadBatchRows);
   data_->clear();
+  partitionStartRows_.clear();
+  partitionStartRows_.reserve(minReadBatchRows);
+  partitionStartRows_.push_back(0);
+  currentPartition_ = -1;
+  numSpillReadBatches_++;
 
+  // Load at least #minReadBatchRows rows and a complete partition. The rows
+  // might contain multiple partitions. Record the partition boundaries as
+  // inMemory case. In this way, the logic of getting window partitions would be
+  // identical between inMemory and spill.
   for (;;) {
     auto next = merge_->next();
     if (next == nullptr) {
+      partitionStartRows_.push_back(sortedRows_.size());
       break;
     }
 
@@ -324,7 +352,10 @@ void SortWindowBuild::loadNextPartitionFromSpill() {
     }
 
     if (newPartition) {
-      break;
+      partitionStartRows_.push_back(sortedRows_.size());
+      if (sortedRows_.size() >= minReadBatchRows) {
+        break;
+      }
     }
 
     auto* newRow = data_->newRow();
@@ -334,16 +365,19 @@ void SortWindowBuild::loadNextPartitionFromSpill() {
     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_);
+  // No more partition batches. All data is consumed.
+  if (sortedRows_.empty()) {
+    partitionStartRows_.clear();
+    numSpillReadBatches_--;
+
+    auto lockedOpStats = opStats_->wlock();
+    lockedOpStats->runtimeStats[Window::kWindowSpillReadNumBatches] =
+        RuntimeMetric(numSpillReadBatches_);
   }
+}
 
+std::shared_ptr<WindowPartition> SortWindowBuild::nextPartition() {
   VELOX_CHECK(!partitionStartRows_.empty(), "No window partitions available");
 
   currentPartition_++;
@@ -364,8 +398,7 @@ std::shared_ptr<WindowPartition> SortWindowBuild::nextPartition() {
 
 bool SortWindowBuild::hasNextPartition() {
   if (merge_ != nullptr) {
-    loadNextPartitionFromSpill();
-    return !sortedRows_.empty();
+    loadNextPartitionBatchFromSpill();
   }
 
   return partitionStartRows_.size() > 0 &&
diff --git a/velox/exec/SortWindowBuild.h b/velox/exec/SortWindowBuild.h
index 72875094007a..c6ddffebfbb6 100644
--- a/velox/exec/SortWindowBuild.h
+++ b/velox/exec/SortWindowBuild.h
@@ -32,6 +32,7 @@ class SortWindowBuild : public WindowBuild {
       common::PrefixSortConfig&& prefixSortConfig,
       const common::SpillConfig* spillConfig,
       tsan_atomic<bool>* nonReclaimableSection,
+      folly::Synchronized<OperatorStats>* opStats,
       folly::Synchronized<common::SpillStats>* spillStats);
 
   ~SortWindowBuild() override {
@@ -45,6 +46,10 @@ class SortWindowBuild : public WindowBuild {
 
   void addInput(RowVectorPtr input) override;
 
+  void addDecodedInputRow(
+      std::vector<DecodedVector>& decodedInputVectors,
+      vector_size_t row);
+
   void spill() override;
 
   std::optional<common::SpillStats> spilledStats() const override;
@@ -55,9 +60,9 @@ class SortWindowBuild : public WindowBuild {
 
   std::shared_ptr<WindowPartition> nextPartition() override;
 
- private:
   void ensureInputFits(const RowVectorPtr& input);
 
+ private:
   void ensureSortFits();
 
   void setupSpiller();
@@ -75,8 +80,10 @@ class SortWindowBuild : public WindowBuild {
   // 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();
+  // Load the next partition batch if needed. If current partition batch is not
+  // entirely consumed, return directly. Otherwise, read next partition batch
+  // from spilled data into 'data_' and set pointers in 'sortedRows_'.
+  void loadNextPartitionBatchFromSpill();
 
   const size_t numPartitionKeys_;
 
@@ -92,6 +99,8 @@ class SortWindowBuild : public WindowBuild {
   // Config for Prefix-sort.
   const common::PrefixSortConfig prefixSortConfig_;
 
+  folly::Synchronized<OperatorStats>* const opStats_;
+
   folly::Synchronized<common::SpillStats>* const spillStats_;
 
   // allKeyInfo_ is a combination of (partitionKeyInfo_ and sortKeyInfo_).
@@ -121,5 +130,8 @@ class SortWindowBuild : public WindowBuild {
 
   // Used to sort-merge spilled data.
   std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge_;
+
+  // Number of batches of whole partitions read from spilled data.
+  uint64_t numSpillReadBatches_ = 0;
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SortedAggregations.cpp b/velox/exec/SortedAggregations.cpp
index 79fbbedb885a..419c8102d435 100644
--- a/velox/exec/SortedAggregations.cpp
+++ b/velox/exec/SortedAggregations.cpp
@@ -63,7 +63,8 @@ struct RowPointers {
 SortedAggregations::SortedAggregations(
     const std::vector<const AggregateInfo*>& aggregates,
     const RowTypePtr& inputType,
-    memory::MemoryPool* pool) {
+    memory::MemoryPool* pool)
+    : pool_(pool) {
   // Collect inputs and sorting keys from all aggregates.
   std::unordered_set<column_index_t> allInputs;
   for (const auto* aggregate : aggregates) {
@@ -366,7 +367,7 @@ vector_size_t SortedAggregations::extractSingleGroup(
 void SortedAggregations::extractValues(
     folly::Range<char**> groups,
     const RowVectorPtr& result) {
-  raw_vector<int32_t> temp;
+  raw_vector<int32_t> indices(pool_);
   SelectivityVector rows;
   std::vector<char*> groupRows;
   for (const auto& [sortingSpec, aggregates] : aggregates_) {
@@ -432,7 +433,7 @@ void SortedAggregations::extractValues(
       aggregate->function->initializeNewGroups(
           groups.data(),
           folly::Range<const int32_t*>(
-              iota(groups.size(), temp), groups.size()));
+              iota(groups.size(), indices), groups.size()));
     }
   }
 }
diff --git a/velox/exec/SortedAggregations.h b/velox/exec/SortedAggregations.h
index 85acbdf4c9db..10ccba2ff233 100644
--- a/velox/exec/SortedAggregations.h
+++ b/velox/exec/SortedAggregations.h
@@ -142,6 +142,8 @@ class SortedAggregations {
     }
   };
 
+  memory::MemoryPool* const pool_;
+
   // Aggregates grouped by sorting keys and orders.
   folly::
       F14FastMap<SortingSpec, std::vector<const AggregateInfo*>, Hash, EqualTo>
diff --git a/velox/exec/SpatialIndex.cpp b/velox/exec/SpatialIndex.cpp
new file mode 100644
index 000000000000..52fee815af25
--- /dev/null
+++ b/velox/exec/SpatialIndex.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 <algorithm>
+#include <vector>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/exec/HilbertIndex.h"
+#include "velox/exec/SpatialIndex.h"
+
+namespace facebook::velox::exec {
+
+std::vector<size_t> RTreeLevel::query(
+    const Envelope& queryEnv,
+    const std::vector<size_t>& branchIndices) const {
+  std::vector<size_t> result;
+
+  for (size_t branchIdx : branchIndices) {
+    size_t startIdx = branchIdx * branchSize_;
+    size_t endIdx = std::min(startIdx + branchSize_, minXs_.size());
+    for (size_t idx = startIdx; idx < endIdx; ++idx) {
+      bool intersects = (queryEnv.maxX >= minXs_[idx]) &&
+          (queryEnv.maxY >= minYs_[idx]) && (queryEnv.minX <= maxXs_[idx]) &&
+          (queryEnv.minY <= maxYs_[idx]);
+      if (intersects) {
+        result.push_back(idx);
+      }
+    }
+  }
+
+  return result;
+}
+
+namespace {
+std::pair<RTreeLevel, std::vector<Envelope>> buildLevel(
+    uint32_t branchSize,
+    const std::vector<Envelope>& envelopes) {
+  std::vector<float> minXs;
+  minXs.reserve(envelopes.size());
+  std::vector<float> minYs;
+  minYs.reserve(envelopes.size());
+  std::vector<float> maxXs;
+  maxXs.reserve(envelopes.size());
+  std::vector<float> maxYs;
+  maxYs.reserve(envelopes.size());
+
+  std::vector<Envelope> parentEnvelopes;
+  parentEnvelopes.reserve((envelopes.size() + branchSize - 1) / branchSize);
+  Envelope currentBounds = Envelope::empty();
+
+  uint32_t idx = 0;
+  for (const auto& env : envelopes) {
+    ++idx;
+    currentBounds.maxX = std::max(currentBounds.maxX, env.maxX);
+    currentBounds.maxY = std::max(currentBounds.maxY, env.maxY);
+    currentBounds.minX = std::min(currentBounds.minX, env.minX);
+    currentBounds.minY = std::min(currentBounds.minY, env.minY);
+    if (idx % branchSize == 0) {
+      parentEnvelopes.push_back(currentBounds);
+      currentBounds = Envelope::empty();
+    }
+
+    minXs.push_back(env.minX);
+    minYs.push_back(env.minY);
+    maxXs.push_back(env.maxX);
+    maxYs.push_back(env.maxY);
+  }
+
+  if (!currentBounds.isEmpty()) {
+    parentEnvelopes.push_back(currentBounds);
+  }
+
+  return {
+      RTreeLevel(
+          branchSize,
+          std::move(minXs),
+          std::move(minYs),
+          std::move(maxXs),
+          std::move(maxYs)),
+      std::move(parentEnvelopes)};
+}
+} // namespace
+
+SpatialIndex::SpatialIndex(
+    Envelope bounds,
+    std::vector<Envelope> envelopes,
+    uint32_t branchSize)
+    : branchSize_(branchSize), bounds_(std::move(bounds)) {
+  VELOX_CHECK_GT(branchSize_, 1);
+
+  if (!bounds_.isEmpty()) {
+    HilbertIndex hilbert(
+        bounds_.minX, bounds_.minY, bounds_.maxX, bounds_.maxY);
+
+    std::sort(
+        envelopes.begin(), envelopes.end(), [&](const auto& a, const auto& b) {
+          return hilbert.indexOf(a.minX, a.minY) <
+              hilbert.indexOf(b.minX, b.minY);
+        });
+  }
+
+  rowIndices_.reserve(envelopes.size());
+  for (const auto& env : envelopes) {
+    VELOX_CHECK(env.minX >= bounds_.minX);
+    VELOX_CHECK(env.minY >= bounds_.minY);
+    VELOX_CHECK(env.maxX <= bounds_.maxX);
+    VELOX_CHECK(env.maxY <= bounds_.maxY);
+    rowIndices_.push_back(env.rowIndex);
+  }
+
+  if (envelopes.size() > 0) {
+    size_t numLevels =
+        std::ceil(std::log(envelopes.size()) / std::log(branchSize_));
+    levels_.reserve(numLevels);
+  }
+
+  while (envelopes.size() > branchSize_) {
+    auto [level, parentEnvelopes] = buildLevel(branchSize_, envelopes);
+    levels_.push_back(std::move(level));
+    envelopes = std::move(parentEnvelopes);
+  }
+
+  if (!envelopes.empty() && (envelopes.size() > 1 || levels_.empty())) {
+    levels_.push_back(buildLevel(branchSize_, envelopes).first);
+  }
+
+  if (!levels_.empty()) {
+    VELOX_CHECK_GT(branchSize_ + 1, levels_.back().size());
+  }
+}
+
+std::vector<vector_size_t> SpatialIndex::query(const Envelope& queryEnv) const {
+  std::vector<vector_size_t> result;
+  if (levels_.empty() || !Envelope::intersects(queryEnv, bounds_)) {
+    return result;
+  }
+
+  size_t thisLevel = levels_.size() - 1;
+  VELOX_CHECK_GT(levels_[thisLevel].size(), 0);
+  VELOX_CHECK_GT(branchSize_ + 1, levels_[thisLevel].size());
+
+  // The top level should have only one branch.
+  std::vector<size_t> childIndices = {0};
+  for (; thisLevel > 0; --thisLevel) {
+    // Avoiding thisLevel = 0 due to int underflow
+    childIndices = levels_[thisLevel].query(queryEnv, childIndices);
+    // If we have no matches, return.
+    if (childIndices.empty()) {
+      return result;
+    }
+  }
+
+  // We're at level 0 now.  The indices index into rowIndices.
+  VELOX_DCHECK_EQ(thisLevel, 0);
+  childIndices = levels_[thisLevel].query(queryEnv, childIndices);
+  result.reserve(childIndices.size());
+  for (auto idx : childIndices) {
+    result.push_back(rowIndices_[idx]);
+  }
+
+  return result;
+}
+
+Envelope SpatialIndex::bounds() const {
+  return bounds_;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialIndex.h b/velox/exec/SpatialIndex.h
new file mode 100644
index 000000000000..d6b2ad6d83b4
--- /dev/null
+++ b/velox/exec/SpatialIndex.h
@@ -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.
+ */
+
+#pragma once
+
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <vector>
+#include "velox/vector/TypeAliases.h"
+
+namespace facebook::velox::exec {
+
+/// A minimal envelope for a geometry.
+/// It also includes an index for the geometry for later reference.  This can
+/// be -1 if the geometry is not indexed.
+///
+/// Envelopes use float32s instead of float64s so that SIMD loops can be
+/// twice as fast.  Our geometries use float64 coordinates, so we have to
+/// downcast them for the envelope.  The loss of precision is theoretically fine
+/// because the envelope checks are already approximate: either they don't
+/// intersect or they might intersect.  Thus, expanding the envelopes slightly
+/// does not affect correctness (but it might affect efficiency slightly).
+///
+/// We want to show that if two envelopes expressed with float64 precision would
+/// intersect, the envelopes with float32 precision would also intersect.
+///
+/// Define
+/// ```
+/// nextUp(f) = std::nextafter(f, std::numeric_limits<float>::infinity())
+/// nextDown(f) = std::nextafter(f, -std::numeric_limits<float>::infinity())
+/// ```
+/// which move a float up or down one ulp (unit in the last place).
+///
+/// Since the conditions are all of the form `maxX >= minX` for float64s maxX
+/// and minX, we need to show that this implies `nextUp((float) maxX) >=
+/// nextDown((float) minX)`.
+///
+/// Assume you have a double `d` and two adjacent floats `f0` and `f1`, such
+/// that `d` is "between" `f0` and `f1`:
+///
+/// 1. `(double) f0 <= d <= (double) f1`
+/// 2. `nextup(f0) == f1 && f0 = nextdown(f0)`
+///
+/// This implies `nextdown((float) d) <= f0 && nextup((float) d) >= f1`.
+///
+/// Let double `minX` have two adjacent floats `f0`, `f1` as above, and `maxX`
+/// have two adjacent floats `g0`, `g1`.  Then
+/// ```
+/// (double) nextDown((float) minX)
+///   <= (double) f0
+///   <= minX
+///   <= maxX
+///   <= (double) g1
+///   <= (double) nextUp((float) maxX)
+/// ```
+///
+/// And this implies `nextDown((float) minX) <= nextUp((float) maxX)` as
+/// desired. The same argument applies to all for members, so if we construct
+/// the float32 precision envelope by applying nextDown to the minX/Ys and
+/// nextUp to maxX/Ys, the float32 envelope intersects in all cases that the
+/// float64 envelope would (but not necessarily the converse).
+struct Envelope {
+  float minX{std::numeric_limits<float>::infinity()};
+  float minY{std::numeric_limits<float>::infinity()};
+  float maxX{-std::numeric_limits<float>::infinity()};
+  float maxY{-std::numeric_limits<float>::infinity()};
+  vector_size_t rowIndex = -1;
+
+  /// Returns true if the intersection of two envelopes is not empty.
+  static inline bool intersects(const Envelope& left, const Envelope& right) {
+    return (left.maxX >= right.minX) && (left.minX <= right.maxX) &&
+        (left.maxY >= right.minY) && (left.minY <= right.maxY);
+  }
+
+  /// Returns true if the envelope contains at least one point.
+  /// An envelope of a point is not empty.
+  inline bool isEmpty() const {
+    // This negation handles NaNs correctly.
+    return !((minX <= maxX) && (minY <= maxY));
+  }
+
+  /// Expands this Envelope to also contain the other.
+  inline void merge(const Envelope& other) {
+    minX = std::min(minX, other.minX);
+    minY = std::min(minY, other.minY);
+    maxX = std::max(maxX, other.maxX);
+    maxY = std::max(maxY, other.maxY);
+  }
+
+  /// Construct an empty envelope.
+  static constexpr inline Envelope empty() {
+    return Envelope{
+        .minX = std::numeric_limits<float>::infinity(),
+        .minY = std::numeric_limits<float>::infinity(),
+        .maxX = -std::numeric_limits<float>::infinity(),
+        .maxY = -std::numeric_limits<float>::infinity()};
+  }
+
+  static constexpr inline Envelope from(
+      double minX,
+      double minY,
+      double maxX,
+      double maxY,
+      vector_size_t rowIndex = -1) {
+    return Envelope{
+        .minX = std::nextafterf(
+            static_cast<float>(minX), -std::numeric_limits<float>::infinity()),
+        .minY = std::nextafterf(
+            static_cast<float>(minY), -std::numeric_limits<float>::infinity()),
+        .maxX = std::nextafterf(
+            static_cast<float>(maxX), std::numeric_limits<float>::infinity()),
+        .maxY = std::nextafterf(
+            static_cast<float>(maxY), std::numeric_limits<float>::infinity()),
+        .rowIndex = rowIndex};
+  }
+
+  static inline Envelope of(const std::vector<Envelope>& envelopes) {
+    Envelope result = Envelope::empty();
+    for (const auto& envelope : envelopes) {
+      result.merge(envelope);
+    }
+    return result;
+  }
+};
+
+/// A single level of an R-tree.  It is a set of envelopes that can be linearly
+/// scanned for envelope intersection.
+class RTreeLevel {
+ public:
+  RTreeLevel(const RTreeLevel&) = delete;
+  RTreeLevel& operator=(const RTreeLevel&) = delete;
+
+  RTreeLevel() = default;
+  RTreeLevel(RTreeLevel&&) = default;
+  RTreeLevel& operator=(RTreeLevel&&) = default;
+  ~RTreeLevel() = default;
+
+  explicit RTreeLevel(
+      size_t branchSize,
+      std::vector<float> minXs,
+      std::vector<float> minYs,
+      std::vector<float> maxXs,
+      std::vector<float> maxYs)
+      : branchSize_{branchSize},
+        minXs_(std::move(minXs)),
+        minYs_(std::move(minYs)),
+        maxXs_(std::move(maxXs)),
+        maxYs_(std::move(maxYs)) {}
+
+  /// Returns the internal indices of all envelopes that probeEnv intersects.
+  /// Order of the returned indices is an implementation detail and cannot be
+  /// relied upon.
+  /// This does not do a short-circuit bounds check: the caller should do that
+  /// first.
+  std::vector<size_t> query(
+      const Envelope& queryEnv,
+      const std::vector<size_t>& branchIndices) const;
+
+  size_t size() const {
+    return minXs_.size();
+  }
+
+ private:
+  size_t branchSize_{};
+  Envelope bounds_;
+  std::vector<float> minXs_{};
+  std::vector<float> minYs_{};
+  std::vector<float> maxXs_{};
+  std::vector<float> maxYs_{};
+};
+
+/// A spatial index for a set of geometries. The index only cares about the
+/// envelopes of the geometries, and an index into the geometries (not stored in
+/// SpatialIndex).
+///
+/// The contract is that SpatialIndex::probe returns the indices of all
+/// envelopes that probeEnv intersects. The form of the index is an
+/// implementation detail. The order of the returned indicies is an
+/// implementation detail.
+class SpatialIndex {
+ public:
+  SpatialIndex(const SpatialIndex&) = delete;
+  SpatialIndex& operator=(const SpatialIndex&) = delete;
+
+  SpatialIndex() = default;
+  SpatialIndex(SpatialIndex&&) = default;
+  SpatialIndex& operator=(SpatialIndex&&) = default;
+  ~SpatialIndex() = default;
+
+  static const uint32_t kDefaultRTreeBranchSize = 32;
+
+  /// Constructs a spatial index from envelopes contained with `bounds`.
+  /// `bounds` must contain all envelopes in `envelopes`, otherwise the
+  /// an assertio will fail.  Envelopes should not contain NaN coordinates.
+  explicit SpatialIndex(
+      Envelope bounds,
+      std::vector<Envelope> envelopes,
+      uint32_t branchSize = kDefaultRTreeBranchSize);
+
+  /// Returns the row indices of all envelopes that probeEnv intersects.
+  /// Order of the returned indices is an implementation detail and cannot be
+  /// relied upon.
+  std::vector<vector_size_t> query(const Envelope& queryEnv) const;
+
+  /// Returns the envelope of the all envelopes in the index.
+  /// The returned envelope will have index = -1.
+  Envelope bounds() const;
+
+ private:
+  uint32_t branchSize_ = kDefaultRTreeBranchSize;
+
+  Envelope bounds_ = Envelope::empty();
+  std::vector<RTreeLevel> levels_{};
+  std::vector<vector_size_t> rowIndices_{};
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialJoinBuild.cpp b/velox/exec/SpatialJoinBuild.cpp
new file mode 100644
index 000000000000..18dea2179caa
--- /dev/null
+++ b/velox/exec/SpatialJoinBuild.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/exec/SpatialJoinBuild.h"
+#include <limits>
+#include "velox/common/geospatial/GeometryConstants.h"
+#ifdef VELOX_ENABLE_GEO
+#include "velox/common/geospatial/GeometrySerde.h"
+#endif
+#include "velox/exec/Task.h"
+
+namespace facebook::velox::exec {
+
+using velox::common::geospatial::GeometrySerializationType;
+
+void SpatialJoinBridge::setData(SpatialBuildResult buildResult) {
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(!buildResult_.has_value(), "setData must be called only once");
+    buildResult_ = std::move(buildResult);
+    promises = std::move(promises_);
+  }
+  notify(std::move(promises));
+}
+
+std::optional<SpatialBuildResult> SpatialJoinBridge::dataOrFuture(
+    ContinueFuture* future) {
+  std::lock_guard<std::mutex> l(mutex_);
+  VELOX_CHECK(!cancelled_, "Getting data after the build side is aborted");
+  if (buildResult_.has_value()) {
+    return buildResult_.value();
+  }
+  promises_.emplace_back("SpatialJoinBridge::dataOrFuture");
+  *future = promises_.back().getSemiFuture();
+  return std::nullopt;
+}
+
+SpatialJoinBuild::SpatialJoinBuild(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    std::shared_ptr<const core::SpatialJoinNode> joinNode)
+    : Operator(
+          driverCtx,
+          nullptr,
+          operatorId,
+          joinNode->id(),
+          "SpatialJoinBuild") {
+  const auto& buildType = joinNode->rightNode()->outputType();
+  buildGeometryChannel_ =
+      buildType->getChildIdx(joinNode->buildGeometry()->name());
+  VELOX_CHECK_EQ(
+      buildType->childAt(buildGeometryChannel_),
+      joinNode->buildGeometry()->type());
+  if (joinNode->radius().has_value()) {
+    auto radiusVar = joinNode->radius().value();
+    uint32_t radiusChannel = buildType->getChildIdx(radiusVar->name());
+    VELOX_CHECK_EQ(buildType->childAt(radiusChannel), radiusVar->type());
+    radiusChannel_ = radiusChannel;
+  }
+}
+
+void SpatialJoinBuild::addInput(RowVectorPtr input) {
+  if (input->size() > 0) {
+    // Load lazy vectors before storing.
+    for (auto& child : input->children()) {
+      child->loadedVector();
+    }
+    dataVectors_.emplace_back(std::move(input));
+  }
+}
+
+BlockingReason SpatialJoinBuild::isBlocked(ContinueFuture* future) {
+  if (!future_.valid()) {
+    return BlockingReason::kNotBlocked;
+  }
+  *future = std::move(future_);
+  return BlockingReason::kWaitForJoinBuild;
+}
+
+// Merge adjacent vectors to larger vectors as long as the result do not exceed
+// the size limit.  This is important for performance because each small vector
+// here would be duplicated by the number of rows on probe side, result in huge
+// number of small vectors in the output.
+std::vector<RowVectorPtr> SpatialJoinBuild::mergeDataVectors() const {
+  const auto maxBatchRows =
+      operatorCtx_->task()->queryCtx()->queryConfig().maxOutputBatchRows();
+  std::vector<RowVectorPtr> merged;
+  for (size_t i = 0; i < dataVectors_.size();) {
+    // convert int32_t to int64_t to avoid sum overflow
+    int64_t batchSize = static_cast<int64_t>(dataVectors_[i]->size());
+    auto j = i + 1;
+    while (j < dataVectors_.size() &&
+           batchSize + dataVectors_[j]->size() <= maxBatchRows) {
+      batchSize += dataVectors_[j++]->size();
+    }
+    if (j == i + 1) {
+      merged.push_back(dataVectors_[i++]);
+    } else {
+      auto batch = BaseVector::create<RowVector>(
+          dataVectors_[i]->type(),
+          static_cast<vector_size_t>(batchSize),
+          pool());
+      batchSize = 0;
+      while (i < j) {
+        auto* source = dataVectors_[i++].get();
+        batch->copy(
+            source, static_cast<vector_size_t>(batchSize), 0, source->size());
+        batchSize += source->size();
+      }
+      merged.push_back(std::move(batch));
+    }
+  }
+  return merged;
+}
+
+Envelope SpatialJoinBuild::readEnvelope(
+    const StringView& geometryBytes,
+    double radius) {
+#ifdef VELOX_ENABLE_GEO
+  radius = std::max(radius, 0.0);
+  auto geosEnvelope =
+      common::geospatial::GeometryDeserializer::deserializeEnvelope(
+          geometryBytes);
+  if (geosEnvelope->isNull()) {
+    return Envelope::empty();
+  } else {
+    return Envelope::from(
+        geosEnvelope->getMinX() - radius,
+        geosEnvelope->getMinY() - radius,
+        geosEnvelope->getMaxX() + radius,
+        geosEnvelope->getMaxY() + radius);
+  }
+#else
+  // When VELOX_ENABLE_GEO is not set, return an envelope of infinite area
+  // to ensure all geometries are considered for spatial join
+  return Envelope::from(
+      -std::numeric_limits<double>::infinity(),
+      -std::numeric_limits<double>::infinity(),
+      std::numeric_limits<double>::infinity(),
+      std::numeric_limits<double>::infinity());
+#endif
+}
+
+SpatialIndex SpatialJoinBuild::buildSpatialIndex(
+    const std::vector<RowVectorPtr>& data,
+    column_index_t geometryIdx,
+    std::optional<column_index_t> radiusIdx) {
+  size_t numRows = 0;
+  for (auto& vector : data) {
+    numRows += vector->size();
+  }
+  std::vector<Envelope> envelopes;
+  // TODO: Chunk the data to avoid allocating a large vector.
+  envelopes.reserve(numRows);
+
+  DecodedVector radiusCol;
+  DecodedVector geometryCol;
+  vector_size_t offset = 0;
+  Envelope bounds = Envelope::empty();
+
+  for (auto& vector : data) {
+    const auto& rawGeometryCol =
+        vector->childAt(geometryIdx)->asChecked<SimpleVector<StringView>>();
+    geometryCol.decode(*rawGeometryCol);
+
+    auto constantZero = velox::BaseVector::createConstant(
+        velox::DOUBLE(), 0.0, vector->size(), pool());
+    if (radiusIdx.has_value()) {
+      const auto& rawRadiusCol =
+          vector->childAt(radiusIdx.value())->asChecked<SimpleVector<double>>();
+      radiusCol.decode(*rawRadiusCol);
+    } else {
+      radiusCol.decode(*constantZero);
+    }
+
+    // TODO: Make a selectivity vector based on nulls and use for DecodedVector.
+    for (vector_size_t i = 0; i < vector->size(); ++i) {
+      if (geometryCol.isNullAt(i) || radiusCol.isNullAt(i)) {
+        // If geometry or radius is null, it will not match the predicate and so
+        // we should skip the envelope.
+        continue;
+      }
+      double radius = radiusCol.valueAt<double>(i);
+      const StringView geometryBytes = geometryCol.valueAt<StringView>(i);
+      Envelope envelope = SpatialJoinBuild::readEnvelope(geometryBytes, radius);
+      if (FOLLY_UNLIKELY(envelope.isEmpty())) {
+        continue;
+      }
+      envelope.rowIndex = offset + geometryCol.index(i);
+      bounds.merge(envelope);
+      envelopes.push_back(std::move(envelope));
+    }
+    offset += vector->size();
+  }
+  return SpatialIndex(std::move(bounds), std::move(envelopes));
+}
+
+void SpatialJoinBuild::noMoreInput() {
+  Operator::noMoreInput();
+  std::vector<ContinuePromise> promises;
+  std::vector<std::shared_ptr<Driver>> peers;
+  // The last Driver to hit SpatialJoinBuild::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;
+  }
+
+  {
+    auto promisesGuard = folly::makeGuard([&]() {
+      // 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();
+      }
+    });
+
+    for (auto& peer : peers) {
+      auto op = peer->findOperator(planNodeId());
+      auto* build = dynamic_cast<SpatialJoinBuild*>(op);
+      VELOX_CHECK_NOT_NULL(build);
+      dataVectors_.insert(
+          dataVectors_.end(),
+          std::make_move_iterator(build->dataVectors_.begin()),
+          std::make_move_iterator(build->dataVectors_.end()));
+    }
+  }
+
+  dataVectors_ = mergeDataVectors();
+  SpatialIndex spatialIndex =
+      buildSpatialIndex(dataVectors_, buildGeometryChannel_, radiusChannel_);
+  SpatialBuildResult buildResult;
+  buildResult.spatialIndex =
+      std::make_shared<SpatialIndex>(std::move(spatialIndex));
+  buildResult.buildVectors = std::move(dataVectors_);
+
+  operatorCtx_->task()
+      ->getSpatialJoinBridge(
+          operatorCtx_->driverCtx()->splitGroupId, planNodeId())
+      ->setData(std::move(buildResult));
+}
+
+bool SpatialJoinBuild::isFinished() {
+  return !future_.valid() && noMoreInput_;
+}
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialJoinBuild.h b/velox/exec/SpatialJoinBuild.h
new file mode 100644
index 000000000000..daceada9f296
--- /dev/null
+++ b/velox/exec/SpatialJoinBuild.h
@@ -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.
+ */
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/JoinBridge.h"
+#include "velox/exec/Operator.h"
+#include "velox/exec/SpatialIndex.h"
+
+namespace facebook::velox::exec {
+
+struct SpatialBuildResult {
+  std::vector<RowVectorPtr> buildVectors;
+  std::shared_ptr<SpatialIndex> spatialIndex;
+};
+
+class SpatialJoinBridge : public JoinBridge {
+ public:
+  void setData(SpatialBuildResult buildResult);
+
+  std::optional<SpatialBuildResult> dataOrFuture(ContinueFuture* future);
+
+ private:
+  std::optional<SpatialBuildResult> buildResult_;
+};
+
+class SpatialJoinBuild : public Operator {
+ public:
+  SpatialJoinBuild(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      std::shared_ptr<const core::SpatialJoinNode> joinNode);
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override {
+    return nullptr;
+  }
+
+  bool needsInput() const override {
+    return !noMoreInput_;
+  }
+
+  void noMoreInput() override;
+
+  BlockingReason isBlocked(ContinueFuture* future) override;
+
+  bool isFinished() override;
+
+  void close() override {
+    dataVectors_.clear();
+    Operator::close();
+  }
+
+  static Envelope readEnvelope(
+      const StringView& serializedGeometry,
+      double radius);
+
+ private:
+  std::vector<RowVectorPtr> mergeDataVectors() const;
+
+  SpatialIndex buildSpatialIndex(
+      const std::vector<RowVectorPtr>& data,
+      column_index_t geometryIdx,
+      std::optional<column_index_t> radiusIdx);
+
+  std::vector<RowVectorPtr> dataVectors_;
+
+  // Channel of geometry variable used to build spatial index
+  column_index_t buildGeometryChannel_;
+  // Channel (if set) of radius variable used to build spatial index
+  std::optional<column_index_t> radiusChannel_{};
+
+  // Future for synchronizing with other Drivers of the same pipeline. All build
+  // Drivers must be completed before making data available for the probe side.
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialJoinProbe.cpp b/velox/exec/SpatialJoinProbe.cpp
new file mode 100644
index 000000000000..2d398dc35ebb
--- /dev/null
+++ b/velox/exec/SpatialJoinProbe.cpp
@@ -0,0 +1,560 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/SpatialJoinProbe.h"
+#include "velox/exec/OperatorUtils.h"
+#include "velox/exec/SpatialJoinBuild.h"
+#include "velox/exec/Task.h"
+#include "velox/expression/FieldReference.h"
+
+namespace facebook::velox::exec {
+namespace {
+
+bool needsProbeMismatch(core::JoinType joinType) {
+  return isLeftJoin(joinType);
+}
+
+std::vector<IdentityProjection> extractProjections(
+    const RowTypePtr& srcType,
+    const RowTypePtr& destType) {
+  std::vector<IdentityProjection> projections;
+  for (auto i = 0; i < srcType->size(); ++i) {
+    auto name = srcType->nameOf(i);
+    auto outIndex = destType->getChildIdxIfExists(name);
+    if (outIndex.has_value()) {
+      projections.emplace_back(i, outIndex.value());
+    }
+  }
+  return projections;
+}
+
+} // namespace
+
+//////////////////
+// OUTPUT BUILDER
+
+void SpatialJoinOutputBuilder::initializeOutput(
+    const RowVectorPtr& input,
+    memory::MemoryPool* pool) {
+  if (output_ == nullptr) {
+    output_ =
+        BaseVector::create<RowVector>(outputType_, outputBatchSize_, pool);
+  } else {
+    VectorPtr outputVector = std::move(output_);
+    BaseVector::prepareForReuse(outputVector, outputBatchSize_);
+    output_ = std::static_pointer_cast<RowVector>(outputVector);
+  }
+  probeOutputIndices_ = allocateIndices(outputBatchSize_, pool);
+  rawProbeOutputIndices_ = probeOutputIndices_->asMutable<vector_size_t>();
+
+  // Add probe side projections as dictionary vectors
+  for (const auto& projection : probeProjections_) {
+    output_->childAt(projection.outputChannel) = wrapChild(
+        outputBatchSize_,
+        probeOutputIndices_,
+        input->childAt(projection.inputChannel));
+  }
+
+  // Add build side projections as uninitialized vectors
+  for (const auto& projection : buildProjections_) {
+    auto child = output_->childAt(projection.outputChannel);
+    if (child == nullptr) {
+      child = BaseVector::create(
+          outputType_->childAt(projection.outputChannel),
+          outputBatchSize_,
+          operatorCtx_.pool());
+    }
+  }
+}
+
+void SpatialJoinOutputBuilder::addOutputRow(
+    vector_size_t probeRow,
+    vector_size_t buildRow) {
+  VELOX_CHECK_NOT_NULL(probeOutputIndices_);
+  // Probe side is always a dictionary; just populate the index.
+  rawProbeOutputIndices_[outputRow_] = probeRow;
+
+  // For the build side, we accumulate the ranges to copy, then copy all of
+  // them at once. Consecutive records are copied in one memcpy.
+  if (!buildCopyRanges_.empty() &&
+      (buildCopyRanges_.back().sourceIndex + buildCopyRanges_.back().count) ==
+          buildRow) {
+    ++buildCopyRanges_.back().count;
+  } else {
+    buildCopyRanges_.push_back({buildRow, outputRow_, 1});
+  }
+  ++outputRow_;
+}
+
+void SpatialJoinOutputBuilder::copyBuildValues(
+    const RowVectorPtr& buildVector) {
+  if (buildCopyRanges_.empty()) {
+    return;
+  }
+
+  VELOX_CHECK_NOT_NULL(output_);
+
+  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 SpatialJoinOutputBuilder::addProbeMismatchRow(vector_size_t probeRow) {
+  VELOX_CHECK_NOT_NULL(output_);
+
+  // Probe side is always a dictionary; just populate the index.
+  rawProbeOutputIndices_[outputRow_] = probeRow;
+
+  // Null out build projections.
+  for (const auto& projection : buildProjections_) {
+    const auto& outputChild = output_->childAt(projection.outputChannel);
+    outputChild->setNull(outputRow_, true);
+  }
+  ++outputRow_;
+}
+
+RowVectorPtr SpatialJoinOutputBuilder::takeOutput() {
+  VELOX_CHECK(buildCopyRanges_.empty());
+  if (outputRow_ == 0 || !output_) {
+    return nullptr;
+  }
+  RowVectorPtr output = std::move(output_);
+  output->resize(outputRow_);
+  output_ = nullptr;
+  outputRow_ = 0;
+  return output;
+}
+
+////////////////////
+// SpatialJoinProbe
+
+SpatialJoinProbe::SpatialJoinProbe(
+    int32_t operatorId,
+    DriverCtx* driverCtx,
+    const std::shared_ptr<const core::SpatialJoinNode>& joinNode)
+    : Operator(
+          driverCtx,
+          joinNode->outputType(),
+          operatorId,
+          joinNode->id(),
+          "SpatialJoinProbe"),
+      joinType_(joinNode->joinType()),
+      outputBatchSize_{outputBatchRows()},
+      joinNode_(joinNode),
+      buildProjections_(extractProjections(
+          joinNode_->rightNode()->outputType(),
+          outputType_)),
+      outputBuilder_{
+          outputBatchSize_,
+          outputType_,
+          extractProjections(
+              joinNode_->leftNode()->outputType(),
+              outputType_), // these are the identity Projections
+          buildProjections_,
+          *operatorCtx_} {
+  auto probeType = joinNode_->leftNode()->outputType();
+  identityProjections_ = extractProjections(probeType, outputType_);
+  probeGeometryChannel_ =
+      probeType->getChildIdx(joinNode_->probeGeometry()->name());
+  VELOX_CHECK_EQ(
+      probeType->childAt(probeGeometryChannel_),
+      joinNode_->probeGeometry()->type());
+}
+
+/////////
+// SETUP
+
+void SpatialJoinProbe::initialize() {
+  Operator::initialize();
+
+  VELOX_CHECK_NOT_NULL(joinNode_);
+  if (joinNode_->joinCondition() != nullptr) {
+    initializeFilter(
+        joinNode_->joinCondition(),
+        joinNode_->leftNode()->outputType(),
+        joinNode_->rightNode()->outputType());
+  }
+
+  joinNode_.reset();
+}
+
+void SpatialJoinProbe::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(
+        "Spatial join filter field {} not in probe or build input, filter: {}",
+        field->toString(),
+        filter->toString());
+  }
+
+  filterInputType_ = ROW(std::move(names), std::move(types));
+}
+
+BlockingReason SpatialJoinProbe::isBlocked(ContinueFuture* future) {
+  switch (state_) {
+    case ProbeOperatorState::kRunning:
+      [[fallthrough]];
+    case ProbeOperatorState::kFinish:
+      return BlockingReason::kNotBlocked;
+    case ProbeOperatorState::kWaitForPeers:
+      if (future_.valid()) {
+        *future = std::move(future_);
+        return BlockingReason::kWaitForJoinProbe;
+      }
+      setState(ProbeOperatorState::kFinish);
+      return BlockingReason::kNotBlocked;
+    case ProbeOperatorState::kWaitForBuild: {
+      VELOX_CHECK(!buildVectors_.has_value());
+      if (!getBuildData(future)) {
+        return BlockingReason::kWaitForJoinBuild;
+      }
+      VELOX_CHECK(buildVectors_.has_value());
+      setState(ProbeOperatorState::kRunning);
+      return BlockingReason::kNotBlocked;
+    }
+    default:
+      VELOX_UNREACHABLE(probeOperatorStateName(state_));
+  }
+}
+
+void SpatialJoinProbe::close() {
+  if (joinCondition_ != nullptr) {
+    joinCondition_->clear();
+  }
+  buildVectors_.reset();
+  spatialIndex_.reset();
+  Operator::close();
+}
+
+void SpatialJoinProbe::noMoreInput() {
+  Operator::noMoreInput();
+  if (state_ == ProbeOperatorState::kRunning && input_ == nullptr) {
+    setState(ProbeOperatorState::kFinish);
+  }
+}
+
+bool SpatialJoinProbe::getBuildData(ContinueFuture* future) {
+  VELOX_CHECK(!buildVectors_.has_value());
+
+  auto buildData =
+      operatorCtx_->task()
+          ->getSpatialJoinBridge(
+              operatorCtx_->driverCtx()->splitGroupId, planNodeId())
+          ->dataOrFuture(future);
+  if (!buildData.has_value()) {
+    return false;
+  }
+
+  buildVectors_ = buildData.value().buildVectors;
+  spatialIndex_ = buildData.value().spatialIndex;
+  return true;
+}
+
+void SpatialJoinProbe::checkStateTransition(ProbeOperatorState state) {
+  VELOX_CHECK_NE(state_, state);
+  switch (state) {
+    case ProbeOperatorState::kRunning:
+      VELOX_CHECK_EQ(state_, ProbeOperatorState::kWaitForBuild);
+      break;
+    case ProbeOperatorState::kWaitForBuild:
+      [[fallthrough]];
+    case ProbeOperatorState::kFinish:
+      VELOX_CHECK_EQ(state_, ProbeOperatorState::kRunning);
+      break;
+    default:
+      VELOX_UNREACHABLE(probeOperatorStateName(state_));
+      break;
+  }
+}
+
+////////////////
+// INPUT/OUTPUT
+
+void SpatialJoinProbe::addInput(RowVectorPtr input) {
+  VELOX_CHECK_NULL(input_);
+  VELOX_CHECK_EQ(probeRow_, 0);
+  VELOX_CHECK(!probeHasMatch_);
+  VELOX_CHECK_EQ(buildVectorIndex_, 0);
+  VELOX_CHECK_EQ(candidateIndex_, 0);
+
+  // In getOutput(), we are going to wrap input in dictionaries a few rows at a
+  // time. Since lazy vectors cannot be wrapped in different dictionaries, we
+  // are going to load them here.
+  for (auto& child : input->children()) {
+    child->loadedVector();
+  }
+  input_ = std::move(input);
+  decodedGeometryCol_.decode(*input_->childAt(probeGeometryChannel_)
+                                  ->asChecked<SimpleVector<StringView>>());
+  ++probeCount_;
+}
+
+RowVectorPtr SpatialJoinProbe::getOutput() {
+  if (state_ == ProbeOperatorState::kFinish ||
+      state_ == ProbeOperatorState::kWaitForPeers) {
+    return nullptr;
+  }
+
+  RowVectorPtr output{nullptr};
+  while (output == nullptr) {
+    // Need more input.
+    if (input_ == nullptr) {
+      break;
+    }
+
+    // If the task owning this operator isn't running, there is no point
+    // to continue executing this procedure, which may be long in degenerate
+    // cases. Exit the working loop and let the Driver handle exiting
+    // gracefully in its own loop.
+    if (!operatorCtx_->task()->isRunning()) {
+      break;
+    }
+
+    if (shouldYield()) {
+      break;
+    }
+
+    // Generate actual join output by processing probe and build matches, and
+    // probe mismaches (for left joins).
+    output = generateOutput();
+  }
+
+  if (output != nullptr) {
+    ++outputCount_;
+  }
+  return output;
+}
+
+RowVectorPtr SpatialJoinProbe::generateOutput() {
+  VELOX_CHECK_NOT_NULL(input_);
+  VELOX_CHECK_GT(input_->size(), probeRow_);
+  outputBuilder_.initializeOutput(input_, pool());
+
+  while (!isOutputDone()) {
+    // Fill output_ with the results from one row.  This may produce too
+    // much output and only partially complete.  If so, the next time we
+    // call this we'll get the next chunk.
+    //
+    // addProbeRowOutput is responsible for advancing probeRow_.
+    addProbeRowOutput();
+  }
+
+  // If we've exhausted the input, release it.
+  if (probeRow_ >= input_->size()) {
+    finishProbeInput();
+  }
+
+  return outputBuilder_.takeOutput();
+}
+
+// Return true if adding output stops early because output is full.
+void SpatialJoinProbe::addProbeRowOutput() {
+  VELOX_CHECK(buildVectors_.has_value());
+  VELOX_CHECK(!outputBuilder_.isOutputFull());
+
+  // Find the candidates for each probe row from the spatial index.  Only do
+  // this at the start for each row.
+  if (buildVectorIndex_ == 0 && candidateIndex_ == 0) {
+    candidateBuildRows_ = querySpatialIndex();
+  }
+
+  while (!isProbeRowDone()) {
+    addBuildVectorOutput(buildVectors_.value()[buildVectorIndex_]);
+    if (outputBuilder_.isOutputFull()) {
+      // If full, don't advance buildVectorIndex_ because we may not have
+      // exhausted the current vector.  Return instead of breaking so that we
+      // can add a mismatch row later if necessary.
+      return;
+    }
+    advanceBuildVector();
+  }
+
+  // Now that we have finished the probe row, check if we need to add a probe
+  // mismatch record.
+  if (!probeHasMatch_ && needsProbeMismatch(joinType_)) {
+    outputBuilder_.addProbeMismatchRow(probeRow_);
+  }
+  // Advance here instead of the loop in generateOutput so that early return on
+  // full doesn't advance the probe.
+  advanceProbeRow();
+}
+
+void SpatialJoinProbe::addBuildVectorOutput(const RowVectorPtr& buildVector) {
+  if (FOLLY_UNLIKELY(needsFilterEvaluated_)) {
+    // Evaluate join filter for the whole vector just once.
+    evaluateJoinFilter(buildVector);
+    needsFilterEvaluated_ = false;
+  }
+
+  // Start where we left off: after the last buildRow_ that was processed.
+  while (!isBuildVectorDone(buildVector)) {
+    vector_size_t buildRow = relativeBuildRow(candidateIndex_);
+    if (isJoinConditionMatch(candidateIndex_)) {
+      outputBuilder_.addOutputRow(probeRow_, buildRow);
+      probeHasMatch_ = true;
+    }
+
+    // Advance candidateIndex_ even if full, since we're finished with this row.
+    ++candidateIndex_;
+  }
+
+  // Since we are copying from the current buildVector, we must copy here.
+  outputBuilder_.copyBuildValues(buildVector);
+}
+
+std::vector<int32_t> SpatialJoinProbe::querySpatialIndex() {
+  VELOX_CHECK(spatialIndex_.has_value());
+  VELOX_CHECK_NOT_NULL(spatialIndex_.value());
+
+  if (decodedGeometryCol_.isNullAt(probeRow_)) {
+    return std::vector<int32_t>{};
+  }
+
+  // Always apply radius to build side, not probe side.
+  Envelope envelope = SpatialJoinBuild::readEnvelope(
+      decodedGeometryCol_.valueAt<StringView>(probeRow_), 0 /* radius */);
+  std::vector<int32_t> candidates = spatialIndex_.value()->query(envelope);
+  std::sort(candidates.begin(), candidates.end());
+
+  return candidates;
+}
+
+BufferPtr SpatialJoinProbe::makeBuildVectorIndices(vector_size_t vectorSize) {
+  // Find the slice of candidates that are in this build vector.
+  vector_size_t endIndex = candidateIndex_;
+  for (; endIndex < candidateBuildRows_.size(); ++endIndex) {
+    if (relativeBuildRow(endIndex) >= vectorSize) {
+      break;
+    }
+  }
+
+  // Make an index vector to fit the candidates.  Populate each entry with its
+  // relative build row.
+  vector_size_t indexCount =
+      static_cast<vector_size_t>(endIndex - candidateIndex_);
+  auto rowIndices = allocateIndices(indexCount, operatorCtx_->pool());
+  auto rawIndices = rowIndices->asMutable<vector_size_t>();
+  for (vector_size_t idx = 0; idx < indexCount; ++idx) {
+    rawIndices[idx] = relativeBuildRow(idx + candidateIndex_);
+  }
+
+  return rowIndices;
+}
+
+void SpatialJoinProbe::evaluateJoinFilter(const RowVectorPtr& buildVector) {
+  // Get the indices of the rows in the build vector that are candidates.
+  auto candidateRowsBuffer = makeBuildVectorIndices(buildVector->size());
+
+  // Now get the input for the spatial join filter, one row per candidate.
+  auto filterInput = getNextJoinBatch(
+      buildVector,
+      filterInputType_,
+      filterProbeProjections_,
+      filterBuildProjections_,
+      candidateRowsBuffer);
+
+  if (filterInputRows_.size() != filterInput->size()) {
+    filterInputRows_.resizeFill(filterInput->size(), true);
+  }
+  VELOX_CHECK(filterInputRows_.isAllSelected());
+
+  std::vector<VectorPtr> filterResult;
+  EvalCtx evalCtx(
+      operatorCtx_->execCtx(), joinCondition_.get(), filterInput.get());
+  joinCondition_->eval(0, 1, true, filterInputRows_, evalCtx, filterResult);
+  VELOX_CHECK_GT(filterResult.size(), 0);
+  filterOutput_ = filterResult[0];
+  decodedFilterResult_.decode(*filterOutput_, filterInputRows_);
+}
+
+RowVectorPtr SpatialJoinProbe::getNextJoinBatch(
+    const RowVectorPtr& buildVector,
+    const RowTypePtr& outputType,
+    const std::vector<IdentityProjection>& probeProjections,
+    const std::vector<IdentityProjection>& buildProjections,
+    BufferPtr candidateRows) const {
+  VELOX_CHECK_GT(buildVector->size(), 0);
+  // candidateRows is a buffer of vector_size_t indices into buildVector
+  const vector_size_t numOutputRows =
+      candidateRows->size() / sizeof(vector_size_t);
+  if (numOutputRows == 0) {
+    return RowVector::createEmpty(outputType, pool());
+  }
+
+  std::vector<VectorPtr> projectedChildren(outputType->size());
+  // Project columns from the build side.
+  projectChildren(
+      projectedChildren,
+      buildVector,
+      buildProjections,
+      numOutputRows,
+      candidateRows);
+
+  // 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 SpatialJoinProbe::finishProbeInput() {
+  VELOX_CHECK_NOT_NULL(input_);
+  input_.reset();
+  probeRow_ = 0;
+
+  if (noMoreInput_) {
+    setState(ProbeOperatorState::kFinish);
+  }
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SpatialJoinProbe.h b/velox/exec/SpatialJoinProbe.h
new file mode 100644
index 000000000000..e9fc2eea13ab
--- /dev/null
+++ b/velox/exec/SpatialJoinProbe.h
@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/Operator.h"
+#include "velox/exec/ProbeOperatorState.h"
+#include "velox/exec/SpatialIndex.h"
+
+namespace facebook::velox::exec {
+
+class SpatialJoinOutputBuilder {
+ public:
+  SpatialJoinOutputBuilder(
+      vector_size_t outputBatchSize,
+      RowTypePtr outputType,
+      std::vector<IdentityProjection> probeProjections,
+      std::vector<IdentityProjection> buildProjections,
+      const OperatorCtx& operatorCtx)
+      : outputBatchSize_{outputBatchSize},
+        outputType_{std::move(outputType)},
+        probeProjections_{std::move(probeProjections)},
+        buildProjections_{std::move(buildProjections)},
+        operatorCtx_{operatorCtx} {
+    VELOX_CHECK_GT(outputBatchSize_, 0);
+  }
+
+  void initializeOutput(const RowVectorPtr& input, memory::MemoryPool* pool);
+
+  bool isOutputFull() const {
+    return outputRow_ >= outputBatchSize_;
+  }
+
+  void addOutputRow(vector_size_t probeRow, 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 addProbeMismatchRow(vector_size_t probeRow);
+
+  void copyBuildValues(const RowVectorPtr& buildVector);
+
+  RowVectorPtr takeOutput();
+
+ private:
+  // Initialization parameters
+  const vector_size_t outputBatchSize_;
+  const RowTypePtr outputType_;
+  const std::vector<IdentityProjection> probeProjections_;
+  const std::vector<IdentityProjection> buildProjections_;
+  const OperatorCtx& operatorCtx_;
+
+  // Output state
+  RowVectorPtr output_;
+  vector_size_t outputRow_{0};
+  // Dictionary indices for probe columns for output vector.
+  BufferPtr probeOutputIndices_;
+  // Mutable pointer to probeOutputIndices_
+  vector_size_t* rawProbeOutputIndices_{};
+
+  // 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_{};
+};
+
+/// Implements a Spatial Join between records from the probe (input_)
+/// and build (SpatialJoinBridge) sides. It supports inner and left joins.
+///
+/// This class is designed to evaluate spatial join conditions (e.g.
+/// ST_INTERSECTS, ST_CONTAINS, ST_WITHIN) between geometric data types. It
+/// can also implement spatial 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 spatial join condition.
+/// 3. Add spatial 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.
+///
+/// Spatial joins typically use spatial indexing for performance optimization,
+/// but this implementation follows the nested loop pattern for compatibility
+/// with the existing join framework.
+class SpatialJoinProbe : public Operator {
+ public:
+  SpatialJoinProbe(
+      int32_t operatorId,
+      DriverCtx* driverCtx,
+      const std::shared_ptr<const core::SpatialJoinNode>& joinNode);
+
+  void initialize() override;
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  bool needsInput() const override {
+    return state_ == ProbeOperatorState::kRunning && input_ == nullptr &&
+        !noMoreInput_;
+  }
+
+  void noMoreInput() override;
+
+  BlockingReason isBlocked(ContinueFuture* future) override;
+
+  bool isFinished() override {
+    return state_ == ProbeOperatorState::kFinish;
+  }
+
+  void close() override;
+
+ private:
+  void checkStateTransition(ProbeOperatorState state);
+
+  void setState(ProbeOperatorState state) {
+    checkStateTransition(state);
+    state_ = state;
+  }
+
+  // Initialize spatial filter for evaluating spatial join conditions.
+  void initializeFilter(
+      const core::TypedExprPtr& filter,
+      const RowTypePtr& leftType,
+      const RowTypePtr& rightType);
+
+  // Materializes build data from spatial join bridge into `buildVectors_`.
+  // Returns whether the data has been materialized and is ready for use.
+  // Spatial join requires all build data to be materialized and available in
+  // `buildVectors_` before it can produce output.
+  bool getBuildData(ContinueFuture* future);
+
+  // Produce as much output as possible for the current input.
+  RowVectorPtr generateOutput();
+
+  // Returns true if the input is exhausted or the output is full.
+  bool isOutputDone() const {
+    return probeRow_ >= input_->size() || outputBuilder_.isOutputFull();
+  }
+
+  // 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();
+
+  // Add the output for a single probe row.  This will return early if the
+  // output vector is full.
+  void addProbeRowOutput();
+
+  // Returns true if all output for the current probe row has been produced.
+  bool isProbeRowDone() const {
+    return candidateIndex_ >= candidateBuildRows_.size() ||
+        buildVectorIndex_ >= buildVectors_.value().size();
+  }
+
+  // Increment probeRow_ and reset associated fields
+  void advanceProbeRow() {
+    ++probeRow_;
+    probeHasMatch_ = false;
+    buildVectorIndex_ = 0;
+    candidateIndex_ = 0;
+    candidateOffsetForCurrentBuildVector_ = 0;
+    buildRowOffset_ = 0;
+    needsFilterEvaluated_ = true;
+  }
+
+  // Add the output for a single build vector for a single probe row.  This will
+  // return early if the output vector is full.
+  void addBuildVectorOutput(const RowVectorPtr& buildVector);
+
+  // Returns true if all the rows for the current build vector have been
+  // processed, or the output is full.
+  bool isBuildVectorDone(const RowVectorPtr& buildVector) const {
+    // Note that candidateBuildRows_ entries are row numbers across
+    // all build vectors.
+    return candidateIndex_ >= candidateBuildRows_.size() ||
+        relativeBuildRow(candidateIndex_) >= buildVector->size() ||
+        outputBuilder_.isOutputFull();
+  }
+
+  // Increment buildVectorIndex_ and reset associated fields
+  void advanceBuildVector() {
+    VELOX_CHECK(buildVectors_.has_value());
+
+    buildRowOffset_ += buildVectors_.value()[buildVectorIndex_]->size();
+    ++buildVectorIndex_;
+    needsFilterEvaluated_ = true;
+    candidateOffsetForCurrentBuildVector_ = candidateIndex_;
+  }
+
+  // Calculate candidate build rows from spatialIndex_ for the current probe
+  // row. This should be done each time the probe is advanced.
+  std::vector<int32_t> querySpatialIndex();
+
+  // Evaluates the spatial joinCondition for a given build vector. This method
+  // sets `filterOutput_` and `decodedFilterResult_`, which will be ready to
+  // be used by `isSpatialJoinConditionMatch()` below.
+  // This only evaluates rows that are in the candidateBuildRows_, restricted to
+  // those in the current build vector. Thus we must index into this with
+  // candidateIndex_.
+  void evaluateJoinFilter(const RowVectorPtr& buildVector);
+
+  // Checks if the spatial join condition matched for a particular row.
+  bool isJoinConditionMatch(vector_size_t candidateIndex) const {
+    vector_size_t relativeIndex =
+        candidateIndex - candidateOffsetForCurrentBuildVector_;
+    VELOX_CHECK_GT(decodedFilterResult_.size(), relativeIndex);
+    return (
+        !decodedFilterResult_.isNullAt(relativeIndex) &&
+        decodedFilterResult_.valueAt<bool>(relativeIndex));
+  }
+
+  // Generates the next batch of a cross product between probe and build using
+  // the supplied projections. It uses the current probe row as constant, and
+  // flat copied data for build records.
+  RowVectorPtr getNextJoinBatch(
+      const RowVectorPtr& buildVector,
+      const RowTypePtr& outputType,
+      const std::vector<IdentityProjection>& probeProjections,
+      const std::vector<IdentityProjection>& buildProjections,
+      BufferPtr candidateRows) const;
+
+  // Given a candidate index, return the row index into the current build
+  // vector.  For example, if we have candidates [2, 50, 81] and have processed
+  // two build vectors with size 30 and 40, then `relativeBuildRow(2) == 11`
+  // (81 - (30 + 40)).
+  vector_size_t relativeBuildRow(vector_size_t candidateRow) const {
+    return candidateBuildRows_[candidateRow] - buildRowOffset_;
+  }
+
+  // Make the indices of build vector candidates suitable for creating a
+  // DictionaryVector.
+  BufferPtr makeBuildVectorIndices(vector_size_t vectorSize);
+
+  /////////
+  // SETUP
+  // Variables set during operator setup that are used during execution.
+  // These should not be modified after the operator is initialized.
+
+  const core::JoinType joinType_;
+
+  // Maximum number of rows in the output batch.
+  const vector_size_t outputBatchSize_;
+
+  // Join metadata and state.
+  std::shared_ptr<const core::SpatialJoinNode> joinNode_;
+
+  // Spatial join condition expression.
+  // Must not be null
+  std::unique_ptr<ExprSet> joinCondition_;
+
+  // Input type for the spatial join condition expression.
+  RowTypePtr filterInputType_;
+
+  // 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 spatial 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_;
+
+  // Stores the build spatial index for the join
+  std::optional<std::shared_ptr<SpatialIndex>> spatialIndex_;
+  // Stores the data for build vectors (right side of the join).
+  std::optional<std::vector<RowVectorPtr>> buildVectors_;
+
+  // Channel of geometry variable used to probe spatial index
+  column_index_t probeGeometryChannel_;
+
+  //////////////////
+  // OPERATOR STATE
+  // Variables used to track the general operator state during exection.
+  // These will change throughout setup and execution.
+
+  ProbeOperatorState state_{ProbeOperatorState::kWaitForBuild};
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+
+  // The information needed to produce an output RowVectorPtr. It is stored
+  // for all execution, but is reset on each output batch.
+  SpatialJoinOutputBuilder outputBuilder_;
+
+  // Count of output batches produced (1-indexed). Primarily for debugging.
+  size_t outputCount_{0};
+
+  // This is always set to all true, but we need it for eval/etc. Reuse between
+  // evaluations.
+  SelectivityVector filterInputRows_;
+  // The output result of the join condition evaluation on the **current**
+  // build vector. We must index into this with
+  // `candidateIndex_ - candidateOffsetForCurrentBuildVector_`.
+  VectorPtr filterOutput_;
+  // Decoded filterOutput: remove recursive dictionary/etc encodings.
+  // Like filterOutput_, this is only for the current build vector and we
+  // must index into this with
+  // `candidateIndex_ - candidateOffsetForCurrentBuildVector_`.
+  DecodedVector decodedFilterResult_;
+
+  // Decoded geometry vector.  Must be reset whenever input_ is changed (it
+  // maintains a pointer to input_).
+  DecodedVector decodedGeometryCol_{};
+
+  ///////////////
+  // PROBE STATE
+  // Variables used to track the probe-side state state during exection.
+  // These will change throughout setup and execution.
+
+  // Count of probe batches added (1-indexed). Primarily for debugging.
+  size_t probeCount_{0};
+
+  // Probe row being currently processed (related to `input_`).
+  vector_size_t probeRow_{0};
+
+  // Whether the current probeRow_ has found a match.  Needed for left join.
+  bool probeHasMatch_{false};
+
+  ///////////////
+  // BUILD STATE
+  // Variables used to track the build-side state state during exection.
+  // These will change throughout setup and execution.
+  //
+  // The build rows are stored in a vector of RowVectorPtrs.  These are
+  // conceptually indexed by an absolute build row, which indexes into a
+  // flattened vector of rows.  buildVectorIndex_ is the index to the current
+  // RowVectorPtr in buildVectors_, buildRowOffset_ is the sum of the sizes
+  // of the previous build vectors and should be subtracted from buildRow
+  // to index into the current build vector.
+  //
+  // We primarily use candidateBuildRows_, which is a vector of (absolute)
+  // build rows.  candidateIndex_ indexes the entry in candidateBuildRows_,
+  // so candidateBuildrows_[candidiateIndex_] is the absolute build row
+  // of the current candidate.
+
+  // Whether we need to evaluate the join filter on this build vector.  It
+  // should be done once per build vector/probe row pair.
+  bool needsFilterEvaluated_{true};
+
+  // Index into `buildVectors_` for the build vector being currently
+  // processed.
+  size_t buildVectorIndex_{0};
+
+  // Keep track of how many build rows we've traversed in previous build
+  // RowVectors. Subtract this from the current element in candidateBuildRows_
+  // to index into the current build RowVector.
+  vector_size_t buildRowOffset_{0};
+
+  // Build rows returned from the spatial index.
+  // The value is the row number over all build vectors, so if the have two
+  // build vectors of size 100 and 200, candidate row 50 is the 50th entry of
+  // the first vector, and 101 is the 2nd entry of the second vector.
+  std::vector<vector_size_t> candidateBuildRows_{};
+
+  // Index of candidate currently being processed from
+  // `buildVectors_[buildIndex_]`.
+  vector_size_t candidateIndex_{0};
+
+  // How many candidates were in previous build vectors.
+  // This is important because for each build vector, we calculate a
+  // decodedFilterResult_ with only the rows from from the candidates in
+  // that build vector.  candidateIndex_ indexes over _all_ candidates, so
+  // we must substract candidateOffsetForCurrentBuildVector_ to index into the
+  // candidates for this build vector.
+  vector_size_t candidateOffsetForCurrentBuildVector_{0};
+};
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/Spill.cpp b/velox/exec/Spill.cpp
index 9b9f14eb75d6..15c077f743ce 100644
--- a/velox/exec/Spill.cpp
+++ b/velox/exec/Spill.cpp
@@ -15,14 +15,82 @@
  */
 
 #include "velox/exec/Spill.h"
+#include "velox/common/Casts.h"
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/OperatorUtils.h"
 #include "velox/serializers/PrestoSerializer.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
+
+namespace {
+/// gatherMerge merges & sorts with the mergeTree and gatherCopy the
+/// results into target. 'target' is the result RowVector, and the copying
+/// starts from row 0 up to row target.size(). 'mergeTree' is the data source.
+/// 'totalNumRows' is the actual num of rows that is copied to target.
+/// 'bufferSources' and 'bufferSourceIndices' are buffering vectors that could
+/// be reused across calls.
+void gatherMerge(
+    RowVectorPtr& target,
+    TreeOfLosers<SpillMergeStream>& mergeTree,
+    int32_t& totalNumRows,
+    std::vector<const RowVector*>& bufferSources,
+    std::vector<vector_size_t>& bufferSourceIndices) {
+  VELOX_CHECK_GE(bufferSources.size(), target->size());
+  VELOX_CHECK_GE(bufferSourceIndices.size(), target->size());
+  totalNumRows = 0;
+  int32_t numBatchRows = 0;
+  bool endOfBatch = false;
+  for (auto currentStream = mergeTree.next();
+       currentStream != nullptr && totalNumRows + numBatchRows < target->size();
+       currentStream = mergeTree.next()) {
+    bufferSources[numBatchRows] = &currentStream->current();
+    bufferSourceIndices[numBatchRows] =
+        currentStream->currentIndex(&endOfBatch);
+    ++numBatchRows;
+    if (FOLLY_UNLIKELY(endOfBatch)) {
+      // The stream is at end of input batch. Need to copy out the rows before
+      // fetching next batch in 'pop'.
+      gatherCopy(
+          target.get(),
+          totalNumRows,
+          numBatchRows,
+          bufferSources,
+          bufferSourceIndices);
+      totalNumRows += numBatchRows;
+      numBatchRows = 0;
+    }
+    // Advance the stream.
+    currentStream->pop();
+  }
+  VELOX_CHECK_LE(totalNumRows + numBatchRows, target->size());
+
+  if (FOLLY_LIKELY(numBatchRows != 0)) {
+    gatherCopy(
+        target.get(),
+        totalNumRows,
+        numBatchRows,
+        bufferSources,
+        bufferSourceIndices);
+    totalNumRows += numBatchRows;
+    numBatchRows = 0;
+  }
+}
+} // namespace
+
+void testingGatherMerge(
+    RowVectorPtr& target,
+    TreeOfLosers<SpillMergeStream>& mergeTree,
+    int32_t& totalNumRows,
+    std::vector<const RowVector*>& bufferSources,
+    std::vector<vector_size_t>& bufferSourceIndices) {
+  gatherMerge(
+      target, mergeTree, totalNumRows, bufferSources, bufferSourceIndices);
+}
+
 void SpillMergeStream::pop() {
   VELOX_CHECK(!closed_);
   if (++index_ >= size_) {
@@ -119,10 +187,11 @@ void SpillState::validateSpillBytesSize(uint64_t bytes) {
   static constexpr uint64_t kMaxSpillBytesPerWrite =
       std::numeric_limits<int32_t>::max();
   if (bytes >= kMaxSpillBytesPerWrite) {
-    VELOX_GENERIC_SPILL_FAILURE(fmt::format(
-        "Spill bytes will overflow. Bytes {}, kMaxSpillBytesPerWrite: {}",
-        bytes,
-        kMaxSpillBytesPerWrite));
+    VELOX_GENERIC_SPILL_FAILURE(
+        fmt::format(
+            "Spill bytes will overflow. Bytes {}, kMaxSpillBytesPerWrite: {}",
+            bytes,
+            kMaxSpillBytesPerWrite));
   }
 }
 
@@ -283,8 +352,9 @@ SpillPartition::createUnorderedReader(
   std::vector<std::unique_ptr<BatchStream>> streams;
   streams.reserve(files_.size());
   for (auto& fileInfo : files_) {
-    streams.push_back(FileSpillBatchStream::create(
-        SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
+    streams.push_back(
+        FileSpillBatchStream::create(
+            SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
   }
   files_.clear();
   return std::make_unique<UnorderedStreamReader<BatchStream>>(
@@ -292,15 +362,16 @@ SpillPartition::createUnorderedReader(
 }
 
 std::unique_ptr<TreeOfLosers<SpillMergeStream>>
-SpillPartition::createOrderedReader(
+SpillPartition::createOrderedReaderInternal(
     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)));
+    streams.push_back(
+        FileSpillMergeStream::create(
+            SpillReadFile::create(fileInfo, bufferSize, pool, spillStats)));
   }
   files_.clear();
   // Check if the partition is empty or not.
@@ -310,6 +381,174 @@ SpillPartition::createOrderedReader(
   return std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
 }
 
+namespace {
+size_t estimateOutputBatchRows(
+    const std::vector<std::unique_ptr<SpillMergeStream>>& streams,
+    vector_size_t maxRows,
+    size_t maxBytes) {
+  size_t numEstimations{0};
+  int64_t totalEstimatedBytes{0};
+  for (const auto& stream : streams) {
+    const auto streamEstimateRowSize = stream->estimateRowSize();
+    if (streamEstimateRowSize.has_value()) {
+      ++numEstimations;
+      totalEstimatedBytes += streamEstimateRowSize.value();
+    }
+  }
+
+  if (numEstimations == 0) {
+    return maxRows;
+  }
+
+  const auto estimateRowSize =
+      std::max<vector_size_t>(1, totalEstimatedBytes / numEstimations);
+  return std::min<vector_size_t>(
+      std::max<vector_size_t>(1, maxBytes / estimateRowSize), maxRows);
+}
+
+// This contains batching parameters and various kinds of batching buffers that
+// are reused across multiple merging rounds.
+struct SpillFileMergeParams {
+  static constexpr size_t kDefaultMaxBatchRows = 1'000;
+  static constexpr size_t kDefaultMaxBatchBytes = 64 * 1024;
+
+  SpillFileMergeParams(
+      const TypePtr& type,
+      memory::MemoryPool* pool,
+      const vector_size_t _maxBatchRows = kDefaultMaxBatchRows,
+      const size_t _maxBatchBytes = kDefaultMaxBatchBytes)
+      : maxBatchRows(_maxBatchRows), maxBatchBytes(_maxBatchBytes) {
+    rowVector = std::static_pointer_cast<RowVector>(
+        BaseVector::create(type, maxBatchRows, pool));
+    spillSources.resize(maxBatchRows);
+    spillSourceRows.resize(maxBatchRows);
+  }
+
+  const vector_size_t maxBatchRows;
+  const size_t maxBatchBytes;
+  RowVectorPtr rowVector;
+  std::vector<const RowVector*> spillSources;
+  std::vector<vector_size_t> spillSourceRows;
+};
+
+SpillFileInfo mergeSpillFiles(
+    const std::vector<SpillFileInfo>& files,
+    const std::string& pathPrefix,
+    const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+    const std::string& fileCreateConfig,
+    uint64_t readBufferSize,
+    uint64_t writeBufferSize,
+    SpillFileMergeParams& mergeParams,
+    memory::MemoryPool* pool,
+    folly::Synchronized<common::SpillStats>* spillStats) {
+  VELOX_CHECK_GT(files.size(), 0);
+  std::vector<std::unique_ptr<SpillMergeStream>> streams;
+  streams.reserve(files.size());
+  for (const auto& fileInfo : files) {
+    streams.push_back(
+        FileSpillMergeStream::create(
+            SpillReadFile::create(fileInfo, readBufferSize, pool, spillStats)));
+  }
+  const auto batchRows = estimateOutputBatchRows(
+      streams, mergeParams.maxBatchRows, mergeParams.maxBatchBytes);
+
+  auto mergeTree =
+      std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
+  const auto type = files[0].type;
+
+  auto writer = std::make_unique<SpillWriter>(
+      type,
+      files[0].sortingKeys,
+      files[0].compressionKind,
+      pathPrefix,
+      std::numeric_limits<uint64_t>::max(),
+      writeBufferSize,
+      fileCreateConfig,
+      updateAndCheckSpillLimitCb,
+      pool,
+      spillStats);
+
+  while (mergeTree->next()) {
+    VectorPtr tmpRowVector = std::move(mergeParams.rowVector);
+    BaseVector::prepareForReuse(tmpRowVector, batchRows);
+    mergeParams.rowVector = checkedPointerCast<RowVector>(tmpRowVector);
+    mergeParams.rowVector->resize(batchRows);
+    int32_t outputRow = 0;
+    gatherMerge(
+        mergeParams.rowVector,
+        *mergeTree,
+        outputRow,
+        mergeParams.spillSources,
+        mergeParams.spillSourceRows);
+
+    IndexRange range{0, outputRow};
+    writer->write(mergeParams.rowVector, folly::Range<IndexRange*>(&range, 1));
+  }
+  auto resultFiles = writer->finish();
+  VELOX_CHECK_EQ(resultFiles.size(), 1);
+  return std::move(resultFiles[0]);
+}
+
+struct SpillFileCompare {
+  bool operator()(const SpillFileInfo& lhs, const SpillFileInfo& rhs) const {
+    return lhs.size > rhs.size;
+  }
+};
+using SpillFileHeap = std::
+    priority_queue<SpillFileInfo, std::vector<SpillFileInfo>, SpillFileCompare>;
+} // namespace
+
+std::unique_ptr<TreeOfLosers<SpillMergeStream>>
+SpillPartition::createOrderedReader(
+    const common::SpillConfig& spillConfig,
+    memory::MemoryPool* pool,
+    folly::Synchronized<common::SpillStats>* spillStats) {
+  const auto numMaxMergeFiles = spillConfig.numMaxMergeFiles;
+  VELOX_CHECK_NE(numMaxMergeFiles, 1);
+  if (numMaxMergeFiles == 0 || files_.size() <= numMaxMergeFiles) {
+    return createOrderedReaderInternal(
+        spillConfig.readBufferSize, pool, spillStats);
+  }
+
+  SpillFileHeap orderedFiles(files_.begin(), files_.end());
+  SpillFiles files;
+  files.reserve(numMaxMergeFiles);
+  const auto mergeFilePathPrefix = files_[0].path;
+  SpillFileMergeParams mergeParams(files_[0].type, pool);
+
+  // Recursively merge the files.
+  for (uint32_t round = 0; orderedFiles.size() > numMaxMergeFiles; ++round) {
+    const uint64_t numMergeFiles = std::min(
+        static_cast<uint64_t>(numMaxMergeFiles),
+        static_cast<uint64_t>(orderedFiles.size() + 1 - numMaxMergeFiles));
+    // Choose the top 'numMergeFiles' smallest files for merging to minimize IO.
+    for (uint32_t i = 0; i < numMergeFiles; i++) {
+      files.push_back(orderedFiles.top());
+      orderedFiles.pop();
+    }
+    auto mergedFile = mergeSpillFiles(
+        files,
+        fmt::format("{}-merge-round-{}", mergeFilePathPrefix, round),
+        spillConfig.updateAndCheckSpillLimitCb,
+        spillConfig.fileCreateConfig,
+        spillConfig.readBufferSize,
+        spillConfig.writeBufferSize,
+        mergeParams,
+        pool,
+        spillStats);
+    orderedFiles.push(mergedFile);
+    files.clear();
+  }
+
+  files_.clear();
+  while (!orderedFiles.empty()) {
+    files_.push_back(orderedFiles.top());
+    orderedFiles.pop();
+  }
+  return createOrderedReaderInternal(
+      spillConfig.readBufferSize, pool, spillStats);
+}
+
 IterableSpillPartitionSet::IterableSpillPartitionSet() {
   spillPartitionIter_ = spillPartitions_.begin();
 }
@@ -429,13 +668,38 @@ const std::vector<SpillSortKey>& ConcatFilesSpillMergeStream::sortingKeys()
   return spillFiles_[fileIndex_]->sortingKeys();
 }
 
+std::unique_ptr<BatchStream> ConcatFilesSpillBatchStream::create(
+    std::vector<std::unique_ptr<SpillReadFile>> spillFiles) {
+  auto* spillStream = new ConcatFilesSpillBatchStream(std::move(spillFiles));
+  return std::unique_ptr<BatchStream>(spillStream);
+}
+
+bool ConcatFilesSpillBatchStream::nextBatch(RowVectorPtr& batch) {
+  TestValue::adjust(
+      "facebook::velox::exec::ConcatFilesSpillBatchStream::nextBatch", nullptr);
+  VELOX_CHECK_NULL(batch);
+  VELOX_CHECK(!atEnd_);
+  for (; fileIndex_ < spillFiles_.size(); ++fileIndex_) {
+    VELOX_CHECK_NOT_NULL(spillFiles_[fileIndex_]);
+    if (spillFiles_[fileIndex_]->nextBatch(batch)) {
+      VELOX_CHECK_NOT_NULL(batch);
+      return true;
+    }
+    spillFiles_[fileIndex_].reset();
+  }
+  spillFiles_.clear();
+  atEnd_ = true;
+  return false;
+}
+
 SpillPartitionId::SpillPartitionId(uint32_t partitionNumber)
     : encodedId_(partitionNumber) {
   if (FOLLY_UNLIKELY(partitionNumber >= (1 << kMaxPartitionBits))) {
-    VELOX_FAIL(fmt::format(
-        "Partition number {} exceeds max partition number {}",
-        partitionNumber,
-        1 << kMaxPartitionBits));
+    VELOX_FAIL(
+        fmt::format(
+            "Partition number {} exceeds max partition number {}",
+            partitionNumber,
+            1 << kMaxPartitionBits));
   }
 }
 
@@ -444,10 +708,11 @@ SpillPartitionId::SpillPartitionId(
     uint32_t partitionNumber) {
   const auto childSpillLevel = parent.spillLevel() + 1;
   if (FOLLY_UNLIKELY(childSpillLevel > kMaxSpillLevel)) {
-    VELOX_FAIL(fmt::format(
-        "Spill level {} exceeds max spill level {}",
-        childSpillLevel,
-        kMaxSpillLevel));
+    VELOX_FAIL(
+        fmt::format(
+            "Spill level {} exceeds max spill level {}",
+            childSpillLevel,
+            kMaxSpillLevel));
   }
   encodedId_ = parent.encodedId_;
   encodedId_ = encodedId_ & ~kSpillLevelBitMask;
@@ -459,15 +724,10 @@ SpillPartitionId::SpillPartitionId(
   encodedId_ |= partitionNumber << (kNumPartitionBits * childSpillLevel);
 }
 
-bool SpillPartitionId::operator==(const SpillPartitionId& other) const {
-  return encodedId_ == other.encodedId_;
-}
-
-bool SpillPartitionId::operator!=(const SpillPartitionId& other) const {
-  return !(*this == other);
-}
-
 bool SpillPartitionId::operator<(const SpillPartitionId& other) const {
+  if (*this == other) {
+    return false;
+  }
   for (auto i = 0; i <= std::min(spillLevel(), other.spillLevel()); ++i) {
     const auto selfPartitionNum = partitionNumber(i);
     const auto otherPartitionNum = other.partitionNumber(i);
diff --git a/velox/exec/Spill.h b/velox/exec/Spill.h
index ec7605af9593..128e1f938a45 100644
--- a/velox/exec/Spill.h
+++ b/velox/exec/Spill.h
@@ -21,11 +21,11 @@
 #include <re2/re2.h>
 #include "velox/common/base/SpillConfig.h"
 #include "velox/common/base/SpillStats.h"
+#include "velox/common/base/TreeOfLosers.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/exec/VectorHasher.h"
 #include "velox/vector/ComplexVector.h"
@@ -33,6 +33,23 @@
 #include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::exec {
+
+class SpillMergeStream;
+
+/// Testing gatherMerge without exposing the interface in the header. Used in
+/// test only. gatherMerge merges & sorts with the mergeTree and gatherCopy the
+/// results into target. 'target' is the result RowVector, and the copying
+/// starts from row 0 up to row target.size(). 'mergeTree' is the data source.
+/// 'totalNumRows' is the actual num of rows that is copied to target.
+/// 'bufferSources' and 'bufferSourceIndices' are buffering vectors that could
+/// be reused across calls.
+void testingGatherMerge(
+    RowVectorPtr& target,
+    TreeOfLosers<SpillMergeStream>& mergeTree,
+    int32_t& totalNumRows,
+    std::vector<const RowVector*>& bufferSources,
+    std::vector<vector_size_t>& bufferSourceIndices);
+
 class VectorHasher;
 
 /// A source of sorted spilled RowVectors coming either from a file or memory.
@@ -80,6 +97,15 @@ class SpillMergeStream : public MergeStream {
     return decoded_[index];
   }
 
+  /// Returns the estimated row size based on the vector received from the
+  /// merge source.
+  std::optional<int64_t> estimateRowSize() const {
+    if (rowVector_ == nullptr || rowVector_->size() == 0) {
+      return std::nullopt;
+    }
+    return rowVector_->estimateFlatSize() / rowVector_->size();
+  }
+
  protected:
   virtual const std::vector<SpillSortKey>& sortingKeys() const = 0;
 
@@ -192,6 +218,28 @@ class FileSpillBatchStream : public BatchStream {
   std::unique_ptr<SpillReadFile> spillFile_;
 };
 
+/// A source of spilled RowVectors coming from a sequence of files.
+///
+/// NOTE: this object is not thread-safe.
+class ConcatFilesSpillBatchStream final : public BatchStream {
+ public:
+  static std::unique_ptr<BatchStream> create(
+      std::vector<std::unique_ptr<SpillReadFile>> spillFiles);
+
+  bool nextBatch(RowVectorPtr& batch) override;
+
+ private:
+  explicit ConcatFilesSpillBatchStream(
+      std::vector<std::unique_ptr<SpillReadFile>> spillFiles)
+      : spillFiles_(std::move(spillFiles)) {
+    VELOX_CHECK(!spillFiles_.empty());
+  }
+
+  std::vector<std::unique_ptr<SpillReadFile>> spillFiles_;
+  size_t fileIndex_{0};
+  bool atEnd_{false};
+};
+
 /// A SpillMergeStream that contains a sequence of sorted spill files, the
 /// sorted keys are ordered both within each file and across files.
 class ConcatFilesSpillMergeStream final : public SpillMergeStream {
@@ -244,9 +292,7 @@ class SpillPartitionId {
   /// Constructs a child spill level id, descending from provided 'parent'.
   SpillPartitionId(SpillPartitionId parent, uint32_t partitionNumber);
 
-  bool operator==(const SpillPartitionId& other) const;
-
-  bool operator!=(const SpillPartitionId& other) const;
+  bool operator==(const SpillPartitionId& other) const = default;
 
   /// Customize the compare operator for recursive spilling control. It
   /// ensures the order such that:
@@ -267,7 +313,7 @@ class SpillPartitionId {
   bool operator<(const SpillPartitionId& other) const;
 
   bool operator>(const SpillPartitionId& other) const {
-    return (*this != other) && !(*this < other);
+    return other < *this;
   }
 
   std::string toString() const;
@@ -459,20 +505,31 @@ class SpillPartition {
       memory::MemoryPool* pool,
       folly::Synchronized<common::SpillStats>* spillStats);
 
+  /// Create an ordered stream reader from this spill partition. If the
+  /// partition has more than spillConfig.numMaxMergeFiles files, the files will
+  /// be pre-merged recursively to make sure the final ordered reader reads no
+  /// more than numMaxMergeFiles files. This behavior is to avoid OOM problem
+  /// when opening and reading too many files at the same time. If
+  /// numMaxMergeFiles < 2, the merge way is unlimited.
+  std::unique_ptr<TreeOfLosers<SpillMergeStream>> createOrderedReader(
+      const common::SpillConfig& spillConfig,
+      memory::MemoryPool* pool,
+      folly::Synchronized<common::SpillStats>* spillStats);
+
+  std::string toString() const;
+
+ private:
   /// 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(
+  std::unique_ptr<TreeOfLosers<SpillMergeStream>> createOrderedReaderInternal(
       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.
diff --git a/velox/exec/SpillFile.cpp b/velox/exec/SpillFile.cpp
index 0e612af59d40..c3cc3fea76a9 100644
--- a/velox/exec/SpillFile.cpp
+++ b/velox/exec/SpillFile.cpp
@@ -16,8 +16,7 @@
 
 #include "velox/exec/SpillFile.h"
 #include "velox/common/base/RuntimeMetrics.h"
-#include "velox/common/file/FileSystems.h"
-#include "velox/vector/VectorStream.h"
+#include "velox/serializers/SerializedPageFile.h"
 
 namespace facebook::velox::exec {
 namespace {
@@ -29,245 +28,90 @@ namespace {
 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,
+SpillWriter::SpillWriter(
+    const RowTypePtr& type,
+    const std::vector<SpillSortKey>& sortingKeys,
+    common::CompressionKind compressionKind,
     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;
-}
-
-SpillWriterBase::SpillWriterBase(
-    uint64_t writeBufferSize,
     uint64_t targetFileSize,
-    const std::string& pathPrefix,
+    uint64_t writeBufferSize,
     const std::string& fileCreateConfig,
-    common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+    const common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
     memory::MemoryPool* pool,
     folly::Synchronized<common::SpillStats>* stats)
-    : pool_(pool),
+    : serializer::SerializedPageFileWriter(
+          pathPrefix,
+          targetFileSize,
+          writeBufferSize,
+          fileCreateConfig,
+          std::make_unique<
+              serializer::presto::PrestoVectorSerde::PrestoOptions>(
+              kDefaultUseLosslessTimestamp,
+              compressionKind,
+              0.8,
+              /*_nullsFirst=*/true),
+          getNamedVectorSerde(VectorSerde::Kind::kPresto),
+          pool),
+      type_(type),
+      sortingKeys_(sortingKeys),
       stats_(stats),
-      updateAndCheckSpillLimitCb_(updateAndCheckSpillLimitCb),
-      fileCreateConfig_(fileCreateConfig),
-      pathPrefix_(pathPrefix),
-      writeBufferSize_(writeBufferSize),
-      targetFileSize_(targetFileSize) {}
+      updateAndCheckLimitCb_(updateAndCheckSpillLimitCb) {}
 
-SpillFiles SpillWriterBase::finish() {
-  checkNotFinished();
-  SCOPE_EXIT {
-    finished_ = true;
-  };
-  finishFile();
-  return std::move(finishedFiles_);
-}
-
-void SpillWriterBase::finishFile() {
-  checkNotFinished();
-  flush();
-  closeFile();
-  VELOX_CHECK_NULL(currentFile_);
-}
-
-uint64_t SpillWriterBase::flush() {
-  if (bufferEmpty()) {
-    return 0;
-  }
-
-  auto* file = ensureFile();
-  VELOX_CHECK_NOT_NULL(file);
-  uint64_t writtenBytes{0};
-  uint64_t flushTimeNs{0};
-  uint64_t writeTimeNs{0};
-  flushBuffer(file, writtenBytes, flushTimeNs, writeTimeNs);
-  updateWriteStats(writtenBytes, flushTimeNs, writeTimeNs);
-  updateAndCheckSpillLimitCb_(writtenBytes);
-  return writtenBytes;
-}
-
-SpillWriteFile* SpillWriterBase::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 SpillWriterBase::closeFile() {
-  if (currentFile_ == nullptr) {
-    return;
-  }
-  currentFile_->finish();
-  updateSpilledFileStats(currentFile_->size());
-  addFinishedFile(currentFile_.get());
-  currentFile_.reset();
-}
-
-uint64_t SpillWriterBase::writeWithBufferControl(
-    const std::function<uint64_t()>& writeCb) {
-  checkNotFinished();
-
-  uint64_t timeNs{0};
-  uint64_t rowsWritten{0};
-  {
-    NanosecondTimer timer(&timeNs);
-    rowsWritten = writeCb();
-  }
-  updateAppendStats(rowsWritten, timeNs);
-
-  if (bufferSize() < 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 SpillWriterBase::updateWriteStats(
+void SpillWriter::updateWriteStats(
     uint64_t spilledBytes,
     uint64_t flushTimeNs,
-    uint64_t writeTimeNs) {
+    uint64_t fileWriteTimeNs) {
   auto statsLocked = stats_->wlock();
   statsLocked->spilledBytes += spilledBytes;
   statsLocked->spillFlushTimeNanos += flushTimeNs;
-  statsLocked->spillWriteTimeNanos += writeTimeNs;
+  statsLocked->spillWriteTimeNanos += fileWriteTimeNs;
   ++statsLocked->spillWrites;
-  common::updateGlobalSpillWriteStats(spilledBytes, flushTimeNs, writeTimeNs);
+  common::updateGlobalSpillWriteStats(
+      spilledBytes, flushTimeNs, fileWriteTimeNs);
+  updateAndCheckLimitCb_(spilledBytes);
 }
 
-void SpillWriterBase::updateSpilledFileStats(uint64_t fileSize) {
+void SpillWriter::updateFileStats(
+    const serializer::SerializedPageFile::FileInfo& file) {
   ++stats_->wlock()->spilledFiles;
   addThreadLocalRuntimeStat(
-      "spillFileSize", RuntimeCounter(fileSize, RuntimeCounter::Unit::kBytes));
+      "spillFileSize", RuntimeCounter(file.size, RuntimeCounter::Unit::kBytes));
   common::incrementGlobalSpilledFiles();
 }
 
-void SpillWriterBase::updateAppendStats(
-    uint64_t numRows,
-    uint64_t serializationTimeNs) {
-  auto statsLocked = stats_->wlock();
-  statsLocked->spilledRows += numRows;
-  statsLocked->spillSerializationTimeNanos += serializationTimeNs;
-  common::updateGlobalSpillAppendStats(numRows, serializationTimeNs);
-}
-
-SpillWriter::SpillWriter(
-    const RowTypePtr& type,
-    const std::vector<SpillSortKey>& sortingKeys,
-    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)
-    : SpillWriterBase(
-          writeBufferSize,
-          targetFileSize,
-          pathPrefix,
-          fileCreateConfig,
-          updateAndCheckSpillLimitCb,
-          pool,
-          stats),
-      type_(type),
-      sortingKeys_(sortingKeys),
-      compressionKind_(compressionKind),
-      serde_(getNamedVectorSerde(VectorSerde::Kind::kPresto)) {}
-
-void SpillWriter::flushBuffer(
-    SpillWriteFile* file,
-    uint64_t& writtenBytes,
-    uint64_t& flushTimeNs,
-    uint64_t& writeTimeNs) {
-  IOBufOutputStream out(
-      *pool_, nullptr, std::max<int64_t>(64 * 1024, batch_->size()));
-  {
-    NanosecondTimer timer(&flushTimeNs);
-    batch_->flush(&out);
-  }
-  batch_.reset();
-
-  auto iobuf = out.getIOBuf();
-  {
-    NanosecondTimer timer(&writeTimeNs);
-    writtenBytes = file->write(std::move(iobuf));
+SpillFiles SpillWriter::finish() {
+  const auto serializedPageFiles =
+      serializer::SerializedPageFileWriter::finish();
+  SpillFiles spillFiles;
+  spillFiles.reserve(serializedPageFiles.size());
+  for (const auto& fileInfo : serializedPageFiles) {
+    spillFiles.push_back(
+        SpillFileInfo{
+            .id = fileInfo.id,
+            .type = type_,
+            .path = fileInfo.path,
+            .size = fileInfo.size,
+            .sortingKeys = sortingKeys_,
+            .compressionKind = serdeOptions_->compressionKind});
   }
-}
-
-uint64_t SpillWriter::write(
-    const RowVectorPtr& rows,
-    const folly::Range<IndexRange*>& indices) {
-  return writeWithBufferControl([&]() {
-    if (batch_ == nullptr) {
-      serializer::presto::PrestoVectorSerde::PrestoOptions options = {
-          kDefaultUseLosslessTimestamp,
-          compressionKind_,
-          0.8,
-          /*nullsFirst=*/true};
-      batch_ = std::make_unique<VectorStreamGroup>(pool_, serde_);
-      batch_->createStreamTree(
-          std::static_pointer_cast<const RowType>(rows->type()),
-          1'000,
-          &options);
-    }
-    batch_->append(rows, indices);
-    return rows->size();
-  });
-}
-
-void SpillWriter::addFinishedFile(SpillWriteFile* file) {
-  finishedFiles_.push_back(SpillFileInfo{
-      .id = file->id(),
-      .type = type_,
-      .path = file->path(),
-      .size = file->size(),
-      .sortingKeys = sortingKeys_,
-      .compressionKind = compressionKind_});
+  return spillFiles;
 }
 
 std::vector<std::string> SpillWriter::testingSpilledFilePaths() const {
   checkNotFinished();
 
   std::vector<std::string> spilledFilePaths;
+  spilledFilePaths.reserve(
+      finishedFiles_.size() + (currentFile_ != nullptr ? 1 : 0));
   for (auto& file : finishedFiles_) {
     spilledFilePaths.push_back(file.path);
   }
@@ -317,44 +161,25 @@ SpillReadFile::SpillReadFile(
     common::CompressionKind compressionKind,
     memory::MemoryPool* pool,
     folly::Synchronized<common::SpillStats>* stats)
-    : id_(id),
+    : serializer::SerializedPageFileReader(
+          path,
+          bufferSize,
+          type,
+          getNamedVectorSerde(VectorSerde::Kind::kPresto),
+          std::make_unique<
+              serializer::presto::PrestoVectorSerde::PrestoOptions>(
+              kDefaultUseLosslessTimestamp,
+              compressionKind,
+              0.8,
+              /*_nullsFirst=*/true),
+          pool),
+      id_(id),
       path_(path),
       size_(size),
-      type_(type),
       sortingKeys_(sortingKeys),
-      compressionKind_(compressionKind),
-      readOptions_{
-          kDefaultUseLosslessTimestamp,
-          compressionKind_,
-          0.8,
-          /*nullsFirst=*/true},
-      pool_(pool),
-      serde_(getNamedVectorSerde(VectorSerde::Kind::kPresto)),
-      stats_(stats) {
-  auto fs = filesystems::getFileSystem(path_, nullptr);
-  auto file = fs->openFileForRead(path_);
-  input_ = std::make_unique<common::FileInputStream>(
-      std::move(file), bufferSize, pool_);
-}
+      stats_(stats) {}
 
-bool SpillReadFile::nextBatch(RowVectorPtr& rowVector) {
-  if (input_->atEnd()) {
-    recordSpillStats();
-    return false;
-  }
-
-  uint64_t timeNs{0};
-  {
-    NanosecondTimer timer{&timeNs};
-    VectorStreamGroup::read(
-        input_.get(), pool_, type_, serde_, &rowVector, &readOptions_);
-  }
-  stats_->wlock()->spillDeserializationTimeNanos += timeNs;
-  common::updateGlobalSpillDeserializationTimeNs(timeNs);
-  return true;
-}
-
-void SpillReadFile::recordSpillStats() {
+void SpillReadFile::updateFinalStats() {
   VELOX_CHECK(input_->atEnd());
   const auto readStats = input_->stats();
   common::updateGlobalSpillReadStats(
@@ -363,5 +188,11 @@ void SpillReadFile::recordSpillStats() {
   lockedSpillStats->spillReads += readStats.numReads;
   lockedSpillStats->spillReadTimeNanos += readStats.readTimeNs;
   lockedSpillStats->spillReadBytes += readStats.readBytes;
-}
+};
+
+void SpillReadFile::updateSerializationTimeStats(uint64_t timeNs) {
+  stats_->wlock()->spillDeserializationTimeNanos += timeNs;
+  common::updateGlobalSpillDeserializationTimeNs(timeNs);
+};
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/SpillFile.h b/velox/exec/SpillFile.h
index 369a1c623399..6f194aa7c324 100644
--- a/velox/exec/SpillFile.h
+++ b/velox/exec/SpillFile.h
@@ -17,14 +17,16 @@
 #pragma once
 
 #include <folly/container/F14Set.h>
+#include <optional>
 
 #include "velox/common/base/SpillConfig.h"
 #include "velox/common/base/SpillStats.h"
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/common/compression/Compression.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileInputStream.h"
-#include "velox/exec/TreeOfLosers.h"
 #include "velox/serializers/PrestoSerializer.h"
+#include "velox/serializers/SerializedPageFile.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/VectorStream.h"
@@ -32,55 +34,6 @@
 namespace facebook::velox::exec {
 using SpillSortKey = std::pair<column_index_t, CompareFlags>;
 
-/// 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);
-
-  void write(const char* data, uint64_t bytes);
-
-  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;
@@ -94,113 +47,10 @@ struct SpillFileInfo {
 
 using SpillFiles = std::vector<SpillFileInfo>;
 
-/// Used to write the spilled data to a sequence of files for one partition.
-/// This base class provides the functionality of managing buffer and write
-/// files. The derived classes are responsible for:
-/// 1. Creating write API to accommodate the type of data to be spilled.
-/// 2. Implementing various buffer APIs and manage the buffer.
-class SpillWriterBase {
- public:
-  using WriteCb = std::function<uint64_t()>;
-
-  SpillWriterBase(
-      uint64_t writeBufferSize,
-      uint64_t targetFileSize,
-      const std::string& pathPrefix,
-      const std::string& fileCreateConfig,
-      common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
-      memory::MemoryPool* pool,
-      folly::Synchronized<common::SpillStats>* stats);
-
-  virtual ~SpillWriterBase() = default;
-
-  /// Finishes the current file writing.
-  void finishFile();
-
-  /// Finishes this file writer. Further writes to this spill writer are not
-  /// allowed after this call.
-  SpillFiles finish();
-
-  uint64_t numFinishedFiles() const {
-    return finishedFiles_.size();
-  }
-
- protected:
-  virtual void flushBuffer(
-      SpillWriteFile* file,
-      uint64_t& writtenBytes,
-      uint64_t& flushTimeNs,
-      uint64_t& writeTimeNs) = 0;
-
-  virtual bool bufferEmpty() const = 0;
-
-  virtual uint64_t bufferSize() const = 0;
-
-  virtual void addFinishedFile(SpillWriteFile* file) = 0;
-
-  // Write wrapper with buffer control. Derived class needs to implement
-  // 'writeCb' that needs to only write data to buffer, without taking care of
-  // the buffer limit. 'args' are the arguments to be passed to 'writeCb'.
-  uint64_t writeWithBufferControl(const std::function<uint64_t()>& writeCb);
-
-  // Writes data from buffer to the current output file. Returns the actual
-  // written size.
-  uint64_t flush();
-
-  FOLLY_ALWAYS_INLINE void checkNotFinished() const {
-    VELOX_CHECK(!finished_, "SpillWriter has finished");
-  }
-
-  memory::MemoryPool* const pool_;
-
-  folly::Synchronized<common::SpillStats>* const stats_;
-
-  std::unique_ptr<SpillWriteFile> currentFile_;
-
-  SpillFiles finishedFiles_;
-
- private:
-  // 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();
-
-  // Invoked to update the disk write stats.
-  void updateWriteStats(
-      uint64_t spilledBytes,
-      uint64_t flushTimeNs,
-      uint64_t writeTimeNs);
-
-  // 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);
-
-  // Updates the aggregated spill bytes of this query, and throws if exceeds
-  // the max spill bytes limit.
-  const common::UpdateAndCheckSpillLimitCB updateAndCheckSpillLimitCb_;
-
-  const std::string fileCreateConfig_;
-
-  const std::string pathPrefix_;
-
-  const uint64_t writeBufferSize_;
-
-  const uint64_t targetFileSize_;
-
-  uint64_t nextFileId_{0};
-
-  bool finished_{false};
-};
-
-/// If data is sorted, each file is sorted. The globally sorted order is
-/// produced by merging the constituent files.
-class SpillWriter : public SpillWriterBase {
+/// 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 serializer::SerializedPageFileWriter {
  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
@@ -221,49 +71,43 @@ class SpillWriter : public SpillWriterBase {
       uint64_t targetFileSize,
       uint64_t writeBufferSize,
       const std::string& fileCreateConfig,
-      common::UpdateAndCheckSpillLimitCB& updateAndCheckSpillLimitCb,
+      const 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);
+  /// Finishes this file writer and returns the written spill files info.
+  ///
+  /// NOTE: we don't allow write to a spill writer after finish
+  SpillFiles finish();
 
   std::vector<std::string> testingSpilledFilePaths() const;
 
   std::vector<uint32_t> testingSpilledFileIds() const;
 
  private:
-  bool bufferEmpty() const override {
-    return batch_ == nullptr;
-  }
-
-  uint64_t bufferSize() const override {
-    return batch_->size();
-  }
+  // Invoked to increment the number of spilled files and the file size.
+  void updateFileStats(
+      const serializer::SerializedPageFile::FileInfo& fileInfo) override;
 
-  void flushBuffer(
-      SpillWriteFile* file,
-      uint64_t& writtenBytes,
-      uint64_t& flushTimeNs,
-      uint64_t& writeTimeNs) override;
+  // Invoked to update the number of spilled rows.
+  void updateAppendStats(uint64_t numRows, uint64_t serializationTimeUs)
+      override;
 
-  void addFinishedFile(SpillWriteFile* file) override;
+  // Invoked to update the disk write stats.
+  void updateWriteStats(
+      uint64_t spilledBytes,
+      uint64_t flushTimeUs,
+      uint64_t writeTimeUs) override;
 
   const RowTypePtr type_;
 
   const std::vector<SpillSortKey> sortingKeys_;
 
-  const common::CompressionKind compressionKind_;
-
-  VectorSerde* const serde_;
+  folly::Synchronized<common::SpillStats>* const stats_;
 
-  std::unique_ptr<VectorStreamGroup> batch_;
+  // Updates the aggregated bytes of this query, and throws if exceeds
+  // the max bytes limit.
+  const common::UpdateAndCheckSpillLimitCB updateAndCheckLimitCb_;
 };
 
 /// Represents a spill file for read which turns the serialized spilled data
@@ -273,7 +117,7 @@ class SpillWriter : public SpillWriterBase {
 /// 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 {
+class SpillReadFile : public serializer::SerializedPageFileReader {
  public:
   static std::unique_ptr<SpillReadFile> create(
       const SpillFileInfo& fileInfo,
@@ -289,8 +133,6 @@ class SpillReadFile {
     return sortingKeys_;
   }
 
-  bool nextBatch(RowVectorPtr& rowVector);
-
   /// Returns the file size in bytes.
   uint64_t size() const {
     return size_;
@@ -312,24 +154,23 @@ class SpillReadFile {
       memory::MemoryPool* pool,
       folly::Synchronized<common::SpillStats>* stats);
 
-  // Invoked to record spill read stats at the end of read input.
-  void recordSpillStats();
+  // Records spill read stats at the end of read input.
+  void updateFinalStats() override;
+
+  void updateSerializationTimeStats(uint64_t timeNs) override;
 
   // 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 std::vector<SpillSortKey> sortingKeys_;
-  const common::CompressionKind compressionKind_;
-  const serializer::presto::PrestoVectorSerde::PrestoOptions readOptions_;
-  memory::MemoryPool* const pool_;
-  VectorSerde* const serde_;
-  folly::Synchronized<common::SpillStats>* const stats_;
 
-  std::unique_ptr<common::FileInputStream> input_;
+  folly::Synchronized<common::SpillStats>* const stats_;
 };
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Spiller.cpp b/velox/exec/Spiller.cpp
index d8dcec644e80..06675ede53aa 100644
--- a/velox/exec/Spiller.cpp
+++ b/velox/exec/Spiller.cpp
@@ -101,8 +101,9 @@ bool SpillerBase::fillSpillRuns(RowContainerIterator* iterator) {
 
     uint64_t totalRows{0};
     for (;;) {
-      const auto numRows = container_->listRows(
-          iterator, rows.size(), RowContainer::kUnlimited, rows.data());
+      // TODO: Reuse 'RowContainer::rowPointers_'.
+      const auto numRows =
+          container_->listRows(iterator, rows.size(), rows.data());
       if (numRows == 0) {
         lastRun = true;
         break;
@@ -154,8 +155,9 @@ void SpillerBase::runSpill(bool lastRun) {
     if (spillRun.rows.empty()) {
       continue;
     }
-    writes.push_back(memory::createAsyncMemoryReclaimTask<SpillStatus>(
-        [partitionId = id, this]() { return writeSpill(partitionId); }));
+    writes.push_back(
+        memory::createAsyncMemoryReclaimTask<SpillStatus>(
+            [partitionId = id, this]() { return writeSpill(partitionId); }));
     if ((writes.size() > 1) && executor_ != nullptr) {
       executor_->add([source = writes.back()]() { source->prepare(); });
     }
@@ -386,17 +388,13 @@ NoRowContainerSpiller::NoRowContainerSpiller(
     RowTypePtr rowType,
     std::optional<SpillPartitionId> parentId,
     HashBitRange bits,
-    const std::vector<SpillSortKey>& sortingKeys,
     const common::SpillConfig* spillConfig,
     folly::Synchronized<common::SpillStats>* spillStats)
-    : SpillerBase(
-          nullptr,
+    : NoRowContainerSpiller(
           std::move(rowType),
-          bits,
-          sortingKeys,
-          spillConfig->maxFileSize,
-          0,
           parentId,
+          bits,
+          {},
           spillConfig,
           spillStats) {}
 
@@ -404,13 +402,17 @@ NoRowContainerSpiller::NoRowContainerSpiller(
     RowTypePtr rowType,
     std::optional<SpillPartitionId> parentId,
     HashBitRange bits,
+    const std::vector<SpillSortKey>& sortingKeys,
     const common::SpillConfig* spillConfig,
     folly::Synchronized<common::SpillStats>* spillStats)
-    : NoRowContainerSpiller(
+    : SpillerBase(
+          nullptr,
           std::move(rowType),
-          parentId,
           bits,
-          {},
+          sortingKeys,
+          spillConfig->maxFileSize,
+          0,
+          parentId,
           spillConfig,
           spillStats) {}
 
diff --git a/velox/exec/Spiller.h b/velox/exec/Spiller.h
index 5fa5a913fa7c..9151a7eaf53f 100644
--- a/velox/exec/Spiller.h
+++ b/velox/exec/Spiller.h
@@ -202,14 +202,6 @@ class NoRowContainerSpiller : public SpillerBase {
  public:
   static constexpr std::string_view kType = "NoRowContainerSpiller";
 
-  NoRowContainerSpiller(
-      RowTypePtr rowType,
-      std::optional<SpillPartitionId> parentId,
-      HashBitRange bits,
-      const std::vector<SpillSortKey>& sortingKeys,
-      const common::SpillConfig* spillConfig,
-      folly::Synchronized<common::SpillStats>* spillStats);
-
   NoRowContainerSpiller(
       RowTypePtr rowType,
       std::optional<SpillPartitionId> parentId,
@@ -227,6 +219,15 @@ class NoRowContainerSpiller : public SpillerBase {
     }
   }
 
+ protected:
+  NoRowContainerSpiller(
+      RowTypePtr rowType,
+      std::optional<SpillPartitionId> parentId,
+      HashBitRange bits,
+      const std::vector<SpillSortKey>& sortingKeys,
+      const common::SpillConfig* spillConfig,
+      folly::Synchronized<common::SpillStats>* spillStats);
+
  private:
   std::string type() const override {
     return std::string(kType);
@@ -237,6 +238,24 @@ class NoRowContainerSpiller : public SpillerBase {
   }
 };
 
+class MergeSpiller final : public NoRowContainerSpiller {
+ public:
+  MergeSpiller(
+      RowTypePtr rowType,
+      std::optional<SpillPartitionId> parentId,
+      HashBitRange bits,
+      const std::vector<SpillSortKey>& sortingKeys,
+      const common::SpillConfig* spillConfig,
+      folly::Synchronized<common::SpillStats>* spillStats)
+      : NoRowContainerSpiller(
+            std::move(rowType),
+            parentId,
+            bits,
+            sortingKeys,
+            spillConfig,
+            spillStats) {}
+};
+
 class SortInputSpiller : public SpillerBase {
  public:
   static constexpr std::string_view kType = "SortInputSpiller";
diff --git a/velox/exec/StreamingAggregation.cpp b/velox/exec/StreamingAggregation.cpp
index 241e8c584778..9cb071ebaadf 100644
--- a/velox/exec/StreamingAggregation.cpp
+++ b/velox/exec/StreamingAggregation.cpp
@@ -41,8 +41,11 @@ StreamingAggregation::StreamingAggregation(
                         ->queryConfig()
                         .streamingAggregationMinOutputBatchRows())
               : maxOutputBatchSize_},
+      maxOutputBatchBytes_{
+          operatorCtx_->driverCtx()->queryConfig().preferredOutputBatchBytes()},
       aggregationNode_{aggregationNode},
-      step_{aggregationNode->step()} {
+      step_{aggregationNode->step()},
+      noGroupsSpanBatches_{aggregationNode_->noGroupsSpanBatches()} {
   if (aggregationNode_->ignoreNullKeys()) {
     VELOX_UNSUPPORTED(
         "Streaming aggregation doesn't support ignoring null keys yet");
@@ -200,12 +203,13 @@ RowVectorPtr StreamingAggregation::createOutput(size_t numGroups) {
   return output;
 }
 
-void StreamingAggregation::assignGroups() {
+bool StreamingAggregation::assignGroups() {
   const auto numInput = input_->size();
   VELOX_CHECK_GT(numInput, 0);
 
   inputGroups_.resize(numInput);
 
+  bool prevGroupAssigned{false};
   // Look for the end of the last group.
   vector_size_t index = 0;
   if (prevInput_ != nullptr) {
@@ -213,6 +217,7 @@ void StreamingAggregation::assignGroups() {
     auto* prevGroup = groups_[numGroups_ - 1];
     for (; index < numInput; ++index) {
       if (equalKeys(groupingKeys_, prevInput_, prevIndex, input_, index)) {
+        prevGroupAssigned = true;
         inputGroups_[index] = prevGroup;
       } else {
         break;
@@ -246,6 +251,7 @@ void StreamingAggregation::assignGroups() {
     }
   }
   groupBoundaries_.push_back(numInput);
+  return prevGroupAssigned;
 }
 
 const SelectivityVector& StreamingAggregation::getSelectivityVector(
@@ -280,7 +286,8 @@ void StreamingAggregation::evaluateAggregates() {
     std::vector<VectorPtr> args;
     for (auto j = 0; j < inputs.size(); ++j) {
       if (inputs[j] == kConstantChannel) {
-        args.push_back(constantInputs[j]);
+        args.push_back(
+            BaseVector::wrapInConstant(input_->size(), 0, constantInputs[j]));
       } else {
         args.push_back(input_->childAt(inputs[j]));
       }
@@ -326,13 +333,20 @@ bool StreamingAggregation::isFinished() {
 
 RowVectorPtr StreamingAggregation::getOutput() {
   if (!input_) {
+    SCOPE_EXIT {
+      outputFirstGroup_ = false;
+    };
     if ((noMoreInput_ || isDraining()) && numGroups_ > 0) {
-      return createOutput(
-          std::min(numGroups_, static_cast<size_t>(maxOutputBatchSize_)));
+      return createOutput(numGroups_);
+    }
+    if (outputFirstGroup_) {
+      VELOX_CHECK_GT(numGroups_, 1);
+      return createOutput(1);
     }
     maybeFinishDrain();
     return nullptr;
   }
+  VELOX_CHECK(!outputFirstGroup_);
 
   const auto numInput = input_->size();
   inputRows_.resize(numInput);
@@ -341,17 +355,44 @@ RowVectorPtr StreamingAggregation::getOutput() {
   masks_->addInput(input_, inputRows_);
 
   const auto numPrevGroups = numGroups_;
-
-  assignGroups();
+  const bool prevGroupAssigned = assignGroups();
   initializeNewGroups(numPrevGroups);
   evaluateAggregates();
 
+  const auto estimatedRowBytes = rows_->estimateRowSize();
+  const auto estimatedBatchBytes =
+      estimatedRowBytes.value_or(0) * rows_->numRows();
+
   RowVectorPtr output;
-  if (numGroups_ > minOutputBatchSize_) {
-    output = createOutput(
-        std::min(numGroups_ - 1, static_cast<size_t>(maxOutputBatchSize_)));
+
+  const bool outputDueToBatchSize = numGroups_ > minOutputBatchSize_;
+  const bool outputDueToBatchBytes =
+      numGroups_ > 1 && estimatedBatchBytes > maxOutputBatchBytes_;
+  if ((noGroupsSpanBatches_ || numPrevGroups > 0) &&
+      (outputDueToBatchSize || outputDueToBatchBytes)) {
+    size_t numOutputGroups{0};
+    if (noGroupsSpanBatches_) {
+      numOutputGroups = numGroups_;
+    } else {
+      // NOTE: we only want to apply the single group output optimization if
+      // 'minOutputBatchSize_' is set to one for eagerly streaming output
+      // producing.
+      if (!prevGroupAssigned || numPrevGroups == 1 ||
+          minOutputBatchSize_ != 1) {
+        numOutputGroups = std::min(numGroups_ - 1, numPrevGroups);
+      } else {
+        numOutputGroups = std::min(numGroups_ - 1, numPrevGroups - 1);
+        outputFirstGroup_ = (numGroups_ - numOutputGroups) > 1;
+      }
+    }
+    VELOX_CHECK_GT(numOutputGroups, 0);
+    output = createOutput(numOutputGroups);
   }
   prevInput_ = input_;
+  if (numGroups_ == 0) {
+    VELOX_CHECK(noGroupsSpanBatches_);
+    prevInput_ = nullptr;
+  }
   input_ = nullptr;
   return output;
 }
@@ -384,6 +425,7 @@ std::unique_ptr<RowContainer> StreamingAggregation::makeRowContainer(
       false,
       false,
       false,
+      false,
       pool());
 }
 
diff --git a/velox/exec/StreamingAggregation.h b/velox/exec/StreamingAggregation.h
index 951cab1a4105..5fcf5d4b7294 100644
--- a/velox/exec/StreamingAggregation.h
+++ b/velox/exec/StreamingAggregation.h
@@ -40,7 +40,9 @@ class StreamingAggregation : public Operator {
   RowVectorPtr getOutput() override;
 
   bool needsInput() const override {
-    return true;
+    // We don't need input if the first group is ready to output which has mixed
+    // input sources across streaming input batches.
+    return !outputFirstGroup_;
   }
 
   bool startDrain() override;
@@ -71,8 +73,9 @@ class StreamingAggregation : public Operator {
   RowVectorPtr createOutput(size_t numGroups);
 
   // Assign input rows to groups based on values of the grouping keys. Store the
-  // assignments in inputGroups_.
-  void assignGroups();
+  // assignments in inputGroups_. Returns true if there is input rows have been
+  // assigned to the previously last group.
+  bool assignGroups();
 
   // Add input data to accumulators.
   void evaluateAggregates();
@@ -87,17 +90,26 @@ class StreamingAggregation : public Operator {
   // Initialize the aggregations setting allocator and offsets.
   void initializeAggregates(uint32_t numKeys);
 
-  /// Maximum number of rows in the output batch.
+  // Maximum number of rows in the output batch.
   const vector_size_t maxOutputBatchSize_;
 
-  /// Maximum number of rows in the output batch.
+  // Maximum number of rows in the output batch.
   const vector_size_t minOutputBatchSize_;
 
+  // If the size of the data in the RowContainer exceeds this value, we will
+  // output a batch regardless of the number of rows.
+  const uint64_t maxOutputBatchBytes_;
+
   // Used at initialize() and gets reset() afterward.
   std::shared_ptr<const core::AggregationNode> aggregationNode_;
 
   const core::AggregationNode::Step step_;
 
+  // When true, indicates that no sort group spans across input batches. Each
+  // input batch contains complete data for its groups. This allows the
+  // streaming aggregation operator to produce all group results for each input.
+  const bool noGroupsSpanBatches_;
+
   std::vector<column_index_t> groupingKeys_;
   std::vector<AggregateInfo> aggregates_;
   std::unique_ptr<SortedAggregations> sortedAggregations_;
@@ -119,6 +131,17 @@ class StreamingAggregation : public Operator {
   // remaining entries are re-usable.
   size_t numGroups_{0};
 
+  // If true, we want to output the first group which has inputs across
+  // different batches. Hence the next output could only contain the input from
+  // a single streaming input batch. This is used to help avoid data copy in
+  // streaming aggregation function processing which is only applicable if all
+  // the sources are from the same input batch.
+  //
+  // NOTE: the streaming aggregation operator must have at-least more than one
+  // groups in this case. Also we only enable this optimization if
+  // 'minOutputBatchSize_' is set to one for eagerly streaming output producing.
+  bool outputFirstGroup_{false};
+
   // Reusable memory.
 
   // Pointers to groups for all input rows.
diff --git a/velox/exec/SubPartitionedSortWindowBuild.cpp b/velox/exec/SubPartitionedSortWindowBuild.cpp
new file mode 100644
index 000000000000..bb380abeaad0
--- /dev/null
+++ b/velox/exec/SubPartitionedSortWindowBuild.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/SubPartitionedSortWindowBuild.h"
+#include "velox/exec/MemoryReclaimer.h"
+
+namespace facebook::velox::exec {
+
+SubPartitionedSortWindowBuild::SubPartitionedSortWindowBuild(
+    const std::shared_ptr<const core::WindowNode>& node,
+    int32_t numSubPartitions,
+    velox::memory::MemoryPool* pool,
+    common::PrefixSortConfig&& prefixSortConfig,
+    const common::SpillConfig* spillConfig,
+    tsan_atomic<bool>* nonReclaimableSection,
+    folly::Synchronized<OperatorStats>* opStats,
+    folly::Synchronized<common::SpillStats>* spillStats)
+    : WindowBuild(node, pool, spillConfig, nonReclaimableSection),
+      numSubPartitions_(numSubPartitions),
+      numPartitionKeys_{node->partitionKeys().size()},
+      pool_(pool),
+      spillStats_(spillStats) {
+  VELOX_CHECK_NOT_NULL(pool_);
+  data_.reset();
+
+  std::vector<column_index_t> keyChannels(numPartitionKeys_);
+  for (int i = 0; i < numPartitionKeys_; i++) {
+    keyChannels[i] = inputChannels_[i];
+  }
+  subPartitioningFunction_ = std::make_unique<HashPartitionFunction>(
+      false, numSubPartitions_, node->inputType(), keyChannels);
+  subWindowBuilds_.resize(numSubPartitions_);
+  for (int i = 0; i < numSubPartitions_; i++) {
+    subWindowBuilds_[i] = std::make_unique<SortWindowBuild>(
+        node,
+        pool,
+        common::PrefixSortConfig(prefixSortConfig),
+        spillConfig,
+        nonReclaimableSection,
+        opStats,
+        spillStats);
+  }
+}
+
+void SubPartitionedSortWindowBuild::addInput(RowVectorPtr input) {
+  VELOX_CHECK_LT(currentSubPartition_, 0);
+
+  subPartitionIdsBuffer_.resize(input->size());
+  subPartitioningFunction_->partition(*input, subPartitionIdsBuffer_);
+
+  for (auto i = 0; i < inputChannels_.size(); ++i) {
+    decodedInputVectors_[i].decode(*input->childAt(inputChannels_[i]));
+  }
+
+  ensureInputFits(input);
+
+  for (auto row = 0; row < input->size(); ++row) {
+    auto& windowBuild = subWindowBuilds_[subPartitionIdsBuffer_[row]];
+    windowBuild->addDecodedInputRow(decodedInputVectors_, row);
+  }
+
+  numRows_ += input->size();
+}
+
+bool SubPartitionedSortWindowBuild::switchToNextSubPartition() {
+  if (currentSubPartition_ >= numSubPartitions_) {
+    return false;
+  }
+
+  if (currentSubPartition_ >= 0) {
+    subWindowBuilds_[currentSubPartition_].reset();
+  }
+  currentSubPartition_++;
+  if (currentSubPartition_ >= numSubPartitions_) {
+    return false;
+  }
+
+  VELOX_CHECK_NOT_NULL(subWindowBuilds_[currentSubPartition_]);
+  // WindowBuild starts processing the partitions when 'noMoreInput' is called,
+  // which allocates additional memory. We want to defer the memory allocation
+  // as late as possible to reduce memory usage, so we don't call 'noMoreInput'
+  // until the sub partition's data is to be consumed.
+  subWindowBuilds_[currentSubPartition_]->noMoreInput();
+  return true;
+}
+
+void SubPartitionedSortWindowBuild::ensureInputFits(const RowVectorPtr& input) {
+  if (spillConfig_ == nullptr) {
+    // Spilling is disabled.
+    return;
+  }
+
+  if (numRows_ == 0) {
+    // Nothing to spill.
+    return;
+  }
+
+  // Test-only spill path.
+  if (testingTriggerSpill(pool_->name())) {
+    spill();
+    return;
+  }
+
+  VELOX_CHECK_LT(currentSubPartition_, 0);
+  for (auto& windowBuild : subWindowBuilds_) {
+    windowBuild->ensureInputFits(input);
+  }
+}
+
+void SubPartitionedSortWindowBuild::spill() {
+  VELOX_CHECK_LT(currentSubPartition_, 0);
+  for (auto& windowBuild : subWindowBuilds_) {
+    windowBuild->spill();
+  }
+  spilled_ = true;
+}
+
+std::optional<common::SpillStats> SubPartitionedSortWindowBuild::spilledStats()
+    const {
+  if (!spilled_) {
+    return std::nullopt;
+  }
+  return {spillStats_->copy()};
+}
+
+void SubPartitionedSortWindowBuild::noMoreInput() {
+  if (numRows_ == 0) {
+    return;
+  }
+
+  if (spilled_) {
+    // Spill remaining data to avoid running out of memory while sort-merging
+    // spilled data.
+    spill();
+  }
+
+  switchToNextSubPartition();
+
+  VELOX_CHECK_EQ(currentSubPartition_, 0);
+}
+
+std::shared_ptr<WindowPartition>
+SubPartitionedSortWindowBuild::nextPartition() {
+  VELOX_CHECK_GE(currentSubPartition_, 0);
+  VELOX_CHECK_LT(currentSubPartition_, numSubPartitions_);
+  VELOX_CHECK_NOT_NULL(subWindowBuilds_[currentSubPartition_]);
+  return subWindowBuilds_[currentSubPartition_]->nextPartition();
+}
+
+std::optional<int64_t> SubPartitionedSortWindowBuild::estimateRowSize() {
+  auto subPartition = std::max(currentSubPartition_, 0);
+  if (subPartition >= numSubPartitions_) {
+    return std::nullopt;
+  }
+
+  if (subWindowBuilds_[subPartition]) {
+    return subWindowBuilds_[subPartition]->estimateRowSize();
+  }
+
+  return std::nullopt;
+}
+
+bool SubPartitionedSortWindowBuild::hasNextPartition() {
+  // Check if the build hasn't begun or has finished.
+  if (currentSubPartition_ < 0 || currentSubPartition_ >= numSubPartitions_) {
+    return false;
+  }
+
+  VELOX_CHECK_NOT_NULL(subWindowBuilds_[currentSubPartition_]);
+  if (subWindowBuilds_[currentSubPartition_]->hasNextPartition()) {
+    return true;
+  }
+
+  if (switchToNextSubPartition()) {
+    return hasNextPartition();
+  }
+  return false;
+}
+} // namespace facebook::velox::exec
diff --git a/velox/exec/SubPartitionedSortWindowBuild.h b/velox/exec/SubPartitionedSortWindowBuild.h
new file mode 100644
index 000000000000..667db5e2d70b
--- /dev/null
+++ b/velox/exec/SubPartitionedSortWindowBuild.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/exec/HashPartitionFunction.h"
+#include "velox/exec/PrefixSort.h"
+#include "velox/exec/SortWindowBuild.h"
+#include "velox/exec/Spiller.h"
+
+namespace facebook::velox::exec {
+// Divides the input data into several sub partitions by partition keys, then
+// sequentially sorts input data of each sub partition by {partition keys, sort
+// keys} to identify window partitions with SortWindowBuild. As each sub
+// partition has a smaller working set, the memory used by sorting is reduced.
+// Besides, once a sub partition is completely consumed, its memory could be
+// released immediately.
+class SubPartitionedSortWindowBuild : public WindowBuild {
+ public:
+  SubPartitionedSortWindowBuild(
+      const std::shared_ptr<const core::WindowNode>& node,
+      int32_t numSubPartitions,
+      velox::memory::MemoryPool* pool,
+      common::PrefixSortConfig&& prefixSortConfig,
+      const common::SpillConfig* spillConfig,
+      tsan_atomic<bool>* nonReclaimableSection,
+      folly::Synchronized<OperatorStats>* opStats,
+      folly::Synchronized<common::SpillStats>* spillStats);
+
+  ~SubPartitionedSortWindowBuild() override {
+    pool_->release();
+  }
+
+  bool needsInput() override {
+    // No sub partitions are available yet, so can consume input rows.
+    return currentSubPartition_ < 0;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  void spill() override;
+
+  std::optional<common::SpillStats> spilledStats() const override;
+
+  void noMoreInput() override;
+
+  bool hasNextPartition() override;
+
+  std::shared_ptr<WindowPartition> nextPartition() override;
+
+  std::optional<int64_t> estimateRowSize() override;
+
+ private:
+  // The current sub partition's WindowBuild has finished producing all the
+  // data. Release all the memory of current sub partition's WindowBuild, and
+  // then switch to next sub partition's WindowBuild as the new current one.
+  bool switchToNextSubPartition();
+
+  void ensureInputFits(const RowVectorPtr& input);
+
+  const int32_t numSubPartitions_;
+
+  const size_t numPartitionKeys_;
+
+  memory::MemoryPool* const pool_;
+
+  folly::Synchronized<common::SpillStats>* const spillStats_;
+
+  // Divide input rows to the corresponding sub partitions.
+  std::unique_ptr<HashPartitionFunction> subPartitioningFunction_;
+
+  // WindowBuilds for each sub partition.
+  std::vector<std::unique_ptr<SortWindowBuild>> subWindowBuilds_;
+
+  bool spilled_{false};
+
+  // Buffers the subPartitionIds for each row. Reused across addInput calls.
+  std::vector<uint32_t> subPartitionIdsBuffer_;
+
+  int32_t currentSubPartition_ = -1;
+};
+} // namespace facebook::velox::exec
diff --git a/velox/exec/TableScan.cpp b/velox/exec/TableScan.cpp
index e5f4c6f76e8a..6c19c1b89510 100644
--- a/velox/exec/TableScan.cpp
+++ b/velox/exec/TableScan.cpp
@@ -17,13 +17,56 @@
 #include "velox/common/testutil/TestValue.h"
 #include "velox/common/time/Timer.h"
 #include "velox/exec/Task.h"
-#include "velox/exec/TraceUtil.h"
-#include "velox/expression/Expr.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
 
+namespace {
+
+std::unique_ptr<connector::DataSource> createDataSource(
+    folly::Synchronized<PushdownFilters>& pushdownFilters,
+    connector::Connector& connector,
+    const RowTypePtr& outputType,
+    const connector::ConnectorTableHandlePtr& tableHandle,
+    const connector::ColumnHandleMap& columnHandles,
+    connector::ConnectorQueryCtx* connectorQueryCtx) {
+  auto dataSource = connector.createDataSource(
+      outputType, tableHandle, columnHandles, connectorQueryCtx);
+  auto* staticFilters = dataSource->getFilters();
+  if (!staticFilters) {
+    VELOX_CHECK(!connector.canAddDynamicFilter());
+    return dataSource;
+  }
+  {
+    auto lk = pushdownFilters.rlock();
+    if (lk->staticFiltersInitialized) {
+      for (auto outIndex : lk->dynamicFilteredColumns) {
+        dataSource->addDynamicFilter(outIndex, lk->filters.at(outIndex));
+      }
+      return dataSource;
+    }
+  }
+  auto lk = pushdownFilters.wlock();
+  if (!lk->staticFiltersInitialized) {
+    for (column_index_t i = 0, size = outputType->size(); i < size; ++i) {
+      auto handle = columnHandles.find(outputType->nameOf(i));
+      VELOX_CHECK(handle != columnHandles.end());
+      auto field = common::Subfield::create(handle->second->name());
+      if (auto it = staticFilters->find(*field); it != staticFilters->end()) {
+        common::Filter::merge(it->second, lk->filters[i]);
+      }
+    }
+    lk->staticFiltersInitialized = true;
+  }
+  for (auto outIndex : lk->dynamicFilteredColumns) {
+    dataSource->addDynamicFilter(outIndex, lk->filters.at(outIndex));
+  }
+  return dataSource;
+}
+
+} // namespace
+
 TableScan::TableScan(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -55,6 +98,11 @@ TableScan::TableScan(
   readBatchSize_ = driverCtx_->queryConfig().preferredOutputBatchRows();
 }
 
+void TableScan::initialize() {
+  SourceOperator::initialize();
+  VELOX_CHECK_EQ(driverCtx_->driver->operatorIndex(this), 0);
+}
+
 bool TableScan::shouldYield(StopReason taskStopReason, size_t startTimeMs)
     const {
   // Checks task-level yield signal, driver-level yield signal and table scan
@@ -132,15 +180,16 @@ RowVectorPtr TableScan::getOutput() {
         }
         continue;
       }
-      const auto estimatedRowSize = dataSource_->estimatedRowSize();
-      readBatchSize_ =
-          estimatedRowSize == connector::DataSource::kUnknownRowSize
-          ? outputBatchRows()
-          : outputBatchRows(estimatedRowSize);
     }
     VELOX_CHECK(!needNewSplit_);
     VELOX_CHECK(!hasDrained());
 
+    const auto estimatedRowSize = dataSource_->estimatedRowSize();
+    // TODO: Expose this to operator stats.
+    VLOG(1) << "estimatedRowSize = " << estimatedRowSize;
+    readBatchSize_ = estimatedRowSize == connector::DataSource::kUnknownRowSize
+        ? outputBatchRows()
+        : outputBatchRows(estimatedRowSize);
     int32_t readBatchSize = readBatchSize_;
     if (maxFilteringRatio_ > 0) {
       readBatchSize = std::min(
@@ -151,6 +200,7 @@ RowVectorPtr TableScan::getOutput() {
     std::optional<RowVectorPtr> dataOptional;
     {
       MicrosecondTimer timer(&ioTimeUs);
+      auto lk = driverCtx_->driver->pushdownFilters()->at(0).rlock();
       dataOptional = dataSource_->next(readBatchSize, blockingFuture_);
     }
 
@@ -174,20 +224,23 @@ RowVectorPtr TableScan::getOutput() {
       // at least read one batch from a split to trigger split fetch inside Meta
       // internal data source connector.
       if (data != nullptr && !shouldDropOutput()) {
+        constexpr int kMaxSelectiveBatchSizeMultiplier = 4;
         if (data->size() > 0) {
           lockedStats->addInputVector(data->estimateFlatSize(), data->size());
-          constexpr int kMaxSelectiveBatchSizeMultiplier = 4;
           maxFilteringRatio_ = std::max(
               {maxFilteringRatio_,
                1.0 * data->size() / readBatchSize,
                1.0 / kMaxSelectiveBatchSizeMultiplier});
           if (ioTimeUs > 0) {
-            RECORD_HISTOGRAM_METRIC_VALUE(
+            RECORD_METRIC_VALUE(
                 velox::kMetricTableScanBatchProcessTimeMs, ioTimeUs / 1'000);
           }
-          RECORD_HISTOGRAM_METRIC_VALUE(
+          RECORD_METRIC_VALUE(
               velox::kMetricTableScanBatchBytes, data->estimateFlatSize());
           return data;
+        } else {
+          maxFilteringRatio_ = std::max(
+              maxFilteringRatio_, 1.0 / kMaxSelectiveBatchSizeMultiplier);
         }
         continue;
       }
@@ -250,17 +303,16 @@ bool TableScan::getSplit() {
 
   if (!split.hasConnectorSplit()) {
     noMoreSplits_ = true;
-    dynamicFilters_.clear();
     if (dataSource_) {
-      const auto connectorStats = dataSource_->runtimeStats();
+      const auto connectorStats = dataSource_->getRuntimeStats();
       auto lockedStats = stats_.wlock();
-      for (const auto& [name, counter] : connectorStats) {
+      for (const auto& [name, metric] : connectorStats) {
         if (FOLLY_UNLIKELY(lockedStats->runtimeStats.count(name) == 0)) {
-          lockedStats->runtimeStats.emplace(name, RuntimeMetric(counter.unit));
+          lockedStats->runtimeStats.emplace(name, RuntimeMetric(metric.unit));
         } else {
-          VELOX_CHECK_EQ(lockedStats->runtimeStats.at(name).unit, counter.unit);
+          VELOX_CHECK_EQ(lockedStats->runtimeStats.at(name).unit, metric.unit);
         }
-        lockedStats->runtimeStats.at(name).addValue(counter.value);
+        lockedStats->runtimeStats.at(name).merge(metric);
       }
     }
     return false;
@@ -269,6 +321,9 @@ bool TableScan::getSplit() {
   if (FOLLY_UNLIKELY(splitTracer_ != nullptr)) {
     splitTracer_->write(split);
   }
+
+  stats_.wlock()->addRuntimeStat(
+      "connectorSplitSize", RuntimeCounter(split.connectorSplit->size()));
   const auto& connectorSplit = split.connectorSplit;
   currentSplitWeight_ = connectorSplit->splitWeight;
   needNewSplit_ = false;
@@ -285,11 +340,13 @@ bool TableScan::getSplit() {
   if (dataSource_ == nullptr) {
     connectorQueryCtx_ = operatorCtx_->createConnectorQueryCtx(
         connectorSplit->connectorId, planNodeId(), connectorPool_);
-    dataSource_ = connector_->createDataSource(
-        outputType_, tableHandle_, columnHandles_, connectorQueryCtx_.get());
-    for (const auto& entry : dynamicFilters_) {
-      dataSource_->addDynamicFilter(entry.first, entry.second);
-    }
+    dataSource_ = createDataSource(
+        driverCtx_->driver->pushdownFilters()->at(0),
+        *connector_,
+        outputType_,
+        tableHandle_,
+        columnHandles_,
+        connectorQueryCtx_.get());
   }
 
   debugString_ = fmt::format(
@@ -308,9 +365,17 @@ bool TableScan::getSplit() {
     // 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 startTimeNs = getCurrentTimeNano();
     auto preparedDataSource = connectorSplit->dataSource->move();
-    stats_.wlock()->getOutputTiming.add(
-        connectorSplit->dataSource->prepareTiming());
+    auto endTimeNs = getCurrentTimeNano();
+    stats_.wlock()->addRuntimeStat(
+        "waitForPreloadSplitNanos",
+        RuntimeCounter(endTimeNs - startTimeNs, RuntimeCounter::Unit::kNanos));
+    stats_.wlock()->addRuntimeStat(
+        "preloadSplitPrepareTimeNanos",
+        RuntimeCounter(
+            connectorSplit->dataSource->prepareTiming().wallNanos,
+            RuntimeCounter::Unit::kNanos));
     if (!preparedDataSource) {
       // There must be a cancellation.
       VELOX_CHECK(operatorCtx_->task()->isCancelled());
@@ -321,6 +386,7 @@ bool TableScan::getSplit() {
     uint64_t addSplitTimeUs{0};
     {
       MicrosecondTimer timer(&addSplitTimeUs);
+      auto lk = driverCtx_->driver->pushdownFilters()->at(0).rlock();
       dataSource_->addSplit(connectorSplit);
     }
     stats_.wlock()->addRuntimeStat(
@@ -369,7 +435,7 @@ void TableScan::preload(
        ctx = operatorCtx_->createConnectorQueryCtx(
            split->connectorId, planNodeId(), connectorPool_),
        task = operatorCtx_->task(),
-       dynamicFilters = dynamicFilters_,
+       pushdownFilters = driverCtx_->driver->pushdownFilters(),
        split]() -> std::unique_ptr<connector::DataSource> {
         if (task->isCancelled()) {
           return nullptr;
@@ -382,22 +448,27 @@ void TableScan::preload(
              },
              &debugString});
 
-        auto dataSource =
-            connector->createDataSource(type, table, columns, ctx.get());
+        auto dataSource = createDataSource(
+            pushdownFilters->at(0),
+            *connector,
+            type,
+            table,
+            columns,
+            ctx.get());
         if (task->isCancelled()) {
           return nullptr;
         }
-        for (const auto& entry : dynamicFilters) {
-          dataSource->addDynamicFilter(entry.first, entry.second);
+        {
+          auto lk = pushdownFilters->at(0).rlock();
+          dataSource->addSplit(split);
         }
-        dataSource->addSplit(split);
         return dataSource;
       });
 }
 
 void TableScan::checkPreload() {
-  auto* executor = connector_->executor();
-  if (maxSplitPreloadPerDriver_ == 0 || !executor ||
+  auto* ioExecutor = connector_->ioExecutor();
+  if (maxSplitPreloadPerDriver_ == 0 || !ioExecutor ||
       !connector_->supportsSplitPreload()) {
     return;
   }
@@ -406,11 +477,11 @@ void TableScan::checkPreload() {
         maxSplitPreloadPerDriver_;
     if (!splitPreloader_) {
       splitPreloader_ =
-          [executor,
+          [ioExecutor,
            this](const std::shared_ptr<connector::ConnectorSplit>& split) {
             preload(split);
 
-            executor->add([connectorSplit = split]() mutable {
+            ioExecutor->add([connectorSplit = split]() mutable {
               connectorSplit->dataSource->prepare();
               connectorSplit.reset();
             });
@@ -423,18 +494,13 @@ bool TableScan::isFinished() {
   return noMoreSplits_;
 }
 
-void TableScan::addDynamicFilter(
+void TableScan::addDynamicFilterLocked(
     const core::PlanNodeId& producer,
-    column_index_t outputChannel,
-    const std::shared_ptr<common::Filter>& filter) {
+    const PushdownFilters& filters) {
   if (dataSource_) {
-    dataSource_->addDynamicFilter(outputChannel, filter);
-  }
-  auto& currentFilter = dynamicFilters_[outputChannel];
-  if (currentFilter) {
-    currentFilter = currentFilter->mergeWith(filter.get());
-  } else {
-    currentFilter = filter;
+    for (auto channel : filters.dynamicFilteredColumns) {
+      dataSource_->addDynamicFilter(channel, filters.filters.at(channel));
+    }
   }
   stats_.wlock()->dynamicFilterStats.producerNodeIds.emplace(producer);
 }
diff --git a/velox/exec/TableScan.h b/velox/exec/TableScan.h
index daebdd85cd1e..69bff9ddc457 100644
--- a/velox/exec/TableScan.h
+++ b/velox/exec/TableScan.h
@@ -28,6 +28,8 @@ class TableScan : public SourceOperator {
       DriverCtx* driverCtx,
       const std::shared_ptr<const core::TableScanNode>& tableScanNode);
 
+  void initialize() override;
+
   RowVectorPtr getOutput() override;
 
   BlockingReason isBlocked(ContinueFuture* future) override {
@@ -50,10 +52,9 @@ class TableScan : public SourceOperator {
     return connector_->canAddDynamicFilter();
   }
 
-  void addDynamicFilter(
+  void addDynamicFilterLocked(
       const core::PlanNodeId& producer,
-      column_index_t outputChannel,
-      const std::shared_ptr<common::Filter>& filter) override;
+      const PushdownFilters& filters) override;
 
   /// The name of runtime stats specific to table scan.
   /// The number of running table scan drivers.
@@ -98,10 +99,8 @@ class TableScan : public SourceOperator {
   // processing or not.
   void tryScaleUp();
 
-  const std::shared_ptr<connector::ConnectorTableHandle> tableHandle_;
-  const std::
-      unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-          columnHandles_;
+  const connector::ConnectorTableHandlePtr tableHandle_;
+  const connector::ColumnHandleMap columnHandles_;
   DriverCtx* const driverCtx_;
   const int32_t maxSplitPreloadPerDriver_{0};
   const vector_size_t maxReadBatchSize_;
@@ -124,9 +123,6 @@ class TableScan : public SourceOperator {
   std::shared_ptr<connector::ConnectorQueryCtx> connectorQueryCtx_;
   std::unique_ptr<connector::DataSource> dataSource_;
   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>>
-      dynamicFilters_;
 
   int32_t maxPreloadedSplits_{0};
 
diff --git a/velox/exec/TableWriteMerge.cpp b/velox/exec/TableWriteMerge.cpp
index 69528e9338e3..cf64f84405ff 100644
--- a/velox/exec/TableWriteMerge.cpp
+++ b/velox/exec/TableWriteMerge.cpp
@@ -22,6 +22,7 @@
 
 namespace facebook::velox::exec {
 namespace {
+
 bool isSameCommitContext(
     const folly::dynamic& first,
     const folly::dynamic& second) {
@@ -44,6 +45,7 @@ bool containsNonNullRows(const VectorPtr& vector) {
   }
   return false;
 }
+
 } // namespace
 
 TableWriteMerge::TableWriteMerge(
@@ -56,18 +58,26 @@ TableWriteMerge::TableWriteMerge(
           operatorId,
           tableWriteMergeNode->id(),
           "TableWriteMerge") {
-  VELOX_USER_CHECK(outputType_->equivalent(
-      *TableWriteTraits::outputType(tableWriteMergeNode->aggregationNode())));
-  if (tableWriteMergeNode->aggregationNode() != nullptr) {
-    aggregation_ = std::make_unique<HashAggregation>(
-        operatorId, driverCtx, tableWriteMergeNode->aggregationNode());
+  if (tableWriteMergeNode->outputType()->size() == 1) {
+    VELOX_USER_CHECK(!tableWriteMergeNode->hasColumnStatsSpec());
+  } else {
+    VELOX_USER_CHECK(tableWriteMergeNode->outputType()->equivalent(*(
+        TableWriteTraits::outputType(tableWriteMergeNode->columnStatsSpec()))));
+  }
+  if (tableWriteMergeNode->hasColumnStatsSpec()) {
+    statsCollector_ = std::make_unique<ColumnStatsCollector>(
+        tableWriteMergeNode->columnStatsSpec().value(),
+        tableWriteMergeNode->sources()[0]->outputType(),
+        &operatorCtx_->driverCtx()->queryConfig(),
+        operatorCtx_->pool(),
+        &nonReclaimableSection_);
   }
 }
 
 void TableWriteMerge::initialize() {
   Operator::initialize();
-  if (aggregation_ != nullptr) {
-    aggregation_->initialize();
+  if (statsCollector_ != nullptr) {
+    statsCollector_->initialize();
   }
 }
 
@@ -76,8 +86,8 @@ void TableWriteMerge::addInput(RowVectorPtr input) {
   VELOX_CHECK_GT(input->size(), 0);
 
   if (isStatistics(input)) {
-    VELOX_CHECK_NOT_NULL(aggregation_);
-    aggregation_->addInput(input);
+    VELOX_CHECK_NOT_NULL(statsCollector_);
+    statsCollector_->addInput(input);
     return;
   }
 
@@ -105,10 +115,16 @@ void TableWriteMerge::addInput(RowVectorPtr input) {
 
 void TableWriteMerge::noMoreInput() {
   Operator::noMoreInput();
-  if (aggregation_ != nullptr) {
-    aggregation_->noMoreInput();
+  if (statsCollector_ != nullptr) {
+    statsCollector_->noMoreInput();
+  }
+}
+
+void TableWriteMerge::close() {
+  if (statsCollector_ != nullptr) {
+    statsCollector_->close();
   }
-  close();
+  Operator::close();
 }
 
 RowVectorPtr TableWriteMerge::getOutput() {
@@ -121,11 +137,11 @@ RowVectorPtr TableWriteMerge::getOutput() {
     return nullptr;
   }
 
-  if (aggregation_ != nullptr && !aggregation_->isFinished()) {
+  if (statsCollector_ != nullptr && !statsCollector_->finished()) {
     const std::string commitContext = createTableCommitContext(false);
     return TableWriteTraits::createAggregationStatsOutput(
         outputType_,
-        aggregation_->getOutput(),
+        statsCollector_->getOutput(),
         StringView(commitContext),
         pool());
   }
diff --git a/velox/exec/TableWriteMerge.h b/velox/exec/TableWriteMerge.h
index 9e915aa6574c..c5a0ade2ccdc 100644
--- a/velox/exec/TableWriteMerge.h
+++ b/velox/exec/TableWriteMerge.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include "velox/core/PlanNode.h"
+#include "velox/exec/ColumnStatsCollector.h"
 #include "velox/exec/Operator.h"
 
 namespace facebook::velox::exec {
@@ -51,6 +52,8 @@ class TableWriteMerge : public Operator {
     return finished_;
   }
 
+  void close() override;
+
  private:
   // Creates non-last output with fragments and last commit context only.
   RowVectorPtr createFragmentsOutput();
@@ -65,7 +68,7 @@ class TableWriteMerge : public Operator {
   // Check if the input is statistics input.
   bool isStatistics(RowVectorPtr input);
 
-  std::unique_ptr<Operator> aggregation_;
+  std::unique_ptr<ColumnStatsCollector> statsCollector_;
   bool finished_{false};
   // The sum of written rows.
   int64_t numRows_{0};
diff --git a/velox/exec/TableWriter.cpp b/velox/exec/TableWriter.cpp
index 6ce173412350..7a202a8c4869 100644
--- a/velox/exec/TableWriter.cpp
+++ b/velox/exec/TableWriter.cpp
@@ -15,8 +15,6 @@
  */
 
 #include "velox/exec/TableWriter.h"
-
-#include "HashAggregation.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
@@ -24,7 +22,7 @@ namespace facebook::velox::exec {
 TableWriter::TableWriter(
     int32_t operatorId,
     DriverCtx* driverCtx,
-    const std::shared_ptr<const core::TableWriteNode>& tableWriteNode)
+    const core::TableWriteNodePtr& tableWriteNode)
     : Operator(
           driverCtx,
           tableWriteNode->outputType(),
@@ -44,18 +42,22 @@ TableWriter::TableWriter(
       insertTableHandle_(
           tableWriteNode->insertTableHandle()->connectorInsertTableHandle()),
       commitStrategy_(tableWriteNode->commitStrategy()),
-      createTimeUs_(getCurrentTimeNano()) {
+      createTimeNs_(getCurrentTimeNano()) {
   setConnectorMemoryReclaimer();
   if (tableWriteNode->outputType()->size() == 1) {
-    VELOX_USER_CHECK_NULL(tableWriteNode->aggregationNode());
+    VELOX_USER_CHECK(!tableWriteNode->columnStatsSpec().has_value());
   } else {
     VELOX_USER_CHECK(tableWriteNode->outputType()->equivalent(
-        *(TableWriteTraits::outputType(tableWriteNode->aggregationNode()))));
+        *(TableWriteTraits::outputType(tableWriteNode->columnStatsSpec()))));
   }
 
-  if (tableWriteNode->aggregationNode() != nullptr) {
-    aggregation_ = std::make_unique<HashAggregation>(
-        operatorId, driverCtx, tableWriteNode->aggregationNode());
+  if (tableWriteNode->columnStatsSpec().has_value()) {
+    statsCollector_ = std::make_unique<ColumnStatsCollector>(
+        tableWriteNode->columnStatsSpec().value(),
+        tableWriteNode->sources()[0]->outputType(),
+        &operatorCtx_->driverCtx()->queryConfig(),
+        operatorCtx_->pool(),
+        &nonReclaimableSection_);
   }
   const auto& connectorId = tableWriteNode->insertTableHandle()->connectorId();
   connector_ = connector::getConnector(connectorId);
@@ -68,7 +70,7 @@ TableWriter::TableWriter(
 }
 
 void TableWriter::setTypeMappings(
-    const std::shared_ptr<const core::TableWriteNode>& tableWriteNode) {
+    const core::TableWriteNodePtr& tableWriteNode) {
   auto outputNames = tableWriteNode->columnNames();
   auto outputTypes = tableWriteNode->columns()->children();
 
@@ -95,8 +97,8 @@ void TableWriter::initialize() {
   Operator::initialize();
   VELOX_CHECK_NULL(dataSink_);
   createDataSink();
-  if (aggregation_ != nullptr) {
-    aggregation_->initialize();
+  if (statsCollector_ != nullptr) {
+    statsCollector_->initialize();
   }
 }
 
@@ -159,15 +161,15 @@ void TableWriter::addInput(RowVectorPtr input) {
   numWrittenRows_ += input->size();
   updateStats(dataSink_->stats());
 
-  if (aggregation_ != nullptr) {
-    aggregation_->addInput(input);
+  if (statsCollector_ != nullptr) {
+    statsCollector_->addInput(input);
   }
 }
 
 void TableWriter::noMoreInput() {
   Operator::noMoreInput();
-  if (aggregation_ != nullptr) {
-    aggregation_->noMoreInput();
+  if (statsCollector_ != nullptr) {
+    statsCollector_->noMoreInput();
   }
 }
 
@@ -185,11 +187,11 @@ RowVectorPtr TableWriter::getOutput() {
     return nullptr;
   }
 
-  if (aggregation_ != nullptr && !aggregation_->isFinished()) {
+  if (statsCollector_ != nullptr && !statsCollector_->finished()) {
     const std::string commitContext = createTableCommitContext(false);
     return TableWriteTraits::createAggregationStatsOutput(
         outputType_,
-        aggregation_->getOutput(),
+        statsCollector_->getOutput(),
         StringView(commitContext),
         pool());
   }
@@ -253,11 +255,12 @@ RowVectorPtr TableWriter::getOutput() {
       writtenRowsVector, fragmentsVector, commitContextVector};
 
   // 4. Set null statistics columns.
-  if (aggregation_ != nullptr) {
+  if (statsCollector_ != nullptr) {
     for (int i = TableWriteTraits::kStatsChannel; i < outputType_->size();
          ++i) {
-      columns.push_back(BaseVector::createNullConstant(
-          outputType_->childAt(i), writtenRowsVector->size(), pool()));
+      columns.push_back(
+          BaseVector::createNullConstant(
+              outputType_->childAt(i), writtenRowsVector->size(), pool()));
     }
   }
 
@@ -271,14 +274,14 @@ std::string TableWriter::createTableCommitContext(bool lastOutput) {
       folly::dynamic::object
           (TableWriteTraits::kLifeSpanContextKey, "TaskWide")
           (TableWriteTraits::kTaskIdContextKey, connectorQueryCtx_->taskId())
-          (TableWriteTraits::kCommitStrategyContextKey, commitStrategyToString(commitStrategy_))
+          (TableWriteTraits::kCommitStrategyContextKey, connector::CommitStrategyName::toName(commitStrategy_))
           (TableWriteTraits::klastPageContextKey, lastOutput));
   // clang-format on
 }
 
 void TableWriter::updateStats(const connector::DataSink::Stats& stats) {
   const auto currentTimeNs = getCurrentTimeNano();
-  VELOX_CHECK_GE(currentTimeNs, createTimeUs_);
+  VELOX_CHECK_GE(currentTimeNs, createTimeNs_);
   {
     auto lockedStats = stats_.wlock();
     lockedStats->physicalWrittenBytes = stats.numWrittenBytes;
@@ -312,10 +315,10 @@ void TableWriter::updateStats(const connector::DataSink::Stats& stats) {
     lockedStats->addRuntimeStat(
         kRunningWallNanos,
         RuntimeCounter(
-            currentTimeNs - createTimeUs_, RuntimeCounter::Unit::kNanos));
+            currentTimeNs - createTimeNs_, RuntimeCounter::Unit::kNanos));
   }
   if (!stats.spillStats.empty()) {
-    *spillStats_.wlock() += stats.spillStats;
+    *spillStats_->wlock() += stats.spillStats;
   }
 }
 
@@ -325,8 +328,8 @@ void TableWriter::close() {
     // regular close.
     abortDataSink();
   }
-  if (aggregation_ != nullptr) {
-    aggregation_->close();
+  if (statsCollector_ != nullptr) {
+    statsCollector_->close();
   }
   Operator::close();
 }
@@ -334,8 +337,9 @@ void TableWriter::close() {
 void TableWriter::setConnectorMemoryReclaimer() {
   VELOX_CHECK_NOT_NULL(connectorPool_);
   if (connectorPool_->parent()->reclaimer() != nullptr) {
-    connectorPool_->setReclaimer(TableWriter::ConnectorReclaimer::create(
-        spillConfig_, operatorCtx_->driverCtx(), this));
+    connectorPool_->setReclaimer(
+        TableWriter::ConnectorReclaimer::create(
+            spillConfig_, operatorCtx_->driverCtx(), this));
   }
 }
 
@@ -403,105 +407,4 @@ uint64_t TableWriter::ConnectorReclaimer::reclaim(
   return ParallelMemoryReclaimer::reclaim(pool, targetBytes, maxWaitMs, stats);
 }
 
-// static
-RowVectorPtr TableWriteTraits::createAggregationStatsOutput(
-    RowTypePtr outputType,
-    RowVectorPtr aggregationOutput,
-    StringView tableCommitContext,
-    velox::memory::MemoryPool* pool) {
-  // TODO: record aggregation stats output time.
-  if (aggregationOutput == nullptr) {
-    return nullptr;
-  }
-  VELOX_CHECK_GT(aggregationOutput->childrenSize(), 0);
-  const vector_size_t numOutputRows = aggregationOutput->childAt(0)->size();
-  std::vector<VectorPtr> columns;
-  for (int channel = 0; channel < outputType->size(); channel++) {
-    if (channel < TableWriteTraits::kContextChannel) {
-      // 1. Set null rows column.
-      // 2. Set null fragments column.
-      columns.push_back(BaseVector::createNullConstant(
-          outputType->childAt(channel), numOutputRows, pool));
-      continue;
-    }
-    if (channel == TableWriteTraits::kContextChannel) {
-      // 3. Set commitcontext column.
-      columns.push_back(std::make_shared<ConstantVector<StringView>>(
-          pool,
-          numOutputRows,
-          false /*isNull*/,
-          VARBINARY(),
-          std::move(tableCommitContext)));
-      continue;
-    }
-    // 4. Set statistics columns.
-    columns.push_back(
-        aggregationOutput->childAt(channel - TableWriteTraits::kStatsChannel));
-  }
-  return std::make_shared<RowVector>(
-      pool, outputType, nullptr, numOutputRows, columns);
-}
-
-std::string TableWriteTraits::rowCountColumnName() {
-  static const std::string kRowCountName = "rows";
-  return kRowCountName;
-}
-
-std::string TableWriteTraits::fragmentColumnName() {
-  static const std::string kFragmentName = "fragments";
-  return kFragmentName;
-}
-
-std::string TableWriteTraits::contextColumnName() {
-  static const std::string kContextName = "commitcontext";
-  return kContextName;
-}
-
-const TypePtr& TableWriteTraits::rowCountColumnType() {
-  static const TypePtr kRowCountType = BIGINT();
-  return kRowCountType;
-}
-
-const TypePtr& TableWriteTraits::fragmentColumnType() {
-  static const TypePtr kFragmentType = VARBINARY();
-  return kFragmentType;
-}
-
-const TypePtr& TableWriteTraits::contextColumnType() {
-  static const TypePtr kContextType = VARBINARY();
-  return kContextType;
-}
-
-const RowTypePtr TableWriteTraits::outputType(
-    const std::shared_ptr<core::AggregationNode>& aggregationNode) {
-  static const auto kOutputTypeWithoutStats =
-      ROW({rowCountColumnName(), fragmentColumnName(), contextColumnName()},
-          {rowCountColumnType(), fragmentColumnType(), contextColumnType()});
-  if (aggregationNode == nullptr) {
-    return kOutputTypeWithoutStats;
-  }
-  return kOutputTypeWithoutStats->unionWith(aggregationNode->outputType());
-}
-
-folly::dynamic TableWriteTraits::getTableCommitContext(
-    const RowVectorPtr& input) {
-  VELOX_CHECK_GT(input->size(), 0);
-  auto* contextVector =
-      input->childAt(kContextChannel)->as<SimpleVector<StringView>>();
-  return folly::parseJson(contextVector->valueAt(input->size() - 1));
-}
-
-int64_t TableWriteTraits::getRowCount(const RowVectorPtr& output) {
-  VELOX_CHECK_GT(output->size(), 0);
-  auto rowCountVector =
-      output->childAt(kRowCountChannel)->asFlatVector<int64_t>();
-  VELOX_CHECK_NOT_NULL(rowCountVector);
-  int64_t rowCount{0};
-  for (int i = 0; i < output->size(); ++i) {
-    if (!rowCountVector->isNullAt(i)) {
-      rowCount += rowCountVector->valueAt(i);
-    }
-  }
-  return rowCount;
-}
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TableWriter.h b/velox/exec/TableWriter.h
index 70505cb3fb5e..4692faec3129 100644
--- a/velox/exec/TableWriter.h
+++ b/velox/exec/TableWriter.h
@@ -16,93 +16,20 @@
 
 #pragma once
 
-#include "OperatorUtils.h"
 #include "velox/core/PlanNode.h"
+#include "velox/core/TableWriteTraits.h"
+#include "velox/exec/ColumnStatsCollector.h"
 #include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/Operator.h"
 
 namespace facebook::velox::exec {
 
-/// Defines table writer output related config properties that are shared
-/// between TableWriter and TableWriteMerger.
-///
-/// TODO: the table write output processing is Prestissimo specific. Consider
-/// move these part logic to Prestissimo and pass to Velox through a customized
-/// output processing callback.
-class TableWriteTraits {
- public:
-  /// Defines the column names/types in table write output.
-  static std::string rowCountColumnName();
-  static std::string fragmentColumnName();
-  static std::string contextColumnName();
-
-  static const TypePtr& rowCountColumnType();
-  static const TypePtr& fragmentColumnType();
-  static const TypePtr& contextColumnType();
-
-  /// Defines the column channels in table write output.
-  /// Both the statistics and the row_count + fragments are transferred over the
-  /// same communication link between the TableWriter and TableFinish. Thus the
-  /// multiplexing is needed.
-  ///
-  ///  The transferred page layout looks like:
-  /// [row_count_channel], [fragment_channel], [context_channel],
-  /// [statistic_channel_1] ... [statistic_channel_N]]
-  ///
-  /// [row_count_channel] - contains number of rows processed by a TableWriter
-  /// [fragment_channel] - contains data provided by the DataSink#finish
-  /// [statistic_channel_1] ...[statistic_channel_N] -
-  /// contain aggregated statistics computed by the statistics aggregation
-  /// within the TableWriter
-  ///
-  /// For convenience, we never set both: [row_count_channel] +
-  /// [fragment_channel] and the [statistic_channel_1] ...
-  /// [statistic_channel_N].
-  ///
-  /// If this is a row that holds statistics - the [row_count_channel] +
-  /// [fragment_channel] will be NULL.
-  ///
-  /// If this is a row that holds the row count
-  /// or the fragment - all the statistics channels will be set to NULL.
-  static constexpr int32_t kRowCountChannel = 0;
-  static constexpr int32_t kFragmentChannel = 1;
-  static constexpr int32_t kContextChannel = 2;
-  static constexpr int32_t kStatsChannel = 3;
-
-  /// Defines the names of metadata in commit context in table writer output.
-  static constexpr std::string_view kLifeSpanContextKey = "lifespan";
-  static constexpr std::string_view kTaskIdContextKey = "taskId";
-  static constexpr std::string_view kCommitStrategyContextKey =
-      "pageSinkCommitStrategy";
-  static constexpr std::string_view klastPageContextKey = "lastPage";
-
-  static const RowTypePtr outputType(
-      const std::shared_ptr<core::AggregationNode>& aggregationNode = nullptr);
-
-  /// Returns the parsed commit context from table writer 'output'.
-  static folly::dynamic getTableCommitContext(const RowVectorPtr& output);
-
-  /// Returns the sum of row counts from table writer 'output'.
-  static int64_t getRowCount(const RowVectorPtr& output);
-
-  /// Creates the statistics output.
-  /// Statistics page layout (aggregate by partition):
-  /// row     fragments     context     [partition]   stats1     stats2 ...
-  /// null       null          X          [X]            X          X
-  /// null       null          X          [X]            X          X
-  static RowVectorPtr createAggregationStatsOutput(
-      RowTypePtr outputType,
-      RowVectorPtr aggregationOutput,
-      StringView tableCommitContext,
-      velox::memory::MemoryPool* pool);
-};
-
 class TableWriter : public Operator {
  public:
   TableWriter(
       int32_t operatorId,
       DriverCtx* driverCtx,
-      const std::shared_ptr<const core::TableWriteNode>& tableWriteNode);
+      const core::TableWriteNodePtr& tableWriteNode);
 
   BlockingReason isBlocked(ContinueFuture* future) override;
 
@@ -137,6 +64,14 @@ class TableWriter : public Operator {
     // the table writer operator pool. So we report the memory usage from
     // 'connectorPool_'.
     stats.memoryStats = MemoryStats::memStatsFromPool(connectorPool_);
+
+    if (FOLLY_LIKELY(dataSink_ != nullptr)) {
+      const auto connectorStats = dataSink_->runtimeStats();
+      for (const auto& [name, counter] : connectorStats) {
+        stats.runtimeStats[name] = RuntimeMetric(counter.value, counter.unit);
+      }
+    }
+
     return stats;
   }
 
@@ -214,8 +149,7 @@ class TableWriter : public Operator {
 
   // Sets type mappings in `inputMapping_`, `mappedInputType_`, and
   // `mappedOutputType_`.
-  void setTypeMappings(
-      const std::shared_ptr<const core::TableWriteNode>& tableWriteNode);
+  void setTypeMappings(const core::TableWriteNodePtr& tableWriteNode);
 
   std::string createTableCommitContext(bool lastOutput);
 
@@ -223,15 +157,14 @@ class TableWriter : public Operator {
 
   const DriverCtx* const driverCtx_;
   memory::MemoryPool* const connectorPool_;
-  const std::shared_ptr<connector::ConnectorInsertTableHandle>
-      insertTableHandle_;
+  const connector::ConnectorInsertTableHandlePtr insertTableHandle_;
   const connector::CommitStrategy commitStrategy_;
   // Records the writer operator creation time in ns. This is used to record
-  // the running wall time of a writer operator. This can helps to detect the
+  // the running wall time of a writer operator. This can help to detect the
   // slow scaled writer scheduling in Prestissimo.
-  const uint64_t createTimeUs_{0};
+  const uint64_t createTimeNs_{0};
 
-  std::unique_ptr<Operator> aggregation_;
+  std::unique_ptr<ColumnStatsCollector> statsCollector_;
   std::shared_ptr<connector::Connector> connector_;
   std::shared_ptr<connector::ConnectorQueryCtx> connectorQueryCtx_;
   std::unique_ptr<connector::DataSink> dataSink_;
@@ -254,4 +187,10 @@ class TableWriter : public Operator {
   bool closed_{false};
   vector_size_t numWrittenRows_{0};
 };
+
+// TODO: TableWriteTraits got moved to velox/core as it pertains to plan
+// metadata, not execution. Maintaining the alias here in order not to break
+// backward compatibility.
+using core::TableWriteTraits;
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/Task.cpp b/velox/exec/Task.cpp
index 3e6b49019271..62f8a81390d1 100644
--- a/velox/exec/Task.cpp
+++ b/velox/exec/Task.cpp
@@ -1,3 +1,4 @@
+#include "velox/common/Casts.h"
 /*
  * Copyright (c) Facebook, Inc. and its affiliates.
  *
@@ -31,7 +32,10 @@
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/SpatialJoinBuild.h"
+#include "velox/exec/TableScan.h"
 #include "velox/exec/Task.h"
+#include "velox/exec/TaskTraceWriter.h"
 #include "velox/exec/TraceUtil.h"
 
 using facebook::velox::common::testutil::TestValue;
@@ -39,6 +43,7 @@ using facebook::velox::common::testutil::TestValue;
 namespace facebook::velox::exec {
 
 namespace {
+
 // RAII helper class to satisfy given promises and notify listeners of an event
 // connected to the promises outside of the mutex that guards the promises.
 // Inactive on creation. Must be activated explicitly by calling 'activate'.
@@ -55,7 +60,7 @@ class EventCompletionNotifier {
       std::vector<ContinuePromise> promises,
       std::function<void()> callback = nullptr) {
     active_ = true;
-    callback_ = callback;
+    callback_ = std::move(callback);
     promises_ = std::move(promises);
   }
 
@@ -89,6 +94,13 @@ folly::Synchronized<std::vector<std::shared_ptr<TaskListener>>>& listeners() {
   return kListeners;
 }
 
+folly::Synchronized<std::vector<std::shared_ptr<SplitListenerFactory>>>&
+splitListenerFactories() {
+  static folly::Synchronized<std::vector<std::shared_ptr<SplitListenerFactory>>>
+      kListenerFactories;
+  return kListenerFactories;
+}
+
 std::string errorMessageImpl(const std::exception_ptr& exception) {
   if (!exception) {
     return "";
@@ -164,20 +176,52 @@ 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;
+class QueueSplitsStore : public SplitsStore {
+ public:
+  using SplitsStore::SplitsStore;
+
+  void requestBarrier(std::vector<ContinuePromise>& promises) override {
+    addSplit(Split::createBarrier(), promises);
+  }
+
+  bool nextSplit(
+      Split& split,
+      ContinueFuture& future,
+      int maxPreloadSplits,
+      const ConnectorSplitPreloadFunc& preload) override {
+    if (!splits_.empty()) {
+      split = getSplit(maxPreloadSplits, preload);
+      return true;
+    }
+    if (noMoreSplits_) {
+      return true;
+    }
+    future = makeFuture();
+    return false;
+  }
+
+  bool allSplitsConsumed() const override {
+    return noMoreSplits_ && splits_.empty();
   }
+};
 
-  for (auto& promise : from) {
-    to.emplace_back(std::move(promise));
+void noMoreSplitsForStore(
+    SplitsStore* splitsStore,
+    std::vector<ContinuePromise>& promises) {
+  if (!splitsStore) {
+    return;
+  }
+  auto newPromises = splitsStore->noMoreSplits();
+  if (promises.empty()) {
+    promises.swap(newPromises);
+    return;
+  }
+  promises.reserve(promises.size() + newPromises.size());
+  for (auto& promise : newPromises) {
+    promises.push_back(std::move(promise));
   }
-  from.clear();
 }
+
 } // namespace
 
 std::string executionModeString(Task::ExecutionMode mode) {
@@ -239,6 +283,34 @@ bool unregisterTaskListener(const std::shared_ptr<TaskListener>& listener) {
   });
 }
 
+bool registerSplitListenerFactory(
+    const std::shared_ptr<SplitListenerFactory>& factory) {
+  return splitListenerFactories().withWLock([&](auto& factories) {
+    for (const auto& existingFactory : factories) {
+      if (existingFactory == factory) {
+        // Listener already registered. Do not register again.
+        return false;
+      }
+    }
+    factories.emplace_back(factory);
+    return true;
+  });
+}
+
+bool unregisterSplitListenerFactory(
+    const std::shared_ptr<SplitListenerFactory>& factory) {
+  return splitListenerFactories().withWLock([&](auto& factories) {
+    for (auto it = factories.begin(); it != factories.end(); ++it) {
+      if ((*it) == factory) {
+        factories.erase(it);
+        return true;
+      }
+    }
+    // Listener not found.
+    return false;
+  });
+}
+
 // static
 std::shared_ptr<Task> Task::create(
     const std::string& taskId,
@@ -248,8 +320,8 @@ std::shared_ptr<Task> Task::create(
     ExecutionMode mode,
     Consumer consumer,
     int32_t memoryArbitrationPriority,
+    std::optional<common::SpillDiskOptions> spillDiskOpts,
     std::function<void(std::exception_ptr)> onError) {
-  VELOX_CHECK_NOT_NULL(planFragment.planNode);
   return Task::create(
       taskId,
       std::move(planFragment),
@@ -259,6 +331,7 @@ std::shared_ptr<Task> Task::create(
       (consumer ? [c = std::move(consumer)]() { return c; }
                 : ConsumerSupplier{}),
       memoryArbitrationPriority,
+      std::move(spillDiskOpts),
       std::move(onError));
 }
 
@@ -271,6 +344,7 @@ std::shared_ptr<Task> Task::create(
     ExecutionMode mode,
     ConsumerSupplier consumerSupplier,
     int32_t memoryArbitrationPriority,
+    std::optional<common::SpillDiskOptions> spillDiskOpts,
     std::function<void(std::exception_ptr)> onError) {
   VELOX_CHECK_NOT_NULL(planFragment.planNode);
   auto task = std::shared_ptr<Task>(new Task(
@@ -282,7 +356,7 @@ std::shared_ptr<Task> Task::create(
       std::move(consumerSupplier),
       memoryArbitrationPriority,
       std::move(onError)));
-  task->initTaskPool();
+  task->init(std::move(spillDiskOpts));
   task->addToTaskList();
   return task;
 }
@@ -303,9 +377,8 @@ Task::Task(
       memoryArbitrationPriority_(memoryArbitrationPriority),
       queryCtx_(std::move(queryCtx)),
       planFragment_(std::move(planFragment)),
-      supportBarrier_(
-          (mode_ == Task::ExecutionMode::kSerial) &&
-          planFragment_.supportsBarrier()),
+      firstNodeNotSupportingBarrier_(
+          planFragment_.firstNodeNotSupportingBarrier()),
       traceConfig_(maybeMakeTraceConfig()),
       consumerSupplier_(std::move(consumerSupplier)),
       onError_(std::move(onError)),
@@ -319,6 +392,19 @@ Task::Task(
         dynamic_cast<const folly::InlineLikeExecutor*>(queryCtx_->executor()));
   }
   maybeInitTrace();
+
+  initSplitListeners();
+}
+
+void Task::initSplitListeners() {
+  splitListenerFactories().withRLock([&](const auto& factories) {
+    for (const auto& factory : factories) {
+      auto listener = factory->create(taskId_, uuid_, queryCtx_->queryConfig());
+      if (listener != nullptr) {
+        splitListeners_.emplace_back(std::move(listener));
+      }
+    }
+  });
 }
 
 Task::~Task() {
@@ -372,6 +458,85 @@ Task::~Task() {
   }
 }
 
+void Task::ensureBarrierSupport() const {
+  VELOX_CHECK_EQ(
+      mode_,
+      Task::ExecutionMode::kSerial,
+      "Task doesn't support barriered execution.");
+
+  VELOX_CHECK_NULL(
+      firstNodeNotSupportingBarrier_,
+      "Task doesn't support barriered execution. Name of the first node that "
+      "doesn't support barriered execution: {}",
+      firstNodeNotSupportingBarrier_->name());
+}
+
+void Task::init(std::optional<common::SpillDiskOptions>&& spillDiskOpts) {
+  VELOX_CHECK(driverFactories_.empty());
+  initTaskPool();
+
+  setSpillDiskConfig(std::move(spillDiskOpts));
+
+  if (mode_ != Task::ExecutionMode::kSerial) {
+    return;
+  }
+
+  // Create drivers.
+  VELOX_CHECK_NULL(
+      consumerSupplier_,
+      "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->supportsSerialExecution());
+    numDriversUngrouped_ += factory->numDrivers;
+    numTotalDrivers_ += factory->numTotalDrivers;
+    taskStats_.pipelineStats.emplace_back(
+        factory->inputDriver, factory->outputDriver);
+  }
+
+  // Create drivers.
+  createSplitGroupStateLocked(kUngroupedGroupId);
+  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());
+  }
+
+  drivers_ = std::move(drivers);
+  driverBlockingStates_.reserve(drivers_.size());
+  for (auto i = 0; i < drivers_.size(); ++i) {
+    driverBlockingStates_.emplace_back(
+        std::make_unique<DriverBlockingState>(drivers_[i].get()));
+  }
+}
+
+void Task::setSpillDiskConfig(
+    std::optional<common::SpillDiskOptions>&& spillDiskOpts) {
+  if (!spillDiskOpts.has_value()) {
+    return;
+  }
+  VELOX_CHECK(
+      !spillDiskOpts->spillDirPath.empty(), "Spill directory can't be empty");
+  VELOX_CHECK(
+      spillDiskOpts->spillDirCreated || spillDiskOpts->spillDirCreateCb);
+  VELOX_CHECK_NULL(spillDirectoryCallback_);
+  VELOX_CHECK(!spillDirectoryCreated_);
+  VELOX_CHECK(spillDirectory_.empty());
+  spillDirectory_ = std::move(spillDiskOpts->spillDirPath);
+  spillDirectoryCreated_ = spillDiskOpts->spillDirCreated;
+  spillDirectoryCallback_ = std::move(spillDiskOpts->spillDirCreateCb);
+}
+
 Task::TaskList& Task::taskList() {
   static TaskList taskList;
   return taskList;
@@ -450,7 +615,7 @@ bool Task::allNodesReceivedNoMoreSplitsMessageLocked() const {
 const std::string& Task::getOrCreateSpillDirectory() {
   VELOX_CHECK(
       !spillDirectory_.empty() || spillDirectoryCallback_,
-      "Spill directory or spill directory callback must be set ");
+      "Spill directory or spill directory callback must be set");
   if (spillDirectoryCreated_) {
     return spillDirectory_;
   }
@@ -584,8 +749,9 @@ velox::memory::MemoryPool* Task::addOperatorPool(
   } else {
     nodePool = getOrAddNodePool(planNodeId);
   }
-  childPools_.push_back(nodePool->addLeafChild(fmt::format(
-      "op.{}.{}.{}.{}", planNodeId, pipelineId, driverId, operatorType)));
+  childPools_.push_back(nodePool->addLeafChild(
+      fmt::format(
+          "op.{}.{}.{}.{}", planNodeId, pipelineId, driverId, operatorType)));
   return childPools_.back().get();
 }
 
@@ -596,13 +762,14 @@ velox::memory::MemoryPool* Task::addConnectorPoolLocked(
     const std::string& operatorType,
     const std::string& connectorId) {
   auto* nodePool = getOrAddNodePool(planNodeId);
-  childPools_.push_back(nodePool->addAggregateChild(fmt::format(
-      "op.{}.{}.{}.{}.{}",
-      planNodeId,
-      pipelineId,
-      driverId,
-      operatorType,
-      connectorId)));
+  childPools_.push_back(nodePool->addAggregateChild(
+      fmt::format(
+          "op.{}.{}.{}.{}.{}",
+          planNodeId,
+          pipelineId,
+          driverId,
+          operatorType,
+          connectorId)));
   return childPools_.back().get();
 }
 
@@ -672,48 +839,8 @@ RowVectorPtr Task::next(ContinueFuture* future) {
     }
   }
 
-  // On first call, create the drivers.
-  if (driverFactories_.empty()) {
-    VELOX_CHECK_NULL(
-        consumerSupplier_,
-        "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->supportsSerialExecution());
-      numDriversUngrouped_ += factory->numDrivers;
-      numTotalDrivers_ += factory->numTotalDrivers;
-      taskStats_.pipelineStats.emplace_back(
-          factory->inputDriver, factory->outputDriver);
-    }
-
-    // Create drivers.
-    createSplitGroupStateLocked(kUngroupedGroupId);
-    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());
-    }
-
-    drivers_ = std::move(drivers);
-    driverBlockingStates_.reserve(drivers_.size());
-    for (auto i = 0; i < drivers_.size(); ++i) {
-      driverBlockingStates_.emplace_back(
-          std::make_unique<DriverBlockingState>(drivers_[i].get()));
-    }
-    if (underBarrier()) {
-      startDriverBarriersLocked();
-    }
-  }
+  VELOX_CHECK_EQ(
+      state_, TaskState::kRunning, "Task has already finished processing.");
 
   // Run drivers one at a time. If a driver blocks, continue running the other
   // drivers. Running other drivers is expected to unblock some or all blocked
@@ -1164,6 +1291,8 @@ void Task::createSplitGroupStateLocked(uint32_t splitGroupId) {
     addHashJoinBridgesLocked(splitGroupId, factory->needsHashJoinBridges());
     addNestedLoopJoinBridgesLocked(
         splitGroupId, factory->needsNestedLoopJoinBridges());
+    addSpatialJoinBridgesLocked(
+        splitGroupId, factory->needsSpatialJoinBridges());
     addCustomJoinBridgesLocked(splitGroupId, factory->planNodes);
 
     core::PlanNodeId tableScanNodeId;
@@ -1196,6 +1325,7 @@ std::vector<std::shared_ptr<Driver>> Task::createDriversLocked(
     // execution, from the split group id.
     const uint32_t driverIdOffset =
         factory->numDrivers * (groupedExecutionDrivers ? splitGroupId : 0);
+    auto filters = std::make_shared<PipelinePushdownFilters>();
     for (uint32_t partitionId = 0; partitionId < factory->numDrivers;
          ++partitionId) {
       drivers.emplace_back(factory->createDriver(
@@ -1206,6 +1336,7 @@ std::vector<std::shared_ptr<Driver>> Task::createDriversLocked(
               splitGroupId,
               partitionId),
           getExchangeClientLocked(pipeline),
+          filters,
           [self](size_t i) {
             return i < self->driverFactories_.size()
                 ? self->driverFactories_[i]->numTotalDrivers
@@ -1358,14 +1489,23 @@ void Task::setMaxSplitSequenceId(
   }
 }
 
+void Task::onAddSplit(
+    const core::PlanNodeId& planNodeId,
+    const exec::Split& split) {
+  for (auto& listener : splitListeners_) {
+    listener->onAddSplit(planNodeId, split);
+  }
+}
+
 bool Task::addSplitWithSequence(
     const core::PlanNodeId& planNodeId,
     exec::Split&& split,
     long sequenceId) {
   RECORD_METRIC_VALUE(kMetricTaskSplitsCount, 1);
-  std::unique_ptr<ContinuePromise> promise;
+  std::vector<ContinuePromise> promises;
   bool added = false;
   bool isTaskRunning;
+  bool shouldLogSplit = false;
   {
     std::lock_guard<std::timed_mutex> l(mutex_);
     isTaskRunning = isRunningLocked();
@@ -1375,14 +1515,15 @@ bool Task::addSplitWithSequence(
       // duplicate splits would be ignored.
       auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
       if (sequenceId > splitsState.maxSequenceId) {
-        promise = addSplitLocked(splitsState, std::move(split));
+        shouldLogSplit = true;
+        addSplitLocked(splitsState, split, promises);
         added = true;
       }
     }
   }
 
-  if (promise) {
-    promise->setValue();
+  for (auto& promise : promises) {
+    promise.setValue();
   }
 
   if (!isTaskRunning) {
@@ -1391,24 +1532,29 @@ bool Task::addSplitWithSequence(
     addRemoteSplit(planNodeId, split);
   }
 
+  if (shouldLogSplit) {
+    onAddSplit(planNodeId, split);
+  }
+
   return added;
 }
 
 void Task::addSplit(const core::PlanNodeId& planNodeId, exec::Split&& split) {
   RECORD_METRIC_VALUE(kMetricTaskSplitsCount, 1);
   bool isTaskRunning;
-  std::unique_ptr<ContinuePromise> promise;
+  bool shouldLogSplit = false;
+  std::vector<ContinuePromise> promises;
   {
     std::lock_guard<std::timed_mutex> l(mutex_);
     isTaskRunning = isRunningLocked();
     if (isTaskRunning) {
-      promise = addSplitLocked(
-          getPlanNodeSplitsStateLocked(planNodeId), std::move(split));
+      shouldLogSplit = true;
+      addSplitLocked(getPlanNodeSplitsStateLocked(planNodeId), split, promises);
     }
   }
 
-  if (promise) {
-    promise->setValue();
+  for (auto& promise : promises) {
+    promise.setValue();
   }
 
   if (!isTaskRunning) {
@@ -1416,6 +1562,10 @@ void Task::addSplit(const core::PlanNodeId& planNodeId, exec::Split&& split) {
     // @lint-ignore CLANGTIDY bugprone-use-after-move
     addRemoteSplit(planNodeId, split);
   }
+
+  if (shouldLogSplit) {
+    onAddSplit(planNodeId, split);
+  }
 }
 
 void Task::addRemoteSplit(
@@ -1432,15 +1582,16 @@ void Task::addRemoteSplit(
   }
 }
 
-std::unique_ptr<ContinuePromise> Task::addSplitLocked(
+void Task::addSplitLocked(
     SplitsState& splitsState,
-    exec::Split&& split) {
+    const exec::Split& split,
+    std::vector<ContinuePromise>& promises) {
   if (split.isBarrier()) {
-    VELOX_CHECK(supportBarrier_);
+    ensureBarrierSupport();
     VELOX_CHECK(splitsState.sourceIsTableScan);
     VELOX_CHECK(!splitsState.noMoreSplits);
-    return addSplitToStoreLocked(
-        splitsState.groupSplitsStores[kUngroupedGroupId], std::move(split));
+    addSplitToStoreLocked(splitsState, kUngroupedGroupId, split, promises);
+    return;
   }
   VELOX_CHECK(
       !barrierRequested_, "Can't add new split under barrier processing");
@@ -1458,8 +1609,8 @@ std::unique_ptr<ContinuePromise> Task::addSplitLocked(
   }
 
   if (!split.hasGroup()) {
-    return addSplitToStoreLocked(
-        splitsState.groupSplitsStores[kUngroupedGroupId], std::move(split));
+    addSplitToStoreLocked(splitsState, kUngroupedGroupId, split, promises);
+    return;
   }
 
   const auto splitGroupId = split.groupId;
@@ -1471,21 +1622,27 @@ std::unique_ptr<ContinuePromise> Task::addSplitLocked(
     // We might have some free driver slots to process this split group.
     ensureSplitGroupsAreBeingProcessedLocked();
   }
-  return addSplitToStoreLocked(
-      splitsState.groupSplitsStores[splitGroupId], std::move(split));
+  addSplitToStoreLocked(splitsState, splitGroupId, split, promises);
 }
 
-std::unique_ptr<ContinuePromise> Task::addSplitToStoreLocked(
-    SplitsStore& splitsStore,
-    exec::Split&& split) {
-  splitsStore.splits.push_back(split);
-  if (splitsStore.splitPromises.empty()) {
-    return nullptr;
+void Task::addSplitToStoreLocked(
+    SplitsState& splitsState,
+    uint32_t groupId,
+    const exec::Split& split,
+    std::vector<ContinuePromise>& promises) {
+  auto& splitsStore = splitsState.groupSplitsStores[groupId];
+  if (!splitsStore) {
+    setSplitsStore(
+        splitsStore,
+        std::make_unique<QueueSplitsStore>(!splitsState.sourceIsTableScan));
+  }
+  if (split.isBarrier()) {
+    splitsStore->requestBarrier(promises);
+    return;
   }
-  auto promise = std::make_unique<ContinuePromise>(
-      std::move(splitsStore.splitPromises.back()));
-  splitsStore.splitPromises.pop_back();
-  return promise;
+  auto* queueSplitsStore =
+      checkedPointerCast<QueueSplitsStore>(splitsStore.get());
+  queueSplitsStore->addSplit(split, promises);
 }
 
 void Task::noMoreSplitsForGroup(
@@ -1497,9 +1654,8 @@ void Task::noMoreSplitsForGroup(
     std::lock_guard<std::timed_mutex> l(mutex_);
 
     auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
-    auto& splitsStore = splitsState.groupSplitsStores[splitGroupId];
-    splitsStore.noMoreSplits = true;
-    promises = std::move(splitsStore.splitPromises);
+    noMoreSplitsForStore(
+        splitsState.groupSplitsStores[splitGroupId].get(), promises);
 
     // There were no splits in this group, hence, no active drivers. Mark the
     // group complete.
@@ -1538,21 +1694,23 @@ void Task::noMoreSplits(const core::PlanNodeId& planNodeId) {
             "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);
+        noMoreSplitsForStore(it->second.get(), 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, {}});
+        auto queueSplitsStore =
+            std::make_unique<QueueSplitsStore>(!splitsState.sourceIsTableScan);
+        queueSplitsStore->noMoreSplits();
+        setSplitsStore(
+            splitsState.groupSplitsStores[kUngroupedGroupId],
+            std::move(queueSplitsStore));
       }
     } else {
       // Grouped execution branch.
       // Mark all split stores as 'no more splits'.
       for (auto& it : splitsState.groupSplitsStores) {
-        it.second.noMoreSplits = true;
-        movePromisesOut(it.second.splitPromises, splitPromises);
+        noMoreSplitsForStore(it.second.get(), splitPromises);
       }
     }
 
@@ -1576,17 +1734,35 @@ void Task::noMoreSplits(const core::PlanNodeId& planNodeId) {
   }
 }
 
+void Task::setSplitsStore(
+    const core::PlanNodeId& planNodeId,
+    std::unique_ptr<SplitsStore> newSplitsStore) {
+  std::lock_guard<std::timed_mutex> lk(mutex_);
+  auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
+  auto& splitsStore = splitsState.groupSplitsStores[kUngroupedGroupId];
+  VELOX_CHECK_NULL(splitsStore);
+  setSplitsStore(splitsStore, std::move(newSplitsStore));
+}
+
+void Task::setSplitsStore(
+    std::unique_ptr<SplitsStore>& splitsStore,
+    std::unique_ptr<SplitsStore> newSplitsStore) {
+  splitsStore = std::move(newSplitsStore);
+  splitsStore->setTaskStats(taskStats_);
+  splitsStore->setPreloadingSplits(preloadingSplits_);
+}
+
 ContinueFuture Task::requestBarrier() {
-  VELOX_CHECK(supportBarrier_, "Task doesn't support barrier");
+  ensureBarrierSupport();
   return startBarrier("Task::requestBarrier");
 }
 
 ContinueFuture Task::startBarrier(std::string_view comment) {
-  VELOX_CHECK(supportBarrier_);
-  std::vector<std::unique_ptr<ContinuePromise>> promises;
+  ensureBarrierSupport();
+  std::vector<ContinuePromise> promises;
   SCOPE_EXIT {
     for (auto& promise : promises) {
-      promise->setValue();
+      promise.setValue();
     }
   };
 
@@ -1595,7 +1771,7 @@ ContinueFuture Task::startBarrier(std::string_view comment) {
   auto [promise, future] =
       makeVeloxContinuePromiseContract(std::string{comment});
   if (!isRunningLocked()) {
-    promises.push_back(std::make_unique<ContinuePromise>(std::move(promise)));
+    promises.push_back(std::move(promise));
     return std::move(future);
   }
 
@@ -1620,10 +1796,7 @@ ContinueFuture Task::startBarrier(std::string_view comment) {
   for (const auto& leafPlanNode : leafPlanNodeIds) {
     auto barrierSplit = Split::createBarrier();
     auto& splitState = getPlanNodeSplitsStateLocked(leafPlanNode);
-    auto promise = addSplitLocked(splitState, std::move(barrierSplit));
-    if (promise != nullptr) {
-      promises.push_back(std::move(promise));
-    }
+    addSplitLocked(splitState, barrierSplit, promises);
   }
   startDriverBarriersLocked();
   return std::move(future);
@@ -1771,6 +1944,11 @@ bool Task::checkNoMoreSplitGroupsLocked() {
   return false;
 }
 
+bool Task::testingAllSplitsFinished() {
+  std::lock_guard<std::timed_mutex> l(mutex_);
+  return isAllSplitsFinishedLocked();
+}
+
 bool Task::isAllSplitsFinishedLocked() {
   return (taskStats_.numFinishedSplits == taskStats_.numTotalSplits) &&
       allNodesReceivedNoMoreSplitsMessageLocked();
@@ -1785,42 +1963,22 @@ BlockingReason Task::getSplitOrFuture(
     const ConnectorSplitPreloadFunc& preload) {
   std::lock_guard<std::timed_mutex> l(mutex_);
   auto& splitsState = getPlanNodeSplitsStateLocked(planNodeId);
-  return getSplitOrFutureLocked(
-      splitsState.sourceIsTableScan,
-      splitsState.groupSplitsStores[splitGroupId],
-      split,
-      future,
-      maxPreloadSplits,
-      preload);
-}
-
-BlockingReason Task::getSplitOrFutureLocked(
-    bool forTableScan,
-    SplitsStore& splitsStore,
-    exec::Split& split,
-    ContinueFuture& future,
-    int32_t maxPreloadSplits,
-    const ConnectorSplitPreloadFunc& preload) {
-  if (splitsStore.splits.empty()) {
-    if (splitsStore.noMoreSplits) {
-      return BlockingReason::kNotBlocked;
-    }
-    auto [splitPromise, splitFuture] = makeVeloxContinuePromiseContract(
-        fmt::format("Task::getSplitOrFuture {}", taskId_));
-    future = std::move(splitFuture);
-    splitsStore.splitPromises.push_back(std::move(splitPromise));
-    return BlockingReason::kWaitForSplit;
+  auto& splitsStore = splitsState.groupSplitsStores[splitGroupId];
+  if (!splitsStore) {
+    setSplitsStore(
+        splitsStore,
+        std::make_unique<QueueSplitsStore>(!splitsState.sourceIsTableScan));
   }
-
-  split = getSplitLocked(forTableScan, splitsStore, maxPreloadSplits, preload);
-  return BlockingReason::kNotBlocked;
+  return splitsStore->nextSplit(split, future, maxPreloadSplits, preload)
+      ? BlockingReason::kNotBlocked
+      : BlockingReason::kWaitForSplit;
 }
 
 bool Task::testingHasDriverWaitForSplit() const {
   std::lock_guard<std::timed_mutex> l(mutex_);
   for (const auto& splitState : splitsStates_) {
-    for (const auto& splitStore : splitState.second.groupSplitsStores) {
-      if (!splitStore.second.splitPromises.empty()) {
+    for (const auto& [_, splitStore] : splitState.second.groupSplitsStores) {
+      if (splitStore && splitStore->numWaiters() > 0) {
         return true;
       }
     }
@@ -1828,54 +1986,6 @@ bool Task::testingHasDriverWaitForSplit() const {
   return false;
 }
 
-exec::Split Task::getSplitLocked(
-    bool forTableScan,
-    SplitsStore& splitsStore,
-    int32_t maxPreloadSplits,
-    const ConnectorSplitPreloadFunc& preload) {
-  int32_t readySplitIndex = -1;
-  if (maxPreloadSplits > 0) {
-    for (auto i = 0; i < splitsStore.splits.size() && i < maxPreloadSplits;
-         ++i) {
-      if (splitsStore.splits[i].isBarrier()) {
-        continue;
-      }
-      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;
-  }
-  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;
-  }
-
-  return split;
-}
-
 std::shared_ptr<ScaledScanController> Task::getScaledScanControllerLocked(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
@@ -1915,9 +2025,6 @@ void Task::splitFinished(bool fromTableScan, int64_t splitWeight) {
     --taskStats_.numRunningTableScanSplits;
     taskStats_.runningTableScanSplitWeights -= splitWeight;
   }
-  if (isAllSplitsFinishedLocked()) {
-    taskStats_.executionEndTimeMs = getCurrentTimeMs();
-  }
 }
 
 void Task::multipleSplitsFinished(
@@ -1931,9 +2038,6 @@ void Task::multipleSplitsFinished(
     taskStats_.numRunningTableScanSplits -= numSplits;
     taskStats_.runningTableScanSplitWeights -= splitsWeight;
   }
-  if (isAllSplitsFinishedLocked()) {
-    taskStats_.executionEndTimeMs = getCurrentTimeMs();
-  }
 }
 
 bool Task::isGroupedExecution() const {
@@ -1983,7 +2087,7 @@ bool Task::allSplitsConsumedHelper(const core::PlanNode* planNode) const {
     VELOX_CHECK_NE(splitsStates_.count(planNodeId), 0);
     for (const auto& [_, splitsStore] :
          splitsStates_.at(planNodeId).groupSplitsStores) {
-      if (!splitsStore.splits.empty()) {
+      if (splitsStore && !splitsStore->allSplitsConsumed()) {
         return false;
       }
     }
@@ -2081,13 +2185,6 @@ bool Task::checkIfFinishedLocked() {
     if (splitGroupStates_[kUngroupedGroupId].numFinishedOutputDrivers ==
         numDrivers(outputPipelineId)) {
       allFinished = true;
-
-      if (taskStats_.executionEndTimeMs == 0) {
-        // In case we haven't set executionEndTimeMs due to all splits
-        // depleted, we set it here. This can happen due to task error or task
-        // being cancelled.
-        taskStats_.executionEndTimeMs = getCurrentTimeMs();
-      }
     }
   }
 
@@ -2220,6 +2317,20 @@ void Task::addNestedLoopJoinBridgesLocked(
   }
 }
 
+void Task::addSpatialJoinBridgesLocked(
+    uint32_t splitGroupId,
+    const std::vector<core::PlanNodeId>& planNodeIds) {
+  auto& splitGroupState = splitGroupStates_[splitGroupId];
+  for (const auto& planNodeId : planNodeIds) {
+    auto const inserted =
+        splitGroupState.bridges
+            .emplace(planNodeId, std::make_shared<SpatialJoinBridge>())
+            .second;
+    VELOX_CHECK(
+        inserted, "Join bridge for node {} is already present", planNodeId);
+  }
+}
+
 std::shared_ptr<HashJoinBridge> Task::getHashJoinBridge(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId) {
@@ -2239,6 +2350,12 @@ std::shared_ptr<NestedLoopJoinBridge> Task::getNestedLoopJoinBridge(
   return getJoinBridgeInternal<NestedLoopJoinBridge>(splitGroupId, planNodeId);
 }
 
+std::shared_ptr<SpatialJoinBridge> Task::getSpatialJoinBridge(
+    uint32_t splitGroupId,
+    const core::PlanNodeId& planNodeId) {
+  return getJoinBridgeInternal<SpatialJoinBridge>(splitGroupId, planNodeId);
+}
+
 template <class TBridgeType>
 std::shared_ptr<TBridgeType> Task::getJoinBridgeInternal(
     uint32_t splitGroupId,
@@ -2252,7 +2369,7 @@ template <class TBridgeType, typename MemberType>
 std::shared_ptr<TBridgeType> Task::getJoinBridgeInternalLocked(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId,
-    MemberType SplitGroupState::*bridges_member) {
+    MemberType SplitGroupState::* bridges_member) {
   const auto& splitGroupState = splitGroupStates_[splitGroupId];
 
   auto it = (splitGroupState.*bridges_member).find(planNodeId);
@@ -2335,9 +2452,9 @@ ContinueFuture Task::terminate(TaskState terminalState) {
       cancellationSource_.requestCancellation();
     }
 
-    LOG(INFO) << "Terminating task " << taskId() << " with state "
-              << taskStateString(state_) << " after running for "
-              << succinctMillis(timeSinceStartMsLocked());
+    VLOG(1) << "Terminating task " << taskId() << " with state "
+            << taskStateString(state_) << " after running for "
+            << succinctMillis(timeSinceStartMsLocked());
 
     taskCompletionNotifier.activate(
         std::move(taskCompletionPromises_), [&]() { onTaskCompletion(); });
@@ -2413,25 +2530,27 @@ ContinueFuture Task::terminate(TaskState terminalState) {
     }
 
     // Collect all outstanding split promises from all splits state structures.
-    for (auto& pair : splitsStates_) {
-      auto& splitState = pair.second;
-      for (auto& it : pair.second.groupSplitsStores) {
-        movePromisesOut(it.second.splitPromises, splitPromises);
+    for (auto& [nodeId, state] : splitsStates_) {
+      for (auto& [_, store] : state.groupSplitsStores) {
+        noMoreSplitsForStore(store.get(), splitPromises);
       }
 
       // Process remaining remote splits.
-      if (getExchangeClientLocked(pair.first) != nullptr) {
+      if (getExchangeClientLocked(nodeId) != nullptr) {
         std::vector<exec::Split> splits;
-        for (auto& [groupId, store] : splitState.groupSplitsStores) {
-          while (!store.splits.empty()) {
-            splits.emplace_back(getSplitLocked(
-                splitState.sourceIsTableScan, store, 0, nullptr));
+        for (auto& [groupId, store] : state.groupSplitsStores) {
+          if (!store) {
+            continue;
+          }
+          while (!store->allSplitsConsumed()) {
+            auto future = ContinueFuture::makeEmpty();
+            VELOX_CHECK(
+                store->nextSplit(splits.emplace_back(), future, 0, nullptr));
           }
         }
         if (!splits.empty()) {
           remainingRemoteSplits.emplace(
-              pair.first,
-              std::make_pair(std::move(splits), splitState.noMoreSplits));
+              nodeId, std::make_pair(std::move(splits), state.noMoreSplits));
         }
       }
     }
@@ -2691,6 +2810,10 @@ void Task::onTaskCompletion() {
           exchangeClientByPlanNode_);
     }
   });
+
+  for (auto& listener : splitListeners_) {
+    listener->onTaskCompletion();
+  }
 }
 
 ContinueFuture Task::stateChangeFuture(uint64_t maxWaitMicros) {
@@ -2850,8 +2973,9 @@ folly::dynamic Task::toJson() const {
 std::shared_ptr<MergeSource> Task::addLocalMergeSource(
     uint32_t splitGroupId,
     const core::PlanNodeId& planNodeId,
-    const RowTypePtr& rowType) {
-  auto source = MergeSource::createLocalMergeSource();
+    const RowTypePtr& rowType,
+    int queueSize) {
+  auto source = MergeSource::createLocalMergeSource(queueSize);
   splitGroupStates_[splitGroupId].localMergeSources[planNodeId].push_back(
       source);
   return source;
@@ -2912,8 +3036,9 @@ void Task::createLocalExchangeQueuesLocked(
       queryCtx_->queryConfig().maxLocalExchangeBufferSize());
   exchange.queues.reserve(numPartitions);
   for (auto i = 0; i < numPartitions; ++i) {
-    exchange.queues.emplace_back(std::make_shared<LocalExchangeQueue>(
-        exchange.memoryManager, exchange.vectorPool, i));
+    exchange.queues.emplace_back(
+        std::make_shared<LocalExchangeQueue>(
+            exchange.memoryManager, exchange.vectorPool, i));
   }
 
   const auto partitionNode =
@@ -3302,7 +3427,9 @@ void Task::createExchangeClientLocked(
       queryCtx()->queryConfig().minExchangeOutputBatchBytes(),
       addExchangeClientPool(planNodeId, pipelineId),
       queryCtx()->executor(),
-      queryCtx()->queryConfig().requestDataSizesMaxWaitSec());
+      queryCtx()->queryConfig().requestDataSizesMaxWaitSec(),
+      queryCtx()->queryConfig().singleSourceExchangeOptimizationEnabled(),
+      queryCtx()->queryConfig().exchangeLazyFetchingEnabled());
   exchangeClientByPlanNode_.emplace(planNodeId, exchangeClients_[pipelineId]);
 }
 
@@ -3339,40 +3466,23 @@ std::optional<TraceConfig> Task::maybeMakeTraceConfig() const {
     return std::nullopt;
   }
 
-  const auto traceNodes = queryConfig.queryTraceNodeIds();
-  VELOX_USER_CHECK(!traceNodes.empty(), "Query trace nodes are not set");
+  const auto traceNodeId = queryConfig.queryTraceNodeId();
+  VELOX_USER_CHECK(!traceNodeId.empty(), "Query trace node ID are not set");
 
   const auto traceDir = trace::getTaskTraceDirectory(
       queryConfig.queryTraceDir(), queryCtx_->queryId(), taskId_);
 
-  std::vector<std::string> traceNodeIds;
-  folly::split(',', traceNodes, traceNodeIds);
-  std::unordered_set<std::string> traceNodeIdSet(
-      traceNodeIds.begin(), traceNodeIds.end());
-  VELOX_USER_CHECK_EQ(
-      traceNodeIdSet.size(),
-      traceNodeIds.size(),
-      "Duplicate trace nodes found: {}",
-      folly::join(", ", traceNodeIds));
-
-  bool foundTraceNode{false};
-  for (const auto& traceNodeId : traceNodeIds) {
-    if (core::PlanNode::findFirstNode(
-            planFragment_.planNode.get(),
-            [traceNodeId](const core::PlanNode* node) -> bool {
-              return node->id() == traceNodeId;
-            })) {
-      foundTraceNode = true;
-      break;
-    }
-  }
-  VELOX_USER_CHECK(
-      foundTraceNode,
-      "Trace plan nodes not found from task {}: {}",
-      taskId_,
-      folly::join(",", traceNodeIdSet));
-
-  LOG(INFO) << "Trace input for plan nodes " << traceNodes << " from task "
+  VELOX_USER_CHECK_NOT_NULL(
+      core::PlanNode::findFirstNode(
+          planFragment_.planNode.get(),
+          [traceNodeId](const core::PlanNode* node) -> bool {
+            return node->id() == traceNodeId;
+          }),
+      "Trace plan node ID = {} not found from task {}",
+      traceNodeId,
+      taskId_);
+
+  LOG(INFO) << "Trace input for plan nodes " << traceNodeId << " from task "
             << taskId_;
 
   UpdateAndCheckTraceLimitCB updateAndCheckTraceLimitCB =
@@ -3380,10 +3490,11 @@ std::optional<TraceConfig> Task::maybeMakeTraceConfig() const {
         queryCtx_->updateTracedBytesAndCheckLimit(bytes);
       };
   return TraceConfig(
-      std::move(traceNodeIdSet),
+      traceNodeId,
       traceDir,
       std::move(updateAndCheckTraceLimitCB),
-      queryConfig.queryTraceTaskRegExp());
+      queryConfig.queryTraceTaskRegExp(),
+      queryConfig.queryTraceDryRun());
 }
 
 void Task::maybeInitTrace() {
@@ -3394,7 +3505,9 @@ void Task::maybeInitTrace() {
   trace::createTraceDirectory(traceConfig_->queryTraceDir);
   const auto metadataWriter = std::make_unique<trace::TaskTraceMetadataWriter>(
       traceConfig_->queryTraceDir, memory::traceMemoryPool());
-  metadataWriter->write(queryCtx_, planFragment_.planNode);
+  auto traceNode =
+      trace::getTraceNode(planFragment_.planNode, traceConfig_->queryNodeId);
+  metadataWriter->write(queryCtx_, traceNode);
 }
 
 void Task::testingVisitDrivers(const std::function<void(Driver*)>& callback) {
@@ -3605,8 +3718,8 @@ bool Task::DriverBlockingState::blocked(ContinueFuture* future) {
     VELOX_CHECK(promises_.empty());
     return false;
   }
-  auto [blockPromise, blockFuture] =
-      makeVeloxContinuePromiseContract(fmt::format(
+  auto [blockPromise, blockFuture] = makeVeloxContinuePromiseContract(
+      fmt::format(
           "DriverBlockingState {} from task {}",
           driver_->driverCtx()->driverId,
           driver_->task()->taskId()));
diff --git a/velox/exec/Task.h b/velox/exec/Task.h
index 9cbb73d98eff..72bc266d1028 100644
--- a/velox/exec/Task.h
+++ b/velox/exec/Task.h
@@ -15,6 +15,8 @@
  */
 #pragma once
 
+#include <folly/container/IntrusiveList.h>
+
 #include "velox/common/base/SkewedPartitionBalancer.h"
 #include "velox/common/base/TraceConfig.h"
 #include "velox/core/PlanFragment.h"
@@ -23,11 +25,9 @@
 #include "velox/exec/LocalPartition.h"
 #include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/MergeSource.h"
-#include "velox/exec/Split.h"
-#include "velox/exec/TableScan.h"
+#include "velox/exec/ScaledScanController.h"
 #include "velox/exec/TaskStats.h"
 #include "velox/exec/TaskStructs.h"
-#include "velox/exec/TaskTraceWriter.h"
 #include "velox/vector/ComplexVector.h"
 
 namespace facebook::velox::exec {
@@ -36,9 +36,8 @@ class OutputBufferManager;
 
 class HashJoinBridge;
 class NestedLoopJoinBridge;
-
-using ConnectorSplitPreloadFunc =
-    std::function<void(const std::shared_ptr<connector::ConnectorSplit>&)>;
+class SpatialJoinBridge;
+class SplitListener;
 
 class Task : public std::enable_shared_from_this<Task> {
  public:
@@ -69,11 +68,16 @@ class Task : public std::enable_shared_from_this<Task> {
   /// @param consumer Optional factory function to get callbacks to pass the
   /// results of the execution. In a parallel execution mode, results from each
   /// thread are passed on to a separate consumer.
+  /// @param memoryArbitrationPriority Priority used by the memory arbitrator
+  /// to determine which task should have its memory reclaimed first when the
+  /// system is under memory pressure. Higher values indicate higher priority
+  /// (lower likelihood of being reclaimed). Default is 0.
+  /// @param spillDiskOpts Optional configuration for spill disk storage. When
+  /// provided, allows operators to spill intermediate data to disk during
+  /// execution when memory pressure is high. Includes spill directory path
+  /// and callback options. Default is std::nullopt (no spilling).
   /// @param onError Optional callback to receive an exception if task
   /// execution fails.
-  /// @param memoryArbitrationPriority Optional priority on task that, in a
-  /// multi task system, is used for memory arbitration to decide the order of
-  /// reclaiming.
   static std::shared_ptr<Task> create(
       const std::string& taskId,
       core::PlanFragment planFragment,
@@ -82,6 +86,7 @@ class Task : public std::enable_shared_from_this<Task> {
       ExecutionMode mode,
       Consumer consumer = nullptr,
       int32_t memoryArbitrationPriority = 0,
+      std::optional<common::SpillDiskOptions> spillDiskOpts = std::nullopt,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
   static std::shared_ptr<Task> create(
@@ -92,6 +97,7 @@ class Task : public std::enable_shared_from_this<Task> {
       ExecutionMode mode,
       ConsumerSupplier consumerSupplier,
       int32_t memoryArbitrationPriority = 0,
+      std::optional<common::SpillDiskOptions> spillDiskOpts = std::nullopt,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
   /// Convenience function for shortening a Presto taskId. To be used
@@ -100,22 +106,6 @@ class Task : public std::enable_shared_from_this<Task> {
 
   ~Task();
 
-  /// Specify directory to which data will be spilled if spilling is enabled and
-  /// 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;
-  }
-
-  void setCreateSpillDirectoryCb(
-      std::function<std::string()> spillDirectoryCallback) {
-    VELOX_CHECK_NULL(spillDirectoryCallback_);
-    spillDirectoryCallback_ = std::move(spillDirectoryCallback);
-  }
-
   /// Returns human-friendly representation of the plan augmented with runtime
   /// statistics. The implementation invokes exec::printPlanWithStats().
   ///
@@ -271,6 +261,14 @@ class Task : public std::enable_shared_from_this<Task> {
   /// corresponding to plan node with specified ID.
   void noMoreSplits(const core::PlanNodeId& planNodeId);
 
+  /// Use a customized split store implementation to replace the default queue
+  /// split store for the specified node.  The customized split store should
+  /// have its own source of splits and no longer need addSplit() call from
+  /// the task.
+  void setSplitsStore(
+      const core::PlanNodeId& planNodeId,
+      std::unique_ptr<SplitsStore> splitsStore);
+
   /// Updates the total number of output buffers to broadcast or arbitrarily
   /// distribute the results of the execution to. Used when plan tree ends with
   /// a PartitionedOutputNode with broadcast of arbitrary output type.
@@ -465,7 +463,8 @@ class Task : public std::enable_shared_from_this<Task> {
   std::shared_ptr<MergeSource> addLocalMergeSource(
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId,
-      const RowTypePtr& rowType);
+      const RowTypePtr& rowType,
+      int queueSize);
 
   /// Returns all MergeSource's for the specified splitGroupId and planNodeId.
   const std::vector<std::shared_ptr<MergeSource>>& getLocalMergeSources(
@@ -514,7 +513,7 @@ class Task : public std::enable_shared_from_this<Task> {
   void setError(const std::string& message);
 
   /// Returns all the peer operators of the 'caller' operator from a given
-  /// 'pipelindId' in this task.
+  /// 'pipelineId' in this task.
   std::vector<Operator*> findPeerOperators(int pipelineId, Operator* caller);
 
   /// Synchronizes completion of an Operator across Drivers of 'this'.
@@ -555,6 +554,11 @@ class Task : public std::enable_shared_from_this<Task> {
       uint32_t splitGroupId,
       const std::vector<core::PlanNodeId>& planNodeIds);
 
+  /// Adds SpatialJoinBridge's for all the specified plan node IDs.
+  void addSpatialJoinBridgesLocked(
+      uint32_t splitGroupId,
+      const std::vector<core::PlanNodeId>& planNodeIds);
+
   /// Adds custom join bridges for all the specified plan nodes.
   void addCustomJoinBridgesLocked(
       uint32_t splitGroupId,
@@ -577,6 +581,11 @@ class Task : public std::enable_shared_from_this<Task> {
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId);
 
+  /// Returns a SpatialJoinBridge for 'planNodeId'.
+  std::shared_ptr<SpatialJoinBridge> getSpatialJoinBridge(
+      uint32_t splitGroupId,
+      const core::PlanNodeId& planNodeId);
+
   /// Returns a custom join bridge for 'planNodeId'.
   std::shared_ptr<JoinBridge> getCustomJoinBridge(
       uint32_t splitGroupId,
@@ -610,7 +619,7 @@ class Task : public std::enable_shared_from_this<Task> {
   StopReason enterForTerminateLocked(ThreadState& state);
 
   /// Marks that the Driver is not on thread. If no more Drivers in the
-  /// CancelPool are on thread, this realizes threadFinishFutures_. These allow
+  /// Task are on thread, this realizes threadFinishFutures_.
   /// syncing with pause or termination. The Driver may go off thread because of
   /// hasBlockingFuture or pause requested or terminate requested. The
   /// return value indicates the reason. If kTerminate is returned, the
@@ -669,10 +678,10 @@ class Task : public std::enable_shared_from_this<Task> {
 
   /// Invoked once by a driver thread to signal it has finished the barrier
   /// processing when all its operators have drained their output and the sink
-  /// operator has propogated the drain signal to all its downstream pipelines
+  /// operator has propagated the drain signal to all its downstream pipelines
   /// through the connected queues. Upon the last driver thread call, the task
   /// finishes the current barrier processing and 'barrierFinishPromises_' are
-  /// fullfiled to resume barrier request caller.
+  /// fulfilled to resume barrier request caller.
   void finishDriverBarrier();
 
   /// Requests the Task to stop activity.  The returned future is
@@ -777,6 +786,9 @@ class Task : public std::enable_shared_from_this<Task> {
   /// split.
   bool testingHasDriverWaitForSplit() const;
 
+  /// Returns true if all the splits have finished.
+  bool testingAllSplitsFinished();
+
  private:
   // Hook of system-wide running task list.
   struct TaskListEntry {
@@ -802,6 +814,13 @@ class Task : public std::enable_shared_from_this<Task> {
       int32_t memoryArbitrationPriority = 0,
       std::function<void(std::exception_ptr)> onError = nullptr);
 
+  // Invoked to do post-create initialization.
+  void init(std::optional<common::SpillDiskOptions>&& spillDiskOpts);
+
+  // Invoked to initialize the spill storage config for this task.
+  void setSpillDiskConfig(
+      std::optional<common::SpillDiskOptions>&& spillDiskOpts);
+
   // Invoked to add this to the system-wide running task list on task creation.
   void addToTaskList();
 
@@ -840,7 +859,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // message.
   bool allNodesReceivedNoMoreSplitsMessageLocked() const;
 
-  // Recursive helper for 'allSpilitsConsumed()' method.
+  // Recursive helper for 'allSplitsConsumed()' method.
   bool allSplitsConsumedHelper(const core::PlanNode* planNode) const;
 
   // Remove the spill directory, if the Task was creating it for potential
@@ -925,7 +944,7 @@ class Task : public std::enable_shared_from_this<Task> {
       VELOX_CHECK_NOT_NULL(task);
     }
 
-    // Gets the shared pointer to the driver to ensure its liveness during the
+    // Gets the shared pointer to the task to ensure its liveness during the
     // memory reclaim operation.
     //
     // NOTE: a task's memory pool might outlive the task itself.
@@ -957,7 +976,7 @@ class Task : public std::enable_shared_from_this<Task> {
   std::shared_ptr<TBridgeType> getJoinBridgeInternalLocked(
       uint32_t splitGroupId,
       const core::PlanNodeId& planNodeId,
-      MemberType SplitGroupState::*bridges_member);
+      MemberType SplitGroupState::* bridges_member);
 
   std::shared_ptr<JoinBridge> getCustomJoinBridgeInternal(
       uint32_t splitGroupId,
@@ -969,23 +988,6 @@ class Task : public std::enable_shared_from_this<Task> {
       const core::PlanNodeId& planNodeId,
       const exec::Split& split);
 
-  /// 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,
-      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,
-      const ConnectorSplitPreloadFunc& preload);
-
   // 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);
@@ -1015,17 +1017,26 @@ class Task : public std::enable_shared_from_this<Task> {
   // Notifies listeners that the task is now complete.
   void onTaskCompletion();
 
+  void onAddSplit(const core::PlanNodeId& planNodeId, const exec::Split& split);
+
   // Returns true if all splits are finished processing and there are no more
   // splits coming for the task.
   bool isAllSplitsFinishedLocked();
 
-  std::unique_ptr<ContinuePromise> addSplitLocked(
+  void addSplitLocked(
       SplitsState& splitsState,
-      exec::Split&& split);
+      const exec::Split& split,
+      std::vector<ContinuePromise>& promises);
 
-  std::unique_ptr<ContinuePromise> addSplitToStoreLocked(
-      SplitsStore& splitsStore,
-      exec::Split&& split);
+  void addSplitToStoreLocked(
+      SplitsState& splitsState,
+      uint32_t groupId,
+      const exec::Split& split,
+      std::vector<ContinuePromise>& promises);
+
+  void setSplitsStore(
+      std::unique_ptr<SplitsStore>& splitsStore,
+      std::unique_ptr<SplitsStore> newSplitsStore);
 
   // Invoked when all the driver threads are off thread. The function returns
   // 'threadFinishPromises_' to fulfill.
@@ -1120,6 +1131,13 @@ class Task : public std::enable_shared_from_this<Task> {
   void recordBatchStartTime();
   void recordBatchEndTime();
 
+  void initSplitListeners();
+
+  /// Checks if the task supports barrier processing. Barrier processing is
+  /// supported when the task is under single threaded execution mode and all
+  /// its plan nodes support barrier processing.
+  void ensureBarrierSupport() const;
+
   // Universally unique identifier of the task. Used to identify the task when
   // calling TaskListener.
   const std::string uuid_;
@@ -1142,10 +1160,10 @@ class Task : public std::enable_shared_from_this<Task> {
 
   core::PlanFragment planFragment_;
 
-  // Indicates if this task supports barrier processing. It is set to true if
-  // the task is under single threaded execution mode and all its plan nodes
-  // support barrier processing.
-  const bool supportBarrier_;
+  // First node in the plan fragment that does not support barrier processing.
+  // Barrier is supported when the task is under single threaded execution mode
+  // and all its plan nodes support barrier processing.
+  const core::PlanNode* firstNodeNotSupportingBarrier_{};
 
   const std::optional<TraceConfig> traceConfig_;
 
@@ -1158,7 +1176,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // to pool_ must be defined after pool_, childPools_.
   std::shared_ptr<memory::MemoryPool> pool_;
 
-  // Keep driver and operator memory pools alive for the duration of the task
+  // Keep plan node and operator memory pools alive for the duration of the task
   // to allow for sharing vectors across drivers without copy.
   std::vector<std::shared_ptr<memory::MemoryPool>> childPools_;
 
@@ -1197,7 +1215,7 @@ class Task : public std::enable_shared_from_this<Task> {
   ConsumerSupplier consumerSupplier_;
 
   // The function that is executed when the task encounters its first error,
-  // that is, serError() is called for the first time.
+  // that is, setError() is called for the first time.
   std::function<void(std::exception_ptr)> onError_;
 
   std::vector<std::unique_ptr<DriverFactory>> driverFactories_;
@@ -1359,7 +1377,7 @@ class Task : public std::enable_shared_from_this<Task> {
   // The promises for the futures returned to callers of requestBarrier().
   std::vector<ContinuePromise> barrierFinishPromises_;
 
-  std::atomic<int32_t> toYield_ = 0;
+  std::atomic_int32_t toYield_ = 0;
   int32_t numThreads_ = 0;
   // Microsecond real time when 'this' last went from no threads to
   // one thread running. Used to decide if continuous run should be
@@ -1391,6 +1409,8 @@ class Task : public std::enable_shared_from_this<Task> {
       preloadingSplits_;
 
   folly::CancellationSource cancellationSource_;
+
+  std::vector<std::unique_ptr<SplitListener>> splitListeners_;
 };
 
 /// Listener invoked on task completion.
@@ -1431,6 +1451,50 @@ bool registerTaskListener(std::shared_ptr<TaskListener> listener);
 /// unregistered successfuly, false if listener was not found.
 bool unregisterTaskListener(const std::shared_ptr<TaskListener>& listener);
 
+/// Listener invoked when splits are added to Task.
+class SplitListener {
+ public:
+  SplitListener(const std::string& taskId, const std::string& taskUuid)
+      : taskId_(taskId), taskUuid_(taskUuid) {}
+
+  virtual ~SplitListener() = default;
+
+  // Called when a split is added to a task for a given plan node.
+  virtual void onAddSplit(
+      const core::PlanNodeId& planNodeId,
+      const exec::Split& split) = 0;
+
+  /// Called on task completion. Provides the information about success or
+  /// failure as well as runtime statistics about task execution.
+  virtual void onTaskCompletion() = 0;
+
+ protected:
+  const std::string taskId_;
+  const std::string taskUuid_;
+};
+
+class SplitListenerFactory {
+ public:
+  virtual ~SplitListenerFactory() = default;
+
+  /// Create and return an std::unique_ptr<SplitListener> to be used by a Task
+  /// of the given taskId, taskUuid and config. The Task constructor calls this
+  /// method and holds the SplitListener. The SplitListener is destroyed when
+  /// the Task is destructed. This method can return a nullptr, e.g., if taskId
+  /// doesn't satisfy certain criteria or if config.maxNumSplitsListenedTo() is
+  /// 0. In this situation, the Task doesn't hold this SplitListener.
+  virtual std::unique_ptr<SplitListener> create(
+      const std::string& taskId,
+      const std::string& taskUuid,
+      const core::QueryConfig& config) = 0;
+};
+
+bool registerSplitListenerFactory(
+    const std::shared_ptr<SplitListenerFactory>& factory);
+
+bool unregisterSplitListenerFactory(
+    const std::shared_ptr<SplitListenerFactory>& factory);
+
 std::string executionModeString(Task::ExecutionMode mode);
 
 std::ostream& operator<<(std::ostream& out, Task::ExecutionMode mode);
diff --git a/velox/exec/TaskStats.h b/velox/exec/TaskStats.h
index fe8289770f58..2bef2a894e41 100644
--- a/velox/exec/TaskStats.h
+++ b/velox/exec/TaskStats.h
@@ -20,7 +20,9 @@
 #include <unordered_set>
 #include <vector>
 
-#include "velox/exec/Driver.h"
+#include "velox/exec/BlockingReason.h"
+#include "velox/exec/DriverStats.h"
+#include "velox/exec/OperatorStats.h"
 #include "velox/exec/OutputBuffer.h"
 
 namespace facebook::velox::exec {
diff --git a/velox/exec/TaskStructs.cpp b/velox/exec/TaskStructs.cpp
new file mode 100644
index 000000000000..21786166125c
--- /dev/null
+++ b/velox/exec/TaskStructs.cpp
@@ -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.
+ */
+
+#include "velox/exec/TaskStructs.h"
+
+namespace facebook::velox::exec {
+
+void SplitsStore::addSplit(
+    Split split,
+    std::vector<ContinuePromise>& promises) {
+  VELOX_CHECK(!noMoreSplits_);
+  VELOX_CHECK(!(remoteSplit_ && split.isBarrier()));
+  splits_.push_back(std::move(split));
+  if (promises_.empty()) {
+    return;
+  }
+  promises.push_back(std::move(promises_.back()));
+  promises_.pop_back();
+}
+
+ContinueFuture SplitsStore::makeFuture() {
+  auto [promise, future] =
+      makeVeloxContinuePromiseContract("SplitsStore::makeFuture");
+  promises_.push_back(std::move(promise));
+  return std::move(future);
+}
+
+Split SplitsStore::getSplit(
+    int maxPreloadSplits,
+    const ConnectorSplitPreloadFunc& preload) {
+  int readySplitIndex = -1;
+  if (maxPreloadSplits > 0) {
+    for (int i = 0, end = std::min<size_t>(maxPreloadSplits, splits_.size());
+         i < end;
+         ++i) {
+      if (splits_[i].isBarrier()) {
+        VELOX_CHECK(!remoteSplit_);
+        continue;
+      }
+      auto& connectorSplit = splits_[i].connectorSplit;
+      if (!connectorSplit->dataSource) {
+        // Initializes split->dataSource.
+        preload(connectorSplit);
+        preloadingSplits_->insert(connectorSplit);
+      } else if (
+          readySplitIndex == -1 && connectorSplit->dataSource->hasValue()) {
+        readySplitIndex = i;
+        preloadingSplits_->erase(connectorSplit);
+      }
+    }
+  }
+  if (readySplitIndex == -1) {
+    readySplitIndex = 0;
+  }
+  VELOX_CHECK(!splits_.empty());
+  auto split = std::move(splits_[readySplitIndex]);
+  splits_.erase(splits_.begin() + readySplitIndex);
+  --taskStats_->numQueuedSplits;
+  ++taskStats_->numRunningSplits;
+  if (!remoteSplit_ && 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;
+  }
+  return split;
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/TaskStructs.h b/velox/exec/TaskStructs.h
index bf3418a3f25b..ba99890d3a0c 100644
--- a/velox/exec/TaskStructs.h
+++ b/velox/exec/TaskStructs.h
@@ -14,7 +14,21 @@
  * limitations under the License.
  */
 #pragma once
+
+#include "velox/common/base/SkewedPartitionBalancer.h"
+#include "velox/common/future/VeloxPromise.h"
+#include "velox/connectors/Connector.h"
+#include "velox/exec/LocalPartition.h"
+#include "velox/exec/ScaledScanController.h"
+#include "velox/exec/Split.h"
+#include "velox/exec/TaskStats.h"
+
+#include <folly/CPortability.h>
+
 #include <limits>
+#include <memory>
+#include <ostream>
+#include <string>
 #include <unordered_set>
 #include <vector>
 
@@ -25,7 +39,6 @@ class JoinBridge;
 class LocalExchangeMemoryManager;
 class MergeSource;
 class MergeJoinSource;
-struct Split;
 
 /// Corresponds to Presto TaskState, needed for reporting query completion.
 enum class TaskState : int {
@@ -55,14 +68,90 @@ struct BarrierState {
   std::vector<ContinuePromise> allPeersFinishedPromises;
 };
 
-/// Structure to accumulate splits for distribution.
-struct SplitsStore {
-  /// Arrived (added), but not distributed yet, splits.
-  std::deque<exec::Split> splits;
-  /// Signal, that no more splits will arrive.
-  bool noMoreSplits{false};
-  /// Blocking promises given out when out of splits to distribute.
-  std::vector<ContinuePromise> splitPromises;
+using ConnectorSplitPreloadFunc =
+    std::function<void(const std::shared_ptr<connector::ConnectorSplit>&)>;
+
+/// A split store that either can accumulate splits through addSplit() or
+/// generating splits from its own source.
+///
+/// This object is not multi-thread safe.
+class SplitsStore {
+ public:
+  explicit SplitsStore(bool remoteSplit) : remoteSplit_(remoteSplit) {}
+
+  virtual ~SplitsStore() = default;
+
+  /// Add a barrier split to this store.  Some of the waiters previously waiting
+  /// on the ContinueFuture after the nextSplit() call should be notified by the
+  /// caller of this function by setting values on the `promises` output
+  /// parameter.
+  ///
+  /// `promises` should be set by caller (potentially outside a lock), to notify
+  /// any waiters on the splits.
+  virtual void requestBarrier(std::vector<ContinuePromise>& promises) = 0;
+
+  /// Return true when split is set or there is no more splits; false when
+  /// caller should retry when the future is fulfilled.
+  virtual bool nextSplit(
+      Split& split,
+      ContinueFuture& future,
+      int maxPreloadSplits,
+      const ConnectorSplitPreloadFunc& preload) = 0;
+
+  /// Return whether all splits has been consumed and there will be no more
+  /// splits.
+  virtual bool allSplitsConsumed() const = 0;
+
+  /// Add new split into this store.  Some of the waiters previously waiting on
+  /// the ContinueFuture after the nextSplit() call should be notified by the
+  /// caller of this function by setting values on the `promises` output
+  /// parameter.
+  ///
+  /// `promises` should be set by caller (potentially outside a lock), to notify
+  /// any waiters on the splits.
+  void addSplit(Split split, std::vector<ContinuePromise>& promises);
+
+  /// Return the number of waiters waiting for new splits.
+  int numWaiters() const {
+    return promises_.size();
+  }
+
+  /// Signal there will not be any more splits added to this store.
+  std::vector<ContinuePromise> noMoreSplits() {
+    noMoreSplits_ = true;
+    return std::move(promises_);
+  }
+
+  void setTaskStats(TaskStats& taskStats) {
+    taskStats_ = &taskStats;
+  }
+
+  void setPreloadingSplits(
+      folly::F14FastSet<std::shared_ptr<connector::ConnectorSplit>>&
+          preloadingSplits) {
+    preloadingSplits_ = &preloadingSplits;
+  }
+
+ protected:
+  Split getSplit(
+      int maxPreloadSplits,
+      const ConnectorSplitPreloadFunc& preload);
+
+  ContinueFuture makeFuture();
+
+  const bool remoteSplit_;
+  TaskStats* taskStats_{};
+  folly::F14FastSet<std::shared_ptr<connector::ConnectorSplit>>*
+      preloadingSplits_{};
+
+  // Arrived (added), but not distributed yet, splits.
+  std::deque<Split> splits_;
+
+  // Signal, that no more splits will arrive.
+  bool noMoreSplits_{false};
+
+  // Blocking promises given out when out of splits to distribute.
+  std::vector<ContinuePromise> promises_;
 };
 
 /// Structure contains the current info on splits for a particular plan node.
@@ -77,7 +166,7 @@ struct SplitsState {
   long maxSequenceId{std::numeric_limits<long>::min()};
 
   /// Map split group id -> split store.
-  std::unordered_map<uint32_t, SplitsStore> groupSplitsStores;
+  std::unordered_map<uint32_t, std::unique_ptr<SplitsStore>> groupSplitsStores;
 
   /// We need these due to having promises in the structure.
   SplitsState() = default;
diff --git a/velox/exec/TaskTraceReader.cpp b/velox/exec/TaskTraceReader.cpp
index b972c90cff8c..24125b01b78b 100644
--- a/velox/exec/TaskTraceReader.cpp
+++ b/velox/exec/TaskTraceReader.cpp
@@ -31,9 +31,10 @@ TaskTraceMetadataReader::TaskTraceMetadataReader(
       traceFilePath_(getTaskTraceMetaFilePath(traceDir_)),
       pool_(pool),
       metadataObj_(getTaskMetadata(traceFilePath_, fs_)),
-      tracePlanNode_(ISerializable::deserialize<core::PlanNode>(
-          metadataObj_[TraceTraits::kPlanNodeKey],
-          pool_)) {}
+      tracePlanNode_(
+          ISerializable::deserialize<core::PlanNode>(
+              metadataObj_[TraceTraits::kPlanNodeKey],
+              pool_)) {}
 
 std::unordered_map<std::string, std::string>
 TaskTraceMetadataReader::queryConfigs() const {
@@ -66,22 +67,41 @@ core::PlanNodePtr TaskTraceMetadataReader::queryPlan() const {
 }
 
 std::string TaskTraceMetadataReader::nodeName(const std::string& nodeId) const {
-  const auto* traceNode = core::PlanNode::findFirstNode(
-      tracePlanNode_.get(),
-      [&nodeId](const core::PlanNode* node) { return node->id() == nodeId; });
+  LOG(ERROR) << "node id " << nodeId << " trace plan node "
+             << tracePlanNode_->toString(true, true);
+  const auto* traceNode =
+      core::PlanNode::findNodeById(tracePlanNode_.get(), nodeId);
+  VELOX_CHECK_NOT_NULL(
+      traceNode, "trace node id {} not found in the trace plan", nodeId);
   return std::string(traceNode->name());
 }
 
-std::string TaskTraceMetadataReader::connectorId(
+std::optional<std::string> TaskTraceMetadataReader::connectorId(
     const std::string& nodeId) const {
-  const auto* traceNode = core::PlanNode::findFirstNode(
-      tracePlanNode_.get(),
-      [&nodeId](const core::PlanNode* node) { return node->id() == nodeId; });
-  const auto* tableScanNode =
-      dynamic_cast<const core::TableScanNode*>(traceNode);
-  VELOX_CHECK_NOT_NULL(tableScanNode);
-  const auto connectorId = tableScanNode->tableHandle()->connectorId();
-  VELOX_CHECK(!connectorId.empty());
-  return connectorId;
+  const auto* traceNode =
+      core::PlanNode::findNodeById(tracePlanNode_.get(), nodeId);
+  VELOX_CHECK_NOT_NULL(
+      traceNode,
+      "trace node id {} not found in the trace plan: {}",
+      nodeId,
+      tracePlanNode_->toString(true, true));
+
+  if (const auto* indexLookupJoinNode =
+          dynamic_cast<const core::IndexLookupJoinNode*>(traceNode)) {
+    const auto indexLookupConnectorId =
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId();
+    VELOX_CHECK(!indexLookupConnectorId.empty());
+    return indexLookupConnectorId;
+  }
+
+  if (const auto* tableScanNode =
+          dynamic_cast<const core::TableScanNode*>(traceNode)) {
+    VELOX_CHECK_NOT_NULL(tableScanNode);
+    const auto connectorId = tableScanNode->tableHandle()->connectorId();
+    VELOX_CHECK(!connectorId.empty());
+    return connectorId;
+  }
+
+  return std::nullopt;
 }
 } // namespace facebook::velox::exec::trace
diff --git a/velox/exec/TaskTraceReader.h b/velox/exec/TaskTraceReader.h
index f8475f966341..51ee04d2813a 100644
--- a/velox/exec/TaskTraceReader.h
+++ b/velox/exec/TaskTraceReader.h
@@ -37,8 +37,9 @@ class TaskTraceMetadataReader {
   /// Returns node name in the trace query plan by ID.
   std::string nodeName(const std::string& nodeId) const;
 
-  /// Returns connector ID in the TableScanNode.
-  std::string connectorId(const std::string& nodeId) const;
+  /// Returns optional of connector ID in the TableScanNode. If nullptr, then no
+  /// connector will be registered.
+  std::optional<std::string> connectorId(const std::string& nodeId) const;
 
  private:
   const std::string traceDir_;
diff --git a/velox/exec/TopNRowNumber.cpp b/velox/exec/TopNRowNumber.cpp
index b4b059cd72df..e0da3986dff8 100644
--- a/velox/exec/TopNRowNumber.cpp
+++ b/velox/exec/TopNRowNumber.cpp
@@ -19,6 +19,28 @@ namespace facebook::velox::exec {
 
 namespace {
 
+#define RANK_FUNCTION_DISPATCH(TEMPLATE_FUNC, functionKind, ...)             \
+  [&]() {                                                                    \
+    switch (functionKind) {                                                  \
+      case core::TopNRowNumberNode::RankFunction::kRowNumber: {              \
+        return TEMPLATE_FUNC<                                                \
+            core::TopNRowNumberNode::RankFunction::kRowNumber>(__VA_ARGS__); \
+      }                                                                      \
+      case core::TopNRowNumberNode::RankFunction::kRank: {                   \
+        return TEMPLATE_FUNC<core::TopNRowNumberNode::RankFunction::kRank>(  \
+            __VA_ARGS__);                                                    \
+      }                                                                      \
+      case core::TopNRowNumberNode::RankFunction::kDenseRank: {              \
+        return TEMPLATE_FUNC<                                                \
+            core::TopNRowNumberNode::RankFunction::kDenseRank>(__VA_ARGS__); \
+      }                                                                      \
+      default:                                                               \
+        VELOX_FAIL(                                                          \
+            "not a rank function kind: {}",                                  \
+            core::TopNRowNumberNode::rankFunctionName(functionKind));        \
+    }                                                                        \
+  }()
+
 std::vector<column_index_t> reorderInputChannels(
     const RowTypePtr& inputType,
     const std::vector<core::FieldAccessTypedExprPtr>& partitionKeys,
@@ -113,9 +135,11 @@ TopNRowNumber::TopNRowNumber(
           node->canSpill(driverCtx->queryConfig())
               ? driverCtx->makeSpillConfig(operatorId)
               : std::nullopt),
+      rankFunction_(node->rankFunction()),
       limit_{node->limit()},
       generateRowNumber_{node->generateRowNumber()},
       numPartitionKeys_{node->partitionKeys().size()},
+      numSortingKeys_{node->sortingKeys().size()},
       inputChannels_{reorderInputChannels(
           node->inputType(),
           node->partitionKeys(),
@@ -127,13 +151,14 @@ TopNRowNumber::TopNRowNumber(
           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())),
+      data_(
+          std::make_unique<RowContainer>(
+              slice(inputType_->children(), 0, spillCompareFlags_.size()),
+              slice(
+                  inputType_->children(),
+                  spillCompareFlags_.size(),
+                  inputType_->size()),
+              pool())),
       comparator_(
           inputType_,
           node->sortingKeys(),
@@ -200,19 +225,30 @@ void TopNRowNumber::addInput(RowVectorPtr input) {
     SelectivityVector rows(numInput);
     table_->prepareForGroupProbe(
         *lookup_, input, rows, BaseHashTable::kNoSpillInputStartPartitionBit);
-    table_->groupProbe(*lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
+    try {
+      table_->groupProbe(
+          *lookup_, BaseHashTable::kNoSpillInputStartPartitionBit);
+    } catch (...) {
+      // If groupProbe throws (e.g., due to OOM), we need to clean up the new
+      // groups that were inserted but not yet initialized by
+      // initializeNewPartitions(). Otherwise, close() will crash when trying to
+      // destroy uninitialized TopRows structures.
+      cleanupNewPartitions();
+      throw;
+    }
 
     // Initialize new partitions.
     initializeNewPartitions();
 
-    // Process input rows. For each row, lookup the partition. If number of rows
-    // in that partition is less than limit, add the new row. Otherwise, check
-    // if row should replace an existing row or be discarded.
-    for (auto i = 0; i < numInput; ++i) {
-      auto& partition = partitionAt(lookup_->hits[i]);
-      processInputRow(i, partition);
-    }
+    // Process input rows. For each row, lookup the partition. If the highest
+    // (top) rank in that partition is less than limit, add the new row.
+    // Otherwise, check if row should replace an existing row or be discarded.
+    RANK_FUNCTION_DISPATCH(processInputRowLoop, rankFunction_, numInput);
 
+    // It is determined that the TopNRowNumber (as a partial) is not rejecting
+    // enough input rows to make the duplicate detection worthwhile. Hence,
+    // abandon the processing at this partial TopN and let the final TopN do
+    // the processing.
     if (abandonPartialEarly()) {
       abandonedPartial_ = true;
       addRuntimeStat("abandonedPartial", RuntimeCounter(1));
@@ -222,9 +258,7 @@ void TopNRowNumber::addInput(RowVectorPtr input) {
       outputRows_.resize(outputBatchSize_);
     }
   } else {
-    for (auto i = 0; i < numInput; ++i) {
-      processInputRow(i, *singlePartition_);
-    }
+    RANK_FUNCTION_DISPATCH(processInputRowLoop, rankFunction_, numInput);
   }
 }
 
@@ -249,25 +283,167 @@ void TopNRowNumber::initializeNewPartitions() {
   }
 }
 
-void TopNRowNumber::processInputRow(vector_size_t index, TopRows& partition) {
+void TopNRowNumber::cleanupNewPartitions() {
+  std::vector<char*> newRows(lookup_->newGroups.size());
+  for (auto i = 0; i < lookup_->newGroups.size(); ++i) {
+    newRows[i] = lookup_->hits[lookup_->newGroups[i]];
+  }
+  table_->erase(folly::Range(newRows.data(), newRows.size()));
+  lookup_->newGroups.clear();
+}
+
+template <>
+char* TopNRowNumber::processRowWithinLimit<
+    core::TopNRowNumberNode::RankFunction::kRank>(
+    vector_size_t index,
+    TopRows& partition) {
+  // The topRanks queue is not filled yet.
+  auto& topRows = partition.rows;
+  if (topRows.empty()) {
+    partition.topRank = 1;
+  } else {
+    // Rank assigns all peer rows the same rank, but the rank increments by
+    // the number of peers when moving between peers. So when adding a new
+    // row:
+    // If row == top rank then top rank is unchanged.
+    // If row < top rank then top rank += 1.
+    // If row > top, then rank += number of peers of top rank.
+    auto* topRow = topRows.top();
+    auto result = comparator_.compare(decodedVectors_, index, topRow);
+    if (result < 0) {
+      partition.topRank += 1;
+    } else if (result > 0) {
+      partition.topRank += partition.numTopRankRows();
+    }
+  }
+  return data_->newRow();
+}
+
+template <>
+char* TopNRowNumber::processRowWithinLimit<
+    core::TopNRowNumberNode::RankFunction::kDenseRank>(
+    vector_size_t index,
+    TopRows& partition) {
+  // The topRanks queue is not filled yet.
+  // dense_rank will add this row to its partition. But the top rank is
+  // incremented only if the new row is not a peer of any other existing
+  // row in the partition queue.
+  if (!partition.isDuplicate(decodedVectors_, index)) {
+    partition.topRank++;
+  }
+  return data_->newRow();
+}
+
+template <>
+char* TopNRowNumber::processRowWithinLimit<
+    core::TopNRowNumberNode::RankFunction::kRowNumber>(
+    vector_size_t /*index*/,
+    TopRows& partition) {
+  // row_number accumulates the new row in the partition, and the top rank is
+  // incremented by 1 as row_number increases by 1 at each new row.
+  ++partition.topRank;
+  return data_->newRow();
+}
+
+template <>
+char* TopNRowNumber::processRowExceedingLimit<
+    core::TopNRowNumberNode::RankFunction::kRank>(
+    vector_size_t index,
+    TopRows& partition) {
   auto& topRows = partition.rows;
+  // The new row < top rank
+  // For rank, the new row gets assigned its rank as per its position in the
+  // queue. But the ranks of all subsequent rows increment by 1.
+  // So we can remove the rows at the top rank as its rank > limit now.
+  char* topRow = partition.removeTopRankRows();
+  char* newRow = data_->initializeRow(topRow, /*reuse=*/true);
+  if (topRows.empty()) {
+    partition.topRank = 1;
+  } else {
+    // The new top rank value depends on the number of peers of the top ranking
+    // row. If the current row also has the same value as the new top ranking
+    // row then it has to be counted as a peer as well.
+    auto numNewTopRankRows = partition.numTopRankRows();
+    topRow = topRows.top();
+    if (comparator_.compare(decodedVectors_, index, topRow) == 0) {
+      partition.topRank = topRows.size() - numNewTopRankRows + 1;
+    } else {
+      partition.topRank = topRows.size() - numNewTopRankRows + 2;
+    }
+  }
+  return newRow;
+}
 
+template <>
+char* TopNRowNumber::processRowExceedingLimit<
+    core::TopNRowNumberNode::RankFunction::kDenseRank>(
+    vector_size_t index,
+    TopRows& partition) {
   char* newRow = nullptr;
-  if (topRows.size() < limit_) {
+  // The new row < top rank
+  // For dense_rank:
+  // i) If the row is a peer of an existing row in the queue, then it
+  // has the same rank as it. The ranks of other rows are unchanged. So its
+  // only added to the queue.
+  // ii) If the row is a distinct new value in the queue, then it is assigned
+  // a rank as per its position, and the ranks of all subsequent rows += 1.
+  // So the current top rank rows can be removed from the queue as their new
+  // rank > limit.
+  if (partition.isDuplicate(decodedVectors_, index)) {
     newRow = data_->newRow();
   } else {
+    char* topRow = partition.removeTopRankRows();
+    newRow = data_->initializeRow(topRow, /*reuse=*/true);
+  }
+  return newRow;
+}
+
+template <>
+char* TopNRowNumber::processRowExceedingLimit<
+    core::TopNRowNumberNode::RankFunction::kRowNumber>(
+    vector_size_t /*index*/,
+    TopRows& partition) {
+  // The new row has rank < highest (aka top) rank at 'limit' function value.
+  // For row_number, such rows are added to the accumulator queue and the
+  // top rank row is popped out. The topRank remains the same.
+  auto& topRows = partition.rows;
+  char* topRow = topRows.top();
+  topRows.pop();
+  // Reuses the space of the popped row itself for the new row.
+  return data_->initializeRow(topRow, true /* reuse */);
+}
+
+template <core::TopNRowNumberNode::RankFunction TRank>
+void TopNRowNumber::processInputRow(vector_size_t index, TopRows& partition) {
+  auto& topRows = partition.rows;
+
+  char* newRow = nullptr;
+  if (partition.topRank < limit_) {
+    newRow = processRowWithinLimit<TRank>(index, partition);
+  } else {
+    // The partition has now accumulated >= limit rows. So the new rows can be
+    // rejected or replace existing rows based on the order_by values.
     char* topRow = topRows.top();
 
-    if (!comparator_(decodedVectors_, index, topRow)) {
-      // Drop this input row.
+    const auto result = comparator_.compare(decodedVectors_, index, topRow);
+    if (result > 0) {
+      // The new row is bigger than the top rank so far, so this row is ignored.
       return;
     }
 
-    // Replace existing row.
-    topRows.pop();
+    // This row has the same value as the top rank row. row_number rejects
+    // such rows, but are added to the queue for rank and dense_rank. The top
+    // rank remains unchanged.
+    else if (result == 0) {
+      if (rankFunction_ == core::TopNRowNumberNode::RankFunction::kRowNumber) {
+        return;
+      }
+      newRow = data_->newRow();
+    }
 
-    // Reuse the topRow's memory.
-    newRow = data_->initializeRow(topRow, true /* reuse */);
+    else if (result < 0) {
+      newRow = processRowExceedingLimit<TRank>(index, partition);
+    }
   }
 
   for (auto col = 0; col < decodedVectors_.size(); ++col) {
@@ -277,6 +453,19 @@ void TopNRowNumber::processInputRow(vector_size_t index, TopRows& partition) {
   topRows.push(newRow);
 }
 
+template <core::TopNRowNumberNode::RankFunction TRank>
+void TopNRowNumber::processInputRowLoop(vector_size_t numInput) {
+  if (table_) {
+    for (auto i = 0; i < numInput; ++i) {
+      processInputRow<TRank>(i, partitionAt(lookup_->hits[i]));
+    }
+  } else {
+    for (auto i = 0; i < numInput; ++i) {
+      processInputRow<TRank>(i, *singlePartition_);
+    }
+  }
+}
+
 void TopNRowNumber::noMoreInput() {
   Operator::noMoreInput();
 
@@ -293,7 +482,7 @@ void TopNRowNumber::noMoreInput() {
     spiller_->finishSpill(spillPartitionSet);
     VELOX_CHECK_EQ(spillPartitionSet.size(), 1);
     merge_ = spillPartitionSet.begin()->second->createOrderedReader(
-        spillConfig_->readBufferSize, pool(), &spillStats_);
+        *spillConfig_, pool(), spillStats_.get());
   } else {
     outputRows_.resize(outputBatchSize_);
   }
@@ -318,10 +507,46 @@ void TopNRowNumber::updateEstimatedOutputRowSize() {
   }
 }
 
+// This function handles a special case when determining the starting
+// rank value for the 'rank' function.
+// If there are many peer rows for the highest rank, then topRank could
+// oscillate between the two cases of topRank < limit and topRank > limit
+// as rows are added
+// E.g. If the input rows are 0, 0, 0, 5, 0, 0, 6 and we want rank <= 5, then
+// at 0, 0, 0, 5 :
+// topRows.pq - 0, 0, 0, 5 topRank -> 4
+// 0 is added.
+// topRows.pq - 0, 0, 0, 0, 5 topRank -> 5
+// topRank = limit now.
+// So when the next 0 is added, the last 5 is popped from TopRows and 0 is added
+// topRows.pq - 0, 0, 0, 0, 0, topRank -> 1
+// This makes topRank < 5 and so when 6 comes by, 6 is pushed
+// topRows.pq - 0, 0, 0, 0, 0, 6 topRank -> 6
+// So when doing getOutput, we need to adjust this case.
+// Since topRank > limit, then the highest rank is popped and the
+// topRank is adjusted as length(pq) - number_of_duplicates_of_new_top_row + 1.
+vector_size_t TopNRowNumber::fixTopRank(TopRows& partition) {
+  if (rankFunction_ == core::TopNRowNumberNode::RankFunction::kRank) {
+    if (partition.topRank > limit_) {
+      partition.removeTopRankRows();
+      auto numNewTopRankRows = partition.numTopRankRows();
+      partition.topRank = partition.rows.size() - numNewTopRankRows + 1;
+    }
+  }
+
+  return partition.topRank;
+}
+
 TopNRowNumber::TopRows* TopNRowNumber::nextPartition() {
+  auto setNextRankAndPeer = [&](TopRows& partition) {
+    nextRank_ = fixTopRank(partition);
+    numPeers_ = 1;
+  };
+
   if (!table_) {
     if (!outputPartitionNumber_) {
       outputPartitionNumber_ = 0;
+      setNextRankAndPeer(*singlePartition_);
       return singlePartition_.get();
     }
     return nullptr;
@@ -337,7 +562,6 @@ TopNRowNumber::TopRows* TopNRowNumber::nextPartition() {
       // No more partitions.
       return nullptr;
     }
-
     outputPartitionNumber_ = 0;
   } else {
     ++outputPartitionNumber_.value();
@@ -347,24 +571,58 @@ TopNRowNumber::TopRows* TopNRowNumber::nextPartition() {
     }
   }
 
-  return &partitionAt(partitions_[outputPartitionNumber_.value()]);
+  auto partition = &partitionAt(partitions_[outputPartitionNumber_.value()]);
+  setNextRankAndPeer(*partition);
+  return partition;
+}
+
+template <core::TopNRowNumberNode::RankFunction TRank>
+void TopNRowNumber::computeNextRankInMemory(
+    const TopRows& partition,
+    vector_size_t outputIndex) {
+  if constexpr (TRank == core::TopNRowNumberNode::RankFunction::kRowNumber) {
+    nextRank_ -= 1;
+    return;
+  }
+
+  // This is the logic for rank() and dense_rank().
+  // If the next row is a peer of the current one, then the rank remains the
+  // same, but the number of peers is incremented.
+  if (comparator_.compare(outputRows_[outputIndex], partition.rows.top()) ==
+      0) {
+    numPeers_ += 1;
+    return;
+  }
+
+  // The new row is not a peer of the current one. So dense_rank drops the
+  // rank by 1, but rank drops it by the number of peers (which is then
+  // reset).
+  if constexpr (TRank == core::TopNRowNumberNode::RankFunction::kDenseRank) {
+    nextRank_ -= 1;
+  } else {
+    nextRank_ -= numPeers_;
+    numPeers_ = 1;
+  }
 }
 
+template <core::TopNRowNumberNode::RankFunction TRank>
 void TopNRowNumber::appendPartitionRows(
     TopRows& partition,
     vector_size_t numRows,
     vector_size_t outputOffset,
-    FlatVector<int64_t>* rowNumbers) {
+    FlatVector<int64_t>* rankValues) {
   // The partition.rows priority queue pops rows in order of reverse
-  // row numbers.
-  auto rowNumber = partition.rows.size();
+  // ranks. Output rows based on nextRank_ and update it with each row.
   for (auto i = 0; i < numRows; ++i) {
-    const auto index = outputOffset + i;
-    if (rowNumbers) {
-      rowNumbers->set(index, rowNumber--);
+    auto index = outputOffset + i;
+    if (rankValues) {
+      rankValues->set(index, nextRank_);
     }
     outputRows_[index] = partition.rows.top();
     partition.rows.pop();
+    if (!partition.rows.empty()) {
+      computeNextRankInMemory<TRank>(partition, index);
+    }
   }
 }
 
@@ -380,7 +638,7 @@ RowVectorPtr TopNRowNumber::getOutput() {
       return output;
     }
 
-    // We may have input accumulated in 'data_'.
+    // There could be older rows accumulated in 'data_'.
     if (data_->numRows() > 0) {
       return getOutputFromMemory();
     }
@@ -389,6 +647,7 @@ RowVectorPtr TopNRowNumber::getOutput() {
       finished_ = true;
     }
 
+    // There is no data to return at this moment.
     return nullptr;
   }
 
@@ -396,9 +655,11 @@ RowVectorPtr TopNRowNumber::getOutput() {
     return nullptr;
   }
 
+  // All the input data is received, so the operator can start producing
+  // output.
   RowVectorPtr output;
   if (merge_ != nullptr) {
-    output = getOutputFromSpill();
+    output = RANK_FUNCTION_DISPATCH(getOutputFromSpill, rankFunction_);
   } else {
     output = getOutputFromMemory();
   }
@@ -435,20 +696,27 @@ RowVectorPtr TopNRowNumber::getOutputFromMemory() {
 
     const auto numOutputRowsLeft = outputBatchSize_ - offset;
     if (outputPartition_->rows.size() > numOutputRowsLeft) {
-      // Only a partial partition can be output in this getOutput() call.
       // Output as many rows as possible.
-      // NOTE: the partial output partition erases the yielded output rows
-      // and next getOutput() call starts with the remaining rows.
-      appendPartitionRows(
-          *outputPartition_, numOutputRowsLeft, offset, rowNumbers);
+      RANK_FUNCTION_DISPATCH(
+          appendPartitionRows,
+          rankFunction_,
+          *outputPartition_,
+          numOutputRowsLeft,
+          offset,
+          rowNumbers);
       offset += numOutputRowsLeft;
       break;
     }
 
     // Add all partition rows.
-    auto numPartitionRows = outputPartition_->rows.size();
-    appendPartitionRows(
-        *outputPartition_, numPartitionRows, offset, rowNumbers);
+    const auto numPartitionRows = outputPartition_->rows.size();
+    RANK_FUNCTION_DISPATCH(
+        appendPartitionRows,
+        rankFunction_,
+        *outputPartition_,
+        numPartitionRows,
+        offset,
+        rowNumbers);
     offset += numPartitionRows;
     outputPartition_ = nullptr;
   }
@@ -475,13 +743,15 @@ RowVectorPtr TopNRowNumber::getOutputFromMemory() {
   return output;
 }
 
-bool TopNRowNumber::isNewPartition(
+bool TopNRowNumber::compareSpillRowColumns(
     const RowVectorPtr& output,
     vector_size_t index,
-    SpillMergeStream* next) {
+    const SpillMergeStream* next,
+    vector_size_t startColumn,
+    vector_size_t endColumn) {
   VELOX_CHECK_GT(index, 0);
 
-  for (auto i = 0; i < numPartitionKeys_; ++i) {
+  for (auto i = startColumn; i < endColumn; ++i) {
     if (!output->childAt(inputChannels_[i])
              ->equalValueAt(
                  next->current().childAt(i).get(),
@@ -493,22 +763,79 @@ bool TopNRowNumber::isNewPartition(
   return false;
 }
 
-void TopNRowNumber::setupNextOutput(
+// Compares the partition keys for new partitions.
+bool TopNRowNumber::isNewPartition(
     const RowVectorPtr& output,
-    int32_t rowNumber) {
-  auto* lookAhead = merge_->next();
-  if (lookAhead == nullptr) {
-    nextRowNumber_ = 0;
+    vector_size_t index,
+    const SpillMergeStream* next) {
+  return compareSpillRowColumns(output, index, next, 0, numPartitionKeys_);
+}
+
+// Compares the sorting keys for determining peers.
+bool TopNRowNumber::isNewRank(
+    const RowVectorPtr& output,
+    vector_size_t index,
+    const SpillMergeStream* next) {
+  return compareSpillRowColumns(
+      output,
+      index,
+      next,
+      numPartitionKeys_,
+      numPartitionKeys_ + numSortingKeys_);
+}
+
+template <core::TopNRowNumberNode::RankFunction TRank>
+void TopNRowNumber::computeNextRankInSpill(
+    const RowVectorPtr& output,
+    vector_size_t index,
+    const SpillMergeStream* next) {
+  if (isNewPartition(output, index, next)) {
+    nextRank_ = 1;
+    numPeers_ = 1;
+    return;
+  }
+
+  if constexpr (TRank == core::TopNRowNumberNode::RankFunction::kRowNumber) {
+    nextRank_ += 1;
+    return;
+  }
+
+  // The function is either rank or dense_rank.
+  // This row belongs to the same partition as the previous row. However,
+  // it should be determined if it is a peer row as well. If its a peer,
+  // then increase numPeers_ but the rank remains unchanged.
+  if (!isNewRank(output, index, next)) {
+    numPeers_ += 1;
+    return;
+  }
+
+  // The row is not a peer, so increment the rank and peers accordingly.
+  if constexpr (TRank == core::TopNRowNumberNode::RankFunction::kDenseRank) {
+    nextRank_ += 1;
+    numPeers_ = 1;
     return;
   }
 
-  if (isNewPartition(output, output->size(), lookAhead)) {
-    nextRowNumber_ = 0;
+  // Rank function increments by number of peers.
+  nextRank_ += numPeers_;
+  numPeers_ = 1;
+}
+
+template <core::TopNRowNumberNode::RankFunction TRank>
+void TopNRowNumber::setupNextOutput(const RowVectorPtr& output) {
+  auto resetNextRankAndPeer = [this]() {
+    nextRank_ = 1;
+    numPeers_ = 1;
+  };
+
+  auto* lookAhead = merge_->next();
+  if (lookAhead == nullptr) {
+    resetNextRankAndPeer();
     return;
   }
 
-  nextRowNumber_ = rowNumber;
-  if (nextRowNumber_ < limit_) {
+  computeNextRankInSpill<TRank>(output, output->size(), lookAhead);
+  if (nextRank_ <= limit_) {
     return;
   }
 
@@ -516,16 +843,17 @@ void TopNRowNumber::setupNextOutput(
   lookAhead->pop();
   while (auto* next = merge_->next()) {
     if (isNewPartition(output, output->size(), next)) {
-      nextRowNumber_ = 0;
+      resetNextRankAndPeer();
       return;
     }
     next->pop();
   }
 
   // This partition is the last partition.
-  nextRowNumber_ = 0;
+  resetNextRankAndPeer();
 }
 
+template <core::TopNRowNumberNode::RankFunction TRank>
 RowVectorPtr TopNRowNumber::getOutputFromSpill() {
   VELOX_CHECK_NOT_NULL(merge_);
 
@@ -533,37 +861,32 @@ RowVectorPtr TopNRowNumber::getOutputFromSpill() {
   // 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
+  // nextRank_ and numPeers_. Once rank 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;
+  FlatVector<int64_t>* rankValues = nullptr;
   if (generateRowNumber_) {
-    rowNumbers = output->children().back()->as<FlatVector<int64_t>>();
+    rankValues = 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_);
+  VELOX_CHECK_LE(nextRank_, 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 (index > 0) {
+      computeNextRankInSpill<TRank>(output, index, next);
     }
 
     // Copy this row to the output buffer if this partition has
     // < limit_ rows output.
-    if (rowNumber < limit_) {
+    if (nextRank_ <= limit_) {
       for (auto i = 0; i < inputChannels_.size(); ++i) {
         output->childAt(inputChannels_[i])
             ->copy(
@@ -572,12 +895,11 @@ RowVectorPtr TopNRowNumber::getOutputFromSpill() {
                 next->currentIndex(),
                 1);
       }
-      if (rowNumbers) {
-        // Row numbers start with 1.
-        rowNumbers->set(index, rowNumber + 1);
+
+      if (rankValues) {
+        rankValues->set(index, nextRank_);
       }
       ++index;
-      ++rowNumber;
     }
 
     // Pop this row from the spill.
@@ -588,8 +910,8 @@ RowVectorPtr TopNRowNumber::getOutputFromSpill() {
       // Prepare the next batch :
       // i) If 'limit_' is reached for this partition, then skip the rows
       // until the next partition.
-      // ii) If the next row is from a new partition, then reset rowNumber_.
-      setupNextOutput(output, rowNumber);
+      // ii) If the next row is from a new partition, then reset nextRank_.
+      setupNextOutput<TRank>(output);
       return output;
     }
   }
@@ -704,14 +1026,15 @@ void TopNRowNumber::ensureInputFits(const RowVectorPtr& input) {
     if ((tableIncrementBytes == 0) && (freeRows > input->size()) &&
         (outOfLineBytes == 0 ||
          outOfLineFreeBytes >= outOfLineBytesPerRow * input->size())) {
-      // Enough free rows for input rows and enough variable length free space.
+      // 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.
+  // 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);
@@ -750,6 +1073,68 @@ void TopNRowNumber::setupSpiller() {
       inputType_,
       sortingKeys,
       &spillConfig_.value(),
-      &spillStats_);
+      spillStats_.get());
+}
+
+// Using the underlying vector of the priority queue for the algorithms to
+// check duplicates and count the number of top rank rows. This makes the
+// algorithms O(n). There could be other approaches to make the
+// algorithms O(1), but would trade memory efficiency.
+namespace {
+template <class T, class S, class C>
+S& PriorityQueueVector(std::priority_queue<T, S, C>& q) {
+  struct PrivateQueue : private std::priority_queue<T, S, C> {
+    static S& Container(std::priority_queue<T, S, C>& q) {
+      return q.*&PrivateQueue::c;
+    }
+  };
+  return PrivateQueue::Container(q);
+}
+} // namespace
+
+char* TopNRowNumber::TopRows::removeTopRankRows() {
+  VELOX_CHECK(!rows.empty());
+
+  char* topRow = rows.top();
+  rows.pop();
+
+  while (!rows.empty()) {
+    char* newTopRow = rows.top();
+    if (rowComparator.compare(topRow, newTopRow) != 0) {
+      return topRow;
+    }
+    rows.pop();
+  }
+  return topRow;
+}
+
+vector_size_t TopNRowNumber::TopRows::numTopRankRows() {
+  VELOX_CHECK(!rows.empty());
+  char* topRow = rows.top();
+  vector_size_t numRows = 0;
+  const std::vector<char*, StlAllocator<char*>> partitionRowsVector =
+      PriorityQueueVector(rows);
+  for (const char* row : partitionRowsVector) {
+    if (rowComparator.compare(topRow, row) == 0) {
+      numRows += 1;
+    } else {
+      break;
+    }
+  }
+  return numRows;
+}
+
+bool TopNRowNumber::TopRows::isDuplicate(
+    const std::vector<DecodedVector>& decodedVectors,
+    vector_size_t index) {
+  const std::vector<char*, StlAllocator<char*>> partitionRowsVector =
+      PriorityQueueVector(rows);
+  for (const char* row : partitionRowsVector) {
+    if (rowComparator.compare(decodedVectors, index, row) == 0) {
+      return true;
+    }
+  }
+  return false;
 }
+
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TopNRowNumber.h b/velox/exec/TopNRowNumber.h
index a89f967f9a04..649869439671 100644
--- a/velox/exec/TopNRowNumber.h
+++ b/velox/exec/TopNRowNumber.h
@@ -22,20 +22,58 @@
 namespace facebook::velox::exec {
 class TopNRowNumberSpiller;
 
-/// Partitions the input using specified partitioning keys, sorts rows within
-/// partitions using specified sorting keys, assigns row numbers and returns up
-/// to specified number of rows per partition.
+/// TopNRowNumber is an optimized version of a Window operator with a
+/// single row_number or rank or dense_rank window function followed by a
+/// rank <= N filter. N must be >= 0. If the TopNRowNumber has no partition
+/// keys, then all the rows belong to a single partition. However, the
+/// TopNRowNumber should have at least one sorting key specified.
 ///
-/// It is allowed to not specify partitioning keys. In this case the whole input
-/// is treated as a single partition.
+/// TopNRowNumber is more efficient than a general Window operator as it does
+/// not store all rows of a partition. Instead, it only keeps the top N
+/// rows of the partition at any point.
 ///
-/// At least one sorting key must be specified.
+/// The operator partitions the input using specified partitioning keys,
+/// and maintains a TopRows structure per partition in a HashTable. The TopRows
+/// maintains a priority queue of row pointers. The priority queue is
+/// kept ordered by sorting keys of the TopNRowNumber. The TopRows only retains
+/// rows whose ranks satisfy the filter condition (so rank <= N). N is also
+/// called the limit of the operator. To aid this filtering, the TopRows tracks
+/// the greatest rank seen for each partition.
 ///
-/// The limit (maximum number of rows to return per partition) must be greater
-/// than zero.
+/// The operator processes all input rows before beginning to output rows.
 ///
-/// This is an optimized version of a Window operator with a single row_number
-/// window function followed by a row_number <= N filter.
+/// For each input row, it retrieves the TopRows corresponding to the partition
+/// keys. The TopRows is first filled until it has N rows. Thereafter, new rows
+/// are compared with the top row in the TopRows priority queue.
+/// If the new rows order by values are less than (for ASC) or greater than
+/// (for DESC) so row rank <= topRank, then the row is added to TopRows.
+/// For each outcome, the greatest rank of the TopRows is updated as per the
+/// ranking function logic.
+/// For each function type, the rank maintenance logic is in:
+/// - processRowWithinLimit() function when the TopRows is filling the first
+///   N rows.
+/// - processRowExceedingLimit() function when the TopRows already has N rows.
+///
+/// After processing all the input rows, the operator proceeds to output the
+/// rows. The rows might all be in memory or spilled to disk if memory
+/// reclamation was triggered during processing.
+///
+/// If the rows are in memory, then the operator iterates over each partition
+/// in the HashTable, and starts outputting rows from the partition. The
+/// TopRows structure maintains the rows in descending order of their ranks
+/// (greatest rank at the top of the priority queue). So when outputting,
+/// the operator first fixes the top rank of the partition using fixTopRank()
+/// and then computes the ranks of each row using computeNextRankInMemory().
+/// The logic of the next rank differs based on the ranking function.
+///
+/// If the rows are in the spill, then the spiller iterates over each spilled
+/// partition in order of the ranks. For each row from the spill, the next
+/// rank is computed using computeNextRankInSpill() function. The logic of
+/// the next rank differs based on the ranking function.
+/// Note : The spill could have > limit rows for a partition as each spill
+/// resets the TopRows for the partition. So stop outputting rows after
+/// reaching the limit for each partition.
+
 class TopNRowNumber : public Operator {
  public:
   TopNRowNumber(
@@ -71,7 +109,23 @@ class TopNRowNumber : public Operator {
       override;
 
  private:
-  // A priority queue to keep track of top 'limit' rows for a given partition.
+  // This structure holds the top rows for a partition. It uses a priority
+  // queue to maintain the top rows in order of their ranks. Note the rank
+  // logic depends on the respective function (row_number, rank or dense_rank).
+  // However, a common requirement across all three is to maintain the rows in
+  // order of their sort keys so that the greatest rank row is always at the top
+  // of the queue. This ordering is done using the RowComparator passed to the
+  // TopRows.
+  //
+  // The number of rows in TopRows are limited to 'limit' specified for the
+  // operator. The greatest rank of the rows in TopRows is maintained in the
+  // 'topRank' variable.
+  //
+  // The TopRows structure is first filled in order to collect 'limit'
+  // rows. Thereafter, new rows are compared with the top row and either kept
+  // or discarded and the new top rank is updated. The rank computation differs
+  // based on the ranking function. This structure has methods for abstractions
+  // used for the top rank maintenance algorithms.
   struct TopRows {
     struct Compare {
       RowComparator& comparator;
@@ -84,12 +138,39 @@ class TopNRowNumber : public Operator {
     std::priority_queue<char*, std::vector<char*, StlAllocator<char*>>, Compare>
         rows;
 
+    RowComparator& rowComparator;
+
+    // This is the greatest rank seen so far in the input rows. Note: rank is
+    // the result of the respective function computation (row_number, rank or
+    // dense_rank). It is compared with the expected limit for the operator.
+    int64_t topRank = 0;
+
+    // Number of rows with the highest rank in the partition.
+    vector_size_t numTopRankRows();
+
+    // Remove all rows with the highest rank in the partition.
+    // Returns a pointer to the last removed row.
+    char* removeTopRankRows();
+
+    // Returns true if the row at position index in decodedVectors
+    // has the same order by keys as another row in the TopRows
+    // priority_vector.
+    bool isDuplicate(
+        const std::vector<DecodedVector>& decodedVectors,
+        vector_size_t index);
+
     TopRows(HashStringAllocator* allocator, RowComparator& comparator)
-        : rows{{comparator}, StlAllocator<char*>(allocator)} {}
+        : rows{{comparator}, StlAllocator<char*>(allocator)},
+          rowComparator(comparator) {}
   };
 
   void initializeNewPartitions();
 
+  // Cleans up any newly inserted but uninitialized partitions from the hash
+  // table. This is called when groupProbe throws (e.g., due to OOM) to ensure
+  // close() doesn't crash trying to destroy uninitialized TopRows structures.
+  void cleanupNewPartitions();
+
   TopRows& partitionAt(char* group) {
     return *reinterpret_cast<TopRows*>(group + partitionOffset_);
   }
@@ -97,17 +178,46 @@ class TopNRowNumber : public Operator {
   // Decodes and potentially loads input if lazy vector.
   void prepareInput(RowVectorPtr& input);
 
+  // Handles input row when the partition has not yet accumulated 'limit' rows.
+  // Returns a pointer to the row to add to the partition accumulator.
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  char* processRowWithinLimit(vector_size_t index, TopRows& partition);
+
+  // Handles input row when the partition has already accumulated 'limit' rows.
+  // Returns a pointer to the row to add to the partition accumulator.
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  char* processRowExceedingLimit(vector_size_t index, TopRows& partition);
+
+  // Loop to process the numInput input rows received by the operator.
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  void processInputRowLoop(vector_size_t numInput);
+
   // Adds input row to a partition or discards the row.
+  template <core::TopNRowNumberNode::RankFunction TRank>
   void processInputRow(vector_size_t index, TopRows& partition);
 
   // Returns next partition to add to output or nullptr if there are no
   // partitions left.
   TopRows* nextPartition();
 
-  // Appends numRows of the output partition the output. Note: The rows are
-  // popped in reverse order of the row_number.
+  // If there are many rows with the highest rank, then the topRank
+  // of the partition can oscillate between a very small value and a
+  // value > limit. Fix the partition for this condition before starting to
+  // output the partition.
+  vector_size_t fixTopRank(TopRows& partition);
+
+  // Computes the rank for the next row to be output
+  // (all output rows in memory).
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  void computeNextRankInMemory(
+      const TopRows& partition,
+      vector_size_t rowIndex);
+
+  // Appends numRows of the current partition to the output. Note: The rows are
+  // popped in reverse order of the rank.
   // NOTE: This function erases the yielded output rows from the partition
   // and the next call starts with the remaining rows.
+  template <core::TopNRowNumberNode::RankFunction TRank>
   void appendPartitionRows(
       TopRows& partition,
       vector_size_t numRows,
@@ -125,6 +235,7 @@ class TopNRowNumber : public Operator {
 
   void setupSpiller();
 
+  template <core::TopNRowNumberNode::RankFunction TRank>
   RowVectorPtr getOutputFromSpill();
 
   RowVectorPtr getOutputFromMemory();
@@ -134,17 +245,42 @@ class TopNRowNumber : public Operator {
   bool isNewPartition(
       const RowVectorPtr& output,
       vector_size_t index,
-      SpillMergeStream* next);
+      const SpillMergeStream* next);
+
+  // Returns true if 'next' row is a new rank (rows differ on order by keys)
+  // of the previous row in the partition (at output[index] of the
+  // output block).
+  bool isNewRank(
+      const RowVectorPtr& output,
+      vector_size_t index,
+      const SpillMergeStream* next);
+
+  // Utility method to compare values from startColumn to endColumn for
+  // 'next' row from SpillMergeStream with current row of output (at index).
+  bool compareSpillRowColumns(
+      const RowVectorPtr& output,
+      vector_size_t index,
+      const SpillMergeStream* next,
+      vector_size_t startColumn,
+      vector_size_t endColumn);
+
+  // Computes next rank value for spill output.
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  inline void computeNextRankInSpill(
+      const RowVectorPtr& output,
+      vector_size_t index,
+      const 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.
+  // Checks if next row in 'merge_' belongs to a different partition than last
+  // row in 'output' and if so updates nextRank_ and numPeers_ to 1.
+  // Also, checks current partition reached the limit on rank and
+  // if so advances 'merge_' to the first row on the next
+  // partition and sets nextRank_ and numPeers_ 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);
+  // included in the next output batch using 'nextRank_'.
+  template <core::TopNRowNumberNode::RankFunction TRank>
+  void setupNextOutput(const RowVectorPtr& output);
 
   // Called in noMoreInput() and spill().
   void updateEstimatedOutputRowSize();
@@ -153,11 +289,15 @@ class TopNRowNumber : public Operator {
   // cardinality sufficiently. Returns false if spilling was triggered earlier.
   bool abandonPartialEarly() const;
 
+  // Rank function semantics of operator.
+  const core::TopNRowNumberNode::RankFunction rankFunction_;
+
   const int32_t limit_;
 
   const bool generateRowNumber_;
 
   const size_t numPartitionKeys_;
+  const size_t numSortingKeys_;
 
   // Input columns in the order of: partition keys, sorting keys, the rest.
   const std::vector<column_index_t> inputChannels_;
@@ -244,7 +384,11 @@ class TopNRowNumber : public Operator {
   // Used to sort-merge spilled data.
   std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge_;
 
-  // Row number for the first row in the next output batch from the spiller.
-  int32_t nextRowNumber_{0};
+  // Row number/rank or dense_rank for the first row in the next output batch
+  // from the spiller.
+  vector_size_t nextRank_{1};
+  // Number of peers of first row in the previous output batch. This is used
+  // in rank calculation.
+  vector_size_t numPeers_{1};
 };
 } // namespace facebook::velox::exec
diff --git a/velox/exec/TraceUtil.cpp b/velox/exec/TraceUtil.cpp
index 10388724e1bc..22b1c7d04c46 100644
--- a/velox/exec/TraceUtil.cpp
+++ b/velox/exec/TraceUtil.cpp
@@ -18,10 +18,12 @@
 
 #include <folly/json.h>
 
-#include <numeric>
+#include <utility>
+
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/file/File.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/exec/TableWriter.h"
 #include "velox/exec/Trace.h"
 
 namespace facebook::velox::exec::trace {
@@ -35,6 +37,11 @@ std::string findLastPathNode(const std::string& path) {
   VELOX_CHECK(!pathNodes.empty(), "No valid path nodes found from {}", path);
   return pathNodes.back();
 }
+
+std::unordered_map<std::string, TraceNodeFactory>& traceNodeRegistry() {
+  static std::unordered_map<std::string, TraceNodeFactory> registry;
+  return registry;
+}
 } // namespace
 
 void createTraceDirectory(
@@ -66,7 +73,13 @@ void createTraceDirectory(
 std::string getQueryTraceDirectory(
     const std::string& traceDir,
     const std::string& queryId) {
-  return fmt::format("{}/{}", traceDir, queryId);
+  // Remove trailing slash from traceDir if present
+  std::string normalizedTraceDir = traceDir;
+  if (!normalizedTraceDir.empty() && normalizedTraceDir.back() == '/') {
+    normalizedTraceDir.pop_back();
+  }
+
+  return fmt::format("{}/{}", normalizedTraceDir, queryId);
 }
 
 std::string getTaskTraceDirectory(
@@ -80,8 +93,9 @@ std::string getTaskTraceDirectory(
     const std::string& traceDir,
     const std::string& queryId,
     const std::string& taskId) {
-  return fmt::format(
-      "{}/{}", getQueryTraceDirectory(traceDir, queryId), taskId);
+  auto queryTraceDir = getQueryTraceDirectory(traceDir, queryId);
+
+  return fmt::format("{}/{}", queryTraceDir, taskId);
 }
 
 std::string getTaskTraceMetaFilePath(const std::string& taskTraceDir) {
@@ -166,10 +180,8 @@ RowTypePtr getDataType(
     const core::PlanNodePtr& tracedPlan,
     const std::string& tracedNodeId,
     size_t sourceIndex) {
-  const auto* traceNode = core::PlanNode::findFirstNode(
-      tracedPlan.get(), [&tracedNodeId](const core::PlanNode* node) {
-        return node->id() == tracedNodeId;
-      });
+  const auto* traceNode =
+      core::PlanNode::findNodeById(tracedPlan.get(), tracedNodeId);
   VELOX_CHECK_NOT_NULL(
       traceNode,
       "traced node id {} not found in the traced plan",
@@ -232,13 +244,256 @@ std::vector<uint32_t> extractDriverIds(const std::string& driverIds) {
 bool canTrace(const std::string& operatorType) {
   static const std::unordered_set<std::string> kSupportedOperatorTypes{
       "Aggregation",
+      "CallbackSink",
+      "Exchange",
       "FilterProject",
       "HashBuild",
       "HashProbe",
+      "IndexLookupJoin",
+      "MergeExchange",
+      "MergeJoin",
+      "OrderBy",
       "PartialAggregation",
       "PartitionedOutput",
       "TableScan",
-      "TableWrite"};
-  return kSupportedOperatorTypes.count(operatorType) > 0;
+      "TableWrite",
+      "TopNRowNumber",
+      "Unnest"};
+  if (kSupportedOperatorTypes.count(operatorType) > 0 ||
+      traceNodeRegistry().count(operatorType) > 0) {
+    return true;
+  }
+  return false;
+}
+
+core::PlanNodePtr getTraceNode(
+    const core::PlanNodePtr& plan,
+    core::PlanNodeId nodeId) {
+  const auto* traceNode = core::PlanNode::findNodeById(plan.get(), nodeId);
+  VELOX_CHECK_NOT_NULL(traceNode, "Failed to find node with id {}", nodeId);
+  if (const auto* hashJoinNode =
+          dynamic_cast<const core::HashJoinNode*>(traceNode)) {
+    return std::make_shared<core::HashJoinNode>(
+        nodeId,
+        hashJoinNode->joinType(),
+        hashJoinNode->isNullAware(),
+        hashJoinNode->leftKeys(),
+        hashJoinNode->rightKeys(),
+        hashJoinNode->filter(),
+        std::make_shared<DummySourceNode>(
+            hashJoinNode->sources()[0]->outputType()),
+        std::make_shared<DummySourceNode>(
+            hashJoinNode->sources()[1]->outputType()),
+        hashJoinNode->outputType());
+  }
+
+  if (const auto* mergeJoinNode =
+          dynamic_cast<const core::MergeJoinNode*>(traceNode)) {
+    return std::make_shared<core::MergeJoinNode>(
+        nodeId,
+        mergeJoinNode->joinType(),
+        mergeJoinNode->leftKeys(),
+        mergeJoinNode->rightKeys(),
+        mergeJoinNode->filter(),
+        std::make_shared<DummySourceNode>(
+            mergeJoinNode->sources()[0]->outputType()),
+        std::make_shared<DummySourceNode>(
+            mergeJoinNode->sources()[1]->outputType()),
+        mergeJoinNode->outputType());
+  }
+
+  if (const auto* filterNode =
+          dynamic_cast<const core::FilterNode*>(traceNode)) {
+    // Single FilterNode.
+    return std::make_shared<core::FilterNode>(
+        nodeId,
+        filterNode->filter(),
+        std::make_shared<DummySourceNode>(
+            filterNode->sources().front()->outputType()));
+  }
+
+  if (const auto* projectNode =
+          dynamic_cast<const core::ProjectNode*>(traceNode)) {
+    // A standalone ProjectNode.
+    if (projectNode->sources().empty() ||
+        projectNode->sources().front()->name() != "Filter") {
+      return std::make_shared<core::ProjectNode>(
+          nodeId,
+          projectNode->names(),
+          projectNode->projections(),
+          std::make_shared<DummySourceNode>(
+              projectNode->sources().front()->outputType()));
+    }
+
+    // -- ProjectNode [nodeId]
+    //   -- FilterNode [nodeId - 1]
+    const auto originalFilterNode =
+        std::dynamic_pointer_cast<const core::FilterNode>(
+            projectNode->sources().front());
+    VELOX_CHECK_NOT_NULL(originalFilterNode);
+
+    auto filterNode = std::make_shared<core::FilterNode>(
+        originalFilterNode->id(),
+        originalFilterNode->filter(),
+        std::make_shared<DummySourceNode>(
+            originalFilterNode->sources().front()->outputType()));
+    return std::make_shared<core::ProjectNode>(
+        nodeId,
+        projectNode->names(),
+        projectNode->projections(),
+        std::move(filterNode));
+  }
+
+  if (const auto* aggregationNode =
+          dynamic_cast<const core::AggregationNode*>(traceNode)) {
+    return std::make_shared<core::AggregationNode>(
+        nodeId,
+        aggregationNode->step(),
+        aggregationNode->groupingKeys(),
+        aggregationNode->preGroupedKeys(),
+        aggregationNode->aggregateNames(),
+        aggregationNode->aggregates(),
+        aggregationNode->globalGroupingSets(),
+        aggregationNode->groupId(),
+        aggregationNode->ignoreNullKeys(),
+        aggregationNode->noGroupsSpanBatches(),
+        std::make_shared<DummySourceNode>(
+            aggregationNode->sources().front()->outputType()));
+  }
+
+  if (const auto* partitionedOutputNode =
+          dynamic_cast<const core::PartitionedOutputNode*>(traceNode)) {
+    return std::make_shared<core::PartitionedOutputNode>(
+        nodeId,
+        partitionedOutputNode->kind(),
+        partitionedOutputNode->keys(),
+        partitionedOutputNode->numPartitions(),
+        partitionedOutputNode->isReplicateNullsAndAny(),
+        partitionedOutputNode->partitionFunctionSpecPtr(),
+        partitionedOutputNode->outputType(),
+        VectorSerde::Kind::kPresto,
+        std::make_shared<DummySourceNode>(
+            partitionedOutputNode->sources().front()->outputType()));
+  }
+
+  if (const auto* indexLookupJoinNode =
+          dynamic_cast<const core::IndexLookupJoinNode*>(traceNode)) {
+    return std::make_shared<core::IndexLookupJoinNode>(
+        nodeId,
+        indexLookupJoinNode->joinType(),
+        indexLookupJoinNode->leftKeys(),
+        indexLookupJoinNode->rightKeys(),
+        indexLookupJoinNode->joinConditions(),
+        indexLookupJoinNode->filter(),
+        indexLookupJoinNode->hasMarker(),
+        std::make_shared<DummySourceNode>(
+            indexLookupJoinNode->sources().front()->outputType()), // Probe side
+        indexLookupJoinNode->lookupSource(), // Index side
+        indexLookupJoinNode->outputType());
+  }
+
+  if (const auto* tableScanNode =
+          dynamic_cast<const core::TableScanNode*>(traceNode)) {
+    return std::make_shared<core::TableScanNode>(
+        nodeId,
+        tableScanNode->outputType(),
+        tableScanNode->tableHandle(),
+        tableScanNode->assignments());
+  }
+
+  if (const auto* tableWriteNode =
+          dynamic_cast<const core::TableWriteNode*>(traceNode)) {
+    return std::make_shared<core::TableWriteNode>(
+        nodeId,
+        tableWriteNode->columns(),
+        tableWriteNode->columnNames(),
+        tableWriteNode->columnStatsSpec(),
+        tableWriteNode->insertTableHandle(),
+        tableWriteNode->hasPartitioningScheme(),
+        TableWriteTraits::outputType(tableWriteNode->columnStatsSpec()),
+        tableWriteNode->commitStrategy(),
+        std::make_shared<DummySourceNode>(
+            tableWriteNode->sources().front()->outputType()));
+  }
+
+  if (const auto* unnestNode =
+          dynamic_cast<const core::UnnestNode*>(traceNode)) {
+    return std::make_shared<core::UnnestNode>(
+        nodeId,
+        unnestNode->replicateVariables(),
+        unnestNode->unnestVariables(),
+        unnestNode->unnestNames(),
+        unnestNode->ordinalityName(),
+        unnestNode->markerName(),
+        std::make_shared<DummySourceNode>(
+            unnestNode->sources().front()->outputType()));
+  }
+
+  if (const auto* orderByNode =
+          dynamic_cast<const core::OrderByNode*>(traceNode)) {
+    return std::make_shared<core::OrderByNode>(
+        nodeId,
+        orderByNode->sortingKeys(),
+        orderByNode->sortingOrders(),
+        orderByNode->isPartial(),
+        std::make_shared<DummySourceNode>(
+            orderByNode->sources().front()->outputType()));
+  }
+
+  if (const auto* topNRowNumberNode =
+          dynamic_cast<const core::TopNRowNumberNode*>(traceNode)) {
+    const auto generateRowNumber = topNRowNumberNode->generateRowNumber();
+    return std::make_shared<core::TopNRowNumberNode>(
+        nodeId,
+        topNRowNumberNode->rankFunction(),
+        topNRowNumberNode->partitionKeys(),
+        topNRowNumberNode->sortingKeys(),
+        topNRowNumberNode->sortingOrders(),
+        generateRowNumber ? std::make_optional(
+                                topNRowNumberNode->outputType()->names().back())
+                          : std::nullopt,
+        topNRowNumberNode->limit(),
+        std::make_shared<DummySourceNode>(
+            topNRowNumberNode->sources().front()->outputType()));
+  }
+
+  if (const auto* exchangeNode =
+          dynamic_cast<const core::ExchangeNode*>(traceNode)) {
+    // Check if it's a MergeExchangeNode
+    if (const auto* mergeExchangeNode =
+            dynamic_cast<const core::MergeExchangeNode*>(traceNode)) {
+      return std::make_shared<core::MergeExchangeNode>(
+          nodeId,
+          mergeExchangeNode->outputType(),
+          mergeExchangeNode->sortingKeys(),
+          mergeExchangeNode->sortingOrders(),
+          mergeExchangeNode->serdeKind());
+    }
+    // Regular ExchangeNode
+    return std::make_shared<core::ExchangeNode>(
+        nodeId, exchangeNode->outputType(), exchangeNode->serdeKind());
+  }
+
+  for (const auto& factory : traceNodeRegistry()) {
+    if (auto node = factory.second(traceNode, nodeId)) {
+      return node;
+    }
+  }
+
+  VELOX_UNSUPPORTED(
+      fmt::format("Unsupported trace node: {}", traceNode->name()));
+}
+
+void registerTraceNodeFactory(
+    const std::string& operatorType,
+    TraceNodeFactory&& factory) {
+  auto& registry = traceNodeRegistry();
+  VELOX_CHECK_EQ(registry.count(operatorType), 0);
+  registry.emplace(operatorType, std::move(factory));
+}
+
+void registerDummySourceSerDe() {
+  auto& registry = DeserializationWithContextRegistryForSharedPtr();
+  registry.Register("DummySource", DummySourceNode::create);
 }
 } // namespace facebook::velox::exec::trace
diff --git a/velox/exec/TraceUtil.h b/velox/exec/TraceUtil.h
index 2a4d6d870d1b..96837ff8b171 100644
--- a/velox/exec/TraceUtil.h
+++ b/velox/exec/TraceUtil.h
@@ -27,6 +27,45 @@
 
 namespace facebook::velox::exec::trace {
 
+static const std::vector<core::PlanNodePtr> kEmptySources;
+
+class DummySourceNode final : public core::PlanNode {
+ public:
+  explicit DummySourceNode(RowTypePtr outputType)
+      : PlanNode(""), outputType_(std::move(outputType)) {}
+
+  const RowTypePtr& outputType() const override {
+    return outputType_;
+  }
+
+  const std::vector<core::PlanNodePtr>& sources() const override {
+    return kEmptySources;
+  }
+
+  std::string_view name() const override {
+    return "DummySource";
+  }
+
+  folly::dynamic serialize() const override {
+    folly::dynamic obj = folly::dynamic::object;
+    obj["name"] = "DummySource";
+    obj["outputType"] = outputType_->serialize();
+    return obj;
+  }
+
+  static core::PlanNodePtr create(const folly::dynamic& obj, void* context) {
+    return std::make_shared<DummySourceNode>(
+        ISerializable::deserialize<RowType>(obj["outputType"]));
+  }
+
+ private:
+  void addDetails(std::stringstream& stream) const override {
+    // Nothing to add.
+  }
+
+  const RowTypePtr outputType_;
+};
+
 /// Creates a directory to store the query trace metdata and data.
 void createTraceDirectory(
     const std::string& traceDir,
@@ -135,4 +174,19 @@ folly::dynamic getTaskMetadata(
 
 /// Checks whether the operator can be traced.
 bool canTrace(const std::string& operatorType);
+
+/// Gets the specified the trace node from 'plan'. In the returned trace node,
+/// we replace its source nodes with DummySourceNode for replay.
+core::PlanNodePtr getTraceNode(
+    const core::PlanNodePtr& plan,
+    core::PlanNodeId nodeId);
+
+using TraceNodeFactory = std::function<
+    core::PlanNodePtr(const core::PlanNode*, const core::PlanNodeId&)>;
+
+void registerTraceNodeFactory(
+    const std::string& operatorType,
+    TraceNodeFactory&& factory);
+
+void registerDummySourceSerDe();
 } // namespace facebook::velox::exec::trace
diff --git a/velox/exec/Unnest.cpp b/velox/exec/Unnest.cpp
index 3891de18550f..2155ef616ac0 100644
--- a/velox/exec/Unnest.cpp
+++ b/velox/exec/Unnest.cpp
@@ -19,6 +19,18 @@
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::exec {
+namespace {
+#ifndef NDEBUG
+void debugCheckOutput(const RowVectorPtr& output) {
+  for (auto i = 0; i < output->childrenSize(); ++i) {
+    VELOX_CHECK_EQ(output->size(), output->childAt(i)->size());
+  }
+}
+#else
+void debugCheckOutput(const RowVectorPtr& output) {}
+#endif
+} // namespace
+
 Unnest::Unnest(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -29,22 +41,35 @@ Unnest::Unnest(
           operatorId,
           unnestNode->id(),
           "Unnest"),
-      withOrdinality_(unnestNode->withOrdinality()),
-      maxOutputSize_(outputBatchRows()) {
+      withOrdinality_(unnestNode->hasOrdinality()),
+      withMarker_(unnestNode->hasMarker()),
+      maxOutputSize_(
+          driverCtx->queryConfig().unnestSplitOutput()
+              ? outputBatchRows()
+              : std::numeric_limits<vector_size_t>::max()) {
   const auto& inputType = unnestNode->sources()[0]->outputType();
   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, the actual type is {}",
+          variable->type()->toString());
     }
     unnestChannels_.push_back(inputType->getChildIdx(variable->name()));
   }
-
   unnestDecoded_.resize(unnestVariables.size());
 
+  column_index_t checkOutputChannel = outputType_->size() - 1;
+  if (withMarker_) {
+    VELOX_CHECK_EQ(
+        outputType_->childAt(checkOutputChannel),
+        BOOLEAN(),
+        "Marker column should be BOOLEAN type.");
+    --checkOutputChannel;
+  }
   if (withOrdinality_) {
     VELOX_CHECK_EQ(
-        outputType_->children().back(),
+        outputType_->childAt(checkOutputChannel),
         BIGINT(),
         "Ordinality column should be BIGINT type.");
   }
@@ -83,11 +108,13 @@ void Unnest::addInput(RowVectorPtr input) {
 
     if (unnestVector->typeKind() == TypeKind::ARRAY) {
       const auto* unnestBaseArray = currentDecoded.base()->as<ArrayVector>();
+      VELOX_CHECK_NOT_NULL(unnestBaseArray);
       rawSizes_[channel] = unnestBaseArray->rawSizes();
       rawOffsets_[channel] = unnestBaseArray->rawOffsets();
     } else {
-      VELOX_CHECK(unnestVector->typeKind() == TypeKind::MAP);
+      VELOX_CHECK_EQ(unnestVector->typeKind(), TypeKind::MAP);
       const auto* unnestBaseMap = currentDecoded.base()->as<MapVector>();
+      VELOX_CHECK_NOT_NULL(unnestBaseMap);
       rawSizes_[channel] = unnestBaseMap->rawSizes();
       rawOffsets_[channel] = unnestBaseMap->rawOffsets();
     }
@@ -98,9 +125,7 @@ void Unnest::addInput(RowVectorPtr input) {
     for (auto row = 0; row < size; ++row) {
       if (!currentDecoded.isNullAt(row)) {
         const auto unnestSize = currentSizes[currentIndices[row]];
-        if (rawMaxSizes_[row] < unnestSize) {
-          rawMaxSizes_[row] = unnestSize;
-        }
+        rawMaxSizes_[row] = std::max(rawMaxSizes_[row], unnestSize);
       }
     }
   }
@@ -118,70 +143,89 @@ RowVectorPtr Unnest::getOutput() {
     return nullptr;
   }
 
-  const auto size = input_->size();
-  VELOX_DCHECK_LT(nextInputRow_, size);
+  const auto numInputRows = input_->size();
+  VELOX_DCHECK_LT(nextInputRow_, numInputRows);
 
   // Limit the number of input rows to keep output batch size within
   // 'maxOutputSize_'. When the output size is 'maxOutputSize_', the
   // first and last row might not be processed completely, and their output
   // might be split into multiple batches.
-  auto rowRange = extractRowRange(size);
-  if (rowRange.numElements == 0) {
-    // All arrays/maps are null or empty.
-    input_ = nullptr;
-    nextInputRow_ = 0;
+  const auto rowRange = extractRowRange(numInputRows);
+  if (rowRange.numInnerRows == 0) {
+    finishInput();
     maybeFinishDrain();
     return nullptr;
   }
 
   const auto output = generateOutput(rowRange);
   VELOX_CHECK_NOT_NULL(output);
-  if (rowRange.lastRowEnd.has_value()) {
+  if (rowRange.lastInnerRowEnd.has_value()) {
     // The last row is not processed completely.
-    firstRowStart_ = rowRange.lastRowEnd.value();
-    nextInputRow_ += rowRange.size - 1;
+    firstInnerRowStart_ = rowRange.lastInnerRowEnd.value();
+    nextInputRow_ += rowRange.numInputRows - 1;
   } else {
-    firstRowStart_ = 0;
-    nextInputRow_ += rowRange.size;
+    firstInnerRowStart_ = 0;
+    nextInputRow_ += rowRange.numInputRows;
   }
 
-  if (nextInputRow_ >= size) {
-    input_ = nullptr;
-    nextInputRow_ = 0;
+  if (nextInputRow_ >= numInputRows) {
+    finishInput();
   }
+  debugCheckOutput(output);
   return output;
 }
 
-Unnest::RowRange Unnest::extractRowRange(vector_size_t size) const {
-  vector_size_t numInput = 0;
-  vector_size_t numElements = 0;
-  std::optional<vector_size_t> lastRowEnd;
-  for (auto row = nextInputRow_; row < size; ++row) {
-    const bool isFirstRow = (row == nextInputRow_);
-    const vector_size_t remainingSize =
-        isFirstRow ? rawMaxSizes_[row] - firstRowStart_ : rawMaxSizes_[row];
-    ++numInput;
-    if (numElements + remainingSize > maxOutputSize_) {
+void Unnest::finishInput() {
+  input_ = nullptr;
+  nextInputRow_ = 0;
+  firstInnerRowStart_ = 0;
+}
+
+Unnest::RowRange Unnest::extractRowRange(vector_size_t inputSize) const {
+  vector_size_t numInputRows{0};
+  vector_size_t numInnerRows{0};
+  std::optional<vector_size_t> lastInnerRowEnd;
+  bool hasEmptyUnnestValue{false};
+  for (auto inputRow = nextInputRow_; inputRow < inputSize; ++inputRow) {
+    const bool isFirstRow = (inputRow == nextInputRow_);
+    vector_size_t remainingInnerRows = isFirstRow
+        ? rawMaxSizes_[inputRow] - firstInnerRowStart_
+        : rawMaxSizes_[inputRow];
+    if (rawMaxSizes_[inputRow] == 0) {
+      VELOX_CHECK_EQ(remainingInnerRows, 0);
+      hasEmptyUnnestValue = true;
+      if (withMarker_) {
+        remainingInnerRows = 1;
+      }
+    }
+    ++numInputRows;
+    if (numInnerRows + remainingInnerRows > maxOutputSize_) {
       // A single row's output needs to be split into multiple batches.
       // Determines the range to process the first and last rows partially,
       // rather than processing from 0 to 'rawMaxSizes_[row]'.
       if (isFirstRow) {
-        lastRowEnd = firstRowStart_ + maxOutputSize_ - numElements;
+        lastInnerRowEnd = firstInnerRowStart_ + maxOutputSize_ - numInnerRows;
       } else {
-        lastRowEnd = maxOutputSize_ - numElements;
+        lastInnerRowEnd = maxOutputSize_ - numInnerRows;
       }
       // Process maxOutputSize_ in this getOutput.
-      numElements = maxOutputSize_;
+      numInnerRows = maxOutputSize_;
       break;
     }
     // Process this row completely.
-    numElements += remainingSize;
-    if (numElements == maxOutputSize_) {
+    numInnerRows += remainingInnerRows;
+    if (numInnerRows == maxOutputSize_) {
       break;
     }
   }
-  VELOX_DCHECK_LE(numElements, maxOutputSize_);
-  return {nextInputRow_, numInput, lastRowEnd, numElements};
+  VELOX_DCHECK_GE(numInnerRows, 0);
+  VELOX_DCHECK_LE(numInnerRows, maxOutputSize_);
+  return {
+      nextInputRow_,
+      numInputRows,
+      lastInnerRowEnd,
+      numInnerRows,
+      hasEmptyUnnestValue};
 };
 
 void Unnest::generateRepeatedColumns(
@@ -189,26 +233,48 @@ void Unnest::generateRepeatedColumns(
     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(range.numElements, pool());
-  auto* rawRepeatedIndices = repeatedIndices->asMutable<vector_size_t>();
-  vector_size_t index = 0;
-  VELOX_DCHECK_GT(range.size, 0);
+  auto repeatedIndices = allocateIndices(range.numInnerRows, pool());
+  vector_size_t* rawRepeatedIndices =
+      repeatedIndices->asMutable<vector_size_t>();
+
+  const bool generateMarker = withMarker_ && range.hasEmptyUnnestValue;
+  vector_size_t index{0};
+  VELOX_CHECK_GT(range.numInputRows, 0);
   // Record the row number to process.
-  range.forEachRow(
-      [&](vector_size_t row, vector_size_t /*start*/, vector_size_t size) {
-        std::fill(
-            rawRepeatedIndices + index, rawRepeatedIndices + index + size, row);
-        index += size;
-      },
-      rawMaxSizes_,
-      firstRowStart_);
+  if (generateMarker) {
+    range.forEachRow(
+        [&](vector_size_t row, vector_size_t /*start*/, vector_size_t size) {
+          if (FOLLY_UNLIKELY(size == 0)) {
+            rawRepeatedIndices[index++] = row;
+          } else {
+            std::fill(
+                rawRepeatedIndices + index,
+                rawRepeatedIndices + index + size,
+                row);
+            index += size;
+          }
+        },
+        rawMaxSizes_,
+        firstInnerRowStart_);
+  } else {
+    range.forEachRow(
+        [&](vector_size_t row, vector_size_t /*start*/, vector_size_t size) {
+          std::fill(
+              rawRepeatedIndices + index,
+              rawRepeatedIndices + index + size,
+              row);
+          index += size;
+        },
+        rawMaxSizes_,
+        firstInnerRowStart_);
+  }
 
   // Wrap "replicated" columns in a dictionary using 'repeatedIndices'.
   for (const auto& projection : identityProjections_) {
     outputs.at(projection.outputChannel) = BaseVector::wrapInDictionary(
-        nullptr /*nulls*/,
+        /*nulls=*/nullptr,
         repeatedIndices,
-        range.numElements,
+        range.numInnerRows,
         input_->childAt(projection.inputChannel));
   }
 }
@@ -216,11 +282,11 @@ void Unnest::generateRepeatedColumns(
 const Unnest::UnnestChannelEncoding Unnest::generateEncodingForChannel(
     column_index_t channel,
     const RowRange& range) {
-  BufferPtr elementIndices = allocateIndices(range.numElements, pool());
-  auto* rawElementIndices = elementIndices->asMutable<vector_size_t>();
+  BufferPtr innerRowIndices = allocateIndices(range.numInnerRows, pool());
+  auto* rawInnerRowIndices = innerRowIndices->asMutable<vector_size_t>();
 
-  auto nulls = allocateNulls(range.numElements, pool());
-  auto rawNulls = nulls->asMutable<uint64_t>();
+  auto nulls = allocateNulls(range.numInnerRows, pool());
+  auto* rawNulls = nulls->asMutable<uint64_t>();
 
   auto& currentDecoded = unnestDecoded_[channel];
   auto* currentSizes = rawSizes_[channel];
@@ -230,12 +296,15 @@ const Unnest::UnnestChannelEncoding Unnest::generateEncodingForChannel(
   // Make dictionary index for elements column since they may be out of order.
   vector_size_t index = 0;
   bool identityMapping = true;
-  VELOX_DCHECK_GT(range.size, 0);
+  VELOX_DCHECK_GT(range.numInputRows, 0);
 
   range.forEachRow(
       [&](vector_size_t row, vector_size_t start, vector_size_t size) {
         const auto end = start + size;
-        if (!currentDecoded.isNullAt(row)) {
+        if (size == 0 && withMarker_) {
+          identityMapping = false;
+          bits::setNull(rawNulls, index++, true);
+        } else if (!currentDecoded.isNullAt(row)) {
           const auto offset = currentOffsets[currentIndices[row]];
           const auto unnestSize = currentSizes[currentIndices[row]];
           // The 'identityMapping' is false when there exists a partially
@@ -244,47 +313,100 @@ const Unnest::UnnestChannelEncoding Unnest::generateEncodingForChannel(
               unnestSize < end) {
             identityMapping = false;
           }
-          auto currentUnnestSize = std::min(end, unnestSize);
-          for (auto i = start; i < currentUnnestSize; i++) {
-            rawElementIndices[index++] = offset + i;
+          const auto currentUnnestSize = std::min(end, unnestSize);
+          for (auto i = start; i < currentUnnestSize; ++i) {
+            rawInnerRowIndices[index++] = offset + i;
           }
-
           for (auto i = std::max(start, currentUnnestSize); i < end; ++i) {
             bits::setNull(rawNulls, index++, true);
           }
         } else if (size > 0) {
           identityMapping = false;
-
           for (auto i = start; i < end; ++i) {
             bits::setNull(rawNulls, index++, true);
           }
         }
       },
       rawMaxSizes_,
-      firstRowStart_);
+      firstInnerRowStart_);
 
-  return {elementIndices, nulls, identityMapping};
+  return {innerRowIndices, nulls, identityMapping};
 }
 
 VectorPtr Unnest::generateOrdinalityVector(const RowRange& range) {
+  VELOX_DCHECK_GT(range.numInputRows, 0);
+
   auto ordinalityVector = BaseVector::create<FlatVector<int64_t>>(
-      BIGINT(), range.numElements, pool());
+      BIGINT(), range.numInnerRows, 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();
+  const bool hasMarker = withMarker_ && range.hasEmptyUnnestValue;
+  if (!hasMarker) {
+    range.forEachRow(
+        [&](vector_size_t /*row*/, vector_size_t start, vector_size_t size) {
+          std::iota(rawOrdinality, rawOrdinality + size, start + 1);
+          rawOrdinality += size;
+        },
+        rawMaxSizes_,
+        firstInnerRowStart_);
+  } else {
+    range.forEachRow(
+        [&](vector_size_t /*row*/, vector_size_t start, vector_size_t size) {
+          if (FOLLY_LIKELY(size > 0)) {
+            std::iota(rawOrdinality, rawOrdinality + size, start + 1);
+            rawOrdinality += size;
+          } else {
+            // Set ordinality to 0 for output row with empty unnest value.
+            //
+            // NOTE: for non-empty unnest value row, the ordinality starts
+            // from 1.
+            VELOX_DCHECK_EQ(size, 0);
+            *rawOrdinality++ = 0;
+          }
+        },
+        rawMaxSizes_,
+        firstInnerRowStart_);
+  }
+  return ordinalityVector;
+}
 
-  VELOX_DCHECK_GT(range.size, 0);
+VectorPtr Unnest::generateMarkerVector(const RowRange& range) {
+  VELOX_CHECK(withMarker_);
+  VELOX_DCHECK_GT(range.numInputRows, 0);
 
+  if (!range.hasEmptyUnnestValue) {
+    return BaseVector::createConstant(
+        BOOLEAN(), true, range.numInnerRows, pool());
+  }
+
+  // Create a vector with all elements set to true initially assuming most
+  // output rows have non-empty unnest values.
+  auto markerBuffer =
+      velox::AlignedBuffer::allocate<bool>(range.numInnerRows, pool(), true);
+  auto markerVector = std::make_shared<velox::FlatVector<bool>>(
+      pool(),
+      /*type=*/BOOLEAN(),
+      /*nulls=*/nullptr,
+      range.numInnerRows,
+      /*values=*/std::move(markerBuffer),
+      /*stringBuffers=*/std::vector<velox::BufferPtr>{});
+  // Set each output row with empty unnest values to false.
+  auto* const rawMarker = markerVector->mutableRawValues<uint64_t>();
+  size_t index{0};
   range.forEachRow(
       [&](vector_size_t /*row*/, vector_size_t start, vector_size_t size) {
-        std::iota(rawOrdinality, rawOrdinality + size, start + 1);
-        rawOrdinality += size;
+        if (size > 0) {
+          index += size;
+        } else {
+          VELOX_DCHECK_EQ(size, 0);
+          bits::setBit(rawMarker, index++, false);
+        }
       },
       rawMaxSizes_,
-      firstRowStart_);
-
-  return ordinalityVector;
+      firstInnerRowStart_);
+  return markerVector;
 }
 
 RowVectorPtr Unnest::generateOutput(const RowRange& range) {
@@ -292,39 +414,42 @@ RowVectorPtr Unnest::generateOutput(const RowRange& range) {
   generateRepeatedColumns(range, outputs);
 
   // Create unnest columns.
-  vector_size_t outputsIndex = identityProjections_.size();
+  column_index_t outputColumnIndex = identityProjections_.size();
   for (auto channel = 0; channel < unnestChannels_.size(); ++channel) {
     const auto unnestChannelEncoding =
         generateEncodingForChannel(channel, range);
 
-    auto& currentDecoded = unnestDecoded_[channel];
+    const auto& currentDecoded = unnestDecoded_[channel];
     if (currentDecoded.base()->typeKind() == TypeKind::ARRAY) {
       // Construct unnest column using Array elements wrapped using above
       // created dictionary.
       const auto* unnestBaseArray = currentDecoded.base()->as<ArrayVector>();
-      outputs[outputsIndex++] = unnestChannelEncoding.wrap(
-          unnestBaseArray->elements(), range.numElements);
+      outputs[outputColumnIndex++] = unnestChannelEncoding.wrap(
+          unnestBaseArray->elements(), range.numInnerRows);
     } else {
       // Construct two unnest columns for Map keys and values vectors wrapped
       // using above created dictionary.
       const auto* unnestBaseMap = currentDecoded.base()->as<MapVector>();
-      outputs[outputsIndex++] = unnestChannelEncoding.wrap(
-          unnestBaseMap->mapKeys(), range.numElements);
-      outputs[outputsIndex++] = unnestChannelEncoding.wrap(
-          unnestBaseMap->mapValues(), range.numElements);
+      outputs[outputColumnIndex++] = unnestChannelEncoding.wrap(
+          unnestBaseMap->mapKeys(), range.numInnerRows);
+      outputs[outputColumnIndex++] = unnestChannelEncoding.wrap(
+          unnestBaseMap->mapValues(), range.numInnerRows);
     }
   }
 
+  // 'Ordinality' and 'EmptyUnnestValue' columns are always at the end.
   if (withOrdinality_) {
-    // Ordinality column is always at the end.
-    outputs.back() = generateOrdinalityVector(range);
+    outputs[outputColumnIndex++] = generateOrdinalityVector(range);
+  }
+  if (withMarker_) {
+    outputs[outputColumnIndex++] = generateMarkerVector(range);
   }
 
   return std::make_shared<RowVector>(
       pool(),
       outputType_,
-      BufferPtr(nullptr),
-      range.numElements,
+      /*nulls=*/nullptr,
+      range.numInnerRows,
       std::move(outputs));
 }
 
@@ -332,7 +457,11 @@ VectorPtr Unnest::UnnestChannelEncoding::wrap(
     const VectorPtr& base,
     vector_size_t wrapSize) const {
   if (identityMapping) {
-    return base;
+    if (wrapSize == base->size()) {
+      return base;
+    }
+    auto* rawIndices = indices->asMutable<vector_size_t>();
+    return base->slice(rawIndices[0], wrapSize);
   }
 
   const auto result =
@@ -360,29 +489,31 @@ bool Unnest::isFinished() {
 }
 
 void Unnest::RowRange::forEachRow(
-    std::function<void(
+    const std::function<void(
         vector_size_t /*row*/,
         vector_size_t /*start*/,
-        vector_size_t /*size*/)> func,
-    const vector_size_t* const rawMaxSizes,
-    vector_size_t firstRowStart) const {
+        vector_size_t /*size*/)>& func,
+    const vector_size_t* rawMaxSizes,
+    vector_size_t firstInnerRowStart) const {
   // Process the first row.
-  const auto firstRowEnd = size == 1 && lastRowEnd.has_value()
-      ? lastRowEnd.value()
-      : rawMaxSizes[start];
-  func(start, firstRowStart, firstRowEnd - firstRowStart);
+  const auto firstInnerRowEnd = numInputRows == 1 && lastInnerRowEnd.has_value()
+      ? lastInnerRowEnd.value()
+      : rawMaxSizes[startInputRow];
+  func(
+      startInputRow, firstInnerRowStart, firstInnerRowEnd - firstInnerRowStart);
 
+  const auto lastInputRow = startInputRow + numInputRows - 1;
   // Process the middle rows.
-  for (auto row = start + 1; row < start + size - 1; ++row) {
-    func(row, 0, rawMaxSizes[row]);
+  for (auto inputRow = startInputRow + 1; inputRow < lastInputRow; ++inputRow) {
+    func(inputRow, 0, rawMaxSizes[inputRow]);
   }
 
   // Process the last row if exists.
-  if (size > 1) {
-    if (lastRowEnd.has_value()) {
-      func(start + size - 1, 0, lastRowEnd.value());
+  if (numInputRows > 1) {
+    if (lastInnerRowEnd.has_value()) {
+      func(lastInputRow, 0, lastInnerRowEnd.value());
     } else {
-      func(start + size - 1, 0, rawMaxSizes[start + size - 1]);
+      func(lastInputRow, 0, rawMaxSizes[lastInputRow]);
     }
   }
 }
diff --git a/velox/exec/Unnest.h b/velox/exec/Unnest.h
index e67dd6ed875f..e1fb967525c3 100644
--- a/velox/exec/Unnest.h
+++ b/velox/exec/Unnest.h
@@ -46,21 +46,20 @@ class Unnest : public Operator {
   void maybeFinishDrain();
 
   // Represents the range of rows to process and indicates that the first and
-  // last
-  // rows may need to be processed partially to match the configured output
+  // last rows may need to be processed partially to match the configured output
   // batch size. When processing a single row, the range is from
-  // 'firstRowStart_' to 'lastRowEnd'. For multiple rows, the range for the
-  // first row is from 'firstRowStart_' to 'rawMaxSizes_[firstRow]', and for the
-  // last row, it is from 0 to 'lastRowEnd', unless the last row is processed
-  // fully, in which case' rawMaxSizes_[lastRow]' is used as the end of the last
-  // row.
+  // 'firstInnerRowStart_' to 'lastRowEnd'. For multiple rows, the range for the
+  // first row is from 'firstInnerRowStart_' to 'rawMaxSizes_[firstRow]', and
+  // for the last row, it is from 0 to 'lastRowEnd', unless the last row is
+  // processed fully, in which case' rawMaxSizes_[lastRow]' is used as the end
+  // of the last row.
   //
   // Single row:
-  //    firstRowStart_  firstRowEnd = lastRowEnd
+  //    firstInnerRowStart_  firstRowEnd = lastRowEnd
   //---|----------------|--- start, size = 1
   //
   // Multiple rows:
-  //    firstRowStart_     firstRowEnd = rawMaxSizes_[start]
+  //    firstInnerRowStart_     firstRowEnd = rawMaxSizes_[start]
   //---|-------------------| start
   //-----------------------
   //-----------------------
@@ -73,34 +72,40 @@ class Unnest : public Operator {
     // number in the '[start, start + size)' range, 'start' is the row number to
     // start processing, and 'size' is the number of rows to process..
     // @param rawMaxSizes Used to compute the end of each row.
-    // @param firstRowStart The index to start processing the first row. Same
-    // with Unnest member firstRowStart_.
+    // @param firstInnerRowStart The index to start processing the first row.
+    // Same with Unnest member firstInnerRowStart_.
     void forEachRow(
-        std::function<void(
+        const std::function<void(
             vector_size_t /*row*/,
             vector_size_t /*start*/,
-            vector_size_t /*size*/)> func,
-        const vector_size_t* const rawMaxSizes,
-        vector_size_t firstRowStart) const;
+            vector_size_t /*size*/)>& func,
+        const vector_size_t* rawMaxSizes,
+        vector_size_t firstInnerRowStart) const;
 
-    // First input row to be included in the output.
-    const vector_size_t start;
+    // First input row in 'input_' to be included in the output.
+    const vector_size_t startInputRow;
 
-    // Number of input rows to be included in the output.
-    const vector_size_t size;
+    // Number of input rows to be included in the output starting from
+    // 'startInputRow'.
+    const vector_size_t numInputRows;
 
-    // The processing of the last input row starts at index 'firstRowStart_' or
-    // 0, depending on whether it is the first row being processed, and ends at
-    // 'lastRowEnd'. It is nullopt when the last row is processed completely.
-    const std::optional<vector_size_t> lastRowEnd;
+    // The processing of the last input row starts at index
+    // 'firstInnerRowStart_' or 0, depending on whether it is the first row
+    // being processed, and ends at 'lastRowEnd'. It is nullopt when the last
+    // row is processed completely.
+    const std::optional<vector_size_t> lastInnerRowEnd;
 
     // Total number of inner rows in the range.
-    const vector_size_t numElements;
+    const vector_size_t numInnerRows;
+
+    // True if the range has input row in which all the unnest columns are
+    // either null or empty.
+    const bool hasEmptyUnnestValue;
   };
 
   // Extract the range of rows to process.
   // @param size The size of input RowVector.
-  RowRange extractRowRange(vector_size_t size) const;
+  RowRange extractRowRange(vector_size_t inputSize) const;
 
   // Generate output for 'rowRange' represented rows.
   // @param rowRange Range of rows to process.
@@ -129,18 +134,27 @@ class Unnest : public Operator {
   // Invoked by generateOutput for the ordinality column.
   VectorPtr generateOrdinalityVector(const RowRange& rowRange);
 
+  // Invoked by generateOutput for the marker column.
+  VectorPtr generateMarkerVector(const RowRange& rowRange);
+
+  // Invoked when finish one input batch processing to reset the internal
+  // execution state for the next batch.
+  void finishInput();
+
   const bool withOrdinality_;
+  const bool withMarker_;
+  // The maximum number of output batch rows.
+  const vector_size_t maxOutputSize_;
+
   std::vector<column_index_t> unnestChannels_;
 
   std::vector<DecodedVector> unnestDecoded_;
 
-  // The maximum number of output batch rows.
-  const uint32_t maxOutputSize_;
   BufferPtr maxSizes_;
   vector_size_t* rawMaxSizes_{nullptr};
 
   // The index to start processing the first row.
-  vector_size_t firstRowStart_ = 0;
+  vector_size_t firstInnerRowStart_{0};
 
   std::vector<const vector_size_t*> rawSizes_;
   std::vector<const vector_size_t*> rawOffsets_;
diff --git a/velox/exec/Values.cpp b/velox/exec/Values.cpp
index 2660732979ae..dc544fba799e 100644
--- a/velox/exec/Values.cpp
+++ b/velox/exec/Values.cpp
@@ -45,8 +45,9 @@ void Values::initialize() {
         // 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->testingCopyPreserveEncodings()));
+        values_.emplace_back(
+            std::static_pointer_cast<RowVector>(
+                vector->testingCopyPreserveEncodings()));
       } else {
         values_.emplace_back(vector);
       }
diff --git a/velox/exec/VectorHasher.cpp b/velox/exec/VectorHasher.cpp
index dc4c921fb035..18d00146ed72 100644
--- a/velox/exec/VectorHasher.cpp
+++ b/velox/exec/VectorHasher.cpp
@@ -23,32 +23,35 @@
 
 namespace facebook::velox::exec {
 
-#define VALUE_ID_TYPE_DISPATCH(TEMPLATE_FUNC, typeKind, ...)             \
-  [&]() {                                                                \
-    switch (typeKind) {                                                  \
-      case TypeKind::BOOLEAN: {                                          \
-        return TEMPLATE_FUNC<TypeKind::BOOLEAN>(__VA_ARGS__);            \
-      }                                                                  \
-      case TypeKind::TINYINT: {                                          \
-        return TEMPLATE_FUNC<TypeKind::TINYINT>(__VA_ARGS__);            \
-      }                                                                  \
-      case TypeKind::SMALLINT: {                                         \
-        return TEMPLATE_FUNC<TypeKind::SMALLINT>(__VA_ARGS__);           \
-      }                                                                  \
-      case TypeKind::INTEGER: {                                          \
-        return TEMPLATE_FUNC<TypeKind::INTEGER>(__VA_ARGS__);            \
-      }                                                                  \
-      case TypeKind::BIGINT: {                                           \
-        return TEMPLATE_FUNC<TypeKind::BIGINT>(__VA_ARGS__);             \
-      }                                                                  \
-      case TypeKind::VARCHAR:                                            \
-      case TypeKind::VARBINARY: {                                        \
-        return TEMPLATE_FUNC<TypeKind::VARCHAR>(__VA_ARGS__);            \
-      }                                                                  \
-      default:                                                           \
-        VELOX_UNREACHABLE(                                               \
-            "Unsupported value ID type: ", mapTypeKindToName(typeKind)); \
-    }                                                                    \
+#define VALUE_ID_TYPE_DISPATCH(TEMPLATE_FUNC, typeKind, ...)                \
+  [&]() {                                                                   \
+    switch (typeKind) {                                                     \
+      case TypeKind::BOOLEAN: {                                             \
+        return TEMPLATE_FUNC<TypeKind::BOOLEAN>(__VA_ARGS__);               \
+      }                                                                     \
+      case TypeKind::TINYINT: {                                             \
+        return TEMPLATE_FUNC<TypeKind::TINYINT>(__VA_ARGS__);               \
+      }                                                                     \
+      case TypeKind::SMALLINT: {                                            \
+        return TEMPLATE_FUNC<TypeKind::SMALLINT>(__VA_ARGS__);              \
+      }                                                                     \
+      case TypeKind::INTEGER: {                                             \
+        return TEMPLATE_FUNC<TypeKind::INTEGER>(__VA_ARGS__);               \
+      }                                                                     \
+      case TypeKind::BIGINT: {                                              \
+        return TEMPLATE_FUNC<TypeKind::BIGINT>(__VA_ARGS__);                \
+      }                                                                     \
+      case TypeKind::VARCHAR:                                               \
+      case TypeKind::VARBINARY: {                                           \
+        return TEMPLATE_FUNC<TypeKind::VARCHAR>(__VA_ARGS__);               \
+      }                                                                     \
+      case TypeKind::TIMESTAMP: {                                           \
+        return TEMPLATE_FUNC<TypeKind::TIMESTAMP>(__VA_ARGS__);             \
+      }                                                                     \
+      default:                                                              \
+        VELOX_UNREACHABLE(                                                  \
+            "Unsupported value ID type: ", TypeKindName::toName(typeKind)); \
+    }                                                                       \
   }()
 
 namespace {
@@ -82,7 +85,6 @@ void VectorHasher::hashValues(
     const SelectivityVector& rows,
     bool mix,
     uint64_t* result) {
-  using T = typename TypeTraits<Kind>::NativeType;
   if (decoded_.isConstantMapping()) {
     auto hash = decoded_.isNullAt(rows.begin())
         ? kNullHash
@@ -349,6 +351,8 @@ bool VectorHasher::makeValueIdsDecoded<bool, false>(
 bool VectorHasher::computeValueIds(
     const SelectivityVector& rows,
     raw_vector<uint64_t>& result) {
+  checkTypeSupportsValueIds();
+
   return VALUE_ID_TYPE_DISPATCH(makeValueIds, typeKind_, rows, result.data());
 }
 
@@ -359,6 +363,8 @@ bool VectorHasher::computeValueIdsForRows(
     int32_t nullByte,
     uint8_t nullMask,
     raw_vector<uint64_t>& result) {
+  checkTypeSupportsValueIds();
+
   return VALUE_ID_TYPE_DISPATCH(
       makeValueIdsForRows,
       typeKind_,
@@ -531,6 +537,8 @@ void VectorHasher::lookupValueIds(
     SelectivityVector& rows,
     ScratchMemory& scratchMemory,
     raw_vector<uint64_t>& result) const {
+  checkTypeSupportsValueIds();
+
   scratchMemory.decoded.decode(values, rows);
   VALUE_ID_TYPE_DISPATCH(
       lookupValueIdsTyped,
@@ -550,7 +558,7 @@ void VectorHasher::hash(
       result[row] = mix ? bits::hashMix(result[row], kNullHash) : kNullHash;
     });
   } else {
-    if (type_->providesCustomComparison()) {
+    if (typeProvidesCustomComparison_) {
       VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
           hashValues, true, typeKind_, rows, mix, result.data());
     } else {
@@ -579,7 +587,7 @@ void VectorHasher::precompute(const BaseVector& value) {
   const SelectivityVector rows(1, true);
   decoded_.decode(value, rows);
 
-  if (type_->providesCustomComparison()) {
+  if (typeProvidesCustomComparison_) {
     precomputedHash_ = VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH(
         hashOne, true, typeKind_, decoded_, 0);
   } else {
@@ -594,6 +602,8 @@ void VectorHasher::analyze(
     int32_t offset,
     int32_t nullByte,
     uint8_t nullMask) {
+  checkTypeSupportsValueIds();
+
   VALUE_ID_TYPE_DISPATCH(
       analyzeTyped, typeKind_, groups, numGroups, offset, nullByte, nullMask);
 }
@@ -666,6 +676,10 @@ void VectorHasher::setRangeOverflow() {
 
 std::unique_ptr<common::Filter> VectorHasher::getFilter(
     bool nullAllowed) const {
+  if (typeProvidesCustomComparison_) {
+    return nullptr;
+  }
+
   switch (typeKind_) {
     case TypeKind::TINYINT:
       [[fallthrough]];
@@ -736,6 +750,7 @@ void extendRange(
     case TypeKind::BIGINT:
     case TypeKind::VARCHAR:
     case TypeKind::VARBINARY:
+    case TypeKind::TIMESTAMP:
       extendRange<int64_t>(reserve, min, max);
       break;
 
@@ -764,6 +779,12 @@ void VectorHasher::cardinality(
     int32_t reservePct,
     uint64_t& asRange,
     uint64_t& asDistincts) {
+  if (!typeSupportsValueIds()) {
+    asRange = kRangeTooLarge;
+    asDistincts = kRangeTooLarge;
+    return;
+  }
+
   if (typeKind_ == TypeKind::BOOLEAN) {
     hasRange_ = true;
     asRange = 3;
@@ -805,6 +826,8 @@ uint64_t VectorHasher::enableValueIds(uint64_t multiplier, int32_t reservePct) {
       typeKind_,
       TypeKind::BOOLEAN,
       "A boolean VectorHasher should  always be by range");
+  checkTypeSupportsValueIds();
+
   multiplier_ = multiplier;
   rangeSize_ = addIdReserve(uniqueValues_.size(), reservePct) + 1;
   isRange_ = false;
@@ -818,6 +841,8 @@ uint64_t VectorHasher::enableValueIds(uint64_t multiplier, int32_t reservePct) {
 uint64_t VectorHasher::enableValueRange(
     uint64_t multiplier,
     int32_t reservePct) {
+  checkTypeSupportsValueIds();
+
   multiplier_ = multiplier;
   VELOX_CHECK_LE(0, reservePct);
   VELOX_CHECK(hasRange_);
@@ -846,7 +871,7 @@ void VectorHasher::copyStatsFrom(const VectorHasher& other) {
   uniqueValues_ = other.uniqueValues_;
 }
 
-void VectorHasher::merge(const VectorHasher& other) {
+void VectorHasher::merge(const VectorHasher& other, size_t maxNumDistinct) {
   if (typeKind_ == TypeKind::BOOLEAN) {
     return;
   }
@@ -864,18 +889,25 @@ void VectorHasher::merge(const VectorHasher& other) {
   } else {
     setRangeOverflow();
   }
-  if (!distinctOverflow_ && !other.distinctOverflow_) {
-    // Unique values can be merged without dispatch on type. All the
-    // merged hashers must stay live for string type columns.
-    for (UniqueValue value : other.uniqueValues_) {
-      // Assign a new id at end of range for the case 'value' is not
-      // in 'uniqueValues_'. We do not set overflow here because the
-      // memory is already allocated and there is a known cap on size.
-      value.setId(uniqueValues_.size() + 1);
-      uniqueValues_.insert(value);
-    }
-  } else {
+  if (distinctOverflow_) {
+    return;
+  }
+  if (other.distinctOverflow_) {
     setDistinctOverflow();
+    return;
+  }
+  // Unique values can be merged without dispatch on type. All the
+  // merged hashers must stay live for string type columns.
+  for (UniqueValue value : other.uniqueValues_) {
+    // Assign a new id at end of range for the case 'value' is not
+    // in 'uniqueValues_'. We do not set overflow here because the
+    // memory is already allocated and there is a known cap on size.
+    value.setId(uniqueValues_.size() + 1);
+    if (uniqueValues_.insert(value).second &&
+        uniqueValues_.size() > maxNumDistinct) {
+      setDistinctOverflow();
+      break;
+    }
   }
 }
 
diff --git a/velox/exec/VectorHasher.h b/velox/exec/VectorHasher.h
index 6a18df611735..29628099c17e 100644
--- a/velox/exec/VectorHasher.h
+++ b/velox/exec/VectorHasher.h
@@ -131,8 +131,15 @@ class VectorHasher {
   static constexpr int32_t kNoLimit = -1;
 
   VectorHasher(TypePtr type, column_index_t channel)
-      : channel_(channel), type_(std::move(type)), typeKind_(type_->kind()) {
-    if (typeKind_ == TypeKind::BOOLEAN) {
+      : channel_(channel),
+        type_(std::move(type)),
+        typeKind_(type_->kind()),
+        typeProvidesCustomComparison_(type_->providesCustomComparison()) {
+    if (!typeSupportsValueIds()) {
+      // Ensure any range or unique value based hashing is disabled.
+      setRangeOverflow();
+      setDistinctOverflow();
+    } else if (typeKind_ == TypeKind::BOOLEAN) {
       // We do not need samples to know the cardinality or limits of a bool
       // vector.
       hasRange_ = true;
@@ -235,15 +242,39 @@ class VectorHasher {
       ScratchMemory& scratchMemory,
       raw_vector<uint64_t>& result) const;
 
-  // Returns true if either range or distinct values have not overflowed.
+  // Returns true if either range or distinct values have not overflowed and the
+  // type doesn't support custom comparison.
   bool mayUseValueIds() const {
-    return hasRange_ || !distinctOverflow_;
+    return typeSupportsValueIds() && (hasRange_ || !distinctOverflow_);
   }
 
   // Returns an instance of the filter corresponding to a set of unique values.
   // Returns null if distinctOverflow_ is true.
   std::unique_ptr<common::Filter> getFilter(bool nullAllowed) const;
 
+  bool supportsBloomFilter() const {
+    if (typeProvidesCustomComparison_) {
+      return false;
+    }
+    switch (typeKind_) {
+      // Smaller integers would never overflow 100'000 distinct values.
+      case TypeKind::INTEGER:
+      case TypeKind::BIGINT:
+        return distinctOverflow_;
+      default:
+        return false;
+    }
+  }
+
+  void setBloomFilter(common::FilterPtr filter) {
+    VELOX_DCHECK(supportsBloomFilter());
+    bloomFilter_ = std::move(filter);
+  }
+
+  const common::FilterPtr& getBloomFilter() const {
+    return bloomFilter_;
+  }
+
   void resetStats() {
     uniqueValues_.clear();
     uniqueValuesStorage_.clear();
@@ -284,8 +315,12 @@ class VectorHasher {
     return isRange_;
   }
 
-  static bool typeKindSupportsValueIds(TypeKind kind) {
-    switch (kind) {
+  bool typeSupportsValueIds() const {
+    if (typeProvidesCustomComparison_) {
+      return false;
+    }
+
+    switch (typeKind_) {
       case TypeKind::BOOLEAN:
       case TypeKind::TINYINT:
       case TypeKind::SMALLINT:
@@ -293,6 +328,7 @@ class VectorHasher {
       case TypeKind::BIGINT:
       case TypeKind::VARCHAR:
       case TypeKind::VARBINARY:
+      case TypeKind::TIMESTAMP:
         return true;
       default:
         return false;
@@ -301,7 +337,7 @@ class VectorHasher {
 
   // Merges the value ids information of 'other' into 'this'. Ranges
   // and distinct values are unioned.
-  void merge(const VectorHasher& other);
+  void merge(const VectorHasher& other, size_t maxNumDistinct);
 
   // true if no values have been added.
   bool empty() const {
@@ -332,6 +368,10 @@ class VectorHasher {
     return value;
   }
 
+  inline int64_t toInt64(Timestamp timestamp) const {
+    return timestamp.toMillis();
+  }
+
   // Sets the data statistics from 'other'. Does not set the mapping mode.
   void copyStatsFrom(const VectorHasher& other);
 
@@ -530,6 +570,13 @@ class VectorHasher {
 
   void setRangeOverflow();
 
+  inline void checkTypeSupportsValueIds() const {
+    VELOX_DCHECK(
+        typeSupportsValueIds(),
+        "Value IDs cannot be used, the type {} is not supported.",
+        type_->toString());
+  }
+
   static inline bool
   isNullAt(const char* group, int32_t nullByte, uint8_t nullMask) {
     return (group[nullByte] & nullMask) != 0;
@@ -546,6 +593,7 @@ class VectorHasher {
   const column_index_t channel_;
   const TypePtr type_;
   const TypeKind typeKind_;
+  const bool typeProvidesCustomComparison_;
 
   DecodedVector decoded_;
   raw_vector<uint64_t> cachedHashes_;
@@ -582,6 +630,8 @@ class VectorHasher {
   // Memory for unique string values.
   std::vector<std::string> uniqueValuesStorage_;
   uint64_t distinctStringsBytes_ = 0;
+
+  common::FilterPtr bloomFilter_;
 };
 
 template <>
@@ -661,10 +711,29 @@ inline uint64_t VectorHasher::lookupValueId(StringView value) const {
   return kUnmappable;
 }
 
+template <>
+inline uint64_t VectorHasher::lookupValueId(Timestamp timestamp) const {
+  return timestamp.getNanos() % 1'000'000 != 0
+      ? kUnmappable
+      : lookupValueId(timestamp.toMillis());
+}
+
 template <>
 inline uint64_t VectorHasher::valueId(bool value) {
   return value ? 2 : 1;
 }
+template <>
+inline uint64_t VectorHasher::valueId(Timestamp value) {
+  if (FOLLY_UNLIKELY(
+          value.getNanos() % Timestamp::kNanosecondsInMillisecond != 0)) {
+    // The timestamp is in nanosecond or microsecond precision. The values are
+    // not mappable to milliseconds without precision loss.
+    setRangeOverflow();
+    setDistinctOverflow();
+    return kUnmappable;
+  }
+  return valueId(value.toMillis());
+}
 
 template <>
 inline bool VectorHasher::tryMapToRange(
diff --git a/velox/exec/Window.cpp b/velox/exec/Window.cpp
index 1f1a91331a95..358290b4e92c 100644
--- a/velox/exec/Window.cpp
+++ b/velox/exec/Window.cpp
@@ -18,10 +18,22 @@
 #include "velox/exec/PartitionStreamingWindowBuild.h"
 #include "velox/exec/RowsStreamingWindowBuild.h"
 #include "velox/exec/SortWindowBuild.h"
+#include "velox/exec/SubPartitionedSortWindowBuild.h"
 #include "velox/exec/Task.h"
 
 namespace facebook::velox::exec {
 
+namespace {
+common::PrefixSortConfig makePrefixSortConfig(
+    const core::QueryConfig& queryConfig) {
+  return common::PrefixSortConfig{
+      queryConfig.prefixSortNormalizedKeyMaxBytes(),
+      queryConfig.prefixSortMinRows(),
+      queryConfig.prefixSortMaxStringPrefixLength()};
+}
+
+} // namespace
+
 Window::Window(
     int32_t operatorId,
     DriverCtx* driverCtx,
@@ -55,16 +67,28 @@ Window::Window(
           windowNode, pool(), spillConfig, &nonReclaimableSection_);
     }
   } else {
-    windowBuild_ = std::make_unique<SortWindowBuild>(
-        windowNode,
-        pool(),
-        common::PrefixSortConfig{
-            driverCtx->queryConfig().prefixSortNormalizedKeyMaxBytes(),
-            driverCtx->queryConfig().prefixSortMinRows(),
-            driverCtx->queryConfig().prefixSortMaxStringPrefixLength()},
-        spillConfig,
-        &nonReclaimableSection_,
-        &spillStats_);
+    if (auto numSubPartitions =
+            operatorCtx_->driverCtx()->queryConfig().windowNumSubPartitions();
+        numSubPartitions > 1) {
+      windowBuild_ = std::make_unique<SubPartitionedSortWindowBuild>(
+          windowNode,
+          numSubPartitions,
+          pool(),
+          makePrefixSortConfig(driverCtx->queryConfig()),
+          spillConfig,
+          &nonReclaimableSection_,
+          &stats_,
+          spillStats_.get());
+    } else {
+      windowBuild_ = std::make_unique<SortWindowBuild>(
+          windowNode,
+          pool(),
+          makePrefixSortConfig(driverCtx->queryConfig()),
+          spillConfig,
+          &nonReclaimableSection_,
+          &stats_,
+          spillStats_.get());
+    }
   }
 }
 
@@ -159,10 +183,11 @@ Window::WindowFrame Window::createWindowFrame(
       return std::make_optional(
           FrameChannelArg{kConstantChannel, nullptr, value});
     } else {
-      return std::make_optional(FrameChannelArg{
-          frameChannel,
-          BaseVector::create(frame->type(), 0, pool()),
-          std::nullopt});
+      return std::make_optional(
+          FrameChannelArg{
+              frameChannel,
+              BaseVector::create(frame->type(), 0, pool()),
+              std::nullopt});
     }
   };
 
@@ -196,14 +221,15 @@ void Window::createWindowFunctions() {
       }
     }
 
-    windowFunctions_.push_back(WindowFunction::create(
-        windowNodeFunction.functionCall->name(),
-        functionArgs,
-        windowNodeFunction.functionCall->type(),
-        windowNodeFunction.ignoreNulls,
-        operatorCtx_->pool(),
-        &stringAllocator_,
-        operatorCtx_->driverCtx()->queryConfig()));
+    windowFunctions_.push_back(
+        WindowFunction::create(
+            windowNodeFunction.functionCall->name(),
+            functionArgs,
+            windowNodeFunction.functionCall->type(),
+            windowNodeFunction.ignoreNulls,
+            operatorCtx_->pool(),
+            &stringAllocator_,
+            operatorCtx_->driverCtx()->queryConfig()));
 
     windowFrames_.push_back(
         createWindowFrame(windowNode_, windowNodeFunction.frame, inputType));
@@ -686,6 +712,9 @@ RowVectorPtr Window::getOutput() {
 
   const auto numRowsLeft = numRows_ - numProcessedRows_;
   if (numRowsLeft == 0) {
+    if (windowBuild_ != nullptr) {
+      windowBuild_->release();
+    }
     return nullptr;
   }
 
diff --git a/velox/exec/Window.h b/velox/exec/Window.h
index 8cbd3b1ee85c..563169ff4226 100644
--- a/velox/exec/Window.h
+++ b/velox/exec/Window.h
@@ -67,6 +67,11 @@ class Window : public Operator {
   void reclaim(uint64_t targetBytes, memory::MemoryReclaimer::Stats& stats)
       override;
 
+  /// Runtime statistics holding total number of batches read from spilled data.
+  /// 0 if no spilling occurred.
+  static inline const std::string kWindowSpillReadNumBatches{
+      "windowSpillReadNumBatches"};
+
  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
diff --git a/velox/exec/WindowBuild.h b/velox/exec/WindowBuild.h
index 01c470803ed7..b047254c752e 100644
--- a/velox/exec/WindowBuild.h
+++ b/velox/exec/WindowBuild.h
@@ -70,10 +70,18 @@ class WindowBuild {
 
   /// Returns the average size of input rows in bytes stored in the data
   /// container of the WindowBuild.
-  std::optional<int64_t> estimateRowSize() {
+  virtual std::optional<int64_t> estimateRowSize() {
     return data_->estimateRowSize();
   }
 
+  /// Releases the memory held by the window build. This is called by the
+  /// window operator when all rows have been processed.
+  void release() {
+    if (data_) {
+      data_->clear();
+    }
+  }
+
   void setNumRowsPerOutput(vector_size_t numRowsPerOutput) {
     numRowsPerOutput_ = numRowsPerOutput;
   }
diff --git a/velox/exec/benchmarks/AtomicsBench.cpp b/velox/exec/benchmarks/AtomicsBench.cpp
index 74343e9303f2..c86991ef6fcb 100644
--- a/velox/exec/benchmarks/AtomicsBench.cpp
+++ b/velox/exec/benchmarks/AtomicsBench.cpp
@@ -16,16 +16,39 @@
 
 #include <folly/Benchmark.h>
 #include <folly/init/Init.h>
-#include <gtest/gtest.h>
 #include <atomic>
 #include <thread>
 #include <vector>
+#include "velox/common/base/Portability.h"
 #include "velox/exec/OneWayStatusFlag.h"
 
-using namespace ::testing;
-using namespace facebook::velox;
-static const size_t kNumThreads = 88;
-static const size_t kNumIterations = 10000;
+namespace {
+
+using facebook::velox::exec::OneWayStatusFlag;
+constexpr size_t kNumThreads = 88;
+constexpr size_t kNumIterations = 10000;
+
+#if defined(__x86_64__) && !defined(TSAN_BUILD)
+
+class OneWayStatusFlagUnsafe {
+ public:
+  bool check() const {
+    return fastStatus_ || atomicStatus_.load();
+  }
+
+  void set() {
+    if (!fastStatus_) {
+      atomicStatus_.store(true);
+      fastStatus_ = true;
+    }
+  }
+
+ private:
+  bool fastStatus_{false};
+  std::atomic_bool atomicStatus_{false};
+};
+
+#endif
 
 void runParallelUpdates(
     std::function<void(size_t iter)> callback,
@@ -46,12 +69,28 @@ void runParallelUpdates(
   }
 }
 
-BENCHMARK(std_atomic_bool_write) {
-  std::atomic<bool> flag{false};
+BENCHMARK(std_atomic_bool_write_seq_cst) {
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
           flag.store(true);
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
+        }
+      },
+      kNumThreads, // Threads
+      kNumIterations); // Iterations per thread
+}
+
+BENCHMARK(std_atomic_bool_write_release) {
+  std::atomic_bool flag{false};
+  runParallelUpdates(
+      [&](size_t iters) {
+        for (size_t i = 0; i < iters; ++i) {
+          flag.store(true, std::memory_order_release);
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
         }
       },
       kNumThreads, // Threads
@@ -59,76 +98,82 @@ BENCHMARK(std_atomic_bool_write) {
 }
 
 BENCHMARK(std_atomic_bool_write_relaxed) {
-  std::atomic<bool> flag{false};
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
           flag.store(true, std::memory_order_relaxed);
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
-BENCHMARK(std_atomic_bool_read_write_relaxed) {
-  std::atomic<bool> flag{false};
+BENCHMARK(one_way_flag_write) {
+  OneWayStatusFlag flag;
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
-          if (!flag.load(std::memory_order_relaxed)) {
-            flag.store(true, std::memory_order_acq_rel);
-          }
+          flag.set();
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
-BENCHMARK(one_way_flag_write) {
-  exec::OneWayStatusFlag flag;
+#if defined(__x86_64__) && !defined(TSAN_BUILD)
+
+BENCHMARK(one_way_flag_unsafe_write) {
+  OneWayStatusFlagUnsafe flag;
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
           flag.set();
+          bool dummy{};
+          folly::doNotOptimizeAway(dummy);
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
+#endif
+
 // Read Benchmarks
-BENCHMARK(std_atomic_bool_read) {
-  std::atomic<bool> flag{false};
+BENCHMARK(std_atomic_bool_read_seq_cst) {
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
-          folly::doNotOptimizeAway(flag.load());
+          folly::doNotOptimizeAway(flag.load(std::memory_order_seq_cst));
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
-BENCHMARK(std_atomic_bool_relaxed_read) {
-  std::atomic<bool> flag{false};
+BENCHMARK(std_atomic_bool_read_acquire) {
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
-          folly::doNotOptimizeAway(flag.load(std::memory_order_relaxed));
+          folly::doNotOptimizeAway(flag.load(std::memory_order_acquire));
         }
       },
       kNumThreads, // Threads
       kNumIterations); // Iterations per thread
 }
 
-BENCHMARK(std_atomic_bool_read_relaxed_acquire) {
-  std::atomic<bool> flag{false};
+BENCHMARK(std_atomic_bool_read_relaxed) {
+  std::atomic_bool flag{false};
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
-          folly::doNotOptimizeAway(
-              flag.load(std::memory_order_relaxed) ||
-              flag.load(std::memory_order_acquire));
+          folly::doNotOptimizeAway(flag.load(std::memory_order_relaxed));
         }
       },
       kNumThreads, // Threads
@@ -136,7 +181,21 @@ BENCHMARK(std_atomic_bool_read_relaxed_acquire) {
 }
 
 BENCHMARK(one_way_flag_read) {
-  exec::OneWayStatusFlag flag;
+  OneWayStatusFlag flag;
+  runParallelUpdates(
+      [&](size_t iters) {
+        for (size_t i = 0; i < iters; ++i) {
+          folly::doNotOptimizeAway(flag.check());
+        }
+      },
+      kNumThreads, // Threads
+      kNumIterations); // Iterations per thread
+}
+
+#if defined(__x86_64__) && !defined(TSAN_BUILD)
+
+BENCHMARK(one_way_flag_unsafe_read) {
+  OneWayStatusFlagUnsafe flag;
   runParallelUpdates(
       [&](size_t iters) {
         for (size_t i = 0; i < iters; ++i) {
@@ -147,6 +206,10 @@ BENCHMARK(one_way_flag_read) {
       kNumIterations); // Iterations per thread
 }
 
+#endif
+
+} // namespace
+
 int main(int argc, char** argv) {
   folly::Init init(&argc, &argv);
   folly::runBenchmarks();
diff --git a/velox/exec/benchmarks/CMakeLists.txt b/velox/exec/benchmarks/CMakeLists.txt
index 994c7305bcea..e0924182982e 100644
--- a/velox/exec/benchmarks/CMakeLists.txt
+++ b/velox/exec/benchmarks/CMakeLists.txt
@@ -14,8 +14,11 @@
 add_executable(velox_exec_vector_hasher_benchmark VectorHasherBenchmark.cpp)
 
 target_link_libraries(
-  velox_exec_vector_hasher_benchmark velox_exec velox_vector_test_lib
-  Folly::follybenchmark)
+  velox_exec_vector_hasher_benchmark
+  velox_exec
+  velox_vector_test_lib
+  Folly::follybenchmark
+)
 
 add_executable(velox_filter_project_benchmark FilterProjectBenchmark.cpp)
 
@@ -24,7 +27,8 @@ target_link_libraries(
   velox_exec
   velox_vector_test_lib
   velox_exec_test_lib
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
 
 add_executable(velox_exchange_benchmark ExchangeBenchmark.cpp)
 
@@ -33,7 +37,8 @@ target_link_libraries(
   velox_exec
   velox_exec_test_lib
   velox_vector_test_lib
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
 
 add_executable(velox_merge_benchmark MergeBenchmark.cpp)
 
@@ -43,7 +48,8 @@ target_link_libraries(
   velox_vector_test_lib
   Folly::follybenchmark
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_hash_benchmark HashTableBenchmark.cpp)
 
@@ -53,27 +59,39 @@ target_link_libraries(
   velox_exec_test_lib
   velox_profiler
   velox_vector_test_lib
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
 
-add_executable(velox_hash_join_list_result_benchmark
-               HashJoinListResultBenchmark.cpp)
+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::follybenchmark)
+  Folly::follybenchmark
+)
+
+add_executable(velox_hash_join_build_benchmark HashJoinBuildBenchmark.cpp)
+
+target_link_libraries(
+  velox_hash_join_build_benchmark
+  velox_exec
+  velox_exec_test_lib
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  Folly::follybenchmark
+)
 
-add_executable(velox_hash_join_prepare_join_table_benchmark
-               HashJoinPrepareJoinTableBenchmark.cpp)
+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::follybenchmark)
+  Folly::follybenchmark
+)
 
 if(${VELOX_ENABLE_PARQUET})
   add_executable(velox_sort_benchmark RowContainerSortBenchmark.cpp)
@@ -86,22 +104,24 @@ if(${VELOX_ENABLE_PARQUET})
     velox_vector_test_lib
     Folly::follybenchmark
     arrow
-    thrift)
+    thrift
+  )
 endif()
 
 add_library(velox_orderby_benchmark_util OrderByBenchmarkUtil.cpp)
 
-target_link_libraries(
-  velox_orderby_benchmark_util velox_vector_fuzzer velox_vector_test_lib)
+target_link_libraries(velox_orderby_benchmark_util velox_vector_fuzzer velox_vector_test_lib)
 
 add_executable(velox_prefixsort_benchmark PrefixSortBenchmark.cpp)
 
 target_link_libraries(
-  velox_prefixsort_benchmark velox_exec velox_orderby_benchmark_util
-  Folly::follybenchmark)
+  velox_prefixsort_benchmark
+  velox_exec
+  velox_orderby_benchmark_util
+  Folly::follybenchmark
+)
 
-add_executable(velox_orderby_benchmark OrderByBenchmark.cpp
-                                       OrderByBenchmarkUtil.cpp)
+add_executable(velox_orderby_benchmark OrderByBenchmark.cpp OrderByBenchmarkUtil.cpp)
 
 target_link_libraries(
   velox_orderby_benchmark
@@ -110,7 +130,8 @@ target_link_libraries(
   velox_orderby_benchmark_util
   velox_vector_fuzzer
   velox_vector_test_lib
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
 
 add_executable(velox_window_prefixsort_benchmark WindowPrefixSortBenchmark.cpp)
 
@@ -123,10 +144,24 @@ target_link_libraries(
   velox_vector_fuzzer
   velox_vector_test_lib
   velox_window
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
+
+add_executable(velox_window_sub_partitioned_sort_benchmark WindowSubPartitionedSortBenchmark.cpp)
+
+target_link_libraries(
+  velox_window_sub_partitioned_sort_benchmark
+  velox_aggregates
+  velox_exec
+  velox_exec_test_lib
+  velox_hive_connector
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  velox_window
+  Folly::follybenchmark
+)
 
-add_executable(velox_streaming_aggregation_benchmark
-               StreamingAggregationBenchmark.cpp)
+add_executable(velox_streaming_aggregation_benchmark StreamingAggregationBenchmark.cpp)
 
 target_link_libraries(
   velox_streaming_aggregation_benchmark
@@ -136,4 +171,37 @@ target_link_libraries(
   velox_exec_test_lib
   velox_vector_fuzzer
   velox_vector_test_lib
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
+
+add_executable(velox_exec_bm_duplicate_project DuplicateProjectBenchmark.cpp)
+
+target_link_libraries(
+  velox_exec_bm_duplicate_project
+  velox_exec_test_lib
+  velox_hive_connector
+  velox_vector_fuzzer
+  Folly::follybenchmark
+)
+
+add_executable(velox_atomics_benchmark AtomicsBench.cpp)
+
+target_link_libraries(velox_atomics_benchmark Folly::follybenchmark)
+
+if(VELOX_ENABLE_GEO)
+  add_executable(velox_spatial_join_benchmark SpatialJoinBenchmark.cpp)
+
+  target_compile_definitions(velox_spatial_join_benchmark PRIVATE VELOX_ENABLE_GEO)
+
+  target_link_libraries(
+    velox_spatial_join_benchmark
+    velox_memory
+    velox_exec
+    velox_exec_test_lib
+    velox_parse_parser
+    velox_presto_types
+    velox_vector_test_lib
+    velox_functions_prestosql
+    Folly::follybenchmark
+  )
+endif()
diff --git a/velox/exec/benchmarks/DuplicateProjectBenchmark.cpp b/velox/exec/benchmarks/DuplicateProjectBenchmark.cpp
new file mode 100644
index 000000000000..4c08384d3c87
--- /dev/null
+++ b/velox/exec/benchmarks/DuplicateProjectBenchmark.cpp
@@ -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.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+DEFINE_int64(fuzzer_seed, 99887766, "Seed for random input dataset generator");
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::test;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+static constexpr int32_t kNumVectors = 50;
+static constexpr int32_t kRowsPerVector = 10'000;
+
+class DuplicateProjectBenchmark : public HiveConnectorTestBase {
+ public:
+  explicit DuplicateProjectBenchmark() {
+    HiveConnectorTestBase::SetUp();
+
+    inputType_ = ROW({
+        {"a", INTEGER()},
+        {"b", INTEGER()},
+        {"c", VARCHAR()},
+        {"d", VARCHAR()},
+    });
+
+    VectorFuzzer::Options opts;
+    opts.vectorSize = kRowsPerVector;
+    opts.nullRatio = 0.2;
+    VectorFuzzer fuzzer(opts, pool_.get(), FLAGS_fuzzer_seed);
+    std::vector<RowVectorPtr> inputVectors;
+    for (auto i = 0; i < kNumVectors; ++i) {
+      std::vector<VectorPtr> children;
+      children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
+      children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
+      children.emplace_back(fuzzer.fuzzFlat(VARCHAR()));
+      children.emplace_back(fuzzer.fuzzFlat(VARCHAR()));
+
+      inputVectors.emplace_back(makeRowVector(inputType_->names(), children));
+    }
+
+    sourceFilePath_ = TempFilePath::create();
+    writeToFile(sourceFilePath_->getPath(), inputVectors);
+  }
+
+  ~DuplicateProjectBenchmark() override {
+    HiveConnectorTestBase::TearDown();
+  }
+
+  void TestBody() override {}
+
+  void run(const std::string& filter, const std::vector<std::string>& project) {
+    auto plan = PlanBuilder()
+                    .tableScan(inputType_)
+                    .filter(filter)
+                    .project(project)
+                    .planNode();
+    auto result = exec::test::AssertQueryBuilder(plan)
+                      .split(makeHiveConnectorSplit(sourceFilePath_->getPath()))
+                      .copyResults(pool_.get());
+    auto numResultRows = result->size();
+    folly::doNotOptimizeAway(numResultRows);
+  }
+
+  void addBenchmarks() {
+    folly::addBenchmark(
+        __FILE__, "filter_integer_duplicate_project_integer", [this]() {
+          run("a > 99999", {"b", "b"});
+          return 1;
+        });
+    folly::addBenchmark(
+        __FILE__, "filter_string_duplicate_project_string", [this]() {
+          run("length(c) > 10", {"d", "d"});
+          return 1;
+        });
+    folly::addBenchmark(__FILE__, "duplicate_project_integer", [this]() {
+      run("true", {"b", "b"});
+      return 1;
+    });
+    folly::addBenchmark(__FILE__, "duplicate_project_string", [this]() {
+      run("true", {"d", "d"});
+      return 1;
+    });
+    folly::addBenchmark(
+        __FILE__, "filter_integers_duplicate_project_integers", [this]() {
+          run("a > 9999 and b < 10000", {"a", "a", "b", "b"});
+          return 1;
+        });
+    folly::addBenchmark(
+        __FILE__, "filter_strings_duplicate_project_strings", [this]() {
+          run("length(c) > 10 and length(d) < 20", {"c", "c", "d", "d"});
+          return 1;
+        });
+  }
+
+ private:
+  RowTypePtr inputType_;
+  std::shared_ptr<TempFilePath> sourceFilePath_;
+};
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  facebook::velox::memory::MemoryManager::initialize(
+      facebook::velox::memory::MemoryManager::Options{});
+  memory::SharedArbitrator::registerFactory();
+  functions::prestosql::registerAllScalarFunctions();
+
+  DuplicateProjectBenchmark bm;
+  bm.addBenchmarks();
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/benchmarks/FilterProjectBenchmark.cpp b/velox/exec/benchmarks/FilterProjectBenchmark.cpp
index e34be8a68e8d..4c0c26ac03e0 100644
--- a/velox/exec/benchmarks/FilterProjectBenchmark.cpp
+++ b/velox/exec/benchmarks/FilterProjectBenchmark.cpp
@@ -94,10 +94,11 @@ class FilterProjectBenchmark : public VectorTestBase {
     auto& type = data[0]->type()->as<TypeKind::ROW>();
     builder.values(data);
     for (auto level = 0; level < numStages; ++level) {
-      builder.filter(fmt::format(
-          "c0 >= {}",
-          static_cast<int32_t>(
-              1000000 - pow(passPct / 100.0, 1 + level) * 1000000)));
+      builder.filter(
+          fmt::format(
+              "c0 >= {}",
+              static_cast<int32_t>(
+                  1000000 - pow(passPct / 100.0, 1 + level) * 1000000)));
       std::vector<std::string> projections = {"c0"};
       int32_t nthBigint = 0;
       int32_t nthVarchar = 0;
diff --git a/velox/exec/benchmarks/HashJoinBuildBenchmark.cpp b/velox/exec/benchmarks/HashJoinBuildBenchmark.cpp
new file mode 100644
index 000000000000..3d52e0581e13
--- /dev/null
+++ b/velox/exec/benchmarks/HashJoinBuildBenchmark.cpp
@@ -0,0 +1,394 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/executors/CPUThreadPoolExecutor.h>
+#include <folly/init/Init.h>
+#include <iostream>
+#include <utility>
+
+#include "velox/exec/HashTable.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/VectorTestUtil.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::test;
+
+namespace {
+struct BenchmarkParams {
+  BenchmarkParams() = default;
+
+  // Benchmark params, we need to provide:
+  //  -the expect hash mode,
+  //  -the build row schema,
+  //  -the duplicate factor,
+  //  -number of building rows,
+  //  -number of probing rows,
+  //  -the abandon percentage,
+  //  -the number of build vector batches.
+  BenchmarkParams(
+      BaseHashTable::HashMode mode,
+      const TypePtr& buildType,
+      double dupFactor,
+      int64_t buildSize,
+      int64_t probeSize,
+      int32_t abandonPct,
+      int32_t numBuildBatches)
+      : mode{mode},
+        buildType{buildType},
+        hashTableSize{static_cast<long>(std::floor(buildSize / dupFactor))},
+        buildSize{buildSize},
+        probeSize{probeSize},
+        numBuildBatches{numBuildBatches},
+        dupFactor{dupFactor},
+        abandonPct{abandonPct} {
+    VELOX_CHECK_LE(hashTableSize, buildSize);
+    VELOX_CHECK_GE(numBuildBatches, 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(
+        "dupFactor:{:<2},abandonPct:{},{}",
+        dupFactor,
+        abandonPct,
+        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 probe rows.
+  int64_t probeSize;
+
+  // Number of build RowContainers.
+  int32_t numBuildBatches;
+
+  // Title for reporting.
+  std::string title;
+
+  // The duplicate factor, 2 means every row will repeat 2 times.
+  double dupFactor;
+
+  // 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;
+
+  int32_t abandonPct;
+
+  std::string toString() const {
+    return fmt::format(
+        "DupFactor:{:<2}, AbandonPct:{}, HashMode:{:<14}",
+        dupFactor,
+        abandonPct,
+        BaseHashTable::modeString(mode));
+  }
+};
+
+struct BenchmarkResult {
+  BenchmarkParams params;
+
+  uint64_t totalClock{0};
+
+  uint64_t hashBuildPeakMemoryBytes{0};
+
+  bool isBuildNoDupHashTableAbandon{false};
+
+  // The mode of the table.
+  BaseHashTable::HashMode hashMode;
+
+  std::string toString() const {
+    return fmt::format(
+        "{}, isAbandon:{:<5}, totalClock:{}ms, peakMemoryBytes:{}",
+        params.toString(),
+        isBuildNoDupHashTableAbandon,
+        totalClock / 1000'000,
+        succinctBytes(hashBuildPeakMemoryBytes));
+  }
+};
+
+class HashJoinBuildBenchmark : public VectorTestBase {
+ public:
+  HashJoinBuildBenchmark() : randomEngine_((std::random_device{}())) {}
+
+  BenchmarkResult run(BenchmarkParams params) {
+    params_ = std::move(params);
+    BenchmarkResult result;
+    result.params = params_;
+    result.hashMode = params_.mode;
+
+    std::vector<RowVectorPtr> buildVectors;
+    makeBuildBatches(buildVectors);
+
+    int64_t sequence = 0;
+    int64_t batchSize = params_.probeSize / 4;
+    std::vector<RowVectorPtr> probeVectors;
+    for (auto i = 0; i < 4; ++i) {
+      auto batch = makeProbeVector(batchSize, params_.hashTableSize, sequence);
+      probeVectors.emplace_back(batch);
+    }
+
+    uint64_t totalClocks{0};
+    {
+      ClockTimer timer(totalClocks);
+      auto plan = makeHashJoinPlan(buildVectors, probeVectors);
+      CursorParameters cursorParams;
+      cursorParams.planNode = std::move(plan);
+      cursorParams.queryCtx = core::QueryCtx::create(
+          executor_.get(),
+          core::QueryConfig{{}},
+          {},
+          cache::AsyncDataCache::getInstance(),
+          rootPool_);
+      cursorParams.queryCtx->testingOverrideConfigUnsafe({
+          {core::QueryConfig::kAbandonDedupHashMapMinPct,
+           std::to_string(params_.abandonPct)},
+          {core::QueryConfig::kAbandonDedupHashMapMinRows, "1000000"},
+      });
+
+      cursorParams.maxDrivers = 1;
+      auto cursor = TaskCursor::create(cursorParams);
+      auto* task = cursor->task().get();
+      while (cursor->moveNext()) {
+      }
+      waitForTaskCompletion(task);
+      result.isBuildNoDupHashTableAbandon = isBuildNoDupHashTableAbandon(task);
+    }
+    result.totalClock = totalClocks;
+
+    result.hashBuildPeakMemoryBytes = getHashBuildPeakMemory(rootPool_.get());
+    return result;
+  }
+
+ private:
+  std::shared_ptr<const core::PlanNode> makeHashJoinPlan(
+      const std::vector<RowVectorPtr>& buildVectors,
+      const std::vector<RowVectorPtr>& probeVectors) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return exec::test::PlanBuilder(planNodeIdGenerator, pool_.get())
+        .values(probeVectors)
+        .project({"c0 AS t0", "c1 as t1", "c2 as t2"})
+        .hashJoin(
+            {"t0"},
+            {"u0"},
+            exec::test::PlanBuilder(planNodeIdGenerator)
+                .values(buildVectors)
+                .project({"c0 AS u0"})
+                .planNode(),
+            "",
+            {"t0", "t1", "match"},
+            core::JoinType::kLeftSemiProject)
+        .planNode();
+  }
+
+  // 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(
+      std::vector<int64_t>& data,
+      int64_t start,
+      int64_t end,
+      bool addExtraValue) {
+    auto subData =
+        std::vector<int64_t>(data.begin() + start, data.begin() + end);
+    if (addExtraValue) {
+      subData[0] = params_.extraValue;
+    }
+
+    std::vector<VectorPtr> children;
+    children.push_back(makeFlatVector<int64_t>(subData));
+    return makeRowVector(children);
+  }
+
+  // Generate the build side data batches.
+  void makeBuildBatches(std::vector<RowVectorPtr>& batches) {
+    int64_t buildKey = 0;
+    std::vector<int64_t> data;
+    for (auto i = 0; i < params_.buildSize; ++i) {
+      data.emplace_back((buildKey++) % params_.hashTableSize);
+    }
+    std::shuffle(data.begin(), data.end(), randomEngine_);
+
+    auto size = params_.buildSize / params_.numBuildBatches;
+    for (auto i = 0; i < params_.numBuildBatches; ++i) {
+      batches.push_back(makeBuildRows(
+          data,
+          i * size,
+          (i + 1) * size + 1,
+          i == params_.numBuildBatches - 1));
+    }
+  }
+
+  // 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(int64_t size, int64_t hashTableSize, int64_t& sequence) {
+    std::vector<VectorPtr> children;
+    for (int32_t i = 0; i < params_.numFields; ++i) {
+      children.push_back(
+          makeFlatVector<int64_t>(
+              size,
+              [&](vector_size_t row) {
+                return (sequence + row) % hashTableSize;
+              },
+              nullptr));
+    }
+    sequence += size;
+
+    for (int32_t i = 0; i < 2; ++i) {
+      children.push_back(
+          makeFlatVector<int64_t>(
+              size, [&](vector_size_t row) { return row + size; }, nullptr));
+    }
+    return makeRowVector(children);
+  }
+
+  static int64_t getHashBuildPeakMemory(memory::MemoryPool* rootPool) {
+    int64_t hashBuildPeakBytes = 0;
+    std::vector<memory::MemoryPool*> pools;
+    pools.push_back(rootPool);
+    while (!pools.empty()) {
+      std::vector<memory::MemoryPool*> childPools;
+      for (auto pool : pools) {
+        pool->visitChildren([&](memory::MemoryPool* childPool) -> bool {
+          if (childPool->name().find("HashBuild") != std::string::npos) {
+            hashBuildPeakBytes += childPool->peakBytes();
+          }
+          childPools.push_back(childPool);
+          return true;
+        });
+      }
+      pools.swap(childPools);
+    }
+    if (hashBuildPeakBytes == 0) {
+      VELOX_FAIL("Failed to get HashBuild peak memory");
+    }
+    return hashBuildPeakBytes;
+  }
+
+  static bool isBuildNoDupHashTableAbandon(exec::Task* task) {
+    for (auto& pipelineStat : task->taskStats().pipelineStats) {
+      for (auto& operatorStat : pipelineStat.operatorStats) {
+        if (operatorStat.operatorType == "HashBuild") {
+          return operatorStat.runtimeStats["abandonBuildNoDupHash"].count != 0;
+        }
+      }
+    }
+    return false;
+  }
+
+  std::default_random_engine randomEngine_;
+  BenchmarkParams params_;
+};
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::Options options;
+  options.useMmapAllocator = true;
+  options.allocatorCapacity = 10UL << 30;
+  options.useMmapArena = true;
+  options.mmapArenaCapacityRatio = 1;
+  memory::MemoryManager::initialize(options);
+
+  auto bm = std::make_unique<HashJoinBuildBenchmark>();
+  std::vector<BenchmarkResult> results;
+
+  auto buildRowSize = (2L << 20) - 3;
+  auto probeRowSize = 100000000L;
+
+  TypePtr twoKeyType{ROW({"k1"}, {BIGINT()})};
+
+  const std::vector<BaseHashTable::HashMode> hashModes = {
+      BaseHashTable::HashMode::kArray,
+      BaseHashTable::HashMode::kNormalizedKey,
+      BaseHashTable::HashMode::kHash,
+  };
+  const std::vector<double> dupFactorVector = {
+      2,
+      8,
+      32,
+  };
+  const std::vector<int32_t> abandonPcts = {
+      90,
+      80,
+      70,
+      50,
+      0,
+  };
+
+  std::vector<BenchmarkParams> params;
+  for (auto mode : hashModes) {
+    for (auto dupFactor : dupFactorVector) {
+      for (auto pct : abandonPcts) {
+        params.push_back(BenchmarkParams(
+            mode, twoKeyType, dupFactor, buildRowSize, probeRowSize, pct, 512));
+      }
+    }
+  }
+
+  for (auto& param : params) {
+    BenchmarkResult result;
+    folly::addBenchmark(__FILE__, param.title, [param, &results, &bm]() {
+      results.emplace_back(bm->run(param));
+      return 1;
+    });
+  }
+
+  folly::runBenchmarks();
+
+  for (auto& result : results) {
+    std::cout << result.toString() << std::endl;
+  }
+  return 0;
+}
diff --git a/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp b/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp
index 417a86825f02..7e4e933a3787 100644
--- a/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp
+++ b/velox/exec/benchmarks/HashJoinListResultBenchmark.cpp
@@ -280,10 +280,11 @@ class HashTableListJoinResultBenchmark : public VectorTestBase {
     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));
+      children.push_back(
+          makeFlatVector<int64_t>(
+              data.size(),
+              [&](vector_size_t row) { return row + maxKey; },
+              nullptr));
     }
     return makeRowVector(children);
   }
@@ -311,21 +312,23 @@ class HashTableListJoinResultBenchmark : public VectorTestBase {
   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));
+    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));
+      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);
+    raw_vector<uint64_t> dummy(batchSize, pool());
     auto rowContainer = table->rows();
     auto& hashers = table->hashers();
     auto numKeys = hashers.size();
@@ -391,6 +394,8 @@ class HashTableListJoinResultBenchmark : public VectorTestBase {
       topTable_->prepareJoinTable(
           std::move(otherTables),
           BaseHashTable::kNoSpillInputStartPartitionBit,
+          1'000'000,
+          false,
           executor_.get());
     }
     buildTime_ = buildClocks;
diff --git a/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp b/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp
index cfe961b297e1..07f75f06cab1 100644
--- a/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp
+++ b/velox/exec/benchmarks/HashJoinPrepareJoinTableBenchmark.cpp
@@ -129,6 +129,8 @@ class HashJoinPrepareJoinTableBenchmark : public VectorTestBase {
     topTable_->prepareJoinTable(
         std::move(otherTables_),
         BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
         executor_.get());
     VELOX_CHECK_EQ(topTable_->hashMode(), params_.mode);
   }
@@ -180,7 +182,7 @@ class HashJoinPrepareJoinTableBenchmark : public VectorTestBase {
 
   void copyVectorsToTable(RowVectorPtr batch, BaseHashTable* table) {
     int32_t batchSize = batch->size();
-    raw_vector<uint64_t> dummy(batchSize);
+    raw_vector<uint64_t> dummy(batchSize, pool());
     auto rowContainer = table->rows();
     auto& hashers = table->hashers();
     auto numKeys = hashers.size();
diff --git a/velox/exec/benchmarks/HashTableBenchmark.cpp b/velox/exec/benchmarks/HashTableBenchmark.cpp
index 7352e46aef3f..0e739194dc6a 100644
--- a/velox/exec/benchmarks/HashTableBenchmark.cpp
+++ b/velox/exec/benchmarks/HashTableBenchmark.cpp
@@ -173,8 +173,9 @@ class HashTableBenchmark : public VectorTestBase {
       std::vector<RowVectorPtr> batches;
       std::vector<std::unique_ptr<VectorHasher>> keyHashers;
       for (auto channel = 0; channel < params_.numKeys; ++channel) {
-        keyHashers.emplace_back(std::make_unique<VectorHasher>(
-            params_.buildType->childAt(channel), channel));
+        keyHashers.emplace_back(
+            std::make_unique<VectorHasher>(
+                params_.buildType->childAt(channel), channel));
       }
       auto table = HashTable<true>::createForJoin(
           std::move(keyHashers),
@@ -198,6 +199,8 @@ class HashTableBenchmark : public VectorTestBase {
     topTable_->prepareJoinTable(
         std::move(otherTables),
         BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
         executor_.get());
     LOG(INFO) << "Made table " << topTable_->toString();
 
@@ -286,7 +289,7 @@ class HashTableBenchmark : public VectorTestBase {
       int32_t tableOffset,
       BaseHashTable* table) {
     int32_t batchSize = batches[0]->size();
-    raw_vector<uint64_t> dummy(batchSize);
+    raw_vector<uint64_t> dummy(batchSize, pool());
     int32_t batchOffset = 0;
     rowOfKey_.resize(tableOffset + batchSize * batches.size());
     auto rowContainer = table->rows();
@@ -409,8 +412,9 @@ class HashTableBenchmark : public VectorTestBase {
       TypePtr buildType,
       std::vector<RowVectorPtr>& batches) {
     for (auto i = 0; i < numBatches; ++i) {
-      batches.push_back(std::static_pointer_cast<RowVector>(
-          makeVector(buildType, batchSize, sequence)));
+      batches.push_back(
+          std::static_pointer_cast<RowVector>(
+              makeVector(buildType, batchSize, sequence)));
       sequence += batchSize;
     }
   }
diff --git a/velox/exec/benchmarks/MergeBenchmark.cpp b/velox/exec/benchmarks/MergeBenchmark.cpp
index f5fbaee0ff6f..118007abe0d4 100644
--- a/velox/exec/benchmarks/MergeBenchmark.cpp
+++ b/velox/exec/benchmarks/MergeBenchmark.cpp
@@ -19,7 +19,7 @@
 
 #include <gflags/gflags.h>
 
-#include "velox/exec/TreeOfLosers.h"
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/exec/tests/utils/MergeTestBase.h"
 
 using namespace facebook::velox;
diff --git a/velox/exec/benchmarks/OrderByBenchmark.cpp b/velox/exec/benchmarks/OrderByBenchmark.cpp
index 326bbf0e53d1..be01eed258f2 100644
--- a/velox/exec/benchmarks/OrderByBenchmark.cpp
+++ b/velox/exec/benchmarks/OrderByBenchmark.cpp
@@ -56,7 +56,7 @@ class OrderByBenchmark {
             const auto start = getCurrentTimeMicro();
             for (auto i = 0; i < iterations; ++i) {
               std::shared_ptr<Task> task;
-              test::AssertQueryBuilder(plan).runWithoutResults(task);
+              test::AssertQueryBuilder(plan).countResults(task);
               auto taskStats = exec::toPlanStats(task->taskStats());
               auto& stats = taskStats.at(orderByNodeId);
               inputNs += stats.addInputTiming.wallNanos;
@@ -79,8 +79,9 @@ class OrderByBenchmark {
       core::PlanNodeId& orderByNodeId) {
     folly::BenchmarkSuspender suspender;
     std::vector<RowVectorPtr> vectors;
-    vectors.emplace_back(OrderByBenchmarkUtil::fuzzRows(
-        test.rowType, test.numRows, pool_.get()));
+    vectors.emplace_back(
+        OrderByBenchmarkUtil::fuzzRows(
+            test.rowType, test.numRows, pool_.get()));
 
     std::vector<std::string> keys;
     keys.reserve(test.numKeys);
diff --git a/velox/exec/benchmarks/OrderByBenchmarkUtil.h b/velox/exec/benchmarks/OrderByBenchmarkUtil.h
index 3605edc936f3..8b3855daabc6 100644
--- a/velox/exec/benchmarks/OrderByBenchmarkUtil.h
+++ b/velox/exec/benchmarks/OrderByBenchmarkUtil.h
@@ -23,12 +23,13 @@ class OrderByBenchmarkUtil {
  public:
   /// Add the benchmarks with the parameter.
   /// @param benchmarkFunc benchmark generator.
-  static void addBenchmarks(const std::function<void(
-                                const std::string& benchmarkName,
-                                vector_size_t numRows,
-                                const RowTypePtr& rowType,
-                                int iterations,
-                                int numKeys)>& benchmarkFunc);
+  static void addBenchmarks(
+      const std::function<void(
+          const std::string& benchmarkName,
+          vector_size_t numRows,
+          const RowTypePtr& rowType,
+          int iterations,
+          int numKeys)>& benchmarkFunc);
 
   /// Generate RowVector by VectorFuzzer according to rowType. Use
   /// FLAGS_data_null_ratio to specify the columns null ratio
diff --git a/velox/exec/benchmarks/SpatialJoinBenchmark.cpp b/velox/exec/benchmarks/SpatialJoinBenchmark.cpp
new file mode 100644
index 000000000000..066cceb63795
--- /dev/null
+++ b/velox/exec/benchmarks/SpatialJoinBenchmark.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 <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/common/memory/Memory.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+/// Benchmark for SpatialJoin operator, which implements a nested-loop join
+/// with spatial predicates (e.g., ST_INTERSECTS, ST_CONTAINS, ST_WITHIN).
+///
+/// This benchmark measures the performance of spatial joins under different
+/// conditions:
+/// - Different build and probe side sizes (cross join cardinality)
+/// - Different spatial predicates
+/// - Different data distributions (dense vs sparse geometries)
+/// - Inner vs Left join types
+///
+/// The benchmark creates synthetic geometric data and measures the throughput
+/// of spatial join operations. The focus is on understanding how the nested
+/// loop pattern performs with varying data sizes and selectivity.
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+/// Spatial distribution patterns for geometry generation.
+enum class Distribution {
+  kUniform, // Geometries uniformly distributed in space
+  kClustered // Geometries clustered in specific regions
+};
+
+// Constants for geometry generation.
+constexpr int32_t kNullPatternModulo = 13;
+constexpr int32_t kRandomCoordinateMax = 10000;
+constexpr double kCoordinateScaleDivisor = 10.0;
+constexpr int32_t kNumClusters = 5;
+constexpr double kClusterSpacing = 200.0;
+constexpr double kClusterCenterOffset = 100.0;
+constexpr int32_t kClusterSpreadRange = 100;
+constexpr int32_t kClusterSpreadHalf = 50;
+constexpr double kPolygonSize = 10.0;
+
+// Constants for benchmark configuration.
+constexpr int32_t kDefaultBatchSize = 10000;
+constexpr int32_t kSmallBenchmarkSize = 1000;
+constexpr int32_t kMediumProbeBenchmarkSize = 50000;
+constexpr int32_t kMediumBuildBenchmarkSize = 5000;
+constexpr int32_t kLargeProbeBenchmarkSize = 200000;
+constexpr int32_t kLargeBuildBenchmarkSize = 50000;
+
+/// Parameters for a spatial join benchmark test case.
+struct SpatialJoinBenchmarkParams {
+  /// Number of rows on the probe (left) side.
+  int32_t probeSize;
+
+  /// Number of rows on the build (right) side.
+  int32_t buildSize;
+
+  /// Spatial predicate to use (e.g., "ST_Intersects", "ST_Contains").
+  std::string predicate;
+
+  /// Join type (kInner or kLeft).
+  core::JoinType joinType;
+
+  /// Spatial distribution pattern for geometry generation.
+  Distribution distribution;
+
+  /// Description for benchmark naming.
+  std::string toString() const {
+    std::string joinTypeStr =
+        (joinType == core::JoinType::kInner) ? "Inner" : "Left";
+    std::string distributionStr =
+        (distribution == Distribution::kUniform) ? "uniform" : "clustered";
+    return fmt::format(
+        "{}x{}_{}_{}_{}",
+        probeSize,
+        buildSize,
+        predicate,
+        joinTypeStr,
+        distributionStr);
+  }
+};
+
+class SpatialJoinBenchmark : public facebook::velox::test::VectorTestBase {
+ public:
+  SpatialJoinBenchmark() : rng_((std::random_device{}())) {}
+
+  /// Creates a vector of POINT geometries with specified distribution.
+  VectorPtr
+  makePointVector(int32_t size, Distribution distribution, bool nulls = false) {
+    return makeFlatVector<std::string>(
+        size,
+        [&](vector_size_t row) {
+          if (nulls && (row % kNullPatternModulo == 0)) {
+            return std::string("");
+          }
+          double x, y;
+          if (distribution == Distribution::kUniform) {
+            x = (folly::Random::rand32(rng_) % kRandomCoordinateMax) /
+                kCoordinateScaleDivisor;
+            y = (folly::Random::rand32(rng_) % kRandomCoordinateMax) /
+                kCoordinateScaleDivisor;
+          } else {
+            int cluster = row % kNumClusters;
+            double centerX = (cluster * kClusterSpacing) + kClusterCenterOffset;
+            double centerY = (cluster * kClusterSpacing) + kClusterCenterOffset;
+            x = centerX +
+                ((folly::Random::rand32(rng_) % kClusterSpreadRange) -
+                 kClusterSpreadHalf);
+            y = centerY +
+                ((folly::Random::rand32(rng_) % kClusterSpreadRange) -
+                 kClusterSpreadHalf);
+          }
+          return fmt::format("POINT ({} {})", x, y);
+        },
+        [&](vector_size_t row) {
+          return nulls && (row % kNullPatternModulo == 0);
+        });
+  }
+
+  /// Creates a vector of POLYGON geometries with specified distribution.
+  VectorPtr makePolygonVector(
+      int32_t size,
+      Distribution distribution,
+      bool nulls = false) {
+    return makeFlatVector<std::string>(
+        size,
+        [&](vector_size_t row) {
+          if (nulls && (row % kNullPatternModulo == 0)) {
+            return std::string("");
+          }
+          double centerX, centerY;
+          if (distribution == Distribution::kUniform) {
+            centerX = (folly::Random::rand32(rng_) % kRandomCoordinateMax) /
+                kCoordinateScaleDivisor;
+            centerY = (folly::Random::rand32(rng_) % kRandomCoordinateMax) /
+                kCoordinateScaleDivisor;
+          } else {
+            int cluster = row % kNumClusters;
+            centerX = (cluster * kClusterSpacing) + kClusterCenterOffset;
+            centerY = (cluster * kClusterSpacing) + kClusterCenterOffset;
+          }
+          return fmt::format(
+              "POLYGON (({} {}, {} {}, {} {}, {} {}, {} {}))",
+              centerX - kPolygonSize,
+              centerY - kPolygonSize,
+              centerX + kPolygonSize,
+              centerY - kPolygonSize,
+              centerX + kPolygonSize,
+              centerY + kPolygonSize,
+              centerX - kPolygonSize,
+              centerY + kPolygonSize,
+              centerX - kPolygonSize,
+              centerY - kPolygonSize);
+        },
+        [&](vector_size_t row) {
+          return nulls && (row % kNullPatternModulo == 0);
+        });
+  }
+
+  RowVectorPtr createProjectionVector(
+      const std::string& prefix,
+      RowVectorPtr input) {
+    const auto plan = PlanBuilder(std::make_shared<core::PlanNodeIdGenerator>())
+                          .values({input})
+                          .project(
+                              {fmt::format("{}_id", prefix),
+                               fmt::format(
+                                   "ST_GeometryFromText({}_geom) AS {}_geom",
+                                   prefix,
+                                   prefix)})
+                          .planNode();
+    return AssertQueryBuilder(plan).copyResults(pool_.get());
+  }
+
+  /// Creates test data for the specified parameters.
+  std::pair<std::vector<RowVectorPtr>, std::vector<RowVectorPtr>> makeTestData(
+      const SpatialJoinBenchmarkParams& params) {
+    // Create probe side data (points)
+    std::vector<RowVectorPtr> probeVectors;
+    const int32_t batchSize = std::min(params.probeSize, kDefaultBatchSize);
+    const int32_t numBatches = (params.probeSize + batchSize - 1) / batchSize;
+
+    for (int32_t i = 0; i < numBatches; ++i) {
+      int32_t currentBatchSize =
+          std::min(batchSize, params.probeSize - (i * batchSize));
+      auto geomVector =
+          makePointVector(currentBatchSize, params.distribution, false);
+      auto idVector = makeFlatVector<int64_t>(
+          currentBatchSize,
+          [i, batchSize](vector_size_t row) { return (i * batchSize) + row; });
+      probeVectors.push_back(createProjectionVector(
+          "probe",
+          makeRowVector({"probe_id", "probe_geom"}, {idVector, geomVector})));
+    }
+
+    // Create build side data (polygons)
+    std::vector<RowVectorPtr> buildVectors;
+    const int32_t buildBatchSize =
+        std::min(params.buildSize, kDefaultBatchSize);
+    const int32_t numBuildBatches =
+        (params.buildSize + buildBatchSize - 1) / buildBatchSize;
+
+    for (int32_t i = 0; i < numBuildBatches; ++i) {
+      int32_t currentBatchSize =
+          std::min(buildBatchSize, params.buildSize - (i * buildBatchSize));
+      auto geomVector =
+          makePolygonVector(currentBatchSize, params.distribution, false);
+      auto idVector = makeFlatVector<int64_t>(
+          currentBatchSize, [i, buildBatchSize](vector_size_t row) {
+            return (i * buildBatchSize) + row;
+          });
+      buildVectors.push_back(createProjectionVector(
+          "build",
+          makeRowVector({"build_id", "build_geom"}, {idVector, geomVector})));
+    }
+
+    return {probeVectors, buildVectors};
+  }
+
+  /// Creates a spatial join plan with the specified parameters.
+  std::shared_ptr<const core::PlanNode> makeSpatialJoinPlan(
+      std::vector<RowVectorPtr>&& probeVectors,
+      std::vector<RowVectorPtr>&& buildVectors,
+      const SpatialJoinBenchmarkParams& params) {
+    const auto planNodeIdGenerator =
+        std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values(probeVectors)
+        .spatialJoin(
+            PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+            fmt::format("{}(probe_geom, build_geom)", params.predicate),
+            "probe_geom",
+            "build_geom",
+            std::nullopt,
+            {"probe_id", "probe_geom", "build_id", "build_geom"},
+            params.joinType)
+        .planNode();
+  }
+
+  /// Runs a single benchmark iteration.
+  uint64_t run(
+      std::shared_ptr<const core::PlanNode> plan,
+      const SpatialJoinBenchmarkParams& params) {
+    auto result = AssertQueryBuilder(plan).copyResults(pool_.get());
+    return result->size();
+  }
+
+  /// Adds a benchmark for the given parameters.
+  void addBenchmark(const SpatialJoinBenchmarkParams& params) {
+    auto name = params.toString();
+    folly::addBenchmark(__FILE__, name, [this, params]() {
+      std::shared_ptr<const core::PlanNode> plan;
+      BENCHMARK_SUSPEND {
+        auto [probeVectors, buildVectors] = makeTestData(params);
+        plan = makeSpatialJoinPlan(
+            std::move(probeVectors), std::move(buildVectors), params);
+      }
+
+      run(plan, params);
+      return 1;
+    });
+  }
+
+ private:
+  std::default_random_engine rng_;
+};
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::initializeMemoryManager(memory::MemoryManager::Options{});
+  parse::registerTypeResolver();
+  functions::prestosql::registerAllScalarFunctions();
+
+  SpatialJoinBenchmark bm;
+
+  // Small scale benchmarks (1K x 1K)
+  bm.addBenchmark(
+      {kSmallBenchmarkSize,
+       kSmallBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kUniform});
+  bm.addBenchmark(
+      {kSmallBenchmarkSize,
+       kSmallBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kClustered});
+
+  // Medium scale benchmarks (50K x 5K)
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize,
+       kMediumBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kUniform});
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize,
+       kMediumBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kClustered});
+
+  // Left join benchmarks (50K x 5K)
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize / 2,
+       kMediumBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kLeft,
+       Distribution::kUniform});
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize / 2,
+       kMediumBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kLeft,
+       Distribution::kClustered});
+
+  // Contains predicate benchmarks (50K x 5K)
+  bm.addBenchmark(
+      {kMediumProbeBenchmarkSize / 2,
+       kMediumBuildBenchmarkSize,
+       "ST_Contains",
+       core::JoinType::kInner,
+       Distribution::kUniform});
+
+  // Large scale benchmark (200K x 50K)
+  bm.addBenchmark(
+      {kLargeProbeBenchmarkSize,
+       kLargeBuildBenchmarkSize,
+       "ST_Intersects",
+       core::JoinType::kInner,
+       Distribution::kUniform});
+
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/exec/benchmarks/StreamingAggregationBenchmark.cpp b/velox/exec/benchmarks/StreamingAggregationBenchmark.cpp
index dc1f16ae6a1d..9393d7cef7d8 100644
--- a/velox/exec/benchmarks/StreamingAggregationBenchmark.cpp
+++ b/velox/exec/benchmarks/StreamingAggregationBenchmark.cpp
@@ -84,10 +84,9 @@ class StreamingAggregationBenchmark : public VectorTestBase {
         std::to_string(params.numGroups));
 
     folly::addBenchmark(__FILE__, name, [plan = &test->plan]() {
-      std::shared_ptr<Task> task;
       exec::test::AssertQueryBuilder(*plan)
           .serialExecution(true)
-          .runWithoutResults(task);
+          .countResults();
       return 1;
     });
 
diff --git a/velox/exec/benchmarks/VectorHasherBenchmark.cpp b/velox/exec/benchmarks/VectorHasherBenchmark.cpp
index 41bb56c05672..f3af6953b601 100644
--- a/velox/exec/benchmarks/VectorHasherBenchmark.cpp
+++ b/velox/exec/benchmarks/VectorHasherBenchmark.cpp
@@ -74,7 +74,7 @@ void benchmarkComputeValueIds(bool withNulls) {
       [](vector_size_t row) { return row % 17; },
       withNulls ? velox::test::VectorMaker::nullEvery(7) : nullptr);
 
-  raw_vector<uint64_t> hashes(size);
+  raw_vector<uint64_t> hashes(size, base.pool());
   SelectivityVector rows(size);
   hasher.decode(*values, rows);
   hasher.computeValueIds(rows, hashes);
@@ -155,7 +155,7 @@ void benchmarkComputeValueIdsForStrings(bool flattenDictionaries) {
   uint64_t multiplier = 1;
   for (int i = 0; i < 4; i++) {
     auto hasher = hashers[i].get();
-    raw_vector<uint64_t> result(size);
+    raw_vector<uint64_t> result(size, base.pool());
     hasher->decode(*vectors[i], allRows);
     auto ok = hasher->computeValueIds(allRows, result);
     folly::doNotOptimizeAway(ok);
@@ -164,7 +164,7 @@ void benchmarkComputeValueIdsForStrings(bool flattenDictionaries) {
   }
   suspender.dismiss();
 
-  raw_vector<uint64_t> result(size);
+  raw_vector<uint64_t> result(size, base.pool());
   for (int i = 0; i < 10'000; i++) {
     for (int j = 0; j < 4; j++) {
       auto hasher = hashers[j].get();
@@ -198,7 +198,7 @@ BENCHMARK(computeValueIdsLowCardinalityLargeBatchSize) {
   auto values = base.vectorMaker().dictionaryVector<int64_t>(data);
 
   for (int i = 0; i < 10; i++) {
-    raw_vector<uint64_t> hashes(batchSize);
+    raw_vector<uint64_t> hashes(batchSize, base.pool());
     SelectivityVector rows(batchSize);
     VectorHasher hasher(BIGINT(), 0);
     hasher.decode(*values, rows);
@@ -228,7 +228,7 @@ BENCHMARK(computeValueIdsLowCardinalityNotAllUsed) {
   auto values = BaseVector::wrapInDictionary(nullptr, indices, batchSize, data);
 
   for (int i = 0; i < 10; i++) {
-    raw_vector<uint64_t> hashes(batchSize);
+    raw_vector<uint64_t> hashes(batchSize, base.pool());
     SelectivityVector rows(batchSize);
     VectorHasher hasher(BIGINT(), 0);
     hasher.decode(*values, rows);
@@ -258,7 +258,7 @@ BENCHMARK(computeValueIdsDictionaryForFiltering) {
   auto values = BaseVector::wrapInDictionary(nullptr, indices, batchSize, data);
 
   for (int i = 0; i < 10; i++) {
-    raw_vector<uint64_t> hashes(batchSize);
+    raw_vector<uint64_t> hashes(batchSize, base.pool());
     SelectivityVector rows(batchSize);
     VectorHasher hasher(BIGINT(), 0);
     hasher.decode(*values, rows);
diff --git a/velox/exec/benchmarks/WindowPrefixSortBenchmark.cpp b/velox/exec/benchmarks/WindowPrefixSortBenchmark.cpp
index 27025f723515..c63f4dd1188c 100644
--- a/velox/exec/benchmarks/WindowPrefixSortBenchmark.cpp
+++ b/velox/exec/benchmarks/WindowPrefixSortBenchmark.cpp
@@ -72,8 +72,9 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
 
       // Generate key with a small number of unique values from a small range
       // (0-16).
-      children.emplace_back(makeFlatVector<int32_t>(
-          kRowsPerVector, [](auto row) { return row % 17; }));
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              kRowsPerVector, [](auto row) { return row % 17; }));
 
       // Generate key with a small number of unique values from a large range
       // (300 total values).
@@ -94,8 +95,9 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
 
       // Generate a column with increasing values to get a deterministic sort
       // order.
-      children.emplace_back(makeFlatVector<int32_t>(
-          kRowsPerVector, [](auto row) { return row; }));
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              kRowsPerVector, [](auto row) { return row; }));
 
       // Generate random values without nulls.
       children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
@@ -192,7 +194,8 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
           std::move(plan),
           0,
           core::QueryCtx::create(executor_.get()),
-          Task::ExecutionMode::kSerial);
+          Task::ExecutionMode::kSerial,
+          exec::Consumer{});
     } else {
       const std::unordered_map<std::string, std::string> queryConfigMap(
           {{core::QueryConfig::kPrefixSortNormalizedKeyMaxBytes, "0"}});
@@ -202,7 +205,8 @@ class WindowPrefixSortBenchmark : public HiveConnectorTestBase {
           0,
           core::QueryCtx::create(
               executor_.get(), core::QueryConfig(queryConfigMap)),
-          Task::ExecutionMode::kSerial);
+          Task::ExecutionMode::kSerial,
+          exec::Consumer{});
     }
   }
 
diff --git a/velox/exec/benchmarks/WindowSubPartitionedSortBenchmark.cpp b/velox/exec/benchmarks/WindowSubPartitionedSortBenchmark.cpp
new file mode 100644
index 000000000000..2fe4451bea97
--- /dev/null
+++ b/velox/exec/benchmarks/WindowSubPartitionedSortBenchmark.cpp
@@ -0,0 +1,407 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/Benchmark.h>
+#include <folly/init/Init.h>
+#include <string>
+
+#include "velox/common/memory/SharedArbitrator.h"
+#include "velox/exec/Cursor.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/window/WindowFunctionsRegistration.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::test;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+static constexpr int32_t kNumVectors = 200;
+static constexpr int32_t kRowsPerVector = 10'000;
+
+namespace {
+class BenchmarkRecorder {
+ public:
+  BenchmarkRecorder() = default;
+
+  void record(std::string name, uint64_t numBytes) {
+    // Only record the first apperance.
+    if (numBytesRecords_.count(name) == 0) {
+      numBytesRecords_[name] = {1, numBytes};
+      names_.push_back(name);
+    } else {
+      auto& record = numBytesRecords_[name];
+      record.numAppearance++;
+      record.totalCount += numBytes;
+    }
+  }
+
+  std::string report() {
+    std::string result = "name, memory(MB)\n";
+    for (auto& name : names_) {
+      auto& record = numBytesRecords_[name];
+      result += fmt::format(
+          "{}, {}MB\n",
+          name,
+          record.totalCount / 1024 / 1024 / record.numAppearance);
+    }
+    return result;
+  }
+
+ private:
+  struct Counter {
+    int32_t numAppearance{0};
+    uint64_t totalCount{0};
+  };
+  std::vector<std::string> names_;
+  std::unordered_map<std::string, Counter> numBytesRecords_;
+};
+
+class WindowSubPartitionedSortBenchmark : public HiveConnectorTestBase {
+ public:
+  WindowSubPartitionedSortBenchmark(
+      int32_t numVectors,
+      int32_t rowsPerVector,
+      std::shared_ptr<BenchmarkRecorder> recorder)
+      : numVectors_(numVectors),
+        rowsPerVector_(rowsPerVector),
+        recorder_(recorder) {
+    memory::SharedArbitrator::registerFactory();
+    HiveConnectorTestBase::SetUp();
+    aggregate::prestosql::registerAllAggregateFunctions();
+    window::prestosql::registerAllWindowFunctions();
+
+    inputType_ = ROW({
+        {"k_array", INTEGER()},
+        {"k_norm", INTEGER()},
+        {"k_hash", INTEGER()},
+        {"k_sort", INTEGER()},
+        {"i32", INTEGER()},
+        {"i64", BIGINT()},
+        {"f32", REAL()},
+        {"f64", DOUBLE()},
+        {"i32_halfnull", INTEGER()},
+        {"i64_halfnull", BIGINT()},
+        {"f32_halfnull", REAL()},
+        {"f64_halfnull", DOUBLE()},
+    });
+
+    VectorFuzzer::Options opts;
+    opts.vectorSize = rowsPerVector_;
+    opts.nullRatio = 0;
+    VectorFuzzer fuzzer(opts, pool_.get(), FLAGS_fuzzer_seed);
+    std::vector<RowVectorPtr> inputVectors;
+    for (auto i = 0; i < numVectors_; ++i) {
+      std::vector<VectorPtr> children;
+
+      // Generate key with a small number of unique values from a small range
+      // (0-16).
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              rowsPerVector_, [](auto row) { return row % 17; }));
+
+      // Generate key with a small number of unique values from a large range
+      // (300 total values).
+      children.emplace_back(
+          makeFlatVector<int32_t>(rowsPerVector_, [](auto row) {
+            if (row % 3 == 0) {
+              return std::numeric_limits<int32_t>::max() - row % 100;
+            } else if (row % 3 == 1) {
+              return row % 100;
+            } else {
+              return std::numeric_limits<int32_t>::min() + row % 100;
+            }
+          }));
+
+      // Generate key with many unique values from a large range (500K total
+      // values).
+      children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
+
+      // Generate a column with increasing values to get a deterministic sort
+      // order.
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              rowsPerVector_, [](auto row) { return row; }));
+
+      // Generate random values without nulls.
+      children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
+      children.emplace_back(fuzzer.fuzzFlat(BIGINT()));
+      children.emplace_back(fuzzer.fuzzFlat(REAL()));
+      children.emplace_back(fuzzer.fuzzFlat(DOUBLE()));
+
+      // Generate random values with nulls.
+      opts.nullRatio = 0.05; // 5%
+      fuzzer.setOptions(opts);
+
+      children.emplace_back(fuzzer.fuzzFlat(INTEGER()));
+      children.emplace_back(fuzzer.fuzzFlat(BIGINT()));
+      children.emplace_back(fuzzer.fuzzFlat(REAL()));
+      children.emplace_back(fuzzer.fuzzFlat(DOUBLE()));
+
+      inputVectors.emplace_back(makeRowVector(inputType_->names(), children));
+    }
+
+    sourceFilePath_ = TempFilePath::create();
+    writeToFile(sourceFilePath_->getPath(), inputVectors);
+  }
+
+  ~WindowSubPartitionedSortBenchmark() override {
+    HiveConnectorTestBase::TearDown();
+  }
+
+  CpuWallTiming windowNanos() {
+    return windowNanos_;
+  }
+
+  void TestBody() override {}
+
+  void run(
+      const std::string& recordName,
+      const std::string& key,
+      const std::string& aggregate,
+      int32_t numSubPartitions) {
+    folly::BenchmarkSuspender suspender1;
+
+    windowNanos_.clear();
+    windowMems_.clear();
+
+    std::string functionSql = fmt::format(
+        "{} over (partition by {} order by k_sort)", aggregate, key);
+
+    core::PlanNodeId tableScanPlanId;
+    core::PlanFragment plan = PlanBuilder()
+                                  .tableScan(inputType_)
+                                  .capturePlanNodeId(tableScanPlanId)
+                                  .window({functionSql})
+                                  .planFragment();
+
+    vector_size_t numResultRows = 0;
+    auto task = makeTask(plan, numSubPartitions);
+    task->addSplit(
+        tableScanPlanId,
+        exec::Split(makeHiveConnectorSplit(sourceFilePath_->getPath())));
+    task->noMoreSplits(tableScanPlanId);
+    suspender1.dismiss();
+
+    while (auto result = task->next()) {
+      numResultRows += result->size();
+    }
+
+    folly::BenchmarkSuspender suspender2;
+    auto stats = task->taskStats();
+    for (auto& pipeline : stats.pipelineStats) {
+      for (auto& op : pipeline.operatorStats) {
+        if (op.operatorType == "Window") {
+          windowNanos_.add(op.addInputTiming);
+          windowNanos_.add(op.getOutputTiming);
+          windowMems_.add(op.memoryStats);
+        }
+        if (op.operatorType == "Values") {
+          // This is the timing for Window::noMoreInput() where the window
+          // sorting happens. So including in the cpu timing.
+          windowNanos_.add(op.finishTiming);
+        }
+      }
+    }
+    recorder_->record(recordName, windowMems_.peakTotalMemoryReservation);
+    suspender2.dismiss();
+    folly::doNotOptimizeAway(numResultRows);
+  }
+
+  std::shared_ptr<exec::Task> makeTask(
+      core::PlanFragment plan,
+      int32_t numSubPartitions) {
+    bool subPartitionedSort = numSubPartitions > 1;
+    if (subPartitionedSort) {
+      const std::unordered_map<std::string, std::string> queryConfigMap(
+          {{core::QueryConfig::kWindowNumSubPartitions,
+            std::to_string(numSubPartitions)}});
+      return exec::Task::create(
+          "t",
+          std::move(plan),
+          0,
+          core::QueryCtx::create(
+              executor_.get(), core::QueryConfig(queryConfigMap)),
+          Task::ExecutionMode::kSerial);
+
+    } else {
+      return exec::Task::create(
+          "t",
+          std::move(plan),
+          0,
+          core::QueryCtx::create(executor_.get()),
+          Task::ExecutionMode::kSerial);
+    }
+  }
+
+  uint64_t getLatestMemoryUsage() {
+    return windowMems_.peakTotalMemoryReservation;
+  }
+
+ private:
+  const int32_t numVectors_;
+  const int32_t rowsPerVector_;
+  const std::shared_ptr<BenchmarkRecorder> recorder_;
+  RowTypePtr inputType_;
+  std::shared_ptr<TempFilePath> sourceFilePath_;
+
+  CpuWallTiming windowNanos_;
+  MemoryStats windowMems_;
+};
+
+std::unique_ptr<WindowSubPartitionedSortBenchmark> benchmark;
+auto recorder = std::make_shared<BenchmarkRecorder>();
+
+void doSortRun(
+    uint32_t,
+    const std::string& recordName,
+    int32_t numSubPartitions,
+    const std::string& key,
+    const std::string& aggregate) {
+  benchmark->run(recordName, key, aggregate, numSubPartitions);
+}
+
+#define BENCHMARK_AND_RECORD_HEAD(_num_, _name_, _key_, _agg_) \
+  BENCHMARK_NAMED_PARAM(                                       \
+      doSortRun,                                               \
+      num##_num_##_##_name_,                                   \
+      fmt::format("num{}_{}", #_num_, #_name_),                \
+      _num_,                                                   \
+      _key_,                                                   \
+      _agg_);
+
+#define BENCHMARK_AND_RECORD_TAIL(_num_, _name_, _key_, _agg_) \
+  BENCHMARK_RELATIVE_NAMED_PARAM(                              \
+      doSortRun,                                               \
+      num##_num_##_##_name_,                                   \
+      fmt::format("num{}_{}", #_num_, #_name_),                \
+      _num_,                                                   \
+      _key_,                                                   \
+      _agg_);
+
+#define BATCHED_BENCHMARKS(_name_, _key_, _agg_)         \
+  BENCHMARK_AND_RECORD_HEAD(1, _name_, _key_, _agg_);    \
+  BENCHMARK_AND_RECORD_TAIL(2, _name_, _key_, _agg_);    \
+  BENCHMARK_AND_RECORD_TAIL(4, _name_, _key_, _agg_);    \
+  BENCHMARK_AND_RECORD_TAIL(8, _name_, _key_, _agg_);    \
+  BENCHMARK_AND_RECORD_TAIL(16, _name_, _key_, _agg_);   \
+  BENCHMARK_AND_RECORD_TAIL(32, _name_, _key_, _agg_);   \
+  BENCHMARK_AND_RECORD_TAIL(64, _name_, _key_, _agg_);   \
+  BENCHMARK_AND_RECORD_TAIL(128, _name_, _key_, _agg_);  \
+  BENCHMARK_AND_RECORD_TAIL(256, _name_, _key_, _agg_);  \
+  BENCHMARK_AND_RECORD_TAIL(512, _name_, _key_, _agg_);  \
+  BENCHMARK_AND_RECORD_TAIL(1024, _name_, _key_, _agg_); \
+  BENCHMARK_AND_RECORD_TAIL(2048, _name_, _key_, _agg_);
+
+#define AGG_BENCHMARKS(_name_, _key_)                                       \
+  BATCHED_BENCHMARKS(                                                       \
+      _name_##_INTEGER_##_key_, #_key_, fmt::format("{}(i32)", (#_name_))); \
+  BATCHED_BENCHMARKS(                                                       \
+      _name_##_REAL_##_key_, #_key_, fmt::format("{}(f32)", (#_name_)));    \
+  BATCHED_BENCHMARKS(                                                       \
+      _name_##_INTEGER_NULLS_##_key_,                                       \
+      #_key_,                                                               \
+      fmt::format("{}(i32_halfnull)", (#_name_)));                          \
+  BATCHED_BENCHMARKS(                                                       \
+      _name_##_REAL_NULLS_##_key_,                                          \
+      #_key_,                                                               \
+      fmt::format("{}(f32_halfnull)", (#_name_)));
+
+#define MULTI_KEY_AGG_BENCHMARKS(_name_, _key1_, _key2_) \
+  BATCHED_BENCHMARKS(                                    \
+      _name_##_BIGINT_##_key1_##_key2_,                  \
+      fmt::format("{},{}", (#_key1_), (#_key2_)),        \
+      fmt::format("{}(i64)", (#_name_)));                \
+  BATCHED_BENCHMARKS(                                    \
+      _name_##_BIGINT_NULLS_##_key1_##_key2_,            \
+      fmt::format("{},{}", (#_key1_), (#_key2_)),        \
+      fmt::format("{}(i64_halfnull)", (#_name_)));       \
+  BATCHED_BENCHMARKS(                                    \
+      _name_##_DOUBLE_##_key1_##_key2_,                  \
+      fmt::format("{},{}", (#_key1_), (#_key2_)),        \
+      fmt::format("{}(f64)", (#_name_)));                \
+  BATCHED_BENCHMARKS(                                    \
+      _name_##_DOUBLE_NULLS_##_key1_##_key2_,            \
+      fmt::format("{},{}", (#_key1_), (#_key2_)),        \
+      fmt::format("{}(f64_halfnull)", (#_name_)));
+
+// Count(1) aggregate.
+BATCHED_BENCHMARKS(count_k_array, "k_array", "count(1)");
+BATCHED_BENCHMARKS(count_k_norm, "k_norm", "count(1)");
+BATCHED_BENCHMARKS(count_k_hash, "k_hash", "count(1)");
+BATCHED_BENCHMARKS(count_k_array_k_hash, "k_array,i32", "count(1)");
+BENCHMARK_DRAW_LINE();
+
+// Count aggregate.
+AGG_BENCHMARKS(count, k_array)
+AGG_BENCHMARKS(count, k_norm)
+AGG_BENCHMARKS(count, k_hash)
+MULTI_KEY_AGG_BENCHMARKS(count, k_array, i32)
+MULTI_KEY_AGG_BENCHMARKS(count, k_array, i64)
+MULTI_KEY_AGG_BENCHMARKS(count, k_hash, f32)
+MULTI_KEY_AGG_BENCHMARKS(count, k_hash, f64)
+BENCHMARK_DRAW_LINE();
+
+// Avg aggregate.
+AGG_BENCHMARKS(avg, k_array)
+AGG_BENCHMARKS(avg, k_norm)
+AGG_BENCHMARKS(avg, k_hash)
+MULTI_KEY_AGG_BENCHMARKS(avg, k_array, i32)
+MULTI_KEY_AGG_BENCHMARKS(avg, k_array, i64)
+MULTI_KEY_AGG_BENCHMARKS(avg, k_hash, f32)
+MULTI_KEY_AGG_BENCHMARKS(avg, k_hash, f64)
+BENCHMARK_DRAW_LINE();
+
+// Min aggregate.
+AGG_BENCHMARKS(min, k_array)
+AGG_BENCHMARKS(min, k_norm)
+AGG_BENCHMARKS(min, k_hash)
+MULTI_KEY_AGG_BENCHMARKS(min, k_array, i32)
+MULTI_KEY_AGG_BENCHMARKS(min, k_array, i64)
+MULTI_KEY_AGG_BENCHMARKS(min, k_hash, f32)
+MULTI_KEY_AGG_BENCHMARKS(min, k_hash, f64)
+BENCHMARK_DRAW_LINE();
+
+// Max aggregate.
+AGG_BENCHMARKS(max, k_array)
+AGG_BENCHMARKS(max, k_norm)
+AGG_BENCHMARKS(max, k_hash)
+MULTI_KEY_AGG_BENCHMARKS(max, k_array, i32)
+MULTI_KEY_AGG_BENCHMARKS(max, k_array, i64)
+MULTI_KEY_AGG_BENCHMARKS(max, k_hash, f32)
+MULTI_KEY_AGG_BENCHMARKS(max, k_hash, f64)
+BENCHMARK_DRAW_LINE();
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  facebook::velox::memory::MemoryManager::initialize(
+      facebook::velox::memory::MemoryManager::Options{});
+
+  benchmark = std::make_unique<WindowSubPartitionedSortBenchmark>(
+      kNumVectors, kRowsPerVector, recorder);
+  folly::runBenchmarks();
+  benchmark.reset();
+
+  std::cout << std::endl << recorder->report();
+  return 0;
+}
diff --git a/velox/exec/fuzzer/AggregationFuzzer.cpp b/velox/exec/fuzzer/AggregationFuzzer.cpp
index fd98a8d8a83d..2f635bbfbef8 100644
--- a/velox/exec/fuzzer/AggregationFuzzer.cpp
+++ b/velox/exec/fuzzer/AggregationFuzzer.cpp
@@ -265,10 +265,7 @@ AggregationFuzzer::AggregationFuzzer(
 
 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();
+  connector::hive::HiveConnector::registerSerDe();
   core::ITypedExpr::registerSerDe();
   core::PlanNode::registerSerDe();
   registerPartitionFunctionSerDe();
@@ -493,21 +490,23 @@ void makeAlternativePlansWithValues(
     const std::vector<core::ExprPtr>& projections,
     std::vector<core::PlanNodePtr>& plans) {
   // Partial -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .projectExpressions(projections)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .finalAggregation()
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .values(inputVectors)
+          .projectExpressions(projections)
+          .partialAggregation(groupingKeys, aggregates, masks)
+          .finalAggregation()
+          .planNode());
 
   // Partial -> intermediate -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .projectExpressions(projections)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .intermediateAggregation()
-                      .finalAggregation()
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .values(inputVectors)
+          .projectExpressions(projections)
+          .partialAggregation(groupingKeys, aggregates, masks)
+          .intermediateAggregation()
+          .finalAggregation()
+          .planNode());
 
   // Partial -> local exchange -> final aggregation plan.
   auto numSources = std::min<size_t>(4, inputVectors.size());
@@ -553,23 +552,25 @@ void makeAlternativePlansWithTableScan(
 // the false negatives.
 #ifndef TSAN_BUILD
   // Partial -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .projectExpressions(projections)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .localPartition(groupingKeys)
-                      .finalAggregation()
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .projectExpressions(projections)
+          .partialAggregation(groupingKeys, aggregates, masks)
+          .localPartition(groupingKeys)
+          .finalAggregation()
+          .planNode());
 
   // Partial -> intermediate -> final aggregation plan.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .projectExpressions(projections)
-                      .partialAggregation(groupingKeys, aggregates, masks)
-                      .localPartition(groupingKeys)
-                      .intermediateAggregation()
-                      .finalAggregation()
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .projectExpressions(projections)
+          .partialAggregation(groupingKeys, aggregates, masks)
+          .localPartition(groupingKeys)
+          .intermediateAggregation()
+          .finalAggregation()
+          .planNode());
 #endif
 }
 
@@ -581,17 +582,18 @@ void makeStreamingPlansWithValues(
     const std::vector<core::ExprPtr>& projections,
     std::vector<core::PlanNodePtr>& plans) {
   // Single aggregation.
-  plans.push_back(PlanBuilder()
-                      .values(inputVectors)
-                      .projectExpressions(projections)
-                      .orderBy(groupingKeys, false)
-                      .streamingAggregation(
-                          groupingKeys,
-                          aggregates,
-                          masks,
-                          core::AggregationNode::Step::kSingle,
-                          false)
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .values(inputVectors)
+          .projectExpressions(projections)
+          .orderBy(groupingKeys, false)
+          .streamingAggregation(
+              groupingKeys,
+              aggregates,
+              masks,
+              core::AggregationNode::Step::kSingle,
+              false)
+          .planNode());
 
   // Partial -> final aggregation plan.
   plans.push_back(
@@ -646,17 +648,18 @@ void makeStreamingPlansWithTableScan(
     const std::vector<core::ExprPtr>& projections,
     std::vector<core::PlanNodePtr>& plans) {
   // Single aggregation.
-  plans.push_back(PlanBuilder()
-                      .tableScan(inputRowType)
-                      .projectExpressions(projections)
-                      .orderBy(groupingKeys, false)
-                      .streamingAggregation(
-                          groupingKeys,
-                          aggregates,
-                          masks,
-                          core::AggregationNode::Step::kSingle,
-                          false)
-                      .planNode());
+  plans.push_back(
+      PlanBuilder()
+          .tableScan(inputRowType)
+          .projectExpressions(projections)
+          .orderBy(groupingKeys, false)
+          .streamingAggregation(
+              groupingKeys,
+              aggregates,
+              masks,
+              core::AggregationNode::Step::kSingle,
+              false)
+          .planNode());
 
   // Partial -> final aggregation plan.
   plans.push_back(
@@ -891,7 +894,7 @@ bool AggregationFuzzer::verifySortedAggregation(
 
   if (customVerification &&
       (!aggregateOrderSensitive || customVerifier == nullptr ||
-       customVerifier->supportsVerify())) {
+       customVerifier->supportsVerify() || customVerifier->supportsCompare())) {
     // 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
@@ -899,13 +902,12 @@ bool AggregationFuzzer::verifySortedAggregation(
     //    verification of this aggregation) or
     // 3) the custom verifier supports verification (it can't compare the
     //    results of the aggregation with the reference DB)
+    // 4) the custom verifier supports compare.
     // 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.
+    // If custom verification is not enabled, then compare the results directly.
     return compareEquivalentPlanResults(plans, false, input, nullptr, 1);
   }
 }
@@ -1059,7 +1061,8 @@ bool AggregationFuzzer::compareEquivalentPlanResults(
                   expectedResult.value(),
                   firstPlan->outputType(),
                   {resultOrError.result}),
-              "Velox and reference DB results don't match");
+              "Velox and reference DB results don't match, plan: {}",
+              firstPlan->toString(true, true));
           LOG(INFO) << "Verified results against reference DB";
         }
       } else if (referenceQueryRunner_->supportsVeloxVectorResults()) {
diff --git a/velox/exec/fuzzer/AggregationFuzzerBase.cpp b/velox/exec/fuzzer/AggregationFuzzerBase.cpp
index 2bd16248fbdd..31606d040c3a 100644
--- a/velox/exec/fuzzer/AggregationFuzzerBase.cpp
+++ b/velox/exec/fuzzer/AggregationFuzzerBase.cpp
@@ -303,8 +303,9 @@ std::vector<RowVectorPtr> AggregationFuzzerBase::generateInputData(
       children.push_back(vectorFuzzer_.fuzz(inputType->childAt(j), size));
     }
 
-    input.push_back(std::make_shared<RowVector>(
-        pool_.get(), inputType, nullptr, size, std::move(children)));
+    input.push_back(
+        std::make_shared<RowVector>(
+            pool_.get(), inputType, nullptr, size, std::move(children)));
   }
 
   if (generator != nullptr) {
@@ -404,16 +405,18 @@ std::vector<RowVectorPtr> AggregationFuzzerBase::generateInputDataWithRowNumber(
         // 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(
-            partitionNulls, partitionIndices, size, baseVector));
+        children.push_back(
+            BaseVector::wrapInDictionary(
+                partitionNulls, partitionIndices, size, baseVector));
       } else if (
           windowFrameBoundsSet.find(names[i]) != windowFrameBoundsSet.end()) {
         // Frame bound columns cannot have NULLs.
         children.push_back(vectorFuzzer_.fuzzNotNull(types[i], size));
       } else if (sortingKeySet.find(names[i]) != sortingKeySet.end()) {
         auto baseVector = vectorFuzzer_.fuzz(types[i], numPeerGroups);
-        children.push_back(BaseVector::wrapInDictionary(
-            sortingNulls, sortingIndices, size, baseVector));
+        children.push_back(
+            BaseVector::wrapInDictionary(
+                sortingNulls, sortingIndices, size, baseVector));
       } else {
         children.push_back(vectorFuzzer_.fuzz(types[i], size));
       }
@@ -553,13 +556,19 @@ void AggregationFuzzerBase::testPlan(
     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);
+  try {
+    auto actual = execute(
+        planWithSplits.plan,
+        planWithSplits.splits,
+        injectSpill,
+        abandonPartial,
+        maxDrivers);
+    compare(actual, customVerification, customVerifiers, expected);
+  } catch (...) {
+    LOG(ERROR) << "Failed while testing plan: "
+               << planWithSplits.plan->toString(true, true);
+    throw;
+  }
 }
 
 void AggregationFuzzerBase::compare(
@@ -606,10 +615,12 @@ void AggregationFuzzerBase::compare(
       VELOX_CHECK(
           verifier->compare(expected.result, actual.result),
           "Logically equivalent plans produced different results");
+      LOG(INFO) << "Verified through custom verifier.";
     } else if (verifier->supportsVerify()) {
       VELOX_CHECK(
           verifier->verify(actual.result),
           "Result of a logically equivalent plan failed custom verification");
+      LOG(INFO) << "Verified through custom verifier.";
     } else {
       VELOX_UNREACHABLE(
           "Custom verifier must support either 'compare' or 'verify' API.");
diff --git a/velox/exec/fuzzer/AggregationFuzzerBase.h b/velox/exec/fuzzer/AggregationFuzzerBase.h
index 668fc9f6ecb6..e058bd898761 100644
--- a/velox/exec/fuzzer/AggregationFuzzerBase.h
+++ b/velox/exec/fuzzer/AggregationFuzzerBase.h
@@ -81,8 +81,6 @@ class AggregationFuzzerBase {
                                       : getFuzzerOptions(timestampPrecision),
             pool_.get()} {
     filesystems::registerLocalFileSystem();
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
     registerHiveConnector(hiveConfigs);
     dwrf::registerDwrfReaderFactory();
     dwrf::registerDwrfWriterFactory();
@@ -123,6 +121,7 @@ class AggregationFuzzerBase {
     opts.stringVariableLength = true;
     opts.stringLength = 4'000;
     opts.nullRatio = FLAGS_null_ratio;
+    opts.useRandomNullPattern = true;
     opts.timestampPrecision = timestampPrecision;
     return opts;
   }
diff --git a/velox/exec/fuzzer/AggregationFuzzerRunner.h b/velox/exec/fuzzer/AggregationFuzzerRunner.h
index dc8d15928e7c..6aa044d84efe 100644
--- a/velox/exec/fuzzer/AggregationFuzzerRunner.h
+++ b/velox/exec/fuzzer/AggregationFuzzerRunner.h
@@ -101,7 +101,7 @@ class AggregationFuzzerRunner {
     if (filteredSignatures.empty()) {
       LOG(ERROR)
           << "No aggregate functions left after filtering using 'only' and 'skip' lists.";
-      exit(1);
+      return 1;
     }
 
     facebook::velox::parse::registerTypeResolver();
diff --git a/velox/exec/fuzzer/CMakeLists.txt b/velox/exec/fuzzer/CMakeLists.txt
index 50b945562b7a..eadc76d8a283 100644
--- a/velox/exec/fuzzer/CMakeLists.txt
+++ b/velox/exec/fuzzer/CMakeLists.txt
@@ -20,10 +20,20 @@ add_library(
   PrestoQueryRunner.cpp
   PrestoQueryRunnerIntermediateTypeTransforms.cpp
   PrestoQueryRunnerTimestampWithTimeZoneTransform.cpp
+  PrestoQueryRunnerJsonTransform.cpp
+  PrestoQueryRunnerIntervalTransform.cpp
   PrestoQueryRunnerToSqlPlanNodeVisitor.cpp
   FuzzerUtil.cpp
   PrestoSql.cpp
-  PrestoQueryRunnerIntermediateTypeTransforms.cpp)
+)
+
+# TODO Add VeloxQueryRunner to velox_fuzzer_util to support in
+# ExpressionFuzzerTest. More information can be found here:
+# https://github.com/facebookincubator/velox/issues/15414
+if(VELOX_ENABLE_REMOTE_FUNCTIONS)
+  target_sources(velox_fuzzer_util PRIVATE VeloxQueryRunner.cpp)
+  target_link_libraries(velox_fuzzer_util FBThrift::thriftcpp2)
+endif()
 
 target_link_libraries(
   velox_fuzzer_util
@@ -33,14 +43,14 @@ target_link_libraries(
   velox_exec_test_lib
   velox_expression_functions
   velox_presto_types
-  cpr::cpr
-  Boost::regex
-  velox_type_parser
+  CURL::libcurl
+  velox_presto_type_parser
   Folly::folly
   velox_hive_connector
   velox_dwio_dwrf_writer
   velox_dwio_catalog_fbhive
-  velox_dwio_faulty_file_sink)
+  velox_dwio_faulty_file_sink
+)
 
 add_library(velox_aggregation_fuzzer_base AggregationFuzzerBase.cpp)
 
@@ -58,7 +68,8 @@ target_link_libraries(
   velox_fuzzer_util
   velox_expression_test_utility
   velox_vector
-  velox_core)
+  velox_core
+)
 
 add_library(velox_aggregation_fuzzer AggregationFuzzer.cpp)
 
@@ -69,7 +80,8 @@ target_link_libraries(
   velox_exec_test_lib
   velox_expression_test_utility
   velox_aggregation_fuzzer_base
-  velox_fuzzer_util)
+  velox_fuzzer_util
+)
 
 add_library(velox_window_fuzzer WindowFuzzer.cpp)
 
@@ -81,7 +93,8 @@ target_link_libraries(
   velox_exec_test_lib
   velox_expression_test_utility
   velox_aggregation_fuzzer_base
-  velox_temp_path)
+  velox_temp_path
+)
 
 add_library(velox_row_number_fuzzer_base_lib RowNumberFuzzerBase.cpp)
 
@@ -90,35 +103,39 @@ target_link_libraries(
   velox_dwio_dwrf_reader
   velox_fuzzer_util
   velox_vector_fuzzer
-  velox_exec_test_lib)
+  velox_exec_test_lib
+)
 
 add_library(velox_row_number_fuzzer_lib RowNumberFuzzer.cpp)
 
 target_link_libraries(
-  velox_row_number_fuzzer_lib velox_row_number_fuzzer_base_lib velox_type
-  velox_expression_test_utility)
+  velox_row_number_fuzzer_lib
+  velox_row_number_fuzzer_base_lib
+  velox_type
+  velox_expression_test_utility
+)
 
 # RowNumber Fuzzer.
 add_executable(velox_row_number_fuzzer RowNumberFuzzerRunner.cpp)
 
-target_link_libraries(
-  velox_row_number_fuzzer velox_row_number_fuzzer_lib)
+target_link_libraries(velox_row_number_fuzzer velox_row_number_fuzzer_lib)
 
 add_library(velox_topn_row_number_fuzzer_lib TopNRowNumberFuzzer.cpp)
 
 target_link_libraries(
-  velox_topn_row_number_fuzzer_lib velox_row_number_fuzzer_base_lib velox_type
-  velox_expression_test_utility)
+  velox_topn_row_number_fuzzer_lib
+  velox_row_number_fuzzer_base_lib
+  velox_type
+  velox_expression_test_utility
+)
 
 # TopNRowNumber Fuzzer.
 add_executable(velox_topn_row_number_fuzzer TopNRowNumberFuzzerRunner.cpp)
 
-target_link_libraries(
-  velox_topn_row_number_fuzzer velox_topn_row_number_fuzzer_lib)
+target_link_libraries(velox_topn_row_number_fuzzer velox_topn_row_number_fuzzer_lib)
 
 # Join Fuzzer.
-add_executable(velox_join_fuzzer JoinFuzzerRunner.cpp JoinFuzzer.cpp
-                                 JoinMaker.cpp)
+add_executable(velox_join_fuzzer JoinFuzzerRunner.cpp JoinFuzzer.cpp JoinMaker.cpp)
 
 target_link_libraries(
   velox_join_fuzzer
@@ -126,7 +143,21 @@ target_link_libraries(
   velox_vector_fuzzer
   velox_fuzzer_util
   velox_exec_test_lib
-  velox_expression_test_utility)
+  velox_expression_test_utility
+)
+
+# Spatial Join Fuzzer.
+add_executable(velox_spatial_join_fuzzer SpatialJoinFuzzerRunner.cpp SpatialJoinFuzzer.cpp)
+
+target_link_libraries(
+  velox_spatial_join_fuzzer
+  velox_type
+  velox_vector_fuzzer
+  velox_fuzzer_util
+  velox_exec_test_lib
+  velox_expression_test_utility
+  velox_vector_test_lib
+)
 
 add_library(velox_writer_fuzzer WriterFuzzer.cpp)
 
@@ -140,9 +171,15 @@ target_link_libraries(
   velox_temp_path
   velox_vector_test_lib
   velox_dwio_faulty_file_sink
-  velox_file_test_utils)
+  velox_file_test_utils
+)
 
-add_library(velox_memory_arbitration_fuzzer MemoryArbitrationFuzzer.cpp)
+# Arbitration Fuzzer.
+add_executable(
+  velox_memory_arbitration_fuzzer
+  MemoryArbitrationFuzzerRunner.cpp
+  MemoryArbitrationFuzzer.cpp
+)
 
 target_link_libraries(
   velox_memory_arbitration_fuzzer
@@ -153,19 +190,22 @@ target_link_libraries(
   velox_exec_test_lib
   velox_expression_test_utility
   velox_functions_prestosql
-  velox_aggregates)
+  velox_aggregates
+)
 
 add_library(velox_cache_fuzzer_lib CacheFuzzer.cpp)
 
 # Cache Fuzzer
 add_executable(velox_cache_fuzzer CacheFuzzerRunner.cpp)
 
-target_link_libraries(
-  velox_cache_fuzzer velox_cache_fuzzer_lib velox_fuzzer_util)
+target_link_libraries(velox_cache_fuzzer velox_cache_fuzzer_lib velox_fuzzer_util)
 
 target_link_libraries(
-  velox_cache_fuzzer_lib velox_dwio_common velox_temp_path
-  velox_vector_test_lib)
+  velox_cache_fuzzer_lib
+  velox_dwio_common
+  velox_temp_path
+  velox_vector_test_lib
+)
 
 # Exchange Fuzzer
 add_executable(velox_exchange_fuzzer ExchangeFuzzer.cpp)
@@ -175,7 +215,55 @@ target_link_libraries(
   velox_exec_test_lib
   velox_aggregates
   velox_vector_test_lib
-  velox_vector_fuzzer)
+  velox_vector_fuzzer
+)
+
+# LocalRunnerService (requires FBThrift support)
+if(VELOX_ENABLE_REMOTE_FUNCTIONS)
+  # Generate Thrift library for LocalRunnerService
+  include(FBThriftCppLibrary)
+  add_fbthrift_cpp_library(
+    local_runner_service_thrift
+    if/LocalRunnerService.thrift
+    SERVICES
+    LocalRunnerService
+  )
+
+  target_compile_options(local_runner_service_thrift PRIVATE -Wno-error=deprecated-declarations)
+
+  # LocalRunnerService Library
+  add_library(velox_local_runner_service_lib LocalRunnerService.cpp)
+
+  target_link_libraries(
+    velox_local_runner_service_lib
+    local_runner_service_thrift
+    velox_core
+    velox_exec
+    velox_exec_test_lib
+    velox_expression
+    velox_functions_prestosql
+    velox_common_base
+    velox_memory
+    Folly::folly
+    FBThrift::thriftcpp2
+    gflags
+    glog::glog
+  )
+
+  target_include_directories(velox_local_runner_service_lib PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+
+  # LocalRunnerService Executable
+  add_executable(velox_local_runner_service_runner LocalRunnerServiceRunner.cpp)
+
+  target_link_libraries(
+    velox_local_runner_service_runner
+    velox_local_runner_service_lib
+    velox_functions_prestosql
+    gtest
+    gflags
+    Folly::folly
+  )
+endif()
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/exec/fuzzer/CacheFuzzer.cpp b/velox/exec/fuzzer/CacheFuzzer.cpp
index 2ab9ef5354f6..8b4a311fbbdb 100644
--- a/velox/exec/fuzzer/CacheFuzzer.cpp
+++ b/velox/exec/fuzzer/CacheFuzzer.cpp
@@ -380,17 +380,18 @@ void CacheFuzzer::initializeInputs() {
     // 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,
-        fsStats,
-        withExecutor ? executor_.get() : nullptr,
-        readOptions));
+    inputs_.emplace_back(
+        std::make_unique<CachedBufferedInput>(
+            std::move(readFile),
+            MetricsLog::voidLog(),
+            fileIds_[i], // NOLINT
+            cache_.get(),
+            tracker,
+            fileIds_[i], // NOLINT
+            ioStats,
+            fsStats,
+            withExecutor ? executor_.get() : nullptr,
+            readOptions));
 
     // Divide file into fragments.
     std::vector<std::pair<int32_t, int32_t>> fragments;
diff --git a/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.cpp b/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.cpp
index 388e67ca36ad..4ec4f00ca5c1 100644
--- a/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.cpp
+++ b/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.cpp
@@ -277,7 +277,8 @@ void DuckQueryRunnerToSqlPlanNodeVisitor::visit(
     sql << inputType->nameOf(i);
   }
 
-  sql << ", row_number() OVER (";
+  sql << ", " << core::TopNRowNumberNode::rankFunctionName(node.rankFunction())
+      << "() OVER (";
 
   const auto& partitionKeys = node.partitionKeys();
   if (!partitionKeys.empty()) {
diff --git a/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.h b/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.h
index 72d0f2dd5419..d7566ed833f0 100644
--- a/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.h
+++ b/velox/exec/fuzzer/DuckQueryRunnerToSqlPlanNodeVisitor.h
@@ -106,6 +106,11 @@ class DuckQueryRunnerToSqlPlanNodeVisitor : public PrestoSqlPlanNodeVisitor {
       const core::NestedLoopJoinNode& node,
       core::PlanNodeVisitorContext& ctx) const override;
 
+  void visit(const core::SpatialJoinNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::OrderByNode&, core::PlanNodeVisitorContext&)
       const override {
     VELOX_NYI();
@@ -119,6 +124,12 @@ class DuckQueryRunnerToSqlPlanNodeVisitor : public PrestoSqlPlanNodeVisitor {
   void visit(const core::ProjectNode& node, core::PlanNodeVisitorContext& ctx)
       const override;
 
+  void visit(
+      const core::ParallelProjectNode& node,
+      core::PlanNodeVisitorContext& ctx) const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::RowNumberNode& node, core::PlanNodeVisitorContext& ctx)
       const override;
 
diff --git a/velox/exec/fuzzer/ExchangeFuzzer.cpp b/velox/exec/fuzzer/ExchangeFuzzer.cpp
index 4443b24fba21..84824658fc5d 100644
--- a/velox/exec/fuzzer/ExchangeFuzzer.cpp
+++ b/velox/exec/fuzzer/ExchangeFuzzer.cpp
@@ -409,9 +409,11 @@ class ExchangeFuzzer : public VectorTestBase {
         LOG(INFO) << "Terminating with error";
         exit(1);
       }
-      LOG(INFO) << "Memory after run="
-                << succinctBytes(memory::AllocationTraits::pageBytes(
-                       memory::memoryManager()->allocator()->numAllocated()));
+      LOG(INFO)
+          << "Memory after run="
+          << succinctBytes(
+                 memory::AllocationTraits::pageBytes(
+                     memory::memoryManager()->allocator()->numAllocated()));
 
       if (FLAGS_duration_sec == 0 && FLAGS_steps &&
           counter + 1 >= FLAGS_steps) {
diff --git a/velox/exec/fuzzer/FuzzerUtil.cpp b/velox/exec/fuzzer/FuzzerUtil.cpp
index b229fd3243f0..caafe71da5b5 100644
--- a/velox/exec/fuzzer/FuzzerUtil.cpp
+++ b/velox/exec/fuzzer/FuzzerUtil.cpp
@@ -323,20 +323,28 @@ TypePtr sanitizeTryResolveType(
     const exec::TypeSignature& typeSignature,
     const std::unordered_map<std::string, SignatureVariable>& variables,
     const std::unordered_map<std::string, TypePtr>& resolvedTypeVariables) {
-  return sanitize(SignatureBinder::tryResolveType(
-      typeSignature, variables, resolvedTypeVariables));
+  return sanitize(
+      SignatureBinder::tryResolveType(
+          typeSignature, variables, resolvedTypeVariables));
 }
 
 TypePtr sanitizeTryResolveType(
     const exec::TypeSignature& typeSignature,
     const std::unordered_map<std::string, SignatureVariable>& variables,
     const std::unordered_map<std::string, TypePtr>& typeVariablesBindings,
-    std::unordered_map<std::string, int>& integerVariablesBindings) {
-  return sanitize(SignatureBinder::tryResolveType(
-      typeSignature,
-      variables,
-      typeVariablesBindings,
-      integerVariablesBindings));
+    std::unordered_map<std::string, int>& integerVariablesBindings,
+    const std::unordered_map<std::string, LongEnumParameter>&
+        longEnumParameterVariablesBindings,
+    const std::unordered_map<std::string, VarcharEnumParameter>&
+        varcharEnumParameterVariablesBindings) {
+  return sanitize(
+      SignatureBinder::tryResolveType(
+          typeSignature,
+          variables,
+          typeVariablesBindings,
+          integerVariablesBindings,
+          longEnumParameterVariablesBindings,
+          varcharEnumParameterVariablesBindings));
 }
 
 void setupMemory(
@@ -353,11 +361,13 @@ void setupMemory(
   options.checkUsageLeak = true;
   options.arbitrationStateCheckCb = memoryArbitrationStateCheck;
   options.extraArbitratorConfigs = {
-      {std::string(velox::memory::SharedArbitrator::ExtraConfig::
-                       kGlobalArbitrationEnabled),
+      {std::string(
+           velox::memory::SharedArbitrator::ExtraConfig::
+               kGlobalArbitrationEnabled),
        enableGlobalArbitration ? "true" : "false"},
-      {std::string(velox::memory::SharedArbitrator::ExtraConfig::
-                       kMemoryPoolMinReclaimBytes),
+      {std::string(
+           velox::memory::SharedArbitrator::ExtraConfig::
+               kMemoryPoolMinReclaimBytes),
        "0B"}};
   facebook::velox::memory::MemoryManager::initialize(options);
 }
@@ -365,17 +375,13 @@ void setupMemory(
 void registerHiveConnector(
     const std::unordered_map<std::string, std::string>& hiveConfigs) {
   auto configs = hiveConfigs;
-  if (!connector::hasConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)) {
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
-  }
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              kHiveConnectorId,
-              std::make_shared<config::ConfigBase>(std::move(configs)));
+  // Make sure not to run out of open file descriptors.
+  configs[connector::hive::HiveConfig::kNumCacheFileHandles] = "1000";
+
+  connector::hive::HiveConnectorFactory factory;
+  auto hiveConnector = factory.newConnector(
+      kHiveConnectorId,
+      std::make_shared<config::ConfigBase>(std::move(configs)));
   connector::registerConnector(hiveConnector);
 }
 
diff --git a/velox/exec/fuzzer/FuzzerUtil.h b/velox/exec/fuzzer/FuzzerUtil.h
index dd8f7b37936a..5ad39818ca55 100644
--- a/velox/exec/fuzzer/FuzzerUtil.h
+++ b/velox/exec/fuzzer/FuzzerUtil.h
@@ -117,7 +117,11 @@ TypePtr sanitizeTryResolveType(
     const exec::TypeSignature& typeSignature,
     const std::unordered_map<std::string, SignatureVariable>& variables,
     const std::unordered_map<std::string, TypePtr>& typeVariablesBindings,
-    std::unordered_map<std::string, int>& integerVariablesBindings);
+    std::unordered_map<std::string, int>& integerVariablesBindings,
+    const std::unordered_map<std::string, LongEnumParameter>&
+        longEnumParameterVariablesBindings,
+    const std::unordered_map<std::string, VarcharEnumParameter>&
+        varcharEnumParameterVariablesBindings);
 
 // Invoked to set up memory system with arbitration.
 void setupMemory(
diff --git a/velox/exec/fuzzer/JoinFuzzer.cpp b/velox/exec/fuzzer/JoinFuzzer.cpp
index ded82a03a310..73a0ebf8f901 100644
--- a/velox/exec/fuzzer/JoinFuzzer.cpp
+++ b/velox/exec/fuzzer/JoinFuzzer.cpp
@@ -88,6 +88,7 @@ class JoinFuzzer {
     opts.stringVariableLength = true;
     opts.stringLength = 100;
     opts.nullRatio = FLAGS_null_ratio;
+    opts.useRandomNullPattern = true;
     opts.timestampPrecision =
         VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
     return opts;
@@ -205,14 +206,11 @@ JoinFuzzer::JoinFuzzer(
   // Make sure not to run out of open file descriptors.
   std::unordered_map<std::string, std::string> hiveConfig = {
       {connector::hive::HiveConfig::kNumCacheFileHandles, "1000"}};
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              test::kHiveConnectorId,
-              std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
+
+  connector::hive::HiveConnectorFactory factory;
+  auto hiveConnector = factory.newConnector(
+      test::kHiveConnectorId,
+      std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
   connector::registerConnector(hiveConnector);
   dwrf::registerDwrfReaderFactory();
   dwrf::registerDwrfWriterFactory();
diff --git a/velox/exec/fuzzer/JoinMaker.cpp b/velox/exec/fuzzer/JoinMaker.cpp
index 07e2b66d6b38..3e4631eb96a4 100644
--- a/velox/exec/fuzzer/JoinMaker.cpp
+++ b/velox/exec/fuzzer/JoinMaker.cpp
@@ -62,10 +62,11 @@ std::vector<core::PlanNodePtr> makeSourcesForPartitionedJoinPlan(
 
   std::vector<core::PlanNodePtr> sourceNodes;
   for (const auto& sourceInput : sourceInputs) {
-    sourceNodes.push_back(test::PlanBuilder(planNodeIdGenerator)
-                              .values(sourceInput)
-                              .projectExpressions(joinSource->projections())
-                              .planNode());
+    sourceNodes.push_back(
+        test::PlanBuilder(planNodeIdGenerator)
+            .values(sourceInput)
+            .projectExpressions(joinSource->projections())
+            .planNode());
   }
 
   return sourceNodes;
diff --git a/velox/exec/fuzzer/LocalRunnerService.cpp b/velox/exec/fuzzer/LocalRunnerService.cpp
new file mode 100644
index 000000000000..2475f6af40ed
--- /dev/null
+++ b/velox/exec/fuzzer/LocalRunnerService.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/exec/fuzzer/if/gen-cpp2/LocalRunnerService.h"
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/init/Init.h>
+#include <folly/json.h>
+#include <folly/portability/GFlags.h>
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <thrift/lib/cpp2/server/ThriftServer.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/memory/ByteStream.h"
+#include "velox/exec/fuzzer/LocalRunnerService.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/serializers/PrestoSerializer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::runner;
+
+namespace facebook::velox::runner {
+namespace {
+
+class StdoutCapture {
+ public:
+  StdoutCapture() {
+    oldCoutBuf_ = std::cout.rdbuf();
+    std::cout.rdbuf(buffer_.rdbuf());
+  }
+  ~StdoutCapture() {
+    std::cout.rdbuf(oldCoutBuf_);
+  }
+  std::string str() {
+    return buffer_.str();
+  }
+
+ private:
+  std::stringstream buffer_;
+  std::streambuf* oldCoutBuf_;
+};
+
+std::pair<RowVectorPtr, std::string> execute(
+    const std::string& serializedPlan,
+    const std::string& queryId,
+    std::shared_ptr<memory::MemoryPool> pool) {
+  StdoutCapture stdoutCapture;
+
+  core::PlanNodePtr plan;
+  try {
+    folly::dynamic planJson = folly::parseJson(serializedPlan);
+    VLOG(1) << "Deserializing plan:\n" << serializedPlan;
+    plan = core::PlanNode::deserialize<core::PlanNode>(planJson, pool.get());
+  } catch (const std::exception& e) {
+    throw std::runtime_error(
+        fmt::format("Failed to deserialize plan: {}", e.what()));
+  }
+  VLOG(1) << "Deserialized plan:\n" << plan->toString(true, true);
+
+  try {
+    exec::test::AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.config("session_timezone", "America/Los_Angeles");
+
+    std::shared_ptr<exec::Task> task;
+    auto results = queryBuilder.copyResults(pool.get(), task);
+
+    return {results, stdoutCapture.str()};
+  } catch (const std::exception& e) {
+    throw std::runtime_error(
+        fmt::format("Error executing query: {}", e.what()));
+  }
+}
+
+} // namespace
+
+std::string serializeBatch(
+    const RowVectorPtr& rowVector,
+    memory::MemoryPool* pool) {
+  std::ostringstream out;
+
+  OStreamOutputStream outputStream(&out);
+
+  auto serde = std::make_unique<serializer::presto::PrestoVectorSerde>();
+  serializer::presto::PrestoVectorSerde::PrestoOptions options;
+
+  auto serializer = serde->createBatchSerializer(pool, &options);
+  serializer->serialize(rowVector, &outputStream);
+
+  return out.str();
+}
+
+std::vector<Batch> convertToBatches(
+    const std::vector<RowVectorPtr>& rowVectors,
+    memory::MemoryPool* pool) {
+  std::vector<Batch> results;
+
+  if (rowVectors.empty()) {
+    return results;
+  }
+
+  auto leafPool = pool->addLeafChild("batchSerialization");
+
+  for (const auto& rowVector : rowVectors) {
+    Batch result;
+    const auto& rowType = rowVector->type()->asRow();
+
+    for (auto i = 0; i < rowType.size(); ++i) {
+      result.columnNames()->push_back(rowType.nameOf(i));
+      result.columnTypes()->push_back(rowType.childAt(i)->toString());
+    }
+
+    std::string serializedData = serializeBatch(rowVector, leafPool.get());
+    result.serializedData() = std::move(serializedData);
+
+    results.push_back(std::move(result));
+  }
+
+  return results;
+}
+
+void LocalRunnerServiceHandler::execute(
+    ExecutePlanResponse& response,
+    std::unique_ptr<ExecutePlanRequest> request) {
+  VLOG(1) << "Received executePlan request";
+
+  auto rootPool = memory::memoryManager()->addRootPool();
+  auto pool = rootPool->addLeafChild("localRunnerHandler");
+
+  RowVectorPtr results;
+  std::string output;
+
+  try {
+    VLOG(1) << "Executing plan in service handler";
+    std::tie(results, output) =
+        ::execute(*request->serializedPlan(), *request->queryId(), pool);
+
+    VLOG(1) << fmt::format(
+        "Result:\nresult rowVector: {}\nstdout: {}",
+        results->toString(true),
+        output);
+  } catch (const std::exception& e) {
+    VLOG(1) << "Exception executing plan: " << e.what();
+    response.success() = false;
+    response.errorMessage() = e.what();
+    return;
+  }
+
+  VLOG(1) << "Converting results to Thrift response";
+  auto resultBatches = convertToBatches({results}, rootPool.get());
+  response.results() = std::move(resultBatches);
+  response.output() = output;
+  response.success() = true;
+  VLOG(1) << "Response sent";
+}
+
+} // namespace facebook::velox::runner
diff --git a/velox/exec/fuzzer/LocalRunnerService.h b/velox/exec/fuzzer/LocalRunnerService.h
new file mode 100644
index 000000000000..dbd5f5d8f17f
--- /dev/null
+++ b/velox/exec/fuzzer/LocalRunnerService.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// Thrift service implementation and library for executing Velox query plans
+/// remotely.
+///
+/// This file provides conversion utilities and a service handler for the
+/// LocalRunnerService. It enables remote execution of serialized Velox
+/// expression evaluation primarily used for fuzzing where query plans need to
+/// be executed on remote workers.
+
+#pragma once
+
+#include <folly/init/Init.h>
+#include <folly/json.h>
+#include <folly/portability/GFlags.h>
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+#include <thrift/lib/cpp2/server/ThriftServer.h>
+
+#include "velox/exec/fuzzer/if/gen-cpp2/LocalRunnerService.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::runner {
+
+/// Converts a collection of Velox RowVectors into Thrift Batches using
+/// binary serialization.
+std::vector<Batch> convertToBatches(
+    const std::vector<RowVectorPtr>& rowVectors,
+    memory::MemoryPool* pool);
+
+/// Thrift service handler for executing Velox query plans.
+/// Executes a serialized Velox query plan. This method deserializes the plan
+/// from JSON, configures execution, runs the query plan to completion,
+/// converts results to Thrift Batches and captures any subsequent errors or
+/// output. The method returns a Thrift response containing the results.
+class LocalRunnerServiceHandler
+    : public apache::thrift::ServiceHandler<LocalRunnerService> {
+ public:
+  void execute(
+      ExecutePlanResponse& response,
+      std::unique_ptr<ExecutePlanRequest> request) override;
+};
+
+} // namespace facebook::velox::runner
diff --git a/velox/exec/fuzzer/LocalRunnerServiceRunner.cpp b/velox/exec/fuzzer/LocalRunnerServiceRunner.cpp
new file mode 100644
index 000000000000..7bb15f9d355a
--- /dev/null
+++ b/velox/exec/fuzzer/LocalRunnerServiceRunner.cpp
@@ -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.
+ */
+
+#include <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+#include <thrift/lib/cpp2/server/ThriftServer.h>
+
+#include "velox/core/ITypedExpr.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/LocalRunnerService.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/type/Type.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::runner;
+
+DEFINE_int32(
+    port,
+    9091,
+    "LocalRunnerService port number to be used in conjunction with ExpressionFuzzerTest flag local_runner_port.");
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+
+  folly::Init init(&argc, &argv);
+
+  memory::initializeMemoryManager(memory::MemoryManager::Options{});
+  Type::registerSerDe();
+  core::PlanNode::registerSerDe();
+  core::ITypedExpr::registerSerDe();
+  functions::prestosql::registerAllScalarFunctions();
+  functions::prestosql::registerInternalFunctions();
+
+  std::shared_ptr<apache::thrift::ThriftServer> thriftServer =
+      std::make_shared<apache::thrift::ThriftServer>();
+  thriftServer->setPort(FLAGS_port);
+  thriftServer->setInterface(std::make_shared<LocalRunnerServiceHandler>());
+  thriftServer->setNumIOWorkerThreads(1);
+  thriftServer->setNumCPUWorkerThreads(1);
+
+  VLOG(1) << "Starting LocalRunnerService";
+  thriftServer->serve();
+
+  return 0;
+}
diff --git a/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp b/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp
index 4aaeee65b887..6d9988108b43 100644
--- a/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp
+++ b/velox/exec/fuzzer/MemoryArbitrationFuzzer.cpp
@@ -18,10 +18,10 @@
 #include <boost/random/uniform_int_distribution.hpp>
 
 #include <folly/concurrency/ConcurrentHashMap.h>
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/common/fuzzer/Utils.h"
-#include "velox/common/memory/SharedArbitrator.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h" // @manual
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h" // @manual
@@ -31,7 +31,6 @@
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/functions/sparksql/aggregates/Register.h"
 #include "velox/serializers/CompactRowSerializer.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/serializers/UnsafeRowSerializer.h"
@@ -78,14 +77,19 @@ DEFINE_int32(
     "Each second, the percentage chance of triggering global arbitration by "
     "calling shrinking pools globally.");
 
+DEFINE_double(
+    spillable_query_ratio,
+    0.7,
+    "The ratio of queries that are spillable.");
+
 DEFINE_double(
     spill_faulty_fs_ratio,
-    0.1,
+    0.2,
     "Chance of spill filesystem being faulty(expressed as double from 0 to 1)");
 
-DEFINE_int32(
+DEFINE_double(
     spill_fs_fault_injection_ratio,
-    0.01,
+    0.02,
     "The chance of actually injecting fault in file operations for spill "
     "filesystem. This is only applicable when 'spill_faulty_fs_ratio' is "
     "larger than 0");
@@ -96,9 +100,15 @@ DEFINE_int32(
     "After each specified number of milliseconds, abort a random task."
     "If given 0, no task will be aborted.");
 
+DEFINE_string(
+    plan_type,
+    "all",
+    "Type of plans to test. Options: all, hash_join, aggregate, "
+    "row_number, topn_row_number, order_by.");
+
 using namespace facebook::velox::tests::utils;
 
-namespace facebook::velox::exec::test {
+namespace facebook::velox::exec {
 namespace {
 
 using fuzzer::coinToss;
@@ -147,7 +157,7 @@ class MemoryArbitrationFuzzer {
     return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
   }
 
-  std::shared_ptr<TempDirectoryPath> maybeGenerateFaultySpillDirectory();
+  std::shared_ptr<test::TempDirectoryPath> maybeGenerateFaultySpillDirectory();
 
   // Returns a list of randomly generated key types for join and aggregation.
   std::vector<TypePtr> generateKeyTypes(int32_t numKeys);
@@ -158,7 +168,8 @@ class MemoryArbitrationFuzzer {
   // 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);
+      const std::vector<TypePtr>& keyTypes,
+      int32_t minPayload = 0);
 
   // Reuses the 'generateInput' method to return randomly generated
   // probe input.
@@ -178,6 +189,12 @@ class MemoryArbitrationFuzzer {
       const std::vector<std::string>& keyNames,
       const std::vector<TypePtr>& keyTypes);
 
+  // Reuses the 'generateInput' method to return randomly generated
+  // topN row number input.
+  std::vector<RowVectorPtr> generateTopNRowNumberInput(
+      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(
@@ -207,6 +224,8 @@ class MemoryArbitrationFuzzer {
 
   std::vector<PlanWithSplits> rowNumberPlans(const std::string& tableDir);
 
+  std::vector<PlanWithSplits> topNRowNumberPlans(const std::string& tableDir);
+
   std::vector<PlanWithSplits> orderByPlans(const std::string& tableDir);
 
   // Helper method that combines all above plan methods into one.
@@ -223,6 +242,9 @@ class MemoryArbitrationFuzzer {
     return opts;
   }
 
+  std::string extractQueryIdFromSpillPath(const std::string& spillPath);
+
+  const std::string kQueryIdPrefix = "query_id_";
   FuzzerGenerator rng_;
   size_t currentSeed_{0};
   std::unordered_map<std::string, std::string> queryConfigsWithSpill_{
@@ -231,6 +253,7 @@ class MemoryArbitrationFuzzer {
       {core::QueryConfig::kSpillStartPartitionBit, "29"},
       {core::QueryConfig::kAggregationSpillEnabled, "true"},
       {core::QueryConfig::kRowNumberSpillEnabled, "true"},
+      {core::QueryConfig::kTopNRowNumberSpillEnabled, "true"},
       {core::QueryConfig::kOrderBySpillEnabled, "true"},
   };
 
@@ -240,7 +263,7 @@ class MemoryArbitrationFuzzer {
           memory::kMaxMemory,
           memory::MemoryReclaimer::create())};
   std::shared_ptr<memory::MemoryPool> pool_{
-      memory::memoryManager()->testingDefaultRoot().addLeafChild(
+      memory::memoryManager()->deprecatedSysRootPool().addLeafChild(
           "memoryArbitrationFuzzerLeaf",
           true)};
   std::shared_ptr<memory::MemoryPool> writerPool_{rootPool_->addAggregateChild(
@@ -250,12 +273,16 @@ class MemoryArbitrationFuzzer {
   VectorFuzzer vectorFuzzer_;
   std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::hardware_concurrency())};
   folly::Synchronized<Stats> stats_;
 };
 
 MemoryArbitrationFuzzer::MemoryArbitrationFuzzer(size_t initialSeed)
     : vectorFuzzer_{getFuzzerOptions(), pool_.get()} {
+  // Set timestamp precision as milliseconds, as timestamp may be used as
+  // paritition key, and presto doesn't supports nanosecond precision.
+  vectorFuzzer_.getMutableOptions().timestampPrecision =
+      fuzzer::FuzzerTimestampPrecision::kMilliSeconds;
   if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
   }
@@ -268,14 +295,11 @@ MemoryArbitrationFuzzer::MemoryArbitrationFuzzer(size_t initialSeed)
   // Make sure not to run out of open file descriptors.
   std::unordered_map<std::string, std::string> hiveConfig = {
       {connector::hive::HiveConfig::kNumCacheFileHandles, "1000"}};
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
-  const auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              kHiveConnectorId,
-              std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
+
+  connector::hive::HiveConnectorFactory hiveFactory;
+  const auto hiveConnector = hiveFactory.newConnector(
+      test::kHiveConnectorId,
+      std::make_shared<config::ConfigBase>(std::move(hiveConfig)));
   connector::registerConnector(hiveConnector);
   dwrf::registerDwrfReaderFactory();
   dwrf::registerDwrfWriterFactory();
@@ -318,7 +342,8 @@ MemoryArbitrationFuzzer::generatePartitionKeys() {
 
 std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateInput(
     const std::vector<std::string>& keyNames,
-    const std::vector<TypePtr>& keyTypes) {
+    const std::vector<TypePtr>& keyTypes,
+    int32_t minPayload) {
   std::vector<std::string> names = keyNames;
   std::vector<TypePtr> types = keyTypes;
 
@@ -330,8 +355,7 @@ std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateInput(
     }
   }
 
-  // Add up to 3 payload columns.
-  const auto numPayload = randInt(0, 3);
+  const auto numPayload = randInt(minPayload, 3);
   for (auto i = 0; i < numPayload; ++i) {
     names.push_back(fmt::format("tp{}", i + keyNames.size()));
     types.push_back(vectorFuzzer_.randType(2 /*maxDepth*/));
@@ -426,6 +450,12 @@ std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateRowNumberInput(
   return generateInput(keyNames, keyTypes);
 }
 
+std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateTopNRowNumberInput(
+    const std::vector<std::string>& keyNames,
+    const std::vector<TypePtr>& keyTypes) {
+  return generateInput(keyNames, keyTypes, 1);
+}
+
 std::vector<RowVectorPtr> MemoryArbitrationFuzzer::generateOrderByInput(
     const std::vector<std::string>& keyNames,
     const std::vector<TypePtr>& keyTypes) {
@@ -445,7 +475,7 @@ MemoryArbitrationFuzzer::hashJoinPlans(
       (core::isLeftSemiProjectJoin(joinType) ||
        core::isLeftSemiFilterJoin(joinType) || core::isAntiJoin(joinType))
       ? asRowType(probeInput[0]->type())->names()
-      : concat(
+      : test::concat(
             asRowType(probeInput[0]->type()), asRowType(buildInput[0]->type()))
             ->names();
 
@@ -456,22 +486,23 @@ MemoryArbitrationFuzzer::hashJoinPlans(
 
   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();
+  auto plan = test::PlanBuilder(planNodeIdGenerator)
+                  .values(probeInput)
+                  .hashJoin(
+                      probeKeys,
+                      buildKeys,
+                      test::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())) {
+  if (!test::isTableScanSupported(probeInput[0]->type()) ||
+      !test::isTableScanSupported(buildInput[0]->type())) {
     return plans;
   }
 
@@ -480,13 +511,13 @@ MemoryArbitrationFuzzer::hashJoinPlans(
   const auto buildType = asRowType(buildInput[0]->type());
   core::PlanNodeId probeScanId;
   core::PlanNodeId buildScanId;
-  plan = PlanBuilder(planNodeIdGenerator)
+  plan = test::PlanBuilder(planNodeIdGenerator)
              .tableScan(probeType)
              .capturePlanNodeId(probeScanId)
              .hashJoin(
                  probeKeys,
                  buildKeys,
-                 PlanBuilder(planNodeIdGenerator)
+                 test::PlanBuilder(planNodeIdGenerator)
                      .tableScan(buildType)
                      .capturePlanNodeId(buildScanId)
                      .planNode(),
@@ -495,9 +526,10 @@ MemoryArbitrationFuzzer::hashJoinPlans(
                  joinType,
                  false)
              .planNode();
-  plans.push_back(PlanWithSplits{
-      std::move(plan),
-      {{probeScanId, probeSplits}, {buildScanId, buildSplits}}});
+  plans.push_back(
+      PlanWithSplits{
+          std::move(plan),
+          {{probeScanId, probeSplits}, {buildScanId, buildSplits}}});
   return plans;
 }
 
@@ -513,14 +545,14 @@ MemoryArbitrationFuzzer::hashJoinPlans(const std::string& tableDir) {
 
   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());
+  std::vector<std::string> probeKeys = test::makeNames("t", keyTypes.size());
+  std::vector<std::string> buildKeys = test::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_);
+  const std::vector<Split> probeScanSplits = test::makeSplits(
+      probeInput, fmt::format("{}/probe", tableDir), writerPool_);
+  const std::vector<Split> buildScanSplits = test::makeSplits(
+      buildInput, fmt::format("{}/build", tableDir), writerPool_);
 
   std::vector<PlanWithSplits> totalPlans;
   for (const auto& joinType : kJoinTypes) {
@@ -545,10 +577,11 @@ 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 std::vector<std::string> groupingKeys =
+      test::makeNames("g", keyTypes.size());
   const auto aggregateInput = generateAggregateInput(groupingKeys, keyTypes);
   const std::vector<std::string> aggregates{"count(1)"};
-  const std::vector<Split> splits = makeSplits(
+  const std::vector<Split> splits = test::makeSplits(
       aggregateInput, fmt::format("{}/aggregate", tableDir), writerPool_);
 
   std::vector<PlanWithSplits> plans;
@@ -559,7 +592,7 @@ MemoryArbitrationFuzzer::aggregatePlans(const std::string& tableDir) {
         std::make_shared<core::PlanNodeIdGenerator>();
     core::PlanNodeId scanId;
     auto plan = PlanWithSplits{
-        PlanBuilder(planNodeIdGenerator)
+        test::PlanBuilder(planNodeIdGenerator)
             .tableScan(inputRowType)
             .capturePlanNodeId(scanId)
             .singleAggregation(groupingKeys, aggregates, {})
@@ -568,7 +601,7 @@ MemoryArbitrationFuzzer::aggregatePlans(const std::string& tableDir) {
     plans.push_back(std::move(plan));
 
     plan = PlanWithSplits{
-        PlanBuilder()
+        test::PlanBuilder()
             .values(aggregateInput)
             .singleAggregation(groupingKeys, aggregates, {})
             .planNode(),
@@ -582,7 +615,7 @@ MemoryArbitrationFuzzer::aggregatePlans(const std::string& tableDir) {
         std::make_shared<core::PlanNodeIdGenerator>();
     core::PlanNodeId scanId;
     auto plan = PlanWithSplits{
-        PlanBuilder(planNodeIdGenerator)
+        test::PlanBuilder(planNodeIdGenerator)
             .tableScan(inputRowType)
             .capturePlanNodeId(scanId)
             .partialAggregation(groupingKeys, aggregates, {})
@@ -592,7 +625,7 @@ MemoryArbitrationFuzzer::aggregatePlans(const std::string& tableDir) {
     plans.push_back(std::move(plan));
 
     plan = PlanWithSplits{
-        PlanBuilder()
+        test::PlanBuilder()
             .values(aggregateInput)
             .partialAggregation(groupingKeys, aggregates, {})
             .finalAggregation()
@@ -607,7 +640,7 @@ MemoryArbitrationFuzzer::aggregatePlans(const std::string& tableDir) {
         std::make_shared<core::PlanNodeIdGenerator>();
     core::PlanNodeId scanId;
     auto plan = PlanWithSplits{
-        PlanBuilder(planNodeIdGenerator)
+        test::PlanBuilder(planNodeIdGenerator)
             .tableScan(inputRowType)
             .capturePlanNodeId(scanId)
             .partialAggregation(groupingKeys, aggregates, {})
@@ -618,7 +651,7 @@ MemoryArbitrationFuzzer::aggregatePlans(const std::string& tableDir) {
     plans.push_back(std::move(plan));
 
     plan = PlanWithSplits{
-        PlanBuilder()
+        test::PlanBuilder()
             .values(aggregateInput)
             .partialAggregation(groupingKeys, aggregates, {})
             .intermediateAggregation()
@@ -641,7 +674,7 @@ MemoryArbitrationFuzzer::rowNumberPlans(const std::string& tableDir) {
   std::vector<std::string> projectFields = keyNames;
   projectFields.emplace_back("row_number");
   auto plan = PlanWithSplits{
-      PlanBuilder()
+      test::PlanBuilder()
           .values(input)
           .rowNumber(keyNames)
           .project(projectFields)
@@ -649,17 +682,17 @@ MemoryArbitrationFuzzer::rowNumberPlans(const std::string& tableDir) {
       {}};
   plans.push_back(std::move(plan));
 
-  if (!isTableScanSupported(input[0]->type())) {
+  if (!test::isTableScanSupported(input[0]->type())) {
     return plans;
   }
 
-  const std::vector<Split> splits =
-      makeSplits(input, fmt::format("{}/row_number", tableDir), writerPool_);
+  const std::vector<Split> splits = test::makeSplits(
+      input, fmt::format("{}/row_number", tableDir), writerPool_);
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId scanId;
   plan = PlanWithSplits{
-      PlanBuilder(planNodeIdGenerator)
+      test::PlanBuilder(planNodeIdGenerator)
           .tableScan(asRowType(input[0]->type()))
           .capturePlanNodeId(scanId)
           .rowNumber(keyNames)
@@ -671,6 +704,90 @@ MemoryArbitrationFuzzer::rowNumberPlans(const std::string& tableDir) {
   return plans;
 }
 
+std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
+MemoryArbitrationFuzzer::topNRowNumberPlans(const std::string& tableDir) {
+  static const std::vector<std::string> kRankFunctions = {
+      "row_number", "rank", "dense_rank"};
+
+  const auto [keyNames, keyTypes] = generatePartitionKeys();
+  const auto input = generateTopNRowNumberInput(keyNames, keyTypes);
+
+  std::vector<PlanWithSplits> plans;
+
+  const auto inputType = asRowType(input[0]->type());
+  std::vector<std::string> sortingKeys;
+
+  std::unordered_set<std::string> partitionKeySet(
+      keyNames.begin(), keyNames.end());
+  for (const auto& name : inputType->names()) {
+    if (partitionKeySet.find(name) == partitionKeySet.end()) {
+      sortingKeys.push_back(name);
+    }
+  }
+
+  const auto numSortingKeys = randInt(1, sortingKeys.size());
+  sortingKeys.resize(numSortingKeys);
+
+  const auto rankFunction =
+      kRankFunctions[randInt(0, kRankFunctions.size() - 1)];
+  const auto limit = randInt(1, 100);
+  const bool generateRowNumber = vectorFuzzer_.coinToss(0.5);
+
+  std::vector<std::string> projectFields = keyNames;
+  if (generateRowNumber) {
+    projectFields.emplace_back("row_number");
+  }
+
+  // Values plan with Partiton Keys
+  auto plan = PlanWithSplits{
+      test::PlanBuilder()
+          .values(input)
+          .topNRank(
+              rankFunction, keyNames, sortingKeys, limit, generateRowNumber)
+          .project(projectFields)
+          .planNode(),
+      {}};
+  plans.push_back(std::move(plan));
+
+  if (!test::isTableScanSupported(input[0]->type())) {
+    return plans;
+  }
+
+  const std::vector<Split> splits = test::makeSplits(
+      input, fmt::format("{}/topn_row_number", tableDir), writerPool_);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanId;
+  // TableScan Plan with Parition Keys
+  plan = PlanWithSplits{
+      test::PlanBuilder(planNodeIdGenerator)
+          .tableScan(asRowType(input[0]->type()))
+          .capturePlanNodeId(scanId)
+          .topNRank(
+              rankFunction, keyNames, sortingKeys, limit, generateRowNumber)
+          .project(projectFields)
+          .planNode(),
+      {{scanId, splits}}};
+  plans.push_back(std::move(plan));
+
+  std::vector<std::string> globalProjectFields;
+  if (generateRowNumber) {
+    globalProjectFields.emplace_back("row_number");
+  }
+
+  // Global TopN
+  plan = PlanWithSplits{
+      test::PlanBuilder()
+          .values(input)
+          .topNRank(rankFunction, {}, sortingKeys, limit, generateRowNumber)
+          .project(globalProjectFields)
+          .planNode(),
+      {}};
+  plans.push_back(std::move(plan));
+
+  return plans;
+}
+
 std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
 MemoryArbitrationFuzzer::orderByPlans(const std::string& tableDir) {
   const auto [keyNames, keyTypes] = generatePartitionKeys();
@@ -679,20 +796,21 @@ MemoryArbitrationFuzzer::orderByPlans(const std::string& tableDir) {
   std::vector<PlanWithSplits> plans;
 
   auto plan = PlanWithSplits{
-      PlanBuilder().values(input).orderBy(keyNames, false).planNode(), {}};
+      test::PlanBuilder().values(input).orderBy(keyNames, false).planNode(),
+      {}};
   plans.push_back(std::move(plan));
 
-  if (!isTableScanSupported(input[0]->type())) {
+  if (!test::isTableScanSupported(input[0]->type())) {
     return plans;
   }
 
-  const std::vector<Split> splits =
-      makeSplits(input, fmt::format("{}/order_by", tableDir), writerPool_);
+  const std::vector<Split> splits = test::makeSplits(
+      input, fmt::format("{}/order_by", tableDir), writerPool_);
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId scanId;
   plan = PlanWithSplits{
-      PlanBuilder(std::move(planNodeIdGenerator))
+      test::PlanBuilder(std::move(planNodeIdGenerator))
           .tableScan(asRowType(input[0]->type()))
           .capturePlanNodeId(scanId)
           .orderBy(keyNames, false)
@@ -706,33 +824,62 @@ MemoryArbitrationFuzzer::orderByPlans(const std::string& tableDir) {
 std::vector<MemoryArbitrationFuzzer::PlanWithSplits>
 MemoryArbitrationFuzzer::allPlans(const std::string& tableDir) {
   std::vector<PlanWithSplits> plans;
-  for (const auto& plan : hashJoinPlans(tableDir)) {
-    plans.push_back(plan);
-  }
-  for (const auto& plan : aggregatePlans(tableDir)) {
-    plans.push_back(plan);
-  }
-  for (const auto& plan : rowNumberPlans(tableDir)) {
-    plans.push_back(plan);
-  }
-  for (const auto& plan : orderByPlans(tableDir)) {
-    plans.push_back(plan);
-  }
+  const std::string planType = FLAGS_plan_type;
+
+  auto appendPlansIf =
+      [&](const std::string& type,
+          std::function<std::vector<PlanWithSplits>(const std::string&)>
+              planGenerator) {
+        if (planType == "all" || planType == type) {
+          auto newPlans = planGenerator(tableDir);
+          plans.insert(
+              plans.end(),
+              std::make_move_iterator(newPlans.begin()),
+              std::make_move_iterator(newPlans.end()));
+        }
+      };
+  appendPlansIf("hash_join", [this](const std::string& dir) {
+    return hashJoinPlans(dir);
+  });
+  appendPlansIf("aggregate", [this](const std::string& dir) {
+    return aggregatePlans(dir);
+  });
+  appendPlansIf("row_number", [this](const std::string& dir) {
+    return rowNumberPlans(dir);
+  });
+  appendPlansIf("topn_row_number", [this](const std::string& dir) {
+    return topNRowNumberPlans(dir);
+  });
+  appendPlansIf(
+      "order_by", [this](const std::string& dir) { return orderByPlans(dir); });
+
+  VELOX_USER_CHECK(
+      !plans.empty(),
+      "No plans generated for plan_type: {}. Valid options are: all, hash_join, aggregate, row_number, topn_row_number, order_by",
+      planType);
+
   return plans;
 }
 
-struct ThreadLocalStats {
-  uint64_t spillFsFaultCount{0};
-};
+std::string MemoryArbitrationFuzzer::extractQueryIdFromSpillPath(
+    const std::string& spillPath) {
+  std::vector<std::string> parts;
+  folly::split('/', spillPath, parts);
+  for (const auto& part : parts) {
+    if (part.starts_with(kQueryIdPrefix)) {
+      return part;
+    }
+  }
+  VELOX_FAIL("No query id found in spill path: {}", spillPath);
+}
 
 // Stats that keeps track of per thread execution status in verify()
-thread_local ThreadLocalStats threadLocalStats;
+folly::ConcurrentHashMap<std::string, folly::Unit> spillFsTaskSet;
 
-std::shared_ptr<TempDirectoryPath>
+std::shared_ptr<test::TempDirectoryPath>
 MemoryArbitrationFuzzer::maybeGenerateFaultySpillDirectory() {
   FuzzerGenerator fsRng(rng_());
-  const auto injectFsFault =
-      coinToss(fsRng, FLAGS_spill_fs_fault_injection_ratio);
+  const auto injectFsFault = coinToss(fsRng, FLAGS_spill_faulty_fs_ratio);
   if (!injectFsFault) {
     return exec::test::TempDirectoryPath::create(false);
   }
@@ -756,10 +903,14 @@ MemoryArbitrationFuzzer::maybeGenerateFaultySpillDirectory() {
         }
         FuzzerGenerator fsRng(rng_());
         if (coinToss(fsRng, FLAGS_spill_fs_fault_injection_ratio)) {
-          ++threadLocalStats.spillFsFaultCount;
+          auto queryId = extractQueryIdFromSpillPath(op->path);
+          spillFsTaskSet.insert(queryId, folly::Unit());
           VELOX_FAIL(
-              "Fault file injection on {}",
-              FaultFileOperation::typeString(op->type));
+              "Fault file injection on {} of query {} path {}",
+              FaultFileOperation::typeString(op->type),
+              queryId,
+              op->path,
+              process::StackTrace().toString());
         }
       });
   return directory;
@@ -772,7 +923,7 @@ void MemoryArbitrationFuzzer::verify() {
   auto plans = allPlans(tableScanDir->getPath());
 
   SCOPE_EXIT {
-    waitForAllTasksToBeDeleted();
+    test::waitForAllTasksToBeDeleted();
     if (auto faultyFileSystem = std::dynamic_pointer_cast<FaultyFileSystem>(
             filesystems::getFileSystem(spillDirectory->getPath(), nullptr))) {
       faultyFileSystem->clearFileFaultInjections();
@@ -792,36 +943,34 @@ void MemoryArbitrationFuzzer::verify() {
     queryThreads.emplace_back([&, spillDirectory, i, seed]() {
       FuzzerGenerator rng(seed);
       while (!stop) {
-        const auto prevSpillFsFaultCount = threadLocalStats.spillFsFaultCount;
-        const auto queryId = fmt::format("query_id_{}", queryCount++);
+        const auto queryId = fmt::format("{}{}", kQueryIdPrefix, queryCount++);
         queryTaskAbortRequestMap.insert(queryId, false);
         try {
-          const auto queryCtx = newQueryCtx(
+          const auto queryCtx = test::newQueryCtx(
               memory::memoryManager(),
               executor_.get(),
               FLAGS_arbitrator_capacity,
               queryId);
 
           const auto plan = plans.at(getRandomIndex(rng, plans.size() - 1));
-          AssertQueryBuilder builder(plan.plan);
+          test::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());
+          if (coinToss(rng, FLAGS_spillable_query_ratio)) {
+            auto res = builder.configs(queryConfigsWithSpill_)
+                           .spillDirectory(
+                               spillDirectory->getPath() +
+                               fmt::format("/{}/{}", i, queryId))
+                           .queryCtx(queryCtx)
+                           .copyResults(pool_.get());
           } else {
-            auto res =
-                builder.configs(queryConfigsWithSpill_)
-                    .spillDirectory(
-                        spillDirectory->getPath() + fmt::format("/{}/", i))
-                    .queryCtx(queryCtx)
-                    .copyResults(pool_.get());
+            builder.queryCtx(queryCtx).copyResults(pool_.get());
           }
           ++stats_.wlock()->successCount;
-          VELOX_CHECK_EQ(
-              threadLocalStats.spillFsFaultCount, prevSpillFsFaultCount);
+          VELOX_CHECK(spillFsTaskSet.find(queryId) == spillFsTaskSet.end());
         } catch (const VeloxException& e) {
           auto lockedStats = stats_.wlock();
           if (e.errorCode() == error_code::kMemCapExceeded.c_str()) {
@@ -830,9 +979,28 @@ void MemoryArbitrationFuzzer::verify() {
             ++lockedStats->abortCount;
           } else if (e.errorCode() == error_code::kInvalidState.c_str()) {
             const auto injectedSpillFsFault =
-                threadLocalStats.spillFsFaultCount > prevSpillFsFaultCount;
+                spillFsTaskSet.find(queryId) != spillFsTaskSet.end();
+            if (injectedSpillFsFault) {
+              spillFsTaskSet.erase(queryId);
+            }
             const auto injectedTaskAbortRequest =
                 queryTaskAbortRequestMap.find(queryId)->second;
+
+            // Debug logging to understand the failure
+            if (!injectedSpillFsFault && !injectedTaskAbortRequest) {
+              LOG(ERROR) << "============== VELOX_CHECK failure debug info:";
+              LOG(ERROR) << "  queryId: " << queryId;
+              LOG(ERROR) << "  spillFsTaskSet size: " << spillFsTaskSet.size();
+              LOG(ERROR) << "  spillFsTaskSet contents:";
+              // Iterate through spillFsTaskSet to log contents
+              for (auto it = spillFsTaskSet.cbegin();
+                   it != spillFsTaskSet.cend();
+                   ++it) {
+                LOG(ERROR) << "    key: " << it->first;
+              }
+              LOG(ERROR) << "  error message: " << e.message();
+            }
+
             VELOX_CHECK(
                 injectedSpillFsFault || injectedTaskAbortRequest,
                 "injectedSpillFsFault: {}, injectedTaskAbortRequest: {}, error message: {}",
@@ -947,4 +1115,4 @@ void MemoryArbitrationFuzzer::go() {
 void memoryArbitrationFuzzer(size_t seed) {
   MemoryArbitrationFuzzer(seed).go();
 }
-} // namespace facebook::velox::exec::test
+} // namespace facebook::velox::exec
diff --git a/velox/exec/fuzzer/MemoryArbitrationFuzzer.h b/velox/exec/fuzzer/MemoryArbitrationFuzzer.h
index 73f32e2215d0..622d27084ae8 100644
--- a/velox/exec/fuzzer/MemoryArbitrationFuzzer.h
+++ b/velox/exec/fuzzer/MemoryArbitrationFuzzer.h
@@ -17,6 +17,6 @@
 
 #include <cstddef>
 
-namespace facebook::velox::exec::test {
+namespace facebook::velox::exec {
 void memoryArbitrationFuzzer(size_t seed);
 }
diff --git a/velox/exec/tests/MemoryArbitrationFuzzerTest.cpp b/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.cpp
similarity index 65%
rename from velox/exec/tests/MemoryArbitrationFuzzerTest.cpp
rename to velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.cpp
index 1ad0247fb887..cfa1e928c1d1 100644
--- a/velox/exec/tests/MemoryArbitrationFuzzerTest.cpp
+++ b/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.cpp
@@ -16,13 +16,16 @@
 
 #include <folly/init/Init.h>
 #include <gflags/gflags.h>
-#include <gtest/gtest.h>
 #include <unordered_set>
+
+#include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
 #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/MemoryArbitrationFuzzer.h"
 #include "velox/exec/fuzzer/PrestoQueryRunner.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 
@@ -39,13 +42,17 @@ DEFINE_int64(
 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
+  // singletons, installing proper signal handlers for a 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);
+  const size_t seed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
+
+  facebook::velox::serializer::presto::PrestoVectorSerde::registerVectorSerde();
+  facebook::velox::filesystems::registerLocalFileSystem();
+  facebook::velox::tests::utils::registerFaultyFileSystem();
+  facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  facebook::velox::aggregate::prestosql::registerAllAggregateFunctions();
+  memoryArbitrationFuzzer(seed);
 }
diff --git a/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.h b/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.h
deleted file mode 100644
index dfe8144bb21e..000000000000
--- a/velox/exec/fuzzer/MemoryArbitrationFuzzerRunner.h
+++ /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.
- */
-#pragma once
-
-#include <gtest/gtest.h>
-
-#include "velox/common/file/FileSystems.h"
-
-#include "velox/common/file/tests/FaultyFileSystem.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();
-    tests::utils::registerFaultyFileSystem();
-    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
index b545235b683e..a2d10ab3f845 100644
--- a/velox/exec/fuzzer/PrestoQueryRunner.cpp
+++ b/velox/exec/fuzzer/PrestoQueryRunner.cpp
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-#include <cpr/cpr.h> // @manual
+#include <curl/curl.h>
 #include <folly/json.h>
 #include <iostream>
+#include <string>
 #include <utility>
 
 #include "velox/common/base/Fs.h"
@@ -32,19 +33,35 @@
 #include "velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h"
 #include "velox/exec/fuzzer/PrestoSql.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/functions/prestosql/types/BingTileType.h"
+#include "velox/functions/prestosql/types/GeometryType.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
 #include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
+#include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/functions/prestosql/types/parser/TypeParser.h"
 #include "velox/serializers/PrestoSerializer.h"
-#include "velox/type/parser/TypeParser.h"
 
 using namespace facebook::velox;
 
 namespace facebook::velox::exec::test {
 namespace {
 
+static size_t
+writeFunction(char* data, size_t size, size_t nmemb, void* userdata) {
+  std::string* response = static_cast<std::string*>(userdata);
+  response->append(data, size * nmemb);
+  return size * nmemb;
+}
+
 void writeToFile(
     const std::string& path,
     const std::vector<RowVectorPtr>& data,
@@ -126,7 +143,9 @@ class ServerResponse {
     std::vector<TypePtr> types;
     for (const auto& column : response_["columns"]) {
       names.push_back(column["name"].asString());
-      types.push_back(parseType(column["type"].asString()));
+      types.push_back(
+          facebook::velox::functions::prestosql::parseType(
+              column["type"].asString()));
     }
 
     auto rowType = ROW(std::move(names), std::move(types));
@@ -191,7 +210,8 @@ const std::vector<TypePtr>& PrestoQueryRunner::supportedScalarTypes() const {
 
 // static
 bool PrestoQueryRunner::isSupportedDwrfType(const TypePtr& type) {
-  if (type->isDate() || type->isIntervalDayTime() || type->isUnKnown()) {
+  if (type->isDate() || type->isIntervalDayTime() || type->isUnKnown() ||
+      isGeometryType(type)) {
     return false;
   }
 
@@ -222,10 +242,10 @@ PrestoQueryRunner::inputProjections(
     // unchanged and the projection is just an identity mapping.
     if (isIntermediateOnlyType(childType)) {
       for (int batchIndex = 0; batchIndex < input.size(); batchIndex++) {
-        children[batchIndex].push_back(transformIntermediateOnlyType(
-            input[batchIndex]->childAt(childIndex)));
+        children[batchIndex].push_back(
+            transformIntermediateTypes(input[batchIndex]->childAt(childIndex)));
       }
-      projections.push_back(getIntermediateOnlyTypeProjectionExpr(
+      projections.push_back(getProjectionsToIntermediateTypes(
           childType,
           std::make_shared<core::FieldAccessExpr>(
               names[childIndex], names[childIndex]),
@@ -235,8 +255,9 @@ PrestoQueryRunner::inputProjections(
         children[batchIndex].push_back(input[batchIndex]->childAt(childIndex));
       }
 
-      projections.push_back(std::make_shared<core::FieldAccessExpr>(
-          names[childIndex], names[childIndex]));
+      projections.push_back(
+          std::make_shared<core::FieldAccessExpr>(
+              names[childIndex], names[childIndex]));
     }
   }
 
@@ -250,12 +271,13 @@ PrestoQueryRunner::inputProjections(
   std::vector<RowVectorPtr> output;
   output.reserve(input.size());
   for (int batchIndex = 0; batchIndex < input.size(); batchIndex++) {
-    output.push_back(std::make_shared<RowVector>(
-        input[batchIndex]->pool(),
-        rowType,
-        input[batchIndex]->nulls(),
-        input[batchIndex]->size(),
-        std::move(children[batchIndex])));
+    output.push_back(
+        std::make_shared<RowVector>(
+            input[batchIndex]->pool(),
+            rowType,
+            input[batchIndex]->nulls(),
+            input[batchIndex]->size(),
+            std::move(children[batchIndex])));
   }
 
   return std::make_pair(output, projections);
@@ -301,27 +323,45 @@ bool PrestoQueryRunner::isConstantExprSupported(
     return type->isPrimitiveType() && !type->isTimestamp() &&
         !isJsonType(type) && !type->isIntervalDayTime() &&
         !isIPAddressType(type) && !isIPPrefixType(type) && !isUuidType(type) &&
-        !isTimestampWithTimeZoneType(type);
+        !isTimestampWithTimeZoneType(type) && !isHyperLogLogType(type) &&
+        !isKHyperLogLogType(type) && !isTDigestType(type) &&
+        !isQDigestType(type) && !isSetDigestType(type) &&
+        !isBingTileType(type) && !isSfmSketchType(type) &&
+        !isTimeWithTimeZone(type);
   }
   return true;
 }
 
 bool PrestoQueryRunner::isSupported(const exec::FunctionSignature& signature) {
-  // TODO: support queries with these types. Among the types below, hugeint is
-  // not a native type in Presto, so fuzzer should not use it as the type of
-  // cast-to or constant literals. Hyperloglog and TDigest can only be casted
-  // from varbinary and cannot be used as the type of constant literals.
-  // Interval year to month can only be casted from NULL and cannot be used as
-  // the type of constant literals. Json, Ipaddress, Ipprefix, and UUID require
-  // special handling, because Presto requires literals of these types to be
-  // valid, and doesn't allow creating HIVE columns of these types.
+  // TODO: support queries with these types.
+  // Types not supported by PrestoQueryRunner and their reasons:
+  //
+  // hugeint:
+  //   - Not a native type in Presto
+  //   - Fuzzer should not use it for cast-to or constant literals
+  //
+  // interval year to month:
+  //   - Can only be casted from NULL
+  //   - Cannot be used as constant literal types
+  //
+  // ipaddress, ipprefix, uuid:
+  //   - Require special handling in Presto
+  //   - Presto requires literals of these types to be valid
+  //   - Cannot create HIVE columns of these types
+  //
+  // geometry:
+  //   - Under development in Presto
+  //   - Cannot be used as constant literals
+  //   - Expected differences between Presto Java and Velox C++ implementations
+  //
+  // p4hyperloglog:
+  //   - Not a native type in Presto
+  //   - Cannot create HIVE columns of these types
   return !(
-      usesTypeName(signature, "bingtile") ||
       usesTypeName(signature, "interval year to month") ||
       usesTypeName(signature, "hugeint") ||
-      usesTypeName(signature, "hyperloglog") ||
-      usesTypeName(signature, "tdigest") ||
-      usesInputTypeName(signature, "json") ||
+      usesTypeName(signature, "geometry") || usesTypeName(signature, "time") ||
+      usesTypeName(signature, "p4hyperloglog") ||
       usesInputTypeName(signature, "ipaddress") ||
       usesInputTypeName(signature, "ipprefix") ||
       usesInputTypeName(signature, "uuid"));
@@ -355,17 +395,19 @@ std::string PrestoQueryRunner::createTable(
 
   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()));
+  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();
+
+  // TODO: Remove explicit std::string_view cast.
+  auto tableDirectoryPath = fs::path(std::string_view(filePath)).parent_path();
 
   // Delete the all-null row.
   execute(fmt::format("DELETE FROM {}", name));
@@ -373,6 +415,10 @@ std::string PrestoQueryRunner::createTable(
   return tableDirectoryPath;
 }
 
+void PrestoQueryRunner::cleanUp(const std::string& name) {
+  execute(fmt::format("DROP TABLE IF EXISTS {}", name));
+}
+
 std::pair<
     std::optional<std::vector<velox::RowVectorPtr>>,
     ReferenceQueryErrorCode>
@@ -402,8 +448,13 @@ PrestoQueryRunner::executeAndReturnVector(const core::PlanNodePtr& plan) {
         writeToFile(filePath, input, writerPool.get());
       }
 
-      // Run the query.
-      return std::make_pair(execute(*sql), ReferenceQueryErrorCode::kSuccess);
+      // Run the query. If successful, delete the table.
+      auto result = execute(*sql);
+      for (const auto& [tableName, _] : inputMap) {
+        cleanUp(tableName);
+      }
+
+      return std::make_pair(result, ReferenceQueryErrorCode::kSuccess);
     } catch (const VeloxRuntimeError& e) {
       // Throw if connection to Presto server is unsuccessful.
       if (e.message().find("Couldn't connect to server") != std::string::npos) {
@@ -455,38 +506,78 @@ std::vector<RowVectorPtr> PrestoQueryRunner::execute(
 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);
+  CURL* curl = curl_easy_init();
+  VELOX_CHECK_NOT_NULL(curl, "Failed to initialize libcurl");
+
+  // Prepare curl headers
+  struct curl_slist* headers = nullptr;
+  headers = curl_slist_append(
+      headers, fmt::format("X-Presto-User: {}", user_).c_str());
+  headers = curl_slist_append(headers, "X-Presto-Catalog: hive");
+  headers = curl_slist_append(headers, "X-Presto-Schema: tpch");
+  headers = curl_slist_append(headers, "Content-Type: text/plain");
+  headers = curl_slist_append(
+      headers, fmt::format("X-Presto-Session: {}", sessionProperty).c_str());
+
+  std::string url =
+      fmt::format("{}/v1/statement?binaryResults=true", coordinatorUri_);
+  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+  curl_easy_setopt(curl, CURLOPT_POST, 1L);
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, sql.c_str());
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, sql.size());
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeout_);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunction);
+  curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
+
+  std::string response;
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+
+  // Perform the request
+  CURLcode res = curl_easy_perform(curl);
   VELOX_CHECK_EQ(
-      response.status_code,
-      200,
+      CURLE_OK,
+      res,
       "POST to {} failed: {}",
-      uri,
-      response.error.message);
-  return response.text;
+      coordinatorUri_,
+      curl_easy_strerror(res));
+
+  // Cleanup
+  curl_slist_free_all(headers);
+  curl_easy_cleanup(curl);
+
+  return response;
 }
 
 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);
+  CURL* curl = curl_easy_init();
+  VELOX_CHECK_NOT_NULL(curl, "Failed to initialize libcurl");
+
+  // Set up the request URL
+  curl_easy_setopt(curl, CURLOPT_URL, nextUri.c_str());
+
+  // Set up headers
+  struct curl_slist* headers = nullptr;
+  headers = curl_slist_append(headers, "X-Presto-Client-Binary-Results: true");
+  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+  curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeout_);
+  curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1_2);
+
+  // Capture the response body
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunction);
+  std::string response;
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
+
+  // Perform GET request
+  CURLcode res = curl_easy_perform(curl);
   VELOX_CHECK_EQ(
-      response.status_code,
-      200,
-      "GET from {} failed: {}",
-      nextUri,
-      response.error.message);
-  return response.text;
+      CURLE_OK, res, "Get request failed: {}", curl_easy_strerror(res));
+
+  // Cleanup
+  curl_slist_free_all(headers);
+  curl_easy_cleanup(curl);
+
+  return response;
 }
 
 bool PrestoQueryRunner::supportsVeloxVectorResults() const {
@@ -494,3 +585,10 @@ bool PrestoQueryRunner::supportsVeloxVectorResults() const {
 }
 
 } // namespace facebook::velox::exec::test
+
+template <>
+struct fmt::formatter<CURLcode> : formatter<int> {
+  auto format(CURLcode s, format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/exec/fuzzer/PrestoQueryRunner.h b/velox/exec/fuzzer/PrestoQueryRunner.h
index 697bf748013c..64ecbcc86b39 100644
--- a/velox/exec/fuzzer/PrestoQueryRunner.h
+++ b/velox/exec/fuzzer/PrestoQueryRunner.h
@@ -121,6 +121,7 @@ class PrestoQueryRunner : public velox::exec::test::ReferenceQueryRunner {
   // 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);
+  void cleanUp(const std::string& name);
 
   const std::string coordinatorUri_;
   const std::string user_;
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.cpp b/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.cpp
index 45658502b413..97a1015b1b16 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.cpp
+++ b/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.cpp
@@ -15,59 +15,77 @@
  */
 
 #include "velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/fuzzer/PrestoQueryRunnerIntervalTransform.h"
+#include "velox/exec/fuzzer/PrestoQueryRunnerJsonTransform.h"
 #include "velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.h"
-#include "velox/expression/VectorWriters.h"
+#include "velox/expression/Expr.h"
+#include "velox/functions/prestosql/types/BingTileType.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
+#include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/parse/Expressions.h"
-#include "velox/vector/ComplexVector.h"
-#include "velox/vector/DecodedVector.h"
-#include "velox/vector/fuzzer/Utils.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
 
 namespace facebook::velox::exec::test {
 namespace {
-class ArrayTransform {
- public:
-  VectorPtr transform(const VectorPtr& vector, const SelectivityVector& rows)
-      const;
-
-  core::ExprPtr projectionExpr(
-      const TypePtr& type,
-      const core::ExprPtr& inputExpr,
-      const std::string& columnAlias) const;
-};
-
-class MapTransform {
- public:
-  VectorPtr transform(const VectorPtr& vector, const SelectivityVector& rows)
-      const;
-
-  core::ExprPtr projectionExpr(
-      const TypePtr& type,
-      const core::ExprPtr& inputExpr,
-      const std::string& columnAlias) const;
-};
-
-class RowTransform {
- public:
-  VectorPtr transform(const VectorPtr& vector, const SelectivityVector& rows)
-      const;
-
-  core::ExprPtr projectionExpr(
-      const TypePtr& type,
-      const core::ExprPtr& inputExpr,
-      const std::string& columnAlias) const;
-};
-
-const ArrayTransform kArrayTransform;
-const MapTransform kMapTransform;
-const RowTransform kRowTransform;
 
 const std::unordered_map<TypePtr, std::shared_ptr<IntermediateTypeTransform>>&
 intermediateTypeTransforms() {
   static std::unordered_map<TypePtr, std::shared_ptr<IntermediateTypeTransform>>
       intermediateTypeTransforms{
+          // Note: INTERVAL DAY TO SECOND is included in the below because its
+          // transform is defined and properly tested; however, due to Presto
+          // Java imprecision in functions parse_duration and to_milliseconds,
+          // it will be temporarily excluded from fuzzer runs until Presto Java
+          // fixes said imprecision or when we compare with Prestissimo
+          // directly. Please track below:
+          // https://github.com/prestodb/presto/issues/25275
+          // https://github.com/prestodb/presto/issues/25340
           {TIMESTAMP_WITH_TIME_ZONE(),
-           std::make_shared<TimestampWithTimeZoneTransform>()}};
+           std::make_shared<TimestampWithTimeZoneTransform>()},
+          {HYPERLOGLOG(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               HYPERLOGLOG(), VARBINARY())},
+          {KHYPERLOGLOG(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               KHYPERLOGLOG(), VARBINARY())},
+          {TDIGEST(DOUBLE()),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               TDIGEST(DOUBLE()), VARBINARY())},
+          {QDIGEST(DOUBLE()),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               QDIGEST(DOUBLE()), VARBINARY())},
+          {QDIGEST(BIGINT()),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               QDIGEST(BIGINT()), VARBINARY())},
+          {QDIGEST(REAL()),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               QDIGEST(REAL()), VARBINARY())},
+          {SETDIGEST(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               SETDIGEST(), VARBINARY())},
+          {SFMSKETCH(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               SFMSKETCH(), VARBINARY())},
+          {JSON(), std::make_shared<JsonTransform>()},
+          {TIME(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               TIME(), VARCHAR())},
+          {TIME_WITH_TIME_ZONE(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               TIME_WITH_TIME_ZONE(), VARCHAR())},
+          {BINGTILE(),
+           std::make_shared<IntermediateTypeTransformUsingCast>(
+               BINGTILE(), BIGINT())},
+          {INTERVAL_DAY_TIME(), std::make_shared<IntervalDayTimeTransform>()},
+      };
   return intermediateTypeTransforms;
 }
 
@@ -84,129 +102,43 @@ const std::shared_ptr<IntermediateTypeTransform>& getIntermediateTypeTransform(
   return it->second;
 }
 
-VectorPtr transformIntermediateOnlyType(
-    const VectorPtr& vector,
+VectorPtr evaluateExpression(
+    core::ExprPtr& expression,
+    const VectorPtr& input,
     const SelectivityVector& rows) {
-  const auto& type = vector->type();
-  if (type->isArray()) {
-    return kArrayTransform.transform(vector, rows);
-  } else if (type->isMap()) {
-    return kMapTransform.transform(vector, rows);
-  } else if (type->isRow()) {
-    return kRowTransform.transform(vector, rows);
-  } else {
-    const auto& transform = getIntermediateTypeTransform(type);
-    DecodedVector decoded(*vector);
-    const auto* base = decoded.base();
-
-    VectorPtr result;
-    const auto& transformedType = transform->transformedType();
-    BaseVector::ensureWritable(
-        SelectivityVector(base->size()), transformedType, base->pool(), result);
-    VectorWriter<Any> writer;
-    writer.init(*result);
-
-    if (base->isConstantEncoding()) {
-      if (rows.countSelected() > 0) {
-        if (base->isNullAt(0)) {
-          result = BaseVector::createNullConstant(
-              transformedType, base->size(), base->pool());
-        } else {
-          const auto value = transform->transform(base, 0);
-
-          if (value.isNull()) {
-            result = BaseVector::createNullConstant(
-                transformedType, base->size(), base->pool());
-          } else {
-            writer.setOffset(0);
-            VELOX_DYNAMIC_TYPE_DISPATCH(
-                fuzzer::writeOne,
-                transformedType->kind(),
-                value,
-                writer.current());
-            writer.commit(true);
-            result = BaseVector::wrapInConstant(base->size(), 0, result);
-          }
-        }
-      }
-    } else {
-      rows.applyToSelected([&](vector_size_t row) {
-        auto index = decoded.index(row);
-        writer.setOffset(index);
-
-        if (base->isNullAt(index)) {
-          writer.commitNull();
-        } else {
-          const auto value = transform->transform(base, index);
-
-          if (value.isNull()) {
-            writer.commitNull();
-          } else {
-            VELOX_DYNAMIC_TYPE_DISPATCH(
-                fuzzer::writeOne,
-                transformedType->kind(),
-                value,
-                writer.current());
-            writer.commit(true);
-          }
-        }
-      });
-    }
-
-    if (!decoded.isIdentityMapping()) {
-      result = decoded.wrap(result, *vector, vector->size());
-    }
-
-    return result;
-  }
+  std::shared_ptr<core::QueryCtx> queryCtx_{velox::core::QueryCtx::create()};
+  std::unique_ptr<core::ExecCtx> execCtx{
+      std::make_unique<core::ExecCtx>(input->pool(), queryCtx_.get())};
+  velox::test::VectorMaker vectorMaker(input->pool());
+  auto rowVector = vectorMaker.rowVector({input});
+  core::TypedExprPtr typedExpr = core::Expressions::inferTypes(
+      expression, rowVector->type(), input->pool());
+  exec::ExprSet exprSet(
+      std::vector<core::TypedExprPtr>{typedExpr}, execCtx.get());
+  exec::EvalCtx evalCtx(execCtx.get(), &exprSet, rowVector.get());
+  std::vector<VectorPtr> result;
+  exprSet.eval(rows, evalCtx, result);
+  VELOX_CHECK_EQ(result.size(), 1);
+  VELOX_CHECK_NOT_NULL(result[0]);
+  return result[0];
 }
 
-// Converts an ArrayVector so that any intermediate only types in the elements
-// are transformed.
-VectorPtr ArrayTransform::transform(
-    const VectorPtr& vector,
-    const SelectivityVector& rows) const {
-  VELOX_CHECK(vector->type()->isArray());
-  DecodedVector decoded(*vector);
-  const auto* base = decoded.base()->as<ArrayVector>();
-
-  SelectivityVector elementRows(base->elements()->size(), false);
-  rows.applyToSelected([&](vector_size_t row) {
-    if (!decoded.isNullAt(row)) {
-      auto index = decoded.index(row);
-      elementRows.setValidRange(
-          base->offsetAt(index),
-          base->offsetAt(index) + base->sizeAt(index),
-          true);
-    }
-  });
-  elementRows.updateBounds();
-
-  VectorPtr elementsVector =
-      transformIntermediateOnlyType(base->elements(), elementRows);
-
-  VectorPtr array = std::make_shared<ArrayVector>(
-      base->pool(),
-      ARRAY(elementsVector->type()),
-      base->nulls(),
-      base->size(),
-      base->offsets(),
-      base->sizes(),
-      elementsVector);
-
-  if (!decoded.isIdentityMapping()) {
-    array = decoded.wrap(array, *vector, vector->size());
-  }
+enum class TransformDirection { TO_INTERMEDIATE, TO_TARGET };
 
-  return array;
-}
+core::ExprPtr getProjection(
+    const TypePtr& type,
+    const core::ExprPtr& inputExpr,
+    const std::string& columnAlias,
+    const TransformDirection transformDirection);
 
 // Applies a lambda transform to the elements of an array to convert input
-// types to intermediate only types where necessary.
-core::ExprPtr ArrayTransform::projectionExpr(
+// types <=> intermediate types (where necessary) depending on
+// 'transformDirection'.
+core::ExprPtr getProjectionForArray(
     const TypePtr& type,
     const core::ExprPtr& inputExpr,
-    const std::string& columnAlias) const {
+    const std::string& columnAlias,
+    const TransformDirection transformDirection) {
   VELOX_CHECK(type->isArray());
 
   return std::make_shared<core::CallExpr>(
@@ -215,70 +147,22 @@ core::ExprPtr ArrayTransform::projectionExpr(
           inputExpr,
           std::make_shared<core::LambdaExpr>(
               std::vector<std::string>{"x"},
-              getIntermediateOnlyTypeProjectionExpr(
+              getProjection(
                   type->asArray().elementType(),
                   std::make_shared<core::FieldAccessExpr>("x", "x"),
-                  "x"))},
+                  "x",
+                  transformDirection))},
       columnAlias);
 }
 
-// Converts an MapVector so that any intermediate only types in the keys and
-// values are transformed.
-VectorPtr MapTransform::transform(
-    const VectorPtr& vector,
-    const SelectivityVector& rows) const {
-  VELOX_CHECK(vector->type()->isMap());
-  DecodedVector decoded(*vector);
-  const auto* base = decoded.base()->as<MapVector>();
-
-  VectorPtr keysVector = base->mapKeys();
-  VectorPtr valuesVector = base->mapValues();
-  const auto& keysType = keysVector->type();
-  const auto& valuesType = valuesVector->type();
-
-  SelectivityVector elementRows(keysVector->size(), false);
-  rows.applyToSelected([&](vector_size_t row) {
-    if (!decoded.isNullAt(row)) {
-      auto index = decoded.index(row);
-      elementRows.setValidRange(
-          base->offsetAt(index),
-          base->offsetAt(index) + base->sizeAt(index),
-          true);
-    }
-  });
-  elementRows.updateBounds();
-
-  if (isIntermediateOnlyType(keysType)) {
-    keysVector = transformIntermediateOnlyType(keysVector, elementRows);
-  }
-
-  if (isIntermediateOnlyType(valuesType)) {
-    valuesVector = transformIntermediateOnlyType(valuesVector, elementRows);
-  }
-
-  VectorPtr map = std::make_shared<MapVector>(
-      base->pool(),
-      MAP(keysVector->type(), valuesVector->type()),
-      base->nulls(),
-      base->size(),
-      base->offsets(),
-      base->sizes(),
-      keysVector,
-      valuesVector);
-
-  if (!decoded.isIdentityMapping()) {
-    map = decoded.wrap(map, *vector, vector->size());
-  }
-
-  return map;
-}
-
 // Applies a lambda transform to the keys and values of a map to convert input
-// types to intermediate only types where necessary.
-core::ExprPtr MapTransform::projectionExpr(
+// types <=> intermediate types (where necessary) depending on
+// 'transformDirection'.
+core::ExprPtr getProjectionForMap(
     const TypePtr& type,
     const core::ExprPtr& inputExpr,
-    const std::string& columnAlias) const {
+    const std::string& columnAlias,
+    const TransformDirection transformDirection) {
   VELOX_CHECK(type->isMap());
   const auto& mapType = type->asMap();
   const auto& keysType = mapType.keyType();
@@ -293,10 +177,11 @@ core::ExprPtr MapTransform::projectionExpr(
             expr,
             std::make_shared<core::LambdaExpr>(
                 std::vector<std::string>{"k", "v"},
-                getIntermediateOnlyTypeProjectionExpr(
+                getProjection(
                     keysType,
                     std::make_shared<core::FieldAccessExpr>("k", "k"),
-                    "k"))},
+                    "k",
+                    transformDirection))},
         columnAlias);
   }
 
@@ -307,103 +192,132 @@ core::ExprPtr MapTransform::projectionExpr(
             expr,
             std::make_shared<core::LambdaExpr>(
                 std::vector<std::string>{"k", "v"},
-                getIntermediateOnlyTypeProjectionExpr(
+                getProjection(
                     valuesType,
                     std::make_shared<core::FieldAccessExpr>("v", "v"),
-                    "v"))},
+                    "v",
+                    transformDirection))},
         columnAlias);
   }
 
   return expr;
 }
 
-// Converts an RowVector so that any intermediate only types in the children
-// are transformed.
-VectorPtr RowTransform::transform(
-    const VectorPtr& vector,
-    const SelectivityVector& rows) const {
-  VELOX_CHECK(vector->type()->isRow());
-  DecodedVector decoded(*vector);
-  const auto* base = decoded.base()->as<RowVector>();
-
-  SelectivityVector childRows(base->size(), false);
-  rows.applyToSelected([&](vector_size_t row) {
-    if (!decoded.isNullAt(row)) {
-      childRows.setValid(decoded.index(row), true);
-    }
-  });
-  childRows.updateBounds();
-
-  std::vector<VectorPtr> children;
-  std::vector<TypePtr> childrenTypes;
-  std::vector<std::string> childrenNames = base->type()->asRow().names();
-  for (const auto& child : base->children()) {
-    if (isIntermediateOnlyType(child->type())) {
-      children.push_back(transformIntermediateOnlyType(child, childRows));
-      childrenTypes.push_back(children.back()->type());
-    } else {
-      children.push_back(child);
-      childrenTypes.push_back(child->type());
+TypePtr replaceIntermediateWithTargetType(TypePtr type) {
+  if (type->isArray()) {
+    const auto& arrayType = type->asArray();
+    return ARRAY(replaceIntermediateWithTargetType(arrayType.elementType()));
+  } else if (type->isMap()) {
+    const auto& mapType = type->asMap();
+    return MAP(
+        replaceIntermediateWithTargetType(mapType.keyType()),
+        replaceIntermediateWithTargetType(mapType.valueType()));
+  } else if (type->isRow()) {
+    const auto& rowType = type->asRow();
+    std::vector<std::string> names;
+    std::vector<TypePtr> children;
+    for (int i = 0; i < rowType.size(); i++) {
+      names.push_back(rowType.nameOf(i));
+      children.push_back(replaceIntermediateWithTargetType(rowType.childAt(i)));
     }
+    return ROW(std::move(names), std::move(children));
   }
-
-  VectorPtr row = std::make_shared<RowVector>(
-      base->pool(),
-      ROW(std::move(childrenNames), std::move(childrenTypes)),
-      base->nulls(),
-      base->size(),
-      std::move(children));
-
-  if (!decoded.isIdentityMapping()) {
-    row = decoded.wrap(row, *vector, vector->size());
+  if (isIntermediateOnlyType(type)) {
+    const auto& transform = getIntermediateTypeTransform(type);
+    return transform->targetType();
   }
-
-  return row;
+  return type;
 }
 
-// Applies transforms to the children of a row to convert input types to
-// intermediate only types where necessary, and reconstructs the row via
-// row_constructor.
-core::ExprPtr RowTransform::projectionExpr(
+// Applies transforms to the children of a row to convert input
+// types <=> intermediate types (where necessary) depending on
+// 'transformDirection', and reconstructs the row via row_constructor.
+core::ExprPtr getProjectionForRow(
     const TypePtr& type,
     const core::ExprPtr& inputExpr,
-    const std::string& columnAlias) const {
+    const std::string& columnAlias,
+    const TransformDirection transformDirection) {
   VELOX_CHECK(type->isRow());
   const auto& rowType = type->asRow();
 
   std::vector<core::ExprPtr> children;
   for (int i = 0; i < rowType.size(); i++) {
     if (isIntermediateOnlyType(rowType.childAt(i))) {
-      children.push_back(getIntermediateOnlyTypeProjectionExpr(
+      children.push_back(getProjection(
           rowType.childAt(i),
           std::make_shared<core::FieldAccessExpr>(
               rowType.nameOf(i),
               rowType.nameOf(i),
               std::vector<core::ExprPtr>{inputExpr}),
-          rowType.nameOf(i)));
-    } else {
-      children.push_back(std::make_shared<core::FieldAccessExpr>(
-          rowType.nameOf(i),
           rowType.nameOf(i),
-          std::vector<core::ExprPtr>{inputExpr}));
+          transformDirection));
+    } else {
+      children.push_back(
+          std::make_shared<core::FieldAccessExpr>(
+              rowType.nameOf(i),
+              rowType.nameOf(i),
+              std::vector<core::ExprPtr>{inputExpr}));
     }
   }
 
+  TypePtr outputRowType;
+  if (transformDirection == TransformDirection::TO_TARGET) {
+    outputRowType = replaceIntermediateWithTargetType(type);
+  } else {
+    outputRowType = type;
+  }
+
   return std::make_shared<core::CallExpr>(
       "switch",
       std::vector<core::ExprPtr>{
           std::make_shared<core::CallExpr>(
               "is_null", std::vector<core::ExprPtr>{inputExpr}, std::nullopt),
           std::make_shared<core::ConstantExpr>(
-              type, variant::null(TypeKind::ROW), std::nullopt),
+              outputRowType, variant::null(TypeKind::ROW), std::nullopt),
           std::make_shared<core::CastExpr>(
-              type,
+              outputRowType,
               std::make_shared<core::CallExpr>(
                   "row_constructor", std::move(children), std::nullopt),
               false,
               std::nullopt)},
       columnAlias);
 }
+
+core::ExprPtr getProjection(
+    const TypePtr& originaltype,
+    const core::ExprPtr& inputExpr,
+    const std::string& columnAlias,
+    const TransformDirection transformDirection) {
+  if (originaltype->isArray()) {
+    return getProjectionForArray(
+        originaltype, inputExpr, columnAlias, transformDirection);
+  } else if (originaltype->isMap()) {
+    return getProjectionForMap(
+        originaltype, inputExpr, columnAlias, transformDirection);
+  } else if (originaltype->isRow()) {
+    return getProjectionForRow(
+        originaltype, inputExpr, columnAlias, transformDirection);
+  }
+  const auto& transform = getIntermediateTypeTransform(originaltype);
+  if (transformDirection == TransformDirection::TO_TARGET) {
+    return transform->projectToTargetType(inputExpr, columnAlias);
+  }
+  return transform->projectToIntermediateType(inputExpr, columnAlias);
+}
+
+VectorPtr transformIntermediateTypes(
+    const VectorPtr& vector,
+    const SelectivityVector& rows) {
+  const auto& type = vector->type();
+  auto expression = getProjection(
+      type,
+      std::make_shared<core::FieldAccessExpr>("c0", "c0"),
+      "c0",
+      TransformDirection::TO_TARGET);
+
+  return evaluateExpression(expression, vector, rows);
+}
+
 } // namespace
 
 bool isIntermediateOnlyType(const TypePtr& type) {
@@ -421,24 +335,30 @@ bool isIntermediateOnlyType(const TypePtr& type) {
   return false;
 }
 
-VectorPtr transformIntermediateOnlyType(const VectorPtr& vector) {
-  return transformIntermediateOnlyType(
+VectorPtr transformIntermediateTypes(const VectorPtr& vector) {
+  return transformIntermediateTypes(
       vector, SelectivityVector(vector->size(), true));
 }
 
-core::ExprPtr getIntermediateOnlyTypeProjectionExpr(
+core::ExprPtr getProjectionsToIntermediateTypes(
     const TypePtr& type,
     const core::ExprPtr& inputExpr,
     const std::string& columnAlias) {
-  if (type->isArray()) {
-    return kArrayTransform.projectionExpr(type, inputExpr, columnAlias);
-  } else if (type->isMap()) {
-    return kMapTransform.projectionExpr(type, inputExpr, columnAlias);
-  } else if (type->isRow()) {
-    return kRowTransform.projectionExpr(type, inputExpr, columnAlias);
-  } else {
-    return getIntermediateTypeTransform(type)->projectionExpr(
-        inputExpr, columnAlias);
-  }
+  return getProjection(
+      type, inputExpr, columnAlias, TransformDirection::TO_INTERMEDIATE);
+}
+
+core::ExprPtr IntermediateTypeTransformUsingCast::projectToTargetType(
+    const core::ExprPtr& inputExpr,
+    const std::string& columnAlias) const {
+  return std::make_shared<core::CastExpr>(
+      targetType_, inputExpr, false, columnAlias);
+}
+
+core::ExprPtr IntermediateTypeTransformUsingCast::projectToIntermediateType(
+    const core::ExprPtr& inputExpr,
+    const std::string& columnAlias) const {
+  return std::make_shared<core::CastExpr>(
+      intermediateType_, inputExpr, false, columnAlias);
 }
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h b/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h
index ca807b69260d..c29e16e9474c 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h
+++ b/velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h
@@ -20,50 +20,90 @@
 #include "velox/vector/BaseVector.h"
 
 namespace facebook::velox::exec::test {
-/// Defines a transform for an intermediate type.
+/// Defines a transform for a intermediate type (that does not exist in file
+/// formats like json) to a target type.
 class IntermediateTypeTransform {
  public:
+  IntermediateTypeTransform(TypePtr intermediateType, TypePtr targetType)
+      : intermediateType_(std::move(intermediateType)),
+        targetType_(std::move(targetType)) {}
   virtual ~IntermediateTypeTransform() = default;
 
   /// The type of the value returned by transform().
-  virtual TypePtr transformedType() const = 0;
+  TypePtr targetType() const {
+    return targetType_;
+  };
 
-  /// Converts the value in vector at position row into a value that can be
-  /// converted back to the original type by the result of projectExpr. Will
-  /// only be called with a ConstantVector or a flat-like Vector (depending on
-  /// the intermediate type's parent type) where the value is non-null.
-  virtual variant transform(const BaseVector* const vector, vector_size_t row)
-      const = 0;
+  TypePtr intermediateType() const {
+    return intermediateType_;
+  };
+
+  /// An expression tree that can convert the type of value returned by
+  /// 'inputExpr' into its target type. It is assumed this has default-null
+  /// behavior, i.e. a null input produces a null output.
+  virtual core::ExprPtr projectToTargetType(
+      const core::ExprPtr& inputExpr,
+      const std::string& columnAlias) const = 0;
 
   /// An expression tree that can convert the value returned by transform() back
   /// into its original value. It is assumed this has default-null behavior,
   /// i.e. a null input produces a null output.
-  virtual core::ExprPtr projectionExpr(
+  virtual core::ExprPtr projectToIntermediateType(
       const core::ExprPtr& inputExpr,
       const std::string& columnAlias) const = 0;
+
+ protected:
+  TypePtr intermediateType_;
+  TypePtr targetType_;
+};
+
+/// This class offers a default implementation for the
+/// IntermediateTypeTransform, enabling conversion to and from target types
+/// using the CAST operator. It is designed to support intermediate types that
+/// can utilize the CAST operator for correct conversion semantics. To add
+/// support for such intermediate types, simply create an instance of this class
+/// with the appropriate parameters.
+class IntermediateTypeTransformUsingCast : public IntermediateTypeTransform {
+ public:
+  IntermediateTypeTransformUsingCast(
+      TypePtr intermediateType,
+      TypePtr targetType)
+      : IntermediateTypeTransform(
+            std::move(intermediateType),
+            std::move(targetType)) {}
+
+  core::ExprPtr projectToTargetType(
+      const core::ExprPtr& inputExpr,
+      const std::string& columnAlias) const override;
+
+  core::ExprPtr projectToIntermediateType(
+      const core::ExprPtr& inputExpr,
+      const std::string& columnAlias) const override;
 };
 
 /// Returns true if this types is an intermediate only type or contains an
 /// intermediate only type.
 bool isIntermediateOnlyType(const TypePtr& type);
 
-/// Converts a Vector of an intermediate only type, or containing one, to a
-/// Vector of value(s) that can be input to a projection to produce those values
-/// of that type but are of types supported as input. Preserves nulls and
-/// encodings.
-VectorPtr transformIntermediateOnlyType(const VectorPtr& vector);
+/// Converts all the intermediate types in an input 'vector' to their respective
+/// target types. For eg. ROW(<INTERMEDIATE>, MAP(<INTERMEDIATE>, BIGINT)) =>
+/// ROW(<TARGET>, MAP(<TARGET>, BIGINT))
+VectorPtr transformIntermediateTypes(const VectorPtr& vector);
 
-/// Converts an expression that takes in a value of an intermediate only type so
-/// that it applies a transformation to convert valid input types into values
-/// of the intermediate only type.
-/// @param type The expected output type of the expression, either an
+/// Generates an expression that takes the output of 'inputExpr' and converts it
+/// into 'ouputType'. The 'ouputType' is expected to be have same type hierarchy
+/// as the types returned from 'inputExpr' with some of the leaf type replaced
+/// with intermediate types. For eg. ouputType can be ROW(<INTERMEDIATE>,
+/// MAP(<INTERMEDIATE>, BIGINT)) and type returned by 'inputExpr' can be
+/// ROW(<TARGET>, MAP(<TARGET>, BIGINT)).
+/// @param ouputType The expected output type of the expression, either an
 /// intermediate only type, or a complex type containing one.
 /// @param inputExpr The expression that will be the input to the returned
 /// expression, the output of this expression will be of a type not containing
 /// intermediate only types.
 /// @param columnAlias The alias to give the returned expression.
-core::ExprPtr getIntermediateOnlyTypeProjectionExpr(
-    const TypePtr& type,
+core::ExprPtr getProjectionsToIntermediateTypes(
+    const TypePtr& ouputType,
     const core::ExprPtr& inputExpr,
     const std::string& columnAlias);
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerIntervalTransform.cpp b/velox/exec/fuzzer/PrestoQueryRunnerIntervalTransform.cpp
new file mode 100644
index 000000000000..0c1e52341d41
--- /dev/null
+++ b/velox/exec/fuzzer/PrestoQueryRunnerIntervalTransform.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/exec/fuzzer/PrestoQueryRunnerIntervalTransform.h"
+#include "velox/parse/Expressions.h"
+
+namespace facebook::velox::exec::test {
+
+core::ExprPtr IntervalDayTimeTransform::projectToTargetType(
+    const core::ExprPtr& inputExpr,
+    const std::string& columnAlias) const {
+  return std::make_shared<core::CallExpr>(
+      "try",
+      std::vector<core::ExprPtr>{std::make_shared<core::CallExpr>(
+          "to_milliseconds",
+          std::vector<core::ExprPtr>{inputExpr},
+          std::nullopt)},
+      columnAlias);
+}
+
+// The below transform executes the following Presto SQL:
+// try(parse_duration(concat(CAST(inputExpr AS VARCHAR), 'ms')))
+//
+// This casts the inputted bigint as a string and concatenates it with 'ms'
+// to generate a valid millisecond duration as a string, which will be parsed
+// as a valid interval and easily re-converted using to_milliseconds.
+core::ExprPtr IntervalDayTimeTransform::projectToIntermediateType(
+    const core::ExprPtr& inputExpr,
+    const std::string& columnAlias) const {
+  return std::make_shared<core::CallExpr>(
+      "try",
+      std::vector<core::ExprPtr>{std::make_shared<core::CallExpr>(
+          "parse_duration",
+          std::vector<core::ExprPtr>{std::make_shared<core::CallExpr>(
+              "concat",
+              std::vector<core::ExprPtr>{
+                  std::make_shared<core::CastExpr>(
+                      VARCHAR(), inputExpr, false, columnAlias),
+                  std::make_shared<core::ConstantExpr>(
+                      VARCHAR(),
+                      variant::create<TypeKind::VARCHAR>("ms"),
+                      std::nullopt)},
+              std::nullopt)},
+          std::nullopt)},
+      columnAlias);
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerIntervalTransform.h b/velox/exec/fuzzer/PrestoQueryRunnerIntervalTransform.h
new file mode 100644
index 000000000000..097359e7d391
--- /dev/null
+++ b/velox/exec/fuzzer/PrestoQueryRunnerIntervalTransform.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/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+
+namespace facebook::velox::exec::test {
+
+// This transform converts negative interval values to NULL due to the
+// constraints in parse_duration. Although constants and inputs to
+// to_milliseconds allow for negatives, parse_duration does not, the try
+// will capture this error and NULL the output. The behavior is the same
+// in Presto Java and Prestissimo.
+class IntervalDayTimeTransform : public IntermediateTypeTransform {
+ public:
+  IntervalDayTimeTransform()
+      : IntermediateTypeTransform(INTERVAL_DAY_TIME(), BIGINT()) {}
+
+  core::ExprPtr projectToTargetType(
+      const core::ExprPtr& inputExpr,
+      const std::string& columnAlias) const override;
+
+  core::ExprPtr projectToIntermediateType(
+      const core::ExprPtr& inputExpr,
+      const std::string& columnAlias) const override;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerJsonTransform.cpp b/velox/exec/fuzzer/PrestoQueryRunnerJsonTransform.cpp
new file mode 100644
index 000000000000..8285cbbc7276
--- /dev/null
+++ b/velox/exec/fuzzer/PrestoQueryRunnerJsonTransform.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/exec/fuzzer/PrestoQueryRunnerJsonTransform.h"
+#include "velox/parse/Expressions.h"
+
+namespace facebook::velox::exec::test {
+
+core::ExprPtr JsonTransform::projectToTargetType(
+    const core::ExprPtr& inputExpr,
+    const std::string& columnAlias) const {
+  return std::make_shared<core::CallExpr>(
+      "try",
+      std::vector<core::ExprPtr>{std::make_shared<core::CallExpr>(
+          "json_format", std::vector<core::ExprPtr>{inputExpr}, std::nullopt)},
+      columnAlias);
+}
+
+core::ExprPtr JsonTransform::projectToIntermediateType(
+    const core::ExprPtr& inputExpr,
+    const std::string& columnAlias) const {
+  return std::make_shared<core::CallExpr>(
+      "try",
+      std::vector<core::ExprPtr>{std::make_shared<core::CallExpr>(
+          "json_parse", std::vector<core::ExprPtr>{inputExpr}, std::nullopt)},
+      columnAlias);
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerJsonTransform.h b/velox/exec/fuzzer/PrestoQueryRunnerJsonTransform.h
new file mode 100644
index 000000000000..88bc67dd56bc
--- /dev/null
+++ b/velox/exec/fuzzer/PrestoQueryRunnerJsonTransform.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/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+
+namespace facebook::velox::exec::test {
+class JsonTransform : public IntermediateTypeTransform {
+ public:
+  JsonTransform() : IntermediateTypeTransform(JSON(), VARCHAR()) {}
+
+  core::ExprPtr projectToTargetType(
+      const core::ExprPtr& inputExpr,
+      const std::string& columnAlias) const override;
+
+  core::ExprPtr projectToIntermediateType(
+      const core::ExprPtr& inputExpr,
+      const std::string& columnAlias) const override;
+};
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.cpp b/velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.cpp
index ef1e6d0d1888..fcad8e0e4314 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.cpp
+++ b/velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.cpp
@@ -15,51 +15,17 @@
  */
 
 #include "velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.h"
-#include "velox/functions/lib/DateTimeFormatter.h"
-#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/parse/Expressions.h"
-#include "velox/type/tz/TimeZoneMap.h"
-#include "velox/vector/SimpleVector.h"
 
 namespace facebook::velox::exec::test {
 namespace {
 const std::string kFormat = "yyyy-MM-dd HH:mm:ss.SSS ZZZ";
 const std::string kBackupFormat = "yyyy-MM-dd HH:mm:ss.SSS ZZ";
-
-std::string format(const int64_t timestampWithTimeZone) {
-  static const std::shared_ptr<functions::DateTimeFormatter> kJodaDateTime =
-      functions::buildJodaDateTimeFormatter(kFormat).value();
-
-  const auto timestamp = unpackTimestampUtc(timestampWithTimeZone);
-  const auto timeZoneId = unpackZoneKeyId(timestampWithTimeZone);
-  auto* timezonePtr = tz::locateZone(tz::getTimeZoneName(timeZoneId));
-
-  const auto maxResultSize = kJodaDateTime->maxResultSize(timezonePtr);
-  std::string str;
-  str.resize(maxResultSize);
-  const auto resultSize =
-      kJodaDateTime->format(timestamp, timezonePtr, maxResultSize, str.data());
-  str.resize(resultSize);
-
-  return str;
-}
 } // namespace
 
-// Convert a TimestampWithTimeZone into a Varchar using DatetimeFormatter, so
-// that we can get the TimestampWithTimeZone back by calling parse_datetime.
-variant TimestampWithTimeZoneTransform::transform(
-    const BaseVector* const vector,
-    vector_size_t row) const {
-  VELOX_CHECK(isTimestampWithTimeZoneType(vector->type()));
-  VELOX_CHECK(!vector->isNullAt(row));
-
-  return variant::create<TypeKind::VARCHAR>(
-      format(vector->asChecked<SimpleVector<int64_t>>()->valueAt(row)));
-}
-
 // Applies parse_datetime to a Vector of VARCHAR (formatted timestamps with time
 // zone) to produce values of type TimestampWithTimeZone.
-core::ExprPtr TimestampWithTimeZoneTransform::projectionExpr(
+core::ExprPtr TimestampWithTimeZoneTransform::projectToIntermediateType(
     const core::ExprPtr& inputExpr,
     const std::string& columnAlias) const {
   // format_datetime with the ZZZ pattern produces time zones that need to be
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.h b/velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.h
index 874d5eba5802..228d4ab53a07 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.h
+++ b/velox/exec/fuzzer/PrestoQueryRunnerTimestampWithTimeZoneTransform.h
@@ -17,18 +17,18 @@
 #pragma once
 
 #include "velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
 namespace facebook::velox::exec::test {
-class TimestampWithTimeZoneTransform : public IntermediateTypeTransform {
+class TimestampWithTimeZoneTransform
+    : public IntermediateTypeTransformUsingCast {
  public:
-  TypePtr transformedType() const override {
-    return VARCHAR();
-  }
+  TimestampWithTimeZoneTransform()
+      : IntermediateTypeTransformUsingCast(
+            TIMESTAMP_WITH_TIME_ZONE(),
+            VARCHAR()) {}
 
-  variant transform(const BaseVector* const vector, vector_size_t row)
-      const override;
-
-  core::ExprPtr projectionExpr(
+  core::ExprPtr projectToIntermediateType(
       const core::ExprPtr& inputExpr,
       const std::string& columnAlias) const override;
 };
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.cpp b/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.cpp
index 0d74dbbd351d..61676760099e 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.cpp
+++ b/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.cpp
@@ -203,7 +203,7 @@ void PrestoQueryRunnerToSqlPlanNodeVisitor::visit(
       static_cast<PrestoSqlPlanNodeVisitorContext&>(ctx);
 
   auto insertTableHandle =
-      std::dynamic_pointer_cast<connector::hive::HiveInsertTableHandle>(
+      std::dynamic_pointer_cast<const connector::hive::HiveInsertTableHandle>(
           node.insertTableHandle()->connectorInsertTableHandle());
 
   // Returns a CTAS sql with specified table properties from TableWriteNode,
@@ -291,7 +291,8 @@ void PrestoQueryRunnerToSqlPlanNodeVisitor::visit(
     sql << inputType->nameOf(i);
   }
 
-  sql << ", row_number() OVER (";
+  sql << ", " << core::TopNRowNumberNode::rankFunctionName(node.rankFunction())
+      << "() OVER (";
 
   const auto& partitionKeys = node.partitionKeys();
   if (!partitionKeys.empty()) {
@@ -344,7 +345,7 @@ void PrestoQueryRunnerToSqlPlanNodeVisitor::visit(
   std::stringstream sql;
   sql << "SELECT ";
 
-  const auto& inputType = node.sources()[0]->outputType();
+  const auto& inputType = node.inputType();
   for (auto i = 0; i < inputType->size(); ++i) {
     appendComma(i, sql);
     sql << inputType->nameOf(i);
@@ -380,7 +381,7 @@ void PrestoQueryRunnerToSqlPlanNodeVisitor::visit(
     }
 
     sql << " " << queryRunnerContext_->windowFrames_.at(node.id()).at(i);
-    sql << ")";
+    sql << ") as " << node.windowColumnNames()[i];
   }
 
   // WindowNode should have a single source.
diff --git a/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h b/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h
index 2c2b5d09f530..dd26b66611c4 100644
--- a/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h
+++ b/velox/exec/fuzzer/PrestoQueryRunnerToSqlPlanNodeVisitor.h
@@ -124,9 +124,20 @@ class PrestoQueryRunnerToSqlPlanNodeVisitor : public PrestoSqlPlanNodeVisitor {
   void visit(const core::ProjectNode& node, core::PlanNodeVisitorContext& ctx)
       const override;
 
+  void visit(const core::ParallelProjectNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::RowNumberNode& node, core::PlanNodeVisitorContext& ctx)
       const override;
 
+  void visit(
+      const core::SpatialJoinNode& node,
+      core::PlanNodeVisitorContext& ctx) const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::TableScanNode& node, core::PlanNodeVisitorContext& ctx)
       const override {
     PrestoSqlPlanNodeVisitor::visit(node, ctx);
diff --git a/velox/exec/fuzzer/PrestoSql.cpp b/velox/exec/fuzzer/PrestoSql.cpp
index 8e9bab903771..6b034ef89d18 100644
--- a/velox/exec/fuzzer/PrestoSql.cpp
+++ b/velox/exec/fuzzer/PrestoSql.cpp
@@ -19,6 +19,7 @@
 #include "velox/exec/fuzzer/PrestoQueryRunner.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/vector/SimpleVector.h"
 
 namespace facebook::velox::exec::test {
 
@@ -94,7 +95,7 @@ std::string toTypeSql(const TypePtr& type) {
     }
     default:
       if (type->isPrimitiveType()) {
-        return type->name();
+        return type->toString();
       }
       VELOX_UNSUPPORTED("Type is not supported: {}", type->toString());
   }
@@ -339,7 +340,7 @@ std::string toCallSql(const core::CallTypedExprPtr& call) {
 
 std::string toCastSql(const core::CastTypedExpr& cast) {
   std::stringstream sql;
-  if (cast.nullOnFailure()) {
+  if (cast.isTryCast()) {
     sql << "try_cast(";
   } else {
     sql << "cast(";
@@ -393,6 +394,10 @@ std::string toConstantSql(const core::ConstantTypedExpr& constant) {
       sql << typeSql << " ";
     }
     sql << std::quoted(getConstantValue<std::string>(constant), '\'', '\'');
+  } else if (type->isIntervalYearMonth()) {
+    sql << fmt::format("INTERVAL '{}' YEAR TO MONTH", constant.toString());
+  } else if (type->isIntervalDayTime()) {
+    sql << fmt::format("INTERVAL '{}' DAY TO SECOND", constant.toString());
   } else if (type->isBigint()) {
     sql << getConstantValue<int64_t>(constant);
   } else if (type->isPrimitiveType()) {
@@ -593,6 +598,12 @@ void PrestoSqlPlanNodeVisitor::visit(
   visitorContext.sql = sql.str();
 }
 
+void PrestoSqlPlanNodeVisitor::visit(
+    const core::SpatialJoinNode& node,
+    core::PlanNodeVisitorContext& ctx) const {
+  VELOX_NYI("SpatialJoinNode is not yet supported in SQL conversion");
+}
+
 std::optional<std::string> PrestoSqlPlanNodeVisitor::toSql(
     const core::PlanNodePtr& node) const {
   PrestoSqlPlanNodeVisitorContext sourceContext;
diff --git a/velox/exec/fuzzer/PrestoSql.h b/velox/exec/fuzzer/PrestoSql.h
index 7e3ed99d7c4d..2acfaaa2df96 100644
--- a/velox/exec/fuzzer/PrestoSql.h
+++ b/velox/exec/fuzzer/PrestoSql.h
@@ -70,6 +70,10 @@ class PrestoSqlPlanNodeVisitor : public core::PlanNodeVisitor {
       const core::NestedLoopJoinNode& node,
       core::PlanNodeVisitorContext& ctx) const override;
 
+  void visit(
+      const core::SpatialJoinNode& node,
+      core::PlanNodeVisitorContext& ctx) const override;
+
   void visit(const core::TableScanNode& node, core::PlanNodeVisitorContext& ctx)
       const override;
 
diff --git a/velox/exec/fuzzer/ReferenceQueryRunner.h b/velox/exec/fuzzer/ReferenceQueryRunner.h
index 4bfe30e955e7..983de96f5f8f 100644
--- a/velox/exec/fuzzer/ReferenceQueryRunner.h
+++ b/velox/exec/fuzzer/ReferenceQueryRunner.h
@@ -55,7 +55,8 @@ class ReferenceQueryRunner {
   enum class RunnerType {
     kPrestoQueryRunner,
     kDuckQueryRunner,
-    kSparkQueryRunner
+    kSparkQueryRunner,
+    kVeloxQueryRunner
   };
 
   // @param aggregatePool Used to allocate memory needed for vectors produced
@@ -114,15 +115,6 @@ class ReferenceQueryRunner {
     return true;
   }
 
-  /// 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<velox::RowVectorPtr>& /*input*/,
-      const velox::RowTypePtr& /*resultType*/) {
-    VELOX_UNSUPPORTED();
-  }
-
   // Converts 'plan' into an SQL query and executes it. Result is returned as
   // a MaterializedRowMultiset with the ReferenceQueryErrorCode::kSuccess if
   // successful, or an std::nullopt with a ReferenceQueryErrorCode if the
@@ -154,21 +146,12 @@ class ReferenceQueryRunner {
     VELOX_UNSUPPORTED();
   }
 
-  /// Returns true if 'executeVector' can be called to get results as Velox
-  /// Vector.
+  /// Returns true if 'executeAndReturnVector' 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();
-  }
-
   virtual std::vector<velox::RowVectorPtr> execute(const std::string& /*sql*/) {
     VELOX_UNSUPPORTED();
   }
diff --git a/velox/exec/fuzzer/RowNumberFuzzer.cpp b/velox/exec/fuzzer/RowNumberFuzzer.cpp
index 2fc3320cdc4d..7c8c911db758 100644
--- a/velox/exec/fuzzer/RowNumberFuzzer.cpp
+++ b/velox/exec/fuzzer/RowNumberFuzzer.cpp
@@ -68,7 +68,12 @@ class RowNumberFuzzer : public RowNumberFuzzerBase {
 RowNumberFuzzer::RowNumberFuzzer(
     size_t initialSeed,
     std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner)
-    : RowNumberFuzzerBase(initialSeed, std::move(referenceQueryRunner)) {}
+    : RowNumberFuzzerBase(initialSeed, std::move(referenceQueryRunner)) {
+  // Set timestamp precision as milliseconds, as timestamp may be used as
+  // paritition key, and presto doesn't supports nanosecond precision.
+  vectorFuzzer_.getMutableOptions().timestampPrecision =
+      fuzzer::FuzzerTimestampPrecision::kMilliSeconds;
+}
 
 std::pair<std::vector<std::string>, std::vector<TypePtr>>
 RowNumberFuzzer::generatePartitionKeys() {
diff --git a/velox/exec/fuzzer/RowNumberFuzzerBase.cpp b/velox/exec/fuzzer/RowNumberFuzzerBase.cpp
index 1b634b0f23bf..307216916c2b 100644
--- a/velox/exec/fuzzer/RowNumberFuzzerBase.cpp
+++ b/velox/exec/fuzzer/RowNumberFuzzerBase.cpp
@@ -19,6 +19,7 @@
 #include <utility>
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
+#include "velox/dwio/dwrf/RegisterDwrfWriter.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
@@ -78,6 +79,7 @@ RowNumberFuzzerBase::RowNumberFuzzerBase(
 void RowNumberFuzzerBase::setupReadWrite() {
   filesystems::registerLocalFileSystem();
   dwrf::registerDwrfReaderFactory();
+  dwrf::registerDwrfWriterFactory();
 
   if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
     serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
diff --git a/velox/exec/fuzzer/RowNumberFuzzerBase.h b/velox/exec/fuzzer/RowNumberFuzzerBase.h
index abae8551c555..1aaf5f4f3b03 100644
--- a/velox/exec/fuzzer/RowNumberFuzzerBase.h
+++ b/velox/exec/fuzzer/RowNumberFuzzerBase.h
@@ -18,6 +18,7 @@
 #include <utility>
 
 #include "velox/common/fuzzer/Utils.h"
+#include "velox/exec/MemoryReclaimer.h"
 #include "velox/exec/Split.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -124,14 +125,14 @@ class RowNumberFuzzerBase {
       memory::memoryManager()->addRootPool(
           "rowNumberFuzzer",
           memory::kMaxMemory,
-          memory::MemoryReclaimer::create())};
+          exec::MemoryReclaimer::create())};
   std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild(
       "rowNumberFuzzerLeaf",
       true,
-      memory::MemoryReclaimer::create())};
+      exec::MemoryReclaimer::create())};
   std::shared_ptr<memory::MemoryPool> writerPool_{rootPool_->addAggregateChild(
       "rowNumberFuzzerWriter",
-      memory::MemoryReclaimer::create())};
+      exec::MemoryReclaimer::create())};
   VectorFuzzer vectorFuzzer_;
   std::unique_ptr<test::ReferenceQueryRunner> referenceQueryRunner_;
 };
diff --git a/velox/exec/fuzzer/SpatialJoinFuzzer.cpp b/velox/exec/fuzzer/SpatialJoinFuzzer.cpp
new file mode 100644
index 000000000000..ffce520eef0a
--- /dev/null
+++ b/velox/exec/fuzzer/SpatialJoinFuzzer.cpp
@@ -0,0 +1,598 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/SpatialJoinFuzzer.h"
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.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).");
+
+namespace facebook::velox::exec {
+
+namespace {
+using namespace facebook::velox;
+
+/// Spatial distribution patterns for geometry generation.
+enum class GeometryDistribution {
+  kUniform, // Geometries uniformly distributed in space
+  kClustered, // Geometries clustered in specific regions
+  kSparse // Sparse geometries with low overlap probability
+};
+
+// Constants for geometry generation.
+constexpr int32_t kRandomCoordinateMax = 1000;
+constexpr int32_t kNumClusters = 5;
+constexpr double kClusterSpacing = 200.0;
+constexpr double kClusterCenterOffset = 100.0;
+constexpr int32_t kClusterSpreadRange = 100;
+constexpr int32_t kClusterSpreadHalf = kClusterSpreadRange / 2;
+constexpr double kPolygonSize = 10.0;
+constexpr double kSparseSpread = 2000.0;
+constexpr uint32_t kMaxRadius = 100;
+
+// Base class for geometry string generators.
+class GeometryInputGenerator : public AbstractInputGenerator {
+ public:
+  GeometryInputGenerator(
+      GeometryDistribution distribution,
+      size_t seed,
+      double nullRatio)
+      : AbstractInputGenerator(seed, VARCHAR(), nullptr, nullRatio),
+        distribution_(distribution) {}
+
+ protected:
+  std::pair<double, double> generateCoordinates() {
+    double x, y;
+    switch (distribution_) {
+      case GeometryDistribution::kUniform: {
+        x = fuzzer::rand<int32_t>(
+            rng_, -kRandomCoordinateMax, kRandomCoordinateMax);
+        y = fuzzer::rand<int32_t>(
+            rng_, -kRandomCoordinateMax, kRandomCoordinateMax);
+        break;
+      }
+      case GeometryDistribution::kClustered: {
+        uint32_t cluster = fuzzer::rand<uint32_t>(rng_, 0, kNumClusters);
+        double centerX = (cluster * kClusterSpacing) + kClusterCenterOffset;
+        double centerY = (cluster * kClusterSpacing) + kClusterCenterOffset;
+        x = centerX +
+            ((fuzzer::rand<int32_t>(
+                 rng_, -kClusterSpreadRange, kClusterSpreadRange)) -
+             kClusterSpreadHalf);
+        y = centerY +
+            ((fuzzer::rand<int32_t>(
+                 rng_, -kClusterSpreadRange, kClusterSpreadRange)) -
+             kClusterSpreadHalf);
+        break;
+      }
+      case GeometryDistribution::kSparse: {
+        x = fuzzer::rand<int32_t>(rng_, -kSparseSpread, kSparseSpread);
+        y = fuzzer::rand<int32_t>(rng_, -kSparseSpread, kSparseSpread);
+        break;
+      }
+    }
+    return {x, y};
+  }
+
+  GeometryDistribution distribution_;
+};
+
+// Generates POINT geometry strings.
+class PointInputGenerator : public GeometryInputGenerator {
+ public:
+  PointInputGenerator(
+      GeometryDistribution distribution,
+      size_t seed,
+      double nullRatio)
+      : GeometryInputGenerator(distribution, seed, nullRatio) {}
+
+  variant generate() override {
+    if (fuzzer::coinToss(rng_, nullRatio_)) {
+      return variant::null(type_->kind());
+    }
+
+    auto [x, y] = generateCoordinates();
+    return fmt::format("POINT ({} {})", x, y);
+  }
+};
+
+// Generates POLYGON geometry strings.
+class PolygonInputGenerator : public GeometryInputGenerator {
+ public:
+  PolygonInputGenerator(
+      GeometryDistribution distribution,
+      size_t seed,
+      double nullRatio)
+      : GeometryInputGenerator(distribution, seed, nullRatio) {}
+
+  variant generate() override {
+    if (fuzzer::coinToss(rng_, nullRatio_)) {
+      return variant::null(type_->kind());
+    }
+    auto [centerX, centerY] = generateCoordinates();
+    return fmt::format(
+        "POLYGON (({} {}, {} {}, {} {}, {} {}, {} {}))",
+        centerX - kPolygonSize,
+        centerY - kPolygonSize,
+        centerX + kPolygonSize,
+        centerY - kPolygonSize,
+        centerX + kPolygonSize,
+        centerY + kPolygonSize,
+        centerX - kPolygonSize,
+        centerY + kPolygonSize,
+        centerX - kPolygonSize,
+        centerY - kPolygonSize);
+  }
+};
+
+// Generates LINESTRING geometry strings.
+class LineStringInputGenerator : public GeometryInputGenerator {
+ public:
+  LineStringInputGenerator(
+      GeometryDistribution distribution,
+      size_t seed,
+      double nullRatio)
+      : GeometryInputGenerator(distribution, seed, nullRatio) {}
+
+  variant generate() override {
+    if (fuzzer::coinToss(rng_, nullRatio_)) {
+      return variant::null(type_->kind());
+    }
+    auto [x1, y1] = generateCoordinates();
+    double x2 = x1 + kPolygonSize;
+    double y2 = y1 + kPolygonSize;
+    return fmt::format("LINESTRING ({} {}, {} {})", x1, y1, x2, y2);
+  }
+};
+
+class SpatialJoinFuzzer {
+ public:
+  explicit SpatialJoinFuzzer(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 supported by SpatialJoin.
+  core::JoinType pickJoinType();
+
+  // Randomly pick a spatial predicate function.
+  std::string pickSpatialPredicate();
+
+  // Randomly pick a geometry distribution pattern.
+  GeometryDistribution pickDistribution();
+
+  // Runs one test iteration from query plans generation, execution and result
+  // verification.
+  void verify(core::JoinType joinType);
+
+  // Creates a vector of POINT geometries with specified distribution.
+  VectorPtr makePointVector(int32_t size, GeometryDistribution distribution);
+
+  // Creates a vector of POLYGON geometries with specified distribution.
+  VectorPtr makePolygonVector(int32_t size, GeometryDistribution distribution);
+
+  // Creates a vector of LINESTRING geometries with specified distribution.
+  VectorPtr makeLineStringVector(
+      int32_t size,
+      GeometryDistribution distribution);
+
+  // Returns randomly generated probe input with geometry columns (as WKT
+  // strings).
+  std::vector<RowVectorPtr> generateProbeInput(
+      GeometryDistribution distribution);
+
+  // Same as generateProbeInput() but copies over 10% of the input to ensure
+  // some matches during joining. Also generates an empty input with a 10%
+  // chance.
+  std::vector<RowVectorPtr> generateBuildInput(
+      const std::vector<RowVectorPtr>& probeInput,
+      GeometryDistribution distribution);
+
+  // Executes a plan and returns the result.
+  RowVectorPtr execute(const core::PlanNodePtr& plan);
+
+  int32_t randInt(int32_t min, int32_t max) {
+    return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
+  }
+
+  const std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  std::mt19937 rng_;
+  size_t currentSeed_{0};
+
+  VectorFuzzer vectorFuzzer_;
+
+  struct {
+    size_t numIterations{0};
+  } stats_;
+};
+
+SpatialJoinFuzzer::SpatialJoinFuzzer(size_t initialSeed)
+    : vectorFuzzer_{getFuzzerOptions(), pool_.get()} {
+  filesystems::registerLocalFileSystem();
+  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 SpatialJoinFuzzer::pickJoinType() {
+  // SpatialJoin only supports INNER and LEFT join types.
+  static std::vector<core::JoinType> kJoinTypes = {
+      core::JoinType::kInner, core::JoinType::kLeft};
+
+  const size_t idx = randInt(0, kJoinTypes.size() - 1);
+  return kJoinTypes[idx];
+}
+
+std::string SpatialJoinFuzzer::pickSpatialPredicate() {
+  // Common spatial predicates supported by spatial joins.
+  static std::vector<std::string> kPredicates = {
+      "ST_Intersects",
+      "ST_Contains",
+      "ST_Within",
+      "ST_Distance",
+      "ST_Overlaps",
+      "ST_Crosses",
+      "ST_Touches",
+      "ST_Equals"};
+
+  const size_t idx = randInt(0, kPredicates.size() - 1);
+  return kPredicates[idx];
+}
+
+GeometryDistribution SpatialJoinFuzzer::pickDistribution() {
+  static std::vector<GeometryDistribution> kDistributions = {
+      GeometryDistribution::kUniform,
+      GeometryDistribution::kClustered,
+      GeometryDistribution::kSparse};
+
+  const size_t idx = randInt(0, kDistributions.size() - 1);
+  return kDistributions[idx];
+}
+
+VectorPtr SpatialJoinFuzzer::makePointVector(
+    int32_t size,
+    GeometryDistribution distribution) {
+  auto generator = std::make_shared<PointInputGenerator>(
+      distribution, currentSeed_, getFuzzerOptions().nullRatio);
+  return vectorFuzzer_.fuzzFlat(VARCHAR(), size, generator);
+}
+
+VectorPtr SpatialJoinFuzzer::makePolygonVector(
+    int32_t size,
+    GeometryDistribution distribution) {
+  auto generator = std::make_shared<PolygonInputGenerator>(
+      distribution, currentSeed_, getFuzzerOptions().nullRatio);
+  return vectorFuzzer_.fuzzFlat(VARCHAR(), size, generator);
+}
+
+VectorPtr SpatialJoinFuzzer::makeLineStringVector(
+    int32_t size,
+    GeometryDistribution distribution) {
+  auto generator = std::make_shared<LineStringInputGenerator>(
+      distribution, currentSeed_, getFuzzerOptions().nullRatio);
+  return vectorFuzzer_.fuzzFlat(VARCHAR(), size, generator);
+}
+
+std::vector<RowVectorPtr> SpatialJoinFuzzer::generateProbeInput(
+    GeometryDistribution distribution) {
+  std::vector<RowVectorPtr> input;
+
+  const int32_t numRows = FLAGS_batch_size * FLAGS_num_batches;
+  const int32_t batchSize = FLAGS_batch_size;
+  const int32_t numBatches = FLAGS_num_batches;
+
+  // Randomly pick geometry type for probe side.
+  const int geometryType = randInt(0, 2);
+
+  for (int32_t i = 0; i < numBatches; ++i) {
+    int32_t currentBatchSize = std::min(batchSize, numRows - (i * batchSize));
+
+    VectorPtr geomVector;
+    if (geometryType == 0) {
+      geomVector = makePointVector(currentBatchSize, distribution);
+    } else if (geometryType == 1) {
+      geomVector = makePolygonVector(currentBatchSize, distribution);
+    } else {
+      geomVector = makeLineStringVector(currentBatchSize, distribution);
+    }
+
+    auto idVector = vectorFuzzer_.fuzzFlat(BIGINT(), currentBatchSize);
+    auto rowType = ROW(
+        {"probe_id", "probe_geom_wkt"}, {idVector->type(), geomVector->type()});
+    auto rowVector = std::make_shared<RowVector>(
+        pool_.get(),
+        rowType,
+        nullptr,
+        currentBatchSize,
+        std::vector{idVector, geomVector});
+    input.push_back(rowVector);
+  }
+
+  return input;
+}
+
+std::vector<RowVectorPtr> SpatialJoinFuzzer::generateBuildInput(
+    const std::vector<RowVectorPtr>& probeInput,
+    GeometryDistribution distribution) {
+  std::vector<RowVectorPtr> input;
+
+  // 1 in 10 times use empty build.
+  if (vectorFuzzer_.coinToss(0.1)) {
+    auto rowType = ROW({"build_id", "build_geom_wkt"}, {BIGINT(), VARCHAR()});
+    auto rowVector = std::make_shared<RowVector>(
+        pool_.get(),
+        rowType,
+        nullptr,
+        0,
+        std::vector{
+            vectorFuzzer_.fuzzFlat(BIGINT(), 0),
+            vectorFuzzer_.fuzzFlat(VARCHAR(), 0)});
+    return {rowVector};
+  }
+
+  // Randomly pick geometry type for build side.
+  const int geometryType = randInt(0, 2);
+
+  for (const auto& probe : probeInput) {
+    auto numRows = 1 + probe->size() / 8;
+
+    VectorPtr geomVector;
+    if (geometryType == 0) {
+      geomVector = makePointVector(numRows, distribution);
+    } else if (geometryType == 1) {
+      geomVector = makePolygonVector(numRows, distribution);
+    } else {
+      geomVector = makeLineStringVector(numRows, distribution);
+    }
+
+    auto idVector = vectorFuzzer_.fuzzFlat(BIGINT(), numRows);
+
+    // To ensure some matches, copy some geometries from probe side.
+    if (probe->size() > 0) {
+      std::vector<vector_size_t> rowNumbers(numRows);
+      SelectivityVector rows(numRows, false);
+      for (vector_size_t i = 0; i < numRows; ++i) {
+        if (vectorFuzzer_.coinToss(0.3)) {
+          rowNumbers[i] = randInt(0, probe->size() - 1);
+          rows.setValid(i, true);
+        }
+      }
+
+      // Copy geometry from probe to build.
+      auto probeGeom = probe->childAt(1);
+      geomVector->copy(probeGeom.get(), rows, rowNumbers.data());
+    }
+
+    auto rowType = ROW(
+        {"build_id", "build_geom_wkt"}, {idVector->type(), geomVector->type()});
+    auto rowVector = std::make_shared<RowVector>(
+        pool_.get(),
+        rowType,
+        nullptr,
+        numRows,
+        std::vector{idVector, geomVector});
+    input.push_back(rowVector);
+  }
+
+  return input;
+}
+
+RowVectorPtr SpatialJoinFuzzer::execute(const core::PlanNodePtr& plan) {
+  LOG(INFO) << "Executing query plan: " << std::endl
+            << plan->toString(true, true);
+
+  return test::AssertQueryBuilder(plan).copyResults(pool_.get());
+}
+
+void SpatialJoinFuzzer::verify(core::JoinType joinType) {
+  const auto distribution = pickDistribution();
+  const auto predicate = pickSpatialPredicate();
+
+  // Generate test data (WKT strings).
+  auto probeInput = generateProbeInput(distribution);
+  auto buildInput = generateBuildInput(probeInput, distribution);
+
+  if (VLOG_IS_ON(1)) {
+    VLOG(1) << "Probe input: " << probeInput[0]->toString();
+    for (const auto& v : probeInput) {
+      VLOG(1) << std::endl << v->toString(0, v->size());
+    }
+
+    VLOG(1) << "Build input: " << buildInput[0]->toString();
+    for (const auto& v : buildInput) {
+      VLOG(1) << std::endl << v->toString(0, v->size());
+    }
+  }
+
+  // Build spatial join plan with geometry conversion as part of the plan.
+  const auto planNodeIdGenerator =
+      std::make_shared<core::PlanNodeIdGenerator>();
+
+  std::string joinCondition;
+  std::optional<std::string> radiusColumn;
+  std::optional<std::string> radiusExpression;
+  if (predicate == "ST_Distance") {
+    // ST_Distance returns a value, use it with a threshold.
+    // For ST_Distance, we use a radius column instead of embedding the
+    // threshold in the join condition.
+    joinCondition =
+        fmt::format("{}(probe_geom, build_geom) < radius", predicate);
+    radiusColumn = "radius";
+    radiusExpression = fmt::format(
+        "CAST({} AS DOUBLE) AS radius",
+        static_cast<double>(randInt(0, kMaxRadius)));
+  } else {
+    // Other predicates return boolean.
+    joinCondition = fmt::format("{}(probe_geom, build_geom)", predicate);
+  }
+
+  // Create SpatialJoin plan with geometry conversion projections.
+  auto spatialJoinPlan =
+      test::PlanBuilder(planNodeIdGenerator)
+          .values(probeInput)
+          // Convert probe WKT strings to Geometry
+          .project(
+              {"probe_id",
+               "ST_GeometryFromText(probe_geom_wkt) AS probe_geom",
+               "probe_geom_wkt"})
+          .spatialJoin(
+              test::PlanBuilder(planNodeIdGenerator)
+                  .values(buildInput)
+                  // Convert build WKT strings to Geometry
+                  .project(
+                      radiusColumn.has_value()
+                          ? std::vector<
+                                std::
+                                    string>{"build_id", "ST_GeometryFromText(build_geom_wkt) AS build_geom", "build_geom_wkt", radiusExpression.value()}
+                          : std::vector<
+                                std::
+                                    string>{"build_id", "ST_GeometryFromText(build_geom_wkt) AS build_geom", "build_geom_wkt"})
+                  .planNode(),
+              joinCondition,
+              "probe_geom",
+              "build_geom",
+              radiusColumn,
+              {"probe_id", "probe_geom_wkt", "build_id", "build_geom_wkt"},
+              joinType)
+          .planNode();
+
+  // Create equivalent NestedLoopJoin plan for comparison.
+  auto nestedLoopJoinPlan =
+      test::PlanBuilder(planNodeIdGenerator)
+          .values(probeInput)
+          // Convert probe WKT strings to Geometry
+          .project(
+              {"probe_id",
+               "ST_GeometryFromText(probe_geom_wkt) AS probe_geom",
+               "probe_geom_wkt"})
+          .nestedLoopJoin(
+              test::PlanBuilder(planNodeIdGenerator)
+                  .values(buildInput)
+                  // Convert build WKT strings to Geometry
+                  .project(
+                      radiusColumn.has_value()
+                          ? std::vector<
+                                std::
+                                    string>{"build_id", "ST_GeometryFromText(build_geom_wkt) AS build_geom", "build_geom_wkt", radiusExpression.value()}
+                          : std::vector<
+                                std::
+                                    string>{"build_id", "ST_GeometryFromText(build_geom_wkt) AS build_geom", "build_geom_wkt"})
+                  .planNode(),
+              {joinCondition},
+              {"probe_id", "probe_geom_wkt", "build_id", "build_geom_wkt"},
+              joinType)
+          .planNode();
+
+  LOG(INFO) << "Executing SpatialJoin plan...";
+  const auto spatialJoinResult = execute(spatialJoinPlan);
+
+  LOG(INFO) << "Executing NestedLoopJoin plan...";
+  const auto nestedLoopJoinResult = execute(nestedLoopJoinPlan);
+
+  // Compare SpatialJoin vs NestedLoopJoin results.
+  auto result =
+      test::assertEqualResults({nestedLoopJoinResult}, {spatialJoinResult});
+  VELOX_CHECK(result, "SpatialJoin and NestedLoopJoin results don't match");
+
+  LOG(INFO) << "SpatialJoin matches NestedLoopJoin.";
+}
+
+void SpatialJoinFuzzer::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) << "Total iterations: " << stats_.numIterations;
+}
+
+} // namespace
+
+void spatialJoinFuzzer(size_t seed) {
+  SpatialJoinFuzzer(seed).go();
+}
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/fuzzer/SpatialJoinFuzzer.h b/velox/exec/fuzzer/SpatialJoinFuzzer.h
new file mode 100644
index 000000000000..92bdd967213b
--- /dev/null
+++ b/velox/exec/fuzzer/SpatialJoinFuzzer.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 <cstddef>
+namespace facebook::velox::exec {
+
+/// Runs the fuzzer for SpatialJoin operator. Generates random geometry data
+/// and spatial join plans with various predicates (ST_Intersects, ST_Contains,
+/// ST_Within, ST_Distance), comparing SpatialJoin results against
+/// NestedLoopJoin as the reference implementation.
+///
+/// The fuzzer tests:
+/// - Different spatial predicates
+/// - INNER and LEFT join types (the only types supported by SpatialJoin)
+/// - Different geometry types (POINT, POLYGON, LINESTRING)
+/// - Various data distributions (uniform, clustered, sparse)
+/// - Different sizes of probe and build sides
+/// - Plans with and without filters
+/// - Different output column projections
+void spatialJoinFuzzer(size_t seed);
+
+} // namespace facebook::velox::exec
diff --git a/velox/exec/fuzzer/SpatialJoinFuzzerRunner.cpp b/velox/exec/fuzzer/SpatialJoinFuzzerRunner.cpp
new file mode 100644
index 000000000000..943c872290c6
--- /dev/null
+++ b/velox/exec/fuzzer/SpatialJoinFuzzerRunner.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 <folly/init/Init.h>
+#include <gflags/gflags.h>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/exec/fuzzer/SpatialJoinFuzzer.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/serializers/PrestoSerializer.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;
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+
+  // Initialize memory system.
+  memory::initializeMemoryManager(memory::MemoryManager::Options{});
+  auto pool = memory::memoryManager()->addLeafPool();
+
+  // Register file systems.
+  filesystems::registerLocalFileSystem();
+
+  // Register Presto functions.
+  functions::prestosql::registerAllScalarFunctions();
+
+  // Register type resolver.
+  parse::registerTypeResolver();
+
+  // Register serializers.
+  if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+    serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
+  }
+
+  // Determine the seed.
+  size_t seed = FLAGS_seed == 0 ? std::random_device{}() : FLAGS_seed;
+  LOG(INFO) << "Using seed: " << seed;
+
+  // Run the spatial join fuzzer.
+  exec::spatialJoinFuzzer(seed);
+
+  return 0;
+}
diff --git a/velox/exec/fuzzer/TopNRowNumberFuzzer.cpp b/velox/exec/fuzzer/TopNRowNumberFuzzer.cpp
index 7d658aa68885..34b33d330ee9 100644
--- a/velox/exec/fuzzer/TopNRowNumberFuzzer.cpp
+++ b/velox/exec/fuzzer/TopNRowNumberFuzzer.cpp
@@ -41,6 +41,8 @@ class TopNRowNumberFuzzer : public RowNumberFuzzerBase {
   std::pair<std::vector<std::string>, std::vector<TypePtr>> generateKeys(
       const std::string& prefix);
 
+  std::string generateRankFunction();
+
   std::vector<RowVectorPtr> generateInput(
       const std::vector<std::string>& keyNames,
       const std::vector<TypePtr>& keyTypes,
@@ -93,6 +95,19 @@ TopNRowNumberFuzzer::generateKeys(const std::string& prefix) {
   return std::make_pair(keys, types);
 }
 
+std::string TopNRowNumberFuzzer::generateRankFunction() {
+  int32_t rankFunction = randInt(0, 2);
+  switch (rankFunction) {
+    case 0:
+      return "row_number";
+    case 1:
+      return "rank";
+    case 2:
+      return "dense_rank";
+  }
+  return "row_number";
+}
+
 std::vector<RowVectorPtr> TopNRowNumberFuzzer::generateInput(
     const std::vector<std::string>& keyNames,
     const std::vector<TypePtr>& keyTypes,
@@ -153,12 +168,14 @@ std::vector<RowVectorPtr> TopNRowNumberFuzzer::generateInput(
         // values. This is done to introduce some repetition of key values for
         // windowing.
         auto baseVector = vectorFuzzer_.fuzz(keyTypes[i], numPartitions);
-        children.push_back(BaseVector::wrapInDictionary(
-            partitionNulls, partitionIndices, size, baseVector));
+        children.push_back(
+            BaseVector::wrapInDictionary(
+                partitionNulls, partitionIndices, size, baseVector));
       } else if (sortingKeySet.find(keyNames[i]) != sortingKeySet.end()) {
         auto baseVector = vectorFuzzer_.fuzz(keyTypes[i], numPeerGroups);
-        children.push_back(BaseVector::wrapInDictionary(
-            sortingNulls, sortingIndices, size, baseVector));
+        children.push_back(
+            BaseVector::wrapInDictionary(
+                sortingNulls, sortingIndices, size, baseVector));
       } else {
         children.push_back(vectorFuzzer_.fuzz(keyTypes[i], size));
       }
@@ -182,11 +199,13 @@ TopNRowNumberFuzzer::makeDefaultPlan(
   projectFields.emplace_back("row_number");
 
   int32_t limit = randInt(1, FLAGS_batch_size);
-  auto plan = test::PlanBuilder()
-                  .values(input)
-                  .topNRowNumber(partitionKeys, sortKeys, limit, true)
-                  .project(projectFields)
-                  .planNode();
+  auto plan =
+      test::PlanBuilder()
+          .values(input)
+          .topNRank(
+              generateRankFunction(), partitionKeys, sortKeys, limit, true)
+          .project(projectFields)
+          .planNode();
   return std::make_pair(PlanWithSplits{std::move(plan)}, limit);
 }
 
@@ -203,11 +222,13 @@ RowNumberFuzzerBase::PlanWithSplits TopNRowNumberFuzzer::makePlanWithTableScan(
   projectFields.emplace_back("row_number");
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto plan = test::PlanBuilder(planNodeIdGenerator)
-                  .tableScan(asRowType(input[0]->type()))
-                  .topNRowNumber(partitionKeys, sortKeys, limit, true)
-                  .project(projectFields)
-                  .planNode();
+  auto plan =
+      test::PlanBuilder(planNodeIdGenerator)
+          .tableScan(asRowType(input[0]->type()))
+          .topNRank(
+              generateRankFunction(), partitionKeys, sortKeys, limit, true)
+          .project(projectFields)
+          .planNode();
 
   const std::vector<Split> splits = test::makeSplits(
       input, fmt::format("{}/topn_row_number", tableDir), writerPool_);
diff --git a/velox/exec/fuzzer/VeloxQueryRunner.cpp b/velox/exec/fuzzer/VeloxQueryRunner.cpp
new file mode 100644
index 000000000000..af938741db0e
--- /dev/null
+++ b/velox/exec/fuzzer/VeloxQueryRunner.cpp
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/VeloxQueryRunner.h"
+
+#include <fmt/format.h>
+#include <folly/Uri.h>
+#include <folly/json.h>
+#include <re2/re2.h>
+#include <thrift/lib/cpp2/async/RocketClientChannel.h>
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/if/gen-cpp2/LocalRunnerService.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/functions/prestosql/types/BingTileType.h"
+#include "velox/functions/prestosql/types/GeometryType.h"
+#include "velox/functions/prestosql/types/IPAddressType.h"
+#include "velox/functions/prestosql/types/IPPrefixType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/type/parser/TypeParser.h"
+
+using namespace facebook::velox::runner;
+
+namespace facebook::velox::exec::test {
+
+namespace {
+
+RowTypePtr parseBatchRowType(Batch batch) {
+  std::vector<std::string> names;
+  std::vector<TypePtr> types;
+
+  for (const auto& name : *batch.columnNames()) {
+    names.push_back(name);
+  }
+
+  // Clean up type strings and format according to TypeParser::parseType
+  // expectation. Input types are serialized by type()->asRow() for Thrift
+  // struct by LocalRunnerService in the format of SOME_COMPLEX_TYPE<TYPE_1,
+  // TYPE_2, etc.> (note the '<' and '>'). And in the case of complex type ROW,
+  // types follow column name and a semicolon: as an example, ROW<f0:TYPE_1,
+  // f1:TYPE_2, etc.>. We need to change these particular character choices to
+  // paranthesis (in the case of the angled brackets) and spaces (in the case of
+  // the semicolon). As an example,
+  //  MAP<VARCHAR,TIMESTAMP> -> MAP(VARCHAR, TIMESTAMP)
+  //  ROW<f0:TYPE_1, f1:TYPE_2, etc.> -> ROW(f0 TYPE_1, f1 TYPE_2, etc.)
+  // as expected by TypeParser::parseType. Without this cleanup, parse will
+  // crash and fuzzer will fail.
+  for (const auto& typeString : *batch.columnTypes()) {
+    auto parsedTypeString = typeString;
+    std::replace(parsedTypeString.begin(), parsedTypeString.end(), '<', '(');
+    std::replace(parsedTypeString.begin(), parsedTypeString.end(), '>', ')');
+    std::replace(parsedTypeString.begin(), parsedTypeString.end(), ':', ' ');
+    types.push_back(parseType(parsedTypeString));
+  }
+
+  return ROW(std::move(names), std::move(types));
+}
+
+std::vector<RowVectorPtr> deserializeBatches(
+    const std::vector<Batch>& resultBatches,
+    memory::MemoryPool* pool) {
+  std::vector<RowVectorPtr> queryResults;
+
+  auto serde = std::make_unique<serializer::presto::PrestoVectorSerde>();
+  serializer::presto::PrestoVectorSerde::PrestoOptions options;
+
+  for (const auto& batch : resultBatches) {
+    VELOX_CHECK(
+        apache::thrift::is_non_optional_field_set_manually_or_by_serializer(
+            batch.serializedData_ref()));
+    VELOX_CHECK(!batch.serializedData()->empty());
+
+    // Deserialize binary data.
+    const auto& serializedData = *batch.serializedData();
+    ByteRange byteRange{
+        reinterpret_cast<uint8_t*>(const_cast<char*>(serializedData.data())),
+        static_cast<int32_t>(serializedData.length()),
+        0};
+    auto byteStream = std::make_unique<BufferInputStream>(
+        std::vector<ByteRange>{{byteRange}});
+
+    RowVectorPtr rowVector;
+    serde->deserialize(
+        byteStream.get(),
+        pool,
+        parseBatchRowType(batch),
+        &rowVector,
+        0,
+        &options);
+
+    VELOX_CHECK_NOT_NULL(rowVector);
+    queryResults.push_back(rowVector);
+  }
+
+  return queryResults;
+}
+
+std::shared_ptr<apache::thrift::Client<LocalRunnerService>> createThriftClient(
+    const std::string& host,
+    int port,
+    std::chrono::milliseconds timeout,
+    folly::EventBase* evb) {
+  folly::SocketAddress addr(host, port);
+  auto socket = folly::AsyncSocket::newSocket(evb, addr, timeout.count());
+  auto channel =
+      apache::thrift::RocketClientChannel::newChannel(std::move(socket));
+  return std::make_shared<apache::thrift::Client<LocalRunnerService>>(
+      std::move(channel));
+}
+} // namespace
+
+VeloxQueryRunner::VeloxQueryRunner(
+    memory::MemoryPool* aggregatePool,
+    std::string serviceUri,
+    std::chrono::milliseconds timeout)
+    : ReferenceQueryRunner(aggregatePool),
+      serviceUri_(std::move(serviceUri)),
+      timeout_(timeout) {
+  pool_ = aggregatePool->addLeafChild("leaf");
+
+  folly::Uri uri(serviceUri_);
+  thriftHost_ = uri.host();
+  thriftPort_ = uri.port();
+}
+
+const std::vector<TypePtr>& VeloxQueryRunner::supportedScalarTypes() const {
+  static const std::vector<TypePtr> kScalarTypes{
+      BOOLEAN(),
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      REAL(),
+      DOUBLE(),
+      VARCHAR(),
+      VARBINARY(),
+      TIMESTAMP(),
+      TIMESTAMP_WITH_TIME_ZONE(),
+      IPADDRESS(),
+      UUID(),
+      // https://github.com/facebookincubator/velox/issues/15379 (IPPREFIX)
+      // https://github.com/facebookincubator/velox/issues/15380 (Non-orderable
+      // custom types such as HYPERLOGLOG, JSON, BINGTILE, GEOMETRY, etc.)
+  };
+  return kScalarTypes;
+}
+
+const std::unordered_map<std::string, DataSpec>&
+VeloxQueryRunner::aggregationFunctionDataSpecs() const {
+  static const std::unordered_map<std::string, DataSpec>
+      kAggregationFunctionDataSpecs{};
+  return kAggregationFunctionDataSpecs;
+}
+
+std::optional<std::string> VeloxQueryRunner::toSql(
+    const core::PlanNodePtr& /*plan*/) {
+  // We don't need to convert to SQL for VeloxQueryRunner
+  // as we're sending the serialized plan directly
+  VELOX_FAIL("VeloxQueryRunner does not support SQL conversion");
+}
+
+bool VeloxQueryRunner::isConstantExprSupported(
+    const core::TypedExprPtr& /*expr*/) {
+  // Since we're using Velox directly, we support all constant expressions
+  return true;
+}
+
+bool VeloxQueryRunner::isSupported(
+    const exec::FunctionSignature& /*signature*/) {
+  // Since we're using Velox directly, we support all function signatures
+  return true;
+}
+
+std::vector<RowVectorPtr> VeloxQueryRunner::execute(
+    const std::string& /*sql*/) {
+  VELOX_FAIL("VeloxQueryRunner does not support SQL execution");
+}
+
+std::vector<RowVectorPtr> VeloxQueryRunner::execute(
+    const std::string& /*sql*/,
+    const std::string& /*sessionProperty*/) {
+  VELOX_FAIL("VeloxQueryRunner does not support SQL execution");
+}
+
+std::pair<
+    std::optional<std::multiset<std::vector<velox::variant>>>,
+    ReferenceQueryErrorCode>
+VeloxQueryRunner::execute(const core::PlanNodePtr& plan) {
+  auto serializedPlan = serializePlan(plan);
+  auto queryId = fmt::format("velox_local_query_runner_{}", rand());
+
+  auto client =
+      createThriftClient(thriftHost_, thriftPort_, timeout_, &eventBase_);
+
+  // Create the request
+  ExecutePlanRequest request;
+  request.serializedPlan() = serializedPlan;
+  request.queryId() = queryId;
+  request.numWorkers() = 4; // Default value
+  request.numDrivers() = 2; // Default value
+
+  // Send the request
+  ExecutePlanResponse response;
+  try {
+    client->sync_execute(response, request);
+  } catch (const std::exception& e) {
+    VELOX_FAIL("Thrift request failed: {}", e.what());
+  }
+
+  // Handle the response
+  if (*response.success()) {
+    LOG(INFO) << "Reference eval succeeded.";
+    return std::make_pair(
+        exec::test::materialize(
+            deserializeBatches(*response.results(), pool_.get())),
+        ReferenceQueryErrorCode::kSuccess);
+  } else {
+    LOG(INFO) << "Reference eval failed.";
+    return std::make_pair(
+        std::nullopt, ReferenceQueryErrorCode::kReferenceQueryFail);
+  }
+}
+
+std::string VeloxQueryRunner::serializePlan(const core::PlanNodePtr& plan) {
+  // Serialize the plan to JSON
+  folly::dynamic serializedPlan = plan->serialize();
+  return folly::toJson(serializedPlan);
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/VeloxQueryRunner.h b/velox/exec/fuzzer/VeloxQueryRunner.h
new file mode 100644
index 000000000000..67826c62bced
--- /dev/null
+++ b/velox/exec/fuzzer/VeloxQueryRunner.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 <folly/io/async/EventBaseThread.h>
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+class VeloxQueryRunner : public ReferenceQueryRunner {
+ public:
+  /// @param serviceUri Thrift URI of the LocalRunnerService.
+  /// @param timeout Timeout in milliseconds of a request.
+  VeloxQueryRunner(
+      memory::MemoryPool* aggregatePool,
+      std::string serviceUri,
+      std::chrono::milliseconds timeout);
+
+  RunnerType runnerType() const override {
+    return RunnerType::kVeloxQueryRunner;
+  }
+
+  const std::vector<TypePtr>& supportedScalarTypes() const override;
+
+  const std::unordered_map<std::string, DataSpec>&
+  aggregationFunctionDataSpecs() const override;
+
+  std::optional<std::string> toSql(const core::PlanNodePtr& plan) override;
+
+  bool isConstantExprSupported(const core::TypedExprPtr& expr) override;
+
+  bool isSupported(const exec::FunctionSignature& signature) override;
+
+  std::pair<
+      std::optional<std::multiset<std::vector<velox::variant>>>,
+      ReferenceQueryErrorCode>
+  execute(const core::PlanNodePtr& plan) override;
+
+  bool supportsVeloxVectorResults() const override {
+    return true;
+  }
+
+  std::vector<RowVectorPtr> execute(const std::string& sql) override;
+
+  std::vector<RowVectorPtr> execute(
+      const std::string& sql,
+      const std::string& sessionProperty) override;
+
+ private:
+  // Serializes the plan node to JSON string
+  std::string serializePlan(const core::PlanNodePtr& plan);
+
+  std::string serviceUri_;
+  std::chrono::milliseconds timeout_;
+  folly::EventBase eventBase_;
+  std::shared_ptr<memory::MemoryPool> pool_;
+
+  // Thrift-specific members
+  std::string thriftHost_;
+  int thriftPort_{9091};
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/fuzzer/WindowFuzzer.cpp b/velox/exec/fuzzer/WindowFuzzer.cpp
index e782d263cc67..28792adeb277 100644
--- a/velox/exec/fuzzer/WindowFuzzer.cpp
+++ b/velox/exec/fuzzer/WindowFuzzer.cpp
@@ -151,12 +151,12 @@ std::string WindowFuzzer::frameClauseString(
     const std::vector<std::string>& kRangeOffsetColumns) {
   auto frameType = [&](const core::WindowNode::BoundType boundType,
                        bool isStartBound) -> std::string {
-    const auto boundTypeString = core::WindowNode::boundTypeName(boundType);
+    const auto boundTypeString = core::WindowNode::toName(boundType);
     switch (boundType) {
       case core::WindowNode::BoundType::kUnboundedPreceding:
       case core::WindowNode::BoundType::kCurrentRow:
       case core::WindowNode::BoundType::kUnboundedFollowing:
-        return boundTypeString;
+        return std::string(boundTypeString);
       case core::WindowNode::BoundType::kPreceding:
       case core::WindowNode::BoundType::kFollowing: {
         std::string frameBound;
@@ -177,7 +177,7 @@ std::string WindowFuzzer::frameClauseString(
 
   return fmt::format(
       " {} BETWEEN {} AND {}",
-      core::WindowNode::windowTypeName(frameMetadata.windowType),
+      core::WindowNode::toName(frameMetadata.windowType),
       frameType(frameMetadata.startBoundType, true),
       frameType(frameMetadata.endBoundType, false));
 }
@@ -218,7 +218,7 @@ const T WindowFuzzer::genOffsetAtIdx(
       "Offset cannot be generated: orderBy key type: {}, sortOrder ascending {}, frameBoundType {}",
       CppToType<T>::name,
       sortOrder.toString(),
-      core::WindowNode::boundTypeName(frameBoundType));
+      core::WindowNode::toName(frameBoundType));
   return T{};
 }
 
@@ -609,8 +609,9 @@ void WindowFuzzer::testAlternativePlans(
     allKeys.emplace_back(key + " NULLS FIRST");
   }
   for (const auto& keyAndOrder : sortingKeysAndOrders) {
-    allKeys.emplace_back(fmt::format(
-        "{} {}", keyAndOrder.key_, keyAndOrder.sortOrder_.toString()));
+    allKeys.emplace_back(
+        fmt::format(
+            "{} {}", keyAndOrder.key_, keyAndOrder.sortOrder_.toString()));
   }
 
   // Streaming window from values.
@@ -793,7 +794,8 @@ bool WindowFuzzer::verifyWindow(
                     expectedResult.value(),
                     plan->outputType(),
                     {resultOrError.result}),
-                "Velox and reference DB results don't match");
+                "Velox and reference DB results don't match, plan: {}",
+                plan->toString(true, true));
             LOG(INFO) << "Verified results against reference DB";
           }
         }
diff --git a/velox/exec/fuzzer/WindowFuzzerRunner.h b/velox/exec/fuzzer/WindowFuzzerRunner.h
index d24536ff8175..e71ae53161c2 100644
--- a/velox/exec/fuzzer/WindowFuzzerRunner.h
+++ b/velox/exec/fuzzer/WindowFuzzerRunner.h
@@ -71,7 +71,7 @@ class WindowFuzzerRunner {
         filteredWindowSignatures.empty()) {
       LOG(ERROR)
           << "No function left after filtering using 'only' and 'skip' lists.";
-      exit(1);
+      return 1;
     }
 
     facebook::velox::parse::registerTypeResolver();
diff --git a/velox/exec/fuzzer/WriterFuzzer.cpp b/velox/exec/fuzzer/WriterFuzzer.cpp
index 79109f9dfa84..5dcacca9e180 100644
--- a/velox/exec/fuzzer/WriterFuzzer.cpp
+++ b/velox/exec/fuzzer/WriterFuzzer.cpp
@@ -16,6 +16,7 @@
 #include "velox/exec/fuzzer/WriterFuzzer.h"
 
 #include <boost/random/uniform_int_distribution.hpp>
+#include <fmt/ranges.h>
 
 #include <re2/re2.h>
 #include <algorithm>
@@ -149,8 +150,7 @@ class WriterFuzzer {
       const std::shared_ptr<TempDirectoryPath>& outputDirectoryPath);
 
   // Generates table column handles based on table column properties
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-  getTableColumnHandles(
+  connector::ColumnHandleMap getTableColumnHandles(
       const std::vector<std::string>& names,
       const std::vector<TypePtr>& types,
       int32_t partitionOffset,
@@ -248,7 +248,7 @@ class WriterFuzzer {
   };
 
   // Supported partition key column types
-  // According to VectorHasher::typeKindSupportsValueIds and
+  // According to VectorHasher::typeSupportsValueIds 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(),
@@ -256,7 +256,8 @@ class WriterFuzzer {
       SMALLINT(),
       INTEGER(),
       BIGINT(),
-      VARCHAR()};
+      VARCHAR(),
+      TIMESTAMP()};
 
   const std::shared_ptr<FaultyFileSystem> faultyFs_ =
       std::dynamic_pointer_cast<FaultyFileSystem>(
@@ -364,11 +365,12 @@ void WriterFuzzer::go() {
           sortColumnOffset -= offset;
           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_))));
+            sortBy.push_back(
+                std::make_shared<const HiveSortingColumn>(
+                    sortByColumn,
+                    kSortOrderTypes_.at(
+                        boost::random::uniform_int_distribution<uint32_t>(
+                            0, 1)(rng_))));
           }
         }
       }
@@ -483,8 +485,9 @@ std::vector<RowVectorPtr> WriterFuzzer::generateInputData(
             partitionValues.at(j - partitionOffset), size));
       }
     }
-    input.push_back(std::make_shared<RowVector>(
-        pool_.get(), inputType, nullptr, size, std::move(children)));
+    input.push_back(
+        std::make_shared<RowVector>(
+            pool_.get(), inputType, nullptr, size, std::move(children)));
   }
 
   return input;
@@ -635,14 +638,12 @@ void WriterFuzzer::verifyWriter(
   LOG(INFO) << "Verified results against reference DB";
 }
 
-std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-WriterFuzzer::getTableColumnHandles(
+connector::ColumnHandleMap 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;
+  connector::ColumnHandleMap columnHandle;
   for (int i = 0; i < names.size(); ++i) {
     HiveColumnHandle::ColumnType columnType;
     if (i < partitionOffset) {
@@ -706,8 +707,9 @@ RowVectorPtr WriterFuzzer::veloxToPrestoResult(const RowVectorPtr& result) {
 std::string WriterFuzzer::getReferenceOutputDirectoryPath(int32_t layers) {
   auto filePath =
       referenceQueryRunner_->execute("SELECT \"$path\" FROM tmp_write");
+  auto stringView = extractSingleValue<StringView>(filePath);
   auto tableDirectoryPath =
-      fs::path(extractSingleValue<StringView>(filePath)).parent_path();
+      fs::path(std::string_view(stringView)).parent_path();
   while (layers-- > 0) {
     tableDirectoryPath = tableDirectoryPath.parent_path();
   }
@@ -745,11 +747,30 @@ void WriterFuzzer::comparePartitionAndBucket(
     // 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");
+        "Velox and reference DB output partitions don't match. Velox: [{}], Presto: [{}]",
+        fmt::join(partitionNames, ", "),
+        fmt::join(referencePartitionNames, ", "));
+  } else if (partitionNameAndFileCount != referencedPartitionNameAndFileCount) {
+    std::vector<std::string> partitionNameAndFileCountStrs;
+    std::vector<std::string> referencedPartitionNameAndFileCountStrs;
+
+    partitionNameAndFileCountStrs.reserve(partitionNameAndFileCount.size());
+    referencedPartitionNameAndFileCountStrs.reserve(
+        referencedPartitionNameAndFileCount.size());
+
+    for (const auto& p : partitionNameAndFileCount) {
+      partitionNameAndFileCountStrs.push_back(
+          fmt::format("'{}': {}", p.first, p.second));
+    }
+    for (const auto& p : referencedPartitionNameAndFileCount) {
+      referencedPartitionNameAndFileCountStrs.push_back(
+          fmt::format("'{}': {}", p.first, p.second));
+    }
+
+    VELOX_FAIL(
+        "Velox and reference DB output partition and bucket don't match. Velox: {{{}}}, Presto: {{{}}}",
+        fmt::join(partitionNameAndFileCountStrs, ", "),
+        fmt::join(referencedPartitionNameAndFileCountStrs, ", "));
   }
 }
 
diff --git a/velox/exec/fuzzer/WriterFuzzerRunner.h b/velox/exec/fuzzer/WriterFuzzerRunner.h
index 527b11bbef1f..fbe76685c898 100644
--- a/velox/exec/fuzzer/WriterFuzzerRunner.h
+++ b/velox/exec/fuzzer/WriterFuzzerRunner.h
@@ -77,15 +77,11 @@ class WriterFuzzerRunner {
       std::unique_ptr<ReferenceQueryRunner> referenceQueryRunner) {
     filesystems::registerLocalFileSystem();
     tests::utils::registerFaultyFileSystem();
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
-    auto hiveConnector =
-        connector::getConnectorFactory(
-            connector::hive::HiveConnectorFactory::kHiveConnectorName)
-            ->newConnector(
-                kHiveConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()));
+    connector::hive::HiveConnectorFactory factory;
+    auto hiveConnector = factory.newConnector(
+        kHiveConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
     connector::registerConnector(hiveConnector);
     dwrf::registerDwrfReaderFactory();
     dwrf::registerDwrfWriterFactory();
diff --git a/velox/exec/fuzzer/if/LocalRunnerService.thrift b/velox/exec/fuzzer/if/LocalRunnerService.thrift
new file mode 100644
index 000000000000..5e28b5f01518
--- /dev/null
+++ b/velox/exec/fuzzer/if/LocalRunnerService.thrift
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 defines a Thrift service for executing Velox query plans remotely.
+// Results are returned using Presto's binary serialization format for efficient
+// data transfer.
+
+namespace cpp2 facebook.velox.runner
+
+// Represents a batch of rows using Presto's binary serialization format.
+// The serialized data can be deserialized using PrestoVectorSerde to reconstruct
+// the original RowVector.
+struct Batch {
+  // Binary serialized RowVector data in Presto format
+  1: binary serializedData;
+  // Column names in the RowVector
+  2: list<string> columnNames;
+  // Column type strings in the RowVector
+  3: list<string> columnTypes;
+}
+
+// Request to execute a serialized Velox query plan.
+struct ExecutePlanRequest {
+  1: string serializedPlan;
+  2: string queryId;
+  3: i32 numWorkers = 4;
+  4: i32 numDrivers = 2;
+}
+
+// Response from executing a query plan.
+struct ExecutePlanResponse {
+  1: list<Batch> results;
+  2: string output;
+  3: bool success;
+  4: optional string errorMessage;
+}
+
+// Service for executing Velox query plans locally.
+// This service enables remote execution of serialized query plans with
+// configurable parallelism, returning results in a structured format.
+service LocalRunnerService {
+  // Inputs a Thrift request and executes a serialized Velox query plan and
+  // returns the results as a Thrift response.
+  ExecutePlanResponse execute(1: ExecutePlanRequest request);
+}
diff --git a/velox/exec/fuzzer/tests/CMakeLists.txt b/velox/exec/fuzzer/tests/CMakeLists.txt
index 3179fad5cfc3..a77e6691a5cc 100644
--- a/velox/exec/fuzzer/tests/CMakeLists.txt
+++ b/velox/exec/fuzzer/tests/CMakeLists.txt
@@ -15,5 +15,25 @@
 add_executable(presto_sql_test PrestoSqlTest.cpp)
 add_test(presto_sql_test presto_sql_test)
 
-target_link_libraries(
-  presto_sql_test velox_fuzzer_util velox_presto_types)
+target_link_libraries(presto_sql_test velox_fuzzer_util velox_presto_types)
+
+# LocalRunnerService Test (requires FBThrift support)
+if(VELOX_ENABLE_REMOTE_FUNCTIONS)
+  add_executable(local_runner_service_test LocalRunnerServiceTest.cpp)
+  add_test(local_runner_service_test local_runner_service_test)
+
+  target_link_libraries(
+    local_runner_service_test
+    velox_local_runner_service_lib
+    local_runner_service_thrift
+    velox_core
+    velox_type
+    velox_functions_prestosql
+    velox_functions_test_lib
+    velox_vector_test_lib
+    velox_common_base
+    Folly::folly
+    gtest
+    gtest_main
+  )
+endif()
diff --git a/velox/exec/fuzzer/tests/LocalRunnerServiceTest.cpp b/velox/exec/fuzzer/tests/LocalRunnerServiceTest.cpp
new file mode 100644
index 000000000000..97ec69308775
--- /dev/null
+++ b/velox/exec/fuzzer/tests/LocalRunnerServiceTest.cpp
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <folly/json.h>
+#include <gtest/gtest.h>
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/fuzzer/LocalRunnerService.h"
+#include "velox/exec/fuzzer/if/gen-cpp2/LocalRunnerService.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/type/Type.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::runner;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::fuzzer::test {
+class LocalRunnerServiceTest : public functions::test::FunctionBaseTest {
+ protected:
+  void SetUp() override {
+    Type::registerSerDe();
+    core::PlanNode::registerSerDe();
+    core::ITypedExpr::registerSerDe();
+    functions::prestosql::registerAllScalarFunctions();
+    functions::prestosql::registerInternalFunctions();
+
+    createTestData();
+  }
+
+  void createTestData() {
+    // Create test vectors for different data types
+    auto rowType = ROW({
+        {"bool_col", BOOLEAN()},
+        {"int_col", INTEGER()},
+        {"bigint_col", BIGINT()},
+        {"double_col", DOUBLE()},
+        {"varchar_col", VARCHAR()},
+        {"timestamp_col", TIMESTAMP()},
+        {"array_col", ARRAY(ARRAY(INTEGER()))},
+    });
+
+    testRowVector_ = makeRowVector(
+        {"bool_col",
+         "int_col",
+         "bigint_col",
+         "double_col",
+         "varchar_col",
+         "timestamp_col",
+         "array_col"},
+        {
+            makeFlatVector<bool>(
+                10,
+                [](auto row) { return row % 2 == 0; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<int32_t>(
+                10,
+                [](auto row) { return row; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<int64_t>(
+                10,
+                [](auto row) { return row; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<double>(
+                10,
+                [](auto row) { return row * 1.1; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<std::string>(
+                10,
+                [](auto row) { return fmt::format("str_{}", row); },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<facebook::velox::Timestamp>(
+                10,
+                [](auto row) { return facebook::velox::Timestamp(row, 0); },
+                [](auto row) { return row % 3 == 0; }),
+            makeNestedArrayVectorFromJson<int64_t>(
+                {"[[1, 2]]",
+                 "[[3]]",
+                 "[[4]]",
+                 "[[5, 6]]",
+                 "[[7]]",
+                 "[[8]]",
+                 "[[9]]",
+                 "[[10]]",
+                 "[[11]]",
+                 "[[12]]"}),
+        });
+
+    testRowVectorWrapped_ = makeRowVector(
+        {"bool_col",
+         "int_col",
+         "bigint_col",
+         "double_col",
+         "varchar_col",
+         "timestamp_col",
+         "array_col"},
+        {
+            makeFlatVector<bool>(
+                5,
+                [](auto row) { return row % 2 == 0; },
+                [](auto row) { return row % 3 == 0; }),
+            wrapInDictionary(
+                makeIndices(5, [](auto row) { return (row * 17 + 3) % 10; }),
+                5,
+                makeFlatVector<int32_t>(
+                    10,
+                    [](auto row) { return row; },
+                    [](auto row) { return row % 3 == 0; })),
+            BaseVector::wrapInConstant(
+                5,
+                0,
+                makeFlatVector<int64_t>(
+                    10,
+                    [](auto row) { return row; },
+                    [](auto row) { return row % 3 == 0; })),
+            makeFlatVector<double>(
+                5,
+                [](auto row) { return row * 1.1; },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<std::string>(
+                5,
+                [](auto row) { return fmt::format("str_{}", row); },
+                [](auto row) { return row % 3 == 0; }),
+            makeFlatVector<facebook::velox::Timestamp>(
+                5,
+                [](auto row) { return facebook::velox::Timestamp(row, 0); },
+                [](auto row) { return row % 3 == 0; }),
+            makeNestedArrayVectorFromJson<int64_t>(
+                {"[[1, 2]]",
+                 "[[3]]",
+                 "[[4]]",
+                 "[[5, 6]]",
+                 "[[7]]",
+                 "[[8]]",
+                 "[[9]]",
+                 "[[10]]",
+                 "[[11]]",
+                 "[[12]]"}),
+        });
+  }
+
+  RowVectorPtr testRowVector_;
+  RowVectorPtr testRowVectorWrapped_;
+};
+
+TEST_F(LocalRunnerServiceTest, ConvertToBatchesRoundTrip) {
+  auto result = facebook::velox::runner::convertToBatches(
+      {testRowVector_}, rootPool_.get());
+
+  ASSERT_EQ(result.size(), 1);
+  ASSERT_EQ(result[0].columnNames()->size(), 7);
+  ASSERT_EQ(result[0].columnTypes()->size(), 7);
+
+  // Verify serializedData is present
+  ASSERT_GT(result[0].serializedData()->size(), 0);
+
+  // Deserialize and verify
+  auto leafPool = rootPool_->addLeafChild("deserialize");
+  auto serde = std::make_unique<
+      facebook::velox::serializer::presto::PrestoVectorSerde>();
+  facebook::velox::serializer::presto::PrestoVectorSerde::PrestoOptions options;
+
+  const auto& serializedData = *result[0].serializedData();
+  ByteRange byteRange{
+      reinterpret_cast<uint8_t*>(const_cast<char*>(serializedData.data())),
+      static_cast<int32_t>(serializedData.length()),
+      0};
+  auto byteStream = std::make_unique<facebook::velox::BufferInputStream>(
+      std::vector<ByteRange>{{byteRange}});
+
+  RowVectorPtr deserialized;
+  serde->deserialize(
+      byteStream.get(),
+      leafPool.get(),
+      asRowType(testRowVector_->type()),
+      &deserialized,
+      0,
+      &options);
+
+  ASSERT_NE(deserialized, nullptr);
+  ASSERT_EQ(deserialized->size(), testRowVector_->size());
+  ASSERT_EQ(deserialized->childrenSize(), testRowVector_->childrenSize());
+
+  assertEqualVectors(deserialized, testRowVector_);
+}
+
+TEST_F(LocalRunnerServiceTest, ServiceHandlerMockRequestIntegration) {
+  LocalRunnerServiceHandler handler;
+
+  auto request = std::make_unique<ExecutePlanRequest>();
+  // Serialized plan for the following:
+  // expressions: (p0:DOUBLE, plus(null,0.1646418017335236))
+  request->serializedPlan() =
+      R"({"names":["p0","p1"],"id":"project","name":"ProjectNode","sources":[{"name":"ProjectNode","id":"transform","projections":[{"name":"FieldAccessTypedExpr","type":{"name":"Type","type":"BIGINT"},"inputs":[{"name":"InputTypedExpr","type":{"type":"ROW","name":"Type","names":["row_number"],"cTypes":[{"name":"Type","type":"BIGINT"}]}}],"fieldName":"row_number"}],"names":["row_number"],"sources":[{"name":"ValuesNode","id":"efb6650a_8541_4214_82dd_9792a4965380","data":"AAAAAF4AAAB7ImNUeXBlcyI6W3sidHlwZSI6IkJJR0lOVCIsIm5hbWUiOiJUeXBlIn1dLCJuYW1lcyI6WyJyb3dfbnVtYmVyIl0sInR5cGUiOiJST1ciLCJuYW1lIjoiVHlwZSJ9AQAAAAABAAAAAQAAAAAfAAAAeyJ0eXBlIjoiQklHSU5UIiwibmFtZSI6IlR5cGUifQEAAAAAAQgAAAAAAAAAAAAAAA==","parallelizable":false,"repeatTimes":1}]}],"projections":[{"name":"CallTypedExpr","type":{"name":"Type","type":"DOUBLE"},"functionName":"plus","inputs":[{"name":"ConstantTypedExpr","type":{"name":"Type","type":"DOUBLE"},"valueVector":"AQAAAB8AAAB7InR5cGUiOiJET1VCTEUiLCJuYW1lIjoiVHlwZSJ9AQAAAAE="},{"name":"ConstantTypedExpr","type":{"name":"Type","type":"DOUBLE"},"valueVector":"AQAAAB8AAAB7InR5cGUiOiJET1VCTEUiLCJuYW1lIjoiVHlwZSJ9AQAAAAABAAAAifsSxT8="}]},{"name":"FieldAccessTypedExpr","type":{"name":"Type","type":"BIGINT"},"fieldName":"row_number"}]})";
+  request->queryId() = "query1";
+
+  ExecutePlanResponse response;
+  handler.execute(response, std::move(request));
+
+  EXPECT_TRUE(*response.success());
+  EXPECT_EQ(response.results()->size(), 1);
+
+  const auto& batch = (*response.results()).front();
+  EXPECT_EQ(batch.columnNames()->size(), 2);
+  EXPECT_EQ((*batch.columnNames())[0], "p0");
+  EXPECT_EQ(batch.columnTypes()->size(), 2);
+  EXPECT_EQ((*batch.columnTypes())[0], "DOUBLE");
+  EXPECT_GT(batch.serializedData()->size(), 0);
+}
+
+TEST_F(LocalRunnerServiceTest, ServiceHandlerMockRequestIntegrationFailure) {
+  LocalRunnerServiceHandler handler;
+
+  auto request = std::make_unique<ExecutePlanRequest>();
+  // Serialized plan for the following:
+  // expressions: (p0:TINYINT, divide(89,"c0")
+  // Will encounter divide by zero error.
+  request->serializedPlan() =
+      R"({"projections":[{"inputs":[{"valueVector":"AQAAACAAAAB7InR5cGUiOiJUSU5ZSU5UIiwibmFtZSI6IlR5cGUifQEAAAAAAVk=","type":{"type":"TINYINT","name":"Type"},"name":"ConstantTypedExpr"},{"fieldName":"c0","type":{"type":"TINYINT","name":"Type"},"name":"FieldAccessTypedExpr"}],"functionName":"divide","type":{"type":"TINYINT","name":"Type"},"name":"CallTypedExpr"},{"fieldName":"row_number","type":{"type":"BIGINT","name":"Type"},"name":"FieldAccessTypedExpr"}],"sources":[{"projections":[{"inputs":[{"type":{"cTypes":[{"type":"TINYINT","name":"Type"},{"type":"BIGINT","name":"Type"}],"names":["c0","row_number"],"type":"ROW","name":"Type"},"name":"InputTypedExpr"}],"fieldName":"c0","type":{"type":"TINYINT","name":"Type"},"name":"FieldAccessTypedExpr"},{"inputs":[{"type":{"cTypes":[{"type":"TINYINT","name":"Type"},{"type":"BIGINT","name":"Type"}],"names":["c0","row_number"],"type":"ROW","name":"Type"},"name":"InputTypedExpr"}],"fieldName":"row_number","type":{"type":"BIGINT","name":"Type"},"name":"FieldAccessTypedExpr"}],"sources":[{"parallelizable":false,"repeatTimes":1,"data":"AAAAAIQAAAB7ImNUeXBlcyI6W3sidHlwZSI6IlRJTllJTlQiLCJuYW1lIjoiVHlwZSJ9LHsidHlwZSI6IkJJR0lOVCIsIm5hbWUiOiJUeXBlIn1dLCJuYW1lcyI6WyJjMCIsInJvd19udW1iZXIiXSwidHlwZSI6IlJPVyIsIm5hbWUiOiJUeXBlIn0KAAAAAAIAAAABAgAAACAAAAB7InR5cGUiOiJUSU5ZSU5UIiwibmFtZSI6IlR5cGUifQoAAAAAKAAAAAMAAAACAAAABgAAAAAAAAABAAAACAAAAAUAAAAAAAAACAAAAAUAAAACAAAAIAAAAHsidHlwZSI6IlRJTllJTlQiLCJuYW1lIjoiVHlwZSJ9CgAAAAECAAAA9/8oAAAACQAAAAQAAAAJAAAAAAAAAAYAAAAHAAAABAAAAAYAAAAAAAAAAAAAAAIAAAAgAAAAeyJ0eXBlIjoiVElOWUlOVCIsIm5hbWUiOiJUeXBlIn0KAAAAAQIAAAD7oigAAAAJAAAAAQAAAAkAAAAHAAAAAAAAAAUAAAAEAAAAAwAAAAEAAAAAAAAAAAAAACAAAAB7InR5cGUiOiJUSU5ZSU5UIiwibmFtZSI6IlR5cGUifQoAAAAAAQoAAABTOkYvJBw5ZUAAAQAAAAAfAAAAeyJ0eXBlIjoiQklHSU5UIiwibmFtZSI6IlR5cGUifQoAAAAAAVAAAAAAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAA==","id":"d69f11dc_1f0e_40ae_8c5d_2cde4b784a12","name":"ValuesNode"}],"names":["c0","row_number"],"id":"transform","name":"ProjectNode"}],"names":["p0","p1"],"id":"project","name":"ProjectNode"})";
+  request->queryId() = "query1";
+
+  ExecutePlanResponse response;
+  handler.execute(response, std::move(request));
+
+  ASSERT_TRUE(response.errorMessage().has_value());
+  auto errorMsg = response.errorMessage().value();
+  EXPECT_NE(errorMsg.find("Error Source: USER"), std::string::npos);
+  EXPECT_NE(errorMsg.find("Error Code: ARITHMETIC_ERROR"), std::string::npos);
+  EXPECT_NE(errorMsg.find("Reason: division by zero"), std::string::npos);
+
+  EXPECT_FALSE(*response.success());
+  EXPECT_EQ(response.results()->size(), 0);
+}
+
+} // namespace facebook::velox::fuzzer::test
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  folly::Init init(&argc, &argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/velox/exec/fuzzer/tests/PrestoSqlTest.cpp b/velox/exec/fuzzer/tests/PrestoSqlTest.cpp
index 42dd2f8e3ea5..1461d5f16cdd 100644
--- a/velox/exec/fuzzer/tests/PrestoSqlTest.cpp
+++ b/velox/exec/fuzzer/tests/PrestoSqlTest.cpp
@@ -19,6 +19,10 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/fuzzer/PrestoSql.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/functions/prestosql/types/TDigestType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
 namespace facebook::velox::exec::test {
@@ -34,7 +38,13 @@ TEST(PrestoSqlTest, toTypeSql) {
   EXPECT_EQ(toTypeSql(DOUBLE()), "DOUBLE");
   EXPECT_EQ(toTypeSql(VARCHAR()), "VARCHAR");
   EXPECT_EQ(toTypeSql(VARBINARY()), "VARBINARY");
+  EXPECT_EQ(toTypeSql(TDIGEST(DOUBLE())), "TDIGEST(DOUBLE)");
   EXPECT_EQ(toTypeSql(TIMESTAMP()), "TIMESTAMP");
+  EXPECT_EQ(toTypeSql(QDIGEST(DOUBLE())), "QDIGEST(DOUBLE)");
+  EXPECT_EQ(toTypeSql(QDIGEST(BIGINT())), "QDIGEST(BIGINT)");
+  EXPECT_EQ(toTypeSql(QDIGEST(REAL())), "QDIGEST(REAL)");
+  EXPECT_EQ(toTypeSql(SETDIGEST()), "SETDIGEST");
+  EXPECT_EQ(toTypeSql(KHYPERLOGLOG()), "KHYPERLOGLOG");
   EXPECT_EQ(toTypeSql(DATE()), "DATE");
   EXPECT_EQ(toTypeSql(TIMESTAMP_WITH_TIME_ZONE()), "TIMESTAMP WITH TIME ZONE");
   EXPECT_EQ(toTypeSql(ARRAY(BOOLEAN())), "ARRAY(BOOLEAN)");
@@ -58,9 +68,8 @@ void toUnaryOperator(
     const std::string& expectedSql) {
   auto expression = std::make_shared<core::CallTypedExpr>(
       INTEGER(),
-      std::vector<core::TypedExprPtr>{
-          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0")},
-      operatorName);
+      operatorName,
+      std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"));
   EXPECT_EQ(toCallSql(expression), expectedSql);
 }
 
@@ -69,10 +78,9 @@ void toBinaryOperator(
     const std::string& expectedSql) {
   auto expression = std::make_shared<core::CallTypedExpr>(
       INTEGER(),
-      std::vector<core::TypedExprPtr>{
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1")},
-      operatorName);
+      operatorName,
+      std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+      std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"));
   EXPECT_EQ(toCallSql(expression), expectedSql);
 }
 
@@ -81,9 +89,8 @@ void toIsNullOrIsNotNull(
     const std::string& expectedSql) {
   auto expression = std::make_shared<core::CallTypedExpr>(
       BOOLEAN(),
-      std::vector<core::TypedExprPtr>{
-          std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0")},
-      operatorName);
+      operatorName,
+      std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"));
   EXPECT_EQ(toCallSql(expression), expectedSql);
 }
 
@@ -92,12 +99,12 @@ TEST(PrestoSqlTest, toCallSql) {
   toUnaryOperator("negate", "(- c0)");
   toUnaryOperator("not", "(not c0)");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "not",
               std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
-              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1")},
-          "not")),
+              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1"))),
       "Expected one argument to a unary operator");
 
   // Binary operators
@@ -114,271 +121,264 @@ TEST(PrestoSqlTest, toCallSql) {
   toBinaryOperator("gte", "(c0 >= c1)");
   toBinaryOperator("distinct_from", "(c0 is distinct from c1)");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "plus",
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3")},
-          "plus")),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"))),
       "Expected two arguments to a binary operator");
 
   // Functions IS NULL and NOT NULL
   toIsNullOrIsNotNull("is_null", "(c0 is null)");
   toIsNullOrIsNotNull("not_null", "(c0 is not null)");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "is_null",
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1")},
-          "is_null")),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
       "Expected one argument to function 'is_null' or 'not_null'");
 
   // Function IN
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "in",
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b")},
-          "in")),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"))),
       "'a' in ('b')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "in",
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d")},
-          "in")),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
       "'a' in ('b', 'c', 'd')");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a")},
-          "in")),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "in",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
       "Expected at least two arguments to function 'in'");
 
   // Function LIKE
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "like",
               std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a")},
-          "like")),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
       "(c0 like 'a')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "like",
               std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b")},
-          "like")),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"))),
       "(c0 like 'a' escape 'b')");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a")},
-          "like")),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "like",
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"))),
       "Expected at least two arguments to function 'like'");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "like",
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d")},
-          "like")),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
       "Expected at most three arguments to function 'like'");
 
   // Functions OR and AND
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "or",
               std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false)},
-          "or")),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
       "(BOOLEAN 'true' or BOOLEAN 'false')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "and",
               std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false)},
-          "and")),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
       "(BOOLEAN 'true' and BOOLEAN 'false')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "or",
               std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
               std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false),
               std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false)},
-          "or")),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
       "(BOOLEAN 'true' or BOOLEAN 'false' or BOOLEAN 'true' or BOOLEAN 'false')");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "and",
               std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
               std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false),
               std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), true),
-              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false)},
-          "and")),
+              std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), false))),
       "(BOOLEAN 'true' and BOOLEAN 'false' and BOOLEAN 'true' and BOOLEAN 'false')");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(), std::vector<core::TypedExprPtr>{}, "or")),
+      toCallSql(std::make_shared<core::CallTypedExpr>(BOOLEAN(), "or")),
       "Expected at least two arguments to function 'or' or 'and'");
 
   // Functions ARRAY_CONSTRUCTOR and ROW_CONSTRUCTOR
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          ARRAY(INTEGER()),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              ARRAY(INTEGER()),
+              "array_constructor",
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c")},
-          "array_constructor")),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"))),
       "ARRAY['a', 'b', 'c']");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          ARRAY(INTEGER()),
-          std::vector<core::TypedExprPtr>{},
-          "array_constructor")),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              ARRAY(INTEGER()), "array_constructor")),
       "ARRAY[]");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "row_constructor",
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "a"),
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "b"),
               std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "c"),
-              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d")},
-          "row_constructor")),
+              std::make_shared<core::ConstantTypedExpr>(VARCHAR(), "d"))),
       "row('a', 'b', 'c', 'd')");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(), std::vector<core::TypedExprPtr>{}, "row_constructor")),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(BOOLEAN(), "row_constructor")),
       "Expected at least one argument to function 'row_constructor'");
 
   // Function BETWEEN
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "between",
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2")},
-          "between")),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c2"))),
       "(c0 between c1 and c2)");
   // Edge case check for ambiguous parantheses processing, query will fail
   // without the parantheses wrapping the left-hand side.
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              BOOLEAN(),
+              "lt",
               std::make_shared<core::CallTypedExpr>(
                   BOOLEAN(),
-                  std::vector<core::TypedExprPtr>{
-                      std::make_shared<core::FieldAccessTypedExpr>(
-                          INTEGER(), "c0"),
-                      std::make_shared<core::FieldAccessTypedExpr>(
-                          INTEGER(), "c0"),
-                      std::make_shared<core::ConstantTypedExpr>(
-                          INTEGER(), variant::null(TypeKind::INTEGER))},
-                  "between"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0")},
-          "lt")),
+                  "between",
+                  std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+                  std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
+                  std::make_shared<core::ConstantTypedExpr>(
+                      INTEGER(), variant::null(TypeKind::INTEGER))),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
       "((c0 between c0 and cast(null as INTEGER)) < c0)");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          BOOLEAN(), std::vector<core::TypedExprPtr>{}, "between")),
+      toCallSql(std::make_shared<core::CallTypedExpr>(BOOLEAN(), "between")),
       "Expected three arguments to function 'between'");
 
   // Function SUBSCRIPT, builds '[]' SQL
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "subscript",
               std::make_shared<core::FieldAccessTypedExpr>(
                   ARRAY(INTEGER()), "array"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0")},
-          "subscript")),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
       "array[c0]");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "subscript",
               std::make_shared<core::FieldAccessTypedExpr>(
                   ARRAY(INTEGER()), "array"),
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1")},
-          "subscript")),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
       "Expected two arguments to function 'subscript'");
 
   // Function SWITCH, builds 'CASE WHEN ... THEN ... ELSE ... END' SQL
   // SWITCH cases with no ELSE.
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "switch",
               std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
-              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1")},
-          "switch")),
+              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1"))),
       "case when c0 then c1 end");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "switch",
               std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
               std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c2"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3")},
-          "switch")),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"))),
       "case when c0 then c1 when c2 then c3 end");
   // SWITCH case with ELSE.
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "switch",
               std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c0"),
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"),
               std::make_shared<core::FieldAccessTypedExpr>(BOOLEAN(), "c2"),
               std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c3"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c4")},
-          "switch")),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c4"))),
       "case when c0 then c1 when c2 then c3 else c4 end");
   VELOX_ASSERT_THROW(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0")},
-          "switch")),
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "switch",
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"))),
       "Expected at least two arguments to function 'switch'");
 
   // Generic functions
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          INTEGER(),
-          std::vector<core::TypedExprPtr>{
+      toCallSql(
+          std::make_shared<core::CallTypedExpr>(
+              INTEGER(),
+              "array_top_n",
               std::make_shared<core::FieldAccessTypedExpr>(
                   ARRAY(INTEGER()), "c0"),
-              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1")},
-          "array_top_n")),
+              std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c1"))),
       "array_top_n(c0, c1)");
   EXPECT_EQ(
-      toCallSql(std::make_shared<core::CallTypedExpr>(
-          REAL(), std::vector<core::TypedExprPtr>{}, "infinity")),
+      toCallSql(std::make_shared<core::CallTypedExpr>(REAL(), "infinity")),
       "infinity()");
 }
 
@@ -405,5 +405,14 @@ TEST(PrestoSqlTest, toCallInputsSql) {
   EXPECT_EQ(sql.str(), "c0.field0");
 }
 
+TEST(PrestoSqlTest, toConstantSql) {
+  EXPECT_EQ(
+      toConstantSql(core::ConstantTypedExpr(INTERVAL_YEAR_MONTH(), 123)),
+      "INTERVAL '123' YEAR TO MONTH");
+  EXPECT_EQ(
+      toConstantSql(core::ConstantTypedExpr(INTERVAL_DAY_TIME(), int64_t(123))),
+      "INTERVAL '123' DAY TO SECOND");
+}
+
 } // namespace
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/prefixsort/CMakeLists.txt b/velox/exec/prefixsort/CMakeLists.txt
index aac7db501ecd..ccaca96a1c46 100644
--- a/velox/exec/prefixsort/CMakeLists.txt
+++ b/velox/exec/prefixsort/CMakeLists.txt
@@ -21,3 +21,5 @@ endif()
 if(${VELOX_ENABLE_BENCHMARKS})
   add_subdirectory(benchmarks)
 endif()
+
+velox_install_library_headers()
diff --git a/velox/exec/prefixsort/PrefixSortAlgorithm.h b/velox/exec/prefixsort/PrefixSortAlgorithm.h
index 385a449c3509..7930b080e0a7 100644
--- a/velox/exec/prefixsort/PrefixSortAlgorithm.h
+++ b/velox/exec/prefixsort/PrefixSortAlgorithm.h
@@ -96,28 +96,12 @@ class PrefixSortIterator {
     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_;
+  FOLLY_ALWAYS_INLINE auto operator<=>(const PrefixSortIterator& other) const {
+    return prefix_ <=> other.prefix_;
   }
 
  private:
diff --git a/velox/exec/prefixsort/PrefixSortEncoder.h b/velox/exec/prefixsort/PrefixSortEncoder.h
index 945b1de5e160..87756792a726 100644
--- a/velox/exec/prefixsort/PrefixSortEncoder.h
+++ b/velox/exec/prefixsort/PrefixSortEncoder.h
@@ -28,7 +28,7 @@ namespace facebook::velox::exec::prefixsort {
 class PrefixSortEncoder {
  public:
   PrefixSortEncoder(bool ascending, bool nullsFirst)
-      : ascending_(ascending), nullsFirst_(nullsFirst){};
+      : ascending_(ascending), nullsFirst_(nullsFirst) {}
 
   /// Encode native primitive types(such as uint64_t, int64_t, uint32_t,
   /// int32_t, uint16_t, int16_t, float, double, Timestamp).
diff --git a/velox/exec/prefixsort/benchmarks/CMakeLists.txt b/velox/exec/prefixsort/benchmarks/CMakeLists.txt
index 77a62b5c0481..5557dca1f5c4 100644
--- a/velox/exec/prefixsort/benchmarks/CMakeLists.txt
+++ b/velox/exec/prefixsort/benchmarks/CMakeLists.txt
@@ -11,8 +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_executable(velox_prefix_sort_algorithm_benchmark
-               PrefixSortAlgorithmBenchmark.cpp)
+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::follybenchmark)
+  velox_prefix_sort_algorithm_benchmark
+  velox_exec_prefixsort_test_lib
+  velox_vector_test_lib
+  Folly::follybenchmark
+)
diff --git a/velox/exec/prefixsort/tests/CMakeLists.txt b/velox/exec/prefixsort/tests/CMakeLists.txt
index 85e0748d9dea..99f5d91d2c81 100644
--- a/velox/exec/prefixsort/tests/CMakeLists.txt
+++ b/velox/exec/prefixsort/tests/CMakeLists.txt
@@ -13,16 +13,19 @@
 # limitations under the License.
 add_subdirectory(utils)
 
-add_executable(velox_exec_prefixsort_test PrefixSortAlgorithmTest.cpp
-                                          PrefixEncoderTest.cpp)
+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})
+  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)
+  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
index 398da750b045..ab88faa09cb2 100644
--- a/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp
+++ b/velox/exec/prefixsort/tests/PrefixEncoderTest.cpp
@@ -270,8 +270,7 @@ class PrefixEncoderTest : public testing::Test,
         const auto rightValue = rightVector->isNullAt(i)
             ? std::nullopt
             : std::optional<ValueDataType>(rightVector->valueAt(i));
-        if constexpr (
-            Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+        if constexpr (is_string_kind(Kind)) {
           encoder.encode(leftValue, leftEncoded, 17, true);
           encoder.encode(rightValue, rightEncoded, 17, true);
         } else {
diff --git a/velox/exec/prefixsort/tests/utils/CMakeLists.txt b/velox/exec/prefixsort/tests/utils/CMakeLists.txt
index 813bd5696e7a..c4691246a33f 100644
--- a/velox/exec/prefixsort/tests/utils/CMakeLists.txt
+++ b/velox/exec/prefixsort/tests/utils/CMakeLists.txt
@@ -14,5 +14,4 @@
 
 add_library(velox_exec_prefixsort_test_lib EncoderTestUtils.cpp)
 
-target_link_libraries(
-  velox_exec_prefixsort_test_lib velox_vector_test_lib)
+target_link_libraries(velox_exec_prefixsort_test_lib velox_vector_test_lib)
diff --git a/velox/exec/tests/AggregateCompanionAdapterTest.cpp b/velox/exec/tests/AggregateCompanionAdapterTest.cpp
index 61d27961ca86..e050dff7fdbb 100644
--- a/velox/exec/tests/AggregateCompanionAdapterTest.cpp
+++ b/velox/exec/tests/AggregateCompanionAdapterTest.cpp
@@ -77,8 +77,8 @@ class AggregateCompanionRegistryTest : public testing::Test {
       const std::vector<TypePtr>& argTypes,
       const TypePtr& intermediateType,
       const TypePtr& resultType) {
-    const auto& [resolvedResult, resolveIntermediate] =
-        resolveAggregateFunction(name, argTypes);
+    const auto& resolvedResult = resolveResultType(name, argTypes);
+    const auto& resolveIntermediate = resolveIntermediateType(name, argTypes);
     checkEqual(resolvedResult, resultType);
     checkEqual(resolveIntermediate, intermediateType);
   }
@@ -414,22 +414,27 @@ TEST_F(
 TEST_F(
     AggregateCompanionRegistryTest,
     resultTypeNotResolvableFromIntermediateType) {
-  // We only register companion functions for original signatures whose result
-  // type can be resolved from its intermediate type.
+  // We only register partial, merge and merge_extract companion functions for
+  // original signatures whose result type cannot be resolved from its
+  // intermediate type.
   std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures{
       AggregateFunctionSignatureBuilder()
-          .typeVariable("T")
-          .returnType("array(T)")
-          .intermediateType("varbinary")
-          .argumentType("T")
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .integerVariable("i_precision", "min(38, a_precision + 10)")
+          .integerVariable("r_precision", "min(38, a_precision + 4)")
+          .integerVariable("r_scale", "min(38, a_scale + 4)")
+          .returnType("DECIMAL(r_precision, r_scale)")
+          .intermediateType("ROW(DECIMAL(i_precision, a_scale), bigint)")
+          .argumentType("DECIMAL(a_precision, a_scale)")
           .build()};
   registerDummyAggregateFunction("aggregateFunc6", signatures);
 
-  checkAggregateSignaturesCount("aggregateFunc6_partial", 0);
+  checkAggregateSignaturesCount("aggregateFunc6_partial", 1);
 
-  checkAggregateSignaturesCount("aggregateFunc6_merge", 0);
+  checkAggregateSignaturesCount("aggregateFunc6_merge", 1);
 
-  checkAggregateSignaturesCount("aggregateFunc6_merge_extract", 0);
+  checkAggregateSignaturesCount("aggregateFunc6_merge_extract", 1);
 
   checkScalarSignaturesCount("aggregateFunc6_extract", 0);
 }
diff --git a/velox/exec/tests/AggregateFunctionRegistryTest.cpp b/velox/exec/tests/AggregateFunctionRegistryTest.cpp
index 223631579182..72b75c538388 100644
--- a/velox/exec/tests/AggregateFunctionRegistryTest.cpp
+++ b/velox/exec/tests/AggregateFunctionRegistryTest.cpp
@@ -15,77 +15,131 @@
  */
 
 #include "velox/exec/AggregateFunctionRegistry.h"
+
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/AggregateUtil.h"
 #include "velox/exec/WindowFunction.h"
 #include "velox/exec/tests/AggregateRegistryTestUtil.h"
-#include "velox/functions/Registerer.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::exec::test {
 
-class FunctionRegistryTest : public testing::Test {
- public:
-  FunctionRegistryTest() {
+class AggregateFunctionRegistryTest : public testing::Test {
+ protected:
+  AggregateFunctionRegistryTest() {
     registerAggregateFunc("aggregate_func");
     registerAggregateFunc("Aggregate_Func_Alias");
   }
 
-  void checkEqual(const TypePtr& actual, const TypePtr& expected) {
-    if (expected) {
-      EXPECT_EQ(*actual, *expected);
-    } else {
-      EXPECT_EQ(actual, nullptr);
+  void testResolve(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedFinalType,
+      const TypePtr& expectedIntermediateType) {
+    {
+      auto finalType = resolveResultType(name, argTypes);
+      auto intermediateType = resolveIntermediateType(name, argTypes);
+      VELOX_EXPECT_EQ_TYPES(finalType, expectedFinalType);
+      VELOX_EXPECT_EQ_TYPES(intermediateType, expectedIntermediateType);
+    }
+
+    {
+      std::vector<TypePtr> coercions;
+      auto finalType =
+          resolveResultTypeWithCoercions(name, argTypes, coercions);
+      VELOX_EXPECT_EQ_TYPES(finalType, expectedFinalType);
+
+      EXPECT_EQ(coercions.size(), argTypes.size());
+      for (const auto& coercion : coercions) {
+        EXPECT_EQ(coercion, nullptr);
+      }
     }
   }
 
-  void testResolveAggregateFunction(
-      const std::string& functionName,
+  void testCoersions(
+      const std::string& name,
       const std::vector<TypePtr>& argTypes,
-      const TypePtr& expectedReturn,
-      const TypePtr& expectedIntermediate) {
-    auto result = resolveAggregateFunction(functionName, argTypes);
-    checkEqual(result.first, expectedReturn);
-    checkEqual(result.second, expectedIntermediate);
+      const TypePtr& expectedFinalType,
+      const std::vector<TypePtr>& expectedCoercions) {
+    VELOX_ASSERT_THROW(
+        resolveResultType(name, argTypes),
+        "Aggregate function signature is not supported");
+
+    std::vector<TypePtr> coercions;
+    auto finalType = resolveResultTypeWithCoercions(name, argTypes, coercions);
+    VELOX_EXPECT_EQ_TYPES(finalType, expectedFinalType);
+
+    EXPECT_EQ(coercions.size(), argTypes.size());
+    for (int i = 0; i < coercions.size(); ++i) {
+      VELOX_EXPECT_EQ_TYPES(coercions[i], expectedCoercions[i]);
+    }
+  }
+
+  void clearRegistry() {
+    aggregateFunctions().withWLock(
+        [](auto& aggregationFunctionMap) { aggregationFunctionMap.clear(); });
   }
 };
 
-TEST_F(FunctionRegistryTest, hasAggregateFunctionSignature) {
-  testResolveAggregateFunction(
+TEST_F(AggregateFunctionRegistryTest, basic) {
+  testResolve(
       "aggregate_func", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func", {DOUBLE(), DOUBLE()}, DOUBLE(), ARRAY(DOUBLE()));
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func",
       {ARRAY(BOOLEAN()), ARRAY(BOOLEAN())},
       ARRAY(BOOLEAN()),
       ARRAY(ARRAY(BOOLEAN())));
-  testResolveAggregateFunction("aggregate_func", {}, DATE(), DATE());
+  testResolve("aggregate_func", {}, DATE(), DATE());
 }
 
-TEST_F(FunctionRegistryTest, hasAggregateFunctionSignatureWrongFunctionName) {
-  testResolveAggregateFunction(
-      "aggregate_func_nonexist", {BIGINT(), BIGINT()}, nullptr, nullptr);
-  testResolveAggregateFunction("aggregate_func_nonexist", {}, nullptr, nullptr);
+TEST_F(AggregateFunctionRegistryTest, wrongFunctionName) {
+  VELOX_ASSERT_THROW(
+      resolveIntermediateType("aggregate_func_nonexist", {BIGINT(), BIGINT()}),
+      "Aggregate function not registered: aggregate_func_nonexist");
+  VELOX_ASSERT_THROW(
+      resolveIntermediateType("aggregate_func_nonexist", {}),
+      "Aggregate function not registered: aggregate_func_nonexist");
 }
 
-TEST_F(FunctionRegistryTest, hasAggregateFunctionSignatureWrongArgType) {
-  testResolveAggregateFunction(
-      "aggregate_func", {DOUBLE(), BIGINT()}, nullptr, nullptr);
-  testResolveAggregateFunction("aggregate_func", {BIGINT()}, nullptr, nullptr);
-  testResolveAggregateFunction(
-      "aggregate_func", {BIGINT(), BIGINT(), BIGINT()}, nullptr, nullptr);
+TEST_F(AggregateFunctionRegistryTest, wrongArgType) {
+  VELOX_ASSERT_THROW(
+      resolveIntermediateType("aggregate_func", {DOUBLE(), BIGINT()}),
+      "Aggregate function signature is not supported");
+  VELOX_ASSERT_THROW(
+      resolveResultType("aggregate_func", {BIGINT()}),
+      "Aggregate function signature is not supported");
+  VELOX_ASSERT_THROW(
+      resolveResultType("aggregate_func", {BIGINT(), BIGINT(), BIGINT()}),
+      "Aggregate function signature is not supported");
 }
 
-TEST_F(FunctionRegistryTest, functionNameInMixedCase) {
-  testResolveAggregateFunction(
+TEST_F(AggregateFunctionRegistryTest, coercions) {
+  // (bigint, double) -> bigint
+  // (T, T) -> T
+  testCoersions(
+      "aggregate_func", {DOUBLE(), BIGINT()}, DOUBLE(), {nullptr, DOUBLE()});
+
+  testCoersions(
+      "aggregate_func", {TINYINT(), BIGINT()}, BIGINT(), {BIGINT(), nullptr});
+
+  testCoersions(
+      "aggregate_func", {INTEGER(), DOUBLE()}, BIGINT(), {BIGINT(), nullptr});
+}
+
+TEST_F(AggregateFunctionRegistryTest, functionNameInMixedCase) {
+  testResolve(
       "aggregatE_funC", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
-  testResolveAggregateFunction(
+  testResolve(
       "aggregatE_funC_aliaS", {DOUBLE(), DOUBLE()}, DOUBLE(), ARRAY(DOUBLE()));
 }
 
-TEST_F(FunctionRegistryTest, getAggregateFunctionSignatures) {
+TEST_F(AggregateFunctionRegistryTest, getSignatures) {
   auto functionSignatures = getAggregateFunctionSignatures();
   auto aggregateFuncSignatures = functionSignatures["aggregate_func"];
   std::vector<std::string> aggregateFuncSignaturesStr;
@@ -106,7 +160,7 @@ TEST_F(FunctionRegistryTest, getAggregateFunctionSignatures) {
   ASSERT_EQ(aggregateFuncSignaturesStr, expectedSignaturesStr);
 }
 
-TEST_F(FunctionRegistryTest, aggregateWindowFunctionSignature) {
+TEST_F(AggregateFunctionRegistryTest, windowFunction) {
   auto windowFunctionSignatures = getWindowFunctionSignatures("aggregate_func");
   ASSERT_EQ(windowFunctionSignatures->size(), 3);
 
@@ -121,12 +175,12 @@ TEST_F(FunctionRegistryTest, aggregateWindowFunctionSignature) {
   ASSERT_EQ(functionSignatures.count("(T,T) -> array(T) -> T"), 1);
 }
 
-TEST_F(FunctionRegistryTest, duplicateRegistration) {
+TEST_F(AggregateFunctionRegistryTest, duplicateRegistration) {
   EXPECT_FALSE(registerAggregateFunc("aggregate_func"));
   EXPECT_TRUE(registerAggregateFunc("aggregate_func", true));
 }
 
-TEST_F(FunctionRegistryTest, multipleNames) {
+TEST_F(AggregateFunctionRegistryTest, multipleNames) {
   auto signatures = AggregateFunc::signatures();
   auto factory = [&](core::AggregationNode::Step step,
                      const std::vector<TypePtr>& argTypes,
@@ -149,9 +203,9 @@ TEST_F(FunctionRegistryTest, multipleNames) {
       /*overwrite*/ false);
   exec::AggregateRegistrationResult allSuccess{true, true, true, true, true};
   EXPECT_EQ(registrationResult, allSuccess);
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func1", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func1_partial",
       {BIGINT(), DOUBLE()},
       ARRAY(BIGINT()),
@@ -166,7 +220,7 @@ TEST_F(FunctionRegistryTest, multipleNames) {
   exec::AggregateRegistrationResult onlyMainSuccess{
       true, false, false, false, false};
   EXPECT_EQ(registrationResult, onlyMainSuccess);
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func2", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
 
   auto registrationResults = registerAggregateFunction(
@@ -179,20 +233,32 @@ TEST_F(FunctionRegistryTest, multipleNames) {
       false, true, true, true, true};
   EXPECT_EQ(registrationResults[0], allSuccessExceptMain);
   EXPECT_EQ(registrationResults[1], allSuccess);
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func2", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func2_partial",
       {BIGINT(), DOUBLE()},
       ARRAY(BIGINT()),
       ARRAY(BIGINT()));
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func3", {BIGINT(), DOUBLE()}, BIGINT(), ARRAY(BIGINT()));
-  testResolveAggregateFunction(
+  testResolve(
       "aggregate_func3_partial",
       {BIGINT(), DOUBLE()},
       ARRAY(BIGINT()),
       ARRAY(BIGINT()));
 }
 
+TEST_F(AggregateFunctionRegistryTest, getAggregateFunctionNames) {
+  clearRegistry();
+  registerAggregateFunc("aggregate_func");
+  registerAggregateFunc("Aggregate_Func_Alias");
+
+  auto functions = getAggregateFunctionNames();
+  EXPECT_EQ(functions.size(), 2);
+  EXPECT_THAT(
+      functions,
+      testing::UnorderedElementsAre("aggregate_func", "aggregate_func_alias"));
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/AggregateSpillBenchmarkBase.cpp b/velox/exec/tests/AggregateSpillBenchmarkBase.cpp
index b8f15c3c799b..91e0ddc469e8 100644
--- a/velox/exec/tests/AggregateSpillBenchmarkBase.cpp
+++ b/velox/exec/tests/AggregateSpillBenchmarkBase.cpp
@@ -36,10 +36,11 @@ std::unique_ptr<RowContainer> makeRowContainer(
       true, // nullableKeys
       std::vector<Accumulator>{},
       dependentTypes,
-      false, // hasNext
-      false, // isJoinBuild
-      false, // hasProbedFlag
-      false, // hasNormalizedKey
+      /*hasNext=*/false,
+      /*isJoinBuild=*/false,
+      /*hasProbedFlag=*/false,
+      /*hasNormalizedKey=*/false,
+      /*useListRowIndex=*/false,
       pool.get());
 }
 
diff --git a/velox/exec/tests/AggregateSpillBenchmarkBase.h b/velox/exec/tests/AggregateSpillBenchmarkBase.h
index aafb67d009ec..f25f35831bbd 100644
--- a/velox/exec/tests/AggregateSpillBenchmarkBase.h
+++ b/velox/exec/tests/AggregateSpillBenchmarkBase.h
@@ -20,7 +20,7 @@ namespace facebook::velox::exec::test {
 class AggregateSpillBenchmarkBase : public SpillerBenchmarkBase {
  public:
   explicit AggregateSpillBenchmarkBase(std::string spillerType)
-      : spillerType_(spillerType){};
+      : spillerType_(spillerType) {};
 
   /// Sets up the test.
   void setUp() override;
diff --git a/velox/exec/tests/AggregationTest.cpp b/velox/exec/tests/AggregationTest.cpp
index 25d552b25ed6..94c235f93c2f 100644
--- a/velox/exec/tests/AggregationTest.cpp
+++ b/velox/exec/tests/AggregationTest.cpp
@@ -26,6 +26,7 @@
 #include "velox/common/testutil/TestValue.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateCompanionSignatures.h"
 #include "velox/exec/GroupingSet.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/PrefixSort.h"
@@ -37,6 +38,7 @@
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/SumNonPODAggregate.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/type/tests/utils/CustomTypesForTesting.h"
 
 namespace facebook::velox::exec::test {
 
@@ -332,10 +334,12 @@ class AggregationTest : public OperatorTestBase {
       std::vector<RowVectorPtr>& batches) {
     std::vector<VectorPtr> children;
     dictionary->setSize(count * sizeof(vector_size_t));
-    children.push_back(BaseVector::wrapInDictionary(
-        BufferPtr(nullptr), dictionary, count, rows->childAt(0)));
-    children.push_back(BaseVector::wrapInDictionary(
-        BufferPtr(nullptr), dictionary, count, rows->childAt(1)));
+    children.push_back(
+        BaseVector::wrapInDictionary(
+            BufferPtr(nullptr), dictionary, count, rows->childAt(0)));
+    children.push_back(
+        BaseVector::wrapInDictionary(
+            BufferPtr(nullptr), dictionary, count, rows->childAt(1)));
     children.push_back(children[1]);
     batches.push_back(vectorMaker_.rowVector(children));
     dictionary = AlignedBuffer::allocate<vector_size_t>(
@@ -380,18 +384,20 @@ class AggregationTest : public OperatorTestBase {
         false,
         true,
         true,
+        false,
         pool_.get());
   }
 
   RowTypePtr rowType_{
-      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6"},
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7"},
           {BIGINT(),
            SMALLINT(),
            INTEGER(),
            BIGINT(),
            REAL(),
            DOUBLE(),
-           VARCHAR()})};
+           VARCHAR(),
+           TIMESTAMP()})};
   folly::Random::DefaultGenerator rng_;
   memory::MemoryReclaimer::Stats reclaimerStats_;
   VectorFuzzer::Options fuzzerOpts_{
@@ -399,6 +405,8 @@ class AggregationTest : public OperatorTestBase {
       .nullRatio = 0,
       .stringLength = 1024,
       .stringVariableLength = false,
+      .timestampPrecision =
+          VectorFuzzer::Options::TimestampPrecision::kMicroSeconds,
       .allowLazyVector = false};
 };
 
@@ -453,8 +461,8 @@ TEST_F(AggregationTest, missingFunctionOrSignature) {
       BIGINT(), inputs, "missing-function");
   auto wrongInputTypes =
       std::make_shared<core::CallTypedExpr>(BIGINT(), inputs, "test_aggregate");
-  auto missingInputs = std::make_shared<core::CallTypedExpr>(
-      BIGINT(), std::vector<core::TypedExprPtr>{}, "test_aggregate");
+  auto missingInputs =
+      std::make_shared<core::CallTypedExpr>(BIGINT(), "test_aggregate");
 
   auto makePlan = [&](const core::CallTypedExprPtr& aggExpr) {
     return PlanBuilder()
@@ -475,7 +483,8 @@ TEST_F(AggregationTest, missingFunctionOrSignature) {
               std::vector<core::FieldAccessTypedExprPtr>{},
               std::vector<std::string>{"agg"},
               aggregates,
-              false,
+              /*ignoreNullKeys=*/false,
+              /*noGroupsSpanBatches=*/false,
               std::move(source));
         })
         .planNode();
@@ -515,9 +524,7 @@ TEST_F(AggregationTest, missingLambdaFunction) {
       std::make_shared<core::LambdaTypedExpr>(
           ROW({"a", "b"}, {BIGINT(), BIGINT()}),
           std::make_shared<core::CallTypedExpr>(
-              BIGINT(),
-              std::vector<core::TypedExprPtr>{field("a"), field("b")},
-              "multiply")),
+              BIGINT(), "multiply", field("a"), field("b"))),
   };
 
   auto plan = PlanBuilder()
@@ -538,7 +545,8 @@ TEST_F(AggregationTest, missingLambdaFunction) {
                         std::vector<core::FieldAccessTypedExprPtr>{},
                         std::vector<std::string>{"agg"},
                         aggregates,
-                        false,
+                        /*ignoreNullKeys=*/false,
+                        /*noGroupsSpanBatches=*/false,
                         std::move(source));
                   })
                   .planNode();
@@ -549,47 +557,6 @@ TEST_F(AggregationTest, missingLambdaFunction) {
       readCursor(params), "Aggregate function not registered: missing-lambda");
 }
 
-TEST_F(AggregationTest, DISABLED_resultTypeMismatch) {
-  using Step = core::AggregationNode::Step;
-
-  registerAggregateFunction(
-      "test_aggregate",
-      {AggregateFunctionSignatureBuilder()
-           .returnType("bigint")
-           .intermediateType("bigint")
-           .argumentType("bigint")
-           .build()},
-      [&](Step /*step*/,
-          const std::vector<TypePtr>& /*argTypes*/,
-          const TypePtr& /*resultType*/,
-          const core::QueryConfig& /*config*/)
-          -> std::unique_ptr<exec::Aggregate> { VELOX_UNREACHABLE(); },
-      false /*registerCompanionFunctions*/,
-      true /*overwrite*/);
-
-  for (auto step : {Step::kIntermediate, Step::kPartial}) {
-    VELOX_ASSERT_THROW(
-        Aggregate::create(
-            "test_aggregate",
-            step,
-            std::vector<TypePtr>{BIGINT()},
-            INTEGER(),
-            core::QueryConfig{{}}),
-        "Intermediate type mismatch");
-  }
-
-  for (auto step : {Step::kFinal, Step::kSingle}) {
-    VELOX_ASSERT_THROW(
-        Aggregate::create(
-            "test_aggregate",
-            step,
-            std::vector<TypePtr>{BIGINT()},
-            INTEGER(),
-            core::QueryConfig{{}}),
-        "Final type mismatch");
-  }
-}
-
 TEST_F(AggregationTest, global) {
   auto vectors = makeVectors(rowType_, 10, 100);
   createDuckDbTable(vectors);
@@ -669,8 +636,11 @@ TEST_F(AggregationTest, manyGlobalAggregations) {
   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)));
+    aggregates.push_back(
+        fmt::format(
+            "array_agg({} ORDER BY {})",
+            rowType->nameOf(i),
+            rowType->nameOf(i)));
   }
 
   op = PlanBuilder()
@@ -711,6 +681,20 @@ TEST_F(AggregationTest, singleStringKeyDistinct) {
   testSingleKey<StringView>(vectors, "c6", true, true);
 }
 
+TEST_F(AggregationTest, singleTimestampKey) {
+  auto vectors = createVectors(100, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  testSingleKey<StringView>(vectors, "c7", false, false);
+  testSingleKey<StringView>(vectors, "c7", true, false);
+}
+
+TEST_F(AggregationTest, singleTimestampKeyDistinct) {
+  auto vectors = createVectors(100, rowType_, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  testSingleKey<StringView>(vectors, "c7", false, true);
+  testSingleKey<StringView>(vectors, "c7", true, true);
+}
+
 TEST_F(AggregationTest, multiKey) {
   auto vectors = makeVectors(rowType_, 10, 100);
   createDuckDbTable(vectors);
@@ -861,8 +845,9 @@ TEST_F(AggregationTest, allKeyTypes) {
 
   std::vector<RowVectorPtr> batches;
   for (auto i = 0; i < 10; ++i) {
-    batches.push_back(std::static_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType, 100, *pool_)));
+    batches.push_back(
+        std::static_pointer_cast<RowVector>(
+            BatchMaker::createBatch(rowType, 100, *pool_)));
   }
   createDuckDbTable(batches);
   auto op =
@@ -896,12 +881,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   core::PlanNodeId aggNodeId;
   auto task = AssertQueryBuilder(duckDbQueryRunner_)
                   .config(QueryConfig::kMaxPartialAggregationMemory, 100)
-                  .plan(PlanBuilder()
-                            .values(vectors)
-                            .partialAggregation({"c0"}, {})
-                            .capturePlanNodeId(aggNodeId)
-                            .finalAggregation()
-                            .planNode())
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .partialAggregation({"c0"}, {})
+                          .capturePlanNodeId(aggNodeId)
+                          .finalAggregation()
+                          .planNode())
                   .assertResults("SELECT distinct c0 FROM tmp");
   EXPECT_GT(
       toPlanStats(task->taskStats())
@@ -919,12 +905,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Count aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
              .config(QueryConfig::kMaxPartialAggregationMemory, 1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({"c0"}, {"count(1)"})
-                       .capturePlanNodeId(aggNodeId)
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({"c0"}, {"count(1)"})
+                     .capturePlanNodeId(aggNodeId)
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT c0, count(1) FROM tmp GROUP BY 1");
   EXPECT_GT(
       toPlanStats(task->taskStats())
@@ -942,12 +929,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Global aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
              .config(QueryConfig::kMaxPartialAggregationMemory, 1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({}, {"sum(c0)"})
-                       .capturePlanNodeId(aggNodeId)
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({}, {"sum(c0)"})
+                     .capturePlanNodeId(aggNodeId)
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT sum(c0) FROM tmp");
   EXPECT_EQ(
       0,
@@ -982,11 +970,12 @@ TEST_F(AggregationTest, partialDistinctWithAbandon) {
                   .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
                   .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
                   .maxDrivers(1)
-                  .plan(PlanBuilder()
-                            .values(vectors)
-                            .partialAggregation({"c0"}, {})
-                            .finalAggregation()
-                            .planNode())
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .partialAggregation({"c0"}, {})
+                          .finalAggregation()
+                          .planNode())
                   .assertResults("SELECT distinct c0 FROM tmp");
 
   // with aggregation, just in case.
@@ -994,11 +983,12 @@ TEST_F(AggregationTest, partialDistinctWithAbandon) {
              .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
              .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
              .maxDrivers(1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({"c0"}, {"sum(c0)"})
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({"c0"}, {"sum(c0)"})
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT distinct c0, sum(c0) FROM tmp group by c0");
 }
 
@@ -1016,6 +1006,7 @@ TEST_F(AggregationTest, distinctWithGroupingKeysReordered) {
   options.vectorSize = vectorSize;
   options.stringVariableLength = false;
   options.stringLength = 128;
+  options.nullRatio = 0.1;
   VectorFuzzer fuzzer(options, pool());
   const int numVectors{5};
   std::vector<RowVectorPtr> vectors;
@@ -1029,20 +1020,20 @@ TEST_F(AggregationTest, distinctWithGroupingKeysReordered) {
   // first.
   auto spillDirectory = exec::test::TempDirectoryPath::create();
   TestScopedSpillInjection scopedSpillInjection(100);
-  auto task =
-      AssertQueryBuilder(duckDbQueryRunner_)
-          .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
-          .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
-          .spillDirectory(spillDirectory->getPath())
-          .config(QueryConfig::kSpillEnabled, true)
-          .config(QueryConfig::kAggregationSpillEnabled, true)
-          .config(QueryConfig::kSpillPrefixSortEnabled, true)
-          .maxDrivers(1)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .singleAggregation({"c4", "c1", "c3", "c2", "c0"}, {})
-                    .planNode())
-          .assertResults("SELECT distinct c4, c1, c3, c2, c0 FROM tmp");
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .config(QueryConfig::kAbandonPartialAggregationMinRows, 100)
+                  .config(QueryConfig::kAbandonPartialAggregationMinPct, 50)
+                  .spillDirectory(spillDirectory->getPath())
+                  .config(QueryConfig::kSpillEnabled, true)
+                  .config(QueryConfig::kAggregationSpillEnabled, true)
+                  .config(QueryConfig::kSpillPrefixSortEnabled, true)
+                  .maxDrivers(1)
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .singleAggregation({"c4", "c1", "c3", "c2", "c0"}, {})
+                          .planNode())
+                  .assertResults("SELECT distinct c4, c1, c3, c2, c0 FROM tmp");
 }
 
 TEST_F(AggregationTest, largeValueRangeArray) {
@@ -1142,12 +1133,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimitIncrease) {
                     .config(
                         QueryConfig::kMaxExtendedPartialAggregationMemory,
                         std::to_string(testData.extendedPartialMemoryLimit))
-                    .plan(PlanBuilder()
-                              .values(vectors)
-                              .partialAggregation({"c0"}, {})
-                              .capturePlanNodeId(aggNodeId)
-                              .finalAggregation()
-                              .planNode())
+                    .plan(
+                        PlanBuilder()
+                            .values(vectors)
+                            .partialAggregation({"c0"}, {})
+                            .capturePlanNodeId(aggNodeId)
+                            .finalAggregation()
+                            .planNode())
                     .assertResults("SELECT distinct c0 FROM tmp");
     const auto runtimeStats =
         toPlanStats(task->taskStats()).at(aggNodeId).customStats;
@@ -1218,13 +1210,13 @@ TEST_F(AggregationTest, partialAggregationMaybeReservationReleaseCheck) {
 TEST_F(AggregationTest, spillAll) {
   auto inputs = makeVectors(rowType_, 100, 10);
 
-  const auto numDistincts =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(inputs)
-                             .singleAggregation({"c0"}, {}, {})
-                             .planNode())
-          .copyResults(pool_.get())
-          ->size();
+  const auto numDistincts = AssertQueryBuilder(
+                                PlanBuilder()
+                                    .values(inputs)
+                                    .singleAggregation({"c0"}, {}, {})
+                                    .planNode())
+                                .copyResults(pool_.get())
+                                ->size();
 
   auto plan = PlanBuilder()
                   .values(inputs)
@@ -1304,7 +1296,7 @@ TEST_F(AggregationTest, memoryAllocations) {
   // 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(7, planStats.at(aggNodeId).numMemoryAllocations);
+  ASSERT_EQ(8, planStats.at(aggNodeId).numMemoryAllocations);
 }
 
 TEST_F(AggregationTest, groupingSets) {
@@ -1738,11 +1730,12 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithSpill) {
             .config(
                 QueryConfig::kMaxOutputBatchRows,
                 std::to_string(testData.maxOutputRows))
-            .plan(PlanBuilder()
-                      .values(inputs)
-                      .singleAggregation({"c0"}, {"array_agg(c1)"})
-                      .capturePlanNodeId(aggrNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(inputs)
+                    .singleAggregation({"c0"}, {"array_agg(c1)"})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
             .assertResults("SELECT c0, array_agg(c1) FROM tmp GROUP BY 1");
     ASSERT_GT(toPlanStats(task->taskStats()).at(aggrNodeId).spilledBytes, 0);
     ASSERT_EQ(
@@ -1802,11 +1795,12 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithSpillForOrderedAggr) {
             .config(
                 QueryConfig::kMaxOutputBatchRows,
                 std::to_string(testData.maxOutputRows))
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0"}, {"array_agg(c1 order by c1)"})
-                      .capturePlanNodeId(aggrNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .singleAggregation({"c0"}, {"array_agg(c1 order by c1)"})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT c0, array_agg(c1 order by c1) FROM tmp GROUP BY 1");
     ASSERT_GT(toPlanStats(task->taskStats()).at(aggrNodeId).spilledBytes, 0);
@@ -1848,11 +1842,12 @@ TEST_F(AggregationTest, spillDuringOutputProcessing) {
           .config(
               QueryConfig::kMaxOutputBatchRows, std::to_string(numOutputRows))
           .config(QueryConfig::kSpillNumPartitionBits, "0")
-          .plan(PlanBuilder()
-                    .values({input})
-                    .singleAggregation({"c0", "c1"}, {"max(c2)", "min(c3)"})
-                    .capturePlanNodeId(aggrNodeId)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values({input})
+                  .singleAggregation({"c0", "c1"}, {"max(c2)", "min(c3)"})
+                  .capturePlanNodeId(aggrNodeId)
+                  .planNode())
           .assertResults(
               "SELECT c0, c1, max(c2), min(c3) FROM tmp GROUP BY 1, 2");
 
@@ -1928,11 +1923,12 @@ TEST_F(AggregationTest, outputBatchSizeCheckWithoutSpill) {
             .config(
                 QueryConfig::kMaxOutputBatchRows,
                 std::to_string(testData.maxOutputRows))
-            .plan(PlanBuilder()
-                      .values(inputs)
-                      .singleAggregation({"c0"}, {"array_agg(c1)"})
-                      .capturePlanNodeId(aggrNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(inputs)
+                    .singleAggregation({"c0"}, {"array_agg(c1)"})
+                    .capturePlanNodeId(aggrNodeId)
+                    .planNode())
             .assertResults("SELECT c0, array_agg(c1) FROM tmp GROUP BY 1");
 
     ASSERT_EQ(
@@ -1958,17 +1954,18 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
   createDuckDbTable(batches);
 
   for (int32_t minSpillableReservationPct : {5, 50, 100}) {
-    SCOPED_TRACE(fmt::format(
-        "minSpillableReservationPct: {}", minSpillableReservationPct));
+    SCOPED_TRACE(
+        fmt::format(
+            "minSpillableReservationPct: {}", minSpillableReservationPct));
 
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::GroupingSet::addInputForActiveRows",
         std::function<void(exec::GroupingSet*)>(
             ([&](exec::GroupingSet* groupingSet) {
-              memory::MemoryPool& pool = groupingSet->testingPool();
+              memory::MemoryPool* pool = groupingSet->testingPool();
               const auto availableReservationBytes =
-                  pool.availableReservation();
-              const auto currentUsedBytes = pool.usedBytes();
+                  pool->availableReservation();
+              const auto currentUsedBytes = pool->usedBytes();
               // Verifies we always have min reservation after ensuring the
               // input.
               ASSERT_GE(
@@ -1988,10 +1985,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, minSpillableMemoryReservation) {
             .config(
                 QueryConfig::kSpillableReservationGrowthPct,
                 std::to_string(minSpillableReservationPct + 1))
-            .plan(PlanBuilder()
-                      .values(batches)
-                      .singleAggregation({"c0"}, {"array_agg(c2)", "max(c3)"})
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(batches)
+                    .singleAggregation({"c0"}, {"array_agg(c2)", "max(c3)"})
+                    .planNode())
             .assertResults(
                 "SELECT c0, array_agg(c2), max(c3) FROM tmp GROUP BY 1");
     OperatorTestBase::deleteTaskAndCheckSpillDirectory(task);
@@ -2026,11 +2024,12 @@ TEST_F(AggregationTest, distinctWithSpilling) {
                     .spillDirectory(spillDirectory->getPath())
                     .config(QueryConfig::kSpillEnabled, true)
                     .config(QueryConfig::kAggregationSpillEnabled, true)
-                    .plan(PlanBuilder()
-                              .values(testParam.inputs)
-                              .singleAggregation({"c0"}, {}, {})
-                              .capturePlanNodeId(aggrNodeId)
-                              .planNode())
+                    .plan(
+                        PlanBuilder()
+                            .values(testParam.inputs)
+                            .singleAggregation({"c0"}, {}, {})
+                            .capturePlanNodeId(aggrNodeId)
+                            .planNode())
                     .assertResults("SELECT distinct c0 FROM tmp");
 
     // Verify that spilling is not triggered.
@@ -2056,11 +2055,12 @@ TEST_F(AggregationTest, spillingForAggrsWithDistinct) {
           .spillDirectory(spillDirectory->getPath())
           .config(QueryConfig::kSpillEnabled, true)
           .config(QueryConfig::kAggregationSpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .singleAggregation({"c1"}, {"count(DISTINCT c0)"}, {})
-                    .capturePlanNodeId(aggrNodeId)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values(vectors)
+                  .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();
@@ -2355,17 +2355,18 @@ TEST_F(AggregationTest, preGroupedAggregationWithSpilling) {
           .spillDirectory(spillDirectory->getPath())
           .config(QueryConfig::kSpillEnabled, true)
           .config(QueryConfig::kAggregationSpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .aggregation(
-                        {"c0", "c1"},
-                        {"c0"},
-                        {"sum(c2)"},
-                        {},
-                        core::AggregationNode::Step::kSingle,
-                        false)
-                    .capturePlanNodeId(aggrNodeId)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values(vectors)
+                  .aggregation(
+                      {"c0", "c1"},
+                      {"c0"},
+                      {"sum(c2)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .capturePlanNodeId(aggrNodeId)
+                  .planNode())
           .assertResults("SELECT c0, c1, sum(c2) FROM tmp GROUP BY c0, c1");
   auto stats = task->taskStats().pipelineStats;
   // Verify that spilling is not triggered.
@@ -2450,8 +2451,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringInputProcessing) {
 
     auto tempDirectory = exec::test::TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -2600,13 +2602,15 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
 
   auto tempDirectory = exec::test::TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   auto expectedResult =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(batches)
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .planNode())
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(batches)
+              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+              .planNode())
           .queryCtx(queryCtx)
           .copyResults(pool_.get());
 
@@ -2651,10 +2655,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringReserve) {
           })));
 
   std::thread taskThread([&]() {
-    AssertQueryBuilder(PlanBuilder()
-                           .values(batches)
-                           .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                           .planNode())
+    AssertQueryBuilder(
+        PlanBuilder()
+            .values(batches)
+            .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+            .planNode())
         .queryCtx(queryCtx)
         .spillDirectory(tempDirectory->getPath())
         .config(QueryConfig::kSpillEnabled, true)
@@ -2838,8 +2843,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringOutputProcessing) {
 
     auto tempDirectory = exec::test::TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -3012,7 +3018,7 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimDuringNonReclaimableSection) {
           if (!testData.nonReclaimableInput) {
             return;
           }
-          if (groupSet->testingPool().usedBytes() == 0) {
+          if (groupSet->testingPool()->usedBytes() == 0) {
             return;
           }
           if (!injectNonReclaimableSectionOnce.exchange(false)) {
@@ -3497,8 +3503,9 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimEmptyInput) {
 
   auto tempDirectory = exec::test::TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   core::PlanNodeId aggNodeId;
   auto task =
       AssertQueryBuilder(
@@ -3526,10 +3533,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimEmptyOutput) {
   auto batches = makeVectors(rowType, 100, 5);
 
   auto expectedResult =
-      AssertQueryBuilder(PlanBuilder()
-                             .values(batches)
-                             .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                             .planNode())
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(batches)
+              .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+              .planNode())
           .copyResults(pool_.get());
 
   std::atomic_int numGetOutput{0};
@@ -3569,24 +3577,25 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimEmptyOutput) {
 
   auto tempDirectory = exec::test::TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  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);
+  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());
@@ -3673,11 +3682,12 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregation) {
             .config(
                 core::QueryConfig::kMaxSpillRunRows,
                 std::to_string(maxSpillRunRows))
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .capturePlanNodeId(aggrNodeId)
-                      .planNode())
+            .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());
@@ -3726,11 +3736,12 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromDistinctAggregation) {
                     .config(
                         core::QueryConfig::kMaxSpillRunRows,
                         std::to_string(maxSpillRunRows))
-                    .plan(PlanBuilder()
-                              .values(vectors)
-                              .singleAggregation({"c0"}, {})
-                              .capturePlanNodeId(aggrNodeId)
-                              .planNode())
+                    .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);
@@ -3765,10 +3776,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationOnNoMoreInput) {
             .config(core::QueryConfig::kSpillEnabled, true)
             .config(core::QueryConfig::kAggregationSpillEnabled, true)
             .maxDrivers(1)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .planNode())
+            .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;
@@ -3810,10 +3822,11 @@ DEBUG_ONLY_TEST_F(AggregationTest, reclaimFromAggregationDuringOutput) {
             .config(core::QueryConfig::kPreferredOutputBatchRows, numRows / 10)
             .maxDrivers(1)
             //.queryCtx(aggregationQueryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .planNode())
+            .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;
@@ -3832,10 +3845,11 @@ TEST_F(AggregationTest, reclaimFromCompletedAggregation) {
   std::thread aggregationThread([&]() {
     auto task =
         AssertQueryBuilder(duckDbQueryRunner_)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                      .planNode())
+            .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());
@@ -4015,6 +4029,7 @@ TEST_F(AggregationTest, destroyAfterPartialInitialization) {
       false, // isJoinBuild
       false, // hasProbedFlag
       false, // hasNormalizedKeys
+      false, // useListRowIndex
       pool());
   const auto rowColumn = rows.columnAt(0);
   agg.setOffsets(
@@ -4030,6 +4045,64 @@ TEST_F(AggregationTest, destroyAfterPartialInitialization) {
   ASSERT_TRUE(agg.destroyCalled);
 }
 
+DEBUG_ONLY_TEST_F(
+    AggregationTest,
+    uninitializedDistinctAggrWithExternalMemAggrDuringAbort) {
+  const auto createInput =
+      [&](int32_t startKey, uint32_t numGroups, uint32_t numElementsPerGroup) {
+        return makeRowVector({
+            makeFlatVector<int32_t>([&]() {
+              std::vector<int32_t> keys;
+              for (auto i = 0; i < numGroups; ++i) {
+                for (auto j = 0; j < numElementsPerGroup; ++j) {
+                  keys.push_back(startKey + i);
+                }
+              }
+              return keys;
+            }()),
+            makeFlatVector<int32_t>(
+                numGroups * numElementsPerGroup,
+                [&](auto row) { return startKey; }),
+        });
+      };
+
+  std::vector<RowVectorPtr> inputs;
+  inputs.emplace_back(createInput(0, 10000, 10));
+  createDuckDbTable(inputs);
+
+  GroupingSet* groupingSet{nullptr};
+
+  std::atomic_bool groupingSetExtracted{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::GroupingSet::addInputForActiveRows",
+      std::function<void(GroupingSet*)>([&](GroupingSet* _groupingSet) {
+        if (!groupingSetExtracted.exchange(true)) {
+          groupingSet = _groupingSet;
+        }
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::memory::MemoryPoolImpl::reserveThreadSafe",
+      std::function<void(void*)>([&](void* /*unused*/) {
+        if (groupingSet == nullptr) {
+          return;
+        }
+        if (groupingSet->numRows() > 0) {
+          VELOX_FAIL("Inject allocation failure.");
+        }
+      }));
+
+  auto plan = PlanBuilder()
+                  .values(inputs)
+                  .singleAggregation({"c0"}, {"array_agg(distinct c1)"})
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      assertQuery(
+          plan, "SELECT c0, array_agg(distinct c1) FROM tmp GROUP BY c0"),
+      "Inject allocation failure.");
+}
+
 TEST_F(AggregationTest, nanKeys) {
   // Some keys are NaNs.
   auto kNaN = std::numeric_limits<double>::quiet_NaN();
@@ -4065,4 +4138,40 @@ TEST_F(AggregationTest, nanKeys) {
       {makeRowVector({c0, c1}), c1},
       {makeRowVector({e0, e1}), e1});
 }
+
+TEST_F(AggregationTest, keysProvideCustomComparison) {
+  // Columns reused across test cases.
+  auto c0 = makeFlatVector<int64_t>(
+      {0, 1, 256, 257, 512, 513},
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON());
+  auto c1 = makeFlatVector<int32_t>({1, 2, 1, 2, 1, 2});
+  // Expected result columns reused across test cases. A deduplicated version of
+  // c0 and c1.
+  auto e0 = makeFlatVector<int64_t>(
+      {0, 1}, velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON());
+  auto e1 = makeFlatVector<int32_t>({1, 2});
+
+  auto testDistinctAgg = [&](const std::vector<std::string>& aggKeys,
+                             const std::vector<VectorPtr>& inputCols,
+                             const 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/AssertQueryBuilderTest.cpp b/velox/exec/tests/AssertQueryBuilderTest.cpp
index db4c44eb2c9f..6ae70783f7a9 100644
--- a/velox/exec/tests/AssertQueryBuilderTest.cpp
+++ b/velox/exec/tests/AssertQueryBuilderTest.cpp
@@ -125,7 +125,7 @@ TEST_F(AssertQueryBuilderTest, hiveSplits) {
   }
 
   // Split with partition key.
-  ColumnHandleMap assignments = {
+  connector::ColumnHandleMap assignments = {
       {"ds", partitionKey("ds", VARCHAR())},
       {"c0", regularColumn("c0", BIGINT())}};
 
diff --git a/velox/exec/tests/AssignUniqueIdTest.cpp b/velox/exec/tests/AssignUniqueIdTest.cpp
index 852a31adee9a..6a34e3bc1418 100644
--- a/velox/exec/tests/AssignUniqueIdTest.cpp
+++ b/velox/exec/tests/AssignUniqueIdTest.cpp
@@ -16,31 +16,51 @@
 #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/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
 
-using namespace facebook::velox;
+namespace facebook::velox::exec {
+
 using namespace facebook::velox::test;
-using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 
-class AssignUniqueIdTest : public OperatorTestBase {
+namespace {
+
+class AssignUniqueIdTest : public HiveConnectorTestBase {
  protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+  }
+
   void verifyUniqueId(
       const std::shared_ptr<const core::PlanNode>& plan,
       const std::vector<RowVectorPtr>& input) {
     CursorParameters params;
     params.planNode = plan;
-
     auto result = readCursor(params);
-    auto numColumns = result.second[0]->childrenSize();
+    ASSERT_EQ(result.second[0]->childrenSize(), input[0]->childrenSize() + 1);
+    verifyUniqueId(input, result.second);
+
+    auto task = result.first->task();
+    // 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(1, stats.at(uniqueNodeId_).numMemoryAllocations);
+  }
+
+  void verifyUniqueId(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<facebook::velox::RowVectorPtr>& vectors) {
+    auto numColumns = vectors[0]->childrenSize();
     ASSERT_EQ(numColumns, input[0]->childrenSize() + 1);
 
     std::set<int64_t> ids;
     for (int i = 0; i < numColumns; i++) {
-      for (auto batch = 0; batch < result.second.size(); ++batch) {
-        auto column = result.second[batch]->childAt(i);
+      for (auto batch = 0; batch < vectors.size(); ++batch) {
+        auto column = vectors[batch]->childAt(i);
         if (i < numColumns - 1) {
           assertEqualVectors(input[batch]->childAt(i), column);
         } else {
@@ -59,15 +79,6 @@ class AssignUniqueIdTest : public OperatorTestBase {
     }
 
     ASSERT_EQ(totalInputSize, ids.size());
-
-    auto task = result.first->task();
-
-    // 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(1, stats.at(uniqueNodeId_).numMemoryAllocations);
   }
 
   core::PlanNodeId uniqueNodeId_;
@@ -76,6 +87,7 @@ class AssignUniqueIdTest : public OperatorTestBase {
 TEST_F(AssignUniqueIdTest, multiBatch) {
   vector_size_t batchSize = 1000;
   std::vector<RowVectorPtr> input;
+  input.reserve(3);
   for (int i = 0; i < 3; ++i) {
     input.push_back(
         makeRowVector({makeFlatVector<int32_t>(batchSize, folly::identity)}));
@@ -133,9 +145,9 @@ TEST_F(AssignUniqueIdTest, multiThread) {
     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.
+    // 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);
   }
@@ -166,3 +178,46 @@ TEST_F(AssignUniqueIdTest, taskUniqueIdLimit) {
       AssertQueryBuilder(plan).copyResults(pool()),
       "(16777216 vs. 16777216) Unique 24-bit ID specified for AssignUniqueId exceeds the limit");
 }
+
+TEST_F(AssignUniqueIdTest, barrier) {
+  auto rowType{ROW({"c0", "c1"}, {BIGINT(), INTEGER()})};
+
+  const int numSplits{5};
+
+  std::vector<RowVectorPtr> vectors;
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+
+  const int numRowsPerSplit{100};
+  for (int32_t i = 0; i < numSplits; ++i) {
+    auto vector = makeRowVector(rowType, {.vectorSize = numRowsPerSplit});
+    vectors.push_back(vector);
+    tempFiles.push_back(TempFilePath::create());
+  }
+  writeToFiles(toFilePaths(tempFiles), vectors);
+
+  auto plan = PlanBuilder()
+                  .tableScan(rowType)
+                  .assignUniqueId("row_number")
+                  .project({"c0", "c1", "row_number"})
+                  .planNode();
+
+  for (const auto barrierExecution : {false, true}) {
+    SCOPED_TRACE(fmt::format("barrierExecution {}", barrierExecution));
+
+    std::shared_ptr<Task> task;
+    auto result = AssertQueryBuilder(plan)
+                      .splits(makeHiveConnectorSplits(tempFiles))
+                      .serialExecution(true)
+                      .barrierExecution(barrierExecution)
+                      .copyResults(pool(), task);
+    auto results = split(result, numSplits);
+
+    verifyUniqueId(vectors, results);
+
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(taskStats.numBarriers, barrierExecution ? numSplits : 0);
+    ASSERT_EQ(taskStats.numFinishedSplits, numSplits);
+  }
+}
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/AsyncConnectorTest.cpp b/velox/exec/tests/AsyncConnectorTest.cpp
index 7f2ad55c00d6..91533ea7f904 100644
--- a/velox/exec/tests/AsyncConnectorTest.cpp
+++ b/velox/exec/tests/AsyncConnectorTest.cpp
@@ -32,11 +32,16 @@ const std::string kTestConnectorId = "test";
 
 class TestTableHandle : public connector::ConnectorTableHandle {
  public:
-  TestTableHandle() : connector::ConnectorTableHandle(kTestConnectorId) {}
+  TestTableHandle(std::string name)
+      : connector::ConnectorTableHandle(kTestConnectorId),
+        name_{std::move(name)} {}
 
-  std::string toString() const override {
-    VELOX_NYI();
+  const std::string& name() const override {
+    return name_;
   }
+
+ private:
+  const std::string name_;
 };
 
 class TestSplit : public connector::ConnectorSplit {
@@ -55,7 +60,8 @@ class TestSplit : public connector::ConnectorSplit {
       return ContinueFuture::makeEmpty();
     }
 
-    auto [promise, future] = makeVeloxContinuePromiseContract();
+    auto [promise, future] =
+        makeVeloxContinuePromiseContract("TestSplit::touch");
 
     promise_ = std::move(promise);
     scheduler_.addFunction(
@@ -121,7 +127,7 @@ class TestDataSource : public connector::DataSource {
     return 0;
   }
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override {
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override {
     return {};
   }
 
@@ -137,18 +143,17 @@ class TestConnector : public connector::Connector {
 
   std::unique_ptr<connector::DataSource> createDataSource(
       const RowTypePtr& /* outputType */,
-      const std::shared_ptr<ConnectorTableHandle>& /* tableHandle */,
+      const ConnectorTableHandlePtr& /* tableHandle */,
       const std::unordered_map<
           std::string,
-          std::shared_ptr<connector::ColumnHandle>>& /* columnHandles */,
+          connector::ColumnHandlePtr>& /* columnHandles */,
       connector::ConnectorQueryCtx* connectorQueryCtx) override {
     return std::make_unique<TestDataSource>(connectorQueryCtx->memoryPool());
   }
 
   std::unique_ptr<connector::DataSink> createDataSink(
       RowTypePtr /*inputType*/,
-      std::shared_ptr<
-          ConnectorInsertTableHandle> /*connectorInsertTableHandle*/,
+      ConnectorInsertTableHandlePtr /*connectorInsertTableHandle*/,
       ConnectorQueryCtx* /*connectorQueryCtx*/,
       CommitStrategy /*commitStrategy*/) override final {
     VELOX_NYI();
@@ -175,15 +180,13 @@ class AsyncConnectorTest : public OperatorTestBase {
  public:
   void SetUp() override {
     OperatorTestBase::SetUp();
-    connector::registerConnectorFactory(
-        std::make_shared<TestConnectorFactory>());
-    auto testConnector =
-        connector::getConnectorFactory(TestConnectorFactory::kTestConnectorName)
-            ->newConnector(
-                kTestConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()),
-                nullptr);
+    TestConnectorFactory factory;
+    auto testConnector = factory.newConnector(
+        kTestConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()),
+        nullptr,
+        nullptr);
     connector::registerConnector(testConnector);
   }
 
@@ -194,7 +197,7 @@ class AsyncConnectorTest : public OperatorTestBase {
 };
 
 TEST_F(AsyncConnectorTest, basic) {
-  auto tableHandle = std::make_shared<TestTableHandle>();
+  auto tableHandle = std::make_shared<TestTableHandle>("test");
   core::PlanNodeId scanId;
   auto plan = PlanBuilder()
                   .startTableScan()
diff --git a/velox/exec/tests/CMakeLists.txt b/velox/exec/tests/CMakeLists.txt
index 70342b290739..882fcfcf7052 100644
--- a/velox/exec/tests/CMakeLists.txt
+++ b/velox/exec/tests/CMakeLists.txt
@@ -15,13 +15,16 @@ add_subdirectory(utils)
 
 add_executable(
   aggregate_companion_functions_test
-  AggregateCompanionAdapterTest.cpp AggregateCompanionSignaturesTest.cpp
-  DummyAggregateFunction.cpp)
+  AggregateCompanionAdapterTest.cpp
+  AggregateCompanionSignaturesTest.cpp
+  DummyAggregateFunction.cpp
+)
 
 add_test(
   NAME aggregate_companion_functions_test
   COMMAND aggregate_companion_functions_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   aggregate_companion_functions_test
@@ -30,7 +33,8 @@ target_link_libraries(
   velox_exec_test_lib
   velox_presto_types
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(
   velox_exec_test
@@ -42,11 +46,13 @@ add_executable(
   AsyncConnectorTest.cpp
   ConcatFilesSpillMergeStreamTest.cpp
   ContainerRowSerdeTest.cpp
+  ColumnStatsCollectorTest.cpp
   CustomJoinTest.cpp
   EnforceSingleRowTest.cpp
   ExchangeClientTest.cpp
   ExpandTest.cpp
   FilterProjectTest.cpp
+  FilterToExpressionTest.cpp
   FunctionResolutionTest.cpp
   HashBitRangeTest.cpp
   HashJoinBridgeTest.cpp
@@ -61,17 +67,19 @@ add_executable(
   MemoryReclaimerTest.cpp
   MergeJoinTest.cpp
   MergeTest.cpp
+  MergerTest.cpp
   MultiFragmentTest.cpp
   NestedLoopJoinTest.cpp
   OrderByTest.cpp
   OperatorTraceTest.cpp
   OutputBufferManagerTest.cpp
+  ParallelProjectTest.cpp
   PartitionedOutputTest.cpp
   PlanNodeSerdeTest.cpp
+  PlanNodeStatsTest.cpp
   PlanNodeToStringTest.cpp
   PlanNodeToSummaryStringTest.cpp
   PrefixSortTest.cpp
-  PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
   PrintPlanWithStatsTest.cpp
   ProbeOperatorStateTest.cpp
   TraceUtilTest.cpp
@@ -81,8 +89,11 @@ add_executable(
   ScaledScanControllerTest.cpp
   ScaleWriterLocalPartitionTest.cpp
   SortBufferTest.cpp
+  SpatialIndexTest.cpp
+  HilbertIndexTest.cpp
   SpillerTest.cpp
   SpillTest.cpp
+  SplitListenerTest.cpp
   SplitTest.cpp
   SqlTest.cpp
   StreamingAggregationTest.cpp
@@ -98,7 +109,12 @@ add_executable(
   VectorHasherTest.cpp
   WindowFunctionRegistryTest.cpp
   WindowTest.cpp
-  WriterFuzzerUtilTest.cpp)
+  WriterFuzzerUtilTest.cpp
+)
+
+if(VELOX_ENABLE_GEO)
+  target_sources(velox_exec_test PRIVATE SpatialJoinTest.cpp)
+endif()
 
 add_executable(
   velox_exec_infra_test
@@ -112,19 +128,20 @@ add_executable(
   PrestoQueryRunnerTest.cpp
   QueryAssertionsTest.cpp
   TaskTest.cpp
-  TreeOfLosersTest.cpp)
+  TreeOfLosersTest.cpp
+)
 
-add_test(
-  NAME velox_exec_test
-  COMMAND velox_exec_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+add_test(NAME velox_exec_test COMMAND velox_exec_test WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 
-set_tests_properties(velox_exec_test PROPERTIES TIMEOUT 3000)
+# TODO: Revert back to 3000 once is fixed.
+# https://github.com/facebookincubator/velox/issues/13879
+set_tests_properties(velox_exec_test PROPERTIES TIMEOUT 6000)
 
 add_test(
   NAME velox_exec_infra_test
   COMMAND velox_exec_infra_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_exec_test
@@ -132,6 +149,7 @@ target_link_libraries(
   velox_dwio_common
   velox_dwio_common_exception
   velox_dwio_common_test_utils
+  velox_dwio_orc_reader
   velox_dwio_parquet_reader
   velox_dwio_parquet_writer
   velox_exec
@@ -156,7 +174,6 @@ target_link_libraries(
   Boost::date_time
   Boost::filesystem
   Boost::program_options
-  Boost::regex
   Boost::thread
   Boost::system
   GTest::gtest
@@ -165,7 +182,8 @@ target_link_libraries(
   Folly::folly
   gflags::gflags
   glog::glog
-  fmt::fmt)
+  fmt::fmt
+)
 
 target_link_libraries(
   velox_exec_infra_test
@@ -193,7 +211,6 @@ target_link_libraries(
   Boost::date_time
   Boost::filesystem
   Boost::program_options
-  Boost::regex
   Boost::thread
   Boost::system
   GTest::gtest
@@ -202,7 +219,36 @@ target_link_libraries(
   Folly::folly
   gflags::gflags
   glog::glog
-  fmt::fmt)
+  fmt::fmt
+)
+
+add_executable(
+  velox_exec_util_test
+  Main.cpp
+  PrestoQueryRunnerHyperLogLogTransformTest.cpp
+  PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp
+  PrestoQueryRunnerTDigestTransformTest.cpp
+  PrestoQueryRunnerQDigestTransformTest.cpp
+  PrestoQueryRunnerKHyperLogLogTransformTest.cpp
+  PrestoQueryRunnerSetDigestTransformTest.cpp
+  PrestoQueryRunnerJsonTransformTest.cpp
+  PrestoQueryRunnerIntervalTransformTest.cpp
+  PrestoQueryRunnerTimeTransformTest.cpp
+  PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
+)
+
+add_test(velox_exec_util_test velox_exec_util_test)
+
+target_link_libraries(
+  velox_exec_util_test
+  velox_fuzzer_util
+  velox_exec_test_lib
+  velox_functions_test_lib
+  velox_presto_types
+  velox_presto_types_fuzzer_utils
+  GTest::gtest
+  GTest::gtest_main
+)
 
 add_executable(velox_in_10_min_demo VeloxIn10MinDemo.cpp)
 
@@ -215,31 +261,34 @@ target_link_libraries(
   velox_exec
   velox_exec_test_lib
   velox_tpch_connector
-  velox_memory)
-
-# Arbitration Fuzzer.
-add_executable(velox_memory_arbitration_fuzzer_test
-               MemoryArbitrationFuzzerTest.cpp)
-
-target_link_libraries(
-  velox_memory_arbitration_fuzzer_test velox_memory_arbitration_fuzzer
-  GTest::gtest GTest::gtest_main)
+  velox_memory
+)
 
-add_executable(velox_table_evolution_fuzzer_test TableEvolutionFuzzerTest.cpp
-                                                 TableEvolutionFuzzer.cpp)
+add_executable(
+  velox_table_evolution_fuzzer_test
+  TableEvolutionFuzzerTest.cpp
+  TableEvolutionFuzzer.cpp
+)
 
 target_link_libraries(
   velox_table_evolution_fuzzer_test
+  velox_expression_fuzzer
+  velox_expression_test_utility
+  velox_constrained_input_generators
+  velox_fuzzer_util
+  velox_functions_prestosql
   velox_exec_test_lib
   velox_temp_path
   velox_vector_fuzzer
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_test(
   NAME velox_table_evolution_fuzzer_test
   COMMAND velox_table_evolution_fuzzer_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 add_executable(velox_aggregation_runner_test AggregationRunnerTest.cpp)
 
@@ -250,33 +299,37 @@ target_link_libraries(
   velox_aggregates
   velox_vector_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
-add_library(velox_simple_aggregate SimpleAverageAggregate.cpp
-                                   SimpleArrayAggAggregate.cpp)
+add_library(velox_simple_aggregate SimpleAverageAggregate.cpp SimpleArrayAggAggregate.cpp)
 
 target_link_libraries(
   velox_simple_aggregate
   velox_exec
   velox_expression
   velox_expression_functions
-  velox_aggregates)
+  velox_aggregates
+)
 
-add_executable(velox_simple_aggregate_test SimpleAggregateAdapterTest.cpp
-                                           Main.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)
+  GTest::gtest
+)
 
 add_test(velox_simple_aggregate_test velox_simple_aggregate_test)
 
 if(VELOX_ENABLE_BENCHMARKS)
-  add_library(velox_spiller_join_benchmark_base JoinSpillInputBenchmarkBase.cpp
-                                                SpillerBenchmarkBase.cpp)
+  add_library(
+    velox_spiller_join_benchmark_base
+    JoinSpillInputBenchmarkBase.cpp
+    SpillerBenchmarkBase.cpp
+  )
   target_link_libraries(
     velox_spiller_join_benchmark_base
     velox_exec
@@ -286,14 +339,22 @@ if(VELOX_ENABLE_BENCHMARKS)
     glog::glog
     gflags::gflags
     Folly::folly
-    pthread)
+    pthread
+  )
 
   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)
+  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)
+  add_library(
+    velox_spiller_aggregate_benchmark_base
+    AggregateSpillBenchmarkBase.cpp
+    SpillerBenchmarkBase.cpp
+  )
   target_link_libraries(
     velox_spiller_aggregate_benchmark_base
     velox_exec
@@ -303,28 +364,23 @@ if(VELOX_ENABLE_BENCHMARKS)
     glog::glog
     gflags::gflags
     Folly::folly
-    pthread)
+    pthread
+  )
 
-  add_executable(velox_spiller_aggregate_benchmark
-                 SpillerAggregateBenchmarkTest.cpp)
+  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)
+    velox_spiller_aggregate_benchmark
+    velox_exec
+    velox_exec_test_lib
+    velox_spiller_aggregate_benchmark_base
+  )
 endif()
 
-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 OperatorReplacementTest.cpp Main.cpp)
 add_test(
   NAME velox_driver_test
   COMMAND velox_driver_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
-target_link_libraries(
-  velox_driver_test velox_exec velox_exec_test_lib GTest::gtest)
+target_link_libraries(velox_driver_test velox_exec velox_exec_test_lib GTest::gtest)
diff --git a/velox/exec/tests/ColumnStatsCollectorTest.cpp b/velox/exec/tests/ColumnStatsCollectorTest.cpp
new file mode 100644
index 000000000000..250ae45e9203
--- /dev/null
+++ b/velox/exec/tests/ColumnStatsCollectorTest.cpp
@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/core/PlanNode.h"
+#include "velox/duckdb/conversion/DuckParser.h"
+#include "velox/exec/ColumnStatsCollector.h"
+#include "velox/exec/tests/utils/AggregationResolver.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/TypeResolver.h"
+
+namespace facebook::velox::exec::test {
+
+class ColumnStatsCollectorTest : public OperatorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    OperatorTestBase::SetUpTestCase();
+  }
+
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+  }
+
+  core::ColumnStatsSpec createStatsSpec(
+      const RowTypePtr& type,
+      const std::vector<std::string>& groupingKeys,
+      core::AggregationNode::Step step,
+      const std::vector<std::string>& aggregates) {
+    VELOX_CHECK(
+        step == core::AggregationNode::Step::kPartial ||
+            step == core::AggregationNode::Step::kSingle,
+        "Unsupported aggregation step: {}",
+        core::AggregationNode::toName(step));
+
+    std::vector<core::AggregationNode::Aggregate> aggs;
+    aggs.reserve(aggregates.size());
+    std::vector<std::string> names;
+    names.reserve(aggregates.size());
+
+    duckdb::ParseOptions options;
+    options.parseIntegerAsBigint = true;
+    AggregateTypeResolver resolver(step);
+
+    for (auto i = 0; i < aggregates.size(); ++i) {
+      const auto& aggregate = aggregates[i];
+      const auto untypedExpr = duckdb::parseAggregateExpr(aggregate, options);
+
+      core::AggregationNode::Aggregate agg;
+      agg.call = std::dynamic_pointer_cast<const core::CallTypedExpr>(
+          core::Expressions::inferTypes(untypedExpr.expr, type, pool()));
+
+      for (const auto& input : agg.call->inputs()) {
+        agg.rawInputTypes.push_back(input->type());
+      }
+
+      VELOX_CHECK_NULL(untypedExpr.maskExpr);
+      VELOX_CHECK(!untypedExpr.distinct);
+      VELOX_CHECK(untypedExpr.orderBy.empty());
+
+      aggs.emplace_back(agg);
+
+      if (untypedExpr.expr->alias().has_value()) {
+        names.push_back(untypedExpr.expr->alias().value());
+      } else {
+        names.push_back(fmt::format("a{}", i));
+      }
+    }
+    VELOX_CHECK_EQ(aggs.size(), names.size());
+
+    std::vector<core::FieldAccessTypedExprPtr> groupingKeyExprs;
+    groupingKeyExprs.reserve(groupingKeys.size());
+    for (const auto& groupingKey : groupingKeys) {
+      auto untypedGroupingKeyExpr = duckdb::parseExpr(groupingKey, options);
+      auto groupingKeyExpr =
+          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+              core::Expressions::inferTypes(
+                  untypedGroupingKeyExpr, type, pool()));
+      VELOX_CHECK_NOT_NULL(
+          groupingKeyExpr,
+          "Grouping key must use a column name, not an expression: {}",
+          groupingKey);
+      groupingKeyExprs.emplace_back(std::move(groupingKeyExpr));
+    }
+
+    return core::ColumnStatsSpec(
+        std::move(groupingKeyExprs), step, std::move(names), std::move(aggs));
+  }
+
+  // Helper to create test data
+  std::vector<RowVectorPtr> createTestData(
+      const RowTypePtr& rowType,
+      size_t numBatches,
+      size_t batchSize,
+      bool withNulls = false) {
+    VectorFuzzer fuzzer(
+        {.vectorSize = batchSize, .nullRatio = withNulls ? 0.2 : 0.0}, pool());
+    std::vector<RowVectorPtr> batches;
+    batches.reserve(numBatches);
+    for (int i = 0; i < numBatches; ++i) {
+      batches.push_back(fuzzer.fuzzInputRow(rowType));
+    }
+    return batches;
+  }
+
+  std::unique_ptr<ColumnStatsCollector> createStatsCollector(
+      const core::ColumnStatsSpec& statsSpec,
+      const RowTypePtr& inputType) {
+    return std::make_unique<ColumnStatsCollector>(
+        statsSpec, inputType, &queryConfig_, pool(), &nonReclaimableSection_);
+  }
+
+  void verifyResult(
+      const std::vector<RowVectorPtr>& inputBatches,
+      const std::vector<std::string>& groupingKeys,
+      core::AggregationNode::Step step,
+      const std::vector<std::string>& aggregates,
+      const std::vector<RowVectorPtr>& resultBatches) {
+    core::PlanNodePtr plan;
+    if (step == core::AggregationNode::Step::kSingle) {
+      plan = PlanBuilder()
+                 .values(inputBatches)
+                 .singleAggregation(groupingKeys, aggregates)
+                 .planNode();
+    } else {
+      plan = PlanBuilder()
+                 .values(inputBatches)
+                 .partialAggregation(groupingKeys, aggregates)
+                 .planNode();
+    }
+
+    const auto expectedResult = AssertQueryBuilder(plan).copyResults(pool());
+    assertEqualResults(resultBatches, {expectedResult});
+  }
+
+  core::QueryConfig queryConfig_{{}};
+  tsan_atomic<bool> nonReclaimableSection_{false};
+};
+
+TEST_F(ColumnStatsCollectorTest, basic) {
+  const auto inputType =
+      ROW({"c0", "c1", "c2"}, {INTEGER(), DOUBLE(), INTEGER()});
+
+  struct {
+    std::vector<std::string> groupingKeys;
+    std::vector<std::string> aggregates;
+    core::AggregationNode::Step step;
+    bool hasNulls;
+
+    std::string debugString() const {
+      return fmt::format(
+          "groupingKeys: {}, aggregates: {}, {}, hasNulls: {}",
+          folly::join(",", groupingKeys),
+          folly::join(",", aggregates),
+          core::AggregationNode::toName(step),
+          hasNulls);
+    }
+  } testCases[] = {
+      {std::vector<std::string>{},
+       std::vector<std::string>{"sum(c0)", "count(c1)", "sum(c2)"},
+       core::AggregationNode::Step::kSingle,
+       false},
+      {std::vector<std::string>{"c0"},
+       std::vector<std::string>{"count(c1)", "sum(c2)"},
+       core::AggregationNode::Step::kSingle,
+       false},
+      {std::vector<std::string>{},
+       std::vector<std::string>{"sum(c0)", "count(c1)", "sum(c2)"},
+       core::AggregationNode::Step::kPartial,
+       false},
+      {std::vector<std::string>{"c0"},
+       std::vector<std::string>{"count(c1)", "sum(c2)"},
+       core::AggregationNode::Step::kPartial,
+       false},
+      {std::vector<std::string>{},
+       std::vector<std::string>{"sum(c0)", "count(c1)", "sum(c2)"},
+       core::AggregationNode::Step::kSingle,
+       true},
+      {std::vector<std::string>{"c0"},
+       std::vector<std::string>{"count(c1)", "sum(c2)"},
+       core::AggregationNode::Step::kSingle,
+       true},
+      {std::vector<std::string>{},
+       std::vector<std::string>{"sum(c0)", "count(c1)", "sum(c2)"},
+       core::AggregationNode::Step::kPartial,
+       true},
+      {std::vector<std::string>{"c0"},
+       std::vector<std::string>{"count(c1)", "sum(c2)"},
+       core::AggregationNode::Step::kPartial,
+       true},
+      // Multiple grouping keys.
+      {std::vector<std::string>{"c0", "c1"},
+       std::vector<std::string>{"sum(c2)"},
+       core::AggregationNode::Step::kSingle,
+       false},
+      {std::vector<std::string>{"c0", "c1"},
+       std::vector<std::string>{"sum(c2)"},
+       core::AggregationNode::Step::kPartial,
+       false},
+      {std::vector<std::string>{"c0", "c1"},
+       std::vector<std::string>{"sum(c2)"},
+       core::AggregationNode::Step::kSingle,
+       true},
+      {std::vector<std::string>{"c0", "c1"},
+       std::vector<std::string>{"sum(c2)"},
+       core::AggregationNode::Step::kPartial,
+       true}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+
+    // Create stats spec for count and sum
+    auto statsSpec = createStatsSpec(
+        inputType, testCase.groupingKeys, testCase.step, testCase.aggregates);
+
+    // Create collector.
+    auto collector = createStatsCollector(statsSpec, inputType);
+
+    // Create test data.
+    auto inputBatches = createTestData(inputType, 10, 100, testCase.hasNulls);
+    VELOX_ASSERT_THROW(collector->addInput(inputBatches[0]), "");
+
+    // Initialize.
+    collector->initialize();
+
+    // Add input.
+    for (const auto& input : inputBatches) {
+      collector->addInput(input);
+      ASSERT_EQ(collector->getOutput(), nullptr);
+    }
+    ASSERT_FALSE(collector->finished());
+    collector->noMoreInput();
+    ASSERT_FALSE(collector->finished());
+
+    // Get output
+    std::vector<RowVectorPtr> outputBatches;
+    for (;;) {
+      auto output = collector->getOutput();
+      if (output != nullptr) {
+        // Single output row without grouping keys.
+        if (testCase.groupingKeys.empty()) {
+          ASSERT_EQ(output->size(), 1);
+        }
+        ASSERT_EQ(
+            output->childrenSize(),
+            testCase.aggregates.size() + testCase.groupingKeys.size());
+        // Verify column names (using asRowType to access field names)
+        auto rowType = std::dynamic_pointer_cast<const RowType>(output->type());
+        ASSERT_NE(rowType, nullptr);
+        auto outputChannel = testCase.groupingKeys.size();
+        const int numAggregates = testCase.aggregates.size();
+        for (int i = 0; i < numAggregates; ++i) {
+          EXPECT_EQ(
+              rowType->nameOf(outputChannel++), statsSpec.aggregateNames[i]);
+        }
+        outputBatches.push_back(output);
+        EXPECT_FALSE(collector->finished());
+      } else {
+        break;
+      }
+    }
+    // Verify finished.
+    EXPECT_TRUE(collector->finished());
+
+    verifyResult(
+        inputBatches,
+        testCase.groupingKeys,
+        testCase.step,
+        testCase.aggregates,
+        outputBatches);
+  }
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/ConcatFilesSpillMergeStreamTest.cpp b/velox/exec/tests/ConcatFilesSpillMergeStreamTest.cpp
index 57a91976fba6..78218e912667 100644
--- a/velox/exec/tests/ConcatFilesSpillMergeStreamTest.cpp
+++ b/velox/exec/tests/ConcatFilesSpillMergeStreamTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/file/FileSystems.h"
 #include "velox/exec/SortBuffer.h"
 #include "velox/exec/Spill.h"
@@ -21,7 +22,6 @@
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/type/Type.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
-#include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <gtest/gtest.h>
 
@@ -67,7 +67,7 @@ class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
 
   SpillFiles generateSortedSpillFiles(
       const std::vector<RowVectorPtr>& sortedVectors) {
-    const auto spiller = std::make_unique<NoRowContainerSpiller>(
+    const auto spiller = std::make_unique<MergeSpiller>(
         inputType_,
         std::nullopt,
         HashBitRange{},
@@ -99,8 +99,12 @@ class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
       std::vector<std::unique_ptr<SpillReadFile>> spillReadFiles;
       spillReadFiles.reserve(spillFiles.size());
       for (const auto& spillFile : spillFiles) {
-        spillReadFiles.emplace_back(SpillReadFile::create(
-            spillFile, spillConfig_.readBufferSize, pool_.get(), &spillStats_));
+        spillReadFiles.emplace_back(
+            SpillReadFile::create(
+                spillFile,
+                spillConfig_.readBufferSize,
+                pool_.get(),
+                &spillStats_));
       }
       auto stream =
           ConcatFilesSpillMergeStream::create(i - 1, std::move(spillReadFiles));
@@ -196,7 +200,7 @@ class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
        {"c3", VARCHAR()}});
   const std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::hardware_concurrency())};
   const std::vector<column_index_t> sortColumnIndices_{0, 2};
   const std::vector<CompareFlags> sortCompareFlags_{
       CompareFlags{},
@@ -221,6 +225,7 @@ class ConcatFilesSpillMergeStreamTest : public OperatorTestBase {
       0,
       0,
       "none",
+      0,
       std::nullopt};
 
   folly::Synchronized<common::SpillStats> spillStats_;
diff --git a/velox/exec/tests/CprHttpClientTest.cpp b/velox/exec/tests/CprHttpClientTest.cpp
deleted file mode 100644
index 9a19ccaaed24..000000000000
--- a/velox/exec/tests/CprHttpClientTest.cpp
+++ /dev/null
@@ -1,51 +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 <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 7c22ef39a653..3169c79b775f 100644
--- a/velox/exec/tests/DriverTest.cpp
+++ b/velox/exec/tests/DriverTest.cpp
@@ -124,8 +124,9 @@ class DriverTest : public OperatorTestBase {
       bool addTestingPauser = false) {
     std::vector<RowVectorPtr> batches;
     for (int32_t i = 0; i < numBatches; ++i) {
-      batches.push_back(std::dynamic_pointer_cast<RowVector>(
-          BatchMaker::createBatch(rowType, rowsInBatch, *pool_)));
+      batches.push_back(
+          std::dynamic_pointer_cast<RowVector>(
+              BatchMaker::createBatch(rowType, rowsInBatch, *pool_)));
     }
     if (filterFunc) {
       int32_t hits = 0;
@@ -468,10 +469,11 @@ 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()
-                  .within(std::chrono::microseconds(1'000'000))
-                  .isReady());
+  EXPECT_TRUE(
+      tasks_[0]
+          ->taskCompletionFuture()
+          .within(std::chrono::microseconds(1'000'000))
+          .isReady());
   EXPECT_EQ(tasks_[0]->state(), TaskState::kFailed);
 }
 
@@ -799,8 +801,9 @@ TEST_F(DriverTest, pauserNode) {
   // all its Tasks in the test instance to create inter-Task pauses.
   static DriverTest* testInstance;
   testInstance = this;
-  Operator::registerOperator(std::make_unique<PauserNodeFactory>(
-      kThreadsPerTask, sequence, testInstance));
+  Operator::registerOperator(
+      std::make_unique<PauserNodeFactory>(
+          kThreadsPerTask, sequence, testInstance));
 
   std::vector<CursorParameters> params(kNumTasks);
   int32_t hits{0};
@@ -1144,6 +1147,43 @@ TEST_F(DriverTest, nonVeloxOperatorException) {
       "Operator::getOutput failed for [operator: Throw, plan node ID: 1]");
 }
 
+TEST_F(DriverTest, enableOperatorBatchSizeStatsConfig) {
+  CursorParameters params;
+  int32_t hits;
+  params.planNode = makeValuesFilterProject(
+      rowType_,
+      "m1 % 10 > 0",
+      "m1 % 3 + m2 % 5 + m3 % 7 + m4 % 11 + m5 % 13 + m6 % 17 + m7 % 19",
+      100,
+      1'000,
+      [](int64_t num) { return num % 10 > 0; },
+      &hits);
+  params.maxDrivers = 4;
+  std::unordered_map<std::string, std::string> queryConfig{
+      {core::QueryConfig::kEnableOperatorBatchSizeStats, "true"}};
+  params.queryCtx = core::QueryCtx::create(
+      executor_.get(), core::QueryConfig(std::move(queryConfig)));
+  int32_t numRead = 0;
+  readResults(params, ResultOperation::kRead, 1'000'000, &numRead);
+  EXPECT_EQ(numRead, 4 * hits);
+  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();
+  EXPECT_TRUE(tasks_[0]->isFinished());
+  EXPECT_EQ(tasks_[0]->numRunningDrivers(), 0);
+  const auto taskStats = tasks_[0]->taskStats();
+  ASSERT_EQ(taskStats.pipelineStats.size(), 1);
+  const auto& operatorStats = taskStats.pipelineStats[0].operatorStats;
+  EXPECT_GT(operatorStats[1].getOutputTiming.wallNanos, 0);
+  EXPECT_EQ(operatorStats[0].outputPositions, 400'000);
+  EXPECT_GT(operatorStats[0].outputBytes, 0);
+  EXPECT_EQ(operatorStats[1].inputPositions, 400'000);
+  EXPECT_EQ(operatorStats[1].outputPositions, 4 * hits);
+  EXPECT_GT(operatorStats[1].outputBytes, 0);
+}
+
 DEBUG_ONLY_TEST_F(DriverTest, driverSuspensionRaceWithTaskPause) {
   struct {
     int numDrivers;
@@ -1577,7 +1617,8 @@ DEBUG_ONLY_TEST_F(DriverTest, driverCpuTimeSlicingCheck) {
           0,
           core::QueryCtx::create(
               driverExecutor_.get(), core::QueryConfig{std::move(queryConfig)}),
-          testParam.executionMode);
+          testParam.executionMode,
+          exec::Consumer{});
       while (task->next() != nullptr) {
       }
     }
diff --git a/velox/exec/tests/ExchangeClientTest.cpp b/velox/exec/tests/ExchangeClientTest.cpp
index 86883d2519de..18b0db75bac7 100644
--- a/velox/exec/tests/ExchangeClientTest.cpp
+++ b/velox/exec/tests/ExchangeClientTest.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/exec/ExchangeClient.h"
 #include <folly/ScopeGuard.h>
 #include <gtest/gtest.h>
 #include <atomic>
@@ -90,7 +91,8 @@ class ExchangeClientTest
         core::PlanFragment{plan},
         0,
         std::move(queryCtx),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
   }
 
   int32_t enqueue(
@@ -107,9 +109,9 @@ class ExchangeClientTest
     return pageSize;
   }
 
-  std::vector<std::unique_ptr<SerializedPage>>
+  std::vector<std::unique_ptr<SerializedPageBase>>
   fetchPages(int consumerId, ExchangeClient& client, int32_t numPages) {
-    std::vector<std::unique_ptr<SerializedPage>> allPages;
+    std::vector<std::unique_ptr<SerializedPageBase>> allPages;
     for (auto i = 0; i < numPages; ++i) {
       bool atEnd{false};
       ContinueFuture future;
@@ -137,7 +139,7 @@ class ExchangeClientTest
 
   static void enqueue(
       ExchangeQueue& queue,
-      std::unique_ptr<SerializedPage> page) {
+      std::unique_ptr<SerializedPageBase> page) {
     std::vector<ContinuePromise> promises;
     {
       std::lock_guard<std::mutex> l(queue.mutex());
@@ -148,10 +150,10 @@ class ExchangeClientTest
     }
   }
 
-  static std::unique_ptr<SerializedPage> makePage(uint64_t size) {
+  static std::unique_ptr<SerializedPageBase> makePage(uint64_t size) {
     auto ioBuf = folly::IOBuf::create(size);
     ioBuf->append(size);
-    return std::make_unique<SerializedPage>(std::move(ioBuf), nullptr, 1);
+    return std::make_unique<PrestoSerializedPage>(std::move(ioBuf), nullptr, 1);
   }
 
   folly::Executor* executor() const {
@@ -587,7 +589,7 @@ TEST_P(ExchangeClientTest, acknowledge) {
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::test::LocalExchangeSource::pause",
       std::function<void(void*)>(([&numberOfAcknowledgeRequests](void*) {
-        numberOfAcknowledgeRequests++;
+        ++numberOfAcknowledgeRequests;
       })));
 
   {
@@ -608,10 +610,11 @@ TEST_P(ExchangeClientTest, acknowledge) {
     client->addRemoteTaskId(sourceTaskId);
     client->noMoreRemoteTasks();
 
-    ASSERT_TRUE(std::move(future)
-                    .via(executor())
-                    .wait(std::chrono::seconds{10})
-                    .isReady());
+    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
@@ -662,7 +665,7 @@ TEST_P(ExchangeClientTest, acknowledge) {
     int attempts = 100;
     bool outputBuffersEmpty;
     while (attempts > 0) {
-      attempts--;
+      --attempts;
       outputBuffersEmpty = bufferManager_->getUtilization(sourceTaskId) == 0;
       if (outputBuffersEmpty) {
         break;
@@ -688,10 +691,11 @@ TEST_P(ExchangeClientTest, acknowledge) {
   pages = client->next(1, 1, &atEnd, &dequeueEndOfDataFuture);
   ASSERT_EQ(0, pages.size());
 
-  ASSERT_TRUE(std::move(dequeueEndOfDataFuture)
-                  .via(executor())
-                  .wait(std::chrono::seconds{10})
-                  .isReady());
+  ASSERT_TRUE(
+      std::move(dequeueEndOfDataFuture)
+          .via(executor())
+          .wait(std::chrono::seconds{10})
+          .isReady());
   pages = client->next(1, 1, &atEnd, &dequeueEndOfDataFuture);
   ASSERT_EQ(0, pages.size());
   ASSERT_TRUE(atEnd);
@@ -975,13 +979,193 @@ TEST_P(ExchangeClientTest, minOutputBatchBytesMultipleConsumers) {
   client->close();
 }
 
+TEST_P(ExchangeClientTest, skipRequestDataSizeWithSingleSource) {
+  // Test skipRequestDataSizeWithSingleSource flag behavior
+
+  struct {
+    bool skipEnabled;
+
+    std::string debugString() const {
+      return fmt::format("skipEnabled={}", skipEnabled);
+    }
+  } testSettings[] = {
+      // skip enabled
+      {true},
+      // skip disabled
+      {false}};
+
+  for (const auto& setting : testSettings) {
+    SCOPED_TRACE(setting.debugString());
+
+    auto client = std::make_shared<ExchangeClient>(
+        "test-" + setting.debugString(),
+        17,
+        1024,
+        1,
+        kDefaultMinExchangeOutputBatchBytes,
+        pool(),
+        executor(),
+        10,
+        setting.skipEnabled);
+
+    client->close();
+  }
+}
+
+TEST_P(ExchangeClientTest, skipRequestDataSizeNotTriggeredWithMultipleSources) {
+  // Test that optimization is NOT triggered with multiple sources
+
+  auto data = makeRowVector({makeFlatVector<int64_t>(100, folly::identity)});
+  auto page = test::toSerializedPage(data, serdeKind_, bufferManager_, pool());
+
+  // Client with optimization ENABLED but multiple sources
+  auto client = std::make_shared<ExchangeClient>(
+      "test-multi-source",
+      17,
+      page->size() * 10,
+      1,
+      kDefaultMinExchangeOutputBatchBytes,
+      pool(),
+      executor(),
+      10,
+      // enableSingleSourceOptimization = true (but won't trigger with
+      // multiple sources)
+      true);
+
+  // Setup: Create tasks with TWO sources
+  std::vector<std::shared_ptr<Task>> tasks;
+  for (int i = 0; i < 2; ++i) {
+    auto taskId = fmt::format("local://test-source-{}", i);
+    auto task = makeTask(taskId);
+    bufferManager_->initializeTask(
+        task, core::PartitionedOutputNode::Kind::kPartitioned, 100, 16);
+
+    // Enqueue data
+    for (int j = 0; j < 3; ++j) {
+      enqueue(taskId, 17, data);
+    }
+
+    tasks.push_back(task);
+    client->addRemoteTaskId(taskId);
+  }
+
+  client->noMoreRemoteTasks();
+
+  // Fetch pages - should work with regular path (not single source
+  // optimization)
+  // 3 pages from each of 2 sources
+  auto pages = fetchPages(1, *client, 6);
+  ASSERT_EQ(pages.size(), 6);
+
+  // Cleanup
+  for (auto& task : tasks) {
+    task->requestCancel();
+    bufferManager_->removeTask(task->taskId());
+  }
+
+  client->close();
+}
+
+// Test that lazyFetching=true defers data fetching until next() is called.
+// When lazyFetching=false (default), fetching starts immediately when remote
+// tasks are added via pickSourcesToRequestLocked(). When lazyFetching=true,
+// pickSourcesToRequestLocked() is not called in addRemoteTaskId(), deferring
+// the fetch until next() is called. This is useful for cached hash table
+// scenarios where waiter tasks may not need the data if the table is already
+// cached.
+TEST_P(ExchangeClientTest, lazyFetching) {
+  auto data = makeRowVector({makeFlatVector<int32_t>({1, 2, 3, 4, 5})});
+
+  // Test with lazyFetching=false (default behavior).
+  // Verify that fetching starts and we can retrieve pages normally.
+  {
+    auto taskId = "local://eager-fetching-test";
+    auto task = makeTask(taskId);
+
+    bufferManager_->initializeTask(
+        task, core::PartitionedOutputNode::Kind::kPartitioned, 100, 16);
+
+    auto client = std::make_shared<ExchangeClient>(
+        "t",
+        17,
+        ExchangeClient::kDefaultMaxQueuedBytes,
+        1,
+        kDefaultMinExchangeOutputBatchBytes,
+        pool(),
+        executor(),
+        10, // requestDataSizesMaxWaitSec
+        false, // skipRequestDataSizeWithSingleSource
+        false); // lazyFetching=false (default)
+
+    client->addRemoteTaskId(taskId);
+    enqueue(taskId, 17, data);
+
+    auto pages = fetchPages(1, *client, 1);
+    ASSERT_EQ(1, pages.size());
+
+    task->requestCancel();
+    bufferManager_->removeTask(taskId);
+    client->close();
+  }
+
+  // Test with lazyFetching=true.
+  // Verify that we can still retrieve pages (fetch is triggered by next()).
+  {
+    auto taskId = "local://lazy-fetching-test";
+    auto task = makeTask(taskId);
+
+    bufferManager_->initializeTask(
+        task, core::PartitionedOutputNode::Kind::kPartitioned, 100, 16);
+
+    auto client = std::make_shared<ExchangeClient>(
+        "t",
+        17,
+        ExchangeClient::kDefaultMaxQueuedBytes,
+        1,
+        kDefaultMinExchangeOutputBatchBytes,
+        pool(),
+        executor(),
+        10, // requestDataSizesMaxWaitSec
+        false, // skipRequestDataSizeWithSingleSource
+        true); // lazyFetching=true
+
+    client->addRemoteTaskId(taskId);
+    enqueue(taskId, 17, data);
+
+    // Even with lazy fetching, we should be able to retrieve pages
+    // since next() triggers the fetch.
+    auto pages = fetchPages(1, *client, 1);
+    ASSERT_EQ(1, pages.size());
+
+    task->requestCancel();
+    bufferManager_->removeTask(taskId);
+    client->close();
+  }
+}
+
+// Test the new hasNoMoreSources() API
+TEST_P(ExchangeClientTest, hasNoMoreSourcesApi) {
+  auto queue = std::make_shared<ExchangeQueue>(1, 0);
+
+  // Initially, should return false
+  EXPECT_FALSE(queue->hasNoMoreSources());
+
+  // After calling noMoreSources(), should return true
+  queue->noMoreSources();
+
+  EXPECT_TRUE(queue->hasNoMoreSources());
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     ExchangeClientTest,
     ExchangeClientTest,
     testing::Values(
         VectorSerde::Kind::kPresto,
         VectorSerde::Kind::kCompactRow,
-        VectorSerde::Kind::kUnsafeRow));
+        VectorSerde::Kind::kUnsafeRow),
+    [](const testing::TestParamInfo<VectorSerde::Kind>& info) {
+      return fmt::format("{}", info.param);
+    });
 
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/ExpandTest.cpp b/velox/exec/tests/ExpandTest.cpp
index f541d20c04a5..d1161b374fc7 100644
--- a/velox/exec/tests/ExpandTest.cpp
+++ b/velox/exec/tests/ExpandTest.cpp
@@ -21,7 +21,6 @@ using namespace facebook::velox;
 using namespace facebook::velox::exec::test;
 
 namespace facebook::velox::exec {
-
 namespace {
 class ExpandTest : public OperatorTestBase {
  public:
@@ -37,7 +36,31 @@ class ExpandTest : public OperatorTestBase {
         });
   }
 };
-} // anonymous namespace
+
+TEST_F(ExpandTest, complexConstant) {
+  auto data = makeRowVectorData(3);
+  auto children = data->children();
+  auto arrayVector =
+      makeArrayVector<int32_t>({{1, 2, 3}, {1, 2, 3}, {1, 2, 3}});
+  children.push_back(arrayVector);
+  children.push_back(makeAllNullArrayVector(3, INTEGER()));
+  children.push_back(makeNullConstant(TypeKind::INTEGER, 3));
+  auto expected = makeRowVector(children);
+
+  auto plan = PlanBuilder(pool())
+                  .values({data})
+                  .expand(
+                      {{"k1",
+                        "k2",
+                        "a",
+                        "b",
+                        "ARRAY[1, 2, 3] as c",
+                        "null::integer[] as d",
+                        "null::integer as e"}})
+                  .planNode();
+
+  assertQuery(plan, expected);
+}
 
 TEST_F(ExpandTest, groupingSets) {
   auto data = makeRowVectorData(1'000);
@@ -151,4 +174,5 @@ TEST_F(ExpandTest, invalidUseCases) {
       "projections must not be empty.");
 }
 
+} // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/ExpressionBuilderTest.cpp b/velox/exec/tests/ExpressionBuilderTest.cpp
new file mode 100644
index 000000000000..084d3275d115
--- /dev/null
+++ b/velox/exec/tests/ExpressionBuilderTest.cpp
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/ExpressionBuilder.h"
+
+#include <gtest/gtest.h>
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::expr_builder::test {
+namespace {
+
+// Test convenience functions for downcasting.
+template <typename T>
+std::shared_ptr<const T> as(detail::ExprWrapper in) {
+  return std::dynamic_pointer_cast<const T>(in.expr());
+}
+
+template <typename T>
+bool is(detail::ExprWrapper in) {
+  return std::dynamic_pointer_cast<const T>(in.expr()) != nullptr;
+}
+
+// Parses a SQL expression using DuckDB.
+core::ExprPtr parseSql(const std::string& sql) {
+  return parse::parseExpr(sql, {});
+}
+
+TEST(ExpressionBuilderTest, columnReference) {
+  EXPECT_EQ(col("c0"), parseSql("c0"));
+  EXPECT_EQ(parseSql("c0"), col("c0"));
+  EXPECT_EQ("c0"_c, parseSql("c0"));
+
+  EXPECT_EQ(col("parent", "child"), parseSql("parent.child"));
+  EXPECT_EQ(col("parent").subfield("child"), parseSql("parent.child"));
+}
+
+TEST(ExpressionBuilderTest, literals) {
+  auto validate = [](detail::ExprWrapper expr,
+                     const TypePtr& expectedType,
+                     variant expectedValue) {
+    EXPECT_TRUE(is<core::ConstantExpr>(expr));
+    auto constant = as<core::ConstantExpr>(expr);
+    EXPECT_EQ(*constant->type(), *expectedType);
+    EXPECT_TRUE(constant->value().equalsWithEpsilon(expectedValue));
+  };
+
+  // Integer literal types.
+  validate(lit(123456L), BIGINT(), variant(123456L));
+  validate(lit(123), INTEGER(), variant(123));
+  validate(lit(int16_t(123)), SMALLINT(), variant(int16_t(123)));
+  validate(lit(int8_t(123)), TINYINT(), variant(int8_t(123)));
+
+  // Boolean.
+  validate(lit(true), BOOLEAN(), variant(true));
+  validate(lit(false), BOOLEAN(), variant(false));
+
+  // Floating point.
+  validate(lit(10.1f), REAL(), variant(10.1f));
+  validate(lit(10.1), DOUBLE(), variant(10.1));
+
+  // String.
+  validate(lit("str"), VARCHAR(), variant("str"));
+
+  // Null.
+  validate(lit(nullptr), UNKNOWN(), variant::null(TypeKind::UNKNOWN));
+}
+
+TEST(ExpressionBuilderTest, comparisons) {
+  // Make sure all combinations work, as long as at least one side is a
+  // ExprWrapper.
+  EXPECT_EQ(col("a") == lit(10L), parseSql("a = 10"));
+  EXPECT_EQ(lit(10L) == col("a"), parseSql("10 = a"));
+
+  EXPECT_EQ(col("a") == 10L, parseSql("a = 10"));
+  EXPECT_EQ(10L == col("a"), parseSql("10 = a"));
+
+  EXPECT_EQ(col("a") == col("b"), parseSql("a = b"));
+  EXPECT_EQ(col("a") == nullptr, parseSql("a = null"));
+
+  // Other comparisons.
+  EXPECT_EQ(col("a") != 1.1, parseSql("a != 1.1"));
+  EXPECT_EQ(col("a") != lit(1.1), parseSql("a != 1.1"));
+  EXPECT_EQ(col("a") > 42L, parseSql("a > 42"));
+  EXPECT_EQ(col("a") >= 42L, parseSql("a >= 42"));
+  EXPECT_EQ(col("a") < 42L, parseSql("a < 42"));
+  EXPECT_EQ(col("a") <= 42L, parseSql("a <= 42"));
+
+  EXPECT_EQ(!col("a"), parseSql("not a"));
+  EXPECT_EQ(isNull(col("a")), parseSql("a is null"));
+  EXPECT_EQ(col("a").isNull(), parseSql("a is null"));
+  EXPECT_EQ(!isNull(col("a")), parseSql("a is not null"));
+  EXPECT_EQ(!col("a").isNull(), parseSql("a is not null"));
+
+  EXPECT_EQ(isNull("a"), parseSql("\'a\' is null")); // this is "a" literal.
+}
+
+TEST(ExpressionBuilderTest, between) {
+  EXPECT_EQ(between(col("a"), 0L, 10L), parseSql("a between 0 and 10"));
+
+  EXPECT_EQ(col("a").between(0L, 10L), parseSql("a between 0 and 10"));
+}
+
+TEST(ExpressionBuilderTest, arithmetics) {
+  EXPECT_EQ(col("b") + 1L, parseSql("b + 1"));
+  EXPECT_EQ(1L + col("b"), parseSql("1 + b"));
+  EXPECT_EQ(lit("str") + col("b"), parseSql("'str' + b"));
+
+  EXPECT_EQ(col("b") - 1L, parseSql("b - 1"));
+  EXPECT_EQ(col("b") * 1L, parseSql("b * 1"));
+  EXPECT_EQ(col("b") / 1L, parseSql("b / 1"));
+  EXPECT_EQ(col("b") % 1L, parseSql("b % 1"));
+
+  EXPECT_EQ(col("b") + 1L / col("c") * 10L, parseSql("b + 1 / c * 10"));
+}
+
+TEST(ExpressionBuilderTest, conjuncts) {
+  EXPECT_EQ(col("b") && 1L, parseSql("b and 1"));
+  EXPECT_EQ(col("b") || 1L, parseSql("b or 1"));
+  EXPECT_EQ(col("b") || false, parseSql("b or false"));
+
+  EXPECT_EQ(col("a") && col("b") || col("c"), parseSql("a and b or c"));
+}
+
+TEST(ExpressionBuilderTest, functions) {
+  EXPECT_EQ(call("func"), parseSql("func()"));
+  EXPECT_EQ(
+      call("func", col("a"), 100L, col("c")), parseSql("func(a, 100, c)"));
+
+  // Nested functions.
+  auto expr = call("f1", call("f2", col("a") > call("f3", col("d"))));
+  EXPECT_EQ(expr, parseSql("f1(f2(a > f3(d)))"));
+
+  expr = 10L * col("c1") > call("func", 3.4, col("g") / col("h"), call("j"));
+  EXPECT_EQ(expr, parseSql("10 * c1 > func(3.4, g / h, j())"));
+}
+
+TEST(ExpressionBuilderTest, casts) {
+  // Casts.
+  EXPECT_EQ(lit("1").cast(TINYINT()).toString(), "cast(1 as TINYINT)");
+  EXPECT_EQ(
+      col("c0").cast(VARBINARY()).toString(), "cast(\"c0\" as VARBINARY)");
+
+  EXPECT_EQ(cast(1, TINYINT()).toString(), "cast(1 as TINYINT)");
+  EXPECT_EQ(
+      cast(col("c0"), VARBINARY()).toString(), "cast(\"c0\" as VARBINARY)");
+
+  // Try casts.
+  EXPECT_EQ(lit("1").tryCast(TINYINT()).toString(), "try_cast(1 as TINYINT)");
+  EXPECT_EQ(
+      col("c0").tryCast(VARBINARY()).toString(),
+      "try_cast(\"c0\" as VARBINARY)");
+
+  EXPECT_EQ(tryCast(1, TINYINT()).toString(), "try_cast(1 as TINYINT)");
+  EXPECT_EQ(
+      tryCast(col("c0"), VARBINARY()).toString(),
+      "try_cast(\"c0\" as VARBINARY)");
+}
+
+TEST(ExpressionBuilderTest, alias) {
+  EXPECT_EQ(lit("str").alias("col"), parseSql("'str' as col"));
+  EXPECT_EQ(col("c1").alias("col"), parseSql("c1 as col"));
+  EXPECT_EQ((col("c1") > 1.1).alias("col"), parseSql("c1 > 1.1 as col"));
+
+  EXPECT_EQ(
+      col("c1").between(1L, 10L).alias("my_col"),
+      parseSql("c1 between 1 and 10 as my_col"));
+
+  // As a free function.
+  EXPECT_EQ(alias(col("c1") == "bla", "col"), parseSql("c1 = 'bla' as col"));
+}
+
+TEST(ExpressionBuilderTest, lambdas) {
+  EXPECT_EQ(lambda("x", 1L), parseSql("x -> 1"));
+  EXPECT_EQ(lambda({"x"}, 1L), parseSql("x -> 1"));
+  EXPECT_EQ(lambda({"x"}, col("x") + 1L), parseSql("x -> x + 1"));
+  EXPECT_EQ(
+      lambda({"x", "y"}, col("x") * col("y")), parseSql("(x, y) -> x * y"));
+}
+
+} // namespace
+} // namespace facebook::velox::expr_builder::test
diff --git a/velox/exec/tests/FilterProjectTest.cpp b/velox/exec/tests/FilterProjectTest.cpp
index 9d7f2e8f172a..87d21381d37a 100644
--- a/velox/exec/tests/FilterProjectTest.cpp
+++ b/velox/exec/tests/FilterProjectTest.cpp
@@ -17,17 +17,12 @@
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.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;
+namespace facebook::velox::exec {
+namespace {
 
-using facebook::velox::test::BatchMaker;
-
-class FilterProjectTest : public HiveConnectorTestBase {
+class FilterProjectTest : public test::HiveConnectorTestBase {
  protected:
   void SetUp() override {
     HiveConnectorTestBase::SetUp();
@@ -37,7 +32,7 @@ class FilterProjectTest : public HiveConnectorTestBase {
       const std::vector<RowVectorPtr>& vectors,
       const std::string& filter = "c1 % 10  > 0") {
     core::PlanNodePtr filterNode;
-    auto plan = PlanBuilder()
+    auto plan = test::PlanBuilder()
                     .values(vectors)
                     .filter(filter)
                     .capturePlanNode(filterNode)
@@ -49,7 +44,7 @@ class FilterProjectTest : public HiveConnectorTestBase {
 
   void assertProject(const std::vector<RowVectorPtr>& vectors) {
     core::PlanNodePtr projectNode;
-    auto plan = PlanBuilder()
+    auto plan = test::PlanBuilder()
                     .values(vectors)
                     .project({"c0", "c1", "c0 + c1"})
                     .capturePlanNode(projectNode)
@@ -64,49 +59,50 @@ class FilterProjectTest : public HiveConnectorTestBase {
     auto projectNodeId = plan->id();
     auto it = planStats.find(projectNodeId);
     ASSERT_TRUE(it != planStats.end());
-    ASSERT_TRUE(it->second.peakMemoryBytes > 0);
+    ASSERT_GT(it->second.peakMemoryBytes, 0);
+  }
+
+  RowVectorPtr makeTestVector(vector_size_t size = 100) const {
+    auto rowType = ROW(
+        {"c0", "c1", "c2", "c3"}, {BIGINT(), INTEGER(), SMALLINT(), DOUBLE()});
+
+    return std::dynamic_pointer_cast<RowVector>(
+        velox::test::BatchMaker::createBatch(rowType, size, *pool_));
   }
 
-  std::shared_ptr<const RowType> rowType_{
-      ROW({"c0", "c1", "c2", "c3"},
-          {BIGINT(), INTEGER(), SMALLINT(), DOUBLE()})};
+  std::vector<RowVectorPtr> makeTestVectors() const {
+    std::vector<RowVectorPtr> vectors;
+    vectors.reserve(10);
+    for (int32_t i = 0; i < 10; ++i) {
+      vectors.push_back(makeTestVector());
+    }
+    return vectors;
+  }
 };
 
 TEST_F(FilterProjectTest, filter) {
-  std::vector<RowVectorPtr> vectors;
-  for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
-    vectors.push_back(vector);
-  }
+  auto vectors = makeTestVectors();
   createDuckDbTable(vectors);
-
   assertFilter(vectors);
 }
 
 TEST_F(FilterProjectTest, filterOverDictionary) {
   std::vector<RowVectorPtr> vectors;
   for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
-
-    auto indices =
-        AlignedBuffer::allocate<int32_t>(2 * vector->size(), pool_.get());
-    auto indicesPtr = indices->asMutable<int32_t>();
-    for (int32_t j = 0; j < vector->size() / 2; j++) {
-      indicesPtr[2 * j] = j;
-      indicesPtr[2 * j + 1] = j;
+    auto vector = makeTestVector();
+
+    auto indices = allocateIndices(2 * vector->size(), pool_.get());
+    auto rawIndices = indices->asMutable<int32_t>();
+    for (int32_t j = 0; j < vector->size(); j += 2) {
+      rawIndices[j] = j / 2;
+      rawIndices[j + 1] = j / 2;
     }
-    std::vector<VectorPtr> newChildren = vector->children();
-    newChildren[1] = BaseVector::wrapInDictionary(
-        BufferPtr(nullptr), indices, vector->size(), vector->childAt(1));
-    vectors.push_back(std::make_shared<RowVector>(
-        pool_.get(),
-        rowType_,
-        BufferPtr(nullptr),
-        vector->size(),
-        newChildren,
-        0 /*nullCount*/));
+
+    auto newChildren = vector->children();
+    newChildren[1] =
+        wrapInDictionary(indices, vector->size(), vector->childAt(1));
+
+    vectors.push_back(makeRowVector(newChildren));
   }
   createDuckDbTable(vectors);
 
@@ -116,19 +112,13 @@ TEST_F(FilterProjectTest, filterOverDictionary) {
 TEST_F(FilterProjectTest, filterOverConstant) {
   std::vector<RowVectorPtr> vectors;
   for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
+    auto vector = makeTestVector();
 
     std::vector<VectorPtr> newChildren = vector->children();
     newChildren[1] =
         BaseVector::wrapInConstant(vector->size(), 7, vector->childAt(1));
-    vectors.push_back(std::make_shared<RowVector>(
-        pool_.get(),
-        rowType_,
-        BufferPtr(nullptr),
-        vector->size(),
-        newChildren,
-        0 /*nullCount*/));
+
+    vectors.push_back(makeRowVector(newChildren));
   }
   createDuckDbTable(vectors);
 
@@ -136,40 +126,27 @@ TEST_F(FilterProjectTest, filterOverConstant) {
 }
 
 TEST_F(FilterProjectTest, project) {
-  std::vector<RowVectorPtr> vectors;
-  for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
-    vectors.push_back(vector);
-  }
+  auto vectors = makeTestVectors();
   createDuckDbTable(vectors);
-
   assertProject(vectors);
 }
 
 TEST_F(FilterProjectTest, projectOverDictionary) {
   std::vector<RowVectorPtr> vectors;
   for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
-
-    auto indices =
-        AlignedBuffer::allocate<int32_t>(2 * vector->size(), pool_.get());
-    auto indicesPtr = indices->asMutable<int32_t>();
-    for (int32_t j = 0; j < vector->size() / 2; j++) {
-      indicesPtr[2 * j] = j;
-      indicesPtr[2 * j + 1] = j;
+    auto vector = makeTestVector();
+
+    auto indices = allocateIndices(2 * vector->size(), pool_.get());
+    auto rawIndices = indices->asMutable<int32_t>();
+    for (int32_t j = 0; j < vector->size(); j += 2) {
+      rawIndices[j] = j / 2;
+      rawIndices[j + 1] = j / 2;
     }
+
     std::vector<VectorPtr> newChildren = vector->children();
-    newChildren[1] = BaseVector::wrapInDictionary(
-        BufferPtr(nullptr), indices, vector->size(), vector->childAt(1));
-    vectors.push_back(std::make_shared<RowVector>(
-        pool_.get(),
-        rowType_,
-        BufferPtr(nullptr),
-        vector->size(),
-        newChildren,
-        0 /*nullCount*/));
+    newChildren[1] =
+        wrapInDictionary(indices, vector->size(), vector->childAt(1));
+    vectors.push_back(makeRowVector(newChildren));
   }
   createDuckDbTable(vectors);
 
@@ -179,19 +156,12 @@ TEST_F(FilterProjectTest, projectOverDictionary) {
 TEST_F(FilterProjectTest, projectOverConstant) {
   std::vector<RowVectorPtr> vectors;
   for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
+    auto vector = makeTestVector();
 
     std::vector<VectorPtr> newChildren = vector->children();
     newChildren[1] =
         BaseVector::wrapInConstant(vector->size(), 7, vector->childAt(1));
-    vectors.push_back(std::make_shared<RowVector>(
-        pool_.get(),
-        rowType_,
-        BufferPtr(nullptr),
-        vector->size(),
-        newChildren,
-        0 /*nullCount*/));
+    vectors.push_back(makeRowVector(newChildren));
   }
   createDuckDbTable(vectors);
 
@@ -218,7 +188,7 @@ TEST_F(FilterProjectTest, projectOverLazy) {
 
   createDuckDbTable({vectors});
 
-  auto plan = PlanBuilder()
+  auto plan = test::PlanBuilder()
                   .values({lazyVectors})
                   .project({"c0 > 0 AND c1 > 0.0", "c1 + 5.2"})
                   .planNode();
@@ -226,15 +196,10 @@ TEST_F(FilterProjectTest, projectOverLazy) {
 }
 
 TEST_F(FilterProjectTest, filterProject) {
-  std::vector<RowVectorPtr> vectors;
-  for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
-    vectors.push_back(vector);
-  }
+  auto vectors = makeTestVectors();
   createDuckDbTable(vectors);
 
-  auto plan = PlanBuilder()
+  auto plan = test::PlanBuilder()
                   .values(vectors)
                   .filter("c1 % 10  > 0")
                   .project({"c0", "c1", "c0 + c1"})
@@ -244,22 +209,17 @@ TEST_F(FilterProjectTest, filterProject) {
 }
 
 TEST_F(FilterProjectTest, dereference) {
-  std::vector<RowVectorPtr> vectors;
-  for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
-    vectors.push_back(vector);
-  }
+  auto vectors = makeTestVectors();
   createDuckDbTable(vectors);
 
-  auto plan = PlanBuilder()
+  auto plan = test::PlanBuilder()
                   .values(vectors)
                   .project({"row_constructor(c1, c2) AS c1_c2"})
                   .project({"c1_c2.c1", "c1_c2.c2"})
                   .planNode();
   assertQuery(plan, "SELECT c1, c2 FROM tmp");
 
-  plan = PlanBuilder()
+  plan = test::PlanBuilder()
              .values(vectors)
              .project({"row_constructor(c1, c2) AS c1_c2"})
              .filter("c1_c2.c1 % 10 = 5")
@@ -291,15 +251,10 @@ TEST_F(FilterProjectTest, allFailedOrPassed) {
 
 // Tests fusing of consecutive filters and projects.
 TEST_F(FilterProjectTest, filterProjectFused) {
-  std::vector<RowVectorPtr> vectors;
-  for (int32_t i = 0; i < 10; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, 100, *pool_));
-    vectors.push_back(vector);
-  }
+  auto vectors = makeTestVectors();
   createDuckDbTable(vectors);
 
-  auto plan = PlanBuilder()
+  auto plan = test::PlanBuilder()
                   .values(vectors)
                   .filter("c0 % 10 < 9")
                   .project({"c0", "c1", "c0 % 100 + c1 % 50 AS e1"})
@@ -332,7 +287,7 @@ TEST_F(FilterProjectTest, projectAndIdentityOverLazy) {
 
   createDuckDbTable({vectors});
 
-  auto plan = PlanBuilder()
+  auto plan = test::PlanBuilder()
                   .values({lazyVectors})
                   .project({"c0 < 10 AND c1 < 10", "c1"})
                   .planNode();
@@ -350,7 +305,7 @@ TEST_F(FilterProjectTest, nestedFieldReferenceSharedChild) {
       }),
   });
   auto plan =
-      PlanBuilder()
+      test::PlanBuilder()
           .values({vector})
           .project({"coalesce((c0).c0.c0, 0) + coalesce((c0).c1.c0, 0)"})
           .planNode();
@@ -358,22 +313,21 @@ TEST_F(FilterProjectTest, nestedFieldReferenceSharedChild) {
   for (int i = 0; i < 10; ++i) {
     expected->set(i, (i % 2 == 0 ? 0 : i) + (i % 3 == 0 ? 0 : i));
   }
-  AssertQueryBuilder(plan).assertResults(makeRowVector({expected}));
+  test::AssertQueryBuilder(plan).assertResults(makeRowVector({expected}));
 }
 
 TEST_F(FilterProjectTest, numSilentThrow) {
-  auto row = makeRowVector(
-      {makeFlatVector<int32_t>(100, [&](auto row) { return row; })});
+  auto row = makeRowVector({makeFlatVector<int32_t>(100, folly::identity)});
 
   core::PlanNodeId filterId;
   // Change the plan when /0 error is fixed not to throw.
-  auto plan = PlanBuilder()
+  auto plan = test::PlanBuilder()
                   .values({row})
                   .filter("try (c0 / 0) = 1")
                   .capturePlanNodeId(filterId)
                   .planNode();
 
-  auto task = AssertQueryBuilder(plan).assertEmptyResults();
+  auto task = test::AssertQueryBuilder(plan).assertEmptyResults();
   auto planStats = toPlanStats(task->taskStats());
   ASSERT_EQ(100, planStats.at(filterId).customStats.at("numSilentThrow").sum);
 }
@@ -388,7 +342,7 @@ TEST_F(FilterProjectTest, statsSplitter) {
   // row.
   core::PlanNodeId filterId;
   core::PlanNodeId projectId;
-  auto plan = PlanBuilder()
+  auto plan = test::PlanBuilder()
                   .values(split(data, 5))
                   .filter("if (c0 < 25, false, c0 % 3 = 0)")
                   .capturePlanNodeId(filterId)
@@ -397,7 +351,7 @@ TEST_F(FilterProjectTest, statsSplitter) {
                   .planNode();
 
   std::shared_ptr<Task> task;
-  AssertQueryBuilder(plan).runWithoutResults(task);
+  test::AssertQueryBuilder(plan).countResults(task);
 
   auto planStats = toPlanStats(task->taskStats());
 
@@ -423,24 +377,18 @@ TEST_F(FilterProjectTest, statsSplitter) {
 
 TEST_F(FilterProjectTest, barrier) {
   std::vector<RowVectorPtr> vectors;
-  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  std::vector<std::shared_ptr<test::TempFilePath>> tempFiles;
   const int numSplits{5};
-  const int numRowsPerSplit{100};
-  for (int32_t i = 0; i < 5; ++i) {
-    auto vector = std::dynamic_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType_, numRowsPerSplit, *pool_));
-    vectors.push_back(vector);
-    tempFiles.push_back(TempFilePath::create());
+  for (int32_t i = 0; i < numSplits; ++i) {
+    vectors.push_back(makeTestVector());
+    tempFiles.push_back(test::TempFilePath::create());
   }
   writeToFiles(toFilePaths(tempFiles), vectors);
   createDuckDbTable(vectors);
 
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId projectPlanNodeId;
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .startTableScan()
-                  .outputType(rowType_)
-                  .endTableScan()
+  auto plan = test::PlanBuilder()
+                  .tableScan(vectors.front()->rowType())
                   .filter("c1 % 10  > 0")
                   .project({"c0", "c1", "c0 + c1"})
                   .capturePlanNodeId(projectPlanNodeId)
@@ -459,17 +407,16 @@ TEST_F(FilterProjectTest, barrier) {
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.toString());
     auto task =
-        AssertQueryBuilder(plan, duckDbQueryRunner_)
-            .config(core::QueryConfig::kSparkPartitionId, "0")
+        test::AssertQueryBuilder(plan, duckDbQueryRunner_)
             .config(
                 core::QueryConfig::kMaxSplitPreloadPerDriver,
                 std::to_string(tempFiles.size()))
-            .splits(makeHiveConnectorSplits(tempFiles))
-            .serialExecution(true)
-            .barrierExecution(testData.barrierExecution)
             .config(
                 core::QueryConfig::kPreferredOutputBatchRows,
                 std::to_string(testData.numOutputRows))
+            .splits(makeHiveConnectorSplits(tempFiles))
+            .serialExecution(true)
+            .barrierExecution(testData.barrierExecution)
             .assertResults("SELECT c0, c1, c0 + c1 FROM tmp WHERE c1 % 10 > 0");
     const auto taskStats = task->taskStats();
     ASSERT_EQ(taskStats.numBarriers, testData.barrierExecution ? numSplits : 0);
@@ -482,3 +429,42 @@ TEST_F(FilterProjectTest, barrier) {
         numSplits);
   }
 }
+
+TEST_F(FilterProjectTest, lazyDereference) {
+  constexpr int kSize = 10;
+  VectorPtr expected[] = {
+      makeFlatVector<int64_t>(kSize, [](auto i) { return i; }),
+      makeFlatVector<int64_t>(kSize, [](auto i) { return i + kSize; }),
+      makeFlatVector<int64_t>(kSize, [](auto i) { return i + kSize * 2; }),
+  };
+  auto vector = makeRowVector({
+      makeRowVector({expected[0], expected[1]}),
+      makeRowVector({makeRowVector({expected[2]})}),
+  });
+  auto file = test::TempFilePath::create();
+  writeToFile(file->getPath(), vector);
+  CursorParameters params;
+  params.copyResult = false;
+  params.serialExecution = true;
+  params.planNode = test::PlanBuilder()
+                        .tableScan(vector->rowType())
+                        .lazyDereference({"c0.c0", "c0.c1", "(c1).c0.c0"})
+                        .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()->asChecked<RowVector>();
+  ASSERT_EQ(result->size(), kSize);
+  ASSERT_EQ(result->childrenSize(), 3);
+  for (int i = 0; i < result->childrenSize(); ++i) {
+    auto* lazy = result->childAt(i)->asChecked<LazyVector>();
+    ASSERT_FALSE(lazy->isLoaded());
+    ASSERT_EQ(lazy->size(), kSize);
+    velox::test::assertEqualVectors(expected[i], lazy->loadedVectorShared());
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/FilterToExpressionTest.cpp b/velox/exec/tests/FilterToExpressionTest.cpp
new file mode 100644
index 000000000000..8f84e04fede5
--- /dev/null
+++ b/velox/exec/tests/FilterToExpressionTest.cpp
@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/FilterToExpression.h"
+#include <gtest/gtest.h>
+#include "velox/core/Expressions.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::core::test {
+
+class FilterToExpressionTest : public testing::Test,
+                               public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void verifyExpr(
+      const TypedExprPtr& expr,
+      const std::string& expectedType,
+      const std::string& expectedName) {
+    ASSERT_TRUE(expr != nullptr);
+    ASSERT_EQ(expr->type()->toString(), expectedType);
+
+    auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+    ASSERT_TRUE(callExpr != nullptr);
+    ASSERT_EQ(callExpr->name(), expectedName);
+  }
+
+  TypedExprPtr toExpr(const common::Filter* filter, const TypePtr& type) {
+    common::Subfield subfield("a");
+    return filterToExpr(subfield, filter, ROW({"a"}, {type}), pool());
+  }
+};
+
+TEST_F(FilterToExpressionTest, alwaysTrue) {
+  auto filter = std::make_unique<common::AlwaysTrue>();
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  ASSERT_TRUE(expr != nullptr);
+  ASSERT_EQ(expr->type()->toString(), "BOOLEAN");
+
+  auto constantExpr = std::dynamic_pointer_cast<const ConstantTypedExpr>(expr);
+  ASSERT_TRUE(constantExpr != nullptr);
+  ASSERT_TRUE(constantExpr->value().value<TypeKind::BOOLEAN>());
+}
+
+TEST_F(FilterToExpressionTest, alwaysFalse) {
+  auto filter = std::make_unique<common::AlwaysFalse>();
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  ASSERT_TRUE(expr != nullptr);
+  ASSERT_EQ(expr->type()->toString(), "BOOLEAN");
+
+  auto constantExpr = std::dynamic_pointer_cast<const ConstantTypedExpr>(expr);
+  ASSERT_TRUE(constantExpr != nullptr);
+  ASSERT_FALSE(constantExpr->value().value<TypeKind::BOOLEAN>());
+}
+
+TEST_F(FilterToExpressionTest, isNull) {
+  auto filter = std::make_unique<common::IsNull>();
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  verifyExpr(expr, "BOOLEAN", "is_null");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 1);
+}
+
+TEST_F(FilterToExpressionTest, isNotNull) {
+  auto filter = std::make_unique<common::IsNotNull>();
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  verifyExpr(expr, "BOOLEAN", "not");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 1);
+
+  // Verify the inner expression is an IS_NULL operation
+  auto isNullExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(isNullExpr != nullptr);
+  ASSERT_EQ(isNullExpr->name(), "is_null");
+}
+
+TEST_F(FilterToExpressionTest, boolValue) {
+  auto filter = std::make_unique<common::BoolValue>(true, false);
+  auto expr = toExpr(filter.get(), BOOLEAN());
+
+  verifyExpr(expr, "BOOLEAN", "eq");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  // First input should be the field access expression
+  auto fieldExpr = callExpr->inputs()[0];
+  ASSERT_TRUE(fieldExpr != nullptr);
+
+  // Second input should be the boolean constant
+  auto constantExpr =
+      std::dynamic_pointer_cast<const ConstantTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(constantExpr != nullptr);
+  ASSERT_EQ(constantExpr->value().value<TypeKind::BOOLEAN>(), true);
+}
+
+TEST_F(FilterToExpressionTest, bigintRangeSingleValue) {
+  auto filter = std::make_unique<common::BigintRange>(42, 42, false);
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  verifyExpr(expr, "BOOLEAN", "eq");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  auto constantExpr =
+      std::dynamic_pointer_cast<const ConstantTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(constantExpr != nullptr);
+  ASSERT_EQ(constantExpr->value().value<TypeKind::BIGINT>(), 42);
+}
+
+TEST_F(FilterToExpressionTest, bigintRangeWithRange) {
+  auto filter = std::make_unique<common::BigintRange>(10, 20, false);
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  verifyExpr(expr, "BOOLEAN", "and");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  auto greaterOrEqual =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(greaterOrEqual != nullptr);
+  ASSERT_EQ(greaterOrEqual->name(), "gte");
+
+  auto lessOrEqual =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(lessOrEqual != nullptr);
+  ASSERT_EQ(lessOrEqual->name(), "lte");
+}
+
+TEST_F(FilterToExpressionTest, negatedBigintRangeSingleValue) {
+  auto filter = std::make_unique<common::NegatedBigintRange>(42, 42, false);
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  // The implementation now uses getNonNegated() which creates a NOT expression
+  // even for single values, so we expect "not" instead of "neq"
+  verifyExpr(expr, "BOOLEAN", "not");
+  auto notExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(notExpr->inputs().size(), 1);
+
+  // The inner expression might be an OR expression due to handleNullAllowed
+  auto innerExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(notExpr->inputs()[0]);
+  ASSERT_TRUE(innerExpr != nullptr);
+
+  if (innerExpr->name() == "or") {
+    // If it's an OR expression, the first input should be the EQ operation
+    ASSERT_EQ(innerExpr->inputs().size(), 2);
+    auto eqExpr =
+        std::dynamic_pointer_cast<const CallTypedExpr>(innerExpr->inputs()[0]);
+    ASSERT_TRUE(eqExpr != nullptr);
+    ASSERT_EQ(eqExpr->name(), "eq");
+    ASSERT_EQ(eqExpr->inputs().size(), 2);
+
+    // Verify the constant value is 42
+    auto constantExpr =
+        std::dynamic_pointer_cast<const ConstantTypedExpr>(eqExpr->inputs()[1]);
+    ASSERT_TRUE(constantExpr != nullptr);
+    ASSERT_EQ(constantExpr->value().value<TypeKind::BIGINT>(), 42);
+  } else if (innerExpr->name() == "eq") {
+    // If it's directly an EQ expression
+    ASSERT_EQ(innerExpr->inputs().size(), 2);
+
+    // Verify the constant value is 42
+    auto constantExpr = std::dynamic_pointer_cast<const ConstantTypedExpr>(
+        innerExpr->inputs()[1]);
+    ASSERT_TRUE(constantExpr != nullptr);
+    ASSERT_EQ(constantExpr->value().value<TypeKind::BIGINT>(), 42);
+  } else {
+    FAIL() << "Expected either 'or' or 'eq' expression, got: "
+           << innerExpr->name();
+  }
+}
+
+TEST_F(FilterToExpressionTest, doubleRange) {
+  auto filter = std::make_unique<common::DoubleRange>(
+      1.5, false, false, 3.5, false, false, false);
+  auto expr = toExpr(filter.get(), DOUBLE());
+
+  verifyExpr(expr, "BOOLEAN", "and");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  auto greaterOrEqual =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(greaterOrEqual != nullptr);
+  ASSERT_EQ(greaterOrEqual->name(), "gte");
+
+  auto lessOrEqual =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(lessOrEqual != nullptr);
+  ASSERT_EQ(lessOrEqual->name(), "lte");
+}
+
+TEST_F(FilterToExpressionTest, floatRange) {
+  auto filter = std::make_unique<common::FloatRange>(
+      1.5f, false, true, 3.5f, false, true, false);
+  auto expr = toExpr(filter.get(), REAL());
+
+  verifyExpr(expr, "BOOLEAN", "and");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  auto greaterThan =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(greaterThan != nullptr);
+  ASSERT_EQ(greaterThan->name(), "gt");
+
+  auto lessThan =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(lessThan != nullptr);
+  ASSERT_EQ(lessThan->name(), "lt");
+}
+
+TEST_F(FilterToExpressionTest, bytesRange) {
+  auto filter = std::make_unique<common::BytesRange>(
+      "apple", false, false, "orange", false, false, false);
+  auto expr = toExpr(filter.get(), VARCHAR());
+
+  verifyExpr(expr, "BOOLEAN", "and");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  auto greaterOrEqual =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(greaterOrEqual != nullptr);
+  ASSERT_EQ(greaterOrEqual->name(), "gte");
+
+  auto lessOrEqual =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(lessOrEqual != nullptr);
+  ASSERT_EQ(lessOrEqual->name(), "lte");
+}
+
+TEST_F(FilterToExpressionTest, bigintValuesUsingHashTable) {
+  std::vector<int64_t> values = {10, 20, 30};
+  auto filter = common::createBigintValues(values, false);
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  // The implementation creates an optimized expression: (range check) AND (in
+  // check)
+  verifyExpr(expr, "BOOLEAN", "and");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  // First input should be the range check (field >= min AND field <= max)
+  auto rangeCheckExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(rangeCheckExpr != nullptr);
+  ASSERT_EQ(rangeCheckExpr->name(), "and");
+
+  // Second input should be the IN expression
+  auto inExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(inExpr != nullptr);
+  ASSERT_EQ(inExpr->name(), "in");
+  ASSERT_EQ(inExpr->inputs().size(), 2);
+
+  auto arrayExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(inExpr->inputs()[1]);
+  ASSERT_TRUE(arrayExpr != nullptr);
+  ASSERT_EQ(arrayExpr->name(), "array_constructor");
+  ASSERT_EQ(arrayExpr->inputs().size(), 3);
+}
+
+TEST_F(FilterToExpressionTest, bytesValues) {
+  std::vector<std::string> values = {"apple", "banana", "orange"};
+  auto filter = std::make_unique<common::BytesValues>(values, false);
+  auto expr = toExpr(filter.get(), VARCHAR());
+
+  verifyExpr(expr, "BOOLEAN", "in");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  auto arrayExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(arrayExpr != nullptr);
+  ASSERT_EQ(arrayExpr->name(), "array_constructor");
+  ASSERT_EQ(arrayExpr->inputs().size(), 3);
+}
+
+TEST_F(FilterToExpressionTest, negatedBytesValues) {
+  std::vector<std::string> values = {"apple", "banana", "orange"};
+  auto filter = std::make_unique<common::NegatedBytesValues>(values, false);
+  auto expr = toExpr(filter.get(), VARCHAR());
+
+  verifyExpr(expr, "BOOLEAN", "not");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 1);
+
+  auto containsExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(containsExpr != nullptr);
+
+  ASSERT_TRUE(containsExpr->name() == "in" || containsExpr->name() == "or");
+}
+
+TEST_F(FilterToExpressionTest, negatedBigintValuesUsingHashTable) {
+  std::vector<int64_t> values = {10, 20, 30};
+  auto filter = std::make_unique<common::NegatedBigintValuesUsingHashTable>(
+      10, 30, values, false);
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  // The implementation creates a NOT expression for the optimized IN check
+  verifyExpr(expr, "BOOLEAN", "not");
+  auto notExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(notExpr->inputs().size(), 1);
+
+  // The input should be an OR expression
+  auto orExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(notExpr->inputs()[0]);
+  ASSERT_TRUE(orExpr != nullptr);
+  ASSERT_EQ(orExpr->name(), "or");
+  ASSERT_EQ(orExpr->inputs().size(), 2);
+
+  // First input of OR should be range check
+  auto rangeCheckExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(orExpr->inputs()[0]);
+  ASSERT_TRUE(rangeCheckExpr != nullptr);
+  ASSERT_EQ(rangeCheckExpr->name(), "and");
+
+  // Second input of OR should be IS_NULL expression
+  auto isNullExpr =
+      std::dynamic_pointer_cast<const CallTypedExpr>(orExpr->inputs()[1]);
+  ASSERT_TRUE(isNullExpr != nullptr);
+  ASSERT_EQ(isNullExpr->name(), "is_null");
+}
+
+TEST_F(FilterToExpressionTest, timestampRange) {
+  auto timestamp1 = Timestamp::fromMillis(1609459200000); // 2021-01-01
+  auto timestamp2 = Timestamp::fromMillis(1640995200000); // 2022-01-01
+  auto filter =
+      std::make_unique<common::TimestampRange>(timestamp1, timestamp2, false);
+  auto expr = toExpr(filter.get(), TIMESTAMP());
+
+  verifyExpr(expr, "BOOLEAN", "and");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+
+  auto greaterOrEqual =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(greaterOrEqual != nullptr);
+  ASSERT_EQ(greaterOrEqual->name(), "gte");
+
+  auto lessOrEqual =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(lessOrEqual != nullptr);
+  ASSERT_EQ(lessOrEqual->name(), "lte");
+}
+
+TEST_F(FilterToExpressionTest, bigintMultiRange) {
+  std::vector<std::unique_ptr<common::BigintRange>> ranges;
+  ranges.push_back(std::make_unique<common::BigintRange>(10, 20, false));
+  ranges.push_back(std::make_unique<common::BigintRange>(30, 40, false));
+  auto filter =
+      std::make_unique<common::BigintMultiRange>(std::move(ranges), false);
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  verifyExpr(expr, "BOOLEAN", "or");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 2);
+}
+
+TEST_F(FilterToExpressionTest, multiRange) {
+  // Create a MultiRange filter with compatible filters for BIGINT field
+  std::vector<std::unique_ptr<common::Filter>> filters;
+
+  // Add a BigintRange filter
+  filters.push_back(std::make_unique<common::BigintRange>(10, 20, false));
+
+  // Add an IsNull filter
+  filters.push_back(std::make_unique<common::IsNull>());
+
+  // Add another BigintRange filter instead of BytesRange to avoid type mismatch
+  filters.push_back(std::make_unique<common::BigintRange>(30, 40, false));
+
+  auto filter = std::make_unique<common::MultiRange>(std::move(filters), false);
+  auto expr = toExpr(filter.get(), BIGINT());
+
+  // Verify the top-level expression is an OR
+  verifyExpr(expr, "BOOLEAN", "or");
+  auto callExpr = std::dynamic_pointer_cast<const CallTypedExpr>(expr);
+  ASSERT_EQ(callExpr->inputs().size(), 3);
+
+  // Verify the first input is a BigintRange expression (AND of
+  // greater_than_or_equal and less_than_or_equal)
+  auto firstInput =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[0]);
+  ASSERT_TRUE(firstInput != nullptr);
+  ASSERT_EQ(firstInput->name(), "and");
+  ASSERT_EQ(firstInput->inputs().size(), 2);
+
+  // Verify the second input is an IsNull expression
+  auto secondInput =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[1]);
+  ASSERT_TRUE(secondInput != nullptr);
+  ASSERT_EQ(secondInput->name(), "is_null");
+
+  // Verify the third input is another BigintRange expression (AND of
+  // greater_than_or_equal and less_than_or_equal)
+  auto thirdInput =
+      std::dynamic_pointer_cast<const CallTypedExpr>(callExpr->inputs()[2]);
+  ASSERT_TRUE(thirdInput != nullptr);
+  ASSERT_EQ(thirdInput->name(), "and");
+  ASSERT_EQ(thirdInput->inputs().size(), 2);
+}
+
+} // namespace facebook::velox::core::test
diff --git a/velox/exec/tests/FunctionSignatureBuilderTest.cpp b/velox/exec/tests/FunctionSignatureBuilderTest.cpp
index 6ac14b0592ad..832f32c957aa 100644
--- a/velox/exec/tests/FunctionSignatureBuilderTest.cpp
+++ b/velox/exec/tests/FunctionSignatureBuilderTest.cpp
@@ -45,11 +45,12 @@ TEST_F(FunctionSignatureBuilderTest, basicTypeTests) {
 
   // Integer variables do not have to be used in the inputs, but in that case
   // must appear in the return.
-  ASSERT_NO_THROW(FunctionSignatureBuilder()
-                      .integerVariable("a")
-                      .returnType("DECIMAL(a, a)")
-                      .argumentType("integer")
-                      .build(););
+  ASSERT_NO_THROW(
+      FunctionSignatureBuilder()
+          .integerVariable("a")
+          .returnType("DECIMAL(a, a)")
+          .argumentType("integer")
+          .build(););
 
   VELOX_ASSERT_THROW(
       FunctionSignatureBuilder()
@@ -124,7 +125,7 @@ TEST_F(FunctionSignatureBuilderTest, typeParamTests) {
           .returnType("integer")
           .argumentType("row(..., varchar)")
           .build(),
-      "Failed to parse type signature [row(..., varchar)]: syntax error, unexpected COMMA");
+      "Failed to parse type signature [row(..., varchar)]: syntax error, unexpected ELLIPSIS");
 
   // Type params cant have type params.
   VELOX_ASSERT_THROW(
@@ -155,6 +156,60 @@ TEST_F(FunctionSignatureBuilderTest, anyInReturn) {
       "Type 'Any' cannot appear in return type");
 }
 
+TEST_F(FunctionSignatureBuilderTest, homogeneousRowInReturn) {
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("row(T, ...)")
+          .argumentType("T")
+          .build(),
+      "Homogeneous row cannot appear in return type");
+
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("array(row(bigint, ...))")
+          .argumentType("bigint")
+          .build(),
+      "Homogeneous row cannot appear in return type");
+}
+
+TEST_F(FunctionSignatureBuilderTest, variableArity) {
+  // .variableArity() requires at least one argument.
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("bigint")
+          .variableArity()
+          .build(),
+      "Variable arity requires at least one argument");
+
+  // .variableArity() can be used only once.
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("bigint")
+          .variableArity("bigint")
+          .variableArity("integer")
+          .build(),
+      "Cannot add arguments after variable arity argument");
+
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("bigint")
+          .argumentType("bigint")
+          .variableArity()
+          .variableArity()
+          .build(),
+      "Only one variable arity argument is allowed");
+
+  // No arguments can be added after calling .variableArity().
+  VELOX_ASSERT_USER_THROW(
+      exec::FunctionSignatureBuilder()
+          .returnType("bigint")
+          .variableArity("bigint")
+          .argumentType("boolean")
+          .build(),
+      "Cannot add arguments after variable arity argument");
+}
+
 TEST_F(FunctionSignatureBuilderTest, scalarConstantFlags) {
   {
     auto signature = FunctionSignatureBuilder()
diff --git a/velox/exec/tests/GroupedExecutionTest.cpp b/velox/exec/tests/GroupedExecutionTest.cpp
index 8263e17bcaed..da3dd53ee2e8 100644
--- a/velox/exec/tests/GroupedExecutionTest.cpp
+++ b/velox/exec/tests/GroupedExecutionTest.cpp
@@ -341,7 +341,7 @@ TEST_F(GroupedExecutionTest, hashJoinWithMixedGroupedExecution) {
       return fmt::format(
           "mode {}, joinType {}, supported {}",
           modeToString(mode),
-          core::joinTypeName(joinType),
+          core::JoinTypeName::toName(joinType),
           supported);
     }
   };
@@ -449,7 +449,7 @@ TEST_F(GroupedExecutionTest, hashJoinWithMixedGroupedExecution) {
             task->start(3, 1),
             fmt::format(
                 "Hash join currently does not support mixed grouped execution for join type {}",
-                core::joinTypeName(testData.joinType)));
+                core::JoinTypeName::toName(testData.joinType)));
         continue;
       }
 
@@ -675,16 +675,25 @@ DEBUG_ONLY_TEST_F(
           }
         }));
 
+    const auto spillDirectory = exec::test::TempDirectoryPath::create();
+    std::optional<common::SpillDiskOptions> spillOpts;
+    if (testData.enableSpill) {
+      spillOpts = common::SpillDiskOptions{
+          .spillDirPath = spillDirectory->getPath(),
+          .spillDirCreated = true,
+          .spillDirCreateCb = nullptr};
+    }
+
     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());
-    }
+        Task::ExecutionMode::kParallel,
+        /*consumer=*/Consumer{},
+        /*memoryArbitrationPriority=*/0,
+        spillOpts,
+        /*onError=*/nullptr);
 
     // 'numDriversPerGroup' drivers max to execute one group at a time.
     task->start(numDriversPerGroup, testData.groupConcurrency);
@@ -817,15 +826,21 @@ DEBUG_ONLY_TEST_F(
         memory::testingRunArbitration(op->pool());
       }));
 
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  common::SpillDiskOptions spillOpts{
+      .spillDirPath = spillDirectory->getPath(),
+      .spillDirCreated = true,
+      .spillDirCreateCb = nullptr};
+
   auto task = exec::Task::create(
       "0",
       std::move(planFragment),
       0,
       std::move(queryCtx),
-      Task::ExecutionMode::kParallel);
-  const auto spillDirectory = exec::test::TempDirectoryPath::create();
-
-  task->setSpillDirectory(spillDirectory->getPath());
+      Task::ExecutionMode::kParallel,
+      Consumer{},
+      /*memoryArbitrationPriority=*/0,
+      spillOpts);
 
   // 'numDriversPerGroup' drivers max to execute one group at a time.
   task->start(numDriversPerGroup, 1);
@@ -848,8 +863,8 @@ DEBUG_ONLY_TEST_F(
   }
 
   // Total drivers should be numDriversPerGroup * (numGroups + 1), but since
-  // probe does not receive termination signal, it cannot signal the build side
-  // to finish. we expect only build's numDriversPerGroup finished.
+  // probe does not receive termination signal, it cannot signal the build
+  // side to finish. we expect only build's numDriversPerGroup finished.
   waitForFinishedDrivers(task, numDriversPerGroup);
 
   // 'Delete results' from output buffer triggers 'set all output consumed',
@@ -1025,8 +1040,8 @@ TEST_F(GroupedExecutionTest, groupedExecutionWithHashAndNestedLoopJoin) {
       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))) {
+        if (childPool->name().starts_with(
+                fmt::format("node.{}[", joinNodeId))) {
           ++numSplitGroupJoinNodes;
           std::vector<std::string> parts;
           folly::split(".", childPool->name(), parts);
diff --git a/velox/exec/tests/HashJoinBridgeTest.cpp b/velox/exec/tests/HashJoinBridgeTest.cpp
index d5a6e5b24072..757e1658491a 100644
--- a/velox/exec/tests/HashJoinBridgeTest.cpp
+++ b/velox/exec/tests/HashJoinBridgeTest.cpp
@@ -44,6 +44,7 @@ class HashJoinBridgeTestHelper {
   HashJoinBridge* const bridge_;
 };
 
+namespace {
 struct TestParam {
   int32_t numProbers{1};
   int32_t numBuilders{1};
@@ -670,12 +671,16 @@ TEST_P(HashJoinBridgeTest, hashJoinTableType) {
     std::vector<core::FieldAccessTypedExprPtr> buildKeys;
     std::vector<core::FieldAccessTypedExprPtr> probeKeys;
     for (uint32_t i = 0; i < testData.buildKeyType->size(); i++) {
-      buildKeys.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-          testData.buildKeyType->childAt(i), testData.buildKeyType->nameOf(i)));
+      buildKeys.push_back(
+          std::make_shared<core::FieldAccessTypedExpr>(
+              testData.buildKeyType->childAt(i),
+              testData.buildKeyType->nameOf(i)));
     }
     for (uint32_t i = 0; i < testData.probeKeyType->size(); i++) {
-      probeKeys.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-          testData.probeKeyType->childAt(i), testData.probeKeyType->nameOf(i)));
+      probeKeys.push_back(
+          std::make_shared<core::FieldAccessTypedExpr>(
+              testData.probeKeyType->childAt(i),
+              testData.probeKeyType->nameOf(i)));
     }
     const auto joinNode = std::make_shared<core::HashJoinNode>(
         "join-bridge-test",
@@ -707,7 +712,7 @@ TEST(HashJoinBridgeTest, hashJoinTableSpillType) {
     std::string debugString() const {
       return fmt::format(
           "joinType: {}, expectedTableSpillType: {}",
-          joinTypeName(joinType),
+          core::JoinTypeName::toName(joinType),
           expectedTableSpillType->toString());
     }
   } testSettings[] = {
@@ -724,4 +729,5 @@ TEST(HashJoinBridgeTest, hashJoinTableSpillType) {
     ASSERT_EQ(spillType->names(), testData.expectedTableSpillType->names());
   }
 }
+} // namespace
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HashJoinTest.cpp b/velox/exec/tests/HashJoinTest.cpp
index 4ff343979326..ff76fa0a16ba 100644
--- a/velox/exec/tests/HashJoinTest.cpp
+++ b/velox/exec/tests/HashJoinTest.cpp
@@ -33,38 +33,47 @@
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/exec/tests/utils/VectorTestUtil.h"
+#include "velox/type/tests/utils/CustomTypesForTesting.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::common::testutil;
 
 using facebook::velox::test::BatchMaker;
 
+namespace facebook::velox::exec {
 namespace {
 
-class HashJoinTest : public HashJoinTestBase {
+class HashJoinTest : public HashJoinTestBase,
+                     public testing::WithParamInterface<TestParam> {
  public:
-  HashJoinTest() : HashJoinTestBase(TestParam(1)) {}
+  HashJoinTest() : HashJoinTestBase(GetParam()) {}
 
   explicit HashJoinTest(const TestParam& param) : HashJoinTestBase(param) {}
+
+  static std::vector<TestParam> getTestParams() {
+    return std::vector<TestParam>({TestParam{1, false}, TestParam{1, true}});
+  }
 };
 
-class MultiThreadedHashJoinTest
-    : public HashJoinTest,
-      public testing::WithParamInterface<TestParam> {
+class MultiThreadedHashJoinTest : public HashJoinTest {
  public:
   MultiThreadedHashJoinTest() : HashJoinTest(GetParam()) {}
 
   static std::vector<TestParam> getTestParams() {
-    return std::vector<TestParam>({TestParam{1}, TestParam{3}});
+    return std::vector<TestParam>(
+        {TestParam{1, false},
+         TestParam{1, true},
+         TestParam{3, false},
+         TestParam{3, true}});
   }
 };
 
 TEST_P(MultiThreadedHashJoinTest, bigintArray) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -76,6 +85,7 @@ TEST_P(MultiThreadedHashJoinTest, bigintArray) {
 TEST_P(MultiThreadedHashJoinTest, outOfJoinKeyColumnOrder) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeType(probeType_)
       .probeKeys({"t_k2"})
       .probeVectors(5, 10)
@@ -91,6 +101,7 @@ TEST_P(MultiThreadedHashJoinTest, outOfJoinKeyColumnOrder) {
 TEST_P(MultiThreadedHashJoinTest, joinWithCancellation) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -108,6 +119,7 @@ TEST_P(MultiThreadedHashJoinTest, testJoinWithSpillenabledCancellation) {
   auto spillDirectory = exec::test::TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -128,6 +140,7 @@ TEST_P(MultiThreadedHashJoinTest, emptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .keyTypes({BIGINT()})
         .probeVectors(1600, 5)
         .buildVectors(0, 5)
@@ -159,6 +172,7 @@ TEST_P(MultiThreadedHashJoinTest, emptyBuild) {
 TEST_P(MultiThreadedHashJoinTest, emptyProbe) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(0, 5)
       .buildVectors(1500, 5)
@@ -195,6 +209,7 @@ TEST_P(MultiThreadedHashJoinTest, emptyProbe) {
 TEST_P(MultiThreadedHashJoinTest, normalizedKey) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT(), VARCHAR()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -220,6 +235,7 @@ DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, parallelJoinBuildCheck) {
       std::function<void(void*)>([&](void*) { isParallelBuild = true; }));
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT(), VARCHAR()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -250,6 +266,7 @@ DEBUG_ONLY_TEST_P(
   VELOX_ASSERT_THROW(
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
           .keyTypes({BIGINT(), VARCHAR()})
           .probeVectors(1600, 5)
           .buildVectors(1500, 5)
@@ -280,6 +297,7 @@ TEST_P(MultiThreadedHashJoinTest, allTypes) {
 TEST_P(MultiThreadedHashJoinTest, filter) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -312,6 +330,7 @@ DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, filterSpillOnFirstProbeInput) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({BIGINT()})
       .numDrivers(1)
       .probeVectors(1600, 5)
@@ -362,6 +381,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithNull) {
 
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeType(probeType_)
         .probeKeys({"t_k2"})
         .probeVectors(std::move(probeVectors))
@@ -401,6 +421,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithLargeOutput) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u0"})
@@ -452,6 +473,7 @@ TEST_P(MultiThreadedHashJoinTest, arrayBasedLookup) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"c0"})
@@ -518,6 +540,7 @@ TEST_P(MultiThreadedHashJoinTest, joinSidesDifferentSchema) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t_c0"})
       .probeVectors(std::move(probeVectors))
       .probeProjections({"c0 AS t_c0", "c1 AS t_c1", "c2 AS t_c2"})
@@ -557,6 +580,7 @@ TEST_P(MultiThreadedHashJoinTest, innerJoinWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"c0"})
@@ -591,6 +615,7 @@ TEST_P(MultiThreadedHashJoinTest, innerJoinWithEmptyBuild) {
 TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilter) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeType(probeType_)
       .probeVectors(174, 5)
       .probeKeys({"t_k1"})
@@ -627,6 +652,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"c0"})
@@ -668,6 +694,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -684,6 +711,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -700,6 +728,7 @@ TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithExtraFilter) {
 TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilter) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeType(probeType_)
       .probeVectors(133, 3)
       .probeKeys({"t_k1"})
@@ -741,6 +770,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u0"})
@@ -798,6 +828,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithAllMatches) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u0"})
@@ -833,6 +864,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -855,6 +887,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -876,6 +909,7 @@ TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -1019,6 +1053,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoin) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"c0"})
@@ -1039,6 +1074,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoin) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"c0"})
@@ -1059,6 +1095,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoin) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"c0"})
@@ -1096,6 +1133,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilter) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u0"})
@@ -1150,6 +1188,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::vector<RowVectorPtr>(probeVectors))
         .buildKeys({"u0"})
@@ -1209,6 +1248,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndNullKey) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -1269,6 +1309,7 @@ TEST_P(
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u0"})
@@ -1307,6 +1348,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
     });
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u0"})
@@ -1357,6 +1399,7 @@ TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
     });
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u0"})
@@ -1405,6 +1448,7 @@ TEST_P(MultiThreadedHashJoinTest, antiJoin) {
   });
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"t0"})
       .probeVectors(std::vector<RowVectorPtr>(probeVectors))
       .buildKeys({"u0"})
@@ -1433,6 +1477,7 @@ TEST_P(MultiThreadedHashJoinTest, antiJoin) {
   for (const std::string& filter : filters) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::vector<RowVectorPtr>(probeVectors))
         .buildKeys({"u0"})
@@ -1440,9 +1485,10 @@ TEST_P(MultiThreadedHashJoinTest, antiJoin) {
         .joinType(core::JoinType::kAnti)
         .joinFilter(filter)
         .joinOutputLayout({"t0", "t1"})
-        .referenceQuery(fmt::format(
-            "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0 AND {})",
-            filter))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0 AND {})",
+                filter))
         .run();
   }
 }
@@ -1472,6 +1518,7 @@ TEST_P(MultiThreadedHashJoinTest, antiJoinWithFilterAndEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"t0"})
         .probeVectors(std::vector<RowVectorPtr>(probeVectors))
         .buildKeys({"u0"})
@@ -1546,6 +1593,7 @@ TEST_P(MultiThreadedHashJoinTest, leftJoin) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u_c0"})
@@ -1601,6 +1649,7 @@ TEST_P(MultiThreadedHashJoinTest, nullStatsWithEmptyBuild) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u_c0"})
@@ -1684,6 +1733,7 @@ TEST_P(MultiThreadedHashJoinTest, leftJoinWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u_c0"})
@@ -1745,6 +1795,7 @@ TEST_P(MultiThreadedHashJoinTest, leftJoinWithNoJoin) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u_c0"})
@@ -1803,6 +1854,7 @@ TEST_P(MultiThreadedHashJoinTest, leftJoinWithAllMatch) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .probeFilter("c0 < 5")
@@ -1866,6 +1918,7 @@ TEST_P(MultiThreadedHashJoinTest, leftJoinWithFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u_c0"})
@@ -1885,6 +1938,7 @@ TEST_P(MultiThreadedHashJoinTest, leftJoinWithFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u_c0"})
@@ -1937,6 +1991,7 @@ TEST_P(MultiThreadedHashJoinTest, leftJoinWithNullableFilter) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u_c0"})
@@ -1988,6 +2043,7 @@ TEST_P(MultiThreadedHashJoinTest, rightJoin) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u_c0"})
@@ -2043,6 +2099,7 @@ TEST_P(MultiThreadedHashJoinTest, rightJoinWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u_c0"})
@@ -2095,6 +2152,7 @@ TEST_P(MultiThreadedHashJoinTest, rightJoinWithAllMatch) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u_c0"})
@@ -2150,6 +2208,7 @@ TEST_P(MultiThreadedHashJoinTest, rightJoinWithFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u_c0"})
@@ -2169,6 +2228,7 @@ TEST_P(MultiThreadedHashJoinTest, rightJoinWithFilter) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u_c0"})
@@ -2222,6 +2282,7 @@ TEST_P(MultiThreadedHashJoinTest, fullJoin) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u_c0"})
@@ -2277,6 +2338,7 @@ TEST_P(MultiThreadedHashJoinTest, fullJoinWithEmptyBuild) {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(probeVectors))
         .buildKeys({"u_c0"})
@@ -2330,6 +2392,7 @@ TEST_P(MultiThreadedHashJoinTest, fullJoinWithNoMatch) {
 
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .probeKeys({"c0"})
       .probeVectors(std::move(probeVectors))
       .buildKeys({"u_c0"})
@@ -2385,6 +2448,7 @@ TEST_P(MultiThreadedHashJoinTest, fullJoinWithFilters) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u_c0"})
@@ -2404,6 +2468,7 @@ TEST_P(MultiThreadedHashJoinTest, fullJoinWithFilters) {
     auto testBuildVectors = buildVectors;
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .probeKeys({"c0"})
         .probeVectors(std::move(testProbeVectors))
         .buildKeys({"u_c0"})
@@ -2421,6 +2486,7 @@ TEST_P(MultiThreadedHashJoinTest, fullJoinWithFilters) {
 TEST_P(MultiThreadedHashJoinTest, noSpillLevelLimit) {
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .keyTypes({INTEGER()})
       .probeVectors(1600, 5)
       .buildVectors(1500, 5)
@@ -2441,7 +2507,7 @@ TEST_P(MultiThreadedHashJoinTest, noSpillLevelLimit) {
 
 // Verify that dynamic filter pushed down is turned off for null-aware right
 // semi project join.
-TEST_F(HashJoinTest, nullAwareRightSemiProjectOverScan) {
+TEST_P(HashJoinTest, nullAwareRightSemiProjectOverScan) {
   std::vector<RowVectorPtr> probes;
   std::vector<RowVectorPtr> builds;
   // Matches present:
@@ -2515,7 +2581,7 @@ TEST_F(HashJoinTest, nullAwareRightSemiProjectOverScan) {
   }
 }
 
-TEST_F(HashJoinTest, duplicateJoinKeys) {
+TEST_P(HashJoinTest, duplicateJoinKeys) {
   auto leftVectors = makeBatches(3, [&](int32_t /*unused*/) {
     return makeRowVector({
         makeNullableFlatVector<int64_t>(
@@ -2597,7 +2663,7 @@ TEST_F(HashJoinTest, duplicateJoinKeys) {
   }
 }
 
-TEST_F(HashJoinTest, semiProject) {
+TEST_P(HashJoinTest, semiProject) {
   // Some keys have multiple rows: 2, 3, 5.
   auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
     return makeRowVector({
@@ -2713,7 +2779,7 @@ TEST_F(HashJoinTest, semiProject) {
       .run();
 }
 
-TEST_F(HashJoinTest, semiProjectWithNullKeys) {
+TEST_P(HashJoinTest, semiProjectWithNullKeys) {
   // Some keys have multiple rows: 2, 3, 5.
   auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
     return makeRowVector(
@@ -2916,7 +2982,7 @@ TEST_F(HashJoinTest, semiProjectWithNullKeys) {
       .run();
 }
 
-TEST_F(HashJoinTest, semiProjectWithFilter) {
+TEST_P(HashJoinTest, semiProjectWithFilter) {
   auto probeVectors = makeBatches(3, [&](auto /*unused*/) {
     return makeRowVector(
         {"t0", "t1"},
@@ -2965,8 +3031,10 @@ TEST_F(HashJoinTest, semiProjectWithFilter) {
 
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .planNode(plan)
-        .referenceQuery(fmt::format(
-            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t", filter))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t",
+                filter))
         .injectSpill(false)
         .run();
 
@@ -2976,15 +3044,16 @@ TEST_F(HashJoinTest, semiProjectWithFilter) {
     // these values.
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .planNode(plan)
-        .referenceQuery(fmt::format(
-            "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE (u0 is not null OR t0 is not null) AND u0 = t0 AND {}) FROM t",
-            filter))
+        .referenceQuery(
+            fmt::format(
+                "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();
   }
 }
 
-TEST_F(HashJoinTest, nullAwareRightSemiProjectWithFilterNotAllowed) {
+TEST_P(HashJoinTest, nullAwareRightSemiProjectWithFilterNotAllowed) {
   auto probe = makeRowVector(ROW({"t0", "t1"}, {INTEGER(), BIGINT()}), 10);
   auto build = makeRowVector(ROW({"u0", "u1"}, {INTEGER(), BIGINT()}), 10);
 
@@ -3003,7 +3072,7 @@ TEST_F(HashJoinTest, nullAwareRightSemiProjectWithFilterNotAllowed) {
       "Null-aware right semi project join doesn't support extra filter");
 }
 
-TEST_F(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
+TEST_P(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
   std::vector<RowVectorPtr> probeVectors;
   std::vector<RowVectorPtr> buildVectors;
   probeVectors.push_back(makeRowVector(
@@ -3078,7 +3147,7 @@ TEST_F(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
   }
 }
 
-TEST_F(HashJoinTest, nullAwareMultiKeyNotAllowed) {
+TEST_P(HashJoinTest, nullAwareMultiKeyNotAllowed) {
   auto probe = makeRowVector(
       ROW({"t0", "t1", "t2"}, {INTEGER(), BIGINT(), VARCHAR()}), 10);
   auto build = makeRowVector(
@@ -3128,7 +3197,7 @@ TEST_F(HashJoinTest, nullAwareMultiKeyNotAllowed) {
       "Null-aware joins allow only one join key");
 }
 
-TEST_F(HashJoinTest, semiProjectOverLazyVectors) {
+TEST_P(HashJoinTest, semiProjectOverLazyVectors) {
   auto probeVectors = makeBatches(1, [&](auto /*unused*/) {
     return makeRowVector(
         {"t0", "t1"},
@@ -3232,12 +3301,15 @@ TEST_F(HashJoinTest, semiProjectOverLazyVectors) {
 }
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
-    HashJoinTest,
     MultiThreadedHashJoinTest,
-    testing::ValuesIn(MultiThreadedHashJoinTest::getTestParams()));
+    MultiThreadedHashJoinTest,
+    testing::ValuesIn(MultiThreadedHashJoinTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return TestParamToName(info.param);
+    });
 
 // TODO: try to parallelize the following test cases if possible.
-TEST_F(HashJoinTest, memory) {
+TEST_P(HashJoinTest, memory) {
   // Measures memory allocation in a 1:n hash join followed by
   // projection and aggregation. We expect vectors to be mostly
   // reused, except for t_k0 + 1, which is a dictionary after the
@@ -3276,7 +3348,7 @@ TEST_F(HashJoinTest, memory) {
   EXPECT_GT(40'000'000, params.queryCtx->pool()->stats().cumulativeBytes);
 }
 
-TEST_F(HashJoinTest, lazyVectors) {
+TEST_P(HashJoinTest, lazyVectors) {
   // a dataset of multiple row groups with multiple columns. We create
   // different dictionary wrappings for different columns and load the
   // rows in scope at different times.
@@ -3322,8 +3394,9 @@ TEST_F(HashJoinTest, lazyVectors) {
       }
       std::vector<exec::Split> buildSplits;
       for (int i = 0; i < buildVectors.size(); ++i) {
-        buildSplits.push_back(exec::Split(makeHiveConnectorSplit(
-            tempFiles[probeSplits.size() + i]->getPath())));
+        buildSplits.push_back(
+            exec::Split(makeHiveConnectorSplit(
+                tempFiles[probeSplits.size() + i]->getPath())));
       }
       SplitInput splits;
       splits.emplace(probeScanId, probeSplits);
@@ -3390,7 +3463,7 @@ TEST_F(HashJoinTest, lazyVectors) {
   }
 }
 
-TEST_F(HashJoinTest, lazyVectorNotLoadedInFilter) {
+TEST_P(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
@@ -3408,7 +3481,7 @@ TEST_F(HashJoinTest, lazyVectorNotLoadedInFilter) {
       "SELECT t.c1, t.c2 FROM t, u WHERE t.c0 = u.c0");
 }
 
-TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftJoin) {
+TEST_P(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.
 
@@ -3419,7 +3492,7 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftJoin) {
       "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_P(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.
 
@@ -3430,7 +3503,7 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterFullJoin) {
       "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_P(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.
 
@@ -3441,7 +3514,7 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiProject) {
       "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_P(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.
 
@@ -3452,7 +3525,7 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterAntiJoin) {
       "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_P(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.
 
@@ -3463,7 +3536,7 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterInnerJoin) {
       "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_P(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.
 
@@ -3474,7 +3547,7 @@ TEST_F(HashJoinTest, lazyVectorPartiallyLoadedInFilterLeftSemiFilter) {
       "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) {
+TEST_P(HashJoinTest, dynamicFilters) {
   const int32_t numSplits = 10;
   const int32_t numRowsProbe = 333;
   const int32_t numRowsBuild = 100;
@@ -3542,7 +3615,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
 
   // Basic push-down.
   {
-    // Inner join.
+    SCOPED_TRACE("Inner join");
     core::PlanNodeId probeScanId;
     core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
@@ -3720,8 +3793,9 @@ TEST_F(HashJoinTest, dynamicFilters) {
   // Basic push-down with column names projected out of the table scan
   // having different names than column names in the files.
   {
+    SCOPED_TRACE("Inner join column rename");
     auto scanOutputType = ROW({"a", "b"}, {INTEGER(), BIGINT()});
-    ColumnHandleMap assignments;
+    connector::ColumnHandleMap assignments;
     assignments["a"] = regularColumn("c0", INTEGER());
     assignments["b"] = regularColumn("c1", BIGINT());
 
@@ -3768,6 +3842,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
 
   // Push-down that requires merging filters.
   {
+    SCOPED_TRACE("Merge filters");
     core::PlanNodeId probeScanId;
     core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
@@ -3808,6 +3883,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
 
   // Push-down that turns join into a no-op.
   {
+    SCOPED_TRACE("canReplaceWithDynamicFilter");
     core::PlanNodeId probeScanId;
     core::PlanNodeId joinId;
     auto op =
@@ -3851,6 +3927,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
   // Push-down that turns join into a no-op with output having a different
   // number of columns than the input.
   {
+    SCOPED_TRACE("canReplaceWithDynamicFilter column rename");
     core::PlanNodeId probeScanId;
     core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
@@ -3891,6 +3968,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
 
   // Push-down that requires merging filters and turns join into a no-op.
   {
+    SCOPED_TRACE("canReplaceWithDynamicFilter merge filters");
     core::PlanNodeId probeScanId;
     core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
@@ -3931,6 +4009,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
 
   // Push-down with highly selective filter in the scan.
   {
+    SCOPED_TRACE("Highly selective filter");
     // Inner join.
     core::PlanNodeId probeScanId;
     core::PlanNodeId joinId;
@@ -3945,6 +4024,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
             .planNode();
 
     {
+      SCOPED_TRACE("Inner join");
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .planNode(std::move(op))
           .makeInputSplits(makeInputSplits(probeScanId))
@@ -3989,6 +4069,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
              .planNode();
 
     {
+      SCOPED_TRACE("Left semi join");
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .planNode(std::move(op))
           .makeInputSplits(makeInputSplits(probeScanId))
@@ -4033,6 +4114,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
              .planNode();
 
     {
+      SCOPED_TRACE("Right semi join");
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .planNode(std::move(op))
           .makeInputSplits(makeInputSplits(probeScanId))
@@ -4073,6 +4155,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
             .planNode();
 
     {
+      SCOPED_TRACE("Right join");
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .planNode(std::move(op))
           .makeInputSplits(makeInputSplits(probeScanId))
@@ -4104,6 +4187,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
 
   // Disable filter push-down by using values in place of scan.
   {
+    SCOPED_TRACE("Disabled in case of values node");
     core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
                   .values(probeVectors)
@@ -4127,6 +4211,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
   // Disable filter push-down by using an expression as the join key on the
   // probe side.
   {
+    SCOPED_TRACE("Disabled in case of join condition");
     core::PlanNodeId probeScanId;
     core::PlanNodeId joinId;
     auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
@@ -4153,7 +4238,7 @@ TEST_F(HashJoinTest, dynamicFilters) {
   }
 }
 
-TEST_F(HashJoinTest, dynamicFiltersStatsWithChainedJoins) {
+TEST_P(HashJoinTest, dynamicFiltersStatsWithChainedJoins) {
   const int32_t numSplits = 10;
   const int32_t numProbeRows = 333;
   const int32_t numBuildRows = 100;
@@ -4250,7 +4335,7 @@ TEST_F(HashJoinTest, dynamicFiltersStatsWithChainedJoins) {
       .run();
 }
 
-TEST_F(HashJoinTest, dynamicFiltersWithSkippedSplits) {
+TEST_P(HashJoinTest, dynamicFiltersWithSkippedSplits) {
   const int32_t numSplits = 20;
   const int32_t numNonSkippedSplits = 10;
   const int32_t numRowsProbe = 333;
@@ -4472,7 +4557,7 @@ TEST_F(HashJoinTest, dynamicFiltersWithSkippedSplits) {
   }
 }
 
-TEST_F(HashJoinTest, dynamicFiltersAppliedToPreloadedSplits) {
+TEST_P(HashJoinTest, dynamicFiltersAppliedToPreloadedSplits) {
   vector_size_t size = 1000;
   const int32_t numSplits = 5;
 
@@ -4500,7 +4585,7 @@ TEST_F(HashJoinTest, dynamicFiltersAppliedToPreloadedSplits) {
   }
 
   auto outputType = ROW({"p0", "p1"}, {BIGINT(), BIGINT()});
-  ColumnHandleMap assignments = {
+  connector::ColumnHandleMap assignments = {
       {"p0", regularColumn("p0", BIGINT())},
       {"p1", partitionKey("p1", BIGINT())}};
   createDuckDbTable("p", probeVectors);
@@ -4556,7 +4641,7 @@ TEST_F(HashJoinTest, dynamicFiltersAppliedToPreloadedSplits) {
       .run();
 }
 
-TEST_F(HashJoinTest, dynamicFiltersPushDownThroughAgg) {
+TEST_P(HashJoinTest, dynamicFiltersPushDownThroughAgg) {
   const int32_t numRowsProbe = 300;
   const int32_t numRowsBuild = 100;
 
@@ -4625,7 +4710,7 @@ TEST_F(HashJoinTest, dynamicFiltersPushDownThroughAgg) {
       .run();
 }
 
-TEST_F(HashJoinTest, noDynamicFiltersPushDownThroughRightJoin) {
+TEST_P(HashJoinTest, noDynamicFiltersPushDownThroughRightJoin) {
   std::vector<RowVectorPtr> innerBuild = {makeRowVector(
       {"a"},
       {
@@ -4672,7 +4757,7 @@ TEST_F(HashJoinTest, noDynamicFiltersPushDownThroughRightJoin) {
 
 // Verify the size of the join output vectors when projecting build-side
 // variable-width column.
-TEST_F(HashJoinTest, memoryUsage) {
+TEST_P(HashJoinTest, memoryUsage) {
   std::vector<RowVectorPtr> probeVectors =
       makeBatches(10, [&](int32_t /*unused*/) {
         return makeRowVector(
@@ -4727,7 +4812,7 @@ TEST_F(HashJoinTest, memoryUsage) {
 /// Test an edge case in producing small output batches where the logic to
 /// calculate the set of probe-side rows to load lazy vectors for was
 /// triggering a crash.
-TEST_F(HashJoinTest, smallOutputBatchSize) {
+TEST_P(HashJoinTest, smallOutputBatchSize) {
   // Setup probe data with 50 non-null matching keys followed by 50 null
   // keys: 1, 2, 1, 2,...null, null.
   auto probeVectors = makeRowVector({
@@ -4773,12 +4858,13 @@ TEST_F(HashJoinTest, smallOutputBatchSize) {
       .run();
 }
 
-TEST_F(HashJoinTest, spillFileSize) {
+TEST_P(HashJoinTest, spillFileSize) {
   const std::vector<uint64_t> maxSpillFileSizes({0, 1, 1'000'000'000});
   for (const auto spillFileSize : maxSpillFileSizes) {
     SCOPED_TRACE(fmt::format("spillFileSize: {}", spillFileSize));
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .keyTypes({BIGINT()})
         .probeVectors(100, 3)
         .buildVectors(100, 3)
@@ -4809,10 +4895,11 @@ TEST_F(HashJoinTest, spillFileSize) {
   }
 }
 
-TEST_F(HashJoinTest, spillPartitionBitsOverlap) {
+TEST_P(HashJoinTest, spillPartitionBitsOverlap) {
   auto builder =
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
           .keyTypes({BIGINT(), BIGINT()})
           .probeVectors(2'000, 3)
           .buildVectors(2'000, 3)
@@ -4827,7 +4914,7 @@ TEST_F(HashJoinTest, spillPartitionBitsOverlap) {
 
 // The test is to verify if the hash build reservation has been released on
 // task error.
-DEBUG_ONLY_TEST_F(HashJoinTest, buildReservationReleaseCheck) {
+DEBUG_ONLY_TEST_P(HashJoinTest, buildReservationReleaseCheck) {
   std::vector<RowVectorPtr> probeVectors =
       makeBatches(1, [&](int32_t /*unused*/) {
         return std::dynamic_pointer_cast<RowVector>(
@@ -4879,7 +4966,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, buildReservationReleaseCheck) {
   ASSERT_TRUE(waitForTaskAborted(task, 5'000'000));
 }
 
-TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
+TEST_P(HashJoinTest, dynamicFilterOnPartitionKey) {
   vector_size_t size = 10;
   auto filePaths = makeFilePaths(1);
   auto rowVector = makeRowVector(
@@ -4894,7 +4981,7 @@ TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
                    .partitionKey("k", "0")
                    .build();
   auto outputType = ROW({"n1_0", "n1_1"}, {BIGINT(), BIGINT()});
-  ColumnHandleMap assignments = {
+  connector::ColumnHandleMap assignments = {
       {"n1_0", regularColumn("c0", BIGINT())},
       {"n1_1", partitionKey("k", BIGINT())}};
 
@@ -4926,7 +5013,7 @@ TEST_F(HashJoinTest, dynamicFilterOnPartitionKey) {
       .run();
 }
 
-TEST_F(HashJoinTest, probeMemoryLimitOnBuildProjection) {
+TEST_P(HashJoinTest, probeMemoryLimitOnBuildProjection) {
   const uint64_t numBuildRows = 20;
   std::vector<RowVectorPtr> probeVectors =
       makeBatches(10, [&](int32_t /*unused*/) {
@@ -5031,7 +5118,7 @@ TEST_F(HashJoinTest, probeMemoryLimitOnBuildProjection) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringInputProcessing) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
   const int32_t numBuildVectors = 10;
@@ -5126,6 +5213,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
     std::thread taskThread([&]() {
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
           .planNode(plan)
           .queryPool(std::move(queryPool))
           .injectSpill(false)
@@ -5197,7 +5285,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringInputProcessing) {
   ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{});
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringReserve) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   const int32_t numBuildVectors = 3;
   std::vector<RowVectorPtr> buildVectors;
@@ -5281,6 +5369,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
   std::thread taskThread([&]() {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .planNode(plan)
         .queryPool(std::move(queryPool))
         .injectSpill(false)
@@ -5330,7 +5419,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
   taskThread.join();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringAllocation) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
   const int32_t numBuildVectors = 10;
@@ -5414,6 +5503,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
     std::thread taskThread([&]() {
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
           .planNode(plan)
           .queryPool(std::move(queryPool))
           .injectSpill(false)
@@ -5461,7 +5551,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
   ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{0});
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringOutputProcessing) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
   const int32_t numBuildVectors = 10;
@@ -5533,6 +5623,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
     std::thread taskThread([&]() {
       HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
           .numDrivers(numDrivers_)
+          .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
           .planNode(plan)
           .queryPool(std::move(queryPool))
           .injectSpill(false)
@@ -5594,7 +5685,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
   ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringWaitForProbe) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
   const int32_t numBuildVectors = 10;
@@ -5680,6 +5771,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
   std::thread taskThread([&]() {
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .planNode(plan)
         .queryPool(std::move(queryPool))
         .injectSpill(false)
@@ -5732,7 +5824,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
   ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
   const auto buildVectors = makeVectors(buildType_, 10, 128);
   const auto probeVectors = makeVectors(probeType_, 5, 128);
 
@@ -5798,6 +5890,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
     VELOX_ASSERT_THROW(
         HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
             .numDrivers(numDrivers_)
+            .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
             .planNode(plan)
             .injectSpill(false)
             .referenceQuery(
@@ -5808,7 +5901,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringInputProcessing) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashBuildAbortDuringInputProcessing) {
   const auto buildVectors = makeVectors(buildType_, 10, 128);
   const auto probeVectors = makeVectors(probeType_, 5, 128);
 
@@ -5874,6 +5967,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringInputProcessing) {
     VELOX_ASSERT_THROW(
         HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
             .numDrivers(numDrivers_)
+            .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
             .planNode(plan)
             .injectSpill(false)
             .referenceQuery(
@@ -5885,7 +5979,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringInputProcessing) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringAllocation) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashBuildAbortDuringAllocation) {
   const auto buildVectors = makeVectors(buildType_, 10, 128);
   const auto probeVectors = makeVectors(probeType_, 5, 128);
 
@@ -5952,6 +6046,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringAllocation) {
     VELOX_ASSERT_THROW(
         HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
             .numDrivers(numDrivers_)
+            .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
             .planNode(plan)
             .injectSpill(false)
             .referenceQuery(
@@ -5963,7 +6058,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringAllocation) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeAbortDuringInputProcessing) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeAbortDuringInputProcessing) {
   const auto buildVectors = makeVectors(buildType_, 10, 128);
   const auto probeVectors = makeVectors(probeType_, 5, 128);
 
@@ -6025,6 +6120,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeAbortDuringInputProcessing) {
     VELOX_ASSERT_THROW(
         HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
             .numDrivers(numDrivers_)
+            .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
             .planNode(plan)
             .injectSpill(false)
             .referenceQuery(
@@ -6035,7 +6131,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeAbortDuringInputProcessing) {
   }
 }
 
-TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
+TEST_P(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
   // Tests some cases where the row at the end of an output batch fails the
   // filter.
   auto probeVectors = std::vector<RowVectorPtr>{makeRowVector(
@@ -6070,9 +6166,10 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
         .numDrivers(1)
         .config(
             core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .referenceQuery(fmt::format(
-            "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
-            filter))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
+                filter))
         .run();
   };
 
@@ -6086,7 +6183,7 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
   test("t_k2 > 9");
 }
 
-TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
+TEST_P(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
   // Tests some cases where the row at the end of an output batch fails the
   // filter and there are multiple matches with the build side..
   auto probeVectors = std::vector<RowVectorPtr>{makeRowVector(
@@ -6121,9 +6218,10 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
         .numDrivers(1)
         .config(
             core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
-        .referenceQuery(fmt::format(
-            "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
-            filter))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
+                filter))
         .run();
   };
 
@@ -6135,7 +6233,7 @@ TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
   test("t_k2 != 4 and t_k2 != 8");
 }
 
-TEST_F(HashJoinTest, leftJoinPreserveProbeOrder) {
+TEST_P(HashJoinTest, leftJoinPreserveProbeOrder) {
   const std::vector<RowVectorPtr> probeVectors = {
       makeRowVector(
           {"k1", "v1"},
@@ -6177,7 +6275,7 @@ TEST_F(HashJoinTest, leftJoinPreserveProbeOrder) {
   ASSERT_EQ(v1->valueAt(2), 0);
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
+DEBUG_ONLY_TEST_P(HashJoinTest, minSpillableMemoryReservation) {
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
   const int32_t numBuildVectors = 10;
   std::vector<RowVectorPtr> buildVectors;
@@ -6208,8 +6306,9 @@ DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
                   .planNode();
 
   for (int32_t minSpillableReservationPct : {5, 50, 100}) {
-    SCOPED_TRACE(fmt::format(
-        "minSpillableReservationPct: {}", minSpillableReservationPct));
+    SCOPED_TRACE(
+        fmt::format(
+            "minSpillableReservationPct: {}", minSpillableReservationPct));
 
     SCOPED_TESTVALUE_SET(
         "facebook::velox::exec::HashBuild::addInput",
@@ -6226,6 +6325,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
     auto tempDirectory = exec::test::TempDirectoryPath::create();
     HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
         .numDrivers(numDrivers_)
+        .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
         .planNode(plan)
         .injectSpill(false)
         .spillDirectory(tempDirectory->getPath())
@@ -6235,7 +6335,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, minSpillableMemoryReservation) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, exceededMaxSpillLevel) {
+DEBUG_ONLY_TEST_P(HashJoinTest, exceededMaxSpillLevel) {
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
   const int32_t numBuildVectors = 10;
   std::vector<RowVectorPtr> buildVectors;
@@ -6325,7 +6425,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, exceededMaxSpillLevel) {
       exceededMaxSpillLevelCount + 16);
 }
 
-TEST_F(HashJoinTest, maxSpillBytes) {
+TEST_P(HashJoinTest, maxSpillBytes) {
   const auto rowType =
       ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
   const auto probeVectors = createVectors(rowType, 1024, 10 << 20);
@@ -6382,7 +6482,7 @@ TEST_F(HashJoinTest, maxSpillBytes) {
   }
 }
 
-TEST_F(HashJoinTest, onlyHashBuildMaxSpillBytes) {
+TEST_P(HashJoinTest, onlyHashBuildMaxSpillBytes) {
   const auto rowType =
       ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), VARCHAR()});
   const auto probeVectors = createVectors(rowType, 32, 128);
@@ -6438,7 +6538,7 @@ TEST_F(HashJoinTest, onlyHashBuildMaxSpillBytes) {
   }
 }
 
-TEST_F(HashJoinTest, reclaimFromJoinBuilderWithMultiDrivers) {
+TEST_P(HashJoinTest, reclaimFromJoinBuilderWithMultiDrivers) {
   auto rowType = ROW({
       {"c0", INTEGER()},
       {"c1", INTEGER()},
@@ -6487,7 +6587,135 @@ TEST_F(HashJoinTest, reclaimFromJoinBuilderWithMultiDrivers) {
   ASSERT_GT(arbitrator->stats().reclaimedUsedBytes, 0);
 }
 
-DEBUG_ONLY_TEST_F(
+TEST_P(HashJoinTest, semiJoinAbandonBuildNoDupHashEarly) {
+  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeFlatVector<int64_t>({1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7}),
+        makeFlatVector<int64_t>({10, 20, 21, 30, 31, 32, 40, 50, 51, 60, 70}),
+    });
+  });
+
+  auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeFlatVector<int64_t>({1, 1, 3, 4, 5, 5, 7, 8}),
+        makeFlatVector<int64_t>({100, 101, 300, 400, 500, 501, 700, 800}),
+    });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t0", "t1", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .config(core::QueryConfig::kAbandonDedupHashMapMinRows, "1")
+      .config(core::QueryConfig::kAbandonDedupHashMapMinPct, "10")
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+      .run();
+}
+
+TEST_P(HashJoinTest, antiJoinAbandonBuildNoDupHashEarly) {
+  auto probeVectors = makeBatches(64, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 1, 2, 3, 4, 5, 6}),
+            makeFlatVector<int32_t>({0, 1, 2, 3, 4, 5, 6}),
+        });
+  });
+  auto buildVectors = makeBatches(64, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 2, 3, 4, 6, 7, 8}),
+            makeFlatVector<int32_t>({0, 2, 3, 4, 6, 7, 8}),
+        });
+  });
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .config(core::QueryConfig::kAbandonDedupHashMapMinRows, "1")
+      .config(core::QueryConfig::kAbandonDedupHashMapMinPct, "10")
+      .numDrivers(numDrivers_)
+      .probeKeys({"t0"})
+      .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+      .buildKeys({"u0"})
+      .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+      .joinType(core::JoinType::kAnti)
+      .joinOutputLayout({"t0", "t1"})
+      .referenceQuery(
+          "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0)")
+      .run();
+}
+
+TEST_P(HashJoinTest, semiJoinDeduplicateResetCapacity) {
+  const int32_t vectorSize = 10;
+  const int32_t batches = 210;
+  auto probeVectors = makeBatches(batches, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        // Join Key is double -> VectorHasher::typeKindSupportsValueIds will
+        // return false -> HashMode is kHash
+        makeFlatVector<double>(
+            vectorSize, [&](vector_size_t /*row*/) { return rand(); }),
+        makeFlatVector<int64_t>(
+            vectorSize, [&](vector_size_t /*row*/) { return rand(); }),
+    });
+  });
+
+  auto buildVectors = makeBatches(batches, [&](int32_t batch) {
+    return makeRowVector({
+        makeFlatVector<double>(
+            vectorSize, [&](vector_size_t /*row*/) { return rand(); }),
+        makeFlatVector<int64_t>(
+            vectorSize, [&](vector_size_t /*row*/) { return rand(); }),
+    });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t0", "t1", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .config(core::QueryConfig::kAbandonDedupHashMapMinRows, "10")
+      .config(core::QueryConfig::kAbandonDedupHashMapMinPct, "50")
+      .numDrivers(1)
+      .checkSpillStats(false)
+      .planNode(plan)
+      .referenceQuery(
+          "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+      .run();
+}
+
+DEBUG_ONLY_TEST_P(
     HashJoinTest,
     failedToReclaimFromHashJoinBuildersInNonReclaimableSection) {
   auto rowType = ROW({
@@ -6580,7 +6808,7 @@ DEBUG_ONLY_TEST_F(
       2);
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringTableBuild) {
+DEBUG_ONLY_TEST_P(HashJoinTest, reclaimDuringTableBuild) {
   VectorFuzzer fuzzer({.vectorSize = 1000}, pool());
   const int32_t numBuildVectors = 5;
   std::vector<RowVectorPtr> buildVectors;
@@ -6640,7 +6868,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringTableBuild) {
       .run();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, exceptionDuringFinishJoinBuild) {
+DEBUG_ONLY_TEST_P(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();
@@ -6724,7 +6952,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, exceptionDuringFinishJoinBuild) {
   ASSERT_EQ(arbitrator->stats().freeCapacityBytes, expectedFreeCapacityBytes);
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredDuringParallelJoinBuild) {
+DEBUG_ONLY_TEST_P(HashJoinTest, arbitrationTriggeredDuringParallelJoinBuild) {
   std::unique_ptr<memory::MemoryManager> memoryManager = createMemoryManager();
   const uint64_t numDrivers = 2;
 
@@ -6839,7 +7067,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredDuringParallelJoinBuild) {
   waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredByEnsureJoinTableFit) {
+DEBUG_ONLY_TEST_P(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
@@ -6853,6 +7081,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredByEnsureJoinTableFit) {
   auto tempDirectory = exec::test::TempDirectoryPath::create();
   HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
       .numDrivers(numDrivers_)
+      .parallelizeJoinBuildRows(parallelBuildSideRowsEnabled_)
       .injectSpill(false)
       .spillDirectory(tempDirectory->getPath())
       .keyTypes({BIGINT()})
@@ -6867,8 +7096,8 @@ DEBUG_ONLY_TEST_F(HashJoinTest, arbitrationTriggeredByEnsureJoinTableFit) {
       .run();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, joinBuildSpillError) {
-  const int kMemoryCapacity = 32 << 20;
+DEBUG_ONLY_TEST_P(HashJoinTest, joinBuildSpillError) {
+  const int kMemoryCapacity = 27 << 20;
   // Set a small memory capacity to trigger spill.
   std::unique_ptr<memory::MemoryManager> memoryManager =
       createMemoryManager(kMemoryCapacity, 0);
@@ -6930,7 +7159,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, joinBuildSpillError) {
   waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, probeSpillOnWaitForPeers) {
+DEBUG_ONLY_TEST_P(HashJoinTest, probeSpillOnWaitForPeers) {
   // This test creates a scenario when tester probe thread finishes processing
   // input, entering kWaitForPeers state, and the other thread is still
   // processing, spill is triggered properly performed.
@@ -7037,7 +7266,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, probeSpillOnWaitForPeers) {
   waitForAllTasksToBeDeleted();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, taskWaitTimeout) {
+DEBUG_ONLY_TEST_P(HashJoinTest, taskWaitTimeout) {
   const int queryMemoryCapacity = 128 << 20;
   // Creates a large number of vectors based on the query capacity to trigger
   // memory arbitration.
@@ -7127,7 +7356,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, taskWaitTimeout) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpill) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpill) {
   struct {
     bool triggerBuildSpill;
     // Triggers after no more input or not.
@@ -7217,7 +7446,9 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpill) {
         .injectSpill(false)
         .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
           auto opStats = toOperatorStats(task->taskStats());
-          ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+          if (!parallelBuildSideRowsEnabled_) {
+            ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+          }
           if (testData.triggerBuildSpill) {
             ASSERT_GT(opStats.at("HashBuild").spilledBytes, 0);
           } else {
@@ -7232,7 +7463,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpill) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfLastOutputProcessing) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillInMiddleOfLastOutputProcessing) {
   std::atomic_int outputCountAfterNoMoreInout{0};
   std::atomic_bool injectOnce{true};
   ::facebook::velox::common::testutil::ScopedTestValue abc(
@@ -7285,7 +7516,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfLastOutputProcessing) {
 // 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) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillInMiddleOfOutputProcessing) {
   for (bool recursiveSpill : {false, true}) {
     std::atomic_int buildInputCount{0};
     SCOPED_TESTVALUE_SET(
@@ -7355,7 +7586,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillInMiddeOfOutputProcessing) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillWhenOneOfProbeFinish) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillWhenOneOfProbeFinish) {
   const int numDrivers{3};
 
   std::atomic_bool probeWaitFlag{true};
@@ -7412,7 +7643,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillWhenOneOfProbeFinish) {
   queryThread.join();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillExceedLimit) {
+DEBUG_ONLY_TEST_P(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));
@@ -7484,7 +7715,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillExceedLimit) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillUnderNonReclaimableSection) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashProbeSpillUnderNonReclaimableSection) {
   std::atomic_bool injectOnce{true};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
@@ -7528,7 +7759,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashProbeSpillUnderNonReclaimableSection) {
 // 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) {
+DEBUG_ONLY_TEST_P(HashJoinTest, spillOutputWithRightSemiJoins) {
   for (const auto joinType :
        {core::JoinType::kRightSemiFilter, core::JoinType::kRightSemiProject}) {
     std::atomic_bool injectOnce{true};
@@ -7584,7 +7815,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, spillOutputWithRightSemiJoins) {
   }
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, spillCheckOnLeftSemiFilterWithDynamicFilters) {
+DEBUG_ONLY_TEST_P(HashJoinTest, spillCheckOnLeftSemiFilterWithDynamicFilters) {
   const int32_t numSplits = 10;
   const int32_t numRowsProbe = 333;
   const int32_t numRowsBuild = 100;
@@ -7700,7 +7931,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, spillCheckOnLeftSemiFilterWithDynamicFilters) {
 // start processing. This can cause unnecessary spill and query OOM under some
 // real workload with many stages as each hash probe might reserve non-trivial
 // amount of memory.
-DEBUG_ONLY_TEST_F(
+DEBUG_ONLY_TEST_P(
     HashJoinTest,
     hashProbeMemoryReservationCheckBeforeProbeStartWithSpillEnabled) {
   fuzzerOpts_.vectorSize = 128;
@@ -7746,7 +7977,7 @@ DEBUG_ONLY_TEST_F(
       .run();
 }
 
-TEST_F(HashJoinTest, nanKeys) {
+TEST_P(HashJoinTest, nanKeys) {
   // Verify the NaN values with different binary representations are considered
   // equal.
   static const double kNan = std::numeric_limits<double>::quiet_NaN();
@@ -7780,7 +8011,7 @@ TEST_F(HashJoinTest, nanKeys) {
   facebook::velox::test::assertEqualVectors(expected, result);
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, spillOnBlockedProbe) {
+DEBUG_ONLY_TEST_P(HashJoinTest, spillOnBlockedProbe) {
   auto blockedOperatorFactoryUniquePtr =
       std::make_unique<BlockedOperatorFactory>();
   auto blockedOperatorFactory = blockedOperatorFactoryUniquePtr.get();
@@ -7854,9 +8085,10 @@ DEBUG_ONLY_TEST_F(HashJoinTest, spillOnBlockedProbe) {
   }
   arbitrationThread.join();
   waitForAllTasksToBeDeleted(30'000'000);
+  Operator::unregisterAllOperators();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, buildReclaimedMemoryReport) {
+DEBUG_ONLY_TEST_P(HashJoinTest, buildReclaimedMemoryReport) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   const int32_t numBuildVectors = 3;
   std::vector<RowVectorPtr> buildVectors;
@@ -7983,7 +8215,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, buildReclaimedMemoryReport) {
   taskThread.join();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, probeReclaimedMemoryReport) {
+DEBUG_ONLY_TEST_P(HashJoinTest, probeReclaimedMemoryReport) {
   constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
   const int32_t numBuildVectors = 3;
   std::vector<RowVectorPtr> buildVectors;
@@ -8088,7 +8320,7 @@ DEBUG_ONLY_TEST_F(HashJoinTest, probeReclaimedMemoryReport) {
   taskThread.join();
 }
 
-DEBUG_ONLY_TEST_F(HashJoinTest, hashTableCleanupAfterProbeFinish) {
+DEBUG_ONLY_TEST_P(HashJoinTest, hashTableCleanupAfterProbeFinish) {
   auto buildVectors = makeVectors(buildType_, 5, 100);
   auto probeVectors = makeVectors(probeType_, 5, 100);
 
@@ -8139,4 +8371,347 @@ DEBUG_ONLY_TEST_F(HashJoinTest, hashTableCleanupAfterProbeFinish) {
       .run();
   ASSERT_TRUE(tableEmpty);
 }
+
+TEST_P(HashJoinTest, innerJoinForTypeWithCustomComparisonAndSmallVector) {
+  // This test corresponds to the SQL query:
+  // SELECT
+  //   LEFT_TABLE.ip_addr as ip_left_string,
+  //   RIGHT_TABLE.ip_addr as ip_right_string,
+  //   CAST(LEFT_TABLE.ip_addr AS IPADDRESS) as ip_left_ip_address_type,
+  //   CAST(RIGHT_TABLE.ip_addr AS IPADDRESS) as ip_right_ip_address_type,
+  //   CAST(LEFT_TABLE.ip_addr AS IPADDRESS) = CAST(RIGHT_TABLE.ip_addr AS
+  //   IPADDRESS) as are_equal_as_ip_address_type
+  // FROM
+  //   (VALUES ('2620:10d:c0a8:f0::37'), ('2620:10d:c053:33::37')) AS
+  //   LEFT_TABLE(ip_addr) INNER JOIN (VALUES ('2620:10d:c0a8:f0::37')) AS
+  //   RIGHT_TABLE(ip_addr) ON CAST(LEFT_TABLE.ip_addr AS IPADDRESS) =
+  //   CAST(RIGHT_TABLE.ip_addr AS IPADDRESS)
+  // LIMIT 1000
+
+  auto leftVectors = makeRowVector({makeFlatVector<StringView>(
+      {StringView("2620:10d:c0a8:f0::37"),
+       StringView("2620:10d:c053:33::37")})});
+
+  auto rightVectors = makeRowVector(
+      {makeFlatVector<StringView>({StringView("2620:10d:c0a8:f0::37")})});
+  createDuckDbTable("t", {leftVectors});
+  createDuckDbTable("u", {rightVectors});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto rightPlan = PlanBuilder(planNodeIdGenerator)
+                       .values({rightVectors})
+                       .project(
+                           {"c0 AS ip_addr_right",
+                            "CAST(c0 AS IPADDRESS) AS ip_addr_cast_right"})
+                       .planNode();
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .values({leftVectors})
+          .project({"c0 AS ip_addr", "CAST(c0 AS IPADDRESS) AS ip_addr_cast"})
+          .hashJoin(
+              {"ip_addr_cast"},
+              {"ip_addr_cast_right"},
+              rightPlan,
+              "",
+              {"ip_addr", "ip_addr_cast"},
+              core::JoinType::kInner)
+          .limit(0, 1000, false)
+          .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto ipAddr = result->childAt(0)->as<SimpleVector<StringView>>();
+
+  // We expect 1 row (only the matching IPv6 address: 2620:10d:c0a8:f0::37)
+  ASSERT_EQ(ipAddr->valueAt(0), StringView("2620:10d:c0a8:f0::37"));
+
+  // Test that different IPADDRESS values correctly don't match in hash join.
+  leftVectors = makeRowVector({
+      makeFlatVector<StringView>({
+          "2620:10d:c053:33::37"_sv,
+      }),
+  });
+
+  rightVectors = makeRowVector({
+      makeFlatVector<StringView>({
+          "2620:10d:c0a8:f0::37"_sv,
+      }),
+  });
+
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  rightPlan = PlanBuilder(planNodeIdGenerator)
+                  .values({rightVectors})
+                  .project(
+                      {"c0 AS ip_addr_right",
+                       "CAST(c0 AS IPADDRESS) AS ip_addr_cast_right"})
+                  .planNode();
+
+  plan = PlanBuilder(planNodeIdGenerator)
+             .values({leftVectors})
+             .project(
+                 {"c0 AS ip_left",
+                  "CAST(c0 AS IPADDRESS) AS ip_left_cast",
+                  "CAST(c0 AS VARCHAR) AS ip_left_string"})
+             .hashJoin(
+                 {"ip_left_cast"},
+                 {"ip_addr_cast_right"},
+                 rightPlan,
+                 "",
+                 {"ip_left_cast", "ip_addr_cast_right", "ip_addr_right"},
+                 core::JoinType::kInner)
+             .planNode();
+
+  // Result should be empty since the IP addresses are different
+  result = AssertQueryBuilder(plan).copyResults(pool());
+  ASSERT_EQ(result->size(), 0)
+      << "Expected no matches between different IP addresses, but got "
+      << result->size() << " rows";
+}
+
+/// Test hash join where build-side keys have a type that supports custom
+/// comparison and come from a small range which would allow for array-based
+/// lookup instead of a hash table for other types.
+TEST_P(HashJoinTest, arrayBasedLookupCustomComparisonType) {
+  std::vector<RowVectorPtr> probeVectors = {
+      makeRowVector({makeFlatVector<int64_t>(
+          1'024,
+          [](auto row) { return row; },
+          nullptr,
+          velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON())})};
+
+  std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector({makeFlatVector<int64_t>(
+          256,
+          [](auto row) { return row; },
+          nullptr,
+          velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON())})};
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto rightPlan = PlanBuilder(planNodeIdGenerator)
+                       .values({buildVectors})
+                       .project({"c0 as right"})
+                       .planNode();
+
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .project({"c0 as left"})
+                  .hashJoin(
+                      {"left"},
+                      {"right"},
+                      rightPlan,
+                      "",
+                      {"left"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  // The probe side consists of the values 0-1023, the build side consists of
+  // the values 0-255. If custom comparison is not respected, the join will
+  // produce 256 values (0-255). When custom comparison is respected equality is
+  // treated mod 256 so we get 1024 values (0-1023).
+  EXPECT_EQ(result->size(), 1'024);
+}
+
+DEBUG_ONLY_TEST_P(
+    HashJoinTest,
+    hashProbeShouldYieldWhenFilterConsistentlyRejectAll) {
+  const uint32_t kProbeSize = 100;
+  const uint32_t kBuildSize = 10'000;
+  const uint64_t kDriverCpuTimeSliceLimitMs = 1'000;
+  const std::string kLargeBatchSize =
+      folly::to<std::string>(kProbeSize * kBuildSize);
+
+  struct {
+    uint32_t numGetOutputCalls;
+    bool hasDelay;
+    std::string debugString() const {
+      return fmt::format(
+          "numGetOutputCalls: {}, hasDelay: {}", numGetOutputCalls, hasDelay);
+    }
+  } testSettings[] = {{0, false}, {0, true}};
+
+  // Create probe data with keys 0-99 and an additional filter column
+  const auto probeData = makeRowVector(
+      {"t_k1", "t_filter"},
+      {
+          makeFlatVector<int32_t>(kProbeSize, [](auto row) { return row; }),
+          makeFlatVector<int32_t>(
+              kProbeSize,
+              [](/*row=*/auto) { return 1; }), // All rows have value 1
+      });
+
+  const auto buildData = makeRowVector(
+      {"u_k1"},
+      {
+          makeFlatVector<int32_t>(kBuildSize, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable("t", {probeData});
+  createDuckDbTable("u", {buildData});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values({probeData})
+          .hashJoin(
+              {"t_k1"},
+              {"u_k1"},
+              PlanBuilder(planNodeIdGenerator).values({buildData}).planNode(),
+              // Filter that DOES find join matches but then rejects all of them
+              // This ensures numOut > 0 after listJoinResults, but == 0 after
+              // evalFilter All probe rows have t_filter=1, so the condition
+              // t_filter > 100000 rejects all
+              "t_filter > 100000",
+              {"t_k1", "u_k1"},
+              core::JoinType::kInner)
+          .planNode();
+
+  for (auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    std::atomic_int hashProbeGetOutputCalls{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(Operator*)>([&](Operator* op) {
+          if (op->operatorType() == "HashProbe") {
+            // Inject delay on the 2nd getOutput call when hasDelay is true
+            // This simulates the scenario where:
+            // 1. First getOutput: Probe data added via addInput
+            // 2. Second getOutput: Join finds matches, filter rejects all
+            //    During this call, we inject delay INSIDE the processing
+            //    to simulate CPU-intensive work in the loop
+            if (hashProbeGetOutputCalls.fetch_add(1) == 1 &&
+                testData.hasDelay) {
+              std::this_thread::sleep_for(
+                  std::chrono::milliseconds(2 * kDriverCpuTimeSliceLimitMs));
+            }
+          }
+        }));
+
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(),
+        core::QueryConfig({
+            {core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+             folly::to<std::string>(kDriverCpuTimeSliceLimitMs)},
+            {core::QueryConfig::kPreferredOutputBatchRows, kLargeBatchSize},
+        }));
+
+    AssertQueryBuilder(planNode, duckDbQueryRunner_)
+        .queryCtx(queryCtx)
+        .maxDrivers(1)
+        .assertResults(
+            "SELECT t_k1, u_k1 FROM t, u WHERE t_k1 = u_k1 AND t_filter > 100000");
+    testData.numGetOutputCalls = hashProbeGetOutputCalls.load();
+  }
+  ASSERT_LT(
+      testSettings[0].numGetOutputCalls, testSettings[1].numGetOutputCalls);
+}
+
+// This test validates that when spillOutput() is running (toSpillOutput=true),
+// the operator should NOT yield even when shouldYield() returns true. This is
+// critical because yielding during spillOutput would break the spilling loop.
+DEBUG_ONLY_TEST_P(
+    HashJoinTest,
+    spillOutputShouldNotYieldWhenFilterConsistentlyRejectAll) {
+  const uint32_t kProbeSize = 100;
+  const uint32_t kBuildSize = 10'000;
+  const uint64_t driverCpuTimeSliceLimitMs = 1'000;
+  const std::string largeBatchSize =
+      folly::to<std::string>(kProbeSize * kBuildSize);
+
+  // Create probe data with keys 0-99 and an additional filter column
+  const auto probeData = makeRowVector(
+      {"t_k1", "t_filter"},
+      {
+          makeFlatVector<int32_t>(kProbeSize, [](auto row) { return row; }),
+          makeFlatVector<int32_t>(
+              kProbeSize,
+              [](/*row=*/auto) { return 1; }), // All rows have value 1
+      });
+
+  const auto buildData = makeRowVector(
+      {"u_k1"},
+      {
+          makeFlatVector<int32_t>(kBuildSize, [](auto row) { return row; }),
+      });
+
+  createDuckDbTable("t", {probeData});
+  createDuckDbTable("u", {buildData});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values({probeData})
+          .hashJoin(
+              {"t_k1"},
+              {"u_k1"},
+              PlanBuilder(planNodeIdGenerator).values({buildData}).planNode(),
+              // Filter that DOES find join matches but then rejects all of them
+              // This ensures numOut > 0 after listJoinResults, but == 0 after
+              // evalFilter. All probe rows have t_filter=1, so the condition
+              // t_filter > 100000 rejects all
+              "t_filter > 100000",
+              {"t_k1", "u_k1"},
+              core::JoinType::kInner)
+          .planNode();
+
+  std::atomic_bool spillTriggered{false};
+  ::facebook ::velox ::common ::testutil ::ScopedTestValue _scopedTestValue5200(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (spillTriggered.load() || op->operatorType() != "HashProbe" ||
+            !op->testingHasInput()) {
+          return;
+        }
+        spillTriggered = true;
+        testingRunArbitration(op->pool());
+      }));
+
+  // We inject delay in reclaim to trigger shouldYield().
+  // The test verifies that the query completes successfully despite
+  // shouldYield() returning true, which would only happen if the
+  // !toSpillOutput check prevents early return.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashProbe::reclaim",
+      std::function<void(HashProbe*)>([&](HashProbe* probe) {
+        if (!spillTriggered.load()) {
+          return;
+        }
+        // Inject delay once to trigger shouldYield()
+        std::this_thread::sleep_for(
+            std::chrono::milliseconds(2 * driverCpuTimeSliceLimitMs));
+      }));
+
+  const auto spillDirectory = exec::test::TempDirectoryPath::create();
+  AssertQueryBuilder(planNode, duckDbQueryRunner_)
+      .queryCtx(core::QueryCtx::create(driverExecutor_.get()))
+      .maxDrivers(1)
+      .spillDirectory(spillDirectory->getPath())
+      .config(core::QueryConfig::kSpillEnabled, true)
+      .config(core::QueryConfig::kJoinSpillEnabled, true)
+      .config(core::QueryConfig::kSpillStartPartitionBit, 29)
+      .config(
+          core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+          driverCpuTimeSliceLimitMs)
+      .config(core::QueryConfig::kPreferredOutputBatchRows, largeBatchSize)
+      .assertResults(
+          "SELECT t_k1, u_k1 FROM t, u WHERE t_k1 = u_k1 AND t_filter > 100000");
+
+  ASSERT_TRUE(spillTriggered.load());
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    HashJoinTest,
+    HashJoinTest,
+    testing::ValuesIn(HashJoinTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return TestParamToName(info.param);
+    });
+
 } // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/HashJoinWithCacheTest.cpp b/velox/exec/tests/HashJoinWithCacheTest.cpp
new file mode 100644
index 000000000000..772c282a7804
--- /dev/null
+++ b/velox/exec/tests/HashJoinWithCacheTest.cpp
@@ -0,0 +1,574 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <thread>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/memory/MemoryArbitrator.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/exec/Cursor.h"
+#include "velox/exec/HashJoinBridge.h"
+#include "velox/exec/HashProbe.h"
+#include "velox/exec/HashTable.h"
+#include "velox/exec/HashTableCache.h"
+#include "velox/exec/MemoryReclaimer.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/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+
+#include "velox/exec/tests/utils/VectorTestUtil.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+// Test fixture for hash join with hash table caching tests.
+class HashJoinWithCacheTest : public HiveConnectorTestBase {};
+
+// Tests hash table caching for broadcast joins.
+// First task builds the table (cache miss), second task reuses it (cache hit).
+TEST_F(HashJoinWithCacheTest, sequential) {
+  // Use a unique query ID for this test to ensure clean cache state.
+  const std::string queryId =
+      "hashTableCachingTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  // Create probe and build vectors with distinct column names.
+  std::vector<RowVectorPtr> probeVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> buildVectors = makeBatches(5, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(50, [](auto row) { return row % 31; }),
+            makeFlatVector<int64_t>(50, [](auto row) { return row * 10; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  // Build the plan using HashJoinNode::Builder to set useHashTableCache.
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  // Create HashJoinNode with useHashTableCache = true.
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+  const auto joinNodeId = joinNode->id();
+
+  const int numDrivers = 3;
+
+  // Create a shared QueryCtx for all tasks.
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Helper to run a task and return the completed task.
+  // Both tasks use the same queryCtx so they share the cache entry.
+  auto runTask = [&]() {
+    return AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+        .queryCtx(queryCtx)
+        .maxDrivers(numDrivers)
+        .assertResults(
+            "SELECT t.t_k, t.t_v, u.u_k, u.u_v FROM t, u WHERE t.t_k = u.u_k");
+  };
+
+  // First task - should build the table (cache miss).
+  auto task1 = runTask();
+
+  // Get stats from first task - expect cache miss.
+  auto opStats1 = toOperatorStats(task1->taskStats());
+  ASSERT_EQ(opStats1.count("HashBuild"), 1);
+  auto& hashBuildStats1 = opStats1.at("HashBuild");
+
+  // The last driver that finishes building reports the cache miss stat.
+  ASSERT_EQ(
+      hashBuildStats1.runtimeStats.count(BaseHashTable::kHashTableCacheMiss), 1)
+      << "First task should report cache miss";
+  EXPECT_EQ(
+      hashBuildStats1.runtimeStats.at(BaseHashTable::kHashTableCacheMiss).count,
+      1)
+      << "Exactly one driver should report cache miss (the one that builds)";
+  EXPECT_EQ(
+      hashBuildStats1.runtimeStats.count(BaseHashTable::kHashTableCacheHit), 0)
+      << "First task should not have any cache hits";
+
+  // Second task - should reuse the cached table (cache hit).
+  auto task2 = runTask();
+
+  // Get stats from second task - expect cache hit.
+  auto opStats2 = toOperatorStats(task2->taskStats());
+  ASSERT_EQ(opStats2.count("HashBuild"), 1);
+  auto& hashBuildStats2 = opStats2.at("HashBuild");
+
+  // The last driver that finishes reports the cache hit stat.
+  ASSERT_EQ(
+      hashBuildStats2.runtimeStats.count(BaseHashTable::kHashTableCacheHit), 1)
+      << "Second task should report cache hit";
+  EXPECT_EQ(
+      hashBuildStats2.runtimeStats.at(BaseHashTable::kHashTableCacheHit).count,
+      1)
+      << "Exactly one driver should report cache hit (the one after barrier)";
+  EXPECT_EQ(
+      hashBuildStats2.runtimeStats.count(BaseHashTable::kHashTableCacheMiss), 0)
+      << "Second task should not have any cache misses";
+
+  // Clean up cache entry before tasks are destroyed.
+  // The release callback on QueryCtx fires too late (after Task destruction
+  // starts), so we need explicit cleanup in tests.
+  const auto cacheKey = fmt::format("{}:{}", queryId, joinNodeId);
+  HashTableCache::instance()->drop(cacheKey);
+}
+
+// Tests that multiple tasks running concurrently share the cached hash table.
+// One task builds the table (cache miss), all others wait and reuse it
+// (cache hits).
+TEST_F(HashJoinWithCacheTest, concurrent) {
+  // Use a unique query ID for this test to ensure clean cache state.
+  const std::string queryId =
+      "hashTableCachingConcurrentTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  // Create probe and build vectors with distinct column names.
+  std::vector<RowVectorPtr> probeVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> buildVectors = makeBatches(5, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(50, [](auto row) { return row % 31; }),
+            makeFlatVector<int64_t>(50, [](auto row) { return row * 10; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  // Build the plan using HashJoinNode::Builder to set useHashTableCache.
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  // Create HashJoinNode with useHashTableCache = true.
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+  const auto joinNodeId = joinNode->id();
+
+  const int numDrivers = 3;
+
+  // Create a shared QueryCtx for all tasks.
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Helper to run a task and return the completed task.
+  // All tasks use the same queryCtx so they share the cache entry.
+  auto runTask = [&]() {
+    return AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+        .queryCtx(queryCtx)
+        .maxDrivers(numDrivers)
+        .assertResults(
+            "SELECT t.t_k, t.t_v, u.u_k, u.u_v FROM t, u WHERE t.t_k = u.u_k");
+  };
+
+  // Run 10 threads concurrently, each executing 5 tasks sequentially.
+  constexpr int kNumThreads = 10;
+  constexpr int kTasksPerThread = 5;
+  constexpr int kTotalTasks = kNumThreads * kTasksPerThread;
+
+  // Each thread maintains its own local vector of tasks.
+  std::vector<std::vector<std::shared_ptr<Task>>> threadTasks(kNumThreads);
+  std::vector<std::thread> threads;
+  threads.reserve(kNumThreads);
+
+  // Launch all threads at once.
+  for (int i = 0; i < kNumThreads; ++i) {
+    threads.emplace_back([&, i]() {
+      // Each thread runs multiple tasks sequentially into its local vector.
+      threadTasks[i].reserve(kTasksPerThread);
+      for (int j = 0; j < kTasksPerThread; ++j) {
+        threadTasks[i].push_back(runTask());
+      }
+    });
+  }
+
+  // Wait for all threads to complete.
+  for (auto& thread : threads) {
+    thread.join();
+  }
+
+  // Merge all thread-local task vectors into a single vector.
+  std::vector<std::shared_ptr<Task>> allTasks;
+  allTasks.reserve(kTotalTasks);
+  for (auto& tasks : threadTasks) {
+    for (auto& task : tasks) {
+      allTasks.push_back(std::move(task));
+    }
+  }
+
+  ASSERT_EQ(allTasks.size(), kTotalTasks);
+
+  // Collect stats from all tasks.
+  int totalCacheMisses = 0;
+  int totalCacheHits = 0;
+
+  for (const auto& task : allTasks) {
+    auto opStats = toOperatorStats(task->taskStats());
+    ASSERT_EQ(opStats.count("HashBuild"), 1);
+    auto& hashBuildStats = opStats.at("HashBuild");
+
+    if (hashBuildStats.runtimeStats.count(BaseHashTable::kHashTableCacheMiss)) {
+      totalCacheMisses +=
+          hashBuildStats.runtimeStats.at(BaseHashTable::kHashTableCacheMiss)
+              .count;
+    }
+    if (hashBuildStats.runtimeStats.count(BaseHashTable::kHashTableCacheHit)) {
+      totalCacheHits +=
+          hashBuildStats.runtimeStats.at(BaseHashTable::kHashTableCacheHit)
+              .count;
+    }
+  }
+
+  // Exactly one task should build (cache miss) and all others should reuse
+  // (cache hits).
+  EXPECT_EQ(totalCacheMisses, 1)
+      << "Exactly one task should report a cache miss (the builder)";
+  EXPECT_EQ(totalCacheHits, kTotalTasks - 1)
+      << "All other tasks should report cache hits";
+
+  // Clean up cache entry before tasks are destroyed.
+  const auto cacheKey = fmt::format("{}:{}", queryId, joinNodeId);
+  HashTableCache::instance()->drop(cacheKey);
+}
+
+// Tests that HashBuild and HashProbe cannot reclaim when using a cached hash
+// table. When useHashTableCache() is true, canReclaim() returns false for both
+// operators because spilling would clear the cached table and corrupt it for
+// other tasks. This test uses TestValue to verify canReclaim() returns false.
+DEBUG_ONLY_TEST_F(HashJoinWithCacheTest, probeCannotSpillWithCachedTable) {
+  const std::string queryId =
+      "probeCannotSpillTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  // Create build and probe vectors.
+  std::vector<RowVectorPtr> buildVectors = makeBatches(1, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row * 10; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> probeVectors = makeBatches(5, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(100, [](auto row) { return row % 23; }),
+            makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+  const auto joinNodeId = joinNode->id();
+
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Use TestValue to verify canReclaim() returns false for HashBuild.
+  std::atomic_bool hashBuildChecked{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::addInput",
+      std::function<void(HashBuild*)>([&](HashBuild* build) {
+        if (hashBuildChecked.exchange(true)) {
+          return;
+        }
+        ASSERT_FALSE(build->canReclaim())
+            << "HashBuild should not be reclaimable with cached hash table";
+      }));
+
+  // Use TestValue to verify canReclaim() returns false for HashProbe.
+  std::atomic_bool hashProbeChecked{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (hashProbeChecked.exchange(true)) {
+          return;
+        }
+        auto* probe = dynamic_cast<HashProbe*>(op);
+        ASSERT_NE(probe, nullptr);
+        ASSERT_FALSE(probe->canReclaim())
+            << "HashProbe should not be reclaimable with cached hash table";
+      }));
+
+  // Run the query and verify results.
+  auto task =
+      AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+          .queryCtx(queryCtx)
+          .maxDrivers(1)
+          .assertResults(
+              "SELECT t.t_k, t.t_v, u.u_k, u.u_v FROM t, u WHERE t.t_k = u.u_k");
+
+  // Verify that both operators were checked.
+  ASSERT_TRUE(hashBuildChecked) << "HashBuild canReclaim check was not reached";
+  ASSERT_TRUE(hashProbeChecked) << "HashProbe canReclaim check was not reached";
+
+  // Verify that HashProbe operator stats show no spilling.
+  auto opStats = toOperatorStats(task->taskStats());
+  ASSERT_EQ(opStats.count("HashProbe"), 1);
+  auto& probeStats = opStats.at("HashProbe");
+
+  EXPECT_EQ(probeStats.spilledInputBytes, 0)
+      << "HashProbe should not spill when using cached hash table";
+  EXPECT_EQ(probeStats.spilledBytes, 0)
+      << "HashProbe should not spill when using cached hash table";
+
+  // Clean up cache entry before task is destroyed.
+  const auto cacheKey = fmt::format("{}:{}", queryId, joinNodeId);
+  HashTableCache::instance()->drop(cacheKey);
+}
+
+// Tests OOM behavior with cached hash tables via memory arbitration.
+// This test triggers memory arbitration during HashProbe to verify:
+// 1. HashProbe::canReclaim() returns false when useHashTableCache=true
+// 2. When an allocation exceeds capacity, arbitration runs but can't reclaim
+// 3. OOM is thrown by the arbitration framework
+// 4. Cleanup works correctly via QueryCtx release callbacks
+DEBUG_ONLY_TEST_F(HashJoinWithCacheTest, probeOOMWithCachedTable) {
+  const std::string queryId =
+      "probeOOMTest_" +
+      std::to_string(
+          std::chrono::steady_clock::now().time_since_epoch().count());
+
+  // Create build side with ~1MB hash table.
+  // 10 batches × 10,000 rows = 100,000 rows × 12 bytes = ~1.2MB raw data.
+  std::vector<RowVectorPtr> buildVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"u_k", "u_v"},
+        {
+            makeFlatVector<int32_t>(10000, [](auto row) { return row % 5000; }),
+            makeFlatVector<int64_t>(10000, [](auto row) { return row * 10; }),
+        });
+  });
+
+  // Create probe vectors with matching key range.
+  std::vector<RowVectorPtr> probeVectors = makeBatches(10, [&](int32_t) {
+    return makeRowVector(
+        {"t_k", "t_v"},
+        {
+            makeFlatVector<int32_t>(1000, [](auto row) { return row % 5000; }),
+            makeFlatVector<int64_t>(1000, [](auto row) { return row; }),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto buildPlanNode =
+      PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode();
+  auto probePlanNode =
+      PlanBuilder(planNodeIdGenerator).values(probeVectors).planNode();
+
+  auto outputType = ROW(
+      {"t_k", "t_v", "u_k", "u_v"}, {INTEGER(), BIGINT(), INTEGER(), BIGINT()});
+
+  auto joinNode =
+      core::HashJoinNode::Builder()
+          .id(planNodeIdGenerator->next())
+          .joinType(core::JoinType::kInner)
+          .nullAware(false)
+          .leftKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "t_k")})
+          .rightKeys(
+              {std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "u_k")})
+          .left(probePlanNode)
+          .right(buildPlanNode)
+          .outputType(outputType)
+          .useHashTableCache(true)
+          .build();
+
+  // Create QueryCtx with sufficient memory for build but we'll exhaust it
+  // during probe via TestValue injection.
+  auto queryCtx = core::QueryCtx::create(
+      driverExecutor_.get(),
+      core::QueryConfig({}),
+      std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
+      cache::AsyncDataCache::getInstance(),
+      nullptr,
+      nullptr,
+      queryId);
+
+  // Use a pool with limited capacity. Build uses ~10MB, so 20MB should be
+  // enough for build but tight for additional allocations during probe.
+  constexpr int64_t kPoolCapacity = 20 * 1024 * 1024; // 20MB
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kPoolCapacity, exec::MemoryReclaimer::create()));
+
+  // Use TestValue at the addInput injection point to trigger OOM during
+  // HashProbe. We allocate more memory than the pool has available, which
+  // triggers arbitration. Since HashProbe::canReclaim() returns false when
+  // useHashTableCache=true, arbitration cannot reclaim and OOM is thrown.
+  std::atomic_bool injected{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        // Only inject once, and only for HashProbe operator.
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (injected.exchange(true)) {
+          return;
+        }
+
+        auto* probe = dynamic_cast<HashProbe*>(op);
+        ASSERT_NE(probe, nullptr);
+
+        // Verify that HashProbe cannot reclaim when using cached hash table.
+        // canReclaim() returns false because canSpill() is false.
+        ASSERT_FALSE(probe->canReclaim())
+            << "HashProbe should not be reclaimable with cached hash table";
+
+        // Allocate memory equal to pool capacity.
+        // If HashProbe could spill, arbitration would reclaim memory and this
+        // allocation would succeed. But since canReclaim() returns false with
+        // cached hash table, arbitration can't free memory and OOM is thrown.
+        auto* pool = op->pool();
+        // This allocation will trigger arbitration and throw OOM.
+        pool->allocate(kPoolCapacity);
+      }));
+
+  // This should throw OOM during probe. The cleanup should work correctly.
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(joinNode, duckDbQueryRunner_)
+          .queryCtx(queryCtx)
+          .maxDrivers(1)
+          .copyResults(pool()),
+      "Exceeded memory pool capacity");
+
+  waitForAllTasksToBeDeleted();
+  queryCtx.reset();
+  // Cache should be cleaned up by QueryCtx destructor via release callback.
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HashTableCacheTest.cpp b/velox/exec/tests/HashTableCacheTest.cpp
new file mode 100644
index 000000000000..38be0378ba42
--- /dev/null
+++ b/velox/exec/tests/HashTableCacheTest.cpp
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/HashTableCache.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/caching/AsyncDataCache.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/core/QueryCtx.h"
+
+namespace facebook::velox::exec::test {
+
+class HashTableCacheTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addRootPool("HashTableCacheTest");
+    queryCtx_ = core::QueryCtx::create();
+  }
+
+  void TearDown() override {
+    // Clean up any cache entries created during tests.
+    auto* cache = HashTableCache::instance();
+    for (const auto& key : createdKeys_) {
+      cache->drop(key);
+    }
+    createdKeys_.clear();
+    queryCtx_.reset();
+  }
+
+  // Helper to track keys for cleanup.
+  void trackKey(const std::string& key) {
+    createdKeys_.push_back(key);
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+  std::vector<std::string> createdKeys_;
+};
+
+TEST_F(HashTableCacheTest, basicGet) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query1:node1";
+  trackKey(key);
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto entry = cache->get(key, "task1", queryCtx_.get(), &future);
+
+  ASSERT_NE(entry, nullptr);
+  ASSERT_NE(entry->tablePool, nullptr);
+  EXPECT_EQ(entry->builderTaskId, "task1");
+  EXPECT_FALSE(entry->buildComplete);
+  // First caller should not get a future (they are the builder).
+  EXPECT_FALSE(future.valid());
+}
+
+TEST_F(HashTableCacheTest, secondCallerGetsWaitFuture) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query2:node1";
+  trackKey(key);
+
+  // First caller (builder).
+  ContinueFuture future1 = ContinueFuture::makeEmpty();
+  auto entry1 = cache->get(key, "task1", queryCtx_.get(), &future1);
+  EXPECT_FALSE(future1.valid());
+  EXPECT_EQ(entry1->builderTaskId, "task1");
+
+  // Second caller (waiter).
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto entry2 = cache->get(key, "task2", queryCtx_.get(), &future2);
+
+  // Should get the same entry.
+  EXPECT_EQ(entry1, entry2);
+  // Should get a valid future to wait on.
+  EXPECT_TRUE(future2.valid());
+  // Builder task ID should not change.
+  EXPECT_EQ(entry2->builderTaskId, "task1");
+}
+
+TEST_F(HashTableCacheTest, putNotifiesWaiters) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query3:node1";
+  trackKey(key);
+
+  // First caller (builder).
+  ContinueFuture future1 = ContinueFuture::makeEmpty();
+  auto entry = cache->get(key, "task1", queryCtx_.get(), &future1);
+
+  // Second caller (waiter).
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  cache->get(key, "task2", queryCtx_.get(), &future2);
+  ASSERT_TRUE(future2.valid());
+
+  // Put the table.
+  cache->put(key, nullptr, false);
+
+  // Entry should now be marked complete.
+  EXPECT_TRUE(entry->buildComplete);
+
+  // The future should be fulfilled.
+  EXPECT_TRUE(future2.isReady());
+}
+
+TEST_F(HashTableCacheTest, getAfterBuildComplete) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query4:node1";
+  trackKey(key);
+
+  // First caller creates and builds.
+  ContinueFuture future1 = ContinueFuture::makeEmpty();
+  cache->get(key, "task1", queryCtx_.get(), &future1);
+  cache->put(key, nullptr, true);
+
+  // Later caller should get completed entry without waiting.
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto entry = cache->get(key, "task2", queryCtx_.get(), &future2);
+
+  EXPECT_TRUE(entry->buildComplete);
+  EXPECT_FALSE(future2.valid()); // No need to wait.
+  EXPECT_TRUE(entry->hasNullKeys);
+}
+
+TEST_F(HashTableCacheTest, drop) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query5:node1";
+  // Don't track - we're testing drop.
+
+  ContinueFuture future = ContinueFuture::makeEmpty();
+  auto entry1 = cache->get(key, "task1", queryCtx_.get(), &future);
+  ASSERT_NE(entry1, nullptr);
+
+  // Keep track of the original pool to verify it's different after flush.
+  auto originalPool = entry1->tablePool;
+
+  // Drop the entry.
+  cache->drop(key);
+
+  // Getting the same key should create a new entry.
+  // Use a new queryCtx with different pool to avoid the leaf child name
+  // collision.
+  auto pool2 = memory::memoryManager()->addRootPool("HashTableCacheTest2");
+  auto queryCtx2 = core::QueryCtx::create(
+      nullptr, // executor
+      core::QueryConfig{{}}, // queryConfig
+      {}, // connectorConfigs
+      cache::AsyncDataCache::getInstance(), // cache
+      pool2);
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto entry2 = cache->get(key, "task2", queryCtx2.get(), &future2);
+
+  EXPECT_NE(entry1, entry2);
+  EXPECT_EQ(entry2->builderTaskId, "task2");
+  // The pool should be different (created under queryCtx2's pool).
+  EXPECT_NE(entry1->tablePool, entry2->tablePool);
+
+  // Cleanup.
+  cache->drop(key);
+}
+
+TEST_F(HashTableCacheTest, concurrentWaiters) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query6:node1";
+  trackKey(key);
+
+  // First caller (builder).
+  ContinueFuture builderFuture = ContinueFuture::makeEmpty();
+  auto entry = cache->get(key, "builder", queryCtx_.get(), &builderFuture);
+
+  // Multiple waiters.
+  constexpr int kNumWaiters = 5;
+  std::vector<ContinueFuture> waiterFutures(kNumWaiters);
+
+  for (int i = 0; i < kNumWaiters; ++i) {
+    waiterFutures[i] = ContinueFuture::makeEmpty();
+    cache->get(
+        key, fmt::format("waiter{}", i), queryCtx_.get(), &waiterFutures[i]);
+    EXPECT_TRUE(waiterFutures[i].valid());
+  }
+
+  // Put the table.
+  cache->put(key, nullptr, false);
+
+  // All waiters should be notified.
+  for (int i = 0; i < kNumWaiters; ++i) {
+    EXPECT_TRUE(waiterFutures[i].isReady());
+  }
+}
+
+TEST_F(HashTableCacheTest, builderTaskDriversDoNotWait) {
+  auto* cache = HashTableCache::instance();
+  const std::string key = "query7:node1";
+  trackKey(key);
+
+  // First driver of builder task.
+  ContinueFuture future1 = ContinueFuture::makeEmpty();
+  auto entry1 = cache->get(key, "task1", queryCtx_.get(), &future1);
+  EXPECT_FALSE(future1.valid());
+
+  // Second driver of the same builder task should not wait.
+  ContinueFuture future2 = ContinueFuture::makeEmpty();
+  auto entry2 = cache->get(key, "task1", queryCtx_.get(), &future2);
+
+  EXPECT_EQ(entry1, entry2);
+  // Same task should not get a future - they coordinate via JoinBridge.
+  EXPECT_FALSE(future2.valid());
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/HashTableTest.cpp b/velox/exec/tests/HashTableTest.cpp
index bee323d38f8f..390bbf5bda6e 100644
--- a/velox/exec/tests/HashTableTest.cpp
+++ b/velox/exec/tests/HashTableTest.cpp
@@ -132,8 +132,9 @@ class HashTableTest : public testing::TestWithParam<bool>,
       std::vector<RowVectorPtr> batches;
       std::vector<std::unique_ptr<VectorHasher>> keyHashers;
       for (auto channel = 0; channel < numKeys; ++channel) {
-        keyHashers.emplace_back(std::make_unique<VectorHasher>(
-            buildType->childAt(channel), channel));
+        keyHashers.emplace_back(
+            std::make_unique<VectorHasher>(
+                buildType->childAt(channel), channel));
       }
       auto table = HashTable<true>::createForJoin(
           std::move(keyHashers), dependentTypes, true, false, 1'000, pool());
@@ -158,6 +159,8 @@ class HashTableTest : public testing::TestWithParam<bool>,
     topTable_->prepareJoinTable(
         std::move(otherTables),
         BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
         executor_.get());
     ASSERT_GE(
         estimatedTableSize,
@@ -431,8 +434,9 @@ class HashTableTest : public testing::TestWithParam<bool>,
       TypePtr buildType,
       std::vector<RowVectorPtr>& batches) {
     for (auto i = 0; i < numBatches; ++i) {
-      batches.push_back(std::static_pointer_cast<RowVector>(
-          makeVector(buildType, batchSize, sequence)));
+      batches.push_back(
+          std::static_pointer_cast<RowVector>(
+              makeVector(buildType, batchSize, sequence)));
       sequence += batchSize;
     }
   }
@@ -542,7 +546,11 @@ class HashTableTest : public testing::TestWithParam<bool>,
         std::move(hashers), {BIGINT()}, true, false, 1'000, pool());
     copyVectorsToTable({batch}, 0, table.get());
     table->prepareJoinTable(
-        {}, BaseHashTable::kNoSpillInputStartPartitionBit, executor_.get());
+        {},
+        BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
+        executor_.get());
     ASSERT_EQ(table->hashMode(), mode);
     std::vector<char*> rows(nullValues.size());
     BaseHashTable::NullKeyRowsIterator iter;
@@ -840,7 +848,11 @@ TEST_P(HashTableTest, regularHashingTableSize) {
     makeRows(1 << 12, 1, 0, type, batches);
     copyVectorsToTable(batches, 0, table.get());
     table->prepareJoinTable(
-        {}, BaseHashTable::kNoSpillInputStartPartitionBit, executor_.get());
+        {},
+        BaseHashTable::kNoSpillInputStartPartitionBit,
+        1'000'000,
+        false,
+        executor_.get());
     ASSERT_EQ(table->hashMode(), mode);
     EXPECT_GE(table->testingRehashSize(), table->numDistinct());
   };
@@ -1146,6 +1158,8 @@ DEBUG_ONLY_TEST_P(HashTableTest, failureInCreateRowPartitions) {
   topTable->prepareJoinTable(
       std::move(otherTables),
       BaseHashTable::kNoSpillInputStartPartitionBit,
+      1'000'000,
+      false,
       executor_.get());
   auto topTabletestHelper = HashTableTestHelper<false>::create(topTable.get());
 
@@ -1234,7 +1248,8 @@ TEST_P(HashTableTest, toStringSingleKey) {
 
   store(*table->rows(), data);
 
-  table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
+  table->prepareJoinTable(
+      {}, BaseHashTable::kNoSpillInputStartPartitionBit, 1'000'000);
 
   ASSERT_NO_THROW(table->toString());
   ASSERT_NO_THROW(table->toString(0));
@@ -1265,7 +1280,8 @@ TEST_P(HashTableTest, toStringMultipleKeys) {
 
   store(*table->rows(), data);
 
-  table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
+  table->prepareJoinTable(
+      {}, BaseHashTable::kNoSpillInputStartPartitionBit, 1'000'000);
 
   ASSERT_NO_THROW(table->toString());
 }
diff --git a/velox/exec/tests/HilbertIndexTest.cpp b/velox/exec/tests/HilbertIndexTest.cpp
new file mode 100644
index 000000000000..85cc634f253f
--- /dev/null
+++ b/velox/exec/tests/HilbertIndexTest.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/HilbertIndex.h"
+#include <gtest/gtest.h>
+#include <limits>
+
+using namespace ::testing;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::exec::test {
+
+class HilbertIndexTest : public virtual testing::Test {};
+
+TEST_F(HilbertIndexTest, testOrder) {
+  HilbertIndex hilbert(0, 0, 4, 4);
+
+  uint32_t h0 = hilbert.indexOf(0.0, 0.0);
+  uint32_t h1 = hilbert.indexOf(1.0, 1.0);
+  uint32_t h2 = hilbert.indexOf(1.0, 3.0);
+  uint32_t h3 = hilbert.indexOf(3.0, 3.0);
+  uint32_t h4 = hilbert.indexOf(3.0, 1.0);
+
+  ASSERT_LT(h0, h1);
+  ASSERT_LT(h1, h2);
+  ASSERT_LT(h2, h3);
+  ASSERT_LT(h3, h4);
+}
+
+TEST_F(HilbertIndexTest, testOutOfBounds) {
+  HilbertIndex hilbert(0, 0, 1, 1);
+
+  ASSERT_EQ(hilbert.indexOf(2.0, 2.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testDegenerateRectangle) {
+  HilbertIndex hilbert(0, 0, 0, 0);
+
+  ASSERT_EQ(hilbert.indexOf(0.0, 0.0), 0);
+  ASSERT_EQ(hilbert.indexOf(2.0, 2.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testDegenerateHorizontalRectangle) {
+  HilbertIndex hilbert(0, 0, 4, 0);
+
+  ASSERT_EQ(hilbert.indexOf(0.0, 0.0), 0);
+  ASSERT_LT(hilbert.indexOf(1.0, 0.0), hilbert.indexOf(2.0, 0.0));
+  ASSERT_EQ(hilbert.indexOf(0.0, 2.0), std::numeric_limits<uint32_t>::max());
+  ASSERT_EQ(hilbert.indexOf(2.0, 2.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testDegenerateVerticalRectangle) {
+  HilbertIndex hilbert(0, 0, 0, 4);
+
+  ASSERT_EQ(hilbert.indexOf(0.0, 0.0), 0);
+  ASSERT_LT(hilbert.indexOf(0.0, 1.0), hilbert.indexOf(0.0, 2.0));
+  ASSERT_EQ(hilbert.indexOf(2.0, 0.0), std::numeric_limits<uint32_t>::max());
+  ASSERT_EQ(hilbert.indexOf(2.0, 2.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testNegativeCoordinates) {
+  HilbertIndex hilbert(-10, -10, 10, 10);
+
+  uint32_t h0 = hilbert.indexOf(-5.0, -5.0);
+  uint32_t h1 = hilbert.indexOf(0.0, 0.0);
+  uint32_t h2 = hilbert.indexOf(5.0, 5.0);
+
+  ASSERT_LT(h0, h1);
+  ASSERT_LT(h1, h2);
+
+  ASSERT_EQ(
+      hilbert.indexOf(-15.0, -15.0), std::numeric_limits<uint32_t>::max());
+  ASSERT_EQ(hilbert.indexOf(15.0, 15.0), std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testFloatingPointPrecision) {
+  HilbertIndex hilbert(0, 0, 1, 1);
+
+  uint32_t h1 = hilbert.indexOf(0.1, 0.1);
+  uint32_t h2 = hilbert.indexOf(0.2, 0.2);
+  uint32_t h3 = hilbert.indexOf(0.9, 0.9);
+
+  ASSERT_LT(h1, h2);
+  ASSERT_LT(h2, h3);
+}
+
+TEST_F(HilbertIndexTest, testBoundaryPoints) {
+  HilbertIndex hilbert(0, 0, 10, 10);
+
+  uint32_t h0 = hilbert.indexOf(0.0, 0.0);
+  uint32_t h1 = hilbert.indexOf(10.0, 10.0);
+  uint32_t h2 = hilbert.indexOf(0.0, 10.0);
+  // Bottom-right corner is at the end of the range, so may be MAX
+
+  ASSERT_NE(h0, std::numeric_limits<uint32_t>::max());
+  ASSERT_NE(h1, std::numeric_limits<uint32_t>::max());
+  ASSERT_NE(h2, std::numeric_limits<uint32_t>::max());
+}
+
+TEST_F(HilbertIndexTest, testLargeCoordinates) {
+  HilbertIndex hilbert(0, 0, 1000000, 1000000);
+
+  uint32_t h1 = hilbert.indexOf(100000, 100000);
+  uint32_t h2 = hilbert.indexOf(500000, 500000);
+  uint32_t h3 = hilbert.indexOf(900000, 900000);
+
+  ASSERT_LT(h1, h2);
+  ASSERT_LT(h2, h3);
+}
+
+TEST_F(HilbertIndexTest, testDensityInSmallRegion) {
+  HilbertIndex hilbert(0, 0, 100, 100);
+
+  std::vector<uint32_t> indices;
+  for (int i = 0; i < 10; ++i) {
+    for (int j = 0; j < 10; ++j) {
+      indices.push_back(hilbert.indexOf(i * 10.0f + 5.0f, j * 10.0f + 5.0f));
+    }
+  }
+
+  std::set<uint32_t> uniqueIndices(indices.begin(), indices.end());
+  ASSERT_EQ(indices.size(), 100);
+  ASSERT_GT(uniqueIndices.size(), 90);
+}
+
+TEST_F(HilbertIndexTest, testSpatialLocality) {
+  HilbertIndex hilbert(0, 0, 100, 100);
+
+  uint32_t h1 = hilbert.indexOf(50.0, 50.0);
+  uint32_t h2 = hilbert.indexOf(50.1, 50.1);
+  uint32_t h3 = hilbert.indexOf(50.2, 50.2);
+  uint32_t h4 = hilbert.indexOf(90.0, 90.0);
+
+  uint32_t diff12 = std::abs(static_cast<int32_t>(h1 - h2));
+  uint32_t diff23 = std::abs(static_cast<int32_t>(h2 - h3));
+  uint32_t diff14 = std::abs(static_cast<int32_t>(h1 - h4));
+
+  ASSERT_LT(diff12, diff14);
+  ASSERT_LT(diff23, diff14);
+}
+
+TEST_F(HilbertIndexTest, testIdenticalPoints) {
+  HilbertIndex hilbert(0, 0, 10, 10);
+
+  uint32_t h1 = hilbert.indexOf(5.0, 5.0);
+  uint32_t h2 = hilbert.indexOf(5.0, 5.0);
+
+  ASSERT_EQ(h1, h2);
+}
+
+TEST_F(HilbertIndexTest, testExtremelySmallBounds) {
+  HilbertIndex hilbert(0, 0, 0.001, 0.001);
+
+  uint32_t h1 = hilbert.indexOf(0.0, 0.0);
+  uint32_t h2 = hilbert.indexOf(0.0005, 0.0005);
+
+  ASSERT_NE(h1, std::numeric_limits<uint32_t>::max());
+  ASSERT_NE(h2, std::numeric_limits<uint32_t>::max());
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/IndexLookupJoinTest.cpp b/velox/exec/tests/IndexLookupJoinTest.cpp
index 857ee78d61a8..34179e0dcf1c 100644
--- a/velox/exec/tests/IndexLookupJoinTest.cpp
+++ b/velox/exec/tests/IndexLookupJoinTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/exec/IndexLookupJoin.h"
+#include "fmt/format.h"
 #include "folly/experimental/EventCount.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest-matchers.h"
@@ -34,24 +35,31 @@ using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::common::testutil;
 
-namespace fecebook::velox::exec::test {
+namespace facebook::velox::exec::test {
 namespace {
 struct TestParam {
   bool asyncLookup;
   int32_t numPrefetches;
   bool serialExecution;
+  bool hasNullKeys;
 
-  TestParam(bool _asyncLookup, int32_t _numPrefetches, bool _serialExecution)
+  TestParam(
+      bool _asyncLookup,
+      int32_t _numPrefetches,
+      bool _serialExecution,
+      bool _hasNullKeys)
       : asyncLookup(_asyncLookup),
         numPrefetches(_numPrefetches),
-        serialExecution(_serialExecution) {}
+        serialExecution(_serialExecution),
+        hasNullKeys(_hasNullKeys) {}
 
   std::string toString() const {
     return fmt::format(
-        "asyncLookup={}, numPrefetches={}, serialExecution={}",
+        "asyncLookup={}, numPrefetches={}, serialExecution={}, hasNullKeys={}",
         asyncLookup,
         numPrefetches,
-        serialExecution);
+        serialExecution,
+        hasNullKeys);
   }
 };
 
@@ -60,36 +68,27 @@ class IndexLookupJoinTest : public IndexLookupJoinTestBase,
  public:
   static std::vector<TestParam> getTestParams() {
     std::vector<TestParam> testParams;
-    testParams.emplace_back(true, 0, true);
-    testParams.emplace_back(true, 0, false);
-    testParams.emplace_back(false, 0, true);
-    testParams.emplace_back(false, 0, false);
-    testParams.emplace_back(true, 3, true);
-    testParams.emplace_back(true, 3, false);
-    testParams.emplace_back(false, 3, true);
-    testParams.emplace_back(false, 3, false);
+    for (bool asyncLookup : {false, true}) {
+      for (int numPrefetches : {0, 3}) {
+        for (bool serialExecution : {false, true}) {
+          for (bool hasNullKeys : {false, true}) {
+            testParams.emplace_back(
+                asyncLookup, numPrefetches, serialExecution, hasNullKeys);
+          }
+        }
+      }
+    }
     return testParams;
   }
 
  protected:
-  IndexLookupJoinTest() = default;
-
   void SetUp() override {
     HiveConnectorTestBase::SetUp();
     core::PlanNode::registerSerDe();
     connector::hive::HiveColumnHandle::registerSerDe();
     Type::registerSerDe();
     core::ITypedExpr::registerSerDe();
-    connector::registerConnectorFactory(
-        std::make_shared<TestIndexConnectorFactory>());
-    std::shared_ptr<connector::Connector> connector =
-        connector::getConnectorFactory(kTestIndexConnectorName)
-            ->newConnector(
-                kTestIndexConnectorName,
-                {},
-                nullptr,
-                connectorCpuExecutor_.get());
-    connector::registerConnector(connector);
+    TestIndexConnectorFactory::registerConnector(connectorCpuExecutor_.get());
 
     keyType_ = ROW({"u0", "u1", "u2"}, {BIGINT(), BIGINT(), BIGINT()});
     valueType_ = ROW({"u3", "u4", "u5"}, {BIGINT(), BIGINT(), VARCHAR()});
@@ -97,12 +96,9 @@ class IndexLookupJoinTest : public IndexLookupJoinTestBase,
     probeType_ = ROW(
         {"t0", "t1", "t2", "t3", "t4", "t5"},
         {BIGINT(), BIGINT(), BIGINT(), BIGINT(), ARRAY(BIGINT()), VARCHAR()});
-
-    TestIndexTableHandle::registerSerDe();
   }
 
   void TearDown() override {
-    connector::unregisterConnectorFactory(kTestIndexConnectorName);
     connector::unregisterConnector(kTestIndexConnectorName);
     HiveConnectorTestBase::TearDown();
   }
@@ -113,88 +109,30 @@ class IndexLookupJoinTest : public IndexLookupJoinTestBase,
     ASSERT_EQ(plan->toString(true, true), copy->toString(true, true));
   }
 
-  // Create index table with the given key and value inputs.
-  std::shared_ptr<TestIndexTable> createIndexTable(
-      int numEqualJoinKeys,
-      const RowVectorPtr& keyData,
-      const RowVectorPtr& valueData) {
-    const auto keyType =
-        std::dynamic_pointer_cast<const RowType>(keyData->type());
-    VELOX_CHECK_GE(keyType->size(), 1);
-    VELOX_CHECK_GE(keyType->size(), numEqualJoinKeys);
-    auto valueType =
-        std::dynamic_pointer_cast<const RowType>(valueData->type());
-    VELOX_CHECK_GE(valueType->size(), 1);
-    const auto numRows = keyData->size();
-    VELOX_CHECK_EQ(numRows, valueData->size());
-
-    std::vector<std::unique_ptr<VectorHasher>> hashers;
-    hashers.reserve(numEqualJoinKeys);
-    std::vector<VectorPtr> keyVectors;
-    keyVectors.reserve(numEqualJoinKeys);
-    for (auto i = 0; i < numEqualJoinKeys; ++i) {
-      hashers.push_back(std::make_unique<VectorHasher>(keyType->childAt(i), i));
-      keyVectors.push_back(keyData->childAt(i));
-    }
-
-    std::vector<TypePtr> dependentTypes;
-    std::vector<VectorPtr> dependentVectors;
-    for (int i = numEqualJoinKeys; i < keyType->size(); ++i) {
-      dependentTypes.push_back(keyType->childAt(i));
-      dependentVectors.push_back(keyData->childAt(i));
-    }
-    for (int i = 0; i < valueType->size(); ++i) {
-      dependentTypes.push_back(valueType->childAt(i));
-      dependentVectors.push_back(valueData->childAt(i));
-    }
-
-    // Create the table.
-    auto table = HashTable<false>::createForJoin(
-        std::move(hashers),
-        /*dependentTypes=*/dependentTypes,
-        /*allowDuplicates=*/true,
-        /*hasProbedFlag=*/false,
-        /*minTableSizeForParallelJoinBuild=*/1,
-        pool_.get());
-
-    // Insert data into the row container.
-    auto* rowContainer = table->rows();
-    std::vector<DecodedVector> decodedVectors;
-    for (auto& vector : keyData->children()) {
-      decodedVectors.emplace_back(*vector);
-    }
-    for (auto& vector : valueData->children()) {
-      decodedVectors.emplace_back(*vector);
-    }
-
-    for (auto row = 0; row < numRows; ++row) {
-      auto* newRow = rowContainer->newRow();
-
-      for (auto col = 0; col < decodedVectors.size(); ++col) {
-        rowContainer->store(decodedVectors[col], row, newRow, col);
-      }
-    }
-
-    // Build the table index.
-    table->prepareJoinTable({}, BaseHashTable::kNoSpillInputStartPartitionBit);
-    return std::make_shared<TestIndexTable>(
-        std::move(keyType), std::move(valueType), std::move(table));
-  }
-
   // Makes index table handle with the specified index table and async lookup
   // flag.
-  std::shared_ptr<TestIndexTableHandle> makeIndexTableHandle(
+  static std::shared_ptr<TestIndexTableHandle> makeIndexTableHandle(
       const std::shared_ptr<TestIndexTable>& indexTable,
       bool asyncLookup) {
     return std::make_shared<TestIndexTableHandle>(
         kTestIndexConnectorName, indexTable, asyncLookup);
   }
 
+  static connector::ColumnHandleMap makeIndexColumnHandles(
+      const std::vector<std::string>& names) {
+    connector::ColumnHandleMap handles;
+    for (const auto& name : names) {
+      handles.emplace(name, std::make_shared<TestIndexColumnHandle>(name));
+    }
+
+    return handles;
+  }
+
   const std::unique_ptr<folly::CPUThreadPoolExecutor> connectorCpuExecutor_{
       std::make_unique<folly::CPUThreadPoolExecutor>(128)};
 };
 
-TEST_P(IndexLookupJoinTest, joinCondition) {
+TEST_F(IndexLookupJoinTest, joinCondition) {
   const auto rowType =
       ROW({"c0", "c1", "c2", "c3", "c4"},
           {BIGINT(), BIGINT(), BIGINT(), ARRAY(BIGINT()), BIGINT()});
@@ -207,9 +145,7 @@ TEST_P(IndexLookupJoinTest, joinCondition) {
   auto inFilterCondition = PlanBuilder::parseIndexJoinCondition(
       "contains(ARRAY[1,2], c2)", rowType, pool_.get());
   ASSERT_TRUE(inFilterCondition->isFilter());
-  ASSERT_EQ(
-      inFilterCondition->toString(),
-      "ROW[\"c2\"] IN 2 elements starting at 0 {1, 2}");
+  ASSERT_EQ(inFilterCondition->toString(), "ROW[\"c2\"] IN {1, 2}");
 
   auto betweenFilterCondition = PlanBuilder::parseIndexJoinCondition(
       "c0 between 0 AND 1", rowType, pool_.get());
@@ -236,13 +172,17 @@ TEST_P(IndexLookupJoinTest, joinCondition) {
   ASSERT_EQ(
       betweenJoinCondition3->toString(),
       "ROW[\"c0\"] BETWEEN ROW[\"c1\"] AND 0");
+
+  auto equalFilterCondition =
+      PlanBuilder::parseIndexJoinCondition("c0=1", rowType, pool_.get());
+  ASSERT_TRUE(equalFilterCondition->isFilter());
+  ASSERT_EQ(equalFilterCondition->toString(), "ROW[\"c0\"] = 1");
 }
 
 TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   TestIndexTableHandle::registerSerDe();
 
-  auto indexConnectorHandle = std::make_shared<TestIndexTableHandle>(
-      kTestIndexConnectorName, nullptr, true);
+  auto indexConnectorHandle = makeIndexTableHandle(nullptr, true);
 
   auto left = makeRowVector(
       {"t0", "t1", "t2", "t3", "t4"},
@@ -269,7 +209,7 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   auto planBuilder = PlanBuilder();
   auto nonIndexTableScan = std::dynamic_pointer_cast<const core::TableScanNode>(
       PlanBuilder::TableScanBuilder(planBuilder)
-          .outputType(std::dynamic_pointer_cast<const RowType>(right->type()))
+          .outputType(asRowType(right->type()))
           .endTableScan()
           .planNode());
   VELOX_CHECK_NOT_NULL(nonIndexTableScan);
@@ -277,7 +217,7 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   auto indexTableScan = std::dynamic_pointer_cast<const core::TableScanNode>(
       PlanBuilder::TableScanBuilder(planBuilder)
           .tableHandle(indexConnectorHandle)
-          .outputType(std::dynamic_pointer_cast<const RowType>(right->type()))
+          .outputType(asRowType(right->type()))
           .endTableScan()
           .planNode());
   VELOX_CHECK_NOT_NULL(indexTableScan);
@@ -285,13 +225,13 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
     auto plan = PlanBuilder(planNodeIdGenerator)
                     .values({left})
-                    .indexLookupJoin(
-                        {"t0"},
-                        {"u0"},
-                        indexTableScan,
-                        {},
-                        {"t0", "u1", "t2", "t1"},
-                        joinType)
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0"})
+                    .rightKeys({"u0"})
+                    .indexSource(indexTableScan)
+                    .outputLayout({"t0", "u1", "t2", "t1"})
+                    .joinType(joinType)
+                    .endIndexLookupJoin()
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
@@ -303,6 +243,101 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
   }
 
   // with in join conditions.
+  for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
+    auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .values({left})
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0"})
+                    .rightKeys({"u0"})
+                    .indexSource(indexTableScan)
+                    .joinConditions({"contains(t3, u0)", "contains(t4, u1)"})
+                    .outputLayout({"t0", "u1", "t2", "t1"})
+                    .joinType(joinType)
+                    .endIndexLookupJoin()
+                    .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with between join conditions.
+  for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
+    auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .values({left})
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0"})
+                    .rightKeys({"u0"})
+                    .indexSource(indexTableScan)
+                    .joinConditions(
+                        {"u0 between t0 AND t1",
+                         "u1 between t1 AND 10",
+                         "u1 between 10 AND t1"})
+                    .outputLayout({"t0", "u1", "t2", "t1"})
+                    .joinType(joinType)
+                    .endIndexLookupJoin()
+                    .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 3);
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with mix join conditions.
+  for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
+    auto plan =
+        PlanBuilder(planNodeIdGenerator, pool_.get())
+            .values({left})
+            .startIndexLookupJoin()
+            .leftKeys({"t0"})
+            .rightKeys({"u0"})
+            .indexSource(indexTableScan)
+            .joinConditions({"contains(t3, u0)", "u1 between 10 AND t1"})
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .joinType(joinType)
+            .endIndexLookupJoin()
+            .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with has match column.
+  {
+    auto plan =
+        PlanBuilder(planNodeIdGenerator, pool_.get())
+            .values({left})
+            .startIndexLookupJoin()
+            .leftKeys({"t0"})
+            .rightKeys({"u0"})
+            .indexSource(indexTableScan)
+            .joinConditions({"contains(t3, u0)", "u1 between 10 AND t1"})
+            .hasMarker(true)
+            .outputLayout({"t0", "u1", "t2", "t1", "match"})
+            .joinType(core::JoinType::kLeft)
+            .endIndexLookupJoin()
+            .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_EQ(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with filter.
   for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
     auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
                     .values({left})
@@ -310,20 +345,25 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
                         {"t0"},
                         {"u0"},
                         indexTableScan,
-                        {"contains(t3, u0)", "contains(t4, u1)"},
+                        {},
+                        /*filter=*/"t1 % 2 = 0",
+                        /*hasMarker=*/false,
                         {"t0", "u1", "t2", "t1"},
                         joinType)
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
-    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_TRUE(indexLookupJoinNode->joinConditions().empty());
+    ASSERT_NE(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->filter()->toString(), "eq(mod(ROW[\"t1\"],2),0)");
     ASSERT_EQ(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
         kTestIndexConnectorName);
     testSerde(plan);
   }
 
-  // with between join conditions.
+  // with join conditions and filter.
   for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
     auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
                     .values({left})
@@ -331,36 +371,73 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
                         {"t0"},
                         {"u0"},
                         indexTableScan,
-                        {"u0 between t0 AND t1",
-                         "u1 between t1 AND 10",
-                         "u1 between 10 AND t1"},
+                        {"contains(t3, u0)"},
+                        /*filter=*/"u1 % 2 = 0 AND t2 > 5",
+                        /*hasMarker=*/false,
                         {"t0", "u1", "t2", "t1"},
                         joinType)
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
-    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 3);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 1);
+    ASSERT_NE(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->filter()->toString(),
+        "and(eq(mod(ROW[\"u1\"],2),0),gt(ROW[\"t2\"],5))");
     ASSERT_EQ(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
         kTestIndexConnectorName);
     testSerde(plan);
   }
 
-  // with mix join conditions.
-  for (const auto joinType : {core::JoinType::kLeft, core::JoinType::kInner}) {
+  // with filter and marker for left join.
+  {
     auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
                     .values({left})
                     .indexLookupJoin(
                         {"t0"},
                         {"u0"},
                         indexTableScan,
-                        {"contains(t3, u0)", "u1 between 10 AND t1"},
-                        {"t0", "u1", "t2", "t1"},
-                        joinType)
+                        {"u1 between 10 AND t1"},
+                        /*filter=*/"t2 < u2",
+                        /*hasMarker=*/true,
+                        {"t0", "u1", "t2", "t1", "match"},
+                        core::JoinType::kLeft)
                     .planNode();
     auto indexLookupJoinNode =
         std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
-    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 2);
+    ASSERT_EQ(indexLookupJoinNode->joinConditions().size(), 1);
+    ASSERT_NE(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->filter()->toString(),
+        "lt(ROW[\"t2\"],ROW[\"u2\"])");
+    ASSERT_TRUE(indexLookupJoinNode->hasMarker());
+    ASSERT_EQ(
+        indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
+        kTestIndexConnectorName);
+    testSerde(plan);
+  }
+
+  // with complex filter expression.
+  {
+    auto plan = PlanBuilder(planNodeIdGenerator, pool_.get())
+                    .values({left})
+                    .startIndexLookupJoin()
+                    .leftKeys({"t0"})
+                    .rightKeys({"u0"})
+                    .indexSource(indexTableScan)
+                    .filter("(t1 + u1) * 2 > 100 OR t2 = u2")
+                    .outputLayout({"t0", "u1", "t2", "t1"})
+                    .joinType(core::JoinType::kInner)
+                    .endIndexLookupJoin()
+                    .planNode();
+    auto indexLookupJoinNode =
+        std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+    ASSERT_TRUE(indexLookupJoinNode->joinConditions().empty());
+    ASSERT_NE(indexLookupJoinNode->filter(), nullptr);
+    ASSERT_EQ(
+        indexLookupJoinNode->filter()->toString(),
+        "or(gt(multiply(plus(ROW[\"t1\"],ROW[\"u1\"]),2),100),eq(ROW[\"t2\"],ROW[\"u2\"]))");
     ASSERT_EQ(
         indexLookupJoinNode->lookupSource()->tableHandle()->connectorId(),
         kTestIndexConnectorName);
@@ -372,13 +449,13 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
     VELOX_ASSERT_USER_THROW(
         PlanBuilder(planNodeIdGenerator)
             .values({left})
-            .indexLookupJoin(
-                {"t0"},
-                {"u0"},
-                indexTableScan,
-                {},
-                {"t0", "u1", "t2", "t1"},
-                core::JoinType::kFull)
+            .startIndexLookupJoin()
+            .leftKeys({"t0"})
+            .rightKeys({"u0"})
+            .indexSource(indexTableScan)
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .joinType(core::JoinType::kFull)
+            .endIndexLookupJoin()
             .planNode(),
         "Unsupported index lookup join type FULL");
   }
@@ -388,8 +465,12 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
     VELOX_ASSERT_USER_THROW(
         PlanBuilder(planNodeIdGenerator)
             .values({left})
-            .indexLookupJoin(
-                {"t0"}, {"u0"}, nonIndexTableScan, {}, {"t0", "u1", "t2", "t1"})
+            .startIndexLookupJoin()
+            .leftKeys({"t0"})
+            .rightKeys({"u0"})
+            .indexSource(nonIndexTableScan)
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .endIndexLookupJoin()
             .planNode(),
         "The lookup table handle hive_table from connector test-hive doesn't support index lookup");
   }
@@ -399,14 +480,15 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
     VELOX_ASSERT_THROW(
         PlanBuilder(planNodeIdGenerator)
             .values({left})
-            .indexLookupJoin(
-                {"t0", "t1"},
-                {"u0"},
-                indexTableScan,
-                {"contains(t4, u0)"},
-                {"t0", "u1", "t2", "t1"})
+            .startIndexLookupJoin()
+            .leftKeys({"t0", "t1"})
+            .rightKeys({"u0"})
+            .indexSource(indexTableScan)
+            .joinConditions({"contains(t4, u0)"})
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .endIndexLookupJoin()
             .planNode(),
-        "JoinNode requires same number of join keys on left and right sides");
+        "The index lookup join node requires same number of join keys on left and right sides");
   }
 
   // No join keys.
@@ -414,14 +496,15 @@ TEST_P(IndexLookupJoinTest, planNodeAndSerde) {
     VELOX_ASSERT_THROW(
         PlanBuilder(planNodeIdGenerator)
             .values({left})
-            .indexLookupJoin(
-                {},
-                {},
-                indexTableScan,
-                {"contains(t4, u0)"},
-                {"t0", "u1", "t2", "t1"})
+            .startIndexLookupJoin()
+            .leftKeys({})
+            .rightKeys({})
+            .indexSource(indexTableScan)
+            .joinConditions({"contains(t4, u0)"})
+            .outputLayout({"t0", "u1", "t2", "t1"})
+            .endIndexLookupJoin()
             .planNode(),
-        "JoinNode requires at least one join key");
+        "The index lookup join node requires at least one join key");
   }
 }
 
@@ -447,7 +530,7 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
           matchPct,
           folly::join(",", scanOutputColumns),
           folly::join(",", outputColumns),
-          core::joinTypeName(joinType),
+          core::JoinTypeName::toName(joinType),
           duckDbVerifySql);
     }
   } testSettings[] = {
@@ -643,7 +726,6 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
        {"t1", "u1", "u2", "u3", "u5"},
        core::JoinType::kLeft,
        "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0"},
-
       // 10% match with larger lookup table.
       {{500, 1, 1},
        10,
@@ -787,6 +869,7 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
         tableData,
         pool_,
         {"t0", "t1", "t2"},
+        GetParam().hasNullKeys,
         {},
         {},
         testData.matchPct);
@@ -796,18 +879,19 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
     createDuckDbTable("t", probeVectors);
     createDuckDbTable("u", {tableData.tableData});
 
-    const auto indexTable = createIndexTable(
-        /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData);
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/3,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
     const auto indexTableHandle =
         makeIndexTableHandle(indexTable, GetParam().asyncLookup);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-        columnHandles;
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
         indexTableHandle,
         makeScanOutputType(testData.scanOutputColumns),
-        columnHandles);
+        makeIndexColumnHandles(testData.scanOutputColumns));
 
     auto plan = makeLookupPlan(
         planNodeIdGenerator,
@@ -815,6 +899,8 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
         {"t0", "t1", "t2"},
         {"u0", "u1", "u2"},
         {},
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -825,6 +911,22 @@ TEST_P(IndexLookupJoinTest, equalJoin) {
         32,
         GetParam().numPrefetches,
         testData.duckDbVerifySql);
+    if (testData.joinType != core::JoinType::kLeft) {
+      continue;
+    }
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/true,
+        testData.joinType,
+        testData.outputColumns);
+    verifyResultWithMatchColumn(
+        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
   }
 }
 
@@ -850,7 +952,7 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
           betweenMatchPct,
           folly::join(",", lookupOutputColumns),
           folly::join(",", outputColumns),
-          core::joinTypeName(joinType),
+          core::JoinTypeName::toName(joinType),
           duckDbVerifySql);
     }
   } testSettings[] = {// Inner join.
@@ -1240,10 +1342,11 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
         tableData,
         pool_,
         {"t0", "t1"},
+        GetParam().hasNullKeys,
         {},
         {{"t2", "t3"}},
-        /*eqaulityMatchPct=*/80,
-        /*inColumns=*/std::nullopt,
+        /*equalMatchPct=*/80,
+        /*inMatchPct=*/std::nullopt,
         testData.betweenMatchPct);
     std::vector<std::shared_ptr<TempFilePath>> probeFiles =
         createProbeFiles(probeVectors);
@@ -1251,18 +1354,19 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
     createDuckDbTable("t", probeVectors);
     createDuckDbTable("u", {tableData.tableData});
 
-    const auto indexTable = createIndexTable(
-        /*numEqualJoinKeys=*/2, tableData.keyData, tableData.valueData);
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/2,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
     const auto indexTableHandle =
         makeIndexTableHandle(indexTable, GetParam().asyncLookup);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-        columnHandles;
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
         indexTableHandle,
         makeScanOutputType(testData.lookupOutputColumns),
-        columnHandles);
+        makeIndexColumnHandles(testData.lookupOutputColumns));
 
     auto plan = makeLookupPlan(
         planNodeIdGenerator,
@@ -1270,6 +1374,8 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
         {"t0", "t1"},
         {"u0", "u1"},
         {testData.betweenCondition},
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -1280,6 +1386,22 @@ TEST_P(IndexLookupJoinTest, betweenJoinCondition) {
         32,
         GetParam().numPrefetches,
         testData.duckDbVerifySql);
+    if (testData.joinType != core::JoinType::kLeft) {
+      continue;
+    }
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1"},
+        {"u0", "u1"},
+        {testData.betweenCondition},
+        /*filter=*/"",
+        /*hasMarker=*/true,
+        testData.joinType,
+        testData.outputColumns);
+    verifyResultWithMatchColumn(
+        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
   }
 }
 
@@ -1305,7 +1427,7 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
           inMatchPct,
           folly::join(",", lookupOutputColumns),
           folly::join(",", outputColumns),
-          core::joinTypeName(joinType),
+          core::JoinTypeName::toName(joinType),
           duckDbVerifySql);
     }
   } testSettings[] = {
@@ -1562,9 +1684,10 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
         tableData,
         pool_,
         {"t0", "t1"},
+        GetParam().hasNullKeys,
         {{"t4"}},
         {},
-        /*eqaulityMatchPct=*/80,
+        /*equalMatchPct=*/80,
         testData.inMatchPct);
     std::vector<std::shared_ptr<TempFilePath>> probeFiles =
         createProbeFiles(probeVectors);
@@ -1572,18 +1695,19 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
     createDuckDbTable("t", probeVectors);
     createDuckDbTable("u", {tableData.tableData});
 
-    const auto indexTable = createIndexTable(
-        /*numEqualJoinKeys=*/2, tableData.keyData, tableData.valueData);
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/2,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
     const auto indexTableHandle =
         makeIndexTableHandle(indexTable, GetParam().asyncLookup);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-        columnHandles;
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
         indexTableHandle,
         makeScanOutputType(testData.lookupOutputColumns),
-        columnHandles);
+        makeIndexColumnHandles(testData.lookupOutputColumns));
 
     auto plan = makeLookupPlan(
         planNodeIdGenerator,
@@ -1591,6 +1715,8 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
         {"t0", "t1"},
         {"u0", "u1"},
         {testData.inCondition},
+        /*filter=*/"",
+        /*hasMarker=*/false,
         testData.joinType,
         testData.outputColumns);
     runLookupQuery(
@@ -1601,88 +1727,552 @@ TEST_P(IndexLookupJoinTest, inJoinCondition) {
         32,
         GetParam().numPrefetches,
         testData.duckDbVerifySql);
+    if (testData.joinType != core::JoinType::kLeft) {
+      continue;
+    }
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1"},
+        {"u0", "u1"},
+        {testData.inCondition},
+        /*filter=*/"",
+        /*hasMarker=*/true,
+        testData.joinType,
+        testData.outputColumns);
+    verifyResultWithMatchColumn(
+        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
   }
 }
 
-DEBUG_ONLY_TEST_P(IndexLookupJoinTest, connectorError) {
-  SequenceTableData tableData;
-  generateIndexTableData({100, 1, 1}, tableData, pool_);
-  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
-      20, 100, 1, tableData, pool_, {"t0", "t1", "t2"}, {}, {}, 100);
-  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
-      createProbeFiles(probeVectors);
+TEST_P(IndexLookupJoinTest, prefixKeysEqualJoin) {
+  struct {
+    std::vector<int> keyCardinalities;
+    int numProbeBatches;
+    int numRowsPerProbeBatch;
+    int matchPct;
+    int numKeysToUse; // Number of keys to use from the full key set
+    std::vector<std::string> scanOutputColumns;
+    std::vector<std::string> outputColumns;
+    core::JoinType joinType;
+    std::string duckDbVerifySql;
 
-  const std::string errorMsg{"injectedError"};
-  std::atomic_int lookupCount{0};
-  SCOPED_TESTVALUE_SET(
-      "facebook::velox::exec::test::TestIndexSource::ResultIterator::syncLookup",
-      std::function<void(void*)>([&](void*) {
-        // Triggers error in the middle.
-        if (lookupCount++ == 10) {
-          VELOX_FAIL(errorMsg);
-        }
-      }));
+    std::string debugString() const {
+      return fmt::format(
+          "keyCardinalities: {}, numProbeBatches: {}, numRowsPerProbeBatch: {}, matchPct: {}, numKeysToUse: {}, "
+          "scanOutputColumns: {}, outputColumns: {}, joinType: {},"
+          " duckDbVerifySql: {}",
+          folly::join(",", keyCardinalities),
+          numProbeBatches,
+          numRowsPerProbeBatch,
+          matchPct,
+          numKeysToUse,
+          folly::join(",", scanOutputColumns),
+          folly::join(",", outputColumns),
+          core::JoinTypeName::toName(joinType),
+          duckDbVerifySql);
+    }
+  } testSettings[] = {
+      // Inner join with 2 out of 3 keys
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       2,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t0", "t1", "u0", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "SELECT t.c0, t.c1, u.c0, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1"},
+      // Left join with 2 out of 3 keys
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       2,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t0", "t1", "u0", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "SELECT t.c0, t.c1, u.c0, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 "},
+      // Inner join with 1 out of 3 keys
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       1,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t0", "u0", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "SELECT t.c0, u.c0, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 "},
+      // Left join with 1 out of 3 keys
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       1,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t0", "u0", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "SELECT t.c0, u.c0, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 "}};
 
-  const auto indexTable = createIndexTable(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData);
-  const auto indexTableHandle =
-      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
-  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      columnHandles;
-  const auto indexScanNode = makeIndexScanNode(
-      planNodeIdGenerator,
-      indexTableHandle,
-      makeScanOutputType({"u0", "u1", "u2", "u5"}),
-      columnHandles);
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
 
-  auto plan = makeLookupPlan(
-      planNodeIdGenerator,
-      indexScanNode,
-      {"t0", "t1", "t2"},
-      {"u0", "u1", "u2"},
-      {},
-      core::JoinType::kInner,
-      {"u0", "u1", "u2", "t5"});
-  VELOX_ASSERT_THROW(
-      runLookupQuery(
-          plan,
-          probeFiles,
-          GetParam().serialExecution,
-          GetParam().serialExecution,
-          100,
-          GetParam().numPrefetches,
-          "SELECT u.c0, u.c1, t.c2, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2"),
-      errorMsg);
-}
+    SequenceTableData tableData;
+    generateIndexTableData(testData.keyCardinalities, tableData, pool_);
 
-DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
-  if (!GetParam().asyncLookup || GetParam().serialExecution) {
-    // This test only works for async lookup.
-    return;
-  }
-  SequenceTableData tableData;
-  generateIndexTableData({100, 1, 1}, tableData, pool_);
-  const int numProbeBatches{20};
-  ASSERT_GT(numProbeBatches, GetParam().numPrefetches);
-  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
-      numProbeBatches,
-      100,
-      1,
-      tableData,
-      pool_,
-      {"t0", "t1", "t2"},
-      {},
-      {},
-      100);
-  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
-      createProbeFiles(probeVectors);
-  createDuckDbTable("t", probeVectors);
-  createDuckDbTable("u", {tableData.tableData});
+    // Generate probe vectors with only the prefix of keys
+    std::vector<std::string> probeKeys;
+    for (int i = 0; i < testData.numKeysToUse; ++i) {
+      probeKeys.push_back(fmt::format("t{}", i));
+    }
 
-  std::atomic_int lookupCount{0};
-  folly::EventCount asyncLookupWait;
-  std::atomic_bool asyncLookupWaitFlag{true};
+    auto probeVectors = generateProbeInput(
+        testData.numProbeBatches,
+        testData.numRowsPerProbeBatch,
+        1,
+        tableData,
+        pool_,
+        probeKeys,
+        GetParam().hasNullKeys,
+        {},
+        {},
+        testData.matchPct);
+    std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+        createProbeFiles(probeVectors);
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", {tableData.tableData});
+
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/testData.numKeysToUse,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
+    const auto indexTableHandle =
+        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const auto indexScanNode = makeIndexScanNode(
+        planNodeIdGenerator,
+        indexTableHandle,
+        makeScanOutputType(testData.scanOutputColumns),
+        makeIndexColumnHandles(testData.scanOutputColumns));
+
+    // Create left and right join keys with only the prefix
+    std::vector<std::string> leftKeys;
+    std::vector<std::string> rightKeys;
+    for (int i = 0; i < testData.numKeysToUse; ++i) {
+      leftKeys.push_back(fmt::format("t{}", i));
+      rightKeys.push_back(fmt::format("u{}", i));
+    }
+
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        leftKeys,
+        rightKeys,
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/false,
+        testData.joinType,
+        testData.outputColumns);
+    runLookupQuery(
+        plan,
+        probeFiles,
+        GetParam().serialExecution,
+        GetParam().serialExecution,
+        32,
+        GetParam().numPrefetches,
+        testData.duckDbVerifySql);
+    if (testData.joinType != core::JoinType::kLeft) {
+      continue;
+    }
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        leftKeys,
+        rightKeys,
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/true,
+        testData.joinType,
+        testData.outputColumns);
+    verifyResultWithMatchColumn(
+        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+  }
+}
+
+TEST_P(IndexLookupJoinTest, prefixKeysbetweenJoinCondition) {
+  struct {
+    std::vector<int> keyCardinalities;
+    int numProbeBatches;
+    int numProbeRowsPerBatch;
+    std::string betweenCondition;
+    int betweenMatchPct;
+    std::vector<std::string> lookupOutputColumns;
+    std::vector<std::string> outputColumns;
+    core::JoinType joinType;
+    std::string duckDbVerifySql;
+
+    std::string debugString() const {
+      return fmt::format(
+          "keyCardinalities: {}, numProbeBatches: {}, numProbeRowsPerBatch: {}, betweenCondition: {}, betweenMatchPct: {}, "
+          "lookupOutputColumns: {}, outputColumns: {}, joinType: {}, duckDbVerifySql: {}",
+          folly::join(",", keyCardinalities),
+          numProbeBatches,
+          numProbeRowsPerBatch,
+          betweenCondition,
+          betweenMatchPct,
+          folly::join(",", lookupOutputColumns),
+          folly::join(",", outputColumns),
+          core::JoinTypeName::toName(joinType),
+          duckDbVerifySql);
+    }
+  } testSettings[] = {
+      {{50, 1, 10},
+       5,
+       100,
+       "u1 between t1 and t3",
+       10,
+       {"u0", "u1", "u2", "u3"},
+       {"t0", "t1", "t3", "u1", "u3"},
+       core::JoinType::kInner,
+       "SELECT t.c0, t.c1, t.c3, u.c1, u.c3 FROM t, u WHERE t.c0 = u.c0 AND u.c1 BETWEEN t.c1 AND t.c3"},
+      {{50, 1, 10},
+       5,
+       100,
+       "u1 between t1 and t3",
+       10,
+       {"u0", "u1", "u2", "u3"},
+       {"t0", "t1", "t3", "u1", "u3"},
+       core::JoinType::kLeft,
+       "SELECT t.c0, t.c1, t.c3, u.c1, u.c3 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c1 BETWEEN t.c1 AND t.c3"},
+      {{50, 1, 10},
+       5,
+       100,
+       "u1 between 0 and t1",
+       80,
+       {"u0", "u1", "u2", "u3"},
+       {"t0", "t1", "u1", "u3"},
+       core::JoinType::kInner,
+       "SELECT t.c0, t.c1, u.c1, u.c3 FROM t, u WHERE t.c0 = u.c0 AND u.c1 BETWEEN 0 AND t.c1"},
+      {{50, 1, 10},
+       5,
+       100,
+       "u1 between 0 and t1",
+       80,
+       {"u0", "u1", "u2", "u3"},
+       {"t0", "t1", "u1", "u3"},
+       core::JoinType::kLeft,
+       "SELECT t.c0, t.c1, u.c1, u.c3 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c1 BETWEEN 0 AND t.c1"}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    SequenceTableData tableData;
+    generateIndexTableData(testData.keyCardinalities, tableData, pool_);
+
+    auto probeVectors = generateProbeInput(
+        testData.numProbeBatches,
+        testData.numProbeRowsPerBatch,
+        1,
+        tableData,
+        pool_,
+        {"t0"},
+        GetParam().hasNullKeys,
+        {},
+        {{"t1", "t2"}},
+        /*equalMatchPct=*/80,
+        /*inMatchPct=*/std::nullopt,
+        testData.betweenMatchPct);
+    std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+        createProbeFiles(probeVectors);
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", {tableData.tableData});
+
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/1,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
+    const auto indexTableHandle =
+        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const auto indexScanNode = makeIndexScanNode(
+        planNodeIdGenerator,
+        indexTableHandle,
+        makeScanOutputType(testData.lookupOutputColumns),
+        makeIndexColumnHandles(testData.lookupOutputColumns));
+
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0"},
+        {"u0"},
+        {testData.betweenCondition},
+        /*filter=*/"",
+        /*hasMarker=*/false,
+        testData.joinType,
+        testData.outputColumns);
+    runLookupQuery(
+        plan,
+        probeFiles,
+        GetParam().serialExecution,
+        GetParam().serialExecution,
+        32,
+        GetParam().numPrefetches,
+        testData.duckDbVerifySql);
+    if (testData.joinType != core::JoinType::kLeft) {
+      continue;
+    }
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0"},
+        {"u0"},
+        {testData.betweenCondition},
+        /*filter=*/"",
+        /*hasMarker=*/true,
+        testData.joinType,
+        testData.outputColumns);
+    verifyResultWithMatchColumn(
+        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+  }
+}
+
+TEST_P(IndexLookupJoinTest, prefixInJoinCondition) {
+  struct {
+    std::vector<int> keyCardinalities;
+    int numProbeBatches;
+    int numProbeRowsPerBatch;
+    std::string inCondition;
+    int inMatchPct;
+    std::vector<std::string> lookupOutputColumns;
+    std::vector<std::string> outputColumns;
+    core::JoinType joinType;
+    std::string duckDbVerifySql;
+
+    std::string debugString() const {
+      return fmt::format(
+          "keyCardinalities: {}: numProbeBatches: {}, numProbeRowsPerBatch: {}, inCondition: {}, inMatchPct: {}, lookupOutputColumns: {}, outputColumns: {}, joinType: {}, duckDbVerifySql: {}",
+          folly::join(",", keyCardinalities),
+          numProbeBatches,
+          numProbeRowsPerBatch,
+          inCondition,
+          inMatchPct,
+          folly::join(",", lookupOutputColumns),
+          folly::join(",", outputColumns),
+          core::JoinTypeName::toName(joinType),
+          duckDbVerifySql);
+    }
+  } testSettings[] = {
+      // Inner join with prefix keys (c0, c1)
+      {{50, 1, 10},
+       1,
+       100,
+       "contains(t4, u1)",
+       10,
+       {"u0", "u1", "u2", "u3"},
+       {"t0", "t1", "t4", "u1", "u3"},
+       core::JoinType::kInner,
+       "SELECT t.c0, t.c1, t.c4, u.c1, u.c3 FROM t, u WHERE t.c0 = u.c0 AND array_contains(t.c4, u.c1)"},
+      // Left join with prefix keys (c0, c1)
+      {{50, 1, 10},
+       1,
+       100,
+       "contains(t4, u1)",
+       10,
+       {"u0", "u1", "u2", "u3"},
+       {"t0", "t1", "t4", "u1", "u3"},
+       core::JoinType::kLeft,
+       "SELECT t.c0, t.c1, t.c4, u.c1, u.c3 FROM t LEFT JOIN u ON t.c0 = u.c0 AND array_contains(t.c4, u.c1)"},
+      // Inner join with prefix keys (c0, c1) - higher match percentage
+      {{50, 1, 10},
+       10,
+       100,
+       "contains(t4, u1)",
+       80,
+       {"u0", "u1", "u2", "u3"},
+       {"t0", "t1", "t4", "u1", "u3"},
+       core::JoinType::kInner,
+       "SELECT t.c0, t.c1, t.c4, u.c1, u.c3 FROM t, u WHERE t.c0 = u.c0 AND array_contains(t.c4, u.c1)"},
+      // Left join with prefix keys (c0, c1) - higher match percentage
+      {{50, 1, 10},
+       10,
+       100,
+       "contains(t4, u1)",
+       80,
+       {"u0", "u1", "u2", "u3"},
+       {"t0", "t1", "t4", "u1", "u3"},
+       core::JoinType::kLeft,
+       "SELECT t.c0, t.c1, t.c4, u.c1, u.c3 FROM t LEFT JOIN u ON t.c0 = u.c0 AND array_contains(t.c4, u.c1)"}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    SequenceTableData tableData;
+    generateIndexTableData(testData.keyCardinalities, tableData, pool_);
+    auto probeVectors = generateProbeInput(
+        testData.numProbeBatches,
+        testData.numProbeRowsPerBatch,
+        1,
+        tableData,
+        pool_,
+        {"t0"},
+        GetParam().hasNullKeys,
+        {{"t4"}},
+        {},
+        /*equalMatchPct=*/80,
+        testData.inMatchPct);
+    std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+        createProbeFiles(probeVectors);
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", {tableData.tableData});
+
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/1,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
+    const auto indexTableHandle =
+        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const auto indexScanNode = makeIndexScanNode(
+        planNodeIdGenerator,
+        indexTableHandle,
+        makeScanOutputType(testData.lookupOutputColumns),
+        makeIndexColumnHandles(testData.lookupOutputColumns));
+
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0"},
+        {"u0"},
+        {testData.inCondition},
+        /*filter=*/"",
+        /*hasMarker=*/false,
+        testData.joinType,
+        testData.outputColumns);
+    runLookupQuery(
+        plan,
+        probeFiles,
+        GetParam().serialExecution,
+        GetParam().serialExecution,
+        32,
+        GetParam().numPrefetches,
+        testData.duckDbVerifySql);
+    if (testData.joinType != core::JoinType::kLeft) {
+      continue;
+    }
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0"},
+        {"u0"},
+        {testData.inCondition},
+        /*filter=*/"",
+        /*hasMarker=*/true,
+        testData.joinType,
+        testData.outputColumns);
+    verifyResultWithMatchColumn(
+        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+  }
+}
+
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, connectorError) {
+  SequenceTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
+      20,
+      100,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+
+  const std::string errorMsg{"injectedError"};
+  std::atomic_int lookupCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::test::TestIndexSource::ResultIterator::syncLookup",
+      std::function<void(void*)>([&](void*) {
+        // Triggers error in the middle.
+        if (lookupCount++ == 10) {
+          VELOX_FAIL(errorMsg);
+        }
+      }));
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
+  const auto indexTableHandle =
+      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u5"}));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u0", "u1", "u2", "t5"});
+  VELOX_ASSERT_THROW(
+      runLookupQuery(
+          plan,
+          probeFiles,
+          GetParam().serialExecution,
+          GetParam().serialExecution,
+          100,
+          GetParam().numPrefetches,
+          "SELECT u.c0, u.c1, t.c2, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2"),
+      errorMsg);
+}
+
+DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
+  if (!GetParam().asyncLookup || GetParam().serialExecution) {
+    // This test only works for async lookup.
+    return;
+  }
+  SequenceTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeBatches{20};
+  ASSERT_GT(numProbeBatches, GetParam().numPrefetches);
+  const std::vector<RowVectorPtr> probeVectors = generateProbeInput(
+      numProbeBatches,
+      100,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableData});
+
+  std::atomic_int lookupCount{0};
+  folly::EventCount asyncLookupWait;
+  std::atomic_bool asyncLookupWaitFlag{true};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::test::TestIndexSource::ResultIterator::asyncLookup",
       std::function<void(void*)>([&](void*) {
@@ -1692,18 +2282,16 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
         asyncLookupWait.await([&] { return !asyncLookupWaitFlag.load(); });
       }));
 
-  const auto indexTable = createIndexTable(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData);
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
   const auto indexTableHandle =
       makeIndexTableHandle(indexTable, GetParam().asyncLookup);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      columnHandles;
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
       indexTableHandle,
       makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
-      columnHandles);
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
 
   auto plan = makeLookupPlan(
       planNodeIdGenerator,
@@ -1711,6 +2299,8 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
       {"t0", "t1", "t2"},
       {"u0", "u1", "u2"},
       {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
       core::JoinType::kInner,
       {"u3", "t5"});
   std::thread queryThread([&] {
@@ -1733,7 +2323,7 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, prefetch) {
   queryThread.join();
 }
 
-TEST_P(IndexLookupJoinTest, outputBatchSize) {
+TEST_P(IndexLookupJoinTest, outputBatchSizeWithInnerJoin) {
   SequenceTableData tableData;
   generateIndexTableData({3'000, 1, 1}, tableData, pool_);
 
@@ -1741,27 +2331,37 @@ TEST_P(IndexLookupJoinTest, outputBatchSize) {
     int numProbeBatches;
     int numRowsPerProbeBatch;
     int maxBatchRows;
+    bool splitOutput;
     int numExpectedOutputBatch;
 
     std::string debugString() const {
       return fmt::format(
-          "numProbeBatches: {}, numRowsPerProbeBatch: {}, maxBatchRows: {}, numExpectedOutputBatch: {}",
+          "numProbeBatches: {}, numRowsPerProbeBatch: {}, maxBatchRows: {}, splitOutput: {}, numExpectedOutputBatch: {}",
           numProbeBatches,
           numRowsPerProbeBatch,
           maxBatchRows,
+          splitOutput,
           numExpectedOutputBatch);
     }
   } testSettings[] = {
-      {10, 100, 10, 100},
-      {10, 500, 10, 500},
-      {10, 1, 200, 10},
-      {1, 500, 10, 50},
-      {1, 300, 10, 30},
-      {1, 500, 200, 3},
-      {10, 200, 200, 10},
-      {10, 500, 300, 20},
-      {10, 50, 1, 500}};
-
+      {10, 100, 10, false, 10},
+      {10, 500, 10, false, 10},
+      {10, 1, 200, false, 10},
+      {1, 500, 10, false, 1},
+      {1, 300, 10, false, 1},
+      {1, 500, 200, false, 1},
+      {10, 200, 200, false, 10},
+      {10, 500, 300, false, 10},
+      {10, 50, 1, false, 10},
+      {10, 100, 10, true, 100},
+      {10, 500, 10, true, 500},
+      {10, 1, 200, true, 10},
+      {1, 500, 10, true, 50},
+      {1, 300, 10, true, 30},
+      {1, 500, 200, true, 3},
+      {10, 200, 200, true, 10},
+      {10, 500, 300, true, 20},
+      {10, 50, 1, true, 500}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
 
@@ -1772,6 +2372,7 @@ TEST_P(IndexLookupJoinTest, outputBatchSize) {
         tableData,
         pool_,
         {"t0", "t1", "t2"},
+        GetParam().hasNullKeys,
         {},
         {},
         /*equalMatchPct=*/100);
@@ -1781,18 +2382,20 @@ TEST_P(IndexLookupJoinTest, outputBatchSize) {
     createDuckDbTable("t", probeVectors);
     createDuckDbTable("u", {tableData.tableData});
 
-    const auto indexTable = createIndexTable(
-        /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData);
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/3,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
     const auto indexTableHandle =
         makeIndexTableHandle(indexTable, GetParam().asyncLookup);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-    std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-        columnHandles;
+
     const auto indexScanNode = makeIndexScanNode(
         planNodeIdGenerator,
         indexTableHandle,
         makeScanOutputType({"u0", "u1", "u2", "u5"}),
-        columnHandles);
+        makeIndexColumnHandles({"u0", "u1", "u2", "u5"}));
 
     auto plan = makeLookupPlan(
         planNodeIdGenerator,
@@ -1800,6 +2403,8 @@ TEST_P(IndexLookupJoinTest, outputBatchSize) {
         {"t0", "t1", "t2"},
         {"u0", "u1", "u2"},
         {},
+        /*filter=*/"",
+        /*hasMarker=*/false,
         core::JoinType::kInner,
         {"t4", "u5"});
     const auto task =
@@ -1814,6 +2419,9 @@ TEST_P(IndexLookupJoinTest, outputBatchSize) {
             .config(
                 core::QueryConfig::kPreferredOutputBatchBytes,
                 std::to_string(1ULL << 30))
+            .config(
+                core::QueryConfig::kIndexLookupJoinSplitOutput,
+                testData.splitOutput ? "true" : "false")
             .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
             .serialExecution(GetParam().serialExecution)
             .barrierExecution(GetParam().serialExecution)
@@ -1825,6 +2433,128 @@ TEST_P(IndexLookupJoinTest, outputBatchSize) {
   }
 }
 
+TEST_P(IndexLookupJoinTest, outputBatchSizeWithLeftJoin) {
+  SequenceTableData tableData;
+  generateIndexTableData({3'000, 1, 1}, tableData, pool_);
+
+  struct {
+    int numProbeBatches;
+    int numRowsPerProbeBatch;
+    int maxBatchRows;
+    bool splitOutput;
+    int numExpectedOutputBatch;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numProbeBatches: {}, numRowsPerProbeBatch: {}, maxBatchRows: {}, splitOutput: {}, numExpectedOutputBatch: {}",
+          numProbeBatches,
+          numRowsPerProbeBatch,
+          maxBatchRows,
+          splitOutput,
+          numExpectedOutputBatch);
+    }
+  } testSettings[] = {
+      {10, 100, 10, false, 10},
+      {10, 500, 10, false, 10},
+      {10, 1, 200, false, 10},
+      {1, 500, 10, false, 1},
+      {1, 300, 10, false, 1},
+      {1, 500, 200, false, 1},
+      {10, 200, 200, false, 10},
+      {10, 500, 300, false, 10},
+      {10, 50, 1, false, 10},
+      {10, 100, 10, true, 100},
+      {10, 500, 10, true, 500},
+      {10, 1, 200, true, 10},
+      {1, 500, 10, true, 50},
+      {1, 300, 10, true, 30},
+      {1, 500, 200, true, 3},
+      {10, 200, 200, true, 10},
+      {10, 500, 300, true, 20},
+      {10, 50, 1, true, 500}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    const auto probeVectors = generateProbeInput(
+        testData.numProbeBatches,
+        testData.numRowsPerProbeBatch,
+        1,
+        tableData,
+        pool_,
+        {"t0", "t1", "t2"},
+        GetParam().hasNullKeys,
+        {},
+        {},
+        /*equalMatchPct=*/100);
+    std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+        createProbeFiles(probeVectors);
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", {tableData.tableData});
+
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/3,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
+    const auto indexTableHandle =
+        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const auto indexScanNode = makeIndexScanNode(
+        planNodeIdGenerator,
+        indexTableHandle,
+        makeScanOutputType({"u0", "u1", "u2", "u5"}),
+        makeIndexColumnHandles({"u0", "u1", "u2", "u5"}));
+
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/false,
+        core::JoinType::kLeft,
+        {"t4", "u5"});
+    const auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .plan(plan)
+            .config(
+                core::QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
+                std::to_string(GetParam().numPrefetches))
+            .config(
+                core::QueryConfig::kPreferredOutputBatchRows,
+                std::to_string(testData.maxBatchRows))
+            .config(
+                core::QueryConfig::kPreferredOutputBatchBytes,
+                std::to_string(1ULL << 30))
+            .config(
+                core::QueryConfig::kIndexLookupJoinSplitOutput,
+                testData.splitOutput ? "true" : "false")
+            .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+            .serialExecution(GetParam().serialExecution)
+            .barrierExecution(GetParam().serialExecution)
+            .assertResults(
+                "SELECT t.c4, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+    ASSERT_EQ(
+        toPlanStats(task->taskStats()).at(joinNodeId_).outputVectors,
+        testData.numExpectedOutputBatch);
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/true,
+        core::JoinType::kLeft,
+        {"t4", "u5"});
+    verifyResultWithMatchColumn(
+        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+  }
+}
+
 DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
   SequenceTableData tableData;
   generateIndexTableData({100, 1, 1}, tableData, pool_);
@@ -1836,6 +2566,7 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
       tableData,
       pool_,
       {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
       {},
       {},
       100);
@@ -1850,18 +2581,16 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
         std::this_thread::sleep_for(std::chrono::milliseconds(100)); // NOLINT
       }));
 
-  const auto indexTable = createIndexTable(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData);
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
   const auto indexTableHandle =
       makeIndexTableHandle(indexTable, GetParam().asyncLookup);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      columnHandles;
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
       indexTableHandle,
       makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
-      columnHandles);
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
 
   auto plan = makeLookupPlan(
       planNodeIdGenerator,
@@ -1869,6 +2598,8 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
       {"t0", "t1", "t2"},
       {"u0", "u1", "u2"},
       {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
       core::JoinType::kInner,
       {"u3", "t5"});
   auto task = runLookupQuery(
@@ -1915,40 +2646,259 @@ DEBUG_ONLY_TEST_P(IndexLookupJoinTest, runtimeStats) {
           ".*Runtime stats.*connectorResultPrepareCpuNanos.*"));
 }
 
-TEST_P(IndexLookupJoinTest, barrier) {
-  if (!GetParam().serialExecution) {
-    GTEST_SKIP();
-  }
+TEST_P(IndexLookupJoinTest, barrier) {
+  SequenceTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeSplits{5};
+  const auto probeVectors = generateProbeInput(
+      numProbeSplits,
+      256,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      GetParam().hasNullKeys,
+      {},
+      {},
+      100);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableData});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
+  const auto indexTableHandle =
+      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u3", "t5"});
+
+  struct {
+    int numPrefetches;
+    bool barrierExecution;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numPrefetches {}, barrierExecution {}",
+          numPrefetches,
+          barrierExecution);
+    }
+  } testSettings[] = {
+      {0, true},
+      {0, false},
+      {1, true},
+      {1, false},
+      {4, true},
+      {4, false},
+      {256, true},
+      {256, false}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    auto task = runLookupQuery(
+        plan,
+        probeFiles,
+        true,
+        testData.barrierExecution,
+        32,
+        testData.numPrefetches,
+        "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(
+        taskStats.numBarriers, testData.barrierExecution ? numProbeSplits : 0);
+    ASSERT_EQ(taskStats.numFinishedSplits, numProbeSplits);
+  }
+}
+
+TEST_P(IndexLookupJoinTest, nullKeys) {
+  SequenceTableData tableData;
+  generateIndexTableData({100, 1, 1}, tableData, pool_);
+  const int numProbeSplits{5};
+  const int probeBatchSize{256};
+  const auto probeVectors = generateProbeInput(
+      numProbeSplits,
+      probeBatchSize,
+      1,
+      tableData,
+      pool_,
+      {"t0", "t1", "t2"},
+      /*hasNullKeys=*/true,
+      {},
+      {},
+      /*equalMatchPct=*/100);
+  // Set some probe key vector to all nulls to trigger the case that entire
+  // probe input is skipped.
+  for (int i = 0; i < numProbeSplits; i += 2) {
+    for (int row = 0; row < probeBatchSize; ++row) {
+      probeVectors[i]->childAt(i % keyType_->size())->setNull(row, true);
+    }
+  }
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableData});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
+  const auto indexTableHandle =
+      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
+      columnHandles;
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
+
+  const auto innerPlan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u3", "t5"});
+
+  runLookupQuery(
+      innerPlan,
+      probeFiles,
+      true,
+      true,
+      32,
+      GetParam().numPrefetches,
+      "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+  const auto leftPlan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kLeft,
+      {"u3", "t5"});
+
+  runLookupQuery(
+      leftPlan,
+      probeFiles,
+      true,
+      true,
+      32,
+      GetParam().numPrefetches,
+      "SELECT u.c3, t.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+
+  const auto probeScanId = probeScanNodeId_;
+  auto planWithMatchColumn = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      /*filter=*/"",
+      /*hasMarker=*/true,
+      core::JoinType::kLeft,
+      {"u3", "t5"});
+  verifyResultWithMatchColumn(
+      leftPlan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
+}
+
+TEST_P(IndexLookupJoinTest, joinFuzzer) {
+  SequenceTableData tableData;
+  generateIndexTableData({1024, 1, 1}, tableData, pool_);
+  const auto probeVectors = generateProbeInput(
+      50, 256, 1, tableData, pool_, {"t0", "t1", "t2"}, GetParam().hasNullKeys);
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+      createProbeFiles(probeVectors);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {tableData.tableData});
+
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/1, tableData.keyData, tableData.valueData, *pool());
+  const auto indexTableHandle =
+      makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto scanOutput = tableType_->names();
+  std::random_device rd;
+  std::mt19937 g(rd());
+  std::shuffle(scanOutput.begin(), scanOutput.end(), g);
+  const auto indexScanNode = makeIndexScanNode(
+      planNodeIdGenerator,
+      indexTableHandle,
+      makeScanOutputType(scanOutput),
+      makeIndexColumnHandles(scanOutput));
+
+  auto plan = makeLookupPlan(
+      planNodeIdGenerator,
+      indexScanNode,
+      {"t0"},
+      {"u0"},
+      {"contains(t4, u1)", "u2 between t1 and t2"},
+      /*filter=*/"",
+      /*hasMarker=*/false,
+      core::JoinType::kInner,
+      {"u0", "u4", "t0", "t1", "t4"});
+  runLookupQuery(
+      plan,
+      probeFiles,
+      GetParam().serialExecution,
+      GetParam().serialExecution,
+      32,
+      GetParam().numPrefetches,
+      "SELECT u.c0, u.c1, u.c2, u.c3, u.c4, u.c5, t.c0, t.c1, t.c2, t.c3, t.c4, t.c5 FROM t, u WHERE t.c0 = u.c0 AND array_contains(t.c4, u.c1) AND u.c2 BETWEEN t.c1 AND t.c2");
+}
+
+TEST_P(IndexLookupJoinTest, tableRowsWithDuplicateKeys) {
   SequenceTableData tableData;
-  generateIndexTableData({100, 1, 1}, tableData, pool_);
-  const int numProbeSplits{5};
-  const auto probeVectors = generateProbeInput(
-      numProbeSplits,
-      256,
-      1,
-      tableData,
-      pool_,
-      {"t0", "t1", "t2"},
-      {},
-      {},
-      100);
+  generateIndexTableData({10, 1, 1}, tableData, pool_);
+  for (int i = 0; i < keyType_->size(); ++i) {
+    tableData.keyData->childAt(i) = makeFlatVector<int64_t>(
+        tableData.keyData->childAt(i)->size(),
+        [](auto /*unused*/) { return 1; });
+    tableData.tableData->childAt(i) = makeFlatVector<int64_t>(
+        tableData.keyData->childAt(i)->size(),
+        [](auto /*unused*/) { return 1; });
+  }
+
+  auto probeVectors = generateProbeInput(
+      4, 32, 1, tableData, pool_, {"t0", "t1", "t2"}, false, {}, {}, 100);
   std::vector<std::shared_ptr<TempFilePath>> probeFiles =
       createProbeFiles(probeVectors);
+
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", {tableData.tableData});
 
-  const auto indexTable = createIndexTable(
-      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData);
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
   const auto indexTableHandle =
       makeIndexTableHandle(indexTable, GetParam().asyncLookup);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      columnHandles;
+  auto scanOutput = tableType_->names();
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
       indexTableHandle,
-      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
-      columnHandles);
+      makeScanOutputType(scanOutput),
+      makeIndexColumnHandles(scanOutput));
 
   auto plan = makeLookupPlan(
       planNodeIdGenerator,
@@ -1956,91 +2906,391 @@ TEST_P(IndexLookupJoinTest, barrier) {
       {"t0", "t1", "t2"},
       {"u0", "u1", "u2"},
       {},
+      /*filter=*/"",
+      /*hasMarker=*/false,
       core::JoinType::kInner,
-      {"u3", "t5"});
+      scanOutput);
+  runLookupQuery(
+      plan,
+      probeFiles,
+      GetParam().serialExecution,
+      GetParam().serialExecution,
+      32,
+      GetParam().numPrefetches,
+      "SELECT u.c0, u.c1, u.c2, u.c3, u.c4, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND u.c2 = t.c2");
+}
 
+TEST_P(IndexLookupJoinTest, withFilter) {
   struct {
-    int numPrefetches;
-    bool barrierExecution;
+    std::vector<int> keyCardinalities;
+    int numProbeBatches;
+    int numRowsPerProbeBatch;
+    int matchPct;
+    std::vector<std::string> scanOutputColumns;
+    std::vector<std::string> outputColumns;
+    core::JoinType joinType;
+    std::string filter;
+    std::string duckDbVerifySql;
 
     std::string debugString() const {
       return fmt::format(
-          "numPrefetches {}, barrierExecution {}",
-          numPrefetches,
-          barrierExecution);
+          "keyCardinalities: {}, numProbeBatches: {}, numRowsPerProbeBatch: {}, matchPct: {}, "
+          "scanOutputColumns: {}, outputColumns: {}, joinType: {}, filter: {}, "
+          "duckDbVerifySql: {}",
+          folly::join(",", keyCardinalities),
+          numProbeBatches,
+          numRowsPerProbeBatch,
+          matchPct,
+          folly::join(",", scanOutputColumns),
+          folly::join(",", outputColumns),
+          core::JoinTypeName::toName(joinType),
+          filter,
+          duckDbVerifySql);
     }
   } testSettings[] = {
-      {0, true},
-      {0, false},
-      {1, true},
-      {1, false},
-      {4, true},
-      {4, false},
-      {256, true},
-      {256, false}};
+      // Inner join with filter on probe side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "t3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c3 % 2 = 0"},
+      // Inner join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "t3 = t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c3 = t.c3"},
+      // Inner join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "t3 != t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c3 != t.c3"},
+
+      // Inner join with filter on lookup side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 % 2 = 0"},
+      // Inner join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 = u3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 = u.c3"},
+      // Inner join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 != u3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 != u.c3"},
+
+      // Inner join with filter on both side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 % 2 = 0 AND t3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 % 2 = 0 AND t.c3 % 2 = 0"},
+      // Inner join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 = u3 AND t3 = t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 = u.c3 AND t.c3 = t.c3"},
+      // Inner join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kInner,
+       "u3 != u3 AND t3 != t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t, u WHERE t.c0 = u.c0 AND u.c3 != u.c3 AND t.c3 != t.c3"},
+
+      // Left join with filter on probe side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "t3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c3 % 2 = 0"},
+      // Left join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "t3 = t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c3 = t.c3"},
+      // Inner join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "t3 != t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c3 != t.c3"},
+
+      // Left join with filter on lookup side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 % 2 = 0"},
+      // Inner join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 = u3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 = u.c3"},
+      // Left join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 != u3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 != u.c3"},
+
+      // Left join with filter on both side
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 % 2 = 0 AND t3 % 2 = 0",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 % 2 = 0 AND t.c3 % 2 = 0"},
+      // Left join with filter always be true.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 = u3 AND t3 = t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 = u.c3 AND t.c3 = t.c3"},
+      // Left join with filter always be false.
+      {{100, 1, 1},
+       5,
+       100,
+       80,
+       {"u0", "u1", "u2", "u3", "u5"},
+       {"t1", "u1", "u2", "u3", "u5"},
+       core::JoinType::kLeft,
+       "u3 != u3 AND t3 != t3",
+       "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND u.c3 != u.c3 AND t.c3 != t.c3"}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    auto task = runLookupQuery(
+
+    SequenceTableData tableData;
+    generateIndexTableData(testData.keyCardinalities, tableData, pool_);
+    auto probeVectors = generateProbeInput(
+        testData.numProbeBatches,
+        testData.numRowsPerProbeBatch,
+        1,
+        tableData,
+        pool_,
+        {"t0", "t1", "t2"},
+        GetParam().hasNullKeys,
+        {},
+        {},
+        testData.matchPct);
+    std::vector<std::shared_ptr<TempFilePath>> probeFiles =
+        createProbeFiles(probeVectors);
+
+    createDuckDbTable("t", probeVectors);
+    createDuckDbTable("u", {tableData.tableData});
+
+    const auto indexTable = TestIndexTable::create(
+        /*numEqualJoinKeys=*/3,
+        tableData.keyData,
+        tableData.valueData,
+        *pool());
+    const auto indexTableHandle =
+        makeIndexTableHandle(indexTable, GetParam().asyncLookup);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const auto indexScanNode = makeIndexScanNode(
+        planNodeIdGenerator,
+        indexTableHandle,
+        makeScanOutputType(testData.scanOutputColumns),
+        makeIndexColumnHandles(testData.scanOutputColumns));
+
+    // Create a plan with filter
+    auto plan = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        testData.filter,
+        /*hasMarker=*/false,
+        testData.joinType,
+        testData.outputColumns);
+
+    runLookupQuery(
         plan,
         probeFiles,
-        true,
-        testData.barrierExecution,
+        GetParam().serialExecution,
+        GetParam().serialExecution,
         32,
-        testData.numPrefetches,
-        "SELECT u.c3, t.c5 FROM t, u WHERE t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2");
+        GetParam().numPrefetches,
+        testData.duckDbVerifySql);
 
-    const auto taskStats = task->taskStats();
-    ASSERT_EQ(
-        taskStats.numBarriers, testData.barrierExecution ? numProbeSplits : 0);
-    ASSERT_EQ(taskStats.numFinishedSplits, numProbeSplits);
+    if (testData.joinType != core::JoinType::kLeft) {
+      continue;
+    }
+    const auto probeScanId = probeScanNodeId_;
+    auto planWithMatchColumn = makeLookupPlan(
+        planNodeIdGenerator,
+        indexScanNode,
+        {"t0", "t1", "t2"},
+        {"u0", "u1", "u2"},
+        {},
+        testData.filter,
+        /*hasMarker=*/true,
+        testData.joinType,
+        testData.outputColumns);
+    verifyResultWithMatchColumn(
+        plan, probeScanId, planWithMatchColumn, probeScanNodeId_, probeFiles);
   }
 }
 
-TEST_P(IndexLookupJoinTest, joinFuzzer) {
+TEST_P(IndexLookupJoinTest, mixedFilterBatches) {
+  // Create SequenceTableData using VectorTestBase utilities
   SequenceTableData tableData;
-  generateIndexTableData({1024, 1, 1}, tableData, pool_);
-  const auto probeVectors =
-      generateProbeInput(50, 256, 1, tableData, pool_, {"t0", "t1", "t2"});
+
+  const std::string dummyString("test");
+  StringView dummyStringView(dummyString);
+  // Create table key data (u0, u1, u2) using makeFlatVector
+  auto u0 = makeFlatVector<int64_t>(64, [&](auto row) { return row % 8; });
+  auto u1 = makeFlatVector<int64_t>(64, [&](auto row) { return row % 8; });
+  auto u2 = makeFlatVector<int64_t>(64, [&](auto row) { return row % 8; });
+  tableData.keyData = makeRowVector({"u0", "u1", "u2"}, {u0, u1, u2});
+
+  // Create table value data (u3, u4, u5) using makeFlatVector
+  auto u3 = makeFlatVector<int64_t>(64, [&](auto row) { return row; });
+  auto u4 = makeFlatVector<int64_t>(64, [&](auto row) { return row; });
+  auto u5 = makeFlatVector<StringView>(
+      64, [&](auto /*unused*/) { return dummyStringView; });
+  tableData.valueData = makeRowVector({"u3", "u4", "u5"}, {u3, u4, u5});
+
+  // Create complete table data by combining key and value data
+  tableData.tableData = makeRowVector(
+      {"u0", "u1", "u2", "u3", "u4", "u5"}, {u0, u1, u2, u3, u4, u5});
+
+  // Create probe vectors using makeArrayVectorFromJson in a loop
+  std::vector<RowVectorPtr> probeVectors;
+  probeVectors.reserve(5);
+  for (int i = 0; i < 5; ++i) {
+    probeVectors.push_back(makeRowVector(
+        {"t0", "t1", "t2", "t3", "t4", "t5"},
+        {makeFlatVector<int64_t>(128, [&](auto row) { return row; }),
+         makeFlatVector<int64_t>(128, [&](auto row) { return row; }),
+         makeFlatVector<int64_t>(128, [&](auto row) { return row; }),
+         makeFlatVector<int64_t>(128, [&](auto row) { return row; }),
+         makeArrayVector<int64_t>(
+             128,
+             [](vector_size_t /*unused*/) { return 1; },
+             [](vector_size_t, vector_size_t) { return 1; }),
+         makeFlatVector<StringView>(
+             128, [&](auto /*unused*/) { return dummyStringView; })}));
+  }
+
   std::vector<std::shared_ptr<TempFilePath>> probeFiles =
       createProbeFiles(probeVectors);
 
   createDuckDbTable("t", probeVectors);
   createDuckDbTable("u", {tableData.tableData});
 
-  const auto indexTable = createIndexTable(
-      /*numEqualJoinKeys=*/1, tableData.keyData, tableData.valueData);
+  const auto indexTable = TestIndexTable::create(
+      /*numEqualJoinKeys=*/3, tableData.keyData, tableData.valueData, *pool());
   const auto indexTableHandle =
       makeIndexTableHandle(indexTable, GetParam().asyncLookup);
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
-  auto scanOutput = tableType_->names();
-  std::random_device rd;
-  std::mt19937 g(rd());
-  std::shuffle(scanOutput.begin(), scanOutput.end(), g);
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      columnHandles;
   const auto indexScanNode = makeIndexScanNode(
       planNodeIdGenerator,
       indexTableHandle,
-      makeScanOutputType(scanOutput),
-      columnHandles);
+      makeScanOutputType({"u0", "u1", "u2", "u3", "u5"}),
+      makeIndexColumnHandles({"u0", "u1", "u2", "u3", "u5"}));
 
   auto plan = makeLookupPlan(
       planNodeIdGenerator,
       indexScanNode,
-      {"t0"},
-      {"u0"},
-      {"contains(t4, u1)", "u2 between t1 and t2"},
-      core::JoinType::kInner,
-      {"u0", "u4", "t0", "t1", "t4"});
-  runLookupQuery(
-      plan,
-      probeFiles,
-      GetParam().serialExecution,
-      GetParam().serialExecution,
-      32,
-      GetParam().numPrefetches,
-      "SELECT u.c0, u.c1, u.c2, u.c3, u.c4, u.c5, t.c0, t.c1, t.c2, t.c3, t.c4, t.c5 FROM t, u WHERE t.c0 = u.c0 AND array_contains(t.c4, u.c1) AND u.c2 BETWEEN t.c1 AND t.c2");
+      {"t0", "t1", "t2"},
+      {"u0", "u1", "u2"},
+      {},
+      "t3 > 4",
+      /*hasMarker=*/false,
+      core::JoinType::kLeft,
+      {"t1", "u1", "u2", "u3", "u5"});
+
+  AssertQueryBuilder(duckDbQueryRunner_)
+      .plan(plan)
+      .config(
+          core::QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
+          std::to_string(GetParam().numPrefetches))
+      .config(core::QueryConfig::kPreferredOutputBatchRows, "4")
+      .config(core::QueryConfig::kIndexLookupJoinSplitOutput, "true")
+      .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
+      .serialExecution(GetParam().serialExecution)
+      .barrierExecution(GetParam().serialExecution)
+      .assertResults(
+          "SELECT t.c1, u.c1, u.c2, u.c3, u.c5 FROM t LEFT JOIN u ON t.c0 = u.c0 AND t.c1 = u.c1 AND t.c2 = u.c2 AND t.c3 > 4");
 }
 } // namespace
 
@@ -2050,9 +3300,10 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
     testing::ValuesIn(IndexLookupJoinTest::getTestParams()),
     [](const testing::TestParamInfo<TestParam>& info) {
       return fmt::format(
-          "{}_{}prefetches_{}",
+          "{}_{}prefetches_{}_{}",
           info.param.asyncLookup ? "async" : "sync",
           info.param.numPrefetches,
-          info.param.serialExecution ? "serial" : "parallel");
+          info.param.serialExecution ? "serial" : "parallel",
+          info.param.hasNullKeys ? "nullKeys" : "noNullKeys");
     });
-} // namespace fecebook::velox::exec::test
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/LimitTest.cpp b/velox/exec/tests/LimitTest.cpp
index d1be2199c006..c00dbc0a32ca 100644
--- a/velox/exec/tests/LimitTest.cpp
+++ b/velox/exec/tests/LimitTest.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 #include "velox/exec/OutputBufferManager.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/PlanBuilder.h"
 
@@ -21,6 +23,7 @@ using namespace facebook::velox;
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 
+namespace {
 class LimitTest : public HiveConnectorTestBase {};
 
 TEST_F(LimitTest, basic) {
@@ -142,3 +145,190 @@ TEST_F(LimitTest, partialLimitEagerFlush) {
   test(true);
   test(false);
 }
+
+TEST_F(LimitTest, barrier) {
+  std::vector<RowVectorPtr> vectors;
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  const int numSplits{5};
+  const int numRowsPerSplit{1'000};
+  for (int32_t i = 0; i < numSplits; ++i) {
+    vectors.push_back(makeRowVector({makeFlatVector<int32_t>(
+        numRowsPerSplit, [](auto row) { return row; })}));
+    tempFiles.push_back(TempFilePath::create());
+  }
+  writeToFiles(toFilePaths(tempFiles), vectors);
+  createDuckDbTable(vectors);
+
+  struct {
+    bool barrierExecution;
+    int offset;
+    int limit;
+    int numExpectedBarriers;
+    int numExpectedOutputRows;
+    int numExpectedFinishedSplits;
+    int numExpectedOutputBatches;
+
+    std::string toString() const {
+      return fmt::format(
+          "barrierExecution {}, offset: {}, limit: {}, numExpectedBarriers: {}, numExpectedOutputRows: {}, numExpectedFinishedSplits: {}, numExpectedOutputBatches: {}",
+          barrierExecution,
+          offset,
+          limit,
+          numExpectedBarriers,
+          numExpectedOutputRows,
+          numExpectedFinishedSplits,
+          numExpectedOutputBatches);
+    }
+  } testSettings[] = {// Test the case where the limit covers all the input rows
+                      // with barrier and not.
+                      {true,
+                       0,
+                       numRowsPerSplit * numSplits,
+                       numSplits,
+                       numRowsPerSplit * numSplits,
+                       numSplits - 1,
+                       numSplits},
+                      {false,
+                       0,
+                       numRowsPerSplit * numSplits,
+                       0,
+                       numRowsPerSplit * numSplits,
+                       numSplits - 1,
+                       numSplits},
+                      // Test the cases where the limit covers the first entire
+                      // split rows with barrier or not. with barrier and not.
+                      {true, 0, numRowsPerSplit, 1, numRowsPerSplit, 0, 1},
+                      {false, 0, numRowsPerSplit, 0, numRowsPerSplit, 0, 1},
+                      // Test the case where the limit covers the one and half
+                      // split rows with barrier or not.
+                      {true,
+                       0,
+                       numRowsPerSplit + numRowsPerSplit / 2,
+                       2,
+                       numRowsPerSplit + numRowsPerSplit / 2,
+                       1,
+                       2},
+                      {false,
+                       0,
+                       numRowsPerSplit + numRowsPerSplit / 2,
+                       0,
+                       numRowsPerSplit + numRowsPerSplit / 2,
+                       1,
+                       2},
+                      {true,
+                       0,
+                       numRowsPerSplit + numRowsPerSplit - 1,
+                       2,
+                       numRowsPerSplit + numRowsPerSplit - 1,
+                       1,
+                       2},
+                      {false,
+                       0,
+                       numRowsPerSplit + numRowsPerSplit - 1,
+                       0,
+                       numRowsPerSplit + numRowsPerSplit - 1,
+                       1,
+                       2},
+                      // Test the case where the limit set to cover more than
+                      // all the input rows with barrier or not.
+                      {true,
+                       0,
+                       numRowsPerSplit * (numSplits + 1),
+                       numSplits,
+                       numRowsPerSplit * numSplits,
+                       numSplits,
+                       numSplits},
+                      {false,
+                       0,
+                       numRowsPerSplit * (numSplits + 1),
+                       0,
+                       numRowsPerSplit * numSplits,
+                       numSplits,
+                       numSplits},
+                      // Test the cases where the limit set to cover partial
+                      // input rows in the middle with barrier or not.
+                      {true,
+                       numRowsPerSplit,
+                       numRowsPerSplit + numRowsPerSplit - 1,
+                       3,
+                       numRowsPerSplit + numRowsPerSplit - 1,
+                       2,
+                       2},
+                      {false,
+                       numRowsPerSplit,
+                       numRowsPerSplit + numRowsPerSplit - 1,
+                       0,
+                       numRowsPerSplit + numRowsPerSplit - 1,
+                       2,
+                       2},
+                      {true,
+                       numRowsPerSplit,
+                       numRowsPerSplit * (numSplits - 1),
+                       numSplits,
+                       numRowsPerSplit * (numSplits - 1),
+                       numSplits - 1,
+                       numSplits - 1},
+                      {false,
+                       numRowsPerSplit,
+                       numRowsPerSplit * (numSplits - 1),
+                       0,
+                       numRowsPerSplit * (numSplits - 1),
+                       numSplits - 1,
+                       numSplits - 1},
+                      {true,
+                       numRowsPerSplit,
+                       numRowsPerSplit / 2,
+                       2,
+                       numRowsPerSplit / 2,
+                       1,
+                       1},
+                      {false,
+                       numRowsPerSplit,
+                       numRowsPerSplit / 2,
+                       0,
+                       numRowsPerSplit / 2,
+                       1,
+                       1},
+                      {true,
+                       numRowsPerSplit / 2,
+                       numRowsPerSplit * numSplits,
+                       numSplits,
+                       numRowsPerSplit * numSplits - numRowsPerSplit / 2,
+                       numSplits,
+                       numSplits},
+                      {false,
+                       numRowsPerSplit / 2,
+                       numRowsPerSplit * numSplits,
+                       0,
+                       numRowsPerSplit * numSplits - numRowsPerSplit / 2,
+                       numSplits,
+                       numSplits}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.toString());
+    core::PlanNodeId limitPlanNodeId;
+    auto plan = PlanBuilder()
+                    .tableScan(asRowType(vectors.back()->type()))
+                    .limit(testData.offset, testData.limit, true)
+                    .capturePlanNodeId(limitPlanNodeId)
+                    .planNode();
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .splits(makeHiveConnectorSplits(tempFiles))
+                    .serialExecution(true)
+                    .barrierExecution(testData.barrierExecution)
+                    .assertResults(
+                        fmt::format(
+                            "SELECT * FROM tmp LIMIT {} OFFSET {}",
+                            testData.limit,
+                            testData.offset));
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(taskStats.numBarriers, testData.numExpectedBarriers);
+    ASSERT_EQ(taskStats.numFinishedSplits, testData.numExpectedFinishedSplits);
+    ASSERT_EQ(
+        exec::toPlanStats(taskStats).at(limitPlanNodeId).outputRows,
+        testData.numExpectedOutputRows);
+    ASSERT_EQ(
+        exec::toPlanStats(taskStats).at(limitPlanNodeId).outputVectors,
+        testData.numExpectedOutputBatches);
+  }
+}
+} // namespace
diff --git a/velox/exec/tests/LocalPartitionTest.cpp b/velox/exec/tests/LocalPartitionTest.cpp
index 508f8db67618..917aa1e32131 100644
--- a/velox/exec/tests/LocalPartitionTest.cpp
+++ b/velox/exec/tests/LocalPartitionTest.cpp
@@ -329,6 +329,80 @@ TEST_F(LocalPartitionTest, partitionBuffering) {
       queryBuilder.assertResults(query), 2200, 2, 2);
 }
 
+TEST_F(LocalPartitionTest, partitionBufferingWithStringBuffers) {
+  // Test string buffer memory accounting with partition buffering.
+  // String buffers are multiply-referenced across partitions. The fix
+  // amortizes string buffer sizes across partitions to avoid over-counting,
+  // which allows more efficient buffering.
+  std::vector<RowVectorPtr> vectors;
+  for (auto i = 0; i < 4; ++i) {
+    vectors.emplace_back(makeRowVector(
+        {"c0", "c1"},
+        {makeFlatVector<int32_t>(100, [](auto row) { return row % 2; }),
+         makeFlatVector<std::string>(
+             100, [](auto /*row*/) { return std::string(100, 'a'); })}));
+  }
+
+  auto runQuery = [&](const std::vector<RowVectorPtr>& input,
+                      int maxDrivers,
+                      int maxPartitionBufferSize) {
+    std::string query{"SELECT c0, arbitrary(c1) FROM tmp GROUP BY c0"};
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .localPartition(
+                {"c0"},
+                {PlanBuilder(planNodeIdGenerator).values(input).planNode()})
+            .partialAggregation({"c0"}, {"arbitrary(c1)"})
+            .planNode();
+    createDuckDbTable(vectors);
+
+    AssertQueryBuilder queryBuilder(plan, duckDbQueryRunner_);
+    queryBuilder.maxDrivers(maxDrivers);
+
+    std::unordered_map<std::string, std::string> configs;
+    configs[core::QueryConfig::
+                kMinLocalExchangePartitionCountToUsePartitionBuffer] =
+        std::to_string(2);
+    configs[core::QueryConfig::kMaxLocalExchangePartitionBufferSize] =
+        std::to_string(maxPartitionBufferSize);
+    queryBuilder.configs(configs);
+
+    return queryBuilder.assertResults(query);
+  };
+
+  // With amortized string buffer accounting, the buffer can accumulate rows
+  // from all input vectors. So only 2 vectors are flushed to
+  // LocalExchangeQueues, compared to 8 if not amortizing string buffer sizes.
+  verifyExchangeSourceOperatorStats(runQuery(vectors, 2, 50000), 400, 2, 2);
+
+  // Test case with 99% of data belonging to one partition. We expect all
+  // partition buffers getting flushed together when the total size of all
+  // partition buffers exceeds the limit, instead of flushing each partiton
+  // buffer individually.
+  vectors.clear();
+  for (auto i = 0; i < 4; ++i) {
+    vectors.emplace_back(makeRowVector(
+        {"c0", "c1"},
+        {makeFlatVector<int32_t>(
+             100,
+             [](auto row) {
+               if (row == 0) {
+                 return 0;
+               } else {
+                 return 1;
+               }
+             }),
+         makeFlatVector<std::string>(
+             100, [](auto /*row*/) { return std::string(100, 'a'); })}));
+  }
+
+  // The total size of all partition buffers should exceed the limit and trigger
+  // the flush of all partition buffers at every batch, hence flushing a total
+  // of 8 vectors.
+  verifyExchangeSourceOperatorStats(runQuery(vectors, 2, 20000), 400, 8, 2);
+}
+
 TEST_F(LocalPartitionTest, partitionBufferingPreserveEncoding) {
   std::vector<RowVectorPtr> vectors = {
       makeRowVector({"c0"}, {makeConstant<int32_t>(0, 100)}),
@@ -388,8 +462,9 @@ TEST_F(LocalPartitionTest, maxBufferSizeGather) {
 
   auto valuesNode = [&](int start, int end) {
     return PlanBuilder(planNodeIdGenerator)
-        .values(std::vector<RowVectorPtr>(
-            vectors.begin() + start, vectors.begin() + end))
+        .values(
+            std::vector<RowVectorPtr>(
+                vectors.begin() + start, vectors.begin() + end))
         .planNode();
   };
 
@@ -498,9 +573,11 @@ TEST_F(LocalPartitionTest, indicesBufferCapacity) {
   params.maxDrivers = 2;
   auto cursor = TaskCursor::create(params);
   for (auto i = 0; i < filePaths.size(); ++i) {
-    auto id = scanNodeIds[i % 3];
+    auto& id = scanNodeIds[i % 3];
     cursor->task()->addSplit(
         id, Split(makeHiveConnectorSplit(filePaths[i]->getPath())));
+  }
+  for (auto& id : scanNodeIds) {
     cursor->task()->noMoreSplits(id);
   }
   int numRows = 0;
@@ -959,8 +1036,9 @@ TEST_F(LocalPartitionTest, unionAllLocalExchangeWithInterDependency) {
       }
     };
 
-    Operator::registerOperator(std::make_unique<BlockingNodeFactory>(
-        std::move(blockingCallback), std::move(finishCallback)));
+    Operator::registerOperator(
+        std::make_unique<BlockingNodeFactory>(
+            std::move(blockingCallback), std::move(finishCallback)));
 
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
     auto plan = PlanBuilder(planNodeIdGenerator)
@@ -1028,8 +1106,9 @@ TEST_F(
 
   auto finishCallback = [&](bool /*unused*/) {};
 
-  Operator::registerOperator(std::make_unique<BlockingNodeFactory>(
-      std::move(blockingCallback), std::move(finishCallback)));
+  Operator::registerOperator(
+      std::make_unique<BlockingNodeFactory>(
+          std::move(blockingCallback), std::move(finishCallback)));
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   auto plan = PlanBuilder(planNodeIdGenerator)
diff --git a/velox/exec/tests/MergeJoinTest.cpp b/velox/exec/tests/MergeJoinTest.cpp
index 5714301a2f3b..f48871c09139 100644
--- a/velox/exec/tests/MergeJoinTest.cpp
+++ b/velox/exec/tests/MergeJoinTest.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.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/PlanBuilder.h"
@@ -112,12 +113,13 @@ class MergeJoinTest : public HiveConnectorTestBase {
     for (const auto& row : input) {
       std::vector<VectorPtr> children;
       for (const auto& child : row->children()) {
-        children.push_back(std::make_shared<LazyVector>(
-            pool(),
-            child->type(),
-            child->size(),
-            std::make_unique<MySimpleVectorLoader>(
-                batchId, counter, [=](RowSet) { return child; })));
+        children.push_back(
+            std::make_shared<LazyVector>(
+                pool(),
+                child->type(),
+                child->size(),
+                std::make_unique<MySimpleVectorLoader>(
+                    batchId, counter, [=, this](RowSet) { return child; })));
       }
 
       data.push_back(makeRowVector(children));
@@ -369,6 +371,87 @@ class MergeJoinTest : public HiveConnectorTestBase {
         std::bind(
             &MergeJoinTest::generateLazyInput, this, std::placeholders::_1));
   }
+
+  void testJoinTwoKeysWithNulls(
+      RowVectorPtr& leftVectors,
+      RowVectorPtr& rightVectors) {
+    auto leftFile = TempFilePath::create();
+    writeToFile(leftFile->getPath(), leftVectors);
+    createDuckDbTable("t", {leftVectors});
+    auto rightFile = TempFilePath::create();
+    writeToFile(rightFile->getPath(), rightVectors);
+    createDuckDbTable("u", {rightVectors});
+
+    auto joinTypes = {
+        core::JoinType::kInner,
+        core::JoinType::kLeft,
+        core::JoinType::kRight,
+        core::JoinType::kFull,
+    };
+
+    for (auto joinType : joinTypes) {
+      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+      core::PlanNodeId leftScanId;
+      core::PlanNodeId rightScanId;
+      auto op = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(
+                        ROW({"c0", "c1", "c2", "c3"},
+                            {VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR()}))
+                    .capturePlanNodeId(leftScanId)
+                    .mergeJoin(
+                        {"c0", "c1"},
+                        {"rc0", "rc1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .tableScan(
+                                ROW({"rc0", "rc1", "rc2"},
+                                    {VARCHAR(), VARCHAR(), VARCHAR()}))
+                            .capturePlanNodeId(rightScanId)
+                            .planNode(),
+                        "",
+                        {"c0", "c1", "c2", "c3", "rc0", "rc1", "rc2"},
+                        joinType)
+                    .planNode();
+      AssertQueryBuilder(op, duckDbQueryRunner_)
+          .split(rightScanId, makeHiveConnectorSplit(rightFile->getPath()))
+          .split(leftScanId, makeHiveConnectorSplit(leftFile->getPath()))
+          .assertResults(
+              fmt::format(
+                  "SELECT * FROM t {} JOIN u "
+                  "ON t.c0 = u.rc0 AND t.c1 = u.rc1",
+                  core::JoinTypeName::toName(joinType)));
+    }
+
+    {
+      // anti join
+      auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+      core::PlanNodeId leftScanId;
+      core::PlanNodeId rightScanId;
+      auto op = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(
+                        ROW({"c0", "c1", "c2", "c3"},
+                            {VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR()}))
+                    .capturePlanNodeId(leftScanId)
+                    .mergeJoin(
+                        {"c0", "c1"},
+                        {"rc0", "rc1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .tableScan(
+                                ROW({"rc0", "rc1", "rc2"},
+                                    {VARCHAR(), VARCHAR(), VARCHAR()}))
+                            .capturePlanNodeId(rightScanId)
+                            .planNode(),
+                        "",
+                        {"c0", "c1", "c2", "c3"},
+                        core::JoinType::kAnti)
+                    .planNode();
+      AssertQueryBuilder(op, duckDbQueryRunner_)
+          .split(rightScanId, makeHiveConnectorSplit(rightFile->getPath()))
+          .split(leftScanId, makeHiveConnectorSplit(leftFile->getPath()))
+          .assertResults(
+              "SELECT * FROM t WHERE NOT exists (select * from u "
+              "where t.c0 = u.rc0 AND t.c1 = u.rc1)");
+    }
+  }
 };
 
 TEST_F(MergeJoinTest, oneToOneAllMatch) {
@@ -870,10 +953,11 @@ TEST_F(MergeJoinTest, lazyVectors) {
     AssertQueryBuilder(op, duckDbQueryRunner_)
         .split(rightScanId, makeHiveConnectorSplit(rightFile->getPath()))
         .split(leftScanId, makeHiveConnectorSplit(leftFile->getPath()))
-        .assertResults(fmt::format(
-            "SELECT c0, rc0, c1, rc1, c2, c3 FROM t {} JOIN u "
-            "ON t.c0 = u.rc0 AND c1 + rc1 < 30",
-            joinTypeName(joinType)));
+        .assertResults(
+            fmt::format(
+                "SELECT c0, rc0, c1, rc1, c2, c3 FROM t {} JOIN u "
+                "ON t.c0 = u.rc0 AND c1 + rc1 < 30",
+                core::JoinTypeName::toName(joinType)));
   }
 }
 
@@ -1016,6 +1100,110 @@ TEST_F(MergeJoinTest, semiJoinWithMultipleMatchVectors) {
       core::JoinType::kLeftSemiFilter);
 }
 
+TEST_F(MergeJoinTest, semiJoinWithMultiMatchedRowsWithFilter) {
+  auto left = makeRowVector(
+      {"t0", "t1"},
+      {makeNullableFlatVector<int64_t>({2, 2, 2, 2, 2}),
+       makeNullableFlatVector<int64_t>({3, 2, 3, 2, 2})});
+
+  auto right = makeRowVector(
+      {"u0", "u1"},
+      {makeNullableFlatVector<int64_t>({2, 2, 2, 2, 2, 2}),
+       makeNullableFlatVector<int64_t>({2, 2, 2, 2, 2, 4})});
+
+  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(split(left, 2))
+                    .mergeJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(split(right, 2))
+                            .planNode(),
+                        filter,
+                        outputLayout,
+                        joinType)
+                    .planNode();
+    AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .config(core::QueryConfig::kPreferredOutputBatchRows, "2")
+        .config(core::QueryConfig::kMaxOutputBatchRows, "2")
+        .assertResults(sql);
+  };
+
+  // Left Semi join With filter
+  testSemiJoin(
+      "t1 > u1",
+      "SELECT t0, t1 FROM t where t0 IN (SELECT u0 from u where t1 > u1)",
+      {"t0", "t1"},
+      core::JoinType::kLeftSemiFilter);
+
+  // Right Semi join With filter
+  testSemiJoin(
+      "u1 > t1",
+      "SELECT u0, u1 FROM u where u0 IN (SELECT t0 from t where u1 > t1)",
+      {"u0", "u1"},
+      core::JoinType::kRightSemiFilter);
+}
+
+TEST_F(MergeJoinTest, semiJoinWithOneMatchedRowWithFilter) {
+  auto left = makeRowVector(
+      {"t0", "t1"},
+      {makeNullableFlatVector<int64_t>({2, 2}),
+       makeNullableFlatVector<int64_t>({3, 5})});
+
+  auto right = makeRowVector(
+      {"u0", "u1"},
+      {makeNullableFlatVector<int64_t>({2, 2}),
+       makeNullableFlatVector<int64_t>({1, 4})});
+
+  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(split(left, 2))
+                    .mergeJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(split(right, 2))
+                            .planNode(),
+                        filter,
+                        outputLayout,
+                        joinType)
+                    .planNode();
+    AssertQueryBuilder(plan, duckDbQueryRunner_)
+        .config(core::QueryConfig::kPreferredOutputBatchRows, "2")
+        .config(core::QueryConfig::kMaxOutputBatchRows, "2")
+        .assertResults(sql);
+  };
+
+  // Left Semi join With filter
+  testSemiJoin(
+      "t1 > u1",
+      "SELECT t0, t1 FROM t where t0 IN (SELECT u0 from u where t1 > u1)",
+      {"t0", "t1"},
+      core::JoinType::kLeftSemiFilter);
+
+  // Right Semi join With filter
+  testSemiJoin(
+      "u1 > t1",
+      "SELECT u0, u1 FROM u where u0 IN (SELECT t0 from t where u1 > t1)",
+      {"u0", "u1"},
+      core::JoinType::kRightSemiFilter);
+}
+
 TEST_F(MergeJoinTest, rightJoin) {
   auto left = makeRowVector(
       {"t0"},
@@ -1206,6 +1394,160 @@ TEST_F(MergeJoinTest, antiJoinWithTwoJoinKeys) {
           "SELECT * FROM t WHERE NOT exists (select * from u where t.a = u.c and t.b < u.d)");
 }
 
+TEST_F(MergeJoinTest, matchRatioStats) {
+  // Test match ratio statistics for different join scenarios.
+
+  // Inner join with full match (all rows match).
+  {
+    auto left = makeRowVector(
+        {"t0"}, {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5})});
+    auto right = makeRowVector(
+        {"u0"}, {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5})});
+
+    createDuckDbTable("t", {left});
+    createDuckDbTable("u", {right});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId mergeJoinNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                "",
+                {"t0", "u0"},
+                core::JoinType::kInner)
+            .capturePlanNodeId(mergeJoinNodeId)
+            .planNode();
+
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .assertResults("SELECT t0, u0 FROM t, u WHERE t0 = u0");
+
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(stats.at(mergeJoinNodeId).outputRows, 5);
+
+    auto runtimeStats = stats.at(mergeJoinNodeId).customStats;
+    ASSERT_EQ(runtimeStats.at("matchedLeftRows").sum, 5);
+    ASSERT_EQ(runtimeStats.at("matchedRightRows").sum, 5);
+  }
+
+  // Inner join with partial match.
+  {
+    auto left = makeRowVector(
+        {"t0"}, {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8})});
+    auto right = makeRowVector(
+        {"u0"}, {makeNullableFlatVector<int64_t>({2, 4, 6, 10, 12})});
+
+    createDuckDbTable("t", {left});
+    createDuckDbTable("u", {right});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId mergeJoinNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                "",
+                {"t0", "u0"},
+                core::JoinType::kInner)
+            .capturePlanNodeId(mergeJoinNodeId)
+            .planNode();
+
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .assertResults("SELECT t0, u0 FROM t, u WHERE t0 = u0");
+
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(stats.at(mergeJoinNodeId).outputRows, 3);
+
+    auto runtimeStats = stats.at(mergeJoinNodeId).customStats;
+    // Only 3 left rows match (2, 4, 6).
+    ASSERT_EQ(runtimeStats.at("matchedLeftRows").sum, 3);
+    // Only 3 right rows match (2, 4, 6).
+    ASSERT_EQ(runtimeStats.at("matchedRightRows").sum, 3);
+  }
+
+  // Left join - all left rows appear in output.
+  {
+    auto left = makeRowVector(
+        {"t0"}, {makeNullableFlatVector<int64_t>({1, 2, 3, 4, 5})});
+    auto right =
+        makeRowVector({"u0"}, {makeNullableFlatVector<int64_t>({2, 4})});
+
+    createDuckDbTable("t", {left});
+    createDuckDbTable("u", {right});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId mergeJoinNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                "",
+                {"t0", "u0"},
+                core::JoinType::kLeft)
+            .capturePlanNodeId(mergeJoinNodeId)
+            .planNode();
+
+    auto task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .assertResults("SELECT t0, u0 FROM t LEFT JOIN u ON t0 = u0");
+
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(stats.at(mergeJoinNodeId).outputRows, 5);
+
+    auto runtimeStats = stats.at(mergeJoinNodeId).customStats;
+    // Only 2 left rows match (2, 4).
+    ASSERT_EQ(runtimeStats.at("matchedLeftRows").sum, 2);
+    ASSERT_EQ(runtimeStats.at("matchedRightRows").sum, 2);
+  }
+
+  // Join with duplicate keys (cartesian product).
+  {
+    auto left = makeRowVector(
+        {"t0"}, {makeNullableFlatVector<int64_t>({1, 1, 1, 2, 2})});
+    auto right = makeRowVector(
+        {"u0"}, {makeNullableFlatVector<int64_t>({1, 1, 2, 2, 2})});
+
+    createDuckDbTable("t", {left});
+    createDuckDbTable("u", {right});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId mergeJoinNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values({left})
+            .mergeJoin(
+                {"t0"},
+                {"u0"},
+                PlanBuilder(planNodeIdGenerator).values({right}).planNode(),
+                "",
+                {"t0", "u0"},
+                core::JoinType::kInner)
+            .capturePlanNodeId(mergeJoinNodeId)
+            .planNode();
+
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .assertResults("SELECT t0, u0 FROM t, u WHERE t0 = u0");
+
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(stats.at(mergeJoinNodeId).outputRows, 12);
+
+    auto runtimeStats = stats.at(mergeJoinNodeId).customStats;
+    // 3 left rows with key=1 and 2 left rows with key=2.
+    ASSERT_EQ(runtimeStats.at("matchedLeftRows").sum, 5);
+    // 2 right rows with key=1 and 3 right rows with key=2.
+    ASSERT_EQ(runtimeStats.at("matchedRightRows").sum, 5);
+  }
+}
+
 TEST_F(MergeJoinTest, antiJoinWithUniqueJoinKeys) {
   auto left = makeRowVector(
       {"a", "b"},
@@ -1811,3 +2153,85 @@ TEST_F(MergeJoinTest, barrier) {
     }
   }
 }
+
+TEST_F(MergeJoinTest, antiJoinWithFilterWithMultiMatchedRows) {
+  auto left = makeRowVector({"t0"}, {makeNullableFlatVector<int64_t>({1, 2})});
+
+  auto right =
+      makeRowVector({"u0"}, {makeNullableFlatVector<int64_t>({1, 2, 2, 2})});
+
+  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, antiJoinWithTwoJoinKeysInDifferentBatch) {
+  auto left = makeRowVector(
+      {"a", "b"},
+      {makeNullableFlatVector<int32_t>({1, 1, 1, 1}),
+       makeNullableFlatVector<double>({3.0, 3.0, 3.0, 3.0})});
+
+  auto right = makeRowVector(
+      {"c", "d"},
+      {makeNullableFlatVector<int32_t>({1, 1, 1}),
+       makeNullableFlatVector<double>({2.0, 2.0, 4.0})});
+
+  createDuckDbTable("t", {left});
+  createDuckDbTable("u", {right});
+
+  // Anti join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({split(left, 2)})
+                  .mergeJoin(
+                      {"a"},
+                      {"c"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({split(right, 2)})
+                          .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, testJoinWithTwoKeysAndSecondColumnHasNulls) {
+  auto left = makeRowVector(
+      {"c0", "c1", "c2", "c3"},
+      {
+          makeNullableFlatVector<StringView>(
+              {"202408", "202409", "202409", "202410"}),
+          makeNullableFlatVector<StringView>({"1", std::nullopt, "2", "3"}),
+          makeNullableFlatVector<StringView>({"1", "2", "2", "3"}),
+          makeNullableFlatVector<StringView>({"1", "2", "2", "3"}),
+      });
+  auto right = makeRowVector(
+      {"rc0", "rc1", "rc2"},
+      {makeNullableFlatVector<StringView>(
+           {"202408", "202409", "202409", "202410"}),
+       makeNullableFlatVector<StringView>({"1", std::nullopt, "2", "3"}),
+       makeNullableFlatVector<StringView>({"1", std::nullopt, "2", "3"})});
+
+  testJoinTwoKeysWithNulls(left, right);
+}
diff --git a/velox/exec/tests/MergeTest.cpp b/velox/exec/tests/MergeTest.cpp
index da7fc3a55183..843d524fc5f3 100644
--- a/velox/exec/tests/MergeTest.cpp
+++ b/velox/exec/tests/MergeTest.cpp
@@ -13,11 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#include "velox/exec/Merge.h"
 #include "folly/experimental/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.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;
 using namespace facebook::velox::exec;
@@ -25,6 +30,11 @@ using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::exec::test;
 
 class MergeTest : public OperatorTestBase {
+ public:
+  MergeTest() {
+    filesystems::registerLocalFileSystem();
+  }
+
  protected:
   void testSingleKey(
       const std::vector<RowVectorPtr>& inputVectors,
@@ -33,7 +43,6 @@ class MergeTest : public OperatorTestBase {
 
     std::vector<std::string> sortOrderSqls = {
         "NULLS LAST", "NULLS FIRST", "DESC NULLS FIRST", "DESC NULLS LAST"};
-
     for (const auto& sortOrderSql : sortOrderSqls) {
       const auto orderByClause = fmt::format("{} {}", key, sortOrderSql);
       auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
@@ -41,18 +50,17 @@ class MergeTest : public OperatorTestBase {
                       .localMerge(
                           {orderByClause},
                           {PlanBuilder(planNodeIdGenerator)
-                               .values(inputVectors, true)
+                               .values(inputVectors)
                                .orderBy({orderByClause}, true)
                                .planNode()})
                       .planNode();
-
+      // Use single source for local merge.
       CursorParameters params;
       params.planNode = plan;
-      params.maxDrivers = 2;
+      params.maxDrivers = 1;
       assertQueryOrdered(
           params,
-          "SELECT * FROM (SELECT * FROM tmp UNION ALL SELECT * FROM tmp) ORDER BY " +
-              orderByClause,
+          "SELECT * FROM (SELECT * FROM tmp) ORDER BY " + orderByClause,
           {keyIndex});
 
       // Use multiple sources for local merge.
@@ -100,18 +108,17 @@ class MergeTest : public OperatorTestBase {
                         .localMerge(
                             orderByClauses,
                             {PlanBuilder(planNodeIdGenerator)
-                                 .values(inputVectors, true)
+                                 .values(inputVectors)
                                  .orderBy(orderByClauses, true)
                                  .planNode()})
                         .planNode();
-
+        // Use single source for local merge.
         CursorParameters params;
         params.planNode = plan;
-        params.maxDrivers = 2;
+        params.maxDrivers = 1;
         assertQueryOrdered(
             params,
-            "SELECT * FROM (SELECT * FROM tmp UNION ALL SELECT * FROM tmp) " +
-                orderBySql,
+            "SELECT * FROM (SELECT * FROM tmp) " + orderBySql,
             sortingKeys);
 
         // Use multiple sources for local merge.
@@ -131,12 +138,473 @@ class MergeTest : public OperatorTestBase {
       }
     }
   }
+
+  void testSingleKeyWithSpill(
+      const std::vector<RowVectorPtr>& inputVectors,
+      const std::string& key) {
+    auto keyIndex = inputVectors[0]->type()->asRow().getChildIdx(key);
+
+    std::vector<std::string> sortOrderSqls = {
+        "NULLS LAST", "NULLS FIRST", "DESC NULLS FIRST", "DESC NULLS LAST"};
+
+    for (const auto& sortOrderSql : sortOrderSqls) {
+      const auto orderByClause = fmt::format("{} {}", key, sortOrderSql);
+      const auto planNodeIdGenerator =
+          std::make_shared<core::PlanNodeIdGenerator>();
+      const std::shared_ptr<TempDirectoryPath> spillDirectory =
+          TempDirectoryPath::create();
+      std::vector<std::shared_ptr<const core::PlanNode>> sources;
+      for (const auto& input : inputVectors) {
+        sources.push_back(PlanBuilder(planNodeIdGenerator)
+                              .values({input})
+                              .orderBy({orderByClause}, true)
+                              .planNode());
+      }
+      core::PlanNodeId nodeId;
+      const auto plan = PlanBuilder(planNodeIdGenerator)
+                            .localMerge({orderByClause}, std::move(sources))
+                            .capturePlanNodeId(nodeId)
+                            .planNode();
+      CursorParameters params;
+      params.planNode = plan;
+      params.maxDrivers = 2;
+      params.queryCtx = createQueryCtx(
+          {{"spill_enabled", "true"},
+           {"local_merge_spill_enabled", "true"},
+           {"local_merge_max_num_merge_sources", "2"}});
+      params.spillDirectory = spillDirectory->getPath();
+      auto task = assertQueryOrdered(
+          params, "SELECT * FROM tmp ORDER BY " + orderByClause, {keyIndex});
+      auto taskStats = toPlanStats(task->taskStats());
+      auto& planStats = taskStats.at(nodeId);
+      auto expectedNumSpillFiles = (inputVectors.size() + 2 - 1) / 2;
+      ASSERT_GT(planStats.spilledBytes, 0);
+      ASSERT_EQ(planStats.spilledPartitions, expectedNumSpillFiles);
+      ASSERT_EQ(planStats.spilledFiles, expectedNumSpillFiles);
+      ASSERT_EQ(
+          planStats.spilledRows, inputVectors.size() * inputVectors[0]->size());
+    }
+  }
+
+  void testTwoKeysWithSpill(
+      const std::vector<RowVectorPtr>& inputVectors,
+      const std::string& key1,
+      const std::string& key2) {
+    auto& rowType = inputVectors[0]->type()->asRow();
+    auto sortingKeys = {rowType.getChildIdx(key1), rowType.getChildIdx(key2)};
+
+    std::vector<core::SortOrder> sortOrders = {
+        core::kAscNullsLast,
+        core::kAscNullsFirst,
+        core::kDescNullsFirst,
+        core::kDescNullsLast};
+    std::vector<std::string> sortOrderSqls = {
+        "NULLS LAST", "NULLS FIRST", "DESC NULLS FIRST", "DESC NULLS LAST"};
+
+    for (auto i = 0; i < sortOrders.size(); ++i) {
+      for (auto j = 0; j < sortOrders.size(); ++j) {
+        const std::vector<std::string> orderByClauses = {
+            fmt::format("{} {}", key1, sortOrderSqls[i]),
+            fmt::format("{} {}", key2, sortOrderSqls[j])};
+        const auto orderBySql = fmt::format(
+            "ORDER BY {}, {}", orderByClauses[0], orderByClauses[1]);
+        const auto planNodeIdGenerator =
+            std::make_shared<core::PlanNodeIdGenerator>();
+        const std::shared_ptr<TempDirectoryPath> spillDirectory =
+            TempDirectoryPath::create();
+        std::vector<std::shared_ptr<const core::PlanNode>> sources;
+        for (const auto& input : inputVectors) {
+          sources.push_back(PlanBuilder(planNodeIdGenerator)
+                                .values({input})
+                                .orderBy(orderByClauses, true)
+                                .planNode());
+        }
+        core::PlanNodeId nodeId;
+        const auto plan = PlanBuilder(planNodeIdGenerator)
+                              .localMerge({orderByClauses}, std::move(sources))
+                              .capturePlanNodeId(nodeId)
+                              .planNode();
+        CursorParameters params;
+        params.planNode = plan;
+        params.maxDrivers = 2;
+        params.queryCtx = createQueryCtx(
+            {{"spill_enabled", "true"},
+             {"local_merge_spill_enabled", "true"},
+             {"local_merge_max_num_merge_sources", "2"}});
+        params.spillDirectory = spillDirectory->getPath();
+        auto task = assertQueryOrdered(
+            params, "SELECT * FROM tmp " + orderBySql, sortingKeys);
+        auto taskStats = toPlanStats(task->taskStats());
+        auto& planStats = taskStats.at(nodeId);
+        auto expectedNumSpillFiles = (inputVectors.size() + 2 - 1) / 2;
+        ASSERT_GT(planStats.spilledBytes, 0);
+        ASSERT_EQ(planStats.spilledPartitions, expectedNumSpillFiles);
+        ASSERT_EQ(planStats.spilledFiles, expectedNumSpillFiles);
+        ASSERT_EQ(
+            planStats.spilledRows,
+            inputVectors.size() * inputVectors[0]->size());
+      }
+    }
+  }
+
+  void testLocalMerge(
+      int numInputSources,
+      int numInputBatches,
+      int inputBatchSize,
+      int maxBatchRows,
+      int maxBatchBytes,
+      int expectedOuputBatches) {
+    std::vector<std::vector<RowVectorPtr>> inputVectors;
+    for (int32_t i = 0; i < numInputSources; ++i) {
+      std::vector<RowVectorPtr> vectors;
+      for (int32_t j = 0; j < numInputBatches; ++j) {
+        auto c0 = makeFlatVector<int64_t>(
+            inputBatchSize,
+            [&](auto row) { return inputBatchSize * j + row; },
+            nullEvery(5));
+        auto c1 = makeFlatVector<int64_t>(
+            inputBatchSize, [&](auto row) { return row; }, nullEvery(5));
+        auto c2 = makeFlatVector<double>(
+            inputBatchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+        auto c3 = makeFlatVector<StringView>(inputBatchSize, [](auto row) {
+          return StringView::makeInline(std::to_string(row));
+        });
+        vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+      }
+      inputVectors.push_back(std::move(vectors));
+    }
+    std::vector<RowVectorPtr> duckInputs;
+    for (const auto& input : inputVectors) {
+      for (const auto& vector : input) {
+        duckInputs.push_back(vector);
+      }
+    }
+    createDuckDbTable(duckInputs);
+    auto keyIndex = inputVectors[0][0]->type()->asRow().getChildIdx("c0");
+
+    const auto orderByClause = fmt::format("{}", "c0");
+    const auto planNodeIdGenerator =
+        std::make_shared<core::PlanNodeIdGenerator>();
+    const std::shared_ptr<TempDirectoryPath> spillDirectory =
+        TempDirectoryPath::create();
+    std::vector<std::shared_ptr<const core::PlanNode>> sources;
+    sources.reserve(inputVectors.size());
+    for (const auto& vectors : inputVectors) {
+      sources.push_back(PlanBuilder(planNodeIdGenerator)
+                            .values(vectors)
+                            .orderBy({orderByClause}, true)
+                            .planNode());
+    }
+    core::PlanNodeId localMergeNodeId;
+    const auto plan = PlanBuilder(planNodeIdGenerator)
+                          .localMerge({orderByClause}, std::move(sources))
+                          .capturePlanNodeId(localMergeNodeId)
+                          .planNode();
+    CursorParameters params;
+    params.planNode = plan;
+    params.maxDrivers = numInputSources;
+    params.queryCtx = createQueryCtx(
+        {{"spill_enabled", "false"},
+         {"local_merge_spill_enabled", "false"},
+         {"preferred_output_batch_bytes", std::to_string(maxBatchBytes)},
+         {"preferred_output_batch_rows", std::to_string(maxBatchRows)}},
+        false);
+    auto task = assertQueryOrdered(
+        params, "SELECT * FROM tmp ORDER BY " + orderByClause, {keyIndex});
+
+    auto taskStats = toPlanStats(task->taskStats());
+    const auto& mergeStats = taskStats.at(localMergeNodeId);
+    ASSERT_EQ(mergeStats.spilledBytes, 0);
+    ASSERT_EQ(mergeStats.spilledPartitions, 0);
+    ASSERT_EQ(mergeStats.spilledFiles, 0);
+    ASSERT_EQ(mergeStats.spilledRows, 0);
+    ASSERT_EQ(
+        mergeStats.outputRows,
+        numInputSources * numInputBatches * inputBatchSize);
+    ASSERT_EQ(mergeStats.outputVectors, expectedOuputBatches);
+  }
+
+  void testLocalMergeSpill(
+      int numInputSources,
+      int numInputBatches,
+      int inputBatchSize,
+      int maxBatchRows,
+      int maxBatchBytes,
+      int numMaxMergeSources,
+      bool hasSpillExecutor,
+      int expectedOuputBatches) {
+    std::vector<std::vector<RowVectorPtr>> inputVectors;
+    for (int32_t i = 0; i < numInputSources; ++i) {
+      std::vector<RowVectorPtr> vectors;
+      for (int32_t j = 0; j < numInputBatches; ++j) {
+        auto c0 = makeFlatVector<int64_t>(
+            inputBatchSize,
+            [&](auto row) { return inputBatchSize * j + row; },
+            nullEvery(5));
+        auto c1 = makeFlatVector<int64_t>(
+            inputBatchSize, [&](auto row) { return row; }, nullEvery(5));
+        auto c2 = makeFlatVector<double>(
+            inputBatchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+        auto c3 = makeFlatVector<StringView>(inputBatchSize, [](auto row) {
+          return StringView::makeInline(std::to_string(row));
+        });
+        vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+      }
+      inputVectors.push_back(std::move(vectors));
+    }
+    std::vector<RowVectorPtr> duckInputs;
+    for (const auto& input : inputVectors) {
+      for (const auto& vector : input) {
+        duckInputs.push_back(vector);
+      }
+    }
+    createDuckDbTable(duckInputs);
+    auto keyIndex = inputVectors[0][0]->type()->asRow().getChildIdx("c0");
+
+    const auto orderByClause = fmt::format("{}", "c0");
+    const auto planNodeIdGenerator =
+        std::make_shared<core::PlanNodeIdGenerator>();
+    const std::shared_ptr<TempDirectoryPath> spillDirectory =
+        TempDirectoryPath::create();
+    std::vector<std::shared_ptr<const core::PlanNode>> sources;
+    sources.reserve(inputVectors.size());
+    for (const auto& vectors : inputVectors) {
+      sources.push_back(PlanBuilder(planNodeIdGenerator)
+                            .values(vectors)
+                            .orderBy({orderByClause}, true)
+                            .planNode());
+    }
+    core::PlanNodeId nodeId;
+    const auto plan = PlanBuilder(planNodeIdGenerator)
+                          .localMerge({orderByClause}, std::move(sources))
+                          .capturePlanNodeId(nodeId)
+                          .planNode();
+    CursorParameters params;
+    params.planNode = plan;
+    params.maxDrivers = 2;
+    params.queryCtx = createQueryCtx(
+        {{"spill_enabled", "true"},
+         {"local_merge_spill_enabled", "true"},
+         {"local_merge_max_num_merge_sources",
+          std::to_string(numMaxMergeSources)},
+         {"preferred_output_batch_bytes", std::to_string(maxBatchBytes)},
+         {"preferred_output_batch_rows", std::to_string(maxBatchRows)}},
+        hasSpillExecutor);
+    params.spillDirectory = spillDirectory->getPath();
+    auto task = assertQueryOrdered(
+        params, "SELECT * FROM tmp ORDER BY " + orderByClause, {keyIndex});
+
+    auto taskStats = toPlanStats(task->taskStats());
+    auto& planStats = taskStats.at(nodeId);
+    if (inputBatchSize == 0 || numMaxMergeSources >= numInputSources ||
+        !hasSpillExecutor) {
+      ASSERT_EQ(planStats.spilledBytes, 0);
+      ASSERT_EQ(planStats.spilledPartitions, 0);
+      ASSERT_EQ(planStats.spilledFiles, 0);
+      ASSERT_EQ(planStats.spilledRows, 0);
+      ASSERT_EQ(
+          planStats.customStats.count(Merge::kSpilledSourceReadWallNanos), 0);
+      ASSERT_GE(
+          planStats.customStats.count(Merge::kStreamingSourceReadWallNanos), 0);
+    } else {
+      const auto expectedFiles =
+          (inputVectors.size() + numMaxMergeSources - 1) / numMaxMergeSources;
+      const auto expectedSpillRows = inputBatchSize * duckInputs.size();
+      ASSERT_GT(planStats.spilledBytes, 0);
+      ASSERT_EQ(planStats.spilledPartitions, expectedFiles);
+      ASSERT_EQ(planStats.spilledFiles, expectedFiles);
+      ASSERT_EQ(planStats.spilledRows, expectedSpillRows);
+      ASSERT_GE(
+          planStats.customStats.count(Merge::kSpilledSourceReadWallNanos), 0);
+      ASSERT_GE(
+          planStats.customStats.count(Merge::kStreamingSourceReadWallNanos), 0);
+    }
+    ASSERT_EQ(
+        planStats.outputRows,
+        numInputSources * numInputBatches * inputBatchSize);
+    ASSERT_EQ(planStats.outputVectors, expectedOuputBatches);
+  }
+
+  std::shared_ptr<core::QueryCtx> createQueryCtx(
+      std::unordered_map<std::string, std::string> queryConfigs = {},
+      bool hasSpillExecutor = true) const {
+    return core::QueryCtx::create(
+        executor_.get(),
+        core::QueryConfig{std::move(queryConfigs)},
+        {},
+        nullptr,
+        nullptr,
+        hasSpillExecutor ? spillExecutor_.get() : nullptr);
+  }
 };
 
-TEST_F(MergeTest, localMerge) {
-  vector_size_t batchSize = 1000;
+TEST_F(MergeTest, localMergeSpillBasic) {
   std::vector<RowVectorPtr> vectors;
-  for (int32_t i = 0; i < 3; ++i) {
+  for (int32_t i = 0; i < 9; ++i) {
+    constexpr vector_size_t batchSize = 137;
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return batchSize * i + row; }, nullEvery(5));
+    auto c1 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return row; }, nullEvery(5));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+    auto c3 = makeFlatVector<StringView>(batchSize, [](auto row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+  }
+  createDuckDbTable(vectors);
+
+  testSingleKeyWithSpill(vectors, "c0");
+  testSingleKeyWithSpill(vectors, "c3");
+
+  testTwoKeysWithSpill(vectors, "c0", "c3");
+  testTwoKeysWithSpill(vectors, "c3", "c0");
+}
+
+TEST_F(MergeTest, localMergeSpill) {
+  struct TestParam {
+    int numInputSources;
+    int numInputBatches;
+    int inputBatchSize;
+    int maxNumMergeSources;
+    int maxOutputBatchRows;
+    int maxOutputBatchBytes;
+    int numExpectedOutputBatches;
+    bool hasSpillExecutor;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numInputSources {}, numInputBatches {}, inputBatchSize {}, maxNumMergeSources {}, maxOutputBatchRows {}, maxOutputBatchBytes {}, numExpectedOutputBatches {}, hasSpillExecutor {}",
+          numInputSources,
+          numInputBatches,
+          inputBatchSize,
+          maxNumMergeSources,
+          maxOutputBatchRows,
+          maxOutputBatchBytes,
+          numExpectedOutputBatches,
+          hasSpillExecutor);
+    }
+  } testSettings[]{
+      {1, 1, 1, 1, 1, std::numeric_limits<int>::max(), 1, true},
+      {1, 1, 1, 1, 1, std::numeric_limits<int>::max(), 1, false},
+      {1, 4, 1, 1, 1, std::numeric_limits<int>::max(), 4, true},
+      {1, 4, 1, 1, 1, std::numeric_limits<int>::max(), 4, false},
+      {1, 4, 32, 1, 1, std::numeric_limits<int>::max(), 4 * 32, true},
+      {1, 4, 32, 1, 1, std::numeric_limits<int>::max(), 4 * 32, false},
+      {3, 4, 32, 1, 1, std::numeric_limits<int>::max(), 3 * 4 * 32, true},
+      {3, 4, 32, 1, 1, std::numeric_limits<int>::max(), 3 * 4 * 32, false},
+      {3, 4, 32, 2, 1, std::numeric_limits<int>::max(), 3 * 4 * 32, true},
+      {3, 4, 32, 2, 1, std::numeric_limits<int>::max(), 3 * 4 * 32, false},
+      {3, 4, 32, 3, 1, std::numeric_limits<int>::max(), 3 * 4 * 32, true},
+      {3, 4, 32, 3, 1, std::numeric_limits<int>::max(), 3 * 4 * 32, false},
+      {3, 4, 32, 4, 1, std::numeric_limits<int>::max(), 3 * 4 * 32, true},
+      {3, 4, 32, 4, 1, std::numeric_limits<int>::max(), 3 * 4 * 32, false},
+      {1, 1, 1, 1, 1024, std::numeric_limits<int>::max(), 1, true},
+      {1, 1, 1, 1, 1024, std::numeric_limits<int>::max(), 1, false},
+      {1, 4, 1, 1, 1024, std::numeric_limits<int>::max(), 1, true},
+      {1, 4, 1, 1, 1024, std::numeric_limits<int>::max(), 1, false},
+      {1, 4, 32, 1, 1024, std::numeric_limits<int>::max(), 1, true},
+      {1, 4, 32, 1, 1024, std::numeric_limits<int>::max(), 1, false},
+      {3, 4, 32, 1, 1024, std::numeric_limits<int>::max(), 1, true},
+      {3, 4, 32, 1, 1024, std::numeric_limits<int>::max(), 1, false},
+      {3, 4, 32, 2, 1024, std::numeric_limits<int>::max(), 1, true},
+      {3, 4, 32, 2, 1024, std::numeric_limits<int>::max(), 1, false},
+      {3, 4, 32, 3, 1024, std::numeric_limits<int>::max(), 1, true},
+      {3, 4, 32, 3, 1024, std::numeric_limits<int>::max(), 1, false},
+      {3, 4, 32, 4, 1024, std::numeric_limits<int>::max(), 1, true},
+      {3, 4, 32, 4, 1024, std::numeric_limits<int>::max(), 1, false},
+      {1, 1, 1, 1, 1024, 1, 1, true},
+      {1, 1, 1, 1, 1024, 1, 1, false},
+      {1, 4, 1, 1, 1024, 1, 4, true},
+      {1, 4, 1, 1, 1024, 1, 4, false},
+      {1, 4, 32, 1, 1024, 1, 4 * 32, true},
+      {1, 4, 32, 1, 1024, 1, 4 * 32, false},
+      {3, 4, 32, 1, 1024, 1, 3 * 4 * 32, true},
+      {3, 4, 32, 1, 1024, 1, 3 * 4 * 32, false},
+      {3, 4, 32, 2, 1024, 1, 3 * 4 * 32, true},
+      {3, 4, 32, 2, 1024, 1, 3 * 4 * 32, false},
+      {3, 4, 32, 3, 1024, 1, 3 * 4 * 32, true},
+      {3, 4, 32, 3, 1024, 1, 3 * 4 * 32, false},
+      {3, 4, 32, 4, 1024, 1, 3 * 4 * 32, true},
+      {3, 4, 32, 4, 1024, 1, 3 * 4 * 32, false}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    testLocalMergeSpill(
+        testData.numInputSources,
+        testData.numInputBatches,
+        testData.inputBatchSize,
+        testData.maxOutputBatchRows,
+        testData.maxOutputBatchBytes,
+        testData.maxNumMergeSources,
+        testData.hasSpillExecutor,
+        testData.numExpectedOutputBatches);
+  }
+}
+
+TEST_F(MergeTest, localMergeSpillPartialEmpty) {
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 9; ++i) {
+    auto batchSize = 30;
+    if (i % 2 == 0) {
+      batchSize = 0;
+    }
+
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return batchSize * i + row; }, nullEvery(5));
+    auto c1 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return row; }, nullEvery(5));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+    auto c3 = makeFlatVector<StringView>(batchSize, [](auto row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+  }
+  createDuckDbTable(vectors);
+  auto keyIndex = vectors[0]->type()->asRow().getChildIdx("c0");
+
+  const auto orderByClause = fmt::format("{}", "c0");
+  const auto planNodeIdGenerator =
+      std::make_shared<core::PlanNodeIdGenerator>();
+  const std::shared_ptr<TempDirectoryPath> spillDirectory =
+      TempDirectoryPath::create();
+  std::vector<std::shared_ptr<const core::PlanNode>> sources;
+  sources.reserve(vectors.size());
+  for (const auto& vector : vectors) {
+    sources.push_back(PlanBuilder(planNodeIdGenerator)
+                          .values({vector})
+                          .orderBy({orderByClause}, true)
+                          .planNode());
+  }
+  core::PlanNodeId nodeId;
+  const auto plan = PlanBuilder(planNodeIdGenerator)
+                        .localMerge({orderByClause}, std::move(sources))
+                        .capturePlanNodeId(nodeId)
+                        .planNode();
+  CursorParameters params;
+  params.planNode = plan;
+  params.maxDrivers = 2;
+  params.queryCtx = createQueryCtx(
+      {{"spill_enabled", "true"},
+       {"local_merge_spill_enabled", "true"},
+       {"local_merge_max_num_merge_sources", "2"}});
+  params.spillDirectory = spillDirectory->getPath();
+  auto task = assertQueryOrdered(
+      params, "SELECT * FROM tmp ORDER BY " + orderByClause, {keyIndex});
+
+  auto taskStats = toPlanStats(task->taskStats());
+  auto& planStats = taskStats.at(nodeId);
+  ASSERT_GT(planStats.spilledBytes, 0);
+  ASSERT_EQ(planStats.spilledPartitions, 4);
+  ASSERT_EQ(planStats.spilledFiles, 4);
+  ASSERT_EQ(planStats.spilledRows, 120);
+}
+
+DEBUG_ONLY_TEST_F(MergeTest, localMergeSpillWithException) {
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 9; ++i) {
+    constexpr vector_size_t batchSize = 137;
     auto c0 = makeFlatVector<int64_t>(
         batchSize, [&](auto row) { return batchSize * i + row; }, nullEvery(5));
     auto c1 = makeFlatVector<int64_t>(
@@ -150,6 +618,200 @@ TEST_F(MergeTest, localMerge) {
   }
   createDuckDbTable(vectors);
 
+  for (auto i = 0; i < 11; ++i) {
+    std::atomic_int cnt{0};
+    const auto errorMessage = "ConcatFilesSpillBatchStream::nextBatch fail";
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::ConcatFilesSpillBatchStream::nextBatch",
+        std::function<void(void*)>([&](void* /*unused*/) {
+          if (cnt++ == i) {
+            VELOX_FAIL("ConcatFilesSpillBatchStream::nextBatch fail");
+          }
+        }));
+
+    VELOX_ASSERT_THROW(testSingleKeyWithSpill(vectors, "c0"), errorMessage);
+  }
+}
+
+DEBUG_ONLY_TEST_F(MergeTest, localMergeSmallBatch) {
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 9; ++i) {
+    auto batchSize = 30;
+    if (i != 0) {
+      batchSize = 0;
+    }
+
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return batchSize * i + row; }, nullEvery(5));
+    auto c1 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return row; }, nullEvery(5));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+    auto c3 = makeFlatVector<StringView>(batchSize, [](auto row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+  }
+  createDuckDbTable(vectors);
+  auto keyIndex = vectors[0]->type()->asRow().getChildIdx("c0");
+
+  const auto orderByClause = fmt::format("{}", "c0");
+  const auto planNodeIdGenerator =
+      std::make_shared<core::PlanNodeIdGenerator>();
+  const std::shared_ptr<TempDirectoryPath> spillDirectory =
+      TempDirectoryPath::create();
+  std::vector<std::shared_ptr<const core::PlanNode>> sources;
+  sources.reserve(vectors.size());
+  for (const auto& vector : vectors) {
+    sources.push_back(PlanBuilder(planNodeIdGenerator)
+                          .values({vector})
+                          .orderBy({orderByClause}, true)
+                          .planNode());
+  }
+  core::PlanNodeId nodeId;
+  const auto plan = PlanBuilder(planNodeIdGenerator)
+                        .localMerge({orderByClause}, std::move(sources))
+                        .capturePlanNodeId(nodeId)
+                        .planNode();
+
+  std::atomic_bool blockFlag{true};
+  folly::Promise<folly::Unit> promise;
+  folly::EventCount callWait;
+  std::atomic_bool callWaitFlag{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::SourceMerger::getOutput",
+      std::function<void(std::vector<ContinueFuture>*)>(
+          [&](std::vector<ContinueFuture>* sourceBlockingFutures) {
+            if (blockFlag) {
+              blockFlag = false;
+              auto [p, f] = folly::makePromiseContract<folly::Unit>();
+              sourceBlockingFutures->push_back(std::move(f));
+              promise = std::move(p);
+              callWaitFlag = false;
+              callWait.notifyAll();
+            }
+          }));
+
+  std::thread promiseThread([&]() {
+    callWait.await([&]() { return !callWaitFlag.load(); });
+    std::this_thread::sleep_for(std::chrono::milliseconds(1'000)); // NOLINT
+    promise.setValue();
+  });
+
+  CursorParameters params;
+  params.planNode = plan;
+  auto task = assertQueryOrdered(
+      params, "SELECT * FROM tmp ORDER BY " + orderByClause, {keyIndex});
+  auto taskStats = toPlanStats(task->taskStats());
+  ASSERT_EQ(taskStats[nodeId].outputRows, 30);
+  ASSERT_EQ(taskStats[nodeId].outputVectors, 1);
+  promiseThread.join();
+}
+
+DEBUG_ONLY_TEST_F(MergeTest, localMergeAbort) {
+  std::vector<std::vector<RowVectorPtr>> inputVectors;
+  for (int32_t i = 0; i < 4; ++i) {
+    std::vector<RowVectorPtr> vectors;
+    for (int32_t j = 0; j < 13; ++j) {
+      constexpr auto batchSize = 5000;
+      auto c0 = makeFlatVector<int64_t>(
+          batchSize,
+          [&](auto row) { return batchSize * j + row; },
+          nullEvery(5));
+      auto c1 = makeFlatVector<int64_t>(
+          batchSize, [&](auto row) { return row; }, nullEvery(5));
+      auto c2 = makeFlatVector<double>(
+          batchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+      auto c3 = makeFlatVector<StringView>(batchSize, [](auto row) {
+        return StringView::makeInline(std::to_string(row));
+      });
+      vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+    }
+    inputVectors.push_back(std::move(vectors));
+  }
+
+  const auto orderByClause = fmt::format("{}", "c0");
+  const auto planNodeIdGenerator =
+      std::make_shared<core::PlanNodeIdGenerator>();
+  const std::shared_ptr<TempDirectoryPath> spillDirectory =
+      TempDirectoryPath::create();
+  std::vector<std::shared_ptr<const core::PlanNode>> sources;
+  sources.reserve(inputVectors.size());
+  for (const auto& vectors : inputVectors) {
+    sources.push_back(PlanBuilder(planNodeIdGenerator)
+                          .values(vectors)
+                          .orderBy({orderByClause}, true)
+                          .planNode());
+  }
+  core::PlanNodeId nodeId;
+  const auto plan = PlanBuilder(planNodeIdGenerator)
+                        .localMerge({orderByClause}, std::move(sources))
+                        .capturePlanNodeId(nodeId)
+                        .planNode();
+  std::atomic_int cnt{0};
+  std::atomic_bool blocked{false};
+  folly::EventCount callWait;
+  std::atomic_bool callWaitFlag{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::SpillMerger::getOutput",
+      std::function<void(std::vector<ContinueFuture>*)>(
+          [&](std::vector<ContinueFuture>* /*unused*/) {
+            if (blocked) {
+              std::this_thread::sleep_for(
+                  std::chrono::milliseconds(1'000)); // NOLINT
+              blocked = false;
+              callWaitFlag = false;
+              callWait.notifyAll();
+              VELOX_USER_FAIL("Abort merge");
+            }
+          }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::SpillMerger::readFromSpillFileStream",
+      std::function<void(void*)>([&](void* /*unused*/) {
+        if (cnt++ == 2) {
+          blocked = true;
+          callWait.await([&]() { return callWaitFlag.load(); });
+          std::this_thread::sleep_for(
+              std::chrono::milliseconds(1'000)); // NOLINT
+        }
+      }));
+
+  auto queryCtx = createQueryCtx();
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan)
+          .spillDirectory(spillDirectory->getPath())
+          .queryCtx(queryCtx)
+          .config(core::QueryConfig::kSpillEnabled, true)
+          .config(core::QueryConfig::kLocalMergeSpillEnabled, true)
+          .config(core::QueryConfig::kLocalMergeMaxNumMergeSources, 2)
+          .config(core::QueryConfig::kMaxOutputBatchRows, 10)
+          .config(core::QueryConfig::kPreferredOutputBatchRows, 10)
+          .copyResults(pool()),
+      "Abort merge");
+  std::dynamic_pointer_cast<folly::CPUThreadPoolExecutor>(spillExecutor_)
+      ->join();
+}
+
+TEST_F(MergeTest, localMerge) {
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 3; ++i) {
+    static constexpr vector_size_t kBatchSize = 100;
+    auto c0 = makeFlatVector<int64_t>(
+        kBatchSize,
+        [&](auto row) { return kBatchSize * i + row; },
+        nullEvery(5));
+    auto c1 = makeFlatVector<int64_t>(
+        kBatchSize, [&](auto row) { return row; }, nullEvery(5));
+    auto c2 = makeFlatVector<double>(
+        kBatchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+    auto c3 = makeFlatVector<StringView>(kBatchSize, [](auto row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2, c3}));
+  }
+  createDuckDbTable(vectors);
+
   testSingleKey(vectors, "c0");
   testSingleKey(vectors, "c3");
 
@@ -238,3 +900,50 @@ TEST_F(MergeTest, offByOne) {
       {{core::QueryConfig::kPreferredOutputBatchRows, "6"}});
   assertQueryOrdered(params, "VALUES (0), (1), (2), (3), (4), (5), (10)", {0});
 }
+
+TEST_F(MergeTest, localMergeOutputSizeWithoutSpill) {
+  struct TestParam {
+    int numSources;
+    int numInputBatches;
+    int inputBatchSize;
+    int maxOutputBatchRows;
+    int maxOutputBatchBytes;
+    int numExpectedOutputBatches;
+
+    std::string debugString() const {
+      return fmt::format(
+          "numSources {}, numInputBatches {}, inputBatchSize {}, maxOutputBatchRows {}, maxOutputBatchBytes {}, numExpectedOutputBatches {}",
+          numSources,
+          numInputBatches,
+          inputBatchSize,
+          maxOutputBatchRows,
+          maxOutputBatchBytes,
+          numExpectedOutputBatches);
+    }
+  } testSettings[]{
+      {1, 1, 1, 1, 1'000'000'000, 1},
+      {3, 1, 1, 1, 1'000'000'000, 3},
+      {3, 4, 1, 1, 1'000'000'000, 3 * 4},
+      {3, 4, 32, 1, 1'000'000'000, 3 * 4 * 32},
+      {1, 1, 1, 1024, 1'000'000'000, 1},
+      {3, 1, 1, 1024, 1'000'000'000, 1},
+      {3, 4, 32, 1024, 1'000'000'000, 1},
+      {1, 1, 1, 1, 1, 1},
+      {3, 1, 1, 1, 1, 3},
+      {3, 4, 1, 1, 1, 3 * 4},
+      {3, 4, 32, 1, 1, 3 * 4 * 32},
+      {1, 1, 1, 1024, 1, 1},
+      {3, 1, 1, 1024, 1, 3},
+      {3, 4, 1, 1024, 1, 3 * 4},
+      {3, 4, 32, 1024, 1, 3 * 4 * 32}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    testLocalMerge(
+        testData.numSources,
+        testData.numInputBatches,
+        testData.inputBatchSize,
+        testData.maxOutputBatchRows,
+        testData.maxOutputBatchBytes,
+        testData.numExpectedOutputBatches);
+  }
+}
diff --git a/velox/exec/tests/MergerTest.cpp b/velox/exec/tests/MergerTest.cpp
new file mode 100644
index 000000000000..1d848bd115ae
--- /dev/null
+++ b/velox/exec/tests/MergerTest.cpp
@@ -0,0 +1,461 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/system/HardwareConcurrency.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/Merge.h"
+#include "velox/exec/MergeSource.h"
+#include "velox/exec/SortBuffer.h"
+#include "velox/exec/Spill.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/type/Type.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox;
+using namespace facebook::velox::memory;
+
+namespace facebook::velox::exec::test {
+
+class MergerTest : public OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    filesystems::registerLocalFileSystem();
+  }
+
+  std::vector<RowVectorPtr> generateSortedVectors(
+      const int32_t numVectors,
+      const size_t vectorSize) {
+    const VectorFuzzer::Options fuzzerOpts{.vectorSize = vectorSize};
+    const auto vectors = createVectors(numVectors, inputType_, fuzzerOpts);
+    const auto sortBuffer = std::make_unique<SortBuffer>(
+        inputType_,
+        sortColumnIndices_,
+        sortCompareFlags_,
+        pool_.get(),
+        &nonReclaimableSection_,
+        common::PrefixSortConfig{},
+        nullptr,
+        nullptr);
+    for (const auto& vector : vectors) {
+      sortBuffer->addInput(vector);
+    }
+    sortBuffer->noMoreInput();
+    std::vector<RowVectorPtr> sortedVectors;
+    sortedVectors.reserve(numVectors);
+    for (auto i = 0; i < numVectors; ++i) {
+      sortedVectors.emplace_back(sortBuffer->getOutput(vectorSize));
+    }
+    return sortedVectors;
+  }
+
+  SpillFiles generateSortedSpillFiles(
+      const std::vector<RowVectorPtr>& sortedVectors) {
+    const auto spiller = std::make_unique<MergeSpiller>(
+        inputType_,
+        std::nullopt,
+        HashBitRange{},
+        sortingKeys_,
+        &spillConfig_,
+        spillStats_.get());
+    for (const auto& vector : sortedVectors) {
+      spiller->spill(SpillPartitionId(0), vector);
+    }
+    SpillPartitionSet spillPartitionSet;
+    spiller->finishSpill(spillPartitionSet);
+    EXPECT_EQ(spillPartitionSet.size(), 1);
+    return spillPartitionSet.cbegin()->second->files();
+  }
+
+  std::pair<
+      std::vector<std::vector<RowVectorPtr>>,
+      std::vector<std::vector<std::unique_ptr<SpillReadFile>>>>
+  generateInputs(size_t numStreams, size_t vectorSize) {
+    std::vector<std::vector<RowVectorPtr>> totalVectors;
+    std::vector<std::vector<std::unique_ptr<SpillReadFile>>>
+        spillReadFilesGroups;
+    for (auto i = 1; i <= numStreams; ++i) {
+      const auto vectors = generateSortedVectors(i * 3 + 1, vectorSize);
+      totalVectors.push_back(vectors);
+      const auto spillFiles = generateSortedSpillFiles(vectors);
+      EXPECT_EQ(spillFiles.size(), vectors.size());
+      std::vector<std::unique_ptr<SpillReadFile>> spillReadFiles;
+      spillReadFiles.reserve(spillFiles.size());
+      for (const auto& spillFile : spillFiles) {
+        spillReadFiles.emplace_back(
+            SpillReadFile::create(
+                spillFile,
+                spillConfig_.readBufferSize,
+                pool_.get(),
+                spillStats_.get()));
+      }
+      spillReadFilesGroups.emplace_back(std::move(spillReadFiles));
+    }
+    return std::make_pair(
+        std::move(totalVectors), std::move(spillReadFilesGroups));
+  }
+
+  std::vector<RowVectorPtr> makeExpectedResults(
+      const std::vector<std::vector<RowVectorPtr>>& inputs,
+      size_t vectorSize) {
+    std::vector<RowVectorPtr> flatInputs;
+    for (const auto& vectors : inputs) {
+      for (const auto& vector : vectors) {
+        flatInputs.emplace_back(vector);
+      }
+    }
+    const auto sortBuffer = std::make_unique<SortBuffer>(
+        inputType_,
+        sortColumnIndices_,
+        sortCompareFlags_,
+        pool_.get(),
+        &nonReclaimableSection_,
+        common::PrefixSortConfig{},
+        nullptr,
+        nullptr);
+    for (const auto& vector : flatInputs) {
+      sortBuffer->addInput(vector);
+    }
+    sortBuffer->noMoreInput();
+    std::vector<RowVectorPtr> sortedVectors;
+    sortedVectors.reserve(flatInputs.size());
+    for (auto i = 0; i < flatInputs.size(); ++i) {
+      sortedVectors.emplace_back(sortBuffer->getOutput(vectorSize));
+    }
+    return sortedVectors;
+  }
+
+  std::unique_ptr<SourceMerger> createSourceMerger(
+      const std::vector<std::shared_ptr<MergeSource>>& sources,
+      uint64_t outputBatchRows,
+      uint64_t outputBatchBytes) const {
+    std::vector<std::unique_ptr<SourceStream>> sourceStreams;
+    for (const auto& source : sources) {
+      sourceStreams.push_back(
+          std::make_unique<SourceStream>(
+              source.get(), sortingKeys_, outputBatchRows));
+    }
+    return std::make_unique<SourceMerger>(
+        inputType_,
+        std::move(sourceStreams),
+        outputBatchRows,
+        outputBatchBytes,
+        pool());
+  }
+
+  static std::vector<std::shared_ptr<MergeSource>> createMergeSources(
+      size_t numSources,
+      size_t queueSize) {
+    std::vector<std::shared_ptr<MergeSource>> sources;
+    sources.reserve(numSources);
+    for (auto i = 0; i < numSources; ++i) {
+      sources.push_back(MergeSource::createLocalMergeSource(queueSize));
+    }
+    for (const auto& source : sources) {
+      source->start();
+    }
+    return sources;
+  }
+
+  void produceAsync(
+      MergeSource* mergeSource,
+      const std::vector<RowVectorPtr>& vectors,
+      size_t index = 0) const {
+    ContinueFuture future;
+    if (index >= vectors.size()) {
+      const auto reason = mergeSource->enqueue(nullptr, &future);
+      EXPECT_EQ(reason, BlockingReason::kNotBlocked);
+      return;
+    }
+
+    mergeSource->enqueue(vectors[index], &future);
+    std::move(future)
+        .via(executor_.get())
+        .thenValue([this, mergeSource, &vectors, index](folly::Unit) {
+          produceAsync(mergeSource, vectors, index + 1);
+        })
+        .thenError(folly::tag_t<std::exception>{}, [](const std::exception& e) {
+          VELOX_FAIL(e.what());
+        });
+  }
+
+  void createProducers(
+      int num,
+      const std::vector<std::vector<RowVectorPtr>>& inputs,
+      const std::vector<std::shared_ptr<MergeSource>>& sources) const {
+    for (auto i = 0; i < inputs.size(); ++i) {
+      executor_->add([&, i]() { produceAsync(sources[i].get(), inputs[i]); });
+    }
+  }
+
+  static std::vector<RowVectorPtr> getOutputFromSourceMerger(
+      SourceMerger* sourceMerger) {
+    std::vector<ContinueFuture> sourceBlockingFutures;
+    std::vector<RowVectorPtr> results;
+    for (;;) {
+      sourceMerger->isBlocked(sourceBlockingFutures);
+      if (!sourceBlockingFutures.empty()) {
+        auto future = std::move(sourceBlockingFutures.back());
+        sourceBlockingFutures.pop_back();
+        future.wait();
+        continue;
+      }
+      bool atEnd = false;
+      auto output = sourceMerger->getOutput(sourceBlockingFutures, atEnd);
+      if (output != nullptr) {
+        results.emplace_back(std::move(output));
+      }
+
+      if (atEnd) {
+        break;
+      }
+    }
+    return results;
+  }
+
+  std::shared_ptr<SpillMerger> createSpillMerger(
+      std::vector<std::vector<std::unique_ptr<SpillReadFile>>>
+          spillReadFilesGroups,
+      vector_size_t outputBatchRows,
+      int queueSize) const {
+    return std::make_shared<SpillMerger>(
+        sortingKeys_,
+        inputType_,
+        std::move(spillReadFilesGroups),
+        outputBatchRows,
+        std::numeric_limits<int64_t>::max(),
+        queueSize,
+        &spillConfig_,
+        spillStats_,
+        pool());
+  }
+
+  static std::vector<RowVectorPtr> getOutputFromSpillMerger(
+      SpillMerger* spillMerger) {
+    std::vector<ContinueFuture> sourceBlockingFutures;
+    std::vector<RowVectorPtr> results;
+    for (;;) {
+      bool atEnd = false;
+      auto output = spillMerger->getOutput(sourceBlockingFutures, atEnd);
+      if (output != nullptr) {
+        results.emplace_back(std::move(output));
+      }
+
+      if (atEnd) {
+        break;
+      }
+
+      while (!sourceBlockingFutures.empty()) {
+        auto future = std::move(sourceBlockingFutures.back());
+        sourceBlockingFutures.pop_back();
+        future.wait();
+      }
+    }
+    return results;
+  }
+
+  static void checkResults(
+      std::vector<RowVectorPtr> expectedResults,
+      std::vector<RowVectorPtr> actualResults) {
+    ASSERT_TRUE(assertEqualResults(expectedResults, actualResults));
+    const auto& actual = actualResults[0];
+    std::for_each(
+        std::next(actualResults.begin()),
+        actualResults.end(),
+        [&](const auto& ele) { actual->append(ele.get()); });
+    const auto& expect = expectedResults[0];
+    std::for_each(
+        std::next(expectedResults.begin()),
+        expectedResults.end(),
+        [&](const auto& ele) { expect->append(ele.get()); });
+    facebook::velox::test::assertEqualVectors(expect, actual);
+  }
+
+ private:
+  const RowTypePtr inputType_ = ROW({{"c0", BIGINT()}, {"c1", SMALLINT()}});
+  const std::shared_ptr<folly::Executor> executor_{
+      std::make_shared<folly::CPUThreadPoolExecutor>(
+          folly::hardware_concurrency())};
+  const std::vector<column_index_t> sortColumnIndices_{0, 1};
+  const std::vector<CompareFlags> sortCompareFlags_{
+      CompareFlags{.ascending = true},
+      CompareFlags{.ascending = false}};
+  const std::vector<SpillSortKey> sortingKeys_ =
+      SpillState::makeSortingKeys(sortColumnIndices_, sortCompareFlags_);
+  const std::shared_ptr<TempDirectoryPath> spillDirectory_ =
+      exec::test::TempDirectoryPath::create();
+  const common::SpillConfig spillConfig_{
+      [&]() -> const std::string& { return spillDirectory_->getPath(); },
+      [&](uint64_t) {},
+      "0.0.0",
+      10, // Force to create a file per spill to mock multiple files per stream
+      0,
+      1 << 20,
+      executor_.get(),
+      100,
+      100,
+      0,
+      0,
+      0,
+      0,
+      0,
+      "none",
+      0,
+      std::nullopt};
+
+  std::shared_ptr<folly::Synchronized<common::SpillStats>> spillStats_ =
+      std::make_shared<folly::Synchronized<common::SpillStats>>();
+  tsan_atomic<bool> nonReclaimableSection_{false};
+};
+} // namespace facebook::velox::exec::test
+
+TEST_F(MergerTest, sourceMerger) {
+  struct TestSetting {
+    size_t maxOutputRows;
+    size_t maxOutputBytes;
+    size_t numSources;
+    size_t queueSize;
+
+    std::string debugString() const {
+      return fmt::format(
+          "maxOutputRows:{}, maxOutputBytes:{}, numStreams:{}, queueSize:{}",
+          maxOutputRows,
+          succinctBytes(maxOutputBytes),
+          numSources,
+          queueSize);
+    }
+  };
+  std::vector<TestSetting> testSettings;
+  for (size_t maxOutputRows : {1, 7, 16}) {
+    for (size_t numSources : {1, 3, 8}) {
+      for (size_t queueSize : {1, 2}) {
+        testSettings.push_back(
+            {maxOutputRows, 1'000'000'000, numSources, queueSize});
+      }
+    }
+  }
+  testSettings.push_back({32, 1'000'000'000, 3, 2});
+  testSettings.push_back({1024, 1'000'000'000, 8, 2});
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    std::vector<std::vector<RowVectorPtr>> inputs;
+    for (auto i = 1; i <= testData.numSources; ++i) {
+      inputs.emplace_back(generateSortedVectors(i, 16));
+    }
+    const auto sources =
+        createMergeSources(testData.numSources, testData.queueSize);
+    const auto sourceMerger = createSourceMerger(
+        sources, testData.maxOutputRows, testData.maxOutputBytes);
+    createProducers(testData.numSources, inputs, sources);
+    const auto results = getOutputFromSourceMerger(sourceMerger.get());
+    const auto expectedResults = makeExpectedResults(inputs, 16);
+    checkResults(expectedResults, results);
+  }
+}
+
+TEST_F(MergerTest, sourceMergerWithEmptySources) {
+  std::vector<std::vector<RowVectorPtr>> inputs;
+  for (auto i = 0; i < 10; ++i) {
+    const auto numVectors = (i % 2 == 0) ? 0 : i;
+    inputs.emplace_back(generateSortedVectors(numVectors, 16));
+  }
+  const auto sources = createMergeSources(10, 2);
+  const auto sourceMerger = createSourceMerger(sources, 32, 1000'000'000);
+  createProducers(10, inputs, sources);
+  const auto results = getOutputFromSourceMerger(sourceMerger.get());
+  const auto expectedResults = makeExpectedResults(inputs, 16);
+  checkResults(expectedResults, results);
+}
+
+TEST_F(MergerTest, spillMerger) {
+  struct TestSetting {
+    size_t maxOutputRows;
+    size_t numSources;
+    size_t queueSize;
+
+    std::string debugString() const {
+      return fmt::format(
+          "maxOutputRows:{}, numStreams:{}, queueSize:{}",
+          maxOutputRows,
+          numSources,
+          queueSize);
+    }
+  };
+  std::vector<TestSetting> testSettings;
+  for (size_t maxOutputRows : {1, 7, 16}) {
+    for (size_t numSources : {1, 3, 8}) {
+      for (size_t queueSize : {1, 2}) {
+        testSettings.push_back({maxOutputRows, numSources, queueSize});
+      }
+    }
+  }
+  testSettings.push_back({32, 3, 2});
+  testSettings.push_back({1024, 8, 2});
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    const auto sources =
+        createMergeSources(testData.numSources, testData.queueSize);
+    auto [inputs, filesGroup] = generateInputs(testData.numSources, 16);
+    ASSERT_EQ(filesGroup.size(), testData.numSources);
+    const auto spillMerger = createSpillMerger(
+        std::move(filesGroup), testData.maxOutputRows, testData.queueSize);
+    spillMerger->start();
+    const auto results = getOutputFromSpillMerger(spillMerger.get());
+    const auto expectedResults = makeExpectedResults(inputs, 16);
+    checkResults(expectedResults, results);
+  }
+}
+
+DEBUG_ONLY_TEST_F(MergerTest, spillMergerException) {
+  struct TestSetting {
+    size_t maxOutputRows;
+    size_t numSources;
+    size_t queueSize;
+
+    std::string debugString() const {
+      return fmt::format(
+          "maxOutputRows:{}, numStreams:{}, queueSize:{}",
+          maxOutputRows,
+          numSources,
+          queueSize);
+    }
+  };
+
+  std::atomic_int cnt{0};
+  const auto errorMessage = "ConcatFilesSpillBatchStream::nextBatch fail";
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::ConcatFilesSpillBatchStream::nextBatch",
+      std::function<void(void*)>([&](void* /*unused*/) {
+        if (cnt++ == 11) {
+          VELOX_FAIL("ConcatFilesSpillBatchStream::nextBatch fail");
+        }
+      }));
+  const auto numSources = 5;
+  const auto queueSize = 2;
+  const auto sources = createMergeSources(numSources, queueSize);
+  auto [inputs, filesGroup] = generateInputs(numSources, 16);
+  const auto spillMerger =
+      createSpillMerger(std::move(filesGroup), 100, queueSize);
+  spillMerger->start();
+  VELOX_ASSERT_THROW(getOutputFromSpillMerger(spillMerger.get()), errorMessage);
+}
diff --git a/velox/exec/tests/MultiFragmentTest.cpp b/velox/exec/tests/MultiFragmentTest.cpp
index 52c46c20180a..13c36172a9fb 100644
--- a/velox/exec/tests/MultiFragmentTest.cpp
+++ b/velox/exec/tests/MultiFragmentTest.cpp
@@ -16,6 +16,7 @@
 #include "folly/experimental/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Exchange.h"
@@ -23,11 +24,13 @@
 #include "velox/exec/PartitionedOutput.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/RoundRobinPartitionFunction.h"
+#include "velox/exec/TableScan.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/exec/tests/utils/SerializedPageUtil.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
 
 using namespace facebook::velox::exec::test;
 
@@ -101,13 +104,14 @@ class MultiFragmentTest : public HiveConnectorTestBase,
       int destination = 0,
       Consumer consumer = nullptr,
       int64_t maxMemory = memory::kMaxMemory,
-      folly::Executor* executor = nullptr) {
+      folly::Executor* executor = nullptr) const {
     auto configCopy = configSettings_;
     auto queryCtx = core::QueryCtx::create(
         executor ? executor : executor_.get(),
         core::QueryConfig(std::move(configCopy)));
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), maxMemory, MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), maxMemory, MemoryReclaimer::create()));
     core::PlanFragment planFragment{planNode};
     return Task::create(
         taskId,
@@ -118,6 +122,41 @@ class MultiFragmentTest : public HiveConnectorTestBase,
         std::move(consumer));
   }
 
+  std::shared_ptr<Task> makeTask(
+      const std::string& taskId,
+      const core::PlanNodePtr& planNode,
+      std::unordered_map<std::string, std::string>& extraQueryConfigs,
+      int destination = 0,
+      Consumer consumer = nullptr,
+      int64_t maxMemory = memory::kMaxMemory,
+      const std::optional<common::SpillDiskOptions>& diskSpillOpts =
+          std::nullopt) const {
+    auto configCopy = configSettings_;
+    for (const auto& [k, v] : extraQueryConfigs) {
+      configCopy[k] = v;
+    }
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(),
+        core::QueryConfig(std::move(configCopy)),
+        {},
+        nullptr,
+        nullptr,
+        executor_.get());
+    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),
+        /*memoryArbitrationPriority=*/0,
+        diskSpillOpts);
+  }
+
   std::vector<RowVectorPtr> makeVectors(int count, int rowsPerVector) {
     std::vector<RowVectorPtr> vectors;
     for (int i = 0; i < count; ++i) {
@@ -128,8 +167,8 @@ class MultiFragmentTest : public HiveConnectorTestBase,
     return vectors;
   }
 
-  void addHiveSplits(
-      std::shared_ptr<Task> task,
+  static void addHiveSplits(
+      const std::shared_ptr<Task>& task,
       const std::vector<std::shared_ptr<TempFilePath>>& filePaths) {
     for (auto& filePath : filePaths) {
       auto split = exec::Split(
@@ -144,11 +183,33 @@ class MultiFragmentTest : public HiveConnectorTestBase,
     task->noMoreSplits("0");
   }
 
-  exec::Split remoteSplit(const std::string& taskId) {
+  static void addHiveSplits(
+      const std::shared_ptr<Task>& task,
+      const std::unordered_map<
+          core::PlanNodeId,
+          std::vector<std::shared_ptr<TempFilePath>>>& nodeSplits) {
+    for (const auto& [scanNodeId, splitPaths] : nodeSplits) {
+      for (const auto& filePath : splitPaths) {
+        auto split = exec::Split(
+            std::make_shared<connector::hive::HiveConnectorSplit>(
+                kHiveConnectorId,
+                "file:" + filePath->getPath(),
+                facebook::velox::dwio::common::FileFormat::DWRF),
+            -1);
+        task->addSplit(scanNodeId, std::move(split));
+      }
+    }
+
+    for (const auto& [scanNodeId, _] : nodeSplits) {
+      task->noMoreSplits(scanNodeId);
+    }
+  }
+
+  static exec::Split remoteSplit(const std::string& taskId) {
     return exec::Split(std::make_shared<RemoteConnectorSplit>(taskId));
   }
 
-  void addRemoteSplits(
+  static void addRemoteSplits(
       std::shared_ptr<Task> task,
       const std::vector<std::string>& remoteTaskIds) {
     for (auto& taskId : remoteTaskIds) {
@@ -197,7 +258,7 @@ class MultiFragmentTest : public HiveConnectorTestBase,
         exchangeStats.at("localExchangeSource.numPages").count);
     ASSERT_EQ(
         expectedBackgroundCpuCount,
-        exchangeStats.at(ExchangeClient::kBackgroundCpuTimeMs).count);
+        exchangeStats.at(Operator::kBackgroundCpuTimeNanos).count);
     ASSERT_EQ(
         expectedBackgroundCpuCount, taskStats.at("0").backgroundTiming.count);
   }
@@ -525,42 +586,61 @@ TEST_P(MultiFragmentTest, abortMergeExchange) {
 
 TEST_P(MultiFragmentTest, mergeExchange) {
   setupSources(20, 1000);
-
   static const core::SortOrder kAscNullsLast(true, false);
   std::vector<std::shared_ptr<Task>> tasks;
-
   std::vector<std::shared_ptr<TempFilePath>> filePaths0(
       filePaths_.begin(), filePaths_.begin() + 10);
   std::vector<std::shared_ptr<TempFilePath>> filePaths1(
       filePaths_.begin() + 10, filePaths_.end());
-
   std::vector<std::vector<std::shared_ptr<TempFilePath>>> filePathsList = {
       filePaths0, filePaths1};
-
   std::vector<std::string> partialSortTaskIds;
   RowTypePtr outputType;
-
   core::PlanNodeId partitionNodeId;
-  for (int i = 0; i < 2; ++i) {
+  for (int numPartialSortTasks = 0; numPartialSortTasks < 2;
+       ++numPartialSortTasks) {
     auto sortTaskId = makeTaskId("orderby", tasks.size());
     partialSortTaskIds.push_back(sortTaskId);
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    std::vector<std::shared_ptr<const core::PlanNode>> sources;
+    sources.reserve(5);
+    std::vector<std::string> scanNodeIds;
+    scanNodeIds.reserve(5);
+    for (int numSourcesPerPartialSortTask = 0; numSourcesPerPartialSortTask < 5;
+         ++numSourcesPerPartialSortTask) {
+      core::PlanNodeId scanNodeId;
+      sources.push_back(PlanBuilder(planNodeIdGenerator)
+                            .tableScan(rowType_)
+                            .capturePlanNodeId(scanNodeId)
+                            .orderBy({"c0"}, true)
+                            .planNode());
+      scanNodeIds.push_back(scanNodeId);
+    }
+
     auto partialSortPlan =
         PlanBuilder(planNodeIdGenerator)
-            .localMerge(
-                {"c0"},
-                {PlanBuilder(planNodeIdGenerator)
-                     .tableScan(rowType_)
-                     .orderBy({"c0"}, true)
-                     .planNode()})
+            .localMerge({"c0"}, std::move(sources))
             .partitionedOutput({}, 1, /*outputLayout=*/{}, GetParam().serdeKind)
             .capturePlanNodeId(partitionNodeId)
             .planNode();
-
     auto sortTask = makeTask(sortTaskId, partialSortPlan, tasks.size());
     tasks.push_back(sortTask);
     sortTask->start(4);
-    addHiveSplits(sortTask, filePathsList[i]);
+
+    std::unordered_map<
+        core::PlanNodeId,
+        std::vector<std::shared_ptr<TempFilePath>>>
+        nodeSplits;
+    nodeSplits.reserve(5);
+    for (int i = 0; i < 5; ++i) {
+      nodeSplits[scanNodeIds[i]] = std::vector<std::shared_ptr<TempFilePath>>();
+    }
+    auto& filePaths = filePathsList[numPartialSortTasks];
+    for (int i = 0; i < filePaths.size(); ++i) {
+      nodeSplits[scanNodeIds[i % scanNodeIds.size()]].push_back(filePaths[i]);
+    }
+
+    addHiveSplits(sortTask, nodeSplits);
     outputType = partialSortPlan->outputType();
   }
 
@@ -795,6 +875,138 @@ TEST_P(MultiFragmentTest, partitionedOutput) {
   }
 }
 
+TEST_P(MultiFragmentTest, mergeExchangeWithSpill) {
+  setupSources(20, 1000);
+  static const core::SortOrder kAscNullsLast(true, false);
+  std::vector<std::shared_ptr<Task>> tasks;
+  std::vector<std::shared_ptr<TempFilePath>> filePaths0(
+      filePaths_.begin(), filePaths_.begin() + 10);
+  std::vector<std::shared_ptr<TempFilePath>> filePaths1(
+      filePaths_.begin() + 10, filePaths_.end());
+  std::vector<std::vector<std::shared_ptr<TempFilePath>>> filePathsList = {
+      filePaths0, filePaths1};
+  std::vector<std::string> partialSortTaskIds;
+  RowTypePtr outputType;
+  std::vector<std::shared_ptr<TempDirectoryPath>> spillDirectories;
+  core::PlanNodeId partitionNodeId;
+  std::unordered_map<std::string, std::string> spillMergeConfigs{
+      {"spill_enabled", "true"},
+      {"local_merge_spill_enabled", "true"},
+      {"local_merge_max_num_merge_sources", "3"}};
+  std::vector<core::PlanNodeId> localMergeNodeIds;
+  for (int numPartialSortTasks = 0; numPartialSortTasks < 2;
+       ++numPartialSortTasks) {
+    auto sortTaskId = makeTaskId("orderby", tasks.size());
+    partialSortTaskIds.push_back(sortTaskId);
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    std::vector<std::shared_ptr<const core::PlanNode>> sources;
+    sources.reserve(5);
+    std::vector<std::string> scanNodeIds;
+    scanNodeIds.reserve(5);
+    for (int numSourcesPerPartialSortTask = 0; numSourcesPerPartialSortTask < 5;
+         ++numSourcesPerPartialSortTask) {
+      core::PlanNodeId scanNodeId;
+      sources.push_back(PlanBuilder(planNodeIdGenerator)
+                            .tableScan(rowType_)
+                            .capturePlanNodeId(scanNodeId)
+                            .orderBy({"c0"}, true)
+                            .planNode());
+      scanNodeIds.push_back(scanNodeId);
+    }
+
+    core::PlanNodeId localMergeNodeId;
+    auto partialSortPlan =
+        PlanBuilder(planNodeIdGenerator)
+            .localMerge({"c0"}, std::move(sources))
+            .capturePlanNodeId(localMergeNodeId)
+            .partitionedOutput({}, 1, /*outputLayout=*/{}, GetParam().serdeKind)
+            .capturePlanNodeId(partitionNodeId)
+            .planNode();
+    localMergeNodeIds.push_back(localMergeNodeId);
+    spillDirectories.push_back(TempDirectoryPath::create());
+    common::SpillDiskOptions spillOpts;
+    spillOpts.spillDirPath = spillDirectories[numPartialSortTasks]->getPath();
+    auto sortTask = makeTask(
+        sortTaskId,
+        partialSortPlan,
+        spillMergeConfigs,
+        tasks.size(),
+        /*consumer=*/nullptr,
+        memory::kMaxMemory,
+        spillOpts);
+    tasks.push_back(sortTask);
+    sortTask->start(4);
+
+    std::unordered_map<
+        core::PlanNodeId,
+        std::vector<std::shared_ptr<TempFilePath>>>
+        nodeSplits;
+    nodeSplits.reserve(5);
+    for (int i = 0; i < 5; ++i) {
+      nodeSplits[scanNodeIds[i]] = std::vector<std::shared_ptr<TempFilePath>>();
+    }
+    auto& filePaths = filePathsList[numPartialSortTasks];
+    for (int i = 0; i < filePaths.size(); ++i) {
+      nodeSplits[scanNodeIds[i % scanNodeIds.size()]].push_back(filePaths[i]);
+    }
+
+    addHiveSplits(sortTask, nodeSplits);
+    outputType = partialSortPlan->outputType();
+  }
+
+  auto finalSortTaskId = makeTaskId("orderby", tasks.size());
+  core::PlanNodeId mergeExchangeId;
+  auto finalSortPlan =
+      PlanBuilder()
+          .mergeExchange(outputType, {"c0"}, GetParam().serdeKind)
+          .capturePlanNodeId(mergeExchangeId)
+          .partitionedOutput({}, 1, /*outputLayout=*/{}, GetParam().serdeKind)
+          .planNode();
+
+  auto mergeTask = makeTask(finalSortTaskId, finalSortPlan, 0);
+  tasks.push_back(mergeTask);
+  mergeTask->start(1);
+  addRemoteSplits(mergeTask, partialSortTaskIds);
+
+  auto op = PlanBuilder().exchange(outputType, GetParam().serdeKind).planNode();
+
+  test::AssertQueryBuilder(op, duckDbQueryRunner_)
+      .split(remoteSplit(finalSortTaskId))
+      .config(
+          core::QueryConfig::kShuffleCompressionKind,
+          common::compressionKindToString(GetParam().compressionKind))
+      .assertResults(
+          "SELECT * FROM tmp ORDER BY 1 NULLS LAST", std::vector<uint32_t>{0});
+
+  for (auto& task : tasks) {
+    ASSERT_TRUE(waitForTaskCompletion(task.get())) << task->taskId();
+  }
+  for (auto i = 0; i < 2; ++i) {
+    auto taskStats = toPlanStats(tasks[i]->taskStats());
+    auto& planStats = taskStats.at(localMergeNodeIds[i]);
+    ASSERT_GT(planStats.spilledBytes, 0);
+    ASSERT_GT(planStats.spilledPartitions, 0);
+    ASSERT_GT(planStats.spilledFiles, 0);
+  }
+
+  const auto finalSortStats = toPlanStats(mergeTask->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);
+
+  const auto serdeKindRuntimsStats =
+      mergeExchangeStats.customStats.at(Operator::kShuffleSerdeKind);
+  ASSERT_EQ(serdeKindRuntimsStats.count, 1);
+  ASSERT_EQ(
+      serdeKindRuntimsStats.min, static_cast<int64_t>(GetParam().serdeKind));
+  ASSERT_EQ(
+      serdeKindRuntimsStats.max, static_cast<int64_t>(GetParam().serdeKind));
+}
+
 TEST_P(MultiFragmentTest, noHashPartitionSkew) {
   setupSources(10, 1000);
 
@@ -1411,6 +1623,56 @@ TEST_P(MultiFragmentTest, mergeExchangeOverEmptySources) {
   }
 }
 
+DEBUG_ONLY_TEST_P(MultiFragmentTest, mergeExchangeFailureOnStart) {
+  std::vector<std::shared_ptr<Task>> tasks;
+  std::vector<std::string> leafTaskIds;
+
+  const auto injectErrorMsg{"injectError"};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::ExchangeQueue::dequeueLocked",
+      std::function<void(ExchangeQueue*)>(
+          ([&](ExchangeQueue* /*unused*/) { VELOX_FAIL(injectErrorMsg); })));
+
+  auto data = makeRowVector(rowType_, 0);
+
+  for (int i = 0; i < 2; ++i) {
+    auto taskId = makeTaskId("leaf-", i);
+    leafTaskIds.push_back(taskId);
+    auto plan =
+        PlanBuilder()
+            .values({data})
+            .partitionedOutput({}, 1, /*outputLayout=*/{}, GetParam().serdeKind)
+            .planNode();
+
+    auto task = makeTask(taskId, plan, tasks.size());
+    tasks.push_back(task);
+    task->start(4);
+  }
+
+  auto exchangeTaskId = makeTaskId("exchange-", 0);
+  auto plan = PlanBuilder()
+                  .mergeExchange(rowType_, {"c0"}, GetParam().serdeKind)
+                  .singleAggregation({"c0"}, {"count(1)"})
+                  .planNode();
+
+  std::vector<Split> leafTaskSplits;
+  for (auto leafTaskId : leafTaskIds) {
+    leafTaskSplits.emplace_back(remoteSplit(leafTaskId));
+  }
+  VELOX_ASSERT_THROW(
+      test::AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .splits(std::move(leafTaskSplits))
+          .config(
+              core::QueryConfig::kShuffleCompressionKind,
+              common::compressionKindToString(GetParam().compressionKind))
+          .assertResults(""),
+      injectErrorMsg);
+
+  for (auto& task : tasks) {
+    ASSERT_TRUE(waitForTaskCompletion(task.get())) << task->taskId();
+  }
+}
+
 namespace {
 core::PlanNodePtr makeJoinOverExchangePlan(
     const RowTypePtr& exchangeType,
@@ -2164,7 +2426,7 @@ DEBUG_ONLY_TEST_P(
   std::thread failThread([&]() {
     try {
       VELOX_FAIL("Test terminate task");
-    } catch (const VeloxException& e) {
+    } catch (const VeloxException&) {
       task->setError(std::current_exception());
     }
   });
@@ -2237,8 +2499,8 @@ DEBUG_ONLY_TEST_P(MultiFragmentTest, mergeWithEarlyTermination) {
   mergeIsBlockedReady.store(true);
   mergeIsBlockedWait.notifyAll();
 
-  ASSERT_TRUE(waitForTaskCompletion(partialSortTask.get(), 1'000'000'000));
-  ASSERT_TRUE(waitForTaskAborted(finalSortTask.get(), 1'000'000'000));
+  ASSERT_TRUE(waitForTaskCompletion(partialSortTask.get(), 30'000'000));
+  ASSERT_TRUE(waitForTaskAborted(finalSortTask.get(), 30'000'000));
 }
 
 class DataFetcher {
@@ -2397,12 +2659,15 @@ DEBUG_ONLY_TEST_P(MultiFragmentTest, maxBytes) {
     return;
   }
   std::string s(25, 'x');
-  // Keep the row count under 7000 to avoid hitting the row limit in the
-  // operator instead.
+  // This number is chosen so that serialization of all the 100 vectors can fit
+  // in 32MB (the QueryConfig::maxOutputBufferSize).  Otherwise the driver is
+  // blocked, since the data consumed by DataFetcher is so small that the
+  // remaining buffered data is still larger than OutputBuffer::continueSize_.
+  constexpr int kNumRows = 4'800;
   auto data = makeRowVector({
-      makeFlatVector<int64_t>(5'000, [](auto row) { return row; }),
-      makeFlatVector<int64_t>(5'000, [](auto row) { return row; }),
-      makeConstant(StringView(s), 5'000),
+      makeFlatVector<int64_t>(kNumRows, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(kNumRows, [](auto row) { return row; }),
+      makeConstant(StringView(s), kNumRows),
   });
 
   core::PlanNodeId outputNodeId;
@@ -2567,7 +2832,7 @@ TEST_P(MultiFragmentTest, earlyTaskFailure) {
     if (internalFailure) {
       try {
         VELOX_FAIL("memoryAbortTest");
-      } catch (const VeloxRuntimeError& e) {
+      } catch (const VeloxRuntimeError&) {
         finalSortTask->pool()->abort(std::current_exception());
       }
     } else {
@@ -2652,8 +2917,8 @@ TEST_P(MultiFragmentTest, mergeSmallBatchesInExchange) {
   if (GetParam().serdeKind == VectorSerde::Kind::kPresto) {
     test(1, 1'000);
     test(1'000, 56);
-    test(10'000, 6);
-    test(100'000, 1);
+    test(10'000, 7);
+    test(100'000, 2);
   } else if (GetParam().serdeKind == VectorSerde::Kind::kCompactRow) {
     test(1, 1'000);
     test(1'000, 39);
@@ -2662,8 +2927,8 @@ TEST_P(MultiFragmentTest, mergeSmallBatchesInExchange) {
   } else {
     test(1, 1'000);
     test(1'000, 72);
-    test(10'000, 7);
-    test(100'000, 1);
+    test(10'000, 8);
+    test(100'000, 2);
   }
 }
 
@@ -2840,10 +3105,11 @@ TEST_P(MultiFragmentTest, compression) {
       test("local://t1", 0.7, false);
     }
     SCOPED_TRACE(fmt::format("minCompressionRatio 0.0000001"));
-    { test("local://t2", 0.0000001, true); }
+    {
+      test("local://t2", 0.0000001, true);
+    }
   }
 }
-
 TEST_P(MultiFragmentTest, scaledTableScan) {
   const int numSplits = 20;
   std::vector<std::shared_ptr<TempFilePath>> splitFiles;
@@ -2970,6 +3236,158 @@ TEST_P(MultiFragmentTest, scaledTableScan) {
   }
 }
 
+// Test row output with no columns (empty schema).
+TEST_P(MultiFragmentTest, emptySchema) {
+  // Create data with rows but no columns
+  auto emptyRowType = ROW({}, {});
+  auto data = makeRowVector(emptyRowType, 1'000);
+
+  std::vector<std::shared_ptr<Task>> tasks;
+  auto leafTaskId = makeTaskId("leaf", 0);
+
+  // Leaf task: Values -> PartitionedOutput
+  auto leafPlan =
+      PlanBuilder()
+          .values({data})
+          .partitionedOutput({}, 1, /*outputLayout=*/{}, GetParam().serdeKind)
+          .planNode();
+
+  auto leafTask = makeTask(leafTaskId, leafPlan, tasks.size());
+  tasks.push_back(leafTask);
+  leafTask->start(4);
+
+  // Root task: Exchange -> Project
+  auto rootTaskId = makeTaskId("root", 0);
+  auto rootPlan = PlanBuilder()
+                      .exchange(emptyRowType, GetParam().serdeKind)
+                      .singleAggregation({}, {"count(1)"})
+                      .planNode();
+
+  test::AssertQueryBuilder(rootPlan, duckDbQueryRunner_)
+      .split(remoteSplit(leafTaskId))
+      .config(
+          core::QueryConfig::kShuffleCompressionKind,
+          common::compressionKindToString(GetParam().compressionKind))
+      .assertResults("SELECT 1000");
+
+  for (auto& task : tasks) {
+    ASSERT_TRUE(waitForTaskCompletion(task.get())) << task->taskId();
+  }
+}
+
+// Test stateful deserialization with different batch byte limits.
+// This validates that the Exchange operator correctly breaks in the middle
+// and continues from the leftover when batch size limits are reached.
+TEST_P(MultiFragmentTest, batchBytes) {
+  auto test = [&](int32_t numBatches,
+                  int32_t rowsPerBatch,
+                  uint64_t preferredBatchBytes,
+                  uint64_t expectedAtLeastOutputBatches = 0) {
+    SCOPED_TRACE(
+        fmt::format(
+            "numBatches={}, rowsPerBatch={}, preferredBatchBytes={}",
+            numBatches,
+            rowsPerBatch,
+            succinctBytes(preferredBatchBytes)));
+
+    std::vector<RowVectorPtr> batches;
+    batches.reserve(numBatches);
+
+    for (int i = 0; i < numBatches; ++i) {
+      auto batch = makeRowVector({
+          makeFlatVector<int64_t>(
+              rowsPerBatch,
+              [i, rowsPerBatch](auto row) { return i * rowsPerBatch + row; }),
+          makeFlatVector<int32_t>(
+              rowsPerBatch,
+              [i, rowsPerBatch](auto row) {
+                return (i * rowsPerBatch + row) % 1000;
+              }),
+          makeFlatVector<double>(
+              rowsPerBatch,
+              [i, rowsPerBatch](auto row) {
+                return (i * rowsPerBatch + row) * 1.5;
+              }),
+      });
+      batches.push_back(batch);
+    }
+
+    auto leafTaskId = makeTaskId("leaf", 0);
+    auto leafPlan =
+        PlanBuilder()
+            .values(batches)
+            .partitionedOutput({}, 1, {"c0", "c1", "c2"}, GetParam().serdeKind)
+            .planNode();
+
+    auto leafTask = makeTask(leafTaskId, leafPlan, 0);
+    leafTask->start(1);
+
+    core::PlanNodeId exchangeNodeId;
+    auto rootPlan =
+        PlanBuilder()
+            .exchange(
+                ROW({"c0", "c1", "c2"}, {BIGINT(), INTEGER(), DOUBLE()}),
+                GetParam().serdeKind)
+            .capturePlanNodeId(exchangeNodeId)
+            .singleAggregation({}, {"count(1)", "sum(c0)", "avg(c2)"})
+            .planNode();
+
+    auto extraConfigs = std::unordered_map<std::string, std::string>{
+        {core::QueryConfig::kPreferredOutputBatchBytes,
+         std::to_string(preferredBatchBytes)},
+        {core::QueryConfig::kShuffleCompressionKind,
+         common::compressionKindToString(GetParam().compressionKind)}};
+
+    auto task = test::AssertQueryBuilder(rootPlan, duckDbQueryRunner_)
+                    .split(remoteSplit(leafTaskId))
+                    .configs(extraConfigs)
+                    .assertResults(
+                        fmt::format(
+                            "SELECT {}, {}, {}",
+                            numBatches * rowsPerBatch,
+                            (static_cast<int64_t>(numBatches) * rowsPerBatch *
+                             (numBatches * rowsPerBatch - 1)) /
+                                2,
+                            (static_cast<int64_t>(numBatches) * rowsPerBatch *
+                             (numBatches * rowsPerBatch - 1)) /
+                                2 * 1.5 / (numBatches * rowsPerBatch)));
+
+    waitForTaskCompletion(leafTask.get());
+
+    // Verify Exchange stats to ensure data was processed correctly
+    auto rootTaskStats = toPlanStats(task->taskStats());
+    const auto& exchangeStats = rootTaskStats.at(exchangeNodeId);
+
+    EXPECT_GE(exchangeStats.outputVectors, expectedAtLeastOutputBatches);
+  };
+
+  // Presto serialization operates at page-level granularity (pages are atomic).
+  // The number of output batches depends on how many Presto pages are created
+  // during serialization, which varies based on encoding, compression, and
+  // data.
+  //
+  // For this test (100 input batches × 100 rows = 10,000 rows):
+  // The actual behavior shows all pages are merged and processed together,
+  // resulting in a single batch output currently.
+  //
+  // This is a known limitation - Presto pages cannot be partially deserialized.
+  // The fix prevents INT32_MAX overflow by controlling the merge size, but
+  // fine-grained batch control requires deeper changes to PrestoVectorSerde.
+
+  if (GetParam().serdeKind == VectorSerde::Kind::kPresto) {
+    // Current implementation merges all pages and processes in one batch
+    // The key improvement is preventing overflow, not fine-grained batching
+    test(100, 100, 1, 1); // Expect single batch with all data
+    test(100, 100, 1ULL << 30, 1); // Expect single batch with all data
+  } else {
+    // Row-based serialization (CompactRow/UnsafeRow) supports row-level
+    // batching With 1 byte limit: Can produce many small batches
+    test(100, 100, 1, 100);
+    // With 1GB limit: All rows fit in one batch
+    test(100, 100, 1ULL << 30, 1);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     MultiFragmentTest,
     MultiFragmentTest,
diff --git a/velox/exec/tests/NestedLoopJoinTest.cpp b/velox/exec/tests/NestedLoopJoinTest.cpp
index f6f21a1138ad..4baec4a8c432 100644
--- a/velox/exec/tests/NestedLoopJoinTest.cpp
+++ b/velox/exec/tests/NestedLoopJoinTest.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/core/PlanNode.h"
 #include "velox/exec/NestedLoopJoinBuild.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
@@ -99,11 +100,12 @@ class NestedLoopJoinTest : public HiveConnectorTestBase {
 
     for (const auto joinType : joinTypes_) {
       for (const auto& comparison : comparisons_) {
-        SCOPED_TRACE(fmt::format(
-            "maxDrivers:{} joinType:{} comparison:{}",
-            std::to_string(numDrivers),
-            joinTypeName(joinType),
-            comparison));
+        SCOPED_TRACE(
+            fmt::format(
+                "maxDrivers:{} joinType:{} comparison:{}",
+                std::to_string(numDrivers),
+                core::JoinTypeName::toName(joinType),
+                comparison));
 
         params.planNode =
             PlanBuilder(planNodeIdGenerator)
@@ -122,7 +124,9 @@ class NestedLoopJoinTest : public HiveConnectorTestBase {
         assertQuery(
             params,
             fmt::format(
-                fmt::runtime(queryStr_), joinTypeName(joinType), comparison));
+                fmt::runtime(queryStr_),
+                core::JoinTypeName::toName(joinType),
+                comparison));
       }
     }
   }
@@ -376,7 +380,7 @@ TEST_F(NestedLoopJoinTest, outerJoinWithoutCondition) {
         op,
         fmt::format(
             "SELECT count(*) FROM t {} join u on 1",
-            core::joinTypeName(joinType)));
+            core::JoinTypeName::toName(joinType)));
   };
   testOuterJoin(core::JoinType::kLeft);
   testOuterJoin(core::JoinType::kRight);
@@ -728,5 +732,86 @@ TEST_F(NestedLoopJoinTest, mergeBuildVectorsOverflow) {
   ASSERT_EQ(mergeResult.size(), 2);
 }
 
+DEBUG_ONLY_TEST_F(NestedLoopJoinTest, longBatchDurationYield) {
+  const uint32_t kProbeSize = 10;
+  const uint32_t kBuildSize = 1'000;
+  const uint64_t kDriverCpuTimeSliceLimitMs = 1'000;
+  const std::string kLargeBatchSize =
+      folly::to<std::string>(kProbeSize * kBuildSize);
+
+  struct {
+    uint32_t numGetOutputCalls;
+    bool hasDelay;
+    std::string debugString() const {
+      return fmt::format(
+          "numGetOutputCalls: {}, needSleep: {}", numGetOutputCalls, hasDelay);
+    }
+  } testSettings[] = {{0, false}, {0, true}};
+
+  const auto probeData = makeRowVector(
+      {"t_c0", "t_c1"},
+      {
+          makeFlatVector<int32_t>(kProbeSize, [](auto row) { return row; }),
+          makeFlatVector<int32_t>(kProbeSize, [](auto row) { return row * 2; }),
+      });
+
+  const auto buildData = makeRowVector(
+      {"u_c0", "u_c1"},
+      {
+          makeFlatVector<int32_t>(kBuildSize, [](auto row) { return row; }),
+          makeFlatVector<int32_t>(kBuildSize, [](auto row) { return row * 3; }),
+      });
+
+  createDuckDbTable("t", {probeData});
+  createDuckDbTable("u", {buildData});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto planNode =
+      PlanBuilder(planNodeIdGenerator)
+          .values({probeData})
+          .nestedLoopJoin(
+              PlanBuilder(planNodeIdGenerator).values({buildData}).planNode(),
+              "",
+              {"t_c0", "t_c1", "u_c0", "u_c1"},
+              core::JoinType::kInner)
+          .planNode();
+
+  for (auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    std::atomic<int> nestedLoopJoinProbeGetOutputCalls{0};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::getOutput",
+        std::function<void(void*)>([&](void* op) {
+          auto* operatorPtr = static_cast<Operator*>(op);
+          if (operatorPtr->operatorType() == "NestedLoopJoinProbe") {
+            // The second time NestedLoopJoinProbe::getOutput actually calls
+            // generateOutput, and the function
+            // NestedLoopJoinProbe::shouldYield is expected to be called.
+            if (nestedLoopJoinProbeGetOutputCalls.fetch_add(1) == 2 &&
+                testData.hasDelay) {
+              std::this_thread::sleep_for(
+                  std::chrono::milliseconds(2 * kDriverCpuTimeSliceLimitMs));
+            }
+          }
+        }));
+
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(),
+        core::QueryConfig({
+            {core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+             folly::to<std::string>(kDriverCpuTimeSliceLimitMs)},
+            {core::QueryConfig::kPreferredOutputBatchRows, kLargeBatchSize},
+        }));
+
+    AssertQueryBuilder(planNode, duckDbQueryRunner_)
+        .queryCtx(queryCtx)
+        .maxDrivers(1)
+        .assertResults("SELECT t_c0, t_c1, u_c0, u_c1 FROM t, u");
+    testData.numGetOutputCalls = nestedLoopJoinProbeGetOutputCalls.load();
+  }
+  ASSERT_LT(
+      testSettings[0].numGetOutputCalls, testSettings[1].numGetOutputCalls);
+}
+
 } // namespace
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/OperatorTraceTest.cpp b/velox/exec/tests/OperatorTraceTest.cpp
index 64a9886f50d5..25da7c069bf1 100644
--- a/velox/exec/tests/OperatorTraceTest.cpp
+++ b/velox/exec/tests/OperatorTraceTest.cpp
@@ -21,15 +21,14 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
-#include "velox/exec/OperatorTraceWriter.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/Split.h"
 #include "velox/exec/TaskTraceReader.h"
+#include "velox/exec/TaskTraceWriter.h"
 #include "velox/exec/Trace.h"
 #include "velox/exec/TraceUtil.h"
-#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -50,15 +49,11 @@ class OperatorTraceTest : public HiveConnectorTestBase {
     }
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveConnectorSplit::registerSerDe();
-    connector::hive::HiveInsertFileNameGenerator::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
+    registerDummySourceSerDe();
   }
 
   void SetUp() override {
@@ -100,7 +95,9 @@ class OperatorTraceTest : public HiveConnectorTestBase {
     }
 
     for (auto i = 0; i < left->sources().size(); ++i) {
-      isSamePlan(left->sources().at(i), right->sources().at(i));
+      if (!isSamePlan(left->sources().at(i), right->sources().at(i))) {
+        return false;
+      }
     }
     return true;
   }
@@ -135,7 +132,7 @@ TEST_F(OperatorTraceTest, emptyTrace) {
           .config(core::QueryConfig::kQueryTraceDir, traceDirPath->getPath())
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-          .config(core::QueryConfig::kQueryTraceNodeIds, planNodeId)
+          .config(core::QueryConfig::kQueryTraceNodeId, planNodeId)
           .assertResults("SELECT a, count(1) FROM tmp WHERE a > 0 GROUP BY 1");
 
   const auto taskTraceDir =
@@ -200,7 +197,7 @@ TEST_F(OperatorTraceTest, traceData) {
                   core::QueryConfig::kQueryTraceMaxBytes,
                   testData.maxTracedBytes)
               .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-              .config(core::QueryConfig::kQueryTraceNodeIds, planNodeId)
+              .config(core::QueryConfig::kQueryTraceNodeId, planNodeId)
               .assertResults("SELECT a, count(1) FROM tmp GROUP BY 1"),
           "Query exceeded per-query local trace limit of");
       continue;
@@ -213,7 +210,7 @@ TEST_F(OperatorTraceTest, traceData) {
             .config(
                 core::QueryConfig::kQueryTraceMaxBytes, testData.maxTracedBytes)
             .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-            .config(core::QueryConfig::kQueryTraceNodeIds, planNodeId)
+            .config(core::QueryConfig::kQueryTraceNodeId, planNodeId)
             .assertResults("SELECT a, count(1) FROM tmp GROUP BY 1");
 
     const auto fs =
@@ -268,6 +265,7 @@ TEST_F(OperatorTraceTest, traceMetadata) {
 
   const auto outputDir = TempDirectoryPath::create();
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId traceNodeId;
   const auto planNode =
       PlanBuilder(planNodeIdGenerator)
           .values(rows, false)
@@ -283,6 +281,7 @@ TEST_F(OperatorTraceTest, traceMetadata) {
               "c0 < 135",
               {"c0", "c1", "c2"},
               core::JoinType::kInner)
+          .capturePlanNodeId(traceNodeId)
           .planNode();
   const auto expectedQueryConfigs =
       std::unordered_map<std::string, std::string>{
@@ -301,14 +300,15 @@ TEST_F(OperatorTraceTest, traceMetadata) {
       core::QueryConfig(expectedQueryConfigs),
       expectedConnectorProperties);
   auto writer = trace::TaskTraceMetadataWriter(outputDir->getPath(), pool());
-  writer.write(queryCtx, planNode);
+  auto traceNode = getTraceNode(planNode, traceNodeId);
+  writer.write(queryCtx, traceNode);
   const auto reader =
       trace::TaskTraceMetadataReader(outputDir->getPath(), pool());
   const auto actualQueryConfigs = reader.queryConfigs();
   const auto actualConnectorProperties = reader.connectorProperties();
   const auto actualQueryPlan = reader.queryPlan();
 
-  ASSERT_TRUE(isSamePlan(actualQueryPlan, planNode));
+  ASSERT_TRUE(isSamePlan(actualQueryPlan, traceNode));
   ASSERT_EQ(actualQueryConfigs.size(), expectedQueryConfigs.size());
   for (const auto& [key, value] : actualQueryConfigs) {
     ASSERT_EQ(actualQueryConfigs.at(key), expectedQueryConfigs.at(key));
@@ -380,7 +380,7 @@ TEST_F(OperatorTraceTest, task) {
              std::to_string(100UL << 30)},
             {core::QueryConfig::kQueryTraceDir, outputDir->getPath()},
             {core::QueryConfig::kQueryTraceTaskRegExp, testData.taskRegExpr},
-            {core::QueryConfig::kQueryTraceNodeIds, hashJoinNodeId},
+            {core::QueryConfig::kQueryTraceNodeId, hashJoinNodeId},
             {"key1", "value1"},
         };
 
@@ -423,7 +423,8 @@ TEST_F(OperatorTraceTest, task) {
     const auto actualConnectorProperties = reader.connectorProperties();
     const auto actualQueryPlan = reader.queryPlan();
 
-    ASSERT_TRUE(isSamePlan(actualQueryPlan, planNode));
+    ASSERT_TRUE(
+        isSamePlan(actualQueryPlan, getTraceNode(planNode, hashJoinNodeId)));
     ASSERT_EQ(actualQueryConfigs.size(), expectedQueryConfigs.size());
     for (const auto& [key, value] : actualQueryConfigs) {
       ASSERT_EQ(actualQueryConfigs.at(key), expectedQueryConfigs.at(key));
@@ -486,32 +487,16 @@ TEST_F(OperatorTraceTest, error) {
             .queryCtx(queryCtx)
             .maxDrivers(1)
             .copyResults(pool()),
-        "Query trace nodes are not set");
-  }
-  // Duplicate trace plan node ids.
-  {
-    const auto queryConfigs = std::unordered_map<std::string, std::string>{
-        {core::QueryConfig::kQueryTraceEnabled, "true"},
-        {core::QueryConfig::kQueryTraceDir, "traceDir"},
-        {core::QueryConfig::kQueryTraceTaskRegExp, ".*"},
-        {core::QueryConfig::kQueryTraceNodeIds, "1,1"},
-    };
-    const auto queryCtx = core::QueryCtx::create(
-        executor_.get(), core::QueryConfig(queryConfigs));
-    VELOX_ASSERT_USER_THROW(
-        AssertQueryBuilder(planNode)
-            .queryCtx(queryCtx)
-            .maxDrivers(1)
-            .copyResults(pool()),
-        "Duplicate trace nodes found: 1, 1");
+        "Query trace node ID are not set");
   }
+
   // Nonexist trace plan node id.
   {
     const auto queryConfigs = std::unordered_map<std::string, std::string>{
         {core::QueryConfig::kQueryTraceEnabled, "true"},
         {core::QueryConfig::kQueryTraceDir, "traceDir"},
         {core::QueryConfig::kQueryTraceTaskRegExp, ".*"},
-        {core::QueryConfig::kQueryTraceNodeIds, "nonexist"},
+        {core::QueryConfig::kQueryTraceNodeId, "nonexist"},
     };
     const auto queryCtx = core::QueryCtx::create(
         executor_.get(), core::QueryConfig(queryConfigs));
@@ -520,7 +505,8 @@ TEST_F(OperatorTraceTest, error) {
             .queryCtx(queryCtx)
             .maxDrivers(1)
             .copyResults(pool()),
-        "Trace plan nodes not found from task");
+
+        "Trace plan node ID = nonexist not found from task");
   }
 }
 
@@ -578,7 +564,7 @@ TEST_F(OperatorTraceTest, traceTableWriter) {
               .config(
                   core::QueryConfig::kQueryTraceTaskRegExp,
                   testData.taskRegExpr)
-              .config(core::QueryConfig::kQueryTraceNodeIds, tableWriteNodeId)
+              .config(core::QueryConfig::kQueryTraceNodeId, tableWriteNodeId)
               .copyResults(pool(), task),
           "Query exceeded per-query local trace limit of");
       continue;
@@ -589,7 +575,7 @@ TEST_F(OperatorTraceTest, traceTableWriter) {
         .config(core::QueryConfig::kQueryTraceDir, traceRoot)
         .config(core::QueryConfig::kQueryTraceMaxBytes, testData.maxTracedBytes)
         .config(core::QueryConfig::kQueryTraceTaskRegExp, testData.taskRegExpr)
-        .config(core::QueryConfig::kQueryTraceNodeIds, tableWriteNodeId)
+        .config(core::QueryConfig::kQueryTraceNodeId, tableWriteNodeId)
         .copyResults(pool(), task);
 
     const auto taskTraceDir = getTaskTraceDirectory(traceRoot, *task);
@@ -684,7 +670,7 @@ TEST_F(OperatorTraceTest, filterProject) {
               .config(
                   core::QueryConfig::kQueryTraceTaskRegExp,
                   testData.taskRegExpr)
-              .config(core::QueryConfig::kQueryTraceNodeIds, projectNodeId)
+              .config(core::QueryConfig::kQueryTraceNodeId, projectNodeId)
               .copyResults(pool(), task),
           "Query exceeded per-query local trace limit of");
       continue;
@@ -695,7 +681,7 @@ TEST_F(OperatorTraceTest, filterProject) {
         .config(core::QueryConfig::kQueryTraceDir, traceRoot)
         .config(core::QueryConfig::kQueryTraceMaxBytes, testData.maxTracedBytes)
         .config(core::QueryConfig::kQueryTraceTaskRegExp, testData.taskRegExpr)
-        .config(core::QueryConfig::kQueryTraceNodeIds, projectNodeId)
+        .config(core::QueryConfig::kQueryTraceNodeId, projectNodeId)
         .copyResults(pool(), task);
 
     const auto taskTraceDir = getTaskTraceDirectory(traceRoot, *task);
@@ -759,7 +745,7 @@ TEST_F(OperatorTraceTest, traceSplitRoundTrip) {
       .config(core::QueryConfig::kQueryTraceEnabled, true)
       .config(core::QueryConfig::kQueryTraceDir, traceDirPath->getPath())
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, "0")
+      .config(core::QueryConfig::kQueryTraceNodeId, "0")
       .splits(splits)
       .copyResults(pool(), task);
 
@@ -769,7 +755,7 @@ TEST_F(OperatorTraceTest, traceSplitRoundTrip) {
   for (int i = 0; i < 3; ++i) {
     const auto opTraceDir = getOpTraceDirectory(
         taskTraceDir,
-        /*planNodeId=*/"0",
+        /*nodeId=*/"0",
         /*pipelineId=*/0,
         /*driverId=*/i);
     const auto summaryFilePath = getOpTraceSummaryFilePath(opTraceDir);
@@ -825,7 +811,7 @@ TEST_F(OperatorTraceTest, traceSplitPartial) {
       .config(core::QueryConfig::kQueryTraceEnabled, true)
       .config(core::QueryConfig::kQueryTraceDir, traceDirPath->getPath())
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, "0")
+      .config(core::QueryConfig::kQueryTraceNodeId, "0")
       .splits(splits)
       .copyResults(pool(), task);
 
@@ -835,7 +821,7 @@ TEST_F(OperatorTraceTest, traceSplitPartial) {
   for (int i = 0; i < 3; ++i) {
     const auto opTraceDir = getOpTraceDirectory(
         taskTraceDir,
-        /*planNodeId=*/"0",
+        /*nodeId=*/"0",
         /*pipelineId=*/0,
         /*driverId=*/i);
     const auto summaryFilePath = getOpTraceSummaryFilePath(opTraceDir);
@@ -914,7 +900,7 @@ TEST_F(OperatorTraceTest, traceSplitCorrupted) {
       .config(core::QueryConfig::kQueryTraceEnabled, true)
       .config(core::QueryConfig::kQueryTraceDir, traceDirPath->getPath())
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, "0")
+      .config(core::QueryConfig::kQueryTraceNodeId, "0")
       .splits(splits)
       .copyResults(pool(), task);
 
@@ -924,7 +910,7 @@ TEST_F(OperatorTraceTest, traceSplitCorrupted) {
   for (int i = 0; i < 3; ++i) {
     const auto opTraceDir = getOpTraceDirectory(
         taskTraceDir,
-        /*planNodeId=*/"0",
+        /*nodeId=*/"0",
         /*pipelineId=*/0,
         /*driverId=*/i);
     const auto summaryFilePath = getOpTraceSummaryFilePath(opTraceDir);
@@ -1056,7 +1042,7 @@ TEST_F(OperatorTraceTest, hashJoin) {
               .config(
                   core::QueryConfig::kQueryTraceTaskRegExp,
                   testData.taskRegExpr)
-              .config(core::QueryConfig::kQueryTraceNodeIds, hashJoinNodeId)
+              .config(core::QueryConfig::kQueryTraceNodeId, hashJoinNodeId)
               .copyResults(pool(), task),
           "Query exceeded per-query local trace limit of");
       continue;
@@ -1067,7 +1053,7 @@ TEST_F(OperatorTraceTest, hashJoin) {
         .config(core::QueryConfig::kQueryTraceDir, traceRoot)
         .config(core::QueryConfig::kQueryTraceMaxBytes, testData.maxTracedBytes)
         .config(core::QueryConfig::kQueryTraceTaskRegExp, testData.taskRegExpr)
-        .config(core::QueryConfig::kQueryTraceNodeIds, hashJoinNodeId)
+        .config(core::QueryConfig::kQueryTraceNodeId, hashJoinNodeId)
         .copyResults(pool(), task);
 
     const auto taskTraceDir = getTaskTraceDirectory(traceRoot, *task);
@@ -1135,13 +1121,18 @@ TEST_F(OperatorTraceTest, canTrace) {
       {"PartitionedOutput", true},
       {"HashBuild", true},
       {"HashProbe", true},
+      {"IndexLookupJoin", true},
+      {"Unnest", true},
       {"RowNumber", false},
-      {"OrderBy", false},
+      {"OrderBy", true},
+      {"TopNRowNumber", true},
       {"PartialAggregation", true},
       {"Aggregation", true},
       {"TableWrite", true},
       {"TableScan", true},
-      {"FilterProject", true}};
+      {"FilterProject", true},
+      {"Exchange", true},
+      {"MergeExchange", true}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     ASSERT_EQ(testData.canTrace, trace::canTrace(testData.operatorType));
@@ -1172,9 +1163,9 @@ TEST_F(OperatorTraceTest, hiveConnectorId) {
       .config(core::QueryConfig::kQueryTraceEnabled, true)
       .config(core::QueryConfig::kQueryTraceDir, traceDirPath->getPath())
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, "0")
+      .config(core::QueryConfig::kQueryTraceNodeId, "0")
       .splits(splits)
-      .runWithoutResults(task);
+      .countResults(task);
   const auto taskTraceDir =
       getTaskTraceDirectory(traceDirPath->getPath(), *task);
   const auto reader = trace::TaskTraceMetadataReader(taskTraceDir, pool());
diff --git a/velox/exec/tests/OperatorUtilsTest.cpp b/velox/exec/tests/OperatorUtilsTest.cpp
index 4ea4864cdd77..0036f2f3dbf9 100644
--- a/velox/exec/tests/OperatorUtilsTest.cpp
+++ b/velox/exec/tests/OperatorUtilsTest.cpp
@@ -17,6 +17,7 @@
 #include <gtest/gtest.h>
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/exec/Operator.h"
+#include "velox/exec/tests/utils/MergeTestBase.h"
 #include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
@@ -48,7 +49,8 @@ class OperatorUtilsTest : public OperatorTestBase {
         std::move(planFragment),
         0,
         core::QueryCtx::create(executor_.get()),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
     driver_ = Driver::testingCreate();
     driverCtx_ = std::make_unique<DriverCtx>(task_, 0, 0, 0, 0);
     driverCtx_->driver = driver_.get();
@@ -57,7 +59,8 @@ class OperatorUtilsTest : public OperatorTestBase {
   void gatherCopyTest(
       const std::shared_ptr<const RowType>& targetType,
       const std::shared_ptr<const RowType>& sourceType,
-      int numSources) {
+      int numSources,
+      bool flattenSources = true) {
     folly::Random::DefaultGenerator rng(1);
     const int kNumRows = 500;
     const int kNumColumns = sourceType->size();
@@ -65,8 +68,9 @@ class OperatorUtilsTest : public OperatorTestBase {
     // Build source vectors with nulls.
     std::vector<RowVectorPtr> sources;
     for (int i = 0; i < numSources; ++i) {
-      sources.push_back(std::static_pointer_cast<RowVector>(
-          BatchMaker::createBatch(sourceType, kNumRows, *pool_)));
+      sources.push_back(
+          std::static_pointer_cast<RowVector>(
+              BatchMaker::createBatch(sourceType, kNumRows, *pool_)));
       for (int j = 0; j < kNumColumns; ++j) {
         auto vector = sources.back()->childAt(j);
         int nullRow = (folly::Random::rand32() % kNumRows) / 4;
@@ -78,6 +82,23 @@ class OperatorUtilsTest : public OperatorTestBase {
       }
     }
 
+    if (!flattenSources) {
+      for (int i = 0; i < numSources; ++i) {
+        const auto source = sources[i];
+        const auto numRows = source->size();
+        std::vector<vector_size_t> sortIndices(numRows, 0);
+        for (auto i = 0; i < numRows; ++i) {
+          sortIndices[i] = i;
+        }
+        BufferPtr indices = allocateIndices(numRows, pool_.get());
+        auto rawIndices = indices->asMutable<vector_size_t>();
+        for (size_t i = 0; i < numRows; ++i) {
+          rawIndices[i] = sortIndices[i];
+        }
+        sources[i] = wrap(numRows, indices, source);
+      }
+    }
+
     std::vector<IdentityProjection> columnMap;
     if (sourceType != targetType) {
       for (column_index_t sourceChannel = 0; sourceChannel < kNumColumns;
@@ -133,6 +154,61 @@ class OperatorUtilsTest : public OperatorTestBase {
     }
   }
 
+  void gatherMergeTest(
+      int32_t numValues,
+      int numMergeWays,
+      int targetSize,
+      bool useRandom) {
+    auto goldenVector = makeRowVector({
+        makeFlatVector<int32_t>(numValues, [&](auto row) { return row; }),
+    });
+    std::vector<std::vector<int32_t>> mergeWays(numMergeWays);
+    for (int32_t value = 0; value < numValues; value++) {
+      int way = useRandom ? folly::Random::rand32() % numMergeWays
+                          : value % numMergeWays;
+      mergeWays[way].push_back(value);
+    }
+    std::vector<RowVectorPtr> sources;
+    std::vector<std::unique_ptr<SpillMergeStream>> streams;
+    std::vector<SpillSortKey> sortKeys = {{0, {true, true}}};
+    for (int way = 0; way < numMergeWays; way++) {
+      auto source = makeRowVector({
+          makeFlatVector<int32_t>(
+              mergeWays[way].size(),
+              [&](auto row) { return mergeWays[way][row]; }),
+      });
+      sources.push_back(source);
+      streams.push_back(
+          std::make_unique<TestingSpillMergeStream>(way, sortKeys, source));
+    }
+    auto mergeTree =
+        std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
+    RowVectorPtr targetVector = std::static_pointer_cast<RowVector>(
+        BaseVector::create(sources[0]->type(), targetSize, pool_.get()));
+    std::vector<const RowVector*> bufferSources(targetSize);
+    std::vector<vector_size_t> bufferSourceIndices(targetSize);
+    for (int32_t batch = 0; batch * targetSize < numValues; batch++) {
+      int32_t valueBegin = batch * targetSize;
+      int32_t valueEnd = valueBegin + targetSize;
+      valueEnd = std::min(valueEnd, numValues);
+      VectorPtr tmp = std::move(targetVector);
+      BaseVector::prepareForReuse(tmp, targetSize);
+      targetVector = std::static_pointer_cast<RowVector>(tmp);
+      for (auto& child : targetVector->children()) {
+        child->resize(targetSize);
+      }
+      int count = 0;
+      testingGatherMerge(
+          targetVector, *mergeTree, count, bufferSources, bufferSourceIndices);
+      EXPECT_EQ(count, valueEnd - valueBegin);
+      auto result = targetVector->childAt(0).get();
+      auto golden = goldenVector->childAt(0).get();
+      for (int32_t row = 0; row < valueEnd - valueBegin; row++) {
+        EXPECT_TRUE(result->equalValueAt(golden, row, valueBegin + row));
+      }
+    }
+  }
+
   void setTaskOutputBatchConfig(
       uint32_t preferredBatchSize,
       uint32_t maxRows,
@@ -373,6 +449,67 @@ TEST_F(OperatorUtilsTest, gatherCopy) {
   }
 }
 
+TEST_F(OperatorUtilsTest, gatherCopyEncoding) {
+  std::shared_ptr<const RowType> rowType;
+  std::shared_ptr<const RowType> reversedRowType;
+  {
+    std::vector<std::string> names = {
+        "bool_val",
+        "tiny_val",
+        "small_val",
+        "int_val",
+        "long_val",
+        "ordinal",
+        "float_val",
+        "double_val",
+        "string_val",
+        "array_val",
+        "struct_val",
+        "map_val"};
+    std::vector<std::string> reversedNames = names;
+    std::reverse(reversedNames.begin(), reversedNames.end());
+
+    std::vector<std::shared_ptr<const Type>> types = {
+        BOOLEAN(),
+        TINYINT(),
+        SMALLINT(),
+        INTEGER(),
+        BIGINT(),
+        BIGINT(),
+        REAL(),
+        DOUBLE(),
+        VARCHAR(),
+        ARRAY(VARCHAR()),
+        ROW({{"s_int", INTEGER()}, {"s_array", ARRAY(REAL())}}),
+        MAP(VARCHAR(),
+            MAP(BIGINT(),
+                ROW({{"s2_int", INTEGER()}, {"s2_string", VARCHAR()}})))};
+    std::vector<std::shared_ptr<const Type>> reversedTypes = types;
+    std::reverse(reversedTypes.begin(), reversedTypes.end());
+
+    rowType = ROW(std::move(names), std::move(types));
+    reversedRowType = ROW(std::move(reversedNames), std::move(reversedTypes));
+  }
+
+  // Gather copy with identical column mapping.
+  gatherCopyTest(rowType, rowType, 1, false);
+  gatherCopyTest(rowType, rowType, 5, false);
+  // Gather copy with non-identical column mapping.
+  gatherCopyTest(rowType, reversedRowType, 1, false);
+  gatherCopyTest(rowType, reversedRowType, 5, false);
+}
+
+TEST_F(OperatorUtilsTest, gatherMerge) {
+  gatherMergeTest(1234, 2, 10, false);
+  gatherMergeTest(1234, 2, 100, false);
+  gatherMergeTest(1234, 10, 10, false);
+  gatherMergeTest(1234, 10, 100, false);
+  gatherMergeTest(1234, 2, 10, true);
+  gatherMergeTest(1234, 2, 100, true);
+  gatherMergeTest(1234, 10, 10, true);
+  gatherMergeTest(1234, 10, 100, true);
+}
+
 TEST_F(OperatorUtilsTest, makeOperatorSpillPath) {
   EXPECT_EQ("spill/3_1_100", makeOperatorSpillPath("spill", 3, 1, 100));
 }
@@ -448,6 +585,36 @@ TEST_F(OperatorUtilsTest, addOperatorRuntimeStats) {
   ASSERT_EQ(stats[statsName].min, 100);
 }
 
+TEST_F(OperatorUtilsTest, setOperatorRuntimeStats) {
+  std::unordered_map<std::string, RuntimeMetric> stats;
+  const std::string statsName("stats");
+  const RuntimeCounter minStatsValue(100, RuntimeCounter::Unit::kBytes);
+  const RuntimeCounter maxStatsValue(200, RuntimeCounter::Unit::kBytes);
+  setOperatorRuntimeStats(statsName, minStatsValue, stats);
+  ASSERT_EQ(stats[statsName].count, 1);
+  ASSERT_EQ(stats[statsName].sum, 100);
+  ASSERT_EQ(stats[statsName].max, 100);
+  ASSERT_EQ(stats[statsName].min, 100);
+
+  setOperatorRuntimeStats(statsName, maxStatsValue, stats);
+  ASSERT_EQ(stats[statsName].count, 1);
+  ASSERT_EQ(stats[statsName].sum, 200);
+  ASSERT_EQ(stats[statsName].max, 200);
+  ASSERT_EQ(stats[statsName].min, 200);
+
+  addOperatorRuntimeStats(statsName, maxStatsValue, stats);
+  ASSERT_EQ(stats[statsName].count, 2);
+  ASSERT_EQ(stats[statsName].sum, 400);
+  ASSERT_EQ(stats[statsName].max, 200);
+  ASSERT_EQ(stats[statsName].min, 200);
+
+  setOperatorRuntimeStats(statsName, minStatsValue, stats);
+  ASSERT_EQ(stats[statsName].count, 1);
+  ASSERT_EQ(stats[statsName].sum, 100);
+  ASSERT_EQ(stats[statsName].max, 100);
+  ASSERT_EQ(stats[statsName].min, 100);
+}
+
 TEST_F(OperatorUtilsTest, initializeRowNumberMapping) {
   BufferPtr mapping;
   auto rawMapping = initializeRowNumberMapping(mapping, 10, pool());
@@ -531,6 +698,52 @@ TEST_F(OperatorUtilsTest, projectChildren) {
   }
 }
 
+TEST_F(OperatorUtilsTest, projectDuplicateChildren) {
+  // Test wrapping an unloaded lazy vector in dictionary vector multiple
+  // times.
+  auto flatVector = makeNullableFlatVector<int64_t>(
+      std::vector<std::optional<int64_t>>{1, std::nullopt, 3, 4, 5});
+  const auto size = flatVector->size();
+
+  auto lazyVector = std::make_shared<LazyVector>(
+      pool(),
+      BIGINT(),
+      size,
+      std::make_unique<SimpleVectorLoader>([&](RowSet /*rows*/) {
+        return makeFlatVector<int64_t>(
+            size,
+            [&](vector_size_t row) { return flatVector->valueAt(row); },
+            [&](vector_size_t row) { return flatVector->isNullAt(row); });
+      }));
+
+  std::vector<VectorPtr> children = {lazyVector};
+  auto rowVector = makeRowVector(std::move(children));
+
+  std::vector<IdentityProjection> identityProjections;
+  identityProjections.emplace_back(0, 0);
+  identityProjections.emplace_back(0, 1);
+
+  auto mapping = makeIndices(size, [](auto row) { return row % 3; });
+
+  std::vector<VectorPtr> projectedChildren(2);
+  projectChildren(
+      projectedChildren, rowVector, identityProjections, size, mapping);
+
+  for (const auto& projection : identityProjections) {
+    auto* result = projectedChildren[projection.outputChannel].get();
+    result->loadedVector();
+    auto* source = rowVector->childAt(projection.inputChannel).get();
+    for (auto i = 0; i < size; ++i) {
+      auto srcIndex = mapping->as<vector_size_t>()[i];
+      if (result->isNullAt(i)) {
+        ASSERT_TRUE(source->isNullAt(srcIndex));
+      } else {
+        ASSERT_TRUE(result->equalValueAt(source, i, srcIndex));
+      }
+    }
+  }
+}
+
 TEST_F(OperatorUtilsTest, reclaimableSectionGuard) {
   RowTypePtr rowType = ROW({"c0"}, {INTEGER()});
 
diff --git a/velox/exec/tests/OrderByTest.cpp b/velox/exec/tests/OrderByTest.cpp
index c343dbe8020d..25548f3f0481 100644
--- a/velox/exec/tests/OrderByTest.cpp
+++ b/velox/exec/tests/OrderByTest.cpp
@@ -558,8 +558,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringInputProcessing) {
 
     auto spillDirectory = exec::test::TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -700,8 +701,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringReserve) {
 
   auto spillDirectory = exec::test::TempDirectoryPath::create();
   auto queryCtx = core::QueryCtx::create(executor_.get());
-  queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-      queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
   auto expectedResult =
       AssertQueryBuilder(
           PlanBuilder()
@@ -946,8 +948,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimDuringOutputProcessing) {
     SCOPED_TRACE(fmt::format("enableSpilling {}", enableSpilling));
     auto spillDirectory = exec::test::TempDirectoryPath::create();
     auto queryCtx = core::QueryCtx::create(executor_.get());
-    queryCtx->testingOverrideMemoryPool(memory::memoryManager()->addRootPool(
-        queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
+    queryCtx->testingOverrideMemoryPool(
+        memory::memoryManager()->addRootPool(
+            queryCtx->queryId(), kMaxBytes, memory::MemoryReclaimer::create()));
     auto expectedResult =
         AssertQueryBuilder(
             PlanBuilder()
@@ -1319,11 +1322,12 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimFromOrderBy) {
           .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())
+          .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);
@@ -1357,10 +1361,11 @@ DEBUG_ONLY_TEST_F(OrderByTest, reclaimFromEmptyOrderBy) {
           .spillDirectory(spillDirectory->getPath())
           .config(core::QueryConfig::kSpillEnabled, true)
           .config(core::QueryConfig::kOrderBySpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(vectors)
-                    .orderBy({"c0 ASC NULLS LAST"}, false)
-                    .planNode())
+          .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;
@@ -1376,8 +1381,9 @@ DEBUG_ONLY_TEST_F(OrderByTest, orderByWithLazyInput) {
       VectorFuzzer(fuzzerOpts_, pool()).fuzzRowChildrenToLazy(nonLazyVector));
 
   std::vector<RowVectorPtr> lazyInputCopy;
-  lazyInputCopy.push_back(std::dynamic_pointer_cast<RowVector>(
-      nonLazyVector->testingCopyPreserveEncodings()));
+  lazyInputCopy.push_back(
+      std::dynamic_pointer_cast<RowVector>(
+          nonLazyVector->testingCopyPreserveEncodings()));
   createDuckDbTable(lazyInputCopy);
 
   std::atomic_bool nonReclaimableSectionEntered{false};
@@ -1404,10 +1410,11 @@ DEBUG_ONLY_TEST_F(OrderByTest, orderByWithLazyInput) {
           .spillDirectory(spillDirectory->getPath())
           .config(core::QueryConfig::kSpillEnabled, true)
           .config(core::QueryConfig::kOrderBySpillEnabled, true)
-          .plan(PlanBuilder()
-                    .values(lazyInput)
-                    .orderBy({"c0 ASC NULLS LAST"}, false)
-                    .planNode())
+          .plan(
+              PlanBuilder()
+                  .values(lazyInput)
+                  .orderBy({"c0 ASC NULLS LAST"}, false)
+                  .planNode())
           .assertResults("SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST");
 
   ASSERT_TRUE(lazyLoadedInNonReclaimableSection.has_value());
diff --git a/velox/exec/tests/OutputBufferManagerTest.cpp b/velox/exec/tests/OutputBufferManagerTest.cpp
index e1e5feaa494d..4c8ffd2dfe5c 100644
--- a/velox/exec/tests/OutputBufferManagerTest.cpp
+++ b/velox/exec/tests/OutputBufferManagerTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include "velox/exec/OutputBufferManager.h"
+#include <folly/system/HardwareConcurrency.h>
 #include <gtest/gtest.h>
 #include "folly/experimental/EventCount.h"
 #include "velox/common/base/tests/GTestUtils.h"
@@ -109,13 +110,14 @@ class OutputBufferManagerTest : public testing::Test {
         std::move(planFragment),
         0,
         std::move(queryCtx),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
 
     bufferManager_->initializeTask(task, kind, numDestinations, numDrivers);
     return task;
   }
 
-  std::unique_ptr<SerializedPage> makeSerializedPage(
+  std::unique_ptr<SerializedPageBase> makeSerializedPage(
       RowTypePtr rowType,
       vector_size_t size) {
     auto vector = std::dynamic_pointer_cast<RowVector>(
@@ -375,8 +377,9 @@ class OutputBufferManagerTest : public testing::Test {
               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)});
+            promise.setValue(
+                Response{
+                    std::move(pages), inSequence, std::move(remainingBytes)});
           });
       future.wait();
       ASSERT_TRUE(future.isReady());
@@ -435,7 +438,7 @@ class OutputBufferManagerTest : public testing::Test {
   const VectorSerde::Kind serdeKind_;
   std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::hardware_concurrency())};
   std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
   std::shared_ptr<OutputBufferManager> bufferManager_;
   RowTypePtr rowType_;
@@ -570,21 +573,18 @@ VELOX_INSTANTIATE_TEST_SUITE_P(
 
 TEST_F(OutputBufferManagerTest, outputType) {
   ASSERT_EQ(
-      PartitionedOutputNode::kindString(
-          PartitionedOutputNode::Kind::kPartitioned),
+      PartitionedOutputNode::toName(PartitionedOutputNode::Kind::kPartitioned),
       "PARTITIONED");
   ASSERT_EQ(
-      PartitionedOutputNode::kindString(
-          PartitionedOutputNode::Kind::kArbitrary),
+      PartitionedOutputNode::toName(PartitionedOutputNode::Kind::kArbitrary),
       "ARBITRARY");
   ASSERT_EQ(
-      PartitionedOutputNode::kindString(
-          PartitionedOutputNode::Kind::kBroadcast),
+      PartitionedOutputNode::toName(PartitionedOutputNode::Kind::kBroadcast),
       "BROADCAST");
   VELOX_ASSERT_THROW(
-      PartitionedOutputNode::kindString(
+      PartitionedOutputNode::toName(
           static_cast<PartitionedOutputNode::Kind>(100)),
-      "Invalid Output Kind 100");
+      "Invalid enum value: 100");
 }
 
 TEST_P(OutputBufferManagerWithDifferentSerdeKindsTest, destinationBuffer) {
@@ -1473,7 +1473,7 @@ TEST_P(
   std::memcpy(iobuf->writableData(), payload.data(), payloadSize);
   iobuf->append(payloadSize);
 
-  auto page = std::make_unique<SerializedPage>(std::move(iobuf));
+  auto page = std::make_unique<PrestoSerializedPage>(std::move(iobuf));
 
   auto queue = std::make_shared<ExchangeQueue>(1, 0);
   std::vector<ContinuePromise> promises;
diff --git a/velox/exec/tests/ParallelProjectTest.cpp b/velox/exec/tests/ParallelProjectTest.cpp
new file mode 100644
index 000000000000..e3fcb8d54e6d
--- /dev/null
+++ b/velox/exec/tests/ParallelProjectTest.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/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::exec {
+namespace {
+
+class ParallelProjectTest : public test::OperatorTestBase {
+ protected:
+  void SetUp() override {
+    test::OperatorTestBase::SetUp();
+  }
+};
+
+TEST_F(ParallelProjectTest, basic) {
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(100, folly::identity),
+      makeFlatVector<int32_t>(100, folly::identity),
+  });
+
+  createDuckDbTable({data});
+
+  auto plan =
+      test::PlanBuilder()
+          .values({data})
+          .parallelProject({{"c0 + 1", "c0 * 2"}, {"c1 + 10", "c1 * 3"}})
+          .planNode();
+
+  assertQuery(plan, "SELECT c0 + 1, c0 * 2, c1 + 10, c1 * 3 FROM tmp");
+}
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/PlanBuilderTest.cpp b/velox/exec/tests/PlanBuilderTest.cpp
index 69436314762b..3366cb71a8ab 100644
--- a/velox/exec/tests/PlanBuilderTest.cpp
+++ b/velox/exec/tests/PlanBuilderTest.cpp
@@ -13,10 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/Expressions.h"
 #include "velox/exec/WindowFunction.h"
+#include "velox/exec/tests/utils/ExpressionBuilder.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/TestIndexStorageConnector.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/Expressions.h"
@@ -254,51 +258,220 @@ TEST_F(PlanBuilderTest, missingOutputType) {
 }
 
 TEST_F(PlanBuilderTest, projectExpressions) {
+  using namespace velox::expr_builder;
+
   // Non-typed Expressions.
   // Simple field access.
   auto data = ROW({"c0"}, {BIGINT()});
   VELOX_CHECK_EQ(
       PlanBuilder()
           .tableScan("tmp", data)
-          .projectExpressions(
-              {std::make_shared<core::FieldAccessExpr>("c0", std::nullopt)})
+          .projectExpressions({col("c0")})
           .planNode()
           ->toString(true, false),
       "-- Project[1][expressions: (c0:BIGINT, ROW[\"c0\"])] -> c0:BIGINT\n");
+
   // Dereference test using field access query.
   data = ROW({"c0"}, {ROW({"field0"}, {BIGINT()})});
   VELOX_CHECK_EQ(
       PlanBuilder()
           .tableScan("tmp", data)
-          .projectExpressions({std::make_shared<core::FieldAccessExpr>(
-              "field0",
-              std::nullopt,
-              std::vector<core::ExprPtr>{
-                  std::make_shared<core::FieldAccessExpr>(
-                      "c0", std::nullopt)})})
+          .projectExpressions({col("c0").subfield("field0")})
           .planNode()
           ->toString(true, false),
       "-- Project[1][expressions: (field0:BIGINT, ROW[\"c0\"][field0])] -> field0:BIGINT\n");
 
   // Test Typed Expressions
+  auto rowType = ROW({"c0"}, {VARCHAR()});
   VELOX_CHECK_EQ(
       PlanBuilder()
-          .tableScan("tmp", ROW({"c0"}, {ROW({VARCHAR()})}))
+          .tableScan("tmp", rowType)
           .projectExpressions(
-              {std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0")})
+              {core::Expressions::inferTypes(col("c0"), rowType, pool_.get())})
+          .planNode()
+          ->toString(true, false),
+      "-- Project[1][expressions: (p0:VARCHAR, ROW[\"c0\"])] -> p0:VARCHAR\n");
+
+  rowType = ROW({"c0"}, {ROW({"field0"}, {VARCHAR()})});
+  VELOX_CHECK_EQ(
+      PlanBuilder()
+          .tableScan("tmp", rowType)
+          .projectExpressions({core::Expressions::inferTypes(
+              col("c0").subfield("field0"), rowType, pool_.get())})
+          .planNode()
+          ->toString(true, false),
+      "-- Project[1][expressions: (p0:VARCHAR, ROW[\"c0\"][field0])] -> p0:VARCHAR\n");
+}
+
+TEST_F(PlanBuilderTest, filter) {
+  auto data = ROW({"c0"}, {BIGINT()});
+  constexpr std::string_view expectation =
+      "-- Filter[1][expression: gt(plus(ROW[\"c0\"],10),100)] -> c0:BIGINT\n";
+
+  // Filter with SQL snippet.
+  VELOX_CHECK_EQ(
+      PlanBuilder()
+          .tableScan("tmp", data)
+          .filter("c0 + 10 > 100")
           .planNode()
           ->toString(true, false),
-      "-- Project[1][expressions: (p0:VARCHAR, \"c0\")] -> p0:VARCHAR\n");
+      expectation);
+
+  using namespace velox::expr_builder;
+
+  // Filter with untyped expression (same expression as above).
   VELOX_CHECK_EQ(
       PlanBuilder()
-          .tableScan("tmp", ROW({"c0"}, {ROW({VARCHAR()})}))
-          .projectExpressions({std::make_shared<core::FieldAccessTypedExpr>(
-              VARCHAR(),
-              std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
-              "field0")})
+          .tableScan("tmp", data)
+          .filter(col("c0") + 10L > 100L)
           .planNode()
           ->toString(true, false),
-      "-- Project[1][expressions: (p0:VARCHAR, \"c0\"[\"field0\"])] -> p0:VARCHAR\n");
+      expectation);
+}
+
+TEST_F(PlanBuilderTest, commitStrategyParameter) {
+  auto data = makeRowVector({makeFlatVector<int64_t>(10, folly::identity)});
+  auto directory = "/some/test/directory";
+
+  // Lambda to create a plan with given commitStrategy and verify it
+  auto testCommitStrategy = [&](connector::CommitStrategy commitStrategy) {
+    // Create a plan with commitStrategy
+    auto planBuilder = PlanBuilder().values({data}).tableWrite(
+        directory,
+        {},
+        0,
+        {},
+        {},
+        dwio::common::FileFormat::DWRF,
+        {},
+        PlanBuilder::kHiveDefaultConnectorId,
+        {},
+        nullptr,
+        "",
+        common::CompressionKind_NONE,
+        nullptr,
+        false);
+
+    core::PlanNodePtr plan;
+    // Conditionally set commitStrategy if it's not kNoCommit
+    if (commitStrategy != connector::CommitStrategy::kNoCommit) {
+      plan = PlanBuilder::TableWriterBuilder(planBuilder)
+                 .commitStrategy(commitStrategy)
+                 .endTableWriter()
+                 .planNode();
+    } else {
+      plan = std::move(planBuilder.planNode());
+    }
+
+    // Verify the plan node has the correct commit strategy
+    auto tableWriteNode =
+        std::dynamic_pointer_cast<const core::TableWriteNode>(plan);
+    ASSERT_NE(tableWriteNode, nullptr);
+    ASSERT_EQ(tableWriteNode->commitStrategy(), commitStrategy);
+  };
+
+  // Test with explicit task commit strategy
+  testCommitStrategy(connector::CommitStrategy::kTaskCommit);
+
+  // Test with no explicit commit strategy (should default to kNoCommit)
+  testCommitStrategy(connector::CommitStrategy::kNoCommit);
+}
+
+TEST_F(PlanBuilderTest, indexLookupJoinBuilder) {
+  auto leftType = ROW({"t0", "t1"}, {BIGINT(), ARRAY(BIGINT())});
+  auto rightType = ROW({"u0", "u1"}, {BIGINT(), BIGINT()});
+
+  // Create a TestIndexTableHandle that supports index lookup
+  auto indexTableHandle = std::make_shared<TestIndexTableHandle>(
+      kTestIndexConnectorName, nullptr, false);
+
+  // Create column handles for the index table
+  connector::ColumnHandleMap columnHandles;
+  for (const auto& name : rightType->names()) {
+    columnHandles[name] = std::make_shared<TestIndexColumnHandle>(name);
+  }
+
+  auto rightScan = std::make_shared<core::TableScanNode>(
+      "right_scan", rightType, indexTableHandle, columnHandles);
+
+  auto plan = PlanBuilder(pool_.get())
+                  .tableScan(leftType)
+                  .startIndexLookupJoin()
+                  .leftKeys({"t0"})
+                  .rightKeys({"u0"})
+                  .indexSource(rightScan)
+                  .joinConditions({"contains(t1, u1)"})
+                  .hasMarker(false)
+                  .outputLayout({"t0", "u1"})
+                  .joinType(core::JoinType::kInner)
+                  .filter("t0 > 0")
+                  .endIndexLookupJoin()
+                  .planNode();
+
+  auto indexJoinNode =
+      std::dynamic_pointer_cast<const core::IndexLookupJoinNode>(plan);
+  ASSERT_NE(indexJoinNode, nullptr);
+  ASSERT_EQ(indexJoinNode->joinType(), core::JoinType::kInner);
+  ASSERT_EQ(indexJoinNode->leftKeys().size(), 1);
+  ASSERT_EQ(indexJoinNode->rightKeys().size(), 1);
+  ASSERT_EQ(indexJoinNode->leftKeys()[0]->name(), "t0");
+  ASSERT_EQ(indexJoinNode->rightKeys()[0]->name(), "u0");
+  ASSERT_EQ(indexJoinNode->joinConditions().size(), 1);
+  ASSERT_FALSE(indexJoinNode->hasMarker());
+  ASSERT_EQ(indexJoinNode->outputType()->names().size(), 2);
+  ASSERT_EQ(indexJoinNode->outputType()->names()[0], "t0");
+  ASSERT_EQ(indexJoinNode->outputType()->names()[1], "u1");
+  ASSERT_EQ(indexJoinNode->filter()->toString(), "gt(ROW[\"t0\"],0)");
+}
+
+TEST_F(PlanBuilderTest, insertTableHandleParameter) {
+  auto data = makeRowVector({makeFlatVector<int64_t>(10, folly::identity)});
+  auto directory = "/some/test/directory";
+
+  // Lambda to create a plan with given insertableHandle and verify it
+  auto testInsertTableHandle =
+      [&](std::shared_ptr<core::InsertTableHandle> insertTableHandle) {
+        // Create a plan with insertTableHandle
+        auto planBuilder = PlanBuilder().values({data}).tableWrite(
+            directory,
+            {},
+            0,
+            {},
+            {},
+            dwio::common::FileFormat::DWRF,
+            {},
+            PlanBuilder::kHiveDefaultConnectorId,
+            {},
+            nullptr,
+            "",
+            common::CompressionKind_NONE,
+            nullptr,
+            false,
+            connector::CommitStrategy::kNoCommit,
+            insertTableHandle);
+
+        // Verify the plan node has the correct insert Table Handle.
+        auto tableWriteNode =
+            std::dynamic_pointer_cast<const core::TableWriteNode>(
+                planBuilder.planNode());
+        ASSERT_NE(tableWriteNode, nullptr);
+        ASSERT_EQ(tableWriteNode->insertTableHandle(), insertTableHandle);
+      };
+
+  auto rowType = ROW({"c0", "c1", "c2"}, {BIGINT(), INTEGER(), SMALLINT()});
+  auto hiveHandle = HiveConnectorTestBase::makeHiveInsertTableHandle(
+      rowType->names(),
+      rowType->children(),
+      {rowType->names()[0]}, // partitionedBy
+      nullptr, // bucketProperty
+      HiveConnectorTestBase::makeLocationHandle(
+          "/path/to/test",
+          std::nullopt,
+          connector::hive::LocationHandle::TableType::kNew));
+
+  auto insertHandle = std::make_shared<core::InsertTableHandle>(
+      std::string(PlanBuilder::kHiveDefaultConnectorId), hiveHandle);
+  testInsertTableHandle(insertHandle);
 }
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PlanNodeSerdeTest.cpp b/velox/exec/tests/PlanNodeSerdeTest.cpp
index 54f5d77361bf..65d64c348f2f 100644
--- a/velox/exec/tests/PlanNodeSerdeTest.cpp
+++ b/velox/exec/tests/PlanNodeSerdeTest.cpp
@@ -13,12 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/TypeResolver.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <gtest/gtest.h>
 
@@ -38,12 +41,7 @@ class PlanNodeSerdeTest : public testing::Test,
 
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveInsertFileNameGenerator::registerSerDe();
-    connector::hive::registerHivePartitionFunctionSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
@@ -52,6 +50,11 @@ class PlanNodeSerdeTest : public testing::Test,
         makeFlatVector<int64_t>({1, 2, 3}),
         makeFlatVector<int32_t>({10, 20, 30}),
         makeConstant(true, 3),
+        makeArrayVector<int32_t>({
+            {1, 2},
+            {3, 4, 5},
+            {},
+        }),
     })};
   }
 
@@ -83,6 +86,26 @@ class PlanNodeSerdeTest : public testing::Test,
     }
   }
 
+  void topNRankSerdeTest(std::string_view function) {
+    auto plan = PlanBuilder()
+                    .values({data_})
+                    .topNRank(function, {}, {"c0", "c2"}, 10, false)
+                    .planNode();
+    testSerde(plan);
+
+    plan = PlanBuilder()
+               .values({data_})
+               .topNRank(function, {}, {"c0", "c2"}, 10, true)
+               .planNode();
+    testSerde(plan);
+
+    plan = PlanBuilder()
+               .values({data_})
+               .topNRank(function, {"c0"}, {"c1", "c2"}, 10, false)
+               .planNode();
+    testSerde(plan);
+  }
+
   std::vector<RowVectorPtr> data_;
 };
 
@@ -95,6 +118,14 @@ TEST_F(PlanNodeSerdeTest, aggregation) {
 
   testSerde(plan);
 
+  plan = PlanBuilder(pool_.get())
+             .values({data_})
+             .partialAggregation({"c0"}, {"count(ARRAY[1, 2])"})
+             .finalAggregation()
+             .planNode();
+
+  testSerde(plan);
+
   // Aggregation over sorted inputs.
   plan = PlanBuilder()
              .values({data_})
@@ -210,6 +241,12 @@ TEST_F(PlanNodeSerdeTest, exchange) {
 TEST_F(PlanNodeSerdeTest, filter) {
   auto plan = PlanBuilder().values({data_}).filter("c0 > 100").planNode();
   testSerde(plan);
+
+  plan = PlanBuilder(pool_.get())
+             .values({data_})
+             .filter("c3 = ARRAY[1,2,3]")
+             .planNode();
+  testSerde(plan);
 }
 
 TEST_F(PlanNodeSerdeTest, groupId) {
@@ -305,11 +342,16 @@ TEST_F(PlanNodeSerdeTest, localMerge) {
 
 TEST_F(PlanNodeSerdeTest, mergeJoin) {
   auto probe = makeRowVector(
-      {"t0", "t1", "t2"},
+      {"t0", "t1", "t2", "t3"},
       {
           makeFlatVector<int32_t>({1, 2, 3}),
           makeFlatVector<int64_t>({10, 20, 30}),
           makeFlatVector<bool>({true, true, false}),
+          makeArrayVector<int32_t>({
+              {1, 2},
+              {3, 4, 5},
+              {},
+          }),
       });
 
   auto build = makeRowVector(
@@ -335,6 +377,19 @@ TEST_F(PlanNodeSerdeTest, mergeJoin) {
 
   testSerde(plan);
 
+  plan = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .values({probe})
+             .mergeJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+                 "t3 = ARRAY[1,2,3]",
+                 {"t0", "t1", "u2", "t2"},
+                 core::JoinType::kInner)
+             .planNode();
+
+  testSerde(plan);
+
   plan = PlanBuilder(planNodeIdGenerator)
              .values({probe})
              .mergeJoin(
@@ -401,13 +456,35 @@ TEST_F(PlanNodeSerdeTest, project) {
   testSerde(plan);
 }
 
+TEST_F(PlanNodeSerdeTest, parallelProjet) {
+  auto plan = PlanBuilder()
+                  .values({data_})
+                  .parallelProject({{"c0 + 1", "c0 * 2"}, {"c1 + 1", "c1 * 2"}})
+                  .planNode();
+
+  testSerde(plan);
+
+  plan = PlanBuilder()
+             .values({data_})
+             .parallelProject(
+                 {{"c0 + 1", "c0 * 2"}, {"c1 + 1", "c1 * 2"}}, {"c2", "c3"})
+             .planNode();
+
+  testSerde(plan);
+}
+
 TEST_F(PlanNodeSerdeTest, hashJoin) {
   auto probe = makeRowVector(
-      {"t0", "t1", "t2"},
+      {"t0", "t1", "t2", "t3"},
       {
           makeFlatVector<int32_t>({1, 2, 3}),
           makeFlatVector<int64_t>({10, 20, 30}),
           makeFlatVector<bool>({true, true, false}),
+          makeArrayVector<int32_t>({
+              {1, 2},
+              {3, 4, 5},
+              {},
+          }),
       });
 
   auto build = makeRowVector(
@@ -433,6 +510,19 @@ TEST_F(PlanNodeSerdeTest, hashJoin) {
 
   testSerde(plan);
 
+  plan = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .values({probe})
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+                 "t3 = ARRAY[1,2,3]",
+                 {"t0", "t1", "u2", "t2"},
+                 core::JoinType::kInner)
+             .planNode();
+
+  testSerde(plan);
+
   plan = PlanBuilder(planNodeIdGenerator)
              .values({probe})
              .hashJoin(
@@ -482,6 +572,12 @@ TEST_F(PlanNodeSerdeTest, unnest) {
   plan =
       PlanBuilder().values({data}).unnest({"c0"}, {"c1"}, "ordinal").planNode();
   testSerde(plan);
+
+  plan = PlanBuilder()
+             .values({data})
+             .unnest({"c0"}, {"c1"}, "ordinal", "emptyUnnestValue")
+             .planNode();
+  testSerde(plan);
 }
 
 TEST_F(PlanNodeSerdeTest, values) {
@@ -561,34 +657,56 @@ TEST_F(PlanNodeSerdeTest, rowNumber) {
 }
 
 TEST_F(PlanNodeSerdeTest, scan) {
-  auto plan = PlanBuilder(pool_.get())
-                  .tableScan(
-                      ROW({"a", "b", "c", "d"},
-                          {BIGINT(), BIGINT(), BOOLEAN(), DOUBLE()}),
-                      {"a < 5", "b = 7", "c = true", "d > 0.01"},
-                      "a + b < 100")
-                  .planNode();
-  testSerde(plan);
+  {
+    auto plan = PlanBuilder(pool_.get())
+                    .tableScan(
+                        ROW({"a", "b", "c", "d"},
+                            {BIGINT(), BIGINT(), BOOLEAN(), DOUBLE()}),
+                        {"a < 5", "b = 7", "c = true", "d > 0.01"},
+                        "a + b < 100")
+                    .planNode();
+    testSerde(plan);
+  }
+
+  {
+    auto plan =
+        PlanBuilder()
+            .startTableScan()
+            .outputType(ROW({"x"}, {BIGINT()}))
+            .assignments(
+                {{"x", HiveConnectorTestBase::regularColumn("a", BIGINT())}})
+            .dataColumns(ROW({"a", "b"}, {BIGINT(), BIGINT()}))
+            .filterColumnHandles({
+                HiveConnectorTestBase::partitionKey("ds", VARCHAR()),
+                HiveConnectorTestBase::regularColumn("a", BIGINT()),
+            })
+            .remainingFilter("length(ds) + a % 2 > 0")
+            .endTableScan()
+            .planNode();
+    testSerde(plan);
+  }
+
+  {
+    auto plan = PlanBuilder()
+                    .startTableScan()
+                    .outputType(ROW({"x"}, {BIGINT()}))
+                    .sampleRate(0.5)
+                    .endTableScan()
+                    .planNode();
+    testSerde(plan);
+  }
 }
 
 TEST_F(PlanNodeSerdeTest, topNRowNumber) {
-  auto plan = PlanBuilder()
-                  .values({data_})
-                  .topNRowNumber({}, {"c0", "c2"}, 10, false)
-                  .planNode();
-  testSerde(plan);
+  topNRankSerdeTest("row_number");
+}
 
-  plan = PlanBuilder()
-             .values({data_})
-             .topNRowNumber({}, {"c0", "c2"}, 10, true)
-             .planNode();
-  testSerde(plan);
+TEST_F(PlanNodeSerdeTest, topNRank) {
+  topNRankSerdeTest("rank");
+}
 
-  plan = PlanBuilder()
-             .values({data_})
-             .topNRowNumber({"c0"}, {"c1", "c2"}, 10, false)
-             .planNode();
-  testSerde(plan);
+TEST_F(PlanNodeSerdeTest, topNDenseRank) {
+  topNRankSerdeTest("dense_rank");
 }
 
 TEST_F(PlanNodeSerdeTest, write) {
@@ -617,7 +735,17 @@ TEST_F(PlanNodeSerdeTest, tableWriteMerge) {
 
   plan = PlanBuilder(pool_.get())
              .values(data_)
-             .tableWrite("targetDirectory")
+             .tableWrite(
+                 "targetDirectory", dwio::common::FileFormat::DWRF, {"min(c0)"})
+             .localPartition(std::vector<std::string>{})
+             .tableWriteMerge()
+             .planNode();
+  testSerde(plan);
+
+  plan = PlanBuilder(pool_.get())
+             .values(data_)
+             .tableWrite(
+                 "targetDirectory", dwio::common::FileFormat::DWRF, {"min(c0)"})
              .localPartition(std::vector<std::string>{})
              .tableWriteMerge()
              .planNode();
@@ -638,8 +766,233 @@ TEST_F(PlanNodeSerdeTest, tableWriteWithStats) {
                        "approx_distinct(c2)",
                        "sum_data_size_for_stats(c2)",
                        "max_data_size_for_stats(c2)"})
+                  .localPartition(std::vector<std::string>{})
+                  .tableWriteMerge()
                   .planNode();
   testSerde(plan);
 }
 
+TEST_F(PlanNodeSerdeTest, columnStatsSpec) {
+  // Helper function to create typed expressions
+  const auto createFieldAccess = [&](const std::string& name,
+                                     const TypePtr& type) {
+    return std::make_shared<core::FieldAccessTypedExpr>(type, name);
+  };
+
+  const auto createCallExpr = [&](const std::string& name,
+                                  const TypePtr& returnType,
+                                  const std::vector<core::TypedExprPtr>& args) {
+    return std::make_shared<core::CallTypedExpr>(returnType, args, name);
+  };
+
+  // Test 1: Empty ColumnStatsSpec
+  {
+    VELOX_ASSERT_THROW(
+        std::make_unique<core::ColumnStatsSpec>(
+            std::vector<core::FieldAccessTypedExprPtr>{},
+            core::AggregationNode::Step::kSingle,
+            std::vector<std::string>{},
+            std::vector<core::AggregationNode::Aggregate>{}),
+        "");
+  }
+
+  // Test 2: ColumnStatsSpec with only aggregates (no grouping keys)
+  {
+    std::vector<core::FieldAccessTypedExprPtr> groupingKeys;
+    std::vector<std::string> aggregateNames = {"min", "max", "count"};
+    std::vector<core::AggregationNode::Aggregate> aggregates;
+
+    // Create min(c0) aggregate
+    auto minInput = createFieldAccess("c0", BIGINT());
+    auto minCall = createCallExpr("min", BIGINT(), {minInput});
+    aggregates.push_back({minCall, {BIGINT()}, nullptr, {}, {}, false});
+
+    // Create max(c0) aggregate
+    auto maxInput = createFieldAccess("c0", BIGINT());
+    auto maxCall = createCallExpr("max", BIGINT(), {maxInput});
+    aggregates.push_back({maxCall, {BIGINT()}, nullptr, {}, {}, false});
+
+    // Create count(c1) aggregate
+    auto countInput = createFieldAccess("c1", INTEGER());
+    auto countCall = createCallExpr("count", BIGINT(), {countInput});
+    aggregates.push_back({countCall, {INTEGER()}, nullptr, {}, {}, false});
+
+    core::ColumnStatsSpec spec(
+        std::move(groupingKeys),
+        core::AggregationNode::Step::kPartial,
+        std::move(aggregateNames),
+        std::move(aggregates));
+
+    auto serialized = spec.serialize();
+    auto deserialized = core::ColumnStatsSpec::create(serialized, pool());
+
+    EXPECT_TRUE(deserialized.groupingKeys.empty());
+    EXPECT_EQ(deserialized.aggregateNames.size(), 3);
+    EXPECT_EQ(deserialized.aggregates.size(), 3);
+    EXPECT_EQ(
+        deserialized.aggregationStep, core::AggregationNode::Step::kPartial);
+    EXPECT_EQ(deserialized.aggregateNames.size(), 3);
+
+    EXPECT_EQ(deserialized.aggregateNames[0], "min");
+    EXPECT_EQ(deserialized.aggregateNames[1], "max");
+    EXPECT_EQ(deserialized.aggregateNames[2], "count");
+    EXPECT_EQ(deserialized.aggregates[0].call->name(), "min");
+    EXPECT_EQ(deserialized.aggregates[1].call->name(), "max");
+    EXPECT_EQ(deserialized.aggregates[2].call->name(), "count");
+  }
+
+  // Test 3: ColumnStatsSpec with grouping keys and aggregates
+  {
+    std::vector<core::FieldAccessTypedExprPtr> groupingKeys;
+    groupingKeys.push_back(createFieldAccess("partition_key", VARCHAR()));
+    groupingKeys.push_back(createFieldAccess("bucket_id", INTEGER()));
+
+    std::vector<std::string> aggregateNames = {"min", "sum"};
+    std::vector<core::AggregationNode::Aggregate> aggregates;
+
+    // Create min(c0) aggregate
+    auto minInput = createFieldAccess("c0", BIGINT());
+    auto minCall = createCallExpr("min", BIGINT(), {minInput});
+    aggregates.push_back({minCall, {BIGINT()}, nullptr, {}, {}, false});
+
+    // Create sum(c1) aggregate
+    auto sumInput = createFieldAccess("c1", DOUBLE());
+    auto sumCall = createCallExpr("sum", DOUBLE(), {sumInput});
+    aggregates.push_back({sumCall, {DOUBLE()}, nullptr, {}, {}, false});
+
+    core::ColumnStatsSpec spec(
+        std::move(groupingKeys),
+        core::AggregationNode::Step::kIntermediate,
+        std::move(aggregateNames),
+        std::move(aggregates));
+
+    auto serialized = spec.serialize();
+    auto deserialized = core::ColumnStatsSpec::create(serialized, pool());
+
+    EXPECT_EQ(deserialized.groupingKeys.size(), 2);
+    EXPECT_EQ(deserialized.aggregateNames.size(), 2);
+    EXPECT_EQ(deserialized.aggregates.size(), 2);
+    EXPECT_EQ(
+        deserialized.aggregationStep,
+        core::AggregationNode::Step::kIntermediate);
+    EXPECT_EQ(deserialized.aggregateNames.size(), 2);
+
+    EXPECT_EQ(deserialized.groupingKeys[0]->name(), "partition_key");
+    EXPECT_EQ(deserialized.groupingKeys[0]->type(), VARCHAR());
+    EXPECT_EQ(deserialized.groupingKeys[1]->name(), "bucket_id");
+    EXPECT_EQ(deserialized.groupingKeys[1]->type(), INTEGER());
+
+    EXPECT_EQ(deserialized.aggregateNames[0], "min");
+    EXPECT_EQ(deserialized.aggregateNames[1], "sum");
+    EXPECT_EQ(deserialized.aggregates[0].call->name(), "min");
+    EXPECT_EQ(deserialized.aggregates[1].call->name(), "sum");
+  }
+
+  // Test 4: ColumnStatsSpec with different aggregation steps
+  for (auto step :
+       {core::AggregationNode::Step::kSingle,
+        core::AggregationNode::Step::kPartial,
+        core::AggregationNode::Step::kIntermediate,
+        core::AggregationNode::Step::kFinal}) {
+    std::vector<core::FieldAccessTypedExprPtr> groupingKeys;
+    std::vector<std::string> aggregateNames = {"count"};
+    std::vector<core::AggregationNode::Aggregate> aggregates;
+
+    auto countInput = createFieldAccess("test_col", BIGINT());
+    auto countCall = createCallExpr("count", BIGINT(), {countInput});
+    aggregates.push_back({countCall, {BIGINT()}, nullptr, {}, {}, false});
+
+    core::ColumnStatsSpec spec(
+        std::move(groupingKeys),
+        step,
+        std::move(aggregateNames),
+        std::move(aggregates));
+
+    auto serialized = spec.serialize();
+    auto deserialized = core::ColumnStatsSpec::create(serialized, pool());
+
+    EXPECT_EQ(deserialized.aggregationStep, step);
+    EXPECT_EQ(deserialized.aggregateNames.size(), 1);
+    EXPECT_EQ(deserialized.aggregateNames[0], "count");
+  }
+
+  // Test 5: ColumnStatsSpec with complex aggregates (distinct, with mask, with
+  // sorting)
+  {
+    std::vector<core::FieldAccessTypedExprPtr> groupingKeys;
+    std::vector<std::string> aggregateNames = {
+        "count_distinct", "array_agg_sorted"};
+    std::vector<core::AggregationNode::Aggregate> aggregates;
+
+    // Create count(distinct c0) aggregate
+    auto distinctInput = createFieldAccess("c0", VARCHAR());
+    auto countDistinctCall = createCallExpr("count", BIGINT(), {distinctInput});
+    auto maskField = createFieldAccess("mask_col", BOOLEAN());
+    aggregates.push_back(
+        {countDistinctCall, {VARCHAR()}, maskField, {}, {}, true});
+
+    // Create array_agg(c1 ORDER BY c2) aggregate
+    auto arrayInput = createFieldAccess("c1", INTEGER());
+    auto arrayAggCall =
+        createCallExpr("array_agg", ARRAY(INTEGER()), {arrayInput});
+    auto sortingKey = createFieldAccess("c2", BIGINT());
+    std::vector<core::FieldAccessTypedExprPtr> sortingKeys = {sortingKey};
+    std::vector<core::SortOrder> sortingOrders = {core::SortOrder(true, true)};
+    aggregates.push_back(
+        {arrayAggCall,
+         {INTEGER()},
+         nullptr,
+         sortingKeys,
+         sortingOrders,
+         false});
+
+    core::ColumnStatsSpec spec(
+        std::move(groupingKeys),
+        core::AggregationNode::Step::kSingle,
+        std::move(aggregateNames),
+        std::move(aggregates));
+
+    auto serialized = spec.serialize();
+    auto deserialized = core::ColumnStatsSpec::create(serialized, pool());
+
+    EXPECT_EQ(deserialized.aggregates.size(), 2);
+
+    // Check distinct aggregate
+    EXPECT_TRUE(deserialized.aggregates[0].distinct);
+    EXPECT_NE(deserialized.aggregates[0].mask, nullptr);
+    EXPECT_EQ(deserialized.aggregates[0].mask->name(), "mask_col");
+
+    // Check sorted aggregate
+    EXPECT_FALSE(deserialized.aggregates[1].distinct);
+    EXPECT_EQ(deserialized.aggregates[1].mask, nullptr);
+    EXPECT_EQ(deserialized.aggregates[1].sortingKeys.size(), 1);
+    EXPECT_EQ(deserialized.aggregates[1].sortingKeys[0]->name(), "c2");
+    EXPECT_EQ(deserialized.aggregates[1].sortingOrders.size(), 1);
+    EXPECT_TRUE(deserialized.aggregates[1].sortingOrders[0].isAscending());
+    EXPECT_TRUE(deserialized.aggregates[1].sortingOrders[0].isNullsFirst());
+  }
+
+  // Error cases.
+  {
+    std::vector<core::FieldAccessTypedExprPtr> groupingKeys;
+    groupingKeys.push_back(createFieldAccess("partition_key", VARCHAR()));
+    groupingKeys.push_back(createFieldAccess("bucket_id", INTEGER()));
+
+    std::vector<std::string> aggregateNames = {"min", "sum"};
+    std::vector<core::AggregationNode::Aggregate> aggregates;
+
+    // Create min(c0) aggregate
+    auto minInput = createFieldAccess("c0", BIGINT());
+    auto minCall = createCallExpr("min", BIGINT(), {minInput});
+    aggregates.push_back({minCall, {BIGINT()}, nullptr, {}, {}, false});
+    VELOX_ASSERT_THROW(
+        core::ColumnStatsSpec(
+            std::move(groupingKeys),
+            core::AggregationNode::Step::kSingle,
+            std::move(aggregateNames),
+            std::move(aggregates)),
+        "");
+  }
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PlanNodeStatsTest.cpp b/velox/exec/tests/PlanNodeStatsTest.cpp
new file mode 100644
index 000000000000..2a59537eb430
--- /dev/null
+++ b/velox/exec/tests/PlanNodeStatsTest.cpp
@@ -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 "velox/exec/PlanNodeStats.h"
+#include <gtest/gtest.h>
+
+namespace facebook::velox::exec::test {
+
+TEST(PlanNodeStatsTest, exprStatsTotal) {
+  PlanNodeStats stats;
+  stats.expressionStats["foo"] = ExprStats{
+      .timing = {.wallNanos = 1, .cpuNanos = 2},
+      .numProcessedRows = 3,
+      .numProcessedVectors = 4};
+
+  PlanNodeStats total;
+  total += stats;
+  EXPECT_EQ(total.expressionStats["foo"], stats.expressionStats["foo"]);
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PlanNodeToStringTest.cpp b/velox/exec/tests/PlanNodeToStringTest.cpp
index 0619aabb6c47..334c35127db8 100644
--- a/velox/exec/tests/PlanNodeToStringTest.cpp
+++ b/velox/exec/tests/PlanNodeToStringTest.cpp
@@ -14,21 +14,21 @@
  * limitations under the License.
  */
 
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/WindowFunction.h"
-#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/TypeResolver.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
 #include <gtest/gtest.h>
 
-using namespace facebook;
-using namespace facebook::velox;
-using namespace facebook::velox::common::test;
-
 using facebook::velox::exec::test::PlanBuilder;
 
+namespace facebook::velox::exec {
+namespace {
+
 class PlanNodeToStringTest : public testing::Test,
                              public velox::test::VectorTestBase {
  public:
@@ -75,25 +75,25 @@ TEST_F(PlanNodeToStringTest, recursive) {
 
 TEST_F(PlanNodeToStringTest, detailed) {
   ASSERT_EQ(
-      "-- Project[4][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[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"
+      "-- 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));
 }
 
 TEST_F(PlanNodeToStringTest, withContext) {
   auto addContext = [](const core::PlanNodeId& planNodeId,
-                       const std::string& /* indentation */,
-                       std::stringstream& stream) {
-    stream << "Context for " << planNodeId;
+                       const std::string& indentation,
+                       std::ostream& stream) {
+    stream << indentation << "Context for " << planNodeId << std::endl;
   };
 
   ASSERT_EQ(
@@ -102,7 +102,7 @@ TEST_F(PlanNodeToStringTest, withContext) {
       plan_->toString(false, false, addContext));
 
   ASSERT_EQ(
-      "-- Project[4][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));
 
@@ -120,13 +120,13 @@ TEST_F(PlanNodeToStringTest, withContext) {
       plan_->toString(false, true, addContext));
 
   ASSERT_EQ(
-      "-- Project[4][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[3][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[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"
+      "    -- 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[1][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[0][5 rows in 1 vectors] -> c0:SMALLINT, c1:INTEGER, c2:BIGINT\n"
       "           Context for 0\n",
@@ -136,9 +136,11 @@ TEST_F(PlanNodeToStringTest, withContext) {
 TEST_F(PlanNodeToStringTest, withMultiLineContext) {
   auto addContext = [](const core::PlanNodeId& planNodeId,
                        const std::string& indentation,
-                       std::stringstream& stream) {
-    stream << "Context for " << planNodeId << ": line 1" << std::endl;
-    stream << indentation << "Context for " << planNodeId << ": line 2";
+                       std::ostream& stream) {
+    stream << indentation << "Context for " << planNodeId << ": line 1"
+           << std::endl;
+    stream << indentation << "Context for " << planNodeId << ": line 2"
+           << std::endl;
   };
 
   ASSERT_EQ(
@@ -148,7 +150,7 @@ TEST_F(PlanNodeToStringTest, withMultiLineContext) {
       plan_->toString(false, false, addContext));
 
   ASSERT_EQ(
-      "-- Project[4][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));
@@ -755,7 +757,7 @@ TEST_F(PlanNodeToStringTest, tableScan) {
         "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)], "
-        "remaining filter: (not(like(ROW[\"comment\"],\"%special%request%\")))] "
+        "remaining filter: (not(like(ROW[\"comment\"],%special%request%)))] "
         "-> discount:DOUBLE, quantity:DOUBLE, shipdate:VARCHAR, comment:VARCHAR\n";
     ASSERT_EQ(output, plan->toString(true, false));
   }
@@ -766,7 +768,7 @@ TEST_F(PlanNodeToStringTest, tableScan) {
             .planNode();
 
     ASSERT_EQ(
-        "-- TableScan[0][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));
   }
@@ -927,38 +929,58 @@ TEST_F(PlanNodeToStringTest, rowNumber) {
       plan->toString(true, false));
 }
 
-TEST_F(PlanNodeToStringTest, topNRowNumber) {
+namespace {
+void topNRankPlanNodeToStringTest(std::string_view function) {
   auto rowType = ROW({"a", "b"}, {BIGINT(), VARCHAR()});
   auto plan = PlanBuilder()
                   .tableScan(rowType)
-                  .topNRowNumber({}, {"a DESC"}, 10, false)
+                  .topNRank(function, {}, {"a DESC"}, 10, false)
                   .planNode();
 
   ASSERT_EQ("-- TopNRowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- TopNRowNumber[1][order by (a DESC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR\n",
+      fmt::format(
+          "-- TopNRowNumber[1][{} order by (a DESC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR\n",
+          function),
       plan->toString(true, false));
 
   plan = PlanBuilder()
              .tableScan(rowType)
-             .topNRowNumber({}, {"a DESC"}, 10, true)
+             .topNRank(function, {}, {"a DESC"}, 10, true)
              .planNode();
 
   ASSERT_EQ("-- TopNRowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- TopNRowNumber[1][order by (a DESC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR, row_number:BIGINT\n",
+      fmt::format(
+          "-- TopNRowNumber[1][{} order by (a DESC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR, row_number:BIGINT\n",
+          function),
       plan->toString(true, false));
 
   plan = PlanBuilder()
              .tableScan(rowType)
-             .topNRowNumber({"a"}, {"b"}, 10, false)
+             .topNRank(function, {"a"}, {"b"}, 10, false)
              .planNode();
 
   ASSERT_EQ("-- TopNRowNumber[1]\n", plan->toString());
   ASSERT_EQ(
-      "-- TopNRowNumber[1][partition by (a) order by (b ASC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR\n",
+      fmt::format(
+          "-- TopNRowNumber[1][{} partition by (a) order by (b ASC NULLS LAST) limit 10] -> a:BIGINT, b:VARCHAR\n",
+          function),
       plan->toString(true, false));
 }
+} // namespace
+
+TEST_F(PlanNodeToStringTest, topNRowNumber) {
+  topNRankPlanNodeToStringTest("row_number");
+}
+
+TEST_F(PlanNodeToStringTest, topNRank) {
+  topNRankPlanNodeToStringTest("rank");
+}
+
+TEST_F(PlanNodeToStringTest, topNDenseRank) {
+  topNRankPlanNodeToStringTest("dense_rank");
+}
 
 TEST_F(PlanNodeToStringTest, markDistinct) {
   auto op =
@@ -971,3 +993,6 @@ TEST_F(PlanNodeToStringTest, markDistinct) {
       "-- MarkDistinct[1][a, b] -> a:VARCHAR, b:BIGINT, c:BIGINT, marker:BOOLEAN\n",
       op->toString(true, false));
 }
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/PlanNodeToSummaryStringTest.cpp b/velox/exec/tests/PlanNodeToSummaryStringTest.cpp
index 2a726e2988bc..4338c3cd1981 100644
--- a/velox/exec/tests/PlanNodeToSummaryStringTest.cpp
+++ b/velox/exec/tests/PlanNodeToSummaryStringTest.cpp
@@ -20,6 +20,7 @@
 #include "velox/parse/TypeResolver.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using facebook::velox::exec::test::PlanBuilder;
@@ -39,6 +40,13 @@ class PlanNodeToSummaryStringTest : public testing::Test,
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
+
+  static std::vector<std::string> toLines(const std::string& planText) {
+    std::vector<std::string> lines;
+    folly::split("\n", planText, lines);
+
+    return lines;
+  }
 };
 
 TEST_F(PlanNodeToSummaryStringTest, basic) {
@@ -64,12 +72,11 @@ TEST_F(PlanNodeToSummaryStringTest, basic) {
       "      functions: plus: 3, subscript: 6\n"
       "      constants: BIGINT: 9\n"
       "      projections: 7 out of 7\n"
-      "      dereferences: 0 out of 7\n"
       "  -- Filter[1]: 3 fields: a INTEGER, b ARRAY, c MAP\n"
       "        expressions: call: 8, cast: 2, constant: 5, field: 3\n"
       "        functions: and: 2, cardinality: 1, gt: 3, plus: 1, subscript: 1\n"
       "        constants: BIGINT: 5\n"
-      "        filter: and(and(gt(cast ROW[\"a\"] as BIGINT,10),gt(cardinal...\n"
+      "        filter: and(and(gt(cast(ROW[\"a\"] as BIGINT),10),gt(cardina...\n"
       "    -- TableScan[0]: 3 fields: a INTEGER, b ARRAY, c MAP\n"
       "          table: hive_table\n",
       plan->toSummaryString());
@@ -80,15 +87,14 @@ TEST_F(PlanNodeToSummaryStringTest, basic) {
       "      functions: plus: 3, subscript: 6\n"
       "      constants: BIGINT: 9\n"
       "      projections: 7 out of 7\n"
-      "         p0: plus(cast ROW[\"a\"] as BIGINT,1)\n"
-      "         p1: subscript(ROW[\"b\"],cast 1 as INTEGER)\n"
+      "         p0: plus(cast(ROW[\"a\"] as BIGINT),1)\n"
+      "         p1: subscript(ROW[\"b\"],cast(1 as INTEGER))\n"
       "         ... 5 more\n"
-      "      dereferences: 0 out of 7\n"
       "  -- Filter[1]: 3 fields: a INTEGER, b ARRAY(BIGINT), c MAP(TINYINT, BIGINT)\n"
       "        expressions: call: 8, cast: 2, constant: 5, field: 3\n"
       "        functions: and: 2, cardinality: 1, gt: 3, plus: 1, subscript: 1\n"
       "        constants: BIGINT: 5\n"
-      "        filter: and(and(gt(cast ROW[\"a\"] as BIGINT,10),gt(cardinal...\n"
+      "        filter: and(and(gt(cast(ROW[\"a\"] as BIGINT),10),gt(cardina...\n"
       "    -- TableScan[0]: 3 fields: a INTEGER, b ARRAY(BIGINT), c MAP(TINYINT, BIGINT)\n"
       "          table: hive_table\n",
       plan->toSummaryString({
@@ -96,6 +102,14 @@ TEST_F(PlanNodeToSummaryStringTest, basic) {
           .maxOutputFields = 3,
           .maxChildTypes = 2,
       }));
+
+  ASSERT_THAT(
+      toLines(plan->toSkeletonString()),
+      testing::ElementsAre(
+          testing::Eq("-- Filter[1]: 3 fields"),
+          testing::Eq("  -- TableScan[0]: 3 fields"),
+          testing::Eq("        table: hive_table"),
+          testing::Eq("")));
 }
 
 TEST_F(PlanNodeToSummaryStringTest, expressions) {
@@ -118,47 +132,56 @@ TEST_F(PlanNodeToSummaryStringTest, expressions) {
                       "d.y",
                       "length(d.z) * strpos(d.z, 'foo')",
                       "12.345",
+                      "ceil(cast(a as real))",
                   })
                   .planNode();
 
   ASSERT_EQ(
-      "-- Project[1]: 7 fields: a INTEGER, p1 ARRAY, c MAP, p3 BIGINT, y BIGINT, ...\n"
-      "      expressions: call: 6, constant: 4, dereference: 4, field: 8, lambda: 1\n"
-      "      functions: length: 1, multiply: 2, plus: 1, strpos: 1, transform: 1\n"
+      "-- Project[1]: 8 fields: a INTEGER, p1 ARRAY, c MAP, p3 BIGINT, y BIGINT, ...\n"
+      "      expressions: call: 7, cast: 1, constant: 4, dereference: 4, field: 7, lambda: 1\n"
+      "      functions: ceil: 1, length: 1, multiply: 2, plus: 1, strpos: 1, transform: 1\n"
       "      constants: BIGINT: 2, DOUBLE: 1, VARCHAR: 1\n"
-      "      projections: 4 out of 7\n"
-      "      dereferences: 1 out of 7\n"
+      "      projections: 4 out of 8\n"
+      "      dereferences: 1 out of 8\n"
+      "      constant projections: 1 out of 8\n"
       "  -- TableScan[0]: 4 fields: a INTEGER, b ARRAY, c MAP, d ROW(3)\n"
       "        table: hive_table\n",
       plan->toSummaryString());
 
   ASSERT_EQ(
-      "-- Project[1]: 7 fields: a INTEGER, p1 ARRAY, c MAP, p3 BIGINT, y BIGINT, ...\n"
-      "      expressions: call: 6, constant: 4, dereference: 4, field: 8, lambda: 1\n"
-      "      functions: length: 1, multiply: 2, plus: 1, strpos: 1, transform: 1\n"
+      "-- Project[1]: 8 fields: a INTEGER, p1 ARRAY, c MAP, p3 BIGINT, y BIGINT, ...\n"
+      "      expressions: call: 7, cast: 1, constant: 4, dereference: 4, field: 7, lambda: 1\n"
+      "      functions: ceil: 1, length: 1, multiply: 2, plus: 1, strpos: 1, transform: 1\n"
       "      constants: BIGINT: 2, DOUBLE: 1, VARCHAR: 1\n"
-      "      projections: 4 out of 7\n"
+      "      projections: 4 out of 8\n"
       "         p1: transform(ROW[\"b\"],lambda ROW<x:BIGINT> -> plus(RO...\n"
       "         p3: multiply(ROW[\"d\"][x],10)\n"
-      "         p5: multiply(length(ROW[\"d\"][z]),strpos(ROW[\"d\"][z],\"f...\n"
+      "         p5: multiply(length(ROW[\"d\"][z]),strpos(ROW[\"d\"][z],fo...\n"
       "         ... 1 more\n"
-      "      dereferences: 1 out of 7\n"
+      "      dereferences: 1 out of 8\n"
       "         y: ROW[\"d\"][y]\n"
+      "      constant projections: 1 out of 8\n"
+      "         p6: 12.345\n"
       "  -- TableScan[0]: 4 fields: a INTEGER, b ARRAY, c MAP, d ROW(3)\n"
       "        table: hive_table\n",
       plan->toSummaryString(
-          {.project = {.maxProjections = 3, .maxDereferences = 2}}));
+          {.project = {
+               .maxProjections = 3,
+               .maxDereferences = 2,
+               .maxConstants = 1,
+           }}));
+
+  ASSERT_THAT(
+      toLines(plan->toSkeletonString()),
+      testing::ElementsAre(
+          testing::Eq("-- TableScan[0]: 4 fields"),
+          testing::Eq("      table: hive_table"),
+          testing::Eq("")));
 }
 
 TEST_F(PlanNodeToSummaryStringTest, aggregation) {
   aggregate::prestosql::registerAllAggregateFunctions();
-  auto rowType =
-      ROW({"a", "b", "c"},
-          {
-              INTEGER(),
-              INTEGER(),
-              INTEGER(),
-          });
+  auto rowType = ROW({"a", "b", "c"}, {INTEGER(), INTEGER(), INTEGER()});
 
   auto plan = PlanBuilder()
                   .tableScan(rowType)
@@ -189,7 +212,46 @@ TEST_F(PlanNodeToSummaryStringTest, aggregation) {
       "  -- TableScan[0]: 3 fields: a INTEGER, b INTEGER, c INTEGER\n"
       "        table: hive_table\n",
       plan->toSummaryString({.aggregate = {.maxAggregations = 3}}));
+
+  ASSERT_THAT(
+      toLines(plan->toSkeletonString()),
+      testing::ElementsAre(
+          testing::Eq("-- Aggregation[1]: 6 fields"),
+          testing::Eq("  -- TableScan[0]: 3 fields"),
+          testing::Eq("        table: hive_table"),
+          testing::Eq("")));
 }
 
+TEST_F(PlanNodeToSummaryStringTest, withContext) {
+  auto plan = PlanBuilder()
+                  .tableScan(ROW({"a", "b", "c"}, INTEGER()))
+                  .project({"a + b", "a * c"})
+                  .filter("p0 > p1")
+                  .planNode();
+
+  auto addContext = [](const PlanNodeId& planNodeId,
+                       const std::string& indentation,
+                       std::ostream& stream) {
+    stream << indentation << "Context for " << planNodeId << std::endl;
+  };
+
+  ASSERT_THAT(
+      toLines(plan->toSummaryString({}, addContext)),
+      testing::ElementsAre(
+          testing::StartsWith("-- Filter[2]"),
+          testing::StartsWith("      expressions:"),
+          testing::StartsWith("      functions:"),
+          testing::StartsWith("      filter:"),
+          testing::StartsWith("      Context for 2"),
+          testing::StartsWith("  -- Project[1]"),
+          testing::StartsWith("        expressions:"),
+          testing::StartsWith("        functions:"),
+          testing::StartsWith("        projections:"),
+          testing::StartsWith("        Context for 1"),
+          testing::StartsWith("    -- TableScan[0]"),
+          testing::StartsWith("          table: hive_table"),
+          testing::StartsWith("          Context for 0"),
+          testing::Eq("")));
+}
 } // namespace
 } // namespace facebook::velox::core
diff --git a/velox/exec/tests/PrefixSortTest.cpp b/velox/exec/tests/PrefixSortTest.cpp
index f404fa05ac4d..732d590dc052 100644
--- a/velox/exec/tests/PrefixSortTest.cpp
+++ b/velox/exec/tests/PrefixSortTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <fmt/ranges.h>
 #include <gtest/gtest.h>
 
 #include "velox/exec/PrefixSort.h"
diff --git a/velox/exec/tests/PrestoQueryRunnerHyperLogLogTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerHyperLogLogTransformTest.cpp
new file mode 100644
index 000000000000..9349f42beed9
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerHyperLogLogTransformTest.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/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerHyperLogLogTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerHyperLogLogTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(HYPERLOGLOG()));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(HYPERLOGLOG())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(HYPERLOGLOG(), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), HYPERLOGLOG())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({HYPERLOGLOG(), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(), TIMESTAMP(), ARRAY(ROW({MAP(VARCHAR(), HYPERLOGLOG())}))})));
+}
+
+TEST_F(PrestoQueryRunnerHyperLogLogTransformTest, transform) {
+  test(HYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerHyperLogLogTransformTest, transformArray) {
+  testArray(HYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerHyperLogLogTransformTest, transformMap) {
+  testMap(HYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerHyperLogLogTransformTest, transformRow) {
+  testRow(HYPERLOGLOG());
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp b/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.cpp
new file mode 100644
index 000000000000..a52fc8150685
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.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 "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+
+namespace facebook::velox::exec::test {
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::test(
+    const VectorPtr& vector) {
+  const auto colName = "col";
+  const auto input =
+      makeRowVector({colName}, {transformIntermediateTypes(vector)});
+
+  auto expr = getProjectionsToIntermediateTypes(
+      vector->type(),
+      std::make_shared<core::FieldAccessExpr>(
+          colName,
+          std::nullopt,
+          std::vector<core::ExprPtr>{std::make_shared<core::InputExpr>()}),
+      colName);
+
+  core::PlanNodePtr plan =
+      PlanBuilder().values({input}).projectExpressions({expr}).planNode();
+
+  AssertQueryBuilder(plan).assertResults(makeRowVector({colName}, {vector}));
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::testDictionary(
+    const VectorPtr& base) {
+  // Wrap in a dictionary without nulls.
+  auto dict = BaseVector::wrapInDictionary(
+      nullptr, makeIndicesInReverse(100), 100, base);
+  test(dict);
+  // Wrap in a dictionary with some nulls.
+  dict = BaseVector::wrapInDictionary(
+      makeNulls(100, [](vector_size_t row) { return row % 10 == 0; }),
+      makeIndicesInReverse(100),
+      100,
+      base);
+  test(dict);
+  // Wrap in a dictionary with all nulls.
+  dict = BaseVector::wrapInDictionary(
+      makeNulls(100, [](vector_size_t) { return true; }),
+      makeIndicesInReverse(100),
+      100,
+      base);
+  test(dict);
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::testConstant(
+    const VectorPtr& base) {
+  // Test a non-null constant.
+  test(BaseVector::wrapInConstant(100, 0, base));
+  // Test a null constant.
+  test(BaseVector::createNullConstant(ARRAY(base->type()), 100, pool_.get()));
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::test(
+    const TypePtr& type) {
+  // No nulls.
+  auto& opts = fuzzer_.getMutableOptions();
+  opts.nullRatio = 0;
+  auto vector = fuzzer_.fuzzFlat(type, kVectorSize);
+  test(vector);
+  // All nulls.
+  opts.nullRatio = 1;
+  vector = fuzzer_.fuzzFlat(type, kVectorSize);
+  test(vector);
+  // Some nulls.
+  opts.nullRatio = 0.1;
+  vector = fuzzer_.fuzzFlat(type, kVectorSize);
+  test(vector);
+
+  testDictionary(vector);
+  testConstant(vector);
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::testArray(
+    const TypePtr& type) {
+  // Test array vector no nulls.
+  auto& opts = fuzzer_.getMutableOptions();
+  opts.nullRatio = 0;
+  auto array = fuzzer_.fuzzArray(type, kVectorSize);
+  test(array);
+
+  // Test array vector all nulls.
+  opts.nullRatio = 1;
+  array = fuzzer_.fuzzArray(type, kVectorSize);
+  test(array);
+
+  // Test array vector some nulls.
+  opts.nullRatio = 0.1;
+  array = fuzzer_.fuzzArray(type, kVectorSize);
+  test(array);
+
+  testDictionary(array);
+  testConstant(array);
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::testMap(
+    const TypePtr& type) {
+  // Test map vector no nulls.
+  auto& opts = fuzzer_.getMutableOptions();
+  opts.nullRatio = 0.0;
+  auto map = fuzzer_.fuzzMap(type, type, kVectorSize);
+  test(map);
+
+  // Test map vector all nulls.
+  opts.nullRatio = 1;
+  map = fuzzer_.fuzzMap(type, type, kVectorSize);
+  test(map);
+
+  // Test map vector some nulls.
+  opts.nullRatio = 0.1;
+  map = fuzzer_.fuzzMap(type, type, kVectorSize);
+  test(map);
+
+  testDictionary(map);
+  testConstant(map);
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::testRow(
+    const TypePtr& type) {
+  const auto size = 100;
+  auto& opts = fuzzer_.getMutableOptions();
+  opts.nullRatio = 0;
+  auto field1 = fuzzer_.fuzz(type, size);
+  opts.nullRatio = 0.1;
+  auto field2 = fuzzer_.fuzz(type, size);
+  opts.nullRatio = 1;
+  auto field3 = fuzzer_.fuzz(type, size);
+  const auto rowType =
+      ROW({"c1", "c2", "c3"}, {field1->type(), field2->type(), field3->type()});
+  // Test map vector no nulls.
+  test(vectorMaker_.rowVector({field1, field2, field3}));
+
+  // Test row vector some nulls.
+  test(
+      std::make_shared<RowVector>(
+          pool_.get(),
+          rowType,
+          makeNulls(size, [](vector_size_t row) { return row % 10 == 0; }),
+          size,
+          std::vector<VectorPtr>{field1, field2, field3}));
+
+  // Test row vector all nulls.
+  test(
+      std::make_shared<RowVector>(
+          pool_.get(),
+          rowType,
+          makeNulls(size, [](vector_size_t) { return true; }),
+          size,
+          std::vector<VectorPtr>{field1, field2, field3}));
+
+  const auto base = vectorMaker_.rowVector({field1, field2, field3});
+  testDictionary(base);
+  testConstant(base);
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::testArray(
+    const VectorPtr& vector) {
+  test(fuzzer_.fuzzArray(vector, vector->size()));
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::testMap(
+    const VectorPtr& keys,
+    const VectorPtr& values) {
+  VELOX_DCHECK_EQ(keys->size(), values->size());
+  test(fuzzer_.fuzzMap(keys, values, keys->size()));
+}
+
+void PrestoQueryRunnerIntermediateTypeTransformTestBase::testRow(
+    std::vector<VectorPtr>&& vectors,
+    std::vector<std::string> names) {
+  auto vector_size = vectors.size();
+  VELOX_DCHECK_EQ(vector_size, names.size());
+  test(fuzzer_.fuzzRow(std::move(vectors), names, vector_size));
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h b/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h
new file mode 100644
index 000000000000..56c93f9966b8
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.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 <gtest/gtest.h>
+
+#include "velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox::exec::test {
+
+class PrestoQueryRunnerIntermediateTypeTransformTestBase
+    : public functions::test::FunctionBaseTest {
+ protected:
+  void test(const VectorPtr& vector);
+
+  void testDictionary(const VectorPtr& base);
+
+  void testConstant(const VectorPtr& base);
+
+  void test(const TypePtr& type);
+
+  void testArray(const TypePtr& type);
+
+  void testMap(const TypePtr& type);
+
+  void testRow(const TypePtr& type);
+
+  void testArray(const VectorPtr& vector);
+
+  void testMap(const VectorPtr& keys, const VectorPtr& values);
+
+  void testRow(
+      std::vector<VectorPtr>&& vectors,
+      std::vector<std::string> names);
+
+ private:
+  const int32_t kVectorSize = 100;
+  VectorFuzzer fuzzer_{VectorFuzzer::Options{}, pool_.get(), 123};
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerIntervalTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerIntervalTransformTest.cpp
new file mode 100644
index 000000000000..340500efc4de
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerIntervalTransformTest.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerIntervalTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerIntervalTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(INTERVAL_DAY_TIME()));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(INTERVAL_DAY_TIME())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(INTERVAL_DAY_TIME(), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), INTERVAL_DAY_TIME())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({INTERVAL_DAY_TIME(), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(),
+       TIMESTAMP(),
+       ARRAY(ROW({MAP(VARCHAR(), INTERVAL_DAY_TIME())}))})));
+}
+
+TEST_F(PrestoQueryRunnerIntervalTransformTest, roundTrip) {
+  std::vector<std::optional<int64_t>> no_nulls{0, 1, 2, 3};
+  test(makeNullableFlatVector(no_nulls, INTERVAL_DAY_TIME()));
+
+  std::vector<std::optional<int64_t>> some_nulls{0, 1, std::nullopt, 3};
+  test(makeNullableFlatVector(some_nulls, INTERVAL_DAY_TIME()));
+
+  std::vector<std::optional<int64_t>> all_nulls{
+      std::nullopt, std::nullopt, std::nullopt};
+  test(makeNullableFlatVector(all_nulls, INTERVAL_DAY_TIME()));
+}
+
+TEST_F(PrestoQueryRunnerIntervalTransformTest, negative) {
+  auto vector = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          -1,
+          -2,
+          -3,
+          -4,
+          -5,
+      },
+      INTERVAL_DAY_TIME());
+  const auto colName = "col";
+  const auto input =
+      makeRowVector({colName}, {transformIntermediateTypes(vector)});
+
+  auto expr = getProjectionsToIntermediateTypes(
+      vector->type(),
+      std::make_shared<core::FieldAccessExpr>(
+          colName,
+          std::nullopt,
+          std::vector<core::ExprPtr>{std::make_shared<core::InputExpr>()}),
+      colName);
+
+  core::PlanNodePtr plan =
+      PlanBuilder().values({input}).projectExpressions({expr}).planNode();
+
+  AssertQueryBuilder(plan).assertResults(makeRowVector(
+      {colName},
+      {makeNullableFlatVector(
+          std::vector<std::optional<int64_t>>{
+              std::nullopt,
+              std::nullopt,
+              std::nullopt,
+              std::nullopt,
+              std::nullopt,
+          },
+          INTERVAL_DAY_TIME())}));
+}
+
+TEST_F(PrestoQueryRunnerIntervalTransformTest, transformArray) {
+  auto input = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          0,
+          1,
+          12,
+          123,
+          1234,
+          12345,
+          123456,
+          1234567,
+          12345678,
+          123456789,
+          1234567890,
+          12345678901,
+          123456789012,
+          1234567890123,
+          12345678901234,
+          123456789012345,
+          1234567890123456,
+          12345678901234567,
+          123456789012345678,
+          1234567890123456789,
+      },
+      INTERVAL_DAY_TIME());
+  testArray(input);
+
+  input = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          993296205767471,
+          101271764434518,
+          166587109740908,
+          210274651317771,
+          276381323443199,
+          283617048324990,
+          519099922518052,
+          530020098439118,
+          604149362180160,
+          622016152847258},
+      INTERVAL_DAY_TIME());
+  testArray(input);
+}
+
+TEST_F(PrestoQueryRunnerIntervalTransformTest, transformMap) {
+  auto keys = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          1,
+          12,
+          123,
+          1234,
+          12345,
+          123456,
+          1234567,
+          12345678,
+          123456789,
+          1234567890,
+      },
+      INTERVAL_DAY_TIME());
+
+  auto values = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          993296205767471,
+          101271764434518,
+          166587109740908,
+          210274651317771,
+          276381323443199,
+          283617048324990,
+          519099922518052,
+          530020098439118,
+          604149362180160,
+          622016152847258},
+      INTERVAL_DAY_TIME());
+
+  testMap(keys, values);
+}
+
+TEST_F(PrestoQueryRunnerIntervalTransformTest, transformRow) {
+  auto input = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          993296205767471,
+          101271764434518,
+          166587109740908,
+          210274651317771,
+          276381323443199,
+          283617048324990,
+          519099922518052,
+          530020098439118,
+          604149362180160,
+          622016152847258},
+      INTERVAL_DAY_TIME());
+  testRow({input}, {"row"});
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerJsonTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerJsonTransformTest.cpp
new file mode 100644
index 000000000000..d54373791d08
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerJsonTransformTest.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/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+#include "velox/functions/prestosql/types/JsonType.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+class PrestoQueryRunnerJsonTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerJsonTransformTest, verifyTransformExpression) {
+  core::PlanNodePtr plan =
+      PlanBuilder()
+          .values({makeRowVector(
+              {"c0"},
+              {transformIntermediateTypes(makeNullableFlatVector(
+                  std::vector<std::optional<StringView>>{}, JSON()))})})
+          .projectExpressions({getProjectionsToIntermediateTypes(
+              JSON(),
+              std::make_shared<core::FieldAccessExpr>(
+                  "c0",
+                  std::nullopt,
+                  std::vector<core::ExprPtr>{
+                      std::make_shared<core::InputExpr>()}),
+              "c0")})
+          .planNode();
+
+  VELOX_CHECK_EQ(
+      plan->toString(true, false),
+      "-- Project[1][expressions: (c0:JSON, try(json_parse(ROW[\"c0\"])))] -> c0:JSON\n");
+  AssertQueryBuilder(plan).assertTypeAndNumRows(JSON(), 0);
+}
+
+TEST_F(PrestoQueryRunnerJsonTransformTest, roundTrip) {
+  std::vector<std::optional<StringView>> no_nulls{"1", "2", "3"};
+  test(makeNullableFlatVector(no_nulls, JSON()));
+
+  std::vector<std::optional<StringView>> some_nulls{"1", std::nullopt, "3"};
+  test(makeNullableFlatVector(some_nulls, JSON()));
+
+  std::vector<std::optional<StringView>> all_nulls{
+      std::nullopt, std::nullopt, std::nullopt};
+  test(makeNullableFlatVector(all_nulls, JSON()));
+}
+
+TEST_F(PrestoQueryRunnerJsonTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(JSON()));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(JSON())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(JSON(), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), JSON())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({JSON(), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({BOOLEAN(), ARRAY(JSON())})));
+  ASSERT_TRUE(isIntermediateOnlyType(
+      ROW({SMALLINT(), TIMESTAMP(), ARRAY(ROW({MAP(VARCHAR(), JSON())}))})));
+}
+
+TEST_F(PrestoQueryRunnerJsonTransformTest, transformArray) {
+  std::vector<std::optional<StringView>> valid_json{
+      "1",
+      "2",
+      "3",
+      "\"{}\"",
+      "[1,2,3]",
+      "{\"name\":\"John\"}",
+      "{\"product\":\"laptop\"}",
+      "{\"temperature\":23.5}",
+      "{\"isActive\":true}",
+      "{\"coordinates\":{\"latitude\":40.7128}}",
+      "{\"colors\":[\"red\"]}",
+      "{\"user\":{\"id\":123}}",
+      "{\"order\":{\"id\":456}}",
+      "{\"event\":\"concert\"}",
+      "{\"settings\":{\"volume\":75}}",
+      "{\"company\":{\"name\":\"TechCorp\"}}",
+      "{\"university\":{\"departments\":[{\"name\":\"ComputerScience\"}]}}",
+      "{\"library\":{\"books\":[{\"title\":\"1984\"}]}}",
+      "{\"restaurant\":{\"menu\":{\"appetizers\":[\"salad\"]}}}",
+      "{\"project\":{\"name\":\"Apollo\"}}",
+  };
+  auto input = makeNullableFlatVector(valid_json, JSON());
+  testArray(input);
+}
+
+TEST_F(PrestoQueryRunnerJsonTransformTest, transformMap) {
+  std::vector<std::optional<StringView>> valid_json_keys{
+      "\"key1\"",
+      "\"key2\"",
+      "\"key3\"",
+      "{\"address\":{\"city\":\"New York\"}}",
+      "{\"company\":{\"name\":\"TechCorp\"}}",
+      "{\"product\":\"Laptop\"}",
+      "\"key7\"",
+      "\"key8\"",
+      "\"key9\"",
+      "\"key10\""};
+  auto keys = makeNullableFlatVector(valid_json_keys, JSON());
+  std::vector<std::optional<StringView>> valid_json_values{
+      "{\"name\":\"Alice\"}",
+      "{\"age\":30}",
+      "{\"address\":{\"city\":\"New York\"}}",
+      "{\"company\":{\"name\":\"TechCorp\"}}",
+      "{\"product\":\"Laptop\"}",
+      "{\"price\":999.99}",
+      "{\"user\":{\"id\":123}}",
+      "{\"order\":{\"id\":456}}",
+      "{\"event\":{\"name\":\"Conference\"}}",
+      "{\"library\":{\"books\":[{\"title\":\"1984\"}]}}"};
+  auto values = makeNullableFlatVector(valid_json_values, JSON());
+  testMap(keys, values);
+}
+
+TEST_F(PrestoQueryRunnerJsonTransformTest, transformRow) {
+  std::vector<std::optional<StringView>> valid_json{
+      "1",
+      "2",
+      "3",
+      "\"{}\"",
+      "[1,2,3]",
+      "{\"name\":\"John\"}",
+      "{\"product\":\"laptop\"}",
+      "{\"temperature\":23.5}",
+      "{\"isActive\":true}",
+      "{\"coordinates\":{\"latitude\":40.7128}}",
+      "{\"colors\":[\"red\"]}",
+      "{\"user\":{\"id\":123}}",
+      "{\"order\":{\"id\":456}}",
+      "{\"event\":\"concert\"}",
+      "{\"settings\":{\"volume\":75}}",
+      "{\"company\":{\"name\":\"TechCorp\"}}",
+      "{\"university\":{\"departments\":[{\"name\":\"ComputerScience\"}]}}",
+      "{\"library\":{\"books\":[{\"title\":\"1984\"}]}}",
+      "{\"restaurant\":{\"menu\":{\"appetizers\":[\"salad\"]}}}",
+      "{\"project\":{\"name\":\"Apollo\"}}",
+  };
+  auto input = makeNullableFlatVector(valid_json, JSON());
+  testRow({input}, {"row"});
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerKHyperLogLogTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerKHyperLogLogTransformTest.cpp
new file mode 100644
index 000000000000..80a4f5a7cd16
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerKHyperLogLogTransformTest.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/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerKHyperLogLogTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(KHYPERLOGLOG()));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(KHYPERLOGLOG())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(KHYPERLOGLOG(), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), KHYPERLOGLOG())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({KHYPERLOGLOG(), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(),
+       TIMESTAMP(),
+       ARRAY(ROW({MAP(VARCHAR(), KHYPERLOGLOG())}))})));
+}
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, transform) {
+  test(KHYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, transformArray) {
+  testArray(KHYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, transformMap) {
+  testMap(KHYPERLOGLOG());
+}
+
+TEST_F(PrestoQueryRunnerKHyperLogLogTransformTest, transformRow) {
+  testRow(KHYPERLOGLOG());
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerQDigestTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerQDigestTransformTest.cpp
new file mode 100644
index 000000000000..173d4966d5e5
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerQDigestTransformTest.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/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerQDigestTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerQDigestTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(QDIGEST(DOUBLE())));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(QDIGEST(DOUBLE()))));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(QDIGEST(DOUBLE()), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), QDIGEST(DOUBLE()))));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({QDIGEST(DOUBLE()), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(),
+       TIMESTAMP(),
+       ARRAY(ROW({MAP(VARCHAR(), QDIGEST(DOUBLE()))}))})));
+
+  ASSERT_TRUE(isIntermediateOnlyType(QDIGEST(BIGINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(QDIGEST(BIGINT()))));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(QDIGEST(BIGINT()), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), QDIGEST(BIGINT()))));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({QDIGEST(BIGINT()), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(),
+       TIMESTAMP(),
+       ARRAY(ROW({MAP(VARCHAR(), QDIGEST(BIGINT()))}))})));
+
+  ASSERT_TRUE(isIntermediateOnlyType(QDIGEST(REAL())));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(QDIGEST(REAL()))));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(QDIGEST(REAL()), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), QDIGEST(REAL()))));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({QDIGEST(REAL()), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(),
+       TIMESTAMP(),
+       ARRAY(ROW({MAP(VARCHAR(), QDIGEST(REAL()))}))})));
+}
+
+TEST_F(PrestoQueryRunnerQDigestTransformTest, transform) {
+  test(QDIGEST(DOUBLE()));
+  test(QDIGEST(BIGINT()));
+  test(QDIGEST(REAL()));
+}
+
+TEST_F(PrestoQueryRunnerQDigestTransformTest, transformArray) {
+  testArray(QDIGEST(DOUBLE()));
+  testArray(QDIGEST(BIGINT()));
+  testArray(QDIGEST(REAL()));
+}
+
+TEST_F(PrestoQueryRunnerQDigestTransformTest, transformMap) {
+  testMap(QDIGEST(DOUBLE()));
+  testMap(QDIGEST(BIGINT()));
+  testMap(QDIGEST(REAL()));
+}
+
+TEST_F(PrestoQueryRunnerQDigestTransformTest, transformRow) {
+  testRow(QDIGEST(DOUBLE()));
+  testRow(QDIGEST(BIGINT()));
+  testRow(QDIGEST(REAL()));
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerSetDigestTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerSetDigestTransformTest.cpp
new file mode 100644
index 000000000000..af15b0dec719
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerSetDigestTransformTest.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/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerSetDigestTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(SETDIGEST()));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(SETDIGEST())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(SETDIGEST(), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), SETDIGEST())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({SETDIGEST(), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(), TIMESTAMP(), ARRAY(ROW({MAP(VARCHAR(), SETDIGEST())}))})));
+}
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, transform) {
+  test(SETDIGEST());
+}
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, transformArray) {
+  testArray(SETDIGEST());
+}
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, transformMap) {
+  testMap(SETDIGEST());
+}
+
+TEST_F(PrestoQueryRunnerSetDigestTransformTest, transformRow) {
+  testRow(SETDIGEST());
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerTDigestTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerTDigestTransformTest.cpp
new file mode 100644
index 000000000000..4dd072cf8591
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerTDigestTransformTest.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/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+#include "velox/functions/prestosql/types/TDigestType.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerTDigestTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+TEST_F(PrestoQueryRunnerTDigestTransformTest, isIntermediateOnlyType) {
+  ASSERT_TRUE(isIntermediateOnlyType(TDIGEST(DOUBLE())));
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(TDIGEST(DOUBLE()))));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(TDIGEST(DOUBLE()), SMALLINT())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARBINARY(), TDIGEST(DOUBLE()))));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({TDIGEST(DOUBLE()), SMALLINT()})));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW(
+      {SMALLINT(),
+       TIMESTAMP(),
+       ARRAY(ROW({MAP(VARCHAR(), TDIGEST(DOUBLE()))}))})));
+}
+
+TEST_F(PrestoQueryRunnerTDigestTransformTest, transform) {
+  test(TDIGEST(DOUBLE()));
+}
+
+TEST_F(PrestoQueryRunnerTDigestTransformTest, transformArray) {
+  testArray(TDIGEST(DOUBLE()));
+}
+
+TEST_F(PrestoQueryRunnerTDigestTransformTest, transformMap) {
+  testMap(TDIGEST(DOUBLE()));
+}
+
+TEST_F(PrestoQueryRunnerTDigestTransformTest, transformRow) {
+  testRow(TDIGEST(DOUBLE()));
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerTest.cpp b/velox/exec/tests/PrestoQueryRunnerTest.cpp
index ee8d1e7bcd2f..598d5633bd91 100644
--- a/velox/exec/tests/PrestoQueryRunnerTest.cpp
+++ b/velox/exec/tests/PrestoQueryRunnerTest.cpp
@@ -203,7 +203,7 @@ TEST_F(PrestoQueryRunnerTest, toSql) {
     EXPECT_EQ(
         queryRunner->toSql(plan),
         fmt::format(
-            "SELECT c0, c1, c2, first_value(c0) OVER (PARTITION BY c1 ORDER BY c2 ASC NULLS LAST {}) FROM (tmp)",
+            "SELECT c0, c1, c2, first_value(c0) OVER (PARTITION BY c1 ORDER BY c2 ASC NULLS LAST {}) as w0 FROM (tmp)",
             frameClause));
 
     const auto firstValueFrame =
@@ -222,7 +222,7 @@ TEST_F(PrestoQueryRunnerTest, toSql) {
     EXPECT_EQ(
         queryRunner->toSql(plan),
         fmt::format(
-            "SELECT c0, c1, c2, first_value(c0) OVER (PARTITION BY c1 ORDER BY c2 DESC NULLS FIRST {}), last_value(c0) OVER (PARTITION BY c1 ORDER BY c2 DESC NULLS FIRST {}) FROM (tmp)",
+            "SELECT c0, c1, c2, first_value(c0) OVER (PARTITION BY c1 ORDER BY c2 DESC NULLS FIRST {}) as w0, last_value(c0) OVER (PARTITION BY c1 ORDER BY c2 DESC NULLS FIRST {}) as w1 FROM (tmp)",
             firstValueFrame,
             lastValueFrame));
   }
diff --git a/velox/exec/tests/PrestoQueryRunnerTimeTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerTimeTransformTest.cpp
new file mode 100644
index 000000000000..0e72861ff20b
--- /dev/null
+++ b/velox/exec/tests/PrestoQueryRunnerTimeTransformTest.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/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class PrestoQueryRunnerTimeTransformTest
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {};
+
+// Test that TIME is recognized as an intermediate type that needs
+// transformation
+TEST_F(PrestoQueryRunnerTimeTransformTest, isIntermediateOnlyType) {
+  // Core test: TIME should be an intermediate type
+  ASSERT_TRUE(isIntermediateOnlyType(TIME()));
+
+  // Complex types containing TIME should also be intermediate types
+  ASSERT_TRUE(isIntermediateOnlyType(ARRAY(TIME())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(VARCHAR(), TIME())));
+  ASSERT_TRUE(isIntermediateOnlyType(MAP(TIME(), VARCHAR())));
+  ASSERT_TRUE(isIntermediateOnlyType(ROW({TIME(), BIGINT()})));
+}
+
+TEST_F(PrestoQueryRunnerTimeTransformTest, roundTrip) {
+  // Test basic TIME values (no nulls, some nulls, all nulls)
+  std::vector<std::optional<int64_t>> no_nulls{0, 3661000, 43200000, 86399999};
+  test(makeNullableFlatVector(no_nulls, TIME()));
+
+  std::vector<std::optional<int64_t>> some_nulls{
+      0, 3661000, std::nullopt, 86399999};
+  test(makeNullableFlatVector(some_nulls, TIME()));
+
+  std::vector<std::optional<int64_t>> all_nulls{
+      std::nullopt, std::nullopt, std::nullopt};
+  test(makeNullableFlatVector(all_nulls, TIME()));
+}
+
+TEST_F(PrestoQueryRunnerTimeTransformTest, transformArray) {
+  auto input = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          0, // 00:00:00.000
+          1000, // 00:00:01.000
+          3661000, // 01:01:01.000
+          43200000, // 12:00:00.000 (noon)
+          86399999, // 23:59:59.999
+          3723456, // 01:02:03.456
+          45678901, // 12:41:18.901
+          std::nullopt,
+          72000000, // 20:00:00.000
+          36000000 // 10:00:00.000
+      },
+      TIME());
+  testArray(input);
+}
+
+TEST_F(PrestoQueryRunnerTimeTransformTest, transformMap) {
+  // keys can't be null for maps
+  auto keys = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          0, // 00:00:00.000
+          3661000, // 01:01:01.000
+          43200000, // 12:00:00.000
+          86399999, // 23:59:59.999
+          36000000, // 10:00:00.000
+          72000000, // 20:00:00.000
+          1800000, // 00:30:00.000
+          7200000, // 02:00:00.000
+          64800000, // 18:00:00.000
+          32400000 // 09:00:00.000
+      },
+      TIME());
+
+  auto values = makeNullableFlatVector<int64_t>(
+      {100, 200, std::nullopt, 400, 500, std::nullopt, 700, 800, 900, 1000},
+      BIGINT());
+
+  testMap(keys, values);
+}
+
+TEST_F(PrestoQueryRunnerTimeTransformTest, transformRow) {
+  auto input = makeNullableFlatVector(
+      std::vector<std::optional<int64_t>>{
+          0, // 00:00:00.000
+          3661000, // 01:01:01.000
+          43200000, // 12:00:00.000
+          86399999, // 23:59:59.999
+          std::nullopt,
+          36000000, // 10:00:00.000
+          72000000, // 20:00:00.000
+          1800000, // 00:30:00.000
+          7200000, // 02:00:00.000
+          64800000 // 18:00:00.000
+      },
+      TIME());
+  testRow({input}, {"time_col"});
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp b/velox/exec/tests/PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
index 92445e94cbd9..4b60208686ea 100644
--- a/velox/exec/tests/PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
+++ b/velox/exec/tests/PrestoQueryRunnerTimestampWithTimeZoneTransformTest.cpp
@@ -15,16 +15,14 @@
  */
 
 #include "velox/exec/fuzzer/PrestoQueryRunnerIntermediateTypeTransforms.h"
-#include "velox/exec/tests/utils/AssertQueryBuilder.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/exec/tests/PrestoQueryRunnerIntermediateTypeTransformTestBase.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.h"
 
 namespace facebook::velox::exec::test {
 namespace {
 class PrestoQueryRunnerTimestampWithTimeZoneTransformTest
-    : public functions::test::FunctionBaseTest {
+    : public PrestoQueryRunnerIntermediateTypeTransformTestBase {
  public:
   VectorPtr fuzzTimestampWithTimeZone(
       const size_t seed,
@@ -44,51 +42,6 @@ class PrestoQueryRunnerTimestampWithTimeZoneTransformTest
 
     return makeNullableFlatVector(values, TIMESTAMP_WITH_TIME_ZONE());
   }
-
-  void test(const VectorPtr& vector) {
-    const auto colName = "col";
-    const auto input =
-        makeRowVector({colName}, {transformIntermediateOnlyType(vector)});
-
-    auto expr = getIntermediateOnlyTypeProjectionExpr(
-        vector->type(),
-        std::make_shared<core::FieldAccessExpr>(
-            colName,
-            std::nullopt,
-            std::vector<core::ExprPtr>{std::make_shared<core::InputExpr>()}),
-        colName);
-
-    core::PlanNodePtr plan =
-        PlanBuilder().values({input}).projectExpressions({expr}).planNode();
-
-    AssertQueryBuilder(plan).assertResults(makeRowVector({colName}, {vector}));
-  }
-
-  void testDictionary(const VectorPtr& base) {
-    // Wrap in a dictionary without nulls.
-    test(BaseVector::wrapInDictionary(
-        nullptr, makeIndicesInReverse(100), 100, base));
-    // Wrap in a dictionary with some nulls.
-    test(BaseVector::wrapInDictionary(
-        makeNulls(100, [](vector_size_t row) { return row % 10 == 0; }),
-        makeIndicesInReverse(100),
-        100,
-        base));
-    // Wrap in a dictionary with all nulls.
-    test(BaseVector::wrapInDictionary(
-        makeNulls(100, [](vector_size_t) { return true; }),
-        makeIndicesInReverse(100),
-        100,
-        base));
-  }
-
-  void testConstant(const VectorPtr& base) {
-    // Test a non-null constant.
-    test(BaseVector::wrapInConstant(100, 0, base));
-    // Test a null constant.
-    test(BaseVector::createNullConstant(
-        ARRAY(TIMESTAMP_WITH_TIME_ZONE()), 100, pool_.get()));
-  }
 };
 
 TEST_F(
@@ -145,8 +98,8 @@ TEST_F(
     transformIntermediateOnlyTypeTimestampWithTimeZoneArray) {
   auto elements = fuzzTimestampWithTimeZone(0, 0.1, 1000);
   auto size = 100;
-  std::vector<vector_size_t> offsets(size + 1);
-  for (int i = 0; i < size + 1; i++) {
+  std::vector<vector_size_t> offsets;
+  for (int i = 0; i < size; i++) {
     offsets.push_back(i * 10);
   }
   // Test array vector no nulls.
@@ -177,8 +130,8 @@ TEST_F(
   auto keys = fuzzTimestampWithTimeZone(0, 0, 1000);
   auto values = fuzzTimestampWithTimeZone(1, 0.1, 1000);
   auto size = 100;
-  std::vector<vector_size_t> offsets(size + 1);
-  for (int i = 0; i < size + 1; i++) {
+  std::vector<vector_size_t> offsets;
+  for (int i = 0; i < size; i++) {
     offsets.push_back(i * 10);
   }
   // Test map vector no nulls.
@@ -216,20 +169,22 @@ TEST_F(
   test(vectorMaker_.rowVector({field1, field2, field3}));
 
   // Test row vector some nulls.
-  test(std::make_shared<RowVector>(
-      pool_.get(),
-      rowType,
-      makeNulls(size, [](vector_size_t row) { return row % 10 == 0; }),
-      size,
-      std::vector<VectorPtr>{field1, field2, field3}));
+  test(
+      std::make_shared<RowVector>(
+          pool_.get(),
+          rowType,
+          makeNulls(size, [](vector_size_t row) { return row % 10 == 0; }),
+          size,
+          std::vector<VectorPtr>{field1, field2, field3}));
 
   // Test row vector all nulls.
-  test(std::make_shared<RowVector>(
-      pool_.get(),
-      rowType,
-      makeNulls(size, [](vector_size_t) { return true; }),
-      size,
-      std::vector<VectorPtr>{field1, field2, field3}));
+  test(
+      std::make_shared<RowVector>(
+          pool_.get(),
+          rowType,
+          makeNulls(size, [](vector_size_t) { return true; }),
+          size,
+          std::vector<VectorPtr>{field1, field2, field3}));
 
   const auto base = vectorMaker_.rowVector({field1, field2, field3});
   testDictionary(base);
diff --git a/velox/exec/tests/PrintPlanWithStatsTest.cpp b/velox/exec/tests/PrintPlanWithStatsTest.cpp
index 4064ea156c87..c1dbfc1303b8 100644
--- a/velox/exec/tests/PrintPlanWithStatsTest.cpp
+++ b/velox/exec/tests/PrintPlanWithStatsTest.cpp
@@ -48,6 +48,12 @@ void compareOutputs(
   for (; std::getline(iss, line);) {
     lineCount++;
     std::vector<std::string> potentialLines;
+    if (expectedLineIndex >= expectedRegex.size()) {
+      ASSERT_FALSE(true) << "Output has more lines than expected."
+                         << "\n  Source: " << testName
+                         << "\n  Line number: " << lineCount
+                         << "\n  Unexpected Line: " << line;
+    }
     auto expectedLine = expectedRegex.at(expectedLineIndex++);
     while (!RE2::FullMatch(line, expectedLine.line)) {
       potentialLines.push_back(expectedLine.line);
@@ -59,11 +65,18 @@ void compareOutputs(
                            << "\n  Expected Line one of: "
                            << folly::join(",", potentialLines);
       }
+      if (expectedLineIndex >= expectedRegex.size()) {
+        ASSERT_FALSE(true)
+            << "Output did not match and no more patterns to check."
+            << "\n  Source: " << testName << "\n  Line number: " << lineCount
+            << "\n  Line: " << line
+            << "\n  Expected Line one of: " << folly::join(",", potentialLines);
+      }
       expectedLine = expectedRegex.at(expectedLineIndex++);
     }
   }
   for (int i = expectedLineIndex; i < expectedRegex.size(); i++) {
-    ASSERT_TRUE(expectedRegex[expectedLineIndex].optional);
+    ASSERT_TRUE(expectedRegex[i].optional);
   }
 }
 
@@ -157,6 +170,7 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
        {"      dataSourceLazyCpuNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"      dataSourceLazyInputBytes[ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"      dataSourceLazyWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"      driverCpuTimeNanos\\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: .+"},
@@ -164,10 +178,12 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
        {"     Output: 2000 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
        {"     HashBuild: Input: 100 rows \\(.+\\), Output: 0 rows \\(.+\\), Cpu time: .+, Blocked wall time: .+, Peak memory: .+, Memory allocations: .+, Threads: 1, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
        {"        distinctKey0\\s+sum: 101, count: 1, min: 101, max: 101, avg: 101"},
+       {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        hashtable.buildWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        hashtable.capacity\\s+sum: 200, count: 1, min: 200, max: 200, avg: 200"},
        {"        hashtable.numDistinct\\s+sum: 100, count: 1, min: 100, max: 100, avg: 100"},
        {"        hashtable.numRehashes\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+       {"        hashtable.vectorHasherMergeCpuNanos\\s+sum: .*, count: 1, min: .*, max: .*, avg: .*"},
        {"        queuedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        rangeKey0\\s+sum: 200, count: 1, min: 200, max: 200, avg: 200"},
        {"        runningAddInputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
@@ -180,6 +196,8 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
         true},
        {"        blockedWaitForJoinBuildWallNanos\\s+sum: .+, count: 1, min: .+, max: .+",
         true},
+       {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+",
+        true},
        {"        dynamicFiltersProduced\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1",
         true},
        {"        queuedWallNanos\\s+sum: .+, count: 1, min: .+, max: .+", true},
@@ -191,38 +209,44 @@ TEST_F(PrintPlanWithStatsTest, innerJoinWithTableScan) {
        {"        runningGetOutputWallNanos\\s+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, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+       {"          connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"          dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"          dataSourceReadWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"          dynamicFiltersAccepted[ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
        {"          footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
-       {"          maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
        {"          numPrefetch         [ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          numRamRead          [ ]* sum: 60, count: 1, min: 60, max: 60, avg: 60"},
-       {"          numStorageRead      [ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"          overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B, avg: 0B"},
-       {"          prefetchBytes       [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          prefetchBytes       [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          preloadSplitPrepareTimeNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"},
        {"          preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
         true},
        {"          processedSplits[ ]+sum: 20, count: 1, min: 20, max: 20, avg: 20"},
        {"          processedStrides[ ]+sum: 20, count: 1, min: 20, max: 20, avg: 20"},
-       {"          ramReadBytes        [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"          processedUnits      [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          ramReadBytes        [ ]* sum: .+, count: .+, 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: .+"},
-       {"          storageReadBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"          totalRemainingFilterTime\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"          storageReadBytes    [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
        {"          totalScanTime       [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"          unitLoadNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"},
+       {"          waitForPreloadSplitNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"},
        {"    -- 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, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+       {"          driverCpuTimeNanos\\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: .+"},
        {"      -- 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, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+       {"            driverCpuTimeNanos\\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: .+"}});
@@ -275,6 +299,7 @@ TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
          {"      dataSourceLazyInputBytes\\s+sum: .+, count: .+, min: .+, max: .+"},
          {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
          {"      distinctKey0\\s+sum: .+, count: 1, min: .+, max: .+"},
+         {"      driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
          {"      hashtable.capacity\\s+sum: (?:1273|1252), count: 1, min: (?:1273|1252), max: (?:1273|1252), avg: (?:1273|1252)"},
          {"      hashtable.numDistinct\\s+sum: (?:849|835), count: 1, min: (?:849|835), max: (?:849|835), avg: (?:849|835)"},
          {"      hashtable.numRehashes\\s+sum: 1, count: 1, min: 1, max: 1, avg: 1"},
@@ -285,31 +310,33 @@ TEST_F(PrintPlanWithStatsTest, partialAggregateWithTableScan) {
          {"      runningGetOutputWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
          {"  -- 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, CPU breakdown: B/I/O/F (.+/.+/.+/.+)"},
+         {"        connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
          {"        dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        dataSourceReadWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+         {"        dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
+         {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
          {"        footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+"},
          {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
-         {"        maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
          {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+"},
          {"        numRamRead       [ ]* sum: 7, count: 1, min: 7, max: 7, avg: 7"},
-         {"        numStorageRead   [ ]* sum: .+, count: 1, min: .+, max: .+"},
          {"        numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
          {"        overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B, avg: 0B"},
 
          {"        prefetchBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
          {"        processedSplits  [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
          {"        processedStrides [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+         {"        processedUnits   [ ]* sum: .+, count: .+, min: .+, max: .+"},
          {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
           true},
-         {"        ramReadBytes     [ ]* sum: .+, count: 1, min: .+, max: .+"},
+         {"        ramReadBytes     [ ]* sum: .+, count: .+, 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: .+"},
-         {"        storageReadBytes [ ]* sum: .+, count: 1, min: .+, max: .+"},
-         {"        totalRemainingFilterTime\\s+sum: .+, count: .+, min: .+, max: .+"},
-         {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"}});
+         {"        storageReadBytes [ ]* sum: .+, count: .+, min: .+, max: .+"},
+         {"        totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+         {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"},
+         {"        unitLoadNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"}});
   }
 }
 
@@ -349,40 +376,44 @@ TEST_F(PrintPlanWithStatsTest, tableWriterWithTableScan) {
        {"      dataSourceLazyCpuNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
        {"      dataSourceLazyInputBytes\\s+sum: .+, count: .+, min: .+, max: .+"},
        {"      dataSourceLazyWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"      driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      dwrfWriterCount\\s+sum: .+, count: 1, 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: .+"},
        {"      runningWallNanos\\s+sum: .+, count: 1, min: .+, max: .+, avg: .+"},
        {"      stripeSize\\s+sum: .+, count: 1, min: .+, max: .+"},
-       {"      writeIOWallNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
+       {"      writeIOWallNanos\\s+sum: .+, count: 1, min: .+, max: .+, avg: .+"},
        {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, CPU breakdown: B/I/O/F (.+/.+/.+/.+))"},
+       {"        connectorSplitSize[ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"        dataSourceAddSplitWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        dataSourceReadWallNanos[ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        dataSourceReadWallNanos[ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"        driverCpuTimeNanos\\s+sum: .+, count: 1, min: .+, max: .+"},
        {"        footerBufferOverread[ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"        ioWaitWallNanos      [ ]* sum: .+, count: .+ min: .+, max: .+"},
-       {"        maxSingleIoWaitWallNanos[ ]*sum: .+, count: 1, min: .+, max: .+"},
        {"        numPrefetch      [ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"        numRamRead       [ ]* sum: 7, count: 1, min: 7, max: 7, avg: 7"},
-       {"        numStorageRead   [ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"        numStripes[ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"        overreadBytes[ ]* sum: 0B, count: 1, min: 0B, max: 0B, avg: 0B"},
 
        {"        prefetchBytes    [ ]* sum: .+, count: 1, min: .+, max: .+"},
        {"        processedSplits  [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
        {"        processedStrides [ ]* sum: 1, count: 1, min: 1, max: 1, avg: 1"},
+       {"        processedUnits   [ ]* sum: .+, count: .+, min: .+, max: .+"},
        {"        preloadedSplits[ ]+sum: .+, count: .+, min: .+, max: .+",
         true},
-       {"        ramReadBytes     [ ]* sum: .+, count: 1, min: .+, max: .+"},
+       {"        ramReadBytes     [ ]* sum: .+, count: .+, 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: .+"},
-       {"        storageReadBytes [ ]* sum: .+, count: 1, min: .+, max: .+"},
-       {"        totalRemainingFilterTime\\s+sum: .+, count: .+, min: .+, max: .+"},
-       {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"}});
+       {"        storageReadBytes [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"        totalRemainingFilterWallNanos\\s+sum: .+, count: .+, min: .+, max: .+"},
+       {"        totalScanTime    [ ]* sum: .+, count: .+, min: .+, max: .+"},
+       {"        unitLoadNanos[ ]* sum: .+, count: .+, min: .+, max: .+, avg: .+"}});
 }
 
 TEST_F(PrintPlanWithStatsTest, taskAPI) {
diff --git a/velox/exec/tests/QueryAssertionsTest.cpp b/velox/exec/tests/QueryAssertionsTest.cpp
index 21b5d60099a0..eb08c7b14b7e 100644
--- a/velox/exec/tests/QueryAssertionsTest.cpp
+++ b/velox/exec/tests/QueryAssertionsTest.cpp
@@ -182,7 +182,7 @@ TEST_F(QueryAssertionsTest, singleFloatColumn) {
           size,
           [&](auto row) {
             return row == 302
-                ? 2.01 + std::max(kEpsilon, double(6 * FLT_EPSILON))
+                ? 2.01 + std::max(Variant::kEpsilon, double(6 * FLT_EPSILON))
                 : row % 6 + 0.01;
           },
           nullEvery(7)),
@@ -282,15 +282,17 @@ TEST_F(QueryAssertionsTest, multiFloatColumnWithUniqueKeys) {
       makeFlatVector<float>(
           size,
           [&](auto row) {
-            return row == 6 ? 2 + std::max(float(kEpsilon), 6 * FLT_EPSILON)
-                            : row % 4;
+            return row == 6
+                ? 2 + std::max(float(Variant::kEpsilon), 6 * FLT_EPSILON)
+                : row % 4;
           },
           nullEvery(5)),
       makeFlatVector<double>(
           size,
           [&](auto row) {
-            return row == 1 ? 1.01 + std::max(kEpsilon, double(3 * FLT_EPSILON))
-                            : row % 6 + 0.01;
+            return row == 1
+                ? 1.01 + std::max(Variant::kEpsilon, double(3 * FLT_EPSILON))
+                : row % 6 + 0.01;
           },
           nullEvery(7)),
   });
diff --git a/velox/exec/tests/RowContainerTest.cpp b/velox/exec/tests/RowContainerTest.cpp
index d7d2622caeff..281ef6e86858 100644
--- a/velox/exec/tests/RowContainerTest.cpp
+++ b/velox/exec/tests/RowContainerTest.cpp
@@ -108,7 +108,8 @@ class RowContainerTestHelper {
   RowContainer* const rowContainer_;
 };
 
-class RowContainerTest : public exec::test::RowContainerTestBase {
+class RowContainerTest : public exec::test::RowContainerTestBase,
+                         public testing::WithParamInterface<bool> {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
@@ -344,7 +345,9 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
       sum += data.rowSize(row) - data.fixedRowSize();
     }
     auto usage = data.stringAllocator().currentBytes();
-    EXPECT_EQ(usage, sum);
+    if (data.testingRowPointers().empty()) {
+      EXPECT_EQ(usage, sum);
+    }
   }
 
   std::vector<char*> store(
@@ -484,11 +487,12 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
       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));
+    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);
@@ -570,8 +574,8 @@ class RowContainerTest : public exec::test::RowContainerTestBase {
     for (auto row : rows) {
       ASSERT_EQ(
           expected[index],
-          rowContainer->equals<canHandleNulls>(
-              row, rowContainer->columnAt(0), rhsDecoded, index))
+          rowContainer->compare<canHandleNulls>(
+              row, rowContainer->columnAt(0), rhsDecoded, index) == 0)
           << fmt::format(
                  "Mismatch at index {} with canHandleNulls {}",
                  index,
@@ -935,7 +939,7 @@ static int32_t sign(int32_t n) {
 }
 } // namespace
 
-TEST_F(RowContainerTest, extractWithNullsAndTargetOffset) {
+TEST_P(RowContainerTest, extractWithNullsAndTargetOffset) {
   constexpr int32_t kNumRows = 100;
   // The second column must have no nulls in the first batch.
   auto rowVector1 = makeRowVector({
@@ -961,8 +965,8 @@ TEST_F(RowContainerTest, extractWithNullsAndTargetOffset) {
   // Create and fill up two row containers from two row vectors.
   std::vector<TypePtr> vecTypes = {BOOLEAN(), VARCHAR(), TINYINT()};
   RowTypePtr rowType = VectorMaker::rowType({BOOLEAN(), VARCHAR(), TINYINT()});
-  auto data1 = makeRowContainer({}, vecTypes);
-  auto data2 = makeRowContainer({}, vecTypes);
+  auto data1 = makeRowContainer({}, vecTypes, true, GetParam());
+  auto data2 = makeRowContainer({}, vecTypes, true, GetParam());
   for (auto i = 0; i < kNumRows; i++) {
     data1->newRow();
     data2->newRow();
@@ -1045,7 +1049,7 @@ TEST_F(RowContainerTest, storeExtractArrayOfVarchar) {
   roundTrip(input);
 }
 
-TEST_F(RowContainerTest, types) {
+TEST_P(RowContainerTest, types) {
   constexpr int32_t kNumRows = 100;
   auto batch = makeDataset(
       ROW(
@@ -1105,7 +1109,7 @@ TEST_F(RowContainerTest, types) {
   std::vector<TypePtr> dependents;
   dependents.insert(
       dependents.begin(), types.begin() + types.size() / 2, types.end());
-  auto data = makeRowContainer(keys, dependents);
+  auto data = makeRowContainer(keys, dependents, true, GetParam());
 
   EXPECT_GT(data->nextOffset(), 0);
   EXPECT_GT(data->probedFlagOffset(), 0);
@@ -1177,11 +1181,13 @@ TEST_F(RowContainerTest, types) {
       EXPECT_EQ(source->hashValueAt(i), hashes[i]);
       // Test non-null and nullable variants of equals.
       if (column < keys.size()) {
-        EXPECT_TRUE(
-            data->equals<false>(rows[i], data->columnAt(column), decoded, i));
+        EXPECT_EQ(
+            data->compare<false>(rows[i], data->columnAt(column), decoded, i),
+            0);
       } else if (!columnType->isMap()) {
-        EXPECT_TRUE(
-            data->equals<true>(rows[i], data->columnAt(column), decoded, i));
+        EXPECT_EQ(
+            data->compare<true>(rows[i], data->columnAt(column), decoded, i),
+            0);
       }
       // Non-key map columns are not comparable, as the map keys are not sorted.
       if (columnType->isMap() && column >= keys.size()) {
@@ -1215,7 +1221,7 @@ TEST_F(RowContainerTest, types) {
   EXPECT_LT(0, free.second);
 }
 
-TEST_F(RowContainerTest, extractNulls) {
+TEST_P(RowContainerTest, extractNulls) {
   constexpr int32_t kNumRows = 100;
   auto batch = makeRowVector({
       makeFlatVector<bool>(
@@ -1266,7 +1272,7 @@ TEST_F(RowContainerTest, extractNulls) {
       ARRAY(INTEGER()),
       MAP(INTEGER(), INTEGER()),
       ROW({INTEGER(), INTEGER()})};
-  auto data = makeRowContainer({}, rowType);
+  auto data = makeRowContainer({}, rowType, true, GetParam());
   for (int i = 0; i < kNumRows; i++) {
     data->newRow();
   }
@@ -1347,11 +1353,11 @@ TEST_F(RowContainerTest, erase) {
   RowContainerTestHelper(data.get()).checkConsistency();
 }
 
-TEST_F(RowContainerTest, initialNulls) {
+TEST_P(RowContainerTest, initialNulls) {
   std::vector<TypePtr> keys{INTEGER()};
   std::vector<TypePtr> dependent{INTEGER()};
   // Join build.
-  auto data = makeRowContainer(keys, dependent, true);
+  auto data = makeRowContainer(keys, dependent, true, GetParam());
   auto row = data->newRow();
   auto isNullAt = [](const RowContainer& data, const char* row, int32_t i) {
     auto column = data.columnAt(i);
@@ -1361,7 +1367,7 @@ TEST_F(RowContainerTest, initialNulls) {
   EXPECT_FALSE(isNullAt(*data, row, 0));
   EXPECT_FALSE(isNullAt(*data, row, 1));
   // Non-join build.
-  data = makeRowContainer(keys, dependent, false);
+  data = makeRowContainer(keys, dependent, false, GetParam());
   row = data->newRow();
   EXPECT_FALSE(isNullAt(*data, row, 0));
   EXPECT_FALSE(isNullAt(*data, row, 1));
@@ -1369,7 +1375,7 @@ TEST_F(RowContainerTest, initialNulls) {
 
 TEST_F(RowContainerTest, rowSize) {
   constexpr int32_t kNumRows = 100;
-  auto data = makeRowContainer({SMALLINT()}, {VARCHAR()});
+  auto data = makeRowContainer({SMALLINT()}, {VARCHAR()}, true);
 
   // The layout is expected to be smallint - 6 bytes of padding - 1 byte of bits
   // - StringView - rowSize - next pointer. The bits are a null flag for the
@@ -1405,10 +1411,10 @@ TEST_F(RowContainerTest, rowSize) {
   EXPECT_EQ(rows, rowsFromContainer);
 }
 
-TEST_F(RowContainerTest, columnSize) {
+TEST_P(RowContainerTest, columnSize) {
   const uint64_t kNumRows = 1000;
-  auto rowContainer =
-      makeRowContainer({BIGINT(), VARCHAR()}, {BIGINT(), VARCHAR()});
+  auto rowContainer = makeRowContainer(
+      {BIGINT(), VARCHAR()}, {BIGINT(), VARCHAR()}, true, GetParam());
 
   VectorFuzzer fuzzer(
       {
@@ -1452,8 +1458,8 @@ TEST_F(RowContainerTest, columnSize) {
   }
 }
 
-TEST_F(RowContainerTest, rowSizeWithNormalizedKey) {
-  auto data = makeRowContainer({SMALLINT()}, {VARCHAR()});
+TEST_P(RowContainerTest, rowSizeWithNormalizedKey) {
+  auto data = makeRowContainer({SMALLINT()}, {VARCHAR()}, true, GetParam());
   data->newRow();
   data->disableNormalizedKeys();
   data->newRow();
@@ -1469,7 +1475,7 @@ TEST_F(RowContainerTest, estimateRowSize) {
 
   // Make a RowContainer with a fixed-length key column and a variable-length
   // dependent column.
-  auto rowContainer = makeRowContainer({BIGINT()}, {VARCHAR()});
+  auto rowContainer = makeRowContainer({BIGINT()}, {VARCHAR()}, true);
   EXPECT_FALSE(rowContainer->estimateRowSize().has_value());
 
   // Store rows to the container.
@@ -1512,6 +1518,7 @@ TEST_F(RowContainerTest, alignment) {
       false,
       true,
       true,
+      false,
       pool_.get());
   constexpr int kNumRows = 100;
   char* rows[kNumRows];
@@ -1679,6 +1686,7 @@ TEST_F(RowContainerTest, probedFlag) {
       true, // isJoinBuild
       true, // hasProbedFlag
       false, // hasNormalizedKey
+      false, // useListRowIndex
       pool_.get());
 
   auto input = makeRowVector({
@@ -1868,8 +1876,10 @@ TEST_F(RowContainerTest, unknown) {
   }
 
   for (size_t row = 0; row < size; ++row) {
-    ASSERT_TRUE(rowContainer->equals<false>(
-        rows[row], rowContainer->columnAt(0), decoded, row));
+    ASSERT_EQ(
+        rowContainer->compare</*mayHaveNulls=*/true>(
+            rows[row], rowContainer->columnAt(0), decoded, row),
+        0);
   }
 
   {
@@ -1892,24 +1902,29 @@ TEST_F(RowContainerTest, unknown) {
   // Verify compare method with row and decoded vector as input
   // Sorting a NULL constant Vector doesn't change the Vector, so we just
   // validate that it runs without throwing an exception.
-  EXPECT_NO_THROW(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, {}) <
-            0;
-      }));
+  EXPECT_NO_THROW(
+      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,
+                       {}) < 0;
+          }));
 
   // Verify compareRows method with row as input.
   // Sorting a NULL constant Vector doesn't change the Vector, so we just
   // validate that it runs without throwing an exception.
-  EXPECT_NO_THROW(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;
-      }));
+  EXPECT_NO_THROW(
+      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;
+          }));
 }
 
 TEST_F(RowContainerTest, nans) {
@@ -1945,8 +1960,10 @@ TEST_F(RowContainerTest, nans) {
 
   // 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<false>(
+            rows[row], rowContainer->columnAt(0), decoded, row),
+        0);
   }
   ASSERT_EQ(rowContainer->compare(rows[0], rows[1], 0, {}), 0);
 }
@@ -1989,10 +2006,10 @@ TEST_F(RowContainerTest, toString) {
 
   EXPECT_EQ(
       rowContainer->toString(rows[0]),
-      "{1, summer, 11, 0.10000000149011612, 3 elements starting at 0 {1, 2, 3}}");
+      "{1, summer, 11, 0.10000000149011612, {1, 2, 3}}");
   EXPECT_EQ(
       rowContainer->toString(rows[1]),
-      "{2, fall, 0, 2.3399999141693115, 2 elements starting at 0 {4, 5}}");
+      "{2, fall, 0, 2.3399999141693115, {4, 5}}");
   EXPECT_EQ(
       rowContainer->toString(rows[2]),
       "{3, winter, 12, 123.00299835205078, null}");
@@ -2133,7 +2150,7 @@ DEBUG_ONLY_TEST_F(RowContainerTest, eraseAfterOomStoringString) {
   rowContainer->eraseRows(folly::Range<char**>(rows.data(), numRows));
 }
 
-TEST_F(RowContainerTest, hugeIntStoreWithNulls) {
+TEST_P(RowContainerTest, hugeIntStoreWithNulls) {
   constexpr int32_t kNumRows = 100;
   constexpr int32_t kColumnIndex = 0;
 
@@ -2166,7 +2183,7 @@ TEST_F(RowContainerTest, hugeIntStoreWithNulls) {
       dictNulls, dictIndices, kNumRows, hugeIntVector);
 
   std::vector<TypePtr> keys;
-  auto data = makeRowContainer({HUGEINT()}, {}, false);
+  auto data = makeRowContainer({HUGEINT()}, {}, false, GetParam());
   std::vector<char*> rows(kNumRows);
   for (auto i = 0; i < kNumRows; ++i) {
     rows[i] = data->newRow();
@@ -2181,9 +2198,9 @@ TEST_F(RowContainerTest, hugeIntStoreWithNulls) {
   assertEqualVectors(source, extracted);
 }
 
-TEST_F(RowContainerTest, columnHasNulls) {
-  auto rowContainer =
-      makeRowContainer({BIGINT(), BIGINT()}, {BIGINT(), BIGINT()}, false);
+TEST_P(RowContainerTest, columnHasNulls) {
+  auto rowContainer = makeRowContainer(
+      {BIGINT(), BIGINT()}, {BIGINT(), BIGINT()}, false, GetParam());
   for (int i = 0; i < rowContainer->columnTypes().size(); ++i) {
     ASSERT_FALSE(rowContainer->columnHasNulls(i));
   }
@@ -2234,7 +2251,7 @@ TEST_F(RowContainerTest, columnHasNulls) {
   }
 }
 
-TEST_F(RowContainerTest, store) {
+TEST_P(RowContainerTest, store) {
   const uint64_t kNumRows = 1000;
   auto rowVectorWithNulls = makeRowVector({
       makeFlatVector<int64_t>(
@@ -2264,7 +2281,7 @@ TEST_F(RowContainerTest, store) {
   });
   for (auto& rowVector : {rowVectorWithNulls, rowVectorNoNulls}) {
     auto rowContainer = makeRowContainer(
-        {BIGINT(), VARCHAR()}, {BIGINT(), ARRAY(BIGINT())}, false);
+        {BIGINT(), VARCHAR()}, {BIGINT(), ARRAY(BIGINT())}, false, GetParam());
     std::vector<char*> rows;
     rows.reserve(kNumRows);
 
@@ -2408,7 +2425,7 @@ TEST_F(RowContainerTest, customComparisonRow) {
       });
 }
 
-TEST_F(RowContainerTest, isNanAt) {
+TEST_P(RowContainerTest, isNanAt) {
   const auto kNan = std::numeric_limits<double>::quiet_NaN();
   const auto kNanF = std::numeric_limits<float>::quiet_NaN();
   auto rowVector = makeRowVector({
@@ -2419,8 +2436,8 @@ TEST_F(RowContainerTest, isNanAt) {
   });
   const auto kNumRows = rowVector->size();
 
-  auto rowContainer =
-      makeRowContainer({REAL(), DOUBLE()}, {REAL(), DOUBLE()}, false);
+  auto rowContainer = makeRowContainer(
+      {REAL(), DOUBLE()}, {REAL(), DOUBLE()}, false, GetParam());
   std::vector<char*> rows;
   rows.reserve(kNumRows);
 
@@ -2653,7 +2670,7 @@ TEST_F(RowContainerTest, rowColumnStats) {
   EXPECT_EQ(stats.nullCount(), 3);
 }
 
-TEST_F(RowContainerTest, storeAndCollectColumnStats) {
+TEST_P(RowContainerTest, storeAndCollectColumnStats) {
   const uint64_t kNumRows = 1000;
   auto rowVector = makeRowVector({
       makeFlatVector<int64_t>(
@@ -2664,7 +2681,8 @@ TEST_F(RowContainerTest, storeAndCollectColumnStats) {
           nullEvery(7)),
   });
 
-  auto rowContainer = makeRowContainer({BIGINT(), VARCHAR()}, {}, false);
+  auto rowContainer =
+      makeRowContainer({BIGINT(), VARCHAR()}, {}, false, GetParam());
   std::vector<char*> rows;
   rows.reserve(kNumRows);
 
@@ -2709,4 +2727,47 @@ TEST_F(RowContainerTest, storeAndCollectColumnStats) {
   }
 }
 
+TEST_F(RowContainerTest, setAllNull) {
+  std::vector<TypePtr> keyTypes = {INTEGER()};
+  std::vector<Accumulator> accumulators{Accumulator(
+      true, 8, false, 8, INTEGER(), [](auto, auto) {}, [](auto) {})};
+
+  auto rowContainer = std::make_unique<RowContainer>(
+      keyTypes,
+      true,
+      accumulators,
+      std::vector<TypePtr>{},
+      false,
+      true,
+      false,
+      false,
+      false,
+      pool_.get());
+
+  auto row = rowContainer->newRow();
+
+  auto keyColumn = rowContainer->columnAt(0);
+  auto accColumn = rowContainer->columnAt(1);
+  ASSERT_FALSE(
+      RowContainer::isNullAt(row, keyColumn.nullByte(), keyColumn.nullMask()));
+  ASSERT_FALSE(
+      RowContainer::isNullAt(row, accColumn.nullByte(), accColumn.nullMask()));
+  ASSERT_EQ(
+      (row[accColumn.initializedByte()] & accColumn.initializedMask()), 0);
+
+  rowContainer->setAllNull(row);
+
+  ASSERT_TRUE(
+      RowContainer::isNullAt(row, keyColumn.nullByte(), keyColumn.nullMask()));
+  ASSERT_TRUE(
+      RowContainer::isNullAt(row, accColumn.nullByte(), accColumn.nullMask()));
+  ASSERT_EQ(
+      (row[accColumn.initializedByte()] & accColumn.initializedMask()), 0);
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    RowContainerTest,
+    RowContainerTest,
+    testing::ValuesIn({false, true}));
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/RowNumberTest.cpp b/velox/exec/tests/RowNumberTest.cpp
index 84e272d42739..7a00000f76a9 100644
--- a/velox/exec/tests/RowNumberTest.cpp
+++ b/velox/exec/tests/RowNumberTest.cpp
@@ -218,11 +218,12 @@ TEST_F(RowNumberTest, spill) {
                 core::QueryConfig::kSpillNumPartitionBits,
                 testData.spillPartitionBits)
             .queryCtx(queryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .rowNumber({"c0"})
-                      .capturePlanNodeId(rowNumberPlanNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .rowNumber({"c0"})
+                    .capturePlanNodeId(rowNumberPlanNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT *, row_number() over (partition by c0) FROM tmp");
     auto taskStats = toPlanStats(task->taskStats());
@@ -404,11 +405,12 @@ DEBUG_ONLY_TEST_F(RowNumberTest, spillOnlyDuringInputOrOutput) {
                 core::QueryConfig::kSpillNumPartitionBits,
                 testData.spillPartitionBits)
             .queryCtx(queryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .rowNumber({"c0"})
-                      .capturePlanNodeId(rowNumberPlanNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .rowNumber({"c0"})
+                    .capturePlanNodeId(rowNumberPlanNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT *, row_number() over (partition by c0) FROM tmp");
     auto taskStats = toPlanStats(task->taskStats());
@@ -488,11 +490,12 @@ DEBUG_ONLY_TEST_F(RowNumberTest, recursiveSpill) {
             .config(
                 core::QueryConfig::kMaxSpillLevel, testData.maxSpillLevel - 1)
             .queryCtx(queryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .rowNumber({"c0"})
-                      .capturePlanNodeId(rowNumberPlanNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .rowNumber({"c0"})
+                    .capturePlanNodeId(rowNumberPlanNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT *, row_number() over (partition by c0) FROM tmp");
     auto taskStats = toPlanStats(task->taskStats());
@@ -550,11 +553,12 @@ TEST_F(RowNumberTest, spillWithYield) {
                 core::QueryConfig::kDriverCpuTimeSliceLimitMs,
                 testData.cpuTimeSliceLimitMs)
             .queryCtx(queryCtx)
-            .plan(PlanBuilder()
-                      .values(vectors)
-                      .rowNumber({"c0"})
-                      .capturePlanNodeId(rowNumberPlanNodeId)
-                      .planNode())
+            .plan(
+                PlanBuilder()
+                    .values(vectors)
+                    .rowNumber({"c0"})
+                    .capturePlanNodeId(rowNumberPlanNodeId)
+                    .planNode())
             .assertResults(
                 "SELECT *, row_number() over (partition by c0) FROM tmp");
     auto taskStats = toPlanStats(task->taskStats());
diff --git a/velox/exec/tests/ScaleWriterLocalPartitionTest.cpp b/velox/exec/tests/ScaleWriterLocalPartitionTest.cpp
index 43a07e7c2ddc..011d3876311d 100644
--- a/velox/exec/tests/ScaleWriterLocalPartitionTest.cpp
+++ b/velox/exec/tests/ScaleWriterLocalPartitionTest.cpp
@@ -81,6 +81,10 @@ class TestExchangeController {
     if (holdBufferBytes_ == 0) {
       return;
     }
+    if (holdBuffer_ != nullptr) {
+      return;
+    }
+
     holdPool_ = pool;
     holdBuffer_ = holdPool_->allocate(holdBufferBytes_);
   }
@@ -227,11 +231,6 @@ class FakeSourceOperator : public SourceOperator {
  private:
   void initialize() override {
     Operator::initialize();
-
-    if (operatorCtx_->driverCtx()->driverId != 0) {
-      return;
-    }
-
     testController_->maybeHoldBuffer(pool());
   }
 
@@ -495,10 +494,11 @@ class ScaleWriterLocalPartitionTest : public HiveConnectorTestBase {
     for (const auto& name : rowType_->names()) {
       orderByKeys.push_back(fmt::format("{} ASC NULLS FIRST", name));
     }
-    AssertQueryBuilder queryBuilder(PlanBuilder()
-                                        .values(inputVectors)
-                                        .orderBy(orderByKeys, false)
-                                        .planNode());
+    AssertQueryBuilder queryBuilder(
+        PlanBuilder()
+            .values(inputVectors)
+            .orderBy(orderByKeys, false)
+            .planNode());
     return queryBuilder.copyResults(pool_.get());
   }
 
@@ -812,11 +812,10 @@ TEST_F(ScaleWriterLocalPartitionTest, partitionBasic) {
       {4, 4, 4, 1ULL << 30, 1.0, 0, {1, 2}, 0.8, 0.6, false},
       {1, 4, 4, 0, 1.0, 0, {1, 2}, 0.3, 0.2, false},
       {4, 4, 4, 0, 1.0, 0, {1, 2}, 0.3, 0.2, false},
-      {1, 4, 4, 0, 0.1, queryCapacity / 2, {1, 2}, 0.8, 0.6, false},
-      {4, 4, 4, 0, 0.1, queryCapacity / 2, {1, 2}, 0.8, 0.6, false},
+      {1, 4, 4, 0, 0.0001, queryCapacity / 2, {1, 2}, 0.8, 0.6, false},
+      {4, 4, 4, 0, 0.0001, queryCapacity / 2, {1, 2}, 0.8, 0.6, false},
       {1, 32, 128, 0, 1.0, 0, {1, 2, 3, 4, 5, 6, 7, 8}, 0.8, 0.6, true},
-      {4, 32, 128, 0, 1.0, 0, {1, 2, 3, 4, 5, 6, 7, 8}, 0.8, 0.6, true},
-  };
+      {4, 32, 128, 0, 1.0, 0, {1, 2, 3, 4, 5, 6, 7, 8}, 0.8, 0.6, true}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
@@ -888,17 +887,25 @@ TEST_F(ScaleWriterLocalPartitionTest, partitionBasic) {
             .copyResults(pool_.get(), task);
     auto planStats = toPlanStats(task->taskStats());
     if (testData.expectedRebalance) {
-      ASSERT_EQ(
+      // NOTE: thre is time race across multiple drivers on the shared balancer
+      // stats reporting which can't totally avoid in tests under some extreme
+      // conditions like the rebalance happens on the last close driver.
+      ASSERT_LE(
           planStats.at(exchnangeNodeId)
               .customStats.count(
                   ScaleWriterPartitioningLocalPartition::kScaledPartitions),
           1);
-      ASSERT_GT(
-          planStats.at(exchnangeNodeId)
-              .customStats
-              .at(ScaleWriterPartitioningLocalPartition::kScaledPartitions)
-              .sum,
-          0);
+      if (planStats.at(exchnangeNodeId)
+              .customStats.count(
+                  ScaleWriterPartitioningLocalPartition::kScaledPartitions) ==
+          1) {
+        ASSERT_GT(
+            planStats.at(exchnangeNodeId)
+                .customStats
+                .at(ScaleWriterPartitioningLocalPartition::kScaledPartitions)
+                .sum,
+            0);
+      }
       ASSERT_EQ(
           planStats.at(exchnangeNodeId)
               .customStats.count(
diff --git a/velox/exec/tests/SerializedPageSpillerTest.cpp b/velox/exec/tests/SerializedPageSpillerTest.cpp
deleted file mode 100644
index 7c97c5b3d543..000000000000
--- a/velox/exec/tests/SerializedPageSpillerTest.cpp
+++ /dev/null
@@ -1,467 +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/SerializedPageSpiller.h"
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/SerializedPageUtil.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/exec/tests/utils/TempFilePath.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::exec;
-using namespace facebook::velox::exec::test;
-namespace facebook::velox::exec::test {
-class SerializedPageSpillerHelper {
- public:
-  SerializedPageSpillerHelper(SerializedPageSpiller& spiller)
-      : spiller_(spiller) {}
-
-  void checkSpillerConsistency() {
-    if (spiller_.totalPages_ == 0) {
-      ASSERT_EQ(spiller_.totalBytes_, 0);
-      ASSERT_EQ(spiller_.bufferStream_, nullptr);
-    }
-    if (spiller_.totalBytes_ > 0) {
-      ASSERT_GT(spiller_.totalPages_, 0);
-      ASSERT_GT(spiller_.bufferStream_->tellp(), spiller_.totalBytes_);
-    }
-  }
-
- private:
-  SerializedPageSpiller const& spiller_;
-};
-
-class SerializedPageSpillReaderHelper {
- public:
-  SerializedPageSpillReaderHelper(SerializedPageSpillReader& reader)
-      : reader_(reader) {}
-
-  void checkReaderConsistency() {
-    ASSERT_GE(reader_.numPages_, reader_.bufferedPages_.size());
-  }
-
-  void assertNumBufferedPages(uint64_t numPages) {
-    ASSERT_EQ(reader_.bufferedPages_.size(), numPages);
-  }
-
- private:
-  SerializedPageSpillReader const& reader_;
-};
-
-class SerializedPageSpillerTest : public exec::test::OperatorTestBase {
- public:
-  void SetUp() override {
-    OperatorTestBase::SetUp();
-    filesystems::registerLocalFileSystem();
-    rng_.seed(0);
-  }
-
- protected:
-  std::vector<std::shared_ptr<SerializedPage>> generateData(
-      uint32_t numPages,
-      int64_t maxPageSize,
-      bool hasVoidedNumRows,
-      int64_t maxNumRows) {
-    std::vector<std::shared_ptr<SerializedPage>> pages;
-    pages.reserve(numPages);
-    for (auto i = 0; i < numPages; ++i) {
-      auto iobufBytes = folly::Random().rand64(maxPageSize, rng_);
-
-      // Setup a chained iobuf.
-      std::unique_ptr<folly::IOBuf> iobuf;
-      if (iobufBytes > 1) {
-        auto firstHalfBytes = iobufBytes / 2;
-        iobuf = folly::IOBuf::create(firstHalfBytes);
-        std::memset(iobuf->writableData(), 'x', firstHalfBytes);
-        iobuf->append(firstHalfBytes);
-
-        auto secondHalfBytes = iobufBytes - firstHalfBytes;
-        auto secondHalfBuf = folly::IOBuf::create(secondHalfBytes);
-        std::memset(secondHalfBuf->writableData(), 'y', secondHalfBytes);
-        secondHalfBuf->append(secondHalfBytes);
-        iobuf->prependChain(std::move(secondHalfBuf));
-      } else {
-        iobuf = folly::IOBuf::create(iobufBytes);
-        std::memset(iobuf->writableData(), 'x', iobufBytes);
-        iobuf->append(iobufBytes);
-      }
-
-      std::optional<int64_t> numRowsOpt;
-      if (!hasVoidedNumRows || folly::Random().oneIn(2, rng_)) {
-        numRowsOpt = std::optional(folly::Random().rand64(maxNumRows, rng_));
-      }
-      pages.push_back(std::make_shared<SerializedPage>(
-          std::move(iobuf), nullptr, numRowsOpt));
-    }
-    return pages;
-  }
-
-  void checkIOBufsEqual(
-      std::unique_ptr<folly::IOBuf>& buf1,
-      std::unique_ptr<folly::IOBuf>& buf2) {
-    auto coalescedBuf1 = buf1->coalesce();
-    auto coalescedBuf2 = buf2->coalesce();
-    ASSERT_EQ(coalescedBuf1.size(), coalescedBuf2.size());
-    ASSERT_EQ(
-        std::memcmp(
-            coalescedBuf1.data(), coalescedBuf2.data(), coalescedBuf1.size()),
-        0);
-  }
-
-  void checkSerializedPageEqual(SerializedPage& page1, SerializedPage& page2) {
-    ASSERT_EQ(page1.numRows().has_value(), page2.numRows().has_value());
-    if (page1.numRows().has_value()) {
-      ASSERT_EQ(page1.numRows().value(), page1.numRows().value());
-    }
-    auto buf1 = page1.getIOBuf();
-    auto buf2 = page2.getIOBuf();
-    checkIOBufsEqual(buf1, buf2);
-  }
-
-  folly::Random::DefaultGenerator rng_;
-  common::UpdateAndCheckSpillLimitCB updateAndCheckSpillLimitCB_{
-      [](uint64_t /* unused */) {}};
-};
-} // namespace facebook::velox::exec::test
-
-TEST_F(SerializedPageSpillerTest, pageSpillerBasic) {
-  auto pool = rootPool_->addLeafChild("destinationBufferSpiller");
-
-  struct TestValue {
-    uint32_t numPages;
-    int64_t maxPageSize;
-    bool hasVoidedNumRows;
-    int64_t maxNumRows;
-    uint64_t readBufferSize;
-    uint64_t writeBufferSize;
-    uint64_t targetFileSize;
-
-    std::string debugString() const {
-      return fmt::format(
-          "numPages {}, maxPageSize {}, hasVoidedNumRows {}, maxNumRows {}, "
-          "readBufferSize {}, writeBufferSize {}, targetFileSize {}",
-          numPages,
-          maxPageSize,
-          hasVoidedNumRows,
-          maxNumRows,
-          readBufferSize,
-          writeBufferSize,
-          targetFileSize);
-    }
-  };
-
-  std::vector<TestValue> testValues{
-      {10, 64, true, 20, 1024, 1024, 2048},
-      {10, 64, false, 20, 1024, 0, 2048},
-      {0, 64, true, 20, 1024, 256, 2048},
-      {10, 64, true, 20, 1, 2048, 128},
-      {10, 0, true, 20, 128, 2048, 128}};
-
-  for (const auto& testValue : testValues) {
-    SCOPED_TRACE(testValue.debugString());
-
-    auto tempFile = exec::test::TempFilePath::create();
-    const auto& prefixPath = tempFile->getPath();
-    auto fs = filesystems::getFileSystem(prefixPath, {});
-    SCOPE_EXIT {
-      fs->remove(prefixPath);
-    };
-
-    auto pages = generateData(
-        testValue.numPages,
-        testValue.maxPageSize,
-        testValue.hasVoidedNumRows,
-        testValue.maxNumRows);
-
-    folly::Synchronized<common::SpillStats> spillStats;
-    SerializedPageSpiller spiller(
-        testValue.writeBufferSize,
-        testValue.targetFileSize,
-        prefixPath,
-        "",
-        updateAndCheckSpillLimitCB_,
-        pool.get(),
-        &spillStats);
-    SerializedPageSpillerHelper spillerHelper(spiller);
-    spillerHelper.checkSpillerConsistency();
-
-    spiller.spill(pages);
-    spillerHelper.checkSpillerConsistency();
-
-    auto spillResults = spiller.finishSpill();
-
-    SerializedPageSpillReader reader(
-        std::move(spillResults),
-        testValue.readBufferSize,
-        pool.get(),
-        &spillStats);
-    SerializedPageSpillReaderHelper readerHelper(reader);
-
-    ASSERT_EQ(reader.empty(), pages.empty());
-    ASSERT_EQ(reader.numPages(), pages.size());
-
-    VELOX_ASSERT_THROW(reader.at(pages.size()), "");
-    readerHelper.checkReaderConsistency();
-
-    VELOX_ASSERT_THROW(reader.deleteFront(pages.size() + 1), "");
-    readerHelper.checkReaderConsistency();
-
-    if (pages.empty()) {
-      ASSERT_TRUE(reader.empty());
-      continue;
-    }
-
-    ASSERT_FALSE(reader.empty());
-    uint32_t i = 0;
-    while (!reader.empty()) {
-      if (reader.at(0) != nullptr) {
-        ASSERT_EQ(reader.at(0)->size(), pages[i]->size());
-      } else {
-        ASSERT_EQ(pages[i], nullptr);
-      }
-      readerHelper.checkReaderConsistency();
-
-      auto unspilledPage = reader.at(0);
-      readerHelper.checkReaderConsistency();
-
-      ASSERT_LT(i, pages.size());
-      ASSERT_EQ(unspilledPage->numRows(), pages[i]->numRows());
-      ASSERT_EQ(unspilledPage->size(), pages[i]->size());
-      auto originalIOBuf = pages[i]->getIOBuf();
-      auto unspilledIOBuf = unspilledPage->getIOBuf();
-      checkIOBufsEqual(originalIOBuf, unspilledIOBuf);
-      if (testValue.maxPageSize == 0) {
-        ASSERT_GE(pool->usedBytes(), 0);
-      } else {
-        ASSERT_GT(pool->usedBytes(), 0);
-      }
-      reader.deleteFront(1);
-      ++i;
-    }
-    ASSERT_EQ(i, pages.size());
-    ASSERT_TRUE(reader.empty());
-    ASSERT_EQ(reader.numPages(), 0);
-
-    VELOX_ASSERT_THROW(reader.at(0), "");
-    readerHelper.checkReaderConsistency();
-
-    VELOX_ASSERT_THROW(reader.deleteFront(1), "");
-    readerHelper.checkReaderConsistency();
-
-    ASSERT_NO_THROW(reader.deleteAll());
-    readerHelper.checkReaderConsistency();
-  }
-  ASSERT_EQ(pool->usedBytes(), 0);
-}
-
-TEST_F(SerializedPageSpillerTest, spillReaderAccessors) {
-  auto pool = rootPool_->addLeafChild("spillReaderAccessors");
-  auto pages = generateData(20, 1LL << 20, true, 1000);
-
-  struct TestValue {
-    std::string testName;
-    std::function<void(
-        std::vector<std::shared_ptr<SerializedPage>>&,
-        SerializedPageSpillReader&,
-        uint64_t)>
-        accessorVerifier;
-    std::string debugString() {
-      return testName;
-    }
-  };
-
-  std::vector<TestValue> testValues{
-      {"SerializedPageSpillReader::at",
-       [this](auto& originalPages, auto& reader, auto index) {
-         // Accessor verifier for SerializedPageSpillReader::at()
-         if (index >= originalPages.size()) {
-           VELOX_ASSERT_THROW(reader.at(index), "");
-           return;
-         }
-         auto originalPage = originalPages[index];
-         auto unspilledPage = reader.at(index);
-         if (originalPage == nullptr) {
-           ASSERT_EQ(unspilledPage, nullptr);
-           return;
-         }
-         ASSERT_EQ(originalPage->size(), unspilledPage->size());
-         ASSERT_EQ(originalPage->numRows(), unspilledPage->numRows());
-         auto originalIOBuf = originalPage->getIOBuf();
-         auto unspilledIOBuf = unspilledPage->getIOBuf();
-         checkIOBufsEqual(originalIOBuf, unspilledIOBuf);
-       }}};
-
-  for (auto& testValue : testValues) {
-    SCOPED_TRACE(testValue.debugString());
-    auto tempFile = exec::test::TempFilePath::create();
-    const auto& prefixPath = tempFile->getPath();
-    auto fs = filesystems::getFileSystem(prefixPath, {});
-    SCOPE_EXIT {
-      fs->remove(prefixPath);
-    };
-
-    folly::Synchronized<common::SpillStats> spillStats;
-    SerializedPageSpiller spiller(
-        1024,
-        2048,
-        prefixPath,
-        "",
-        updateAndCheckSpillLimitCB_,
-        pool.get(),
-        &spillStats);
-    SerializedPageSpillerHelper spillerHelper(spiller);
-    spiller.spill(pages);
-    spillerHelper.checkSpillerConsistency();
-    auto spillResults = spiller.finishSpill();
-
-    SerializedPageSpillReader reader(
-        std::move(spillResults), 1024, pool.get(), &spillStats);
-    SerializedPageSpillReaderHelper readerHelper(reader);
-
-    testValue.accessorVerifier(pages, reader, 1);
-    readerHelper.checkReaderConsistency();
-    readerHelper.assertNumBufferedPages(2);
-
-    testValue.accessorVerifier(pages, reader, 10);
-    readerHelper.checkReaderConsistency();
-    readerHelper.assertNumBufferedPages(11);
-
-    testValue.accessorVerifier(pages, reader, 25);
-    readerHelper.checkReaderConsistency();
-    readerHelper.assertNumBufferedPages(11);
-
-    testValue.accessorVerifier(pages, reader, 19);
-    readerHelper.checkReaderConsistency();
-    readerHelper.assertNumBufferedPages(20);
-
-    testValue.accessorVerifier(pages, reader, 5);
-    readerHelper.checkReaderConsistency();
-    readerHelper.assertNumBufferedPages(20);
-  }
-  ASSERT_EQ(pool->usedBytes(), 0);
-}
-
-TEST_F(SerializedPageSpillerTest, spillReaderDelete) {
-  auto pool = rootPool_->addLeafChild("spillReaderDelete");
-  const auto kNumPages = 20;
-  auto pages = generateData(kNumPages, 1LL << 20, true, 1000);
-
-  struct TestValue {
-    uint32_t numBufferedPages;
-    uint32_t numDelete;
-
-    std::string debugString() {
-      return fmt::format(
-          "numBufferedPages {}, numDelete {}", numBufferedPages, numDelete);
-    }
-  };
-
-  std::vector<TestValue> testValues{
-      {0, 0},
-      {0, 10},
-      {0, 20},
-      {0, 25},
-      {10, 0},
-      {10, 5},
-      {10, 15},
-      {10, 20},
-      {10, 25}};
-  for (auto& testValue : testValues) {
-    SCOPED_TRACE(testValue.debugString());
-    // Test delete front.
-    auto tempFile = exec::test::TempFilePath::create();
-    const auto& prefixPath = tempFile->getPath();
-    auto fs = filesystems::getFileSystem(prefixPath, {});
-    SCOPE_EXIT {
-      fs->remove(prefixPath);
-    };
-
-    folly::Synchronized<common::SpillStats> spillStats;
-    SerializedPageSpiller spiller(
-        1024,
-        2048,
-        prefixPath,
-        "",
-        updateAndCheckSpillLimitCB_,
-        pool.get(),
-        &spillStats);
-    SerializedPageSpillerHelper spillerHelper(spiller);
-    spiller.spill(pages);
-    spillerHelper.checkSpillerConsistency();
-    auto spillResult = spiller.finishSpill();
-
-    SerializedPageSpillReader reader(
-        std::move(spillResult), 1024, pool.get(), &spillStats);
-    SerializedPageSpillReaderHelper readerHelper(reader);
-
-    // Unspill pages to buffer
-    if (testValue.numBufferedPages > 0) {
-      reader.at(testValue.numBufferedPages - 1);
-    }
-    readerHelper.checkReaderConsistency();
-    readerHelper.assertNumBufferedPages(testValue.numBufferedPages);
-
-    if (testValue.numDelete > kNumPages) {
-      VELOX_ASSERT_THROW(reader.deleteFront(testValue.numDelete), "");
-      readerHelper.checkReaderConsistency();
-      readerHelper.assertNumBufferedPages(testValue.numBufferedPages);
-      continue;
-    } else {
-      reader.deleteFront(testValue.numDelete);
-    }
-    readerHelper.checkReaderConsistency();
-    if (testValue.numDelete <= testValue.numBufferedPages) {
-      readerHelper.assertNumBufferedPages(
-          testValue.numBufferedPages - testValue.numDelete);
-    } else {
-      readerHelper.assertNumBufferedPages(0);
-    }
-  }
-
-  {
-    // Test delete all.
-    auto tempFile = exec::test::TempFilePath::create();
-    const auto& prefixPath = tempFile->getPath();
-    auto fs = filesystems::getFileSystem(prefixPath, {});
-    SCOPE_EXIT {
-      fs->remove(prefixPath);
-    };
-
-    folly::Synchronized<common::SpillStats> spillStats;
-    SerializedPageSpiller spiller(
-        1024,
-        2048,
-        prefixPath,
-        "",
-        updateAndCheckSpillLimitCB_,
-        pool.get(),
-        &spillStats);
-    SerializedPageSpillerHelper spillerHelper(spiller);
-    spiller.spill(pages);
-    spillerHelper.checkSpillerConsistency();
-    auto spillResult = spiller.finishSpill();
-
-    SerializedPageSpillReader reader(
-        std::move(spillResult), 1024, pool.get(), &spillStats);
-    SerializedPageSpillReaderHelper readerHelper(reader);
-
-    reader.at(10);
-    reader.deleteAll();
-    readerHelper.checkReaderConsistency();
-    readerHelper.assertNumBufferedPages(0);
-  }
-}
diff --git a/velox/exec/tests/SimpleAverageAggregate.cpp b/velox/exec/tests/SimpleAverageAggregate.cpp
index fea9254cb1cf..ea710380b3b6 100644
--- a/velox/exec/tests/SimpleAverageAggregate.cpp
+++ b/velox/exec/tests/SimpleAverageAggregate.cpp
@@ -34,9 +34,8 @@ class AverageAggregate {
   using InputType = Row<T>;
 
   // Type of intermediate result vector wrapped in Row.
-  using IntermediateType =
-      Row</*sum*/ double,
-          /*count*/ int64_t>;
+  using IntermediateType = Row</*sum*/ double,
+                               /*count*/ int64_t>;
 
   // Type of output vector.
   using OutputType =
@@ -102,18 +101,20 @@ exec::AggregateRegistrationResult registerSimpleAverageAggregate(
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   for (const auto& inputType : {"smallint", "integer", "bigint", "double"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,bigint)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,bigint)")
+            .argumentType(inputType)
+            .build());
   }
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType("real")
-                           .intermediateType("row(double,bigint)")
-                           .argumentType("real")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("real")
+          .intermediateType("row(double,bigint)")
+          .argumentType("real")
+          .build());
 
   return exec::registerAggregateFunction(
       name,
diff --git a/velox/exec/tests/SortBufferTest.cpp b/velox/exec/tests/SortBufferTest.cpp
index 93bf32edf4df..80774a2d2613 100644
--- a/velox/exec/tests/SortBufferTest.cpp
+++ b/velox/exec/tests/SortBufferTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/exec/SortBuffer.h"
+#include <folly/system/HardwareConcurrency.h>
 #include <gtest/gtest.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
@@ -89,6 +90,7 @@ class SortBufferTest : public OperatorTestBase,
         0,
         0,
         "none",
+        0,
         spillPrefixSortConfig);
   }
 
@@ -118,7 +120,9 @@ class SortBufferTest : public OperatorTestBase,
 
   const std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::hardware_concurrency())};
+  const std::shared_ptr<memory::MemoryPool> fuzzerPool_ =
+      memory::memoryManager()->addLeafPool("SortBufferTest");
 
   tsan_atomic<bool> nonReclaimableSection_{false};
   folly::Random::DefaultGenerator rng_;
@@ -335,13 +339,10 @@ TEST_P(SortBufferTest, DISABLED_randomData) {
         &nonReclaimableSection_,
         prefixSortConfig_);
 
-    const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::memoryManager()->addLeafPool("VectorFuzzer");
-
     std::vector<RowVectorPtr> inputVectors;
     inputVectors.reserve(3);
     for (size_t inputRows : {1000, 1000, 1000}) {
-      VectorFuzzer fuzzer({.vectorSize = inputRows}, fuzzerPool.get());
+      VectorFuzzer fuzzer({.vectorSize = inputRows}, fuzzerPool_.get());
       RowVectorPtr input = fuzzer.fuzzRow(inputType_);
       sortBuffer->addInput(input);
       inputVectors.push_back(input);
@@ -401,6 +402,7 @@ TEST_P(SortBufferTest, batchOutput) {
         0,
         0,
         "none",
+        0,
         prefixSortConfig_);
     folly::Synchronized<common::SpillStats> spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
@@ -413,15 +415,11 @@ TEST_P(SortBufferTest, batchOutput) {
         testData.triggerSpill ? &spillConfig : nullptr,
         &spillStats);
     ASSERT_EQ(sortBuffer->canSpill(), testData.triggerSpill);
-
-    const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::memoryManager()->addLeafPool("VectorFuzzer");
-
     std::vector<RowVectorPtr> inputVectors;
     inputVectors.reserve(testData.numInputRows.size());
     uint64_t totalNumInput = 0;
     for (size_t inputRows : testData.numInputRows) {
-      VectorFuzzer fuzzer({.vectorSize = inputRows}, fuzzerPool.get());
+      VectorFuzzer fuzzer({.vectorSize = inputRows}, fuzzerPool_.get());
       RowVectorPtr input = fuzzer.fuzzRow(inputType_);
       sortBuffer->addInput(input);
       inputVectors.push_back(input);
@@ -498,6 +496,7 @@ TEST_P(SortBufferTest, spill) {
         0,
         0,
         "none",
+        0,
         prefixSortConfig_);
     folly::Synchronized<common::SpillStats> spillStats;
     auto sortBuffer = std::make_unique<SortBuffer>(
@@ -510,9 +509,7 @@ TEST_P(SortBufferTest, spill) {
         testData.spillEnabled ? &spillConfig : nullptr,
         &spillStats);
 
-    const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::memoryManager()->addLeafPool("spillSource");
-    VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+    VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
     uint64_t totalNumInput = 0;
 
     ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
@@ -595,9 +592,7 @@ DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringInput) {
         ASSERT_EQ(sortBuffer->pool()->usedBytes(), 0);
       })));
 
-  const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-      memory::memoryManager()->addLeafPool("spillDuringInput");
-  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
 
   ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
   const auto peakSpillMemoryUsage =
@@ -621,6 +616,7 @@ DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringInput) {
     ASSERT_GE(
         memory::spillMemoryPool()->stats().peakBytes, peakSpillMemoryUsage);
   }
+  ASSERT_EQ(pool_->usedBytes(), 0);
 }
 
 DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringOutput) {
@@ -645,10 +641,7 @@ DEBUG_ONLY_TEST_P(SortBufferTest, spillDuringOutput) {
         sortBuffer->spill();
         ASSERT_EQ(sortBuffer->pool()->usedBytes(), 0);
       })));
-
-  const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-      memory::memoryManager()->addLeafPool("spillDuringOutput");
-  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+  VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
 
   ASSERT_EQ(memory::spillMemoryPool()->stats().usedBytes, 0);
   const auto peakSpillMemoryUsage =
@@ -690,10 +683,7 @@ DEBUG_ONLY_TEST_P(SortBufferTest, reserveMemorySortGetOutput) {
         prefixSortConfig_,
         spillEnabled ? &spillConfig : nullptr,
         &spillStats);
-
-    const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-        memory::memoryManager()->addLeafPool("reserveMemoryGetOutput");
-    VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+    VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
 
     const int numInputs{10};
     for (int i = 0; i < numInputs; ++i) {
@@ -735,8 +725,11 @@ DEBUG_ONLY_TEST_P(SortBufferTest, reserveMemorySort) {
   } testSettings[] = {{false, true}, {true, false}, {true, true}};
 
   for (const auto [usePrefixSort, spillEnabled] : testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "usePrefixSort: {}, spillEnabled: {}, ", usePrefixSort, spillEnabled));
+    SCOPED_TRACE(
+        fmt::format(
+            "usePrefixSort: {}, spillEnabled: {}, ",
+            usePrefixSort,
+            spillEnabled));
     auto spillDirectory = exec::test::TempDirectoryPath::create();
     auto spillConfig = getSpillConfig(spillDirectory->getPath(), usePrefixSort);
     folly::Synchronized<common::SpillStats> spillStats;
@@ -777,9 +770,6 @@ DEBUG_ONLY_TEST_P(SortBufferTest, reserveMemorySort) {
 }
 
 TEST_P(SortBufferTest, emptySpill) {
-  const std::shared_ptr<memory::MemoryPool> fuzzerPool =
-      memory::memoryManager()->addLeafPool("emptySpillSource");
-
   for (bool hasPostSpillData : {false, true}) {
     SCOPED_TRACE(fmt::format("hasPostSpillData {}", hasPostSpillData));
     auto spillDirectory = exec::test::TempDirectoryPath::create();
@@ -797,7 +787,7 @@ TEST_P(SortBufferTest, emptySpill) {
 
     sortBuffer->spill();
     if (hasPostSpillData) {
-      VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool.get());
+      VectorFuzzer fuzzer({.vectorSize = 1024}, fuzzerPool_.get());
       sortBuffer->addInput(fuzzer.fuzzRow(inputType_));
     }
     sortBuffer->noMoreInput();
diff --git a/velox/exec/tests/SpatialIndexTest.cpp b/velox/exec/tests/SpatialIndexTest.cpp
new file mode 100644
index 000000000000..e2a7778cd52f
--- /dev/null
+++ b/velox/exec/tests/SpatialIndexTest.cpp
@@ -0,0 +1,550 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/SpatialIndex.h"
+#include <gtest/gtest.h>
+#include <algorithm>
+
+using namespace ::testing;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::exec::test {
+
+class SpatialIndexTest : public virtual testing::Test {
+ protected:
+  void makeIndex(
+      std::vector<Envelope> envelopes,
+      uint32_t branchSize = SpatialIndex::kDefaultRTreeBranchSize) {
+    branchSize_ = branchSize;
+    Envelope bounds = Envelope::of(envelopes);
+    index_ = SpatialIndex(std::move(bounds), std::move(envelopes), branchSize);
+  }
+
+  Envelope indexBounds() const {
+    return index_.bounds();
+  }
+
+  void assertQuery(
+      double minX,
+      double minY,
+      double maxX,
+      double maxY,
+      std::vector<int32_t> expected) const {
+    std::vector<int32_t> actual =
+        index_.query(Envelope::from(minX, minY, maxX, maxY));
+    std::sort(actual.begin(), actual.end());
+    std::sort(expected.begin(), expected.end());
+    ASSERT_EQ(actual, expected);
+  }
+
+  SpatialIndex index_;
+  uint32_t branchSize_ = SpatialIndex::kDefaultRTreeBranchSize;
+};
+
+TEST_F(SpatialIndexTest, testEnvelope) {
+  Envelope empty = Envelope::empty();
+  ASSERT_TRUE(empty.isEmpty());
+  ASSERT_FALSE(Envelope::intersects(empty, empty));
+
+  Envelope point =
+      Envelope{.minX = 0, .minY = 0, .maxX = 0, .maxY = 0, .rowIndex = -1};
+  ASSERT_FALSE(point.isEmpty());
+  ASSERT_FALSE(Envelope::intersects(empty, point));
+  ASSERT_TRUE(Envelope::intersects(point, point));
+}
+
+TEST_F(SpatialIndexTest, testNaNHandling) {
+  float nan = std::numeric_limits<float>::quiet_NaN();
+
+  Envelope envWithNaN{
+      .minX = nan, .minY = 0, .maxX = 1, .maxY = 1, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN.isEmpty());
+
+  Envelope envWithNaN2{
+      .minX = 0, .minY = 0, .maxX = nan, .maxY = 1, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN2.isEmpty());
+
+  Envelope envWithNaN3{
+      .minX = 0, .minY = nan, .maxX = 1, .maxY = 1, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN3.isEmpty());
+
+  Envelope envWithNaN4{
+      .minX = 0, .minY = 0, .maxX = 1, .maxY = nan, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN4.isEmpty());
+
+  Envelope envWithNaN5{
+      .minX = nan, .minY = nan, .maxX = nan, .maxY = nan, .rowIndex = 0};
+  ASSERT_TRUE(envWithNaN5.isEmpty());
+}
+
+TEST_F(SpatialIndexTest, testEmptyIndex) {
+  makeIndex(std::vector<Envelope>{});
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, std::numeric_limits<double>::infinity());
+  ASSERT_EQ(bounds.minY, std::numeric_limits<double>::infinity());
+  ASSERT_EQ(bounds.maxX, -std::numeric_limits<double>::infinity());
+  ASSERT_EQ(bounds.maxY, -std::numeric_limits<double>::infinity());
+  ASSERT_EQ(bounds.rowIndex, -1);
+
+  assertQuery(0, 0, 1, 1, {});
+}
+
+TEST_F(SpatialIndexTest, testSingleEnvelope) {
+  makeIndex(
+      std::vector<Envelope>{Envelope{
+          .minX = 1, .minY = 11, .maxX = 2, .maxY = 12, .rowIndex = 0}});
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, 1);
+  ASSERT_EQ(bounds.minY, 11);
+  ASSERT_EQ(bounds.maxX, 2);
+  ASSERT_EQ(bounds.maxY, 12);
+
+  assertQuery(1.5, 11.5, 1.5, 11.5, {0});
+  assertQuery(0.5, 10.5, 1.5, 11.5, {0});
+  assertQuery(0, 10, 0.5, 10.5, {});
+  assertQuery(3, 13, 4, 14, {});
+}
+
+TEST_F(SpatialIndexTest, testPointProbe) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 1, .minY = 0, .maxX = 1, .maxY = 0, .rowIndex = 6},
+          Envelope{.minX = 0, .minY = 0, .maxX = 0, .maxY = 0, .rowIndex = 5},
+          Envelope{.minX = 0, .minY = 0, .maxX = 1, .maxY = 1, .rowIndex = 4},
+          Envelope{.minX = -1, .minY = -1, .maxX = 0, .maxY = 0, .rowIndex = 3},
+          Envelope{.minX = -1, .minY = -1, .maxX = 1, .maxY = 1, .rowIndex = 2},
+          Envelope{
+              .minX = 0.5, .minY = 0.5, .maxX = 1, .maxY = 1, .rowIndex = 1},
+      });
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, -1);
+  ASSERT_EQ(bounds.minY, -1);
+  ASSERT_EQ(bounds.maxX, 1);
+  ASSERT_EQ(bounds.maxY, 1);
+  ASSERT_EQ(bounds.rowIndex, -1);
+
+  assertQuery(0, 0, 0, 0, {2, 3, 4, 5});
+  assertQuery(0, 1, 0, 1, {2, 4});
+}
+
+TEST_F(SpatialIndexTest, testFloatImprecision) {
+  // Since the index casts doubles to floats then nudges the result,
+  // we should make sure that the index gives the right results on
+  // cases where the double doesn't have an exact float representation.
+  float float1 = 1.0f;
+  float float1Down =
+      std::nextafterf(float1, -std::numeric_limits<float>::infinity());
+  float float2 = 2.0f;
+  float float2Up =
+      std::nextafterf(float2, std::numeric_limits<float>::infinity());
+
+  double baseMax = static_cast<double>(float2);
+  double baseMaxUp =
+      std::nextafter<double>(baseMax, std::numeric_limits<double>::infinity());
+  double baseMaxDown =
+      std::nextafter<double>(baseMax, -std::numeric_limits<double>::infinity());
+  double baseMin = static_cast<double>(float1);
+  double baseMinUp =
+      std::nextafter<double>(baseMin, std::numeric_limits<double>::infinity());
+  double baseMinDown =
+      std::nextafter<double>(baseMin, -std::numeric_limits<double>::infinity());
+
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope::from(baseMin, baseMin, baseMax, baseMax, 1),
+          Envelope::from(baseMinUp, baseMinUp, baseMaxUp, baseMaxUp, 2),
+          Envelope::from(baseMinDown, baseMinDown, baseMaxDown, baseMaxDown, 3),
+      });
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, float1Down);
+  ASSERT_EQ(bounds.minY, float1Down);
+  ASSERT_EQ(bounds.maxX, float2Up);
+  ASSERT_EQ(bounds.maxY, float2Up);
+
+  assertQuery(2.1, 2.1, 2.1, 2.1, {});
+  assertQuery(baseMin, baseMin, baseMin, baseMin, {1, 2, 3});
+  assertQuery(baseMinDown, baseMinDown, baseMinDown, baseMinDown, {1, 2, 3});
+  assertQuery(baseMinUp, baseMinUp, baseMinUp, baseMinUp, {1, 2, 3});
+  assertQuery(baseMax, baseMax, baseMax, baseMax, {1, 2, 3});
+  assertQuery(baseMaxDown, baseMaxDown, baseMaxDown, baseMaxDown, {1, 2, 3});
+  assertQuery(baseMaxUp, baseMaxUp, baseMaxUp, baseMaxUp, {1, 2, 3});
+}
+
+TEST_F(SpatialIndexTest, testFloatImprecisionSubnormal) {
+  // Check that our bumping rules work for subnormal floats as well.
+  float subnormalFloatDown =
+      std::nextafterf(0.0, -std::numeric_limits<float>::infinity());
+  float subnormalFloatUp =
+      std::nextafterf(0.0, std::numeric_limits<float>::infinity());
+
+  double subnormalDoubleDown =
+      std::nextafter<double>(0.0, -std::numeric_limits<double>::infinity());
+  double subnormalDoubleUp =
+      std::nextafter<double>(0.0, std::numeric_limits<double>::infinity());
+
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope::from(0.0, 0.0, 0.0, 0.0, 1),
+          Envelope::from(
+              subnormalDoubleDown,
+              subnormalDoubleDown,
+              subnormalDoubleDown,
+              subnormalDoubleDown,
+              2),
+          Envelope::from(
+              subnormalDoubleUp,
+              subnormalDoubleUp,
+              subnormalDoubleUp,
+              subnormalDoubleUp,
+              3),
+          Envelope::from(
+              subnormalDoubleDown,
+              subnormalDoubleDown,
+              subnormalDoubleUp,
+              subnormalDoubleUp,
+              4),
+      });
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, subnormalFloatDown);
+  ASSERT_EQ(bounds.minY, subnormalFloatDown);
+  ASSERT_EQ(bounds.maxX, subnormalFloatUp);
+  ASSERT_EQ(bounds.maxY, subnormalFloatUp);
+
+  assertQuery(0.1, 0.1, 0.1, 0.1, {});
+  assertQuery(0.0, 0.0, 0.0, 0.0, {1, 2, 3, 4});
+  assertQuery(
+      subnormalDoubleDown,
+      subnormalDoubleDown,
+      subnormalDoubleDown,
+      subnormalDoubleDown,
+      {1, 2, 3, 4});
+  assertQuery(
+      subnormalDoubleUp,
+      subnormalDoubleUp,
+      subnormalDoubleUp,
+      subnormalDoubleUp,
+      {1, 2, 3, 4});
+  assertQuery(
+      subnormalDoubleDown,
+      subnormalDoubleDown,
+      subnormalDoubleUp,
+      subnormalDoubleUp,
+      {1, 2, 3, 4});
+}
+
+TEST_F(SpatialIndexTest, testNegativeCoordinates) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{
+              .minX = -5, .minY = -5, .maxX = -1, .maxY = -1, .rowIndex = 0},
+          Envelope{
+              .minX = -10, .minY = -10, .maxX = -6, .maxY = -6, .rowIndex = 1},
+          Envelope{
+              .minX = -3, .minY = -8, .maxX = 2, .maxY = -4, .rowIndex = 2}});
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, -10);
+  ASSERT_EQ(bounds.minY, -10);
+  ASSERT_EQ(bounds.maxX, 2);
+  ASSERT_EQ(bounds.maxY, -1);
+
+  assertQuery(-7, -7, -7, -7, {1});
+  assertQuery(-2, -5, -2, -5, {0, 2});
+  assertQuery(0, 0, 1, 1, {});
+}
+
+TEST_F(SpatialIndexTest, testOverlappingEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 5, .maxX = 15, .maxY = 15, .rowIndex = 1},
+          Envelope{.minX = 2, .minY = 2, .maxX = 8, .maxY = 8, .rowIndex = 2},
+          Envelope{
+              .minX = 7, .minY = 7, .maxX = 12, .maxY = 12, .rowIndex = 3}});
+
+  assertQuery(6, 6, 6, 6, {0, 1, 2});
+  assertQuery(8, 8, 8, 8, {0, 1, 2, 3});
+  assertQuery(9, 9, 9, 9, {0, 1, 3});
+  assertQuery(3, 3, 3, 3, {0, 2});
+  assertQuery(13, 13, 13, 13, {1});
+}
+
+TEST_F(SpatialIndexTest, testNonOverlappingEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 1, .maxY = 1, .rowIndex = 0},
+          Envelope{.minX = 2, .minY = 2, .maxX = 3, .maxY = 3, .rowIndex = 1},
+          Envelope{.minX = 4, .minY = 4, .maxX = 5, .maxY = 5, .rowIndex = 2},
+          Envelope{.minX = 6, .minY = 6, .maxX = 7, .maxY = 7, .rowIndex = 3}});
+
+  assertQuery(0.5, 0.5, 0.5, 0.5, {0});
+  assertQuery(2.5, 2.5, 2.5, 2.5, {1});
+  assertQuery(4.5, 4.5, 4.5, 4.5, {2});
+  assertQuery(6.5, 6.5, 6.5, 6.5, {3});
+  assertQuery(1.5, 1.5, 1.5, 1.5, {});
+}
+
+TEST_F(SpatialIndexTest, testLargeQueryEnvelope) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 1, .minY = 1, .maxX = 2, .maxY = 2, .rowIndex = 0},
+          Envelope{.minX = 3, .minY = 3, .maxX = 4, .maxY = 4, .rowIndex = 1},
+          Envelope{.minX = 5, .minY = 5, .maxX = 6, .maxY = 6, .rowIndex = 2}});
+
+  assertQuery(0, 0, 10, 10, {0, 1, 2});
+  assertQuery(-100, -100, 100, 100, {0, 1, 2});
+}
+
+TEST_F(SpatialIndexTest, testSmallQueryEnvelope) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{
+              .minX = 0, .minY = 0, .maxX = 100, .maxY = 100, .rowIndex = 0},
+          Envelope{
+              .minX = 50,
+              .minY = 50,
+              .maxX = 150,
+              .maxY = 150,
+              .rowIndex = 1}});
+
+  assertQuery(25, 25, 26, 26, {0});
+  assertQuery(75, 75, 76, 76, {0, 1});
+  assertQuery(125, 125, 126, 126, {1});
+  assertQuery(0.1, 0.1, 0.2, 0.2, {0});
+}
+
+TEST_F(SpatialIndexTest, testEdgeTouching) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 5, .maxY = 5, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 0, .maxX = 10, .maxY = 5, .rowIndex = 1},
+          Envelope{.minX = 0, .minY = 5, .maxX = 5, .maxY = 10, .rowIndex = 2},
+          Envelope{
+              .minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 3}});
+
+  assertQuery(5, 5, 5, 5, {0, 1, 2, 3});
+  assertQuery(5, 2, 5, 2, {0, 1});
+  assertQuery(2, 5, 2, 5, {0, 2});
+}
+
+TEST_F(SpatialIndexTest, testCornerTouching) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 5, .maxY = 5, .rowIndex = 0},
+          Envelope{
+              .minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 1}});
+
+  assertQuery(5, 5, 5, 5, {0, 1});
+  assertQuery(4.9, 4.9, 5.1, 5.1, {0, 1});
+}
+
+TEST_F(SpatialIndexTest, testInfiniteValues) {
+  float inf = std::numeric_limits<float>::infinity();
+  float negInf = -std::numeric_limits<float>::infinity();
+
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 1, .maxY = 1, .rowIndex = 0}});
+
+  assertQuery(inf, inf, inf, inf, {});
+  assertQuery(negInf, negInf, negInf, negInf, {});
+  assertQuery(negInf, negInf, inf, inf, {0});
+}
+
+TEST_F(SpatialIndexTest, testLargeDataset) {
+  std::vector<Envelope> envelopes;
+  envelopes.reserve(1000);
+  for (int i = 0; i < 1000; ++i) {
+    envelopes.push_back(
+        Envelope{
+            .minX = static_cast<float>(i),
+            .minY = static_cast<float>(i),
+            .maxX = static_cast<float>(i + 1),
+            .maxY = static_cast<float>(i + 1),
+            .rowIndex = i});
+  }
+  makeIndex(std::move(envelopes));
+
+  assertQuery(500.5, 500.5, 500.5, 500.5, {500});
+  assertQuery(100.5, 100.5, 104.5, 104.5, {100, 101, 102, 103, 104});
+  assertQuery(-1, -1, -1, -1, {});
+  assertQuery(1001, 1001, 1001, 1001, {});
+
+  Envelope bounds = indexBounds();
+  ASSERT_EQ(bounds.minX, 0);
+  ASSERT_EQ(bounds.minY, 0);
+  ASSERT_EQ(bounds.maxX, 1000);
+  ASSERT_EQ(bounds.maxY, 1000);
+}
+
+TEST_F(SpatialIndexTest, testVeryLargeCoordinates) {
+  float largeVal = 1e20f;
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{
+              .minX = -largeVal,
+              .minY = -largeVal,
+              .maxX = -largeVal + 1,
+              .maxY = -largeVal + 1,
+              .rowIndex = 0},
+          Envelope{
+              .minX = largeVal - 1,
+              .minY = largeVal - 1,
+              .maxX = largeVal,
+              .maxY = largeVal,
+              .rowIndex = 1}});
+
+  assertQuery(
+      -largeVal + 0.5, -largeVal + 0.5, -largeVal + 0.5, -largeVal + 0.5, {0});
+  assertQuery(
+      largeVal - 0.5, largeVal - 0.5, largeVal - 0.5, largeVal - 0.5, {1});
+  assertQuery(0, 0, 0, 0, {});
+}
+
+TEST_F(SpatialIndexTest, testQueryOutsideBounds) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{
+              .minX = 5, .minY = 5, .maxX = 15, .maxY = 15, .rowIndex = 1}});
+
+  assertQuery(-10, -10, -5, -5, {});
+  assertQuery(20, 20, 25, 25, {});
+  assertQuery(-10, 5, -5, 10, {});
+  assertQuery(5, 20, 10, 25, {});
+}
+
+TEST_F(SpatialIndexTest, testPartialOverlap) {
+  makeIndex(
+      std::vector<Envelope>{Envelope{
+          .minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0}});
+
+  assertQuery(-5, -5, 5, 5, {0});
+  assertQuery(5, -5, 15, 5, {0});
+  assertQuery(-5, 5, 5, 15, {0});
+  assertQuery(5, 5, 15, 15, {0});
+}
+
+TEST_F(SpatialIndexTest, testMixedSizeEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{
+              .minX = 0, .minY = 0, .maxX = 0.1, .maxY = 0.1, .rowIndex = 0},
+          Envelope{
+              .minX = 1, .minY = 1, .maxX = 100, .maxY = 100, .rowIndex = 1},
+          Envelope{
+              .minX = 50, .minY = 50, .maxX = 51, .maxY = 51, .rowIndex = 2}});
+
+  assertQuery(0.05, 0.05, 0.05, 0.05, {0});
+  assertQuery(50, 50, 100, 100, {1, 2});
+  assertQuery(25, 25, 25, 25, {1});
+}
+
+TEST_F(SpatialIndexTest, testZeroAreaEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 0, .maxY = 0, .rowIndex = 0},
+          Envelope{.minX = 1, .minY = 1, .maxX = 1, .maxY = 1, .rowIndex = 1},
+          Envelope{.minX = 2, .minY = 2, .maxX = 2, .maxY = 2, .rowIndex = 2}});
+
+  assertQuery(0, 0, 0, 0, {0});
+  assertQuery(1, 1, 1, 1, {1});
+  assertQuery(2, 2, 2, 2, {2});
+  assertQuery(0.5, 0.5, 0.5, 0.5, {});
+  assertQuery(0, 0, 2, 2, {0, 1, 2});
+}
+
+TEST_F(SpatialIndexTest, testIdenticalEnvelopes) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 1},
+          Envelope{
+              .minX = 5, .minY = 5, .maxX = 10, .maxY = 10, .rowIndex = 2}});
+
+  assertQuery(7, 7, 7, 7, {0, 1, 2});
+  assertQuery(5, 5, 10, 10, {0, 1, 2});
+  assertQuery(4, 4, 4, 4, {});
+}
+
+TEST_F(SpatialIndexTest, testDifferentBranchSizes) {
+  std::vector<uint32_t> branchSizes = {2, 3, 4, 8, 16, 32, 64, 128, 256};
+
+  for (uint32_t branchSize : branchSizes) {
+    std::vector<Envelope> envelopes;
+    envelopes.reserve(100);
+    for (int i = 0; i < 100; ++i) {
+      envelopes.push_back(
+          Envelope{
+              .minX = static_cast<float>(i),
+              .minY = static_cast<float>(i),
+              .maxX = static_cast<float>(i + 1),
+              .maxY = static_cast<float>(i + 1),
+              .rowIndex = i});
+    }
+    makeIndex(std::move(envelopes), branchSize);
+
+    assertQuery(50.5, 50.5, 50.5, 50.5, {50});
+    assertQuery(10.5, 10.5, 14.5, 14.5, {10, 11, 12, 13, 14});
+    assertQuery(-1, -1, -1, -1, {});
+    assertQuery(101, 101, 101, 101, {});
+
+    Envelope bounds = indexBounds();
+    ASSERT_EQ(bounds.minX, 0);
+    ASSERT_EQ(bounds.minY, 0);
+    ASSERT_EQ(bounds.maxX, 100);
+    ASSERT_EQ(bounds.maxY, 100);
+  }
+}
+
+TEST_F(SpatialIndexTest, testSmallBranchSize) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 5, .maxX = 15, .maxY = 15, .rowIndex = 1},
+          Envelope{.minX = 2, .minY = 2, .maxX = 8, .maxY = 8, .rowIndex = 2},
+          Envelope{
+              .minX = 7, .minY = 7, .maxX = 12, .maxY = 12, .rowIndex = 3}},
+      2);
+
+  assertQuery(6, 6, 6, 6, {0, 1, 2});
+  assertQuery(8, 8, 8, 8, {0, 1, 2, 3});
+  assertQuery(9, 9, 9, 9, {0, 1, 3});
+  assertQuery(3, 3, 3, 3, {0, 2});
+  assertQuery(13, 13, 13, 13, {1});
+}
+
+TEST_F(SpatialIndexTest, testLargeBranchSize) {
+  makeIndex(
+      std::vector<Envelope>{
+          Envelope{.minX = 0, .minY = 0, .maxX = 10, .maxY = 10, .rowIndex = 0},
+          Envelope{.minX = 5, .minY = 5, .maxX = 15, .maxY = 15, .rowIndex = 1},
+          Envelope{.minX = 2, .minY = 2, .maxX = 8, .maxY = 8, .rowIndex = 2},
+          Envelope{
+              .minX = 7, .minY = 7, .maxX = 12, .maxY = 12, .rowIndex = 3}},
+      512);
+
+  assertQuery(6, 6, 6, 6, {0, 1, 2});
+  assertQuery(8, 8, 8, 8, {0, 1, 2, 3});
+  assertQuery(9, 9, 9, 9, {0, 1, 3});
+  assertQuery(3, 3, 3, 3, {0, 2});
+  assertQuery(13, 13, 13, 13, {1});
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/SpatialJoinTest.cpp b/velox/exec/tests/SpatialJoinTest.cpp
new file mode 100644
index 000000000000..01606121a403
--- /dev/null
+++ b/velox/exec/tests/SpatialJoinTest.cpp
@@ -0,0 +1,767 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/core/PlanFragment.h"
+#include "velox/core/PlanNode.h"
+#include "velox/core/QueryConfig.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;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::exec::test {
+
+class SpatialJoinTest : public OperatorTestBase {
+ public:
+  /* The polygons below have the following relations:
+   * [Legend: = equals, v overlap, / disjoint]
+   *
+   *   A  B  C  D
+   * A =  v  /  /
+   * B v  =  /  /
+   * C /  /  =  /
+   * D /  /  /  =
+   *
+   * Overlap means geometries share interior points (for full definition see
+   * (DE-9IM)[https://en.wikipedia.org/wiki/DE-9IM]), but neither contains the
+   * other.
+   */
+  static constexpr std::string_view kPolygonA =
+      "POLYGON ((0 0, -0.5 2.5, 0 5, 2.5 5.5, 5 5, 5.5 2.5, 5 0, 2.5 -0.5, 0 0))";
+  static constexpr std::string_view kPolygonB =
+      "POLYGON ((4 4, 3.5 7, 4 10, 7 10.5, 10 10, 10.5 7, 10 4, 7 3.5, 4 4))";
+  static constexpr std::string_view kPolygonC =
+      "POLYGON ((15 15, 15 14, 14 14, 14 15, 15 15))";
+  static constexpr std::string_view kPolygonD =
+      "POLYGON ((18 18, 18 19, 19 19, 19 18, 18 18))";
+
+  // A set of points: X in A, Y in A and B, Z in B, W outside of A and B
+  static constexpr std::string_view kPointX = "POINT (1 1)";
+  static constexpr std::string_view kPointY = "POINT (4.5 4.5)";
+  static constexpr std::string_view kPointZ = "POINT (6 6)";
+  static constexpr std::string_view kPointW = "POINT (20 20)";
+  static constexpr std::string_view kPointV = "POINT (15 15)";
+  static constexpr std::string_view kPointS = "POINT (18 18)";
+  static constexpr std::string_view kPointQ = "POINT (28 28)";
+  static constexpr std::string_view kMultipointU = "MULTIPOINT (15 15)";
+  static constexpr std::string_view kMultipointT =
+      "MULTIPOINT (14.5 14.5, 16 16)";
+  static constexpr std::string_view kMultipointR = "MULTIPOINT (15 15, 19 19)";
+
+ protected:
+  void runTest(
+      const std::vector<std::optional<std::string_view>>& probeWkts,
+      const std::vector<std::optional<std::string_view>>& buildWkts,
+      const std::optional<const std::vector<std::optional<double>>>& radiiOpt,
+      const std::string& predicate,
+      core::JoinType joinType,
+      const std::vector<std::optional<std::string_view>>& expectedLeftWkts,
+      const std::vector<std::optional<std::string_view>>& expectedRightWkts) {
+    for (bool separateProbeBatches : {false, true}) {
+      for (size_t maxBatchSize : {128, 3, 2, 1}) {
+        for (int32_t maxDrivers : {1, 4}) {
+          runTestWithConfig(
+              probeWkts,
+              buildWkts,
+              radiiOpt,
+              predicate,
+              joinType,
+              expectedLeftWkts,
+              expectedRightWkts,
+              maxDrivers,
+              maxBatchSize,
+              separateProbeBatches);
+        }
+      }
+    }
+  }
+
+  void runTestWithConfig(
+      const std::vector<std::optional<std::string_view>>& probeWkts,
+      const std::vector<std::optional<std::string_view>>& buildWkts,
+      const std::optional<const std::vector<std::optional<double>>>& radiiOpt,
+      const std::string& predicate,
+      core::JoinType joinType,
+      const std::vector<std::optional<std::string_view>>& expectedLeftWkts,
+      const std::vector<std::optional<std::string_view>>& expectedRightWkts,
+      int32_t maxDrivers,
+      size_t maxBatchSize,
+      bool separateBatches) {
+    std::vector<std::optional<std::string>> probeWktsStr(
+        probeWkts.begin(), probeWkts.end());
+    std::vector<std::optional<std::string>> buildWktsStr(
+        buildWkts.begin(), buildWkts.end());
+    std::vector<std::optional<std::string>> expectedLeftWktsStr(
+        expectedLeftWkts.begin(), expectedLeftWkts.end());
+    std::vector<std::optional<std::string>> expectedRightWktsStr(
+        expectedRightWkts.begin(), expectedRightWkts.end());
+    auto radii = radiiOpt.value_or(
+        std::vector<std::optional<double>>(buildWkts.size(), std::nullopt));
+    VELOX_CHECK_EQ(radii.size(), buildWkts.size());
+    std::optional<std::string> radiusVariable = std::nullopt;
+    if (radiiOpt.has_value()) {
+      radiusVariable = "radius";
+    }
+
+    std::vector<RowVectorPtr> probeBatches;
+    std::vector<RowVectorPtr> buildBatches;
+    if (separateBatches) {
+      for (const auto& wkt : probeWktsStr) {
+        probeBatches.push_back(makeRowVector(
+            {"left_g"}, {makeNullableFlatVector<std::string>({wkt})}));
+      }
+      if (probeBatches.empty()) {
+        probeBatches.push_back(makeRowVector(
+            {"left_g"}, {makeNullableFlatVector<std::string>({})}));
+      }
+
+      for (size_t idx = 0; idx < buildWktsStr.size(); ++idx) {
+        auto& wkt = buildWktsStr[idx];
+        buildBatches.push_back(makeRowVector(
+            {"right_g", "radius"},
+            {makeNullableFlatVector<std::string>({wkt}),
+             makeNullableFlatVector<double>({radii[idx]})}));
+      }
+      if (buildBatches.empty()) {
+        buildBatches.push_back(makeRowVector(
+            {"right_g", "radius"},
+            {makeNullableFlatVector<std::string>({}),
+             makeNullableFlatVector<double>({})}));
+      }
+    } else {
+      probeBatches.push_back(makeRowVector(
+          {"left_g"}, {makeNullableFlatVector<std::string>(probeWktsStr)}));
+      buildBatches.push_back(makeRowVector(
+          {"right_g", "radius"},
+          {makeNullableFlatVector<std::string>(buildWktsStr),
+           makeNullableFlatVector<double>(radii)}));
+    }
+    auto expectedRows = makeRowVector(
+        {"left_g", "right_g"},
+        {makeNullableFlatVector<std::string>(expectedLeftWktsStr),
+         makeNullableFlatVector<std::string>(expectedRightWktsStr)});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .values(probeBatches)
+            .project({"ST_GeometryFromText(left_g) AS left_g"})
+            .localPartitionRoundRobinRow()
+            .spatialJoin(
+                PlanBuilder(planNodeIdGenerator)
+                    .values(buildBatches)
+                    .project(
+                        {"ST_GeometryFromText(right_g) AS right_g", "radius"})
+                    .localPartition({})
+                    .planNode(),
+                predicate,
+                "left_g",
+                "right_g",
+                radiusVariable,
+                {"left_g", "right_g"},
+                joinType)
+            .project(
+                {"ST_AsText(left_g) AS left_g",
+                 "ST_AsText(right_g) AS right_g"})
+            .planNode();
+    AssertQueryBuilder builder{plan};
+    builder.maxDrivers(maxDrivers)
+        .config(core::QueryConfig::kPreferredOutputBatchRows, maxBatchSize)
+        .config(core::QueryConfig::kMaxOutputBatchRows, maxBatchSize)
+        .assertResults({expectedRows});
+  }
+};
+
+TEST_F(SpatialJoinTest, testTrivialSpatialJoin) {
+  runTest(
+      {"POINT (1 1)"},
+      {"POINT (1 1)"},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (1 1)"},
+      {"POINT (1 1)"});
+}
+
+TEST_F(SpatialJoinTest, testSimpleSpatialInnerJoin) {
+  runTest(
+      {"POINT (1 1)", "POINT (1 2)"},
+      {"POINT (1 1)", "POINT (2 1)"},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (1 1)"},
+      {"POINT (1 1)"});
+}
+
+TEST_F(SpatialJoinTest, testSimpleSpatialLeftJoin) {
+  runTest(
+      {"POINT (1 1)", "POINT (1 2)"},
+      {"POINT (1 1)", "POINT (2 1)"},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kLeft,
+      {"POINT (1 1)", "POINT (1 2)"},
+      {"POINT (1 1)", std::nullopt});
+}
+
+TEST_F(SpatialJoinTest, testSpatialJoinNullRows) {
+  runTest(
+      {"POINT (0 0)", std::nullopt, "POINT (1 1)", std::nullopt},
+      {"POINT (0 0)", "POINT (1 1)", std::nullopt, std::nullopt},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (0 0)", "POINT (1 1)"},
+      {"POINT (0 0)", "POINT (1 1)"});
+  runTest(
+      {"POINT (0 0)", std::nullopt, "POINT (2 2)", std::nullopt},
+      {"POINT (0 0)", "POINT (1 1)", std::nullopt, std::nullopt},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kLeft,
+      {"POINT (0 0)", "POINT (2 2)", std::nullopt, std::nullopt},
+      {"POINT (0 0)", std::nullopt, std::nullopt, std::nullopt});
+}
+
+// Test geometries that don't intersect but their envelopes do.
+// Important to test spatial index
+TEST_F(SpatialJoinTest, simpleSpatialJoinEnvelopes) {
+  runTest(
+      {"POINT (0.5 0.6)", "POINT (0.5 0.5)", "LINESTRING (0 0.1, 0.9 1)"},
+      {"POLYGON ((0 0, 1 1, 1 0, 0 0))"},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (0.5 0.5)"},
+      {"POLYGON ((0 0, 1 1, 1 0, 0 0))"});
+}
+
+TEST_F(SpatialJoinTest, testSelfSpatialJoin) {
+  std::vector<std::optional<std::string_view>> inputWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+  std::vector<std::optional<std::string_view>> leftOutputWkts = {
+      kPolygonA, kPolygonA, kPolygonB, kPolygonB, kPolygonC, kPolygonD};
+  std::vector<std::optional<std::string_view>> rightOutputWkts = {
+      kPolygonA, kPolygonB, kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+
+  runTest(
+      inputWkts,
+      inputWkts,
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      leftOutputWkts,
+      rightOutputWkts);
+
+  runTest(
+      inputWkts,
+      inputWkts,
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kLeft,
+      leftOutputWkts,
+      rightOutputWkts);
+
+  runTest(
+      inputWkts,
+      inputWkts,
+      std::nullopt,
+      "ST_Overlaps(left_g, right_g)",
+      core::JoinType::kInner,
+      {kPolygonA, kPolygonB},
+      {kPolygonB, kPolygonA});
+
+  runTest(
+      inputWkts,
+      inputWkts,
+      std::nullopt,
+      "ST_Intersects(left_g, right_g) AND ST_Overlaps(left_g, right_g)",
+      core::JoinType::kInner,
+      {kPolygonA, kPolygonB},
+      {kPolygonB, kPolygonA});
+
+  runTest(
+      inputWkts,
+      inputWkts,
+      std::nullopt,
+      "ST_Overlaps(left_g, right_g)",
+      core::JoinType::kLeft,
+      {kPolygonA, kPolygonB, kPolygonC, kPolygonD},
+      {kPolygonB, kPolygonA, std::nullopt, std::nullopt});
+
+  runTest(
+      inputWkts,
+      inputWkts,
+      std::nullopt,
+      "ST_Equals(left_g, right_g)",
+      core::JoinType::kInner,
+      inputWkts,
+      inputWkts);
+
+  runTest(
+      inputWkts,
+      inputWkts,
+      std::nullopt,
+      "ST_Equals(left_g, right_g)",
+      core::JoinType::kLeft,
+      inputWkts,
+      inputWkts);
+}
+
+TEST_F(SpatialJoinTest, pointPolygonSpatialJoin) {
+  std::vector<std::optional<std::string_view>> polygonWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+  std::vector<std::optional<std::string_view>> pointWkts = {
+      kPointX,
+      kPointY,
+      kPointZ,
+      kPointW,
+      kPointV,
+      kPointS,
+      kPointQ,
+      kMultipointU,
+      kMultipointT,
+      kMultipointR};
+
+  std::vector<std::optional<std::string_view>> pointOutputWkts = {
+      kPointX,
+      kPointY,
+      kPointY,
+      kPointZ,
+      kPointV,
+      kPointS,
+      kMultipointU,
+      kMultipointR,
+      kMultipointR,
+      kMultipointT};
+  std::vector<std::optional<std::string_view>> polygonOutputWkts = {
+      kPolygonA,
+      kPolygonA,
+      kPolygonB,
+      kPolygonB,
+      kPolygonC,
+      kPolygonD,
+      kPolygonC,
+      kPolygonC,
+      kPolygonD,
+      kPolygonC};
+  runTest(
+      pointWkts,
+      polygonWkts,
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      pointOutputWkts,
+      polygonOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testSimpleNullRowsJoin) {
+  runTest(
+      {"POINT (1 1)", std::nullopt, "POINT (1 2)"},
+      {"POINT (1 1)", "POINT (2 1)", std::nullopt},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"POINT (1 1)"},
+      {"POINT (1 1)"});
+}
+
+TEST_F(SpatialJoinTest, testGeometryCollection) {
+  runTest(
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION EMPTY",
+       "POINT (1 1)"},
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION EMPTY",
+       "POINT (1 1)"},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION (POINT (1 1))",
+       "POINT (1 1)",
+       "POINT (1 1)"},
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "POINT (1 1)",
+       "GEOMETRYCOLLECTION (POINT (1 1))",
+       "POINT (1 1)"});
+
+  runTest(
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION EMPTY",
+       "POINT (1 1)"},
+      {"GEOMETRYCOLLECTION (POINT (1 2))",
+       "GEOMETRYCOLLECTION EMPTY",
+       "POINT (1 2)"},
+      std::vector<std::optional<double>>{1.0, 1.0, 1.0},
+      "ST_Distance(left_g, right_g) <= radius",
+      core::JoinType::kInner,
+      {"GEOMETRYCOLLECTION (POINT (1 1))",
+       "GEOMETRYCOLLECTION (POINT (1 1))",
+       "POINT (1 1)",
+       "POINT (1 1)"},
+      {"GEOMETRYCOLLECTION (POINT (1 2))",
+       "POINT (1 2)",
+       "GEOMETRYCOLLECTION (POINT (1 2))",
+       "POINT (1 2)"});
+}
+
+TEST_F(SpatialJoinTest, testDistanceJoin) {
+  runTest(
+      {"POINT (1 2)", "POLYGON ((1 2, 2 2, 2 3, 1 3, 1 2))", std::nullopt},
+      {"POINT (2 2)",
+       "POINT (1 1)",
+       std::nullopt,
+       "POINT (1 2)",
+       "POLYGON ((1 1, 1 0, 0 0, 0 1, 1 1))"},
+      std::vector<std::optional<double>>{std::nullopt, 1.0, 0.0, 0.0, 1.0},
+      "ST_Distance(left_g, right_g) <= radius",
+      core::JoinType::kInner,
+      {"POINT (1 2)",
+       "POLYGON ((1 2, 1 3, 2 3, 2 2, 1 2))",
+       "POINT (1 2)",
+       "POLYGON ((1 2, 1 3, 2 3, 2 2, 1 2))",
+       "POINT (1 2)",
+       "POLYGON ((1 2, 1 3, 2 3, 2 2, 1 2))"},
+      {"POINT (1 1)",
+       "POINT (1 1)",
+       "POINT (1 2)",
+       "POINT (1 2)",
+       "POLYGON ((1 1, 1 0, 0 0, 0 1, 1 1))",
+       "POLYGON ((1 1, 1 0, 0 0, 0 1, 1 1))"});
+}
+
+TEST_F(SpatialJoinTest, testContainsPointsInPolygons) {
+  // Tests ST_Contains(polygon, point) - which polygons contain which points
+  std::vector<std::optional<std::string_view>> pointWkts = {
+      kPointX, kPointY, kPointZ, kPointW};
+  std::vector<std::optional<std::string_view>> polygonWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+
+  // Expected: A contains X, B contains Y, B contains Z, A contains Y, D
+  // contains nothing from our test set Note: Y is in both A and B since they
+  // overlap
+  std::vector<std::optional<std::string_view>> pointOutputWkts = {
+      kPointX, kPointY, kPointY, kPointZ};
+  std::vector<std::optional<std::string_view>> polygonOutputWkts = {
+      kPolygonA, kPolygonA, kPolygonB, kPolygonB};
+
+  runTest(
+      pointWkts,
+      polygonWkts,
+      std::nullopt,
+      "ST_Contains(right_g, left_g)",
+      core::JoinType::kInner,
+      pointOutputWkts,
+      polygonOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testContainsPolygonsInPolygons) {
+  // Tests ST_Contains(polygon, polygon) - which polygons contain which polygons
+  // From the Java test, polygon C contains polygon B (C is larger and covers B)
+  std::vector<std::optional<std::string_view>> polygonWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+
+  // Each polygon contains itself, plus any additional containments
+  // Based on the spatial relations, we need to check which polygons actually
+  // contain others For now, test self-containment which should always work
+  std::vector<std::optional<std::string_view>> leftOutputWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+  std::vector<std::optional<std::string_view>> rightOutputWkts = {
+      kPolygonA, kPolygonB, kPolygonC, kPolygonD};
+
+  runTest(
+      polygonWkts,
+      polygonWkts,
+      std::nullopt,
+      "ST_Contains(right_g, left_g)",
+      core::JoinType::kInner,
+      leftOutputWkts,
+      rightOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testContainsLeftJoin) {
+  // Tests ST_Contains with LEFT join - all probe rows should appear
+  std::vector<std::optional<std::string_view>> pointWkts = {
+      kPointX, kPointY, kPointZ, kPointW};
+  std::vector<std::optional<std::string_view>> polygonWkts = {
+      kPolygonA, kPolygonB};
+
+  // W is outside both polygons, so it should have null for the right side
+  std::vector<std::optional<std::string_view>> pointOutputWkts = {
+      kPointX, kPointY, kPointY, kPointZ, kPointW};
+  std::vector<std::optional<std::string_view>> polygonOutputWkts = {
+      kPolygonA, kPolygonA, kPolygonB, kPolygonB, std::nullopt};
+
+  runTest(
+      pointWkts,
+      polygonWkts,
+      std::nullopt,
+      "ST_Contains(right_g, left_g)",
+      core::JoinType::kLeft,
+      pointOutputWkts,
+      polygonOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testTouches) {
+  // Test ST_Touches - geometries that touch at boundary but don't overlap
+  // Polygon and a point on its boundary
+  std::vector<std::optional<std::string_view>> probeWkts = {
+      "POINT (1 2)", "POINT (3 2)", "LINESTRING (0 0, 1 1)"};
+  std::vector<std::optional<std::string_view>> buildWkts = {
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))",
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"};
+
+  // Point (1,2) touches both polygons (on their boundaries)
+  // Point (3,2) touches second polygon (on its boundary)
+  // LineString (0 0, 1 1) touches both polygons (endpoint at (1,1))
+  std::vector<std::optional<std::string_view>> probeOutputWkts = {
+      "POINT (1 2)",
+      "POINT (1 2)",
+      "POINT (3 2)",
+      "LINESTRING (0 0, 1 1)",
+      "LINESTRING (0 0, 1 1)"};
+  std::vector<std::optional<std::string_view>> buildOutputWkts = {
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))",
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))",
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"};
+
+  runTest(
+      probeWkts,
+      buildWkts,
+      std::nullopt,
+      "ST_Touches(left_g, right_g)",
+      core::JoinType::kInner,
+      probeOutputWkts,
+      buildOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testTouchesPolygons) {
+  // Test ST_Touches with two polygons that touch at a corner
+  std::vector<std::optional<std::string_view>> probeWkts = {
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((5 5, 5 6, 6 6, 6 5, 5 5))"};
+  std::vector<std::optional<std::string_view>> buildWkts = {
+      "POLYGON ((3 3, 3 5, 5 5, 5 3, 3 3))"};
+
+  // Both polygons touch the build polygon at corners:
+  // - First polygon touches at (3,3)
+  // - Second polygon touches at (5,5)
+  std::vector<std::optional<std::string_view>> probeOutputWkts = {
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((5 5, 5 6, 6 6, 6 5, 5 5))"};
+  std::vector<std::optional<std::string_view>> buildOutputWkts = {
+      "POLYGON ((3 3, 3 5, 5 5, 5 3, 3 3))",
+      "POLYGON ((3 3, 3 5, 5 5, 5 3, 3 3))"};
+
+  runTest(
+      probeWkts,
+      buildWkts,
+      std::nullopt,
+      "ST_Touches(left_g, right_g)",
+      core::JoinType::kInner,
+      probeOutputWkts,
+      buildOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testCrosses) {
+  // Test ST_Crosses - geometries that cross each other
+  // A linestring crossing a polygon
+  std::vector<std::optional<std::string_view>> probeWkts = {
+      "LINESTRING (0 0, 4 4)", // Crosses both polygons
+      "LINESTRING (5 0, 5 4)", // Outside both
+      "LINESTRING (1 1, 2 2)" // Contained in polygon, doesn't cross
+  };
+  std::vector<std::optional<std::string_view>> buildWkts = {
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"};
+
+  // Only the first linestring crosses the polygon
+  std::vector<std::optional<std::string_view>> probeOutputWkts = {
+      "LINESTRING (0 0, 4 4)"};
+  std::vector<std::optional<std::string_view>> buildOutputWkts = {
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"};
+
+  runTest(
+      probeWkts,
+      buildWkts,
+      std::nullopt,
+      "ST_Crosses(left_g, right_g)",
+      core::JoinType::kInner,
+      probeOutputWkts,
+      buildOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testCrossesLineStrings) {
+  // Test ST_Crosses with two linestrings that cross each other
+  std::vector<std::optional<std::string_view>> probeWkts = {
+      "LINESTRING (0 0, 1 1)", // Crosses first build linestring
+      "LINESTRING (2 2, 3 3)" // Parallel, doesn't cross
+  };
+  std::vector<std::optional<std::string_view>> buildWkts = {
+      "LINESTRING (1 0, 0 1)"};
+
+  // Only the first linestring crosses
+  std::vector<std::optional<std::string_view>> probeOutputWkts = {
+      "LINESTRING (0 0, 1 1)"};
+  std::vector<std::optional<std::string_view>> buildOutputWkts = {
+      "LINESTRING (1 0, 0 1)"};
+
+  runTest(
+      probeWkts,
+      buildWkts,
+      std::nullopt,
+      "ST_Crosses(left_g, right_g)",
+      core::JoinType::kInner,
+      probeOutputWkts,
+      buildOutputWkts);
+}
+
+TEST_F(SpatialJoinTest, testEmptyBuild) {
+  runTest(
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      {},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {},
+      {});
+  runTest(
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      {},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kLeft,
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
+
+TEST_F(SpatialJoinTest, testEmptyProbe) {
+  runTest(
+      {},
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kInner,
+      {},
+      {});
+  runTest(
+      {},
+      {kPointX, std::nullopt, kPointY, kPointZ, kPointW},
+      std::nullopt,
+      "ST_Intersects(left_g, right_g)",
+      core::JoinType::kLeft,
+      {},
+      {});
+}
+
+TEST_F(SpatialJoinTest, failOnGroupedExecution) {
+  std::vector<RowVectorPtr> batches{
+      makeRowVector({"wkt"}, {makeFlatVector<std::string>({"POINT(0 0)"})})};
+  core::PlanNodeId groupedScanNodeId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto planFragment =
+      PlanBuilder(planNodeIdGenerator)
+          .values(batches)
+          .capturePlanNodeId(groupedScanNodeId)
+          .project({"ST_GeometryFromText(wkt) AS left_g"})
+          .spatialJoin(
+              PlanBuilder(planNodeIdGenerator)
+                  .values(batches)
+                  .project({"ST_GeometryFromText(wkt) AS right_g"})
+                  .localPartition({})
+                  .planNode(),
+              "ST_Intersects(left_g, right_g)",
+              "left_g",
+              "right_g",
+              std::nullopt,
+              {"left_g", "right_g"},
+              core::JoinType::kInner)
+          .project(
+              {"ST_AsText(left_g) AS left_g", "ST_AsText(right_g) AS right_g"})
+          .planFragment();
+  planFragment.executionStrategy = core::ExecutionStrategy::kGrouped;
+  planFragment.groupedExecutionLeafNodeIds.emplace(groupedScanNodeId);
+  auto task = Task::create(
+      "task-grouped-join",
+      std::move(planFragment),
+      0,
+      core::QueryCtx::create(driverExecutor_.get()),
+      Task::ExecutionMode::kParallel);
+
+  VELOX_ASSERT_THROW(
+      task->start(1), "Spatial joins do not support grouped execution.");
+}
+
+TEST_F(SpatialJoinTest, testLargeJoinSize) {
+  size_t numRows = 64;
+  size_t maxCoord = 17;
+  std::vector<std::string> buildWkts;
+  buildWkts.reserve(numRows);
+  std::vector<std::string> probeWkts;
+  probeWkts.reserve(numRows);
+  for (size_t i = 0; i < numRows; ++i) {
+    buildWkts.push_back(
+        fmt::format("POINT ({} {})", (i + 1) % maxCoord, (i + 2) % maxCoord));
+    probeWkts.push_back(
+        fmt::format("POINT ({} {})", i % maxCoord, (i + 1) % maxCoord));
+  }
+
+  std::vector<std::optional<std::string_view>> buildWktsView;
+  buildWktsView.reserve(numRows);
+  std::vector<std::optional<std::string_view>> probeWktsView;
+  probeWktsView.reserve(numRows);
+  for (size_t i = 0; i < numRows; ++i) {
+    buildWktsView.push_back(buildWkts[i]);
+    probeWktsView.push_back(probeWkts[i]);
+  }
+
+  std::vector<std::optional<std::string_view>> expectedLeftWkts;
+  expectedLeftWkts.reserve(numRows * numRows / maxCoord);
+  std::vector<std::optional<std::string_view>> expectedRightWkts;
+  expectedRightWkts.reserve(numRows * numRows / maxCoord);
+  for (size_t innerIdx = 0; innerIdx < numRows; ++innerIdx) {
+    for (size_t outerIdx = 0; outerIdx < numRows; ++outerIdx) {
+      if (probeWkts[outerIdx] == buildWkts[innerIdx]) {
+        expectedLeftWkts.push_back(probeWkts[outerIdx]);
+        expectedRightWkts.push_back(buildWkts[innerIdx]);
+      }
+    }
+  }
+
+  for (bool separateProbeBatches : {false, true}) {
+    for (size_t maxBatchSize : {64, 13, 7, 5, 3, 2, 1}) {
+      runTestWithConfig(
+          buildWktsView,
+          probeWktsView,
+          std::nullopt,
+          "ST_Equals(left_g, right_g)",
+          core::JoinType::kInner,
+          expectedLeftWkts,
+          expectedRightWkts,
+          1,
+          maxBatchSize,
+          separateProbeBatches);
+    }
+  }
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/SpillTest.cpp b/velox/exec/tests/SpillTest.cpp
index 9097abd7f664..1ba324c042ab 100644
--- a/velox/exec/tests/SpillTest.cpp
+++ b/velox/exec/tests/SpillTest.cpp
@@ -23,6 +23,7 @@
 #include "velox/common/file/FileSystems.h"
 #include "velox/exec/OperatorUtils.h"
 #include "velox/exec/Spill.h"
+#include "velox/exec/tests/utils/MergeTestBase.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/type/Timestamp.h"
@@ -394,6 +395,31 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
     ASSERT_EQ(numFinishedFiles, expectedFiles);
   }
 
+  void hybridSpillStateTest(
+      int64_t targetFileSize,
+      int numPartitions,
+      int numBatches,
+      int numDuplicates,
+      const std::vector<CompareFlags>& compareFlags,
+      uint64_t expectedNumSpilledFiles) {
+    int mergeWayThresholdBegin = 0;
+    int mergeWayThresholdEnd = 4;
+    for (int i = mergeWayThresholdBegin; i < mergeWayThresholdEnd; i++) {
+      if (i == 1) {
+        // Skip invalid value.
+        continue;
+      }
+      spillStateTest(
+          targetFileSize,
+          numPartitions,
+          numBatches,
+          numDuplicates,
+          compareFlags,
+          expectedNumSpilledFiles,
+          i);
+    }
+  }
+
   // 'numDuplicates' specifies the number of duplicates generated for each
   // distinct sort key value in test.
   void spillStateTest(
@@ -402,16 +428,18 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
       int numBatches,
       int numDuplicates,
       const std::vector<CompareFlags>& compareFlags,
-      uint64_t expectedNumSpilledFiles) {
+      uint64_t expectedNumSpilledFiles,
+      int mergeWayThreshold) {
     const int numRowsPerBatch = 1'000;
-    SCOPED_TRACE(fmt::format(
-        "targetFileSize: {}, numPartitions: {}, numBatches: {}, numDuplicates: {}, nullsFirst: {}, ascending: {}",
-        targetFileSize,
-        numPartitions,
-        numBatches,
-        numDuplicates,
-        compareFlags.empty() ? true : compareFlags[0].nullsFirst,
-        compareFlags.empty() ? true : compareFlags[0].ascending));
+    SCOPED_TRACE(
+        fmt::format(
+            "targetFileSize: {}, numPartitions: {}, numBatches: {}, numDuplicates: {}, nullsFirst: {}, ascending: {}",
+            targetFileSize,
+            numPartitions,
+            numBatches,
+            numDuplicates,
+            compareFlags.empty() ? true : compareFlags[0].nullsFirst,
+            compareFlags.empty() ? true : compareFlags[0].ascending));
 
     const auto prevGStats = common::globalSpillStats();
 
@@ -488,13 +516,20 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
     ASSERT_EQ(stats.spilledBytes, totalFileBytes);
     ASSERT_EQ(prevGStats.spilledBytes + totalFileBytes, newGStats.spilledBytes);
 
+    bool usePreMerge = mergeWayThreshold >= 2;
     for (const auto& partitionId : partitionIds) {
       auto spillFiles = state_->finish(partitionId);
       ASSERT_EQ(state_->numFinishedFiles(partitionId), 0);
       auto spillPartition =
           SpillPartition(SpillPartitionId(partitionId), std::move(spillFiles));
-      auto merge =
-          spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_);
+      auto spillConfig = common::SpillConfig();
+      spillConfig.numMaxMergeFiles = mergeWayThreshold;
+      spillConfig.readBufferSize = 1 << 20;
+      spillConfig.writeBufferSize = 1 << 20;
+      spillConfig.updateAndCheckSpillLimitCb = [](int64_t) {};
+      spillConfig.fileCreateConfig = "";
+      std::unique_ptr<TreeOfLosers<SpillMergeStream>> merge =
+          spillPartition.createOrderedReader(spillConfig, pool(), &spillStats_);
       int numReadBatches = 0;
       // We expect all the rows in dense increasing order.
       for (auto i = 0; i < numBatches * numRowsPerBatch; ++i) {
@@ -527,8 +562,10 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
         }
       }
       ASSERT_EQ(nullptr, merge->next());
-      // We do two append writes per each input batch.
-      ASSERT_EQ(numBatches, numReadBatches);
+      if (!usePreMerge) {
+        // We do two append writes per each input batch.
+        ASSERT_EQ(numBatches, numReadBatches);
+      }
     }
 
     const auto finalStats = spillStats_.copy();
@@ -567,7 +604,67 @@ class SpillTest : public ::testing::TestWithParam<uint32_t>,
       ASSERT_TRUE(fs->exists(spilledFile));
     }
     // Verify stats.
-    ASSERT_EQ(runtimeStats_["spillFileSize"].count, spilledFiles.size());
+    if (!usePreMerge) {
+      ASSERT_EQ(runtimeStats_["spillFileSize"].count, spilledFiles.size());
+    } else {
+      ASSERT_GE(runtimeStats_["spillFileSize"].count, spilledFiles.size());
+    }
+  }
+
+  void gatherMergeTest(
+      int32_t numValues,
+      int numMergeWays,
+      int targetSize,
+      bool useRandom) {
+    auto goldenVector = makeRowVector({
+        makeFlatVector<int32_t>(numValues, [&](auto row) { return row; }),
+    });
+    std::vector<std::vector<int32_t>> mergeWays(numMergeWays);
+    for (int32_t value = 0; value < numValues; value++) {
+      int way = useRandom ? folly::Random::rand32() % numMergeWays
+                          : value % numMergeWays;
+      mergeWays[way].push_back(value);
+    }
+    std::vector<RowVectorPtr> sources;
+    std::vector<std::unique_ptr<SpillMergeStream>> streams;
+    std::vector<SpillSortKey> sortKeys = {{0, {true, true}}};
+    for (int way = 0; way < numMergeWays; way++) {
+      auto source = makeRowVector({
+          makeFlatVector<int32_t>(
+              mergeWays[way].size(),
+              [&](auto row) { return mergeWays[way][row]; }),
+      });
+      sources.push_back(source);
+      streams.push_back(
+          std::make_unique<exec::test::TestingSpillMergeStream>(
+              way, sortKeys, source));
+    }
+    auto mergeTree =
+        std::make_unique<TreeOfLosers<SpillMergeStream>>(std::move(streams));
+    RowVectorPtr targetVector = std::static_pointer_cast<RowVector>(
+        BaseVector::create(sources[0]->type(), targetSize, pool_.get()));
+    std::vector<const RowVector*> bufferSources(targetSize);
+    std::vector<vector_size_t> bufferSourceIndices(targetSize);
+    for (int32_t batch = 0; batch * targetSize < numValues; batch++) {
+      int32_t valueBegin = batch * targetSize;
+      int32_t valueEnd = valueBegin + targetSize;
+      valueEnd = std::min(valueEnd, numValues);
+      VectorPtr tmp = std::move(targetVector);
+      BaseVector::prepareForReuse(tmp, targetSize);
+      targetVector = std::static_pointer_cast<RowVector>(tmp);
+      for (auto& child : targetVector->children()) {
+        child->resize(targetSize);
+      }
+      int count = 0;
+      testingGatherMerge(
+          targetVector, *mergeTree, count, bufferSources, bufferSourceIndices);
+      EXPECT_EQ(count, valueEnd - valueBegin);
+      auto result = targetVector->childAt(0).get();
+      auto golden = goldenVector->childAt(0).get();
+      for (int32_t row = 0; row < valueEnd - valueBegin; row++) {
+        EXPECT_TRUE(result->equalValueAt(golden, row, valueBegin + row));
+      }
+    }
   }
 
   folly::Random::DefaultGenerator rng_;
@@ -591,18 +688,18 @@ TEST_P(SpillTest, spillState) {
   // triggered by batch write.
 
   // Test with distinct sort keys.
-  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);
+  hybridSpillStateTest(kGB, 2, 8, 1, {CompareFlags{true, true}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {CompareFlags{true, false}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {CompareFlags{false, true}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {CompareFlags{false, false}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 1, {}, 8);
 
   // Test with duplicate sort keys.
-  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);
+  hybridSpillStateTest(kGB, 2, 8, 8, {CompareFlags{true, true}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {CompareFlags{true, false}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {CompareFlags{false, true}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {CompareFlags{false, false}}, 8);
+  hybridSpillStateTest(kGB, 2, 8, 8, {}, 8);
 }
 
 TEST_P(SpillTest, spillTimestamp) {
@@ -646,11 +743,17 @@ TEST_P(SpillTest, spillTimestamp) {
       state.testingNonEmptySpilledPartitionIdSet().contains(partitionId));
 
   SpillPartition spillPartition(SpillPartitionId{0}, state.finish(partitionId));
+  auto spillConfig = common::SpillConfig();
+  spillConfig.numMaxMergeFiles = 2;
+  spillConfig.readBufferSize = 1 << 20;
+  spillConfig.writeBufferSize = 1 << 20;
+  spillConfig.updateAndCheckSpillLimitCb = [](int64_t) {};
+  spillConfig.fileCreateConfig = "";
   auto merge =
-      spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_);
+      spillPartition.createOrderedReader(spillConfig, pool(), &spillStats_);
   ASSERT_TRUE(merge != nullptr);
   ASSERT_TRUE(
-      spillPartition.createOrderedReader(1 << 20, pool(), &spillStats_) ==
+      spillPartition.createOrderedReader(spillConfig, pool(), &spillStats_) ==
       nullptr);
   for (auto i = 0; i < timeValues.size(); ++i) {
     auto* stream = merge->next();
@@ -668,18 +771,18 @@ TEST_P(SpillTest, spillStateWithSmallTargetFileSize) {
   // write.
 
   // Test with distinct sort keys.
-  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);
+  hybridSpillStateTest(1, 2, 8, 1, {CompareFlags{true, true}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {CompareFlags{true, false}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {CompareFlags{false, true}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {CompareFlags{false, false}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 1, {}, 8 * 2);
 
   // Test with duplicated sort keys.
-  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);
+  hybridSpillStateTest(1, 2, 8, 8, {CompareFlags{true, false}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {CompareFlags{true, true}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {CompareFlags{false, false}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {CompareFlags{false, true}}, 8 * 2);
+  hybridSpillStateTest(1, 2, 8, 8, {}, 8 * 2);
 }
 
 TEST_P(SpillTest, spillPartitionId) {
@@ -958,12 +1061,15 @@ TEST_P(SpillTest, spillPartitionFunctionBasic) {
     std::vector<VectorPtr> columns;
     columns.push_back(
         makeFlatVector<int64_t>(numRows, [](auto row) { return row; }));
-    columns.push_back(makeFlatVector<std::string>(
-        numRows, [](auto row) { return fmt::format("key_{}", row); }));
-    columns.push_back(makeFlatVector<std::string>(
-        numRows, [](auto row) { return fmt::format("key_{}_{}", row, row); }));
-    columns.push_back(makeFlatVector<std::string>(
-        numRows, [](auto row) { return fmt::format("val_{}", row); }));
+    columns.push_back(makeFlatVector<std::string>(numRows, [](auto row) {
+      return fmt::format("key_{}", row);
+    }));
+    columns.push_back(makeFlatVector<std::string>(numRows, [](auto row) {
+      return fmt::format("key_{}_{}", row, row);
+    }));
+    columns.push_back(makeFlatVector<std::string>(numRows, [](auto row) {
+      return fmt::format("val_{}", row);
+    }));
     inputVectors.push_back(makeRowVector(columns));
   }
 
@@ -1522,6 +1628,17 @@ TEST(SpillTest, scopedSpillInjectionRegex) {
   }
 }
 
+TEST_P(SpillTest, gatherMerge) {
+  gatherMergeTest(1234, 2, 10, false);
+  gatherMergeTest(1234, 2, 100, false);
+  gatherMergeTest(1234, 10, 10, false);
+  gatherMergeTest(1234, 10, 100, false);
+  gatherMergeTest(1234, 2, 10, true);
+  gatherMergeTest(1234, 2, 100, true);
+  gatherMergeTest(1234, 10, 10, true);
+  gatherMergeTest(1234, 10, 100, true);
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     SpillTestSuite,
     SpillTest,
diff --git a/velox/exec/tests/SpillerBenchmarkBase.cpp b/velox/exec/tests/SpillerBenchmarkBase.cpp
index ab94f79c62e3..8eab9d0d7560 100644
--- a/velox/exec/tests/SpillerBenchmarkBase.cpp
+++ b/velox/exec/tests/SpillerBenchmarkBase.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <folly/system/HardwareConcurrency.h>
 #include <gflags/gflags.h>
 #include <glog/logging.h>
 #include <filesystem>
@@ -56,7 +57,7 @@ DEFINE_uint32(
     "The number of key columns");
 DEFINE_uint32(
     spiller_benchmark_spill_executor_size,
-    std::thread::hardware_concurrency(),
+    folly::hardware_concurrency(),
     "The spiller executor size in number of threads");
 DEFINE_uint32(
     spiller_benchmark_spill_vector_size,
diff --git a/velox/exec/tests/SpillerTest.cpp b/velox/exec/tests/SpillerTest.cpp
index e9f435495960..ecec2f6f844d 100644
--- a/velox/exec/tests/SpillerTest.cpp
+++ b/velox/exec/tests/SpillerTest.cpp
@@ -115,7 +115,7 @@ struct TestParam {
         poolSize,
         compressionKindToString(compressionKind),
         std::to_string(enablePrefixSort),
-        joinTypeName(joinType));
+        core::JoinTypeName::toName(joinType));
   }
 };
 
@@ -331,13 +331,14 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       bool ascending = true,
       bool makeError = false,
       uint64_t readBufferSize = 1 << 20) {
-    SCOPED_TRACE(fmt::format(
-        "spillType: {} numDuplicates: {} outputBatchSize: {} ascending: {} makeError: {}",
-        typeName(type_),
-        numDuplicates,
-        outputBatchSize,
-        ascending,
-        makeError));
+    SCOPED_TRACE(
+        fmt::format(
+            "spillType: {} numDuplicates: {} outputBatchSize: {} ascending: {} makeError: {}",
+            typeName(type_),
+            numDuplicates,
+            outputBatchSize,
+            ascending,
+            makeError));
     constexpr int32_t kNumRows = 5'000;
     const auto prevGStats = common::globalSpillStats();
 
@@ -714,11 +715,11 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       // We make a merge reader that merges the spill files and the rows that
       // are still in the RowContainer.
       auto merge = spillPartition->createOrderedReader(
-          spillConfig_.readBufferSize, pool(), &spillStats_);
+          spillConfig_, pool(), &spillStats_);
       ASSERT_TRUE(merge != nullptr);
       ASSERT_TRUE(
           spillPartition->createOrderedReader(
-              spillConfig_.readBufferSize, pool(), &spillStats_) == nullptr);
+              spillConfig_, pool(), &spillStats_) == nullptr);
 
       // We read the spilled data back and check that it matches the sorted
       // order of the partition.
@@ -865,14 +866,15 @@ class SpillerTest : public exec::test::RowContainerTestBase {
       ss << partitionId.toString() << " ";
     }
     ss << "]";
-    SCOPED_TRACE(fmt::format(
-        "Param: {}, numSpillers: {}, numBatchRows: {}, numAppendBatches: {}, targetFileSize: {}, spillPartitionIdSet: {}",
-        param_.toString(),
-        numSpillers,
-        numBatchRows,
-        numAppendBatches,
-        targetFileSize,
-        ss.str()));
+    SCOPED_TRACE(
+        fmt::format(
+            "Param: {}, numSpillers: {}, numBatchRows: {}, numAppendBatches: {}, targetFileSize: {}, spillPartitionIdSet: {}",
+            param_.toString(),
+            numSpillers,
+            numBatchRows,
+            numAppendBatches,
+            targetFileSize,
+            ss.str()));
 
     std::vector<std::vector<RowVectorPtr>> inputsByPartition(numPartitions_);
 
@@ -1573,7 +1575,7 @@ TEST_P(AggregationOutputOnly, basic) {
       ASSERT_EQ(spillPartitionSet.size(), 1);
       auto spillPartition = std::move(spillPartitionSet.begin()->second);
       auto merge = spillPartition->createOrderedReader(
-          spillConfig_.readBufferSize, pool(), &spillStats_);
+          spillConfig_, pool(), &spillStats_);
 
       for (auto i = 0; i < expectedNumSpilledRows; ++i) {
         auto* stream = merge->next();
@@ -1686,8 +1688,8 @@ TEST_P(SortOutputOnly, basic) {
     auto spillPartition = std::move(spillPartitionSet.begin()->second);
 
     const int expectedNumSpilledRows = numListedRows;
-    auto merge = spillPartition->createOrderedReader(
-        spillConfig_.readBufferSize, pool(), &spillStats_);
+    auto merge =
+        spillPartition->createOrderedReader(spillConfig_, pool(), &spillStats_);
     if (expectedNumSpilledRows == 0) {
       ASSERT_TRUE(merge == nullptr);
     } else {
diff --git a/velox/exec/tests/SplitListenerTest.cpp b/velox/exec/tests/SplitListenerTest.cpp
new file mode 100644
index 000000000000..9f7b3a35841e
--- /dev/null
+++ b/velox/exec/tests/SplitListenerTest.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/exec/Task.h"
+#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"
+
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::exec::test {
+namespace {
+
+std::unordered_map<std::string, std::unordered_map<core::PlanNodeId, int64_t>>
+    numOfSplitsByUuid;
+
+class CountSplitListener : public SplitListener {
+ public:
+  CountSplitListener(const std::string& taskId, const std::string& taskUuid)
+      : SplitListener(taskId, taskUuid) {}
+
+  void onTaskCompletion() override {
+    auto& map = numOfSplitsByUuid[taskUuid_];
+    for (auto& [planNodeId, count] : counts_) {
+      map[planNodeId] += count;
+    }
+  }
+
+  void onAddSplit(
+      const core::PlanNodeId& planNodeId,
+      const exec::Split& /*split*/) override {
+    counts_[planNodeId]++;
+  }
+
+ private:
+  std::unordered_map<core::PlanNodeId, int64_t> counts_;
+};
+
+class CountAgainSplitListener : public SplitListener {
+ public:
+  CountAgainSplitListener(
+      const std::string& taskId,
+      const std::string& taskUuid)
+      : SplitListener(taskId, taskUuid) {}
+
+  void onTaskCompletion() override {
+    auto& map = numOfSplitsByUuid[taskUuid_];
+    for (auto& [planNodeId, count] : counts_) {
+      map[planNodeId] += count;
+    }
+  }
+
+  void onAddSplit(
+      const core::PlanNodeId& planNodeId,
+      const exec::Split& /*split*/) override {
+    counts_[planNodeId]++;
+  }
+
+ private:
+  std::unordered_map<core::PlanNodeId, int64_t> counts_;
+};
+
+template <typename T>
+class TestSplitListenerFactory : public SplitListenerFactory {
+ public:
+  ~TestSplitListenerFactory() override = default;
+
+  std::unique_ptr<SplitListener> create(
+      const std::string& taskId,
+      const std::string& taskUuid,
+      const core::QueryConfig& /*config*/) override {
+    return std::make_unique<T>(taskId, taskUuid);
+  }
+};
+
+class DummyListenerFactory : public SplitListenerFactory {
+ public:
+  ~DummyListenerFactory() override = default;
+
+  std::unique_ptr<SplitListener> create(
+      const std::string& /*taskId*/,
+      const std::string& /*taskUuid*/,
+      const core::QueryConfig& /*config*/) override {
+    return nullptr;
+  }
+};
+
+class SplitListenerTest : public HiveConnectorTestBase {
+ public:
+  SplitListenerTest() {
+    countSplitListenerFactory_ =
+        std::make_shared<TestSplitListenerFactory<CountSplitListener>>();
+    countAgainSplitListenerFactory_ =
+        std::make_shared<TestSplitListenerFactory<CountAgainSplitListener>>();
+    dummyListenerFactory_ = std::make_shared<DummyListenerFactory>();
+  }
+
+ protected:
+  void makeTable() {
+    rowType_ = ROW({"c0"}, {BIGINT()});
+    RowVectorPtr table =
+        makeRowVector({"c0"}, {makeFlatVector<int64_t>({1, 2, 3, 4, 5})});
+    directory_ = TempDirectoryPath::create();
+    auto directoryPath = directory_->getPath();
+    auto tablePath = fmt::format("{}/t", directoryPath);
+    auto fs = filesystems::getFileSystem(tablePath, {});
+    fs->mkdir(tablePath);
+    // Write the table three times to make multiple splits.
+    for (auto i = 0; i < 3; ++i) {
+      auto filePath = fmt::format("{}/f{}", tablePath, i);
+      writeToFile(filePath, table);
+      filePaths_.emplace_back(filePath);
+    }
+  }
+
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> getSplits() {
+    std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
+    splits.reserve(filePaths_.size());
+    for (const auto& filePath : filePaths_) {
+      splits.emplace_back(
+          connector::hive::HiveConnectorSplitBuilder(filePath)
+              .connectorId(kHiveConnectorId)
+              .fileFormat(dwio::common::FileFormat::DWRF)
+              .build());
+    }
+    return splits;
+  }
+
+  RowTypePtr rowType_;
+  std::shared_ptr<TempDirectoryPath> directory_;
+  std::vector<std::string> filePaths_;
+
+  std::shared_ptr<TestSplitListenerFactory<CountSplitListener>>
+      countSplitListenerFactory_;
+  std::shared_ptr<TestSplitListenerFactory<CountAgainSplitListener>>
+      countAgainSplitListenerFactory_;
+  std::shared_ptr<DummyListenerFactory> dummyListenerFactory_;
+};
+
+} // namespace
+} // namespace facebook::velox::exec::test
+
+namespace facebook::velox::exec::test {
+
+TEST_F(SplitListenerTest, basic) {
+  ASSERT_TRUE(exec::registerSplitListenerFactory(countSplitListenerFactory_));
+  // Not allowing register the same split listener factory twice.
+  ASSERT_FALSE(exec::registerSplitListenerFactory(countSplitListenerFactory_));
+  ASSERT_TRUE(exec::registerSplitListenerFactory(dummyListenerFactory_));
+
+  makeTable();
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId nodeId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(rowType_)
+                  .capturePlanNodeId(nodeId)
+                  .project({"c0 + 1 as c0"})
+                  .planNode();
+
+  auto checkCount = [&](std::shared_ptr<Task>& task) {
+    const auto uuid = task->uuid();
+    task = nullptr;
+    EXPECT_GT(numOfSplitsByUuid.count(uuid), 0);
+    EXPECT_EQ(numOfSplitsByUuid[uuid].size(), 1);
+    EXPECT_GT(numOfSplitsByUuid[uuid].count(nodeId), 0);
+    EXPECT_EQ(numOfSplitsByUuid[uuid][nodeId], 3);
+  };
+
+  for (const auto addWithSequence : {false, true}) {
+    const auto splits = getSplits();
+    std::shared_ptr<Task> task;
+    AssertQueryBuilder(plan)
+        .splits(nodeId, splits)
+        .addSplitWithSequence(addWithSequence)
+        .copyResults(pool_.get(), task);
+    checkCount(task);
+  }
+
+  ASSERT_TRUE(exec::unregisterSplitListenerFactory(countSplitListenerFactory_));
+  ASSERT_TRUE(exec::unregisterSplitListenerFactory(dummyListenerFactory_));
+}
+
+TEST_F(SplitListenerTest, multipleListeners) {
+  ASSERT_TRUE(exec::registerSplitListenerFactory(countSplitListenerFactory_));
+  ASSERT_TRUE(
+      exec::registerSplitListenerFactory(countAgainSplitListenerFactory_));
+
+  makeTable();
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId nodeId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(rowType_)
+                  .capturePlanNodeId(nodeId)
+                  .project({"c0 + 1 as c0"})
+                  .planNode();
+
+  const auto splits = getSplits();
+  std::shared_ptr<Task> task;
+  AssertQueryBuilder(plan)
+      .splits(nodeId, splits)
+      .copyResults(pool_.get(), task);
+
+  const auto uuid = task->uuid();
+  task = nullptr;
+  EXPECT_GT(numOfSplitsByUuid.count(uuid), 0);
+  EXPECT_EQ(numOfSplitsByUuid[uuid].size(), 1);
+  EXPECT_GT(numOfSplitsByUuid[uuid].count(nodeId), 0);
+  EXPECT_EQ(numOfSplitsByUuid[uuid][nodeId], 6);
+
+  ASSERT_TRUE(exec::unregisterSplitListenerFactory(countSplitListenerFactory_));
+  ASSERT_TRUE(
+      exec::unregisterSplitListenerFactory(countAgainSplitListenerFactory_));
+}
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/StreamingAggregationTest.cpp b/velox/exec/tests/StreamingAggregationTest.cpp
index 224a044feca9..1e23fa58bf8a 100644
--- a/velox/exec/tests/StreamingAggregationTest.cpp
+++ b/velox/exec/tests/StreamingAggregationTest.cpp
@@ -27,8 +27,14 @@ namespace {
 
 using namespace facebook::velox::exec::test;
 
-class StreamingAggregationTest : public HiveConnectorTestBase,
-                                 public testing::WithParamInterface<int32_t> {
+struct TestParams {
+  int32_t streamingMinOutputBatchSize;
+  uint64_t preferredOutputBatchBytes;
+};
+
+class StreamingAggregationTest
+    : public HiveConnectorTestBase,
+      public testing::WithParamInterface<TestParams> {
  protected:
   void SetUp() override {
     HiveConnectorTestBase::SetUp();
@@ -36,7 +42,11 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
   }
 
   int32_t flushRows() {
-    return GetParam();
+    return GetParam().streamingMinOutputBatchSize;
+  }
+
+  uint64_t preferredOutputBatchBytes() {
+    return GetParam().preferredOutputBatchBytes;
   }
 
   AssertQueryBuilder& config(
@@ -48,7 +58,10 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
             std::to_string(outputBatchSize))
         .config(
             core::QueryConfig::kStreamingAggregationMinOutputBatchRows,
-            std::to_string(flushRows()));
+            std::to_string(flushRows()))
+        .config(
+            core::QueryConfig::kPreferredOutputBatchBytes,
+            std::to_string(preferredOutputBatchBytes()));
   }
 
   void testAggregation(
@@ -139,21 +152,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
 
   void testSortedAggregationWithBarrier(
       const std::vector<VectorPtr>& keys,
-      uint32_t outputBatchSize) {
+      uint32_t outputBatchSize,
+      uint32_t expectedNumOuputBatches) {
     const auto inputVectors = addPayload(keys, 2);
-    int expectedNumOuputBatchesWithBarrier{0};
-    int numInputRows{0};
-    for (const auto& inputVector : inputVectors) {
-      numInputRows += inputVector->size();
-      if (outputBatchSize > inputVector->size()) {
-        ++expectedNumOuputBatchesWithBarrier;
-      } else {
-        expectedNumOuputBatchesWithBarrier +=
-            bits::divRoundUp(inputVector->size(), outputBatchSize);
-      }
-    }
-    const int expectedNumOuputBatches =
-        bits::divRoundUp(numInputRows, outputBatchSize);
 
     std::vector<std::shared_ptr<TempFilePath>> tempFiles;
     const int numSplits = keys.size();
@@ -168,8 +169,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
     core::PlanNodeId aggregationNodeId;
     auto plan = PlanBuilder(planNodeIdGenerator)
                     .startTableScan()
-                    .outputType(std::dynamic_pointer_cast<const RowType>(
-                        inputVectors[0]->type()))
+                    .outputType(
+                        std::dynamic_pointer_cast<const RowType>(
+                            inputVectors[0]->type()))
                     .endTableScan()
                     .streamingAggregation(
                         {"c0"},
@@ -201,8 +203,7 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
           velox::exec::toPlanStats(taskStats)
               .at(aggregationNodeId)
               .outputVectors,
-          barrierExecution ? expectedNumOuputBatchesWithBarrier
-                           : expectedNumOuputBatches);
+          expectedNumOuputBatches);
     }
   }
 
@@ -247,22 +248,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
 
   void testDistinctAggregationWithBarrier(
       const std::vector<VectorPtr>& keys,
-      uint32_t outputBatchSize) {
+      uint32_t outputBatchSize,
+      uint32_t expectedNumOuputBatches) {
     const auto inputVectors = addPayload(keys, 2);
-    int expectedNumOuputBatchesWithBarrier{0};
-    int numInputRows{0};
-    for (const auto& inputVector : inputVectors) {
-      numInputRows += inputVector->size();
-      if (outputBatchSize > inputVector->size()) {
-        ++expectedNumOuputBatchesWithBarrier;
-      } else {
-        expectedNumOuputBatchesWithBarrier +=
-            bits::divRoundUp(inputVector->size(), outputBatchSize);
-      }
-    }
-    const int expectedNumOuputBatches =
-        bits::divRoundUp(numInputRows, outputBatchSize);
-
     std::vector<std::shared_ptr<TempFilePath>> tempFiles;
     const int numSplits = keys.size();
     for (int32_t i = 0; i < numSplits; ++i) {
@@ -277,8 +265,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       core::PlanNodeId aggregationNodeId;
       auto plan = PlanBuilder(planNodeIdGenerator)
                       .startTableScan()
-                      .outputType(std::dynamic_pointer_cast<const RowType>(
-                          inputVectors[0]->type()))
+                      .outputType(
+                          std::dynamic_pointer_cast<const RowType>(
+                              inputVectors[0]->type()))
                       .endTableScan()
                       .streamingAggregation(
                           {"c0"},
@@ -311,8 +300,7 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
             velox::exec::toPlanStats(taskStats)
                 .at(aggregationNodeId)
                 .outputVectors,
-            barrierExecution ? expectedNumOuputBatchesWithBarrier
-                             : expectedNumOuputBatches);
+            expectedNumOuputBatches);
       }
     }
 
@@ -321,8 +309,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       auto plan =
           PlanBuilder(planNodeIdGenerator)
               .startTableScan()
-              .outputType(std::dynamic_pointer_cast<const RowType>(
-                  inputVectors[0]->type()))
+              .outputType(
+                  std::dynamic_pointer_cast<const RowType>(
+                      inputVectors[0]->type()))
               .endTableScan()
               .streamingAggregation(
                   {"c0"}, {}, {}, core::AggregationNode::Step::kSingle, false)
@@ -346,8 +335,7 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
             velox::exec::toPlanStats(taskStats)
                 .at(aggregationNodeId)
                 .outputVectors,
-            barrierExecution ? expectedNumOuputBatchesWithBarrier
-                             : expectedNumOuputBatches);
+            expectedNumOuputBatches);
       }
     }
   }
@@ -513,19 +501,6 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       const std::vector<RowVectorPtr>& keys,
       uint32_t outputBatchSize) {
     const auto inputVectors = addPayload(keys);
-    int expectedNumOuputBatchesWithBarrier{0};
-    int numInputRows{0};
-    for (const auto& inputVector : inputVectors) {
-      numInputRows += inputVector->size();
-      if (outputBatchSize > inputVector->size()) {
-        ++expectedNumOuputBatchesWithBarrier;
-      } else {
-        expectedNumOuputBatchesWithBarrier +=
-            bits::divRoundUp(inputVector->size(), outputBatchSize);
-      }
-    }
-    const int expectedNumOuputBatches =
-        bits::divRoundUp(numInputRows, outputBatchSize);
     std::vector<std::shared_ptr<TempFilePath>> tempFiles;
     const int numSplits = keys.size();
     for (int32_t i = 0; i < numSplits; ++i) {
@@ -541,8 +516,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       auto plan =
           PlanBuilder(planNodeIdGenerator)
               .startTableScan()
-              .outputType(std::dynamic_pointer_cast<const RowType>(
-                  inputVectors[0]->type()))
+              .outputType(
+                  std::dynamic_pointer_cast<const RowType>(
+                      inputVectors[0]->type()))
               .endTableScan()
               .streamingAggregation(
                   keys[0]->type()->asRow().names(),
@@ -578,12 +554,6 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
         const auto taskStats = task->taskStats();
         ASSERT_EQ(taskStats.numBarriers, barrierExecution ? numSplits : 0);
         ASSERT_EQ(taskStats.numFinishedSplits, numSplits);
-        ASSERT_EQ(
-            velox::exec::toPlanStats(taskStats)
-                .at(aggregationNodeId)
-                .outputVectors,
-            barrierExecution ? expectedNumOuputBatchesWithBarrier
-                             : expectedNumOuputBatches);
         EXPECT_EQ(NonPODInt64::constructed, NonPODInt64::destructed);
       }
     }
@@ -592,8 +562,9 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
       core::PlanNodeId aggregationNodeId;
       auto plan = PlanBuilder(planNodeIdGenerator)
                       .startTableScan()
-                      .outputType(std::dynamic_pointer_cast<const RowType>(
-                          inputVectors[0]->type()))
+                      .outputType(
+                          std::dynamic_pointer_cast<const RowType>(
+                              inputVectors[0]->type()))
                       .endTableScan()
                       .streamingAggregation(
                           keys[0]->type()->asRow().names(),
@@ -626,12 +597,6 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
         const auto taskStats = task->taskStats();
         ASSERT_EQ(taskStats.numBarriers, barrierExecution ? numSplits : 0);
         ASSERT_EQ(taskStats.numFinishedSplits, numSplits);
-        ASSERT_EQ(
-            velox::exec::toPlanStats(taskStats)
-                .at(aggregationNodeId)
-                .outputVectors,
-            barrierExecution ? expectedNumOuputBatchesWithBarrier
-                             : expectedNumOuputBatches);
         EXPECT_EQ(NonPODInt64::constructed, NonPODInt64::destructed);
       }
     }
@@ -641,13 +606,32 @@ class StreamingAggregationTest : public HiveConnectorTestBase,
 VELOX_INSTANTIATE_TEST_SUITE_P(
     StreamingAggregationTest,
     StreamingAggregationTest,
-    testing::ValuesIn({0, 1, 64, std::numeric_limits<int32_t>::max()}),
-    [](const testing::TestParamInfo<int32_t>& info) {
+    testing::Values(
+        TestParams{0, 1},
+        TestParams{0, 1024},
+        TestParams{0, std::numeric_limits<uint64_t>::max()},
+        TestParams{1, 1},
+        TestParams{1, 1024},
+        TestParams{1, std::numeric_limits<uint64_t>::max()},
+        TestParams{64, 1},
+        TestParams{64, 1024},
+        TestParams{64, std::numeric_limits<uint64_t>::max()},
+        TestParams{std::numeric_limits<int32_t>::max(), 1},
+        TestParams{std::numeric_limits<int32_t>::max(), 1024},
+        TestParams{
+            std::numeric_limits<int32_t>::max(),
+            std::numeric_limits<uint64_t>::max()}),
+    [](const testing::TestParamInfo<TestParams>& info) {
       return fmt::format(
-          "streamingMinOutputBatchSize_{}",
-          info.param == std::numeric_limits<int32_t>::max()
+          "streamingMinOutputBatchSize_{}_preferredOutputBatchBytes_{}",
+          info.param.streamingMinOutputBatchSize ==
+                  std::numeric_limits<int32_t>::max()
               ? "inf"
-              : std::to_string(info.param));
+              : std::to_string(info.param.streamingMinOutputBatchSize),
+          info.param.preferredOutputBatchBytes ==
+                  std::numeric_limits<uint64_t>::max()
+              ? "inf"
+              : std::to_string(info.param.preferredOutputBatchBytes));
     });
 
 TEST_P(StreamingAggregationTest, smallInputBatches) {
@@ -779,9 +763,7 @@ TEST_P(StreamingAggregationTest, closeUninitialized) {
                             std::make_shared<core::FieldAccessTypedExpr>(
                                 BIGINT(), "c0"),
                             std::make_shared<core::CallTypedExpr>(
-                                BIGINT(),
-                                std::vector<core::TypedExprPtr>{},
-                                "do-not-exist")},
+                                BIGINT(), "do-not-exist")},
                         source);
                   })
                   .partialStreamingAggregation({"c0"}, {"sum(x)"})
@@ -793,8 +775,7 @@ TEST_P(StreamingAggregationTest, closeUninitialized) {
 }
 
 TEST_P(StreamingAggregationTest, sortedAggregations) {
-  auto size = 1024;
-
+  const auto size = 512;
   std::vector<VectorPtr> keys = {
       makeFlatVector<int32_t>(size, [](auto row) { return row; }),
       makeFlatVector<int32_t>(size, [size](auto row) { return (size + row); }),
@@ -804,7 +785,7 @@ TEST_P(StreamingAggregationTest, sortedAggregations) {
           78, [size](auto row) { return (3 * size + row); }),
   };
 
-  testSortedAggregation(keys, 1024);
+  testSortedAggregation(keys, 512);
   testSortedAggregation(keys, 32);
 }
 
@@ -878,6 +859,189 @@ TEST_P(StreamingAggregationTest, clusteredInput) {
   }
 }
 
+TEST_P(StreamingAggregationTest, clusteredInputWithOutputSplit) {
+  std::vector<VectorPtr> keysWithOverlap = {
+      makeNullableFlatVector<int32_t>({1, 1, std::nullopt, 2, 2}),
+      makeFlatVector<int32_t>({2, 3, 3, 4}),
+      makeFlatVector<int32_t>({5, 6, 6, 6}),
+      makeFlatVector<int32_t>({6, 6, 6, 6}),
+      makeFlatVector<int32_t>({6, 7, 8}),
+  };
+  auto dataWithOverlap = addPayload(keysWithOverlap, 1);
+  auto planWithOverlap = PlanBuilder()
+                             .values(dataWithOverlap)
+                             .streamingAggregation(
+                                 {"c0"},
+                                 {"arbitrary(c1)", "array_agg(c1)"},
+                                 {},
+                                 core::AggregationNode::Step::kSingle,
+                                 false)
+                             .planNode();
+  const auto expectedWithOverlap = makeRowVector({
+      makeNullableFlatVector<int32_t>({1, std::nullopt, 2, 3, 4, 5, 6, 7, 8}),
+      makeFlatVector<int32_t>({0, 2, 3, 6, 8, 9, 10, 18, 19}),
+      makeArrayVector<int32_t>(
+          {{0, 1},
+           {2},
+           {3, 4, 5},
+           {6, 7},
+           {8},
+           {9},
+           {10, 11, 12, 13, 14, 15, 16, 17},
+           {18},
+           {19}}),
+  });
+  for (auto batchSize : {1, 3, 20}) {
+    SCOPED_TRACE(fmt::format("batchSize={}", batchSize));
+    config(AssertQueryBuilder(planWithOverlap), batchSize)
+        .assertResults(expectedWithOverlap);
+  }
+
+  std::vector<VectorPtr> keysWithoutOverlap = {
+      makeNullableFlatVector<int32_t>({1, 1, std::nullopt, 2, 2}),
+      makeFlatVector<int32_t>({3, 3, 4, 4}),
+      makeFlatVector<int32_t>({5, 6, 6, 7}),
+      makeFlatVector<int32_t>({8, 8, 9, 9}),
+      makeFlatVector<int32_t>({10, 11, 12}),
+  };
+  auto dataWithoutOverlap = addPayload(keysWithoutOverlap, 1);
+  auto planWithoutOverlap = PlanBuilder()
+                                .values(dataWithoutOverlap)
+                                .streamingAggregation(
+                                    {"c0"},
+                                    {"arbitrary(c1)", "array_agg(c1)"},
+                                    {},
+                                    core::AggregationNode::Step::kSingle,
+                                    false)
+                                .planNode();
+  const auto expectedWithoutOverlap = makeRowVector(
+      {makeNullableFlatVector<int32_t>(
+           {1, std::nullopt, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}),
+       makeFlatVector<int32_t>({0, 2, 3, 5, 7, 9, 10, 12, 13, 15, 17, 18, 19}),
+       makeArrayVector<int32_t>(
+           {{0, 1},
+            {2},
+            {3, 4},
+            {5, 6},
+            {7, 8},
+            {9},
+            {10, 11},
+            {12},
+            {13, 14},
+            {15, 16},
+            {17},
+            {18},
+            {19}})});
+  for (auto batchSize : {1, 3, 20}) {
+    SCOPED_TRACE(fmt::format("batchSize={}", batchSize));
+    config(AssertQueryBuilder(planWithoutOverlap), batchSize)
+        .assertResults(expectedWithoutOverlap);
+  }
+
+  std::vector<VectorPtr> mixedKeys = {
+      makeNullableFlatVector<int32_t>({1, 1, std::nullopt, std::nullopt, 2}),
+      makeFlatVector<int32_t>({3, 3, 4, 4}),
+      makeFlatVector<int32_t>({6, 6, 6, 7}),
+      makeFlatVector<int32_t>({7, 8, 9, 9}),
+      makeFlatVector<int32_t>({10, 11, 12}),
+  };
+  auto mixedData = addPayload(mixedKeys, 1);
+  auto mixedPlan = PlanBuilder()
+                       .values(mixedData)
+                       .streamingAggregation(
+                           {"c0"},
+                           {"arbitrary(c1)", "array_agg(c1)"},
+                           {},
+                           core::AggregationNode::Step::kSingle,
+                           false)
+                       .planNode();
+  const auto expectedMixedResult = makeRowVector(
+      {makeNullableFlatVector<int32_t>(
+           {1, std::nullopt, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12}),
+       makeFlatVector<int32_t>({0, 2, 4, 5, 7, 9, 12, 14, 15, 17, 18, 19}),
+       makeArrayVector<int32_t>(
+           {{0, 1},
+            {2, 3},
+            {4},
+            {5, 6},
+            {7, 8},
+            {9, 10, 11},
+            {12, 13},
+            {14},
+            {15, 16},
+            {17},
+            {18},
+            {19}})});
+  for (auto batchSize : {1, 3, 20}) {
+    SCOPED_TRACE(fmt::format("batchSize={}", batchSize));
+    config(AssertQueryBuilder(mixedPlan), batchSize)
+        .assertResults(expectedMixedResult);
+  }
+}
+
+TEST_P(StreamingAggregationTest, clusteredInputWithNulls) {
+  std::vector<VectorPtr> keyVectors = {
+      makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2, 3, 3, 3, 3}),
+      makeFlatVector<int32_t>({4, 4, 4, 4, 5, 5, 5, 5, 6, 6}),
+      makeFlatVector<int32_t>({7, 7, 7, 8}),
+      makeFlatVector<int32_t>({8, 8, 8, 9, 9, 9, 10, 10, 10}),
+      makeFlatVector<int32_t>({11, 11, 11}),
+  };
+  std::vector<VectorPtr> dataVectors = {
+      makeRowVector(
+          {makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2, 3, 3, 3, 3}),
+           makeFlatVector<int32_t>({1, 1, 1, 2, 2, 2, 3, 3, 3, 3})},
+          [](auto row) { return row < 3; }),
+      makeRowVector(
+          {makeFlatVector<int32_t>({4, 4, 4, 4, 5, 5, 5, 5, 6, 6}),
+           makeFlatVector<int32_t>({4, 4, 4, 4, 5, 5, 5, 5, 6, 6})},
+          [](auto row) { return row < 4 || row > 7; }),
+
+      makeRowVector(
+          {makeFlatVector<int32_t>({7, 7, 7, 8}),
+           makeFlatVector<int32_t>({7, 7, 7, 8})},
+          [](auto row) { return row > 2; }),
+
+      makeRowVector(
+          {makeFlatVector<int32_t>({8, 8, 8, 9, 9, 9, 10, 10, 10}),
+           makeFlatVector<int32_t>({8, 8, 8, 9, 9, 9, 10, 10, 10})},
+          [](auto row) { return row < 3; }),
+
+      makeRowVector(
+          {makeFlatVector<int32_t>({11, 11, 11}),
+           makeFlatVector<int32_t>({11, 11, 11})},
+          [](auto /*unused*/) { return true; })};
+  ASSERT_EQ(keyVectors.size(), dataVectors.size());
+  std::vector<RowVectorPtr> rowVectors;
+  for (int i = 0; i < keyVectors.size(); ++i) {
+    rowVectors.emplace_back(makeRowVector({keyVectors[i], dataVectors[i]}));
+  }
+
+  const auto plan =
+      PlanBuilder()
+          .values(rowVectors)
+          .partialStreamingAggregation({"c0"}, {"count(c1)", "arbitrary(c1)"})
+          .finalAggregation()
+          .planNode();
+
+  const auto expected = makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}),
+       makeFlatVector<int64_t>({0, 3, 4, 0, 4, 0, 3, 0, 3, 3, 0}),
+       makeRowVector(
+           {makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}),
+            makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11})},
+           [](auto row) {
+             if (row == 0 || row == 3 || row == 5 || row == 7 || row == 10) {
+               return true;
+             }
+             return false;
+           })});
+  for (auto batchSize : {20}) {
+    SCOPED_TRACE(fmt::format("batchSize={}", batchSize));
+    config(AssertQueryBuilder(plan), batchSize).assertResults(expected);
+  }
+}
+
 TEST_P(StreamingAggregationTest, sortedAggregationsWithBarrier) {
   const auto size = 1024;
   const std::vector<VectorPtr> keys = {
@@ -889,8 +1053,8 @@ TEST_P(StreamingAggregationTest, sortedAggregationsWithBarrier) {
           78, [size](auto row) { return (3 * size + row); }),
   };
 
-  testSortedAggregationWithBarrier(keys, 1024);
-  testSortedAggregationWithBarrier(keys, 32);
+  testSortedAggregationWithBarrier(keys, 1024, 4);
+  testSortedAggregationWithBarrier(keys, 32, 4);
 }
 
 TEST_P(StreamingAggregationTest, clusteredInputWithBarrier) {
@@ -909,16 +1073,17 @@ TEST_P(StreamingAggregationTest, clusteredInputWithBarrier) {
 
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId streamingAggregationNodeId;
-  auto plan = PlanBuilder(planNodeIdGenerator)
-                  .startTableScan()
-                  .outputType(std::dynamic_pointer_cast<const RowType>(
-                      inputVectors[0]->type()))
-                  .endTableScan()
-                  .partialStreamingAggregation(
-                      {"c0"}, {"count(c1)", "arbitrary(c1)", "array_agg(c1)"})
-                  .capturePlanNodeId(streamingAggregationNodeId)
-                  .finalAggregation()
-                  .planNode();
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .startTableScan()
+          .outputType(
+              std::dynamic_pointer_cast<const RowType>(inputVectors[0]->type()))
+          .endTableScan()
+          .partialStreamingAggregation(
+              {"c0"}, {"count(c1)", "arbitrary(c1)", "array_agg(c1)"})
+          .capturePlanNodeId(streamingAggregationNodeId)
+          .finalAggregation()
+          .planNode();
   const auto expected = makeRowVector(
       {makeNullableFlatVector<int32_t>(
            {1, 2, std::nullopt, 3, 4, 9, 10, 11, 12, 17, 18, 19}),
@@ -929,28 +1094,20 @@ TEST_P(StreamingAggregationTest, clusteredInputWithBarrier) {
   struct {
     int batchSize;
     bool barrierExecution;
+    int numExpectedOutputBatches;
 
     std::string debugString() const {
       return fmt::format(
-          "batchSize={}, barrierExecution={}", batchSize, barrierExecution);
+          "batchSize={}, barrierExecution={}, numExpectedOutputBatches={}",
+          batchSize,
+          barrierExecution,
+          numExpectedOutputBatches);
     }
-  } testSettings[] = {{3, true}, {3, false}, {20, true}, {20, false}};
+  } testSettings[] = {
+      {3, true, 3}, {3, false, 3}, {20, true, 3}, {20, false, 1}};
 
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
-    int expectedNumOuputBatchesWithBarrier{0};
-    int numInputRows{0};
-    for (const auto& inputVector : inputVectors) {
-      numInputRows += inputVector->size();
-      if (testData.batchSize > inputVector->size()) {
-        ++expectedNumOuputBatchesWithBarrier;
-      } else {
-        expectedNumOuputBatchesWithBarrier +=
-            bits::divRoundUp(inputVector->size(), testData.batchSize);
-      }
-    }
-    const int expectedNumOuputBatches =
-        bits::divRoundUp(numInputRows, testData.batchSize);
 
     auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
                     .splits(makeHiveConnectorSplits(tempFiles))
@@ -967,8 +1124,7 @@ TEST_P(StreamingAggregationTest, clusteredInputWithBarrier) {
         velox::exec::toPlanStats(taskStats)
             .at(streamingAggregationNodeId)
             .outputVectors,
-        testData.barrierExecution ? expectedNumOuputBatchesWithBarrier
-                                  : expectedNumOuputBatches);
+        testData.numExpectedOutputBatches);
   }
 }
 
@@ -983,8 +1139,8 @@ TEST_P(StreamingAggregationTest, distinctAggregationsWithBarrier) {
           78, [size](auto row) { return (3 * size + row); }),
   };
 
-  testDistinctAggregationWithBarrier(keys, 1024);
-  testDistinctAggregationWithBarrier(keys, 32);
+  testDistinctAggregationWithBarrier(keys, 1024, 4);
+  testDistinctAggregationWithBarrier(keys, 32, 4);
 
   std::vector<RowVectorPtr> multiKeys = {
       makeRowVector({
@@ -1003,5 +1159,287 @@ TEST_P(StreamingAggregationTest, distinctAggregationsWithBarrier) {
   testMultiKeyDistinctAggregationWithBarrier(multiKeys, 1024);
   testMultiKeyDistinctAggregationWithBarrier(multiKeys, 3);
 }
+
+TEST_P(StreamingAggregationTest, constantInput) {
+  auto data = makeRowVector({makeFlatVector<int32_t>({1, 1, 2, 2})});
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .partialStreamingAggregation({"c0"}, {"array_agg(3)"})
+                  .finalAggregation()
+                  .planNode();
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeArrayVector<int64_t>({{3, 3}, {3, 3}}),
+  });
+  config(AssertQueryBuilder(plan), 1).assertResults(expected);
+  config(AssertQueryBuilder(plan), 10).assertResults(expected);
+}
+
+TEST_P(StreamingAggregationTest, preferredOutputBatchBytes) {
+  // Use grouping keys that span one or more batches.
+  std::vector<VectorPtr> keys = {
+      makeNullableFlatVector<int32_t>({1, 1, std::nullopt, 2, 2}),
+      makeFlatVector<int32_t>({2, 3, 3, 4}),
+      makeFlatVector<int32_t>({5, 6, 6, 6}),
+      makeFlatVector<int32_t>({6, 6, 6, 6}),
+      makeFlatVector<int32_t>({6, 7, 8}),
+  };
+
+  auto data = addPayload(keys, 1);
+
+  auto plan = PlanBuilder()
+                  .values(data)
+                  .partialStreamingAggregation(
+                      {"c0"},
+                      {"count(1)",
+                       "min(c1)",
+                       "max(c1)",
+                       "sum(c1)",
+                       "sumnonpod(1)",
+                       "sum(cast(NULL as INT))"})
+                  .finalAggregation()
+                  .planNode();
+
+  auto results =
+      config(AssertQueryBuilder(plan), 1024).copyResultBatches(pool_.get());
+
+  // If streamingMinOutputBatchSize is set to 1, we expect an output batch for:
+  // {1, NULL}, {2}, {3, 4}, {5}, {6}, {7, 8}.
+  // Otherwise, we expect the output batches to be determined by
+  // preferredOutputBatchBytes.
+  size_t expectedOutputBatches;
+  if (GetParam().streamingMinOutputBatchSize == 1) {
+    expectedOutputBatches = 6;
+  } else if (GetParam().preferredOutputBatchBytes == 1) {
+    expectedOutputBatches = 5;
+  } else if (GetParam().preferredOutputBatchBytes == 1024) {
+    expectedOutputBatches = 2;
+  } else {
+    ASSERT_EQ(
+        GetParam().preferredOutputBatchBytes,
+        std::numeric_limits<uint64_t>::max());
+    expectedOutputBatches = 1;
+  }
+
+  ASSERT_EQ(results.size(), expectedOutputBatches);
+}
+
+// Tests that when noGroupsSpanBatches is set, the number of output batches
+// matches the number of input batches when minOutputBatchRows is set to 1.
+// When minOutputBatchRows is set to an extremely large value, we expect a
+// single output batch.
+TEST_F(StreamingAggregationTest, noGroupsSpanBatches) {
+  // Create input batches where no group spans across batches.
+  // Each batch has unique grouping keys that don't appear in other batches.
+  std::vector<VectorPtr> keys = {
+      makeFlatVector<int32_t>({1, 1, 2, 2}),
+      makeFlatVector<int32_t>({3, 3, 4, 4}),
+      makeFlatVector<int32_t>({5, 5, 6, 6}),
+      makeFlatVector<int32_t>({7, 7, 8, 8}),
+      makeFlatVector<int32_t>({9, 9, 10, 10}),
+  };
+
+  auto data = addPayload(keys, 1);
+  createDuckDbTable(data);
+
+  struct {
+    int32_t minOutputBatchRows;
+    size_t expectedOutputBatches;
+
+    std::string debugString() const {
+      return fmt::format(
+          "minOutputBatchRows={}, expectedOutputBatches={}",
+          minOutputBatchRows,
+          expectedOutputBatches);
+    }
+  } testSettings[] = {
+      // When minOutputBatchRows is 1, each input batch produces an output batch
+      {1, keys.size()},
+      // When minOutputBatchRows is very large, all groups are batched together
+      // into a single output
+      {std::numeric_limits<int32_t>::max(), 1},
+  };
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId aggregationNodeId;
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(data)
+                    .streamingAggregation(
+                        {"c0"},
+                        {"count(1)", "sum(c1)"},
+                        {},
+                        core::AggregationNode::Step::kSingle,
+                        /*ignoreNullKeys=*/false,
+                        /*noGroupsSpanBatches=*/true)
+                    .capturePlanNodeId(aggregationNodeId)
+                    .planNode();
+
+    auto task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .config(
+                core::QueryConfig::kStreamingAggregationMinOutputBatchRows,
+                std::to_string(testData.minOutputBatchRows))
+            .assertResults("SELECT c0, count(1), sum(c1) FROM tmp GROUP BY c0");
+
+    // Verify the number of output batches.
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(
+        velox::exec::toPlanStats(taskStats).at(aggregationNodeId).outputVectors,
+        testData.expectedOutputBatches);
+  }
+}
+
+namespace {
+class InputSourceNode : public core::PlanNode {
+ public:
+  InputSourceNode(
+      const core::PlanNodeId& id,
+      int numInitialInputCalls,
+      int numSkipInputCalls,
+      core::PlanNodePtr source)
+      : PlanNode{id},
+        numInitialInputCalls_(numInitialInputCalls),
+        numSkipInputCalls_(numSkipInputCalls),
+        sources_{std::move(source)} {}
+
+  const RowTypePtr& outputType() const override {
+    return sources_[0]->outputType();
+  }
+
+  const std::vector<core::PlanNodePtr>& sources() const override {
+    return sources_;
+  }
+
+  int numInitialInputCalls() const {
+    return numInitialInputCalls_;
+  }
+
+  int numSkipInputCalls() const {
+    return numSkipInputCalls_;
+  }
+
+  std::string_view name() const override {
+    return "external blocking node";
+  }
+
+ private:
+  void addDetails(std::stringstream& /* stream */) const override {}
+
+  const int numInitialInputCalls_;
+  const int numSkipInputCalls_;
+  const std::vector<core::PlanNodePtr> sources_;
+};
+
+class InputSourceOperator : public exec::Operator {
+ public:
+  InputSourceOperator(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const InputSourceNode> node)
+      : Operator(
+            driverCtx,
+            node->outputType(),
+            operatorId,
+            node->id(),
+            "InputSource"),
+        numInitialInputCalls_(node->numInitialInputCalls()),
+        numSkipInputCalls_(node->numSkipInputCalls()) {}
+
+  bool needsInput() const override {
+    if (numInitialInputCalls_-- >= 0) {
+      return true;
+    }
+    if (numSkipInputCalls_-- >= 0) {
+      return false;
+    }
+    return !noMoreInput_;
+  }
+
+  void addInput(RowVectorPtr input) override {
+    input_ = std::move(input);
+  }
+
+  RowVectorPtr getOutput() override {
+    auto output = std::move(input_);
+    input_ = nullptr;
+    return output;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* future) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override {
+    return noMoreInput_;
+  }
+
+ private:
+  mutable int numInitialInputCalls_{0};
+  mutable int numSkipInputCalls_{0};
+  RowVectorPtr input_;
+};
+
+class SourceNodeTranslator : public exec::Operator::PlanNodeTranslator {
+  std::unique_ptr<exec::Operator> toOperator(
+      exec::DriverCtx* ctx,
+      int32_t id,
+      const core::PlanNodePtr& node) override {
+    if (auto castedNode =
+            std::dynamic_pointer_cast<const InputSourceNode>(node)) {
+      return std::make_unique<InputSourceOperator>(id, ctx, castedNode);
+    }
+    return nullptr;
+  }
+};
+} // namespace
+
+TEST_P(StreamingAggregationTest, needsInputWhenSplitOutput) {
+  exec::Operator::registerOperator(std::make_unique<SourceNodeTranslator>());
+  const auto size = 32;
+  const auto numBatches{5};
+  std::vector<RowVectorPtr> batches;
+  for (int i = 0; i < numBatches; ++i) {
+    batches.push_back(makeRowVector(
+        {makeFlatVector<int32_t>(
+             size,
+             [i, size](auto row) {
+               return row == 0 ? i * size + row - 1 : i * size + row;
+             }),
+         makeFlatVector<int32_t>(size, [](auto row) { return row; })}));
+  }
+  createDuckDbTable(batches);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId aggregationNodeId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(batches)
+                  .streamingAggregation(
+                      {"c0"},
+                      {"array_agg(c1)"},
+                      {},
+                      core::AggregationNode::Step::kSingle,
+                      false)
+                  .addNode([](std::string id, core::PlanNodePtr input) mutable {
+                    return std::make_shared<InputSourceNode>(
+                        id, 2, numBatches - 2, input);
+                  })
+                  .project({"c0", "a0"})
+                  .capturePlanNodeId(aggregationNodeId)
+                  .planNode();
+
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .serialExecution(true)
+          .config(
+              core::QueryConfig::kStreamingAggregationMinOutputBatchRows, "1")
+          .assertResults("SELECT c0, array_agg(c1) FROM tmp GROUP BY c0");
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(
+      velox::exec::toPlanStats(taskStats).at(aggregationNodeId).outputVectors,
+      9);
+}
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/TableEvolutionFuzzer.cpp b/velox/exec/tests/TableEvolutionFuzzer.cpp
index ac52462b9741..82863458aee2 100644
--- a/velox/exec/tests/TableEvolutionFuzzer.cpp
+++ b/velox/exec/tests/TableEvolutionFuzzer.cpp
@@ -16,13 +16,45 @@
 
 #include "velox/exec/tests/TableEvolutionFuzzer.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/common/tests/utils/FilterGenerator.h"
+#include "velox/dwio/dwrf/common/Config.h"
 #include "velox/exec/Cursor.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/expression/fuzzer/ExpressionFuzzer.h"
+#include "velox/functions/FunctionRegistry.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
 #include <filesystem>
 
+#include <re2/re2.h>
+
+DEFINE_bool(
+    enable_oom_injection_write_path,
+    false,
+    "When enabled OOMs will randomly be triggered while executing the write path "
+    "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.");
+
+DEFINE_bool(
+    enable_oom_injection_read_path,
+    false,
+    "When enabled OOMs will randomly be triggered while executing scan "
+    "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.");
+
+DEFINE_int32(
+    aggregation_pushdown_frequency,
+    5,
+    "Controls the frequency of aggregation pushdown. The aggregation pushdown "
+    "is enabled with probability 1/N where N is this value. For example, "
+    "N=5 means 20% chance, N=2 means 50% chance.");
+
 namespace facebook::velox::exec::test {
 
 std::ostream& operator<<(
@@ -45,6 +77,70 @@ VectorFuzzer::Options makeVectorFuzzerOptions() {
   return options;
 }
 
+template <typename T>
+void removeFromVector(std::vector<T>& vec, const T& value) {
+  auto it = std::find(vec.begin(), vec.end(), value);
+  if (it != vec.end()) {
+    vec.erase(it);
+  }
+}
+
+bool hasUnsupportedMapKey(const TypePtr& type) {
+  switch (type->kind()) {
+    case TypeKind::MAP: {
+      auto mapType = type->asMap();
+      // FlatMapColumnWriter only supports TINYINT, SMALLINT, INTEGER, BIGINT,
+      // VARCHAR, VARBINARY as KeyType
+      auto keyKind = mapType.keyType()->kind();
+      if (keyKind != TypeKind::TINYINT && keyKind != TypeKind::SMALLINT &&
+          keyKind != TypeKind::INTEGER && keyKind != TypeKind::BIGINT &&
+          keyKind != TypeKind::VARCHAR && keyKind != TypeKind::VARBINARY) {
+        return true;
+      }
+      return hasUnsupportedMapKey(mapType.valueType());
+    }
+    case TypeKind::ARRAY:
+      return hasUnsupportedMapKey(type->asArray().elementType());
+    case TypeKind::ROW: {
+      auto& rowType = type->asRow();
+      for (int i = 0; i < rowType.size(); ++i) {
+        if (hasUnsupportedMapKey(rowType.childAt(i))) {
+          return true;
+        }
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+
+bool hasMapColumns(const RowTypePtr& schema) {
+  VLOG(1) << "Checking if schema has map columns";
+  for (int i = 0; i < schema->size(); ++i) {
+    if (schema->childAt(i)->isMap()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool hasEmptyElement(const RowVectorPtr& data, int columnIndex) {
+  auto mapVector = data->childAt(columnIndex)->as<MapVector>();
+  if (!mapVector) {
+    return true;
+  }
+
+  // Check if any map entry is empty (null or size = 0)
+  auto sizes = mapVector->sizes();
+  for (int j = 0; j < mapVector->size(); ++j) {
+    if (mapVector->isNullAt(j) || sizes->as<vector_size_t>()[j] == 0) {
+      return true; // Found an empty map
+    }
+  }
+  return false; // No empty maps found
+}
+
 } // namespace
 
 TableEvolutionFuzzer::TableEvolutionFuzzer(const Config& config)
@@ -91,23 +187,82 @@ TableEvolutionFuzzer::parseFileFormats(std::string input) {
 
 namespace {
 
+// Helper function to randomly select aggregates from available columns
+// without replacement. Returns a list of aggregate expressions.
+void generateAggregatesForColumns(
+    const std::vector<int>& availableColumns,
+    const std::vector<std::string>& supportedAggFuncs,
+    const RowTypePtr& schema,
+    FuzzerGenerator& rng,
+    std::vector<std::string>& aggregates) {
+  if (availableColumns.empty()) {
+    return;
+  }
+
+  int numAggregates = std::min(
+      static_cast<int>(availableColumns.size()),
+      std::min(
+          static_cast<int>(5),
+          static_cast<int>(
+              folly::Random::rand32(1, availableColumns.size() + 1, rng))));
+
+  std::unordered_set<int> selectedIndices;
+  for (int i = 0; i < numAggregates; ++i) {
+    if (folly::Random::oneIn(2, rng)) {
+      int randomIdx;
+      do {
+        randomIdx = folly::Random::rand32(availableColumns.size(), rng);
+      } while (selectedIndices.count(randomIdx) > 0);
+      selectedIndices.insert(randomIdx);
+
+      int colIdx = availableColumns[randomIdx];
+      std::string aggFunc = supportedAggFuncs[folly::Random::rand32(
+          supportedAggFuncs.size(), rng)];
+      aggregates.push_back(
+          fmt::format("{}({})", aggFunc, schema->nameOf(colIdx)));
+    }
+  }
+}
+
 std::vector<std::vector<RowVectorPtr>> runTaskCursors(
-    const std::vector<std::unique_ptr<TaskCursor>>& cursors,
+    const std::vector<std::shared_ptr<TaskCursor>>& cursors,
     folly::Executor& executor) {
   std::vector<folly::SemiFuture<std::vector<RowVectorPtr>>> futures;
   for (int i = 0; i < cursors.size(); ++i) {
     auto [promise, future] =
         folly::makePromiseContract<std::vector<RowVectorPtr>>();
     futures.push_back(std::move(future));
-    executor.add([&, i, promise = std::move(promise)]() mutable {
+    auto cursorPtr = cursors[i];
+    auto task = cursorPtr->task();
+    executor.add([cursorPtr, task, promise = std::move(promise)]() mutable {
       std::vector<RowVectorPtr> results;
       try {
-        while (cursors[i]->moveNext()) {
-          auto& result = cursors[i]->current();
+        while (cursorPtr->moveNext()) {
+          auto& result = cursorPtr->current();
           result->loadedVector();
           results.push_back(std::move(result));
         }
         promise.setValue(std::move(results));
+      } catch (VeloxRuntimeError& e) {
+        if (FLAGS_enable_oom_injection_write_path &&
+            e.errorCode() == facebook::velox::error_code::kMemCapExceeded &&
+            e.message() == ScopedOOMInjector::kErrorMessage) {
+          // If we enabled OOM injection we expect the exception thrown by the
+          // ScopedOOMInjector.
+          LOG(INFO) << "OOM injection triggered in write path: " << e.what();
+          promise.setValue(std::move(results));
+        } else if (
+            FLAGS_enable_oom_injection_read_path &&
+            e.errorCode() == facebook::velox::error_code::kMemCapExceeded &&
+            e.message() == ScopedOOMInjector::kErrorMessage) {
+          // If we enabled OOM injection we expect the exception thrown by the
+          // ScopedOOMInjector.
+          LOG(INFO) << "OOM injection triggered in read path: " << e.what();
+          promise.setValue(std::move(results));
+        } else {
+          LOG(ERROR) << e.what();
+          promise.setException(e);
+        }
       } catch (const std::exception& e) {
         LOG(ERROR) << e.what();
         promise.setException(e);
@@ -116,12 +271,12 @@ std::vector<std::vector<RowVectorPtr>> runTaskCursors(
   }
   std::vector<std::vector<RowVectorPtr>> results;
   constexpr std::chrono::seconds kTaskTimeout(10);
+  results.reserve(futures.size());
   for (auto& future : futures) {
     results.push_back(std::move(future).get(kTaskTimeout));
   }
   return results;
 }
-
 // `tableBucketCount' is the bucket count of current table setup when reading.
 // `partitionBucketCount' is the bucket count when the partition was written.
 // `tableBucketCount' must be a multiple of `partitionBucketCount'.
@@ -134,11 +289,14 @@ void buildScanSplitFromTableWriteResult(
     dwio::common::FileFormat fileFormat,
     const std::vector<RowVectorPtr>& writeResult,
     std::vector<Split>& splits) {
+  if (FLAGS_enable_oom_injection_write_path) {
+    return;
+  }
   VELOX_CHECK_EQ(writeResult.size(), 1);
   auto* fragments =
       writeResult[0]->childAt(1)->asChecked<SimpleVector<StringView>>();
   for (int i = 1; i < writeResult[0]->size(); ++i) {
-    auto fragment = folly::parseJson(fragments->valueAt(i));
+    auto fragment = folly::parseJson(std::string_view(fragments->valueAt(i)));
     auto fileName = fragment["fileWriteInfos"][0]["writeFileName"].asString();
     auto hiveSplit = std::make_shared<connector::hive::HiveConnectorSplit>(
         TableEvolutionFuzzer::connectorId(),
@@ -191,8 +349,18 @@ void checkResultsEqual(
       expectedRowIndex = 0;
       continue;
     }
-    VELOX_CHECK(actual[actualVectorIndex]->equalValueAt(
-        expected[expectedVectorIndex].get(), actualRowIndex, expectedRowIndex));
+    VELOX_CHECK(
+        actual[actualVectorIndex]->equalValueAt(
+            expected[expectedVectorIndex].get(),
+            actualRowIndex,
+            expectedRowIndex),
+        "actualVectorIndex={} actualRowIndex={} expectedVectorIndex={} expectedRowIndex={}\nactual={}\nexpected={}",
+        actualVectorIndex,
+        actualRowIndex,
+        expectedVectorIndex,
+        expectedRowIndex,
+        actual[actualVectorIndex]->toString(actualRowIndex),
+        expected[expectedVectorIndex]->toString(expectedRowIndex));
     ++actualRowIndex;
     ++expectedRowIndex;
   }
@@ -210,6 +378,169 @@ void checkResultsEqual(
   VELOX_CHECK_EQ(expectedVectorIndex, expected.size());
 }
 
+common::SubfieldFilters generateSubfieldFilters(
+    RowTypePtr& rowType,
+    const RowVectorPtr& finalExpectedData) {
+  dwio::common::MutationSpec mutations;
+  std::vector<uint64_t> hitRows;
+
+  std::unique_ptr<velox::dwio::common::FilterGenerator> filterGenerator =
+      std::make_unique<velox::dwio::common::FilterGenerator>(rowType, 0);
+
+  auto subfieldsVector = filterGenerator->makeFilterables(rowType->size(), 100);
+
+  const auto& filterSpecs =
+      filterGenerator->makeRandomSpecs(subfieldsVector, 100);
+
+  return filterGenerator->makeSubfieldFilters(
+      filterSpecs, {finalExpectedData}, &mutations, hitRows);
+}
+
+fuzzer::ExpressionFuzzer::FuzzedExpressionData generateRemainingFilters(
+    const TableEvolutionFuzzer::Config& config,
+    unsigned currentSeed) {
+  // Use ExpressionFuzzer to generate complex expressions, but use the actual
+  // data types from finalExpectedData
+  // Configure ExpressionFuzzer to generate simpler expressions suitable for
+  // filters
+  fuzzer::ExpressionFuzzer::Options options;
+  options.enableComplexTypes = false; // Disable complex types to avoid issues
+  options.enableDecimalType = false; // Disable decimal types
+  options.maxLevelOfNesting = 3; // Reduce nesting to avoid complexity
+  options.nullRatio = 0.0; // No null values to avoid type resolution issues
+  // Only use simple comparison and logical functions suitable for filters
+  options.useOnlyFunctions = "eq,neq,lt,lte,gt,gte,and,or,not";
+  options.specialForms = "and,or"; // Only simple special forms
+
+  // Skip complex functions that generate unparseable expressions
+  options.skipFunctions = {
+      "regexp_like",
+      "regexp_extract",
+      "replace",
+      "replace_first",
+      "json_format",
+      "json_extract",
+      "json_parse",
+      "from_utf8",
+      "to_utf8",
+      "reverse",
+      "upper",
+      "lower",
+      "st_coorddim",
+      "is_null",
+      "is_not_null"};
+
+  auto signatureMap = getVectorFunctionSignatures();
+
+  // Configure VectorFuzzer to avoid null values and use the actual data types
+  VectorFuzzer::Options vectorFuzzerOptions;
+  vectorFuzzerOptions.nullRatio = 0.0; // No nulls
+  vectorFuzzerOptions.vectorSize = 100;
+  auto vectorFuzzer =
+      std::make_shared<VectorFuzzer>(vectorFuzzerOptions, config.pool);
+
+  fuzzer::ExpressionFuzzer expressionFuzzer(
+      signatureMap, currentSeed, vectorFuzzer, options);
+
+  return expressionFuzzer.fuzzExpressions(1);
+}
+
+// Generate random aggregation configuration for pushdown testing.
+// Only generates aggregations that are eligible for pushdown:
+// - Supported aggregate functions: min, max, bool_and, bool_or
+// - Each column can only be used by at most one aggregate
+// - Grouping keys are optional (can be empty for global aggregation)
+// - Columns with filters (subfield or remaining) are excluded to enable
+// pushdown
+std::optional<AggregationConfig> generateAggregationConfig(
+    const RowTypePtr& schema,
+    FuzzerGenerator& rng,
+    const std::unordered_set<std::string>& filteredColumns) {
+  // List of aggregate functions that support pushdown
+  // Note: Excluding 'sum' to avoid integer overflow in fuzzer with random data
+  static const std::vector<std::string> supportedNumericAggs = {"min", "max"};
+  static const std::vector<std::string> supportedBooleanAggs = {
+      "bool_and", "bool_or"};
+  static const std::vector<std::string> supportedIntegerAggs = {
+      "bitwise_and_agg", "bitwise_or_agg", "bitwise_xor_agg"};
+
+  // Randomly decide number of grouping keys (0 to 2)
+  int numGroupingKeys = folly::Random::rand32(3, rng);
+  std::vector<std::string> groupingKeys;
+  std::unordered_set<int> usedColumnIndices;
+
+  // Select random columns for grouping keys
+  for (int i = 0; i < numGroupingKeys && i < schema->size(); ++i) {
+    int colIdx = folly::Random::rand32(schema->size(), rng);
+    if (usedColumnIndices.count(colIdx) == 0) {
+      groupingKeys.push_back(schema->nameOf(colIdx));
+      usedColumnIndices.insert(colIdx);
+    }
+  }
+
+  // Generate aggregates on remaining columns
+  // For aggregation pushdown to work, each column should only be used once
+  // and columns with filters should be excluded
+  std::vector<std::string> aggregates;
+  std::vector<int> availableNumericColumns;
+  std::vector<int> availableIntegerColumns;
+  std::vector<int> availableBooleanColumns;
+  for (int i = 0; i < schema->size(); ++i) {
+    if (usedColumnIndices.count(i) == 0) {
+      auto columnName = schema->nameOf(i);
+      // Skip columns that have filters (subfield or remaining)
+      if (filteredColumns.count(columnName) > 0) {
+        continue;
+      }
+
+      auto type = schema->childAt(i);
+      // Integer types: randomly choose between min/max or bitwise aggregations
+      // Note: Exclude DATE/Interval type as it doesn't support bitwise
+      // aggregations
+      if ((type->isInteger() || type->isBigint() || type->isSmallint() ||
+           type->isTinyint()) &&
+          !type->isDate() && !type->isIntervalDayTime() &&
+          !type->isIntervalYearMonth()) {
+        if (folly::Random::oneIn(2, rng)) {
+          availableIntegerColumns.push_back(i);
+        } else {
+          availableNumericColumns.push_back(i);
+        }
+      }
+      // Float types support min/max only
+      else if ((type->isReal() || type->isDouble()) && !type->isDecimal()) {
+        availableNumericColumns.push_back(i);
+      }
+      // Boolean types support bool_and/bool_or
+      else if (type->isBoolean()) {
+        availableBooleanColumns.push_back(i);
+      }
+    }
+  }
+
+  // Need at least one column to aggregate
+  if (availableNumericColumns.empty() && availableBooleanColumns.empty() &&
+      availableIntegerColumns.empty()) {
+    return std::nullopt;
+  }
+
+  // Randomly pick columns for aggregates without replacement
+  generateAggregatesForColumns(
+      availableNumericColumns, supportedNumericAggs, schema, rng, aggregates);
+  generateAggregatesForColumns(
+      availableBooleanColumns, supportedBooleanAggs, schema, rng, aggregates);
+  generateAggregatesForColumns(
+      availableIntegerColumns, supportedIntegerAggs, schema, rng, aggregates);
+
+  if (aggregates.empty()) {
+    return std::nullopt;
+  }
+
+  return AggregationConfig{
+      .groupingKeys = std::move(groupingKeys),
+      .aggregates = std::move(aggregates)};
+}
+
 } // namespace
 
 VectorPtr TableEvolutionFuzzer::liftToType(
@@ -302,8 +633,9 @@ VectorPtr TableEvolutionFuzzer::liftToType(
         if (i < children.size()) {
           children[i] = liftToType(children[i], childType);
         } else {
-          children.push_back(BaseVector::createNullConstant(
-              childType, row->size(), config_.pool));
+          children.push_back(
+              BaseVector::createNullConstant(
+                  childType, row->size(), config_.pool));
         }
       }
       return std::make_shared<RowVector>(
@@ -315,42 +647,84 @@ VectorPtr TableEvolutionFuzzer::liftToType(
 }
 
 void TableEvolutionFuzzer::run() {
-  std::vector<column_index_t> bucketColumnIndices;
-  for (int i = 0; i < config_.columnCount; ++i) {
-    if (folly::Random::oneIn(2 * config_.columnCount, rng_)) {
-      bucketColumnIndices.push_back(i);
-    }
+  ScopedOOMInjector oomInjectorWritePath(
+      [this]() -> bool { return folly::Random::oneIn(10, rng_); },
+      10); // Check the condition every 10 ms.
+  if (FLAGS_enable_oom_injection_write_path) {
+    oomInjectorWritePath.enable();
   }
-  VLOG(1) << "bucketColumnIndices: [" << folly::join(", ", bucketColumnIndices)
-          << "]";
-  auto testSetups = makeSetups(bucketColumnIndices);
-  auto tableOutputRootDir = TempDirectoryPath::create();
-  std::vector<std::unique_ptr<TaskCursor>> writeTasks(
-      2 * config_.evolutionCount - 1);
-  for (int i = 0; i < config_.evolutionCount; ++i) {
-    auto data = vectorFuzzer_.fuzzRow(testSetups[i].schema, kVectorSize, false);
-    for (auto& child : data->children()) {
-      BaseVector::flattenVector(child);
+
+  // Step 1: Randomly decide whether to generate remaining filters (50% chance)
+  bool shouldGenerateRemainingFilters = folly::Random::oneIn(2, rng_);
+
+  fuzzer::ExpressionFuzzer::FuzzedExpressionData generatedRemainingFilters;
+  std::vector<std::string> additionalColumnNames;
+  std::vector<TypePtr> additionalColumnTypes;
+
+  if (shouldGenerateRemainingFilters) {
+    // Generate remaining filters and extract new columns
+    generatedRemainingFilters = generateRemainingFilters(config_, currentSeed_);
+
+    VLOG(1) << "Generated remaining filters from expression fuzzer: "
+            << generatedRemainingFilters.expressions[0]->toString();
+
+    // Extract all columns from generatedRemainingFilters.inputType
+    if (generatedRemainingFilters.inputType) {
+      for (int i = 0; i < generatedRemainingFilters.inputType->size(); ++i) {
+        const auto& columnName = generatedRemainingFilters.inputType->nameOf(i);
+        additionalColumnNames.push_back(columnName);
+        additionalColumnTypes.push_back(
+            generatedRemainingFilters.inputType->childAt(i));
+      }
     }
-    auto actualDir =
-        fmt::format("{}/actual_{}", tableOutputRootDir->getPath(), i);
-    VELOX_CHECK(std::filesystem::create_directory(actualDir));
-    writeTasks[2 * i] =
-        makeWriteTask(testSetups[i], data, actualDir, bucketColumnIndices);
-    if (i == config_.evolutionCount - 1) {
-      continue;
+
+    if (!additionalColumnNames.empty()) {
+      VLOG(1)
+          << "Found " << additionalColumnNames.size()
+          << " columns from generateRemainingFilters, will add to schema evolution";
     }
-    auto expectedDir =
-        fmt::format("{}/expected_{}", tableOutputRootDir->getPath(), i);
-    VELOX_CHECK(std::filesystem::create_directory(expectedDir));
-    auto expectedData = std::static_pointer_cast<RowVector>(
-        liftToType(data, testSetups.back().schema));
-    writeTasks[2 * i + 1] = makeWriteTask(
-        testSetups.back(), expectedData, expectedDir, bucketColumnIndices);
+  } else {
+    VLOG(1) << "Skipping remaining filter generation (50% randomization)";
   }
+
+  // Step 2: Test setup and bucketColumnIndices generation with additional
+  // columns
+  auto bucketColumnIndices = generateBucketColumnIndices();
+
+  // Track column name mappings during evolution
+  std::unordered_map<std::string, std::string> columnNameMapping;
+  for (const auto& columnName : additionalColumnNames) {
+    columnNameMapping[columnName] = columnName; // Initially map to itself
+  }
+
+  auto testSetups = makeSetups(
+      bucketColumnIndices,
+      additionalColumnNames,
+      additionalColumnTypes,
+      &columnNameMapping);
+
+  // Step 3: Create and execute write tasks
+  auto tableOutputRootDir = TempDirectoryPath::create();
+  std::vector<std::shared_ptr<TaskCursor>> writeTasks(
+      2 * config_.evolutionCount - 1);
+  RowVectorPtr finalExpectedData;
+
+  folly::F14FastMap<int, folly::F14FastSet<std::string>> globalMapColumnKeys;
+  std::vector<int> globallyConsistentColumnIndexVector;
+
+  createWriteTasks(
+      testSetups,
+      bucketColumnIndices,
+      tableOutputRootDir->getPath(),
+      writeTasks,
+      finalExpectedData,
+      globalMapColumnKeys,
+      globallyConsistentColumnIndexVector);
+
   auto executor = folly::getGlobalCPUExecutor();
   auto writeResults = runTaskCursors(writeTasks, *executor);
 
+  // Step 4: Create scan splits from write results
   std::optional<int32_t> selectedBucket;
   if (!bucketColumnIndices.empty()) {
     selectedBucket =
@@ -358,38 +732,115 @@ void TableEvolutionFuzzer::run() {
     VLOG(1) << "selectedBucket=" << *selectedBucket;
   }
 
-  std::vector<Split> actualSplits, expectedSplits;
-  for (int i = 0; i < config_.evolutionCount; ++i) {
-    auto* result = &writeResults[2 * i];
-    buildScanSplitFromTableWriteResult(
-        testSetups.back().schema,
-        bucketColumnIndices,
-        selectedBucket,
-        testSetups.back().bucketCount(),
-        testSetups[i].bucketCount(),
-        testSetups[i].fileFormat,
-        *result,
-        actualSplits);
-    if (i < config_.evolutionCount - 1) {
-      result = &writeResults[2 * i + 1];
+  auto [actualSplits, expectedSplits] = createScanSplitsFromWriteResults(
+      writeResults,
+      testSetups,
+      bucketColumnIndices,
+      selectedBucket,
+      finalExpectedData);
+
+  // Step 5: Setup scan tasks with filters and optional aggregation pushdown
+  auto rowType = testSetups.back().schema;
+  PushdownConfig pushdownConfig;
+
+  // Generate subfield filters first
+  pushdownConfig.subfieldFiltersMap =
+      generateSubfieldFilters(rowType, finalExpectedData);
+
+  // Extract field names used by subfield filters to avoid conflicts
+  std::unordered_set<std::string> subfieldFilteredFields;
+  for (const auto& [subfield, filter] : pushdownConfig.subfieldFiltersMap) {
+    auto fieldName = subfield.toString();
+    VLOG(1) << "Raw subfield: " << fieldName << ' ' << filter->toString();
+    // Extract the root field name (before any nested access)
+    const size_t dotPos = fieldName.find('.');
+    if (dotPos != std::string::npos) {
+      fieldName = fieldName.substr(0, dotPos);
+      VLOG(1) << "Subfield filter targets field: " << fieldName;
+    }
+    subfieldFilteredFields.insert(fieldName);
+  }
+
+  // Apply generated remaining filters with updated column names, avoiding
+  // conflicts
+  if (shouldGenerateRemainingFilters) {
+    // Apply generated remaining filters
+    applyRemainingFilters(
+        generatedRemainingFilters,
+        columnNameMapping,
+        pushdownConfig,
+        subfieldFilteredFields);
+  }
+
+  // Collect all filtered columns (both subfield and remaining filters)
+  std::unordered_set<std::string> allFilteredColumns = subfieldFilteredFields;
+
+  // Extract columns from remaining filter if present
+  if (!pushdownConfig.remainingFilter.empty()) {
+    for (const auto& name : rowType->names()) {
+      // Check if the column name appears in the remaining filter
+      if (pushdownConfig.remainingFilter.find(name) != std::string::npos) {
+        allFilteredColumns.insert(name);
+      }
     }
-    buildScanSplitFromTableWriteResult(
-        testSetups.back().schema,
-        bucketColumnIndices,
-        selectedBucket,
-        testSetups.back().bucketCount(),
-        testSetups.back().bucketCount(),
-        testSetups.back().fileFormat,
-        *result,
-        expectedSplits);
   }
-  std::vector<std::unique_ptr<TaskCursor>> scanTasks(2);
-  scanTasks[0] =
-      makeScanTask(testSetups.back().schema, std::move(actualSplits));
-  scanTasks[1] =
-      makeScanTask(testSetups.back().schema, std::move(expectedSplits));
+
+  // Enable aggregation testing
+  std::optional<AggregationConfig> aggConfig;
+  bool shouldTestAggregation =
+      folly::Random::oneIn(FLAGS_aggregation_pushdown_frequency, rng_);
+  if (shouldTestAggregation) {
+    aggConfig = generateAggregationConfig(rowType, rng_, allFilteredColumns);
+    if (aggConfig.has_value()) {
+      VLOG(1) << "Testing aggregation pushdown with grouping keys: ["
+              << folly::join(", ", aggConfig->groupingKeys)
+              << "] and aggregates: ["
+              << folly::join(", ", aggConfig->aggregates) << "]";
+    } else {
+      VLOG(1) << "Could not generate valid aggregation configuration";
+      aggConfig = std::nullopt;
+    }
+  }
+
+  std::vector<std::shared_ptr<TaskCursor>> scanTasks(2);
+  // actual: TableScan -> Aggregation (allows pushdown)
+  pushdownConfig.aggregationConfig = aggConfig;
+  scanTasks[0] = makeScanTask(
+      rowType,
+      std::move(actualSplits),
+      pushdownConfig,
+      false,
+      false, // insertProjectToBlockPushdown
+      globalMapColumnKeys,
+      globallyConsistentColumnIndexVector);
+
+  // expected: TableScan -> Project -> Aggregation (blocks pushdown)
+  // Insert a Project node to prevent aggregation pushdown
+  pushdownConfig.aggregationConfig = aggConfig;
+  scanTasks[1] = makeScanTask(
+      rowType,
+      std::move(expectedSplits),
+      pushdownConfig,
+      true,
+      true, // insertProjectToBlockPushdown
+      globalMapColumnKeys,
+      globallyConsistentColumnIndexVector);
+
+  ScopedOOMInjector oomInjectorReadPath(
+      [this]() -> bool { return folly::Random::oneIn(10, rng_); },
+      10); // Check the condition every 10 ms.
+  if (FLAGS_enable_oom_injection_read_path) {
+    oomInjectorReadPath.enable();
+  }
+
+  // Step 6: Execute scan tasks and verify results
   auto scanResults = runTaskCursors(scanTasks, *executor);
-  checkResultsEqual(scanResults[0], scanResults[1]);
+
+  // Skip result verification when OOM injection is enabled
+  if (!FLAGS_enable_oom_injection_write_path &&
+      !FLAGS_enable_oom_injection_read_path) {
+    checkResultsEqual(scanResults[0], scanResults[1]);
+  }
 }
 
 int TableEvolutionFuzzer::Setup::bucketCount() const {
@@ -416,13 +867,25 @@ TypePtr TableEvolutionFuzzer::makeNewType(int maxDepth) {
   return vectorFuzzer_.randType(scalarTypes, maxDepth);
 }
 
-RowTypePtr TableEvolutionFuzzer::makeInitialSchema() {
+RowTypePtr TableEvolutionFuzzer::makeInitialSchema(
+    const std::vector<std::string>& additionalColumnNames,
+    const std::vector<TypePtr>& additionalColumnTypes) {
   std::vector<std::string> names(config_.columnCount);
   std::vector<TypePtr> types(config_.columnCount);
   for (int i = 0; i < config_.columnCount; ++i) {
     names[i] = makeNewName();
     types[i] = makeNewType(3);
   }
+
+  // Add additional columns from generateRemainingFilters
+  for (int i = 0; i < additionalColumnNames.size(); ++i) {
+    names.push_back(additionalColumnNames[i]);
+    types.push_back(additionalColumnTypes[i]);
+    VLOG(1) << "Adding additional column to initial schema: "
+            << additionalColumnNames[i] << " of type "
+            << additionalColumnTypes[i]->toString();
+  }
+
   return ROW(std::move(names), std::move(types));
 }
 
@@ -449,6 +912,10 @@ TypePtr TableEvolutionFuzzer::evolveType(const TypePtr& old) {
     case TypeKind::SMALLINT:
       return INTEGER();
     case TypeKind::INTEGER:
+      // Don't evolve DATE type to BIGINT
+      if (old->isDate()) {
+        return old;
+      }
       return BIGINT();
     case TypeKind::REAL:
       return DOUBLE();
@@ -459,7 +926,8 @@ TypePtr TableEvolutionFuzzer::evolveType(const TypePtr& old) {
 
 RowTypePtr TableEvolutionFuzzer::evolveRowType(
     const RowType& old,
-    const std::vector<column_index_t>& bucketColumnIndices) {
+    const std::vector<column_index_t>& bucketColumnIndices,
+    std::unordered_map<std::string, std::string>* columnNameMapping) {
   auto names = old.names();
   auto types = old.children();
   for (int i = 0, j = 0; i < old.size(); ++i) {
@@ -471,7 +939,22 @@ RowTypePtr TableEvolutionFuzzer::evolveRowType(
       continue;
     }
     if (folly::Random::oneIn(4, rng_)) {
-      names[i] = makeNewName();
+      auto oldName = names[i];
+      auto newName = makeNewName();
+      names[i] = newName;
+
+      // Update column name mapping if provided
+      if (columnNameMapping) {
+        // Find if this column was originally from generateRemainingFilters
+        for (auto& [originalName, currentName] : *columnNameMapping) {
+          if (currentName == oldName) {
+            currentName = newName;
+            VLOG(1) << "Updated column name mapping: " << originalName << " -> "
+                    << newName;
+            break;
+          }
+        }
+      }
     }
     types[i] = evolveType(types[i]);
   }
@@ -483,14 +966,18 @@ RowTypePtr TableEvolutionFuzzer::evolveRowType(
 }
 
 std::vector<TableEvolutionFuzzer::Setup> TableEvolutionFuzzer::makeSetups(
-    const std::vector<column_index_t>& bucketColumnIndices) {
+    const std::vector<column_index_t>& bucketColumnIndices,
+    const std::vector<std::string>& additionalColumnNames,
+    const std::vector<TypePtr>& additionalColumnTypes,
+    std::unordered_map<std::string, std::string>* columnNameMapping) {
   std::vector<Setup> setups(config_.evolutionCount);
   for (int i = 0; i < config_.evolutionCount; ++i) {
     if (i == 0) {
-      setups[i].schema = makeInitialSchema();
-    } else {
       setups[i].schema =
-          evolveRowType(*setups[i - 1].schema, bucketColumnIndices);
+          makeInitialSchema(additionalColumnNames, additionalColumnTypes);
+    } else {
+      setups[i].schema = evolveRowType(
+          *setups[i - 1].schema, bucketColumnIndices, columnNameMapping);
     }
     if (!bucketColumnIndices.empty()) {
       if (i == 0) {
@@ -513,22 +1000,161 @@ std::unique_ptr<TaskCursor> TableEvolutionFuzzer::makeWriteTask(
     const Setup& setup,
     const RowVectorPtr& data,
     const std::string& outputDir,
-    const std::vector<column_index_t>& bucketColumnIndices) {
+    const std::vector<column_index_t>& bucketColumnIndices,
+    FuzzerGenerator& rng,
+    bool enableFlatMap,
+    folly::F14FastMap<int, folly::F14FastSet<std::string>>& globalMapColumnKeys,
+    std::vector<int>& globallyCompatibleFlatmapColumns) {
   auto builder = PlanBuilder().values({data});
+
+  // Create serdeParameters using proper dwrf::Config for flatmap configuration
+  std::unordered_map<std::string, std::string> serdeParameters;
+
+  if (hasMapColumns(setup.schema)) {
+    // Find all top-level map column indices that support flatmap
+    std::vector<uint32_t> supportedMapColumnIndices;
+
+    for (int i = 0; i < setup.schema->size(); ++i) {
+      if (setup.schema->childAt(i)->isMap()) {
+        // Check if this specific map column has any empty elements
+        if (hasEmptyElement(data, i)) {
+          removeFromVector(globallyCompatibleFlatmapColumns, i);
+          continue;
+        }
+
+        if (!hasUnsupportedMapKey(setup.schema->childAt(i))) {
+          // %50 chance to enable flatmap for this map column.
+          if (enableFlatMap && folly::Random::oneIn(2, rng)) {
+            supportedMapColumnIndices.push_back(static_cast<uint32_t>(i));
+            VLOG(1) << "Write column " << setup.schema->nameOf(i)
+                    << " as flatmap";
+
+            // Extract actual keys from the map data and collect directly into
+            // global set
+            SelectivityVector allRows(data->childAt(i)->size());
+            DecodedVector decodedMap(*data->childAt(i), allRows);
+            auto* mapVector = decodedMap.base()->asChecked<MapVector>();
+            if (mapVector->size() > 0) {
+              auto keys = mapVector->mapKeys();
+
+              if (keys) {
+                // Collect keys directly into the global set
+                auto& uniqueKeys = globalMapColumnKeys[static_cast<int>(i)];
+
+                // Iterate through the decoded rows, not the raw mapVector
+                // indices
+                for (vector_size_t row = 0; row < data->childAt(i)->size();
+                     ++row) {
+                  auto decodedIndex = decodedMap.index(row);
+                  if (!decodedMap.isNullAt(row) &&
+                      !mapVector->isNullAt(decodedIndex)) {
+                    // Get the map entry for this decoded row
+                    auto mapOffset = mapVector->offsetAt(decodedIndex);
+                    auto mapSize = mapVector->sizeAt(decodedIndex);
+
+                    // Process all keys in this map entry
+                    for (vector_size_t keyIdx = 0; keyIdx < mapSize; ++keyIdx) {
+                      auto keyPosition = mapOffset + keyIdx;
+                      if (!keys->isNullAt(keyPosition)) {
+                        std::string keyStr;
+                        if (keys->type()->isVarchar() ||
+                            keys->type()->isVarbinary()) {
+                          auto* keyVector = keys->asFlatVector<StringView>();
+                          auto keyView = keyVector->valueAt(keyPosition);
+                          keyStr = std::string(keyView);
+                        } else if (keys->type()->isInteger()) {
+                          auto* keyVector = keys->asFlatVector<int32_t>();
+                          auto keyVal = keyVector->valueAt(keyPosition);
+                          keyStr = std::to_string(keyVal);
+                        } else if (keys->type()->isBigint()) {
+                          auto* keyVector = keys->asFlatVector<int64_t>();
+                          auto keyVal = keyVector->valueAt(keyPosition);
+                          keyStr = std::to_string(keyVal);
+                        } else if (keys->type()->isSmallint()) {
+                          auto* keyVector = keys->asFlatVector<int16_t>();
+                          auto keyVal = keyVector->valueAt(keyPosition);
+                          keyStr = std::to_string(keyVal);
+                        } else if (keys->type()->isTinyint()) {
+                          auto* keyVector = keys->asFlatVector<int8_t>();
+                          auto keyVal = keyVector->valueAt(keyPosition);
+                          keyStr = std::to_string(keyVal);
+                        } else {
+                          // This should not be reached since
+                          // hasUnsupportedMapKey filters out unsupported types
+                          VELOX_UNREACHABLE(
+                              "Unsupported map key type: {}",
+                              keys->type()->toString());
+                        }
+                        uniqueKeys.insert(keyStr);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          } else {
+            // Remove this column from globallyCompatibleFlatmapColumns
+            removeFromVector(globallyCompatibleFlatmapColumns, i);
+          }
+        } else {
+          removeFromVector(globallyCompatibleFlatmapColumns, i);
+        }
+      }
+    }
+
+    if (!supportedMapColumnIndices.empty()) {
+      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, supportedMapColumnIndices);
+
+      // Convert to serdeParameters
+      auto configParams = config->toSerdeParams();
+      serdeParameters.insert(configParams.begin(), configParams.end());
+    }
+  }
+
   if (bucketColumnIndices.empty()) {
-    builder.tableWrite(outputDir, setup.fileFormat);
+    if (!serdeParameters.empty()) {
+      builder.tableWrite(
+          outputDir,
+          /*partitionBy=*/{},
+          /*bucketCount=*/0,
+          /*bucketedBy=*/{},
+          /*sortBy=*/{},
+          setup.fileFormat,
+          /*aggregates=*/{},
+          /*connectorId=*/PlanBuilder::kHiveDefaultConnectorId,
+          serdeParameters);
+    } else {
+      builder.tableWrite(outputDir, setup.fileFormat);
+    }
   } else {
     std::vector<std::string> bucketColumnNames;
     bucketColumnNames.reserve(bucketColumnIndices.size());
     for (auto i : bucketColumnIndices) {
       bucketColumnNames.push_back(setup.schema->nameOf(i));
     }
-    builder.tableWrite(
-        outputDir,
-        /*partitionBy=*/{},
-        setup.bucketCount(),
-        bucketColumnNames,
-        setup.fileFormat);
+    if (!serdeParameters.empty()) {
+      builder.tableWrite(
+          outputDir,
+          /*partitionBy=*/{},
+          setup.bucketCount(),
+          bucketColumnNames,
+          /*sortBy=*/{},
+          setup.fileFormat,
+          /*aggregates=*/{},
+          /*connectorId=*/PlanBuilder::kHiveDefaultConnectorId,
+          serdeParameters);
+    } else {
+      builder.tableWrite(
+          outputDir,
+          /*partitionBy=*/{},
+          setup.bucketCount(),
+          bucketColumnNames,
+          /*sortBy=*/{},
+          setup.fileFormat);
+    }
   }
   CursorParameters params;
   params.serialExecution = true;
@@ -555,19 +1181,101 @@ VectorPtr TableEvolutionFuzzer::liftToPrimitiveType(
       std::vector<BufferPtr>({}));
 }
 
+RowTypePtr TableEvolutionFuzzer::buildFlatmapAsStructSchema(
+    const RowTypePtr& tableSchema,
+    const folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+        globalMapColumnKeys,
+    const std::vector<int>& globallyCompatibleFlatmapColumns) {
+  if (globallyCompatibleFlatmapColumns.empty()) {
+    return tableSchema;
+  }
+
+  VLOG(1) << "Setting up struct reading for "
+          << globallyCompatibleFlatmapColumns.size()
+          << " flatmap columns with real keys";
+
+  auto names = tableSchema->names();
+  auto types = tableSchema->children();
+
+  // Filter globalMapColumnKeys to only include globally compatible columns
+  std::unordered_map<int, folly::F14FastSet<std::string>> filteredMapColumnKeys;
+  for (int mapColumnIndex : globallyCompatibleFlatmapColumns) {
+    if (globalMapColumnKeys.find(mapColumnIndex) != globalMapColumnKeys.end()) {
+      // Add 50% probability to include this column in filteredMapColumnKeys
+      if (folly::Random::oneIn(2, rng_)) {
+        filteredMapColumnKeys[mapColumnIndex] =
+            globalMapColumnKeys.at(mapColumnIndex);
+      }
+    }
+  }
+
+  // Use the filteredMapColumnKeys for struct reading
+  for (const auto& [mapColumnIndex, keysSet] : filteredMapColumnKeys) {
+    // Convert map type to struct type for struct reading
+    auto finalMapType = types[mapColumnIndex]->asMap();
+    auto finalValueType = finalMapType.valueType();
+    // Convert F14FastSet to vector for ROW constructor
+    std::vector<std::string> keys(keysSet.begin(), keysSet.end());
+    // Construct struct schema with real keys from write time + final value
+    // type
+    std::vector<TypePtr> finalStructFieldTypes(keys.size(), finalValueType);
+    auto finalStructSchema = ROW(keys, finalStructFieldTypes);
+
+    // Replace the map type with struct type in the schema
+    types[mapColumnIndex] = finalStructSchema;
+  }
+
+  // Build new schema using struct reading for flatmap columns
+  return ROW(names, types);
+}
+
 std::unique_ptr<TaskCursor> TableEvolutionFuzzer::makeScanTask(
     const RowTypePtr& tableSchema,
-    std::vector<Split> splits) {
+    std::vector<Split> splits,
+    const PushdownConfig& pushdownConfig,
+    bool useFiltersAsNode,
+    bool insertProjectToBlockPushdown,
+    const folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+        globalMapColumnKeys,
+    const std::vector<int>& globallyCompatibleFlatmapColumns) {
+  // Build schema for flatmap as struct reading
+  RowTypePtr newSchemaUsingStructReadingFlatMap = buildFlatmapAsStructSchema(
+      tableSchema, globalMapColumnKeys, globallyCompatibleFlatmapColumns);
+
   CursorParameters params;
   params.serialExecution = true;
-  // TODO: Mix in filter and aggregate pushdowns.
-  params.planNode = PlanBuilder()
-                        .tableScan(
-                            tableSchema,
-                            /*subfieldFilters=*/{},
-                            /*remainingFilter=*/"",
-                            tableSchema)
-                        .planNode();
+
+  auto builder = PlanBuilder()
+                     .filtersAsNode(useFiltersAsNode)
+                     .tableScanWithPushDown(
+                         newSchemaUsingStructReadingFlatMap, // Use struct
+                                                             // schema for
+                                                             // flatmap reading
+                         /*pushdownConfig=*/pushdownConfig,
+                         tableSchema, // Original schema as dataColumns
+                         {});
+
+  // If insertProjectToBlockPushdown is set, insert an identity Project node
+  // to prevent Driver::mayPushdownAggregation() from allowing pushdown
+  if (insertProjectToBlockPushdown &&
+      pushdownConfig.aggregationConfig.has_value()) {
+    // Create identity projection: simply pass through all columns
+    std::vector<std::string> projectExprs;
+    for (const auto& name : newSchemaUsingStructReadingFlatMap->names()) {
+      projectExprs.push_back(name);
+    }
+    builder.project(projectExprs);
+  }
+
+  // Add aggregation if enabled in pushdown config
+  if (pushdownConfig.aggregationConfig.has_value()) {
+    builder.singleAggregation(
+        pushdownConfig.aggregationConfig->groupingKeys,
+        pushdownConfig.aggregationConfig->aggregates);
+  }
+
+  params.planNode = builder.planNode();
+
   auto cursor = TaskCursor::create(params);
   for (auto& split : splits) {
     cursor->task()->addSplit("0", std::move(split));
@@ -576,4 +1284,224 @@ std::unique_ptr<TaskCursor> TableEvolutionFuzzer::makeScanTask(
   return cursor;
 }
 
+std::vector<column_index_t>
+TableEvolutionFuzzer::generateBucketColumnIndices() {
+  std::vector<column_index_t> bucketColumnIndices;
+  for (int i = 0; i < config_.columnCount; ++i) {
+    if (folly::Random::oneIn(2 * config_.columnCount, rng_)) {
+      bucketColumnIndices.push_back(i);
+    }
+  }
+  VLOG(1) << "bucketColumnIndices: [" << folly::join(", ", bucketColumnIndices)
+          << "]";
+  return bucketColumnIndices;
+}
+
+std::pair<std::vector<Split>, std::vector<Split>>
+TableEvolutionFuzzer::createScanSplitsFromWriteResults(
+    const std::vector<std::vector<RowVectorPtr>>& writeResults,
+    const std::vector<Setup>& testSetups,
+    const std::vector<column_index_t>& bucketColumnIndices,
+    std::optional<int32_t> selectedBucket,
+    const RowVectorPtr& finalExpectedData) {
+  std::vector<Split> actualSplits, expectedSplits;
+
+  for (int i = 0; i < config_.evolutionCount; ++i) {
+    auto* result = &writeResults[2 * i];
+    buildScanSplitFromTableWriteResult(
+        testSetups.back().schema,
+        bucketColumnIndices,
+        selectedBucket,
+        testSetups.back().bucketCount(),
+        testSetups[i].bucketCount(),
+        testSetups[i].fileFormat,
+        *result,
+        actualSplits);
+
+    if (i < config_.evolutionCount - 1) {
+      result = &writeResults[2 * i + 1];
+    }
+    buildScanSplitFromTableWriteResult(
+        testSetups.back().schema,
+        bucketColumnIndices,
+        selectedBucket,
+        testSetups.back().bucketCount(),
+        testSetups.back().bucketCount(),
+        testSetups.back().fileFormat,
+        *result,
+        expectedSplits);
+  }
+
+  return {std::move(actualSplits), std::move(expectedSplits)};
+}
+
+void TableEvolutionFuzzer::createWriteTasks(
+    const std::vector<Setup>& testSetups,
+    const std::vector<column_index_t>& bucketColumnIndices,
+    const std::string& tableOutputRootDirPath,
+    std::vector<std::shared_ptr<TaskCursor>>& writeTasks,
+    RowVectorPtr& finalExpectedData,
+    folly::F14FastMap<int, folly::F14FastSet<std::string>>& globalMapColumnKeys,
+    std::vector<int>& globallyConsistentColumnIndexVector) {
+  // Initialize globallyConsistentColumnIndexVector with all map column indices
+  // from the first schema, then filter out incompatible ones during processing
+  if (hasMapColumns(testSetups[0].schema)) {
+    for (int j = 0; j < testSetups[0].schema->size(); ++j) {
+      if (testSetups[0].schema->childAt(j)->isMap() &&
+          !hasUnsupportedMapKey(testSetups[0].schema->childAt(j))) {
+        globallyConsistentColumnIndexVector.push_back(j);
+      }
+    }
+  }
+
+  // Generate data and create write tasks in a single loop
+  for (int i = 0; i < config_.evolutionCount; ++i) {
+    // Generate fresh data for each evolution step independently
+    auto data = vectorFuzzer_.fuzzRow(testSetups[i].schema, kVectorSize, false);
+    for (auto& child : data->children()) {
+      BaseVector::flattenVector(child);
+    }
+
+    auto actualDir = fmt::format("{}/actual_{}", tableOutputRootDirPath, i);
+    VELOX_CHECK(std::filesystem::create_directory(actualDir));
+
+    // Pass globally consistent columns to restrict flatmap usage
+    writeTasks[2 * i] = makeWriteTask(
+        testSetups[i],
+        data,
+        actualDir,
+        bucketColumnIndices,
+        rng_,
+        true,
+        globalMapColumnKeys,
+        globallyConsistentColumnIndexVector);
+
+    if (i == config_.evolutionCount - 1) {
+      finalExpectedData = std::move(data);
+      continue;
+    }
+    auto expectedDir = fmt::format("{}/expected_{}", tableOutputRootDirPath, i);
+    VELOX_CHECK(std::filesystem::create_directory(expectedDir));
+    auto expectedData = std::static_pointer_cast<RowVector>(
+        liftToType(data, testSetups.back().schema));
+
+    writeTasks[2 * i + 1] = makeWriteTask(
+        testSetups.back(),
+        expectedData,
+        expectedDir,
+        bucketColumnIndices,
+        rng_,
+        true,
+        globalMapColumnKeys,
+        globallyConsistentColumnIndexVector);
+  }
+}
+
+void TableEvolutionFuzzer::applyRemainingFilters(
+    const fuzzer::ExpressionFuzzer::FuzzedExpressionData&
+        generatedRemainingFilters,
+    const std::unordered_map<std::string, std::string>& columnNameMapping,
+    PushdownConfig& pushownConfig,
+    const std::unordered_set<std::string>& subfieldFilteredFields) {
+  if (generatedRemainingFilters.expressions.empty() ||
+      columnNameMapping.empty()) {
+    return;
+  }
+
+  std::vector<std::string> filterStrings;
+  for (const auto& expr : generatedRemainingFilters.expressions) {
+    auto filterString = expr->toString();
+    VLOG(1) << "Processing remaining filter expression: " << filterString;
+
+    // First, update column names in the filter string using columnNameMapping
+    for (const auto& [originalName, currentName] : columnNameMapping) {
+      // Simple string replacement - this is a basic approach
+      // In a more robust implementation, we would parse the expression tree
+      size_t pos = 0;
+      while ((pos = filterString.find(originalName, pos)) !=
+             std::string::npos) {
+        // Check if this is a complete word (not part of another identifier)
+        bool isCompleteWord = true;
+        if (pos > 0 &&
+            (std::isalnum(filterString[pos - 1]) ||
+             filterString[pos - 1] == '_')) {
+          isCompleteWord = false;
+        }
+        if (pos + originalName.length() < filterString.length() &&
+            (std::isalnum(filterString[pos + originalName.length()]) ||
+             filterString[pos + originalName.length()] == '_')) {
+          isCompleteWord = false;
+        }
+
+        if (isCompleteWord) {
+          filterString.replace(pos, originalName.length(), currentName);
+          pos += currentName.length();
+        } else {
+          pos += originalName.length();
+        }
+      }
+    }
+
+    VLOG(1) << "After column name mapping: " << filterString;
+
+    // Now check if this filter expression conflicts with subfield filters
+    bool hasConflict = false;
+    for (const auto& subfieldField : subfieldFilteredFields) {
+      // Check if the filter string contains references to fields that are
+      // already filtered by subfield filters
+      size_t pos = 0;
+      while ((pos = filterString.find(subfieldField, pos)) !=
+             std::string::npos) {
+        // Check if this is a complete word (not part of another identifier)
+        bool isCompleteWord = true;
+        if (pos > 0 &&
+            (std::isalnum(filterString[pos - 1]) ||
+             filterString[pos - 1] == '_')) {
+          isCompleteWord = false;
+        }
+        if (pos + subfieldField.length() < filterString.length() &&
+            (std::isalnum(filterString[pos + subfieldField.length()]) ||
+             filterString[pos + subfieldField.length()] == '_')) {
+          isCompleteWord = false;
+        }
+
+        if (isCompleteWord) {
+          hasConflict = true;
+          VLOG(1)
+              << "CONFLICT DETECTED! Skipping remaining filter due to conflict with subfield filter on field: "
+              << subfieldField << ", filter: " << filterString;
+          break;
+        }
+        pos += subfieldField.length();
+      }
+      if (hasConflict) {
+        break;
+      }
+    }
+
+    // Skip this filter if it conflicts with subfield filters
+    if (hasConflict) {
+      VLOG(1) << "Skipping filter due to conflict: " << filterString;
+      continue;
+    }
+
+    VLOG(1) << "No conflict detected, proceeding with filter: " << filterString;
+
+    // Fix DATE literal format: convert bare date to DATE literal format
+    // to prevent DuckDB parser from interpreting it as arithmetic expression
+    RE2 datePattern(R"(\b(\d{4}-\d{2}-\d{2})\b)");
+    RE2::GlobalReplace(&filterString, datePattern, "DATE '\\1'");
+
+    filterStrings.push_back(filterString);
+    VLOG(1) << "Updated filter expression: " << filterString;
+  }
+
+  if (filterStrings.size() == 1) {
+    pushownConfig.remainingFilter = filterStrings[0];
+  } else if (filterStrings.size() > 1) {
+    pushownConfig.remainingFilter =
+        "(" + folly::join(") AND (", filterStrings) + ")";
+  }
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/TableEvolutionFuzzer.h b/velox/exec/tests/TableEvolutionFuzzer.h
index f1540fc1e793..80f0ff95538d 100644
--- a/velox/exec/tests/TableEvolutionFuzzer.h
+++ b/velox/exec/tests/TableEvolutionFuzzer.h
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#pragma once
+
 #include "velox/exec/Cursor.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -21,6 +23,8 @@
 #include <folly/init/Init.h>
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
+#include <unordered_set>
+#include "velox/expression/fuzzer/ExpressionFuzzer.h"
 
 namespace facebook::velox::exec::test {
 
@@ -76,22 +80,35 @@ class TableEvolutionFuzzer {
 
   TypePtr makeNewType(int maxDepth);
 
-  RowTypePtr makeInitialSchema();
+  RowTypePtr makeInitialSchema(
+      const std::vector<std::string>& additionalColumnNames = {},
+      const std::vector<TypePtr>& additionalColumnTypes = {});
 
   TypePtr evolveType(const TypePtr& old);
 
   RowTypePtr evolveRowType(
       const RowType& old,
-      const std::vector<column_index_t>& bucketColumnIndices);
+      const std::vector<column_index_t>& bucketColumnIndices,
+      std::unordered_map<std::string, std::string>* columnNameMapping =
+          nullptr);
 
   std::vector<Setup> makeSetups(
-      const std::vector<column_index_t>& bucketColumnIndices);
+      const std::vector<column_index_t>& bucketColumnIndices,
+      const std::vector<std::string>& additionalColumnNames = {},
+      const std::vector<TypePtr>& additionalColumnTypes = {},
+      std::unordered_map<std::string, std::string>* columnNameMapping =
+          nullptr);
 
   static std::unique_ptr<TaskCursor> makeWriteTask(
       const Setup& setup,
       const RowVectorPtr& data,
       const std::string& outputDir,
-      const std::vector<column_index_t>& bucketColumnIndices);
+      const std::vector<column_index_t>& bucketColumnIndices,
+      FuzzerGenerator& rng,
+      bool enableFlatMap,
+      folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+          globalMapColumnKeys,
+      std::vector<int>& globallyCompatibleFlatmapColumns);
 
   template <typename To, typename From>
   VectorPtr liftToPrimitiveType(
@@ -102,7 +119,61 @@ class TableEvolutionFuzzer {
 
   std::unique_ptr<TaskCursor> makeScanTask(
       const RowTypePtr& tableSchema,
-      std::vector<Split> splits);
+      std::vector<Split> splits,
+      const PushdownConfig& pushdownConfig,
+      bool useFiltersAsNode,
+      bool insertProjectToBlockPushdown,
+      const folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+          globalMapColumnKeys = {},
+      const std::vector<int>& globallyCompatibleFlatmapColumns = {});
+
+  /// Builds schema for flatmap as struct reading by converting selected map
+  /// columns to struct types.
+  RowTypePtr buildFlatmapAsStructSchema(
+      const RowTypePtr& tableSchema,
+      const folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+          globalMapColumnKeys,
+      const std::vector<int>& globallyCompatibleFlatmapColumns);
+
+  /// Randomly generates bucket column indices for partitioning data.
+  /// Returns a vector of column indices that will be used for bucketing,
+  /// with each column having a 1/(2*columnCount) probability of being selected.
+  std::vector<column_index_t> generateBucketColumnIndices();
+
+  /// Creates write tasks for all evolution steps.
+  /// Generates test data and creates TaskCursor objects for writing data
+  /// to temporary directories. Populates the writeTasks vector and sets
+  /// finalExpectedData to the data from the last evolution step.
+  void createWriteTasks(
+      const std::vector<Setup>& testSetups,
+      const std::vector<column_index_t>& bucketColumnIndices,
+      const std::string& tableOutputRootDirPath,
+      std::vector<std::shared_ptr<TaskCursor>>& writeTasks,
+      RowVectorPtr& finalExpectedData,
+      folly::F14FastMap<int, folly::F14FastSet<std::string>>&
+          globalMapColumnKeys,
+      std::vector<int>& globallyConsistentColumnIndexVector);
+
+  /// Creates scan splits from write results.
+  /// Converts the output of write tasks into scan splits that can be used
+  /// for reading the written data back during the scan phase.
+  std::pair<std::vector<Split>, std::vector<Split>>
+  createScanSplitsFromWriteResults(
+      const std::vector<std::vector<RowVectorPtr>>& writeResults,
+      const std::vector<Setup>& testSetups,
+      const std::vector<column_index_t>& bucketColumnIndices,
+      std::optional<int32_t> selectedBucket,
+      const RowVectorPtr& finalExpectedData);
+
+  /// Applies remaining filters with updated column names.
+  /// Updates filter expressions to use evolved column names based on the
+  /// column name mapping tracked during schema evolution.
+  void applyRemainingFilters(
+      const fuzzer::ExpressionFuzzer::FuzzedExpressionData&
+          generatedRemainingFilters,
+      const std::unordered_map<std::string, std::string>& columnNameMapping,
+      PushdownConfig& pushdownConfig,
+      const std::unordered_set<std::string>& subfieldFilteredFields);
 
   const Config config_;
   VectorFuzzer vectorFuzzer_;
diff --git a/velox/exec/tests/TableEvolutionFuzzerTest.cpp b/velox/exec/tests/TableEvolutionFuzzerTest.cpp
index 09f672488cc5..250920369ec9 100644
--- a/velox/exec/tests/TableEvolutionFuzzerTest.cpp
+++ b/velox/exec/tests/TableEvolutionFuzzerTest.cpp
@@ -18,13 +18,16 @@
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 
 #include <folly/init/Init.h>
 #include <gflags/gflags.h>
 #include <gtest/gtest.h>
+#include "velox/parse/TypeResolver.h"
 
 DEFINE_uint32(seed, 0, "");
-DEFINE_int32(duration_sec, 30, "");
+DEFINE_int32(table_evolution_fuzzer_duration_sec, 30, "");
 DEFINE_int32(column_count, 5, "");
 DEFINE_int32(evolution_count, 5, "");
 
@@ -34,16 +37,12 @@ namespace {
 
 void registerFactories(folly::Executor* ioExecutor) {
   filesystems::registerLocalFileSystem();
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              TableEvolutionFuzzer::connectorId(),
-              std::make_shared<config::ConfigBase>(
-                  std::unordered_map<std::string, std::string>()),
-              ioExecutor);
+  connector::hive::HiveConnectorFactory factory;
+  auto hiveConnector = factory.newConnector(
+      TableEvolutionFuzzer::connectorId(),
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()),
+      ioExecutor);
   connector::registerConnector(hiveConnector);
   dwio::common::registerFileSinks();
   dwrf::registerDwrfReaderFactory();
@@ -61,7 +60,8 @@ TEST(TableEvolutionFuzzerTest, run) {
   exec::test::TableEvolutionFuzzer fuzzer(config);
   fuzzer.setSeed(FLAGS_seed);
   const auto startTime = std::chrono::system_clock::now();
-  const auto deadline = startTime + std::chrono::seconds(FLAGS_duration_sec);
+  const auto deadline = startTime +
+      std::chrono::seconds(FLAGS_table_evolution_fuzzer_duration_sec);
   for (int i = 0; std::chrono::system_clock::now() < deadline; ++i) {
     LOG(INFO) << "Starting iteration " << i << ", seed=" << fuzzer.seed();
     fuzzer.run();
@@ -84,5 +84,8 @@ int main(int argc, char** argv) {
       facebook::velox::memory::MemoryManager::Options{});
   auto ioExecutor = folly::getGlobalIOExecutor();
   facebook::velox::exec::test::registerFactories(ioExecutor.get());
+  facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  facebook::velox::aggregate::prestosql::registerAllAggregateFunctions();
+  facebook::velox::parse::registerTypeResolver();
   return RUN_ALL_TESTS();
 }
diff --git a/velox/exec/tests/TableScanTest.cpp b/velox/exec/tests/TableScanTest.cpp
index 1a0e94a97d38..44fd4fc0fe6d 100644
--- a/velox/exec/tests/TableScanTest.cpp
+++ b/velox/exec/tests/TableScanTest.cpp
@@ -20,11 +20,13 @@
 #include <folly/experimental/EventCount.h>
 #include <folly/synchronization/Baton.h>
 #include <folly/synchronization/Latch.h>
+#include <filesystem>
 
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/caching/AsyncDataCache.h"
 #include "velox/common/caching/tests/CacheTestUtil.h"
+#include "velox/common/file/File.h"
 #include "velox/common/file/tests/FaultyFile.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
 #include "velox/common/memory/MemoryArbitrator.h"
@@ -33,20 +35,19 @@
 #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/dwio/orc/reader/OrcReader.h"
 #include "velox/exec/Cursor.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/HiveConnectorTestBase.h"
-#include "velox/exec/tests/utils/LocalExchangeSource.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/exec/tests/utils/TableScanTestBase.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/functions/lib/IsNull.h"
 #include "velox/type/Timestamp.h"
 #include "velox/type/Type.h"
 #include "velox/type/tests/SubfieldFiltersBuilder.h"
@@ -55,13 +56,13 @@ using namespace facebook::velox;
 using namespace facebook::velox::cache;
 using namespace facebook::velox::connector::hive;
 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;
 
 DECLARE_int32(cache_prefetch_min_pct);
 
+namespace facebook::velox::exec {
 namespace {
 void verifyCacheStats(
     const FileHandleCacheStats& cacheStats,
@@ -72,9 +73,13 @@ void verifyCacheStats(
   EXPECT_EQ(cacheStats.numHits, numHits);
   EXPECT_EQ(cacheStats.numLookups, numLookups);
 }
-} // namespace
 
-class TableScanTest : public TableScanTestBase {};
+class TableScanTest : public TableScanTestBase {
+  void SetUp() override {
+    TableScanTestBase::SetUp();
+    orc::registerOrcReaderFactory();
+  }
+};
 
 TEST_F(TableScanTest, allColumns) {
   auto vectors = makeVectors(10, 1'000);
@@ -286,7 +291,7 @@ TEST_F(TableScanTest, partitionKeyAlias) {
   writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
-  ColumnHandleMap assignments = {
+  connector::ColumnHandleMap assignments = {
       {"a", regularColumn("c0", BIGINT())},
       {"ds_alias", partitionKey("ds", VARCHAR())}};
 
@@ -355,8 +360,8 @@ TEST_F(TableScanTest, timestamp) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()}))
-           .subfieldFilter("c1 is null")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 is null")
            .endTableScan()
            .planNode();
   assertQuery(op, {filePath}, "SELECT c0, c1 FROM tmp WHERE c1 is null");
@@ -364,8 +369,8 @@ TEST_F(TableScanTest, timestamp) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(ROW({"c0", "c1"}, {BIGINT(), TIMESTAMP()}))
-           .subfieldFilter("c1 < '1970-01-01 01:30:00'::TIMESTAMP")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 < '1970-01-01 01:30:00'::TIMESTAMP")
            .endTableScan()
            .planNode();
   assertQuery(
@@ -384,8 +389,8 @@ TEST_F(TableScanTest, timestamp) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(ROW({"c0"}, {BIGINT()}))
-           .subfieldFilter("c1 is null")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 is null")
            .endTableScan()
            .planNode();
   assertQuery(op, {filePath}, "SELECT c0 FROM tmp WHERE c1 is null");
@@ -393,8 +398,8 @@ TEST_F(TableScanTest, timestamp) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(ROW({"c0"}, {BIGINT()}))
-           .subfieldFilter("c1 < timestamp'1970-01-01 01:30:00'")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 < timestamp'1970-01-01 01:30:00'")
            .endTableScan()
            .planNode();
   assertQuery(
@@ -520,8 +525,7 @@ TEST_F(TableScanTest, subfieldPruningRowType) {
   writeToFile(filePath->getPath(), vectors);
   std::vector<common::Subfield> requiredSubfields;
   requiredSubfields.emplace_back("e.c");
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
   assignments["e"] = std::make_shared<HiveColumnHandle>(
       "e",
       HiveColumnHandle::ColumnType::kRegular,
@@ -577,8 +581,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterSubfieldsMissing) {
   writeToFile(filePath->getPath(), vectors);
   std::vector<common::Subfield> requiredSubfields;
   requiredSubfields.emplace_back("e.c");
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
   assignments["e"] = std::make_shared<HiveColumnHandle>(
       "e",
       HiveColumnHandle::ColumnType::kRegular,
@@ -633,8 +636,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterRootFieldMissing) {
   auto vectors = makeVectors(10, 1'000, rowType);
   auto filePath = TempFilePath::create();
   writeToFile(filePath->getPath(), vectors);
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
   assignments["d"] = std::make_shared<HiveColumnHandle>(
       "d", HiveColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
   auto op = PlanBuilder()
@@ -676,8 +678,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterStruct) {
     for (int filterColumn = kWholeColumn; filterColumn <= kSubfieldOnly;
          ++filterColumn) {
       SCOPED_TRACE(fmt::format("{} {}", outputColumn, filterColumn));
-      std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-          assignments;
+      connector::ColumnHandleMap assignments;
       assignments["d"] = std::make_shared<HiveColumnHandle>(
           "d", HiveColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
       if (outputColumn > kNoOutput) {
@@ -762,8 +763,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterMap) {
     for (int filterColumn = kWholeColumn; filterColumn <= kSubfieldOnly;
          ++filterColumn) {
       SCOPED_TRACE(fmt::format("{} {}", outputColumn, filterColumn));
-      std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-          assignments;
+      connector::ColumnHandleMap assignments;
       assignments["a"] = std::make_shared<HiveColumnHandle>(
           "a", HiveColumnHandle::ColumnType::kRegular, BIGINT(), BIGINT());
       if (outputColumn > kNoOutput) {
@@ -780,8 +780,7 @@ TEST_F(TableScanTest, subfieldPruningRemainingFilterMap) {
       }
       std::string remainingFilter;
       if (filterColumn == kWholeColumn) {
-        remainingFilter =
-            "coalesce(b, cast(null AS MAP(BIGINT, BIGINT)))[0] == 0";
+        remainingFilter = "coalesce(b, map_concat(b, b))[0] == 0";
       } else {
         remainingFilter = "b[0] == 0";
       }
@@ -862,8 +861,7 @@ TEST_F(TableScanTest, subfieldPruningMapType) {
   requiredSubfields.emplace_back("c[0]");
   requiredSubfields.emplace_back("c[2]");
   requiredSubfields.emplace_back("c[4]");
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
   assignments["c"] = std::make_shared<HiveColumnHandle>(
       "c",
       HiveColumnHandle::ColumnType::kRegular,
@@ -946,8 +944,7 @@ TEST_F(TableScanTest, subfieldPruningArrayType) {
   writeToFile(filePath->getPath(), vectors);
   std::vector<common::Subfield> requiredSubfields;
   requiredSubfields.emplace_back("c[3]");
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
   assignments["c"] = std::make_shared<HiveColumnHandle>(
       "c",
       HiveColumnHandle::ColumnType::kRegular,
@@ -1064,8 +1061,8 @@ TEST_F(TableScanTest, missingColumns) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(outputType)
-           .subfieldFilter("c1 <= 100.1")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 <= 100.1")
            .endTableScan()
            .planNode();
   assertQuery(op, filePaths, "SELECT * FROM tmp WHERE c1 <= 100.1", 0);
@@ -1074,8 +1071,8 @@ TEST_F(TableScanTest, missingColumns) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(outputType)
-           .subfieldFilter("c1 <= 2000.1")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 <= 2000.1")
            .endTableScan()
            .planNode();
 
@@ -1085,8 +1082,8 @@ TEST_F(TableScanTest, missingColumns) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(outputTypeC0)
-           .subfieldFilter("c1 <= 3000.1")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 <= 3000.1")
            .endTableScan()
            .planNode();
 
@@ -1096,8 +1093,8 @@ TEST_F(TableScanTest, missingColumns) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(ROW({}, {}))
-           .subfieldFilter("c1 <= 4000.1")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 <= 4000.1")
            .endTableScan()
            .singleAggregation({}, {"count(1)"})
            .planNode();
@@ -1109,7 +1106,7 @@ TEST_F(TableScanTest, missingColumns) {
   filters[common::Subfield("c1")] = lessThanOrEqualDouble(1050.0, true);
   auto tableHandle = std::make_shared<HiveTableHandle>(
       kHiveConnectorId, "tmp", true, std::move(filters), nullptr, dataColumns);
-  ColumnHandleMap assignments;
+  connector::ColumnHandleMap assignments;
   assignments["c0"] = regularColumn("c0", BIGINT());
   op = PlanBuilder(pool_.get())
            .startTableScan()
@@ -1125,8 +1122,8 @@ TEST_F(TableScanTest, missingColumns) {
   op = PlanBuilder(pool_.get())
            .startTableScan()
            .outputType(ROW({}, {}))
-           .subfieldFilter("c1 is null")
            .dataColumns(dataColumns)
+           .subfieldFilter("c1 is null")
            .endTableScan()
            .singleAggregation({}, {"count(1)"})
            .planNode();
@@ -1347,6 +1344,18 @@ TEST_F(TableScanTest, batchSize) {
     EXPECT_GT(opStats.outputPositions / opStats.outputVectors, 1);
     EXPECT_LT(opStats.outputPositions / opStats.outputVectors, numRows);
   }
+  {
+    SCOPED_TRACE("Projection");
+    plan = PlanBuilder().tableScan(ROW({}, {}), {}, "", rowType).planNode();
+    auto task = AssertQueryBuilder(plan)
+                    .splits(makeHiveConnectorSplits({filePath}))
+                    .config(
+                        QueryConfig::kPreferredOutputBatchBytes,
+                        std::to_string(1 + numRows / 8))
+                    .assertResults(makeRowVector(ROW({}, {}), numRows));
+    const auto opStats = task->taskStats().pipelineStats[0].operatorStats[0];
+    EXPECT_EQ(opStats.outputVectors, 1);
+  }
 }
 
 // Test that adding the same split with the same sequence id does not cause
@@ -1767,6 +1776,33 @@ TEST_F(TableScanTest, preloadEmptySplit) {
   assertQuery(op, filePaths, "SELECT * FROM tmp", 1);
 }
 
+TEST_F(TableScanTest, readAsLowerCase) {
+  auto rowType =
+      ROW({"Товары", "国Ⅵ", "\uFF21", "\uFF22"},
+          {BIGINT(), DOUBLE(), REAL(), INTEGER()});
+  auto vectors = makeVectors(10, 1'000, rowType);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+  createDuckDbTable(vectors);
+
+  // Test reading table with non-ascii names.
+  auto op = PlanBuilder()
+                .tableScan(
+                    ROW({"товары", "国ⅵ", "\uFF41", "\uFF42"},
+                        {BIGINT(), DOUBLE(), REAL(), INTEGER()}))
+                .planNode();
+  auto split =
+      exec::test::HiveConnectorSplitBuilder(filePath->getPath()).build();
+
+  AssertQueryBuilder(op, duckDbQueryRunner_)
+      .connectorSessionProperty(
+          kHiveConnectorId,
+          connector::hive::HiveConfig::kFileColumnNamesReadAsLowerCaseSession,
+          "true")
+      .split(split)
+      .assertResults("SELECT * FROM tmp");
+}
+
 TEST_F(TableScanTest, partitionedTableVarcharKey) {
   auto rowType = ROW({"c0", "c1"}, {BIGINT(), DOUBLE()});
   auto vectors = makeVectors(10, 1'000, rowType);
@@ -1855,7 +1891,7 @@ TEST_F(TableScanTest, partitionedTableDateKey) {
                      .partitionKey("pkey", partitionValue)
                      .build();
     auto outputType = ROW({"pkey", "c0", "c1"}, {DATE(), BIGINT(), DOUBLE()});
-    ColumnHandleMap assignments = {
+    connector::ColumnHandleMap assignments = {
         {"pkey", partitionKey("pkey", DATE())},
         {"c0", regularColumn("c0", BIGINT())},
         {"c1", regularColumn("c1", DOUBLE())}};
@@ -1895,7 +1931,7 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                    .partitionKey("pkey", partitionValue)
                    .build();
 
-  ColumnHandleMap assignments = {
+  connector::ColumnHandleMap assignments = {
       {"pkey", partitionKey("pkey", TIMESTAMP())},
       {"c0", regularColumn("c0", BIGINT())},
       {"c1", regularColumn("c1", DOUBLE())}};
@@ -1933,8 +1969,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT {}, * FROM tmp", asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT {}, * FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
 
     expect(true);
@@ -1960,9 +1998,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT c0, {}, c1 FROM tmp",
-              asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT c0, {}, c1 FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
     expect(true);
     expect(false);
@@ -1987,9 +2026,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT c0, c1, {} FROM tmp",
-              asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT c0, c1, {} FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
     expect(true);
     expect(false);
@@ -2014,8 +2054,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT {} FROM tmp", asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT {} FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
     expect(true);
     expect(false);
@@ -2062,8 +2104,10 @@ TEST_F(TableScanTest, partitionedTableTimestampKey) {
                   kReadTimestampPartitionValueAsLocalTimeSession,
               asLocalTime ? "true" : "false")
           .splits({split})
-          .assertResults(fmt::format(
-              "SELECT {}, * FROM tmp", asLocalTime ? tsValueAsLocal : tsValue));
+          .assertResults(
+              fmt::format(
+                  "SELECT {}, * FROM tmp",
+                  asLocalTime ? tsValueAsLocal : tsValue));
     };
     expect(true);
     expect(false);
@@ -2223,7 +2267,8 @@ TEST_F(TableScanTest, statsBasedSkipping) {
   // c0 <= -1 -> whole file should be skipped based on stats
   auto subfieldFilters = singleSubfieldFilter("c0", lessThanOrEqual(-1));
 
-  ColumnHandleMap assignments = {{"c1", regularColumn("c1", INTEGER())}};
+  connector::ColumnHandleMap assignments = {
+      {"c1", regularColumn("c1", INTEGER())}};
 
   auto assertQuery = [&](const std::string& query) {
     auto tableHandle = makeTableHandle(
@@ -2470,7 +2515,7 @@ TEST_F(TableScanTest, statsBasedSkippingWithoutDecompression) {
   auto assertQuery = [&](const std::string& filter) {
     auto rowType = asRowType(rowVector->type());
     return TableScanTest::assertQuery(
-        PlanBuilder(pool_.get()).tableScan(rowType, {filter}).planNode(),
+        PlanBuilder(pool_.get()).tableScan(rowType, {}, {filter}).planNode(),
         filePaths,
         "SELECT * FROM tmp WHERE " + filter);
   };
@@ -3031,6 +3076,7 @@ TEST_F(TableScanTest, bucketConversion) {
     return splits;
   };
   {
+    SCOPED_TRACE("Basic");
     auto outputType = ROW({"c1"}, {BIGINT()});
     auto plan = PlanBuilder().tableScan(outputType, {}, "", schema).planNode();
     std::vector<int64_t> c1;
@@ -3087,6 +3133,28 @@ TEST_F(TableScanTest, bucketConversion) {
     auto expected = makeRowVector({"c2", "c1"}, {data, data});
     AssertQueryBuilder(plan).splits(makeSplits()).assertResults(expected);
   }
+  {
+    SCOPED_TRACE("Dynamic filters");
+    auto outputType = ROW({"c1"}, {BIGINT()});
+    auto build = makeRowVector({"cc1"}, {makeFlatVector<int64_t>({2, 3})});
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanNodeId;
+    auto plan =
+        PlanBuilder(planNodeIdGenerator)
+            .tableScan(outputType, {}, "", schema)
+            .capturePlanNodeId(scanNodeId)
+            .hashJoin(
+                {"c1"},
+                {"cc1"},
+                PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+                "",
+                {"c1"})
+            .planNode();
+    auto expected = makeRowVector({makeConstant<int64_t>(2, 1)});
+    AssertQueryBuilder(plan)
+        .splits(scanNodeId, makeSplits())
+        .assertResults(expected);
+  }
 }
 
 TEST_F(TableScanTest, bucketConversionWithSubfieldPruning) {
@@ -3137,6 +3205,52 @@ TEST_F(TableScanTest, bucketConversionWithSubfieldPruning) {
   ASSERT_EQ(j, result->size());
 }
 
+TEST_F(TableScanTest, bucketConversionLazyColumn) {
+  auto vector = makeRowVector({
+      makeFlatVector<int32_t>({1, 3, 5}),
+      makeFlatVector<int64_t>({4, 4, 6}),
+  });
+  auto schema = asRowType(vector->type());
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  constexpr int kNewNumBuckets = 4;
+  std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
+  {
+    // First split requires bucket conversion.
+    std::vector<std::shared_ptr<HiveColumnHandle>> handles;
+    handles.push_back(makeColumnHandle("c0", INTEGER(), {}));
+    auto split = makeHiveConnectorSplit(file->getPath());
+    split->tableBucketNumber = 1;
+    split->bucketConversion = {kNewNumBuckets, 2, std::move(handles)};
+    splits.push_back(split);
+  }
+  // Second split no bucket conversion, and non-empty after filter.
+  vector = makeRowVector({
+      makeFlatVector<int32_t>({1, 3, 5}),
+      makeFlatVector<int64_t>({4, 5, 6}),
+  });
+  auto file2 = TempFilePath::create();
+  writeToFile(file2->getPath(), {vector});
+  splits.push_back(makeHiveConnectorSplit(file2->getPath()));
+  {
+    // Third split requires bucket conversion, empty after filter.
+    std::vector<std::shared_ptr<HiveColumnHandle>> handles;
+    handles.push_back(makeColumnHandle("c0", INTEGER(), {}));
+    auto split = makeHiveConnectorSplit(file->getPath());
+    split->tableBucketNumber = 3;
+    split->bucketConversion = {kNewNumBuckets, 2, std::move(handles)};
+    splits.push_back(split);
+  }
+  auto outputType = ROW({"c1"}, {BIGINT()});
+  auto plan =
+      PlanBuilder().tableScan(outputType, {"c1 = 5"}, "", schema).planNode();
+  auto expected = makeRowVector({makeConstant<int64_t>(5, 1)});
+  AssertQueryBuilder(plan)
+      .splits(splits)
+      .config(core::QueryConfig::kMaxSplitPreloadPerDriver, "0")
+      .assertResults(expected);
+}
+
 TEST_F(TableScanTest, integerNotEqualFilter) {
   auto rowType = ROW(
       {"c0", "c1", "c2", "c3"}, {TINYINT(), SMALLINT(), INTEGER(), BIGINT()});
@@ -3417,7 +3531,8 @@ TEST_F(TableScanTest, remainingFilter) {
       "SELECT * FROM tmp WHERE c1 > c0 AND c0 >= 0");
 
   // Remaining filter uses columns that are not used otherwise.
-  ColumnHandleMap assignments = {{"c2", regularColumn("c2", DOUBLE())}};
+  connector::ColumnHandleMap assignments = {
+      {"c2", regularColumn("c2", DOUBLE())}};
 
   assertQuery(
       PlanBuilder(pool_.get())
@@ -4026,7 +4141,8 @@ TEST_F(TableScanTest, interleaveLazyEager) {
   auto eagerFile = TempFilePath::create();
   writeToFile(eagerFile->getPath(), rowsWithNulls);
 
-  ColumnHandleMap assignments = {{"c0", regularColumn("c0", column->type())}};
+  connector::ColumnHandleMap assignments = {
+      {"c0", regularColumn("c0", column->type())}};
   CursorParameters params;
   params.planNode = PlanBuilder()
                         .startTableScan()
@@ -4208,6 +4324,53 @@ TEST_F(TableScanTest, parallelPrepare) {
       .copyResults(pool_.get());
 }
 
+TEST_F(TableScanTest, parallelPrepareWithSubfieldFilters) {
+  // Test metadataFilter is correctly transferred during split prefetch.
+  constexpr int32_t kNumParallel = 100;
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(100, [](auto row) { return row; }),
+      makeFlatVector<int64_t>(100, [](auto row) { return row * 2; }),
+  });
+
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), {data});
+
+  auto subfieldFilters = SubfieldFiltersBuilder()
+                             .add("c0", greaterThanOrEqual(10))
+                             .add("c1", lessThan(150))
+                             .build();
+
+  auto outputType = ROW({"c0", "c1"}, {INTEGER(), BIGINT()});
+  auto remainingFilter = parseExpr("c0 % 2 = 0", outputType);
+  auto tableHandle =
+      makeTableHandle(std::move(subfieldFilters), remainingFilter);
+  auto assignments = allRegularColumns(outputType);
+
+  auto plan = exec::test::PlanBuilder(pool_.get())
+                  .startTableScan()
+                  .outputType(outputType)
+                  .tableHandle(tableHandle)
+                  .assignments(assignments)
+                  .endTableScan()
+                  .planNode();
+
+  std::vector<exec::Split> splits;
+  for (auto i = 0; i < kNumParallel; ++i) {
+    splits.push_back(makeHiveSplit(filePath->getPath()));
+  }
+
+  auto result = AssertQueryBuilder(plan)
+                    .config(
+                        core::QueryConfig::kMaxSplitPreloadPerDriver,
+                        std::to_string(kNumParallel))
+                    .splits(splits)
+                    .copyResults(pool_.get());
+
+  // Verify results: c0 >= 10 AND c1 < 150 AND c0 % 2 = 0
+  // So rows [10,12,14,...,74] = 33 rows per split
+  ASSERT_EQ(result->size(), 33 * kNumParallel);
+}
+
 TEST_F(TableScanTest, dictionaryMemo) {
   constexpr int kSize = 100;
   const char* baseStrings[] = {
@@ -4839,7 +5002,7 @@ TEST_F(TableScanTest, varbinaryPartitionKey) {
   writeToFile(filePath->getPath(), vectors);
   createDuckDbTable(vectors);
 
-  ColumnHandleMap assignments = {
+  connector::ColumnHandleMap assignments = {
       {"a", regularColumn("c0", BIGINT())},
       {"ds_alias", partitionKey("ds", VARBINARY())}};
 
@@ -4896,7 +5059,8 @@ TEST_F(TableScanTest, timestampPartitionKey) {
     return splits;
   };
 
-  ColumnHandleMap assignments = {{"t", partitionKey("t", TIMESTAMP())}};
+  connector::ColumnHandleMap assignments = {
+      {"t", partitionKey("t", TIMESTAMP())}};
   auto plan = PlanBuilder()
                   .startTableScan()
                   .outputType(ROW({"t"}, {TIMESTAMP()}))
@@ -5001,6 +5165,88 @@ TEST_F(TableScanTest, flatMapReadOffset) {
       .assertResults(expected);
 }
 
+TEST_F(TableScanTest, flatMapKeyTypeEvolution) {
+  auto vector =
+      makeRowVector({makeMapVector<int32_t, int64_t>({{{1, 2}, {3, 4}}})});
+  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});
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector}, config);
+  auto split = makeHiveConnectorSplit(file->getPath());
+  auto schema = ROW({"c0"}, {MAP(BIGINT(), BIGINT())});
+  {
+    SCOPED_TRACE("Read as map");
+    auto plan = PlanBuilder().tableScan(schema).planNode();
+    auto expected =
+        makeRowVector({makeMapVector<int64_t, int64_t>({{{1, 2}, {3, 4}}})});
+    AssertQueryBuilder(plan).split(split).assertResults(expected);
+  }
+  {
+    SCOPED_TRACE("Read as struct");
+    auto readSchema = ROW({"c0"}, {ROW({"1", "3"}, {BIGINT(), BIGINT()})});
+    auto plan = PlanBuilder().tableScan(readSchema, {}, "", schema).planNode();
+    auto expected = makeRowVector({makeRowVector(
+        {"1", "3"},
+        {makeConstant<int64_t>(2, 1), makeConstant<int64_t>(4, 1)})});
+    AssertQueryBuilder(plan).split(split).assertResults(expected);
+  }
+}
+
+TEST_F(TableScanTest, flatMapLazyRowValue) {
+  auto c0 = makeMapVector(
+      {0, 2},
+      makeFlatVector<int64_t>({1, 2, 1, 2}),
+      makeRowVector({
+          makeFlatVector<int64_t>({3, 4, 5, 6}),
+          makeFlatVector<int64_t>({7, 8, 9, 10}),
+      }));
+  auto vector = makeRowVector({c0, makeFlatVector<bool>({false, true})});
+  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});
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector}, config);
+  auto split = makeHiveConnectorSplit(file->getPath());
+  {
+    SCOPED_TRACE("Read as map");
+    auto plan = PlanBuilder()
+                    .tableScan(
+                        ROW("c0", c0->type()),
+                        {"c0 is not null", "c1 = true"},
+                        "",
+                        vector->rowType())
+                    .planNode();
+    auto expected = makeRowVector({wrapInDictionary(makeIndices({1}), c0)});
+    AssertQueryBuilder(plan).split(split).assertResults(expected);
+  }
+  {
+    SCOPED_TRACE("Read as struct");
+    auto valueType = ROW({"c0", "c1"}, {BIGINT(), BIGINT()});
+    auto readSchema = ROW("c0", ROW({"1", "2"}, valueType));
+    auto plan = PlanBuilder()
+                    .tableScan(
+                        readSchema,
+                        {"c0 is not null", "c1 = true"},
+                        "",
+                        vector->rowType())
+                    .planNode();
+    auto expected = makeRowVector({makeRowVector(
+        {"1", "2"},
+        {
+            makeRowVector({
+                makeConstant<int64_t>(5, 1),
+                makeConstant<int64_t>(9, 1),
+            }),
+            makeRowVector({
+                makeConstant<int64_t>(6, 1),
+                makeConstant<int64_t>(10, 1),
+            }),
+        })});
+    AssertQueryBuilder(plan).split(split).assertResults(expected);
+  }
+}
+
 TEST_F(TableScanTest, dynamicFilters) {
   // Make sure filters on same column from multiple downstream operators are
   // merged properly without overwriting each other.
@@ -5067,8 +5313,7 @@ TEST_F(TableScanTest, dynamicFilterWithRowIndexColumn) {
       {"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;
+  connector::ColumnHandleMap assignments;
   assignments["a"] = std::make_shared<connector::hive::HiveColumnHandle>(
       "a",
       connector::hive::HiveColumnHandle::ColumnType::kRegular,
@@ -5112,6 +5357,63 @@ TEST_F(TableScanTest, dynamicFilterWithRowIndexColumn) {
       .assertResults(resVector);
 }
 
+TEST_F(TableScanTest, bloomFilterPushdown) {
+  auto build = makeRowVector(
+      {"b"},
+      {
+          makeFlatVector<int64_t>(
+              10'001 + VectorHasher::kMaxDistinct,
+              [](auto i) { return 1000 * i; }),
+      });
+  auto probe = makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int64_t>(
+              2 * build->size(), [](auto i) { return 500 * i; }),
+      });
+  std::shared_ptr<TempFilePath> files[2];
+  files[0] = TempFilePath::create();
+  writeToFile(files[0]->getPath(), {probe});
+  files[1] = TempFilePath::create();
+  writeToFile(files[1]->getPath(), {build});
+  auto idGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId probeScanId, buildScanId, joinId;
+  auto plan = PlanBuilder(idGenerator)
+                  .tableScan(ROW({"a"}, {BIGINT()}))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"a"},
+                      {"b"},
+                      PlanBuilder(idGenerator)
+                          .tableScan(ROW({"b"}, {BIGINT()}))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      /*filter=*/"",
+                      {"a"})
+                  .capturePlanNodeId(joinId)
+                  .planNode();
+  for (bool parallelBuild : {false, true}) {
+    SCOPED_TRACE(fmt::format("parallelBuild={}", parallelBuild));
+    AssertQueryBuilder builder(plan);
+    builder
+        .config(
+            core::QueryConfig::kHashProbeBloomFilterPushdownMaxSize,
+            std::to_string(4 * build->size()))
+        .split(probeScanId, makeHiveConnectorSplit(files[0]->getPath()))
+        .split(buildScanId, makeHiveConnectorSplit(files[1]->getPath()));
+    if (parallelBuild) {
+      builder.serialExecution(false).maxDrivers(2).config(
+          core::QueryConfig::kMinTableRowsForParallelJoinBuild, "1");
+    }
+    auto task = builder.assertResults(build);
+    auto planStats = toPlanStats(task->taskStats());
+    ASSERT_EQ(
+        planStats.at(joinId).customStats.at("dynamicFiltersProduced").sum,
+        parallelBuild ? 2 : 1);
+    ASSERT_GT(planStats.at(joinId).customStats.at("bloomFilterSize").sum, 0);
+  }
+}
+
 // TODO: re-enable this test once we add back driver suspension support for
 // table scan.
 TEST_F(TableScanTest, DISABLED_memoryArbitrationWithSlowTableScan) {
@@ -5519,11 +5821,11 @@ TEST_F(TableScanTest, footerIOCount) {
           .assertResults(
               BaseVector::create<RowVector>(vector->type(), 0, pool()));
   auto stats = getTableScanRuntimeStats(task);
-  ASSERT_EQ(stats.at("numStorageRead").sum, 1);
+  ASSERT_EQ(stats.at("storageReadBytes").count, 1);
   ASSERT_GT(stats.at("footerBufferOverread").sum, 0);
 }
 
-TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
+TEST_F(TableScanTest, statsBasedFilterReorderBothEnabledAndDisabled) {
   gflags::FlagSaver gflagSaver;
   // Disable prefetch to avoid test flakiness.
   FLAGS_cache_prefetch_min_pct = 200;
@@ -5552,8 +5854,8 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
   }
   createDuckDbTable(vectors);
 
-  for (auto disableReoder : {false}) {
-    SCOPED_TRACE(fmt::format("disableReoder {}", disableReoder));
+  for (auto disableReorder : {false, true}) {
+    SCOPED_TRACE(fmt::format("disableReorder {}", disableReorder));
     auto* cache = cache::AsyncDataCache::getInstance();
     cache->clear();
 
@@ -5586,7 +5888,7 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
                   kHiveConnectorId,
                   connector::hive::HiveConfig::
                       kReadStatsBasedFilterReorderDisabledSession,
-                  disableReoder ? "true" : "false")
+                  disableReorder ? "true" : "false")
               // Disable coalesce so that each column stream has a separate read
               // per split at least.
               .connectorSessionProperty(
@@ -5610,7 +5912,7 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
       auto tableScanStats = getTableScanStats(task);
       ASSERT_EQ(tableScanStats.customStats.count("storageReadBytes"), 1);
       ASSERT_GT(tableScanStats.customStats["storageReadBytes"].sum, 0);
-      ASSERT_EQ(tableScanStats.customStats["storageReadBytes"].count, 1);
+      ASSERT_GT(tableScanStats.customStats["storageReadBytes"].count, 0);
       ASSERT_EQ(tableScanStats.numSplits, numSplits);
     }
 
@@ -5622,7 +5924,7 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
                   kHiveConnectorId,
                   connector::hive::HiveConfig::
                       kReadStatsBasedFilterReorderDisabledSession,
-                  disableReoder ? "true" : "false")
+                  disableReorder ? "true" : "false")
               .connectorSessionProperty(
                   kHiveConnectorId,
                   connector::hive::HiveConfig::kMaxCoalescedBytesSession,
@@ -5640,17 +5942,566 @@ TEST_F(TableScanTest, statsBasedFilterReorderDisabled) {
                   "SELECT c0 FROM tmp WHERE (c1 IN (1,7,11) OR c1 IS NULL) AND (c3 IN (1,7,11)  OR c3 IS NULL)");
 
       auto tableScanStats = getTableScanStats(task);
-      if (disableReoder) {
+      if (disableReorder) {
         ASSERT_EQ(tableScanStats.customStats.count("storageReadBytes"), 0);
       } else {
+        // Cache hit
         if (tableScanStats.customStats.count("storageReadBytes") == 0) {
           continue;
         }
+        // Cache miss, should behave like first time run
         ASSERT_EQ(tableScanStats.customStats.count("storageReadBytes"), 1);
         ASSERT_GT(tableScanStats.customStats["storageReadBytes"].sum, 0);
-        ASSERT_EQ(tableScanStats.customStats["storageReadBytes"].count, 1);
+        ASSERT_GT(tableScanStats.customStats["storageReadBytes"].count, 0);
       }
       ASSERT_EQ(tableScanStats.numSplits, numSplits);
     }
   }
 }
+
+TEST_F(TableScanTest, prevBatchEmptyAdaptivity) {
+  auto rowType = ROW({"c0", "c1"}, {BIGINT(), VARCHAR()});
+
+  const vector_size_t size = 100;
+  const size_t stringBytes = 1024 * 1024;
+  const size_t preferredOutputBatchBytes = 10UL << 20;
+
+  const std::string sampleString(stringBytes, 'a');
+  StringView sampleStringView(sampleString);
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int64_t>(
+           size,
+           [&](auto row) {
+             return row % 100 == 50 ? 51 : row % 100;
+           }), // so that the filter "c0 = 50" cannot rely on the min-max range
+               // to filter out all data in the data source even before the
+               // first batch is read
+       makeFlatVector<StringView>(
+           size, [&](auto /*unused*/) { return sampleStringView; })});
+
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), rowVector);
+  createDuckDbTable({rowVector});
+
+  auto plan = PlanBuilder().tableScan(rowType, {"c0 = 50"}).planNode();
+  {
+    auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                    .plan(plan)
+                    .split(makeHiveConnectorSplit(filePath->getPath()))
+                    .config(
+                        QueryConfig::kMaxOutputBatchRows,
+                        folly::to<std::string>(size * 4))
+                    .config(
+                        QueryConfig::kPreferredOutputBatchBytes,
+                        folly::to<std::string>(preferredOutputBatchBytes))
+                    .assertResults("SELECT * FROM tmp WHERE c0 = 50");
+    const auto opStats = task->taskStats().pipelineStats[0].operatorStats[0];
+    const auto numBatchesRead =
+        opStats.runtimeStats.at("dataSourceReadWallNanos").count - 1;
+    const auto batchSizeWithoutAdaptivity =
+        QueryConfig({}).preferredOutputBatchBytes() /
+        (sizeof(int64_t) + stringBytes + sizeof(StringView));
+    const auto numBatchesReadWithoutAdaptivity =
+        bits::divRoundUp(size, batchSizeWithoutAdaptivity);
+    EXPECT_GT(numBatchesReadWithoutAdaptivity, numBatchesRead);
+  }
+}
+
+TEST_F(TableScanTest, textfileEscape) {
+  auto expected = makeRowVector(
+      {"c0", "c1"},
+      {
+          makeFlatVector<std::string>({"a,bc", "d"}),
+          makeFlatVector<std::string>({"e", "e"}),
+      });
+
+  const auto tempFile = TempFilePath::create();
+  const auto tempPath = tempFile->getPath();
+  remove(tempPath.c_str());
+  LocalWriteFile localWriteFile(tempPath);
+  localWriteFile.append("a\\,bc,e\nd,e");
+  localWriteFile.close();
+
+  std::unordered_map<std::string, std::string> customSplitInfo;
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+  std::unordered_map<std::string, std::string> serdeParameters{
+      {dwio::common::SerDeOptions::kFieldDelim, ","},
+      {dwio::common::SerDeOptions::kEscapeChar, "\\"}};
+
+  auto split = std::make_shared<connector::hive::HiveConnectorSplit>(
+      kHiveConnectorId,
+      tempPath,
+      dwio::common::FileFormat(dwio::common::FileFormat::TEXT),
+      0,
+      std::numeric_limits<uint64_t>::max(),
+      partitionKeys,
+      std::nullopt,
+      customSplitInfo,
+      nullptr,
+      serdeParameters);
+
+  auto inputType = asRowType(expected->type());
+  auto plan =
+      PlanBuilder(pool()).tableScan(inputType, {}, "", inputType).planNode();
+
+  auto task = facebook::velox::exec::test::AssertQueryBuilder(plan)
+                  .split(split)
+                  .assertResults(expected);
+  auto planStats = facebook::velox::exec::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_EQ(rawInputBytes, 11);
+  ASSERT_EQ(overreadBytes, 0);
+}
+
+TEST_F(TableScanTest, textfileChunkReadEntireFile) {
+  auto expected = makeRowVector(
+      {"c0", "c1"},
+      {
+          makeFlatVector<std::string>({"row1_col1", "row2_col1", "row3_col1"}),
+          makeFlatVector<std::string>({"row1_col2", "row2_col2", "row3_col2"}),
+      });
+
+  const auto tempFile = TempFilePath::create();
+  const auto tempPath = tempFile->getPath();
+  remove(tempPath.c_str());
+  LocalWriteFile localWriteFile(tempPath);
+
+  localWriteFile.append("row1_col1,row1_col2\n");
+  localWriteFile.append("row2_col1,row2_col2\n");
+  localWriteFile.append("row3_col1,row3_col2\n");
+
+  // Add extra padding data that might be read but not used
+  localWriteFile.append("extra_row1,extra_data1\n");
+  localWriteFile.append("extra_row2,extra_data2\n");
+  localWriteFile.close();
+
+  std::unordered_map<std::string, std::string> customSplitInfo;
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+  std::unordered_map<std::string, std::string> serdeParameters{
+      {dwio::common::SerDeOptions::kFieldDelim, ","}};
+
+  // Create a split that only reads part of the file (first 60 bytes)
+  // This should cause the reader to potentially overread beyond the split
+  // boundary
+  auto split = std::make_shared<connector::hive::HiveConnectorSplit>(
+      kHiveConnectorId,
+      tempPath,
+      dwio::common::FileFormat(dwio::common::FileFormat::TEXT),
+      0,
+      59, // Limit to first 60 bytes instead of reading entire file
+      partitionKeys,
+      std::nullopt,
+      customSplitInfo,
+      nullptr,
+      serdeParameters);
+
+  auto inputType = asRowType(expected->type());
+  auto plan =
+      PlanBuilder(pool()).tableScan(inputType, {}, "", inputType).planNode();
+
+  auto task = facebook::velox::exec::test::AssertQueryBuilder(plan)
+                  .split(split)
+                  .assertResults(expected);
+
+  auto planStats = facebook::velox::exec::toPlanStats(task->taskStats());
+  auto scanNodeId = plan->id();
+  auto it = planStats.find(scanNodeId);
+  ASSERT_TRUE(it != planStats.end());
+  auto rawInputBytes = it->second.rawInputBytes;
+
+  // Entire file was read in a single chunk even though range is [0,59]
+  ASSERT_EQ(rawInputBytes, 106);
+}
+
+TEST_F(TableScanTest, textfileLarge) {
+  constexpr int kNumRows =
+      100000; // This will generate well over 8388608 bytes (per chunk read)
+  constexpr int kNumCols = 10;
+
+  constexpr int loadQuantum = 8 << 20; // loadQuantum_ as of June 2025
+
+  // Helper function to generate column data
+  auto generateColumnData = [](int row, int col) {
+    return fmt::format("row{}_col{}_padding_data_to_increase_size", row, col);
+  };
+
+  // Helper function to generate CSV row
+  auto generateCsvRow = [&](int row) {
+    std::vector<std::string> cols;
+    cols.reserve(kNumCols);
+    for (int col = 0; col < kNumCols; ++col) {
+      cols.push_back(generateColumnData(row, col));
+    }
+    return fmt::format("{}\n", fmt::join(cols, ","));
+  };
+
+  // Create expected result (only first row since split limit is 10 bytes)
+  std::vector<std::string> expectedRow;
+  expectedRow.reserve(kNumCols);
+  for (int col = 0; col < kNumCols; ++col) {
+    expectedRow.push_back(generateColumnData(0, col));
+  }
+
+  std::vector<std::string> columnNames;
+  std::vector<VectorPtr> columnVectors;
+  columnNames.reserve(kNumCols);
+  columnVectors.reserve(kNumCols);
+
+  for (int col = 0; col < kNumCols; ++col) {
+    columnNames.push_back(fmt::format("c{}", col));
+    columnVectors.push_back(makeFlatVector<std::string>({expectedRow[col]}));
+  }
+
+  auto expected = makeRowVector(columnNames, columnVectors);
+
+  // Create large file
+  const auto tempFile = TempFilePath::create();
+  const auto tempPath = tempFile->getPath();
+  remove(tempPath.c_str());
+  LocalWriteFile localWriteFile(tempPath);
+
+  for (int row = 0; row < kNumRows; ++row) {
+    localWriteFile.append(generateCsvRow(row));
+  }
+  localWriteFile.close();
+
+  ASSERT_GE(std::filesystem::file_size(tempPath), loadQuantum);
+
+  std::unordered_map<std::string, std::string> customSplitInfo;
+  std::unordered_map<std::string, std::optional<std::string>> partitionKeys;
+  std::unordered_map<std::string, std::string> serdeParameters{
+      {dwio::common::SerDeOptions::kFieldDelim, ","}};
+
+  auto split = std::make_shared<connector::hive::HiveConnectorSplit>(
+      kHiveConnectorId,
+      tempPath,
+      dwio::common::FileFormat(dwio::common::FileFormat::TEXT),
+      0,
+      10, // Limit to only first row
+      partitionKeys,
+      std::nullopt,
+      customSplitInfo,
+      nullptr,
+      serdeParameters);
+
+  auto inputType = asRowType(expected->type());
+  auto plan =
+      PlanBuilder(pool()).tableScan(inputType, {}, "", inputType).planNode();
+
+  auto task = facebook::velox::exec::test::AssertQueryBuilder(plan)
+                  .split(split)
+                  .assertResults(expected);
+
+  auto planStats = facebook::velox::exec::toPlanStats(task->taskStats());
+  auto scanNodeId = plan->id();
+  auto it = planStats.find(scanNodeId);
+  ASSERT_TRUE(it != planStats.end());
+  auto rawInputBytes = it->second.rawInputBytes;
+
+  // Verify we did not read the entire file but only a chunk
+  ASSERT_EQ(rawInputBytes, loadQuantum);
+  ASSERT_GT(getTableScanRuntimeStats(task)["totalScanTime"].sum, 0);
+  ASSERT_GT(getTableScanRuntimeStats(task)["ioWaitWallNanos"].sum, 0);
+}
+
+TEST_F(TableScanTest, duplicateFieldProject) {
+  auto vector = makeRowVector(
+      {"id", "name"},
+      {
+          makeFlatVector<int32_t>({1, 2}),
+          makeFlatVector<std::string>({"Alice", "John"}),
+      });
+
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), vector);
+  createDuckDbTable({vector});
+
+  auto plan = PlanBuilder()
+                  .tableScan(vector->rowType())
+                  .filter("name = 'John'")
+                  .project({"id AS t0", "id AS t1"})
+                  .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .split(makeHiveConnectorSplit(file->getPath()))
+      .assertResults("SELECT id, id FROM tmp WHERE name = 'John'");
+}
+
+TEST_F(TableScanTest, parallelUnitLoader) {
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(
+      filePath->getPath(),
+      vectors,
+      std::make_shared<facebook::velox::dwrf::Config>(),
+      []() { return std::make_unique<dwrf::DefaultFlushPolicy>(1000, 0); });
+  createDuckDbTable(vectors);
+  auto plan = tableScanNode();
+  auto task =
+      AssertQueryBuilder(plan)
+          .splits(makeHiveConnectorSplits({filePath}))
+          .connectorSessionProperty(
+              kHiveConnectorId,
+              connector::hive::HiveConfig::kParallelUnitLoadCountSession,
+              std::to_string(3))
+          .assertTypeAndNumRows(rowType_, 10'000);
+  auto stats = getTableScanRuntimeStats(task);
+  // Verify that parallel unit loader is enabled.
+  ASSERT_GT(stats.count("waitForUnitReadyNanos"), 0);
+}
+
+TEST_F(TableScanTest, filterColumnHandles) {
+  auto data = makeVectors(1, 10, ROW({"a", "b"}, BIGINT()));
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), data);
+  auto split = exec::test::HiveConnectorSplitBuilder(filePath->getPath())
+                   .partitionKey("ds", "2025-10-23")
+                   .build();
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(ROW({"x"}, {BIGINT()}))
+                  .assignments({{"x", regularColumn("a", BIGINT())}})
+                  .dataColumns(asRowType(data[0]->type()))
+                  .filterColumnHandles({
+                      partitionKey("ds", VARCHAR()),
+                      regularColumn("a", BIGINT()),
+                  })
+                  .remainingFilter("length(ds) + a % 2 > 0")
+                  .endTableScan()
+                  .planNode();
+  AssertQueryBuilder(plan).split(split).assertResults(
+      makeRowVector({data[0]->childAt(0)}));
+}
+
+TEST_F(TableScanTest, columnPostProcessorWithSubfieldFilters) {
+  auto data = makeFlatVector<int64_t>(10, folly::identity);
+  auto vector = makeRowVector({data, data, data});
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), {vector});
+  ChainedVectorLoader::PostVectorLoadProcessor postProc;
+  postProc = [&](auto& column) {
+    if (column->isLazy()) {
+      auto* lazy = column->template asUnchecked<LazyVector>();
+      if (lazy->isLoaded()) {
+        column = lazy->loadedVectorShared();
+        postProc(column);
+      } else {
+        lazy->chain(postProc);
+      }
+      return;
+    }
+    if (column->encoding() == VectorEncoding::Simple::DICTIONARY) {
+      auto alphabet = column->valueVector();
+      postProc(alphabet);
+      column->setValueVector(std::move(alphabet));
+      return;
+    }
+    auto* values =
+        column->template asChecked<FlatVector<int64_t>>()->mutableRawValues();
+    for (vector_size_t i = 0; i < column->size(); ++i) {
+      ++values[i];
+    }
+  };
+  auto c0Handle = std::make_shared<HiveColumnHandle>(
+      "c0",
+      HiveColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      BIGINT(),
+      std::vector<common::Subfield>{},
+      HiveColumnHandle::ColumnParseParameters{},
+      postProc);
+  auto c1Handle = regularColumn("c1", BIGINT());
+  auto c2Handle = std::make_shared<HiveColumnHandle>(
+      "c2",
+      HiveColumnHandle::ColumnType::kRegular,
+      BIGINT(),
+      BIGINT(),
+      std::vector<common::Subfield>{},
+      HiveColumnHandle::ColumnParseParameters{},
+      postProc);
+  auto expected = makeRowVector({
+      makeFlatVector<int64_t>({1, 3, 5, 7, 9}),
+      makeFlatVector<int64_t>({0, 2, 4, 6, 8}),
+      makeFlatVector<int64_t>({1, 3, 5, 7, 9}),
+  });
+  {
+    SCOPED_TRACE("Subfield filters");
+    auto plan =
+        PlanBuilder(pool())
+            .startTableScan()
+            .outputType(asRowType(vector->type()))
+            .subfieldFilter("c0 in (0, 2, 4, 6, 8)")
+            .assignments({{"c0", c0Handle}, {"c1", c1Handle}, {"c2", c2Handle}})
+            .endTableScan()
+            .planNode();
+    auto split = makeHiveConnectorSplit(file->getPath());
+    AssertQueryBuilder(plan).split(split).assertResults(expected);
+  }
+  {
+    SCOPED_TRACE("Remaining filter");
+    auto plan =
+        PlanBuilder()
+            .startTableScan()
+            .outputType(asRowType(vector->type()))
+            .remainingFilter("c0 % 2 = 0")
+            .assignments({{"c0", c0Handle}, {"c1", c1Handle}, {"c2", c2Handle}})
+            .endTableScan()
+            .planNode();
+    auto split = makeHiveConnectorSplit(file->getPath());
+    AssertQueryBuilder(plan).split(split).assertResults(expected);
+  }
+}
+
+TEST_F(TableScanTest, shortDecimalFilter) {
+  functions::registerIsNotNullFunction("isnotnull");
+
+  std::vector<std::optional<int64_t>> values = {
+      123456789123456789L,
+      987654321123456L,
+      std::nullopt,
+      2000000000000000L,
+      5000000000000000L,
+      987654321987654321L,
+      100000000000000L,
+      1230000000123456L,
+      120000000123456L,
+      std::nullopt};
+  auto rowVector = makeRowVector(
+      {"a"},
+      {
+          makeNullableFlatVector<int64_t>(values, DECIMAL(18, 6)),
+      });
+  createDuckDbTable({rowVector});
+
+  auto filePath = facebook::velox::test::getDataFilePath(
+      "velox/exec/tests", "data/decimal.orc");
+  auto split = exec::test::HiveConnectorSplitBuilder(filePath)
+                   .start(0)
+                   .length(fs::file_size(filePath))
+                   .fileFormat(dwio::common::FileFormat::ORC)
+                   .build();
+
+  auto rowType = rowVector->rowType();
+  // Is not null.
+  auto op =
+      PlanBuilder().tableScan(rowType, {}, "isnotnull(a)", rowType).planNode();
+  assertQuery(op, split, "SELECT a FROM tmp where a is not null");
+
+  // Is null.
+  op = PlanBuilder().tableScan(rowType, {}, "is_null(a)", rowType).planNode();
+  assertQuery(op, split, "SELECT a FROM tmp where a is null");
+
+  // BigintRange.
+  op =
+      PlanBuilder()
+          .tableScan(
+              rowType,
+              {},
+              "a > 2000000000.0::DECIMAL(18, 6) and a < 6000000000.0::DECIMAL(18, 6)",
+              rowType)
+          .planNode();
+  assertQuery(
+      op,
+      split,
+      "SELECT a FROM tmp where a > 2000000000.0 and a < 6000000000.0");
+
+  // NegatedBigintRange.
+  op =
+      PlanBuilder()
+          .tableScan(
+              rowType,
+              {},
+              "not(a between 2000000000.0::DECIMAL(18, 6) and 6000000000.0::DECIMAL(18, 6))",
+              rowType)
+          .planNode();
+  assertQuery(
+      op,
+      split,
+      "SELECT a FROM tmp where a < 2000000000.0 or a > 6000000000.0");
+}
+
+TEST_F(TableScanTest, longDecimalFilter) {
+  functions::registerIsNotNullFunction("isnotnull");
+
+  std::vector<std::optional<int64_t>> shortValues = {
+      123456789123456789L,
+      987654321123456L,
+      std::nullopt,
+      2000000000000000L,
+      5000000000000000L,
+      987654321987654321L,
+      100000000000000L,
+      1230000000123456L,
+      120000000123456L,
+      std::nullopt};
+
+  std::vector<std::optional<int128_t>> longValues = {
+      HugeInt::parse("123456789123456789123456789" + std::string(9, '0')),
+      HugeInt::parse("987654321123456789" + std::string(9, '0')),
+      std::nullopt,
+      HugeInt::parse("2" + std::string(37, '0')),
+      HugeInt::parse("5" + std::string(37, '0')),
+      HugeInt::parse("987654321987654321987654321" + std::string(9, '0')),
+      HugeInt::parse("1" + std::string(26, '0')),
+      HugeInt::parse("123000000012345678" + std::string(10, '0')),
+      HugeInt::parse("120000000123456789" + std::string(9, '0')),
+      HugeInt::parse("9" + std::string(37, '0'))};
+
+  auto rowVector = makeRowVector(
+      {"a", "b"},
+      {
+          makeNullableFlatVector<int64_t>(shortValues, DECIMAL(18, 6)),
+          makeNullableFlatVector<int128_t>(longValues, DECIMAL(38, 18)),
+      });
+  createDuckDbTable({rowVector});
+
+  auto filePath = facebook::velox::test::getDataFilePath(
+      "velox/exec/tests", "data/decimal.orc");
+  auto split = exec::test::HiveConnectorSplitBuilder(filePath)
+                   .start(0)
+                   .length(fs::file_size(filePath))
+                   .fileFormat(dwio::common::FileFormat::ORC)
+                   .build();
+
+  auto outputType = ROW({"b"}, {DECIMAL(38, 18)});
+  auto dataColumns = rowVector->rowType();
+
+  auto op = PlanBuilder()
+                .tableScan(outputType, {}, "isnotnull(b)", dataColumns)
+                .planNode();
+  assertQuery(op, split, "SELECT b FROM tmp where b is not null");
+
+  // Is null.
+  op = PlanBuilder()
+           .tableScan(outputType, {}, "is_null(b)", dataColumns)
+           .planNode();
+  assertQuery(op, split, "SELECT b FROM tmp where b is null");
+
+  // HugeintRange.
+  op =
+      PlanBuilder()
+          .tableScan(
+              outputType,
+              {},
+              "b > 2000000000.0::DECIMAL(38, 18) and b < 6000000000.0::DECIMAL(38, 18)",
+              dataColumns)
+          .planNode();
+  assertQuery(
+      op,
+      split,
+      "SELECT b FROM tmp where b > 2000000000.0 and b < 6000000000.0");
+
+  // Test filter column not being projected out.
+  op = PlanBuilder()
+           .tableScan(outputType, {}, "a is null", dataColumns)
+           .planNode();
+  assertQuery(op, split, "SELECT b FROM tmp WHERE a is null");
+}
+
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/exec/tests/TableWriterTest.cpp b/velox/exec/tests/TableWriterTest.cpp
index 412ab6c5f734..8a78a9208df5 100644
--- a/velox/exec/tests/TableWriterTest.cpp
+++ b/velox/exec/tests/TableWriterTest.cpp
@@ -82,7 +82,7 @@ TEST_F(BasicTableWriterTestBase, roundTrip) {
                      ->as<FlatVector<StringView>>();
   ASSERT_TRUE(details->isNullAt(0));
   ASSERT_FALSE(details->isNullAt(1));
-  folly::dynamic obj = folly::parseJson(details->valueAt(1));
+  folly::dynamic obj = folly::parseJson(std::string_view(details->valueAt(1)));
 
   ASSERT_EQ(size, obj["rowCount"].asInt());
   auto fileWriteInfos = obj["fileWriteInfos"];
@@ -93,10 +93,12 @@ TEST_F(BasicTableWriterTestBase, roundTrip) {
   // Read from 'writeFileName' and verify the data matches the original.
   plan = PlanBuilder().tableScan(rowType).planNode();
 
-  auto copy = AssertQueryBuilder(plan)
-                  .split(makeHiveConnectorSplit(fmt::format(
-                      "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
-                  .copyResults(pool());
+  auto copy =
+      AssertQueryBuilder(plan)
+          .split(makeHiveConnectorSplit(
+              fmt::format(
+                  "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
+          .copyResults(pool());
   assertEqualResults({data}, {copy});
 }
 
@@ -178,7 +180,7 @@ TEST_F(BasicTableWriterTestBase, targetFileName) {
   auto results = AssertQueryBuilder(plan).copyResults(pool());
   auto* details = results->childAt(TableWriteTraits::kFragmentChannel)
                       ->asUnchecked<SimpleVector<StringView>>();
-  auto detail = folly::parseJson(details->valueAt(1));
+  auto detail = folly::parseJson(std::string_view(details->valueAt(1)));
   auto fileWriteInfos = detail["fileWriteInfos"];
   ASSERT_EQ(1, fileWriteInfos.size());
   ASSERT_EQ(fileWriteInfos[0]["writeFileName"].asString(), kFileName);
@@ -205,66 +207,72 @@ class PartitionedTableWriterTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (bool scaleWriter : {false, true}) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
         }
       }
     }
@@ -288,26 +296,28 @@ class UnpartitionedTableWriterTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (bool scaleWriter : {false, true}) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kUnpartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_NONE,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kUnpartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_NONE,
-              scaleWriter}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kUnpartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_NONE,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kUnpartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_NONE,
+                  scaleWriter}
+                  .value);
         }
       }
     }
@@ -331,26 +341,28 @@ class BucketedUnpartitionedTableWriterTest
     const std::vector<TestMode> bucketModes = {TestMode::kOnlyBucketed};
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kOnlyBucketed,
-            CommitStrategy::kNoCommit,
-            HiveBucketProperty::Kind::kHiveCompatible,
-            true,
-            multiDrivers,
-            facebook::velox::common::CompressionKind_ZSTD,
-            /*scaleWriter=*/false}
-                                 .value);
-        testParams.push_back(TestParam{
-            fileFormat,
-            TestMode::kOnlyBucketed,
-            CommitStrategy::kTaskCommit,
-            HiveBucketProperty::Kind::kHiveCompatible,
-            true,
-            multiDrivers,
-            facebook::velox::common::CompressionKind_NONE,
-            /*scaleWriter=*/false}
-                                 .value);
+        testParams.push_back(
+            TestParam{
+                fileFormat,
+                TestMode::kOnlyBucketed,
+                CommitStrategy::kNoCommit,
+                HiveBucketProperty::Kind::kHiveCompatible,
+                true,
+                multiDrivers,
+                facebook::velox::common::CompressionKind_ZSTD,
+                /*scaleWriter=*/false}
+                .value);
+        testParams.push_back(
+            TestParam{
+                fileFormat,
+                TestMode::kOnlyBucketed,
+                CommitStrategy::kTaskCommit,
+                HiveBucketProperty::Kind::kHiveCompatible,
+                true,
+                multiDrivers,
+                facebook::velox::common::CompressionKind_NONE,
+                /*scaleWriter=*/false}
+                .value);
       }
     }
     return testParams;
@@ -375,86 +387,83 @@ class BucketedTableOnlyWriteTest
     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,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              true,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              true,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              true,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              true,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  true,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  true,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  true,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
         }
       }
     }
@@ -480,26 +489,28 @@ class BucketSortOnlyTableWriterTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (auto bucketMode : bucketModes) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              true,
-              multiDrivers,
-              facebook::velox::common::CompressionKind_ZSTD,
-              /*scaleWriter=*/false}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              bucketMode,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              true,
-              multiDrivers,
-              facebook::velox::common::CompressionKind_NONE,
-              /*scaleWriter=*/false}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  true,
+                  multiDrivers,
+                  facebook::velox::common::CompressionKind_ZSTD,
+                  /*scaleWriter=*/false}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  bucketMode,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  true,
+                  multiDrivers,
+                  facebook::velox::common::CompressionKind_NONE,
+                  /*scaleWriter=*/false}
+                  .value);
         }
       }
     }
@@ -523,26 +534,28 @@ class PartitionedWithoutBucketTableWriterTest
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (bool scaleWriter : {false, true}) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              true,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
         }
       }
     }
@@ -565,126 +578,138 @@ class AllTableWriterTest : public TableWriterTestBase,
     for (bool multiDrivers : multiDriverOptions) {
       for (FileFormat fileFormat : fileFormats) {
         for (bool scaleWriter : {false, true}) {
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kUnpartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kUnpartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kPartitioned,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kOnlyBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kOnlyBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kHiveCompatible,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kOnlyBucketed,
-              CommitStrategy::kNoCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
-          testParams.push_back(TestParam{
-              fileFormat,
-              TestMode::kOnlyBucketed,
-              CommitStrategy::kTaskCommit,
-              HiveBucketProperty::Kind::kPrestoNative,
-              false,
-              multiDrivers,
-              CompressionKind_ZSTD,
-              scaleWriter}
-                                   .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kUnpartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kUnpartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kPartitioned,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kOnlyBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kOnlyBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kHiveCompatible,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kOnlyBucketed,
+                  CommitStrategy::kNoCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
+          testParams.push_back(
+              TestParam{
+                  fileFormat,
+                  TestMode::kOnlyBucketed,
+                  CommitStrategy::kTaskCommit,
+                  HiveBucketProperty::Kind::kPrestoNative,
+                  false,
+                  multiDrivers,
+                  CompressionKind_ZSTD,
+                  scaleWriter}
+                  .value);
         }
       }
     }
@@ -1444,6 +1469,7 @@ TEST_P(UnpartitionedTableWriterTest, differentCompression) {
     }
     if (compressionKind == CompressionKind_NONE ||
         compressionKind == CompressionKind_ZLIB ||
+        compressionKind == CompressionKind_GZIP ||
         compressionKind == CompressionKind_ZSTD) {
       auto result = AssertQueryBuilder(plan)
                         .config(
@@ -1630,6 +1656,17 @@ TEST_P(BucketedTableOnlyWriteTest, bucketCountLimit) {
   SCOPED_TRACE(testParam_.toString());
   auto input = makeVectors(1, 100);
   createDuckDbTable(input);
+
+  // Get the HiveConfig to access the configurable maxBucketCount
+  auto defaultHiveConfig =
+      std::make_shared<const HiveConfig>(std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
+
+  auto emptySession = std::make_shared<config::ConfigBase>(
+      std::unordered_map<std::string, std::string>());
+  uint32_t maxBucketCount =
+      defaultHiveConfig->maxBucketCount(emptySession.get());
+
   struct {
     uint32_t bucketCount;
     bool expectedError;
@@ -1641,10 +1678,10 @@ TEST_P(BucketedTableOnlyWriteTest, bucketCountLimit) {
   } testSettings[] = {
       {1, false},
       {3, false},
-      {HiveDataSink::maxBucketCount() - 1, false},
-      {HiveDataSink::maxBucketCount(), true},
-      {HiveDataSink::maxBucketCount() + 1, true},
-      {HiveDataSink::maxBucketCount() * 2, true}};
+      {maxBucketCount - 1, false},
+      {maxBucketCount, true},
+      {maxBucketCount + 1, true},
+      {maxBucketCount * 2, true}};
   for (const auto& testData : testSettings) {
     SCOPED_TRACE(testData.debugString());
     auto outputDirectory = TempDirectoryPath::create();
@@ -1780,7 +1817,8 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
     }
     if (!fragmentVector->isNullAt(i)) {
       ASSERT_FALSE(fragmentVector->isNullAt(i));
-      folly::dynamic obj = folly::parseJson(fragmentVector->valueAt(i));
+      folly::dynamic obj =
+          folly::parseJson(std::string_view(fragmentVector->valueAt(i)));
       if (testMode_ == TestMode::kUnpartitioned) {
         ASSERT_EQ(obj["targetPath"], outputDirectory->getPath());
         ASSERT_EQ(obj["writePath"], outputDirectory->getPath());
@@ -1789,13 +1827,17 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
         for (const auto& partitionBy : partitionedBy_) {
           partitionDirRe += fmt::format("/{}=.+", partitionBy);
         }
-        ASSERT_TRUE(RE2::FullMatch(
-            obj["targetPath"].asString(),
-            fmt::format("{}{}", outputDirectory->getPath(), partitionDirRe)))
+        ASSERT_TRUE(
+            RE2::FullMatch(
+                obj["targetPath"].asString(),
+                fmt::format(
+                    "{}{}", outputDirectory->getPath(), partitionDirRe)))
             << obj["targetPath"].asString();
-        ASSERT_TRUE(RE2::FullMatch(
-            obj["writePath"].asString(),
-            fmt::format("{}{}", outputDirectory->getPath(), partitionDirRe)))
+        ASSERT_TRUE(
+            RE2::FullMatch(
+                obj["writePath"].asString(),
+                fmt::format(
+                    "{}{}", outputDirectory->getPath(), partitionDirRe)))
             << obj["writePath"].asString();
       }
       numRows += obj["rowCount"].asInt();
@@ -1820,7 +1862,7 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
         ASSERT_EQ(writeFileName, targetFileName);
       } else {
         const std::string kParquetSuffix = ".parquet";
-        if (folly::StringPiece(targetFileName).endsWith(kParquetSuffix)) {
+        if (targetFileName.ends_with(kParquetSuffix)) {
           // Remove the .parquet suffix.
           auto trimmedFilename = targetFileName.substr(
               0, targetFileName.size() - kParquetSuffix.size());
@@ -1831,9 +1873,11 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
       }
     }
     if (!commitContextVector->isNullAt(i)) {
-      ASSERT_TRUE(RE2::FullMatch(
-          commitContextVector->valueAt(i).getString(),
-          fmt::format(".*{}.*", commitStrategyToString(commitStrategy_))))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              commitContextVector->valueAt(i).getString(),
+              fmt::format(
+                  ".*{}.*", CommitStrategyName::toName(commitStrategy_))))
           << commitContextVector->valueAt(i);
     }
   }
@@ -1853,7 +1897,7 @@ TEST_P(AllTableWriterTest, tableWriteOutputCheck) {
   auto obj = TableWriteTraits::getTableCommitContext(result);
   ASSERT_EQ(
       obj[TableWriteTraits::kCommitStrategyContextKey],
-      commitStrategyToString(commitStrategy_));
+      CommitStrategyName::toName(commitStrategy_));
   ASSERT_EQ(obj[TableWriteTraits::klastPageContextKey], true);
   ASSERT_EQ(obj[TableWriteTraits::kLifeSpanContextKey], "TaskWide");
 }
@@ -1900,60 +1944,52 @@ TEST_P(AllTableWriterTest, columnStatsDataTypes) {
   auto outputDirectory = TempDirectoryPath::create();
 
   std::vector<FieldAccessTypedExprPtr> groupingKeyFields;
+  groupingKeyFields.reserve(partitionedBy_.size());
   for (int i = 0; i < partitionedBy_.size(); ++i) {
-    groupingKeyFields.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        partitionTypes_.at(i), partitionedBy_.at(i)));
+    groupingKeyFields.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            partitionTypes_.at(i), partitionedBy_.at(i)));
   }
 
   // aggregation node
   core::TypedExprPtr intInputField =
       std::make_shared<const core::FieldAccessTypedExpr>(SMALLINT(), "c2");
   auto minCallExpr = std::make_shared<const core::CallTypedExpr>(
-      SMALLINT(), std::vector<core::TypedExprPtr>{intInputField}, "min");
+      SMALLINT(), "min", intInputField);
   auto maxCallExpr = std::make_shared<const core::CallTypedExpr>(
-      SMALLINT(), std::vector<core::TypedExprPtr>{intInputField}, "max");
+      SMALLINT(), "max", intInputField);
   auto distinctCountCallExpr = std::make_shared<const core::CallTypedExpr>(
-      VARBINARY(),
-      std::vector<core::TypedExprPtr>{intInputField},
-      "approx_distinct");
+      VARBINARY(), "approx_distinct", intInputField);
 
   core::TypedExprPtr strInputField =
       std::make_shared<const core::FieldAccessTypedExpr>(VARCHAR(), "c5");
   auto maxDataSizeCallExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(),
-      std::vector<core::TypedExprPtr>{strInputField},
-      "max_data_size_for_stats");
+      BIGINT(), "max_data_size_for_stats", strInputField);
   auto sumDataSizeCallExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(),
-      std::vector<core::TypedExprPtr>{strInputField},
-      "sum_data_size_for_stats");
+      BIGINT(), "sum_data_size_for_stats", strInputField);
 
   core::TypedExprPtr boolInputField =
       std::make_shared<const core::FieldAccessTypedExpr>(BOOLEAN(), "c6");
   auto countCallExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(), std::vector<core::TypedExprPtr>{boolInputField}, "count");
+      BIGINT(), "count", boolInputField);
   auto countIfCallExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(), std::vector<core::TypedExprPtr>{boolInputField}, "count_if");
+      BIGINT(), "count_if", boolInputField);
 
   core::TypedExprPtr mapInputField =
       std::make_shared<const core::FieldAccessTypedExpr>(
           MAP(DATE(), BIGINT()), "c7");
   auto countMapCallExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(), std::vector<core::TypedExprPtr>{mapInputField}, "count");
+      BIGINT(), "count", mapInputField);
   auto sumDataSizeMapCallExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(),
-      std::vector<core::TypedExprPtr>{mapInputField},
-      "sum_data_size_for_stats");
+      BIGINT(), "sum_data_size_for_stats", mapInputField);
 
   core::TypedExprPtr arrayInputField =
       std::make_shared<const core::FieldAccessTypedExpr>(
           MAP(DATE(), BIGINT()), "c7");
   auto countArrayCallExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(), std::vector<core::TypedExprPtr>{mapInputField}, "count");
+      BIGINT(), "count", mapInputField);
   auto sumDataSizeArrayCallExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(),
-      std::vector<core::TypedExprPtr>{mapInputField},
-      "sum_data_size_for_stats");
+      BIGINT(), "sum_data_size_for_stats", mapInputField);
 
   const std::vector<std::string> aggregateNames = {
       "min",
@@ -1983,7 +2019,7 @@ TEST_P(AllTableWriterTest, columnStatsDataTypes) {
     };
   };
 
-  std::vector<core::AggregationNode::Aggregate> aggregates = {
+  const std::vector<core::AggregationNode::Aggregate> aggregates = {
       makeAggregate(minCallExpr),
       makeAggregate(maxCallExpr),
       makeAggregate(distinctCountCallExpr),
@@ -1996,22 +2032,18 @@ TEST_P(AllTableWriterTest, columnStatsDataTypes) {
       makeAggregate(countArrayCallExpr),
       makeAggregate(sumDataSizeArrayCallExpr),
   };
-  const auto aggregationNode = std::make_shared<core::AggregationNode>(
-      core::PlanNodeId(),
-      core::AggregationNode::Step::kPartial,
+  const core::ColumnStatsSpec columnStatsSpec{
       groupingKeyFields,
-      std::vector<core::FieldAccessTypedExprPtr>{},
+      core::AggregationNode::Step::kPartial,
       aggregateNames,
-      aggregates,
-      false, // ignoreNullKeys
-      PlanBuilder().values({input}).planNode());
+      aggregates};
 
   auto plan = PlanBuilder()
                   .values({input})
                   .addNode(addTableWriter(
                       rowType_,
                       rowType_->names(),
-                      aggregationNode,
+                      columnStatsSpec,
                       std::make_shared<core::InsertTableHandle>(
                           kHiveConnectorId,
                           makeHiveInsertTableHandle(
@@ -2036,7 +2068,7 @@ TEST_P(AllTableWriterTest, columnStatsDataTypes) {
   const auto distinctCountStatsVector =
       result->childAt(nextColumnStatsIndex++)->asFlatVector<StringView>();
   HashStringAllocator allocator{pool_.get()};
-  DenseHll denseHll{
+  DenseHll<> denseHll{
       std::string(distinctCountStatsVector->valueAt(0)).c_str(), &allocator};
   ASSERT_EQ(denseHll.cardinality(), 1000);
   const auto maxDataSizeStatsVector =
@@ -2087,20 +2119,15 @@ TEST_P(AllTableWriterTest, columnStats) {
   output.emplace_back("min");
   types.emplace_back(BIGINT());
   const auto writerOutputType = ROW(std::move(output), std::move(types));
-
-  // aggregation node
-  auto aggregationNode = generateAggregationNode(
-      "c0",
-      groupingKeys,
-      core::AggregationNode::Step::kPartial,
-      PlanBuilder().values({input}).planNode());
+  auto columnStatsSpec = generateColumnStatsSpec(
+      "c0", groupingKeys, core::AggregationNode::Step::kPartial);
 
   auto plan = PlanBuilder()
                   .values({input})
                   .addNode(addTableWriter(
                       rowType_,
                       rowType_->names(),
-                      aggregationNode,
+                      columnStatsSpec,
                       std::make_shared<core::InsertTableHandle>(
                           kHiveConnectorId,
                           makeHiveInsertTableHandle(
@@ -2188,16 +2215,13 @@ TEST_P(AllTableWriterTest, columnStatsWithTableWriteMerge) {
   const auto writerOutputType = ROW(std::move(output), std::move(types));
 
   // aggregation node
-  auto aggregationNode = generateAggregationNode(
-      "c0",
-      groupingKeys,
-      core::AggregationNode::Step::kPartial,
-      PlanBuilder().values({input}).planNode());
+  auto columnStatsSpec = generateColumnStatsSpec(
+      "c0", groupingKeys, core::AggregationNode::Step::kPartial);
 
   auto tableWriterPlan = PlanBuilder().values({input}).addNode(addTableWriter(
       rowType_,
       rowType_->names(),
-      aggregationNode,
+      columnStatsSpec,
       std::make_shared<core::InsertTableHandle>(
           kHiveConnectorId,
           makeHiveInsertTableHandle(
@@ -2209,17 +2233,10 @@ TEST_P(AllTableWriterTest, columnStatsWithTableWriteMerge) {
       false,
       commitStrategy_));
 
-  auto mergeAggregationNode = generateAggregationNode(
-      "min",
-      groupingKeys,
-      core::AggregationNode::Step::kIntermediate,
-      std::move(tableWriterPlan.planNode()));
-
   auto finalPlan = tableWriterPlan.capturePlanNodeId(tableWriteNodeId_)
                        .localPartition(std::vector<std::string>{})
-                       .tableWriteMerge(std::move(mergeAggregationNode))
+                       .tableWriteMerge()
                        .planNode();
-
   auto result = AssertQueryBuilder(finalPlan).copyResults(pool());
   auto rowVector = result->childAt(0)->asFlatVector<int64_t>();
   auto fragmentVector = result->childAt(1)->asFlatVector<StringView>();
@@ -2516,13 +2533,14 @@ DEBUG_ONLY_TEST_P(BucketSortOnlyTableWriterTest, outputBatchRows) {
           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}};
+  } 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());
@@ -2674,38 +2692,78 @@ DEBUG_ONLY_TEST_P(BucketSortOnlyTableWriterTest, yield) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TableWriterTest,
     UnpartitionedTableWriterTest,
-    testing::ValuesIn(UnpartitionedTableWriterTest::getTestParams()));
+    testing::ValuesIn(UnpartitionedTableWriterTest::getTestParams()),
+    [](const testing::TestParamInfo<uint64_t>& info) {
+      const auto testParams =
+          static_cast<TableWriterTestBase::TestParam>(info.param);
+      return fmt::format(
+          "UnpartitionedTableWriterTest_{}", testParams.toString());
+    });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TableWriterTest,
     BucketedUnpartitionedTableWriterTest,
-    testing::ValuesIn(BucketedUnpartitionedTableWriterTest::getTestParams()));
+    testing::ValuesIn(BucketedUnpartitionedTableWriterTest::getTestParams()),
+    [](const testing::TestParamInfo<uint64_t>& info) {
+      const auto testParams =
+          static_cast<TableWriterTestBase::TestParam>(info.param);
+      return fmt::format(
+          "BucketedUnpartitionedTableWriterTest_{}", testParams.toString());
+    });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TableWriterTest,
     PartitionedTableWriterTest,
-    testing::ValuesIn(PartitionedTableWriterTest::getTestParams()));
+    testing::ValuesIn(PartitionedTableWriterTest::getTestParams()),
+    [](const testing::TestParamInfo<uint64_t>& info) {
+      const auto testParams =
+          static_cast<TableWriterTestBase::TestParam>(info.param);
+      return fmt::format(
+          "PartitionedTableWriterTest_{}", testParams.toString());
+    });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TableWriterTest,
     BucketedTableOnlyWriteTest,
-    testing::ValuesIn(BucketedTableOnlyWriteTest::getTestParams()));
+    testing::ValuesIn(BucketedTableOnlyWriteTest::getTestParams()),
+    [](const testing::TestParamInfo<uint64_t>& info) {
+      const auto testParams =
+          static_cast<TableWriterTestBase::TestParam>(info.param);
+      return fmt::format(
+          "BucketedTableOnlyWriteTest_{}", testParams.toString());
+    });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TableWriterTest,
     AllTableWriterTest,
-    testing::ValuesIn(AllTableWriterTest::getTestParams()));
+    testing::ValuesIn(AllTableWriterTest::getTestParams()),
+    [](const testing::TestParamInfo<uint64_t>& info) {
+      const auto testParams =
+          static_cast<TableWriterTestBase::TestParam>(info.param);
+      return fmt::format("AllTableWriterTest_{}", testParams.toString());
+    });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TableWriterTest,
     PartitionedWithoutBucketTableWriterTest,
-    testing::ValuesIn(
-        PartitionedWithoutBucketTableWriterTest::getTestParams()));
+    testing::ValuesIn(PartitionedWithoutBucketTableWriterTest::getTestParams()),
+    [](const testing::TestParamInfo<uint64_t>& info) {
+      const auto testParams =
+          static_cast<TableWriterTestBase::TestParam>(info.param);
+      return fmt::format(
+          "PartitionedWithoutBucketTableWriterTest_{}", testParams.toString());
+    });
 
 VELOX_INSTANTIATE_TEST_SUITE_P(
     TableWriterTest,
     BucketSortOnlyTableWriterTest,
-    testing::ValuesIn(BucketSortOnlyTableWriterTest::getTestParams()));
+    testing::ValuesIn(BucketSortOnlyTableWriterTest::getTestParams()),
+    [](const testing::TestParamInfo<uint64_t>& info) {
+      const auto testParams =
+          static_cast<TableWriterTestBase::TestParam>(info.param);
+      return fmt::format(
+          "BucketSortOnlyTableWriterTest_{}", testParams.toString());
+    });
 
 class TableWriterArbitrationTest : public HiveConnectorTestBase {
  protected:
@@ -2738,7 +2796,7 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, reclaimFromTableWriter) {
   const int batchSize = 1'000;
   options.vectorSize = batchSize;
   options.stringVariableLength = false;
-  options.stringLength = 1'000;
+  options.stringLength = 500;
   VectorFuzzer fuzzer(options, pool());
   const int numBatches = 20;
   std::vector<RowVectorPtr> vectors;
@@ -2758,8 +2816,10 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, reclaimFromTableWriter) {
       const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
       const int numPrevNonReclaimableAttempts =
           arbitrator->stats().numNonReclaimableAttempts;
-      auto queryCtx = core::QueryCtx::create(
-          executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+      auto queryCtx = core::QueryCtx::Builder()
+                          .executor(executor_.get())
+                          .pool(std::move(queryPool))
+                          .build();
       ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
       std::atomic_int numInputs{0};
@@ -2877,8 +2937,10 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, reclaimFromSortTableWriter) {
       const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
       const int numPrevNonReclaimableAttempts =
           arbitrator->stats().numNonReclaimableAttempts;
-      auto queryCtx = core::QueryCtx::create(
-          executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+      auto queryCtx = core::QueryCtx::Builder()
+                          .executor(executor_.get())
+                          .pool(std::move(queryPool))
+                          .build();
       ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
       const auto spillStats = common::globalSpillStats();
@@ -2980,10 +3042,11 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, writerFlushThreshold) {
   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)));
+    SCOPED_TRACE(
+        fmt::format(
+            "bytesToReserve: {}, writerFlushThreshold: {}",
+            succinctBytes(testParam.bytesToReserve),
+            succinctBytes(testParam.writerFlushThreshold)));
 
     auto queryPool = memory::memoryManager()->addRootPool(
         "writerFlushThreshold", kQueryMemoryCapacity);
@@ -2991,8 +3054,11 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, writerFlushThreshold) {
     const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
     const int numPrevNonReclaimableAttempts =
         arbitrator->stats().numNonReclaimableAttempts;
-    auto queryCtx = core::QueryCtx::create(
-        executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+    auto queryCtx = core::QueryCtx::Builder()
+                        .executor(executor_.get())
+                        .pool(std::move(queryPool))
+                        .build();
+
     ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
     memory::MemoryPool* compressionPool{nullptr};
@@ -3099,8 +3165,11 @@ DEBUG_ONLY_TEST_F(
   const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
   const int numPrevNonReclaimableAttempts =
       arbitrator->stats().numNonReclaimableAttempts;
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
+
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic<bool> injectFakeAllocationOnce{true};
@@ -3182,8 +3251,10 @@ DEBUG_ONLY_TEST_F(
   const int numPrevNonReclaimableAttempts =
       arbitrator->stats().numNonReclaimableAttempts;
   const int numPrevReclaimedBytes = arbitrator->stats().reclaimedUsedBytes;
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic<bool> writerNoMoreInput{false};
@@ -3282,8 +3353,10 @@ DEBUG_ONLY_TEST_F(
   const int numPrevArbitrationFailures = arbitrator->stats().numFailures;
   const int numPrevNonReclaimableAttempts =
       arbitrator->stats().numNonReclaimableAttempts;
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic<bool> injectFakeAllocationOnce{true};
@@ -3374,8 +3447,11 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableFileWriteError) {
 
   auto queryPool = memory::memoryManager()->addRootPool(
       "tableFileWriteError", kQueryMemoryCapacity);
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
+
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic_bool injectWriterErrorOnce{true};
@@ -3442,8 +3518,10 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableWriteSpillUseMoreMemory) {
 
   auto queryPool = memory::memoryManager()->addRootPool(
       "tableWriteSpillUseMoreMemory", kQueryMemoryCapacity / 4);
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity / 4);
 
   auto fakeLeafPool = queryCtx->pool()->addLeafChild(
@@ -3529,14 +3607,18 @@ DEBUG_ONLY_TEST_F(TableWriterArbitrationTest, tableWriteReclaimOnClose) {
 
   auto queryPool = memory::memoryManager()->addRootPool(
       "tableWriteSpillUseMoreMemory", kQueryMemoryCapacity);
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   auto fakeQueryPool =
       memory::memoryManager()->addRootPool("fake", kQueryMemoryCapacity);
-  auto fakeQueryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(fakeQueryPool));
+  auto fakeQueryCtx = core::QueryCtx::Builder()
+                          .executor(executor_.get())
+                          .pool(std::move(fakeQueryPool))
+                          .build();
   ASSERT_EQ(fakeQueryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   auto fakeLeafPool = fakeQueryCtx->pool()->addLeafChild(
@@ -3622,8 +3704,10 @@ DEBUG_ONLY_TEST_F(
           .data;
   auto queryPool = memory::memoryManager()->addRootPool(
       "tableWriteSpillUseMoreMemory", kQueryMemoryCapacity);
-  auto queryCtx = core::QueryCtx::create(
-      executor_.get(), QueryConfig{{}}, {}, nullptr, std::move(queryPool));
+  auto queryCtx = core::QueryCtx::Builder()
+                      .executor(executor_.get())
+                      .pool(std::move(queryPool))
+                      .build();
   ASSERT_EQ(queryCtx->pool()->capacity(), kQueryMemoryCapacity);
 
   std::atomic_bool writerCloseWaitFlag{true};
diff --git a/velox/exec/tests/TaskTest.cpp b/velox/exec/tests/TaskTest.cpp
index 0aa7d1ed8bea..d74826cc3480 100644
--- a/velox/exec/tests/TaskTest.cpp
+++ b/velox/exec/tests/TaskTest.cpp
@@ -25,6 +25,7 @@
 #include "velox/common/testutil/TestValue.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/exec/Cursor.h"
+#include "velox/exec/HashAggregation.h"
 #include "velox/exec/OutputBufferManager.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/Values.h"
@@ -255,7 +256,8 @@ class ExternalBlocker {
  public:
   folly::SemiFuture<folly::Unit> continueFuture() {
     if (isBlocked_) {
-      auto [promise, future] = makeVeloxContinuePromiseContract();
+      auto [promise, future] =
+          makeVeloxContinuePromiseContract("ExternalBlocker::continueFuture");
       continuePromise_ = std::move(promise);
       return std::move(future);
     }
@@ -459,6 +461,55 @@ class TestBadMemoryTranslator : public exec::Operator::PlanNodeTranslator {
     return nullptr;
   }
 };
+
+// Test operator that calls the protected shouldYield() method to verify it
+// correctly delegates to the driver's shouldYield() implementation and
+// respects CPU time slice limits.
+class TestShouldYieldOperator : public exec::Operator {
+ public:
+  TestShouldYieldOperator(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const RowTypePtr& outputType,
+      const std::string& nodeId)
+      : Operator(driverCtx, outputType, operatorId, nodeId, "TestShouldYield") {
+  }
+
+  bool needsInput() const override {
+    return !noMoreInput_ && !input_;
+  }
+
+  void addInput(RowVectorPtr input) override {
+    input_ = std::move(input);
+  }
+
+  RowVectorPtr getOutput() override {
+    if (!input_) {
+      return nullptr;
+    }
+
+    // Test the protected shouldYield() method
+    shouldYieldResult_ = shouldYield();
+
+    return input_;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*unused*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override {
+    return noMoreInput_ && !input_;
+  }
+
+  bool getShouldYieldResult() const {
+    return shouldYieldResult_;
+  }
+
+ private:
+  RowVectorPtr input_;
+  bool shouldYieldResult_{false};
+};
 } // namespace
 
 class TaskTest : public HiveConnectorTestBase {
@@ -474,7 +525,8 @@ class TaskTest : public HiveConnectorTestBase {
         plan,
         0,
         core::QueryCtx::create(),
-        Task::ExecutionMode::kSerial);
+        Task::ExecutionMode::kSerial,
+        exec::Consumer{});
 
     for (const auto& [nodeId, paths] : filePaths) {
       for (const auto& path : paths) {
@@ -523,7 +575,8 @@ TEST_F(TaskTest, toJson) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
 
   ASSERT_EQ(
       task->toString(),
@@ -588,7 +641,8 @@ TEST_F(TaskTest, wrongPlanNodeForSplit) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
 
   // Add split for the source node.
   task->addSplit("0", exec::Split(folly::copy(connectorSplit)));
@@ -644,7 +698,8 @@ TEST_F(TaskTest, wrongPlanNodeForSplit) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   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(
@@ -671,7 +726,8 @@ TEST_F(TaskTest, duplicatePlanNodeIds) {
           std::move(plan),
           0,
           core::QueryCtx::create(driverExecutor_.get()),
-          Task::ExecutionMode::kParallel),
+          Task::ExecutionMode::kParallel,
+          exec::Consumer{}),
       "Plan node IDs must be unique. Found duplicate ID: 0.")
 }
 
@@ -847,8 +903,8 @@ TEST_F(TaskTest, hasMixedExecutionGroupJoin) {
 
   task->start(1);
 
-  ASSERT_FALSE(
-      task->hasMixedExecutionGroupJoin(dynamic_cast<const core::HashJoinNode*>(
+  ASSERT_FALSE(task->hasMixedExecutionGroupJoin(
+      dynamic_cast<const core::HashJoinNode*>(
           nonMixedGroupedModeJoinNode.get())));
   ASSERT_TRUE(task->hasMixedExecutionGroupJoin(
       dynamic_cast<const core::HashJoinNode*>(mixedGroupedModeJoinNode.get())));
@@ -1178,7 +1234,8 @@ TEST_F(TaskTest, serialExecutionExternalBlockable) {
       plan,
       0,
       core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
+      Task::ExecutionMode::kSerial,
+      exec::Consumer{});
   std::vector<RowVectorPtr> results;
   for (;;) {
     auto result = nonBlockingTask->next(&continueFuture);
@@ -1204,7 +1261,8 @@ TEST_F(TaskTest, serialExecutionExternalBlockable) {
       plan,
       0,
       core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
+      Task::ExecutionMode::kSerial,
+      exec::Consumer{});
   // Before we block, we expect `next` to get data normally.
   results.push_back(blockingTask->next(&continueFuture));
   EXPECT_TRUE(results.back() != nullptr);
@@ -1241,16 +1299,17 @@ TEST_F(TaskTest, supportSerialExecutionMode) {
                   .project({"c0 % 10"})
                   .partitionedOutput({}, 1, std::vector<std::string>{"p0"})
                   .planFragment();
-  auto task = Task::create(
-      "single.execution.task.0",
-      plan,
-      0,
-      core::QueryCtx::create(),
-      Task::ExecutionMode::kSerial);
-
   // PartitionedOutput does not support serial execution mode, therefore the
   // task doesn't support it either.
-  ASSERT_FALSE(task->supportSerialExecutionMode());
+  VELOX_ASSERT_THROW(
+      Task::create(
+          "single.execution.task.0",
+          plan,
+          0,
+          core::QueryCtx::create(),
+          Task::ExecutionMode::kSerial,
+          exec::Consumer{}),
+      "");
 }
 
 TEST_F(TaskTest, updateBroadCastOutputBuffers) {
@@ -1266,7 +1325,8 @@ TEST_F(TaskTest, updateBroadCastOutputBuffers) {
         plan,
         0,
         core::QueryCtx::create(driverExecutor_.get()),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
 
     task->start(1, 1);
 
@@ -1284,7 +1344,8 @@ TEST_F(TaskTest, updateBroadCastOutputBuffers) {
         plan,
         0,
         core::QueryCtx::create(driverExecutor_.get()),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
 
     task->start(1, 1);
 
@@ -1572,8 +1633,13 @@ DEBUG_ONLY_TEST_F(TaskTest, inconsistentExecutionMode) {
     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);
+    auto task = Task::create(
+        "task.0",
+        plan,
+        0,
+        queryCtx,
+        Task::ExecutionMode::kSerial,
+        exec::Consumer{});
 
     task->next();
     VELOX_ASSERT_THROW(task->start(4, 1), "Inconsistent task execution mode.");
@@ -1907,17 +1973,24 @@ TEST_F(TaskTest, driverCreationMemoryAllocationCheck) {
           .planFragment();
   for (bool singleThreadExecution : {false, true}) {
     SCOPED_TRACE(fmt::format("singleThreadExecution: ", singleThreadExecution));
-    auto badTask = Task::create(
-        "driverCreationMemoryAllocationCheck",
-        plan,
-        0,
-        core::QueryCtx::create(
-            singleThreadExecution ? nullptr : driverExecutor_.get()),
-        singleThreadExecution ? Task::ExecutionMode::kSerial
-                              : Task::ExecutionMode::kParallel);
     if (singleThreadExecution) {
-      VELOX_ASSERT_THROW(badTask->next(), "Unexpected memory pool allocations");
+      VELOX_ASSERT_THROW(
+          Task::create(
+              "driverCreationMemoryAllocationCheck",
+              plan,
+              0,
+              core::QueryCtx::create(nullptr),
+              Task::ExecutionMode::kSerial,
+              exec::Consumer{}),
+          "Unexpected memory pool allocations");
     } else {
+      auto badTask = Task::create(
+          "driverCreationMemoryAllocationCheck",
+          plan,
+          0,
+          core::QueryCtx::create(driverExecutor_.get()),
+          Task::ExecutionMode::kParallel,
+          exec::Consumer{});
       VELOX_ASSERT_THROW(
           badTask->start(1), "Unexpected memory pool allocations");
     }
@@ -1944,36 +2017,34 @@ TEST_F(TaskTest, spillDirectoryCallback) {
       {{core::QueryConfig::kSpillEnabled, "true"},
        {core::QueryConfig::kAggregationSpillEnabled, "true"}});
   params.maxDrivers = 1;
-
-  auto cursor = TaskCursor::create(params);
-
-  std::shared_ptr<Task> task = cursor->task();
-  auto tmpRootDir = exec::test::TempDirectoryPath::create();
-  auto tmpParentSpillDir = fmt::format(
+  auto spillRootDir = exec::test::TempDirectoryPath::create();
+  auto spillParentDir = fmt::format(
       "{}{}/parent_spill/",
       tests::utils::FaultyFileSystem::scheme(),
-      tmpRootDir->getPath());
-  auto tmpSpillDir = fmt::format(
+      spillRootDir->getPath());
+  auto spillDir = fmt::format(
       "{}{}/parent_spill/spill/",
       tests::utils::FaultyFileSystem::scheme(),
-      tmpRootDir->getPath());
+      spillRootDir->getPath());
 
-  EXPECT_FALSE(task->hasCreateSpillDirectoryCb());
-
-  task->setCreateSpillDirectoryCb([tmpParentSpillDir, tmpSpillDir]() {
-    auto filesystem = filesystems::getFileSystem(tmpParentSpillDir, nullptr);
+  params.spillDirectory = spillDir;
+  params.spillDirectoryCallback = [spillParentDir, spillDir]() {
+    auto filesystem = filesystems::getFileSystem(spillParentDir, nullptr);
     filesystems::DirectoryOptions options;
     options.values.emplace(
         filesystems::DirectoryOptions::kMakeDirectoryConfig.toString(),
         "dummy.config=123");
-    filesystem->mkdir(tmpParentSpillDir, options);
-    filesystem->mkdir(tmpSpillDir);
-    return tmpSpillDir;
-  });
+    filesystem->mkdir(spillParentDir, options);
+    filesystem->mkdir(spillDir);
+    return spillDir;
+  };
 
+  auto cursor = TaskCursor::create(params);
+  std::shared_ptr<Task> task = cursor->task();
   EXPECT_TRUE(task->hasCreateSpillDirectoryCb());
+
   auto fs = std::dynamic_pointer_cast<tests::utils::FaultyFileSystem>(
-      filesystems::getFileSystem(tmpParentSpillDir, nullptr));
+      filesystems::getFileSystem(spillParentDir, nullptr));
 
   fs->setFileSystemInjectionError(
       std::make_exception_ptr(std::runtime_error("test exception")),
@@ -1989,7 +2060,7 @@ TEST_F(TaskTest, spillDirectoryCallback) {
     auto mkdirOp =
         static_cast<tests::utils::FaultFileSystemMkdirOperation*>(op);
     if (mkdirOp->path ==
-        fmt::format("{}/parent_spill/", tmpRootDir->getPath())) {
+        fmt::format("{}/parent_spill/", spillRootDir->getPath())) {
       parentDirectoryCreated = true;
       auto it = mkdirOp->options.values.find(
           filesystems::DirectoryOptions::kMakeDirectoryConfig.toString());
@@ -1997,7 +2068,7 @@ TEST_F(TaskTest, spillDirectoryCallback) {
       EXPECT_EQ(it->second, "dummy.config=123");
     }
     if (mkdirOp->path ==
-        fmt::format("{}/parent_spill/spill/", tmpRootDir->getPath())) {
+        fmt::format("{}/parent_spill/spill/", spillRootDir->getPath())) {
       spillDirectoryCreated = true;
     }
     return;
@@ -2042,13 +2113,13 @@ TEST_F(TaskTest, spillDirectoryLifecycleManagement) {
       {{core::QueryConfig::kSpillEnabled, "true"},
        {core::QueryConfig::kAggregationSpillEnabled, "true"}});
   params.maxDrivers = 1;
+  const auto rootTempDir = exec::test::TempDirectoryPath::create();
+  const auto tmpDirectoryPath =
+      rootTempDir->getPath() + "/spillDirectoryLifecycleManagement";
+  params.spillDirectory = tmpDirectoryPath;
 
   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()) {
@@ -2104,7 +2175,6 @@ TEST_F(TaskTest, spillDirNotCreated) {
   auto* task = cursor->task().get();
   auto rootTempDir = exec::test::TempDirectoryPath::create();
   auto tmpDirectoryPath = rootTempDir->getPath() + "/spillDirNotCreated";
-  task->setSpillDirectory(tmpDirectoryPath, false);
 
   while (cursor->moveNext()) {
   }
@@ -2150,7 +2220,8 @@ DEBUG_ONLY_TEST_F(TaskTest, resumeAfterTaskFinish) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
 
   // Request pause and then unblock operators to proceed.
@@ -2181,7 +2252,12 @@ DEBUG_ONLY_TEST_F(TaskTest, serialLongRunningOperatorInTaskReclaimerAbort) {
   auto queryCtx = core::QueryCtx::create(driverExecutor_.get());
 
   auto blockingTask = Task::create(
-      "blocking.task.0", plan, 0, queryCtx, Task::ExecutionMode::kSerial);
+      "blocking.task.0",
+      plan,
+      0,
+      queryCtx,
+      Task::ExecutionMode::kSerial,
+      exec::Consumer{});
 
   // Before we block, we expect `next` to get data normally.
   EXPECT_NE(nullptr, blockingTask->next());
@@ -2256,7 +2332,12 @@ DEBUG_ONLY_TEST_F(TaskTest, longRunningOperatorInTaskReclaimerAbort) {
   auto queryCtx = core::QueryCtx::create(driverExecutor_.get());
 
   auto blockingTask = Task::create(
-      "blocking.task.0", plan, 0, queryCtx, Task::ExecutionMode::kParallel);
+      "blocking.task.0",
+      plan,
+      0,
+      queryCtx,
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
 
   blockingTask->start(4, 1);
   const std::string abortErrorMessage("Synthetic Exception");
@@ -2322,7 +2403,8 @@ DEBUG_ONLY_TEST_F(TaskTest, taskReclaimStats) {
       std::move(plan),
       0,
       std::move(queryCtx),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
 
   const int numReclaims{10};
@@ -2396,7 +2478,8 @@ DEBUG_ONLY_TEST_F(TaskTest, taskPauseTime) {
       std::move(plan),
       0,
       std::move(queryCtx),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
 
   // Wait for the task driver starts to run.
@@ -2445,7 +2528,8 @@ TEST_F(TaskTest, updateStatsWhileCloseOffThreadDriver) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
   std::this_thread::sleep_for(std::chrono::milliseconds(100));
   task->testingVisitDrivers(
@@ -2490,7 +2574,8 @@ DEBUG_ONLY_TEST_F(TaskTest, driverEnqueAfterFailedAndPausedTask) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
 
   // Request pause.
@@ -2533,10 +2618,11 @@ DEBUG_ONLY_TEST_F(TaskTest, taskReclaimFailure) {
           .config(core::QueryConfig::kSpillEnabled, true)
           .config(core::QueryConfig::kAggregationSpillEnabled, true)
           .maxDrivers(1)
-          .plan(PlanBuilder()
-                    .values(inputVectors)
-                    .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                    .planNode())
+          .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);
@@ -2561,10 +2647,11 @@ DEBUG_ONLY_TEST_F(TaskTest, taskDeletionPromise) {
   std::thread queryThread([&]() {
     AssertQueryBuilder(duckDbQueryRunner_)
         .maxDrivers(1)
-        .plan(PlanBuilder()
-                  .values(inputVectors)
-                  .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
-                  .planNode())
+        .plan(
+            PlanBuilder()
+                .values(inputVectors)
+                .singleAggregation({"c0", "c1"}, {"array_agg(c2)"})
+                .planNode())
         .assertResults("SELECT c0, c1, array_agg(c2) FROM tmp GROUP BY c0, c1");
   });
 
@@ -2610,7 +2697,8 @@ DEBUG_ONLY_TEST_F(TaskTest, taskCancellation) {
       std::move(plan),
       0,
       core::QueryCtx::create(driverExecutor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(4, 1);
   auto cancellationToken = task->getCancellationToken();
   ASSERT_FALSE(cancellationToken.isCancellationRequested());
@@ -2668,13 +2756,12 @@ TEST_F(TaskTest, invalidPlanNodeForBarrier) {
       makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
   });
 
-  // Filter + Project.
   const auto plan = PlanBuilder()
                         .values({data, data})
                         .filter("c0 < 100")
                         .project({"c0 + 5"})
                         .planFragment();
-  ASSERT_FALSE(plan.supportsBarrier());
+  ASSERT_TRUE(plan.firstNodeNotSupportingBarrier());
 
   const auto task = Task::create(
       "invalidPlanNodeForBarrier",
@@ -2683,7 +2770,12 @@ TEST_F(TaskTest, invalidPlanNodeForBarrier) {
       core::QueryCtx::create(),
       Task::ExecutionMode::kSerial);
   ASSERT_TRUE(!task->underBarrier());
-  VELOX_ASSERT_THROW(task->requestBarrier(), "Task doesn't support barrier");
+  VELOX_ASSERT_THROW(
+      task->requestBarrier(),
+      "Name of the first node that doesn't support barriered execution:");
+  while (auto next = task->next()) {
+  }
+  ASSERT_TRUE(task->isFinished());
 }
 
 TEST_F(TaskTest, barrierAfterNoMoreSplits) {
@@ -2718,6 +2810,9 @@ TEST_F(TaskTest, barrierAfterNoMoreSplits) {
   VELOX_ASSERT_THROW(
       task->requestBarrier(),
       "Can't start barrier on task which has already received no more splits");
+  while (auto next = task->next()) {
+  }
+  ASSERT_TRUE(task->isFinished());
 }
 
 TEST_F(TaskTest, invalidTaskModeForBarrier) {
@@ -2733,7 +2828,7 @@ TEST_F(TaskTest, invalidTaskModeForBarrier) {
                         .filter("c0 < 100")
                         .project({"c0 + 5"})
                         .planFragment();
-  ASSERT_TRUE(plan.supportsBarrier());
+  ASSERT_TRUE(plan.firstNodeNotSupportingBarrier() == nullptr);
 
   const auto task = Task::create(
       "invalidTaskModeForBarrier",
@@ -2742,7 +2837,9 @@ TEST_F(TaskTest, invalidTaskModeForBarrier) {
       core::QueryCtx::create(),
       Task::ExecutionMode::kParallel);
   ASSERT_TRUE(!task->underBarrier());
-  VELOX_ASSERT_THROW(task->requestBarrier(), "Task doesn't support barrier");
+  VELOX_ASSERT_THROW(
+      task->requestBarrier(),
+      "(Parallel vs. Serial) Task doesn't support barriered execution.");
 }
 
 TEST_F(TaskTest, addSplitAfterBarrier) {
@@ -2760,7 +2857,7 @@ TEST_F(TaskTest, addSplitAfterBarrier) {
                         .filter("c0 < 100")
                         .project({"c0 + 5"})
                         .planFragment();
-  ASSERT_TRUE(plan.supportsBarrier());
+  ASSERT_TRUE(plan.firstNodeNotSupportingBarrier() == nullptr);
 
   const auto task = Task::create(
       "barrierAfterNoMoreSplits",
@@ -3144,4 +3241,185 @@ TEST_F(TaskTest, testTerminateDuringBarrierWithUnion) {
   ASSERT_EQ(task->taskStats().numBarriers, 1);
   ASSERT_EQ(task->taskStats().numFinishedSplits, 3);
 }
+
+TEST_F(TaskTest, expressionStatsInBetweenBarriers) {
+  // Verify that expression stats are collected in between barriers and at the
+  // end.
+  // This projection ensures that we verify that inputs of special
+  // form (coalesce) are also included.
+  const std::string projection = "coalesce(c0 + 1, 0)";
+  const int numRows{10};
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>(numRows, [](auto row) { return row; }),
+  });
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), {data});
+
+  core::PlanNodeId scanId;
+  core::PlanNodeId projectNodeId;
+  auto plan = PlanBuilder()
+                  .tableScan(asRowType(data->type()))
+                  .capturePlanNodeId(scanId)
+                  .project({projection})
+                  .capturePlanNodeId(projectNodeId)
+                  .planFragment();
+
+  auto queryCtx = core::QueryCtx::create();
+  queryCtx->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kMaxOutputBatchRows, "10"},
+       {core::QueryConfig::kOperatorTrackExpressionStats, "true"}});
+  const auto task = Task::create(
+      "expressionStatsInBetweenBarriers",
+      plan,
+      0,
+      std::move(queryCtx),
+      Task::ExecutionMode::kSerial);
+  ASSERT_TRUE(!task->underBarrier());
+  task->addSplit(
+      scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+  auto barrierFuture = task->requestBarrier();
+  ASSERT_TRUE(task->underBarrier());
+  RowVectorPtr result;
+  do {
+    ContinueFuture dummyFuture{ContinueFuture::makeEmpty()};
+    result = task->next(&dummyFuture);
+    ASSERT_FALSE(dummyFuture.valid());
+  } while (result != nullptr);
+  auto taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.numBarriers, 1);
+  ASSERT_EQ(taskStats.numFinishedSplits, 1);
+  auto verifyExpressionStats = [nodeId = projectNodeId](
+                                   const TaskStats& taskStats,
+                                   uint64_t expectedNumProcessedRows) {
+    ASSERT_EQ(taskStats.pipelineStats.size(), 1);
+    ASSERT_EQ(taskStats.pipelineStats[0].operatorStats.size(), 2);
+    auto& projectStats = taskStats.pipelineStats[0].operatorStats[1];
+    ASSERT_EQ(projectStats.planNodeId, nodeId);
+    auto& expressionStats = projectStats.expressionStats;
+    // Ensure only the non-special form expression is tracked.
+    ASSERT_EQ(expressionStats.size(), 1);
+    auto it = expressionStats.find("plus");
+    ASSERT_TRUE(it != expressionStats.end());
+    ASSERT_EQ(it->second.numProcessedRows, expectedNumProcessedRows);
+  };
+  verifyExpressionStats(taskStats, 10);
+  ASSERT_TRUE(barrierFuture.isReady());
+  barrierFuture.wait();
+  task->addSplit(
+      scanId, exec::Split(makeHiveConnectorSplit(filePath->getPath())));
+  task->noMoreSplits(scanId);
+  do {
+    result = task->next();
+  } while (result != nullptr);
+  VELOX_CHECK(waitForTaskCompletion(task.get()));
+  taskStats = task->taskStats();
+  ASSERT_EQ(taskStats.numFinishedSplits, 2);
+  verifyExpressionStats(taskStats, 20);
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, taskExecutionEndTime) {
+  std::vector<RowVectorPtr> vectors;
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+  const int numSplits{5};
+  const int numRowsPerSplit{1'000};
+  for (int32_t i = 0; i < numSplits; ++i) {
+    vectors.push_back(makeRowVector(
+        {makeFlatVector<int32_t>(numRowsPerSplit, [](auto row) { return row; }),
+         makeFlatVector<int32_t>(
+             numRowsPerSplit, [](auto row) { return row * 2; })}));
+    tempFiles.push_back(TempFilePath::create());
+  }
+  writeToFiles(toFilePaths(tempFiles), vectors);
+  createDuckDbTable(vectors);
+
+  const int injectedDelaySecs{2};
+  std::atomic_bool injectDelayOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(const velox::exec::Operator*)>(
+          ([&](const velox::exec::Operator* op) {
+            if (op->operatorCtx()->operatorType() == "HashAggregation") {
+              return;
+            }
+            auto task = op->operatorCtx()->task();
+            if (!task->testingAllSplitsFinished()) {
+              return;
+            }
+            if (!injectDelayOnce.exchange(false)) {
+              return;
+            }
+            std::this_thread::sleep_for(
+                std::chrono::seconds(injectedDelaySecs)); // No Lint.
+          })));
+
+  core::PlanNodeId tableScanNodeId;
+  auto plan = test::PlanBuilder()
+                  .tableScan(asRowType(vectors.back()->type()))
+                  .capturePlanNodeId(tableScanNodeId)
+                  .singleAggregation({"c0"}, {"sum(c1)"})
+                  .planNode();
+  auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                  .splits(tableScanNodeId, makeHiveConnectorSplits(tempFiles))
+                  .assertResults("SELECT c0, sum(c1) FROM tmp GROUP BY c0");
+  const auto taskStats = task->taskStats();
+  ASSERT_GE(
+      taskStats.executionEndTimeMs - taskStats.executionStartTimeMs,
+      injectedDelaySecs * 1'000);
+}
+
+DEBUG_ONLY_TEST_F(TaskTest, operatorShouldYieldMethod) {
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  const auto data = makeRowVector({
+      makeFlatVector<int64_t>(3, [](auto row) { return row; }),
+  });
+  const uint64_t kDriverCpuTimeSliceLimitMs = 100;
+
+  struct {
+    bool hasDelay;
+    std::string debugString() const {
+      return fmt::format("hasDelay: {}", hasDelay);
+    }
+  } testSetting[]{{true}, {false}};
+
+  for (const auto& testData : testSetting) {
+    SCOPED_TRACE(testData.debugString());
+    std::atomic<bool> shouldYieldResult{false};
+
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Values::getOutput",
+        std::function<void(const exec::Values*)>(
+            [&](const exec::Values* values) {
+              auto testShouldYieldOp =
+                  std::make_unique<TestShouldYieldOperator>(
+                      0,
+                      values->operatorCtx()->driverCtx(),
+                      ROW({"c0"}, {BIGINT()}),
+                      planNodeIdGenerator->next());
+
+              testShouldYieldOp->addInput(
+                  makeRowVector({makeFlatVector<int64_t>({1})}));
+              if (testData.hasDelay) {
+                std::this_thread::sleep_for(
+                    std::chrono::milliseconds(2 * kDriverCpuTimeSliceLimitMs));
+              }
+
+              // This will test shouldYield() internally
+              testShouldYieldOp->getOutput();
+              shouldYieldResult = testShouldYieldOp->getShouldYieldResult();
+            }));
+
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(),
+        core::QueryConfig({
+            {core::QueryConfig::kDriverCpuTimeSliceLimitMs,
+             folly::to<std::string>(kDriverCpuTimeSliceLimitMs)},
+        }));
+
+    auto plan = PlanBuilder(planNodeIdGenerator).values({data}).planNode();
+    AssertQueryBuilder(plan).queryCtx(queryCtx).copyResults(pool());
+
+    ASSERT_EQ(testData.hasDelay, shouldYieldResult.load());
+  }
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/ThreadDebugInfoTest.cpp b/velox/exec/tests/ThreadDebugInfoTest.cpp
index 75bab5b37593..6bcb1801e145 100644
--- a/velox/exec/tests/ThreadDebugInfoTest.cpp
+++ b/velox/exec/tests/ThreadDebugInfoTest.cpp
@@ -63,6 +63,7 @@ template <typename T>
 struct InduceSegFaultFunction {
   template <typename TResult, typename TInput>
   void call(TResult& out, const TInput& in) {
+    LOG(ERROR) << "error";
     int* nullpointer = nullptr;
     *nullpointer = 6;
   }
@@ -117,9 +118,10 @@ DEBUG_ONLY_TEST_F(ThreadDebugInfoDeathTest, withinTheCallingThread) {
 
 #ifndef IS_BUILDING_WITH_SAN
   ASSERT_DEATH(
-      (task->next()),
+      task->next(),
       ".*Fatal signal handler. Query Id= TaskCursorQuery_0 Task Id= single.execution.task.0.*");
 #endif
+  task->requestCancel();
 }
 
 DEBUG_ONLY_TEST_F(ThreadDebugInfoDeathTest, noThreadContextSet) {
diff --git a/velox/exec/tests/TopNRowNumberTest.cpp b/velox/exec/tests/TopNRowNumberTest.cpp
index fac57658c2c1..7b21a3dee4b5 100644
--- a/velox/exec/tests/TopNRowNumberTest.cpp
+++ b/velox/exec/tests/TopNRowNumberTest.cpp
@@ -29,12 +29,25 @@ namespace {
 
 class TopNRowNumberTest : public OperatorTestBase {
  protected:
-  TopNRowNumberTest() {
+  explicit TopNRowNumberTest(core::TopNRowNumberNode::RankFunction function)
+      : functionName_(core::TopNRowNumberNode::rankFunctionName(function)) {}
+
+  void SetUp() override {
+    exec::test::OperatorTestBase::SetUp();
     filesystems::registerLocalFileSystem();
   }
+
+  const std::string functionName_;
 };
 
-TEST_F(TopNRowNumberTest, basic) {
+class MultiTopNRowNumberTest : public TopNRowNumberTest,
+                               public testing::WithParamInterface<
+                                   core::TopNRowNumberNode::RankFunction> {
+ public:
+  MultiTopNRowNumberTest() : TopNRowNumberTest(GetParam()) {}
+};
+
+TEST_P(MultiTopNRowNumberTest, basic) {
   auto data = makeRowVector({
       // Partitioning key.
       makeFlatVector<int64_t>({1, 1, 2, 2, 1, 2, 1}),
@@ -50,38 +63,41 @@ TEST_F(TopNRowNumberTest, basic) {
     // Emit row numbers.
     auto plan = PlanBuilder()
                     .values({data})
-                    .topNRowNumber({"c0"}, {"c1"}, limit, true)
+                    .topNRank(functionName_, {"c0"}, {"c1"}, limit, true)
                     .planNode();
     assertQuery(
         plan,
         fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (partition by c0 order by c1) as rn FROM tmp) "
+            "SELECT * FROM (SELECT *, {}() over (partition by c0 order by c1) as rn FROM tmp) "
             " WHERE rn <= {}",
+            functionName_,
             limit));
 
     // Do not emit row numbers.
     plan = PlanBuilder()
                .values({data})
-               .topNRowNumber({"c0"}, {"c1"}, limit, false)
+               .topNRank(functionName_, {"c0"}, {"c1"}, limit, false)
                .planNode();
 
     assertQuery(
         plan,
         fmt::format(
-            "SELECT c0, c1, c2 FROM (SELECT *, row_number() over (partition by c0 order by c1) as rn FROM tmp) "
+            "SELECT c0, c1, c2 FROM (SELECT *, {}() over (partition by c0 order by c1) as rn FROM tmp) "
             " WHERE rn <= {}",
+            functionName_,
             limit));
 
     // No partitioning keys.
     plan = PlanBuilder()
                .values({data})
-               .topNRowNumber({}, {"c1"}, limit, true)
+               .topNRank(functionName_, {}, {"c1"}, limit, true)
                .planNode();
     assertQuery(
         plan,
         fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (order by c1) as rn FROM tmp) "
+            "SELECT * FROM (SELECT *, {}() over (order by c1) as rn FROM tmp) "
             " WHERE rn <= {}",
+            functionName_,
             limit));
   };
 
@@ -91,7 +107,7 @@ TEST_F(TopNRowNumberTest, basic) {
   testLimit(5);
 }
 
-TEST_F(TopNRowNumberTest, largeOutput) {
+TEST_P(MultiTopNRowNumberTest, 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.
@@ -119,13 +135,14 @@ TEST_F(TopNRowNumberTest, largeOutput) {
     core::PlanNodeId topNRowNumberId;
     auto plan = PlanBuilder()
                     .values(data)
-                    .topNRowNumber({"p"}, {"s"}, limit, true)
+                    .topNRank(functionName_, {"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) "
+        "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
         " WHERE rn <= {}",
+        functionName_,
         limit);
     AssertQueryBuilder(plan, duckDbQueryRunner_)
         .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
@@ -154,15 +171,17 @@ TEST_F(TopNRowNumberTest, largeOutput) {
     // No partitioning keys.
     plan = PlanBuilder()
                .values(data)
-               .topNRowNumber({}, {"s"}, limit, true)
+               .topNRank(functionName_, {}, {"s"}, limit, true)
                .planNode();
 
     AssertQueryBuilder(plan, duckDbQueryRunner_)
         .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
-        .assertResults(fmt::format(
-            "SELECT * FROM (SELECT *, row_number() over (order by s) as rn FROM tmp) "
-            " WHERE rn <= {}",
-            limit));
+        .assertResults(
+            fmt::format(
+                "SELECT * FROM (SELECT *, {}() over (order by s) as rn FROM tmp) "
+                " WHERE rn <= {}",
+                functionName_,
+                limit));
   };
 
   testLimit(1);
@@ -172,7 +191,7 @@ TEST_F(TopNRowNumberTest, largeOutput) {
   testLimit(2000);
 }
 
-TEST_F(TopNRowNumberTest, manyPartitions) {
+TEST_P(MultiTopNRowNumberTest, manyPartitions) {
   const vector_size_t size = 10'000;
   auto data = split(
       makeRowVector(
@@ -203,13 +222,14 @@ TEST_F(TopNRowNumberTest, manyPartitions) {
     core::PlanNodeId topNRowNumberId;
     auto plan = PlanBuilder()
                     .values(data)
-                    .topNRowNumber({"p"}, {"s"}, limit, true)
+                    .topNRank(functionName_, {"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) "
+        "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
         " WHERE rn <= {}",
+        functionName_,
         limit);
     assertQuery(plan, sql);
 
@@ -243,7 +263,7 @@ TEST_F(TopNRowNumberTest, manyPartitions) {
   testLimit(1, 1);
 }
 
-TEST_F(TopNRowNumberTest, fewPartitions) {
+TEST_P(MultiTopNRowNumberTest, fewPartitions) {
   const vector_size_t size = 10'000;
   auto data = split(
       makeRowVector(
@@ -274,13 +294,14 @@ TEST_F(TopNRowNumberTest, fewPartitions) {
     core::PlanNodeId topNRowNumberId;
     auto plan = PlanBuilder()
                     .values(data)
-                    .topNRowNumber({"p"}, {"s"}, limit, true)
+                    .topNRank(functionName_, {"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) "
+        "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
         " WHERE rn <= {}",
+        functionName_,
         limit);
     assertQuery(plan, sql);
 
@@ -312,7 +333,7 @@ TEST_F(TopNRowNumberTest, fewPartitions) {
   testLimit(100);
 }
 
-TEST_F(TopNRowNumberTest, abandonPartialEarly) {
+TEST_P(MultiTopNRowNumberTest, abandonPartialEarly) {
   auto data = makeRowVector(
       {"p", "s"},
       {
@@ -326,9 +347,9 @@ TEST_F(TopNRowNumberTest, abandonPartialEarly) {
   auto runPlan = [&](int32_t minRows) {
     auto plan = PlanBuilder()
                     .values(split(data, 10))
-                    .topNRowNumber({"p"}, {"s"}, 99, false)
+                    .topNRank(functionName_, {"p"}, {"s"}, 99, false)
                     .capturePlanNodeId(topNRowNumberId)
-                    .topNRowNumber({"p"}, {"s"}, 99, true)
+                    .topNRank(functionName_, {"p"}, {"s"}, 99, true)
                     .planNode();
     auto task =
         AssertQueryBuilder(plan, duckDbQueryRunner_)
@@ -337,8 +358,10 @@ TEST_F(TopNRowNumberTest, abandonPartialEarly) {
                 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");
+                fmt::format(
+                    "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
+                    "WHERE rn <= 99",
+                    functionName_));
 
     return exec::toPlanStats(task->taskStats());
   };
@@ -360,7 +383,7 @@ TEST_F(TopNRowNumberTest, abandonPartialEarly) {
   }
 }
 
-TEST_F(TopNRowNumberTest, planNodeValidation) {
+TEST_P(MultiTopNRowNumberTest, planNodeValidation) {
   auto data = makeRowVector(
       ROW({"a", "b", "c", "d", "e"},
           {
@@ -377,7 +400,7 @@ TEST_F(TopNRowNumberTest, planNodeValidation) {
                   int32_t limit = 10) {
     PlanBuilder()
         .values({data})
-        .topNRowNumber(partitionKeys, sortingKeys, limit, true)
+        .topNRank(functionName_, partitionKeys, sortingKeys, limit, true)
         .planNode();
   };
 
@@ -403,15 +426,16 @@ TEST_F(TopNRowNumberTest, planNodeValidation) {
       plan({"a", "b"}, {"c"}, 0), "Limit must be greater than zero");
 }
 
-TEST_F(TopNRowNumberTest, maxSpillBytes) {
+TEST_P(MultiTopNRowNumberTest, 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)
+                  .topNRank(functionName_, {"c0"}, {"c1"}, 100, true)
                   .planNode();
+
   struct {
     int32_t maxSpilledBytes;
     bool expectedExceedLimit;
@@ -451,7 +475,7 @@ TEST_F(TopNRowNumberTest, maxSpillBytes) {
 
 // This test verifies that TopNRowNumber operator reclaim all the memory after
 // spill.
-DEBUG_ONLY_TEST_F(TopNRowNumberTest, memoryUsageCheckAfterReclaim) {
+DEBUG_ONLY_TEST_P(MultiTopNRowNumberTest, memoryUsageCheckAfterReclaim) {
   std::atomic_int inputCount{0};
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal::addInput",
@@ -496,13 +520,14 @@ DEBUG_ONLY_TEST_F(TopNRowNumberTest, memoryUsageCheckAfterReclaim) {
   core::PlanNodeId topNRowNumberId;
   auto plan = PlanBuilder()
                   .values(data)
-                  .topNRowNumber({"p"}, {"s"}, 1'000, true)
+                  .topNRank(functionName_, {"p"}, {"s"}, 1'000, true)
                   .capturePlanNodeId(topNRowNumberId)
                   .planNode();
 
-  const auto sql =
-      "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
-      " WHERE rn <= 1000";
+  const auto sql = fmt::format(
+      "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
+      " WHERE rn <= 1000",
+      functionName_);
   auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
                   .config(core::QueryConfig::kSpillEnabled, "true")
                   .config(core::QueryConfig::kTopNRowNumberSpillEnabled, "true")
@@ -520,7 +545,7 @@ DEBUG_ONLY_TEST_F(TopNRowNumberTest, memoryUsageCheckAfterReclaim) {
 
 // This test verifies that TopNRowNumber operator can be closed twice which
 // might be triggered by memory pool abort.
-DEBUG_ONLY_TEST_F(TopNRowNumberTest, doubleClose) {
+DEBUG_ONLY_TEST_P(MultiTopNRowNumberTest, doubleClose) {
   const std::string errorMessage("doubleClose");
   SCOPED_TESTVALUE_SET(
       "facebook::velox::exec::Driver::runInternal::noMoreInput",
@@ -556,15 +581,72 @@ DEBUG_ONLY_TEST_F(TopNRowNumberTest, doubleClose) {
   core::PlanNodeId topNRowNumberId;
   auto plan = PlanBuilder()
                   .values(data)
-                  .topNRowNumber({"p"}, {"s"}, 1'000, true)
+                  .topNRank(functionName_, {"p"}, {"s"}, 1'000, true)
                   .capturePlanNodeId(topNRowNumberId)
                   .planNode();
 
-  const auto sql =
-      "SELECT * FROM (SELECT *, row_number() over (partition by p order by s) as rn FROM tmp) "
-      " WHERE rn <= 1000";
+  const auto sql = fmt::format(
+      "SELECT * FROM (SELECT *, {}() over (partition by p order by s) as rn FROM tmp) "
+      " WHERE rn <= 1000",
+      functionName_);
 
   VELOX_ASSERT_THROW(assertQuery(plan, sql), errorMessage);
 }
+
+// This test verifies that TopNRowNumber operator handles OOM that occurs in the
+// middle of groupProbe, after inserting some new rows into the row container.
+DEBUG_ONLY_TEST_P(MultiTopNRowNumberTest, oomInGroupProbe) {
+  const std::string errorMessage("Simulated OOM in groupProbe");
+  std::atomic_int insertCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashTable::insertEntry",
+      std::function<void(memory::MemoryPool*)>(
+          ([&](memory::MemoryPool* /*pool*/) {
+            // Trigger OOM after inserting some rows to simulate failure in the
+            // middle of groupProbe insertion.
+            if (++insertCount == 100) {
+              VELOX_FAIL(errorMessage);
+            }
+          })));
+
+  const vector_size_t size = 10'000;
+  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.
+              makeFlatVector<int64_t>(
+                  size, [](auto row) { return row % 5'000; }, nullEvery(7)),
+          }),
+      10);
+
+  core::PlanNodeId topNRowNumberId;
+  auto plan = PlanBuilder()
+                  .values(data)
+                  .topNRank(functionName_, {"p"}, {"s"}, 1'000, true)
+                  .capturePlanNodeId(topNRowNumberId)
+                  .planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool_.get()), errorMessage);
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TopNRowNumberTest,
+    MultiTopNRowNumberTest,
+    testing::ValuesIn(
+        std::vector<core::TopNRowNumberNode::RankFunction>(
+            {core::TopNRowNumberNode::RankFunction::kRowNumber,
+             core::TopNRowNumberNode::RankFunction::kRank,
+             core::TopNRowNumberNode::RankFunction::kDenseRank})));
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/TraceUtilTest.cpp b/velox/exec/tests/TraceUtilTest.cpp
index 14a62f2159c4..acb94280ba52 100644
--- a/velox/exec/tests/TraceUtilTest.cpp
+++ b/velox/exec/tests/TraceUtilTest.cpp
@@ -139,6 +139,29 @@ TEST_F(TraceUtilTest, traceDirectoryLayoutUtilities) {
       "/traceRoot/queryId/taskId/1/1/1/op_split_trace.split");
 }
 
+TEST_F(TraceUtilTest, traceDirectoryTrailingSlashHandling) {
+  const std::string queryId = "queryId";
+  const std::string taskId = "taskId";
+
+  const std::string expectedPath = "/traceRoot/queryId";
+  const std::string expectedTaskPath = "/traceRoot/queryId/taskId";
+
+  // Test with trailing slash
+  const std::string traceDirWithSlash = "/traceRoot/";
+  ASSERT_EQ(getQueryTraceDirectory(traceDirWithSlash, queryId), expectedPath);
+  ASSERT_EQ(
+      getTaskTraceDirectory(traceDirWithSlash, queryId, taskId),
+      expectedTaskPath);
+
+  // Test without trailing slash
+  const std::string traceDirWithoutSlash = "/traceRoot";
+  ASSERT_EQ(
+      getQueryTraceDirectory(traceDirWithoutSlash, queryId), expectedPath);
+  ASSERT_EQ(
+      getTaskTraceDirectory(traceDirWithoutSlash, queryId, taskId),
+      expectedTaskPath);
+}
+
 TEST_F(TraceUtilTest, getTaskIds) {
   const auto rootDir = TempDirectoryPath::create();
   const auto rootPath = rootDir->getPath();
diff --git a/velox/exec/tests/TreeOfLosersTest.cpp b/velox/exec/tests/TreeOfLosersTest.cpp
index 8e193e40fcd2..0a56a4f49701 100644
--- a/velox/exec/tests/TreeOfLosersTest.cpp
+++ b/velox/exec/tests/TreeOfLosersTest.cpp
@@ -181,8 +181,9 @@ TEST_F(TreeOfLosersTest, allSorted) {
 TEST_F(TreeOfLosersTest, allEmpty) {
   for (bool testNextEqual : {false, true}) {
     for (int numStreams : {0, 1, 5, 100}) {
-      SCOPED_TRACE(fmt::format(
-          "numStreams: {}, testNextEqual", numStreams, testNextEqual));
+      SCOPED_TRACE(
+          fmt::format(
+              "numStreams: {}, testNextEqual", numStreams, testNextEqual));
       std::vector<std::unique_ptr<TestingStream>> mergeStreams;
       for (int i = 0; i < numStreams; ++i) {
         mergeStreams.push_back(
@@ -211,12 +212,13 @@ TEST_F(TreeOfLosersTest, randomWithDuplicates) {
     for (int iter = 0; iter < 10; ++iter) {
       const int numCount = std::max<int>(1, folly::Random::rand32(1000'000));
       const int numStreams = std::max<int>(3, folly::Random::rand32(100));
-      SCOPED_TRACE(fmt::format(
-          "iter: {}, testNextEqual: {}, numCount: {}, numStreams: {}",
-          iter,
-          testNextEqual,
-          numCount,
-          numStreams));
+      SCOPED_TRACE(
+          fmt::format(
+              "iter: {}, testNextEqual: {}, numCount: {}, numStreams: {}",
+              iter,
+              testNextEqual,
+              numCount,
+              numStreams));
       std::vector<std::vector<uint32_t>> streamNumVectors(numStreams);
       for (int i = 0; i < numCount; ++i) {
         const int streamIndex = folly::Random::rand32(numStreams);
diff --git a/velox/exec/tests/UnnestTest.cpp b/velox/exec/tests/UnnestTest.cpp
index a3bc2b20b8f2..7d8e1b7d6b78 100644
--- a/velox/exec/tests/UnnestTest.cpp
+++ b/velox/exec/tests/UnnestTest.cpp
@@ -67,6 +67,160 @@ TEST_P(UnnestTest, basicArray) {
   assertQuery(params, "SELECT c0, UNNEST(c1) FROM tmp WHERE c0 % 7 > 0");
 }
 
+TEST_P(UnnestTest, arrayWithIdentityMap) {
+  struct {
+    int32_t vectorSize;
+    int32_t arraySize;
+    int32_t outputBatchSize;
+    int32_t expectedOutputBatches;
+
+    std::string debugString() const {
+      return fmt::format(
+          "vectorSize: {}, arraySize: {}, outputBatchSize: {}, expectedOutputBatches: {}",
+          vectorSize,
+          arraySize,
+          outputBatchSize,
+          expectedOutputBatches);
+    }
+  } testSettings[] = {
+      {100, 1, 1, 100},
+      {100, 1, 100, 1},
+      {100, 4, 1, 400},
+      {100, 4, 100, 4},
+      {100, 4, 400, 1},
+      {1024, 4, 256, 16},
+      {1024, 4, 1024, 4},
+      {1024, 4, 4096, 1},
+      {1024, 1, 256, 4},
+      {1024, 4, 7, 586},
+      {1024, 1, 7, 147}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto vector = makeRowVector(
+        {makeFlatVector<int64_t>(
+             testData.vectorSize, [](auto row) { return row; }),
+         makeArrayVector<int32_t>(
+             testData.vectorSize,
+             [&](auto /*unused*/) { return testData.arraySize; },
+             [](auto row, auto index) { return index * (row % 3); })});
+    createDuckDbTable({vector});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId unnestPlanNodeId;
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values({vector})
+                    .unnest({"c0"}, {"c1"})
+                    .capturePlanNodeId(unnestPlanNodeId)
+                    .planNode();
+
+    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+                    .config(
+                        core::QueryConfig::kPreferredOutputBatchRows,
+                        std::to_string(testData.outputBatchSize))
+                    .assertResults({"SELECT c0, UNNEST(c1) FROM tmp"});
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(
+        exec::toPlanStats(taskStats).at(unnestPlanNodeId).outputVectors,
+        testData.expectedOutputBatches);
+  }
+}
+
+TEST_P(UnnestTest, arrayWithoutIdentityMap) {
+  struct {
+    int32_t vectorSize;
+    int32_t arraySize1;
+    int32_t arraySize2;
+    int32_t outputBatchSize;
+    int32_t expectedOutputBatches;
+
+    std::string debugString() const {
+      return fmt::format(
+          "vectorSize: {}, arraySize1: {}, arraySize2: {}, outputBatchSize: {}, expectedOutputBatches: {}",
+          vectorSize,
+          arraySize1,
+          arraySize2,
+          outputBatchSize,
+          expectedOutputBatches);
+    }
+  } testSettings[] = {
+      {100, 1, 2, 100, 2},
+      {100, 1, 2, 200, 1},
+      {1024, 1, 4, 256, 16},
+      {1024, 3, 4, 256, 16},
+      {1024, 1, 4, 4096, 1},
+      {1024, 3, 4, 4096, 1},
+      {1024, 1, 4, 7, 586},
+      {1024, 3, 4, 7, 586}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto vector = makeRowVector(
+        {makeFlatVector<int64_t>(
+             testData.vectorSize, [](auto row) { return row; }),
+         makeArrayVector<int32_t>(
+             testData.vectorSize,
+             [&](auto /*unused*/) { return testData.arraySize1; },
+             [](auto row, auto index) { return index * (row % 3); }),
+         makeArrayVector<int32_t>(
+             testData.vectorSize,
+             [&](auto /*unused*/) { return testData.arraySize2; },
+             [](auto row, auto index) { return index * (row % 3); })});
+    createDuckDbTable({vector});
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId unnestPlanNodeId;
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values({vector})
+                    .unnest({"c0"}, {"c1", "c2"})
+                    .capturePlanNodeId(unnestPlanNodeId)
+                    .planNode();
+
+    auto task =
+        AssertQueryBuilder(plan, duckDbQueryRunner_)
+            .config(
+                core::QueryConfig::kPreferredOutputBatchRows,
+                std::to_string(testData.outputBatchSize))
+            .assertResults({"SELECT c0, UNNEST(c1), UNNEST(c2) FROM tmp"});
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(
+        exec::toPlanStats(taskStats).at(unnestPlanNodeId).outputVectors,
+        testData.expectedOutputBatches);
+  }
+}
+
+TEST_P(UnnestTest, arrayWithNull) {
+  const auto vector = makeRowVector(
+      {makeFlatVector<int64_t>(1024, [](auto row) { return row; }),
+       makeArrayVector<int32_t>(
+           1024,
+           [&](auto /*unused*/) { return 3; },
+           [](auto row, auto index) { return index * (row % 3); },
+           nullEvery(6)),
+       makeArrayVector<int32_t>(
+           1024,
+           [&](auto /*unused*/) { return 4; },
+           [](auto row, auto index) { return index * (row % 3); })});
+  createDuckDbTable({vector});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId unnestPlanNodeId;
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({vector})
+                  .unnest({"c0"}, {"c1", "c2"})
+                  .capturePlanNodeId(unnestPlanNodeId)
+                  .planNode();
+
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(
+              core::QueryConfig::kPreferredOutputBatchRows, std::to_string(25))
+          .assertResults({"SELECT c0, UNNEST(c1), UNNEST(c2) FROM tmp"});
+  const auto taskStats = task->taskStats();
+  ASSERT_EQ(
+      exec::toPlanStats(taskStats).at(unnestPlanNodeId).outputVectors, 164);
+}
+
 TEST_P(UnnestTest, arrayWithOrdinality) {
   auto array = vectorMaker_.arrayVectorNullable<int32_t>(
       {{{1, 2, std::nullopt, 4}},
@@ -131,6 +285,119 @@ TEST_P(UnnestTest, arrayWithOrdinality) {
   assertQuery(params, expectedInDict);
 }
 
+TEST_P(UnnestTest, arrayWithMarker) {
+  const auto array = makeArrayVectorFromJson<int32_t>(
+      {"[1, 2, null, 4]", "null", "[5, 6]", "[]", "[null]", "[7, 8, 9]"});
+  const auto input = makeRowVector(
+      {makeNullableFlatVector<double>({1.1, 2.2, 3.3, 4.4, 5.5, std::nullopt}),
+       array});
+
+  const auto expected = makeRowVector(
+      {makeNullableFlatVector<double>(
+           {1.1,
+            1.1,
+            1.1,
+            1.1,
+            3.3,
+            3.3,
+            5.5,
+            std::nullopt,
+            std::nullopt,
+            std::nullopt}),
+       makeNullableFlatVector<int32_t>(
+           {1, 2, std::nullopt, 4, 5, 6, std::nullopt, 7, 8, 9})});
+
+  const auto expectedWithOrdinality = makeRowVector(
+      {expected->childAt(0),
+       expected->childAt(1),
+       makeNullableFlatVector<int64_t>({1, 2, 3, 4, 1, 2, 1, 1, 2, 3})});
+
+  const auto expectedWithMarker = makeRowVector(
+      {makeNullableFlatVector<double>(
+           {1.1,
+            1.1,
+            1.1,
+            1.1,
+            2.2,
+            3.3,
+            3.3,
+            4.4,
+            5.5,
+            std::nullopt,
+            std::nullopt,
+            std::nullopt}),
+       makeNullableFlatVector<int32_t>(
+           {1,
+            2,
+            std::nullopt,
+            4,
+            std::nullopt,
+            5,
+            6,
+            std::nullopt,
+            std::nullopt,
+            7,
+            8,
+            9}),
+       makeNullableFlatVector<bool>(
+           {true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true})});
+  const auto expectedWithBoth = makeRowVector(
+      {expectedWithMarker->childAt(0),
+       expectedWithMarker->childAt(1),
+       makeNullableFlatVector<int64_t>({1, 2, 3, 4, 0, 1, 2, 0, 1, 1, 2, 3}),
+       expectedWithMarker->childAt(2)});
+
+  struct {
+    bool hasOrdinality;
+    bool hasEmptyUnnestValue;
+    RowVectorPtr input;
+    RowVectorPtr expected;
+
+    std::string debugString() const {
+      return fmt::format(
+          "hasOrdinality: {}, hasEmptyUnnestValue: {}, input: {}, expected: {}",
+          hasOrdinality,
+          hasEmptyUnnestValue,
+          input->toString(0, input->size()),
+          expected->toString(0, expected->size()));
+    }
+  } testSettings[] = {
+      {false, false, input, expected},
+      {true, false, input, expectedWithOrdinality},
+      {false, true, input, expectedWithMarker},
+      {true, true, input, expectedWithBoth}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::optional<std::string> ordinalityName;
+    if (testData.hasOrdinality) {
+      ordinalityName = "ordinal";
+    }
+    std::optional<std::string> markerName;
+    if (testData.hasEmptyUnnestValue) {
+      markerName = "emptyUnnestValue";
+    }
+    auto op = PlanBuilder()
+                  .values({testData.input})
+                  .unnest({"c0"}, {"c1"}, ordinalityName, markerName)
+                  .planNode();
+    auto params = makeCursorParameters(op);
+    assertQuery(params, testData.expected);
+  }
+}
+
 TEST_P(UnnestTest, basicMap) {
   auto vector = makeRowVector(
       {makeFlatVector<int64_t>(100, [](auto row) { return row; }),
@@ -199,6 +466,92 @@ TEST_P(UnnestTest, mapWithOrdinality) {
   assertQuery(params, expectedInDict);
 }
 
+TEST_P(UnnestTest, mapWithMarker) {
+  const auto map = makeNullableMapVector<int32_t, double>(
+      {{{{1, 1.1}, {2, std::nullopt}}},
+       common::testutil::optionalEmpty,
+       {{{3, 3.3}, {4, 4.4}, {5, 5.5}}},
+       std::nullopt,
+       {{{6, std::nullopt}}}});
+
+  const auto input =
+      makeRowVector({makeNullableFlatVector<int32_t>({1, 2, 3, 4, 5}), map});
+
+  const auto expected = makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, 1, 3, 3, 3, 5}),
+       makeNullableFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+       makeNullableFlatVector<double>(
+           {1.1, std::nullopt, 3.3, 4.4, 5.5, std::nullopt})});
+
+  const auto expectedWithOrdinality = makeRowVector(
+      {expected->childAt(0),
+       expected->childAt(1),
+       expected->childAt(2),
+       makeNullableFlatVector<int64_t>({1, 2, 1, 2, 3, 1})});
+
+  const auto expectedWithMarker = makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, 1, 2, 3, 3, 3, 4, 5}),
+       makeNullableFlatVector<int32_t>(
+           {1, 2, std::nullopt, 3, 4, 5, std::nullopt, 6}),
+       makeNullableFlatVector<double>(
+           {1.1,
+            std::nullopt,
+            std::nullopt,
+            3.3,
+            4.4,
+            5.5,
+            std::nullopt,
+            std::nullopt}),
+       makeNullableFlatVector<bool>(
+           {true, true, false, true, true, true, false, true})});
+
+  const auto expectedWithBoth = makeRowVector(
+      {expectedWithMarker->childAt(0),
+       expectedWithMarker->childAt(1),
+       expectedWithMarker->childAt(2),
+       makeNullableFlatVector<int64_t>({1, 2, 0, 1, 2, 3, 0, 1}),
+       expectedWithMarker->childAt(3)});
+
+  struct {
+    bool hasOrdinality;
+    bool hasEmptyUnnestValue;
+    RowVectorPtr input;
+    RowVectorPtr expected;
+
+    std::string debugString() const {
+      return fmt::format(
+          "hasOrdinality: {}, hasEmptyUnnestValue: {}, input: {}, expected: {}",
+          hasOrdinality,
+          hasEmptyUnnestValue,
+          input->toString(0, input->size()),
+          expected->toString(0, expected->size()));
+    }
+  } testSettings[] = {
+      {false, false, input, expected},
+      {true, false, input, expectedWithOrdinality},
+      {false, true, input, expectedWithMarker},
+      {true, true, input, expectedWithBoth}};
+
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::optional<std::string> ordinalityName;
+    if (testData.hasOrdinality) {
+      ordinalityName = "ordinal";
+    }
+    std::optional<std::string> markerName;
+    if (testData.hasEmptyUnnestValue) {
+      markerName = "emptyUnnestValue";
+    }
+    auto op = PlanBuilder()
+                  .values({testData.input})
+                  .unnest({"c0"}, {"c1"}, ordinalityName, markerName)
+                  .planNode();
+    auto params = makeCursorParameters(op);
+    assertQuery(params, testData.expected);
+  }
+}
+
 TEST_P(UnnestTest, multipleColumns) {
   std::vector<vector_size_t> offsets(100, 0);
   for (int i = 1; i < 100; ++i) {
@@ -225,8 +578,8 @@ TEST_P(UnnestTest, multipleColumns) {
                 .unnest({"c0"}, {"c1", "c2", "c3"})
                 .planNode();
 
-  // DuckDB doesn't support Unnest from MAP column. Hence,using 2 separate array
-  // columns with the keys and values part of the MAP to validate.
+  // DuckDB doesn't support Unnest from MAP column. Hence,using 2 separate
+  // array columns with the keys and values part of the MAP to validate.
   auto duckDbVector = makeRowVector(
       {makeFlatVector<int64_t>(100, [](auto row) { return row; }),
        makeArrayVector<int64_t>(
@@ -278,8 +631,8 @@ TEST_P(UnnestTest, multipleColumnsWithOrdinality) {
                 .unnest({"c0"}, {"c1", "c2", "c3"}, "ordinal")
                 .planNode();
 
-  // DuckDB doesn't support Unnest from MAP column. Hence,using 2 separate array
-  // columns with the keys and values part of the MAP to validate.
+  // DuckDB doesn't support Unnest from MAP column. Hence,using 2 separate
+  // array columns with the keys and values part of the MAP to validate.
   auto ordinalitySize = [&](auto row) {
     if (row % 42 == 0) {
       return offsets[row + 1] - offsets[row];
@@ -495,15 +848,16 @@ TEST_P(UnnestTest, barrier) {
   // Unnest 1K rows into 3K rows.
   auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
   core::PlanNodeId unnestPlanNodeId;
-  const auto plan = PlanBuilder(planNodeIdGenerator)
-                        .startTableScan()
-                        .outputType(std::dynamic_pointer_cast<const RowType>(
-                            vectors[0]->type()))
-                        .endTableScan()
-                        .project({"sequence(1, 3) as s"})
-                        .unnest({}, {"s"})
-                        .capturePlanNodeId(unnestPlanNodeId)
-                        .planNode();
+  const auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .startTableScan()
+          .outputType(
+              std::dynamic_pointer_cast<const RowType>(vectors[0]->type()))
+          .endTableScan()
+          .project({"sequence(1, 3) as s"})
+          .unnest({}, {"s"})
+          .capturePlanNodeId(unnestPlanNodeId)
+          .planNode();
 
   const auto expectedResult = makeRowVector({
       makeFlatVector<int64_t>(
@@ -527,7 +881,7 @@ TEST_P(UnnestTest, barrier) {
     const int numExpectedOutputVectors =
         bits::divRoundUp(numRowsPerSplit * 3, testData.numOutputRows) *
         numSplits;
-    auto task = AssertQueryBuilder(plan, duckDbQueryRunner_)
+    auto task = AssertQueryBuilder(plan)
                     .config(core::QueryConfig::kSparkPartitionId, "0")
                     .config(
                         core::QueryConfig::kMaxSplitPreloadPerDriver,
@@ -545,18 +899,76 @@ TEST_P(UnnestTest, barrier) {
     ASSERT_EQ(
         exec::toPlanStats(taskStats).at(unnestPlanNodeId).outputRows,
         numSplits * numRowsPerSplit * 3);
-    // NOTE: unnest operator produce the same number of output batches no matter
-    // it is under barrier execution mode or not.
+    // NOTE: unnest operator produce the same number of output batches no
+    // matter it is under barrier execution mode or not.
     ASSERT_EQ(
         exec::toPlanStats(taskStats).at(unnestPlanNodeId).outputVectors,
         numExpectedOutputVectors);
   }
 }
 
+TEST_P(UnnestTest, spiltOutput) {
+  std::vector<RowVectorPtr> vectors;
+  const auto numBatches = 3;
+  const auto inputBatchSize = 256;
+  for (int32_t i = 0; i < 3; ++i) {
+    auto vector = makeRowVector({
+        makeFlatVector<int64_t>(inputBatchSize, [](auto row) { return row; }),
+    });
+    vectors.push_back(vector);
+  }
+  createDuckDbTable(vectors);
+
+  // Unnest 256 rows into 768 rows.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId unnestPlanNodeId;
+  const auto plan = PlanBuilder(planNodeIdGenerator)
+                        .values(vectors)
+                        .project({"sequence(1, 3) as s"})
+                        .unnest({}, {"s"})
+                        .capturePlanNodeId(unnestPlanNodeId)
+                        .planNode();
+
+  const auto expectedResult = makeRowVector({
+      makeFlatVector<int64_t>(
+          numBatches * 3 * inputBatchSize,
+          [](auto row) { return 1 + row % 3; }),
+  });
+
+  struct {
+    bool produceSingleOutput;
+    int expectedNumOutputExectors;
+
+    std::string toString() const {
+      return fmt::format(
+          "produceSingleOutput {}, expectedNumOutputExectors {}",
+          produceSingleOutput,
+          expectedNumOutputExectors);
+    }
+  } testSettings[] = {
+      {true, numBatches},
+      {false, bits::divRoundUp(inputBatchSize * 3, GetParam()) * numBatches}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.toString());
+    auto task = AssertQueryBuilder(plan)
+                    .config(
+                        core::QueryConfig::kPreferredOutputBatchRows,
+                        std::to_string(GetParam()))
+                    .config(
+                        core::QueryConfig::kUnnestSplitOutput,
+                        testData.produceSingleOutput ? "false" : "true")
+                    .assertResults(expectedResult);
+    const auto taskStats = task->taskStats();
+    ASSERT_EQ(
+        exec::toPlanStats(taskStats).at(unnestPlanNodeId).outputVectors,
+        testData.expectedNumOutputExectors);
+  }
+}
+
 VELOX_INSTANTIATE_TEST_SUITE_P(
     UnnestTest,
     UnnestTest,
-    testing::ValuesIn(/*batchSize*/ {2, 17, 33, 1024}),
+    testing::ValuesIn(/*batchSize*/ {2, 17, 33, 512}),
     [](const testing::TestParamInfo<int32_t>& info) {
       return fmt::format("outputBatchSize_{}", info.param);
     });
diff --git a/velox/exec/tests/VectorHasherTest.cpp b/velox/exec/tests/VectorHasherTest.cpp
index 2a3cb8ef9f78..cb3224162f40 100644
--- a/velox/exec/tests/VectorHasherTest.cpp
+++ b/velox/exec/tests/VectorHasherTest.cpp
@@ -462,14 +462,15 @@ TEST_F(VectorHasherTest, stringDistinctOverflow) {
   for (auto i = 0; i < 7; ++i) {
     auto& stringVec = strings[i];
     stringVec.resize(numRows);
-    batches.emplace_back(makeFlatVector<StringView>(
-        numRows, [&i, &stringVec, numRows](vector_size_t row) {
-          const auto num = numRows * i + row;
-          stringVec[row] = (row != 0)
-              ? fmt::format("abcdefghijabcdefghij{}", num)
-              : fmt::format("s{}", num);
-          return StringView(stringVec[row]);
-        }));
+    batches.emplace_back(
+        makeFlatVector<StringView>(
+            numRows, [&i, &stringVec, numRows](vector_size_t row) {
+              const auto num = numRows * i + row;
+              stringVec[row] = (row != 0)
+                  ? fmt::format("abcdefghijabcdefghij{}", num)
+                  : fmt::format("s{}", num);
+              return StringView(stringVec[row]);
+            }));
   }
 
   SelectivityVector rows(numRows, true);
@@ -680,9 +681,9 @@ TEST_F(VectorHasherTest, merge) {
   VectorHasher emptyHasher(BIGINT(), 0);
   VectorHasher otherEmptyHasher(BIGINT(), 0);
   EXPECT_TRUE(emptyHasher.empty());
-  emptyHasher.merge(otherHasher);
-  hasher.merge(emptyHasher);
-  hasher.merge(otherEmptyHasher);
+  emptyHasher.merge(otherHasher, 1'000'000);
+  hasher.merge(emptyHasher, 1'000'000);
+  hasher.merge(otherEmptyHasher, 1'000'000);
   uint64_t numRange;
   uint64_t numDistinct;
   hasher.cardinality(0, numRange, numDistinct);
@@ -720,6 +721,45 @@ TEST_F(VectorHasherTest, merge) {
   EXPECT_EQ(numDistinct - 1, ids.size());
 }
 
+TEST_F(VectorHasherTest, mergeMaxNumDistinct) {
+  constexpr vector_size_t kSize = 100;
+  SelectivityVector rows(kSize);
+  raw_vector<uint64_t> hashes(kSize);
+
+  auto vector1 =
+      makeFlatVector<int64_t>(kSize, [](vector_size_t row) { return row; });
+  auto vector2 = makeFlatVector<int64_t>(
+      kSize, [](vector_size_t row) { return 1000 + row; });
+  auto vector3 = makeFlatVector<int64_t>(
+      kSize, [](vector_size_t row) { return 2000 + row; });
+
+  VectorHasher hasher1(BIGINT(), 0);
+  hasher1.decode(*vector1, rows);
+  hasher1.computeValueIds(rows, hashes);
+
+  VectorHasher hasher2(BIGINT(), 0);
+  hasher2.decode(*vector2, rows);
+  hasher2.computeValueIds(rows, hashes);
+
+  VectorHasher hasher3(BIGINT(), 0);
+  hasher3.decode(*vector3, rows);
+  hasher3.computeValueIds(rows, hashes);
+
+  hasher1.merge(hasher2, kSize * 2);
+  uint64_t numRange;
+  uint64_t numDistinct;
+  hasher1.cardinality(0, numRange, numDistinct);
+  EXPECT_EQ(numDistinct, kSize * 2 + 1);
+
+  hasher1.merge(hasher3, kSize * 2);
+  hasher1.cardinality(0, numRange, numDistinct);
+  EXPECT_EQ(numDistinct, VectorHasher::kRangeTooLarge);
+
+  hasher1.merge(hasher3, kSize * 10);
+  hasher1.cardinality(0, numRange, numDistinct);
+  EXPECT_EQ(numDistinct, VectorHasher::kRangeTooLarge);
+}
+
 TEST_F(VectorHasherTest, computeValueIdsBigint) {
   testComputeValueIds<int64_t>(false);
   testComputeValueIds<int64_t>(true);
@@ -1197,3 +1237,84 @@ TEST_F(VectorHasherTest, customComparisonRow) {
               {std::nullopt, 0, 1, 0, 1, 0, 1},
               velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON())}));
 }
+
+TEST_F(VectorHasherTest, customComparisonValueIds) {
+  // Test that VectorHasher created with custom comparison type
+  // has value IDs disabled (distinctOverflow_ and rangeOverflow_ set).
+  auto vectorHasher = exec::VectorHasher::create(
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON(), 1);
+
+  // Test that types with custom comparison do not support value IDs.
+  EXPECT_FALSE(vectorHasher->typeSupportsValueIds());
+
+  // Verify that mayUseValueIds() returns false for custom comparison types.
+  EXPECT_FALSE(vectorHasher->mayUseValueIds());
+}
+
+DEBUG_ONLY_TEST_F(VectorHasherTest, customComparisonNoValueIds) {
+  // Test that custom comparison types cannot use value IDs for optimization.
+  auto data = makeRowVector({makeNullableFlatVector<int64_t>(
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON())});
+
+  auto hasher = exec::VectorHasher::create(
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON(), 0);
+
+  SelectivityVector allRows(data->size());
+  raw_vector<uint64_t> result(data->size());
+  std::fill(result.begin(), result.end(), 0);
+
+  hasher->decode(*data->childAt(0), allRows);
+
+  VELOX_ASSERT_THROW(
+      hasher->computeValueIds(allRows, result), "Value IDs cannot be used");
+  VectorHasher::ScratchMemory scratchMemory;
+  VELOX_ASSERT_THROW(
+      hasher->lookupValueIds(*data->childAt(0), allRows, scratchMemory, result),
+      "Value IDs cannot be used");
+  EXPECT_EQ(nullptr, hasher->getFilter(true));
+  VELOX_ASSERT_THROW(
+      hasher->enableValueRange(1, 50), "Value IDs cannot be used");
+  VELOX_ASSERT_THROW(
+      hasher->enableValueRange(1, 50), "Value IDs cannot be used");
+}
+
+DEBUG_ONLY_TEST_F(VectorHasherTest, computeValueIdsForRowsCustomComparison) {
+  // Test that computeValueIdsForRows throws an exception for types with custom
+  // comparison.
+  auto hasher = exec::VectorHasher::create(
+      velox::test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON(), 0);
+
+  constexpr int32_t kNumGroups = 5;
+  constexpr int32_t kRowSize = 16;
+  constexpr int32_t kValueOffset = 0;
+  constexpr int32_t kNullByte = 8;
+  constexpr uint8_t kNullMask = 1;
+
+  // Allocate memory for row-wise data.
+  std::vector<std::vector<char>> rowData(kNumGroups);
+  std::vector<char*> groups(kNumGroups);
+
+  for (int i = 0; i < kNumGroups; ++i) {
+    rowData[i].resize(kRowSize, 0);
+    groups[i] = rowData[i].data();
+
+    // Set values for all rows (no nulls for simplicity).
+    *reinterpret_cast<int64_t*>(groups[i] + kValueOffset) = i * 256;
+  }
+
+  raw_vector<uint64_t> result(kNumGroups);
+  std::fill(result.begin(), result.end(), 0);
+
+  // computeValueIdsForRows should throw an exception for types with custom
+  // comparison.
+  VELOX_ASSERT_THROW(
+      hasher->computeValueIdsForRows(
+          groups.data(),
+          kNumGroups,
+          kValueOffset,
+          kNullByte,
+          kNullMask,
+          result),
+      "Value IDs cannot be used");
+}
diff --git a/velox/exec/tests/VeloxIn10MinDemo.cpp b/velox/exec/tests/VeloxIn10MinDemo.cpp
index 87d571a1788c..e1c6ec5d5504 100644
--- a/velox/exec/tests/VeloxIn10MinDemo.cpp
+++ b/velox/exec/tests/VeloxIn10MinDemo.cpp
@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 #include <folly/init/Init.h>
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/memory/Memory.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/connectors/tpch/TpchConnectorSplit.h"
-#include "velox/core/Expressions.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/expression/Expr.h"
@@ -47,25 +47,17 @@ class VeloxIn10MinDemo : public VectorTestBase {
     // Register type resolver with DuckDB SQL parser.
     parse::registerTypeResolver();
 
-    // Register the TPC-H Connector Factory.
-    connector::registerConnectorFactory(
-        std::make_shared<connector::tpch::TpchConnectorFactory>());
-
     // Create and register a TPC-H connector.
-    auto tpchConnector =
-        connector::getConnectorFactory(
-            connector::tpch::TpchConnectorFactory::kTpchConnectorName)
-            ->newConnector(
-                kTpchConnectorId,
-                std::make_shared<config::ConfigBase>(
-                    std::unordered_map<std::string, std::string>()));
+    connector::tpch::TpchConnectorFactory factory;
+    auto tpchConnector = factory.newConnector(
+        kTpchConnectorId,
+        std::make_shared<config::ConfigBase>(
+            std::unordered_map<std::string, std::string>()));
     connector::registerConnector(tpchConnector);
   }
 
   ~VeloxIn10MinDemo() {
     connector::unregisterConnector(kTpchConnectorId);
-    connector::unregisterConnectorFactory(
-        connector::tpch::TpchConnectorFactory::kTpchConnectorName);
   }
 
   /// Parse SQL expression into a typed expression tree using DuckDB SQL parser.
@@ -99,8 +91,9 @@ class VeloxIn10MinDemo : public VectorTestBase {
 
   /// Make TPC-H split to add to TableScan node.
   exec::Split makeTpchSplit() const {
-    return exec::Split(std::make_shared<connector::tpch::TpchConnectorSplit>(
-        kTpchConnectorId, /*cacheable=*/true, 1, 0));
+    return exec::Split(
+        std::make_shared<connector::tpch::TpchConnectorSplit>(
+            kTpchConnectorId, /*cacheable=*/true, 1, 0));
   }
 
   /// Run the demo.
@@ -108,7 +101,7 @@ class VeloxIn10MinDemo : public VectorTestBase {
 
   std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::hardware_concurrency())};
   std::shared_ptr<core::QueryCtx> queryCtx_{
       core::QueryCtx::create(executor_.get())};
   std::unique_ptr<core::ExecCtx> execCtx_{
diff --git a/velox/exec/tests/WindowTest.cpp b/velox/exec/tests/WindowTest.cpp
index c2e84f9b0f32..0c1be2f231c7 100644
--- a/velox/exec/tests/WindowTest.cpp
+++ b/velox/exec/tests/WindowTest.cpp
@@ -13,9 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/exec/Window.h"
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/exec/OrderBy.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/RowsStreamingWindowBuild.h"
 #include "velox/exec/SortWindowBuild.h"
@@ -61,12 +64,13 @@ class WindowTest : public OperatorTestBase {
         0,
         0,
         "none",
+        0,
         prefixSortConfig);
   }
 
   const std::shared_ptr<folly::Executor> executor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::hardware_concurrency())};
 
   tsan_atomic<bool> nonReclaimableSection_{false};
 };
@@ -113,6 +117,112 @@ TEST_F(WindowTest, spill) {
   ASSERT_GT(stats.spilledPartitions, 0);
 }
 
+TEST_F(WindowTest, spillBatchReadTinyPartitions) {
+  const vector_size_t size = 1'000;
+  const uint32_t minReadBatchRows = 100;
+  // Each tiny partition has 1 row.
+  const uint32_t partitionRows = 1;
+  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 / partitionRows; }),
+          // 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")
+          .config(
+              core::QueryConfig::kWindowSpillMinReadBatchRows, minReadBatchRows)
+          .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);
+  ASSERT_EQ(
+      stats.operatorStats.at("Window")
+          ->customStats[Window::kWindowSpillReadNumBatches]
+          .sum,
+      size / minReadBatchRows);
+}
+
+TEST_F(WindowTest, spillBatchReadHugePartitions) {
+  const vector_size_t size = 1'000;
+  const uint32_t minReadBatchRows = 100;
+  // Each huge partition has 200 rows, which is larger than minReadBatchRows.
+  const uint32_t partitionRows = 200;
+  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 / partitionRows; }),
+          // 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")
+          .config(
+              core::QueryConfig::kWindowSpillMinReadBatchRows, minReadBatchRows)
+          .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);
+  ASSERT_EQ(
+      stats.operatorStats.at("Window")
+          ->customStats[Window::kWindowSpillReadNumBatches]
+          .sum,
+      size / partitionRows);
+}
+
 TEST_F(WindowTest, spillUnsupported) {
   const vector_size_t size = 1'000;
   auto data = makeRowVector(
@@ -178,10 +288,11 @@ TEST_F(WindowTest, rowBasedStreamingWindowOOM) {
   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()));
+  queryCtx->testingOverrideMemoryPool(
+      memory::memoryManager()->addRootPool(
+          queryCtx->queryId(),
+          8'388'608 /* 8MB */,
+          exec::MemoryReclaimer::create()));
 
   params.queryCtx = queryCtx;
 
@@ -323,6 +434,122 @@ DEBUG_ONLY_TEST_F(WindowTest, valuesRowsStreamingWindowBuild) {
   ASSERT_TRUE(isStreamCreated.load());
 }
 
+TEST_F(WindowTest, prePartitionedSortBuild) {
+  const vector_size_t size = 1'000;
+  const int numPartitions = 37;
+  const int numSubPartitions = 4;
+  auto data = makeRowVector(
+      {"p", "s"},
+      {
+          // Partition key.
+          makeFlatVector<int16_t>(
+              size, [](auto row) { return row % numPartitions; }),
+          // 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 desc)"})
+          .capturePlanNodeId(windowId)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(
+          core::QueryConfig::kWindowNumSubPartitions,
+          std::to_string(numSubPartitions))
+      .assertResults(
+          "SELECT *, row_number() over (partition by p order by s desc) FROM tmp ORDER BY s");
+}
+
+TEST_F(WindowTest, prePartitionedSortBuildSkewed) {
+  const vector_size_t size = 1'000;
+  const int numPartitions = 4;
+  const int numSubPartitions = 16;
+  auto data = makeRowVector(
+      {"p", "s"},
+      {
+          // Partition key.
+          makeFlatVector<int16_t>(
+              size, [](auto row) { return row % numPartitions; }),
+          // 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 desc)"})
+          .capturePlanNodeId(windowId)
+          .planNode();
+
+  AssertQueryBuilder(plan, duckDbQueryRunner_)
+      .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+      .config(
+          core::QueryConfig::kWindowNumSubPartitions,
+          std::to_string(numSubPartitions))
+      .assertResults(
+          "SELECT *, row_number() over (partition by p order by s desc) FROM tmp ORDER BY s");
+}
+
+TEST_F(WindowTest, prePartitionedBuildWithSpill) {
+  const vector_size_t size = 1'000;
+  const int numPartitions = 37;
+  const int numSubPartitions = 4;
+  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 % numPartitions; }),
+          // 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 desc)"})
+          .capturePlanNodeId(windowId)
+          .planNode();
+
+  auto spillDirectory = TempDirectoryPath::create();
+  TestScopedSpillInjection scopedSpillInjection(100);
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+          .config(
+              core::QueryConfig::kWindowNumSubPartitions,
+              std::to_string(numSubPartitions))
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(core::QueryConfig::kWindowSpillEnabled, "true")
+          .config(core::QueryConfig::kOrderBySpillEnabled, "false")
+          .spillDirectory(spillDirectory->getPath())
+          .assertResults(
+              "SELECT *, row_number() over (partition by p order by s desc) FROM tmp ORDER BY s");
+
+  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);
+}
+
 DEBUG_ONLY_TEST_F(WindowTest, aggregationWithNonDefaultFrame) {
   const vector_size_t size = 1'00;
 
@@ -436,9 +663,8 @@ TEST_F(WindowTest, missingFunctionSignature) {
 
   auto callExpr = std::make_shared<core::CallTypedExpr>(
       BIGINT(),
-      std::vector<core::TypedExprPtr>{
-          std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1")},
-      "sum");
+      "sum",
+      std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c1"));
 
   VELOX_ASSERT_THROW(
       runWindow(callExpr),
@@ -446,9 +672,8 @@ TEST_F(WindowTest, missingFunctionSignature) {
 
   callExpr = std::make_shared<core::CallTypedExpr>(
       VARCHAR(),
-      std::vector<core::TypedExprPtr>{
-          std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c2")},
-      "sum");
+      "sum",
+      std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c2"));
 
   VELOX_ASSERT_THROW(
       runWindow(callExpr),
@@ -552,10 +777,11 @@ TEST_F(WindowTest, nagativeFrameArg) {
             .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)),
+            .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());
   }
 }
@@ -645,11 +871,12 @@ DEBUG_ONLY_TEST_F(WindowTest, reserveMemorySort) {
 
   for (const auto [usePrefixSort, spillEnabled, enableSpillPrefixSort] :
        testSettings) {
-    SCOPED_TRACE(fmt::format(
-        "usePrefixSort: {}, spillEnabled: {}, enableSpillPrefixSort: {}",
-        usePrefixSort,
-        spillEnabled,
-        enableSpillPrefixSort));
+    SCOPED_TRACE(
+        fmt::format(
+            "usePrefixSort: {}, spillEnabled: {}, enableSpillPrefixSort: {}",
+            usePrefixSort,
+            spillEnabled,
+            enableSpillPrefixSort));
     auto spillDirectory = exec::test::TempDirectoryPath::create();
     auto spillConfig =
         getSpillConfig(spillDirectory->getPath(), enableSpillPrefixSort);
@@ -658,12 +885,14 @@ DEBUG_ONLY_TEST_F(WindowTest, reserveMemorySort) {
     velox::common::PrefixSortConfig prefixSortConfig =
         velox::common::PrefixSortConfig{
             std::numeric_limits<int32_t>::max(), 130, 12};
+    folly::Synchronized<OperatorStats> opStats;
     auto sortWindowBuild = std::make_unique<SortWindowBuild>(
         plan,
         pool_.get(),
         std::move(prefixSortConfig),
         spillEnabled ? &spillConfig : nullptr,
         &nonReclaimableSection_,
+        &opStats,
         &spillStats);
 
     TestScopedSpillInjection scopedSpillInjection(0);
@@ -713,18 +942,20 @@ TEST_F(WindowTest, NaNFrameBound) {
           if (startBound == "following" && endBound == "preceding") {
             continue;
           }
-          frames.push_back(fmt::format(
-              "{} over (order by s0 {} range between off0 {} and off1 {})",
-              call,
-              order,
-              startBound,
-              endBound));
-          frames.push_back(fmt::format(
-              "{} over (order by s0 {} range between off1 {} and off0 {})",
-              call,
-              order,
-              startBound,
-              endBound));
+          frames.push_back(
+              fmt::format(
+                  "{} over (order by s0 {} range between off0 {} and off1 {})",
+                  call,
+                  order,
+                  startBound,
+                  endBound));
+          frames.push_back(
+              fmt::format(
+                  "{} over (order by s0 {} range between off1 {} and off0 {})",
+                  call,
+                  order,
+                  startBound,
+                  endBound));
         }
       }
     }
@@ -749,5 +980,63 @@ TEST_F(WindowTest, NaNFrameBound) {
   }
 }
 
+DEBUG_ONLY_TEST_F(WindowTest, releaseWindowBuildInTime) {
+  const vector_size_t size = 1'000;
+  auto data = makeRowVector(
+      {"d", "p0", "s"},
+      {
+          // Payload Data.
+          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;
+  core::PlanNodeId orderById;
+  auto plan = PlanBuilder()
+                  .values(split(data, 10))
+                  .window({"row_number() over (partition by p0 order by s)"})
+                  .capturePlanNodeId(windowId)
+                  .orderBy({"d"}, false)
+                  .capturePlanNodeId(orderById)
+                  .planNode();
+
+  std::atomic<memory::MemoryPool*> windowPool{nullptr};
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](exec::Operator* op) {
+        auto* windowOp = dynamic_cast<exec::Window*>(op);
+        if (windowOp == nullptr || windowPool != nullptr) {
+          return;
+        }
+        windowPool = windowOp->pool();
+      }));
+
+  std::atomic_bool checkOnce{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>([&](exec::Operator* op) {
+        if (dynamic_cast<exec::OrderBy*>(op) == nullptr ||
+            checkOnce.exchange(true)) {
+          return;
+        }
+        ASSERT_LT(
+            windowPool.load()->usedBytes(), windowPool.load()->peakBytes() / 3);
+      }));
+
+  auto task =
+      AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .config(core::QueryConfig::kPreferredOutputBatchBytes, "1024")
+          .assertResults(
+              "SELECT *, row_number() over (partition by p0 order by s) "
+              "FROM tmp "
+              "ORDER BY d");
+}
+
 } // namespace
 } // namespace facebook::velox::exec
diff --git a/velox/exec/tests/data/decimal.orc b/velox/exec/tests/data/decimal.orc
new file mode 100644
index 000000000000..b89662b65f68
Binary files /dev/null and b/velox/exec/tests/data/decimal.orc differ
diff --git a/velox/exec/tests/utils/AggregationResolver.cpp b/velox/exec/tests/utils/AggregationResolver.cpp
new file mode 100644
index 000000000000..44cc0058b143
--- /dev/null
+++ b/velox/exec/tests/utils/AggregationResolver.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/AggregationResolver.h"
+
+#include "velox/exec/Aggregate.h"
+#include "velox/expression/FunctionCallToSpecialForm.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+std::string throwAggregateFunctionDoesntExist(const std::string& name) {
+  std::stringstream error;
+  error << "Aggregate function doesn't exist: " << name << ".";
+  exec::aggregateFunctions().withRLock([&](const auto& functionsMap) {
+    if (functionsMap.empty()) {
+      error << " Registry of aggregate functions is empty. "
+               "Make sure to register some aggregate functions.";
+    }
+  });
+  VELOX_USER_FAIL(error.str());
+}
+
+std::string throwAggregateFunctionSignatureNotSupported(
+    const std::string& name,
+    const std::vector<TypePtr>& types,
+    const std::vector<std::shared_ptr<AggregateFunctionSignature>>&
+        signatures) {
+  std::stringstream error;
+  error << "Aggregate function signature is not supported: "
+        << toString(name, types)
+        << ". Supported signatures: " << toString(signatures) << ".";
+  VELOX_USER_FAIL(error.str());
+}
+} // namespace
+
+TypePtr resolveAggregateType(
+    const std::string& aggregateName,
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& rawInputTypes,
+    bool nullOnFailure) {
+  if (auto signatures = exec::getAggregateFunctionSignatures(aggregateName)) {
+    for (const auto& signature : signatures.value()) {
+      exec::SignatureBinder binder(*signature, rawInputTypes);
+      if (binder.tryBind()) {
+        return binder.tryResolveType(
+            exec::isPartialOutput(step) ? signature->intermediateType()
+                                        : signature->returnType());
+      }
+    }
+
+    if (nullOnFailure) {
+      return nullptr;
+    }
+
+    throwAggregateFunctionSignatureNotSupported(
+        aggregateName, rawInputTypes, signatures.value());
+  }
+
+  // We may be parsing lambda expression used in a lambda aggregate function. In
+  // this case, 'aggregateName' would refer to a scalar function.
+  //
+  // TODO Enhance the parser to allow for specifying separate resolver for
+  // lambda expressions.
+  if (auto type =
+          exec::resolveTypeForSpecialForm(aggregateName, rawInputTypes)) {
+    return type;
+  }
+
+  if (auto type = parse::resolveScalarFunctionType(
+          aggregateName, rawInputTypes, true)) {
+    return type;
+  }
+
+  if (nullOnFailure) {
+    return nullptr;
+  }
+
+  throwAggregateFunctionDoesntExist(aggregateName);
+  return nullptr;
+}
+
+AggregateTypeResolver::AggregateTypeResolver(core::AggregationNode::Step step)
+    : step_(step), previousHook_(core::Expressions::getResolverHook()) {
+  core::Expressions::setTypeResolverHook(
+      [&](const auto& inputs, const auto& expr, bool nullOnFailure) {
+        return resolveType(inputs, expr, nullOnFailure);
+      });
+}
+
+AggregateTypeResolver::~AggregateTypeResolver() {
+  core::Expressions::setTypeResolverHook(previousHook_);
+}
+
+TypePtr AggregateTypeResolver::resolveType(
+    const std::vector<core::TypedExprPtr>& inputs,
+    const std::shared_ptr<const core::CallExpr>& expr,
+    bool nullOnFailure) const {
+  auto functionName = expr->name();
+
+  // Use raw input types (if available) to resolve intermediate and final
+  // result types.
+  if (exec::isRawInput(step_)) {
+    std::vector<TypePtr> types;
+    for (auto& input : inputs) {
+      types.push_back(input->type());
+    }
+
+    return resolveAggregateType(functionName, step_, types, nullOnFailure);
+  }
+
+  if (!rawInputTypes_.empty()) {
+    return resolveAggregateType(
+        functionName, step_, rawInputTypes_, nullOnFailure);
+  }
+
+  if (!nullOnFailure) {
+    VELOX_USER_FAIL(
+        "Cannot resolve aggregation function return type without raw input types: {}",
+        functionName);
+  }
+  return nullptr;
+}
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/AggregationResolver.h b/velox/exec/tests/utils/AggregationResolver.h
new file mode 100644
index 000000000000..65cefb6620c6
--- /dev/null
+++ b/velox/exec/tests/utils/AggregationResolver.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/core/ITypedExpr.h"
+#include "velox/core/PlanNode.h"
+#include "velox/parse/Expressions.h"
+#include "velox/parse/TypeResolver.h"
+
+namespace facebook::velox::exec::test {
+class AggregateTypeResolver {
+ public:
+  explicit AggregateTypeResolver(core::AggregationNode::Step step);
+
+  ~AggregateTypeResolver();
+
+  void setRawInputTypes(const std::vector<TypePtr>& types) {
+    rawInputTypes_ = types;
+  }
+
+ private:
+  TypePtr resolveType(
+      const std::vector<core::TypedExprPtr>& inputs,
+      const std::shared_ptr<const core::CallExpr>& expr,
+      bool nullOnFailure) const;
+
+  const core::AggregationNode::Step step_;
+  const core::Expressions::TypeResolverHook previousHook_;
+  std::vector<TypePtr> rawInputTypes_;
+};
+
+/// Resolves the output type for an aggregate function given its name,
+/// aggregation step, and input types.
+///
+/// The resolution process follows these steps:
+/// 1. Looks up registered aggregate function signatures by name
+/// 2. Attempts to bind the provided raw input types to available signatures
+/// 3. Returns the appropriate output type based on the aggregation step:
+///    - For partial steps (kPartial, kIntermediate): returns intermediate type
+///    - For final steps (kSingle, kFinal): returns the final result type
+/// 4. Falls back to scalar function or special form resolution if aggregate
+///    function lookup fails (useful for lambda expressions in aggregates)
+///
+/// @param aggregateName The name of the aggregate function (e.g., "sum",
+/// "count", "avg")
+/// @param step The aggregation step indicating the stage in multi-phase
+/// aggregation
+/// @param rawInputTypes The types of the raw input arguments to the aggregate
+/// function
+/// @param nullOnFailure If true, returns nullptr when type resolution fails;
+///                      if false, throws an exception on failure
+/// @return The resolved output type for the aggregate function, or nullptr if
+///         nullOnFailure is true and resolution fails
+/// @throws VeloxUserError if type resolution fails and nullOnFailure is false
+TypePtr resolveAggregateType(
+    const std::string& aggregateName,
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& rawInputTypes,
+    bool nullOnFailure);
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/ArbitratorTestUtil.cpp b/velox/exec/tests/utils/ArbitratorTestUtil.cpp
index 8c3bb9dc8ace..5499898d0666 100644
--- a/velox/exec/tests/utils/ArbitratorTestUtil.cpp
+++ b/velox/exec/tests/utils/ArbitratorTestUtil.cpp
@@ -19,9 +19,6 @@
 #include "velox/dwio/dwrf/common/Config.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 {
@@ -31,18 +28,11 @@ std::shared_ptr<core::QueryCtx> newQueryCtx(
     folly::Executor* executor,
     int64_t memoryCapacity,
     const std::string& queryId) {
-  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),
-      nullptr,
-      queryId);
-  return queryCtx;
+  return core::QueryCtx::Builder()
+      .executor(executor)
+      .pool(memoryManager->addRootPool("", memoryCapacity))
+      .queryId(queryId)
+      .build();
 }
 
 std::unique_ptr<memory::MemoryManager> createMemoryManager(
diff --git a/velox/exec/tests/utils/ArbitratorTestUtil.h b/velox/exec/tests/utils/ArbitratorTestUtil.h
index 8021db656081..6260c78883ed 100644
--- a/velox/exec/tests/utils/ArbitratorTestUtil.h
+++ b/velox/exec/tests/utils/ArbitratorTestUtil.h
@@ -112,7 +112,7 @@ std::shared_ptr<core::QueryCtx> newQueryCtx(
 std::unique_ptr<memory::MemoryManager> createMemoryManager(
     int64_t arbitratorCapacity = kMemoryCapacity,
     uint64_t memoryPoolInitCapacity = kMemoryPoolInitCapacity,
-    uint64_t maxReclaimWaitMs = 5 * 60 * 1'000,
+    uint64_t maxReclaimWaitMs = 60 * 1'000,
     uint64_t fastExponentialGrowthCapacityLimit = 0,
     double slowCapacityGrowPct = 0);
 
diff --git a/velox/exec/tests/utils/AssertQueryBuilder.cpp b/velox/exec/tests/utils/AssertQueryBuilder.cpp
index 1b68b77cf717..26008449aedb 100644
--- a/velox/exec/tests/utils/AssertQueryBuilder.cpp
+++ b/velox/exec/tests/utils/AssertQueryBuilder.cpp
@@ -266,7 +266,26 @@ RowVectorPtr AssertQueryBuilder::copyResults(
   return copy;
 }
 
-uint64_t AssertQueryBuilder::runWithoutResults(std::shared_ptr<Task>& task) {
+std::vector<RowVectorPtr> AssertQueryBuilder::copyResultBatches(
+    memory::MemoryPool* pool) {
+  auto [cursor, results] = readCursor();
+
+  if (results.empty()) {
+    return results;
+  }
+
+  std::vector<RowVectorPtr> copies;
+  copies.reserve(results.size());
+  for (const auto& result : results) {
+    copies.push_back(
+        BaseVector::create<RowVector>(result->type(), result->size(), pool));
+    copies.back()->copy(result.get(), 0, 0, result->size());
+  }
+
+  return copies;
+}
+
+uint64_t AssertQueryBuilder::countResults(std::shared_ptr<Task>& task) {
   auto [cursor, results] = readCursor();
   uint64_t count = 0;
   for (const auto& result : results) {
@@ -276,6 +295,11 @@ uint64_t AssertQueryBuilder::runWithoutResults(std::shared_ptr<Task>& task) {
   return count;
 }
 
+uint64_t AssertQueryBuilder::countResults() {
+  std::shared_ptr<Task> task;
+  return countResults(task);
+}
+
 std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
 AssertQueryBuilder::readCursor() {
   VELOX_CHECK_NOT_NULL(params_.planNode);
@@ -287,17 +311,14 @@ AssertQueryBuilder::readCursor() {
       static std::atomic<uint64_t> cursorQueryId{0};
       const std::string queryId =
           fmt::format("TaskCursorQuery_{}", cursorQueryId++);
-      auto queryPool = memory::memoryManager()->addRootPool(
-          queryId, params_.maxQueryCapacity);
-      params_.queryCtx = core::QueryCtx::create(
-          executor_.get(),
-          core::QueryConfig({}),
-          std::
-              unordered_map<std::string, std::shared_ptr<config::ConfigBase>>{},
-          cache::AsyncDataCache::getInstance(),
-          std::move(queryPool),
-          nullptr,
-          queryId);
+
+      params_.queryCtx = core::QueryCtx::Builder()
+                             .executor(executor_.get())
+                             .pool(
+                                 memory::memoryManager()->addRootPool(
+                                     queryId, params_.maxQueryCapacity))
+                             .queryId(queryId)
+                             .build();
     }
   }
   if (!configs_.empty()) {
diff --git a/velox/exec/tests/utils/AssertQueryBuilder.h b/velox/exec/tests/utils/AssertQueryBuilder.h
index 8e9f15d9831b..127d142f1168 100644
--- a/velox/exec/tests/utils/AssertQueryBuilder.h
+++ b/velox/exec/tests/utils/AssertQueryBuilder.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <folly/system/HardwareConcurrency.h>
 #include "velox/exec/tests/utils/QueryAssertions.h"
 
 namespace facebook::velox::exec::test {
@@ -182,8 +183,7 @@ class AssertQueryBuilder {
       const TypePtr& expectedType,
       vector_size_t expectedNumRows);
 
-  /// Run the query and collect all results into a single vector. Throws if
-  /// query returns empty result.
+  /// Run the query and collect all results into a single vector.
   RowVectorPtr copyResults(memory::MemoryPool* pool);
 
   /// Similar to above method and also returns the task.
@@ -191,8 +191,15 @@ class AssertQueryBuilder {
       memory::MemoryPool* pool,
       std::shared_ptr<Task>& task);
 
+  /// Run the query and copy the result Vectors as their original batches.
+  std::vector<RowVectorPtr> copyResultBatches(memory::MemoryPool* pool);
+
   /// Run the query and return the number of result rows.
-  uint64_t runWithoutResults(std::shared_ptr<Task>& task);
+  uint64_t countResults(std::shared_ptr<Task>& task);
+
+  /// Run the query and return the number of result rows without requiring a
+  /// task parameter.
+  uint64_t countResults();
 
  private:
   std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>>
@@ -200,7 +207,7 @@ class AssertQueryBuilder {
 
   static std::unique_ptr<folly::Executor> newExecutor() {
     return std::make_unique<folly::CPUThreadPoolExecutor>(
-        std::thread::hardware_concurrency());
+        folly::hardware_concurrency());
   }
 
   // Used by the created task as the default driver executor.
diff --git a/velox/exec/tests/utils/CMakeLists.txt b/velox/exec/tests/utils/CMakeLists.txt
index acc1119c9942..cf3ef9dbb102 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
+  AggregationResolver.cpp
   AssertQueryBuilder.cpp
   ArbitratorTestUtil.cpp
+  FilterToExpression.cpp
   HiveConnectorTestBase.cpp
   IndexLookupJoinTestBase.cpp
   LocalExchangeSource.cpp
@@ -34,7 +35,8 @@ add_library(
   TpchQueryBuilder.cpp
   VectorTestUtil.cpp
   PortUtil.cpp
-  SerializedPageUtil.cpp)
+  SerializedPageUtil.cpp
+)
 
 target_link_libraries(
   velox_exec_test_lib
@@ -50,27 +52,14 @@ target_link_libraries(
   velox_dwio_common
   velox_dwio_dwrf_reader
   velox_dwio_dwrf_writer
+  velox_dwio_text_reader_register
   velox_dwio_common_test_utils
   velox_file_test_utils
   velox_type_fbhive
   velox_hive_connector
   velox_tpch_connector
+  velox_tpcds_connector
   velox_presto_serializer
   velox_functions_prestosql
-  velox_aggregates)
-
-if(${VELOX_BUILD_RUNNER})
-  add_library(velox_exec_runner_test_util DistributedPlanBuilder.cpp
-                                          LocalRunnerTestBase.cpp)
-
-  target_link_libraries(
-    velox_exec_runner_test_util
-    velox_temp_path
-    velox_exec_test_lib
-    velox_exec
-    velox_file_test_utils
-    velox_hive_connector
-    velox_tpch_connector
-    velox_local_runner)
-
-endif()
+  velox_aggregates
+)
diff --git a/velox/exec/tests/utils/DistributedPlanBuilder.cpp b/velox/exec/tests/utils/DistributedPlanBuilder.cpp
deleted file mode 100644
index da09ee09af71..000000000000
--- a/velox/exec/tests/utils/DistributedPlanBuilder.cpp
+++ /dev/null
@@ -1,151 +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/DistributedPlanBuilder.h"
-
-namespace facebook::velox::exec::test {
-
-DistributedPlanBuilder::DistributedPlanBuilder(
-    const runner::MultiFragmentPlan::Options& options,
-    std::shared_ptr<core::PlanNodeIdGenerator> planNodeIdGenerator,
-    memory::MemoryPool* pool)
-    : PlanBuilder(planNodeIdGenerator, pool), options_(options), root_(this) {
-  root_->stack_.push_back(this);
-  newFragment();
-  current_->width = options_.numWorkers;
-}
-
-DistributedPlanBuilder::DistributedPlanBuilder(DistributedPlanBuilder& root)
-    : PlanBuilder(root.planNodeIdGenerator(), root.pool()),
-      options_(root.options_),
-      root_(&root) {
-  root_->stack_.push_back(this);
-  newFragment();
-  current_->width = options_.numWorkers;
-}
-
-DistributedPlanBuilder::~DistributedPlanBuilder() {
-  VELOX_CHECK_EQ(root_->stack_.size(), 1);
-}
-
-std::vector<runner::ExecutableFragment> DistributedPlanBuilder::fragments() {
-  newFragment();
-  return std::move(fragments_);
-}
-
-void DistributedPlanBuilder::newFragment() {
-  if (current_) {
-    gatherScans(planNode_);
-    current_->fragment = core::PlanFragment(std::move(planNode_));
-    fragments_.push_back(std::move(*current_));
-  }
-  current_ = std::make_unique<runner::ExecutableFragment>(
-      fmt::format("{}.{}", options_.queryId, root_->fragmentCounter_++));
-  planNode_ = nullptr;
-}
-
-PlanBuilder& DistributedPlanBuilder::shufflePartitioned(
-    const std::vector<std::string>& partitionKeys,
-    int numPartitions,
-    bool replicateNullsAndAny,
-    const std::vector<std::string>& outputLayout) {
-  partitionedOutput(
-      partitionKeys, numPartitions, replicateNullsAndAny, outputLayout);
-  auto* output =
-      dynamic_cast<const core::PartitionedOutputNode*>(planNode_.get());
-  VELOX_CHECK_NOT_NULL(output);
-  auto producerPrefix = current_->taskPrefix;
-  newFragment();
-  current_->width = numPartitions;
-  exchange(output->outputType(), VectorSerde::Kind::kPresto);
-  auto* exchange = dynamic_cast<const core::ExchangeNode*>(planNode_.get());
-  VELOX_CHECK_NOT_NULL(exchange);
-  current_->inputStages.push_back(
-      runner::InputStage{exchange->id(), producerPrefix});
-  return *this;
-}
-
-core::PlanNodePtr DistributedPlanBuilder::shufflePartitionedResult(
-    const std::vector<std::string>& partitionKeys,
-    int numPartitions,
-    bool replicateNullsAndAny,
-    const std::vector<std::string>& outputLayout) {
-  partitionedOutput(
-      partitionKeys, numPartitions, replicateNullsAndAny, outputLayout);
-  auto* output =
-      dynamic_cast<const core::PartitionedOutputNode*>(planNode_.get());
-  VELOX_CHECK_NOT_NULL(output);
-  const auto producerPrefix = current_->taskPrefix;
-  auto result = planNode_;
-  newFragment();
-  root_->stack_.pop_back();
-  auto* consumer = root_->stack_.back();
-  if (consumer->current_->width != 0) {
-    VELOX_CHECK_EQ(
-        numPartitions,
-        consumer->current_->width,
-        "The consumer width should match the producer fanout");
-  } else {
-    consumer->current_->width = numPartitions;
-  }
-
-  for (auto& fragment : fragments_) {
-    root_->fragments_.push_back(std::move(fragment));
-  }
-  exchange(output->outputType(), VectorSerde::Kind::kPresto);
-  auto* exchange = dynamic_cast<const core::ExchangeNode*>(planNode_.get());
-  consumer->current_->inputStages.push_back(
-      runner::InputStage{exchange->id(), producerPrefix});
-  return std::move(planNode_);
-}
-
-core::PlanNodePtr DistributedPlanBuilder::shuffleBroadcastResult() {
-  partitionedOutputBroadcast();
-  auto* output =
-      dynamic_cast<const core::PartitionedOutputNode*>(planNode_.get());
-  VELOX_CHECK_NOT_NULL(output);
-  const auto producerPrefix = current_->taskPrefix;
-  auto result = planNode_;
-  newFragment();
-
-  VELOX_CHECK_GE(root_->stack_.size(), 2);
-  root_->stack_.pop_back();
-  auto* consumer = root_->stack_.back();
-  VELOX_CHECK_GE(consumer->current_->width, 1);
-  VELOX_CHECK_EQ(fragments_.back().numBroadcastDestinations, 0);
-  fragments_.back().numBroadcastDestinations = consumer->current_->width;
-
-  for (auto& fragment : fragments_) {
-    root_->fragments_.push_back(std::move(fragment));
-  }
-  exchange(output->outputType(), VectorSerde::Kind::kPresto);
-  auto* exchange = dynamic_cast<const core::ExchangeNode*>(planNode_.get());
-  VELOX_CHECK_NOT_NULL(exchange);
-  consumer->current_->inputStages.push_back(
-      runner::InputStage{exchange->id(), producerPrefix});
-  return std::move(planNode_);
-}
-
-void DistributedPlanBuilder::gatherScans(const core::PlanNodePtr& plan) {
-  if (auto scan = std::dynamic_pointer_cast<const core::TableScanNode>(plan)) {
-    current_->scans.push_back(scan);
-    return;
-  }
-  for (auto& source : plan->sources()) {
-    gatherScans(source);
-  }
-}
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/DistributedPlanBuilder.h b/velox/exec/tests/utils/DistributedPlanBuilder.h
deleted file mode 100644
index 3f54d7915339..000000000000
--- a/velox/exec/tests/utils/DistributedPlanBuilder.h
+++ /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.
- */
-
-#pragma once
-
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/runner/MultiFragmentPlan.h"
-
-namespace facebook::velox::exec::test {
-
-/// Builder for distributed plans. Adds a shuffle() and related
-/// methods for building PartitionedOutput-Exchange pairs between
-/// fragments. Not thread safe.
-class DistributedPlanBuilder : public PlanBuilder {
- public:
-  /// Constructs a top level DistributedPlanBuilder.
-  DistributedPlanBuilder(
-      const runner::MultiFragmentPlan::Options& options,
-      std::shared_ptr<core::PlanNodeIdGenerator> planNodeIdGenerator,
-      memory::MemoryPool* pool = nullptr);
-
-  /// Constructs a child builder. Used for branching plans, e.g. the subplan for
-  /// a join build side.
-  DistributedPlanBuilder(DistributedPlanBuilder& root);
-
-  ~DistributedPlanBuilder() override;
-
-  /// Returns the planned fragments. The builder will be empty after this. This
-  /// is only called on the root builder.
-  std::vector<runner::ExecutableFragment> fragments();
-
-  PlanBuilder& shufflePartitioned(
-      const std::vector<std::string>& keys,
-      int numPartitions,
-      bool replicateNullsAndAny,
-      const std::vector<std::string>& outputLayout = {}) override;
-
-  core::PlanNodePtr shufflePartitionedResult(
-      const std::vector<std::string>& keys,
-      int numPartitions,
-      bool replicateNullsAndAny,
-      const std::vector<std::string>& outputLayout = {}) override;
-
-  core::PlanNodePtr shuffleBroadcastResult() override;
-
- private:
-  void newFragment();
-
-  void gatherScans(const core::PlanNodePtr& plan);
-
-  const runner::MultiFragmentPlan::Options& options_;
-  DistributedPlanBuilder* const root_;
-
-  // Stack of outstanding builders. The last element is the immediately
-  // enclosing one. When returning an ExchangeNode from returnShuffle, the stack
-  // is used to establish the linkage between the fragment of the returning
-  // builder and the fragment current in the calling builder. Only filled in the
-  // root builder.
-  std::vector<DistributedPlanBuilder*> stack_;
-
-  // Fragment counter. Only used in root builder.
-  int32_t fragmentCounter_{0};
-
-  // The fragment being built. Will be moved to the root builder's 'fragments_'
-  // when complete.
-  std::unique_ptr<runner::ExecutableFragment> current_;
-
-  // The fragments gathered under this builder. Moved to the root builder when
-  // returning the subplan.
-  std::vector<runner::ExecutableFragment> fragments_;
-};
-
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/ExpressionBuilder.h b/velox/exec/tests/utils/ExpressionBuilder.h
new file mode 100644
index 000000000000..d2d208b29647
--- /dev/null
+++ b/velox/exec/tests/utils/ExpressionBuilder.h
@@ -0,0 +1,478 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/parse/Expressions.h"
+
+namespace facebook::velox::expr_builder {
+
+/// Fluent Expression Builder.
+///
+/// This file contains fluent methods that make it convenient to create
+/// (untyped) expression trees. This provides similar functionality to a SQL
+/// parser, without bringing dependency on external libraries or bringing leaked
+/// semantics from other systems.
+///
+/// The untyped expressions can then be turned into typed expressions ready for
+/// execution using type binding from `core::Expressions::inferTypes()`.
+///
+/// The API provided is as close to the actual expression trees as possible.
+/// Comparisons, arithmetics, conjuncts, function calls, literals, aliases, and
+/// more are supported with this API.
+///
+/// For example, to create a column reference, you can:
+///
+/// > using namespace expr_builder;
+/// > core::ExprPtr e = col("c0");
+///
+/// You can also use the "_c" C++ literal provided:
+///
+/// > core::ExprPtr e = "c0"_c;
+///
+/// Expressions created using ExpressionBuilder functions can be used in any
+/// places that accept a ExprPtr. In practice, they create a ExprWrapper object,
+/// but ExprWrappers are implicitly convertible to ExprSet.
+///
+/// Nested column references can be specified as either:
+///
+/// > col("parent", "child");
+/// > col("parent").subfield("child");
+///
+/// To debug the expression generated, you can simply:
+///
+/// > LOG(INFO) << *e;
+///
+/// Comparisons and other expressions can be fluently created using C++
+/// overloaded operators:
+///
+/// > col("c") > 10; // "c > 10"
+/// > col("c") != "bar"; // "c != 'bar'"
+/// > col("c") == nullptr; // "c = null"
+///
+/// C++ literals are automatically converted into ConstantExpr (expression
+/// literals) when part of an expression. To explicitly create a literal you can
+/// use:
+///
+/// > lit(10.3);
+/// > lit("str");
+///
+/// Casts can be done using one of the two formats:
+///
+/// > lit(3).cast(TINYINT());
+/// > cast("str", VARBINARY());
+///
+/// Null checking filters:
+///
+/// > isNull(col("c")) // "c is null"
+/// > !isNull(col("c")) // "c is not null"
+///
+/// Conjuncts and "between":
+///
+/// > (col("a") && col("b")) || col("c"); // "(a AND b) OR c"
+/// > between(col("a"), 0, 10); // "a between 0 and 10"
+///
+/// You can also use fluent version of these APIs:
+///
+/// > col("a").between(0, 10); // "a between 0 and 10"
+///
+/// Arithmetic operators are also overloaded:
+///
+/// > col("c") * 100 + col("b"); // "c * 100 + b"
+///
+/// In any expression, as long as one of the sides is an expression node, the
+/// correct expression will be created. For example, both version work as
+/// expected:
+///
+/// > col("c") * 100; // "c * 100"
+/// > 100 * col("c"); // "100 * c"
+///
+/// When building long expressions, be careful about C++ constant folding and
+/// operator precedence:
+///
+/// > col("c") + 5 * 100;
+///
+/// C++ will fold "5 * 100" and generate the expression "c + 500". To force the
+/// expected behavior, you can explicitly spell out the literal:
+///
+/// > col("c") + 5 * lit(100);
+/// > col("c") + lit(5) * 100;
+///
+/// Both will generate "col + 5 * 100", which is "plus(col, multiply(5, 100))".
+///
+/// Generic function calls can be created using `call()`:
+///
+/// > call("func", 10); // "func(10)"
+///
+/// `call()` supports arbitrary parameters, which can be other expressions or
+/// (C++) literals.
+///
+/// Lambdas can be created using the following syntax:
+///
+/// > lambda({"x", "y"}, col("x") * col("y") + 1)
+///
+/// Where the first parameter is a vector of the lambda arguments, and the
+/// second the lambda body.
+///
+/// All functions above can be nested and combined in arbitrary ways.
+///
+/// > 10L * col("c1") > call("func", 3.4, col("g") / col("h"), call("j"));
+///
+/// is the same as "10 * c1 > func(3.4, g / h, j())".
+///
+/// Comparisons, arithmetics, and other operators are mapped to function names
+/// according to the table below. It is the user's responsibility to make sure
+/// that there names map to their appropriate implementation:
+///
+///  -------------------------------
+///  | C++        |  Function Name |
+///  -------------------------------
+///  | operator== |  eq            |
+///  | operator!= |  neq           |
+///  | operator<  |  lt            |
+///  | operator<= |  lte           |
+///  | operator>  |  gt            |
+///  | operator>= |  gte           |
+///  | operator!  |  not           |
+///  | operator&& |  and           |
+///  | operator|| |  or            |
+///  | operator+  |  plus          |
+///  | operator-  |  minus         |
+///  | operator*  |  multiply      |
+///  | operator/  |  divide        |
+///  | operator%  |  mode          |
+///  | operator== |  eq            |
+///  -------------------------------
+
+namespace detail {
+
+class ExprWrapper;
+
+/// Either builds a ConstantExpr (literal) based on a scalar value, or passes
+/// through an ExprWrapper already constructed.
+template <typename T>
+inline ExprWrapper toExprWrapper(T value);
+
+// Specialization for long to avoid ambiguity.
+inline ExprWrapper toExprWrapper(long value);
+
+template <>
+inline ExprWrapper toExprWrapper<ExprWrapper>(ExprWrapper expr);
+
+/// Wrapper library used so we can safely overload operators.
+class ExprWrapper {
+ public:
+  ExprWrapper(const core::ExprPtr& expr) : expr_(expr) {}
+
+  std::string toString() const {
+    return expr_->toString();
+  }
+
+  core::ExprPtr expr() const {
+    return expr_;
+  }
+
+  /// Add an alias to the current expression:
+  ///
+  /// > col("c0").alias("my_column");
+  ExprWrapper& alias(const std::string& newAlias) {
+    expr_ = expr_->withAlias(newAlias);
+    return *this;
+  }
+
+  /// Add a "subfield" expression to enable access of subfields in
+  /// rows/structs:
+  ///
+  /// > col("parent_col").subfield("child_name");
+  ExprWrapper& subfield(std::string childName) {
+    expr_ = std::make_shared<core::FieldAccessExpr>(
+        std::move(childName), std::nullopt, std::vector<core::ExprPtr>{expr_});
+    return *this;
+  }
+
+  /// Add a "cast" to the current expression:
+  ///
+  /// > col("c0").cast(VARBINARY());
+  /// > lit(10).cast(TINYINT());
+  ExprWrapper& cast(const TypePtr& castType) {
+    expr_ =
+        std::make_shared<core::CastExpr>(castType, expr_, false, std::nullopt);
+    return *this;
+  }
+
+  /// Add a "try_cast" to the current expression:
+  ///
+  /// > col("c0").tryCast(VARBINARY());
+  /// > lit(10).tryCast(TINYINT());
+  ExprWrapper& tryCast(const TypePtr& castType) {
+    expr_ =
+        std::make_shared<core::CastExpr>(castType, expr_, true, std::nullopt);
+    return *this;
+  }
+
+  /// Add a "is_null" to the current expression:
+  ///
+  /// > col("c0").isNull();
+  ExprWrapper& isNull() {
+    expr_ = std::make_shared<core::CallExpr>(
+        "is_null", std::vector<core::ExprPtr>{expr_}, std::nullopt);
+    return *this;
+  }
+
+  /// Add a "between" clause to the current expression wrapper:
+  ///
+  /// > col("a").between(1, 10);
+  template <typename T1, typename T2>
+  ExprWrapper& between(const T1& value1, const T2& value2) {
+    expr_ = std::make_shared<core::CallExpr>(
+        "between",
+        std::vector<core::ExprPtr>{
+            expr_,
+            detail::toExprWrapper(value1),
+            detail::toExprWrapper(value2)},
+        std::nullopt);
+    return *this;
+  }
+
+  /// If equality is used against an actual ExpPtr (not the wrapper), this will
+  /// compare the expressions themselves.
+  ///
+  /// It won't assume this is generating a eq() Velox expression.
+  bool operator==(const core::ExprPtr& other) const {
+    return *expr_ == *other;
+  }
+
+  /// Provide better gtest failure messages.
+  friend std::ostream& operator<<(std::ostream& os, const ExprWrapper& expr) {
+    return os << expr.expr_->toString();
+  }
+
+  /// For convenience, enable implicit conversions to ExprPtr.
+  operator core::ExprPtr() const {
+    return expr_;
+  }
+
+ private:
+  core::ExprPtr expr_;
+};
+
+/// Unpacks a list of variadic template parameters in a
+/// std::vector<core::ExprPtr>. The elements could be ExprWrapper or C++
+/// literals, which will get converted to ConstantExpr.
+///
+/// Base of recursion.
+inline std::vector<core::ExprPtr> unpackList() {
+  return {};
+}
+
+template <typename TFirst, typename... TArgs>
+inline std::vector<core::ExprPtr> unpackList(TFirst first, TArgs&&... args) {
+  std::vector<core::ExprPtr> head = {toExprWrapper(first)};
+  auto tail = unpackList(std::forward<TArgs>(args)...);
+  head.insert(head.end(), tail.begin(), tail.end());
+  return head;
+}
+
+} // namespace detail
+
+/// Column references.
+inline detail::ExprWrapper col(std::string name) {
+  return {std::make_shared<const core::FieldAccessExpr>(
+      std::move(name), std::nullopt)};
+}
+
+/// Enable users to use a custom C++ literal to add a column reference.
+/// For example: "col"_c
+inline detail::ExprWrapper operator"" _c(const char* str, size_t len) {
+  return col(std::string(str, len));
+}
+
+/// Nested column names. Ror rows/struct member references.
+inline detail::ExprWrapper col(std::string parentName, std::string childName) {
+  return col(std::move(parentName)).subfield(std::move(childName));
+}
+
+/// Literals.
+inline detail::ExprWrapper lit(int64_t value) {
+  return {std::make_shared<core::ConstantExpr>(BIGINT(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(int32_t value) {
+  return {std::make_shared<core::ConstantExpr>(INTEGER(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(int16_t value) {
+  return {
+      std::make_shared<core::ConstantExpr>(SMALLINT(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(int8_t value) {
+  return {std::make_shared<core::ConstantExpr>(TINYINT(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(bool value) {
+  return {std::make_shared<core::ConstantExpr>(BOOLEAN(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(double value) {
+  return {std::make_shared<core::ConstantExpr>(DOUBLE(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(float value) {
+  return {std::make_shared<core::ConstantExpr>(REAL(), value, std::nullopt)};
+}
+
+/// Different string flavors.
+inline detail::ExprWrapper lit(const char* value) {
+  return {std::make_shared<core::ConstantExpr>(VARCHAR(), value, std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(const std::string_view& value) {
+  return {std::make_shared<core::ConstantExpr>(
+      VARCHAR(), std::string(value), std::nullopt)};
+}
+
+inline detail::ExprWrapper lit(const std::string& value) {
+  return {std::make_shared<core::ConstantExpr>(VARCHAR(), value, std::nullopt)};
+}
+
+/// lit(nullptr).
+inline detail::ExprWrapper lit(std::nullptr_t) {
+  return {std::make_shared<core::ConstantExpr>(
+      UNKNOWN(), variant::null(TypeKind::UNKNOWN), std::nullopt)};
+}
+
+/// Macro to reduce builerplate when overloading C++ operators. The template
+/// magic basically means that the overload is matched if either left or right
+/// operands are an ExprWrapper. This is so that both "c"_f + 10 and 10 + "c"_f
+/// are supported, for example.
+///
+/// If either left or right side are ExprWrapper, we either convert the other
+/// side as a constant/literal, or use it as-is if it is already an ExprWrapper.
+#define VELOX_EXPR_BUILDER_OPERATOR(__op, __name)                    \
+  template <typename T1, typename T2>                                \
+  inline std::enable_if_t<                                           \
+      std::is_same_v<T1, detail::ExprWrapper> ||                     \
+          std::is_same_v<T2, detail::ExprWrapper>,                   \
+      detail::ExprWrapper>                                           \
+  __op(T1 lhs, T2 rhs) {                                             \
+    return {std::make_shared<core::CallExpr>(                        \
+        __name,                                                      \
+        std::vector<core::ExprPtr>{                                  \
+            detail::toExprWrapper(lhs), detail::toExprWrapper(rhs)}, \
+        std::nullopt)};                                              \
+  }
+
+/// Define C++ operator overload for comparisons.
+VELOX_EXPR_BUILDER_OPERATOR(operator==, "eq");
+VELOX_EXPR_BUILDER_OPERATOR(operator!=, "neq");
+VELOX_EXPR_BUILDER_OPERATOR(operator<, "lt");
+VELOX_EXPR_BUILDER_OPERATOR(operator<=, "lte");
+VELOX_EXPR_BUILDER_OPERATOR(operator>, "gt");
+VELOX_EXPR_BUILDER_OPERATOR(operator>=, "gte");
+
+/// Define C++ operator overload for arithmetics.
+VELOX_EXPR_BUILDER_OPERATOR(operator+, "plus");
+VELOX_EXPR_BUILDER_OPERATOR(operator-, "minus");
+VELOX_EXPR_BUILDER_OPERATOR(operator*, "multiply");
+VELOX_EXPR_BUILDER_OPERATOR(operator/, "divide");
+VELOX_EXPR_BUILDER_OPERATOR(operator%, "mod");
+
+VELOX_EXPR_BUILDER_OPERATOR(operator&&, "and");
+VELOX_EXPR_BUILDER_OPERATOR(operator||, "or");
+
+/// "not" is an unary operator.
+inline detail::ExprWrapper operator!(detail::ExprWrapper expr) {
+  return {std::make_shared<core::CallExpr>(
+      "not", std::vector<core::ExprPtr>{expr.expr()}, std::nullopt)};
+}
+
+/// "is_null" is also unary.
+template <typename T>
+inline detail::ExprWrapper isNull(const T& expr) {
+  return detail::toExprWrapper(expr).isNull();
+}
+
+/// "alias" as a free function.
+template <typename TInput>
+inline detail::ExprWrapper alias(TInput lhs, const std::string& newAlias) {
+  return detail::toExprWrapper(lhs).alias(newAlias);
+}
+
+/// "cast" as a free function.
+template <typename TInput>
+inline detail::ExprWrapper cast(TInput lhs, const TypePtr& castType) {
+  return detail::toExprWrapper(lhs).cast(castType);
+}
+
+/// "tryCast" as a free function.
+template <typename TInput>
+inline detail::ExprWrapper tryCast(TInput lhs, const TypePtr& castType) {
+  return detail::toExprWrapper(lhs).tryCast(castType);
+}
+
+/// "between" as a free function.
+template <typename T1, typename T2>
+inline detail::ExprWrapper
+between(detail::ExprWrapper lhs, const T1& value1, const T2& value2) {
+  return lhs.between(value1, value2);
+}
+
+/// Creates a lambda expressions, given the function parameters and an
+/// expression for the function body.
+template <typename TInput>
+inline detail::ExprWrapper lambda(
+    std::initializer_list<std::string> args,
+    const TInput& body) {
+  return {std::make_shared<core::LambdaExpr>(
+      std::move(args), detail::toExprWrapper(body))};
+}
+
+/// Convenience lambda builder for single argument lambdas.
+template <typename TInput>
+inline detail::ExprWrapper lambda(std::string arg, const TInput& body) {
+  return lambda({std::move(arg)}, body);
+}
+
+/// Regular function calls. First parameter is the function name, followed by
+/// their parameters. Parameters can be other expression nodes or literals.
+template <typename... TArgs>
+inline detail::ExprWrapper call(std::string name, TArgs&&... args) {
+  return {std::make_shared<core::CallExpr>(
+      std::move(name),
+      detail::unpackList(std::forward<TArgs>(args)...),
+      std::nullopt)};
+}
+
+namespace detail {
+
+template <typename T>
+inline ExprWrapper toExprWrapper(T value) {
+  return lit(value);
+}
+
+inline ExprWrapper toExprWrapper(long value) {
+  return lit(static_cast<int64_t>(value));
+}
+
+template <>
+inline ExprWrapper toExprWrapper<ExprWrapper>(ExprWrapper expr) {
+  return expr;
+}
+
+} // namespace detail
+
+} // namespace facebook::velox::expr_builder
diff --git a/velox/exec/tests/utils/FilterToExpression.cpp b/velox/exec/tests/utils/FilterToExpression.cpp
new file mode 100644
index 000000000000..7546694935d7
--- /dev/null
+++ b/velox/exec/tests/utils/FilterToExpression.cpp
@@ -0,0 +1,634 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/FilterToExpression.h"
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::core::test {
+
+core::TypedExprPtr createBooleanExpr(
+    const std::vector<TypedExprPtr>& conditions) {
+  if (conditions.empty()) {
+    return std::make_shared<ConstantTypedExpr>(BOOLEAN(), variant(true));
+  } else if (conditions.size() == 1) {
+    return conditions[0];
+  } else {
+    return std::make_shared<CallTypedExpr>(BOOLEAN(), conditions, "and");
+  }
+}
+
+core::TypedExprPtr handleNullAllowed(
+    const core::TypedExprPtr& expression,
+    const core::TypedExprPtr& subfieldExpr,
+    bool nullAllowed) {
+  if (nullAllowed) {
+    auto isNullExpr =
+        std::make_shared<CallTypedExpr>(BOOLEAN(), "is_null", subfieldExpr);
+
+    return std::make_shared<CallTypedExpr>(
+        BOOLEAN(), "or", expression, isNullExpr);
+  } else {
+    return expression;
+  }
+}
+
+core::TypedExprPtr getTypedExprFromSubfield(
+    const common::Subfield& subfield,
+    const RowTypePtr& rowType) {
+  VELOX_CHECK(subfield.valid(), "Invalid subfield");
+
+  const auto& path = subfield.path();
+  const auto& fieldName = subfield.baseName();
+
+  core::TypedExprPtr expr = std::make_shared<core::FieldAccessTypedExpr>(
+      rowType->findChild(fieldName), fieldName);
+  for (size_t i = 1; i < path.size(); ++i) {
+    const auto& element = path[i];
+
+    switch (element->kind()) {
+      case common::SubfieldKind::kNestedField: {
+        const auto* nestedField = element->as<common::Subfield::NestedField>();
+        const auto& nestedName = nestedField->name();
+
+        VELOX_CHECK(
+            expr->type()->isRow(), "Expected ROW type for nested field access");
+        const auto& rowType = expr->type()->asRow();
+
+        expr = std::make_shared<core::FieldAccessTypedExpr>(
+            rowType.findChild(nestedName), expr, nestedName);
+        break;
+      }
+
+      default:
+        VELOX_NYI(
+            "SubfieldKind other than kNestedField are not supported: {}",
+            common::SubfieldKindName::toName(element->kind()));
+    }
+  }
+
+  return expr;
+}
+
+core::TypedExprPtr filterToExpr(
+    const common::Subfield& subfield,
+    const common::Filter* filter,
+    const RowTypePtr& rowType,
+    memory::MemoryPool* pool) {
+  auto subfieldExpr = getTypedExprFromSubfield(subfield, rowType);
+
+  auto subfieldType = subfieldExpr->type();
+  auto isComplexType =
+      (subfieldType->kind() == TypeKind::ROW ||
+       subfieldType->kind() == TypeKind::MAP ||
+       subfieldType->kind() == TypeKind::ARRAY);
+
+  // Complex types (ROW, MAP, ARRAY) only support IsNull and IsNotNull filters.
+  if (isComplexType && filter->kind() != common::FilterKind::kIsNull &&
+      filter->kind() != common::FilterKind::kIsNotNull) {
+    VELOX_FAIL(
+        "Should not get any filter on complex type other than IsNull or IsNotNUll");
+  }
+
+  switch (filter->kind()) {
+    case common::FilterKind::kAlwaysFalse:
+      return std::make_shared<ConstantTypedExpr>(BOOLEAN(), variant(false));
+
+    case common::FilterKind::kAlwaysTrue:
+      return std::make_shared<ConstantTypedExpr>(BOOLEAN(), variant(true));
+
+    case common::FilterKind::kIsNull:
+      return std::make_shared<CallTypedExpr>(
+          BOOLEAN(), "is_null", subfieldExpr);
+
+    case common::FilterKind::kIsNotNull: {
+      auto isNullExpr =
+          std::make_shared<CallTypedExpr>(BOOLEAN(), "is_null", subfieldExpr);
+      return std::make_shared<CallTypedExpr>(BOOLEAN(), "not", isNullExpr);
+    }
+
+    case common::FilterKind::kBoolValue: {
+      auto boolFilter = static_cast<const common::BoolValue*>(filter);
+      auto boolValue = std::make_shared<ConstantTypedExpr>(
+          BOOLEAN(), variant(boolFilter->testBool(true)));
+
+      auto eqExpr = std::make_shared<CallTypedExpr>(
+          BOOLEAN(), "eq", subfieldExpr, boolValue);
+
+      return handleNullAllowed(eqExpr, subfieldExpr, boolFilter->nullAllowed());
+    }
+
+    case common::FilterKind::kBigintRange: {
+      auto rangeFilter = static_cast<const common::BigintRange*>(filter);
+      auto subfieldType = subfieldExpr->type();
+
+      // Special handling for TPCH DATE types.
+      if (subfieldType->isDate()) {
+        const int64_t kMaxInt64 = std::numeric_limits<int64_t>::max();
+        const int64_t kMinInt64 = std::numeric_limits<int64_t>::min();
+
+        std::vector<TypedExprPtr> conditions;
+
+        if (rangeFilter->lower() > kMinInt64) {
+          auto lower = std::make_shared<ConstantTypedExpr>(
+              subfieldType,
+              variant(static_cast<int32_t>(rangeFilter->lower())));
+
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gte", subfieldExpr, lower));
+        }
+
+        if (rangeFilter->upper() < kMaxInt64) {
+          auto upper = std::make_shared<ConstantTypedExpr>(
+              subfieldType,
+              variant(static_cast<int32_t>(rangeFilter->upper())));
+
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lte", subfieldExpr, upper));
+        }
+
+        auto rangeExpr = createBooleanExpr(conditions);
+        return handleNullAllowed(
+            rangeExpr, subfieldExpr, rangeFilter->nullAllowed());
+      } else {
+        ConstantTypedExprPtr lower;
+        ConstantTypedExprPtr upper;
+
+        switch (subfieldType->kind()) {
+          case TypeKind::TINYINT:
+            lower = std::make_shared<ConstantTypedExpr>(
+                subfieldType,
+                variant(static_cast<int8_t>(rangeFilter->lower())));
+            upper = std::make_shared<ConstantTypedExpr>(
+                subfieldType,
+                variant(static_cast<int8_t>(rangeFilter->upper())));
+            break;
+          case TypeKind::SMALLINT:
+            lower = std::make_shared<ConstantTypedExpr>(
+                subfieldType,
+                variant(static_cast<int16_t>(rangeFilter->lower())));
+            upper = std::make_shared<ConstantTypedExpr>(
+                subfieldType,
+                variant(static_cast<int16_t>(rangeFilter->upper())));
+            break;
+          case TypeKind::INTEGER:
+            lower = std::make_shared<ConstantTypedExpr>(
+                subfieldType,
+                variant(static_cast<int32_t>(rangeFilter->lower())));
+            upper = std::make_shared<ConstantTypedExpr>(
+                subfieldType,
+                variant(static_cast<int32_t>(rangeFilter->upper())));
+            break;
+          case TypeKind::BIGINT:
+          default:
+            lower = std::make_shared<ConstantTypedExpr>(
+                subfieldType, variant(rangeFilter->lower()));
+            upper = std::make_shared<ConstantTypedExpr>(
+                subfieldType, variant(rangeFilter->upper()));
+            break;
+        }
+
+        CallTypedExprPtr rangeExpr;
+        if (rangeFilter->lower() == rangeFilter->upper()) {
+          rangeExpr = std::make_shared<CallTypedExpr>(
+              BOOLEAN(), "eq", subfieldExpr, lower);
+        } else {
+          auto greaterOrEqual = std::make_shared<CallTypedExpr>(
+              BOOLEAN(), "gte", subfieldExpr, lower);
+
+          auto lessOrEqual = std::make_shared<CallTypedExpr>(
+              BOOLEAN(), "lte", subfieldExpr, upper);
+
+          rangeExpr = std::make_shared<CallTypedExpr>(
+              BOOLEAN(), "and", greaterOrEqual, lessOrEqual);
+        }
+
+        return handleNullAllowed(
+            rangeExpr, subfieldExpr, rangeFilter->nullAllowed());
+      }
+    }
+
+    case common::FilterKind::kNegatedBigintRange: {
+      auto negatedRangeFilter =
+          static_cast<const common::NegatedBigintRange*>(filter);
+      bool nullAllowed = negatedRangeFilter->nullAllowed();
+      const common::Filter* nonNegatedFilter =
+          negatedRangeFilter->getNonNegated();
+
+      auto rangeExpr = filterToExpr(subfield, nonNegatedFilter, rowType, pool);
+
+      auto notRangeExpr =
+          std::make_shared<CallTypedExpr>(BOOLEAN(), "not", rangeExpr);
+
+      return handleNullAllowed(notRangeExpr, subfieldExpr, nullAllowed);
+    }
+
+    case common::FilterKind::kDoubleRange: {
+      auto doubleFilter = static_cast<const common::DoubleRange*>(filter);
+      auto subfieldType = subfieldExpr->type();
+
+      std::vector<TypedExprPtr> conditions;
+
+      if (!doubleFilter->lowerUnbounded()) {
+        ConstantTypedExprPtr lower;
+
+        switch (subfieldType->kind()) {
+          case TypeKind::REAL:
+            lower = std::make_shared<ConstantTypedExpr>(
+                subfieldType,
+                variant(static_cast<float>(doubleFilter->lower())));
+            break;
+          case TypeKind::DOUBLE:
+          default:
+            lower = std::make_shared<ConstantTypedExpr>(
+                subfieldType, variant(doubleFilter->lower()));
+            break;
+        }
+
+        if (doubleFilter->lowerExclusive()) {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gt", subfieldExpr, lower));
+        } else {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gte", subfieldExpr, lower));
+        }
+      }
+
+      if (!doubleFilter->upperUnbounded()) {
+        ConstantTypedExprPtr upper;
+
+        switch (subfieldType->kind()) {
+          case TypeKind::REAL:
+            upper = std::make_shared<ConstantTypedExpr>(
+                subfieldType,
+                variant(static_cast<float>(doubleFilter->upper())));
+            break;
+          case TypeKind::DOUBLE:
+          default:
+            upper = std::make_shared<ConstantTypedExpr>(
+                subfieldType, variant(doubleFilter->upper()));
+            break;
+        }
+
+        if (doubleFilter->upperExclusive()) {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lt", subfieldExpr, upper));
+        } else {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lte", subfieldExpr, upper));
+        }
+      }
+
+      auto rangeExpr = createBooleanExpr(conditions);
+      return handleNullAllowed(
+          rangeExpr, subfieldExpr, doubleFilter->nullAllowed());
+    }
+
+    case common::FilterKind::kFloatRange: {
+      auto floatFilter = static_cast<const common::FloatRange*>(filter);
+      auto subfieldType = subfieldExpr->type();
+
+      std::vector<TypedExprPtr> conditions;
+
+      if (!floatFilter->lowerUnbounded()) {
+        auto lowerValue = floatFilter->lower();
+        auto lower = std::make_shared<ConstantTypedExpr>(
+            subfieldType, variant(static_cast<float>(lowerValue)));
+
+        if (floatFilter->lowerExclusive()) {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gt", subfieldExpr, lower));
+        } else {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gte", subfieldExpr, lower));
+        }
+      }
+
+      if (!floatFilter->upperUnbounded()) {
+        auto upperValue = floatFilter->upper();
+        auto upper = std::make_shared<ConstantTypedExpr>(
+            subfieldType, variant(static_cast<float>(upperValue)));
+
+        if (floatFilter->upperExclusive()) {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lt", subfieldExpr, upper));
+        } else {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lte", subfieldExpr, upper));
+        }
+      }
+
+      auto rangeExpr = createBooleanExpr(conditions);
+      return handleNullAllowed(
+          rangeExpr, subfieldExpr, floatFilter->nullAllowed());
+    }
+
+    case common::FilterKind::kBytesRange: {
+      auto bytesFilter = static_cast<const common::BytesRange*>(filter);
+      auto subfieldType = subfieldExpr->type();
+
+      std::vector<TypedExprPtr> conditions;
+
+      if (!bytesFilter->isLowerUnbounded()) {
+        auto lower = std::make_shared<ConstantTypedExpr>(
+            subfieldType, variant(bytesFilter->lower()));
+
+        if (bytesFilter->isLowerExclusive()) {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gt", subfieldExpr, lower));
+        } else {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "gte", subfieldExpr, lower));
+        }
+      }
+
+      if (!bytesFilter->isUpperUnbounded()) {
+        auto upper = std::make_shared<ConstantTypedExpr>(
+            subfieldType, variant(bytesFilter->upper()));
+
+        if (bytesFilter->isUpperExclusive()) {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lt", subfieldExpr, upper));
+        } else {
+          conditions.push_back(
+              std::make_shared<CallTypedExpr>(
+                  BOOLEAN(), "lte", subfieldExpr, upper));
+        }
+      }
+
+      auto rangeExpr = createBooleanExpr(conditions);
+      return handleNullAllowed(
+          rangeExpr, subfieldExpr, bytesFilter->nullAllowed());
+    }
+
+    case common::FilterKind::kBigintValuesUsingHashTable:
+    case common::FilterKind::kBigintValuesUsingBitmask: {
+      std::vector<int64_t> values;
+      int64_t min, max;
+      bool nullAllowed;
+
+      if (filter->kind() == common::FilterKind::kBigintValuesUsingHashTable) {
+        auto hashFilter =
+            static_cast<const common::BigintValuesUsingHashTable*>(filter);
+        values = hashFilter->values();
+        min = hashFilter->min();
+        max = hashFilter->max();
+        nullAllowed = hashFilter->nullAllowed();
+      } else {
+        auto bitmaskFilter =
+            static_cast<const common::BigintValuesUsingBitmask*>(filter);
+        values = bitmaskFilter->values();
+        min = bitmaskFilter->min();
+        max = bitmaskFilter->max();
+        nullAllowed = bitmaskFilter->nullAllowed();
+      }
+
+      auto subfieldType = subfieldExpr->type();
+      std::vector<TypedExprPtr> valueExprs;
+      valueExprs.reserve(values.size());
+
+      for (const auto& value : values) {
+        switch (subfieldType->kind()) {
+          case TypeKind::TINYINT:
+            valueExprs.push_back(
+                std::make_shared<ConstantTypedExpr>(
+                    subfieldType, variant(static_cast<int8_t>(value))));
+            break;
+          case TypeKind::SMALLINT:
+            valueExprs.push_back(
+                std::make_shared<ConstantTypedExpr>(
+                    subfieldType, variant(static_cast<int16_t>(value))));
+            break;
+          case TypeKind::INTEGER:
+            valueExprs.push_back(
+                std::make_shared<ConstantTypedExpr>(
+                    subfieldType, variant(static_cast<int32_t>(value))));
+            break;
+          case TypeKind::BIGINT:
+          default:
+            valueExprs.push_back(
+                std::make_shared<ConstantTypedExpr>(
+                    subfieldType, variant(value)));
+            break;
+        }
+      }
+
+      auto arrayExpr = std::make_shared<CallTypedExpr>(
+          ARRAY(subfieldType), valueExprs, "array_constructor");
+
+      auto inExpr = std::make_shared<CallTypedExpr>(
+          BOOLEAN(), "in", subfieldExpr, arrayExpr);
+
+      // Optimization: Add range check (field >= min AND field <= max) before IN
+      // check.
+      ConstantTypedExprPtr minConstant, maxConstant;
+      switch (subfieldType->kind()) {
+        case TypeKind::TINYINT:
+          minConstant = std::make_shared<ConstantTypedExpr>(
+              subfieldType, variant(static_cast<int8_t>(min)));
+          maxConstant = std::make_shared<ConstantTypedExpr>(
+              subfieldType, variant(static_cast<int8_t>(max)));
+          break;
+        case TypeKind::SMALLINT:
+          minConstant = std::make_shared<ConstantTypedExpr>(
+              subfieldType, variant(static_cast<int16_t>(min)));
+          maxConstant = std::make_shared<ConstantTypedExpr>(
+              subfieldType, variant(static_cast<int16_t>(max)));
+          break;
+        case TypeKind::INTEGER:
+          minConstant = std::make_shared<ConstantTypedExpr>(
+              subfieldType, variant(static_cast<int32_t>(min)));
+          maxConstant = std::make_shared<ConstantTypedExpr>(
+              subfieldType, variant(static_cast<int32_t>(max)));
+          break;
+        case TypeKind::BIGINT:
+        default:
+          minConstant =
+              std::make_shared<ConstantTypedExpr>(subfieldType, variant(min));
+          maxConstant =
+              std::make_shared<ConstantTypedExpr>(subfieldType, variant(max));
+          break;
+      }
+
+      // Create a range check expression to validate field bounds.
+      auto gteMinExpr = std::make_shared<CallTypedExpr>(
+          BOOLEAN(), "gte", subfieldExpr, minConstant);
+      auto lteMaxExpr = std::make_shared<CallTypedExpr>(
+          BOOLEAN(), "lte", subfieldExpr, maxConstant);
+      auto rangeCheckExpr = std::make_shared<CallTypedExpr>(
+          BOOLEAN(), "and", gteMinExpr, lteMaxExpr);
+
+      // Combine the range check with the IN check for optimization.
+      auto optimizedInExpr = std::make_shared<CallTypedExpr>(
+          BOOLEAN(), "and", rangeCheckExpr, inExpr);
+
+      return handleNullAllowed(optimizedInExpr, subfieldExpr, nullAllowed);
+    }
+
+    case common::FilterKind::kNegatedBigintValuesUsingHashTable: {
+      auto hashFilter =
+          static_cast<const common::NegatedBigintValuesUsingHashTable*>(filter);
+      bool nullAllowed = hashFilter->nullAllowed();
+      const common::Filter* nonNegatedFilter = hashFilter->getNonNegated();
+
+      auto inExpr = filterToExpr(subfield, nonNegatedFilter, rowType, pool);
+
+      auto notInExpr =
+          std::make_shared<CallTypedExpr>(BOOLEAN(), "not", inExpr);
+
+      return handleNullAllowed(notInExpr, subfieldExpr, nullAllowed);
+    }
+    case common::FilterKind::kNegatedBigintValuesUsingBitmask: {
+      auto bitmaskFilter =
+          static_cast<const common::NegatedBigintValuesUsingBitmask*>(filter);
+      bool nullAllowed = bitmaskFilter->nullAllowed();
+      const common::Filter* nonNegatedFilter = bitmaskFilter->getNonNegated();
+
+      auto inExpr = filterToExpr(subfield, nonNegatedFilter, rowType, pool);
+
+      auto notInExpr =
+          std::make_shared<CallTypedExpr>(BOOLEAN(), "not", inExpr);
+
+      return handleNullAllowed(notInExpr, subfieldExpr, nullAllowed);
+    }
+
+    case common::FilterKind::kBytesValues: {
+      auto bytesFilter = static_cast<const common::BytesValues*>(filter);
+      const auto& values = bytesFilter->values();
+      auto subfieldType = subfieldExpr->type();
+
+      std::vector<TypedExprPtr> valueExprs;
+      for (const auto& value : values) {
+        valueExprs.push_back(
+            std::make_shared<ConstantTypedExpr>(subfieldType, variant(value)));
+      }
+
+      auto arrayExpr = std::make_shared<CallTypedExpr>(
+          ARRAY(subfieldType), valueExprs, "array_constructor");
+
+      auto inExpr = std::make_shared<CallTypedExpr>(
+          BOOLEAN(), "in", subfieldExpr, arrayExpr);
+
+      return handleNullAllowed(
+          inExpr, subfieldExpr, bytesFilter->nullAllowed());
+    }
+
+    case common::FilterKind::kNegatedBytesValues: {
+      auto negatedBytesFilter =
+          static_cast<const common::NegatedBytesValues*>(filter);
+      bool nullAllowed = negatedBytesFilter->nullAllowed();
+      const common::Filter* nonNegatedFilter =
+          negatedBytesFilter->getNonNegated();
+
+      auto inExpr = filterToExpr(subfield, nonNegatedFilter, rowType, pool);
+
+      auto notInExpr =
+          std::make_shared<CallTypedExpr>(BOOLEAN(), "not", inExpr);
+
+      return handleNullAllowed(notInExpr, subfieldExpr, nullAllowed);
+    }
+
+    case common::FilterKind::kTimestampRange: {
+      auto timestampFilter = static_cast<const common::TimestampRange*>(filter);
+      auto lower = std::make_shared<ConstantTypedExpr>(
+          TIMESTAMP(), variant(timestampFilter->lower()));
+      auto upper = std::make_shared<ConstantTypedExpr>(
+          TIMESTAMP(), variant(timestampFilter->upper()));
+
+      CallTypedExprPtr rangeExpr;
+      if (timestampFilter->isSingleValue()) {
+        rangeExpr = std::make_shared<CallTypedExpr>(
+            BOOLEAN(), "eq", subfieldExpr, lower);
+      } else {
+        auto greaterOrEqual = std::make_shared<CallTypedExpr>(
+            BOOLEAN(), "gte", subfieldExpr, lower);
+
+        auto lessOrEqual = std::make_shared<CallTypedExpr>(
+            BOOLEAN(), "lte", subfieldExpr, upper);
+
+        rangeExpr = std::make_shared<CallTypedExpr>(
+            BOOLEAN(), "and", greaterOrEqual, lessOrEqual);
+      }
+
+      return handleNullAllowed(
+          rangeExpr, subfieldExpr, timestampFilter->nullAllowed());
+    }
+
+    case common::FilterKind::kBigintMultiRange: {
+      auto multiRangeFilter =
+          static_cast<const common::BigintMultiRange*>(filter);
+      const auto& ranges = multiRangeFilter->ranges();
+
+      std::vector<TypedExprPtr> rangeExprs;
+      for (const auto& range : ranges) {
+        auto rangeExpr = filterToExpr(subfield, range.get(), rowType, pool);
+        rangeExprs.push_back(rangeExpr);
+      }
+
+      return std::make_shared<CallTypedExpr>(BOOLEAN(), rangeExprs, "or");
+    }
+
+    case common::FilterKind::kMultiRange: {
+      auto multiRangeFilter = static_cast<const common::MultiRange*>(filter);
+      const auto& filters = multiRangeFilter->filters();
+
+      std::vector<TypedExprPtr> filterExprs;
+      for (const auto& subFilter : filters) {
+        auto filterExpr =
+            filterToExpr(subfield, subFilter.get(), rowType, pool);
+        filterExprs.push_back(filterExpr);
+      }
+
+      return std::make_shared<CallTypedExpr>(BOOLEAN(), filterExprs, "or");
+    }
+
+    case common::FilterKind::kNegatedBytesRange: {
+      auto negatedBytesFilter =
+          static_cast<const common::NegatedBytesRange*>(filter);
+      bool nullAllowed = negatedBytesFilter->nullAllowed();
+      const common::Filter* nonNegatedFilter =
+          negatedBytesFilter->getNonNegated();
+
+      auto rangeExpr = filterToExpr(subfield, nonNegatedFilter, rowType, pool);
+
+      auto notRangeExpr =
+          std::make_shared<CallTypedExpr>(BOOLEAN(), "not", rangeExpr);
+
+      return handleNullAllowed(notRangeExpr, subfieldExpr, nullAllowed);
+    }
+
+    case common::FilterKind::kHugeintRange:
+    case common::FilterKind::kHugeintValuesUsingHashTable:
+    default:
+      VELOX_NYI(
+          "Filter type not yet implemented in filterToExpr: {}",
+          filter->toString());
+      return subfieldExpr;
+  }
+}
+} // namespace facebook::velox::core::test
diff --git a/velox/exec/tests/utils/FilterToExpression.h b/velox/exec/tests/utils/FilterToExpression.h
new file mode 100644
index 000000000000..e0664cb03a31
--- /dev/null
+++ b/velox/exec/tests/utils/FilterToExpression.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 "velox/common/memory/MemoryPool.h"
+#include "velox/core/ITypedExpr.h"
+#include "velox/type/Filter.h"
+#include "velox/type/Subfield.h"
+
+namespace facebook::velox::core::test {
+/// Converts a Filter object to a TypedExpr object that can be used in Velox's
+/// expression evaluation system.
+///
+/// This function takes a filter that applies to a specific subfield and
+/// converts it to an equivalent expression tree.
+///
+/// @param subfield The subfield to which the filter applies. This is used to
+///                 create the base expression that the filter condition will
+///                 be applied to.
+/// @param filter The filter to convert. This can be any subclass of Filter,
+///               such as AlwaysTrue, IsNull, BigintRange, BytesValues, etc.
+/// @param rowType The row type that contains the subfield. This is used to
+///                resolve the subfield path and determine its type.
+/// @param pool Memory pool to use for allocations.
+/// @return A TypedExpr object representing the filter condition applied to
+///         the subfield.
+core::TypedExprPtr filterToExpr(
+    const common::Subfield& subfield,
+    const common::Filter* filter,
+    const RowTypePtr& rowType,
+    memory::MemoryPool* pool);
+} // namespace facebook::velox::core::test
diff --git a/velox/exec/tests/utils/HashJoinTestBase.h b/velox/exec/tests/utils/HashJoinTestBase.h
index b063389cc607..3f1bc5509f92 100644
--- a/velox/exec/tests/utils/HashJoinTestBase.h
+++ b/velox/exec/tests/utils/HashJoinTestBase.h
@@ -42,10 +42,24 @@ using facebook::velox::test::BatchMaker;
 
 struct TestParam {
   int64_t numDrivers{1};
+  bool parallelBuildSideRowsEnabled;
 
-  explicit TestParam(int _numDrivers) : numDrivers(_numDrivers) {}
+  explicit TestParam(int _numDrivers)
+      : numDrivers(_numDrivers), parallelBuildSideRowsEnabled(false) {}
+
+  TestParam(int _numDrivers, bool _parallelBuildSideRowsEnabled)
+      : numDrivers(_numDrivers),
+        parallelBuildSideRowsEnabled(_parallelBuildSideRowsEnabled) {}
 };
 
+// Required for GTest to generate unique parameterized test names.
+inline std::string TestParamToName(const TestParam& param) {
+  return fmt::format(
+      "{}_drivers_{}_parallelBuildSideRowsEnabled",
+      param.numDrivers,
+      param.parallelBuildSideRowsEnabled ? "with" : "without");
+}
+
 using SplitInput =
     std::unordered_map<core::PlanNodeId, std::vector<exec::Split>>;
 
@@ -407,6 +421,11 @@ class HashJoinBuilder {
     return *this;
   }
 
+  HashJoinBuilder& parallelizeJoinBuildRows(bool value) {
+    parallelJoinBuildRowsEnabled_ = value;
+    return *this;
+  }
+
   HashJoinBuilder& spillDirectory(const std::string& spillDirectory) {
     spillDirectory_ = spillDirectory;
     return *this;
@@ -467,8 +486,9 @@ class HashJoinBuilder {
     }
 
     for (const auto& testData : testSettings) {
-      SCOPED_TRACE(fmt::format(
-          "{} numDrivers: {}", testData.debugString(), numDrivers_));
+      SCOPED_TRACE(
+          fmt::format(
+              "{} numDrivers: {}", testData.debugString(), numDrivers_));
       auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
       std::shared_ptr<const core::HashJoinNode> joinNode;
       auto planNode =
@@ -596,15 +616,14 @@ class HashJoinBuilder {
         builder.splits(splitEntry.first, splitEntry.second);
       }
     }
-    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()));
+    auto queryCtx = core::QueryCtx::Builder()
+                        .executor(executor_)
+                        .pool(
+                            memory::MemoryManager::getInstance()->addRootPool(
+                                "query_pool",
+                                memory::kMaxMemory,
+                                memory::MemoryReclaimer::create()))
+                        .build();
     std::shared_ptr<TempDirectoryPath> spillDirectory;
     int32_t spillPct{0};
     if (injectSpill) {
@@ -628,6 +647,9 @@ class HashJoinBuilder {
     config(
         core::QueryConfig::kHashProbeFinishEarlyOnEmptyBuild,
         hashProbeFinishEarlyOnEmptyBuild_ ? "true" : "false");
+    config(
+        core::QueryConfig::kParallelOutputJoinBuildRowsEnabled,
+        parallelJoinBuildRowsEnabled_ ? "true" : "false");
     if (maxDriverYieldTimeMs != 0) {
       config(
           core::QueryConfig::kDriverCpuTimeSliceLimitMs,
@@ -759,6 +781,7 @@ class HashJoinBuilder {
   std::shared_ptr<memory::MemoryPool> queryPool_;
   std::string spillDirectory_;
   bool hashProbeFinishEarlyOnEmptyBuild_{true};
+  bool parallelJoinBuildRowsEnabled_{false};
 
   SplitInput inputSplits_;
   std::function<SplitInput()> makeInputSplits_;
@@ -773,7 +796,8 @@ class HashJoinTestBase : public HiveConnectorTestBase {
   HashJoinTestBase() : HashJoinTestBase(TestParam(1)) {}
 
   explicit HashJoinTestBase(const TestParam& param)
-      : numDrivers_(param.numDrivers) {}
+      : numDrivers_(param.numDrivers),
+        parallelBuildSideRowsEnabled_(param.parallelBuildSideRowsEnabled) {}
 
   void SetUp() override {
     HiveConnectorTestBase::SetUp();
@@ -791,7 +815,7 @@ class HashJoinTestBase : public HiveConnectorTestBase {
   }
 
   // Make splits with each plan node having a number of source files.
-  SplitInput makeSpiltInput(
+  SplitInput makeSplitInput(
       const std::vector<core::PlanNodeId>& nodeIds,
       const std::vector<std::vector<std::shared_ptr<TempFilePath>>>& files) {
     VELOX_CHECK_EQ(nodeIds.size(), files.size());
@@ -945,7 +969,8 @@ class HashJoinTestBase : public HiveConnectorTestBase {
       case core::JoinType::kRightSemiProject:
         return core::JoinType::kLeftSemiProject;
       default:
-        VELOX_FAIL("Cannot flip join type: {}", core::joinTypeName(joinType));
+        VELOX_FAIL(
+            "Cannot flip join type: {}", core::JoinTypeName::toName(joinType));
     }
   }
 
@@ -965,6 +990,7 @@ class HashJoinTestBase : public HiveConnectorTestBase {
   }
 
   const int32_t numDrivers_;
+  const bool parallelBuildSideRowsEnabled_;
 
   // The default left and right table types used for test.
   RowTypePtr probeType_;
diff --git a/velox/exec/tests/utils/HiveConnectorTestBase.cpp b/velox/exec/tests/utils/HiveConnectorTestBase.cpp
index 94aea88367c2..6e12c0d98aa1 100644
--- a/velox/exec/tests/utils/HiveConnectorTestBase.cpp
+++ b/velox/exec/tests/utils/HiveConnectorTestBase.cpp
@@ -18,12 +18,13 @@
 
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h"
-#include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/writer/FlushPolicy.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/dwio/text/RegisterTextReader.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 
 namespace facebook::velox::exec::test {
@@ -35,20 +36,17 @@ HiveConnectorTestBase::HiveConnectorTestBase() {
 
 void HiveConnectorTestBase::SetUp() {
   OperatorTestBase::SetUp();
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              kHiveConnectorId,
-              std::make_shared<config::ConfigBase>(
-                  std::unordered_map<std::string, std::string>()),
-              ioExecutor_.get());
+  connector::hive::HiveConnectorFactory factory;
+  auto hiveConnector = factory.newConnector(
+      kHiveConnectorId,
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()),
+      ioExecutor_.get());
   connector::registerConnector(hiveConnector);
   dwio::common::registerFileSinks();
   dwrf::registerDwrfReaderFactory();
   dwrf::registerDwrfWriterFactory();
+  text::registerTextReaderFactory();
 }
 
 void HiveConnectorTestBase::TearDown() {
@@ -58,18 +56,17 @@ void HiveConnectorTestBase::TearDown() {
   dwrf::unregisterDwrfReaderFactory();
   dwrf::unregisterDwrfWriterFactory();
   connector::unregisterConnector(kHiveConnectorId);
-  connector::unregisterConnectorFactory(
-      connector::hive::HiveConnectorFactory::kHiveConnectorName);
+  text::unregisterTextReaderFactory();
   OperatorTestBase::TearDown();
 }
 
 void HiveConnectorTestBase::resetHiveConnector(
     const std::shared_ptr<const config::ConfigBase>& config) {
   connector::unregisterConnector(kHiveConnectorId);
+
+  connector::hive::HiveConnectorFactory factory;
   auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(kHiveConnectorId, config, ioExecutor_.get());
+      factory.newConnector(kHiveConnectorId, config, ioExecutor_.get());
   connector::registerConnector(hiveConnector);
 }
 
@@ -206,23 +203,23 @@ HiveConnectorTestBase::makeHiveConnectorSplits(
         infoColumns) {
   auto file =
       filesystems::getFileSystem(filePath, nullptr)->openFileForRead(filePath);
-  const int64_t fileSize = file->size();
+  const uint64_t fileSize = file->size();
   // Take the upper bound.
-  const int64_t splitSize = std::ceil((fileSize) / splitCount);
+  const uint64_t splitSize = std::ceil((fileSize) / splitCount);
   std::vector<std::shared_ptr<connector::hive::HiveConnectorSplit>> splits;
   // Add all the splits.
-  for (int i = 0; i < splitCount; i++) {
+  for (uint32_t i = 0; i < splitCount; i++) {
     auto splitBuilder = HiveConnectorSplitBuilder(filePath)
                             .fileFormat(format)
                             .start(i * splitSize)
                             .length(splitSize);
     if (infoColumns.has_value()) {
-      for (auto infoColumn : infoColumns.value()) {
+      for (const auto& infoColumn : infoColumns.value()) {
         splitBuilder.infoColumn(infoColumn.first, infoColumn.second);
       }
     }
     if (partitionKeys.has_value()) {
-      for (auto partitionKey : partitionKeys.value()) {
+      for (const auto& partitionKey : partitionKeys.value()) {
         splitBuilder.partitionKey(partitionKey.first, partitionKey.second);
       }
     }
@@ -262,7 +259,8 @@ std::vector<std::shared_ptr<connector::ConnectorSplit>>
 HiveConnectorTestBase::makeHiveConnectorSplits(
     const std::vector<std::shared_ptr<TempFilePath>>& filePaths) {
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
-  for (auto filePath : filePaths) {
+  splits.reserve(filePaths.size());
+  for (const auto& filePath : filePaths) {
     splits.push_back(makeHiveConnectorSplit(
         filePath->getPath(),
         filePath->fileSize(),
diff --git a/velox/exec/tests/utils/HiveConnectorTestBase.h b/velox/exec/tests/utils/HiveConnectorTestBase.h
index 2173acf133e7..b3660714f509 100644
--- a/velox/exec/tests/utils/HiveConnectorTestBase.h
+++ b/velox/exec/tests/utils/HiveConnectorTestBase.h
@@ -15,24 +15,18 @@
  */
 #pragma once
 
-#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #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"
-#include "velox/type/tests/SubfieldFiltersBuilder.h"
 
 namespace facebook::velox::exec::test {
 
 static const std::string kHiveConnectorId = "test-hive";
 
-using ColumnHandleMap =
-    std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>;
-
 class HiveConnectorTestBase : public OperatorTestBase {
  public:
   HiveConnectorTestBase();
@@ -236,8 +230,9 @@ class HiveConnectorTestBase : public OperatorTestBase {
       const std::string& name,
       const TypePtr& type);
 
-  static ColumnHandleMap allRegularColumns(const RowTypePtr& rowType) {
-    ColumnHandleMap assignments;
+  static connector::ColumnHandleMap allRegularColumns(
+      const RowTypePtr& rowType) {
+    connector::ColumnHandleMap assignments;
     assignments.reserve(rowType->size());
     for (uint32_t i = 0; i < rowType->size(); ++i) {
       const auto& name = rowType->nameOf(i);
@@ -253,7 +248,7 @@ class HiveConnectorSplitBuilder
     : public connector::hive::HiveConnectorSplitBuilder {
  public:
   explicit HiveConnectorSplitBuilder(std::string filePath)
-      : connector::hive::HiveConnectorSplitBuilder(filePath) {
+      : connector::hive::HiveConnectorSplitBuilder(std::move(filePath)) {
     connectorId(kHiveConnectorId);
   }
 };
diff --git a/velox/exec/tests/utils/IndexLookupJoinTestBase.cpp b/velox/exec/tests/utils/IndexLookupJoinTestBase.cpp
index 8ec2d9710745..8bb2bb2a0072 100644
--- a/velox/exec/tests/utils/IndexLookupJoinTestBase.cpp
+++ b/velox/exec/tests/utils/IndexLookupJoinTestBase.cpp
@@ -15,15 +15,29 @@
  */
 
 #include "velox/exec/tests/utils/IndexLookupJoinTestBase.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
-namespace fecebook::velox::exec::test {
+namespace facebook::velox::exec::test {
+using namespace facebook::velox::test;
 
-facebook::velox::RowTypePtr IndexLookupJoinTestBase::concat(
-    const facebook::velox::RowTypePtr& a,
-    const facebook::velox::RowTypePtr& b) {
+namespace {
+std::vector<std::string> appendMarker(const std::vector<std::string> columns) {
+  std::vector<std::string> resultColumns;
+  resultColumns.reserve(columns.size() + 1);
+  for (const auto& column : columns) {
+    resultColumns.push_back(column);
+  }
+  resultColumns.push_back("__match__");
+  return resultColumns;
+}
+} // namespace
+
+RowTypePtr IndexLookupJoinTestBase::concat(
+    const RowTypePtr& a,
+    const RowTypePtr& b) {
   std::vector<std::string> names = a->names();
-  std::vector<facebook::velox::TypePtr> types = a->children();
+  std::vector<TypePtr> types = a->children();
   names.insert(names.end(), b->names().begin(), b->names().end());
   types.insert(types.end(), b->children().begin(), b->children().end());
   return ROW(std::move(names), std::move(types));
@@ -37,15 +51,15 @@ int IndexLookupJoinTestBase::getNumRows(const std::vector<int>& cardinalities) {
   return numRows;
 }
 
-std::vector<facebook::velox::RowVectorPtr>
-IndexLookupJoinTestBase::generateProbeInput(
+std::vector<RowVectorPtr> IndexLookupJoinTestBase::generateProbeInput(
     size_t numBatches,
     size_t batchSize,
     size_t numDuplicateProbeRows,
     SequenceTableData& tableData,
-    std::shared_ptr<facebook::velox::memory::MemoryPool>& pool,
+    std::shared_ptr<memory::MemoryPool>& pool,
     const std::vector<std::string>& probeJoinKeys,
-    const std::vector<std::string> inColumns,
+    bool hasNullKeys,
+    const std::vector<std::string>& inColumns,
     const std::vector<std::pair<std::string, std::string>>& betweenColumns,
     std::optional<int> equalMatchPct,
     std::optional<int> inMatchPct,
@@ -53,16 +67,33 @@ IndexLookupJoinTestBase::generateProbeInput(
   VELOX_CHECK_LE(
       probeJoinKeys.size() + betweenColumns.size() + inColumns.size(),
       keyType_->size());
-  std::vector<facebook::velox::RowVectorPtr> probeInputs;
+  std::vector<RowVectorPtr> probeInputs;
   probeInputs.reserve(numBatches);
-  facebook::velox::VectorFuzzer::Options opts;
+  VectorFuzzer::Options opts;
   opts.vectorSize = batchSize * numDuplicateProbeRows;
   opts.allowSlice = false;
   // TODO: add nullable handling later.
-  opts.nullRatio = 0.0;
-  facebook::velox::VectorFuzzer fuzzer(opts, pool.get());
+  opts.nullRatio = hasNullKeys ? 0.1 : 0.0;
+  VectorFuzzer fuzzer(opts, pool.get());
   for (int i = 0; i < numBatches; ++i) {
     probeInputs.push_back(fuzzer.fuzzInputRow(probeType_));
+    // NOTE: index connector doesn't expect in condition column rray elements to
+    // be null.
+    if ((!inMatchPct.has_value() || tableData.keyData->size() == 0) &&
+        hasNullKeys) {
+      for (int i = 0; i < probeType_->size(); ++i) {
+        const auto columnType = probeType_->childAt(i);
+        if (columnType->isArray()) {
+          opts.nullRatio = 0.0;
+          VectorFuzzer vectorFuzzer(opts, pool.get());
+          probeInputs.back()->childAt(i) = vectorFuzzer.fuzz(columnType);
+          VELOX_CHECK(!probeInputs.back()->childAt(i)->mayHaveNulls());
+          VELOX_CHECK_EQ(
+              probeInputs.back()->childAt(i)->size(),
+              probeInputs.back()->size());
+        }
+      }
+    }
   }
 
   if (tableData.keyData->size() == 0) {
@@ -70,42 +101,49 @@ IndexLookupJoinTestBase::generateProbeInput(
   }
 
   const auto numTableRows = tableData.keyData->size();
-  std::vector<facebook::velox::FlatVectorPtr<int64_t>> tableKeyVectors;
+  std::vector<FlatVectorPtr<int64_t>> tableKeyVectors;
   for (int i = 0; i < probeJoinKeys.size(); ++i) {
     auto keyVector = tableData.keyData->childAt(i);
     keyVector->loadedVector();
-    facebook::velox::BaseVector::flattenVector(keyVector);
+    BaseVector::flattenVector(keyVector);
     tableKeyVectors.push_back(
-        std::dynamic_pointer_cast<facebook::velox::FlatVector<int64_t>>(
-            keyVector));
+        std::dynamic_pointer_cast<FlatVector<int64_t>>(keyVector));
   }
 
   if (equalMatchPct.has_value()) {
     VELOX_CHECK_GE(equalMatchPct.value(), 0);
     VELOX_CHECK_LE(equalMatchPct.value(), 100);
-    for (int i = 0, totalRows = 0; i < numBatches; ++i) {
-      std::vector<facebook::velox::FlatVectorPtr<int64_t>> probeKeyVectors;
+    for (int i = 0; i < numBatches; ++i) {
+      std::vector<FlatVectorPtr<int64_t>> probeKeyVectors;
       for (int j = 0; j < probeJoinKeys.size(); ++j) {
-        probeKeyVectors.push_back(facebook::velox::BaseVector::create<
-                                  facebook::velox::FlatVector<int64_t>>(
-            probeType_->findChild(probeJoinKeys[j]),
-            probeInputs[i]->size(),
-            pool.get()));
+        probeKeyVectors.push_back(
+            BaseVector::create<FlatVector<int64_t>>(
+                probeType_->findChild(probeJoinKeys[j]),
+                probeInputs[i]->size(),
+                pool.get()));
       }
       for (int row = 0; row < probeInputs[i]->size();
-           row += numDuplicateProbeRows, totalRows += numDuplicateProbeRows) {
-        if ((totalRows / numDuplicateProbeRows) % 100 < equalMatchPct.value()) {
-          const auto matchKeyRow = folly::Random::rand64(numTableRows);
+           row += numDuplicateProbeRows) {
+        const auto hit =
+            (folly::Random::rand32(rng_) % 100) < equalMatchPct.value();
+        if (hit) {
+          const auto matchKeyRow = folly::Random::rand32(numTableRows, rng_);
           for (int j = 0; j < probeJoinKeys.size(); ++j) {
             for (int k = 0; k < numDuplicateProbeRows; ++k) {
+              if (probeKeyVectors[j]->isNullAt(row + k)) {
+                continue;
+              }
               probeKeyVectors[j]->set(
                   row + k, tableKeyVectors[j]->valueAt(matchKeyRow));
             }
           }
         } else {
           for (int j = 0; j < probeJoinKeys.size(); ++j) {
-            const auto randomValue = folly::Random::rand32() % 4096;
+            const auto randomValue = folly::Random::rand32(rng_) % 4096;
             for (int k = 0; k < numDuplicateProbeRows; ++k) {
+              if (probeKeyVectors[j]->isNullAt(row + k)) {
+                continue;
+              }
               probeKeyVectors[j]->set(
                   row + k, tableData.maxKeys[j] + 1 + randomValue);
             }
@@ -125,9 +163,8 @@ IndexLookupJoinTestBase::generateProbeInput(
     for (int i = 0; i < inColumns.size(); ++i) {
       const auto inColumnName = inColumns[i];
       const auto inColumnChannel = probeType_->getChildIdx(inColumnName);
-      auto inColumnType =
-          std::dynamic_pointer_cast<const facebook::velox::ArrayType>(
-              probeType_->childAt(inColumnChannel));
+      auto inColumnType = std::dynamic_pointer_cast<const ArrayType>(
+          probeType_->childAt(inColumnChannel));
       VELOX_CHECK_NOT_NULL(inColumnType);
       const auto tableKeyChannel = probeJoinKeys.size() + i;
       VELOX_CHECK(keyType_->childAt(tableKeyChannel)
@@ -144,10 +181,11 @@ IndexLookupJoinTestBase::generateProbeInput(
       for (int i = 0; i < numBatches; ++i) {
         probeInputs[i]->childAt(inColumnChannel) = makeArrayVector<int64_t>(
             probeInputs[i]->size(),
-            [&](auto row) -> facebook::velox::vector_size_t {
-              return maxValue - minValue + 1;
-            },
-            [&](auto /*unused*/, auto index) { return minValue + index; });
+            [&](auto row) -> vector_size_t { return maxValue - minValue + 1; },
+            [&](auto /*unused*/, auto index) { return minValue + index; },
+            [&](auto row) {
+              return probeInputs[i]->childAt(inColumnChannel)->isNullAt(row);
+            });
       }
     }
   }
@@ -177,15 +215,22 @@ IndexLookupJoinTestBase::generateProbeInput(
         if (lowerBoundChannel.has_value()) {
           probeInputs[i]->childAt(lowerBoundChannel.value()) =
               makeFlatVector<int64_t>(
-                  probeInputs[i]->size(), [&](auto /*unused*/) {
+                  probeInputs[i]->size(),
+                  [&](auto /*unused*/) {
                     return tableData.minKeys[tableKeyChannel];
+                  },
+                  [&](auto row) {
+                    return probeInputs[i]
+                        ->childAt(lowerBoundChannel.value())
+                        ->isNullAt(row);
                   });
         }
         const auto upperBoundColumn = betweenColumn.second;
         if (upperBoundChannel.has_value()) {
           probeInputs[i]->childAt(upperBoundChannel.value()) =
               makeFlatVector<int64_t>(
-                  probeInputs[i]->size(), [&](auto /*unused*/) -> int64_t {
+                  probeInputs[i]->size(),
+                  [&](auto /*unused*/) -> int64_t {
                     if (betweenMatchPct.value() == 0) {
                       return tableData.minKeys[tableKeyChannel] - 1;
                     } else {
@@ -194,6 +239,11 @@ IndexLookupJoinTestBase::generateProbeInput(
                            tableData.minKeys[tableKeyChannel]) *
                           betweenMatchPct.value() / 100;
                     }
+                  },
+                  [&](auto row) {
+                    return probeInputs[i]
+                        ->childAt(upperBoundChannel.value())
+                        ->isNullAt(row);
                   });
         }
       }
@@ -202,64 +252,68 @@ IndexLookupJoinTestBase::generateProbeInput(
   return probeInputs;
 }
 
-facebook::velox::core::PlanNodePtr IndexLookupJoinTestBase::makeLookupPlan(
-    const std::shared_ptr<facebook::velox::core::PlanNodeIdGenerator>&
-        planNodeIdGenerator,
-    facebook::velox::core::TableScanNodePtr indexScanNode,
-    const std::vector<facebook::velox::RowVectorPtr>& probeVectors,
+PlanNodePtr IndexLookupJoinTestBase::makeLookupPlan(
+    const std::shared_ptr<PlanNodeIdGenerator>& planNodeIdGenerator,
+    TableScanNodePtr indexScanNode,
+    const std::vector<RowVectorPtr>& probeVectors,
     const std::vector<std::string>& leftKeys,
     const std::vector<std::string>& rightKeys,
     const std::vector<std::string>& joinConditions,
-    facebook::velox::core::JoinType joinType,
+    bool hasMarker,
+    JoinType joinType,
     const std::vector<std::string>& outputColumns,
-    facebook::velox::core::PlanNodeId& joinNodeId) {
+    PlanNodeId& joinNodeId) {
   VELOX_CHECK_EQ(leftKeys.size(), rightKeys.size());
   VELOX_CHECK_LE(leftKeys.size(), keyType_->size());
-  return facebook::velox::exec::test::PlanBuilder(
-             planNodeIdGenerator, pool_.get())
+  return PlanBuilder(planNodeIdGenerator, pool_.get())
       .values(probeVectors)
-      .indexLookupJoin(
-          leftKeys,
-          rightKeys,
-          indexScanNode,
-          joinConditions,
-          outputColumns,
-          joinType)
+      .startIndexLookupJoin()
+      .leftKeys(leftKeys)
+      .rightKeys(rightKeys)
+      .indexSource(indexScanNode)
+      .joinConditions(joinConditions)
+      .hasMarker(hasMarker)
+      .outputLayout(hasMarker ? appendMarker(outputColumns) : outputColumns)
+      .joinType(joinType)
+      .endIndexLookupJoin()
       .capturePlanNodeId(joinNodeId)
       .planNode();
 }
 
-facebook::velox::core::PlanNodePtr IndexLookupJoinTestBase::makeLookupPlan(
-    const std::shared_ptr<facebook::velox::core::PlanNodeIdGenerator>&
-        planNodeIdGenerator,
-    facebook::velox::core::TableScanNodePtr indexScanNode,
+PlanNodePtr IndexLookupJoinTestBase::makeLookupPlan(
+    const std::shared_ptr<PlanNodeIdGenerator>& planNodeIdGenerator,
+    TableScanNodePtr indexScanNode,
     const std::vector<std::string>& leftKeys,
     const std::vector<std::string>& rightKeys,
     const std::vector<std::string>& joinConditions,
-    facebook::velox::core::JoinType joinType,
+    const std::string& filter,
+    bool hasMarker,
+    JoinType joinType,
     const std::vector<std::string>& outputColumns) {
   VELOX_CHECK_EQ(leftKeys.size(), rightKeys.size());
   VELOX_CHECK_LE(leftKeys.size(), keyType_->size());
-  return facebook::velox::exec::test::PlanBuilder(
-             planNodeIdGenerator, pool_.get())
+  return PlanBuilder(planNodeIdGenerator, pool_.get())
       .startTableScan()
       .outputType(probeType_)
       .endTableScan()
       .captureScanNodeId(probeScanNodeId_)
-      .indexLookupJoin(
-          leftKeys,
-          rightKeys,
-          indexScanNode,
-          joinConditions,
-          outputColumns,
-          joinType)
+      .startIndexLookupJoin()
+      .leftKeys(leftKeys)
+      .rightKeys(rightKeys)
+      .indexSource(indexScanNode)
+      .joinConditions(joinConditions)
+      .filter(filter)
+      .hasMarker(hasMarker)
+      .outputLayout(hasMarker ? appendMarker(outputColumns) : outputColumns)
+      .joinType(joinType)
+      .endIndexLookupJoin()
       .capturePlanNodeId(joinNodeId_)
       .planNode();
 }
 
 void IndexLookupJoinTestBase::createDuckDbTable(
     const std::string& tableName,
-    const std::vector<facebook::velox::RowVectorPtr>& data) {
+    const std::vector<RowVectorPtr>& data) {
   // Change each column with prefix 'c' to simplify the duckdb table
   // column naming.
   std::vector<std::string> columnNames;
@@ -267,7 +321,7 @@ void IndexLookupJoinTestBase::createDuckDbTable(
   for (int i = 0; i < data[0]->type()->size(); ++i) {
     columnNames.push_back(fmt::format("c{}", i));
   }
-  std::vector<facebook::velox::RowVectorPtr> duckDbInputs;
+  std::vector<RowVectorPtr> duckDbInputs;
   duckDbInputs.reserve(data.size());
   for (const auto& dataVector : data) {
     duckDbInputs.emplace_back(
@@ -276,29 +330,20 @@ void IndexLookupJoinTestBase::createDuckDbTable(
   duckDbQueryRunner_.createTable(tableName, duckDbInputs);
 }
 
-facebook::velox::core::TableScanNodePtr
-IndexLookupJoinTestBase::makeIndexScanNode(
-    const std::shared_ptr<facebook::velox::core::PlanNodeIdGenerator>&
-        planNodeIdGenerator,
-    const std::shared_ptr<facebook::velox::connector::ConnectorTableHandle>
-        indexTableHandle,
-    const facebook::velox::RowTypePtr& outputType,
-    std::unordered_map<
-        std::string,
-        std::shared_ptr<facebook::velox::connector::ColumnHandle>>&
-        assignments) {
-  auto planBuilder = facebook::velox::exec::test::PlanBuilder(
-      planNodeIdGenerator, pool_.get());
-  auto indexTableScan =
-      std::dynamic_pointer_cast<const facebook::velox::core::TableScanNode>(
-          facebook::velox::exec::test::PlanBuilder::TableScanBuilder(
-              planBuilder)
-              .tableHandle(indexTableHandle)
-              .outputType(outputType)
-              .assignments(assignments)
-              .endTableScan()
-              .capturePlanNodeId(indexScanNodeId_)
-              .planNode());
+TableScanNodePtr IndexLookupJoinTestBase::makeIndexScanNode(
+    const std::shared_ptr<PlanNodeIdGenerator>& planNodeIdGenerator,
+    const connector::ConnectorTableHandlePtr& indexTableHandle,
+    const RowTypePtr& outputType,
+    const connector::ColumnHandleMap& assignments) {
+  auto planBuilder = PlanBuilder(planNodeIdGenerator, pool_.get());
+  auto indexTableScan = std::dynamic_pointer_cast<const TableScanNode>(
+      PlanBuilder::TableScanBuilder(planBuilder)
+          .tableHandle(indexTableHandle)
+          .outputType(outputType)
+          .assignments(assignments)
+          .endTableScan()
+          .capturePlanNodeId(indexScanNodeId_)
+          .planNode());
   VELOX_CHECK_NOT_NULL(indexTableScan);
   return indexTableScan;
 }
@@ -306,14 +351,14 @@ IndexLookupJoinTestBase::makeIndexScanNode(
 void IndexLookupJoinTestBase::generateIndexTableData(
     const std::vector<int>& keyCardinalities,
     SequenceTableData& tableData,
-    std::shared_ptr<facebook::velox::memory::MemoryPool>& pool) {
+    std::shared_ptr<memory::MemoryPool>& pool) {
   VELOX_CHECK_EQ(keyCardinalities.size(), keyType_->size());
   const auto numRows = getNumRows(keyCardinalities);
-  facebook::velox::VectorFuzzer::Options opts;
+  VectorFuzzer::Options opts;
   opts.vectorSize = numRows;
   opts.nullRatio = 0.0;
   opts.allowSlice = false;
-  facebook::velox::VectorFuzzer fuzzer(opts, pool.get());
+  VectorFuzzer fuzzer(opts, pool.get());
 
   tableData.keyData = fuzzer.fuzzInputFlatRow(keyType_);
   tableData.valueData = fuzzer.fuzzInputFlatRow(valueType_);
@@ -339,7 +384,7 @@ void IndexLookupJoinTestBase::generateIndexTableData(
     tableData.maxKeys[i] = maxKey;
   }
 
-  std::vector<facebook::velox::VectorPtr> tableColumns;
+  std::vector<VectorPtr> tableColumns;
   VELOX_CHECK_EQ(tableType_->size(), keyType_->size() + valueType_->size());
   tableColumns.reserve(tableType_->size());
   for (auto i = 0; i < keyType_->size(); ++i) {
@@ -351,9 +396,9 @@ void IndexLookupJoinTestBase::generateIndexTableData(
   tableData.tableData = makeRowVector(tableType_->names(), tableColumns);
 }
 
-facebook::velox::RowTypePtr IndexLookupJoinTestBase::makeScanOutputType(
+RowTypePtr IndexLookupJoinTestBase::makeScanOutputType(
     std::vector<std::string> outputNames) {
-  std::vector<facebook::velox::TypePtr> types;
+  std::vector<TypePtr> types;
   for (int i = 0; i < outputNames.size(); ++i) {
     if (valueType_->getChildIdxIfExists(outputNames[i]).has_value()) {
       types.push_back(valueType_->findChild(outputNames[i]));
@@ -361,65 +406,114 @@ facebook::velox::RowTypePtr IndexLookupJoinTestBase::makeScanOutputType(
     }
     types.push_back(keyType_->findChild(outputNames[i]));
   }
-  return facebook::velox::ROW(std::move(outputNames), std::move(types));
+  return ROW(std::move(outputNames), std::move(types));
 }
 
 bool IndexLookupJoinTestBase::isFilter(const std::string& conditionSql) const {
   const auto inputType = concat(keyType_, probeType_);
-  return facebook::velox::exec::test::PlanBuilder::parseIndexJoinCondition(
+  return PlanBuilder::parseIndexJoinCondition(
              conditionSql, inputType, pool_.get())
       ->isFilter();
 }
 
-std::shared_ptr<facebook::velox::exec::Task>
-IndexLookupJoinTestBase::runLookupQuery(
-    const facebook::velox::core::PlanNodePtr& plan,
+std::shared_ptr<Task> IndexLookupJoinTestBase::runLookupQuery(
+    const PlanNodePtr& plan,
     int numPrefetchBatches,
     const std::string& duckDbVefifySql) {
-  return facebook::velox::exec::test::AssertQueryBuilder(duckDbQueryRunner_)
+  return AssertQueryBuilder(duckDbQueryRunner_)
       .plan(plan)
       .config(
-          facebook::velox::core::QueryConfig::
-              kIndexLookupJoinMaxPrefetchBatches,
+          QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
           std::to_string(numPrefetchBatches))
       .assertResults(duckDbVefifySql);
 }
 
-std::shared_ptr<facebook::velox::exec::Task>
-IndexLookupJoinTestBase::runLookupQuery(
-    const facebook::velox::core::PlanNodePtr& plan,
-    const std::vector<
-        std::shared_ptr<facebook::velox::exec::test::TempFilePath>>& probeFiles,
+std::shared_ptr<Task> IndexLookupJoinTestBase::runLookupQuery(
+    const PlanNodePtr& plan,
+    const std::vector<std::shared_ptr<TempFilePath>>& probeFiles,
     bool serialExecution,
     bool barrierExecution,
     int maxOutputRows,
     int numPrefetchBatches,
     const std::string& duckDbVefifySql) {
-  return facebook::velox::exec::test::AssertQueryBuilder(duckDbQueryRunner_)
+  return AssertQueryBuilder(duckDbQueryRunner_)
       .plan(plan)
       .splits(probeScanNodeId_, makeHiveConnectorSplits(probeFiles))
       .serialExecution(serialExecution)
       .barrierExecution(barrierExecution)
+      .config(QueryConfig::kMaxOutputBatchRows, std::to_string(maxOutputRows))
       .config(
-          facebook::velox::core::QueryConfig::kMaxOutputBatchRows,
-          std::to_string(maxOutputRows))
-      .config(
-          facebook::velox::core::QueryConfig::
-              kIndexLookupJoinMaxPrefetchBatches,
+          QueryConfig::kIndexLookupJoinMaxPrefetchBatches,
           std::to_string(numPrefetchBatches))
       .assertResults(duckDbVefifySql);
 }
 
-std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
+void IndexLookupJoinTestBase::verifyResultWithMatchColumn(
+    const PlanNodePtr& planWithoutMatchColumn,
+    const PlanNodeId& probeScanNodeIdWithoutMatchColumn,
+    const PlanNodePtr& planWithMatchColumn,
+    const PlanNodeId& probeScanNodeIdWithMatchColumn,
+    const std::vector<std::shared_ptr<TempFilePath>>& probeFiles) {
+  VectorPtr expectedResult = AssertQueryBuilder(duckDbQueryRunner_)
+                                 .plan(planWithoutMatchColumn)
+                                 .splits(
+                                     probeScanNodeIdWithoutMatchColumn,
+                                     makeHiveConnectorSplits(probeFiles))
+                                 .copyResults(pool());
+  BaseVector::flattenVector(expectedResult);
+
+  VectorPtr resultWithMatchColumn = AssertQueryBuilder(duckDbQueryRunner_)
+                                        .plan(planWithMatchColumn)
+                                        .splits(
+                                            probeScanNodeIdWithMatchColumn,
+                                            makeHiveConnectorSplits(probeFiles))
+                                        .copyResults(pool());
+  BaseVector::flattenVector(resultWithMatchColumn);
+  auto rowResultWithMatchMatchColumn =
+      std::dynamic_pointer_cast<RowVector>(resultWithMatchColumn);
+  const auto resultWithMatchColumnType =
+      std::dynamic_pointer_cast<const RowType>(
+          rowResultWithMatchMatchColumn->type());
+  std::vector<VectorPtr> childVectors;
+  std::unordered_set<std::string> lookupColumnNameSet(
+      valueType_->names().begin(), valueType_->names().end());
+  std::vector<VectorPtr> lookupColumnVectors;
+  for (int i = 0; i < rowResultWithMatchMatchColumn->childrenSize() - 1; ++i) {
+    childVectors.push_back(rowResultWithMatchMatchColumn->childAt(i));
+    if (lookupColumnNameSet.contains(resultWithMatchColumnType->nameOf(i))) {
+      lookupColumnVectors.push_back(rowResultWithMatchMatchColumn->childAt(i));
+    }
+  }
+  auto resultWithoutMatchColumn = makeRowVector(childVectors);
+  assertEqualVectors(expectedResult, resultWithoutMatchColumn);
+  // Verify the match column if it is expected.
+  const auto matchColumn =
+      rowResultWithMatchMatchColumn
+          ->childAt(rowResultWithMatchMatchColumn->childrenSize() - 1)
+          ->asFlatVector<bool>();
+  for (int i = 0; i < resultWithMatchColumn->size(); ++i) {
+    const bool match = matchColumn->valueAt(i);
+    if (match) {
+      for (const auto& lookupColumnVector : lookupColumnVectors) {
+        ASSERT_FALSE(lookupColumnVector->isNullAt(i));
+      }
+    } else {
+      for (const auto& lookupColumnVector : lookupColumnVectors) {
+        ASSERT_TRUE(lookupColumnVector->isNullAt(i));
+      }
+    }
+  }
+}
+
+std::vector<std::shared_ptr<TempFilePath>>
 IndexLookupJoinTestBase::createProbeFiles(
-    const std::vector<facebook::velox::RowVectorPtr>& probeVectors) {
-  std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
-      probeFiles;
+    const std::vector<RowVectorPtr>& probeVectors) {
+  std::vector<std::shared_ptr<TempFilePath>> probeFiles;
   probeFiles.reserve(probeVectors.size());
   for (auto i = 0; i < probeVectors.size(); ++i) {
-    probeFiles.push_back(facebook::velox::exec::test::TempFilePath::create());
+    probeFiles.push_back(TempFilePath::create());
   }
   writeToFiles(toFilePaths(probeFiles), probeVectors);
   return probeFiles;
 }
-} // namespace fecebook::velox::exec::test
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/IndexLookupJoinTestBase.h b/velox/exec/tests/utils/IndexLookupJoinTestBase.h
index 4fa0c3472826..db96fbae95df 100644
--- a/velox/exec/tests/utils/IndexLookupJoinTestBase.h
+++ b/velox/exec/tests/utils/IndexLookupJoinTestBase.h
@@ -13,30 +13,37 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+#pragma once
 #include "velox/connectors/Connector.h"
 #include "velox/core/PlanNode.h"
-#include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/parse/PlanNodeIdGenerator.h"
 
-namespace fecebook::velox::exec::test {
-class IndexLookupJoinTestBase
-    : public facebook::velox::exec::test::HiveConnectorTestBase {
+namespace facebook::velox::exec::test {
+
+using namespace facebook::velox;
+using namespace facebook::velox::core;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class IndexLookupJoinTestBase : public HiveConnectorTestBase {
  protected:
   IndexLookupJoinTestBase() = default;
 
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    rng_.seed(123);
+  }
+
   struct SequenceTableData {
-    facebook::velox::RowVectorPtr keyData;
-    facebook::velox::RowVectorPtr valueData;
-    facebook::velox::RowVectorPtr tableData;
+    RowVectorPtr keyData;
+    RowVectorPtr valueData;
+    RowVectorPtr tableData;
     std::vector<int64_t> minKeys;
     std::vector<int64_t> maxKeys;
   };
 
-  static facebook::velox::RowTypePtr concat(
-      const facebook::velox::RowTypePtr& a,
-      const facebook::velox::RowTypePtr& b);
+  static RowTypePtr concat(const RowTypePtr& a, const RowTypePtr& b);
 
   bool isFilter(const std::string& conditionSql) const;
 
@@ -50,6 +57,7 @@ class IndexLookupJoinTestBase
   /// @param tableData: contains the sequence table data including key vectors
   /// and min/max key values.
   /// @param probeJoinKeys: the prefix key colums used for equality joins.
+  /// @param hasNullKeys: whether the probe input has null keys.
   /// @param inColumns: the ordered list of in conditions.
   /// @param betweenColumns: the ordered list of between conditions.
   /// @param equalMatchPct: percentage of rows in the probe input that matches
@@ -58,14 +66,15 @@ class IndexLookupJoinTestBase
   /// the rows in index table with between conditions.
   /// @param inMatchPct: percentage of rows in the probe input that matches the
   /// rows in index table with in conditions.
-  std::vector<facebook::velox::RowVectorPtr> generateProbeInput(
+  std::vector<RowVectorPtr> generateProbeInput(
       size_t numBatches,
       size_t batchSize,
       size_t numDuplicateProbeRows,
       SequenceTableData& tableData,
-      std::shared_ptr<facebook::velox::memory::MemoryPool>& pool,
+      std::shared_ptr<memory::MemoryPool>& pool,
       const std::vector<std::string>& probeJoinKeys,
-      const std::vector<std::string> inColumns = {},
+      bool hasNullKeys = false,
+      const std::vector<std::string>& inColumns = {},
       const std::vector<std::pair<std::string, std::string>>& betweenColumns =
           {},
       std::optional<int> equalMatchPct = std::nullopt,
@@ -77,58 +86,59 @@ class IndexLookupJoinTestBase
   /// @param probeVectors: the probe input vectors.
   /// @param leftKeys: the left join keys of index lookup join.
   /// @param rightKeys: the right join keys of index lookup join.
+  /// @param hasMarker: whether the index join output includes a match
+  /// column at the end.
   /// @param joinType: the join type of index lookup join.
   /// @param outputColumns: the output column names of index lookup join.
   /// @param joinNodeId: returns the plan node id of the index lookup join
   /// node.
-  facebook::velox::core::PlanNodePtr makeLookupPlan(
-      const std::shared_ptr<facebook::velox::core::PlanNodeIdGenerator>&
-          planNodeIdGenerator,
-      facebook::velox::core::TableScanNodePtr indexScanNode,
-      const std::vector<facebook::velox::RowVectorPtr>& probeVectors,
+  PlanNodePtr makeLookupPlan(
+      const std::shared_ptr<PlanNodeIdGenerator>& planNodeIdGenerator,
+      TableScanNodePtr indexScanNode,
+      const std::vector<RowVectorPtr>& probeVectors,
       const std::vector<std::string>& leftKeys,
       const std::vector<std::string>& rightKeys,
       const std::vector<std::string>& joinConditions,
-      facebook::velox::core::JoinType joinType,
+      bool hasMarker,
+      core::JoinType joinType,
       const std::vector<std::string>& outputColumns,
-      facebook::velox::core::PlanNodeId& joinNodeId);
+      core::PlanNodeId& joinNodeId);
 
   /// Makes lookup join plan with the following parameters:
+  /// @param planNodeIdGenerator: generator for creating unique plan node IDs.
   /// @param indexScanNode: the index table scan node.
-  /// @param probeVectors: the probe input vectors.
   /// @param leftKeys: the left join keys of index lookup join.
   /// @param rightKeys: the right join keys of index lookup join.
+  /// @param joinConditions: the join conditions for index lookup join that
+  /// can't be converted into simple equality join conditions.
+  /// @param filter: additional filter condition SQL string to apply on join
+  /// results. Can be empty string if no additional filter is needed.
+  /// @param hasMarker: whether the index join output includes a match
+  /// column at the end.
   /// @param joinType: the join type of index lookup join.
   /// @param outputColumns: the output column names of index lookup join.
-  /// @param joinNodeId: returns the plan node id of the index lookup join
-  /// node.
-  /// @param probeScanNodeId: returns the plan node id of the probe table scan
-  facebook::velox::core::PlanNodePtr makeLookupPlan(
-      const std::shared_ptr<facebook::velox::core::PlanNodeIdGenerator>&
-          planNodeIdGenerator,
-      facebook::velox::core::TableScanNodePtr indexScanNode,
+  PlanNodePtr makeLookupPlan(
+      const std::shared_ptr<PlanNodeIdGenerator>& planNodeIdGenerator,
+      TableScanNodePtr indexScanNode,
       const std::vector<std::string>& leftKeys,
       const std::vector<std::string>& rightKeys,
       const std::vector<std::string>& joinConditions,
-      facebook::velox::core::JoinType joinType,
+      const std::string& filter,
+      bool hasMarker,
+      JoinType joinType,
       const std::vector<std::string>& outputColumns);
 
   void createDuckDbTable(
       const std::string& tableName,
-      const std::vector<facebook::velox::RowVectorPtr>& data);
+      const std::vector<RowVectorPtr>& data);
 
   /// Makes index table scan node with the specified index table handle.
   /// @param outputType: the output schema of the index table scan node.
-  facebook::velox::core::TableScanNodePtr makeIndexScanNode(
-      const std::shared_ptr<facebook::velox::core::PlanNodeIdGenerator>&
-          planNodeIdGenerator,
-      const std::shared_ptr<facebook::velox::connector::ConnectorTableHandle>
-          indexTableHandle,
-      const facebook::velox::RowTypePtr& outputType,
-      std::unordered_map<
-          std::string,
-          std::shared_ptr<facebook::velox::connector::ColumnHandle>>&
-          assignments);
+  TableScanNodePtr makeIndexScanNode(
+      const std::shared_ptr<PlanNodeIdGenerator>& planNodeIdGenerator,
+      const connector::ConnectorTableHandlePtr& indexTableHandle,
+      const RowTypePtr& outputType,
+      const connector::ColumnHandleMap& assignments);
 
   /// Generate sequence storage table which will be persisted by mock zippydb
   /// client for testing.
@@ -141,41 +151,47 @@ class IndexLookupJoinTestBase
   void generateIndexTableData(
       const std::vector<int>& keyCardinalities,
       SequenceTableData& tableData,
-      std::shared_ptr<facebook::velox::memory::MemoryPool>& pool);
+      std::shared_ptr<memory::MemoryPool>& pool);
 
   /// Write 'probeVectors' to a number of files with one per each file.
-  std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
-  createProbeFiles(
-      const std::vector<facebook::velox::RowVectorPtr>& probeVectors);
+  std::vector<std::shared_ptr<TempFilePath>> createProbeFiles(
+      const std::vector<RowVectorPtr>& probeVectors);
 
   /// Makes output schema from the index table scan node with the specified
   /// column names.
-  facebook::velox::RowTypePtr makeScanOutputType(
-      std::vector<std::string> outputNames);
+  RowTypePtr makeScanOutputType(std::vector<std::string> outputNames);
 
-  std::shared_ptr<facebook::velox::exec::Task> runLookupQuery(
-      const facebook::velox::core::PlanNodePtr& plan,
+  std::shared_ptr<Task> runLookupQuery(
+      const PlanNodePtr& plan,
       int numPrefetchBatches,
       const std::string& duckDbVefifySql);
 
-  std::shared_ptr<facebook::velox::exec::Task> runLookupQuery(
-      const facebook::velox::core::PlanNodePtr& plan,
-      const std::vector<
-          std::shared_ptr<facebook::velox::exec::test::TempFilePath>>&
-          probeFiles,
+  std::shared_ptr<Task> runLookupQuery(
+      const PlanNodePtr& plan,
+      const std::vector<std::shared_ptr<TempFilePath>>& probeFiles,
       bool serialExecution,
       bool barrierExecution,
       int maxBatchRows,
       int numPrefetchBatches,
       const std::string& duckDbVefifySql);
 
-  facebook::velox::RowTypePtr keyType_;
-  std::optional<facebook::velox::RowTypePtr> partitionType_;
-  facebook::velox::RowTypePtr valueType_;
-  facebook::velox::RowTypePtr tableType_;
-  facebook::velox::RowTypePtr probeType_;
-  facebook::velox::core::PlanNodeId joinNodeId_;
-  facebook::velox::core::PlanNodeId indexScanNodeId_;
-  facebook::velox::core::PlanNodeId probeScanNodeId_;
+  /// Verifies the results of the index lookup join query with and without match
+  /// column.
+  void verifyResultWithMatchColumn(
+      const PlanNodePtr& planWithoutMatchColumn,
+      const PlanNodeId& probeScanNodeIdWithoutMatchColumn,
+      const PlanNodePtr& planWithMatchColumn,
+      const PlanNodeId& probeScanNodeIdWithMatchColumn,
+      const std::vector<std::shared_ptr<TempFilePath>>& probeFiles);
+
+  RowTypePtr keyType_;
+  std::optional<RowTypePtr> partitionType_;
+  RowTypePtr valueType_;
+  RowTypePtr tableType_;
+  RowTypePtr probeType_;
+  PlanNodeId joinNodeId_;
+  PlanNodeId indexScanNodeId_;
+  PlanNodeId probeScanNodeId_;
+  folly::Random::DefaultGenerator rng_;
 };
-} // namespace fecebook::velox::exec::test
+} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/LocalExchangeSource.cpp b/velox/exec/tests/utils/LocalExchangeSource.cpp
index ca5545fd5a3f..87cdbc966567 100644
--- a/velox/exec/tests/utils/LocalExchangeSource.cpp
+++ b/velox/exec/tests/utils/LocalExchangeSource.cpp
@@ -17,6 +17,7 @@
 #include <folly/executors/IOThreadPoolExecutor.h>
 #include <atomic>
 #include "velox/common/testutil/TestValue.h"
+#include "velox/exec/Operator.h"
 #include "velox/exec/OutputBufferManager.h"
 
 namespace facebook::velox::exec::test {
@@ -89,7 +90,7 @@ class LocalExchangeSource : public exec::ExchangeSource {
       if (data.empty()) {
         sequence = requestedSequence;
       }
-      std::vector<std::unique_ptr<SerializedPage>> pages;
+      std::vector<std::unique_ptr<SerializedPageBase>> pages;
       bool atEnd = false;
       int64_t totalBytes = 0;
       for (auto& inputPage : data) {
@@ -100,7 +101,8 @@ class LocalExchangeSource : public exec::ExchangeSource {
         }
         totalBytes += inputPage->length();
         inputPage->unshare();
-        pages.push_back(std::make_unique<SerializedPage>(std::move(inputPage)));
+        pages.push_back(
+            std::make_unique<PrestoSerializedPage>(std::move(inputPage)));
         inputPage = nullptr;
       }
       numPages_ += pages.size();
@@ -189,7 +191,7 @@ class LocalExchangeSource : public exec::ExchangeSource {
         {"localExchangeSource.numPages", RuntimeMetric(numPages_)},
         {"localExchangeSource.totalBytes",
          RuntimeMetric(totalBytes_, RuntimeCounter::Unit::kBytes)},
-        {ExchangeClient::kBackgroundCpuTimeMs,
+        {Operator::kBackgroundCpuTimeNanos,
          RuntimeMetric(123 * 1000000, RuntimeCounter::Unit::kNanos)},
     };
   }
@@ -270,7 +272,7 @@ class LocalExchangeSource : public exec::ExchangeSource {
   }
 
   bool checkSetRequestPromise() {
-    VeloxPromise<Response> promise;
+    VeloxPromise<Response> promise{VeloxPromise<Response>::makeEmpty()};
     {
       std::lock_guard<std::mutex> l(queue_->mutex());
       promise = std::move(promise_);
diff --git a/velox/exec/tests/utils/LocalExchangeSource.h b/velox/exec/tests/utils/LocalExchangeSource.h
index 2a69f6343af2..30a9dd60a111 100644
--- a/velox/exec/tests/utils/LocalExchangeSource.h
+++ b/velox/exec/tests/utils/LocalExchangeSource.h
@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 #pragma once
-#include "velox/exec/Exchange.h"
+
+#include "velox/exec/ExchangeSource.h"
 
 namespace facebook::velox::exec::test {
 
diff --git a/velox/exec/tests/utils/LocalRunnerTestBase.cpp b/velox/exec/tests/utils/LocalRunnerTestBase.cpp
deleted file mode 100644
index 398df844ef17..000000000000
--- a/velox/exec/tests/utils/LocalRunnerTestBase.cpp
+++ /dev/null
@@ -1,142 +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/LocalRunnerTestBase.h"
-#include "velox/connectors/hive/HiveConfig.h"
-#include "velox/exec/tests/utils/LocalExchangeSource.h"
-
-namespace facebook::velox::exec::test {
-
-void LocalRunnerTestBase::SetUp() {
-  HiveConnectorTestBase::SetUp();
-  exec::ExchangeSource::factories().clear();
-  exec::ExchangeSource::registerFactory(createLocalExchangeSource);
-  ensureTestData();
-}
-
-std::shared_ptr<core::QueryCtx> LocalRunnerTestBase::makeQueryCtx(
-    const std::string& queryId,
-    memory::MemoryPool* rootPool) {
-  auto& config = config_;
-  auto hiveConfig = hiveConfig_;
-  std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
-      connectorConfigs;
-  connectorConfigs[kHiveConnectorId] =
-      std::make_shared<config::ConfigBase>(std::move(hiveConfig));
-
-  return core::QueryCtx::create(
-      schemaExecutor_.get(),
-      core::QueryConfig(config),
-      std::move(connectorConfigs),
-      cache::AsyncDataCache::getInstance(),
-      rootPool->shared_from_this(),
-      nullptr,
-      queryId);
-}
-
-void LocalRunnerTestBase::ensureTestData() {
-  if (!files_) {
-    makeTables(testTables_, files_);
-  }
-  // Destroy and rebuild the testing connector. The connector will
-  // show the metadata if the connector is wired for metadata.
-  setupConnector();
-}
-
-void LocalRunnerTestBase::setupConnector() {
-  connector::unregisterConnector(kHiveConnectorId);
-
-  std::unordered_map<std::string, std::string> configs;
-  configs[connector::hive::HiveConfig::kLocalDataPath] = testDataPath_;
-  configs[connector::hive::HiveConfig::kLocalFileFormat] = localFileFormat_;
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              kHiveConnectorId,
-              std::make_shared<config::ConfigBase>(std::move(configs)),
-              ioExecutor_.get());
-  connector::registerConnector(hiveConnector);
-}
-
-void LocalRunnerTestBase::makeTables(
-    std::vector<TableSpec> specs,
-    std::shared_ptr<TempDirectoryPath>& directory) {
-  if (initialized_) {
-    return;
-  }
-  initialized_ = true;
-  if (testDataPath_.empty()) {
-    directory = exec::test::TempDirectoryPath::create();
-    testDataPath_ = directory->getPath();
-  }
-  for (auto& spec : specs) {
-    auto tablePath = fmt::format("{}/{}", testDataPath_, spec.name);
-    auto fs = filesystems::getFileSystem(tablePath, {});
-    fs->mkdir(tablePath);
-    for (auto i = 0; i < spec.numFiles; ++i) {
-      auto vectors = HiveConnectorTestBase::makeVectors(
-          spec.columns, spec.numVectorsPerFile, spec.rowsPerVector);
-      if (spec.customizeData) {
-        for (auto& vector : vectors) {
-          spec.customizeData(vector);
-        }
-      }
-      auto filePath = fmt::format("{}/f{}", tablePath, i);
-      tableFilePaths_[spec.name].push_back(filePath);
-      writeToFile(filePath, vectors);
-    }
-  }
-}
-
-std::shared_ptr<runner::SimpleSplitSourceFactory>
-LocalRunnerTestBase::makeSimpleSplitSourceFactory(
-    const runner::MultiFragmentPlanPtr& plan) {
-  std::unordered_map<
-      core::PlanNodeId,
-      std::vector<std::shared_ptr<connector::ConnectorSplit>>>
-      nodeSplitMap;
-  for (auto& fragment : plan->fragments()) {
-    for (auto& scan : fragment.scans) {
-      auto& name = scan->tableHandle()->name();
-      auto files = tableFilePaths_[name];
-      VELOX_CHECK(!files.empty(), "No splits known for {}", name);
-      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
-      for (auto& file : files) {
-        splits.push_back(connector::hive::HiveConnectorSplitBuilder(file)
-                             .connectorId(kHiveConnectorId)
-                             .fileFormat(dwio::common::FileFormat::DWRF)
-                             .build());
-      }
-      nodeSplitMap[scan->id()] = std::move(splits);
-    }
-  };
-  return std::make_shared<runner::SimpleSplitSourceFactory>(
-      std::move(nodeSplitMap));
-}
-
-std::vector<RowVectorPtr> readCursor(
-    std::shared_ptr<runner::LocalRunner> runner) {
-  // 'result' borrows memory from cursor so the life cycle must be shorter.
-  std::vector<RowVectorPtr> result;
-
-  while (auto rows = runner->next()) {
-    result.push_back(rows);
-  }
-  return result;
-}
-
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/LocalRunnerTestBase.h b/velox/exec/tests/utils/LocalRunnerTestBase.h
deleted file mode 100644
index 0303a153d503..000000000000
--- a/velox/exec/tests/utils/LocalRunnerTestBase.h
+++ /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.
- */
-
-#pragma once
-
-#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
-#include "velox/exec/tests/utils/TempDirectoryPath.h"
-#include "velox/runner/LocalRunner.h"
-
-namespace facebook::velox::exec::test {
-
-struct TableSpec {
-  std::string name;
-  RowTypePtr columns;
-  int32_t rowsPerVector{10000};
-  int32_t numVectorsPerFile{5};
-  int32_t numFiles{5};
-
-  /// Function  Applied to generated RowVectors for the table before writing.
-  /// May be used to insert non-random data on top of the random datafrom
-  /// HiveConnectorTestBase::makeVectors.
-  std::function<void(const RowVectorPtr& vector)> customizeData;
-};
-
-/// Test helper class that manages a TestCase with a set of generated
-/// tables and a HiveConnector that exposes the files and their
-/// metadata. The lifetime the test data is the test case consisting
-/// of multiple google unit test cases.
-class LocalRunnerTestBase : public HiveConnectorTestBase {
- protected:
-  static void SetUpTestCase() {
-    HiveConnectorTestBase::SetUpTestCase();
-    schemaExecutor_ = std::make_unique<folly::CPUThreadPoolExecutor>(4);
-  }
-
-  static void TearDownTestCase() {
-    initialized_ = false;
-    files_.reset();
-    HiveConnectorTestBase::TearDownTestCase();
-  }
-
-  void SetUp() override;
-
-  void ensureTestData();
-
-  /// Re-creates the connector with kHiveConnectorId with a config
-  /// that points to the temp directory created by 'this'. If the
-  /// connector factory is wired to capture metadata then the metadata
-  /// will be available through the connector.
-  void setupConnector();
-
-  /// Returns a split source factory that contains splits for the table scans in
-  /// 'plan'. 'plan' should refer to testing tables created by 'this'.
-  std::shared_ptr<runner::SimpleSplitSourceFactory>
-  makeSimpleSplitSourceFactory(const runner::MultiFragmentPlanPtr& plan);
-
-  void makeTables(
-      std::vector<TableSpec> specs,
-      std::shared_ptr<TempDirectoryPath>& directory);
-
-  // Creates a QueryCtx with 'pool'. 'pool' must be a root pool.
-  static std::shared_ptr<core::QueryCtx> makeQueryCtx(
-      const std::string& queryId,
-      memory::MemoryPool* pool);
-
-  // Configs for creating QueryCtx.
-  inline static std::unordered_map<std::string, std::string> config_;
-  inline static std::unordered_map<std::string, std::string> hiveConfig_;
-
-  // The specification of the test data. The data is created in ensureTestData()
-  // called from each SetUp()(.
-  inline static std::vector<TableSpec> testTables_;
-
-  // The top level directory with the test data.
-  inline static bool initialized_;
-  inline static std::string testDataPath_;
-  inline static std::string localFileFormat_{"dwrf"};
-  inline static std::shared_ptr<TempDirectoryPath> files_;
-  /// Map from table name to list of file system paths.
-  inline static std::unordered_map<std::string, std::vector<std::string>>
-      tableFilePaths_;
-  inline static std::unique_ptr<folly::CPUThreadPoolExecutor> schemaExecutor_;
-};
-
-/// Reads all results from 'runner'.
-std::vector<RowVectorPtr> readCursor(
-    std::shared_ptr<runner::LocalRunner> runner);
-
-} // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/MergeTestBase.h b/velox/exec/tests/utils/MergeTestBase.h
index 54d4bdbac700..e20118f8df1a 100644
--- a/velox/exec/tests/utils/MergeTestBase.h
+++ b/velox/exec/tests/utils/MergeTestBase.h
@@ -15,8 +15,9 @@
  */
 
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/TreeOfLosers.h"
 #include "velox/common/time/Timer.h"
-#include "velox/exec/TreeOfLosers.h"
+#include "velox/exec/Spill.h"
 
 #include <folly/Random.h>
 
@@ -100,6 +101,44 @@ class TestingStream final : public MergeStream {
   std::vector<uint32_t> numbers_;
 };
 
+class TestingSpillMergeStream : public SpillMergeStream {
+ public:
+  TestingSpillMergeStream(
+      uint32_t id,
+      const std::vector<SpillSortKey>& sortingKeys,
+      RowVectorPtr rowVector)
+      : id_(id), sortingKeys_(sortingKeys) {
+    rowVector_ = rowVector;
+    size_ = rowVector_->size();
+  }
+
+  uint32_t id() const override {
+    return id_;
+  }
+
+ private:
+  const std::vector<SpillSortKey>& sortingKeys() const override {
+    VELOX_CHECK(!closed_);
+    return sortingKeys_;
+  }
+
+  void nextBatch() override {
+    VELOX_CHECK(!closed_);
+    index_ = 0;
+    size_ = 0;
+    close();
+    rowVector_.reset();
+  }
+
+  void close() override {
+    VELOX_CHECK(!closed_);
+    SpillMergeStream::close();
+  }
+
+  uint32_t id_;
+  const std::vector<SpillSortKey> sortingKeys_;
+};
+
 // Test data for merging.
 struct TestData {
   // Globally sorted sequence of test keys.
diff --git a/velox/exec/tests/utils/OperatorTestBase.cpp b/velox/exec/tests/utils/OperatorTestBase.cpp
index 297010acb4cc..e235f1249057 100644
--- a/velox/exec/tests/utils/OperatorTestBase.cpp
+++ b/velox/exec/tests/utils/OperatorTestBase.cpp
@@ -24,7 +24,6 @@
 #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/CompactRowSerializer.h"
@@ -154,6 +153,7 @@ void OperatorTestBase::SetUp() {
 void OperatorTestBase::TearDown() {
   waitForAllTasksToBeDeleted();
   stopPeriodicStatsReporter();
+  executor_.reset();
   // 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.
diff --git a/velox/exec/tests/utils/PlanBuilder.cpp b/velox/exec/tests/utils/PlanBuilder.cpp
index 1ddf46c61976..b204ba76d265 100644
--- a/velox/exec/tests/utils/PlanBuilder.cpp
+++ b/velox/exec/tests/utils/PlanBuilder.cpp
@@ -17,6 +17,7 @@
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/TableHandle.h"
+#include "velox/connectors/tpcds/TpcdsConnector.h"
 #include "velox/connectors/tpch/TpchConnector.h"
 #include "velox/duckdb/conversion/DuckParser.h"
 #include "velox/exec/Aggregate.h"
@@ -24,9 +25,10 @@
 #include "velox/exec/RoundRobinPartitionFunction.h"
 #include "velox/exec/TableWriter.h"
 #include "velox/exec/WindowFunction.h"
+#include "velox/exec/tests/utils/AggregationResolver.h"
+#include "velox/exec/tests/utils/FilterToExpression.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/ExprToSubfieldFilter.h"
-#include "velox/expression/FunctionCallToSpecialForm.h"
 #include "velox/expression/SignatureBinder.h"
 #include "velox/expression/VectorReaders.h"
 #include "velox/parse/Expressions.h"
@@ -72,16 +74,14 @@ PlanBuilder& PlanBuilder::tableScan(
     const std::vector<std::string>& subfieldFilters,
     const std::string& remainingFilter,
     const RowTypePtr& dataColumns,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& assignments) {
+    const connector::ColumnHandleMap& assignments) {
   return TableScanBuilder(*this)
       .filtersAsNode(filtersAsNode_ ? planNodeIdGenerator_ : nullptr)
       .outputType(outputType)
       .assignments(assignments)
+      .dataColumns(dataColumns)
       .subfieldFilters(subfieldFilters)
       .remainingFilter(remainingFilter)
-      .dataColumns(dataColumns)
       .endTableScan();
 }
 
@@ -92,28 +92,42 @@ PlanBuilder& PlanBuilder::tableScan(
     const std::vector<std::string>& subfieldFilters,
     const std::string& remainingFilter,
     const RowTypePtr& dataColumns,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& assignments) {
+    const connector::ColumnHandleMap& assignments) {
   return TableScanBuilder(*this)
       .filtersAsNode(filtersAsNode_ ? planNodeIdGenerator_ : nullptr)
       .tableName(tableName)
       .outputType(outputType)
       .columnAliases(columnAliases)
+      .dataColumns(dataColumns)
+
       .subfieldFilters(subfieldFilters)
       .remainingFilter(remainingFilter)
-      .dataColumns(dataColumns)
       .assignments(assignments)
       .endTableScan();
 }
 
+PlanBuilder& PlanBuilder::tableScanWithPushDown(
+    const RowTypePtr& outputType,
+    const PushdownConfig& pushdownConfig,
+    const RowTypePtr& dataColumns,
+    const connector::ColumnHandleMap& assignments) {
+  return TableScanBuilder(*this)
+      .filtersAsNode(filtersAsNode_ ? planNodeIdGenerator_ : nullptr)
+      .outputType(outputType)
+      .assignments(assignments)
+      .dataColumns(dataColumns)
+      .subfieldFiltersMap(pushdownConfig.subfieldFiltersMap)
+      .remainingFilter(pushdownConfig.remainingFilter)
+      .endTableScan();
+}
+
 PlanBuilder& PlanBuilder::tpchTableScan(
     tpch::Table table,
     std::vector<std::string> columnNames,
     double scaleFactor,
-    std::string_view connectorId) {
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignmentsMap;
+    std::string_view connectorId,
+    const std::string& filter) {
+  connector::ColumnHandleMap assignmentsMap;
   std::vector<TypePtr> outputTypes;
 
   assignmentsMap.reserve(columnNames.size());
@@ -126,23 +140,150 @@ PlanBuilder& PlanBuilder::tpchTableScan(
     outputTypes.emplace_back(resolveTpchColumn(table, columnName));
   }
   auto rowType = ROW(std::move(columnNames), std::move(outputTypes));
+
+  core::TypedExprPtr filterExpression;
+  if (!filter.empty()) {
+    auto expression = parse::parseExpr(filter, options_);
+    filterExpression =
+        core::Expressions::inferTypes(expression, rowType, pool_);
+  }
+
+  auto tableHandle = std::make_shared<connector::tpch::TpchTableHandle>(
+      std::string(connectorId),
+      table,
+      scaleFactor,
+      std::move(filterExpression));
+
   return TableScanBuilder(*this)
       .filtersAsNode(filtersAsNode_ ? planNodeIdGenerator_ : nullptr)
       .outputType(rowType)
-      .tableHandle(std::make_shared<connector::tpch::TpchTableHandle>(
-          std::string(connectorId), table, scaleFactor))
+      .tableHandle(tableHandle)
       .assignments(assignmentsMap)
       .endTableScan();
 }
 
+PlanBuilder& PlanBuilder::tpcdsTableScan(
+    tpcds::Table table,
+    std::vector<std::string> columnNames,
+    double scaleFactor,
+    std::string_view connectorId) {
+  std::
+      unordered_map<std::string, std::shared_ptr<const 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::tpcds::TpcdsColumnHandle>(columnName));
+    outputTypes.emplace_back(resolveTpcdsColumn(table, columnName));
+  }
+  auto rowType = ROW(std::move(columnNames), std::move(outputTypes));
+  return TableScanBuilder(*this)
+      .outputType(rowType)
+      .tableHandle(
+          std::make_shared<connector::tpcds::TpcdsTableHandle>(
+              std::string(connectorId), table, scaleFactor))
+      .assignments(assignmentsMap)
+      .endTableScan();
+}
+
+namespace {
+
+// Analyzes 'expr' to determine if it can be expressed as a subfield filter.
+// Returns a pair of subfield and filter if so. Otherwise, throws.
+//
+// Supports all expressions supported by
+// exec::ExprToSubfieldFilterParser::leafCallToSubfieldFilter + negations and
+// disjunctions over same subfield.
+//
+//  Examples:
+//    a = 1
+//    a = 1 OR a > 10
+//    not (a = 1)
+std::pair<common::Subfield, std::unique_ptr<common::Filter>> toSubfieldFilter(
+    const core::TypedExprPtr& expr,
+    core::ExpressionEvaluator* evaluator) {
+  if (expr->isCallKind();
+      auto* call = expr->asUnchecked<core::CallTypedExpr>()) {
+    if (call->name() == "or") {
+      VELOX_CHECK_EQ(call->inputs().size(), 2);
+      auto left = toSubfieldFilter(call->inputs()[0], evaluator);
+      auto right = toSubfieldFilter(call->inputs()[1], evaluator);
+      VELOX_CHECK(left.first == right.first);
+      auto filter = exec::ExprToSubfieldFilterParser::makeOrFilter(
+          std::move(left.second), std::move(right.second));
+      VELOX_CHECK_NOT_NULL(filter);
+      return {std::move(left.first), std::move(filter)};
+    }
+
+    if (call->name() == "not") {
+      const auto& input = call->inputs()[0];
+      if (input->isCallKind();
+          auto* inner = input->asUnchecked<core::CallTypedExpr>()) {
+        if (auto result =
+                exec::ExprToSubfieldFilterParser::getInstance()
+                    ->leafCallToSubfieldFilter(*inner, evaluator, true)) {
+          return std::move(result.value());
+        }
+      }
+    } else {
+      if (auto result =
+              exec::ExprToSubfieldFilterParser::getInstance()
+                  ->leafCallToSubfieldFilter(*call, evaluator, false)) {
+        return std::move(result.value());
+      }
+    }
+  }
+  VELOX_UNSUPPORTED(
+      "Unsupported expression for range filter: {}", expr->toString());
+}
+} // namespace
+
 PlanBuilder::TableScanBuilder& PlanBuilder::TableScanBuilder::subfieldFilters(
     std::vector<std::string> subfieldFilters) {
-  subfieldFilters_.clear();
-  subfieldFilters_.reserve(subfieldFilters.size());
+  VELOX_CHECK(subfieldFiltersMap_.empty());
+
+  if (subfieldFilters.empty()) {
+    return *this;
+  }
+
+  // Parse subfield filters
+  auto queryCtx = core::QueryCtx::create();
+  exec::SimpleExpressionEvaluator evaluator(queryCtx.get(), planBuilder_.pool_);
+  const RowTypePtr& parseType = dataColumns_ ? dataColumns_ : outputType_;
 
   for (const auto& filter : subfieldFilters) {
-    subfieldFilters_.emplace_back(
-        parse::parseExpr(filter, planBuilder_.options_));
+    auto untypedExpr = parse::parseExpr(filter, planBuilder_.options_);
+
+    // Parse directly to subfieldFiltersMap_
+    auto filterExpr = core::Expressions::inferTypes(
+        untypedExpr, parseType, planBuilder_.pool_);
+    auto [subfield, subfieldFilter] = toSubfieldFilter(filterExpr, &evaluator);
+
+    auto it = columnAliases_.find(subfield.toString());
+    if (it != columnAliases_.end()) {
+      subfield = common::Subfield(it->second);
+    }
+    VELOX_CHECK_EQ(
+        subfieldFiltersMap_.count(subfield),
+        0,
+        "Duplicate subfield: {}",
+        subfield.toString());
+
+    subfieldFiltersMap_[std::move(subfield)] = std::move(subfieldFilter);
+  }
+  return *this;
+}
+
+PlanBuilder::TableScanBuilder&
+PlanBuilder::TableScanBuilder::subfieldFiltersMap(
+    const common::SubfieldFilters& filtersMap) {
+  for (const auto& [k, v] : filtersMap) {
+    subfieldFiltersMap_[k.clone()] = v->clone();
   }
   return *this;
 }
@@ -155,6 +296,11 @@ PlanBuilder::TableScanBuilder& PlanBuilder::TableScanBuilder::remainingFilter(
   return *this;
 }
 
+PlanBuilder::TableScanBuilder& PlanBuilder::TableScanBuilder::sampleRate(
+    double sampleRate) {
+  sampleRate_ = sampleRate;
+  return *this;
+}
 namespace {
 void addConjunct(
     const core::TypedExprPtr& conjunct,
@@ -163,9 +309,7 @@ void addConjunct(
     conjunction = conjunct;
   } else {
     conjunction = std::make_shared<core::CallTypedExpr>(
-        BOOLEAN(),
-        std::vector<core::TypedExprPtr>{conjunction, conjunct},
-        "and");
+        BOOLEAN(), "and", conjunction, conjunct);
   }
 }
 } // namespace
@@ -198,35 +342,30 @@ core::PlanNodePtr PlanBuilder::TableScanBuilder::build(core::PlanNodeId id) {
     }
   }
 
-  const RowTypePtr& parseType = dataColumns_ ? dataColumns_ : outputType_;
+  RowTypePtr parseType = dataColumns_ ? dataColumns_ : outputType_;
+  if (!filterColumnHandles_.empty()) {
+    auto names = parseType->names();
+    auto types = parseType->children();
+    for (auto& handle : filterColumnHandles_) {
+      if (!parseType->containsChild(handle->name())) {
+        names.push_back(handle->name());
+        types.push_back(handle->hiveType());
+      }
+    }
+    parseType = ROW(std::move(names), std::move(types));
+  }
 
   core::TypedExprPtr filterNodeExpr;
-  common::SubfieldFilters filters;
-  filters.reserve(subfieldFilters_.size());
-  auto queryCtx = core::QueryCtx::create();
-  exec::SimpleExpressionEvaluator evaluator(queryCtx.get(), planBuilder_.pool_);
-
-  for (const auto& filter : subfieldFilters_) {
-    auto filterExpr =
-        core::Expressions::inferTypes(filter, parseType, planBuilder_.pool_);
-    if (filtersAsNode_) {
-      addConjunct(filterExpr, filterNodeExpr);
-    } else {
-      auto [subfield, subfieldFilter] =
-          exec::toSubfieldFilter(filterExpr, &evaluator);
 
-      auto it = columnAliases_.find(subfield.toString());
-      if (it != columnAliases_.end()) {
-        subfield = common::Subfield(it->second);
-      }
-      VELOX_CHECK_EQ(
-          filters.count(subfield),
-          0,
-          "Duplicate subfield: {}",
-          subfield.toString());
+  if (filtersAsNode_) {
+    for (const auto& [subfield, filter] : subfieldFiltersMap_) {
+      auto filterExpr = core::test::filterToExpr(
+          subfield, filter.get(), parseType, planBuilder_.pool_);
 
-      filters[std::move(subfield)] = std::move(subfieldFilter);
+      addConjunct(filterExpr, filterNodeExpr);
     }
+
+    subfieldFiltersMap_.clear();
   }
 
   core::TypedExprPtr remainingFilterExpr;
@@ -245,12 +384,15 @@ core::PlanNodePtr PlanBuilder::TableScanBuilder::build(core::PlanNodeId id) {
         connectorId_,
         tableName_,
         true,
-        std::move(filters),
+        std::move(subfieldFiltersMap_),
         remainingFilterExpr,
-        dataColumns_);
+        dataColumns_,
+        /*tableParameters=*/std::unordered_map<std::string, std::string>{},
+        filterColumnHandles_);
   }
   core::PlanNodePtr result = std::make_shared<core::TableScanNode>(
       id, outputType_, tableHandle_, assignments_);
+
   if (filtersAsNode_ && filterNodeExpr) {
     auto filterId = planNodeIdGenerator_->next();
     result =
@@ -314,32 +456,32 @@ core::PlanNodePtr PlanBuilder::TableWriterBuilder::build(core::PlanNodeId id) {
         std::make_shared<core::InsertTableHandle>(connectorId_, hiveHandle);
   }
 
-  std::shared_ptr<core::AggregationNode> aggregationNode;
+  std::optional<core::ColumnStatsSpec> columnStatsSpec;
   if (!aggregates_.empty()) {
     auto aggregatesAndNames = planBuilder_.createAggregateExpressionsAndNames(
         aggregates_, {}, core::AggregationNode::Step::kPartial);
-    aggregationNode = std::make_shared<core::AggregationNode>(
-        planBuilder_.nextPlanNodeId(),
+    std::vector<core::FieldAccessTypedExprPtr> groupingKeys;
+    groupingKeys.reserve(partitionBy_.size());
+    for (const auto& partitionBy : partitionBy_) {
+      groupingKeys.push_back(
+          std::make_shared<core::FieldAccessTypedExpr>(
+              outputType->findChild(partitionBy), partitionBy));
+    }
+    columnStatsSpec = core::ColumnStatsSpec(
+        std::move(groupingKeys),
         core::AggregationNode::Step::kPartial,
-        std::vector<core::FieldAccessTypedExprPtr>{}, // groupingKeys
-        std::vector<core::FieldAccessTypedExprPtr>{}, // preGroupedKeys
-        aggregatesAndNames.names, // ignoreNullKeys
-        aggregatesAndNames.aggregates,
-        false,
-        upstreamNode);
-    VELOX_CHECK_EQ(
-        aggregationNode->supportsBarrier(), aggregationNode->isPreGrouped());
+        aggregatesAndNames.names,
+        aggregatesAndNames.aggregates);
   }
-
   const auto writeNode = std::make_shared<core::TableWriteNode>(
       id,
       outputType,
       outputType->names(),
-      aggregationNode,
+      columnStatsSpec,
       insertHandle_,
       false,
-      TableWriteTraits::outputType(aggregationNode),
-      connector::CommitStrategy::kNoCommit,
+      TableWriteTraits::outputType(columnStatsSpec),
+      commitStrategy_,
       upstreamNode);
   VELOX_CHECK(!writeNode->supportsBarrier());
   return writeNode;
@@ -393,9 +535,9 @@ parseOrderByClauses(
   std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>> sortingKeys;
   std::vector<core::SortOrder> sortingOrders;
   for (const auto& key : keys) {
-    auto [untypedExpr, sortOrder] = parse::parseOrderByExpr(key);
+    auto orderBy = parse::parseOrderByExpr(key);
     auto typedExpr =
-        core::Expressions::inferTypes(untypedExpr, inputType, pool);
+        core::Expressions::inferTypes(orderBy.expr, inputType, pool);
 
     auto sortingKey =
         std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(typedExpr);
@@ -404,7 +546,7 @@ parseOrderByClauses(
         "ORDER BY clause must use a column name, not an expression: {}",
         key);
     sortingKeys.emplace_back(sortingKey);
-    sortingOrders.emplace_back(sortOrder);
+    sortingOrders.emplace_back(orderBy.ascending, orderBy.nullsFirst);
   }
 
   return {sortingKeys, sortingOrders};
@@ -444,7 +586,7 @@ PlanBuilder& PlanBuilder::projectExpressions(
     } else if (
         auto fieldExpr =
             dynamic_cast<const core::FieldAccessExpr*>(projections[i].get())) {
-      projectNames.push_back(fieldExpr->getFieldName());
+      projectNames.push_back(fieldExpr->name());
     } else {
       projectNames.push_back(fmt::format("p{}", i));
     }
@@ -466,7 +608,7 @@ PlanBuilder& PlanBuilder::projectExpressions(
     expressions.push_back(projections[i]);
     if (auto fieldExpr =
             dynamic_cast<const core::FieldAccessExpr*>(projections[i].get())) {
-      projectNames.push_back(fieldExpr->getFieldName());
+      projectNames.push_back(fieldExpr->name());
     } else {
       projectNames.push_back(fmt::format("p{}", i));
     }
@@ -483,12 +625,79 @@ 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;
+  expressions.reserve(projections.size());
   for (auto i = 0; i < projections.size(); ++i) {
     expressions.push_back(parse::parseExpr(projections[i], options_));
   }
   return projectExpressions(expressions);
 }
 
+PlanBuilder& PlanBuilder::parallelProject(
+    const std::vector<std::vector<std::string>>& projectionGroups,
+    const std::vector<std::string>& noLoadColumns) {
+  VELOX_CHECK_NOT_NULL(planNode_, "ParallelProject cannot be the source node");
+
+  std::vector<std::string> names;
+
+  std::vector<std::vector<core::TypedExprPtr>> exprGroups;
+  exprGroups.reserve(projectionGroups.size());
+
+  size_t i = 0;
+
+  for (const auto& group : projectionGroups) {
+    std::vector<core::TypedExprPtr> typedExprs;
+    typedExprs.reserve(group.size());
+
+    for (const auto& expr : group) {
+      const auto typedExpr = inferTypes(parse::parseExpr(expr, options_));
+      typedExprs.push_back(typedExpr);
+
+      if (auto fieldExpr =
+              dynamic_cast<const core::FieldAccessExpr*>(typedExpr.get())) {
+        names.push_back(fieldExpr->name());
+      } else {
+        names.push_back(fmt::format("p{}", i));
+      }
+
+      ++i;
+    }
+    exprGroups.push_back(std::move(typedExprs));
+  }
+
+  planNode_ = std::make_shared<core::ParallelProjectNode>(
+      nextPlanNodeId(),
+      std::move(names),
+      std::move(exprGroups),
+      noLoadColumns,
+      planNode_);
+
+  return *this;
+}
+
+PlanBuilder& PlanBuilder::lazyDereference(
+    const std::vector<std::string>& projections) {
+  VELOX_CHECK_NOT_NULL(planNode_, "LazyDeference cannot be the source node");
+  std::vector<core::TypedExprPtr> expressions;
+  std::vector<std::string> projectNames;
+  for (auto i = 0; i < projections.size(); ++i) {
+    auto expr = inferTypes(parse::parseExpr(projections[i], options_));
+    expressions.push_back(expr);
+    if (auto* fieldExpr =
+            dynamic_cast<const core::FieldAccessExpr*>(expr.get())) {
+      projectNames.push_back(fieldExpr->name());
+    } else {
+      projectNames.push_back(fmt::format("p{}", i));
+    }
+  }
+  planNode_ = std::make_shared<core::LazyDereferenceNode>(
+      nextPlanNodeId(),
+      std::move(projectNames),
+      std::move(expressions),
+      planNode_);
+  VELOX_CHECK(planNode_->supportsBarrier());
+  return *this;
+}
+
 PlanBuilder& PlanBuilder::appendColumns(
     const std::vector<std::string>& newColumns) {
   VELOX_CHECK_NOT_NULL(planNode_, "Project cannot be the source node");
@@ -507,15 +716,20 @@ PlanBuilder& PlanBuilder::optionalFilter(const std::string& optionalFilter) {
   return filter(optionalFilter);
 }
 
-PlanBuilder& PlanBuilder::filter(const std::string& filter) {
+PlanBuilder& PlanBuilder::filter(const core::ExprPtr& filterExpr) {
   VELOX_CHECK_NOT_NULL(planNode_, "Filter cannot be the source node");
-  auto expr = parseExpr(filter, planNode_->outputType(), options_, pool_);
-  planNode_ =
-      std::make_shared<core::FilterNode>(nextPlanNodeId(), expr, planNode_);
+  auto typedExpr =
+      core::Expressions::inferTypes(filterExpr, planNode_->outputType(), pool_);
+  planNode_ = std::make_shared<core::FilterNode>(
+      nextPlanNodeId(), typedExpr, planNode_);
   VELOX_CHECK(planNode_->supportsBarrier());
   return *this;
 }
 
+PlanBuilder& PlanBuilder::filter(const std::string& filterExpr) {
+  return filter(parse::parseExpr(filterExpr, options_));
+}
+
 PlanBuilder& PlanBuilder::tableWrite(
     const std::string& outputDirectoryPath,
     const dwio::common::FileFormat fileFormat,
@@ -579,7 +793,9 @@ PlanBuilder& PlanBuilder::tableWrite(
     const std::string& outputFileName,
     const common::CompressionKind compressionKind,
     const RowTypePtr& schema,
-    const bool ensureFiles) {
+    const bool ensureFiles,
+    const connector::CommitStrategy commitStrategy,
+    std::shared_ptr<core::InsertTableHandle> insertTableHandle) {
   return TableWriterBuilder(*this)
       .outputDirectoryPath(outputDirectoryPath)
       .outputFileName(outputFileName)
@@ -595,147 +811,74 @@ PlanBuilder& PlanBuilder::tableWrite(
       .options(options)
       .compressionKind(compressionKind)
       .ensureFiles(ensureFiles)
+      .commitStrategy(commitStrategy)
+      .insertHandle(insertTableHandle)
       .endTableWriter();
 }
 
-PlanBuilder& PlanBuilder::tableWriteMerge(
-    const std::shared_ptr<core::AggregationNode>& aggregationNode) {
-  planNode_ = std::make_shared<core::TableWriteMergeNode>(
-      nextPlanNodeId(),
-      TableWriteTraits::outputType(aggregationNode),
-      aggregationNode,
-      planNode_);
-  VELOX_CHECK(!planNode_->supportsBarrier());
-  return *this;
-}
-
 namespace {
-
-std::string throwAggregateFunctionDoesntExist(const std::string& name) {
-  std::stringstream error;
-  error << "Aggregate function doesn't exist: " << name << ".";
-  exec::aggregateFunctions().withRLock([&](const auto& functionsMap) {
-    if (functionsMap.empty()) {
-      error << " Registry of aggregate functions is empty. "
-               "Make sure to register some aggregate functions.";
-    }
-  });
-  VELOX_USER_FAIL(error.str());
-}
-
-std::string throwAggregateFunctionSignatureNotSupported(
-    const std::string& name,
-    const std::vector<TypePtr>& types,
-    const std::vector<std::shared_ptr<AggregateFunctionSignature>>&
-        signatures) {
-  std::stringstream error;
-  error << "Aggregate function signature is not supported: "
-        << toString(name, types)
-        << ". Supported signatures: " << toString(signatures) << ".";
-  VELOX_USER_FAIL(error.str());
-}
-
-TypePtr resolveAggregateType(
-    const std::string& aggregateName,
-    core::AggregationNode::Step step,
-    const std::vector<TypePtr>& rawInputTypes,
-    bool nullOnFailure) {
-  if (auto signatures = exec::getAggregateFunctionSignatures(aggregateName)) {
-    for (const auto& signature : signatures.value()) {
-      exec::SignatureBinder binder(*signature, rawInputTypes);
-      if (binder.tryBind()) {
-        return binder.tryResolveType(
-            exec::isPartialOutput(step) ? signature->intermediateType()
-                                        : signature->returnType());
-      }
+// Finds the table writer source node rooted from 'node'.
+const core::TableWriteNodePtr findTableWrite(const core::PlanNodePtr planNode) {
+  if (auto writer =
+          std::dynamic_pointer_cast<const core::TableWriteNode>(planNode)) {
+    return writer;
+  }
+  for (const auto& source : planNode->sources()) {
+    if (auto writer = findTableWrite(source)) {
+      return writer;
     }
-
-    if (nullOnFailure) {
-      return nullptr;
-    }
-
-    throwAggregateFunctionSignatureNotSupported(
-        aggregateName, rawInputTypes, signatures.value());
-  }
-
-  // We may be parsing lambda expression used in a lambda aggregate function. In
-  // this case, 'aggregateName' would refer to a scalar function.
-  //
-  // TODO Enhance the parser to allow for specifying separate resolver for
-  // lambda expressions.
-  if (auto type =
-          exec::resolveTypeForSpecialForm(aggregateName, rawInputTypes)) {
-    return type;
   }
-
-  if (auto type = parse::resolveScalarFunctionType(
-          aggregateName, rawInputTypes, true)) {
-    return type;
-  }
-
-  if (nullOnFailure) {
-    return nullptr;
-  }
-
-  throwAggregateFunctionDoesntExist(aggregateName);
   return nullptr;
 }
+} // namespace
 
-class AggregateTypeResolver {
- public:
-  explicit AggregateTypeResolver(core::AggregationNode::Step step)
-      : step_(step), previousHook_(core::Expressions::getResolverHook()) {
-    core::Expressions::setTypeResolverHook(
-        [&](const auto& inputs, const auto& expr, bool nullOnFailure) {
-          return resolveType(inputs, expr, nullOnFailure);
-        });
-  }
-
-  ~AggregateTypeResolver() {
-    core::Expressions::setTypeResolverHook(previousHook_);
-  }
-
-  void setRawInputTypes(const std::vector<TypePtr>& types) {
-    rawInputTypes_ = types;
-  }
-
- private:
-  TypePtr resolveType(
-      const std::vector<core::TypedExprPtr>& inputs,
-      const std::shared_ptr<const core::CallExpr>& expr,
-      bool nullOnFailure) const {
-    auto functionName = expr->getFunctionName();
-
-    // Use raw input types (if available) to resolve intermediate and final
-    // result types.
-    if (exec::isRawInput(step_)) {
-      std::vector<TypePtr> types;
-      for (auto& input : inputs) {
-        types.push_back(input->type());
-      }
-
-      return resolveAggregateType(functionName, step_, types, nullOnFailure);
-    }
+PlanBuilder& PlanBuilder::tableWriteMerge() {
+  VELOX_CHECK_NOT_NULL(planNode_, "TableWriteMerge cannot be the source node");
+  auto writer = findTableWrite(planNode_);
+  VELOX_CHECK_NOT_NULL(
+      writer, "TableWriteMerge can only be added after TableWrite node");
 
-    if (!rawInputTypes_.empty()) {
-      return resolveAggregateType(
-          functionName, step_, rawInputTypes_, nullOnFailure);
+  std::optional<core::ColumnStatsSpec> columnStatsSpec;
+  if (writer->hasColumnStatsSpec()) {
+    const auto writerSpec = writer->columnStatsSpec().value();
+    VELOX_CHECK_EQ(
+        writerSpec.aggregationStep, core::AggregationNode::Step::kPartial);
+    std::vector<std::vector<TypePtr>> aggregateRawInputs;
+    const auto numAggregates = writerSpec.aggregates.size();
+    aggregateRawInputs.reserve(numAggregates);
+    for (const auto& aggregate : writerSpec.aggregates) {
+      aggregateRawInputs.push_back(aggregate.rawInputTypes);
     }
-
-    if (!nullOnFailure) {
-      VELOX_USER_FAIL(
-          "Cannot resolve aggregation function return type without raw input types: {}",
-          functionName);
+    const auto& inputType = planNode_->outputType();
+
+    std::vector<std::string> aggregateNames;
+    aggregateNames.reserve(numAggregates);
+    std::vector<core::AggregationNode::Aggregate> aggregates;
+    aggregates.reserve(numAggregates);
+    for (int i = 0; i < numAggregates; ++i) {
+      core::AggregationNode::Aggregate aggregate = writerSpec.aggregates[i];
+      aggregate.call = std::make_shared<core::CallTypedExpr>(
+          aggregate.call->type(),
+          aggregate.call->name(),
+          field(inputType, writerSpec.aggregateNames[i]));
+      aggregates.push_back(std::move(aggregate));
+      aggregateNames.push_back(fmt::format("a{}", i));
     }
-    return nullptr;
+    columnStatsSpec = core::ColumnStatsSpec{
+        writerSpec.groupingKeys,
+        core::AggregationNode::Step::kIntermediate,
+        std::move(aggregateNames),
+        std::move(aggregates)};
   }
 
-  const core::AggregationNode::Step step_;
-  const core::Expressions::TypeResolverHook previousHook_;
-  std::vector<TypePtr> rawInputTypes_;
-};
-
-} // namespace
+  planNode_ = std::make_shared<core::TableWriteMergeNode>(
+      nextPlanNodeId(),
+      TableWriteTraits::outputType(columnStatsSpec),
+      columnStatsSpec,
+      planNode_);
+  VELOX_CHECK(!planNode_->supportsBarrier());
+  return *this;
+}
 
 core::PlanNodePtr PlanBuilder::createIntermediateOrFinalAggregation(
     core::AggregationNode::Step step,
@@ -785,6 +928,7 @@ core::PlanNodePtr PlanBuilder::createIntermediateOrFinalAggregation(
       partialAggNode->aggregateNames(),
       aggregates,
       partialAggNode->ignoreNullKeys(),
+      partialAggNode->noGroupsSpanBatches(),
       planNode_);
   VELOX_CHECK_EQ(
       aggregationNode->supportsBarrier(), aggregationNode->isPreGrouped());
@@ -926,17 +1070,17 @@ PlanBuilder::AggregatesAndNames PlanBuilder::createAggregateExpressionsAndNames(
       }
     }
 
-    for (const auto& [keyExpr, order] : untypedExpr.orderBy) {
+    for (const auto& orderBy : untypedExpr.orderBy) {
       auto sortingKey =
           std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-              inferTypes(keyExpr));
+              inferTypes(orderBy.expr));
       VELOX_CHECK_NOT_NULL(
           sortingKey,
           "ORDER BY clause must use a column name, not an expression: {}",
           aggregate);
 
       agg.sortingKeys.push_back(sortingKey);
-      agg.sortingOrders.push_back(order);
+      agg.sortingOrders.emplace_back(orderBy.ascending, orderBy.nullsFirst);
     }
 
     aggs.emplace_back(agg);
@@ -990,6 +1134,7 @@ PlanBuilder& PlanBuilder::aggregation(
       globalGroupingSets,
       groupId,
       ignoreNullKeys,
+      /*noGroupsSpanBatches=*/false,
       planNode_);
   VELOX_CHECK_EQ(
       aggregationNode->supportsBarrier(), aggregationNode->isPreGrouped());
@@ -1002,7 +1147,8 @@ PlanBuilder& PlanBuilder::streamingAggregation(
     const std::vector<std::string>& aggregates,
     const std::vector<std::string>& masks,
     core::AggregationNode::Step step,
-    bool ignoreNullKeys) {
+    bool ignoreNullKeys,
+    bool noGroupsSpanBatches) {
   auto aggregatesAndNames =
       createAggregateExpressionsAndNames(aggregates, masks, step);
   auto aggregationNode = std::make_shared<core::AggregationNode>(
@@ -1013,6 +1159,7 @@ PlanBuilder& PlanBuilder::streamingAggregation(
       aggregatesAndNames.names,
       aggregatesAndNames.aggregates,
       ignoreNullKeys,
+      noGroupsSpanBatches,
       planNode_);
   VELOX_CHECK_EQ(
       aggregationNode->supportsBarrier(), aggregationNode->isPreGrouped());
@@ -1035,7 +1182,7 @@ PlanBuilder& PlanBuilder::groupId(
         fieldAccessExpr,
         "Grouping key {} is not valid projection",
         groupingKey);
-    std::string inputField = fieldAccessExpr->getFieldName();
+    std::string inputField = fieldAccessExpr->name();
     std::string outputField = untypedExpr->alias().has_value()
         ?
         // This is a projection with a column alias with the format
@@ -1043,7 +1190,7 @@ PlanBuilder& PlanBuilder::groupId(
         untypedExpr->alias().value()
         :
         // This is a projection without a column alias.
-        fieldAccessExpr->getFieldName();
+        fieldAccessExpr->name();
 
     core::GroupIdNode::GroupingKeyInfo keyInfos;
     keyInfos.output = outputField;
@@ -1107,7 +1254,7 @@ PlanBuilder& PlanBuilder::expand(
           auto fieldExpr = dynamic_cast<const core::FieldAccessExpr*>(
               untypedExpression.get());
           VELOX_CHECK_NOT_NULL(fieldExpr);
-          aliases.push_back(fieldExpr->getFieldName());
+          aliases.push_back(fieldExpr->name());
         }
         projectExpr.push_back(typedExpression);
       } else {
@@ -1121,8 +1268,9 @@ PlanBuilder& PlanBuilder::expand(
               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())));
+          projectExpr.push_back(
+              std::make_shared<core::ConstantTypedExpr>(
+                  expectedType, variant::null(expectedType->kind())));
         }
       }
     }
@@ -1181,7 +1329,7 @@ PlanBuilder& PlanBuilder::topN(
 PlanBuilder& PlanBuilder::limit(int64_t offset, int64_t count, bool isPartial) {
   planNode_ = std::make_shared<core::LimitNode>(
       nextPlanNodeId(), offset, count, isPartial, planNode_);
-  VELOX_CHECK(!planNode_->supportsBarrier());
+  VELOX_CHECK(planNode_->supportsBarrier());
   return *this;
 }
 
@@ -1196,7 +1344,7 @@ PlanBuilder& PlanBuilder::assignUniqueId(
     const int32_t taskUniqueId) {
   planNode_ = std::make_shared<core::AssignUniqueIdNode>(
       nextPlanNodeId(), idName, taskUniqueId, planNode_);
-  VELOX_CHECK(!planNode_->supportsBarrier());
+  VELOX_CHECK(planNode_->supportsBarrier());
   return *this;
 }
 
@@ -1673,6 +1821,45 @@ PlanBuilder& PlanBuilder::nestedLoopJoin(
   return *this;
 }
 
+PlanBuilder& PlanBuilder::spatialJoin(
+    const core::PlanNodePtr& right,
+    const std::string& joinCondition,
+    const std::string& probeGeometry,
+    const std::string& buildGeometry,
+    const std::optional<std::string>& radius,
+    const std::vector<std::string>& outputLayout,
+    core::JoinType joinType) {
+  VELOX_CHECK_NOT_NULL(planNode_, "SpatialJoin cannot be the source node");
+  auto probeType = planNode_->outputType();
+  auto buildType = right->outputType();
+  auto resultType = concat(probeType, buildType);
+  auto outputType = extract(resultType, outputLayout);
+
+  VELOX_CHECK(!joinCondition.empty(), "SpatialJoin condition cannot be empty");
+  core::TypedExprPtr joinConditionExpr =
+      parseExpr(joinCondition, resultType, options_, pool_);
+
+  auto probeGeometryField = field(probeType, probeGeometry);
+  auto buildGeometryField = field(buildType, buildGeometry);
+  std::optional<core::FieldAccessTypedExprPtr> radiusField;
+  if (radius.has_value()) {
+    radiusField = field(buildType, radius.value());
+  }
+
+  planNode_ = std::make_shared<core::SpatialJoinNode>(
+      nextPlanNodeId(),
+      joinType,
+      std::move(joinConditionExpr),
+      std::move(probeGeometryField),
+      std::move(buildGeometryField),
+      std::move(radiusField),
+      std::move(planNode_),
+      right,
+      outputType);
+  VELOX_CHECK(!planNode_->supportsBarrier());
+  return *this;
+}
+
 namespace {
 core::TypedExprPtr removeCastTypedExpr(const core::TypedExprPtr& expr) {
   core::TypedExprPtr convertedTypedExpr = expr;
@@ -1853,8 +2040,21 @@ core::IndexLookupConditionPtr PlanBuilder::parseIndexJoinCondition(
         castIndexConditionInputExpr(
             typedCallExpr->inputs()[2], keyColumnExpr->type()));
   }
+
+  if (typedCallExpr->name() == "eq") {
+    VELOX_CHECK_EQ(typedCallExpr->inputs().size(), 2);
+    const auto keyColumnExpr =
+        std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
+            removeCastTypedExpr(typedCallExpr->inputs()[0]));
+    VELOX_CHECK_NOT_NULL(
+        keyColumnExpr, "{}", typedCallExpr->inputs()[0]->toString());
+    return std::make_shared<core::EqualIndexLookupCondition>(
+        keyColumnExpr,
+        castIndexConditionInputExpr(
+            typedCallExpr->inputs()[1], keyColumnExpr->type()));
+  }
   VELOX_USER_FAIL(
-      "Invalid index join condition: {}, and we only support in and between conditions",
+      "Invalid index join condition: {}, and we only support in, between, and equal conditions",
       joinCondition);
 }
 
@@ -1863,12 +2063,20 @@ PlanBuilder& PlanBuilder::indexLookupJoin(
     const std::vector<std::string>& rightKeys,
     const core::TableScanNodePtr& right,
     const std::vector<std::string>& joinConditions,
+    const std::string& filter,
+    bool hasMarker,
     const std::vector<std::string>& outputLayout,
     core::JoinType joinType) {
   VELOX_CHECK_NOT_NULL(planNode_, "indexLookupJoin cannot be the source node");
-  const auto inputType = concat(planNode_->outputType(), right->outputType());
+  auto inputType = concat(planNode_->outputType(), right->outputType());
+  if (hasMarker) {
+    auto names = inputType->names();
+    names.push_back(outputLayout.back());
+    auto types = inputType->children();
+    types.push_back(BOOLEAN());
+    inputType = ROW(std::move(names), std::move(types));
+  }
   auto outputType = extract(inputType, outputLayout);
-
   auto leftKeyFields = fields(planNode_->outputType(), leftKeys);
   auto rightKeyFields = fields(right->outputType(), rightKeys);
 
@@ -1879,12 +2087,20 @@ PlanBuilder& PlanBuilder::indexLookupJoin(
         parseIndexJoinCondition(joinCondition, inputType, pool_));
   }
 
+  // Parse filter expression if provided
+  core::TypedExprPtr filterExpr;
+  if (!filter.empty()) {
+    filterExpr = parseExpr(filter, inputType, options_, pool_);
+  }
+
   planNode_ = std::make_shared<core::IndexLookupJoinNode>(
       nextPlanNodeId(),
       joinType,
       std::move(leftKeyFields),
       std::move(rightKeyFields),
       std::move(joinConditionPtrs),
+      filterExpr,
+      hasMarker,
       std::move(planNode_),
       right,
       std::move(outputType));
@@ -1895,7 +2111,8 @@ PlanBuilder& PlanBuilder::indexLookupJoin(
 PlanBuilder& PlanBuilder::unnest(
     const std::vector<std::string>& replicateColumns,
     const std::vector<std::string>& unnestColumns,
-    const std::optional<std::string>& ordinalColumn) {
+    const std::optional<std::string>& ordinalColumn,
+    const std::optional<std::string>& markerName) {
   VELOX_CHECK_NOT_NULL(planNode_, "Unnest cannot be the source node");
   std::vector<std::shared_ptr<const core::FieldAccessTypedExpr>>
       replicateFields;
@@ -1931,6 +2148,7 @@ PlanBuilder& PlanBuilder::unnest(
       unnestFields,
       unnestNames,
       ordinalColumn,
+      markerName,
       planNode_);
   VELOX_CHECK(planNode_->supportsBarrier());
   return *this;
@@ -2008,7 +2226,7 @@ class WindowTypeResolver {
       types.push_back(input->type());
     }
 
-    auto functionName = expr->getFunctionName();
+    const auto& functionName = expr->name();
 
     return resolveWindowType(functionName, types, nullOnFailure);
   }
@@ -2083,8 +2301,9 @@ parseOrderByKeys(
   std::vector<core::FieldAccessTypedExprPtr> sortingKeys;
   std::vector<core::SortOrder> sortingOrders;
 
-  for (const auto& [untypedExpr, sortOrder] : windowExpr.orderBy) {
-    auto typedExpr = core::Expressions::inferTypes(untypedExpr, inputRow, pool);
+  for (const auto& orderBy : windowExpr.orderBy) {
+    auto typedExpr =
+        core::Expressions::inferTypes(orderBy.expr, inputRow, pool);
     auto sortingKey =
         std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(typedExpr);
     VELOX_CHECK_NOT_NULL(
@@ -2092,7 +2311,7 @@ parseOrderByKeys(
         "ORDER BY clause must use a column name, not an expression: {}",
         windowString);
     sortingKeys.emplace_back(sortingKey);
-    sortingOrders.emplace_back(sortOrder);
+    sortingOrders.emplace_back(orderBy.ascending, orderBy.nullsFirst);
   }
   return {sortingKeys, sortingOrders};
 }
@@ -2243,7 +2462,8 @@ PlanBuilder& PlanBuilder::rowNumber(
   return *this;
 }
 
-PlanBuilder& PlanBuilder::topNRowNumber(
+PlanBuilder& PlanBuilder::topNRank(
+    std::string_view function,
     const std::vector<std::string>& partitionKeys,
     const std::vector<std::string>& sortingKeys,
     int32_t limit,
@@ -2257,6 +2477,7 @@ PlanBuilder& PlanBuilder::topNRowNumber(
   }
   planNode_ = std::make_shared<core::TopNRowNumberNode>(
       nextPlanNodeId(),
+      core::TopNRowNumberNode::rankFunctionFromName(function),
       fields(partitionKeys),
       sortingFields,
       sortingOrders,
@@ -2267,6 +2488,15 @@ PlanBuilder& PlanBuilder::topNRowNumber(
   return *this;
 }
 
+PlanBuilder& PlanBuilder::topNRowNumber(
+    const std::vector<std::string>& partitionKeys,
+    const std::vector<std::string>& sortingKeys,
+    int32_t limit,
+    bool generateRowNumber) {
+  return topNRank(
+      "row_number", partitionKeys, sortingKeys, limit, generateRowNumber);
+}
+
 PlanBuilder& PlanBuilder::markDistinct(
     std::string markerKey,
     const std::vector<std::string>& distinctKeys) {
@@ -2377,4 +2607,51 @@ core::TypedExprPtr PlanBuilder::inferTypes(
   return core::Expressions::inferTypes(
       untypedExpr, planNode_->outputType(), pool_);
 }
+
+core::PlanNodePtr PlanBuilder::IndexLookupJoinBuilder::build(
+    const core::PlanNodeId& id) {
+  VELOX_CHECK_NOT_NULL(
+      planBuilder_.planNode_, "IndexLookupJoin cannot be the source node");
+  auto inputType =
+      concat(planBuilder_.planNode_->outputType(), indexSource_->outputType());
+  if (hasMarker_) {
+    auto names = inputType->names();
+    names.push_back(outputLayout_.back());
+    auto types = inputType->children();
+    types.push_back(BOOLEAN());
+    inputType = ROW(std::move(names), std::move(types));
+  }
+  auto outputType = extract(inputType, outputLayout_);
+  auto leftKeyFields =
+      PlanBuilder::fields(planBuilder_.planNode_->outputType(), leftKeys_);
+  auto rightKeyFields =
+      PlanBuilder::fields(indexSource_->outputType(), rightKeys_);
+
+  std::vector<core::IndexLookupConditionPtr> joinConditionPtrs{};
+  joinConditionPtrs.reserve(joinConditions_.size());
+  for (const auto& joinCondition : joinConditions_) {
+    joinConditionPtrs.push_back(
+        PlanBuilder::parseIndexJoinCondition(
+            joinCondition, inputType, planBuilder_.pool_));
+  }
+
+  // Parse filter expression if provided
+  core::TypedExprPtr filterExpr;
+  if (!filter_.empty()) {
+    filterExpr = parseExpr(
+        filter_, inputType, planBuilder_.options_, planBuilder_.pool_);
+  }
+
+  return std::make_shared<core::IndexLookupJoinNode>(
+      id,
+      joinType_,
+      std::move(leftKeyFields),
+      std::move(rightKeyFields),
+      std::move(joinConditionPtrs),
+      filterExpr,
+      hasMarker_,
+      std::move(planBuilder_.planNode_),
+      indexSource_,
+      std::move(outputType));
+}
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/PlanBuilder.h b/velox/exec/tests/utils/PlanBuilder.h
index 0307d4dcf491..072579380287 100644
--- a/velox/exec/tests/utils/PlanBuilder.h
+++ b/velox/exec/tests/utils/PlanBuilder.h
@@ -20,7 +20,6 @@
 #include <velox/core/ITypedExpr.h>
 #include <velox/core/PlanFragment.h>
 #include <velox/core/PlanNode.h>
-#include "velox/common/memory/Memory.h"
 #include "velox/connectors/hive/HiveDataSink.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/IExpr.h"
@@ -30,8 +29,24 @@ namespace facebook::velox::tpch {
 enum class Table : uint8_t;
 }
 
+namespace facebook::velox::tpcds {
+enum class Table : uint8_t;
+}
+
 namespace facebook::velox::exec::test {
 
+struct AggregationConfig {
+  std::vector<std::string> groupingKeys;
+  std::vector<std::string> aggregates;
+};
+
+struct PushdownConfig {
+  common::SubfieldFilters subfieldFiltersMap;
+  std::string remainingFilter;
+  // Aggregation pushdown configuration
+  std::optional<AggregationConfig> aggregationConfig;
+};
+
 /// A builder class with fluent API for building query plans. Plans are built
 /// bottom up starting with the source node (table scan or similar). Expressions
 /// and orders can be specified using SQL. See filter, project and orderBy
@@ -109,6 +124,8 @@ class PlanBuilder {
 
   static constexpr const std::string_view kHiveDefaultConnectorId{"test-hive"};
   static constexpr const std::string_view kTpchDefaultConnectorId{"test-tpch"};
+  static constexpr const std::string_view kTpcdsDefaultConnectorId{
+      "test-tpcds"};
 
   ///
   /// TableScan
@@ -136,9 +153,7 @@ class PlanBuilder {
       const std::vector<std::string>& subfieldFilters = {},
       const std::string& remainingFilter = "",
       const RowTypePtr& dataColumns = nullptr,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& assignments = {});
+      const connector::ColumnHandleMap& assignments = {});
 
   /// Add a TableScanNode to scan a Hive table.
   ///
@@ -168,9 +183,20 @@ class PlanBuilder {
       const std::vector<std::string>& subfieldFilters = {},
       const std::string& remainingFilter = "",
       const RowTypePtr& dataColumns = nullptr,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& assignments = {});
+      const connector::ColumnHandleMap& assignments = {});
+
+  /// Add a TableScanNode to scan a Hive table with direct SubfieldFilters.
+  ///
+  /// @param outputType List of column names and types to read from the table.
+  /// @param PushdownConfig Contains pushdown configs for the table scan.
+  /// @param dataColumns Optional data columns that may differ from outputType.
+  /// @param assignments Optional ColumnHandles.
+
+  PlanBuilder& tableScanWithPushDown(
+      const RowTypePtr& outputType,
+      const PushdownConfig& pushdownConfig,
+      const RowTypePtr& dataColumns = nullptr,
+      const connector::ColumnHandleMap& assignments = {});
 
   /// Add a TableScanNode to scan a TPC-H table.
   ///
@@ -179,11 +205,27 @@ class PlanBuilder {
   /// @param columnNames The columns to be returned from that table.
   /// @param scaleFactor The TPC-H scale factor.
   /// @param connectorId The TPC-H connector id.
+  /// @param filter Optional SQL expression to filter the data at the connector
+  /// level.
   PlanBuilder& tpchTableScan(
       tpch::Table table,
       std::vector<std::string> columnNames,
       double scaleFactor = 1,
-      std::string_view connectorId = kTpchDefaultConnectorId);
+      std::string_view connectorId = kTpchDefaultConnectorId,
+      const std::string& filter = "");
+
+  /// Add a TableScanNode to scan a TPC-DS table.
+  ///
+  /// @param tpcdsTableHandle The handle that specifies the target TPC-DS table
+  /// and scale factor.
+  /// @param columnNames The columns to be returned from that table.
+  /// @param scaleFactor The TPC-DS scale factor.
+  /// @param connectorId The TPC-DS connector id.
+  PlanBuilder& tpcdsTableScan(
+      tpcds::Table table,
+      std::vector<std::string> columnNames,
+      double scaleFactor = 0.01,
+      std::string_view connectorId = kTpcdsDefaultConnectorId);
 
   /// Helper class to build a custom TableScanNode.
   /// Uses a planBuilder instance to get the next plan id, memory pool, and
@@ -239,6 +281,10 @@ class PlanBuilder {
     /// >  column >= v2
     TableScanBuilder& subfieldFilters(std::vector<std::string> subfieldFilters);
 
+    // @param subfieldFiltersMap A map of Subfield to Filters.
+    TableScanBuilder& subfieldFiltersMap(
+        const common::SubfieldFilters& filtersMap);
+
     /// @param subfieldFilter A single SQL expression to be applied to an
     /// individual column.
     TableScanBuilder& subfieldFilter(std::string subfieldFilter) {
@@ -250,6 +296,8 @@ class PlanBuilder {
     /// AND'ed with all the subfieldFilters.
     TableScanBuilder& remainingFilter(std::string remainingFilter);
 
+    TableScanBuilder& sampleRate(double sampleRate);
+
     /// @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
@@ -272,19 +320,22 @@ class PlanBuilder {
     /// @param tableHandle Optional tableHandle. Other builder arguments such as
     /// the `subfieldFilters` and `remainingFilter` will be ignored.
     TableScanBuilder& tableHandle(
-        std::shared_ptr<connector::ConnectorTableHandle> tableHandle) {
+        connector::ConnectorTableHandlePtr tableHandle) {
       tableHandle_ = std::move(tableHandle);
       return *this;
     }
 
+    TableScanBuilder& filterColumnHandles(
+        std::vector<connector::hive::HiveColumnHandlePtr> filterColumnHandles) {
+      filterColumnHandles_ = std::move(filterColumnHandles);
+      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) {
+    TableScanBuilder& assignments(connector::ColumnHandleMap assignments) {
       assignments_ = std::move(assignments);
       return *this;
     }
@@ -303,19 +354,22 @@ class PlanBuilder {
     std::string tableName_{"hive_table"};
     std::string connectorId_{kHiveDefaultConnectorId};
     RowTypePtr outputType_;
-    std::vector<core::ExprPtr> subfieldFilters_;
     core::ExprPtr remainingFilter_;
+    double sampleRate_{1.0};
     RowTypePtr dataColumns_;
+    std::vector<connector::hive::HiveColumnHandlePtr> filterColumnHandles_;
     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_;
+    connector::ConnectorTableHandlePtr tableHandle_;
+    connector::ColumnHandleMap assignments_;
 
     // produce filters as a FilterNode instead of pushdown.
     bool filtersAsNode_{false};
 
     // Generates the id of a FilterNode if 'filtersAsNode_'.
     std::shared_ptr<core::PlanNodeIdGenerator> planNodeIdGenerator_;
+
+    // SubfieldFilters object containing filters to apply.
+    common::SubfieldFilters subfieldFiltersMap_;
   };
 
   /// Start a TableScanBuilder.
@@ -324,6 +378,91 @@ class PlanBuilder {
     return *tableScanBuilder_;
   }
 
+  /// Helper class to build a custom IndexLookupJoinNode.
+  class IndexLookupJoinBuilder {
+   public:
+    explicit IndexLookupJoinBuilder(PlanBuilder& builder)
+        : planBuilder_(builder) {}
+
+    /// @param leftKeys Join keys from the table scan side, the preceding plan
+    /// node. Cannot be empty.
+    IndexLookupJoinBuilder& leftKeys(std::vector<std::string> leftKeys) {
+      leftKeys_ = std::move(leftKeys);
+      return *this;
+    }
+
+    /// @param rightKeys Join keys from the index lookup side, the plan node
+    /// specified in 'right' parameter. The number and types of left and right
+    /// keys must be the same.
+    IndexLookupJoinBuilder& rightKeys(std::vector<std::string> rightKeys) {
+      rightKeys_ = std::move(rightKeys);
+      return *this;
+    }
+
+    /// @param indexSource The right input source with index lookup support.
+    IndexLookupJoinBuilder& indexSource(
+        const core::TableScanNodePtr& indexSource) {
+      indexSource_ = indexSource;
+      return *this;
+    }
+
+    IndexLookupJoinBuilder& joinConditions(
+        std::vector<std::string> joinConditions) {
+      joinConditions_ = std::move(joinConditions);
+      return *this;
+    }
+
+    IndexLookupJoinBuilder& hasMarker(bool hasMarker) {
+      hasMarker_ = hasMarker;
+      return *this;
+    }
+
+    IndexLookupJoinBuilder& outputLayout(
+        std::vector<std::string> outputLayout) {
+      outputLayout_ = std::move(outputLayout);
+      return *this;
+    }
+
+    /// @param filter SQL expression for the additional join filter. Can
+    /// use columns from both probe and build sides of the join.
+    IndexLookupJoinBuilder& filter(std::string filter) {
+      filter_ = std::move(filter);
+      return *this;
+    }
+
+    /// @param joinType Type of the join supported: inner, left.
+    IndexLookupJoinBuilder& joinType(core::JoinType joinType) {
+      joinType_ = joinType;
+      return *this;
+    }
+
+    /// Stop the IndexLookupJoinBuilder.
+    PlanBuilder& endIndexLookupJoin() {
+      planBuilder_.planNode_ = build(planBuilder_.nextPlanNodeId());
+      return planBuilder_;
+    }
+
+   private:
+    /// Build the plan node IndexLookupJoinNode.
+    core::PlanNodePtr build(const core::PlanNodeId& id);
+
+    PlanBuilder& planBuilder_;
+    std::vector<std::string> leftKeys_;
+    std::vector<std::string> rightKeys_;
+    core::TableScanNodePtr indexSource_;
+    std::vector<std::string> joinConditions_;
+    std::string filter_;
+    bool hasMarker_{false};
+    std::vector<std::string> outputLayout_;
+    core::JoinType joinType_{core::JoinType::kInner};
+  };
+
+  /// Start an IndexLookupJoinBuilder.
+  IndexLookupJoinBuilder& startIndexLookupJoin() {
+    indexLookupJoinBuilder_.reset(new IndexLookupJoinBuilder(*this));
+    return *indexLookupJoinBuilder_;
+  }
+
   ///
   /// TableWriter
   ///
@@ -442,6 +581,15 @@ class PlanBuilder {
       return *this;
     }
 
+    /// Specifies commitStrategy for writing to the connector.
+    /// @param commitStrategy The commit strategy to use for the table write
+    /// operation.
+    TableWriterBuilder& commitStrategy(
+        connector::CommitStrategy commitStrategy) {
+      commitStrategy_ = commitStrategy;
+      return *this;
+    }
+
     /// Stop the TableWriterBuilder.
     PlanBuilder& endTableWriter() {
       planBuilder_.planNode_ = build(planBuilder_.nextPlanNodeId());
@@ -473,6 +621,8 @@ class PlanBuilder {
     common::CompressionKind compressionKind_{common::CompressionKind_NONE};
 
     bool ensureFiles_{false};
+    connector::CommitStrategy commitStrategy_{
+        connector::CommitStrategy::kNoCommit};
   };
 
   /// Start a TableWriterBuilder.
@@ -497,8 +647,8 @@ class PlanBuilder {
       bool parallelizable = false,
       size_t repeatTimes = 1);
 
-  PlanBuilder& filtersAsNode(bool _filtersAsNode) {
-    filtersAsNode_ = _filtersAsNode;
+  PlanBuilder& filtersAsNode(bool filtersAsNode) {
+    filtersAsNode_ = filtersAsNode;
     return *this;
   }
 
@@ -562,6 +712,22 @@ class PlanBuilder {
   /// will produce projected columns named sum_ab, c and p2.
   PlanBuilder& project(const std::vector<std::string>& projections);
 
+  /// Add a ParallelProjectNode using groups of independent SQL expressions.
+  ///
+  /// @param projectionGroups One or more groups of expressions that depend on
+  /// disjunct sets of inputs.
+  /// @param noLoadColumn Optional columns to pass through as is without
+  /// loading. These columns must be distinct from the set of columns used in
+  /// 'projectionGroups'.
+  PlanBuilder& parallelProject(
+      const std::vector<std::vector<std::string>>& projectionGroups,
+      const std::vector<std::string>& noLoadColumns = {});
+
+  /// Add a LazyDereferenceNode to the plan.
+  /// @param projections Same format as in `project`, but can only contain
+  /// field/subfield accesses.
+  PlanBuilder& lazyDereference(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
@@ -573,6 +739,7 @@ class PlanBuilder {
   /// the type.
   PlanBuilder& projectExpressions(
       const std::vector<core::ExprPtr>& projections);
+
   PlanBuilder& projectExpressions(
       const std::vector<core::TypedExprPtr>& projections);
 
@@ -584,7 +751,10 @@ class PlanBuilder {
   /// Add a FilterNode using specified SQL expression.
   ///
   /// @param filter SQL expression of type boolean.
-  PlanBuilder& filter(const std::string& filter);
+  PlanBuilder& filter(const std::string& filterExpr);
+
+  /// Same as above, but takes an untyped expression.
+  PlanBuilder& filter(const core::ExprPtr& filterExpr);
 
   /// Similar to filter() except 'optionalFilter' could be empty and the
   /// function will skip creating a FilterNode in that case.
@@ -675,6 +845,12 @@ class PlanBuilder {
   /// output of the previous operator.
   /// @param ensureFiles When this option is set the HiveDataSink will always
   /// create a file even if there is no data.
+  /// @param commitStrategy The commit strategy to use for the table write
+  /// operation, default is kNoCommit.
+  /// @param insertTableHandle Encapsulates information needed to write data
+  /// to a table through a connector. If not specified, tableWrite will build
+  /// a HiveInsertTableHandle with columnHandles, bucketProperty and
+  /// locationHandle.
   PlanBuilder& tableWrite(
       const std::string& outputDirectoryPath,
       const std::vector<std::string>& partitionBy,
@@ -691,19 +867,21 @@ class PlanBuilder {
       const std::string& outputFileName = "",
       const common::CompressionKind = common::CompressionKind_NONE,
       const RowTypePtr& schema = nullptr,
-      const bool ensureFiles = false);
+      const bool ensureFiles = false,
+      const connector::CommitStrategy commitStrategy =
+          connector::CommitStrategy::kNoCommit,
+      std::shared_ptr<core::InsertTableHandle> insertTableHandle = nullptr);
 
   /// Add a TableWriteMergeNode.
-  PlanBuilder& tableWriteMerge(
-      const std::shared_ptr<core::AggregationNode>& aggregationNode = nullptr);
+  PlanBuilder& tableWriteMerge();
 
   /// Add an AggregationNode representing partial aggregation with the
   /// specified grouping keys, aggregates and optional masks.
   ///
-  /// Aggregates are specified as function calls over unmodified input columns,
-  /// e.g. sum(a), avg(b), min(c). SQL statement AS can be used to specify names
-  /// for the aggregation result columns. In the absence of AS statement, result
-  /// columns are named a0, a1, a2, etc.
+  /// Aggregates are specified as function calls over unmodified input
+  /// columns, e.g. sum(a), avg(b), min(c). SQL statement AS can be used to
+  /// specify names for the aggregation result columns. In the absence of AS
+  /// statement, result columns are named a0, a1, a2, etc.
   ///
   /// For example,
   ///
@@ -713,8 +891,8 @@ class PlanBuilder {
   ///
   ///     partialAggregation({"k1", "k2"}, {"min(a) AS min_a", "max(b)"})
   ///
-  /// will produce output columns k1, k2, min_a and a1, assuming the names of
-  /// the first two input columns are k1 and k2.
+  /// will produce output columns k1, k2, min_a and a1, assuming the names
+  /// of the first two input columns are k1 and k2.
   PlanBuilder& partialAggregation(
       const std::vector<std::string>& groupingKeys,
       const std::vector<std::string>& aggregates,
@@ -871,7 +1049,8 @@ class PlanBuilder {
       const std::vector<std::string>& aggregates,
       const std::vector<std::string>& masks,
       core::AggregationNode::Step step,
-      bool ignoreNullKeys);
+      bool ignoreNullKeys,
+      bool noGroupsSpanBatches = false);
 
   /// Add a GroupIdNode using the specified grouping keys, grouping sets,
   /// aggregation inputs and a groupId column name.
@@ -1147,6 +1326,24 @@ class PlanBuilder {
       const std::vector<std::string>& outputLayout,
       core::JoinType joinType = core::JoinType::kInner);
 
+  /// Add a SpatialJoinNode to join two inputs using spatial join condition.
+  ///
+  /// @param right Right-side input. Typically, to reduce memory usage, the
+  /// smaller input is placed on the right-side.
+  /// @param joinCondition SQL expression as the spatial join condition. Can
+  /// use columns from both probe and build sides of the join.
+  /// @param outputLayout Output layout consisting of columns from probe and
+  /// build sides.
+  /// @param joinType Type of the join: inner (only one supported for now
+  PlanBuilder& spatialJoin(
+      const core::PlanNodePtr& right,
+      const std::string& joinCondition,
+      const std::string& probeGeometry,
+      const std::string& buildGeometry,
+      const std::optional<std::string>& radius,
+      const std::vector<std::string>& outputLayout,
+      core::JoinType joinType = core::JoinType::kInner);
+
   static core::IndexLookupConditionPtr parseIndexJoinCondition(
       const std::string& joinCondition,
       const RowTypePtr& rowType,
@@ -1157,6 +1354,11 @@ class PlanBuilder {
   /// node. Second input is specified in 'right' parameter and must be a
   /// table source with the connector table handle with index lookup support.
   ///
+  /// @param leftKeys Join keys from the probe side, the preceding plan node.
+  /// Cannot be empty.
+  /// @param rightKeys Join keys from the index lookup side, the plan node
+  /// specified in 'right' parameter. The number and types of left and right
+  /// keys must be the same.
   /// @param right The right input source with index lookup support.
   /// @param joinConditions SQL expressions as the join conditions. Each join
   /// condition must use columns from both sides. For the right side, it can
@@ -1169,14 +1371,23 @@ class PlanBuilder {
   /// where "a" is the index column from right side and "b", "c" are either
   /// condition column from left side or a constant but at least one of them
   /// must not be constant. They all have the same type.
+  /// @param filter SQL expression for the additional join filter to apply on
+  /// join results. This supports filters that can't be converted into join
+  /// conditions or lookup conditions. Can be an empty string if no additional
+  /// filter is needed.
+  /// @param hasMarker if true, 'outputLayout' should include a boolean
+  /// column at the end to indicate if a join output row has a match or not.
+  /// This only applies for left join.
+  /// @param outputLayout Output layout consisting of columns from probe and
+  /// build sides.
   /// @param joinType Type of the join supported: inner, left.
-  ///
-  /// See hashJoin method for the description of the other parameters.
   PlanBuilder& indexLookupJoin(
       const std::vector<std::string>& leftKeys,
       const std::vector<std::string>& rightKeys,
       const core::TableScanNodePtr& right,
       const std::vector<std::string>& joinConditions,
+      const std::string& filter,
+      bool hasMarker,
       const std::vector<std::string>& outputLayout,
       core::JoinType joinType = core::JoinType::kInner);
 
@@ -1198,10 +1409,16 @@ class PlanBuilder {
   /// @param ordinalColumn An optional name for the 'ordinal' column to produce.
   /// This column contains the index of the element of the unnested array or
   /// map. If not specified, the output will not contain this column.
+  /// @param markerName An optional name for the marker column to produce.
+  /// This column contains a boolean indicating whether the output row has
+  /// non-empty unnested value. If not specified, the output will not contain
+  /// this column and the unnest operator also skips producing output rows
+  /// with empty unnest value.
   PlanBuilder& unnest(
       const std::vector<std::string>& replicateColumns,
       const std::vector<std::string>& unnestColumns,
-      const std::optional<std::string>& ordinalColumn = std::nullopt);
+      const std::optional<std::string>& ordinalColumn = std::nullopt,
+      const std::optional<std::string>& markerName = std::nullopt);
 
   /// Add a WindowNode to compute one or more windowFunctions.
   /// @param windowFunctions A list of one or more window function SQL like
@@ -1237,14 +1454,23 @@ class PlanBuilder {
       std::optional<int32_t> limit = std::nullopt,
       bool generateRowNumber = true);
 
-  /// Add a TopNRowNumberNode to compute single row_number window function with
-  /// a limit applied to sorted partitions.
+  /// Add a TopNRowNumberNode to compute row_number
+  /// function with a limit applied to sorted partitions.
   PlanBuilder& topNRowNumber(
       const std::vector<std::string>& partitionKeys,
       const std::vector<std::string>& sortingKeys,
       int32_t limit,
       bool generateRowNumber);
 
+  /// Add a TopNRowNumberNode to compute row_number, rank or dense_rank window
+  /// function with a limit applied to sorted partitions.
+  PlanBuilder& topNRank(
+      std::string_view function,
+      const std::vector<std::string>& partitionKeys,
+      const std::vector<std::string>& sortingKeys,
+      int32_t limit,
+      bool generateRowNumber);
+
   /// Add a MarkDistinctNode to compute aggregate mask channel
   /// @param markerKey Name of output mask channel
   /// @param distinctKeys List of columns to be marked distinct.
@@ -1424,6 +1650,7 @@ class PlanBuilder {
   core::PlanNodePtr planNode_;
   parse::ParseOptions options_;
   std::shared_ptr<TableScanBuilder> tableScanBuilder_;
+  std::shared_ptr<IndexLookupJoinBuilder> indexLookupJoinBuilder_;
   std::shared_ptr<TableWriterBuilder> tableWriterBuilder_;
 
  private:
diff --git a/velox/exec/tests/utils/QueryAssertions.cpp b/velox/exec/tests/utils/QueryAssertions.cpp
index 720b4943b78c..9eef2c5a60f3 100644
--- a/velox/exec/tests/utils/QueryAssertions.cpp
+++ b/velox/exec/tests/utils/QueryAssertions.cpp
@@ -20,9 +20,9 @@
 #include "duckdb/common/types.hpp" // @manual
 #include "velox/duckdb/conversion/DuckConversion.h"
 #include "velox/exec/Cursor.h"
-#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/QueryAssertions.h"
-#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Type.h"
+#include "velox/vector/VariantToVector.h"
 #include "velox/vector/VectorTypeUtils.h"
 
 using facebook::velox::duckdb::duckdbTimestampToVelox;
@@ -102,8 +102,9 @@ ::duckdb::Value duckValueAt<TypeKind::INTEGER>(
     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::DATE(
+        ::duckdb::Date::EpochDaysToDate(
+            vector->as<SimpleVector<int32_t>>()->valueAt(index)));
   }
   return ::duckdb::Value(vector->as<SimpleVector<int32_t>>()->valueAt(index));
 }
@@ -218,9 +219,10 @@ ::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())));
+  auto mapType = ::duckdb::ListType::GetChildType(
+      ::duckdb::LogicalType::MAP(
+          duckdb::fromVeloxType(mapKeys->type()),
+          duckdb::fromVeloxType(mapValues->type())));
   if (size == 0) {
     return ::duckdb::Value::MAP(mapType, ::duckdb::vector<::duckdb::Value>());
   }
@@ -276,7 +278,8 @@ variant variantAt<TypeKind::VARBINARY>(
     int32_t row,
     int32_t column) {
   return variant::binary(
-      StringView(::duckdb::StringValue::Get(dataChunk->GetValue(column, row))));
+      std::string(
+          ::duckdb::StringValue::Get(dataChunk->GetValue(column, row))));
 }
 
 template <>
@@ -321,7 +324,7 @@ variant variantAt<TypeKind::VARCHAR>(const ::duckdb::Value& value) {
 
 template <>
 variant variantAt<TypeKind::VARBINARY>(const ::duckdb::Value& value) {
-  return variant::binary(StringView(::duckdb::StringValue::Get(value)));
+  return variant::binary(std::string(::duckdb::StringValue::Get(value)));
 }
 
 variant nullVariant(const TypePtr& type) {
@@ -437,12 +440,14 @@ std::vector<MaterializedRow> materialize(
       } else if (type->isDecimal()) {
         row.push_back(duckdb::decimalVariant(dataChunk->GetValue(j, i)));
       } else if (type->isIntervalDayTime()) {
-        auto value = variant(::duckdb::Interval::GetMicro(
-            dataChunk->GetValue(j, i).GetValue<::duckdb::interval_t>()));
+        auto value = variant(
+            ::duckdb::Interval::GetMicro(
+                dataChunk->GetValue(j, i).GetValue<::duckdb::interval_t>()));
         row.push_back(value);
       } else if (type->isDate()) {
-        auto value = variant(::duckdb::Date::EpochDays(
-            dataChunk->GetValue(j, i).GetValue<::duckdb::date_t>()));
+        auto value = variant(
+            ::duckdb::Date::EpochDays(
+                dataChunk->GetValue(j, i).GetValue<::duckdb::date_t>()));
         row.push_back(value);
       } else {
         auto value = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
@@ -455,93 +460,6 @@ std::vector<MaterializedRow> materialize(
   return rows;
 }
 
-template <TypeKind kind>
-variant variantAt(VectorPtr vector, int32_t row) {
-  using T = typename KindToFlatVector<kind>::WrapperType;
-  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);
-
-variant arrayVariantAt(const VectorPtr& vector, vector_size_t row) {
-  auto arrayVector = vector->wrappedVector()->as<ArrayVector>();
-  auto& elements = arrayVector->elements();
-
-  auto wrappedRow = vector->wrappedIndex(row);
-  auto offset = arrayVector->offsetAt(wrappedRow);
-  auto size = arrayVector->sizeAt(wrappedRow);
-
-  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 variant::array(array);
-}
-
-variant mapVariantAt(const VectorPtr& vector, vector_size_t row) {
-  auto mapVector = vector->wrappedVector()->as<MapVector>();
-  auto& mapKeys = mapVector->mapKeys();
-  auto& mapValues = mapVector->mapValues();
-
-  auto wrappedRow = vector->wrappedIndex(row);
-  auto offset = mapVector->offsetAt(wrappedRow);
-  auto size = mapVector->sizeAt(wrappedRow);
-
-  std::map<variant, variant> map;
-  for (auto i = 0; i < size; i++) {
-    auto innerRow = offset + i;
-    auto key = variantAt(mapKeys, innerRow);
-    auto value = variantAt(mapValues, innerRow);
-    map.insert({key, value});
-  }
-  return variant::map(map);
-}
-
-variant rowVariantAt(const VectorPtr& vector, vector_size_t row) {
-  auto rowValues = vector->wrappedVector()->as<RowVector>();
-  auto wrappedRow = vector->wrappedIndex(row);
-
-  std::vector<variant> values;
-  for (auto& child : rowValues->children()) {
-    values.push_back(variantAt(child, wrappedRow));
-  }
-  return variant::row(std::move(values));
-}
-
-variant variantAt(const VectorPtr& vector, vector_size_t row) {
-  if (vector->isNullAt(row)) {
-    return nullVariant(vector->type());
-  }
-
-  auto typeKind = vector->typeKind();
-  if (typeKind == TypeKind::ROW) {
-    return rowVariantAt(vector, row);
-  }
-
-  if (typeKind == TypeKind::ARRAY) {
-    return arrayVariantAt(vector, row);
-  }
-
-  if (typeKind == TypeKind::MAP) {
-    return mapVariantAt(vector, row);
-  }
-
-  if (isTimestampWithTimeZoneType(vector->type())) {
-    return variant::typeWithCustomComparison<TypeKind::BIGINT>(
-        vector->as<SimpleVector<int64_t>>()->valueAt(row),
-        TIMESTAMP_WITH_TIME_ZONE());
-  }
-
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(variantAt, typeKind, vector, row);
-}
-
 MaterializedRow getColumns(
     const MaterializedRow& row,
     const std::vector<uint32_t>& columnIndices) {
@@ -797,7 +715,7 @@ std::string toTypeString(const MaterializedRow& row) {
     if (i > 0) {
       out << ", ";
     }
-    out << mapTypeKindToName(row[i].kind());
+    out << TypeKindName::toName(row[i].kind());
   }
   out << ")";
   return out.str();
@@ -899,7 +817,7 @@ std::vector<MaterializedRow> materialize(const RowVectorPtr& vector) {
     MaterializedRow row;
     row.reserve(numColumns);
     for (size_t j = 0; j < numColumns; ++j) {
-      row.push_back(variantAt(simpleVectors[j], i));
+      row.push_back(simpleVectors[j]->variantAt(i));
     }
     rows.push_back(row);
   }
@@ -1433,11 +1351,12 @@ std::pair<std::unique_ptr<TaskCursor>, std::vector<RowVectorPtr>> readCursor(
   // 'result' borrows memory from cursor so the life cycle must be shorter.
   std::vector<RowVectorPtr> result;
   auto* task = cursor->task().get();
-
   while (!cursor->noMoreSplits()) {
     addSplits(cursor.get());
     while (cursor->moveNext()) {
-      result.push_back(cursor->current());
+      auto vector = cursor->current();
+      vector->loadedVector();
+      result.push_back(std::move(vector));
       testingMaybeTriggerAbort(task);
     }
   }
@@ -1507,7 +1426,7 @@ bool waitForTaskStateChange(
 void waitForAllTasksToBeDeleted(uint64_t maxWaitUs) {
   uint64_t waitUs = 0;
   while (Task::numRunningTasks() != 0) {
-    constexpr uint64_t kWaitInternalUs = 1'000;
+    constexpr uint64_t kWaitInternalUs = 50'000;
     std::this_thread::sleep_for(std::chrono::microseconds(kWaitInternalUs));
     waitUs += kWaitInternalUs;
     if (waitUs >= maxWaitUs) {
@@ -1529,6 +1448,15 @@ void waitForAllTasksToBeDeleted(uint64_t maxWaitUs) {
       folly::join("\n", pendingTaskStats));
 }
 
+void cancelAllTasks() {
+  std::vector<std::shared_ptr<Task>> pendingTasks = Task::getRunningTasks();
+  for (const auto& task : pendingTasks) {
+    if (task->isRunning()) {
+      task->requestCancel();
+    }
+  }
+}
+
 std::shared_ptr<Task> assertQuery(
     const core::PlanNodePtr& plan,
     std::function<void(exec::TaskCursor*)> addSplits,
diff --git a/velox/exec/tests/utils/QueryAssertions.h b/velox/exec/tests/utils/QueryAssertions.h
index 3acfa88885d0..db766aa1e5bf 100644
--- a/velox/exec/tests/utils/QueryAssertions.h
+++ b/velox/exec/tests/utils/QueryAssertions.h
@@ -221,6 +221,11 @@ bool waitForTaskStateChange(
 /// during this wait call. This is for testing purpose for now.
 void waitForAllTasksToBeDeleted(uint64_t maxWaitUs = 3'000'000);
 
+/// Cancels all currently running tasks across all available task managers.
+/// This is primarily used in testing scenarios to clean up active tasks
+/// and ensure test isolation between test cases.
+void cancelAllTasks();
+
 std::shared_ptr<Task> assertQuery(
     const core::PlanNodePtr& plan,
     const std::string& duckDbSql,
@@ -307,6 +312,13 @@ bool assertEqualResults(
     const core::PlanNodePtr& plan1,
     const core::PlanNodePtr& plan2);
 
+bool assertEqualResults(
+    const MaterializedRowMultiset& expectedRows,
+    const TypePtr& expectedType,
+    const MaterializedRowMultiset& actualRows,
+    const TypePtr& actualType,
+    const std::string& message);
+
 /// Ensure both datasets have the same type and number of rows.
 void assertEqualTypeAndNumRows(
     const TypePtr& expectedType,
diff --git a/velox/exec/tests/utils/RowContainerTestBase.h b/velox/exec/tests/utils/RowContainerTestBase.h
index c9d126fa869e..5bde0826f5b4 100644
--- a/velox/exec/tests/utils/RowContainerTestBase.h
+++ b/velox/exec/tests/utils/RowContainerTestBase.h
@@ -76,7 +76,8 @@ class RowContainerTestBase : public testing::Test,
   std::unique_ptr<RowContainer> makeRowContainer(
       const std::vector<TypePtr>& keyTypes,
       const std::vector<TypePtr>& dependentTypes,
-      bool isJoinBuild = true) {
+      bool isJoinBuild = true,
+      bool useListRowIndex = false) {
     auto container = std::make_unique<RowContainer>(
         keyTypes,
         !isJoinBuild,
@@ -86,6 +87,7 @@ class RowContainerTestBase : public testing::Test,
         isJoinBuild,
         true,
         true,
+        useListRowIndex,
         pool_.get());
     VELOX_CHECK(container->testingMutable());
     return container;
diff --git a/velox/exec/tests/utils/SerializedPageUtil.cpp b/velox/exec/tests/utils/SerializedPageUtil.cpp
index 4316f1a783fa..a498fe5b8c1d 100644
--- a/velox/exec/tests/utils/SerializedPageUtil.cpp
+++ b/velox/exec/tests/utils/SerializedPageUtil.cpp
@@ -20,7 +20,7 @@ using namespace facebook::velox;
 
 namespace facebook::velox::exec::test {
 
-std::unique_ptr<SerializedPage> toSerializedPage(
+std::unique_ptr<SerializedPageBase> toSerializedPage(
     const RowVectorPtr& vector,
     VectorSerde::Kind serdeKind,
     const std::shared_ptr<OutputBufferManager>& bufferManager,
@@ -34,7 +34,8 @@ std::unique_ptr<SerializedPage> toSerializedPage(
   auto listener = bufferManager->newListener();
   IOBufOutputStream stream(*pool, listener.get(), data->size());
   data->flush(&stream);
-  return std::make_unique<SerializedPage>(stream.getIOBuf(), nullptr, size);
+  return std::make_unique<PrestoSerializedPage>(
+      stream.getIOBuf(), nullptr, size);
 }
 
 } // namespace facebook::velox::exec::test
diff --git a/velox/exec/tests/utils/SerializedPageUtil.h b/velox/exec/tests/utils/SerializedPageUtil.h
index 6890693d6345..b074068c3ebd 100644
--- a/velox/exec/tests/utils/SerializedPageUtil.h
+++ b/velox/exec/tests/utils/SerializedPageUtil.h
@@ -23,7 +23,7 @@
 namespace facebook::velox::exec::test {
 
 /// Helper function for serializing RowVector to PrestoPage format.
-std::unique_ptr<SerializedPage> toSerializedPage(
+std::unique_ptr<SerializedPageBase> toSerializedPage(
     const RowVectorPtr& vector,
     VectorSerde::Kind serdeKind,
     const std::shared_ptr<OutputBufferManager>& bufferManager,
diff --git a/velox/exec/tests/utils/TableScanTestBase.cpp b/velox/exec/tests/utils/TableScanTestBase.cpp
index ef571d75b6d3..394020fe1b5a 100644
--- a/velox/exec/tests/utils/TableScanTestBase.cpp
+++ b/velox/exec/tests/utils/TableScanTestBase.cpp
@@ -15,7 +15,6 @@
  */
 
 #include "velox/exec/tests/utils/TableScanTestBase.h"
-
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/LocalExchangeSource.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -159,7 +158,7 @@ void TableScanTestBase::testPartitionedTableImpl(
                    .build();
   auto outputType =
       ROW({"pkey", "c0", "c1"}, {partitionType, BIGINT(), DOUBLE()});
-  ColumnHandleMap assignments = {
+  connector::ColumnHandleMap assignments = {
       {"pkey", partitionKey("pkey", partitionType)},
       {"c0", regularColumn("c0", BIGINT())},
       {"c1", regularColumn("c1", DOUBLE())}};
diff --git a/velox/exec/tests/utils/TableScanTestBase.h b/velox/exec/tests/utils/TableScanTestBase.h
index b51f629a49d8..f7e2929f2847 100644
--- a/velox/exec/tests/utils/TableScanTestBase.h
+++ b/velox/exec/tests/utils/TableScanTestBase.h
@@ -20,6 +20,7 @@
 #include <folly/experimental/EventCount.h>
 #include <folly/synchronization/Baton.h>
 #include <folly/synchronization/Latch.h>
+#include "velox/connectors/hive/FileHandle.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/type/Type.h"
diff --git a/velox/exec/tests/utils/TableWriterTestBase.cpp b/velox/exec/tests/utils/TableWriterTestBase.cpp
index ebf2eb1f0599..6ec932f748db 100644
--- a/velox/exec/tests/utils/TableWriterTestBase.cpp
+++ b/velox/exec/tests/utils/TableWriterTestBase.cpp
@@ -42,7 +42,7 @@ CompressionKind TableWriterTestBase::TestParam::compressionKind() const {
 }
 
 bool TableWriterTestBase::TestParam::multiDrivers() const {
-  return (value >> 40) != 0;
+  return (value & (1L << 40)) != 0;
 }
 
 FileFormat TableWriterTestBase::TestParam::fileFormat() const {
@@ -71,10 +71,10 @@ bool TableWriterTestBase::TestParam::scaleWriter() const {
 
 std::string TableWriterTestBase::TestParam::toString() const {
   return fmt::format(
-      "FileFormat[{}] TestMode[{}] commitStrategy[{}] bucketKind[{}] bucketSort[{}] multiDrivers[{}] compression[{}] scaleWriter[{}]",
+      "FileFormat_{}_TestMode_{}_commitStrategy_{}_bucketKind_{}_bucketSort_{}_multiDrivers_{}_compression_{}_scaleWriter_{}",
       dwio::common::toString((fileFormat())),
       testModeString(testMode()),
-      commitStrategyToString(commitStrategy()),
+      CommitStrategyName::toName(commitStrategy()),
       HiveBucketProperty::kindString(bucketKind()),
       bucketSort(),
       multiDrivers(),
@@ -91,35 +91,26 @@ std::string TableWriterTestBase::testModeString(TestMode mode) {
     case TestMode::kBucketed:
       return "BUCKETED";
     case TestMode::kOnlyBucketed:
-      return "BUCKETED (NOT PARTITIONED)";
+      return "BUCKETED_WITHOUT_PARTITION";
   }
   VELOX_UNREACHABLE();
 }
 
 // static
-std::shared_ptr<core::AggregationNode>
-TableWriterTestBase::generateAggregationNode(
+core::ColumnStatsSpec TableWriterTestBase::generateColumnStatsSpec(
     const std::string& name,
     const std::vector<core::FieldAccessTypedExprPtr>& groupingKeys,
-    AggregationNode::Step step,
-    const PlanNodePtr& source) {
+    AggregationNode::Step step) {
   core::TypedExprPtr inputField =
       std::make_shared<const core::FieldAccessTypedExpr>(BIGINT(), name);
-  auto callExpr = std::make_shared<const core::CallTypedExpr>(
-      BIGINT(), std::vector<core::TypedExprPtr>{inputField}, "min");
+  auto callExpr =
+      std::make_shared<const core::CallTypedExpr>(BIGINT(), "min", inputField);
   std::vector<std::string> aggregateNames = {"min"};
   std::vector<core::AggregationNode::Aggregate> aggregates = {
       core::AggregationNode::Aggregate{
           callExpr, {{BIGINT()}}, nullptr, {}, {}}};
-  return std::make_shared<core::AggregationNode>(
-      core::PlanNodeId(),
-      step,
-      groupingKeys,
-      std::vector<core::FieldAccessTypedExprPtr>{},
-      aggregateNames,
-      aggregates,
-      false, // ignoreNullKeys
-      source);
+  return core::ColumnStatsSpec{
+      std::move(groupingKeys), step, aggregateNames, aggregates};
 }
 
 // static.
@@ -127,7 +118,7 @@ std::function<PlanNodePtr(std::string, PlanNodePtr)>
 TableWriterTestBase::addTableWriter(
     const RowTypePtr& inputColumns,
     const std::vector<std::string>& tableColumnNames,
-    const std::shared_ptr<core::AggregationNode>& aggregationNode,
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec,
     const std::shared_ptr<core::InsertTableHandle>& insertHandle,
     bool hasPartitioningScheme,
     connector::CommitStrategy commitStrategy) {
@@ -137,10 +128,10 @@ TableWriterTestBase::addTableWriter(
         nodeId,
         inputColumns,
         tableColumnNames,
-        aggregationNode,
+        columnStatsSpec,
         insertHandle,
         hasPartitioningScheme,
-        TableWriteTraits::outputType(aggregationNode),
+        TableWriteTraits::outputType(columnStatsSpec),
         commitStrategy,
         std::move(source));
   };
@@ -408,8 +399,9 @@ TableWriterTestBase::makeHiveConnectorSplits(const std::string& directoryPath) {
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
     if (path.is_regular_file()) {
-      splits.push_back(HiveConnectorTestBase::makeHiveConnectorSplits(
-          path.path().string(), 1, fileFormat_)[0]);
+      splits.push_back(
+          HiveConnectorTestBase::makeHiveConnectorSplits(
+              path.path().string(), 1, fileFormat_)[0]);
     }
   }
   return splits;
@@ -435,8 +427,9 @@ TableWriterTestBase::makeHiveConnectorSplits(
     const std::vector<std::filesystem::path>& filePaths) {
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   for (const auto& filePath : filePaths) {
-    splits.push_back(HiveConnectorTestBase::makeHiveConnectorSplits(
-        filePath.string(), 1, fileFormat_)[0]);
+    splits.push_back(
+        HiveConnectorTestBase::makeHiveConnectorSplits(
+            filePath.string(), 1, fileFormat_)[0]);
   }
   return splits;
 }
@@ -550,7 +543,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlan(
     const connector::hive::LocationHandle::TableType& outputTableType,
     const CommitStrategy& outputCommitStrategy,
     bool aggregateResult,
-    std::shared_ptr<core::AggregationNode> aggregationNode) {
+    const std::optional<ColumnStatsSpec>& columnStatsSpec) {
   return createInsertPlan(
       inputPlan,
       inputPlan.planNode()->outputType(),
@@ -563,7 +556,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlan(
       outputTableType,
       outputCommitStrategy,
       aggregateResult,
-      aggregationNode);
+      columnStatsSpec);
 }
 
 PlanNodePtr TableWriterTestBase::createInsertPlan(
@@ -578,7 +571,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlan(
     const connector::hive::LocationHandle::TableType& outputTableType,
     const CommitStrategy& outputCommitStrategy,
     bool aggregateResult,
-    std::shared_ptr<core::AggregationNode> aggregationNode) {
+    const std::optional<ColumnStatsSpec>& columnStatsSpec) {
   if (numTableWriters == 1) {
     return createInsertPlanWithSingleWriter(
         inputPlan,
@@ -591,7 +584,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlan(
         outputTableType,
         outputCommitStrategy,
         aggregateResult,
-        aggregationNode);
+        columnStatsSpec);
   } else if (bucketProperty_ == nullptr) {
     return createInsertPlanWithForNonBucketedTable(
         inputPlan,
@@ -603,7 +596,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlan(
         outputTableType,
         outputCommitStrategy,
         aggregateResult,
-        aggregationNode);
+        columnStatsSpec);
   } else {
     return createInsertPlanForBucketTable(
         inputPlan,
@@ -616,7 +609,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlan(
         outputTableType,
         outputCommitStrategy,
         aggregateResult,
-        aggregationNode);
+        columnStatsSpec);
   }
 }
 
@@ -631,7 +624,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlanWithSingleWriter(
     const connector::hive::LocationHandle::TableType& outputTableType,
     const CommitStrategy& outputCommitStrategy,
     bool aggregateResult,
-    std::shared_ptr<core::AggregationNode> aggregationNode) {
+    std::optional<ColumnStatsSpec> columnStatsSpec) {
   const bool addScaleWriterExchange =
       scaleWriter_ && (bucketProperty != nullptr);
   auto insertPlan = inputPlan;
@@ -647,7 +640,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlanWithSingleWriter(
       .addNode(addTableWriter(
           inputRowType,
           tableRowType->names(),
-          aggregationNode,
+          columnStatsSpec,
           createInsertTableHandle(
               tableRowType,
               outputTableType,
@@ -658,14 +651,6 @@ PlanNodePtr TableWriterTestBase::createInsertPlanWithSingleWriter(
           false,
           outputCommitStrategy))
       .capturePlanNodeId(tableWriteNodeId_);
-  if (addScaleWriterExchange) {
-    if (!partitionedBy.empty()) {
-      insertPlan.scaleWriterlocalPartition(
-          inputColumnNames(partitionedBy, tableRowType, inputRowType));
-    } else {
-      insertPlan.scaleWriterlocalPartitionRoundRobin();
-    }
-  }
   if (aggregateResult) {
     insertPlan.project({TableWriteTraits::rowCountColumnName()})
         .singleAggregation(
@@ -686,7 +671,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlanForBucketTable(
     const connector::hive::LocationHandle::TableType& outputTableType,
     const CommitStrategy& outputCommitStrategy,
     bool aggregateResult,
-    std::shared_ptr<core::AggregationNode> aggregationNode) {
+    std::optional<ColumnStatsSpec> columnStatsSpec) {
   // Since we might do column rename, so generate bucket property based on
   // the data type from 'inputPlan'.
   std::vector<std::string> bucketColumns;
@@ -706,7 +691,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlanForBucketTable(
           .addNode(addTableWriter(
               inputRowType,
               tableRowType->names(),
-              nullptr,
+              std::nullopt,
               createInsertTableHandle(
                   tableRowType,
                   outputTableType,
@@ -752,7 +737,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlanWithForNonBucketedTable(
     const connector::hive::LocationHandle::TableType& outputTableType,
     const CommitStrategy& outputCommitStrategy,
     bool aggregateResult,
-    std::shared_ptr<core::AggregationNode> aggregationNode) {
+    std::optional<ColumnStatsSpec> columnStatsSpec) {
   auto insertPlan = inputPlan;
   if (scaleWriter_) {
     if (!partitionedBy.empty()) {
@@ -766,7 +751,7 @@ PlanNodePtr TableWriterTestBase::createInsertPlanWithForNonBucketedTable(
       .addNode(addTableWriter(
           inputRowType,
           tableRowType->names(),
-          nullptr,
+          std::nullopt,
           createInsertTableHandle(
               tableRowType,
               outputTableType,
@@ -798,9 +783,10 @@ std::string TableWriterTestBase::partitionNameToPredicate(
   for (auto i = 0; i < partitionKeyValues.size(); ++i) {
     if (partitionTypes[i]->isVarchar() || partitionTypes[i]->isVarbinary() ||
         partitionTypes[i]->isDate()) {
-      conjuncts.push_back(partitionKeyValues[i]
-                              .replace(partitionKeyValues[i].find("="), 1, "='")
-                              .append("'"));
+      conjuncts.push_back(
+          partitionKeyValues[i]
+              .replace(partitionKeyValues[i].find("="), 1, "='")
+              .append("'"));
     } else {
       conjuncts.push_back(partitionKeyValues[i]);
     }
@@ -816,9 +802,10 @@ std::string TableWriterTestBase::partitionNameToPredicate(
   for (auto i = 0; i < partitionDirNames.size(); ++i) {
     if (partitionTypes_[i]->isVarchar() || partitionTypes_[i]->isVarbinary() ||
         partitionTypes_[i]->isDate()) {
-      conjuncts.push_back(partitionKeyValues[i]
-                              .replace(partitionKeyValues[i].find("="), 1, "='")
-                              .append("'"));
+      conjuncts.push_back(
+          partitionKeyValues[i]
+              .replace(partitionKeyValues[i].find("="), 1, "='")
+              .append("'"));
     } else {
       conjuncts.push_back(partitionDirNames[i]);
     }
@@ -831,20 +818,22 @@ void TableWriterTestBase::verifyUnbucketedFilePath(
     const std::string& targetDir) {
   ASSERT_EQ(filePath.parent_path().string(), targetDir);
   if (commitStrategy_ == CommitStrategy::kNoCommit) {
-    ASSERT_TRUE(RE2::FullMatch(
-        filePath.filename().string(),
-        fmt::format(
-            "test_cursor.+_[0-{}]_{}_.+",
-            numTableWriterCount_ - 1,
-            tableWriteNodeId_)))
+    ASSERT_TRUE(
+        RE2::FullMatch(
+            filePath.filename().string(),
+            fmt::format(
+                "test_cursor.+_[0-{}]_{}_.+",
+                numTableWriterCount_ - 1,
+                tableWriteNodeId_)))
         << filePath.filename().string();
   } else {
-    ASSERT_TRUE(RE2::FullMatch(
-        filePath.filename().string(),
-        fmt::format(
-            ".tmp.velox.test_cursor.+_[0-{}]_{}_.+",
-            numTableWriterCount_ - 1,
-            tableWriteNodeId_)))
+    ASSERT_TRUE(
+        RE2::FullMatch(
+            filePath.filename().string(),
+            fmt::format(
+                ".tmp.velox.test_cursor.+_[0-{}]_{}_.+",
+                numTableWriterCount_ - 1,
+                tableWriteNodeId_)))
         << filePath.filename().string();
   }
 }
@@ -860,25 +849,29 @@ void TableWriterTestBase::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$"))
+      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]+"))
+      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$"))
+      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]+_.+"))
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(),
+              ".tmp.velox.0[0-9]+_0_TaskCursorQuery_[0-9]+_.+"))
           << filePath.filename().string();
     }
   }
diff --git a/velox/exec/tests/utils/TableWriterTestBase.h b/velox/exec/tests/utils/TableWriterTestBase.h
index a98e4e44d722..f0c71f92beee 100644
--- a/velox/exec/tests/utils/TableWriterTestBase.h
+++ b/velox/exec/tests/utils/TableWriterTestBase.h
@@ -105,7 +105,7 @@ class TableWriterTestBase : public HiveConnectorTestBase {
   static std::function<PlanNodePtr(std::string, PlanNodePtr)> addTableWriter(
       const RowTypePtr& inputColumns,
       const std::vector<std::string>& tableColumnNames,
-      const std::shared_ptr<core::AggregationNode>& aggregationNode,
+      const std::optional<core::ColumnStatsSpec>& columnStatsSpec,
       const std::shared_ptr<core::InsertTableHandle>& insertHandle,
       bool hasPartitioningScheme,
       connector::CommitStrategy commitStrategy =
@@ -115,11 +115,10 @@ class TableWriterTestBase : public HiveConnectorTestBase {
       const std::vector<std::string>& partitionedKeys,
       const RowTypePtr& rowType);
 
-  static std::shared_ptr<core::AggregationNode> generateAggregationNode(
+  static core::ColumnStatsSpec generateColumnStatsSpec(
       const std::string& name,
       const std::vector<core::FieldAccessTypedExprPtr>& groupingKeys,
-      AggregationNode::Step step,
-      const PlanNodePtr& source);
+      AggregationNode::Step step);
 
   std::shared_ptr<Task> assertQueryWithWriterConfigs(
       const core::PlanNodePtr& plan,
@@ -207,7 +206,7 @@ class TableWriterTestBase : public HiveConnectorTestBase {
           connector::hive::LocationHandle::TableType::kNew,
       const CommitStrategy& outputCommitStrategy = CommitStrategy::kNoCommit,
       bool aggregateResult = true,
-      std::shared_ptr<core::AggregationNode> aggregationNode = nullptr);
+      const std::optional<ColumnStatsSpec>& columnStatsSpec = std::nullopt);
 
   PlanNodePtr createInsertPlan(
       PlanBuilder& inputPlan,
@@ -222,7 +221,7 @@ class TableWriterTestBase : public HiveConnectorTestBase {
           connector::hive::LocationHandle::TableType::kNew,
       const CommitStrategy& outputCommitStrategy = CommitStrategy::kNoCommit,
       bool aggregateResult = true,
-      std::shared_ptr<core::AggregationNode> aggregationNode = nullptr);
+      const std::optional<ColumnStatsSpec>& columnStatsSpec = std::nullopt);
 
   PlanNodePtr createInsertPlanWithSingleWriter(
       PlanBuilder& inputPlan,
@@ -235,7 +234,7 @@ class TableWriterTestBase : public HiveConnectorTestBase {
       const connector::hive::LocationHandle::TableType& outputTableType,
       const CommitStrategy& outputCommitStrategy,
       bool aggregateResult,
-      std::shared_ptr<core::AggregationNode> aggregationNode);
+      std::optional<ColumnStatsSpec> columnStatsSpec);
 
   PlanNodePtr createInsertPlanForBucketTable(
       PlanBuilder& inputPlan,
@@ -248,7 +247,7 @@ class TableWriterTestBase : public HiveConnectorTestBase {
       const connector::hive::LocationHandle::TableType& outputTableType,
       const CommitStrategy& outputCommitStrategy,
       bool aggregateResult,
-      std::shared_ptr<core::AggregationNode> aggregationNode);
+      std::optional<ColumnStatsSpec> columnStatsSpec);
 
   // Return the corresponding column names in 'inputRowType' of
   // 'tableColumnNames' from 'tableRowType'.
@@ -267,7 +266,7 @@ class TableWriterTestBase : public HiveConnectorTestBase {
       const connector::hive::LocationHandle::TableType& outputTableType,
       const CommitStrategy& outputCommitStrategy,
       bool aggregateResult,
-      std::shared_ptr<core::AggregationNode> aggregationNode);
+      std::optional<ColumnStatsSpec> columnStatsSpec);
 
   // Parameter partitionName is string formatted in the Hive style
   // key1=value1/key2=value2/... Parameter partitionTypes are types of partition
diff --git a/velox/exec/tests/utils/TestIndexStorageConnector.cpp b/velox/exec/tests/utils/TestIndexStorageConnector.cpp
index 3dfdfe04e3b2..2dc3eb1a0ee6 100644
--- a/velox/exec/tests/utils/TestIndexStorageConnector.cpp
+++ b/velox/exec/tests/utils/TestIndexStorageConnector.cpp
@@ -25,15 +25,90 @@
 
 using facebook::velox::common::testutil::TestValue;
 namespace facebook::velox::exec::test {
+
+// static
+std::shared_ptr<TestIndexTable> TestIndexTable::create(
+    size_t numEqualJoinKeys,
+    const RowVectorPtr& keyData,
+    const RowVectorPtr& valueData,
+    velox::memory::MemoryPool& pool) {
+  VELOX_CHECK_GE(numEqualJoinKeys, 1);
+  VELOX_CHECK_NOT_NULL(keyData);
+  VELOX_CHECK_NOT_NULL(valueData);
+
+  auto keyType = asRowType(keyData->type());
+  VELOX_CHECK_GE(keyType->size(), numEqualJoinKeys);
+
+  auto valueType = asRowType(valueData->type());
+  VELOX_CHECK_GE(valueType->size(), 1);
+
+  const auto numRows = keyData->size();
+  VELOX_CHECK_EQ(numRows, valueData->size());
+
+  std::vector<std::unique_ptr<VectorHasher>> hashers;
+  hashers.reserve(numEqualJoinKeys);
+  std::vector<VectorPtr> keyVectors;
+  keyVectors.reserve(numEqualJoinKeys);
+  for (auto i = 0; i < numEqualJoinKeys; ++i) {
+    hashers.push_back(std::make_unique<VectorHasher>(keyType->childAt(i), i));
+    keyVectors.push_back(keyData->childAt(i));
+  }
+
+  std::vector<TypePtr> dependentTypes;
+  std::vector<VectorPtr> dependentVectors;
+  for (auto i = numEqualJoinKeys; i < keyType->size(); ++i) {
+    dependentTypes.push_back(keyType->childAt(i));
+    dependentVectors.push_back(keyData->childAt(i));
+  }
+
+  for (auto i = 0; i < valueType->size(); ++i) {
+    dependentTypes.push_back(valueType->childAt(i));
+    dependentVectors.push_back(valueData->childAt(i));
+  }
+
+  // Create the table.
+  auto table = HashTable<false>::createForJoin(
+      std::move(hashers),
+      /*dependentTypes=*/dependentTypes,
+      /*allowDuplicates=*/true,
+      /*hasProbedFlag=*/false,
+      /*minTableSizeForParallelJoinBuild=*/1,
+      &pool);
+
+  // Insert data into the row container.
+  auto* rowContainer = table->rows();
+  std::vector<DecodedVector> decodedVectors;
+  for (auto& vector : keyData->children()) {
+    decodedVectors.emplace_back(*vector);
+  }
+  for (auto& vector : valueData->children()) {
+    decodedVectors.emplace_back(*vector);
+  }
+
+  const auto nextOffset = rowContainer->nextOffset();
+  VELOX_CHECK_GT(nextOffset, 0);
+  for (auto row = 0; row < numRows; ++row) {
+    auto* newRow = rowContainer->newRow();
+    *reinterpret_cast<char**>(newRow + nextOffset) = nullptr;
+    for (auto col = 0; col < decodedVectors.size(); ++col) {
+      rowContainer->store(decodedVectors[col], row, newRow, col);
+    }
+  }
+
+  // Build the table index.
+  table->prepareJoinTable(
+      {}, BaseHashTable::kNoSpillInputStartPartitionBit, 1'000'000);
+  return std::make_shared<TestIndexTable>(
+      std::move(keyType), std::move(valueType), std::move(table));
+}
+
 namespace {
 core::TypedExprPtr toJoinConditionExpr(
     const std::vector<std::shared_ptr<core::IndexLookupCondition>>&
         joinConditions,
     const std::shared_ptr<TestIndexTable>& indexTable,
     const RowTypePtr& inputType,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& columnHandles) {
+    const connector::ColumnHandleMap& columnHandles) {
   if (joinConditions.empty()) {
     return nullptr;
   }
@@ -46,23 +121,35 @@ core::TypedExprPtr toJoinConditionExpr(
     if (auto inCondition =
             std::dynamic_pointer_cast<core::InIndexLookupCondition>(
                 condition)) {
-      conditionExprs.push_back(std::make_shared<const core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
-              inCondition->list, std::move(indexColumnExpr)},
-          "contains"));
+      conditionExprs.push_back(
+          std::make_shared<const core::CallTypedExpr>(
+              BOOLEAN(),
+              "contains",
+              inCondition->list,
+              std::move(indexColumnExpr)));
       continue;
     }
     if (auto betweenCondition =
             std::dynamic_pointer_cast<core::BetweenIndexLookupCondition>(
                 condition)) {
-      conditionExprs.push_back(std::make_shared<const core::CallTypedExpr>(
-          BOOLEAN(),
-          std::vector<core::TypedExprPtr>{
+      conditionExprs.push_back(
+          std::make_shared<const core::CallTypedExpr>(
+              BOOLEAN(),
+              "between",
               std::move(indexColumnExpr),
               betweenCondition->lower,
-              betweenCondition->upper},
-          "between"));
+              betweenCondition->upper));
+      continue;
+    }
+    if (auto equalCondition =
+            std::dynamic_pointer_cast<core::EqualIndexLookupCondition>(
+                condition)) {
+      conditionExprs.push_back(
+          std::make_shared<const core::CallTypedExpr>(
+              BOOLEAN(),
+              "eq",
+              std::move(indexColumnExpr),
+              equalCondition->value));
       continue;
     }
     VELOX_FAIL("Invalid index join condition: {}", condition->toString());
@@ -101,7 +188,9 @@ TestIndexSource::TestIndexSource(
     const RowTypePtr& outputType,
     size_t numEqualJoinKeys,
     const core::TypedExprPtr& joinConditionExpr,
-    const std::shared_ptr<TestIndexTableHandle>& tableHandle,
+    const TestIndexTableHandlePtr& tableHandle,
+    const std::unordered_map<std::string, TestIndexColumnHandlePtr>&
+        columnHandles,
     connector::ConnectorQueryCtx* connectorQueryCtx,
     folly::Executor* executor)
     : tableHandle_(tableHandle),
@@ -118,7 +207,9 @@ TestIndexSource::TestIndexSource(
               : nullptr),
       pool_(connectorQueryCtx_->memoryPool()->shared_from_this()),
       executor_(executor) {
-  VELOX_CHECK_NOT_NULL(executor_);
+  if (tableHandle_->asyncLookup()) {
+    VELOX_CHECK_NOT_NULL(executor_);
+  }
   VELOX_CHECK_LE(outputType_->size(), valueType_->size() + keyType_->size());
   VELOX_CHECK_LE(numEqualJoinKeys_, keyType_->size());
   for (int i = 0; i < numEqualJoinKeys_; ++i) {
@@ -128,7 +219,7 @@ TestIndexSource::TestIndexSource(
         keyType_->toString(),
         inputType_->toString());
   }
-  initOutputProjections();
+  initOutputProjections(columnHandles);
   initConditionProjections();
 }
 
@@ -186,20 +277,24 @@ void TestIndexSource::initConditionProjections() {
   conditionInputType_ = ROW(std::move(names), std::move(types));
 }
 
-void TestIndexSource::initOutputProjections() {
+void TestIndexSource::initOutputProjections(
+    const std::unordered_map<std::string, TestIndexColumnHandlePtr>&
+        columnHandles) {
   VELOX_CHECK(lookupOutputProjections_.empty());
+
   lookupOutputProjections_.reserve(outputType_->size());
   for (auto outputChannel = 0; outputChannel < outputType_->size();
        ++outputChannel) {
     const auto outputName = outputType_->nameOf(outputChannel);
-    if (valueType_->containsChild(outputName)) {
-      const auto tableValueChannel = valueType_->getChildIdx(outputName);
+    const auto columnName = columnHandles.at(outputName)->name();
+    if (valueType_->containsChild(columnName)) {
+      const auto tableValueChannel = valueType_->getChildIdx(columnName);
       // The hash table layout is: index columns, value columns.
       lookupOutputProjections_.emplace_back(
           keyType_->size() + tableValueChannel, outputChannel);
       continue;
     }
-    const auto tableKeyChannel = keyType_->getChildIdx(outputName);
+    const auto tableKeyChannel = keyType_->getChildIdx(columnName);
     lookupOutputProjections_.emplace_back(tableKeyChannel, outputChannel);
   }
   VELOX_CHECK_EQ(lookupOutputProjections_.size(), outputType_->size());
@@ -250,10 +345,21 @@ TestIndexSource::ResultIterator::ResultIterator(
   lookupResultIter_->reset(*lookupResult_);
 }
 
+bool TestIndexSource::ResultIterator::hasNext() {
+  // If we have an async result ready, we have more to return.
+  if (asyncResult_.has_value()) {
+    return true;
+  }
+
+  // If the iterator is not at end, there are more results to fetch.
+  return !lookupResultIter_->atEnd();
+}
+
 std::optional<std::unique_ptr<connector::IndexSource::LookupResult>>
 TestIndexSource::ResultIterator::next(
     vector_size_t size,
     ContinueFuture& future) {
+  const auto lookupSize = std::min(size, kMaxLookupSize);
   source_->checkNotFailed();
 
   if (hasPendingRequest_.exchange(true)) {
@@ -261,7 +367,7 @@ TestIndexSource::ResultIterator::next(
   }
 
   if (executor_ && !asyncResult_.has_value()) {
-    asyncLookup(size, future);
+    asyncLookup(lookupSize, future);
     return std::nullopt;
   }
 
@@ -274,7 +380,7 @@ TestIndexSource::ResultIterator::next(
     asyncResult_.reset();
     return result;
   }
-  return syncLookup(size);
+  return syncLookup(lookupSize);
 }
 
 void TestIndexSource::ResultIterator::extractLookupColumns(
@@ -460,24 +566,33 @@ std::shared_ptr<connector::IndexSource> TestIndexConnector::createIndexSource(
     size_t numJoinKeys,
     const std::vector<core::IndexLookupConditionPtr>& joinConditions,
     const RowTypePtr& outputType,
-    const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-    const std::unordered_map<
-        std::string,
-        std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+    const connector::ConnectorTableHandlePtr& tableHandle,
+    const connector::ColumnHandleMap& columnHandles,
     connector::ConnectorQueryCtx* connectorQueryCtx) {
   VELOX_CHECK_GE(inputType->size(), numJoinKeys + joinConditions.size());
   auto testIndexTableHandle =
-      std::dynamic_pointer_cast<TestIndexTableHandle>(tableHandle);
+      std::dynamic_pointer_cast<const TestIndexTableHandle>(tableHandle);
   VELOX_CHECK_NOT_NULL(testIndexTableHandle);
   const auto& indexTable = testIndexTableHandle->indexTable();
   auto joinConditionExpr =
       toJoinConditionExpr(joinConditions, indexTable, inputType, columnHandles);
+
+  std::unordered_map<std::string, TestIndexColumnHandlePtr> testColumnHandles;
+  for (const auto& [name, handle] : columnHandles) {
+    auto testColumnHandle =
+        std::dynamic_pointer_cast<const TestIndexColumnHandle>(handle);
+    VELOX_CHECK_NOT_NULL(testColumnHandle);
+
+    testColumnHandles.emplace(name, testColumnHandle);
+  }
+
   return std::make_shared<TestIndexSource>(
       inputType,
       outputType,
       numJoinKeys,
-      std::move(joinConditionExpr),
-      std::move(testIndexTableHandle),
+      joinConditionExpr,
+      testIndexTableHandle,
+      testColumnHandles,
       connectorQueryCtx,
       executor_);
 }
diff --git a/velox/exec/tests/utils/TestIndexStorageConnector.h b/velox/exec/tests/utils/TestIndexStorageConnector.h
index 08a1c5d69b94..64f34c025ac7 100644
--- a/velox/exec/tests/utils/TestIndexStorageConnector.h
+++ b/velox/exec/tests/utils/TestIndexStorageConnector.h
@@ -16,7 +16,6 @@
 #pragma once
 
 #include "velox/exec/HashTable.h"
-#include "velox/exec/OperatorUtils.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::exec::test {
@@ -38,6 +37,13 @@ struct TestIndexTable {
       : keyType(std::move(_keyType)),
         dataType(std::move(_dataType)),
         table(std::move(_table)) {}
+
+  // Create index table with the given key and value inputs.
+  static std::shared_ptr<TestIndexTable> create(
+      size_t numEqualJoinKeys,
+      const RowVectorPtr& keyData,
+      const RowVectorPtr& valueData,
+      velox::memory::MemoryPool& pool);
 };
 
 // The index table handle which provides the index table for index lookup.
@@ -74,16 +80,23 @@ class TestIndexTableHandle : public connector::ConnectorTableHandle {
     obj["name"] = name();
     obj["connectorId"] = connectorId();
     obj["asyncLookup"] = asyncLookup_;
+    // For testing purpose only, we serialize the index table pointer as an
+    // long integer.
+    obj["indexTable"] = reinterpret_cast<int64_t>(indexTable_.get());
     return obj;
   }
 
-  static std::shared_ptr<TestIndexTableHandle> create(
+  static std::shared_ptr<const TestIndexTableHandle> create(
       const folly::dynamic& obj,
       void* context) {
     // NOTE: this is only for testing purpose so we don't support to serialize
     // the table.
+    auto ptr = obj["indexTable"].asInt();
+    auto indexTablePtr = reinterpret_cast<TestIndexTable*>(ptr);
     return std::make_shared<TestIndexTableHandle>(
-        obj["connectorId"].getString(), nullptr, obj["asyncLookup"].asBool());
+        obj["connectorId"].getString(),
+        std::shared_ptr<TestIndexTable>(indexTablePtr, [](TestIndexTable*) {}),
+        obj["asyncLookup"].asBool());
   }
 
   static void registerSerDe() {
@@ -105,6 +118,39 @@ class TestIndexTableHandle : public connector::ConnectorTableHandle {
   const bool asyncLookup_;
 };
 
+using TestIndexTableHandlePtr = std::shared_ptr<const TestIndexTableHandle>;
+
+class TestIndexColumnHandle : public connector::ColumnHandle {
+ public:
+  explicit TestIndexColumnHandle(std::string name) : name_{std::move(name)} {}
+
+  const std::string& name() const override {
+    return name_;
+  }
+
+  folly::dynamic serialize() const override {
+    auto obj = serializeBase("TestIndexColumnHandle");
+    obj["columnName"] = name_;
+    return obj;
+  }
+
+  static connector::ColumnHandlePtr create(const folly::dynamic& obj) {
+    auto name = obj["columnName"].asString();
+
+    return std::make_shared<TestIndexColumnHandle>(name);
+  }
+
+  static void registerSerDe() {
+    auto& registry = DeserializationRegistryForSharedPtr();
+    registry.Register("TestIndexColumnHandle", TestIndexColumnHandle::create);
+  }
+
+ private:
+  const std::string name_;
+};
+
+using TestIndexColumnHandlePtr = std::shared_ptr<const TestIndexColumnHandle>;
+
 class TestIndexSource : public connector::IndexSource,
                         public std::enable_shared_from_this<TestIndexSource> {
  public:
@@ -113,7 +159,9 @@ class TestIndexSource : public connector::IndexSource,
       const RowTypePtr& outputType,
       size_t numEqualJoinKeys,
       const core::TypedExprPtr& joinConditionExpr,
-      const std::shared_ptr<TestIndexTableHandle>& tableHandle,
+      const TestIndexTableHandlePtr& tableHandle,
+      const std::unordered_map<std::string, TestIndexColumnHandlePtr>&
+          columnHandles,
       connector::ConnectorQueryCtx* connectorQueryCtx,
       folly::Executor* executor);
 
@@ -146,11 +194,15 @@ class TestIndexSource : public connector::IndexSource,
         std::unique_ptr<HashLookup> lookupResult,
         folly::Executor* executor);
 
+    bool hasNext() override;
+
     std::optional<std::unique_ptr<LookupResult>> next(
         vector_size_t size,
         ContinueFuture& future) override;
 
    private:
+    static constexpr vector_size_t kMaxLookupSize = 8192;
+
     // Initializes the buffer used to store row pointers or indices for output
     // match result processing.
     template <typename T>
@@ -224,14 +276,16 @@ class TestIndexSource : public connector::IndexSource,
   void checkNotFailed();
 
   // Initialize the output projections for lookup result processing.
-  void initOutputProjections();
+  void initOutputProjections(
+      const std::unordered_map<std::string, TestIndexColumnHandlePtr>&
+          columnHandles);
 
   // Initialize the condition filter input type and projections if configured.
   void initConditionProjections();
 
   void recordCpuTiming(const CpuWallTiming& timing);
 
-  const std::shared_ptr<TestIndexTableHandle> tableHandle_;
+  const TestIndexTableHandlePtr tableHandle_;
   const RowTypePtr inputType_;
   const RowTypePtr outputType_;
   const RowTypePtr keyType_;
@@ -274,9 +328,8 @@ class TestIndexConnector : public connector::Connector {
 
   std::unique_ptr<connector::DataSource> createDataSource(
       const RowTypePtr&,
-      const std::shared_ptr<connector::ConnectorTableHandle>&,
-      const std::
-          unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>&,
+      const connector::ConnectorTableHandlePtr&,
+      const connector::ColumnHandleMap&,
       connector::ConnectorQueryCtx*) override {
     VELOX_UNSUPPORTED("{} not implemented", __FUNCTION__);
   }
@@ -286,15 +339,13 @@ class TestIndexConnector : public connector::Connector {
       size_t numJoinKeys,
       const std::vector<core::IndexLookupConditionPtr>& joinConditions,
       const RowTypePtr& outputType,
-      const std::shared_ptr<connector::ConnectorTableHandle>& tableHandle,
-      const std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::ColumnHandle>>& columnHandles,
+      const connector::ConnectorTableHandlePtr& tableHandle,
+      const connector::ColumnHandleMap& columnHandles,
       connector::ConnectorQueryCtx* connectorQueryCtx) override;
 
   std::unique_ptr<connector::DataSink> createDataSink(
       RowTypePtr,
-      std::shared_ptr<connector::ConnectorInsertTableHandle>,
+      connector::ConnectorInsertTableHandlePtr,
       connector::ConnectorQueryCtx*,
       connector::CommitStrategy) override {
     VELOX_UNSUPPORTED("{} not implemented", __FUNCTION__);
@@ -316,5 +367,12 @@ class TestIndexConnectorFactory : public connector::ConnectorFactory {
       folly::Executor* cpuExecutor) override {
     return std::make_shared<TestIndexConnector>(id, properties, cpuExecutor);
   }
+
+  static void registerConnector(folly::CPUThreadPoolExecutor* cpuExecutor) {
+    TestIndexConnectorFactory factory;
+    std::shared_ptr<connector::Connector> connector =
+        factory.newConnector(kTestIndexConnectorName, {}, nullptr, cpuExecutor);
+    connector::registerConnector(connector);
+  }
 };
 } // namespace facebook::velox::exec::test
diff --git a/velox/experimental/breeze/CMakeLists.txt b/velox/experimental/breeze/CMakeLists.txt
index 122f0c995b04..90001307ee8a 100644
--- a/velox/experimental/breeze/CMakeLists.txt
+++ b/velox/experimental/breeze/CMakeLists.txt
@@ -42,9 +42,7 @@ option(BUILD_TRACING "Build tracing." ON)
 option(BUILD_GENERATE_TEST_FIXTURES "Generate test fixtures at build time." ON)
 
 if(NOT DEFINED PERFTEST_EXT_TYPES)
-  set(PERFTEST_EXT_TYPES
-      0
-      CACHE STRING "Extended test types for perf tests")
+  set(PERFTEST_EXT_TYPES 0 CACHE STRING "Extended test types for perf tests")
 endif()
 
 if(NOT DEFINED VELOX_PROJECT_SOURCE_DIR)
@@ -56,7 +54,8 @@ list(
   CMAKE_MODULE_PATH
   "${PROJECT_SOURCE_DIR}/cmake"
   "${VELOX_PROJECT_SOURCE_DIR}/CMake"
-  "${VELOX_PROJECT_SOURCE_DIR}/CMake/third-party")
+  "${VELOX_PROJECT_SOURCE_DIR}/CMake/third-party"
+)
 
 # Include Velox ThirdPartyToolchain dependencies macros
 include(ResolveDependency)
diff --git a/velox/experimental/breeze/breeze/platforms/cuda.cuh b/velox/experimental/breeze/breeze/platforms/cuda.cuh
index 661e0743b460..02378f9af452 100644
--- a/velox/experimental/breeze/breeze/platforms/cuda.cuh
+++ b/velox/experimental/breeze/breeze/platforms/cuda.cuh
@@ -371,12 +371,12 @@ CudaSpecialization::atomic_add<breeze::utils::Slice<
   static_assert(sizeof(double) == sizeof(unsigned long long),
                 "unexpected type sizes");
   unsigned long long old =
-      *reinterpret_cast<unsigned long long *>(address.data());
+      *reinterpret_cast<unsigned long long*>(address.data());
   unsigned long long assumed;
   do {
     assumed = old;
     old = atomicCAS(
-        reinterpret_cast<unsigned long long *>(address.data()), assumed,
+        reinterpret_cast<unsigned long long*>(address.data()), assumed,
         __double_as_longlong(value + __longlong_as_double(assumed)));
   } while (assumed != old);
 
@@ -394,9 +394,9 @@ CudaSpecialization::atomic_add<breeze::utils::Slice<
         address,
     long long value) {
   unsigned long long result =
-      atomicAdd(reinterpret_cast<unsigned long long *>(address.data()),
-                *reinterpret_cast<unsigned long long *>(&value));
-  return *reinterpret_cast<long long *>(&result);
+      atomicAdd(reinterpret_cast<unsigned long long*>(address.data()),
+                *reinterpret_cast<unsigned long long*>(&value));
+  return *reinterpret_cast<long long*>(&result);
 }
 
 // specialization for T=Slice<GLOBAL, BLOCKED, float>
@@ -409,10 +409,10 @@ __device__ __forceinline__ void CudaSpecialization::atomic_min<
   static_assert(sizeof(float) == sizeof(unsigned), "unexpected type sizes");
   float current = atomic_load(address);
   while (current > value) {
-    unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),
-                             *reinterpret_cast<unsigned *>(&current),
-                             *reinterpret_cast<unsigned *>(&value));
-    current = *reinterpret_cast<float *>(&old);
+    unsigned old = atomicCAS(reinterpret_cast<unsigned*>(address.data()),
+                             *reinterpret_cast<unsigned*>(&current),
+                             *reinterpret_cast<unsigned*>(&value));
+    current = *reinterpret_cast<float*>(&old);
     if (current == value) {
       break;
     }
@@ -429,10 +429,10 @@ __device__ __forceinline__ void CudaSpecialization::atomic_max<
   static_assert(sizeof(float) == sizeof(unsigned), "unexpected type sizes");
   float current = atomic_load(address);
   while (current < value) {
-    unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),
-                             *reinterpret_cast<unsigned *>(&current),
-                             *reinterpret_cast<unsigned *>(&value));
-    current = *reinterpret_cast<float *>(&old);
+    unsigned old = atomicCAS(reinterpret_cast<unsigned*>(address.data()),
+                             *reinterpret_cast<unsigned*>(&current),
+                             *reinterpret_cast<unsigned*>(&value));
+    current = *reinterpret_cast<float*>(&old);
     if (current == value) {
       break;
     }
@@ -452,10 +452,10 @@ CudaSpecialization::atomic_min<breeze::utils::Slice<
   double current = atomic_load(address);
   while (current > value) {
     unsigned long long old =
-        atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),
-                  *reinterpret_cast<unsigned long long *>(&current),
-                  *reinterpret_cast<unsigned long long *>(&value));
-    current = *reinterpret_cast<double *>(&old);
+        atomicCAS(reinterpret_cast<unsigned long long*>(address.data()),
+                  *reinterpret_cast<unsigned long long*>(&current),
+                  *reinterpret_cast<unsigned long long*>(&value));
+    current = *reinterpret_cast<double*>(&old);
     if (current == value) {
       break;
     }
@@ -475,10 +475,10 @@ CudaSpecialization::atomic_max<breeze::utils::Slice<
   double current = atomic_load(address);
   while (current < value) {
     unsigned long long old =
-        atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),
-                  *reinterpret_cast<unsigned long long *>(&current),
-                  *reinterpret_cast<unsigned long long *>(&value));
-    current = *reinterpret_cast<double *>(&old);
+        atomicCAS(reinterpret_cast<unsigned long long*>(address.data()),
+                  *reinterpret_cast<unsigned long long*>(&current),
+                  *reinterpret_cast<unsigned long long*>(&value));
+    current = *reinterpret_cast<double*>(&old);
     if (current == value) {
       break;
     }
@@ -496,10 +496,10 @@ __device__ __forceinline__ long long CudaSpecialization::atomic_cas<
         address,
     long long compare, long long value) {
   unsigned long long old =
-      atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),
-                *reinterpret_cast<unsigned long long *>(&compare),
-                *reinterpret_cast<unsigned long long *>(&value));
-  return *reinterpret_cast<long long *>(&old);
+      atomicCAS(reinterpret_cast<unsigned long long*>(address.data()),
+                *reinterpret_cast<unsigned long long*>(&compare),
+                *reinterpret_cast<unsigned long long*>(&value));
+  return *reinterpret_cast<long long*>(&old);
 }
 
 // specialization for T=Slice<SHARED, BLOCKED, long long>
@@ -518,9 +518,9 @@ __device__ __forceinline__ long long CudaSpecialization::atomic_cas<
                                     unsigned long long>::pointer_type;
   unsigned long long old =
       atomicCAS(reinterpret_cast<pointer_type>(address.data()),
-                *reinterpret_cast<unsigned long long *>(&compare),
-                *reinterpret_cast<unsigned long long *>(&value));
-  return *reinterpret_cast<long long *>(&old);
+                *reinterpret_cast<unsigned long long*>(&compare),
+                *reinterpret_cast<unsigned long long*>(&value));
+  return *reinterpret_cast<long long*>(&old);
 }
 
 // specialization for T=Slice<GLOBAL, BLOCKED, float>
@@ -532,10 +532,10 @@ __device__ __forceinline__ float CudaSpecialization::atomic_cas<
         address,
     float compare, float value) {
   static_assert(sizeof(float) == sizeof(unsigned), "unexpected type sizes");
-  unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),
-                           *reinterpret_cast<unsigned *>(&compare),
-                           *reinterpret_cast<unsigned *>(&value));
-  return *reinterpret_cast<float *>(&old);
+  unsigned old = atomicCAS(reinterpret_cast<unsigned*>(address.data()),
+                           *reinterpret_cast<unsigned*>(&compare),
+                           *reinterpret_cast<unsigned*>(&value));
+  return *reinterpret_cast<float*>(&old);
 }
 
 #if __CUDA_ARCH__ >= 800
diff --git a/velox/experimental/breeze/breeze/platforms/hip.hpp b/velox/experimental/breeze/breeze/platforms/hip.hpp
index 2ddef322d5e4..9f9b38d19f76 100644
--- a/velox/experimental/breeze/breeze/platforms/hip.hpp
+++ b/velox/experimental/breeze/breeze/platforms/hip.hpp
@@ -70,11 +70,11 @@ struct HipPlatform {
   }
   template <typename SliceT, typename T = typename SliceT::data_type>
   __device__ __forceinline__ T atomic_load(SliceT address) {
-    return *reinterpret_cast<volatile T *>(address.data());
+    return *reinterpret_cast<volatile T*>(address.data());
   }
   template <typename SliceT, typename T = typename SliceT::data_type>
   __device__ __forceinline__ void atomic_store(SliceT address, T value) {
-    *reinterpret_cast<volatile T *>(address.data()) = value;
+    *reinterpret_cast<volatile T*>(address.data()) = value;
   }
   template <typename SliceT, typename T = typename SliceT::data_type>
   __device__ __forceinline__ T atomic_cas(SliceT address, T compare, T value) {
diff --git a/velox/experimental/breeze/breeze/platforms/metal.h b/velox/experimental/breeze/breeze/platforms/metal.h
index c1a3e28882fc..498fa31858c2 100644
--- a/velox/experimental/breeze/breeze/platforms/metal.h
+++ b/velox/experimental/breeze/breeze/platforms/metal.h
@@ -78,16 +78,15 @@ struct MetalPlatform {
     MetalSpecialization::atomic_store<SliceT, T>(address, value);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline uint atomic_cas(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint> address,
       uint expected, uint desired) {
-    volatile device uint *ptr = address.data();
+    volatile device uint* ptr = address.data();
     uint current = expected;
     do {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_uint *)ptr, &current, desired,
+              (device metal::atomic_uint*)ptr, &current, desired,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         return expected;
       }
@@ -95,16 +94,15 @@ struct MetalPlatform {
     return current;
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline bool atomic_cas(
       SliceT<breeze::utils::SHARED, breeze::utils::BLOCKED, uint> address,
       uint expected, uint desired) {
-    volatile threadgroup uint *ptr = address.data();
+    volatile threadgroup uint* ptr = address.data();
     uint current = expected;
     do {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (threadgroup metal::atomic_uint *)ptr, &current, desired,
+              (threadgroup metal::atomic_uint*)ptr, &current, desired,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         return expected;
       }
@@ -112,110 +110,101 @@ struct MetalPlatform {
     return current;
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline int atomic_add(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int> address,
       int value) {
-    volatile device int *ptr = address.data();
-    return metal::atomic_fetch_add_explicit((device metal::atomic_int *)ptr,
+    volatile device int* ptr = address.data();
+    return metal::atomic_fetch_add_explicit((device metal::atomic_int*)ptr,
                                             value, metal::memory_order_relaxed);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline int atomic_add(
       SliceT<breeze::utils::SHARED, breeze::utils::BLOCKED, int> address,
       int value) {
-    volatile threadgroup int *ptr = address.data();
-    return metal::atomic_fetch_add_explicit(
-        (threadgroup metal::atomic_int *)ptr, value,
-        metal::memory_order_relaxed);
+    volatile threadgroup int* ptr = address.data();
+    return metal::atomic_fetch_add_explicit((threadgroup metal::atomic_int*)ptr,
+                                            value, metal::memory_order_relaxed);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline uint atomic_add(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint> address,
       uint value) {
-    volatile device uint *ptr = address.data();
-    return metal::atomic_fetch_add_explicit((device metal::atomic_uint *)ptr,
+    volatile device uint* ptr = address.data();
+    return metal::atomic_fetch_add_explicit((device metal::atomic_uint*)ptr,
                                             value, metal::memory_order_relaxed);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline uint atomic_add(
       SliceT<breeze::utils::SHARED, breeze::utils::BLOCKED, uint> address,
       uint value) {
-    volatile threadgroup uint *ptr = address.data();
+    volatile threadgroup uint* ptr = address.data();
     return metal::atomic_fetch_add_explicit(
-        (threadgroup metal::atomic_uint *)ptr, value,
+        (threadgroup metal::atomic_uint*)ptr, value,
         metal::memory_order_relaxed);
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline void atomic_min(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int> address,
       int value) {
-    volatile device int *ptr = address.data();
-    int current = metal::atomic_load_explicit((device metal::atomic_int *)ptr,
+    volatile device int* ptr = address.data();
+    int current = metal::atomic_load_explicit((device metal::atomic_int*)ptr,
                                               metal::memory_order_relaxed);
     while (current > value) {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_int *)ptr, &current, value,
+              (device metal::atomic_int*)ptr, &current, value,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         break;
       }
     }
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline void atomic_min(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint> address,
       uint value) {
-    volatile device uint *ptr = address.data();
-    uint current = metal::atomic_load_explicit((device metal::atomic_uint *)ptr,
+    volatile device uint* ptr = address.data();
+    uint current = metal::atomic_load_explicit((device metal::atomic_uint*)ptr,
                                                metal::memory_order_relaxed);
     while (current > value) {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_uint *)ptr, &current, value,
+              (device metal::atomic_uint*)ptr, &current, value,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         break;
       }
     }
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline void atomic_max(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int> address,
       int value) {
-    volatile device int *ptr = address.data();
-    int current = metal::atomic_load_explicit((device metal::atomic_int *)ptr,
+    volatile device int* ptr = address.data();
+    int current = metal::atomic_load_explicit((device metal::atomic_int*)ptr,
                                               metal::memory_order_relaxed);
     while (current < value) {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_int *)ptr, &current, value,
+              (device metal::atomic_int*)ptr, &current, value,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         break;
       }
     }
   }
   template <template <breeze::utils::AddressSpace,
-                      breeze::utils::DataArrangement, typename>
-            class SliceT>
+                      breeze::utils::DataArrangement, typename> class SliceT>
   inline void atomic_max(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint> address,
       uint value) {
-    volatile device uint *ptr = address.data();
-    uint current = metal::atomic_load_explicit((device metal::atomic_uint *)ptr,
+    volatile device uint* ptr = address.data();
+    uint current = metal::atomic_load_explicit((device metal::atomic_uint*)ptr,
                                                metal::memory_order_relaxed);
     while (current < value) {
       if (metal::atomic_compare_exchange_weak_explicit(
-              (device metal::atomic_uint *)ptr, &current, value,
+              (device metal::atomic_uint*)ptr, &current, value,
               metal::memory_order_relaxed, metal::memory_order_relaxed)) {
         break;
       }
@@ -295,8 +284,8 @@ inline uint MetalSpecialization::atomic_load<
     breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint>>(
     breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint>
         address) {
-  volatile device uint *ptr = address.data();
-  return metal::atomic_load_explicit((device metal::atomic_uint *)ptr,
+  volatile device uint* ptr = address.data();
+  return metal::atomic_load_explicit((device metal::atomic_uint*)ptr,
                                      metal::memory_order_relaxed);
 }
 
@@ -307,8 +296,8 @@ inline void MetalSpecialization::atomic_store<
     breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int>
         address,
     int value) {
-  volatile device int *ptr = address.data();
-  metal::atomic_store_explicit((device metal::atomic_int *)ptr, value,
+  volatile device int* ptr = address.data();
+  metal::atomic_store_explicit((device metal::atomic_int*)ptr, value,
                                metal::memory_order_relaxed);
 }
 
@@ -319,7 +308,7 @@ inline void MetalSpecialization::atomic_store<
     breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, uint>
         address,
     uint value) {
-  volatile device uint *ptr = address.data();
-  metal::atomic_store_explicit((device metal::atomic_uint *)ptr, value,
+  volatile device uint* ptr = address.data();
+  metal::atomic_store_explicit((device metal::atomic_uint*)ptr, value,
                                metal::memory_order_relaxed);
 }
diff --git a/velox/experimental/breeze/breeze/platforms/opencl.h b/velox/experimental/breeze/breeze/platforms/opencl.h
index f4c5394e98ee..41e319bd5799 100644
--- a/velox/experimental/breeze/breeze/platforms/opencl.h
+++ b/velox/experimental/breeze/breeze/platforms/opencl.h
@@ -56,11 +56,11 @@ struct OpenCLPlatform {
   }
   template <typename SliceT, typename T = typename SliceT::data_type>
   inline T atomic_load(SliceT address) {
-    return *reinterpret_cast<const volatile T *>(address.data());
+    return *reinterpret_cast<const volatile T*>(address.data());
   }
   template <typename SliceT, typename T>
   inline void atomic_store(SliceT address, T value) {
-    *reinterpret_cast<volatile T *>(address.data()) = value;
+    *reinterpret_cast<volatile T*>(address.data()) = value;
   }
   template <typename SliceT, typename T>
   inline T atomic_cas(SliceT address, T compare, T value) {
diff --git a/velox/experimental/breeze/breeze/platforms/openmp.h b/velox/experimental/breeze/breeze/platforms/openmp.h
index 05123099a42a..dae8c82be672 100644
--- a/velox/experimental/breeze/breeze/platforms/openmp.h
+++ b/velox/experimental/breeze/breeze/platforms/openmp.h
@@ -31,9 +31,9 @@ template <typename T>
 struct supported_type {
   static T min();
   static T max();
-  static T atomic_load(T *address);
-  static void atomic_store(T *address, T value);
-  static bool atomic_cas(T *address, T *compare, T value, bool weak);
+  static T atomic_load(T* address);
+  static void atomic_store(T* address, T value);
+  static bool atomic_cas(T* address, T* compare, T value, bool weak);
   static int count_leading_zeros(T value);
   static int population_count(T value);
   static T extract_bits(T value, int start_bit, int num_bits);
@@ -44,13 +44,13 @@ template <>
 struct supported_type<unsigned> {
   static unsigned min() { return 0; }
   static unsigned max() { return __INT_MAX__ * 2u + 1; }
-  static unsigned atomic_load(unsigned *address) {
+  static unsigned atomic_load(unsigned* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(unsigned *address, unsigned value) {
+  static void atomic_store(unsigned* address, unsigned value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(unsigned *address, unsigned *compare, unsigned value,
+  static bool atomic_cas(unsigned* address, unsigned* compare, unsigned value,
                          bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
@@ -72,13 +72,13 @@ template <>
 struct supported_type<int> {
   static int min() { return -__INT_MAX__ - 1; }
   static int max() { return __INT_MAX__; }
-  static int atomic_load(int *address) {
+  static int atomic_load(int* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(int *address, int value) {
+  static void atomic_store(int* address, int value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(int *address, int *compare, int value, bool weak) {
+  static bool atomic_cas(int* address, int* compare, int value, bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
   }
@@ -89,15 +89,15 @@ template <>
 struct supported_type<unsigned long long> {
   static unsigned long long min() { return 0; }
   static unsigned long long max() { return __LONG_LONG_MAX__ * 2ull + 1; }
-  static unsigned long long atomic_load(unsigned long long *address) {
+  static unsigned long long atomic_load(unsigned long long* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(unsigned long long *address,
+  static void atomic_store(unsigned long long* address,
                            unsigned long long value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(unsigned long long *address,
-                         unsigned long long *compare, unsigned long long value,
+  static bool atomic_cas(unsigned long long* address,
+                         unsigned long long* compare, unsigned long long value,
                          bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
@@ -120,13 +120,13 @@ template <>
 struct supported_type<long long> {
   static long long min() { return -__LONG_LONG_MAX__ - 1; }
   static long long max() { return __LONG_LONG_MAX__; }
-  static long long atomic_load(long long *address) {
+  static long long atomic_load(long long* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(long long *address, long long value) {
+  static void atomic_store(long long* address, long long value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(long long *address, long long *compare,
+  static bool atomic_cas(long long* address, long long* compare,
                          long long value, bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
@@ -139,24 +139,24 @@ struct supported_type<float> {
   static_assert(sizeof(float) == sizeof(unsigned), "unexpected type sizes");
   static float min() { return __FLT_MIN__; }
   static float max() { return __FLT_MAX__; }
-  static float atomic_load(float *address) {
+  static float atomic_load(float* address) {
     union {
       float value;
       unsigned raw;
     } content;
-    content.raw = __atomic_load_n(reinterpret_cast<unsigned *>(address),
-                                  __ATOMIC_RELAXED);
+    content.raw =
+        __atomic_load_n(reinterpret_cast<unsigned*>(address), __ATOMIC_RELAXED);
     return content.value;
   }
-  static void atomic_store(float *address, float value) {
-    __atomic_store_n(reinterpret_cast<unsigned *>(address),
-                     *reinterpret_cast<unsigned *>(&value), __ATOMIC_RELAXED);
+  static void atomic_store(float* address, float value) {
+    __atomic_store_n(reinterpret_cast<unsigned*>(address),
+                     *reinterpret_cast<unsigned*>(&value), __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(float *address, float *compare, float value,
+  static bool atomic_cas(float* address, float* compare, float value,
                          bool weak) {
-    return __atomic_compare_exchange_n(reinterpret_cast<unsigned *>(address),
-                                       reinterpret_cast<unsigned *>(compare),
-                                       *reinterpret_cast<unsigned *>(&value),
+    return __atomic_compare_exchange_n(reinterpret_cast<unsigned*>(address),
+                                       reinterpret_cast<unsigned*>(compare),
+                                       *reinterpret_cast<unsigned*>(&value),
                                        weak, __ATOMIC_RELAXED,
                                        __ATOMIC_RELAXED);
   }
@@ -169,26 +169,26 @@ struct supported_type<double> {
                 "unexpected type sizes");
   static double min() { return __DBL_MIN__; }
   static double max() { return __DBL_MAX__; }
-  static double atomic_load(double *address) {
+  static double atomic_load(double* address) {
     union {
       double value;
       unsigned long long raw;
     } content;
     content.raw = __atomic_load_n(
-        reinterpret_cast<unsigned long long *>(address), __ATOMIC_RELAXED);
+        reinterpret_cast<unsigned long long*>(address), __ATOMIC_RELAXED);
     return content.value;
   }
-  static void atomic_store(double *address, double value) {
-    __atomic_store_n(reinterpret_cast<unsigned long long *>(address),
-                     *reinterpret_cast<unsigned long long *>(&value),
+  static void atomic_store(double* address, double value) {
+    __atomic_store_n(reinterpret_cast<unsigned long long*>(address),
+                     *reinterpret_cast<unsigned long long*>(&value),
                      __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(double *address, double *compare, double value,
+  static bool atomic_cas(double* address, double* compare, double value,
                          bool weak) {
     return __atomic_compare_exchange_n(
-        reinterpret_cast<unsigned long long *>(address),
-        reinterpret_cast<unsigned long long *>(compare),
-        *reinterpret_cast<unsigned long long *>(&value), weak, __ATOMIC_RELAXED,
+        reinterpret_cast<unsigned long long*>(address),
+        reinterpret_cast<unsigned long long*>(compare),
+        *reinterpret_cast<unsigned long long*>(&value), weak, __ATOMIC_RELAXED,
         __ATOMIC_RELAXED);
   }
 };
@@ -198,13 +198,13 @@ template <>
 struct supported_type<unsigned char> {
   static unsigned char min() { return 0; }
   static unsigned char max() { return 255; }
-  static unsigned atomic_load(unsigned char *address) {
+  static unsigned atomic_load(unsigned char* address) {
     return __atomic_load_n(address, __ATOMIC_RELAXED);
   }
-  static void atomic_store(unsigned char *address, unsigned char value) {
+  static void atomic_store(unsigned char* address, unsigned char value) {
     __atomic_store_n(address, value, __ATOMIC_RELAXED);
   }
-  static bool atomic_cas(unsigned char *address, unsigned char *compare,
+  static bool atomic_cas(unsigned char* address, unsigned char* compare,
                          unsigned char value, bool weak) {
     return __atomic_compare_exchange_n(address, compare, value, weak,
                                        __ATOMIC_RELAXED, __ATOMIC_RELAXED);
@@ -308,7 +308,7 @@ struct OpenMPPlatform {
     static_assert(WARP_THREADS == BLOCK_THREADS,
                   "WARP_THREADS must be the same as BLOCK_THREADS");
 
-    T *scratch = reinterpret_cast<T *>(shared_scratch_);
+    T* scratch = reinterpret_cast<T*>(shared_scratch_);
 #pragma omp single
     scratch[0] = static_cast<T>(0);
 
@@ -325,7 +325,7 @@ struct OpenMPPlatform {
     static_assert(WARP_THREADS == BLOCK_THREADS,
                   "WARP_THREADS must be the same as BLOCK_THREADS");
 
-    T *scratch = reinterpret_cast<T *>(shared_scratch_);
+    T* scratch = reinterpret_cast<T*>(shared_scratch_);
 
 #pragma omp single
     scratch[0] = supported_type<T>::max();
@@ -343,7 +343,7 @@ struct OpenMPPlatform {
     static_assert(WARP_THREADS == BLOCK_THREADS,
                   "WARP_THREADS must be the same as BLOCK_THREADS");
 
-    T *scratch = reinterpret_cast<T *>(shared_scratch_);
+    T* scratch = reinterpret_cast<T*>(shared_scratch_);
 #pragma omp single
     scratch[0] = supported_type<T>::min();
 
@@ -360,7 +360,7 @@ struct OpenMPPlatform {
     static_assert(WARP_THREADS == BLOCK_THREADS,
                   "WARP_THREADS must be the same as BLOCK_THREADS");
 
-    T *scratch = reinterpret_cast<T *>(shared_scratch_);
+    T* scratch = reinterpret_cast<T*>(shared_scratch_);
 #pragma omp single
     scratch[0] = static_cast<T>(0);
 
@@ -420,7 +420,7 @@ struct OpenMPPlatform {
   template <typename SliceT>
   inline void prefetch(SliceT) {}
   int block_idx_;
-  void *shared_scratch_;
+  void* shared_scratch_;
 };
 
 #pragma GCC diagnostic pop
diff --git a/velox/experimental/breeze/breeze/platforms/specialization/cuda-ptx.cuh b/velox/experimental/breeze/breeze/platforms/specialization/cuda-ptx.cuh
index 47014f6204c4..7a4d49434fdf 100644
--- a/velox/experimental/breeze/breeze/platforms/specialization/cuda-ptx.cuh
+++ b/velox/experimental/breeze/breeze/platforms/specialization/cuda-ptx.cuh
@@ -69,7 +69,7 @@ __device__ __forceinline__ unsigned CudaSpecialization::extract_bits(
   return BFE(value, start_bit, num_bits);
 }
 
-__device__ __forceinline__ void PREFETCH(void *ptr) {
+__device__ __forceinline__ void PREFETCH(void* ptr) {
   asm("prefetch.global.L1 [%0];" ::"l"(ptr));
 }
 
diff --git a/velox/experimental/breeze/breeze/platforms/sycl.hpp b/velox/experimental/breeze/breeze/platforms/sycl.hpp
index bc8c4dd8bbfa..e4693d9cfa58 100644
--- a/velox/experimental/breeze/breeze/platforms/sycl.hpp
+++ b/velox/experimental/breeze/breeze/platforms/sycl.hpp
@@ -66,24 +66,24 @@ struct SyCLPlatform {
   inline T max(T lhs, T rhs) {
     return cl::sycl::max(lhs, rhs);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline T atomic_load(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address) {
     return cl::sycl::atomic<T>{cl::sycl::global_ptr<T>{address.data()}}.load();
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline void atomic_store(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T value) {
     cl::sycl::atomic<T>{cl::sycl::global_ptr<T>{address.data()}}.store(value);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline T atomic_cas(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T compare, T value) {
@@ -91,18 +91,18 @@ struct SyCLPlatform {
         .compare_exchange_strong(compare, value);
     return compare;
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline T atomic_add(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T value) {
     return cl::sycl::atomic<T>{cl::sycl::global_ptr<T>{address.data()}}
         .fetch_add(value);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline T atomic_add(
       SliceT<breeze::utils::SHARED, breeze::utils::BLOCKED, T> address,
       T value) {
@@ -110,18 +110,18 @@ struct SyCLPlatform {
         cl::sycl::local_ptr<T>{address.data()}}
         .fetch_add(value);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline void atomic_min(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T value) {
     cl::sycl::atomic<T>{cl::sycl::global_ptr<T>{address.data()}}.fetch_min(
         value);
   }
-  template <typename T, template <breeze::utils::AddressSpace,
-                                  breeze::utils::DataArrangement, typename>
-                        typename SliceT>
+  template <typename T,
+            template <breeze::utils::AddressSpace,
+                      breeze::utils::DataArrangement, typename> typename SliceT>
   inline void atomic_max(
       SliceT<breeze::utils::GLOBAL, breeze::utils::BLOCKED, T> address,
       T value) {
diff --git a/velox/experimental/breeze/breeze/utils/types.h b/velox/experimental/breeze/breeze/utils/types.h
index 256d92d1787e..c6acd1ee881e 100644
--- a/velox/experimental/breeze/breeze/utils/types.h
+++ b/velox/experimental/breeze/breeze/utils/types.h
@@ -170,7 +170,7 @@ class BadDeviceAlloc : public std::exception {
                  ",free=" + std::to_string(free) +
                  ",total=" + std::to_string(total) + ")") {}
 
-  virtual const char *what() const noexcept { return message_.c_str(); }
+  virtual const char* what() const noexcept { return message_.c_str(); }
 
  private:
   std::string message_;
@@ -219,13 +219,13 @@ class Slice<THREAD, A, T> {
   static constant DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(thread T *data) : data_(data) {}
-  ATTR T const thread &operator[](int index) const { return data_[index]; }
-  ATTR T thread &operator[](int index) { return data_[index]; }
-  ATTR T const thread &operator*() const { return *data_; }
-  ATTR T thread &operator*() { return *data_; }
-  ATTR T const thread *operator->() const { return data_; }
-  ATTR T thread *operator->() { return data_; }
+  ATTR explicit Slice(thread T* data) : data_(data) {}
+  ATTR T const thread& operator[](int index) const { return data_[index]; }
+  ATTR T thread& operator[](int index) { return data_[index]; }
+  ATTR T const thread& operator*() const { return *data_; }
+  ATTR T thread& operator*() { return *data_; }
+  ATTR T const thread* operator->() const { return data_; }
+  ATTR T thread* operator->() { return data_; }
   ATTR Slice<THREAD, A, T> subslice(int offset) {
     return Slice<THREAD, A, T>(data_ + offset);
   }
@@ -233,15 +233,15 @@ class Slice<THREAD, A, T> {
     return Slice<THREAD, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T thread *data() { return data_; }
-  ATTR T const thread *data() const { return data_; }
+  ATTR T thread* data() { return data_; }
+  ATTR T const thread* data() const { return data_; }
 
  private:
-  thread T *data_;
+  thread T* data_;
 };
 
 template <AddressSpace A = THREAD, DataArrangement B = STRIPED, typename T>
-ATTR Slice<THREAD, B, T> constexpr make_slice(thread T *data) {
+ATTR Slice<THREAD, B, T> constexpr make_slice(thread T* data) {
   return Slice<THREAD, B, T>(data);
 }
 
@@ -253,13 +253,13 @@ class Slice<SHARED, A, T> {
   static constant DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(threadgroup T *data) : data_(data) {}
-  ATTR T const threadgroup &operator[](int index) const { return data_[index]; }
-  ATTR T threadgroup &operator[](int index) { return data_[index]; }
-  ATTR T const threadgroup &operator*() const { return *data_; }
-  ATTR T threadgroup &operator*() { return *data_; }
-  ATTR T const threadgroup *operator->() const { return data_; }
-  ATTR T threadgroup *operator->() { return data_; }
+  ATTR explicit Slice(threadgroup T* data) : data_(data) {}
+  ATTR T const threadgroup& operator[](int index) const { return data_[index]; }
+  ATTR T threadgroup& operator[](int index) { return data_[index]; }
+  ATTR T const threadgroup& operator*() const { return *data_; }
+  ATTR T threadgroup& operator*() { return *data_; }
+  ATTR T const threadgroup* operator->() const { return data_; }
+  ATTR T threadgroup* operator->() { return data_; }
   ATTR Slice<SHARED, A, T> subslice(int offset) {
     return Slice<SHARED, A, T>(data_ + offset);
   }
@@ -267,8 +267,8 @@ class Slice<SHARED, A, T> {
     return Slice<SHARED, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T threadgroup *data() { return data_; }
-  ATTR T const threadgroup *data() const { return data_; }
+  ATTR T threadgroup* data() { return data_; }
+  ATTR T const threadgroup* data() const { return data_; }
 
   template <AddressSpace OTHER>
   ATTR Slice<OTHER, A, T> reinterpret();
@@ -279,11 +279,11 @@ class Slice<SHARED, A, T> {
   }
 
  private:
-  threadgroup T *data_;
+  threadgroup T* data_;
 };
 
 template <AddressSpace A = SHARED, DataArrangement B = BLOCKED, typename T>
-ATTR Slice<SHARED, B, T> constexpr make_slice(threadgroup T *data) {
+ATTR Slice<SHARED, B, T> constexpr make_slice(threadgroup T* data) {
   return Slice<SHARED, B, T>(data);
 }
 
@@ -295,11 +295,11 @@ class Slice<GLOBAL, A, T> {
   static constant DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(device T *data) : data_(data) {}
-  ATTR T const device &operator[](int index) const { return data_[index]; }
-  ATTR T device &operator[](int index) { return data_[index]; }
-  ATTR T const device &operator*() const { return *data_; }
-  ATTR T device &operator*() { return *data_; }
+  ATTR explicit Slice(device T* data) : data_(data) {}
+  ATTR T const device& operator[](int index) const { return data_[index]; }
+  ATTR T device& operator[](int index) { return data_[index]; }
+  ATTR T const device& operator*() const { return *data_; }
+  ATTR T device& operator*() { return *data_; }
   ATTR Slice<GLOBAL, A, T> subslice(int offset) {
     return Slice<GLOBAL, A, T>(data_ + offset);
   }
@@ -307,15 +307,15 @@ class Slice<GLOBAL, A, T> {
     return Slice<GLOBAL, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T device *data() { return data_; }
-  ATTR T const device *data() const { return data_; }
+  ATTR T device* data() { return data_; }
+  ATTR T const device* data() const { return data_; }
 
  private:
-  device T *data_;
+  device T* data_;
 };
 
 template <AddressSpace A = GLOBAL, DataArrangement B = BLOCKED, typename T>
-ATTR Slice<GLOBAL, B, T> constexpr make_slice(device T *data) {
+ATTR Slice<GLOBAL, B, T> constexpr make_slice(device T* data) {
   return Slice<GLOBAL, B, T>(data);
 }
 
@@ -332,13 +332,13 @@ class Slice<THREAD, A, T> {
   static constexpr DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(__private T *data) : data_(data) {}
-  ATTR T const __private &operator[](int index) const { return data_[index]; }
-  ATTR T __private &operator[](int index) { return data_[index]; }
-  ATTR T const __private &operator*() const { return *data_; }
-  ATTR T __private &operator*() { return *data_; }
-  ATTR T const __private *operator->() const { return data_; }
-  ATTR T __private *operator->() { return data_; }
+  ATTR explicit Slice(__private T* data) : data_(data) {}
+  ATTR T const __private& operator[](int index) const { return data_[index]; }
+  ATTR T __private& operator[](int index) { return data_[index]; }
+  ATTR T const __private& operator*() const { return *data_; }
+  ATTR T __private& operator*() { return *data_; }
+  ATTR T const __private* operator->() const { return data_; }
+  ATTR T __private* operator->() { return data_; }
   ATTR Slice<THREAD, A, T> subslice(int offset) {
     return Slice<THREAD, A, T>(data_ + offset);
   }
@@ -346,8 +346,8 @@ class Slice<THREAD, A, T> {
     return Slice<THREAD, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T __private *data() { return data_; }
-  ATTR T const __private *data() const { return data_; }
+  ATTR T __private* data() { return data_; }
+  ATTR T const __private* data() const { return data_; }
 
   template <AddressSpace OTHER>
   ATTR Slice<OTHER, A, T> reinterpret();
@@ -358,11 +358,11 @@ class Slice<THREAD, A, T> {
   }
 
  private:
-  __private T *data_;
+  __private T* data_;
 };
 
 template <AddressSpace A = THREAD, DataArrangement B = STRIPED, typename T>
-ATTR Slice<THREAD, B, T> constexpr make_slice(private T *data) {
+ATTR Slice<THREAD, B, T> constexpr make_slice(private T* data) {
   return Slice<THREAD, B, T>(data);
 }
 
@@ -374,13 +374,13 @@ class Slice<SHARED, A, T> {
   static constexpr DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(local T *data) : data_(data) {}
-  ATTR T const local &operator[](int index) const { return data_[index]; }
-  ATTR T local &operator[](int index) { return data_[index]; }
-  ATTR T const local &operator*() const { return *data_; }
-  ATTR T local &operator*() { return *data_; }
-  ATTR T const local *operator->() const { return data_; }
-  ATTR T local *operator->() { return data_; }
+  ATTR explicit Slice(local T* data) : data_(data) {}
+  ATTR T const local& operator[](int index) const { return data_[index]; }
+  ATTR T local& operator[](int index) { return data_[index]; }
+  ATTR T const local& operator*() const { return *data_; }
+  ATTR T local& operator*() { return *data_; }
+  ATTR T const local* operator->() const { return data_; }
+  ATTR T local* operator->() { return data_; }
   ATTR Slice<SHARED, A, T> subslice(int offset) {
     return Slice<SHARED, A, T>(data_ + offset);
   }
@@ -388,8 +388,8 @@ class Slice<SHARED, A, T> {
     return Slice<SHARED, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T local *data() { return data_; }
-  ATTR T const local *data() const { return data_; }
+  ATTR T local* data() { return data_; }
+  ATTR T const local* data() const { return data_; }
 
   template <AddressSpace OTHER>
   ATTR Slice<OTHER, A, T> reinterpret();
@@ -400,11 +400,11 @@ class Slice<SHARED, A, T> {
   }
 
  private:
-  local T *data_;
+  local T* data_;
 };
 
 template <AddressSpace A = SHARED, DataArrangement B = BLOCKED, typename T>
-ATTR Slice<SHARED, B, T> constexpr make_slice(local T *data) {
+ATTR Slice<SHARED, B, T> constexpr make_slice(local T* data) {
   return Slice<SHARED, B, T>(data);
 }
 
@@ -416,11 +416,11 @@ class Slice<GLOBAL, A, T> {
   static constexpr DataArrangement ARRANGEMENT = A;
   using data_type = T;
 
-  ATTR explicit Slice(global T *data) : data_(data) {}
-  ATTR T const global &operator[](int index) const { return data_[index]; }
-  ATTR T global &operator[](int index) { return data_[index]; }
-  ATTR T const global &operator*() const { return *data_; }
-  ATTR T global &operator*() { return *data_; }
+  ATTR explicit Slice(global T* data) : data_(data) {}
+  ATTR T const global& operator[](int index) const { return data_[index]; }
+  ATTR T global& operator[](int index) { return data_[index]; }
+  ATTR T const global& operator*() const { return *data_; }
+  ATTR T global& operator*() { return *data_; }
   ATTR Slice<GLOBAL, A, T> subslice(int offset) {
     return Slice<GLOBAL, A, T>(data_ + offset);
   }
@@ -428,15 +428,15 @@ class Slice<GLOBAL, A, T> {
     return Slice<GLOBAL, A, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T global *data() { return data_; }
-  ATTR T const global *data() const { return data_; }
+  ATTR T global* data() { return data_; }
+  ATTR T const global* data() const { return data_; }
 
  private:
-  global T *data_;
+  global T* data_;
 };
 
 template <AddressSpace A = GLOBAL, DataArrangement B = BLOCKED, typename T>
-ATTR Slice<GLOBAL, B, T> constexpr make_slice(global T *data) {
+ATTR Slice<GLOBAL, B, T> constexpr make_slice(global T* data) {
   return Slice<GLOBAL, B, T>(data);
 }
 
@@ -448,15 +448,15 @@ class Slice {
   static constexpr AddressSpace ADDRESS_SPACE = A;
   static constexpr DataArrangement ARRANGEMENT = B;
   using data_type = T;
-  using pointer_type = T *;
+  using pointer_type = T*;
 
   ATTR explicit Slice(pointer_type data) : data_(data) {}
-  ATTR T const &operator[](int index) const { return data_[index]; }
-  ATTR T &operator[](int index) { return data_[index]; }
-  ATTR T const &operator*() const { return *data_; }
-  ATTR T &operator*() { return *data_; }
-  ATTR T const *operator->() const { return data_; }
-  ATTR T *operator->() { return data_; }
+  ATTR T const& operator[](int index) const { return data_[index]; }
+  ATTR T& operator[](int index) { return data_[index]; }
+  ATTR T const& operator*() const { return *data_; }
+  ATTR T& operator*() { return *data_; }
+  ATTR T const* operator->() const { return data_; }
+  ATTR T* operator->() { return data_; }
   ATTR Slice<A, B, T> subslice(int offset) {
     return Slice<A, B, T>(data_ + offset);
   }
@@ -464,8 +464,8 @@ class Slice {
     return Slice<A, B, T>(data_ + offset);
   }
   ATTR operator bool() const { return data_ != nullptr; }
-  ATTR T *data() { return data_; }
-  ATTR T const *data() const { return data_; }
+  ATTR T* data() { return data_; }
+  ATTR T const* data() const { return data_; }
 
   template <AddressSpace OTHER, DataArrangement OTHER_ARRANGEMENT =
                                     OTHER == THREAD ? STRIPED : BLOCKED>
@@ -482,7 +482,7 @@ class Slice {
 // arrangement by default for other address spaces
 template <AddressSpace A = THREAD,
           DataArrangement B = A == THREAD ? STRIPED : BLOCKED, typename T>
-ATTR Slice<A, B, T> constexpr make_slice(T *data) {
+ATTR Slice<A, B, T> constexpr make_slice(T* data) {
   return Slice<A, B, T>(data);
 }
 
diff --git a/velox/experimental/breeze/cmake/cuda.cmake b/velox/experimental/breeze/cmake/cuda.cmake
index f82d3ea04fab..f31598c100aa 100644
--- a/velox/experimental/breeze/cmake/cuda.cmake
+++ b/velox/experimental/breeze/cmake/cuda.cmake
@@ -18,9 +18,7 @@
 
 if(NOT DEFINED CMAKE_NVCC_FLAGS)
   if(DEFINED ENV{NVCCFLAGS})
-    set(CMAKE_NVCC_FLAGS
-        "$ENV{NVCCFLAGS}"
-        CACHE STRING "NVCC flags")
+    set(CMAKE_NVCC_FLAGS "$ENV{NVCCFLAGS}" CACHE STRING "NVCC flags")
   endif()
 endif()
 if(BREEZE_BUILD_TYPE MATCHES Debug)
@@ -34,9 +32,7 @@ find_program(NVCC_EXECUTABLE nvcc REQUIRED PATHS /usr/local/cuda/bin)
 
 if(DEFINED CUDA_EXPECTED_RESOURCE_USAGE_DIR)
   if(NOT EXISTS "${CUDA_EXPECTED_RESOURCE_USAGE_DIR}")
-    message(
-      FATAL_ERROR
-        "Invalid resource usage dir: ${CUDA_EXPECTED_RESOURCE_USAGE_DIR}")
+    message(FATAL_ERROR "Invalid resource usage dir: ${CUDA_EXPECTED_RESOURCE_USAGE_DIR}")
   endif()
   if(NOT DEFINED CUDA_RESOURCE_USAGE_CMDLINE)
     message(FATAL_ERROR "CUDA_RESOURCE_USAGE_CMDLINE is undefined")
@@ -49,77 +45,64 @@ endif()
 
 # use PTX specialization by default for CUDA
 if(NOT DEFINED CUDA_PLATFORM_SPECIALIZATION_HEADER)
-  set(CUDA_PLATFORM_SPECIALIZATION_HEADER
-      breeze/platforms/specialization/cuda-ptx.cuh
-      CACHE STRING "CUDA platform specialization header")
+  set(
+    CUDA_PLATFORM_SPECIALIZATION_HEADER
+    breeze/platforms/specialization/cuda-ptx.cuh
+    CACHE STRING
+    "CUDA platform specialization header"
+  )
 endif()
 
 function(breeze_add_cuda_object target source)
-  cmake_parse_arguments(
-    arg
-    ""
-    ""
-    "FLAGS;LIBS;DEPENDS"
-    ${ARGN})
+  cmake_parse_arguments(arg "" "" "FLAGS;LIBS;DEPENDS" ${ARGN})
   add_custom_command(
     OUTPUT ${target}.o
     COMMAND
-      ${NVCC_EXECUTABLE} -x cu ${CMAKE_NVCC_FLAGS} ${NDEBUG_DEFINE}
-      -DPLATFORM_CUDA
+      ${NVCC_EXECUTABLE} -x cu ${CMAKE_NVCC_FLAGS} ${NDEBUG_DEFINE} -DPLATFORM_CUDA
       -DCUDA_PLATFORM_SPECIALIZATION_HEADER=${CUDA_PLATFORM_SPECIALIZATION_HEADER}
-      -I${CMAKE_SOURCE_DIR} ${CMAKE_CXX_FLAGS} ${COMPILER_WARN_FLAGS}
-      ${OPT_FLAGS} ${CUDA_OPT_FLAGS} ${arg_FLAGS} -std=c++17 -c ${source} -MD
-      -MF ${target}.o.d -o ${target}.o
+      -I${CMAKE_SOURCE_DIR} ${CMAKE_CXX_FLAGS} ${COMPILER_WARN_FLAGS} ${OPT_FLAGS} ${CUDA_OPT_FLAGS}
+      ${arg_FLAGS} -std=c++17 -c ${source} -MD -MF ${target}.o.d -o ${target}.o
     DEPFILE ${target}.o.d
     DEPENDS ${arg_DEPENDS}
-    COMMENT "Building CUDA object ${target}.o")
+    COMMENT "Building CUDA object ${target}.o"
+  )
 endfunction()
 
 function(breeze_add_cuda_test target source)
-  cmake_parse_arguments(
-    arg
-    ""
-    ""
-    "FLAGS;LIBS;DEPENDS"
-    ${ARGN})
+  cmake_parse_arguments(arg "" "" "FLAGS;LIBS;DEPENDS" ${ARGN})
   list(APPEND arg_FLAGS -I${googletest_SOURCE_DIR}/googletest/include)
   list(APPEND arg_FLAGS -I${CMAKE_SOURCE_DIR})
   list(APPEND arg_FLAGS -I${CMAKE_BINARY_DIR})
-  breeze_add_cuda_object(
-    ${target}
-    ${source}
-    FLAGS
-    ${arg_FLAGS}
-    DEPENDS
-    ${arg_DEPENDS})
+  breeze_add_cuda_object(${target} ${source} FLAGS ${arg_FLAGS} DEPENDS ${arg_DEPENDS})
   add_custom_command(
     OUTPUT ${target}
     COMMAND
       ${NVCC_EXECUTABLE} -o ${target} ${target}.o ${arg_LIBS}
-      $<TARGET_FILE_DIR:GTest::gtest>/libgtest.a
-      $<TARGET_FILE_DIR:test_main>/libtest_main.a
-      $<$<BOOL:${BUILD_TRACING}>:$<TARGET_FILE_DIR:perfetto>/libperfetto.a>
-      ${ARCH_LINK_FLAGS}
+      $<TARGET_FILE_DIR:GTest::gtest>/libgtest.a $<TARGET_FILE_DIR:test_main>/libtest_main.a
+      $<$<BOOL:${BUILD_TRACING}>:$<TARGET_FILE_DIR:perfetto>/libperfetto.a> ${ARCH_LINK_FLAGS}
     DEPENDS ${target}.o test_main
-    COMMENT "Linking CUDA executable ${target}")
+    COMMENT "Linking CUDA executable ${target}"
+  )
   add_executable(${target}_TESTS IMPORTED)
-  set_property(TARGET ${target}_TESTS
-               PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/${target})
-  gtest_discover_tests(${target}_TESTS TEST_PREFIX cuda: DISCOVERY_MODE
-                                                         PRE_TEST)
+  set_property(
+    TARGET ${target}_TESTS
+    PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/${target}
+  )
+  gtest_discover_tests(${target}_TESTS TEST_PREFIX cuda: DISCOVERY_MODE PRE_TEST)
   if(DEFINED CUDA_EXPECTED_RESOURCE_USAGE_DIR)
     if(EXISTS "${CUDA_EXPECTED_RESOURCE_USAGE_DIR}/${target}-expected.txt")
-      set(GET_RESOURCE_USAGE_CMDLINE
-          "${CUDA_RESOURCE_USAGE_CMDLINE} ${CMAKE_CURRENT_BINARY_DIR}/${target} | ${CUDA_RESOURCE_USAGE_FILTER_CMDLINE}"
+      set(
+        GET_RESOURCE_USAGE_CMDLINE
+        "${CUDA_RESOURCE_USAGE_CMDLINE} ${CMAKE_CURRENT_BINARY_DIR}/${target} | ${CUDA_RESOURCE_USAGE_FILTER_CMDLINE}"
       )
       set(ACTUAL_USAGE_PATH resource-usage/${target}-actual.txt)
       add_custom_command(
         OUTPUT ${ACTUAL_USAGE_PATH}
         COMMAND sh -c "${GET_RESOURCE_USAGE_CMDLINE} > ${ACTUAL_USAGE_PATH}"
         DEPENDS ${target}
-        VERBATIM)
-      add_custom_target(${target}-resource-usage ALL
-                        DEPENDS ${ACTUAL_USAGE_PATH})
+        VERBATIM
+      )
+      add_custom_target(${target}-resource-usage ALL DEPENDS ${ACTUAL_USAGE_PATH})
       string(ASCII 27 Esc)
       set(RedColor "${Esc}[31m")
       set(YellowColor "${Esc}[33m")
@@ -131,9 +114,12 @@ function(breeze_add_cuda_test target source)
           "${DIFF_EXECUTABLE} --color=always -u ${CUDA_EXPECTED_RESOURCE_USAGE_DIR}/${target}-expected.txt ${CMAKE_CURRENT_BINARY_DIR}/${ACTUAL_USAGE_PATH} \
             || (echo '\n${RedColor}Resource usage checks FAILED:${ColorReset}\n\nRun the following command to update the baseline if this is expected:' ;
                 echo '${YellowColor}cp ${CMAKE_CURRENT_BINARY_DIR}/${ACTUAL_USAGE_PATH} ${CUDA_EXPECTED_RESOURCE_USAGE_DIR}/${target}-expected.txt${ColorReset}' ;
-                exit 1\)")
-      set_tests_properties(cuda:${target}:resource-usage
-                           PROPERTIES DEPENDS ${target}-resource-usage)
+                exit 1\)"
+      )
+      set_tests_properties(
+        cuda:${target}:resource-usage
+        PROPERTIES DEPENDS ${target}-resource-usage
+      )
     endif()
   endif()
 endfunction()
diff --git a/velox/experimental/breeze/cmake/hip.cmake b/velox/experimental/breeze/cmake/hip.cmake
index 74895739bb55..205cb79fe2c9 100644
--- a/velox/experimental/breeze/cmake/hip.cmake
+++ b/velox/experimental/breeze/cmake/hip.cmake
@@ -19,34 +19,31 @@
 find_program(HIPCC_EXECUTABLE hipcc REQUIRED PATHS /opt/rocm/bin)
 
 function(breeze_add_hip_test target source)
-  cmake_parse_arguments(
-    arg
-    ""
-    ""
-    "DEPENDS"
-    ${ARGN})
+  cmake_parse_arguments(arg "" "" "DEPENDS" ${ARGN})
   add_custom_command(
     OUTPUT ${target}.o
     COMMAND
-      ${HIPCC_EXECUTABLE} ${HIP_HIPCC_FLAGS} ${NDEBUG_DEFINE} -DPLATFORM_HIP
-      -I${CMAKE_SOURCE_DIR} -I${googletest_SOURCE_DIR}/googletest/include
-      -I${CMAKE_BINARY_DIR} ${CMAKE_CXX_FLAGS} ${COMPILER_WARN_FLAGS}
-      ${OPT_FLAGS} -std=c++17 -c ${source} -MD -MF ${target}.o.d -o ${target}.o
+      ${HIPCC_EXECUTABLE} ${HIP_HIPCC_FLAGS} ${NDEBUG_DEFINE} -DPLATFORM_HIP -I${CMAKE_SOURCE_DIR}
+      -I${googletest_SOURCE_DIR}/googletest/include -I${CMAKE_BINARY_DIR} ${CMAKE_CXX_FLAGS}
+      ${COMPILER_WARN_FLAGS} ${OPT_FLAGS} -std=c++17 -c ${source} -MD -MF ${target}.o.d -o
+      ${target}.o
     DEPFILE ${target}.o.d
     DEPENDS ${arg_DEPENDS}
-    COMMENT "Building HIP object ${target}.o")
+    COMMENT "Building HIP object ${target}.o"
+  )
   add_custom_command(
     OUTPUT ${target}
     COMMAND
-      ${HIPCC_EXECUTABLE} -o ${target} ${target}.o
-      $<TARGET_FILE_DIR:GTest::gtest>/libgtest.a
+      ${HIPCC_EXECUTABLE} -o ${target} ${target}.o $<TARGET_FILE_DIR:GTest::gtest>/libgtest.a
       $<TARGET_FILE_DIR:test_main>/libtest_main.a
-      $<$<BOOL:${BUILD_TRACING}>:$<TARGET_FILE_DIR:perfetto>/libperfetto.a>
-      ${ARCH_LINK_FLAGS}
+      $<$<BOOL:${BUILD_TRACING}>:$<TARGET_FILE_DIR:perfetto>/libperfetto.a> ${ARCH_LINK_FLAGS}
     DEPENDS ${target}.o test_main
-    COMMENT "Linking HIP executable ${target}")
+    COMMENT "Linking HIP executable ${target}"
+  )
   add_executable(${target}_TESTS IMPORTED)
-  set_property(TARGET ${target}_TESTS
-               PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/${target})
+  set_property(
+    TARGET ${target}_TESTS
+    PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/${target}
+  )
   gtest_discover_tests(${target}_TESTS TEST_PREFIX hip: DISCOVERY_MODE PRE_TEST)
 endfunction()
diff --git a/velox/experimental/breeze/cmake/metal.cmake b/velox/experimental/breeze/cmake/metal.cmake
index a4813e766f04..303c20d13b7c 100644
--- a/velox/experimental/breeze/cmake/metal.cmake
+++ b/velox/experimental/breeze/cmake/metal.cmake
@@ -17,26 +17,23 @@
 # SPDX-License-Identifier: Apache-2.0
 
 function(breeze_add_metal_test_kernels target source)
-  cmake_parse_arguments(
-    arg
-    ""
-    ""
-    "DEPENDS"
-    ${ARGN})
+  cmake_parse_arguments(arg "" "" "DEPENDS" ${ARGN})
   add_custom_command(
     OUTPUT ${target}.air
     COMMAND
-      xcrun -sdk macosx metal -DPLATFORM_METAL -I${CMAKE_SOURCE_DIR}
-      -I${CMAKE_BINARY_DIR} ${WARN_FLAGS} ${OPT_FLAGS} -Wno-c++17-extensions
-      -std=metal3.0 -c ${source} -MD -MF ${target}.air.d -o ${target}.air
+      xcrun -sdk macosx metal -DPLATFORM_METAL -I${CMAKE_SOURCE_DIR} -I${CMAKE_BINARY_DIR}
+      ${WARN_FLAGS} ${OPT_FLAGS} -Wno-c++17-extensions -std=metal3.0 -c ${source} -MD -MF
+      ${target}.air.d -o ${target}.air
     COMMENT "Compile ${source} --> ${target}.air"
     DEPENDS ${arg_DEPENDS}
-    DEPFILE ${target}.air.d)
+    DEPFILE ${target}.air.d
+  )
   add_custom_command(
     OUTPUT ${target}.metallib
     COMMAND xcrun -sdk macosx metallib -o ${target}.metallib ${target}.air
     COMMENT "Compile ${target}.air --> ${target}.metallib"
-    DEPENDS ${target}.air)
+    DEPENDS ${target}.air
+  )
   add_custom_target(${target} DEPENDS ${target}.metallib)
 endfunction()
 
@@ -44,22 +41,18 @@ function(breeze_add_metal_test target source shaderlib)
   add_executable(${target} ${source} platforms/metal_test.mm)
   target_compile_features(${target} PRIVATE cxx_std_17)
   target_include_directories(${target} PRIVATE ${CMAKE_BINARY_DIR})
-  target_compile_definitions(${target} PUBLIC PLATFORM_METAL=1
-                                              SHADER_LIB=\"${shaderlib}\")
+  target_compile_definitions(${target} PUBLIC PLATFORM_METAL=1 SHADER_LIB=\"${shaderlib}\")
   target_compile_options(
     ${target}
-    PRIVATE
-      -x
-      objective-c++
-      ${WARN_FLAGS}
-      ${OPT_FLAGS}
-      ${SANITIZE_COMPILE_FLAGS})
+    PRIVATE -x objective-c++ ${WARN_FLAGS} ${OPT_FLAGS} ${SANITIZE_COMPILE_FLAGS}
+  )
   target_link_libraries(
     ${target}
     "-framework Foundation"
     "-framework CoreGraphics"
     "-framework Metal"
-    test_main)
+    test_main
+  )
   target_link_options(${target} PRIVATE ${SANITIZE_LINK_FLAGS})
   gtest_discover_tests(${target} TEST_PREFIX metal: DISCOVERY_MODE PRE_TEST)
 endfunction()
diff --git a/velox/experimental/breeze/cmake/opencl.cmake b/velox/experimental/breeze/cmake/opencl.cmake
index c9dbba520044..dabe86c1a52f 100644
--- a/velox/experimental/breeze/cmake/opencl.cmake
+++ b/velox/experimental/breeze/cmake/opencl.cmake
@@ -19,39 +19,29 @@
 find_program(CLCC_EXECUTABLE clcc REQUIRED)
 
 function(breeze_add_opencl_test_kernels target source)
-  cmake_parse_arguments(
-    arg
-    ""
-    ""
-    "DEPENDS"
-    ${ARGN})
+  cmake_parse_arguments(arg "" "" "DEPENDS" ${ARGN})
   add_custom_command(
     OUTPUT ${target}.so
     COMMAND
-      ${CLCC_EXECUTABLE} -o ${target}.so ${source} -MD -MF ${target}.clcpp.d
-      -DPLATFORM_OPENCL -I${CMAKE_SOURCE_DIR} -I${CMAKE_BINARY_DIR}
-      ${COMPILER_WARN_FLAGS} ${OPT_FLAGS}
+      ${CLCC_EXECUTABLE} -o ${target}.so ${source} -MD -MF ${target}.clcpp.d -DPLATFORM_OPENCL
+      -I${CMAKE_SOURCE_DIR} -I${CMAKE_BINARY_DIR} ${COMPILER_WARN_FLAGS} ${OPT_FLAGS}
     COMMENT "Building OpenCL kernels ${source} --> ${target}.so"
     DEPENDS ${arg_DEPENDS}
-    DEPFILE ${target}.clcpp.d)
+    DEPFILE ${target}.clcpp.d
+  )
   add_custom_target(${target} DEPENDS ${target}.so)
 endfunction()
 
 function(breeze_add_opencl_test target source shaderlib)
   add_executable(${target} ${source})
   target_compile_features(${target} PRIVATE cxx_std_17)
-  target_include_directories(${target} PRIVATE ${CMAKE_OPENCL_INCLUDE}
-                                               ${CMAKE_BINARY_DIR})
-  target_compile_definitions(${target} PUBLIC PLATFORM_OPENCL=1
-                                              SHADER_LIB=\"${shaderlib}\")
-  target_compile_options(${target} PRIVATE ${WARN_FLAGS} ${OPT_FLAGS}
-                                           ${SANITIZE_COMPILE_FLAGS})
+  target_include_directories(${target} PRIVATE ${CMAKE_OPENCL_INCLUDE} ${CMAKE_BINARY_DIR})
+  target_compile_definitions(${target} PUBLIC PLATFORM_OPENCL=1 SHADER_LIB=\"${shaderlib}\")
+  target_compile_options(${target} PRIVATE ${WARN_FLAGS} ${OPT_FLAGS} ${SANITIZE_COMPILE_FLAGS})
   target_link_libraries(${target} gtest -lOpenCL test_main)
   target_link_options(
     ${target}
-    PRIVATE
-    ${CMAKE_OPENCL_LINK_FLAGS}
-    ${SANITIZE_LINK_FLAGS}
-    ${ARCH_CLANG_LINK_FLAGS})
+    PRIVATE ${CMAKE_OPENCL_LINK_FLAGS} ${SANITIZE_LINK_FLAGS} ${ARCH_CLANG_LINK_FLAGS}
+  )
   gtest_discover_tests(${target} TEST_PREFIX opencl: DISCOVERY_MODE PRE_TEST)
 endfunction()
diff --git a/velox/experimental/breeze/cmake/openmp.cmake b/velox/experimental/breeze/cmake/openmp.cmake
index 1617c5c08c25..7e3dbf63816c 100644
--- a/velox/experimental/breeze/cmake/openmp.cmake
+++ b/velox/experimental/breeze/cmake/openmp.cmake
@@ -19,9 +19,7 @@
 set(OPENMP_GCC_NO_WARN_FLAGS "-Wno-unknown-pragmas;-Wno-maybe-uninitialized")
 
 if(NOT DEFINED OPENMP_UNROLL_THRESHOLD)
-  set(OPENMP_UNROLL_THRESHOLD
-      32
-      CACHE STRING "OpenMP loop unroll threshold")
+  set(OPENMP_UNROLL_THRESHOLD 32 CACHE STRING "OpenMP loop unroll threshold")
 endif()
 
 find_package(OpenMP REQUIRED)
@@ -44,7 +42,8 @@ function(breeze_add_openmp_test target source)
         -Xclang
         -mllvm
         -Xclang
-        -unroll-threshold=${OPENMP_UNROLL_THRESHOLD})
+        -unroll-threshold=${OPENMP_UNROLL_THRESHOLD}
+    )
   else()
     target_compile_options(
       ${target}
@@ -55,7 +54,8 @@ function(breeze_add_openmp_test target source)
         ${WARN_FLAGS}
         ${OPENMP_GCC_NO_WARN_FLAGS}
         ${OPT_FLAGS}
-        ${SANITIZE_COMPILE_FLAGS})
+        ${SANITIZE_COMPILE_FLAGS}
+    )
   endif()
   target_link_options(${target} PRIVATE ${SANITIZE_LINK_FLAGS})
   target_link_libraries(${target} OpenMP::OpenMP_CXX test_main)
diff --git a/velox/experimental/breeze/cmake/sycl.cmake b/velox/experimental/breeze/cmake/sycl.cmake
index 47b43c787872..edf986e9d508 100644
--- a/velox/experimental/breeze/cmake/sycl.cmake
+++ b/velox/experimental/breeze/cmake/sycl.cmake
@@ -19,36 +19,31 @@
 find_program(SYCLCC_EXECUTABLE syclcc REQUIRED PATHS /opt/hipSYCL)
 
 function(breeze_add_sycl_test target source)
-  cmake_parse_arguments(
-    arg
-    ""
-    ""
-    "DEPENDS"
-    ${ARGN})
+  cmake_parse_arguments(arg "" "" "DEPENDS" ${ARGN})
   add_custom_command(
     OUTPUT ${target}.o
     COMMAND
-      ${SYCLCC_EXECUTABLE} ${NDEBUG_DEFINE} -DPLATFORM_SYCL
-      -I${CMAKE_SOURCE_DIR} -I${googletest_SOURCE_DIR}/googletest/include
-      -I${CMAKE_BINARY_DIR} ${CMAKE_CXX_FLAGS} ${OPT_FLAGS}
-      ${SANITIZE_COMPILE_FLAGS} -std=c++17 -c ${source} -MD -MF ${target}.o.d -o
+      ${SYCLCC_EXECUTABLE} ${NDEBUG_DEFINE} -DPLATFORM_SYCL -I${CMAKE_SOURCE_DIR}
+      -I${googletest_SOURCE_DIR}/googletest/include -I${CMAKE_BINARY_DIR} ${CMAKE_CXX_FLAGS}
+      ${OPT_FLAGS} ${SANITIZE_COMPILE_FLAGS} -std=c++17 -c ${source} -MD -MF ${target}.o.d -o
       ${target}.o
     DEPFILE ${target}.o.d
     DEPENDS ${arg_DEPENDS}
-    COMMENT "Building SYCL object ${target}.o")
+    COMMENT "Building SYCL object ${target}.o"
+  )
   add_custom_command(
     OUTPUT ${target}
     COMMAND
-      ${SYCLCC_EXECUTABLE} -o ${target} ${target}.o
-      $<TARGET_FILE_DIR:GTest::gtest>/libgtest.a
-      $<TARGET_FILE_DIR:test_main>/libtest_main.a ${CMAKE_THREAD_LIBS_INIT}
-      ${ARCH_LINK_FLAGS}
+      ${SYCLCC_EXECUTABLE} -o ${target} ${target}.o $<TARGET_FILE_DIR:GTest::gtest>/libgtest.a
+      $<TARGET_FILE_DIR:test_main>/libtest_main.a ${CMAKE_THREAD_LIBS_INIT} ${ARCH_LINK_FLAGS}
       $<$<BOOL:${BUILD_TRACING}>:$<TARGET_FILE_DIR:perfetto>/libperfetto.a>
     DEPENDS ${target}.o test_main
-    COMMENT "Linking SYCL executable ${target}")
+    COMMENT "Linking SYCL executable ${target}"
+  )
   add_executable(${target}_TESTS IMPORTED)
-  set_property(TARGET ${target}_TESTS
-               PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/${target})
-  gtest_discover_tests(${target}_TESTS TEST_PREFIX sycl: DISCOVERY_MODE
-                                                         PRE_TEST)
+  set_property(
+    TARGET ${target}_TESTS
+    PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/${target}
+  )
+  gtest_discover_tests(${target}_TESTS TEST_PREFIX sycl: DISCOVERY_MODE PRE_TEST)
 endfunction()
diff --git a/velox/experimental/breeze/perftest/CMakeLists.txt b/velox/experimental/breeze/perftest/CMakeLists.txt
index f11a30e254c0..0edda92c1c81 100644
--- a/velox/experimental/breeze/perftest/CMakeLists.txt
+++ b/velox/experimental/breeze/perftest/CMakeLists.txt
@@ -33,25 +33,10 @@ function(breeze_add_perftests dir type)
       list(APPEND _cuda_flags -I${CMAKE_SOURCE_DIR}/../../external/perfetto/sdk)
       list(APPEND _cuda_flags -DTRACING=1)
     endif()
-    breeze_add_tests(
-      ${dir}
-      ${type}
-      "_perftest"
-      ".cu"
-      ${ARGN})
+    breeze_add_tests(${dir} ${type} "_perftest" ".cu" ${ARGN})
   endif()
 endfunction()
 
-breeze_add_perftests(
-  "functions"
-  "function"
-  "reduce"
-  "scan"
-  "sort")
-breeze_add_perftests(
-  "algorithms"
-  "algorithm"
-  "reduce"
-  "scan"
-  "sort")
+breeze_add_perftests("functions" "function" "reduce" "scan" "sort")
+breeze_add_perftests("algorithms" "algorithm" "reduce" "scan" "sort")
 breeze_add_perftests("queries" "query" "order_by")
diff --git a/velox/experimental/breeze/test/CMakeLists.txt b/velox/experimental/breeze/test/CMakeLists.txt
index 0afdd04880c8..817cd2b7d232 100644
--- a/velox/experimental/breeze/test/CMakeLists.txt
+++ b/velox/experimental/breeze/test/CMakeLists.txt
@@ -19,28 +19,24 @@
 include_directories(${CMAKE_SOURCE_DIR})
 
 add_library(test_main test_main.cpp)
-target_link_libraries(
-  test_main
-  PUBLIC gtest $<$<BOOL:${BUILD_TRACING}>:perfetto>)
+target_link_libraries(test_main PUBLIC gtest $<$<BOOL:${BUILD_TRACING}>:perfetto>)
 target_compile_features(test_main PRIVATE cxx_std_17)
-target_compile_options(test_main PRIVATE ${CMAKE_CXX_FLAGS} ${WARN_FLAGS}
-                                         ${SANITIZE_COMPILE_FLAGS})
+target_compile_options(test_main PRIVATE ${CMAKE_CXX_FLAGS} ${WARN_FLAGS} ${SANITIZE_COMPILE_FLAGS})
 
-function(
-  breeze_add_tests
-  dir
-  type
-  suite
-  filetype)
+function(breeze_add_tests dir type suite filetype)
   if(BUILD_OPENCL)
     breeze_add_opencl_test_kernels(
-      ${type}_opencl_kernels ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/kernels.clcpp
-      DEPENDS ${_opencl_kernels_src})
+      ${type}_opencl_kernels
+      ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/kernels.clcpp
+      DEPENDS ${_opencl_kernels_src}
+    )
   endif()
   if(BUILD_METAL)
     breeze_add_metal_test_kernels(
-      ${type}_metal_kernels ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/kernels.metal
-      DEPENDS ${_metal_kernels_src})
+      ${type}_metal_kernels
+      ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/kernels.metal
+      DEPENDS ${_metal_kernels_src}
+    )
   endif()
   foreach(name IN LISTS ARGN)
     set(_deps)
@@ -48,50 +44,52 @@ function(
       breeze_add_cuda_test(
         ${name}_${type}${suite}-cuda
         ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${name}${suite}${filetype}
-        FLAGS
-        ${_cuda_flags}
-        LIBS
-        ${_cuda_libs}
-        DEPENDS
-        ${_cuda_deps}
-        ${_cuda_kernels_src}
-        ${_cuda_test_fixture_src})
+        FLAGS ${_cuda_flags}
+        LIBS ${_cuda_libs}
+        DEPENDS ${_cuda_deps} ${_cuda_kernels_src} ${_cuda_test_fixture_src}
+      )
       list(APPEND _deps ${name}_${type}${suite}-cuda)
     endif()
     if(BUILD_HIP)
       breeze_add_hip_test(
         ${name}_${type}${suite}-hip
         ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${name}${suite}${filetype}
-        DEPENDS
-        ${_hip_kernels_src}
-        ${_hip_test_fixture_src})
+        DEPENDS ${_hip_kernels_src} ${_hip_test_fixture_src}
+      )
       list(APPEND _deps ${name}_${type}${suite}-hip)
     endif()
     if(BUILD_SYCL)
       breeze_add_sycl_test(
         ${name}_${type}${suite}-sycl
         ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${name}${suite}${filetype}
-        DEPENDS
-        ${_sycl_kernels_src}
-        ${_sycl_test_fixture_src})
+        DEPENDS ${_sycl_kernels_src} ${_sycl_test_fixture_src}
+      )
       list(APPEND _deps ${name}_${type}${suite}-sycl)
     endif()
     if(BUILD_OPENCL)
       breeze_add_opencl_test(
         ${name}_${type}${suite}-opencl
         ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${name}${suite}${filetype}
-        ${CMAKE_CURRENT_BINARY_DIR}/${type}_opencl_kernels.so)
-      add_dependencies(${name}_${type}${suite}-opencl ${type}_opencl_kernels
-                       ${_opencl_test_fixture_src})
+        ${CMAKE_CURRENT_BINARY_DIR}/${type}_opencl_kernels.so
+      )
+      add_dependencies(
+        ${name}_${type}${suite}-opencl
+        ${type}_opencl_kernels
+        ${_opencl_test_fixture_src}
+      )
       list(APPEND _deps ${name}_${type}${suite}-opencl)
     endif()
     if(BUILD_OPENMP)
       breeze_add_openmp_test(
         ${name}_${type}${suite}-openmp
-        ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${name}${suite}${filetype})
+        ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${name}${suite}${filetype}
+      )
       if(DEFINED _openmp_kernels_src)
-        add_dependencies(${name}_${type}${suite}-openmp ${_openmp_kernels_src}
-                         ${_openmp_test_fixture_src})
+        add_dependencies(
+          ${name}_${type}${suite}-openmp
+          ${_openmp_kernels_src}
+          ${_openmp_test_fixture_src}
+        )
       endif()
       list(APPEND _deps ${name}_${type}${suite}-openmp)
     endif()
@@ -99,9 +97,13 @@ function(
       breeze_add_metal_test(
         ${name}_${type}${suite}-metal
         ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${name}${suite}${filetype}
-        ${CMAKE_CURRENT_BINARY_DIR}/${type}_metal_kernels.metallib)
-      add_dependencies(${name}_${type}${suite}-metal ${type}_metal_kernels
-                       ${_metal_test_fixture_src})
+        ${CMAKE_CURRENT_BINARY_DIR}/${type}_metal_kernels.metallib
+      )
+      add_dependencies(
+        ${name}_${type}${suite}-metal
+        ${type}_metal_kernels
+        ${_metal_test_fixture_src}
+      )
       list(APPEND _deps ${name}_${type}${suite}-metal)
     endif()
     add_custom_target(${name}_${type}${suite} ALL DEPENDS ${_deps})
@@ -116,7 +118,8 @@ function(
   dir
   type
   backend
-  outfile)
+  outfile
+)
   if(DEFINED LLVM_PATH)
     set(LLVM_FLAG "--llvm-root='${LLVM_PATH}'")
   endif()
@@ -130,7 +133,8 @@ function(
       "${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${type}-kernels.template.h"
       "${CMAKE_CURRENT_SOURCE_DIR}/kernel_generator.py"
       "${CMAKE_CURRENT_SOURCE_DIR}/generator_common.py"
-    COMMENT "Specializing kernel code for backend ${backend}")
+    COMMENT "Specializing kernel code for backend ${backend}"
+  )
   add_custom_target(${target} DEPENDS ${outfile})
 endfunction()
 
@@ -140,22 +144,23 @@ function(
   dir
   type
   backend
-  outfile)
+  outfile
+)
   if(DEFINED LLVM_PATH)
     set(LLVM_FLAG "--llvm-root='${LLVM_PATH}'")
   endif()
   add_custom_command(
     OUTPUT ${outfile}
     COMMAND
-      ${CMAKE_CURRENT_SOURCE_DIR}/test_fixture_generator.py
-      --backend="${backend}"
+      ${CMAKE_CURRENT_SOURCE_DIR}/test_fixture_generator.py --backend="${backend}"
       --template="${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${type}_test.template.h"
       --out="${CMAKE_CURRENT_BINARY_DIR}/${outfile}" ${LLVM_FLAG}
     DEPENDS
       "${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${type}_test.template.h"
       "${CMAKE_CURRENT_SOURCE_DIR}/test_fixture_generator.py"
       "${CMAKE_CURRENT_SOURCE_DIR}/generator_common.py"
-    COMMENT "Specializing test fixture for backend ${backend}")
+    COMMENT "Specializing test fixture for backend ${backend}"
+  )
   add_custom_target(${target} DEPENDS ${outfile})
 endfunction()
 
@@ -167,13 +172,15 @@ function(breeze_add_unittests dir type)
         ${dir}
         ${type}
         "opencl"
-        "generated/${dir}/kernels-opencl.h")
+        "generated/${dir}/kernels-opencl.h"
+      )
       generate_test_fixture(
         ${type}_opencl_test_fixture_src
         ${dir}
         ${type}
         "opencl"
-        "generated/${dir}/${type}_test-opencl.h")
+        "generated/${dir}/${type}_test-opencl.h"
+      )
       set(_opencl_kernels_src ${type}_opencl_kernels_src)
       set(_opencl_test_fixture_src ${type}_opencl_test_fixture_src)
     endif()
@@ -183,13 +190,15 @@ function(breeze_add_unittests dir type)
         ${dir}
         ${type}
         "metal"
-        "generated/${dir}/kernels-metal.h")
+        "generated/${dir}/kernels-metal.h"
+      )
       generate_test_fixture(
         ${type}_metal_test_fixture_src
         ${dir}
         ${type}
         "metal"
-        "generated/${dir}/${type}_test-metal.h")
+        "generated/${dir}/${type}_test-metal.h"
+      )
       set(_metal_kernels_src ${type}_metal_kernels_src)
       set(_metal_test_fixture_src ${type}_metal_test_fixture_src)
     endif()
@@ -199,13 +208,15 @@ function(breeze_add_unittests dir type)
         ${dir}
         ${type}
         "cuda"
-        "generated/${dir}/kernels-cuda.cuh")
+        "generated/${dir}/kernels-cuda.cuh"
+      )
       generate_test_fixture(
         ${type}_cuda_test_fixture_src
         ${dir}
         ${type}
         "cuda"
-        "generated/${dir}/${type}_test-cuda.cuh")
+        "generated/${dir}/${type}_test-cuda.cuh"
+      )
       set(_cuda_kernels_src ${type}_cuda_kernels_src)
       set(_cuda_test_fixture_src ${type}_cuda_test_fixture_src)
     endif()
@@ -215,13 +226,15 @@ function(breeze_add_unittests dir type)
         ${dir}
         ${type}
         "hip"
-        "generated/${dir}/kernels-hip.hpp")
+        "generated/${dir}/kernels-hip.hpp"
+      )
       generate_test_fixture(
         ${type}_hip_test_fixture_src
         ${dir}
         ${type}
         "hip"
-        "generated/${dir}/${type}_test-hip.hpp")
+        "generated/${dir}/${type}_test-hip.hpp"
+      )
       set(_hip_kernels_src ${type}_hip_kernels_src)
       set(_hip_test_fixture_src ${type}_hip_test_fixture_src)
     endif()
@@ -231,13 +244,15 @@ function(breeze_add_unittests dir type)
         ${dir}
         ${type}
         "sycl"
-        "generated/${dir}/kernels-sycl.hpp")
+        "generated/${dir}/kernels-sycl.hpp"
+      )
       generate_test_fixture(
         ${type}_sycl_test_fixture_src
         ${dir}
         ${type}
         "sycl"
-        "generated/${dir}/${type}_test-sycl.hpp")
+        "generated/${dir}/${type}_test-sycl.hpp"
+      )
       set(_sycl_kernels_src ${type}_sycl_kernels_src)
       set(_sycl_test_fixture_src ${type}_sycl_test_fixture_src)
     endif()
@@ -247,23 +262,20 @@ function(breeze_add_unittests dir type)
         ${dir}
         ${type}
         "openmp"
-        "generated/${dir}/kernels-openmp.h")
+        "generated/${dir}/kernels-openmp.h"
+      )
       generate_test_fixture(
         ${type}_openmp_test_fixture_src
         ${dir}
         ${type}
         "openmp"
-        "generated/${dir}/${type}_test-openmp.h")
+        "generated/${dir}/${type}_test-openmp.h"
+      )
       set(_openmp_kernels_src ${type}_openmp_kernels_src)
       set(_openmp_test_fixture_src ${type}_openmp_test_fixture_src)
     endif()
   endif()
-  breeze_add_tests(
-    ${dir}
-    ${type}
-    "_unittest"
-    ".cpp"
-    ${ARGN})
+  breeze_add_tests(${dir} ${type} "_unittest" ".cpp" ${ARGN})
 endfunction()
 
 breeze_add_unittests(
@@ -273,10 +285,6 @@ breeze_add_unittests(
   "store"
   "reduce"
   "scan"
-  "sort")
-breeze_add_unittests(
-  "algorithms"
-  "algorithm"
-  "reduce"
-  "scan"
-  "sort")
+  "sort"
+)
+breeze_add_unittests("algorithms" "algorithm" "reduce" "scan" "sort")
diff --git a/velox/experimental/breeze/test/algorithms/kernels.metal b/velox/experimental/breeze/test/algorithms/kernels.metal
index 07a91a7161bd..50caf7a9bea7 100644
--- a/velox/experimental/breeze/test/algorithms/kernels.metal
+++ b/velox/experimental/breeze/test/algorithms/kernels.metal
@@ -39,8 +39,8 @@ using namespace breeze::utils;
 
 #define GEN_REDUCE_T(O, T, BT, IPT)                                     \
   kernel void NAME(reduce_##O##_##T, T, BT, IPT)(                       \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],    \
-      const device int *num_items [[buffer(2)]],                        \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],    \
+      const device int* num_items [[buffer(2)]],                        \
       uint thread_idx [[thread_index_in_threadgroup]],                  \
       uint block_idx [[threadgroup_position_in_grid]]) {                \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, block_idx};           \
@@ -60,10 +60,10 @@ GEN_REDUCE(max)
 
 #define GEN_SCAN_T(O, T, BT, IPT, LD)                                          \
   kernel void NAME(scan_##O##_##T, uint_##T, BT, IPT##x##LD)(                  \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],           \
-      device int *next_block_idx [[buffer(2)]],                                \
-      device uint *blocks [[buffer(3)]],                                       \
-      const device int *num_items [[buffer(4)]],                               \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],           \
+      device int* next_block_idx [[buffer(2)]],                                \
+      device uint* blocks [[buffer(3)]],                                       \
+      const device int* num_items [[buffer(4)]],                               \
       uint thread_idx [[thread_index_in_threadgroup]],                         \
       uint block_idx [[threadgroup_position_in_grid]]) {                       \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, block_idx};                  \
@@ -82,8 +82,8 @@ GEN_SCAN(add)
 
 #define GEN_RADIX_SORT_HISTOGRAM_T(T, BT, IPT, TS, RB)                   \
   kernel void NAME(radix_sort_histogram, T, BT, IPT##x##TS##x##RB)(      \
-      const device T *in [[buffer(0)]], device uint *out [[buffer(1)]],  \
-      const device int *num_items [[buffer(2)]],                         \
+      const device T* in [[buffer(0)]], device uint* out [[buffer(1)]],  \
+      const device int* num_items [[buffer(2)]],                         \
       uint thread_idx [[thread_index_in_threadgroup]],                   \
       uint block_idx [[threadgroup_position_in_grid]]) {                 \
     threadgroup DeviceRadixSortHistogram<RB, T>::Scratch scratch;        \
@@ -104,16 +104,16 @@ GEN_RADIX_SORT_HISTOGRAM(uint)
 
 #define GEN_RADIX_SORT(KT, VT, BT, IPT, RB)                                \
   kernel void NAME2(radix_sort, KT, VT, BT, IPT##x##RB)(                   \
-      const device KT *in_keys [[buffer(0)]],                              \
-      const device VT##_value_type *in_values [[buffer(1)]],               \
-      const device uint *in_offsets [[buffer(2)]],                         \
-      const device int *start_bit [[buffer(3)]],                           \
-      const device int *num_pass_bits [[buffer(4)]],                       \
-      device KT *out_keys [[buffer(5)]],                                   \
-      device VT##_value_type *out_values [[buffer(6)]],                    \
-      device int *next_block_idx [[buffer(7)]],                            \
-      device uint *blocks [[buffer(8)]],                                   \
-      const device int *num_items [[buffer(9)]],                           \
+      const device KT* in_keys [[buffer(0)]],                              \
+      const device VT##_value_type* in_values [[buffer(1)]],               \
+      const device uint* in_offsets [[buffer(2)]],                         \
+      const device int* start_bit [[buffer(3)]],                           \
+      const device int* num_pass_bits [[buffer(4)]],                       \
+      device KT* out_keys [[buffer(5)]],                                   \
+      device VT##_value_type* out_values [[buffer(6)]],                    \
+      device int* next_block_idx [[buffer(7)]],                            \
+      device uint* blocks [[buffer(8)]],                                   \
+      const device int* num_items [[buffer(9)]],                           \
       uint thread_idx [[thread_index_in_threadgroup]],                     \
       uint block_idx [[threadgroup_position_in_grid]]) {                   \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, block_idx};              \
diff --git a/velox/experimental/breeze/test/functions/kernels.metal b/velox/experimental/breeze/test/functions/kernels.metal
index f8193bfad9b2..c211a78becad 100644
--- a/velox/experimental/breeze/test/functions/kernels.metal
+++ b/velox/experimental/breeze/test/functions/kernels.metal
@@ -35,8 +35,8 @@ using namespace breeze::utils;
 
 #define GEN_LOAD(T)                                                          \
   kernel void NAME(load, T, 4, 2)(                                           \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],         \
-      const device int *num_items [[buffer(2)]],                             \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],         \
+      const device int* num_items [[buffer(2)]],                             \
       uint thread_idx [[thread_index_in_threadgroup]]) {                     \
     block_load<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in, out, \
                      *num_items);                                            \
@@ -50,9 +50,9 @@ GEN_LOAD(float)
 
 #define GEN_LOAD_IF(T)                                                        \
   kernel void NAME(load_if, T, 4, 2)(                                         \
-      const device T *in [[buffer(0)]],                                       \
-      const device int *in_selection_flags [[buffer(1)]],                     \
-      device T *out [[buffer(2)]], const device int *num_items [[buffer(3)]], \
+      const device T* in [[buffer(0)]],                                       \
+      const device int* in_selection_flags [[buffer(1)]],                     \
+      device T* out [[buffer(2)]], const device int* num_items [[buffer(3)]], \
       uint thread_idx [[thread_index_in_threadgroup]]) {                      \
     block_load_if<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in,    \
                         in_selection_flags, out, *num_items);                 \
@@ -66,9 +66,9 @@ GEN_LOAD_IF(float)
 
 #define GEN_LOAD_FROM(T)                                                     \
   kernel void NAME(load_from, T, 4, 2)(                                      \
-      const device T *in [[buffer(0)]],                                      \
-      const device int *offsets [[buffer(1)]], device T *out [[buffer(2)]],  \
-      const device int *num_items [[buffer(3)]],                             \
+      const device T* in [[buffer(0)]],                                      \
+      const device int* offsets [[buffer(1)]], device T* out [[buffer(2)]],  \
+      const device int* num_items [[buffer(3)]],                             \
       uint thread_idx [[thread_index_in_threadgroup]]) {                     \
     block_load_from<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in, \
                           offsets, out, *num_items);                         \
@@ -82,8 +82,8 @@ GEN_LOAD_FROM(float)
 
 #define GEN_STORE(T)                                                          \
   kernel void NAME(store, T, 4, 2)(                                           \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],          \
-      const device int *num_items [[buffer(2)]],                              \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],          \
+      const device int* num_items [[buffer(2)]],                              \
       uint thread_idx [[thread_index_in_threadgroup]]) {                      \
     block_store<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in, out, \
                       *num_items);                                            \
@@ -97,9 +97,9 @@ GEN_STORE(float)
 
 #define GEN_STORE_IF(T)                                                       \
   kernel void NAME(store_if, T, 4, 2)(                                        \
-      const device T *in [[buffer(0)]],                                       \
-      const device int *selection_flags [[buffer(1)]],                        \
-      device T *out [[buffer(2)]], const device int *num_items [[buffer(3)]], \
+      const device T* in [[buffer(0)]],                                       \
+      const device int* selection_flags [[buffer(1)]],                        \
+      device T* out [[buffer(2)]], const device int* num_items [[buffer(3)]], \
       uint thread_idx [[thread_index_in_threadgroup]]) {                      \
     block_store_if<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, in,   \
                          selection_flags, out, *num_items);                   \
@@ -113,9 +113,9 @@ GEN_STORE_IF(float)
 
 #define GEN_STORE_AT(T)                                                     \
   kernel void NAME(store_at, T, 1, 8)(                                      \
-      const device T *in [[buffer(0)]],                                     \
-      const device int *offsets [[buffer(1)]], device T *out [[buffer(2)]], \
-      const device int *num_items [[buffer(3)]],                            \
+      const device T* in [[buffer(0)]],                                     \
+      const device int* offsets [[buffer(1)]], device T* out [[buffer(2)]], \
+      const device int* num_items [[buffer(3)]],                            \
       uint thread_idx [[thread_index_in_threadgroup]]) {                    \
     block_store_at<1, 8>(MetalPlatform<1, WARP_THREADS>{thread_idx, 0}, in, \
                          offsets, out, *num_items);                         \
@@ -129,10 +129,10 @@ GEN_STORE_AT(float)
 
 #define GEN_STORE_AT_IF(T)                                                     \
   kernel void NAME(store_at_if, T, 1, 8)(                                      \
-      const device T *in [[buffer(0)]],                                        \
-      const device int *offsets [[buffer(1)]],                                 \
-      const device int *selection_flags [[buffer(2)]],                         \
-      device T *out [[buffer(3)]], const device int *num_items [[buffer(4)]],  \
+      const device T* in [[buffer(0)]],                                        \
+      const device int* offsets [[buffer(1)]],                                 \
+      const device int* selection_flags [[buffer(2)]],                         \
+      device T* out [[buffer(3)]], const device int* num_items [[buffer(4)]],  \
       uint thread_idx [[thread_index_in_threadgroup]]) {                       \
     block_store_at_if<1, 8>(MetalPlatform<1, WARP_THREADS>{thread_idx, 0}, in, \
                             offsets, selection_flags, out, *num_items);        \
@@ -146,8 +146,8 @@ GEN_STORE_AT_IF(float)
 
 #define GEN_FILL(T)                                                        \
   kernel void NAME(fill, T, 4, 2)(                                         \
-      const device T *value [[buffer(0)]], device T *out [[buffer(1)]],    \
-      const device int *num_items [[buffer(2)]],                           \
+      const device T* value [[buffer(0)]], device T* out [[buffer(1)]],    \
+      const device int* num_items [[buffer(2)]],                           \
       uint thread_idx [[thread_index_in_threadgroup]]) {                   \
     block_fill<4, 2>(MetalPlatform<4, WARP_THREADS>{thread_idx, 0}, value, \
                      out, *num_items);                                     \
@@ -161,10 +161,10 @@ GEN_FILL(float)
 
 #define GEN_FILL_AT_IF(T)                                                     \
   kernel void NAME(fill_at_if, T, 1, 8)(                                      \
-      const device T *value [[buffer(0)]],                                    \
-      const device int *offsets [[buffer(1)]],                                \
-      const device int *selection_flags [[buffer(2)]],                        \
-      device T *out [[buffer(3)]], const device int *num_items [[buffer(4)]], \
+      const device T* value [[buffer(0)]],                                    \
+      const device int* offsets [[buffer(1)]],                                \
+      const device int* selection_flags [[buffer(2)]],                        \
+      device T* out [[buffer(3)]], const device int* num_items [[buffer(4)]], \
       uint thread_idx [[thread_index_in_threadgroup]]) {                      \
     block_fill_at_if<1, 8>(MetalPlatform<1, WARP_THREADS>{thread_idx, 0},     \
                            value, offsets, selection_flags, out, *num_items); \
@@ -182,8 +182,8 @@ GEN_FILL_AT_IF(float)
 
 #define GEN_REDUCE_T(O, T, BT, IPT)                                         \
   kernel void NAME(reduce_##O##_##T, T, BT, IPT)(                           \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],        \
-      const device int *num_items [[buffer(2)]],                            \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],        \
+      const device int* num_items [[buffer(2)]],                            \
       uint thread_idx [[thread_index_in_threadgroup]]) {                    \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, 0};                       \
     threadgroup BlockReduce<decltype(p), T>::Scratch scratch;               \
@@ -206,8 +206,8 @@ GEN_REDUCE(max)
 
 #define GEN_SCAN_T(O, T, BT, IPT)                                       \
   kernel void NAME(scan_##O##_##T, T, BT, IPT)(                         \
-      const device T *in [[buffer(0)]], device T *out [[buffer(1)]],    \
-      const device int *num_items [[buffer(2)]],                        \
+      const device T* in [[buffer(0)]], device T* out [[buffer(1)]],    \
+      const device int* num_items [[buffer(2)]],                        \
       uint thread_idx [[thread_index_in_threadgroup]]) {                \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, 0};                   \
     threadgroup BlockScan<decltype(p), T, IPT>::Scratch scratch;        \
@@ -226,8 +226,8 @@ GEN_SCAN(add)
 
 #define GEN_RADIX_RANK(T, BT, IPT, RB)                                 \
   kernel void NAME(radix_rank, T, BT, IPT##x##RB)(                     \
-      const device T *in [[buffer(0)]], device int *out [[buffer(1)]], \
-      const device int *num_items [[buffer(2)]],                       \
+      const device T* in [[buffer(0)]], device int* out [[buffer(1)]], \
+      const device int* num_items [[buffer(2)]],                       \
       uint thread_idx [[thread_index_in_threadgroup]]) {               \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, 0};                  \
     threadgroup BlockRadixRank<decltype(p), IPT, RB>::Scratch scratch; \
@@ -242,11 +242,11 @@ GEN_RADIX_RANK(uint, 64, 2, 6)
 
 #define GEN_RADIX_SORT(KT, VT, BT, IPT, RB)                                    \
   kernel void NAME2(radix_sort, KT, VT, BT, IPT##x##RB)(                       \
-      const device KT *in_keys [[buffer(0)]],                                  \
-      const device VT##_value_type *in_values [[buffer(1)]],                   \
-      device KT *out_keys [[buffer(2)]],                                       \
-      device VT##_value_type *out_values [[buffer(3)]],                        \
-      const device int *num_items [[buffer(4)]],                               \
+      const device KT* in_keys [[buffer(0)]],                                  \
+      const device VT##_value_type* in_values [[buffer(1)]],                   \
+      device KT* out_keys [[buffer(2)]],                                       \
+      device VT##_value_type* out_values [[buffer(3)]],                        \
+      const device int* num_items [[buffer(4)]],                               \
       uint thread_idx [[thread_index_in_threadgroup]]) {                       \
     MetalPlatform<BT, WARP_THREADS> p{thread_idx, 0};                          \
     threadgroup BlockRadixSort<decltype(p), IPT, RB, KT,                       \
diff --git a/velox/experimental/breeze/test/generate.sh b/velox/experimental/breeze/test/generate.sh
index 2bdb15e17587..fa7ea697969a 100755
--- a/velox/experimental/breeze/test/generate.sh
+++ b/velox/experimental/breeze/test/generate.sh
@@ -19,13 +19,13 @@ SCRIPTDIR=$(dirname "${BASH_SOURCE[0]}")
 cd "$SCRIPTDIR"
 
 function generate {
-    BACKEND=$1
-    TYPE=$2
-    EXT=$3
-    DIR="$TYPE"s
-    mkdir -p generated/"$DIR"
-    ./kernel_generator.py --backend="$BACKEND" --template="$DIR"/"$TYPE"-kernels.template.h --out=generated/"$DIR"/kernels-"$BACKEND"."$EXT" ${LLVM_PATH:+-l "$LLVM_PATH"}
-    ./test_fixture_generator.py --backend="$BACKEND" --template="$DIR"/"$TYPE"_test.template.h --out=generated/"$DIR"/"$TYPE"_test-"$BACKEND"."$EXT" ${LLVM_PATH:+-l "$LLVM_PATH"}
+  BACKEND=$1
+  TYPE=$2
+  EXT=$3
+  DIR="$TYPE"s
+  mkdir -p generated/"$DIR"
+  ./kernel_generator.py --backend="$BACKEND" --template="$DIR"/"$TYPE"-kernels.template.h --out=generated/"$DIR"/kernels-"$BACKEND"."$EXT" ${LLVM_PATH:+-l "$LLVM_PATH"}
+  ./test_fixture_generator.py --backend="$BACKEND" --template="$DIR"/"$TYPE"_test.template.h --out=generated/"$DIR"/"$TYPE"_test-"$BACKEND"."$EXT" ${LLVM_PATH:+-l "$LLVM_PATH"}
 }
 
 generate openmp "algorithm" h
diff --git a/velox/experimental/cudf/.clang-tidy b/velox/experimental/cudf/.clang-tidy
index ec5b4e407844..61c04b1dbd5b 100644
--- a/velox/experimental/cudf/.clang-tidy
+++ b/velox/experimental/cudf/.clang-tidy
@@ -44,11 +44,11 @@ CheckOptions:
     value: CamelCase
   - key: readability-identifier-naming.EnumConstantPrefix
     value: k
-    
+
   # Use nullptr instead of NULL or 0
   - key: modernize-use-nullptr.NullMacros
     value: 'NULL'
-    
+
   # Prefer enum class over enum
   - key: modernize-use-using.IgnoreUsingStdAllocator
-    value: 1 
\ No newline at end of file
+    value: 1
diff --git a/velox/experimental/cudf/CMakeLists.txt b/velox/experimental/cudf/CMakeLists.txt
index 6d400056c35a..7bc45500d87d 100644
--- a/velox/experimental/cudf/CMakeLists.txt
+++ b/velox/experimental/cudf/CMakeLists.txt
@@ -13,7 +13,14 @@
 # limitations under the License.
 
 add_subdirectory(exec)
+add_subdirectory(connectors)
+add_subdirectory(vector)
+add_subdirectory(expression)
 
 if(VELOX_BUILD_TESTING)
   add_subdirectory(tests)
 endif()
+
+if(VELOX_ENABLE_BENCHMARKS)
+  add_subdirectory(benchmarks)
+endif()
diff --git a/velox/experimental/cudf/CudfConfig.h b/velox/experimental/cudf/CudfConfig.h
new file mode 100644
index 000000000000..92657d8fc7ed
--- /dev/null
+++ b/velox/experimental/cudf/CudfConfig.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 <string>
+#include <unordered_map>
+
+namespace facebook::velox::cudf_velox {
+
+struct CudfConfig {
+  /// Keys used by the initialize() method.
+  static constexpr const char* kCudfEnabled{"cudf.enabled"};
+  static constexpr const char* kCudfDebugEnabled{"cudf.debug_enabled"};
+  static constexpr const char* kCudfMemoryResource{"cudf.memory_resource"};
+  static constexpr const char* kCudfMemoryPercent{"cudf.memory_percent"};
+  static constexpr const char* kCudfFunctionNamePrefix{
+      "cudf.function_name_prefix"};
+  static constexpr const char* kCudfAstExpressionEnabled{
+      "cudf.ast_expression_enabled"};
+  static constexpr const char* kCudfAstExpressionPriority{
+      "cudf.ast_expression_priority"};
+  static constexpr const char* kCudfAllowCpuFallback{"cudf.allow_cpu_fallback"};
+  static constexpr const char* kCudfLogFallback{"cudf.log_fallback"};
+
+  /// Singleton CudfConfig instance.
+  /// Clients must set the configs below before invoking registerCudf().
+  static CudfConfig& getInstance();
+
+  /// Initialize from a map with the above keys.
+  void initialize(std::unordered_map<std::string, std::string>&&);
+
+  /// Enable cudf by default.
+  /// Clients can disable here and enable it via the QueryConfig as well.
+  bool enabled{true};
+
+  /// Enable debug printing.
+  bool debugEnabled{false};
+
+  /// Allow fallback to CPU operators if GPU operator replacement fails.
+  bool allowCpuFallback{true};
+
+  /// Memory resource for cuDF.
+  /// Possible values are (cuda, pool, async, arena, managed, managed_pool).
+  std::string memoryResource{"async"};
+
+  /// The initial percent of GPU memory to allocate for pool or arena memory
+  /// resources.
+  int32_t memoryPercent{50};
+
+  /// Register all the functions with the functionNamePrefix.
+  std::string functionNamePrefix;
+
+  /// Enable AST in expression evaluation
+  bool astExpressionEnabled{true};
+
+  /// Priority of AST expression. Expression with higher priority is chosen for
+  /// a given root expression.
+  /// Example:
+  /// Priority of expression that uses individual cuDF functions is 50.
+  /// If AST priority is 100 then for a velox expression node that is supported
+  /// by both, AST will be chosen as replacement for cudf execution, if AST
+  /// priority is 25 then standalone cudf function is chosen.
+  int astExpressionPriority{100};
+
+  /// Whether to log a reason for falling back to Velox CPU execution.
+  bool logFallback{true};
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/CudfQueryConfig.h b/velox/experimental/cudf/CudfQueryConfig.h
new file mode 100644
index 000000000000..9d657dfcf95f
--- /dev/null
+++ b/velox/experimental/cudf/CudfQueryConfig.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
+
+namespace facebook::velox::cudf_velox {
+
+/// CudfQueryConfig - Query session configs for the cuDF Operators.
+struct CudfQueryConfig {
+  // Query config key for the TopN batch size in the cuDF TopN operator.
+  static constexpr const char* kCudfTopNBatchSize{"cudf.topk_batch_size"};
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/README.md b/velox/experimental/cudf/README.md
new file mode 100644
index 000000000000..7ea513abcd12
--- /dev/null
+++ b/velox/experimental/cudf/README.md
@@ -0,0 +1,70 @@
+# Velox-cuDF
+
+Velox-cuDF is a Velox extension module that uses the cuDF library to implement a GPU-accelerated backend for executing Velox plans. [cuDF](https://github.com/rapidsai/cudf) is an open source library for GPU data processing, and Velox-cuDF integrates with "[libcudf](https://github.com/rapidsai/cudf/tree/main/cpp)", the CUDA C++ core of cuDF. libcudf uses [Arrow](https://arrow.apache.org)-compatible data layouts and includes single-node, single-GPU algorithms for data processing.
+
+## How Velox and cuDF work together
+
+Velox-cuDF implements the Velox [DriverAdapter](https://github.com/facebookincubator/velox/blob/d9f953cd23880f29593534f1ba9031c6cea8ba06/velox/exec/Driver.h#L695) interface as [CudfDriverAdapter](https://github.com/facebookincubator/velox/blob/226b92cefedce4b8a484bfc351260edbd3d2e501/velox/experimental/cudf/exec/ToCudf.cpp#L301) to rewrite query plans for GPU execution. Generally the cuDF DriverAdapter replaces operators one-to-one. For end-to-end GPU execution where cuDF replaces all of the Velox CPU operators, cuDF relies on Velox's [pipeline-based execution model](https://facebookincubator.github.io/velox/develop/task.html) to separate stages of execution, partition the work across drivers, and schedule concurrent work on the GPU.
+
+For more information please refer to our blog: "[Extending Velox - GPU Acceleration with cuDF](https://velox-lib.io/blog/extending-velox-with-cudf)."
+
+## Getting started with Velox-cuDF
+
+cuDF supports Linux and WSL2 but not Windows or MacOS. cuDF also has minimum CUDA version, NVIDIA driver and GPU architecture requirements which can be found in the [RAPIDS Installation Guide](https://docs.rapids.ai/install/). Please refer to cuDF's [readme](https://github.com/rapidsai/cudf) and [developer guide](https://github.com/rapidsai/cudf/blob/main/cpp/doxygen/developer_guide/DEVELOPER_GUIDE.md) for more information.
+
+### Building Velox with cuDF
+
+The cuDF backend is included in Velox builds when the [VELOX_ENABLE_CUDF](https://github.com/facebookincubator/velox/blob/43df50c4f24bcbfa96f5739c072ab0894d41cf4c/CMakeLists.txt#L455) CMake option is set. The `adapters-cuda` service in Velox's [docker-compose.yml](https://github.com/facebookincubator/velox/blob/43df50c4f24bcbfa96f5739c072ab0894d41cf4c/docker-compose.yml#L69) is an excellent starting point for Velox builds with cuDF.
+
+1. Use `docker compose` to run an `adapters-cuda` image.
+```
+$ docker compose -f docker-compose.yml run -e NUM_THREADS=8 --rm -v "$(pwd):/velox" adapters-cuda /bin/bash
+```
+2. Once inside the image, build cuDF with the following flags:
+```
+$ CUDA_ARCHITECTURES="native" EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_ARROW=ON -DVELOX_ENABLE_PARQUET=ON -DVELOX_ENABLE_BENCHMARKS=ON -DVELOX_ENABLE_BENCHMARKS_BASIC=ON" make cudf
+```
+3. After cuDF is built, verify the build by running the unit tests.
+```
+$ cd _build/release
+$ ctest -R cudf -V
+```
+
+Velox-cuDF builds are included in Velox CI as part of the [adapters build](https://github.com/facebookincubator/velox/blob/de31a3eb07b5ec3cbd1e6320a989fcb2ee1a95a7/.github/workflows/linux-build-base.yml#L85). The build step for cuDF does not require the worker to have a GPU, so adding a Velox-cuDF build step to Velox CI is compatible with the existing runners.
+
+### Configuring Velox-cuDF
+
+Velox-cuDF provides several configuration properties to control GPU execution behavior, memory management, and debugging. These configurations are available when compiled with cuDF support and can be set via Velox's configuration system. For a complete list of cuDF-specific configuration properties and their descriptions, see the [Cudf-specific Configuration section](https://facebookincubator.github.io/velox/configs.html#cudf-specific-configuration-experimental) in the Velox configuration documentation.
+
+### Testing Velox with cuDF
+
+Tests with Velox-cuDF can only be run on GPU-enabled hardware. The Velox-cuDF tests in [experimental/cudf/tests](https://github.com/facebookincubator/velox/blob/main/velox/experimental/cudf/tests) include several types of tests:
+* operator tests
+* function tests
+* fuzz tests (not yet implemented)
+
+The repo [rapidsai/velox-testing](https://github.com/rapidsai/velox-testing/) includes standard scripts for testing Velox-cuDF. Please refer to the [test_velox.sh](https://github.com/rapidsai/velox-testing/blob/main/velox/scripts/test_velox.sh) for running the Velox-cuDF unit tests. We plan to first develop GitHub Actions for GPU CI in [rapidsai/velox-testing](https://github.com/rapidsai/velox-testing/), and then later transition GPU-enabled GitHub Actions to Velox mainline.
+
+#### Operator tests
+
+Many of the tests for cuDF are "operator tests" which confirm correct execution of simple query plans. cuDF's operator tests use `CudfDriverAdapter` to modify the test plan with GPU operators before executing it. The operator tests for cuDF include both tests that assert successful GPU operator replacement, and tests that pass with CPU fallback.
+
+#### Function tests
+
+Velox-cuDF also includes "function tests" which cover the behavior of shared functions that could be called in multiple operators. Velox-cuDF function tests assess the correctness of functions using one or more cuDF API calls to provide the output. [SubfieldFilterAstTest](https://github.com/facebookincubator/velox/blob/99a04b94eed42d1c35ae99101da3bf77b31652e8/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp#L158) includes several examples of function tests. Please note that unit tests for cuDF APIs are included in [cudf/cpp/tests](https://github.com/rapidsai/cudf/tree/branch-25.10/cpp/tests) rather than Velox.
+
+#### Fuzz tests
+
+Velox includes components for "fuzz testing" to ensure robustness of Velox operators. For instance, the [Join Fuzzer](https://github.com/facebookincubator/velox/blob/99a04b94eed42d1c35ae99101da3bf77b31652e8/velox/docs/develop/testing/join-fuzzer.rst) executes a random join type with random inputs and compares the Velox results with a reference query engine. Fuzz testing tools have been used for cuDF operator development, but fuzz testing for cuDF is not yet integrated into Velox mainline.
+
+### Benchmarking Velox with cuDF
+
+Velox's [TpchBenchmark](https://github.com/facebookincubator/velox/blob/d9f953cd23880f29593534f1ba9031c6cea8ba06/velox/benchmarks/tpch/TpchBenchmark.cpp) is derived from [TPC-H](https://www.tpc.org/tpch/) and provides a convenient tool for  benchmarking Velox's performance with OLAP (Online Analytical Processing) workloads. Velox-cuDF includes GPU operators for the hand-built query plans located in [TpchQueryBuilder](https://github.com/facebookincubator/velox/blob/43df50c4f24bcbfa96f5739c072ab0894d41cf4c/velox/exec/tests/utils/TpchQueryBuilder.cpp). Velox [PR 13695](https://github.com/facebookincubator/velox/pull/13695) extends Velox's TpchBenchmark to the cuDF backend.
+
+Please note that Velox's hand-built query plans require the data set to have floating-point types in place of the fixed-point types defined in the standard. Further development of Velox's TpchBenchmark could allow correct behavior with both fixed-point and floating-point types.
+
+## Contributing
+
+Velox-cuDF's development priorities are documented as Velox issues using the "[cuDF]" prefix. Please check out the [open issues](https://github.com/facebookincubator/velox/issues?q=is%3Aissue%20state%3Aopen%20%5BcuDF%5D) to learn more.
+
+We would love to hear from you in Velox's Slack workspace, please see Velox discussion [11348](https://github.com/facebookincubator/velox/discussions/11348) for information on joining.
diff --git a/velox/experimental/cudf/benchmarks/CMakeLists.txt b/velox/experimental/cudf/benchmarks/CMakeLists.txt
new file mode 100644
index 000000000000..71e8e80c753b
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CMakeLists.txt
@@ -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.
+
+add_executable(velox_cudf_tpch_benchmark CudfTpchBenchmark.cpp)
+
+target_link_libraries(
+  velox_cudf_tpch_benchmark
+  velox_cudf_exec
+  velox_cudf_exec_test_lib
+  velox_tpch_benchmark_lib
+)
diff --git a/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.cpp b/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.cpp
new file mode 100644
index 000000000000..4e45df761911
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.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/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/benchmarks/CudfTpchBenchmark.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
+
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+
+#include <experimental/cudf/connectors/hive/CudfHiveConnector.h>
+
+DECLARE_int64(max_coalesced_bytes);
+DECLARE_string(max_coalesced_distance_bytes);
+DECLARE_int32(parquet_prefetch_rowgroups);
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::dwio::common;
+
+DEFINE_uint64(
+    cudf_chunk_read_limit,
+    0,
+    "Output table chunk read limit for cudf::parquet_chunked_reader.");
+
+DEFINE_uint64(
+    cudf_pass_read_limit,
+    0,
+    "Pass read limit for cudf::parquet_chunked_reader.");
+
+DEFINE_int32(
+    cudf_gpu_batch_size_rows,
+    100000,
+    "Preferred output batch size in rows for cudf operators.");
+
+DEFINE_string(
+    cudf_memory_resource,
+    "async",
+    "Memory resource for cudf operators.");
+
+DEFINE_int32(
+    cudf_memory_percent,
+    50,
+    "Percentage of GPU memory to allocate for cudf operators.");
+
+DEFINE_bool(velox_cudf_table_scan, true, "Enable cuDF table scan");
+
+void CudfTpchBenchmark::initialize() {
+  TpchBenchmark::initialize();
+
+  if (FLAGS_velox_cudf_table_scan) {
+    connector::unregisterConnector(
+        facebook::velox::exec::test::kHiveConnectorId);
+
+    // Add new values into the cudfHive configuration...
+    auto cudfHiveConfigurationValues =
+        std::unordered_map<std::string, std::string>();
+    cudfHiveConfigurationValues
+        [cudf_velox::connector::hive::CudfHiveConfig::kMaxChunkReadLimit] =
+            std::to_string(FLAGS_cudf_chunk_read_limit);
+    cudfHiveConfigurationValues
+        [cudf_velox::connector::hive::CudfHiveConfig::kMaxPassReadLimit] =
+            std::to_string(FLAGS_cudf_pass_read_limit);
+    cudfHiveConfigurationValues[cudf_velox::connector::hive::CudfHiveConfig::
+                                    kAllowMismatchedCudfHiveSchemas] =
+        std::to_string(true);
+    auto cudfHiveProperties = std::make_shared<const config::ConfigBase>(
+        std::move(cudfHiveConfigurationValues));
+
+    // Create cudfHive connector with config...
+    cudf_velox::connector::hive::CudfHiveConnectorFactory cudfHiveFactory;
+    auto cudfHiveConnector = cudfHiveFactory.newConnector(
+        facebook::velox::exec::test::kHiveConnectorId,
+        cudfHiveProperties,
+        ioExecutor_.get());
+    connector::registerConnector(cudfHiveConnector);
+  }
+
+  cudf_velox::CudfConfig::getInstance().memoryResource =
+      FLAGS_cudf_memory_resource;
+  cudf_velox::CudfConfig::getInstance().memoryPercent =
+      FLAGS_cudf_memory_percent;
+
+  // Enable cuDF operators
+  cudf_velox::registerCudf();
+
+  // Add custom configs
+  queryConfigs_[facebook::velox::cudf_velox::CudfFromVelox::kGpuBatchSizeRows] =
+      std::to_string(FLAGS_cudf_gpu_batch_size_rows);
+}
+
+std::shared_ptr<config::ConfigBase>
+CudfTpchBenchmark::makeConnectorProperties() {
+  auto cfg = TpchBenchmark::makeConnectorProperties();
+  using CudfHiveCfg = cudf_velox::connector::hive::CudfHiveConfig;
+
+  // CuDF-specific properties.
+  cfg->set(
+      CudfHiveCfg::kMaxChunkReadLimit,
+      std::to_string(FLAGS_cudf_chunk_read_limit));
+  cfg->set(
+      CudfHiveCfg::kMaxPassReadLimit,
+      std::to_string(FLAGS_cudf_pass_read_limit));
+  cfg->set(CudfHiveCfg::kAllowMismatchedCudfHiveSchemas, "true");
+
+  return cfg;
+}
+
+std::vector<std::shared_ptr<connector::ConnectorSplit>>
+CudfTpchBenchmark::listSplits(
+    const std::string& path,
+    int32_t numSplitsPerFile,
+    const exec::test::TpchPlan& plan) {
+  // TODO (dm): Figure out a way to enforce 1 split per file in
+  // CudfHiveDataSource outside of this benchmark
+  if (FLAGS_velox_cudf_table_scan) {
+    // TODO (dm): Instead of this, we can maybe use
+    // makeHiveConnectorSplits(vector<shared_ptr<TempFilePath>>& filePaths)
+    std::vector<std::shared_ptr<connector::ConnectorSplit>> result;
+    auto temp = HiveConnectorTestBase::makeHiveConnectorSplits(
+        path, 1, plan.dataFileFormat);
+    for (auto& i : temp) {
+      result.push_back(i);
+    }
+    return result;
+  }
+
+  return TpchBenchmark::listSplits(path, numSplitsPerFile, plan);
+}
+
+void CudfTpchBenchmark::shutdown() {
+  cudf_velox::unregisterCudf();
+  TpchBenchmark::shutdown();
+}
+
+int main(int argc, char** argv) {
+  std::string kUsage(
+      "This program benchmarks TPC-H queries. Run 'velox_cudf_tpch_benchmark -helpon=TpchBenchmark' for available options.\n");
+  gflags::SetUsageMessage(kUsage);
+  folly::Init init{&argc, &argv, false};
+  benchmark = std::make_unique<CudfTpchBenchmark>();
+  tpchBenchmarkMain();
+}
diff --git a/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.h b/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.h
new file mode 100644
index 000000000000..054e2d65a78a
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/CudfTpchBenchmark.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/benchmarks/tpch/TpchBenchmark.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class CudfTpchBenchmark : public TpchBenchmark {
+ public:
+  void initialize() override;
+
+  std::shared_ptr<facebook::velox::config::ConfigBase> makeConnectorProperties()
+      override;
+
+  std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+  listSplits(
+      const std::string& path,
+      int32_t numSplitsPerFile,
+      const facebook::velox::exec::test::TpchPlan& plan) override;
+
+  void shutdown() override;
+};
diff --git a/velox/experimental/cudf/benchmarks/benchmark.sh b/velox/experimental/cudf/benchmarks/benchmark.sh
new file mode 100755
index 000000000000..86fe70f3f4fa
--- /dev/null
+++ b/velox/experimental/cudf/benchmarks/benchmark.sh
@@ -0,0 +1,77 @@
+#!/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 -euo pipefail
+
+# Put the generated data in the directory velox-tpch-sf10-data at the root of this repo
+
+# Run this to launch the CUDA container:
+# docker-compose run -e NUM_THREADS=$(nproc) --rm adapters-cuda /bin/bash
+# Then run the following to build with GPU support.
+# CUDA_ARCHITECTURES=native EXTRA_CMAKE_FLAGS="-DVELOX_ENABLE_BENCHMARKS=ON" make cudf
+# Then invoke this script from the root of the repo:
+# ./velox/experimental/cudf/benchmarks/benchmark.sh
+
+mkdir -p benchmark_results
+
+queries=${1:-$(seq 1 22)}
+devices=${2:-"cpu gpu"}
+profile=${3:-"false"}
+
+cudf_chunk_read_limit=$((1024 * 1024 * 1024 * 1))
+cudf_pass_read_limit=0
+VELOX_CUDF_MEMORY_RESOURCE="async"
+VELOX_CUDF_MEMORY_PERCENT=0
+
+for query_number in ${queries}; do
+  printf -v query_number '%02d' "${query_number}"
+  for device in ${devices}; do
+    case "${device}" in
+    "cpu")
+      num_drivers=${NUM_DRIVERS:-32}
+      BENCHMARK_EXECUTABLE=./_build/release/velox/benchmarks/tpch/velox_tpch_benchmark
+      CUDF_FLAGS=""
+      ;;
+    "gpu")
+      num_drivers=${NUM_DRIVERS:-4}
+      BENCHMARK_EXECUTABLE=./_build/release/velox/experimental/cudf/benchmarks/velox_cudf_tpch_benchmark
+      CUDF_FLAGS="--velox_cudf_table_scan=true --cudf_chunk_read_limit=${cudf_chunk_read_limit} --cudf_pass_read_limit=${cudf_pass_read_limit} --cudf_memory_resource=${VELOX_CUDF_MEMORY_RESOURCE} --cudf_memory_percent=${VELOX_CUDF_MEMORY_PERCENT}"
+      ;;
+    esac
+    echo "Running query ${query_number} on ${device} with ${num_drivers} drivers."
+    # The benchmarks segfault after reporting results, so we disable errors
+    PROFILE_CMD=""
+    if [[ ${profile} == "true" ]]; then
+      PROFILE_CMD="nsys profile -t nvtx,cuda,osrt -f true --cuda-memory-usage=true --cuda-um-cpu-page-faults=true --cuda-um-gpu-page-faults=true --output=benchmark_results/q${query_number}_${device}_${num_drivers}_drivers.nsys-rep"
+      # Enable GPU metrics if supported (Ampere or newer)
+      if [[ "$(nvidia-smi --query-gpu=compute_cap --format=csv,noheader -i 0 | cut -d '.' -f 1)" -gt 7 ]]; then
+        device_id=${CUDA_VISIBLE_DEVICES:-"0"}
+        PROFILE_CMD="${PROFILE_CMD} --gpu-metrics-devices=${device_id}"
+      fi
+    fi
+
+    set +e -x
+    ${PROFILE_CMD} \
+      ${BENCHMARK_EXECUTABLE} \
+      --data_path=velox-tpch-sf10-data \
+      --data_format=parquet \
+      --run_query_verbose=${query_number} \
+      --num_repeats=1 \
+      --num_drivers=${num_drivers} \
+      ${CUDF_FLAGS} 2>&1 |
+      tee benchmark_results/q${query_number}_${device}_${num_drivers}_drivers
+    { set -e +x; } &>/dev/null
+  done
+done
diff --git a/velox/experimental/cudf/connectors/CMakeLists.txt b/velox/experimental/cudf/connectors/CMakeLists.txt
new file mode 100644
index 000000000000..d73b2c3e1286
--- /dev/null
+++ b/velox/experimental/cudf/connectors/CMakeLists.txt
@@ -0,0 +1,15 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(hive)
diff --git a/velox/experimental/cudf/connectors/hive/CMakeLists.txt b/velox/experimental/cudf/connectors/hive/CMakeLists.txt
new file mode 100644
index 000000000000..5b7ec82ae9fd
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CMakeLists.txt
@@ -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.
+
+add_library(
+  velox_cudf_hive_connector
+  CudfHiveConfig.cpp
+  CudfHiveConnector.cpp
+  CudfHiveConnectorSplit.cpp
+  CudfHiveDataSource.cpp
+  CudfHiveDataSourceHelpers.cpp
+  CudfHiveDataSink.cpp
+  CudfHiveTableHandle.cpp
+)
+
+set_target_properties(velox_cudf_hive_connector PROPERTIES CUDA_ARCHITECTURES native)
+
+target_link_libraries(
+  velox_cudf_hive_connector
+  PRIVATE velox_hive_connector
+  PUBLIC cudf::cudf velox_cudf_expression
+)
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConfig.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveConfig.cpp
new file mode 100644
index 000000000000..d04849e87a57
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConfig.cpp
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/connectors/hive/CudfHiveConfig.h"
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/config/Config.h"
+
+#include <cudf/types.hpp>
+
+#include <optional>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+int64_t CudfHiveConfig::skipRows() const {
+  return config_->get<int64_t>(kSkipRows, 0);
+}
+
+std::optional<cudf::size_type> CudfHiveConfig::numRows() const {
+  auto numRows = config_->get<cudf::size_type>(kNumRows);
+  return numRows.has_value()
+      ? std::make_optional<cudf::size_type>(numRows.value())
+      : std::nullopt;
+}
+
+std::size_t CudfHiveConfig::maxChunkReadLimit() const {
+  // chunk read limit = 0 means no limit
+  return config_->get<std::size_t>(kMaxChunkReadLimit, 0);
+}
+
+std::size_t CudfHiveConfig::maxChunkReadLimitSession(
+    const config::ConfigBase* session) const {
+  // pass read limit = 0 means no limit
+  return session->get<std::size_t>(
+      kMaxChunkReadLimitSession,
+      config_->get<std::size_t>(kMaxChunkReadLimit, 0));
+}
+
+std::size_t CudfHiveConfig::maxPassReadLimit() const {
+  // pass read limit = 0 means no limit
+  return config_->get<std::size_t>(kMaxPassReadLimit, 0);
+}
+
+std::size_t CudfHiveConfig::maxPassReadLimitSession(
+    const config::ConfigBase* session) const {
+  // pass read limit = 0 means no limit
+  return session->get<std::size_t>(
+      kMaxPassReadLimitSession,
+      config_->get<std::size_t>(kMaxPassReadLimit, 0));
+}
+
+bool CudfHiveConfig::isConvertStringsToCategories() const {
+  return config_->get<bool>(kConvertStringsToCategories, false);
+}
+
+bool CudfHiveConfig::isConvertStringsToCategoriesSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kConvertStringsToCategoriesSession,
+      config_->get<bool>(kConvertStringsToCategories, false));
+}
+
+bool CudfHiveConfig::isUsePandasMetadata() const {
+  return config_->get<bool>(kUsePandasMetadata, true);
+}
+
+bool CudfHiveConfig::isUsePandasMetadataSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kUsePandasMetadataSession, config_->get<bool>(kUsePandasMetadata, true));
+}
+
+bool CudfHiveConfig::isUseArrowSchema() const {
+  return config_->get<bool>(kUseArrowSchema, true);
+}
+
+bool CudfHiveConfig::isUseArrowSchemaSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kUseArrowSchemaSession, config_->get<bool>(kUseArrowSchema, true));
+}
+
+bool CudfHiveConfig::isAllowMismatchedCudfHiveSchemas() const {
+  return config_->get<bool>(kAllowMismatchedCudfHiveSchemas, false);
+}
+
+bool CudfHiveConfig::isAllowMismatchedCudfHiveSchemasSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kAllowMismatchedCudfHiveSchemasSession,
+      config_->get<bool>(kAllowMismatchedCudfHiveSchemas, false));
+}
+
+cudf::data_type CudfHiveConfig::timestampType() const {
+  const auto unit = config_->get<cudf::type_id>(
+      kTimestampType, cudf::type_id::TIMESTAMP_MILLISECONDS /*milli*/);
+  VELOX_CHECK(
+      unit == cudf::type_id::TIMESTAMP_DAYS /*days*/ ||
+          unit == cudf::type_id::TIMESTAMP_SECONDS /*seconds*/ ||
+          unit == cudf::type_id::TIMESTAMP_MILLISECONDS /*milli*/ ||
+          unit == cudf::type_id::TIMESTAMP_MICROSECONDS /*micro*/ ||
+          unit == cudf::type_id::TIMESTAMP_NANOSECONDS /*nano*/,
+      "Invalid timestamp unit.");
+  return cudf::data_type(cudf::type_id{unit});
+}
+
+cudf::data_type CudfHiveConfig::timestampTypeSession(
+    const config::ConfigBase* session) const {
+  const auto unit = session->get<cudf::type_id>(
+      kTimestampTypeSession,
+      config_->get<cudf::type_id>(
+          kTimestampType, cudf::type_id::TIMESTAMP_MILLISECONDS /*milli*/));
+  VELOX_CHECK(
+      unit == cudf::type_id::TIMESTAMP_DAYS /*days*/ ||
+          unit == cudf::type_id::TIMESTAMP_SECONDS /*seconds*/ ||
+          unit == cudf::type_id::TIMESTAMP_MILLISECONDS /*milli*/ ||
+          unit == cudf::type_id::TIMESTAMP_MICROSECONDS /*micro*/ ||
+          unit == cudf::type_id::TIMESTAMP_NANOSECONDS /*nano*/,
+      "Invalid timestamp unit.");
+  return cudf::data_type(cudf::type_id{unit});
+}
+
+bool CudfHiveConfig::useBufferedInput() const {
+  return config_->get<bool>(kUseBufferedInput, true);
+}
+
+bool CudfHiveConfig::useBufferedInputSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kUseBufferedInputSession, config_->get<bool>(kUseBufferedInput, true));
+}
+
+bool CudfHiveConfig::useExperimentalCudfReader() const {
+  return config_->get<bool>(kUseExperimentalCudfReader, false);
+}
+
+bool CudfHiveConfig::useExperimentalCudfReaderSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kUseExperimentalCudfReaderSession,
+      config_->get<bool>(kUseExperimentalCudfReader, false));
+}
+
+bool CudfHiveConfig::immutableFiles() const {
+  return config_->get<bool>(kImmutableFiles, false);
+}
+
+uint64_t CudfHiveConfig::sortWriterFinishTimeSliceLimitMs(
+    const config::ConfigBase* session) const {
+  return session->get<uint64_t>(
+      kSortWriterFinishTimeSliceLimitMsSession,
+      config_->get<uint64_t>(kSortWriterFinishTimeSliceLimitMs, 5'000));
+}
+
+bool CudfHiveConfig::writeTimestampsAsUTC() const {
+  return config_->get<bool>(kWriteTimestampsAsUTC, true);
+}
+
+bool CudfHiveConfig::writeTimestampsAsUTCSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kWriteTimestampsAsUTCSession,
+      config_->get<bool>(kWriteTimestampsAsUTC, true));
+}
+
+bool CudfHiveConfig::writeArrowSchema() const {
+  return config_->get<bool>(kWriteArrowSchema, false);
+}
+
+bool CudfHiveConfig::writeArrowSchemaSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kWriteArrowSchemaSession, config_->get<bool>(kWriteArrowSchema, false));
+}
+
+bool CudfHiveConfig::writev2PageHeaders() const {
+  return config_->get<bool>(kWritev2PageHeaders, false);
+}
+
+bool CudfHiveConfig::writev2PageHeadersSession(
+    const config::ConfigBase* session) const {
+  return session->get<bool>(
+      kWritev2PageHeadersSession,
+      config_->get<bool>(kWritev2PageHeaders, false));
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConfig.h b/velox/experimental/cudf/connectors/hive/CudfHiveConfig.h
new file mode 100644
index 000000000000..eab53ea279f7
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConfig.h
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/config/Config.h"
+
+#include <cudf/types.hpp>
+
+#include <optional>
+
+namespace facebook::velox::config {
+class ConfigBase;
+}
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+class CudfHiveConfig {
+ public:
+  // Reader config options
+
+  // Number of rows to skip from the start; CudfHive stores the number of rows
+  // as int64_t
+  static constexpr const char* kSkipRows = "parquet.reader.skip-rows";
+
+  // Number of rows to read; `nullopt` is all
+  static constexpr const char* kNumRows = "parquet.reader.num-rows";
+
+  // This isn't a typo; parquet connector and session config names are different
+  // ('-' vs '_').
+  static constexpr const char* kMaxChunkReadLimit =
+      "parquet.reader.chunk-read-limit";
+  static constexpr const char* kMaxChunkReadLimitSession =
+      "parquet.reader.chunk_read_limit";
+
+  static constexpr const char* kMaxPassReadLimit =
+      "parquet.reader.pass-read-limit";
+  static constexpr const char* kMaxPassReadLimitSession =
+      "parquet.reader.pass_read_limit";
+
+  // Whether to store string data as categorical type
+  static constexpr const char* kConvertStringsToCategories =
+      "parquet.reader.convert-strings-to-categories";
+  static constexpr const char* kConvertStringsToCategoriesSession =
+      "parquet.reader.convert_strings_to_categories";
+
+  // Whether to use PANDAS metadata to load columns
+  static constexpr const char* kUsePandasMetadata =
+      "parquet.reader.use-pandas-metadata";
+  static constexpr const char* kUsePandasMetadataSession =
+      "parquet.reader.use_pandas_metadata";
+
+  // Whether to read and use ARROW schema
+  static constexpr const char* kUseArrowSchema =
+      "parquet.reader.use-arrow-schema";
+  static constexpr const char* kUseArrowSchemaSession =
+      "parquet.reader.use_arrow_schema";
+
+  // Whether to allow reading matching select columns from mismatched CudfHive
+  // files.
+  static constexpr const char* kAllowMismatchedCudfHiveSchemas =
+      "parquet.reader.allow-mismatched-parquet-schemas";
+  static constexpr const char* kAllowMismatchedCudfHiveSchemasSession =
+      "parquet.reader.allow_mismatched_parquet_schemas";
+
+  // Cast timestamp columns to a specific type
+  static constexpr const char* kTimestampType = "parquet.reader.timestamp-type";
+  static constexpr const char* kTimestampTypeSession =
+      "parquet.reader.timestamp_type";
+
+  // Whether to use the BufferedInput source for CudfHiveDataSource. The
+  // buffered source takes advantage of the `AsyncDataCache` if available. The
+  // `AsyncDataCache` is controlled (default: enabled) using the
+  // HiveConfig::kEnableFileHandleCache config option
+  static constexpr const char* kUseBufferedInput =
+      "cudf.hive.use-buffered-input";
+  static constexpr const char* kUseBufferedInputSession =
+      "cudf.hive.use_buffered_input";
+
+  static constexpr const char* kUseExperimentalCudfReader =
+      "cudf.hive.use-experimental-reader";
+  static constexpr const char* kUseExperimentalCudfReaderSession =
+      "cudf.hive.use_experimental_reader";
+
+  // Writer config options
+
+  /// Whether new data can be inserted into a CudfHive file
+  /// Cudf-Velox currently does not support appending data to existing files.
+  static constexpr const char* kImmutableFiles = "parquet.immutable-files";
+
+  /// Sort Writer will exit finish() method after this many milliseconds even if
+  /// it has not completed its work yet. Zero means no time limit.
+  static constexpr const char* kSortWriterFinishTimeSliceLimitMs =
+      "sort-writer_finish_time_slice_limit_ms";
+  static constexpr const char* kSortWriterFinishTimeSliceLimitMsSession =
+      "sort_writer_finish_time_slice_limit_ms";
+
+  static constexpr const char* kWriteTimestampsAsUTC =
+      "parquet.writer.write-timestamps-as-utc";
+  static constexpr const char* kWriteTimestampsAsUTCSession =
+      "parquet.writer.write_timestamps_as_utc";
+
+  static constexpr const char* kWriteArrowSchema =
+      "parquet.writer.write-arrow-schema";
+  static constexpr const char* kWriteArrowSchemaSession =
+      "parquet.writer.write_arrow_schema";
+
+  static constexpr const char* kWritev2PageHeaders =
+      "parquet.writer.write-v2-page-headers";
+  static constexpr const char* kWritev2PageHeadersSession =
+      "parquet.writer.write_v2_page_headers";
+
+  CudfHiveConfig(std::shared_ptr<const config::ConfigBase> config) {
+    VELOX_CHECK_NOT_NULL(
+        config, "Config is null for CudfHiveConfig initialization");
+    config_ = std::move(config);
+  }
+
+  const std::shared_ptr<const config::ConfigBase>& config() const {
+    return config_;
+  }
+
+  uint64_t sortWriterFinishTimeSliceLimitMs(
+      const config::ConfigBase* session) const;
+
+  std::size_t maxChunkReadLimit() const;
+  std::size_t maxChunkReadLimitSession(const config::ConfigBase* session) const;
+
+  std::size_t maxPassReadLimit() const;
+  std::size_t maxPassReadLimitSession(const config::ConfigBase* session) const;
+
+  int64_t skipRows() const;
+  std::optional<cudf::size_type> numRows() const;
+
+  bool isConvertStringsToCategories() const;
+  bool isConvertStringsToCategoriesSession(
+      const config::ConfigBase* session) const;
+
+  bool isUsePandasMetadata() const;
+  bool isUsePandasMetadataSession(const config::ConfigBase* session) const;
+
+  bool isUseArrowSchema() const;
+  bool isUseArrowSchemaSession(const config::ConfigBase* session) const;
+
+  bool isAllowMismatchedCudfHiveSchemas() const;
+  bool isAllowMismatchedCudfHiveSchemasSession(
+      const config::ConfigBase* session) const;
+
+  cudf::data_type timestampType() const;
+  cudf::data_type timestampTypeSession(const config::ConfigBase* session) const;
+
+  bool useBufferedInput() const;
+  bool useBufferedInputSession(const config::ConfigBase* session) const;
+
+  bool useExperimentalCudfReader() const;
+  bool useExperimentalCudfReaderSession(
+      const config::ConfigBase* session) const;
+
+  bool immutableFiles() const;
+
+  bool writeTimestampsAsUTC() const;
+  bool writeTimestampsAsUTCSession(const config::ConfigBase* session) const;
+
+  bool writeArrowSchema() const;
+  bool writeArrowSchemaSession(const config::ConfigBase* session) const;
+
+  bool writev2PageHeaders() const;
+  bool writev2PageHeadersSession(const config::ConfigBase* session) const;
+
+ private:
+  std::shared_ptr<const config::ConfigBase> config_;
+};
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConnector.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveConnector.cpp
new file mode 100644
index 000000000000..baf3e6f2ef86
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConnector.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/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/connectors/hive/HiveDataSource.h"
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+
+CudfHiveConnector::CudfHiveConnector(
+    const std::string& id,
+    std::shared_ptr<const facebook::velox::config::ConfigBase> config,
+    folly::Executor* executor)
+    : ::facebook::velox::connector::hive::HiveConnector(id, config, executor),
+      cudfHiveConfig_(std::make_shared<CudfHiveConfig>(config)) {
+  LOG(INFO) << "cuDF Hive connector created";
+}
+
+std::unique_ptr<DataSource> CudfHiveConnector::createDataSource(
+    const RowTypePtr& outputType,
+    const ConnectorTableHandlePtr& tableHandle,
+    const ColumnHandleMap& columnHandles,
+    ConnectorQueryCtx* connectorQueryCtx) {
+  // If it's parquet then return CudfHiveDataSource
+  // If it's not parquet then return HiveDataSource
+  // TODO (dm): Make this ^^^ happen
+  // Problem: this information is in split, not table handle
+
+  if (cudfIsRegistered()) {
+    return std::make_unique<CudfHiveDataSource>(
+        outputType,
+        tableHandle,
+        columnHandles,
+        &fileHandleFactory_,
+        ioExecutor_,
+        connectorQueryCtx,
+        cudfHiveConfig_);
+  }
+
+  return std::make_unique<::facebook::velox::connector::hive::HiveDataSource>(
+      outputType,
+      tableHandle,
+      columnHandles,
+      &fileHandleFactory_,
+      ioExecutor_,
+      connectorQueryCtx,
+      hiveConfig_);
+}
+
+// TODO (dm): Re-add data sink
+
+std::shared_ptr<Connector> CudfHiveConnectorFactory::newConnector(
+    const std::string& id,
+    std::shared_ptr<const facebook::velox::config::ConfigBase> config,
+    folly::Executor* ioExecutor,
+    folly::Executor* cpuExecutor) {
+  return std::make_shared<CudfHiveConnector>(id, config, ioExecutor);
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConnector.h b/velox/experimental/cudf/connectors/hive/CudfHiveConnector.h
new file mode 100644
index 000000000000..fbb5929f3f42
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConnector.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/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+
+#include "velox/connectors/hive/HiveConnector.h"
+
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/types.hpp>
+#include <cudf/types.hpp>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+using namespace facebook::velox::config;
+
+class CudfHiveConnector final
+    : public ::facebook::velox::connector::hive::HiveConnector {
+ public:
+  CudfHiveConnector(
+      const std::string& id,
+      std::shared_ptr<const ConfigBase> config,
+      folly::Executor* executor);
+
+  std::unique_ptr<DataSource> createDataSource(
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const ColumnHandleMap& columnHandles,
+      ConnectorQueryCtx* connectorQueryCtx) override final;
+
+  bool canAddDynamicFilter() const override {
+    return false;
+  }
+
+  // TODO (dm): Re-add data sink
+
+ protected:
+  // TODO (dm): rename parquetconfig
+  const std::shared_ptr<CudfHiveConfig> cudfHiveConfig_;
+};
+
+class CudfHiveConnectorFactory
+    : public ::facebook::velox::connector::hive::HiveConnectorFactory {
+ public:
+  CudfHiveConnectorFactory()
+      : ::facebook::velox::connector::hive::HiveConnectorFactory() {}
+
+  explicit CudfHiveConnectorFactory(const char* connectorName)
+      : ::facebook::velox::connector::hive::HiveConnectorFactory(
+            connectorName) {}
+
+  std::shared_ptr<Connector> newConnector(
+      const std::string& id,
+      std::shared_ptr<const ConfigBase> config,
+      folly::Executor* ioExecutor = nullptr,
+      folly::Executor* cpuExecutor = nullptr) override;
+};
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.cpp
new file mode 100644
index 000000000000..c4f04c6be0aa
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.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/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
+
+#include <cudf/io/types.hpp>
+
+#include <string>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+namespace {
+std::string stripFilePrefix(const std::string& targetPath) {
+  const std::string prefix = "file:";
+  if (targetPath.rfind(prefix, 0) == 0) {
+    return targetPath.substr(prefix.length());
+  }
+  return targetPath;
+}
+} // namespace
+
+std::string CudfHiveConnectorSplit::toString() const {
+  return fmt::format("CudfHive: {}", filePath);
+}
+
+std::string CudfHiveConnectorSplit::getFileName() const {
+  const auto i = filePath.rfind('/');
+  return i == std::string::npos ? filePath : filePath.substr(i + 1);
+}
+
+CudfHiveConnectorSplit::CudfHiveConnectorSplit(
+    const std::string& connectorId,
+    const std::string& _filePath,
+    int64_t _splitWeight)
+    : facebook::velox::connector::ConnectorSplit(connectorId, _splitWeight),
+      filePath(stripFilePrefix(_filePath)),
+      cudfSourceInfo(std::make_unique<cudf::io::source_info>(filePath)) {}
+
+// static
+std::shared_ptr<CudfHiveConnectorSplit> CudfHiveConnectorSplit::create(
+    const folly::dynamic& obj) {
+  const auto connectorId = obj["connectorId"].asString();
+  const auto splitWeight = obj["splitWeight"].asInt();
+  const auto filePath = obj["filePath"].asString();
+
+  return std::make_shared<CudfHiveConnectorSplit>(
+      connectorId, filePath, splitWeight);
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h b/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h
new file mode 100644
index 000000000000..6ae350a474ab
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.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/connectors/Connector.h"
+#include "velox/dwio/common/Options.h"
+
+namespace cudf {
+namespace io {
+struct source_info;
+}
+} // namespace cudf
+
+#include <memory>
+#include <string>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+struct CudfHiveConnectorSplit
+    : public facebook::velox::connector::ConnectorSplit {
+  const std::string filePath;
+  const facebook::velox::dwio::common::FileFormat fileFormat{
+      facebook::velox::dwio::common::FileFormat::PARQUET};
+  const std::unique_ptr<cudf::io::source_info> cudfSourceInfo;
+
+  CudfHiveConnectorSplit(
+      const std::string& connectorId,
+      const std::string& _filePath,
+      int64_t _splitWeight = 0);
+
+  std::string toString() const override;
+  std::string getFileName() const;
+
+  const cudf::io::source_info& getCudfSourceInfo() const {
+    return *cudfSourceInfo;
+  }
+
+  static std::shared_ptr<CudfHiveConnectorSplit> create(
+      const folly::dynamic& obj);
+};
+
+class CudfHiveConnectorSplitBuilder {
+ public:
+  explicit CudfHiveConnectorSplitBuilder(std::string filePath)
+      : filePath_{std::move(filePath)} {}
+
+  CudfHiveConnectorSplitBuilder& splitWeight(int64_t splitWeight) {
+    splitWeight_ = splitWeight;
+    return *this;
+  }
+
+  CudfHiveConnectorSplitBuilder& connectorId(const std::string& connectorId) {
+    connectorId_ = connectorId;
+    return *this;
+  }
+
+  std::shared_ptr<CudfHiveConnectorSplit> build() const {
+    return std::make_shared<CudfHiveConnectorSplit>(
+        connectorId_, filePath_, splitWeight_);
+  }
+
+ private:
+  const std::string filePath_;
+  std::string connectorId_;
+  int64_t splitWeight_{0};
+};
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.cpp
new file mode 100644
index 000000000000..7c6d06163c4a
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.cpp
@@ -0,0 +1,571 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/common/base/Counters.h"
+#include "velox/common/base/Fs.h"
+#include "velox/common/base/StatsReporter.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/exec/OperatorUtils.h"
+
+#include <cudf/copying.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/types.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/table/table_view.hpp>
+
+#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::cudf_velox::connector::hive {
+
+namespace {
+
+std::unordered_map<LocationHandle::TableType, std::string> tableTypeNames() {
+  return {
+      {LocationHandle::TableType::kNew, "kNew"},
+  };
+}
+
+template <typename K, typename V>
+std::unordered_map<V, K> invertMap(const std::unordered_map<K, V>& mapping) {
+  std::unordered_map<V, K> inverted;
+  for (const auto& [key, value] : mapping) {
+    inverted.emplace(value, key);
+  }
+  return inverted;
+}
+
+uint64_t getFinishTimeSliceLimitMsFromCudfHiveConfig(
+    const std::shared_ptr<const CudfHiveConfig>& config,
+    const config::ConfigBase* sessions) {
+  const uint64_t flushTimeSliceLimitMsFromConfig =
+      config->sortWriterFinishTimeSliceLimitMs(sessions);
+  // NOTE: if the flush time slice limit is set to 0, then we treat it as no
+  // limit.
+  return flushTimeSliceLimitMsFromConfig == 0
+      ? std::numeric_limits<uint64_t>::max()
+      : flushTimeSliceLimitMsFromConfig;
+}
+
+std::string makeUuid() {
+  return boost::lexical_cast<std::string>(boost::uuids::random_generator()());
+}
+
+cudf::io::compression_type getCompressionType(
+    facebook::velox::common::CompressionKind name) {
+  using CompressionType = cudf::io::compression_type;
+
+  static std::unordered_map<
+      facebook::velox::common::CompressionKind,
+      CompressionType> const kMap = {
+      {facebook::velox::common::CompressionKind::CompressionKind_NONE,
+       CompressionType::NONE},
+      {facebook::velox::common::CompressionKind::CompressionKind_SNAPPY,
+       CompressionType::SNAPPY},
+      {facebook::velox::common::CompressionKind::CompressionKind_LZ4,
+       CompressionType::LZ4},
+      {facebook::velox::common::CompressionKind::CompressionKind_ZSTD,
+       CompressionType::ZSTD}};
+
+  VELOX_CHECK(
+      kMap.find(name) != kMap.end(),
+      "Unsupported compression type requested. Supported compression types are: "
+      "NONE, SNAPPY, LZ4, ZSTD");
+
+  return kMap.at(name);
+}
+
+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()));
+}
+
+} // namespace
+
+const std::string LocationHandle::tableTypeName(
+    LocationHandle::TableType type) {
+  static const auto kTableTypes = tableTypeNames();
+  return kTableTypes.at(type);
+}
+
+LocationHandle::TableType LocationHandle::tableTypeFromName(
+    const std::string& name) {
+  static const auto kNameTableTypes = invertMap(tableTypeNames());
+  return kNameTableTypes.at(name);
+}
+
+CudfHiveDataSink::CudfHiveDataSink(
+    RowTypePtr inputType,
+    std::shared_ptr<const CudfHiveInsertTableHandle> insertTableHandle,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    CommitStrategy commitStrategy,
+    const std::shared_ptr<const CudfHiveConfig>& parquetConfig)
+    : inputType_(std::move(inputType)),
+      insertTableHandle_(std::move(insertTableHandle)),
+      connectorQueryCtx_(connectorQueryCtx),
+      commitStrategy_(commitStrategy),
+      parquetConfig_(parquetConfig),
+      spillConfig_(connectorQueryCtx->spillConfig()),
+      sortWriterFinishTimeSliceLimitMs_(
+          getFinishTimeSliceLimitMsFromCudfHiveConfig(
+              parquetConfig_,
+              connectorQueryCtx->sessionProperties())) {
+  VELOX_USER_CHECK(
+      (commitStrategy_ == CommitStrategy::kNoCommit) ||
+          (commitStrategy_ == CommitStrategy::kTaskCommit),
+      "Unsupported commit strategy: {}",
+      CommitStrategyName::toName(commitStrategy_));
+
+  const auto& writerOptions = dynamic_cast<CudfHiveWriterOptions*>(
+      insertTableHandle_->writerOptions().get());
+
+  if (writerOptions != nullptr) {
+    sortingColumns_ = std::move(writerOptions->sortingColumns);
+  }
+}
+
+void CudfHiveDataSink::appendData(RowVectorPtr input) {
+  checkRunning();
+
+  // Convert the input RowVectorPtr to cudf::table
+  auto stream = cudfGlobalStreamPool().get_stream();
+  auto cudfInput = with_arrow::toCudfTable(input, input->pool(), stream);
+  stream.synchronize();
+  VELOX_CHECK_NOT_NULL(
+      cudfInput, "Failed to convert input RowVectorPtr to cudf::table");
+
+  // Check if the writer doesn't already exist
+  if (writer_ == nullptr) {
+    writer_ = createCudfWriter(cudfInput->view());
+  }
+
+  // Write the table to the sink
+  writer_->write(cudfInput->view());
+  writerInfo_->inputSizeInBytes += input->estimateFlatSize();
+  writerInfo_->numWrittenRows += input->size();
+}
+
+std::unique_ptr<cudf::io::chunked_parquet_writer>
+CudfHiveDataSink::createCudfWriter(cudf::table_view cudfTable) {
+  // Create a table_input_metadata from the input
+  auto tableInputMetadata = createCudfTableInputMetadata(cudfTable);
+
+  auto compressionKind =
+      getCompressionType(insertTableHandle_->compressionKind().value_or(
+          facebook::velox::common::CompressionKind::CompressionKind_NONE));
+
+  // Create a sink and writer
+  const auto& locationHandle = insertTableHandle_->locationHandle();
+  const auto targetFileName = locationHandle->targetFileName().empty()
+      ? fmt::format("{}{}", makeUuid(), ".parquet")
+      : locationHandle->targetFileName();
+
+  auto writerParameters = CudfHiveWriterParameters(
+      CudfHiveWriterParameters::UpdateMode::kNew,
+      targetFileName,
+      locationHandle->targetPath());
+
+  const auto writePath = fs::path(writerParameters.writeDirectory()) /
+      writerParameters.writeFileName();
+
+  makeWriterOptions(writerParameters);
+
+  // Create writer options for the given sink
+  const auto sinkInfo = cudf::io::sink_info(
+      fmt::format("{}/{}", locationHandle->targetPath(), targetFileName));
+  auto cudfWriterOptions =
+      cudf::io::chunked_parquet_writer_options::builder(sinkInfo)
+          .metadata(tableInputMetadata)
+          .utc_timestamps(parquetConfig_->writeTimestampsAsUTC())
+          .write_arrow_schema(parquetConfig_->writeArrowSchema())
+          .write_v2_headers(parquetConfig_->writev2PageHeaders())
+          .compression(compressionKind)
+          .build();
+
+  const auto& writerOptions = dynamic_cast<CudfHiveWriterOptions*>(
+      insertTableHandle_->writerOptions().get());
+
+  // If non-null writerOptions were passed, pass them to the chunked parquet
+  // writer options
+  if (writerOptions != nullptr) {
+    // Set encoding for all columns
+    std::for_each(
+        tableInputMetadata.column_metadata.begin(),
+        tableInputMetadata.column_metadata.end(),
+        [=](auto& colMeta) { colMeta.set_encoding(writerOptions->encoding); });
+
+    cudfWriterOptions.set_row_group_size_bytes(
+        writerOptions->rowGroupSizeBytes);
+    cudfWriterOptions.set_row_group_size_rows(writerOptions->rowGroupSizeRows);
+    cudfWriterOptions.set_max_page_size_bytes(writerOptions->maxPageSizeBytes);
+    cudfWriterOptions.set_max_page_size_rows(writerOptions->maxPageSizeRows);
+    cudfWriterOptions.set_dictionary_policy(writerOptions->dictionaryPolicy);
+    cudfWriterOptions.set_max_dictionary_size(writerOptions->maxDictionarySize);
+    cudfWriterOptions.enable_int96_timestamps(
+        writerOptions->writeTimestampsAsInt96);
+
+    // Enable if enabled in the session or the writerOptions
+    cudfWriterOptions.enable_utc_timestamps(
+        parquetConfig_->writeTimestampsAsUTC() or
+        writerOptions->writeTimestampsAsUTC);
+    cudfWriterOptions.enable_write_arrow_schema(
+        parquetConfig_->writeArrowSchema() or writerOptions->writeArrowSchema);
+    cudfWriterOptions.enable_write_v2_headers(
+        parquetConfig_->writev2PageHeaders() or writerOptions->v2PageHeaders);
+    cudfWriterOptions.set_stats_level(writerOptions->statsLevel);
+
+    if (writerOptions->maxPageFragmentSize.has_value()) {
+      cudfWriterOptions.set_max_page_fragment_size(
+          writerOptions->maxPageFragmentSize.value());
+    }
+    // Get compression stats if needed
+    if (writerOptions->compressionStats != nullptr) {
+      cudfWriterOptions.set_compression_statistics(
+          writerOptions->compressionStats);
+    }
+    // Write sorting columns if available
+    if (sortingColumns_.empty()) {
+      cudfWriterOptions.set_sorting_columns(sortingColumns_);
+    }
+  }
+
+  return std::make_unique<cudf::io::chunked_parquet_writer>(cudfWriterOptions);
+}
+
+cudf::io::table_input_metadata CudfHiveDataSink::createCudfTableInputMetadata(
+    cudf::table_view cudfTable) {
+  auto tableInputMetadata = cudf::io::table_input_metadata(cudfTable);
+  auto inputColumns = insertTableHandle_->inputColumns();
+
+  // Check if equal number of columns in the input and
+  // CudfHiveInsertTableHandle
+  VELOX_CHECK_EQ(
+      tableInputMetadata.column_metadata.size(),
+      inputColumns.size(),
+      "Unequal number of columns in the input and CudfHiveInsertTableHandle");
+
+  std::function<void(
+      cudf::io::column_in_metadata&, const CudfHiveColumnHandle&)>
+      setColumnName = [&](cudf::io::column_in_metadata& colMeta,
+                          const CudfHiveColumnHandle& columnHandle) {
+        // Check if equal number of children
+        const auto& childrenHandles = columnHandle.children();
+
+        // Warn if the mismatch in the number of child cols in CudfHive
+        // table_metadata and columnHandles
+        if (colMeta.num_children() != childrenHandles.size()) {
+          LOG(WARNING) << fmt::format(
+              "({} vs {}): Unequal number of child columns in CudfHive table_metadata and ColumnHandles",
+              colMeta.num_children(),
+              childrenHandles.size());
+        }
+
+        // Set children's names
+        for (int32_t i = 0; i <
+             std::min<int32_t>(colMeta.num_children(), childrenHandles.size());
+             ++i) {
+          setColumnName(colMeta.child(i), childrenHandles[i]);
+        }
+        // Set this column's name
+        colMeta.set_name(columnHandle.name());
+      };
+
+  // Set names for all columns and their children
+  for (int32_t i = 0; i < tableInputMetadata.column_metadata.size(); ++i) {
+    setColumnName(tableInputMetadata.column_metadata[i], *inputColumns[i]);
+  }
+
+  return tableInputMetadata;
+}
+
+std::string CudfHiveDataSink::stateString(State state) {
+  switch (state) {
+    case State::kRunning:
+      return "RUNNING";
+    case State::kFinishing:
+      return "FLUSHING";
+    case State::kClosed:
+      return "CLOSED";
+    case State::kAborted:
+      return "ABORTED";
+    default:
+      VELOX_UNREACHABLE("BAD STATE: {}", static_cast<int>(state));
+  }
+}
+
+DataSink::Stats CudfHiveDataSink::stats() const {
+  Stats stats;
+  if (state_ == State::kAborted) {
+    return stats;
+  }
+
+  int64_t numWrittenBytes{0};
+  int64_t writeIOTimeUs{0};
+
+  numWrittenBytes += ioStats_->rawBytesWritten();
+  writeIOTimeUs += ioStats_->writeIOTimeUs();
+
+  stats.numWrittenBytes = numWrittenBytes;
+  stats.writeIOTimeUs = writeIOTimeUs;
+
+  if (state_ != State::kClosed) {
+    return stats;
+  }
+
+  stats.numWrittenFiles = 1;
+  VELOX_CHECK_NOT_NULL(writerInfo_);
+  const auto spillStats = writerInfo_->spillStats->rlock();
+  if (!spillStats->empty()) {
+    stats.spillStats += *spillStats;
+  }
+
+  return stats;
+}
+
+void CudfHiveDataSink::setState(State newState) {
+  checkStateTransition(state_, newState);
+  state_ = newState;
+}
+
+/// Validates the state transition from 'oldState' to 'newState'.
+void CudfHiveDataSink::checkStateTransition(State oldState, State newState) {
+  switch (oldState) {
+    case State::kRunning:
+      if (newState == State::kAborted || newState == State::kFinishing) {
+        return;
+      }
+      break;
+    case State::kFinishing:
+      if (newState == State::kAborted || newState == State::kClosed ||
+          // The finishing state is reentry state if we yield in the
+          // middle of finish processing if a single run takes too long.
+          newState == State::kFinishing) {
+        return;
+      }
+      [[fallthrough]];
+    case State::kAborted:
+    case State::kClosed:
+    default:
+      break;
+  }
+  VELOX_FAIL("Unexpected state transition from {} to {}", oldState, newState);
+}
+
+bool CudfHiveDataSink::finish() {
+  VELOX_CHECK_NOT_NULL(writer_, "CudfHiveDataSink has no writer");
+
+  setState(State::kFinishing);
+  return true;
+}
+
+std::vector<std::string> CudfHiveDataSink::close() {
+  setState(State::kClosed);
+  closeInternal();
+
+  std::vector<std::string> partitionUpdates{};
+
+  partitionUpdates.reserve(1);
+  VELOX_CHECK_NOT_NULL(writerInfo_);
+  // clang-format off
+    auto partitionUpdateJson = folly::toJson(
+     folly::dynamic::object
+        ("writePath", writerInfo_->writerParameters.writeDirectory())
+        ("targetPath", writerInfo_->writerParameters.targetDirectory())
+        ("fileWriteInfos", folly::dynamic::array(
+          folly::dynamic::object
+            ("writeFileName", writerInfo_->writerParameters.writeFileName())
+            ("targetFileName", writerInfo_->writerParameters.targetFileName())
+            ("fileSize", ioStats_->rawBytesWritten())))
+        ("rowCount", writerInfo_->numWrittenRows)
+        ("inMemoryDataSizeInBytes", writerInfo_->inputSizeInBytes)
+        ("onDiskDataSizeInBytes", ioStats_->rawBytesWritten())
+        ("containsNumberedFileNames", true));
+  // clang-format on
+  partitionUpdates.emplace_back(partitionUpdateJson);
+
+  return partitionUpdates;
+}
+
+void CudfHiveDataSink::abort() {
+  setState(State::kAborted);
+  closeInternal();
+}
+
+void CudfHiveDataSink::closeInternal() {
+  VELOX_CHECK_NE(state_, State::kRunning);
+  VELOX_CHECK_NE(state_, State::kFinishing);
+  VELOX_CHECK_NOT_NULL(writer_, "CudfHiveDataSink has no writer");
+
+  TestValue::adjust(
+      "facebook::velox::connector::hive::CudfHiveDataSink::closeInternal",
+      this);
+
+  // Close cudf writer
+  writer_->close();
+
+  // Reset the unique pointers to Cudf writer and options
+  writer_.reset();
+}
+
+std::shared_ptr<memory::MemoryPool> CudfHiveDataSink::createWriterPool() {
+  auto* connectorPool = connectorQueryCtx_->connectorMemoryPool();
+  return connectorPool->addAggregateChild(
+      fmt::format("{}.{}", connectorPool->name(), "parquet-writer"));
+}
+
+void CudfHiveDataSink::makeWriterOptions(
+    CudfHiveWriterParameters writerParameters) {
+  auto writerPool = createWriterPool();
+  auto sinkPool = createSinkPool(writerPool);
+  std::shared_ptr<memory::MemoryPool> sortPool{nullptr};
+  if (sortWrite()) {
+    sortPool = createSortPool(writerPool);
+  }
+
+  writerInfo_ = std::make_shared<CudfHiveWriterInfo>(
+      std::move(writerParameters),
+      std::move(writerPool),
+      std::move(sinkPool),
+      std::move(sortPool));
+
+  ioStats_ = std::make_shared<io::IoStatistics>();
+
+  // Take the writer options provided by the user as a starting point,
+  // or allocate a new one.
+  auto options = insertTableHandle_->writerOptions();
+  if (!options) {
+    options = std::make_unique<CudfHiveWriterOptions>();
+  }
+
+  const auto* connectorSessionProperties =
+      connectorQueryCtx_->sessionProperties();
+
+  if (options->memoryPool == nullptr) {
+    options->memoryPool = writerInfo_->writerPool.get();
+  }
+
+  if (!options->compressionKind) {
+    options->compressionKind = insertTableHandle_->compressionKind();
+  }
+
+  const auto& sessionTimeZoneName = connectorQueryCtx_->sessionTimezone();
+  if (!sessionTimeZoneName.empty()) {
+    options->sessionTimezoneName = sessionTimeZoneName;
+  }
+  options->adjustTimestampToTimezone =
+      connectorQueryCtx_->adjustTimestampToTimezone();
+}
+
+folly::dynamic CudfHiveInsertTableHandle::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "CudfHiveInsertTableHandle";
+  folly::dynamic arr = folly::dynamic::array;
+  for (const auto& ic : inputColumns_) {
+    arr.push_back(ic->serialize());
+  }
+
+  obj["inputColumns"] = arr;
+  obj["locationHandle"] = locationHandle_->serialize();
+  obj["tableStorageFormat"] = dwio::common::toString(storageFormat_);
+
+  if (compressionKind_.has_value()) {
+    obj["compressionKind"] = common::compressionKindToString(*compressionKind_);
+  }
+
+  return obj;
+}
+
+CudfHiveInsertTableHandlePtr CudfHiveInsertTableHandle::create(
+    const folly::dynamic& obj) {
+  auto inputColumns =
+      ISerializable::deserialize<std::vector<CudfHiveColumnHandle>>(
+          obj["inputColumns"]);
+  auto locationHandle =
+      ISerializable::deserialize<LocationHandle>(obj["locationHandle"]);
+  std::optional<common::CompressionKind> compressionKind = std::nullopt;
+  if (obj.count("compressionKind") > 0) {
+    compressionKind =
+        common::stringToCompressionKind(obj["compressionKind"].asString());
+  }
+  std::unordered_map<std::string, std::string> serdeParameters;
+  for (const auto& pair : obj["serdeParameters"].items()) {
+    serdeParameters.emplace(pair.first.asString(), pair.second.asString());
+  }
+  return std::make_shared<CudfHiveInsertTableHandle>(
+      inputColumns, locationHandle, compressionKind, serdeParameters);
+}
+
+std::string CudfHiveInsertTableHandle::toString() const {
+  std::ostringstream out;
+  out << "CudfHiveInsertTableHandle ["
+      << dwio::common::toString(storageFormat_);
+  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 << "]";
+  return out.str();
+}
+
+void CudfHiveInsertTableHandle::registerSerDe() {
+  auto& registry = DeserializationRegistryForSharedPtr();
+  registry.Register("HiveInsertTableHandle", CudfHiveInsertTableHandle::create);
+}
+
+std::string LocationHandle::toString() const {
+  return fmt::format(
+      "LocationHandle [targetPath: {}, tableType: {},",
+      targetPath_,
+      tableTypeName(tableType_));
+}
+
+folly::dynamic LocationHandle::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "LocationHandle";
+  obj["targetPath"] = targetPath_;
+  obj["tableType"] = tableTypeName(tableType_);
+  return obj;
+}
+
+LocationHandlePtr LocationHandle::create(const folly::dynamic& obj) {
+  auto targetPath = obj["targetPath"].asString();
+  auto tableType = tableTypeFromName(obj["tableType"].asString());
+  return std::make_shared<LocationHandle>(targetPath, tableType);
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h b/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h
new file mode 100644
index 000000000000..02984124c247
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h
@@ -0,0 +1,389 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/connectors/hive/WriterOptions.h"
+
+#include "velox/common/compression/Compression.h"
+#include "velox/connectors/Connector.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/dwio/common/WriterFactory.h"
+#include "velox/exec/MemoryReclaimer.h"
+#include "velox/type/Type.h"
+
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/types.hpp>
+#include <cudf/types.hpp>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+
+class LocationHandle;
+using LocationHandlePtr = std::shared_ptr<const LocationHandle>;
+
+/// Location related properties of the CudfHive table to be written.
+class LocationHandle : public ISerializable {
+ public:
+  enum class TableType {
+    /// Write to a new table to be created.
+    kNew,
+  };
+
+  LocationHandle(
+      std::string targetPath,
+      TableType tableType,
+      std::string targetFileName = "")
+      : targetPath_(std::move(targetPath)),
+        targetFileName_(std::move(targetFileName)),
+        tableType_(tableType) {}
+
+  const std::string& targetPath() const {
+    return targetPath_;
+  }
+
+  const std::string& targetFileName() const {
+    return targetFileName_;
+  }
+
+  TableType tableType() const {
+    return tableType_;
+  }
+
+  std::string toString() const;
+
+  static void registerSerDe();
+
+  folly::dynamic serialize() const override;
+
+  static LocationHandlePtr create(const folly::dynamic& obj);
+
+  static const std::string tableTypeName(LocationHandle::TableType type);
+
+  static LocationHandle::TableType tableTypeFromName(const std::string& name);
+
+ private:
+  // Target directory path.
+  const std::string targetPath_;
+  // If non-empty, use this name instead of generating our own.
+  const std::string targetFileName_;
+  // Whether the table to be written is new, already existing or temporary.
+  const TableType tableType_;
+};
+
+/// Parameters for Hive writers.
+class CudfHiveWriterParameters {
+ public:
+  enum class UpdateMode {
+    kNew, // Write files to a new directory.
+  };
+
+  /// @param updateMode Write the files to a new directory, or append to an
+  /// existing directory or overwrite an existing directory.
+  /// @param targetFileName The final name of a file after committing.
+  /// @param targetDirectory The final directory that a file should be in after
+  /// committing.
+  /// @param writeFileName The temporary name of the file that a running writer
+  /// writes to. If a running writer writes directory to the target file, set
+  /// writeFileName to targetFileName by default.
+  /// @param writeDirectory The temporary directory that a running writer writes
+  /// to. If a running writer writes directory to the target directory, set
+  /// writeDirectory to targetDirectory by default.
+  CudfHiveWriterParameters(
+      UpdateMode updateMode,
+      std::string targetFileName,
+      std::string targetDirectory,
+      std::optional<std::string> writeFileName = std::nullopt,
+      std::optional<std::string> writeDirectory = std::nullopt)
+      : updateMode_(updateMode),
+        targetFileName_(std::move(targetFileName)),
+        targetDirectory_(std::move(targetDirectory)),
+        writeFileName_(writeFileName.value_or(targetFileName_)),
+        writeDirectory_(writeDirectory.value_or(targetDirectory_)) {}
+
+  UpdateMode updateMode() const {
+    return updateMode_;
+  }
+
+  static std::string updateModeToString(UpdateMode updateMode) {
+    switch (updateMode) {
+      case UpdateMode::kNew:
+        return "NEW";
+      default:
+        VELOX_UNSUPPORTED("Unsupported update mode.");
+    }
+  }
+
+  const std::string& targetFileName() const {
+    return targetFileName_;
+  }
+
+  const std::string& writeFileName() const {
+    return writeFileName_;
+  }
+
+  const std::string& targetDirectory() const {
+    return targetDirectory_;
+  }
+
+  const std::string& writeDirectory() const {
+    return writeDirectory_;
+  }
+
+ private:
+  const UpdateMode updateMode_;
+  const std::optional<std::string> partitionName_;
+  const std::string targetFileName_;
+  const std::string targetDirectory_;
+  const std::string writeFileName_;
+  const std::string writeDirectory_;
+};
+
+struct CudfHiveWriterInfo {
+  CudfHiveWriterInfo(
+      CudfHiveWriterParameters 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 CudfHiveWriterParameters 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;
+  int64_t inputSizeInBytes = 0;
+};
+
+class CudfHiveInsertTableHandle;
+using CudfHiveInsertTableHandlePtr = std::shared_ptr<CudfHiveInsertTableHandle>;
+
+/// Represents a request for CudfHive write.
+class CudfHiveInsertTableHandle : public ConnectorInsertTableHandle {
+ public:
+  CudfHiveInsertTableHandle(
+      std::vector<std::shared_ptr<const CudfHiveColumnHandle>> inputColumns,
+      std::shared_ptr<const LocationHandle> locationHandle,
+      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)),
+        compressionKind_(compressionKind),
+        serdeParameters_(serdeParameters),
+        writerOptions_(writerOptions) {
+    if (compressionKind.has_value()) {
+      VELOX_CHECK(
+          compressionKind.value() != common::CompressionKind_MAX,
+          "Unsupported compression type: CompressionKind_MAX");
+      VELOX_CHECK(
+          compressionKind.value() == common::CompressionKind_NONE or
+              compressionKind.value() == common::CompressionKind_SNAPPY or
+              compressionKind.value() == common::CompressionKind_LZ4 or
+              compressionKind.value() == common::CompressionKind_ZSTD,
+          "CudfHive DataSink only supports NONE, SNAPPY, LZ4, and ZSTD compressions.");
+    }
+  }
+
+  virtual ~CudfHiveInsertTableHandle() = default;
+
+  const std::vector<std::shared_ptr<const CudfHiveColumnHandle>>& inputColumns()
+      const {
+    return inputColumns_;
+  }
+
+  const std::shared_ptr<const LocationHandle>& locationHandle() const {
+    return locationHandle_;
+  }
+
+  std::optional<common::CompressionKind> compressionKind() const {
+    return compressionKind_;
+  }
+
+  const dwio::common::FileFormat storageFormat() const {
+    return storageFormat_;
+  }
+
+  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; // TODO: Needs more testing if this is ok
+  }
+
+  bool isExistingTable() const {
+    return false; // This is always false as cudf's CudfHive writer doesn't yet
+                  // support updating existing CudfHive files
+  }
+
+  folly::dynamic serialize() const override;
+
+  static CudfHiveInsertTableHandlePtr create(const folly::dynamic& obj);
+
+  static void registerSerDe();
+
+  std::string toString() const override;
+
+ private:
+  const std::vector<std::shared_ptr<const CudfHiveColumnHandle>> inputColumns_;
+  const std::shared_ptr<const LocationHandle> locationHandle_;
+  const std::optional<common::CompressionKind> compressionKind_;
+  const dwio::common::FileFormat storageFormat_ =
+      dwio::common::FileFormat::PARQUET;
+  const std::unordered_map<std::string, std::string> serdeParameters_;
+  const std::shared_ptr<dwio::common::WriterOptions> writerOptions_;
+};
+
+class CudfHiveDataSink : public DataSink {
+ public:
+  /// The list of runtime stats reported by parquet data sink
+  static constexpr const char* kEarlyFlushedRawBytes = "earlyFlushedRawBytes";
+
+  /// Defines the execution states of a parquet data sink running internally.
+  enum class State {
+    /// The data sink accepts new append data in this state.
+    kRunning = 0,
+    /// The data sink flushes any buffered data to the underlying file writer
+    /// but no more data can be appended.
+    kFinishing = 1,
+    /// The data sink is aborted on error and no more data can be appended.
+    kAborted = 2,
+    /// The data sink is closed on error and no more data can be appended.
+    kClosed = 3
+  };
+  static std::string stateString(State state);
+
+  CudfHiveDataSink(
+      RowTypePtr inputType,
+      std::shared_ptr<const CudfHiveInsertTableHandle> insertTableHandle,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      CommitStrategy commitStrategy,
+      const std::shared_ptr<const CudfHiveConfig>& parquetConfig);
+
+  void appendData(RowVectorPtr input) override;
+
+  bool finish() override;
+
+  Stats stats() const override;
+
+  std::vector<std::string> close() override;
+
+  void abort() override;
+
+  bool canReclaim() const {
+    return false;
+  };
+
+ private:
+  // Creates a new cudf chunked parquet writer.
+  std::unique_ptr<cudf::io::chunked_parquet_writer> createCudfWriter(
+      cudf::table_view cudfTable);
+  cudf::io::table_input_metadata createCudfTableInputMetadata(
+      cudf::table_view cudfTable);
+
+  // Validates the state transition from 'oldState' to 'newState'.
+  void checkStateTransition(State oldState, State newState);
+  void setState(State newState);
+
+  std::shared_ptr<memory::MemoryPool> createWriterPool();
+
+  FOLLY_ALWAYS_INLINE bool sortWrite() const {
+    return not sortingColumns_.empty();
+  }
+
+  FOLLY_ALWAYS_INLINE bool isCommitRequired() const {
+    return false; // Since we always immediately write
+  }
+
+  FOLLY_ALWAYS_INLINE void checkRunning() const {
+    VELOX_CHECK_EQ(
+        state_, State::kRunning, "CudfHive data sink is not running");
+  }
+
+  void closeInternal();
+  void makeWriterOptions(CudfHiveWriterParameters writerParameters);
+
+  const RowTypePtr inputType_;
+  const std::shared_ptr<const CudfHiveInsertTableHandle> insertTableHandle_;
+  const ConnectorQueryCtx* const connectorQueryCtx_;
+  const CommitStrategy commitStrategy_;
+  const std::shared_ptr<const CudfHiveConfig> parquetConfig_;
+  const common::SpillConfig* const spillConfig_;
+  const uint64_t sortWriterFinishTimeSliceLimitMs_{0};
+  State state_{State::kRunning};
+
+  // Below are structures for partitions from all inputs. writerInfo_ and
+  // writers_ are both indexed by partitionId.
+  std::unique_ptr<cudf::io::chunked_parquet_writer> writer_;
+
+  std::vector<cudf::io::sorting_column> sortingColumns_;
+
+  std::shared_ptr<CudfHiveWriterInfo> writerInfo_;
+
+  // IO statistics collected for writer.
+  std::shared_ptr<io::IoStatistics> ioStats_;
+};
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(
+    std::ostream& os,
+    CudfHiveDataSink::State state) {
+  os << CudfHiveDataSink::stateString(state);
+  return os;
+}
+} // namespace facebook::velox::cudf_velox::connector::hive
+
+template <>
+struct fmt::formatter<
+    facebook::velox::cudf_velox::connector::hive::CudfHiveDataSink::State>
+    : formatter<std::string> {
+  auto format(
+      facebook::velox::cudf_velox::connector::hive::CudfHiveDataSink::State s,
+      format_context& ctx) const {
+    return formatter<std::string>::format(
+        facebook::velox::cudf_velox::connector::hive::CudfHiveDataSink::
+            stateString(s),
+        ctx);
+  }
+};
+
+template <>
+struct fmt::formatter<
+    facebook::velox::cudf_velox::connector::hive::LocationHandle::TableType>
+    : formatter<int> {
+  auto format(
+      facebook::velox::cudf_velox::connector::hive::LocationHandle::TableType s,
+      format_context& ctx) const {
+    return formatter<int>::format(static_cast<int>(s), ctx);
+  }
+};
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.cpp
new file mode 100644
index 000000000000..b977788e23db
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.cpp
@@ -0,0 +1,652 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSourceHelpers.hpp"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/expression/SubfieldFiltersToAst.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/common/caching/CacheTTLController.h"
+#include "velox/common/time/Timer.h"
+#include "velox/connectors/hive/BufferedInputBuilder.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/HiveConnectorUtil.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/expression/FieldReference.h"
+
+#include <cudf/column/column_factories.hpp>
+#include <cudf/io/datasource.hpp>
+#include <cudf/io/experimental/hybrid_scan.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/text/byte_range_info.hpp>
+#include <cudf/io/types.hpp>
+#include <cudf/stream_compaction.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/table/table_view.hpp>
+#include <cudf/transform.hpp>
+
+#include <cuda_runtime.h>
+
+#include <filesystem>
+#include <memory>
+#include <string>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+using namespace facebook::velox::connector::hive;
+
+CudfHiveDataSource::CudfHiveDataSource(
+    const RowTypePtr& outputType,
+    const ConnectorTableHandlePtr& tableHandle,
+    const ColumnHandleMap& columnHandles,
+    facebook::velox::FileHandleFactory* fileHandleFactory,
+    folly::Executor* executor,
+    const ConnectorQueryCtx* connectorQueryCtx,
+    const std::shared_ptr<CudfHiveConfig>& cudfHiveConfig)
+    : NvtxHelper(
+          nvtx3::rgb{80, 171, 241}, // CudfHive blue,
+          std::nullopt,
+          fmt::format("[{}]", tableHandle->name())),
+      cudfHiveConfig_(cudfHiveConfig),
+      fileHandleFactory_(fileHandleFactory),
+      executor_(executor),
+      connectorQueryCtx_(connectorQueryCtx),
+      pool_(connectorQueryCtx->memoryPool()),
+      baseReaderOpts_(pool_),
+      outputType_(outputType),
+      expressionEvaluator_(connectorQueryCtx->expressionEvaluator()) {
+  // Set up column projection if needed
+  auto readColumnTypes = outputType_->children();
+  for (const auto& outputName : outputType_->names()) {
+    auto it = columnHandles.find(outputName);
+    VELOX_CHECK(
+        it != columnHandles.end(),
+        "ColumnHandle is missing for output column: {}",
+        outputName);
+
+    auto* handle = static_cast<const hive::HiveColumnHandle*>(it->second.get());
+    readColumnNames_.emplace_back(handle->name());
+  }
+
+  tableHandle_ =
+      std::dynamic_pointer_cast<const hive::HiveTableHandle>(tableHandle);
+  VELOX_CHECK_NOT_NULL(
+      tableHandle_, "TableHandle must be an instance of HiveTableHandle");
+
+  // Copy subfield filters
+  for (const auto& [k, v] : tableHandle_->subfieldFilters()) {
+    subfieldFilters_.emplace(k.clone(), v->clone());
+    // Add fields in the filter to the columns to read if not there
+    for (const auto& [field, _] : subfieldFilters_) {
+      if (std::find(
+              readColumnNames_.begin(),
+              readColumnNames_.end(),
+              field.toString()) == readColumnNames_.end()) {
+        readColumnNames_.push_back(field.toString());
+      }
+    }
+  }
+
+  // Create remaining filter
+  auto remainingFilter = tableHandle_->remainingFilter();
+  if (remainingFilter) {
+    remainingFilterExprSet_ = expressionEvaluator_->compile(remainingFilter);
+    for (const auto& field : remainingFilterExprSet_->distinctFields()) {
+      // Add fields in the filter to the columns to read if not there
+      if (std::find(
+              readColumnNames_.begin(),
+              readColumnNames_.end(),
+              field->name()) == readColumnNames_.end()) {
+        readColumnNames_.push_back(field->name());
+      }
+    }
+
+    const RowTypePtr remainingFilterType_ = [&] {
+      if (tableHandle_->dataColumns()) {
+        std::vector<std::string> new_names;
+        std::vector<TypePtr> new_types;
+
+        for (const auto& name : readColumnNames_) {
+          auto parsedType = tableHandle_->dataColumns()->findChild(name);
+          new_names.emplace_back(std::move(name));
+          new_types.push_back(parsedType);
+        }
+
+        return ROW(std::move(new_names), std::move(new_types));
+      } else {
+        return outputType_;
+      }
+    }();
+
+    cudfExpressionEvaluator_ = velox::cudf_velox::createCudfExpression(
+        remainingFilterExprSet_->exprs()[0], remainingFilterType_);
+    // TODO(kn): Get column names and subfields from remaining filter and add to
+    // readColumnNames_
+  }
+
+  VELOX_CHECK_NOT_NULL(fileHandleFactory_, "No FileHandleFactory present");
+
+  // Create empty IOStats and FsStats for later use
+  ioStats_ = std::make_shared<io::IoStatistics>();
+  fsStats_ = std::make_shared<filesystems::File::IoStats>();
+
+  // Whether to use the experimental split reader
+  useExperimentalSplitReader_ =
+      cudfHiveConfig_->useExperimentalCudfReaderSession(
+          connectorQueryCtx_->sessionProperties());
+}
+
+std::optional<RowVectorPtr> CudfHiveDataSource::next(
+    uint64_t /*size*/,
+    velox::ContinueFuture& /* future */) {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  // Basic sanity checks
+  VELOX_CHECK_NOT_NULL(split_, "No split to process. Call addSplit first.");
+  VELOX_CHECK_NOT_NULL(
+      splitReader_ or exptSplitReader_, "No split reader present");
+
+  std::unique_ptr<cudf::table> cudfTable;
+  cudf::io::table_metadata metadata;
+
+  // Record start time before reading chunk
+  auto startTimeUs = getCurrentTimeMicro();
+
+  if (not useExperimentalSplitReader_) {
+    // Read a table chunk using the regular parquet reader
+    VELOX_CHECK_NOT_NULL(splitReader_, "Regular cudf split reader not present");
+
+    if (not splitReader_->has_next()) {
+      return nullptr;
+    }
+    // Read a table chunk
+    auto tableWithMetadata = splitReader_->read_chunk();
+    cudfTable = std::move(tableWithMetadata.tbl);
+    metadata = std::move(tableWithMetadata.metadata);
+  } else {
+    // Read a table chunk using the experimental parquet reader
+    VELOX_CHECK_NOT_NULL(
+        exptSplitReader_, "Experimental cudf split reader not present");
+
+    // TODO(mh): Replace this with chunked hybrid scan APIs when available in
+    // the pinned cuDF version
+    std::call_once(*tableMaterialized_, [&]() {
+      auto rowGroupIndices = exptSplitReader_->all_row_groups(readerOptions_);
+
+      // Temporary options used for filtering row groups. TODO(mh): Remove this
+      // once PR https://github.com/rapidsai/cudf/pull/20604 is merged
+      auto tmpOptions = readerOptions_;
+
+      if (readerOptions_.get_filter().has_value()) {
+        // Filter expression converter
+        auto exprConverter = referenceToNameConverter(
+            readerOptions_.get_filter(),
+            exptSplitReader_->parquet_metadata().schema,
+            readColumnNames_);
+        tmpOptions.set_filter(exprConverter.convertedExpression());
+
+        // Create a temporary split reader for filtering row groups. TODO(mh):
+        // Remove this once PR https://github.com/rapidsai/cudf/pull/20604 is
+        // merged or the pinned cuDF version is updated
+        auto footerBytes = fetchFooterBytes(dataSource_);
+        auto tmpExptSplitReader = std::make_unique<CudfHybridScanReader>(
+            cudf::host_span<uint8_t const>{
+                footerBytes->data(), footerBytes->size()},
+            tmpOptions);
+        rowGroupIndices = tmpExptSplitReader->filter_row_groups_with_stats(
+            rowGroupIndices, tmpOptions, stream_);
+      }
+
+      // Workaround: Set a dummy filter expression to avoid erroneous assertion
+      // in `payload_column_chunks_byte_ranges`. TODO(mh): Remove this once PR
+      // https://github.com/rapidsai/cudf/pull/20604 is merged
+      if (not tmpOptions.get_filter().has_value()) {
+        auto scalar = cudf::numeric_scalar<int32_t>(0, false, stream_);
+        auto literal = cudf::ast::literal(scalar);
+        auto filter =
+            cudf::ast::operation(cudf::ast::ast_operator::IDENTITY, literal);
+        tmpOptions.set_filter(filter);
+      }
+
+      // Get column chunk byte ranges to fetch
+      const auto columnChunkByteRanges =
+          exptSplitReader_->payload_column_chunks_byte_ranges(
+              rowGroupIndices, tmpOptions);
+      // Fetch row group data device buffers
+      std::vector<rmm::device_buffer> columnChunkBuffers(
+          columnChunkByteRanges.size());
+      std::vector<std::future<size_t>> ioFutures{};
+      ioFutures.reserve(columnChunkByteRanges.size());
+      std::for_each(
+          thrust::counting_iterator<size_t>(0),
+          thrust::counting_iterator(columnChunkByteRanges.size()),
+          [&](auto idx) {
+            const auto& byteRange = columnChunkByteRanges[idx];
+            auto& buffer = columnChunkBuffers[idx];
+
+            // Pad the buffer size to be a multiple of 8 bytes
+            constexpr size_t bufferPaddingMultiple = 8;
+            buffer = rmm::device_buffer(
+                cudf::util::round_up_safe<size_t>(
+                    byteRange.size(), bufferPaddingMultiple),
+                stream_,
+                cudf::get_current_device_resource_ref());
+            // Directly read the column chunk data to the device buffer if
+            // supported
+            if (dataSource_->supports_device_read() and
+                dataSource_->is_device_read_preferred(byteRange.size())) {
+              ioFutures.emplace_back(dataSource_->device_read_async(
+                  byteRange.offset(),
+                  byteRange.size(),
+                  static_cast<uint8_t*>(buffer.data()),
+                  stream_));
+            } else {
+              // Read the column chunk data to the host buffer and copy it to
+              // the device buffer
+              auto hostBuffer =
+                  dataSource_->host_read(byteRange.offset(), byteRange.size());
+              CUDF_CUDA_TRY(cudaMemcpyAsync(
+                  buffer.data(),
+                  hostBuffer->data(),
+                  byteRange.size(),
+                  cudaMemcpyHostToDevice,
+                  stream_.value()));
+            }
+          });
+
+      // Wait for all IO futures to complete
+      std::for_each(ioFutures.begin(), ioFutures.end(), [](auto& future) {
+        future.get();
+      });
+
+      // Create an all true row mask to read the table in one go without output
+      // filtering. TODO(mh): Remove this once PR
+      // https://github.com/rapidsai/cudf/pull/20604 is merged
+      const auto totalRows =
+          exptSplitReader_->total_rows_in_row_groups(rowGroupIndices);
+
+      auto const scalarTrue = cudf::numeric_scalar<bool>(true, true, stream_);
+      auto allTrueRowMask =
+          cudf::make_column_from_scalar(scalarTrue, totalRows, stream_);
+
+      // Read the table in one go
+      auto tableWithMetadata = exptSplitReader_->materialize_payload_columns(
+          rowGroupIndices,
+          std::move(columnChunkBuffers),
+          allTrueRowMask->view(),
+          cudf::io::parquet::experimental::use_data_page_mask::NO,
+          readerOptions_,
+          stream_);
+
+      // Store the read metadata
+      metadata = std::move(tableWithMetadata.metadata);
+
+      // Apply the subfield filter manually since we passed an all true row mask
+      if (readerOptions_.get_filter().has_value()) {
+        std::unique_ptr<cudf::table> table = std::move(tableWithMetadata.tbl);
+        auto filterMask = cudf::compute_column(
+            *table, readerOptions_.get_filter().value(), stream_);
+        cudfTable = cudf::apply_boolean_mask(
+            table->view(),
+            filterMask->view(),
+            stream_,
+            cudf::get_current_device_resource_ref());
+      } else {
+        cudfTable = std::move(tableWithMetadata.tbl);
+      }
+    });
+
+    if (cudfTable == nullptr) {
+      return nullptr;
+    }
+  }
+
+  TotalScanTimeCallbackData* callbackData =
+      new TotalScanTimeCallbackData{startTimeUs, ioStats_};
+
+  // Launch host callback to calculate timing when scan completes
+  cudaLaunchHostFunc(
+      stream_.value(),
+      &CudfHiveDataSource::totalScanTimeCalculator,
+      callbackData);
+
+  uint64_t filterTimeUs{0};
+  // Apply remaining filter if present
+  if (remainingFilterExprSet_) {
+    MicrosecondTimer filterTimer(&filterTimeUs);
+    auto cudfTableColumns = cudfTable->release();
+    const auto originalNumColumns = cudfTableColumns.size();
+    // Filter may need addtional computed columns which are added to
+    // cudfTableColumns
+    auto filterResult = cudfExpressionEvaluator_->eval(
+        cudfTableColumns, stream_, cudf::get_current_device_resource_ref());
+    // discard computed columns
+    std::vector<std::unique_ptr<cudf::column>> originalColumns;
+    originalColumns.reserve(originalNumColumns);
+    std::move(
+        cudfTableColumns.begin(),
+        cudfTableColumns.begin() + originalNumColumns,
+        std::back_inserter(originalColumns));
+    auto originalTable =
+        std::make_unique<cudf::table>(std::move(originalColumns));
+    // Keep only rows where the filter is true
+    cudfTable = cudf::apply_boolean_mask(
+        *originalTable,
+        asView(filterResult),
+        stream_,
+        cudf::get_current_device_resource_ref());
+  }
+  totalRemainingFilterTime_.fetch_add(
+      filterTimeUs * 1000, std::memory_order_relaxed);
+
+  // Output RowVectorPtr
+  const auto nRows = cudfTable->num_rows();
+
+  // keep only outputType_.size() columns in cudfTable_
+  if (outputType_->size() < cudfTable->num_columns()) {
+    auto cudfTableColumns = cudfTable->release();
+    std::vector<std::unique_ptr<cudf::column>> originalColumns;
+    originalColumns.reserve(outputType_->size());
+    std::move(
+        cudfTableColumns.begin(),
+        cudfTableColumns.begin() + outputType_->size(),
+        std::back_inserter(originalColumns));
+    cudfTable = std::make_unique<cudf::table>(std::move(originalColumns));
+  }
+
+  // TODO (dm): Should we only enable table scan if cudf is registered?
+  // Earlier we could enable cudf table scans without using other cudf operators
+  // We still can, but I'm wondering if this is the right thing to do
+  auto output = cudfIsRegistered()
+      ? std::make_shared<CudfVector>(
+            pool_, outputType_, nRows, std::move(cudfTable), stream_)
+      : with_arrow::toVeloxColumn(
+            cudfTable->view(), pool_, outputType_->names(), stream_);
+  stream_.synchronize();
+
+  // Check if conversion yielded a nullptr
+  VELOX_CHECK_NOT_NULL(output, "Cudf to Velox conversion yielded a nullptr");
+
+  // Update completedRows_.
+  completedRows_ += output->size();
+
+  // TODO: Update `completedBytes_` here instead of in `addSplit()`
+
+  return output;
+}
+
+void CudfHiveDataSource::totalScanTimeCalculator(void* userData) {
+  TotalScanTimeCallbackData* data =
+      static_cast<TotalScanTimeCallbackData*>(userData);
+
+  // Record end time in callback
+  auto endTimeUs = getCurrentTimeMicro();
+
+  // Calculate elapsed time in microseconds and convert to nanoseconds
+  auto elapsedUs = endTimeUs - data->startTimeUs;
+  auto elapsedNs = elapsedUs * 1000; // Convert microseconds to nanoseconds
+
+  // Update totalScanTime
+  data->ioStats->incTotalScanTime(elapsedNs);
+
+  delete data;
+}
+
+void CudfHiveDataSource::addSplit(std::shared_ptr<ConnectorSplit> split) {
+  split_ = [&]() {
+    // Dynamic cast split to `CudfHiveConnectorSplit`
+    if (std::dynamic_pointer_cast<CudfHiveConnectorSplit>(split)) {
+      return std::dynamic_pointer_cast<CudfHiveConnectorSplit>(split);
+      // Convert `HiveConnectorSplit` to `CudfHiveConnectorSplit`
+    } else if (std::dynamic_pointer_cast<hive::HiveConnectorSplit>(split)) {
+      const auto hiveSplit =
+          std::dynamic_pointer_cast<hive::HiveConnectorSplit>(split);
+      VELOX_CHECK_EQ(
+          hiveSplit->fileFormat,
+          dwio::common::FileFormat::PARQUET,
+          "Unsupported file format for conversion from HiveConnectorSplit to CudfHiveConnectorSplit");
+      VELOX_CHECK_EQ(
+          hiveSplit->start,
+          0,
+          "CudfHiveDataSource cannot process splits with non-zero offset");
+      // Remove "file:" prefix from the file path if present
+      std::string cleanedPath = hiveSplit->filePath;
+      constexpr std::string_view kFilePrefix = "file:";
+      if (cleanedPath.compare(0, kFilePrefix.size(), kFilePrefix) == 0) {
+        cleanedPath = cleanedPath.substr(kFilePrefix.size());
+      }
+      return CudfHiveConnectorSplitBuilder(cleanedPath)
+          .connectorId(hiveSplit->connectorId)
+          .splitWeight(hiveSplit->splitWeight)
+          .build();
+    } else {
+      VELOX_FAIL("Unsupported split type: {}", split->toString());
+    }
+  }();
+
+  VLOG(1) << "Adding split " << split_->toString();
+
+  // Split reader already exists, reset
+  if (splitReader_ or exptSplitReader_) {
+    splitReader_.reset();
+    exptSplitReader_.reset();
+    tableMaterialized_.reset();
+  }
+
+  // Create a cudf split reader
+  if (useExperimentalSplitReader_) {
+    exptSplitReader_ = createExperimentalSplitReader();
+  } else {
+    splitReader_ = createSplitReader();
+  }
+
+  tableMaterialized_ = std::make_unique<std::once_flag>();
+
+  // TODO: `completedBytes_` should be updated in `next()` as we read more and
+  // more table bytes
+  try {
+    const auto fileHandleKey = FileHandleKey{
+        .filename = split_->filePath,
+        .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
+    auto fileProperties = FileProperties{};
+    auto const fileHandleCachePtr = fileHandleFactory_->generate(
+        fileHandleKey, &fileProperties, fsStats_ ? fsStats_.get() : nullptr);
+    if (fileHandleCachePtr.get() and fileHandleCachePtr.get()->file) {
+      completedBytes_ += fileHandleCachePtr->file->size();
+    }
+  } catch (const std::exception& e) {
+    // Unable to get the file size, log a warning and continue
+    LOG(WARNING) << "Failed to get file size for " << split_->filePath << ": "
+                 << e.what();
+  }
+}
+
+void CudfHiveDataSource::setupCudfDataSourceAndOptions() {
+  // Build source info for the chunked parquet reader
+  auto sourceInfo = [&]() {
+    // Use file data source if we don't want to use the BufferedInput source
+    if (not cudfHiveConfig_->useBufferedInputSession(
+            connectorQueryCtx_->sessionProperties())) {
+      LOG(INFO) << "Using file data source for CudfHiveDataSource";
+      return cudf::io::source_info{split_->filePath};
+    }
+
+    auto fileHandleCachePtr = FileHandleCachedPtr{};
+    try {
+      const auto fileHandleKey = FileHandleKey{
+          .filename = split_->filePath,
+          .tokenProvider = connectorQueryCtx_->fsTokenProvider()};
+      auto fileProperties = FileProperties{};
+      fileHandleCachePtr = fileHandleFactory_->generate(
+          fileHandleKey, &fileProperties, fsStats_ ? fsStats_.get() : nullptr);
+      VELOX_CHECK_NOT_NULL(fileHandleCachePtr.get());
+    } catch (const VeloxRuntimeError& e) {
+      LOG(WARNING) << fmt::format(
+          "Failed to generate file handle cache for file {}, falling back to file data source for CudfHiveDataSource",
+          split_->filePath);
+      return cudf::io::source_info{split_->filePath};
+    }
+
+    // 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 bufferedInput =
+        velox::connector::hive::BufferedInputBuilder::getInstance()->create(
+            *fileHandleCachePtr,
+            baseReaderOpts_,
+            connectorQueryCtx_,
+            ioStats_,
+            fsStats_,
+            executor_);
+    if (not bufferedInput) {
+      LOG(WARNING) << fmt::format(
+          "Failed to create buffered input source for file {}, falling back to file data source for CudfHiveDataSource",
+          split_->filePath);
+      return cudf::io::source_info{split_->filePath};
+    }
+    dataSource_ =
+        std::make_unique<BufferedInputDataSource>(std::move(bufferedInput));
+    return cudf::io::source_info{dataSource_.get()};
+  }();
+
+  if (dataSource_ == nullptr) {
+    dataSource_ = std::move(makeDataSourcesFromSourceInfo(sourceInfo).front());
+  }
+
+  // Reader options
+  readerOptions_ =
+      cudf::io::parquet_reader_options::builder(std::move(sourceInfo))
+          .skip_rows(cudfHiveConfig_->skipRows())
+          .use_pandas_metadata(cudfHiveConfig_->isUsePandasMetadata())
+          .use_arrow_schema(cudfHiveConfig_->isUseArrowSchema())
+          .allow_mismatched_pq_schemas(
+              cudfHiveConfig_->isAllowMismatchedCudfHiveSchemas())
+          .timestamp_type(cudfHiveConfig_->timestampType())
+          .build();
+
+  // Set num_rows only if available
+  if (cudfHiveConfig_->numRows().has_value()) {
+    readerOptions_.set_num_rows(cudfHiveConfig_->numRows().value());
+  }
+
+  if (subfieldFilters_.size()) {
+    const RowTypePtr readerFilterType = [&] {
+      if (tableHandle_->dataColumns()) {
+        std::vector<std::string> newNames;
+        std::vector<TypePtr> newTypes;
+
+        for (const auto& name : readColumnNames_) {
+          // Ensure all columns being read are available to the filter
+          auto parsedType = tableHandle_->dataColumns()->findChild(name);
+          newNames.emplace_back(std::move(name));
+          newTypes.push_back(parsedType);
+        }
+
+        return ROW(std::move(newNames), std::move(newTypes));
+      } else {
+        return outputType_;
+      }
+    }();
+
+    // Build a combined AST for all subfield filters.
+    auto const& combinedExpr = createAstFromSubfieldFilters(
+        subfieldFilters_, subfieldTree_, subfieldScalars_, readerFilterType);
+
+    readerOptions_.set_filter(combinedExpr);
+  }
+
+  // Set column projection if needed
+  if (readColumnNames_.size()) {
+    readerOptions_.set_columns(readColumnNames_);
+  }
+}
+
+CudfParquetReaderPtr CudfHiveDataSource::createSplitReader() {
+  setupCudfDataSourceAndOptions();
+  stream_ = cudfGlobalStreamPool().get_stream();
+
+  // Create a parquet reader
+  return std::make_unique<cudf::io::chunked_parquet_reader>(
+      cudfHiveConfig_->maxChunkReadLimit(),
+      cudfHiveConfig_->maxPassReadLimit(),
+      readerOptions_,
+      stream_,
+      cudf::get_current_device_resource_ref());
+}
+
+CudfHybridScanReaderPtr CudfHiveDataSource::createExperimentalSplitReader() {
+  setupCudfDataSourceAndOptions();
+  stream_ = cudfGlobalStreamPool().get_stream();
+
+  // Create a hybrid scan reader
+  auto const footerBytes = fetchFooterBytes(dataSource_);
+  auto exptSplitReader = std::make_unique<CudfHybridScanReader>(
+      cudf::host_span<uint8_t const>{footerBytes->data(), footerBytes->size()},
+      readerOptions_);
+
+  // Setup page index if available
+  auto const pageIndexByteRange = exptSplitReader->page_index_byte_range();
+  if (not pageIndexByteRange.is_empty()) {
+    auto const pageIndexBytes = dataSource_->host_read(
+        pageIndexByteRange.offset(), pageIndexByteRange.size());
+    exptSplitReader->setup_page_index(
+        cudf::host_span<uint8_t const>{
+            pageIndexBytes->data(), pageIndexBytes->size()});
+  }
+
+  return exptSplitReader;
+}
+
+void CudfHiveDataSource::resetSplit() {
+  split_.reset();
+  splitReader_.reset();
+  exptSplitReader_.reset();
+  tableMaterialized_.reset();
+  dataSource_.reset();
+}
+
+std::unordered_map<std::string, RuntimeMetric>
+CudfHiveDataSource::getRuntimeStats() {
+  auto res = runtimeStats_.toRuntimeMetricMap();
+  res.insert({
+      {"totalScanTime",
+       RuntimeMetric(ioStats_->totalScanTime(), RuntimeCounter::Unit::kNanos)},
+      {"totalRemainingFilterTime",
+       RuntimeMetric(
+           totalRemainingFilterTime_.load(std::memory_order_relaxed),
+           RuntimeCounter::Unit::kNanos)},
+  });
+  const auto& fsStats = fsStats_->stats();
+  for (const auto& storageStats : fsStats) {
+    res.emplace(storageStats.first, storageStats.second);
+  }
+  return res;
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h b/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h
new file mode 100644
index 000000000000..82b148d68fde
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSource.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 "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
+#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/common/base/RandomUtil.h"
+#include "velox/common/io/IoStatistics.h"
+#include "velox/common/io/Options.h"
+#include "velox/connectors/Connector.h"
+#include "velox/connectors/hive/FileHandle.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/type/Type.h"
+
+#include <cudf/io/datasource.hpp>
+#include <cudf/io/experimental/hybrid_scan.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/types.hpp>
+
+#include <mutex>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+
+using CudfParquetReader = cudf::io::chunked_parquet_reader;
+using CudfParquetReaderPtr = std::unique_ptr<CudfParquetReader>;
+
+using CudfHybridScanReader =
+    cudf::io::parquet::experimental::hybrid_scan_reader;
+using CudfHybridScanReaderPtr = std::unique_ptr<CudfHybridScanReader>;
+
+class CudfHiveDataSource : public DataSource, public NvtxHelper {
+ public:
+  CudfHiveDataSource(
+      const RowTypePtr& outputType,
+      const ConnectorTableHandlePtr& tableHandle,
+      const ColumnHandleMap& columnHandles,
+      facebook::velox::FileHandleFactory* fileHandleFactory,
+      folly::Executor* executor,
+      const ConnectorQueryCtx* connectorQueryCtx,
+      const std::shared_ptr<CudfHiveConfig>& CudfHiveConfig);
+
+  void addSplit(std::shared_ptr<ConnectorSplit> split) override;
+
+  void addDynamicFilter(
+      column_index_t /*outputChannel*/,
+      const std::shared_ptr<facebook::velox::common::Filter>& /*filter*/)
+      override {
+    VELOX_NYI(
+        "Dynamic filters not yet implemented by cudf::CudfHiveConnector.");
+  }
+
+  std::optional<RowVectorPtr> next(
+      uint64_t size,
+      velox::ContinueFuture& /* future */) override;
+
+  uint64_t getCompletedRows() override {
+    return completedRows_;
+  }
+
+  const common::SubfieldFilters* getFilters() const override {
+    return &subfieldFilters_;
+  }
+
+  uint64_t getCompletedBytes() override {
+    return completedBytes_;
+  }
+
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override;
+
+ private:
+  // Create a CudfParquetReader with the given split.
+  CudfParquetReaderPtr createSplitReader();
+  CudfHybridScanReaderPtr createExperimentalSplitReader();
+
+  // Clear split_ and splitReader after split has been fully processed.  Keep
+  // readers around to hold adaptation.
+  void resetSplit();
+  // Clear cudfTable_ and currentCudfTableView_ once we have successfully
+  // converted it to `RowVectorPtr` and returned.
+  void resetCudfTableAndView();
+  const RowVectorPtr& getEmptyOutput() {
+    if (!emptyOutput_) {
+      emptyOutput_ = RowVector::createEmpty(outputType_, pool_);
+    }
+    return emptyOutput_;
+  }
+
+  // Setup the cuDF data source and options
+  void setupCudfDataSourceAndOptions();
+
+  RowVectorPtr emptyOutput_;
+
+  std::shared_ptr<CudfHiveConnectorSplit> split_;
+  std::shared_ptr<const ::facebook::velox::connector::hive::HiveTableHandle>
+      tableHandle_;
+
+  const std::shared_ptr<CudfHiveConfig> cudfHiveConfig_;
+  facebook::velox::FileHandleFactory* const fileHandleFactory_;
+  folly::Executor* const executor_;
+  const ConnectorQueryCtx* const connectorQueryCtx_;
+
+  memory::MemoryPool* const pool_;
+
+  // cuDF split reader stuff.
+  cudf::io::parquet_reader_options readerOptions_;
+  std::shared_ptr<cudf::io::datasource> dataSource_;
+  std::unique_ptr<std::once_flag> tableMaterialized_;
+  CudfParquetReaderPtr splitReader_;
+  CudfHybridScanReaderPtr exptSplitReader_;
+  bool useExperimentalSplitReader_;
+  rmm::cuda_stream_view stream_;
+
+  // Output type from file reader.  This is different from outputType_ that it
+  // contains column names before assignment, and columns that only used in
+  // remaining filter.
+  RowTypePtr readerOutputType_;
+
+  // Columns to read.
+  std::vector<std::string> readColumnNames_;
+
+  std::shared_ptr<io::IoStatistics> ioStats_;
+  std::shared_ptr<filesystems::File::IoStats> fsStats_;
+
+  dwio::common::ReaderOptions baseReaderOpts_;
+
+  size_t completedRows_{0};
+  size_t completedBytes_{0};
+
+  // The row type for the data source output, not including filter-only columns
+  const RowTypePtr outputType_;
+
+  // Expression evaluator for remaining filter.
+  core::ExpressionEvaluator* const expressionEvaluator_;
+  std::unique_ptr<exec::ExprSet> remainingFilterExprSet_;
+  std::shared_ptr<velox::cudf_velox::CudfExpression> cudfExpressionEvaluator_;
+
+  // Expression evaluator for subfield filter.
+  std::vector<std::unique_ptr<cudf::scalar>> subfieldScalars_;
+  cudf::ast::tree subfieldTree_;
+  common::SubfieldFilters subfieldFilters_;
+
+  dwio::common::RuntimeStatistics runtimeStats_;
+  std::atomic<uint64_t> totalRemainingFilterTime_{0};
+
+  // Create callback data for total scan timing calculation
+  struct TotalScanTimeCallbackData {
+    uint64_t startTimeUs;
+    std::shared_ptr<io::IoStatistics> ioStats;
+  };
+
+  // Host callback function to calculate total scan time
+  static void totalScanTimeCalculator(void* userData);
+};
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSourceHelpers.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveDataSourceHelpers.cpp
new file mode 100644
index 000000000000..0a3f3347b414
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSourceHelpers.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/experimental/cudf/connectors/hive/CudfHiveDataSourceHelpers.hpp"
+
+#include "velox/dwio/common/BufferedInput.h"
+
+#include <cudf/ast/detail/expression_transformer.hpp>
+#include <cudf/ast/detail/operators.hpp>
+#include <cudf/ast/expressions.hpp>
+#include <cudf/detail/utilities/integer_utils.hpp>
+#include <cudf/io/datasource.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/types.hpp>
+
+#include <list>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+BufferedInputDataSource::BufferedInputDataSource(
+    std::shared_ptr<facebook::velox::dwio::common::BufferedInput> input)
+    : input_(std::move(input)), fileSize_(input_->getReadFile()->size()) {}
+
+size_t BufferedInputDataSource::size() const {
+  return fileSize_;
+}
+
+std::unique_ptr<cudf::io::datasource::buffer>
+BufferedInputDataSource::host_read(size_t offset, size_t size) {
+  if (offset >= fileSize_) {
+    return cudf::io::datasource::buffer::create(std::vector<uint8_t>{});
+  }
+  const size_t readSize = std::min(size, fileSize_ - offset);
+  std::vector<uint8_t> data(readSize);
+  readContiguous(offset, readSize, data.data());
+  return cudf::io::datasource::buffer::create(std::move(data));
+}
+
+size_t
+BufferedInputDataSource::host_read(size_t offset, size_t size, uint8_t* dst) {
+  if (offset >= fileSize_) {
+    return 0;
+  }
+  const size_t readSize = std::min(size, fileSize_ - offset);
+  readContiguous(offset, readSize, dst);
+  return readSize;
+}
+
+std::future<std::unique_ptr<cudf::io::datasource::buffer>>
+BufferedInputDataSource::host_read_async(size_t offset, size_t size) {
+  return std::async(std::launch::deferred, [this, offset, size]() {
+    return this->host_read(offset, size);
+  });
+}
+
+std::future<size_t> BufferedInputDataSource::host_read_async(
+    size_t offset,
+    size_t size,
+    uint8_t* dst) {
+  return std::async(std::launch::deferred, [this, offset, size, dst]() {
+    return this->host_read(offset, size, dst);
+  });
+}
+
+bool BufferedInputDataSource::supports_device_read() const {
+  return false;
+}
+
+void BufferedInputDataSource::readContiguous(
+    size_t offset,
+    size_t size,
+    uint8_t* dst) {
+  using namespace facebook::velox::dwio::common;
+  // BufferedInput::read gives us a stream over the exact region.
+  auto stream = input_->read(offset, size, LogType::FILE);
+  VELOX_CHECK(stream != nullptr, "read() returned null stream");
+  stream->readFully(reinterpret_cast<char*>(dst), size);
+}
+
+referenceToNameConverter::referenceToNameConverter(
+    std::optional<std::reference_wrapper<const cudf::ast::expression>> expr,
+    const std::vector<cudf::io::parquet::SchemaElement>& schemaTree,
+    cudf::host_span<const std::string> readColumnNames) {
+  if (not expr.has_value()) {
+    return;
+  }
+  // Map column indices to their names
+  if (not readColumnNames.empty()) {
+    std::transform(
+        readColumnNames.begin(),
+        readColumnNames.end(),
+        thrust::counting_iterator<cudf::size_type>(0),
+        std::inserter(indicesToColumnNames_, indicesToColumnNames_.end()),
+        [](const auto& columnName, const auto colIndex) {
+          return std::make_pair(colIndex, columnName);
+        });
+  } else {
+    const auto& root = schemaTree.front();
+    std::for_each(
+        thrust::counting_iterator(0),
+        thrust::counting_iterator<cudf::size_type>(root.children_idx.size()),
+        [&](int32_t colIndex) {
+          const auto schemaIdx = root.children_idx[colIndex];
+          indicesToColumnNames_.insert({colIndex, schemaTree[schemaIdx].name});
+        });
+  }
+
+  expr.value().get().accept(*this);
+}
+
+std::reference_wrapper<const cudf::ast::expression>
+referenceToNameConverter::visit(const cudf::ast::literal& expr) {
+  return expr;
+}
+
+std::reference_wrapper<const cudf::ast::expression>
+referenceToNameConverter::visit(const cudf::ast::column_reference& expr) {
+  const auto columnIdx = expr.get_column_index();
+  const auto columnName = indicesToColumnNames_.find(columnIdx);
+  VELOX_CHECK(
+      columnName != indicesToColumnNames_.end(), "Column index not found");
+  convertedExpr_.push(cudf::ast::column_name_reference{columnName->second});
+  return std::reference_wrapper<const cudf::ast::expression>(
+      convertedExpr_.back());
+}
+
+std::reference_wrapper<const cudf::ast::expression>
+referenceToNameConverter::visit(const cudf::ast::column_name_reference& expr) {
+  return expr;
+}
+
+std::reference_wrapper<const cudf::ast::expression>
+referenceToNameConverter::visit(const cudf::ast::operation& expr) {
+  const auto operands = expr.get_operands();
+  auto op = expr.get_operator();
+  auto newOperands = visitOperands(operands);
+  const auto operatorArity = cudf::ast::detail::ast_operator_arity(op);
+  if (operatorArity == 2) {
+    convertedExpr_.push(
+        cudf::ast::operation{op, newOperands.front(), newOperands.back()});
+  } else if (operatorArity == 1) {
+    convertedExpr_.push(cudf::ast::operation{op, newOperands.front()});
+  }
+  return convertedExpr_.back();
+}
+
+std::reference_wrapper<const cudf::ast::expression>
+referenceToNameConverter::convertedExpression() const {
+  return convertedExpr_.back();
+}
+
+std::vector<std::reference_wrapper<const cudf::ast::expression>>
+referenceToNameConverter::visitOperands(
+    cudf::host_span<const std::reference_wrapper<const cudf::ast::expression>>
+        operands) {
+  std::vector<std::reference_wrapper<const cudf::ast::expression>>
+      transformedOperands;
+  for (const auto& operand : operands) {
+    const auto newOperand = operand.get().accept(*this);
+    transformedOperands.push_back(newOperand);
+  }
+  return transformedOperands;
+}
+
+std::unique_ptr<cudf::io::datasource::buffer> fetchFooterBytes(
+    std::shared_ptr<cudf::io::datasource> dataSource) {
+  using namespace cudf::io::parquet;
+
+  constexpr auto header_len = sizeof(file_header_s);
+  constexpr auto ender_len = sizeof(file_ender_s);
+  const size_t len = dataSource->size();
+
+  const auto header_buffer = dataSource->host_read(0, header_len);
+  const auto ender_buffer = dataSource->host_read(len - ender_len, ender_len);
+  const auto header =
+      reinterpret_cast<const file_header_s*>(header_buffer->data());
+  const auto ender =
+      reinterpret_cast<const file_ender_s*>(ender_buffer->data());
+  VELOX_CHECK(len > header_len + ender_len, "Incorrect data source");
+  constexpr uint32_t parquet_magic =
+      (('P' << 0) | ('A' << 8) | ('R' << 16) | ('1' << 24));
+  VELOX_CHECK(
+      header->magic == parquet_magic && ender->magic == parquet_magic,
+      "Corrupted header or footer");
+  VELOX_CHECK(
+      ender->footer_len != 0 &&
+          ender->footer_len <= (len - header_len - ender_len),
+      "Incorrect footer length");
+
+  return dataSource->host_read(
+      len - ender->footer_len - ender_len, ender->footer_len);
+}
+
+std::vector<std::unique_ptr<cudf::io::datasource>>
+makeDataSourcesFromSourceInfo(
+    const cudf::io::source_info& info,
+    size_t offset,
+    size_t maxSizeEstimate) {
+  switch (info.type()) {
+    case cudf::io::io_type::FILEPATH: {
+      std::vector<std::unique_ptr<cudf::io::datasource>> sources;
+      sources.reserve(info.filepaths().size());
+      for (auto const& filepath : info.filepaths()) {
+        sources.emplace_back(
+            cudf::io::datasource::create(filepath, offset, maxSizeEstimate));
+      }
+      return sources;
+    }
+    case cudf::io::io_type::HOST_BUFFER:
+      return cudf::io::datasource::create(info.host_buffers());
+    case cudf::io::io_type::DEVICE_BUFFER:
+      return cudf::io::datasource::create(info.device_buffers());
+    case cudf::io::io_type::USER_IMPLEMENTED:
+      return cudf::io::datasource::create(info.user_sources());
+    default:
+      CUDF_FAIL("Unsupported source type");
+  }
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveDataSourceHelpers.hpp b/velox/experimental/cudf/connectors/hive/CudfHiveDataSourceHelpers.hpp
new file mode 100644
index 000000000000..6d3a93438aeb
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveDataSourceHelpers.hpp
@@ -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/dwio/common/BufferedInput.h"
+
+#include <cudf/ast/detail/expression_transformer.hpp>
+#include <cudf/ast/detail/operators.hpp>
+#include <cudf/ast/expressions.hpp>
+#include <cudf/detail/utilities/integer_utils.hpp>
+#include <cudf/io/datasource.hpp>
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/parquet_schema.hpp>
+#include <cudf/io/types.hpp>
+
+#include <list>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+// ---------------- Internal helper ----------------
+// A cudf::io::datasource that serves bytes via Velox BufferedInput so that
+// reads benefit from AsyncDataCache / SSD cache and are always returned as
+// contiguous buffers.
+class BufferedInputDataSource : public cudf::io::datasource {
+ public:
+  explicit BufferedInputDataSource(
+      std::shared_ptr<facebook::velox::dwio::common::BufferedInput> input);
+
+  [[nodiscard]] size_t size() const override;
+
+  std::unique_ptr<datasource::buffer> host_read(size_t offset, size_t size)
+      override;
+
+  size_t host_read(size_t offset, size_t size, uint8_t* dst) override;
+
+  std::future<std::unique_ptr<datasource::buffer>> host_read_async(
+      size_t offset,
+      size_t size) override;
+
+  std::future<size_t> host_read_async(size_t offset, size_t size, uint8_t* dst);
+
+  [[nodiscard]] bool supports_device_read() const override;
+
+ private:
+  void readContiguous(size_t offset, size_t size, uint8_t* dst);
+
+  std::shared_ptr<facebook::velox::dwio::common::BufferedInput> input_;
+  const size_t fileSize_;
+};
+
+// ---------------- Internal helper ----------------
+// Convert a filter expression such that all `ast::column_reference`s are
+// replaced with `ast::column_name_reference`s from the selected columns or
+// the schema tree.
+// TODO(mh): Remove this once https://github.com/rapidsai/cudf/pull/20604 is
+// merged
+class referenceToNameConverter
+    : public cudf::ast::detail::expression_transformer {
+ public:
+  explicit referenceToNameConverter(
+      std::optional<std::reference_wrapper<const cudf::ast::expression>> expr,
+      const std::vector<cudf::io::parquet::SchemaElement>& schemaTree,
+      cudf::host_span<const std::string> readColumnNames);
+
+  std::reference_wrapper<const cudf::ast::expression> visit(
+      const cudf::ast::literal& expr) override;
+
+  std::reference_wrapper<const cudf::ast::expression> visit(
+      const cudf::ast::column_reference& expr) override;
+
+  std::reference_wrapper<const cudf::ast::expression> visit(
+      const cudf::ast::column_name_reference& expr) override;
+
+  std::reference_wrapper<const cudf::ast::expression> visit(
+      const cudf::ast::operation& expr) override;
+
+  // Returns the converted AST expression
+  [[nodiscard]] std::reference_wrapper<const cudf::ast::expression>
+  convertedExpression() const;
+
+ private:
+  std::vector<std::reference_wrapper<const cudf::ast::expression>>
+  visitOperands(
+      cudf::host_span<const std::reference_wrapper<const cudf::ast::expression>>
+          operands);
+  cudf::ast::tree convertedExpr_;
+  std::unordered_map<cudf::size_type, std::string> indicesToColumnNames_;
+};
+
+// Fetch a host buffer containing parquet source footer from a data source.
+std::unique_ptr<cudf::io::datasource::buffer> fetchFooterBytes(
+    std::shared_ptr<cudf::io::datasource> dataSource);
+
+std::vector<std::unique_ptr<cudf::io::datasource>>
+makeDataSourcesFromSourceInfo(
+    const cudf::io::source_info& info,
+    size_t offset = 0,
+    size_t maxSizeEstimate = 0);
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.cpp b/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.cpp
new file mode 100644
index 000000000000..64286506cf09
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.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/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+
+#include "velox/connectors/Connector.h"
+#include "velox/type/Type.h"
+
+#include <string>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+
+std::string CudfHiveColumnHandle::toString() const {
+  std::ostringstream out;
+  out << fmt::format(
+      "CudfHiveColumnHandle [name: {}, Type: {},", name_, type_->toString());
+  return out.str();
+}
+
+CudfHiveTableHandle::CudfHiveTableHandle(
+    std::string connectorId,
+    const std::string& tableName,
+    bool filterPushdownEnabled,
+    const core::TypedExprPtr& subfieldFilterExpr,
+    const core::TypedExprPtr& remainingFilter,
+    const RowTypePtr& dataColumns)
+    : ConnectorTableHandle(std::move(connectorId)),
+      tableName_(tableName),
+      filterPushdownEnabled_(filterPushdownEnabled),
+      subfieldFilterExpr_(subfieldFilterExpr),
+      remainingFilter_(remainingFilter),
+      dataColumns_(dataColumns) {}
+
+std::string CudfHiveTableHandle::toString() const {
+  std::stringstream out;
+  out << "table: " << tableName_;
+  if (dataColumns_) {
+    out << ", data columns: " << dataColumns_->toString();
+  }
+  return out.str();
+}
+
+ConnectorTableHandlePtr CudfHiveTableHandle::create(
+    const folly::dynamic& obj,
+    void* context) {
+  VELOX_NYI("CudfHiveTableHandle::create() not yet implemented");
+}
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h b/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h
new file mode 100644
index 000000000000..8d97db028d49
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/core/Expressions.h"
+#include "velox/expression/Expr.h"
+#include "velox/type/Type.h"
+
+#include <cudf/types.hpp>
+
+#include <string>
+#include <vector>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace facebook::velox::connector;
+
+// CudfHive column handle only needs the column name (all columns are generated
+// in the same way).
+class CudfHiveColumnHandle : public ColumnHandle {
+ public:
+  explicit CudfHiveColumnHandle(
+      const std::string& name,
+      const TypePtr type,
+      const cudf::data_type cudfDataType,
+      std::vector<CudfHiveColumnHandle> children = {})
+      : name_(name),
+        type_(type),
+        cudfDataType_(cudfDataType),
+        children_(std::move(children)) {}
+
+  const std::string& name() const {
+    return name_;
+  }
+
+  const TypePtr& type() const {
+    return type_;
+  }
+
+  const cudf::data_type cudfDataType() const {
+    return cudfDataType_;
+  }
+
+  const std::vector<CudfHiveColumnHandle>& children() const {
+    return children_;
+  }
+
+  std::string toString() const;
+
+ private:
+  const std::string name_;
+  const TypePtr type_;
+  const cudf::data_type cudfDataType_;
+  const std::vector<CudfHiveColumnHandle> children_;
+};
+
+class CudfHiveTableHandle : public ConnectorTableHandle {
+ public:
+  CudfHiveTableHandle(
+      std::string connectorId,
+      const std::string& tableName,
+      bool filterPushdownEnabled,
+      const core::TypedExprPtr& subfieldFilterExpr,
+      const core::TypedExprPtr& remainingFilter = nullptr,
+      const RowTypePtr& dataColumns = nullptr);
+
+  const std::string& name() const override {
+    return tableName_;
+  }
+
+  bool isFilterPushdownEnabled() const {
+    return filterPushdownEnabled_;
+  }
+
+  const core::TypedExprPtr& subfieldFilterExpr() const {
+    return subfieldFilterExpr_;
+  }
+
+  const core::TypedExprPtr& remainingFilter() const {
+    return remainingFilter_;
+  }
+
+  // Schema of the table.  Need this for reading TEXTFILE.
+  const RowTypePtr& dataColumns() const {
+    return dataColumns_;
+  }
+
+  std::string toString() const override;
+
+  static ConnectorTableHandlePtr create(
+      const folly::dynamic& obj,
+      void* context);
+
+ private:
+  const std::string tableName_;
+  const bool filterPushdownEnabled_;
+  // This expression is used for predicate pushdown.
+  const core::TypedExprPtr subfieldFilterExpr_;
+  // This expression is used for post-scan filtering.
+  const core::TypedExprPtr remainingFilter_;
+  const RowTypePtr dataColumns_;
+};
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/connectors/hive/WriterOptions.h b/velox/experimental/cudf/connectors/hive/WriterOptions.h
new file mode 100644
index 000000000000..389ad985e27e
--- /dev/null
+++ b/velox/experimental/cudf/connectors/hive/WriterOptions.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/dwio/common/Options.h"
+
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/types.hpp>
+#include <cudf/types.hpp>
+
+#include <optional>
+
+namespace facebook::velox::cudf_velox::connector::hive {
+
+using namespace cudf::io;
+
+/**
+ * @brief Struct to 1:1 correspond with cudf::io::chunked_parquet_reader_options
+ * except sink_info and a few others which are provided to the CudfHiveDataSink
+ * from elsewhere.
+ */
+struct CudfHiveWriterOptions
+    : public facebook::velox::dwio::common::WriterOptions {
+  // Specify the level of statistics in the output file
+  statistics_freq statsLevel = statistics_freq::STATISTICS_ROWGROUP;
+
+  // CudfHive writer can write INT96 or TIMESTAMP_MICROS. Defaults to
+  // TIMESTAMPMICROS. If true then overrides any per-column setting in
+  // Metadata.
+  bool writeTimestampsAsInt96 = false;
+
+  // CudfHive writer can write timestamps as UTC
+  // Defaults to true because libcudf timestamps are implicitly UTC
+  bool writeTimestampsAsUTC = true;
+
+  // Whether to write ARROW schema
+  bool writeArrowSchema = false;
+
+  // Maximum size of each row group (unless smaller than a single page)
+  size_t rowGroupSizeBytes = default_row_group_size_bytes;
+
+  // Maximum number of rows in row group (unless smaller than a single page)
+  cudf::size_type rowGroupSizeRows = default_row_group_size_rows;
+
+  // Maximum size of each page (uncompressed) - Velox uses 1KB (2 x cudf limit)
+  size_t maxPageSizeBytes = 2 * default_max_page_size_bytes;
+
+  // Maximum number of rows in a page
+  cudf::size_type maxPageSizeRows = default_max_page_size_rows;
+
+  // Maximum size of min or max values in column index
+  int32_t columnIndexTruncateLength = default_column_index_truncate_length;
+
+  // When to use dictionary encoding for data
+  dictionary_policy dictionaryPolicy = dictionary_policy::ADAPTIVE;
+
+  // Maximum size of column chunk dictionary (in bytes)
+  size_t maxDictionarySize = default_max_dictionary_size;
+
+  // Maximum number of rows in a page fragment
+  std::optional<cudf::size_type> maxPageFragmentSize;
+
+  // Optional compression statistics
+  std::shared_ptr<writer_compression_statistics> compressionStats;
+
+  // Write V2 page headers?
+  bool v2PageHeaders = false;
+
+  // Encoding to use for columns
+  column_encoding encoding = column_encoding::PLAIN;
+
+  // Sorting columns
+  std::vector<sorting_column> sortingColumns;
+};
+
+} // namespace facebook::velox::cudf_velox::connector::hive
diff --git a/velox/experimental/cudf/exec/CMakeLists.txt b/velox/experimental/cudf/exec/CMakeLists.txt
index c5c2711f8124..28acf1131d43 100644
--- a/velox/experimental/cudf/exec/CMakeLists.txt
+++ b/velox/experimental/cudf/exec/CMakeLists.txt
@@ -14,20 +14,33 @@
 
 add_library(
   velox_cudf_exec
+  CudfAssignUniqueId.cpp
   CudfConversion.cpp
+  CudfFilterProject.cpp
   CudfHashAggregation.cpp
+  CudfHashJoin.cpp
+  CudfLimit.cpp
+  CudfLocalPartition.cpp
   CudfOrderBy.cpp
+  CudfTopN.cpp
+  DebugUtil.cpp
   ToCudf.cpp
   Utilities.cpp
-  VeloxCudfInterop.cpp)
+  VeloxCudfInterop.cpp
+)
 
 target_link_libraries(
   velox_cudf_exec
-  cudf::cudf
-  arrow
-  velox_arrow_bridge
-  velox_exception
-  velox_common_base
-  velox_exec)
+  PUBLIC cudf::cudf
+  PRIVATE
+    arrow
+    velox_arrow_bridge
+    velox_exception
+    velox_common_base
+    velox_cudf_vector
+    velox_exec
+    velox_cudf_hive_connector
+    velox_cudf_expression
+)
 
 target_compile_options(velox_cudf_exec PRIVATE -Wno-missing-field-initializers)
diff --git a/velox/experimental/cudf/exec/CudfAssignUniqueId.cpp b/velox/experimental/cudf/exec/CudfAssignUniqueId.cpp
new file mode 100644
index 000000000000..10b779317ec7
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfAssignUniqueId.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 "velox/experimental/cudf/exec/CudfAssignUniqueId.h"
+
+#include <cudf/lists/filling.hpp>
+
+#include <utility>
+
+namespace facebook::velox::cudf_velox {
+
+CudfAssignUniqueId::CudfAssignUniqueId(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::AssignUniqueIdNode>& planNode,
+    int32_t uniqueTaskId,
+    std::shared_ptr<std::atomic_int64_t> rowIdPool)
+    : Operator(
+          driverCtx,
+          planNode->outputType(),
+          operatorId,
+          planNode->id(),
+          "CudfAssignUniqueId"),
+      NvtxHelper(
+          nvtx3::rgb{160, 82, 45}, // Sienna
+          operatorId,
+          fmt::format("[{}]", planNode->id())),
+      rowIdPool_(std::move(rowIdPool)) {
+  VELOX_USER_CHECK_LT(
+      uniqueTaskId,
+      kTaskUniqueIdLimit,
+      "Unique 24-bit ID specified for CudfAssignUniqueId exceeds the limit");
+  uniqueValueMask_ = static_cast<int64_t>(uniqueTaskId) << 40;
+
+  rowIdCounter_ = 0;
+  maxRowIdCounterValue_ = 0;
+}
+
+void CudfAssignUniqueId::addInput(RowVectorPtr input) {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  auto numInput = input->size();
+  VELOX_CHECK_NE(
+      numInput, 0, "CudfAssignUniqueId::addInput received empty set of rows");
+  input_ = std::move(input);
+}
+
+RowVectorPtr CudfAssignUniqueId::getOutput() {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+
+  if (input_ == nullptr) {
+    return nullptr;
+  }
+
+  auto cudfVector = std::dynamic_pointer_cast<CudfVector>(input_);
+  VELOX_CHECK(cudfVector, "Input must be a CudfVector");
+  auto stream = cudfVector->stream();
+  auto uniqueIdColumn = generateIdColumn(
+      input_->size(), stream, cudf::get_current_device_resource_ref());
+  auto size = cudfVector->size();
+  auto columns = cudfVector->release()->release();
+  columns.push_back(std::move(uniqueIdColumn));
+  auto output = std::make_shared<CudfVector>(
+      input_->pool(),
+      outputType_,
+      size,
+      std::make_unique<cudf::table>(std::move(columns)),
+      stream);
+  input_ = nullptr;
+  return output;
+}
+
+bool CudfAssignUniqueId::isFinished() {
+  return noMoreInput_ && input_ == nullptr;
+}
+
+std::unique_ptr<cudf::column> CudfAssignUniqueId::generateIdColumn(
+    vector_size_t size,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  std::vector<int64_t> starts, sizes;
+  starts.reserve(size / kRowIdsPerRequest + 1);
+  sizes.reserve(size / kRowIdsPerRequest + 1);
+
+  vector_size_t start = 0;
+  while (start < size) {
+    if (rowIdCounter_ >= maxRowIdCounterValue_) {
+      requestRowIds();
+    }
+
+    const auto numAvailableIds =
+        std::min(maxRowIdCounterValue_ - rowIdCounter_, kRowIdsPerRequest);
+    const vector_size_t end =
+        std::min(static_cast<int64_t>(size), start + numAvailableIds);
+    VELOX_CHECK_EQ(
+        (rowIdCounter_ + (end - start)) & uniqueValueMask_,
+        0,
+        "Ran out of unique IDs at {}. Need {} more.",
+        rowIdCounter_,
+        (end - start));
+    starts.push_back(uniqueValueMask_ | rowIdCounter_);
+    sizes.push_back(end - start);
+
+    rowIdCounter_ += (end - start);
+    start = end;
+  }
+
+  // Copy starts and sizes to device.
+  rmm::device_buffer d_starts_buffer(
+      starts.data(), starts.size() * sizeof(int64_t), stream, mr);
+  rmm::device_buffer d_sizes_buffer(
+      sizes.data(), sizes.size() * sizeof(int64_t), stream, mr);
+  auto d_starts_column_view = cudf::column_view(
+      cudf::data_type(cudf::type_id::INT64),
+      starts.size(),
+      d_starts_buffer.data(),
+      nullptr,
+      0,
+      0);
+  auto d_sizes_column_view = cudf::column_view(
+      cudf::data_type(cudf::type_id::INT64),
+      sizes.size(),
+      d_sizes_buffer.data(),
+      nullptr,
+      0,
+      0);
+
+  auto list_sequence = cudf::lists::sequences(
+      d_starts_column_view, d_sizes_column_view, stream, mr);
+  // Discard offsets.
+  return std::move(list_sequence->release().children[1]);
+}
+
+void CudfAssignUniqueId::requestRowIds() {
+  rowIdCounter_ = rowIdPool_->fetch_add(kRowIdsPerRequest);
+  maxRowIdCounterValue_ =
+      std::min(rowIdCounter_ + kRowIdsPerRequest, kMaxRowId);
+}
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfAssignUniqueId.h b/velox/experimental/cudf/exec/CudfAssignUniqueId.h
new file mode 100644
index 000000000000..b76870b563eb
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfAssignUniqueId.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/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/exec/Operator.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::cudf_velox {
+
+class CudfAssignUniqueId : public exec::Operator, public NvtxHelper {
+ public:
+  CudfAssignUniqueId(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::AssignUniqueIdNode>& planNode,
+      int32_t uniqueTaskId,
+      std::shared_ptr<std::atomic_int64_t> rowIdPool);
+
+  bool isFilter() const override {
+    return true;
+  }
+
+  bool preservesOrder() const override {
+    return true;
+  }
+
+  bool needsInput() const override {
+    return input_ == nullptr;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool startDrain() override {
+    // No need to drain for assignUniqueId operator.
+    return false;
+  }
+
+  bool isFinished() override;
+
+ private:
+  std::unique_ptr<cudf::column> generateIdColumn(
+      vector_size_t size,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr);
+
+  void requestRowIds();
+
+  const int64_t kRowIdsPerRequest = 1L << 20;
+  const int64_t kMaxRowId = 1L << 40;
+  const int64_t kTaskUniqueIdLimit = 1L << 24;
+
+  int64_t uniqueValueMask_;
+  int64_t rowIdCounter_;
+  int64_t maxRowIdCounterValue_;
+
+  std::shared_ptr<std::atomic_int64_t> rowIdPool_;
+};
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfConversion.cpp b/velox/experimental/cudf/exec/CudfConversion.cpp
index 903b01fe814c..9a366eb6f4f4 100644
--- a/velox/experimental/cudf/exec/CudfConversion.cpp
+++ b/velox/experimental/cudf/exec/CudfConversion.cpp
@@ -13,8 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include "velox/experimental/cudf/exec/CudfConversion.h"
 #include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
 #include "velox/experimental/cudf/exec/Utilities.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 #include "velox/experimental/cudf/vector/CudfVector.h"
@@ -23,7 +25,7 @@
 #include "velox/exec/Operator.h"
 #include "velox/vector/ComplexVector.h"
 
-#include <cudf/concatenate.hpp>
+#include <cudf/copying.hpp>
 #include <cudf/table/table.hpp>
 #include <cudf/utilities/default_stream.hpp>
 
@@ -36,6 +38,9 @@ RowVectorPtr mergeRowVectors(
     const std::vector<RowVectorPtr>& results,
     velox::memory::MemoryPool* pool) {
   VELOX_NVTX_FUNC_RANGE();
+  if (results.size() == 1) {
+    return results[0];
+  }
   vector_size_t totalCount = 0;
   for (const auto& result : results) {
     totalCount += result->size();
@@ -172,6 +177,11 @@ CudfToVelox::CudfToVelox(
           operatorId,
           fmt::format("[{}]", planNodeId)) {}
 
+bool CudfToVelox::isPassthroughMode() const {
+  return operatorCtx_->driverCtx()->queryConfig().get<bool>(
+      kPassthroughMode, true);
+}
+
 void CudfToVelox::addInput(RowVectorPtr input) {
   // Accumulate inputs
   if (input->size() > 0) {
@@ -181,6 +191,14 @@ void CudfToVelox::addInput(RowVectorPtr input) {
   }
 }
 
+std::optional<uint64_t> CudfToVelox::averageRowSize() {
+  if (!averageRowSize_) {
+    averageRowSize_ =
+        inputs_.front()->estimateFlatSize() / inputs_.front()->size();
+  }
+  return averageRowSize_;
+}
+
 RowVectorPtr CudfToVelox::getOutput() {
   VELOX_NVTX_OPERATOR_FUNC_RANGE();
   if (finished_ || inputs_.empty()) {
@@ -188,16 +206,92 @@ RowVectorPtr CudfToVelox::getOutput() {
     return nullptr;
   }
 
+  // Get the target batch size
+  const auto targetBatchSize = outputBatchRows(averageRowSize());
   auto stream = inputs_.front()->stream();
-  std::unique_ptr<cudf::table> tbl = inputs_.front()->release();
-  inputs_.pop_front();
 
-  VELOX_CHECK_NOT_NULL(tbl);
-  if (tbl->num_rows() == 0) {
+  // Process single input directly in these cases:
+  // 1. In passthrough mode
+  // 2. If we only have one input and it's smaller than or equal to the target
+  // batch size
+  if (isPassthroughMode() ||
+      (inputs_.size() == 1 && inputs_.front()->size() <= targetBatchSize)) {
+    std::unique_ptr<cudf::table> tbl = inputs_.front()->release();
+    inputs_.pop_front();
+
+    VELOX_CHECK_NOT_NULL(tbl);
+    if (tbl->num_rows() == 0) {
+      finished_ = noMoreInput_ && inputs_.empty();
+      return nullptr;
+    }
+    RowVectorPtr output =
+        with_arrow::toVeloxColumn(tbl->view(), pool(), "", stream);
+    stream.synchronize();
+    finished_ = noMoreInput_ && inputs_.empty();
+    output->setType(outputType_);
+    return output;
+  }
+
+  // Calculate how many tables we need to concatenate to reach the target batch
+  // size and collect them in a vector
+  std::vector<CudfVectorPtr> selectedInputs;
+  vector_size_t totalSize = 0;
+
+  while (!inputs_.empty() && totalSize < targetBatchSize) {
+    auto& input = inputs_.front();
+    if (totalSize + input->size() <= targetBatchSize) {
+      totalSize += input->size();
+      selectedInputs.push_back(std::move(input));
+      inputs_.pop_front();
+    } else {
+      // If the next input would exceed targetBatchSize,
+      // we need to split it and only take what we need
+      auto cudfTableView = input->getTableView();
+      auto partitions = std::vector<cudf::size_type>{
+          static_cast<cudf::size_type>(targetBatchSize - totalSize)};
+      auto tableSplits = cudf::split(cudfTableView, partitions);
+
+      // Create new CudfVector from the first part
+      auto firstPart = std::make_unique<cudf::table>(tableSplits[0], stream);
+      auto firstPartSize = firstPart->num_rows();
+      auto firstPartVector = std::make_shared<CudfVector>(
+          pool(), input->type(), firstPartSize, std::move(firstPart), stream);
+
+      // Create new CudfVector from the second part
+      auto secondPart = std::make_unique<cudf::table>(tableSplits[1], stream);
+      auto secondPartSize = secondPart->num_rows();
+      auto secondPartVector = std::make_shared<CudfVector>(
+          pool(), input->type(), secondPartSize, std::move(secondPart), stream);
+
+      // Replace the original input with the second part
+      input = std::move(secondPartVector);
+
+      // Add the first part to selectedInputs
+      selectedInputs.push_back(std::move(firstPartVector));
+      totalSize += firstPartSize;
+      break;
+    }
+  }
+
+  finished_ = noMoreInput_ && inputs_.empty();
+
+  // If we have no inputs to process, return nullptr
+  if (selectedInputs.empty()) {
+    return nullptr;
+  }
+
+  // Concatenate the selected tables on the GPU
+  auto resultTable = getConcatenatedTable(selectedInputs, outputType_, stream);
+
+  // Convert the concatenated table to a RowVector
+  const auto size = resultTable->num_rows();
+  VELOX_CHECK_NOT_NULL(resultTable);
+  if (size == 0) {
     return nullptr;
   }
+
   RowVectorPtr output =
-      with_arrow::toVeloxColumn(tbl->view(), pool(), "", stream);
+      with_arrow::toVeloxColumn(resultTable->view(), pool(), "", stream);
   stream.synchronize();
   finished_ = noMoreInput_ && inputs_.empty();
   output->setType(outputType_);
diff --git a/velox/experimental/cudf/exec/CudfConversion.h b/velox/experimental/cudf/exec/CudfConversion.h
index 16ca33d786cb..879f21d512ba 100644
--- a/velox/experimental/cudf/exec/CudfConversion.h
+++ b/velox/experimental/cudf/exec/CudfConversion.h
@@ -23,8 +23,6 @@
 #include "velox/exec/Operator.h"
 #include "velox/vector/ComplexVector.h"
 
-#include <cudf/table/table.hpp>
-
 #include <deque>
 #include <memory>
 #include <vector>
@@ -68,6 +66,9 @@ class CudfFromVelox : public exec::Operator, public NvtxHelper {
 
 class CudfToVelox : public exec::Operator, public NvtxHelper {
  public:
+  static constexpr const char* kPassthroughMode =
+      "velox.cudf.to_velox.passthrough_mode";
+
   CudfToVelox(
       int32_t operatorId,
       RowTypePtr outputType,
@@ -93,6 +94,9 @@ class CudfToVelox : public exec::Operator, public NvtxHelper {
   void close() override;
 
  private:
+  bool isPassthroughMode() const;
+  std::optional<uint64_t> averageRowSize();
+  std::optional<uint64_t> averageRowSize_;
   std::deque<CudfVectorPtr> inputs_;
   bool finished_ = false;
 };
diff --git a/velox/experimental/cudf/exec/CudfFilterProject.cpp b/velox/experimental/cudf/exec/CudfFilterProject.cpp
new file mode 100644
index 000000000000..06e3d1266f45
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfFilterProject.cpp
@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/CudfFilterProject.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/common/memory/Memory.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/FieldReference.h"
+
+#include <cudf/aggregation.hpp>
+#include <cudf/reduction.hpp>
+#include <cudf/stream_compaction.hpp>
+#include <cudf/unary.hpp>
+
+#include <unordered_map>
+
+namespace facebook::velox::cudf_velox {
+
+namespace {
+
+void debugPrintTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    int indent = 0) {
+  std::cout << std::string(indent, ' ') << expr->name() << std::endl;
+  for (auto& input : expr->inputs()) {
+    debugPrintTree(input, indent + 2);
+  }
+}
+
+bool checkAddIdentityProjection(
+    const core::TypedExprPtr& projection,
+    const RowTypePtr& inputType,
+    column_index_t outputChannel,
+    std::vector<exec::IdentityProjection>& identityProjections) {
+  if (auto field = core::TypedExprs::asFieldAccess(projection)) {
+    const auto& inputs = field->inputs();
+    if (inputs.empty() ||
+        (inputs.size() == 1 &&
+         dynamic_cast<const core::InputTypedExpr*>(inputs[0].get()))) {
+      const auto inputChannel = inputType->getChildIdx(field->name());
+      identityProjections.emplace_back(inputChannel, outputChannel);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Split stats to attrbitute cardinality reduction to the Filter node.
+std::vector<exec::OperatorStats> splitStats(
+    const exec::OperatorStats& combinedStats,
+    const core::PlanNodeId& filterNodeId) {
+  exec::OperatorStats filterStats;
+
+  filterStats.operatorId = combinedStats.operatorId;
+  filterStats.pipelineId = combinedStats.pipelineId;
+  filterStats.planNodeId = filterNodeId;
+  filterStats.operatorType = combinedStats.operatorType;
+  filterStats.numDrivers = combinedStats.numDrivers;
+
+  filterStats.inputBytes = combinedStats.inputBytes;
+  filterStats.inputPositions = combinedStats.inputPositions;
+  filterStats.inputVectors = combinedStats.inputVectors;
+
+  // Estimate Filter's output bytes based on cardinality change.
+  const double filterRate = combinedStats.inputPositions > 0
+      ? (combinedStats.outputPositions * 1.0 / combinedStats.inputPositions)
+      : 1.0;
+
+  filterStats.outputBytes = (uint64_t)(filterStats.inputBytes * filterRate);
+  filterStats.outputPositions = combinedStats.outputPositions;
+  filterStats.outputVectors = combinedStats.outputVectors;
+
+  auto projectStats = combinedStats;
+  projectStats.inputBytes = filterStats.outputBytes;
+  projectStats.inputPositions = filterStats.outputPositions;
+  projectStats.inputVectors = filterStats.outputVectors;
+
+  return {std::move(projectStats), std::move(filterStats)};
+}
+
+} // namespace
+
+bool canBeEvaluatedByCudf(
+    const std::vector<core::TypedExprPtr>& exprs,
+    core::QueryCtx* queryCtx) {
+  if (exprs.empty()) {
+    return true;
+  }
+
+  auto precompilePool = memory::memoryManager()->addLeafPool(
+      "cudf-expr-precompile", /*threadSafe*/ false);
+  core::ExecCtx precompileCtx(precompilePool.get(), queryCtx);
+
+  bool lazyDereference = false;
+  std::vector<core::TypedExprPtr> exprsCopy = exprs;
+  std::unique_ptr<exec::ExprSet> exprSet = exec::makeExprSetFromFlag(
+      std::move(exprsCopy), &precompileCtx, lazyDereference);
+
+  for (const auto& e : exprSet->exprs()) {
+    if (!canBeEvaluatedByCudf(e)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+CudfFilterProject::CudfFilterProject(
+    int32_t operatorId,
+    velox::exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::FilterNode>& filter,
+    const std::shared_ptr<const core::ProjectNode>& project)
+    : Operator(
+          driverCtx,
+          project ? project->outputType() : filter->outputType(),
+          operatorId,
+          project ? project->id() : filter->id(),
+          "CudfFilterProject"),
+      NvtxHelper(
+          nvtx3::rgb{220, 20, 60}, // Crimson
+          operatorId,
+          fmt::format("[{}]", project ? project->id() : filter->id())),
+      hasFilter_(filter != nullptr),
+      project_(project),
+      filter_(filter) {
+  if (filter_ != nullptr && project_ != nullptr) {
+    folly::Synchronized<exec::OperatorStats>& opStats = Operator::stats();
+    opStats.withWLock([&](auto& stats) {
+      stats.setStatSplitter(
+          [filterId = filter_->id()](const auto& combinedStats) {
+            return splitStats(combinedStats, filterId);
+          });
+    });
+  }
+}
+
+void CudfFilterProject::initialize() {
+  Operator::initialize();
+
+  std::vector<core::TypedExprPtr> allExprs;
+  if (hasFilter_) {
+    VELOX_CHECK_NOT_NULL(filter_);
+    allExprs.push_back(filter_->filter());
+  }
+
+  if (project_) {
+    const auto& inputType = project_->sources()[0]->outputType();
+
+    for (column_index_t i = 0; i < project_->projections().size(); i++) {
+      auto& projection = project_->projections()[i];
+      bool identityProjection = checkAddIdentityProjection(
+          projection, inputType, i, identityProjections_);
+      if (!identityProjection) {
+        allExprs.push_back(projection);
+        resultProjections_.emplace_back(allExprs.size() - 1, i);
+      }
+    }
+  } else {
+    for (column_index_t i = 0; i < outputType_->size(); ++i) {
+      identityProjections_.emplace_back(i, i);
+    }
+    isIdentityProjection_ = true;
+  }
+
+  auto lazyDereference =
+      (dynamic_cast<const core::LazyDereferenceNode*>(project_.get()) !=
+       nullptr);
+  VELOX_CHECK(!(lazyDereference && filter_));
+  auto expr = exec::makeExprSetFromFlag(
+      std::move(allExprs), operatorCtx_->execCtx(), lazyDereference);
+
+  const auto inputType = project_ ? project_->sources()[0]->outputType()
+                                  : filter_->sources()[0]->outputType();
+
+  // convert to AST
+  if (CudfConfig::getInstance().debugEnabled) {
+    int i = 0;
+    for (const auto& expr : expr->exprs()) {
+      LOG(INFO) << "expr[" << i++ << "] " << expr->toString() << std::endl;
+      debugPrintTree(expr);
+      ++i;
+    }
+  }
+  if (hasFilter_) {
+    // First expr is Filter, rest are Project
+    filterEvaluator_ = createCudfExpression(expr->exprs()[0], inputType);
+    std::transform(
+        expr->exprs().begin() + 1,
+        expr->exprs().end(),
+        std::back_inserter(projectEvaluators_),
+        [inputType](const auto& expr) {
+          return createCudfExpression(expr, inputType);
+        });
+  } else {
+    std::transform(
+        expr->exprs().begin(),
+        expr->exprs().end(),
+        std::back_inserter(projectEvaluators_),
+        [inputType](const auto& expr) {
+          return createCudfExpression(expr, inputType);
+        });
+  }
+
+  filter_.reset();
+  project_.reset();
+}
+
+void CudfFilterProject::addInput(RowVectorPtr input) {
+  input_ = std::move(input);
+}
+
+RowVectorPtr CudfFilterProject::getOutput() {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+
+  if (allInputProcessed()) {
+    return nullptr;
+  }
+  if (input_->size() == 0) {
+    input_.reset();
+    return nullptr;
+  }
+
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input_);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+  auto stream = cudfInput->stream();
+  auto inputTableColumns = cudfInput->release()->release();
+
+  if (hasFilter_) {
+    filter(inputTableColumns, stream);
+  }
+  auto outputColumns = project(inputTableColumns, stream);
+
+  auto outputTable = std::make_unique<cudf::table>(std::move(outputColumns));
+  stream.synchronize();
+  auto const numColumns = outputTable->num_columns();
+  auto const size = outputTable->num_rows();
+  if (CudfConfig::getInstance().debugEnabled) {
+    VLOG(1) << "cudfProject Output: " << size << " rows, " << numColumns
+            << " columns " << std::endl;
+  }
+
+  auto cudfOutput = std::make_shared<CudfVector>(
+      input_->pool(), outputType_, size, std::move(outputTable), stream);
+  input_.reset();
+  if (numColumns == 0 or size == 0) {
+    return nullptr;
+  }
+  return cudfOutput;
+}
+
+void CudfFilterProject::filter(
+    std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+    rmm::cuda_stream_view stream) {
+  // Evaluate the Filter
+  auto filterColumn = filterEvaluator_->eval(
+      inputTableColumns, stream, cudf::get_current_device_resource_ref(), true);
+  auto filterColumnView = asView(filterColumn);
+  bool shouldApplyFilter = [&]() {
+    if (filterColumnView.has_nulls()) {
+      return true;
+    }
+    // check if all values in filterColumnView are true
+    auto isAllTrue = cudf::reduce(
+        filterColumnView,
+        *cudf::make_all_aggregation<cudf::reduce_aggregation>(),
+        cudf::data_type(cudf::type_id::BOOL8),
+        stream,
+        cudf::get_current_device_resource_ref());
+    using ScalarType = cudf::scalar_type_t<bool>;
+    auto result = static_cast<ScalarType*>(isAllTrue.get());
+    // If filter is not all true, apply the filter
+    return !(result->is_valid(stream) && result->value(stream));
+  }();
+  if (shouldApplyFilter) {
+    auto filterTable =
+        std::make_unique<cudf::table>(std::move(inputTableColumns));
+    auto filteredTable =
+        cudf::apply_boolean_mask(*filterTable, filterColumnView, stream);
+    inputTableColumns = filteredTable->release();
+  }
+}
+
+std::vector<std::unique_ptr<cudf::column>> CudfFilterProject::project(
+    std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+    rmm::cuda_stream_view stream) {
+  std::vector<ColumnOrView> columns;
+  for (auto& projectEvaluator : projectEvaluators_) {
+    columns.push_back(projectEvaluator->eval(
+        inputTableColumns,
+        stream,
+        cudf::get_current_device_resource_ref(),
+        true));
+  }
+
+  // Rearrange columns to match outputType_
+  std::vector<std::unique_ptr<cudf::column>> outputColumns(outputType_->size());
+  // computed resultProjections
+  for (int i = 0; i < resultProjections_.size(); i++) {
+    auto& columnOrView = columns[i];
+    if (std::holds_alternative<std::unique_ptr<cudf::column>>(columnOrView)) {
+      // Move the owned column
+      outputColumns[resultProjections_[i].outputChannel] =
+          std::move(std::get<std::unique_ptr<cudf::column>>(columnOrView));
+    } else {
+      // Materialize the column_view into an owned column
+      auto view = std::get<cudf::column_view>(columnOrView);
+      outputColumns[resultProjections_[i].outputChannel] =
+          std::make_unique<cudf::column>(
+              view, stream, cudf::get_current_device_resource_ref());
+    }
+  }
+
+  // Count occurrences of each inputChannel, and move columns if they occur only
+  // once
+  std::unordered_map<column_index_t, int> inputChannelCount;
+  for (const auto& identity : identityProjections_) {
+    inputChannelCount[identity.inputChannel]++;
+  }
+
+  // identityProjections (input to output copy)
+  for (auto const& identity : identityProjections_) {
+    VELOX_CHECK_NOT_NULL(inputTableColumns[identity.inputChannel]);
+    if (inputChannelCount[identity.inputChannel] == 1) {
+      // Move the column if it occurs only once
+      outputColumns[identity.outputChannel] =
+          std::move(inputTableColumns[identity.inputChannel]);
+    } else {
+      // Otherwise, copy the column and decrement the count
+      outputColumns[identity.outputChannel] = std::make_unique<cudf::column>(
+          *inputTableColumns[identity.inputChannel],
+          stream,
+          cudf::get_current_device_resource_ref());
+    }
+    VELOX_CHECK_GT(inputChannelCount[identity.inputChannel], 0);
+    inputChannelCount[identity.inputChannel]--;
+  }
+
+  return outputColumns;
+}
+
+bool CudfFilterProject::allInputProcessed() {
+  return !input_;
+}
+
+bool CudfFilterProject::isFinished() {
+  return noMoreInput_ && allInputProcessed();
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfFilterProject.h b/velox/experimental/cudf/exec/CudfFilterProject.h
new file mode 100644
index 000000000000..32a8a3b1e7ed
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfFilterProject.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/core/Expressions.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/FilterProject.h"
+#include "velox/exec/Operator.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::cudf_velox {
+
+// TODO: Does not support Filter yet.
+class CudfFilterProject : public exec::Operator, public NvtxHelper {
+ public:
+  CudfFilterProject(
+      int32_t operatorId,
+      velox::exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::FilterNode>& filter,
+      const std::shared_ptr<const core::ProjectNode>& project);
+
+  // Some is copied from operator FilterProject.
+  void initialize() override;
+
+  bool needsInput() const override {
+    return !input_;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  void filter(
+      std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+      rmm::cuda_stream_view stream);
+
+  std::vector<std::unique_ptr<cudf::column>> project(
+      std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+      rmm::cuda_stream_view stream);
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+  void close() override {
+    Operator::close();
+    projectEvaluators_.clear();
+    filterEvaluator_.reset();
+  }
+
+ private:
+  bool allInputProcessed();
+
+  // If true exprs_[0] is a filter and the other expressions are projections
+  const bool hasFilter_{false};
+
+  // Cached filter and project node for lazy initialization. After
+  // initialization, they will be reset, and initialized_ will be set to true.
+  std::shared_ptr<const core::ProjectNode> project_;
+  std::shared_ptr<const core::FilterNode> filter_;
+
+  std::vector<CudfExpressionPtr> projectEvaluators_;
+  CudfExpressionPtr filterEvaluator_;
+
+  std::vector<velox::exec::IdentityProjection> resultProjections_;
+  std::vector<velox::exec::IdentityProjection> identityProjections_;
+};
+
+bool canBeEvaluatedByCudf(
+    const std::vector<core::TypedExprPtr>& exprs,
+    core::QueryCtx* queryCtx);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfHashAggregation.cpp b/velox/experimental/cudf/exec/CudfHashAggregation.cpp
index dfc03a1b2580..d0d49ff6c5e9 100644
--- a/velox/experimental/cudf/exec/CudfHashAggregation.cpp
+++ b/velox/experimental/cudf/exec/CudfHashAggregation.cpp
@@ -14,11 +14,13 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfConfig.h"
 #include "velox/experimental/cudf/exec/CudfHashAggregation.h"
 #include "velox/experimental/cudf/exec/Utilities.h"
 #include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 
 #include "velox/exec/Aggregate.h"
+#include "velox/exec/AggregateFunctionRegistry.h"
 #include "velox/exec/PrefixSort.h"
 #include "velox/exec/Task.h"
 #include "velox/expression/Expr.h"
@@ -40,13 +42,15 @@ using namespace facebook::velox;
         core::AggregationNode::Step step,                                     \
         uint32_t inputIndex,                                                  \
         VectorPtr constant,                                                   \
-        bool is_global)                                                       \
+        bool is_global,                                                       \
+        const TypePtr& resultType)                                            \
         : Aggregator(                                                         \
               step,                                                           \
               cudf::aggregation::KIND,                                        \
               inputIndex,                                                     \
               constant,                                                       \
-              is_global) {}                                                   \
+              is_global,                                                      \
+              resultType) {}                                                  \
                                                                               \
     void addGroupbyRequest(                                                   \
         cudf::table_view const& tbl,                                          \
@@ -64,7 +68,13 @@ using namespace facebook::velox;
     std::unique_ptr<cudf::column> makeOutputColumn(                           \
         std::vector<cudf::groupby::aggregation_result>& results,              \
         rmm::cuda_stream_view stream) override {                              \
-      return std::move(results[output_idx].results[0]);                       \
+      auto col = std::move(results[output_idx].results[0]);                   \
+      const auto cudfType =                                                   \
+          cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType));         \
+      if (col->type() != cudfType) {                                          \
+        col = cudf::cast(*col, cudfType, stream);                             \
+      }                                                                       \
+      return col;                                                             \
     }                                                                         \
                                                                               \
     std::unique_ptr<cudf::column> doReduce(                                   \
@@ -93,13 +103,15 @@ struct CountAggregator : cudf_velox::CudfHashAggregation::Aggregator {
       core::AggregationNode::Step step,
       uint32_t inputIndex,
       VectorPtr constant,
-      bool isGlobal)
+      bool isGlobal,
+      const TypePtr& resultType)
       : Aggregator(
             step,
             cudf::aggregation::COUNT_VALID,
             inputIndex,
             constant,
-            isGlobal) {}
+            isGlobal,
+            resultType) {}
 
   void addGroupbyRequest(
       cudf::table_view const& tbl,
@@ -139,6 +151,7 @@ struct CountAggregator : cudf_velox::CudfHashAggregation::Aggregator {
       auto const cudfOutputType = cudf::data_type(cudf::type_id::INT64);
       auto const resultScalar = cudf::reduce(
           input.column(inputIndex), *aggRequest, cudfOutputType, stream);
+      resultScalar->set_valid_async(true, stream);
       return cudf::make_column_from_scalar(*resultScalar, 1, stream);
     }
     return nullptr;
@@ -149,8 +162,10 @@ struct CountAggregator : cudf_velox::CudfHashAggregation::Aggregator {
       rmm::cuda_stream_view stream) override {
     // cudf produces int32 for count(0) but velox expects int64
     auto col = std::move(results[outputIdx_].results[0]);
-    if (col->type() == cudf::data_type(cudf::type_id::INT32)) {
-      col = cudf::cast(*col, cudf::data_type(cudf::type_id::INT64), stream);
+    const auto cudfOutputType =
+        cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType));
+    if (col->type() != cudfOutputType) {
+      col = cudf::cast(*col, cudfOutputType, stream);
     }
     return col;
   }
@@ -164,13 +179,15 @@ struct MeanAggregator : cudf_velox::CudfHashAggregation::Aggregator {
       core::AggregationNode::Step step,
       uint32_t inputIndex,
       VectorPtr constant,
-      bool isGlobal)
+      bool isGlobal,
+      const TypePtr& resultType)
       : Aggregator(
             step,
             cudf::aggregation::MEAN,
             inputIndex,
             constant,
-            isGlobal) {}
+            isGlobal,
+            resultType) {}
 
   void addGroupbyRequest(
       cudf::table_view const& tbl,
@@ -223,6 +240,7 @@ struct MeanAggregator : cudf_velox::CudfHashAggregation::Aggregator {
   std::unique_ptr<cudf::column> makeOutputColumn(
       std::vector<cudf::groupby::aggregation_result>& results,
       rmm::cuda_stream_view stream) override {
+    const auto& outputType = asRowType(resultType);
     switch (step) {
       case core::AggregationNode::Step::kSingle:
         return std::move(results[meanIdx_].results[0]);
@@ -231,13 +249,20 @@ struct MeanAggregator : cudf_velox::CudfHashAggregation::Aggregator {
         auto count = std::move(results[sumIdx_].results[1]);
 
         auto const size = sum->size();
-
-        auto countInt64 =
-            cudf::cast(*count, cudf::data_type(cudf::type_id::INT64), stream);
+        auto const cudfSumType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(0)));
+        auto const cudfCountType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(1)));
+        if (sum->type() != cudf::data_type(cudfSumType)) {
+          sum = cudf::cast(*sum, cudf::data_type(cudfSumType), stream);
+        }
+        if (count->type() != cudf::data_type(cudfCountType)) {
+          count = cudf::cast(*count, cudf::data_type(cudfCountType), stream);
+        }
 
         auto children = std::vector<std::unique_ptr<cudf::column>>();
         children.push_back(std::move(sum));
-        children.push_back(std::move(countInt64));
+        children.push_back(std::move(count));
 
         // TODO: Handle nulls. This can happen if all values are null in a
         // group.
@@ -260,6 +285,16 @@ struct MeanAggregator : cudf_velox::CudfHashAggregation::Aggregator {
         auto count = std::move(results[countIdx_].results[0]);
 
         auto size = sum->size();
+        auto const cudfSumType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(0)));
+        auto const cudfCountType = cudf::data_type(
+            cudf_velox::veloxToCudfTypeId(outputType->childAt(1)));
+        if (sum->type() != cudf::data_type(cudfSumType)) {
+          sum = cudf::cast(*sum, cudf::data_type(cudfSumType), stream);
+        }
+        if (count->type() != cudf::data_type(cudfCountType)) {
+          count = cudf::cast(*count, cudf::data_type(cudfCountType), stream);
+        }
 
         auto children = std::vector<std::unique_ptr<cudf::column>>();
         children.push_back(std::move(sum));
@@ -280,9 +315,7 @@ struct MeanAggregator : cudf_velox::CudfHashAggregation::Aggregator {
             *sum,
             *count,
             cudf::binary_operator::DIV,
-            // TODO: Change the output type to be dependent on the input type
-            // like in the cudf groupby implementation.
-            cudf::data_type(cudf::type_id::FLOAT64),
+            cudf::data_type(cudf_velox::veloxToCudfTypeId(resultType)),
             stream);
         return avg;
       }
@@ -391,39 +424,84 @@ std::unique_ptr<cudf_velox::CudfHashAggregation::Aggregator> createAggregator(
     std::string const& kind,
     uint32_t inputIndex,
     VectorPtr constant,
-    bool isGlobal) {
-  // Companion function may be count_merge_extract or count_partial or others,
-  // so use this to map
-  if (kind.rfind("sum", 0) == 0) {
+    bool isGlobal,
+    const TypePtr& resultType) {
+  auto prefix = cudf_velox::CudfConfig::getInstance().functionNamePrefix;
+  if (kind.rfind(prefix + "sum", 0) == 0) {
     return std::make_unique<SumAggregator>(
-        step, inputIndex, constant, isGlobal);
-  } else if (kind.rfind("count", 0) == 0) {
+        step, inputIndex, constant, isGlobal, resultType);
+  } else if (kind.rfind(prefix + "count", 0) == 0) {
     return std::make_unique<CountAggregator>(
-        step, inputIndex, constant, isGlobal);
-  } else if (kind.rfind("min", 0) == 0) {
+        step, inputIndex, constant, isGlobal, resultType);
+  } else if (kind.rfind(prefix + "min", 0) == 0) {
     return std::make_unique<MinAggregator>(
-        step, inputIndex, constant, isGlobal);
-  } else if (kind.rfind("max", 0) == 0) {
+        step, inputIndex, constant, isGlobal, resultType);
+  } else if (kind.rfind(prefix + "max", 0) == 0) {
     return std::make_unique<MaxAggregator>(
-        step, inputIndex, constant, isGlobal);
-  } else if (kind.rfind("avg", 0) == 0) {
+        step, inputIndex, constant, isGlobal, resultType);
+  } else if (kind.rfind(prefix + "avg", 0) == 0) {
     return std::make_unique<MeanAggregator>(
-        step, inputIndex, constant, isGlobal);
+        step, inputIndex, constant, isGlobal, resultType);
   } else {
     VELOX_NYI("Aggregation not yet supported");
   }
 }
 
+static const std::unordered_map<std::string, core::AggregationNode::Step>
+    companionStep = {
+        {"_partial", core::AggregationNode::Step::kPartial},
+        {"_merge", core::AggregationNode::Step::kIntermediate},
+        {"_merge_extract", core::AggregationNode::Step::kFinal}};
+
+/// \brief Convert companion function to step for the aggregation function
+///
+/// Companion functions are functions that are registered in velox along with
+/// their main aggregation functions. These are designed to always function
+/// with a fixed `step`. This is to allow spark style planNodes where `step` is
+/// the property of the aggregation function rather than the planNode.
+/// Companion functions allow us to override the planNode's step and use
+/// aggregations of different steps in the same planNode
+core::AggregationNode::Step getCompanionStep(
+    std::string const& kind,
+    core::AggregationNode::Step step) {
+  for (const auto& [k, v] : companionStep) {
+    if (kind.ends_with(k)) {
+      step = v;
+      break;
+    }
+  }
+  return step;
+}
+
+std::string getOriginalName(std::string const& kind) {
+  for (const auto& [k, v] : companionStep) {
+    if (kind.ends_with(k)) {
+      return kind.substr(0, kind.length() - k.length());
+    }
+  }
+  return kind;
+}
+
+bool hasFinalAggs(
+    std::vector<core::AggregationNode::Aggregate> const& aggregates) {
+  return std::any_of(aggregates.begin(), aggregates.end(), [](auto const& agg) {
+    return agg.call->name().ends_with("_merge_extract");
+  });
+}
+
 auto toAggregators(
     core::AggregationNode const& aggregationNode,
     exec::OperatorCtx const& operatorCtx) {
   auto const step = aggregationNode.step();
   bool const isGlobal = aggregationNode.groupingKeys().empty();
   auto const& inputRowSchema = aggregationNode.sources()[0]->outputType();
+  const auto numKeys = aggregationNode.groupingKeys().size();
+  const auto outputType = aggregationNode.outputType();
 
   std::vector<std::unique_ptr<cudf_velox::CudfHashAggregation::Aggregator>>
       aggregators;
-  for (auto const& aggregate : aggregationNode.aggregates()) {
+  for (auto i = 0; i < aggregationNode.aggregates().size(); ++i) {
+    auto const& aggregate = aggregationNode.aggregates()[i];
     std::vector<column_index_t> aggInputs;
     std::vector<VectorPtr> aggConstants;
     for (auto const& arg : aggregate.call->inputs()) {
@@ -444,7 +522,10 @@ auto toAggregators(
     // be multiple inputs to an aggregate.
     // We're postponing properly supporting this for now because the currently
     // supported aggregation functions in cudf_velox don't use it.
-    VELOX_CHECK(aggInputs.size() == 1);
+    VELOX_CHECK(aggInputs.size() <= 1);
+    if (aggInputs.empty()) {
+      aggInputs.push_back(0);
+    }
 
     if (aggregate.distinct) {
       VELOX_NYI("De-dup before aggregation is not yet supported");
@@ -453,8 +534,14 @@ auto toAggregators(
     auto const kind = aggregate.call->name();
     auto const inputIndex = aggInputs[0];
     auto const constant = aggConstants.empty() ? nullptr : aggConstants[0];
-    aggregators.push_back(
-        createAggregator(step, kind, inputIndex, constant, isGlobal));
+    auto const companionStep = getCompanionStep(kind, step);
+    const auto originalName = getOriginalName(kind);
+    const auto resultType = exec::isPartialOutput(companionStep)
+        ? exec::resolveIntermediateType(originalName, aggregate.rawInputTypes)
+        : outputType->childAt(numKeys + i);
+
+    aggregators.push_back(createAggregator(
+        companionStep, kind, inputIndex, constant, isGlobal, resultType));
   }
   return aggregators;
 }
@@ -475,8 +562,17 @@ auto toIntermediateAggregators(
     auto const inputIndex = aggregationNode.groupingKeys().size() + i;
     auto const kind = aggregate.call->name();
     auto const constant = nullptr;
-    aggregators.push_back(
-        createAggregator(step, kind, inputIndex, constant, isGlobal));
+    const auto originalName = getOriginalName(kind);
+    auto const companionStep = getCompanionStep(kind, step);
+    if (exec::isPartialOutput(companionStep)) {
+      const auto resultType =
+          exec::resolveIntermediateType(originalName, aggregate.rawInputTypes);
+      aggregators.push_back(createAggregator(
+          step, kind, inputIndex, constant, isGlobal, resultType));
+    } else {
+      // Final step aggregator will not use the intermediate aggregator.
+      aggregators.push_back(nullptr);
+    }
   }
   return aggregators;
 }
@@ -505,7 +601,9 @@ CudfHashAggregation::CudfHashAggregation(
           operatorId,
           fmt::format("[{}]", aggregationNode->id())),
       aggregationNode_(aggregationNode),
-      isPartialOutput_(exec::isPartialOutput(aggregationNode->step())),
+      isPartialOutput_(
+          exec::isPartialOutput(aggregationNode->step()) &&
+          !hasFinalAggs(aggregationNode->aggregates())),
       isGlobal_(aggregationNode->groupingKeys().empty()),
       isDistinct_(!isGlobal_ && aggregationNode->aggregates().empty()),
       maxPartialAggregationMemoryUsage_(
@@ -514,7 +612,7 @@ CudfHashAggregation::CudfHashAggregation(
 void CudfHashAggregation::initialize() {
   Operator::initialize();
 
-  auto const& inputType = aggregationNode_->sources()[0]->outputType();
+  inputType_ = aggregationNode_->sources()[0]->outputType();
   ignoreNullKeys_ = aggregationNode_->ignoreNullKeys();
   setupGroupingKeyChannelProjections(
       groupingKeyInputChannels_, groupingKeyOutputChannels_);
@@ -719,13 +817,13 @@ CudfVectorPtr CudfHashAggregation::doGroupByAggregation(
   // make a cudf table out of columns
   auto resultTable = std::make_unique<cudf::table>(std::move(resultColumns));
 
+  auto numRows = resultTable->num_rows();
+
   // velox expects nullptr instead of a table with 0 rows
-  if (resultTable->num_rows() == 0) {
+  if (numRows == 0) {
     return nullptr;
   }
 
-  auto numRows = resultTable->num_rows();
-
   return std::make_shared<cudf_velox::CudfVector>(
       pool(), outputType_, numRows, std::move(resultTable), stream);
 }
@@ -736,8 +834,9 @@ CudfVectorPtr CudfHashAggregation::doGlobalAggregation(
   std::vector<std::unique_ptr<cudf::column>> resultColumns;
   resultColumns.reserve(aggregators_.size());
   for (auto i = 0; i < aggregators_.size(); i++) {
-    resultColumns.push_back(aggregators_[i]->doReduce(
-        tbl->view(), outputType_->childAt(i), stream));
+    resultColumns.push_back(
+        aggregators_[i]->doReduce(
+            tbl->view(), outputType_->childAt(i), stream));
   }
 
   return std::make_shared<cudf_velox::CudfVector>(
@@ -762,6 +861,11 @@ CudfVectorPtr CudfHashAggregation::getDistinctKeys(
 
   auto numRows = result->num_rows();
 
+  // velox expects nullptr instead of a table with 0 rows
+  if (numRows == 0) {
+    return nullptr;
+  }
+
   return std::make_shared<cudf_velox::CudfVector>(
       pool(), outputType_, numRows, std::move(result), stream);
 }
@@ -788,7 +892,7 @@ CudfVectorPtr CudfHashAggregation::releaseAndResetPartialOutput() {
 RowVectorPtr CudfHashAggregation::getOutput() {
   VELOX_NVTX_OPERATOR_FUNC_RANGE();
 
-  // Handle partial groupby.
+  // Handle partial groupby and distinct.
   if (isPartialOutput_ && !isGlobal_) {
     if (partialOutput_ &&
         partialOutput_->estimateFlatSize() >
@@ -817,12 +921,13 @@ RowVectorPtr CudfHashAggregation::getOutput() {
     return nullptr;
   }
 
-  if (inputs_.empty()) {
+  if (inputs_.empty() && !noMoreInput_) {
     return nullptr;
   }
 
   auto stream = cudfGlobalStreamPool().get_stream();
-  auto tbl = getConcatenatedTable(inputs_, stream);
+
+  auto tbl = getConcatenatedTable(inputs_, inputType_, stream);
 
   // Release input data after synchronizing.
   stream.synchronize();
diff --git a/velox/experimental/cudf/exec/CudfHashAggregation.h b/velox/experimental/cudf/exec/CudfHashAggregation.h
index 3b828e18e3cb..5b31de5a2990 100644
--- a/velox/experimental/cudf/exec/CudfHashAggregation.h
+++ b/velox/experimental/cudf/exec/CudfHashAggregation.h
@@ -32,6 +32,7 @@ class CudfHashAggregation : public exec::Operator, public NvtxHelper {
     cudf::aggregation::Kind kind;
     uint32_t inputIndex;
     VectorPtr constant;
+    TypePtr resultType;
 
     virtual void addGroupbyRequest(
         cudf::table_view const& tbl,
@@ -52,12 +53,14 @@ class CudfHashAggregation : public exec::Operator, public NvtxHelper {
         cudf::aggregation::Kind kind,
         uint32_t inputIndex,
         VectorPtr constant,
-        bool isGlobal)
+        bool isGlobal,
+        const TypePtr& _resultType)
         : step(step),
           is_global(isGlobal),
           kind(kind),
           inputIndex(inputIndex),
-          constant(constant) {}
+          constant(constant),
+          resultType(_resultType) {}
   };
 
   CudfHashAggregation(
@@ -138,6 +141,8 @@ class CudfHashAggregation : public exec::Operator, public NvtxHelper {
 
   std::vector<cudf_velox::CudfVectorPtr> inputs_;
 
+  TypePtr inputType_;
+
   // This is for partial aggregation to keep reducing the amount of memory it
   // has to hold on to.
   void computeIntermediateGroupbyPartial(CudfVectorPtr tbl);
diff --git a/velox/experimental/cudf/exec/CudfHashJoin.cpp b/velox/experimental/cudf/exec/CudfHashJoin.cpp
new file mode 100644
index 000000000000..f2601b9533ed
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfHashJoin.cpp
@@ -0,0 +1,1432 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/CudfHashJoin.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/Task.h" // NOLINT(misc-unused-headers)
+#include "velox/type/TypeUtil.h"
+
+#include <cudf/aggregation.hpp>
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/concatenate.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/filling.hpp>
+#include <cudf/groupby.hpp>
+#include <cudf/join/filtered_join.hpp>
+#include <cudf/join/join.hpp>
+#include <cudf/join/mixed_join.hpp>
+#include <cudf/null_mask.hpp>
+#include <cudf/reduction.hpp>
+#include <cudf/scalar/scalar_factories.hpp>
+#include <cudf/stream_compaction.hpp>
+#include <cudf/unary.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_uvector.hpp>
+#include <rmm/exec_policy.hpp>
+
+#include <nvtx3/nvtx3.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+void CudfHashJoinBridge::setHashTable(
+    std::optional<CudfHashJoinBridge::hash_type> hashObject) {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBridge::setHashTable" << std::endl;
+  }
+  std::vector<ContinuePromise> promises;
+  {
+    std::lock_guard<std::mutex> l(mutex_);
+    VELOX_CHECK(
+        !hashObject_.has_value(),
+        "CudfHashJoinBridge already has a hash table");
+    hashObject_ = std::move(hashObject);
+    promises = std::move(promises_);
+  }
+  notify(std::move(promises));
+}
+
+std::optional<CudfHashJoinBridge::hash_type> CudfHashJoinBridge::hashOrFuture(
+    ContinueFuture* future) {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBridge::hashOrFuture" << std::endl;
+  }
+  std::lock_guard<std::mutex> l(mutex_);
+  if (hashObject_.has_value()) {
+    return hashObject_;
+  }
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBridge::hashOrFuture constructing promise"
+              << std::endl;
+  }
+  promises_.emplace_back("CudfHashJoinBridge::hashOrFuture");
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBridge::hashOrFuture getSemiFuture"
+              << std::endl;
+  }
+  *future = promises_.back().getSemiFuture();
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBridge::hashOrFuture returning nullopt"
+              << std::endl;
+  }
+  return std::nullopt;
+}
+
+void CudfHashJoinBridge::setBuildStream(rmm::cuda_stream_view buildStream) {
+  std::lock_guard<std::mutex> l(mutex_);
+  buildStream_ = buildStream;
+}
+
+std::optional<rmm::cuda_stream_view> CudfHashJoinBridge::getBuildStream() {
+  std::lock_guard<std::mutex> l(mutex_);
+  return buildStream_;
+}
+
+CudfHashJoinBuild::CudfHashJoinBuild(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<const core::HashJoinNode> joinNode)
+    // TODO check outputType should be set or not?
+    : exec::Operator(
+          driverCtx,
+          nullptr, // joinNode->sources(),
+          operatorId,
+          joinNode->id(),
+          "CudfHashJoinBuild"),
+      NvtxHelper(
+          nvtx3::rgb{65, 105, 225}, // Royal Blue
+          operatorId,
+          fmt::format("[{}]", joinNode->id())),
+      joinNode_(joinNode) {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "CudfHashJoinBuild constructor" << std::endl;
+  }
+}
+
+void CudfHashJoinBuild::addInput(RowVectorPtr input) {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBuild::addInput" << std::endl;
+  }
+  // Queue inputs, process all at once.
+  if (input->size() > 0) {
+    auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
+    VELOX_CHECK_NOT_NULL(cudfInput);
+    // Count nulls in join key columns
+    auto [_, null_count] = cudf::bitmask_and(
+        cudfInput->getTableView(),
+        cudfInput->stream(),
+        cudf::get_current_device_resource_ref());
+    {
+      // Update statistics for null keys in join operator.
+      auto lockedStats = stats_.wlock();
+      lockedStats->numNullKeys += null_count;
+    }
+    inputs_.push_back(std::move(cudfInput));
+  }
+}
+
+bool CudfHashJoinBuild::needsInput() const {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBuild::needsInput" << std::endl;
+  }
+  return !noMoreInput_;
+}
+
+RowVectorPtr CudfHashJoinBuild::getOutput() {
+  return nullptr;
+}
+
+void CudfHashJoinBuild::noMoreInput() {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBuild::noMoreInput" << std::endl;
+  }
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  Operator::noMoreInput();
+  std::vector<ContinuePromise> promises;
+  std::vector<std::shared_ptr<exec::Driver>> peers;
+  // Only last driver collects all answers
+  if (!operatorCtx_->task()->allPeersFinished(
+          planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
+    return;
+  }
+  // Collect results from peers
+  for (auto& peer : peers) {
+    auto op = peer->findOperator(planNodeId());
+    auto* build = dynamic_cast<CudfHashJoinBuild*>(op);
+    VELOX_CHECK_NOT_NULL(build);
+    inputs_.insert(inputs_.end(), build->inputs_.begin(), build->inputs_.end());
+  }
+
+  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 (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "CudfHashJoinBuild: build batches" << std::endl;
+    LOG(INFO) << "Build batches number of columns: "
+              << inputs_[0]->getTableView().num_columns() << std::endl;
+    for (auto i = 0; i < inputs_.size(); i++) {
+      LOG(INFO) << "Build batch " << i
+                << ": number of rows: " << inputs_[i]->getTableView().num_rows()
+                << std::endl;
+    }
+  }
+
+  auto stream = cudfGlobalStreamPool().get_stream();
+  auto tbls = getConcatenatedTableBatched(
+      inputs_, joinNode_->sources()[1]->outputType(), stream);
+
+  // Release input data after synchronizing
+  stream.synchronize();
+  inputs_.clear();
+
+  for (auto const& tbl : tbls) {
+    VELOX_CHECK_NOT_NULL(tbl);
+  }
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Build table number of columns: " << tbls[0]->num_columns()
+              << std::endl;
+    for (auto i = 0; i < tbls.size(); i++) {
+      LOG(INFO) << "Build table " << i
+                << ": number of rows: " << tbls[i]->num_rows() << std::endl;
+    }
+  }
+
+  auto buildType = joinNode_->sources()[1]->outputType();
+  auto rightKeys = joinNode_->rightKeys();
+
+  auto buildKeyIndices = std::vector<cudf::size_type>(rightKeys.size());
+  for (size_t i = 0; i < buildKeyIndices.size(); i++) {
+    buildKeyIndices[i] = static_cast<cudf::size_type>(
+        buildType->getChildIdx(rightKeys[i]->name()));
+  }
+
+  // Only need to construct hash_join object if it's an inner join, left join or
+  // right join.
+  // All other cases use a standalone function in cudf
+  bool buildHashJoin =
+      (joinNode_->isInnerJoin() || joinNode_->isLeftJoin() ||
+       joinNode_->isRightJoin());
+
+  std::vector<std::shared_ptr<cudf::hash_join>> hashObjects;
+  for (auto i = 0; i < tbls.size(); i++) {
+    hashObjects.push_back(
+        (buildHashJoin) ? std::make_shared<cudf::hash_join>(
+                              tbls[i]->view().select(buildKeyIndices),
+                              cudf::null_equality::UNEQUAL,
+                              stream)
+                        : nullptr);
+    if (buildHashJoin) {
+      VELOX_CHECK_NOT_NULL(hashObjects.back());
+    }
+    if (CudfConfig::getInstance().debugEnabled) {
+      if (hashObjects.back() != nullptr) {
+        LOG(INFO) << "hashObject " << i << " is not nullptr "
+                  << hashObjects.back().get() << "\n";
+      } else {
+        LOG(INFO) << "hashObject " << i << " is *** nullptr\n";
+      }
+    }
+  }
+
+  std::vector<std::shared_ptr<cudf::table>> shared_tbls;
+  for (auto& tbl : tbls) {
+    shared_tbls.push_back(std::move(tbl));
+  }
+  // set hash table to CudfHashJoinBridge
+  auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
+      operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+  auto cudfHashJoinBridge =
+      std::dynamic_pointer_cast<CudfHashJoinBridge>(joinBridge);
+
+  cudfHashJoinBridge->setBuildStream(stream);
+  cudfHashJoinBridge->setHashTable(
+      std::make_optional(
+          std::make_pair(std::move(shared_tbls), std::move(hashObjects))));
+}
+
+exec::BlockingReason CudfHashJoinBuild::isBlocked(ContinueFuture* future) {
+  if (!future_.valid()) {
+    return exec::BlockingReason::kNotBlocked;
+  }
+  *future = std::move(future_);
+  return exec::BlockingReason::kWaitForJoinBuild;
+}
+
+bool CudfHashJoinBuild::isFinished() {
+  return !future_.valid() && noMoreInput_;
+}
+
+CudfHashJoinProbe::CudfHashJoinProbe(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    std::shared_ptr<const core::HashJoinNode> joinNode)
+    : exec::Operator(
+          driverCtx,
+          joinNode->outputType(),
+          operatorId,
+          joinNode->id(),
+          "CudfHashJoinProbe"),
+      NvtxHelper(
+          nvtx3::rgb{0, 128, 128}, // Teal
+          operatorId,
+          fmt::format("[{}]", joinNode->id())),
+      joinNode_(joinNode),
+      cudaEvent_(std::make_unique<CudaEvent>(cudaEventDisableTiming)) {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "CudfHashJoinProbe constructor" << std::endl;
+  }
+  auto probeType = joinNode_->sources()[0]->outputType();
+  auto buildType = joinNode_->sources()[1]->outputType();
+  auto const& leftKeys = joinNode_->leftKeys(); // probe keys
+  auto const& rightKeys = joinNode_->rightKeys(); // build keys
+
+  if (CudfConfig::getInstance().debugEnabled) {
+    for (int i = 0; i < probeType->names().size(); i++) {
+      LOG(INFO) << "Left column " << i << ": " << probeType->names()[i]
+                << std::endl;
+    }
+
+    for (int i = 0; i < buildType->names().size(); i++) {
+      LOG(INFO) << "Right column " << i << ": " << buildType->names()[i]
+                << std::endl;
+    }
+
+    for (int i = 0; i < leftKeys.size(); i++) {
+      LOG(INFO) << "Left key " << i << ": " << leftKeys[i]->name() << " "
+                << leftKeys[i]->type()->kind() << std::endl;
+    }
+
+    for (int i = 0; i < rightKeys.size(); i++) {
+      LOG(INFO) << "Right key " << i << ": " << rightKeys[i]->name() << " "
+                << rightKeys[i]->type()->kind() << std::endl;
+    }
+  }
+
+  auto const probeTableNumColumns = probeType->size();
+  leftKeyIndices_ = std::vector<cudf::size_type>(leftKeys.size());
+  for (size_t i = 0; i < leftKeyIndices_.size(); i++) {
+    leftKeyIndices_[i] = static_cast<cudf::size_type>(
+        probeType->getChildIdx(leftKeys[i]->name()));
+    VELOX_CHECK_LT(leftKeyIndices_[i], probeTableNumColumns);
+  }
+  auto const buildTableNumColumns = buildType->size();
+  rightKeyIndices_ = std::vector<cudf::size_type>(rightKeys.size());
+  for (size_t i = 0; i < rightKeyIndices_.size(); i++) {
+    rightKeyIndices_[i] = static_cast<cudf::size_type>(
+        buildType->getChildIdx(rightKeys[i]->name()));
+    VELOX_CHECK_LT(rightKeyIndices_[i], buildTableNumColumns);
+  }
+
+  auto outputType = joinNode_->outputType();
+  leftColumnIndicesToGather_ = std::vector<cudf::size_type>();
+  rightColumnIndicesToGather_ = std::vector<cudf::size_type>();
+  leftColumnOutputIndices_ = std::vector<size_t>();
+  rightColumnOutputIndices_ = std::vector<size_t>();
+  for (int i = 0; i < outputType->names().size(); i++) {
+    auto const outputName = outputType->names()[i];
+    if (CudfConfig::getInstance().debugEnabled) {
+      LOG(INFO) << "Output column " << i << ": " << outputName << std::endl;
+    }
+    auto channel = probeType->getChildIdxIfExists(outputName);
+    if (channel.has_value()) {
+      leftColumnIndicesToGather_.push_back(
+          static_cast<cudf::size_type>(channel.value()));
+      leftColumnOutputIndices_.push_back(i);
+      continue;
+    }
+    channel = buildType->getChildIdxIfExists(outputName);
+    if (channel.has_value()) {
+      rightColumnIndicesToGather_.push_back(
+          static_cast<cudf::size_type>(channel.value()));
+      rightColumnOutputIndices_.push_back(i);
+      continue;
+    }
+    VELOX_FAIL(
+        "Join field {} not in probe or build input", outputType->children()[i]);
+  }
+
+  if (CudfConfig::getInstance().debugEnabled) {
+    for (int i = 0; i < leftColumnIndicesToGather_.size(); i++) {
+      LOG(INFO) << "Left index to gather " << i << ": "
+                << leftColumnIndicesToGather_[i] << std::endl;
+    }
+
+    for (int i = 0; i < rightColumnIndicesToGather_.size(); i++) {
+      LOG(INFO) << "Right index to gather " << i << ": "
+                << rightColumnIndicesToGather_[i] << std::endl;
+    }
+  }
+
+  // Setup filter in case it exists
+  if (joinNode_->filter()) {
+    // simplify expression
+    exec::ExprSet exprs({joinNode_->filter()}, operatorCtx_->execCtx());
+    VELOX_CHECK_EQ(exprs.exprs().size(), 1);
+
+    // We don't need to get tables that contain conditional comparison columns
+    // We'll pass the entire table. The ast will handle finding the required
+    // columns. This is required because we build the ast with whole row schema
+    // and the column locations in that schema translate to column locations
+    // in whole tables
+
+    // create ast tree
+    std::vector<PrecomputeInstruction> rightPrecomputeInstructions;
+    std::vector<PrecomputeInstruction> leftPrecomputeInstructions;
+    static constexpr bool kAllowPureAstOnly = true;
+    if (joinNode_->isRightJoin() || joinNode_->isRightSemiFilterJoin()) {
+      createAstTree(
+          exprs.exprs()[0],
+          tree_,
+          scalars_,
+          buildType,
+          probeType,
+          rightPrecomputeInstructions,
+          leftPrecomputeInstructions,
+          kAllowPureAstOnly);
+    } else {
+      createAstTree(
+          exprs.exprs()[0],
+          tree_,
+          scalars_,
+          probeType,
+          buildType,
+          leftPrecomputeInstructions,
+          rightPrecomputeInstructions,
+          kAllowPureAstOnly);
+    }
+    if (leftPrecomputeInstructions.size() > 0 ||
+        rightPrecomputeInstructions.size() > 0) {
+      VELOX_NYI("Filters that require precomputation are not yet supported");
+    }
+  }
+}
+
+bool CudfHashJoinProbe::needsInput() const {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinProbe::needsInput" << std::endl;
+  }
+  if (joinNode_->isRightSemiFilterJoin()) {
+    return !noMoreInput_;
+  }
+  return !noMoreInput_ && !finished_ && input_ == nullptr;
+}
+
+void CudfHashJoinProbe::addInput(RowVectorPtr input) {
+  if (skipInput_) {
+    VELOX_CHECK_NULL(input_);
+    return;
+  }
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+  // Count nulls in join key columns
+  auto [_, null_count] = cudf::bitmask_and(
+      cudfInput->getTableView(),
+      cudfInput->stream(),
+      cudf::get_current_device_resource_ref());
+  {
+    // Update statistics for null keys in join operator.
+    auto lockedStats = stats_.wlock();
+    lockedStats->numNullKeys += null_count;
+  }
+  if (joinNode_->isRightSemiFilterJoin()) {
+    // Queue inputs and process all at once
+    if (input->size() > 0) {
+      inputs_.push_back(std::move(cudfInput));
+    }
+    return;
+  }
+
+  if (input->size() > 0) {
+    input_ = std::move(input);
+  }
+}
+
+void CudfHashJoinProbe::noMoreInput() {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinProbe::noMoreInput" << std::endl;
+  }
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  Operator::noMoreInput();
+  if (!joinNode_->isRightJoin() && !joinNode_->isRightSemiFilterJoin()) {
+    return;
+  }
+  std::vector<ContinuePromise> promises;
+  std::vector<std::shared_ptr<exec::Driver>> peers;
+  // Only last driver collects all answers
+  if (!operatorCtx_->task()->allPeersFinished(
+          planNodeId(), operatorCtx_->driver(), &future_, promises, peers)) {
+    return;
+  }
+
+  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 (joinNode_->isRightJoin()) {
+    isLastDriver_ = true;
+    if (hashObject_.has_value()) {
+      auto stream = cudfGlobalStreamPool().get_stream();
+      for (auto& peer : peers) {
+        if (peer.get() == operatorCtx_->driver()) {
+          continue;
+        }
+        auto op = peer->findOperator(planNodeId());
+        auto* probe = dynamic_cast<CudfHashJoinProbe*>(op);
+        if (probe == nullptr) {
+          continue;
+        }
+        // Combine flags per partition using cuDF bitwise OR
+        // DM: This needs a relook. This is for when build side exceeds cudf
+        // size_type limits. In case of multiple right side chunks, I'm not sure
+        // if partitions to combine are in the same place p
+        for (size_t p = 0; p < rightMatchedFlags_.size(); ++p) {
+          auto or_result = cudf::binary_operation(
+              rightMatchedFlags_[p]->view(),
+              probe->rightMatchedFlags_[p]->view(),
+              cudf::binary_operator::BITWISE_OR,
+              cudf::data_type{cudf::type_id::BOOL8},
+              stream,
+              cudf::get_current_device_resource_ref());
+          rightMatchedFlags_[p] = std::move(or_result);
+        }
+      }
+      stream.synchronize();
+    }
+    return;
+  }
+
+  // Handling RightSemiFilterJoin
+  // Collect results from peers
+  for (auto& peer : peers) {
+    auto op = peer->findOperator(planNodeId());
+    auto* probe = dynamic_cast<CudfHashJoinProbe*>(op);
+    VELOX_CHECK_NOT_NULL(probe);
+    inputs_.insert(inputs_.end(), probe->inputs_.begin(), probe->inputs_.end());
+  }
+
+  auto stream = cudfGlobalStreamPool().get_stream();
+  auto tbl = getConcatenatedTable(
+      inputs_, joinNode_->sources()[1]->outputType(), stream);
+
+  // Release input data after synchronizing
+  stream.synchronize();
+
+  VELOX_CHECK_NOT_NULL(tbl);
+
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Probe table number of columns: " << tbl->num_columns()
+              << std::endl;
+    LOG(INFO) << "Probe table number of rows: " << tbl->num_rows() << std::endl;
+  }
+
+  // Store the concatenated table in input_
+  input_ = std::make_shared<CudfVector>(
+      operatorCtx_->pool(),
+      joinNode_->outputType(),
+      tbl->num_rows(),
+      std::move(tbl),
+      stream);
+
+  inputs_.clear();
+}
+
+std::unique_ptr<cudf::table> CudfHashJoinProbe::unfilteredOutput(
+    cudf::table_view leftTableView,
+    cudf::column_view leftIndicesCol,
+    cudf::table_view rightTableView,
+    cudf::column_view rightIndicesCol,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::column>> joinedCols;
+  auto leftInput = leftTableView.select(leftColumnIndicesToGather_);
+  auto rightInput = rightTableView.select(rightColumnIndicesToGather_);
+  auto leftResult = cudf::gather(leftInput, leftIndicesCol, oobPolicy, stream);
+  auto rightResult =
+      cudf::gather(rightInput, rightIndicesCol, oobPolicy, stream);
+
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Left result number of columns: " << leftResult->num_columns()
+              << std::endl;
+    LOG(INFO) << "Right result number of columns: "
+              << rightResult->num_columns() << std::endl;
+  }
+
+  auto leftCols = leftResult->release();
+  auto rightCols = rightResult->release();
+  joinedCols.resize(outputType_->names().size());
+  for (int i = 0; i < leftColumnOutputIndices_.size(); i++) {
+    joinedCols[leftColumnOutputIndices_[i]] = std::move(leftCols[i]);
+  }
+  for (int i = 0; i < rightColumnOutputIndices_.size(); i++) {
+    joinedCols[rightColumnOutputIndices_[i]] = std::move(rightCols[i]);
+  }
+  if (buildStream_.has_value()) {
+    // Ensure deallocation of build table happens after probe gathers
+    cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+  }
+  stream.synchronize();
+  return std::make_unique<cudf::table>(std::move(joinedCols));
+}
+
+std::unique_ptr<cudf::table> CudfHashJoinProbe::filteredOutput(
+    cudf::table_view leftTableView,
+    cudf::column_view leftIndicesCol,
+    cudf::table_view rightTableView,
+    cudf::column_view rightIndicesCol,
+    std::function<std::vector<std::unique_ptr<cudf::column>>(
+        std::vector<std::unique_ptr<cudf::column>>&&,
+        cudf::column_view)> func,
+    rmm::cuda_stream_view stream) {
+  auto leftResult =
+      cudf::gather(leftTableView, leftIndicesCol, oobPolicy, stream);
+  auto rightResult =
+      cudf::gather(rightTableView, rightIndicesCol, oobPolicy, stream);
+  auto leftColsSize = leftResult->num_columns();
+  auto rightColsSize = rightResult->num_columns();
+
+  std::vector<std::unique_ptr<cudf::column>> joinedCols = leftResult->release();
+  auto rightCols = rightResult->release();
+  joinedCols.insert(
+      joinedCols.end(),
+      std::make_move_iterator(rightCols.begin()),
+      std::make_move_iterator(rightCols.end()));
+
+  auto probeType = joinNode_->sources()[0]->outputType();
+  auto buildType = joinNode_->sources()[1]->outputType();
+  std::vector<velox::RowTypePtr> rowTypes{probeType, buildType};
+  exec::ExprSet exprs({joinNode_->filter()}, operatorCtx_->execCtx());
+  VELOX_CHECK_EQ(exprs.exprs().size(), 1);
+  auto filterEvaluator = createCudfExpression(
+      exprs.exprs()[0], facebook::velox::type::concatRowTypes(rowTypes));
+  auto filterColumns = filterEvaluator->eval(
+      joinedCols, stream, cudf::get_current_device_resource_ref());
+  auto filterColumn = asView(filterColumns);
+
+  joinedCols = func(std::move(joinedCols), filterColumn);
+
+  auto filteredjoinedCols =
+      std::vector<std::unique_ptr<cudf::column>>(outputType_->names().size());
+  for (int i = 0; i < leftColumnOutputIndices_.size(); i++) {
+    filteredjoinedCols[leftColumnOutputIndices_[i]] =
+        std::move(joinedCols[leftColumnIndicesToGather_[i]]);
+  }
+  for (int i = 0; i < rightColumnOutputIndices_.size(); i++) {
+    filteredjoinedCols[rightColumnOutputIndices_[i]] =
+        std::move(joinedCols[leftColsSize + rightColumnIndicesToGather_[i]]);
+  }
+  joinedCols = std::move(filteredjoinedCols);
+  if (buildStream_.has_value()) {
+    // Ensure any deallocation of join indices is ordered wrt probe gathers
+    cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+  }
+  stream.synchronize();
+  return std::make_unique<cudf::table>(std::move(joinedCols));
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::innerJoin(
+    std::unique_ptr<cudf::table> const& leftTable,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto leftTableView = leftTable->view();
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    auto& hb = hbs[i];
+
+    // left = probe, right = build
+    VELOX_CHECK_NOT_NULL(hb);
+    if (buildStream_.has_value()) {
+      // Make build stream wait for probe tables to become valid
+      cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+    }
+    auto [leftJoinIndices, rightJoinIndices] = hb->inner_join(
+        leftTableView.select(leftKeyIndices_),
+        std::nullopt,
+        buildStream_.has_value() ? buildStream_.value() : stream);
+    if (buildStream_.has_value()) {
+      // Make probe stream wait for join completion before using indices
+      cudaEvent_->recordFrom(buildStream_.value()).waitOn(stream);
+    }
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto rightIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+    std::vector<std::unique_ptr<cudf::column>> joinedCols;
+
+    if (joinNode_->filter()) {
+      auto filterFunc =
+          [stream](
+              std::vector<std::unique_ptr<cudf::column>>&& joinedCols,
+              cudf::column_view filterColumn) {
+            auto filterTable =
+                std::make_unique<cudf::table>(std::move(joinedCols));
+            auto filteredTable =
+                cudf::apply_boolean_mask(*filterTable, filterColumn, stream);
+            return filteredTable->release();
+          };
+      cudfOutputs.push_back(filteredOutput(
+          leftTableView,
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          filterFunc,
+          stream));
+    } else {
+      cudfOutputs.push_back(unfilteredOutput(
+          leftTableView,
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          stream));
+    }
+  }
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::leftJoin(
+    std::unique_ptr<cudf::table> const& leftTable,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto leftTableView = leftTable->view();
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    auto& hb = hbs[i];
+
+    VELOX_CHECK_NOT_NULL(hb);
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+    }
+    auto [leftJoinIndices, rightJoinIndices] = hb->left_join(
+        leftTableView.select(leftKeyIndices_),
+        std::nullopt,
+        buildStream_.has_value() ? buildStream_.value() : stream);
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(buildStream_.value()).waitOn(stream);
+    }
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto rightIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+    std::vector<std::unique_ptr<cudf::column>> joinedCols;
+
+    if (joinNode_->filter()) {
+      auto filterFunc = [&leftJoinIndices,
+                         &rightJoinIndices,
+                         leftTableView,
+                         leftIndicesCol,
+                         rightTableView,
+                         rightIndicesCol,
+                         stream](
+                            std::vector<std::unique_ptr<cudf::column>>&&
+                                joinedCols,
+                            cudf::column_view filterColumn) {
+        auto leftColsSize = leftTableView.num_columns();
+        auto rightColsSize = rightTableView.num_columns();
+
+        cudf::groupby::groupby keysleftIndicesColGrouper(
+            cudf::table_view{{leftIndicesCol}},
+            cudf::null_policy::EXCLUDE,
+            cudf::sorted::NO);
+        std::vector<cudf::groupby::aggregation_request> requests;
+        requests.emplace_back(cudf::groupby::aggregation_request{});
+        requests.emplace_back(cudf::groupby::aggregation_request{});
+        requests[0].aggregations.push_back(
+            cudf::make_sum_aggregation<cudf::groupby_aggregation>());
+        requests[0].values = filterColumn;
+
+        auto zero_scalar =
+            cudf::numeric_scalar<cudf::size_type>(0, true, stream);
+        auto rowIndexColumn =
+            cudf::sequence(leftIndicesCol.size(), zero_scalar, stream);
+        requests[1].aggregations.push_back(
+            cudf::make_min_aggregation<cudf::groupby_aggregation>());
+        requests[1].values = rowIndexColumn->view();
+        auto result = keysleftIndicesColGrouper.aggregate(requests, stream);
+
+        auto uniqueFilter = std::move(result.second[0].results[0]);
+        auto zero_scalar_64 =
+            cudf::numeric_scalar<std::int64_t>(0, true, stream);
+        uniqueFilter =
+            cudf::replace_nulls(uniqueFilter->view(), zero_scalar_64, stream);
+        uniqueFilter = cudf::binary_operation(
+            uniqueFilter->view(),
+            zero_scalar_64,
+            cudf::binary_operator::EQUAL,
+            cudf::data_type{cudf::type_id::BOOL8},
+            stream);
+
+        auto minIndices = std::move(result.second[1].results[0]);
+        auto filteredMinIndicesTable = cudf::apply_boolean_mask(
+            cudf::table_view{{minIndices->view()}},
+            uniqueFilter->view(),
+            stream);
+        auto filteredMinIndices = filteredMinIndicesTable->get_column(0).view();
+        {
+          std::vector<std::unique_ptr<cudf::scalar>> nullScalars;
+          std::vector<std::reference_wrapper<cudf::scalar const>>
+              nullScalarRefs;
+          std::vector<cudf::column_view> rightColViews;
+          for (auto col = leftColsSize; col < joinedCols.size(); col++) {
+            nullScalars.emplace_back(
+                cudf::make_empty_scalar_like(joinedCols[col]->view(), stream));
+            nullScalarRefs.push_back(
+                std::reference_wrapper<cudf::scalar const>(
+                    *(nullScalars.back())));
+            rightColViews.push_back(joinedCols[col]->view());
+          }
+          auto nullifiedRightTable = cudf::scatter(
+              nullScalarRefs,
+              filteredMinIndices,
+              cudf::table_view(rightColViews),
+              stream);
+          auto nullifiedRightCols = nullifiedRightTable->release();
+          for (auto col = leftColsSize; col < joinedCols.size(); col++) {
+            joinedCols[col] = std::move(nullifiedRightCols[col - leftColsSize]);
+          }
+        }
+
+        // Update filter using scatter
+        auto true_scalar = cudf::numeric_scalar<bool>(true, true);
+        std::vector<std::reference_wrapper<cudf::scalar const>> source_scalars{
+            true_scalar};
+        auto filteredColumnTable = cudf::scatter(
+            source_scalars,
+            filteredMinIndices,
+            cudf::table_view{{filterColumn}},
+            stream);
+        auto updatedFilterColumn = filteredColumnTable->get_column(0).view();
+
+        // Apply the Filter
+        auto filterTable = std::make_unique<cudf::table>(std::move(joinedCols));
+        auto filteredTable =
+            cudf::apply_boolean_mask(*filterTable, updatedFilterColumn, stream);
+        stream.synchronize();
+
+        return filteredTable->release();
+      };
+
+      cudfOutputs.push_back(filteredOutput(
+          leftTableView,
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          filterFunc,
+          stream));
+    } else {
+      cudfOutputs.push_back(unfilteredOutput(
+          leftTableView,
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          stream));
+    }
+  }
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::rightJoin(
+    std::unique_ptr<cudf::table> const& leftTable,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto leftTableView = leftTable->view();
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    auto& hb = hbs[i];
+
+    VELOX_CHECK_NOT_NULL(hb);
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(stream).waitOn(buildStream_.value());
+    }
+    auto [leftJoinIndices, rightJoinIndices] = hb->inner_join(
+        leftTableView.select(leftKeyIndices_),
+        std::nullopt,
+        buildStream_.has_value() ? buildStream_.value() : stream);
+    if (buildStream_.has_value()) {
+      cudaEvent_->recordFrom(buildStream_.value()).waitOn(stream);
+    }
+    if (!joinNode_->filter()) {
+      // Mark matched rights using scatter of true into flags at matching
+      // indices
+      // TODO (dm): Use a better implementation that doesn't require making a
+      // scalar and broadcasting. My cuDF foo is rusty
+      auto true_scalar = cudf::numeric_scalar<bool>(true, true, stream);
+      auto true_col = cudf::make_column_from_scalar(
+          true_scalar,
+          rightJoinIndices->size(),
+          stream,
+          cudf::get_current_device_resource_ref());
+      auto flags_table = cudf::table_view({rightMatchedFlags_[i]->view()});
+      auto rightIdxCol = cudf::column_view{
+          cudf::device_span<cudf::size_type const>{*rightJoinIndices}};
+      auto updated_flags_tbl = cudf::scatter(
+          cudf::table_view({true_col->view()}),
+          rightIdxCol,
+          flags_table,
+          stream,
+          cudf::get_current_device_resource_ref());
+      rightMatchedFlags_[i] = std::move(updated_flags_tbl->release()[0]);
+    }
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto rightIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+    std::vector<std::unique_ptr<cudf::column>> joinedCols;
+
+    if (joinNode_->filter()) {
+      auto& rightMatchedFlags = rightMatchedFlags_[i];
+      auto filterFunc =
+          [&rightMatchedFlags, rightIndicesSpan, stream](
+              std::vector<std::unique_ptr<cudf::column>>&& joinedCols,
+              cudf::column_view filterColumn) {
+            // apply the filter
+            auto filterTable =
+                std::make_unique<cudf::table>(std::move(joinedCols));
+            auto filteredTable =
+                cudf::apply_boolean_mask(*filterTable, filterColumn, stream);
+            joinedCols = filteredTable->release();
+
+            // For streaming right join, after applying filter, we record
+            // matched right indices filter rightJoinIndices with the same mask
+            // to update matched flags
+            auto rightIdxCol = cudf::column_view{rightIndicesSpan};
+            auto filteredIdxTable = cudf::apply_boolean_mask(
+                cudf::table_view{std::vector<cudf::column_view>{rightIdxCol}},
+                filterColumn,
+                stream);
+            auto filteredCols = filteredIdxTable->release();
+            auto filteredRightIdxCol = std::move(filteredCols[0]);
+
+            // TODO (dm): The below code is repeated from non-filter case. Find
+            // a way to consolidate in future
+            auto true_scalar = cudf::numeric_scalar<bool>(true, true, stream);
+            auto true_col = cudf::make_column_from_scalar(
+                true_scalar,
+                filteredRightIdxCol->size(),
+                stream,
+                cudf::get_current_device_resource_ref());
+            auto flags_table = cudf::table_view({rightMatchedFlags->view()});
+            auto updated_flags_tbl = cudf::scatter(
+                cudf::table_view({true_col->view()}),
+                filteredRightIdxCol->view(),
+                flags_table,
+                stream,
+                cudf::get_current_device_resource_ref());
+            rightMatchedFlags = std::move(updated_flags_tbl->release()[0]);
+            return std::move(joinedCols);
+          };
+      cudfOutputs.push_back(filteredOutput(
+          leftTableView,
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          filterFunc,
+          stream));
+    } else {
+      cudfOutputs.push_back(unfilteredOutput(
+          leftTableView,
+          leftIndicesCol,
+          rightTableView,
+          rightIndicesCol,
+          stream));
+    }
+  }
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::leftSemiFilterJoin(
+    std::unique_ptr<cudf::table> const& leftTable,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto leftTableView = leftTable->view();
+  auto& rightTables = hashObject_.value().first;
+
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto rightTableView = rightTables[i]->view();
+    std::unique_ptr<rmm::device_uvector<cudf::size_type>> leftJoinIndices;
+
+    if (joinNode_->filter()) {
+      leftJoinIndices = cudf::mixed_left_semi_join(
+          leftTableView.select(leftKeyIndices_),
+          rightTableView.select(rightKeyIndices_),
+          leftTableView,
+          rightTableView,
+          tree_.back(),
+          cudf::null_equality::UNEQUAL,
+          stream,
+          cudf::get_current_device_resource_ref());
+    } else {
+      cudf::filtered_join filter_join(
+          rightTableView.select(rightKeyIndices_),
+          cudf::null_equality::UNEQUAL,
+          cudf::set_as_build_table::RIGHT,
+          stream);
+      leftJoinIndices = filter_join.semi_join(
+          leftTableView.select(leftKeyIndices_),
+          stream,
+          cudf::get_current_device_resource_ref());
+    }
+
+    auto leftIndicesSpan =
+        cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+    auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+    auto rightIndicesCol = cudf::empty_like(leftIndicesCol);
+
+    cudfOutputs.push_back(unfilteredOutput(
+        leftTableView,
+        leftIndicesCol,
+        rightTableView,
+        rightIndicesCol->view(),
+        stream));
+  }
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>>
+CudfHashJoinProbe::rightSemiFilterJoin(
+    std::unique_ptr<cudf::table> const& leftTable,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+
+  auto leftTableView = leftTable->view();
+  auto& rightTables = hashObject_.value().first;
+  auto rightTableView = rightTables[0]->view();
+
+  VELOX_CHECK_EQ(
+      rightTables.size(),
+      1,
+      "Multiple right tables not yet supported for rightSemiFilterJoin");
+
+  std::unique_ptr<rmm::device_uvector<cudf::size_type>> rightJoinIndices;
+  if (joinNode_->filter()) {
+    rightJoinIndices = cudf::mixed_left_semi_join(
+        rightTableView.select(rightKeyIndices_),
+        leftTableView.select(leftKeyIndices_),
+        rightTableView,
+        leftTableView,
+        tree_.back(),
+        cudf::null_equality::UNEQUAL,
+        stream,
+        cudf::get_current_device_resource_ref());
+  } else {
+    cudf::filtered_join filter_join(
+        leftTableView.select(leftKeyIndices_),
+        cudf::null_equality::UNEQUAL,
+        cudf::set_as_build_table::RIGHT,
+        stream);
+    rightJoinIndices = filter_join.semi_join(
+        rightTableView.select(rightKeyIndices_),
+        stream,
+        cudf::get_current_device_resource_ref());
+  }
+
+  auto rightIndicesSpan =
+      cudf::device_span<cudf::size_type const>{*rightJoinIndices};
+  auto rightIndicesCol = cudf::column_view{rightIndicesSpan};
+  auto leftIndicesCol = cudf::empty_like(rightIndicesCol);
+  cudfOutputs.push_back(unfilteredOutput(
+      leftTableView,
+      leftIndicesCol->view(),
+      rightTableView,
+      rightIndicesCol,
+      stream));
+
+  return cudfOutputs;
+}
+
+std::vector<std::unique_ptr<cudf::table>> CudfHashJoinProbe::antiJoin(
+    std::unique_ptr<cudf::table>&& leftTable,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+  auto& rightTables = hashObject_.value().first;
+
+  VELOX_CHECK_EQ(
+      rightTables.size(),
+      1,
+      "Multiple right tables not yet supported for antiJoin");
+
+  auto rightTableView = rightTables[0]->view();
+  // Special case for null-aware anti join where
+  // build table is not empty, no nulls, and probe table has nulls
+  if (joinNode_->isNullAware() and !joinNode_->filter()) {
+    auto const leftTableHasNulls =
+        cudf::has_nulls(leftTable->view().select(leftKeyIndices_));
+    auto const rightTableHasNulls =
+        cudf::has_nulls(rightTableView.select(rightKeyIndices_));
+    if (rightTables[0]->num_rows() > 0 and !rightTableHasNulls and
+        leftTableHasNulls) {
+      // drop nulls on probe table
+      leftTable = cudf::drop_nulls(leftTable->view(), leftKeyIndices_, stream);
+    }
+  }
+
+  auto leftTableView = leftTable->view();
+  std::unique_ptr<rmm::device_uvector<cudf::size_type>> leftJoinIndices;
+  if (joinNode_->filter()) {
+    leftJoinIndices = cudf::mixed_left_anti_join(
+        leftTableView.select(leftKeyIndices_),
+        rightTableView.select(rightKeyIndices_),
+        leftTableView,
+        rightTableView,
+        tree_.back(),
+        cudf::null_equality::UNEQUAL,
+        stream,
+        cudf::get_current_device_resource_ref());
+  } else {
+    auto const rightTableHasNulls =
+        cudf::has_nulls(rightTableView.select(rightKeyIndices_));
+    if (joinNode_->isNullAware() and rightTableHasNulls) {
+      // empty result
+      leftJoinIndices = std::make_unique<rmm::device_uvector<cudf::size_type>>(
+          0, stream, cudf::get_current_device_resource_ref());
+    } else {
+      cudf::filtered_join filter_join(
+          rightTableView.select(rightKeyIndices_),
+          cudf::null_equality::UNEQUAL,
+          cudf::set_as_build_table::RIGHT,
+          stream);
+      leftJoinIndices = filter_join.anti_join(
+          leftTableView.select(leftKeyIndices_),
+          stream,
+          cudf::get_current_device_resource_ref());
+    }
+  }
+
+  auto leftIndicesSpan =
+      cudf::device_span<cudf::size_type const>{*leftJoinIndices};
+  auto leftIndicesCol = cudf::column_view{leftIndicesSpan};
+  auto rightIndicesCol = cudf::empty_like(leftIndicesCol);
+  cudfOutputs.push_back(unfilteredOutput(
+      leftTableView,
+      leftIndicesCol,
+      rightTableView,
+      rightIndicesCol->view(),
+      stream));
+
+  return cudfOutputs;
+}
+
+RowVectorPtr CudfHashJoinProbe::getOutput() {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinProbe::getOutput" << std::endl;
+  }
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+
+  if (finished_ or !hashObject_.has_value()) {
+    return nullptr;
+  }
+  if (!input_) {
+    // If no more input, emit unmatched-right rows if needed.
+    if (joinNode_->isRightJoin() && noMoreInput_ && !finished_ &&
+        isLastDriver_) {
+      auto& rightTables = hashObject_.value().first;
+      auto stream = cudfGlobalStreamPool().get_stream();
+      std::vector<std::unique_ptr<cudf::table>> toConcat;
+      for (size_t i = 0; i < rightTables.size(); ++i) {
+        auto& rightTable = rightTables[i];
+        auto n = rightTable->num_rows();
+        if (n == 0) {
+          continue;
+        }
+        auto& flags = rightMatchedFlags_[i];
+        // Build a boolean mask: unmatched = NOT(flags)
+        auto boolMask = cudf::unary_operation(
+            flags->view(), cudf::unary_operator::NOT, stream);
+
+        auto rightInput =
+            rightTable->view().select(rightColumnIndicesToGather_);
+        auto unmatchedRight =
+            cudf::apply_boolean_mask(rightInput, boolMask->view(), stream);
+        auto m = unmatchedRight->num_rows();
+        if (m == 0) {
+          continue;
+        }
+        // Build left null columns
+        std::vector<std::unique_ptr<cudf::column>> outCols(outputType_->size());
+        // Left side nulls (types derive from probe schema at the matching
+        // channel indices)
+        auto probeType = joinNode_->sources()[0]->outputType();
+        for (int li = 0; li < leftColumnOutputIndices_.size(); ++li) {
+          auto outIdx = leftColumnOutputIndices_[li];
+          auto probeChannel = leftColumnIndicesToGather_[li];
+          auto leftCudfType =
+              veloxToCudfTypeId(probeType->childAt(probeChannel));
+          auto nullScalar = cudf::make_default_constructed_scalar(
+              cudf::data_type{leftCudfType});
+          outCols[outIdx] = cudf::make_column_from_scalar(
+              *nullScalar, m, stream, cudf::get_current_device_resource_ref());
+        }
+        // Right side
+        auto rightCols = unmatchedRight->release();
+        for (int ri = 0; ri < rightColumnOutputIndices_.size(); ++ri) {
+          auto outIdx = rightColumnOutputIndices_[ri];
+          outCols[outIdx] = std::move(rightCols[ri]);
+        }
+        toConcat.push_back(std::make_unique<cudf::table>(std::move(outCols)));
+      }
+      // TODO (dm): We build multiple right chunks only when they are too large
+      // to fit in cudf::size_type. In case of a right join which doesn't have a
+      // lot of matches we'll get outCols of similar size. This concatenation
+      // will overflow. Try emitting result of one right chunk at a time.
+      if (!toConcat.empty()) {
+        auto out = concatenateTables(std::move(toConcat), stream);
+        finished_ = true;
+        auto size = out->num_rows();
+        if (out->num_columns() == 0 || size == 0) {
+          return nullptr;
+        }
+        return std::make_shared<CudfVector>(
+            pool(), outputType_, size, std::move(out), stream);
+      }
+      finished_ = true;
+    }
+    return nullptr;
+  }
+
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input_);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+  auto stream = cudfInput->stream();
+  auto leftTable = cudfInput->release(); // probe table
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Probe table number of columns: " << leftTable->num_columns()
+              << std::endl;
+    LOG(INFO) << "Probe table number of rows: " << leftTable->num_rows()
+              << std::endl;
+  }
+
+  auto& rightTables = hashObject_.value().first;
+  auto& hbs = hashObject_.value().second;
+  for (auto i = 0; i < rightTables.size(); i++) {
+    auto& rightTable = rightTables[i];
+    auto& hb = hbs[i];
+    VELOX_CHECK_NOT_NULL(rightTable);
+    if (CudfConfig::getInstance().debugEnabled) {
+      if (rightTable != nullptr)
+        LOG(INFO) << "right_table is not nullptr " << rightTable.get()
+                  << " hasValue(" << hashObject_.has_value() << ")\n";
+      if (hb != nullptr)
+        LOG(INFO) << "hb is not nullptr " << hb.get() << " hasValue("
+                  << hashObject_.has_value() << ")\n";
+    }
+  }
+
+  std::vector<std::unique_ptr<cudf::table>> cudfOutputs;
+  switch (joinNode_->joinType()) {
+    case core::JoinType::kInner:
+      cudfOutputs = innerJoin(leftTable, stream);
+      break;
+    case core::JoinType::kLeft:
+      cudfOutputs = leftJoin(leftTable, stream);
+      break;
+    case core::JoinType::kRight:
+      cudfOutputs = rightJoin(leftTable, stream);
+      break;
+    case core::JoinType::kLeftSemiFilter:
+      cudfOutputs = leftSemiFilterJoin(leftTable, stream);
+      break;
+    case core::JoinType::kRightSemiFilter:
+      cudfOutputs = rightSemiFilterJoin(leftTable, stream);
+      break;
+    case core::JoinType::kAnti:
+      cudfOutputs = antiJoin(std::move(leftTable), stream);
+      break;
+    default:
+      VELOX_FAIL("Unsupported join type: ", joinNode_->joinType());
+  }
+
+  input_.reset();
+  finished_ = noMoreInput_ && !joinNode_->isRightJoin();
+
+  auto cudfOutput = concatenateTables(std::move(cudfOutputs), stream);
+  auto const size = cudfOutput->num_rows();
+  if (cudfOutput->num_columns() == 0 or size == 0) {
+    return nullptr;
+  }
+  return std::make_shared<CudfVector>(
+      pool(),
+      outputType_,
+      cudfOutput->num_rows(),
+      std::move(cudfOutput),
+      stream);
+}
+
+bool CudfHashJoinProbe::skipProbeOnEmptyBuild() const {
+  auto const joinType = joinNode_->joinType();
+  return isInnerJoin(joinType) || isLeftSemiFilterJoin(joinType) ||
+      isRightJoin(joinType) || isRightSemiFilterJoin(joinType) ||
+      isRightSemiProjectJoin(joinType);
+}
+
+exec::BlockingReason CudfHashJoinProbe::isBlocked(ContinueFuture* future) {
+  if ((joinNode_->isRightJoin() || joinNode_->isRightSemiFilterJoin()) &&
+      hashObject_.has_value()) {
+    if (!future_.valid()) {
+      return exec::BlockingReason::kNotBlocked;
+    }
+    *future = std::move(future_);
+    return exec::BlockingReason::kWaitForJoinProbe;
+  }
+
+  if (hashObject_.has_value()) {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  auto joinBridge = operatorCtx_->task()->getCustomJoinBridge(
+      operatorCtx_->driverCtx()->splitGroupId, planNodeId());
+  auto cudfJoinBridge =
+      std::dynamic_pointer_cast<CudfHashJoinBridge>(joinBridge);
+  VELOX_CHECK_NOT_NULL(cudfJoinBridge);
+  VELOX_CHECK_NOT_NULL(future);
+  auto hashObject = cudfJoinBridge->hashOrFuture(future);
+
+  if (!hashObject.has_value()) {
+    if (CudfConfig::getInstance().debugEnabled) {
+      LOG(INFO) << "CudfHashJoinProbe is blocked, waiting for join build"
+                << std::endl;
+    }
+    return exec::BlockingReason::kWaitForJoinBuild;
+  }
+  hashObject_ = std::move(hashObject);
+  buildStream_ = cudfJoinBridge->getBuildStream();
+
+  // Lazy initialize matched flags only when build side is done
+  if (joinNode_->isRightJoin()) {
+    auto& rightTablesInit = hashObject_.value().first;
+    rightMatchedFlags_.clear();
+    rightMatchedFlags_.reserve(rightTablesInit.size());
+    auto initStream = cudfGlobalStreamPool().get_stream();
+    for (auto& rt : rightTablesInit) {
+      auto n = rt->num_rows();
+      auto false_scalar = cudf::numeric_scalar<bool>(false, true, initStream);
+      auto flags_col = cudf::make_column_from_scalar(
+          false_scalar, n, initStream, cudf::get_current_device_resource_ref());
+      rightMatchedFlags_.push_back(std::move(flags_col));
+    }
+    initStream.synchronize();
+  }
+  auto& rightTables = hashObject_.value().first;
+  // should be rightTable->numDistinct() but it needs compute,
+  // so we use num_rows()
+  if (rightTables[0]->num_rows() == 0) {
+    if (skipProbeOnEmptyBuild()) {
+      if (operatorCtx_->driverCtx()
+              ->queryConfig()
+              .hashProbeFinishEarlyOnEmptyBuild()) {
+        noMoreInput();
+      } else {
+        skipInput_ = true;
+      }
+    }
+  }
+  if ((joinNode_->isRightJoin() || joinNode_->isRightSemiFilterJoin()) &&
+      future_.valid()) {
+    *future = std::move(future_);
+    return exec::BlockingReason::kWaitForJoinProbe;
+  }
+  return exec::BlockingReason::kNotBlocked;
+}
+
+bool CudfHashJoinProbe::isFinished() {
+  auto const isFinished = finished_ || (noMoreInput_ && input_ == nullptr);
+
+  // Release hashObject_ if finished
+  if (isFinished) {
+    hashObject_.reset();
+  }
+  return isFinished;
+}
+
+std::unique_ptr<exec::Operator> CudfHashJoinBridgeTranslator::toOperator(
+    exec::DriverCtx* ctx,
+    int32_t id,
+    const core::PlanNodePtr& node) {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBridgeTranslator::toOperator"
+              << std::endl;
+  }
+  if (auto joinNode =
+          std::dynamic_pointer_cast<const core::HashJoinNode>(node)) {
+    return std::make_unique<CudfHashJoinProbe>(id, ctx, joinNode);
+  }
+  return nullptr;
+}
+
+std::unique_ptr<exec::JoinBridge> CudfHashJoinBridgeTranslator::toJoinBridge(
+    const core::PlanNodePtr& node) {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBridgeTranslator::toJoinBridge"
+              << std::endl;
+  }
+  if (auto joinNode =
+          std::dynamic_pointer_cast<const core::HashJoinNode>(node)) {
+    auto joinBridge = std::make_unique<CudfHashJoinBridge>();
+    return joinBridge;
+  }
+  return nullptr;
+}
+
+exec::OperatorSupplier CudfHashJoinBridgeTranslator::toOperatorSupplier(
+    const core::PlanNodePtr& node) {
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Calling CudfHashJoinBridgeTranslator::toOperatorSupplier"
+              << std::endl;
+  }
+  if (auto joinNode =
+          std::dynamic_pointer_cast<const core::HashJoinNode>(node)) {
+    return [joinNode](int32_t operatorId, exec::DriverCtx* ctx) {
+      return std::make_unique<CudfHashJoinBuild>(operatorId, ctx, joinNode);
+    };
+  }
+  return nullptr;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfHashJoin.h b/velox/experimental/cudf/exec/CudfHashJoin.h
new file mode 100644
index 000000000000..bce949ac15df
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfHashJoin.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/JoinBridge.h"
+#include "velox/exec/Operator.h"
+#include "velox/vector/ComplexVector.h"
+
+#include <cudf/ast/expressions.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/join/hash_join.hpp>
+#include <cudf/table/table.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+
+#include <memory>
+
+namespace facebook::velox::cudf_velox {
+
+class CudaEvent;
+
+/**
+ * @brief Bridge for transferring build-side hash tables between build and probe
+ * operators.
+ *
+ * This bridge manages the lifecycle of CUDF hash join objects and ensures
+ * proper synchronization between build and probe phases. It stores the
+ * constructed hash tables and hash join objects created from build-side data,
+ * making them available to probe operators across different driver threads.
+ *
+ * The bridge handles batched hash tables when build data exceeds
+ * cudf::size_type limits, and manages CUDA stream coordination between build
+ * and probe operations.
+ */
+class CudfHashJoinBridge : public exec::JoinBridge {
+ public:
+  // The bridge transfers all build side batches and the hash join objects
+  // constructed from them to the probe operator
+  /** @brief Hash tables paired with their corresponding join objects for
+   * batched processing */
+  using hash_type = std::pair<
+      std::vector<std::shared_ptr<cudf::table>>,
+      std::vector<std::shared_ptr<cudf::hash_join>>>;
+
+  void setHashTable(std::optional<hash_type> hashObject);
+
+  std::optional<hash_type> hashOrFuture(ContinueFuture* future);
+
+  // Store and retrieve the CUDA stream used for building the hash join.
+  void setBuildStream(rmm::cuda_stream_view buildStream);
+
+  std::optional<rmm::cuda_stream_view> getBuildStream();
+
+ private:
+  /** @brief Hash tables and join objects transferred from build to probe
+   * operators */
+  std::optional<hash_type> hashObject_;
+  /** @brief CUDA stream used by build operator for proper synchronization */
+  std::optional<rmm::cuda_stream_view> buildStream_;
+};
+
+/**
+ * @brief Build operator that constructs CUDF hash tables from build-side input
+ * data.
+ *
+ * This operator accumulates all build-side input batches and constructs hash
+ * tables when all input is received. It handles batching when data exceeds
+ * cudf::size_type limits and coordinates with other driver threads to ensure
+ * only one driver performs the final hash table construction. The constructed
+ * hash tables are transferred to probe operators via CudfHashJoinBridge.
+ */
+class CudfHashJoinBuild : public exec::Operator, public NvtxHelper {
+ public:
+  CudfHashJoinBuild(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::HashJoinNode> joinNode);
+
+  void addInput(RowVectorPtr input) override;
+
+  bool needsInput() const override;
+
+  RowVectorPtr getOutput() override;
+
+  void noMoreInput() override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* future) override;
+
+  bool isFinished() override;
+
+ private:
+  std::shared_ptr<const core::HashJoinNode> joinNode_;
+  std::vector<CudfVectorPtr> inputs_;
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+};
+
+/**
+ * @brief Probe operator that performs CUDF hash join operations on probe-side
+ * input.
+ *
+ * This operator receives hash tables from CudfHashJoinBuild via the bridge and
+ * performs join operations on probe-side input data. It supports all standard
+ * join types (inner, left, right, anti, semi) with optional filter conditions.
+ * The operator handles stream synchronization between build and probe phases,
+ * manages right join state across multiple drivers, and supports batched
+ * processing for large datasets.
+ */
+class CudfHashJoinProbe : public exec::Operator, public NvtxHelper {
+ public:
+  using hash_type = CudfHashJoinBridge::hash_type;
+
+  CudfHashJoinProbe(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      std::shared_ptr<const core::HashJoinNode> joinNode);
+
+  bool needsInput() const override;
+
+  void addInput(RowVectorPtr input) override;
+
+  void noMoreInput() override;
+
+  RowVectorPtr getOutput() override;
+
+  bool skipProbeOnEmptyBuild() const;
+
+  exec::BlockingReason isBlocked(ContinueFuture* future) override;
+
+  static bool isSupportedJoinType(core::JoinType joinType) {
+    return joinType == core::JoinType::kInner ||
+        joinType == core::JoinType::kLeft ||
+        joinType == core::JoinType::kAnti ||
+        joinType == core::JoinType::kLeftSemiFilter ||
+        joinType == core::JoinType::kRight ||
+        joinType == core::JoinType::kRightSemiFilter;
+  }
+
+  bool isFinished() override;
+
+ private:
+  std::shared_ptr<const core::HashJoinNode> joinNode_;
+  /** @brief Hash tables and join objects received from build operator */
+  std::optional<hash_type> hashObject_;
+
+  // Filter related members
+  /** @brief CUDF AST tree for join filter evaluation */
+  cudf::ast::tree tree_;
+  /** @brief Scalar values used in filter expressions */
+  std::vector<std::unique_ptr<cudf::scalar>> scalars_;
+
+  bool rightPrecomputed_{false};
+
+  // Batched probe inputs needed for right join
+  std::vector<CudfVectorPtr> inputs_;
+  ContinueFuture future_{ContinueFuture::makeEmpty()};
+
+  /** @brief Column indices for join keys in left (probe) table */
+  std::vector<cudf::size_type> leftKeyIndices_;
+  /** @brief Column indices for join keys in right (build) table */
+  std::vector<cudf::size_type> rightKeyIndices_;
+  /** @brief Column indices to gather from left table for output */
+  std::vector<cudf::size_type> leftColumnIndicesToGather_;
+  /** @brief Column indices to gather from right table for output */
+  std::vector<cudf::size_type> rightColumnIndicesToGather_;
+  /** @brief Output column positions for left table columns */
+  std::vector<size_t> leftColumnOutputIndices_;
+  /** @brief Output column positions for right table columns */
+  std::vector<size_t> rightColumnOutputIndices_;
+  bool finished_{false};
+
+  // Copied from HashProbe.h
+  // Indicates whether to skip probe input data processing or not. It only
+  // applies for a specific set of join types (see skipProbeOnEmptyBuild()), and
+  // the build table is empty and the probe input is read from non-spilled
+  // source. This ensures the hash probe operator keeps running until all the
+  // probe input from the sources have been processed. It prevents the exchange
+  // hanging problem at the producer side caused by the early query finish.
+  bool skipInput_{false};
+
+  /** @brief CUDA stream from build operator for synchronization */
+  std::optional<rmm::cuda_stream_view> buildStream_;
+  /** @brief CUDA event for coordinating stream synchronization */
+  std::unique_ptr<CudaEvent> cudaEvent_;
+
+  // Streaming right join state
+  // Per-build-table flags indicating whether a build row has had at least one
+  // left match.
+  /** @brief Flags tracking which build rows have been matched (for right joins)
+   */
+  std::vector<std::unique_ptr<cudf::column>> rightMatchedFlags_;
+
+  // For Right joins, only one driver collects the unmatched rows mask and
+  // emits. This value is set true only for that driver. See noMoreInput
+  bool isLastDriver_{false};
+
+  static constexpr auto oobPolicy = cudf::out_of_bounds_policy::NULLIFY;
+  /**
+   * @brief Performs inner join between probe table and all build tables.
+   * @param leftTable Probe-side table to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> innerJoin(
+      std::unique_ptr<cudf::table> const& leftTable,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs left join between probe table and all build tables.
+   * @param leftTable Probe-side table to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> leftJoin(
+      std::unique_ptr<cudf::table> const& leftTable,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs right join between probe table and all build tables.
+   * @param leftTable Probe-side table to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> rightJoin(
+      std::unique_ptr<cudf::table> const& leftTable,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs left semi filter join between probe table and all build
+   * tables.
+   * @param leftTable Probe-side table to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> leftSemiFilterJoin(
+      std::unique_ptr<cudf::table> const& leftTable,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs right semi filter join between probe table and all build
+   * tables.
+   * @param leftTable Probe-side table to join
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> rightSemiFilterJoin(
+      std::unique_ptr<cudf::table> const& leftTable,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Performs anti join between probe table and all build tables.
+   * @param leftTable Probe-side table to join (moved)
+   * @param stream CUDA stream for operations
+   * @return Vector of result tables (multiple if build data was batched)
+   */
+  std::vector<std::unique_ptr<cudf::table>> antiJoin(
+      std::unique_ptr<cudf::table>&& leftTable,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Constructs join output table without applying filter conditions.
+   * @param leftTableView Input probe table view
+   * @param leftIndicesCol Column of indices into left table
+   * @param rightTableView Input build table view
+   * @param rightIndicesCol Column of indices into right table
+   * @param stream CUDA stream for operations
+   * @return Join result table with gathered columns from both sides
+   */
+  std::unique_ptr<cudf::table> unfilteredOutput(
+      cudf::table_view leftTableView,
+      cudf::column_view leftIndicesCol,
+      cudf::table_view rightTableView,
+      cudf::column_view rightIndicesCol,
+      rmm::cuda_stream_view stream);
+  /**
+   * @brief Constructs join output table with filter condition applied.
+   * @param leftTableView Input probe table view
+   * @param leftIndicesCol Column of indices into left table
+   * @param rightTableView Input build table view
+   * @param rightIndicesCol Column of indices into right table
+   * @param func Filter function to apply to joined data
+   * @param stream CUDA stream for operations
+   * @return Filtered join result table
+   */
+  std::unique_ptr<cudf::table> filteredOutput(
+      cudf::table_view leftTableView,
+      cudf::column_view leftIndicesCol,
+      cudf::table_view rightTableView,
+      cudf::column_view rightIndicesCol,
+      std::function<std::vector<std::unique_ptr<cudf::column>>(
+          std::vector<std::unique_ptr<cudf::column>>&&,
+          cudf::column_view)> func,
+      rmm::cuda_stream_view stream);
+};
+
+/**
+ * @brief Factory for creating CUDF hash join operators and bridges from plan
+ * nodes.
+ *
+ * This translator converts HashJoinNode plan nodes into the appropriate
+ * CUDF-specific operators and bridges. It creates CudfHashJoinProbe operators
+ * for probe-side processing, CudfHashJoinBuild operators for build-side
+ * processing, and CudfHashJoinBridge instances for coordinating between them.
+ */
+class CudfHashJoinBridgeTranslator : public exec::Operator::PlanNodeTranslator {
+ public:
+  std::unique_ptr<exec::Operator>
+  toOperator(exec::DriverCtx* ctx, int32_t id, const core::PlanNodePtr& node);
+
+  std::unique_ptr<exec::JoinBridge> toJoinBridge(const core::PlanNodePtr& node);
+
+  exec::OperatorSupplier toOperatorSupplier(const core::PlanNodePtr& node);
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfLimit.cpp b/velox/experimental/cudf/exec/CudfLimit.cpp
new file mode 100644
index 000000000000..7cf320c89a61
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfLimit.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/cudf/exec/CudfLimit.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include <cudf/copying.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+CudfLimit::CudfLimit(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::LimitNode>& limitNode)
+    : Operator(
+          driverCtx,
+          limitNode->outputType(),
+          operatorId,
+          limitNode->id(),
+          "CudfLimit"),
+      NvtxHelper(
+          nvtx3::rgb{112, 128, 144}, // Slate Gray
+          operatorId,
+          fmt::format("[{}]", limitNode->id())),
+      remainingOffset_{limitNode->offset()},
+      remainingLimit_{limitNode->count()} {
+  isIdentityProjection_ = true;
+
+  const auto numColumns = limitNode->outputType()->size();
+  identityProjections_.reserve(numColumns);
+  for (column_index_t i = 0; i < numColumns; ++i) {
+    identityProjections_.emplace_back(i, i);
+  }
+}
+
+bool CudfLimit::needsInput() const {
+  return !finished_ && input_ == nullptr;
+}
+
+void CudfLimit::addInput(RowVectorPtr input) {
+  VELOX_CHECK_NULL(input_);
+  input_ = input;
+}
+
+RowVectorPtr CudfLimit::getOutput() {
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  if (input_ == nullptr || (remainingOffset_ == 0 && remainingLimit_ == 0)) {
+    return nullptr;
+  }
+
+  const auto inputSize = input_->size();
+
+  if (remainingOffset_ >= inputSize) {
+    remainingOffset_ -= inputSize;
+    input_ = nullptr;
+    return nullptr;
+  }
+
+  auto cudfInput = std::dynamic_pointer_cast<cudf_velox::CudfVector>(input_);
+
+  // This is the case where the offset lies in the middle of the current batch
+  // we want to start outputting rows from the middle of the input.
+  if (remainingOffset_ > 0) {
+    // Return a subset of input_ rows.
+    const auto outputSize =
+        std::min(inputSize - remainingOffset_, remainingLimit_);
+
+    auto slicedTable = cudf::slice(
+        cudfInput->getTableView(),
+        {static_cast<int>(remainingOffset_),
+         static_cast<int>(remainingOffset_ + outputSize)},
+        cudfInput->stream());
+
+    auto materializedTable =
+        std::make_unique<cudf::table>(slicedTable[0], cudfInput->stream());
+
+    remainingOffset_ = 0;
+    remainingLimit_ -= outputSize;
+    if (remainingLimit_ == 0) {
+      finished_ = true;
+    }
+    auto output = std::make_shared<cudf_velox::CudfVector>(
+        input_->pool(),
+        input_->type(),
+        outputSize,
+        std::move(materializedTable),
+        cudfInput->stream());
+    input_.reset();
+    return output;
+  }
+
+  if (remainingLimit_ <= inputSize) {
+    finished_ = true;
+  }
+
+  // This is the case where we want to output all rows from the input because
+  // the range we want to output exceeds the input in both directions.
+  if (remainingLimit_ >= inputSize) {
+    remainingLimit_ -= inputSize;
+    auto output = input_;
+    input_.reset();
+    return output;
+  }
+
+  // At this point, we have no offset but the limit is less than the input size.
+  // We want to slice from the beginning but till the middle of the input.
+  auto slicedTable = cudf::slice(
+      cudfInput->getTableView(),
+      {0, static_cast<int>(remainingLimit_)},
+      cudfInput->stream());
+
+  auto materializedTable =
+      std::make_unique<cudf::table>(slicedTable[0], cudfInput->stream());
+
+  auto output = std::make_shared<cudf_velox::CudfVector>(
+      input_->pool(),
+      input_->type(),
+      remainingLimit_,
+      std::move(materializedTable),
+      cudfInput->stream());
+  input_.reset();
+  remainingLimit_ = 0;
+  return output;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfLimit.h b/velox/experimental/cudf/exec/CudfLimit.h
new file mode 100644
index 000000000000..c6220e26f925
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfLimit.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/experimental/cudf/exec/NvtxHelper.h"
+
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::cudf_velox {
+class CudfLimit : public exec::Operator, public NvtxHelper {
+ public:
+  CudfLimit(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::LimitNode>& limitNode);
+
+  bool needsInput() const override;
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override {
+    return finished_ || (noMoreInput_ && input_ == nullptr);
+  }
+
+ private:
+  int64_t remainingOffset_;
+  int64_t remainingLimit_;
+  bool finished_{false};
+};
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfLocalPartition.cpp b/velox/experimental/cudf/exec/CudfLocalPartition.cpp
new file mode 100644
index 000000000000..bce2ee2a120d
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfLocalPartition.cpp
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/exec/CudfLocalPartition.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/exec/HashPartitionFunction.h"
+#include "velox/exec/Task.h"
+
+#include <cudf/copying.hpp>
+#include <cudf/partitioning.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+bool CudfLocalPartition::shouldReplace(
+    const std::shared_ptr<const core::LocalPartitionNode>& planNode) {
+  auto* hashFunctionSpec = dynamic_cast<const exec::HashPartitionFunctionSpec*>(
+      &planNode->partitionFunctionSpec());
+  // Only replace LocalPartition with CudfLocalPartition for hash partitioning.
+  // TODO: Round Robin Row-Wise Partitioning can be supported in future.
+  return hashFunctionSpec;
+}
+
+CudfLocalPartition::CudfLocalPartition(
+    int32_t operatorId,
+    exec::DriverCtx* ctx,
+    const std::shared_ptr<const core::LocalPartitionNode>& planNode)
+    : Operator(
+          ctx,
+          planNode->outputType(),
+          operatorId,
+          planNode->id(),
+          "CudfLocalPartition"),
+      NvtxHelper(
+          nvtx3::rgb{255, 215, 0}, // Gold
+          operatorId,
+          fmt::format("[{}]", planNode->id())),
+      queues_{
+          ctx->task->getLocalExchangeQueues(ctx->splitGroupId, planNode->id())},
+      numPartitions_{queues_.size()} {
+  // Following is IMO a hacky way to get the partition key indices. It is to
+  // workaround the fact that the partition spec constructs the hash function
+  // directly and has no public methods to get the partition key indices.
+
+  // When the operator is of type kRepartition, the partition spec is a string
+  // in the format "HASH(key1, key2, ...)"
+  // We're going to extract the keys between HASH( and ) and find their indices
+  // in the output row type.
+
+  // When operator is of type kGather, we don't need to store any partition key
+  // indices because we're going to merge all the incoming streams together.
+
+  // Get partition function specification string
+  std::string spec = planNode->partitionFunctionSpec().toString();
+  auto* hashFunctionSpec = dynamic_cast<const exec::HashPartitionFunctionSpec*>(
+      &planNode->partitionFunctionSpec());
+
+  // Only parse keys if it's a hash function
+  if (hashFunctionSpec) {
+    // Extract keys between HASH( and )
+    size_t start = spec.find("HASH(") + 5;
+    size_t end = spec.find(")", start);
+    if (start != std::string::npos && end != std::string::npos) {
+      std::string keysStr = spec.substr(start, end - start);
+
+      // Split by comma to get individual keys.
+      std::vector<std::string> keys;
+      size_t pos = 0;
+      while ((pos = keysStr.find(",")) != std::string::npos) {
+        std::string key = keysStr.substr(0, pos);
+        keys.push_back(key);
+        keysStr.erase(0, pos + 1);
+      }
+      keys.push_back(keysStr); // Add the last key.
+
+      // Find field indices for each key.
+      const auto& rowType = planNode->outputType();
+      for (const auto& key : keys) {
+        auto trimmedKey = key;
+        // Trim whitespace
+        trimmedKey.erase(0, trimmedKey.find_first_not_of(" "));
+        trimmedKey.erase(trimmedKey.find_last_not_of(" ") + 1);
+
+        auto fieldIndex = rowType->getChildIdx(trimmedKey);
+        partitionKeyIndices_.push_back(fieldIndex);
+      }
+    }
+    partitionFunctionType_ = PartitionFunctionType::kHash;
+  } else if (
+      numPartitions_ > 1 && spec.find("ROUND ROBIN") != std::string::npos) {
+    partitionFunctionType_ = PartitionFunctionType::kRoundRobin;
+  }
+  VELOX_CHECK(
+      numPartitions_ == 1 || partitionKeyIndices_.size() > 0 ||
+      partitionFunctionType_ == PartitionFunctionType::kRoundRobin);
+
+  // Since we're replacing the LocalPartition with CudfLocalPartition, the
+  // number of producers is already set. Adding producer only adds to a counter
+  // which we don't have to do again.
+  // Normally, this is what we'd have to do:
+  // for (auto& queue : queues_) {
+  //   queue->addProducer();
+  // }
+}
+
+void CudfLocalPartition::recordOutputStats(RowVectorPtr& input) {
+  {
+    auto lockedStats = stats_.wlock();
+    lockedStats->addOutputVector(input->estimateFlatSize(), input->size());
+  }
+}
+
+void CudfLocalPartition::flushVectorPool() {
+  // We reuse the LocalExchangeQueue from the CPU implementation. That impl
+  // stores used vectors in a vector pool for the CPU LocalPartition to re-use.
+  // CudfLocalPartition does not need it and does not extract it. This results
+  // in unnecessary extension of the lifetimes of vectors that were exchanged,
+  // resulting in kind of a memory leak.
+  // This is a hack to forcefully flush the vector pools.
+
+  for (auto& queue : queues_) {
+    queue->getVector();
+  }
+}
+
+void CudfLocalPartition::addInput(RowVectorPtr input) {
+  flushVectorPool();
+  VELOX_NVTX_OPERATOR_FUNC_RANGE();
+  recordOutputStats(input);
+  auto cudfVector = std::dynamic_pointer_cast<CudfVector>(input);
+  VELOX_CHECK(cudfVector, "Input must be a CudfVector");
+  auto stream = cudfVector->stream();
+
+  if (numPartitions_ > 1) {
+    auto [partitionedTable, partitionOffsets] = [&]() {
+      auto tableView = cudfVector->getTableView();
+      // Use cudf hash partitioning
+      if (partitionFunctionType_ == PartitionFunctionType::kHash) {
+        std::vector<cudf::size_type> partitionKeyIndices;
+        for (const auto& idx : partitionKeyIndices_) {
+          partitionKeyIndices.push_back(static_cast<cudf::size_type>(idx));
+        }
+
+        return cudf::hash_partition(
+            tableView,
+            partitionKeyIndices,
+            numPartitions_,
+            cudf::hash_id::HASH_MURMUR3,
+            cudf::DEFAULT_HASH_SEED,
+            stream);
+      } else if (partitionFunctionType_ == PartitionFunctionType::kRoundRobin) {
+        return cudf::round_robin_partition(
+            tableView, numPartitions_, counter_, stream);
+        counter_ = (counter_ + cudfVector->size()) % numPartitions_;
+      }
+      VELOX_FAIL("Unsupported partition function");
+    }();
+
+    VELOX_CHECK(partitionOffsets.size() == numPartitions_);
+    VELOX_CHECK(partitionOffsets[0] == 0);
+
+    // Erase first element since it's always 0 and we don't need it.
+    partitionOffsets.erase(partitionOffsets.begin());
+
+    auto partitionedTables =
+        cudf::split(partitionedTable->view(), partitionOffsets);
+
+    for (int i = 0; i < numPartitions_; ++i) {
+      auto partitionData = partitionedTables[i];
+      if (partitionData.num_rows() == 0) {
+        // Skip empty partitions.
+        continue;
+      }
+
+      ContinueFuture future;
+      // DM: We should investigate if keeping partitionedTables alive and using
+      // the table view in partitonedData is more efficient than creating a new
+      // table each time. Currently out of scope because it would need a new
+      // type of RowVector that can hold a table view and shared_ptr to the
+      // table.
+      auto blockingReason = queues_[i]->enqueue(
+          std::make_shared<CudfVector>(
+              pool(),
+              outputType_,
+              partitionData.num_rows(),
+              std::make_unique<cudf::table>(partitionData),
+              stream),
+          partitionData.num_rows(),
+          &future);
+      if (blockingReason != exec::BlockingReason::kNotBlocked) {
+        blockingReasons_.push_back(blockingReason);
+        futures_.push_back(std::move(future));
+      }
+    }
+  } else {
+    // Single partition case.
+    ContinueFuture future;
+    auto blockingReason =
+        queues_[0]->enqueue(input, input->retainedSize(), &future);
+    if (blockingReason != exec::BlockingReason::kNotBlocked) {
+      blockingReasons_.push_back(blockingReason);
+      futures_.push_back(std::move(future));
+    }
+  }
+}
+
+exec::BlockingReason CudfLocalPartition::isBlocked(ContinueFuture* future) {
+  if (!futures_.empty()) {
+    auto blockingReason = blockingReasons_.front();
+    *future = folly::collectAll(futures_.begin(), futures_.end()).unit();
+    futures_.clear();
+    blockingReasons_.clear();
+    return blockingReason;
+  }
+
+  return exec::BlockingReason::kNotBlocked;
+}
+
+void CudfLocalPartition::noMoreInput() {
+  Operator::noMoreInput();
+  for (const auto& queue : queues_) {
+    queue->noMoreData();
+  }
+}
+
+bool CudfLocalPartition::isFinished() {
+  if (!futures_.empty() || !noMoreInput_) {
+    return false;
+  }
+  flushVectorPool();
+
+  return true;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfLocalPartition.h b/velox/experimental/cudf/exec/CudfLocalPartition.h
new file mode 100644
index 000000000000..53a216d937a8
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfLocalPartition.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/experimental/cudf/exec/NvtxHelper.h"
+
+#include "velox/exec/LocalPartition.h"
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::cudf_velox {
+
+enum class PartitionFunctionType {
+  kHash,
+  kRoundRobin,
+};
+
+class CudfLocalPartition : public exec::Operator, public NvtxHelper {
+ public:
+  CudfLocalPartition(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::LocalPartitionNode>& planNode);
+
+  std::string toString() const override {
+    return fmt::format("CudfLocalPartition({})", numPartitions_);
+  }
+
+  void recordOutputStats(RowVectorPtr& input);
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override {
+    return nullptr;
+  }
+
+  /// Always true but the caller will check isBlocked before adding input, hence
+  /// the blocked state does not accumulate input.
+  bool needsInput() const override {
+    return true;
+  }
+
+  exec::BlockingReason isBlocked(ContinueFuture* future) override;
+
+  void noMoreInput() override;
+
+  bool isFinished() override;
+
+  static bool shouldReplace(
+      const std::shared_ptr<const core::LocalPartitionNode>& planNode);
+
+ private:
+  void flushVectorPool();
+
+ protected:
+  const std::vector<std::shared_ptr<exec::LocalExchangeQueue>> queues_;
+  const size_t numPartitions_;
+  PartitionFunctionType partitionFunctionType_;
+  size_t counter_{0};
+
+  std::vector<exec::BlockingReason> blockingReasons_;
+  std::vector<ContinueFuture> futures_;
+
+  std::vector<column_index_t> partitionKeyIndices_;
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfOperator.h b/velox/experimental/cudf/exec/CudfOperator.h
new file mode 100644
index 000000000000..de486eadd398
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfOperator.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/experimental/cudf/exec/NvtxHelper.h"
+
+#include "velox/core/PlanNode.h"
+
+namespace facebook::velox::cudf_velox {
+
+/// The user defined operator will inherit this operator, the operator accepts
+/// CudfOperator and output CudfVector.
+class CudfOperator : public NvtxHelper {
+ public:
+  CudfOperator(
+      int32_t operatorId,
+      const core::PlanNodeId& nodeId,
+      nvtx3::color color = nvtx3::rgb{160, 82, 45} /* Sienna */)
+      : facebook::velox::cudf_velox::NvtxHelper(
+            color,
+            operatorId,
+            fmt::format("[{}]", nodeId)) {}
+};
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfOrderBy.cpp b/velox/experimental/cudf/exec/CudfOrderBy.cpp
index d395ac9d0a9a..19935c3ab3c5 100644
--- a/velox/experimental/cudf/exec/CudfOrderBy.cpp
+++ b/velox/experimental/cudf/exec/CudfOrderBy.cpp
@@ -77,7 +77,7 @@ void CudfOrderBy::noMoreInput() {
   }
 
   auto stream = cudfGlobalStreamPool().get_stream();
-  auto tbl = getConcatenatedTable(inputs_, stream);
+  auto tbl = getConcatenatedTable(inputs_, outputType_, stream);
 
   // Release input data after synchronizing
   stream.synchronize();
diff --git a/velox/experimental/cudf/exec/CudfTopN.cpp b/velox/experimental/cudf/exec/CudfTopN.cpp
new file mode 100644
index 000000000000..5c44006d6e1b
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfTopN.cpp
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/CudfQueryConfig.h"
+#include "velox/experimental/cudf/exec/CudfTopN.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+
+#include <cudf/detail/copy.hpp>
+#include <cudf/detail/gather.hpp>
+#include <cudf/merge.hpp>
+#include <cudf/sorting.hpp>
+
+namespace facebook::velox::cudf_velox {
+CudfTopN::CudfTopN(
+    int32_t operatorId,
+    exec::DriverCtx* driverCtx,
+    const std::shared_ptr<const core::TopNNode>& topNNode)
+    : exec::Operator(
+          driverCtx,
+          topNNode->outputType(),
+          operatorId,
+          topNNode->id(),
+          "CudfTopN"),
+      NvtxHelper(
+          nvtx3::rgb{175, 238, 238}, // Pale Turquoise
+          operatorId,
+          fmt::format("[{}]", topNNode->id())),
+      count_(topNNode->count()),
+      topNNode_(topNNode) {
+  kBatchSize_ = driverCtx->queryConfig().get<int32_t>(
+      CudfQueryConfig::kCudfTopNBatchSize, kBatchSize_);
+  const auto numColumns{outputType_->children().size()};
+  const auto numSortingKeys{topNNode->sortingKeys().size()};
+  std::vector<bool> isSortingKey(numColumns);
+  sortKeys_.reserve(numSortingKeys);
+  columnOrder_.reserve(numSortingKeys);
+  nullOrder_.reserve(numSortingKeys);
+
+  for (int i = 0; i < numSortingKeys; ++i) {
+    const auto channel =
+        exec::exprToChannel(topNNode->sortingKeys()[i].get(), outputType_);
+    VELOX_CHECK(
+        channel != kConstantChannel,
+        "TopN doesn't allow constant sorting keys");
+    sortKeys_.push_back(channel);
+    isSortingKey[channel] = true;
+    auto const& sortingOrder = topNNode->sortingOrders()[i];
+    columnOrder_.push_back(
+        sortingOrder.isAscending() ? cudf::order::ASCENDING
+                                   : cudf::order::DESCENDING);
+    nullOrder_.push_back(
+        (sortingOrder.isNullsFirst() ^ !sortingOrder.isAscending())
+            ? cudf::null_order::BEFORE
+            : cudf::null_order::AFTER);
+  }
+}
+
+CudfVectorPtr CudfTopN::mergeTopK(
+    std::vector<CudfVectorPtr> topNBatches,
+    int32_t k,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  std::vector<cudf::table_view> tableViews;
+  for (const auto& batch : topNBatches) {
+    tableViews.push_back(batch->getTableView());
+  }
+  auto mergedTable =
+      cudf::merge(tableViews, sortKeys_, columnOrder_, nullOrder_, stream, mr);
+  // slice it
+  auto topk =
+      cudf::split(
+          mergedTable->view(), {std::min(k, mergedTable->num_rows())}, stream)
+          .front();
+  auto const size = topk.num_rows();
+  return std::make_shared<CudfVector>(
+      topNBatches[0]->pool(),
+      outputType_,
+      size,
+      std::make_unique<cudf::table>(topk),
+      stream);
+}
+
+std::unique_ptr<cudf::table> CudfTopN::getTopK(
+    cudf::table_view const& values,
+    int32_t k,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  auto keys = values.select(sortKeys_);
+  auto const indices =
+      cudf::stable_sorted_order(keys, columnOrder_, nullOrder_, stream, mr);
+  auto const kIndices =
+      cudf::split(indices->view(), {std::min(k, indices->size())}, stream)
+          .front();
+  return cudf::detail::gather(
+      values,
+      kIndices,
+      cudf::out_of_bounds_policy::DONT_CHECK,
+      cudf::detail::negative_index_policy::NOT_ALLOWED,
+      stream,
+      mr);
+}
+
+// helper to get topk of a table
+CudfVectorPtr CudfTopN::getTopKBatch(CudfVectorPtr cudfInput, int32_t k) {
+  if (k == 0 || cudfInput->size() == 0) {
+    return nullptr;
+  }
+  auto stream = cudfInput->stream();
+  auto mr = cudf::get_current_device_resource_ref();
+  auto values = cudfInput->getTableView();
+  auto result = getTopK(values, k, stream, mr);
+  auto const size = result->num_rows();
+  return std::make_shared<CudfVector>(
+      cudfInput->pool(), cudfInput->type(), size, std::move(result), stream);
+}
+
+void CudfTopN::addInput(RowVectorPtr input) {
+  if (count_ == 0 || input->size() == 0) {
+    return;
+  }
+
+  auto cudfInput = std::dynamic_pointer_cast<CudfVector>(input);
+  VELOX_CHECK_NOT_NULL(cudfInput);
+  // Take topk of each input, add to batch.
+  // If got kBatchSize_ batches, concat batches and topk once.
+  // During getOutput, concat batches and topk once.
+  topNBatches_.push_back(getTopKBatch(cudfInput, count_));
+  // sum of sizes of topNBatches_ >= count_, then concat and topk once.
+  auto totalSize = std::accumulate(
+      topNBatches_.begin(),
+      topNBatches_.end(),
+      0,
+      [](int32_t sum, const auto& batch) {
+        return sum + (batch ? batch->size() : 0);
+      });
+  if (topNBatches_.size() >= kBatchSize_ and totalSize >= count_) {
+    auto stream = cudfGlobalStreamPool().get_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+
+    auto result = mergeTopK(topNBatches_, count_, stream, mr);
+    topNBatches_.clear();
+    topNBatches_.push_back(std::move(result));
+  }
+}
+
+RowVectorPtr CudfTopN::getOutput() {
+  if (finished_ || !noMoreInput_) {
+    return nullptr;
+  }
+  if (topNBatches_.empty()) {
+    finished_ = noMoreInput_;
+    return nullptr;
+  }
+
+  auto stream = topNBatches_[0]->stream();
+  auto mr = cudf::get_current_device_resource_ref();
+  auto result = mergeTopK(topNBatches_, count_, stream, mr);
+  topNBatches_.clear();
+  finished_ = noMoreInput_ && topNBatches_.empty();
+  return result;
+}
+
+void CudfTopN::noMoreInput() {
+  Operator::noMoreInput();
+  if (topNBatches_.empty()) {
+    finished_ = true;
+    return;
+  }
+}
+
+bool CudfTopN::isFinished() {
+  return finished_;
+}
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/CudfTopN.h b/velox/experimental/cudf/exec/CudfTopN.h
new file mode 100644
index 000000000000..99144bf2a5fa
--- /dev/null
+++ b/velox/experimental/cudf/exec/CudfTopN.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/experimental/cudf/exec/NvtxHelper.h"
+#include "velox/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/exec/Operator.h"
+
+namespace facebook::velox::cudf_velox {
+
+class CudfTopN : public exec::Operator, public NvtxHelper {
+ public:
+  CudfTopN(
+      int32_t operatorId,
+      exec::DriverCtx* driverCtx,
+      const std::shared_ptr<const core::TopNNode>& topNNode);
+
+  bool needsInput() const override {
+    return !noMoreInput_;
+  }
+
+  void addInput(RowVectorPtr input) override;
+
+  RowVectorPtr getOutput() override;
+
+  void noMoreInput() override;
+
+  exec::BlockingReason isBlocked(ContinueFuture* /*future*/) override {
+    return exec::BlockingReason::kNotBlocked;
+  }
+
+  bool isFinished() override;
+
+ private:
+  const int32_t count_; // N value of TopN
+
+  std::shared_ptr<const core::TopNNode> topNNode_;
+  std::vector<cudf::size_type> sortKeys_;
+  std::vector<cudf::order> columnOrder_;
+  std::vector<cudf::null_order> nullOrder_;
+
+  CudfVectorPtr mergeTopK(
+      std::vector<CudfVectorPtr> topNBatches,
+      int32_t k,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr);
+
+  CudfVectorPtr getTopKBatch(CudfVectorPtr cudfInput, int32_t k);
+  std::unique_ptr<cudf::table> getTopK(
+      cudf::table_view const& values,
+      int32_t k,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr);
+
+  // As the inputs are added to TopN operator, we use topNBatches_
+  // (a vector of CudfVectorPtrs) to keep track of the topN rows of each input.
+  // We only update the topNBatches_ if number of batches >= 5 and number of
+  // rows in topNBatches_ >= count_. Once all inputs are available, we concat
+  // the topNBatches_ and get the topN rows.
+  // config value kCudfTopNBatchSize is maximum number of batches to hold.
+  std::vector<CudfVectorPtr> topNBatches_;
+  int32_t kBatchSize_{5};
+  bool finished_ = false;
+};
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/DebugUtil.cpp b/velox/experimental/cudf/exec/DebugUtil.cpp
new file mode 100644
index 000000000000..b1153c17c0db
--- /dev/null
+++ b/velox/experimental/cudf/exec/DebugUtil.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/experimental/cudf/exec/DebugUtil.h"
+#include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+
+namespace facebook::velox::cudf_velox {
+
+std::string DebugUtil::toString(
+    const cudf::table_view& table,
+    rmm::cuda_stream_view stream,
+    vector_size_t from,
+    vector_size_t to) {
+  auto rowVector = with_arrow::toVeloxColumn(table, pool_.get(), "", stream);
+  stream.synchronize();
+  return rowVector->toString(from, to);
+}
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/DebugUtil.h b/velox/experimental/cudf/exec/DebugUtil.h
new file mode 100644
index 000000000000..7fc4de0ea4cd
--- /dev/null
+++ b/velox/experimental/cudf/exec/DebugUtil.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/experimental/cudf/vector/CudfVector.h"
+
+namespace facebook::velox::cudf_velox {
+class DebugUtil {
+ public:
+  std::string toString(
+      const cudf::table_view& table,
+      rmm::cuda_stream_view stream,
+      vector_size_t from,
+      vector_size_t to);
+
+ private:
+  std::shared_ptr<memory::MemoryPool> rootPool_{
+      memory::memoryManager()->addRootPool()};
+  std::shared_ptr<memory::MemoryPool> pool_{
+      rootPool_->addLeafChild("debug_util")};
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/ToCudf.cpp b/velox/experimental/cudf/exec/ToCudf.cpp
index 2c1fc91cd416..96da4857cc4b 100644
--- a/velox/experimental/cudf/exec/ToCudf.cpp
+++ b/velox/experimental/cudf/exec/ToCudf.cpp
@@ -14,19 +14,40 @@
  * limitations under the License.
  */
 
+#include "velox/experimental/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
+#include "velox/experimental/cudf/exec/CudfAssignUniqueId.h"
 #include "velox/experimental/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/CudfFilterProject.h"
 #include "velox/experimental/cudf/exec/CudfHashAggregation.h"
+#include "velox/experimental/cudf/exec/CudfHashJoin.h"
+#include "velox/experimental/cudf/exec/CudfLimit.h"
+#include "velox/experimental/cudf/exec/CudfLocalPartition.h"
+#include "velox/experimental/cudf/exec/CudfOperator.h"
 #include "velox/experimental/cudf/exec/CudfOrderBy.h"
+#include "velox/experimental/cudf/exec/CudfTopN.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
 #include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
 
+#include "folly/Conv.h"
+#include "velox/exec/AssignUniqueId.h"
+#include "velox/exec/CallbackSink.h"
 #include "velox/exec/Driver.h"
 #include "velox/exec/FilterProject.h"
 #include "velox/exec/HashAggregation.h"
 #include "velox/exec/HashBuild.h"
 #include "velox/exec/HashProbe.h"
+#include "velox/exec/Limit.h"
 #include "velox/exec/Operator.h"
 #include "velox/exec/OrderBy.h"
+#include "velox/exec/StreamingAggregation.h"
+#include "velox/exec/TableScan.h"
+#include "velox/exec/Task.h"
+#include "velox/exec/TopN.h"
+#include "velox/exec/Values.h"
 
 #include <cudf/detail/nvtx/ranges.hpp>
 
@@ -34,9 +55,7 @@
 
 #include <iostream>
 
-DEFINE_bool(velox_cudf_enabled, true, "Enable cuDF-Velox acceleration");
-DEFINE_string(velox_cudf_memory_resource, "async", "Memory resource for cuDF");
-DEFINE_bool(velox_cudf_debug, false, "Enable debug printing");
+static const std::string kCudfAdapterName = "cuDF";
 
 namespace facebook::velox::cudf_velox {
 
@@ -49,22 +68,19 @@ bool isAnyOf(const Base* p) {
 
 } // namespace
 
-bool CompileState::compile() {
+bool CompileState::compile(bool allowCpuFallback) {
   auto operators = driver_.operators();
 
-  if (FLAGS_velox_cudf_debug) {
-    std::cout << "Operators before adapting for cuDF: count ["
+  if (CudfConfig::getInstance().debugEnabled) {
+    LOG(INFO) << "Operators before adapting for cuDF: count ["
               << operators.size() << "]" << std::endl;
     for (auto& op : operators) {
-      std::cout << "  Operator: ID " << op->operatorId() << ": "
+      LOG(INFO) << "  Operator: ID " << op->operatorId() << ": "
                 << op->toString() << std::endl;
     }
+    LOG(INFO) << "allowCpuFallback = " << allowCpuFallback << std::endl;
   }
 
-  // Make sure operator states are initialized.  We will need to inspect some of
-  // them during the transformation.
-  driver_.initializeOperators();
-
   bool replacementsMade = false;
   auto ctx = driver_.driverCtx();
 
@@ -82,23 +98,123 @@ bool CompileState::compile() {
     return driverFactory_.consumerNode;
   };
 
-  auto isSupportedGpuOperator = [](const exec::Operator* op) {
-    return isAnyOf<exec::OrderBy, exec::HashAggregation>(op);
+  auto isTableScanSupported = [getPlanNode](const exec::Operator* op) {
+    if (!isAnyOf<exec::TableScan>(op)) {
+      return false;
+    }
+    auto tableScanNode = std::dynamic_pointer_cast<const core::TableScanNode>(
+        getPlanNode(op->planNodeId()));
+    VELOX_CHECK(tableScanNode != nullptr);
+    auto const& connector = velox::connector::getConnector(
+        tableScanNode->tableHandle()->connectorId());
+    auto cudfHiveConnector = std::dynamic_pointer_cast<
+        facebook::velox::cudf_velox::connector::hive::CudfHiveConnector>(
+        connector);
+    if (!cudfHiveConnector) {
+      return false;
+    }
+    // TODO (dm): we need to ask CudfHiveConnector whether this table handle is
+    // supported by it. It may choose to produce a HiveDatasource.
+    return true;
   };
 
+  auto isFilterProjectSupported = [getPlanNode, ctx](const exec::Operator* op) {
+    if (auto filterProjectOp = dynamic_cast<const exec::FilterProject*>(op)) {
+      auto projectPlanNode = std::dynamic_pointer_cast<const core::ProjectNode>(
+          getPlanNode(filterProjectOp->planNodeId()));
+      auto filterNode = filterProjectOp->filterNode();
+
+      // Check filter separately.
+      if (filterNode) {
+        if (!canBeEvaluatedByCudf(
+                {filterNode->filter()}, ctx->task->queryCtx().get())) {
+          return false;
+        }
+      }
+
+      // Check projects separately.
+      if (projectPlanNode) {
+        if (!canBeEvaluatedByCudf(
+                projectPlanNode->projections(), ctx->task->queryCtx().get())) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  };
+
+  auto isJoinSupported = [getPlanNode](const exec::Operator* op) {
+    if (!isAnyOf<exec::HashBuild, exec::HashProbe>(op)) {
+      return false;
+    }
+    auto planNode = std::dynamic_pointer_cast<const core::HashJoinNode>(
+        getPlanNode(op->planNodeId()));
+    if (!planNode) {
+      return false;
+    }
+    if (!CudfHashJoinProbe::isSupportedJoinType(planNode->joinType())) {
+      return false;
+    }
+    // disabling null-aware anti join with filter until we implement it right
+    if (planNode->joinType() == core::JoinType::kAnti and
+        planNode->isNullAware() and planNode->filter()) {
+      return false;
+    }
+    return true;
+  };
+
+  auto isSupportedGpuOperator =
+      [isFilterProjectSupported, isJoinSupported, isTableScanSupported](
+          const exec::Operator* op) {
+        return isAnyOf<
+                   exec::OrderBy,
+                   exec::TopN,
+                   exec::HashAggregation,
+                   exec::StreamingAggregation,
+                   exec::Limit,
+                   exec::LocalPartition,
+                   exec::LocalExchange,
+                   exec::AssignUniqueId,
+                   CudfOperator>(op) ||
+            isFilterProjectSupported(op) || isJoinSupported(op) ||
+            isTableScanSupported(op);
+      };
+
   std::vector<bool> isSupportedGpuOperators(operators.size());
   std::transform(
       operators.begin(),
       operators.end(),
       isSupportedGpuOperators.begin(),
       isSupportedGpuOperator);
-
-  auto acceptsGpuInput = [](const exec::Operator* op) {
-    return isAnyOf<exec::OrderBy, exec::HashAggregation>(op);
+  auto acceptsGpuInput = [isFilterProjectSupported,
+                          isJoinSupported](const exec::Operator* op) {
+    return isAnyOf<
+               exec::OrderBy,
+               exec::TopN,
+               exec::HashAggregation,
+               exec::StreamingAggregation,
+               exec::Limit,
+               exec::LocalPartition,
+               exec::AssignUniqueId,
+               CudfOperator>(op) ||
+        isFilterProjectSupported(op) || isJoinSupported(op);
   };
-
-  auto producesGpuOutput = [](const exec::Operator* op) {
-    return isAnyOf<exec::OrderBy, exec::HashAggregation>(op);
+  auto producesGpuOutput = [isFilterProjectSupported,
+                            isJoinSupported,
+                            isTableScanSupported](const exec::Operator* op) {
+    return isAnyOf<
+               exec::OrderBy,
+               exec::TopN,
+               exec::HashAggregation,
+               exec::StreamingAggregation,
+               exec::Limit,
+               exec::LocalExchange,
+               exec::AssignUniqueId,
+               CudfOperator>(op) ||
+        isFilterProjectSupported(op) ||
+        (isAnyOf<exec::HashProbe>(op) && isJoinSupported(op)) ||
+        (isTableScanSupported(op));
   };
 
   int32_t operatorsOffset = 0;
@@ -121,52 +237,187 @@ bool CompileState::compile() {
     auto id = oper->operatorId();
     if (previousOperatorIsNotGpu and acceptsGpuInput(oper)) {
       auto planNode = getPlanNode(oper->planNodeId());
-      replaceOp.push_back(std::make_unique<CudfFromVelox>(
-          id, planNode->outputType(), ctx, planNode->id() + "-from-velox"));
-      replaceOp.back()->initialize();
+      replaceOp.push_back(
+          std::make_unique<CudfFromVelox>(
+              id, planNode->outputType(), ctx, planNode->id() + "-from-velox"));
+    }
+    if (not replaceOp.empty()) {
+      // from-velox only, because need to inserted before current operator.
+      operatorsOffset += replaceOp.size();
+      [[maybe_unused]] auto replaced = driverFactory_.replaceOperators(
+          driver_,
+          replacingOperatorIndex,
+          replacingOperatorIndex,
+          std::move(replaceOp));
+      replacingOperatorIndex = operatorIndex + operatorsOffset;
+      replaceOp.clear();
+      replacementsMade = true;
     }
 
-    if (auto* orderByOp = dynamic_cast<exec::OrderBy*>(oper)) {
+    // This is used to denote if the current operator is kept or replaced.
+    auto keepOperator = 0;
+    // TableScan
+    if (isTableScanSupported(oper)) {
+      auto planNode = std::dynamic_pointer_cast<const core::TableScanNode>(
+          getPlanNode(oper->planNodeId()));
+      VELOX_CHECK(planNode != nullptr);
+      keepOperator = 1;
+    } else if (isJoinSupported(oper)) {
+      if (auto joinBuildOp = dynamic_cast<exec::HashBuild*>(oper)) {
+        auto planNode = std::dynamic_pointer_cast<const core::HashJoinNode>(
+            getPlanNode(joinBuildOp->planNodeId()));
+        VELOX_CHECK(planNode != nullptr);
+        // From-Velox (optional)
+        replaceOp.push_back(
+            std::make_unique<CudfHashJoinBuild>(id, ctx, planNode));
+      } else if (auto joinProbeOp = dynamic_cast<exec::HashProbe*>(oper)) {
+        auto planNode = std::dynamic_pointer_cast<const core::HashJoinNode>(
+            getPlanNode(joinProbeOp->planNodeId()));
+        VELOX_CHECK(planNode != nullptr);
+        // From-Velox (optional)
+        replaceOp.push_back(
+            std::make_unique<CudfHashJoinProbe>(id, ctx, planNode));
+        // To-Velox (optional)
+      }
+    } else if (auto orderByOp = dynamic_cast<exec::OrderBy*>(oper)) {
       auto id = orderByOp->operatorId();
       auto planNode = std::dynamic_pointer_cast<const core::OrderByNode>(
           getPlanNode(orderByOp->planNodeId()));
       VELOX_CHECK(planNode != nullptr);
       replaceOp.push_back(std::make_unique<CudfOrderBy>(id, ctx, planNode));
-      replaceOp.back()->initialize();
-    } else if (auto hashAggOp = dynamic_cast<exec::HashAggregation*>(oper)) {
+    } else if (auto topNOp = dynamic_cast<exec::TopN*>(oper)) {
+      auto planNode = std::dynamic_pointer_cast<const core::TopNNode>(
+          getPlanNode(topNOp->planNodeId()));
+      VELOX_CHECK(planNode != nullptr);
+      replaceOp.push_back(std::make_unique<CudfTopN>(id, ctx, planNode));
+    } else if (
+        dynamic_cast<exec::HashAggregation*>(oper) or
+        dynamic_cast<exec::StreamingAggregation*>(oper)) {
       auto planNode = std::dynamic_pointer_cast<const core::AggregationNode>(
-          getPlanNode(hashAggOp->planNodeId()));
+          getPlanNode(oper->planNodeId()));
       VELOX_CHECK(planNode != nullptr);
       replaceOp.push_back(
           std::make_unique<CudfHashAggregation>(id, ctx, planNode));
-      replaceOp.back()->initialize();
+    } else if (isFilterProjectSupported(oper)) {
+      auto filterProjectOp = dynamic_cast<exec::FilterProject*>(oper);
+      auto projectPlanNode = std::dynamic_pointer_cast<const core::ProjectNode>(
+          getPlanNode(filterProjectOp->planNodeId()));
+      // When filter and project both exist, the FilterProject planNodeId id is
+      // project node id, so we need FilterProject to report the FilterNode.
+      auto filterPlanNode = filterProjectOp->filterNode();
+      VELOX_CHECK(projectPlanNode != nullptr or filterPlanNode != nullptr);
+      replaceOp.push_back(
+          std::make_unique<CudfFilterProject>(
+              id, ctx, filterPlanNode, projectPlanNode));
+    } else if (auto limitOp = dynamic_cast<exec::Limit*>(oper)) {
+      auto planNode = std::dynamic_pointer_cast<const core::LimitNode>(
+          getPlanNode(limitOp->planNodeId()));
+      VELOX_CHECK(planNode != nullptr);
+      replaceOp.push_back(std::make_unique<CudfLimit>(id, ctx, planNode));
+    } else if (
+        auto localPartitionOp = dynamic_cast<exec::LocalPartition*>(oper)) {
+      auto planNode = std::dynamic_pointer_cast<const core::LocalPartitionNode>(
+          getPlanNode(localPartitionOp->planNodeId()));
+      VELOX_CHECK(planNode != nullptr);
+      if (CudfLocalPartition::shouldReplace(planNode)) {
+        replaceOp.push_back(
+            std::make_unique<CudfLocalPartition>(id, ctx, planNode));
+      } else {
+        // Round Robin batch-wise Partitioning is supported by CPU operator with
+        // GPU Vector.
+        keepOperator = 1;
+      }
+    } else if (
+        auto localExchangeOp = dynamic_cast<exec::LocalExchange*>(oper)) {
+      keepOperator = 1;
+    } else if (
+        auto assignUniqueIdOp = dynamic_cast<exec::AssignUniqueId*>(oper)) {
+      auto planNode = std::dynamic_pointer_cast<const core::AssignUniqueIdNode>(
+          getPlanNode(assignUniqueIdOp->planNodeId()));
+      VELOX_CHECK(planNode != nullptr);
+      replaceOp.push_back(
+          std::make_unique<CudfAssignUniqueId>(
+              id,
+              ctx,
+              planNode,
+              planNode->taskUniqueId(),
+              planNode->uniqueIdCounter()));
+    } else {
+      keepOperator = 1;
     }
 
     if (producesGpuOutput(oper) and
         (nextOperatorIsNotGpu or isLastOperatorOfTask)) {
       auto planNode = getPlanNode(oper->planNodeId());
-      replaceOp.push_back(std::make_unique<CudfToVelox>(
-          id, planNode->outputType(), ctx, planNode->id() + "-to-velox"));
-      replaceOp.back()->initialize();
+      replaceOp.push_back(
+          std::make_unique<CudfToVelox>(
+              id, planNode->outputType(), ctx, planNode->id() + "-to-velox"));
+    }
+
+    if (CudfConfig::getInstance().debugEnabled) {
+      LOG(INFO) << "Operator: ID " << oper->operatorId() << ": "
+                << oper->toString().c_str()
+                << ", keepOperator = " << keepOperator
+                << ", replaceOp.size() = " << replaceOp.size() << "\n";
+    }
+    auto GpuReplacedOperator = [](const exec::Operator* op) {
+      return isAnyOf<
+          exec::OrderBy,
+          exec::TopN,
+          exec::HashAggregation,
+          exec::HashProbe,
+          exec::HashBuild,
+          exec::StreamingAggregation,
+          exec::Limit,
+          exec::LocalPartition,
+          exec::LocalExchange,
+          exec::FilterProject,
+          exec::AssignUniqueId,
+          CudfOperator>(op);
+    };
+    auto GpuRetainedOperator =
+        [isTableScanSupported](const exec::Operator* op) {
+          return isAnyOf<exec::Values, exec::LocalExchange, exec::CallbackSink>(
+                     op) ||
+              (isAnyOf<exec::TableScan>(op) && isTableScanSupported(op));
+        };
+    // If GPU operator is supported, then replaceOp should be non-empty and
+    // the operator should not be retained Else the velox operator is retained
+    // as-is
+    auto condition = (GpuReplacedOperator(oper) && !replaceOp.empty() &&
+                      keepOperator == 0) ||
+        (GpuRetainedOperator(oper) && replaceOp.empty() && keepOperator == 1);
+    if (CudfConfig::getInstance().debugEnabled) {
+      LOG(INFO) << "GpuReplacedOperator = " << GpuReplacedOperator(oper)
+                << ", GpuRetainedOperator = " << GpuRetainedOperator(oper)
+                << std::endl;
+      LOG(INFO) << "GPU operator condition = " << condition << std::endl;
+    }
+    if (!allowCpuFallback) {
+      VELOX_CHECK(condition, "Replacement with cuDF operator failed");
+    } else if (!condition) {
+      LOG(WARNING)
+          << "Replacement with cuDF operator failed. Falling back to CPU execution";
     }
 
     if (not replaceOp.empty()) {
-      operatorsOffset += replaceOp.size() - 1;
+      // ReplaceOp, to-velox.
+      operatorsOffset += replaceOp.size() - 1 + keepOperator;
       [[maybe_unused]] auto replaced = driverFactory_.replaceOperators(
           driver_,
-          replacingOperatorIndex,
+          replacingOperatorIndex + keepOperator,
           replacingOperatorIndex + 1,
           std::move(replaceOp));
       replacementsMade = true;
     }
   }
 
-  if (FLAGS_velox_cudf_debug) {
+  if (CudfConfig::getInstance().debugEnabled) {
     operators = driver_.operators();
-    std::cout << "Operators after adapting for cuDF: count ["
+    LOG(INFO) << "Operators after adapting for cuDF: count ["
               << operators.size() << "]" << std::endl;
     for (auto& op : operators) {
-      std::cout << "  Operator: ID " << op->operatorId() << ": "
+      LOG(INFO) << "  Operator: ID " << op->operatorId() << ": "
                 << op->toString() << std::endl;
     }
   }
@@ -174,43 +425,65 @@ bool CompileState::compile() {
   return replacementsMade;
 }
 
-struct CudfDriverAdapter {
-  std::shared_ptr<rmm::mr::device_memory_resource> mr_;
+std::shared_ptr<rmm::mr::device_memory_resource> mr_;
 
-  CudfDriverAdapter(std::shared_ptr<rmm::mr::device_memory_resource> mr)
-      : mr_(mr) {}
+struct CudfDriverAdapter {
+  CudfDriverAdapter(bool allowCpuFallback)
+      : allowCpuFallback_{allowCpuFallback} {}
 
   // Call operator needed by DriverAdapter
   bool operator()(const exec::DriverFactory& factory, exec::Driver& driver) {
+    if (!driver.driverCtx()->queryConfig().get<bool>(
+            CudfConfig::kCudfEnabled, CudfConfig::getInstance().enabled) &&
+        allowCpuFallback_) {
+      return false;
+    }
     auto state = CompileState(factory, driver);
-    auto res = state.compile();
+    auto res = state.compile(allowCpuFallback_);
     return res;
   }
+
+ private:
+  bool allowCpuFallback_;
 };
 
 static bool isCudfRegistered = false;
 
-void registerCudf(const CudfOptions& options) {
+bool cudfIsRegistered() {
+  return isCudfRegistered;
+}
+
+void registerCudf() {
   if (cudfIsRegistered()) {
     return;
   }
-  if (!options.cudfEnabled) {
-    return;
-  }
+
+  registerBuiltinFunctions(CudfConfig::getInstance().functionNamePrefix);
 
   CUDF_FUNC_RANGE();
   cudaFree(nullptr); // Initialize CUDA context at startup
 
-  const std::string mrMode = options.cudfMemoryResource;
-  auto mr = cudf_velox::createMemoryResource(mrMode);
+  const std::string mrMode = CudfConfig::getInstance().memoryResource;
+  auto mr = cudf_velox::createMemoryResource(
+      mrMode, CudfConfig::getInstance().memoryPercent);
   cudf::set_current_device_resource(mr.get());
-  CudfDriverAdapter cda{mr};
+  mr_ = mr;
+
+  exec::Operator::registerOperator(
+      std::make_unique<CudfHashJoinBridgeTranslator>());
+  CudfDriverAdapter cda{CudfConfig::getInstance().allowCpuFallback};
   exec::DriverAdapter cudfAdapter{kCudfAdapterName, {}, cda};
   exec::DriverFactory::registerAdapter(cudfAdapter);
+
+  if (CudfConfig::getInstance().astExpressionEnabled) {
+    registerAstEvaluator(CudfConfig::getInstance().astExpressionPriority);
+  }
+
   isCudfRegistered = true;
 }
 
 void unregisterCudf() {
+  mr_ = nullptr;
   exec::DriverFactory::adapters.erase(
       std::remove_if(
           exec::DriverFactory::adapters.begin(),
@@ -223,8 +496,41 @@ void unregisterCudf() {
   isCudfRegistered = false;
 }
 
-bool cudfIsRegistered() {
-  return isCudfRegistered;
+CudfConfig& CudfConfig::getInstance() {
+  static CudfConfig instance;
+  return instance;
+}
+
+void CudfConfig::initialize(
+    std::unordered_map<std::string, std::string>&& config) {
+  if (config.find(kCudfEnabled) != config.end()) {
+    enabled = folly::to<bool>(config[kCudfEnabled]);
+  }
+  if (config.find(kCudfDebugEnabled) != config.end()) {
+    debugEnabled = folly::to<bool>(config[kCudfDebugEnabled]);
+  }
+  if (config.find(kCudfMemoryResource) != config.end()) {
+    memoryResource = config[kCudfMemoryResource];
+  }
+  if (config.find(kCudfMemoryPercent) != config.end()) {
+    memoryPercent = folly::to<int32_t>(config[kCudfMemoryPercent]);
+  }
+  if (config.find(kCudfFunctionNamePrefix) != config.end()) {
+    functionNamePrefix = config[kCudfFunctionNamePrefix];
+  }
+  if (config.find(kCudfAstExpressionEnabled) != config.end()) {
+    astExpressionEnabled = folly::to<bool>(config[kCudfAstExpressionEnabled]);
+  }
+  if (config.find(kCudfAstExpressionPriority) != config.end()) {
+    astExpressionPriority =
+        folly::to<int32_t>(config[kCudfAstExpressionPriority]);
+  }
+  if (config.find(kCudfAllowCpuFallback) != config.end()) {
+    allowCpuFallback = folly::to<bool>(config[kCudfAllowCpuFallback]);
+  }
+  if (config.find(kCudfLogFallback) != config.end()) {
+    logFallback = folly::to<bool>(config[kCudfLogFallback]);
+  }
 }
 
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/ToCudf.h b/velox/experimental/cudf/exec/ToCudf.h
index 63fcf0d5dd76..910f857cb00b 100644
--- a/velox/experimental/cudf/exec/ToCudf.h
+++ b/velox/experimental/cudf/exec/ToCudf.h
@@ -19,16 +19,10 @@
 #include "velox/exec/Driver.h"
 #include "velox/exec/Operator.h"
 
-#include <gflags/gflags.h>
-
-DECLARE_bool(velox_cudf_enabled);
-DECLARE_string(velox_cudf_memory_resource);
-DECLARE_bool(velox_cudf_debug);
+#include <rmm/mr/device_memory_resource.hpp>
 
 namespace facebook::velox::cudf_velox {
 
-static const std::string kCudfAdapterName = "cuDF";
-
 class CompileState {
  public:
   CompileState(const exec::DriverFactory& driverFactory, exec::Driver& driver)
@@ -40,22 +34,16 @@ class CompileState {
 
   // Replaces sequences of Operators in the Driver given at construction with
   // cuDF equivalents. Returns true if the Driver was changed.
-  bool compile();
+  bool compile(bool allow_cpu_fallback);
 
   const exec::DriverFactory& driverFactory_;
   exec::Driver& driver_;
 };
 
-struct CudfOptions {
-  bool cudfEnabled = FLAGS_velox_cudf_enabled;
-  std::string cudfMemoryResource = FLAGS_velox_cudf_memory_resource;
-  static CudfOptions defaultOptions() {
-    return CudfOptions();
-  }
-};
+extern std::shared_ptr<rmm::mr::device_memory_resource> mr_;
 
 /// Registers adapter to add cuDF operators to Drivers.
-void registerCudf(const CudfOptions& options = CudfOptions::defaultOptions());
+void registerCudf();
 void unregisterCudf();
 
 /// Returns true if cuDF is registered.
diff --git a/velox/experimental/cudf/exec/Utilities.cpp b/velox/experimental/cudf/exec/Utilities.cpp
index f861724ee635..90aa838671a0 100644
--- a/velox/experimental/cudf/exec/Utilities.cpp
+++ b/velox/experimental/cudf/exec/Utilities.cpp
@@ -15,24 +15,29 @@
  */
 
 #include "velox/experimental/cudf/exec/Utilities.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
 
+#include <cudf/column/column_factories.hpp>
 #include <cudf/concatenate.hpp>
 #include <cudf/detail/utilities/stream_pool.hpp>
 #include <cudf/utilities/default_stream.hpp>
 #include <cudf/utilities/error.hpp>
 #include <cudf/utilities/memory_resource.hpp>
+#include <cudf/utilities/prefetch.hpp>
 
-#include <rmm/mr/device/arena_memory_resource.hpp>
-#include <rmm/mr/device/cuda_async_memory_resource.hpp>
-#include <rmm/mr/device/cuda_memory_resource.hpp>
-#include <rmm/mr/device/device_memory_resource.hpp>
-#include <rmm/mr/device/managed_memory_resource.hpp>
-#include <rmm/mr/device/owning_wrapper.hpp>
-#include <rmm/mr/device/pool_memory_resource.hpp>
+#include <rmm/mr/arena_memory_resource.hpp>
+#include <rmm/mr/cuda_async_memory_resource.hpp>
+#include <rmm/mr/cuda_memory_resource.hpp>
+#include <rmm/mr/device_memory_resource.hpp>
+#include <rmm/mr/managed_memory_resource.hpp>
+#include <rmm/mr/owning_wrapper.hpp>
+#include <rmm/mr/pool_memory_resource.hpp>
+#include <rmm/mr/prefetch_resource_adaptor.hpp>
 
 #include <common/base/Exceptions.h>
 
 #include <cstdlib>
+#include <limits>
 #include <memory>
 #include <string_view>
 
@@ -43,9 +48,9 @@ namespace {
   return std::make_shared<rmm::mr::cuda_memory_resource>();
 }
 
-[[nodiscard]] auto makePoolMr() {
+[[nodiscard]] auto makePoolMr(int percent) {
   return rmm::mr::make_owning_wrapper<rmm::mr::pool_memory_resource>(
-      makeCudaMr(), rmm::percent_of_free_device_memory(50));
+      makeCudaMr(), rmm::percent_of_free_device_memory(percent));
 }
 
 [[nodiscard]] auto makeAsyncMr() {
@@ -56,34 +61,60 @@ namespace {
   return std::make_shared<rmm::mr::managed_memory_resource>();
 }
 
-[[nodiscard]] auto makeArenaMr() {
+/// \brief Makes a prefetched<managed> resource
+[[nodiscard]] auto makePrefetchManagedMr() {
+  return rmm::mr::make_owning_wrapper<rmm::mr::prefetch_resource_adaptor>(
+      makeManagedMr());
+}
+
+[[nodiscard]] auto makeArenaMr(int percent) {
   return rmm::mr::make_owning_wrapper<rmm::mr::arena_memory_resource>(
-      makeCudaMr());
+      makeCudaMr(), rmm::percent_of_free_device_memory(percent));
 }
 
-[[nodiscard]] auto makeManagedPoolMr() {
+[[nodiscard]] auto makeManagedPoolMr(int percent) {
   return rmm::mr::make_owning_wrapper<rmm::mr::pool_memory_resource>(
-      makeManagedMr(), rmm::percent_of_free_device_memory(50));
+      makeManagedMr(), rmm::percent_of_free_device_memory(percent));
+}
+
+/// \brief Makes a prefetched<pool<managed>> resource
+[[nodiscard]] auto makePrefetchManagedPoolMr(int percent) {
+  return rmm::mr::make_owning_wrapper<rmm::mr::prefetch_resource_adaptor>(
+      makeManagedPoolMr(percent));
 }
+
+void enablePrefetching() {
+  cudf::prefetch::enable();
+}
+
 } // namespace
 
 std::shared_ptr<rmm::mr::device_memory_resource> createMemoryResource(
-    std::string_view mode) {
+    std::string_view mode,
+    int percent) {
   if (mode == "cuda")
     return makeCudaMr();
   if (mode == "pool")
-    return makePoolMr();
+    return makePoolMr(percent);
   if (mode == "async")
     return makeAsyncMr();
   if (mode == "arena")
-    return makeArenaMr();
+    return makeArenaMr(percent);
   if (mode == "managed")
     return makeManagedMr();
   if (mode == "managed_pool")
-    return makeManagedPoolMr();
+    return makeManagedPoolMr(percent);
+  if (mode == "prefetch_managed") {
+    enablePrefetching();
+    return makePrefetchManagedMr();
+  }
+  if (mode == "prefetch_managed_pool") {
+    enablePrefetching();
+    return makePrefetchManagedPoolMr(percent);
+  }
   VELOX_FAIL(
       "Unknown memory resource mode: " + std::string(mode) +
-      "\nExpecting: cuda, pool, async, arena, managed, or managed_pool");
+      "\nExpecting: cuda, pool, async, arena, managed, prefetch_managed, managed_pool, prefetch_managed_pool");
 }
 
 cudf::detail::cuda_stream_pool& cudfGlobalStreamPool() {
@@ -110,11 +141,37 @@ std::unique_ptr<cudf::table> concatenateTables(
       tableViews, stream, cudf::get_current_device_resource_ref());
 }
 
+std::unique_ptr<cudf::table> makeEmptyTable(TypePtr const& inputType) {
+  std::vector<std::unique_ptr<cudf::column>> emptyColumns;
+  for (size_t i = 0; i < inputType->size(); ++i) {
+    if (auto const& childType = inputType->childAt(i);
+        childType->kind() == TypeKind::ROW) {
+      auto tbl = makeEmptyTable(childType);
+      auto structColumn = std::make_unique<cudf::column>(
+          cudf::data_type(cudf::type_id::STRUCT),
+          0,
+          rmm::device_buffer(),
+          rmm::device_buffer(),
+          0,
+          tbl->release());
+      emptyColumns.push_back(std::move(structColumn));
+    } else {
+      auto emptyColumn = cudf::make_empty_column(
+          cudf_velox::veloxToCudfTypeId(inputType->childAt(i)));
+      emptyColumns.push_back(std::move(emptyColumn));
+    }
+  }
+  return std::make_unique<cudf::table>(std::move(emptyColumns));
+}
+
 std::unique_ptr<cudf::table> getConcatenatedTable(
     std::vector<CudfVectorPtr>& tables,
+    const TypePtr& tableType,
     rmm::cuda_stream_view stream) {
   // Check for empty vector
-  VELOX_CHECK_GT(tables.size(), 0);
+  if (tables.size() == 0) {
+    return makeEmptyTable(tableType);
+  }
 
   auto inputStreams = std::vector<rmm::cuda_stream_view>();
   auto tableViews = std::vector<cudf::table_view>();
@@ -140,4 +197,95 @@ std::unique_ptr<cudf::table> getConcatenatedTable(
   return output;
 }
 
+std::vector<std::unique_ptr<cudf::table>> getConcatenatedTableBatched(
+    std::vector<CudfVectorPtr>& tables,
+    const TypePtr& tableType,
+    rmm::cuda_stream_view stream) {
+  std::vector<std::unique_ptr<cudf::table>> concatTables;
+  // Check for empty vector
+  if (tables.size() == 0) {
+    concatTables.push_back(makeEmptyTable(tableType));
+    return concatTables;
+  }
+
+  auto inputStreams = std::vector<rmm::cuda_stream_view>();
+  auto tableViews = std::vector<cudf::table_view>();
+
+  inputStreams.reserve(tables.size());
+  tableViews.reserve(tables.size());
+
+  for (const auto& table : tables) {
+    VELOX_CHECK_NOT_NULL(table);
+    tableViews.push_back(table->getTableView());
+    inputStreams.push_back(table->stream());
+  }
+
+  cudf::detail::join_streams(inputStreams, stream);
+
+  if (tables.size() == 1) {
+    concatTables.push_back(tables[0]->release());
+    return concatTables;
+  }
+
+  std::vector<std::unique_ptr<cudf::table>> outputTables;
+  auto const maxRows =
+      static_cast<size_t>(std::numeric_limits<cudf::size_type>::max());
+  size_t startpos = 0;
+  size_t runningRows = 0;
+  for (size_t i = 0; i < tableViews.size(); ++i) {
+    auto const numRows = static_cast<size_t>(tableViews[i].num_rows());
+    // If adding this table would exceed the limit, flush current batch
+    // [startpos, i).
+    if (runningRows > 0 && runningRows + numRows > maxRows) {
+      outputTables.push_back(
+          cudf::concatenate(
+              std::vector<cudf::table_view>(
+                  tableViews.begin() + startpos, tableViews.begin() + i),
+              stream,
+              cudf::get_current_device_resource_ref()));
+      startpos = i;
+      runningRows = 0;
+    }
+    runningRows += numRows;
+  }
+  // Flush the final batch [startpos, end).
+  if (startpos < tableViews.size()) {
+    outputTables.push_back(
+        cudf::concatenate(
+            std::vector<cudf::table_view>(
+                tableViews.begin() + startpos, tableViews.end()),
+            stream,
+            cudf::get_current_device_resource_ref()));
+  }
+  stream.synchronize();
+  return outputTables;
+}
+
+CudaEvent::CudaEvent(unsigned int flags) {
+  cudaEvent_t ev{};
+  cudaEventCreateWithFlags(&ev, flags);
+  event_ = ev;
+}
+
+CudaEvent::~CudaEvent() {
+  if (event_ != nullptr) {
+    cudaEventDestroy(event_);
+    event_ = nullptr;
+  }
+}
+
+CudaEvent::CudaEvent(CudaEvent&& other) noexcept : event_(other.event_) {
+  other.event_ = nullptr;
+}
+
+const CudaEvent& CudaEvent::recordFrom(rmm::cuda_stream_view stream) const {
+  cudaEventRecord(event_, stream.value());
+  return *this;
+}
+
+const CudaEvent& CudaEvent::waitOn(rmm::cuda_stream_view stream) const {
+  cudaStreamWaitEvent(stream.value(), event_, 0);
+  return *this;
+}
+
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/Utilities.h b/velox/experimental/cudf/exec/Utilities.h
index 31f529bb34a3..24f201e586c2 100644
--- a/velox/experimental/cudf/exec/Utilities.h
+++ b/velox/experimental/cudf/exec/Utilities.h
@@ -21,7 +21,8 @@
 #include <cudf/detail/utilities/stream_pool.hpp>
 #include <cudf/table/table.hpp>
 
-#include <rmm/mr/device/device_memory_resource.hpp>
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/mr/device_memory_resource.hpp>
 
 #include <memory>
 #include <string_view>
@@ -30,9 +31,13 @@ namespace facebook::velox::cudf_velox {
 
 /**
  * @brief Creates a memory resource based on the given mode.
+ *
+ * @param mode rmm::mr::pool_memory_resource mode.
+ * @param percent The initial percent of GPU memory to allocate for memory
+ * resource.
  */
 [[nodiscard]] std::shared_ptr<rmm::mr::device_memory_resource>
-createMemoryResource(std::string_view mode);
+createMemoryResource(std::string_view mode, int percent);
 
 /**
  * @brief Returns the global CUDA stream pool used by cudf.
@@ -49,6 +54,112 @@ createMemoryResource(std::string_view mode);
 // stream. Inputs are not safe to use after calling this function.
 [[nodiscard]] std::unique_ptr<cudf::table> getConcatenatedTable(
     std::vector<CudfVectorPtr>& tables,
+    const TypePtr& tableType,
+    rmm::cuda_stream_view stream);
+
+/**
+ * @brief Concatenates multiple CUDF tables with automatic batching based on
+ * size limits.
+ *
+ * This function concatenates a vector of CUDF tables while respecting size
+ * limits imposed by cudf::size_type i.e. 32-bit signed integer. Unlike
+ * getConcatenatedTable that returns a single concatenated table, this batched
+ * version splits the concatenation into multiple output tables when the total
+ * number of rows would exceeds ~2.1 billion, the maximum value representable by
+ * cudf::size_type
+ *
+ * The function is stream-safe and handles proper stream synchronization. All
+ * input streams from individual tables are collected and joined on the provided
+ * output stream. Tables that may have been created on different CUDA streams
+ * are also properly synchronized.
+ *
+ * @param tables Input vector of CUDF tables to concatenate (consumed during
+ * operation)
+ * @param tableType Velox type representation for creating empty tables when
+ * needed
+ * @param stream CUDA stream for asynchronous operations and memory management
+ * @return Vector of concatenated tables (multiple if input exceeded size
+ * limits)
+ *
+ */
+[[nodiscard]] std::vector<std::unique_ptr<cudf::table>>
+getConcatenatedTableBatched(
+    std::vector<CudfVectorPtr>& tables,
+    const TypePtr& tableType,
     rmm::cuda_stream_view stream);
 
+/**
+ * @brief Wrapper for CUDA events used for stream synchronization.
+ *
+ * CudaEvent provides a safe, move-only wrapper around cudaEvent_t that
+ * automatically manages the event lifecycle.
+ *
+ * @note This class is non-copyable but move-constructible, ensuring exclusive
+ * ownership of the underlying CUDA event.
+ *
+ * Example usage:
+ * @code
+ *   // Create an event
+ *   CudaEvent event;
+ *
+ *   // Record the event on stream1 after some work
+ *   // ... launch kernels on stream1 ...
+ *   event.recordFrom(stream1);
+ *
+ *   // Make stream2 wait for the event before proceeding
+ *   event.waitOn(stream2);
+ *   // ... launch kernels on stream2 (will wait for stream1 to reach event) ...
+ * @endcode
+ */
+class CudaEvent {
+ public:
+  /**
+   * @brief Constructs a CUDA event with the specified flags.
+   *
+   * @param flags Optional flags for event creation (default: 0).
+   *              Common flags include:
+   *              - cudaEventDefault: Default event creation flag
+   *              - cudaEventBlockingSync: Use blocking synchronization
+   *              - cudaEventDisableTiming: Event will not record timing data
+   *              - cudaEventInterprocess: Event may be used for interprocess
+   *
+   * @throws May throw if CUDA event creation fails
+   */
+  explicit CudaEvent(unsigned int flags = 0);
+
+  ~CudaEvent();
+
+  CudaEvent(const CudaEvent&) = delete;
+
+  CudaEvent& operator=(const CudaEvent&) = delete;
+
+  CudaEvent(CudaEvent&& other) noexcept;
+
+  /**
+   * @brief Records this event in the specified CUDA stream.
+   *
+   * The event will be recorded after all previously issued operations in the
+   * stream have completed. This does not block the host thread or the stream.
+   *
+   * @param stream The CUDA stream in which to record the event
+   * @return Reference to this CudaEvent for method chaining
+   */
+  const CudaEvent& recordFrom(rmm::cuda_stream_view stream) const;
+
+  /**
+   * @brief Makes the specified stream wait until this event has been recorded.
+   *
+   * All future operations in the specified stream will wait until this event
+   * has been recorded (i.e., all operations before the recordFrom() call have
+   * completed). This enables synchronization between different CUDA streams
+   * without blocking the host thread.
+   *
+   * @param stream The CUDA stream that should wait for this event
+   * @return Reference to this CudaEvent for method chaining
+   */
+  const CudaEvent& waitOn(rmm::cuda_stream_view stream) const;
+
+ private:
+  cudaEvent_t event_{};
+};
 } // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/Validation.h b/velox/experimental/cudf/exec/Validation.h
new file mode 100644
index 000000000000..d5ac57d666f1
--- /dev/null
+++ b/velox/experimental/cudf/exec/Validation.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 "velox/experimental/cudf/CudfConfig.h"
+
+#include "velox/common/base/ExceptionHelper.h"
+
+namespace facebook::velox::cudf_velox {
+
+/// Log a reason for falling back to Velox CPU execution if
+/// CudfConfig::getInstance().logFallback is enabled. It captures the
+/// file name, line number, function name, and reason for the failure. The
+/// validation failure introduces extra data format conversion which can
+/// negatively impact the performance, so log the messgage to notify the
+/// important reason.
+///
+/// Usage:
+///
+/// LOG_FALLBACK("Sort merge join");
+/// LOG_FALLBACK(functionName);
+/// LOG_FALLBACK("Cast from {} to {}", fromType->toString(),
+/// toType->toString());
+#define LOG_FALLBACK(...)                                                                                \
+  do {                                                                                                   \
+    if (CudfConfig::getInstance().logFallback) {                                                         \
+      auto message = ::facebook::velox::errorMessage(__VA_ARGS__);                                       \
+      LOG(WARNING) << fmt::format(                                                                       \
+          "Validation failed at function: {}, reason: Operation is not supported in cuDF execution: {}", \
+          __FUNCTION__,                                                                                  \
+          message);                                                                                      \
+    }                                                                                                    \
+  } while (0)
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/exec/VeloxCudfInterop.cpp b/velox/experimental/cudf/exec/VeloxCudfInterop.cpp
index e2ac69148423..48bb6417d39a 100644
--- a/velox/experimental/cudf/exec/VeloxCudfInterop.cpp
+++ b/velox/experimental/cudf/exec/VeloxCudfInterop.cpp
@@ -74,7 +74,8 @@ cudf::type_id veloxToCudfTypeId(const TypePtr& type) {
     // https://github.com/facebookincubator/velox/commit/73d2f935b55f084d30557c7be94b9768efb8e56f
     // case TypeKind::SHORT_DECIMAL: return cudf::type_id::DECIMAL64;
     // case TypeKind::LONG_DECIMAL: return cudf::type_id::DECIMAL128;
-    // case TypeKind::ARRAY: return cudf::type_id::EMPTY;
+    case TypeKind::ARRAY:
+      return cudf::type_id::LIST;
     // case TypeKind::MAP: return cudf::type_id::EMPTY;
     case TypeKind::ROW:
       return cudf::type_id::STRUCT;
@@ -83,7 +84,9 @@ cudf::type_id veloxToCudfTypeId(const TypePtr& type) {
     // case TypeKind::OPAQUE: return cudf::type_id::EMPTY;
     // case TypeKind::INVALID: return cudf::type_id::EMPTY;
     default:
-      CUDF_FAIL("Unsupported Velox type");
+      CUDF_FAIL(
+          "Unsupported Velox type: " +
+          std::string(TypeKindName::toName(type->kind())));
       return cudf::type_id::EMPTY;
   }
 }
diff --git a/velox/experimental/cudf/expression/AstExpression.cpp b/velox/experimental/cudf/expression/AstExpression.cpp
new file mode 100644
index 000000000000..49f4287db544
--- /dev/null
+++ b/velox/experimental/cudf/expression/AstExpression.cpp
@@ -0,0 +1,751 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/AstUtils.h"
+
+#include "velox/expression/ConstantExpr.h"
+#include "velox/expression/FieldReference.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/ConstantVector.h"
+
+#include <cudf/ast/detail/operators.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/transform.hpp>
+#include <cudf/unary.hpp>
+#include <cudf/utilities/traits.hpp>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+cudf::ast::literal createLiteral(
+    const VectorPtr& vector,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    size_t atIndex = 0) {
+  const auto kind = vector->typeKind();
+  const auto& type = vector->type();
+  variant value =
+      VELOX_DYNAMIC_TYPE_DISPATCH(getVariant, kind, vector, atIndex);
+  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+      makeScalarAndLiteral, kind, type, value, scalars);
+}
+
+// Helper function to extract literals from array elements based on type
+void extractArrayLiterals(
+    const ArrayVector* arrayVector,
+    std::vector<cudf::ast::literal>& literals,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    vector_size_t offset,
+    vector_size_t size) {
+  auto elements = arrayVector->elements();
+
+  for (auto i = offset; i < offset + size; ++i) {
+    if (elements->isNullAt(i)) {
+      // Skip null values for IN expressions
+      continue;
+    } else {
+      literals.emplace_back(createLiteral(elements, scalars, i));
+    }
+  }
+}
+
+// Function to create literals from an array vector
+std::vector<cudf::ast::literal> createLiteralsFromArray(
+    const VectorPtr& vector,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars) {
+  std::vector<cudf::ast::literal> literals;
+
+  // Check if it's a constant vector containing an array
+  if (vector->isConstantEncoding()) {
+    auto constantVector = vector->asUnchecked<ConstantVector<ComplexType>>();
+    if (constantVector->isNullAt(0)) {
+      // Return empty vector for null array
+      return literals;
+    }
+
+    auto valueVector = constantVector->valueVector();
+    if (valueVector->encoding() == VectorEncoding::Simple::ARRAY) {
+      auto arrayVector = valueVector->as<ArrayVector>();
+      auto index = constantVector->index();
+      auto size = arrayVector->sizeAt(index);
+      if (size == 0) {
+        // Return empty vector for empty array
+        return literals;
+      }
+
+      auto offset = arrayVector->offsetAt(index);
+      auto elements = arrayVector->elements();
+
+      // Handle different element types
+      if (elements->isScalar()) {
+        literals.reserve(size);
+        extractArrayLiterals(arrayVector, literals, scalars, offset, size);
+      } else if (elements->typeKind() == TypeKind::ARRAY) {
+        // Nested arrays not supported in IN expressions
+        VELOX_FAIL("Nested arrays not supported in IN expressions");
+      } else {
+        VELOX_FAIL(
+            "Unsupported element type in array: {}",
+            elements->type()->toString());
+      }
+    } else {
+      VELOX_FAIL("Expected ARRAY encoding");
+    }
+  } else {
+    VELOX_FAIL("Expected constant vector for IN list");
+  }
+
+  return literals;
+}
+
+std::string stripPrefix(const std::string& input, const std::string& prefix) {
+  if (input.size() >= prefix.size() &&
+      input.compare(0, prefix.size(), prefix) == 0) {
+    return input.substr(prefix.size());
+  }
+  return input;
+}
+
+using Op = cudf::ast::ast_operator;
+const std::unordered_map<std::string, Op> prestoBinaryOps = {
+    {"plus", Op::ADD},
+    {"minus", Op::SUB},
+    {"multiply", Op::MUL},
+    {"divide", Op::DIV},
+    {"eq", Op::EQUAL},
+    {"neq", Op::NOT_EQUAL},
+    {"lt", Op::LESS},
+    {"gt", Op::GREATER},
+    {"lte", Op::LESS_EQUAL},
+    {"gte", Op::GREATER_EQUAL},
+    {"and", Op::NULL_LOGICAL_AND},
+    {"or", Op::NULL_LOGICAL_OR},
+    {"mod", Op::MOD},
+};
+
+const std::unordered_map<std::string, Op> sparkBinaryOps = {
+    {"add", Op::ADD},
+    {"subtract", Op::SUB},
+    {"multiply", Op::MUL},
+    {"divide", Op::DIV},
+    {"equalto", Op::EQUAL},
+    {"lessthan", Op::LESS},
+    {"greaterthan", Op::GREATER},
+    {"lessthanorequal", Op::LESS_EQUAL},
+    {"greaterthanorequal", Op::GREATER_EQUAL},
+    {"and", Op::NULL_LOGICAL_AND},
+    {"or", Op::NULL_LOGICAL_OR},
+    {"mod", Op::MOD},
+};
+
+const std::unordered_map<std::string, Op> binaryOps = [] {
+  std::unordered_map<std::string, Op> merged(
+      sparkBinaryOps.begin(), sparkBinaryOps.end());
+  merged.insert(prestoBinaryOps.begin(), prestoBinaryOps.end());
+  return merged;
+}();
+
+const std::map<std::string, Op> unaryOps = {
+    {"not", Op::NOT},
+    {"is_null", Op::IS_NULL}};
+
+namespace detail {
+
+// return the AST operator for the given expression name, if any
+std::optional<Op> opFromFunctionName(const std::string& funcName) {
+  if (binaryOps.find(funcName) != binaryOps.end()) {
+    return binaryOps.at(funcName);
+  } else if (unaryOps.find(funcName) != unaryOps.end()) {
+    return unaryOps.at(funcName);
+  }
+  return std::nullopt;
+}
+
+bool isOpAndInputsSupported(
+    const cudf::ast::ast_operator op,
+    const std::vector<cudf::data_type>& inputCudfDataTypes) {
+  // check arity
+  const auto arity = cudf::ast::detail::ast_operator_arity(op);
+  if (arity != static_cast<int>(inputCudfDataTypes.size())) {
+    LOG(WARNING) << "Arity mismatch for operator: " << static_cast<int>(op)
+                 << " with input types size " << inputCudfDataTypes.size();
+    return false;
+  }
+  // check for a cuDF implementation of this op with these inputs
+  try {
+    // this will throw if no matching implementation is found
+    const auto returnCudfType =
+        cudf::ast::detail::ast_operator_return_type(op, inputCudfDataTypes);
+    // check it's a sensible type
+    return returnCudfType.id() != cudf::type_id::EMPTY;
+  } catch (...) {
+    // no matching cuDF implementation
+  }
+  return false;
+}
+
+// not special form, name = function, so unsupported for astpure
+// "in", "between", "isnotnull" are not special form, but supported for astpure
+// enum class SpecialFormKind : int32_t {
+//   kFieldAccess = 0, supported if not nested column / function
+//   kConstant = 1, "literal" for fixed_width and VARCHAR / function
+//   kCast = 2, "cast" or "try_cast" to int32, int64, double only / function
+//   kCoalesce = 3, unsupported/function
+//   kSwitch = 4, unsupported
+//   kLambda = 5, unsupported
+//   kTry = 6, unsupported
+//   kAnd = 7, "and" or "or" with multiple inputs
+//   kOr = 8,
+//   kCustom = 999,
+// };
+// check if the expression (name + input types) is supported in AST
+bool isAstExprSupported(const std::shared_ptr<velox::exec::Expr>& expr) {
+  using velox::exec::FieldReference;
+  using Op = cudf::ast::ast_operator;
+
+  const auto name =
+      stripPrefix(expr->name(), CudfConfig::getInstance().functionNamePrefix);
+  const auto len = expr->inputs().size();
+
+  // Literals and field references are always supported
+  auto isSupportedLiteral = [&](const TypePtr& type) {
+    try {
+      auto cudfType = cudf::data_type(veloxToCudfTypeId(type));
+      return cudf::is_fixed_width(cudfType) ||
+          cudfType.id() == cudf::type_id::STRING;
+    } catch (...) {
+      LOG(WARNING) << "Unsupported type for literal: " << type->toString();
+      return false;
+    }
+  };
+  if (name == "literal") {
+    auto type = expr->type();
+    return isSupportedLiteral(type);
+  }
+  if (auto fieldExpr = std::dynamic_pointer_cast<FieldReference>(expr)) {
+    const auto fieldName =
+        fieldExpr->inputs().empty() ? name : fieldExpr->inputs()[0]->name();
+    if (fieldExpr->field() == fieldName) {
+      return true;
+    }
+    LOG(WARNING) << "Field " << name << "not found, in expression "
+                 << expr->toString();
+    return false;
+  }
+
+  // Convert input types to CUDF types once
+  std::vector<cudf::data_type> inputCudfDataTypes;
+  inputCudfDataTypes.reserve(len);
+  for (const auto& input : expr->inputs()) {
+    try {
+      inputCudfDataTypes.push_back(
+          cudf::data_type(veloxToCudfTypeId(input->type())));
+    } catch (...) {
+      return false;
+    }
+  }
+
+  // Binary operations
+  if (binaryOps.find(name) != binaryOps.end()) {
+    // AND/OR can handle multiple inputs by chaining
+    if ((name == "and" || name == "or") && len > 2) {
+      for (size_t i = 1; i < len; i++) {
+        if (!isOpAndInputsSupported(
+                binaryOps.at(name),
+                {inputCudfDataTypes[0], inputCudfDataTypes[i]})) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return len == 2 &&
+        isOpAndInputsSupported(binaryOps.at(name), inputCudfDataTypes);
+  }
+
+  // Unary operations (includes both unaryOps and "isnotnull")
+  if (unaryOps.find(name) != unaryOps.end()) {
+    return isOpAndInputsSupported(unaryOps.at(name), inputCudfDataTypes);
+  }
+  if (name == "isnotnull" && len == 1) {
+    return isOpAndInputsSupported(Op::IS_NULL, inputCudfDataTypes);
+  }
+
+  // Between: value >= lower AND value <= upper
+  if (name == "between" && len == 3) {
+    return isOpAndInputsSupported(
+               Op::GREATER_EQUAL,
+               {inputCudfDataTypes[0], inputCudfDataTypes[1]}) &&
+        isOpAndInputsSupported(
+               Op::LESS_EQUAL, {inputCudfDataTypes[0], inputCudfDataTypes[2]});
+  }
+
+  // In: chain of EQUAL operations
+  if (name == "in") {
+    return len == 2 && isSupportedLiteral(expr->inputs()[0]->type()) &&
+        isOpAndInputsSupported(
+               Op::EQUAL, {inputCudfDataTypes[0], inputCudfDataTypes[0]});
+  }
+
+  // Cast operations: only INTEGER, BIGINT, DOUBLE supported in pure AST
+  if ((name == "cast" || name == "try_cast") && len == 1) {
+    const auto outputKind = expr->type()->kind();
+    if (outputKind == TypeKind::INTEGER || outputKind == TypeKind::BIGINT) {
+      return isOpAndInputsSupported(Op::CAST_TO_INT64, inputCudfDataTypes);
+    }
+    if (outputKind == TypeKind::DOUBLE) {
+      return isOpAndInputsSupported(Op::CAST_TO_FLOAT64, inputCudfDataTypes);
+    }
+    return false;
+  }
+
+  LOG(WARNING) << "Unsupported expression by AST: " << expr->toString();
+  return false;
+}
+
+} // namespace detail
+
+struct AstContext {
+  cudf::ast::tree& tree;
+  std::vector<std::unique_ptr<cudf::scalar>>& scalars;
+  const std::vector<RowTypePtr> inputRowSchema;
+  const std::vector<std::reference_wrapper<std::vector<PrecomputeInstruction>>>
+      precomputeInstructions;
+  const std::shared_ptr<velox::exec::Expr>
+      rootExpr; // Track the root expression
+  bool allowPureAstOnly;
+
+  cudf::ast::expression const& pushExprToTree(
+      const std::shared_ptr<velox::exec::Expr>& expr);
+  cudf::ast::expression const& addPrecomputeInstructionOnSide(
+      size_t sideIdx,
+      size_t columnIndex,
+      std::string const& instruction,
+      std::string const& fieldName,
+      const std::shared_ptr<CudfExpression>& node = nullptr);
+  cudf::ast::expression const& addPrecomputeInstruction(
+      std::string const& name,
+      std::string const& instruction,
+      std::string const& fieldName = {},
+      const std::shared_ptr<CudfExpression>& node = nullptr);
+  cudf::ast::expression const& multipleInputsToPairWise(
+      const std::shared_ptr<velox::exec::Expr>& expr);
+  static bool canBeEvaluated(const std::shared_ptr<velox::exec::Expr>& expr);
+};
+
+// get nested column indices
+std::vector<int> getNestedColumnIndices(
+    const TypePtr& rowType,
+    const std::string& fieldName) {
+  std::vector<int> indices;
+  auto rowTypePtr = asRowType(rowType);
+  if (rowTypePtr->containsChild(fieldName)) {
+    auto columnIndex = rowTypePtr->getChildIdx(fieldName);
+    indices.push_back(columnIndex);
+  }
+  return indices;
+}
+
+cudf::ast::expression const& AstContext::addPrecomputeInstructionOnSide(
+    size_t sideIdx,
+    size_t columnIndex,
+    std::string const& instruction,
+    std::string const& fieldName,
+    const std::shared_ptr<CudfExpression>& node) {
+  auto newColumnIndex = inputRowSchema[sideIdx].get()->size() +
+      precomputeInstructions[sideIdx].get().size();
+  if (fieldName.empty()) {
+    // This custom op should be added to input columns.
+    precomputeInstructions[sideIdx].get().emplace_back(
+        columnIndex, instruction, newColumnIndex, node);
+  } else {
+    auto nestedIndices = getNestedColumnIndices(
+        inputRowSchema[sideIdx].get()->childAt(columnIndex), fieldName);
+    precomputeInstructions[sideIdx].get().emplace_back(
+        columnIndex, instruction, newColumnIndex, nestedIndices, node);
+  }
+  auto side = static_cast<cudf::ast::table_reference>(sideIdx);
+  return tree.push(cudf::ast::column_reference(newColumnIndex, side));
+}
+
+cudf::ast::expression const& AstContext::addPrecomputeInstruction(
+    std::string const& name,
+    std::string const& instruction,
+    std::string const& fieldName,
+    const std::shared_ptr<CudfExpression>& node) {
+  for (size_t sideIdx = 0; sideIdx < inputRowSchema.size(); ++sideIdx) {
+    if (inputRowSchema[sideIdx].get()->containsChild(name)) {
+      auto columnIndex = inputRowSchema[sideIdx].get()->getChildIdx(name);
+      return addPrecomputeInstructionOnSide(
+          sideIdx, columnIndex, instruction, fieldName, node);
+    }
+  }
+  VELOX_FAIL("Field not found, " + name);
+}
+
+/// Handles logical AND/OR expressions with multiple inputs by converting them
+/// into a chain of binary operations. For example, "a AND b AND c" becomes
+/// "(a AND b) AND c".
+///
+/// @param expr The expression containing multiple inputs for AND/OR operation
+/// @return A reference to the resulting AST expression
+cudf::ast::expression const& AstContext::multipleInputsToPairWise(
+    const std::shared_ptr<velox::exec::Expr>& expr) {
+  using Operation = cudf::ast::operation;
+
+  const auto name =
+      stripPrefix(expr->name(), CudfConfig::getInstance().functionNamePrefix);
+  auto len = expr->inputs().size();
+  // Create a simple chain of operations
+  auto result = &pushExprToTree(expr->inputs()[0]);
+
+  // Chain the rest of the inputs sequentially
+  for (size_t i = 1; i < len; i++) {
+    auto const& nextInput = pushExprToTree(expr->inputs()[i]);
+    result = &tree.push(Operation{binaryOps.at(name), *result, nextInput});
+  }
+  return *result;
+}
+
+/// Pushes an expression into the AST tree and returns a reference to the
+/// resulting expression.
+///
+/// @param expr The expression to push into the AST tree
+/// @return A reference to the resulting AST expression
+cudf::ast::expression const& AstContext::pushExprToTree(
+    const std::shared_ptr<velox::exec::Expr>& expr) {
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+  using velox::exec::ConstantExpr;
+  using velox::exec::FieldReference;
+
+  const auto name =
+      stripPrefix(expr->name(), CudfConfig::getInstance().functionNamePrefix);
+  auto len = expr->inputs().size();
+  auto& type = expr->type();
+
+  if (name == "literal") {
+    auto c = dynamic_cast<ConstantExpr*>(expr.get());
+    VELOX_CHECK_NOT_NULL(c, "literal expression should be ConstantExpr");
+    auto value = c->value();
+    VELOX_CHECK(value->isConstantEncoding());
+
+    // Special case: VARCHAR literals cannot be handled by cudf::compute_column
+    // as the final output due to variable-width output limitation.
+    // However, if this is part of a larger expression tree (e.g., string
+    // comparison), then cudf can handle it fine since the final output won't be
+    // VARCHAR. We only need special handling when this literal will be the
+    // final output.
+    if (expr->type()->kind() == TypeKind::VARCHAR && expr == rootExpr) {
+      // convert to cudf scalar and store it
+      createLiteral(value, scalars);
+      // The scalar index is scalars.size() - 1 since we just added it
+      std::string fillExpr = "fill " + std::to_string(scalars.size() - 1);
+      // For literals, we use the first column just to get the size, but create
+      // a new column The new column will be appended after the original input
+      // columns
+      return addPrecomputeInstruction(inputRowSchema[0]->nameOf(0), fillExpr);
+    }
+
+    return tree.push(createLiteral(value, scalars));
+  } else if (binaryOps.find(name) != binaryOps.end()) {
+    if (name == "and" or name == "or") {
+      return multipleInputsToPairWise(expr);
+    }
+    VELOX_CHECK_EQ(len, 2);
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    auto const& op2 = pushExprToTree(expr->inputs()[1]);
+    return tree.push(Operation{binaryOps.at(name), op1, op2});
+  } else if (unaryOps.find(name) != unaryOps.end()) {
+    VELOX_CHECK_EQ(len, 1);
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    return tree.push(Operation{unaryOps.at(name), op1});
+  } else if (name == "isnotnull") {
+    VELOX_CHECK_EQ(len, 1);
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    auto const& nullOp = tree.push(Operation{Op::IS_NULL, op1});
+    return tree.push(Operation{Op::NOT, nullOp});
+  } else if (name == "between") {
+    VELOX_CHECK_EQ(len, 3);
+    auto const& value = pushExprToTree(expr->inputs()[0]);
+    auto const& lower = pushExprToTree(expr->inputs()[1]);
+    auto const& upper = pushExprToTree(expr->inputs()[2]);
+    // construct between(op2, op3) using >= and <=
+    auto const& geLower = tree.push(Operation{Op::GREATER_EQUAL, value, lower});
+    auto const& leUpper = tree.push(Operation{Op::LESS_EQUAL, value, upper});
+    return tree.push(Operation{Op::NULL_LOGICAL_AND, geLower, leUpper});
+  } else if (name == "in") {
+    // number of inputs is variable. >=2
+    VELOX_CHECK_EQ(len, 2);
+    // actually len is 2, second input is ARRAY
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    auto c = dynamic_cast<ConstantExpr*>(expr->inputs()[1].get());
+    VELOX_CHECK_NOT_NULL(c, "literal expression should be ConstantExpr");
+    auto value = c->value();
+    VELOX_CHECK_NOT_NULL(value, "ConstantExpr value is null");
+
+    // Use the new createLiteralsFromArray function to get literals
+    auto literals = createLiteralsFromArray(value, scalars);
+
+    // Create equality expressions for each literal and OR them together
+    std::vector<const cudf::ast::expression*> exprVec;
+    for (auto& literal : literals) {
+      auto const& opi = tree.push(std::move(literal));
+      auto const& logicalNode = tree.push(Operation{Op::EQUAL, op1, opi});
+      exprVec.push_back(&logicalNode);
+    }
+
+    // Handle empty IN list case
+    if (exprVec.empty()) {
+      // FAIL
+      VELOX_FAIL("Empty IN list");
+      // Return FALSE for empty IN list
+      // auto falseValue = std::make_shared<ConstantVector<bool>>(
+      //     value->pool(), 1, false, TypeKind::BOOLEAN, false);
+      // return tree.push(createLiteral(falseValue, scalars));
+    }
+
+    // OR all logical nodes
+    auto* result = exprVec[0];
+    for (size_t i = 1; i < exprVec.size(); i++) {
+      auto const& treeNode =
+          tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprVec[i]});
+      result = &treeNode;
+    }
+    return *result;
+  } else if (name == "cast" || name == "try_cast") {
+    VELOX_CHECK_EQ(len, 1);
+    auto const& op1 = pushExprToTree(expr->inputs()[0]);
+    if (expr->type()->kind() == TypeKind::INTEGER) {
+      // No int32 cast in cudf ast
+      return tree.push(Operation{Op::CAST_TO_INT64, op1});
+    } else if (expr->type()->kind() == TypeKind::BIGINT) {
+      return tree.push(Operation{Op::CAST_TO_INT64, op1});
+    } else if (expr->type()->kind() == TypeKind::DOUBLE) {
+      return tree.push(Operation{Op::CAST_TO_FLOAT64, op1});
+    } else {
+      VELOX_FAIL("Unsupported type for cast operation");
+    }
+  } else if (auto fieldExpr = std::dynamic_pointer_cast<FieldReference>(expr)) {
+    // Refer to the appropriate side
+    const auto fieldName =
+        fieldExpr->inputs().empty() ? name : fieldExpr->inputs()[0]->name();
+    for (size_t sideIdx = 0; sideIdx < inputRowSchema.size(); ++sideIdx) {
+      auto& schema = inputRowSchema[sideIdx];
+      if (schema.get()->containsChild(fieldName)) {
+        auto columnIndex = schema.get()->getChildIdx(fieldName);
+        // This column may be complex data type like ROW, we need to get the
+        // name from row. Push fieldName.name to the tree.
+        auto side = static_cast<cudf::ast::table_reference>(sideIdx);
+        if (fieldExpr->field() == fieldName) {
+          return tree.push(cudf::ast::column_reference(columnIndex, side));
+        } else if (!allowPureAstOnly) {
+          return addPrecomputeInstruction(
+              fieldName, "nested_column", fieldExpr->field());
+        } else {
+          VELOX_FAIL("Unsupported type for nested column operation");
+        }
+      }
+    }
+    VELOX_FAIL("Field not found, " + name);
+  } else if (!allowPureAstOnly && canBeEvaluatedByCudf(expr, /*deep=*/false)) {
+    // Shallow check: only verify this operation is supported
+    // Children will be recursively handled by createCudfExpression
+    auto node =
+        createCudfExpression(expr, inputRowSchema[0], kAstEvaluatorName);
+    return addPrecomputeInstructionOnSide(0, 0, name, "", node);
+  } else {
+    VELOX_FAIL("Unsupported expression: " + name);
+  }
+}
+
+std::vector<ColumnOrView> precomputeSubexpressions(
+    std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+    const std::vector<PrecomputeInstruction>& precomputeInstructions,
+    const std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema,
+    rmm::cuda_stream_view stream) {
+  std::vector<ColumnOrView> precomputedColumns;
+  precomputedColumns.reserve(precomputeInstructions.size());
+
+  for (const auto& instruction : precomputeInstructions) {
+    auto
+        [dependent_column_index,
+         ins_name,
+         new_column_index,
+         nested_dependent_column_indices,
+         cudf_expression] = instruction;
+
+    // If a compiled cudf node is available, evaluate it directly.
+    if (cudf_expression) {
+      auto result = cudf_expression->eval(
+          inputTableColumns,
+          stream,
+          cudf::get_current_device_resource_ref(),
+          /*finalize=*/true);
+      precomputedColumns.push_back(std::move(result));
+      continue;
+    }
+    if (ins_name.rfind("fill", 0) == 0) {
+      auto scalarIndex =
+          std::stoi(ins_name.substr(5)); // "fill " is 5 characters
+      auto newColumn = cudf::make_column_from_scalar(
+          *static_cast<cudf::string_scalar*>(scalars[scalarIndex].get()),
+          inputTableColumns[dependent_column_index]->size(),
+          stream,
+          cudf::get_current_device_resource_ref());
+      precomputedColumns.push_back(std::move(newColumn));
+    } else if (ins_name == "nested_column") {
+      // Nested column already exists in input. Don't materialize.
+      auto view = inputTableColumns[dependent_column_index]->view().child(
+          nested_dependent_column_indices[0]);
+      precomputedColumns.push_back(view);
+    } else {
+      VELOX_FAIL("Unsupported precompute operation " + ins_name);
+    }
+  }
+
+  return precomputedColumns;
+}
+
+} // namespace
+
+// Create tree from Expr
+// and collect precompute instructions for non-ast operations
+cudf::ast::expression const& createAstTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema,
+    std::vector<PrecomputeInstruction>& precomputeInstructions) {
+  static constexpr bool kAllowPureAstOnly = false;
+  AstContext context{
+      tree,
+      scalars,
+      {inputRowSchema},
+      {precomputeInstructions},
+      expr,
+      kAllowPureAstOnly};
+  return context.pushExprToTree(expr);
+}
+
+cudf::ast::expression const& createAstTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& leftRowSchema,
+    const RowTypePtr& rightRowSchema,
+    std::vector<PrecomputeInstruction>& leftPrecomputeInstructions,
+    std::vector<PrecomputeInstruction>& rightPrecomputeInstructions,
+    const bool allowPureAstOnly) {
+  AstContext context{
+      tree,
+      scalars,
+      {leftRowSchema, rightRowSchema},
+      {leftPrecomputeInstructions, rightPrecomputeInstructions},
+      expr,
+      allowPureAstOnly};
+  return context.pushExprToTree(expr);
+}
+
+ASTExpression::ASTExpression(
+    std::shared_ptr<velox::exec::Expr> expr,
+    const RowTypePtr& inputRowSchema)
+    : expr_(expr), inputRowSchema_(inputRowSchema) {
+  createAstTree(
+      expr, cudfTree_, scalars_, inputRowSchema, precomputeInstructions_);
+}
+
+void ASTExpression::close() {
+  cudfTree_ = {};
+  scalars_.clear();
+  precomputeInstructions_.clear();
+}
+
+ColumnOrView ASTExpression::eval(
+    std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr,
+    bool finalize) {
+  auto precomputedColumns = precomputeSubexpressions(
+      inputTableColumns,
+      precomputeInstructions_,
+      scalars_,
+      inputRowSchema_,
+      stream);
+
+  // Make table_view from input columns and precomputed columns
+  std::vector<cudf::column_view> allColumnViews;
+  allColumnViews.reserve(inputTableColumns.size() + precomputedColumns.size());
+
+  for (const auto& col : inputTableColumns) {
+    allColumnViews.push_back(col->view());
+  }
+
+  for (auto& precomputedCol : precomputedColumns) {
+    allColumnViews.push_back(asView(precomputedCol));
+  }
+
+  cudf::table_view astInputTableView(allColumnViews);
+
+  auto result = [&]() -> ColumnOrView {
+    if (auto colRefPtr = dynamic_cast<cudf::ast::column_reference const*>(
+            &cudfTree_.back())) {
+      auto columnIndex = colRefPtr->get_column_index();
+      if (columnIndex < inputTableColumns.size()) {
+        return inputTableColumns[columnIndex]->view();
+      } else {
+        // Referencing a precomputed column return as it is (view or owned)
+        return std::move(
+            precomputedColumns[columnIndex - inputTableColumns.size()]);
+      }
+    } else {
+      return cudf::compute_column(
+          astInputTableView, cudfTree_.back(), stream, mr);
+    }
+  }();
+  if (finalize) {
+    const auto requestedType =
+        cudf::data_type(cudf_velox::veloxToCudfTypeId(expr_->type()));
+    auto resultView = asView(result);
+    if (resultView.type() != requestedType) {
+      result = cudf::cast(resultView, requestedType, stream, mr);
+    }
+  }
+  return result;
+}
+
+bool ASTExpression::canEvaluate(std::shared_ptr<velox::exec::Expr> expr) {
+  return std::dynamic_pointer_cast<velox::exec::FieldReference>(expr) !=
+      nullptr ||
+      detail::isAstExprSupported(expr);
+}
+
+void registerAstEvaluator(int priority) {
+  registerCudfExpressionEvaluator(
+      kAstEvaluatorName,
+      priority,
+      [](std::shared_ptr<velox::exec::Expr> expr) {
+        return ASTExpression::canEvaluate(expr);
+      },
+      [](std::shared_ptr<velox::exec::Expr> expr, const RowTypePtr& row) {
+        return std::make_shared<ASTExpression>(std::move(expr), row);
+      },
+      /*overwrite=*/false);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/AstExpression.h b/velox/experimental/cudf/expression/AstExpression.h
new file mode 100644
index 000000000000..f21fdb9627bc
--- /dev/null
+++ b/velox/experimental/cudf/expression/AstExpression.h
@@ -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.
+ */
+#pragma once
+
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include <cudf/ast/expressions.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+const std::string kAstEvaluatorName = "ast";
+
+// Pre-compute instructions for the expression,
+// for ops that are not supported by cudf::ast
+struct PrecomputeInstruction {
+  int dependent_column_index;
+  std::string ins_name;
+  int new_column_index;
+  std::vector<int> nested_dependent_column_indices;
+  std::shared_ptr<CudfExpression> cudf_expression;
+
+  // Constructor to initialize the struct with values
+  PrecomputeInstruction(
+      int depIndex,
+      const std::string& name,
+      int newIndex,
+      const std::shared_ptr<CudfExpression>& node = nullptr)
+      : dependent_column_index(depIndex),
+        ins_name(name),
+        new_column_index(newIndex),
+        cudf_expression(node) {}
+
+  // TODO (dm): This two ctor situation is crazy.
+  PrecomputeInstruction(
+      int depIndex,
+      const std::string& name,
+      int newIndex,
+      const std::vector<int>& nestedIndices,
+      const std::shared_ptr<CudfExpression>& node = nullptr)
+      : dependent_column_index(depIndex),
+        ins_name(name),
+        new_column_index(newIndex),
+        nested_dependent_column_indices(nestedIndices),
+        cudf_expression(node) {}
+};
+
+cudf::ast::expression const& createAstTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema,
+    std::vector<PrecomputeInstruction>& precomputeInstructions);
+
+cudf::ast::expression const& createAstTree(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& leftRowSchema,
+    const RowTypePtr& rightRowSchema,
+    std::vector<PrecomputeInstruction>& leftPrecomputeInstructions,
+    std::vector<PrecomputeInstruction>& rightPrecomputeInstructions,
+    const bool allowPureAstOnly);
+
+// Evaluates the expression tree
+class ASTExpression : public CudfExpression {
+ public:
+  ASTExpression() = default;
+  // Converts velox expressions to cudf::ast::tree, scalars and
+  // precompute instructions and stores them
+  ASTExpression(
+      std::shared_ptr<velox::exec::Expr> expr,
+      const RowTypePtr& inputRowSchema);
+
+  // Evaluates the expression tree for the given input columns
+  ColumnOrView eval(
+      std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr,
+      bool finalize = false) override;
+
+  void close() override;
+
+  // Check if this specific operation (not its children) can be evaluated by
+  // ASTExpression
+  static bool canEvaluate(std::shared_ptr<velox::exec::Expr> expr);
+
+ private:
+  std::shared_ptr<velox::exec::Expr> expr_;
+
+  cudf::ast::tree cudfTree_;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars_;
+  // instruction on dependent column to get new column index on non-ast
+  // supported operations in expressions
+  // <dependent_column_index, "instruction", new_column_index>
+  std::vector<PrecomputeInstruction> precomputeInstructions_;
+  RowTypePtr inputRowSchema_;
+};
+
+void registerAstEvaluator(int priority);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/AstUtils.h b/velox/experimental/cudf/expression/AstUtils.h
new file mode 100644
index 000000000000..f2d767203fb9
--- /dev/null
+++ b/velox/experimental/cudf/expression/AstUtils.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/expression/ConstantExpr.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/SimpleVector.h"
+#include "velox/vector/VectorTypeUtils.h"
+
+#include <cudf/ast/expressions.hpp>
+#include <cudf/scalar/scalar.hpp>
+#include <cudf/utilities/default_stream.hpp>
+
+namespace facebook::velox::cudf_velox {
+
+template <typename T>
+cudf::ast::literal makeLiteralFromScalar(
+    cudf::scalar& scalar,
+    const TypePtr& type) {
+  if constexpr (cudf::is_fixed_width<T>()) {
+    if (type->isIntervalDayTime()) {
+      using CudfDurationType = cudf::duration_ms;
+      if constexpr (std::is_same_v<T, CudfDurationType::rep>) {
+        using CudfScalarType = cudf::duration_scalar<CudfDurationType>;
+        return cudf::ast::literal{*static_cast<CudfScalarType*>(&scalar)};
+      }
+    } else if (type->isDate()) {
+      using CudfDateType = cudf::timestamp_D;
+      if constexpr (std::is_same_v<T, CudfDateType::rep>) {
+        using CudfScalarType = cudf::timestamp_scalar<CudfDateType>;
+        return cudf::ast::literal{*static_cast<CudfScalarType*>(&scalar)};
+      }
+    } else {
+      // Create a numeric scalar of type T, store it in the scalars vector,
+      // and use its reference in the literal expression.
+      using CudfScalarType = cudf::numeric_scalar<T>;
+      return cudf::ast::literal{*static_cast<CudfScalarType*>(&scalar)};
+    }
+    VELOX_FAIL("Unsupported base type for literal");
+  } else if (type->kind() == TypeKind::VARCHAR) {
+    return cudf::ast::literal{*static_cast<cudf::string_scalar*>(&scalar)};
+  } else {
+    // TODO for non-numeric types too.
+    VELOX_NYI(
+        "Non-numeric types not yet implemented for type {}", type->toString());
+  }
+}
+
+template <TypeKind kind>
+variant getVariant(const VectorPtr& vector, size_t atIndex = 0) {
+  using T = typename facebook::velox::KindToFlatVector<kind>::WrapperType;
+  if constexpr (!std::is_same_v<T, ComplexType>) {
+    return vector->as<SimpleVector<T>>()->valueAt(atIndex);
+  } else {
+    return Variant();
+  }
+}
+
+template <typename T>
+std::unique_ptr<cudf::scalar> makeScalarFromValue(
+    const TypePtr& type,
+    T value,
+    bool isNull,
+    std::optional<cudf::type_id> toType = std::nullopt) {
+  auto stream = cudf::get_default_stream();
+  auto mr = cudf::get_current_device_resource_ref();
+
+  if constexpr (cudf::is_fixed_width<T>()) {
+    if (type->isDecimal()) {
+      VELOX_FAIL("Decimal not supported");
+      /* TODO: enable after rewriting using binary ops
+     using CudfDecimalType = cudf::numeric::decimal64;
+     using cudfScalarType = cudf::fixed_point_scalar<CudfDecimalType>;
+     auto scalar = std::make_unique<cudfScalarType>(value,
+                   type->scale(),
+                    true,
+                    stream,
+                    mr);*/
+    } else if (type->isIntervalYearMonth()) {
+      VELOX_FAIL("Interval year month not supported");
+    } else if (type->isIntervalDayTime()) {
+      using CudfDurationType = cudf::duration_ms;
+      if constexpr (std::is_same_v<T, CudfDurationType::rep>) {
+        return std::make_unique<cudf::duration_scalar<CudfDurationType>>(
+            value, !isNull, stream, mr);
+      }
+    } else if (type->isDate()) {
+      using CudfDateType = cudf::timestamp_D;
+      if constexpr (std::is_same_v<T, CudfDateType::rep>) {
+        return std::make_unique<cudf::timestamp_scalar<CudfDateType>>(
+            value, !isNull, stream, mr);
+      }
+    } else if (toType.has_value()) {
+      if (toType == cudf::type_id::DURATION_DAYS) {
+        return std::make_unique<cudf::duration_scalar<cudf::duration_D>>(
+            value, !isNull, stream, mr);
+      }
+      VELOX_FAIL(
+          "Unsupported result type {}", static_cast<int32_t>(toType.value()));
+    } else {
+      return std::make_unique<cudf::numeric_scalar<T>>(
+          value, !isNull, stream, mr);
+    }
+    VELOX_FAIL("Unsupported fixed-width scalar type");
+  } else if constexpr (
+      std::is_same_v<T, StringView> || std::is_same_v<T, std::string_view> ||
+      std::is_same_v<T, std::string>) {
+    return std::make_unique<cudf::string_scalar>(
+        std::string_view(value.data(), value.size()), !isNull, stream, mr);
+  }
+  VELOX_NYI("Scalar creation not implemented for type " + type->toString());
+}
+
+template <TypeKind Kind>
+static std::unique_ptr<cudf::scalar> createCudfScalar(
+    const velox::VectorPtr& value,
+    std::optional<cudf::type_id> toType = std::nullopt) {
+  using T = typename TypeTraits<Kind>::NativeType;
+  auto vector = value->as<velox::ConstantVector<T>>();
+  return makeScalarFromValue<T>(
+      vector->type(), vector->value(), vector->isNullAt(0), toType);
+}
+
+inline std::unique_ptr<cudf::scalar> makeScalarFromConstantExpr(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    std::optional<cudf::type_id> toType = std::nullopt) {
+  auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr);
+  VELOX_CHECK_NOT_NULL(constExpr);
+  auto constValue = constExpr->value();
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      createCudfScalar, constValue->typeKind(), constValue, toType);
+}
+
+template <TypeKind kind>
+cudf::ast::literal makeScalarAndLiteral(
+    const TypePtr& type,
+    const variant& var,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars) {
+  using T = typename TypeTraits<kind>::NativeType;
+  if constexpr (cudf::is_fixed_width<T>() || kind == TypeKind::VARCHAR) {
+    auto value = var.value<T>();
+    auto scalar = makeScalarFromValue(type, value, false);
+    scalars.emplace_back(std::move(scalar));
+    return makeLiteralFromScalar<T>(*(scalars.back()), type);
+  }
+  VELOX_NYI("Scalar creation not implemented for type " + type->toString());
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/CMakeLists.txt b/velox/experimental/cudf/expression/CMakeLists.txt
new file mode 100644
index 000000000000..1f4f3ec876cf
--- /dev/null
+++ b/velox/experimental/cudf/expression/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_library(
+  velox_cudf_expression
+  AstExpression.cpp
+  ExpressionEvaluator.cpp
+  SubfieldFiltersToAst.cpp
+)
+
+target_link_libraries(
+  velox_cudf_expression
+  PUBLIC cudf::cudf
+  PRIVATE arrow velox_exception velox_common_base velox_cudf_vector
+)
+
+target_compile_options(velox_cudf_expression PRIVATE -Wno-missing-field-initializers)
diff --git a/velox/experimental/cudf/expression/ExpressionEvaluator.cpp b/velox/experimental/cudf/expression/ExpressionEvaluator.cpp
new file mode 100644
index 000000000000..4eefb404bbc6
--- /dev/null
+++ b/velox/experimental/cudf/expression/ExpressionEvaluator.cpp
@@ -0,0 +1,1196 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/exec/Validation.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/AstUtils.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/expression/ConstantExpr.h"
+#include "velox/expression/FieldReference.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/expression/SignatureBinder.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+
+#include <cudf/binaryop.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/copying.hpp>
+#include <cudf/datetime.hpp>
+#include <cudf/hashing.hpp>
+#include <cudf/lists/count_elements.hpp>
+#include <cudf/replace.hpp>
+#include <cudf/round.hpp>
+#include <cudf/strings/attributes.hpp>
+#include <cudf/strings/case.hpp>
+#include <cudf/strings/contains.hpp>
+#include <cudf/strings/find.hpp>
+#include <cudf/strings/slice.hpp>
+#include <cudf/strings/split/split.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/transform.hpp>
+#include <cudf/unary.hpp>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+struct CudfExpressionEvaluatorEntry {
+  int priority;
+  CudfExpressionEvaluatorCanEvaluate canEvaluate;
+  CudfExpressionEvaluatorCreate create;
+};
+
+static std::unordered_map<std::string, CudfExpressionEvaluatorEntry>&
+getCudfExpressionEvaluatorRegistry() {
+  static std::unordered_map<std::string, CudfExpressionEvaluatorEntry> registry;
+  return registry;
+}
+
+static void ensureBuiltinExpressionEvaluatorsRegistered() {
+  static bool registered = false;
+  if (registered) {
+    return;
+  }
+
+  // Default priority for function evaluator
+  const int kFunctionPriority = 50;
+
+  // Function evaluator
+  registerCudfExpressionEvaluator(
+      "function",
+      kFunctionPriority,
+      [](std::shared_ptr<velox::exec::Expr> expr) {
+        return FunctionExpression::canEvaluate(std::move(expr));
+      },
+      [](std::shared_ptr<velox::exec::Expr> expr, const RowTypePtr& row) {
+        return FunctionExpression::create(std::move(expr), row);
+      },
+      /*overwrite=*/false);
+
+  registered = true;
+}
+
+} // namespace
+
+bool registerCudfExpressionEvaluator(
+    const std::string& name,
+    int priority,
+    CudfExpressionEvaluatorCanEvaluate canEvaluate,
+    CudfExpressionEvaluatorCreate create,
+    bool overwrite) {
+  auto& registry = getCudfExpressionEvaluatorRegistry();
+  if (!overwrite && registry.find(name) != registry.end()) {
+    return false;
+  }
+  registry[name] = CudfExpressionEvaluatorEntry{
+      priority, std::move(canEvaluate), std::move(create)};
+  return true;
+}
+
+std::unordered_map<std::string, CudfFunctionSpec>& getCudfFunctionRegistry() {
+  static std::unordered_map<std::string, CudfFunctionSpec> registry;
+  return registry;
+}
+
+namespace {
+
+static bool matchCallAgainstSignatures(
+    const velox::exec::Expr& call,
+    const std::vector<exec::FunctionSignaturePtr>& sigs) {
+  const auto n = call.inputs().size();
+  std::vector<TypePtr> argTypes;
+  argTypes.reserve(n);
+  for (const auto& in : call.inputs()) {
+    argTypes.push_back(in->type());
+  }
+  for (const auto& sig : sigs) {
+    exec::SignatureBinder binder(*sig, argTypes);
+    if (!binder.tryBind()) {
+      continue;
+    }
+    // binder does not confirm whether positional arguments are
+    // constants(scalars) as expected. we have to check manually
+    const auto& constArgs = sig->constantArguments();
+    const size_t fixed = std::min(constArgs.size(), n);
+    bool ok = true;
+    for (size_t i = 0; i < fixed; ++i) {
+      if (constArgs[i] && call.inputs()[i]->name() != "literal") {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+
+} // namespace
+
+class SplitFunction : public CudfFunction {
+ public:
+  SplitFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+
+    auto stream = cudf::get_default_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+
+    auto delimiterExpr =
+        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
+    VELOX_CHECK_NOT_NULL(delimiterExpr, "split delimiter must be a constant");
+    delimiterScalar_ = std::make_unique<cudf::string_scalar>(
+        delimiterExpr->value()->toString(0), true, stream, mr);
+
+    auto limitExpr =
+        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr->inputs()[2]);
+    VELOX_CHECK_NOT_NULL(limitExpr, "split limit must be a constant");
+    maxSplitCount_ = std::stoll(limitExpr->value()->toString(0));
+
+    // Presto specifies maxSplitCount as the maximum size of the returned array
+    // while cuDF understands the parameter as how many splits can it perform.
+    maxSplitCount_ -= 1;
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::split_record(
+        inputCol, *delimiterScalar_, maxSplitCount_, stream, mr);
+  };
+
+ private:
+  std::unique_ptr<cudf::string_scalar> delimiterScalar_;
+  cudf::size_type maxSplitCount_;
+};
+
+class CastFunction : public CudfFunction {
+ public:
+  CastFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(expr->inputs().size(), 1, "cast expects exactly 1 input");
+
+    targetCudfType_ =
+        cudf::data_type(cudf_velox::veloxToCudfTypeId(expr->type()));
+    auto sourceType = cudf::data_type(
+        cudf_velox::veloxToCudfTypeId(expr->inputs()[0]->type()));
+    VELOX_CHECK(
+        cudf::is_supported_cast(sourceType, targetCudfType_),
+        "Cast from {} to {} is not supported",
+        expr->inputs()[0]->type()->toString(),
+        expr->type()->toString());
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::cast(inputCol, targetCudfType_, stream, mr);
+  }
+
+ private:
+  cudf::data_type targetCudfType_;
+};
+
+// Spark date_add function implementation.
+// For the presto date_add, the first value is unit string,
+// may need to get the function with prefix, if the prefix is "", it is Spark
+// function.
+class DateAddFunction : public CudfFunction {
+ public:
+  DateAddFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 2, "date_add function expects exactly 2 inputs");
+    VELOX_CHECK(
+        expr->inputs()[0]->type()->isDate(),
+        "First argument to date_add must be a date");
+    VELOX_CHECK_NULL(
+        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[0]));
+    // The date_add second argument could be int8_t, int16_t, int32_t.
+    value_ = makeScalarFromConstantExpr(
+        expr->inputs()[1], cudf::type_id::DURATION_DAYS);
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::binary_operation(
+        inputCol,
+        *value_,
+        cudf::binary_operator::ADD,
+        cudf::data_type(cudf::type_id::TIMESTAMP_DAYS),
+        stream,
+        mr);
+  }
+
+ private:
+  std::unique_ptr<cudf::scalar> value_;
+};
+
+class CardinalityFunction : public CudfFunction {
+ public:
+  CardinalityFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    // Cardinality doesn't need any pre-computed scalars, just validates input
+    // count
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "cardinality expects exactly 1 input");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::lists::count_elements(inputCol, stream, mr);
+  }
+};
+
+class RoundFunction : public CudfFunction {
+ public:
+  explicit RoundFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    const auto argSize = expr->inputs().size();
+    VELOX_CHECK(argSize >= 1 && argSize <= 2, "round expects 1 or 2 inputs");
+    VELOX_CHECK_NULL(
+        std::dynamic_pointer_cast<exec::ConstantExpr>(expr->inputs()[0]),
+        "round expects first column is not literal");
+    if (argSize == 2) {
+      auto scaleExpr =
+          std::dynamic_pointer_cast<exec::ConstantExpr>(expr->inputs()[1]);
+      VELOX_CHECK_NOT_NULL(scaleExpr, "round scale must be a constant");
+      scale_ = scaleExpr->value()->as<SimpleVector<int32_t>>()->valueAt(0);
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    return cudf::round_decimal(
+        asView(inputColumns[0]),
+        scale_,
+        cudf::rounding_method::HALF_UP,
+        stream,
+        mr);
+    ;
+  }
+
+ private:
+  int32_t scale_ = 0;
+};
+
+class BinaryFunction : public CudfFunction {
+ public:
+  BinaryFunction(
+      const std::shared_ptr<velox::exec::Expr>& expr,
+      cudf::binary_operator op)
+      : op_(op),
+        type_(cudf::data_type(cudf_velox::veloxToCudfTypeId(expr->type()))) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 2, "binary function expects exactly 2 inputs");
+    if (auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[0])) {
+      auto constValue = constExpr->value();
+      left_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    } else if (
+        auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[1])) {
+      auto constValue = constExpr->value();
+      right_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    }
+
+    VELOX_CHECK(
+        !(left_ != nullptr && right_ != nullptr),
+        "Not support both left and right are literals");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    if (left_ == nullptr && right_ == nullptr) {
+      return cudf::binary_operation(
+          asView(inputColumns[0]),
+          asView(inputColumns[1]),
+          op_,
+          type_,
+          stream,
+          mr);
+    } else if (left_ == nullptr) {
+      return cudf::binary_operation(
+          asView(inputColumns[0]), *right_, op_, type_, stream, mr);
+    }
+    return cudf::binary_operation(
+        *left_, asView(inputColumns[0]), op_, type_, stream, mr);
+  }
+
+ private:
+  const cudf::binary_operator op_;
+  const cudf::data_type type_;
+  std::unique_ptr<cudf::scalar> left_;
+  std::unique_ptr<cudf::scalar> right_;
+};
+
+class SwitchFunction : public CudfFunction {
+ public:
+  SwitchFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 3, "case when expects exactly 3 inputs");
+    VELOX_CHECK_EQ(
+        expr->inputs()[0]->type()->kind(),
+        TypeKind::BOOLEAN,
+        "The switch condition result type should be boolean");
+    VELOX_CHECK_NULL(
+        std::dynamic_pointer_cast<velox::exec::ConstantExpr>(expr),
+        "The condition should not be constant");
+    if (auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[1])) {
+      auto constValue = constExpr->value();
+      left_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    }
+    if (auto constExpr = std::dynamic_pointer_cast<velox::exec::ConstantExpr>(
+            expr->inputs()[2])) {
+      auto constValue = constExpr->value();
+      right_ = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          createCudfScalar, constValue->typeKind(), constValue);
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    if (left_ == nullptr && right_ == nullptr) {
+      return cudf::copy_if_else(
+          asView(inputColumns[1]),
+          asView(inputColumns[2]),
+          asView(inputColumns[0]),
+          stream,
+          mr);
+    } else if (left_ == nullptr) {
+      return cudf::copy_if_else(
+          asView(inputColumns[1]),
+          *right_,
+          asView(inputColumns[0]),
+          stream,
+          mr);
+    } else if (right_ == nullptr) {
+      return cudf::copy_if_else(
+          *left_, asView(inputColumns[1]), asView(inputColumns[0]), stream, mr);
+    }
+    // right != null and left != null
+    return cudf::copy_if_else(
+        *left_, *right_, asView(inputColumns[0]), stream, mr);
+  }
+
+ private:
+  std::unique_ptr<cudf::scalar> left_;
+  std::unique_ptr<cudf::scalar> right_;
+};
+
+class SubstrFunction : public CudfFunction {
+ public:
+  SubstrFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+
+    VELOX_CHECK_GE(
+        expr->inputs().size(), 2, "substr expects at least 2 inputs");
+    VELOX_CHECK_LE(expr->inputs().size(), 3, "substr expects at most 3 inputs");
+
+    auto stream = cudf::get_default_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+
+    auto startExpr = std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
+    VELOX_CHECK_NOT_NULL(startExpr, "substr start must be a constant");
+
+    auto startValue =
+        startExpr->value()->as<SimpleVector<int64_t>>()->valueAt(0);
+    cudf::size_type adjustedStart = static_cast<cudf::size_type>(startValue);
+    if (startValue >= 1) {
+      // cuDF indexing starts at 0.
+      // Presto indexing starts at 1.
+      // Positive indices need to substract 1.
+      adjustedStart = static_cast<cudf::size_type>(startValue - 1);
+    }
+
+    startScalar_ = std::make_unique<cudf::numeric_scalar<cudf::size_type>>(
+        adjustedStart, true, stream, mr);
+
+    if (expr->inputs().size() > 2) {
+      auto lengthExpr =
+          std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[2]);
+      VELOX_CHECK_NOT_NULL(lengthExpr, "substr length must be a constant");
+
+      auto lengthValue =
+          lengthExpr->value()->as<SimpleVector<int64_t>>()->valueAt(0);
+      // cuDF uses indices [begin, end).
+      // Presto uses length as the length of the substring.
+      // We compute the end as start + length.
+      cudf::size_type endPosition =
+          adjustedStart + static_cast<cudf::size_type>(lengthValue);
+
+      endScalar_ = std::make_unique<cudf::numeric_scalar<cudf::size_type>>(
+          endPosition, true, stream, mr);
+    } else {
+      endScalar_ = std::make_unique<cudf::numeric_scalar<cudf::size_type>>(
+          0, false, stream, mr);
+    }
+
+    stepScalar_ = std::make_unique<cudf::numeric_scalar<cudf::size_type>>(
+        1, true, stream, mr);
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::slice_strings(
+        inputCol, *startScalar_, *endScalar_, *stepScalar_, stream, mr);
+  }
+
+ private:
+  std::unique_ptr<cudf::numeric_scalar<cudf::size_type>> startScalar_;
+  std::unique_ptr<cudf::numeric_scalar<cudf::size_type>> endScalar_;
+  std::unique_ptr<cudf::numeric_scalar<cudf::size_type>> stepScalar_;
+};
+
+class CoalesceFunction : public CudfFunction {
+ public:
+  CoalesceFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+
+    // Storing the first literal that appears in inputs because we don't need to
+    // process after that. This is the last fallback.
+    numColumnsBeforeLiteral_ = expr->inputs().size();
+    for (size_t i = 0; i < expr->inputs().size(); ++i) {
+      const auto& input = expr->inputs()[i];
+      if (auto c =
+              std::dynamic_pointer_cast<velox::exec::ConstantExpr>(input)) {
+        if (!c->value()->isNullAt(0)) {
+          literalScalar_ = makeScalarFromConstantExpr(c);
+          numColumnsBeforeLiteral_ = i;
+          break;
+        }
+      }
+    }
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    std::cout << "CoalesceFunction::eval" << std::endl;
+    // Coalesce is practically a cudf::replace_nulls over multiple columns.
+    // Starting from first column, we keep calling replace nulls with
+    // subsequent cols until we get an all valid col or run out of columns
+
+    // If a literal comes before any column input, fill the result with it.
+    if (literalScalar_ && numColumnsBeforeLiteral_ == 0) {
+      if (inputColumns.empty()) {
+        // We need at least one column to tell us the required output size
+        VELOX_NYI("coalesce with only literal inputs is not supported");
+      }
+      auto size = asView(inputColumns[0]).size();
+      return cudf::make_column_from_scalar(*literalScalar_, size, stream, mr);
+    }
+
+    VELOX_CHECK(
+        !inputColumns.empty(),
+        "coalesce requires at least one non-literal input");
+    ColumnOrView result = asView(inputColumns[0]);
+    size_t stop = std::min(numColumnsBeforeLiteral_, inputColumns.size());
+    for (size_t i = 1; i < stop && asView(result).has_nulls(); ++i) {
+      result = cudf::replace_nulls(
+          asView(result), asView(inputColumns[i]), stream, mr);
+    }
+
+    if (literalScalar_ && asView(result).has_nulls()) {
+      result = cudf::replace_nulls(asView(result), *literalScalar_, stream, mr);
+    }
+
+    return result;
+  }
+
+ private:
+  size_t numColumnsBeforeLiteral_;
+  std::unique_ptr<cudf::scalar> literalScalar_;
+};
+
+class HashFunction : public CudfFunction {
+ public:
+  HashFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+    VELOX_CHECK_GE(expr->inputs().size(), 2, "hash expects at least 2 inputs");
+    auto seedExpr = std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[0]);
+    VELOX_CHECK_NOT_NULL(seedExpr, "hash seed must be a constant");
+    int32_t seedValue =
+        seedExpr->value()->as<SimpleVector<int32_t>>()->valueAt(0);
+    VELOX_CHECK_GE(seedValue, 0);
+    seedValue_ = seedValue;
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    VELOX_CHECK(!inputColumns.empty());
+    auto inputTableView = convertToTableView(inputColumns);
+    return cudf::hashing::murmurhash3_x86_32(
+        inputTableView, seedValue_, stream, mr);
+  }
+
+ private:
+  static cudf::table_view convertToTableView(
+      std::vector<ColumnOrView>& inputColumns) {
+    std::vector<cudf::column_view> columns;
+    columns.reserve(inputColumns.size());
+
+    for (auto& col : inputColumns) {
+      columns.push_back(asView(col));
+    }
+
+    return cudf::table_view(columns);
+  }
+
+  uint32_t seedValue_;
+};
+
+class YearFunction : public CudfFunction {
+ public:
+  explicit YearFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "year expects exactly 1 input column");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::datetime::extract_datetime_component(
+        inputCol, cudf::datetime::datetime_component::YEAR, stream, mr);
+  }
+};
+
+class LengthFunction : public CudfFunction {
+ public:
+  explicit LengthFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "length expects exactly 1 input column");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::count_characters(inputCol, stream, mr);
+  }
+};
+
+class LowerFunction : public CudfFunction {
+ public:
+  explicit LowerFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "lower expects exactly 1 input column");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::to_lower(inputCol, stream, mr);
+  }
+};
+
+class UpperFunction : public CudfFunction {
+ public:
+  explicit UpperFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    VELOX_CHECK_EQ(
+        expr->inputs().size(), 1, "upper expects exactly 1 input column");
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::to_upper(inputCol, stream, mr);
+  }
+};
+
+class LikeFunction : public CudfFunction {
+ public:
+  explicit LikeFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+    VELOX_CHECK_EQ(expr->inputs().size(), 2, "like expects 2 inputs");
+
+    auto patternExpr =
+        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
+    VELOX_CHECK_NOT_NULL(patternExpr, "like pattern must be a constant");
+    pattern_ = patternExpr->value()->toString(0);
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::like(
+        inputCol, pattern_, std::string_view(""), stream, mr);
+  }
+
+ private:
+  std::string pattern_;
+};
+
+class StartswithFunction : public CudfFunction {
+ public:
+  explicit StartswithFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+    VELOX_CHECK_EQ(expr->inputs().size(), 2, "startswith expects 2 inputs");
+
+    auto stream = cudf::get_default_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+
+    auto patternExpr =
+        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
+    VELOX_CHECK_NOT_NULL(patternExpr, "startswith pattern must be a constant");
+    pattern_ = std::make_unique<cudf::string_scalar>(
+        patternExpr->value()->toString(0), true, stream, mr);
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::starts_with(inputCol, *pattern_, stream, mr);
+  }
+
+ private:
+  std::unique_ptr<cudf::string_scalar> pattern_;
+};
+
+class EndswithFunction : public CudfFunction {
+ public:
+  explicit EndswithFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+    VELOX_CHECK_EQ(expr->inputs().size(), 2, "endswith expects 2 inputs");
+
+    auto stream = cudf::get_default_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+
+    auto patternExpr =
+        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
+    VELOX_CHECK_NOT_NULL(patternExpr, "endswith pattern must be a constant");
+    pattern_ = std::make_unique<cudf::string_scalar>(
+        patternExpr->value()->toString(0), true, stream, mr);
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::ends_with(inputCol, *pattern_, stream, mr);
+  }
+
+ private:
+  std::unique_ptr<cudf::string_scalar> pattern_;
+};
+
+class ContainsFunction : public CudfFunction {
+ public:
+  explicit ContainsFunction(const std::shared_ptr<velox::exec::Expr>& expr) {
+    using velox::exec::ConstantExpr;
+    VELOX_CHECK_EQ(expr->inputs().size(), 2, "contains expects 2 inputs");
+
+    auto stream = cudf::get_default_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+
+    auto patternExpr =
+        std::dynamic_pointer_cast<ConstantExpr>(expr->inputs()[1]);
+    VELOX_CHECK_NOT_NULL(patternExpr, "contains pattern must be a constant");
+    pattern_ = std::make_unique<cudf::string_scalar>(
+        patternExpr->value()->toString(0), true, stream, mr);
+  }
+
+  ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const override {
+    auto inputCol = asView(inputColumns[0]);
+    return cudf::strings::contains(inputCol, *pattern_, stream, mr);
+  }
+
+ private:
+  std::unique_ptr<cudf::string_scalar> pattern_;
+};
+
+bool registerCudfFunction(
+    const std::string& name,
+    CudfFunctionFactory factory,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite) {
+  auto& registry = getCudfFunctionRegistry();
+  if (!overwrite && registry.find(name) != registry.end()) {
+    return false;
+  }
+  registry[name] = CudfFunctionSpec{std::move(factory), signatures};
+  return true;
+}
+
+void registerCudfFunctions(
+    const std::vector<std::string>& aliases,
+    CudfFunctionFactory factory,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite) {
+  for (const auto& name : aliases) {
+    registerCudfFunction(name, factory, signatures, overwrite);
+  }
+}
+
+std::shared_ptr<CudfFunction> createCudfFunction(
+    const std::string& name,
+    const std::shared_ptr<velox::exec::Expr>& expr) {
+  auto& registry = getCudfFunctionRegistry();
+  auto it = registry.find(name);
+  if (it != registry.end()) {
+    return it->second.factory(name, expr);
+  }
+  return nullptr;
+}
+
+bool registerBuiltinFunctions(const std::string& prefix) {
+  using exec::FunctionSignatureBuilder;
+
+  registerCudfFunction(
+      prefix + "split",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<SplitFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("array(varchar)")
+           .argumentType("varchar")
+           .constantArgumentType("varchar")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("array(varchar)")
+           .argumentType("varchar")
+           .constantArgumentType("varchar")
+           // cuDF expects cudf::size_type (int32) but we may get bigint from
+           // presto. SplitFunction hacks around this by converting to string
+           // and back
+           .constantArgumentType("bigint")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "cardinality",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<CardinalityFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("array(any)")
+           .build()});
+
+  registerCudfFunctions(
+      {prefix + "substr", prefix + "substring"},
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<SubstrFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .constantArgumentType("bigint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .constantArgumentType("bigint")
+           .constantArgumentType("bigint")
+           .build()});
+
+  // Coalesce is special form and doesn't have a prefix in its name.
+  registerCudfFunction(
+      "coalesce",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<CoalesceFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .typeVariable("T")
+           .returnType("T")
+           .argumentType("T")
+           .variableArity("T")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "hash_with_seed",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<HashFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("bigint")
+           .constantArgumentType("integer")
+           .argumentType("any")
+           .variableArity()
+           .build()});
+
+  registerCudfFunction(
+      prefix + "round",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<RoundFunction>(expr);
+      },
+      {// TODO(dm): Enable after adding decimal support to velox-cudf
+       //   FunctionSignatureBuilder()
+       //      .integerVariable("p")
+       //      .integerVariable("s")
+       //      .returnType("decimal(p,s)")
+       //      .argumentType("decimal(p,s)")
+       //      .build(),
+       //  FunctionSignatureBuilder()
+       //      .integerVariable("p")
+       //      .integerVariable("s")
+       //      .returnType("decimal(p,s)")
+       //      .argumentType("decimal(p,s)")
+       //      .constantArgumentType("integer")
+       //      .build(),
+       FunctionSignatureBuilder()
+           .returnType("tinyint")
+           .argumentType("tinyint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("tinyint")
+           .argumentType("tinyint")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("smallint")
+           .argumentType("smallint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("smallint")
+           .argumentType("smallint")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("integer")
+           .constantArgumentType("integer")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("bigint")
+           .argumentType("bigint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("bigint")
+           .argumentType("bigint")
+           .constantArgumentType("integer")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "year",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<YearFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("timestamp")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("integer")
+           .argumentType("date")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "length",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<LengthFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("bigint")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "lower",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<LowerFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "upper",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<UpperFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("varchar")
+           .argumentType("varchar")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "like",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<LikeFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("varchar")
+           .constantArgumentType("varchar")
+           .build()});
+
+  // Our cudf binary ops can take all numeric types but instead of listing them
+  // all, we're testing if input types can be casted to double. Coersion will
+  // pass because all numerics can be casted to double.
+  // TODO (dm): This could break for decimal
+  registerCudfFunctions(
+      {prefix + "greaterthan", prefix + "gt"},
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<BinaryFunction>(
+            expr, cudf::binary_operator::GREATER);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("boolean")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+
+  registerCudfFunction(
+      prefix + "divide",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<BinaryFunction>(
+            expr, cudf::binary_operator::DIV);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("double")
+           .argumentType("double")
+           .argumentType("double")
+           .build()});
+
+  // No prefix because switch and if are special form
+  registerCudfFunctions(
+      {"switch", "if"},
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<SwitchFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .typeVariable("T")
+           .returnType("T")
+           .argumentType("boolean")
+           .argumentType("T")
+           .argumentType("T")
+           .build()});
+
+  registerCudfFunctions(
+      // No signatures required for cast and try_cast. They are special forms.
+      {"try_cast", "cast"},
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<CastFunction>(expr);
+      },
+      {
+          // Cast needs special handling dynamically using cudf.
+      });
+
+  registerCudfFunction(
+      prefix + "date_add",
+      [](const std::string&, const std::shared_ptr<velox::exec::Expr>& expr) {
+        return std::make_shared<DateAddFunction>(expr);
+      },
+      {FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .constantArgumentType("tinyint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .constantArgumentType("smallint")
+           .build(),
+       FunctionSignatureBuilder()
+           .returnType("date")
+           .argumentType("date")
+           .constantArgumentType("integer")
+           .build()});
+
+  return true;
+}
+
+std::shared_ptr<FunctionExpression> FunctionExpression::create(
+    const std::shared_ptr<velox::exec::Expr>& expr,
+    const RowTypePtr& inputRowSchema) {
+  auto node = std::make_shared<FunctionExpression>();
+  node->expr_ = expr;
+  node->inputRowSchema_ = inputRowSchema;
+
+  auto name = expr->name();
+  node->function_ = createCudfFunction(name, expr);
+
+  if (node->function_) {
+    for (const auto& input : expr->inputs()) {
+      if (input->name() != "literal") {
+        node->subexpressions_.push_back(
+            createCudfExpression(input, inputRowSchema));
+      }
+    }
+  }
+
+  return node;
+}
+
+ColumnOrView FunctionExpression::eval(
+    std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr,
+    bool finalize) {
+  using velox::exec::FieldReference;
+
+  if (auto fieldExpr = std::dynamic_pointer_cast<FieldReference>(expr_)) {
+    auto name = fieldExpr->name();
+    auto columnIndex = inputRowSchema_->getChildIdx(name);
+    return inputTableColumns[columnIndex]->view();
+  }
+
+  if (function_) {
+    std::vector<ColumnOrView> inputColumns;
+    inputColumns.reserve(subexpressions_.size());
+
+    for (const auto& subexpr : subexpressions_) {
+      inputColumns.push_back(subexpr->eval(inputTableColumns, stream, mr));
+    }
+
+    auto result = function_->eval(inputColumns, stream, mr);
+    if (finalize) {
+      const auto requestedType =
+          cudf::data_type(cudf_velox::veloxToCudfTypeId(expr_->type()));
+      auto resultView = asView(result);
+      if (resultView.type() != requestedType) {
+        return cudf::cast(resultView, requestedType, stream, mr);
+      }
+    }
+    return result;
+  }
+
+  VELOX_FAIL(
+      "Unsupported expression for recursive evaluation: " + expr_->name());
+}
+
+void FunctionExpression::close() {
+  function_.reset();
+  subexpressions_.clear();
+}
+
+bool FunctionExpression::canEvaluate(std::shared_ptr<velox::exec::Expr> expr) {
+  using velox::exec::FieldReference;
+
+  if (std::dynamic_pointer_cast<FieldReference>(expr)) {
+    return true;
+  }
+
+  const auto& opName = expr->name();
+  if (opName == "cast" || opName == "try_cast") {
+    const auto& srcType =
+        expr->inputs().empty() ? nullptr : expr->inputs()[0]->type();
+    const auto& dstType = expr->type();
+    if (srcType == nullptr || dstType == nullptr) {
+      return false;
+    }
+    auto src = cudf::data_type(cudf_velox::veloxToCudfTypeId(srcType));
+    auto dst = cudf::data_type(cudf_velox::veloxToCudfTypeId(dstType));
+    return cudf::is_supported_cast(src, dst);
+  }
+
+  auto& registry = getCudfFunctionRegistry();
+  auto it = registry.find(expr->name());
+  if (it == registry.end()) {
+    return false;
+  }
+  const auto& spec = it->second;
+  return matchCallAgainstSignatures(*expr, spec.signatures);
+}
+
+bool canBeEvaluatedByCudf(std::shared_ptr<velox::exec::Expr> expr, bool deep) {
+  ensureBuiltinExpressionEvaluatorsRegistered();
+  const auto& registry = getCudfExpressionEvaluatorRegistry();
+
+  bool supported = false;
+  for (const auto& [name, entry] : registry) {
+    if (entry.canEvaluate && entry.canEvaluate(expr)) {
+      supported = true;
+      break;
+    }
+  }
+  if (!supported) {
+    LOG_FALLBACK(expr->toString());
+    return false;
+  }
+
+  if (deep) {
+    for (const auto& input : expr->inputs()) {
+      if (input->name() != "literal" && !canBeEvaluatedByCudf(input, true)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+std::shared_ptr<CudfExpression> createCudfExpression(
+    std::shared_ptr<velox::exec::Expr> expr,
+    const RowTypePtr& inputRowSchema,
+    std::optional<std::string> except) {
+  ensureBuiltinExpressionEvaluatorsRegistered();
+  const auto& registry = getCudfExpressionEvaluatorRegistry();
+
+  const CudfExpressionEvaluatorEntry* best = nullptr;
+  for (const auto& [name, entry] : registry) {
+    if (except && name == *except) {
+      continue;
+    }
+    if (entry.canEvaluate && entry.canEvaluate(expr)) {
+      if (best == nullptr || entry.priority > best->priority) {
+        best = &entry;
+      }
+    }
+  }
+
+  if (best != nullptr) {
+    return best->create(expr, inputRowSchema);
+  }
+
+  return FunctionExpression::create(expr, inputRowSchema);
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/ExpressionEvaluator.h b/velox/experimental/cudf/expression/ExpressionEvaluator.h
new file mode 100644
index 000000000000..124b4f14afb9
--- /dev/null
+++ b/velox/experimental/cudf/expression/ExpressionEvaluator.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/expression/Expr.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/type/Type.h"
+
+#include <cudf/column/column.hpp>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace facebook::velox::cudf_velox {
+
+// Holds either a non-owning cudf::column_view (zero-copy) or an owning
+// cudf::column (materialised result).
+using ColumnOrView =
+    std::variant<cudf::column_view, std::unique_ptr<cudf::column>>;
+
+// Helper to always obtain a column_view.
+inline cudf::column_view asView(ColumnOrView& holder) {
+  return std::visit(
+      [](auto& h) -> cudf::column_view {
+        using T = std::decay_t<decltype(h)>;
+        if constexpr (std::is_same_v<T, cudf::column_view>) {
+          return h;
+        } else {
+          return h->view();
+        }
+      },
+      holder);
+}
+
+class CudfFunction {
+ public:
+  virtual ~CudfFunction() = default;
+  virtual ColumnOrView eval(
+      std::vector<ColumnOrView>& inputColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr) const = 0;
+};
+
+using CudfFunctionFactory = std::function<std::shared_ptr<CudfFunction>(
+    const std::string& name,
+    const std::shared_ptr<velox::exec::Expr>& expr)>;
+
+struct CudfFunctionSpec {
+  CudfFunctionFactory factory;
+  std::vector<exec::FunctionSignaturePtr> signatures;
+};
+
+bool registerCudfFunction(
+    const std::string& name,
+    CudfFunctionFactory factory,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite = true);
+
+void registerCudfFunctions(
+    const std::vector<std::string>& aliases,
+    CudfFunctionFactory factory,
+    const std::vector<exec::FunctionSignaturePtr>& signatures,
+    bool overwrite = true);
+
+bool registerBuiltinFunctions(const std::string& prefix);
+
+class CudfExpression {
+ public:
+  virtual ~CudfExpression() = default;
+  virtual void close() = 0;
+
+  virtual ColumnOrView eval(
+      std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr,
+      bool finalize = false) = 0;
+};
+
+using CudfExpressionPtr = std::shared_ptr<CudfExpression>;
+
+using CudfExpressionEvaluatorCanEvaluate =
+    std::function<bool(std::shared_ptr<velox::exec::Expr> expr)>;
+using CudfExpressionEvaluatorCreate =
+    std::function<std::shared_ptr<CudfExpression>(
+        std::shared_ptr<velox::exec::Expr> expr,
+        const RowTypePtr& inputRowSchema)>;
+
+// Register a CudfExpression evaluator.
+// - name: unique identifier (e.g., "ast", "function", "my_custom").
+// - priority: higher number = higher priority.
+// - canEvaluate: shallow check whether evaluator can handle current expr root.
+// - create: factory to build the evaluator node.
+// - overwrite: replace existing registration with the same name if true.
+bool registerCudfExpressionEvaluator(
+    const std::string& name,
+    int priority,
+    CudfExpressionEvaluatorCanEvaluate canEvaluate,
+    CudfExpressionEvaluatorCreate create,
+    bool overwrite = true);
+
+class FunctionExpression : public CudfExpression {
+ public:
+  static std::shared_ptr<FunctionExpression> create(
+      const std::shared_ptr<velox::exec::Expr>& expr,
+      const RowTypePtr& inputRowSchema);
+
+  // TODO (dm): A storage for keeping results in case this is a multiply
+  // referenced subexpression (to do CSE)
+
+  ColumnOrView eval(
+      std::vector<std::unique_ptr<cudf::column>>& inputTableColumns,
+      rmm::cuda_stream_view stream,
+      rmm::device_async_resource_ref mr,
+      bool finalize = false) override;
+
+  void close() override;
+
+  // Check if this specific operation can be evaluated by FunctionExpression
+  // (does not recursively check children)
+  static bool canEvaluate(std::shared_ptr<velox::exec::Expr> expr);
+
+ private:
+  std::shared_ptr<velox::exec::Expr> expr_;
+  std::shared_ptr<CudfFunction> function_;
+  std::vector<std::shared_ptr<CudfExpression>> subexpressions_;
+
+  RowTypePtr inputRowSchema_;
+};
+
+std::shared_ptr<CudfExpression> createCudfExpression(
+    std::shared_ptr<velox::exec::Expr> expr,
+    const RowTypePtr& inputRowSchema,
+    std::optional<std::string> except = std::nullopt);
+
+/// Lightweight check if an expression tree is supported by any CUDF evaluator
+/// without initializing CudfExpression objects.
+/// \param expr Expression to check
+/// \param deep If true, recursively check all children in the expression tree;
+///             if false, only check if the top-level operation is supported
+///             (useful when delegating to subexpressions)
+bool canBeEvaluatedByCudf(
+    std::shared_ptr<velox::exec::Expr> expr,
+    bool deep = true);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/SubfieldFiltersToAst.cpp b/velox/experimental/cudf/expression/SubfieldFiltersToAst.cpp
new file mode 100644
index 000000000000..01ef05ebd3d8
--- /dev/null
+++ b/velox/experimental/cudf/expression/SubfieldFiltersToAst.cpp
@@ -0,0 +1,462 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/expression/AstUtils.h"
+#include "velox/experimental/cudf/expression/SubfieldFiltersToAst.h"
+
+#include "velox/common/base/Exceptions.h"
+
+#include <cudf/ast/detail/expression_parser.hpp>
+#include <cudf/ast/expressions.hpp>
+#include <cudf/scalar/scalar_device_view.cuh>
+#include <cudf/types.hpp>
+
+#include <limits>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+template <
+    typename RangeT,
+    typename ScalarT,
+    typename = std::enable_if_t<
+        std::is_base_of_v<facebook::velox::common::AbstractRange, RangeT>>>
+const cudf::ast::expression& createRangeExpr(
+    const facebook::velox::common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+
+  auto* range = dynamic_cast<const RangeT*>(&filter);
+  VELOX_CHECK_NOT_NULL(range, "Filter is not the expected range type");
+
+  const bool lowerUnbounded = range->lowerUnbounded();
+  const bool upperUnbounded = range->upperUnbounded();
+
+  const cudf::ast::expression* lowerExpr = nullptr;
+  const cudf::ast::expression* upperExpr = nullptr;
+
+  auto addLiteral = [&](auto value) -> const cudf::ast::expression& {
+    scalars.emplace_back(std::make_unique<ScalarT>(value, true, stream, mr));
+    return tree.push(
+        cudf::ast::literal{*static_cast<ScalarT*>(scalars.back().get())});
+  };
+
+  // If RangeT is BytesValues and it's a single value, return a simple equality
+  // expression. This is an early return for the single-value IN-list filter on
+  // bytes.
+  if constexpr (std::is_same_v<RangeT, facebook::velox::common::BytesRange>) {
+    if (range->isSingleValue()) {
+      // Only one value in the IN-list, so just compare for equality.
+      auto singleValue = range->lower();
+      const auto& literal = addLiteral(singleValue);
+      return tree.push(Operation{Op::EQUAL, columnRef, literal});
+    }
+  }
+
+  if (!lowerUnbounded) {
+    auto lowerValue = range->lower();
+    const auto& lowerLiteral = addLiteral(lowerValue);
+
+    auto lowerOp = range->lowerExclusive() ? Op::GREATER : Op::GREATER_EQUAL;
+    lowerExpr = &tree.push(Operation{lowerOp, columnRef, lowerLiteral});
+  }
+
+  if (!upperUnbounded) {
+    auto upperValue = range->upper();
+    const auto& upperLiteral = addLiteral(upperValue);
+
+    auto upperOp = range->upperExclusive() ? Op::LESS : Op::LESS_EQUAL;
+    upperExpr = &tree.push(Operation{upperOp, columnRef, upperLiteral});
+  }
+
+  if (lowerExpr && upperExpr) {
+    return tree.push(Operation{Op::NULL_LOGICAL_AND, *lowerExpr, *upperExpr});
+  } else if (lowerExpr) {
+    return *lowerExpr;
+  } else if (upperExpr) {
+    return *upperExpr;
+  }
+
+  // Both bounds unbounded => Pass-through filter (everything).
+  return tree.push(Operation{Op::EQUAL, columnRef, columnRef});
+}
+
+template <TypeKind Kind>
+std::reference_wrapper<const cudf::ast::expression> buildBigintRangeExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr,
+    const TypePtr& columnTypePtr) {
+  using NativeT = typename TypeTraits<Kind>::NativeType;
+
+  if constexpr (std::is_integral_v<NativeT>) {
+    using Op = cudf::ast::ast_operator;
+    using Operation = cudf::ast::operation;
+
+    auto* bigintRange = static_cast<const common::BigintRange*>(&filter);
+
+    const auto lower = bigintRange->lower();
+    const auto upper = bigintRange->upper();
+
+    const bool skipLowerBound =
+        lower <= static_cast<int64_t>(std::numeric_limits<NativeT>::min());
+    const bool skipUpperBound =
+        upper >= static_cast<int64_t>(std::numeric_limits<NativeT>::max());
+
+    auto addLiteral = [&](int64_t value) -> const cudf::ast::expression& {
+      variant veloxVariant = static_cast<NativeT>(value);
+      const auto& literal =
+          makeScalarAndLiteral<Kind>(columnTypePtr, veloxVariant, scalars);
+      return tree.push(literal);
+    };
+
+    if (bigintRange->isSingleValue()) {
+      // Equal comparison: column = value. This value is the same as the
+      // lower/upper bound.
+      if (skipLowerBound || skipUpperBound) {
+        // If the singular value of this filter lies outside the range of the
+        // column's NativeT type then we want to be always false
+        return tree.push(Operation{Op::NOT_EQUAL, columnRef, columnRef});
+      } else {
+        auto const& literal = addLiteral(lower);
+        return tree.push(Operation{Op::EQUAL, columnRef, literal});
+      }
+    } else {
+      // Range comparison: column >= lower AND column <= upper
+
+      const cudf::ast::expression* lowerExpr = nullptr;
+      if (!skipLowerBound) {
+        auto const& lowerLiteral = addLiteral(lower);
+        lowerExpr =
+            &tree.push(Operation{Op::GREATER_EQUAL, columnRef, lowerLiteral});
+      }
+
+      const cudf::ast::expression* upperExpr = nullptr;
+      if (!skipUpperBound) {
+        auto const& upperLiteral = addLiteral(upper);
+        upperExpr =
+            &tree.push(Operation{Op::LESS_EQUAL, columnRef, upperLiteral});
+      }
+
+      if (lowerExpr && upperExpr) {
+        auto const& result =
+            tree.push(Operation{Op::NULL_LOGICAL_AND, *lowerExpr, *upperExpr});
+        return result;
+      } else if (lowerExpr) {
+        return *lowerExpr;
+      } else if (upperExpr) {
+        return *upperExpr;
+      }
+
+      // If neither lower nor upper bound expressions were created, it means
+      // the filter covers the entire range of the type, so it's a no-op
+      return tree.push(Operation{Op::EQUAL, columnRef, columnRef});
+    }
+  } else {
+    VELOX_FAIL("Unsupported type for buildBigintRangeExpr: {}", Kind);
+  }
+}
+
+template <typename T>
+auto createFloatingPointRangeExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) -> const cudf::ast::expression& {
+  return createRangeExpr<
+      facebook::velox::common::FloatingPointRange<T>,
+      cudf::numeric_scalar<T>>(filter, tree, scalars, columnRef, stream, mr);
+};
+
+const cudf::ast::expression& createBytesRangeExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  return createRangeExpr<
+      facebook::velox::common::BytesRange,
+      cudf::string_scalar>(filter, tree, scalars, columnRef, stream, mr);
+}
+
+template <typename FilterT, typename ScalarT>
+const cudf::ast::expression& buildInListExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    const cudf::ast::expression& columnRef,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    bool isNegated,
+    rmm::cuda_stream_view stream,
+    rmm::device_async_resource_ref mr) {
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+
+  auto* valuesFilter = dynamic_cast<const FilterT*>(&filter);
+  VELOX_CHECK_NOT_NULL(valuesFilter, "Filter is not a List filter");
+  auto const& values = valuesFilter->values();
+  if (values.empty()) {
+    VELOX_FAIL("Empty List filter not supported");
+  }
+
+  std::vector<const cudf::ast::expression*> exprVec;
+  for (const auto& value : values) {
+    scalars.emplace_back(std::make_unique<ScalarT>(value, true, stream, mr));
+    auto const& literal = tree.push(
+        cudf::ast::literal{*static_cast<ScalarT*>(scalars.back().get())});
+    auto const& equalExpr = tree.push(
+        Operation{isNegated ? Op::NOT_EQUAL : Op::EQUAL, columnRef, literal});
+    exprVec.push_back(&equalExpr);
+  }
+
+  const cudf::ast::expression* result = exprVec[0];
+  for (size_t i = 1; i < exprVec.size(); ++i) {
+    if (isNegated) {
+      result =
+          &tree.push(Operation{Op::NULL_LOGICAL_AND, *result, *exprVec[i]});
+    } else {
+      result = &tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprVec[i]});
+    }
+  }
+  return *result;
+}
+
+// Build an IN-list expression for integer columns where the filter values are
+// provided as int64_t but the column may be any integral type. Values outside
+// the target type's range are ignored. If all values are out of range, this
+// returns a constant false expression (col != col).
+template <TypeKind Kind>
+std::reference_wrapper<const cudf::ast::expression> buildIntegerInListExpr(
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const cudf::ast::expression& columnRef,
+    rmm::cuda_stream_view /*stream*/,
+    rmm::device_async_resource_ref /*mr*/,
+    const TypePtr& columnTypePtr) {
+  using NativeT = typename TypeTraits<Kind>::NativeType;
+
+  if constexpr (std::is_integral_v<NativeT>) {
+    using Op = cudf::ast::ast_operator;
+    using Operation = cudf::ast::operation;
+
+    auto* valuesFilter =
+        static_cast<const common::BigintValuesUsingBitmask*>(&filter);
+    const auto& values = valuesFilter->values();
+
+    std::vector<const cudf::ast::expression*> exprVec;
+    exprVec.reserve(values.size());
+
+    for (const int64_t value : values) {
+      if (value < static_cast<int64_t>(std::numeric_limits<NativeT>::min()) ||
+          value > static_cast<int64_t>(std::numeric_limits<NativeT>::max())) {
+        // Skip values that cannot be represented in the column type.
+        continue;
+      }
+
+      variant veloxVariant = static_cast<NativeT>(value);
+      const auto& literal =
+          makeScalarAndLiteral<Kind>(columnTypePtr, veloxVariant, scalars);
+      auto const& cudfLiteral = tree.push(literal);
+      auto const& equalExpr =
+          tree.push(Operation{Op::EQUAL, columnRef, cudfLiteral});
+      exprVec.push_back(&equalExpr);
+    }
+
+    if (exprVec.empty()) {
+      // No representable values -> always false
+      auto const& alwaysFalse =
+          tree.push(Operation{Op::NOT_EQUAL, columnRef, columnRef});
+      return std::ref(alwaysFalse);
+    }
+
+    const cudf::ast::expression* result = exprVec[0];
+    for (size_t i = 1; i < exprVec.size(); ++i) {
+      result = &tree.push(Operation{Op::NULL_LOGICAL_OR, *result, *exprVec[i]});
+    }
+    return std::ref(*result);
+  } else {
+    VELOX_FAIL("Unsupported type for buildIntegerInListExpr: {}", Kind);
+  }
+}
+
+} // namespace
+
+// Convert subfield filters to cudf AST
+cudf::ast::expression const& createAstFromSubfieldFilter(
+    const common::Subfield& subfield,
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema) {
+  // First, create column reference from subfield
+  // For now, only support simple field references
+  if (subfield.path().empty() ||
+      subfield.path()[0]->kind() != common::SubfieldKind::kNestedField) {
+    VELOX_FAIL(
+        "Only simple field references are supported in subfield filters");
+  }
+
+  auto nestedField = static_cast<const common::Subfield::NestedField*>(
+      subfield.path()[0].get());
+  const std::string& fieldName = nestedField->name();
+
+  if (!inputRowSchema->containsChild(fieldName)) {
+    VELOX_FAIL("Field '{}' not found in input schema", fieldName);
+  }
+
+  auto columnIndex = inputRowSchema->getChildIdx(fieldName);
+  auto const& columnRef = tree.push(cudf::ast::column_reference(columnIndex));
+
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+
+  auto stream = cudf::get_default_stream();
+  auto mr = cudf::get_current_device_resource_ref();
+
+  switch (filter.kind()) {
+    case common::FilterKind::kBigintRange: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      auto result = VELOX_DYNAMIC_TYPE_DISPATCH(
+          buildBigintRangeExpr,
+          columnType->kind(),
+          filter,
+          tree,
+          scalars,
+          columnRef,
+          stream,
+          mr,
+          columnType);
+      return result.get();
+    }
+
+    case common::FilterKind::kBigintValuesUsingBitmask: {
+      auto const& columnType = inputRowSchema->childAt(columnIndex);
+      // Dispatch by the column's integer kind and cast filter values to it.
+      auto result = VELOX_DYNAMIC_TYPE_DISPATCH(
+          buildIntegerInListExpr,
+          columnType->kind(),
+          filter,
+          tree,
+          scalars,
+          columnRef,
+          stream,
+          mr,
+          columnType);
+      return result.get();
+    }
+
+    case common::FilterKind::kBytesValues: {
+      return buildInListExpr<common::BytesValues, cudf::string_scalar>(
+          filter, tree, columnRef, scalars, false, stream, mr);
+    }
+
+    case common::FilterKind::kNegatedBytesValues: {
+      return buildInListExpr<common::NegatedBytesValues, cudf::string_scalar>(
+          filter, tree, columnRef, scalars, true, stream, mr);
+    }
+
+    case common::FilterKind::kDoubleRange: {
+      return createFloatingPointRangeExpr<double>(
+          filter, tree, scalars, columnRef, stream, mr);
+    }
+
+    case common::FilterKind::kFloatRange: {
+      return createFloatingPointRangeExpr<float>(
+          filter, tree, scalars, columnRef, stream, mr);
+    }
+
+    case common::FilterKind::kBytesRange: {
+      return createBytesRangeExpr(filter, tree, scalars, columnRef, stream, mr);
+    }
+
+    case common::FilterKind::kBoolValue: {
+      auto* boolValue = static_cast<const common::BoolValue*>(&filter);
+      auto matchesTrue = boolValue->testBool(true);
+      scalars.emplace_back(
+          std::make_unique<cudf::numeric_scalar<bool>>(
+              matchesTrue, true, stream, mr));
+      auto const& matchesBoolExpr = tree.push(
+          cudf::ast::literal{
+              *static_cast<cudf::numeric_scalar<bool>*>(scalars.back().get())});
+      return tree.push(Operation{Op::EQUAL, columnRef, matchesBoolExpr});
+    }
+
+    case common::FilterKind::kIsNull: {
+      return tree.push(Operation{Op::IS_NULL, columnRef});
+    }
+
+    case common::FilterKind::kIsNotNull: {
+      // For IsNotNull, we can use NOT(IS_NULL)
+      auto const& nullCheck = tree.push(Operation{Op::IS_NULL, columnRef});
+      return tree.push(Operation{Op::NOT, nullCheck});
+    }
+
+    default:
+      VELOX_NYI(
+          "Filter type {} not yet supported for subfield filter conversion",
+          static_cast<int>(filter.kind()));
+  }
+}
+
+// Create a combined AST from a set of subfield filters by chaining them with
+// logical ANDs. The returned expression is owned by the provided 'tree'.
+cudf::ast::expression const& createAstFromSubfieldFilters(
+    const common::SubfieldFilters& subfieldFilters,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema) {
+  using Op = cudf::ast::ast_operator;
+  using Operation = cudf::ast::operation;
+
+  std::vector<const cudf::ast::expression*> exprRefs;
+
+  // Build individual filter expressions.
+  for (const auto& [subfield, filterPtr] : subfieldFilters) {
+    if (!filterPtr) {
+      continue;
+    }
+    auto const& expr = createAstFromSubfieldFilter(
+        subfield, *filterPtr, tree, scalars, inputRowSchema);
+    exprRefs.push_back(&expr);
+  }
+
+  VELOX_CHECK_GT(exprRefs.size(), 0, "No subfield filters provided");
+
+  if (exprRefs.size() == 1) {
+    return *exprRefs[0];
+  }
+
+  // Combine expressions with NULL_LOGICAL_AND.
+  const cudf::ast::expression* result = exprRefs[0];
+  for (size_t i = 1; i < exprRefs.size(); ++i) {
+    auto const& andExpr =
+        tree.push(Operation{Op::NULL_LOGICAL_AND, *result, *exprRefs[i]});
+    result = &andExpr;
+  }
+
+  return *result;
+}
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/expression/SubfieldFiltersToAst.h b/velox/experimental/cudf/expression/SubfieldFiltersToAst.h
new file mode 100644
index 000000000000..e44e2bea15b9
--- /dev/null
+++ b/velox/experimental/cudf/expression/SubfieldFiltersToAst.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/type/Filter.h"
+#include "velox/type/Subfield.h"
+#include "velox/type/Type.h"
+
+#include <cudf/ast/expressions.hpp>
+#include <cudf/scalar/scalar.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace cudf {
+namespace ast {
+class tree;
+}
+} // namespace cudf
+
+namespace facebook::velox::cudf_velox {
+
+// Convert subfield filters to cudf AST
+cudf::ast::expression const& createAstFromSubfieldFilter(
+    const common::Subfield& subfield,
+    const common::Filter& filter,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema);
+
+// Build a single AST expression representing logical AND of all filters in
+// 'subfieldFilters'. The resulting expression reference is owned by the passed
+// 'tree'.
+cudf::ast::expression const& createAstFromSubfieldFilters(
+    const common::SubfieldFilters& subfieldFilters,
+    cudf::ast::tree& tree,
+    std::vector<std::unique_ptr<cudf::scalar>>& scalars,
+    const RowTypePtr& inputRowSchema);
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/tests/AggregationTest.cpp b/velox/experimental/cudf/tests/AggregationTest.cpp
index 2f405b672e2b..4a5af4211d86 100644
--- a/velox/experimental/cudf/tests/AggregationTest.cpp
+++ b/velox/experimental/cudf/tests/AggregationTest.cpp
@@ -292,8 +292,9 @@ TEST_F(AggregationTest, allKeyTypes) {
 
   std::vector<RowVectorPtr> batches;
   for (auto i = 0; i < 10; ++i) {
-    batches.push_back(std::static_pointer_cast<RowVector>(
-        BatchMaker::createBatch(rowType, 100, *pool_)));
+    batches.push_back(
+        std::static_pointer_cast<RowVector>(
+            BatchMaker::createBatch(rowType, 100, *pool_)));
   }
   createDuckDbTable(batches);
   auto op =
@@ -479,6 +480,33 @@ TEST_F(AggregationTest, countPartialFinalGlobal) {
   assertQuery(op, "SELECT count(*) FROM tmp");
 }
 
+/// Tests the spark scenario of having different types of aggs in the same
+/// planNode Specific example being tested is
+/// https://github.com/facebookincubator/velox/issues/12830#issuecomment-2783340233
+TEST_F(AggregationTest, CompanionAggs) {
+  std::vector<int64_t> keys0{1, 1, 1, 2, 1, 1, 2, 2};
+  std::vector<int64_t> keys1{1, 2, 1, 2, 1, 2, 1, 2};
+  std::vector<int64_t> values{1, 2, 3, 4, 5, 6, 7, 8};
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int64_t>(keys0),
+       makeFlatVector<int64_t>(keys1),
+       makeFlatVector<int64_t>(values)});
+
+  createDuckDbTable({rowVector});
+
+  auto op =
+      PlanBuilder()
+          .values({rowVector})
+          .singleAggregation({"c2", "c0"}, {"count_partial(c1)"})
+          .localPartition({"c2", "c0"})
+          .singleAggregation({"c0"}, {"count_merge(a0)", "count_partial(c2)"})
+          .localPartition({"c0"})
+          .singleAggregation({"c0"}, {"count_merge(a0)", "count_merge(a1)"})
+          .planNode();
+  assertQuery(
+      op, "SELECT c0, count(c1), count(distinct c2) FROM tmp GROUP BY c0");
+}
+
 TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   auto vectors = {
       makeRowVector({makeFlatVector<int32_t>(
@@ -498,12 +526,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   core::PlanNodeId aggNodeId;
   auto task = AssertQueryBuilder(duckDbQueryRunner_)
                   .config(QueryConfig::kMaxPartialAggregationMemory, 100)
-                  .plan(PlanBuilder()
-                            .values(vectors)
-                            .partialAggregation({"c0"}, {})
-                            .capturePlanNodeId(aggNodeId)
-                            .finalAggregation()
-                            .planNode())
+                  .plan(
+                      PlanBuilder()
+                          .values(vectors)
+                          .partialAggregation({"c0"}, {})
+                          .capturePlanNodeId(aggNodeId)
+                          .finalAggregation()
+                          .planNode())
                   .assertResults("SELECT distinct c0 FROM tmp");
 
   auto rowFlushStats = toPlanStats(task->taskStats())
@@ -515,12 +544,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Count aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
              .config(QueryConfig::kMaxPartialAggregationMemory, 1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({"c0"}, {"count(1)"})
-                       .capturePlanNodeId(aggNodeId)
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({"c0"}, {"count(1)"})
+                     .capturePlanNodeId(aggNodeId)
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT c0, count(1) FROM tmp GROUP BY 1");
 
   rowFlushStats = toPlanStats(task->taskStats())
@@ -532,12 +562,13 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
   // Global aggregation.
   task = AssertQueryBuilder(duckDbQueryRunner_)
              .config(QueryConfig::kMaxPartialAggregationMemory, 1)
-             .plan(PlanBuilder()
-                       .values(vectors)
-                       .partialAggregation({}, {"sum(c0)"})
-                       .capturePlanNodeId(aggNodeId)
-                       .finalAggregation()
-                       .planNode())
+             .plan(
+                 PlanBuilder()
+                     .values(vectors)
+                     .partialAggregation({}, {"sum(c0)"})
+                     .capturePlanNodeId(aggNodeId)
+                     .finalAggregation()
+                     .planNode())
              .assertResults("SELECT sum(c0) FROM tmp");
   EXPECT_EQ(
       0,
@@ -546,4 +577,126 @@ TEST_F(AggregationTest, partialAggregationMemoryLimit) {
           .customStats.count("flushRowCount"));
 }
 
+class EmptyInputAggregationTest : public AggregationTest {
+ protected:
+  void SetUp() override {
+    AggregationTest::SetUp();
+
+    // Common test data setup
+    data_ = makeRowVector({
+        makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+        makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+        makeFlatVector<std::string>({"a", "b", "c", "d", "e"}),
+    });
+
+    createDuckDbTable({data_});
+    filter_ = "c0 > 10"; // This filter eliminates all rows
+  }
+
+  void TearDown() override {
+    // Need to clear data before plan destruction to keep memory pools happy
+    data_.reset();
+    plan_.reset();
+    filter_.clear();
+    AggregationTest::TearDown();
+  }
+
+  RowVectorPtr data_;
+  core::PlanNodePtr plan_;
+  std::string filter_;
+};
+
+TEST_F(EmptyInputAggregationTest, groupedSingleAggregation) {
+  // Test case where CUDF aggregation operator receives no input rows for
+  // grouped aggregation
+  plan_ = PlanBuilder()
+              .values({data_})
+              .filter(filter_)
+              .singleAggregation(
+                  {"c2"}, {"sum(c0)", "count(c1)", "max(c1)", "avg(c1)"})
+              .planNode();
+
+  // should return empty result for grouped aggregation
+  assertQuery(
+      plan_,
+      "SELECT c2, sum(c0), count(c1), max(c1), avg(c1) FROM tmp WHERE c0 > 10 GROUP BY c2");
+}
+
+TEST_F(EmptyInputAggregationTest, globalSingleAggregation) {
+  // Test case where CUDF aggregation operator receives no input rows for global
+  // aggregation
+  plan_ =
+      PlanBuilder()
+          .values({data_})
+          .filter(filter_)
+          .singleAggregation({}, {"sum(c0)", "count(c1)", "max(c1)", "avg(c1)"})
+          .planNode();
+
+  // global aggregation should return one row with null/zero values
+  assertQuery(
+      plan_,
+      "SELECT sum(c0), count(c1), max(c1), avg(c1) FROM tmp WHERE c0 > 10");
+}
+
+TEST_F(EmptyInputAggregationTest, distinctSingleAggregation) {
+  // Test case where CUDF aggregation operator receives no input rows for
+  // distinct aggregation
+  plan_ = PlanBuilder()
+              .values({data_})
+              .filter(filter_)
+              .singleAggregation({"c2"}, {})
+              .planNode();
+
+  // should return empty result for distinct aggregation
+  assertQuery(plan_, "SELECT DISTINCT c2 FROM tmp WHERE c0 > 10");
+}
+
+TEST_F(EmptyInputAggregationTest, distinctPartialFinalAggregation) {
+  // Test case where CUDF aggregation operator receives no input rows for
+  // distinct partial-final aggregation
+  plan_ = PlanBuilder()
+              .values({data_})
+              .filter(filter_)
+              .partialAggregation({"c2"}, {})
+              .finalAggregation()
+              .planNode();
+
+  // should return empty result for distinct aggregation
+  assertQuery(plan_, "SELECT DISTINCT c2 FROM tmp WHERE c0 > 10");
+}
+
+TEST_F(EmptyInputAggregationTest, groupedPartialFinalAggregation) {
+  // Test case where CUDF aggregation operator receives no input rows for
+  // partial-final aggregation
+  plan_ = PlanBuilder()
+              .values({data_})
+              .filter(filter_)
+              .partialAggregation(
+                  {"c2"}, {"sum(c0)", "count(c1)", "max(c1)", "avg(c1)"})
+              .finalAggregation()
+              .planNode();
+
+  // should return empty result for partial-final aggregation
+  assertQuery(
+      plan_,
+      "SELECT c2, sum(c0), count(c1), max(c1), avg(c1) FROM tmp WHERE c0 > 10 GROUP BY c2");
+}
+
+TEST_F(EmptyInputAggregationTest, globalPartialFinalAggregation) {
+  // Test case where CUDF aggregation operator receives no input rows for global
+  // partial-final aggregation
+  plan_ = PlanBuilder()
+              .values({data_})
+              .filter(filter_)
+              .partialAggregation(
+                  {}, {"sum(c0)", "count(c1)", "max(c1)", "avg(c1)"})
+              .finalAggregation()
+              .planNode();
+
+  // global partial-final aggregation should return 1 row with null/zero values
+  assertQuery(
+      plan_,
+      "SELECT sum(c0), count(c1), max(c1), avg(c1) FROM tmp WHERE c0 > 10");
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/experimental/cudf/tests/AssignUniqueIdTest.cpp b/velox/experimental/cudf/tests/AssignUniqueIdTest.cpp
new file mode 100644
index 000000000000..6d4e84ad1da4
--- /dev/null
+++ b/velox/experimental/cudf/tests/AssignUniqueIdTest.cpp
@@ -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.
+ */
+#include "velox/experimental/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/ToCudf.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/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+
+namespace facebook::velox::exec {
+
+using namespace facebook::velox::test;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+class AssignUniqueIdTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  void verifyUniqueId(
+      const std::shared_ptr<const core::PlanNode>& plan,
+      const std::vector<RowVectorPtr>& input) {
+    CursorParameters params;
+    params.planNode = plan;
+    params.queryConfigs.insert(
+        {cudf_velox::CudfFromVelox::kGpuBatchSizeRows, "1"});
+    auto result = readCursor(params);
+    ASSERT_EQ(result.second[0]->childrenSize(), input[0]->childrenSize() + 1);
+    verifyUniqueId(input, result.second);
+
+    auto task = result.first->task();
+    // Verify number of memory allocations. As no memory is allocated for the
+    // unique ID vector generation in GPU, the number of memory allocations
+    // should be 0. cudf can generate new columns, and cannot reuse the memory.
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(0, stats.at(uniqueNodeId_).numMemoryAllocations);
+    // check if CudfAssignUniqueId operator is executed with stats
+    ASSERT_EQ(
+        1, stats.at(uniqueNodeId_).operatorStats.count("CudfAssignUniqueId"));
+  }
+
+  void verifyUniqueId(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<facebook::velox::RowVectorPtr>& vectors) {
+    auto numColumns = vectors[0]->childrenSize();
+    ASSERT_EQ(numColumns, input[0]->childrenSize() + 1);
+
+    std::set<int64_t> ids;
+    for (int i = 0; i < numColumns; i++) {
+      for (auto batch = 0; batch < vectors.size(); ++batch) {
+        auto column = vectors[batch]->childAt(i);
+        if (i < numColumns - 1) {
+          assertEqualVectors(input[batch]->childAt(i), column);
+        } else {
+          auto idValues = column->asFlatVector<int64_t>()->rawValues();
+          std::copy(
+              idValues,
+              idValues + column->size(),
+              std::inserter(ids, ids.end()));
+        }
+      }
+    }
+
+    vector_size_t totalInputSize = 0;
+    for (const auto& vector : input) {
+      totalInputSize += vector->size();
+    }
+
+    ASSERT_EQ(totalInputSize, ids.size());
+  }
+
+  core::PlanNodeId uniqueNodeId_;
+};
+
+TEST_F(AssignUniqueIdTest, multiBatch) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> input;
+  input.reserve(3);
+  for (int i = 0; i < 3; ++i) {
+    input.push_back(
+        makeRowVector({makeFlatVector<int32_t>(batchSize, folly::identity)}));
+  }
+
+  auto plan = PlanBuilder()
+                  .values(input)
+                  .assignUniqueId()
+                  .capturePlanNodeId(uniqueNodeId_)
+                  .planNode();
+
+  verifyUniqueId(plan, input);
+}
+
+TEST_F(AssignUniqueIdTest, exceedRequestLimit) {
+  vector_size_t requestLimit = 1 << 20L;
+  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)
+                  .assignUniqueId()
+                  .capturePlanNodeId(uniqueNodeId_)
+                  .planNode();
+
+  verifyUniqueId(plan, input);
+}
+
+TEST_F(AssignUniqueIdTest, multiThread) {
+  for (int i = 0; i < 3; i++) {
+    vector_size_t batchSize = 1000;
+    auto input = {
+        makeRowVector({makeFlatVector<int32_t>(batchSize, folly::identity)})};
+    auto plan = PlanBuilder()
+                    .values(input, true)
+                    .assignUniqueId()
+                    .capturePlanNodeId(uniqueNodeId_)
+                    .planNode();
+
+    std::shared_ptr<exec::Task> task;
+    auto result = AssertQueryBuilder(plan)
+                      .config(cudf_velox::CudfFromVelox::kGpuBatchSizeRows, "1")
+                      .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. As no memory is allocated for the
+    // unique ID vector generation in GPU, the number of memory allocations
+    // should be 0. cudf can generate new columns, and cannot reuse the memory.
+    auto stats = toPlanStats(task->taskStats());
+    ASSERT_EQ(0, stats.at(uniqueNodeId_).numMemoryAllocations);
+  }
+}
+
+TEST_F(AssignUniqueIdTest, maxRowIdLimit) {
+  auto input = {makeRowVector({makeFlatVector<int32_t>({1, 2, 3})})};
+
+  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);
+
+  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).planNode();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(plan).copyResults(pool()),
+      "(16777216 vs. 16777216) Unique 24-bit ID specified for AssignUniqueId exceeds the limit");
+}
+
+// TODO: Add test for barrier execution, other operators does not support
+// draining yet.
+} // namespace
+} // namespace facebook::velox::exec
diff --git a/velox/experimental/cudf/tests/CMakeLists.txt b/velox/experimental/cudf/tests/CMakeLists.txt
index 52653addd69c..3233f134f832 100644
--- a/velox/experimental/cudf/tests/CMakeLists.txt
+++ b/velox/experimental/cudf/tests/CMakeLists.txt
@@ -12,36 +12,180 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_cudf_order_by_test Main.cpp OrderByTest.cpp)
 add_executable(velox_cudf_aggregation_test Main.cpp AggregationTest.cpp)
+add_executable(velox_cudf_assign_unique_id_test Main.cpp AssignUniqueIdTest.cpp)
+add_executable(velox_cudf_config_test Main.cpp ConfigTest.cpp)
+add_executable(velox_cudf_expression_selection_test Main.cpp ExpressionEvaluatorSelectionTest.cpp)
+add_executable(velox_cudf_filter_project_test Main.cpp FilterProjectTest.cpp)
+add_executable(velox_cudf_hash_join_test HashJoinTest.cpp Main.cpp)
+add_executable(velox_cudf_limit_test Main.cpp LimitTest.cpp)
+add_executable(velox_cudf_local_partition_test Main.cpp LocalPartitionTest.cpp)
+add_executable(velox_cudf_order_by_test Main.cpp OrderByTest.cpp)
+if(VELOX_ENABLE_S3)
+  add_executable(velox_cudf_s3_read_test Main.cpp S3ReadTest.cpp)
+endif()
+add_executable(velox_cudf_subfield_filter_ast_test Main.cpp SubfieldFilterAstTest.cpp)
+add_executable(velox_cudf_table_scan_test Main.cpp TableScanTest.cpp)
+# Disabling writer tests until we re-add writing ability to CudfHiveConnector
+# add_executable(velox_cudf_table_write_test Main.cpp TableWriteTest.cpp)
+add_executable(velox_cudf_topn_test Main.cpp TopNTest.cpp)
+
+add_test(
+  NAME velox_cudf_aggregation_test
+  COMMAND velox_cudf_aggregation_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_test(
+  NAME velox_cudf_assign_unique_id_test
+  COMMAND velox_cudf_assign_unique_id_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_test(
+  NAME velox_cudf_config_test
+  COMMAND velox_cudf_config_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_test(
+  NAME velox_cudf_expression_selection_test
+  COMMAND velox_cudf_expression_selection_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_test(
+  NAME velox_cudf_filter_project_test
+  COMMAND velox_cudf_filter_project_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_test(
+  NAME velox_cudf_hash_join_test
+  COMMAND velox_cudf_hash_join_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_test(
+  NAME velox_cudf_limit_test
+  COMMAND velox_cudf_limit_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_test(
+  NAME velox_cudf_local_partition_test
+  COMMAND velox_cudf_local_partition_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 add_test(
   NAME velox_cudf_order_by_test
   COMMAND velox_cudf_order_by_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+if(VELOX_ENABLE_S3)
+  add_test(
+    NAME velox_cudf_s3_read_test
+    COMMAND velox_cudf_s3_read_test
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  )
+endif()
 
 add_test(
-  NAME velox_cudf_aggregation_test
-  COMMAND velox_cudf_aggregation_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  NAME velox_cudf_subfield_filter_ast_test
+  COMMAND velox_cudf_subfield_filter_ast_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_test(
+  NAME velox_cudf_table_scan_test
+  COMMAND velox_cudf_table_scan_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# add_test(
+#   NAME velox_cudf_table_write_test
+#   COMMAND velox_cudf_table_write_test
+#   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+# )
+
+add_test(
+  NAME velox_cudf_topn_test
+  COMMAND velox_cudf_topn_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
-set_tests_properties(velox_cudf_order_by_test PROPERTIES LABELS cuda_driver
-                                                         TIMEOUT 3000)
-set_tests_properties(velox_cudf_aggregation_test PROPERTIES LABELS cuda_driver
-                                                            TIMEOUT 3000)
+set_tests_properties(velox_cudf_hash_join_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_order_by_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_aggregation_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_assign_unique_id_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_config_test PROPERTIES LABELS cuda_driver TIMEOUT 300)
+set_tests_properties(
+  velox_cudf_expression_selection_test
+  PROPERTIES LABELS cuda_driver TIMEOUT 3000
+)
+set_tests_properties(velox_cudf_filter_project_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_hash_join_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_limit_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_local_partition_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_order_by_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+if(VELOX_ENABLE_S3)
+  set_tests_properties(velox_cudf_s3_read_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+endif()
+set_tests_properties(velox_cudf_subfield_filter_ast_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_table_scan_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+# set_tests_properties(velox_cudf_table_write_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+set_tests_properties(velox_cudf_topn_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
 
 target_link_libraries(
-  velox_cudf_order_by_test
+  velox_cudf_aggregation_test
   velox_cudf_exec
   velox_exec
   velox_exec_test_lib
   velox_test_util
+  velox_vector_fuzzer
   gtest
   gtest_main
-  fmt::fmt)
+  fmt::fmt
+)
 
 target_link_libraries(
-  velox_cudf_aggregation_test
+  velox_cudf_assign_unique_id_test
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  gtest
+  gtest_main
+)
+
+target_link_libraries(velox_cudf_config_test velox_cudf_exec gtest gtest_main)
+
+target_link_libraries(
+  velox_cudf_expression_selection_test
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  velox_functions_spark
+  gtest
+  gtest_main
+)
+
+target_link_libraries(
+  velox_cudf_filter_project_test
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_functions_test_lib
+  velox_test_util
+  gtest
+  gtest_main
+)
+
+target_link_libraries(
+  velox_cudf_hash_join_test
   velox_cudf_exec
   velox_exec
   velox_exec_test_lib
@@ -49,4 +193,104 @@ target_link_libraries(
   velox_vector_fuzzer
   gtest
   gtest_main
-  fmt::fmt)
+  Folly::folly
+  fmt::fmt
+)
+
+target_link_libraries(
+  velox_cudf_limit_test
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  gtest
+  gtest_main
+)
+
+target_link_libraries(
+  velox_cudf_local_partition_test
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  gtest
+  gtest_main
+  fmt::fmt
+)
+
+target_link_libraries(
+  velox_cudf_order_by_test
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  gtest
+  gtest_main
+  fmt::fmt
+)
+
+if(VELOX_ENABLE_S3)
+  target_link_libraries(
+    velox_cudf_s3_read_test
+    velox_cudf_exec_test_lib
+    velox_cudf_hive_connector
+    velox_s3fs
+    velox_file
+    velox_exec
+    velox_exec_test_lib
+    velox_test_util
+    gtest
+    gtest_main
+  )
+endif()
+
+target_link_libraries(
+  velox_cudf_subfield_filter_ast_test
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  gtest
+  gtest_main
+)
+
+target_link_libraries(
+  velox_cudf_table_scan_test
+  velox_cudf_exec_test_lib
+  velox_cudf_hive_connector
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  gtest
+  gtest_main
+  fmt::fmt
+)
+
+# target_link_libraries(
+#   velox_cudf_table_write_test
+#   velox_cudf_exec_test_lib
+#   velox_cudf_hive_connector
+#   velox_exec
+#   velox_exec_test_lib
+#   velox_test_util
+#   gtest
+#   gtest_main
+#   fmt::fmt
+# )
+
+target_link_libraries(
+  velox_cudf_topn_test
+  velox_cudf_exec
+  velox_exec
+  velox_exec_test_lib
+  velox_test_util
+  gtest
+  gtest_main
+  fmt::fmt
+)
+
+add_subdirectory(utils)
+
+if(${VELOX_ENABLE_SPARK_FUNCTIONS})
+  add_subdirectory(sparksql)
+endif()
diff --git a/velox/experimental/cudf/tests/ConfigTest.cpp b/velox/experimental/cudf/tests/ConfigTest.cpp
new file mode 100644
index 000000000000..f8344ffd7094
--- /dev/null
+++ b/velox/experimental/cudf/tests/ConfigTest.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/experimental/cudf/CudfConfig.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::cudf_velox::test {
+
+TEST(ConfigTest, CudfConfig) {
+  std::unordered_map<std::string, std::string> options = {
+      {CudfConfig::kCudfEnabled, "false"},
+      {CudfConfig::kCudfDebugEnabled, "true"},
+      {CudfConfig::kCudfMemoryResource, "arena"},
+      {CudfConfig::kCudfMemoryPercent, "25"},
+      {CudfConfig::kCudfFunctionNamePrefix, "presto"},
+      {CudfConfig::kCudfAllowCpuFallback, "false"}};
+
+  CudfConfig config;
+  config.initialize(std::move(options));
+  ASSERT_EQ(config.enabled, false);
+  ASSERT_EQ(config.debugEnabled, true);
+  ASSERT_EQ(config.memoryResource, "arena");
+  ASSERT_EQ(config.memoryPercent, 25);
+  ASSERT_EQ(config.functionNamePrefix, "presto");
+  ASSERT_EQ(config.allowCpuFallback, false);
+}
+} // namespace facebook::velox::cudf_velox::test
diff --git a/velox/experimental/cudf/tests/CudfFunctionBaseTest.h b/velox/experimental/cudf/tests/CudfFunctionBaseTest.h
new file mode 100644
index 000000000000..ea36247779ad
--- /dev/null
+++ b/velox/experimental/cudf/tests/CudfFunctionBaseTest.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/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox::cudf_velox {
+
+class CudfFunctionBaseTest : public velox::functions::test::FunctionBaseTest {
+ protected:
+  VectorPtr evaluate(
+      exec::ExprSet& exprSet,
+      const RowVectorPtr& input,
+      const std::optional<SelectivityVector>& rows = std::nullopt) override {
+    exec::EvalCtx context(&execCtx_, &exprSet, input.get());
+
+    VELOX_CHECK(!rows.has_value());
+    auto stream = cudf::get_default_stream();
+    auto cudfTable =
+        velox::cudf_velox::with_arrow::toCudfTable(input, pool_.get(), stream);
+    auto filterEvaluator =
+        createCudfExpression({exprSet.exprs()[0]}, input->rowType());
+    auto inputColumns = cudfTable->release();
+    auto filterColumn = filterEvaluator->eval(
+        inputColumns, stream, cudf::get_current_device_resource_ref());
+    auto filterColumnView = asView(filterColumn);
+    cudf::table_view resultTable({filterColumnView});
+    auto result = velox::cudf_velox::with_arrow::toVeloxColumn(
+        resultTable, pool_.get(), "", stream);
+    return result->childAt(0);
+  }
+};
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/tests/ExpressionEvaluatorSelectionTest.cpp b/velox/experimental/cudf/tests/ExpressionEvaluatorSelectionTest.cpp
new file mode 100644
index 000000000000..fe2b3f51269c
--- /dev/null
+++ b/velox/experimental/cudf/tests/ExpressionEvaluatorSelectionTest.cpp
@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/expression/AstExpression.h"
+#include "velox/experimental/cudf/expression/ExpressionEvaluator.h"
+#include "velox/experimental/cudf/tests/utils/ExpressionTestUtil.h"
+
+#include "velox/common/memory/Memory.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/expression/ConstantExpr.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/sparksql/registration/Register.h"
+#include "velox/type/Type.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::cudf_velox;
+using namespace facebook::velox::cudf_velox::test_utils;
+
+namespace {
+
+class CudfExpressionSelectionTest : public ::testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    facebook::velox::functions::sparksql::registerFunctions();
+    facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addLeafPool("", false);
+    queryCtx_ = core::QueryCtx::create();
+    execCtx_ = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get());
+    cudf_velox::registerCudf();
+    rowType_ = ROW({
+        {"a", BIGINT()},
+        {"b", BIGINT()},
+        {"c", INTEGER()},
+        {"name", VARCHAR()},
+        {"date", TIMESTAMP()},
+        {"c", INTEGER()},
+    });
+
+    parse::registerTypeResolver();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    execCtx_.reset();
+    queryCtx_.reset();
+    pool_.reset();
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::shared_ptr<core::QueryCtx> queryCtx_;
+  std::unique_ptr<core::ExecCtx> execCtx_;
+  RowTypePtr rowType_;
+};
+
+TEST_F(CudfExpressionSelectionTest, astRoot) {
+  auto prev = CudfConfig::getInstance().astExpressionEnabled;
+  CudfConfig::getInstance().astExpressionEnabled = true;
+  auto expr = compileExecExpr("a + c", rowType_, execCtx_.get());
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+  auto* ast = dynamic_cast<ASTExpression*>(cudfExpr.get());
+  ASSERT_NE(ast, nullptr);
+  CudfConfig::getInstance().astExpressionEnabled = prev;
+}
+
+TEST_F(CudfExpressionSelectionTest, functionRoot) {
+  auto expr = compileExecExpr("lower(name)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(expr, /*deep=*/false));
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+  auto* functionExpr = dynamic_cast<FunctionExpression*>(cudfExpr.get());
+  ASSERT_NE(functionExpr, nullptr);
+}
+
+TEST_F(CudfExpressionSelectionTest, astTopLevelWithFunctionPrecompute) {
+  auto prev = CudfConfig::getInstance().astExpressionEnabled;
+  CudfConfig::getInstance().astExpressionEnabled = true;
+  auto expr = compileExecExpr(
+      "(year(date) > 2020) AND (length(name) < 10)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(expr, /*deep=*/false));
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+  auto* ast = dynamic_cast<ASTExpression*>(cudfExpr.get());
+  ASSERT_NE(ast, nullptr);
+  CudfConfig::getInstance().astExpressionEnabled = prev;
+}
+
+TEST_F(CudfExpressionSelectionTest, functionTopLevelWithNestedFunction) {
+  auto expr =
+      compileExecExpr("lower(substr(name, 1, 5))", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(expr, /*deep=*/false));
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+
+  // Top level should be Function
+  auto* functionExpr = dynamic_cast<FunctionExpression*>(cudfExpr.get());
+  ASSERT_NE(functionExpr, nullptr);
+}
+
+// Disabled because this test segfaults in CI in compileExecExpr step which does
+// not use cudf code.
+TEST_F(CudfExpressionSelectionTest, DISABLED_functionTopLevelWithNestedAst) {
+  auto expr = compileExecExpr(
+      "hash_with_seed(42, add(a, b))",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  auto cudfExpr = createCudfExpression(expr, rowType_);
+  auto* functionExpr = dynamic_cast<FunctionExpression*>(cudfExpr.get());
+  ASSERT_NE(functionExpr, nullptr);
+}
+
+// Disabled because this test segfaults in CI in compileExecExpr step which does
+// not use cudf code.
+TEST_F(
+    CudfExpressionSelectionTest,
+    DISABLED_signatureEnforcesConstantArgsSplit) {
+  // OK: delimiter and limit are constants
+  auto ok = compileExecExpr(
+      "split(name, ',', 3)",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+
+  // Bad: delimiter is not a constant
+  auto bad = compileExecExpr(
+      "split(name, name, 3)",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  ASSERT_FALSE(canBeEvaluatedByCudf(bad, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureEnforcesConstantArgsLike) {
+  // OK: pattern is a constant
+  auto ok = compileExecExpr("like(name, '%abc%')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+
+  // Bad: pattern is not a constant
+  auto bad = compileExecExpr("like(name, name)", rowType_, execCtx_.get());
+  ASSERT_FALSE(canBeEvaluatedByCudf(bad, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureArityAndConstantsSubstr) {
+  // OK: 2-arg substr with constant start
+  auto ok2 = compileExecExpr("substr(name, 1)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok2, /*deep=*/true));
+
+  // OK: 3-arg substr with constant start and length
+  auto ok3 = compileExecExpr("substr(name, 1, 5)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok3, /*deep=*/true));
+
+  // Bad: start must be constant
+  auto badConst = compileExecExpr("substr(name, a)", rowType_, execCtx_.get());
+  ASSERT_FALSE(canBeEvaluatedByCudf(badConst, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureCastsInDivide) {
+  // OK: numeric args are castable to double
+  auto ok = compileExecExpr("divide(a, b)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureVarargsHashWithSeed) {
+  facebook::velox::functions::sparksql::registerFunctions();
+
+  // OK: first arg constant seed
+  auto ok = compileExecExpr(
+      "hash_with_seed(42, a, b)",
+      rowType_,
+      execCtx_.get(),
+      {.parseIntegerAsBigint = false, .functionPrefix = ""});
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok, /*deep=*/true));
+
+  // Bad: first arg must be constant seed
+  try {
+    auto bad = compileExecExpr(
+        "hash_with_seed(c, b)",
+        rowType_,
+        execCtx_.get(),
+        {.parseIntegerAsBigint = false, .functionPrefix = ""});
+    // If compilation succeeds, the compiled check must fail.
+    ASSERT_FALSE(canBeEvaluatedByCudf(bad, /*deep=*/true));
+  } catch (const VeloxUserError&) {
+    // Treat compile-time validation failure as unsupported.
+    SUCCEED();
+  }
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureTypeVariableCoalesce) {
+  // OK: same type BIGINT
+  auto ok1 = compileExecExpr("coalesce(a, b)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok1, /*deep=*/true));
+
+  // OK: VARCHAR with literal
+  auto ok2 = compileExecExpr("coalesce(name, 'x')", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok2, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, signatureTypeVariableSwitchIf) {
+  // OK: boolean + same type BIGINT
+  auto ok1 = compileExecExpr("if(true, a, b)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(ok1, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, DISABLED_castAndTryCast) {
+  // TODO (dm): This is required for passing of castAndTryCast test but breaks
+  // others. This is because ASTExpr agrees to support bad casts. remove after
+  // ASTExpr checks cast types
+  // CudfConfig::getInstance().astExpressionEnabled = false;
+
+  // OK: cast bigint -> double (supported by cuDF)
+  auto okCast = compileExecExpr("cast(a AS double)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okCast, /*deep=*/true));
+
+  // OK: try_cast bigint -> double (supported by cuDF)
+  auto okTryCast =
+      compileExecExpr("try_cast(a AS double)", rowType_, execCtx_.get());
+  ASSERT_TRUE(canBeEvaluatedByCudf(okTryCast, /*deep=*/true));
+
+  // BAD: cast boolean -> date (expected unsupported by cuDF)
+  auto badCast = compileExecExpr(
+      "cast(length(name) < 10 AS date)", rowType_, execCtx_.get());
+  ASSERT_FALSE(canBeEvaluatedByCudf(badCast, /*deep=*/true));
+}
+
+TEST_F(CudfExpressionSelectionTest, constantFoldingStringAllocatesOnCompile) {
+  // Build a constant string expression that should be folded at compile time.
+  // This triggers creation of a ConstantExpr and allocates memory for the
+  // folded string using the ExecCtx pool.
+  auto typed =
+      parseAndInferTypedExpr("lower('ABCDEF')", rowType_, execCtx_.get());
+
+  std::vector<core::TypedExprPtr> exprs;
+  exprs.push_back(typed);
+
+  auto exprSet = exec::makeExprSetFromFlag(
+      std::move(exprs), execCtx_.get(), /*lazyDereference=*/false);
+
+  auto compiled = exprSet->expr(0);
+  auto* c = dynamic_cast<facebook::velox::exec::ConstantExpr*>(compiled.get());
+  ASSERT_NE(c, nullptr);
+  // Verify the constant vector was created using the provided ExecCtx pool.
+  ASSERT_EQ(c->value()->pool(), execCtx_->pool());
+}
+
+} // namespace
diff --git a/velox/experimental/cudf/tests/FilterProjectTest.cpp b/velox/experimental/cudf/tests/FilterProjectTest.cpp
new file mode 100644
index 000000000000..3b43fc844278
--- /dev/null
+++ b/velox/experimental/cudf/tests/FilterProjectTest.cpp
@@ -0,0 +1,1203 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/CudfFunctionBaseTest.h"
+
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/TypeResolver.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
+
+namespace {
+
+template <typename T>
+T getColValue(const std::vector<RowVectorPtr>& input, int col, int32_t index) {
+  return input[0]->as<RowVector>()->childAt(col)->as<FlatVector<T>>()->valueAt(
+      index);
+}
+
+class CudfFilterProjectTest : public OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    filesystems::registerLocalFileSystem();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
+    cudf_velox::registerCudf();
+    rng_.seed(123);
+
+    rowType_ = ROW({{"c0", INTEGER()}, {"c1", DOUBLE()}, {"c2", VARCHAR()}});
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    OperatorTestBase::TearDown();
+  }
+
+  void testMultiplyOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a multiply operation
+    auto plan =
+        PlanBuilder().values(input).project({"1.0 * c1 AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT 1.0 * c1 AS result FROM tmp");
+  }
+
+  void testDivideOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a divide operation
+    auto plan =
+        PlanBuilder().values(input).project({"c0 / c1 AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 / c1 AS result FROM tmp");
+  }
+
+  void testMultiplyAndMinusOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a multiply and minus operation
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"c0 * (1.0 - c1) AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 * (1.0 - c1) AS result FROM tmp");
+  }
+
+  void testStringEqualOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a string equal operation
+    auto c2Value = input[0]
+                       ->as<RowVector>()
+                       ->childAt(2)
+                       ->as<FlatVector<StringView>>()
+                       ->valueAt(1)
+                       .str();
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"c2 = '" + c2Value + "' AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c2 = '" + c2Value + "' AS result FROM tmp");
+  }
+
+  void testStringNotEqualOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a string not equal operation
+    auto c2Value = input[0]
+                       ->as<RowVector>()
+                       ->childAt(2)
+                       ->as<FlatVector<StringView>>()
+                       ->valueAt(1)
+                       .str();
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"c2 <> '" + c2Value + "' AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c2 <> '" + c2Value + "' AS result FROM tmp");
+  }
+
+  void testAndOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with AND operation
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"c0 = 1 AND c1 = 2.0 AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 = 1 AND c1 = 2.0 AS result FROM tmp");
+  }
+
+  void testOrOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with OR operation
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"c0 = 1 OR c1 = 2.0 AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 = 1 OR c1 = 2.0 AS result FROM tmp");
+  }
+
+  void testYearFunction(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with YEAR function
+    auto plan =
+        PlanBuilder().values(input).project({"YEAR(c2) AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT YEAR(c2) AS result FROM tmp");
+  }
+
+  void testLengthFunction(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with LENGTH function
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"LENGTH(c2) AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT LENGTH(c2) AS result FROM tmp");
+  }
+
+  void testCaseWhenOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a CASE WHEN operation
+    auto plan =
+        PlanBuilder()
+            .values(input)
+            .project({"CASE WHEN c0 = 0 THEN 1.0 ELSE 0.0 END AS result"})
+            .planNode();
+
+    // Run the test
+    runTest(
+        plan,
+        "SELECT CASE WHEN c0 = 0 THEN 1.0 ELSE 0.0 END AS result FROM tmp");
+  }
+
+  void testSubstrOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a substr operation
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"substr(c2, 1, 3) AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT substr(c2, 1, 3) AS result FROM tmp");
+  }
+
+  void testLikeOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a like operation
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"c2 LIKE '%test%' AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c2 LIKE '%test%' AS result FROM tmp");
+  }
+
+  void testLessThanOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a less than operation
+    auto plan =
+        PlanBuilder().values(input).project({"c0 < c1 AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 < c1 AS result FROM tmp");
+
+    // compare against literals
+    plan = PlanBuilder().values(input).project({"c0 < 1 AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 < 1 AS result FROM tmp");
+  }
+
+  void testGreaterThanOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a greater than operation
+    auto plan =
+        PlanBuilder().values(input).project({"c0 > c1 AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 > c1 AS result FROM tmp");
+
+    // compare against literals
+    plan = PlanBuilder().values(input).project({"c0 > 1 AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 > 1 AS result FROM tmp");
+  }
+
+  void testLessThanEqualOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a less than equal operation
+    auto plan =
+        PlanBuilder().values(input).project({"c0 <= c1 AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 <= c1 AS result FROM tmp");
+  }
+
+  void testGreaterThanEqualOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a greater than equal operation
+    auto plan =
+        PlanBuilder().values(input).project({"c0 >= c1 AS result"}).planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 >= c1 AS result FROM tmp");
+  }
+
+  void testNotOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a NOT operation
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"NOT (c0 = 1) AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT NOT (c0 = 1) AS result FROM tmp");
+  }
+
+  void testBetweenOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with a BETWEEN operation
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"c0 BETWEEN 1 AND 100 AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 BETWEEN 1 AND 100 AS result FROM tmp");
+  }
+
+  void testMultiInputAndOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with multiple AND operations
+    auto c2Value = getColValue<StringView>(input, 2, 1).str();
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project(
+                        {"c0 > 1000 AND c0 < 20000 AND c2 = '" + c2Value +
+                         "' AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(
+        plan,
+        "SELECT c0 > 1000 AND c0 < 20000 AND c2 = '" + c2Value +
+            "' AS result FROM tmp");
+  }
+
+  void testMultiInputOrOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with multiple OR operations
+    auto c2Value = getColValue<StringView>(input, 2, 1).str();
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project(
+                        {"c0 > 16000 OR c0 < 8000 OR c1 = 2.0 OR c2 = '" +
+                         c2Value + "' AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(
+        plan,
+        "SELECT c0 > 16000 OR c0 < 8000 OR c1 = 2.0 OR c2 = '" + c2Value +
+            "' AS result FROM tmp");
+  }
+
+  void testIntegerInOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with an IN operation for integers
+    std::vector<int32_t> c0Values;
+    for (int32_t i = 0; i < 5; i++) {
+      c0Values.push_back(getColValue<int32_t>(input, 0, i));
+    }
+    std::string c0ValuesStr;
+    for (size_t i = 0; i < c0Values.size(); ++i) {
+      c0ValuesStr += std::to_string(c0Values[i]) + ",";
+    }
+    c0ValuesStr.pop_back();
+    auto plan = PlanBuilder(pool_.get())
+                    .values(input)
+                    .project({"c0 IN (" + c0ValuesStr + ") AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c0 IN (" + c0ValuesStr + ") AS result FROM tmp");
+  }
+
+  void testDoubleInOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with an IN operation for doubles
+    std::vector<double> c1Values;
+    for (int32_t i = 0; i < 4; i++) {
+      c1Values.push_back(getColValue<double>(input, 1, i));
+    }
+    std::string c1ValuesStr;
+    for (size_t i = 0; i < c1Values.size(); ++i) {
+      c1ValuesStr += std::to_string(c1Values[i]) + ",";
+    }
+    c1ValuesStr.pop_back();
+    auto plan = PlanBuilder(pool_.get())
+                    .values(input)
+                    .project({"c1 IN (" + c1ValuesStr + ") AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c1 IN (" + c1ValuesStr + ") AS result FROM tmp");
+  }
+
+  void testStringInOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan with an IN operation for strings
+    std::vector<StringView> c2Values;
+    for (int32_t i = 0; i < 3; i++) {
+      c2Values.push_back(getColValue<StringView>(input, 2, i));
+    }
+    std::string c2ValuesStr;
+    for (size_t i = 0; i < c2Values.size(); ++i) {
+      c2ValuesStr += "'" + c2Values[i].str() + "',";
+    }
+    c2ValuesStr.pop_back();
+    auto plan = PlanBuilder(pool_.get())
+                    .values(input)
+                    .project({"c2 IN (" + c2ValuesStr + ") AS result"})
+                    .planNode();
+
+    // Run the test
+    runTest(plan, "SELECT c2 IN (" + c2ValuesStr + ") AS result FROM tmp");
+  }
+
+  void testMixedInOperation(const std::vector<RowVectorPtr>& input) {
+    // Create a plan that combines multiple IN operations
+    auto plan =
+        PlanBuilder(pool_.get())
+            .values(input)
+            .project(
+                {"c0 IN (1, 2, 3) OR c1 IN (1.5, 2.5) OR c2 IN ('test1', 'test2') AS result"})
+            .planNode();
+
+    // Run the test
+    runTest(
+        plan,
+        "SELECT c0 IN (1, 2, 3) OR c1 IN (1.5, 2.5) OR c2 IN ('test1', 'test2') AS result FROM tmp");
+  }
+
+  void testStringLiteralExpansion(const std::vector<RowVectorPtr>& input) {
+    // Test VARCHAR literal as standalone expression (needs special handling)
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"'literal_value' AS result"})
+                    .planNode();
+
+    runTest(plan, "SELECT 'literal_value' AS result FROM tmp");
+  }
+
+  void testStringLiteralInComparison(const std::vector<RowVectorPtr>& input) {
+    // Test VARCHAR literal within comparison (should work normally)
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"c2 = 'test_value' AS result"})
+                    .planNode();
+
+    runTest(plan, "SELECT c2 = 'test_value' AS result FROM tmp");
+  }
+
+  void testStringLowerOperation(const std::vector<RowVectorPtr>& input) {
+    // Test VARCHAR lower
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"LOWER(c2) = 'test_value' AS result"})
+                    .planNode();
+
+    runTest(plan, "SELECT LOWER(c2) = 'test_value' AS result FROM tmp");
+  }
+
+  void testStringUpperOperation(const std::vector<RowVectorPtr>& input) {
+    // Test VARCHAR upper
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project({"UPPER(c2) = 'TEST_VALUE' AS result"})
+                    .planNode();
+
+    runTest(plan, "SELECT UPPER(c2) = 'TEST_VALUE' AS result FROM tmp");
+  }
+
+  void testMixedLiteralProjection(const std::vector<RowVectorPtr>& input) {
+    // Test mixing standalone literals with expressions containing literals
+    auto plan = PlanBuilder()
+                    .values(input)
+                    .project(
+                        {"'standalone_string' AS str_literal",
+                         "42 AS int_literal",
+                         "c2 = 'comparison_string' AS bool_result"})
+                    .planNode();
+
+    runTest(
+        plan,
+        "SELECT 'standalone_string' AS str_literal, 42 AS int_literal, c2 = 'comparison_string' AS bool_result FROM tmp");
+  }
+
+  void runTest(core::PlanNodePtr planNode, const std::string& duckDbSql) {
+    SCOPED_TRACE("run without spilling");
+    assertQuery(planNode, duckDbSql);
+  }
+
+  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>(
+          facebook::velox::test::BatchMaker::createBatch(
+              rowType, rowsPerVector, *pool_));
+      vectors.push_back(vector);
+    }
+    return vectors;
+  }
+
+  folly::Random::DefaultGenerator rng_;
+  RowTypePtr rowType_;
+};
+
+TEST_F(CudfFilterProjectTest, multiplyOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testMultiplyOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, divideOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testDivideOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, multiplyAndMinusOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testMultiplyAndMinusOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, stringEqualOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringEqualOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, stringNotEqualOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringNotEqualOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, andOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testAndOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, orOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testOrOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, lengthFunction) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testLengthFunction(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, yearFunction) {
+  // Update row type to use TIMESTAMP directly
+  auto rowType =
+      ROW({{"c0", INTEGER()}, {"c1", DOUBLE()}, {"c2", TIMESTAMP()}});
+
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType, 2, batchSize);
+
+  // Set timestamp values directly
+  for (auto& vector : vectors) {
+    auto timestampVector = vector->childAt(2)->asFlatVector<Timestamp>();
+    for (vector_size_t i = 0; i < batchSize; ++i) {
+      // Set to 2024-03-14 12:34:56
+      Timestamp ts(1710415496, 0); // seconds, nanos
+      timestampVector->set(i, ts);
+    }
+  }
+
+  createDuckDbTable(vectors);
+  testYearFunction(vectors);
+}
+
+// The result mismatches.
+TEST_F(CudfFilterProjectTest, caseWhenOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testCaseWhenOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, substrOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testSubstrOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, likeOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testLikeOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, lessThanOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testLessThanOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, greaterThanOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testGreaterThanOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, lessThanEqualOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testLessThanEqualOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, greaterThanEqualOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testGreaterThanEqualOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, notOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testNotOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, betweenOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testBetweenOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, multiInputAndOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testMultiInputAndOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, multiInputOrOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testMultiInputOrOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, integerInOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testIntegerInOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, doubleInOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testDoubleInOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, stringInOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringInOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, mixedInOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testMixedInOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, round) {
+  auto data = makeRowVector({makeFlatVector<int64_t>({4123, 456789098})});
+  parse::ParseOptions options;
+  options.parseIntegerAsBigint = false;
+  auto plan = PlanBuilder()
+                  .setParseOptions(options)
+                  .values({data})
+                  .project({"round(c0, 2) as c1"})
+                  .planNode();
+  AssertQueryBuilder(plan).assertResults(data);
+  plan = PlanBuilder()
+             .setParseOptions(options)
+             .values({data})
+             .project({"round(c0) as c1"})
+             .planNode();
+  AssertQueryBuilder(plan).assertResults(data);
+
+  plan = PlanBuilder()
+             .setParseOptions(options)
+             .values({data})
+             .project({"round(c0, -3) as c1"})
+             .planNode();
+  auto expected = makeRowVector({makeFlatVector<int64_t>({4000, 456789000})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+// TODO (dm): Enable after adding decimal support to velox-cudf
+TEST_F(CudfFilterProjectTest, DISABLED_roundDecimal) {
+  parse::ParseOptions options;
+  options.parseIntegerAsBigint = false;
+
+  auto decimalData = makeRowVector(
+      {makeFlatVector<int64_t>({412389, -456789}, DECIMAL(10, 4))});
+
+  auto plan = PlanBuilder()
+                  .setParseOptions(options)
+                  .values({decimalData})
+                  .project({"round(c0, 2) as c1"})
+                  .planNode();
+  auto decimalExpected = makeRowVector(
+      {makeFlatVector<int64_t>({412400, -456800}, DECIMAL(10, 4))});
+  AssertQueryBuilder(plan).assertResults(decimalExpected);
+
+  plan = PlanBuilder()
+             .setParseOptions(options)
+             .values({decimalData})
+             .project({"round(c0) as c1"})
+             .planNode();
+  decimalExpected = makeRowVector(
+      {makeFlatVector<int64_t>({410000, -460000}, DECIMAL(10, 4))});
+  AssertQueryBuilder(plan).assertResults(decimalExpected);
+
+  plan = PlanBuilder()
+             .setParseOptions(options)
+             .values({decimalData})
+             .project({"round(c0, -1) as c1"})
+             .planNode();
+  decimalExpected = makeRowVector(
+      {makeFlatVector<int64_t>({400000, -500000}, DECIMAL(10, 4))});
+  AssertQueryBuilder(plan).assertResults(decimalExpected);
+}
+
+TEST_F(CudfFilterProjectTest, simpleFilter) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with a simple filter
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .filter("c0 > 500")
+                  .project({"c0", "c1", "c2"})
+                  .planNode();
+
+  // Run the test
+  assertQuery(plan, "SELECT c0, c1, c2 FROM tmp WHERE c0 > 500");
+}
+
+TEST_F(CudfFilterProjectTest, filterWithProject) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with filter and project
+  auto plan =
+      PlanBuilder()
+          .values(vectors)
+          .filter("c0 > 500")
+          .project({"c0 + 2 as doubled", "c1 + 1.0 as incremented", "c2"})
+          .planNode();
+
+  // Run the test
+  assertQuery(
+      plan,
+      "SELECT c0 + 2 as doubled, c1 + 1.0 as incremented, c2 FROM tmp WHERE c0 > 500");
+}
+
+TEST_F(CudfFilterProjectTest, complexFilter) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with a complex filter condition
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .filter("c0 > 500 AND c1 < 0.5 AND c2 LIKE '%test%'")
+                  .project({"c0", "c1", "c2"})
+                  .planNode();
+
+  // Run the test
+  assertQuery(
+      plan,
+      "SELECT c0, c1, c2 FROM tmp WHERE c0 > 500 AND c1 < 0.5 AND c2 LIKE '%test%'");
+}
+
+TEST_F(CudfFilterProjectTest, filterWithNullValues) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+
+  // Add some null values to the vectors
+  for (auto& vector : vectors) {
+    auto c0Vector = vector->childAt(0)->asFlatVector<int32_t>();
+    auto c1Vector = vector->childAt(1)->asFlatVector<double>();
+    for (vector_size_t i = 0; i < batchSize; i += 10) {
+      c0Vector->setNull(i, true);
+      c1Vector->setNull(i, true);
+    }
+  }
+
+  createDuckDbTable(vectors);
+
+  // Create a plan with filter that handles null values
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .filter("c0 IS NOT NULL AND c1 IS NOT NULL")
+                  .project({"c0", "c1", "c2"})
+                  .planNode();
+
+  // Run the test
+  assertQuery(
+      plan,
+      "SELECT c0, c1, c2 FROM tmp WHERE c0 IS NOT NULL AND c1 IS NOT NULL");
+}
+
+TEST_F(CudfFilterProjectTest, filterWithOrCondition) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with OR condition in filter
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .filter("c0 > 500 OR c1 < 0.5")
+                  .project({"c0", "c1", "c2"})
+                  .planNode();
+
+  // Run the test
+  assertQuery(plan, "SELECT c0, c1, c2 FROM tmp WHERE c0 > 500 OR c1 < 0.5");
+}
+
+TEST_F(CudfFilterProjectTest, filterWithInCondition) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with IN condition in filter
+  auto plan = PlanBuilder(pool_.get())
+                  .values(vectors)
+                  .filter("c0 IN (100, 200, 300, 400, 500)")
+                  .project({"c0", "c1", "c2"})
+                  .planNode();
+
+  // Run the test
+  assertQuery(
+      plan, "SELECT c0, c1, c2 FROM tmp WHERE c0 IN (100, 200, 300, 400, 500)");
+}
+
+TEST_F(CudfFilterProjectTest, filterWithBetweenCondition) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with BETWEEN condition in filter
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .filter("c0 BETWEEN 100 AND 500")
+                  .project({"c0", "c1", "c2"})
+                  .planNode();
+
+  // Run the test
+  assertQuery(plan, "SELECT c0, c1, c2 FROM tmp WHERE c0 BETWEEN 100 AND 500");
+}
+
+TEST_F(CudfFilterProjectTest, filterWithStringOperations) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with string operations in filter
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .filter("LENGTH(c2) > 5")
+                  .project({"c0", "c1", "c2"})
+                  .planNode();
+
+  // Run the test
+  assertQuery(plan, "SELECT c0, c1, c2 FROM tmp WHERE LENGTH(c2) > 5");
+}
+
+TEST_F(CudfFilterProjectTest, filterWithoutProject) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with only filter (no projection)
+  auto plan =
+      PlanBuilder().values(vectors).filter("c0 > 500 AND c1 < 0.5").planNode();
+
+  // Run the test - should return all columns without modification
+  assertQuery(plan, "SELECT c0, c1, c2 FROM tmp WHERE c0 > 500 AND c1 < 0.5");
+}
+
+TEST_F(CudfFilterProjectTest, filterWithEmptyResult) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  // Create a plan with a filter that should return no rows
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .filter("c0 < 0 AND c0 > 1000") // Impossible condition
+                  .planNode();
+
+  // Run the test - should return empty result
+  assertQuery(plan, "SELECT c0, c1, c2 FROM tmp WHERE c0 < 0 AND c0 > 1000");
+}
+
+TEST_F(CudfFilterProjectTest, stringLiteralExpansion) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringLiteralExpansion(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, stringLiteralInComparison) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringLiteralInComparison(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, stringLowerOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringLowerOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, stringUpperOperation) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testStringUpperOperation(vectors);
+}
+
+TEST_F(CudfFilterProjectTest, mixedLiteralProjection) {
+  vector_size_t batchSize = 1000;
+  auto vectors = makeVectors(rowType_, 2, batchSize);
+  createDuckDbTable(vectors);
+
+  testMixedLiteralProjection(vectors);
+}
+
+// This test checks for CudfExpression's ability to handle nested field
+// references. However, to test this, we need to disable CPU fallback, otherwise
+// the test could pass by using CPU, having not exercised the CudfExpression at
+// all. But this test relies on row_constructor to construct the nested fields,
+// which CudfExpression doesn't support. Disabling this until we have a better
+// test
+TEST_F(CudfFilterProjectTest, DISABLED_dereference) {
+  auto rowType = ROW(
+      {"c0", "c1", "c2", "c3"}, {BIGINT(), INTEGER(), SMALLINT(), DOUBLE()});
+  auto vectors = makeVectors(rowType, 10, 100);
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .project({"row_constructor(c1, c2) AS c1_c2"})
+                  .project({"c1_c2.c1", "c1_c2.c2"})
+                  .planNode();
+  assertQuery(plan, "SELECT c1, c2 FROM tmp");
+
+  plan = PlanBuilder()
+             .values(vectors)
+             .project({"row_constructor(c1, c2) AS c1_c2"})
+             .filter("c1_c2.c1 % 10 = 5")
+             .project({"c1_c2.c1", "c1_c2.c2"})
+             .planNode();
+  assertQuery(plan, "SELECT c1, c2 FROM tmp WHERE c1 % 10 = 5");
+}
+
+TEST_F(CudfFilterProjectTest, cardinality) {
+  auto input = makeArrayVector<int64_t>({{1, 2, 3}, {1, 2}, {}});
+  auto data = makeRowVector({input});
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .project({"cardinality(c0) AS result"})
+                  .planNode();
+  auto expected = makeRowVector({makeFlatVector<int64_t>({3, 2, 0})});
+  AssertQueryBuilder(plan).assertResults({expected});
+}
+
+TEST_F(CudfFilterProjectTest, split) {
+  auto input = makeFlatVector<std::string>(
+      {"hello world", "hello world2", "hello hello"});
+  auto data = makeRowVector({input});
+  createDuckDbTable({data});
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .project({"split(c0, 'hello', 2) AS result"})
+                  .planNode();
+  auto splitResults = AssertQueryBuilder(plan).copyResults(pool());
+
+  auto calculatedSplitResults = makeRowVector({
+      makeArrayVector<std::string>({
+          {"", " world"},
+          {"", " world2"},
+          {"", " hello"},
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(
+      splitResults, calculatedSplitResults);
+}
+
+TEST_F(CudfFilterProjectTest, cardinalityAndSplitOneByOne) {
+  auto input = makeFlatVector<std::string>(
+      {"hello world", "hello world2", "hello hello", "does not contain it"});
+  auto data = makeRowVector({input});
+  auto splitPlan = PlanBuilder()
+                       .values({data})
+                       .project({"split(c0, 'hello', 2) AS c0"})
+                       .planNode();
+  auto splitResults = AssertQueryBuilder(splitPlan).copyResults(pool());
+
+  auto calculatedSplitResults = makeRowVector({
+      makeArrayVector<std::string>({
+          {"", " world"},
+          {"", " world2"},
+          {"", " hello"},
+          {"does not contain it"},
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(
+      splitResults, calculatedSplitResults);
+  auto cardinalityPlan = PlanBuilder()
+                             .values({splitResults})
+                             .project({"cardinality(c0) AS result"})
+                             .planNode();
+  auto expected = makeRowVector({makeFlatVector<int64_t>({2, 2, 2, 1})});
+  AssertQueryBuilder(cardinalityPlan).assertResults({expected});
+}
+
+// TODO: Requires a fix for the expression evaluator to handle function nesting.
+TEST_F(CudfFilterProjectTest, cardinalityAndSplitFused) {
+  auto input = makeFlatVector<std::string>(
+      {"hello world", "hello world2", "hello hello", "does not contain it"});
+  auto data = makeRowVector({input});
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .project({"cardinality(split(c0, 'hello', 2)) AS c0"})
+                  .planNode();
+  auto expected = makeRowVector({makeFlatVector<int64_t>({2, 2, 2, 1})});
+  AssertQueryBuilder(plan).assertResults({expected});
+}
+
+TEST_F(CudfFilterProjectTest, negativeSubstr) {
+  auto input =
+      makeFlatVector<std::string>({"hellobutlonghello", "secondstring"});
+  auto data = makeRowVector({input});
+  auto negativeSubstrPlan =
+      PlanBuilder().values({data}).project({"substr(c0, -2) AS c0"}).planNode();
+  auto negativeSubstrResults =
+      AssertQueryBuilder(negativeSubstrPlan).copyResults(pool());
+
+  auto calculatedNegativeSubstrResults = makeRowVector({
+      makeFlatVector<std::string>({
+          "lo",
+          "ng",
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(
+      negativeSubstrResults, calculatedNegativeSubstrResults);
+}
+
+TEST_F(CudfFilterProjectTest, negativeSubstrWithLength) {
+  auto input =
+      makeFlatVector<std::string>({"hellobutlonghello", "secondstring"});
+  auto data = makeRowVector({input});
+  auto negativeSubstrWithLengthPlan = PlanBuilder()
+                                          .values({data})
+                                          .project({"substr(c0, -6, 3) AS c0"})
+                                          .planNode();
+  auto negativeSubstrWithLengthResults =
+      AssertQueryBuilder(negativeSubstrWithLengthPlan).copyResults(pool());
+
+  auto calculatedNegativeSubstrWithLengthResults = makeRowVector({
+      makeFlatVector<std::string>({
+          "ghe",
+          "str",
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(
+      negativeSubstrWithLengthResults,
+      calculatedNegativeSubstrWithLengthResults);
+}
+
+TEST_F(CudfFilterProjectTest, substrWithLength) {
+  auto input =
+      makeFlatVector<std::string>({"hellobutlonghello", "secondstring"});
+  auto data = makeRowVector({input});
+  auto substrPlan = PlanBuilder()
+                        .values({data})
+                        .project({"substr(c0, 1, 3) AS c0"})
+                        .planNode();
+  auto substrResults = AssertQueryBuilder(substrPlan).copyResults(pool());
+
+  auto calculatedSubstrResults = makeRowVector({
+      makeFlatVector<std::string>({
+          "hel",
+          "sec",
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(
+      substrResults, calculatedSubstrResults);
+}
+
+TEST_F(CudfFilterProjectTest, coalesceColumnWithLiteral) {
+  vector_size_t batchSize = 100;
+  auto vectors = makeVectors(rowType_, 1, batchSize);
+  // Introduce nulls into c0 to exercise replacement
+  auto& vec = vectors[0];
+  auto c0Vector = vec->childAt(0)->asFlatVector<int32_t>();
+  for (vector_size_t i = 0; i < batchSize; i += 3) {
+    c0Vector->setNull(i, true);
+  }
+
+  createDuckDbTable(vectors);
+
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .project({"coalesce(c0, 5::INTEGER) AS result"})
+                  .planNode();
+
+  runTest(plan, "SELECT coalesce(c0, 5) AS result FROM tmp");
+}
+
+TEST_F(CudfFilterProjectTest, coalesceLiteralFirst) {
+  vector_size_t batchSize = 100;
+  auto vectors = makeVectors(rowType_, 1, batchSize);
+  createDuckDbTable(vectors);
+
+  // Literal appears before any column; result should be a constant column.
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .project({"coalesce(5::INTEGER, c0) AS result"})
+                  .planNode();
+
+  runTest(plan, "SELECT coalesce(5, c0) AS result FROM tmp");
+}
+
+TEST_F(CudfFilterProjectTest, coalesceStopsAtFirstLiteral) {
+  // Use two integer columns to validate that columns after the literal are
+  // ignored.
+  auto rowType = ROW({{"c0", INTEGER()}, {"c1", INTEGER()}});
+  auto vectors = makeVectors(rowType, 1, 50);
+  // Make some c0 nulls so fallback engages.
+  auto& vec = vectors[0];
+  auto c0 = vec->childAt(0)->asFlatVector<int32_t>();
+  for (vector_size_t i = 1; i < vec->size(); i += 4) {
+    c0->setNull(i, true);
+  }
+
+  createDuckDbTable(vectors);
+
+  // With expression coalesce(c0, 100, c1), rows with null c0 should become 100,
+  // regardless of c1. This also verifies we stop at the first literal.
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .project({"coalesce(c0, 100::INTEGER, c1) AS result"})
+                  .planNode();
+
+  runTest(plan, "SELECT coalesce(c0, 100, c1) AS result FROM tmp");
+}
+
+TEST_F(CudfFilterProjectTest, switchExpr) {
+  auto data = makeRowVector(
+      {makeFlatVector<double>({45676567.78, 6789098767.90876, -2.34}),
+       makeFlatVector<double>({123.4, 124.5, 1678})});
+  auto plan =
+      PlanBuilder()
+          .values({data})
+          .project(
+              {"CASE WHEN c0 > 0.0 THEN c0 / c1 ELSE cast(null as double) END AS result"})
+          .planNode();
+  auto result = AssertQueryBuilder(plan).copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeNullableFlatVector<double>(
+          {45676567.78 / 123.4, 6789098767.90876 / 124.5, std::nullopt}),
+  });
+  facebook::velox::test::assertEqualVectors(expected, result);
+}
+
+class CudfSimpleFilterProjectTest : public cudf_velox::CudfFunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    parse::registerTypeResolver();
+    functions::prestosql::registerAllScalarFunctions();
+    aggregate::prestosql::registerAllAggregateFunctions();
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    cudf_velox::registerCudf();
+  }
+
+  static void TearDownTestCase() {
+    cudf_velox::unregisterCudf();
+  }
+};
+
+TEST_F(CudfSimpleFilterProjectTest, castToSmallInt) {
+  auto castValue = evaluateOnce<int16_t, int32_t>("cast(c0 as smallint)", 12);
+  EXPECT_EQ(castValue, 12);
+  auto tryCast =
+      evaluateOnce<int16_t, int32_t>("try_cast(c0 as smallint)", -214);
+  EXPECT_EQ(tryCast, -214);
+}
+
+} // namespace
diff --git a/velox/experimental/cudf/tests/HashJoinTest.cpp b/velox/experimental/cudf/tests/HashJoinTest.cpp
new file mode 100644
index 000000000000..fef5227fd535
--- /dev/null
+++ b/velox/experimental/cudf/tests/HashJoinTest.cpp
@@ -0,0 +1,8485 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/CudfConfig.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#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/Cursor.h"
+#include "velox/exec/HashBuild.h"
+#include "velox/exec/HashJoinBridge.h"
+#include "velox/exec/OperatorUtils.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/HashJoinTestBase.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/exec/tests/utils/VectorTestUtil.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+#include <fmt/format.h>
+#include <re2/re2.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::testutil;
+
+using facebook::velox::test::BatchMaker;
+
+namespace {
+
+class HashJoinTest : public HashJoinTestBase {
+ public:
+  HashJoinTest() : HashJoinTestBase(TestParam(1)) {}
+
+  explicit HashJoinTest(const TestParam& param) : HashJoinTestBase(param) {}
+
+  void SetUp() override {
+    HashJoinTestBase::SetUp();
+    cudf_velox::CudfConfig::getInstance().allowCpuFallback = false;
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    HashJoinTestBase::TearDown();
+  }
+};
+
+class MultiThreadedHashJoinTest
+    : public HashJoinTest,
+      public testing::WithParamInterface<TestParam> {
+ public:
+  MultiThreadedHashJoinTest() : HashJoinTest(GetParam()) {}
+
+  static std::vector<TestParam> getTestParams() {
+    return std::vector<TestParam>({TestParam{1}, TestParam{3}});
+  }
+};
+
+TEST_P(MultiThreadedHashJoinTest, bigintArray) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .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")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, outOfJoinKeyColumnOrder) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeType(probeType_)
+      .probeKeys({"t_k2"})
+      .probeVectors(5, 10)
+      .buildType(buildType_)
+      .buildKeys({"u_k2"})
+      .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")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, joinWithCancellation) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .keyTypes({BIGINT()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .injectTaskCancellation(true)
+      .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*/) {
+        auto stats = task->taskStats();
+        EXPECT_GT(stats.terminationTimeMs, 0);
+      })
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, testJoinWithSpillenabledCancellation) {
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .keyTypes({BIGINT()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .injectTaskCancellation(true)
+      .injectSpill(false)
+      // Need spill directory so that canSpill() is true for HashProbe
+      .spillDirectory(spillDirectory->getPath())
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t.t_k0 = u.u_k0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, emptyBuild) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
+    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .keyTypes({BIGINT()})
+        .probeVectors(1600, 5)
+        .buildVectors(0, 5)
+        .referenceQuery(
+            "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t_k0 = u_k0")
+        .checkSpillStats(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          ASSERT_EQ(statsPair.first.spilledRows, 0);
+          ASSERT_EQ(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.first.spilledFiles, 0);
+          ASSERT_EQ(statsPair.second.spilledRows, 0);
+          ASSERT_EQ(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.second.spilledFiles, 0);
+          verifyTaskSpilledRuntimeStats(*task, false);
+          // Check the hash probe has processed probe input rows.
+          if (finishOnEmpty) {
+            ASSERT_EQ(getInputPositions(task, 1), 0);
+          } else {
+            ASSERT_GT(getInputPositions(task, 1), 0);
+          }
+        })
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, emptyProbe) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .keyTypes({BIGINT()})
+      .probeVectors(0, 5)
+      .buildVectors(1500, 5)
+      .checkSpillStats(false)
+      .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 hasSpill) {
+        const auto statsPair = taskSpilledStats(*task);
+        if (hasSpill) {
+          ASSERT_GT(statsPair.first.spilledRows, 0);
+          ASSERT_GT(statsPair.first.spilledBytes, 0);
+          ASSERT_GT(statsPair.first.spilledPartitions, 0);
+          ASSERT_GT(statsPair.first.spilledFiles, 0);
+          // There is no spilling at empty probe side.
+          ASSERT_EQ(statsPair.second.spilledRows, 0);
+          ASSERT_EQ(statsPair.second.spilledBytes, 0);
+          ASSERT_GT(statsPair.second.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.second.spilledFiles, 0);
+        } else {
+          ASSERT_EQ(statsPair.first.spilledRows, 0);
+          ASSERT_EQ(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.first.spilledFiles, 0);
+          ASSERT_EQ(statsPair.second.spilledRows, 0);
+          ASSERT_EQ(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.second.spilledFiles, 0);
+          verifyTaskSpilledRuntimeStats(*task, false);
+        }
+      })
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, normalizedKey) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .keyTypes({BIGINT(), VARCHAR()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .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")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, normalizedKeyOverflow) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .keyTypes({BIGINT(), VARCHAR(), BIGINT(), BIGINT(), BIGINT(), BIGINT()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .referenceQuery(
+          "SELECT t_k0, t_k1, t_k2, t_k3, t_k4, t_k5, t_data, u_k0, u_k1, u_k2, u_k3, u_k4, u_k5, u_data FROM t, u WHERE t_k0 = u_k0 AND t_k1 = u_k1 AND t_k2 = u_k2 AND t_k3 = u_k3 AND t_k4 = u_k4 AND t_k5 = u_k5")
+      .run();
+}
+
+DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, parallelJoinBuildCheck) {
+  std::atomic<bool> isParallelBuild{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashTable::parallelJoinBuild",
+      std::function<void(void*)>([&](void*) { isParallelBuild = true; }));
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .keyTypes({BIGINT(), VARCHAR()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .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);
+}
+
+DEBUG_ONLY_TEST_P(
+    MultiThreadedHashJoinTest,
+    raceBetweenTaskTerminateAndTableBuild) {
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(Operator*)>([&](Operator* op) {
+        auto task = op->operatorCtx()->task();
+        task->requestAbort();
+      }));
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .keyTypes({BIGINT(), VARCHAR()})
+          .probeVectors(1600, 5)
+          .buildVectors(1500, 5)
+          .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)
+          .run(),
+      "Aborted for external error");
+}
+
+TEST_P(MultiThreadedHashJoinTest, allTypes) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .keyTypes(
+          {BIGINT(),
+           VARCHAR(),
+           REAL(),
+           DOUBLE(),
+           INTEGER(),
+           SMALLINT(),
+           TINYINT()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .referenceQuery(
+          "SELECT t_k0, t_k1, t_k2, t_k3, t_k4, t_k5, t_k6, t_data, u_k0, u_k1, u_k2, u_k3, u_k4, u_k5, u_k6, u_data FROM t, u WHERE t_k0 = u_k0 AND t_k1 = u_k1 AND t_k2 = u_k2 AND t_k3 = u_k3 AND t_k4 = u_k4 AND t_k5 = u_k5 AND t_k6 = u_k6")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, filter) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .keyTypes({BIGINT()})
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .joinFilter("((t_k0 % 100) + (u_k0 % 100)) % 40 < 20")
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t_k0 = u_k0 AND ((t_k0 % 100) + (u_k0 % 100)) % 40 < 20")
+      .run();
+}
+
+DEBUG_ONLY_TEST_P(MultiThreadedHashJoinTest, filterSpillOnFirstProbeInput) {
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  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;
+        }
+        HashProbe* probeOp = static_cast<HashProbe*>(op);
+        if (!probeOp->testingHasPendingInput()) {
+          return;
+        }
+        if (!injectProbeSpillOnce.exchange(false)) {
+          return;
+        }
+        testingRunArbitration(op->pool());
+        ASSERT_EQ(op->pool()->usedBytes(), 40960);
+        ASSERT_EQ(op->pool()->reservedBytes(), 1048576);
+      }));
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .keyTypes({BIGINT()})
+      .numDrivers(1)
+      .probeVectors(1600, 5)
+      .buildVectors(1500, 5)
+      .injectSpill(false)
+      .spillDirectory(spillDirectory->getPath())
+      .joinFilter("((t_k0 % 100) + (u_k0 % 100)) % 40 < 20")
+      .referenceQuery(
+          "SELECT t_k0, t_data, u_k0, u_data FROM t, u WHERE t_k0 = u_k0 AND ((t_k0 % 100) + (u_k0 % 100)) % 40 < 20")
+      .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+        const auto statsPair = taskSpilledStats(*task);
+        ASSERT_EQ(statsPair.first.spilledRows, 0);
+        ASSERT_EQ(statsPair.first.spilledBytes, 0);
+        ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+        ASSERT_EQ(statsPair.first.spilledFiles, 0);
+        ASSERT_GT(statsPair.second.spilledRows, 0);
+        ASSERT_GT(statsPair.second.spilledBytes, 0);
+        ASSERT_GT(statsPair.second.spilledPartitions, 0);
+        ASSERT_GT(statsPair.second.spilledFiles, 0);
+      })
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithNull) {
+  struct {
+    double probeNullRatio;
+    double buildNullRatio;
+
+    std::string debugString() const {
+      return fmt::format(
+          "probeNullRatio: {}, buildNullRatio: {}",
+          probeNullRatio,
+          buildNullRatio);
+    }
+  } testSettings[] = {
+      {0.0, 1.0}, {0.0, 0.1}, {0.1, 1.0}, {0.1, 0.1}, {1.0, 1.0}, {1.0, 0.1}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    std::vector<RowVectorPtr> probeVectors =
+        makeBatches(5, 3, probeType_, pool_.get(), testData.probeNullRatio);
+
+    // The first half number of build batches having no nulls to trigger it
+    // later during the processing.
+    std::vector<RowVectorPtr> buildVectors = mergeBatches(
+        makeBatches(5, 6, buildType_, pool_.get(), 0.0),
+        makeBatches(5, 6, buildType_, pool_.get(), testData.buildNullRatio));
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .probeType(probeType_)
+        .probeKeys({"t_k2"})
+        .probeVectors(std::move(probeVectors))
+        .buildType(buildType_)
+        .buildKeys({"u_k2"})
+        .buildVectors(std::move(buildVectors))
+        .joinType(core::JoinType::kAnti)
+        .nullAware(true)
+        .joinOutputLayout({"t_k1", "t_k2"})
+        .referenceQuery(
+            "SELECT t_k1, t_k2 FROM t WHERE t.t_k2 NOT IN (SELECT u_k2 FROM u)")
+        // NOTE: we might not trigger spilling at build side if we detect the
+        // null join key in the build rows early.
+        .checkSpillStats(false)
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithLargeOutput) {
+  // Build the identical left and right vectors to generate large join
+  // outputs.
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(4, [&](uint32_t /*unused*/) {
+        return makeRowVector(
+            {"t0", "t1"},
+            {makeFlatVector<int32_t>(2048, [](auto row) { return row; }),
+             makeFlatVector<int32_t>(2048, [](auto row) { return row; })});
+      });
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(4, [&](uint32_t /*unused*/) {
+        return makeRowVector(
+            {"u0", "u1"},
+            {makeFlatVector<int32_t>(2048, [](auto row) { return row; }),
+             makeFlatVector<int32_t>(2048, [](auto row) { return row; })});
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"t0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u0"})
+      .buildVectors(std::move(buildVectors))
+      .joinType(core::JoinType::kRightSemiFilter)
+      .joinOutputLayout({"u1"})
+      .referenceQuery("SELECT u.u1 FROM u WHERE u.u0 IN (SELECT t0 FROM t)")
+      .run();
+}
+
+/// Test hash join where build-side keys come from a small range and allow for
+/// array-based lookup instead of a hash table.
+// Array-based lookup is not implemented for cudfHashJoin.
+TEST_P(MultiThreadedHashJoinTest, DISABLED_arrayBasedLookup) {
+  auto oddIndices = makeIndices(500, [](auto i) { return 2 * i + 1; });
+
+  std::vector<RowVectorPtr> probeVectors = {
+      // Join key vector is flat.
+      makeRowVector({
+          makeFlatVector<int32_t>(1'000, [](auto row) { return row; }),
+          makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+      }),
+      // Join key vector is constant. There is a match in the build side.
+      makeRowVector({
+          makeConstant(4, 2'000),
+          makeFlatVector<int64_t>(2'000, [](auto row) { return row; }),
+      }),
+      // Join key vector is constant. There is no match.
+      makeRowVector({
+          makeConstant(5, 2'000),
+          makeFlatVector<int64_t>(2'000, [](auto row) { return row; }),
+      }),
+      // Join key vector is a dictionary.
+      makeRowVector({
+          wrapInDictionary(
+              oddIndices,
+              500,
+              makeFlatVector<int32_t>(1'000, [](auto row) { return row * 4; })),
+          makeFlatVector<int64_t>(1'000, [](auto row) { return row; }),
+      })};
+
+  // 100 key values in [0, 198] range.
+  std::vector<RowVectorPtr> buildVectors = {
+      makeRowVector(
+          {makeFlatVector<int32_t>(100, [](auto row) { return row / 2; })}),
+      makeRowVector(
+          {makeFlatVector<int32_t>(100, [](auto row) { return row * 2; })}),
+      makeRowVector(
+          {makeFlatVector<int32_t>(100, [](auto row) { return row; })})};
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"c0"})
+      .buildVectors(std::move(buildVectors))
+      .joinOutputLayout({"c1"})
+      .outputProjections({"c1 + 1"})
+      .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
+      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+        if (hasSpill) {
+          return;
+        }
+        auto joinStats = task->taskStats()
+                             .pipelineStats.back()
+                             .operatorStats.back()
+                             .runtimeStats;
+        ASSERT_EQ(151, joinStats["distinctKey0"].sum);
+        ASSERT_EQ(200, joinStats["rangeKey0"].sum);
+      })
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, joinSidesDifferentSchema) {
+  // In this join, the tables have different schema. LHS table t has schema
+  // {INTEGER, VARCHAR, INTEGER}. RHS table u has schema {INTEGER, REAL,
+  // INTEGER}. The filter predicate uses
+  // a column from the right table  before the left and the corresponding
+  // columns at the same channel number(1) have different types. This has been
+  // a source of crashes in the join logic.
+  size_t batchSize = 100;
+
+  std::vector<std::string> stringVector = {"aaa", "bbb", "ccc", "ddd", "eee"};
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(5, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(batchSize, [](auto row) { return row; }),
+            makeFlatVector<StringView>(
+                batchSize,
+                [&](auto row) {
+                  return StringView(stringVector[row % stringVector.size()]);
+                }),
+            makeFlatVector<int32_t>(batchSize, [](auto row) { return row; }),
+        });
+      });
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(5, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(batchSize, [](auto row) { return row; }),
+            makeFlatVector<double>(
+                batchSize, [](auto row) { return row * 5.0; }),
+            makeFlatVector<int32_t>(batchSize, [](auto row) { return row; }),
+        });
+      });
+
+  // In this hash join the 2 tables have a common key which is the
+  // first channel in both tables.
+  const std::string referenceQuery =
+      "SELECT t.c0 * t.c2/2 FROM "
+      "  t, u "
+      "  WHERE t.c0 = u.c0 AND "
+      // TODO: enable ltrim test after the race condition in expression
+      // execution gets fixed.
+      //"  u.c2 > 10 AND ltrim(t.c1) = 'aaa'";
+      "  u.c2 > 10";
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"t_c0"})
+      .probeVectors(std::move(probeVectors))
+      .probeProjections({"c0 AS t_c0", "c1 AS t_c1", "c2 AS t_c2"})
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1", "c2 AS u_c2"})
+      //.joinFilter("u_c2 > 10 AND ltrim(t_c1) == 'aaa'")
+      .joinFilter("u_c2 > 10")
+      .joinOutputLayout({"t_c0", "t_c2"})
+      .outputProjections({"t_c0 * t_c2/2"})
+      .referenceQuery(referenceQuery)
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, innerJoinWithEmptyBuild) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (auto finishOnEmpty : finishOnEmptys) {
+    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
+
+    std::vector<RowVectorPtr> probeVectors = makeBatches(5, [&](int32_t batch) {
+      return makeRowVector({
+          makeFlatVector<int32_t>(
+              123,
+              [batch](auto row) { return row * 11 / std::max(batch, 1); },
+              nullEvery(13)),
+          makeFlatVector<int32_t>(1'234, [](auto row) { return row; }),
+      });
+    });
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(10, [&](int32_t batch) {
+          return makeRowVector({makeFlatVector<int32_t>(
+              123,
+              [batch](auto row) { return row % std::max(batch, 1); },
+              nullEvery(7))});
+        });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"c0"})
+        .buildVectors(std::move(buildVectors))
+        .buildFilter("c0 < 0")
+        .joinOutputLayout({"c1"})
+        .referenceQuery("SELECT null LIMIT 0")
+        .checkSpillStats(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          ASSERT_EQ(statsPair.first.spilledRows, 0);
+          ASSERT_EQ(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.first.spilledFiles, 0);
+          ASSERT_EQ(statsPair.second.spilledRows, 0);
+          ASSERT_EQ(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.second.spilledFiles, 0);
+          verifyTaskSpilledRuntimeStats(*task, false);
+          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+          // Check the hash probe has processed probe input rows.
+          if (finishOnEmpty) {
+            ASSERT_EQ(getInputPositions(task, 1), 0);
+          } else {
+            ASSERT_GT(getInputPositions(task, 1), 0);
+          }
+        })
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilter) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeType(probeType_)
+      .probeVectors(174, 5)
+      .probeKeys({"t_k1"})
+      .buildType(buildType_)
+      .buildVectors(133, 4)
+      .buildKeys({"u_k1"})
+      .joinType(core::JoinType::kLeftSemiFilter)
+      .joinOutputLayout({"t_k2"})
+      .referenceQuery("SELECT t_k2 FROM t WHERE t_k1 IN (SELECT u_k1 FROM u)")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithEmptyBuild) {
+  const std::vector<bool> finishOnEmptys = {false, true};
+  for (const auto finishOnEmpty : finishOnEmptys) {
+    SCOPED_TRACE(fmt::format("finishOnEmpty: {}", finishOnEmpty));
+
+    std::vector<RowVectorPtr> probeVectors =
+        makeBatches(10, [&](int32_t /*unused*/) {
+          return makeRowVector({
+              makeFlatVector<int32_t>(
+                  1'234, [](auto row) { return row % 11; }, nullEvery(13)),
+              makeFlatVector<int32_t>(1'234, [](auto row) { return row; }),
+          });
+        });
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(10, [&](int32_t /*unused*/) {
+          return makeRowVector({
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return row % 5; }, nullEvery(7)),
+          });
+        });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"c0"})
+        .buildVectors(std::move(buildVectors))
+        .joinType(core::JoinType::kLeftSemiFilter)
+        .joinFilter("c0 < 0")
+        .joinOutputLayout({"c1"})
+        .referenceQuery(
+            "SELECT t.c1 FROM t WHERE t.c0 IN (SELECT c0 FROM u WHERE c0 < 0)")
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftSemiJoinFilterWithExtraFilter) {
+  std::vector<RowVectorPtr> probeVectors = makeBatches(5, [&](int32_t batch) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<int32_t>(
+                250, [batch](auto row) { return row % (11 + batch); }),
+            makeFlatVector<int32_t>(
+                250, [batch](auto row) { return row * batch; }),
+        });
+  });
+
+  std::vector<RowVectorPtr> buildVectors = makeBatches(5, [&](int32_t batch) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>(
+                123, [batch](auto row) { return row % (5 + batch); }),
+            makeFlatVector<int32_t>(
+                123, [batch](auto row) { return row * batch; }),
+        });
+  });
+
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .numDrivers(numDrivers_)
+        .probeKeys({"t0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::move(testBuildVectors))
+        .joinType(core::JoinType::kLeftSemiFilter)
+        .joinOutputLayout({"t0", "t1"})
+        .referenceQuery(
+            "SELECT t.* FROM t WHERE EXISTS (SELECT u0 FROM u WHERE t0 = u0)")
+        .run();
+  }
+
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .numDrivers(numDrivers_)
+        .probeKeys({"t0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::move(testBuildVectors))
+        .joinType(core::JoinType::kLeftSemiFilter)
+        .joinFilter("t1 != u1")
+        .joinOutputLayout({"t0", "t1"})
+        .referenceQuery(
+            "SELECT t.* FROM t WHERE EXISTS (SELECT u0, u1 FROM u WHERE t0 = u0 AND t1 <> u1)")
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilter) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeType(probeType_)
+      .probeVectors(133, 3)
+      .probeKeys({"t_k1"})
+      .buildType(buildType_)
+      .buildVectors(174, 4)
+      .buildKeys({"u_k1"})
+      .joinType(core::JoinType::kRightSemiFilter)
+      .joinOutputLayout({"u_k2"})
+      .referenceQuery("SELECT u_k2 FROM u WHERE u_k1 IN (SELECT t_k1 FROM t)")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithEmptyBuild) {
+  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.
+    std::vector<RowVectorPtr> probeVectors =
+        makeBatches(5, [&](uint32_t /*unused*/) {
+          return makeRowVector(
+              {"t0", "t1"},
+              {makeFlatVector<int32_t>(
+                   431, [](auto row) { return row % 11; }, nullEvery(13)),
+               makeFlatVector<int32_t>(431, [](auto row) { return row; })});
+        });
+
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(5, [&](uint32_t /*unused*/) {
+          return makeRowVector(
+              {"u0", "u1"},
+              {
+                  makeFlatVector<int32_t>(
+                      434, [](auto row) { return row % 5; }, nullEvery(7)),
+                  makeFlatVector<int32_t>(434, [](auto row) { return row; }),
+              });
+        });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .probeKeys({"t0"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::move(buildVectors))
+        .buildFilter("u0 < 0")
+        .joinType(core::JoinType::kRightSemiFilter)
+        .joinOutputLayout({"u1"})
+        .referenceQuery(
+            "SELECT u.u1 FROM u WHERE u.u0 IN (SELECT t0 FROM t) AND u.u0 < 0")
+        .checkSpillStats(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          ASSERT_EQ(statsPair.first.spilledRows, 0);
+          ASSERT_EQ(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.first.spilledFiles, 0);
+          ASSERT_EQ(statsPair.second.spilledRows, 0);
+          ASSERT_EQ(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.second.spilledFiles, 0);
+          verifyTaskSpilledRuntimeStats(*task, false);
+          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+          // Check the hash probe has processed probe input rows.
+          if (finishOnEmpty) {
+            ASSERT_EQ(getInputPositions(task, 1), 0);
+          } else {
+            ASSERT_GT(getInputPositions(task, 1), 0);
+          }
+        })
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithAllMatches) {
+  // Make build side larger to test all rows are returned.
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(3, [&](uint32_t /*unused*/) {
+        return makeRowVector(
+            {"t0", "t1"},
+            {
+                makeFlatVector<int32_t>(
+                    123, [](auto row) { return row % 5; }, nullEvery(7)),
+                makeFlatVector<int32_t>(123, [](auto row) { return row; }),
+            });
+      });
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(5, [&](uint32_t /*unused*/) {
+        return makeRowVector(
+            {"u0", "u1"},
+            {makeFlatVector<int32_t>(
+                 314, [](auto row) { return row % 11; }, nullEvery(13)),
+             makeFlatVector<int32_t>(314, [](auto row) { return row; })});
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"t0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u0"})
+      .buildVectors(std::move(buildVectors))
+      .joinType(core::JoinType::kRightSemiFilter)
+      .joinOutputLayout({"u1"})
+      .referenceQuery("SELECT u.u1 FROM u WHERE u.u0 IN (SELECT t0 FROM t)")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightSemiJoinFilterWithExtraFilter) {
+  auto probeVectors = makeBatches(4, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<int32_t>(345, [](auto row) { return row; }),
+            makeFlatVector<int32_t>(345, [](auto row) { return row; }),
+        });
+  });
+
+  auto buildVectors = makeBatches(4, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>(250, [](auto row) { return row; }),
+            makeFlatVector<int32_t>(250, [](auto row) { return row; }),
+        });
+  });
+
+  // Always true filter.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .numDrivers(numDrivers_)
+        .probeKeys({"t0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::move(testBuildVectors))
+        .joinType(core::JoinType::kRightSemiFilter)
+        .joinFilter("t1 > -1")
+        .joinOutputLayout({"u0", "u1"})
+        .referenceQuery(
+            "SELECT u.* FROM u WHERE EXISTS (SELECT t0 FROM t WHERE u0 = t0 AND t1 > -1)")
+        .run();
+  }
+
+  // Always false filter.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .numDrivers(numDrivers_)
+        .probeKeys({"t0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::move(testBuildVectors))
+        .joinType(core::JoinType::kRightSemiFilter)
+        .joinFilter("t1 > 100000")
+        .joinOutputLayout({"u0", "u1"})
+        .referenceQuery(
+            "SELECT u.* FROM u WHERE EXISTS (SELECT t0 FROM t WHERE u0 = t0 AND t1 > 100000)")
+        .run();
+  }
+
+  // Selective filter.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .numDrivers(numDrivers_)
+        .probeKeys({"t0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::move(testBuildVectors))
+        .joinType(core::JoinType::kRightSemiFilter)
+        .joinFilter("t1 % 5 = 0")
+        .joinOutputLayout({"u0", "u1"})
+        .referenceQuery(
+            "SELECT u.* FROM u WHERE EXISTS (SELECT t0 FROM t WHERE u0 = t0 AND t1 % 5 = 0)")
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, DISABLED_semiFilterOverLazyVectors) {
+  auto probeVectors = makeBatches(1, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<int32_t>(1'000, [](auto row) { return row; }),
+            makeFlatVector<int64_t>(1'000, [](auto row) { return row * 10; }),
+        });
+  });
+
+  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>(
+                1'000, [](auto row) { return -100 + (row / 5); }),
+            makeFlatVector<int64_t>(
+                1'000, [](auto row) { return -1000 + (row / 5) * 10; }),
+        });
+  });
+
+  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);
+
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId buildScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(asRowType(probeVectors[0]->type()))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(asRowType(buildVectors[0]->type()))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      "",
+                      {"t0", "t1"},
+                      core::JoinType::kLeftSemiFilter)
+                  .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 t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u)")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .planNode(flipJoinSides(plan))
+      .inputSplits(splitInput)
+      .checkSpillStats(false)
+      .referenceQuery("SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u)")
+      .run();
+
+  // With extra filter.
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  plan = PlanBuilder(planNodeIdGenerator)
+             .tableScan(asRowType(probeVectors[0]->type()))
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator)
+                     .tableScan(asRowType(buildVectors[0]->type()))
+                     .capturePlanNodeId(buildScanId)
+                     .planNode(),
+                 "(t1 + u1) % 3 = 0",
+                 {"t0", "t1"},
+                 core::JoinType::kLeftSemiFilter)
+             .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(plan)
+      .inputSplits(splitInput)
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0)")
+      .run();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .planNode(flipJoinSides(plan))
+      .inputSplits(splitInput)
+      .checkSpillStats(false)
+      .referenceQuery(
+          "SELECT t0, t1 FROM t WHERE t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0)")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, DISABLED_nullAwareAntiJoin) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(5, [&](uint32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                1'000, [](auto row) { return row % 11; }, nullEvery(13)),
+            makeFlatVector<int32_t>(1'000, [](auto row) { return row; }),
+        });
+      });
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(5, [&](uint32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                1'234, [](auto row) { return row % 5; }, nullEvery(7)),
+        });
+      });
+
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildFilter("c0 IS NOT NULL")
+        .joinType(core::JoinType::kAnti)
+        .nullAware(true)
+        .joinOutputLayout({"c1"})
+        .referenceQuery(
+            "SELECT t.c1 FROM t WHERE t.c0 NOT IN (SELECT c0 FROM u WHERE c0 IS NOT NULL)")
+        .checkSpillStats(false)
+        .run();
+  }
+
+  // Empty build side.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildFilter("c0 < 0")
+        .joinType(core::JoinType::kAnti)
+        .nullAware(true)
+        .joinOutputLayout({"c1"})
+        .referenceQuery(
+            "SELECT t.c1 FROM t WHERE t.c0 NOT IN (SELECT c0 FROM u WHERE c0 < 0)")
+        .checkSpillStats(false)
+        .run();
+  }
+
+  // Build side with nulls. Null-aware Anti join always returns nothing.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .joinType(core::JoinType::kAnti)
+        .nullAware(true)
+        .joinOutputLayout({"c1"})
+        .referenceQuery(
+            "SELECT t.c1 FROM t WHERE t.c0 NOT IN (SELECT c0 FROM u)")
+        .checkSpillStats(false)
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilter) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(5, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"t0", "t1"},
+            {
+                makeFlatVector<int32_t>(128, [](auto row) { return row % 11; }),
+                makeFlatVector<int32_t>(128, [](auto row) { return row; }),
+            });
+      });
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(5, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"u0", "u1"},
+            {
+                makeFlatVector<int32_t>(123, [](auto row) { return row % 5; }),
+                makeFlatVector<int32_t>(123, [](auto row) { return row; }),
+            });
+      });
+
+  // null-anti join with filter not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .probeKeys({"t0"})
+          .probeVectors(std::move(probeVectors))
+          .buildKeys({"u0"})
+          .buildVectors(std::move(buildVectors))
+          .joinType(core::JoinType::kAnti)
+          .nullAware(true)
+          .joinFilter("t1 != u1")
+          .joinOutputLayout({"t0", "t1"})
+          .referenceQuery(
+              "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE t0 = u0 AND t1 <> u1)")
+          .checkSpillStats(false)
+          .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+            // Verify spilling is not triggered in case of null-aware anti-join
+            // with filter.
+            const auto statsPair = taskSpilledStats(*task);
+            ASSERT_EQ(statsPair.first.spilledRows, 0);
+            ASSERT_EQ(statsPair.first.spilledBytes, 0);
+            ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+            ASSERT_EQ(statsPair.first.spilledFiles, 0);
+            ASSERT_EQ(statsPair.second.spilledRows, 0);
+            ASSERT_EQ(statsPair.second.spilledBytes, 0);
+            ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+            ASSERT_EQ(statsPair.second.spilledFiles, 0);
+            verifyTaskSpilledRuntimeStats(*task, false);
+            ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+          })
+          .run(),
+      "Replacement with cuDF operator failed");
+}
+
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndEmptyBuild) {
+  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*/) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
+              makeFlatVector<int32_t>({0, 1, 2}),
+          });
+    });
+    auto buildVectors = makeBatches(4, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeNullableFlatVector<int32_t>({3, 2, 3}),
+              makeFlatVector<int32_t>({0, 2, 3}),
+          });
+    });
+
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+            .buildFilter("u0 < 0")
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter("u1 > t1")
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(
+                "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u0 < 0 AND u.u0 = t.t0)")
+            .checkSpillStats(false)
+            .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+              // Verify spilling is not triggered in case of null-aware
+              // anti-join with filter.
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_EQ(statsPair.first.spilledRows, 0);
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.first.spilledFiles, 0);
+              ASSERT_EQ(statsPair.second.spilledRows, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledFiles, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+              ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+            })
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterAndNullKey) {
+  auto probeVectors = makeBatches(4, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
+            makeFlatVector<int32_t>({0, 1, 2}),
+        });
+  });
+  auto buildVectors = makeBatches(4, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 2, 3}),
+            makeFlatVector<int32_t>({0, 2, 3}),
+        });
+  });
+
+  std::vector<std::string> filters({"u1 > t1", "u1 * t1 > 0"});
+  for (const std::string& filter : filters) {
+    const auto referenceSql = fmt::format(
+        "SELECT t.* FROM t WHERE t0 NOT IN (SELECT u0 FROM u WHERE {})",
+        filter);
+
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::move(testProbeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::move(testBuildVectors))
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter(filter)
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(referenceSql)
+            .checkSpillStats(false)
+            .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+              // Verify spilling is not triggered in case of null-aware
+              // anti-join with filter.
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_EQ(statsPair.first.spilledRows, 0);
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.first.spilledFiles, 0);
+              ASSERT_EQ(statsPair.second.spilledRows, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledFiles, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+              ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+            })
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+}
+
+TEST_P(
+    MultiThreadedHashJoinTest,
+    hashModeNullAwareAntiJoinWithFilterAndNullKey) {
+  // Use float type keys to trigger hash mode table.
+  auto probeVectors = makeBatches(50, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<float>({std::nullopt, 1, 2}),
+            makeFlatVector<int32_t>({1, 1, 2}),
+        });
+  });
+  auto buildVectors = makeBatches(5, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<float>({std::nullopt, 2, 3}),
+            makeFlatVector<int32_t>({0, 2, 3}),
+        });
+  });
+
+  std::vector<std::string> filters({"u1 < t1", "u1 + t1 = 0"});
+  for (const std::string& filter : filters) {
+    const auto referenceSql = fmt::format(
+        "SELECT t.* FROM t WHERE t0 NOT IN (SELECT u0 FROM u WHERE {})",
+        filter);
+
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::move(testProbeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::move(testBuildVectors))
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter(filter)
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(referenceSql)
+            .checkSpillStats(false)
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, nullAwareAntiJoinWithFilterOnNullableColumn) {
+  const std::string referenceSql =
+      "SELECT t.* FROM t WHERE t0 NOT IN (SELECT u0 FROM u WHERE t1 <> u1)";
+  const std::string joinFilter = "t1 <> u1";
+  {
+    SCOPED_TRACE("null filter column");
+    auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeFlatVector<int32_t>(200, [](auto row) { return row % 11; }),
+              makeFlatVector<int32_t>(200, folly::identity, nullEvery(97)),
+          });
+    });
+    auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeFlatVector<int32_t>(234, [](auto row) { return row % 5; }),
+              makeFlatVector<int32_t>(234, folly::identity, nullEvery(91)),
+          });
+    });
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::move(probeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::move(buildVectors))
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter(joinFilter)
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(referenceSql)
+            .checkSpillStats(false)
+            .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+              // Verify spilling is not triggered in case of null-aware
+              // anti-join with filter.
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_EQ(statsPair.first.spilledRows, 0);
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.first.spilledFiles, 0);
+              ASSERT_EQ(statsPair.second.spilledRows, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledFiles, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+              ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+            })
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+
+  {
+    SCOPED_TRACE("null filter and key column");
+    auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeFlatVector<int32_t>(
+                  200, [](auto row) { return row % 11; }, nullEvery(23)),
+              makeFlatVector<int32_t>(200, folly::identity, nullEvery(29)),
+          });
+    });
+    auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeFlatVector<int32_t>(
+                  234, [](auto row) { return row % 5; }, nullEvery(31)),
+              makeFlatVector<int32_t>(234, folly::identity, nullEvery(37)),
+          });
+    });
+    // null-anti join with filter not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .probeKeys({"t0"})
+            .probeVectors(std::move(probeVectors))
+            .buildKeys({"u0"})
+            .buildVectors(std::move(buildVectors))
+            .joinType(core::JoinType::kAnti)
+            .nullAware(true)
+            .joinFilter(joinFilter)
+            .joinOutputLayout({"t0", "t1"})
+            .referenceQuery(referenceSql)
+            .checkSpillStats(false)
+            .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+              // Verify spilling is not triggered in case of null-aware
+              // anti-join with filter.
+              const auto statsPair = taskSpilledStats(*task);
+              ASSERT_EQ(statsPair.first.spilledRows, 0);
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.first.spilledFiles, 0);
+              ASSERT_EQ(statsPair.second.spilledRows, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledFiles, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+              ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+            })
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, antiJoin) {
+  auto probeVectors = makeBatches(64, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
+            makeFlatVector<int32_t>({0, 1, 2}),
+        });
+  });
+  auto buildVectors = makeBatches(64, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({std::nullopt, 2, 3}),
+            makeFlatVector<int32_t>({0, 2, 3}),
+        });
+  });
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .checkSpillStats(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"t0"})
+      .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+      .buildKeys({"u0"})
+      .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+      .joinType(core::JoinType::kAnti)
+      .joinOutputLayout({"t0", "t1"})
+      .referenceQuery(
+          "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0)")
+      .run();
+
+  std::vector<std::string> filters({
+      "u1 > t1",
+      "u1 * t1 > 0",
+      // This filter is true on rows without a match. It should not prevent
+      // the row from being returned.
+      // Disabling this because coalesce is not supported in cudf.
+      // "coalesce(u1, t1, 0::integer) is not null",
+      // This filter throws if evaluated on rows without a match. The join
+      // should not evaluate filter on those rows and therefore should not
+      // fail.
+      // Disabling this because coalesce is not supported in cudf.
+      // "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.
+      // Disabling this because contains is not supported in cudf.
+      // "contains(array[1, 2, NULL], 1)",
+  });
+  for (const std::string& filter : filters) {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .checkSpillStats(false)
+        .numDrivers(numDrivers_)
+        .probeKeys({"t0"})
+        .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+        .joinType(core::JoinType::kAnti)
+        .joinFilter(filter)
+        .joinOutputLayout({"t0", "t1"})
+        .referenceQuery(
+            fmt::format(
+                "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u.u0 = t.t0 AND {})",
+                filter))
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, antiJoinWithFilterAndEmptyBuild) {
+  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*/) {
+      return makeRowVector(
+          {"t0", "t1"},
+          {
+              makeNullableFlatVector<int32_t>({std::nullopt, 1, 2}),
+              makeFlatVector<int32_t>({0, 1, 2}),
+          });
+    });
+    auto buildVectors = makeBatches(4, [&](int32_t /*unused*/) {
+      return makeRowVector(
+          {"u0", "u1"},
+          {
+              makeNullableFlatVector<int32_t>({3, 2, 3}),
+              makeFlatVector<int32_t>({0, 2, 3}),
+          });
+    });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .probeKeys({"t0"})
+        .probeVectors(std::vector<RowVectorPtr>(probeVectors))
+        .buildKeys({"u0"})
+        .buildVectors(std::vector<RowVectorPtr>(buildVectors))
+        .buildFilter("u0 < 0")
+        .joinType(core::JoinType::kAnti)
+        .joinFilter("u1 > t1")
+        .joinOutputLayout({"t0", "t1"})
+        .referenceQuery(
+            "SELECT t.* FROM t WHERE NOT EXISTS (SELECT * FROM u WHERE u0 < 0 AND u.u0 = t.t0)")
+        .checkSpillStats(false)
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          ASSERT_EQ(statsPair.first.spilledRows, 0);
+          ASSERT_EQ(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.first.spilledFiles, 0);
+          ASSERT_EQ(statsPair.second.spilledRows, 0);
+          ASSERT_EQ(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+          ASSERT_EQ(statsPair.second.spilledFiles, 0);
+          verifyTaskSpilledRuntimeStats(*task, false);
+          ASSERT_EQ(maxHashBuildSpillLevel(*task), -1);
+        })
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoin) {
+  // Left side keys are [0, 1, 2,..20].
+  // Use 3-rd column as row number to allow for asserting the order of
+  // results.
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](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; }),
+                });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        97,
+                        [](auto row) { return (row + 3) % 21; },
+                        nullEvery(13)),
+                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(
+                        97, [](auto row) { return 97 + row; }),
+                });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return row % 5; }, nullEvery(7)),
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .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 == "CudfHashJoinBuild") {
+              nullJoinBuildKeyCount += op.numNullKeys;
+            }
+            if (op.operatorType == "CudfHashJoinProbe") {
+              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 == "CudfHashJoinBuild") {
+              nullJoinBuildKeyCount += op.numNullKeys;
+            }
+            if (op.operatorType == "CudfHashJoinProbe") {
+              nullJoinProbeKeyCount += op.numNullKeys;
+            }
+          }
+        }
+        // Due to inaccurate stats tracking in case of empty build side,
+        // we will report 0 null keys on probe side.
+        // CudfHashJoinProbe will reports correct null keys
+        // since early exit is not implemented.
+        ASSERT_EQ(nullJoinProbeKeyCount, 6 * GetParam().numDrivers);
+        ASSERT_EQ(nullJoinBuildKeyCount, 1 * GetParam().numDrivers);
+      })
+      .checkSpillStats(false)
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithEmptyBuild) {
+  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].
+    // Use 3-rd column as row number to allow for asserting the order of
+    // results.
+    std::vector<RowVectorPtr> probeVectors = mergeBatches(
+        makeBatches(
+            3,
+            [&](int32_t /*unused*/) {
+              return makeRowVector(
+                  {"c0", "c1", "row_number"},
+                  {
+                      makeFlatVector<int32_t>(
+                          77, [](auto row) { return row % 11; }, nullEvery(13)),
+                      makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                      makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                  });
+            }),
+        makeBatches(
+            2,
+            [&](int32_t /*unused*/) {
+              return makeRowVector(
+                  {"c0", "c1", "row_number"},
+                  {
+                      makeFlatVector<int32_t>(
+                          97,
+                          [](auto row) { return (row + 3) % 11; },
+                          nullEvery(13)),
+                      makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                      makeFlatVector<int32_t>(
+                          97, [](auto row) { return 97 + row; }),
+                  });
+            }),
+        true);
+
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(3, [&](int32_t /*unused*/) {
+          return makeRowVector({
+              makeFlatVector<int32_t>(
+                  73, [](auto row) { return row % 5; }, nullEvery(7)),
+              makeFlatVector<int32_t>(
+                  73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+          });
+        });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(buildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .buildFilter("c0 < 0")
+        .joinType(core::JoinType::kLeft)
+        .joinOutputLayout({"row_number", "c1"})
+        .referenceQuery(
+            "SELECT t.row_number, t.c1 FROM t LEFT JOIN (SELECT c0 FROM u WHERE c0 < 0) u ON t.c0 = u.c0")
+        .checkSpillStats(false)
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithNoJoin) {
+  // Left side keys are [0, 1, 2,..10].
+  // Use 3-rd column as row number to allow for asserting the order of
+  // results.
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        77, [](auto row) { return row % 11; }, nullEvery(13)),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        97,
+                        [](auto row) { return (row + 3) % 11; },
+                        nullEvery(13)),
+                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(
+                        97, [](auto row) { return 97 + row; }),
+                });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return row % 5; }, nullEvery(7)),
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 - 123::INTEGER AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kLeft)
+      .joinOutputLayout({"row_number", "c0", "u_c1"})
+      .referenceQuery(
+          "SELECT t.row_number, t.c0, u.c1 FROM t LEFT JOIN (SELECT c0 - 123::INTEGER AS u_c0, c1 FROM u) u ON t.c0 = u.u_c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithAllMatch) {
+  // Left side keys are [0, 1, 2,..10].
+  // Use 3-rd column as row number to allow for asserting the order of
+  // results.
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        77, [](auto row) { return row % 11; }, nullEvery(13)),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        97,
+                        [](auto row) { return (row + 3) % 11; },
+                        nullEvery(13)),
+                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(
+                        97, [](auto row) { return 97 + row; }),
+                });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return row % 5; }, nullEvery(7)),
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .probeFilter("c0 < 5")
+      .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_c1"})
+      .referenceQuery(
+          "SELECT t.row_number, t.c0, t.c1, u.c1 FROM (SELECT * FROM t WHERE c0 < 5) t LEFT JOIN u ON t.c0 = u.c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithFilter) {
+  // Left side keys are [0, 1, 2,..10].
+  // Use 3-rd column as row number to allow for asserting the order of
+  // results.
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        77, [](auto row) { return row % 11; }, nullEvery(13)),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(77, [](auto row) { return row; }),
+                });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector(
+                {"c0", "c1", "row_number"},
+                {
+                    makeFlatVector<int32_t>(
+                        97,
+                        [](auto row) { return (row + 3) % 11; },
+                        nullEvery(13)),
+                    makeFlatVector<int32_t>(97, [](auto row) { return row; }),
+                    makeFlatVector<int32_t>(
+                        97, [](auto row) { return 97 + row; }),
+                });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return row % 5; }, nullEvery(7)),
+            makeFlatVector<int32_t>(
+                73, [](auto row) { return -111 + row * 2; }, nullEvery(7)),
+        });
+      });
+
+  // Additional filter.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .numDrivers(numDrivers_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kLeft)
+        .joinFilter("(c1 + u_c1) % 2 = 1")
+        .joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.row_number, t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
+        .run();
+  }
+
+  // No rows pass the additional filter.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .numDrivers(numDrivers_)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kLeft)
+        .joinFilter("(c1 + u_c1) % 2  = 3")
+        .joinOutputLayout({"row_number", "c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.row_number, t.c0, t.c1, u.c1 FROM t LEFT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
+        .run();
+  }
+}
+
+/// Tests left join with a filter that may evaluate to true, false or null.
+/// Makes sure that null filter results are handled correctly, e.g. as if the
+/// filter returned false.
+TEST_P(MultiThreadedHashJoinTest, leftJoinWithNullableFilter) {
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          5,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+                makeNullableFlatVector<int32_t>(
+                    {10, std::nullopt, 30, std::nullopt, 50}),
+            });
+          }),
+      makeBatches(
+          5,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+                makeNullableFlatVector<int32_t>(
+                    {std::nullopt, 20, 30, std::nullopt, 50}),
+            });
+          }),
+      true);
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(5, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {makeFlatVector<int32_t>(128, [](vector_size_t row) {
+              if (row < 3) {
+                return row;
+              }
+              return row + 10;
+            })});
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .checkSpillStats(false)
+      .numDrivers(numDrivers_)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildProjections({"c0 AS u_c0"})
+      .joinType(core::JoinType::kLeft)
+      .joinFilter("c1 + u_c0 > 0")
+      .joinOutputLayout({"c0", "c1", "u_c0"})
+      .referenceQuery(
+          "SELECT * FROM t LEFT JOIN u ON (t.c0 = u.c0 AND t.c1 + u.c0 > 0)")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightJoin) {
+  // Left side keys are [0, 1, 2,..20].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    234,
+                    [](auto row) { return (row + 3) % 21; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .injectSpill(false)
+      .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::kRight)
+      .joinOutputLayout({"c0", "c1", "u_c1"})
+      .referenceQuery(
+          "SELECT t.c0, t.c1, u.c1 FROM t RIGHT 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 == "CudfHashJoinBuild") {
+              nullJoinBuildKeyCount += op.numNullKeys;
+            }
+            if (op.operatorType == "CudfHashJoinProbe") {
+              nullJoinProbeKeyCount += op.numNullKeys;
+            }
+          }
+        }
+        ASSERT_GT(nullJoinBuildKeyCount, 0);
+        ASSERT_GT(nullJoinProbeKeyCount, 0);
+      })
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightJoinWithEmptyBuild) {
+  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].
+    std::vector<RowVectorPtr> probeVectors = mergeBatches(
+        makeBatches(
+            3,
+            [&](int32_t /*unused*/) {
+              return makeRowVector({
+                  makeFlatVector<int32_t>(
+                      137, [](auto row) { return row % 11; }, nullEvery(13)),
+                  makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+              });
+            }),
+        makeBatches(
+            3,
+            [&](int32_t /*unused*/) {
+              return makeRowVector({
+                  makeFlatVector<int32_t>(
+                      234,
+                      [](auto row) { return (row + 3) % 11; },
+                      nullEvery(13)),
+                  makeFlatVector<int32_t>(234, [](auto row) { return row; }),
+              });
+            }),
+        true);
+
+    // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(3, [&](int32_t /*unused*/) {
+          return makeRowVector({
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+          });
+        });
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+        .numDrivers(numDrivers_)
+        .injectSpill(false)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(probeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(buildVectors))
+        .buildFilter("c0 > 100")
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kRight)
+        .joinOutputLayout({"c1"})
+        .referenceQuery("SELECT null LIMIT 0")
+        .checkSpillStats(false)
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightJoinWithAllMatch) {
+  // Left side keys are [0, 1, 2,..20].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    234,
+                    [](auto row) { return (row + 3) % 21; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .injectSpill(false)
+      .probeKeys({"c0"})
+      .probeVectors(std::move(probeVectors))
+      .buildKeys({"u_c0"})
+      .buildVectors(std::move(buildVectors))
+      .buildFilter("c0 >= 0")
+      .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+      .joinType(core::JoinType::kRight)
+      .joinOutputLayout({"c0", "c1", "u_c1"})
+      .referenceQuery(
+          "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN (SELECT * FROM u WHERE c0 >= 0) u ON t.c0 = u.c0")
+      .run();
+}
+
+TEST_P(MultiThreadedHashJoinTest, rightJoinWithFilter) {
+  // Left side keys are [0, 1, 2,..20].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    234,
+                    [](auto row) { return (row + 3) % 21; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(234, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  // Filter with passed rows.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .injectSpill(false)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kRight)
+        .joinFilter("(c1 + u_c1) % 2 = 1")
+        .joinOutputLayout({"c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
+        .run();
+  }
+
+  // Filter without passed rows.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .injectSpill(false)
+        .probeKeys({"c0"})
+        .probeVectors(std::move(testProbeVectors))
+        .buildKeys({"u_c0"})
+        .buildVectors(std::move(testBuildVectors))
+        .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+        .joinType(core::JoinType::kRight)
+        .joinFilter("(c1 + u_c1) % 2 = 3")
+        .joinOutputLayout({"c0", "c1", "u_c1"})
+        .referenceQuery(
+            "SELECT t.c0, t.c1, u.c1 FROM t RIGHT JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
+        .run();
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, fullJoin) {
+  // Left side keys are [0, 1, 2,..20].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    213, [](auto row) { return row % 21; }, nullEvery(13)),
+                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137,
+                    [](auto row) { return (row + 3) % 21; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1,
+  // 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  // full join not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .injectSpill(false)
+          .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::kFull)
+          .joinOutputLayout({"c0", "c1", "u_c1"})
+          .referenceQuery(
+              "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0")
+          .run(),
+      "Replacement with cuDF operator failed");
+}
+
+TEST_P(MultiThreadedHashJoinTest, fullJoinWithEmptyBuild) {
+  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].
+    std::vector<RowVectorPtr> probeVectors = mergeBatches(
+        makeBatches(
+            3,
+            [&](int32_t /*unused*/) {
+              return makeRowVector({
+                  makeFlatVector<int32_t>(
+                      213, [](auto row) { return row % 11; }, nullEvery(13)),
+                  makeFlatVector<int32_t>(213, [](auto row) { return row; }),
+              });
+            }),
+        makeBatches(
+            2,
+            [&](int32_t /*unused*/) {
+              return makeRowVector({
+                  makeFlatVector<int32_t>(
+                      137,
+                      [](auto row) { return (row + 3) % 11; },
+                      nullEvery(13)),
+                  makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+              });
+            }),
+        true);
+
+    // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+    std::vector<RowVectorPtr> buildVectors =
+        makeBatches(3, [&](int32_t /*unused*/) {
+          return makeRowVector({
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+              makeFlatVector<int32_t>(
+                  123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+          });
+        });
+
+    // full join not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .hashProbeFinishEarlyOnEmptyBuild(finishOnEmpty)
+            .numDrivers(numDrivers_)
+            .injectSpill(false)
+            .probeKeys({"c0"})
+            .probeVectors(std::move(probeVectors))
+            .buildKeys({"u_c0"})
+            .buildVectors(std::move(buildVectors))
+            .buildFilter("c0 > 100")
+            .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+            .joinType(core::JoinType::kFull)
+            .joinOutputLayout({"c1"})
+            .referenceQuery(
+                "SELECT t.c1 FROM t FULL OUTER JOIN (SELECT * FROM u WHERE c0 > 100) u ON t.c0 = u.c0")
+            .checkSpillStats(false)
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, fullJoinWithNoMatch) {
+  // Left side keys are [0, 1, 2,..10].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    213, [](auto row) { return row % 11; }, nullEvery(13)),
+                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137,
+                    [](auto row) { return (row + 3) % 11; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  // full join not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .injectSpill(false)
+          .probeKeys({"c0"})
+          .probeVectors(std::move(probeVectors))
+          .buildKeys({"u_c0"})
+          .buildVectors(std::move(buildVectors))
+          .buildFilter("c0 < 0")
+          .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+          .joinType(core::JoinType::kFull)
+          .joinOutputLayout({"c1"})
+          .referenceQuery(
+              "SELECT t.c1 FROM t FULL OUTER JOIN (SELECT * FROM u WHERE c0 < 0) u ON t.c0 = u.c0")
+          .run(),
+      "Replacement with cuDF operator failed");
+}
+
+TEST_P(MultiThreadedHashJoinTest, fullJoinWithFilters) {
+  // Left side keys are [0, 1, 2,..10].
+  std::vector<RowVectorPtr> probeVectors = mergeBatches(
+      makeBatches(
+          3,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    213, [](auto row) { return row % 11; }, nullEvery(13)),
+                makeFlatVector<int32_t>(213, [](auto row) { return row; }),
+            });
+          }),
+      makeBatches(
+          2,
+          [&](int32_t /*unused*/) {
+            return makeRowVector({
+                makeFlatVector<int32_t>(
+                    137,
+                    [](auto row) { return (row + 3) % 11; },
+                    nullEvery(13)),
+                makeFlatVector<int32_t>(137, [](auto row) { return row; }),
+            });
+          }),
+      true);
+
+  // Right side keys are [-3, -2, -1, 0, 1, 2, 3].
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(3, [&](int32_t /*unused*/) {
+        return makeRowVector({
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -3 + row % 7; }, nullEvery(11)),
+            makeFlatVector<int32_t>(
+                123, [](auto row) { return -111 + row * 2; }, nullEvery(13)),
+        });
+      });
+
+  // Filter with passed rows.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    // full join not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .injectSpill(false)
+            .probeKeys({"c0"})
+            .probeVectors(std::move(testProbeVectors))
+            .buildKeys({"u_c0"})
+            .buildVectors(std::move(testBuildVectors))
+            .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+            .joinType(core::JoinType::kFull)
+            .joinFilter("(c1 + u_c1) % 2 = 1")
+            .joinOutputLayout({"c0", "c1", "u_c1"})
+            .referenceQuery(
+                "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 1")
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+
+  // Filter without passed rows.
+  {
+    auto testProbeVectors = probeVectors;
+    auto testBuildVectors = buildVectors;
+    // full join not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .numDrivers(numDrivers_)
+            .injectSpill(false)
+            .probeKeys({"c0"})
+            .probeVectors(std::move(testProbeVectors))
+            .buildKeys({"u_c0"})
+            .buildVectors(std::move(testBuildVectors))
+            .buildProjections({"c0 AS u_c0", "c1 AS u_c1"})
+            .joinType(core::JoinType::kFull)
+            .joinFilter("(c1 + u_c1) % 2 = 3")
+            .joinOutputLayout({"c0", "c1", "u_c1"})
+            .referenceQuery(
+                "SELECT t.c0, t.c1, u.c1 FROM t FULL OUTER JOIN u ON t.c0 = u.c0 AND (t.c1 + u.c1) % 2 = 3")
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+}
+
+TEST_P(MultiThreadedHashJoinTest, noSpillLevelLimit) {
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(numDrivers_)
+      .injectSpill(false)
+      .keyTypes({INTEGER()})
+      .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")
+      .maxSpillLevel(-1)
+      .config(core::QueryConfig::kSpillStartPartitionBit, "51")
+      .config(core::QueryConfig::kSpillNumPartitionBits, "3")
+      .checkSpillStats(false)
+      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+        if (!hasSpill) {
+          return;
+        }
+        ASSERT_EQ(maxHashBuildSpillLevel(*task), 3);
+      })
+      .run();
+}
+
+// Verify that dynamic filter pushed down is turned off for null-aware right
+// semi project join.
+TEST_F(HashJoinTest, nullAwareRightSemiProjectOverScan) {
+  std::vector<RowVectorPtr> probes;
+  std::vector<RowVectorPtr> builds;
+  // Matches present:
+  probes.push_back(makeRowVector(
+      {"t0"},
+      {
+          makeNullableFlatVector<int32_t>({1, std::nullopt, 2}),
+      }));
+  builds.push_back(makeRowVector(
+      {"u0"},
+      {
+          makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+      }));
+
+  // No matches present:
+  probes.push_back(makeRowVector(
+      {"t0"},
+      {
+          makeFlatVector<int32_t>({5, 6}),
+      }));
+  builds.push_back(makeRowVector(
+      {"u0"},
+      {
+          makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+      }));
+
+  for (int i = 0; i < probes.size(); i++) {
+    RowVectorPtr& probe = probes[i];
+    RowVectorPtr& build = builds[i];
+    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()))}},
+    };
+
+    // right semi project not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .planNode(plan)
+            .inputSplits(splitInput)
+            .checkSpillStats(false)
+            .referenceQuery("SELECT u0, u0 IN (SELECT t0 FROM t) FROM u")
+            .run(),
+        "Replacement with cuDF operator failed");
+  }
+}
+
+TEST_F(HashJoinTest, duplicateJoinKeys) {
+  auto leftVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeNullableFlatVector<int64_t>(
+            {1, 2, 2, 3, 3, std::nullopt, 4, 5, 5, 6, 7}),
+        makeNullableFlatVector<int64_t>(
+            {1, 2, 2, std::nullopt, 3, 3, 4, 5, 5, 6, 8}),
+    });
+  });
+
+  auto rightVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeNullableFlatVector<int64_t>({1, 1, 3, 4, std::nullopt, 5, 7, 8}),
+        makeNullableFlatVector<int64_t>({1, 1, 3, 4, 5, std::nullopt, 7, 8}),
+    });
+  });
+
+  createDuckDbTable("t", leftVectors);
+  createDuckDbTable("u", rightVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto assertPlan = [&](const std::vector<std::string>& leftProject,
+                        const std::vector<std::string>& leftKeys,
+                        const std::vector<std::string>& rightProject,
+                        const std::vector<std::string>& rightKeys,
+                        const std::vector<std::string>& outputLayout,
+                        core::JoinType joinType,
+                        bool throwType,
+                        const std::string& query) {
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(leftVectors)
+                    .project(leftProject)
+                    .hashJoin(
+                        leftKeys,
+                        rightKeys,
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(rightVectors)
+                            .project(rightProject)
+                            .planNode(),
+                        "",
+                        outputLayout,
+                        joinType)
+                    .planNode();
+    if (throwType) {
+      VELOX_ASSERT_THROW(
+          HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+              .planNode(plan)
+              .injectSpill(false)
+              .checkSpillStats(false)
+              .referenceQuery(query)
+              .run(),
+          "Replacement with cuDF operator failed");
+    } else {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(plan)
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(query)
+          .run();
+    }
+  };
+
+  std::vector<std::pair<core::JoinType, std::string>> joins = {
+      {core::JoinType::kInner, "INNER JOIN"},
+      {core::JoinType::kLeft, "LEFT JOIN"},
+      {core::JoinType::kRight, "RIGHT JOIN"}};
+
+  // full outer join not supported
+  std::vector<std::pair<core::JoinType, std::string>> throwingJoins = {
+      {core::JoinType::kFull, "FULL OUTER JOIN"}};
+
+  for (const auto& [joinType, joinTypeSql] : joins) {
+    // Duplicate keys on the build side.
+    assertPlan(
+        {"c0 AS t0", "c1 as t1"}, // leftProject
+        {"t0", "t1"}, // leftKeys
+        {"c0 AS u0"}, // rightProject
+        {"u0", "u0"}, // rightKeys
+        {"t0", "t1", "u0"}, // outputLayout
+        joinType,
+        false,
+        "SELECT t.c0, t.c1, u.c0 FROM t " + joinTypeSql +
+            " u ON t.c0 = u.c0 and t.c1 = u.c0");
+  }
+
+  for (const auto& [joinType, joinTypeSql] : joins) {
+    // Duplicated keys on the probe side.
+    assertPlan(
+        {"c0 AS t0"}, // leftProject
+        {"t0", "t0"}, // leftKeys
+        {"c0 AS u0", "c1 AS u1"}, // rightProject
+        {"u0", "u1"}, // rightKeys
+        {"t0", "u0", "u1"}, // outputLayout
+        joinType,
+        false,
+        "SELECT t.c0, u.c0, u.c1 FROM t " + joinTypeSql +
+            " u ON t.c0 = u.c0 and t.c0 = u.c1");
+  }
+
+  for (const auto& [joinType, joinTypeSql] : throwingJoins) {
+    // Duplicate keys on the build side.
+    assertPlan(
+        {"c0 AS t0", "c1 as t1"}, // leftProject
+        {"t0", "t1"}, // leftKeys
+        {"c0 AS u0"}, // rightProject
+        {"u0", "u0"}, // rightKeys
+        {"t0", "t1", "u0"}, // outputLayout
+        joinType,
+        true,
+        "SELECT t.c0, t.c1, u.c0 FROM t " + joinTypeSql +
+            " u ON t.c0 = u.c0 and t.c1 = u.c0");
+    assertPlan(
+        {"c0 AS t0"}, // leftProject
+        {"t0", "t0"}, // leftKeys
+        {"c0 AS u0", "c1 AS u1"}, // rightProject
+        {"u0", "u1"}, // rightKeys
+        {"t0", "u0", "u1"}, // outputLayout
+        joinType,
+        true,
+        "SELECT t.c0, u.c0, u.c1 FROM t " + joinTypeSql +
+            " u ON t.c0 = u.c0 and t.c0 = u.c1");
+  }
+}
+
+TEST_F(HashJoinTest, semiProject) {
+  // Some keys have multiple rows: 2, 3, 5.
+  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeFlatVector<int64_t>({1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7}),
+        makeFlatVector<int64_t>({10, 20, 21, 30, 31, 32, 40, 50, 51, 60, 70}),
+    });
+  });
+
+  // Some keys are missing: 2, 6.
+  // Some have multiple rows: 1, 5.
+  // Some keys are not present on probe side: 8.
+  auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector({
+        makeFlatVector<int64_t>({1, 1, 3, 4, 5, 5, 7, 8}),
+        makeFlatVector<int64_t>({100, 101, 300, 400, 500, 501, 700, 800}),
+    });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t0", "t1", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // With extra filter.
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  plan = PlanBuilder(planNodeIdGenerator)
+             .values(probeVectors)
+             .project({"c0 AS t0", "c1 AS t1"})
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator)
+                     .values(buildVectors)
+                     .project({"c0 AS u0", "c1 AS u1"})
+                     .planNode(),
+                 "t1 * 10 <> u1",
+                 {"t0", "t1", "match"},
+                 core::JoinType::kLeftSemiProject)
+             .planNode();
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE t.c0 = u.c0 AND t.c1 * 10 <> u.c1) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // Empty build side.
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  plan = PlanBuilder(planNodeIdGenerator)
+             .values(probeVectors)
+             .project({"c0 AS t0", "c1 AS t1"})
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator)
+                     .values(buildVectors)
+                     .project({"c0 AS u0", "c1 AS u1"})
+                     .filter("u0 < 0")
+                     .planNode(),
+                 "",
+                 {"t0", "t1", "match"},
+                 core::JoinType::kLeftSemiProject)
+             .planNode();
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE u.c0 < 0 AND t.c0 = u.c0) FROM t")
+          // NOTE:, there is no spilling in empty build test case as all the
+          // build-side rows have been filtered out.
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t.c0, t.c1, EXISTS (SELECT * FROM u WHERE u.c0 < 0 AND t.c0 = u.c0) FROM t")
+          // NOTE: there is no spilling in empty build test case as all the
+          // build-side rows have been filtered out.
+          .checkSpillStats(false)
+          .run(),
+      "Replacement with cuDF operator failed");
+}
+
+TEST_F(HashJoinTest, semiProjectWithNullKeys) {
+  // Some keys have multiple rows: 2, 3, 5.
+  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int64_t>(
+                {1, 2, 2, 3, 3, 3, 4, std::nullopt, 5, 5, 6, 7}),
+            makeFlatVector<int64_t>(
+                {10, 20, 21, 30, 31, 32, 40, -1, 50, 51, 60, 70}),
+        });
+  });
+
+  // Some keys are missing: 2, 6.
+  // Some have multiple rows: 1, 5.
+  // Some keys are not present on probe side: 8.
+  auto buildVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int64_t>(
+                {1, 1, 3, 4, std::nullopt, 5, 5, 7, 8}),
+            makeFlatVector<int64_t>(
+                {100, 101, 300, 400, -100, 500, 501, 700, 800}),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto makePlan = [&](bool nullAware,
+                      const std::string& probeFilter = "",
+                      const std::string& buildFilter = "") {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values(probeVectors)
+        .optionalFilter(probeFilter)
+        .hashJoin(
+            {"t0"},
+            {"u0"},
+            PlanBuilder(planNodeIdGenerator)
+                .values(buildVectors)
+                .optionalFilter(buildFilter)
+                .planNode(),
+            "",
+            {"t0", "t1", "match"},
+            core::JoinType::kLeftSemiProject,
+            nullAware)
+        .planNode();
+  };
+
+  // Null join keys on both sides.
+  auto plan = makePlan(false /*nullAware*/);
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  plan = makePlan(true /*nullAware*/);
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // Null join keys on build side-only.
+  plan = makePlan(false /*nullAware*/, "t0 IS NOT NULL");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0) FROM t WHERE t0 IS NOT NULL")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  plan = makePlan(true /*nullAware*/, "t0 IS NOT NULL");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t WHERE t0 IS NOT NULL")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // Null join keys on probe side-only.
+  plan = makePlan(false /*nullAware*/, "", "u0 IS NOT NULL");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NOT NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  plan = makePlan(true /*nullAware*/, "", "u0 IS NOT NULL");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(plan)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .planNode(flipJoinSides(plan))
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NOT NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // Empty build side.
+  plan = makePlan(false /*nullAware*/, "", "u0 < 0");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(plan)
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(flipJoinSides(plan))
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 < 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  plan = makePlan(true /*nullAware*/, "", "u0 < 0");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(plan)
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(flipJoinSides(plan))
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 < 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // Build side with all rows having null join keys.
+  plan = makePlan(false /*nullAware*/, "", "u0 IS NULL");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(plan)
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(flipJoinSides(plan))
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, EXISTS (SELECT * FROM u WHERE u0 = t0 AND u0 IS NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  plan = makePlan(true /*nullAware*/, "", "u0 IS NULL");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(plan)
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, executor_.get())
+          .planNode(flipJoinSides(plan))
+          .injectSpill(false)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE u0 IS NULL) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+}
+
+TEST_F(HashJoinTest, semiProjectWithFilter) {
+  auto probeVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt, 5}),
+            makeFlatVector<int64_t>({10, 20, 30, 40, 50}),
+        });
+  });
+
+  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeNullableFlatVector<int32_t>({1, 2, 3, std::nullopt}),
+            makeFlatVector<int64_t>({11, 22, 33, 44}),
+        });
+  });
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto makePlan = [&](bool nullAware, const std::string& filter) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    return PlanBuilder(planNodeIdGenerator)
+        .values(probeVectors)
+        .hashJoin(
+            {"t0"},
+            {"u0"},
+            PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+            filter,
+            {"t0", "t1", "match"},
+            core::JoinType::kLeftSemiProject,
+            nullAware)
+        .planNode();
+  };
+
+  std::vector<std::string> filters = {
+      "t1 <> u1",
+      "t1 < u1",
+      "t1 > u1",
+      "t1 is not null AND u1 is not null",
+      "t1 is null OR u1 is null",
+  };
+  for (const auto& filter : filters) {
+    auto plan = makePlan(true /*nullAware*/, filter);
+
+    // left semi project not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .planNode(plan)
+            .referenceQuery(
+                fmt::format(
+                    "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t",
+                    filter))
+            .injectSpill(false)
+            .run(),
+        "Replacement with cuDF operator failed");
+
+    plan = makePlan(false /*nullAware*/, filter);
+
+    // DuckDB Exists operator returns NULL when u0 or t0 is NULL. We exclude
+    // these values.
+    // left semi project not supported
+    VELOX_ASSERT_THROW(
+        HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+            .planNode(plan)
+            .referenceQuery(
+                fmt::format(
+                    "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(),
+        "Replacement with cuDF operator failed");
+  }
+}
+
+TEST_F(HashJoinTest, nullAwareRightSemiProjectWithFilterNotAllowed) {
+  auto probe = makeRowVector(ROW({"t0", "t1"}, {INTEGER(), BIGINT()}), 10);
+  auto build = makeRowVector(ROW({"u0", "u1"}, {INTEGER(), BIGINT()}), 10);
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  VELOX_ASSERT_THROW(
+      PlanBuilder(planNodeIdGenerator)
+          .values({probe})
+          .hashJoin(
+              {"t0"},
+              {"u0"},
+              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+              "t1 > u1",
+              {"u0", "u1", "match"},
+              core::JoinType::kRightSemiProject,
+              true /* nullAware */),
+      "Null-aware right semi project join doesn't support extra filter");
+}
+
+TEST_F(HashJoinTest, leftSemiJoinWithExtraOutputCapacity) {
+  std::vector<RowVectorPtr> probeVectors;
+  std::vector<RowVectorPtr> buildVectors;
+  probeVectors.push_back(makeRowVector(
+      {"t0", "t1"},
+      {
+          makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6}),
+          makeFlatVector<int64_t>({10, 10, 10, 10, 10, 10}),
+      }));
+
+  buildVectors.push_back(makeRowVector(
+      {"u0", "u1"},
+      {
+          makeFlatVector<int32_t>({1, 1, 1, 1, 1}),
+          makeFlatVector<int64_t>({10, 10, 10, 10, 10}),
+      }));
+  buildVectors.push_back(makeRowVector(
+      {"u0", "u1"},
+      {
+          makeFlatVector<int32_t>({2, 3, 4, 5, 6}),
+          makeFlatVector<int64_t>({10, 10, 10, 10, 10}),
+      }));
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+  auto runQuery = [&](const std::string& query,
+                      const std::string& filter,
+                      core::JoinType joinType,
+                      bool throwType) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    std::vector<std::string> outputLayout = {"t0", "t1"};
+    if (joinType == core::JoinType::kLeftSemiProject) {
+      outputLayout.push_back("match");
+    }
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors)
+                    .hashJoin(
+                        {"t0"},
+                        {"u0"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors)
+                            .planNode(),
+                        filter,
+                        outputLayout,
+                        joinType,
+                        false)
+                    .planNode();
+    if (throwType) {
+      VELOX_ASSERT_RUNTIME_THROW(
+          HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+              .planNode(plan)
+              .config(core::QueryConfig::kPreferredOutputBatchRows, "5")
+              .referenceQuery(query)
+              .injectSpill(false)
+              .run(),
+          "Replacement with cuDF operator failed");
+    } else {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(plan)
+          .config(core::QueryConfig::kPreferredOutputBatchRows, "5")
+          .referenceQuery(query)
+          .injectSpill(false)
+          .run();
+    }
+  };
+  {
+    SCOPED_TRACE("left semi filter join");
+    std::string filter = "t1 = u1";
+    runQuery(
+        fmt::format(
+            "SELECT t0, t1 FROM t WHERE EXISTS (SELECT u0 FROM u WHERE t0 = u0 AND {})",
+            filter),
+        filter,
+        core::JoinType::kLeftSemiFilter,
+        false);
+  }
+
+  {
+    SCOPED_TRACE("left semi project join");
+    std::string filter = "t1 <> u1";
+    runQuery(
+        fmt::format(
+            "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE {}) FROM t", filter),
+        filter,
+        core::JoinType::kLeftSemiProject,
+        true);
+  }
+}
+
+TEST_F(HashJoinTest, nullAwareMultiKeyNotAllowed) {
+  auto probe = makeRowVector(
+      ROW({"t0", "t1", "t2"}, {INTEGER(), BIGINT(), VARCHAR()}), 10);
+  auto build = makeRowVector(
+      ROW({"u0", "u1", "u2"}, {INTEGER(), BIGINT(), VARCHAR()}), 10);
+
+  // Null-aware left semi project join.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  VELOX_ASSERT_THROW(
+      PlanBuilder(planNodeIdGenerator)
+          .values({probe})
+          .hashJoin(
+              {"t0", "t1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+              "",
+              {"t0", "t1", "match"},
+              core::JoinType::kLeftSemiProject,
+              true /* nullAware */),
+      "Null-aware joins allow only one join key");
+
+  // Null-aware right semi project join.
+  VELOX_ASSERT_THROW(
+      PlanBuilder(planNodeIdGenerator)
+          .values({probe})
+          .hashJoin(
+              {"t0", "t1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+              "",
+              {"u0", "u1", "match"},
+              core::JoinType::kRightSemiProject,
+              true /* nullAware */),
+      "Null-aware joins allow only one join key");
+
+  // Null-aware anti join.
+  VELOX_ASSERT_THROW(
+      PlanBuilder(planNodeIdGenerator)
+          .values({probe})
+          .hashJoin(
+              {"t0", "t1"},
+              {"u0", "u1"},
+              PlanBuilder(planNodeIdGenerator).values({build}).planNode(),
+              "",
+              {"t0", "t1"},
+              core::JoinType::kAnti,
+              true /* nullAware */),
+      "Null-aware joins allow only one join key");
+}
+
+TEST_F(HashJoinTest, semiProjectOverLazyVectors) {
+  auto probeVectors = makeBatches(1, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"t0", "t1"},
+        {
+            makeFlatVector<int32_t>(1'000, [](auto row) { return row; }),
+            makeFlatVector<int64_t>(1'000, [](auto row) { return row * 10; }),
+        });
+  });
+
+  auto buildVectors = makeBatches(3, [&](auto /*unused*/) {
+    return makeRowVector(
+        {"u0", "u1"},
+        {
+            makeFlatVector<int32_t>(
+                1'000, [](auto row) { return -100 + (row / 5); }),
+            makeFlatVector<int64_t>(
+                1'000, [](auto row) { return -1000 + (row / 5) * 10; }),
+        });
+  });
+
+  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);
+
+  core::PlanNodeId probeScanId;
+  core::PlanNodeId buildScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(asRowType(probeVectors[0]->type()))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(asRowType(buildVectors[0]->type()))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      "",
+                      {"t0", "t1", "match"},
+                      core::JoinType::kLeftSemiProject)
+                  .planNode();
+
+  SplitInput splitInput = {
+      {probeScanId,
+       {exec::Split(makeHiveConnectorSplit(probeFile->getPath()))}},
+      {buildScanId,
+       {exec::Split(makeHiveConnectorSplit(buildFile->getPath()))}},
+  };
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(plan)
+          .inputSplits(splitInput)
+          .checkSpillStats(false)
+          .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(flipJoinSides(plan))
+          .inputSplits(splitInput)
+          .checkSpillStats(false)
+          .referenceQuery("SELECT t0, t1, t0 IN (SELECT u0 FROM u) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // With extra filter.
+  planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  plan = PlanBuilder(planNodeIdGenerator)
+             .tableScan(asRowType(probeVectors[0]->type()))
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"t0"},
+                 {"u0"},
+                 PlanBuilder(planNodeIdGenerator)
+                     .tableScan(asRowType(buildVectors[0]->type()))
+                     .capturePlanNodeId(buildScanId)
+                     .planNode(),
+                 "(t1 + u1) % 3 = 0",
+                 {"t0", "t1", "match"},
+                 core::JoinType::kLeftSemiProject)
+             .planNode();
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(plan)
+          .inputSplits(splitInput)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+
+  // right semi project not supported
+  VELOX_ASSERT_THROW(
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(flipJoinSides(plan))
+          .inputSplits(splitInput)
+          .checkSpillStats(false)
+          .referenceQuery(
+              "SELECT t0, t1, t0 IN (SELECT u0 FROM u WHERE (t1 + u1) % 3 = 0) FROM t")
+          .run(),
+      "Replacement with cuDF operator failed");
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    HashJoinTest,
+    MultiThreadedHashJoinTest,
+    testing::ValuesIn(MultiThreadedHashJoinTest::getTestParams()));
+
+// TODO: try to parallelize the following test cases if possible.
+TEST_F(HashJoinTest, memory) {
+  // Measures memory allocation in a 1:n hash join followed by
+  // projection and aggregation. We expect vectors to be mostly
+  // reused, except for t_k0 + 1, which is a dictionary after the
+  // join.
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return std::dynamic_pointer_cast<RowVector>(
+            BatchMaker::createBatch(probeType_, 1000, *pool_));
+      });
+
+  // auto buildType = makeRowType(keyTypes, "u_");
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return std::dynamic_pointer_cast<RowVector>(
+            BatchMaker::createBatch(buildType_, 1000, *pool_));
+      });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values(probeVectors, true)
+                        .hashJoin(
+                            {"t_k1"},
+                            {"u_k1"},
+                            PlanBuilder(planNodeIdGenerator)
+                                .values(buildVectors, true)
+                                .planNode(),
+                            "",
+                            concat(probeType_->names(), buildType_->names()))
+                        .project({"t_k1 % 1000 AS k1", "u_k1 % 1000 AS k2"})
+                        .singleAggregation({}, {"sum(k1)", "sum(k2)"})
+                        .planNode();
+  params.queryCtx = core::QueryCtx::create(driverExecutor_.get());
+  auto [taskCursor, rows] = readCursor(params);
+  EXPECT_GT(3'500, params.queryCtx->pool()->stats().numAllocs);
+  EXPECT_GT(40'000'000, params.queryCtx->pool()->stats().cumulativeBytes);
+}
+
+TEST_F(HashJoinTest, DISABLED_lazyVectors) {
+  // a dataset of multiple row groups with multiple columns. We create
+  // different dictionary wrappings for different columns and load the
+  // rows in scope at different times.
+  auto probeVectors = makeBatches(3, [&](int32_t /*unused*/) {
+    return makeRowVector(
+        {makeFlatVector<int32_t>(3'000, [](auto row) { return row; }),
+         makeFlatVector<int64_t>(30'000, [](auto row) { return row % 23; }),
+         makeFlatVector<int32_t>(30'000, [](auto row) { return row % 31; }),
+         makeFlatVector<StringView>(30'000, [](auto row) {
+           return StringView::makeInline(fmt::format("{}   string", row % 43));
+         })});
+  });
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(4, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {makeFlatVector<int32_t>(1'000, [](auto row) { return row * 3; }),
+             makeFlatVector<int64_t>(
+                 10'000, [](auto row) { return row % 31; })});
+      });
+
+  std::vector<std::shared_ptr<TempFilePath>> tempFiles;
+
+  for (const auto& probeVector : probeVectors) {
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), probeVector);
+  }
+  createDuckDbTable("t", probeVectors);
+
+  for (const auto& buildVector : buildVectors) {
+    tempFiles.push_back(TempFilePath::create());
+    writeToFile(tempFiles.back()->getPath(), buildVector);
+  }
+  createDuckDbTable("u", buildVectors);
+
+  auto makeInputSplits = [&](const core::PlanNodeId& probeScanId,
+                             const core::PlanNodeId& buildScanId) {
+    return [&] {
+      std::vector<exec::Split> probeSplits;
+      for (int i = 0; i < probeVectors.size(); ++i) {
+        probeSplits.push_back(
+            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]->getPath())));
+      }
+      SplitInput splits;
+      splits.emplace(probeScanId, probeSplits);
+      splits.emplace(buildScanId, buildSplits);
+      return splits;
+    };
+  };
+
+  {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    auto op = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(ROW({"c0", "c1"}, {INTEGER(), BIGINT()}))
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"c0"},
+                      {"c0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(ROW({"c0"}, {INTEGER()}))
+                          .capturePlanNodeId(buildScanId)
+                          .planNode(),
+                      "",
+                      {"c1"})
+                  .project({"c1 + 1"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .checkSpillStats(false)
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId, buildScanId))
+        .referenceQuery("SELECT t.c1 + 1 FROM t, u WHERE t.c0 = u.c0")
+        .run();
+  }
+
+  {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    auto op = PlanBuilder(planNodeIdGenerator)
+                  .tableScan(
+                      ROW({"c0", "c1", "c2", "c3"},
+                          {INTEGER(), BIGINT(), INTEGER(), VARCHAR()}))
+                  .capturePlanNodeId(probeScanId)
+                  .filter("c2 < 29")
+                  .hashJoin(
+                      {"c0"},
+                      {"bc0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .tableScan(ROW({"c0", "c1"}, {INTEGER(), BIGINT()}))
+                          .capturePlanNodeId(buildScanId)
+                          .project({"c0 as bc0", "c1 as bc1"})
+                          .planNode(),
+                      "(c1 + bc1) % 33 < 27",
+                      {"c1", "bc1", "c3"})
+                  .project({"c1 + 1", "bc1", "length(c3)"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .injectSpill(false)
+        .checkSpillStats(false)
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId, buildScanId))
+        .referenceQuery(
+            "SELECT t.c1 + 1, U.c1, length(t.c3) FROM t, u WHERE t.c0 = u.c0 and t.c2 < 29 and (t.c1 + u.c1) % 33 < 27")
+        .run();
+  }
+}
+
+TEST_F(HashJoinTest, DISABLED_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, DISABLED_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, DISABLED_lazyVectorPartiallyLoadedInFilterFullJoin) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  // full join not supported
+  VELOX_ASSERT_THROW(
+      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)"),
+      "Replacement with cuDF operator failed");
+}
+
+TEST_F(
+    HashJoinTest,
+    DISABLED_lazyVectorPartiallyLoadedInFilterLeftSemiProject) {
+  // Test the case where a filter loads a subset of the rows that will be output
+  // from a column on the probe side.
+
+  // left semi project not supported
+  VELOX_ASSERT_THROW(
+      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"),
+      "Replacement with cuDF operator failed");
+}
+
+TEST_F(HashJoinTest, DISABLED_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, DISABLED_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, DISABLED_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))");
+}
+
+// Disabled because dynamic filters are not supported yet in velox-cudf.
+TEST_F(HashJoinTest, DISABLED_dynamicFilters) {
+  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();
+  auto keyOnlyBuildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                              .values(keyOnlyBuildVectors)
+                              .project({"c0 AS u_c0"})
+                              .planNode();
+
+  // Basic push-down.
+  {
+    SCOPED_TRACE("Inner join");
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .tableScan(probeType)
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      buildSide,
+                      "",
+                      {"c0", "c1", "u_c1"},
+                      core::JoinType::kInner)
+                  .capturePlanNodeId(joinId)
+                  .project({"c0", "c1 + 1", "c1 + u_c1"})
+                  .planNode();
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .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 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();
+    }
+
+    // Left semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType)
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"c0", "c1"},
+                 core::JoinType::kLeftSemiFilter)
+             .capturePlanNodeId(joinId)
+             .project({"c0", "c1 + 1"})
+             .planNode();
+
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .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 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();
+    }
+
+    // Right semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType)
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"u_c0", "u_c1"},
+                 core::JoinType::kRightSemiFilter)
+             .capturePlanNodeId(joinId)
+             .project({"u_c0", "u_c1 + 1"})
+             .planNode();
+
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "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();
+    }
+
+    // Right join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType)
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"c0", "c1", "u_c1"},
+                 core::JoinType::kRight)
+             .capturePlanNodeId(joinId)
+             .project({"c0", "c1 + 1", "c1 + u_c1"})
+             .planNode();
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t RIGHT 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(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();
+    }
+  }
+
+  // Basic push-down with column names projected out of the table scan
+  // having different names than column names in the files.
+  {
+    SCOPED_TRACE("Inner join column rename");
+    auto scanOutputType = ROW({"a", "b"}, {INTEGER(), BIGINT()});
+    connector::ColumnHandleMap assignments;
+    assignments["a"] = regularColumn("c0", INTEGER());
+    assignments["b"] = regularColumn("c1", BIGINT());
+
+    core::PlanNodeId probeScanId;
+    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))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .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 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();
+  }
+
+  // Push-down that requires merging filters.
+  {
+    SCOPED_TRACE("Merge 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();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .referenceQuery(
+            "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();
+  }
+
+  // Push-down that turns join into a no-op.
+  {
+    SCOPED_TRACE("canReplaceWithDynamicFilter");
+    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();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .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);
+            ASSERT_EQ(
+                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();
+  }
+
+  // Push-down that turns join into a no-op with output having a different
+  // number of columns than the input.
+  {
+    SCOPED_TRACE("canReplaceWithDynamicFilter column rename");
+    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())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .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);
+            ASSERT_EQ(
+                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();
+  }
+
+  // Push-down that requires merging filters and turns join into a no-op.
+  {
+    SCOPED_TRACE("canReplaceWithDynamicFilter merge filters");
+    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();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .makeInputSplits(makeInputSplits(probeScanId))
+        .referenceQuery(
+            "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();
+  }
+
+  // Push-down with highly selective filter in the scan.
+  {
+    SCOPED_TRACE("Highly selective filter");
+    // 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();
+
+    {
+      SCOPED_TRACE("Inner join");
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "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();
+    }
+
+    // Left semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType, {"c0 < 200::INTEGER"})
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"c1"},
+                 core::JoinType::kLeftSemiFilter)
+             .capturePlanNodeId(joinId)
+             .project({"c1 + 1"})
+             .planNode();
+
+    {
+      SCOPED_TRACE("Left semi join");
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "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();
+    }
+
+    // Right semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType, {"c0 < 200::INTEGER"})
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"u_c1"},
+                 core::JoinType::kRightSemiFilter)
+             .capturePlanNodeId(joinId)
+             .project({"u_c1 + 1"})
+             .planNode();
+
+    {
+      SCOPED_TRACE("Right semi join");
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "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();
+    }
+
+    // Right join.
+    op =
+        PlanBuilder(planNodeIdGenerator, pool_.get())
+            .tableScan(probeType, {"c0 < 200::INTEGER"})
+            .capturePlanNodeId(probeScanId)
+            .hashJoin(
+                {"c0"}, {"u_c0"}, buildSide, "", {"c1"}, core::JoinType::kRight)
+            .capturePlanNodeId(joinId)
+            .project({"c1 + 1"})
+            .planNode();
+
+    {
+      SCOPED_TRACE("Right join");
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c1 + 1 FROM (SELECT * FROM t WHERE t.c0 < 200) t RIGHT 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(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();
+    }
+  }
+
+  // Disable filter push-down by using values in place of scan.
+  {
+    SCOPED_TRACE("Disabled in case of values node");
+    core::PlanNodeId joinId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .values(probeVectors)
+                  .hashJoin({"c0"}, {"u_c0"}, buildSide, "", {"c1"})
+                  .capturePlanNodeId(joinId)
+                  .project({"c1 + 1"})
+                  .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .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));
+        })
+        .run();
+  }
+
+  // Disable filter push-down by using an expression as the join key on the
+  // probe side.
+  {
+    SCOPED_TRACE("Disabled in case of join condition");
+    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();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(std::move(op))
+        .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, DISABLED_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, DISABLED_dynamicFiltersWithSkippedSplits) {
+  const int32_t numSplits = 20;
+  const int32_t numNonSkippedSplits = 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;
+  // Each split has a column containing
+  // the split number. This is used to filter out whole splits based
+  // on metadata. We test how using metadata for dropping splits
+  // interactts with dynamic filters. In specific, if the first split
+  // is discarded based on metadata, the dynamic filters must not be
+  // lost even if there is no actual reader for the split.
+  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; }),
+        makeFlatVector<int64_t>(
+            numRowsProbe, [&](auto /*row*/) { return i % 2 == 0 ? 0 : i; }),
+    });
+    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())));
+      }
+      // We add splits that have no rows.
+      auto makeEmpty = [&]() {
+        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()};
+      probeSplits.insert(
+          probeSplits.begin(), emptyFront.begin(), emptyFront.end());
+      probeSplits.insert(
+          probeSplits.begin() + 13, emptyMiddle.begin(), emptyMiddle.end());
+      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", "c2"}, {INTEGER(), BIGINT(), 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();
+  auto keyOnlyBuildSide = PlanBuilder(planNodeIdGenerator, pool_.get())
+                              .values(keyOnlyBuildVectors)
+                              .project({"c0 AS u_c0"})
+                              .planNode();
+
+  // Basic push-down.
+  {
+    // Inner join.
+    core::PlanNodeId probeScanId;
+    auto op = PlanBuilder(planNodeIdGenerator, pool_.get())
+                  .tableScan(probeType, {"c2 > 0"})
+                  .capturePlanNodeId(probeScanId)
+                  .hashJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      buildSide,
+                      "",
+                      {"c0", "c1", "u_c1"},
+                      core::JoinType::kInner)
+                  .project({"c0", "c1 + 1", "c1 + u_c1"})
+                  .planNode();
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c0, t.c1 + 1, t.c1 + u.c1 FROM t, u WHERE t.c0 = u.c0 AND t.c2 > 0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            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 * numNonSkippedSplits);
+            } 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 * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+
+    // Left semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType, {"c2 > 0"})
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"c0", "c1"},
+                 core::JoinType::kLeftSemiFilter)
+             .project({"c0", "c1 + 1"})
+             .planNode();
+
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT t.c0, t.c1 + 1 FROM t WHERE t.c0 IN (SELECT c0 FROM u) AND t.c2 > 0")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            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 * numNonSkippedSplits);
+            } 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 * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+
+    // Right semi join.
+    op = PlanBuilder(planNodeIdGenerator, pool_.get())
+             .tableScan(probeType, {"c2 > 0"})
+             .capturePlanNodeId(probeScanId)
+             .hashJoin(
+                 {"c0"},
+                 {"u_c0"},
+                 buildSide,
+                 "",
+                 {"u_c0", "u_c1"},
+                 core::JoinType::kRightSemiFilter)
+             .project({"u_c0", "u_c1 + 1"})
+             .planNode();
+
+    {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .planNode(std::move(op))
+          .numDrivers(1)
+          .makeInputSplits(makeInputSplits(probeScanId))
+          .referenceQuery(
+              "SELECT u.c0, u.c1 + 1 FROM u WHERE u.c0 IN (SELECT c0 FROM t WHERE t.c2 > 0)")
+          .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+            SCOPED_TRACE(fmt::format("hasSpill:{}", hasSpill));
+            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 * numNonSkippedSplits);
+            } 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 * numNonSkippedSplits);
+            }
+          })
+          .run();
+    }
+  }
+}
+
+TEST_F(HashJoinTest, DISABLED_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()});
+  connector::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, DISABLED_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();
+}
+
+TEST_F(HashJoinTest, DISABLED_noDynamicFiltersPushDownThroughRightJoin) {
+  std::vector<RowVectorPtr> innerBuild = {makeRowVector(
+      {"a"},
+      {
+          makeFlatVector<int64_t>(5, [](auto i) { return 2 * i; }),
+      })};
+  std::vector<RowVectorPtr> rightBuild = {makeRowVector(
+      {"b"},
+      {
+          makeFlatVector<int64_t>(5, [](auto i) { return 1 + 2 * i; }),
+      })};
+  std::vector<RowVectorPtr> rightProbe = {makeRowVector(
+      {"aa", "bb"},
+      {
+          makeFlatVector<int64_t>(10, folly::identity),
+          makeFlatVector<int64_t>(10, folly::identity),
+      })};
+  auto file = TempFilePath::create();
+  writeToFile(file->getPath(), rightProbe);
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId scanNodeId;
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(asRowType(rightProbe[0]->type()))
+          .capturePlanNodeId(scanNodeId)
+          .hashJoin(
+              {"bb"},
+              {"b"},
+              PlanBuilder(planNodeIdGenerator).values(rightBuild).planNode(),
+              "",
+              {"aa", "b"},
+              core::JoinType::kRight)
+          .hashJoin(
+              {"aa"},
+              {"a"},
+              PlanBuilder(planNodeIdGenerator).values(innerBuild).planNode(),
+              "",
+              {"aa"})
+          .planNode();
+  AssertQueryBuilder(plan)
+      .split(scanNodeId, Split(makeHiveConnectorSplit(file->getPath())))
+      .assertResults(
+          BaseVector::create<RowVector>(innerBuild[0]->type(), 0, pool_.get()));
+}
+
+// Verify the size of the join output vectors when projecting build-side
+// variable-width column.
+TEST_F(HashJoinTest, memoryUsage) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {makeFlatVector<int32_t>(1'000, [](auto row) { return row % 5; })});
+      });
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(5, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"u_c0", "u_c1"},
+            {makeFlatVector<int32_t>({0, 1, 2}),
+             makeFlatVector<std::string>({
+                 std::string(40, 'a'),
+                 std::string(50, 'b'),
+                 std::string(30, 'c'),
+             })});
+      });
+  core::PlanNodeId joinNodeId;
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(probeVectors)
+                  .hashJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .planNode(),
+                      "",
+                      {"c0", "u_c1"})
+                  .capturePlanNodeId(joinNodeId)
+                  .singleAggregation({}, {"count(1)"})
+                  .planNode();
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .injectSpill(false)
+      .planNode(std::move(plan))
+      .referenceQuery("SELECT 30000")
+      .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+        if (hasSpill) {
+          return;
+        }
+        auto planStats = toPlanStats(task->taskStats());
+        auto outputBytes = planStats.at(joinNodeId).outputBytes;
+        ASSERT_LT(outputBytes, ((40 + 50 + 30) / 3 + 8) * 1000 * 10 * 5);
+        // Verify number of memory allocations. Should not be too high if
+        // hash join is able to re-use output vectors that contain
+        // build-side data.
+        ASSERT_GT(40, task->pool()->stats().numAllocs);
+      })
+      .run();
+}
+
+/// Test an edge case in producing small output batches where the logic to
+/// calculate the set of probe-side rows to load lazy vectors for was
+/// triggering a crash.
+TEST_F(HashJoinTest, smallOutputBatchSize) {
+  // Setup probe data with 50 non-null matching keys followed by 50 null
+  // keys: 1, 2, 1, 2,...null, null.
+  auto probeVectors = makeRowVector({
+      makeFlatVector<int32_t>(
+          100,
+          [](auto row) { return 1 + row % 2; },
+          [](auto row) { return row > 50; }),
+      makeFlatVector<int32_t>(100, [](auto row) { return row * 10; }),
+  });
+
+  // Setup build side to match non-null probe side keys.
+  auto buildVectors = makeRowVector(
+      {"u_c0", "u_c1"},
+      {
+          makeFlatVector<int32_t>({1, 2}),
+          makeFlatVector<int32_t>({100, 200}),
+      });
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  // Plan hash inner join with a filter.
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values({probeVectors})
+                  .hashJoin(
+                      {"c0"},
+                      {"u_c0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values({buildVectors})
+                          .planNode(),
+                      "c1 < u_c1",
+                      {"c0", "u_c1"})
+                  .planNode();
+
+  // Use small output batch size to trigger logic for calculating set of
+  // probe-side rows to load lazy vectors for.
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(plan))
+      .config(core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+      .referenceQuery("SELECT c0, u_c1 FROM t, u WHERE c0 = u_c0 AND c1 < u_c1")
+      .injectSpill(false)
+      .run();
+}
+
+TEST_F(HashJoinTest, DISABLED_spillFileSize) {
+  const std::vector<uint64_t> maxSpillFileSizes({0, 1, 1'000'000'000});
+  for (const auto spillFileSize : maxSpillFileSizes) {
+    SCOPED_TRACE(fmt::format("spillFileSize: {}", spillFileSize));
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .keyTypes({BIGINT()})
+        .probeVectors(100, 3)
+        .buildVectors(100, 3)
+        .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::kSpillNumPartitionBits, "3")
+        .config(
+            core::QueryConfig::kMaxSpillFileSize, std::to_string(spillFileSize))
+        .checkSpillStats(false)
+        .maxSpillLevel(0)
+        .verifier([&](const std::shared_ptr<Task>& task, bool hasSpill) {
+          if (!hasSpill) {
+            return;
+          }
+          const auto statsPair = taskSpilledStats(*task);
+          const int32_t numPartitions = statsPair.first.spilledPartitions;
+          ASSERT_EQ(statsPair.second.spilledPartitions, numPartitions);
+          const auto fileSizes = numTaskSpillFiles(*task);
+          if (spillFileSize != 1) {
+            ASSERT_EQ(fileSizes.first, numPartitions);
+          } else {
+            ASSERT_GT(fileSizes.first, numPartitions);
+          }
+          verifyTaskSpilledRuntimeStats(*task, true);
+        })
+        .run();
+  }
+}
+
+// Spilling is not supported for cudfHashJoin.
+TEST_F(HashJoinTest, DISABLED_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) {
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return std::dynamic_pointer_cast<RowVector>(
+            BatchMaker::createBatch(probeType_, 1000, *pool_));
+      });
+  std::vector<RowVectorPtr> buildVectors = makeBatches(10, [&](int32_t index) {
+    return std::dynamic_pointer_cast<RowVector>(
+        BatchMaker::createBatch(buildType_, 5000 * (1 + index), *pool_));
+  });
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  CursorParameters params;
+  params.planNode = PlanBuilder(planNodeIdGenerator)
+                        .values(probeVectors, true)
+                        .hashJoin(
+                            {"t_k1"},
+                            {"u_k1"},
+                            PlanBuilder(planNodeIdGenerator)
+                                .values(buildVectors, true)
+                                .planNode(),
+                            "",
+                            concat(probeType_->names(), buildType_->names()))
+                        .planNode();
+  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->getPath();
+  params.queryCtx->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kSpillEnabled, "true"},
+       {core::QueryConfig::kMaxSpillLevel, "0"}});
+  params.maxDrivers = 1;
+
+  auto cursor = TaskCursor::create(params);
+  auto* task = cursor->task().get();
+
+  // Set up a testvalue to trigger task abort when hash build tries to reserve
+  // memory.
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+      std::function<void(memory::MemoryPool*)>(
+          [&](memory::MemoryPool* /*unused*/) { task->requestAbort(); }));
+  auto runTask = [&]() {
+    while (cursor->moveNext()) {
+    }
+  };
+  VELOX_ASSERT_THROW(runTask(), "");
+  ASSERT_TRUE(waitForTaskAborted(task, 5'000'000));
+}
+
+TEST_F(HashJoinTest, DISABLED_dynamicFilterOnPartitionKey) {
+  vector_size_t size = 10;
+  auto filePaths = makeFilePaths(1);
+  auto rowVector = makeRowVector(
+      {makeFlatVector<int64_t>(size, [&](auto row) { return row; })});
+  createDuckDbTable("u", {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]->getPath())
+                   .partitionKey("k", "0")
+                   .build();
+  auto outputType = ROW({"n1_0", "n1_1"}, {BIGINT(), BIGINT()});
+  connector::ColumnHandleMap assignments = {
+      {"n1_0", regularColumn("c0", BIGINT())},
+      {"n1_1", partitionKey("k", BIGINT())}};
+
+  core::PlanNodeId probeScanId;
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .startTableScan()
+          .outputType(outputType)
+          .assignments(assignments)
+          .endTableScan()
+          .capturePlanNodeId(probeScanId)
+          .hashJoin(
+              {"n1_1"},
+              {"c0"},
+              PlanBuilder(planNodeIdGenerator).values(buildVectors).planNode(),
+              "",
+              {"c0"},
+              core::JoinType::kInner)
+          .project({"c0"})
+          .planNode();
+  SplitInput splits = {{probeScanId, {exec::Split(split)}}};
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .planNode(std::move(op))
+      .inputSplits(splits)
+      .referenceQuery("select t.c0 from t, u where t.c0 = 0")
+      .checkSpillStats(false)
+      .run();
+}
+
+TEST_F(HashJoinTest, DISABLED_probeMemoryLimitOnBuildProjection) {
+  const uint64_t numBuildRows = 20;
+  std::vector<RowVectorPtr> probeVectors =
+      makeBatches(10, [&](int32_t /*unused*/) {
+        return makeRowVector({makeFlatVector<int32_t>(
+            1'000, [](auto row) { return row % 25; })});
+      });
+
+  std::vector<RowVectorPtr> buildVectors =
+      makeBatches(1, [&](int32_t /*unused*/) {
+        return makeRowVector(
+            {"u_c0", "u_c1", "u_c2", "u_c3", "u_c4"},
+            {makeFlatVector<int32_t>(
+                 numBuildRows, [](auto row) { return row; }),
+             makeFlatVector<std::string>(
+                 numBuildRows,
+                 [](auto /* row */) { return std::string(4096, 'a'); }),
+             makeFlatVector<std::string>(
+                 numBuildRows,
+                 [](auto /* row */) { return std::string(4096, 'a'); }),
+             makeFlatVector<std::string>(
+                 numBuildRows,
+                 [](auto row) {
+                   // Row that has too large of size variation.
+                   if (row == 0) {
+                     return std::string(4096, 'a');
+                   } else {
+                     return std::string(1, 'a');
+                   }
+                 }),
+             makeFlatVector<std::string>(numBuildRows, [](auto row) {
+               // Row that has tolerable size variation.
+               if (row == 0) {
+                 return std::string(4096, 'a');
+               } else {
+                 return std::string(256, 'a');
+               }
+             })});
+      });
+
+  createDuckDbTable("t", {probeVectors});
+  createDuckDbTable("u", {buildVectors});
+
+  struct TestParam {
+    std::vector<int32_t> varSizeColumns;
+    int32_t numExpectedBatches;
+    std::string referenceQuery;
+    std::string debugString() const {
+      std::stringstream ss;
+      ss << "varSizeColumns [";
+      for (const auto& columnIndex : varSizeColumns) {
+        ss << columnIndex << ", ";
+      }
+      ss << "] ";
+      ss << "numExpectedBatches " << numExpectedBatches << ", referenceQuery '"
+         << referenceQuery << "'";
+      return ss.str();
+    }
+  };
+
+  std::vector<TestParam> testParams{
+      {{}, 10, "SELECT t.c0 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {{1}, 4000, "SELECT t.c0, u.u_c1 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {{1, 2},
+       8000,
+       "SELECT t.c0, u.u_c1, u.u_c2 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {{3}, 210, "SELECT t.c0, u.u_c3 FROM t JOIN u ON t.c0 = u.u_c0"},
+      {{4}, 2670, "SELECT t.c0, u.u_c4 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.varSizeColumns.size(); i++) {
+      outputLayout.push_back(fmt::format("u_c{}", testParam.varSizeColumns[i]));
+    }
+    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());
+  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);
+
+  struct {
+    // 0: trigger reclaim with some input processed.
+    // 1: trigger reclaim after all the inputs processed.
+    int triggerCondition;
+    bool spillEnabled;
+    bool expectedReclaimable;
+
+    std::string debugString() const {
+      return fmt::format(
+          "triggerCondition {}, spillEnabled {}, expectedReclaimable {}",
+          triggerCondition,
+          spillEnabled,
+          expectedReclaimable);
+    }
+  } testSettings[] = {
+      {0, true, true}, {0, true, true}, {0, false, false}, {0, false, false}};
+  for (const auto& testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+
+    auto tempDirectory = exec::test::TempDirectoryPath::create();
+    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)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, false)
+                            .planNode(),
+                        "",
+                        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") {
+            return;
+          }
+          op = testOp;
+          ++numInputs;
+          if (testData.triggerCondition == 0) {
+            if (numInputs != 2) {
+              return;
+            }
+          }
+          if (testData.triggerCondition == 1) {
+            if (numInputs != numBuildVectors) {
+              return;
+            }
+          }
+          ASSERT_EQ(op->canReclaim(), testData.expectedReclaimable);
+          uint64_t reclaimableBytes{0};
+          const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+          ASSERT_EQ(reclaimable, testData.expectedReclaimable);
+          if (testData.expectedReclaimable) {
+            ASSERT_GT(reclaimableBytes, 0);
+          } else {
+            ASSERT_EQ(reclaimableBytes, 0);
+          }
+          testWait.notify();
+          driverWait.wait(driverWaitKey);
+        })));
+
+    std::thread taskThread([&]() {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .planNode(plan)
+          .queryPool(std::move(queryPool))
+          .injectSpill(false)
+          .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, 8);
+              ASSERT_GT(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 8);
+              verifyTaskSpilledRuntimeStats(*task, true);
+            } else {
+              ASSERT_EQ(statsPair.first.spilledBytes, 0);
+              ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+              ASSERT_EQ(statsPair.second.spilledBytes, 0);
+              ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+              verifyTaskSpilledRuntimeStats(*task, false);
+            }
+          })
+          .run();
+    });
+
+    testWait.wait(testWaitKey);
+    ASSERT_TRUE(op != nullptr);
+    auto task = op->operatorCtx()->task();
+    auto taskPauseWait = task->requestPause();
+    driverWait.notify();
+    taskPauseWait.wait();
+
+    uint64_t reclaimableBytes{0};
+    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+    ASSERT_EQ(op->canReclaim(), testData.expectedReclaimable);
+    ASSERT_EQ(reclaimable, testData.expectedReclaimable);
+    if (testData.expectedReclaimable) {
+      ASSERT_GT(reclaimableBytes, 0);
+    } else {
+      ASSERT_EQ(reclaimableBytes, 0);
+    }
+
+    if (testData.expectedReclaimable) {
+      {
+        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(
+              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+              reclaimerStats_),
+          "");
+    }
+
+    Task::resume(task);
+    task.reset();
+
+    taskThread.join();
+  }
+  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{});
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringReserve) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  const int32_t numBuildVectors = 3;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    const size_t size = i == 0 ? 1 : 1'000;
+    VectorFuzzer fuzzer({.vectorSize = size}, pool());
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+
+  const int32_t numProbeVectors = 3;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 1'000}, pool());
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
+
+  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();
+
+  folly::EventCount driverWait;
+  std::atomic_bool driverWaitFlag{true};
+  folly::EventCount testWait;
+  std::atomic_bool testWaitFlag{true};
+
+  Operator* op{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>(([&](Operator* testOp) {
+        if (testOp->operatorType() != "HashBuild") {
+          return;
+        }
+        op = testOp;
+      })));
+
+  std::atomic<bool> injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+      std::function<void(memory::MemoryPoolImpl*)>(
+          ([&](memory::MemoryPoolImpl* pool) {
+            ASSERT_TRUE(op != nullptr);
+            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;
+            }
+            uint64_t reclaimableBytes{0};
+            const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+            ASSERT_TRUE(reclaimable);
+            ASSERT_GT(reclaimableBytes, 0);
+            auto* driver = op->operatorCtx()->driver();
+            TestSuspendedSection suspendedSection(driver);
+            testWaitFlag = false;
+            testWait.notifyAll();
+            driverWait.await([&]() { return !driverWaitFlag.load(); });
+          })));
+
+  std::thread taskThread([&]() {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .planNode(plan)
+        .queryPool(std::move(queryPool))
+        .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")
+        .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, 8);
+          ASSERT_GT(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 8);
+          verifyTaskSpilledRuntimeStats(*task, true);
+        })
+        .run();
+  });
+
+  testWait.await([&]() { return !testWaitFlag.load(); });
+  ASSERT_TRUE(op != nullptr);
+  auto task = op->operatorCtx()->task();
+  task->requestPause().wait();
+
+  uint64_t reclaimableBytes{0};
+  const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+  ASSERT_TRUE(op->canReclaim());
+  ASSERT_TRUE(reclaimable);
+  ASSERT_GT(reclaimableBytes, 0);
+
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    uint64_t reclaimedBytes = task->pool()->reclaim(
+        folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+        0,
+        reclaimerStats_);
+    ASSERT_GT(reclaimedBytes, 0);
+  }
+  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();
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringAllocation) {
+  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_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  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::memoryManager()->addRootPool("", kMaxBytes);
+
+    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();
+
+    folly::EventCount driverWait;
+    auto driverWaitKey = driverWait.prepareWait();
+    folly::EventCount testWait;
+    auto testWaitKey = testWait.prepareWait();
+
+    Operator* op;
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* testOp) {
+          if (testOp->operatorType() != "HashBuild") {
+            return;
+          }
+          op = testOp;
+        })));
+
+    std::atomic<bool> injectOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::common::memory::MemoryPoolImpl::allocateNonContiguous",
+        std::function<void(memory::MemoryPoolImpl*)>(
+            ([&](memory::MemoryPoolImpl* pool) {
+              ASSERT_TRUE(op != nullptr);
+              const std::string re(".*HashBuild");
+              if (!RE2::FullMatch(pool->name(), re)) {
+                return;
+              }
+              if (!injectOnce.exchange(false)) {
+                return;
+              }
+              ASSERT_EQ(op->canReclaim(), enableSpilling);
+              uint64_t reclaimableBytes{0};
+              const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+              ASSERT_EQ(reclaimable, enableSpilling);
+              if (enableSpilling) {
+                ASSERT_GE(reclaimableBytes, 0);
+              } else {
+                ASSERT_EQ(reclaimableBytes, 0);
+              }
+              auto* driver = op->operatorCtx()->driver();
+              TestSuspendedSection suspendedSection(driver);
+              testWait.notify();
+              driverWait.wait(driverWaitKey);
+            })));
+
+    std::thread taskThread([&]() {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .planNode(plan)
+          .queryPool(std::move(queryPool))
+          .injectSpill(false)
+          .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*/) {
+            const auto statsPair = taskSpilledStats(*task);
+            ASSERT_EQ(statsPair.first.spilledBytes, 0);
+            ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+            ASSERT_EQ(statsPair.second.spilledBytes, 0);
+            ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+            verifyTaskSpilledRuntimeStats(*task, false);
+          })
+          .run();
+    });
+
+    testWait.wait(testWaitKey);
+    ASSERT_TRUE(op != nullptr);
+    auto task = op->operatorCtx()->task();
+    auto taskPauseWait = task->requestPause();
+    taskPauseWait.wait();
+
+    uint64_t reclaimableBytes{0};
+    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+    ASSERT_EQ(op->canReclaim(), enableSpilling);
+    ASSERT_EQ(reclaimable, enableSpilling);
+    if (enableSpilling) {
+      ASSERT_GE(reclaimableBytes, 0);
+    } else {
+      ASSERT_EQ(reclaimableBytes, 0);
+    }
+    VELOX_ASSERT_THROW(
+        op->reclaim(
+            folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+            reclaimerStats_),
+        "");
+
+    driverWait.notify();
+    Task::resume(task);
+    task.reset();
+
+    taskThread.join();
+  }
+  ASSERT_EQ(reclaimerStats_, memory::MemoryReclaimer::Stats{0});
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringOutputProcessing) {
+  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_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  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::memoryManager()->addRootPool(
+        "", kMaxBytes, memory::MemoryReclaimer::create());
+
+    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 driverWaitFlag{true};
+    folly::EventCount driverWait;
+    std::atomic_bool testWaitFlag{true};
+    folly::EventCount testWait;
+
+    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") {
+            return;
+          }
+          op = testOp;
+          if (!injectOnce.exchange(false)) {
+            return;
+          }
+          ASSERT_EQ(op->canReclaim(), enableSpilling);
+          uint64_t reclaimableBytes{0};
+          const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+          ASSERT_EQ(reclaimable, enableSpilling);
+          if (enableSpilling) {
+            ASSERT_GT(reclaimableBytes, 0);
+          } else {
+            ASSERT_EQ(reclaimableBytes, 0);
+          }
+          testWaitFlag = false;
+          testWait.notifyAll();
+          driverWait.await([&]() { return !driverWaitFlag.load(); });
+        })));
+
+    std::thread taskThread([&]() {
+      HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+          .numDrivers(numDrivers_)
+          .planNode(plan)
+          .queryPool(std::move(queryPool))
+          .injectSpill(false)
+          .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*/) {
+            const auto statsPair = taskSpilledStats(*task);
+            ASSERT_EQ(statsPair.first.spilledBytes, 0);
+            ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+            ASSERT_EQ(statsPair.second.spilledBytes, 0);
+            ASSERT_EQ(statsPair.second.spilledPartitions, 0);
+            verifyTaskSpilledRuntimeStats(*task, false);
+          })
+          .run();
+    });
+
+    testWait.await([&]() { return !testWaitFlag.load(); });
+    ASSERT_TRUE(op != nullptr);
+    auto task = op->operatorCtx()->task();
+    auto taskPauseWait = task->requestPause();
+    driverWaitFlag = false;
+    driverWait.notifyAll();
+    taskPauseWait.wait();
+
+    uint64_t reclaimableBytes{0};
+    const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+    ASSERT_EQ(op->canReclaim(), enableSpilling);
+    ASSERT_EQ(reclaimable, enableSpilling);
+
+    if (enableSpilling) {
+      ASSERT_GT(reclaimableBytes, 0);
+      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()->usedBytes());
+    } else {
+      ASSERT_EQ(reclaimableBytes, 0);
+      VELOX_ASSERT_THROW(
+          op->reclaim(
+              folly::Random::oneIn(2) ? 0 : folly::Random::rand32(),
+              reclaimerStats_),
+          "");
+    }
+
+    Task::resume(task);
+    task.reset();
+
+    taskThread.join();
+  }
+  ASSERT_EQ(reclaimerStats_.numNonReclaimableAttempts, 1);
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, reclaimDuringWaitForProbe) {
+  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_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  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)
+                  .hashJoin(
+                      {"t_k1"},
+                      {"u_k1"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(buildVectors, false)
+                          .planNode(),
+                      "",
+                      concat(probeType_->names(), buildType_->names()))
+                  .planNode();
+
+  std::atomic_bool driverWaitFlag{true};
+  folly::EventCount driverWait;
+  std::atomic_bool testWaitFlag{true};
+  folly::EventCount testWait;
+
+  Operator* op{nullptr};
+  std::atomic<bool> injectSpillOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(Operator*)>(([&](Operator* testOp) {
+        if (testOp->operatorType() != "HashBuild") {
+          return;
+        }
+        op = testOp;
+        if (!injectSpillOnce.exchange(false)) {
+          return;
+        }
+        auto* driver = op->operatorCtx()->driver();
+        auto task = driver->task();
+        memory::ScopedMemoryArbitrationContext ctx(op->pool());
+        Operator::ReclaimableSectionGuard guard(testOp);
+        testingRunArbitration(testOp->pool());
+      })));
+
+  std::atomic<bool> injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>(([&](Operator* testOp) {
+        if (testOp->operatorType() != "HashProbe") {
+          return;
+        }
+        if (!injectOnce.exchange(false)) {
+          return;
+        }
+        ASSERT_TRUE(op != nullptr);
+        ASSERT_TRUE(op->canReclaim());
+        uint64_t reclaimableBytes{0};
+        const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+        ASSERT_TRUE(reclaimable);
+        ASSERT_GT(reclaimableBytes, 0);
+        testWaitFlag = false;
+        testWait.notifyAll();
+        auto* driver = testOp->operatorCtx()->driver();
+        auto task = driver->task();
+        TestSuspendedSection suspendedSection(driver);
+        driverWait.await([&]() { return !driverWaitFlag.load(); });
+      })));
+
+  std::thread taskThread([&]() {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers_)
+        .planNode(plan)
+        .queryPool(std::move(queryPool))
+        .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")
+        .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, 8);
+          ASSERT_GT(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 8);
+        })
+        .run();
+  });
+
+  testWait.await([&]() { return !testWaitFlag.load(); });
+  ASSERT_TRUE(op != nullptr);
+  auto task = op->operatorCtx()->task();
+  auto taskPauseWait = task->requestPause();
+  taskPauseWait.wait();
+
+  uint64_t reclaimableBytes{0};
+  const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+  ASSERT_TRUE(op->canReclaim());
+  ASSERT_TRUE(reclaimable);
+  ASSERT_GT(reclaimableBytes, 0);
+
+  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_.numNonReclaimableAttempts, 1);
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, hashBuildAbortDuringOutputProcessing) {
+  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<bool> injectOnce{true};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::noMoreInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashBuild") {
+            return;
+          }
+          if (!injectOnce.exchange(false)) {
+            return;
+          }
+          ASSERT_GT(op->pool()->usedBytes(), 0);
+          auto* driver = op->operatorCtx()->driver();
+          ASSERT_EQ(
+              driver->task()->enterSuspended(driver->state()),
+              StopReason::kNone);
+          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");
+        })));
+
+    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, hashBuildAbortDuringInputProcessing) {
+  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};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashBuild") {
+            return;
+          }
+          if (++numInputs != 2) {
+            return;
+          }
+          ASSERT_GT(op->pool()->usedBytes(), 0);
+          auto* driver = op->operatorCtx()->driver();
+          ASSERT_EQ(
+              driver->task()->enterSuspended(driver->state()),
+              StopReason::kNone);
+          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");
+        })));
+
+    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, hashBuildAbortDuringAllocation) {
+  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_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;
+              }
+
+              const 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};
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::exec::Driver::runInternal::addInput",
+        std::function<void(Operator*)>(([&](Operator* op) {
+          if (op->operatorType() != "HashProbe") {
+            return;
+          }
+          if (++numInputs != 2) {
+            return;
+          }
+          auto* driver = op->operatorCtx()->driver();
+          ASSERT_EQ(
+              driver->task()->enterSuspended(driver->state()),
+              StopReason::kNone);
+          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");
+        })));
+
+    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();
+  }
+}
+
+TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatch) {
+  // Tests some cases where the row at the end of an output batch fails the
+  // filter.
+  auto probeVectors = std::vector<RowVectorPtr>{makeRowVector(
+      {"t_k1", "t_k2"},
+      {makeFlatVector<int32_t>(20, [](auto row) { return 1 + row % 2; }),
+       makeFlatVector<int32_t>(20, [](auto row) { return row; })})};
+  auto buildVectors = std::vector<RowVectorPtr>{
+      makeRowVector({"u_k1"}, {makeFlatVector<int32_t>({1, 2})})};
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {buildVectors});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto test = [&](const std::string& filter) {
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        filter,
+                        {"t_k1", "u_k1"},
+                        core::JoinType::kLeft)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .injectSpill(false)
+        .checkSpillStats(false)
+        .maxSpillLevel(0)
+        .numDrivers(1)
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
+                filter))
+        .run();
+  };
+
+  // Alternate rows pass this filter and last row of a batch fails.
+  test("t_k1=1");
+
+  // All rows fail this filter.
+  test("t_k1=5");
+
+  // All rows in the second batch pass this filter.
+  test("t_k2 > 9");
+}
+
+TEST_F(HashJoinTest, leftJoinWithMissAtEndOfBatchMultipleBuildMatches) {
+  // Tests some cases where the row at the end of an output batch fails the
+  // filter and there are multiple matches with the build side..
+  auto probeVectors = std::vector<RowVectorPtr>{makeRowVector(
+      {"t_k1", "t_k2"},
+      {makeFlatVector<int32_t>(10, [](auto row) { return 1 + row % 2; }),
+       makeFlatVector<int32_t>(10, [](auto row) { return row; })})};
+  auto buildVectors = std::vector<RowVectorPtr>{
+      makeRowVector({"u_k1"}, {makeFlatVector<int32_t>({1, 2, 1, 2})})};
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", {buildVectors});
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto test = [&](const std::string& filter) {
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .values(probeVectors, true)
+                    .hashJoin(
+                        {"t_k1"},
+                        {"u_k1"},
+                        PlanBuilder(planNodeIdGenerator)
+                            .values(buildVectors, true)
+                            .planNode(),
+                        filter,
+                        {"t_k1", "u_k1"},
+                        core::JoinType::kLeft)
+                    .planNode();
+
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .planNode(plan)
+        .injectSpill(false)
+        .checkSpillStats(false)
+        .maxSpillLevel(0)
+        .numDrivers(1)
+        .config(
+            core::QueryConfig::kPreferredOutputBatchRows, std::to_string(10))
+        .referenceQuery(
+            fmt::format(
+                "SELECT t_k1, u_k1 from t left join u on t_k1 = u_k1 and {}",
+                filter))
+        .run();
+  };
+
+  // In this case the rows with t_k2 = 4 appear at the end of the first batch,
+  // meaning the last rows in that output batch are misses, and don't get added.
+  // The rows with t_k2 = 8 appear in the second batch so only one row is
+  // written, meaning there is space in the second output batch for the miss
+  // 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) {
+  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::reclaim",
+      std::function<void(exec::Operator*)>(([&](exec::Operator* op) {
+        HashBuild* hashBuild = static_cast<HashBuild*>(op);
+        ASSERT_FALSE(hashBuild->testingExceededMaxSpillLevelLimit());
+      })));
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashProbe::reclaim",
+      std::function<void(exec::HashBuild*)>(([&](exec::Operator* op) {
+        HashProbe* hashProbe = static_cast<HashProbe*>(op);
+        ASSERT_FALSE(hashProbe->testingExceededMaxSpillLevelLimit());
+      })));
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      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);
+}
+
+// disable because spilling is not supported for velox-cudf hash join
+TEST_F(HashJoinTest, DISABLED_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);
+    }
+  }
+}
+
+// disable because spilling is not supported for velox-cudf hash join
+TEST_F(HashJoinTest, DISABLED_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);
+    }
+  }
+}
+
+// disable because spilling is not supported for velox-cudf hash join
+TEST_F(HashJoinTest, DISABLED_reclaimFromJoinBuilderWithMultiDrivers) {
+  auto rowType = ROW({
+      {"c0", INTEGER()},
+      {"c1", INTEGER()},
+      {"c2", VARCHAR()},
+  });
+  const auto vectors = createVectors(rowType, 64 << 20, fuzzerOpts_);
+  const int numDrivers = 4;
+
+  memory::MemoryManager::Options 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().reclaimedUsedBytes, 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&) {
+          buildOp->operatorCtx()->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 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, probeSpillOnWaitForPeers) {
+  // This test creates a scenario when tester probe thread finishes processing
+  // input, entering kWaitForPeers state, and the other thread is still
+  // processing, spill is triggered properly performed.
+
+  folly::EventCount startWait;
+  folly::Synchronized<std::string> testerOpName;
+  std::atomic_bool injectedSpillOnce{false};
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        testerOpName.withWLock([&](std::string& opName) {
+          if (opName.empty()) {
+            opName = op->pool()->name();
+          }
+        });
+        if (op->pool()->name() == *testerOpName.rlock()) {
+          // Do not block tester thread.
+          return;
+        }
+        startWait.await([&]() { return injectedSpillOnce.load(); });
+      }));
+
+  // tester probe operator is guaranteed to be in kWaitForPeers state the next
+  // isBlocked() is called after noMoreInput() is called.
+  std::atomic_bool noMoreInputCalled{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        noMoreInputCalled = true;
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::isBlocked",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (!isHashProbeMemoryPool(*op->pool())) {
+          return;
+        }
+        if (injectedSpillOnce || !noMoreInputCalled) {
+          return;
+        }
+        injectedSpillOnce = true;
+        EXPECT_EQ(
+            dynamic_cast<HashProbe*>(op)->testingState(),
+            ProbeOperatorState::kWaitForPeers);
+        testingRunArbitration(op->pool());
+      }));
+
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Task::requestPauseLocked",
+      std::function<void(Task*)>([&](Task* task) { startWait.notifyAll(); }));
+
+  const uint64_t numDrivers{2};
+  std::shared_ptr<core::QueryCtx> joinQueryCtx =
+      newQueryCtx(memory::memoryManager(), executor_.get(), kMemoryCapacity);
+  auto rowType = ROW({{"c0", INTEGER()}, {"c1", INTEGER()}});
+  fuzzerOpts_.vectorSize = 20;
+  std::vector<RowVectorPtr> vectors = createVectors(6, rowType, fuzzerOpts_);
+  std::vector<RowVectorPtr> totalVectors;
+  for (auto i = 0; i < numDrivers; ++i) {
+    totalVectors.insert(totalVectors.end(), vectors.begin(), vectors.end());
+  }
+  createDuckDbTable(totalVectors);
+  auto spillDirectory = exec::test::TempDirectoryPath::create();
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto plan = PlanBuilder(planNodeIdGenerator)
+                  .values(vectors, true)
+                  .project({"c0 AS t0", "c1 AS t1"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(vectors, true)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t1"},
+                      core::JoinType::kInner)
+                  .planNode();
+
+  {
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .plan(plan)
+            .queryCtx(joinQueryCtx)
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .maxDrivers(numDrivers)
+            .assertResults("SELECT a.c1 from tmp a join tmp b on a.c0 = b.c0");
+
+    auto opStats = toOperatorStats(task->taskStats());
+    ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+    ASSERT_EQ(opStats.at("HashBuild").spilledBytes, 0);
+
+    const auto* arbitrator = memory::memoryManager()->arbitrator();
+    ASSERT_GT(arbitrator->stats().reclaimedUsedBytes, 0);
+  }
+  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 : {1'000, 30'000}) {
+    SCOPED_TRACE(fmt::format("timeout {}", succinctMillis(timeoutMs)));
+    auto memoryManager = createMemoryManager(512 << 20, 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().reclaimedUsedBytes, 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_GT(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(64, buildType_, fuzzerOpts_);
+    for (int i = 0; i < probeVectors.size(); ++i) {
+      const auto probeKeyChannel = probeType_->getChildIdx("t_k1");
+      const auto buildKeyChannle = buildType_->getChildIdx("u_k1");
+      probeVectors[i]->childAt(probeKeyChannel) =
+          buildVectors[i]->childAt(buildKeyChannle);
+    }
+
+    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->operatorCtx()->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->operatorCtx()->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();
+}
+
+// This test is to verify there is no memory reservation made before hash probe
+// start processing. This can cause unnecessary spill and query OOM under some
+// real workload with many stages as each hash probe might reserve non-trivial
+// amount of memory.
+DEBUG_ONLY_TEST_F(
+    HashJoinTest,
+    hashProbeMemoryReservationCheckBeforeProbeStartWithSpillEnabled) {
+  fuzzerOpts_.vectorSize = 128;
+  auto probeVectors = createVectors(10, probeType_, fuzzerOpts_);
+  auto buildVectors = createVectors(20, buildType_, fuzzerOpts_);
+
+  std::atomic_bool checkOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>(([&](Operator* op) {
+        if (op->operatorType() != "HashProbe") {
+          return;
+        }
+        if (!checkOnce.exchange(false)) {
+          return;
+        }
+        ASSERT_EQ(op->pool()->usedBytes(), 0);
+        ASSERT_EQ(op->pool()->reservedBytes(), 0);
+      })));
+
+  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::kInner)
+      .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 JOIN u ON t.t_k1 = u.u_k1")
+      .injectSpill(true)
+      .verifier([&](const std::shared_ptr<Task>& task, bool injectSpill) {
+        if (!injectSpill) {
+          return;
+        }
+        auto opStats = toOperatorStats(task->taskStats());
+        ASSERT_GT(opStats.at("HashProbe").spilledBytes, 0);
+        ASSERT_GE(opStats.at("HashProbe").spilledPartitions, 1);
+      })
+      .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);
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, spillOnBlockedProbe) {
+  auto blockedOperatorFactoryUniquePtr =
+      std::make_unique<BlockedOperatorFactory>();
+  auto blockedOperatorFactory = blockedOperatorFactoryUniquePtr.get();
+  Operator::registerOperator(std::move(blockedOperatorFactoryUniquePtr));
+
+  std::vector<ContinuePromise> unblockPromises;
+  std::atomic_bool shouldBlock{true};
+  blockedOperatorFactory->setBlockedCb([&](ContinueFuture* future) {
+    if (!shouldBlock) {
+      return BlockingReason::kNotBlocked;
+    }
+    auto [p, f] = makeVeloxContinuePromiseContract("Blocked Operator");
+    *future = std::move(f);
+    unblockPromises.push_back(std::move(p));
+    return BlockingReason::kWaitForConsumer;
+  });
+
+  folly::EventCount arbitrationWait;
+  std::atomic<bool> arbitrationWaitFlag{true};
+  ::facebook::velox::common::testutil::ScopedTestValue _scopedTestValue15(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(exec::HashBuild*)>([&](Operator* /* unused */) {
+        arbitrationWaitFlag = false;
+        arbitrationWait.notifyAll();
+      }));
+  std::thread arbitrationThread([&]() {
+    arbitrationWait.await([&]() { return !arbitrationWaitFlag.load(); });
+    memory::memoryManager()->shrinkPools();
+    shouldBlock = false;
+    for (auto& unblockPromise : unblockPromises) {
+      unblockPromise.setValue();
+    }
+  });
+
+  auto rowType = ROW({{"c0", INTEGER()}, {"c1", INTEGER()}});
+  std::vector<RowVectorPtr> vectors = createVectors(1, rowType, fuzzerOpts_);
+  createDuckDbTable(vectors);
+  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"})
+                  .hashJoin(
+                      {"t0"},
+                      {"u0"},
+                      PlanBuilder(planNodeIdGenerator)
+                          .values(vectors)
+                          .project({"c0 AS u0", "c1 AS u1"})
+                          .planNode(),
+                      "",
+                      {"t1"},
+                      core::JoinType::kInner)
+                  .addNode([&](std::string id, core::PlanNodePtr input) {
+                    return std::make_shared<BlockedNode>(id, input);
+                  })
+                  .planNode();
+
+  {
+    auto task =
+        AssertQueryBuilder(duckDbQueryRunner_)
+            .plan(plan)
+            .queryCtx(newQueryCtx(
+                memory::memoryManager(), executor_.get(), kMemoryCapacity))
+            .spillDirectory(spillDirectory->getPath())
+            .config(core::QueryConfig::kSpillEnabled, true)
+            .maxDrivers(1)
+            .assertResults("SELECT a.c1 from tmp a join tmp b on a.c0 = b.c0");
+    auto joinSpillStats = taskSpilledStats(*task);
+    auto buildSpillStats = joinSpillStats.first;
+    ASSERT_GT(buildSpillStats.spilledBytes, 0);
+  }
+  arbitrationThread.join();
+  waitForAllTasksToBeDeleted(30'000'000);
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, buildReclaimedMemoryReport) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  const int32_t numBuildVectors = 3;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+
+  const int32_t numProbeVectors = 3;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  const int numDrivers{2};
+  // duckdb need double probe and build inputs as we run two drivers for hash
+  // join.
+  std::vector<RowVectorPtr> totalProbeVectors = probeVectors;
+  totalProbeVectors.insert(
+      totalProbeVectors.end(), probeVectors.begin(), probeVectors.end());
+  std::vector<RowVectorPtr> totalBuildVectors = buildVectors;
+  totalBuildVectors.insert(
+      totalBuildVectors.end(), buildVectors.begin(), buildVectors.end());
+
+  createDuckDbTable("t", totalProbeVectors);
+  createDuckDbTable("u", totalBuildVectors);
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
+
+  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();
+
+  folly::EventCount driverWait;
+  std::atomic_bool driverWaitFlag{true};
+  folly::EventCount taskWait;
+  std::atomic_bool taskWaitFlag{true};
+
+  Operator* op{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::HashBuild::finishHashBuild",
+      std::function<void(Operator*)>(([&](Operator* testOp) { op = testOp; })));
+
+  std::atomic_bool injectOnce{true};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::common::memory::MemoryPoolImpl::maybeReserve",
+      std::function<void(memory::MemoryPoolImpl*)>(
+          ([&](memory::MemoryPoolImpl* pool) {
+            if (op == nullptr || op->pool() != pool) {
+              return;
+            }
+            ASSERT_TRUE(isHashBuildMemoryPool(*pool));
+            ASSERT_TRUE(op->canReclaim());
+            ASSERT_GT(op->pool()->usedBytes(), 0);
+            ASSERT_GT(
+                op->pool()->parent()->reservedBytes(),
+                op->pool()->reservedBytes());
+            if (!injectOnce.exchange(false)) {
+              return;
+            }
+            uint64_t reclaimableBytes{0};
+            const bool reclaimable = op->reclaimableBytes(reclaimableBytes);
+            ASSERT_TRUE(reclaimable);
+            ASSERT_GT(reclaimableBytes, 0);
+            auto* driver = op->operatorCtx()->driver();
+            TestSuspendedSection suspendedSection(driver);
+            taskWaitFlag = false;
+            taskWait.notifyAll();
+            driverWait.await([&]() { return !driverWaitFlag.load(); });
+          })));
+
+  std::thread taskThread([&]() {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(numDrivers)
+        .planNode(plan)
+        .queryPool(std::move(queryPool))
+        .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")
+        .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, 16);
+          ASSERT_GT(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 16);
+          verifyTaskSpilledRuntimeStats(*task, true);
+        })
+        .run();
+  });
+
+  taskWait.await([&]() { return !taskWaitFlag.load(); });
+  ASSERT_TRUE(op != nullptr);
+  auto task = op->operatorCtx()->task();
+  auto* nodePool = op->pool()->parent();
+  const auto nodeMemoryUsage = nodePool->reservedBytes();
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    const uint64_t reclaimedBytes = task->pool()->reclaim(
+        task->pool()->capacity(), 1'000'000, reclaimerStats_);
+    ASSERT_GT(reclaimedBytes, 0);
+    ASSERT_EQ(nodeMemoryUsage - nodePool->reservedBytes(), reclaimedBytes);
+  }
+  // Verify all the memory has been freed.
+  ASSERT_EQ(nodePool->reservedBytes(), 0);
+
+  driverWaitFlag = false;
+  driverWait.notifyAll();
+  task.reset();
+
+  taskThread.join();
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, probeReclaimedMemoryReport) {
+  constexpr int64_t kMaxBytes = 1LL << 30; // 1GB
+  const int32_t numBuildVectors = 3;
+  std::vector<RowVectorPtr> buildVectors;
+  for (int32_t i = 0; i < numBuildVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
+    buildVectors.push_back(fuzzer.fuzzRow(buildType_));
+  }
+
+  const int32_t numProbeVectors = 3;
+  std::vector<RowVectorPtr> probeVectors;
+  for (int32_t i = 0; i < numProbeVectors; ++i) {
+    VectorFuzzer fuzzer({.vectorSize = 200}, pool());
+    probeVectors.push_back(fuzzer.fuzzRow(probeType_));
+  }
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  auto queryPool = memory::memoryManager()->addRootPool(
+      "", kMaxBytes, memory::MemoryReclaimer::create());
+
+  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();
+
+  folly::EventCount driverWait;
+  std::atomic_bool driverWaitFlag{true};
+  folly::EventCount taskWait;
+  std::atomic_bool taskWaitFlag{true};
+
+  Operator* op{nullptr};
+  std::atomic_int probeInputCount{0};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::addInput",
+      std::function<void(Operator*)>(([&](Operator* testOp) {
+        if (testOp->operatorType() != "HashProbe") {
+          return;
+        }
+        op = testOp;
+
+        ASSERT_TRUE(op->canReclaim());
+        if (probeInputCount++ != 1) {
+          return;
+        }
+        auto* driver = op->operatorCtx()->driver();
+        TestSuspendedSection suspendedSection(driver);
+        taskWaitFlag = false;
+        taskWait.notifyAll();
+        driverWait.await([&]() { return !driverWaitFlag.load(); });
+      })));
+
+  std::thread taskThread([&]() {
+    HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+        .numDrivers(1)
+        .planNode(plan)
+        .queryPool(std::move(queryPool))
+        .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")
+        .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+        .verifier([&](const std::shared_ptr<Task>& task, bool /*unused*/) {
+          const auto statsPair = taskSpilledStats(*task);
+          // The spill triggered at the probe side.
+          ASSERT_EQ(statsPair.first.spilledBytes, 0);
+          ASSERT_EQ(statsPair.first.spilledPartitions, 0);
+          ASSERT_GT(statsPair.second.spilledBytes, 0);
+          ASSERT_EQ(statsPair.second.spilledPartitions, 16);
+        })
+        .run();
+  });
+
+  taskWait.await([&]() { return !taskWaitFlag.load(); });
+  ASSERT_TRUE(op != nullptr);
+  auto task = op->operatorCtx()->task();
+  auto* nodePool = op->pool()->parent();
+  const auto nodeMemoryUsage = nodePool->reservedBytes();
+  {
+    memory::ScopedMemoryArbitrationContext ctx(op->pool());
+    const uint64_t reclaimedBytes = task->pool()->reclaim(
+        task->pool()->capacity(), 1'000'000, reclaimerStats_);
+    ASSERT_GT(reclaimedBytes, 0);
+    ASSERT_EQ(nodeMemoryUsage - nodePool->reservedBytes(), reclaimedBytes);
+  }
+  // Verify all the memory has been freed, except for the ones for hash lookup.
+  ASSERT_EQ(nodePool->reservedBytes(), 1048576);
+
+  driverWaitFlag = false;
+  driverWait.notifyAll();
+  task.reset();
+
+  taskThread.join();
+}
+
+DEBUG_ONLY_TEST_F(HashJoinTest, hashTableCleanupAfterProbeFinish) {
+  auto buildVectors = makeVectors(buildType_, 5, 100);
+  auto probeVectors = makeVectors(probeType_, 5, 100);
+
+  createDuckDbTable("t", probeVectors);
+  createDuckDbTable("u", buildVectors);
+
+  HashProbe* probeOp{nullptr};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::getOutput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (probeOp == nullptr && op->operatorType() == "HashProbe") {
+          probeOp = dynamic_cast<HashProbe*>(op);
+        }
+      }));
+
+  bool tableEmpty{false};
+  SCOPED_TESTVALUE_SET(
+      "facebook::velox::exec::Driver::runInternal::noMoreInput",
+      std::function<void(Operator*)>([&](Operator* op) {
+        if (op->operatorType() == "FilterProject") {
+          tableEmpty = (probeOp->testingTable()->numDistinct() == 0);
+        }
+      }));
+
+  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()))
+                  .project({"t_k1", "t_k2", "t_v1", "u_k1", "u_k2", "u_v1"})
+                  .planNode();
+
+  auto tempDirectory = exec::test::TempDirectoryPath::create();
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .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")
+      .config(core::QueryConfig::kSpillStartPartitionBit, "29")
+      .run();
+  ASSERT_TRUE(tableEmpty);
+}
+
+} // namespace
diff --git a/velox/experimental/cudf/tests/LimitTest.cpp b/velox/experimental/cudf/tests/LimitTest.cpp
new file mode 100644
index 000000000000..7fb01f49cbe5
--- /dev/null
+++ b/velox/experimental/cudf/tests/LimitTest.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/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/exec/OutputBufferManager.h"
+#include "velox/exec/tests/utils/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+class LimitTest : public HiveConnectorTestBase {
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    HiveConnectorTestBase::TearDown();
+  }
+};
+
+TEST_F(LimitTest, basic) {
+  vector_size_t batchSize = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 3; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](auto row) { return batchSize * i + row; }, nullEvery(5));
+    auto c1 = makeFlatVector<int32_t>(
+        batchSize, [&](auto row) { return row; }, nullEvery(7));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](auto row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  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");
+  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, 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(
+      makePlan(1'000, 1'000), "SELECT * FROM tmp OFFSET 1000 LIMIT 1000");
+  assertQuery(
+      makePlan(1'000, 1'234), "SELECT * FROM tmp OFFSET 1000 LIMIT 1234");
+
+  assertQuery(makePlan(1'234, 10), "SELECT * FROM tmp OFFSET 1234 LIMIT 10");
+  assertQuery(makePlan(1'234, 983), "SELECT * FROM tmp OFFSET 1234 LIMIT 983");
+  assertQuery(
+      makePlan(1'234, 1'000), "SELECT * FROM tmp OFFSET 1234 LIMIT 1000");
+  assertQuery(
+      makePlan(1'234, 2'000), "SELECT * FROM tmp OFFSET 1234 LIMIT 2000");
+
+  assertQueryReturnsEmptyResult(makePlan(12'345, 10));
+}
diff --git a/velox/experimental/cudf/tests/LocalPartitionTest.cpp b/velox/experimental/cudf/tests/LocalPartitionTest.cpp
new file mode 100644
index 000000000000..39136cc5f7c4
--- /dev/null
+++ b/velox/experimental/cudf/tests/LocalPartitionTest.cpp
@@ -0,0 +1,479 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/exec/CudfConversion.h"
+#include "velox/experimental/cudf/exec/ToCudf.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/HiveConnectorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::exec::test {
+namespace {
+
+class LocalPartitionTest : public HiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    HiveConnectorTestBase::SetUp();
+    cudf_velox::registerCudf();
+  }
+
+  template <typename T>
+  FlatVectorPtr<T> makeFlatSequence(T start, vector_size_t size) {
+    return makeFlatVector<T>(size, [start](auto row) { return start + row; });
+  }
+
+  template <typename T>
+  FlatVectorPtr<T> makeFlatSequence(T start, T max, vector_size_t size) {
+    return makeFlatVector<T>(
+        size, [start, max](auto row) { return (start + row) % max; });
+  }
+
+  std::vector<std::shared_ptr<TempFilePath>> writeToFiles(
+      const std::vector<RowVectorPtr>& vectors) {
+    auto filePaths = makeFilePaths(vectors.size());
+    for (auto i = 0; i < vectors.size(); i++) {
+      writeToFile(filePaths[i]->getPath(), vectors[i]);
+    }
+    return filePaths;
+  }
+};
+
+TEST_F(LocalPartitionTest, gather) {
+  std::vector<RowVectorPtr> vectors = {
+      makeRowVector({makeFlatSequence<int32_t>(0, 100)}),
+      makeRowVector({makeFlatSequence<int32_t>(53, 100)}),
+      makeRowVector({makeFlatSequence<int32_t>(-71, 100)}),
+  };
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto valuesNode = [&](int index) {
+    return PlanBuilder(planNodeIdGenerator).values({vectors[index]}).planNode();
+  };
+
+  auto op = PlanBuilder(planNodeIdGenerator)
+                .localPartition(
+                    {},
+                    {
+                        valuesNode(0),
+                        valuesNode(1),
+                        valuesNode(2),
+                    })
+                .singleAggregation({}, {"min(c0)", "max(c0)"})
+                .planNode();
+
+  auto task = assertQuery(op, "SELECT -71, 152");
+
+  auto filePaths = writeToFiles(vectors);
+
+  auto rowType = asRowType(vectors[0]->type());
+
+  std::vector<core::PlanNodeId> scanNodeIds;
+
+  auto tableScanNode = [&]() {
+    auto node = PlanBuilder(planNodeIdGenerator).tableScan(rowType).planNode();
+    scanNodeIds.push_back(node->id());
+    return node;
+  };
+
+  op = PlanBuilder(planNodeIdGenerator)
+           .localPartition(
+               {},
+               {
+                   tableScanNode(),
+                   tableScanNode(),
+                   tableScanNode(),
+               })
+           .singleAggregation({}, {"min(c0)", "max(c0)"})
+           .planNode();
+
+  AssertQueryBuilder queryBuilder(op, duckDbQueryRunner_);
+  for (auto i = 0; i < filePaths.size(); ++i) {
+    queryBuilder.split(
+        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->getPath()));
+  }
+
+  task = queryBuilder.assertResults("SELECT -71, 152");
+}
+
+TEST_F(LocalPartitionTest, partition) {
+  std::vector<RowVectorPtr> vectors = {
+      makeRowVector({makeFlatSequence<int32_t>(0, 100)}),
+      makeRowVector({makeFlatSequence<int32_t>(53, 100)}),
+      makeRowVector({makeFlatSequence<int32_t>(-71, 100)}),
+  };
+
+  auto filePaths = writeToFiles(vectors);
+
+  auto rowType = asRowType(vectors[0]->type());
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  std::vector<core::PlanNodeId> scanNodeIds;
+
+  auto scanAggNode = [&]() {
+    auto builder = PlanBuilder(planNodeIdGenerator);
+    auto scanNode = builder.tableScan(rowType).planNode();
+    scanNodeIds.push_back(scanNode->id());
+    return builder.partialAggregation({"c0"}, {"max(c0)"}).planNode();
+  };
+
+  auto op = PlanBuilder(planNodeIdGenerator)
+                .localPartition(
+                    {"c0"},
+                    {
+                        scanAggNode(),
+                        scanAggNode(),
+                        scanAggNode(),
+                    })
+                .finalAggregation()
+                .planNode();
+
+  createDuckDbTable(vectors);
+
+  AssertQueryBuilder queryBuilder(op, duckDbQueryRunner_);
+  queryBuilder.maxDrivers(2);
+  queryBuilder.config(core::QueryConfig::kMaxLocalExchangePartitionCount, "2");
+
+  for (auto i = 0; i < filePaths.size(); ++i) {
+    queryBuilder.split(
+        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->getPath()));
+  }
+
+  auto task =
+      queryBuilder.assertResults("SELECT c0, max(c0) FROM tmp GROUP BY 1");
+}
+
+TEST_F(LocalPartitionTest, unionAllLocalExchange) {
+  auto data1 = makeRowVector({"d0"}, {makeFlatVector<StringView>({"x"})});
+  auto data2 = makeRowVector({"e0"}, {makeFlatVector<StringView>({"y"})});
+  for (bool serialExecutionMode : {false, true}) {
+    SCOPED_TRACE(fmt::format("serialExecutionMode {}", serialExecutionMode));
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    AssertQueryBuilder queryBuilder(duckDbQueryRunner_);
+    // applyTestParameters(queryBuilder);
+    queryBuilder.serialExecution(serialExecutionMode)
+        .plan(PlanBuilder(planNodeIdGenerator)
+                  .localPartitionRoundRobin(
+                      {PlanBuilder(planNodeIdGenerator)
+                           .values({data1})
+                           .project({"d0 as c0"})
+                           .planNode(),
+                       PlanBuilder(planNodeIdGenerator)
+                           .values({data2})
+                           .project({"e0 as c0"})
+                           .planNode()})
+                  .project({"length(c0)"})
+                  .planNode())
+        .assertResults(
+            "SELECT length(c0) FROM ("
+            "   SELECT * FROM (VALUES ('x')) as t1(c0) UNION ALL "
+            "   SELECT * FROM (VALUES ('y')) as t2(c0)"
+            ")");
+  }
+}
+
+TEST_F(LocalPartitionTest, roundRobinMultipleBatches) {
+  // Test round robin with multiple input batches to verify counter continuity
+  std::vector<RowVectorPtr> vectors = {
+      makeRowVector({makeFlatSequence<int32_t>(0, 5)}), // Batch 1: 5 rows
+      makeRowVector({makeFlatSequence<int32_t>(5, 5)}), // Batch 2: 5 rows
+      makeRowVector({makeFlatSequence<int32_t>(10, 5)}), // Batch 3: 5 rows
+  };
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .localPartitionRoundRobin(
+              {PlanBuilder(planNodeIdGenerator).values(vectors).planNode()})
+          .singleAggregation({}, {"count(1)", "min(c0)", "max(c0)"})
+          .planNode();
+
+  // Total 15 rows, 3 partitions: each gets 5 rows
+  auto task = assertQuery(op, "SELECT 15, 0, 14");
+
+  auto stats = task->taskStats();
+  ASSERT_EQ(stats.numTotalDrivers, 2);
+}
+
+TEST_F(LocalPartitionTest, roundRobinEmptyInput) {
+  // Test with empty input
+  std::vector<RowVectorPtr> vectors = {
+      makeRowVector({makeFlatVector<int32_t>({})}), // Empty vector
+  };
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .localPartitionRoundRobin(
+              {PlanBuilder(planNodeIdGenerator).values(vectors).planNode()})
+          .singleAggregation({}, {"count(1)"})
+          .planNode();
+
+  // Should handle empty input gracefully
+  auto task = assertQuery(op, "SELECT 0");
+
+  auto stats = task->taskStats();
+  ASSERT_EQ(stats.numTotalDrivers, 2);
+}
+
+TEST_F(LocalPartitionTest, roundRobinMultipleSources) {
+  // Test round robin with multiple input sources
+  std::vector<RowVectorPtr> vectors1 = {
+      makeRowVector({makeFlatSequence<int32_t>(0, 5)}),
+  };
+
+  std::vector<RowVectorPtr> vectors2 = {
+      makeRowVector({makeFlatSequence<int32_t>(5, 5)}),
+  };
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .localPartitionRoundRobin({
+              PlanBuilder(planNodeIdGenerator).values(vectors1).planNode(),
+              PlanBuilder(planNodeIdGenerator).values(vectors2).planNode(),
+          })
+          .singleAggregation({}, {"count(1)", "min(c0)", "max(c0)"})
+          .planNode();
+
+  // Total 10 rows from 2 sources, 3 partitions
+  auto task = assertQuery(op, "SELECT 10, 0, 9");
+
+  auto stats = task->taskStats();
+  ASSERT_EQ(stats.numTotalDrivers, 3);
+}
+
+TEST_F(LocalPartitionTest, roundRobinWithAggregation) {
+  // Test round robin followed by aggregation
+  std::vector<RowVectorPtr> vectors = {
+      makeRowVector({
+          makeFlatSequence<int32_t>(0, 20), // 20 rows
+          makeFlatSequence<int32_t>(0, 4, 20), // Values 0,1,2,3 repeating
+      }),
+  };
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .localPartitionRoundRobin(
+              {PlanBuilder(planNodeIdGenerator).values(vectors).planNode()})
+          .singleAggregation({}, {"count(1)", "sum(c0)"})
+          .planNode();
+
+  auto task = assertQuery(op, "SELECT 20, 190");
+
+  auto stats = task->taskStats();
+  ASSERT_EQ(stats.numTotalDrivers, 2);
+}
+
+TEST_F(LocalPartitionTest, roundRobinWithTableScan) {
+  // Test round robin with table scan sources
+  std::vector<RowVectorPtr> vectors = {
+      makeRowVector({makeFlatSequence<int32_t>(0, 30)}),
+      makeRowVector({makeFlatSequence<int32_t>(0, 12)}),
+  };
+
+  auto filePaths = writeToFiles(vectors);
+  auto rowType = asRowType(vectors[0]->type());
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  std::vector<core::PlanNodeId> scanNodeIds;
+
+  auto tableScanNode = [&]() {
+    auto node = PlanBuilder(planNodeIdGenerator).tableScan(rowType).planNode();
+    scanNodeIds.push_back(node->id());
+    return node;
+  };
+
+  auto op = PlanBuilder(planNodeIdGenerator)
+                .localPartitionRoundRobin({
+                    tableScanNode(),
+                    tableScanNode(),
+                })
+                .singleAggregation({}, {"count(1)", "min(c0)", "max(c0)"})
+                .planNode();
+
+  createDuckDbTable(vectors);
+
+  AssertQueryBuilder queryBuilder(op, duckDbQueryRunner_);
+  queryBuilder.maxDrivers(3); // 3 partitions
+  queryBuilder.config(core::QueryConfig::kMaxLocalExchangePartitionCount, "3");
+
+  for (auto i = 0; i < filePaths.size(); ++i) {
+    queryBuilder.split(
+        scanNodeIds[i], makeHiveConnectorSplit(filePaths[i]->getPath()));
+  }
+
+  // 1st partition gets all rows
+  // 2nd partition gets zero rows
+  // 3rd partition gets zero rows
+
+  auto task = queryBuilder.assertResults(
+      "SELECT 42, 0, 29 UNION ALL SELECT 0, NULL, NULL UNION ALL SELECT 0, NULL, NULL");
+
+  auto stats = task->taskStats();
+  ASSERT_EQ(stats.numTotalDrivers, 9);
+}
+
+TEST_F(LocalPartitionTest, roundRobinAllCombinations) {
+  // 6 value vectors in different scenarios.
+  // Test all possible round robin distribution configurations:
+  for (auto [num_sources, num_partitions] :
+       {std::pair{3, 1},
+        {2, 3},
+        {3, 2},
+        {1, 3},
+        {2, 2},
+        {2, 5},
+        {1, 5},
+        {5, 2},
+        {5, 3}}) {
+    // Test to verify actual distribution pattern
+    std::vector<RowVectorPtr> vectors = {
+        makeRowVector({makeFlatSequence<int32_t>(0, 12)}), // 12 rows
+        makeRowVector({makeFlatSequence<int32_t>(0, 4)}), // 4 rows
+        makeRowVector({makeFlatSequence<int32_t>(0, 40)}), // 40 rows
+        makeRowVector({makeFlatSequence<int32_t>(0, 8)}), // 8 rows
+        makeRowVector({makeFlatSequence<int32_t>(0, 6)}), // 6 rows
+        makeRowVector({makeFlatSequence<int32_t>(0, 25)}), // 25 rows
+    };
+    auto expectedTotalRows = std::accumulate(
+        vectors.begin(),
+        vectors.end(),
+        0,
+        [](int sum, const RowVectorPtr& vector) {
+          return sum + vector->size();
+        });
+    std::vector<int> expected_partition_counts(num_partitions, 0);
+    for (int i = 0; i < vectors.size(); ++i) {
+      expected_partition_counts[i % num_partitions] += 1;
+    }
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+    auto make_op = [&](int num_sources) {
+      std::vector<core::PlanNodePtr> sources;
+      for (size_t i = 0; i < num_sources; ++i) {
+        auto num_vectors = (vectors.size() + num_sources - 1) / num_sources;
+        auto start = std::min(i * num_vectors, vectors.size());
+        auto end = std::min(start + num_vectors, vectors.size());
+        std::vector<RowVectorPtr> source_vectors(
+            vectors.begin() + start, vectors.begin() + end);
+        if (source_vectors.empty()) {
+          source_vectors.push_back(
+              makeRowVector({makeFlatSequence<int32_t>(0, 0)}));
+        }
+        sources.push_back(
+            PlanBuilder(planNodeIdGenerator).values(source_vectors).planNode());
+      }
+      return PlanBuilder(planNodeIdGenerator)
+          .localPartitionRoundRobin(sources)
+          .planNode();
+    };
+
+    auto op = make_op(num_sources);
+
+    // Use cursor to examine actual distribution
+    CursorParameters params;
+    params.queryConfigs.insert(
+        {cudf_velox::CudfFromVelox::kGpuBatchSizeRows, "1"});
+    params.queryConfigs.insert(
+        {core::QueryConfig::kMaxLocalExchangePartitionCount,
+         std::to_string(num_partitions)});
+
+    params.planNode = op;
+    params.maxDrivers = num_partitions;
+    params.copyResult = false;
+
+    auto cursor = TaskCursor::create(params);
+
+    std::vector<int> partitionCounts(num_partitions, 0);
+    int partition = 0;
+    int totalRows = 0;
+
+    while (cursor->moveNext()) {
+      auto* batch = cursor->current()->as<RowVector>();
+      partitionCounts[partition++ % num_partitions] += 1;
+      totalRows += batch->size();
+    }
+
+    EXPECT_EQ(totalRows, expectedTotalRows)
+        << "for {" << num_sources << ", " << num_partitions << "}";
+    // With round robin, each batch should go into separate partitions.
+    for (int i = 0; i < num_partitions; ++i) {
+      auto expected_count = expected_partition_counts[i];
+      ASSERT_EQ(partitionCounts[i], expected_count)
+          << "for i " << i << ", {" << num_sources << ", " << num_partitions
+          << "}";
+    }
+  }
+}
+
+TEST_F(LocalPartitionTest, roundRobinDistributionVerification) {
+  // Test to verify actual distribution pattern
+  std::vector<RowVectorPtr> vectors = {
+      makeRowVector({makeFlatSequence<int32_t>(0, 12)}), // 12 rows
+      makeRowVector({makeFlatSequence<int32_t>(0, 4)}), // 4 rows
+      makeRowVector({makeFlatSequence<int32_t>(0, 40)}), // 40 rows
+  };
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+  auto op =
+      PlanBuilder(planNodeIdGenerator)
+          .localPartitionRoundRobin(
+              {PlanBuilder(planNodeIdGenerator).values(vectors).planNode()})
+          .planNode();
+
+  // Use cursor to examine actual distribution
+  CursorParameters params;
+  params.queryConfigs.insert(
+      {cudf_velox::CudfFromVelox::kGpuBatchSizeRows, "1"});
+  params.queryConfigs.insert(
+      {core::QueryConfig::kMaxLocalExchangePartitionCount, "3"});
+
+  params.planNode = op;
+  params.maxDrivers = 3;
+  params.copyResult = false;
+
+  auto cursor = TaskCursor::create(params);
+
+  std::vector<int> partitionCounts(3, 0);
+  int partition = 0;
+  int totalRows = 0;
+
+  while (cursor->moveNext()) {
+    auto* batch = cursor->current()->as<RowVector>();
+    partitionCounts[partition++ % 3] += 1;
+    totalRows += batch->size();
+  }
+
+  ASSERT_EQ(totalRows, 56);
+  // With round robin, each batch should go into separate partitions.
+  ASSERT_EQ(partitionCounts[0], 1);
+  ASSERT_EQ(partitionCounts[1], 1);
+  ASSERT_EQ(partitionCounts[2], 1);
+}
+
+} // namespace
+} // namespace facebook::velox::exec::test
diff --git a/velox/experimental/cudf/tests/OrderByTest.cpp b/velox/experimental/cudf/tests/OrderByTest.cpp
index d3eb5a75867f..1ee44e0fdf79 100644
--- a/velox/experimental/cudf/tests/OrderByTest.cpp
+++ b/velox/experimental/cudf/tests/OrderByTest.cpp
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/experimental/cudf/exec/CudfConversion.h"
 #include "velox/experimental/cudf/exec/ToCudf.h"
-#include "velox/experimental/cudf/exec/Utilities.h"
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/core/QueryConfig.h"
@@ -25,7 +25,6 @@
 #include "velox/exec/tests/utils/PlanBuilder.h"
 
 #include <fmt/format.h>
-#include <re2/re2.h>
 
 using namespace facebook::velox;
 using namespace facebook::velox::exec;
@@ -319,4 +318,74 @@ TEST_F(OrderByTest, varfields) {
   testSingleKey(vectors, "c2");
 }
 
+/// Verifies output batch rows of OrderBy
+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:{}, preferredOutBatchBytes:{}, maxOutBatchRows:{}, expectedOutputVectors:{}",
+          numRowsPerBatch,
+          preferredOutBatchBytes,
+          maxOutBatchRows,
+          expectedOutputVectors);
+    }
+  } 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());
+    const vector_size_t batchSize = testData.numRowsPerBatch;
+    std::vector<RowVectorPtr> rowVectors;
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](vector_size_t row) { return row; }, nullEvery(5));
+    auto c1 = makeFlatVector<double>(
+        batchSize, [&](vector_size_t row) { return row; }, nullEvery(11));
+    std::vector<VectorPtr> vectors;
+    vectors.push_back(c0);
+    for (int i = 0; i < 256; ++i) {
+      vectors.push_back(c1);
+    }
+    rowVectors.push_back(makeRowVector(vectors));
+    createDuckDbTable(rowVectors);
+
+    core::PlanNodeId orderById;
+    auto plan = PlanBuilder()
+                    .values(rowVectors)
+                    .orderBy({fmt::format("{} ASC NULLS LAST", "c0")}, false)
+                    .capturePlanNodeId(orderById)
+                    .planNode();
+    auto queryCtx = core::QueryCtx::create(executor_.get());
+    queryCtx->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kPreferredOutputBatchBytes,
+          std::to_string(testData.preferredOutBatchBytes)},
+         {core::QueryConfig::kMaxOutputBatchRows,
+          std::to_string(testData.maxOutBatchRows)},
+         {facebook::velox::cudf_velox::CudfToVelox::kPassthroughMode,
+          "false"}});
+    CursorParameters params;
+    params.planNode = plan;
+    params.queryCtx = queryCtx;
+    auto task = assertQueryOrdered(
+        params, "SELECT * FROM tmp ORDER BY c0 ASC NULLS LAST", {0});
+
+    EXPECT_EQ(
+        testData.expectedOutputVectors,
+        toPlanStats(task->taskStats())
+            .at(orderById + "-to-velox")
+            .outputVectors);
+  }
+}
+
 } // namespace
diff --git a/velox/experimental/cudf/tests/S3ReadTest.cpp b/velox/experimental/cudf/tests/S3ReadTest.cpp
new file mode 100644
index 000000000000..126f951c01f3
--- /dev/null
+++ b/velox/experimental/cudf/tests/S3ReadTest.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/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
+
+#include "velox/common/memory/Memory.h"
+#include "velox/connectors/hive/HiveConfig.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"
+
+#include <folly/init/Init.h>
+#include <gtest/gtest.h>
+
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::cudf_velox::exec::test;
+namespace {
+
+class S3ReadTest : public S3Test, public ::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    S3Test::SetUp();
+    // Register cudf to enable the CudfDatasource creation from
+    // CudfHiveConnector
+    facebook::velox::cudf_velox::registerCudf();
+    filesystems::registerS3FileSystem();
+
+    // Register Hive connector
+    facebook::velox::cudf_velox::connector::hive::CudfHiveConnectorFactory
+        factory;
+    auto hiveConnector = factory.newConnector(
+        kCudfHiveConnectorId, minioServer_->hiveConfig(), ioExecutor_.get());
+    facebook::velox::connector::registerConnector(hiveConnector);
+  }
+
+  void TearDown() override {
+    filesystems::finalizeS3FileSystem();
+    facebook::velox::connector::unregisterConnector(kCudfHiveConnectorId);
+    S3Test::TearDown();
+  }
+};
+} // namespace
+
+TEST_F(S3ReadTest, s3ReadTest) {
+  const auto sourceFile =
+      "/velox/velox/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.
+  auto rowType = ROW({"int", "bigint"}, {INTEGER(), BIGINT()});
+  auto tableHandle =
+      std::make_shared<facebook::velox::connector::hive::HiveTableHandle>(
+          kCudfHiveConnectorId,
+          "int_table",
+          false,
+          common::SubfieldFilters{},
+          nullptr,
+          nullptr);
+  auto plan = PlanBuilder(pool())
+                  .startTableScan()
+                  .tableHandle(tableHandle)
+                  .outputType(rowType)
+                  .endTableScan()
+                  .planNode();
+  auto split = facebook::velox::connector::hive::HiveConnectorSplitBuilder(
+                   filesystems::s3URI(bucketName, "int.parquet"))
+                   .connectorId(kCudfHiveConnectorId)
+                   .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});
+}
diff --git a/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp b/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp
new file mode 100644
index 000000000000..bba356b5b401
--- /dev/null
+++ b/velox/experimental/cudf/tests/SubfieldFilterAstTest.cpp
@@ -0,0 +1,684 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/expression/SubfieldFiltersToAst.h"
+
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/type/Filter.h"
+#include "velox/type/Subfield.h"
+
+#include <cudf/column/column_view.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/transform.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::cudf_velox;
+using namespace facebook::velox::exec::test;
+
+namespace {
+
+class SubfieldFilterAstTest : public OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    facebook::velox::filesystems::registerLocalFileSystem();
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    OperatorTestBase::TearDown();
+  }
+
+  // Generate a single test vector
+  RowVectorPtr makeTestVector(const RowTypePtr& rowType, int32_t rows = 100) {
+    return std::dynamic_pointer_cast<RowVector>(
+        facebook::velox::test::BatchMaker::createBatch(rowType, rows, *pool_));
+  }
+
+  // Execute filter comparison between Velox and cuDF using a pre-created AST.
+  // 'tree' and 'scalars' must out-live the computation because they own the
+  // expression nodes and literal scalars referenced by 'expr'.
+  void testFilterExecution(
+      const RowTypePtr& rowType,
+      const std::string& columnName,
+      const common::Filter& filter,
+      const RowVectorPtr& vector,
+      const cudf::ast::expression& expr) {
+    auto stream = cudf::get_default_stream();
+    auto mr = cudf::get_current_device_resource_ref();
+
+    {
+      auto cudfTable =
+          cudf_velox::with_arrow::toCudfTable(vector, pool_.get(), stream);
+      ASSERT_NE(cudfTable, nullptr);
+
+      auto cudfResult =
+          cudf::compute_column(cudfTable->view(), expr, stream, mr);
+
+      ASSERT_NE(cudfResult, nullptr);
+      EXPECT_EQ(cudfResult->type().id(), cudf::type_id::BOOL8);
+      EXPECT_EQ(cudfResult->size(), vector->size())
+          << "Result size mismatch for column: " << columnName;
+
+      // Convert cuDF bool result back to Velox to compare element-wise.
+      auto resultTable = std::make_unique<cudf::table>(
+          std::vector<std::unique_ptr<cudf::column>>{});
+      std::vector<std::unique_ptr<cudf::column>> cols;
+      cols.emplace_back(
+          std::move(const_cast<std::unique_ptr<cudf::column>&>(cudfResult)));
+      resultTable = std::make_unique<cudf::table>(std::move(cols));
+
+      auto veloxBoolRow = cudf_velox::with_arrow::toVeloxColumn(
+          resultTable->view(), pool_.get(), "cmp_", stream);
+      auto boolVector = veloxBoolRow->childAt(0)->asFlatVector<bool>();
+      boolVector->loadedVector();
+
+      // Compare with Velox filter evaluation.
+      auto inputFieldIdx = rowType->getChildIdx(columnName);
+      auto fieldVec = vector->childAt(inputFieldIdx);
+
+      for (int i = 0; i < vector->size(); ++i) {
+        if (fieldVec->isNullAt(i)) {
+          continue; // skip null comparison
+        }
+
+        bool veloxExpected = false;
+        switch (fieldVec->typeKind()) {
+          case TypeKind::BIGINT: {
+            auto v = fieldVec->asFlatVector<int64_t>()->valueAt(i);
+            veloxExpected = filter.testInt64(v);
+            break;
+          }
+          case TypeKind::INTEGER: {
+            auto v = fieldVec->asFlatVector<int32_t>()->valueAt(i);
+            veloxExpected = filter.testInt64(static_cast<int64_t>(v));
+            break;
+          }
+          case TypeKind::SMALLINT: {
+            auto v = fieldVec->asFlatVector<int16_t>()->valueAt(i);
+            veloxExpected = filter.testInt64(static_cast<int64_t>(v));
+            break;
+          }
+          case TypeKind::TINYINT: {
+            auto v = fieldVec->asFlatVector<int8_t>()->valueAt(i);
+            veloxExpected = filter.testInt64(static_cast<int64_t>(v));
+            break;
+          }
+          case TypeKind::DOUBLE: {
+            auto v = fieldVec->asFlatVector<double>()->valueAt(i);
+            veloxExpected = filter.testDouble(v);
+            break;
+          }
+          case TypeKind::REAL: {
+            auto v = fieldVec->asFlatVector<float>()->valueAt(i);
+            veloxExpected = filter.testFloat(v);
+            break;
+          }
+          case TypeKind::BOOLEAN: {
+            auto v = fieldVec->asFlatVector<bool>()->valueAt(i);
+            veloxExpected = filter.testBool(v);
+            break;
+          }
+          case TypeKind::VARCHAR: {
+            auto sv = fieldVec->asFlatVector<StringView>()->valueAt(i);
+            veloxExpected = filter.testBytes(sv.data(), sv.size());
+            break;
+          }
+          default:
+            veloxExpected = true;
+        }
+        bool cudfGot = boolVector->valueAt(i);
+        EXPECT_EQ(veloxExpected, cudfGot)
+            << "Mismatch at row " << i << " for " << columnName;
+      }
+    }
+  }
+};
+
+// Basic AST generation tests
+TEST_F(SubfieldFilterAstTest, Int32RangeInclusive) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, INTEGER()}});
+  auto filter =
+      std::make_unique<common::BigintRange>(10, 20, /*nullAllowed*/ false);
+
+  // AST validation
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for test";
+  EXPECT_LE(scalars.size(), 2UL) << "Too many scalars for range filter";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, DoubleRange) {
+  const std::string columnName = "c1";
+  auto rowType = ROW({{columnName, DOUBLE()}});
+  auto filter = std::make_unique<common::DoubleRange>(
+      0.1, false, false, 10.5, false, false, /*nullAllowed*/ false);
+
+  // AST validation
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for test";
+  EXPECT_LE(scalars.size(), 2UL) << "Too many scalars for float range";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, StringInList) {
+  const std::string columnName = "c2";
+  auto rowType = ROW({{columnName, VARCHAR()}});
+  // Manually construct a VARCHAR column so IN-list values are guaranteed.
+  auto strings = makeFlatVector<std::string>(std::vector<std::string>{
+      "alpha", "zeta", "beta", "omega", "alpha", "beta"});
+  auto vec = makeRowVector({columnName}, {strings});
+  std::vector<std::string> stringVals = {"alpha", "beta"};
+  auto filter =
+      std::make_unique<common::BytesValues>(stringVals, /*nullAllowed*/ false);
+
+  // AST validation
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for test";
+  EXPECT_EQ(scalars.size(), stringVals.size())
+      << "Scalar count mismatch for string IN list";
+
+  // Execution validation
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, StringNotInList) {
+  const std::string columnName = "c2";
+  auto rowType = ROW({{columnName, VARCHAR()}});
+  // Manually construct a VARCHAR column and a NOT IN list.
+  auto strings = makeFlatVector<std::string>(std::vector<std::string>{
+      "alpha", "beta", "gamma", "delta", "alpha", "epsilon"});
+  auto vec = makeRowVector({columnName}, {strings});
+  std::vector<std::string> stringVals = {"alpha", "beta"};
+  auto filter = std::make_unique<common::NegatedBytesValues>(
+      stringVals, /*nullAllowed*/ false);
+
+  // AST validation
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for test";
+  EXPECT_EQ(scalars.size(), stringVals.size())
+      << "Scalar count mismatch for string NOT IN list";
+
+  // Execution validation
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, StringRange) {
+  const std::string columnName = "c2";
+  auto rowType = ROW({{columnName, VARCHAR()}});
+  auto filter = std::make_unique<common::BytesRange>(
+      "apple",
+      /*lowerUnbounded*/ false,
+      /*lowerExclusive*/ false,
+      "orange",
+      /*upperUnbounded*/ false,
+      /*upperExclusive*/ false,
+      /*nullAllowed*/ false);
+
+  // AST validation
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for test";
+  EXPECT_LE(scalars.size(), 2UL) << "Too many scalars for string range";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+// Single value string range test
+TEST_F(SubfieldFilterAstTest, StringRangeSingleValue) {
+  const std::string columnName = "c2";
+  auto rowType = ROW({{columnName, VARCHAR()}});
+
+  // Define a single-value range where lower == upper.
+  auto filter = std::make_unique<common::BytesRange>(
+      "banana",
+      /*lowerUnbounded*/ false,
+      /*lowerExclusive*/ false,
+      "banana",
+      /*upperUnbounded*/ false,
+      /*upperExclusive*/ false,
+      /*nullAllowed*/ false);
+
+  // AST validation
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  // Single value range should create exactly one scalar for equality
+  EXPECT_EQ(scalars.size(), 1UL)
+      << "Single value range should create 1 scalar for equality";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, BoolValue) {
+  const std::string columnName = "flag";
+  auto rowType = ROW({{columnName, BOOLEAN()}});
+  auto filter =
+      std::make_unique<common::BoolValue>(true, /*nullAllowed*/ false);
+
+  // AST validation
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for test";
+  EXPECT_LE(scalars.size(), 1UL) << "Too many scalars for bool value";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+// Single value range tests
+TEST_F(SubfieldFilterAstTest, BigintRangeSingleValue) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, BIGINT()}});
+  auto filter =
+      std::make_unique<common::BigintRange>(42, 42, /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  // Single value range should create 1 scalar for equality comparison (c0 = 42)
+  EXPECT_EQ(scalars.size(), 1UL)
+      << "Single value range should create 1 scalar for equality";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, Int32SingleValue) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, INTEGER()}}); // 32-bit int
+  auto filter =
+      std::make_unique<common::BigintRange>(100, 100, /*nullAllowed*/ false);
+
+  common::Subfield subfield("c0");
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  EXPECT_EQ(scalars.size(), 1UL)
+      << "Single value on int32 should create 1 scalar for equality";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+// Single value that is outside the column's type range.
+// For an INT32 column, pick a 64-bit value greater than INT32_MAX.
+TEST_F(SubfieldFilterAstTest, Int32SingleValueOutOfRange) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, INTEGER()}}); // 32-bit int column
+
+  // Value well above INT32_MAX.
+  int64_t outOfRangeValue =
+      static_cast<int64_t>(std::numeric_limits<int32_t>::max()) + 1000;
+
+  auto filter = std::make_unique<common::BigintRange>(
+      outOfRangeValue, outOfRangeValue, /*nullAllowed*/ false);
+
+  // Build AST once.
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL)
+      << "No expressions created for out-of-range single value test";
+  EXPECT_EQ(scalars.size(), 0UL)
+      << "Single value on int32 should create no scalars for out-of-range";
+
+  // Execution validation – compare Velox filter vs cuDF AST results.
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+// Type boundary tests
+TEST_F(SubfieldFilterAstTest, IntegerOverflowBounds) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, INTEGER()}}); // 32-bit int
+  auto filter = std::make_unique<common::BigintRange>(
+      std::numeric_limits<int64_t>::min(),
+      std::numeric_limits<int64_t>::max(),
+      /*nullAllowed*/ false);
+
+  common::Subfield subfield("c0");
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  // Should have created no scalars since both bounds are beyond int32 range
+  EXPECT_EQ(scalars.size(), 0UL)
+      << "Should skip both bounds for full-range int32 filter";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, PartialBoundsOutsideTypeRange) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, INTEGER()}}); // 32-bit int
+  auto filter = std::make_unique<common::BigintRange>(
+      std::numeric_limits<int64_t>::min(), 1000, /*nullAllowed*/ false);
+
+  common::Subfield subfield("c0");
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  // Should create 1 scalar (upper bound), lower bound should be skipped
+  EXPECT_EQ(scalars.size(), 1UL)
+      << "Should create only upper bound scalar when lower is out of range";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, SmallIntTypeBounds) {
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, SMALLINT()}}); // 16-bit int
+  auto filter = std::make_unique<common::BigintRange>(
+      -100000, 100000, /*nullAllowed*/ false);
+
+  common::Subfield subfield("c0");
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+
+  EXPECT_GT(tree.size(), 0UL);
+  // Should skip both bounds since they exceed int16 range (-32768 to 32767)
+  EXPECT_EQ(scalars.size(), 0UL)
+      << "Should skip both bounds for range exceeding int16 limits";
+
+  // Execution validation
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+TEST_F(SubfieldFilterAstTest, EmptyInListHandling) {
+  auto rowType = ROW({{"c0", BIGINT()}});
+  std::vector<int64_t> emptyVals = {};
+
+  // Empty IN list should throw or handle gracefully
+  // Note: This test checks that we handle the edge case appropriately
+  EXPECT_THROW(
+      {
+        auto filter = std::make_unique<common::BigintValuesUsingBitmask>(
+            0, 1, emptyVals, /*nullAllowed*/ false);
+        common::Subfield subfield("c0");
+        cudf::ast::tree tree;
+        std::vector<std::unique_ptr<cudf::scalar>> scalars;
+        createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+      },
+      VeloxException);
+}
+
+TEST_F(SubfieldFilterAstTest, MultipleSubfieldFilters) {
+  // Schema with multiple columns to filter on.
+  auto rowType = ROW({
+      {"c0", INTEGER()},
+      {"c1", DOUBLE()},
+      {"c2", VARCHAR()},
+      {"flag", BOOLEAN()},
+  });
+
+  // Build multiple filters across columns.
+  common::SubfieldFilters filters;
+  filters.emplace(
+      common::Subfield("c0"),
+      std::make_shared<common::BigintRange>(10, 20, /*nullAllowed*/ false));
+  filters.emplace(
+      common::Subfield("c1"),
+      std::make_shared<common::DoubleRange>(
+          0.1, false, false, 10.5, false, false, /*nullAllowed*/ false));
+  filters.emplace(
+      common::Subfield("c2"),
+      std::make_shared<common::NegatedBytesValues>(
+          std::vector<std::string>{"apple", "cherry"},
+          /*nullAllowed*/ false));
+  filters.emplace(
+      common::Subfield("flag"),
+      std::make_shared<common::BoolValue>(true, /*nullAllowed*/ false));
+
+  // Build AST for combined filters.
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  auto const& combinedExpr =
+      createAstFromSubfieldFilters(filters, tree, scalars, rowType);
+  ASSERT_GT(tree.size(), 0UL) << "No expressions created for combined filters";
+  // Expect number of scalars to equal the sum of scalars used by each filter.
+  EXPECT_GE(scalars.size(), 1UL);
+
+  // Create input vector and evaluate using cuDF.
+  auto vec = makeTestVector(rowType, 200);
+  auto stream = cudf::get_default_stream();
+  auto mr = cudf::get_current_device_resource_ref();
+
+  auto cudfTable =
+      cudf_velox::with_arrow::toCudfTable(vec, pool_.get(), stream);
+  ASSERT_NE(cudfTable, nullptr);
+  auto cudfResult =
+      cudf::compute_column(cudfTable->view(), combinedExpr, stream, mr);
+  ASSERT_NE(cudfResult, nullptr);
+  EXPECT_EQ(cudfResult->type().id(), cudf::type_id::BOOL8);
+  EXPECT_EQ(cudfResult->size(), vec->size());
+
+  // Convert cuDF result back to Velox bool vector.
+  auto resultTable = std::make_unique<cudf::table>(
+      std::vector<std::unique_ptr<cudf::column>>{});
+  std::vector<std::unique_ptr<cudf::column>> cols;
+  cols.emplace_back(
+      std::move(const_cast<std::unique_ptr<cudf::column>&>(cudfResult)));
+  resultTable = std::make_unique<cudf::table>(std::move(cols));
+  auto veloxBoolRow = cudf_velox::with_arrow::toVeloxColumn(
+      resultTable->view(), pool_.get(), "cmp_", stream);
+  auto boolVector = veloxBoolRow->childAt(0)->asFlatVector<bool>();
+  boolVector->loadedVector();
+
+  // Validate row-wise: AND of each filter's predicate; skip rows with any
+  // nulls.
+  auto c0Vec = vec->childAt(rowType->getChildIdx("c0"));
+  auto c1Vec = vec->childAt(rowType->getChildIdx("c1"));
+  auto c2Vec = vec->childAt(rowType->getChildIdx("c2"));
+  auto flagVec = vec->childAt(rowType->getChildIdx("flag"));
+
+  auto& f0 = *filters.at(common::Subfield("c0"));
+  auto& f1 = *filters.at(common::Subfield("c1"));
+  auto& f2 = *filters.at(common::Subfield("c2"));
+  auto& f3 = *filters.at(common::Subfield("flag"));
+
+  for (int i = 0; i < vec->size(); ++i) {
+    if (c0Vec->isNullAt(i) || c1Vec->isNullAt(i) || c2Vec->isNullAt(i) ||
+        flagVec->isNullAt(i)) {
+      continue;
+    }
+
+    bool e0 = f0.testInt64(
+        static_cast<int64_t>(c0Vec->asFlatVector<int32_t>()->valueAt(i)));
+    bool e1 = f1.testDouble(c1Vec->asFlatVector<double>()->valueAt(i));
+    auto sv = c2Vec->asFlatVector<StringView>()->valueAt(i);
+    bool e2 = f2.testBytes(sv.data(), sv.size());
+    bool e3 = f3.testBool(flagVec->asFlatVector<bool>()->valueAt(i));
+    bool expected = e0 && e1 && e2 && e3;
+
+    bool got = boolVector->valueAt(i);
+    EXPECT_EQ(expected, got) << "Mismatch at row " << i;
+  }
+}
+
+struct IntInListCase {
+  TypeKind kind;
+  std::vector<int64_t> values;
+  const char* name;
+};
+
+class IntInListParamTest : public SubfieldFilterAstTest,
+                           public ::testing::WithParamInterface<IntInListCase> {
+};
+
+static bool isRepresentableForKind(int64_t v, TypeKind kind) {
+  switch (kind) {
+    case TypeKind::TINYINT:
+      return v >= std::numeric_limits<int8_t>::min() &&
+          v <= std::numeric_limits<int8_t>::max();
+    case TypeKind::SMALLINT:
+      return v >= std::numeric_limits<int16_t>::min() &&
+          v <= std::numeric_limits<int16_t>::max();
+    case TypeKind::INTEGER:
+      return v >= std::numeric_limits<int32_t>::min() &&
+          v <= std::numeric_limits<int32_t>::max();
+    case TypeKind::BIGINT:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static TypePtr buildTypeForKind(TypeKind kind) {
+  switch (kind) {
+    case TypeKind::TINYINT:
+      return TINYINT();
+    case TypeKind::SMALLINT:
+      return SMALLINT();
+    case TypeKind::INTEGER:
+      return INTEGER();
+    case TypeKind::BIGINT:
+      return BIGINT();
+    default:
+      VELOX_FAIL("Unsupported kind for IntInListParamTest");
+  }
+}
+
+TEST_P(IntInListParamTest, InListParam) {
+  const auto& p = GetParam();
+  const std::string columnName = "c0";
+  auto rowType = ROW({{columnName, buildTypeForKind(p.kind)}});
+
+  int64_t min = *std::min_element(p.values.begin(), p.values.end());
+  int64_t max = *std::max_element(p.values.begin(), p.values.end());
+  auto filter = std::make_unique<common::BigintValuesUsingBitmask>(
+      min, max, p.values, /*nullAllowed*/ false);
+
+  common::Subfield subfield(columnName);
+  cudf::ast::tree tree;
+  std::vector<std::unique_ptr<cudf::scalar>> scalars;
+  const auto& expr =
+      createAstFromSubfieldFilter(subfield, *filter, tree, scalars, rowType);
+  ASSERT_GT(tree.size(), 0UL);
+
+  size_t expectedScalars = 0;
+  for (auto v : p.values) {
+    if (isRepresentableForKind(v, p.kind)) {
+      expectedScalars++;
+    }
+  }
+  EXPECT_EQ(scalars.size(), expectedScalars)
+      << "Scalar count mismatch for IN list with kind " << p.kind;
+
+  auto vec = makeTestVector(rowType, 100);
+  testFilterExecution(rowType, columnName, *filter, vec, expr);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    IntegerInList,
+    IntInListParamTest,
+    ::testing::Values(
+        IntInListCase{TypeKind::BIGINT, {1, 2, 5, 7}, "BigintBasic"},
+        IntInListCase{TypeKind::INTEGER, {1, 2, 5, 7}, "Int32Basic"},
+        IntInListCase{TypeKind::SMALLINT, {-10, 0, 32767}, "SmallIntBasic"},
+        IntInListCase{TypeKind::TINYINT, {-128, 0, 127}, "TinyIntBasic"},
+        IntInListCase{
+            TypeKind::INTEGER,
+            {static_cast<int64_t>(std::numeric_limits<int32_t>::max()),
+             static_cast<int64_t>(std::numeric_limits<int32_t>::max()) + 1},
+            "Int32MixedOutOfRange"},
+        IntInListCase{
+            TypeKind::SMALLINT,
+            {static_cast<int64_t>(std::numeric_limits<int16_t>::max()) + 1000,
+             static_cast<int64_t>(std::numeric_limits<int16_t>::min()) - 1000},
+            "SmallIntAllOutOfRange"},
+        IntInListCase{
+            TypeKind::TINYINT,
+            {1000, -1000},
+            "TinyIntAllOutOfRange"}),
+    [](const ::testing::TestParamInfo<IntInListCase>& info) {
+      return std::string(info.param.name);
+    });
+
+} // namespace
diff --git a/velox/experimental/cudf/tests/TableScanTest.cpp b/velox/experimental/cudf/tests/TableScanTest.cpp
new file mode 100644
index 000000000000..14981be10e10
--- /dev/null
+++ b/velox/experimental/cudf/tests/TableScanTest.cpp
@@ -0,0 +1,548 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.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/HiveConnector.h"
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/dwio/common/tests/utils/DataFiles.h"
+#include "velox/exec/Exchange.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/TableScan.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/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/expression/ExprToSubfieldFilter.h"
+#include "velox/type/Type.h"
+#include "velox/type/tests/SubfieldFiltersBuilder.h"
+
+#include <fmt/ranges.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::connector;
+using namespace facebook::velox::core;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::test;
+using namespace facebook::velox::tests::utils;
+using namespace facebook::velox::cudf_velox;
+using namespace facebook::velox::cudf_velox::exec;
+using namespace facebook::velox::cudf_velox::exec::test;
+
+class TableScanTest : public virtual CudfHiveConnectorTestBase {
+ protected:
+  void SetUp() override {
+    CudfHiveConnectorTestBase::SetUp();
+    ExchangeSource::factories().clear();
+    ExchangeSource::registerFactory(createLocalExchangeSource);
+  }
+
+  static void SetUpTestCase() {
+    CudfHiveConnectorTestBase::SetUpTestCase();
+  }
+
+  std::vector<RowVectorPtr> makeVectors(
+      int32_t count,
+      int32_t rowsPerVector,
+      const RowTypePtr& rowType = nullptr) {
+    auto inputs = rowType ? rowType : rowType_;
+    return CudfHiveConnectorTestBase::makeVectors(inputs, count, rowsPerVector);
+  }
+
+  Split makeCudfHiveSplit(std::string path, int64_t splitWeight = 0) {
+    return Split(makeCudfHiveConnectorSplit(std::move(path), splitWeight));
+  }
+
+  std::shared_ptr<Task> assertQuery(
+      const PlanNodePtr& plan,
+      const std::shared_ptr<facebook::velox::connector::ConnectorSplit>&
+          parquetSplit,
+      const std::string& duckDbSql) {
+    return OperatorTestBase::assertQuery(plan, {parquetSplit}, duckDbSql);
+  }
+
+  std::shared_ptr<Task> assertQuery(
+      const PlanNodePtr& plan,
+      const Split&& split,
+      const std::string& duckDbSql) {
+    return OperatorTestBase::assertQuery(plan, {split}, duckDbSql);
+  }
+
+  std::shared_ptr<Task> assertQuery(
+      const PlanNodePtr& plan,
+      const std::vector<std::shared_ptr<TempFilePath>>& filePaths,
+      const std::string& duckDbSql) {
+    return CudfHiveConnectorTestBase::assertQuery(plan, filePaths, duckDbSql);
+  }
+
+  // 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, false)
+        .config(core::QueryConfig::kAggregationSpillEnabled, false)
+        .splits(makeCudfHiveConnectorSplits(filePaths))
+        .assertResults(duckDbSql);
+  }
+
+  core::PlanNodePtr tableScanNode() {
+    return tableScanNode(rowType_);
+  }
+
+  core::PlanNodePtr tableScanNode(const RowTypePtr& outputType) {
+    auto tableHandle = makeTableHandle();
+    return PlanBuilder(pool_.get())
+        .startTableScan()
+        .outputType(outputType)
+        .tableHandle(tableHandle)
+        .endTableScan()
+        .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) {
+    VELOX_NYI(
+        "RuntimeStats not yet implemented for the cudf CudfHiveConnector");
+    // return task->taskStats().pipelineStats[0].operatorStats[0].runtimeStats;
+  }
+
+  static int64_t getSkippedStridesStat(const std::shared_ptr<Task>& task) {
+    VELOX_NYI(
+        "RuntimeStats not yet implemented for the cudf CudfHiveConnector");
+    // return getTableScanRuntimeStats(task)["skippedStrides"].sum;
+  }
+
+  static int64_t getSkippedSplitsStat(const std::shared_ptr<Task>& task) {
+    VELOX_NYI(
+        "RuntimeStats not yet implemented for the cudf CudfHiveConnector");
+    // 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());
+  }
+
+  RowTypePtr rowType_{
+      ROW({"c0", "c1", "c2", "c3", "c4", "c5", "c6"},
+          {INTEGER(),
+           VARCHAR(),
+           TINYINT(),
+           DOUBLE(),
+           BIGINT(),
+           VARCHAR(),
+           REAL()})};
+};
+
+TEST_F(TableScanTest, allColumns) {
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors, "c");
+
+  createDuckDbTable(vectors);
+  auto plan = tableScanNode();
+
+  const std::string duckDbSql = "SELECT * FROM tmp";
+
+  // Helper to test scan all columns for the given splits
+  auto testScanAllColumns =
+      [&](const std::vector<std::shared_ptr<
+              facebook::velox::connector::ConnectorSplit>>& splits) {
+        auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                        .plan(plan)
+                        .splits(splits)
+                        .assertResults(duckDbSql);
+
+        // 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());
+        // TODO (dm): enable this test once we start to track gpu memory
+        // ASSERT_TRUE(it->second.peakMemoryBytes > 0);
+
+        //  Verifies there is no dynamic filter stats.
+        ASSERT_TRUE(it->second.dynamicFilterStats.empty());
+
+        // TODO: We are not writing any customStats yet so disable this check
+        // ASSERT_LT(0, it->second.customStats.at("ioWaitWallNanos").sum);
+      };
+
+  // Test scan all columns with CudfHiveConnectorSplits
+  {
+    auto splits = makeCudfHiveConnectorSplits({filePath});
+    testScanAllColumns(splits);
+  }
+
+  // Test scan all columns with HiveConnectorSplits
+  {
+    // Lambda to create HiveConnectorSplits from file paths
+    auto makeHiveConnectorSplits =
+        [&](const std::vector<std::shared_ptr<
+                facebook::velox::exec::test::TempFilePath>>& filePaths) {
+          std::vector<
+              std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+              splits;
+          for (const auto& filePath : filePaths) {
+            splits.push_back(
+                facebook::velox::connector::hive::HiveConnectorSplitBuilder(
+                    filePath->getPath())
+                    .connectorId(kCudfHiveConnectorId)
+                    .fileFormat(dwio::common::FileFormat::PARQUET)
+                    .build());
+          }
+          return splits;
+        };
+
+    auto splits = makeHiveConnectorSplits({filePath});
+    testScanAllColumns(splits);
+  }
+}
+
+TEST_F(TableScanTest, allColumnsUsingFileDataSource) {
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors, "c");
+
+  createDuckDbTable(vectors);
+  auto plan = tableScanNode();
+
+  const std::string duckDbSql = "SELECT * FROM tmp";
+
+  // Reset the CudfHiveConnector config to not buffered input data source
+  auto config = std::unordered_map<std::string, std::string>{
+      {facebook::velox::cudf_velox::connector::hive::CudfHiveConfig::
+           kUseBufferedInput,
+       "false"}};
+  resetCudfHiveConnector(
+      std::make_shared<config::ConfigBase>(std::move(config)));
+  auto splits = makeCudfHiveConnectorSplits({filePath});
+  auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                  .plan(plan)
+                  .splits(splits)
+                  .assertResults(duckDbSql);
+
+  // 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());
+  // TODO (dm): enable this test once we start to track gpu memory
+  // ASSERT_TRUE(it->second.peakMemoryBytes > 0);
+
+  //  Verifies there is no dynamic filter stats.
+  ASSERT_TRUE(it->second.dynamicFilterStats.empty());
+
+  // TODO: We are not writing any customStats yet so disable this check
+  // ASSERT_LT(0, it->second.customStats.at("ioWaitWallNanos").sum);
+}
+
+TEST_F(TableScanTest, allColumnsUsingExperimentalReader) {
+  auto vectors = makeVectors(10, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors, "c");
+
+  createDuckDbTable(vectors);
+  const std::string duckDbSql =
+      "SELECT * FROM tmp UNION ALL "
+      "SELECT * FROM tmp UNION ALL "
+      "SELECT * FROM tmp UNION ALL "
+      "SELECT * FROM tmp UNION ALL "
+      "SELECT * FROM tmp";
+
+  auto splits = makeCudfHiveConnectorSplits(
+      {filePath, filePath, filePath, filePath, filePath});
+
+  // Helper to test scan all columns for the given splits
+  auto testScanAllColumnsUsingExperimentalReader =
+      [&](const core::PlanNodePtr& plan) {
+        auto task = AssertQueryBuilder(duckDbQueryRunner_)
+                        .plan(plan)
+                        .splits(splits)
+                        .assertResults(duckDbSql);
+
+        // 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());
+        // TODO (dm): enable this test once we start to track gpu memory
+        // ASSERT_TRUE(it->second.peakMemoryBytes > 0);
+
+        //  Verifies there is no dynamic filter stats.
+        ASSERT_TRUE(it->second.dynamicFilterStats.empty());
+
+        // TODO: We are not writing any customStats yet so disable this check
+        // ASSERT_LT(0, it->second.customStats.at("ioWaitWallNanos").sum);
+      };
+
+  // Reset the CudfHiveConnector config to use the experimental reader
+  auto config = std::unordered_map<std::string, std::string>{
+      {facebook::velox::cudf_velox::connector::hive::CudfHiveConfig::
+           kUseExperimentalCudfReader,
+       "true"}};
+  resetCudfHiveConnector(
+      std::make_shared<config::ConfigBase>(std::move(config)));
+
+  // Test scan all columns with buffered input datasource(s)
+  {
+    auto plan = tableScanNode();
+    testScanAllColumnsUsingExperimentalReader(plan);
+  }
+
+  // Test scan all columns with kvikIO datasource(s)
+  {
+    config.insert(
+        {facebook::velox::cudf_velox::connector::hive::CudfHiveConfig::
+             kUseBufferedInput,
+         "false"});
+    resetCudfHiveConnector(
+        std::make_shared<config::ConfigBase>(std::move(config)));
+    auto plan = tableScanNode();
+    testScanAllColumnsUsingExperimentalReader(plan);
+  }
+}
+
+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}, "c");
+
+  auto tableHandle = makeTableHandle();
+  auto plan = PlanBuilder(pool_.get())
+                  .startTableScan()
+                  .tableHandle(tableHandle)
+                  .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(makeCudfHiveConnectorSplits({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;
+  // Reduced from 500 to 400 as cudf CudfHive writer seems to be writing smaller
+  // files.
+  ASSERT_GE(rawInputBytes, 400);
+
+  // TableScan runtime stats not available with CudfHive connector yet
+#if 0
+  auto overreadBytes =
+  getTableScanRuntimeStats(task).at("overreadBytes").sum;
+  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);
+#endif
+}
+
+TEST_F(TableScanTest, columnAliases) {
+  auto vectors = makeVectors(1, 1'000);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors, "c");
+  createDuckDbTable(vectors);
+
+  std::string tableName = "t";
+  std::unordered_map<std::string, std::string> aliases = {{"a", "c0"}};
+  auto outputType = ROW({"a"}, {INTEGER()});
+  auto tableHandle = makeTableHandle();
+  auto op = PlanBuilder(pool_.get())
+                .startTableScan()
+                .tableHandle(tableHandle)
+                .tableName(tableName)
+                .outputType(outputType)
+                .columnAliases(aliases)
+                .endTableScan()
+                .planNode();
+  assertQuery(op, {filePath}, "SELECT c0 FROM tmp");
+}
+
+TEST_F(TableScanTest, filterPushdown) {
+  auto rowType =
+      ROW({"c0", "c1", "c2", "c3"}, {TINYINT(), BIGINT(), 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]->getPath(), vectors[i]);
+  }
+  createDuckDbTable(vectors);
+
+  // c1 >= 0 or null and c3 is true
+  common::SubfieldFilters subfieldFilters =
+      common::test::SubfieldFiltersBuilder()
+          .add(
+              "c1",
+              std::make_unique<common::BigintRange>(
+                  int64_t(0), std::numeric_limits<int64_t>::max(), true))
+          .add("c3", std::make_unique<common::BoolValue>(true, false))
+          .build();
+
+  auto tableHandle = makeTableHandle(
+      "parquet_table", rowType, true, std::move(subfieldFilters), nullptr);
+
+  auto assignments =
+      facebook::velox::exec::test::HiveConnectorTestBase::allRegularColumns(
+          rowType);
+
+  auto task = assertQuery(
+      PlanBuilder()
+          .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 ) AND c3");
+
+  auto tableScanStats = getTableScanStats(task);
+  // EXPECT_EQ(tableScanStats.rawInputRows, 10'000);
+  // EXPECT_LT(tableScanStats.inputRows, tableScanStats.rawInputRows);
+  EXPECT_EQ(tableScanStats.inputRows, tableScanStats.outputRows);
+
+#if 0
+  // Repeat the same but do not project out the filtered columns.
+  assignments.clear();
+  assignments["c0"] =
+      facebook::velox::exec::test::HiveConnectorTestBase::regularColumn(
+          "c0", TINYINT());
+  assertQuery(
+      PlanBuilder()
+          .startTableScan()
+          .outputType(ROW({"c0"}, {TINYINT()}))
+          .tableHandle(tableHandle)
+          .assignments(assignments)
+          .endTableScan()
+          .planNode(),
+      filePaths,
+      "SELECT c0 FROM tmp WHERE (c1 >= 0 ) AND c3");
+
+  // TODO: zero column non-empty table is not possible in cudf, need to implement.
+  // Do the same for count, no columns projected out.
+  assignments.clear();
+  assertQuery(
+      PlanBuilder()
+          .startTableScan()
+          .outputType(ROW({}, {}))
+          .tableHandle(tableHandle)
+          .assignments(assignments)
+          .endTableScan()
+          .singleAggregation({}, {"sum(1)"})
+          .planNode(),
+      filePaths,
+      "SELECT count(*) FROM tmp WHERE (c1 >= 0 ) AND c3");
+
+  // Do the same for count, no filter, no projections.
+  assignments.clear();
+  // subfieldFilters.clear(); // Explicitly clear this.
+  tableHandle = makeTableHandle(
+      "parquet_table",
+      rowType,
+      false,
+      nullptr,
+      nullptr);
+  assertQuery(
+      PlanBuilder()
+          .startTableScan()
+          .outputType(ROW({}, {}))
+          .tableHandle(tableHandle)
+          .assignments(assignments)
+          .endTableScan()
+          .singleAggregation({}, {"sum(1)"})
+          .planNode(),
+      filePaths,
+      "SELECT count(*) FROM tmp");
+#endif
+}
+
+TEST_F(TableScanTest, splitOffset) {
+  auto vectors = makeVectors(1, 10);
+  auto filePath = TempFilePath::create();
+  writeToFile(filePath->getPath(), vectors);
+
+  auto plan = tableScanNode();
+
+  auto split = facebook::velox::connector::hive::HiveConnectorSplitBuilder(
+                   filePath->getPath())
+                   .connectorId(kCudfHiveConnectorId)
+                   .start(1)
+                   .fileFormat(dwio::common::FileFormat::PARQUET)
+                   .build();
+
+  VELOX_ASSERT_THROW(
+      AssertQueryBuilder(duckDbQueryRunner_)
+          .plan(plan)
+          .splits({split})
+          .assertEmptyResults(),
+      "CudfHiveDataSource cannot process splits with non-zero offset");
+}
diff --git a/velox/experimental/cudf/tests/TableWriteTest.cpp b/velox/experimental/cudf/tests/TableWriteTest.cpp
new file mode 100644
index 000000000000..1a72f6ed51a3
--- /dev/null
+++ b/velox/experimental/cudf/tests/TableWriteTest.cpp
@@ -0,0 +1,831 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnectorSplit.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveTableHandle.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
+#include "velox/experimental/cudf/tests/utils/CudfPlanBuilder.h"
+
+#include "folly/dynamic.h"
+#include "velox/common/base/Fs.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/dwio/common/Options.h"
+#include "velox/dwio/common/WriterFactory.h"
+#include "velox/exec/PlanNodeStats.h"
+#include "velox/exec/TableWriter.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 <gflags/gflags.h>
+#include <re2/re2.h>
+
+#include <string>
+
+using namespace facebook::velox;
+using namespace facebook::velox::core;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::common;
+using namespace facebook::velox::connector;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::test;
+using namespace facebook::velox::common::testutil;
+using namespace facebook::velox::dwio::common;
+
+using namespace facebook::velox::cudf_velox;
+using namespace facebook::velox::cudf_velox::exec;
+using namespace facebook::velox::cudf_velox::exec::test;
+
+constexpr uint64_t kQueryMemoryCapacity = 512 * MB;
+
+DEFINE_bool(velox_cudf_debug, false, "Enable debug printing");
+
+namespace {
+
+static core::ColumnStatsSpec generateColumnStatsSpec(
+    const std::string& name,
+    const std::vector<core::FieldAccessTypedExprPtr>& groupingKeys,
+    AggregationNode::Step step) {
+  core::TypedExprPtr inputField =
+      std::make_shared<const core::FieldAccessTypedExpr>(BIGINT(), name);
+  auto callExpr =
+      std::make_shared<const core::CallTypedExpr>(BIGINT(), "min", inputField);
+  std::vector<std::string> aggregateNames = {"min"};
+  std::vector<core::AggregationNode::Aggregate> aggregates = {
+      core::AggregationNode::Aggregate{
+          callExpr, {{BIGINT()}}, nullptr, {}, {}}};
+  return core::ColumnStatsSpec{groupingKeys, step, aggregateNames, aggregates};
+}
+
+} // namespace
+
+enum class TestMode {
+  kUnpartitioned,
+};
+
+std::string testModeString(TestMode mode) {
+  switch (mode) {
+    case TestMode::kUnpartitioned:
+      return "UNPARTITIONED";
+  }
+  VELOX_UNREACHABLE();
+}
+
+FOLLY_ALWAYS_INLINE std::ostream& operator<<(std::ostream& os, TestMode mode) {
+  os << testModeString(mode);
+  return os;
+}
+
+// NOTE: google parameterized test framework can't handle complex test
+// parameters properly. So we encode the different test parameters into one
+// integer value.
+struct TestParam {
+  uint64_t value;
+
+  explicit TestParam(uint64_t value) : value(value) {}
+
+  TestParam(
+      FileFormat fileFormat,
+      TestMode testMode,
+      CommitStrategy commitStrategy,
+      bool multiDrivers,
+      CompressionKind compressionKind) {
+    value = static_cast<uint64_t>(compressionKind) << 32 |
+        static_cast<uint64_t>(static_cast<bool>(multiDrivers)) << 24 |
+        static_cast<uint64_t>(fileFormat) << 16 |
+        static_cast<uint64_t>(testMode) << 8 |
+        static_cast<uint64_t>(commitStrategy);
+  }
+
+  CompressionKind compressionKind() const {
+    return static_cast<CompressionKind>((value & ((1L << 40) - 1)) >> 32);
+  }
+
+  bool multiDrivers() const {
+    return (value >> 24) != 0;
+  }
+
+  FileFormat fileFormat() const {
+    return static_cast<FileFormat>((value & ((1L << 24) - 1)) >> 16);
+  }
+
+  TestMode testMode() const {
+    return static_cast<TestMode>((value & ((1L << 16) - 1)) >> 8);
+  }
+
+  CommitStrategy commitStrategy() const {
+    return static_cast<CommitStrategy>((value & ((1L << 8) - 1)));
+  }
+
+  std::string toString() const {
+    return fmt::format(
+        "FileFormat[{}] TestMode[{}] commitStrategy[{}] multiDrivers[{}] compression[{}]",
+        dwio::common::toString((fileFormat())),
+        testModeString(testMode()),
+        CommitStrategyName::toName(commitStrategy()),
+        multiDrivers(),
+        compressionKindToString(compressionKind()));
+  }
+};
+
+class TableWriteTest : public CudfHiveConnectorTestBase {
+ protected:
+  explicit TableWriteTest(uint64_t testValue)
+      : testParam_(static_cast<TestParam>(testValue)),
+        fileFormat_(dwio::common::FileFormat::PARQUET),
+        testMode_(testParam_.testMode()),
+        numTableWriterCount_(
+            testParam_.multiDrivers() ? kNumTableWriterCount : 1),
+        commitStrategy_(testParam_.commitStrategy()),
+        compressionKind_(testParam_.compressionKind()) {
+    LOG(INFO) << testParam_.toString();
+    if (FLAGS_velox_cudf_debug) {
+      std::cout << testParam_.toString() << std::endl;
+    }
+
+    auto rowType =
+        ROW({"c0", "c1", "c2", "c3", "c4", "c5"},
+            {BIGINT(), INTEGER(), SMALLINT(), REAL(), DOUBLE(), VARCHAR()});
+    setDataTypes(rowType);
+  }
+
+  void SetUp() override {
+    CudfHiveConnectorTestBase::SetUp();
+  }
+
+  std::shared_ptr<Task> assertQueryWithWriterConfigs(
+      const core::PlanNodePtr& plan,
+      std::vector<std::shared_ptr<TempFilePath>> filePaths,
+      const std::string& duckDbSql,
+      bool spillEnabled = false) {
+    std::vector<Split> splits;
+    for (const auto& filePath : filePaths) {
+      splits.push_back(
+          facebook::velox::exec::Split(
+              makeCudfHiveConnectorSplit(filePath->getPath())));
+    }
+    if (!spillEnabled) {
+      return AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .maxDrivers(2 * kNumTableWriterCount)
+          .config(
+              QueryConfig::kTaskWriterCount,
+              std::to_string(numTableWriterCount_))
+          .splits(splits)
+          .assertResults(duckDbSql);
+    }
+  }
+
+  std::shared_ptr<Task> assertQueryWithWriterConfigs(
+      const core::PlanNodePtr& plan,
+      const std::string& duckDbSql,
+      bool enableSpill = false) {
+    if (!enableSpill) {
+      TestScopedSpillInjection scopedSpillInjection(100);
+      return AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .maxDrivers(2 * kNumTableWriterCount)
+          .config(
+              QueryConfig::kTaskWriterCount,
+              std::to_string(numTableWriterCount_))
+          .config(core::QueryConfig::kSpillEnabled, "true")
+          .config(QueryConfig::kWriterSpillEnabled, "true")
+          // Scale writer settings to trigger partition rebalancing.
+          .config(QueryConfig::kScaleWriterRebalanceMaxMemoryUsageRatio, "1.0")
+          .config(
+              QueryConfig::kScaleWriterMinProcessedBytesRebalanceThreshold, "0")
+          .config(
+              QueryConfig::
+                  kScaleWriterMinPartitionProcessedBytesRebalanceThreshold,
+              "0")
+          .assertResults(duckDbSql);
+    }
+  }
+
+  RowVectorPtr runQueryWithWriterConfigs(
+      const core::PlanNodePtr& plan,
+      bool spillEnabled = false) {
+    if (!spillEnabled) {
+      return AssertQueryBuilder(plan, duckDbQueryRunner_)
+          .maxDrivers(2 * kNumTableWriterCount)
+          .config(
+              QueryConfig::kTaskWriterCount,
+              std::to_string(numTableWriterCount_))
+          // Scale writer settings to trigger partition rebalancing.
+          .config(QueryConfig::kScaleWriterRebalanceMaxMemoryUsageRatio, "1.0")
+          .config(
+              QueryConfig::kScaleWriterMinProcessedBytesRebalanceThreshold, "0")
+          .config(
+              QueryConfig::
+                  kScaleWriterMinPartitionProcessedBytesRebalanceThreshold,
+              "0")
+          .copyResults(pool());
+    }
+  }
+
+  void setCommitStrategy(CommitStrategy commitStrategy) {
+    commitStrategy_ = commitStrategy;
+  }
+
+  void setDataTypes(
+      const RowTypePtr& inputType,
+      const RowTypePtr& tableSchema = nullptr) {
+    rowType_ = inputType;
+    if (tableSchema != nullptr) {
+      setTableSchema(tableSchema);
+    } else {
+      setTableSchema(rowType_);
+    }
+  }
+
+  void setTableSchema(const RowTypePtr& tableSchema) {
+    tableSchema_ = tableSchema;
+  }
+
+  std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+  makeCudfHiveConnectorSplits(
+      const std::shared_ptr<TempDirectoryPath>& directoryPath) {
+    return makeCudfHiveConnectorSplits(directoryPath->getPath());
+  }
+
+  std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+  makeCudfHiveConnectorSplits(const std::string& directoryPath) {
+    std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+        splits;
+
+    for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
+      if (path.is_regular_file()) {
+        splits.push_back(
+            CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
+                path.path().string(), 1)[0]);
+      }
+    }
+
+    return splits;
+  }
+
+  // Lists and returns all the regular files from a given directory recursively.
+  std::vector<std::string> listAllFiles(const std::string& directoryPath) {
+    std::vector<std::string> files;
+    for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
+      if (path.is_regular_file()) {
+        files.push_back(path.path().filename());
+      }
+    }
+    return files;
+  }
+
+  // Builds and returns the parquet splits from the list of files with one split
+  // per each file.
+  std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+  makeCudfHiveConnectorSplits(
+      const std::vector<std::filesystem::path>& filePaths) {
+    std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+        splits;
+    for (const auto& filePath : filePaths) {
+      splits.push_back(
+          CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
+              filePath.string(), 1)[0]);
+    }
+    return splits;
+  }
+
+  std::vector<RowVectorPtr> makeVectors(
+      int32_t numVectors,
+      int32_t rowsPerVector) {
+    return CudfHiveConnectorTestBase::makeVectors(
+        rowType_, numVectors, rowsPerVector);
+  }
+
+  RowVectorPtr makeConstantVector(size_t size) {
+    return makeRowVector(
+        rowType_->names(),
+        {makeConstant((int64_t)123'456, size),
+         makeConstant((int32_t)321, size),
+         makeConstant((int16_t)12'345, size),
+         makeConstant(variant(TypeKind::REAL), size),
+         makeConstant((double)1'234.01, size),
+         makeConstant(variant(TypeKind::VARCHAR), size)});
+  }
+
+  std::vector<RowVectorPtr> makeBatches(
+      vector_size_t numBatches,
+      std::function<RowVectorPtr(int32_t)> makeVector) {
+    std::vector<RowVectorPtr> batches;
+    batches.reserve(numBatches);
+    for (int32_t i = 0; i < numBatches; ++i) {
+      batches.push_back(makeVector(i));
+    }
+    return batches;
+  }
+
+  std::set<std::string> getLeafSubdirectories(
+      const std::string& directoryPath) {
+    std::set<std::string> subdirectories;
+    for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
+      if (path.is_regular_file()) {
+        subdirectories.emplace(path.path().parent_path().string());
+      }
+    }
+    return subdirectories;
+  }
+
+  std::vector<std::string> getRecursiveFiles(const std::string& directoryPath) {
+    std::vector<std::string> files;
+    for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
+      if (path.is_regular_file()) {
+        files.push_back(path.path().string());
+      }
+    }
+    return files;
+  }
+
+  uint32_t countRecursiveFiles(const std::string& directoryPath) {
+    return getRecursiveFiles(directoryPath).size();
+  }
+
+  // Helper method to return InsertTableHandle.
+  std::shared_ptr<core::InsertTableHandle> createInsertTableHandle(
+      const RowTypePtr& outputRowType,
+      const cudf_velox::connector::hive::LocationHandle::TableType&
+          outputTableType,
+      const std::string& outputDirectoryPath,
+      const std::optional<CompressionKind> compressionKind = {}) {
+    return std::make_shared<core::InsertTableHandle>(
+        kCudfHiveConnectorId,
+        makeCudfHiveInsertTableHandle(
+            outputRowType->names(),
+            outputRowType->children(),
+            makeLocationHandle(outputDirectoryPath, outputTableType),
+            compressionKind));
+  }
+
+  // Returns a table insert plan node.
+  PlanNodePtr createInsertPlan(
+      PlanBuilder& inputPlan,
+      const RowTypePtr& outputRowType,
+      const std::string& outputDirectoryPath,
+      const std::optional<CompressionKind> compressionKind = {},
+      int numTableWriters = 1,
+      const cudf_velox::connector::hive::LocationHandle::TableType&
+          outputTableType =
+              cudf_velox::connector::hive::LocationHandle::TableType::kNew,
+      const CommitStrategy& outputCommitStrategy = CommitStrategy::kNoCommit,
+      bool aggregateResult = true,
+      std::shared_ptr<core::AggregationNode> aggregationNode = nullptr) {
+    std::optional<core::ColumnStatsSpec> columnStatsSpec = std::nullopt;
+    if (aggregationNode != nullptr) {
+      // Convert AggregationNode to ColumnStatsSpec
+      VELOX_CHECK(!aggregationNode->ignoreNullKeys());
+      VELOX_CHECK(!aggregationNode->groupId().has_value());
+      VELOX_CHECK(!aggregationNode->isPreGrouped());
+      VELOX_CHECK(aggregationNode->globalGroupingSets().empty());
+      VELOX_CHECK(!aggregationNode->aggregateNames().empty());
+      VELOX_CHECK_EQ(
+          aggregationNode->aggregateNames().size(),
+          aggregationNode->aggregates().size());
+      columnStatsSpec = core::ColumnStatsSpec{
+          aggregationNode->groupingKeys(),
+          aggregationNode->step(),
+          aggregationNode->aggregateNames(),
+          aggregationNode->aggregates()};
+    }
+    return createInsertPlan(
+        inputPlan,
+        inputPlan.planNode()->outputType(),
+        outputRowType,
+        outputDirectoryPath,
+        compressionKind,
+        numTableWriters,
+        outputTableType,
+        outputCommitStrategy,
+        aggregateResult,
+        columnStatsSpec);
+  }
+
+  PlanNodePtr createInsertPlan(
+      PlanBuilder& inputPlan,
+      const RowTypePtr& inputRowType,
+      const RowTypePtr& tableRowType,
+      const std::string& outputDirectoryPath,
+      const std::optional<CompressionKind> compressionKind = {},
+      int numTableWriters = 1,
+      const cudf_velox::connector::hive::LocationHandle::TableType&
+          outputTableType =
+              cudf_velox::connector::hive::LocationHandle::TableType::kNew,
+      const CommitStrategy& outputCommitStrategy = CommitStrategy::kNoCommit,
+      bool aggregateResult = true,
+      std::optional<core::ColumnStatsSpec> columnStatsSpec = std::nullopt) {
+    VELOX_CHECK(
+        numTableWriters == 1, "Multiple CudfTableWriters not yet supported");
+    return createInsertPlanWithSingleWriter(
+        inputPlan,
+        inputRowType,
+        tableRowType,
+        outputDirectoryPath,
+        compressionKind,
+        outputTableType,
+        outputCommitStrategy,
+        aggregateResult,
+        columnStatsSpec);
+  }
+
+  PlanNodePtr createInsertPlanWithSingleWriter(
+      PlanBuilder& inputPlan,
+      const RowTypePtr& inputRowType,
+      const RowTypePtr& tableRowType,
+      const std::string& outputDirectoryPath,
+      const std::optional<CompressionKind> compressionKind,
+      const cudf_velox::connector::hive::LocationHandle::TableType&
+          outputTableType,
+      const CommitStrategy& outputCommitStrategy,
+      bool aggregateResult,
+      std::optional<core::ColumnStatsSpec> columnStatsSpec) {
+    const bool addScaleWriterExchange = false;
+    auto insertPlan = inputPlan;
+    insertPlan
+        .addNode(addCudfTableWriter(
+            inputRowType,
+            tableRowType->names(),
+            columnStatsSpec,
+            createInsertTableHandle(
+                tableRowType,
+                outputTableType,
+                outputDirectoryPath,
+                compressionKind),
+            outputCommitStrategy))
+        .capturePlanNodeId(tableWriteNodeId_);
+    if (aggregateResult) {
+      insertPlan.project({TableWriteTraits::rowCountColumnName()})
+          .singleAggregation(
+              {},
+              {fmt::format("sum({})", TableWriteTraits::rowCountColumnName())});
+    }
+    return insertPlan.planNode();
+  }
+
+  // Return the corresponding column names in 'inputRowType' of
+  // 'tableColumnNames' from 'tableRowType'.
+  static std::vector<std::string> inputColumnNames(
+      const std::vector<std::string>& tableColumnNames,
+      const RowTypePtr& tableRowType,
+      const RowTypePtr& inputRowType) {
+    std::vector<std::string> inputNames;
+    inputNames.reserve(tableColumnNames.size());
+    for (const auto& tableColumnName : tableColumnNames) {
+      const auto columnIdx = tableRowType->getChildIdx(tableColumnName);
+      inputNames.push_back(inputRowType->nameOf(columnIdx));
+    }
+    return inputNames;
+  }
+
+  // Parameter partitionName is string formatted in the CudfHive 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
+  // predicate with values single quoted for string and date and not quoted for
+  // other supported types, ex., key1='value1' AND key2=value2 AND ...
+  std::string partitionNameToPredicate(
+      const std::string& partitionName,
+      const std::vector<TypePtr>& partitionTypes) {
+    std::vector<std::string> conjuncts;
+
+    std::vector<std::string> partitionKeyValues;
+    folly::split('/', partitionName, partitionKeyValues);
+    VELOX_CHECK_EQ(partitionKeyValues.size(), partitionTypes.size());
+
+    for (auto i = 0; i < partitionKeyValues.size(); ++i) {
+      if (partitionTypes[i]->isVarchar() || partitionTypes[i]->isVarbinary() ||
+          partitionTypes[i]->isDate()) {
+        conjuncts.push_back(
+            partitionKeyValues[i]
+                .replace(partitionKeyValues[i].find("="), 1, "='")
+                .append("'"));
+      } else {
+        conjuncts.push_back(partitionKeyValues[i]);
+      }
+    }
+
+    return folly::join(" AND ", conjuncts);
+  }
+
+  // Verifies if a unbucketed file name is encoded properly based on the
+  // used commit strategy.
+  void verifyUnbucketedFilePath(
+      const std::filesystem::path& filePath,
+      const std::string& targetDir) {
+    ASSERT_EQ(filePath.parent_path().string(), targetDir);
+    if (commitStrategy_ == CommitStrategy::kNoCommit) {
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(),
+              fmt::format(
+                  "test_cursor.+_[0-{}]_{}_.+",
+                  numTableWriterCount_ - 1,
+                  tableWriteNodeId_)))
+          << filePath.filename().string();
+    } else {
+      ASSERT_TRUE(
+          RE2::FullMatch(
+              filePath.filename().string(),
+              fmt::format(
+                  ".tmp.velox.test_cursor.+_[0-{}]_{}_.+",
+                  numTableWriterCount_ - 1,
+                  tableWriteNodeId_)))
+          << filePath.filename().string();
+    }
+  }
+
+  // Verifies the file layout and data produced by a table writer.
+  void verifyTableWriterOutput(
+      const std::string& targetDir,
+      const RowTypePtr& bucketCheckFileType,
+      bool verifyPartitionedData = true,
+      bool verifyBucketedData = true) {
+    SCOPED_TRACE(testParam_.toString());
+    std::vector<std::filesystem::path> filePaths;
+    std::vector<std::filesystem::path> dirPaths;
+    for (auto& path : fs::recursive_directory_iterator(targetDir)) {
+      if (path.is_regular_file()) {
+        filePaths.push_back(path.path());
+      } else {
+        dirPaths.push_back(path.path());
+      }
+    }
+    if (testMode_ == TestMode::kUnpartitioned) {
+      ASSERT_EQ(dirPaths.size(), 0);
+      ASSERT_LE(filePaths.size(), numTableWriterCount_);
+      verifyUnbucketedFilePath(filePaths[0], targetDir);
+      return;
+    }
+  }
+
+  int getNumWriters() {
+    return numTableWriterCount_;
+  }
+
+  static inline int kNumTableWriterCount = 1;
+
+  const TestParam testParam_;
+  const FileFormat fileFormat_ = FileFormat::PARQUET;
+  const TestMode testMode_;
+  const int numTableWriterCount_;
+
+  RowTypePtr rowType_;
+  RowTypePtr tableSchema_;
+  CommitStrategy commitStrategy_;
+  std::optional<CompressionKind> compressionKind_;
+  std::vector<column_index_t> sortColumnIndices_;
+  std::vector<CompareFlags> sortedFlags_;
+  core::PlanNodeId tableWriteNodeId_;
+};
+
+class BasicTableWriteTest : public CudfHiveConnectorTestBase {};
+
+TEST_F(BasicTableWriteTest, roundTrip) {
+  vector_size_t size = 1'000;
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(size, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(
+          size, [](auto row) { return row * 2; }, nullEvery(7)),
+  });
+
+  auto sourceFilePath = TempFilePath::create();
+  writeToFile(sourceFilePath->getPath(), data);
+
+  auto targetDirectoryPath = TempDirectoryPath::create();
+
+  auto rowType = asRowType(data->type());
+  auto plan = PlanBuilder()
+                  .startTableScan()
+                  .outputType(rowType)
+                  .tableHandle(CudfHiveConnectorTestBase::makeTableHandle())
+                  .endTableScan()
+                  .addNode(cudfTableWrite(targetDirectoryPath->getPath()))
+                  .planNode();
+
+  auto results =
+      AssertQueryBuilder(plan)
+          .split(makeCudfHiveConnectorSplit(sourceFilePath->getPath()))
+          .copyResults(pool());
+  ASSERT_EQ(2, results->size());
+
+  // First column has number of rows written in the first row and nulls in other
+  // rows.
+  auto rowCount = results->childAt(TableWriteTraits::kRowCountChannel)
+                      ->as<FlatVector<int64_t>>();
+  ASSERT_FALSE(rowCount->isNullAt(0));
+  ASSERT_EQ(size, rowCount->valueAt(0));
+  ASSERT_TRUE(rowCount->isNullAt(1));
+
+  // Second column contains details about written files.
+  auto details = results->childAt(TableWriteTraits::kFragmentChannel)
+                     ->as<FlatVector<StringView>>();
+  ASSERT_TRUE(details->isNullAt(0));
+  ASSERT_FALSE(details->isNullAt(1));
+  folly::dynamic obj = folly::parseJson(details->valueAt(1));
+
+  ASSERT_EQ(size, obj["rowCount"].asInt());
+  auto fileWriteInfos = obj["fileWriteInfos"];
+  ASSERT_EQ(1, fileWriteInfos.size());
+  auto writeFileName = fileWriteInfos[0]["writeFileName"].asString();
+
+  // Read from 'writeFileName' and verify the data matches the original.
+  plan = PlanBuilder()
+             .startTableScan()
+             .outputType(rowType)
+             .tableHandle(CudfHiveConnectorTestBase::makeTableHandle())
+             .endTableScan()
+             .planNode();
+
+  auto copy =
+      AssertQueryBuilder(plan)
+          .split(makeCudfHiveConnectorSplit(
+              fmt::format(
+                  "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
+          .copyResults(pool());
+  assertEqualResults({data}, {copy});
+}
+
+TEST_F(BasicTableWriteTest, targetFileName) {
+  constexpr const char* kFileName = "test.parquet";
+  auto data = makeRowVector({makeFlatVector<int64_t>(10, folly::identity)});
+  auto directory = TempDirectoryPath::create();
+  auto plan = PlanBuilder()
+                  .values({data})
+                  .addNode(cudfTableWrite(
+                      directory->getPath(),
+                      dwio::common::FileFormat::PARQUET,
+                      {},
+                      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()
+             .startTableScan()
+             .outputType(asRowType(data->type()))
+             .tableHandle(CudfHiveConnectorTestBase::makeTableHandle())
+             .endTableScan()
+             .planNode();
+  AssertQueryBuilder(plan)
+      .split(makeCudfHiveConnectorSplit(
+          fmt::format("{}/{}", directory->getPath(), kFileName)))
+      .assertResults(data);
+}
+
+class UnpartitionedTableWriterTest
+    : public TableWriteTest,
+      public testing::WithParamInterface<uint64_t> {
+ public:
+  UnpartitionedTableWriterTest() : TableWriteTest(GetParam()) {}
+
+  static std::vector<uint64_t> getTestParams() {
+    std::vector<uint64_t> testParams;
+    const auto multiDriverOptions = std::vector<bool>{false, true};
+    for (bool multiDrivers : multiDriverOptions) {
+      testParams.push_back(
+          TestParam{
+              FileFormat::PARQUET,
+              TestMode::kUnpartitioned,
+              CommitStrategy::kNoCommit,
+              multiDrivers,
+              CompressionKind_NONE}
+              .value);
+      testParams.push_back(
+          TestParam{
+              FileFormat::PARQUET,
+              TestMode::kUnpartitioned,
+              CommitStrategy::kTaskCommit,
+              multiDrivers,
+              CompressionKind_NONE}
+              .value);
+    }
+    return testParams;
+  }
+};
+
+TEST_P(UnpartitionedTableWriterTest, differentCompression) {
+  std::vector<CompressionKind> compressions{
+      CompressionKind_NONE,
+      CompressionKind_SNAPPY,
+      CompressionKind_ZSTD,
+      CompressionKind_LZ4,
+      CompressionKind_MAX};
+
+  for (auto compressionKind : compressions) {
+    auto input = makeVectors(10, 10);
+    auto outputDirectory = TempDirectoryPath::create();
+    if (compressionKind == CompressionKind_MAX) {
+      VELOX_ASSERT_THROW(
+          createInsertPlan(
+              PlanBuilder().values(input),
+              rowType_,
+              outputDirectory->getPath(),
+              compressionKind,
+              numTableWriterCount_,
+              cudf_velox::connector::hive::LocationHandle::TableType::kNew),
+          "Unsupported compression type: CompressionKind_MAX");
+      return;
+    }
+    auto plan = createInsertPlan(
+        PlanBuilder().values(input),
+        rowType_,
+        outputDirectory->getPath(),
+        compressionKind,
+        numTableWriterCount_,
+        cudf_velox::connector::hive::LocationHandle::TableType::kNew);
+
+    auto result = AssertQueryBuilder(plan)
+                      .config(
+                          QueryConfig::kTaskWriterCount,
+                          std::to_string(numTableWriterCount_))
+                      .copyResults(pool());
+    assertEqualResults(
+        {makeRowVector({makeConstant<int64_t>(100, 1)})}, {result});
+  }
+}
+
+// Test not really needed as we always write a TableType::kNew table in CudfHive
+// DataSink
+TEST_P(UnpartitionedTableWriterTest, immutableSettings) {
+  struct {
+    cudf_velox::connector::hive::LocationHandle::TableType dataType;
+    bool immutableFilesEnabled;
+    bool expectedInsertSuccees;
+
+    std::string debugString() const {
+      return fmt::format(
+          "dataType:{}, immutableFilesEnabled:{}, operationSuccess:{}",
+          dataType,
+          immutableFilesEnabled,
+          expectedInsertSuccees);
+    }
+  } testSettings[] = {
+      {cudf_velox::connector::hive::LocationHandle::TableType::kNew,
+       true,
+       true},
+      {cudf_velox::connector::hive::LocationHandle::TableType::kNew,
+       false,
+       true}};
+
+  for (auto testData : testSettings) {
+    SCOPED_TRACE(testData.debugString());
+    std::unordered_map<std::string, std::string> propFromFile{
+        {"parquet.immutable-files",
+         testData.immutableFilesEnabled ? "true" : "false"}};
+    std::shared_ptr<const config::ConfigBase> config{
+        std::make_shared<config::ConfigBase>(std::move(propFromFile))};
+    resetCudfHiveConnector(config);
+
+    auto input = makeVectors(10, 10);
+    auto outputDirectory = TempDirectoryPath::create();
+    auto plan = createInsertPlan(
+        PlanBuilder().values(input),
+        rowType_,
+        outputDirectory->getPath(),
+        CompressionKind_NONE,
+        numTableWriterCount_,
+        testData.dataType);
+
+    if (!testData.expectedInsertSuccees) {
+      VELOX_ASSERT_THROW(
+          AssertQueryBuilder(plan).copyResults(pool()),
+          "CudfHive tables are immutable.");
+    } else {
+      auto result = AssertQueryBuilder(plan)
+                        .config(
+                            QueryConfig::kTaskWriterCount,
+                            std::to_string(numTableWriterCount_))
+                        .copyResults(pool());
+      assertEqualResults(
+          {makeRowVector({makeConstant<int64_t>(100, 1)})}, {result});
+    }
+  }
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    TableWriterTest,
+    UnpartitionedTableWriterTest,
+    testing::ValuesIn(UnpartitionedTableWriterTest::getTestParams()));
diff --git a/velox/experimental/cudf/tests/TopNTest.cpp b/velox/experimental/cudf/tests/TopNTest.cpp
new file mode 100644
index 000000000000..ea6601da5950
--- /dev/null
+++ b/velox/experimental/cudf/tests/TopNTest.cpp
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/cudf/exec/ToCudf.h"
+
+#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;
+
+class TopNTest : public OperatorTestBase {
+ public:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+    cudf_velox::registerCudf();
+  }
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+    OperatorTestBase::TearDown();
+  }
+
+ protected:
+  static std::vector<std::string> getSortOrderSqls() {
+    return {"NULLS LAST", "NULLS FIRST", "DESC NULLS FIRST", "DESC NULLS LAST"};
+  }
+
+  void testSingleKey(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& key,
+      int32_t limit) {
+    auto keyIndex = input[0]->type()->asRow().getChildIdx(key);
+
+    auto sortOrderSqls = getSortOrderSqls();
+
+    for (const auto& sortOrderSql : sortOrderSqls) {
+      auto sql = fmt::format("{} {}", key, sortOrderSql);
+
+      auto plan =
+          PlanBuilder().values(input).topN({sql}, limit, false).planNode();
+
+      assertQueryOrdered(
+          plan,
+          fmt::format("SELECT * FROM tmp ORDER BY {} LIMIT {}", sql, limit),
+          {keyIndex});
+    }
+  }
+
+  void testSingleKey(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& key,
+      const std::string& filter) {
+    auto keyIndex = input[0]->type()->asRow().getChildIdx(key);
+
+    auto sortOrderSqls = getSortOrderSqls();
+
+    for (const auto& sortOrderSql : sortOrderSqls) {
+      auto sql = fmt::format("{} {}", key, sortOrderSql);
+
+      auto plan = PlanBuilder()
+                      .values(input)
+                      .filter(filter)
+                      .topN({sql}, 10, false)
+                      .planNode();
+
+      assertQueryOrdered(
+          plan,
+          fmt::format(
+              "SELECT * FROM tmp WHERE {} ORDER BY {} LIMIT 10", filter, sql),
+          {keyIndex});
+    }
+  }
+
+  void testTwoKeys(
+      const std::vector<RowVectorPtr>& input,
+      const std::string& key1,
+      const std::string& key2,
+      int32_t limit) {
+    auto& rowType = input[0]->type()->asRow();
+    auto keyIndices = {rowType.getChildIdx(key1), rowType.getChildIdx(key2)};
+
+    auto sortOrderSqls = getSortOrderSqls();
+
+    for (const auto& sortOrderSql1 : sortOrderSqls) {
+      for (const auto& sortOrderSql2 : sortOrderSqls) {
+        auto sql1 = fmt::format("{} {}", key1, sortOrderSql1);
+        auto sql2 = fmt::format("{} {}", key2, sortOrderSql2);
+
+        auto plan = PlanBuilder()
+                        .values(input)
+                        .topN({sql1, sql2}, limit, false)
+                        .planNode();
+
+        assertQueryOrdered(
+            plan,
+            fmt::format(
+                "SELECT * FROM tmp ORDER BY {}, {} LIMIT {}",
+                sql1,
+                sql2,
+                limit),
+            keyIndices);
+      }
+    }
+  }
+};
+
+TEST_F(TopNTest, selectiveFilter) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 3; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize,
+        [&](vector_size_t row) { return batchSize * i + row; },
+        nullEvery(5));
+    auto c1 = makeFlatVector<int64_t>(
+        batchSize, [&](vector_size_t row) { return row; }, nullEvery(5));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  // c0 values are unique across batches
+  testSingleKey(vectors, "c0", "c0 % 333 = 0");
+
+  // c1 values are unique only within a batch
+  testSingleKey(vectors, "c1", "c1 % 333 = 0");
+}
+
+TEST_F(TopNTest, singleKey) {
+  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; }, nullEvery(5));
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1}));
+  }
+  createDuckDbTable(vectors);
+
+  // DESC NULLS LAST and ASC NULLS FIRST will return all rows where c0 is null;
+  // There are 400 rows where c0 is null. Use limit greater than 400 to make the
+  // query deterministic.
+  testSingleKey(vectors, "c0", 410);
+
+  // parser doesn't support "is not null" expression, hence, using c0 % 2 >= 0
+  testSingleKey(vectors, "c0", "c0 % 2 >= 0");
+}
+
+TEST_F(TopNTest, multipleKeys) {
+  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 % 4; }, nullEvery(31, 1));
+    auto c1 = makeFlatVector<int32_t>(
+        batchSize, [](vector_size_t row) { return row; }, nullEvery(17));
+    auto c2 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  testTwoKeys(vectors, "c0", "c1", 200);
+}
+
+TEST_F(TopNTest, compaction) {
+  vector_size_t batchSize = 1000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize,
+        [&](vector_size_t row) { return batchSize * i + row; },
+        nullEvery(31));
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    vectors.push_back(makeRowVector({c0, c1, c1, c1, c1, c1}));
+  }
+  createDuckDbTable(vectors);
+
+  // Make sure LIMIT is greater than number of rows with nulls to avoid
+  // non-deterministic results.
+  testSingleKey(vectors, "c0", 500);
+
+  testSingleKey(vectors, "c0", 900);
+}
+
+TEST_F(TopNTest, varchar) {
+  vector_size_t batchSize = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize,
+        [&](vector_size_t row) { return batchSize * i + row; },
+        nullEvery(5));
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; }, nullEvery(11));
+    auto c2 = makeFlatVector<StringView>(
+        batchSize,
+        [](vector_size_t row) {
+          return StringView::makeInline(std::to_string(row));
+        },
+        nullEvery(31));
+    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);
+
+  // Make sure LIMIT is greater than number of rows with nulls to avoid
+  // non-deterministic results.
+  testSingleKey(vectors, "c2", 200);
+}
+
+TEST_F(TopNTest, multiBatch) {
+  vector_size_t batchSize = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](vector_size_t row) { return batchSize * i + row; });
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; });
+    auto c2 = makeFlatVector<StringView>(batchSize, [](vector_size_t row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  testSingleKey(vectors, "c0", 1'500);
+  testSingleKey(vectors, "c2", 2'500);
+}
+
+TEST_F(TopNTest, empty) {
+  vector_size_t batchSize = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(
+        batchSize, [&](vector_size_t row) { return batchSize * i + row; });
+    auto c1 = makeFlatVector<double>(
+        batchSize, [](vector_size_t row) { return row * 0.1; });
+    auto c2 = makeFlatVector<StringView>(batchSize, [](vector_size_t row) {
+      return StringView::makeInline(std::to_string(row));
+    });
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  testSingleKey(vectors, "c0", "c0 < 0");
+}
+
+TEST_F(TopNTest, lowCardinality) {
+  vector_size_t size = 1'000;
+  std::vector<RowVectorPtr> vectors;
+  for (int32_t i = 0; i < 5; ++i) {
+    auto c0 = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 0; });
+    auto c1 = makeFlatVector<int32_t>(size, [](auto /*row*/) { return 10; });
+    auto c2 = makeFlatVector<double>(size, [](auto /*row*/) { return 12.5; });
+    vectors.push_back(makeRowVector({c0, c1, c2}));
+  }
+  createDuckDbTable(vectors);
+
+  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/experimental/cudf/tests/sparksql/AggregationTest.cpp b/velox/experimental/cudf/tests/sparksql/AggregationTest.cpp
new file mode 100644
index 000000000000..d07390bb00f6
--- /dev/null
+++ b/velox/experimental/cudf/tests/sparksql/AggregationTest.cpp
@@ -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.
+ */
+
+#include "velox/experimental/cudf/exec/ToCudf.h"
+
+#include "velox/common/base/tests/GTestUtils.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::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::exec::sparksql::test {
+
+class AggregationTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    functions::aggregate::sparksql::registerAggregateFunctions("");
+    filesystems::registerLocalFileSystem();
+    // After register supports function prefix, we could register the function
+    // with spark_ to align with sparksql AverageAggregationTest, the
+    // function name overwrite may not work well in some condition.
+    cudf_velox::registerCudf();
+  }
+
+  void TearDown() override {
+    cudf_velox::unregisterCudf();
+  }
+};
+
+TEST_F(AggregationTest, sumReal) {
+  // spark sum:
+  // exec::AggregateFunctionSignatureBuilder()
+  // .returnType("double")
+  // .intermediateType("double")
+  // .argumentType("real")
+  // .build(),
+  // presto sum:
+  // exec::AggregateFunctionSignatureBuilder()
+  //       .returnType("real")
+  //       .intermediateType("double")
+  //       .argumentType("real")
+  //       .build(),
+  // The sum(real) final result type is different.
+  auto data = makeRowVector({makeFlatVector<float>({3.4028, 3.1})});
+  auto vectors = {data};
+  auto plan = PlanBuilder()
+                  .values(vectors)
+                  .partialAggregation({}, {"sum(c0)"})
+                  .finalAggregation()
+                  .planNode();
+  auto expected = makeRowVector({"c0"}, {makeConstant<double>(6.5028, 1)});
+  assertQuery(plan, expected);
+}
+
+} // namespace facebook::velox::exec::sparksql::test
diff --git a/velox/experimental/cudf/tests/sparksql/CMakeLists.txt b/velox/experimental/cudf/tests/sparksql/CMakeLists.txt
new file mode 100644
index 000000000000..baa31524822d
--- /dev/null
+++ b/velox/experimental/cudf/tests/sparksql/CMakeLists.txt
@@ -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.
+
+add_executable(velox_cudf_spark_aggregates_test AggregationTest.cpp Main.cpp)
+
+add_test(
+  NAME velox_cudf_spark_aggregates_test
+  COMMAND velox_cudf_spark_aggregates_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set_tests_properties(velox_cudf_spark_aggregates_test PROPERTIES LABELS cuda_driver TIMEOUT 3000)
+
+target_link_libraries(
+  velox_cudf_spark_aggregates_test
+  velox_cudf_exec
+  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
+  GTest::gtest_main
+)
+
+add_executable(velox_cudf_spark_filter_project_test FilterProjectTest.cpp Main.cpp)
+
+add_test(
+  NAME velox_cudf_spark_filter_project_test
+  COMMAND velox_cudf_spark_filter_project_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set_tests_properties(
+  velox_cudf_spark_filter_project_test
+  PROPERTIES LABELS cuda_driver TIMEOUT 3000
+)
+
+target_link_libraries(
+  velox_cudf_spark_filter_project_test
+  velox_cudf_exec
+  velox_exec_test_lib
+  velox_vector_test_lib
+  velox_functions_spark
+  velox_vector_fuzzer
+  gflags::gflags
+  GTest::gtest
+  GTest::gtest_main
+)
diff --git a/velox/experimental/cudf/tests/sparksql/FilterProjectTest.cpp b/velox/experimental/cudf/tests/sparksql/FilterProjectTest.cpp
new file mode 100644
index 000000000000..2174fa00c7e1
--- /dev/null
+++ b/velox/experimental/cudf/tests/sparksql/FilterProjectTest.cpp
@@ -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.
+ */
+
+#include "velox/experimental/cudf/exec/CudfFilterProject.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/tests/CudfFunctionBaseTest.h"
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/sparksql/registration/Register.h"
+#include "velox/parse/TypeResolver.h"
+
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox;
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+class CudfFilterProjectTest : public CudfFunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    parse::registerTypeResolver();
+    functions::sparksql::registerFunctions("");
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    cudf_velox::registerCudf();
+  }
+
+  static void TearDownTestCase() {
+    cudf_velox::unregisterCudf();
+  }
+
+  CudfFilterProjectTest() {
+    options_.parseIntegerAsBigint = false;
+  }
+};
+
+TEST_F(CudfFilterProjectTest, hashWithSeed) {
+  auto input = makeFlatVector<int64_t>({INT64_MAX, INT64_MIN});
+  auto data = makeRowVector({input});
+  auto hashPlan = PlanBuilder()
+                      .setParseOptions(options_)
+                      .values({data})
+                      .project({"hash_with_seed(42, c0) AS c1"})
+                      .planNode();
+  auto hashResults = AssertQueryBuilder(hashPlan).copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({
+          1049813396,
+          1800792340,
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(expected, hashResults);
+}
+
+TEST_F(CudfFilterProjectTest, hashWithSeedMultiColumns) {
+  auto input = makeFlatVector<int64_t>({INT64_MAX, INT64_MIN});
+  auto data = makeRowVector({input, input});
+  auto hashPlan = PlanBuilder()
+                      .setParseOptions(options_)
+                      .values({data})
+                      .project({"hash_with_seed(42, c0, c1) AS c2"})
+                      .planNode();
+  auto hashResults = AssertQueryBuilder(hashPlan).copyResults(pool());
+
+  auto expected = makeRowVector({
+      makeFlatVector<int32_t>({
+          -864217843,
+          821064941,
+      }),
+  });
+  facebook::velox::test::assertEqualVectors(expected, hashResults);
+}
+
+TEST_F(CudfFilterProjectTest, dateAdd) {
+  const auto dateAdd = [&](const std::string& dateStr, int32_t value) {
+    return evaluateOnce<int32_t>(
+        fmt::format("date_add(c0, {})", value),
+        {DATE()},
+        std::optional<int32_t>(parseDate(dateStr)));
+  };
+
+  // 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));
+}
+
+} // namespace
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/runner/tests/Main.cpp b/velox/experimental/cudf/tests/sparksql/Main.cpp
similarity index 100%
rename from velox/runner/tests/Main.cpp
rename to velox/experimental/cudf/tests/sparksql/Main.cpp
diff --git a/velox/experimental/cudf/tests/utils/CMakeLists.txt b/velox/experimental/cudf/tests/utils/CMakeLists.txt
new file mode 100644
index 000000000000..eb1f8cb52d96
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/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.
+
+add_library(velox_cudf_exec_test_lib CudfHiveConnectorTestBase.cpp CudfPlanBuilder.cpp)
+
+set_target_properties(velox_cudf_exec_test_lib PROPERTIES CUDA_ARCHITECTURES native)
+
+target_link_libraries(
+  velox_cudf_exec_test_lib
+  velox_vector_test_lib
+  velox_temp_path
+  velox_cursor
+  cudf::cudf
+  velox_cudf_exec
+  velox_cudf_vector
+  velox_core
+  velox_exception
+  velox_expression
+  velox_parse_parser
+  velox_duckdb_conversion
+  velox_file_test_utils
+  velox_cudf_hive_connector
+  velox_aggregates
+)
diff --git a/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.cpp b/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.cpp
new file mode 100644
index 000000000000..dd84cd3c7cd6
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.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/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/exec/ToCudf.h"
+#include "velox/experimental/cudf/exec/VeloxCudfInterop.h"
+#include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/connectors/hive/storage_adapters/s3fs/RegisterS3FileSystem.h"
+#include "velox/dwio/common/FileSink.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/Driver.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+
+#include <cudf/io/parquet.hpp>
+#include <cudf/io/types.hpp>
+#include <cudf/table/table.hpp>
+#include <cudf/table/table_view.hpp>
+
+#include <functional>
+#include <string>
+
+namespace facebook::velox::cudf_velox::exec::test {
+
+namespace {
+
+void fillColumnNames(
+    cudf::io::table_input_metadata& tableMeta,
+    const std::string& prefix) {
+  // Fill unnamed columns' names in cudf table_meta
+  std::function<void(cudf::io::column_in_metadata&, std::string)>
+      addDefaultName =
+          [&](cudf::io::column_in_metadata& colMeta, std::string defaultName) {
+            if (colMeta.get_name().empty()) {
+              colMeta.set_name(defaultName);
+            }
+            for (int32_t i = 0; i < colMeta.num_children(); ++i) {
+              addDefaultName(
+                  colMeta.child(i), fmt::format("{}_{}", defaultName, i));
+            }
+          };
+  for (int32_t i = 0; i < tableMeta.column_metadata.size(); ++i) {
+    addDefaultName(tableMeta.column_metadata[i], prefix + std::to_string(i));
+  }
+}
+
+} // namespace
+
+using facebook::velox::connector::hive::HiveConnectorFactory;
+
+CudfHiveConnectorTestBase::CudfHiveConnectorTestBase() {
+  filesystems::registerLocalFileSystem();
+  filesystems::registerS3FileSystem();
+  tests::utils::registerFaultyFileSystem();
+}
+
+void CudfHiveConnectorTestBase::SetUp() {
+  OperatorTestBase::SetUp();
+
+  // Register cudf to enable the CudfDatasource creation from CudfHiveConnector
+  facebook::velox::cudf_velox::registerCudf();
+
+  // Register Hive connector
+  facebook::velox::cudf_velox::connector::hive::CudfHiveConnectorFactory
+      factory;
+  auto config = std::unordered_map<std::string, std::string>{};
+  // TODO(mh):Enable experimental cudf reader
+  // config.insert({facebook::velox::cudf_velox::connector::hive::CudfHiveConfig::kUseExperimentalCudfReader,
+  // "true"});
+  auto hiveConnector = factory.newConnector(
+      kCudfHiveConnectorId,
+      std::make_shared<facebook::velox::config::ConfigBase>(std::move(config)),
+      ioExecutor_.get());
+  facebook::velox::connector::registerConnector(hiveConnector);
+  dwio::common::registerFileSinks();
+}
+
+void CudfHiveConnectorTestBase::TearDown() {
+  // Make sure all pending loads are finished or cancelled before unregister
+  // connector.
+  ioExecutor_.reset();
+  facebook::velox::connector::unregisterConnector(kCudfHiveConnectorId);
+  facebook::velox::cudf_velox::unregisterCudf();
+  OperatorTestBase::TearDown();
+}
+
+void CudfHiveConnectorTestBase::resetCudfHiveConnector(
+    const std::shared_ptr<const facebook::velox::config::ConfigBase>& config) {
+  facebook::velox::connector::unregisterConnector(kCudfHiveConnectorId);
+
+  facebook::velox::cudf_velox::connector::hive::CudfHiveConnectorFactory
+      factory;
+  auto hiveConnector =
+      factory.newConnector(kCudfHiveConnectorId, config, ioExecutor_.get());
+  facebook::velox::connector::registerConnector(hiveConnector);
+}
+
+std::vector<RowVectorPtr> CudfHiveConnectorTestBase::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;
+}
+
+std::shared_ptr<facebook::velox::exec::Task>
+CudfHiveConnectorTestBase::assertQuery(
+    const core::PlanNodePtr& plan,
+    const std::vector<
+        std::shared_ptr<facebook::velox::exec::test::TempFilePath>>& filePaths,
+    const std::string& duckDbSql) {
+  return OperatorTestBase::assertQuery(
+      plan, makeCudfHiveConnectorSplits(filePaths), duckDbSql);
+}
+
+std::shared_ptr<facebook::velox::exec::Task>
+CudfHiveConnectorTestBase::assertQuery(
+    const facebook::velox::core::PlanNodePtr& plan,
+    const std::vector<
+        std::shared_ptr<facebook::velox::connector::ConnectorSplit>>& splits,
+    const std::string& duckDbSql,
+    const int32_t numPrefetchSplit) {
+  return facebook::velox::exec::test::AssertQueryBuilder(
+             plan, duckDbQueryRunner_)
+      .config(
+          facebook::velox::core::QueryConfig::kMaxSplitPreloadPerDriver,
+          std::to_string(numPrefetchSplit))
+      .splits(splits)
+      .assertResults(duckDbSql);
+}
+
+std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
+CudfHiveConnectorTestBase::makeFilePaths(int count) {
+  std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
+      filePaths;
+  filePaths.reserve(count);
+  for (auto i = 0; i < count; ++i) {
+    filePaths.emplace_back(facebook::velox::exec::test::TempFilePath::create());
+  }
+  return filePaths;
+}
+
+void CudfHiveConnectorTestBase::writeToFile(
+    const std::string& filePath,
+    const std::vector<RowVectorPtr>& vectors,
+    std::string prefix) {
+  // Convert all RowVectorPtrs to cudf tables
+  std::vector<std::unique_ptr<cudf::table>> cudfTables;
+  cudfTables.reserve(vectors.size());
+  for (const auto& vector : vectors) {
+    VELOX_CHECK_NOT_NULL(vector);
+    if (vector->size()) {
+      auto stream = cudf::get_default_stream();
+      auto cudfTable = with_arrow::toCudfTable(vector, vector->pool(), stream);
+      stream.synchronize();
+      cudfTables.emplace_back(std::move(cudfTable));
+    }
+  }
+  // Make sure cudfTables has at least one table
+  if (cudfTables.empty()) {
+    VELOX_CHECK(not cudfTables.empty());
+    return;
+  }
+
+  // Create a sink and writer
+  auto const sinkInfo = cudf::io::sink_info(filePath);
+  auto tableInputMetadata =
+      cudf::io::table_input_metadata(cudfTables[0]->view());
+  fillColumnNames(tableInputMetadata, prefix);
+  auto options = cudf::io::chunked_parquet_writer_options::builder(sinkInfo)
+                     .metadata(tableInputMetadata)
+                     .build();
+  cudf::io::chunked_parquet_writer writer(options);
+
+  // Write all table chunks
+  for (const auto& table : cudfTables) {
+    writer.write(table->view());
+  }
+
+  // Close the writer
+  writer.close();
+}
+
+void CudfHiveConnectorTestBase::writeToFile(
+    const std::string& filePath,
+    RowVectorPtr vector,
+    std::string prefix) {
+  auto const sinkInfo = cudf::io::sink_info(filePath);
+  VELOX_CHECK_NOT_NULL(vector);
+  auto stream = cudf::get_default_stream();
+  auto cudfTable = with_arrow::toCudfTable(vector, vector->pool(), stream);
+  stream.synchronize();
+  auto tableInputMetadata = cudf::io::table_input_metadata(cudfTable->view());
+  fillColumnNames(tableInputMetadata, prefix);
+  auto options =
+      cudf::io::parquet_writer_options::builder(sinkInfo, cudfTable->view())
+          .metadata(tableInputMetadata)
+          .build();
+  cudf::io::write_parquet(options);
+}
+
+std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
+    const std::vector<
+        std::shared_ptr<facebook::velox::exec::test::TempFilePath>>&
+        filePaths) {
+  std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+      splits;
+  for (const auto& filePath : filePaths) {
+    splits.push_back(makeCudfHiveConnectorSplit(filePath->getPath()));
+  }
+  return splits;
+}
+
+std::vector<
+    std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>>
+CudfHiveConnectorTestBase::makeCudfHiveConnectorSplits(
+    const std::string& filePath,
+    uint32_t splitCount) {
+  auto file =
+      filesystems::getFileSystem(filePath, nullptr)->openFileForRead(filePath);
+  const int64_t fileSize = file->size();
+  // Take the upper bound.
+  const int64_t splitSize = std::ceil((fileSize) / splitCount);
+  std::vector<
+      std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>>
+      splits;
+  // Add all the splits.
+  for (int i = 0; i < splitCount; i++) {
+    auto split =
+        facebook::velox::connector::hive::HiveConnectorSplitBuilder(filePath)
+            .connectorId(kCudfHiveConnectorId)
+            .fileFormat(facebook::velox::dwio::common::FileFormat::PARQUET)
+            .build();
+    splits.push_back(std::move(split));
+  }
+  return splits;
+}
+
+std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>
+CudfHiveConnectorTestBase::makeCudfHiveConnectorSplit(
+    const std::string& filePath,
+    int64_t splitWeight) {
+  return facebook::velox::connector::hive::HiveConnectorSplitBuilder(filePath)
+      .connectorId(kCudfHiveConnectorId)
+      .fileFormat(facebook::velox::dwio::common::FileFormat::PARQUET)
+      .splitWeight(splitWeight)
+      .build();
+}
+
+// static
+std::shared_ptr<connector::hive::CudfHiveInsertTableHandle>
+CudfHiveConnectorTestBase::makeCudfHiveInsertTableHandle(
+    const std::vector<std::string>& tableColumnNames,
+    const std::vector<TypePtr>& tableColumnTypes,
+    std::shared_ptr<connector::hive::LocationHandle> locationHandle,
+    const std::optional<common::CompressionKind> compressionKind,
+    const std::unordered_map<std::string, std::string>& serdeParameters,
+    const std::shared_ptr<dwio::common::WriterOptions>& writerOptions) {
+  std::vector<std::shared_ptr<const connector::hive::CudfHiveColumnHandle>>
+      columnHandles;
+
+  for (int i = 0; i < tableColumnNames.size(); ++i) {
+    columnHandles.push_back(
+        std::make_shared<connector::hive::CudfHiveColumnHandle>(
+            tableColumnNames.at(i),
+            tableColumnTypes.at(i),
+            cudf::data_type{veloxToCudfTypeId(tableColumnTypes.at(i))}));
+  }
+
+  return std::make_shared<connector::hive::CudfHiveInsertTableHandle>(
+      columnHandles,
+      locationHandle,
+      compressionKind,
+      serdeParameters,
+      writerOptions);
+}
+
+} // namespace facebook::velox::cudf_velox::exec::test
diff --git a/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h b/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h
new file mode 100644
index 000000000000..d67719b1a6e3
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.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 "velox/experimental/cudf/connectors/hive/CudfHiveConfig.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveConnector.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSink.h"
+#include "velox/experimental/cudf/connectors/hive/CudfHiveDataSource.h"
+
+#include "velox/connectors/hive/HiveConnectorSplit.h"
+#include "velox/connectors/hive/TableHandle.h"
+#include "velox/exec/Operator.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/TempFilePath.h"
+#include "velox/type/tests/SubfieldFiltersBuilder.h"
+
+namespace facebook::velox::cudf_velox::exec::test {
+
+static const std::string kCudfHiveConnectorId = "test-cudf-hive";
+
+using ColumnHandleMap = std::unordered_map<
+    std::string,
+    std::shared_ptr<facebook::velox::connector::ColumnHandle>>;
+
+class CudfHiveConnectorTestBase
+    : public facebook::velox::exec::test::OperatorTestBase {
+ public:
+  CudfHiveConnectorTestBase();
+
+  void SetUp() override;
+  void TearDown() override;
+
+  void resetCudfHiveConnector(
+      const std::shared_ptr<const facebook::velox::config::ConfigBase>& config);
+
+  void writeToFile(
+      const std::string& filePath,
+      RowVectorPtr vector,
+      std::string prefix = "c");
+
+  void writeToFile(
+      const std::string& filePath,
+      const std::vector<RowVectorPtr>& vectors,
+      std::string prefix = "c");
+
+  std::vector<RowVectorPtr> makeVectors(
+      const RowTypePtr& rowType,
+      int32_t numVectors,
+      int32_t rowsPerVector);
+
+  using facebook::velox::exec::test::OperatorTestBase::assertQuery;
+
+  /// Assumes plan has a single TableScan node.
+  std::shared_ptr<facebook::velox::exec::Task> assertQuery(
+      const facebook::velox::core::PlanNodePtr& plan,
+      const std::vector<
+          std::shared_ptr<facebook::velox::exec::test::TempFilePath>>&
+          filePaths,
+      const std::string& duckDbSql);
+
+  std::shared_ptr<facebook::velox::exec::Task> assertQuery(
+      const facebook::velox::core::PlanNodePtr& plan,
+      const std::vector<
+          std::shared_ptr<facebook::velox::connector::ConnectorSplit>>& splits,
+      const std::string& duckDbSql,
+      const int32_t numPrefetchSplit);
+
+  static std::vector<std::shared_ptr<facebook::velox::exec::test::TempFilePath>>
+  makeFilePaths(int count);
+
+  static std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>
+  makeCudfHiveConnectorSplit(
+      const std::string& filePath,
+      int64_t splitWeight = 0);
+
+  static std::vector<
+      std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
+  makeCudfHiveConnectorSplits(
+      const std::vector<
+          std::shared_ptr<facebook::velox::exec::test::TempFilePath>>&
+          filePaths);
+
+  static std::vector<
+      std::shared_ptr<facebook::velox::connector::hive::HiveConnectorSplit>>
+  makeCudfHiveConnectorSplits(const std::string& filePath, uint32_t splitCount);
+
+  static std::shared_ptr<facebook::velox::connector::hive::HiveTableHandle>
+  makeTableHandle(
+      const std::string& tableName = "parquet_table",
+      const RowTypePtr& dataColumns = nullptr,
+      bool filterPushdownEnabled = false,
+      common::SubfieldFilters subfieldFilters = {},
+      const core::TypedExprPtr& remainingFilterExpr = nullptr) {
+    return std::make_shared<facebook::velox::connector::hive::HiveTableHandle>(
+        kCudfHiveConnectorId,
+        tableName,
+        filterPushdownEnabled,
+        std::move(subfieldFilters),
+        remainingFilterExpr,
+        dataColumns);
+  }
+
+  /// @param name Column name.
+  /// @param type Column type.
+  /// @param Required subfields of this column.
+  static std::shared_ptr<facebook::velox::connector::hive::HiveColumnHandle>
+  makeColumnHandle(
+      const std::string& name,
+      const TypePtr& type,
+      facebook::velox::connector::hive::HiveColumnHandle::ColumnType
+          columnType = facebook::velox::connector::hive::HiveColumnHandle::
+              ColumnType::kRegular,
+      const std::vector<facebook::velox::common::Subfield>& requiredSubfields =
+          {}) {
+    return std::make_shared<facebook::velox::connector::hive::HiveColumnHandle>(
+        name,
+        columnType,
+        type,
+        type,
+        std::vector<facebook::velox::common::Subfield>{});
+  }
+
+  /// @param name Column name.
+  /// @param type Column type.
+  /// @param type cudf column type.
+  /// @param Required subfields of this column.
+  static std::unique_ptr<connector::hive::CudfHiveColumnHandle>
+  makeColumnHandle(
+      const std::string& name,
+      const TypePtr& type,
+      const cudf::data_type data_type,
+      const std::vector<connector::hive::CudfHiveColumnHandle>& children);
+
+  /// @param targetDirectory Final directory of the target table.
+  /// @param tableType Whether to create a new table.
+  static std::shared_ptr<connector::hive::LocationHandle> makeLocationHandle(
+      std::string targetDirectory) {
+    return std::make_shared<connector::hive::LocationHandle>(
+        targetDirectory, connector::hive::LocationHandle::TableType::kNew, "");
+  }
+
+  /// @param targetDirectory Final directory of the target table.
+  /// @param tableType Whether to create a new table, insert into an existing
+  /// table, or write a temporary table.
+  /// @param targetDirectory Final file name of the target table .
+  static std::shared_ptr<connector::hive::LocationHandle> makeLocationHandle(
+      std::string targetDirectory,
+      connector::hive::LocationHandle::TableType tableType =
+          connector::hive::LocationHandle::TableType::kNew,
+      std::string targetFileName = "") {
+    return std::make_shared<connector::hive::LocationHandle>(
+        targetDirectory, tableType, targetFileName);
+  }
+
+  /// Build a CudfHiveInsertTableHandle.
+  /// @param tableColumnNames Column names of the target table. Corresponding
+  /// type of tableColumnNames[i] is tableColumnTypes[i].
+  /// @param tableColumnTypes Column types of the target table. Corresponding
+  /// name of tableColumnTypes[i] is tableColumnNames[i].
+  /// @param locationHandle Location handle for the table write.
+  /// @param compressionKind compression algorithm to use for table write.
+  /// @param serdeParameters Table writer configuration parameters.
+  static std::shared_ptr<connector::hive::CudfHiveInsertTableHandle>
+  makeCudfHiveInsertTableHandle(
+      const std::vector<std::string>& tableColumnNames,
+      const std::vector<TypePtr>& tableColumnTypes,
+      std::shared_ptr<connector::hive::LocationHandle> locationHandle,
+      const std::optional<common::CompressionKind> compressionKind = {},
+      const std::unordered_map<std::string, std::string>& serdeParameters = {},
+      const std::shared_ptr<dwio::common::WriterOptions>& writerOptions =
+          nullptr);
+};
+
+/// Same as connector::hive::CudfHiveConnectorBuilder, except that this
+/// defaults connectorId to kCudfHiveConnectorId.
+class CudfHiveConnectorSplitBuilder
+    : public connector::hive::CudfHiveConnectorSplitBuilder {
+ public:
+  explicit CudfHiveConnectorSplitBuilder(std::string filePath)
+      : connector::hive::CudfHiveConnectorSplitBuilder(filePath) {
+    connectorId(kCudfHiveConnectorId);
+  }
+};
+
+} // namespace facebook::velox::cudf_velox::exec::test
diff --git a/velox/experimental/cudf/tests/utils/CudfPlanBuilder.cpp b/velox/experimental/cudf/tests/utils/CudfPlanBuilder.cpp
new file mode 100644
index 000000000000..96856a43b4ed
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/CudfPlanBuilder.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/experimental/cudf/tests/utils/CudfPlanBuilder.h"
+
+#include "velox/dwio/common/Options.h"
+#include "velox/exec/TableWriter.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+namespace facebook::velox::cudf_velox::exec::test {
+
+std::function<PlanNodePtr(std::string, PlanNodePtr)> addCudfTableWriter(
+    const RowTypePtr& inputColumns,
+    const std::vector<std::string>& tableColumnNames,
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec,
+    const std::shared_ptr<core::InsertTableHandle>& insertHandle,
+    facebook::velox::connector::CommitStrategy commitStrategy) {
+  return [=](core::PlanNodeId nodeId,
+             core::PlanNodePtr source) -> core::PlanNodePtr {
+    return std::make_shared<core::TableWriteNode>(
+        nodeId,
+        inputColumns,
+        tableColumnNames,
+        columnStatsSpec,
+        insertHandle,
+        false,
+        TableWriteTraits::outputType(columnStatsSpec),
+        commitStrategy,
+        std::move(source));
+  };
+}
+
+std::function<PlanNodePtr(std::string, PlanNodePtr)> cudfTableWrite(
+    const std::string& outputDirectoryPath,
+    const dwio::common::FileFormat fileFormat,
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec,
+    const std::shared_ptr<dwio::common::WriterOptions>& options,
+    const std::string& outputFileName) {
+  return cudfTableWrite(
+      outputDirectoryPath,
+      fileFormat,
+      columnStatsSpec,
+      kCudfHiveConnectorId,
+      {},
+      options,
+      outputFileName);
+}
+
+std::function<PlanNodePtr(std::string, PlanNodePtr)> cudfTableWrite(
+    const std::string& outputDirectoryPath,
+    const dwio::common::FileFormat fileFormat,
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec,
+    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,
+    const common::CompressionKind compression,
+    const RowTypePtr& schema) {
+  return [=](core::PlanNodeId nodeId,
+             core::PlanNodePtr source) -> core::PlanNodePtr {
+    auto rowType = schema ? schema : source->outputType();
+
+    auto locationHandle = CudfHiveConnectorTestBase::makeLocationHandle(
+        outputDirectoryPath,
+        cudf_velox::connector::hive::LocationHandle::TableType::kNew,
+        outputFileName);
+    auto parquetHandle =
+        CudfHiveConnectorTestBase::makeCudfHiveInsertTableHandle(
+            rowType->names(), rowType->children(), locationHandle, compression);
+    auto insertHandle = std::make_shared<core::InsertTableHandle>(
+        std::string(connectorId), parquetHandle);
+
+    return std::make_shared<core::TableWriteNode>(
+        nodeId,
+        rowType,
+        rowType->names(),
+        columnStatsSpec,
+        insertHandle,
+        false,
+        TableWriteTraits::outputType(columnStatsSpec),
+        facebook::velox::connector::CommitStrategy::kNoCommit,
+        std::move(source));
+  };
+}
+
+} // namespace facebook::velox::cudf_velox::exec::test
diff --git a/velox/experimental/cudf/tests/utils/CudfPlanBuilder.h b/velox/experimental/cudf/tests/utils/CudfPlanBuilder.h
new file mode 100644
index 000000000000..f2cf39e5ede7
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/CudfPlanBuilder.h
@@ -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/experimental/cudf/connectors/hive/CudfHiveDataSink.h"
+#include "velox/experimental/cudf/tests/utils/CudfHiveConnectorTestBase.h"
+
+#include "velox/dwio/common/Options.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+#include <string>
+
+namespace facebook::velox::cudf_velox::exec::test {
+
+using namespace facebook::velox;
+using namespace facebook::velox::core;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::common;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::common::test;
+using namespace facebook::velox::common::testutil;
+using namespace facebook::velox::dwio::common;
+
+// Adds a TableWriter node to write all input columns into a CudfHive table.
+std::function<PlanNodePtr(std::string, PlanNodePtr)> addCudfTableWriter(
+    const RowTypePtr& inputColumns,
+    const std::vector<std::string>& tableColumnNames,
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec,
+    const std::shared_ptr<core::InsertTableHandle>& insertHandle,
+    facebook::velox::connector::CommitStrategy commitStrategy =
+        facebook::velox::connector::CommitStrategy::kNoCommit);
+
+/// Adds a TableWriteNode to write all input columns into an un-partitioned
+/// un-bucketed CudfHive table without compression.
+///
+/// @param outputDirectoryPath Path to a directory to write data to.
+/// @param fileFormat File format to use for the written data.
+/// @param columnStatsSpec ColumnStatsSpec for column statistics collection
+/// during write.
+/// @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.
+/// Varchar: count, approx_distinct, sum_data_size_for_stats,
+/// max_data_size_for_stats.
+std::function<PlanNodePtr(std::string, PlanNodePtr)> cudfTableWrite(
+    const std::string& outputDirectoryPath,
+    const dwio::common::FileFormat fileFormat =
+        dwio::common::FileFormat::PARQUET,
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec = std::nullopt,
+    const std::shared_ptr<dwio::common::WriterOptions>& options = nullptr,
+    const std::string& outputFileName = "");
+
+/// Adds a TableWriteNode to write all input columns into CudfHive
+/// table with compression.
+///
+/// @param outputDirectoryPath Path to a directory to write data to.
+/// @param fileFormat File format to use for the written data.
+/// @param columnStatsSpec ColumnStatsSpec 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.
+/// @param compressionKind Compression scheme to use for writing the
+/// output data files.
+/// @param schema Output schema to be passed to the writer. By default use the
+/// output of the previous operator.
+std::function<PlanNodePtr(std::string, PlanNodePtr)> cudfTableWrite(
+    const std::string& outputDirectoryPath,
+    const dwio::common::FileFormat fileFormat,
+    const std::optional<core::ColumnStatsSpec>& columnStatsSpec,
+    const std::string_view& connectorId = kCudfHiveConnectorId,
+    const std::unordered_map<std::string, std::string>& serdeParameters = {},
+    const std::shared_ptr<dwio::common::WriterOptions>& options = nullptr,
+    const std::string& outputFileName = "",
+    const common::CompressionKind compression =
+        common::CompressionKind::CompressionKind_NONE,
+    const RowTypePtr& schema = nullptr);
+
+} // namespace facebook::velox::cudf_velox::exec::test
diff --git a/velox/experimental/cudf/tests/utils/ExpressionTestUtil.h b/velox/experimental/cudf/tests/utils/ExpressionTestUtil.h
new file mode 100644
index 000000000000..171eb5fda3d2
--- /dev/null
+++ b/velox/experimental/cudf/tests/utils/ExpressionTestUtil.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/Expr.h"
+#include "velox/expression/ExprCompiler.h"
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
+
+#include <memory>
+#include <string>
+
+namespace facebook::velox::cudf_velox::test_utils {
+
+// Parse SQL and infer types only, without compiling to exec::Expr
+inline core::TypedExprPtr parseAndInferTypedExpr(
+    const std::string& sql,
+    const RowTypePtr& rowType,
+    core::ExecCtx* execCtx,
+    const parse::ParseOptions& options = {}) {
+  auto untyped = parse::parseExpr(sql, options);
+  return core::Expressions::inferTypes(untyped, rowType, execCtx->pool());
+}
+
+inline std::shared_ptr<exec::Expr> compileExecExpr(
+    const std::string& sql,
+    const RowTypePtr& rowType,
+    core::ExecCtx* execCtx,
+    const parse::ParseOptions& options = {}) {
+  auto typed = parseAndInferTypedExpr(sql, rowType, execCtx, options);
+  exec::ExprSet exprSet({typed}, execCtx, /*enableConstantFolding*/ false);
+  return exprSet.expr(0);
+}
+
+} // namespace facebook::velox::cudf_velox::test_utils
diff --git a/velox/experimental/cudf/vector/CMakeLists.txt b/velox/experimental/cudf/vector/CMakeLists.txt
new file mode 100644
index 000000000000..018b49cbb13f
--- /dev/null
+++ b/velox/experimental/cudf/vector/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_library(velox_cudf_vector CudfVector.cpp)
+
+set_target_properties(velox_cudf_vector PROPERTIES CUDA_ARCHITECTURES native)
+
+target_link_libraries(velox_cudf_vector cudf::cudf velox_exception velox_common_base velox_vector)
diff --git a/velox/experimental/cudf/vector/CudfVector.cpp b/velox/experimental/cudf/vector/CudfVector.cpp
new file mode 100644
index 000000000000..93e1c22bd673
--- /dev/null
+++ b/velox/experimental/cudf/vector/CudfVector.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/experimental/cudf/vector/CudfVector.h"
+
+#include "velox/buffer/Buffer.h"
+#include "velox/common/memory/MemoryPool.h"
+#include "velox/vector/TypeAliases.h"
+
+#include <cudf/column/column.hpp>
+#include <cudf/table/table.hpp>
+
+namespace facebook::velox::cudf_velox {
+namespace {
+
+/// Calculates the total memory size in bytes of a cudf column and reconstructs
+/// it.
+///
+/// This function disassembles a cudf column to access its underlying memory
+/// buffers, calculates the total size including children columns (for nested
+/// types), and then reassembles the column.
+///
+/// @return A pair containing the total size in bytes and the reconstructed
+/// column
+std::pair<uint64_t, std::unique_ptr<cudf::column>> getColumnSize(
+    std::unique_ptr<cudf::column> column) {
+  // Store column metadata (type, null count, and size) before releasing it,
+  // as the release() operation transfers ownership of the underlying buffers
+  // and invalidates access to these properties.
+  auto type = column->type();
+  auto nullCount = column->null_count();
+  auto size = column->size();
+
+  auto contents = column->release();
+  auto bytes = contents.data->size() + contents.null_mask->size();
+
+  // Recursively get the size of the children columns.
+  std::vector<std::unique_ptr<cudf::column>> children;
+  for (auto& child : contents.children) {
+    auto [childBytes, childColumn] = getColumnSize(std::move(child));
+    bytes += childBytes;
+    children.push_back(std::move(childColumn));
+  }
+
+  // Reassemble the column with the original metadata.
+  auto reconstitutedColumn = std::make_unique<cudf::column>(
+      type,
+      size,
+      std::move(*contents.data.release()),
+      std::move(*contents.null_mask.release()),
+      nullCount,
+      std::move(children));
+
+  return std::make_pair(bytes, std::move(reconstitutedColumn));
+}
+
+/// Calculates the total memory size in bytes of a cudf table and reconstructs
+/// it.
+///
+/// This function disassembles a cudf table to access its underlying columns,
+/// calculates the total size, and then reassembles the table.
+///
+/// @note This is a workaround because cudf::table doesn't have an API to get
+/// this information without involving estimation and d->h copies.
+/// @see https://github.com/rapidsai/cudf/issues/18462
+///
+/// @return A pair containing the total size in bytes and the reconstructed
+/// table
+std::pair<uint64_t, std::unique_ptr<cudf::table>> getTableSize(
+    std::unique_ptr<cudf::table>&& table) {
+  auto columns = table->release();
+  std::vector<std::unique_ptr<cudf::column>> columnsOut;
+  uint64_t totalBytes = 0;
+
+  for (auto& column : columns) {
+    auto [bytes, columnOut] = getColumnSize(std::move(column));
+    totalBytes += bytes;
+    columnsOut.push_back(std::move(columnOut));
+  }
+  return std::make_pair(
+      totalBytes, std::make_unique<cudf::table>(std::move(columnsOut)));
+}
+
+} // namespace
+
+CudfVector::CudfVector(
+    velox::memory::MemoryPool* pool,
+    TypePtr type,
+    vector_size_t size,
+    std::unique_ptr<cudf::table>&& table,
+    rmm::cuda_stream_view stream)
+    : RowVector(
+          pool,
+          std::move(type),
+          BufferPtr(nullptr),
+          size,
+          std::vector<VectorPtr>(),
+          std::nullopt),
+      table_{std::move(table)},
+      stream_{stream} {
+  auto [bytes, tableOut] = getTableSize(std::move(table_));
+  flatSize_ = bytes;
+  table_ = std::move(tableOut);
+}
+
+uint64_t CudfVector::estimateFlatSize() const {
+  return flatSize_;
+}
+
+} // namespace facebook::velox::cudf_velox
diff --git a/velox/experimental/cudf/vector/CudfVector.h b/velox/experimental/cudf/vector/CudfVector.h
index db1590b3c080..bb27bd4a8892 100644
--- a/velox/experimental/cudf/vector/CudfVector.h
+++ b/velox/experimental/cudf/vector/CudfVector.h
@@ -15,13 +15,13 @@
  */
 #pragma once
 
-#include "velox/buffer/Buffer.h"
 #include "velox/common/memory/MemoryPool.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/TypeAliases.h"
 
 #include <cudf/table/table.hpp>
-#include <cudf/utilities/default_stream.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
 
 #include <memory>
 #include <utility>
@@ -36,16 +36,7 @@ class CudfVector : public RowVector {
       TypePtr type,
       vector_size_t size,
       std::unique_ptr<cudf::table>&& table,
-      rmm::cuda_stream_view stream)
-      : RowVector(
-            pool,
-            std::move(type),
-            BufferPtr(nullptr),
-            size,
-            std::vector<VectorPtr>(),
-            std::nullopt),
-        table_{std::move(table)},
-        stream_{stream} {}
+      rmm::cuda_stream_view stream);
 
   rmm::cuda_stream_view stream() const {
     return stream_;
@@ -56,12 +47,16 @@ class CudfVector : public RowVector {
   }
 
   std::unique_ptr<cudf::table>&& release() {
+    flatSize_ = 0;
     return std::move(table_);
   }
 
+  uint64_t estimateFlatSize() const override;
+
  private:
   std::unique_ptr<cudf::table> table_;
   rmm::cuda_stream_view stream_;
+  uint64_t flatSize_;
 };
 
 using CudfVectorPtr = std::shared_ptr<CudfVector>;
diff --git a/velox/experimental/gpu/CudaMemMeter.cu b/velox/experimental/gpu/CudaMemMeter.cu
index c198f961ded9..517b6d95fca3 100644
--- a/velox/experimental/gpu/CudaMemMeter.cu
+++ b/velox/experimental/gpu/CudaMemMeter.cu
@@ -102,152 +102,153 @@ int main(int argc, char** argv) {
   std::vector<std::thread> threads;
   auto start = std::chrono::steady_clock::now();
   for (auto dev : devices) {
-    threads.push_back(std::thread([dev,
-                                   n,
-                                   start,
-                                   streamSize,
-                                   blockSize,
-                                   bytes,
-                                   streamBytes,
-                                   nRepeats,
-                                   nStreams,
-                                   oneWay,
-                                   multiplier]() {
-      checkCuda(cudaSetDevice(dev));
-      // allocate pinned host memory and device memory
-      float *a, *d_a;
-      printf("%ldKB\n", bytes / 1024);
-      checkCuda(cudaMallocHost((void**)&a, bytes)); // host pinned
-      checkCuda(cudaMalloc((void**)&d_a, bytes)); // device
+    threads.push_back(
+        std::thread([dev,
+                     n,
+                     start,
+                     streamSize,
+                     blockSize,
+                     bytes,
+                     streamBytes,
+                     nRepeats,
+                     nStreams,
+                     oneWay,
+                     multiplier]() {
+          checkCuda(cudaSetDevice(dev));
+          // allocate pinned host memory and device memory
+          float *a, *d_a;
+          printf("%ldKB\n", bytes / 1024);
+          checkCuda(cudaMallocHost((void**)&a, bytes)); // host pinned
+          checkCuda(cudaMalloc((void**)&d_a, bytes)); // device
 
-      float ms; // elapsed time in milliseconds
-      float singleMs = 0;
-      float async1Ms = 0;
-      float async2Ms = 0;
+          float ms; // elapsed time in milliseconds
+          float singleMs = 0;
+          float async1Ms = 0;
+          float async2Ms = 0;
 
-      // create events and streams
-      cudaEvent_t startEvent, stopEvent, dummyEvent;
-      cudaStream_t* stream =
-          (cudaStream_t*)malloc(nStreams * sizeof(cudaStream_t));
-      checkCuda(cudaEventCreate(&startEvent));
-      checkCuda(cudaEventCreate(&stopEvent));
-      checkCuda(cudaEventCreate(&dummyEvent));
-      for (int i = 0; i < nStreams; ++i) {
-        checkCuda(cudaStreamCreate(&stream[i]));
-      }
-      // baseline case - sequential transfer and execute
-      memset(a, 0, bytes);
-      for (int repeat = 0; repeat < nRepeats; ++repeat) {
-        checkCuda(cudaEventRecord(startEvent, 0));
-        checkCuda(cudaMemcpy(d_a, a, bytes, cudaMemcpyHostToDevice));
-        kernel<<<n / blockSize, blockSize>>>(d_a, 0);
-        checkCuda(cudaGetLastError());
-        if (!oneWay) {
-          checkCuda(cudaMemcpy(a, d_a, bytes, cudaMemcpyDeviceToHost));
-        }
-        checkCuda(cudaEventRecord(stopEvent, 0));
-        checkCuda(cudaEventSynchronize(stopEvent));
-        checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
-        singleMs += ms;
-      }
-      float volume = bytes * nRepeats;
-      printf(
-          "%d at %ld: Time for sequential transfer and execute (ms): %f %f GB/s\n",
-          dev,
-          millis(start),
-          singleMs,
-          multiplier * (volume / (1 << 30)) / (singleMs / 1000));
+          // create events and streams
+          cudaEvent_t startEvent, stopEvent, dummyEvent;
+          cudaStream_t* stream =
+              (cudaStream_t*)malloc(nStreams * sizeof(cudaStream_t));
+          checkCuda(cudaEventCreate(&startEvent));
+          checkCuda(cudaEventCreate(&stopEvent));
+          checkCuda(cudaEventCreate(&dummyEvent));
+          for (int i = 0; i < nStreams; ++i) {
+            checkCuda(cudaStreamCreate(&stream[i]));
+          }
+          // baseline case - sequential transfer and execute
+          memset(a, 0, bytes);
+          for (int repeat = 0; repeat < nRepeats; ++repeat) {
+            checkCuda(cudaEventRecord(startEvent, 0));
+            checkCuda(cudaMemcpy(d_a, a, bytes, cudaMemcpyHostToDevice));
+            kernel<<<n / blockSize, blockSize>>>(d_a, 0);
+            checkCuda(cudaGetLastError());
+            if (!oneWay) {
+              checkCuda(cudaMemcpy(a, d_a, bytes, cudaMemcpyDeviceToHost));
+            }
+            checkCuda(cudaEventRecord(stopEvent, 0));
+            checkCuda(cudaEventSynchronize(stopEvent));
+            checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
+            singleMs += ms;
+          }
+          float volume = bytes * nRepeats;
+          printf(
+              "%d at %ld: Time for sequential transfer and execute (ms): %f %f GB/s\n",
+              dev,
+              millis(start),
+              singleMs,
+              multiplier * (volume / (1 << 30)) / (singleMs / 1000));
 
-      // asynchronous version 1: loop over {copy, kernel, copy}
-      memset(a, 0, bytes);
-      for (int repeat = 0; repeat < nRepeats; ++repeat) {
-        checkCuda(cudaEventRecord(startEvent, 0));
-        for (int i = 0; i < nStreams; ++i) {
-          int offset = i * streamSize;
-          checkCuda(cudaMemcpyAsync(
-              &d_a[offset],
-              &a[offset],
-              streamBytes,
-              cudaMemcpyHostToDevice,
-              stream[i]));
-          kernel<<<streamSize / blockSize, blockSize, 0, stream[i]>>>(
-              d_a, offset);
-          checkCuda(cudaGetLastError());
-          if (!oneWay) {
-            checkCuda(cudaMemcpyAsync(
-                &a[offset],
-                &d_a[offset],
-                streamBytes,
-                cudaMemcpyDeviceToHost,
-                stream[i]));
+          // asynchronous version 1: loop over {copy, kernel, copy}
+          memset(a, 0, bytes);
+          for (int repeat = 0; repeat < nRepeats; ++repeat) {
+            checkCuda(cudaEventRecord(startEvent, 0));
+            for (int i = 0; i < nStreams; ++i) {
+              int offset = i * streamSize;
+              checkCuda(cudaMemcpyAsync(
+                  &d_a[offset],
+                  &a[offset],
+                  streamBytes,
+                  cudaMemcpyHostToDevice,
+                  stream[i]));
+              kernel<<<streamSize / blockSize, blockSize, 0, stream[i]>>>(
+                  d_a, offset);
+              checkCuda(cudaGetLastError());
+              if (!oneWay) {
+                checkCuda(cudaMemcpyAsync(
+                    &a[offset],
+                    &d_a[offset],
+                    streamBytes,
+                    cudaMemcpyDeviceToHost,
+                    stream[i]));
+              }
+            }
+            checkCuda(cudaEventRecord(stopEvent, 0));
+            checkCuda(cudaEventSynchronize(stopEvent));
+            checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
+            async1Ms += ms;
           }
-        }
-        checkCuda(cudaEventRecord(stopEvent, 0));
-        checkCuda(cudaEventSynchronize(stopEvent));
-        checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
-        async1Ms += ms;
-      }
-      volume = streamBytes * nRepeats * nStreams;
-      printf(
-          "%d at %ld: Time for asynchronous V1 transfer and execute (ms): %f %f GB/s\n",
-          dev,
-          millis(start),
-          async1Ms,
-          multiplier * (volume / (1 << 30)) / (async1Ms / 1000));
+          volume = streamBytes * nRepeats * nStreams;
+          printf(
+              "%d at %ld: Time for asynchronous V1 transfer and execute (ms): %f %f GB/s\n",
+              dev,
+              millis(start),
+              async1Ms,
+              multiplier * (volume / (1 << 30)) / (async1Ms / 1000));
 
-      // asynchronous version 2:
-      // loop over copy, loop over kernel, loop over copy
-      memset(a, 0, bytes);
-      for (int repeat = 0; repeat < nRepeats; ++repeat) {
-        checkCuda(cudaEventRecord(startEvent, 0));
-        for (int i = 0; i < nStreams; ++i) {
-          int offset = i * streamSize;
-          checkCuda(cudaMemcpyAsync(
-              &d_a[offset],
-              &a[offset],
-              streamBytes,
-              cudaMemcpyHostToDevice,
-              stream[i]));
-        }
-        for (int i = 0; i < nStreams; ++i) {
-          int offset = i * streamSize;
-          kernel<<<streamSize / blockSize, blockSize, 0, stream[i]>>>(
-              d_a, offset);
-          checkCuda(cudaGetLastError());
-        }
-        for (int i = 0; i < nStreams; ++i) {
-          int offset = i * streamSize;
-          if (!oneWay) {
-            checkCuda(cudaMemcpyAsync(
-                &a[offset],
-                &d_a[offset],
-                streamBytes,
-                cudaMemcpyDeviceToHost,
-                stream[i]));
+          // asynchronous version 2:
+          // loop over copy, loop over kernel, loop over copy
+          memset(a, 0, bytes);
+          for (int repeat = 0; repeat < nRepeats; ++repeat) {
+            checkCuda(cudaEventRecord(startEvent, 0));
+            for (int i = 0; i < nStreams; ++i) {
+              int offset = i * streamSize;
+              checkCuda(cudaMemcpyAsync(
+                  &d_a[offset],
+                  &a[offset],
+                  streamBytes,
+                  cudaMemcpyHostToDevice,
+                  stream[i]));
+            }
+            for (int i = 0; i < nStreams; ++i) {
+              int offset = i * streamSize;
+              kernel<<<streamSize / blockSize, blockSize, 0, stream[i]>>>(
+                  d_a, offset);
+              checkCuda(cudaGetLastError());
+            }
+            for (int i = 0; i < nStreams; ++i) {
+              int offset = i * streamSize;
+              if (!oneWay) {
+                checkCuda(cudaMemcpyAsync(
+                    &a[offset],
+                    &d_a[offset],
+                    streamBytes,
+                    cudaMemcpyDeviceToHost,
+                    stream[i]));
+              }
+            }
+            checkCuda(cudaEventRecord(stopEvent, 0));
+            checkCuda(cudaEventSynchronize(stopEvent));
+            checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
+            async2Ms += ms;
           }
-        }
-        checkCuda(cudaEventRecord(stopEvent, 0));
-        checkCuda(cudaEventSynchronize(stopEvent));
-        checkCuda(cudaEventElapsedTime(&ms, startEvent, stopEvent));
-        async2Ms += ms;
-      }
-      volume = streamBytes * nRepeats * nStreams;
-      printf(
-          "%d at %ld: Time for asynchronous V2 transfer and execute (ms): %f %f GB/s\n",
-          dev,
-          millis(start),
-          async2Ms,
-          multiplier * (volume / (1 << 30)) / (async2Ms / 1000));
+          volume = streamBytes * nRepeats * nStreams;
+          printf(
+              "%d at %ld: Time for asynchronous V2 transfer and execute (ms): %f %f GB/s\n",
+              dev,
+              millis(start),
+              async2Ms,
+              multiplier * (volume / (1 << 30)) / (async2Ms / 1000));
 
-      // cleanup
-      checkCuda(cudaEventDestroy(startEvent));
-      checkCuda(cudaEventDestroy(stopEvent));
-      checkCuda(cudaEventDestroy(dummyEvent));
-      for (int i = 0; i < nStreams; ++i)
-        checkCuda(cudaStreamDestroy(stream[i]));
-      checkCuda(cudaFree(d_a));
-      checkCuda(cudaFreeHost(a));
-    }));
+          // cleanup
+          checkCuda(cudaEventDestroy(startEvent));
+          checkCuda(cudaEventDestroy(stopEvent));
+          checkCuda(cudaEventDestroy(dummyEvent));
+          for (int i = 0; i < nStreams; ++i)
+            checkCuda(cudaStreamDestroy(stream[i]));
+          checkCuda(cudaFree(d_a));
+          checkCuda(cudaFreeHost(a));
+        }));
   }
   for (auto& thread : threads) {
     thread.join();
diff --git a/velox/experimental/gpu/tests/CMakeLists.txt b/velox/experimental/gpu/tests/CMakeLists.txt
index 6202a78d0bd1..fd98d6f22a00 100644
--- a/velox/experimental/gpu/tests/CMakeLists.txt
+++ b/velox/experimental/gpu/tests/CMakeLists.txt
@@ -13,6 +13,7 @@
 # limitations under the License.
 list(APPEND CMAKE_PREFIX_PATH "${CUDAToolkit_LIBRARY_DIR}/cmake")
 find_package(CUB REQUIRED)
+find_package(Thrust REQUIRED)
 
 add_executable(velox_gpu_hash_table_test HashTableTest.cu)
 target_link_libraries(
@@ -21,4 +22,6 @@ target_link_libraries(
   gflags::gflags
   glog::glog
   CUB::CUB
-  CUDA::cudart)
+  Thrust::Thrust
+  CUDA::cudart
+)
diff --git a/velox/experimental/gpu/tests/HashTableTest.cu b/velox/experimental/gpu/tests/HashTableTest.cu
index 6de1378d93a6..d50e818ead98 100644
--- a/velox/experimental/gpu/tests/HashTableTest.cu
+++ b/velox/experimental/gpu/tests/HashTableTest.cu
@@ -415,8 +415,9 @@ void partitionKeys(
   computeHistogram<<<(size + kBlockSize - 1) / kBlockSize, kBlockSize>>>(
       keys, size, numPartitions - 1, hist);
   CUDA_CHECK_FATAL(cudaMemset(offsets, 0, sizeof(int64_t)));
-  CUDA_CHECK_FATAL(cub::DeviceScan::InclusiveSum(
-      tmp, tmpSize, hist, offsets + 1, numPartitions));
+  CUDA_CHECK_FATAL(
+      cub::DeviceScan::InclusiveSum(
+          tmp, tmpSize, hist, offsets + 1, numPartitions));
   CUDA_CHECK_FATAL(cudaMemcpy(
       hist,
       offsets,
@@ -665,8 +666,9 @@ void runPartitioned() {
   auto hist = allocateDeviceMemory<int64_t>(numPartitions);
   auto offsets = allocateDeviceMemory<int64_t>(numPartitions + 1);
   size_t tmpSize;
-  CUDA_CHECK_FATAL(cub::DeviceScan::InclusiveSum(
-      nullptr, tmpSize, hist.get(), offsets.get(), numPartitions));
+  CUDA_CHECK_FATAL(
+      cub::DeviceScan::InclusiveSum(
+          nullptr, tmpSize, hist.get(), offsets.get(), numPartitions));
   auto tmp = allocateDeviceMemory<char>(tmpSize);
   auto shuffledKeys = allocateDeviceMemory<uint64_t>(numKeys);
 
@@ -710,8 +712,6 @@ void runPartitioned() {
       shuffledKeys.get(),
       tmp.get(),
       tmpSize);
-  CUDA_CHECK_FATAL(
-      cudaDeviceSetSharedMemConfig(cudaSharedMemBankSizeEightByte));
   CUDA_CHECK_FATAL(cudaFuncSetAttribute(
       probePartitioned<kUseTags>,
       cudaFuncAttributeMaxDynamicSharedMemorySize,
diff --git a/velox/experimental/wave/CMakeLists.txt b/velox/experimental/wave/CMakeLists.txt
index e1de32ea3e66..6e173a0004df 100644
--- a/velox/experimental/wave/CMakeLists.txt
+++ b/velox/experimental/wave/CMakeLists.txt
@@ -14,9 +14,12 @@
 
 # Use breeze PTX specialization by default for CUDA.
 if(NOT DEFINED CUDA_PLATFORM_SPECIALIZATION_HEADER)
-  set(CUDA_PLATFORM_SPECIALIZATION_HEADER
-      breeze/platforms/specialization/cuda-ptx.cuh
-      CACHE STRING "CUDA platform specialization header")
+  set(
+    CUDA_PLATFORM_SPECIALIZATION_HEADER
+    breeze/platforms/specialization/cuda-ptx.cuh
+    CACHE STRING
+    "CUDA platform specialization header"
+  )
 endif()
 
 # Add header only library for breeze and CUDA platform.
@@ -24,9 +27,8 @@ add_library(breeze_cuda INTERFACE)
 target_include_directories(breeze_cuda INTERFACE ../breeze)
 target_compile_definitions(
   breeze_cuda
-  INTERFACE
-    PLATFORM_CUDA
-    CUDA_PLATFORM_SPECIALIZATION_HEADER=${CUDA_PLATFORM_SPECIALIZATION_HEADER})
+  INTERFACE PLATFORM_CUDA CUDA_PLATFORM_SPECIALIZATION_HEADER=${CUDA_PLATFORM_SPECIALIZATION_HEADER}
+)
 
 add_subdirectory(common)
 add_subdirectory(exec)
diff --git a/velox/experimental/wave/common/Atomic.cuh b/velox/experimental/wave/common/Atomic.cuh
new file mode 100644
index 000000000000..51f5bc3054d3
--- /dev/null
+++ b/velox/experimental/wave/common/Atomic.cuh
@@ -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 <breeze/platforms/platform.h>
+#include <breeze/utils/types.h>
+#include <breeze/platforms/cuda.cuh>
+#include "velox/experimental/wave/common/BitUtil.cuh"
+#include "velox/experimental/wave/common/CompilerDefines.h"
+
+namespace facebook::velox::wave {
+
+enum class MemoryScope { kDevice };
+
+enum class MemoryOrder {
+  kRelaxed,
+  kAcquire,
+  kRelease,
+};
+
+template <MemoryScope>
+struct MemoryScopeTraits;
+
+template <>
+struct MemoryScopeTraits<MemoryScope::kDevice> {
+  WAVE_DEVICE_HOST static constexpr breeze::utils::AddressSpace
+  breezeAddressSpace() {
+    return breeze::utils::GLOBAL;
+  }
+};
+
+template <MemoryOrder>
+struct MemoryOrderTraits;
+
+template <>
+struct MemoryOrderTraits<MemoryOrder::kRelaxed> {
+  WAVE_DEVICE_HOST static constexpr breeze::utils::MemoryOrder breezeType() {
+    return breeze::utils::RELAXED;
+  }
+};
+
+template <>
+struct MemoryOrderTraits<MemoryOrder::kAcquire> {
+  WAVE_DEVICE_HOST static constexpr breeze::utils::MemoryOrder breezeType() {
+    return breeze::utils::ACQUIRE;
+  }
+};
+
+template <>
+struct MemoryOrderTraits<MemoryOrder::kRelease> {
+  WAVE_DEVICE_HOST static constexpr breeze::utils::MemoryOrder breezeType() {
+    return breeze::utils::RELEASE;
+  }
+};
+
+template <typename T, MemoryScope Scope = MemoryScope::kDevice>
+struct Atomic {
+ private:
+  // Note: We currently do not require usage of this class to specify
+  // kBlockThreads as that is not technically used by the CUDA platform
+  // implementation of the atomics in breeze and is non-trivial for
+  // existing usage of atomics to provide. We might want to change that
+  // in the future to remove that assumption.
+  using PlatformT = CudaPlatform</*kBlockThreads=*/kWarpThreads, kWarpThreads>;
+
+  T value_;
+
+ public:
+  Atomic(const Atomic&) = delete;
+  Atomic& operator=(const Atomic&) = delete;
+  Atomic& operator=(const Atomic&) volatile = delete;
+
+  WAVE_DEVICE_HOST explicit constexpr Atomic() noexcept = default;
+  WAVE_DEVICE_HOST constexpr explicit inline Atomic(T value) noexcept
+      : value_(value) {}
+
+  template <MemoryOrder Order = MemoryOrder::kRelaxed>
+  WAVE_DEVICE_HOST T load() noexcept {
+    using namespace breeze::utils;
+    return PlatformT().atomic_load<MemoryOrderTraits<Order>::breezeType()>(
+        make_slice<MemoryScopeTraits<Scope>::breezeAddressSpace()>(&value_));
+  }
+
+  template <MemoryOrder Order = MemoryOrder::kRelaxed>
+  WAVE_DEVICE_HOST void store(T value) noexcept {
+    using namespace breeze::utils;
+    PlatformT().atomic_store<MemoryOrderTraits<Order>::breezeType()>(
+        make_slice<MemoryScopeTraits<Scope>::breezeAddressSpace()>(&value_),
+        value);
+  }
+
+  template <MemoryOrder Order = MemoryOrder::kRelaxed>
+  WAVE_DEVICE_HOST bool compare_exchange(T& expected, T desired) noexcept {
+    using namespace breeze::utils;
+    T actual = PlatformT().atomic_cas<MemoryOrderTraits<Order>::breezeType()>(
+        make_slice<MemoryScopeTraits<Scope>::breezeAddressSpace()>(&value_),
+        expected,
+        desired);
+    bool was_changed = actual == expected;
+    expected = actual;
+    return was_changed;
+  }
+};
+
+template <MemoryScope Scope = MemoryScope::kDevice>
+struct AtomicMutex {
+ private:
+  Atomic<int, Scope> value_;
+
+ public:
+  AtomicMutex(const AtomicMutex&) = delete;
+  AtomicMutex& operator=(const AtomicMutex&) = delete;
+  AtomicMutex& operator=(const AtomicMutex&) volatile = delete;
+
+  WAVE_DEVICE_HOST explicit constexpr AtomicMutex() noexcept = default;
+  WAVE_DEVICE_HOST constexpr explicit inline AtomicMutex(int value) noexcept
+      : value_(value) {}
+
+  WAVE_DEVICE_HOST void acquire() {
+    constexpr int kPollingCount = 5;
+    constexpr int kInitialBackoffStepNs = 10;
+
+    int count = 0;
+    auto step_ns = kInitialBackoffStepNs + threadIdx.x % 32;
+    for (;;) {
+      int available = value_.template load<MemoryOrder::kAcquire>();
+      while (available) {
+        if (value_.template compare_exchange<MemoryOrder::kAcquire>(
+                available, 0)) {
+          return;
+        }
+      }
+      if (count < kPollingCount) {
+        count += 1;
+        continue;
+      }
+#if defined(__CUDA_ARCH__)
+      __nanosleep(step_ns);
+      step_ns *= 2;
+#endif
+    }
+  }
+
+  WAVE_DEVICE_HOST void release() {
+    value_.template store<MemoryOrder::kRelease>(1);
+  }
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/Block.cuh b/velox/experimental/wave/common/Block.cuh
index 9024fb2ef930..b02fb40b3754 100644
--- a/velox/experimental/wave/common/Block.cuh
+++ b/velox/experimental/wave/common/Block.cuh
@@ -47,8 +47,12 @@ template <
     typename T,
     cub::BlockScanAlgorithm Algorithm = cub::BLOCK_SCAN_RAKING,
     typename Getter>
-__device__ inline void
-boolBlockToIndices(Getter getter, T start, T* indices, void* shmem, T& size) {
+__device__ inline void boolBlockToIndices(
+    Getter getter,
+    unsigned start,
+    T* indices,
+    void* shmem,
+    T& size) {
   typedef cub::BlockScan<T, blockSize, Algorithm> BlockScanT;
 
   auto* temp = reinterpret_cast<typename BlockScanT::TempStorage*>(shmem);
@@ -78,8 +82,12 @@ inline int32_t __device__ __host__ bool256ToIndicesSize() {
 /// 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) {
+__device__ inline void bool256ToIndices(
+    Getter8 getter8,
+    unsigned start,
+    T* indices,
+    T& size,
+    char* smem) {
   using Scan = cub::WarpScan<uint16_t>;
   auto* smem16 = reinterpret_cast<uint16_t*>(smem);
   auto group = threadIdx.x / 8;
diff --git a/velox/experimental/wave/common/CMakeLists.txt b/velox/experimental/wave/common/CMakeLists.txt
index cb20c7c5840e..04dbb7082249 100644
--- a/velox/experimental/wave/common/CMakeLists.txt
+++ b/velox/experimental/wave/common/CMakeLists.txt
@@ -21,16 +21,20 @@ add_library(
   Exception.cpp
   KernelCache.cpp
   Type.cpp
-  ResultStaging.cpp)
+  ResultStaging.cpp
+)
 
 target_link_libraries(
   velox_wave_common
   velox_exception
   velox_common_base
   velox_type
+  Folly::folly
   CUDA::cuda_driver
   CUDA::nvrtc
-  CUDA::cudart)
+  CUDA::cudart
+  breeze_cuda
+)
 
 target_compile_definitions(velox_wave_common PRIVATE VELOX_OSS_BUILD=1)
 
diff --git a/velox/experimental/wave/common/Compile.cu b/velox/experimental/wave/common/Compile.cu
index b07f55c95af1..3e85d8b27d82 100644
--- a/velox/experimental/wave/common/Compile.cu
+++ b/velox/experimental/wave/common/Compile.cu
@@ -38,6 +38,8 @@ DEFINE_int32(
     ,
     "-O level for NVRTC");
 
+DEFINE_bool(cuda_ptx, false, "Compile to ptx instead of cubin");
+
 #ifndef VELOX_OSS_BUILD
 #include "velox/facebook/NvrtcUtil.h"
 #endif
@@ -164,8 +166,9 @@ void saveSystemHeaders(std::map<std::string, std::string>& map) {
         << pair.second;
   }
   out.close();
-  system(fmt::format(" mv /tmp/h.{} /tmp/wavesystemheaders.txt", getpid())
-             .c_str());
+  system(
+      fmt::format(" mv /tmp/h.{} /tmp/wavesystemheaders.txt", getpid())
+          .c_str());
 }
 
 // Adds a trailing zero to make the string.data() a C char*.
@@ -253,8 +256,10 @@ void ensureInit() {
     }
   }
   if (!hasArch) {
-    waveNvrtcFlags.push_back(fmt::format(
-        "--gpu-architecture=compute_{}{}", device->major, device->minor));
+    std::string arch = FLAGS_cuda_ptx ? "compute" : "sm";
+    waveNvrtcFlags.push_back(
+        fmt::format(
+            "--gpu-architecture={}_{}{}", arch, device->major, device->minor));
   }
   ::jitify::detail::detect_and_add_cuda_arch(waveNvrtcFlags);
   std::map<std::string, std::string> headers;
@@ -334,11 +339,17 @@ std::shared_ptr<CompiledModule> CompiledModule::create(const KernelSpec& spec) {
     waveError(std::string("Cuda compilation error: ") + log);
   }
   // Obtain PTX from the program.
-  size_t ptxSize;
-  nvrtcCheck(nvrtcGetPTXSize(prog, &ptxSize));
-  std::string ptx;
-  ptx.resize(ptxSize);
-  nvrtcCheck(nvrtcGetPTX(prog, ptx.data()));
+  size_t codeSize;
+  std::string code;
+  if (FLAGS_cuda_ptx) {
+    nvrtcCheck(nvrtcGetPTXSize(prog, &codeSize));
+    code.resize(codeSize);
+    nvrtcCheck(nvrtcGetPTX(prog, code.data()));
+  } else {
+    nvrtcCheck(nvrtcGetCUBINSize(prog, &codeSize));
+    code.resize(codeSize);
+    nvrtcCheck(nvrtcGetCUBIN(prog, code.data()));
+  }
   std::vector<std::string> loweredNames;
   for (auto& entry : spec.entryPoints) {
     const char* temp;
@@ -360,7 +371,7 @@ std::shared_ptr<CompiledModule> CompiledModule::create(const KernelSpec& spec) {
 
   CUmodule module;
   auto loadResult = cuModuleLoadDataEx(
-      &module, ptx.data(), sizeof(values) / sizeof(void*), options, values);
+      &module, code.data(), sizeof(values) / sizeof(void*), options, values);
   if (loadResult != CUDA_SUCCESS) {
     LOG(ERROR) << "Load error " << errorSize << " " << infoSize;
     waveError(fmt::format("Error in load module: {} {}", info, error));
diff --git a/velox/experimental/wave/common/Cuda.cu b/velox/experimental/wave/common/Cuda.cu
index beb58f60a9ba..f000d9d41d3b 100644
--- a/velox/experimental/wave/common/Cuda.cu
+++ b/velox/experimental/wave/common/Cuda.cu
@@ -283,7 +283,7 @@ void Stream::deviceConstantToHostAsync(
 namespace {
 struct CallbackData {
   CallbackData(std::function<void()> callback)
-      : callback(std::move(callback)){};
+      : callback(std::move(callback)) {};
   std::function<void()> callback;
 };
 
diff --git a/velox/experimental/wave/common/HashTable.h b/velox/experimental/wave/common/HashTable.h
index 619ad10eb766..1927288cc00e 100644
--- a/velox/experimental/wave/common/HashTable.h
+++ b/velox/experimental/wave/common/HashTable.h
@@ -81,7 +81,7 @@ struct AllocationRange {
         firstRowOffset(roundUp64(capacity / rowSize) / 8),
         rowOffset(firstRowOffset),
         stringOffset(capacity) {
-    ::memset(reinterpret_cast<char*>(base), 0, firstRowOffset);
+    ::memset(reinterpret_cast<uint8_t*>(base), 0, firstRowOffset);
   }
 
   AllocationRange(AllocationRange&& other) {
@@ -92,7 +92,7 @@ struct AllocationRange {
 
   void operator=(AllocationRange&& other) {
     *this = other;
-    memset(&other, 0, sizeof(AllocationRange));
+    memset(reinterpret_cast<uint8_t*>(&other), 0, sizeof(AllocationRange));
   }
 
   int64_t availableFixed() {
diff --git a/velox/experimental/wave/common/tests/AtomicTest.cu b/velox/experimental/wave/common/tests/AtomicTest.cu
new file mode 100644
index 000000000000..4eb0eab6cc48
--- /dev/null
+++ b/velox/experimental/wave/common/tests/AtomicTest.cu
@@ -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.
+ */
+
+#include <gtest/gtest.h>
+
+#include "velox/experimental/wave/common/Atomic.cuh"
+#include "velox/experimental/wave/common/Cuda.h"
+
+namespace facebook::velox::wave {
+namespace {
+
+template <typename T, typename U>
+inline __device__ Atomic<T, MemoryScope::kDevice>* asDeviceAtomic(U* ptr) {
+  return reinterpret_cast<Atomic<T, MemoryScope::kDevice>*>(ptr);
+}
+
+template <MemoryOrder Order>
+__global__ void loadKernel(int* in, int* out) {
+  *out = asDeviceAtomic<int>(in)->template load<Order>();
+}
+
+template <MemoryOrder Order>
+__global__ void storeKernel(int in, int* out) {
+  asDeviceAtomic<int>(out)->template store<Order>(in);
+}
+
+template <MemoryOrder Order>
+__global__ void
+compareExchangeKernel(int* expected, int desired, int* out, bool* was_changed) {
+  int expected_value = *expected;
+  *was_changed = asDeviceAtomic<int>(out)->template compare_exchange<Order>(
+      expected_value, desired);
+  *expected = expected_value;
+}
+
+template <MemoryOrder Order>
+struct AtomicTestType {
+  static const MemoryOrder memory_order = Order;
+};
+
+struct AtomicTestNameGenerator {
+  template <typename T>
+  static std::string GetName(int) {
+    if constexpr (T::memory_order == MemoryOrder::kRelaxed)
+      return "relaxed";
+    if constexpr (T::memory_order == MemoryOrder::kAcquire)
+      return "acquire";
+    if constexpr (T::memory_order == MemoryOrder::kRelease)
+      return "release";
+    return "?";
+  }
+};
+
+template <typename TypeParam>
+class AtomicLoadTest : public testing::Test {};
+
+using AtomicLoadTestTypes = ::testing::Types<
+    AtomicTestType<MemoryOrder::kRelaxed>,
+    AtomicTestType<MemoryOrder::kAcquire>>;
+
+TYPED_TEST_SUITE(AtomicLoadTest, AtomicLoadTestTypes, AtomicTestNameGenerator);
+
+TYPED_TEST(AtomicLoadTest, load) {
+  auto* allocator = getAllocator(getDevice());
+  auto input = allocator->allocate<int>();
+  *input = 1234;
+  auto output = allocator->allocate<int>();
+  loadKernel<TypeParam::memory_order><<<1, 1>>>(input.get(), output.get());
+  ASSERT_EQ(cudaGetLastError(), cudaSuccess);
+  ASSERT_EQ(cudaDeviceSynchronize(), cudaSuccess);
+  ASSERT_EQ(*output, 1234);
+}
+
+template <typename TypeParam>
+class AtomicStoreTest : public testing::Test {};
+
+using AtomicStoreTestTypes = ::testing::Types<
+    AtomicTestType<MemoryOrder::kRelaxed>,
+    AtomicTestType<MemoryOrder::kRelease>>;
+
+TYPED_TEST_SUITE(
+    AtomicStoreTest,
+    AtomicStoreTestTypes,
+    AtomicTestNameGenerator);
+
+TYPED_TEST(AtomicStoreTest, store) {
+  auto* allocator = getAllocator(getDevice());
+  auto output = allocator->allocate<int>();
+  storeKernel<TypeParam::memory_order><<<1, 1>>>(4321, output.get());
+  ASSERT_EQ(cudaGetLastError(), cudaSuccess);
+  ASSERT_EQ(cudaDeviceSynchronize(), cudaSuccess);
+  ASSERT_EQ(*output, 4321);
+}
+
+template <typename TypeParam>
+class AtomicCompareExchangeTest : public testing::Test {};
+
+using AtomicCompareExchangeTestTypes = ::testing::Types<
+    AtomicTestType<MemoryOrder::kRelaxed>,
+    AtomicTestType<MemoryOrder::kAcquire>,
+    AtomicTestType<MemoryOrder::kRelease>>;
+
+TYPED_TEST_SUITE(
+    AtomicCompareExchangeTest,
+    AtomicCompareExchangeTestTypes,
+    AtomicTestNameGenerator);
+
+TYPED_TEST(AtomicCompareExchangeTest, compare_exchange) {
+  auto* allocator = getAllocator(getDevice());
+  auto expected = allocator->allocate<int>();
+  *expected = 1234;
+  auto output = allocator->allocate<int>();
+  *output = 0;
+  auto was_changed = allocator->allocate<bool>();
+  *was_changed = true;
+  compareExchangeKernel<TypeParam::memory_order>
+      <<<1, 1>>>(expected.get(), 4321, output.get(), was_changed.get());
+  ASSERT_EQ(cudaGetLastError(), cudaSuccess);
+  ASSERT_EQ(cudaDeviceSynchronize(), cudaSuccess);
+  ASSERT_EQ(*output, 0);
+  ASSERT_EQ(*expected, 0);
+  ASSERT_EQ(*was_changed, false);
+  *output = 1234;
+  *expected = 1234;
+  compareExchangeKernel<TypeParam::memory_order>
+      <<<1, 1>>>(expected.get(), 4321, output.get(), was_changed.get());
+  ASSERT_EQ(cudaGetLastError(), cudaSuccess);
+  ASSERT_EQ(cudaDeviceSynchronize(), cudaSuccess);
+  ASSERT_EQ(*output, 4321);
+  ASSERT_EQ(*expected, 1234);
+  ASSERT_EQ(*was_changed, true);
+}
+
+inline __device__ AtomicMutex<MemoryScope::kDevice>* asDeviceAtomicMutex(
+    int* ptr) {
+  return reinterpret_cast<AtomicMutex<MemoryScope::kDevice>*>(ptr);
+}
+
+__global__ void mutexKernel(int* mtx, int* out) {
+  asDeviceAtomicMutex(mtx)->acquire();
+  *out += 1;
+  asDeviceAtomicMutex(mtx)->release();
+}
+
+TEST(AtomicMutexTest, basic) {
+  auto* allocator = getAllocator(getDevice());
+  auto mutex = allocator->allocate<int>();
+  *mutex = 1;
+  auto output = allocator->allocate<int>();
+  *output = 0;
+  mutexKernel<<<4, 8>>>(mutex.get(), output.get());
+  ASSERT_EQ(cudaGetLastError(), cudaSuccess);
+  ASSERT_EQ(cudaDeviceSynchronize(), cudaSuccess);
+  ASSERT_EQ(*mutex, 1);
+  ASSERT_EQ(*output, 32);
+}
+
+} // namespace
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/common/tests/BlockTest.cu b/velox/experimental/wave/common/tests/BlockTest.cu
index 192cf2d4baa3..2eeaff50152f 100644
--- a/velox/experimental/wave/common/tests/BlockTest.cu
+++ b/velox/experimental/wave/common/tests/BlockTest.cu
@@ -32,7 +32,7 @@ using ScanAlgorithm = cub::BlockScan<int, 256, cub::BLOCK_SCAN_RAKING>;
 __global__ void
 boolToIndicesKernel(uint8_t** bools, int32_t** indices, int32_t* sizes) {
   extern __shared__ char smem[];
-  int32_t idx = blockIdx.x;
+  auto idx = blockIdx.x;
   // Start cycle timer
   uint8_t* blockBools = bools[idx];
   boolBlockToIndices<256>(
@@ -61,7 +61,7 @@ __global__ void boolToIndicesNoSharedKernel(
     int32_t** indices,
     int32_t* sizes,
     void* temp) {
-  int32_t idx = blockIdx.x;
+  auto idx = blockIdx.x;
 
   uint8_t* blockBools = bools[idx];
   char* smem = reinterpret_cast<char*>(temp) +
@@ -94,7 +94,7 @@ int32_t BlockTestStream::boolToIndicesSize() {
 __global__ void
 bool256ToIndicesKernel(uint8_t** bools, int32_t** indices, int32_t* sizes) {
   extern __shared__ char smem[];
-  int32_t idx = blockIdx.x;
+  auto idx = blockIdx.x;
   auto* bool64 = reinterpret_cast<uint64_t*>(bools[idx]);
   bool256ToIndices(
       [&](int32_t index8) { return bool64[index8]; },
@@ -122,7 +122,7 @@ __global__ void bool256ToIndicesNoSharedKernel(
     int32_t** indices,
     int32_t* sizes,
     void* temp) {
-  int32_t idx = blockIdx.x;
+  auto idx = blockIdx.x;
   auto* bool64 = reinterpret_cast<uint64_t*>(bools[idx]);
   char* smem = reinterpret_cast<char*>(temp) + blockIdx.x * 80;
   bool256ToIndices(
@@ -152,7 +152,7 @@ int32_t BlockTestStream::bool256ToIndicesSize() {
 
 __global__ void sum64(int64_t* numbers, int64_t* results) {
   extern __shared__ char smem[];
-  int32_t idx = blockIdx.x;
+  auto idx = blockIdx.x;
   blockSum<256>(
       [&]() { return numbers[idx * 256 + threadIdx.x]; }, smem, results);
   __syncthreads();
@@ -396,7 +396,7 @@ void __global__ __launch_bounds__(1024) hashTestKernel(
   switch (mode) {
     case BlockTestStream::HashCase::kGroup: {
       MockGroupByOps ops(probe);
-      int32_t begin = blockIdx.x * probe->numRowsPerThread * blockDim.x;
+      auto begin = blockIdx.x * probe->numRowsPerThread * blockDim.x;
       int32_t end = begin + probe->numRows[blockIdx.x];
 
       for (auto i = begin + threadIdx.x; i < end; i += blockDim.x) {
diff --git a/velox/experimental/wave/common/tests/CMakeLists.txt b/velox/experimental/wave/common/tests/CMakeLists.txt
index f505381ad49a..c509056fc0b5 100644
--- a/velox/experimental/wave/common/tests/CMakeLists.txt
+++ b/velox/experimental/wave/common/tests/CMakeLists.txt
@@ -22,14 +22,15 @@ add_executable(
   BlockTest.cpp
   BlockTest.cu
   HashTableTest.cpp
-  HashTestUtil.cpp)
+  HashTestUtil.cpp
+  AtomicTest.cu
+)
 
 add_test(velox_wave_common_test velox_wave_common_test)
 set_tests_properties(velox_wave_common_test PROPERTIES LABELS cuda_driver)
 
 if(VELOX_SKIP_WAVE_BRANCH_KERNEL_TEST)
-  target_compile_definitions(velox_wave_common_test
-                             PRIVATE VELOX_SKIP_WAVE_BRANCH_KERNEL_TEST=1)
+  target_compile_definitions(velox_wave_common_test PRIVATE VELOX_SKIP_WAVE_BRANCH_KERNEL_TEST=1)
 endif()
 target_link_libraries(
   velox_wave_common_test
@@ -38,4 +39,5 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
   CUDA::cudart
-  breeze_cuda)
+  breeze_cuda
+)
diff --git a/velox/experimental/wave/common/tests/CudaTest.cpp b/velox/experimental/wave/common/tests/CudaTest.cpp
index 2f8f6efb148a..5baa0e1d99a4 100644
--- a/velox/experimental/wave/common/tests/CudaTest.cpp
+++ b/velox/experimental/wave/common/tests/CudaTest.cpp
@@ -1112,8 +1112,9 @@ class CudaTest : public testing::Test {
     auto start = getCurrentTimeMicro();
     for (auto i = 0; i < numStreams; ++i) {
       streams.push_back(std::make_unique<TestStream>());
-      ints.push_back(reinterpret_cast<int32_t*>(
-          allocator_->allocate(opSize * sizeof(int32_t))));
+      ints.push_back(
+          reinterpret_cast<int32_t*>(
+              allocator_->allocate(opSize * sizeof(int32_t))));
       auto last = ints.back();
       auto data = initVector;
       for (auto i = 0; i < opSize; i += kBatch) {
@@ -1380,8 +1381,9 @@ class CudaTest : public testing::Test {
           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]); }));
+          threads.push_back(std::thread([i, &runs, &threadStats]() {
+            runs[i]->run(threadStats[i]);
+          }));
         }
         for (auto i = 0; i < numThreads; ++i) {
           threads[i].join();
diff --git a/velox/experimental/wave/common/tests/IdMapTest.cu b/velox/experimental/wave/common/tests/IdMapTest.cu
index cc8b322400d7..c0e0b400a461 100644
--- a/velox/experimental/wave/common/tests/IdMapTest.cu
+++ b/velox/experimental/wave/common/tests/IdMapTest.cu
@@ -16,6 +16,7 @@
 
 #include <folly/init/Init.h>
 #include <gtest/gtest.h>
+#include <iomanip>
 #include <random>
 
 #include "velox/experimental/wave/common/Cuda.h"
@@ -61,8 +62,8 @@ IdMapHolder<T> createIdMap(GpuAllocator* allocator, int capacity) {
 template <typename T>
 __global__ void
 runMakeIds(IdMap<T>* idMap, const T* values, int size, int32_t* output) {
-  int step = gridDim.x * blockDim.x;
-  for (int i = threadIdx.x + blockIdx.x * blockDim.x; i < size; i += step) {
+  auto step = gridDim.x * blockDim.x;
+  for (auto i = threadIdx.x + blockIdx.x * blockDim.x; i < size; i += step) {
     output[i] = idMap->makeId(values[i]);
   }
 }
diff --git a/velox/experimental/wave/common/tests/Updates.cuh b/velox/experimental/wave/common/tests/Updates.cuh
index 0297a5491fae..45b1972b7483 100644
--- a/velox/experimental/wave/common/tests/Updates.cuh
+++ b/velox/experimental/wave/common/tests/Updates.cuh
@@ -35,7 +35,7 @@ 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;
+  auto 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) {
@@ -57,7 +57,7 @@ void __device__ testSumPart(
   auto deltas = keys[1];
   for (auto groupIdx = 0; groupIdx < numGroups; ++groupIdx) {
     auto groupStart = groupIdx * groupStride;
-    int32_t linear = threadIdx.x + blockIdx.x * blockDim.x;
+    auto linear = threadIdx.x + blockIdx.x * blockDim.x;
     if (linear > numParts) {
       break;
     }
@@ -78,7 +78,7 @@ 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;
+  auto 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) {
@@ -93,7 +93,7 @@ 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;
+  auto 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) {
@@ -107,7 +107,7 @@ void __device__ testSumAtomicCoalesceShmem(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;
+  auto base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
   int32_t lane = cub::LaneId();
   int32_t end = base + probe->numRows[blockIdx.x];
   extern __shared__ char smem[];
@@ -147,7 +147,7 @@ void __device__ testSumAtomicCoalesceShfl(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;
+  auto base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
   int32_t lane = cub::LaneId();
   int32_t end = base + probe->numRows[blockIdx.x];
 
@@ -186,7 +186,7 @@ void __device__ testSumMtxCoalesce(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;
+  auto base = probe->numRowsPerThread * blockDim.x * blockIdx.x;
   int32_t lane = cub::LaneId();
   int32_t end = base + probe->numRows[blockIdx.x];
 
@@ -226,7 +226,7 @@ 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;
+  auto 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) {
diff --git a/velox/experimental/wave/dwio/CMakeLists.txt b/velox/experimental/wave/dwio/CMakeLists.txt
index 192a71f77a7e..c5502ef17e3c 100644
--- a/velox/experimental/wave/dwio/CMakeLists.txt
+++ b/velox/experimental/wave/dwio/CMakeLists.txt
@@ -14,8 +14,6 @@
 
 add_subdirectory(decode)
 
-add_library(velox_wave_dwio ColumnReader.cpp FormatData.cpp ReadStream.cpp
-                            StructColumnReader.cpp)
+add_library(velox_wave_dwio ColumnReader.cpp FormatData.cpp ReadStream.cpp StructColumnReader.cpp)
 
-target_link_libraries(
-  velox_wave_dwio Folly::folly fmt::fmt xsimd)
+target_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
index 5a498dc97175..965d22b93a35 100644
--- a/velox/experimental/wave/dwio/ColumnReader.cpp
+++ b/velox/experimental/wave/dwio/ColumnReader.cpp
@@ -26,6 +26,7 @@ void ColumnReader::makeOp(
   op.action = action;
   op.reader = this;
   op.waveVector = readStream->operandVector(operand_->id, requestedType_);
+  op.hasMultiChunks = op.reader->formatData()->hasMultiChunks();
 };
 
 bool ColumnReader::hasNonNullFilter() const {
diff --git a/velox/experimental/wave/dwio/ColumnReader.h b/velox/experimental/wave/dwio/ColumnReader.h
index 6d6f3f3660fb..d3a123b0f909 100644
--- a/velox/experimental/wave/dwio/ColumnReader.h
+++ b/velox/experimental/wave/dwio/ColumnReader.h
@@ -42,7 +42,11 @@ class ColumnReader {
             fileType_,
             scanSpec,
             operand ? operand->id : kNoOperand)),
-        scanSpec_(&scanSpec) {}
+        scanSpec_(&scanSpec) {
+    if (operand) {
+      operand->notNull = !formatData_->hasNulls();
+    }
+  }
 
   virtual ~ColumnReader() = default;
 
@@ -188,6 +192,8 @@ class ReadStream : public Executable {
   // launch cost but run all non-filter columns in their own TBs.
   bool decodenonFiltersInFiltersKernel();
 
+  void initializeResultNulls(Stream& stream);
+
   StructColumnReader* reader_;
   std::vector<AbstractOperand*> abstractOperands_;
 
@@ -235,6 +241,12 @@ class ReadStream : public Executable {
   // Set to true when after first griddize() and akeOps().
   bool inited_{false};
   FileInfo fileInfo_;
+
+  // Keep track of which level of encodings we are decoding for. This is
+  // necessary when you decode multiple streams together and want them to be
+  // fully decoded in the same kernel launch in order to implement filters.
+  int32_t decodeLevel_{0};
+  bool filtersCompacted_{false};
 };
 
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/FormatData.cpp b/velox/experimental/wave/dwio/FormatData.cpp
index 2e849c204013..92a29278e1db 100644
--- a/velox/experimental/wave/dwio/FormatData.cpp
+++ b/velox/experimental/wave/dwio/FormatData.cpp
@@ -58,8 +58,7 @@ void SplitStaging::copyColumns(
     char* destination,
     bool release) {
   for (auto i = begin; i < end; ++i) {
-    memcpy(destination, staging_[i].hostData, staging_[i].size);
-    destination += staging_[i].size;
+    memcpy(destination + offsets_[i], staging_[i].hostData, staging_[i].size);
   }
   if (release) {
     sem_.release();
@@ -176,9 +175,9 @@ void setFilter(GpuDecode* step, ColumnReader* reader, Stream* stream) {
       step->filterKind = WaveFilterKind::kBigintRange;
       step->nullsAllowed = veloxFilter->testNull();
       step->filter._.int64Range[0] =
-          reinterpret_cast<common::BigintRange*>(veloxFilter)->lower();
+          reinterpret_cast<const common::BigintRange*>(veloxFilter)->lower();
       step->filter._.int64Range[1] =
-          reinterpret_cast<common::BigintRange*>(veloxFilter)->upper();
+          reinterpret_cast<const common::BigintRange*>(veloxFilter)->upper();
       break;
     }
 
diff --git a/velox/experimental/wave/dwio/FormatData.h b/velox/experimental/wave/dwio/FormatData.h
index 8800f596ff02..ccfedfd6f15f 100644
--- a/velox/experimental/wave/dwio/FormatData.h
+++ b/velox/experimental/wave/dwio/FormatData.h
@@ -206,6 +206,7 @@ enum class ColumnAction { kNulls = 1, kLengths = 2, kFilter = 4, kValues = 8 };
 struct ColumnOp {
   static constexpr int32_t kNoPrerequisite = -1;
   static constexpr int32_t kNoOperand = -1;
+  static constexpr int32_t kAnyLevel = -1;
 
   // Is the op completed after this? If so, any dependent action can be
   // queued as soon as this is set.
@@ -222,6 +223,14 @@ struct ColumnOp {
   // Vector completed by arrival of this. nullptr if no vector.
   WaveVector* waveVector{nullptr};
 
+  // True if the column contains multiple uncontiguous chunks.
+  bool hasMultiChunks{false};
+
+  // Set by ReadStream to coordinate the decoding of multiple streams. The
+  // FormatData should decode the current layer of encoding iff decodeLevel is
+  // equal to the current layer or kAnyLevel.
+  int32_t decodeLevel{kAnyLevel};
+
   // Host side result size. 0 for unconditional decoding. Can be buffer size for
   // passing rows, length/offset array etc.
   int32_t resultSize{0};
@@ -278,6 +287,15 @@ class FormatData {
   /// column is in terms of the column, not in terms of top level rows.
   virtual void newBatch(int32_t startRow) = 0;
 
+  /// Returns the maximum level of encoding of all chunks of 'this'.
+  virtual int32_t maxDecodeLevel() const {
+    return maxDecodeLevel_;
+  }
+
+  virtual bool hasMultiChunks() const {
+    return false;
+  }
+
   /// 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
@@ -344,6 +362,8 @@ class FormatData {
 
   ColumnGridInfo grid_;
   bool griddized_{false};
+
+  int32_t maxDecodeLevel_{0};
 };
 
 class FormatParams {
diff --git a/velox/experimental/wave/dwio/ReadStream.cpp b/velox/experimental/wave/dwio/ReadStream.cpp
index 9a47a0dff67e..ce866f86fb63 100644
--- a/velox/experimental/wave/dwio/ReadStream.cpp
+++ b/velox/experimental/wave/dwio/ReadStream.cpp
@@ -219,6 +219,7 @@ void ReadStream::makeCompact(bool isSerial) {
 
 void ReadStream::makeOps() {
   auto& children = reader_->children();
+  bool isMultiChunkFilter = false;
   for (auto i = 0; i < children.size(); ++i) {
     auto* child = reader_->children()[i];
     if (child->scanSpec().filter()) {
@@ -229,8 +230,14 @@ void ReadStream::makeOps() {
           this,
           filterOnly ? ColumnAction::kFilter : ColumnAction::kValues,
           filters_.back());
+      decodeLevel_ =
+          std::max(decodeLevel_, child->formatData()->maxDecodeLevel());
+      isMultiChunkFilter |= filters_.back().hasMultiChunks;
     }
   }
+  for (auto& filter : filters_) {
+    filter.hasMultiChunks = isMultiChunkFilter;
+  }
   for (auto i = 0; i < children.size(); ++i) {
     auto* child = reader_->children()[i];
     if (child->scanSpec().filter()) {
@@ -248,6 +255,7 @@ bool ReadStream::decodenonFiltersInFiltersKernel() {
 
 void ReadStream::prepareRead() {
   filtersDone_ = false;
+  filtersCompacted_ = false;
   for (auto& op : filters_) {
     op.reader->formatData()->newBatch(row_);
     op.isFinal = false;
@@ -265,10 +273,18 @@ bool ReadStream::makePrograms(bool& needSync) {
   needSync = false;
   programs_.clear();
   ColumnOp* previousFilter = nullptr;
+
+  auto filterOpsFinal = [&]() {
+    return std::all_of(filters_.begin(), filters_.end(), [](auto& filter) {
+      return filter.isFinal;
+    });
+  };
+
   if (!filtersDone_ && !filters_.empty()) {
     // Filters are done consecutively, each TB does all the filters for its
     // range.
     for (auto& filter : filters_) {
+      filter.decodeLevel = decodeLevel_;
       filter.reader->formatData()->startOp(
           filter,
           previousFilter,
@@ -279,12 +295,21 @@ bool ReadStream::makePrograms(bool& needSync) {
           *this);
       previousFilter = &filter;
     }
-    if (!decodenonFiltersInFiltersKernel()) {
-      filtersDone_ = true;
-      return false;
-    }
+    decodeLevel_--;
+    filtersDone_ = filterOpsFinal();
+
+    // the decode is already done here if the filters are dispatched and there
+    // is only one filter kernel (hence makeCompact is not needed) and there are
+    // no non-filter columns to decode.
+    return filtersDone_ && filters_.size() == 1 && ops_.empty();
+    // TODO(bowenwu): revisit this optimization of
+    // decodenonFiltersInFiltersKernel().
+  }
+  if (!filtersCompacted_) {
+    // makeCompact is not idempotent can only be called once per batch.
+    makeCompact(!filtersDone_);
+    filtersCompacted_ = true;
   }
-  makeCompact(!filtersDone_);
   previousFilter = filters_.empty() ? nullptr : &filters_.back();
   for (auto i = 0; i < ops_.size(); ++i) {
     auto& op = ops_[i];
@@ -342,6 +367,24 @@ void ReadStream::syncStaging(Stream& stream) {
   });
 }
 
+void ReadStream::initializeResultNulls(Stream& stream) {
+  for (auto i = 0; i < filters_.size(); ++i) {
+    if (filters_[i].reader->formatData()->hasNulls()) {
+      auto waveVector = filters_[i].waveVector;
+      if (waveVector && waveVector->nulls()) {
+        stream.memset(waveVector->nulls(), 1, waveVector->size());
+      }
+    }
+  }
+  for (auto i = 0; i < ops_.size(); ++i) {
+    if (ops_[i].reader->formatData()->hasNulls()) {
+      auto waveVector = ops_[i].waveVector;
+      VELOX_CHECK(waveVector != nullptr && waveVector->nulls() != nullptr);
+      stream.memset(waveVector->nulls(), 1, waveVector->size());
+    }
+  }
+}
+
 void ReadStream::launch(
     std::unique_ptr<ReadStream> readStream,
     int32_t row,
@@ -366,6 +409,7 @@ void ReadStream::launch(
         if (!readStream->inited_) {
           readStream->makeOps();
           readStream->makeGrid(stream);
+          readStream->initializeResultNulls(*stream);
           griddizedHere = true;
           readStream->inited_ = true;
         }
diff --git a/velox/experimental/wave/dwio/decode/CMakeLists.txt b/velox/experimental/wave/dwio/decode/CMakeLists.txt
index d690b53255ad..a04ae9655c5b 100644
--- a/velox/experimental/wave/dwio/decode/CMakeLists.txt
+++ b/velox/experimental/wave/dwio/decode/CMakeLists.txt
@@ -17,5 +17,4 @@ endif()
 
 add_library(velox_wave_decode GpuDecoder.cu)
 
-target_link_libraries(
-  velox_wave_decode velox_wave_common CUDA::cudart breeze_cuda)
+target_link_libraries(velox_wave_decode velox_wave_common CUDA::cudart breeze_cuda)
diff --git a/velox/experimental/wave/dwio/decode/DecodeStep.h b/velox/experimental/wave/dwio/decode/DecodeStep.h
index 453871e563e0..dbf9d15884b7 100644
--- a/velox/experimental/wave/dwio/decode/DecodeStep.h
+++ b/velox/experimental/wave/dwio/decode/DecodeStep.h
@@ -64,6 +64,8 @@ enum class DecodeStep {
   kSelective32,
   kCompact64,
   kSelective64,
+  kSelective32Chunked,
+  kSelective64Chunked,
   kConstant32,
   kConstant64,
   kConstantChar,
@@ -275,6 +277,11 @@ struct alignas(16) GpuDecode {
     void* result;
   };
 
+  struct SelectiveChunked {
+    int32_t chunkStart;
+    const void* input;
+  };
+
   struct Varint {
     // Address of the input data.
     const char* input;
@@ -392,8 +399,12 @@ struct alignas(16) GpuDecode {
     RowCountNoFilter rowCountNoFilter;
     CountBits countBits;
     CompactValues compact;
+    SelectiveChunked selectiveChunked;
   } data;
 
+  /// True if 'nulls' is a bitmap of nulls. False if 'nulls' an array of uint8_t
+  bool isNullsBitmap{true};
+
   /// Returns the amount of int aligned global memory per TB needed in 'temp'
   /// for standard size TB.
   int32_t tempSize() const;
diff --git a/velox/experimental/wave/dwio/decode/GpuDecoder-inl.cuh b/velox/experimental/wave/dwio/decode/GpuDecoder-inl.cuh
index d96e615fd7c2..107a7c8267b5 100644
--- a/velox/experimental/wave/dwio/decode/GpuDecoder-inl.cuh
+++ b/velox/experimental/wave/dwio/decode/GpuDecoder-inl.cuh
@@ -608,6 +608,19 @@ __device__ void makeScatterIndices(GpuDecode::MakeScatterIndices& op) {
   }
 }
 
+template <typename T>
+inline __device__ T loadBits(
+    void const* p,
+    uint32_t idx,
+    uint32_t width = 8 * sizeof(T),
+    int64_t baseline = 0) {
+  if (sizeof(T) == 4 || width <= 32) {
+    return loadBits32(p, idx * width, width) + baseline;
+  } else {
+    return loadBits64(p, idx * width, width) + baseline;
+  }
+}
+
 template <typename T, DecodeStep kEncoding>
 inline __device__ T randomAccessDecode(const GpuDecode* op, int32_t idx) {
   switch (kEncoding) {
@@ -827,7 +840,7 @@ __device__ void decodeSelective(GpuDecode* op) {
       int32_t maxRow = op->maxRow;
       int32_t dataIdx = 0;
       auto* state = reinterpret_cast<NonNullState*>(op->temp);
-      if (threadIdx.x == 0) {
+      if (threadIdx.x == 0 && op->isNullsBitmap) {
         state->nonNullsBelow = op->nthBlock == 0
             ? 0
             : op->nonNullBases
@@ -844,8 +857,14 @@ __device__ void decodeSelective(GpuDecode* op) {
         int32_t dataIdx;
         IndexT data{};
         if (base < maxRow) {
-          dataIdx = nonNullIndex256(
-              op->nulls, base, min(kBlockSize, maxRow - base), state);
+          if (op->isNullsBitmap) {
+            dataIdx = nonNullIndex256(
+                op->nulls, base, min(kBlockSize, maxRow - base), state);
+          } else {
+            dataIdx = base + threadIdx.x < maxRow
+                ? (op->nulls[base + threadIdx.x] ? base + threadIdx.x : -1)
+                : -1;
+          }
           filterPass = base + threadIdx.x < maxRow;
           if (filterPass) {
             if (dataIdx == -1) {
@@ -877,7 +896,7 @@ __device__ void decodeSelective(GpuDecode* op) {
     }
     case NullMode::kSparseNullable: {
       auto state = reinterpret_cast<NonNullState*>(op->temp);
-      if (threadIdx.x == 0) {
+      if (threadIdx.x == 0 && op->isNullsBitmap) {
         state->nonNullsBelow = op->nthBlock == 0
             ? 0
             : op->nonNullBases
@@ -895,8 +914,17 @@ __device__ void decodeSelective(GpuDecode* op) {
         } else {
           bool filterPass = true;
           IndexT data{};
-          int32_t dataIdx =
-              nonNullIndex256Sparse(op->nulls, op->rows + base, numRows, state);
+          int32_t dataIdx;
+          if (op->isNullsBitmap) {
+            dataIdx = nonNullIndex256Sparse(
+                op->nulls, op->rows + base, numRows, state);
+          } else {
+            dataIdx = threadIdx.x < numRows
+                ? (op->nulls[op->rows[base + threadIdx.x]]
+                       ? op->rows[base + threadIdx.x]
+                       : -1)
+                : -1;
+          }
           filterPass = threadIdx.x < numRows;
           if (filterPass) {
             if (dataIdx == -1) {
@@ -1141,6 +1169,91 @@ __device__ void selectiveFilter(GpuDecode* op) {
   }
 }
 
+__device__ inline int32_t
+rowExists(int32_t row, const int32_t* rows, int32_t numRows) {
+  int lo = 0, hi = numRows;
+  while (lo < hi) {
+    int i = (lo + hi) / 2;
+    if (rows[i] == row) {
+      return i;
+    }
+    if (rows[i] < row) {
+      lo = i + 1;
+    } else {
+      hi = i;
+    }
+  }
+  return -1;
+}
+
+// returns the index of the matching row in the rows array if exists . -1
+// if not exists.
+template <int32_t kBlockSize>
+__device__ int32_t rowExists(int32_t nthLoop, GpuDecode* op) {
+  auto row = threadIdx.x + op->data.selectiveChunked.chunkStart + op->baseRow +
+      nthLoop * kBlockSize; // global row id
+  auto tileSize = kBlockSize * op->numRowsPerThread;
+  auto resultBlockId = row / tileSize;
+  auto loopId = (row % tileSize) / kBlockSize;
+  auto resultStart = resultBlockId * tileSize + loopId * kBlockSize;
+  auto numRows =
+      op->filterRowCount[resultBlockId * op->numRowsPerThread + loopId];
+  auto match = rowExists(row, op->rows + resultStart, numRows);
+  return match == -1 ? match : resultStart + match;
+}
+
+template <typename T, int32_t kBlockSize>
+__device__ void selectiveFilterChunked(GpuDecode* op) {
+  using namespace breeze::utils;
+  int32_t nthLoop = 0;
+  bool hasNulls = op->nullMode == NullMode::kSparseNullable ||
+      op->nullMode == NullMode::kDenseNullable;
+  if (hasNulls) {
+    int32_t maxRow = op->maxRow;
+    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 {
+      auto base = op->baseRow + nthLoop * kBlockSize;
+      int32_t dataIdx = nonNullIndex256(
+          op->nulls, base, min(kBlockSize, maxRow - base), state);
+
+      auto row = threadIdx.x + base; // local row id wrt the chunk
+      auto resultIdx =
+          row < op->maxRow ? rowExists<kBlockSize>(nthLoop, op) : -1;
+      if (resultIdx != -1) {
+        if (dataIdx != -1) {
+          auto data = loadBits<T>(op->data.selectiveChunked.input, dataIdx);
+          reinterpret_cast<T*>(op->result)[resultIdx] = data;
+        }
+        op->resultNulls[resultIdx] = (dataIdx == -1 ? kNull : kNotNull);
+      }
+    } while (++nthLoop < op->numRowsPerThread);
+  } else {
+    do {
+      auto row = threadIdx.x + op->baseRow +
+          nthLoop * kBlockSize; // local row id wrt the chunk
+
+      auto resultIdx =
+          row < op->maxRow ? rowExists<kBlockSize>(nthLoop, op) : -1;
+      if (resultIdx != -1) {
+        auto data = loadBits<T>(op->data.selectiveChunked.input, row);
+        reinterpret_cast<T*>(op->result)[resultIdx] = data;
+      }
+    } while (++nthLoop < op->numRowsPerThread);
+  }
+  __syncthreads();
+}
+
 template <typename T, int32_t kBlockSize>
 __device__ void selectiveSwitch(GpuDecode* op) {
   if (op->encoding == DecodeStep::kDictionaryOnBitpack) {
@@ -1160,6 +1273,12 @@ __device__ void decodeSwitch(GpuDecode& op) {
     case DecodeStep::kSelective64:
       selectiveSwitch<int64_t, kBlockSize>(&op);
       break;
+    case DecodeStep::kSelective32Chunked:
+      selectiveFilterChunked<int32_t, kBlockSize>(&op);
+      break;
+    case DecodeStep::kSelective64Chunked:
+      selectiveFilterChunked<int64_t, kBlockSize>(&op);
+      break;
     case DecodeStep::kCompact64:
       detail::compactValues<int64_t, kBlockSize>(&op);
       break;
@@ -1236,6 +1355,8 @@ int32_t sharedMemorySizeForDecode(DecodeStep step) {
   switch (step) {
     case DecodeStep::kSelective32:
     case DecodeStep::kSelective64:
+    case DecodeStep::kSelective32Chunked:
+    case DecodeStep::kSelective64Chunked:
     case DecodeStep::kCompact64:
     case DecodeStep::kTrivial:
     case DecodeStep::kDictionaryOnBitpack:
diff --git a/velox/experimental/wave/dwio/decode/GpuDecoder.cu b/velox/experimental/wave/dwio/decode/GpuDecoder.cu
index c5079f3351b8..f3c63b6bfc49 100644
--- a/velox/experimental/wave/dwio/decode/GpuDecoder.cu
+++ b/velox/experimental/wave/dwio/decode/GpuDecoder.cu
@@ -39,7 +39,7 @@ int32_t GpuDecode::sharedMemorySize() const {
 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 = 17;
+  static constexpr int32_t kMaxInlineOps = 15;
 
   // Pointer to standalone description of work. If nullptr, the description of
   // work fits inline in 'this'.
diff --git a/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt b/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt
index 66d35ec05a69..d93e34c7ab26 100644
--- a/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt
+++ b/velox/experimental/wave/dwio/decode/tests/CMakeLists.txt
@@ -25,4 +25,5 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
   Folly::folly
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/experimental/wave/dwio/nimble/Encoding.h b/velox/experimental/wave/dwio/nimble/Encoding.h
new file mode 100644
index 000000000000..5ed9e0cac1e4
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/Encoding.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
+
+namespace facebook::wave::nimble {
+class Encoding {
+ public:
+  // The binary layout for each Encoding begins with the same prefix:
+  // 1 byte: EncodingType
+  // 1 byte: DataType
+  // 4 bytes: uint32_t num rows
+  static constexpr int kEncodingTypeOffset = 0;
+  static constexpr int kDataTypeOffset = 1;
+  static constexpr int kRowCountOffset = 2;
+  static constexpr int kPrefixSize = 6;
+};
+} // namespace facebook::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/EncodingIdentifier.h b/velox/experimental/wave/dwio/nimble/EncodingIdentifier.h
new file mode 100644
index 000000000000..19e169ac03e3
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/EncodingIdentifier.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 <cstdint>
+
+namespace facebook::wave::nimble {
+
+// When encoding contains nested encodings, each nested encoding has its
+// own identifier.
+using NestedEncodingIdentifier = uint8_t;
+
+struct EncodingIdentifiers {
+  struct Dictionary {
+    static constexpr NestedEncodingIdentifier Alphabet = 0;
+    static constexpr NestedEncodingIdentifier Indices = 1;
+  };
+
+  struct MainlyConstant {
+    static constexpr NestedEncodingIdentifier IsCommon = 0;
+    static constexpr NestedEncodingIdentifier OtherValues = 1;
+  };
+
+  struct Nullable {
+    static constexpr NestedEncodingIdentifier Data = 0;
+    static constexpr NestedEncodingIdentifier Nulls = 1;
+  };
+
+  struct RunLength {
+    static constexpr NestedEncodingIdentifier RunLengths = 0;
+    static constexpr NestedEncodingIdentifier RunValues = 1;
+  };
+
+  struct SparseBool {
+    static constexpr NestedEncodingIdentifier Indices = 0;
+  };
+
+  struct Trivial {
+    static constexpr NestedEncodingIdentifier Lengths = 0;
+  };
+};
+
+} // namespace facebook::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/EncodingPrimitives.h b/velox/experimental/wave/dwio/nimble/EncodingPrimitives.h
new file mode 100644
index 000000000000..500d7943e8e4
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/EncodingPrimitives.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstring>
+#include <string_view>
+
+#include "folly/io/IOBuf.h"
+
+// Primitives for reading and writing to a stream of bytes.
+
+namespace facebook::wave::nimble::encoding {
+
+// The write functions serialize a datum into a buffer, advancing the
+// buffer pointer appropriately.
+
+// Write a type in native format for numeric types, via WriteString
+// for string types.
+template <typename T>
+inline void write(T value, char*& pos) {
+  *reinterpret_cast<T*>(pos) = value;
+  pos += sizeof(T);
+}
+
+inline void writeChar(char value, char*& pos) {
+  write<char>(value, pos);
+}
+
+inline void writeUint32(uint32_t value, char*& pos) {
+  write<uint32_t>(value, pos);
+}
+
+inline void writeUint64(uint64_t value, char*& pos) {
+  write<uint64_t>(value, pos);
+}
+
+// Just the chars, no leading length.
+inline void writeBytes(std::string_view value, char*& pos) {
+  std::copy(value.cbegin(), value.cend(), pos);
+  pos += value.size();
+}
+
+// Just the buffers, no leading length.
+inline void writeBuffers(const folly::IOBuf& buffers, char*& pos) {
+  for (const auto buffer : buffers) {
+    std::copy(buffer.cbegin(), buffer.cend(), pos);
+    pos += buffer.size();
+  }
+}
+
+// 4 byte length followed by chars.
+inline void writeString(std::string_view value, char*& pos) {
+  writeUint32(value.size(), pos);
+  writeBytes(value, pos);
+}
+
+template <>
+inline void write(std::string_view value, char*& pos) {
+  writeString(value, pos);
+}
+
+template <>
+inline void write(const std::string& value, char*& pos) {
+  writeString({value.data(), value.size()}, pos);
+}
+
+// The read functions extract a datum from the buffer (stored in the
+// format output by the Write functions), advancing the buffer
+// pointer appropriately.
+
+// Reads a type written via Write.
+template <typename T, typename TReturn = T>
+inline TReturn read(const char*& pos) {
+  const T value = *reinterpret_cast<const T*>(pos);
+  pos += sizeof(T);
+  return static_cast<TReturn>(value);
+}
+
+inline char readChar(const char*& pos) {
+  return read<char>(pos);
+}
+
+inline uint32_t readUint32(const char*& pos) {
+  return read<uint32_t>(pos);
+}
+
+inline uint64_t readUint64(const char*& pos) {
+  return read<uint64_t>(pos);
+}
+
+inline std::string_view readString(const char*& pos) {
+  const uint32_t size = readUint32(pos);
+  std::string_view result(pos, size);
+  pos += size;
+  return result;
+}
+
+inline std::string readOwnedString(const char*& pos) {
+  const uint32_t size = readUint32(pos);
+  std::string result(pos, size);
+  pos += size;
+  return result;
+}
+
+template <>
+inline std::string_view read<std::string_view, std::string_view>(
+    const char*& pos) {
+  return readString(pos);
+}
+
+template <>
+inline std::string read<std::string, std::string>(const char*& pos) {
+  return readOwnedString(pos);
+}
+
+template <typename T, typename TReturn = T>
+inline TReturn peek(const char* pos) {
+  return static_cast<TReturn>(*reinterpret_cast<const T*>(pos));
+}
+
+} // namespace facebook::wave::nimble::encoding
diff --git a/velox/experimental/wave/dwio/nimble/NimbleFileFormat.cpp b/velox/experimental/wave/dwio/nimble/NimbleFileFormat.cpp
new file mode 100644
index 000000000000..d09a462eba1e
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/NimbleFileFormat.cpp
@@ -0,0 +1,853 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/nimble/NimbleFileFormat.h"
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/dwio/nimble/Encoding.h"
+#include "velox/experimental/wave/dwio/nimble/EncodingIdentifier.h"
+#include "velox/experimental/wave/dwio/nimble/EncodingPrimitives.h"
+#include "velox/experimental/wave/dwio/nimble/Types.h"
+
+using namespace facebook::wave::nimble;
+
+DECLARE_int32(wave_reader_rows_per_tb);
+
+namespace facebook::velox::wave {
+
+/// NimbleEncoding implementation
+NimbleEncoding::NimbleEncoding(std::string_view encodingData, bool encodeNulls)
+    : encodingData_(encodingData), encodeNulls_(encodeNulls) {
+  encodingType_ = encoding::peek<uint8_t, EncodingType>(encodingData_.data());
+  dataType_ = encoding::peek<uint8_t, DataType>(
+      encodingData_.data() + Encoding::kDataTypeOffset);
+  numValues_ = encoding::peek<uint32_t>(
+      encodingData_.data() + Encoding::kRowCountOffset);
+}
+
+NimbleEncoding::NimbleEncoding(
+    facebook::wave::nimble::EncodingType encodingType,
+    facebook::wave::nimble::DataType dataType,
+    uint32_t numValues)
+    : encodingData_{},
+      encodingType_(encodingType),
+      dataType_(dataType),
+      numValues_(numValues),
+      encodeNulls_(false) {}
+
+uint8_t NimbleEncoding::childrenCount() const {
+  const auto encodingType = this->encodingType();
+  switch (encodingType) {
+    case EncodingType::Trivial: {
+      if (dataType() == DataType::String) {
+        VELOX_NYI("Unsupported encoding type");
+      }
+      return 0;
+    }
+    case EncodingType::Dictionary:
+    case EncodingType::Nullable: {
+      return 2;
+    }
+    case EncodingType::RLE: {
+      if (dataType() == DataType::Bool) {
+        VELOX_NYI("Unsupported encoding type");
+      }
+      return 2;
+    }
+    default:
+      VELOX_NYI(
+          "Unsupported encoding type: {}", static_cast<int>(encodingType));
+  }
+}
+
+facebook::velox::TypePtr NimbleEncoding::nimbleDataTypeToVeloxType(
+    DataType nimbleDataType) const {
+  switch (nimbleDataType) {
+    case DataType::Int8:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::TINYINT>::create();
+    case DataType::Uint8:
+      // Velox doesn't have unsigned types, map to signed equivalent
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::TINYINT>::create();
+    case DataType::Int16:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::SMALLINT>::create();
+    case DataType::Uint16:
+      // Velox doesn't have unsigned types, map to signed equivalent
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::SMALLINT>::create();
+    case DataType::Int32:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::INTEGER>::create();
+    case DataType::Uint32:
+      // Velox doesn't have unsigned types, map to signed equivalent
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::INTEGER>::create();
+    case DataType::Int64:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::BIGINT>::create();
+    case DataType::Uint64:
+      // Velox doesn't have unsigned types, map to signed equivalent
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::BIGINT>::create();
+    case DataType::Float:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::REAL>::create();
+    case DataType::Double:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::DOUBLE>::create();
+    case DataType::Bool:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::BOOLEAN>::create();
+    case DataType::String:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::VARCHAR>::create();
+    case DataType::Undefined:
+    default:
+      return facebook::velox::ScalarType<
+          facebook::velox::TypeKind::UNKNOWN>::create();
+  }
+}
+
+facebook::velox::TypePtr NimbleEncoding::veloxType() const {
+  return nimbleDataTypeToVeloxType(dataType());
+}
+
+facebook::velox::TypeKind NimbleEncoding::typeKind() const {
+  return veloxType()->kind();
+}
+
+NimbleEncoding* NimbleEncoding::childAt(uint8_t childIndex) {
+  VELOX_CHECK_LT(childIndex, childrenCount(), "Child index out of range");
+  return (childIndex >= children_.size())
+      ? createChildEncodingByIndex(childIndex)
+      : children_[childIndex].get();
+}
+
+NimbleEncoding* NimbleEncoding::createChildEncodingByIndex(uint8_t childIndex) {
+  VELOX_CHECK_LT(childIndex, childrenCount(), "Child index out of range");
+
+  const auto encodingType = this->encodingType();
+  const auto dataType = this->dataType();
+  const char* pos = encodedDataPtr();
+
+  std::string_view childEncodingData;
+  bool encodeNulls = false;
+
+  switch (encodingType) {
+    case EncodingType::Dictionary: {
+      if (childIndex == 0) {
+        const uint32_t alphabetBytes = encoding::readUint32(pos);
+        childEncodingData = std::string_view(pos, alphabetBytes);
+      } else if (childIndex == 1) {
+        const uint32_t alphabetBytes = encoding::readUint32(pos);
+        pos += alphabetBytes;
+        const size_t indicesBytes =
+            encodingData_.size() - (pos - encodingData_.data());
+        childEncodingData = std::string_view(pos, indicesBytes);
+      }
+      break;
+    }
+
+    case EncodingType::RLE: {
+      if (childIndex == 0) {
+        const uint32_t runLengthBytes = encoding::readUint32(pos);
+        childEncodingData = std::string_view(pos, runLengthBytes);
+      } else if (childIndex == 1 && dataType != DataType::Bool) {
+        const uint32_t runLengthBytes = encoding::readUint32(pos);
+        pos += runLengthBytes;
+        const size_t runValuesBytes =
+            encodingData_.size() - (pos - encodingData_.data());
+        childEncodingData = std::string_view(pos, runValuesBytes);
+      }
+      break;
+    }
+
+    case EncodingType::Nullable: {
+      if (childIndex == 0) {
+        const uint32_t dataBytes = encoding::readUint32(pos);
+        childEncodingData = std::string_view(pos, dataBytes);
+      } else if (childIndex == 1) {
+        const uint32_t dataBytes = encoding::readUint32(pos);
+        pos += dataBytes;
+        const size_t nullsBytes =
+            encodingData_.size() - (pos - encodingData_.data());
+        childEncodingData = std::string_view(pos, nullsBytes);
+        encodeNulls = true;
+      }
+      break;
+    }
+
+    default:
+      VELOX_NYI("Encoding type does not support child streams");
+  }
+
+  if (childEncodingData.empty()) {
+    VELOX_NYI("Invalid child index for this encoding type");
+  }
+
+  auto child = create(childEncodingData, encodeNulls);
+  NimbleEncoding* childPtr = child.get();
+  children_.push_back(std::move(child));
+  return childPtr;
+}
+
+#define DEFINE_ENCODING_ACCESSOR(methodName)     \
+  NimbleEncoding* NimbleEncoding::methodName() { \
+    return nullptr;                              \
+  }
+
+DEFINE_ENCODING_ACCESSOR(alphabetEncoding)
+DEFINE_ENCODING_ACCESSOR(indicesEncoding)
+DEFINE_ENCODING_ACCESSOR(lengthsEncoding)
+DEFINE_ENCODING_ACCESSOR(runLengthsEncoding)
+DEFINE_ENCODING_ACCESSOR(runValuesEncoding)
+DEFINE_ENCODING_ACCESSOR(nullsEncoding)
+DEFINE_ENCODING_ACCESSOR(nonNullsEncoding)
+
+bool NimbleEncoding::isReadyToDecode() const {
+  for (auto& child : children_) {
+    if (!child->isDecoded()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+#define NIMBLE_ENCODING_FACTORY_CASE(type, className) \
+  case EncodingType::type:                            \
+    return std::make_unique<className>(encodingData, encodeNulls);
+
+std::unique_ptr<NimbleEncoding> NimbleEncoding::create(
+    std::string_view encodingData,
+    bool encodeNulls) {
+  EncodingType encodingType =
+      encoding::peek<uint8_t, EncodingType>(encodingData.data());
+
+  switch (encodingType) {
+    NIMBLE_ENCODING_FACTORY_CASE(Trivial, NimbleTrivialEncoding)
+    NIMBLE_ENCODING_FACTORY_CASE(RLE, NimbleRLEEncoding)
+    NIMBLE_ENCODING_FACTORY_CASE(Dictionary, NimbleDictionaryEncoding)
+    NIMBLE_ENCODING_FACTORY_CASE(Nullable, NimbleNullableEncoding)
+    default:
+      VELOX_NYI("Unsupported encoding type");
+  }
+}
+
+#undef NIMBLE_ENCODING_FACTORY_CASE
+
+namespace {
+void setFilter(GpuDecode* step, ColumnReader* reader) {
+  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<const common::BigintRange*>(veloxFilter)->lower();
+      step->filter._.int64Range[1] =
+          reinterpret_cast<const common::BigintRange*>(veloxFilter)->upper();
+      break;
+    }
+
+    default:
+      VELOX_UNSUPPORTED(
+          "Unsupported filter kind", static_cast<int32_t>(veloxFilter->kind()));
+  }
+}
+} // namespace
+
+std::unique_ptr<GpuDecode> NimbleEncoding::makeStepCommon(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ReadStream& stream,
+    ResultStaging& deviceStaging,
+    int32_t blockIdx,
+    bool isRoot,
+    bool processFilter,
+    int32_t resultOffset) {
+  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
+  auto maxRowsPerThread = (rowsPerBlock / kBlockSize);
+  [[maybe_unused]] int32_t numBlocks =
+      bits::roundUp(numValues(), rowsPerBlock) / rowsPerBlock;
+  auto rowsInBlock =
+      std::min<int32_t>(rowsPerBlock, numValues() - (blockIdx * rowsPerBlock));
+
+  auto step = std::make_unique<GpuDecode>();
+  step->numRowsPerThread = bits::roundUp(rowsInBlock, kBlockSize) / kBlockSize;
+  step->gridNumRowsPerThread = maxRowsPerThread;
+  step->nthBlock = blockIdx;
+  step->baseRow = rowsPerBlock * blockIdx;
+  if (processFilter && previousFilter) {
+    step->maxRow = GpuDecode::kFilterHits;
+  } else {
+    step->maxRow = (blockIdx * rowsPerBlock) + rowsInBlock;
+  }
+
+  // if the encoding is not a root, we ignore the previous filter when decoding
+  bool dense = (previousFilter == nullptr || !processFilter) &&
+      simd::isDense(op.rows.data(), op.rows.size());
+  bool nullable = isRoot && isNullableEncoding();
+  step->nullMode = dense
+      ? (nullable ? NullMode::kDenseNullable : NullMode::kDenseNonNull)
+      : (nullable ? NullMode::kSparseNullable : NullMode::kSparseNonNull);
+
+  // intermediate decoding steps don't need to worry about filters
+  if (processFilter) {
+    setFilter(step.get(), op.reader);
+  }
+
+  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);
+    }
+  }
+
+  if (processFilter && 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 (processFilter && 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);
+    }
+  }
+
+  auto columnKind = static_cast<WaveTypeKind>(typeKind());
+  step->dataType = columnKind;
+  auto kindSize = waveTypeKindSize(columnKind);
+
+  if (isRoot) {
+    step->result = op.waveVector->values<char>();
+  } else {
+    if (decodedResultBuffer_ == nullptr) {
+      decodedResultBuffer_ = stream.waveStream->deviceArena().allocate<char>(
+          kindSize * numValues());
+    }
+    step->result = decodedResultBuffer_->as<char>();
+  }
+  step->resultNulls = nullptr;
+
+  return step;
+}
+
+void NimbleEncoding::getDeviceEncodingInput(
+    SplitStaging& staging,
+    BufferId bufferId,
+    const NimbleEncoding& rootEncoding,
+    const void* hostPtr,
+    const void** devicePtr) {
+  auto* hostBasePtr = rootEncoding.encodedDataPtr();
+  void* deviceBasePtr = rootEncoding.deviceEncodedDataPtr();
+  std::ptrdiff_t offset = static_cast<const char*>(hostPtr) - hostBasePtr;
+  if (deviceBasePtr != nullptr) {
+    *devicePtr = static_cast<char*>(deviceBasePtr) + offset;
+  } else { // the root encoding is not transferred to the device yet
+    *devicePtr = reinterpret_cast<void*>(offset);
+    staging.registerPointer(bufferId, devicePtr, false);
+  }
+}
+
+// NimbleDictionaryEncoding implementation
+NimbleDictionaryEncoding::NimbleDictionaryEncoding(
+    std::string_view encodingData,
+    bool encodeNulls)
+    : NimbleEncoding(encodingData, encodeNulls) {
+  if (encodeNulls) {
+    VELOX_NYI("Dictionary-encoded null is not supported for decoding yet.");
+  }
+}
+
+NimbleEncoding* NimbleDictionaryEncoding::alphabetEncoding() {
+  return childAt(EncodingIdentifiers::Dictionary::Alphabet);
+}
+
+NimbleEncoding* NimbleDictionaryEncoding::indicesEncoding() {
+  return childAt(EncodingIdentifiers::Dictionary::Indices);
+}
+
+std::unique_ptr<GpuDecode> NimbleDictionaryEncoding::makeStep(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ReadStream& stream,
+    SplitStaging& staging,
+    ResultStaging& deviceStaging,
+    BufferId bufferId,
+    const NimbleEncoding& rootEncoding,
+    int32_t blockIdx,
+    int32_t resultOffset) {
+  VELOX_NYI("Dicionary encoding is not supported yet.");
+}
+
+// NimbleTrivialEncoding implementation
+NimbleTrivialEncoding::NimbleTrivialEncoding(
+    std::string_view encodingData,
+    bool encodeNulls)
+    : NimbleEncoding(encodingData, encodeNulls) {}
+
+NimbleEncoding* NimbleTrivialEncoding::lengthsEncoding() {
+  VELOX_NYI("Trivial encoding does not support strings yet");
+}
+
+std::unique_ptr<GpuDecode> NimbleTrivialEncoding::makeStep(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ReadStream& stream,
+    SplitStaging& splitStaging,
+    ResultStaging& deviceStaging,
+    BufferId bufferId,
+    const NimbleEncoding& rootEncoding,
+    int32_t blockIdx,
+    int32_t resultOffset) {
+  auto hostPtr = encodedDataPtr();
+  auto compressionType =
+      static_cast<CompressionType>(encoding::readChar(hostPtr));
+  if (compressionType != CompressionType::Uncompressed) {
+    VELOX_NYI("Trivial encoding does not support compression yet");
+  }
+
+  if (encodeNulls_) {
+    return makeStepNulls(
+        op,
+        stream,
+        splitStaging,
+        deviceStaging,
+        bufferId,
+        rootEncoding,
+        blockIdx,
+        resultOffset);
+  }
+  bool isRoot = (this == &rootEncoding);
+
+  // True if we process the filter in this step.
+  bool processFilter = isRoot && !op.hasMultiChunks &&
+      (previousFilter || op.reader->scanSpec().filter());
+
+  auto step = makeStepCommon(
+      op,
+      previousFilter,
+      stream,
+      deviceStaging,
+      blockIdx,
+      isRoot,
+      processFilter,
+      resultOffset);
+  auto kindSize = waveTypeKindSize(step->dataType);
+
+  // True if it is a single-chunk, filter or non-filter column
+  bool singleChunkFilter = isRoot && !op.hasMultiChunks &&
+      (previousFilter || op.reader->scanSpec().filter());
+
+  if (singleChunkFilter) {
+    if (kindSize != 4 && kindSize != 8) {
+      VELOX_NYI(
+          "Unsupported data type for nullable encoding. The data type must be either 4 or 8 bytes.");
+    }
+    step->step =
+        kindSize == 4 ? DecodeStep::kSelective32 : DecodeStep::kSelective64;
+    step->encoding = DecodeStep::kDictionaryOnBitpack;
+    step->dictMode = DictMode::kNone;
+    step->data.dictionaryOnBitpack.dataType = step->dataType;
+    step->data.dictionaryOnBitpack.alphabet = nullptr;
+    step->data.dictionaryOnBitpack.scatter = nullptr;
+    step->data.dictionaryOnBitpack.bitWidth = 8 * kindSize;
+
+    // Input is exclusive to a chunk and does not need to be specified the chunk
+    // offset. TB offset is also not needed if we set baseRow and maxRow
+    // correctly.
+    getDeviceEncodingInput(
+        splitStaging,
+        bufferId,
+        rootEncoding,
+        hostPtr,
+        reinterpret_cast<const void**>(
+            &step->data.dictionaryOnBitpack.indices));
+
+    // Output is shared across chunks and must be specified the chunk offset and
+    // the TB offset.
+    step->result = step->data.dictionaryOnBitpack.result =
+        static_cast<char*>(step->result) + resultOffset * kindSize +
+        step->baseRow * kindSize;
+
+    return step;
+  }
+
+  // True if it is a multi-chunk, non-filter column
+  bool multiChunkFiltered = isRoot && previousFilter && op.hasMultiChunks &&
+      !op.reader->scanSpec().filter();
+  if (multiChunkFiltered) {
+    step->step = kindSize == 4 ? DecodeStep::kSelective32Chunked
+                               : DecodeStep::kSelective64Chunked;
+    step->rows = previousFilter->deviceResult;
+    step->filterRowCount = previousFilter->extraRowCount;
+    step->result = op.waveVector->values<char>();
+    step->data.selectiveChunked.chunkStart = resultOffset;
+    getDeviceEncodingInput(
+        splitStaging,
+        bufferId,
+        rootEncoding,
+        hostPtr,
+        reinterpret_cast<const void**>(&step->data.selectiveChunked.input));
+    return step;
+  }
+
+  step->step = DecodeStep::kTrivial;
+  step->data.trivial.dataType = step->dataType;
+  step->data.trivial.result = static_cast<char*>(step->result) +
+      kindSize * resultOffset + kindSize * step->baseRow;
+  step->data.trivial.begin = 0;
+  step->data.trivial.end = step->maxRow - step->baseRow;
+  step->data.trivial.scatter = nullptr;
+  getDeviceEncodingInput(
+      splitStaging,
+      bufferId,
+      rootEncoding,
+      hostPtr + step->baseRow * waveTypeKindSize(step->dataType),
+      &step->data.trivial.input);
+  return step;
+}
+
+std::unique_ptr<GpuDecode> NimbleTrivialEncoding::makeStepNulls(
+    ColumnOp& op,
+    ReadStream& stream,
+    SplitStaging& splitStaging,
+    ResultStaging& deviceStaging,
+    BufferId bufferId,
+    const NimbleEncoding& rootEncoding,
+    int32_t blockIdx,
+    int32_t offset) {
+  constexpr int32_t kCountStride = 1024;
+
+  if (stagedNulls_) {
+    return nullptr;
+  }
+  stagedNulls_ = true;
+
+  // For bools, we don't need to decode the data, just transfer the data
+  // we do not transfer the nulls with the root encoding because we want to
+  // make sure the null encodings are aligned.
+  Staging staging(
+      encodedDataPtr() + 1, // skip the compression type
+      bits::nwords(numValues()) * sizeof(uint64_t),
+      common::Region{0, 0});
+  auto nullStageId = splitStaging.add(staging);
+  splitStaging.registerPointer(nullStageId, &nulls_, true);
+
+  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
+  auto numBlocks = bits::roundUp(numValues(), rowsPerBlock) / rowsPerBlock;
+
+  // A single thread block is enough to decode the nulls
+  if (numBlocks == 1) {
+    return nullptr;
+  }
+
+  auto count = std::make_unique<GpuDecode>();
+  splitStaging.registerPointer(nullStageId, &count->data.countBits.bits, true);
+  auto numStrides = bits::roundUp(numValues(), kCountStride) / kCountStride;
+  auto resultId = deviceStaging.reserve(sizeof(int32_t) * numStrides);
+  deviceStaging.registerPointer(resultId, &count->result, true);
+  deviceStaging.registerPointer(resultId, &numNonNull_, true);
+  count->step = DecodeStep::kCountBits;
+  count->data.countBits.numBits = numValues();
+  count->data.countBits.resultStride = kCountStride;
+
+  return count;
+}
+
+// NimbleRLEEncoding implementation
+NimbleRLEEncoding::NimbleRLEEncoding(
+    std::string_view encodingData,
+    bool encodeNulls)
+    : NimbleEncoding(encodingData, encodeNulls) {
+  if (encodeNulls) {
+    VELOX_NYI("RLE-encoded null is not supported for decoding yet.");
+  }
+}
+
+NimbleEncoding* NimbleRLEEncoding::runLengthsEncoding() {
+  return childAt(EncodingIdentifiers::RunLength::RunLengths);
+}
+
+NimbleEncoding* NimbleRLEEncoding::runValuesEncoding() {
+  if (dataType() != DataType::Bool) {
+    return childAt(EncodingIdentifiers::RunLength::RunValues);
+  }
+  VELOX_NYI("RLE encoding does not support bools yet");
+}
+
+std::unique_ptr<GpuDecode> NimbleRLEEncoding::makeStep(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ReadStream& stream,
+    SplitStaging& staging,
+    ResultStaging& deviceStaging,
+
+    BufferId bufferId,
+    const NimbleEncoding& rootEncoding,
+    int32_t blockIdx,
+    int32_t resultOffset) {
+  VELOX_NYI("RLE encoding is not supported yet.");
+}
+
+// NimbleNullableEncoding implementation
+NimbleNullableEncoding::NimbleNullableEncoding(
+    std::string_view encodingData,
+    bool encodeNulls)
+    : NimbleEncoding(encodingData, encodeNulls) {
+  VELOX_CHECK(!encodeNulls, "Nullable encoding cannot be used to encode nulls");
+}
+
+NimbleEncoding* NimbleNullableEncoding::nullsEncoding() {
+  return childAt(EncodingIdentifiers::Nullable::Nulls);
+}
+
+NimbleEncoding* NimbleNullableEncoding::nonNullsEncoding() {
+  return childAt(EncodingIdentifiers::Nullable::Data);
+}
+
+std::unique_ptr<GpuDecode> NimbleNullableEncoding::makeStep(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ReadStream& stream,
+    SplitStaging& staging,
+    ResultStaging& deviceStaging,
+    BufferId bufferId,
+    const NimbleEncoding& rootEncoding,
+    int32_t blockIdx,
+    int32_t resultOffset) {
+  VELOX_CHECK(
+      this == &rootEncoding,
+      "Only root encoding can be decoded for nullable encoding");
+  bool isRoot = (this == &rootEncoding);
+  bool processFilter = isRoot && !op.hasMultiChunks &&
+      (previousFilter || op.reader->scanSpec().filter());
+  auto step = makeStepCommon(
+      op,
+      previousFilter,
+      stream,
+      deviceStaging,
+      blockIdx,
+      isRoot,
+      processFilter,
+      resultOffset);
+  auto kindSize = waveTypeKindSize(step->dataType);
+  if (kindSize != 4 && kindSize != 8) {
+    VELOX_NYI(
+        "Unsupported data type for nullable encoding. The data type must be either 4 or 8 bytes.");
+  }
+  auto dataBufferPtr =
+      childAt(EncodingIdentifiers::Nullable::Data)->decodedResultBuffer();
+
+  bool multiChunkFiltered = isRoot && previousFilter && op.hasMultiChunks &&
+      !op.reader->scanSpec().filter();
+  if (multiChunkFiltered) {
+    step->step = kindSize == 4 ? DecodeStep::kSelective32Chunked
+                               : DecodeStep::kSelective64Chunked;
+    step->rows = previousFilter->deviceResult;
+    step->filterRowCount = previousFilter->extraRowCount;
+    step->result = op.waveVector->values<char>();
+    step->nulls =
+        childAt(EncodingIdentifiers::Nullable::Nulls)->nulls(); // chunk local
+    step->nonNullBases =
+        childAt(EncodingIdentifiers::Nullable::Nulls)->numNonNull();
+
+    step->resultNulls = op.waveVector->nulls();
+    step->result = op.waveVector->values<void>();
+
+    step->data.selectiveChunked.chunkStart = resultOffset;
+    step->data.selectiveChunked.input =
+        dataBufferPtr ? dataBufferPtr->as<void>() : nullptr;
+    return step;
+  }
+
+  step->step =
+      kindSize == 4 ? DecodeStep::kSelective32 : DecodeStep::kSelective64;
+  step->encoding = DecodeStep::kDictionaryOnBitpack;
+  step->dictMode = DictMode::kNone;
+  step->data.dictionaryOnBitpack.dataType = step->dataType;
+  step->data.dictionaryOnBitpack.alphabet = nullptr;
+  step->data.dictionaryOnBitpack.scatter = nullptr;
+  step->data.dictionaryOnBitpack.bitWidth = 8 * kindSize;
+
+  // Input is exclusive to a chunk and does not need to be specified the chunk
+  // offset. TB offset is also not needed if we set baseRow and maxRow
+  // correctly.
+  step->data.dictionaryOnBitpack.indices =
+      dataBufferPtr ? dataBufferPtr->as<uint64_t>() : nullptr;
+  step->nulls =
+      childAt(EncodingIdentifiers::Nullable::Nulls)->nulls(); // chunk local
+  step->nonNullBases =
+      childAt(EncodingIdentifiers::Nullable::Nulls)->numNonNull();
+
+  // Output is shared across chunks and must be specified the chunk offset and
+  // the TB offset.
+  step->resultNulls = op.waveVector->nulls() + resultOffset +
+      step->baseRow; // shared across chunks
+  step->result = step->data.dictionaryOnBitpack.result =
+      static_cast<char*>(step->result) + resultOffset * kindSize +
+      step->baseRow * kindSize;
+
+  return step;
+}
+
+NimbleFilterEncoding::NimbleFilterEncoding(
+    facebook::wave::nimble::DataType dataType,
+    uint32_t numValues,
+    bool hasNulls)
+    : NimbleEncoding(
+          hasNulls ? EncodingType::Nullable : EncodingType::Trivial,
+          dataType,
+          numValues) {}
+
+std::unique_ptr<GpuDecode> NimbleFilterEncoding::makeStep(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ReadStream& stream,
+    SplitStaging& staging,
+    ResultStaging& deviceStaging,
+    BufferId bufferId,
+    const NimbleEncoding& rootEncoding,
+    int32_t blockIdx,
+    int32_t resultOffset) {
+  auto step = makeStepCommon(
+      op,
+      previousFilter,
+      stream,
+      deviceStaging,
+      blockIdx,
+      true,
+      true,
+      resultOffset);
+
+  auto columnKind = static_cast<WaveTypeKind>(typeKind());
+  step->dataType = columnKind;
+  auto kindSize = waveTypeKindSize(columnKind);
+  if (kindSize != 4 && kindSize != 8) {
+    VELOX_NYI(
+        "Unsupported data type for filters. The data type must be either 4 or 8 bytes.");
+  }
+  step->step =
+      kindSize == 4 ? DecodeStep::kSelective32 : DecodeStep::kSelective64;
+  step->encoding = DecodeStep::kDictionaryOnBitpack;
+  step->dictMode = DictMode::kNone;
+  step->data.dictionaryOnBitpack.dataType = step->dataType;
+  step->data.dictionaryOnBitpack.alphabet = nullptr;
+  step->data.dictionaryOnBitpack.scatter = nullptr;
+  step->data.dictionaryOnBitpack.bitWidth = 8 * kindSize;
+  step->data.dictionaryOnBitpack.indices = op.waveVector->values<uint64_t>();
+  step->nulls = reinterpret_cast<char*>(op.waveVector->nulls());
+  step->isNullsBitmap = false;
+  step->result = step->data.dictionaryOnBitpack.result =
+      op.waveVector->values<char>() + step->baseRow * kindSize;
+  step->resultNulls = op.waveVector->nulls() + step->baseRow;
+
+  return step;
+}
+
+/// NimbleChunk implementation
+NimbleChunk::NimbleChunk(std::string_view chunkData) : chunkData_(chunkData) {}
+
+std::unique_ptr<NimbleEncoding> NimbleChunk::parseEncodingFromChunk(
+    std::string_view chunkData) {
+  VELOX_CHECK(
+      chunkData.size() >= sizeof(uint32_t) + sizeof(char),
+      "Chunk data too small to contain header");
+
+  const char* pos = chunkData.data();
+
+  auto encodingDataLength = encoding::readUint32(pos);
+
+  const size_t headerSize = sizeof(uint32_t) + sizeof(char);
+  VELOX_CHECK(
+      chunkData.size() >= headerSize + encodingDataLength,
+      "Chunk data size does not match header length");
+
+  std::string_view encodingData =
+      chunkData.substr(headerSize, encodingDataLength);
+
+  return NimbleEncoding::create(encodingData, false);
+}
+
+/// NimbleChunkedStream implementation
+NimbleChunkedStream::NimbleChunkedStream(
+    velox::memory::MemoryPool& memoryPool,
+    std::string_view streamData)
+    : streamData_(streamData), pos_(streamData.data()) {}
+
+bool NimbleChunkedStream::hasNext() {
+  return pos_ - streamData_.data() < streamData_.size();
+}
+
+NimbleChunk NimbleChunkedStream::nextChunk() {
+  VELOX_CHECK(
+      sizeof(uint32_t) + sizeof(char) <=
+          streamData_.size() - (pos_ - streamData_.data()),
+      "Read beyond end of stream");
+
+  // Read the chunk header to get length and compression type
+  const char* headerPos = pos_;
+  auto length = encoding::readUint32(pos_);
+  [[maybe_unused]] auto compressionType =
+      static_cast<CompressionType>(encoding::readChar(pos_));
+
+  VELOX_CHECK(
+      length <= streamData_.size() - (pos_ - streamData_.data()),
+      "Read beyond end of stream");
+
+  const size_t headerSize = sizeof(uint32_t) + sizeof(char);
+  const size_t totalChunkSize = headerSize + length;
+
+  std::string_view chunkData;
+  chunkData = std::string_view(headerPos, totalChunkSize);
+
+  pos_ += length;
+
+  return NimbleChunk(chunkData);
+}
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/NimbleFileFormat.h b/velox/experimental/wave/dwio/nimble/NimbleFileFormat.h
new file mode 100644
index 000000000000..e16753680b8f
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/NimbleFileFormat.h
@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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_view>
+#include <vector>
+#include "velox/experimental/wave/common/Buffer.h"
+#include "velox/experimental/wave/dwio/FormatData.h"
+#include "velox/experimental/wave/dwio/decode/DecodeStep.h"
+#include "velox/experimental/wave/dwio/nimble/Encoding.h"
+#include "velox/experimental/wave/dwio/nimble/Types.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::wave {
+
+// Base class for all Nimble encodings
+class NimbleEncoding {
+ public:
+  explicit NimbleEncoding(std::string_view encodingData, bool encodeNulls);
+  explicit NimbleEncoding(
+      facebook::wave::nimble::EncodingType encodingType,
+      facebook::wave::nimble::DataType dataType,
+      uint32_t numValues);
+
+  virtual ~NimbleEncoding() = default;
+
+  std::string_view encodingData() const {
+    return encodingData_;
+  }
+
+  facebook::wave::nimble::EncodingType encodingType() const {
+    return encodingType_;
+  }
+
+  // Get a string_view of just the encoded data region (excluding prefix)
+  std::string_view encodedData() const {
+    return encodingData_.substr(facebook::wave::nimble::Encoding::kPrefixSize);
+  }
+
+  // Get pointer to the encoded data region (after the 6-byte prefix)
+  const char* encodedDataPtr() const {
+    return encodedData().data();
+  }
+
+  facebook::wave::nimble::DataType dataType() const {
+    return dataType_;
+  }
+
+  uint32_t numValues() const {
+    return numValues_;
+  }
+
+  facebook::velox::TypePtr veloxType() const;
+  facebook::velox::TypeKind typeKind() const;
+
+  uint8_t childrenCount() const;
+  NimbleEncoding* childAt(uint8_t childIndex);
+
+#define NIMBLE_ENCODING_TYPE_CHECK(name, type)                          \
+  bool is##name##Encoding() const {                                     \
+    return encodingType_ == facebook::wave::nimble::EncodingType::type; \
+  }
+
+  NIMBLE_ENCODING_TYPE_CHECK(Trivial, Trivial)
+  NIMBLE_ENCODING_TYPE_CHECK(RLE, RLE)
+  NIMBLE_ENCODING_TYPE_CHECK(Dictionary, Dictionary)
+  NIMBLE_ENCODING_TYPE_CHECK(Nullable, Nullable)
+
+#undef NIMBLE_ENCODING_TYPE_CHECK
+
+  // return nullptr if not applicable for this encoding type
+  // Dictionary
+  virtual NimbleEncoding* alphabetEncoding();
+  virtual NimbleEncoding* indicesEncoding();
+  // Trivial
+  virtual NimbleEncoding* lengthsEncoding();
+  // RLE
+  virtual NimbleEncoding* runLengthsEncoding();
+  virtual NimbleEncoding* runValuesEncoding();
+  // Nullable
+  virtual NimbleEncoding* nullsEncoding();
+  virtual NimbleEncoding* nonNullsEncoding();
+
+  static std::unique_ptr<NimbleEncoding> create(
+      std::string_view encodingData,
+      bool encodeNulls);
+
+  // Check if the encoding is ready to be decoded
+  bool isDecoded() const {
+    return decoded_;
+  }
+  void setDecoded() {
+    decoded_ = true;
+  }
+  bool isReadyToDecode() const;
+
+  // Populates the encoding-specific members and does necessary preparation
+  // required by decoding.
+  virtual std::unique_ptr<GpuDecode> makeStep(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ReadStream& stream,
+      SplitStaging& staging,
+      ResultStaging& deviceStaging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      int32_t blockIdx,
+      int32_t resultOffset) = 0;
+
+  // Specially used for dealing with the null bitmasks. If an encoding
+  // (currently only trivial, but may be more in the future) encodes null
+  // bitmask rather than regular values, it needs to call this function.
+  virtual std::unique_ptr<GpuDecode> makeStepNulls(
+      ColumnOp& op,
+      ReadStream& stream,
+      SplitStaging& staging,
+      ResultStaging& deviceStaging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      int32_t blockIdx,
+      int32_t offset = 0) {
+    return nullptr;
+  }
+
+  void* deviceEncodedDataPtr() const {
+    return deviceEncodedData_;
+  }
+
+  void** deviceEncodedDataPtrPtr() {
+    return &deviceEncodedData_;
+  }
+
+  facebook::velox::wave::WaveBufferPtr decodedResultBuffer() const {
+    return decodedResultBuffer_;
+  }
+
+  char* nulls() const {
+    return nulls_;
+  }
+
+  int32_t* numNonNull() const {
+    return numNonNull_;
+  }
+
+ protected:
+  facebook::velox::TypePtr nimbleDataTypeToVeloxType(
+      facebook::wave::nimble::DataType nimbleDataType) const;
+
+  // Populates the shared members of GpuDecode of different encodings.
+  std::unique_ptr<GpuDecode> makeStepCommon(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ReadStream& stream,
+      ResultStaging& deviceStaging,
+      int32_t blockIdx,
+      bool isRoot,
+      bool processFilter,
+      int32_t resultOffset);
+  void getDeviceEncodingInput(
+      SplitStaging& staging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      const void* hostPtr,
+      const void** devicePtr);
+
+ protected:
+  std::string_view encodingData_;
+  facebook::wave::nimble::EncodingType encodingType_;
+  facebook::wave::nimble::DataType dataType_;
+  uint32_t numValues_;
+  std::vector<std::unique_ptr<NimbleEncoding>> children_;
+  void* deviceEncodedData_{nullptr};
+  facebook::velox::wave::WaveBufferPtr decodedResultBuffer_;
+  bool decoded_{false};
+  char* nulls_{nullptr};
+  bool stagedNulls_{false};
+  int32_t* numNonNull_{nullptr};
+
+  // true if this encoding encodes the null bitmask from Nullable
+  bool encodeNulls_{false};
+
+ private:
+  NimbleEncoding* createChildEncodingByIndex(uint8_t childIndex);
+};
+
+// Dictionary encoding subclass
+class NimbleDictionaryEncoding : public NimbleEncoding {
+ public:
+  explicit NimbleDictionaryEncoding(
+      std::string_view encodingData,
+      bool encodeNulls);
+
+  NimbleEncoding* alphabetEncoding() override;
+  NimbleEncoding* indicesEncoding() override;
+  std::unique_ptr<GpuDecode> makeStep(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ReadStream& stream,
+      SplitStaging& staging,
+      ResultStaging& deviceStaging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      int32_t blockIdx,
+      int32_t resultOffset) override;
+};
+
+// Trivial encoding subclass
+class NimbleTrivialEncoding : public NimbleEncoding {
+ public:
+  explicit NimbleTrivialEncoding(
+      std::string_view encodingData,
+      bool encodeNulls);
+
+  NimbleEncoding* lengthsEncoding() override;
+  std::unique_ptr<GpuDecode> makeStep(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ReadStream& stream,
+      SplitStaging& staging,
+      ResultStaging& deviceStaging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      int32_t blockIdx,
+      int32_t offset = 0) override;
+  std::unique_ptr<GpuDecode> makeStepNulls(
+      ColumnOp& op,
+      ReadStream& stream,
+      SplitStaging& staging,
+      ResultStaging& deviceStaging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      int32_t blockIdx,
+      int32_t resultOffset) override;
+};
+
+// RLE encoding subclass
+class NimbleRLEEncoding : public NimbleEncoding {
+ public:
+  explicit NimbleRLEEncoding(std::string_view encodingData, bool encodeNulls);
+
+  NimbleEncoding* runLengthsEncoding() override;
+  NimbleEncoding* runValuesEncoding() override;
+  std::unique_ptr<GpuDecode> makeStep(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ReadStream& stream,
+      SplitStaging& staging,
+      ResultStaging& deviceStaging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      int32_t blockIdx,
+      int32_t resultOffset) override;
+};
+
+// Nullable encoding subclass
+class NimbleNullableEncoding : public NimbleEncoding {
+ public:
+  explicit NimbleNullableEncoding(
+      std::string_view encodingData,
+      bool encodeNulls);
+
+  NimbleEncoding* nullsEncoding() override;
+  NimbleEncoding* nonNullsEncoding() override;
+  std::unique_ptr<GpuDecode> makeStep(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ReadStream& stream,
+      SplitStaging& staging,
+      ResultStaging& deviceStaging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      int32_t blockIdx,
+      int32_t resultOffset) override;
+};
+
+class NimbleFilterEncoding : public NimbleEncoding {
+ public:
+  explicit NimbleFilterEncoding(
+      facebook::wave::nimble::DataType dataType,
+      uint32_t numValues,
+      bool hasNulls);
+
+  std::unique_ptr<GpuDecode> makeStep(
+      ColumnOp& op,
+      const ColumnOp* previousFilter,
+      ReadStream& stream,
+      SplitStaging& staging,
+      ResultStaging& deviceStaging,
+      BufferId bufferId,
+      const NimbleEncoding& rootEncoding,
+      int32_t blockIdx,
+      int32_t resultOffset) override;
+};
+
+class NimbleChunk {
+ public:
+  // Chunk layout: length + compression type + encoding data
+  explicit NimbleChunk(std::string_view chunkData);
+
+  // Get the raw chunk data including header
+  std::string_view chunkData() const {
+    return chunkData_;
+  }
+
+  static std::unique_ptr<NimbleEncoding> parseEncodingFromChunk(
+      std::string_view chunkData);
+
+ private:
+  std::string_view chunkData_;
+};
+
+class NimbleChunkedStream {
+ public:
+  NimbleChunkedStream(
+      velox::memory::MemoryPool& memoryPool,
+      std::string_view streamData);
+
+  bool hasNext();
+
+  NimbleChunk nextChunk();
+
+ private:
+  std::string_view streamData_;
+  const char* pos_;
+};
+
+class NimbleStripe {
+ public:
+  NimbleStripe(
+      std::vector<std::unique_ptr<NimbleChunkedStream>>&& in,
+      const std::shared_ptr<const dwio::common::TypeWithId>& type,
+      int32_t totalRows)
+      : typeWithId_(type), streams_(std::move(in)), totalRows_(totalRows) {}
+
+  NimbleChunkedStream* findStream(const dwio::common::TypeWithId& child) const {
+    for (auto i = 0; i < typeWithId_->size(); ++i) {
+      if (typeWithId_->childAt(i)->id() == child.id()) {
+        return streams_[i].get();
+      }
+    }
+    VELOX_FAIL("No such column {}", child.id());
+  }
+
+  int32_t numStreams() const {
+    return streams_.size();
+  }
+
+  int32_t totalRows() const {
+    return totalRows_;
+  }
+
+ private:
+  std::shared_ptr<const dwio::common::TypeWithId> typeWithId_;
+  std::vector<std::unique_ptr<NimbleChunkedStream>> streams_;
+  int32_t totalRows_;
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/NimbleFormatData.cpp b/velox/experimental/wave/dwio/nimble/NimbleFormatData.cpp
new file mode 100644
index 000000000000..03082d943dd4
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/NimbleFormatData.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/experimental/wave/dwio/nimble/NimbleFormatData.h"
+
+DECLARE_int32(wave_reader_rows_per_tb);
+
+namespace facebook::velox::wave {
+std::unique_ptr<FormatData> NimbleFormatParams::toFormatData(
+    const std::shared_ptr<const dwio::common::TypeWithId>& type,
+    const velox::common::ScanSpec& scanSpec,
+    OperandId operand) {
+  std::vector<NimbleChunkDecodePipeline> pipelines;
+  if (type->type()->kind() == TypeKind::ROW) {
+    return std::make_unique<NimbleFormatData>(
+        operand, stripe_.totalRows(), std::move(pipelines));
+  }
+  auto* stream = getChunkedStream(*type);
+  VELOX_CHECK_NOT_NULL(stream, "NimbleChunkedStream is null.");
+  while (stream->hasNext()) {
+    auto chunk = stream->nextChunk();
+    pipelines.emplace_back(
+        NimbleChunk::parseEncodingFromChunk(chunk.chunkData()));
+  }
+  int32_t totalRows = 0;
+  for (auto& pipeline : pipelines) {
+    totalRows += pipeline[pipeline.size() - 1].numValues();
+  }
+
+  VELOX_CHECK_EQ(totalRows, stripe_.totalRows());
+  return std::make_unique<NimbleFormatData>(
+      operand, totalRows, std::move(pipelines));
+}
+
+BufferId NimbleFormatData::stageNulls(
+    ResultStaging& deviceStaging,
+    SplitStaging& splitStaging) {
+  if (!hasNulls()) {
+    nullsStaged_ = true;
+    return kNotRegistered;
+  } else {
+    VELOX_NYI("Nulls are not supported yet");
+  }
+}
+
+void NimbleFormatData::griddize(
+    ColumnOp& op,
+    int32_t blockSize,
+    int32_t numBlocks,
+    ResultStaging& deviceStaging,
+    ResultStaging& resultStaging,
+    SplitStaging& staging,
+    DecodePrograms& programs,
+    ReadStream& stream) {
+  griddized_ = true;
+  return;
+}
+
+int32_t NimbleFormatData::maxDecodeLevel() const {
+  int32_t maxLevel = 0;
+  for (auto& pipeline : pipelines_) {
+    maxLevel = std::max(maxLevel, pipeline.maxLevel());
+  }
+  return maxLevel;
+}
+
+bool NimbleFormatData::hasMultiChunks() const {
+  return pipelines_.size() > 1;
+}
+
+void NimbleFormatData::startOp(
+    ColumnOp& op,
+    const ColumnOp* previousFilter,
+    ResultStaging& deviceStaging,
+    ResultStaging& resultStaging,
+    SplitStaging& splitStaging,
+    DecodePrograms& program,
+    ReadStream& stream) {
+  auto rowsPerBlock = FLAGS_wave_reader_rows_per_tb;
+  op.isFinal = true;
+
+  bool newSteps = false;
+  for (size_t i = 0; i < pipelines_.size(); ++i) {
+    auto& pipeline = pipelines_[i];
+    auto& rootEncoding = pipeline.rootEncoding();
+    BufferId id = kNoBufferId;
+    if (!streamStaged_) {
+      Staging staging(
+          rootEncoding.encodedDataPtr(),
+          rootEncoding.encodedData().size(),
+          common::Region{0, 0}); // TODO(bowenwu): revisit the
+                                 // region construction here
+      id = splitStaging.add(staging);
+      lastStagingId_ = splitStaging.id();
+      splitStaging.registerPointer(
+          id, rootEncoding.deviceEncodedDataPtrPtr(), true);
+    } else {
+      VELOX_CHECK_NOT_NULL(rootEncoding.deviceEncodedDataPtr());
+    }
+
+    while (auto encoding = pipeline.next(op.decodeLevel)) {
+      auto offset = encoding == &rootEncoding ? offsets_[i] : 0;
+      int32_t numBlocks =
+          bits::roundUp(encoding->numValues(), 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 step = encoding->makeStep(
+            op,
+            previousFilter,
+            stream,
+            splitStaging,
+            deviceStaging,
+            id,
+            rootEncoding,
+            blockIdx,
+            offset);
+        if (!step) {
+          continue;
+        }
+        newSteps = true;
+        bool processFilter = step->filterKind != WaveFilterKind::kAlwaysTrue;
+        // To process filters in a cascading way, we must make sure the same
+        // thread block always process the same set of rows.
+        bool serialDispatch = processFilter && previousFilter;
+        if (serialDispatch) {
+          program.programs[blockIdx].push_back(std::move(step));
+        } else {
+          program.programs.emplace_back();
+          program.programs.back().push_back(std::move(step));
+        }
+      }
+    }
+    op.isFinal &= pipeline.finished();
+  }
+
+  auto readyForMultiChunkFiltering = [&]() {
+    // if this column does not have a filter or there is only one chunk, we can
+    // do the filtering in the same kernel as decoding
+    if (!op.reader->scanSpec().filter() || !op.hasMultiChunks) {
+      return false;
+    }
+
+    // Wait for all chunks to be decoded, which is indicated by no new decode
+    // steps are created
+    if (newSteps || !op.isFinal) {
+      op.isFinal = false;
+      return false;
+    }
+
+    return true;
+  };
+
+  // if this column has a filter or the table has a filter and has multiple
+  // chunks, we need to do the filter in a separate kernel launch
+  if (readyForMultiChunkFiltering()) {
+    auto numBlocks = bits::roundUp(totalRows_, rowsPerBlock) / rowsPerBlock;
+    VELOX_CHECK_LT(numBlocks, 256 * 256, "Overflow 16 bit block number");
+
+    program.programs.resize(numBlocks);
+
+    NimbleFilterEncoding filterEncoding(
+        pipelines_[0].rootEncoding().dataType(), totalRows_, hasNulls());
+
+    for (auto blockIdx = 0; blockIdx < numBlocks; ++blockIdx) {
+      auto step = filterEncoding.makeStep(
+          op,
+          previousFilter,
+          stream,
+          splitStaging,
+          deviceStaging,
+          -1,
+          filterEncoding,
+          blockIdx,
+          0);
+      // Multiple filters may be processed together in a cascading way, so we
+      // must make sure the same physical thread block always process the same
+      // set of rows across all columns that bear a filter in order to avoid
+      // dependency between thread blocks.
+      program.programs[blockIdx].push_back(std::move(step));
+    }
+  }
+
+  streamStaged_ = true;
+}
+
+// NimbleChunkDecodePipeline implementation
+NimbleChunkDecodePipeline::NimbleChunkDecodePipeline(
+    std::unique_ptr<NimbleEncoding> encoding)
+    : encoding_(std::move(encoding)) {
+  if (!encoding_) {
+    return;
+  }
+
+  std::queue<std::pair<NimbleEncoding*, int32_t>> queue;
+  queue.push({encoding_.get(), 0});
+
+  while (!queue.empty()) {
+    auto [node, level] = queue.front();
+    queue.pop();
+    pipeline_.push_back({node, level});
+    maxLevel_ = std::max(maxLevel_, level);
+
+    for (uint8_t i = 0; i < node->childrenCount(); ++i) {
+      queue.push({node->childAt(i), level + 1});
+    }
+  }
+
+  // currentLevel_ = maxLevel_;
+
+  std::reverse(pipeline_.begin(), pipeline_.end());
+
+  // Reorder pipeline to ensure all leaves come first
+  std::stable_partition(pipeline_.begin(), pipeline_.end(), [](auto& node) {
+    return node.first->childrenCount() == 0;
+  });
+
+  currentEncoding_ = pipeline_.begin();
+}
+
+NimbleEncoding* NimbleChunkDecodePipeline::next(int32_t level) {
+  if (finished() || !(currentEncoding_->first->isReadyToDecode())) {
+    for (auto it = currentEncoding_ - 1;
+         it >= pipeline_.begin() && !it->first->isDecoded();
+         --it) {
+      it->first->setDecoded();
+    }
+    return nullptr;
+  }
+
+  if (level != kAnyLevel && currentEncoding_->second != level) {
+    return nullptr;
+  }
+
+  return (currentEncoding_++)->first;
+}
+
+bool NimbleChunkDecodePipeline::finished() const {
+  return currentEncoding_ == pipeline_.end();
+}
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/NimbleFormatData.h b/velox/experimental/wave/dwio/nimble/NimbleFormatData.h
new file mode 100644
index 000000000000..b9f7a26c1601
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/NimbleFormatData.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/dwio/common/ScanSpec.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/dwio/common/TypeWithId.h"
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/dwio/FormatData.h"
+#include "velox/experimental/wave/dwio/decode/DecodeStep.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
+#include "velox/experimental/wave/vector/Operand.h"
+
+namespace facebook::velox::wave {
+
+class NimbleChunkDecodePipeline {
+  constexpr static int32_t kAnyLevel = -1;
+
+ public:
+  NimbleChunkDecodePipeline(std::unique_ptr<NimbleEncoding> encoding);
+  NimbleChunkDecodePipeline(NimbleChunk const& chunk);
+  NimbleEncoding* next(int32_t level = kAnyLevel);
+  bool finished() const;
+  uint32_t size() const {
+    return pipeline_.size();
+  }
+  NimbleEncoding& operator[](uint32_t index) {
+    return *(pipeline_[index].first);
+  }
+  NimbleEncoding& rootEncoding() const {
+    return *encoding_;
+  }
+  int32_t maxLevel() const {
+    return maxLevel_;
+  }
+
+ private:
+  std::unique_ptr<NimbleEncoding> encoding_;
+  std::vector<std::pair<NimbleEncoding*, int32_t>> pipeline_;
+  typename decltype(pipeline_)::iterator currentEncoding_;
+  int32_t maxLevel_{0};
+  // int32_t currentLevel_{0};
+};
+
+class NimbleFormatData : public wave::FormatData {
+ public:
+  static constexpr int32_t kNotRegistered = -1;
+
+  NimbleFormatData(
+      OperandId operand,
+      int32_t totalRows,
+      std::vector<NimbleChunkDecodePipeline>&& pipelines)
+      : operand_(operand),
+        totalRows_(totalRows),
+        pipelines_(std::move(pipelines)) {
+    offsets_.resize(pipelines_.size());
+    int32_t sum = 0;
+    for (size_t i = 0; i < pipelines_.size(); ++i) {
+      offsets_[i] = sum;
+      sum += pipelines_[i].rootEncoding().numValues();
+    }
+  }
+
+  bool hasNulls() const override {
+    for (int i = 0; i < pipelines_.size(); i++) {
+      auto& pipeline = pipelines_[i];
+      if (pipeline.rootEncoding().isNullableEncoding()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  int32_t totalRows() const override {
+    return totalRows_;
+  }
+
+  void newBatch(int32_t startRow) override {
+    currentRow_ = startRow;
+    queued_ = false;
+  }
+
+  int32_t maxDecodeLevel() const override;
+  bool hasMultiChunks() const override;
+
+  void griddize(
+      ColumnOp& op,
+      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_;
+  bool queued_{false};
+  int32_t totalRows_{0};
+  bool nullsStaged_{false};
+  bool streamStaged_{false};
+
+  const NimbleEncoding* encoding_;
+  std::vector<NimbleChunkDecodePipeline> pipelines_;
+  std::vector<int32_t> offsets_;
+};
+
+class NimbleFormatParams : public wave::FormatParams {
+ public:
+  NimbleFormatParams(
+      memory::MemoryPool& pool,
+      dwio::common::ColumnReaderStatistics& stats,
+      NimbleStripe& 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;
+
+  NimbleChunkedStream* getChunkedStream(
+      const dwio::common::TypeWithId& child) const {
+    return stripe_.findStream(child);
+  }
+
+  NimbleStripe& stripe() {
+    return stripe_;
+  }
+
+ private:
+  NimbleStripe& stripe_;
+};
+
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.cpp b/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.cpp
new file mode 100644
index 000000000000..34a1756bec6e
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.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/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h"
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/dwio/StructColumnReader.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
+
+namespace facebook::velox::wave::nimble {
+
+SelectiveStructColumnReader::SelectiveStructColumnReader(
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+    NimbleFormatParams& params,
+    common::ScanSpec& scanSpec,
+    std::vector<std::unique_ptr<AbstractOperand>>&& operands,
+    bool isRoot)
+    : StructColumnReader(
+          requestedType,
+          fileType,
+          operands[0].get(),
+          params,
+          scanSpec,
+          isRoot),
+      operands_(std::move(operands)) {
+  // 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 = NimbleFormatParams(
+        params.pool(), params.runtimeStatistics(), params.stripe());
+
+    auto childOperand = std::make_unique<AbstractOperand>(
+        i + 1, childRequestedType, "c" + std::to_string(i));
+
+    addChild(
+        NimbleFormatReader::build(
+            childRequestedType,
+            childFileType,
+            params,
+            *childSpec /*, path, defines*/,
+            childOperand.get()));
+    childSpec->setSubscript(children_.size() - 1);
+    operands_.push_back(std::move(childOperand));
+  }
+}
+
+// static
+std::unique_ptr<ColumnReader> NimbleFormatReader::build(
+    const TypePtr& requestedType,
+    const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+    NimbleFormatParams& params,
+    common::ScanSpec& scanSpec,
+    AbstractOperand* operand,
+    bool isRoot) {
+  VELOX_CHECK(isRoot || operand != nullptr, "Operand is null.");
+  std::vector<std::unique_ptr<AbstractOperand>> operands;
+  operands.push_back(nullptr); // root does not need an operand
+  switch (fileType->type()->kind()) {
+    case TypeKind::INTEGER:
+    case TypeKind::BIGINT:
+    case TypeKind::DOUBLE:
+    case TypeKind::REAL:
+      return std::make_unique<ColumnReader>(
+          requestedType, fileType, operand, params, scanSpec);
+
+    case TypeKind::ROW:
+      return std::make_unique<SelectiveStructColumnReader>(
+          requestedType,
+          fileType,
+          params,
+          scanSpec,
+          std::move(operands),
+          isRoot);
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+} // namespace facebook::velox::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h b/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h
new file mode 100644
index 000000000000..ca917a5bad0a
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.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/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/dwio/StructColumnReader.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
+
+namespace facebook::velox::wave::nimble {
+
+class SelectiveStructColumnReader : public StructColumnReader {
+ public:
+  SelectiveStructColumnReader(
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      NimbleFormatParams& params,
+      common::ScanSpec& scanSpec,
+      std::vector<std::unique_ptr<AbstractOperand>>&& operands,
+      bool isRoot);
+
+  const std::vector<std::unique_ptr<AbstractOperand>>* getOperands() const {
+    return &operands_;
+  }
+
+ private:
+  std::vector<std::unique_ptr<AbstractOperand>> operands_;
+};
+
+class NimbleFormatReader {
+ public:
+  static std::unique_ptr<ColumnReader> build(
+      const TypePtr& requestedType,
+      const std::shared_ptr<const dwio::common::TypeWithId>& fileType,
+      NimbleFormatParams& params,
+      common::ScanSpec& scanSpec,
+      AbstractOperand* operand,
+      bool isRoot = false);
+};
+
+} // namespace facebook::velox::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/Types.h b/velox/experimental/wave/dwio/nimble/Types.h
new file mode 100644
index 000000000000..971fa22d14c5
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/Types.h
@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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 <string_view>
+#include <variant>
+
+// Single file containing all the types and enums in nimble, as well as some
+// templates for mapping between those types and C++ types.
+//
+// A note on types: For all of our enum classes, we assume the number of
+// types will stay small, so that each one is representable by a single byte.
+// Don't violate this!
+
+namespace facebook::wave::nimble {
+
+using VariantType = std::variant<
+    int8_t,
+    uint8_t,
+    int16_t,
+    uint16_t,
+    int32_t,
+    uint32_t,
+    int64_t,
+    uint64_t,
+    float,
+    double,
+    bool,
+    std::string>;
+
+template <typename T>
+class Variant {
+ public:
+  static void set(VariantType& target, T source) {
+    target = source;
+  }
+
+  static T get(VariantType& source) {
+    return std::get<T>(source);
+  }
+};
+
+template <>
+void Variant<std::string_view>::set(
+    VariantType& target,
+    std::string_view source);
+
+template <>
+std::string_view Variant<std::string_view>::get(VariantType& source);
+
+enum class EncodingType {
+  // Native encoding for numerics, simple packed chars with offsets for strings,
+  // bitpacked for bools. All data types supported.
+  Trivial = 0,
+  // Run length encoded data. The runs lengths are bit packed, and the run
+  // values are encoded like the trivial encoding. All data types supported.
+  RLE = 1,
+  // Data with the uniques encoded in a dictionary and the indices into that
+  // dictionary. All data types except bools supported.
+  Dictionary = 2,
+  // Stores integer types packed into a fixed number of bits (namely, the
+  // smallest required to represent the largest element). Currently only
+  // works with non-negative values, we may add ZigZag encoding later.
+  FixedBitWidth = 3,
+  // Stores nullable data using a 'sentinel' value to represent nulls in a
+  // single non-nullable encoding.
+  Sentinel = 4,
+  // Stores nullable data by wrapping one subencoding representing the non-nulls
+  // with another subencoding marking which rows are null.
+  Nullable = 5,
+  // Stores indices to set (or unset) bits. Useful for storing sparse data, such
+  // as when only a few rows in a encoding are non-null.
+  SparseBool = 6,
+  // Stores integer types via varint encoding. Currently only
+  // works with non-negative values, we may add ZigZag encoding later.
+  Varint = 7,
+  // Stores integer types with a delta encoding. Currently only supports
+  // positive deltas.
+  Delta = 8,
+  // Stores constant (i.e. only 1 unique value) data.
+  Constant = 9,
+  // Stores 'mainly constant' data, i.e. treats one particular value as special,
+  // using a bool child vector to store whether each row is that special value,
+  // and stores the non-special values as a separate encoding.
+  MainlyConstant = 10,
+};
+std::string toString(EncodingType encodingType);
+std::ostream& operator<<(std::ostream& out, EncodingType encodingType);
+
+enum class DataType : uint8_t {
+  Undefined = 0,
+  Int8 = 1,
+  Uint8 = 2,
+  Int16 = 3,
+  Uint16 = 4,
+  Int32 = 5,
+  Uint32 = 6,
+  Int64 = 7,
+  Uint64 = 8,
+  Float = 9,
+  Double = 10,
+  Bool = 11,
+  String = 12,
+};
+
+std::string toString(DataType dataType);
+std::ostream& operator<<(std::ostream& out, DataType dataType);
+
+// General string compression. Make sure values here match those in the footer
+// specification
+enum class CompressionType : uint8_t {
+  Uncompressed = 0,
+  // Zstd doesn't require us to externally store level or any other info.
+  Zstd = 1,
+  MetaInternal = 2,
+};
+
+std::string toString(CompressionType compressionType);
+std::ostream& operator<<(std::ostream& out, CompressionType compressionType);
+
+enum class ChecksumType : uint8_t { XXH3_64 = 0 };
+
+std::string toString(ChecksumType type);
+
+// A CompresionType and any type-specific configuration params.
+struct CompressionParams {
+  CompressionType type;
+
+  // For zstd.
+  int zstdLevel = 1;
+};
+
+// Parameters controlling the search for the optimal encoding on a data set.
+struct OptimalSearchParams {
+  // Whether recursive structures are allowed. E.g. a encoding may use another
+  // encoding as a subencoding, and may use the encoding factory to find the
+  // best subencoding. We must terminate the recursion at some depth. With the
+  // default of 1 allowed recursion the top level encoding may use recursive
+  // encodings, but its subencodings may not.
+  int allowedRecursions = 1;
+
+  // Whether to log debug info during the search (such as estimated sizes of
+  // each encoding considered, etc.);
+  bool logSearch = false;
+
+  // Helps align log messages when log_search=true to help distinguish
+  // subencoding log messages from higher-level ones.
+  int logDepth = 0;
+
+  // Entropy encodings, such as HuffmanEncoding, can be much more compact than
+  // others, but are quite a bit slower. However, compared to applying a general
+  // string compression on top of another encoding they are relatively fast.
+  // In general the entropy encodings will also be smaller than GSC on top of
+  // a non-entropy encoding.
+  bool enableEntropyEncodings = true;
+
+  // For some dimension encodings that will frequently be grouped by, we may
+  // want to force dictionary enabled encodings so grouping by that can will be
+  // fast.
+  bool requireDictionaryEnabled = false;
+};
+
+template <typename T>
+struct TypeTraits {};
+
+template <>
+struct TypeTraits<int8_t> {
+  using physicalType = uint8_t;
+  using sumType = int64_t;
+  static constexpr DataType dataType = DataType::Int8;
+};
+
+template <>
+struct TypeTraits<uint8_t> {
+  using physicalType = uint8_t;
+  using sumType = uint64_t;
+  static constexpr DataType dataType = DataType::Uint8;
+};
+
+template <>
+struct TypeTraits<int16_t> {
+  using physicalType = uint16_t;
+  using sumType = int64_t;
+  static constexpr DataType dataType = DataType::Int16;
+};
+
+template <>
+struct TypeTraits<uint16_t> {
+  using physicalType = uint16_t;
+  using sumType = uint64_t;
+  static constexpr DataType dataType = DataType::Uint16;
+};
+
+template <>
+struct TypeTraits<int32_t> {
+  using physicalType = uint32_t;
+  using sumType = int64_t;
+  static constexpr DataType dataType = DataType::Int32;
+};
+
+template <>
+struct TypeTraits<uint32_t> {
+  using physicalType = uint32_t;
+  using sumType = uint64_t;
+  static constexpr DataType dataType = DataType::Uint32;
+};
+
+template <>
+struct TypeTraits<int64_t> {
+  using physicalType = uint64_t;
+  using sumType = int64_t;
+  static constexpr DataType dataType = DataType::Int64;
+};
+
+template <>
+struct TypeTraits<uint64_t> {
+  using physicalType = uint64_t;
+  using sumType = uint64_t;
+  static constexpr DataType dataType = DataType::Uint64;
+};
+
+template <>
+struct TypeTraits<float> {
+  using physicalType = uint32_t;
+  using sumType = double;
+  static constexpr DataType dataType = DataType::Float;
+};
+
+template <>
+struct TypeTraits<double> {
+  using physicalType = uint64_t;
+  using sumType = double;
+  static constexpr DataType dataType = DataType::Double;
+};
+
+template <>
+struct TypeTraits<bool> {
+  using physicalType = bool;
+  static constexpr DataType dataType = DataType::Bool;
+};
+
+template <>
+struct TypeTraits<std::string> {
+  using physicalType = std::string;
+  static constexpr DataType dataType = DataType::String;
+};
+
+template <>
+struct TypeTraits<std::string_view> {
+  using physicalType = std::string_view;
+  static constexpr DataType dataType = DataType::String;
+};
+
+template <typename T>
+constexpr bool isFourByteIntegralType() {
+  return std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t>;
+}
+
+template <typename T>
+constexpr bool isSignedIntegralType() {
+  return std::is_same_v<T, int32_t> || std::is_same_v<T, int64_t> ||
+      std::is_same_v<T, int8_t> || std::is_same_v<T, int16_t>;
+}
+
+template <typename T>
+constexpr bool isUnsignedIntegralType() {
+  return std::is_same_v<T, uint32_t> || std::is_same_v<T, uint64_t> ||
+      std::is_same_v<T, uint8_t> || std::is_same_v<T, uint16_t>;
+}
+
+template <typename T>
+constexpr bool isIntegralType() {
+  return isSignedIntegralType<T>() || isUnsignedIntegralType<T>();
+}
+
+template <typename T>
+constexpr bool isFloatingPointType() {
+  return std::is_same_v<T, float> || std::is_same_v<T, double>;
+}
+
+template <typename T>
+constexpr bool isNumericType() {
+  return isIntegralType<T>() || isFloatingPointType<T>();
+}
+
+template <typename T>
+constexpr bool isStringType() {
+  return std::is_same_v<T, std::string_view> || std::is_same_v<T, std::string>;
+}
+
+template <typename T>
+constexpr bool isBoolType() {
+  return std::is_same_v<T, bool>;
+}
+
+} // namespace facebook::wave::nimble
diff --git a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.cpp b/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.cpp
new file mode 100644
index 000000000000..37ed8f75cc68
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.cpp
@@ -0,0 +1,402 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/nimble/fuzzer/NimbleReaderFuzzer.h"
+#include <cstddef>
+#include "dwio/nimble/encodings/EncodingSelectionPolicy.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h"
+#include "velox/type/Filter.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.");
+
+namespace facebook::velox::wave {
+namespace {
+using namespace facebook::nimble;
+
+struct ChunkSpec {
+  TypePtr type;
+  int32_t numValues;
+  double nullRatio;
+};
+
+struct StreamSpec {
+  std::string name;
+  std::vector<ChunkSpec> chunks;
+  double nullRatio;
+
+  vector_size_t numValues() const {
+    vector_size_t numValues = 0;
+    for (const auto& chunk : chunks) {
+      numValues += chunk.numValues;
+    }
+    return numValues;
+  }
+
+  TypePtr type() const {
+    return chunks.empty() ? nullptr : chunks[0].type;
+  }
+};
+
+struct StripeSpec {
+  std::vector<StreamSpec> streams;
+  std::vector<FilterSpec> filters;
+
+  void check() const {
+    for (const auto& stream : streams) {
+      VELOX_CHECK_EQ(stream.numValues(), numValues());
+    }
+  }
+
+  vector_size_t numValues() const {
+    return streams.empty() ? 0 : streams[0].numValues();
+  }
+};
+
+class NimbleReaderFuzzer {
+ public:
+  NimbleReaderFuzzer(
+      size_t initialSeed,
+      NimbleReaderFuzzerOptions opts,
+      std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner);
+
+  void go();
+
+  void setOptions(const NimbleReaderFuzzerOptions& options) {
+    opts_ = options;
+  }
+
+  const NimbleReaderFuzzerOptions& getOptions() {
+    return opts_;
+  }
+
+  NimbleReaderFuzzerOptions& getMutableOptions() {
+    return opts_;
+  }
+
+ private:
+  static VectorFuzzer::Options getFuzzerOptions() {
+    VectorFuzzer::Options opts;
+    opts.allowSlice = false;
+    opts.allowConstantVector = false;
+    opts.allowDictionaryVector = false;
+    return opts;
+  }
+
+  void seed(size_t seed) {
+    currentSeed_ = seed;
+    vectorFuzzer_.reSeed(seed);
+    rng_.seed(currentSeed_);
+  }
+
+  void reSeed() {
+    seed(rng_());
+  }
+
+  void run();
+
+  VectorPtr makeChunk(const ChunkSpec& spec);
+  std::vector<VectorPtr> makeStream(const StreamSpec& spec);
+  std::vector<std::vector<VectorPtr>> makeStripe(const StripeSpec& spec);
+  StripeSpec generateStripeSpec();
+  template <typename T>
+  std::shared_ptr<common::Filter> generateOneFilter(VectorPtr input);
+  std::vector<FilterSpec> generateFilters(RowVectorPtr input);
+  std::vector<std::pair<EncodingType, float>> generateReadFactors();
+
+  int32_t randInt(int32_t min, int32_t max) {
+    return boost::random::uniform_int_distribution<int32_t>(min, max)(rng_);
+  }
+
+  double randDouble01() {
+    return boost::random::uniform_01<double>()(rng_);
+  }
+
+  FuzzerGenerator rng_;
+  size_t currentSeed_{0};
+
+  std::shared_ptr<memory::MemoryPool> rootPool_{
+      memory::memoryManager()->addRootPool(
+          "nimbleReaderFuzzer",
+          memory::kMaxMemory,
+          memory::MemoryReclaimer::create())};
+  std::shared_ptr<memory::MemoryPool> pool_{rootPool_->addLeafChild(
+      "nimbleReaderFuzzerLeaf",
+      true,
+      memory::MemoryReclaimer::create())};
+
+  VectorFuzzer vectorFuzzer_;
+  NimbleReaderVerifier verifier_;
+
+  struct Stats {
+    // The total number of iterations tested.
+    size_t numIterations{0};
+
+    size_t numStreams{0};
+    size_t numNullables{0};
+    size_t numChunks{0};
+    size_t numFilters{0};
+    size_t numFiltersKeepValues{0};
+    size_t numFiltersWithNullsAllowed{0};
+    double selectivity{0.0};
+
+    std::string toString() const {
+      return fmt::format(
+          "\nTotal iterations tested: {}\n"
+          "Avg. number of streams: {}\n"
+          "Avg. number of nullables: {}\n"
+          "Avg. number of chunks: {}\n"
+          "Avg. number of filters: {}\n"
+          "Avg. number of filters with keep values: {}\n"
+          "Avg. number of filters with nulls allowed: {}\n"
+          "Avg. selectivity: {}\n",
+          numIterations,
+          numStreams / (double)numIterations,
+          numNullables / (double)numIterations,
+          numChunks / (double)numIterations,
+          numFilters / (double)numIterations,
+          numFiltersKeepValues / (double)numIterations,
+          numFiltersWithNullsAllowed / (double)numIterations,
+          selectivity / numIterations);
+    }
+
+    void add(
+        const StripeSpec& stripe,
+        const std::vector<FilterSpec>& filters,
+        RowVectorPtr output) {
+      numStreams += stripe.streams.size();
+      std::for_each(
+          stripe.streams.begin(),
+          stripe.streams.end(),
+          [&](const auto& stream) {
+            numNullables += stream.nullRatio > 0 ? 1 : 0;
+            numChunks += stream.chunks.size();
+          });
+
+      numFilters += filters.size();
+      std::for_each(filters.begin(), filters.end(), [&](const auto& filter) {
+        numFiltersKeepValues += filter.keepValues ? 1 : 0;
+        numFiltersWithNullsAllowed += filter.filter->nullAllowed() ? 1 : 0;
+      });
+
+      if (output) {
+        selectivity += output->size() / (double)stripe.numValues();
+      }
+    }
+  };
+
+  Stats stats_;
+  NimbleReaderFuzzerOptions opts_;
+};
+
+bool isDone(
+    size_t i,
+    std::chrono::time_point<std::chrono::system_clock> 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;
+}
+
+NimbleReaderFuzzer::NimbleReaderFuzzer(
+    size_t initialSeed,
+    NimbleReaderFuzzerOptions opts,
+    std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner)
+    : vectorFuzzer_{getFuzzerOptions(), pool_.get()},
+      verifier_{std::move(referenceQueryRunner)},
+      opts_(opts) {
+  seed(initialSeed);
+}
+
+void NimbleReaderFuzzer::go() {
+  VELOX_USER_CHECK(
+      FLAGS_steps > 0 || FLAGS_duration_sec > 0,
+      "Either --steps or --duration_sec needs to be greater than zero.");
+
+  const auto startTime = std::chrono::system_clock::now();
+
+  while (!isDone(stats_.numIterations, startTime)) {
+    LOG(INFO) << "==============================> Started iteration "
+              << stats_.numIterations << " (seed: " << currentSeed_ << ")";
+
+    run();
+
+    LOG(INFO) << "==============================> Done with iteration "
+              << stats_.numIterations;
+
+    reSeed();
+    ++stats_.numIterations;
+  }
+  LOG(INFO) << stats_.toString();
+}
+
+VectorPtr NimbleReaderFuzzer::makeChunk(const ChunkSpec& spec) {
+  auto& option = vectorFuzzer_.getMutableOptions();
+  option.vectorSize = spec.numValues;
+  option.nullRatio = spec.nullRatio;
+  auto vector = vectorFuzzer_.fuzzFlat(spec.type);
+  auto tempType = vector->type();
+  return std::make_shared<RowVector>(
+      vector->pool(),
+      ROW({""}, {tempType}),
+      BufferPtr{nullptr},
+      vector->size(),
+      std::vector<VectorPtr>{vector});
+}
+
+std::vector<VectorPtr> NimbleReaderFuzzer::makeStream(const StreamSpec& spec) {
+  std::vector<VectorPtr> chunkVectors;
+  for (const auto& chunkSpec : spec.chunks) {
+    chunkVectors.push_back(makeChunk(chunkSpec));
+  }
+  return chunkVectors;
+}
+
+std::vector<std::vector<VectorPtr>> NimbleReaderFuzzer::makeStripe(
+    const StripeSpec& spec) {
+  std::vector<std::vector<VectorPtr>> chunkVectorGroups;
+  for (const auto& streamSpec : spec.streams) {
+    chunkVectorGroups.push_back(makeStream(streamSpec));
+  }
+  return chunkVectorGroups;
+}
+
+template <typename T>
+std::shared_ptr<common::Filter> NimbleReaderFuzzer::generateOneFilter(
+    VectorPtr input) {
+  vector_size_t endPointIdx1 = randInt(0, input->size() - 1);
+  vector_size_t endPointIdx2 = randInt(0, input->size() - 1);
+  bool nullAllowed = vectorFuzzer_.coinToss(opts_.nullAllowedProbability);
+  auto endPoint1 = input->as<SimpleVector<T>>()->valueAt(endPointIdx1);
+  auto endPoint2 = input->as<SimpleVector<T>>()->valueAt(endPointIdx2);
+  auto lower = std::min(endPoint1, endPoint2);
+  auto upper = std::max(endPoint1, endPoint2);
+  return std::make_shared<common::BigintRange>(lower, upper, nullAllowed);
+}
+
+std::vector<FilterSpec> NimbleReaderFuzzer::generateFilters(
+    RowVectorPtr input) {
+  std::vector<FilterSpec> filters;
+  bool hasFilter = vectorFuzzer_.coinToss(opts_.hasFilterProbability);
+  if (!hasFilter) {
+    return filters;
+  }
+  for (int i = 0; i < input->childrenSize(); i++) {
+    if (!vectorFuzzer_.coinToss(opts_.isFilterProbability)) {
+      continue;
+    }
+    auto kind = input->childAt(i)->typeKind();
+    if (kind != TypeKind::BIGINT) {
+      continue;
+    }
+    filters.emplace_back();
+    auto& filterSpec = filters.back();
+    filterSpec.name = input->type()->asRow().nameOf(i);
+    filterSpec.keepValues =
+        vectorFuzzer_.coinToss(opts_.filterKeepValuesProbability);
+    switch (kind) {
+      case TypeKind::BIGINT:
+        filterSpec.filter = generateOneFilter<int64_t>(input->childAt(i));
+        break;
+      case TypeKind::INTEGER:
+        filterSpec.filter = generateOneFilter<int32_t>(input->childAt(i));
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+  }
+
+  return filters;
+}
+
+StripeSpec NimbleReaderFuzzer::generateStripeSpec() {
+  StripeSpec spec;
+  const auto numStreams = randInt(opts_.minNumStreams, opts_.maxNumStreams);
+  const auto numValues = randInt(opts_.minNumValues, opts_.maxNumValues);
+  spec.streams.resize(numStreams);
+  for (size_t i = 0; i < numStreams; i++) {
+    auto& stream = spec.streams[i];
+    stream.name = "c" + std::to_string(i);
+    auto type = vectorFuzzer_.randType(opts_.types, 1);
+    auto numChunks = randInt(opts_.minNumChunks, opts_.maxNumChunks);
+    stream.chunks.resize(numChunks);
+    bool hasNulls = vectorFuzzer_.coinToss(opts_.hasNullProbability);
+    stream.nullRatio = hasNulls ? randDouble01() : 0;
+
+    size_t numValuesLeft = numValues;
+    for (size_t nthChunk = 0; nthChunk < numChunks; nthChunk++) {
+      auto& chunk = stream.chunks[nthChunk];
+      chunk.type = type;
+      chunk.nullRatio = stream.nullRatio;
+
+      if (nthChunk == numChunks - 1) {
+        chunk.numValues = numValuesLeft;
+      } else {
+        chunk.numValues = randInt(
+            opts_.minChunkSize,
+            numValuesLeft - (numChunks - nthChunk - 1) * opts_.minChunkSize);
+      }
+      numValuesLeft -= chunk.numValues;
+    }
+  }
+
+  spec.check();
+  return spec;
+}
+
+std::vector<std::pair<EncodingType, float>>
+NimbleReaderFuzzer::generateReadFactors() {
+  return {
+      {EncodingType::Nullable, 1.0}, // This enables both nullable and trivial
+  };
+}
+
+void NimbleReaderFuzzer::run() {
+  auto stripeSpec = generateStripeSpec();
+  auto stripe = makeStripe(stripeSpec);
+
+  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
+      pool_.get(),
+      stripe,
+      generateReadFactors(),
+      CompressionOptions{.compressionAcceptRatio = 0.0});
+
+  auto input = createInputFromChunkVectorGroups(stripe);
+  auto filterSpecs = generateFilters(input);
+
+  TestNimbleReader reader(pool_.get(), input, streamLoaders, filterSpecs);
+  auto testResult = reader.read();
+
+  stats_.add(stripeSpec, filterSpecs, testResult);
+  verifier_.verify(input, filterSpecs, testResult);
+}
+} // namespace
+
+void nimbleReaderFuzzer(
+    size_t seed,
+    NimbleReaderFuzzerOptions opts,
+    std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner) {
+  NimbleReaderFuzzer(seed, opts, std::move(referenceQueryRunner)).go();
+}
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h b/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h
new file mode 100644
index 000000000000..26c3ede8213a
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.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 <cstddef>
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+
+namespace facebook::velox::wave {
+struct NimbleReaderFuzzerOptions {
+  size_t minNumStreams{1};
+  size_t maxNumStreams{10};
+  size_t minNumChunks{1};
+  size_t maxNumChunks{10};
+  size_t minChunkSize{1};
+  size_t minNumValues{10};
+  size_t maxNumValues{10000};
+  double hasNullProbability{0.5};
+  double hasFilterProbability{0.75};
+  double isFilterProbability{0.5};
+  double nullAllowedProbability{0};
+  double filterKeepValuesProbability{1.0};
+  std::vector<TypePtr> types{INTEGER(), BIGINT(), REAL(), DOUBLE()};
+};
+void nimbleReaderFuzzer(
+    size_t seed,
+    NimbleReaderFuzzerOptions options,
+    std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner);
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzerRunner.cpp b/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzerRunner.cpp
new file mode 100644
index 000000000000..0991804e832b
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzerRunner.cpp
@@ -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 <folly/init/Init.h>
+#include <gflags/gflags.h>
+#include "velox/exec/fuzzer/FuzzerUtil.h"
+#include "velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h"
+
+DEFINE_int64(
+    seed,
+    0,
+    "Initial seed for random number generator used to reproduce previous "
+    "results (0 means start with random seed).");
+
+DECLARE_int32(steps);
+DECLARE_int32(duration_sec);
+
+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;
+
+int main(int argc, char** argv) {
+  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;
+  facebook::velox::wave::NimbleReaderFuzzerOptions options;
+  facebook::velox::wave::nimbleReaderFuzzer(initialSeed, options, nullptr);
+}
diff --git a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderFuzzerTest.cpp b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderFuzzerTest.cpp
new file mode 100644
index 000000000000..50a9acb876f7
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderFuzzerTest.cpp
@@ -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.
+ */
+
+#include <cuda_runtime.h> // @manual
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/experimental/wave/dwio/nimble/fuzzer/NimbleReaderFuzzer.h"
+
+DECLARE_int32(steps);
+DECLARE_int32(duration_sec);
+
+namespace facebook::velox::wave {
+struct NimbleReaderFuzzerParam {
+  int64_t seed{0};
+  NimbleReaderFuzzerOptions options{};
+};
+std::vector<NimbleReaderFuzzerParam> NimbleReaderFuzzerParams() {
+  return {
+      {.seed = 42, .options = {}},
+      {.seed = 56, .options = {}},
+      {.seed = 189, .options = {}},
+      {.seed = 331, .options = {}},
+  };
+}
+class NimbleReaderFuzzerTest
+    : public testing::Test,
+      public testing::WithParamInterface<NimbleReaderFuzzerParam> {
+ protected:
+  static void SetUpTestCase() {
+    memory::initializeMemoryManager(velox::memory::MemoryManager::Options{});
+  }
+  void SetUp() override {
+    if (int device; cudaGetDevice(&device) != cudaSuccess) {
+      GTEST_SKIP() << "No CUDA detected, skipping all tests";
+    }
+    auto param = GetParam();
+    seed_ = param.seed;
+    opts_ = param.options;
+  }
+
+  int64_t seed_{0};
+  NimbleReaderFuzzerOptions opts_{};
+};
+
+TEST_P(NimbleReaderFuzzerTest, basic) {
+  facebook::velox::wave::nimbleReaderFuzzer(seed_, opts_, nullptr);
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    NimbleReaderFuzzerTests,
+    NimbleReaderFuzzerTest,
+    testing::ValuesIn(NimbleReaderFuzzerParams()));
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTest.cpp b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTest.cpp
new file mode 100644
index 000000000000..d86dcf90d6c5
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTest.cpp
@@ -0,0 +1,921 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <fmt/format.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+
+#include "dwio/nimble/encodings/EncodingLayout.h"
+#include "dwio/nimble/encodings/EncodingLayoutCapture.h"
+#include "dwio/nimble/encodings/EncodingSelectionPolicy.h"
+#include "dwio/nimble/tablet/TabletReader.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
+#include "velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h"
+#include "velox/type/Filter.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::wave {
+using namespace facebook::nimble;
+
+namespace {
+using namespace facebook::velox;
+
+class NimbleReaderTest : public ::testing::Test,
+                         public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::initializeMemoryManager(velox::memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    if (int device; cudaGetDevice(&device) != cudaSuccess) {
+      GTEST_SKIP() << "No CUDA detected, skipping all tests";
+    }
+  }
+
+  memory::MemoryPool* leafPool() {
+    return pool_.get();
+  }
+
+  // Helper function to decode a vector with specified read factors and
+  // compression options
+  void test(
+      const std::vector<std::vector<VectorPtr>>& chunkVectorGroups,
+      const std::vector<std::pair<EncodingType, float>>& readFactors,
+      const CompressionOptions& compressionOptions =
+          {.compressionAcceptRatio = 0.0},
+      const std::vector<FilterSpec>& filters = {}) {
+    auto streamLoaders = writeToNimbleAndGetStreamLoaders(
+        leafPool(), chunkVectorGroups, readFactors, compressionOptions);
+
+    auto input = createInputFromChunkVectorGroups(chunkVectorGroups);
+
+    TestNimbleReader reader(leafPool(), input, streamLoaders, filters);
+    auto testResult = reader.read();
+
+    verifier_.verify(input, filters, testResult);
+  }
+
+ private:
+  NimbleReaderVerifier verifier_{};
+};
+
+#define ENCODING_TYPE_EXPECT_EQ(type1, type2) \
+  EXPECT_EQ(static_cast<int>(type1), static_cast<int>(type2));
+
+#define ENCODING_TYPE_ASSERT_EQ(type1, type2) \
+  ASSERT_EQ(static_cast<int>(type1), static_cast<int>(type2));
+
+void compareEncodingTree(
+    NimbleEncoding& encoding,
+    EncodingLayout const& layout) {
+  SCOPED_TRACE(
+      fmt::format(
+          "Encoding: {}, #children: {}",
+          toString(layout.encodingType()),
+          encoding.childrenCount()));
+  EXPECT_EQ(encoding.childrenCount(), layout.childrenCount());
+  ENCODING_TYPE_EXPECT_EQ(encoding.encodingType(), layout.encodingType());
+  for (int i = 0; i < encoding.childrenCount(); i++) {
+    compareEncodingTree(*encoding.childAt(i), layout.child(i).value());
+  }
+}
+} // namespace
+
+TEST_F(NimbleReaderTest, rootTrivialEncoding) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeRowVector({
+      makeFlatVector<int16_t>(10, folly::identity),
+  });
+  auto pool = leafPool();
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
+      pool, {{c0}}, readFactors, compressionOptions);
+
+  ASSERT_EQ(streamLoaders.size(), 1);
+  ASSERT_NE(streamLoaders[0], nullptr);
+  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
+
+  ASSERT_TRUE(stream.hasNext());
+
+  auto chunk = stream.nextChunk();
+  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
+  auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
+
+  ASSERT_EQ(layout.encodingType(), EncodingType::Trivial);
+
+  EXPECT_EQ(encoding->numValues(), c0->childAt(0)->size());
+
+  compareEncodingTree(*encoding, layout);
+}
+
+TEST_F(NimbleReaderTest, rootNullableEncoding) {
+  using namespace facebook::nimble;
+
+  const int nullFreq = 10;
+  auto c0 = makeRowVector({
+      makeFlatVector<int16_t>(100, folly::identity, nullEvery(nullFreq)),
+  });
+  auto pool = leafPool();
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
+      pool, {{c0}}, readFactors, compressionOptions);
+
+  ASSERT_EQ(streamLoaders.size(), 1);
+  ASSERT_NE(streamLoaders[0], nullptr);
+  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
+
+  ASSERT_TRUE(stream.hasNext());
+
+  auto chunk = stream.nextChunk();
+  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
+
+  ENCODING_TYPE_ASSERT_EQ(encoding->encodingType(), EncodingType::Nullable);
+
+  EXPECT_EQ(encoding->numValues(), c0->childAt(0)->size());
+
+  EXPECT_EQ(encoding->childrenCount(), 2);
+  EXPECT_EQ(
+      encoding->childAt(0)->numValues(),
+      c0->size() - c0->size() / nullFreq); // non-nulls
+  EXPECT_EQ(encoding->childAt(1)->numValues(), c0->size()); // nulls
+}
+
+TEST_F(NimbleReaderTest, rootDictionaryEncoding) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeRowVector({
+      makeFlatVector<int16_t>({3, 3, 4, 4, 5, 5, 6, 6, 7, 7}),
+  });
+  auto pool = leafPool();
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Dictionary, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
+      pool, {{c0}}, readFactors, compressionOptions);
+
+  ASSERT_EQ(streamLoaders.size(), 1);
+  ASSERT_NE(streamLoaders[0], nullptr);
+  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
+
+  ASSERT_TRUE(stream.hasNext());
+
+  auto chunk = stream.nextChunk();
+  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
+  auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
+
+  ASSERT_EQ(layout.encodingType(), EncodingType::Dictionary);
+
+  EXPECT_EQ(encoding->numValues(), c0->childAt(0)->size());
+
+  compareEncodingTree(*encoding, layout);
+  EXPECT_EQ(encoding->childrenCount(), layout.childrenCount());
+  EXPECT_EQ(encoding->childAt(0)->numValues(), 5); // unique values
+  EXPECT_EQ(encoding->childAt(1)->numValues(), encoding->numValues());
+}
+
+TEST_F(NimbleReaderTest, rootRLEEncoding) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 1, 1, 2, 2, 2, 3, 3, 3}),
+  });
+  auto pool = leafPool();
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::RLE, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
+      pool, {{c0}}, readFactors, compressionOptions);
+
+  ASSERT_EQ(streamLoaders.size(), 1);
+  ASSERT_NE(streamLoaders[0], nullptr);
+  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
+
+  ASSERT_TRUE(stream.hasNext());
+
+  auto chunk = stream.nextChunk();
+  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
+  auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
+
+  ASSERT_EQ(layout.encodingType(), EncodingType::RLE);
+
+  EXPECT_EQ(encoding->numValues(), c0->childAt(0)->size());
+
+  compareEncodingTree(*encoding, layout);
+  EXPECT_EQ(encoding->childAt(0)->numValues(), 3);
+  EXPECT_EQ(encoding->childAt(1)->numValues(), 3);
+}
+
+TEST_F(NimbleReaderTest, decodePipeline) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeRowVector({
+      makeFlatVector<int16_t>({1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 3, 3, 3, 3}),
+  });
+  auto pool = leafPool();
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::RLE, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
+      pool, {{c0}}, readFactors, compressionOptions);
+
+  ASSERT_EQ(streamLoaders.size(), 1);
+  ASSERT_NE(streamLoaders[0], nullptr);
+  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
+
+  ASSERT_TRUE(stream.hasNext());
+
+  auto chunk = stream.nextChunk();
+  auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
+  auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
+
+  ASSERT_EQ(layout.encodingType(), EncodingType::RLE);
+  ASSERT_EQ(encoding->childrenCount(), 2);
+
+  NimbleChunkDecodePipeline pipeline(std::move(encoding));
+
+  // rle(trivial(lengths), trivial(values))
+  ASSERT_EQ(pipeline.size(), 3);
+  auto encodingNode = pipeline.next();
+  ENCODING_TYPE_EXPECT_EQ(encodingNode->encodingType(), EncodingType::Trivial);
+  encodingNode = pipeline.next();
+  ENCODING_TYPE_EXPECT_EQ(encodingNode->encodingType(), EncodingType::Trivial);
+  // This encoding depends on the previous and therefore is not ready yet
+  encodingNode = pipeline.next();
+  EXPECT_EQ(encodingNode, nullptr);
+  ENCODING_TYPE_EXPECT_EQ(pipeline[2].encodingType(), EncodingType::RLE);
+  EXPECT_TRUE(pipeline[0].isDecoded());
+  EXPECT_TRUE(pipeline[1].isDecoded());
+  EXPECT_EQ(pipeline.finished(), false);
+}
+
+TEST_F(NimbleReaderTest, decodeTrivialSingleLevelInteger) {
+  using namespace facebook::nimble;
+
+  auto c0 =
+      makeFlatVector<int32_t>({1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 3, 3, 3, 3});
+  auto input = makeRowVector({c0});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions);
+}
+
+TEST_F(NimbleReaderTest, decodeTrivialSingleLevelFloat) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeFlatVector<double>(1893, [](auto row) { return row * 1.1; });
+  auto input = makeRowVector({c0});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions);
+}
+
+TEST_F(NimbleReaderTest, DISABLED_TrivialWithCompressionShouldFail) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeFlatVector<double>(17, [](auto row) { return row * 1.1; });
+  auto input = makeRowVector({c0});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 1.0};
+  try {
+    test({{input}}, readFactors, compressionOptions);
+    FAIL() << "Expected exception for decoding trivial with compression";
+  } catch (const VeloxRuntimeError& e) {
+    EXPECT_NE(
+        e.message().find("Trivial encoding does not support compression yet"),
+        std::string::npos);
+  } catch (...) {
+    FAIL() << "unexpected exception thrown";
+  }
+}
+
+TEST_F(NimbleReaderTest, loadMultiChunks) {
+  using namespace facebook::nimble;
+
+  auto pool = leafPool();
+
+  auto chunk0 = makeRowVector({
+      makeFlatVector<double>(17, folly::identity),
+  });
+  auto chunk1 = makeRowVector({
+      makeFlatVector<double>(26, folly::identity),
+  });
+  auto chunk2 = makeRowVector({
+      makeFlatVector<double>(34, folly::identity),
+  });
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  auto streamLoaders = writeToNimbleAndGetStreamLoaders(
+      pool, {{chunk0, chunk1, chunk2}}, readFactors, compressionOptions);
+
+  ASSERT_EQ(streamLoaders.size(), 1);
+  ASSERT_NE(streamLoaders[0], nullptr);
+  NimbleChunkedStream stream(*pool, streamLoaders[0]->getStream());
+
+  std::vector<RowVectorPtr> chunks{chunk0, chunk1, chunk2};
+  for (int i = 0; i < 3; i++) {
+    SCOPED_TRACE(fmt::format("i: {}", i));
+    ASSERT_TRUE(stream.hasNext());
+    auto chunk = stream.nextChunk();
+    auto encoding = NimbleChunk::parseEncodingFromChunk(chunk.chunkData());
+    auto layout = EncodingLayoutCapture::capture(encoding->encodingData());
+
+    ASSERT_EQ(layout.encodingType(), EncodingType::Trivial);
+    EXPECT_EQ(encoding->numValues(), chunks[i]->childAt(0)->size());
+    compareEncodingTree(*encoding, layout);
+  }
+  ASSERT_FALSE(stream.hasNext());
+}
+
+TEST_F(NimbleReaderTest, decodeTrivialMultiChunksFloat) {
+  using namespace facebook::nimble;
+
+  auto chunk1 = makeRowVector(
+      {makeFlatVector<double>(1893, [](auto row) { return row + 1.1; })});
+  auto chunk2 = makeRowVector(
+      {makeFlatVector<double>(267, [](auto row) { return row + 2.2; })});
+  auto chunk3 = makeRowVector(
+      {makeFlatVector<double>(449, [](auto row) { return row + 3.3; })});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{chunk1, chunk2, chunk3}}, readFactors, compressionOptions);
+}
+
+TEST_F(NimbleReaderTest, decodeTrivialMultiChunksMultiStreams) {
+  using namespace facebook::nimble;
+
+  auto chunk1 = makeRowVector(
+      {makeFlatVector<double>(513, [](auto row) { return row + 1.1; }),
+       makeFlatVector<int32_t>(513, folly::identity),
+       makeFlatVector<int64_t>(513, folly::identity)});
+  auto chunk2 = makeRowVector(
+      {makeFlatVector<double>(267, [](auto row) { return row + 2.2; }),
+       makeFlatVector<int32_t>(267, folly::identity),
+       makeFlatVector<int64_t>(267, folly::identity)});
+  auto chunk3 = makeRowVector(
+      {makeFlatVector<double>(449, [](auto row) { return row + 3.3; }),
+       makeFlatVector<int32_t>(449, folly::identity),
+       makeFlatVector<int64_t>(449, folly::identity)});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{chunk1, chunk2, chunk3}}, readFactors, compressionOptions);
+}
+
+TEST_F(NimbleReaderTest, decodeNullableFloat) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeFlatVector<double>(
+      1025, [](auto row) { return row + 0.1; }, nullEvery(3));
+  auto input = makeRowVector({c0});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions);
+}
+
+TEST_F(NimbleReaderTest, decodeAllNulls) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeFlatVector<double>(
+      1893, [](auto row) { return row * 1.1; }, nullEvery(1));
+  auto c1 = makeFlatVector<double>(
+      1893, [](auto row) { return row * 1.1; }, nullEvery(2));
+  auto input = makeRowVector({c0, c1});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions);
+}
+
+TEST_F(NimbleReaderTest, decodeNullableMultiChunks) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeRowVector({makeFlatVector<double>(
+      1893, [](auto row) { return row + 1.1; }, nullEvery(3))});
+  auto c1 = makeRowVector(
+      {makeFlatVector<double>(2156, [](auto row) { return row + 1.2; })});
+  auto c2 = makeRowVector({makeFlatVector<double>(
+      4790, [](auto row) { return row + 1.3; }, nullEvery(19))});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{c0, c1, c2}}, readFactors, compressionOptions);
+}
+
+TEST_F(NimbleReaderTest, decodeNullableMultiChunksMultiStreams) {
+  using namespace facebook::nimble;
+
+  auto c0 = makeRowVector(
+      {makeFlatVector<double>(1893, [](auto row) { return row + 1.1; }),
+       makeFlatVector<int32_t>(1893, folly::identity, nullEvery(5))});
+  auto c1 = makeRowVector(
+      {makeFlatVector<double>(
+           2156, [](auto row) { return row + 1.2; }, nullEvery(13)),
+       makeFlatVector<int32_t>(2156, folly::identity)});
+  auto c2 = makeRowVector(
+      {makeFlatVector<double>(4790, [](auto row) { return row + 1.3; }),
+       makeFlatVector<int32_t>(4790, folly::identity)});
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{c0, c1, c2}}, readFactors, compressionOptions);
+}
+
+TEST_F(NimbleReaderTest, NullableWithOneFilterKeepValues) {
+  using namespace facebook::nimble;
+
+  auto input = makeRowVector({makeFlatVector<int32_t>(
+      1893, [](auto row) { return row; }, nullEvery(3))});
+
+  auto filter = std::make_shared<common::BigintRange>(1022, 1025, false);
+  std::vector<FilterSpec> filters = {{"c0", filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, NullableWithMoreFiltersKeepValues) {
+  using namespace facebook::nimble;
+
+  auto input = makeRowVector(
+      {makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(3)),
+       makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(3))});
+
+  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
+  auto c1Filter = std::make_shared<common::BigintRange>(1022, 1024, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, NullableWithOneFilterOneNonFilterKeepValues) {
+  using namespace facebook::nimble;
+
+  auto input = makeRowVector(
+      {makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(3)),
+       makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(3))});
+
+  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
+  std::vector<FilterSpec> filters = {{"c0", c0Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, NullableWithMoreFiltersMoreNonFiltersKeepValues) {
+  using namespace facebook::nimble;
+
+  auto input = makeRowVector(
+      {makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(3)),
+       makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(3)),
+       makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(2)),
+       makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(2))});
+
+  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
+  auto c1Filter = std::make_shared<common::BigintRange>(1022, 1024, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, NullableFilterNoResults) {
+  using namespace facebook::nimble;
+
+  auto input = makeRowVector(
+      {makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(3)),
+       makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(3)),
+       makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(2)),
+       makeFlatVector<int32_t>(
+           1893, [](auto row) { return row; }, nullEvery(2))});
+
+  auto c0Filter = std::make_shared<common::BigintRange>(1893, 1944, false);
+  auto c1Filter = std::make_shared<common::BigintRange>(1022, 1024, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, TrivialWithOneFilterKeepValues) {
+  using namespace facebook::nimble;
+
+  auto input = makeRowVector(
+      {makeFlatVector<int32_t>(2000, [](auto row) { return row; })});
+
+  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
+  std::vector<FilterSpec> filters = {{"c0", c0Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, TrivialWithMoreFiltersMoreNonFiltersKeepValues) {
+  using namespace facebook::nimble;
+
+  auto input = makeRowVector(
+      {makeFlatVector<int32_t>(1893, [](auto row) { return row; }),
+       makeFlatVector<int64_t>(1893, [](auto row) { return row; }),
+       makeFlatVector<int32_t>(1893, [](auto row) { return row; }),
+       makeFlatVector<int64_t>(1893, [](auto row) { return row; })});
+
+  auto c0Filter = std::make_shared<common::BigintRange>(1022, 1025, false);
+  auto c1Filter = std::make_shared<common::BigintRange>(1022, 1024, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{input}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, TrivialChunksOneFilterKeepValues) {
+  using namespace facebook::nimble;
+
+  auto chunk0 = makeRowVector(
+      {makeFlatVector<int32_t>(1200, [](auto row) { return row; })});
+  auto chunk1 = makeRowVector({makeFlatVector<int32_t>(
+      1800, [&](auto row) { return row + chunk0->size(); })});
+
+  int64_t lower = 1020, upper = 1202;
+  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
+  std::vector<FilterSpec> filters = {{"c0", c0Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, NullableChunksOneFilterKeepValues) {
+  using namespace facebook::nimble;
+
+  auto chunk0 = makeRowVector({makeFlatVector<int32_t>(
+      1200, [](auto row) { return row; }, nullEvery(2))});
+  auto chunk1 = makeRowVector({makeFlatVector<int32_t>(
+      1800, [&](auto row) { return row + chunk0->size(); }, nullEvery(2))});
+
+  int64_t lower = 1198, upper = 1202;
+  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
+  std::vector<FilterSpec> filters = {{"c0", c0Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, NullableChunksFiltersKeepValues) {
+  using namespace facebook::nimble;
+
+  auto chunk0 = makeRowVector(
+      {makeFlatVector<int32_t>(
+           1200, [](auto row) { return row; }, nullEvery(2)),
+       makeFlatVector<int32_t>(
+           1200, [](auto row) { return row; }, nullEvery(2))});
+  auto chunk1 = makeRowVector(
+      {makeFlatVector<int32_t>(
+           1800, [&](auto row) { return row + chunk0->size(); }, nullEvery(2)),
+       makeFlatVector<int32_t>(
+           1800,
+           [&](auto row) { return row + chunk0->size(); },
+           nullEvery(2))});
+
+  int64_t lower = 1198, upper = 1202;
+  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
+  auto c1filter =
+      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c1", c0Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, NullableChunksFiltersNonFiltersKeepValues) {
+  using namespace facebook::nimble;
+
+  auto vector = [&](int32_t numValues, int32_t offset = 0) {
+    return makeFlatVector<int32_t>(
+        numValues, [&](auto row) { return row + offset; }, nullEvery(2));
+  };
+  auto chunk0 = makeRowVector({
+      vector(1200),
+      vector(1200),
+      vector(1200),
+      vector(1200),
+  });
+  auto chunk1 = makeRowVector({
+      vector(1800, chunk0->size()),
+      vector(1800, chunk0->size()),
+      vector(1800, chunk0->size()),
+      vector(1800, chunk0->size()),
+  });
+
+  int64_t lower = 1198, upper = 1202;
+  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
+  auto c1Filter =
+      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, TrivialChunksFiltersKeepValues) {
+  using namespace facebook::nimble;
+
+  auto chunk0 = makeRowVector(
+      {makeFlatVector<int32_t>(1200, [](auto row) { return row; }),
+       makeFlatVector<int32_t>(1200, [](auto row) { return row; })});
+  auto chunk1 = makeRowVector(
+      {makeFlatVector<int32_t>(
+           1800, [&](auto row) { return row + chunk0->size(); }),
+       makeFlatVector<int32_t>(
+           1800, [&](auto row) { return row + chunk0->size(); })});
+
+  int64_t lower = 1020, upper = 1202;
+  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
+  auto c1filter =
+      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c1", c0Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, TrivialChunksFiltersNonFiltersKeepValues) {
+  using namespace facebook::nimble;
+
+  auto vector = [&](int32_t numValues, int32_t offset = 0) {
+    return makeFlatVector<int32_t>(
+        numValues, [&](auto row) { return row + offset; });
+  };
+  auto chunk0 = makeRowVector({
+      vector(1200),
+      vector(1200),
+      vector(1200),
+      vector(1200),
+  });
+  auto chunk1 = makeRowVector({
+      vector(1800, chunk0->size()),
+      vector(1800, chunk0->size()),
+      vector(1800, chunk0->size()),
+      vector(1800, chunk0->size()),
+  });
+
+  int64_t lower = 1020, upper = 1202;
+  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
+  auto c1Filter =
+      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c1", c1Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test({{chunk0, chunk1}}, readFactors, compressionOptions, filters);
+}
+
+TEST_F(NimbleReaderTest, TrivialUnalignedChunks) {
+  using namespace facebook::nimble;
+
+  auto vector = [&](int32_t numValues, int32_t offset = 0) {
+    return makeFlatVector<int32_t>(
+        numValues, [&](auto row) { return row + offset; });
+  };
+  int32_t offset = 0;
+
+  // Group 1
+  auto chunk0 = makeRowVector({
+      vector(1200),
+      vector(1200),
+  });
+  offset = chunk0->size();
+  auto chunk1 = makeRowVector({
+      vector(1800, offset),
+      vector(1800, offset),
+  });
+
+  // Group 2
+  auto chunk2 = makeRowVector({
+      vector(500),
+      vector(500),
+  });
+  offset = chunk2->size();
+  auto chunk3 = makeRowVector({
+      vector(1200, offset),
+      vector(1200, offset),
+  });
+  offset += chunk3->size();
+  auto chunk4 = makeRowVector({
+      vector(1300, offset),
+      vector(1300, offset),
+  });
+
+  int64_t lower = 1020, upper = 1202;
+  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
+  auto c2Filter =
+      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c2", c2Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Trivial, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test(
+      {{chunk0, chunk1}, {chunk2, chunk3, chunk4}},
+      readFactors,
+      compressionOptions,
+      filters);
+}
+
+TEST_F(NimbleReaderTest, NullablelUnalignedChunks) {
+  using namespace facebook::nimble;
+
+  auto vector = [&](int32_t numValues, int32_t nullFreq, int32_t offset = 0) {
+    return makeFlatVector<int32_t>(
+        numValues, [&](auto row) { return row + offset; }, nullEvery(nullFreq));
+  };
+  int32_t offset = 0;
+
+  // Group 1
+  auto chunk0 = makeRowVector({
+      vector(1200, 3),
+      vector(1200, 3),
+  });
+  offset = chunk0->size();
+  auto chunk1 = makeRowVector({
+      vector(1800, 3, offset),
+      vector(1800, 3, offset),
+  });
+
+  // Group 2
+  auto chunk2 = makeRowVector({
+      vector(600, 3),
+      vector(600, 3),
+  });
+  offset = chunk2->size();
+  auto chunk3 = makeRowVector({
+      vector(1200, 3, offset),
+      vector(1200, 3, offset),
+  });
+  offset += chunk3->size();
+  auto chunk4 = makeRowVector({
+      vector(1200, 3, offset),
+      vector(1200, 3, offset),
+  });
+
+  int64_t lower = 1020, upper = 1202;
+  auto c0Filter = std::make_shared<common::BigintRange>(lower, upper, false);
+  auto c2Filter =
+      std::make_shared<common::BigintRange>(lower - 2, upper + 2, false);
+  std::vector<FilterSpec> filters = {
+      {"c0", c0Filter, true}, {"c2", c2Filter, true}};
+
+  std::vector<std::pair<EncodingType, float>> readFactors = {
+      {EncodingType::Nullable, 1.0},
+  };
+  CompressionOptions compressionOptions = {.compressionAcceptRatio = 0.0};
+
+  test(
+      {{chunk0, chunk1}, {chunk2, chunk3, chunk4}},
+      readFactors,
+      compressionOptions,
+      filters);
+}
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.cpp b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.cpp
new file mode 100644
index 000000000000..3ddfc2b77ead
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.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/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h"
+#include <numeric>
+#include "dwio/nimble/common/tests/NimbleFileWriter.h"
+#include "dwio/nimble/encodings/EncodingSelectionPolicy.h"
+#include "dwio/nimble/tablet/TabletReader.h"
+#include "dwio/nimble/velox/VeloxWriterOptions.h"
+#include "velox/common/file/File.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/dwio/StructColumnReader.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
+#include "velox/experimental/wave/dwio/nimble/SelectiveStructColumnReader.h"
+
+namespace facebook::velox::wave {
+TestNimbleReader::TestNimbleReader(
+    memory::MemoryPool* pool,
+    RowVectorPtr input,
+    std::vector<std::unique_ptr<StreamLoader>>& streamLoaders,
+    const std::vector<FilterSpec>& filters)
+    : pool_(pool), input_(input) {
+  deviceArena_ = std::make_unique<GpuArena>(
+      100000000, getDeviceAllocator(getDevice()), 400000000);
+
+  std::vector<std::unique_ptr<NimbleChunkedStream>> chunkedStreams;
+  for (int i = 0; i < streamLoaders.size(); i++) {
+    auto& streamLoader = streamLoaders[i];
+    if (streamLoader == nullptr) { // this is a null stream
+      continue;
+    }
+    nonNullOutputChildrenIds_.push_back(i);
+    auto chunkedStream =
+        std::make_unique<NimbleChunkedStream>(*pool, streamLoader->getStream());
+    VELOX_CHECK(chunkedStream->hasNext());
+    chunkedStreams.emplace_back(std::move(chunkedStream));
+  }
+
+  if (chunkedStreams.empty()) { // only contain null streams
+    return;
+  }
+
+  // Create non-null type and scan spec that only include non-null streams
+  std::vector<std::string> nonNullNames;
+  std::vector<TypePtr> nonNullTypes;
+  const auto& inputRowType = input->type()->asRow();
+  for (int32_t childId : nonNullOutputChildrenIds_) {
+    nonNullNames.push_back(inputRowType.nameOf(childId));
+    nonNullTypes.push_back(inputRowType.childAt(childId));
+  }
+  auto nonNullRowType = ROW(std::move(nonNullNames), std::move(nonNullTypes));
+
+  // Set up scan spec and format parameters
+  scanSpec_ = std::make_shared<common::ScanSpec>("root");
+  scanSpec_->addAllChildFields(*nonNullRowType);
+
+  // Apply filters to specific children if provided
+  for (const auto& [childName, filter, keepValues] : filters) {
+    auto* childSpec = scanSpec_->childByName(childName);
+    if (childSpec != nullptr) {
+      childSpec->setFilter(filter);
+      childSpec->setProjectOut(keepValues);
+    } else if (!filter->nullAllowed()) {
+      earlyStop_ = true;
+      return;
+    }
+  }
+  auto requestedType = nonNullRowType;
+  auto fileType = dwio::common::TypeWithId::create(requestedType);
+  std::shared_ptr<dwio::common::TypeWithId> fileTypeShared =
+      std::move(fileType);
+
+  stripe_ = std::make_unique<NimbleStripe>(
+      std::move(chunkedStreams), fileTypeShared, input->size());
+
+  formatParams_ = std::make_unique<NimbleFormatParams>(*pool, stats_, *stripe_);
+  reader_ = nimble::NimbleFormatReader::build(
+      requestedType, fileTypeShared, *formatParams_, *scanSpec_, nullptr, true);
+
+  // Set up wave stream and read stream
+  auto arena = std::make_unique<GpuArena>(100000000, getAllocator(getDevice()));
+  InstructionStatus instructionStatus;
+  waveStream_ = std::make_unique<WaveStream>(
+      std::move(arena),
+      deviceArena(),
+      reinterpret_cast<nimble::SelectiveStructColumnReader*>(reader_.get())
+          ->getOperands(),
+      &operandStateMap_,
+      instructionStatus,
+      0);
+
+  readStream_ = std::make_unique<ReadStream>(
+      reinterpret_cast<StructColumnReader*>(reader_.get()),
+      *waveStream_,
+      &ioStats_,
+      fileInfo_);
+}
+
+RowVectorPtr TestNimbleReader::read() {
+  if (earlyStop_) {
+    return RowVector::createEmpty(input_->type(), pool_);
+  }
+  std::vector<int32_t> rowIds;
+  rowIds.resize(input_->size());
+  std::iota(rowIds.begin(), rowIds.end(), 0);
+  RowSet rows(rowIds.data(), rowIds.size());
+  ReadStream::launch(std::move(readStream_), 0, rows);
+
+  std::vector<OperandId> operandIds;
+  operandIds.resize(nonNullOutputChildrenIds_.size());
+  std::iota(operandIds.begin(), operandIds.end(), 1);
+  folly::Range<const int32_t*> operandIdRange(
+      operandIds.data(), operandIds.size());
+  std::vector<VectorPtr> nonNullOutputChildren;
+  nonNullOutputChildren.resize(nonNullOutputChildrenIds_.size());
+  auto numOutputValues = waveStream_->getOutput(
+      0, *pool_, operandIdRange, nonNullOutputChildren.data());
+
+  auto output = std::make_shared<RowVector>(
+      input_->pool(),
+      input_->type(),
+      BufferPtr(nullptr),
+      numOutputValues,
+      std::vector<VectorPtr>(input_->childrenSize()));
+
+  for (int i = 0; i < nonNullOutputChildrenIds_.size(); i++) {
+    output->childAt(nonNullOutputChildrenIds_[i]) =
+        std::move(nonNullOutputChildren[i]);
+  }
+
+  for (int i = 0; i < input_->childrenSize(); i++) {
+    if (output->childAt(i) == nullptr) { // populate the null children
+      output->childAt(i) = BaseVector::createNullConstant(
+          input_->childAt(i)->type(), numOutputValues, pool_);
+    }
+  }
+
+  return output;
+}
+
+void NimbleReaderVerifier::verifyWithQueryRunner(
+    RowVectorPtr input,
+    const std::vector<FilterSpec>& filters,
+    RowVectorPtr actual) {
+  std::string whereClause;
+  for (int32_t i = 0; i < filters.size(); i++) {
+    whereClause += filters[i].toString();
+    if (i < filters.size() - 1) {
+      whereClause += " AND ";
+    }
+  }
+
+  auto plan =
+      exec::test::PlanBuilder().values({input}).filter(whereClause).planNode();
+  auto result = referenceQueryRunner_->execute(plan);
+  VELOX_CHECK_NE(
+      result.second, exec::test::ReferenceQueryErrorCode::kReferenceQueryFail);
+  VELOX_CHECK(
+      exec::test::assertEqualResults(
+          result.first.value(), plan->outputType(), {actual}),
+      "Velox and Reference results don't match");
+}
+
+void NimbleReaderVerifier::verify(
+    RowVectorPtr input,
+    const std::vector<FilterSpec>& filters,
+    RowVectorPtr actual) {
+  if (referenceQueryRunner_ != nullptr) {
+    verifyWithQueryRunner(input, filters, actual);
+  }
+
+  if (filters.empty()) {
+    VELOX_CHECK(
+        exec::test::assertEqualResults({input}, {actual}),
+        "Input and actual results don't match when no filters are applied");
+    return;
+  }
+
+  // Create a ScanSpec for the root
+  auto scanSpec = std::make_shared<common::ScanSpec>("root");
+  scanSpec->addAllChildFields(*input->type());
+
+  // Apply filters to the appropriate columns
+  for (const auto& filterSpec : filters) {
+    auto* childSpec = scanSpec->childByName(filterSpec.name);
+    if (childSpec != nullptr) {
+      childSpec->setFilter(filterSpec.filter);
+      childSpec->setProjectOut(filterSpec.keepValues);
+    } else {
+      VELOX_FAIL("Column '{}' not found in input schema", filterSpec.name);
+    }
+  }
+  // Apply filters to get a bitmask of passing rows
+  auto size = input->size();
+  // Initialize result buffer with enough bits for all rows
+  auto resultSize = bits::nwords(size);
+  std::vector<uint64_t> resultBuffer(resultSize, ~0ULL);
+  uint64_t* result = resultBuffer.data();
+  scanSpec->applyFilter(*input, size, result);
+
+  // Count selected rows
+  vector_size_t selectedCount = 0;
+  for (int i = 0; i < size; i++) {
+    if (bits::isBitSet(result, i)) {
+      selectedCount++;
+    }
+  }
+
+  // Create expected output based on filter results
+  RowVectorPtr expected;
+  if (selectedCount == 0) {
+    // No rows passed the filter, so create empty vector with same schema
+    std::vector<VectorPtr> emptyChildren;
+    emptyChildren.reserve(input->childrenSize());
+    for (int i = 0; i < input->childrenSize(); i++) {
+      emptyChildren.push_back(
+          BaseVector::create(input->childAt(i)->type(), 0, input->pool()));
+    }
+    expected = std::make_shared<RowVector>(
+        input->pool(),
+        input->type(),
+        BufferPtr(nullptr),
+        0,
+        std::move(emptyChildren));
+  } else if (selectedCount == size) {
+    // All rows passed the filter
+    expected = input;
+  } else {
+    BufferPtr indices = allocateIndices(selectedCount, input->pool());
+    auto* rawIndices = indices->asMutable<vector_size_t>();
+    int idx = 0;
+    for (int i = 0; i < size; i++) {
+      if (bits::isBitSet(result, i)) {
+        rawIndices[idx++] = i;
+      }
+    }
+
+    // Create filtered children vectors
+    std::vector<VectorPtr> filteredChildren;
+    for (int i = 0; i < input->childrenSize(); i++) {
+      auto* childSpec = scanSpec->childByName(input->type()->asRow().nameOf(i));
+
+      if (childSpec && childSpec->projectOut()) {
+        // This column should be projected out - wrap with dictionary
+        filteredChildren.push_back(
+            BaseVector::wrapInDictionary(
+                nullptr, indices, selectedCount, input->childAt(i)));
+      } else {
+        // This column is not projected out - create null constant
+        filteredChildren.push_back(
+            BaseVector::createNullConstant(
+                input->childAt(i)->type(), selectedCount, input->pool()));
+      }
+    }
+
+    expected = std::make_shared<RowVector>(
+        input->pool(),
+        input->type(),
+        BufferPtr(nullptr),
+        selectedCount,
+        std::move(filteredChildren));
+  }
+
+  VELOX_CHECK(
+      exec::test::assertEqualResults({expected}, {actual}),
+      "Expected and actual results don't match after applying filters");
+}
+
+RowVectorPtr createInputFromChunkVectorGroups(
+    const std::vector<std::vector<VectorPtr>>& chunkVectorGroups) {
+  std::vector<RowVectorPtr> groupVectors;
+  for (const auto& chunkVectors : chunkVectorGroups) {
+    if (chunkVectors.empty()) {
+      continue;
+    }
+
+    auto groupVector = std::dynamic_pointer_cast<RowVector>(chunkVectors[0]);
+    for (int i = 1; i < chunkVectors.size(); i++) {
+      groupVector->append(chunkVectors[i].get());
+    }
+    groupVectors.push_back(groupVector);
+  }
+
+  if (groupVectors.empty()) {
+    return nullptr; // No valid groups
+  }
+
+  if (groupVectors.size() == 1) {
+    return groupVectors[0];
+  } else {
+    std::vector<std::string> allNames;
+    std::vector<TypePtr> allTypes;
+    std::vector<VectorPtr> allChildren;
+
+    int32_t childId = 0;
+    for (const auto& groupVector : groupVectors) {
+      const auto& rowType = groupVector->type()->asRow();
+      for (int i = 0; i < groupVector->childrenSize(); i++, childId++) {
+        allNames.push_back("c" + std::to_string(childId));
+        allTypes.push_back(rowType.childAt(i));
+        allChildren.push_back(groupVector->childAt(i));
+      }
+    }
+
+    auto combinedType = ROW(std::move(allNames), std::move(allTypes));
+    return std::make_shared<RowVector>(
+        groupVectors[0]->pool(),
+        combinedType,
+        BufferPtr(nullptr),
+        groupVectors[0]->size(),
+        std::move(allChildren));
+  }
+}
+
+std::vector<std::unique_ptr<StreamLoader>> writeToNimbleAndGetStreamLoaders(
+    memory::MemoryPool* pool,
+    const std::vector<std::vector<VectorPtr>>& chunkVectorGroups,
+    const std::vector<std::pair<EncodingType, float>>& readFactors,
+    const CompressionOptions& compressionOptions) {
+  using namespace facebook::nimble;
+
+  // Configure writer options with the specified read factors and compression
+  // options
+  VeloxWriterOptions writerOptions;
+  ManualEncodingSelectionPolicyFactory encodingFactory(
+      readFactors, compressionOptions);
+  writerOptions.encodingSelectionPolicyFactory = [&](DataType dataType) {
+    return encodingFactory.createPolicy(dataType);
+  };
+  writerOptions.enableChunking = true;
+  writerOptions.minStreamChunkRawSize = 0;
+  writerOptions.flushPolicyFactory = [] {
+    return std::make_unique<LambdaFlushPolicy>(
+        /*flushLambda=*/[](const StripeProgress&) { return false; },
+        /*chunkLambda=*/[](const StripeProgress&) { return true; });
+  };
+
+  std::vector<std::unique_ptr<StreamLoader>> allStreamLoaders;
+
+  for (const auto& chunkVectors : chunkVectorGroups) {
+    if (chunkVectors.empty()) {
+      continue;
+    }
+
+    auto file = facebook::nimble::test::createNimbleFile(
+        *pool, chunkVectors, writerOptions, false);
+
+    auto numChildren = chunkVectors[0]->as<RowVector>()->childrenSize();
+
+    auto readFile = std::make_unique<InMemoryReadFile>(file);
+    auto tablet = TabletReader::create(std::move(readFile), *pool);
+    auto stripeIdentifier = tablet->stripeIdentifier(0);
+    // VELOX_CHECK_EQ(numChildren + 1, tablet.streamCount(stripeIdentifier));
+
+    std::vector<uint32_t> streamIds;
+    streamIds.resize(numChildren);
+    std::iota(streamIds.begin(), streamIds.end(), 1);
+    auto streamLoaders =
+        tablet->load(stripeIdentifier, std::span<const uint32_t>(streamIds));
+
+    for (auto& loader : streamLoaders) {
+      allStreamLoaders.push_back(std::move(loader));
+    }
+  }
+
+  return allStreamLoaders;
+}
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.h
new file mode 100644
index 000000000000..a3cb2230f82c
--- /dev/null
+++ b/velox/experimental/wave/dwio/nimble/tests/NimbleReaderTestUtil.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 <cuda_runtime.h> // @manual
+#include <fmt/format.h>
+#include <gflags/gflags.h>
+#include <gtest/gtest.h>
+
+#include "dwio/nimble/encodings/EncodingSelectionPolicy.h"
+#include "dwio/nimble/tablet/TabletReader.h"
+#include "velox/dwio/common/Statistics.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/experimental/wave/dwio/ColumnReader.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFileFormat.h"
+#include "velox/experimental/wave/dwio/nimble/NimbleFormatData.h"
+#include "velox/type/Filter.h"
+
+namespace facebook::velox::wave {
+using nimble::CompressionOptions;
+using nimble::EncodingType;
+using nimble::StreamLoader;
+struct FilterSpec {
+  std::string name;
+  std::shared_ptr<common::Filter> filter;
+  bool keepValues;
+
+  std::string toString() const {
+    switch (filter->kind()) {
+      case common::FilterKind::kBigintRange: {
+        auto bigIntRangeFilter =
+            std::dynamic_pointer_cast<common::BigintRange>(this->filter);
+        return fmt::format(
+            "{} BETWEEN {} AND {}",
+            name,
+            bigIntRangeFilter->lower(),
+            bigIntRangeFilter->upper());
+      }
+      default:
+        VELOX_NYI("Not supported filter type");
+    }
+  }
+};
+
+class TestNimbleReader {
+ public:
+  TestNimbleReader(
+      memory::MemoryPool* pool,
+      RowVectorPtr input,
+      std::vector<std::unique_ptr<StreamLoader>>& streamLoaders,
+      const std::vector<FilterSpec>& filters);
+  RowVectorPtr read();
+
+ private:
+  memory::MemoryPool* pool_{nullptr};
+  RowVectorPtr input_{nullptr};
+  std::unique_ptr<GpuArena> deviceArena_{nullptr};
+  std::shared_ptr<common::ScanSpec> scanSpec_{nullptr};
+  std::unique_ptr<NimbleStripe> stripe_{nullptr};
+  std::unique_ptr<NimbleFormatParams> formatParams_{nullptr};
+  std::unique_ptr<ColumnReader> reader_{nullptr};
+  dwio::common::ColumnReaderStatistics stats_;
+  io::IoStatistics ioStats_;
+  FileInfo fileInfo_;
+  OperatorStateMap operandStateMap_;
+  std::unique_ptr<WaveStream> waveStream_{nullptr};
+  std::unique_ptr<ReadStream> readStream_{nullptr};
+  std::vector<int32_t> nonNullOutputChildrenIds_;
+  bool earlyStop_{false};
+
+  GpuArena& deviceArena() {
+    return *deviceArena_;
+  }
+};
+
+class NimbleReaderVerifier {
+ public:
+  explicit NimbleReaderVerifier(
+      std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner =
+          nullptr)
+      : referenceQueryRunner_{std::move(referenceQueryRunner)} {}
+
+  void verify(
+      RowVectorPtr input,
+      const std::vector<FilterSpec>& filters,
+      RowVectorPtr actual);
+
+ private:
+  std::unique_ptr<exec::test::ReferenceQueryRunner> referenceQueryRunner_;
+  void verifyWithQueryRunner(
+      RowVectorPtr input,
+      const std::vector<FilterSpec>& filters,
+      RowVectorPtr actual);
+};
+
+// Helper function to create input by combining chunk vector groups
+RowVectorPtr createInputFromChunkVectorGroups(
+    const std::vector<std::vector<VectorPtr>>& chunkVectorGroups);
+
+// Helper function to write multiple vectors to nimble files and get back all
+// streamLoaders. A chunk vector group contains several chunked vectors
+// (mapping to chunked streams in Nimble) that share the same chunk
+// boundaries.
+std::vector<std::unique_ptr<StreamLoader>> writeToNimbleAndGetStreamLoaders(
+    memory::MemoryPool* pool,
+    const std::vector<std::vector<VectorPtr>>& chunkVectorGroups,
+    const std::vector<std::pair<EncodingType, float>>& readFactors,
+    const CompressionOptions& compressionOptions);
+} // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/exec/CMakeLists.txt b/velox/experimental/wave/exec/CMakeLists.txt
index aa3b9286298f..fbb9b06d9985 100644
--- a/velox/experimental/wave/exec/CMakeLists.txt
+++ b/velox/experimental/wave/exec/CMakeLists.txt
@@ -14,11 +14,11 @@
 
 add_library(velox_wave_stream OperandSet.cpp Wave.cpp)
 
-target_link_libraries(
-  velox_wave_stream Folly::folly fmt::fmt xsimd)
+target_link_libraries(velox_wave_stream Folly::folly fmt::fmt xsimd)
 
 add_library(
-  velox_wave_exec OBJECT
+  velox_wave_exec
+  OBJECT
   AggregateGen.cpp
   JoinGen.cpp
   HashGen.cpp
@@ -37,7 +37,8 @@ add_library(
   Project.cpp
   TableScan.cpp
   WaveHiveDataSource.cpp
-  WaveSplitReader.cpp)
+  WaveSplitReader.cpp
+)
 
 target_link_libraries(
   velox_wave_exec
@@ -47,7 +48,8 @@ target_link_libraries(
   velox_exception
   velox_common_base
   velox_exec
-  CUDA::cudart)
+  CUDA::cudart
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/experimental/wave/exec/Instruction.cpp b/velox/experimental/wave/exec/Instruction.cpp
index 1ceda6bcebe5..450b7653b728 100644
--- a/velox/experimental/wave/exec/Instruction.cpp
+++ b/velox/experimental/wave/exec/Instruction.cpp
@@ -67,7 +67,7 @@ void restockAllocator(
   // If we can get rows by raising the row limit we do this first.
   int32_t adjustedSize = size - allocator->raiseRowLimits(size);
   if (adjustedSize <= 0) {
-    TR1(fmt::format(
+    TR(fmt::format(
         "Found {} rows of existing space", size / allocator->rowSize));
     return;
   }
@@ -82,7 +82,7 @@ void restockAllocator(
       size,
       size,
       allocator->rowSize);
-  TR1(fmt::format("Made range of {} rows", size / allocator->rowSize));
+  TR(fmt::format("Made range of {} rows", size / allocator->rowSize));
   if (allocator->ranges[0].empty()) {
     allocator->ranges[0] = std::move(newRange);
   } else {
@@ -101,7 +101,7 @@ void AggregateOperatorState::setSizesToSafe() {
   for (auto i = 0; i < numPartitions; ++i) {
     auto availableInAllocator = allocators[i].availableFixed() / rowSize;
     if (availableInAllocator > allowedPerPartition) {
-      TR1(fmt::format(
+      TR(fmt::format(
           "Trim avail from {} to {} rows\n",
           availableInAllocator,
           allowedPerPartition));
@@ -272,7 +272,7 @@ std::pair<int64_t, int64_t> countResultRows(
     auto bits = reinterpret_cast<uint64_t*>(range.base);
     int32_t numFree = bits::countBits(bits, 0, range.firstRowOffset * 8);
     if (numFree) {
-      TR1(fmt::format("freeRows={}\n", numFree));
+      TR(fmt::format("freeRows={}\n", numFree));
     }
     auto n = ((range.rowOffset - range.firstRowOffset) / rowSize) - numFree;
     count += n;
diff --git a/velox/experimental/wave/exec/SimpleAggregate.cpp b/velox/experimental/wave/exec/SimpleAggregate.cpp
index 3b621c3e1afd..f6af426fbf0a 100644
--- a/velox/experimental/wave/exec/SimpleAggregate.cpp
+++ b/velox/experimental/wave/exec/SimpleAggregate.cpp
@@ -69,7 +69,7 @@ class SimpleAggregate : public AggregateGenerator {
   virtual void makeDeduppedUpdate(
       CompileState& state,
       const AggregateProbe& probe,
-      const AggregateUpdate& update) const {
+      const AggregateUpdate& update) const override {
     if (probe.keys.empty()) {
       VELOX_NYI();
     } else {
diff --git a/velox/experimental/wave/exec/TableScan.cpp b/velox/experimental/wave/exec/TableScan.cpp
index 6a988bf02cf4..6a1cb58389b3 100644
--- a/velox/experimental/wave/exec/TableScan.cpp
+++ b/velox/experimental/wave/exec/TableScan.cpp
@@ -90,6 +90,29 @@ void TableScan::updateStats(
   }
 }
 
+void TableScan::updateStats(
+    std::unordered_map<std::string, RuntimeMetric> connectorStats,
+    WaveSplitReader* splitReader) {
+  auto lockedStats = stats().wlock();
+  if (splitReader) {
+    lockedStats->rawInputPositions = splitReader->getCompletedRows();
+    lockedStats->rawInputBytes = splitReader->getCompletedBytes();
+  }
+  for (const auto& [name, metric] : connectorStats) {
+    if (name == "ioWaitNanos") {
+      ioWaitNanos_ += metric.sum - lastIoWaitNanos_;
+      lastIoWaitNanos_ = metric.sum;
+    }
+    if (UNLIKELY(lockedStats->runtimeStats.count(name) == 0)) {
+      lockedStats->runtimeStats.insert(
+          std::make_pair(name, RuntimeMetric(metric.unit)));
+    } else {
+      VELOX_CHECK_EQ(lockedStats->runtimeStats.at(name).unit, metric.unit);
+    }
+    lockedStats->runtimeStats.at(name).merge(metric);
+  }
+}
+
 BlockingReason TableScan::nextSplit(ContinueFuture* future) {
   exec::Split split;
   blockingReason_ = driverCtx_->task->getSplitOrFuture(
@@ -106,7 +129,7 @@ BlockingReason TableScan::nextSplit(ContinueFuture* future) {
   if (!split.hasConnectorSplit()) {
     noMoreSplits_ = true;
     if (dataSource_) {
-      updateStats(dataSource_->runtimeStats());
+      updateStats(dataSource_->getRuntimeStats());
     }
     return BlockingReason::kNotBlocked;
   }
@@ -150,10 +173,6 @@ BlockingReason TableScan::nextSplit(ContinueFuture* future) {
   }
   ++stats().wlock()->numSplits;
 
-  for (const auto& entry : pendingDynamicFilters_) {
-    waveDataSource_->addDynamicFilter(entry.first, entry.second);
-  }
-  pendingDynamicFilters_.clear();
   return BlockingReason::kNotBlocked;
 }
 
@@ -199,8 +218,8 @@ void TableScan::preload(std::shared_ptr<connector::ConnectorSplit> split) {
 }
 
 void TableScan::checkPreload() {
-  auto executor = connector_->executor();
-  if (maxPreloadedSplits_ == 0 || !executor ||
+  auto ioExecutor = connector_->ioExecutor();
+  if (maxPreloadedSplits_ == 0 || !ioExecutor ||
       !connector_->supportsSplitPreload()) {
     return;
   }
@@ -209,10 +228,10 @@ void TableScan::checkPreload() {
         maxSplitPreloadPerDriver_;
     if (!splitPreloader_) {
       splitPreloader_ =
-          [executor, this](std::shared_ptr<connector::ConnectorSplit> split) {
+          [ioExecutor, this](std::shared_ptr<connector::ConnectorSplit> split) {
             preload(split);
 
-            executor->add(
+            ioExecutor->add(
                 [taskHolder = driver_->operatorCtx()->task(), split]() mutable {
                   split->dataSource->prepare();
                   split.reset();
@@ -226,15 +245,4 @@ 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
index c07530789494..905cc0f7b80c 100644
--- a/velox/experimental/wave/exec/TableScan.h
+++ b/velox/experimental/wave/exec/TableScan.h
@@ -65,15 +65,6 @@ class TableScan : public WaveSourceOperator {
 
   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_;
   }
@@ -105,14 +96,15 @@ class TableScan : public WaveSourceOperator {
   void updateStats(
       std::unordered_map<std::string, RuntimeCounter> stats,
       WaveSplitReader* splitReader = nullptr);
+  void updateStats(
+      std::unordered_map<std::string, RuntimeMetric> 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_;
+  const connector::ConnectorTableHandlePtr tableHandle_;
+  const connector::ColumnHandleMap columnHandles_;
   exec::DriverCtx* const driverCtx_;
   memory::MemoryPool* const connectorPool_;
   ContinueFuture blockingFuture_{ContinueFuture::makeEmpty()};
@@ -121,9 +113,6 @@ class TableScan : public WaveSourceOperator {
   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_;
 
diff --git a/velox/experimental/wave/exec/ToWave.cpp b/velox/experimental/wave/exec/ToWave.cpp
index acbcf51613d1..98f839c8e7ce 100644
--- a/velox/experimental/wave/exec/ToWave.cpp
+++ b/velox/experimental/wave/exec/ToWave.cpp
@@ -70,7 +70,7 @@ common::Subfield* CompileState::toSubfield(const std::string& name) {
 
 // true if expr translates to Subfield path.
 bool isField(const Expr& expr) {
-  if (auto* field = dynamic_cast<const exec::FieldReference*>(&expr)) {
+  if (dynamic_cast<const exec::FieldReference*>(&expr)) {
     return (expr.inputs().empty());
   }
   return false;
diff --git a/velox/experimental/wave/exec/ToWave.h b/velox/experimental/wave/exec/ToWave.h
index d17820634e58..8fd38c65b4bf 100644
--- a/velox/experimental/wave/exec/ToWave.h
+++ b/velox/experimental/wave/exec/ToWave.h
@@ -279,7 +279,7 @@ struct Filter : public KernelStep {
     return true;
   }
 
-  int32_t sharedMemorySize() const {
+  int32_t sharedMemorySize() const override {
     return sizeof(WaveShared) + (kBlockSize / 32) * sizeof(int32_t);
   }
 
@@ -405,7 +405,7 @@ struct AggregateUpdate : public KernelStep {
     return StepKind::kAggregateUpdate;
   }
 
-  bool isSink() const {
+  bool isSink() const override {
     return true;
   }
 
@@ -456,7 +456,7 @@ struct AggregateProbe : public KernelStep {
     return !updates.empty() && allUpdatesInlined;
   }
 
-  int32_t sharedMemorySize() const {
+  int32_t sharedMemorySize() const override {
     // If no grouping, we have one word plus one byte of shared memory
     // per warp and a pad of 4 to align at 8. This is after the
     // regular WaveShared struct.
@@ -646,7 +646,7 @@ struct JoinExpand : public KernelStep {
     return true;
   }
 
-  int32_t sharedMemorySize() const {
+  int32_t sharedMemorySize() const override {
     return sizeof(WaveShared) + sizeof(JoinShared);
   }
 
diff --git a/velox/experimental/wave/exec/Wave.cpp b/velox/experimental/wave/exec/Wave.cpp
index 5c2a6d0b72e9..15851d3b3fad 100644
--- a/velox/experimental/wave/exec/Wave.cpp
+++ b/velox/experimental/wave/exec/Wave.cpp
@@ -981,6 +981,7 @@ int32_t WaveStream::getOutput(
     auto id = operands[i];
     auto exe = operandExecutable(id);
     VELOX_CHECK_NOT_NULL(exe);
+    exe->stream->wait();
     auto ordinal = exe->outputOperands.ordinal(id);
     auto waveVectorPtr = &exe->output[ordinal];
     if (!waveVectorPtr->get()) {
diff --git a/velox/experimental/wave/exec/Wave.h b/velox/experimental/wave/exec/Wave.h
index ab0a8ae332e7..1c11548e87ed 100644
--- a/velox/experimental/wave/exec/Wave.h
+++ b/velox/experimental/wave/exec/Wave.h
@@ -30,22 +30,28 @@
 #include <folly/executors/CPUThreadPoolExecutor.h>
 
 #include <iostream>
+#include <utility>
 
 DECLARE_bool(wave_timing);
 DECLARE_bool(wave_transfer_timing);
 DECLARE_bool(wave_trace_stream);
 
-#define TR(str, msg)                                                   \
-  if (FLAGS_wave_trace_stream) {                                       \
-    (std::cout << fmt::format("St{}: {}\n", (str)->streamIdx(), msg)); \
-  }
+namespace facebook::velox::wave {
 
-#define TR1(msg)                 \
-  if (FLAGS_wave_trace_stream) { \
-    std::cout << msg;            \
+template <typename StreamType, typename MsgType>
+inline void TR(StreamType&& stream, const MsgType& msg) {
+  if (FLAGS_wave_trace_stream) {
+    std::cout << fmt::format(
+        "St{}: {}\n", std::forward<StreamType>(stream)->streamIdx(), msg);
   }
+}
 
-namespace facebook::velox::wave {
+template <typename MsgType>
+inline void TR(const MsgType& msg) {
+  if (FLAGS_wave_trace_stream) {
+    std::cout << msg;
+  }
+}
 
 /// Scoped guard, prints the time spent inside if
 class PrintTime {
diff --git a/velox/experimental/wave/exec/WaveDataSource.h b/velox/experimental/wave/exec/WaveDataSource.h
index caf7c28f2504..be0cf309cd95 100644
--- a/velox/experimental/wave/exec/WaveDataSource.h
+++ b/velox/experimental/wave/exec/WaveDataSource.h
@@ -56,7 +56,7 @@ class WaveDataSource : public std::enable_shared_from_this<WaveDataSource> {
 
   virtual uint64_t getCompletedRows() = 0;
 
-  virtual std::unordered_map<std::string, RuntimeCounter> runtimeStats() = 0;
+  virtual std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() = 0;
 
   virtual void setFromDataSource(std::shared_ptr<WaveDataSource> source) {
     VELOX_UNSUPPORTED();
diff --git a/velox/experimental/wave/exec/WaveDriver.cpp b/velox/experimental/wave/exec/WaveDriver.cpp
index c6f97ecb6899..d8840263e789 100644
--- a/velox/experimental/wave/exec/WaveDriver.cpp
+++ b/velox/experimental/wave/exec/WaveDriver.cpp
@@ -416,7 +416,7 @@ bool WaveDriver::maybeWaitForPeers() {
   if (barrier_->stateMap().states.empty()) {
     return false;
   }
-  TR1("wait_for_peers\n");
+  TR("wait_for_peers\n");
   std::vector<ContinuePromise> promises;
   std::vector<std::shared_ptr<exec::Driver>> peers;
 
diff --git a/velox/experimental/wave/exec/WaveDriver.h b/velox/experimental/wave/exec/WaveDriver.h
index a0072a64bbe7..77fd6322a828 100644
--- a/velox/experimental/wave/exec/WaveDriver.h
+++ b/velox/experimental/wave/exec/WaveDriver.h
@@ -210,12 +210,10 @@ class WaveDriver : public exec::SourceOperator {
 
   std::string toString() const override;
 
-  void addDynamicFilter(
+  void addDynamicFilterLocked(
       const core::PlanNodeId& producer,
-      column_index_t outputChannel,
-      const std::shared_ptr<common::Filter>& filter) override {
-    pipelines_[0].operators[0]->addDynamicFilter(
-        producer, outputChannel, filter);
+      const exec::PushdownFilters& filters) override {
+    pipelines_[0].operators[0]->addDynamicFilter(producer, filters);
   }
 
   exec::OperatorCtx* operatorCtx() const {
diff --git a/velox/experimental/wave/exec/WaveGen.cpp b/velox/experimental/wave/exec/WaveGen.cpp
index 7807909df68c..5d1b5f9391b7 100644
--- a/velox/experimental/wave/exec/WaveGen.cpp
+++ b/velox/experimental/wave/exec/WaveGen.cpp
@@ -1039,11 +1039,12 @@ void CompileState::generatePrograms() {
     auto firstOperatorIdx = operators_.size();
     if (firstStep->kind() == StepKind::kTableScan) {
       auto& scanStep = firstStep->as<TableScanStep>();
-      operators_.push_back(std::make_unique<TableScan>(
-          *this,
-          operators_.size(),
-          *scanStep.node,
-          std::move(scanStep.defines)));
+      operators_.push_back(
+          std::make_unique<TableScan>(
+              *this,
+              operators_.size(),
+              *scanStep.node,
+              std::move(scanStep.defines)));
       start = 1;
     }
     instructionStatus_ = InstructionStatus();
@@ -1085,10 +1086,11 @@ void CompileState::generatePrograms() {
       levels.back().push_back(std::move(program));
     }
     if (!levels.empty()) {
-      operators_.push_back(std::make_unique<Project>(
-          *this,
-          selectedPipelines_[pipelineIdx_].outputType,
-          std::move(levels)));
+      operators_.push_back(
+          std::make_unique<Project>(
+              *this,
+              selectedPipelines_[pipelineIdx_].outputType,
+              std::move(levels)));
       currentCandidate_->setOutputIds(
           this,
           operators_.back().get(),
diff --git a/velox/experimental/wave/exec/WaveHiveDataSource.cpp b/velox/experimental/wave/exec/WaveHiveDataSource.cpp
index 1b372008303c..740f0f8a859c 100644
--- a/velox/experimental/wave/exec/WaveHiveDataSource.cpp
+++ b/velox/experimental/wave/exec/WaveHiveDataSource.cpp
@@ -21,11 +21,10 @@ namespace facebook::velox::wave {
 using namespace connector::hive;
 
 WaveHiveDataSource::WaveHiveDataSource(
-    const std::shared_ptr<HiveTableHandle>& hiveTableHandle,
+    const HiveTableHandlePtr& hiveTableHandle,
     const std::shared_ptr<common::ScanSpec>& scanSpec,
     const RowTypePtr& readerOutputType,
-    std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
-        partitionKeys,
+    std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
     FileHandleFactory* fileHandleFactory,
     folly::Executor* executor,
     const connector::ConnectorQueryCtx* connectorQueryCtx,
@@ -124,8 +123,9 @@ bool WaveHiveDataSource::isFinished() {
       if (it == splitReaderStats_.end()) {
         splitReaderStats_.insert(std::make_pair(name, counter));
       } else {
-        splitReaderStats_.insert(std::make_pair(
-            name, RuntimeCounter(it->second.value, counter.unit)));
+        splitReaderStats_.insert(
+            std::make_pair(
+                name, RuntimeCounter(it->second.value, counter.unit)));
       }
     }
     return true;
@@ -141,11 +141,12 @@ uint64_t WaveHiveDataSource::getCompletedRows() {
   return completedRows_;
 }
 
-std::unordered_map<std::string, RuntimeCounter>
-WaveHiveDataSource::runtimeStats() {
-  auto map = runtimeStats_.toMap();
+std::unordered_map<std::string, RuntimeMetric>
+WaveHiveDataSource::getRuntimeStats() {
+  auto map = runtimeStats_.toRuntimeMetricMap();
   for (const auto& [name, counter] : splitReaderStats_) {
-    map.insert(std::make_pair(name, counter));
+    map.insert(
+        std::make_pair(name, RuntimeMetric(counter.value, counter.unit)));
   }
   return map;
 }
@@ -161,17 +162,14 @@ void WaveHiveDataSource::registerConnector() {
       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::hive::HiveConnectorFactory factory;
+  auto hiveConnector = factory.newConnector("wavemock", config, nullptr);
   connector::registerConnector(hiveConnector);
   connector::hive::HiveDataSource::registerWaveDelegateHook(
-      [](const std::shared_ptr<HiveTableHandle>& hiveTableHandle,
+      [](const HiveTableHandlePtr& hiveTableHandle,
          const std::shared_ptr<common::ScanSpec>& scanSpec,
          const RowTypePtr& readerOutputType,
-         std::unordered_map<std::string, std::shared_ptr<HiveColumnHandle>>*
-             partitionKeys,
+         std::unordered_map<std::string, HiveColumnHandlePtr>* partitionKeys,
          FileHandleFactory* fileHandleFactory,
          folly::Executor* executor,
          const connector::ConnectorQueryCtx* connectorQueryCtx,
@@ -183,7 +181,6 @@ void WaveHiveDataSource::registerConnector() {
             hiveTableHandle,
             scanSpec,
             readerOutputType,
-
             partitionKeys,
             fileHandleFactory,
             executor,
diff --git a/velox/experimental/wave/exec/WaveHiveDataSource.h b/velox/experimental/wave/exec/WaveHiveDataSource.h
index 7e1336ab4f57..01634f701d1a 100644
--- a/velox/experimental/wave/exec/WaveHiveDataSource.h
+++ b/velox/experimental/wave/exec/WaveHiveDataSource.h
@@ -24,12 +24,11 @@ namespace facebook::velox::wave {
 class WaveHiveDataSource : public WaveDataSource {
  public:
   WaveHiveDataSource(
-      const std::shared_ptr<connector::hive::HiveTableHandle>& hiveTableHandle,
+      const connector::hive::HiveTableHandlePtr& hiveTableHandle,
       const std::shared_ptr<common::ScanSpec>& scanSpec,
       const RowTypePtr& readerOutputType,
-      std::unordered_map<
-          std::string,
-          std::shared_ptr<connector::hive::HiveColumnHandle>>* partitionKeys,
+      std::unordered_map<std::string, connector::hive::HiveColumnHandlePtr>*
+          partitionKeys,
       FileHandleFactory* fileHandleFactory,
       folly::Executor* executor,
       const connector::ConnectorQueryCtx* connectorQueryCtx,
@@ -60,7 +59,7 @@ class WaveHiveDataSource : public WaveDataSource {
 
   uint64_t getCompletedRows() override;
 
-  std::unordered_map<std::string, RuntimeCounter> runtimeStats() override;
+  std::unordered_map<std::string, RuntimeMetric> getRuntimeStats() override;
 
   static void registerConnector();
 
diff --git a/velox/experimental/wave/exec/WaveOperator.h b/velox/experimental/wave/exec/WaveOperator.h
index f2ec2305cb30..9a09fdde6bfd 100644
--- a/velox/experimental/wave/exec/WaveOperator.h
+++ b/velox/experimental/wave/exec/WaveOperator.h
@@ -175,8 +175,7 @@ class WaveOperator {
 
   virtual void addDynamicFilter(
       const core::PlanNodeId& /*producer*/,
-      column_index_t /*outputChannel*/,
-      const std::shared_ptr<common::Filter>& /*filter*/) {
+      const exec::PushdownFilters& /*filters*/) {
     VELOX_UNSUPPORTED();
   }
 
diff --git a/velox/experimental/wave/exec/WavePlan.cpp b/velox/experimental/wave/exec/WavePlan.cpp
index ff53baa46bc5..30eddd9f9b1c 100644
--- a/velox/experimental/wave/exec/WavePlan.cpp
+++ b/velox/experimental/wave/exec/WavePlan.cpp
@@ -134,9 +134,8 @@ AbstractOperand* CompileState::fieldToOperand(Subfield& field, Scope* scope) {
   if (op) {
     return markUse(op);
   }
-  auto* name =
-      &reinterpret_cast<common::Subfield::NestedField*>(field.path()[0].get())
-           ->name();
+
+  auto* name = &field.baseName();
   VELOX_CHECK_EQ(topScopes_.size(), renames_.size());
   for (int32_t i = renames_.size() - 1; i >= 0; --i) {
     auto* op = topScopes_[i].findValue(Value(&field));
@@ -436,6 +435,7 @@ bool CompileState::tryPlanOperator(
     step->state = state;
     step->id = atoi(node->id().c_str());
     segments_.back().steps.push_back(step);
+    step->joinType = node->joinType();
     auto expand = makeStep<JoinExpand>();
     step->expand = expand;
     expand->nthWrap = wrapId_++;
@@ -842,10 +842,10 @@ void CompileState::planSegment(
       }
       bool needNewKernel = false;
       auto* node = segment.planNode;
-      if (auto* scan = dynamic_cast<const core::TableScanNode*>(node)) {
+      if (dynamic_cast<const core::TableScanNode*>(node)) {
         candidate.currentBox->steps.push_back(segment.steps[0]);
         needNewKernel = true;
-      } else if (auto* values = dynamic_cast<const core::ValuesNode*>(node)) {
+      } else if (dynamic_cast<const core::ValuesNode*>(node)) {
         candidate.currentBox->steps.push_back(segment.steps[0]);
         needNewKernel = true;
       } else if (
diff --git a/velox/experimental/wave/exec/WaveSplitReader.h b/velox/experimental/wave/exec/WaveSplitReader.h
index 3bd4e6a7cc54..7d99d0b938e8 100644
--- a/velox/experimental/wave/exec/WaveSplitReader.h
+++ b/velox/experimental/wave/exec/WaveSplitReader.h
@@ -30,12 +30,11 @@ namespace facebook::velox::wave {
 
 /// Parameters for a Wave Hive SplitReaderFactory.
 struct SplitReaderParams {
-  std ::shared_ptr<connector::hive::HiveTableHandle> hiveTableHandle;
+  connector::hive::HiveTableHandlePtr hiveTableHandle;
   std::shared_ptr<common::ScanSpec> scanSpec;
   RowTypePtr readerOutputType;
-  std::unordered_map<
-      std::string,
-      std::shared_ptr<connector::hive::HiveColumnHandle>>* partitionKeys;
+  std::unordered_map<std::string, connector::hive::HiveColumnHandlePtr>*
+      partitionKeys;
   FileHandleFactory* fileHandleFactory;
   folly::Executor* executor;
   const connector::ConnectorQueryCtx* connectorQueryCtx;
diff --git a/velox/experimental/wave/exec/tests/CMakeLists.txt b/velox/experimental/wave/exec/tests/CMakeLists.txt
index 002803639c00..acbdd7ce3ef5 100644
--- a/velox/experimental/wave/exec/tests/CMakeLists.txt
+++ b/velox/experimental/wave/exec/tests/CMakeLists.txt
@@ -20,7 +20,8 @@ add_executable(
   TableScanTest.cpp
   HashJoinTest.cpp
   BarrierTest.cpp
-  Main.cpp)
+  Main.cpp
+)
 
 target_link_libraries(
   velox_wave_exec_test
@@ -52,7 +53,8 @@ target_link_libraries(
   gflags::gflags
   glog::glog
   fmt::fmt
-  CUDA::cudart)
+  CUDA::cudart
+)
 
 add_test(velox_wave_exec_test velox_wave_exec_test)
 set_tests_properties(velox_wave_exec_test PROPERTIES LABELS cuda_driver)
@@ -92,5 +94,6 @@ if(${VELOX_ENABLE_BENCHMARKS})
     gflags::gflags
     glog::glog
     fmt::fmt
-    CUDA::cudart)
+    CUDA::cudart
+  )
 endif()
diff --git a/velox/experimental/wave/exec/tests/HashJoinTest.cpp b/velox/experimental/wave/exec/tests/HashJoinTest.cpp
index ee1b06c83498..cf1590168bd9 100644
--- a/velox/experimental/wave/exec/tests/HashJoinTest.cpp
+++ b/velox/experimental/wave/exec/tests/HashJoinTest.cpp
@@ -124,3 +124,66 @@ TEST_F(HashJoinTest, manyHits) {
           "SELECT t_k1, t_k2, t_data, u_k1, u_k2, u_data FROM t, u WHERE t_k1 = u_k1 AND t_k2 = u_k2")
       .run();
 }
+
+TEST_F(HashJoinTest, DISABLED_twoKeysLeft) {
+  probeType_ = ROW({"t_k1", "t_k2", "t_data"}, {BIGINT(), BIGINT(), BIGINT()});
+  buildType_ = ROW({"u_k1", "u_k2", "u_data"}, {BIGINT(), BIGINT(), BIGINT()});
+
+  auto build = makeRowVector(
+      {"u_k1", "u_k2", "u_data"},
+      {makeFlatVector<int64_t>(1000, [&](auto r) { return r; }),
+       makeFlatVector<int64_t>(1000, [&](auto r) { return r; }),
+       makeFlatVector<int64_t>(1000, [&](auto r) { return r; })});
+  auto probe = makeRowVector(
+      {"t_k1", "t_k2", "t_data"},
+      {makeFlatVector<int64_t>(1000, [&](auto r) { return r + 100; }),
+       makeFlatVector<int64_t>(1000, [&](auto r) { return r + 100; }),
+       makeFlatVector<int64_t>(1000, [&](auto r) { return r + 2; })});
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .probeType(probeType_)
+      .probeKeys({"t_k1", "t_k2"})
+      .probeVectors({probe})
+      .joinType(core::JoinType::kLeft)
+      .buildType(buildType_)
+      .buildKeys({"u_k1", "u_k2"})
+      .buildVectors({build})
+      .injectSpill(false)
+      .referenceQuery(
+          "SELECT t_k1, t_k2, t_data, u_k1, u_k2, u_data FROM t LEFT JOIN u ON t_k1 = u_k1 AND t_k2 = u_k2")
+      .run();
+}
+
+TEST_F(HashJoinTest, DISABLED_manyHitsLeft) {
+  probeType_ = ROW({"t_k1", "t_k2", "t_data"}, {BIGINT(), BIGINT(), BIGINT()});
+  buildType_ = ROW({"u_k1", "u_k2", "u_data"}, {BIGINT(), BIGINT(), BIGINT()});
+
+  int32_t numRepeats = 20;
+  auto build = makeRowVector(
+      {"u_k1", "u_k2", "u_data"},
+      {makeFlatVector<int64_t>(
+           15000, [&](auto r) { return (r / numRepeats) * 9; }),
+       makeFlatVector<int64_t>(
+           15000, [&](auto r) { return (r / numRepeats) * 9; }),
+       makeFlatVector<int64_t>(15000, [&](auto r) { return r; })});
+  auto probe = makeRowVector(
+      {"t_k1", "t_k2", "t_data"},
+      {makeFlatVector<int64_t>(1000, [&](auto r) { return r * 3; }),
+       makeFlatVector<int64_t>(1000, [&](auto r) { return r * 3; }),
+       makeFlatVector<int64_t>(1000, [&](auto r) { return r; })});
+
+  HashJoinBuilder(*pool_, duckDbQueryRunner_, driverExecutor_.get())
+      .numDrivers(1)
+      .probeType(probeType_)
+      .probeKeys({"t_k1", "t_k2"})
+      .probeVectors({probe})
+      .joinType(core::JoinType::kLeft)
+      .buildType(buildType_)
+      .buildKeys({"u_k1", "u_k2"})
+      .buildVectors({build})
+      .injectSpill(false)
+      .referenceQuery(
+          "SELECT t_k1, t_k2, t_data, u_k1, u_k2, u_data FROM t LEFT JOIN u ON t_k1 = u_k1 AND t_k2 = u_k2")
+      .run();
+}
diff --git a/velox/experimental/wave/exec/tests/TableScanTest.cpp b/velox/experimental/wave/exec/tests/TableScanTest.cpp
index 24969fee14eb..b7e34f9a952d 100644
--- a/velox/experimental/wave/exec/tests/TableScanTest.cpp
+++ b/velox/experimental/wave/exec/tests/TableScanTest.cpp
@@ -214,7 +214,7 @@ class TableScanTest : public virtual HiveConnectorTestBase,
     for (auto i = begin; i < end; ++i) {
       auto child = row->childAt(i);
       int32_t counter = 0;
-      if (auto ints = child->as<FlatVector<int64_t>>()) {
+      if (child->as<FlatVector<int64_t>>()) {
         makeNumbers(child, mod, counter);
       }
       if (notNull) {
diff --git a/velox/experimental/wave/exec/tests/WaveBenchmark.cpp b/velox/experimental/wave/exec/tests/WaveBenchmark.cpp
index d4ac1f136eeb..31727faf5439 100644
--- a/velox/experimental/wave/exec/tests/WaveBenchmark.cpp
+++ b/velox/experimental/wave/exec/tests/WaveBenchmark.cpp
@@ -15,10 +15,9 @@
  */
 
 #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/dwio/parquet/writer/Writer.h"
+#include "velox/exec/PlanNodeStats.h"
 #include "velox/experimental/wave/common/Cuda.h"
 #include "velox/experimental/wave/exec/ToWave.h"
 #include "velox/experimental/wave/exec/WaveHiveDataSource.h"
@@ -258,8 +257,11 @@ class WaveBenchmark : public QueryBenchmarkBase {
         float passRatio = FLAGS_filter_pass_pct / 100.0;
         std::vector<std::string> scanFilters;
         for (auto i = 0; i < FLAGS_num_column_filters; ++i) {
-          scanFilters.push_back(fmt::format(
-              "c{} < {}", i, static_cast<int64_t>(specs_[i].mod * passRatio)));
+          scanFilters.push_back(
+              fmt::format(
+                  "c{} < {}",
+                  i,
+                  static_cast<int64_t>(specs_[i].mod * passRatio)));
         }
         auto builder =
             PlanBuilder(leafPool_.get()).tableScan(type_, scanFilters);
@@ -267,10 +269,11 @@ class WaveBenchmark : public QueryBenchmarkBase {
         for (auto i = FLAGS_num_column_filters;
              i < FLAGS_num_column_filters + FLAGS_num_expr_filters;
              ++i) {
-          builder = builder.filter(fmt::format(
-              "c{} + 1 < {}",
-              i,
-              static_cast<int64_t>(specs_[i].mod * passRatio)));
+          builder = builder.filter(
+              fmt::format(
+                  "c{} + 1 < {}",
+                  i,
+                  static_cast<int64_t>(specs_[i].mod * passRatio)));
         }
 
         std::vector<std::string> aggInputs;
@@ -278,12 +281,13 @@ class WaveBenchmark : public QueryBenchmarkBase {
         std::vector<std::string> keys;
         for (auto i = 0; i < type_->size(); ++i) {
           if (i < FLAGS_num_keys) {
-            keyProjections.push_back(fmt::format(
-                "(c{} / {}) % {} as c{}",
-                i,
-                specs_[i].roundUp,
-                FLAGS_key_mod,
-                i));
+            keyProjections.push_back(
+                fmt::format(
+                    "(c{} / {}) % {} as c{}",
+                    i,
+                    specs_[i].roundUp,
+                    FLAGS_key_mod,
+                    i));
             keys.push_back(fmt::format("c{}", i));
           } else {
             keyProjections.push_back(fmt::format("c{}", i));
diff --git a/velox/experimental/wave/exec/tests/utils/CMakeLists.txt b/velox/experimental/wave/exec/tests/utils/CMakeLists.txt
index e977acd4506e..6bd74f062a33 100644
--- a/velox/experimental/wave/exec/tests/utils/CMakeLists.txt
+++ b/velox/experimental/wave/exec/tests/utils/CMakeLists.txt
@@ -13,8 +13,7 @@
 # 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)
+target_link_libraries(velox_wave_mock_file velox_exception velox_common_base velox_vector)
 
 add_library(velox_wave_mock_reader WaveTestSplitReader.cpp TestFormatReader.cpp)
 
@@ -26,4 +25,5 @@ target_link_libraries(
   velox_wave_decode
   velox_exception
   velox_common_base
-  velox_vector)
+  velox_vector
+)
diff --git a/velox/experimental/wave/exec/tests/utils/FileFormat.cpp b/velox/experimental/wave/exec/tests/utils/FileFormat.cpp
index 1c944c94b5ab..2673934d3ad7 100644
--- a/velox/experimental/wave/exec/tests/utils/FileFormat.cpp
+++ b/velox/experimental/wave/exec/tests/utils/FileFormat.cpp
@@ -383,8 +383,11 @@ void Writer::finishStripe() {
     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));
+  stripes_.push_back(
+      std::make_unique<Stripe>(
+          std::move(columns),
+          dwio::common::TypeWithId::create(type_),
+          numRows));
   encoders_.clear();
   rowsInStripe_ = 0;
 }
@@ -617,8 +620,9 @@ void Table::fromFile(
       int32_t numRows;
       readNumber(footerStream, numRows);
       auto columns = readColumns(footerStream);
-      stripes.push_back(std::make_unique<Stripe>(
-          std::move(columns), typeWithId, numRows, path));
+      stripes.push_back(
+          std::make_unique<Stripe>(
+              std::move(columns), typeWithId, numRows, path));
     }
   }
   addStripes(std::move(stripes), nullptr);
diff --git a/velox/experimental/wave/exec/tests/utils/FileFormat.h b/velox/experimental/wave/exec/tests/utils/FileFormat.h
index 58e837d6beec..05da39cdacb0 100644
--- a/velox/experimental/wave/exec/tests/utils/FileFormat.h
+++ b/velox/experimental/wave/exec/tests/utils/FileFormat.h
@@ -285,8 +285,9 @@ class Table {
     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));
+      result.push_back(
+          std::make_shared<connector::hive::HiveConnectorSplit>(
+              "test-hive", stripe->name, dwio::common::FileFormat::UNKNOWN));
     }
     return result;
   }
diff --git a/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp b/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp
index e6032a27e413..b4b9f28d0a21 100644
--- a/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp
+++ b/velox/experimental/wave/exec/tests/utils/TestFormatReader.cpp
@@ -289,15 +289,17 @@ class TestStructColumnReader : public StructColumnReader {
       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.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);
     }
diff --git a/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp
index bdbaab479d75..04d39385930c 100644
--- a/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp
+++ b/velox/experimental/wave/exec/tests/utils/WaveTestSplitReader.cpp
@@ -35,8 +35,9 @@ WaveTestSplitReader::WaveTestSplitReader(
   stripe_ = test::Table::getStripe(hiveSplit->filePath);
   if (!stripe_->isLoaded()) {
     try {
+      FileHandleKey key{stripe_->path};
       fileHandle_ = params_.fileHandleFactory->generate(
-          stripe_->path,
+          key,
           hiveSplit->properties.has_value() ? &*hiveSplit->properties
                                             : nullptr);
       VELOX_CHECK_NOT_NULL(fileHandle_.get());
@@ -80,8 +81,9 @@ 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()));
+  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())));
diff --git a/velox/experimental/wave/jit/Headers.h b/velox/experimental/wave/jit/Headers.h
index e5dbbe412b7e..c4247c65ca27 100644
--- a/velox/experimental/wave/jit/Headers.h
+++ b/velox/experimental/wave/jit/Headers.h
@@ -248,8 +248,7 @@ const char* velox_experimental_wave_common_Scan_cuh =
     "  constexpr int32_t kNumWarps = kBlockSize / kWarpThreads;\n"
     "  using Scan = WarpScan<T>;\n"
     "  T sum;\n"
-    "  Scan()\n"
-    "      .exclusiveSum(input, sum);\n"
+    "  Scan().exclusiveSum(input, sum);\n"
     "  if (kBlockSize == kWarpThreads) {\n"
     "    if (total) {\n"
     "      if (threadIdx.x == kWarpThreads - 1) {\n"
@@ -266,8 +265,7 @@ const char* velox_experimental_wave_common_Scan_cuh =
     "  using InnerScan = WarpScan<T, kNumWarps>;\n"
     "  T warpSum = threadIdx.x < kNumWarps ? temp[threadIdx.x] : 0;\n"
     "  T blockSum;\n"
-    "  InnerScan()\n"
-    "      .exclusiveSum(warpSum, blockSum);\n"
+    "  InnerScan().exclusiveSum(warpSum, blockSum);\n"
     "  if (threadIdx.x < kNumWarps) {\n"
     "    temp[threadIdx.x] = blockSum;\n"
     "    if (total && threadIdx.x == kNumWarps - 1) {\n"
@@ -287,8 +285,7 @@ const char* velox_experimental_wave_common_Scan_cuh =
     "  constexpr int32_t kNumWarps = kBlockSize / kWarpThreads;\n"
     "  using Scan = WarpScan<T>;\n"
     "  T sum;\n"
-    "  Scan()\n"
-    "      .inclusiveSum(input, sum);\n"
+    "  Scan().inclusiveSum(input, sum);\n"
     "  if (kBlockSize <= kWarpThreads) {\n"
     "    if (total != nullptr) {\n"
     "      if (threadIdx.x == kBlockSize - 1) {\n"
@@ -306,8 +303,7 @@ const char* velox_experimental_wave_common_Scan_cuh =
     "  using InnerScan = WarpScan<T, kInnerWidth>;\n"
     "  T warpSum = threadIdx.x < kInnerWidth ? temp[threadIdx.x] : 0;\n"
     "  T blockSum;\n"
-    "  InnerScan()\n"
-    "      .exclusiveSum(warpSum, blockSum);\n"
+    "  InnerScan().exclusiveSum(warpSum, blockSum);\n"
     "  if (threadIdx.x < kInnerWidth) {\n"
     "    temp[threadIdx.x] = blockSum;\n"
     "  }\n"
@@ -318,7 +314,6 @@ const char* velox_experimental_wave_common_Scan_cuh =
     "  return sum + temp[threadIdx.x / kWarpThreads];\n"
     "}\n"
     "\n"
-    "\n"
     "} // namespace facebook::velox::wave\n";
 bool velox_experimental_wave_common_Scan_cuh_reg =
     registerHeader(velox_experimental_wave_common_Scan_cuh);
@@ -641,7 +636,7 @@ const char* velox_experimental_wave_exec_WaveCore_cuh =
     "    int32_t blockBase,\n"
     "    T& value) {\n"
     "  auto op = operands[opIdx];\n"
-    "  int32_t index = threadIdx.x;\n"
+    "  auto index = threadIdx.x;\n"
     "  if (auto indicesInOp = op->indices) {\n"
     "    auto indices = indicesInOp[blockBase / kBlockSize];\n"
     "    if (indices) {\n"
@@ -669,7 +664,7 @@ const char* velox_experimental_wave_exec_WaveCore_cuh =
     "    int32_t blockBase,\n"
     "    T& value) {\n"
     "  auto op = operands[opIdx];\n"
-    "  int32_t index = threadIdx.x;\n"
+    "  auto index = threadIdx.x;\n"
     "  if (!kMayWrap) {\n"
     "    index = (index + blockBase) & op->indexMask;\n"
     "    if (op->nulls && op->nulls[index] == kNull) {\n"
@@ -715,7 +710,7 @@ const char* velox_experimental_wave_exec_WaveCore_cuh =
     "T __device__ __forceinline__\n"
     "nonNullOperand(Operand** operands, OperandIndex opIdx, int32_t blockBase) {\n"
     "  auto op = operands[opIdx];\n"
-    "  int32_t index = threadIdx.x;\n"
+    "  auto index = threadIdx.x;\n"
     "  if (!kMayWrap) {\n"
     "    index = (index + blockBase) & op->indexMask;\n"
     "    return reinterpret_cast<const T*>(op->base)[index];\n"
@@ -818,13 +813,13 @@ const char* velox_experimental_wave_exec_WaveCore_cuh =
     "    shared->states = params.operatorStates[0];                                 \\\n"
     "    shared->nthBlock = 0;                                                      \\\n"
     "    shared->streamIdx = params.streamIdx;                                      \\\n"
-    "    shared->localContinue = false;  \\\n"
+    "    shared->localContinue = false;                                             \\\n"
     "    shared->isContinue = params.startPC != nullptr;                            \\\n"
     "    if (shared->isContinue) {                                                  \\\n"
     "      shared->startLabel = params.startPC[shared->programIdx];                 \\\n"
-    "    } else { \\\n"
-    "      shared->startLabel = -1; \\\n"
-    "      }\\\n"
+    "    } else {                                                                   \\\n"
+    "      shared->startLabel = -1;                                                 \\\n"
+    "    }                                                                          \\\n"
     "    shared->extraWraps = params.extraWraps;                                    \\\n"
     "    shared->numExtraWraps = params.numExtraWraps;                              \\\n"
     "    shared->hasContinue = false;                                               \\\n"
@@ -1217,7 +1212,7 @@ const char* velox_experimental_wave_exec_ExprKernel_h =
     "  /// non-continue case, e.g. first kernel of 1:n join or unnest\n"
     "  /// producing non-first result for an active lane of input.\n"
     "  bool localContinue;\n"
-    "  \n"
+    "\n"
     "  /// If true, all threads in block return before starting next instruction.\n"
     "  bool stop;\n"
     "  int32_t blockBase;\n"
@@ -1311,7 +1306,6 @@ const char* velox_experimental_wave_exec_ExprKernel_h =
     "  int32_t temp[kBlockSize / 32];\n"
     "};\n"
     "\n"
-    " \n"
     "} // namespace facebook::velox::wave\n";
 bool velox_experimental_wave_exec_ExprKernel_h_reg =
     registerHeader(velox_experimental_wave_exec_ExprKernel_h);
@@ -1463,7 +1457,7 @@ const char* velox_experimental_wave_exec_Join_cuh =
     "#include \"velox/experimental/wave/exec/WaveCore.cuh\"\n"
     "\n"
     "namespace facebook::velox::wave {\n"
-    "  \n"
+    "\n"
     "inline __device__ JoinShared* joinShared(WaveShared* shared) {\n"
     "  return reinterpret_cast<JoinShared*>(&shared->data);\n"
     "}\n"
@@ -1485,8 +1479,8 @@ const char* velox_experimental_wave_exec_Join_cuh =
     "    int32_t indicesIdx,\n"
     "    int32_t gridstatusOffset,\n"
     "    int32_t gridStatusSize,\n"
-    "  int32_t blockStatusOffset,\n"
-    "  int32_t hitsIdx>\n"
+    "    int32_t blockStatusOffset,\n"
+    "    int32_t hitsIdx>\n"
     "bool __device__ __forceinline__ joinResult(\n"
     "    int64_t& hitAsInt,\n"
     "    bool filterResult,\n"
@@ -1494,7 +1488,8 @@ const char* velox_experimental_wave_exec_Join_cuh =
     "    ErrorCode laneStatus,\n"
     "    WaveShared* shared,\n"
     "    bool hasDuplicates) {\n"
-    "  RowType* hit = reinterpret_cast<RowType*>(laneStatus == ErrorCode::kOk ? hitAsInt : 0);\n"
+    "  RowType* hit =\n"
+    "      reinterpret_cast<RowType*>(laneStatus == ErrorCode::kOk ? hitAsInt : 0);\n"
     "  if (threadIdx.x == 0) {\n"
     "    auto* j = joinShared(shared);\n"
     "    if (hasDuplicates) {\n"
@@ -1537,17 +1532,19 @@ const char* velox_experimental_wave_exec_Join_cuh =
     "    uint32_t flags = __ballot_sync(0xffffffff, next != nullptr);\n"
     "    if ((threadIdx.x & 31) == 0) {\n"
     "      if (flags) {\n"
-    "	atomicOr(&joinShared(shared)->anyNext, flags);\n"
-    "	joinShared(shared)->gridStatus->anyContinuable = true;\n"
+    "        atomicOr(&joinShared(shared)->anyNext, flags);\n"
+    "        joinShared(shared)->gridStatus->anyContinuable = true;\n"
     "      }\n"
     "    }\n"
     "    __syncthreads();\n"
     "    if (threadIdx.x == 0) {\n"
-    "      shared->localContinue = shared->numRows < kBlockSize - 64 && joinShared(shared)->anyNext;\n"
+    "      shared->localContinue =\n"
+    "          shared->numRows < kBlockSize - 64 && joinShared(shared)->anyNext;\n"
     "    }\n"
     "    __syncthreads();\n"
-    "    // All threads return the same. true if there is space in the output and nexts to look at.\n"
-    "      return shared->localContinue;\n"
+    "    // All threads return the same. true if there is space in the output and\n"
+    "    // nexts to look at.\n"
+    "    return shared->localContinue;\n"
     "  }\n"
     "  // We come here when there are  places to fill above shared->numRows.\n"
     "  bool laneFull = false;\n"
@@ -1566,9 +1563,9 @@ const char* velox_experimental_wave_exec_Join_cuh =
     "  // Make sure joinShared is seen on all threads.\n"
     "  __syncthreads();\n"
     "  if (!laneFull && hit) {\n"
-    "      auto* next = *hit->nextPtr();\n"
-    "      joinShared(shared)->blockStatus->next[threadIdx.x] = next;\n"
-    "      hitAsInt = reinterpret_cast<int64_t>(next);\n"
+    "    auto* next = *hit->nextPtr();\n"
+    "    joinShared(shared)->blockStatus->next[threadIdx.x] = next;\n"
+    "    hitAsInt = reinterpret_cast<int64_t>(next);\n"
     "  }\n"
     "\n"
     "  if (threadIdx.x == 0 && shared->numRows > kBlockSize) {\n"
@@ -1584,23 +1581,24 @@ const char* velox_experimental_wave_exec_Join_cuh =
     "  }\n"
     "  __syncthreads();\n"
     "  if (threadIdx.x == 0) {\n"
-    "    if(joinShared(shared)->anyNext) {\n"
+    "    if (joinShared(shared)->anyNext) {\n"
     "      joinShared(shared)->gridStatus->anyContinuable = 1;\n"
     "    }\n"
-    "    shared->localContinue = shared->numRows < kBlockSize - 32 && joinShared(shared)->anyNext;\n"
+    "    shared->localContinue =\n"
+    "        shared->numRows < kBlockSize - 32 && joinShared(shared)->anyNext;\n"
     "  }\n"
     "  __syncthreads();\n"
     "  return shared->localContinue;\n"
     "}\n"
     "\n"
-    "  template <typename RowType, int32_t hitsIdx, typename CopyRow>\n"
-    "void __device__ __forceinline__ joinRow(\n"
-    "    ErrorCode laneStatus,\n"
-    "    WaveShared* shared,\n"
-    "    CopyRow copy) {\n"
-    "    if (laneStatus == ErrorCode::kOk) {\n"
-    "      RowType** hits = reinterpret_cast<RowType**>(shared->operands[hitsIdx]->base);\n"
-    "      copy(hits[shared->blockBase + threadIdx.x], shared->blockBase + threadIdx.x);\n"
+    "template <typename RowType, int32_t hitsIdx, typename CopyRow>\n"
+    "void __device__ __forceinline__\n"
+    "joinRow(ErrorCode laneStatus, WaveShared* shared, CopyRow copy) {\n"
+    "  if (laneStatus == ErrorCode::kOk) {\n"
+    "    RowType** hits =\n"
+    "        reinterpret_cast<RowType**>(shared->operands[hitsIdx]->base);\n"
+    "    copy(\n"
+    "        hits[shared->blockBase + threadIdx.x], shared->blockBase + threadIdx.x);\n"
     "  }\n"
     "}\n"
     "\n"
@@ -2090,27 +2088,27 @@ const char* velox_experimental_wave_common_HashTable_cuh =
     "\n"
     "  template <typename RowType, typename Compare>\n"
     "  RowType* __device__ joinProbe(uint64_t h, Compare compare) {\n"
-    "      uint32_t tagWord = hashTag(h);\n"
-    "      tagWord |= tagWord << 8;\n"
-    "      tagWord = tagWord | tagWord << 16;\n"
-    "      auto bucketIdx = h & sizeMask;\n"
-    "      for (;;) {\n"
-    "        GpuBucket* bucket = buckets + bucketIdx;\n"
-    "        auto tags = bucket->tags;\n"
-    "        auto hits = __vcmpeq4(tags, tagWord) & 0x01010101;\n"
-    "        while (hits) {\n"
-    "          auto hitIdx = (__ffs(hits) - 1) / 8;\n"
-    "          auto* hit = bucket->load<RowType>(hitIdx);\n"
-    "          if (compare(hit)) {\n"
-    "            return hit;\n"
-    "          }\n"
-    "          hits = hits & (hits - 1);\n"
-    "        }\n"
-    "        if (__vcmpeq4(tags, 0)) {\n"
-    "          return nullptr;\n"
+    "    uint32_t tagWord = hashTag(h);\n"
+    "    tagWord |= tagWord << 8;\n"
+    "    tagWord = tagWord | tagWord << 16;\n"
+    "    auto bucketIdx = h & sizeMask;\n"
+    "    for (;;) {\n"
+    "      GpuBucket* bucket = buckets + bucketIdx;\n"
+    "      auto tags = bucket->tags;\n"
+    "      auto hits = __vcmpeq4(tags, tagWord) & 0x01010101;\n"
+    "      while (hits) {\n"
+    "        auto hitIdx = (__ffs(hits) - 1) / 8;\n"
+    "        auto* hit = bucket->load<RowType>(hitIdx);\n"
+    "        if (compare(hit)) {\n"
+    "          return hit;\n"
     "        }\n"
-    "        bucketIdx = (bucketIdx + 1) & sizeMask;\n"
+    "        hits = hits & (hits - 1);\n"
     "      }\n"
+    "      if (__vcmpeq4(tags, 0)) {\n"
+    "        return nullptr;\n"
+    "      }\n"
+    "      bucketIdx = (bucketIdx + 1) & sizeMask;\n"
+    "    }\n"
     "  }\n"
     "\n"
     "  template <typename RowType, typename Init>\n"
@@ -2295,7 +2293,7 @@ const char* velox_experimental_wave_common_HashTable_cuh =
     "  template <typename RowType, typename Ops>\n"
     "  void __device__\n"
     "  rehash(GpuBucket* oldBuckets, int32_t numOldBuckets, Ops ops) {\n"
-    "    int32_t stride = blockDim.x * gridDim.x;\n"
+    "    auto stride = blockDim.x * gridDim.x;\n"
     "    for (auto idx = threadIdx.x + blockDim.x * blockIdx.x; idx < numOldBuckets;\n"
     "         idx += stride) {\n"
     "      for (auto slot = 0; slot < GpuBucketMembers::kNumSlots; ++slot) {\n"
@@ -2331,8 +2329,7 @@ const char* velox_experimental_wave_common_HashTable_cuh =
     "  }\n"
     "\n"
     "  template <typename RowType, typename Ops>\n"
-    "  void __device__\n"
-    "  joinBuild(RowType* rows, int32_t numRows, Ops ops) {\n"
+    "  void __device__ joinBuild(RowType* rows, int32_t numRows, Ops ops) {\n"
     "    auto stride = blockDim.x * gridDim.x;\n"
     "    for (auto idx = threadIdx.x + blockDim.x * blockIdx.x; idx < numRows;\n"
     "         idx += stride) {\n"
@@ -2344,43 +2341,48 @@ const char* velox_experimental_wave_common_HashTable_cuh =
     "      tagWord = tagWord | tagWord << 16;\n"
     "\n"
     "      for (;;) {\n"
-    "	GpuBucket* bucket = buckets + bucketIdx;\n"
+    "        GpuBucket* bucket = buckets + bucketIdx;\n"
     "      reprobe:\n"
-    "	uint32_t tags = asDeviceAtomic<uint32_t>(&bucket->tags)\n"
-    "	  ->load(cuda::memory_order_consume);\n"
-    "	auto hits = __vcmpeq4(tags, tagWord) & 0x01010101;\n"
-    "	while (hits) {\n"
-    "	  auto hitIdx = (__ffs(hits) - 1) / 8;\n"
-    "	  auto candidate = bucket->loadWithWait<RowType>(hitIdx);\n"
-    "	  if (ops.compare(row, candidate)) {\n"
-    "	    for (;;) {\n"
-    "	      auto previous = asDeviceAtomic<RowType*>(candidate->nextPtr())->load(cuda::memory_order_relaxed);\n"
-    "		if ((unsigned long long)previous == atomicCAS((unsigned long long*)&candidate->next, (unsigned long long)previous, (unsigned long long)row)) {\n"
-    "		  *row->nextPtr() = previous;\n"
-    "		  // Set duplicates flag, no need to set if already set.\n"
-    "		  atomicCAS(&hasDuplicates, 0, 1);\n"
-    "		  goto next;\n"
-    "		}\n"
-    "	    }\n"
-    "	  }\n"
-    "	  hits &= hits - 1;\n"
-    "	}\n"
-    "	auto misses = __vcmpeq4(tags, 0) & 0x01010101;\n"
-    "	if (misses) {\n"
-    "	  auto missShift = __ffs(misses) - 1;\n"
-    "	  if (!bucket->addNewTag(tagWord, tags, missShift)) {\n"
-    "	    goto reprobe;\n"
-    "	  }\n"
-    "	  bucket->store(missShift / 8, row);\n"
-    "	  goto next;\n"
-    "	}\n"
-    "	\n"
-    "	bucketIdx = (bucketIdx + 1) & sizeMask;\n"
+    "        uint32_t tags = asDeviceAtomic<uint32_t>(&bucket->tags)\n"
+    "                            ->load(cuda::memory_order_consume);\n"
+    "        auto hits = __vcmpeq4(tags, tagWord) & 0x01010101;\n"
+    "        while (hits) {\n"
+    "          auto hitIdx = (__ffs(hits) - 1) / 8;\n"
+    "          auto candidate = bucket->loadWithWait<RowType>(hitIdx);\n"
+    "          if (ops.compare(row, candidate)) {\n"
+    "            for (;;) {\n"
+    "              auto previous = asDeviceAtomic<RowType*>(candidate->nextPtr())\n"
+    "                                  ->load(cuda::memory_order_relaxed);\n"
+    "              if ((unsigned long long)previous ==\n"
+    "                  atomicCAS(\n"
+    "                      (unsigned long long*)&candidate->next,\n"
+    "                      (unsigned long long)previous,\n"
+    "                      (unsigned long long)row)) {\n"
+    "                *row->nextPtr() = previous;\n"
+    "                // Set duplicates flag, no need to set if already set.\n"
+    "                atomicCAS(&hasDuplicates, 0, 1);\n"
+    "                goto next;\n"
+    "              }\n"
+    "            }\n"
+    "          }\n"
+    "          hits &= hits - 1;\n"
+    "        }\n"
+    "        auto misses = __vcmpeq4(tags, 0) & 0x01010101;\n"
+    "        if (misses) {\n"
+    "          auto missShift = __ffs(misses) - 1;\n"
+    "          if (!bucket->addNewTag(tagWord, tags, missShift)) {\n"
+    "            goto reprobe;\n"
+    "          }\n"
+    "          bucket->store(missShift / 8, row);\n"
+    "          goto next;\n"
+    "        }\n"
+    "\n"
+    "        bucketIdx = (bucketIdx + 1) & sizeMask;\n"
     "      }\n"
     "    next:;\n"
     "    }\n"
     "    __syncthreads();\n"
-    "}\n"
+    "  }\n"
     "\n"
     "  int32_t __device__ partitionIdx(uint64_t h) const {\n"
     "    return partitionMask == 0 ? 0 : (h >> 41) & partitionMask;\n"
@@ -2723,4 +2725,1509 @@ const char* velox_experimental_wave_common_CompilerDefines_h =
     "#endif\n";
 bool velox_experimental_wave_common_CompilerDefines_h_reg =
     registerHeader(velox_experimental_wave_common_CompilerDefines_h);
+const char* velox_experimental_wave_common_Atomic_cuh =
+    "velox/experimental/wave/common/Atomic.cuh\n"
+    "/*\n"
+    " * Copyright (c) Facebook, Inc. and its affiliates.\n"
+    " *\n"
+    " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+    " * you may not use this file except in compliance with the License.\n"
+    " * You may obtain a copy of the License at\n"
+    " *\n"
+    " *     http://www.apache.org/licenses/LICENSE-2.0\n"
+    " *\n"
+    " * Unless required by applicable law or agreed to in writing, software\n"
+    " * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+    " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+    " * See the License for the specific language governing permissions and\n"
+    " * limitations under the License.\n"
+    " */\n"
+    "\n"
+    "#pragma once\n"
+    "\n"
+    "#include <breeze/platforms/platform.h>\n"
+    "#include <breeze/utils/types.h>\n"
+    "#include <breeze/platforms/cuda.cuh>\n"
+    "#include \"velox/experimental/wave/common/BitUtil.cuh\"\n"
+    "#include \"velox/experimental/wave/common/CompilerDefines.h\"\n"
+    "\n"
+    "namespace facebook::velox::wave {\n"
+    "\n"
+    "enum class MemoryScope { kDevice };\n"
+    "\n"
+    "enum class MemoryOrder {\n"
+    "  kRelaxed,\n"
+    "  kAcquire,\n"
+    "  kRelease,\n"
+    "};\n"
+    "\n"
+    "template <MemoryScope>\n"
+    "struct MemoryScopeTraits;\n"
+    "\n"
+    "template <>\n"
+    "struct MemoryScopeTraits<MemoryScope::kDevice> {\n"
+    "  WAVE_DEVICE_HOST static constexpr breeze::utils::AddressSpace\n"
+    "  breezeAddressSpace() {\n"
+    "    return breeze::utils::GLOBAL;\n"
+    "  }\n"
+    "};\n"
+    "\n"
+    "template <MemoryOrder>\n"
+    "struct MemoryOrderTraits;\n"
+    "\n"
+    "template <>\n"
+    "struct MemoryOrderTraits<MemoryOrder::kRelaxed> {\n"
+    "  WAVE_DEVICE_HOST static constexpr breeze::utils::MemoryOrder breezeType() {\n"
+    "    return breeze::utils::RELAXED;\n"
+    "  }\n"
+    "};\n"
+    "\n"
+    "template <>\n"
+    "struct MemoryOrderTraits<MemoryOrder::kAcquire> {\n"
+    "  WAVE_DEVICE_HOST static constexpr breeze::utils::MemoryOrder breezeType() {\n"
+    "    return breeze::utils::ACQUIRE;\n"
+    "  }\n"
+    "};\n"
+    "\n"
+    "template <>\n"
+    "struct MemoryOrderTraits<MemoryOrder::kRelease> {\n"
+    "  WAVE_DEVICE_HOST static constexpr breeze::utils::MemoryOrder breezeType() {\n"
+    "    return breeze::utils::RELEASE;\n"
+    "  }\n"
+    "};\n"
+    "\n"
+    "template <typename T, MemoryScope Scope = MemoryScope::kDevice>\n"
+    "struct Atomic {\n"
+    " private:\n"
+    "  // Note: We currently do not require usage of this class to specify\n"
+    "  // kBlockThreads as that is not technically used by the CUDA platform\n"
+    "  // implementation of the atomics in breeze and is non-trivial for\n"
+    "  // existing usage of atomics to provide. We might want to change that\n"
+    "  // in the future to remove that assumption.\n"
+    "  using PlatformT = CudaPlatform</*kBlockThreads=*/kWarpThreads, kWarpThreads>;\n"
+    "\n"
+    "  T value_;\n"
+    "\n"
+    " public:\n"
+    "  Atomic(const Atomic&) = delete;\n"
+    "  Atomic& operator=(const Atomic&) = delete;\n"
+    "  Atomic& operator=(const Atomic&) volatile = delete;\n"
+    "\n"
+    "  WAVE_DEVICE_HOST explicit constexpr Atomic() noexcept = default;\n"
+    "  WAVE_DEVICE_HOST constexpr explicit inline Atomic(T value) noexcept\n"
+    "      : value_(value) {}\n"
+    "\n"
+    "  template <MemoryOrder Order = MemoryOrder::kRelaxed>\n"
+    "  WAVE_DEVICE_HOST T load() noexcept {\n"
+    "    using namespace breeze::utils;\n"
+    "    return PlatformT().atomic_load<MemoryOrderTraits<Order>::breezeType()>(\n"
+    "        make_slice<MemoryScopeTraits<Scope>::breezeAddressSpace()>(&value_));\n"
+    "  }\n"
+    "\n"
+    "  template <MemoryOrder Order = MemoryOrder::kRelaxed>\n"
+    "  WAVE_DEVICE_HOST void store(T value) noexcept {\n"
+    "    using namespace breeze::utils;\n"
+    "    PlatformT().atomic_store<MemoryOrderTraits<Order>::breezeType()>(\n"
+    "        make_slice<MemoryScopeTraits<Scope>::breezeAddressSpace()>(&value_),\n"
+    "        value);\n"
+    "  }\n"
+    "\n"
+    "  template <MemoryOrder Order = MemoryOrder::kRelaxed>\n"
+    "  WAVE_DEVICE_HOST bool compare_exchange(T& expected, T desired) noexcept {\n"
+    "    using namespace breeze::utils;\n"
+    "    T actual = PlatformT().atomic_cas<MemoryOrderTraits<Order>::breezeType()>(\n"
+    "        make_slice<MemoryScopeTraits<Scope>::breezeAddressSpace()>(&value_),\n"
+    "        expected,\n"
+    "        desired);\n"
+    "    bool was_changed = actual == expected;\n"
+    "    expected = actual;\n"
+    "    return was_changed;\n"
+    "  }\n"
+    "};\n"
+    "\n"
+    "template <MemoryScope Scope = MemoryScope::kDevice>\n"
+    "struct AtomicMutex {\n"
+    " private:\n"
+    "  Atomic<int, Scope> value_;\n"
+    "\n"
+    " public:\n"
+    "  AtomicMutex(const AtomicMutex&) = delete;\n"
+    "  AtomicMutex& operator=(const AtomicMutex&) = delete;\n"
+    "  AtomicMutex& operator=(const AtomicMutex&) volatile = delete;\n"
+    "\n"
+    "  WAVE_DEVICE_HOST explicit constexpr AtomicMutex() noexcept = default;\n"
+    "  WAVE_DEVICE_HOST constexpr explicit inline AtomicMutex(int value) noexcept\n"
+    "      : value_(value) {}\n"
+    "\n"
+    "  WAVE_DEVICE_HOST void acquire() {\n"
+    "    constexpr int kPollingCount = 5;\n"
+    "    constexpr int kInitialBackoffStepNs = 10;\n"
+    "\n"
+    "    int count = 0;\n"
+    "    auto step_ns = kInitialBackoffStepNs + threadIdx.x % 32;\n"
+    "    for (;;) {\n"
+    "      int available = value_.template load<MemoryOrder::kAcquire>();\n"
+    "      while (available) {\n"
+    "        if (value_.template compare_exchange<MemoryOrder::kAcquire>(\n"
+    "                available, 0)) {\n"
+    "          return;\n"
+    "        }\n"
+    "      }\n"
+    "      if (count < kPollingCount) {\n"
+    "        count += 1;\n"
+    "        continue;\n"
+    "      }\n"
+    "#if defined(__CUDA_ARCH__)\n"
+    "      __nanosleep(step_ns);\n"
+    "      step_ns *= 2;\n"
+    "#endif\n"
+    "    }\n"
+    "  }\n"
+    "\n"
+    "  WAVE_DEVICE_HOST void release() {\n"
+    "    value_.template store<MemoryOrder::kRelease>(1);\n"
+    "  }\n"
+    "};\n"
+    "\n"
+    "} // namespace facebook::velox::wave\n";
+bool velox_experimental_wave_common_Atomic_cuh_reg =
+    registerHeader(velox_experimental_wave_common_Atomic_cuh);
+const char* breeze_platforms_cuda_cuh =
+    "breeze/platforms/cuda.cuh\n"
+    "/*\n"
+    " * Copyright (c) Facebook, Inc. and its affiliates.\n"
+    " *\n"
+    " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+    " * you may not use this file except in compliance with the License.\n"
+    " * You may obtain a copy of the License at\n"
+    " *\n"
+    " *     http://www.apache.org/licenses/LICENSE-2.0\n"
+    " *\n"
+    " * Unless required by applicable law or agreed to in writing, software\n"
+    " * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+    " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+    " * See the License for the specific language governing permissions and\n"
+    " * limitations under the License.\n"
+    " */\n"
+    "\n"
+    "/*\n"
+    " * Copyright (c) 2024 by Rivos Inc.\n"
+    " * Licensed under the Apache License, Version 2.0, see LICENSE for details.\n"
+    " * SPDX-License-Identifier: Apache-2.0\n"
+    " */\n"
+    "\n"
+    "#pragma once\n"
+    "\n"
+    "#include <cuda_runtime_api.h>\n"
+    "\n"
+    "#include \"breeze/utils/types.h\"\n"
+    "\n"
+    "#if defined(__CUDA_ARCH__)\n"
+    "#if __CUDA_ARCH__ < 500\n"
+    "#error \"Unsupported CUDA architecture\"\n"
+    "#endif\n"
+    "#endif\n"
+    "\n"
+    "struct CudaSpecialization {\n"
+    "  template <int WARP_THREADS>\n"
+    "  static __device__ __forceinline__ int lane_idx();\n"
+    "  template <int WARP_THREADS>\n"
+    "  static __device__ __forceinline__ int warp_idx();\n"
+    "  template <int WARP_THREADS>\n"
+    "  static __device__ __forceinline__ unsigned lower_rank_lanemask();\n"
+    "  template <int WARP_THREADS>\n"
+    "  static __device__ __forceinline__ unsigned higher_rank_lanemask();\n"
+    "  static __device__ __forceinline__ void reconvergence_hint() {\n"
+    "    // Use full warp syncs as hint to encourage reconvergence by default.\n"
+    "    __syncwarp();\n"
+    "  }\n"
+    "  template <breeze::utils::MemoryOrder MEMORY_ORDER = breeze::utils::RELAXED,\n"
+    "            typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  static __device__ __forceinline__ T atomic_load(SliceT address) {\n"
+    "    static_assert(MEMORY_ORDER != breeze::utils::RELEASE,\n"
+    "                  \"RELEASE is not a valid memory order for atomic_load\");\n"
+    "    T value;\n"
+    "    if constexpr (SliceT::ADDRESS_SPACE == breeze::utils::GLOBAL) {\n"
+    "      value = __ldcg(address.data());  // cache only globally\n"
+    "    } else {\n"
+    "      value = *address.data();\n"
+    "    }\n"
+    "    if constexpr (MEMORY_ORDER == breeze::utils::ACQUIRE) {\n"
+    "      __threadfence();\n"
+    "    }\n"
+    "    return value;\n"
+    "  }\n"
+    "  template <breeze::utils::MemoryOrder MEMORY_ORDER = breeze::utils::RELAXED,\n"
+    "            typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  static __device__ __forceinline__ void atomic_store(SliceT address, T value) {\n"
+    "    static_assert(MEMORY_ORDER != breeze::utils::ACQUIRE,\n"
+    "                  \"ACQUIRE is not a valid memory order for atomic_store\");\n"
+    "    if constexpr (MEMORY_ORDER == breeze::utils::RELEASE) {\n"
+    "      __threadfence();\n"
+    "    }\n"
+    "    if constexpr (SliceT::ADDRESS_SPACE == breeze::utils::GLOBAL) {\n"
+    "      __stcg(address.data(), value);  // cache only globally\n"
+    "    } else {\n"
+    "      *address.data() = value;\n"
+    "    }\n"
+    "  }\n"
+    "  template <breeze::utils::MemoryOrder MEMORY_ORDER = breeze::utils::RELAXED,\n"
+    "            typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  static __device__ __forceinline__ T atomic_cas(SliceT address, T compare,\n"
+    "                                                 T value) {\n"
+    "    if constexpr (MEMORY_ORDER == breeze::utils::RELEASE) {\n"
+    "      __threadfence();\n"
+    "    }\n"
+    "    T old = atomicCAS(address.data(), compare, value);\n"
+    "    if constexpr (MEMORY_ORDER == breeze::utils::ACQUIRE) {\n"
+    "      __threadfence();\n"
+    "    }\n"
+    "    return old;\n"
+    "  }\n"
+    "  template <typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  static __device__ __forceinline__ T atomic_add(SliceT address, T value) {\n"
+    "    return atomicAdd(address.data(), value);\n"
+    "  }\n"
+    "  template <typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  static __device__ __forceinline__ void atomic_min(SliceT address, T value) {\n"
+    "    atomicMin(address.data(), value);\n"
+    "  }\n"
+    "  template <typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  static __device__ __forceinline__ void atomic_max(SliceT address, T value) {\n"
+    "    atomicMax(address.data(), value);\n"
+    "  }\n"
+    "  template <int WARP_THREADS, typename T>\n"
+    "  static __device__ __forceinline__ T reduce_add(T value) {\n"
+    "#pragma unroll\n"
+    "    for (int offset = WARP_THREADS / 2; offset > 0; offset /= 2) {\n"
+    "      value += __shfl_xor_sync(0xffffffff, value, offset);\n"
+    "    }\n"
+    "    return value;\n"
+    "  }\n"
+    "  template <int WARP_THREADS, typename T>\n"
+    "  static __device__ __forceinline__ T reduce_min(T value) {\n"
+    "#pragma unroll\n"
+    "    for (int offset = WARP_THREADS / 2; offset > 0; offset /= 2) {\n"
+    "      value = ::min(value, __shfl_xor_sync(0xffffffff, value, offset));\n"
+    "    }\n"
+    "    return value;\n"
+    "  }\n"
+    "  template <int WARP_THREADS, typename T>\n"
+    "  static __device__ __forceinline__ T reduce_max(T value) {\n"
+    "#pragma unroll\n"
+    "    for (int offset = WARP_THREADS / 2; offset > 0; offset /= 2) {\n"
+    "      value = ::max(value, __shfl_xor_sync(0xffffffff, value, offset));\n"
+    "    }\n"
+    "    return value;\n"
+    "  }\n"
+    "  template <int WARP_THREADS, typename T>\n"
+    "  static __device__ __forceinline__ T scan_add(T value) {\n"
+    "#pragma unroll\n"
+    "    for (int offset = 1; offset < WARP_THREADS; offset <<= 1) {\n"
+    "      T result = __shfl_up_sync(0xffffffff, value, offset);\n"
+    "      if ((threadIdx.x % WARP_THREADS) >= offset) {\n"
+    "        value += result;\n"
+    "      }\n"
+    "    }\n"
+    "    return value;\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  static __device__ __forceinline__ int count_leading_zeros(T value);\n"
+    "  template <typename T>\n"
+    "  static __device__ __forceinline__ int population_count(T value);\n"
+    "  template <typename T>\n"
+    "  static __device__ __forceinline__ T extract_bits(T value, int start_bit,\n"
+    "                                                   int num_bits);\n"
+    "  template <bool HIGH_PRIORITY>\n"
+    "  static __device__ __forceinline__ void scheduling_hint() {}\n"
+    "  template <typename SliceT>\n"
+    "  static __device__ __forceinline__ void prefetch(SliceT) {}\n"
+    "};\n"
+    "\n"
+    "template <int CUDA_BLOCK_THREADS, int CUDA_WARP_THREADS>\n"
+    "struct CudaPlatform {\n"
+    "  enum {\n"
+    "    BLOCK_THREADS = CUDA_BLOCK_THREADS,\n"
+    "    WARP_THREADS = CUDA_WARP_THREADS,\n"
+    "  };\n"
+    "  __device__ __forceinline__ int thread_idx() { return threadIdx.x; }\n"
+    "  __device__ __forceinline__ int block_idx() { return blockIdx.x; }\n"
+    "  __device__ __forceinline__ void syncthreads() { __syncthreads(); }\n"
+    "  __device__ __forceinline__ void syncwarp() { __syncwarp(); }\n"
+    "  __device__ __forceinline__ int lane_idx() {\n"
+    "    return CudaSpecialization::template lane_idx<WARP_THREADS>();\n"
+    "  }\n"
+    "  __device__ __forceinline__ int warp_idx() {\n"
+    "    return CudaSpecialization::template warp_idx<WARP_THREADS>();\n"
+    "  }\n"
+    "  __device__ __forceinline__ unsigned lower_rank_lanemask() {\n"
+    "    return CudaSpecialization::template lower_rank_lanemask<WARP_THREADS>();\n"
+    "  }\n"
+    "  __device__ __forceinline__ unsigned higher_rank_lanemask() {\n"
+    "    return CudaSpecialization::template higher_rank_lanemask<WARP_THREADS>();\n"
+    "  }\n"
+    "  __device__ __forceinline__ void reconvergence_hint() {\n"
+    "    CudaSpecialization::reconvergence_hint();\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ T min(T lhs, T rhs) {\n"
+    "    return ::min(lhs, rhs);\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ T max(T lhs, T rhs) {\n"
+    "    return ::max(lhs, rhs);\n"
+    "  }\n"
+    "  template <breeze::utils::MemoryOrder MEMORY_ORDER = breeze::utils::RELAXED,\n"
+    "            typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  __device__ __forceinline__ T atomic_load(SliceT address) {\n"
+    "    return CudaSpecialization::atomic_load<MEMORY_ORDER>(address);\n"
+    "  }\n"
+    "  template <breeze::utils::MemoryOrder MEMORY_ORDER = breeze::utils::RELAXED,\n"
+    "            typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  __device__ __forceinline__ void atomic_store(SliceT address, T value) {\n"
+    "    CudaSpecialization::atomic_store<MEMORY_ORDER>(address, value);\n"
+    "  }\n"
+    "  template <breeze::utils::MemoryOrder MEMORY_ORDER = breeze::utils::RELAXED,\n"
+    "            typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  __device__ __forceinline__ T atomic_cas(SliceT address, T compare, T value) {\n"
+    "    return CudaSpecialization::atomic_cas<MEMORY_ORDER>(address, compare,\n"
+    "                                                        value);\n"
+    "  }\n"
+    "  template <typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  __device__ __forceinline__ T atomic_add(SliceT address, T value) {\n"
+    "    return CudaSpecialization::atomic_add(address, value);\n"
+    "  }\n"
+    "  template <typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  __device__ __forceinline__ void atomic_min(SliceT address, T value) {\n"
+    "    CudaSpecialization::atomic_min(address, value);\n"
+    "  }\n"
+    "  template <typename SliceT, typename T = typename SliceT::data_type>\n"
+    "  __device__ __forceinline__ void atomic_max(SliceT address, T value) {\n"
+    "    CudaSpecialization::atomic_max(address, value);\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ T reduce_add(T value) {\n"
+    "    return CudaSpecialization::template reduce_add<WARP_THREADS, T>(value);\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ T reduce_min(T value) {\n"
+    "    return CudaSpecialization::template reduce_min<WARP_THREADS, T>(value);\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ T reduce_max(T value) {\n"
+    "    return CudaSpecialization::template reduce_max<WARP_THREADS, T>(value);\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ T scan_add(T value) {\n"
+    "    return CudaSpecialization::template scan_add<WARP_THREADS, T>(value);\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ T ballot(bool value) {\n"
+    "    return __ballot_sync(0xffffffff, value);\n"
+    "  }\n"
+    "  template <int MIN_BITS, typename T>\n"
+    "  __device__ __forceinline__ unsigned match_any(T value) {\n"
+    "#if __CUDA_ARCH__ >= 800\n"
+    "    return __match_any_sync(0xffffffff, value);\n"
+    "#else\n"
+    "    unsigned result;\n"
+    "#pragma unroll\n"
+    "    for (unsigned i = 0; i < MIN_BITS; ++i) {\n"
+    "      unsigned current_bit = 1 << i;\n"
+    "      bool pred = (value & current_bit) == current_bit;\n"
+    "      unsigned mask = __ballot_sync(0xffffffff, pred);\n"
+    "      if (!pred) {\n"
+    "        mask = ~mask;\n"
+    "      }\n"
+    "      result = (i == 0) ? mask : result & mask;\n"
+    "    }\n"
+    "    return result;\n"
+    "#endif\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ int count_leading_zeros(T value) {\n"
+    "    return CudaSpecialization::count_leading_zeros(value);\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ int population_count(T value) {\n"
+    "    return CudaSpecialization::population_count(value);\n"
+    "  }\n"
+    "  template <typename T>\n"
+    "  __device__ __forceinline__ T extract_bits(T value, int start_bit,\n"
+    "                                            int num_bits) {\n"
+    "    return CudaSpecialization::extract_bits(value, start_bit, num_bits);\n"
+    "  }\n"
+    "  template <bool HIGH_PRIORITY>\n"
+    "  __device__ __forceinline__ void scheduling_hint() {\n"
+    "    CudaSpecialization::scheduling_hint<HIGH_PRIORITY>();\n"
+    "  }\n"
+    "  template <typename SliceT>\n"
+    "  __device__ __forceinline__ void prefetch(SliceT address) {\n"
+    "    CudaSpecialization::prefetch(address);\n"
+    "  }\n"
+    "};\n"
+    "\n"
+    "#if CUDART_VERSION >= 12080 && __CUDA_ARCH__ >= 700\n"
+    "// specialization for MEMORY_ORDER=ACQUIRE, SliceT=Slice<GLOBAL, BLOCKED, int>\n"
+    "template <>\n"
+    "__device__ __forceinline__ int CudaSpecialization::atomic_load<\n"
+    "    breeze::utils::ACQUIRE,\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int>\n"
+    "        address) {\n"
+    "  return __nv_atomic_load_n(address.data(), __NV_ATOMIC_ACQUIRE,\n"
+    "                            __NV_THREAD_SCOPE_DEVICE);\n"
+    "}\n"
+    "\n"
+    "// specialization for MEMORY_ORDER=ACQUIRE, SliceT=Slice<GLOBAL, BLOCKED,\n"
+    "// unsigned>\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned CudaSpecialization::atomic_load<\n"
+    "    breeze::utils::ACQUIRE,\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         unsigned>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         unsigned>\n"
+    "        address) {\n"
+    "  return __nv_atomic_load_n(address.data(), __NV_ATOMIC_ACQUIRE,\n"
+    "                            __NV_THREAD_SCOPE_DEVICE);\n"
+    "}\n"
+    "\n"
+    "// specialization for MEMORY_ORDER=ACQUIRE, SliceT=Slice<GLOBAL, BLOCKED, int>\n"
+    "template <>\n"
+    "__device__ __forceinline__ void CudaSpecialization::atomic_store<\n"
+    "    breeze::utils::ACQUIRE,\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int>\n"
+    "        address,\n"
+    "    int value) {\n"
+    "  __nv_atomic_store_n(address.data(), value, __NV_ATOMIC_RELEASE,\n"
+    "                      __NV_THREAD_SCOPE_DEVICE);\n"
+    "}\n"
+    "\n"
+    "// specialization for MEMORY_ORDER=ACQUIRE, SliceT=Slice<GLOBAL, BLOCKED,\n"
+    "// unsigned>\n"
+    "template <>\n"
+    "__device__ __forceinline__ void CudaSpecialization::atomic_store<\n"
+    "    breeze::utils::ACQUIRE,\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         unsigned>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         unsigned>\n"
+    "        address,\n"
+    "    unsigned value) {\n"
+    "  __nv_atomic_store_n(address.data(), value, __NV_ATOMIC_RELEASE,\n"
+    "                      __NV_THREAD_SCOPE_DEVICE);\n"
+    "}\n"
+    "\n"
+    "// specialization for MEMORY_ORDER=ACQUIRE, SliceT=Slice<GLOBAL, BLOCKED,\n"
+    "// unsigned>\n"
+    "template <>\n"
+    "__device__ __forceinline__ int CudaSpecialization::atomic_cas<\n"
+    "    breeze::utils::ACQUIRE,\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, int>\n"
+    "        address,\n"
+    "    int compare, int value) {\n"
+    "  int expected = compare;\n"
+    "  __nv_atomic_compare_exchange_n(address.data(), &expected, value, false,\n"
+    "                                 __NV_ATOMIC_ACQUIRE, __NV_ATOMIC_ACQUIRE,\n"
+    "                                 __NV_THREAD_SCOPE_DEVICE);\n"
+    "  return expected;\n"
+    "}\n"
+    "\n"
+    "// specialization for MEMORY_ORDER=ACQUIRE, SliceT=Slice<GLOBAL, BLOCKED,\n"
+    "// unsigned>\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned CudaSpecialization::atomic_cas<\n"
+    "    breeze::utils::ACQUIRE,\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         unsigned>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         unsigned>\n"
+    "        address,\n"
+    "    unsigned compare, unsigned value) {\n"
+    "  unsigned expected = compare;\n"
+    "  __nv_atomic_compare_exchange_n(address.data(), &expected, value, false,\n"
+    "                                 __NV_ATOMIC_ACQUIRE, __NV_ATOMIC_ACQUIRE,\n"
+    "                                 __NV_THREAD_SCOPE_DEVICE);\n"
+    "  return expected;\n"
+    "}\n"
+    "#endif\n"
+    "\n"
+    "#if __CUDA_ARCH__ < 600\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, double>\n"
+    "template <>\n"
+    "__device__ __forceinline__ double\n"
+    "CudaSpecialization::atomic_add<breeze::utils::Slice<\n"
+    "    breeze::utils::GLOBAL, breeze::utils::BLOCKED, double>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, double>\n"
+    "        address,\n"
+    "    double value) {\n"
+    "  static_assert(sizeof(double) == sizeof(unsigned long long),\n"
+    "                \"unexpected type sizes\");\n"
+    "  unsigned long long old =\n"
+    "      *reinterpret_cast<unsigned long long *>(address.data());\n"
+    "  unsigned long long assumed;\n"
+    "  do {\n"
+    "    assumed = old;\n"
+    "    old = atomicCAS(\n"
+    "        reinterpret_cast<unsigned long long *>(address.data()), assumed,\n"
+    "        __double_as_longlong(value + __longlong_as_double(assumed)));\n"
+    "  } while (assumed != old);\n"
+    "\n"
+    "  return __longlong_as_double(old);\n"
+    "}\n"
+    "#endif\n"
+    "\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, long long>\n"
+    "template <>\n"
+    "__device__ __forceinline__ long long\n"
+    "CudaSpecialization::atomic_add<breeze::utils::Slice<\n"
+    "    breeze::utils::GLOBAL, breeze::utils::BLOCKED, long long>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         long long>\n"
+    "        address,\n"
+    "    long long value) {\n"
+    "  unsigned long long result =\n"
+    "      atomicAdd(reinterpret_cast<unsigned long long *>(address.data()),\n"
+    "                *reinterpret_cast<unsigned long long *>(&value));\n"
+    "  return *reinterpret_cast<long long *>(&result);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, float>\n"
+    "template <>\n"
+    "__device__ __forceinline__ void CudaSpecialization::atomic_min<\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, float>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, float>\n"
+    "        address,\n"
+    "    float value) {\n"
+    "  static_assert(sizeof(float) == sizeof(unsigned), \"unexpected type sizes\");\n"
+    "  float current = atomic_load(address);\n"
+    "  while (current > value) {\n"
+    "    unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),\n"
+    "                             *reinterpret_cast<unsigned *>(&current),\n"
+    "                             *reinterpret_cast<unsigned *>(&value));\n"
+    "    current = *reinterpret_cast<float *>(&old);\n"
+    "    if (current == value) {\n"
+    "      break;\n"
+    "    }\n"
+    "  }\n"
+    "}\n"
+    "\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, float>\n"
+    "template <>\n"
+    "__device__ __forceinline__ void CudaSpecialization::atomic_max<\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, float>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, float>\n"
+    "        address,\n"
+    "    float value) {\n"
+    "  static_assert(sizeof(float) == sizeof(unsigned), \"unexpected type sizes\");\n"
+    "  float current = atomic_load(address);\n"
+    "  while (current < value) {\n"
+    "    unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),\n"
+    "                             *reinterpret_cast<unsigned *>(&current),\n"
+    "                             *reinterpret_cast<unsigned *>(&value));\n"
+    "    current = *reinterpret_cast<float *>(&old);\n"
+    "    if (current == value) {\n"
+    "      break;\n"
+    "    }\n"
+    "  }\n"
+    "}\n"
+    "\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, double>\n"
+    "template <>\n"
+    "__device__ __forceinline__ void\n"
+    "CudaSpecialization::atomic_min<breeze::utils::Slice<\n"
+    "    breeze::utils::GLOBAL, breeze::utils::BLOCKED, double>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, double>\n"
+    "        address,\n"
+    "    double value) {\n"
+    "  static_assert(sizeof(double) == sizeof(unsigned long long),\n"
+    "                \"unexpected type sizes\");\n"
+    "  double current = atomic_load(address);\n"
+    "  while (current > value) {\n"
+    "    unsigned long long old =\n"
+    "        atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),\n"
+    "                  *reinterpret_cast<unsigned long long *>(&current),\n"
+    "                  *reinterpret_cast<unsigned long long *>(&value));\n"
+    "    current = *reinterpret_cast<double *>(&old);\n"
+    "    if (current == value) {\n"
+    "      break;\n"
+    "    }\n"
+    "  }\n"
+    "}\n"
+    "\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, double>\n"
+    "template <>\n"
+    "__device__ __forceinline__ void\n"
+    "CudaSpecialization::atomic_max<breeze::utils::Slice<\n"
+    "    breeze::utils::GLOBAL, breeze::utils::BLOCKED, double>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, double>\n"
+    "        address,\n"
+    "    double value) {\n"
+    "  static_assert(sizeof(double) == sizeof(unsigned long long),\n"
+    "                \"unexpected type sizes\");\n"
+    "  double current = atomic_load(address);\n"
+    "  while (current < value) {\n"
+    "    unsigned long long old =\n"
+    "        atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),\n"
+    "                  *reinterpret_cast<unsigned long long *>(&current),\n"
+    "                  *reinterpret_cast<unsigned long long *>(&value));\n"
+    "    current = *reinterpret_cast<double *>(&old);\n"
+    "    if (current == value) {\n"
+    "      break;\n"
+    "    }\n"
+    "  }\n"
+    "}\n"
+    "\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, long long>\n"
+    "template <>\n"
+    "__device__ __forceinline__ long long CudaSpecialization::atomic_cas<\n"
+    "    breeze::utils::RELAXED,\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         long long>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         long long>\n"
+    "        address,\n"
+    "    long long compare, long long value) {\n"
+    "  unsigned long long old =\n"
+    "      atomicCAS(reinterpret_cast<unsigned long long *>(address.data()),\n"
+    "                *reinterpret_cast<unsigned long long *>(&compare),\n"
+    "                *reinterpret_cast<unsigned long long *>(&value));\n"
+    "  return *reinterpret_cast<long long *>(&old);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=Slice<SHARED, BLOCKED, long long>\n"
+    "template <>\n"
+    "__device__ __forceinline__ long long CudaSpecialization::atomic_cas<\n"
+    "    breeze::utils::RELAXED,\n"
+    "    breeze::utils::Slice<breeze::utils::SHARED, breeze::utils::BLOCKED,\n"
+    "                         long long>>(\n"
+    "    breeze::utils::Slice<breeze::utils::SHARED, breeze::utils::BLOCKED,\n"
+    "                         long long>\n"
+    "        address,\n"
+    "    long long compare, long long value) {\n"
+    "  using pointer_type =\n"
+    "      typename breeze::utils::Slice<breeze::utils::SHARED,\n"
+    "                                    breeze::utils::BLOCKED,\n"
+    "                                    unsigned long long>::pointer_type;\n"
+    "  unsigned long long old =\n"
+    "      atomicCAS(reinterpret_cast<pointer_type>(address.data()),\n"
+    "                *reinterpret_cast<unsigned long long *>(&compare),\n"
+    "                *reinterpret_cast<unsigned long long *>(&value));\n"
+    "  return *reinterpret_cast<long long *>(&old);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, float>\n"
+    "template <>\n"
+    "__device__ __forceinline__ float CudaSpecialization::atomic_cas<\n"
+    "    breeze::utils::RELAXED,\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, float>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED, float>\n"
+    "        address,\n"
+    "    float compare, float value) {\n"
+    "  static_assert(sizeof(float) == sizeof(unsigned), \"unexpected type sizes\");\n"
+    "  unsigned old = atomicCAS(reinterpret_cast<unsigned *>(address.data()),\n"
+    "                           *reinterpret_cast<unsigned *>(&compare),\n"
+    "                           *reinterpret_cast<unsigned *>(&value));\n"
+    "  return *reinterpret_cast<float *>(&old);\n"
+    "}\n"
+    "\n"
+    "#if __CUDA_ARCH__ >= 800\n"
+    "// specialization for T=int\n"
+    "template <>\n"
+    "__device__ __forceinline__ int CudaSpecialization::reduce_add<32, int>(\n"
+    "    int value) {\n"
+    "  return __reduce_add_sync(0xffffffff, value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned\n"
+    "CudaSpecialization::reduce_add<32, unsigned>(unsigned value) {\n"
+    "  return __reduce_add_sync(0xffffffff, value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned long long\n"
+    "CudaSpecialization::reduce_add<32, unsigned long long>(\n"
+    "    unsigned long long value) {\n"
+    "  unsigned low =\n"
+    "      __reduce_add_sync(0xffffffff, static_cast<unsigned>(value & 0xffffff));\n"
+    "  unsigned mid = __reduce_add_sync(\n"
+    "      0xffffffff, static_cast<unsigned>((value >> 24) & 0xffffff));\n"
+    "  unsigned high =\n"
+    "      __reduce_add_sync(0xffffffff, static_cast<unsigned>(value >> 48));\n"
+    "  return low + (static_cast<unsigned long long>(mid) << 24) +\n"
+    "         (static_cast<unsigned long long>(high) << 48);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ long long\n"
+    "CudaSpecialization::reduce_add<32, long long>(long long value) {\n"
+    "  return reduce_add<32, unsigned long long>(value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=int\n"
+    "template <>\n"
+    "__device__ __forceinline__ int CudaSpecialization::reduce_min<32, int>(\n"
+    "    int value) {\n"
+    "  return __reduce_min_sync(0xffffffff, value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned\n"
+    "CudaSpecialization::reduce_min<32, unsigned>(unsigned value) {\n"
+    "  return __reduce_min_sync(0xffffffff, value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ long long\n"
+    "CudaSpecialization::reduce_min<32, long long>(long long value) {\n"
+    "  int high = __reduce_min_sync(0xffffffff, static_cast<int>(value >> 32));\n"
+    "  bool match_high = high == static_cast<int>(value >> 32);\n"
+    "  // force threads that lost the first reduction to lose the second reduction\n"
+    "  unsigned sel_low =\n"
+    "      match_high ? static_cast<unsigned>(value & 0xffffffff) : ~0u;\n"
+    "  unsigned low = __reduce_min_sync(0xffffffff, sel_low);\n"
+    "  return low + (static_cast<long long>(high) << 32);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned long long\n"
+    "CudaSpecialization::reduce_min<32, unsigned long long>(\n"
+    "    unsigned long long value) {\n"
+    "  unsigned high =\n"
+    "      __reduce_min_sync(0xffffffff, static_cast<unsigned>(value >> 32));\n"
+    "  bool match_high = high == static_cast<unsigned>(value >> 32);\n"
+    "  // force threads that lost the first reduction to lose the second reduction\n"
+    "  unsigned sel_low =\n"
+    "      match_high ? static_cast<unsigned>(value & 0xffffffff) : ~0u;\n"
+    "  unsigned low = __reduce_min_sync(0xffffffff, sel_low);\n"
+    "  return low + (static_cast<unsigned long long>(high) << 32);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=int\n"
+    "template <>\n"
+    "__device__ __forceinline__ int CudaSpecialization::reduce_max<32, int>(\n"
+    "    int value) {\n"
+    "  return __reduce_max_sync(0xffffffff, value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned\n"
+    "CudaSpecialization::reduce_max<32, unsigned>(unsigned value) {\n"
+    "  return __reduce_max_sync(0xffffffff, value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ long long\n"
+    "CudaSpecialization::reduce_max<32, long long>(long long value) {\n"
+    "  int high = __reduce_max_sync(0xffffffff, static_cast<int>(value >> 32));\n"
+    "  bool match_high = high == static_cast<int>(value >> 32);\n"
+    "  // force threads that lost the first reduction to lose the second reduction\n"
+    "  unsigned sel_low =\n"
+    "      match_high ? static_cast<unsigned>(value & 0xffffffff) : 0u;\n"
+    "  unsigned low = __reduce_max_sync(0xffffffff, sel_low);\n"
+    "  return low + (static_cast<long long>(high) << 32);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned long long\n"
+    "CudaSpecialization::reduce_max<32, unsigned long long>(\n"
+    "    unsigned long long value) {\n"
+    "  unsigned high =\n"
+    "      __reduce_max_sync(0xffffffff, static_cast<unsigned>(value >> 32));\n"
+    "  bool match_high = high == static_cast<unsigned>(value >> 32);\n"
+    "  // force threads that lost the first reduction to lose the second reduction\n"
+    "  unsigned sel_low =\n"
+    "      match_high ? static_cast<unsigned>(value & 0xffffffff) : 0u;\n"
+    "  unsigned low = __reduce_max_sync(0xffffffff, sel_low);\n"
+    "  return low + (static_cast<unsigned long long>(high) << 32);\n"
+    "}\n"
+    "#endif  // __CUDA_ARCH__ >= 800\n"
+    "\n"
+    "// specialization for T=unsigned\n"
+    "template <>\n"
+    "__device__ __forceinline__ int\n"
+    "CudaSpecialization::count_leading_zeros<unsigned>(unsigned value) {\n"
+    "  return __clz(value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ int\n"
+    "CudaSpecialization::count_leading_zeros<unsigned long long>(\n"
+    "    unsigned long long value) {\n"
+    "  return __clzll(value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned\n"
+    "template <>\n"
+    "__device__ __forceinline__ int CudaSpecialization::population_count<unsigned>(\n"
+    "    unsigned value) {\n"
+    "  return __popc(value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ int\n"
+    "CudaSpecialization::population_count<unsigned long long>(\n"
+    "    unsigned long long value) {\n"
+    "  return __popcll(value);\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned long long\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned long long CudaSpecialization::extract_bits(\n"
+    "    unsigned long long value, int start_bit, int num_bits) {\n"
+    "  unsigned long long mask = (1llu << num_bits) - 1;\n"
+    "  return (value >> start_bit) & mask;\n"
+    "}\n"
+    "\n"
+    "#define Q(x) #x\n"
+    "#define QUOTE(x) Q(x)\n"
+    "#include QUOTE(CUDA_PLATFORM_SPECIALIZATION_HEADER)\n"
+    "#undef QUOTE\n"
+    "#undef Q\n";
+bool breeze_platforms_cuda_cuh_reg = registerHeader(breeze_platforms_cuda_cuh);
+const char* breeze_platforms_specialization_cuda_ptx_cuh =
+    "breeze/platforms/specialization/cuda-ptx.cuh\n"
+    "/*\n"
+    " * Copyright (c) Facebook, Inc. and its affiliates.\n"
+    " *\n"
+    " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+    " * you may not use this file except in compliance with the License.\n"
+    " * You may obtain a copy of the License at\n"
+    " *\n"
+    " *     http://www.apache.org/licenses/LICENSE-2.0\n"
+    " *\n"
+    " * Unless required by applicable law or agreed to in writing, software\n"
+    " * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+    " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+    " * See the License for the specific language governing permissions and\n"
+    " * limitations under the License.\n"
+    " */\n"
+    "\n"
+    "/*\n"
+    " * Copyright (c) 2024 by Rivos Inc.\n"
+    " * Licensed under the Apache License, Version 2.0, see LICENSE for details.\n"
+    " * SPDX-License-Identifier: Apache-2.0\n"
+    " */\n"
+    "\n"
+    "#pragma once\n"
+    "\n"
+    "template <int WARP_THREADS>\n"
+    "__device__ __forceinline__ int CudaSpecialization::lane_idx() {\n"
+    "  return threadIdx.x % WARP_THREADS;\n"
+    "}\n"
+    "\n"
+    "template <int WARP_THREADS>\n"
+    "__device__ __forceinline__ int CudaSpecialization::warp_idx() {\n"
+    "  return threadIdx.x / WARP_THREADS;\n"
+    "}\n"
+    "\n"
+    "__device__ __forceinline__ unsigned LANEMASK_LT() {\n"
+    "  unsigned result;\n"
+    "  asm(\"mov.u32 %0, %%lanemask_lt;\" : \"=r\"(result));\n"
+    "  return result;\n"
+    "}\n"
+    "\n"
+    "template <int WARP_THREADS>\n"
+    "__device__ __forceinline__ unsigned CudaSpecialization::lower_rank_lanemask() {\n"
+    "  return LANEMASK_LT();\n"
+    "}\n"
+    "\n"
+    "__device__ __forceinline__ unsigned LANEMASK_GT() {\n"
+    "  unsigned result;\n"
+    "  asm(\"mov.u32 %0, %%lanemask_gt;\" : \"=r\"(result));\n"
+    "  return result;\n"
+    "}\n"
+    "\n"
+    "template <int WARP_THREADS>\n"
+    "__device__ __forceinline__ unsigned CudaSpecialization::higher_rank_lanemask() {\n"
+    "  return LANEMASK_GT();\n"
+    "}\n"
+    "\n"
+    "__device__ __forceinline__ unsigned BFE(unsigned value, int start_bit,\n"
+    "                                        int num_bits) {\n"
+    "  asm(\"bfe.u32 %0, %1, %2, %3;\"\n"
+    "      : \"=r\"(value)\n"
+    "      : \"r\"(value), \"r\"(start_bit), \"r\"(num_bits));\n"
+    "  return value;\n"
+    "}\n"
+    "\n"
+    "// specialization for T=unsigned\n"
+    "template <>\n"
+    "__device__ __forceinline__ unsigned CudaSpecialization::extract_bits(\n"
+    "    unsigned value, int start_bit, int num_bits) {\n"
+    "  return BFE(value, start_bit, num_bits);\n"
+    "}\n"
+    "\n"
+    "__device__ __forceinline__ void PREFETCH(void *ptr) {\n"
+    "  asm(\"prefetch.global.L1 [%0];\" ::\"l\"(ptr));\n"
+    "}\n"
+    "\n"
+    "// specialization for T=Slice<GLOBAL, BLOCKED, unsigned long long>\n"
+    "template <>\n"
+    "__device__ __forceinline__ void\n"
+    "CudaSpecialization::prefetch<breeze::utils::Slice<\n"
+    "    breeze::utils::GLOBAL, breeze::utils::BLOCKED, unsigned long long>>(\n"
+    "    breeze::utils::Slice<breeze::utils::GLOBAL, breeze::utils::BLOCKED,\n"
+    "                         unsigned long long>\n"
+    "        address) {\n"
+    "  PREFETCH(address.data());\n"
+    "}\n";
+bool breeze_platforms_specialization_cuda_ptx_cuh_reg =
+    registerHeader(breeze_platforms_specialization_cuda_ptx_cuh);
+const char* breeze_platforms_platform_h =
+    "breeze/platforms/platform.h\n"
+    "/*\n"
+    " * Copyright (c) Facebook, Inc. and its affiliates.\n"
+    " *\n"
+    " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+    " * you may not use this file except in compliance with the License.\n"
+    " * You may obtain a copy of the License at\n"
+    " *\n"
+    " *     http://www.apache.org/licenses/LICENSE-2.0\n"
+    " *\n"
+    " * Unless required by applicable law or agreed to in writing, software\n"
+    " * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+    " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+    " * See the License for the specific language governing permissions and\n"
+    " * limitations under the License.\n"
+    " */\n"
+    "\n"
+    "/*\n"
+    " * Copyright (c) 2024 by Rivos Inc.\n"
+    " * Licensed under the Apache License, Version 2.0, see LICENSE for details.\n"
+    " * SPDX-License-Identifier: Apache-2.0\n"
+    " */\n"
+    "\n"
+    "#pragma once\n"
+    "\n"
+    "// some platforms require a system header to be included\n"
+    "#if defined(PLATFORM_CUDA)\n"
+    "#include <cuda_runtime_api.h>\n"
+    "#elif defined(PLATFORM_HIP)\n"
+    "#include <hip/hip_runtime.h>\n"
+    "#elif defined(PLATFORM_METAL)\n"
+    "#include <metal_stdlib>\n"
+    "#endif\n"
+    "\n"
+    "// function attributes used for device code\n"
+    "#if defined(PLATFORM_CUDA) || defined(PLATFORM_HIP)\n"
+    "#define ATTR __device__ __forceinline__\n"
+    "#elif defined(PLATFORM_SYCL) || defined(PLATFORM_METAL) || \\\n"
+    "    defined(PLATFORM_OPENCL) || defined(PLATFORM_OPENMP)\n"
+    "#define ATTR inline\n"
+    "#else\n"
+    "#error platform must be set\n"
+    "#endif\n";
+bool breeze_platforms_platform_h_reg =
+    registerHeader(breeze_platforms_platform_h);
+const char* breeze_utils_types_h =
+    "breeze/utils/types.h\n"
+    "/*\n"
+    " * Copyright (c) Facebook, Inc. and its affiliates.\n"
+    " *\n"
+    " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+    " * you may not use this file except in compliance with the License.\n"
+    " * You may obtain a copy of the License at\n"
+    " *\n"
+    " *     http://www.apache.org/licenses/LICENSE-2.0\n"
+    " *\n"
+    " * Unless required by applicable law or agreed to in writing, software\n"
+    " * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+    " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+    " * See the License for the specific language governing permissions and\n"
+    " * limitations under the License.\n"
+    " */\n"
+    "\n"
+    "/*\n"
+    " * Copyright (c) 2024 by Rivos Inc.\n"
+    " * Licensed under the Apache License, Version 2.0, see LICENSE for details.\n"
+    " * SPDX-License-Identifier: Apache-2.0\n"
+    " */\n"
+    "\n"
+    "#pragma once\n"
+    "\n"
+    "#include \"breeze/platforms/platform.h\"\n"
+    "\n"
+    "#if !defined(__CUDACC_RTC__) && defined(__EXCEPTIONS)\n"
+    "#include <exception>\n"
+    "#include <string>\n"
+    "#endif\n"
+    "\n"
+    "namespace breeze {\n"
+    "namespace utils {\n"
+    "\n"
+    "using size_type = int;\n"
+    "\n"
+    "template <int N, int M>\n"
+    "struct Min {\n"
+    "  enum { VALUE = ((N < M) ? N : M) };\n"
+    "};\n"
+    "\n"
+    "template <int N, int M>\n"
+    "struct Max {\n"
+    "  enum { VALUE = ((N > M) ? N : M) };\n"
+    "};\n"
+    "\n"
+    "template <int N>\n"
+    "struct PowerOfTwo {\n"
+    "  enum { VALUE = ((N & (N - 1)) == 0) };\n"
+    "};\n"
+    "\n"
+    "template <int N, int D>\n"
+    "struct DivideAndRoundUp {\n"
+    "  enum { VALUE = N / D + (N % D != 0 ? 1 : 0) };\n"
+    "};\n"
+    "\n"
+    "template <int N, int D>\n"
+    "struct RoundUp {\n"
+    "  enum {\n"
+    "    DIVIDE_AND_ROUND_UP_VALUE = DivideAndRoundUp<N, D>::VALUE,\n"
+    "    VALUE = DIVIDE_AND_ROUND_UP_VALUE * D,\n"
+    "  };\n"
+    "};\n"
+    "\n"
+    "template <typename T>\n"
+    "struct NumericLimits {\n"
+    "  static ATTR T min();\n"
+    "  static ATTR T max();\n"
+    "};\n"
+    "\n"
+    "// specialization for T=int\n"
+    "template <>\n"
+    "struct NumericLimits<int> {\n"
+    "  static ATTR int min() { return -2147483648; }\n"
+    "  static ATTR int max() { return 2147483647; }\n"
+    "};\n"
+    "\n"
+    "// specialization for T=unsigned\n"
+    "template <>\n"
+    "struct NumericLimits<unsigned> {\n"
+    "  static ATTR unsigned min() { return 0u; }\n"
+    "  static ATTR unsigned max() { return 4294967295u; }\n"
+    "};\n"
+    "\n"
+    "// specialization for T=float\n"
+    "template <>\n"
+    "struct NumericLimits<float> {\n"
+    "  static ATTR float min() { return 1.17549435e-38f; }\n"
+    "  static ATTR float max() { return 3.40282347e+38f; }\n"
+    "};\n"
+    "\n"
+    "#if !defined(PLATFORM_METAL)\n"
+    "\n"
+    "// specialization for T=long long\n"
+    "template <>\n"
+    "struct NumericLimits<long long> {\n"
+    "  static ATTR long long min() { return -9223372036854775807ll; }\n"
+    "  static ATTR long long max() { return 9223372036854775807ll; }\n"
+    "};\n"
+    "\n"
+    "// specialization for T=unsigned long long\n"
+    "template <>\n"
+    "struct NumericLimits<unsigned long long> {\n"
+    "  static ATTR unsigned long long min() { return 0; }\n"
+    "  static ATTR unsigned long long max() { return 18446744073709551615llu; }\n"
+    "};\n"
+    "\n"
+    "// specialization for T=double\n"
+    "template <>\n"
+    "struct NumericLimits<double> {\n"
+    "  static ATTR double min() { return 2.22507385850720138309e-308L; }\n"
+    "  static ATTR double max() { return 1.79769313486231570815e+308L; }\n"
+    "};\n"
+    "\n"
+    "#endif  // !defined(PLATFORM_METAL)\n"
+    "\n"
+    "template <typename T>\n"
+    "struct Msb {\n"
+    "  enum { VALUE = sizeof(T) * /*CHAR_BIT=*/8 - 1 };\n"
+    "};\n"
+    "\n"
+    "#ifndef __CUDACC_RTC__\n"
+    "\n"
+    "template <typename T>\n"
+    "T NextPowerOfTwo(T value);\n"
+    "\n"
+    "// specialization for T=int\n"
+    "template <>\n"
+    "inline int NextPowerOfTwo(int value) {\n"
+    "  return value == 1 ? 1 : 1 << (32 - __builtin_clz(value - 1));\n"
+    "}\n"
+    "\n"
+    "#endif\n"
+    "\n"
+    "template <typename T, typename U>\n"
+    "struct IsSame {\n"
+    "  enum { VALUE = 0 };\n"
+    "};\n"
+    "\n"
+    "template <typename T>\n"
+    "struct IsSame<T, T> {\n"
+    "  enum { VALUE = 1 };\n"
+    "};\n"
+    "\n"
+    "template <typename T, typename U>\n"
+    "struct IsDifferent {\n"
+    "  enum { VALUE = !IsSame<T, U>::VALUE };\n"
+    "};\n"
+    "\n"
+    "template <typename T>\n"
+    "struct RemoveConstT {\n"
+    "  using Type = T;\n"
+    "};\n"
+    "\n"
+    "template <typename T>\n"
+    "struct RemoveConstT<const T> {\n"
+    "  using Type = T;\n"
+    "};\n"
+    "\n"
+    "template <typename T>\n"
+    "using RemoveConst = typename RemoveConstT<T>::Type;\n"
+    "\n"
+    "#if !defined(__CUDACC_RTC__) && defined(__EXCEPTIONS)\n"
+    "\n"
+    "// custom exception used for device allocation failures\n"
+    "class BadDeviceAlloc : public std::exception {\n"
+    " public:\n"
+    "  BadDeviceAlloc(size_t size, size_t free, size_t total)\n"
+    "      : message_(\"BadDeviceAlloc(size=\" + std::to_string(size) +\n"
+    "                 \",free=\" + std::to_string(free) +\n"
+    "                 \",total=\" + std::to_string(total) + \")\") {}\n"
+    "\n"
+    "  virtual const char *what() const noexcept { return message_.c_str(); }\n"
+    "\n"
+    " private:\n"
+    "  std::string message_;\n"
+    "};\n"
+    "\n"
+    "#endif  // !__CUDACC_RTC__ && __EXCEPTIONS\n"
+    "\n"
+    "enum AddressSpace {\n"
+    "  THREAD,\n"
+    "  SHARED,\n"
+    "  GLOBAL,\n"
+    "};\n"
+    "\n"
+    "enum DataArrangement {\n"
+    "  BLOCKED,\n"
+    "  STRIPED,\n"
+    "  WARP_STRIPED,\n"
+    "};\n"
+    "\n"
+    "enum MemoryOrder {\n"
+    "  RELAXED,\n"
+    "  ACQUIRE,\n"
+    "  RELEASE,\n"
+    "};\n"
+    "\n"
+    "class NullType {};\n"
+    "\n"
+    "class EmptySlice {\n"
+    "  using data_type = NullType;\n"
+    "};\n"
+    "\n"
+    "ATTR EmptySlice constexpr make_empty_slice() { return EmptySlice{}; }\n"
+    "\n"
+    "// metal platform requires specialization as it has native address space\n"
+    "// qualifiers\n"
+    "#if defined(PLATFORM_METAL)\n"
+    "\n"
+    "template <AddressSpace A, DataArrangement B, typename T>\n"
+    "class Slice {};\n"
+    "\n"
+    "// partial specialization for ADDRESS_SPACE=THREAD\n"
+    "template <DataArrangement A, typename T>\n"
+    "class Slice<THREAD, A, T> {\n"
+    " public:\n"
+    "  static constant AddressSpace ADDRESS_SPACE = THREAD;\n"
+    "  static constant DataArrangement ARRANGEMENT = A;\n"
+    "  using data_type = T;\n"
+    "\n"
+    "  ATTR explicit Slice(thread T *data) : data_(data) {}\n"
+    "  ATTR T const thread &operator[](int index) const { return data_[index]; }\n"
+    "  ATTR T thread &operator[](int index) { return data_[index]; }\n"
+    "  ATTR T const thread &operator*() const { return *data_; }\n"
+    "  ATTR T thread &operator*() { return *data_; }\n"
+    "  ATTR T const thread *operator->() const { return data_; }\n"
+    "  ATTR T thread *operator->() { return data_; }\n"
+    "  ATTR Slice<THREAD, A, T> subslice(int offset) {\n"
+    "    return Slice<THREAD, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR const Slice<THREAD, A, T> subslice(int offset) const {\n"
+    "    return Slice<THREAD, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR operator bool() const { return data_ != nullptr; }\n"
+    "  ATTR T thread *data() { return data_; }\n"
+    "  ATTR T const thread *data() const { return data_; }\n"
+    "\n"
+    " private:\n"
+    "  thread T *data_;\n"
+    "};\n"
+    "\n"
+    "template <AddressSpace A = THREAD, DataArrangement B = STRIPED, typename T>\n"
+    "ATTR Slice<THREAD, B, T> constexpr make_slice(thread T *data) {\n"
+    "  return Slice<THREAD, B, T>(data);\n"
+    "}\n"
+    "\n"
+    "// partial specialization for ADDRESS_SPACE=SHARED\n"
+    "template <DataArrangement A, typename T>\n"
+    "class Slice<SHARED, A, T> {\n"
+    " public:\n"
+    "  static constant AddressSpace ADDRESS_SPACE = SHARED;\n"
+    "  static constant DataArrangement ARRANGEMENT = A;\n"
+    "  using data_type = T;\n"
+    "\n"
+    "  ATTR explicit Slice(threadgroup T *data) : data_(data) {}\n"
+    "  ATTR T const threadgroup &operator[](int index) const { return data_[index]; }\n"
+    "  ATTR T threadgroup &operator[](int index) { return data_[index]; }\n"
+    "  ATTR T const threadgroup &operator*() const { return *data_; }\n"
+    "  ATTR T threadgroup &operator*() { return *data_; }\n"
+    "  ATTR T const threadgroup *operator->() const { return data_; }\n"
+    "  ATTR T threadgroup *operator->() { return data_; }\n"
+    "  ATTR Slice<SHARED, A, T> subslice(int offset) {\n"
+    "    return Slice<SHARED, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR const Slice<SHARED, A, T> subslice(int offset) const {\n"
+    "    return Slice<SHARED, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR operator bool() const { return data_ != nullptr; }\n"
+    "  ATTR T threadgroup *data() { return data_; }\n"
+    "  ATTR T const threadgroup *data() const { return data_; }\n"
+    "\n"
+    "  template <AddressSpace OTHER>\n"
+    "  ATTR Slice<OTHER, A, T> reinterpret();\n"
+    "  // This is a no-op, but is needed for consistency with other platforms\n"
+    "  template <>\n"
+    "  ATTR Slice<SHARED, A, T> reinterpret<SHARED>() {\n"
+    "    return *this;\n"
+    "  }\n"
+    "\n"
+    " private:\n"
+    "  threadgroup T *data_;\n"
+    "};\n"
+    "\n"
+    "template <AddressSpace A = SHARED, DataArrangement B = BLOCKED, typename T>\n"
+    "ATTR Slice<SHARED, B, T> constexpr make_slice(threadgroup T *data) {\n"
+    "  return Slice<SHARED, B, T>(data);\n"
+    "}\n"
+    "\n"
+    "// partial specialization for ADDRESS_SPACE=GLOBAL\n"
+    "template <DataArrangement A, typename T>\n"
+    "class Slice<GLOBAL, A, T> {\n"
+    " public:\n"
+    "  static constant AddressSpace ADDRESS_SPACE = GLOBAL;\n"
+    "  static constant DataArrangement ARRANGEMENT = A;\n"
+    "  using data_type = T;\n"
+    "\n"
+    "  ATTR explicit Slice(device T *data) : data_(data) {}\n"
+    "  ATTR T const device &operator[](int index) const { return data_[index]; }\n"
+    "  ATTR T device &operator[](int index) { return data_[index]; }\n"
+    "  ATTR T const device &operator*() const { return *data_; }\n"
+    "  ATTR T device &operator*() { return *data_; }\n"
+    "  ATTR Slice<GLOBAL, A, T> subslice(int offset) {\n"
+    "    return Slice<GLOBAL, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR const Slice<GLOBAL, A, T> subslice(int offset) const {\n"
+    "    return Slice<GLOBAL, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR operator bool() const { return data_ != nullptr; }\n"
+    "  ATTR T device *data() { return data_; }\n"
+    "  ATTR T const device *data() const { return data_; }\n"
+    "\n"
+    " private:\n"
+    "  device T *data_;\n"
+    "};\n"
+    "\n"
+    "template <AddressSpace A = GLOBAL, DataArrangement B = BLOCKED, typename T>\n"
+    "ATTR Slice<GLOBAL, B, T> constexpr make_slice(device T *data) {\n"
+    "  return Slice<GLOBAL, B, T>(data);\n"
+    "}\n"
+    "\n"
+    "#elif defined(PLATFORM_OPENCL)\n"
+    "\n"
+    "template <AddressSpace A, DataArrangement B, typename T>\n"
+    "class Slice {};\n"
+    "\n"
+    "// partial specialization for ADDRESS_SPACE=THREAD\n"
+    "template <DataArrangement A, typename T>\n"
+    "class Slice<THREAD, A, T> {\n"
+    " public:\n"
+    "  static constexpr AddressSpace ADDRESS_SPACE = THREAD;\n"
+    "  static constexpr DataArrangement ARRANGEMENT = A;\n"
+    "  using data_type = T;\n"
+    "\n"
+    "  ATTR explicit Slice(__private T *data) : data_(data) {}\n"
+    "  ATTR T const __private &operator[](int index) const { return data_[index]; }\n"
+    "  ATTR T __private &operator[](int index) { return data_[index]; }\n"
+    "  ATTR T const __private &operator*() const { return *data_; }\n"
+    "  ATTR T __private &operator*() { return *data_; }\n"
+    "  ATTR T const __private *operator->() const { return data_; }\n"
+    "  ATTR T __private *operator->() { return data_; }\n"
+    "  ATTR Slice<THREAD, A, T> subslice(int offset) {\n"
+    "    return Slice<THREAD, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR const Slice<THREAD, A, T> subslice(int offset) const {\n"
+    "    return Slice<THREAD, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR operator bool() const { return data_ != nullptr; }\n"
+    "  ATTR T __private *data() { return data_; }\n"
+    "  ATTR T const __private *data() const { return data_; }\n"
+    "\n"
+    "  template <AddressSpace OTHER>\n"
+    "  ATTR Slice<OTHER, A, T> reinterpret();\n"
+    "  // This is a no-op, but is needed for consistency with other platforms\n"
+    "  template <>\n"
+    "  ATTR Slice<THREAD, A, T> reinterpret<THREAD>() {\n"
+    "    return *this;\n"
+    "  }\n"
+    "\n"
+    " private:\n"
+    "  __private T *data_;\n"
+    "};\n"
+    "\n"
+    "template <AddressSpace A = THREAD, DataArrangement B = STRIPED, typename T>\n"
+    "ATTR Slice<THREAD, B, T> constexpr make_slice(private T *data) {\n"
+    "  return Slice<THREAD, B, T>(data);\n"
+    "}\n"
+    "\n"
+    "// partial specialization for ADDRESS_SPACE=SHARED\n"
+    "template <DataArrangement A, typename T>\n"
+    "class Slice<SHARED, A, T> {\n"
+    " public:\n"
+    "  static constexpr AddressSpace ADDRESS_SPACE = SHARED;\n"
+    "  static constexpr DataArrangement ARRANGEMENT = A;\n"
+    "  using data_type = T;\n"
+    "\n"
+    "  ATTR explicit Slice(local T *data) : data_(data) {}\n"
+    "  ATTR T const local &operator[](int index) const { return data_[index]; }\n"
+    "  ATTR T local &operator[](int index) { return data_[index]; }\n"
+    "  ATTR T const local &operator*() const { return *data_; }\n"
+    "  ATTR T local &operator*() { return *data_; }\n"
+    "  ATTR T const local *operator->() const { return data_; }\n"
+    "  ATTR T local *operator->() { return data_; }\n"
+    "  ATTR Slice<SHARED, A, T> subslice(int offset) {\n"
+    "    return Slice<SHARED, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR const Slice<SHARED, A, T> subslice(int offset) const {\n"
+    "    return Slice<SHARED, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR operator bool() const { return data_ != nullptr; }\n"
+    "  ATTR T local *data() { return data_; }\n"
+    "  ATTR T const local *data() const { return data_; }\n"
+    "\n"
+    "  template <AddressSpace OTHER>\n"
+    "  ATTR Slice<OTHER, A, T> reinterpret();\n"
+    "  // This is a no-op, but is needed for consistency with other platforms\n"
+    "  template <>\n"
+    "  ATTR Slice<SHARED, A, T> reinterpret<SHARED>() {\n"
+    "    return *this;\n"
+    "  }\n"
+    "\n"
+    " private:\n"
+    "  local T *data_;\n"
+    "};\n"
+    "\n"
+    "template <AddressSpace A = SHARED, DataArrangement B = BLOCKED, typename T>\n"
+    "ATTR Slice<SHARED, B, T> constexpr make_slice(local T *data) {\n"
+    "  return Slice<SHARED, B, T>(data);\n"
+    "}\n"
+    "\n"
+    "// partial specialization for ADDRESS_SPACE=GLOBAL\n"
+    "template <DataArrangement A, typename T>\n"
+    "class Slice<GLOBAL, A, T> {\n"
+    " public:\n"
+    "  static constexpr AddressSpace ADDRESS_SPACE = GLOBAL;\n"
+    "  static constexpr DataArrangement ARRANGEMENT = A;\n"
+    "  using data_type = T;\n"
+    "\n"
+    "  ATTR explicit Slice(global T *data) : data_(data) {}\n"
+    "  ATTR T const global &operator[](int index) const { return data_[index]; }\n"
+    "  ATTR T global &operator[](int index) { return data_[index]; }\n"
+    "  ATTR T const global &operator*() const { return *data_; }\n"
+    "  ATTR T global &operator*() { return *data_; }\n"
+    "  ATTR Slice<GLOBAL, A, T> subslice(int offset) {\n"
+    "    return Slice<GLOBAL, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR const Slice<GLOBAL, A, T> subslice(int offset) const {\n"
+    "    return Slice<GLOBAL, A, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR operator bool() const { return data_ != nullptr; }\n"
+    "  ATTR T global *data() { return data_; }\n"
+    "  ATTR T const global *data() const { return data_; }\n"
+    "\n"
+    " private:\n"
+    "  global T *data_;\n"
+    "};\n"
+    "\n"
+    "template <AddressSpace A = GLOBAL, DataArrangement B = BLOCKED, typename T>\n"
+    "ATTR Slice<GLOBAL, B, T> constexpr make_slice(global T *data) {\n"
+    "  return Slice<GLOBAL, B, T>(data);\n"
+    "}\n"
+    "\n"
+    "#else  // defined(PLATFORM_OPENCL)\n"
+    "\n"
+    "template <AddressSpace A, DataArrangement B, typename T>\n"
+    "class Slice {\n"
+    " public:\n"
+    "  static constexpr AddressSpace ADDRESS_SPACE = A;\n"
+    "  static constexpr DataArrangement ARRANGEMENT = B;\n"
+    "  using data_type = T;\n"
+    "  using pointer_type = T *;\n"
+    "\n"
+    "  ATTR explicit Slice(pointer_type data) : data_(data) {}\n"
+    "  ATTR T const &operator[](int index) const { return data_[index]; }\n"
+    "  ATTR T &operator[](int index) { return data_[index]; }\n"
+    "  ATTR T const &operator*() const { return *data_; }\n"
+    "  ATTR T &operator*() { return *data_; }\n"
+    "  ATTR T const *operator->() const { return data_; }\n"
+    "  ATTR T *operator->() { return data_; }\n"
+    "  ATTR Slice<A, B, T> subslice(int offset) {\n"
+    "    return Slice<A, B, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR const Slice<A, B, T> subslice(int offset) const {\n"
+    "    return Slice<A, B, T>(data_ + offset);\n"
+    "  }\n"
+    "  ATTR operator bool() const { return data_ != nullptr; }\n"
+    "  ATTR T *data() { return data_; }\n"
+    "  ATTR T const *data() const { return data_; }\n"
+    "\n"
+    "  template <AddressSpace OTHER, DataArrangement OTHER_ARRANGEMENT =\n"
+    "                                    OTHER == THREAD ? STRIPED : BLOCKED>\n"
+    "  ATTR Slice<OTHER, OTHER_ARRANGEMENT, T> reinterpret() {\n"
+    "    using other_slice_type = Slice<OTHER, OTHER_ARRANGEMENT, T>;\n"
+    "    return other_slice_type((typename other_slice_type::pointer_type)data_);\n"
+    "  }\n"
+    "\n"
+    " private:\n"
+    "  pointer_type data_;\n"
+    "};\n"
+    "\n"
+    "// STRIPED arrangement by default for THREAD address space and BLOCKED\n"
+    "// arrangement by default for other address spaces\n"
+    "template <AddressSpace A = THREAD,\n"
+    "          DataArrangement B = A == THREAD ? STRIPED : BLOCKED, typename T>\n"
+    "ATTR Slice<A, B, T> constexpr make_slice(T *data) {\n"
+    "  return Slice<A, B, T>(data);\n"
+    "}\n"
+    "\n"
+    "#endif  // !defined(PLATFORM_METAL) && !defined(PLATFORM_OPENCL)\n"
+    "\n"
+    "}  // namespace utils\n"
+    "}  // namespace breeze\n";
+bool breeze_utils_types_h_reg = registerHeader(breeze_utils_types_h);
 } // namespace facebook::velox::wave
diff --git a/velox/experimental/wave/jit/make_headers.sh b/velox/experimental/wave/jit/make_headers.sh
index 00dfb3c92b4a..f7b8fef7b939 100755
--- a/velox/experimental/wave/jit/make_headers.sh
+++ b/velox/experimental/wave/jit/make_headers.sh
@@ -13,34 +13,43 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 # Generates the inlined headers for Wave Jit.
 #
 # Run in the valox checkout root.
 
 JIT=velox/experimental/wave/jit
-
-head --lines 16 velox/experimental/wave/common/Cuda.h > $JIT/Headers.h
-echo "namespace facebook::velox::wave {" >> $JIT/Headers.h
-
-echo "bool registerHeader(const char* text);" >> $JIT/Headers.h
-
-stringify velox/experimental/wave/common/BitUtil.cuh >> $JIT/Headers.h
-stringify velox/experimental/wave/common/Scan.cuh >> $JIT/Headers.h
-stringify "velox/experimental/wave/vector/Operand.h" >> $JIT/Headers.h
-stringify "velox/experimental/wave/exec/ErrorCode.h" >> $JIT/Headers.h
-stringify "velox/experimental/wave/exec/WaveCore.cuh" >> $JIT/Headers.h
-stringify "velox/experimental/wave/exec/ExprKernel.h" >> $JIT/Headers.h
-stringify "velox/experimental/wave/exec/Accumulators.cuh" >> $JIT/Headers.h
-stringify "velox/experimental/wave/exec/Join.cuh" >> $JIT/Headers.h
-stringify "velox/experimental/wave/common/HashTable.h" >> $JIT/Headers.h
-stringify "velox/experimental/wave/common/HashTable.cuh" >> $JIT/Headers.h
-stringify "velox/experimental/wave/common/hash.cuh" >> $JIT/Headers.h
-stringify "velox/experimental/wave/common/StringView.cuh" >> $JIT/Headers.h
-stringify "velox/experimental/wave/common/StringView.h" >> $JIT/Headers.h
-stringify "velox/experimental/wave/common/Hash.h" >> $JIT/Headers.h
-stringify "velox/experimental/wave/common/CompilerDefines.h" >> $JIT/Headers.h
-
-echo "}" >> $JIT/Headers.h
+if [ -z "$STRINGIFY" ]; then
+  STRINGIFY=stringify
+fi
+
+head --lines 16 velox/experimental/wave/common/Cuda.h >$JIT/Headers.h
+echo "namespace facebook::velox::wave {" >>$JIT/Headers.h
+
+echo "bool registerHeader(const char* text);" >>$JIT/Headers.h
+
+$STRINGIFY velox/experimental/wave/common/BitUtil.cuh >>$JIT/Headers.h
+$STRINGIFY velox/experimental/wave/common/Scan.cuh >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/vector/Operand.h" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/exec/ErrorCode.h" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/exec/WaveCore.cuh" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/exec/ExprKernel.h" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/exec/Accumulators.cuh" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/exec/Join.cuh" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/common/HashTable.h" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/common/HashTable.cuh" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/common/hash.cuh" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/common/StringView.cuh" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/common/StringView.h" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/common/Hash.h" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/common/CompilerDefines.h" >>$JIT/Headers.h
+$STRINGIFY "velox/experimental/wave/common/Atomic.cuh" >>$JIT/Headers.h
+cd velox/experimental/breeze || exit
+$STRINGIFY "breeze/platforms/cuda.cuh" >>../../../$JIT/Headers.h
+$STRINGIFY "breeze/platforms/specialization/cuda-ptx.cuh" >>../../../$JIT/Headers.h
+$STRINGIFY "breeze/platforms/platform.h" >>../../../$JIT/Headers.h
+$STRINGIFY "breeze/utils/types.h" >>../../../$JIT/Headers.h
+cd - || exit
+
+echo "}" >>$JIT/Headers.h
 
 clang-format -i $JIT/Headers.h
diff --git a/velox/experimental/wave/vector/CMakeLists.txt b/velox/experimental/wave/vector/CMakeLists.txt
index b70f331e3b11..4f04b01abe16 100644
--- a/velox/experimental/wave/vector/CMakeLists.txt
+++ b/velox/experimental/wave/vector/CMakeLists.txt
@@ -13,5 +13,4 @@
 # limitations under the License.
 
 add_library(velox_wave_vector WaveVector.cpp)
-target_link_libraries(
-  velox_wave_vector velox_vector velox_common_base)
+target_link_libraries(velox_wave_vector velox_vector velox_common_base)
diff --git a/velox/experimental/wave/vector/WaveVector.cpp b/velox/experimental/wave/vector/WaveVector.cpp
index deb8154ea3cb..85d3ca2d23cc 100644
--- a/velox/experimental/wave/vector/WaveVector.cpp
+++ b/velox/experimental/wave/vector/WaveVector.cpp
@@ -29,7 +29,7 @@ static int32_t kindSize() {
 
 int32_t waveTypeKindSize(WaveTypeKind waveKind) {
   TypeKind kind = static_cast<TypeKind>(waveKind);
-  if (kind == TypeKind::VARCHAR || kind == TypeKind::VARBINARY) {
+  if (is_string_kind(kind)) {
     // Wave StringView is 8, not 16 bytes.
     return sizeof(StringView);
   }
@@ -161,7 +161,7 @@ static VectorPtr toVeloxTyped(
 }
 
 bool isDenselyFilled(const BlockStatus* status, int32_t numBlocks) {
-  for (int32_t i = 0; i < numBlocks - 1; ++i) {
+  for (int32_t i = 0; i < numBlocks; ++i) {
     if (status[i].numRows != kBlockSize) {
       return false;
     }
diff --git a/velox/experimental/wave/vector/tests/CMakeLists.txt b/velox/experimental/wave/vector/tests/CMakeLists.txt
index 3abf0a43cd18..1dc7377ee4d4 100644
--- a/velox/experimental/wave/vector/tests/CMakeLists.txt
+++ b/velox/experimental/wave/vector/tests/CMakeLists.txt
@@ -26,7 +26,6 @@ target_link_libraries(
   Boost::date_time
   Boost::filesystem
   Boost::program_options
-  Boost::regex
   Boost::thread
   Boost::system
   GTest::gtest
@@ -35,4 +34,5 @@ target_link_libraries(
   Folly::folly
   gflags::gflags
   glog::glog
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/expression/CMakeLists.txt b/velox/expression/CMakeLists.txt
index e1229b67c014..4d5450f1aac2 100644
--- a/velox/expression/CMakeLists.txt
+++ b/velox/expression/CMakeLists.txt
@@ -16,15 +16,20 @@ velox_add_library(velox_type_signature OBJECT TypeSignature.cpp)
 
 velox_link_libraries(velox_type_signature velox_common_base)
 
-velox_add_library(velox_expression_functions FunctionSignature.cpp
-                  SignatureBinder.cpp ReverseSignatureBinder.cpp)
+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_signature_parser
+)
 
 velox_add_library(
   velox_expression
@@ -37,7 +42,10 @@ velox_add_library(
   EvalCtx.cpp
   Expr.cpp
   ExprCompiler.cpp
+  ExprRewriteRegistry.cpp
+  ExprOptimizer.cpp
   ExprToSubfieldFilter.cpp
+  ExprUtils.cpp
   FieldReference.cpp
   FunctionCallToSpecialForm.cpp
   GenericWriter.cpp
@@ -48,9 +56,13 @@ velox_add_library(
   RowConstructor.cpp
   SimpleFunctionRegistry.cpp
   SpecialFormRegistry.cpp
+  CoalesceRewrite.cpp
+  ConjunctRewrite.cpp
   SwitchExpr.cpp
+  SwitchRewrite.cpp
   TryExpr.cpp
-  VectorFunction.cpp)
+  VectorFunction.cpp
+)
 
 velox_link_libraries(
   velox_expression
@@ -61,7 +73,8 @@ velox_link_libraries(
   velox_functions_util
   velox_type_tz
   double-conversion::double-conversion
-  Folly::folly)
+  Folly::folly
+)
 
 add_subdirectory(type_calculation)
 add_subdirectory(signature_parser)
diff --git a/velox/expression/CastExpr-inl.h b/velox/expression/CastExpr-inl.h
index bd92884d0487..db286f15d7d2 100644
--- a/velox/expression/CastExpr-inl.h
+++ b/velox/expression/CastExpr-inl.h
@@ -51,150 +51,6 @@ inline std::exception_ptr makeBadCastException(
 
 } // 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;
-};
-
-// 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());
-  }
-
-  // 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;
-    }
-  } 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();
-      }
-    }
-  }
-
-  int128_t out = 0;
-  if (auto status = parseHugeInt(decimalComponents, out); !status.ok()) {
-    return status;
-  }
-
-  if (roundUp) {
-    bool overflow = __builtin_add_overflow(out, 1, &out);
-    if (UNLIKELY(overflow)) {
-      return Status::UserError("Value too large.");
-    }
-  }
-  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(
     EvalCtx& context,
@@ -319,8 +175,7 @@ void CastExpr::applyCastKernel(
     }
 
     // Optimize empty input strings casting by avoiding throwing exceptions.
-    if constexpr (
-        FromKind == TypeKind::VARCHAR || FromKind == TypeKind::VARBINARY) {
+    if constexpr (is_string_kind(FromKind)) {
       if constexpr (
           TypeTraits<ToKind>::isPrimitiveType &&
           TypeTraits<ToKind>::isFixedWidth) {
@@ -367,10 +222,9 @@ void CastExpr::applyCastKernel(
       return;
     }
 
-    const auto output = castResult.value();
+    const auto& output = castResult.value();
 
-    if constexpr (
-        ToKind == TypeKind::VARCHAR || ToKind == TypeKind::VARBINARY) {
+    if constexpr (is_string_kind(ToKind)) {
       // Write the result output to the output vector
       auto writer = exec::StringWriter(result, row);
       writer.copy_from(output);
@@ -498,7 +352,7 @@ void CastExpr::applyVarcharToDecimalCastKernel(
 
   rows.applyToSelected([&](auto row) {
     T decimalValue;
-    const auto status = detail::toDecimalValue<T>(
+    const auto status = DecimalUtil::castFromString<T>(
         hooks_->removeWhiteSpaces(sourceVector->valueAt(row)),
         toPrecisionScale.first,
         toPrecisionScale.second,
@@ -568,11 +422,14 @@ VectorPtr CastExpr::applyDecimalToIntegralCast(
     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 (hooks_->getPolicy() != SparkTryCastPolicy) {
+        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()) {
@@ -722,6 +579,12 @@ void CastExpr::applyCastPrimitives(
             row, context, inputSimpleVector, resultFlatVector);
       });
       break;
+    case SparkTryCastPolicy:
+      applyToSelectedNoThrowLocal(context, rows, result, [&](int row) {
+        applyCastKernel<ToKind, FromKind, util::SparkTryCastPolicy>(
+            row, context, inputSimpleVector, resultFlatVector);
+      });
+      break;
 
     default:
       VELOX_NYI("Policy {} not yet implemented.", hooks_->getPolicy());
diff --git a/velox/expression/CastExpr.cpp b/velox/expression/CastExpr.cpp
index 559e67339bba..0b29e361caf9 100644
--- a/velox/expression/CastExpr.cpp
+++ b/velox/expression/CastExpr.cpp
@@ -24,126 +24,17 @@
 #include "velox/expression/PeeledEncoding.h"
 #include "velox/expression/PrestoCastHooks.h"
 #include "velox/expression/ScopedVarSetter.h"
+#include "velox/external/tzdb/time_zone.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/LazyVector.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 = static_cast<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) {
@@ -323,6 +214,196 @@ VectorPtr CastExpr::castFromIntervalDayTime(
   }
 }
 
+VectorPtr CastExpr::castFromTime(
+    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: {
+      // Get session timezone
+      const auto* timeZone =
+          getTimeZoneFromConfig(context.execCtx()->queryCtx()->queryConfig());
+      // Get session start time
+      const auto startTimeMs =
+          context.execCtx()->queryCtx()->queryConfig().sessionStartTimeMs();
+      auto systemDay = std::chrono::milliseconds{startTimeMs} / kMillisInDay;
+
+      auto* resultFlatVector = castResult->as<FlatVector<StringView>>();
+
+      Buffer* buffer = resultFlatVector->getBufferWithSpace(
+          rows.countSelected() * TimeType::kTimeToVarcharRowSize,
+          true /*exactSize*/);
+      char* rawBuffer = buffer->asMutable<char>() + buffer->size();
+
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        try {
+          // Use timezone-aware conversion
+          auto systemTime =
+              systemDay.count() * kMillisInDay + inputFlatVector->valueAt(row);
+
+          int64_t adjustedTime{0};
+          if (timeZone) {
+            adjustedTime =
+                (timeZone->to_local(std::chrono::milliseconds{systemTime}) %
+                 kMillisInDay)
+                    .count();
+          } else {
+            adjustedTime = systemTime % kMillisInDay;
+          }
+
+          if (adjustedTime < 0) {
+            adjustedTime += kMillisInDay;
+          }
+
+          auto output = TIME()->valueToString(adjustedTime, rawBuffer);
+          resultFlatVector->setNoCopy(row, output);
+          rawBuffer += output.size();
+        } 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());
+        }
+      });
+
+      buffer->setSize(rawBuffer - buffer->asMutable<char>());
+      return castResult;
+    }
+    case TypeKind::BIGINT: {
+      // if input is constant, create a constant output vector
+      if (input.isConstantEncoding()) {
+        auto constantInput = input.as<ConstantVector<int64_t>>();
+        if (constantInput->isNullAt(0)) {
+          return BaseVector::createNullConstant(
+              toType, rows.end(), context.pool());
+        } else {
+          auto constantValue = constantInput->valueAt(0);
+          return std::make_shared<ConstantVector<int64_t>>(
+              context.pool(),
+              rows.end(),
+              false, // isNull
+              toType,
+              std::move(constantValue));
+        }
+      }
+
+      // fallback to element-wise copy for non-constant inputs
+      auto* resultFlatVector = castResult->as<FlatVector<int64_t>>();
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        resultFlatVector->set(row, inputFlatVector->valueAt(row));
+      });
+      return castResult;
+    }
+    case TypeKind::TIMESTAMP: {
+      // if input is constant, create a constant output vector
+      if (input.isConstantEncoding()) {
+        auto constantInput = input.as<ConstantVector<int64_t>>();
+        if (constantInput->isNullAt(0)) {
+          return BaseVector::createNullConstant(
+              toType, rows.end(), context.pool());
+        } else {
+          auto timeMillis = constantInput->valueAt(0);
+          return std::make_shared<ConstantVector<Timestamp>>(
+              context.pool(),
+              rows.end(),
+              false, // isNull
+              toType,
+              Timestamp::fromMillis(timeMillis));
+        }
+      }
+
+      // fallback to element-wise copy for non-constant inputs
+      auto* resultFlatVector = castResult->as<FlatVector<Timestamp>>();
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        auto timeMillis = inputFlatVector->valueAt(row);
+        resultFlatVector->set(row, Timestamp::fromMillis(timeMillis));
+      });
+      return castResult;
+    }
+    default:
+      VELOX_UNSUPPORTED(
+          "Cast from TIME to {} is not supported", toType->toString());
+  }
+}
+
+VectorPtr CastExpr::castToTime(
+    const SelectivityVector& rows,
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const TypePtr& fromType) {
+  switch (fromType->kind()) {
+    case TypeKind::VARCHAR: {
+      VectorPtr castResult;
+      context.ensureWritable(rows, TIME(), castResult);
+      (*castResult).clearNulls(rows);
+
+      // Get session timezone and start time for timezone conversions
+      const auto* timeZone =
+          getTimeZoneFromConfig(context.execCtx()->queryCtx()->queryConfig());
+      const auto sessionStartTimeMs =
+          context.execCtx()->queryCtx()->queryConfig().sessionStartTimeMs();
+
+      auto* inputVector = input.as<SimpleVector<StringView>>();
+      auto* resultFlatVector = castResult->as<FlatVector<int64_t>>();
+
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        try {
+          const auto inputString = inputVector->valueAt(row);
+          int64_t result =
+              TIME()->valueToTime(inputString, timeZone, sessionStartTimeMs);
+          resultFlatVector->set(row, result);
+        } catch (const VeloxException& ue) {
+          if (!ue.isUserError()) {
+            throw;
+          }
+          VELOX_USER_FAIL(
+              makeErrorMessage(input, row, TIME()) + " " + ue.message());
+        } catch (const std::exception& e) {
+          VELOX_USER_FAIL(
+              makeErrorMessage(input, row, TIME()) + " " + e.what());
+        }
+      });
+
+      return castResult;
+    }
+    case TypeKind::TIMESTAMP: {
+      VectorPtr castResult;
+      context.ensureWritable(rows, TIME(), castResult);
+      (*castResult).clearNulls(rows);
+
+      auto* inputVector = input.as<SimpleVector<Timestamp>>();
+      auto* resultFlatVector = castResult->as<FlatVector<int64_t>>();
+
+      // Cast from TIMESTAMP to TIME extracts the time-of-day component
+      // (milliseconds since midnight) from the timestamp
+      applyToSelectedNoThrowLocal(context, rows, castResult, [&](int row) {
+        const auto timestamp = inputVector->valueAt(row);
+        // Extract time-of-day using std::chrono.
+        // floor() also rounds towards negative infinity, so this correctly
+        // handles negative timestamps.
+        auto millis = std::chrono::milliseconds{timestamp.toMillis()};
+        auto timeOfDay = millis - std::chrono::floor<std::chrono::days>(millis);
+        resultFlatVector->set(row, timeOfDay.count());
+      });
+
+      return castResult;
+    }
+    default:
+      VELOX_UNSUPPORTED(
+          "Cast from {} to TIME is not supported", fromType->toString());
+  }
+}
+
 namespace {
 void propagateErrorsOrSetNulls(
     bool setNullInResultAtError,
@@ -330,11 +411,11 @@ void propagateErrorsOrSetNulls(
     const SelectivityVector& nestedRows,
     const BufferPtr& elementToTopLevelRows,
     VectorPtr& result,
-    EvalErrorsPtr& oldErrors) {
+    exec::EvalErrorsPtr& oldErrors) {
   if (context.errors()) {
     if (setNullInResultAtError) {
-      // Errors in context.errors() should be translated to nulls in the top
-      // level rows.
+      // Errors in context.errors() should be translated to nulls in
+      // the top level rows.
       context.convertElementErrorsToTopLevelNulls(
           nestedRows, elementToTopLevelRows, result);
     } else {
@@ -361,8 +442,8 @@ VectorPtr CastExpr::applyMap(
     exec::EvalCtx& context,
     const MapType& fromType,
     const MapType& toType) {
-  // Cast input keys/values vector to output keys/values vector using their
-  // element selectivity vector
+  // Cast input keys/values vector to output keys/values vector using
+  // their element selectivity vector
 
   // Initialize nested rows
   auto mapKeys = input->mapKeys();
@@ -414,8 +495,8 @@ VectorPtr CastExpr::applyMap(
     }
   }
 
-  // Returned map vector should be addressable for every element, even those
-  // that are not selected.
+  // Returned map vector should be addressable for every element, even
+  // those that are not selected.
   BufferPtr sizes = input->sizes();
   if (newMapKeys->isConstantEncoding() && newMapValues->isConstantEncoding()) {
     // We extends size since that is cheap.
@@ -463,8 +544,8 @@ VectorPtr CastExpr::applyArray(
     exec::EvalCtx& context,
     const ArrayType& fromType,
     const ArrayType& toType) {
-  // Cast input array elements to output array elements based on their types
-  // using their linear selectivity vector
+  // Cast input array elements to output array elements based on their
+  // types using their linear selectivity vector
   auto arrayElements = input->elements();
 
   auto nestedRows =
@@ -487,8 +568,8 @@ VectorPtr CastExpr::applyArray(
         newElements);
   }
 
-  // Returned array vector should be addressable for every element, even those
-  // that are not selected.
+  // Returned array vector should be addressable for every element,
+  // even those that are not selected.
   BufferPtr sizes = input->sizes();
   if (newElements->isConstantEncoding()) {
     // If the newElements we extends its size since that is cheap.
@@ -533,8 +614,8 @@ VectorPtr CastExpr::applyRow(
   int numInputChildren = input->children().size();
   int numOutputChildren = toRowType.size();
 
-  // Extract the flag indicating matching of children must be done by name or
-  // position
+  // Extract the flag indicating matching of children must be done by
+  // name or position
   auto matchByName =
       context.execCtx()->queryCtx()->queryConfig().isMatchStructByName();
 
@@ -544,14 +625,16 @@ VectorPtr CastExpr::applyRow(
 
   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.
+    // We need to isolate errors that happen during the cast from
+    // previous errors since those translate to nulls, unlike
+    // exisiting errors.
     context.swapErrors(oldErrors);
   }
 
   for (auto toChildrenIndex = 0; toChildrenIndex < numOutputChildren;
        toChildrenIndex++) {
-    // For each child, find the corresponding column index in the output
+    // For each child, find the corresponding column index in the
+    // output
     const auto& toFieldName = toRowType.nameOf(toChildrenIndex);
     bool matchNotFound = false;
 
@@ -725,8 +808,8 @@ void CastExpr::applyPeeled(
     };
 
     if (setNullInResultAtError()) {
-      // This can be optimized by passing setNullInResultAtError() to castTo and
-      // castFrom operations.
+      // This can be optimized by passing setNullInResultAtError() to
+      // castTo and castFrom operations.
 
       EvalErrorsPtr oldErrors;
       context.swapErrors(oldErrors);
@@ -760,6 +843,10 @@ void CastExpr::applyPeeled(
         "Cast from {} to {} is not supported",
         fromType->toString(),
         toType->toString());
+  } else if (fromType->isTime()) {
+    result = castFromTime(rows, input, context, toType);
+  } else if (toType->isTime()) {
+    result = castToTime(rows, input, context, fromType);
   } else if (toType->isShortDecimal()) {
     result = applyDecimal<int64_t>(rows, input, context, fromType, toType);
   } else if (toType->isLongDecimal()) {
@@ -879,8 +966,8 @@ VectorPtr CastExpr::applyTimestampToVarcharCast(
     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.
+    // The result of both Presto and Spark contains more than 12
+    // digits even when 'zeroPaddingYear' is disabled.
     VELOX_DCHECK(!stringView.isInline());
     rawBuffer += stringView.size();
   });
@@ -977,8 +1064,8 @@ void CastExpr::apply(
   context.moveOrCopyResult(localResult, *remainingRows, result);
   context.releaseVector(localResult);
 
-  // If there are nulls or rows that encountered errors in the 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 || context.errors()) {
     EvalCtx::addNulls(
@@ -996,7 +1083,7 @@ void CastExpr::evalSpecialForm(
   auto toType = std::const_pointer_cast<const Type>(type_);
 
   inTopLevel = true;
-  if (nullOnFailure()) {
+  if (isTryCast()) {
     ScopedVarSetter holder{context.mutableThrowOnError(), false};
     ScopedVarSetter captureErrorDetails(
         context.mutableCaptureErrorDetails(), false);
@@ -1007,7 +1094,8 @@ void CastExpr::evalSpecialForm(
   } else {
     apply(rows, input, context, fromType, toType, result);
   }
-  // Return 'input' back to the vector pool in 'context' so it can be reused.
+  // Return 'input' back to the vector pool in 'context' so it can be
+  // reused.
   context.releaseVector(input);
 }
 
diff --git a/velox/expression/CastExpr.h b/velox/expression/CastExpr.h
index 01bcc053a56e..09c1c03baff5 100644
--- a/velox/expression/CastExpr.h
+++ b/velox/expression/CastExpr.h
@@ -17,14 +17,12 @@
 #pragma once
 
 #include "velox/expression/CastHooks.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/FunctionCallToSpecialForm.h"
 #include "velox/expression/SpecialForm.h"
 
 namespace facebook::velox::exec {
 
-constexpr folly::StringPiece kCast = "cast";
-constexpr folly::StringPiece kTryCast = "try_cast";
-
 /// Custom operator for casts from and to custom types.
 class CastOperator {
  public:
@@ -87,15 +85,16 @@ class CastExpr : public SpecialForm {
       TypePtr type,
       ExprPtr&& expr,
       bool trackCpuUsage,
-      bool nullOnFailure,
+      bool isTryCast,
       std::shared_ptr<CastHooks> hooks)
       : SpecialForm(
+            SpecialFormKind::kCast,
             type,
             std::vector<ExprPtr>({expr}),
-            nullOnFailure ? kTryCast.data() : kCast.data(),
+            isTryCast ? expression::kTryCast : expression::kCast,
             false /* supportsFlatNoNullsFastPath */,
             trackCpuUsage),
-        nullOnFailure_(nullOnFailure),
+        isTryCast_(isTryCast),
         hooks_(std::move(hooks)) {}
 
   void evalSpecialForm(
@@ -205,6 +204,18 @@ class CastExpr : public SpecialForm {
       exec::EvalCtx& context,
       const TypePtr& toType);
 
+  VectorPtr castFromTime(
+      const SelectivityVector& rows,
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const TypePtr& toType);
+
+  VectorPtr castToTime(
+      const SelectivityVector& rows,
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const TypePtr& fromType);
+
   template <typename TInput, typename TOutput>
   void applyDecimalCastKernel(
       const SelectivityVector& rows,
@@ -303,12 +314,12 @@ class CastExpr : public SpecialForm {
       exec::EvalCtx& context,
       const BaseVector& input);
 
-  bool nullOnFailure() const {
-    return nullOnFailure_;
+  bool isTryCast() const {
+    return isTryCast_;
   }
 
   bool setNullInResultAtError() const {
-    return nullOnFailure() && inTopLevel;
+    return isTryCast() && (inTopLevel || hooks_->applyTryCastRecursively());
   }
 
   CastOperatorPtr getCastOperator(const TypePtr& type);
@@ -316,7 +327,7 @@ class CastExpr : public SpecialForm {
   // Custom cast operators for to and from top-level as well as nested types.
   folly::F14FastMap<std::string, CastOperatorPtr> castOperators_;
 
-  bool nullOnFailure_;
+  bool isTryCast_;
   std::shared_ptr<CastHooks> hooks_;
 
   bool inTopLevel = false;
diff --git a/velox/expression/CastHooks.h b/velox/expression/CastHooks.h
index 66e6f00b704d..f51ce56ed9d9 100644
--- a/velox/expression/CastHooks.h
+++ b/velox/expression/CastHooks.h
@@ -21,7 +21,12 @@
 
 namespace facebook::velox::exec {
 
-enum PolicyType { LegacyCastPolicy = 1, PrestoCastPolicy, SparkCastPolicy };
+enum PolicyType {
+  LegacyCastPolicy = 1,
+  PrestoCastPolicy,
+  SparkCastPolicy,
+  SparkTryCastPolicy
+};
 
 fmt::underlying_t<PolicyType> format_as(PolicyType f);
 
@@ -45,26 +50,31 @@ class CastHooks {
   virtual Expected<int32_t> castStringToDate(
       const StringView& dateString) const = 0;
 
-  // 'data' is guaranteed to be non-empty and has been processed by
-  // removeWhiteSpaces.
+  /// '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.
+  /// '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.
+  /// Trims all leading and trailing UTF8 whitespaces.
   virtual StringView removeWhiteSpaces(const StringView& view) const = 0;
 
-  // Returns the options to cast from timestamp to string.
+  /// Returns the options to cast from timestamp to string.
   virtual const TimestampToStringOptions& timestampToStringOptions() const = 0;
 
-  // Returns whether to cast to int by truncate.
+  /// Returns whether to cast to int by truncate.
   virtual bool truncate() const = 0;
 
+  /// Returns whether to apply try_cast recursively rather than only at the top
+  /// level. E.g. if true, an element inside an array would be null rather than
+  /// the entire array if the cast of that element fails.
+  virtual bool applyTryCastRecursively() const = 0;
+
   virtual PolicyType getPolicy() const = 0;
 
-  // Converts boolean to timestamp type.
+  /// Converts boolean to timestamp type.
   virtual Expected<Timestamp> castBooleanToTimestamp(bool seconds) const = 0;
 };
 } // namespace facebook::velox::exec
diff --git a/velox/expression/CoalesceExpr.cpp b/velox/expression/CoalesceExpr.cpp
index cc7e7f18164c..4f7023aee328 100644
--- a/velox/expression/CoalesceExpr.cpp
+++ b/velox/expression/CoalesceExpr.cpp
@@ -14,17 +14,74 @@
  * limitations under the License.
  */
 #include "velox/expression/CoalesceExpr.h"
+#include "velox/expression/ExprConstants.h"
+#include "velox/type/TypeCoercer.h"
 
 namespace facebook::velox::exec {
 
+namespace {
+
+TypePtr resolveTypeInt(
+    const std::vector<TypePtr>& argTypes,
+    bool allowedCoercions,
+    std::vector<TypePtr>& coercions) {
+  VELOX_CHECK_GT(
+      argTypes.size(),
+      0,
+      "COALESCE statements expect to receive at least 1 argument, but did not receive any.");
+
+  const auto numArgs = argTypes.size();
+
+  if (allowedCoercions) {
+    coercions.clear();
+    coercions.resize(numArgs);
+  }
+
+  auto resultType = argTypes[0];
+
+  for (auto i = 1; i < numArgs; i++) {
+    if (*resultType == *argTypes[i]) {
+      continue;
+    }
+
+    if (allowedCoercions && TypeCoercer::coercible(argTypes[i], resultType)) {
+      coercions[i] = resultType;
+      continue;
+    }
+
+    if (allowedCoercions && TypeCoercer::coercible(resultType, argTypes[i])) {
+      resultType = argTypes[i];
+      for (auto j = 0; j < i; j++) {
+        coercions[j] = resultType;
+      }
+      continue;
+    }
+
+    VELOX_USER_CHECK(
+        *argTypes[0] == *argTypes[i],
+        "Inputs to coalesce must have the same type. Expected {}, but got {}.",
+        argTypes[0]->toString(),
+        argTypes[i]->toString());
+  }
+
+  return resultType;
+}
+
+TypePtr resolveTypeInt(const std::vector<TypePtr>& argTypes) {
+  std::vector<TypePtr> coercions;
+  return resolveTypeInt(argTypes, false, coercions);
+}
+} // namespace
+
 CoalesceExpr::CoalesceExpr(
     TypePtr type,
     std::vector<ExprPtr>&& inputs,
     bool inputsSupportFlatNoNullsFastPath)
     : SpecialForm(
+          SpecialFormKind::kCoalesce,
           std::move(type),
           std::move(inputs),
-          kCoalesce,
+          expression::kCoalesce,
           inputsSupportFlatNoNullsFastPath,
           false /* trackCpuUsage */) {
   std::vector<TypePtr> inputTypes;
@@ -36,10 +93,10 @@ CoalesceExpr::CoalesceExpr(
       [](const ExprPtr& expr) { return expr->type(); });
 
   // Apply type checks.
-  auto expectedType = resolveType(inputTypes);
+  auto expectedType = resolveTypeInt(inputTypes);
   VELOX_CHECK(
       *expectedType == *this->type(),
-      "Coalesce expression type different than its inputs. Expected {} but got Actual {}.",
+      "Coalesce expression type different than its inputs. Expected {}, but got {}.",
       expectedType->toString(),
       this->type()->toString());
 }
@@ -85,26 +142,15 @@ void CoalesceExpr::evalSpecialForm(
   }
 }
 
-// static
-TypePtr CoalesceExpr::resolveType(const std::vector<TypePtr>& argTypes) {
-  VELOX_CHECK_GT(
-      argTypes.size(),
-      0,
-      "COALESCE statements expect to receive at least 1 argument, but did not receive any.");
-  for (auto i = 1; i < argTypes.size(); i++) {
-    VELOX_USER_CHECK(
-        *argTypes[0] == *argTypes[i],
-        "Inputs to coalesce must have the same type. Expected {}, but got {}.",
-        argTypes[0]->toString(),
-        argTypes[i]->toString());
-  }
-
-  return argTypes[0];
-}
-
 TypePtr CoalesceCallToSpecialForm::resolveType(
     const std::vector<TypePtr>& argTypes) {
-  return CoalesceExpr::resolveType(argTypes);
+  return resolveTypeInt(argTypes);
+}
+
+TypePtr CoalesceCallToSpecialForm::resolveTypeWithCorsions(
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  return resolveTypeInt(argTypes, true, coercions);
 }
 
 ExprPtr CoalesceCallToSpecialForm::constructSpecialForm(
diff --git a/velox/expression/CoalesceExpr.h b/velox/expression/CoalesceExpr.h
index c55d441d197c..8afbcdfffb6b 100644
--- a/velox/expression/CoalesceExpr.h
+++ b/velox/expression/CoalesceExpr.h
@@ -20,8 +20,6 @@
 
 namespace facebook::velox::exec {
 
-const char* const kCoalesce = "coalesce";
-
 class CoalesceExpr : public SpecialForm {
  public:
   CoalesceExpr(
@@ -39,15 +37,19 @@ class CoalesceExpr : public SpecialForm {
     propagatesNulls_ = false;
   }
 
-  static TypePtr resolveType(const std::vector<TypePtr>& argTypes);
-
   friend class CoalesceCallToSpecialForm;
 };
 
 class CoalesceCallToSpecialForm : public FunctionCallToSpecialForm {
  public:
+  /// Returns the type of the 1st argument. Throws if 'argTypes' is empty or not
+  /// argument types are the same.
   TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
 
+  TypePtr resolveTypeWithCorsions(
+      const std::vector<TypePtr>& argTypes,
+      std::vector<TypePtr>& coercions) override;
+
   ExprPtr constructSpecialForm(
       const TypePtr& type,
       std::vector<ExprPtr>&& compiledChildren,
diff --git a/velox/expression/CoalesceRewrite.cpp b/velox/expression/CoalesceRewrite.cpp
new file mode 100644
index 000000000000..96a7f35dedca
--- /dev/null
+++ b/velox/expression/CoalesceRewrite.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <set>
+
+#include "velox/expression/CoalesceRewrite.h"
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/expression/ExprUtils.h"
+
+namespace facebook::velox::expression {
+
+core::TypedExprPtr CoalesceRewrite::rewrite(const core::TypedExprPtr& expr) {
+  if (!expr->isCallKind()) {
+    return nullptr;
+  }
+  const auto* callExpr = expr->asUnchecked<core::CallTypedExpr>();
+  if (callExpr->name() != kCoalesce) {
+    return nullptr;
+  }
+
+  // Deduplicate inputs to COALESCE and remove NULL inputs.
+  std::vector<core::TypedExprPtr> flat;
+  utils::flattenInput(expr, kCoalesce, flat);
+  folly::F14FastSet<
+      const core::ITypedExpr*,
+      core::ITypedExprHasher,
+      core::ITypedExprComparer>
+      uniqueInputs;
+  std::vector<core::TypedExprPtr> deduplicatedInputs;
+
+  for (const auto& input : flat) {
+    if (input->isConstantKind()) {
+      const auto* constantExpr = input->asUnchecked<core::ConstantTypedExpr>();
+      if (constantExpr->isNull()) {
+        // Drop NULL constant.
+        continue;
+      }
+
+      if (uniqueInputs.empty()) {
+        // Return first non-NULL constant input.
+        return input;
+      }
+
+      // Drop inputs after non-NULL constant input.
+      uniqueInputs.insert(input.get());
+      deduplicatedInputs.push_back(input);
+      break;
+    } else {
+      if (uniqueInputs.emplace(input.get()).second) {
+        deduplicatedInputs.push_back(input);
+      }
+    }
+  }
+
+  // Return NULL if all inputs to COALESCE are NULL.
+  if (uniqueInputs.empty()) {
+    return flat.front();
+  }
+  // If there is a single input to COALESCE, return this expression.
+  if (uniqueInputs.size() == 1) {
+    return deduplicatedInputs.front();
+  }
+
+  return std::make_shared<core::CallTypedExpr>(
+      expr->type(), std::move(deduplicatedInputs), kCoalesce);
+}
+
+void CoalesceRewrite::registerRewrite() {
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      expression::CoalesceRewrite::rewrite);
+}
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/CoalesceRewrite.h b/velox/expression/CoalesceRewrite.h
new file mode 100644
index 000000000000..9954fd34709f
--- /dev/null
+++ b/velox/expression/CoalesceRewrite.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.
+ */
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression {
+
+class CoalesceRewrite {
+ public:
+  /// Rewrites COALESCE special form expression. Nested COALESCE expressions are
+  /// first flattened in a recursive manner, eg: COALESCE(a, COALESCE(b, c)) ->
+  /// COALESCE(a, b, c). The inputs to COALESCE are then traversed in order and:
+  ///  1. If the input is constant:
+  ///     a. and it is NULL, the input is removed.
+  ///     b. and if there are no inputs before this, the COALESCE expression is
+  ///        simplified to this constant input.
+  ///     c. otherwise, all subsequent inputs after this are removed.
+  ///  2. Otherwise, if the same input is seen before, it is removed i.e non
+  ///     constant inputs to COALESCE are deduplicated.
+  /// If there is a single input to COALESCE after pruning inputs, COALESCE is
+  /// simplified to this expression. Otherwise, returns an optimized COALESCE
+  /// expression with pruned inputs.
+  static core::TypedExprPtr rewrite(const core::TypedExprPtr& expr);
+
+  static void registerRewrite();
+};
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ComplexViewTypes.h b/velox/expression/ComplexViewTypes.h
index 6a8be6fb9b88..97d19bc1b5db 100644
--- a/velox/expression/ComplexViewTypes.h
+++ b/velox/expression/ComplexViewTypes.h
@@ -43,24 +43,11 @@ struct ViewWithComparison {
     return compareOrThrow(lhs, rhs, kEqualValueAtFlags) == 0;
   }
 
-  friend bool operator!=(const T& lhs, const T& rhs) {
-    return !(lhs == rhs);
-  }
-
-  friend bool operator<(const T& lhs, const T& rhs) {
-    return compareOrThrow(lhs, rhs) < 0;
-  }
-
-  friend bool operator>(const T& lhs, const T& rhs) {
-    return rhs < lhs;
-  }
-
-  friend bool operator<=(const T& lhs, const T& rhs) {
-    return !(lhs > rhs);
-  }
-
-  friend bool operator>=(const T& lhs, const T& rhs) {
-    return !(lhs < rhs);
+  friend std::strong_ordering operator<=>(const T& lhs, const T& rhs) {
+    const auto cmp = compareOrThrow(lhs, rhs);
+    return cmp < 0 ? std::strong_ordering::less
+        : cmp > 0  ? std::strong_ordering::greater
+                   : std::strong_ordering::equal;
   }
 
  private:
@@ -147,28 +134,12 @@ class IndexBasedIterator {
     return elementAccessor_(index_ + n);
   }
 
-  bool operator!=(const Iterator& rhs) const {
-    return index_ != rhs.index_;
-  }
-
   bool operator==(const Iterator& rhs) const {
     return index_ == rhs.index_;
   }
 
-  bool operator<(const Iterator& rhs) const {
-    return index_ < rhs.index_;
-  }
-
-  bool operator>(const Iterator& rhs) const {
-    return index_ > rhs.index_;
-  }
-
-  bool operator<=(const Iterator& rhs) const {
-    return index_ <= rhs.index_;
-  }
-
-  bool operator>=(const Iterator& rhs) const {
-    return index_ >= rhs.index_;
+  auto operator<=>(const Iterator& rhs) const {
+    return index_ <=> rhs.index_;
   }
 
   // Implement post increment.
@@ -320,18 +291,14 @@ class SkipNullsIterator {
     return PointerWrapper(iter_.value());
   }
 
-  bool operator<(const Iterator& rhs) const {
-    return iter_ < rhs.iter_;
-  }
-
-  bool operator!=(const Iterator& rhs) const {
-    return iter_ != rhs.iter_;
-  }
-
   bool operator==(const Iterator& rhs) const {
     return iter_ == rhs.iter_;
   }
 
+  auto operator<=>(const Iterator& rhs) const {
+    return iter_ <=> rhs.iter_;
+  }
+
   // Implement post increment.
   Iterator operator++(int) {
     Iterator old = *this;
@@ -395,10 +362,6 @@ class OptionalAccessor {
     return true;
   }
 
-  bool operator!=(const OptionalAccessor& other) const {
-    return !(*this == other);
-  }
-
   bool has_value() const {
     return reader_->isSet(index_);
   }
@@ -427,7 +390,7 @@ class OptionalAccessor {
  private:
   const VectorReader<T>* reader_;
   // Index of element within the reader.
-  int64_t index_;
+  const int64_t index_;
 
   template <bool nullable, typename V>
   friend class ArrayView;
@@ -466,42 +429,16 @@ operator==(const OptionalAccessor<U>& lhs, const std::optional<T>& rhs) {
   return rhs == lhs;
 }
 
-template <typename T, typename U>
-typename std::enable_if_t<
-    std::is_trivially_constructible_v<typename VectorReader<U>::exec_in_t, T>,
-    bool>
-operator!=(const std::optional<T>& lhs, const OptionalAccessor<U>& rhs) {
-  return !(lhs == rhs);
-}
-
-template <typename U, typename T>
-typename std::enable_if_t<
-    std::is_trivially_constructible_v<typename VectorReader<U>::exec_in_t, T>,
-    bool>
-operator!=(const OptionalAccessor<U>& lhs, const std::optional<T>& rhs) {
-  return !(lhs == rhs);
-}
-
 template <typename T>
 bool operator==(std::nullopt_t, const OptionalAccessor<T>& rhs) {
   return !rhs.has_value();
 }
 
-template <typename T>
-bool operator!=(std::nullopt_t, const OptionalAccessor<T>& rhs) {
-  return rhs.has_value();
-}
-
 template <typename T>
 bool operator==(const OptionalAccessor<T>& lhs, std::nullopt_t) {
   return !lhs.has_value();
 }
 
-template <typename T>
-bool operator!=(const OptionalAccessor<T>& lhs, std::nullopt_t) {
-  return lhs.has_value();
-}
-
 // Allow comparing OptionalAccessor<T> with T::exec_t.
 template <typename T, typename U>
 typename std::enable_if_t<
@@ -519,22 +456,6 @@ operator==(const OptionalAccessor<U>& lhs, const T& rhs) {
   return rhs == lhs;
 }
 
-template <typename T, typename U>
-typename std::enable_if_t<
-    std::is_trivially_constructible_v<typename VectorReader<U>::exec_in_t, T>,
-    bool>
-operator!=(const T& lhs, const OptionalAccessor<U>& rhs) {
-  return !(lhs == rhs);
-}
-
-template <typename U, typename T>
-typename std::enable_if_t<
-    std::is_trivially_constructible_v<typename VectorReader<U>::exec_in_t, T>,
-    bool>
-operator!=(const OptionalAccessor<U>& lhs, const T& rhs) {
-  return !(lhs == rhs);
-}
-
 // Helper function that calls materialize on element if it's not primitive.
 template <typename VeloxType, typename T>
 auto materializeElement(const T& element) {
@@ -678,6 +599,7 @@ class ArrayView {
 
   materialize_t materialize() const {
     materialize_t result;
+    result.reserve(size_);
 
     for (const auto& element : *this) {
       if constexpr (returnsOptionalValues) {
@@ -785,9 +707,7 @@ class MapView {
     const KeyAccessor first;
     const ValueAccessor second;
 
-    bool operator==(const Element& other) const {
-      return first == other.first && second == other.second;
-    }
+    bool operator==(const Element& other) const = default;
 
     // T is pair like object.
     // TODO: compare is not defined for view types yet
@@ -796,11 +716,6 @@ class MapView {
       return first == other.first && second == other.second;
     }
 
-    template <typename T>
-    bool operator!=(const T& other) const {
-      return !(*this == other);
-    }
-
    private:
     // Helper functions to allow us to use "if constexpr" when initializing
     // the values.
@@ -1292,28 +1207,15 @@ class CustomTypeWithCustomComparisonView {
           type)
       : value_(value), type_(type) {}
 
-  bool operator!=(const CustomTypeWithCustomComparisonView<T>& other) const {
-    return type_->compare(value_, other.value_) != 0;
-  }
-
   bool operator==(const CustomTypeWithCustomComparisonView<T>& other) const {
     return type_->compare(value_, other.value_) == 0;
   }
 
-  bool operator<(const CustomTypeWithCustomComparisonView<T>& other) const {
-    return type_->compare(value_, other.value_) < 0;
-  }
-
-  bool operator>(const CustomTypeWithCustomComparisonView<T>& other) const {
-    return type_->compare(value_, other.value_) > 0;
-  }
-
-  bool operator<=(const CustomTypeWithCustomComparisonView<T>& other) const {
-    return type_->compare(value_, other.value_) <= 0;
-  }
-
-  bool operator>=(const CustomTypeWithCustomComparisonView<T>& other) const {
-    return type_->compare(value_, other.value_) >= 0;
+  auto operator<=>(const CustomTypeWithCustomComparisonView<T>& other) const {
+    const auto cmp = type_->compare(value_, other.value_);
+    return cmp < 0 ? std::strong_ordering::less
+        : cmp > 0  ? std::strong_ordering::greater
+                   : std::strong_ordering::equal;
   }
 
   uint64_t hash() const {
diff --git a/velox/expression/ComplexWriterTypes.h b/velox/expression/ComplexWriterTypes.h
index 1874d8c014b3..88f4cf40631c 100644
--- a/velox/expression/ComplexWriterTypes.h
+++ b/velox/expression/ComplexWriterTypes.h
@@ -48,7 +48,7 @@ class VectorWriterBase {
     offset_ = offset;
   }
   virtual void commit(bool isSet) = 0;
-  virtual void ensureSize(size_t size) = 0;
+  virtual void ensureSize(vector_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.
@@ -94,8 +94,16 @@ 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>;
+bool constexpr has_string_value =
+    std::is_same_v<V, Varchar> || std::is_same_v<V, Varbinary>;
+
+template <typename T, bool providesCustomComparison>
+bool constexpr has_string_value<CustomType<T, providesCustomComparison>> =
+    has_string_value<typename T::type>;
+
+template <typename V>
+bool constexpr provide_std_interface =
+    SimpleTypeTrait<V>::isPrimitiveType && !has_string_value<V>;
 
 // bool is an exception, it requires commit but also provides std::interface.
 template <typename V>
@@ -109,8 +117,7 @@ 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>;
+  static constexpr bool hasStringValue = has_string_value<V>;
 
  public:
   // Note: size is with respect to the current size of this array being written.
@@ -118,8 +125,14 @@ class ArrayWriter {
     auto currentSize = size + valuesOffset_;
 
     if (UNLIKELY(currentSize > elementsVectorCapacity_)) {
-      elementsVectorCapacity_ = std::pow(2, std::ceil(std::log2(currentSize)));
-      childWriter_->ensureSize(elementsVectorCapacity_);
+      const vector_size_t childCapacity =
+          std::pow(2, std::ceil(std::log2(currentSize)));
+      childWriter_->ensureSize(childCapacity);
+
+      // Only update capacity_ after the writer has been successfully resized
+      // to ensure it accurately reflects the size of the elements even in the
+      // presence of failures.
+      elementsVectorCapacity_ = childCapacity;
     }
   }
 
@@ -598,10 +611,16 @@ class MapWriter {
     auto currentSize = size + innerOffset_;
 
     if (UNLIKELY(currentSize > capacity_)) {
-      capacity_ = std::pow(2, std::ceil(std::log2(currentSize)));
+      const vector_size_t childCapacity =
+          std::pow(2, std::ceil(std::log2(currentSize)));
+
+      keysWriter_->ensureSize(childCapacity);
+      valuesWriter_->ensureSize(childCapacity);
 
-      keysWriter_->ensureSize(capacity_);
-      valuesWriter_->ensureSize(capacity_);
+      // Only update capacity_ after the writers have been successfully resized
+      // to ensure it accurately reflects the minimum size of keys and values
+      // even in the presence of failures.
+      capacity_ = childCapacity;
     }
   }
 
diff --git a/velox/expression/ConjunctExpr.cpp b/velox/expression/ConjunctExpr.cpp
index 90d49c5800f7..1dd98b461207 100644
--- a/velox/expression/ConjunctExpr.cpp
+++ b/velox/expression/ConjunctExpr.cpp
@@ -105,7 +105,7 @@ void ConjunctExpr::evalSpecialForm(
     rows.clearNulls(nulls);
   }
   // Initialize result to all true for AND and all false for OR.
-  auto values = flatResult->mutableValues(rows.end())->asMutable<uint64_t>();
+  auto values = flatResult->mutableValues()->asMutable<uint64_t>();
   if (isAnd_) {
     bits::orBits(values, rows.asRange().bits(), rows.begin(), rows.end());
   } else {
diff --git a/velox/expression/ConjunctExpr.h b/velox/expression/ConjunctExpr.h
index 2ad9a1c4fd78..ba3135f11103 100644
--- a/velox/expression/ConjunctExpr.h
+++ b/velox/expression/ConjunctExpr.h
@@ -16,14 +16,12 @@
 #pragma once
 
 #include "velox/common/base/SelectivityInfo.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/FunctionCallToSpecialForm.h"
 #include "velox/expression/SpecialForm.h"
 
 namespace facebook::velox::exec {
 
-constexpr const char* kAnd = "and";
-constexpr const char* kOr = "or";
-
 class ConjunctExpr : public SpecialForm {
  public:
   ConjunctExpr(
@@ -32,9 +30,10 @@ class ConjunctExpr : public SpecialForm {
       bool isAnd,
       bool inputsSupportFlatNoNullsFastPath)
       : SpecialForm(
+            isAnd ? SpecialFormKind::kAnd : SpecialFormKind::kOr,
             std::move(type),
             std::move(inputs),
-            isAnd ? kAnd : kOr,
+            isAnd ? expression::kAnd : expression::kOr,
             inputsSupportFlatNoNullsFastPath,
             false /* trackCpuUsage */),
         isAnd_(isAnd) {
@@ -123,7 +122,7 @@ class ConjunctCallToSpecialForm : public FunctionCallToSpecialForm {
       const core::QueryConfig& config) override;
 
  private:
-  bool isAnd_;
+  const bool isAnd_;
 };
 
 } // namespace facebook::velox::exec
diff --git a/velox/expression/ConjunctRewrite.cpp b/velox/expression/ConjunctRewrite.cpp
new file mode 100644
index 000000000000..cb0ed3873b2a
--- /dev/null
+++ b/velox/expression/ConjunctRewrite.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 <set>
+
+#include "velox/expression/ConjunctRewrite.h"
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/expression/ExprUtils.h"
+
+namespace facebook::velox::expression {
+
+core::TypedExprPtr ConjunctRewrite::rewrite(const core::TypedExprPtr& expr) {
+  if (!expr->isCallKind()) {
+    return nullptr;
+  }
+
+  const auto* callExpr = expr->asUnchecked<core::CallTypedExpr>();
+  const bool conjunct = callExpr->name() == kAnd;
+  const bool disjunct = callExpr->name() == kOr;
+  if (!conjunct && !disjunct) {
+    return nullptr;
+  }
+
+  std::vector<core::TypedExprPtr> flat;
+  utils::flattenInput(expr, callExpr->name(), flat);
+  std::vector<core::TypedExprPtr> optimizedInputs;
+  bool nullInput = false;
+
+  for (const auto& input : flat) {
+    if (input->isConstantKind()) {
+      const auto* constInput = input->asUnchecked<core::ConstantTypedExpr>();
+      if (auto boolInput = constInput->toBool()) {
+        if (!boolInput.value() && conjunct) {
+          return input;
+        }
+        if (boolInput.value() && disjunct) {
+          return input;
+        }
+      } else if (!nullInput) {
+        nullInput = true;
+        optimizedInputs.push_back(input);
+      }
+    } else {
+      optimizedInputs.push_back(input);
+    }
+  }
+
+  // optimizedInputs can be empty for expressions like `true OR true`, returns
+  // the first input in this case.
+  if (optimizedInputs.empty()) {
+    return expr->inputs().front();
+  }
+  if (optimizedInputs.size() == 1) {
+    return optimizedInputs.front();
+  }
+  return std::make_shared<core::CallTypedExpr>(
+      expr->type(), std::move(optimizedInputs), callExpr->name());
+}
+
+void ConjunctRewrite::registerRewrite() {
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      expression::ConjunctRewrite::rewrite);
+}
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ConjunctRewrite.h b/velox/expression/ConjunctRewrite.h
new file mode 100644
index 000000000000..163c7eb51be3
--- /dev/null
+++ b/velox/expression/ConjunctRewrite.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.
+ */
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression {
+
+class ConjunctRewrite {
+ public:
+  /// Rewrites special forms AND and OR. First, nested AND, OR special forms
+  /// are flattened recursively, eg: a AND (b AND (c AND d)) -> AND(a, b, c, d).
+  /// Then, tries to short circuit expression evaluation by rewriting AND and OR
+  /// special forms to `false` and `true` respectively if this is one of
+  /// the inputs. If expression could not be short-circuited, inputs to AND and
+  /// OR conjuncts that are `true` and `false` respectively are pruned. If there
+  /// is only one input to the conjunct after its inputs are pruned, rewrites
+  /// the conjunct expression to this input. Otherwise, returns an optimized
+  /// conjunct expression with pruned inputs.
+  static core::TypedExprPtr rewrite(const core::TypedExprPtr& expr);
+
+  static void registerRewrite();
+};
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ConstantExpr.cpp b/velox/expression/ConstantExpr.cpp
index 397699644f84..a66798dbb6de 100644
--- a/velox/expression/ConstantExpr.cpp
+++ b/velox/expression/ConstantExpr.cpp
@@ -21,19 +21,7 @@ void ConstantExpr::evalSpecialForm(
     const SelectivityVector& rows,
     EvalCtx& context,
     VectorPtr& result) {
-  if (sharedConstantValue_.use_count() == 1) {
-    sharedConstantValue_->resize(rows.end());
-  } else {
-    // By reassigning sharedConstantValue_ we increase the chances that it will
-    // be unique the next time this expression is evaluated.
-    sharedConstantValue_ =
-        BaseVector::wrapInConstant(rows.end(), 0, sharedConstantValue_);
-  }
-
   if (needToSetIsAscii_) {
-    // sharedConstantValue_ must be unique because computeAndSetIsAscii may
-    // modify it.
-    VELOX_CHECK_EQ(sharedConstantValue_.use_count(), 1);
     auto* vector =
         sharedConstantValue_->asUnchecked<SimpleVector<StringView>>();
     LocalSingleRow singleRow(context, 0);
@@ -42,6 +30,15 @@ void ConstantExpr::evalSpecialForm(
     needToSetIsAscii_ = false;
   }
 
+  if (sharedConstantValue_.use_count() == 1) {
+    sharedConstantValue_->resize(rows.end());
+  } else {
+    // By reassigning sharedConstantValue_ we increase the chances that it will
+    // be unique the next time this expression is evaluated.
+    sharedConstantValue_ =
+        BaseVector::wrapInConstant(rows.end(), 0, sharedConstantValue_);
+  }
+
   context.moveOrCopyResult(sharedConstantValue_, rows, result);
 }
 
diff --git a/velox/expression/ConstantExpr.h b/velox/expression/ConstantExpr.h
index f72328230215..9e524b801802 100644
--- a/velox/expression/ConstantExpr.h
+++ b/velox/expression/ConstantExpr.h
@@ -22,6 +22,7 @@ class ConstantExpr : public SpecialForm {
  public:
   explicit ConstantExpr(VectorPtr value)
       : SpecialForm(
+            SpecialFormKind::kConstant,
             value->type(),
             std::vector<ExprPtr>(),
             "literal",
@@ -29,10 +30,7 @@ class ConstantExpr : public SpecialForm {
             false /* trackCpuUsage */),
         needToSetIsAscii_{value->type()->isVarchar()} {
     VELOX_CHECK_EQ(value->encoding(), VectorEncoding::Simple::CONSTANT);
-    // sharedConstantValue_ may be modified so we should take our own copy to
-    // prevent sharing across threads.
-    sharedConstantValue_ =
-        BaseVector::wrapInConstant(1, 0, std::move(value), true);
+    sharedConstantValue_ = std::move(value);
   }
 
   void evalSpecialForm(
diff --git a/velox/expression/DecodedArgs.h b/velox/expression/DecodedArgs.h
index cfe791293eef..ff44765b702e 100644
--- a/velox/expression/DecodedArgs.h
+++ b/velox/expression/DecodedArgs.h
@@ -36,6 +36,7 @@ class DecodedArgs {
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       exec::EvalCtx& context) {
+    holders_.reserve(args.size());
     for (auto& arg : args) {
       holders_.emplace_back(context, *arg, rows);
     }
diff --git a/velox/expression/EvalCtx.cpp b/velox/expression/EvalCtx.cpp
index f380daa59fa5..ac6cc68aea42 100644
--- a/velox/expression/EvalCtx.cpp
+++ b/velox/expression/EvalCtx.cpp
@@ -17,16 +17,22 @@
 #include "velox/expression/EvalCtx.h"
 #include <exception>
 #include "velox/common/testutil/TestValue.h"
-#include "velox/core/QueryConfig.h"
-#include "velox/expression/Expr.h"
 #include "velox/expression/PeeledEncoding.h"
+#include "velox/vector/LazyVector.h"
 
 using facebook::velox::common::testutil::TestValue;
 
 namespace facebook::velox::exec {
 
-EvalCtx::EvalCtx(core::ExecCtx* execCtx, ExprSet* exprSet, const RowVector* row)
-    : execCtx_(execCtx), exprSet_(exprSet), row_(row) {
+EvalCtx::EvalCtx(
+    core::ExecCtx* execCtx,
+    ExprSet* exprSet,
+    const RowVector* row,
+    bool lazyDereference)
+    : execCtx_(execCtx),
+      exprSet_(exprSet),
+      row_(row),
+      lazyDereference_(lazyDereference) {
   // TODO Change the API to replace raw pointers with non-const references.
   // Sanity check inputs to prevent crashes.
   VELOX_CHECK_NOT_NULL(execCtx);
@@ -44,7 +50,10 @@ EvalCtx::EvalCtx(core::ExecCtx* execCtx, ExprSet* exprSet, const RowVector* row)
 }
 
 EvalCtx::EvalCtx(core::ExecCtx* execCtx)
-    : execCtx_(execCtx), exprSet_(nullptr), row_(nullptr) {
+    : execCtx_(execCtx),
+      exprSet_(nullptr),
+      row_(nullptr),
+      lazyDereference_(false) {
   VELOX_CHECK_NOT_NULL(execCtx);
   inputFlatNoNulls_ = false;
 }
@@ -183,6 +192,25 @@ void EvalCtx::setStatus(vector_size_t index, const Status& status) {
   }
 }
 
+void EvalCtx::setStatuses(const SelectivityVector& rows, const Status& status) {
+  VELOX_CHECK(!status.ok(), "Status must be an error");
+  if (status.isUserError()) {
+    if (throwOnError_) {
+      VELOX_USER_FAIL(status.message());
+    }
+
+    if (captureErrorDetails_) {
+      auto veloxException = toVeloxUserError(status.message());
+      rows.applyToSelected(
+          [&](auto row) { addError(row, veloxException, errors_); });
+    } else {
+      rows.applyToSelected([&](auto row) { addError(row, errors_); });
+    }
+  } else {
+    VELOX_FAIL(status.message());
+  }
+}
+
 void EvalCtx::setError(
     vector_size_t index,
     const std::exception_ptr& exceptionPtr) {
@@ -294,6 +322,7 @@ const VectorPtr& EvalCtx::getField(int32_t index) const {
 VectorPtr EvalCtx::ensureFieldLoaded(
     int32_t index,
     const SelectivityVector& rows) {
+  VELOX_CHECK(!lazyDereference_);
   auto field = getField(index);
   if (isLazyNotLoaded(*field)) {
     const auto& rowsToLoad = isFinalSelection_ ? rows : *finalSelection_;
@@ -333,7 +362,7 @@ VectorPtr extendSizeByWrappingInDictionary(
   VELOX_DCHECK(
       !vector->type()->isPrimitiveType(), "Only used for complex types.");
   BufferPtr indices = allocateIndices(targetSize, context.pool());
-  auto rawIndices = indices->asMutable<vector_size_t>();
+  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
diff --git a/velox/expression/EvalCtx.h b/velox/expression/EvalCtx.h
index 3df8ac2cfd78..e2c23297b117 100644
--- a/velox/expression/EvalCtx.h
+++ b/velox/expression/EvalCtx.h
@@ -23,7 +23,6 @@
 #include "velox/common/base/Portability.h"
 #include "velox/core/QueryCtx.h"
 #include "velox/vector/ComplexVector.h"
-#include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::exec {
 
@@ -219,7 +218,11 @@ using EvalErrorsPtr = std::shared_ptr<EvalErrors>;
 // flags for Expr interpreter.
 class EvalCtx {
  public:
-  EvalCtx(core::ExecCtx* execCtx, ExprSet* exprSet, const RowVector* row);
+  EvalCtx(
+      core::ExecCtx* execCtx,
+      ExprSet* exprSet,
+      const RowVector* row,
+      bool lazyDereference = false);
 
   /// For testing only.
   explicit EvalCtx(core::ExecCtx* execCtx);
@@ -263,6 +266,7 @@ class EvalCtx {
 
   // @param status Must indicate an error. Cannot be "ok".
   void setStatus(vector_size_t index, const Status& status);
+  void setStatuses(const SelectivityVector& rows, const Status& status);
 
   // If exceptionPtr is known to be a VeloxException use setVeloxExceptionError
   // instead.
@@ -425,8 +429,8 @@ class EvalCtx {
     return &isFinalSelection_;
   }
 
-  const SelectivityVector* FOLLY_NULLABLE* FOLLY_NONNULL
-  mutableFinalSelection() {
+  const SelectivityVector * FOLLY_NULLABLE *
+      FOLLY_NONNULL mutableFinalSelection() {
     return &finalSelection_;
   }
 
@@ -442,6 +446,15 @@ class EvalCtx {
     return exprSet_;
   }
 
+  /// By default (when this is false), lazy vectors are all loaded at beginning
+  /// of evaluation.  When this is true, the evalution should contain only field
+  /// references, and we only load the lazy vector when we take a child from it,
+  /// and we keep the output child lazy as well.  This is used to maximize
+  /// parallelism in ParallelProject.
+  bool lazyDereference() const {
+    return lazyDereference_;
+  }
+
   VectorEncoding::Simple wrapEncoding() const;
 
   void setPeeledEncoding(std::shared_ptr<PeeledEncoding>& peel) {
@@ -552,7 +565,7 @@ class EvalCtx {
   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.
+  // occurred 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'.
@@ -567,6 +580,7 @@ class EvalCtx {
   core::ExecCtx* const execCtx_;
   ExprSet* const exprSet_;
   const RowVector* row_;
+  const bool lazyDereference_;
   bool inputFlatNoNulls_;
 
   // Corresponds 1:1 to children of 'row_'. Set to an inner vector
@@ -769,40 +783,40 @@ class LocalSelectivityVector {
 
 class LocalDecodedVector {
  public:
-  explicit LocalDecodedVector(core::ExecCtx& context) : context_(context) {}
+  explicit LocalDecodedVector(core::ExecCtx& context) : context_(&context) {}
 
-  explicit LocalDecodedVector(EvalCtx& context)
-      : context_(*context.execCtx()) {}
+  explicit LocalDecodedVector(EvalCtx& evalCtx) : context_(evalCtx.execCtx()) {}
 
-  explicit LocalDecodedVector(EvalCtx* context)
-      : LocalDecodedVector(*context) {}
+  explicit LocalDecodedVector(EvalCtx* evalCtx)
+      : context_(evalCtx ? evalCtx->execCtx() : nullptr) {}
 
   LocalDecodedVector(
       const EvalCtx& context,
       const BaseVector& vector,
       const SelectivityVector& rows,
       bool loadLazy = true)
-      : context_(*context.execCtx()) {
+      : context_(context.execCtx()) {
     get()->decode(vector, rows, loadLazy);
   }
 
   LocalDecodedVector(LocalDecodedVector&& other) noexcept
       : context_{other.context_}, vector_{std::move(other.vector_)} {}
 
-  void operator=(LocalDecodedVector&& other) {
+  void operator=(LocalDecodedVector&& other) noexcept {
     context_ = other.context_;
     vector_ = std::move(other.vector_);
   }
 
   ~LocalDecodedVector() {
-    if (vector_) {
-      context_.get().releaseDecodedVector(std::move(vector_));
+    if (vector_ && context_) {
+      context_->releaseDecodedVector(std::move(vector_));
     }
   }
 
   DecodedVector* get() {
     if (!vector_) {
-      vector_ = context_.get().getDecodedVector();
+      vector_ = context_ ? context_->getDecodedVector()
+                         : std::make_unique<DecodedVector>();
     }
     return vector_.get();
   }
@@ -829,7 +843,7 @@ class LocalDecodedVector {
   }
 
  private:
-  std::reference_wrapper<core::ExecCtx> context_;
+  core::ExecCtx* context_;
   std::unique_ptr<DecodedVector> vector_;
 };
 
diff --git a/velox/expression/Expr.cpp b/velox/expression/Expr.cpp
index cdbaea9e24c2..e2481f2eab22 100644
--- a/velox/expression/Expr.cpp
+++ b/velox/expression/Expr.cpp
@@ -16,22 +16,22 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
-#include <fstream>
 
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Fs.h"
 #include "velox/common/base/SuccinctPrinter.h"
 #include "velox/common/process/ThreadDebugInfo.h"
 #include "velox/common/testutil/TestValue.h"
-#include "velox/core/Expressions.h"
 #include "velox/expression/CastExpr.h"
 #include "velox/expression/ConstantExpr.h"
 #include "velox/expression/Expr.h"
 #include "velox/expression/ExprCompiler.h"
 #include "velox/expression/FieldReference.h"
+#include "velox/expression/LambdaExpr.h"
 #include "velox/expression/PeeledEncoding.h"
 #include "velox/expression/ScopedVarSetter.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/vector/LazyVector.h"
 #include "velox/vector/SelectivityVector.h"
 #include "velox/vector/VectorSaver.h"
 
@@ -41,6 +41,27 @@ DECLARE_bool(force_eval_simplified);
 DECLARE_bool(velox_experimental_save_input_on_fatal_signal);
 
 namespace facebook::velox::exec {
+
+namespace {
+const auto& specialFormNames() {
+  static const folly::F14FastMap<SpecialFormKind, std::string_view> kNames = {
+      {SpecialFormKind::kFieldAccess, "FIELD"},
+      {SpecialFormKind::kConstant, "CONSTANT"},
+      {SpecialFormKind::kCast, "CAST"},
+      {SpecialFormKind::kCoalesce, "COALESCE"},
+      {SpecialFormKind::kSwitch, "SWITCH"},
+      {SpecialFormKind::kLambda, "LAMBDA"},
+      {SpecialFormKind::kTry, "TRY"},
+      {SpecialFormKind::kAnd, "AND"},
+      {SpecialFormKind::kOr, "OR"},
+      {SpecialFormKind::kCustom, "CUSTOM"},
+  };
+  return kNames;
+}
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(SpecialFormKind, specialFormNames);
+
 folly::Synchronized<std::vector<std::shared_ptr<ExprSetListener>>>&
 exprSetListeners() {
   static folly::Synchronized<std::vector<std::shared_ptr<ExprSetListener>>>
@@ -121,7 +142,7 @@ Expr::Expr(
       name_(std::move(name)),
       vectorFunction_(std::move(vectorFunction)),
       vectorFunctionMetadata_{std::move(metadata)},
-      specialForm_{false},
+      specialFormKind_{std::nullopt},
       supportsFlatNoNullsFastPath_{
           vectorFunction_->supportsFlatNoNullsFastPath() &&
           type_->isPrimitiveType() && type_->isFixedWidth() &&
@@ -234,7 +255,11 @@ void Expr::computeMetadata() {
   // a special form, and all its inputs are also deterministic.
   deterministic_ = isCurrentFunctionDeterministic();
   for (auto& input : inputs_) {
-    deterministic_ &= input->deterministic_;
+    if (auto* lambda = input->as<LambdaExpr>()) {
+      deterministic_ &= lambda->body()->isDeterministic();
+    } else {
+      deterministic_ &= input->deterministic_;
+    }
   }
 
   // (2) Compute distinctFields_ and multiplyReferencedFields_.
@@ -810,7 +835,10 @@ void Expr::eval(
   // different subset.
   //
   // TODO: Re-work the logic of deciding when to load which field.
-  if (!hasConditionals_ || distinctFields_.size() == 1 ||
+  if (context.lazyDereference()) {
+    // Do not load any lazy.
+  } else if (
+      !hasConditionals_ || distinctFields_.size() == 1 ||
       shouldEvaluateSharedSubexp(context) ||
       !context.deferredLazyLoadingEnabled()) {
     // Load lazy vectors if any.
@@ -1192,20 +1220,36 @@ void Expr::evalWithMemo(
   VectorPtr base;
   distinctFields_[0]->evalSpecialForm(rows, context, base);
 
+  // evalWithNulls may throw an exception. If this happens during constant
+  // folding, the exception is suppressed and the Expr object may be reused.
+  // Hence, it is important to update state in way that ensure "valid" state in
+  // case of exceptions.
+  //
+  // Also, note that the same expression running on same data may pass or may
+  // fail depending on whether it runs under TRY or not.
+  //
+  // An example expression that triggers these edge cases:
+  //
+  //    try(coalesce(array_min_by(array[1, 2, 3], x -> x / 0), 0::INTEGER))
+
   if (base.get() != baseOfDictionaryRawPtr_ ||
       baseOfDictionaryWeakPtr_.expired()) {
     baseOfDictionaryRepeats_ = 0;
-    baseOfDictionaryWeakPtr_ = base;
-    baseOfDictionaryRawPtr_ = base.get();
+    baseOfDictionaryWeakPtr_.reset();
+    baseOfDictionaryRawPtr_ = nullptr;
     context.releaseVector(baseOfDictionary_);
     context.releaseVector(dictionaryCache_);
+
     evalWithNulls(rows, context, result);
+    baseOfDictionaryWeakPtr_ = base;
+    baseOfDictionaryRawPtr_ = base.get();
     return;
   }
-  ++baseOfDictionaryRepeats_;
 
-  if (baseOfDictionaryRepeats_ == 1) {
+  if (baseOfDictionaryRepeats_ == 0) {
     evalWithNulls(rows, context, result);
+
+    ++baseOfDictionaryRepeats_;
     baseOfDictionary_ = base;
     dictionaryCache_ = result;
     if (!cachedDictionaryIndices_) {
@@ -1217,6 +1261,8 @@ void Expr::evalWithMemo(
     return;
   }
 
+  ++baseOfDictionaryRepeats_;
+
   if (cachedDictionaryIndices_) {
     LocalSelectivityVector cachedHolder(context, rows);
     auto cached = cachedHolder.get();
@@ -1242,31 +1288,34 @@ void Expr::evalWithMemo(
 
     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);
-    }
+    if (uncached->hasSelections()) {
+      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);
+      cachedDictionaryIndices_->select(*uncached);
 
-    // Resize the dictionaryCache_ to accommodate all the necessary rows.
-    if (dictionaryCache_->size() < uncached->end()) {
-      dictionaryCache_->resize(uncached->end());
+      // Resize the dictionaryCache_ to accommodate all the necessary rows.
+      if (dictionaryCache_->size() < uncached->end()) {
+        dictionaryCache_->resize(uncached->end());
+      }
+      dictionaryCache_->copy(result.get(), *uncached, nullptr);
     }
-    dictionaryCache_->copy(result.get(), *uncached, nullptr);
   }
   context.releaseVector(base);
 }
@@ -1656,16 +1705,8 @@ void Expr::appendInputsSql(
   }
 }
 
-bool Expr::isConstant() const {
-  if (!isDeterministic()) {
-    return false;
-  }
-  for (auto& input : inputs_) {
-    if (!input->is<ConstantExpr>()) {
-      return false;
-    }
-  }
-  return true;
+bool Expr::isConstantExpr() const {
+  return isDeterministic() && distinctFields_.empty();
 }
 
 namespace {
@@ -1708,24 +1749,29 @@ common::Subfield extractSubfield(
     }
     switch (index->value()->typeKind()) {
       case TypeKind::TINYINT:
-        path.push_back(std::make_unique<common::Subfield::LongSubscript>(
-            index->value()->as<ConstantVector<int8_t>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::LongSubscript>(
+                index->value()->as<ConstantVector<int8_t>>()->value()));
         break;
       case TypeKind::SMALLINT:
-        path.push_back(std::make_unique<common::Subfield::LongSubscript>(
-            index->value()->as<ConstantVector<int16_t>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::LongSubscript>(
+                index->value()->as<ConstantVector<int16_t>>()->value()));
         break;
       case TypeKind::INTEGER:
-        path.push_back(std::make_unique<common::Subfield::LongSubscript>(
-            index->value()->as<ConstantVector<int32_t>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::LongSubscript>(
+                index->value()->as<ConstantVector<int32_t>>()->value()));
         break;
       case TypeKind::BIGINT:
-        path.push_back(std::make_unique<common::Subfield::LongSubscript>(
-            index->value()->as<ConstantVector<int64_t>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::LongSubscript>(
+                index->value()->as<ConstantVector<int64_t>>()->value()));
         break;
       case TypeKind::VARCHAR:
-        path.push_back(std::make_unique<common::Subfield::StringSubscript>(
-            index->value()->as<ConstantVector<StringView>>()->value()));
+        path.push_back(
+            std::make_unique<common::Subfield::StringSubscript>(std::string(
+                index->value()->as<ConstantVector<StringView>>()->value())));
         break;
       default:
         return {};
@@ -1756,12 +1802,57 @@ std::vector<common::Subfield> Expr::extractSubfields() const {
   return subfields;
 }
 
+namespace {
+
+// Make sure there are only FieldReferences, and there is no overlap between the
+// output of expressions.
+void validateLazyDereference(const std::vector<std::shared_ptr<Expr>>& exprs) {
+#ifndef NDEBUG
+  std::vector<std::vector<std::string>> paths;
+  for (auto& expr : exprs) {
+    std::vector<std::string> path;
+    auto* fieldRef = dynamic_cast<const FieldReference*>(expr.get());
+    VELOX_CHECK_NOT_NULL(fieldRef);
+    path.push_back(fieldRef->field());
+    while (!fieldRef->inputs().empty()) {
+      VELOX_CHECK_EQ(fieldRef->inputs().size(), 1);
+      fieldRef =
+          dynamic_cast<const FieldReference*>(fieldRef->inputs()[0].get());
+      VELOX_CHECK_NOT_NULL(fieldRef);
+      path.push_back(fieldRef->field());
+    }
+    std::reverse(path.begin(), path.end());
+    paths.push_back(std::move(path));
+  }
+  std::sort(paths.begin(), paths.end());
+  for (int i = 1; i < paths.size(); ++i) {
+    if (paths[i - 1].size() > paths[i].size()) {
+      continue;
+    }
+    bool isPrefix = true;
+    for (int j = 0; j < paths[i - 1].size(); ++j) {
+      if (paths[i - 1][j] != paths[i][j]) {
+        isPrefix = false;
+        break;
+      }
+    }
+    VELOX_CHECK(!isPrefix);
+  }
+#endif
+}
+
+} // namespace
+
 ExprSet::ExprSet(
     const std::vector<core::TypedExprPtr>& sources,
     core::ExecCtx* execCtx,
-    bool enableConstantFolding)
-    : execCtx_(execCtx) {
+    bool enableConstantFolding,
+    bool lazyDereference)
+    : execCtx_(execCtx), lazyDereference_(lazyDereference) {
   exprs_ = compileExpressions(sources, execCtx, this, enableConstantFolding);
+  if (lazyDereference_) {
+    validateLazyDereference(exprs_);
+  }
   std::vector<FieldReference*> allDistinctFields;
   for (auto& expr : exprs_) {
     Expr::mergeFields(
@@ -1773,7 +1864,8 @@ namespace {
 void addStats(
     const exec::Expr& expr,
     std::unordered_map<std::string, exec::ExprStats>& stats,
-    std::unordered_set<const exec::Expr*>& uniqueExprs) {
+    std::unordered_set<const exec::Expr*>& uniqueExprs,
+    bool excludeSpecialForm) {
   auto it = uniqueExprs.find(&expr);
   if (it != uniqueExprs.end()) {
     // Common sub-expression. Skip to avoid double counting.
@@ -1782,13 +1874,16 @@ void addStats(
 
   uniqueExprs.insert(&expr);
 
+  bool excludeSplFormExpr = excludeSpecialForm && expr.isSpecialForm();
   // Do not aggregate empty stats.
-  if (expr.stats().numProcessedRows || expr.stats().defaultNullRowsSkipped) {
+  bool emptyStats =
+      !expr.stats().numProcessedRows && !expr.stats().defaultNullRowsSkipped;
+  if (!emptyStats && !excludeSplFormExpr) {
     stats[expr.name()].add(expr.stats());
   }
 
   for (const auto& input : expr.inputs()) {
-    addStats(*input, stats, uniqueExprs);
+    addStats(*input, stats, uniqueExprs, excludeSpecialForm);
   }
 }
 
@@ -1797,11 +1892,12 @@ std::string makeUuid() {
 }
 } // namespace
 
-std::unordered_map<std::string, exec::ExprStats> ExprSet::stats() const {
+std::unordered_map<std::string, exec::ExprStats> ExprSet::stats(
+    bool excludeSpecialForm) const {
   std::unordered_map<std::string, exec::ExprStats> stats;
   std::unordered_set<const exec::Expr*> uniqueExprs;
   for (const auto& expr : exprs()) {
-    addStats(*expr, stats, uniqueExprs);
+    addStats(*expr, stats, uniqueExprs, excludeSpecialForm);
   }
 
   return stats;
@@ -1902,20 +1998,23 @@ void ExprSet::eval(
     const SelectivityVector& rows,
     EvalCtx& context,
     std::vector<VectorPtr>& result) {
+  VELOX_CHECK_EQ(lazyDereference_, context.lazyDereference());
   result.resize(exprs_.size());
   if (initialize) {
     clearSharedSubexprs();
   }
 
-  // Make sure LazyVectors, referenced by multiple expressions, are loaded
-  // for all the "rows".
-  //
-  // Consider projection with 2 expressions: f(a) AND g(b), h(b)
-  // If b is a LazyVector and f(a) AND g(b) expression is evaluated first, it
-  // will load b only for rows where f(a) is true. However, h(b) projection
-  // needs all rows for "b".
-  for (const auto& field : multiplyReferencedFields_) {
-    context.ensureFieldLoaded(field->index(context), rows);
+  if (!lazyDereference_) {
+    // Make sure LazyVectors, referenced by multiple expressions, are loaded for
+    // all the "rows".
+    //
+    // Consider projection with 2 expressions: f(a) AND g(b), h(b) If b is a
+    // LazyVector and f(a) AND g(b) expression is evaluated first, it will load
+    // b only for rows where f(a) is true. However, h(b) projection needs all
+    // rows for "b".
+    for (const auto& field : multiplyReferencedFields_) {
+      context.ensureFieldLoaded(field->index(context), rows);
+    }
   }
 
   if (FLAGS_velox_experimental_save_input_on_fatal_signal) {
@@ -1952,8 +2051,7 @@ void ExprSet::clear() {
   for (auto* memo : memoizingExprs_) {
     memo->clearMemo();
   }
-  distinctFields_.clear();
-  multiplyReferencedFields_.clear();
+  memoizingExprs_.clear();
 }
 
 void ExprSet::clearCache() {
@@ -1980,12 +2078,14 @@ void ExprSetSimplified::eval(
 
 std::unique_ptr<ExprSet> makeExprSetFromFlag(
     std::vector<core::TypedExprPtr>&& source,
-    core::ExecCtx* execCtx) {
+    core::ExecCtx* execCtx,
+    bool lazyDereference) {
   if (execCtx->queryCtx()->queryConfig().exprEvalSimplified() ||
       FLAGS_force_eval_simplified) {
     return std::make_unique<ExprSetSimplified>(std::move(source), execCtx);
   }
-  return std::make_unique<ExprSet>(std::move(source), execCtx);
+  return std::make_unique<ExprSet>(
+      std::move(source), execCtx, true, lazyDereference);
 }
 
 std::string printExprWithStats(const exec::ExprSet& exprSet) {
@@ -2012,6 +2112,15 @@ void SimpleExpressionEvaluator::evaluate(
   result = results[0];
 }
 
+void SimpleExpressionEvaluator::evaluate(
+    exec::ExprSet* exprSet,
+    const SelectivityVector& rows,
+    const RowVector& input,
+    std::vector<VectorPtr>& results) {
+  EvalCtx context(ensureExecCtx(), exprSet, &input);
+  exprSet->eval(0, exprSet->size(), true, rows, context, results);
+}
+
 core::ExecCtx* SimpleExpressionEvaluator::ensureExecCtx() {
   if (!execCtx_) {
     execCtx_ = std::make_unique<core::ExecCtx>(pool_, queryCtx_);
@@ -2019,20 +2128,57 @@ core::ExecCtx* SimpleExpressionEvaluator::ensureExecCtx() {
   return execCtx_.get();
 }
 
-VectorPtr evaluateConstantExpression(
+namespace {
+VectorPtr tryEvaluateConstantExpressionInternal(
     const core::TypedExprPtr& expr,
-    memory::MemoryPool* pool) {
-  auto data = BaseVector::create<RowVector>(ROW({}), 1, pool);
+    memory::MemoryPool* pool,
+    core::ExecCtx* execCtx,
+    bool suppressEvaluationFailures) {
+  // Disable constant folding to avoid an infinite loop between ExprOptimizer
+  // and ExprCompiler.
+  velox::exec::ExprSet exprSet(
+      {expr}, execCtx, /*enableConstantFolding*/ false);
+
+  // The construction of ExprSet involves compiling and constant folding the
+  // expression. If constant folding succeeded, then we get a ConstantExpr.
+  // Constant folding may fail because expression is not constant-foldable or if
+  // an error happened during evaluation (5 / 0 fails with "division by zero").
+  // If constant folding didn't succeed, but suppressEvaluationFailures is
+  // false, we need to re-evaluate the expression to propagate the failure.
+  const bool doEvaluate = exprSet.expr(0)->is<ConstantExpr>() ||
+      (!suppressEvaluationFailures && exprSet.expr(0)->isConstantExpr());
+
+  if (doEvaluate) {
+    auto data = BaseVector::create<RowVector>(ROW({}), 1, pool);
+    velox::exec::EvalCtx evalCtx(execCtx, &exprSet, data.get());
+    velox::SelectivityVector singleRow(1);
+    std::vector<velox::VectorPtr> results(1);
+    exprSet.eval(singleRow, evalCtx, results);
+    return results.at(0);
+  }
+
+  return nullptr;
+}
+} // namespace
 
-  auto queryCtx = velox::core::QueryCtx::create();
+VectorPtr tryEvaluateConstantExpression(
+    const core::TypedExprPtr& expr,
+    memory::MemoryPool* pool,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool suppressEvaluationFailures) {
   velox::core::ExecCtx execCtx{pool, queryCtx.get()};
-  velox::exec::ExprSet exprSet({expr}, &execCtx);
-  velox::exec::EvalCtx evalCtx(&execCtx, &exprSet, data.get());
+  return tryEvaluateConstantExpressionInternal(
+      expr, pool, &execCtx, suppressEvaluationFailures);
+}
 
-  velox::SelectivityVector singleRow(1);
-  std::vector<velox::VectorPtr> results(1);
-  exprSet.eval(singleRow, evalCtx, results);
-  return results.at(0);
+VectorPtr tryEvaluateConstantExpression(
+    const core::TypedExprPtr& expr,
+    memory::MemoryPool* pool,
+    core::QueryCtx* queryCtx,
+    bool suppressEvaluationFailures) {
+  velox::core::ExecCtx execCtx{pool, queryCtx};
+  return tryEvaluateConstantExpressionInternal(
+      expr, pool, &execCtx, suppressEvaluationFailures);
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/expression/Expr.h b/velox/expression/Expr.h
index 17ec0377ae60..94d574e85991 100644
--- a/velox/expression/Expr.h
+++ b/velox/expression/Expr.h
@@ -22,9 +22,8 @@
 
 #include "velox/common/time/CpuWallTimer.h"
 #include "velox/core/ExpressionEvaluator.h"
-#include "velox/core/Expressions.h"
-#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/EvalCtx.h"
+#include "velox/expression/ExprStats.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/type/Subfield.h"
 #include "velox/vector/SimpleVector.h"
@@ -35,38 +34,6 @@ class ExprSet;
 class FieldReference;
 class VectorFunction;
 
-struct ExprStats {
-  /// Requires QueryConfig.exprTrackCpuUsage() to be 'true'.
-  CpuWallTiming timing;
-
-  /// Number of processed rows.
-  uint64_t numProcessedRows{0};
-
-  /// Number of processed vectors / batches. Allows to compute average batch
-  /// size.
-  uint64_t numProcessedVectors{0};
-
-  /// Whether default-null behavior of an expression resulted in skipping
-  /// evaluation of rows.
-  bool defaultNullRowsSkipped{false};
-
-  void add(const ExprStats& other) {
-    timing.add(other.timing);
-    numProcessedRows += other.numProcessedRows;
-    numProcessedVectors += other.numProcessedVectors;
-    defaultNullRowsSkipped |= other.defaultNullRowsSkipped;
-  }
-
-  std::string toString() const {
-    return fmt::format(
-        "timing: {}, numProcessedRows: {}, numProcessedVectors: {}, defaultNullRowsSkipped: {}",
-        timing.toString(),
-        numProcessedRows,
-        numProcessedVectors,
-        defaultNullRowsSkipped ? "true" : "false");
-  }
-};
-
 /// Maintains a set of rows for evaluation and removes rows with
 /// nulls or errors as needed. Helps to avoid copying SelectivityVector in cases
 /// when evaluation doesn't encounter nulls or errors.
@@ -137,6 +104,21 @@ class MutableRemainingRows {
   LocalSelectivityVector mutableRowsHolder_;
 };
 
+enum class SpecialFormKind : int32_t {
+  kFieldAccess = 0,
+  kConstant = 1,
+  kCast = 2,
+  kCoalesce = 3,
+  kSwitch = 4,
+  kLambda = 5,
+  kTry = 6,
+  kAnd = 7,
+  kOr = 8,
+  kCustom = 999,
+};
+
+VELOX_DECLARE_ENUM_NAME(SpecialFormKind);
+
 // An executable expression.
 class Expr {
  public:
@@ -144,14 +126,14 @@ class Expr {
       TypePtr type,
       std::vector<std::shared_ptr<Expr>>&& inputs,
       std::string name,
-      bool specialForm,
+      std::optional<SpecialFormKind> specialFormKind,
       bool supportsFlatNoNullsFastPath,
       bool trackCpuUsage)
       : type_(std::move(type)),
         inputs_(std::move(inputs)),
         name_(std::move(name)),
         vectorFunction_(nullptr),
-        specialForm_{specialForm},
+        specialFormKind_{specialFormKind},
         supportsFlatNoNullsFastPath_{supportsFlatNoNullsFastPath},
         trackCpuUsage_{trackCpuUsage} {}
 
@@ -251,9 +233,9 @@ class Expr {
 
   void clearMemo() {
     baseOfDictionaryRepeats_ = 0;
-    baseOfDictionary_.reset();
-    baseOfDictionaryWeakPtr_.reset();
     baseOfDictionaryRawPtr_ = nullptr;
+    baseOfDictionaryWeakPtr_.reset();
+    baseOfDictionary_.reset();
     dictionaryCache_ = nullptr;
     cachedDictionaryIndices_ = nullptr;
   }
@@ -279,7 +261,51 @@ class Expr {
   }
 
   bool isSpecialForm() const {
-    return specialForm_;
+    return specialFormKind_.has_value();
+  }
+
+  SpecialFormKind specialFormKind() const {
+    return specialFormKind_.value();
+  }
+
+  bool isFieldAccess() const {
+    return specialFormKind_ == SpecialFormKind::kFieldAccess;
+  }
+
+  bool isConstant() const {
+    return specialFormKind_ == SpecialFormKind::kConstant;
+  }
+
+  bool isCast() const {
+    return specialFormKind_ == SpecialFormKind::kCast;
+  }
+
+  bool isCoalesce() const {
+    return specialFormKind_ == SpecialFormKind::kCoalesce;
+  }
+
+  bool isSwitch() const {
+    return specialFormKind_ == SpecialFormKind::kSwitch;
+  }
+
+  bool isLambda() const {
+    return specialFormKind_ == SpecialFormKind::kLambda;
+  }
+
+  bool isTry() const {
+    return specialFormKind_ == SpecialFormKind::kTry;
+  }
+
+  bool isAnd() const {
+    return specialFormKind_ == SpecialFormKind::kAnd;
+  }
+
+  bool isOr() const {
+    return specialFormKind_ == SpecialFormKind::kOr;
+  }
+
+  bool isCustom() const {
+    return specialFormKind_ == SpecialFormKind::kCustom;
   }
 
   virtual bool isConditional() const {
@@ -294,7 +320,7 @@ class Expr {
     return deterministic_;
   }
 
-  virtual bool isConstant() const;
+  virtual bool isConstantExpr() const;
 
   bool supportsFlatNoNullsFastPath() const {
     return supportsFlatNoNullsFastPath_;
@@ -583,7 +609,7 @@ class Expr {
   const std::string name_;
   const std::shared_ptr<VectorFunction> vectorFunction_;
   const VectorFunctionMetadata vectorFunctionMetadata_;
-  const bool specialForm_;
+  const std::optional<SpecialFormKind> specialFormKind_;
   const bool supportsFlatNoNullsFastPath_;
   const bool trackCpuUsage_;
 
@@ -713,7 +739,8 @@ class ExprSet {
   explicit ExprSet(
       const std::vector<core::TypedExprPtr>& source,
       core::ExecCtx* execCtx,
-      bool enableConstantFolding = true);
+      bool enableConstantFolding = true,
+      bool lazyDereference = false);
 
   virtual ~ExprSet();
 
@@ -761,6 +788,10 @@ class ExprSet {
     return distinctFields_;
   }
 
+  bool lazyDereference() const {
+    return lazyDereference_;
+  }
+
   // Flags a shared subexpression which needs to be reset (e.g. previously
   // computed results must be deleted) when evaluating new batch of data.
   void addToReset(const std::shared_ptr<Expr>& expr) {
@@ -781,8 +812,9 @@ class ExprSet {
   /// name. If a function or a special form occurs in the expression
   /// multiple times, the statistics will be aggregated across all calls.
   /// Statistics will be missing for functions and special forms that didn't get
-  /// evaluated.
-  std::unordered_map<std::string, exec::ExprStats> stats() const;
+  /// evaluated. If 'excludeSpecialForm' is true, special forms are excluded.
+  std::unordered_map<std::string, exec::ExprStats> stats(
+      bool excludeSpecialForm = false) const;
 
  protected:
   void clearSharedSubexprs();
@@ -802,6 +834,7 @@ class ExprSet {
   // Exprs which retain memoized state, e.g. from running over dictionaries.
   std::unordered_set<Expr*> memoizingExprs_;
   core::ExecCtx* const execCtx_;
+  const bool lazyDereference_;
 };
 
 class ExprSetSimplified : public ExprSet {
@@ -834,13 +867,30 @@ class ExprSetSimplified : public ExprSet {
 // account and instantiates the correct ExprSet class.
 std::unique_ptr<ExprSet> makeExprSetFromFlag(
     std::vector<core::TypedExprPtr>&& source,
-    core::ExecCtx* execCtx);
+    core::ExecCtx* execCtx,
+    bool lazyDereference = false);
+
+/// Evaluates a deterministic expression that doesn't depend on any inputs and
+/// returns the result as single-row vector. Returns nullptr if the expression
+/// is non-deterministic or has dependencies.
+///
+/// By default, propagates failures that occur during evaluation of the
+/// expression. For example, evaluating 5 / 0 throws "division by zero". If
+/// 'suppressEvaluationFailures' is true, these failures are swallowed and the
+/// caller receives a nullptr result.
+VectorPtr tryEvaluateConstantExpression(
+    const core::TypedExprPtr& expr,
+    memory::MemoryPool* pool,
+    const std::shared_ptr<core::QueryCtx>& queryCtx,
+    bool suppressEvaluationFailures = false);
 
-/// Evaluates an expression that doesn't depend on any inputs and returns the
-/// result as single-row vector.
-VectorPtr evaluateConstantExpression(
+/// Variant of `tryEvaluateConstantExpression` with a raw pointer to QueryCtx
+/// instead of a shared_ptr, used by `ExprOptimizer`.
+VectorPtr tryEvaluateConstantExpression(
     const core::TypedExprPtr& expr,
-    memory::MemoryPool* pool);
+    memory::MemoryPool* pool,
+    core::QueryCtx* queryCtx,
+    bool suppressEvaluationFailures);
 
 /// Returns a string representation of the expression trees annotated with
 /// runtime statistics. Expected to be called after calling ExprSet::eval one or
@@ -903,12 +953,23 @@ class SimpleExpressionEvaluator : public core::ExpressionEvaluator {
         std::vector<core::TypedExprPtr>{expression}, ensureExecCtx());
   }
 
+  std::unique_ptr<ExprSet> compile(
+      const std::vector<core::TypedExprPtr>& expressions) override {
+    return std::make_unique<ExprSet>(expressions, ensureExecCtx());
+  }
+
   void evaluate(
       ExprSet* exprSet,
       const SelectivityVector& rows,
       const RowVector& input,
       VectorPtr& result) override;
 
+  void evaluate(
+      exec::ExprSet* exprSet,
+      const SelectivityVector& rows,
+      const RowVector& input,
+      std::vector<VectorPtr>& results) override;
+
   memory::MemoryPool* pool() override {
     return pool_;
   }
diff --git a/velox/expression/ExprCompiler.cpp b/velox/expression/ExprCompiler.cpp
index a678509b4ba6..bfc17daf76f5 100644
--- a/velox/expression/ExprCompiler.cpp
+++ b/velox/expression/ExprCompiler.cpp
@@ -15,19 +15,16 @@
  */
 
 #include "velox/expression/ExprCompiler.h"
-#include "velox/expression/CastExpr.h"
-#include "velox/expression/CoalesceExpr.h"
-#include "velox/expression/ConjunctExpr.h"
 #include "velox/expression/ConstantExpr.h"
-#include "velox/expression/Expr.h"
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprOptimizer.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/expression/ExprUtils.h"
 #include "velox/expression/FieldReference.h"
 #include "velox/expression/LambdaExpr.h"
 #include "velox/expression/RowConstructor.h"
 #include "velox/expression/SimpleFunctionRegistry.h"
 #include "velox/expression/SpecialFormRegistry.h"
-#include "velox/expression/SwitchExpr.h"
-#include "velox/expression/TryExpr.h"
-#include "velox/expression/VectorFunction.h"
 
 namespace facebook::velox::exec {
 
@@ -36,27 +33,47 @@ namespace {
 using core::ITypedExpr;
 using core::TypedExprPtr;
 
-const char* const kAnd = "and";
-const char* const kOr = "or";
-
-struct ITypedExprHasher {
-  size_t operator()(const ITypedExpr* expr) const {
-    return expr->hash();
-  }
-};
-
-struct ITypedExprComparer {
-  bool operator()(const ITypedExpr* lhs, const ITypedExpr* rhs) const {
-    return *lhs == *rhs;
+/// Parses a comma-separated list of function names that should turn on CPU
+/// tracking.
+std::unordered_set<std::string> fetchCallExprNamesForCpuTracking(
+    const core::QueryConfig& queryConfig) {
+  std::vector<std::string> nameList;
+  folly::split(
+      ',', queryConfig.exprTrackCpuUsageForFunctions(), nameList, true);
+
+  std::unordered_set<std::string> result;
+  for (auto& name : nameList) {
+    // Sanitize function names.
+    folly::toLowerAscii(name);
+    if (!name.empty()) {
+      result.insert(std::move(name));
+    }
   }
-};
+  return result;
+}
 
 // Map for deduplicating ITypedExpr trees.
 using ExprDedupMap = folly::F14FastMap<
     const ITypedExpr*,
     std::shared_ptr<Expr>,
-    ITypedExprHasher,
-    ITypedExprComparer>;
+    core::ITypedExprHasher,
+    core::ITypedExprComparer>;
+
+struct CompilerCtx {
+  core::QueryCtx* queryCtx;
+  memory::MemoryPool* pool;
+
+  /// Whether to enable constant folding.
+  bool enableConstantFolding;
+
+  /// Names of simple or vector functions within the expression tree being
+  /// compiled that support flattening.
+  std::unordered_set<std::string> flatteningCandidates;
+
+  /// List of call expression names whose CPU usage should be tracked.
+  /// Extracted from the query config.
+  std::unordered_set<std::string> cpuUsageTrackingCandidates;
+};
 
 /// Represents a lexical scope. A top level scope corresponds to a top
 /// level Expr and is shared among the Exprs of the ExprSet. Each
@@ -86,7 +103,7 @@ struct Scope {
   std::vector<TypedExprPtr> rewrittenExpressions;
 
   Scope(std::vector<std::string>&& _locals, Scope* _parent, ExprSet* _exprSet)
-      : locals(_locals), parent(_parent), exprSet(_exprSet) {}
+      : locals(std::move(_locals)), parent(_parent), exprSet(_exprSet) {}
 
   void addCapture(FieldReference* reference, const ITypedExpr* fieldAccess) {
     capture.emplace_back(reference->field());
@@ -95,116 +112,62 @@ struct Scope {
   }
 };
 
-// Utility method to check eligibility for flattening.
-bool allInputTypesEquivalent(const TypedExprPtr& expr) {
-  const auto& inputs = expr->inputs();
-  for (int i = 1; i < inputs.size(); i++) {
-    if (!inputs[0]->type()->equivalent(*inputs[i]->type())) {
-      return false;
-    }
-  }
-  return true;
-}
-
 std::optional<std::string> shouldFlatten(
     const TypedExprPtr& expr,
     const std::unordered_set<std::string>& flatteningCandidates) {
-  if (auto call = std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
+  if (expr->isCallKind()) {
+    const auto* call = expr->asUnchecked<core::CallTypedExpr>();
     // Currently only supports the most common case for flattening where all
     // inputs are of the same type.
-    if (call->name() == kAnd || call->name() == kOr ||
+    if (call->name() == expression::kAnd || call->name() == expression::kOr ||
         (flatteningCandidates.count(call->name()) &&
-         allInputTypesEquivalent(expr))) {
+         expression::utils::allInputTypesEquivalent(expr))) {
       return call->name();
     }
   }
   return std::nullopt;
 }
 
-bool isCall(const TypedExprPtr& expr, const std::string& name) {
-  if (auto call = std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
-    return call->name() == name;
+ExprPtr getAlreadyCompiled(
+    const ITypedExpr* expr,
+    const core::QueryConfig& config,
+    ExprDedupMap* visited) {
+  auto iter = visited->find(expr);
+  if (iter == visited->end()) {
+    return nullptr;
   }
-  return false;
-}
 
-// Recursively flattens nested ANDs, ORs or eligible callable expressions into a
-// vector of their inputs. Recursive flattening ceases exploring an input branch
-// if it encounters either an expression different from 'flattenCall' or its
-// inputs are not the same type.
-// Examples:
-// flattenCall: AND
-// in: a AND (b AND (c AND d))
-// out: [a, b, c, d]
-//
-// flattenCall: OR
-// in: (a OR b) OR (c OR d)
-// out: [a, b, c, d]
-//
-// flattenCall: concat
-// in: (array1, concat(array2, concat(array2, intVal))
-// out: [array1, array2, concat(array2, intVal)]
-void flattenInput(
-    const TypedExprPtr& input,
-    const std::string& flattenCall,
-    std::vector<TypedExprPtr>& flat) {
-  if (isCall(input, flattenCall) && allInputTypesEquivalent(input)) {
-    for (auto& child : input->inputs()) {
-      flattenInput(child, flattenCall, flat);
-    }
-  } else {
-    flat.emplace_back(input);
+  const ExprPtr& alreadyCompiled = iter->second;
+  if (alreadyCompiled->isDeterministic()) {
+    return alreadyCompiled;
   }
-}
 
-ExprPtr getAlreadyCompiled(const ITypedExpr* expr, ExprDedupMap* visited) {
-  auto iter = visited->find(expr);
-  return iter == visited->end() ? nullptr : iter->second;
+  return config.exprDedupNonDeterministic() ? alreadyCompiled : nullptr;
 }
 
 ExprPtr compileExpression(
     const TypedExprPtr& expr,
     Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding);
+    const CompilerCtx& ctx);
 
-std::vector<ExprPtr> compileInputs(
-    const TypedExprPtr& expr,
-    Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding) {
+std::vector<ExprPtr>
+compileInputs(const TypedExprPtr& expr, Scope* scope, const CompilerCtx& ctx) {
   std::vector<ExprPtr> compiledInputs;
-  auto flattenIf = shouldFlatten(expr, flatteningCandidates);
+  auto flattenIf = shouldFlatten(expr, ctx.flatteningCandidates);
   for (auto& input : expr->inputs()) {
-    if (dynamic_cast<const core::InputTypedExpr*>(input.get())) {
+    if (input->isInputKind()) {
       VELOX_CHECK(
-          dynamic_cast<const core::FieldAccessTypedExpr*>(expr.get()),
+          expr->isFieldAccessKind(),
           "An InputReference can only occur under a FieldReference");
     } else {
       if (flattenIf.has_value()) {
         std::vector<TypedExprPtr> flat;
-        flattenInput(input, flattenIf.value(), flat);
+        expression::utils::flattenInput(input, flattenIf.value(), flat);
         for (auto& input_2 : flat) {
-          compiledInputs.push_back(compileExpression(
-              input_2,
-              scope,
-              config,
-              pool,
-              flatteningCandidates,
-              enableConstantFolding));
+          compiledInputs.push_back(compileExpression(input_2, scope, ctx));
         }
       } else {
-        compiledInputs.push_back(compileExpression(
-            input,
-            scope,
-            config,
-            pool,
-            flatteningCandidates,
-            enableConstantFolding));
+        compiledInputs.push_back(compileExpression(input, scope, ctx));
       }
     }
   }
@@ -257,20 +220,11 @@ void captureFieldReference(
 std::shared_ptr<Expr> compileLambda(
     const core::LambdaTypedExpr* lambda,
     Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding) {
+    const CompilerCtx& ctx) {
   auto signature = lambda->signature();
   auto parameterNames = signature->names();
   Scope lambdaScope(std::move(parameterNames), scope, scope->exprSet);
-  auto body = compileExpression(
-      lambda->body(),
-      &lambdaScope,
-      config,
-      pool,
-      flatteningCandidates,
-      enableConstantFolding);
+  auto body = compileExpression(lambda->body(), &lambdaScope, ctx);
 
   // The lambda depends on the captures. For a lambda caller to be
   // able to peel off encodings, the captures too must be peelable.
@@ -278,7 +232,8 @@ std::shared_ptr<Expr> compileLambda(
   captureReferences.reserve(lambdaScope.capture.size());
   for (auto i = 0; i < lambdaScope.capture.size(); ++i) {
     auto expr = lambdaScope.captureFieldAccesses[i];
-    auto reference = getAlreadyCompiled(expr, &scope->visited);
+    auto reference =
+        getAlreadyCompiled(expr, ctx.queryCtx->queryConfig(), &scope->visited);
     if (!reference) {
       auto inner = lambdaScope.captureReferences[i];
       reference = std::make_shared<FieldReference>(
@@ -296,49 +251,7 @@ std::shared_ptr<Expr> compileLambda(
       std::move(signature),
       std::move(captureReferences),
       std::move(body),
-      config.exprTrackCpuUsage());
-}
-
-ExprPtr tryFoldIfConstant(const ExprPtr& expr, Scope* scope) {
-  if (expr->isConstant() && scope->exprSet->execCtx()) {
-    try {
-      auto rowType = ROW({}, {});
-      auto execCtx = scope->exprSet->execCtx();
-      auto row = BaseVector::create(rowType, 1, execCtx->pool());
-      EvalCtx context(
-          execCtx, scope->exprSet, dynamic_cast<RowVector*>(row.get()));
-      VectorPtr result;
-      SelectivityVector rows(1);
-      expr->eval(rows, context, result);
-      auto constantVector = BaseVector::wrapInConstant(1, 0, result);
-
-      auto resultExpr = std::make_shared<ConstantExpr>(constantVector);
-      if (expr->stats().defaultNullRowsSkipped ||
-          std::any_of(
-              expr->inputs().begin(),
-              expr->inputs().end(),
-              [](const ExprPtr& input) {
-                return input->stats().defaultNullRowsSkipped;
-              })) {
-        resultExpr->setDefaultNullRowsSkipped(true);
-      }
-      return resultExpr;
-    }
-    // Constant folding has a subtle gotcha: if folding a constant expression
-    // deterministically throws, we can't throw at expression compilation time
-    // yet because we can't guarantee that this expression would actually need
-    // to be evaluated.
-    //
-    // So, here, if folding an expression throws an exception, we just ignore it
-    // and leave the expression as-is. If this expression is hit at execution
-    // time and needs to be evaluated, it will throw and fail the query anyway.
-    // If not, in case this expression is never hit at execution time (for
-    // instance, if other arguments are all null in a function with default null
-    // behavior), the query won't fail.
-    catch (const VeloxUserError&) {
-    }
-  }
-  return expr;
+      ctx.queryCtx->queryConfig().exprTrackCpuUsage());
 }
 
 /// Returns a vector aligned with exprs vector where elements that correspond to
@@ -348,7 +261,8 @@ std::vector<VectorPtr> getConstantInputs(const std::vector<ExprPtr>& exprs) {
   std::vector<VectorPtr> constants;
   constants.reserve(exprs.size());
   for (auto& expr : exprs) {
-    if (auto constantExpr = std::dynamic_pointer_cast<ConstantExpr>(expr)) {
+    if (expr->isConstant()) {
+      auto* constantExpr = dynamic_cast<ConstantExpr*>(expr.get());
       constants.emplace_back(constantExpr->value());
     } else {
       constants.emplace_back(nullptr);
@@ -357,23 +271,125 @@ std::vector<VectorPtr> getConstantInputs(const std::vector<ExprPtr>& exprs) {
   return constants;
 }
 
-core::TypedExprPtr rewriteExpression(const core::TypedExprPtr& expr) {
-  for (auto& rewrite : expressionRewrites()) {
-    if (auto rewritten = rewrite(expr)) {
-      return rewritten;
+ExprPtr compileCall(
+    const TypedExprPtr& expr,
+    std::vector<ExprPtr> inputs,
+    bool trackCpuUsage,
+    const CompilerCtx& ctx) {
+  const auto* call = expr->asUnchecked<core::CallTypedExpr>();
+  // Determine if CPU tracking should be enabled for this specific expression.
+  if (!trackCpuUsage && !ctx.cpuUsageTrackingCandidates.empty()) {
+    trackCpuUsage = ctx.cpuUsageTrackingCandidates.count(call->name()) > 0;
+  }
+  const auto& resultType = expr->type();
+  const auto inputTypes = getTypes(inputs);
+
+  if (auto specialForm = specialFormRegistry().getSpecialForm(call->name())) {
+    return specialForm->constructSpecialForm(
+        resultType,
+        std::move(inputs),
+        trackCpuUsage,
+        ctx.queryCtx->queryConfig());
+  }
+
+  if (auto functionWithMetadata = getVectorFunctionWithMetadata(
+          call->name(),
+          inputTypes,
+          getConstantInputs(inputs),
+          ctx.queryCtx->queryConfig())) {
+    return std::make_shared<Expr>(
+        resultType,
+        std::move(inputs),
+        functionWithMetadata->first,
+        functionWithMetadata->second,
+        call->name(),
+        trackCpuUsage);
+  }
+
+  if (auto simpleFunctionEntry =
+          simpleFunctions().resolveFunction(call->name(), inputTypes)) {
+    VELOX_USER_CHECK(
+        resultType->equivalent(*simpleFunctionEntry->type().get()),
+        "Found incompatible return types for '{}' ({} vs. {}) "
+        "for input types ({}).",
+        call->name(),
+        simpleFunctionEntry->type(),
+        resultType,
+        folly::join(", ", inputTypes));
+
+    auto func = simpleFunctionEntry->createFunction()->createVectorFunction(
+        inputTypes,
+        getConstantInputs(inputs),
+        ctx.queryCtx->queryConfig(),
+        ctx.pool);
+    return std::make_shared<Expr>(
+        resultType,
+        std::move(inputs),
+        std::move(func),
+        simpleFunctionEntry->metadata(),
+        call->name(),
+        trackCpuUsage);
+  }
+
+  const auto& functionName = call->name();
+  auto vectorFunctionSignatures = getVectorFunctionSignatures(functionName);
+  auto simpleFunctionSignatures =
+      simpleFunctions().getFunctionSignatures(functionName);
+  std::vector<std::string> signatures;
+
+  if (vectorFunctionSignatures.has_value()) {
+    for (const auto& signature : vectorFunctionSignatures.value()) {
+      signatures.push_back(fmt::format("({})", signature->toString()));
     }
   }
-  return expr;
+
+  for (const auto& signature : simpleFunctionSignatures) {
+    signatures.push_back(fmt::format("({})", signature->toString()));
+  }
+
+  if (signatures.empty()) {
+    VELOX_USER_FAIL(
+        "Scalar function name not registered: {}, called with arguments: ({}).",
+        call->name(),
+        folly::join(", ", inputTypes));
+  } else {
+    VELOX_USER_FAIL(
+        "Scalar function {} not registered with arguments: ({}). "
+        "Found function registered with the following signatures:\n{}",
+        call->name(),
+        folly::join(", ", inputTypes),
+        folly::join("\n", signatures));
+  }
+}
+
+ExprPtr compileCast(
+    const TypedExprPtr& expr,
+    std::vector<ExprPtr> inputs,
+    bool trackCpuUsage,
+    const core::QueryConfig& config) {
+  VELOX_CHECK_EQ(1, inputs.size());
+
+  const auto& resultType = expr->type();
+
+  if (FOLLY_UNLIKELY(*resultType == *inputs[0]->type())) {
+    return inputs[0];
+  }
+
+  const auto* cast = expr->asUnchecked<core::CastTypedExpr>();
+  return getSpecialForm(
+      config,
+      cast->isTryCast() ? expression::kTryCast : expression::kCast,
+      resultType,
+      std::move(inputs),
+      trackCpuUsage);
 }
 
 ExprPtr compileRewrittenExpression(
     const TypedExprPtr& expr,
     Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding) {
-  ExprPtr alreadyCompiled = getAlreadyCompiled(expr.get(), &scope->visited);
+    const CompilerCtx& ctx) {
+  ExprPtr alreadyCompiled = getAlreadyCompiled(
+      expr.get(), ctx.queryCtx->queryConfig(), &scope->visited);
   if (alreadyCompiled) {
     if (!alreadyCompiled->isMultiplyReferenced()) {
       scope->exprSet->addToReset(alreadyCompiled);
@@ -386,166 +402,85 @@ ExprPtr compileRewrittenExpression(
     return alreadyCompiled;
   }
 
-  const bool trackCpuUsage = config.exprTrackCpuUsage();
+  const bool trackCpuUsage = ctx.queryCtx->queryConfig().exprTrackCpuUsage();
+
+  const auto& resultType = expr->type();
+  auto compiledInputs = compileInputs(expr, scope, ctx);
 
   ExprPtr result;
-  auto resultType = expr->type();
-  auto compiledInputs = compileInputs(
-      expr, scope, config, pool, flatteningCandidates, enableConstantFolding);
-  auto inputTypes = getTypes(compiledInputs);
-  bool isConstantExpr = false;
-  if (dynamic_cast<const core::ConcatTypedExpr*>(expr.get())) {
-    result = getSpecialForm(
-        config,
-        RowConstructorCallToSpecialForm::kRowConstructor,
-        resultType,
-        std::move(compiledInputs),
-        trackCpuUsage);
-  } else if (auto cast = dynamic_cast<const core::CastTypedExpr*>(expr.get())) {
-    VELOX_CHECK(!compiledInputs.empty());
-    if (FOLLY_UNLIKELY(*resultType == *compiledInputs[0]->type())) {
-      result = compiledInputs[0];
-    } else {
+  switch (expr->kind()) {
+    case core::ExprKind::kConcat: {
       result = getSpecialForm(
-          config,
-          cast->nullOnFailure() ? "try_cast" : "cast",
+          ctx.queryCtx->queryConfig(),
+          expression::kRowConstructor,
           resultType,
           std::move(compiledInputs),
           trackCpuUsage);
+      break;
     }
-  } else if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
-    if (auto specialForm = specialFormRegistry().getSpecialForm(call->name())) {
-      result = specialForm->constructSpecialForm(
-          resultType, std::move(compiledInputs), trackCpuUsage, config);
-    } else if (
-        auto functionWithMetadata = getVectorFunctionWithMetadata(
-            call->name(),
-            inputTypes,
-            getConstantInputs(compiledInputs),
-            config)) {
-      result = std::make_shared<Expr>(
-          resultType,
-          std::move(compiledInputs),
-          functionWithMetadata->first,
-          functionWithMetadata->second,
-          call->name(),
-          trackCpuUsage);
-    } else if (
-        auto simpleFunctionEntry =
-            simpleFunctions().resolveFunction(call->name(), inputTypes)) {
-      VELOX_USER_CHECK(
-          resultType->equivalent(*simpleFunctionEntry->type().get()),
-          "Found incompatible return types for '{}' ({} vs. {}) "
-          "for input types ({}).",
-          call->name(),
-          simpleFunctionEntry->type(),
-          resultType,
-          folly::join(", ", inputTypes));
-
-      auto func = simpleFunctionEntry->createFunction()->createVectorFunction(
-          inputTypes, getConstantInputs(compiledInputs), config);
-      result = std::make_shared<Expr>(
-          resultType,
-          std::move(compiledInputs),
-          std::move(func),
-          simpleFunctionEntry->metadata(),
-          call->name(),
-          trackCpuUsage);
-    } else {
-      const auto& functionName = call->name();
-      auto vectorFunctionSignatures = getVectorFunctionSignatures(functionName);
-      auto simpleFunctionSignatures =
-          simpleFunctions().getFunctionSignatures(functionName);
-      std::vector<std::string> signatures;
-
-      if (vectorFunctionSignatures.has_value()) {
-        for (const auto& signature : vectorFunctionSignatures.value()) {
-          signatures.push_back(fmt::format("({})", signature->toString()));
-        }
-      }
-
-      for (const auto& signature : simpleFunctionSignatures) {
-        signatures.push_back(fmt::format("({})", signature->toString()));
-      }
-
-      if (signatures.empty()) {
-        VELOX_USER_FAIL(
-            "Scalar function name not registered: {}, called with arguments: ({}).",
-            call->name(),
-            folly::join(", ", inputTypes));
-      } else {
-        VELOX_USER_FAIL(
-            "Scalar function {} not registered with arguments: ({}). "
-            "Found function registered with the following signatures:\n{}",
-            call->name(),
-            folly::join(", ", inputTypes),
-            folly::join("\n", signatures));
+    case core::ExprKind::kCast: {
+      result = compileCast(
+          expr, compiledInputs, trackCpuUsage, ctx.queryCtx->queryConfig());
+      break;
+    }
+    case core::ExprKind::kCall: {
+      result = compileCall(expr, compiledInputs, trackCpuUsage, ctx);
+      break;
+    }
+    case core::ExprKind::kFieldAccess: {
+      const auto* access = expr->asUnchecked<core::FieldAccessTypedExpr>();
+      auto fieldReference = std::make_shared<FieldReference>(
+          expr->type(), std::move(compiledInputs), access->name());
+      if (access->isInputColumn()) {
+        // We only want to capture references to top level fields, not struct
+        // fields.
+        captureFieldReference(fieldReference.get(), expr.get(), scope);
       }
+      result = fieldReference;
+      break;
     }
-  } else if (
-      auto access =
-          dynamic_cast<const core::FieldAccessTypedExpr*>(expr.get())) {
-    auto fieldReference = std::make_shared<FieldReference>(
-        expr->type(), std::move(compiledInputs), access->name());
-    if (access->isInputColumn()) {
-      // We only want to capture references to top level fields, not struct
-      // fields.
-      captureFieldReference(fieldReference.get(), expr.get(), scope);
+    case core::ExprKind::kDereference: {
+      const auto* dereference = expr->asUnchecked<core::DereferenceTypedExpr>();
+      result = std::make_shared<FieldReference>(
+          expr->type(), std::move(compiledInputs), dereference->index());
+      break;
+    }
+    case core::ExprKind::kInput: {
+      VELOX_UNSUPPORTED("InputTypedExpr is not supported");
+    }
+    case core::ExprKind::kConstant: {
+      const auto* constant = expr->asUnchecked<core::ConstantTypedExpr>();
+      result =
+          std::make_shared<ConstantExpr>(constant->toConstantVector(ctx.pool));
+      break;
+    }
+    case core::ExprKind::kLambda: {
+      result =
+          compileLambda(expr->asUnchecked<core::LambdaTypedExpr>(), scope, ctx);
+      break;
+    }
+    default: {
+      VELOX_UNSUPPORTED("Unknown typed expression");
     }
-    result = fieldReference;
-  } else if (
-      auto dereference =
-          dynamic_cast<const core::DereferenceTypedExpr*>(expr.get())) {
-    result = std::make_shared<FieldReference>(
-        expr->type(), std::move(compiledInputs), dereference->index());
-  } else if (auto row = dynamic_cast<const core::InputTypedExpr*>(expr.get())) {
-    VELOX_UNSUPPORTED("InputTypedExpr '{}' is not supported", row->toString());
-  } else if (
-      auto constant =
-          dynamic_cast<const core::ConstantTypedExpr*>(expr.get())) {
-    result = std::make_shared<ConstantExpr>(constant->toConstantVector(pool));
-    isConstantExpr = true;
-  } else if (
-      auto lambda = dynamic_cast<const core::LambdaTypedExpr*>(expr.get())) {
-    result = compileLambda(
-        lambda,
-        scope,
-        config,
-        pool,
-        flatteningCandidates,
-        enableConstantFolding);
-  } else {
-    VELOX_UNSUPPORTED("Unknown typed expression");
   }
 
   result->computeMetadata();
-
-  // If the expression is constant folding it is redundant.
-  auto folded = enableConstantFolding && !isConstantExpr
-      ? tryFoldIfConstant(result, scope)
-      : result;
-  scope->visited[expr.get()] = folded;
-  return folded;
+  scope->visited[expr.get()] = result;
+  return result;
 }
 
 ExprPtr compileExpression(
     const TypedExprPtr& expr,
     Scope* scope,
-    const core::QueryConfig& config,
-    memory::MemoryPool* pool,
-    const std::unordered_set<std::string>& flatteningCandidates,
-    bool enableConstantFolding) {
-  auto rewritten = rewriteExpression(expr);
+    const CompilerCtx& ctx) {
+  auto rewritten = ctx.enableConstantFolding
+      ? expression::optimize(expr, ctx.queryCtx, ctx.pool)
+      : expr;
   if (rewritten.get() != expr.get()) {
     scope->rewrittenExpressions.push_back(rewritten);
   }
   return compileRewrittenExpression(
-      rewritten == nullptr ? expr : rewritten,
-      scope,
-      config,
-      pool,
-      flatteningCandidates,
-      enableConstantFolding);
+      rewritten == nullptr ? expr : rewritten, scope, ctx);
 }
 
 /// Walk expression tree and collect names of functions used in CallTypedExpr
@@ -553,8 +488,8 @@ ExprPtr compileExpression(
 void collectCallNames(
     const TypedExprPtr& expr,
     std::unordered_set<std::string>& names) {
-  if (auto call = std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
-    names.insert(call->name());
+  if (expr->isCallKind()) {
+    names.insert(expr->asUnchecked<core::CallTypedExpr>()->name());
   }
 
   for (const auto& input : expr->inputs()) {
@@ -595,18 +530,18 @@ std::vector<std::shared_ptr<Expr>> compileExpressions(
   std::vector<std::shared_ptr<Expr>> exprs;
   exprs.reserve(sources.size());
 
-  // Precompute a set of function calls that support flattening. This allows to
-  // lock function registry once vs. locking for each function call.
-  auto flatteningCandidates = collectFlatteningCandidates(sources);
+  CompilerCtx ctx{
+      .queryCtx = execCtx->queryCtx(),
+      .pool = execCtx->pool(),
+      .enableConstantFolding = enableConstantFolding,
+      // Precompute a set of function calls that support flattening. This allows
+      // to lock function registry once vs. locking for each function call.
+      .flatteningCandidates = collectFlatteningCandidates(sources),
+      .cpuUsageTrackingCandidates =
+          fetchCallExprNamesForCpuTracking(execCtx->queryCtx()->queryConfig())};
 
   for (auto& source : sources) {
-    exprs.push_back(compileExpression(
-        source,
-        &scope,
-        execCtx->queryCtx()->queryConfig(),
-        execCtx->pool(),
-        flatteningCandidates,
-        enableConstantFolding));
+    exprs.push_back(compileExpression(source, &scope, ctx));
   }
   return exprs;
 }
diff --git a/velox/expression/ExprConstants.h b/velox/expression/ExprConstants.h
new file mode 100644
index 000000000000..02f0b46156aa
--- /dev/null
+++ b/velox/expression/ExprConstants.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
+
+namespace facebook::velox::expression {
+
+inline constexpr const char* kAnd = "and";
+inline constexpr const char* kOr = "or";
+inline constexpr const char* kSwitch = "switch";
+inline constexpr const char* kIf = "if";
+inline constexpr const char* kCoalesce = "coalesce";
+inline constexpr const char* kCast = "cast";
+inline constexpr const char* kTryCast = "try_cast";
+inline constexpr const char* kTry = "try";
+inline constexpr const char* kRowConstructor = "row_constructor";
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprOptimizer.cpp b/velox/expression/ExprOptimizer.cpp
new file mode 100644
index 000000000000..3df2f3bb2689
--- /dev/null
+++ b/velox/expression/ExprOptimizer.cpp
@@ -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.
+ */
+#include "velox/expression/ExprOptimizer.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+
+namespace facebook::velox::expression {
+
+namespace {
+
+// Tries constant folding input `expr` with `tryEvaluateConstantExpression` API
+// and returns the evaluated expression if constant folding succeeds. If
+// `tryEvaluateConstantExpression` throws a `VeloxUserError`, returns the
+// result of applying `makeFailExpr` to `expr`, otherwise returns `expr`.
+core::TypedExprPtr tryConstantFold(
+    const core::TypedExprPtr& expr,
+    core::QueryCtx* queryCtx,
+    memory::MemoryPool* pool,
+    const MakeFailExpr& makeFailExpr) {
+  try {
+    if (auto results =
+            exec::tryEvaluateConstantExpression(expr, pool, queryCtx, false)) {
+      return std::make_shared<core::ConstantTypedExpr>(results);
+    }
+  } catch (VeloxUserError& e) {
+    if (makeFailExpr != nullptr) {
+      const auto result = makeFailExpr(e.message(), expr->type());
+      VELOX_USER_CHECK(
+          *result->type() == *expr->type(),
+          "makeFailExpr returned expression: {} of type: {}, which does not match type: {} of failing expression: {}",
+          result->toString(),
+          result->type()->toString(),
+          expr->type()->toString(),
+          expr->toString());
+      return result;
+    }
+  }
+  // Return the expression unmodified.
+  return expr;
+}
+
+// Optimizes all inputs to expr and returns an expression that is of the same
+// kind as expr but with optimized inputs.
+core::TypedExprPtr optimizeInputs(
+    const core::TypedExprPtr& expr,
+    core::QueryCtx* queryCtx,
+    memory::MemoryPool* pool,
+    const MakeFailExpr& makeFailExpr) {
+  if (expr->isCallKind()) {
+    std::vector<core::TypedExprPtr> optimizedInputs;
+    optimizedInputs.reserve(expr->inputs().size());
+    for (const auto& input : expr->inputs()) {
+      optimizedInputs.push_back(optimize(input, queryCtx, pool, makeFailExpr));
+    }
+    const auto* callExpr = expr->asUnchecked<core::CallTypedExpr>();
+
+    return std::make_shared<core::CallTypedExpr>(
+        callExpr->type(), optimizedInputs, callExpr->name());
+  }
+
+  if (expr->isCastKind()) {
+    const auto optimizedInput =
+        optimize(expr->inputs().at(0), queryCtx, pool, makeFailExpr);
+    const auto* castExpr = expr->asUnchecked<core::CastTypedExpr>();
+    return std::make_shared<core::CastTypedExpr>(
+        expr->type(), optimizedInput, castExpr->isTryCast());
+  }
+
+  if (expr->isLambdaKind()) {
+    const auto* lambdaExpr = expr->asUnchecked<core::LambdaTypedExpr>();
+    const auto foldedBody =
+        optimize(lambdaExpr->body(), queryCtx, pool, makeFailExpr);
+    return std::make_shared<core::LambdaTypedExpr>(
+        lambdaExpr->signature(), foldedBody);
+  }
+
+  return expr;
+}
+} // namespace
+
+core::TypedExprPtr optimize(
+    const core::TypedExprPtr& expr,
+    core::QueryCtx* queryCtx,
+    memory::MemoryPool* pool,
+    const MakeFailExpr& makeFailExpr) {
+  auto result = expr;
+  // cast(1 AS BIGINT) -> 1.
+  // cast(a AS BIGINT) -> a ; when type(a) == BIGINT.
+  // cast(concat(a, 'test') AS VARCHAR) -> concat(a, 'test') ; when type(a) ==
+  //  VARCHAR.
+  if (result->isCastKind() &&
+      *result->type() == *result->inputs().at(0)->type()) {
+    result = result->inputs().at(0);
+  }
+  // 1 -> 1, a -> a.
+  if (result->isConstantKind() || result->isFieldAccessKind()) {
+    return result;
+  }
+
+  result = optimizeInputs(result, queryCtx, pool, makeFailExpr);
+  bool allInputsConstant = true;
+  for (const auto& input : result->inputs()) {
+    if (!input->isConstantKind()) {
+      allInputsConstant = false;
+      break;
+    }
+  }
+
+  if (allInputsConstant) {
+    return tryConstantFold(result, queryCtx, pool, makeFailExpr);
+  }
+  return ExprRewriteRegistry::instance().rewrite(result);
+}
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprOptimizer.h b/velox/expression/ExprOptimizer.h
new file mode 100644
index 000000000000..6448ce99b99b
--- /dev/null
+++ b/velox/expression/ExprOptimizer.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.
+ */
+#include "velox/core/Expressions.h"
+#include "velox/core/QueryCtx.h"
+
+namespace facebook::velox::expression {
+
+/// A callback invoked if execution failure is encountered during constant
+/// folding. The callback receives an error message and the result type of the
+/// expression that fails. The callback is expected to produce a replacement
+/// expression with the same result type. For example, Presto returns
+/// `cast(fail(errorMessage) as resultType)`.
+using MakeFailExpr = std::function<core::TypedExprPtr(
+    const std::string& errorMessage,
+    const TypePtr& resultType)>;
+
+/// Optimizes expression through a combination of constant folding and rewrites;
+/// all possible subtrees of the expression are constant folded first in a
+/// bottom up manner, then the folded expression is rewritten. If an exception
+/// (i.e VeloxUserError) is encountered during constant folding of any subtree
+/// of the expression and the function `makeFailExpr` is provided, the failing
+/// subexpression is replaced by the result of applying `makeFailExpr`, allowing
+/// users to define custom logic for handling constant folding errors during
+/// expression optimization. When `makeFailExpr` is not provided, exceptions
+/// encountered while constant folding subexpressions are ignored and failing
+/// subexpressions are left unchanged in the expression tree.
+core::TypedExprPtr optimize(
+    const core::TypedExprPtr& expr,
+    core::QueryCtx* queryCtx,
+    memory::MemoryPool* pool,
+    const MakeFailExpr& makeFailExpr = nullptr);
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprRewriteRegistry.cpp b/velox/expression/ExprRewriteRegistry.cpp
new file mode 100644
index 000000000000..5f144e0376dc
--- /dev/null
+++ b/velox/expression/ExprRewriteRegistry.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/expression/ExprRewriteRegistry.h"
+#include "velox/expression/FunctionSignature.h"
+
+namespace facebook::velox::expression {
+
+void ExprRewriteRegistry::registerRewrite(ExpressionRewrite rewrite) {
+  registry_.withWLock([&](auto& list) { list.push_back(std::move(rewrite)); });
+}
+
+void ExprRewriteRegistry::clear() {
+  registry_.withWLock([&](auto& list) { list.clear(); });
+}
+
+core::TypedExprPtr ExprRewriteRegistry::rewrite(
+    const core::TypedExprPtr& expr) {
+  const auto& inputs = expr->inputs();
+  VELOX_CHECK(
+      std::any_of(
+          inputs.begin(),
+          inputs.end(),
+          [](const core::TypedExprPtr& input) {
+            return !input->isConstantKind();
+          }),
+      "Expression should have at least one non-constant input.");
+
+  core::TypedExprPtr result = expr;
+  registry_.withRLock([&](const auto& list) {
+    for (const auto& rewrite : list) {
+      VELOX_CHECK_NOT_NULL(rewrite);
+      if (auto rewritten = (rewrite)(expr)) {
+        result = rewritten;
+        break;
+      }
+    }
+  });
+
+  return result;
+}
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprRewriteRegistry.h b/velox/expression/ExprRewriteRegistry.h
new file mode 100644
index 000000000000..7e39dd67dead
--- /dev/null
+++ b/velox/expression/ExprRewriteRegistry.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 <folly/Synchronized.h>
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression {
+
+/// An expression re-writer that takes an expression and returns an equivalent
+/// expression or nullptr if re-write is not possible.
+using ExpressionRewrite =
+    std::function<core::TypedExprPtr(const core::TypedExprPtr)>;
+
+class ExprRewriteRegistry {
+ public:
+  /// Appends a 'rewrite' to 'expressionRewrites'.
+  ///
+  /// The logic that applies re-writes is very simple and assumes that all
+  /// rewrites are independent. For each expression, rewrites are applied in the
+  /// order they were registered. The first rewrite that returns non-null result
+  /// terminates the re-write for that particular expression.
+  void registerRewrite(ExpressionRewrite rewrite);
+
+  /// Clears the registry to remove all registered rewrites.
+  void clear();
+
+  /// Rewrites input expression to an equivalent expression. Throws if the
+  /// expression only has constant inputs.
+  core::TypedExprPtr rewrite(const core::TypedExprPtr& expr);
+
+  static ExprRewriteRegistry& instance() {
+    static ExprRewriteRegistry kInstance;
+    return kInstance;
+  }
+
+ private:
+  folly::Synchronized<std::vector<ExpressionRewrite>> registry_;
+};
+} // namespace facebook::velox::expression
diff --git a/velox/expression/ExprStats.h b/velox/expression/ExprStats.h
new file mode 100644
index 000000000000..532925cbff25
--- /dev/null
+++ b/velox/expression/ExprStats.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.
+ */
+
+#pragma once
+
+#include "velox/common/time/CpuWallTimer.h"
+
+namespace facebook::velox::exec {
+
+struct ExprStats {
+  /// Requires QueryConfig.exprTrackCpuUsage() to be 'true'.
+  CpuWallTiming timing;
+
+  /// Number of processed rows.
+  uint64_t numProcessedRows{0};
+
+  /// Number of processed vectors / batches. Allows to compute average batch
+  /// size.
+  uint64_t numProcessedVectors{0};
+
+  /// Whether default-null behavior of an expression resulted in skipping
+  /// evaluation of rows.
+  bool defaultNullRowsSkipped{false};
+
+  auto operator<=>(const ExprStats&) const = default;
+
+  void add(const ExprStats& other) {
+    timing.add(other.timing);
+    numProcessedRows += other.numProcessedRows;
+    numProcessedVectors += other.numProcessedVectors;
+    defaultNullRowsSkipped |= other.defaultNullRowsSkipped;
+  }
+
+  std::string toString() const {
+    return fmt::format(
+        "timing: {}, numProcessedRows: {}, numProcessedVectors: {}, defaultNullRowsSkipped: {}",
+        timing.toString(),
+        numProcessedRows,
+        numProcessedVectors,
+        defaultNullRowsSkipped ? "true" : "false");
+  }
+};
+} // namespace facebook::velox::exec
diff --git a/velox/expression/ExprToSubfieldFilter.cpp b/velox/expression/ExprToSubfieldFilter.cpp
index 54a11e065e43..281165a8fe47 100644
--- a/velox/expression/ExprToSubfieldFilter.cpp
+++ b/velox/expression/ExprToSubfieldFilter.cpp
@@ -28,7 +28,7 @@ VectorPtr toConstant(
     const core::TypedExprPtr& expr,
     core::ExpressionEvaluator* evaluator) {
   auto exprSet = evaluator->compile(expr);
-  if (!exprSet->exprs()[0]->isConstant()) {
+  if (!exprSet->exprs()[0]->isConstantExpr()) {
     return nullptr;
   }
   RowVector input(
@@ -50,17 +50,12 @@ T singleValue(const VectorPtr& vector) {
   return simpleVector->valueAt(0);
 }
 
-const core::CallTypedExpr* asCall(const core::ITypedExpr* expr) {
-  return dynamic_cast<const core::CallTypedExpr*>(expr);
+bool isBigintRange(const std::unique_ptr<common::Filter>& filter) {
+  return filter->is(common::FilterKind::kBigintRange);
 }
 
-common::BigintRange* asBigintRange(std::unique_ptr<common::Filter>& filter) {
-  return dynamic_cast<common::BigintRange*>(filter.get());
-}
-
-common::BigintMultiRange* asBigintMultiRange(
-    std::unique_ptr<common::Filter>& filter) {
-  return dynamic_cast<common::BigintMultiRange*>(filter.get());
+bool isBigintMultiRange(const std::unique_ptr<common::Filter>& filter) {
+  return filter->is(common::FilterKind::kBigintMultiRange);
 }
 
 template <typename T, typename U>
@@ -68,58 +63,54 @@ std::unique_ptr<T> asUniquePtr(std::unique_ptr<U> ptr) {
   return std::unique_ptr<T>(static_cast<T*>(ptr.release()));
 }
 
-std::unique_ptr<common::Filter> makeOrFilter(
-    std::unique_ptr<common::Filter> a,
-    std::unique_ptr<common::Filter> b) {
-  if (asBigintRange(a) && asBigintRange(b)) {
-    return bigintOr(
-        asUniquePtr<common::BigintRange>(std::move(a)),
-        asUniquePtr<common::BigintRange>(std::move(b)));
-  }
-
-  if (asBigintRange(a) && asBigintMultiRange(b)) {
-    const auto& ranges = asBigintMultiRange(b)->ranges();
-    std::vector<std::unique_ptr<common::BigintRange>> newRanges;
-    newRanges.emplace_back(asUniquePtr<common::BigintRange>(std::move(a)));
-    for (const auto& range : ranges) {
-      newRanges.emplace_back(asUniquePtr<common::BigintRange>(range->clone()));
-    }
-
-    std::sort(
-        newRanges.begin(), newRanges.end(), [](const auto& a, const auto& b) {
-          return a->lower() < b->lower();
-        });
-
-    return std::make_unique<common::BigintMultiRange>(
-        std::move(newRanges), false);
-  }
-
-  if (asBigintMultiRange(a) && asBigintRange(b)) {
-    return makeOrFilter(std::move(b), std::move(a));
-  }
-
-  return orFilter(std::move(a), std::move(b));
+std::unique_ptr<common::BigintRange> asBigintRange(
+    std::unique_ptr<common::Filter>& ptr) {
+  return asUniquePtr<common::BigintRange>(std::move(ptr));
 }
 
 template <typename T>
-std::vector<int64_t>
-toInt64List(const VectorPtr& vector, vector_size_t start, vector_size_t size) {
+std::unique_ptr<common::Filter> toInt64In(
+    const VectorPtr& vector,
+    vector_size_t start,
+    vector_size_t size,
+    bool negated) {
   auto ints = vector->as<SimpleVector<T>>();
   std::vector<int64_t> values;
-  for (auto i = 0; i < size; i++) {
-    values.push_back(ints->valueAt(start + i));
+  values.reserve(size);
+  bool hasNull = false;
+  if (!ints->mayHaveNulls()) {
+    for (auto i = 0; i < size; i++) {
+      values.push_back(ints->valueAt(start + i));
+    }
+  } else {
+    for (auto i = 0; i < size; i++) {
+      if (!ints->isNullAt(start + i)) {
+        values.push_back(ints->valueAt(start + i));
+      } else if (!hasNull) {
+        hasNull = true;
+      }
+    }
+  }
+
+  if (negated) {
+    if (hasNull) {
+      // If values contain NULL, the input cannot pass the filter, e.g. '1
+      // not in (2, NULL)' evaluates to NULL.
+      return std::make_unique<common::AlwaysFalse>();
+    }
+    return notIn(values);
   }
-  return values;
-}
 
-static std::shared_ptr<ExprToSubfieldFilterParser> defaultParser =
-    std::make_shared<PrestoExprToSubfieldFilterParser>();
+  return in(values);
+}
 
 } // namespace
 
-std::function<std::shared_ptr<ExprToSubfieldFilterParser>()>
-    ExprToSubfieldFilterParser::parserFactory_ = [] { return defaultParser; };
+std::shared_ptr<ExprToSubfieldFilterParser>
+    ExprToSubfieldFilterParser::parser_ =
+        std::make_shared<PrestoExprToSubfieldFilterParser>();
 
+// static
 bool ExprToSubfieldFilterParser::toSubfield(
     const core::ITypedExpr* field,
     common::Subfield& subfield) {
@@ -161,6 +152,7 @@ bool ExprToSubfieldFilterParser::toSubfield(
   return true;
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeNotEqualFilter(
     const core::TypedExprPtr& valueExpr,
     core::ExpressionEvaluator* evaluator) {
@@ -168,46 +160,46 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeNotEqualFilter(
   if (!value) {
     return nullptr;
   }
+  if (value->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
 
-  std::unique_ptr<common::Filter> lessThanFilter =
-      makeLessThanFilter(valueExpr, evaluator);
+  auto lessThanFilter = makeLessThanFilter(valueExpr, evaluator);
   if (!lessThanFilter) {
     return nullptr;
   }
-  std::unique_ptr<common::Filter> greaterThanFilter =
-      makeGreaterThanFilter(valueExpr, evaluator);
+
+  auto greaterThanFilter = makeGreaterThanFilter(valueExpr, evaluator);
   if (!greaterThanFilter) {
     return nullptr;
   }
 
-  if (value->typeKind() == TypeKind::TINYINT ||
-      value->typeKind() == TypeKind::SMALLINT ||
-      value->typeKind() == TypeKind::INTEGER ||
-      value->typeKind() == TypeKind::BIGINT) {
-    // Cast lessThanFilter and greaterThanFilter to
-    // std::unique_ptr<common::BigintRange>.
-    std::vector<std::unique_ptr<common::BigintRange>> ranges;
-    auto lessRange =
-        dynamic_cast<common::BigintRange*>(lessThanFilter.release());
-    VELOX_CHECK_NOT_NULL(lessRange, "Less-than range is null");
-    ranges.emplace_back(std::unique_ptr<common::BigintRange>(lessRange));
-
-    auto greaterRange =
-        dynamic_cast<common::BigintRange*>(greaterThanFilter.release());
-    VELOX_CHECK_NOT_NULL(greaterRange, "Greater-than range is null");
-    ranges.emplace_back(std::unique_ptr<common::BigintRange>(greaterRange));
-
-    return std::make_unique<common::BigintMultiRange>(std::move(ranges), false);
-  } else if (value->typeKind() == TypeKind::HUGEINT) {
+  const auto typeKind = value->typeKind();
+
+  if (typeKind == TypeKind::TINYINT || typeKind == TypeKind::SMALLINT ||
+      typeKind == TypeKind::INTEGER || typeKind == TypeKind::BIGINT) {
+    VELOX_CHECK(isBigintRange(lessThanFilter));
+    VELOX_CHECK(isBigintRange(greaterThanFilter));
+
+    std::vector<std::unique_ptr<common::BigintRange>> filters;
+    filters.emplace_back(asBigintRange(lessThanFilter));
+    filters.emplace_back(asBigintRange(greaterThanFilter));
+    return std::make_unique<common::BigintMultiRange>(
+        std::move(filters), false);
+  }
+
+  if (typeKind == TypeKind::HUGEINT) {
     VELOX_NYI();
   } else {
     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);
   }
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeEqualFilter(
     const core::TypedExprPtr& valueExpr,
     core::ExpressionEvaluator* evaluator) {
@@ -215,6 +207,9 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeEqualFilter(
   if (!value) {
     return nullptr;
   }
+  if (value->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (value->typeKind()) {
     case TypeKind::BOOLEAN:
       return boolEqual(singleValue<bool>(value));
@@ -229,7 +224,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeEqualFilter(
     case TypeKind::HUGEINT:
       return equalHugeint(singleValue<int128_t>(value));
     case TypeKind::VARCHAR:
-      return equal(singleValue<StringView>(value));
+      return equal(std::string(singleValue<StringView>(value)));
     case TypeKind::TIMESTAMP:
       return equal(singleValue<Timestamp>(value));
     default:
@@ -237,6 +232,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeEqualFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter>
 ExprToSubfieldFilterParser::makeGreaterThanFilter(
     const core::TypedExprPtr& lowerExpr,
@@ -245,6 +241,9 @@ ExprToSubfieldFilterParser::makeGreaterThanFilter(
   if (!lower) {
     return nullptr;
   }
+  if (lower->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (lower->typeKind()) {
     case TypeKind::TINYINT:
       return greaterThan(singleValue<int8_t>(lower));
@@ -261,7 +260,7 @@ ExprToSubfieldFilterParser::makeGreaterThanFilter(
     case TypeKind::REAL:
       return greaterThanFloat(singleValue<float>(lower));
     case TypeKind::VARCHAR:
-      return greaterThan(singleValue<StringView>(lower));
+      return greaterThan(std::string(singleValue<StringView>(lower)));
     case TypeKind::TIMESTAMP:
       return greaterThan(singleValue<Timestamp>(lower));
     default:
@@ -269,6 +268,7 @@ ExprToSubfieldFilterParser::makeGreaterThanFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeLessThanFilter(
     const core::TypedExprPtr& upperExpr,
     core::ExpressionEvaluator* evaluator) {
@@ -276,6 +276,9 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeLessThanFilter(
   if (!upper) {
     return nullptr;
   }
+  if (upper->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (upper->typeKind()) {
     case TypeKind::TINYINT:
       return lessThan(singleValue<int8_t>(upper));
@@ -292,7 +295,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeLessThanFilter(
     case TypeKind::REAL:
       return lessThanFloat(singleValue<float>(upper));
     case TypeKind::VARCHAR:
-      return lessThan(singleValue<StringView>(upper));
+      return lessThan(std::string(singleValue<StringView>(upper)));
     case TypeKind::TIMESTAMP:
       return lessThan(singleValue<Timestamp>(upper));
     default:
@@ -300,6 +303,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeLessThanFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter>
 ExprToSubfieldFilterParser::makeLessThanOrEqualFilter(
     const core::TypedExprPtr& upperExpr,
@@ -308,6 +312,9 @@ ExprToSubfieldFilterParser::makeLessThanOrEqualFilter(
   if (!upper) {
     return nullptr;
   }
+  if (upper->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (upper->typeKind()) {
     case TypeKind::TINYINT:
       return lessThanOrEqual(singleValue<int8_t>(upper));
@@ -324,7 +331,7 @@ ExprToSubfieldFilterParser::makeLessThanOrEqualFilter(
     case TypeKind::REAL:
       return lessThanOrEqualFloat(singleValue<float>(upper));
     case TypeKind::VARCHAR:
-      return lessThanOrEqual(singleValue<StringView>(upper));
+      return lessThanOrEqual(std::string(singleValue<StringView>(upper)));
     case TypeKind::TIMESTAMP:
       return lessThanOrEqual(singleValue<Timestamp>(upper));
     default:
@@ -332,6 +339,7 @@ ExprToSubfieldFilterParser::makeLessThanOrEqualFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter>
 ExprToSubfieldFilterParser::makeGreaterThanOrEqualFilter(
     const core::TypedExprPtr& lowerExpr,
@@ -340,6 +348,9 @@ ExprToSubfieldFilterParser::makeGreaterThanOrEqualFilter(
   if (!lower) {
     return nullptr;
   }
+  if (lower->isNullAt(0)) {
+    return std::make_unique<common::AlwaysFalse>();
+  }
   switch (lower->typeKind()) {
     case TypeKind::TINYINT:
       return greaterThanOrEqual(singleValue<int8_t>(lower));
@@ -356,7 +367,7 @@ ExprToSubfieldFilterParser::makeGreaterThanOrEqualFilter(
     case TypeKind::REAL:
       return greaterThanOrEqualFloat(singleValue<float>(lower));
     case TypeKind::VARCHAR:
-      return greaterThanOrEqual(singleValue<StringView>(lower));
+      return greaterThanOrEqual(std::string(singleValue<StringView>(lower)));
     case TypeKind::TIMESTAMP:
       return greaterThanOrEqual(singleValue<Timestamp>(lower));
     default:
@@ -364,6 +375,7 @@ ExprToSubfieldFilterParser::makeGreaterThanOrEqualFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeInFilter(
     const core::TypedExprPtr& expr,
     core::ExpressionEvaluator* evaluator,
@@ -381,29 +393,39 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeInFilter(
 
   auto elementType = arrayVector->type()->asArray().elementType();
   switch (elementType->kind()) {
-    case TypeKind::TINYINT: {
-      auto values = toInt64List<int8_t>(elements, offset, size);
-      return negated ? notIn(values) : in(values);
-    }
-    case TypeKind::SMALLINT: {
-      auto values = toInt64List<int16_t>(elements, offset, size);
-      return negated ? notIn(values) : in(values);
-    }
-    case TypeKind::INTEGER: {
-      auto values = toInt64List<int32_t>(elements, offset, size);
-      return negated ? notIn(values) : in(values);
-    }
-    case TypeKind::BIGINT: {
-      auto values = toInt64List<int64_t>(elements, offset, size);
-      return negated ? notIn(values) : in(values);
-    }
+    case TypeKind::TINYINT:
+      return toInt64In<int8_t>(elements, offset, size, negated);
+    case TypeKind::SMALLINT:
+      return toInt64In<int16_t>(elements, offset, size, negated);
+    case TypeKind::INTEGER:
+      return toInt64In<int32_t>(elements, offset, size, negated);
+    case TypeKind::BIGINT:
+      return toInt64In<int64_t>(elements, offset, size, negated);
     case TypeKind::VARCHAR: {
       auto stringElements = elements->as<SimpleVector<StringView>>();
       std::vector<std::string> values;
-      for (auto i = 0; i < size; i++) {
-        values.push_back(stringElements->valueAt(offset + i).str());
+      values.reserve(size);
+      bool hasNull = false;
+      if (!stringElements->mayHaveNulls()) {
+        for (auto i = 0; i < size; i++) {
+          values.push_back(std::string(stringElements->valueAt(offset + i)));
+        }
+      } else {
+        for (auto i = 0; i < size; i++) {
+          if (!stringElements->isNullAt(offset + i)) {
+            values.push_back(std::string(stringElements->valueAt(offset + i)));
+          } else if (!hasNull) {
+            hasNull = true;
+          }
+        }
       }
+
       if (negated) {
+        if (hasNull) {
+          // If values contain NULL, the input cannot pass the filter, e.g. 'a'
+          // not in ('b', NULL) evaluates to NULL.
+          return std::make_unique<common::AlwaysFalse>();
+        }
         return notIn(values);
       }
       return in(values);
@@ -413,6 +435,7 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeInFilter(
   }
 }
 
+// static
 std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeBetweenFilter(
     const core::TypedExprPtr& lowerExpr,
     const core::TypedExprPtr& upperExpr,
@@ -451,10 +474,12 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeBetweenFilter(
     case TypeKind::VARCHAR:
       if (negated) {
         return notBetween(
-            singleValue<StringView>(lower), singleValue<StringView>(upper));
+            std::string(singleValue<StringView>(lower)),
+            std::string(singleValue<StringView>(upper)));
       }
       return between(
-          singleValue<StringView>(lower), singleValue<StringView>(upper));
+          std::string(singleValue<StringView>(lower)),
+          std::string(singleValue<StringView>(upper)));
     case TypeKind::TIMESTAMP:
       return negated
           ? nullptr
@@ -465,100 +490,332 @@ std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeBetweenFilter(
   }
 }
 
-std::unique_ptr<common::Filter>
+namespace {
+
+bool isNullAllowed(
+    const std::vector<std::unique_ptr<common::Filter>>& disjuncts) {
+  return std::any_of(
+      disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return filter->nullAllowed();
+      });
+}
+
+// Combines overlapping ranges into one using OR semantic. Returns nullptr if
+// ranges do not overlap. Ignores nullAllowed flag.
+// @pre a.lower() <= b.lower()
+std::unique_ptr<common::BigintRange> tryMergeOverlappingRanges(
+    const common::BigintRange& a,
+    const common::BigintRange& b,
+    bool& alwaysTrue) {
+  static constexpr auto kMax = std::numeric_limits<int64_t>::max();
+  static constexpr auto kMin = std::numeric_limits<int64_t>::min();
+
+  if (a.upper() == kMax || a.upper() + 1 >= b.lower()) {
+    if (a.lower() == kMin && (a.upper() == kMax || b.upper() == kMax)) {
+      alwaysTrue = true;
+      return nullptr;
+    }
+
+    return std::make_unique<common::BigintRange>(
+        a.lower(), std::max(a.upper(), b.upper()), /*nullAllowed=*/false);
+  }
+  return nullptr;
+}
+
+// Returns a single range that represents "a OR b" or nullptr if no such range
+// exists.
+// @pre a.lower() <= b.lower()
+template <typename T>
+std::unique_ptr<common::FloatingPointRange<T>> tryMergeOverlappingRanges(
+    const common::FloatingPointRange<T>& a,
+    const common::FloatingPointRange<T>& b,
+    bool& alwaysTrue) {
+  if (!a.upperUnbounded() && !b.lowerUnbounded() &&
+      (a.upper() < b.lower() ||
+       (a.upper() == b.lower() && a.upperExclusive() && b.lowerExclusive()))) {
+    return nullptr;
+  }
+
+  const bool lowerUnbounded = a.lowerUnbounded() || b.lowerUnbounded();
+  const bool upperUnbounded = a.upperUnbounded() || b.upperUnbounded();
+
+  const T lower = lowerUnbounded ? std::numeric_limits<T>::lowest()
+                                 : std::min(a.lower(), b.lower());
+
+  bool lowerExclusive = lowerUnbounded;
+  if (!lowerUnbounded) {
+    if (a.lower() < b.lower()) {
+      lowerExclusive = a.lowerExclusive();
+    } else {
+      lowerExclusive = a.lowerExclusive() && b.lowerExclusive();
+    }
+  }
+
+  const T upper = upperUnbounded ? std::numeric_limits<T>::max()
+                                 : std::max(a.upper(), b.upper());
+
+  bool upperExclusive = upperUnbounded;
+  if (!upperUnbounded) {
+    if (a.upper() > b.upper()) {
+      upperExclusive = a.upperExclusive();
+    } else if (a.upper() < b.upper()) {
+      upperExclusive = b.upperExclusive();
+    } else {
+      upperExclusive = a.upperExclusive() && b.upperExclusive();
+    }
+  }
+
+  if (lowerUnbounded && upperUnbounded) {
+    alwaysTrue = true;
+    return nullptr;
+  }
+
+  return std::make_unique<common::FloatingPointRange<T>>(
+      lower,
+      lowerUnbounded,
+      lowerExclusive,
+      upper,
+      upperUnbounded,
+      upperExclusive,
+      /*nullAllowed=*/false);
+}
+
+template <typename T, typename TToMultiRange>
+std::unique_ptr<common::Filter> mergeOverlappingDisjuncts(
+    std::vector<std::unique_ptr<T>>& ranges,
+    bool nullAllowed,
+    const TToMultiRange& toMultiRange) {
+  std::vector<std::unique_ptr<T>> newRanges;
+  newRanges.emplace_back(asUniquePtr<T>(ranges.front()->clone(nullAllowed)));
+
+  for (auto i = 1; i < ranges.size(); i++) {
+    bool alwaysTrue = false;
+    if (auto merged = tryMergeOverlappingRanges(
+            *newRanges.back(), *ranges[i], alwaysTrue)) {
+      newRanges.back() = std::move(merged);
+    } else {
+      if (alwaysTrue) {
+        if (nullAllowed) {
+          return std::make_unique<common::AlwaysTrue>();
+        }
+        return isNotNull();
+      }
+      newRanges.emplace_back(std::move(ranges[i]));
+    }
+  }
+
+  if (newRanges.size() == 1) {
+    return std::move(newRanges.front());
+  }
+
+  return toMultiRange(newRanges, nullAllowed);
+}
+
+std::unique_ptr<common::Filter> tryMergeBigintRanges(
+    std::vector<std::unique_ptr<common::Filter>>& disjuncts) {
+  // Check if all filters are single-value equalities: a = 5. Convert these to
+  // an IN list.
+  if (std::all_of(disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return isBigintRange(filter) &&
+            filter->template as<common::BigintRange>()->isSingleValue();
+      })) {
+    std::vector<int64_t> values;
+    values.reserve(disjuncts.size());
+
+    for (auto& filter : disjuncts) {
+      values.emplace_back(filter->as<common::BigintRange>()->lower());
+    }
+
+    return common::createBigintValues(values, isNullAllowed(disjuncts));
+  }
+
+  if (!std::all_of(disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return isBigintRange(filter) || isBigintMultiRange(filter);
+      })) {
+    return nullptr;
+  }
+
+  const bool nullAllowed = isNullAllowed(disjuncts);
+
+  std::vector<std::unique_ptr<common::BigintRange>> ranges;
+  for (auto& filter : disjuncts) {
+    if (isBigintRange(filter)) {
+      ranges.emplace_back(asBigintRange(filter));
+    } else {
+      for (const auto& range :
+           filter->as<common::BigintMultiRange>()->ranges()) {
+        ranges.emplace_back(std::make_unique<common::BigintRange>(*range));
+      }
+    }
+  }
+
+  std::sort(ranges.begin(), ranges.end(), [](const auto& a, const auto& b) {
+    return a->lower() < b->lower();
+  });
+
+  return mergeOverlappingDisjuncts(
+      ranges, nullAllowed, [](auto& newRanges, bool nullAllowed) {
+        return std::make_unique<common::BigintMultiRange>(
+            std::move(newRanges), nullAllowed);
+      });
+}
+
+template <typename T>
+std::unique_ptr<common::Filter> tryMergeFloatingPointRanges(
+    std::vector<std::unique_ptr<common::Filter>>& disjuncts) {
+  constexpr auto filterKind = std::is_same_v<T, double>
+      ? common::FilterKind::kDoubleRange
+      : common::FilterKind::kFloatRange;
+
+  if (!std::all_of(disjuncts.begin(), disjuncts.end(), [](const auto& filter) {
+        return filter->is(filterKind);
+      })) {
+    return nullptr;
+  }
+
+  const bool nullAllowed = isNullAllowed(disjuncts);
+
+  std::vector<std::unique_ptr<common::FloatingPointRange<T>>> ranges;
+  ranges.reserve(disjuncts.size());
+  for (auto& filter : disjuncts) {
+    ranges.emplace_back(
+        asUniquePtr<common::FloatingPointRange<T>>(std::move(filter)));
+  }
+
+  std::sort(ranges.begin(), ranges.end(), [](const auto& a, const auto& b) {
+    if (a->lowerUnbounded() && b->lowerUnbounded()) {
+      return false;
+    }
+
+    if (a->lowerUnbounded()) {
+      return true;
+    }
+
+    if (b->lowerUnbounded()) {
+      return false;
+    }
+
+    return a->lower() < b->lower();
+  });
+
+  return mergeOverlappingDisjuncts(
+      ranges, nullAllowed, [](auto& newRanges, bool nullAllowed) {
+        std::vector<std::unique_ptr<common::Filter>> filters;
+        filters.reserve(newRanges.size());
+        for (auto& range : newRanges) {
+          filters.emplace_back(std::move(range));
+        }
+        return std::make_unique<common::MultiRange>(
+            std::move(filters), nullAllowed);
+      });
+}
+
+} // namespace
+
+// static
+std::unique_ptr<common::Filter> ExprToSubfieldFilterParser::makeOrFilter(
+    std::vector<std::unique_ptr<common::Filter>> disjuncts) {
+  VELOX_CHECK_GE(disjuncts.size(), 2);
+
+  if (auto merged = tryMergeBigintRanges(disjuncts)) {
+    return merged;
+  }
+
+  if (auto merged = tryMergeFloatingPointRanges<double>(disjuncts)) {
+    return merged;
+  }
+
+  if (auto merged = tryMergeFloatingPointRanges<float>(disjuncts)) {
+    return merged;
+  }
+
+  return nullptr;
+}
+
+namespace {
+std::optional<std::pair<common::Subfield, std::unique_ptr<common::Filter>>>
+combine(common::Subfield& subfield, std::unique_ptr<common::Filter>& filter) {
+  if (filter != nullptr) {
+    return std::make_pair(std::move(subfield), std::move(filter));
+  }
+
+  return std::nullopt;
+}
+} // namespace
+
+std::optional<std::pair<common::Subfield, std::unique_ptr<common::Filter>>>
 PrestoExprToSubfieldFilterParser::leafCallToSubfieldFilter(
     const core::CallTypedExpr& call,
-    common::Subfield& subfield,
     core::ExpressionEvaluator* evaluator,
     bool negated) {
   if (call.inputs().empty()) {
-    return nullptr;
+    return std::nullopt;
   }
 
   const auto* leftSide = call.inputs()[0].get();
 
+  common::Subfield subfield;
   if (call.name() == "eq") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeNotEqualFilter(call.inputs()[1], evaluator)
-                     : makeEqualFilter(call.inputs()[1], evaluator);
+      auto filter = negated ? makeNotEqualFilter(call.inputs()[1], evaluator)
+                            : makeEqualFilter(call.inputs()[1], evaluator);
+
+      return combine(subfield, filter);
     }
   } else if (call.name() == "neq") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeEqualFilter(call.inputs()[1], evaluator)
-                     : makeNotEqualFilter(call.inputs()[1], evaluator);
+      auto filter = negated ? makeEqualFilter(call.inputs()[1], evaluator)
+                            : makeNotEqualFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "lte") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeGreaterThanFilter(call.inputs()[1], evaluator)
-                     : makeLessThanOrEqualFilter(call.inputs()[1], evaluator);
+      auto filter = negated
+          ? makeGreaterThanFilter(call.inputs()[1], evaluator)
+          : makeLessThanOrEqualFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "lt") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeGreaterThanOrEqualFilter(call.inputs()[1], evaluator)
-                     : makeLessThanFilter(call.inputs()[1], evaluator);
+      auto filter = negated
+          ? makeGreaterThanOrEqualFilter(call.inputs()[1], evaluator)
+          : makeLessThanFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "gte") {
     if (toSubfield(leftSide, subfield)) {
-      return negated
+      auto filter = negated
           ? makeLessThanFilter(call.inputs()[1], evaluator)
           : makeGreaterThanOrEqualFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "gt") {
     if (toSubfield(leftSide, subfield)) {
-      return negated ? makeLessThanOrEqualFilter(call.inputs()[1], evaluator)
-                     : makeGreaterThanFilter(call.inputs()[1], evaluator);
+      auto filter = negated
+          ? makeLessThanOrEqualFilter(call.inputs()[1], evaluator)
+          : makeGreaterThanFilter(call.inputs()[1], evaluator);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "between") {
     if (toSubfield(leftSide, subfield)) {
-      return makeBetweenFilter(
+      auto filter = makeBetweenFilter(
           call.inputs()[1], call.inputs()[2], evaluator, negated);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "in") {
     if (toSubfield(leftSide, subfield)) {
-      return makeInFilter(call.inputs()[1], evaluator, negated);
+      auto filter = makeInFilter(call.inputs()[1], evaluator, negated);
+      return combine(subfield, filter);
     }
   } else if (call.name() == "is_null") {
     if (toSubfield(leftSide, subfield)) {
       if (negated) {
-        return isNotNull();
-      }
-      return isNull();
-    }
-  }
-  return nullptr;
-}
-
-std::pair<common::Subfield, std::unique_ptr<common::Filter>> toSubfieldFilter(
-    const core::TypedExprPtr& expr,
-    core::ExpressionEvaluator* evaluator) {
-  if (auto call = asCall(expr.get())) {
-    if (call->name() == "or") {
-      auto left = toSubfieldFilter(call->inputs()[0], evaluator);
-      auto right = toSubfieldFilter(call->inputs()[1], evaluator);
-      VELOX_CHECK(left.first == right.first);
-      return {
-          std::move(left.first),
-          makeOrFilter(std::move(left.second), std::move(right.second))};
-    }
-    common::Subfield subfield;
-    std::unique_ptr<common::Filter> filter;
-    if (call->name() == "not") {
-      if (auto* inner = asCall(call->inputs()[0].get())) {
-        filter =
-            ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-                *inner, subfield, evaluator, true);
+        return std::make_pair(std::move(subfield), isNotNull());
       }
-    } else {
-      filter =
-          ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-              *call, subfield, evaluator, false);
-    }
-    if (filter) {
-      return std::make_pair(std::move(subfield), std::move(filter));
+      return std::make_pair(std::move(subfield), isNull());
     }
   }
-  VELOX_UNSUPPORTED(
-      "Unsupported expression for range filter: {}", expr->toString());
+  return std::nullopt;
 }
 
 } // namespace facebook::velox::exec
diff --git a/velox/expression/ExprToSubfieldFilter.h b/velox/expression/ExprToSubfieldFilter.h
index 12ea9b4c2637..67dd1c7a7b54 100644
--- a/velox/expression/ExprToSubfieldFilter.h
+++ b/velox/expression/ExprToSubfieldFilter.h
@@ -52,9 +52,10 @@ inline std::unique_ptr<common::BigintRange> greaterThanOrEqual(
 }
 
 inline std::unique_ptr<common::NegatedBigintRange> notEqual(
-    int64_t val,
+    int64_t value,
     bool nullAllowed = false) {
-  return std::make_unique<common::NegatedBigintRange>(val, val, nullAllowed);
+  return std::make_unique<common::NegatedBigintRange>(
+      value, value, nullAllowed);
 }
 
 inline std::unique_ptr<common::NegatedBigintRange>
@@ -221,64 +222,58 @@ inline std::unique_ptr<common::BigintRange> equal(
   return std::make_unique<common::BigintRange>(value, value, nullAllowed);
 }
 
-inline std::unique_ptr<common::BytesRange> between(
-    const std::string& min,
-    const std::string& max,
-    bool nullAllowed = false) {
+inline std::unique_ptr<common::BytesRange>
+between(std::string min, std::string max, bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      min, false, false, max, false, false, nullAllowed);
+      std::move(min), false, false, std::move(max), false, false, nullAllowed);
 }
 
-inline std::unique_ptr<common::BytesRange> betweenExclusive(
-    const std::string& min,
-    const std::string& max,
-    bool nullAllowed = false) {
+inline std::unique_ptr<common::BytesRange>
+betweenExclusive(std::string min, std::string max, bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      min, false, true, max, false, true, nullAllowed);
+      std::move(min), false, true, std::move(max), false, true, nullAllowed);
 }
 
-inline std::unique_ptr<common::NegatedBytesRange> notBetween(
-    const std::string& min,
-    const std::string& max,
-    bool nullAllowed = false) {
+inline std::unique_ptr<common::NegatedBytesRange>
+notBetween(std::string min, std::string max, bool nullAllowed = false) {
   return std::make_unique<common::NegatedBytesRange>(
-      min, false, false, max, false, false, nullAllowed);
+      std::move(min), false, false, std::move(max), false, false, nullAllowed);
 }
 
 inline std::unique_ptr<common::NegatedBytesRange> notBetweenExclusive(
-    const std::string& min,
-    const std::string& max,
+    std::string min,
+    std::string max,
     bool nullAllowed = false) {
   return std::make_unique<common::NegatedBytesRange>(
-      min, false, true, max, false, true, nullAllowed);
+      std::move(min), false, true, std::move(max), false, true, nullAllowed);
 }
 
 inline std::unique_ptr<common::BytesRange> lessThanOrEqual(
-    const std::string& max,
+    std::string max,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      "", true, false, max, false, false, nullAllowed);
+      "", true, false, std::move(max), false, false, nullAllowed);
 }
 
 inline std::unique_ptr<common::BytesRange> lessThan(
-    const std::string& max,
+    std::string max,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      "", true, false, max, false, true, nullAllowed);
+      "", true, false, std::move(max), false, true, nullAllowed);
 }
 
 inline std::unique_ptr<common::BytesRange> greaterThanOrEqual(
-    const std::string& min,
+    std::string min,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      min, false, false, "", true, false, nullAllowed);
+      std::move(min), false, false, "", true, false, nullAllowed);
 }
 
 inline std::unique_ptr<common::BytesRange> greaterThan(
-    const std::string& min,
+    std::string min,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesRange>(
-      min, false, true, "", true, false, nullAllowed);
+      std::move(min), false, true, "", true, false, nullAllowed);
 }
 
 inline std::unique_ptr<common::Filter> in(
@@ -287,24 +282,48 @@ inline std::unique_ptr<common::Filter> in(
   return common::createBigintValues(values, nullAllowed);
 }
 
+inline std::unique_ptr<common::Filter> in(
+    std::initializer_list<int64_t> values,
+    bool nullAllowed = false) {
+  return in(std::vector<int64_t>(values), nullAllowed);
+}
+
 inline std::unique_ptr<common::Filter> notIn(
     const std::vector<int64_t>& values,
     bool nullAllowed = false) {
   return common::createNegatedBigintValues(values, nullAllowed);
 }
 
+inline std::unique_ptr<common::Filter> notIn(
+    std::initializer_list<int64_t> values,
+    bool nullAllowed = false) {
+  return notIn(std::vector<int64_t>(values), nullAllowed);
+}
+
 inline std::unique_ptr<common::BytesValues> in(
     const std::vector<std::string>& values,
     bool nullAllowed = false) {
   return std::make_unique<common::BytesValues>(values, nullAllowed);
 }
 
+inline std::unique_ptr<common::BytesValues> in(
+    std::initializer_list<std::string> values,
+    bool nullAllowed = false) {
+  return in(std::vector<std::string>(values), nullAllowed);
+}
+
 inline std::unique_ptr<common::NegatedBytesValues> notIn(
     const std::vector<std::string>& values,
     bool nullAllowed = false) {
   return std::make_unique<common::NegatedBytesValues>(values, nullAllowed);
 }
 
+inline std::unique_ptr<common::NegatedBytesValues> notIn(
+    std::initializer_list<std::string> values,
+    bool nullAllowed = false) {
+  return notIn(std::vector<std::string>(values), nullAllowed);
+}
+
 inline std::unique_ptr<common::BoolValue> boolEqual(
     bool value,
     bool nullAllowed = false) {
@@ -319,6 +338,10 @@ inline std::unique_ptr<common::IsNotNull> isNotNull() {
   return std::make_unique<common::IsNotNull>();
 }
 
+inline std::unique_ptr<common::AlwaysTrue> alwaysTrue() {
+  return std::make_unique<common::AlwaysTrue>();
+}
+
 template <typename T>
 std::unique_ptr<common::MultiRange>
 orFilter(std::unique_ptr<T> a, std::unique_ptr<T> b, bool nullAllowed = false) {
@@ -367,10 +390,6 @@ betweenHugeint(int128_t min, int128_t max, bool nullAllowed = false) {
   return std::make_unique<common::HugeintRange>(min, max, nullAllowed);
 }
 
-std::pair<common::Subfield, std::unique_ptr<common::Filter>> toSubfieldFilter(
-    const core::TypedExprPtr& expr,
-    core::ExpressionEvaluator*);
-
 inline std::unique_ptr<common::TimestampRange> equal(
     const Timestamp& value,
     bool nullAllowed = false) {
@@ -412,96 +431,119 @@ inline std::unique_ptr<common::TimestampRange> greaterThanOrEqual(
       min, std::numeric_limits<Timestamp>::max(), nullAllowed);
 }
 
-/// Provides the instance and helper functions to convert a leaf call
-/// expression to subfield filter. Allows the registration of custom parser.
+/// Language-specific translator of generic expressions into subfield filters.
+/// Default language is Presto. A different language can be supported by
+/// registering language-specific implementation using 'registerParser' API.
 class ExprToSubfieldFilterParser {
  public:
   virtual ~ExprToSubfieldFilterParser() = default;
 
-  static std::shared_ptr<ExprToSubfieldFilterParser> getInstance() {
-    return parserFactory_();
+  /// Returns a parser provided to an earlier 'registerParser' call. Not thread
+  /// safe.
+  static const std::shared_ptr<ExprToSubfieldFilterParser>& getInstance() {
+    VELOX_CHECK_NOT_NULL(parser_, "Parser is not registered");
+    return parser_;
   }
 
-  /// Registers a custom parser factory. The factory is called to create a
-  /// parser instance.
-  static void registerParserFactory(
-      std::function<std::shared_ptr<ExprToSubfieldFilterParser>()>
-          parserFactory) {
-    parserFactory_ = std::move(parserFactory);
+  /// Registers a parser. Silently overwrites previously registered parser if
+  /// any. Not thread safe.
+  static void registerParser(
+      std::shared_ptr<ExprToSubfieldFilterParser> parser) {
+    VELOX_CHECK_NOT_NULL(parser);
+    parser_ = std::move(parser);
   }
 
-  /// Converts a leaf call expression (no conjunction like AND/OR) to subfield
-  /// and filter. Return nullptr if not supported for pushdown. This is needed
-  /// because this conversion is frequently applied when extracting filters from
-  /// remaining filter in readers. Frequent throw clutters logs and slows down
-  /// execution.
-  virtual std::unique_ptr<common::Filter> leafCallToSubfieldFilter(
+  /// Analyzes 'call' expression to determine if it can be expressed as a
+  /// subfield filter. Returns the subfield and filter if so. Otherwise, returns
+  /// std::nullopt. If 'negated' is true, considers the negation of 'call'
+  /// expressions (not(call)). It is possible that 'call' expression can be
+  /// represented as subfield filter, but its negation cannot.
+  virtual std::optional<
+      std::pair<common::Subfield, std::unique_ptr<common::Filter>>>
+  leafCallToSubfieldFilter(
       const core::CallTypedExpr& call,
-      common::Subfield& subfield,
       core::ExpressionEvaluator* evaluator,
       bool negated = false) = 0;
 
+  /// Combines 2 or more filters with an OR.
+  /// Detects overlapping ranges of bigint and floating point values.
+  /// Detects a list of single-value bigint filters and combines them into a
+  /// single IN list.
+  /// Returns nullptr if no combination has been made.
+  static std::unique_ptr<common::Filter> makeOrFilter(
+      std::vector<std::unique_ptr<common::Filter>> disjuncts);
+
+  template <typename... Disjuncts>
+  static std::unique_ptr<common::Filter> makeOrFilter(
+      Disjuncts&&... disjuncts) {
+    std::vector<std::unique_ptr<common::Filter>> filters;
+    filters.reserve(sizeof...(Disjuncts));
+    (filters.emplace_back(std::forward<Disjuncts>(disjuncts)), ...);
+    return makeOrFilter(std::move(filters));
+  }
+
  protected:
-  // Converts an expression into a subfield. Returns false if the expression is
-  // not a valid field expression.
-  bool toSubfield(const core::ITypedExpr* field, common::Subfield& subfield);
+  // Converts an expression into a subfield. Returns false if the expression
+  // is not a valid field expression.
+  static bool toSubfield(
+      const core::ITypedExpr* field,
+      common::Subfield& subfield);
 
   // Creates a non-equal subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeNotEqualFilter(
+  static std::unique_ptr<common::Filter> makeNotEqualFilter(
       const core::TypedExprPtr& valueExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates an equal subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeEqualFilter(
+  static std::unique_ptr<common::Filter> makeEqualFilter(
       const core::TypedExprPtr& valueExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates a greater-than subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeGreaterThanFilter(
+  static std::unique_ptr<common::Filter> makeGreaterThanFilter(
       const core::TypedExprPtr& lowerExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates a less-than subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeLessThanFilter(
+  static std::unique_ptr<common::Filter> makeLessThanFilter(
       const core::TypedExprPtr& upperExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates a less-than-or-equal subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeLessThanOrEqualFilter(
+  static std::unique_ptr<common::Filter> makeLessThanOrEqualFilter(
       const core::TypedExprPtr& upperExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates a greater-than-or-equal subfield filter against the given constant.
-  std::unique_ptr<common::Filter> makeGreaterThanOrEqualFilter(
+  static std::unique_ptr<common::Filter> makeGreaterThanOrEqualFilter(
       const core::TypedExprPtr& lowerExpr,
       core::ExpressionEvaluator* evaluator);
 
   // Creates an in subfield filter against the given vector.
-  std::unique_ptr<common::Filter> makeInFilter(
+  static std::unique_ptr<common::Filter> makeInFilter(
       const core::TypedExprPtr& expr,
       core::ExpressionEvaluator* evaluator,
       bool negated);
 
   // Creates a between subfield filter against the given lower and upper
   // bounds.
-  std::unique_ptr<common::Filter> makeBetweenFilter(
+  static std::unique_ptr<common::Filter> makeBetweenFilter(
       const core::TypedExprPtr& lowerExpr,
       const core::TypedExprPtr& upperExpr,
       core::ExpressionEvaluator* evaluator,
       bool negated);
 
  private:
-  // Factory method to create a parser instance.
-  static std::function<std::shared_ptr<ExprToSubfieldFilterParser>()>
-      parserFactory_;
+  // Singleton parser instance.
+  static std::shared_ptr<ExprToSubfieldFilterParser> parser_;
 };
 
 // Parser for Presto expressions.
 class PrestoExprToSubfieldFilterParser : public ExprToSubfieldFilterParser {
  public:
-  std::unique_ptr<common::Filter> leafCallToSubfieldFilter(
+  std::optional<std::pair<common::Subfield, std::unique_ptr<common::Filter>>>
+  leafCallToSubfieldFilter(
       const core::CallTypedExpr& call,
-      common::Subfield& subfield,
       core::ExpressionEvaluator* evaluator,
       bool negated = false) override;
 };
diff --git a/velox/expression/ExprUtils.cpp b/velox/expression/ExprUtils.cpp
new file mode 100644
index 000000000000..201b49a935ea
--- /dev/null
+++ b/velox/expression/ExprUtils.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/expression/ExprUtils.h"
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression::utils {
+
+bool isCall(const core::TypedExprPtr& expr, const std::string& name) {
+  if (expr->isCallKind()) {
+    return expr->asUnchecked<core::CallTypedExpr>()->name() == name;
+  }
+  return false;
+}
+
+void flattenInput(
+    const core::TypedExprPtr& input,
+    const std::string& flattenCall,
+    std::vector<core::TypedExprPtr>& flat) {
+  if (isCall(input, flattenCall) && allInputTypesEquivalent(input)) {
+    for (auto& child : input->inputs()) {
+      flattenInput(child, flattenCall, flat);
+    }
+  } else {
+    flat.emplace_back(input);
+  }
+}
+
+bool allInputTypesEquivalent(const core::TypedExprPtr& expr) {
+  const auto& inputs = expr->inputs();
+  for (int i = 1; i < inputs.size(); i++) {
+    if (!inputs[0]->type()->equivalent(*inputs[i]->type())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace facebook::velox::expression::utils
diff --git a/velox/expression/ExprUtils.h b/velox/expression/ExprUtils.h
new file mode 100644
index 000000000000..51acfc50c004
--- /dev/null
+++ b/velox/expression/ExprUtils.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/expression/Expr.h"
+
+namespace facebook::velox::expression::utils {
+
+/// Returns true if expr is of type CallTypedExpr and the expr name matches
+/// the passed name. Otherwise, returns false.
+bool isCall(const core::TypedExprPtr& expr, const std::string& name);
+
+/// Utility method to check eligibility for flattening. Returns true if all
+/// inputs to expr have the same type.
+bool allInputTypesEquivalent(const core::TypedExprPtr& expr);
+
+/// Recursively flattens nested ANDs, ORs or eligible callable expressions into
+/// a vector of their inputs. Recursive flattening ceases exploring an input
+/// branch if it encounters either an expression different from 'flattenCall' or
+/// its inputs are not the same type. Examples:
+/// flattenCall: AND
+/// in: a AND (b AND (c AND d))
+/// out: [a, b, c, d]
+///
+/// flattenCall: OR
+/// in: (a OR b) OR (c OR d)
+/// out: [a, b, c, d]
+///
+/// flattenCall: concat
+/// in: (array1, concat(array2, concat(array3, array4))
+/// out: [array1, array2, array3, array4]
+void flattenInput(
+    const core::TypedExprPtr& input,
+    const std::string& flattenCall,
+    std::vector<core::TypedExprPtr>& flat);
+
+} // namespace facebook::velox::expression::utils
diff --git a/velox/expression/FieldReference.cpp b/velox/expression/FieldReference.cpp
index f68678a2e50e..fe9a4cc5d361 100644
--- a/velox/expression/FieldReference.cpp
+++ b/velox/expression/FieldReference.cpp
@@ -15,8 +15,9 @@
  */
 
 #include "velox/expression/FieldReference.h"
-
+#include "velox/common/memory/RawVector.h"
 #include "velox/expression/PeeledEncoding.h"
+#include "velox/vector/LazyVector.h"
 
 namespace facebook::velox::exec {
 
@@ -30,6 +31,40 @@ void FieldReference::computeDistinctFields() {
   }
 }
 
+namespace {
+
+// Load the parent RowVector but keep any lazy in its children.
+const RowVector* loadRowVector(
+    const BaseVector& vector,
+    const SelectivityVector& rows) {
+  switch (vector.encoding()) {
+    case VectorEncoding::Simple::ROW:
+      return static_cast<const RowVector*>(&vector);
+    case VectorEncoding::Simple::LAZY: {
+      auto* lazy = vector.asUnchecked<LazyVector>();
+      if (!lazy->isLoaded()) {
+        // This condition could be loosen but we leave it here for now to inform
+        // us any inefficiency in lazy loading.
+        VELOX_CHECK(rows.isAllSelected());
+        raw_vector<vector_size_t> rowSetHolder;
+        RowSet rowSet(iota(rows.end(), rowSetHolder), rows.end());
+        lazy->load(rowSet, nullptr);
+      }
+      return loadRowVector(*lazy->loadedVector(), rows);
+    }
+    default:
+      // If we get dictionary encoding here, it is generated by remaining
+      // filter.  Since we have full control over the plan when we use lazy
+      // dereference, remaining filter should be put in downstream of lazy
+      // dereference node when we generate the plan.  We may need to revisit
+      // this in fallback cases later (e.g. no control over the plan, fallback
+      // filtering).
+      VELOX_FAIL("Unsupported encoding: {}", vector.encoding());
+  }
+}
+
+} // namespace
+
 void FieldReference::apply(
     const SelectivityVector& rows,
     EvalCtx& context,
@@ -45,34 +80,38 @@ void FieldReference::apply(
     row = context.row();
   } else {
     inputs_[0]->eval(rows, context, input);
-
-    decoded.decode(*input, rows);
-    if (decoded.mayHaveNulls()) {
-      nonNullRowsHolder.get(rows);
-      nonNullRowsHolder->deselectNulls(
-          decoded.nulls(&rows), rows.begin(), rows.end());
-      nonNullRows = nonNullRowsHolder.get();
-      if (!nonNullRows->hasSelections()) {
-        addNulls(rows, decoded.nulls(&rows), context, result);
-        return;
+    if (context.lazyDereference() && isLazyNotLoaded(*input)) {
+      row = loadRowVector(*input, rows);
+    } else {
+      decoded.decode(*input, rows);
+      if (decoded.mayHaveNulls()) {
+        nonNullRowsHolder.get(rows);
+        nonNullRowsHolder->deselectNulls(
+            decoded.nulls(&rows), rows.begin(), rows.end());
+        nonNullRows = nonNullRowsHolder.get();
+        if (!nonNullRows->hasSelections()) {
+          addNulls(rows, decoded.nulls(&rows), context, result);
+          return;
+        }
       }
-    }
-    useDecode = !decoded.isIdentityMapping();
-    if (useDecode) {
-      std::vector<VectorPtr> peeledVectors;
-      LocalDecodedVector localDecoded{context};
-      peeledEncoding = PeeledEncoding::peel(
-          {input}, *nonNullRows, localDecoded, true, peeledVectors);
-      VELOX_CHECK_NOT_NULL(peeledEncoding);
-      if (peeledVectors[0]->isLazy()) {
-        peeledVectors[0] =
-            peeledVectors[0]->as<LazyVector>()->loadedVectorShared();
+      useDecode = !decoded.isIdentityMapping();
+      if (useDecode) {
+        std::vector<VectorPtr> peeledVectors;
+        LocalDecodedVector localDecoded{context};
+        peeledEncoding = PeeledEncoding::peel(
+            {input}, *nonNullRows, localDecoded, true, peeledVectors);
+        VELOX_CHECK_NOT_NULL(peeledEncoding);
+        if (peeledVectors[0]->isLazy()) {
+          peeledVectors[0] =
+              peeledVectors[0]->as<LazyVector>()->loadedVectorShared();
+        }
+        VELOX_CHECK(
+            peeledVectors[0]->encoding() == VectorEncoding::Simple::ROW);
+        row = peeledVectors[0]->as<const RowVector>();
+      } else {
+        VELOX_CHECK(input->encoding() == VectorEncoding::Simple::ROW);
+        row = input->as<const RowVector>();
       }
-      VELOX_CHECK(peeledVectors[0]->encoding() == VectorEncoding::Simple::ROW);
-      row = peeledVectors[0]->as<const RowVector>();
-    } else {
-      VELOX_CHECK(input->encoding() == VectorEncoding::Simple::ROW);
-      row = input->as<const RowVector>();
     }
   }
   if (index_ == -1) {
@@ -82,7 +121,8 @@ void FieldReference::apply(
   }
   VectorPtr child =
       inputs_.empty() ? context.getField(index_) : row->childAt(index_);
-  if (child->encoding() == VectorEncoding::Simple::LAZY) {
+  if (child->encoding() == VectorEncoding::Simple::LAZY &&
+      !context.lazyDereference()) {
     child = BaseVector::loadedVectorShared(child);
   }
   if (result.get()) {
diff --git a/velox/expression/FieldReference.h b/velox/expression/FieldReference.h
index ed1b12bc2c15..0a8e9546503f 100644
--- a/velox/expression/FieldReference.h
+++ b/velox/expression/FieldReference.h
@@ -26,6 +26,7 @@ class FieldReference : public SpecialForm {
       const std::vector<ExprPtr>& inputs,
       const std::string& field)
       : SpecialForm(
+            SpecialFormKind::kFieldAccess,
             std::move(type),
             inputs,
             field,
@@ -38,6 +39,7 @@ class FieldReference : public SpecialForm {
       const std::vector<ExprPtr>& inputs,
       int32_t index)
       : SpecialForm(
+            SpecialFormKind::kFieldAccess,
             std::move(type),
             inputs,
             inputs.at(0)->type()->asRow().nameOf(index),
@@ -50,8 +52,8 @@ class FieldReference : public SpecialForm {
     return field_;
   }
 
-  bool isConstant() const override {
-    return SpecialForm::isConstant() && !inputs_.empty();
+  bool isConstantExpr() const override {
+    return Expr::isConstantExpr() && !inputs_.empty();
   }
 
   int32_t index(const EvalCtx& context) {
diff --git a/velox/expression/FunctionCallToSpecialForm.cpp b/velox/expression/FunctionCallToSpecialForm.cpp
index 86135ba134e8..c23fbd8ba75f 100644
--- a/velox/expression/FunctionCallToSpecialForm.cpp
+++ b/velox/expression/FunctionCallToSpecialForm.cpp
@@ -31,6 +31,18 @@ TypePtr resolveTypeForSpecialForm(
   return specialForm->resolveType(argTypes);
 }
 
+TypePtr resolveTypeForSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  auto specialForm = specialFormRegistry().getSpecialForm(functionName);
+  if (specialForm == nullptr) {
+    return nullptr;
+  }
+
+  return specialForm->resolveTypeWithCorsions(argTypes, coercions);
+}
+
 ExprPtr constructSpecialForm(
     const std::string& functionName,
     const TypePtr& type,
diff --git a/velox/expression/FunctionCallToSpecialForm.h b/velox/expression/FunctionCallToSpecialForm.h
index 5f6b0db8e925..9da39b70edd6 100644
--- a/velox/expression/FunctionCallToSpecialForm.h
+++ b/velox/expression/FunctionCallToSpecialForm.h
@@ -30,6 +30,17 @@ class FunctionCallToSpecialForm {
   /// arguments, e.g. Try.
   virtual TypePtr resolveType(const std::vector<TypePtr>& argTypes) = 0;
 
+  /// Like 'resolveType', but with support for applying type conversions if a
+  /// special form signature doesn't match 'argTypes' exactly. Support varies
+  /// from special form to special form. By default, no coersions are attempted.
+  virtual TypePtr resolveTypeWithCorsions(
+      const std::vector<TypePtr>& argTypes,
+      [[maybe_unused]] std::vector<TypePtr>& coercions) {
+    coercions.clear();
+    coercions.resize(argTypes.size());
+    return resolveType(argTypes);
+  }
+
   /// Given the output Type, the child expresssions, and whether or not to track
   /// CPU usage, returns the SpecialForm.
   virtual ExprPtr constructSpecialForm(
@@ -47,6 +58,11 @@ TypePtr resolveTypeForSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+TypePtr resolveTypeForSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions);
+
 /// Returns the SpeicalForm associated with the functionName.  If functionName
 /// is not the name of a known SpecialForm, returns nulltpr.
 ExprPtr constructSpecialForm(
diff --git a/velox/expression/FunctionSignature.cpp b/velox/expression/FunctionSignature.cpp
index a1460f1355a9..68e3a31f72ea 100644
--- a/velox/expression/FunctionSignature.cpp
+++ b/velox/expression/FunctionSignature.cpp
@@ -106,6 +106,12 @@ void validateBaseTypeAndCollectTypeParams(
     const TypeSignature& arg,
     std::unordered_set<std::string>& collectedTypeVariables,
     bool isReturnType) {
+  if (isReturnType) {
+    VELOX_USER_CHECK(
+        !arg.isHomogeneousRow(),
+        "Homogeneous row cannot appear in return type");
+  }
+
   if (!variables.count(arg.baseName())) {
     auto typeName = boost::algorithm::to_upper_copy(arg.baseName());
 
@@ -119,7 +125,7 @@ void validateBaseTypeAndCollectTypeParams(
     }
 
     if (!isPositiveInteger(typeName) &&
-        !tryMapNameToTypeKind(typeName).has_value() &&
+        !TypeKindName::tryToTypeKind(typeName).has_value() &&
         !isDecimalName(typeName) && !isDateName(typeName)) {
       VELOX_USER_CHECK(hasType(typeName), "Type doesn't exist: '{}'", typeName);
     }
@@ -146,18 +152,26 @@ void validate(
     const TypeSignature& returnType,
     const std::vector<TypeSignature>& argumentTypes,
     const std::vector<bool>& constantArguments,
+    bool variableArity,
     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 ?
     validateBaseTypeAndCollectTypeParams(variables, arg, usedVariables, false);
   }
 
+  if (variableArity) {
+    VELOX_USER_CHECK(
+        !argumentTypes.empty(),
+        "Variable arity requires at least one argument");
+  }
+
   // All type variables should apear in the inputs arguments.
   for (auto& [name, variable] : variables) {
     if (variable.isTypeParameter()) {
@@ -189,23 +203,44 @@ SignatureVariable::SignatureVariable(
     ParameterType type,
     bool knownTypesOnly,
     bool orderableTypesOnly,
-    bool comaprableTypesOnly)
+    bool comparableTypesOnly)
     : name_{std::move(name)},
       constraint_(constraint.has_value() ? std::move(constraint.value()) : ""),
       type_{type},
       knownTypesOnly_(knownTypesOnly),
       orderableTypesOnly_(orderableTypesOnly),
-      comparableTypesOnly_(comaprableTypesOnly) {
+      comparableTypesOnly_(comparableTypesOnly) {
   VELOX_CHECK(
       !(knownTypesOnly_ || orderableTypesOnly_ || comparableTypesOnly_) ||
           isTypeParameter(),
       "Non-Type variables cannot have the knownTypesOnly/orderableTypesOnly/comparableTypesOnly constraint");
 
   VELOX_CHECK(
-      isIntegerParameter() || (isTypeParameter() && constraint_.empty()),
+      (isIntegerParameter() || isEnumParameter() ||
+       (isTypeParameter() && constraint_.empty())),
       "Type variables cannot have constraints");
 }
 
+bool SignatureVariable::isEligibleType(const Type& type) const {
+  if (!isTypeParameter()) {
+    return false;
+  }
+
+  if (knownTypesOnly_ && type.isUnKnown()) {
+    return false;
+  }
+
+  if (orderableTypesOnly_ && !type.isOrderable()) {
+    return false;
+  }
+
+  if (comparableTypesOnly_ && !type.isComparable()) {
+    return false;
+  }
+
+  return true;
+}
+
 FunctionSignature::FunctionSignature(
     std::unordered_map<std::string, SignatureVariable> variables,
     TypeSignature returnType,
@@ -217,7 +252,12 @@ FunctionSignature::FunctionSignature(
       argumentTypes_{std::move(argumentTypes)},
       constantArguments_{std::move(constantArguments)},
       variableArity_{variableArity} {
-  validate(variables_, returnType_, argumentTypes_, constantArguments_);
+  validate(
+      variables_,
+      returnType_,
+      argumentTypes_,
+      constantArguments_,
+      variableArity_);
 }
 
 FunctionSignature::FunctionSignature(
@@ -237,6 +277,7 @@ FunctionSignature::FunctionSignature(
       returnType_,
       argumentTypes_,
       constantArguments_,
+      variableArity_,
       additionalTypes);
 }
 
@@ -267,7 +308,7 @@ FunctionSignatureBuilder& FunctionSignatureBuilder::knownTypeVariable(
           ParameterType::kTypeParameter,
           /*knownTypesOnly*/ true,
           /*orderableTypesOnly*/ false,
-          /*comaprableTypesOnly*/ false));
+          /*comparableTypesOnly*/ false));
   return *this;
 }
 
@@ -281,7 +322,7 @@ FunctionSignatureBuilder& FunctionSignatureBuilder::orderableTypeVariable(
           ParameterType::kTypeParameter,
           /*knownTypesOnly*/ false,
           /*orderableTypesOnly*/ true,
-          /*comaprableTypesOnly*/ true));
+          /*comparableTypesOnly*/ true));
   return *this;
 }
 
@@ -295,7 +336,7 @@ FunctionSignatureBuilder& FunctionSignatureBuilder::comparableTypeVariable(
           ParameterType::kTypeParameter,
           /*knownTypesOnly*/ false,
           /*orderableTypesOnly*/ false,
-          /*comaprableTypesOnly*/ true));
+          /*comparableTypesOnly*/ true));
   return *this;
 }
 
@@ -322,7 +363,7 @@ AggregateFunctionSignatureBuilder::knownTypeVariable(const std::string& name) {
           ParameterType::kTypeParameter,
           /*knownTypesOnly*/ true,
           /*orderableTypesOnly*/ false,
-          /*comaprableTypesOnly*/ false));
+          /*comparableTypesOnly*/ false));
   return *this;
 }
 
@@ -337,7 +378,7 @@ AggregateFunctionSignatureBuilder::orderableTypeVariable(
           ParameterType::kTypeParameter,
           /*knownTypesOnly*/ false,
           /*orderableTypesOnly*/ true,
-          /*comaprableTypesOnly*/ true));
+          /*comparableTypesOnly*/ true));
   return *this;
 }
 
@@ -352,7 +393,7 @@ AggregateFunctionSignatureBuilder::comparableTypeVariable(
           ParameterType::kTypeParameter,
           /*knownTypesOnly*/ false,
           /*orderableTypesOnly*/ false,
-          /*comaprableTypesOnly*/ true));
+          /*comparableTypesOnly*/ true));
   return *this;
 }
 
diff --git a/velox/expression/FunctionSignature.h b/velox/expression/FunctionSignature.h
index 35e51ad20ce3..3d0cbc8ddb54 100644
--- a/velox/expression/FunctionSignature.h
+++ b/velox/expression/FunctionSignature.h
@@ -34,7 +34,11 @@ std::string sanitizeName(const std::string& name);
 /// Return a list of primitive type names.
 const std::vector<std::string> primitiveTypeNames();
 
-enum class ParameterType : int8_t { kTypeParameter, kIntegerParameter };
+enum class ParameterType : int8_t {
+  kTypeParameter,
+  kIntegerParameter,
+  kEnumParameter,
+};
 
 /// Canonical names for functions that have special treatments in pushdowns.
 enum class FunctionCanonicalName {
@@ -49,7 +53,7 @@ enum class FunctionCanonicalName {
 /// a_precision + b_precision" in decimals).
 class SignatureVariable {
  public:
-  explicit SignatureVariable(
+  SignatureVariable(
       std::string name,
       std::optional<std::string> constraint,
       ParameterType type,
@@ -80,6 +84,10 @@ class SignatureVariable {
     return comparableTypesOnly_;
   }
 
+  /// Return true if this variable describes a type and the specified type
+  /// satisfies the constraints.
+  bool isEligibleType(const Type& type) const;
+
   bool isTypeParameter() const {
     return type_ == ParameterType::kTypeParameter;
   }
@@ -88,6 +96,10 @@ class SignatureVariable {
     return type_ == ParameterType::kIntegerParameter;
   }
 
+  bool isEnumParameter() const {
+    return type_ == ParameterType::kEnumParameter;
+  }
+
   bool operator==(const SignatureVariable& rhs) const {
     return type_ == rhs.type_ && name_ == rhs.name_ &&
         constraint_ == rhs.constraint_ &&
@@ -139,6 +151,23 @@ class FunctionSignature {
     return argumentTypes_;
   }
 
+  const TypeSignature& argumentTypeAt(size_t index) const {
+    return argumentTypes_.at(index);
+  }
+
+  bool isLambdaArgumentAt(size_t index) const {
+    return argumentTypes().at(index).baseName() == "function";
+  }
+
+  bool hasLambdaArgument() const {
+    for (auto i = 0; i < argumentTypes_.size(); ++i) {
+      if (isLambdaArgumentAt(i)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   const std::vector<bool>& constantArguments() const {
     return constantArguments_;
   }
@@ -292,27 +321,37 @@ class FunctionSignatureBuilder {
     return *this;
   }
 
+  FunctionSignatureBuilder& enumVariable(
+      const std::string& name,
+      std::optional<std::string> constraint = std::nullopt) {
+    addVariable(
+        variables_,
+        SignatureVariable(name, constraint, ParameterType::kEnumParameter));
+    return *this;
+  }
+
   FunctionSignatureBuilder& returnType(const std::string& type) {
     returnType_.emplace(parseTypeSignature(type));
     return *this;
   }
 
   FunctionSignatureBuilder& argumentType(const std::string& type) {
-    argumentTypes_.emplace_back(parseTypeSignature(type));
-    constantArguments_.push_back(false);
-    return *this;
+    return addArgument(type, /*constant=*/false, /*variableArity=*/false);
   }
 
   FunctionSignatureBuilder& constantArgumentType(const std::string& type) {
-    argumentTypes_.emplace_back(parseTypeSignature(type));
-    constantArguments_.push_back(true);
-    return *this;
+    return addArgument(type, /*constant=*/true, /*variableArity=*/false);
   }
 
   /// Variable arity arguments can appear only at the end of the argument list
   /// and their types must match the type specified in the last entry of
   /// 'argumentTypes'. Variable arity arguments can appear zero or more times.
   FunctionSignatureBuilder& variableArity() {
+    VELOX_USER_CHECK(
+        !variableArity_, "Only one variable arity argument is allowed.");
+    VELOX_USER_CHECK(
+        !argumentTypes_.empty(),
+        "Variable arity requires at least one argument");
     variableArity_ = true;
     return *this;
   }
@@ -320,24 +359,33 @@ class FunctionSignatureBuilder {
   /// 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;
+    return addArgument(type, /*constant=*/false, /*variableArity=*/true);
   }
 
   /// 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;
+    return addArgument(type, /*constant=*/true, /*variableArity=*/true);
   }
 
   FunctionSignaturePtr build();
 
  private:
+  FunctionSignatureBuilder&
+  addArgument(const std::string& type, bool constant, bool variableArity) {
+    VELOX_USER_CHECK(
+        !variableArity_, "Cannot add arguments after variable arity argument");
+
+    argumentTypes_.emplace_back(parseTypeSignature(type));
+    constantArguments_.push_back(constant);
+
+    if (variableArity) {
+      this->variableArity();
+    }
+
+    return *this;
+  }
+
   std::unordered_map<std::string, SignatureVariable> variables_;
   std::optional<TypeSignature> returnType_;
   std::vector<TypeSignature> argumentTypes_;
diff --git a/velox/expression/LambdaExpr.cpp b/velox/expression/LambdaExpr.cpp
index 8e3f58f987e9..00ccee777b1c 100644
--- a/velox/expression/LambdaExpr.cpp
+++ b/velox/expression/LambdaExpr.cpp
@@ -165,6 +165,7 @@ LambdaExpr::LambdaExpr(
     std::shared_ptr<Expr>&& body,
     bool trackCpuUsage)
     : SpecialForm(
+          SpecialFormKind::kLambda,
           std::move(type),
           std::vector<std::shared_ptr<Expr>>(),
           "lambda",
@@ -183,6 +184,7 @@ LambdaExpr::LambdaExpr(
 void LambdaExpr::computeDistinctFields() {
   SpecialForm::computeDistinctFields();
   std::vector<FieldReference*> capturedFields;
+  capturedFields.reserve(capture_.size());
   for (auto& field : capture_) {
     capturedFields.push_back(field.get());
   }
diff --git a/velox/expression/LambdaExpr.h b/velox/expression/LambdaExpr.h
index bba0dc0e85f5..4c5dd17d3101 100644
--- a/velox/expression/LambdaExpr.h
+++ b/velox/expression/LambdaExpr.h
@@ -35,7 +35,7 @@ class LambdaExpr : public SpecialForm {
       std::shared_ptr<Expr>&& body,
       bool trackCpuUsage);
 
-  bool isConstant() const override {
+  bool isConstantExpr() const override {
     return false;
   }
 
@@ -49,6 +49,10 @@ class LambdaExpr : public SpecialForm {
       EvalCtx& context,
       VectorPtr& result) override;
 
+  const ExprPtr& body() const {
+    return body_;
+  }
+
  protected:
   void computeDistinctFields() override;
 
diff --git a/velox/expression/PeeledEncoding.cpp b/velox/expression/PeeledEncoding.cpp
index 1015bc91dbab..780b084469d5 100644
--- a/velox/expression/PeeledEncoding.cpp
+++ b/velox/expression/PeeledEncoding.cpp
@@ -15,8 +15,8 @@
  */
 
 #include "velox/expression/PeeledEncoding.h"
-
 #include "velox/expression/EvalCtx.h"
+#include "velox/vector/LazyVector.h"
 
 namespace facebook::velox::exec {
 
diff --git a/velox/expression/PrestoCastHooks.h b/velox/expression/PrestoCastHooks.h
index 96c1964f8b35..b4156ac792f3 100644
--- a/velox/expression/PrestoCastHooks.h
+++ b/velox/expression/PrestoCastHooks.h
@@ -61,6 +61,10 @@ class PrestoCastHooks : public CastHooks {
     return false;
   }
 
+  bool applyTryCastRecursively() const override {
+    return false;
+  }
+
   PolicyType getPolicy() const override;
 
  private:
diff --git a/velox/expression/RegisterSpecialForm.cpp b/velox/expression/RegisterSpecialForm.cpp
index 663bcac6ac7d..7d06f3ff3696 100644
--- a/velox/expression/RegisterSpecialForm.cpp
+++ b/velox/expression/RegisterSpecialForm.cpp
@@ -19,33 +19,42 @@
 
 #include "velox/expression/CastExpr.h"
 #include "velox/expression/CoalesceExpr.h"
+#include "velox/expression/CoalesceRewrite.h"
 #include "velox/expression/ConjunctExpr.h"
-#include "velox/expression/FunctionCallToSpecialForm.h"
+#include "velox/expression/ConjunctRewrite.h"
 #include "velox/expression/RowConstructor.h"
 #include "velox/expression/SpecialFormRegistry.h"
 #include "velox/expression/SwitchExpr.h"
+#include "velox/expression/SwitchRewrite.h"
 #include "velox/expression/TryExpr.h"
 
 namespace facebook::velox::exec {
+
 void registerFunctionCallToSpecialForms() {
   registerFunctionCallToSpecialForm(
-      kAnd, std::make_unique<ConjunctCallToSpecialForm>(true /* isAnd */));
+      expression::kAnd,
+      std::make_unique<ConjunctCallToSpecialForm>(true /* isAnd */));
   registerFunctionCallToSpecialForm(
-      kCast.str(), std::make_unique<CastCallToSpecialForm>());
+      expression::kCast, std::make_unique<CastCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
-      kTryCast.str(), std::make_unique<TryCastCallToSpecialForm>());
+      expression::kTryCast, std::make_unique<TryCastCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
-      kCoalesce, std::make_unique<CoalesceCallToSpecialForm>());
+      expression::kCoalesce, std::make_unique<CoalesceCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
-      kIf, std::make_unique<IfCallToSpecialForm>());
+      expression::kIf, std::make_unique<IfCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
-      kOr, std::make_unique<ConjunctCallToSpecialForm>(false /* isAnd */));
+      expression::kOr,
+      std::make_unique<ConjunctCallToSpecialForm>(false /* isAnd */));
   registerFunctionCallToSpecialForm(
-      kSwitch, std::make_unique<SwitchCallToSpecialForm>());
+      expression::kSwitch, std::make_unique<SwitchCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
-      kTry, std::make_unique<TryCallToSpecialForm>());
+      expression::kTry, std::make_unique<TryCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
-      RowConstructorCallToSpecialForm::kRowConstructor,
+      expression::kRowConstructor,
       std::make_unique<RowConstructorCallToSpecialForm>());
+
+  expression::CoalesceRewrite::registerRewrite();
+  expression::ConjunctRewrite::registerRewrite();
+  expression::SwitchRewrite::registerRewrite();
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/RegisterSpecialForm.h b/velox/expression/RegisterSpecialForm.h
index bd71ac53b83a..90e57dee3e94 100644
--- a/velox/expression/RegisterSpecialForm.h
+++ b/velox/expression/RegisterSpecialForm.h
@@ -17,5 +17,7 @@
 #pragma once
 
 namespace facebook::velox::exec {
+
 void registerFunctionCallToSpecialForms();
-}
+
+} // namespace facebook::velox::exec
diff --git a/velox/expression/ReverseSignatureBinder.h b/velox/expression/ReverseSignatureBinder.h
index 3da800a5edbb..44b99232d6ed 100644
--- a/velox/expression/ReverseSignatureBinder.h
+++ b/velox/expression/ReverseSignatureBinder.h
@@ -53,6 +53,26 @@ class ReverseSignatureBinder : private SignatureBinderBase {
     return integerVariablesBindings_;
   }
 
+  /// Return the LongEnumParameter bindings produced by 'tryBind'. This
+  /// function should be called after 'tryBind' and only if 'tryBind' returns
+  /// true.
+  const std::unordered_map<std::string, LongEnumParameter>&
+  longEnumParameterBindings() const {
+    VELOX_CHECK(
+        tryBindSucceeded_, "tryBind() must be called first and succeed");
+    return longEnumVariablesBindings_;
+  }
+
+  /// Return the VarcharEnumParameter bindings produced by 'tryBind'. This
+  /// function should be called after 'tryBind' and only if 'tryBind' returns
+  /// true.
+  const std::unordered_map<std::string, VarcharEnumParameter>&
+  varcharEnumParameterBindings() const {
+    VELOX_CHECK(
+        tryBindSucceeded_, "tryBind() must be called first and succeed");
+    return varcharEnumVariablesBindings_;
+  }
+
  private:
   const TypePtr returnType_;
 
diff --git a/velox/expression/RowConstructor.cpp b/velox/expression/RowConstructor.cpp
index 59f3f2b42709..61443e5acd54 100644
--- a/velox/expression/RowConstructor.cpp
+++ b/velox/expression/RowConstructor.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/expression/RowConstructor.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/VectorFunction.h"
 
 namespace facebook::velox::exec {
@@ -40,13 +41,15 @@ ExprPtr RowConstructorCallToSpecialForm::constructSpecialForm(
       [&config](auto& functionMap) -> std::pair<
                                        std::shared_ptr<VectorFunction>,
                                        VectorFunctionMetadata> {
-        auto functionIterator = functionMap.find(kRowConstructor);
+        auto functionIterator = functionMap.find(expression::kRowConstructor);
         if (functionIterator != functionMap.end()) {
           return {
-              functionIterator->second.factory(kRowConstructor, {}, config),
+              functionIterator->second.factory(
+                  expression::kRowConstructor, {}, config),
               functionIterator->second.metadata};
         } else {
-          VELOX_FAIL("Function {} is not registered.", kRowConstructor);
+          VELOX_FAIL(
+              "Function {} is not registered.", expression::kRowConstructor);
         }
       });
 
@@ -55,7 +58,7 @@ ExprPtr RowConstructorCallToSpecialForm::constructSpecialForm(
       std::move(compiledChildren),
       function,
       metadata,
-      kRowConstructor,
+      expression::kRowConstructor,
       trackCpuUsage);
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/RowConstructor.h b/velox/expression/RowConstructor.h
index 9e29208536cc..dd84d26ca973 100644
--- a/velox/expression/RowConstructor.h
+++ b/velox/expression/RowConstructor.h
@@ -28,7 +28,5 @@ class RowConstructorCallToSpecialForm : public FunctionCallToSpecialForm {
       std::vector<ExprPtr>&& compiledChildren,
       bool trackCpuUsage,
       const core::QueryConfig& config) override;
-
-  static constexpr const char* kRowConstructor = "row_constructor";
 };
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SignatureBinder.cpp b/velox/expression/SignatureBinder.cpp
index 4786e612dd32..dcd8ee7a7d98 100644
--- a/velox/expression/SignatureBinder.cpp
+++ b/velox/expression/SignatureBinder.cpp
@@ -19,6 +19,7 @@
 #include "velox/expression/SignatureBinder.h"
 #include "velox/expression/type_calculation/TypeCalculation.h"
 #include "velox/type/Type.h"
+#include "velox/type/TypeUtil.h"
 
 namespace facebook::velox::exec {
 namespace {
@@ -35,25 +36,22 @@ bool isPositiveInteger(const std::string& str) {
       }) == str.end();
 }
 
-std::string buildCalculation(
-    const std::string& variable,
-    const std::string& calculation) {
-  return fmt::format("{}={}", variable, calculation);
-}
-
-std::optional<int64_t> tryResolveLongLiteral(
+std::optional<int> tryResolveLongLiteral(
     const TypeSignature& parameter,
     const std::unordered_map<std::string, SignatureVariable>& variables,
     std::unordered_map<std::string, int>& integerVariablesBindings) {
-  auto variable = parameter.baseName();
+  const auto& variable = parameter.baseName();
 
   if (isPositiveInteger(variable)) {
     // Handle constant.
     return atoi(variable.c_str());
   };
 
-  if (integerVariablesBindings.count(variable)) {
-    return integerVariablesBindings.at(variable);
+  {
+    auto integerIt = integerVariablesBindings.find(variable);
+    if (integerIt != integerVariablesBindings.end()) {
+      return integerIt->second;
+    }
   }
 
   auto it = variables.find(variable);
@@ -61,21 +59,44 @@ std::optional<int64_t> tryResolveLongLiteral(
     return std::nullopt;
   }
 
-  auto& constraints = it->second.constraint();
-
-  if (constraints == "") {
+  const auto& constraints = it->second.constraint();
+  if (constraints.empty()) {
     return std::nullopt;
   }
 
   // Try to assign value based on constraints.
   // Check constraints and evaluate.
-  auto calculation = buildCalculation(variable, constraints);
+  const auto calculation = fmt::format("{}={}", variable, constraints);
   expression::calculation::evaluate(calculation, integerVariablesBindings);
+
+  auto integerIt = integerVariablesBindings.find(variable);
   VELOX_CHECK(
-      integerVariablesBindings.count(variable),
-      "Variable {} calculation failed.",
+      integerIt != integerVariablesBindings.end(),
+      "Variable calculation failed: {}",
       variable);
-  return integerVariablesBindings.at(variable);
+  return integerIt->second;
+}
+
+std::optional<LongEnumParameter> tryResolveLongEnumLiteral(
+    const TypeSignature& parameter,
+    const std::unordered_map<std::string, LongEnumParameter>&
+        longEnumParameterVariableBindings) {
+  auto it = longEnumParameterVariableBindings.find(parameter.baseName());
+  if (it != longEnumParameterVariableBindings.end()) {
+    return it->second;
+  }
+  return std::nullopt;
+}
+
+std::optional<VarcharEnumParameter> tryResolveVarcharEnumLiteral(
+    const TypeSignature& parameter,
+    const std::unordered_map<std::string, VarcharEnumParameter>&
+        varcharEnumParameterVariableBindings) {
+  auto it = varcharEnumParameterVariableBindings.find(parameter.baseName());
+  if (it != varcharEnumParameterVariableBindings.end()) {
+    return it->second;
+  }
+  return std::nullopt;
 }
 
 // If the parameter is a named field from a row, ensure the names are
@@ -96,43 +117,127 @@ bool checkNamedRowField(
 
 } // namespace
 
+bool SignatureBinder::tryBindWithCoercions(std::vector<Coercion>& coercions) {
+  return tryBind(true, coercions);
+}
+
 bool SignatureBinder::tryBind() {
+  std::vector<Coercion> coercions;
+  return tryBind(false, coercions);
+}
+
+bool SignatureBinder::tryBind(
+    bool allowCoercions,
+    std::vector<Coercion>& coercions) {
+  const auto numActualTypes = actualTypes_.size();
+
+  if (allowCoercions) {
+    coercions.clear();
+    coercions.resize(numActualTypes);
+  }
+
   const auto& formalArgs = signature_.argumentTypes();
-  auto formalArgsCnt = formalArgs.size();
+  const auto numFormalArgs = formalArgs.size();
 
   if (signature_.variableArity()) {
-    if (actualTypes_.size() < formalArgsCnt - 1) {
+    if (numActualTypes < numFormalArgs - 1) {
+      return false;
+    }
+  } else {
+    if (numFormalArgs != numActualTypes) {
+      return false;
+    }
+  }
+
+  if (allowCoercions && !variables().empty()) {
+    for (auto i = 0; i < numActualTypes; i++) {
+      if (actualTypes_[i]) {
+        const auto& typeSignature =
+            i < numFormalArgs ? formalArgs[i] : formalArgs[numFormalArgs - 1];
+
+        if (!tryBindVariablesWithCoercion(typeSignature, actualTypes_[i])) {
+          return false;
+        }
+      }
+    }
+  }
+
+  for (auto i = 0; i < numFormalArgs && i < numActualTypes; i++) {
+    if (actualTypes_[i]) {
+      if (allowCoercions) {
+        if (!SignatureBinderBase::tryBindWithCoercion(
+                formalArgs[i], actualTypes_[i], coercions[i])) {
+          return false;
+        }
+      } else {
+        if (!SignatureBinderBase::tryBind(formalArgs[i], actualTypes_[i])) {
+          return false;
+        }
+      }
+    } else {
       return false;
     }
+  }
 
+  if (signature_.variableArity()) {
     if (!isAny(signature_.argumentTypes().back())) {
-      if (actualTypes_.size() > formalArgsCnt) {
-        auto& type = actualTypes_[formalArgsCnt - 1];
-        for (auto i = formalArgsCnt; i < actualTypes_.size(); i++) {
-          if (!type->equivalent(*actualTypes_[i]) &&
-              actualTypes_[i]->kind() != TypeKind::UNKNOWN) {
-            return false;
+      if (numActualTypes > numFormalArgs) {
+        if (allowCoercions) {
+          auto firstType = actualTypes_[numFormalArgs - 1];
+          if (coercions[numFormalArgs - 1].type != nullptr) {
+            firstType = coercions[numFormalArgs - 1].type;
+          }
+
+          for (auto i = numFormalArgs; i < numActualTypes; i++) {
+            if (auto cost =
+                    TypeCoercer::coercible(actualTypes_[i], firstType)) {
+              if (cost.value() > 0) {
+                coercions[i] = Coercion{firstType, cost.value()};
+              }
+            } else {
+              return false;
+            }
+          }
+
+        } else {
+          const auto& firstType = actualTypes_[numFormalArgs - 1];
+          for (auto i = numFormalArgs; i < numActualTypes; i++) {
+            if (!firstType->equivalent(*actualTypes_[i])) {
+              return false;
+            }
           }
         }
       }
     }
-  } else {
-    if (formalArgsCnt != actualTypes_.size()) {
+  }
+
+  return true;
+}
+
+bool SignatureBinderBase::checkOrSetLongEnumParameter(
+    const std::string& parameterName,
+    const LongEnumParameter& params) {
+  auto it = longEnumVariablesBindings_.find(parameterName);
+  if (it != longEnumVariablesBindings_.end()) {
+    if (longEnumVariablesBindings_[parameterName] != params) {
       return false;
     }
   }
+  longEnumVariablesBindings_[parameterName] = params;
+  return true;
+}
 
-  bool allBound = true;
-  for (auto i = 0; i < formalArgsCnt && i < actualTypes_.size(); i++) {
-    if (actualTypes_[i]) {
-      if (!SignatureBinderBase::tryBind(formalArgs[i], actualTypes_[i])) {
-        allBound = false;
-      }
-    } else {
-      allBound = false;
+bool SignatureBinderBase::checkOrSetVarcharEnumParameter(
+    const std::string& parameterName,
+    const VarcharEnumParameter& params) {
+  auto it = varcharEnumVariablesBindings_.find(parameterName);
+  if (it != varcharEnumVariablesBindings_.end()) {
+    if (varcharEnumVariablesBindings_[parameterName] != params) {
+      return false;
     }
   }
-  return allBound;
+  varcharEnumVariablesBindings_[parameterName] = params;
+  return true;
 }
 
 bool SignatureBinderBase::checkOrSetIntegerParameter(
@@ -141,76 +246,221 @@ bool SignatureBinderBase::checkOrSetIntegerParameter(
   if (isPositiveInteger(parameterName)) {
     return atoi(parameterName.c_str()) == value;
   }
-  if (!variables().count(parameterName)) {
+  if (!variables().contains(parameterName)) {
     // Return false if the parameter is not found in the signature.
     return false;
   }
 
-  if (integerVariablesBindings_.count(parameterName)) {
+  const auto& constraint = variables().at(parameterName).constraint();
+  if (isPositiveInteger(constraint) && atoi(constraint.c_str()) != value) {
+    // Return false if the actual value does not match the constraint.
+    return false;
+  }
+
+  auto integerIt = integerVariablesBindings_.find(parameterName);
+  if (integerIt != integerVariablesBindings_.end()) {
     // Return false if the parameter is found with a different value.
-    if (integerVariablesBindings_[parameterName] != value) {
+    if (integerIt->second != value) {
       return false;
     }
   }
+
   // Bind the variable.
   integerVariablesBindings_[parameterName] = value;
   return true;
 }
 
-bool SignatureBinderBase::tryBind(
+std::optional<bool> SignatureBinderBase::checkSetTypeVariable(
     const exec::TypeSignature& typeSignature,
-    const TypePtr& actualType) {
-  if (isAny(typeSignature)) {
+    const TypePtr& actualType,
+    bool allowCoercion,
+    Coercion& coercion) {
+  const auto& baseName = typeSignature.baseName();
+
+  auto variableIt = variables().find(baseName);
+  if (variableIt == variables().end()) {
+    return std::nullopt;
+  }
+
+  if (allowCoercion) {
+    // Variables must be already set.
+    auto bindingIt = typeVariablesBindings_.find(baseName);
+    VELOX_CHECK(bindingIt != typeVariablesBindings_.end());
+
+    const auto& boundType = bindingIt->second;
+    const auto cost = TypeCoercer::coercible(actualType, boundType);
+    VELOX_CHECK(cost.has_value());
+
+    if (cost.value() > 0) {
+      coercion.type = boundType;
+      coercion.cost = cost.value();
+    }
     return true;
   }
 
-  const auto baseName = typeSignature.baseName();
+  // Variables cannot have further parameters.
+  VELOX_CHECK(
+      typeSignature.parameters().empty(),
+      "Variables with parameters are not supported");
+  const auto& variable = variableIt->second;
+  VELOX_CHECK(variable.isTypeParameter(), "Not expecting integer variable");
+
+  auto bindingIt = typeVariablesBindings_.find(baseName);
+  if (bindingIt != typeVariablesBindings_.end()) {
+    return bindingIt->second->equivalent(*actualType);
+  }
+
+  if (!variable.isEligibleType(*actualType)) {
+    return false;
+  }
 
-  if (variables().count(baseName)) {
+  typeVariablesBindings_[baseName] = actualType;
+  return true;
+}
+
+bool SignatureBinderBase::tryBindWithCoercion(
+    const exec::TypeSignature& typeSignature,
+    const TypePtr& actualType,
+    Coercion& coercion) {
+  return tryBind(typeSignature, actualType, true, coercion);
+}
+
+bool SignatureBinderBase::tryBind(
+    const exec::TypeSignature& typeSignature,
+    const TypePtr& actualType) {
+  Coercion coercion;
+  return tryBind(typeSignature, actualType, false, coercion);
+}
+
+bool SignatureBinder::tryBindVariablesWithCoercion(
+    const exec::TypeSignature& typeSignature,
+    const TypePtr& actualType) {
+  const auto& baseName = typeSignature.baseName();
+
+  auto variableIt = variables().find(baseName);
+  if (variableIt != variables().end()) {
     // Variables cannot have further parameters.
     VELOX_CHECK(
         typeSignature.parameters().empty(),
         "Variables with parameters are not supported");
-    auto& variable = variables().at(baseName);
+    const auto& variable = variableIt->second;
     VELOX_CHECK(variable.isTypeParameter(), "Not expecting integer variable");
 
-    if (typeVariablesBindings_.count(baseName)) {
-      // If the the variable type is already mapped to a concrete type, make
-      // sure the mapped type is equivalent to the actual type.
-      return typeVariablesBindings_[baseName]->equivalent(*actualType);
+    if (!variable.isEligibleType(*actualType)) {
+      return false;
     }
 
-    if (actualType->isUnKnown() && variable.knownTypesOnly()) {
-      return false;
+    auto bindingIt = typeVariablesBindings_.find(baseName);
+    if (bindingIt == typeVariablesBindings_.end()) {
+      typeVariablesBindings_[baseName] = actualType;
+      return true;
     }
 
-    if (variable.orderableTypesOnly() && !actualType->isOrderable()) {
-      return false;
+    if (auto superType =
+            TypeCoercer::leastCommonSuperType(actualType, bindingIt->second)) {
+      typeVariablesBindings_[baseName] = superType;
+      return true;
     }
 
-    if (variable.comparableTypesOnly() && !actualType->isComparable()) {
-      return false;
+    return false;
+  }
+
+  if (typeSignature.isHomogeneousRow()) {
+    // TODO Add coercion support.
+    return true;
+  }
+
+  const auto& params = typeSignature.parameters();
+  if (params.size() != actualType->parameters().size()) {
+    return false;
+  }
+
+  for (auto i = 0; i < params.size(); i++) {
+    const auto& actualParameter = actualType->parameters()[i];
+    if (actualParameter.kind == TypeParameterKind::kType) {
+      if (!tryBindVariablesWithCoercion(params[i], actualParameter.type)) {
+        return false;
+      }
     }
+  }
 
-    typeVariablesBindings_[baseName] = actualType;
+  return true;
+}
+
+bool SignatureBinderBase::tryBind(
+    const exec::TypeSignature& typeSignature,
+    const TypePtr& actualType,
+    bool allowCoercion,
+    Coercion& coercion) {
+  coercion.reset();
+  if (isAny(typeSignature)) {
     return true;
   }
 
+  if (auto result = checkSetTypeVariable(
+          typeSignature, actualType, allowCoercion, coercion)) {
+    return result.value();
+  }
+
   // Type is not a variable.
+  const auto& baseName = typeSignature.baseName();
   auto typeName = boost::algorithm::to_upper_copy(baseName);
-  auto actualTypeName =
-      boost::algorithm::to_upper_copy(std::string(actualType->name()));
-
-  if (typeName != actualTypeName) {
+  if (!boost::algorithm::iequals(typeName, actualType->name())) {
+    if (allowCoercion) {
+      if (auto availableCoercion =
+              TypeCoercer::coerceTypeBase(actualType, typeName)) {
+        coercion = availableCoercion.value();
+        return true;
+      }
+    }
     return false;
   }
 
   const auto& params = typeSignature.parameters();
+
+  // Handle homogeneous row case: row(T, ...)
+  if (typeSignature.isHomogeneousRow()) {
+    VELOX_CHECK_EQ(
+        params.size(), 1, "Homogeneous row must have exactly one parameter");
+
+    if (actualType->kind() != TypeKind::ROW) {
+      return false;
+    }
+
+    if (actualType->size() == 0) {
+      // Empty row is always compatible with homogeneous row.
+      return true;
+    }
+
+    // All children must unify to the same type variable T
+    const auto& typeParam = params[0];
+
+    // First, check and extract the common child type if homogeneous.
+    const auto actualChildType =
+        velox::type::tryGetHomogeneousRowChild(actualType);
+    if (!actualChildType) {
+      return false;
+    }
+
+    // TODO Add coercion support.
+    if (auto result = checkSetTypeVariable(
+            typeParam, actualChildType, /*allowCoercion=*/false, coercion)) {
+      return result.value();
+    }
+
+    return tryBind(typeParam, actualChildType);
+  }
+
   // Type Parameters can recurse.
   if (params.size() != actualType->parameters().size()) {
     return false;
   }
 
+  std::vector<Coercion> paramCoercions;
+  if (allowCoercion) {
+    paramCoercions.resize(params.size());
+  }
+
   for (auto i = 0; i < params.size(); i++) {
     const auto& actualParameter = actualType->parameters()[i];
     switch (actualParameter.kind) {
@@ -220,17 +470,61 @@ bool SignatureBinderBase::tryBind(
           return false;
         }
         break;
+      case TypeParameterKind::kLongEnumLiteral:
+        if (!checkOrSetLongEnumParameter(
+                params[i].baseName(),
+                actualParameter.longEnumLiteral.value())) {
+          return false;
+        }
+        break;
+      case TypeParameterKind::kVarcharEnumLiteral:
+        if (!checkOrSetVarcharEnumParameter(
+                params[i].baseName(),
+                actualParameter.varcharEnumLiteral.value())) {
+          return false;
+        }
+        break;
       case TypeParameterKind::kType:
         if (!checkNamedRowField(params[i], actualType, i)) {
           return false;
         }
 
-        if (!tryBind(params[i], actualParameter.type)) {
+        if (allowCoercion) {
+          if (!tryBindWithCoercion(
+                  params[i], actualParameter.type, paramCoercions[i])) {
+            return false;
+          }
+
+        } else if (!tryBind(params[i], actualParameter.type)) {
           return false;
         }
+
         break;
     }
   }
+
+  if (allowCoercion) {
+    const bool hasCoercion = std::ranges::any_of(
+        paramCoercions,
+        [](const auto& coercion) { return coercion.type != nullptr; });
+
+    if (hasCoercion) {
+      std::vector<TypeParameter> newParams;
+      newParams.reserve(params.size());
+      for (auto i = 0; i < params.size(); i++) {
+        if (paramCoercions[i].type != nullptr) {
+          newParams.push_back(
+              TypeParameter(paramCoercions[i].type, params[i].rowFieldName()));
+          coercion.cost += paramCoercions[i].cost;
+        } else {
+          newParams.push_back(actualType->parameters()[i]);
+        }
+      }
+
+      coercion.type = getType(typeName, newParams);
+    }
+  }
+
   return true;
 }
 
@@ -238,10 +532,14 @@ TypePtr SignatureBinder::tryResolveType(
     const exec::TypeSignature& typeSignature,
     const std::unordered_map<std::string, SignatureVariable>& variables,
     const std::unordered_map<std::string, TypePtr>& typeVariablesBindings,
-    std::unordered_map<std::string, int>& integerVariablesBindings) {
-  const auto baseName = typeSignature.baseName();
-
-  if (variables.count(baseName)) {
+    std::unordered_map<std::string, int>& integerVariablesBindings,
+    const std::unordered_map<std::string, LongEnumParameter>&
+        longEnumParameterVariableBindings,
+    const std::unordered_map<std::string, VarcharEnumParameter>&
+        varcharEnumParameterVariableBindings) {
+  const auto& baseName = typeSignature.baseName();
+
+  if (variables.contains(baseName)) {
     auto it = typeVariablesBindings.find(baseName);
     if (it == typeVariablesBindings.end()) {
       return nullptr;
@@ -259,16 +557,33 @@ TypePtr SignatureBinder::tryResolveType(
     auto literal =
         tryResolveLongLiteral(param, variables, integerVariablesBindings);
     if (literal.has_value()) {
-      typeParameters.push_back(TypeParameter(literal.value()));
+      typeParameters.emplace_back(literal.value());
+      continue;
+    }
+    auto longEnumParameterliteral =
+        tryResolveLongEnumLiteral(param, longEnumParameterVariableBindings);
+    if (longEnumParameterliteral.has_value()) {
+      typeParameters.emplace_back(longEnumParameterliteral.value());
+      continue;
+    }
+    auto varcharEnumParameterliteral = tryResolveVarcharEnumLiteral(
+        param, varcharEnumParameterVariableBindings);
+    if (varcharEnumParameterliteral.has_value()) {
+      typeParameters.emplace_back(varcharEnumParameterliteral.value());
       continue;
     }
 
     auto type = tryResolveType(
-        param, variables, typeVariablesBindings, integerVariablesBindings);
+        param,
+        variables,
+        typeVariablesBindings,
+        integerVariablesBindings,
+        longEnumParameterVariableBindings,
+        varcharEnumParameterVariableBindings);
     if (!type) {
       return nullptr;
     }
-    typeParameters.push_back(TypeParameter(type, param.rowFieldName()));
+    typeParameters.emplace_back(type, param.rowFieldName());
   }
 
   try {
@@ -280,7 +595,7 @@ TypePtr SignatureBinder::tryResolveType(
     return nullptr;
   }
 
-  auto typeKind = tryMapNameToTypeKind(typeName);
+  auto typeKind = TypeKindName::tryToTypeKind(typeName);
   if (!typeKind.has_value()) {
     return nullptr;
   }
diff --git a/velox/expression/SignatureBinder.h b/velox/expression/SignatureBinder.h
index a3ad5270e300..183949969b83 100644
--- a/velox/expression/SignatureBinder.h
+++ b/velox/expression/SignatureBinder.h
@@ -17,6 +17,7 @@
 
 #include "velox/expression/FunctionSignature.h"
 #include "velox/type/Type.h"
+#include "velox/type/TypeCoercer.h"
 
 namespace facebook::velox::exec {
 
@@ -26,18 +27,29 @@ class SignatureBinderBase {
       : signature_{signature} {}
 
   /// Return true if actualType can bind to typeSignature and update bindings_
-  /// accordingly. The number of parameters in typeSignature and actualType must
-  /// match. Return false otherwise.
+  /// accordingly. The number of parameters in typeSignature and actualType
+  /// must match. Return false otherwise.
   bool tryBind(
       const exec::TypeSignature& typeSignature,
       const TypePtr& actualType);
 
+  /// Like 'tryBind', but allows implicit type conversion if actualType
+  /// doesn't match typeSignature exactly.
+  ///
+  /// @param coercion Type coercion necessary to bind actualType to
+  /// typeSignature if there is no exact match. 'coercion.type' is null if
+  /// there is exact match.
+  bool tryBindWithCoercion(
+      const exec::TypeSignature& typeSignature,
+      const TypePtr& actualType,
+      Coercion& coercion);
+
   // Return the variables of the signature.
   auto& variables() const {
     return signature_.variables();
   }
 
-  /// The funcion signature we are trying to bind.
+  /// The function signature we are trying to bind.
   const exec::FunctionSignature& signature_;
 
   /// Record concrete types that are bound to type variables.
@@ -46,15 +58,44 @@ class SignatureBinderBase {
   /// Record concrete values that are bound to integer variables.
   std::unordered_map<std::string, int> integerVariablesBindings_;
 
+  /// Record concrete values that are bound to LongEnumParameter variables.
+  std::unordered_map<std::string, LongEnumParameter> longEnumVariablesBindings_;
+
+  /// Record concrete values that are bound to VarcharEnumParameter variables.
+  std::unordered_map<std::string, VarcharEnumParameter>
+      varcharEnumVariablesBindings_;
+
  private:
   /// If the integer parameter is set, then it must match with value.
   /// Returns false if values do not match or the parameter does not exist.
   bool checkOrSetIntegerParameter(const std::string& parameterName, int value);
 
+  /// Try to bind the LongEnumParameter from the actualType.
+  bool checkOrSetLongEnumParameter(
+      const std::string& parameterName,
+      const LongEnumParameter& params);
+
+  /// Try to bind the VarcharEnumParameter from the actualType.
+  bool checkOrSetVarcharEnumParameter(
+      const std::string& parameterName,
+      const VarcharEnumParameter& params);
+
+  std::optional<bool> checkSetTypeVariable(
+      const exec::TypeSignature& typeSignature,
+      const TypePtr& actualType,
+      bool allowCoercion,
+      Coercion& coercion);
+
   /// Try to bind the integer parameter from the actualType.
   bool tryBindIntegerParameters(
       const std::vector<exec::TypeSignature>& parameters,
       const TypePtr& actualType);
+
+  bool tryBind(
+      const exec::TypeSignature& typeSignature,
+      const TypePtr& actualType,
+      bool allowCoercion,
+      Coercion& coercion);
 };
 
 /// Resolves generic type names in the function signature using actual input
@@ -76,17 +117,45 @@ class SignatureBinder : private SignatureBinderBase {
   /// Returns true if successfully resolved all generic type names.
   bool tryBind();
 
-  /// Returns concrete return type or null if couldn't fully resolve.
+  /// Like 'tryBind', but allows implicit type conversion if actualTypes don't
+  /// match the signature exactly.
+  /// @param coercions Type coercions necessary to bind actualTypes to the
+  /// signature. There is one entry per argument. Coercion.type is null if no
+  /// coercion is required for that argument.
+  bool tryBindWithCoercions(std::vector<Coercion>& coercions);
+
+  /// Returns concrete return type or nullptr if couldn't fully resolve.
   TypePtr tryResolveReturnType() {
     return tryResolveType(signature_.returnType());
   }
 
+  // Try resolve type for the specified signature. Return nullptr if cannot
+  // resolve.
   TypePtr tryResolveType(const exec::TypeSignature& typeSignature) {
     return tryResolveType(
         typeSignature,
         variables(),
         typeVariablesBindings_,
-        integerVariablesBindings_);
+        integerVariablesBindings_,
+        longEnumVariablesBindings_,
+        varcharEnumVariablesBindings_);
+  }
+
+  // Try resolve types for all specified signatures. Return empty list if some
+  // signatures cannot be resolved.
+  std::vector<TypePtr> tryResolveTypes(
+      const folly::Range<const TypeSignature*>& typeSignatures) {
+    std::vector<TypePtr> types;
+    for (const auto& signature : typeSignatures) {
+      auto type = tryResolveType(signature);
+      if (type == nullptr) {
+        return {};
+      }
+
+      types.push_back(type);
+    }
+
+    return types;
   }
 
   // Given a pre-computed binding for type variables resolve typeSignature if
@@ -95,9 +164,16 @@ class SignatureBinder : private SignatureBinderBase {
       const exec::TypeSignature& typeSignature,
       const std::unordered_map<std::string, SignatureVariable>& variables,
       const std::unordered_map<std::string, TypePtr>& resolvedTypeVariables) {
-    std::unordered_map<std::string, int> dummyEmpty = {};
+    std::unordered_map<std::string, int> dummyEmpty;
+    std::unordered_map<std::string, LongEnumParameter> dummyEmpty2;
+    std::unordered_map<std::string, VarcharEnumParameter> dummyEmpty3;
     return tryResolveType(
-        typeSignature, variables, resolvedTypeVariables, dummyEmpty);
+        typeSignature,
+        variables,
+        resolvedTypeVariables,
+        dummyEmpty,
+        dummyEmpty2,
+        dummyEmpty3);
   }
 
   // Given a pre-computed binding for type variables and integer variables,
@@ -107,9 +183,20 @@ class SignatureBinder : private SignatureBinderBase {
       const exec::TypeSignature& typeSignature,
       const std::unordered_map<std::string, SignatureVariable>& variables,
       const std::unordered_map<std::string, TypePtr>& typeVariablesBindings,
-      std::unordered_map<std::string, int>& integerVariablesBindings);
+      std::unordered_map<std::string, int>& integerVariablesBindings,
+      const std::unordered_map<std::string, LongEnumParameter>&
+          bigintEnumVariablesBindings,
+      const std::unordered_map<std::string, VarcharEnumParameter>&
+          varcharEnumVariablesBindings);
 
  private:
+  bool tryBind(bool allowCoercions, std::vector<Coercion>& coercions);
+
+  bool tryBindVariablesWithCoercion(
+      const exec::TypeSignature& typeSignature,
+      const TypePtr& actualType);
+
   const std::vector<TypePtr>& actualTypes_;
 };
+
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SimpleFunctionAdapter.h b/velox/expression/SimpleFunctionAdapter.h
index aa19c249291e..e257cf2f7046 100644
--- a/velox/expression/SimpleFunctionAdapter.h
+++ b/velox/expression/SimpleFunctionAdapter.h
@@ -216,14 +216,15 @@ class SimpleFunctionAdapter : public VectorFunction {
     bool mayHaveNullsRecursive{false};
   };
 
-  template <int32_t POSITION, typename... Values>
+  template <size_t POSITION, typename... Values>
   void unpackInitialize(
       const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
+      memory::MemoryPool* memoryPool,
       const std::vector<VectorPtr>& packed,
       const Values*... values) const {
     if constexpr (POSITION == FUNC::num_args) {
-      return (*fn_).initialize(inputTypes, config, values...);
+      return (*fn_).initialize(inputTypes, config, memoryPool, values...);
     } else {
       if (packed.at(POSITION) != nullptr) {
         SelectivityVector rows(1);
@@ -232,11 +233,16 @@ class SimpleFunctionAdapter : public VectorFunction {
         auto oneValue = oneReader[0];
 
         unpackInitialize<POSITION + 1>(
-            inputTypes, config, packed, values..., &oneValue);
+            inputTypes, config, memoryPool, packed, values..., &oneValue);
       } else {
         using temp_type = exec_arg_at<POSITION>;
         unpackInitialize<POSITION + 1>(
-            inputTypes, config, packed, values..., (const temp_type*)nullptr);
+            inputTypes,
+            config,
+            memoryPool,
+            packed,
+            values...,
+            (const temp_type*)nullptr);
       }
     }
   }
@@ -245,11 +251,12 @@ class SimpleFunctionAdapter : public VectorFunction {
   SimpleFunctionAdapter(
       const std::vector<TypePtr>& inputTypes,
       const core::QueryConfig& config,
-      const std::vector<VectorPtr>& constantInputs)
+      const std::vector<VectorPtr>& constantInputs,
+      memory::MemoryPool* memoryPool = nullptr)
       : fn_{std::make_unique<FUNC>()} {
     if constexpr (FUNC::udf_has_initialize) {
       try {
-        unpackInitialize<0>(inputTypes, config, constantInputs);
+        unpackInitialize<0>(inputTypes, config, memoryPool, constantInputs);
       } catch (const VeloxRuntimeError&) {
         throw;
       } catch (const std::exception&) {
@@ -970,9 +977,10 @@ class SimpleFunctionAdapterFactoryImpl : public SimpleFunctionAdapterFactory {
   std::unique_ptr<VectorFunction> createVectorFunction(
       const std::vector<TypePtr>& inputTypes,
       const std::vector<VectorPtr>& constantInputs,
-      const core::QueryConfig& config) const override {
+      const core::QueryConfig& config,
+      memory::MemoryPool* memoryPool = nullptr) const override {
     return std::make_unique<SimpleFunctionAdapter<UDFHolder>>(
-        inputTypes, config, constantInputs);
+        inputTypes, config, constantInputs, memoryPool);
   }
 };
 
diff --git a/velox/expression/SimpleFunctionRegistry.cpp b/velox/expression/SimpleFunctionRegistry.cpp
index 9b08d6e18df5..c159a60b5343 100644
--- a/velox/expression/SimpleFunctionRegistry.cpp
+++ b/velox/expression/SimpleFunctionRegistry.cpp
@@ -85,6 +85,25 @@ const SignatureMap* getSignatureMap(
 }
 } // namespace
 
+std::unordered_map<std::string, std::vector<const FunctionSignature*>>
+SimpleFunctionRegistry::getFunctionSignatureMap() const {
+  std::unordered_map<std::string, std::vector<const FunctionSignature*>> result;
+  registeredFunctions_.withRLock([&](const auto& map) {
+    result.reserve(map.size());
+
+    for (const auto& entry : map) {
+      std::vector<const FunctionSignature*> signatures;
+      const auto signatureMap = &entry.second;
+      signatures.reserve(signatureMap->size());
+      for (const auto& pair : *signatureMap) {
+        signatures.emplace_back(&pair.first);
+      }
+      result[entry.first] = signatures;
+    }
+  });
+  return result;
+}
+
 std::vector<const FunctionSignature*>
 SimpleFunctionRegistry::getFunctionSignatures(const std::string& name) const {
   std::vector<const FunctionSignature*> signatures;
@@ -152,25 +171,45 @@ bool physicalTypeMatches(const TypePtr& type, const TypePtr& physicalType) {
 std::optional<SimpleFunctionRegistry::ResolvedSimpleFunction>
 SimpleFunctionRegistry::resolveFunction(
     const std::string& name,
-    const std::vector<TypePtr>& argTypes) const {
-  const FunctionEntry* selectedCandidate = nullptr;
-  TypePtr selectedCandidateType = nullptr;
+    const std::vector<TypePtr>& argTypes,
+    bool allowCoercion,
+    std::vector<TypePtr>& coercions) const {
+  using Candidate = std::pair<const FunctionEntry*, TypePtr>;
+
+  std::optional<Candidate> selectedCandidate;
   registeredFunctions_.withRLock([&](const auto& map) {
     if (const auto* signatureMap = getSignatureMap(name, map)) {
+      std::vector<std::pair<std::vector<Coercion>, Candidate>> candidates;
+      std::optional<uint32_t> priority;
+
       for (const auto& [candidateSignature, functionEntry] : *signatureMap) {
         SignatureBinder binder(candidateSignature, argTypes);
-        if (binder.tryBind()) {
+
+        std::vector<Coercion> requiredCoercions;
+
+        bool bound;
+        if (allowCoercion) {
+          bound = binder.tryBindWithCoercions(requiredCoercions);
+        } else {
+          bound = binder.tryBind();
+        }
+
+        if (bound) {
           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.
+            // 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])) {
+              auto argType = argTypes[i];
+              if (allowCoercion && requiredCoercions[i].type != nullptr) {
+                argType = requiredCoercions[i].type;
+              }
+              if (!physicalTypeMatches(argType, m.argPhysicalTypes()[i])) {
                 match = false;
                 break;
               }
@@ -180,28 +219,50 @@ SimpleFunctionRegistry::resolveFunction(
               continue;
             }
 
-            if (!selectedCandidate ||
-                currentCandidate->getMetadata().priority() <
-                    selectedCandidate->getMetadata().priority()) {
-              auto resultType = binder.tryResolveReturnType();
-              VELOX_CHECK_NOT_NULL(resultType);
+            auto resultType = binder.tryResolveReturnType();
+            VELOX_CHECK_NOT_NULL(resultType);
 
-              if (physicalTypeMatches(resultType, m.resultPhysicalType())) {
-                selectedCandidate = currentCandidate.get();
-                selectedCandidateType = resultType;
+            if (physicalTypeMatches(resultType, m.resultPhysicalType())) {
+              const auto currentPriority = m.priority();
+
+              if (!priority.has_value() || currentPriority < priority.value()) {
+                candidates.clear();
+                candidates.emplace_back(
+                    requiredCoercions,
+                    std::make_pair(currentCandidate.get(), resultType));
+                priority = currentPriority;
+              } else if (allowCoercion && currentPriority == priority.value()) {
+                candidates.emplace_back(
+                    requiredCoercions,
+                    std::make_pair(currentCandidate.get(), resultType));
               }
             }
           }
         }
       }
+
+      if (!candidates.empty()) {
+        if (allowCoercion) {
+          if (auto index = Coercion::pickLowestCost(candidates)) {
+            selectedCandidate = candidates[index.value()].second;
+
+            const auto& selectedCoercions = candidates[index.value()].first;
+
+            coercions.clear();
+            for (const auto& coercion : selectedCoercions) {
+              coercions.push_back(coercion.type);
+            }
+          }
+        } else {
+          selectedCandidate = candidates[0].second;
+        }
+      }
     }
   });
 
-  VELOX_DCHECK(!selectedCandidate || selectedCandidateType);
-
-  return selectedCandidate
-      ? std::optional<ResolvedSimpleFunction>(
-            ResolvedSimpleFunction(*selectedCandidate, selectedCandidateType))
+  return selectedCandidate.has_value()
+      ? std::make_optional(ResolvedSimpleFunction(
+            *(selectedCandidate->first), selectedCandidate->second))
       : std::nullopt;
 }
 
diff --git a/velox/expression/SimpleFunctionRegistry.h b/velox/expression/SimpleFunctionRegistry.h
index ffd5ec5deb0d..7244d35beb1b 100644
--- a/velox/expression/SimpleFunctionRegistry.h
+++ b/velox/expression/SimpleFunctionRegistry.h
@@ -76,7 +76,7 @@ class SimpleFunctionRegistry {
       bool overwrite) {
     const auto& metadata = singletonUdfMetadata<typename UDF::Metadata>(
         UDF::is_default_null_behavior, constraints);
-    const auto factory = []() { return CreateUdf<UDF>(); };
+    const auto factory = []() { return std::make_unique<UDF>(); };
 
     if (aliases.empty()) {
       return registerFunctionInternal(
@@ -109,6 +109,9 @@ class SimpleFunctionRegistry {
     registeredFunctions_.withWLock([&](auto& map) { map.clear(); });
   }
 
+  std::unordered_map<std::string, std::vector<const exec::FunctionSignature*>>
+  getFunctionSignatureMap() const;
+
   std::vector<const FunctionSignature*> getFunctionSignatures(
       const std::string& name) const;
 
@@ -152,14 +155,25 @@ class SimpleFunctionRegistry {
 
   std::optional<ResolvedSimpleFunction> resolveFunction(
       const std::string& name,
-      const std::vector<TypePtr>& argTypes) const;
+      const std::vector<TypePtr>& argTypes) const {
+    std::vector<TypePtr> coercions;
+    return resolveFunction(name, argTypes, false, coercions);
+  }
 
- private:
-  template <typename T>
-  static std::unique_ptr<T> CreateUdf() {
-    return std::make_unique<T>();
+  std::optional<ResolvedSimpleFunction> resolveFunctionWithCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      std::vector<TypePtr>& coercions) const {
+    return resolveFunction(name, argTypes, true, coercions);
   }
 
+ private:
+  std::optional<ResolvedSimpleFunction> resolveFunction(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      bool allowCoercion,
+      std::vector<TypePtr>& coercions) const;
+
   /// 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
diff --git a/velox/expression/SpecialForm.h b/velox/expression/SpecialForm.h
index 81c2ddde526a..840be0a0bde3 100644
--- a/velox/expression/SpecialForm.h
+++ b/velox/expression/SpecialForm.h
@@ -22,6 +22,7 @@ namespace facebook::velox::exec {
 class SpecialForm : public Expr {
  public:
   SpecialForm(
+      SpecialFormKind kind,
       TypePtr type,
       std::vector<ExprPtr> inputs,
       const std::string& name,
@@ -31,7 +32,7 @@ class SpecialForm : public Expr {
             std::move(type),
             std::move(inputs),
             name,
-            true /* specialForm */,
+            kind,
             supportsFlatNoNullsFastPath,
             trackCpuUsage) {}
 
@@ -40,5 +41,9 @@ class SpecialForm : public Expr {
   virtual void computePropagatesNulls() {
     VELOX_NYI();
   }
+
+  SpecialFormKind kind() const {
+    return specialFormKind();
+  }
 };
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SwitchExpr.cpp b/velox/expression/SwitchExpr.cpp
index 3ef508a6c8bb..29031fcee7b4 100644
--- a/velox/expression/SwitchExpr.cpp
+++ b/velox/expression/SwitchExpr.cpp
@@ -15,9 +15,9 @@
  */
 #include "velox/expression/SwitchExpr.h"
 #include "velox/expression/BooleanMix.h"
-#include "velox/expression/ConstantExpr.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/FieldReference.h"
-#include "velox/expression/ScopedVarSetter.h"
+#include "velox/type/TypeCoercer.h"
 
 namespace facebook::velox::exec {
 
@@ -25,6 +25,16 @@ namespace {
 bool hasElseClause(const std::vector<ExprPtr>& inputs) {
   return inputs.size() % 2 == 1;
 }
+
+TypePtr resolveTypeInt(
+    const std::vector<TypePtr>& argTypes,
+    bool allowedCoercions,
+    std::vector<TypePtr>& coercions);
+
+TypePtr resolveTypeInt(const std::vector<TypePtr>& argTypes) {
+  std::vector<TypePtr> coercions;
+  return resolveTypeInt(argTypes, false, coercions);
+};
 } // namespace
 
 SwitchExpr::SwitchExpr(
@@ -32,9 +42,10 @@ SwitchExpr::SwitchExpr(
     const std::vector<ExprPtr>& inputs,
     bool inputsSupportFlatNoNullsFastPath)
     : SpecialForm(
+          SpecialFormKind::kSwitch,
           std::move(type),
           inputs,
-          "switch",
+          expression::kSwitch,
           hasElseClause(inputs) && inputsSupportFlatNoNullsFastPath,
           false /* trackCpuUsage */),
       numCases_{inputs_.size() / 2},
@@ -48,10 +59,10 @@ SwitchExpr::SwitchExpr(
       [](const ExprPtr& expr) { return expr->type(); });
 
   // Apply type checking.
-  auto typeExpected = resolveType(inputTypes);
+  auto typeExpected = resolveTypeInt(inputTypes);
   VELOX_CHECK(
       *typeExpected == *this->type(),
-      "Switch expression type different than then clause. Expected {} but got Actual {}.",
+      "Switch expression type different than then clause. Expected {}, but got {}.",
       typeExpected->toString(),
       this->type()->toString());
 }
@@ -165,7 +176,8 @@ void SwitchExpr::evalSpecialForm(
   }
   // TODO: Fix evaluate lambda expression return vector of size 0 issue #6270.
   if (type()->kind() != TypeKind::FUNCTION) {
-    VELOX_CHECK(localResult && localResult->size() >= rows.end());
+    VELOX_CHECK_NOT_NULL(localResult);
+    VELOX_CHECK_GE(localResult->size(), rows.end());
   }
 
   context.moveOrCopyResult(localResult, rows, finalResult);
@@ -217,58 +229,93 @@ void SwitchExpr::computePropagatesNulls() {
   propagatesNulls_ = true;
 }
 
-// static
-TypePtr SwitchExpr::resolveType(const std::vector<TypePtr>& argTypes) {
+namespace {
+TypePtr resolveTypeInt(
+    const std::vector<TypePtr>& argTypes,
+    bool allowedCoercions,
+    std::vector<TypePtr>& coercions) {
   VELOX_CHECK_GT(
       argTypes.size(),
       1,
       "Switch statements expect at least 2 arguments, received {}",
       argTypes.size());
-  // Type structure is [cond1Type, then1Type, cond2Type, then2Type, ...
-  // elseType*]
 
-  // Make sure all 'condition' expressions hae type BOOLEAN and all 'then' and
-  // an optional 'else' clause have the same type.
-  int numCases = argTypes.size() / 2;
+  const size_t numArgs = argTypes.size();
+  const size_t numCases = numArgs / 2;
 
-  auto& expressionType = argTypes[1];
+  TypePtr resultType = argTypes[1];
+
+  if (allowedCoercions) {
+    coercions.clear();
+    coercions.resize(numArgs);
+  }
+
+  auto setCoercionsUpTo = [&](int index, const TypePtr& type) {
+    for (auto i = 1; i <= index; i += 2) {
+      coercions[i] = type;
+    }
+  };
 
   for (auto i = 0; i < numCases; i++) {
-    auto& conditionType = argTypes[i * 2];
-    auto& thenType = argTypes[i * 2 + 1];
+    const auto& conditionType = argTypes[i * 2];
+    const auto& thenType = argTypes[i * 2 + 1];
 
     VELOX_CHECK_EQ(
         conditionType->kind(),
         TypeKind::BOOLEAN,
         "Condition of  SWITCH statement is not bool");
 
-    VELOX_CHECK(
-        *thenType == *expressionType,
-        "All then clauses of a SWITCH statement must have the same type. "
-        "Expected {}, but got {}.",
-        expressionType->toString(),
-        thenType->toString());
+    if (*thenType != *resultType) {
+      if (allowedCoercions && TypeCoercer::coercible(thenType, resultType)) {
+        coercions[i * 2 + 1] = resultType;
+      } else if (
+          allowedCoercions && TypeCoercer::coercible(resultType, thenType)) {
+        resultType = thenType;
+        setCoercionsUpTo(i * 2 - 1, resultType);
+      } else {
+        VELOX_FAIL(
+            "All then clauses of a SWITCH statement must have the same type. "
+            "Expected {}, but got {}.",
+            resultType->toString(),
+            thenType->toString());
+      }
+    }
   }
 
-  bool hasElse = argTypes.size() % 2 == 1;
-
+  const bool hasElse = argTypes.size() % 2 == 1;
   if (hasElse) {
-    auto& elseClauseType = argTypes.back();
-
-    VELOX_CHECK(
-        *elseClauseType == *expressionType,
-        "Else clause of a SWITCH statement must have the same type as 'then' clauses. "
-        "Expected {}, but got {}.",
-        expressionType->toString(),
-        elseClauseType->toString());
+    const auto& elseType = argTypes.back();
+
+    if (*elseType != *resultType) {
+      if (allowedCoercions && TypeCoercer::coercible(elseType, resultType)) {
+        coercions.back() = resultType;
+      } else if (
+          allowedCoercions && TypeCoercer::coercible(resultType, elseType)) {
+        resultType = elseType;
+        setCoercionsUpTo(numArgs - 2, resultType);
+      } else {
+        VELOX_FAIL(
+            "Else clause of a SWITCH statement must have the same type as 'then' clauses. "
+            "Expected {}, but got {}.",
+            resultType->toString(),
+            elseType->toString());
+      }
+    }
   }
 
-  return expressionType;
+  return resultType;
 }
+} // namespace
 
 TypePtr SwitchCallToSpecialForm::resolveType(
     const std::vector<TypePtr>& argTypes) {
-  return SwitchExpr::resolveType(argTypes);
+  return resolveTypeInt(argTypes);
+}
+
+TypePtr SwitchCallToSpecialForm::resolveTypeWithCorsions(
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  return resolveTypeInt(argTypes, true, coercions);
 }
 
 ExprPtr SwitchCallToSpecialForm::constructSpecialForm(
@@ -283,11 +330,22 @@ ExprPtr SwitchCallToSpecialForm::constructSpecialForm(
 }
 
 TypePtr IfCallToSpecialForm::resolveType(const std::vector<TypePtr>& argTypes) {
-  VELOX_CHECK(
-      argTypes.size() == 3,
-      "An IF statement must have 3 clauses, the if clause, the then clause, and the else clause. Expected 3, but got {}.",
-      argTypes.size());
+  VELOX_CHECK_EQ(
+      argTypes.size(),
+      3,
+      "An IF statement must have 3 clauses: 'if', 'then', and 'else'.");
+
+  return resolveTypeInt(argTypes);
+}
+
+TypePtr IfCallToSpecialForm::resolveTypeWithCorsions(
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  VELOX_CHECK_EQ(
+      argTypes.size(),
+      3,
+      "An IF statement must have 3 clauses: 'if', 'then', and 'else'.");
 
-  return SwitchCallToSpecialForm::resolveType(argTypes);
+  return resolveTypeInt(argTypes, true, coercions);
 }
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SwitchExpr.h b/velox/expression/SwitchExpr.h
index e5c9bf0f27b2..15ac6ca0514c 100644
--- a/velox/expression/SwitchExpr.h
+++ b/velox/expression/SwitchExpr.h
@@ -20,9 +20,6 @@
 
 namespace facebook::velox::exec {
 
-constexpr const char* kIf = "if";
-constexpr const char* kSwitch = "switch";
-
 /// CASE expression:
 ///
 /// case
@@ -61,21 +58,25 @@ class SwitchExpr : public SpecialForm {
   }
 
  private:
-  static TypePtr resolveType(const std::vector<TypePtr>& argTypes);
-
   void computePropagatesNulls() override;
 
   const size_t numCases_;
   const bool hasElseClause_;
   BufferPtr tempValues_;
-
-  friend class SwitchCallToSpecialForm;
 };
 
 class SwitchCallToSpecialForm : public FunctionCallToSpecialForm {
  public:
+  /// Returns the type of the 2nd argument. Throws if types of even arguments
+  /// (conditions) are not BOOLEAN or if types of odd arguments (then and else
+  /// branches) don't match.
   TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
 
+  /// Supports coercions for odd arguments (then and else branches).
+  TypePtr resolveTypeWithCorsions(
+      const std::vector<TypePtr>& argTypes,
+      std::vector<TypePtr>& coercions) override;
+
   ExprPtr constructSpecialForm(
       const TypePtr& type,
       std::vector<ExprPtr>&& compiledChildren,
@@ -85,6 +86,15 @@ class SwitchCallToSpecialForm : public FunctionCallToSpecialForm {
 
 class IfCallToSpecialForm : public SwitchCallToSpecialForm {
  public:
+  /// Returns the type of the 2nd argument. Throws if number of arguments is not
+  /// 3 or types, type of 1st argument (condition) is not BOOLEAN, or types of
+  /// 2nd (then) and 3rd (else) arguments don't match.
   TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
+
+  /// Supports coercions for 2nd and 3rd arguments (then and else branches).
+  TypePtr resolveTypeWithCorsions(
+      const std::vector<TypePtr>& argTypes,
+      std::vector<TypePtr>& coercions) override;
 };
+
 } // namespace facebook::velox::exec
diff --git a/velox/expression/SwitchRewrite.cpp b/velox/expression/SwitchRewrite.cpp
new file mode 100644
index 000000000000..ce46a94ab771
--- /dev/null
+++ b/velox/expression/SwitchRewrite.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 <set>
+
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/expression/ExprUtils.h"
+#include "velox/expression/SwitchRewrite.h"
+
+namespace facebook::velox::expression {
+
+core::TypedExprPtr SwitchRewrite::rewrite(const core::TypedExprPtr& expr) {
+  if (!expr->isCallKind()) {
+    return nullptr;
+  }
+  const auto* callExpr = expr->asUnchecked<core::CallTypedExpr>();
+  if (!(callExpr->name() == kSwitch) && !(callExpr->name() == kIf)) {
+    return nullptr;
+  }
+
+  const auto& inputs = expr->inputs();
+  const auto numInputs = inputs.size();
+  std::vector<core::TypedExprPtr> optimizedInputs;
+
+  // Iterate over all `(condition, value)` pairs. Handle `else` value at the
+  // end.
+  for (auto i = 0; i < numInputs - 1; i += 2) {
+    const auto& condition = inputs.at(i);
+    const auto& value = inputs.at(i + 1);
+
+    if (condition->isConstantKind()) {
+      const auto* constCondition =
+          condition->asUnchecked<core::ConstantTypedExpr>();
+      if (auto boolCondition = constCondition->toBool()) {
+        if (boolCondition.value()) {
+          // If this condition is true and all conditions before this are false,
+          // simplify `switch` expression to the corresponding `value`.
+          if (optimizedInputs.empty()) {
+            return value;
+          }
+          // If this condition is true and all conditions before this can only
+          // be evaluated at runtime, make this the new `else` value and stop
+          // checking further conditions.
+          optimizedInputs.push_back(value);
+          break;
+        } else {
+          // Skip false conditions.
+          continue;
+        }
+      } else {
+        // Skip NULL conditions.
+        continue;
+      }
+    } else {
+      optimizedInputs.push_back(condition);
+      optimizedInputs.push_back(value);
+    }
+  }
+
+  // Handle `else` value if present.
+  if (optimizedInputs.size() % 2 == 0 && numInputs % 2 == 1) {
+    const auto elseValue = inputs.at(numInputs - 1);
+    // Return `else` value if there are no conditions.
+    if (optimizedInputs.empty()) {
+      return elseValue;
+    }
+    optimizedInputs.emplace_back(elseValue);
+  }
+  // Return NULL if there are no conditions and `else` value is not present.
+  if (optimizedInputs.empty()) {
+    return core::ConstantTypedExpr::makeNull(expr->type());
+  }
+
+  return std::make_shared<core::CallTypedExpr>(
+      expr->type(), std::move(optimizedInputs), callExpr->name());
+}
+
+void SwitchRewrite::registerRewrite() {
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      expression::SwitchRewrite::rewrite);
+}
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/SwitchRewrite.h b/velox/expression/SwitchRewrite.h
new file mode 100644
index 000000000000..31e1df96beb7
--- /dev/null
+++ b/velox/expression/SwitchRewrite.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.
+ */
+#include "velox/core/Expressions.h"
+
+namespace facebook::velox::expression {
+
+class SwitchRewrite {
+ public:
+  /// Rewrites SWITCH and IF special form expressions which have the shape
+  /// `SWITCH(condition1, value1, condition2, value2, .., conditionN, valueN, ..
+  /// .., optional<elseValue>)`, and `IF(condition, trueValue, falseValue)`
+  /// respectively. IF expression is rewritten to `trueValue` or `falseValue`
+  /// if `condition` is either true or false respectively. The conditions of
+  /// SWITCH expression are traversed in order and if the condition is:
+  ///  1. false, it is removed from the inputs along with its corresponding
+  ///     value.
+  ///  2. true: If there are no inputs before this, the corresponding value
+  ///     is returned. Otherwise, the corresponding value is the new else value
+  ///     and all subsequent inputs are ignored.
+  ///  3. not a constant boolean and it cannot be evaluated without input data,
+  ///     the condition and its corresponding value are retained in the inputs.
+  /// If there are no conditions in the expression now, the else value is
+  /// returned if it is present; otherwise NULL is returned. The else value is
+  /// added to the inputs otherwise and the optimized SWITCH expression with
+  /// pruned inputs is returned.
+  static core::TypedExprPtr rewrite(const core::TypedExprPtr& expr);
+
+  static void registerRewrite();
+};
+
+} // namespace facebook::velox::expression
diff --git a/velox/expression/TryExpr.h b/velox/expression/TryExpr.h
index 1cc86cce5726..d248f9dcef87 100644
--- a/velox/expression/TryExpr.h
+++ b/velox/expression/TryExpr.h
@@ -15,21 +15,21 @@
  */
 #pragma once
 
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/FunctionCallToSpecialForm.h"
 #include "velox/expression/SpecialForm.h"
 
 namespace facebook::velox::exec {
 
-constexpr const char* kTry = "try";
-
 class TryExpr : public SpecialForm {
  public:
   /// Try expression adds nulls, hence, doesn't support flat-no-nulls fast path.
   TryExpr(TypePtr type, ExprPtr&& input)
       : SpecialForm(
+            SpecialFormKind::kTry,
             std::move(type),
             {std::move(input)},
-            kTry,
+            expression::kTry,
             false /* supportsFlatNoNullsFastPath */,
             false /* trackCpuUsage */) {}
 
diff --git a/velox/expression/TypeSignature.cpp b/velox/expression/TypeSignature.cpp
index b04bb0ae0079..422e3b68d8e0 100644
--- a/velox/expression/TypeSignature.cpp
+++ b/velox/expression/TypeSignature.cpp
@@ -15,12 +15,11 @@
  */
 
 #include "velox/expression/TypeSignature.h"
-#include "velox/common/base/Exceptions.h"
+#include <folly/String.h>
+#include <sstream>
 
 namespace facebook::velox::exec {
-void toAppend(
-    const facebook::velox::exec::TypeSignature& signature,
-    std::string* result) {
+void toAppend(const TypeSignature& signature, std::string* result) {
   result->append(signature.toString());
 }
 
@@ -31,7 +30,11 @@ std::string TypeSignature::toString() const {
   }
   out << baseName_;
   if (!parameters_.empty()) {
-    out << "(" << folly::join(",", parameters_) << ")";
+    if (isHomogeneousRow()) {
+      out << "(" << parameters_[0].toString() << ", ..." << ")";
+    } else {
+      out << "(" << folly::join(",", parameters_) << ")";
+    }
   }
   return out.str();
 }
diff --git a/velox/expression/TypeSignature.h b/velox/expression/TypeSignature.h
index 3dc2144fd368..13ae2bfad49e 100644
--- a/velox/expression/TypeSignature.h
+++ b/velox/expression/TypeSignature.h
@@ -33,13 +33,16 @@ class TypeSignature {
   /// @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.
+  /// @param variableArity indicates if the last parameter is variadic.
   TypeSignature(
       std::string baseName,
       std::vector<TypeSignature> parameters,
-      std::optional<std::string> rowFieldName = std::nullopt)
+      std::optional<std::string> rowFieldName = std::nullopt,
+      bool variableArity = false)
       : baseName_{std::move(baseName)},
         parameters_{std::move(parameters)},
-        rowFieldName_(rowFieldName) {}
+        rowFieldName_(std::move(rowFieldName)),
+        variableArity_{variableArity} {}
 
   const std::string& baseName() const {
     return baseName_;
@@ -53,11 +56,20 @@ class TypeSignature {
     return rowFieldName_;
   }
 
+  bool variableArity() const {
+    return variableArity_;
+  }
+
+  bool isHomogeneousRow() const {
+    return baseName_ == "row" && parameters_.size() == 1 && variableArity_;
+  }
+
   std::string toString() const;
 
   bool operator==(const TypeSignature& rhs) const {
     return baseName_ == rhs.baseName_ && parameters_ == rhs.parameters_ &&
-        rowFieldName_ == rhs.rowFieldName_;
+        rowFieldName_ == rhs.rowFieldName_ &&
+        variableArity_ == rhs.variableArity_;
   }
 
  private:
@@ -66,7 +78,10 @@ class TypeSignature {
 
   // 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_;
+  const std::optional<std::string> rowFieldName_;
+
+  // Indicates if the parameter is variadic.
+  const bool variableArity_;
 };
 
 using TypeSignaturePtr = std::shared_ptr<TypeSignature>;
diff --git a/velox/expression/UdfTypeResolver.h b/velox/expression/UdfTypeResolver.h
index b27c197dbdb4..90472c3ec44c 100644
--- a/velox/expression/UdfTypeResolver.h
+++ b/velox/expression/UdfTypeResolver.h
@@ -150,6 +150,13 @@ struct resolver<IntervalYearMonth> {
   using out_type = int32_t;
 };
 
+template <>
+struct resolver<Time> {
+  using in_type = int64_t;
+  using null_free_in_type = in_type;
+  using out_type = int64_t;
+};
+
 template <typename T>
 struct resolver<std::shared_ptr<T>> {
   using in_type = std::shared_ptr<T>;
diff --git a/velox/expression/VectorFunction.cpp b/velox/expression/VectorFunction.cpp
index 44e70cd44977..f002423a806e 100644
--- a/velox/expression/VectorFunction.cpp
+++ b/velox/expression/VectorFunction.cpp
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 #include "velox/expression/VectorFunction.h"
-#include <unordered_map>
-#include "folly/Singleton.h"
 #include "folly/Synchronized.h"
 #include "velox/expression/SignatureBinder.h"
 
@@ -88,6 +86,58 @@ TypePtr resolveVectorFunction(
   return nullptr;
 }
 
+namespace {
+bool hasCoercion(const std::vector<Coercion>& coercions) {
+  for (const auto& coercion : coercions) {
+    if (coercion.type != nullptr) {
+      return true;
+    }
+  }
+
+  return false;
+}
+} // namespace
+
+TypePtr resolveVectorFunctionWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  coercions.clear();
+
+  auto optionalType = applyToVectorFunctionEntry<TypePtr>(
+      functionName,
+      [&](const auto& /*name*/, const auto& entry) -> std::optional<TypePtr> {
+        std::vector<std::pair<std::vector<Coercion>, TypePtr>> candidates;
+        for (const auto& signature : entry.signatures) {
+          exec::SignatureBinder binder(*signature, argTypes);
+          std::vector<Coercion> requiredCoercions;
+          if (binder.tryBindWithCoercions(requiredCoercions)) {
+            auto type = binder.tryResolveReturnType();
+            if (!hasCoercion(requiredCoercions)) {
+              coercions.resize(argTypes.size(), nullptr);
+              return type;
+            }
+
+            candidates.emplace_back(requiredCoercions, type);
+          }
+        }
+
+        if (auto index = Coercion::pickLowestCost(candidates)) {
+          const auto& requiredCoercions = candidates[index.value()].first;
+          coercions.reserve(requiredCoercions.size());
+          for (const auto& coercion : requiredCoercions) {
+            coercions.push_back(coercion.type);
+          }
+
+          return candidates[index.value()].second;
+        }
+
+        return std::nullopt;
+      });
+
+  return optionalType.value_or(nullptr);
+}
+
 std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
 resolveVectorFunctionWithMetadata(
     const std::string& functionName,
@@ -195,13 +245,4 @@ bool registerVectorFunction(
       name, signatures, factory, metadata, overwrite);
 }
 
-std::vector<ExpressionRewrite>& expressionRewrites() {
-  static std::vector<ExpressionRewrite> rewrites;
-  return rewrites;
-}
-
-void registerExpressionRewrite(ExpressionRewrite rewrite) {
-  expressionRewrites().emplace_back(rewrite);
-}
-
 } // namespace facebook::velox::exec
diff --git a/velox/expression/VectorFunction.h b/velox/expression/VectorFunction.h
index 085047da0cde..5f0c59c8dc55 100644
--- a/velox/expression/VectorFunction.h
+++ b/velox/expression/VectorFunction.h
@@ -17,7 +17,7 @@
 #pragma once
 
 #include <vector>
-#include "velox/core/Expressions.h"
+#include "velox/core/ITypedExpr.h"
 #include "velox/expression/EvalCtx.h"
 #include "velox/expression/FunctionMetadata.h"
 #include "velox/expression/FunctionSignature.h"
@@ -166,7 +166,8 @@ class SimpleFunctionAdapterFactory {
   virtual std::unique_ptr<VectorFunction> createVectorFunction(
       const std::vector<TypePtr>& inputTypes,
       const std::vector<VectorPtr>& constantInputs,
-      const core::QueryConfig& config) const = 0;
+      const core::QueryConfig& config,
+      memory::MemoryPool* memoryPool = nullptr) const = 0;
   virtual ~SimpleFunctionAdapterFactory() = default;
 };
 
@@ -187,6 +188,11 @@ TypePtr resolveVectorFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+TypePtr resolveVectorFunctionWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions);
+
 std::optional<std::pair<TypePtr, VectorFunctionMetadata>>
 resolveVectorFunctionWithMetadata(
     const std::string& functionName,
@@ -274,22 +280,6 @@ bool registerStatefulVectorFunction(
     VectorFunctionMetadata metadata = {},
     bool overwrite = true);
 
-/// An expression re-writer that takes an expression and returns an equivalent
-/// expression or nullptr if re-write is not possible.
-using ExpressionRewrite = std::function<core::TypedExprPtr(core::TypedExprPtr)>;
-
-/// Returns a list of registered re-writes.
-std::vector<ExpressionRewrite>& expressionRewrites();
-
-/// Appends a 'rewrite' to 'expressionRewrites'.
-///
-/// The logic that applies re-writes is very simple and assumes that all
-/// rewrites are independent. Re-writes are applied to all expressions starting
-/// at the root and going down the hierarchy. For each expression, rewrites are
-/// applied in the order they were registered. The first rewrite that returns
-/// non-null result terminates the re-write for this particular expression.
-void registerExpressionRewrite(ExpressionRewrite rewrite);
-
 } // namespace facebook::velox::exec
 
 // Private. Return the external function name given a UDF tag.
diff --git a/velox/expression/VectorReaders.h b/velox/expression/VectorReaders.h
index b042b04c3a33..1411bcd33cc2 100644
--- a/velox/expression/VectorReaders.h
+++ b/velox/expression/VectorReaders.h
@@ -115,7 +115,7 @@ struct ConstantVectorReader {
 
   std::optional<exec_in_t> value;
 
-  explicit ConstantVectorReader<T>(ConstantVector<exec_in_t>& vector) {
+  explicit ConstantVectorReader(ConstantVector<exec_in_t>& vector) {
     if (!vector.isNullAt(0)) {
       value = *vector.rawValues();
     }
@@ -160,7 +160,7 @@ struct FlatVectorReader {
   const exec_in_t* values;
   FlatVector<exec_in_t>* vector;
 
-  explicit FlatVectorReader<T>(FlatVector<exec_in_t>& baseVector)
+  explicit FlatVectorReader(FlatVector<exec_in_t>& baseVector)
       : values(baseVector.rawValues()), vector(&baseVector) {}
 
   exec_in_t operator[](vector_size_t offset) const {
@@ -733,8 +733,9 @@ struct VectorReader<DynamicRow> {
         vector_(detail::getDecoded<in_vector_t>(decoded_)),
         childrenDecoders_{vector_.childrenSize()} {
     for (int i = 0; i < vector_.childrenSize(); i++) {
-      childReaders_.push_back(std::make_unique<VectorReader<Any>>(
-          detail::decode(childrenDecoders_[i], *vector_.childAt(i))));
+      childReaders_.push_back(
+          std::make_unique<VectorReader<Any>>(
+              detail::decode(childrenDecoders_[i], *vector_.childAt(i))));
     }
   }
 
diff --git a/velox/expression/VectorWriters.h b/velox/expression/VectorWriters.h
index c2d845144c61..da5d19fb77d9 100644
--- a/velox/expression/VectorWriters.h
+++ b/velox/expression/VectorWriters.h
@@ -47,7 +47,8 @@ struct VectorWriter : public VectorWriterBase {
     }
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     if (size > vector_->size()) {
       vector_->resize(size, /*setNotNull*/ false);
       data_ = vector_->mutableRawValues();
@@ -118,7 +119,8 @@ struct VectorWriter<Array<V>> : public VectorWriterBase {
     return *arrayVector_;
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     if (size > arrayVector_->size()) {
       arrayVector_->resize(size);
     }
@@ -198,7 +200,8 @@ struct VectorWriter<Map<K, V>> : public VectorWriterBase {
     return *mapVector_;
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     if (size > mapVector_->size()) {
       mapVector_->resize(size);
     }
@@ -275,7 +278,8 @@ struct VectorWriter<Row<T...>> : public VectorWriterBase {
     return *rowVector_;
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     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.
@@ -336,8 +340,9 @@ struct VectorWriter<Row<T...>> : public VectorWriterBase {
     } else {
       using type = std::tuple_element_t<I, children_types>;
       std::get<I>(writer_.childrenWriters_)
-          .init(static_cast<typename TypeToFlatVector<type>::type&>(
-              *rowVector_->childAt(I).get()));
+          .init(
+              static_cast<typename TypeToFlatVector<type>::type&>(
+                  *rowVector_->childAt(I).get()));
 
       initVectorWriters<I + 1>();
     }
@@ -359,9 +364,10 @@ struct VectorWriter<
     proxy_.vector_ = &vector;
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     if (size > proxy_.vector_->size()) {
-      proxy_.vector_->resize(size, /*setNotNull*/ false);
+      proxy_.vector_->resize(size, /*setNotNull=*/false);
     }
   }
 
@@ -410,7 +416,8 @@ struct VectorWriter<T, std::enable_if_t<std::is_same_v<T, bool>>>
     vector_ = &vector;
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     if (size > vector_->size()) {
       vector_->resize(size, /*setNotNull*/ false);
     }
@@ -457,7 +464,8 @@ struct VectorWriter<std::shared_ptr<T>> : public VectorWriterBase {
     vector_ = &vector;
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     if (size > vector_->size()) {
       vector_->resize(size, /*setNotNull*/ false);
     }
@@ -546,7 +554,8 @@ struct VectorWriter<Generic<T, comparable, orderable>>
     }
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     if (castType_) {
       castWriter_->ensureSize(size);
     } else {
@@ -723,7 +732,8 @@ struct VectorWriter<DynamicRow, void> : public VectorWriterBase {
     return *rowVector_;
   }
 
-  void ensureSize(size_t size) override {
+  void ensureSize(vector_size_t size) override {
+    VELOX_CHECK_GE(size, 0);
     if (size > rowVector_->size()) {
       for (int i = 0; i < writer_.childrenCount_; ++i) {
         writer_.childrenWriters_[i]->ensureSize(size);
diff --git a/velox/expression/benchmarks/CMakeLists.txt b/velox/expression/benchmarks/CMakeLists.txt
index 80321cb6db86..9ed0e6b72438 100644
--- a/velox/expression/benchmarks/CMakeLists.txt
+++ b/velox/expression/benchmarks/CMakeLists.txt
@@ -12,47 +12,49 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(BENCHMARK_DEPENDENCIES
-    velox_functions_test_lib
-    velox_exec
-    velox_exec_test_lib
-    gflags::gflags
-    Folly::folly
-    Folly::follybenchmark)
+set(
+  BENCHMARK_DEPENDENCIES
+  velox_functions_test_lib
+  velox_exec
+  velox_exec_test_lib
+  gflags::gflags
+  Folly::folly
+  Folly::follybenchmark
+)
 
-add_executable(velox_benchmark_call_null_free_no_nulls
-               CallNullFreeBenchmark.cpp)
-target_link_libraries(
-  velox_benchmark_call_null_free_no_nulls ${BENCHMARK_DEPENDENCIES})
+add_executable(velox_benchmark_call_null_free_no_nulls CallNullFreeBenchmark.cpp)
+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)
+  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})
+add_executable(velox_benchmark_call_null_free_null_arrays CallNullFreeBenchmark.cpp)
+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)
+  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})
+add_executable(velox_benchmark_call_null_free_null_elements CallNullFreeBenchmark.cpp)
+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)
+  velox_benchmark_call_null_free_null_elements
+  PUBLIC WITH_NULL_ARRAYS=false WITH_NULL_ELEMENTS=true
+)
 
-add_executable(velox_benchmark_call_null_free_null_arrays_and_null_elements
-               CallNullFreeBenchmark.cpp)
+add_executable(
+  velox_benchmark_call_null_free_null_arrays_and_null_elements
+  CallNullFreeBenchmark.cpp
+)
 target_link_libraries(
   velox_benchmark_call_null_free_null_arrays_and_null_elements
-  ${BENCHMARK_DEPENDENCIES})
+  ${BENCHMARK_DEPENDENCIES}
+)
 target_compile_definitions(
   velox_benchmark_call_null_free_null_arrays_and_null_elements
-  PUBLIC WITH_NULL_ARRAYS=true WITH_NULL_ELEMENTS=true)
+  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/fuzzer/ArgValuesGenerators.cpp b/velox/expression/fuzzer/ArgValuesGenerators.cpp
index 16cb029e5647..cc313d67bb76 100644
--- a/velox/expression/fuzzer/ArgValuesGenerators.cpp
+++ b/velox/expression/fuzzer/ArgValuesGenerators.cpp
@@ -137,11 +137,12 @@ std::vector<core::TypedExprPtr> PhoneNumberArgValuesGenerator::generate(
             seed, signature.args[0], nullRatio));
 
     VELOX_CHECK_GE(state.inputRowNames_.size(), 1);
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[0],
-        signature.args.size() == 1
-            ? state.inputRowNames_.back()
-            : state.inputRowNames_[state.inputRowNames_.size() - 2]));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0],
+            signature.args.size() == 1
+                ? state.inputRowNames_.back()
+                : state.inputRowNames_[state.inputRowNames_.size() - 2]));
 
     //  Populate state.customInputGenerators_ and inputExpressions with nullptr
     //  for inputs that do not require custom input generators
@@ -158,12 +159,13 @@ std::vector<core::TypedExprPtr> PhoneNumberArgValuesGenerator::generate(
             seed, signature.args[0], nullRatio));
 
     VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size());
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[0],
-        signature.args.size() == 1
-            ? state.inputRowNames_.back()
-            : state.inputRowNames_
-                  [state.inputRowNames_.size() - signature.args.size()]));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0],
+            signature.args.size() == 1
+                ? state.inputRowNames_.back()
+                : state.inputRowNames_
+                      [state.inputRowNames_.size() - signature.args.size()]));
 
     for (int i = 1; i < signature.args.size(); i++) {
       if (i == 1) {
@@ -218,8 +220,9 @@ std::vector<core::TypedExprPtr> JsonExtractArgValuesGenerator::generate(
     state.inputRowTypes_.emplace_back(signature.args[i]);
     state.inputRowNames_.emplace_back(
         fmt::format("c{}", state.inputRowTypes_.size() - 1));
-    inputExpressions.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[i], state.inputRowNames_.back()));
+    inputExpressions.push_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[i], state.inputRowNames_.back()));
   }
 
   const auto nullRatio = options.nullRatio;
@@ -304,8 +307,118 @@ std::vector<core::TypedExprPtr> CastVarcharAndJsonArgValuesGenerator::generate(
     }
 
     VELOX_CHECK_GE(signature.args.size(), 1);
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[0], state.inputRowNames_.back()));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0], state.inputRowNames_.back()));
+  }
+
+  return inputExpressions;
+}
+
+std::vector<core::TypedExprPtr> QDigestArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  populateInputTypesAndNames(signature, state);
+  const auto seed = rand<uint32_t>(rng);
+  const auto nullRatio = options.nullRatio;
+  std::vector<core::TypedExprPtr> inputExpressions;
+  VELOX_CHECK_GE(signature.args.size(), 2);
+  const std::vector<std::string> functionNames = {
+      "value_at_quantile",
+      "values_at_quantiles",
+      "quantile_at_value",
+      "scale_qdigest",
+      "fb_truncated_mean"};
+  if (std::find(functionNames.begin(), functionNames.end(), functionName_) ==
+      functionNames.end()) {
+    return inputExpressions;
+  }
+  VELOX_CHECK_GE(state.inputRowNames_.size(), 2);
+
+  const auto& qDigestType = [&signature]() -> TypePtr {
+    const auto& typeStr = signature.args[0]->toString();
+    if (typeStr.find("QDIGEST(BIGINT)") != std::string::npos) {
+      return BIGINT();
+    } else if (typeStr.find("QDIGEST(DOUBLE)") != std::string::npos) {
+      return DOUBLE();
+    } else if (typeStr.find("QDIGEST(REAL)") != std::string::npos) {
+      return REAL();
+    }
+    VELOX_UNREACHABLE("Unsupported QDigest type: {}", typeStr);
+  };
+
+  state.customInputGenerators_.emplace_back(
+      std::make_shared<fuzzer::QDigestInputGenerator>(
+          seed, signature.args[0], nullRatio, qDigestType()));
+  VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size());
+  inputExpressions.emplace_back(
+      std::make_shared<core::FieldAccessTypedExpr>(
+          signature.args[0],
+          signature.args.size() == 1
+              ? state.inputRowNames_.back()
+              : state.inputRowNames_
+                    [state.inputRowNames_.size() - signature.args.size()]));
+
+  // Add null generators for remaining arguments
+  for (size_t i = 1; i < signature.args.size(); i++) {
+    state.customInputGenerators_.emplace_back(nullptr);
+    VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size() - i);
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[i],
+            state.inputRowNames_
+                [state.inputRowNames_.size() + i - signature.args.size()]));
+  }
+  return inputExpressions;
+}
+
+std::vector<core::TypedExprPtr> URLArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  VELOX_CHECK_GE(signature.args.size(), 1);
+  populateInputTypesAndNames(signature, state);
+  std::vector<core::TypedExprPtr> inputExpressions;
+
+  const auto seed = rand<uint32_t>(rng);
+  const auto nullRatio = options.nullRatio;
+
+  // Only URL part of input should have URL input generation.
+  state.customInputGenerators_.emplace_back(
+      std::make_shared<fuzzer::URLInputGenerator>(
+          seed,
+          signature.args[0],
+          nullRatio,
+          signature.name,
+          std::vector<std::string>(
+              {"url_extract_query",
+               "url_extract_path",
+               "url_extract_host",
+               "url_extract_protocol"}),
+          std::vector<std::string>(
+              {"url_extract_path",
+               "url_extract_fragment",
+               "url_extract_query",
+               "url_extract_protocol",
+               "url_extract_host"})));
+
+  VELOX_CHECK_GE(signature.args.size(), 1);
+  inputExpressions.emplace_back(
+      std::make_shared<core::FieldAccessTypedExpr>(
+          signature.args[0], state.inputRowNames_.back()));
+
+  // Add null generators for remaining arguments
+  for (size_t i = 1; i < signature.args.size(); i++) {
+    state.customInputGenerators_.emplace_back(nullptr);
+    VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size() - i);
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[i],
+            state.inputRowNames_
+                [state.inputRowNames_.size() + i - signature.args.size()]));
   }
 
   return inputExpressions;
@@ -326,6 +439,7 @@ std::vector<core::TypedExprPtr> TDigestArgValuesGenerator::generate(
       "values_at_quantiles",
       "scale_tdigest",
       "quantile_at_value",
+      "quantiles_at_values",
       "destructure_tdigest",
       "trimmed_mean"};
   if (std::find(functionNames.begin(), functionNames.end(), functionName_) !=
@@ -335,12 +449,13 @@ std::vector<core::TypedExprPtr> TDigestArgValuesGenerator::generate(
         std::make_shared<fuzzer::TDigestInputGenerator>(
             seed, signature.args[0], nullRatio));
     VELOX_CHECK_GE(state.inputRowNames_.size(), signature.args.size());
-    inputExpressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        signature.args[0],
-        signature.args.size() == 1
-            ? state.inputRowNames_.back()
-            : state.inputRowNames_
-                  [state.inputRowNames_.size() - signature.args.size()]));
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0],
+            signature.args.size() == 1
+                ? state.inputRowNames_.back()
+                : state.inputRowNames_
+                      [state.inputRowNames_.size() - signature.args.size()]));
     // Add null generators for remaining arguments
     for (size_t i = 1; i < signature.args.size(); i++) {
       state.customInputGenerators_.emplace_back(nullptr);
@@ -354,4 +469,174 @@ std::vector<core::TypedExprPtr> TDigestArgValuesGenerator::generate(
   }
   return inputExpressions;
 }
+
+std::vector<core::TypedExprPtr> UnifiedDigestArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  VELOX_CHECK_GE(signature.args.size(), 1);
+  const auto& argType = signature.args[0];
+
+  if (argType->toString().find("TDIGEST") != std::string::npos) {
+    return tdigestGenerator_.generate(signature, options, rng, state);
+
+  } else if (argType->toString().find("QDIGEST") != std::string::npos) {
+    return qdigestGenerator_.generate(signature, options, rng, state);
+  }
+
+  VELOX_UNREACHABLE("Unsupported digest type");
+}
+
+std::vector<core::TypedExprPtr>
+FbDedupNormalizeTextArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  VELOX_CHECK_LE(signature.args.size(), 2);
+  populateInputTypesAndNames(signature, state);
+
+  const auto seed = static_cast<size_t>(rand<uint32_t>(rng));
+  const auto nullRatio = options.nullRatio;
+
+  // Add custom input generator for the first argument (text)
+  state.customInputGenerators_.emplace_back(
+      std::make_shared<RandomInputGenerator<StringView>>(
+          seed,
+          signature.args[0],
+          nullRatio,
+          20,
+          std::vector<UTF8CharList>{
+              UTF8CharList::ASCII,
+              UTF8CharList::UNICODE_CASE_SENSITIVE,
+              UTF8CharList::EXTENDED_UNICODE,
+              UTF8CharList::MATHEMATICAL_SYMBOLS},
+          RandomStrVariationOptions{
+              /*controlCharacterProbability=*/0.5,
+              /*escapeStringProbability=*/0.5,
+              /*truncateProbability=*/0.2,
+          }));
+
+  // Populate inputExpressions_ for the argument that requires custom
+  // generation. A nullptr should be added at inputExpressions[i] if the i-th
+  // argument does not require custom input generation.
+  std::vector<core::TypedExprPtr> inputExpressions{
+      signature.args.size(), nullptr};
+
+  // First argument (text) - use FieldAccessTypedExpr
+  inputExpressions[0] = std::make_shared<core::FieldAccessTypedExpr>(
+      signature.args[0], state.inputRowNames_.back());
+
+  // Second argument (normalization form) - Add an INVALID form
+  if (signature.args.size() > 1) {
+    // Add null generator for second argument if it exists
+    state.customInputGenerators_.emplace_back(nullptr);
+
+    static const std::vector<std::string> testForms = {
+        "NFC", "NFD", "NFKC", "NFKD", "INVALID"};
+
+    auto index = rand<uint64_t>(rng, 0, testForms.size() - 1);
+    inputExpressions[1] = std::make_shared<core::ConstantTypedExpr>(
+        VARCHAR(), variant(testForms[index]));
+  }
+
+  return inputExpressions;
+}
+
+std::vector<core::TypedExprPtr> AtTimezoneArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  VELOX_CHECK_EQ(signature.args.size(), 2);
+  populateInputTypesAndNames(signature, state);
+
+  std::vector<core::TypedExprPtr> inputExpressions{
+      signature.args.size(), nullptr};
+
+  // First argument - use default generation (TIME WITH TIME ZONE or TIMESTAMP
+  // WITH TIME ZONE)
+  state.customInputGenerators_.emplace_back(nullptr);
+  inputExpressions[0] = std::make_shared<core::FieldAccessTypedExpr>(
+      signature.args[0], state.inputRowNames_[state.inputRowNames_.size() - 2]);
+
+  // Second argument - constrain to valid timezone offset formats
+  // Valid formats: "+HH:mm" or "-HH:mm" (Presto-compatible)
+  // Offset range: -14:00 to +14:00
+  // Uses shared timezone generation utility (25% frequently used, 75% random)
+  state.customInputGenerators_.emplace_back(nullptr);
+
+  // Generate random timezone offset and convert to string
+  int16_t offsetMinutes = generateRandomTimezoneOffset(rng);
+  std::string timezoneString = timezoneOffsetToString(offsetMinutes);
+  inputExpressions[1] = std::make_shared<core::ConstantTypedExpr>(
+      VARCHAR(), variant(timezoneString));
+
+  return inputExpressions;
+}
+
+std::vector<core::TypedExprPtr> SetDigestArgValuesGenerator::generate(
+    const CallableSignature& signature,
+    const VectorFuzzer::Options& options,
+    FuzzerGenerator& rng,
+    ExpressionFuzzerState& state) {
+  populateInputTypesAndNames(signature, state);
+  const auto seed = rand<uint32_t>(rng);
+  const auto nullRatio = options.nullRatio;
+  std::vector<core::TypedExprPtr> inputExpressions;
+
+  VELOX_CHECK_GE(signature.args.size(), 1);
+  VELOX_CHECK_LE(signature.args.size(), 2);
+
+  const std::vector<std::string> singleArgFunctions = {
+      "hash_counts", "cardinality"};
+  const std::vector<std::string> twoArgFunctions = {
+      "jaccard_index", "intersection_cardinality"};
+
+  if (std::find(
+          singleArgFunctions.begin(),
+          singleArgFunctions.end(),
+          functionName_) != singleArgFunctions.end()) {
+    // Functions with one SetDigest input
+    VELOX_CHECK_EQ(signature.args.size(), 1);
+
+    state.customInputGenerators_.emplace_back(
+        std::make_shared<fuzzer::SetDigestInputGenerator>(
+            seed, signature.args[0], nullRatio));
+
+    VELOX_CHECK_GE(state.inputRowNames_.size(), 1);
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0], state.inputRowNames_.back()));
+  } else if (
+      std::find(
+          twoArgFunctions.begin(), twoArgFunctions.end(), functionName_) !=
+      twoArgFunctions.end()) {
+    // Functions with two SetDigest inputs
+    VELOX_CHECK_EQ(signature.args.size(), 2);
+
+    // First SetDigest input
+    state.customInputGenerators_.emplace_back(
+        std::make_shared<fuzzer::SetDigestInputGenerator>(
+            seed, signature.args[0], nullRatio));
+
+    VELOX_CHECK_GE(state.inputRowNames_.size(), 2);
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[0],
+            state.inputRowNames_[state.inputRowNames_.size() - 2]));
+
+    // Second SetDigest input
+    state.customInputGenerators_.emplace_back(
+        std::make_shared<fuzzer::SetDigestInputGenerator>(
+            seed + 1, signature.args[1], nullRatio));
+
+    inputExpressions.emplace_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            signature.args[1],
+            state.inputRowNames_[state.inputRowNames_.size() - 1]));
+  }
+  return inputExpressions;
+}
 } // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ArgValuesGenerators.h b/velox/expression/fuzzer/ArgValuesGenerators.h
index 0fa8d2d4bd0e..d2afd7808271 100644
--- a/velox/expression/fuzzer/ArgValuesGenerators.h
+++ b/velox/expression/fuzzer/ArgValuesGenerators.h
@@ -65,7 +65,7 @@ class PhoneNumberArgValuesGenerator : public ArgValuesGenerator {
 // 2. the size of all container types in the JSON argument do not exceed a
 // randomly generated maxContainerSize.
 // 1. either all map keys in all maps in the JSON argument are VARCHAR or they
-// are BIGINT, and all map-key values are choosen from a randomly generated
+// are BIGINT, and all map-key values are chosen from a randomly generated
 // candidate set. The size of the candidate map-key set is slightly larger than
 // maxContainerSize, so that access into maps by keys has matches and misses.
 //
@@ -93,6 +93,17 @@ class CastVarcharAndJsonArgValuesGenerator : public ArgValuesGenerator {
       ExpressionFuzzerState& state) override;
 };
 
+class URLArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  ~URLArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+};
+
 class TDigestArgValuesGenerator : public ArgValuesGenerator {
  public:
   explicit TDigestArgValuesGenerator(std::string functionName) {
@@ -109,4 +120,89 @@ class TDigestArgValuesGenerator : public ArgValuesGenerator {
  private:
   std::string functionName_;
 };
+
+class QDigestArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  explicit QDigestArgValuesGenerator(std::string functionName) {
+    functionName_ = std::move(functionName);
+  }
+  ~QDigestArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+
+ private:
+  std::string functionName_;
+};
+
+class UnifiedDigestArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  explicit UnifiedDigestArgValuesGenerator(std::string functionName)
+      : functionName_(std::move(functionName)),
+        tdigestGenerator_(functionName_),
+        qdigestGenerator_(functionName_) {}
+
+  ~UnifiedDigestArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+
+ private:
+  std::string functionName_;
+  TDigestArgValuesGenerator tdigestGenerator_;
+  QDigestArgValuesGenerator qdigestGenerator_;
+};
+
+/// Generates arguments for fb_dedup_normalize_text function.
+/// For the two-parameter version, constrains the second parameter to valid
+/// normalization forms: NFC, NFD, NFKC, NFKD.
+class FbDedupNormalizeTextArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  FbDedupNormalizeTextArgValuesGenerator() = default;
+  ~FbDedupNormalizeTextArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+};
+
+/// Generates arguments for at_timezone function.
+/// Constrains the second parameter (timezone) to valid timezone offset formats
+/// (e.g., "+HH:MM", "-HH:MM", "+HH", etc.) instead of random strings.
+class AtTimezoneArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  AtTimezoneArgValuesGenerator() = default;
+  ~AtTimezoneArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+};
+
+class SetDigestArgValuesGenerator : public ArgValuesGenerator {
+ public:
+  explicit SetDigestArgValuesGenerator(std::string functionName) {
+    functionName_ = std::move(functionName);
+  }
+  ~SetDigestArgValuesGenerator() override = default;
+
+  std::vector<core::TypedExprPtr> generate(
+      const CallableSignature& signature,
+      const VectorFuzzer::Options& options,
+      FuzzerGenerator& rng,
+      ExpressionFuzzerState& state) override;
+
+ private:
+  std::string functionName_;
+};
 } // namespace facebook::velox::fuzzer
diff --git a/velox/expression/fuzzer/ArgumentTypeFuzzer.cpp b/velox/expression/fuzzer/ArgumentTypeFuzzer.cpp
index a8fdb752510c..32a1b51a1bd0 100644
--- a/velox/expression/fuzzer/ArgumentTypeFuzzer.cpp
+++ b/velox/expression/fuzzer/ArgumentTypeFuzzer.cpp
@@ -46,7 +46,7 @@ std::string typeToBaseName(const TypePtr& type) {
 
 std::optional<TypeKind> baseNameToTypeKind(const std::string& typeName) {
   auto kindName = boost::algorithm::to_upper_copy(typeName);
-  return tryMapNameToTypeKind(kindName);
+  return TypeKindName::tryToTypeKind(kindName);
 }
 
 namespace {
@@ -108,6 +108,51 @@ void ArgumentTypeFuzzer::determineUnboundedIntegerVariables(
   }
 }
 
+void ArgumentTypeFuzzer::determineUnboundedEnumVariables(
+    const exec::TypeSignature& type) {
+  const auto typeName = boost::algorithm::to_lower_copy(type.baseName());
+  if (typeName != "bigint_enum" && typeName != "varchar_enum") {
+    return;
+  }
+
+  for (const auto& param : type.parameters()) {
+    const auto paramName = param.baseName();
+
+    auto it = variables().find(paramName);
+    if (it != variables().end() && it->second.isEnumParameter()) {
+      // Generate a random Long/Varchar EnumParameter with a random name and
+      // random values.
+      // TODO: Revisit when implementing custom input generator for enum type,
+      // and when enum_key function is removed from the fuzzer skip list.
+      int numValues = rand32(0, 20);
+      std::string enumName =
+          fmt::format("test.enum.{}{}", paramName, numValues);
+      if (typeName == "bigint_enum" &&
+          longEnumParameterBindings_.find(paramName) ==
+              longEnumParameterBindings_.end()) {
+        std::unordered_map<std::string, int64_t> enumValues;
+        for (int i = 0; i < numValues; i++) {
+          std::string key = fmt::format("VALUE{}", i);
+          enumValues[key] = i;
+        }
+        LongEnumParameter enumParam(enumName, enumValues);
+        longEnumParameterBindings_[paramName] = enumParam;
+      } else if (
+          typeName == "varchar_enum" &&
+          varcharEnumParameterBindings_.find(paramName) ==
+              varcharEnumParameterBindings_.end()) {
+        std::unordered_map<std::string, std::string> enumValues;
+        for (int i = 0; i < numValues; i++) {
+          std::string key = fmt::format("VALUE{}", i);
+          enumValues[key] = key;
+        }
+        VarcharEnumParameter enumParam(enumName, enumValues);
+        varcharEnumParameterBindings_[paramName] = enumParam;
+      }
+    }
+  }
+}
+
 void ArgumentTypeFuzzer::determineUnboundedTypeVariables() {
   for (auto& [variableName, variableInfo] : variables()) {
     if (!variableInfo.isTypeParameter()) {
@@ -180,6 +225,8 @@ bool ArgumentTypeFuzzer::fuzzArgumentTypes(uint32_t maxVariadicArgs) {
 
     bindings_ = binder.bindings();
     integerBindings_ = binder.integerBindings();
+    longEnumParameterBindings_ = binder.longEnumParameterBindings();
+    varcharEnumParameterBindings_ = binder.varcharEnumParameterBindings();
   }
 
   const auto& formalArgs = signature_.argumentTypes();
@@ -188,6 +235,7 @@ bool ArgumentTypeFuzzer::fuzzArgumentTypes(uint32_t maxVariadicArgs) {
   determineUnboundedTypeVariables();
   for (const auto& argType : formalArgs) {
     determineUnboundedIntegerVariables(argType);
+    determineUnboundedEnumVariables(argType);
   }
   for (auto i = 0; i < formalArgsCnt; i++) {
     TypePtr actualArg;
@@ -195,7 +243,12 @@ bool ArgumentTypeFuzzer::fuzzArgumentTypes(uint32_t maxVariadicArgs) {
       actualArg = randType();
     } else {
       actualArg = sanitizeTryResolveType(
-          formalArgs[i], variables(), bindings_, integerBindings_);
+          formalArgs[i],
+          variables(),
+          bindings_,
+          integerBindings_,
+          longEnumParameterBindings_,
+          varcharEnumParameterBindings_);
       VELOX_CHECK(actualArg != nullptr);
     }
     argumentTypes_.push_back(actualArg);
@@ -223,6 +276,7 @@ TypePtr ArgumentTypeFuzzer::fuzzReturnType() {
 
   determineUnboundedTypeVariables();
   determineUnboundedIntegerVariables(signature_.returnType());
+  determineUnboundedEnumVariables(signature_.returnType());
 
   const auto& returnType = signature_.returnType();
 
@@ -230,7 +284,12 @@ TypePtr ArgumentTypeFuzzer::fuzzReturnType() {
     returnType_ = randType();
   } else {
     returnType_ = sanitizeTryResolveType(
-        returnType, variables(), bindings_, integerBindings_);
+        returnType,
+        variables(),
+        bindings_,
+        integerBindings_,
+        longEnumParameterBindings_,
+        varcharEnumParameterBindings_);
   }
 
   VELOX_CHECK_NOT_NULL(returnType_);
diff --git a/velox/expression/fuzzer/ArgumentTypeFuzzer.h b/velox/expression/fuzzer/ArgumentTypeFuzzer.h
index 4b774c1576a4..86072dc1f7e4 100644
--- a/velox/expression/fuzzer/ArgumentTypeFuzzer.h
+++ b/velox/expression/fuzzer/ArgumentTypeFuzzer.h
@@ -81,6 +81,10 @@ class ArgumentTypeFuzzer {
   // Noop if 'type' is not a decimal type signature.
   void determineUnboundedIntegerVariables(const exec::TypeSignature& type);
 
+  // Bind LongEnumParameter variables used in enum type signatures to
+  // randomly generated values if not already bound.
+  void determineUnboundedEnumVariables(const exec::TypeSignature& type);
+
   TypePtr randType();
 
   /// Generates an orderable random type, including structs, and arrays.
@@ -113,6 +117,13 @@ class ArgumentTypeFuzzer {
 
   std::unordered_map<std::string, int> integerBindings_;
 
+  /// Bindings between LongEnumParameter variables and their actual types.
+  std::unordered_map<std::string, LongEnumParameter> longEnumParameterBindings_;
+
+  /// Bindings between VarcharEnumParameter variables and their actual types.
+  std::unordered_map<std::string, VarcharEnumParameter>
+      varcharEnumParameterBindings_;
+
   /// RNG to generate random types for unbounded type variables when necessary.
   FuzzerGenerator& rng_;
 
diff --git a/velox/expression/fuzzer/CMakeLists.txt b/velox/expression/fuzzer/CMakeLists.txt
index f2a950408e81..a4ddb2641a7a 100644
--- a/velox/expression/fuzzer/CMakeLists.txt
+++ b/velox/expression/fuzzer/CMakeLists.txt
@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_library(velox_expression_test_utility ArgumentTypeFuzzer.cpp
-                                          FuzzerToolkit.cpp)
+add_library(velox_expression_test_utility ArgumentTypeFuzzer.cpp FuzzerToolkit.cpp)
 
 target_link_libraries(
   velox_expression_test_utility
@@ -21,7 +20,8 @@ target_link_libraries(
   velox_expression_functions
   velox_fuzzer_util
   velox_presto_types
-  GTest::gtest)
+  GTest::gtest
+)
 
 add_library(
   velox_expression_fuzzer
@@ -31,7 +31,8 @@ add_library(
   ExpressionFuzzer.cpp
   ExpressionFuzzerVerifier.cpp
   FuzzerRunner.cpp
-  SpecialFormSignatureGenerator.cpp)
+  SpecialFormSignatureGenerator.cpp
+)
 
 target_link_libraries(
   velox_expression_fuzzer
@@ -45,7 +46,8 @@ target_link_libraries(
   velox_file
   velox_hive_connector
   velox_fuzzer_util
-  velox_common_fuzzer_util)
+  velox_common_fuzzer_util
+)
 
 add_executable(velox_expression_fuzzer_test ExpressionFuzzerTest.cpp)
 
@@ -56,20 +58,25 @@ target_link_libraries(
   velox_fuzzer_util
   velox_hive_connector
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(
-  spark_expression_fuzzer_test SparkExpressionFuzzerTest.cpp
-                               SparkSpecialFormSignatureGenerator.cpp)
+  spark_expression_fuzzer_test
+  SparkExpressionFuzzerTest.cpp
+  SparkSpecialFormSignatureGenerator.cpp
+)
 
 target_link_libraries(
   spark_expression_fuzzer_test
   velox_expression_fuzzer
+  velox_constrained_input_generators
   velox_fuzzer_util
   velox_hive_connector
   velox_functions_spark
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/expression/fuzzer/ExpressionFuzzer.cpp b/velox/expression/fuzzer/ExpressionFuzzer.cpp
index 7da4c59ce221..10cbccd358c6 100644
--- a/velox/expression/fuzzer/ExpressionFuzzer.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzer.cpp
@@ -329,8 +329,9 @@ ExpressionFuzzer::ExpressionFuzzer(
         }
         atLeastOneSupported = true;
         ++supportedFunctionSignatures;
-        signatureTemplates_.emplace_back(SignatureTemplate{
-            function.first, signature, std::move(typeVariables)});
+        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
@@ -451,6 +452,10 @@ bool ExpressionFuzzer::isSupportedSignature(
   if (usesTypeName(signature, "opaque") ||
       usesTypeName(signature, "interval day to second") ||
       usesTypeName(signature, "ipprefix") ||
+      usesTypeName(
+          signature,
+          "sfmsketch") || // See Issue :
+                          // https://github.com/facebookincubator/velox/issues/14643
       (!options_.enableDecimalType && usesTypeName(signature, "decimal")) ||
       (!options_.enableComplexTypes && useComplexType) ||
       (options_.enableComplexTypes && usesTypeName(signature, "unknown"))) {
@@ -634,8 +639,9 @@ core::TypedExprPtr ExpressionFuzzer::generateArgFunction(const TypePtr& arg) {
   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()));
+    inputs.push_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            args.back(), names.back()));
   }
 
   const auto& returnType = functionType.children().back();
@@ -646,19 +652,16 @@ core::TypedExprPtr ExpressionFuzzer::generateArgFunction(const TypePtr& arg) {
 
   std::vector<std::string> eligible;
   for (const auto& functionName : baseList) {
-    if (auto* signature =
-            findConcreteSignature(args, returnType, functionName)) {
+    if (findConcreteSignature(args, returnType, functionName)) {
       eligible.push_back(functionName);
-    } else if (
-        auto* signatureTemplate =
-            findSignatureTemplate(args, returnType, baseType, functionName)) {
+    } else if (findSignatureTemplate(
+                   args, returnType, baseType, functionName)) {
       eligible.push_back(functionName);
     }
   }
 
   for (const auto& functionName : templateList) {
-    if (auto* signatureTemplate =
-            findSignatureTemplate(args, returnType, baseType, functionName)) {
+    if (findSignatureTemplate(args, returnType, baseType, functionName)) {
       eligible.push_back(functionName);
     }
   }
@@ -1094,8 +1097,8 @@ core::TypedExprPtr ExpressionFuzzer::generateCastExpression(
   markSelected("cast");
 
   // Generate try_cast expression with 50% chance.
-  bool nullOnFailure = vectorFuzzer_->coinToss(0.5);
-  return std::make_shared<core::CastTypedExpr>(returnType, args, nullOnFailure);
+  bool isTryCast = vectorFuzzer_->coinToss(0.5);
+  return std::make_shared<core::CastTypedExpr>(returnType, args, isTryCast);
 }
 
 core::TypedExprPtr ExpressionFuzzer::generateRowConstructorExpression(
diff --git a/velox/expression/fuzzer/ExpressionFuzzerTest.cpp b/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
index 8cf6d76af951..821bd25d78db 100644
--- a/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzerTest.cpp
@@ -28,6 +28,7 @@
 #include "velox/functions/prestosql/fuzzer/ModulusArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/MultiplyArgTypesGenerator.h"
 #include "velox/functions/prestosql/fuzzer/PlusMinusArgTypesGenerator.h"
+
 #include "velox/functions/prestosql/fuzzer/SortArrayTransformer.h"
 #include "velox/functions/prestosql/fuzzer/TruncateArgTypesGenerator.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
@@ -55,18 +56,424 @@ using namespace facebook::velox::exec::test;
 using facebook::velox::exec::test::PrestoQueryRunner;
 using facebook::velox::fuzzer::ArgTypesGenerator;
 using facebook::velox::fuzzer::ArgValuesGenerator;
+using facebook::velox::fuzzer::AtTimezoneArgValuesGenerator;
 using facebook::velox::fuzzer::CastVarcharAndJsonArgValuesGenerator;
 using facebook::velox::fuzzer::ExpressionFuzzer;
 using facebook::velox::fuzzer::FuzzerRunner;
 using facebook::velox::fuzzer::JsonExtractArgValuesGenerator;
 using facebook::velox::fuzzer::JsonParseArgValuesGenerator;
+using facebook::velox::fuzzer::QDigestArgValuesGenerator;
+using facebook::velox::fuzzer::SetDigestArgValuesGenerator;
 using facebook::velox::fuzzer::TDigestArgValuesGenerator;
+using facebook::velox::fuzzer::UnifiedDigestArgValuesGenerator;
+using facebook::velox::fuzzer::URLArgValuesGenerator;
 using facebook::velox::test::ReferenceQueryRunner;
 
+std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>
+    argTypesGenerators = {
+        {"plus", std::make_shared<PlusMinusArgTypesGenerator>()},
+        {"minus", std::make_shared<PlusMinusArgTypesGenerator>()},
+        {"multiply", std::make_shared<MultiplyArgTypesGenerator>()},
+        {"divide", std::make_shared<DivideArgTypesGenerator>()},
+        {"floor", std::make_shared<FloorAndRoundArgTypesGenerator>()},
+        {"round", std::make_shared<FloorAndRoundArgTypesGenerator>()},
+        {"mod", std::make_shared<ModulusArgTypesGenerator>()},
+        {"truncate", std::make_shared<TruncateArgTypesGenerator>()}};
+
+std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>
+    exprTransformers = {
+        {"array_intersect", std::make_shared<SortArrayTransformer>()},
+        {"array_except", std::make_shared<SortArrayTransformer>()},
+        {"array_duplicates", std::make_shared<SortArrayTransformer>()},
+        {"map_entries", std::make_shared<SortArrayTransformer>()},
+        {"map_keys", std::make_shared<SortArrayTransformer>()},
+        {"map_values", std::make_shared<SortArrayTransformer>()}};
+
+std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>
+    argValuesGenerators = {
+        {"at_timezone", std::make_shared<AtTimezoneArgValuesGenerator>()},
+        {"cast", std::make_shared<CastVarcharAndJsonArgValuesGenerator>()},
+        {"json_parse", std::make_shared<JsonParseArgValuesGenerator>()},
+        {"json_extract", std::make_shared<JsonExtractArgValuesGenerator>()},
+        {"scale_tdigest",
+         std::make_shared<TDigestArgValuesGenerator>("scale_tdigest")},
+        {"url_extract_fragment", std::make_shared<URLArgValuesGenerator>()},
+        {"url_extract_host", std::make_shared<URLArgValuesGenerator>()},
+        {"url_extract_parameter", std::make_shared<URLArgValuesGenerator>()},
+        {"url_extract_path", std::make_shared<URLArgValuesGenerator>()},
+        {"url_extract_port", std::make_shared<URLArgValuesGenerator>()},
+        {"url_extract_protocol", std::make_shared<URLArgValuesGenerator>()},
+        {"url_extract_query", std::make_shared<URLArgValuesGenerator>()},
+        {"value_at_quantile",
+         std::make_shared<UnifiedDigestArgValuesGenerator>(
+             "value_at_quantile")},
+        {"values_at_quantiles",
+         std::make_shared<UnifiedDigestArgValuesGenerator>(
+             "values_at_quantiles")},
+        {"scale_qdigest",
+         std::make_shared<QDigestArgValuesGenerator>("scale_qdigest")},
+        {"scale_tdigest",
+         std::make_shared<TDigestArgValuesGenerator>("scale_tdigest")},
+        {"quantile_at_value",
+         std::make_shared<UnifiedDigestArgValuesGenerator>(
+             "quantile_at_value")},
+        {"destructure_tdigest",
+         std::make_shared<TDigestArgValuesGenerator>("destructure_tdigest")},
+        {"trimmed_mean",
+         std::make_shared<TDigestArgValuesGenerator>("trimmed_mean")},
+        {"hash_counts",
+         std::make_shared<SetDigestArgValuesGenerator>("hash_counts")},
+        {"cardinality",
+         std::make_shared<SetDigestArgValuesGenerator>("cardinality")},
+        {"jaccard_index",
+         std::make_shared<SetDigestArgValuesGenerator>("jaccard_index")},
+        {"intersection_cardinality",
+         std::make_shared<SetDigestArgValuesGenerator>(
+             "intersection_cardinality")}};
+
+// 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 = {
+    "noisy_empty_approx_set_sfm", // Non-deterministic because of privacy.
+    "current_timestamp", // Non-deterministic: returns the current timestamp at
+                         // query execution time, so results differ across runs
+    "now", // alias for current_timestamp
+    "merge_sfm", // Fuzzer can generate sketches of different sizes.
+    "element_at",
+    "width_bucket",
+    // Varbinary output can't be compared exactly with Java.
+    "merge_hll",
+    // Fuzzer and the underlying engine are confused about TDigest functions
+    // (since TDigest is a user defined type), and tries to pass a
+    // VARBINARY (since TDigest's implementation uses an
+    // alias to VARBINARY).
+    "value_at_quantile",
+    "values_at_quantiles",
+    "merge_tdigest",
+    "scale_tdigest",
+    "quantiles_at_values",
+    "construct_tdigest",
+    "destructure_tdigest",
+    "trimmed_mean",
+    // Fuzzer and the underlying engine are confused about SetDigest functions
+    // (since KHLL is a user defined type), and tries to pass a
+    // VARBINARY (since KHLL's implementation uses an
+    // alias to VARBINARY).
+    "cardinality(hyperloglog) -> bigint", // Skip HLL version, only test
+                                          // setdigest
+    "cardinality(khyperloglog) -> bigint",
+    "intersection_cardinality(khyperloglog,khyperloglog) -> bigint",
+    "jaccard_index(khyperloglog,khyperloglog) -> double",
+    "reidentification_potential(khyperloglog,bigint) -> double",
+    "uniqueness_distribution(khyperloglog) -> map(bigint,double)",
+    "uniqueness_distribution(khyperloglog,bigint) -> map(bigint,double)",
+    "merge_khll(array(khyperloglog)) -> khyperloglog",
+    // Fuzzer cannot generate valid 'comparator' lambda.
+    "array_sort(array(T),constant function(T,T,bigint)) -> array(T)",
+    "array_sort(array(T),constant function(T,U)) -> array(T)",
+    "array_sort_desc(array(T),constant function(T,U)) -> 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",
+    "map_top_n", // https://github.com/facebookincubator/velox/issues/9497
+    // These can take 2 random int32s and makes an NxM matrix. Naturally this
+    // matrix can be very large taking a long time to populate and OOM'ing the
+    // host.
+    "bootstrap_metrics",
+    "bootstrap_metrics_list",
+    // This function invokes a Boost library function with a known issue where
+    // it hits integer overflows when the arguments are very large.
+    // https://github.com/facebookincubator/velox/issues/11802
+    "inverse_beta_cdf",
+    // https://github.com/facebookincubator/velox/issues/13047
+    "inverse_poisson_cdf",
+    "map_subset", // https://github.com/facebookincubator/velox/issues/12654
+    // JSON not supported, Real doesn't match exactly, etc.
+    "array_join(array(json),varchar) -> varchar",
+    "array_join(array(json),varchar,varchar) -> varchar",
+    "array_join(array(real),varchar) -> varchar",
+    "array_join(array(real),varchar,varchar) -> varchar",
+    "array_join(array(double),varchar) -> varchar",
+    "array_join(array(double),varchar,varchar) -> varchar",
+    // Distance functions
+    "cosine_similarity", // T224131333
+    "l2_squared", // T228562088
+    "dot_product", // T228562088
+    // Geometry functions don't yet have a ValuesGenerator
+    "st_geometryfromtext",
+    "st_geomfrombinary",
+    "st_area",
+    "st_astext",
+    "st_asbinary",
+    "st_boundary",
+    "st_centroid",
+    "st_distance",
+    "st_geometrytype",
+    "st_polygon",
+    "st_isclosed",
+    "st_isempty",
+    "st_length",
+    "st_pointn",
+    "st_isring",
+    "st_relate",
+    "st_contains",
+    "st_crosses",
+    "st_disjoint",
+    "st_equals",
+    "st_intersects",
+    "st_overlaps",
+    "st_touches",
+    "st_within",
+    "st_difference",
+    "st_intersection",
+    "st_symdifference",
+    "st_union",
+    "st_point",
+    "st_points",
+    "st_interiorrings",
+    "st_geometries",
+    "st_x",
+    "st_y",
+    "st_isvalid",
+    "st_issimple",
+    "st_startpoint",
+    "st_endpoint",
+    "st_geometryn",
+    "st_interiorringn",
+    "st_numinteriorring",
+    "st_numpoints",
+    "st_envelopeaspts",
+    "st_numgeometries",
+    "st_convexhull",
+    "st_coorddim",
+    "st_dimension",
+    "st_exteriorring",
+    "st_envelope",
+    "ST_EnvelopeAsPts",
+    "st_buffer",
+    "st_linestring",
+    "st_linefromtext",
+    "st_multipoint",
+    "geometry_invalid_reason",
+    "geometry_nearest_points",
+    "simplify_geometry",
+    "st_xmax",
+    "st_xmin",
+    "st_ymax",
+    "st_ymin",
+    "line_locate_point",
+    "line_interpolate_point",
+    "flatten_geometry_collections",
+    "expand_envelope",
+    "bing_tile_polygon",
+    "geometry_as_geojson",
+    "geometry_from_geojson",
+    "great_circle_distance",
+    "geometry_to_bing_tiles",
+    "geometry_to_dissolved_bing_tiles",
+    "geometry_union",
+    "to_geometry",
+    "to_spherical_geography",
+    "convex_hull_agg",
+    "geometry_union_agg",
+    "localtime",
+};
+
+std::unordered_set<std::string> skipFunctionsSOT = {
+    "t_cdf", // New function, not yet widely deployed in Presto instances
+    "inverse_t_cdf", // New function, not yet widely deployed in Presto
+                     // instances
+    "array_subset", // Velox-only function, not available in Presto
+    "remap_keys", // Velox-only function, not available in Presto
+    "map_intersect", // Velox-only function, not available in Presto
+    "map_keys_overlap", // Velox-only function, not available in Presto
+    "map_append", // Velox-only function, not available in Presto
+    "noisy_empty_approx_set_sfm", // non-deterministic because of privacy.
+    // https://github.com/facebookincubator/velox/issues/11034
+    "cast(real) -> varchar",
+    "cast(row(real)) -> row(varchar)",
+    "cast(double) -> varchar",
+    "cast(row(double)) -> row(varchar)",
+    "cast(array(double)) -> array(varchar)",
+    "cast(array(real)) -> array(varchar)",
+    "cast(map(varchar,double)) -> map(varchar,varchar)",
+    "cast(map(varchar,real)) -> map(varchar,varchar)",
+    // Velox and Presto may not match with regards to sparse vs. dense HLL
+    "cast(hyperloglog) -> p4hyperloglog",
+    "cast(p4hyperloglog) -> hyperloglog",
+    "round", // https://github.com/facebookincubator/velox/issues/10634
+    "bitwise_right_shift_arithmetic", // https://github.com/facebookincubator/velox/issues/10841
+    "map_size_with", // https://github.com/facebookincubator/velox/issues/10964
+    "binomial_cdf", // https://github.com/facebookincubator/velox/issues/10702
+    "inverse_laplace_cdf", // https://github.com/facebookincubator/velox/issues/10699
+    "gamma_cdf", // https://github.com/facebookincubator/velox/issues/10749
+    "inverse_normal_cdf", // https://github.com/facebookincubator/velox/issues/10836
+    "regr_avgx", // https://github.com/facebookincubator/velox/issues/10610
+    "rtrim", // https://github.com/facebookincubator/velox/issues/10973
+    "split", // https://github.com/facebookincubator/velox/issues/10867
+    "array_intersect", // https://github.com/facebookincubator/velox/issues/10740
+    "f_cdf", // https://github.com/facebookincubator/velox/issues/10633
+    "truncate", // https://github.com/facebookincubator/velox/issues/10628
+    "laplace_cdf", // https://github.com/facebookincubator/velox/issues/10974
+    "inverse_beta_cdf", // https://github.com/facebookincubator/velox/issues/11802
+    "conjunct", // https://github.com/facebookincubator/velox/issues/10678
+    "weibull_cdf", // https://github.com/facebookincubator/velox/issues/10977
+    "zip_with", // https://github.com/facebookincubator/velox/issues/10844
+    "bitwise_shift_left", // https://github.com/facebookincubator/velox/issues/10870
+    "split_part", // https://github.com/facebookincubator/velox/issues/10839
+    "bitwise_arithmetic_shift_right", // https://github.com/facebookincubator/velox/issues/10750
+    "date_format", // https://github.com/facebookincubator/velox/issues/10968
+    "substr", // https://github.com/facebookincubator/velox/issues/10660
+    "cauchy_cdf", // https://github.com/facebookincubator/velox/issues/10976
+    "covar_pop", // https://github.com/facebookincubator/velox/issues/10627
+    "lpad", // https://github.com/facebookincubator/velox/issues/10757
+    "format_datetime", // https://github.com/facebookincubator/velox/issues/10779
+    "inverse_cauchy_cdf", // https://github.com/facebookincubator/velox/issues/10840
+    "array_position", // https://github.com/facebookincubator/velox/issues/10580
+    "chi_squared_cdf", // https://github.com/facebookincubator/velox/issues/12327
+    "map_except",
+    "bitwise_left_shift", // https://github.com/facebookincubator/velox/issues/12330
+    "log2", // https://github.com/facebookincubator/velox/issues/12338
+    "bitwise_right_shift", // https://github.com/facebookincubator/velox/issues/12339
+    "word_stem", // https://github.com/facebookincubator/velox/issues/12341
+    "rpad", // https://github.com/facebookincubator/velox/issues/12343
+    "to_ieee754_32", // https://github.com/facebookincubator/velox/issues/12345
+    "beta_cdf", // https://github.com/facebookincubator/velox/issues/12346
+    "wilson_interval_upper", // https://github.com/facebookincubator/velox/issues/12347
+    "to_ieee754_64", // https://github.com/facebookincubator/velox/issues/12372
+    "inverse_weibull_cdf", // https://github.com/facebookincubator/velox/issues/12550
+    "from_utf8", // https://github.com/facebookincubator/velox/issues/12554
+    // https://github.com/facebookincubator/velox/issues/12555
+    "year",
+    "year_of_week",
+    "day_of_year",
+    "week_of_year",
+    "doy",
+    "minute",
+    "quarter",
+    "yow",
+    "day",
+    "day_of_month",
+    "dow",
+    "week",
+    "cast(timestamp) -> varchar", // https://github.com/facebookincubator/velox/issues/12803
+    "from_iso8601_timestamp", // https://github.com/facebookincubator/velox/issues/13605
+    "typeof", // https://github.com/facebookincubator/velox/issues/12804
+    "escape", // https://github.com/facebookincubator/velox/issues/12558
+    "from_base64url", // https://github.com/facebookincubator/velox/issues/12562
+    "array_top_n", // https://github.com/prestodb/presto/issues/24700
+    "array_subset",
+    "codepoint", // https://github.com/facebookincubator/velox/issues/12598
+    "in", // https://github.com/facebookincubator/velox/issues/12597
+    "multimap_from_entries", // https://github.com/facebookincubator/velox/issues/12628
+    "map_zip_with", // https://github.com/facebookincubator/velox/issues/10964
+    "transform_keys", // https://github.com/facebookincubator/velox/issues/12992
+    "arrays_overlap", // https://github.com/facebookincubator/velox/issues/12651
+    "array_normalize", // https://github.com/facebookincubator/velox/issues/12623
+    "array_distinct", // https://github.com/prestodb/presto/issues/24719
+    "power", // https://github.com/facebookincubator/velox/issues/12557
+    "like", // https://github.com/prestodb/presto/issues/24747
+    "slice", // https://github.com/facebookincubator/velox/issues/12782
+    "inverse_gamma_cdf", // https://github.com/facebookincubator/velox/issues/12918
+    "atan2", // T219988962
+    "cosine_similarity", // https://github.com/facebookincubator/velox/issues/12915
+    "l2_squared", // https://github.com/facebookincubator/velox/issues/12915
+    "dot_product", // https://github.com/facebookincubator/velox/issues/12915
+    "subscript", // https://github.com/facebookincubator/velox/issues/12959
+    "reduce", // T220595632
+    "inverse_binomial_cdf", // https://github.com/facebookincubator/velox/issues/12981
+    "inverse_poisson_cdf", // https://github.com/facebookincubator/velox/issues/12982
+    // https://github.com/facebookincubator/velox/issues/13002
+    "ceiling",
+    "ceil",
+    // https://github.com/facebookincubator/velox/issues/13132
+    "normalize",
+    "concat",
+    "trim", // https://github.com/facebookincubator/velox/issues/13176
+    "map_key_exists", // https://github.com/facebookincubator/velox/issues/13190
+    "map_from_entries", // https://github.com/facebookincubator/velox/issues/13191
+    "switch", // https://github.com/prestodb/presto/issues/25077
+    "degrees", // https://github.com/facebookincubator/velox/issues/13608
+    "substring", // T225620908
+    "json_extract", // https://github.com/facebookincubator/velox/issues/12344
+    "to_milliseconds", // https://github.com/prestodb/presto/issues/25275
+    "parse_duration", // https://github.com/prestodb/presto/issues/25340
+    "json_format",
+    "json_array_length", // https://github.com/facebookincubator/velox/issues/13356
+    "is_json_scalar", // https://github.com/facebookincubator/velox/issues/10748
+    "json_size", // https://github.com/facebookincubator/velox/issues/12371
+    "json_extract_scalar", // https://github.com/facebookincubator/velox/issues/10698
+    "json_array_contains", // https://github.com/facebookincubator/velox/issues/13685
+    // https://github.com/facebookincubator/velox/issues/14313
+    "array_intersect",
+    "array_except",
+    "array_duplicates",
+    "map_entries",
+    "map_keys",
+    "map_values",
+    "clamp", // Function clamp not registered
+    "current_date", // Non-deterministic
+    "xxhash64_internal",
+    "combine_hash_internal",
+    "noisy_avg_gaussian", // Non-deterministic
+    "noisy_count_if_gaussian", // Non-deterministic
+    "noisy_count_gaussian", // Non-deterministic
+    "noisy_sum_gaussian", // Non-deterministic
+    "second", // https://github.com/prestodb/presto/pull/25090
+    "inverse_f_cdf", // https://github.com/facebookincubator/velox/issues/13715
+    // https://github.com/facebookincubator/velox/issues/13767
+    "array_max(array(__user_T1)) -> __user_T1",
+    "array_min(array(__user_T1)) -> __user_T1",
+    "inverse_chi_squared_cdf", // https://github.com/facebookincubator/velox/issues/13788
+    "bing_tile_children", // Velox limits the max zoom shift
+                          // https://github.com/facebookincubator/velox/pull/13604
+    "enum_key", // Requires a custom input generator
+    // Not registered
+    "array_sum_propagate_element_null",
+    // Skipping until the new signature is merged and released in Presto:
+    // https://github.com/prestodb/presto/pull/25521
+    "xxhash64(varbinary,bigint) -> varbinary",
+    "map_keys_by_top_n_values", // https://github.com/facebookincubator/velox/issues/14374
+    "$internal$split_to_map",
+    "$internal$canonicalize",
+    "$internal$contains",
+    "localtime", // localtime cannot be called with paranthesis:
+                 // https://github.com/facebookincubator/velox/issues/14937,
+    "jarowinkler_similarity", // https://github.com/facebookincubator/velox/issues/15736
+    // Fuzzer and the underlying engine are confused about SetDigest functions
+    // (since KHLL is a user defined type), and tries to pass a
+    // VARBINARY (since KHLL's implementation uses an
+    // alias to VARBINARY).
+    "cardinality(hyperloglog) -> bigint", // Skip HLL version, only test
+                                          // setdigest
+    // Same with KHyperLogLog functions
+    "cardinality(khyperloglog) -> bigint",
+    "intersection_cardinality(khyperloglog,khyperloglog) -> bigint",
+    "jaccard_index(khyperloglog,khyperloglog) -> double",
+    "reidentification_potential(khyperloglog,bigint) -> double",
+    "uniqueness_distribution(khyperloglog) -> map(bigint,double)",
+    "uniqueness_distribution(khyperloglog,bigint) -> map(bigint,double)",
+    "merge_khll(array(khyperloglog)) -> khyperloglog",
+};
+
 int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
 
   facebook::velox::functions::prestosql::registerAllScalarFunctions();
+  facebook::velox::functions::prestosql::registerInternalFunctions();
 
   // Calls common init functions in the necessary order, initializing
   // singletons, installing proper signal handlers for better debugging
@@ -76,188 +483,16 @@ int main(int argc, char** argv) {
   facebook::velox::memory::MemoryManager::initialize(
       facebook::velox::memory::MemoryManager::Options{});
 
-  // 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 and the underlying engine are confused about TDigest output
-      // (since TDigest is a user defined type), and tries to pass a
-      // VARBINARY (since TDigest's implementation uses an
-      // alias to VARBINARY).
-      "values_at_quantiles",
-      "merge_tdigest",
-      "construct_tdigest",
-      // 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",
-      // JSON not supported, Real doesn't match exactly, etc.
-      "array_join(array(json),varchar) -> varchar",
-      "array_join(array(json),varchar,varchar) -> varchar",
-      "array_join(array(real),varchar) -> varchar",
-      "array_join(array(real),varchar,varchar) -> varchar",
-      "array_join(array(double),varchar) -> varchar",
-      "array_join(array(double),varchar,varchar) -> varchar",
-      // https://github.com/facebookincubator/velox/issues/13047
-      "inverse_poisson_cdf",
-      // Geometry functions don't yet have a ValuesGenerator
-      "st_geometryfromtext",
-      "st_geomfrombinary",
-      "st_area",
-      "st_astext",
-      "st_asbinary",
-      "st_relate",
-      "st_contains",
-      "st_crosses",
-      "st_disjoint",
-      "st_equals",
-      "st_intersects",
-      "st_overlaps",
-      "st_touches",
-      "st_within",
-      "st_difference",
-      "st_intersection",
-      "st_symdifference",
-      "st_union",
-      "st_point",
-      "st_x",
-      "st_y",
-  };
   size_t initialSeed = FLAGS_seed == 0 ? std::time(nullptr) : FLAGS_seed;
 
-  std::unordered_map<std::string, std::shared_ptr<ArgTypesGenerator>>
-      argTypesGenerators = {
-          {"plus", std::make_shared<PlusMinusArgTypesGenerator>()},
-          {"minus", std::make_shared<PlusMinusArgTypesGenerator>()},
-          {"multiply", std::make_shared<MultiplyArgTypesGenerator>()},
-          {"divide", std::make_shared<DivideArgTypesGenerator>()},
-          {"floor", std::make_shared<FloorAndRoundArgTypesGenerator>()},
-          {"round", std::make_shared<FloorAndRoundArgTypesGenerator>()},
-          {"mod", std::make_shared<ModulusArgTypesGenerator>()},
-          {"truncate", std::make_shared<TruncateArgTypesGenerator>()}};
-
-  std::unordered_map<std::string, std::shared_ptr<ExprTransformer>>
-      exprTransformers = {
-          {"array_intersect", std::make_shared<SortArrayTransformer>()},
-          {"array_except", std::make_shared<SortArrayTransformer>()},
-          {"map_keys", std::make_shared<SortArrayTransformer>()},
-          {"map_values", std::make_shared<SortArrayTransformer>()}};
-
-  std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>
-      argValuesGenerators = {
-          {"cast", std::make_shared<CastVarcharAndJsonArgValuesGenerator>()},
-          {"json_parse", std::make_shared<JsonParseArgValuesGenerator>()},
-          {"json_extract", std::make_shared<JsonExtractArgValuesGenerator>()},
-          {"value_at_quantile",
-           std::make_shared<TDigestArgValuesGenerator>("value_at_quantile")},
-          {"scale_tdigest",
-           std::make_shared<TDigestArgValuesGenerator>("scale_tdigest")},
-          {"quantile_at_value",
-           std::make_shared<TDigestArgValuesGenerator>("quantile_at_value")},
-          {"destructure_tdigest",
-           std::make_shared<TDigestArgValuesGenerator>("destructure_tdigest")},
-          {"trimmed_mean",
-           std::make_shared<TDigestArgValuesGenerator>("trimmed_mean")}};
-
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
       facebook::velox::memory::memoryManager()->addRootPool()};
   std::shared_ptr<ReferenceQueryRunner> referenceQueryRunner{nullptr};
+
   if (!FLAGS_presto_url.empty()) {
     // Add additional functions to skip since we are now querying Presto
     // directly and are aware of certain failures.
-    skipFunctions.insert({
-        "cast(real) -> varchar", // https://github.com/facebookincubator/velox/issues/11034
-        "round", // https://github.com/facebookincubator/velox/issues/10634
-        "json_size", // https://github.com/facebookincubator/velox/issues/10700
-        "bitwise_right_shift_arithmetic", // https://github.com/facebookincubator/velox/issues/10841
-        "map_size_with", // https://github.com/facebookincubator/velox/issues/10964
-        "binomial_cdf", // https://github.com/facebookincubator/velox/issues/10702
-        "inverse_laplace_cdf", // https://github.com/facebookincubator/velox/issues/10699
-        "gamma_cdf", // https://github.com/facebookincubator/velox/issues/10749
-        "inverse_normal_cdf", // https://github.com/facebookincubator/velox/issues/10836
-        "regr_avgx", // https://github.com/facebookincubator/velox/issues/10610
-        "is_json_scalar", // https://github.com/facebookincubator/velox/issues/10748
-        "json_extract_scalar", // https://github.com/facebookincubator/velox/issues/10698
-        "rtrim", // https://github.com/facebookincubator/velox/issues/10973
-        "split", // https://github.com/facebookincubator/velox/issues/10867
-        "array_intersect", // https://github.com/facebookincubator/velox/issues/10740
-        "f_cdf", // https://github.com/facebookincubator/velox/issues/10633
-        "truncate", // https://github.com/facebookincubator/velox/issues/10628
-        "url_extract_query", // https://github.com/facebookincubator/velox/issues/10659
-        "laplace_cdf", // https://github.com/facebookincubator/velox/issues/10974
-        "inverse_beta_cdf", // https://github.com/facebookincubator/velox/issues/11802
-        "conjunct", // https://github.com/facebookincubator/velox/issues/10678
-        "url_extract_host", // https://github.com/facebookincubator/velox/issues/10578
-        "weibull_cdf", // https://github.com/facebookincubator/velox/issues/10977
-        "zip_with", // https://github.com/facebookincubator/velox/issues/10844
-        "url_extract_path", // https://github.com/facebookincubator/velox/issues/10579
-        "bitwise_shift_left", // https://github.com/facebookincubator/velox/issues/10870
-        "split_part", // https://github.com/facebookincubator/velox/issues/10839
-        "bitwise_arithmetic_shift_right", // https://github.com/facebookincubator/velox/issues/10750
-        "date_format", // https://github.com/facebookincubator/velox/issues/10968
-        "substr", // https://github.com/facebookincubator/velox/issues/10660
-        "cauchy_cdf", // https://github.com/facebookincubator/velox/issues/10976
-        "covar_pop", // https://github.com/facebookincubator/velox/issues/10627
-        "lpad", // https://github.com/facebookincubator/velox/issues/10757
-        "format_datetime", // https://github.com/facebookincubator/velox/issues/10779
-        "inverse_cauchy_cdf", // https://github.com/facebookincubator/velox/issues/10840
-        "array_position", // https://github.com/facebookincubator/velox/issues/10580
-        "url_extract_fragment", // https://github.com/facebookincubator/velox/issues/12324
-        "url_extract_protocol", // https://github.com/facebookincubator/velox/issues/12325
-        "chi_squared_cdf", // https://github.com/facebookincubator/velox/issues/12327
-        "bitwise_left_shift", // https://github.com/facebookincubator/velox/issues/12330
-        "log2", // https://github.com/facebookincubator/velox/issues/12338
-        "bitwise_right_shift", // https://github.com/facebookincubator/velox/issues/12339
-        "word_stem", // https://github.com/facebookincubator/velox/issues/12341
-        "rpad", // https://github.com/facebookincubator/velox/issues/12343
-        "json_extract", // https://github.com/facebookincubator/velox/issues/12344
-        "to_ieee754_32", // https://github.com/facebookincubator/velox/issues/12345
-        "beta_cdf", // https://github.com/facebookincubator/velox/issues/12346
-        "wilson_interval_upper", // https://github.com/facebookincubator/velox/issues/12347
-        "json_parse", // https://github.com/facebookincubator/velox/issues/12371
-        "to_ieee754_64", // https://github.com/facebookincubator/velox/issues/12372
-        // No default Hive type provided for unsupported Hive type: json
-        "json_format",
-        "json_array_length",
-        "json_array_get",
-        "json_array_contains",
-        "clamp", // Function clamp not registered
-        "current_date", // Non-deterministic
-        "xxhash64_internal",
-        "combine_hash_internal",
-        "map_keys_by_top_n_values", // requires
-                                    // https://github.com/prestodb/presto/pull/24570
-        "inverse_gamma_cdf", // https://github.com/facebookincubator/velox/issues/12918
-        "inverse_binomial_cdf", // https://github.com/facebookincubator/velox/issues/12981
-        "inverse_poisson_cdf", // https://github.com/facebookincubator/velox/issues/12982
-    });
+    skipFunctions.insert(skipFunctionsSOT.begin(), skipFunctionsSOT.end());
 
     referenceQueryRunner = std::make_shared<PrestoQueryRunner>(
         rootPool.get(),
diff --git a/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp b/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
index acfb0200ab4b..95147f3d80bf 100644
--- a/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
+++ b/velox/expression/fuzzer/ExpressionFuzzerVerifier.cpp
@@ -62,9 +62,10 @@ ExpressionFuzzerVerifier::ExpressionFuzzerVerifier(
     const std::unordered_map<std::string, std::shared_ptr<ArgValuesGenerator>>&
         argValuesGenerators)
     : options_(options),
-      queryCtx_(core::QueryCtx::create(
-          nullptr,
-          core::QueryConfig(options_.queryConfigs))),
+      queryCtx_(
+          core::QueryCtx::create(
+              nullptr,
+              core::QueryConfig(options_.queryConfigs))),
       execCtx_({pool_.get(), queryCtx_.get()}),
       verifier_(
           &execCtx_,
@@ -72,9 +73,10 @@ ExpressionFuzzerVerifier::ExpressionFuzzerVerifier(
            options_.reproPersistPath,
            options_.persistAndRunOnce},
           options_.expressionFuzzerOptions.referenceQueryRunner),
-      vectorFuzzer_(std::make_shared<VectorFuzzer>(
-          options_.vectorFuzzerOptions,
-          execCtx_.pool())),
+      vectorFuzzer_(
+          std::make_shared<VectorFuzzer>(
+              options_.vectorFuzzerOptions,
+              execCtx_.pool())),
       expressionFuzzer_(
           signatureMap,
           initialSeed,
@@ -86,8 +88,6 @@ ExpressionFuzzerVerifier::ExpressionFuzzerVerifier(
           options_.expressionFuzzerOptions.referenceQueryRunner} {
   parse::registerTypeResolver();
   filesystems::registerLocalFileSystem();
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
   exec::test::registerHiveConnector({});
   dwrf::registerDwrfWriterFactory();
 
@@ -290,8 +290,8 @@ void ExpressionFuzzerVerifier::retryWithTry(
   // 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"));
+    tryPlans.push_back(
+        std::make_shared<core::CallTypedExpr>(plan->type(), "try", plan));
   }
 
   std::vector<ResultOrError> tryResults;
diff --git a/velox/expression/fuzzer/FuzzerRunner.cpp b/velox/expression/fuzzer/FuzzerRunner.cpp
index bc00c4fc5040..ece25c8930d8 100644
--- a/velox/expression/fuzzer/FuzzerRunner.cpp
+++ b/velox/expression/fuzzer/FuzzerRunner.cpp
@@ -171,6 +171,7 @@ VectorFuzzer::Options getVectorFuzzerOptions() {
   opts.stringVariableLength = true;
   opts.stringLength = 100;
   opts.nullRatio = FLAGS_null_ratio;
+  opts.useRandomNullPattern = true;
   opts.timestampPrecision =
       VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
   return opts;
diff --git a/velox/expression/fuzzer/FuzzerToolkit.h b/velox/expression/fuzzer/FuzzerToolkit.h
index e24ebabcfcd0..26e5d4f67461 100644
--- a/velox/expression/fuzzer/FuzzerToolkit.h
+++ b/velox/expression/fuzzer/FuzzerToolkit.h
@@ -87,7 +87,7 @@ SignatureMapType filterSignatures(
   SignatureMapType output;
   if (!onlyFunctions.empty()) {
     // Parse, lower case and trim it.
-    std::vector<folly::StringPiece> nameList;
+    std::vector<std::string_view> nameList;
     folly::split(',', onlyFunctions, nameList);
     std::unordered_set<std::string> nameSet;
     for (const auto& it : nameList) {
diff --git a/velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.cpp b/velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.cpp
index 0c1cef30722a..62b2e0edf854 100644
--- a/velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.cpp
+++ b/velox/expression/fuzzer/SparkSpecialFormSignatureGenerator.cpp
@@ -20,7 +20,7 @@ namespace facebook::velox::fuzzer {
 std::vector<exec::FunctionSignaturePtr>
 SparkSpecialFormSignatureGenerator::getSignaturesForCast() const {
   std::vector<exec::FunctionSignaturePtr> signatures =
-      SpecialFormSignatureGenerator::getSignaturesForCast();
+      getCommonSignaturesForCast();
 
   // Cast tinyint/smallint/integer/bigint as varbinary is supported in Spark.
   for (auto fromType : {"tinyint", "smallint", "integer", "bigint"}) {
@@ -31,6 +31,24 @@ SparkSpecialFormSignatureGenerator::getSignaturesForCast() const {
   for (auto fromType : {"tinyint", "smallint", "integer", "bigint"}) {
     signatures.push_back(makeCastSignature(fromType, "timestamp"));
   }
+
+  // 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;
 }
 
diff --git a/velox/expression/fuzzer/SpecialFormSignatureGenerator.cpp b/velox/expression/fuzzer/SpecialFormSignatureGenerator.cpp
index 0428e613422f..06c643f3ddfb 100644
--- a/velox/expression/fuzzer/SpecialFormSignatureGenerator.cpp
+++ b/velox/expression/fuzzer/SpecialFormSignatureGenerator.cpp
@@ -63,6 +63,12 @@ void SpecialFormSignatureGenerator::addCastFromTimestampSignature(
   signatures.push_back(makeCastSignature("timestamp", toType));
 }
 
+void SpecialFormSignatureGenerator::addCastFromTimeSignature(
+    const std::string& toType,
+    std::vector<exec::FunctionSignaturePtr>& signatures) const {
+  signatures.push_back(makeCastSignature("time", toType));
+}
+
 void SpecialFormSignatureGenerator::addCastFromDateSignature(
     const std::string& toType,
     std::vector<exec::FunctionSignaturePtr>& signatures) const {
@@ -156,7 +162,7 @@ SpecialFormSignatureGenerator::getSignaturesForSwitch() const {
 }
 
 std::vector<exec::FunctionSignaturePtr>
-SpecialFormSignatureGenerator::getSignaturesForCast() const {
+SpecialFormSignatureGenerator::getCommonSignaturesForCast() const {
   std::vector<exec::FunctionSignaturePtr> signatures;
 
   // To integral types.
@@ -179,15 +185,31 @@ SpecialFormSignatureGenerator::getSignaturesForCast() const {
   addCastFromVarcharSignature("varchar", signatures);
   addCastFromDateSignature("varchar", signatures);
   addCastFromTimestampSignature("varchar", signatures);
+  addCastFromTimeSignature("varchar", signatures);
 
   // To timestamp type.
   addCastFromVarcharSignature("timestamp", signatures);
   addCastFromDateSignature("timestamp", signatures);
 
+  // To time type.
+  addCastFromVarcharSignature("time", signatures);
+
   // To date type.
   addCastFromVarcharSignature("date", signatures);
   addCastFromTimestampSignature("date", signatures);
 
+  return signatures;
+}
+
+std::vector<exec::FunctionSignaturePtr>
+SpecialFormSignatureGenerator::getSignaturesForCast() const {
+  std::vector<exec::FunctionSignaturePtr> signatures =
+      getCommonSignaturesForCast();
+
+  // P4HyperLogLog <-> HyperLogLog casts
+  signatures.push_back(makeCastSignature("hyperloglog", "p4hyperloglog"));
+  signatures.push_back(makeCastSignature("p4hyperloglog", "hyperloglog"));
+
   // 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();
diff --git a/velox/expression/fuzzer/SpecialFormSignatureGenerator.h b/velox/expression/fuzzer/SpecialFormSignatureGenerator.h
index 2b986872c77e..f567f25bc5fb 100644
--- a/velox/expression/fuzzer/SpecialFormSignatureGenerator.h
+++ b/velox/expression/fuzzer/SpecialFormSignatureGenerator.h
@@ -57,6 +57,12 @@ class SpecialFormSignatureGenerator {
       const std::string& toType,
       std::vector<exec::FunctionSignaturePtr>& signatures) const;
 
+  /// Generates signatures for cast from time to the given type and adds
+  /// them to signatures.
+  void addCastFromTimeSignature(
+      const std::string& toType,
+      std::vector<exec::FunctionSignaturePtr>& signatures) const;
+
   /// Generates signatures for cast from date to the given type and adds them to
   /// signatures.
   void addCastFromDateSignature(
@@ -85,6 +91,9 @@ class SpecialFormSignatureGenerator {
   virtual std::vector<exec::FunctionSignaturePtr> getSignaturesForSwitch()
       const;
 
+  // Returns the common signatures for the 'cast' special form.
+  std::vector<exec::FunctionSignaturePtr> getCommonSignaturesForCast() const;
+
   // Returns the signatures for the 'cast' special form.
   virtual std::vector<exec::FunctionSignaturePtr> getSignaturesForCast() const;
 
diff --git a/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp b/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp
index c89240f874ef..eaaf62c81669 100644
--- a/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp
+++ b/velox/expression/fuzzer/tests/ArgumentTypeFuzzerTest.cpp
@@ -18,7 +18,10 @@
 
 #include <gtest/gtest.h>
 
-#include "velox/expression/SignatureBinder.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/TDigestRegistration.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 #include "velox/type/Type.h"
@@ -714,4 +717,41 @@ TEST_F(ArgumentTypeFuzzerTest, tdigestType) {
   testFuzzingSuccess(signature, TDIGEST(DOUBLE()), {DOUBLE()});
 }
 
+TEST_F(ArgumentTypeFuzzerTest, qdigestType) {
+  registerQDigestType();
+  auto signature = exec::FunctionSignatureBuilder()
+                       .returnType("qdigest(DOUBLE)")
+                       .argumentType("double")
+                       .build();
+  testFuzzingSuccess(signature, QDIGEST(DOUBLE()), {DOUBLE()});
+
+  signature = exec::FunctionSignatureBuilder()
+                  .returnType("qdigest(BIGINT)")
+                  .argumentType("double")
+                  .build();
+  testFuzzingSuccess(signature, QDIGEST(BIGINT()), {DOUBLE()});
+
+  signature = exec::FunctionSignatureBuilder()
+                  .returnType("qdigest(REAL)")
+                  .argumentType("double")
+                  .build();
+  testFuzzingSuccess(signature, QDIGEST(REAL()), {DOUBLE()});
+}
+
+TEST_F(ArgumentTypeFuzzerTest, setdigestType) {
+  registerSetDigestType();
+  auto signature = exec::FunctionSignatureBuilder()
+                       .returnType("setdigest")
+                       .argumentType("bigint")
+                       .build();
+  testFuzzingSuccess(signature, SETDIGEST(), {BIGINT()});
+
+  signature = exec::FunctionSignatureBuilder()
+                  .returnType("setdigest")
+                  .argumentType("varchar")
+                  .build();
+  testFuzzingSuccess(signature, SETDIGEST(), {VARCHAR()});
+  testFuzzingSuccess(signature, SETDIGEST(), {VARCHAR()});
+}
+
 } // namespace facebook::velox::fuzzer::test
diff --git a/velox/expression/fuzzer/tests/CMakeLists.txt b/velox/expression/fuzzer/tests/CMakeLists.txt
index f352a7375e0a..eed2e9ff3297 100644
--- a/velox/expression/fuzzer/tests/CMakeLists.txt
+++ b/velox/expression/fuzzer/tests/CMakeLists.txt
@@ -14,13 +14,18 @@
 
 add_library(velox_expression_fuzzer_test_utility ArgTypesGeneratorTestUtils.cpp)
 target_link_libraries(
-  velox_expression_fuzzer_test_utility velox_expression_functions
-  velox_function_registry GTest::gtest)
+  velox_expression_fuzzer_test_utility
+  velox_expression_functions
+  velox_function_registry
+  GTest::gtest
+)
 
 add_executable(
   velox_expression_fuzzer_unit_test
-  ArgumentTypeFuzzerTest.cpp DecimalArgTypesGeneratorTest.cpp
-  ExpressionFuzzerUnitTest.cpp)
+  ArgumentTypeFuzzerTest.cpp
+  DecimalArgTypesGeneratorTest.cpp
+  ExpressionFuzzerUnitTest.cpp
+)
 
 target_link_libraries(
   velox_expression_fuzzer_unit_test
@@ -31,4 +36,5 @@ target_link_libraries(
   velox_expression
   velox_expression_fuzzer_test_utility
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp b/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
index 2d5890aaa6b9..12240cf813f4 100644
--- a/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
+++ b/velox/expression/fuzzer/tests/ExpressionFuzzerUnitTest.cpp
@@ -18,6 +18,10 @@
 
 #include "velox/expression/fuzzer/ExpressionFuzzer.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/TDigestRegistration.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 
@@ -26,6 +30,8 @@ class ExpressionFuzzerUnitTest : public testing::Test {
  protected:
   static void SetUpTestCase() {
     registerTDigestType();
+    registerQDigestType();
+    registerSetDigestType();
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
@@ -54,7 +60,11 @@ class ExpressionFuzzerUnitTest : public testing::Test {
         TIMESTAMP(),
         DATE(),
         INTERVAL_DAY_TIME(),
-        TDIGEST(DOUBLE())};
+        TDIGEST(DOUBLE()),
+        QDIGEST(DOUBLE()),
+        QDIGEST(BIGINT()),
+        QDIGEST(REAL()),
+        SETDIGEST()};
     auto index = folly::Random::rand32(kSupportedTypes.size(), seed);
     return kSupportedTypes[index];
   }
diff --git a/velox/expression/signature_parser/CMakeLists.txt b/velox/expression/signature_parser/CMakeLists.txt
index 0627986c9879..58377ba206d6 100644
--- a/velox/expression/signature_parser/CMakeLists.txt
+++ b/velox/expression/signature_parser/CMakeLists.txt
@@ -17,26 +17,36 @@ if(${VELOX_BUILD_TESTING})
 endif()
 
 bison_target(
-  SignatureParser SignatureParser.yy
+  SignatureParser
+  SignatureParser.yy
   ${CMAKE_CURRENT_BINARY_DIR}/SignatureParser.yy.cc
   DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/SignatureParser.yy.h
-  COMPILE_FLAGS "-Werror -Wno-deprecated")
+  COMPILE_FLAGS "-Werror -Wno-deprecated"
+)
 
 flex_target(
-  SignatureParserScanner SignatureParser.ll
-  ${CMAKE_CURRENT_BINARY_DIR}/Scanner.cpp COMPILE_FLAGS "-Cf --prefix=veloxsp")
+  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})
+    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_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/Scanner.h b/velox/expression/signature_parser/Scanner.h
index 9733cf079c3e..f7cf41f3dec4 100644
--- a/velox/expression/signature_parser/Scanner.h
+++ b/velox/expression/signature_parser/Scanner.h
@@ -36,6 +36,9 @@ class Scanner : public yyFlexLexer {
       : yyFlexLexer(&arg_yyin, &arg_yyout),
         outputType_(outputType),
         input_(input) {}
+
+  ~Scanner() = default;
+
   int lex(Parser::semantic_type* yylval);
 
   void setTypeSignature(TypeSignaturePtr type) {
diff --git a/velox/expression/signature_parser/SignatureParser.ll b/velox/expression/signature_parser/SignatureParser.ll
index d11063122865..17950877f4d0 100644
--- a/velox/expression/signature_parser/SignatureParser.ll
+++ b/velox/expression/signature_parser/SignatureParser.ll
@@ -1,3 +1,4 @@
+%option 8bit
 %{
 #include <vector>
 #include <memory>
@@ -5,9 +6,33 @@
 #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)
+
+std::string unescape_doublequote(const char* yytext) {
+    size_t len = strlen(yytext);
+    std::string output;
+    output.resize(len);
+
+    int i = 0;
+    int j = 0;
+
+    while (i < len - 1) {
+        if (yytext[i] == '"' && yytext[i+1] == '"') {
+            output[j++] = '"';
+            i += 2;
+        } else {
+            output[j++] = yytext[i++];
+        }
+    }
+    // Check if the last character needs to be added.
+    if (i < len) {
+       output[j++] = yytext[i++];
+    }
+    output.resize(j);
+    return output;
+}
 %}
 
-%option c++ noyywrap noyylineno nodefault caseless
+%option c++ noyywrap noyylineno nodefault caseless 8bit
 
 A   [A|a]
 B   [B|b]
@@ -34,7 +59,7 @@ Y   [Y|y]
 Z   [Z|z]
 
 WORD              ([[:alnum:]_]*)
-QUOTED_ID         (['"'][[:alnum:][:space:]_]*['"'])
+QUOTED_ID         (\"([^\"\n]|\"\")*\")
 ROW               (ROW|STRUCT)
 
 %%
@@ -42,13 +67,14 @@ ROW               (ROW|STRUCT)
 "("                return Parser::token::LPAREN;
 ")"                return Parser::token::RPAREN;
 ","                return Parser::token::COMMA;
+"..."              return Parser::token::ELLIPSIS;
 (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;
+{QUOTED_ID}        {auto val = unescape_doublequote(YYText()); yylval->build<std::string>(val.c_str()); return Parser::token::QUOTED_ID;}
 <<EOF>>            return Parser::token::YYEOF;
 .               /* no action on unmatched input */
 
diff --git a/velox/expression/signature_parser/SignatureParser.yy b/velox/expression/signature_parser/SignatureParser.yy
index 5453d2fc7943..c79067e96ce3 100644
--- a/velox/expression/signature_parser/SignatureParser.yy
+++ b/velox/expression/signature_parser/SignatureParser.yy
@@ -27,13 +27,15 @@
     #define yylex(x) scanner->lex(x)
 }
 
-%token               LPAREN RPAREN COMMA ARRAY MAP ROW FUNCTION
+%token               LPAREN RPAREN COMMA ARRAY MAP ROW FUNCTION ELLIPSIS
 %token <std::string> WORD VARIABLE QUOTED_ID DECIMAL
 %token YYEOF         0
 
+%expect 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::shared_ptr<exec::TypeSignature>> type named_type row_field
+%nterm <std::vector<exec::TypeSignature>> type_list row_field_list
 %nterm <std::vector<std::string>> type_with_spaces
 
 %%
@@ -71,14 +73,24 @@ 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_field : named_type { $$ = $1; }
+          | type       { $$ = $1; }
+          ;
 
-row_type : ROW LPAREN type_list_opt_names RPAREN  { $$ = std::make_shared<exec::TypeSignature>("row", $3); }
-         ;
+row_field_list : row_field { $$.push_back(*($1)); }
+               | row_field_list COMMA row_field { $1.push_back(*($3)); $$ = std::move($1); }
+               ;
+
+row_type
+    : ROW LPAREN row_field RPAREN
+        { std::vector<exec::TypeSignature> params; params.push_back(*($3)); $$ = std::make_shared<exec::TypeSignature>("row", params); }
+    | ROW LPAREN row_field COMMA ELLIPSIS RPAREN
+        { if ($3->rowFieldName().has_value()) { VELOX_FAIL("Homogeneous row cannot have a field name"); } std::vector<exec::TypeSignature> params; params.push_back(*($3)); $$ = std::make_shared<exec::TypeSignature>("row", params, std::nullopt, true); }
+    | ROW LPAREN row_field COMMA row_field_list RPAREN
+        { std::vector<exec::TypeSignature> params; params.push_back(*($3)); for (auto& f : $5) { params.push_back(f); } $$ = std::make_shared<exec::TypeSignature>("row", params); }
+    ;
+
+// Homogeneous rows use only the explicit pattern: row(T, ...)
 
 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) })); }
diff --git a/velox/expression/signature_parser/tests/CMakeLists.txt b/velox/expression/signature_parser/tests/CMakeLists.txt
index 7d02765ee26b..1ad3391b1eb8 100644
--- a/velox/expression/signature_parser/tests/CMakeLists.txt
+++ b/velox/expression/signature_parser/tests/CMakeLists.txt
@@ -22,4 +22,5 @@ target_link_libraries(
   velox_type_signature
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
diff --git a/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp b/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp
index daa0d8545269..0de3f5f9bf0e 100644
--- a/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp
+++ b/velox/expression/signature_parser/tests/ParseTypeSignatureTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include <gtest/gtest.h>
-
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/signature_parser/SignatureParser.h"
 
 using namespace facebook::velox::exec;
@@ -52,9 +52,9 @@ static const TypePtr& TIMESTAMP_WITH_TIME_ZONE() {
   return instance;
 }
 
-class TypeFactories : public CustomTypeFactories {
+class TypeFactory : public CustomTypeFactory {
  public:
-  TypeFactories(const TypePtr& type) : type_(type) {}
+  TypeFactory(const TypePtr& type) : type_(type) {}
 
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -78,10 +78,10 @@ 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("json", std::make_unique<const TypeFactory>(JSON()));
     registerCustomType(
         "timestamp with time zone",
-        std::make_unique<const TypeFactories>(TIMESTAMP_WITH_TIME_ZONE()));
+        std::make_unique<const TypeFactory>(TIMESTAMP_WITH_TIME_ZONE()));
   }
 };
 
@@ -191,7 +191,7 @@ TEST_F(ParseTypeSignatureTest, row) {
     ASSERT_EQ(signature.parameters().size(), 1);
   }
 
-  // test quoted row fields.
+  // Test quoted row fields.
   {
     auto signature = parseTypeSignature("row(\"12col0\" v, l)");
     ASSERT_EQ(signature.baseName(), "row");
@@ -230,6 +230,82 @@ TEST_F(ParseTypeSignatureTest, row) {
     ASSERT_EQ(rowfield.rowFieldName(), "bla");
     ASSERT_EQ(rowfield.parameters().size(), 0);
   }
+
+  {
+    auto signature = parseTypeSignature("row(\"a (b)\" INTEGER)");
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 1);
+    auto field0 = signature.parameters()[0];
+    ASSERT_EQ(field0.baseName(), "INTEGER");
+    ASSERT_EQ(field0.rowFieldName(), "a (b)");
+  }
+
+  // Test double double quote escape
+  {
+    auto signature = parseTypeSignature(
+        "row(\"a\"\"b\" INTEGER, \"\"\"ab\" INTEGER, \"ab\"\"\"\"\" INTEGER)");
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 3);
+    auto field0 = signature.parameters()[0];
+    ASSERT_EQ(field0.baseName(), "INTEGER");
+    ASSERT_EQ(field0.rowFieldName(), "a\"b");
+    auto field1 = signature.parameters()[1];
+    ASSERT_EQ(field1.baseName(), "INTEGER");
+    ASSERT_EQ(field1.rowFieldName(), "\"ab");
+    auto field2 = signature.parameters()[2];
+    ASSERT_EQ(field2.baseName(), "INTEGER");
+    ASSERT_EQ(field2.rowFieldName(), "ab\"\"");
+  }
+
+  // Single double quote is an error.
+  EXPECT_THROW(parseTypeSignature("row(\"a\"b\" INTEGER)"), VeloxRuntimeError);
+}
+
+TEST_F(ParseTypeSignatureTest, homogeneousRow) {
+  {
+    auto signature = parseTypeSignature("row(varchar, ...)");
+    ASSERT_TRUE(signature.isHomogeneousRow());
+    ASSERT_EQ(signature.toString(), "row(varchar, ...)");
+
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 1);
+    auto field = signature.parameters()[0];
+    ASSERT_EQ(field.baseName(), "varchar");
+    ASSERT_FALSE(field.variableArity());
+  }
+
+  {
+    auto signature = parseTypeSignature("row(T, ...)");
+    ASSERT_TRUE(signature.isHomogeneousRow());
+    ASSERT_EQ(signature.toString(), "row(T, ...)");
+
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 1);
+    auto field = signature.parameters()[0];
+    ASSERT_EQ(field.baseName(), "T");
+    ASSERT_FALSE(field.variableArity());
+  }
+
+  {
+    auto signature = parseTypeSignature("row(array(bigint), ...)");
+    ASSERT_TRUE(signature.isHomogeneousRow());
+    ASSERT_EQ(signature.toString(), "row(array(bigint), ...)");
+
+    ASSERT_EQ(signature.baseName(), "row");
+    ASSERT_EQ(signature.parameters().size(), 1);
+    auto field = signature.parameters()[0];
+    ASSERT_EQ(field.baseName(), "array");
+    ASSERT_FALSE(field.variableArity());
+  }
+
+  VELOX_ASSERT_RUNTIME_THROW(
+      parseTypeSignature("row(integer, boolean, ...)"),
+      "Failed to parse type signature [row(integer, boolean, ...)]: syntax error, unexpected ELLIPSIS");
+
+  // Homogeneous row with named field is not allowed.
+  VELOX_ASSERT_RUNTIME_THROW(
+      parseTypeSignature("row(name varchar, ...)"),
+      "Homogeneous row cannot have a field name");
 }
 
 TEST_F(ParseTypeSignatureTest, tdigest) {
@@ -252,10 +328,15 @@ TEST_F(ParseTypeSignatureTest, roundTrip) {
 
   ASSERT_EQ(roundTrip("function(S,R)"), "function(S,R)");
 
-  // Test a complex type as the second field in a row
+  // 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 homogeneous row round-trip parsing.
+  ASSERT_EQ(roundTrip("row(T, ...)"), "row(T, ...)");
+  ASSERT_EQ(roundTrip("row(varchar, ...)"), "row(varchar, ...)");
+  ASSERT_EQ(roundTrip("row(bigint, ...)"), "row(bigint, ...)");
 }
 
 TEST_F(ParseTypeSignatureTest, invalidSignatures) {
diff --git a/velox/expression/tests/ArrayViewTest.cpp b/velox/expression/tests/ArrayViewTest.cpp
index 27e6e9781d94..2ee9d67de651 100644
--- a/velox/expression/tests/ArrayViewTest.cpp
+++ b/velox/expression/tests/ArrayViewTest.cpp
@@ -494,7 +494,7 @@ TEST_F(NullFreeArrayViewTest, materialize) {
 
 TEST_F(NullableArrayViewTest, materialize) {
   auto result = evaluate(
-      "array_constructor(1, 2, NULL, 4, NULL)",
+      "array_constructor(1, 2, null::bigint, 4, null::bigint)",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -508,7 +508,7 @@ TEST_F(NullableArrayViewTest, materialize) {
 
 TEST_F(NullableArrayViewTest, materializeNested) {
   auto result = evaluate(
-      "array_constructor(array_constructor(1), array_constructor(1, NULL), NULL)",
+      "array_constructor(array_constructor(1), array_constructor(1, null::bigint), null::bigint[])",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -534,7 +534,7 @@ TEST_F(NullableArrayViewTest, materializeArrayWithOpaque) {
   registerFunction<MakeOpaqueFunc, std::shared_ptr<int64_t>>({"make_opaque"});
 
   auto result = evaluate(
-      "array_constructor(make_opaque(), null)",
+      "array_constructor(make_opaque(), null::\"OPAQUE<void>\")",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -579,7 +579,7 @@ TEST_F(NullableArrayViewTest, materializeArrayOfCustomTypes) {
   registerFunction<MakeUDTFunc, UDTTypeRegistrar::SimpleType>({"make_udt"});
 
   auto result = evaluate(
-      "array_constructor(make_udt(), null, make_udt(), make_udt())",
+      "array_constructor(make_udt(), null::materializeTestUDT, make_udt(), make_udt())",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
diff --git a/velox/expression/tests/ArrayWriterTest.cpp b/velox/expression/tests/ArrayWriterTest.cpp
index f62f5fbdf5dd..3594b7d02e83 100644
--- a/velox/expression/tests/ArrayWriterTest.cpp
+++ b/velox/expression/tests/ArrayWriterTest.cpp
@@ -20,7 +20,9 @@
 #include <cstdint>
 #include <memory>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/OptionalEmpty.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/expression/VectorWriters.h"
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
@@ -122,6 +124,12 @@ class ArrayWriterTest : public functions::test::FunctionBaseTest {
     writer.writer->setOffset(0);
     return writer;
   }
+
+ protected:
+  static void SetUpTestCase() {
+    FunctionBaseTest::SetUpTestCase();
+    common::testutil::TestValue::enable();
+  }
 };
 
 TEST_F(ArrayWriterTest, addNull) {
@@ -681,7 +689,7 @@ TEST_F(ArrayWriterTest, copyFromNullableArrayView) {
       {"copy_from_nullable"});
 
   auto result = evaluate(
-      "copy_from_nullable(array_constructor(1, null, 3, null, 5))",
+      "copy_from_nullable(array_constructor(1, null::bigint, 3, null::bigint, 5))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   // Test results.
@@ -704,7 +712,7 @@ TEST_F(ArrayWriterTest, copyFromNestedNullableArrayView) {
       Array<Array<int64_t>>>({"copy_from_nullable_nested"});
 
   auto result = evaluate(
-      "copy_from_nullable_nested(array_constructor(array_constructor(1), array_constructor(3, null, 5)))",
+      "copy_from_nullable_nested(array_constructor(array_constructor(1), array_constructor(3, null::bigint, 5)))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   // Test results.
@@ -761,7 +769,7 @@ TEST_F(ArrayWriterTest, addItems) {
   {
     // call path.
     auto result = evaluate(
-        "add_items_test(array_constructor(10, null))",
+        "add_items_test(array_constructor(10, null::bigint))",
         makeRowVector({makeFlatVector<int64_t>(1)}));
 
     // Test results.
@@ -1102,5 +1110,36 @@ TEST_F(ArrayWriterTest, errorHandlingE2E) {
            "null"}));
 }
 
+DEBUG_ONLY_TEST_F(ArrayWriterTest, resizeErrorHandling) {
+  // When resizing the element Vector it's possible that an error is thrown,
+  // e.g. due to running out of memory or the Driver shutting down, ensure the
+  // Writer does not end up in an inconsistent state when this happens.
+  auto [result, vectorWriter] = makeTestWriter();
+  const auto elementsVector = vectorWriter->vector().elements();
+
+  vectorWriter->setOffset(0);
+  auto& arrayWriter = vectorWriter->current();
+  arrayWriter.add_item() = 100;
+
+  // Simulate an error growing the Values Buffer in the element's Vector.
+  {
+    const std::string errorMessage = "Simulated failure in memory allocation";
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::FlatVector::resizeValues",
+        std::function<void(FlatVector<int64_t>*)>(
+            [&](FlatVector<int64_t>*) { VELOX_FAIL(errorMessage); }));
+    VELOX_ASSERT_THROW(arrayWriter.add_item(), errorMessage);
+  }
+
+  // The elements Vector should not have been resized due to the error.
+  VELOX_CHECK_EQ(elementsVector->size(), 1);
+
+  // If we call add_item again it should resize the elements Vector to
+  // accommodate the new element. If the ArrayWriter is in an invalid state it
+  // will think the elements has already been resized.
+  arrayWriter.add_item() = 200;
+  VELOX_CHECK_EQ(elementsVector->size(), 2);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/expression/tests/CMakeLists.txt b/velox/expression/tests/CMakeLists.txt
index 036c13fc378f..d22f083f7690 100644
--- a/velox/expression/tests/CMakeLists.txt
+++ b/velox/expression/tests/CMakeLists.txt
@@ -23,6 +23,8 @@ add_executable(
   CustomTypeTest.cpp
   ExprCompilerTest.cpp
   ExprEncodingsTest.cpp
+  ExprOptimizerTest.cpp
+  ExprRewriteRegistryTest.cpp
   ExprStatsTest.cpp
   ExprTest.cpp
   ExprToSubfieldFilterTest.cpp
@@ -44,15 +46,24 @@ add_executable(
   SimpleFunctionInitTest.cpp
   SimpleFunctionPresetNullsTest.cpp
   SimpleFunctionTest.cpp
+  SpecialFormRewriteTestBase.cpp
+  SwitchRewriteTest.cpp
+  CoalesceRewriteTest.cpp
+  ConjunctRewriteTest.cpp
   StringWriterTest.cpp
   TryExprTest.cpp
   VariadicViewTest.cpp
-  VectorReaderTest.cpp)
+  VectorReaderTest.cpp
+)
+if(VELOX_ENABLE_GEO)
+  target_compile_definitions(velox_expression_test PRIVATE VELOX_ENABLE_GEO)
+endif()
 
 add_test(
   NAME velox_expression_test
   COMMAND velox_expression_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_expression_test
@@ -78,7 +89,8 @@ target_link_libraries(
   Folly::folly
   gflags::gflags
   glog::glog
-  fmt::fmt)
+  fmt::fmt
+)
 
 add_library(velox_expression_verifier ExpressionVerifier.cpp)
 
@@ -88,7 +100,8 @@ target_link_libraries(
   velox_vector_fuzzer
   velox_fuzzer_util
   velox_type
-  velox_expression_test_utility)
+  velox_expression_test_utility
+)
 
 add_library(velox_expression_runner ExpressionRunner.cpp)
 target_link_libraries(
@@ -98,7 +111,8 @@ target_link_libraries(
   velox_functions_prestosql
   velox_functions_spark
   velox_parse_parser
-  GTest::gtest)
+  GTest::gtest
+)
 
 add_executable(velox_expression_runner_test ExpressionRunnerTest.cpp)
 target_link_libraries(
@@ -111,10 +125,10 @@ target_link_libraries(
   velox_hive_connector
   velox_fuzzer_util
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
-add_executable(velox_expression_verifier_unit_test
-               ExpressionVerifierUnitTest.cpp)
+add_executable(velox_expression_verifier_unit_test ExpressionVerifierUnitTest.cpp)
 target_link_libraries(
   velox_expression_verifier_unit_test
   velox_expression_verifier
@@ -126,7 +140,8 @@ target_link_libraries(
   velox_type
   velox_vector_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 add_executable(velox_expression_runner_unit_test ExpressionRunnerUnitTest.cpp)
 target_link_libraries(
@@ -141,4 +156,5 @@ target_link_libraries(
   velox_exec_test_lib
   velox_vector_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/expression/tests/CastExprTest.cpp b/velox/expression/tests/CastExprTest.cpp
index a8c4957dc117..e58ae6680284 100644
--- a/velox/expression/tests/CastExprTest.cpp
+++ b/velox/expression/tests/CastExprTest.cpp
@@ -27,6 +27,7 @@
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/Type.h"
 #include "velox/type/tests/utils/CustomTypesForTesting.h"
+#include "velox/type/tz/TimeZoneMap.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/TypeAliases.h"
 
@@ -1484,16 +1485,16 @@ TEST_F(CastExprTest, arrayCast) {
   {
     // Array with all inner elements null.
     auto sizeAtLocal = [](vector_size_t /* row */) { return 5; };
-    auto arrayVector = vectorMaker_.arrayVector<int32_t>(
+    auto nullElementsArrayVector = vectorMaker_.arrayVector<int32_t>(
         kVectorSize, sizeAtLocal, nullptr, nullptr, nullEvery(1));
 
     SelectivityVector rows(5);
     rows.setValid(2, false);
-    arrayVector->setOffsetAndSize(2, 100, 5);
-    arrayVector->setOffsetAndSize(20, 10, 5);
+    nullElementsArrayVector->setOffsetAndSize(2, 100, 5);
+    nullElementsArrayVector->setOffsetAndSize(20, 10, 5);
     std::vector<VectorPtr> results(1);
 
-    auto rowVector = makeRowVector({arrayVector});
+    auto rowVector = makeRowVector({nullElementsArrayVector});
     auto castExpr =
         makeTypedExpr("cast (c0 as bigint[])", asRowType(rowVector->type()));
     exec::ExprSet exprSet({castExpr}, &execCtx_);
@@ -1668,10 +1669,10 @@ TEST_F(CastExprTest, testNullOnFailure) {
   auto expected = makeNullableFlatVector<int32_t>(
       {1, 2, std::nullopt, std::nullopt, std::nullopt});
 
-  // nullOnFailure is true, so we should return null instead of throwing.
+  // isTryCast is true, so we should return null instead of throwing.
   testCast(input, expected, true);
 
-  // nullOnFailure is false, so we should throw.
+  // isTryCast is false, so we should throw.
   EXPECT_THROW(testCast(input, expected, false), VeloxUserError);
 }
 
@@ -1841,7 +1842,7 @@ TEST_F(CastExprTest, decimalToDecimal) {
       testCast(longFlat, expectedShort),
       "Cannot cast DECIMAL '-1000.000' to DECIMAL(6, 4)");
 
-  // nullOnFailure is true.
+  // isTryCast is true.
   testCast(longFlat, expectedShort, true);
 
   // long to short, big numbers.
@@ -2080,7 +2081,7 @@ TEST_F(CastExprTest, varcharToDecimal) {
       VARCHAR(),
       DECIMAL(38, 0),
       {"0.0444a"},
-      "Cannot cast VARCHAR '0.0444a' to DECIMAL(38, 0). Value is not a number. Chars 'a' are invalid.");
+      "Cannot cast VARCHAR '0.0444a' to DECIMAL(38, 0). Value is not a number.");
 
   testThrow<std::string>(
       VARCHAR(),
@@ -2113,29 +2114,29 @@ TEST_F(CastExprTest, varcharToDecimal) {
       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.");
+      "Cannot cast VARCHAR '23e-5d' to DECIMAL(38, 0). Value is not a number. Non-digit character 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.");
+      "Cannot cast VARCHAR '1. 23' to DECIMAL(38, 0). Value is not a number.");
   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.");
+      "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.");
+      "Cannot cast VARCHAR '1.23 ' to DECIMAL(38, 0). Value is not a number.");
   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.");
+      "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),
@@ -2151,7 +2152,7 @@ TEST_F(CastExprTest, varcharToDecimal) {
       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.");
+      "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(),
@@ -2164,6 +2165,18 @@ TEST_F(CastExprTest, varcharToDecimal) {
       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),
+      {"9e"},
+      "Cannot cast VARCHAR '9e' to DECIMAL(12, 2). Value is not a number. The exponent part is empty.");
+
+  testThrow<std::string>(
+      VARCHAR(),
+      DECIMAL(12, 2),
+      {"09{xi+yD"},
+      "Cannot cast VARCHAR '09{xi+yD' to DECIMAL(12, 2). Value is not a number. Chars are invalid.");
 }
 
 TEST_F(CastExprTest, castInTry) {
@@ -2513,8 +2526,8 @@ TEST_F(CastExprTest, castAsCall) {
   auto input = makeRowVector({makeNullableFlatVector(inputValues)});
   core::TypedExprPtr inputField =
       std::make_shared<const core::FieldAccessTypedExpr>(INTEGER(), "c0");
-  core::TypedExprPtr callExpr = std::make_shared<const core::CallTypedExpr>(
-      DOUBLE(), std::vector<core::TypedExprPtr>{inputField}, "cast");
+  core::TypedExprPtr callExpr =
+      std::make_shared<const core::CallTypedExpr>(DOUBLE(), "cast", inputField);
 
   auto result = evaluate(callExpr, input);
   auto expected = makeNullableFlatVector(outputValues);
@@ -2815,13 +2828,15 @@ TEST_F(CastExprTest, intervalDayTimeToVarchar) {
       "Cast from VARCHAR to INTERVAL DAY TO SECOND is not supported");
 }
 
-class BigintTypeWithCustomComparisonCastOperator : public exec::CastOperator {
- public:
-  static const std::shared_ptr<const CastOperator>& get() {
-    static const std::shared_ptr<const CastOperator> instance{
-        new BigintTypeWithCustomComparisonCastOperator()};
+class BigintTypeWithCustomComparisonCastOperator final
+    : public exec::CastOperator {
+  BigintTypeWithCustomComparisonCastOperator() = default;
 
-    return instance;
+ public:
+  static std::shared_ptr<const CastOperator> get() {
+    VELOX_CONSTEXPR_SINGLETON BigintTypeWithCustomComparisonCastOperator
+        kInstance;
+    return {std::shared_ptr<const CastOperator>{}, &kInstance};
   }
 
   bool isSupportedFromType(const TypePtr& other) const override {
@@ -2849,12 +2864,9 @@ class BigintTypeWithCustomComparisonCastOperator : public exec::CastOperator {
       VectorPtr& result) const override {
     VELOX_FAIL("Cast from BigintTypeWithCustomComparison should not be called");
   }
-
- private:
-  BigintTypeWithCustomComparisonCastOperator() = default;
 };
 
-class BigintTypeWithCustomComparisonTypeFactories : public CustomTypeFactories {
+class BigintTypeWithCustomComparisonTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -2886,8 +2898,7 @@ TEST_F(CastExprTest, skipUnnecessaryChildrenOfComplexTypes) {
   VELOX_CHECK(
       registerCustomType(
           BIGINT_TYPE_WITH_CUSTOM_COMPARISON()->name(),
-          std::make_unique<
-              const BigintTypeWithCustomComparisonTypeFactories>()),
+          std::make_unique<const BigintTypeWithCustomComparisonTypeFactory>()),
       "Failed to register custom type 'bigint type with custom comparison'");
 
   const auto valuesThatThrowOnCast = makeFlatVector<int64_t>(
@@ -2965,5 +2976,1086 @@ TEST_F(CastExprTest, skipUnnecessaryChildrenOfComplexTypes) {
     testCast(mapVector, expectedMapVector);
   }
 }
+
+TEST_F(CastExprTest, timeToVarcharCast) {
+  {
+    // Test casting TIME to VARCHAR
+
+    // Test various TIME values (milliseconds since midnight)
+    // 0 = 00:00:00.000
+    // 3661000 = 01:01:01.000
+    // 43200000 = 12:00:00.000 (noon)
+    // 86399999 = 23:59:59.999
+    auto timeVector =
+        makeFlatVector<int64_t>({0, 3661000, 43200000, 86399999}, TIME());
+
+    auto result = evaluate<FlatVector<StringView>>(
+        "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<StringView>(
+        {"00:00:00.000", "01:01:01.000", "12:00:00.000", "23:59:59.999"});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting TIME to VARCHAR with nulls
+    auto timeVector = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt}, TIME());
+
+    auto result = evaluate<FlatVector<StringView>>(
+        "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    auto expected = makeNullableFlatVector<StringView>(
+        {"00:00:00.000", std::nullopt, "12:00:00.000", std::nullopt});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test try_cast for TIME to VARCHAR
+    auto timeVector = makeFlatVector<int64_t>({0, 43200000}, TIME());
+
+    auto result = evaluate<FlatVector<StringView>>(
+        "try_cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    auto expected =
+        makeFlatVector<StringView>({"00:00:00.000", "12:00:00.000"});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test across different time zones with America/Los_Angeles timezone
+
+    // Test various TIME values (milliseconds since midnight)
+    // Los Angeles is UTC-8 (standard time) or UTC-7 (daylight saving time)
+    auto timeVector = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 UTC -> should adjust for timezone
+            3661000, // 01:01:01.000 UTC -> should adjust for timezone
+            43200000, // 12:00:00.000 UTC -> should adjust for timezone
+            86399999, // 23:59:59.999 UTC -> should adjust for timezone
+            25200000, // 07:00:00.000 UTC -> should adjust for timezone
+            72000000 // 20:00:00.000 UTC -> should adjust for timezone
+        },
+        TIME());
+
+    // With timezone displacement, the times should be adjusted
+    // Note: The exact expected values depend on the timezone implementation
+    // This test verifies that timezone-aware casting is working
+
+    {
+      // In Daylight savings time at session start time below.
+      setSessionStartTimeAndTimeZone(
+          1756710000000, "America/Los_Angeles"); // 2025-09-01T00:00:00.000
+
+      auto result = evaluate<FlatVector<StringView>>(
+          "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+      auto expected = makeFlatVector<StringView>({
+          "17:00:00.000", // 00:00:00.000 - 7 hours = 17:00:00.000 (previous
+                          // day)
+          "18:01:01.000", // 01:01:01.000 - 7 hours = 18:01:01.000 (previous
+                          // day)
+          "05:00:00.000", // 12:00:00.000 - 7 hours = 05:00:00.000
+          "16:59:59.999", // 23:59:59.999 - 7 hours = 16:59:59.999
+          "00:00:00.000", // 07:00:00.000 - 7 hours = 00:00:00.000 (mid night)
+          "13:00:00.000" // 20:00:00.000 - 7 hours = 12:00:00.000
+      });
+
+      assertEqualVectors(expected, result);
+    }
+
+    {
+      // Not In Daylight savings time at session start time below.
+      setSessionStartTimeAndTimeZone(
+          1762761600000, "America/Los_Angeles"); // 025-11-10T00:00:00.000
+
+      auto result = evaluate<FlatVector<StringView>>(
+          "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+      auto expected = makeFlatVector<StringView>({
+          "16:00:00.000", // 00:00:00.000 - 8 hours = 16:00:00.000 (previous
+                          // day)
+          "17:01:01.000", // 01:01:01.000 - 8 hours = 17:01:01.000 (previous
+                          // day)
+          "04:00:00.000", // 12:00:00.000 - 8 hours = 04:00:00.000
+          "15:59:59.999", // 23:59:59.999 - 8 hours = 15:59:59.999
+          "23:00:00.000", // 07:00:00.000 - 8 hours = 23:00:00.000 (previous
+                          // day)
+          "12:00:00.000" // 20:00:00.000 - 8 hours = 12:00:00.000
+      });
+
+      assertEqualVectors(expected, result);
+    }
+
+    {
+      // Try this again with a different timezone
+      setTimezone("Australia/Perth");
+
+      auto result = evaluate<FlatVector<StringView>>(
+          "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+      // Perth is always UTC+8 (no daylight saving time)
+      auto expected = makeFlatVector<StringView>({
+          "08:00:00.000", // 00:00:00.000 + 8 hours
+          "09:01:01.000", // 01:01:01.000 + 8 hours
+          "20:00:00.000", // 12:00:00.000 + 8 hours
+          "07:59:59.999", // 23:59:59.999 + 8 hours (wraps around)
+          "15:00:00.000", // 07:00:00.000 + 8 hours
+          "04:00:00.000" // 20:00:00.000 + 8 hours (wraps around)
+      });
+
+      assertEqualVectors(expected, result);
+    }
+  }
+
+  {
+    // Test during daylight saving time , March 10, 2024 09:00:00 AM UTC
+    // Spring forward. The clock jumps forward 1 hour, from 2:00 AM to 3:00 AM.
+    setSessionStartTimeAndTimeZone(1710061200000, "America/Los_Angeles");
+
+    auto timeVector = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 UTC -> should adjust for timezone
+            3661000, // 01:01:01.000 UTC -> should adjust for timezone
+            43200000, // 12:00:00.000 UTC -> should adjust for timezone
+            86399999, // 23:59:59.999 UTC -> should adjust for timezone
+            25200000, // 07:00:00.000 UTC -> should adjust for timezone
+            72000000 // 20:00:00.000 UTC -> should adjust for timezone
+        },
+        TIME());
+
+    auto result = evaluate<FlatVector<StringView>>(
+        "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<StringView>({
+        "16:00:00.000", // 00:00:00.000 - 8 hours = 16:00:00.000 (previous
+                        // day)
+        "17:01:01.000", // 01:01:01.000 - 8 hours = 17:01:01.000 (previous
+                        // day)
+        "05:00:00.000", // 12:00:00.000 - 7 hours = 05:00:00.000
+        "16:59:59.999", // 23:59:59.999 - 7 hours = 16:59:59.999
+        "23:00:00.000", // 07:00:00.000 - 8 hours = 23:00:00.000 (previous
+                        // day)
+        "13:00:00.000" // 20:00:00.000 - 7 hours = 13:00:00.000
+    });
+
+    assertEqualVectors(expected, result);
+
+    // Fall Back. The clock jumps back 1 hour, from 2:00 AM to 1:00 AM.
+    setSessionStartTimeAndTimeZone(1730620800000, "America/Los_Angeles");
+
+    result = evaluate<FlatVector<StringView>>(
+        "cast(c0 as varchar)", makeRowVector({timeVector}));
+
+    expected = makeFlatVector<StringView>({
+        "17:00:00.000", // 00:00:00.000 - 7 hours = 17:00:00.000 (previous
+                        // day)
+        "18:01:01.000", // 01:01:01.000 - 7 hours = 18:01:01.000 (previous
+                        // day)
+        "04:00:00.000", // 12:00:00.000 - 8 hours = 04:00:00.000
+        "15:59:59.999", // 23:59:59.999 - 8 hours = 15:59:59.999
+        "00:00:00.000", // 07:00:00.000 - 7 hours = 00:00:00.000 (previous
+                        // day)
+        "12:00:00.000" // 20:00:00.000 - 8 hours = 12:00:00.000
+    });
+
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(CastExprTest, timeToBigintCast) {
+  {
+    // Test casting TIME to BIGINT
+
+    // Test various TIME values (milliseconds since midnight)
+    // 0 = 00:00:00.000
+    // 3661000 = 01:01:01.000
+    // 43200000 = 12:00:00.000 (noon)
+    // 86399999 = 23:59:59.999
+    auto timeVector =
+        makeFlatVector<int64_t>({0, 3661000, 43200000, 86399999}, TIME());
+
+    auto result = evaluate<FlatVector<int64_t>>(
+        "cast(c0 as bigint)", makeRowVector({timeVector}));
+
+    // Should return the same values since TIME is already stored as int64_t
+    // milliseconds
+    auto expected = makeFlatVector<int64_t>({0, 3661000, 43200000, 86399999});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting TIME to BIGINT with nulls
+    auto timeVector = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt}, TIME());
+
+    auto result = evaluate<FlatVector<int64_t>>(
+        "cast(c0 as bigint)", makeRowVector({timeVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test try_cast for TIME to BIGINT
+    auto timeVector = makeFlatVector<int64_t>({0, 43200000}, TIME());
+
+    auto result = evaluate<FlatVector<int64_t>>(
+        "try_cast(c0 as bigint)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<int64_t>({0, 43200000});
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test constant TIME vector cast to BIGINT (non-null)
+    // This tests the optimization path for constant vectors
+    auto constantTimeVector = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({43200000}, TIME()));
+
+    auto result =
+        evaluate("cast(c0 as bigint)", makeRowVector({constantTimeVector}));
+
+    // Should return a constant vector with the same value
+    auto expected = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({43200000}));
+
+    assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded (optimization worked)
+    ASSERT_TRUE(result->isConstantEncoding());
+  }
+
+  {
+    // Test constant TIME vector cast to BIGINT (null)
+    // This tests the optimization path for null constant vectors
+    auto nullTimeVector = BaseVector::createNullConstant(TIME(), 500, pool());
+
+    auto result =
+        evaluate("cast(c0 as bigint)", makeRowVector({nullTimeVector}));
+
+    // Should return a null constant vector
+    auto expected = BaseVector::createNullConstant(BIGINT(), 500, pool());
+
+    assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded (optimization worked)
+    ASSERT_TRUE(result->isConstantEncoding());
+    ASSERT_TRUE(result->isNullAt(0));
+  }
+
+  {
+    // Test constant TIME vector cast to BIGINT with different sizes
+    // This ensures the optimization correctly handles different vector sizes
+    for (auto size : {1, 10, 100, 1000}) {
+      auto constantTimeVector = BaseVector::wrapInConstant(
+          size, 0, makeFlatVector<int64_t>({86399999}, TIME()));
+
+      auto result =
+          evaluate("cast(c0 as bigint)", makeRowVector({constantTimeVector}));
+
+      auto expected = BaseVector::wrapInConstant(
+          size, 0, makeFlatVector<int64_t>({86399999}));
+
+      assertEqualVectors(expected, result);
+      ASSERT_TRUE(result->isConstantEncoding());
+      ASSERT_EQ(result->size(), size);
+    }
+  }
+}
+
+TEST_F(CastExprTest, varcharToTimeCast) {
+  // Set session time zone to UTC before running the tests
+  setTimezone("UTC");
+
+  {
+    // Test casting VARCHAR to TIME with valid time strings
+    auto varcharVector = makeFlatVector<StringView>(
+        {"00:00:00.000",
+         "01:01:01.000",
+         "12:00:00.000",
+         "23:59:59.999",
+         "09:30:15.123",
+         "18:45:30.500"});
+
+    // Use makeCastExpr directly to avoid DuckDB parser issues
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    // TIME is milliseconds since midnight
+    auto expected = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000
+            3661000, // 01:01:01.000 = 3600*1000 + 60*1000 + 1*1000
+            43200000, // 12:00:00.000 = 12*3600*1000
+            86399999, // 23:59:59.999 = 23*3600*1000 + 59*60*1000 + 59*1000 +
+                      // 999
+            34215123, // 09:30:15.123 = 9*3600*1000 + 30*60*1000 + 15*1000 + 123
+            67530500 // 18:45:30.500 = 18*3600*1000 + 45*60*1000 + 30*1000 + 500
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting VARCHAR to TIME with nulls
+    auto varcharVector = makeNullableFlatVector<StringView>(
+        {"00:00:00.000", std::nullopt, "12:00:00.000", std::nullopt});
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt}, TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test time formats without seconds and milliseconds
+    auto varcharVector = makeFlatVector<StringView>(
+        {"00:00:00", "12:30:45", "23:59:59", "12:30"});
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00
+            45045000, // 12:30:45 = 12*3600*1000 + 30*60*1000 + 45*1000
+            86399000, // 23:59:59 = 23*3600*1000 + 59*60*1000 + 59*1000
+            45000000, // 12:30 = 12*3600*1000 + 30*60*1000
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test try_cast with invalid formats
+    auto varcharVector = makeFlatVector<StringView>({
+        "00:00:00.000", // valid
+        "25:00:00.000", // invalid hour
+        "12:60:00.000", // invalid minute
+        "12:30:60.000", // invalid second
+        "invalid" // completely invalid
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {
+            0, // valid
+            std::nullopt, // invalid hour
+            std::nullopt, // invalid minute
+            std::nullopt, // invalid second
+            std::nullopt // completely invalid
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test edge cases with leading/trailing spaces (should NOT be handled -
+    // should fail like Presto)
+    auto varcharVector = makeFlatVector<StringView>({
+        " 12:30:45.123 ", // spaces should cause failure
+        "12:30:45.123", // no spaces - should succeed
+        " 09:15:30.456", // leading space - should fail
+        "14:22:33.789 ", // trailing space - should fail
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {
+            std::nullopt, // spaces cause failure
+            45045123, // 12:30:45.123 without spaces succeeds
+            std::nullopt, // leading space causes failure
+            std::nullopt, // trailing space causes failure
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test that Unicode digits are rejected (not converted)
+    auto varcharVector = makeFlatVector<StringView>({
+        "1٢:30:45.123", // Arabic digit in hour should throw error
+        "12:٣٠:45.123", // Arabic digits in minute should throw error
+        "12:30:٤٥.123", // Arabic digits in second should throw error
+        "12:30:45.١٢٣", // Arabic digits in millisecond should throw error
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    // Should throw error for Unicode digits
+    VELOX_ASSERT_THROW(
+        evaluate(castExpr, makeRowVector({varcharVector})),
+        "Invalid time format: expected ':' after hour");
+
+    // Test with try_cast - should return null for Unicode digits
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {std::nullopt, std::nullopt, std::nullopt, std::nullopt}, TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test that microsecond precision should throw an error (not truncate)
+    auto varcharVector = makeFlatVector<StringView>({
+        "12:30:45.123456", // microseconds should throw error
+        "12:30:45.123999", // microseconds should throw error
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    // Should throw error for microseconds
+    VELOX_ASSERT_THROW(
+        evaluate(castExpr, makeRowVector({varcharVector})),
+        "Microsecond precision not supported");
+
+    // Test with try_cast - should return null for microseconds
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    auto expected =
+        makeNullableFlatVector<int64_t>({std::nullopt, std::nullopt}, TIME());
+
+    assertEqualVectors(expected, result);
+
+    // Test that exact milliseconds still work
+    auto validVector = makeFlatVector<StringView>({"12:30:45.123"});
+    auto validResult = evaluate(
+        makeCastExpr(
+            std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"),
+            TIME(),
+            false),
+        makeRowVector({validVector}));
+
+    auto validExpected = makeFlatVector<int64_t>({45045123}, TIME());
+    assertEqualVectors(validExpected, validResult);
+  }
+
+  {
+    // Test timezone-aware VARCHAR to TIME casting with America/Los_Angeles
+    // timezone When casting VARCHAR to TIME, the string is interpreted as local
+    // time and converted to UTC (the reverse of TIME to VARCHAR)
+    setSessionStartTimeAndTimeZone(
+        1756710000000, "America/Los_Angeles"); // 2025-09-01T00:00:00.000 (DST)
+
+    auto varcharVector = makeFlatVector<StringView>({
+        "00:00:00.000", // Midnight local time
+        "07:00:00.000", // 7 AM local time
+        "12:00:00.000", // Noon local time
+        "23:59:59.999" // Just before midnight local time
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    // During DST, LA is UTC-7, so local times are converted to UTC by adding 7
+    // hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            25200000, // 00:00:00.000 + 7 hours = 07:00:00.000 UTC
+            50400000, // 07:00:00.000 + 7 hours = 14:00:00.000 UTC
+            68400000, // 12:00:00.000 + 7 hours = 19:00:00.000 UTC
+            25199999, // 23:59:59.999 + 7 hours = 06:59:59.999 UTC (next day)
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with different timezone settings - during standard time (not DST)
+    setSessionStartTimeAndTimeZone(
+        1762761600000,
+        "America/Los_Angeles"); // 2025-11-10T00:00:00.000 (Standard Time)
+
+    auto varcharVector = makeFlatVector<StringView>({
+        "00:00:00.000", // Midnight local time
+        "08:00:00.000", // 8 AM local time
+        "12:00:00.000", // Noon local time
+        "23:59:59.999" // Just before midnight local time
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    // During standard time, LA is UTC-8, so local times are converted to UTC by
+    // adding 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            28800000, // 00:00:00.000 + 8 hours = 08:00:00.000 UTC
+            57600000, // 08:00:00.000 + 8 hours = 16:00:00.000 UTC
+            72000000, // 12:00:00.000 + 8 hours = 20:00:00.000 UTC
+            28799999, // 23:59:59.999 + 8 hours = 07:59:59.999 UTC (next day)
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with Australia/Perth timezone
+    setTimezone("Australia/Perth");
+
+    auto varcharVector = makeFlatVector<StringView>({
+        "00:00:00.000", // Midnight local time
+        "06:00:00.000", // 6 AM local time
+        "12:00:00.000", // Noon local time
+        "18:00:00.000" // 6 PM local time
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    // Perth is UTC+8, so local times are converted to UTC by subtracting 8
+    // hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            57600000, // 00:00:00.000 - 8 hours = 16:00:00.000 UTC (previous
+                      // day)
+            79200000, // 06:00:00.000 - 8 hours = 22:00:00.000 UTC (previous
+                      // day)
+            14400000, // 12:00:00.000 - 8 hours = 04:00:00.000 UTC
+            36000000 // 18:00:00.000 - 8 hours = 10:00:00.000 UTC
+        },
+        TIME());
+
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(CastExprTest, varcharToTimeDSTGapHandling) {
+  // Test DST gap handling for VARCHAR to TIME conversion during spring-forward
+  // transition in America/Los_Angeles on March 10, 2024
+  setSessionStartTimeAndTimeZone(
+      1710064800000, "America/Los_Angeles"); // March 10, 2024 01:00:00 UTC
+
+  {
+    // Test normal times outside DST gaps work correctly
+    auto varcharVector = makeFlatVector<StringView>({
+        "01:30:00.000", // Before DST gap
+        "03:30:00.000", // After DST gap
+        "05:00:00.000", // Well after DST gap
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto timeResult = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    ASSERT_TRUE(timeResult != nullptr);
+    ASSERT_EQ(timeResult->size(), 3);
+
+    for (int i = 0; i < 3; i++) {
+      EXPECT_FALSE(timeResult->isNullAt(i))
+          << "Valid time at index " << i << " should not be null";
+    }
+  }
+
+  {
+    // Test round-trip conversion for valid times
+    auto varcharVector = makeFlatVector<StringView>({
+        "01:30:00.000", // Before DST gap
+        "03:30:00.000", // After DST gap
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto timeResult = evaluate(castExpr, makeRowVector({varcharVector}));
+
+    auto timeToVarcharExpr = makeCastExpr(
+        std::make_shared<core::FieldAccessTypedExpr>(TIME(), "c0"),
+        VARCHAR(),
+        false);
+    auto varcharResult =
+        evaluate(timeToVarcharExpr, makeRowVector({timeResult}));
+
+    auto result =
+        std::dynamic_pointer_cast<FlatVector<StringView>>(varcharResult);
+    ASSERT_TRUE(result != nullptr);
+
+    // Times outside the DST gap should round-trip correctly
+    EXPECT_EQ(result->valueAt(0), "01:30:00.000");
+    EXPECT_EQ(result->valueAt(1), "03:30:00.000");
+  }
+
+  {
+    // Test DST gap times with try_cast - gap times should return null
+    auto varcharVector = makeFlatVector<StringView>({
+        "01:30:00.000", // Before gap - should work
+        "02:01:00.000", // In the gap - should return null
+        "02:30:00.000", // In the gap - should return null
+        "03:30:00.000", // After gap - should work
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({varcharVector}));
+
+    ASSERT_TRUE(result != nullptr);
+    ASSERT_EQ(result->size(), 4);
+
+    // Times before and after the gap should work
+    EXPECT_FALSE(result->isNullAt(0)) << "Time before DST gap should work";
+    EXPECT_FALSE(result->isNullAt(3)) << "Time after DST gap should work";
+
+    // Gap times should return null
+    EXPECT_TRUE(result->isNullAt(1)) << "Gap time 02:01:00 should return null";
+    EXPECT_TRUE(result->isNullAt(2)) << "Gap time 02:30:00 should return null";
+  }
+
+  {
+    // Test DST fall-back transition (November - when times are ambiguous)
+    setSessionStartTimeAndTimeZone(
+        1730620800000, "America/Los_Angeles"); // November 3, 2024 DST end
+
+    auto ambiguousTimeVector = makeFlatVector<StringView>({
+        "00:30:00.000", // Before fall-back - should work
+        "01:30:00.000", // Ambiguous time - occurs twice during fall-back
+        "02:30:00.000", // After fall-back - should work
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto result = evaluate(tryCastExpr, makeRowVector({ambiguousTimeVector}));
+
+    ASSERT_TRUE(result != nullptr);
+    ASSERT_EQ(result->size(), 3);
+
+    // All times should work during fall-back (no gaps, just ambiguity)
+    EXPECT_FALSE(result->isNullAt(0)) << "Time before fall-back should work";
+    EXPECT_FALSE(result->isNullAt(2)) << "Time after fall-back should work";
+  }
+
+  {
+    // Test that ambiguous times during DST fall-back pick the earlier
+    // occurrence (like Presto does). During fall-back, clocks go from 2:00 AM
+    // to 1:00 AM, so times like 1:30 AM occur twice - we should pick the first
+    // occurrence.
+    setSessionStartTimeAndTimeZone(
+        1730620800000, "America/Los_Angeles"); // November 3, 2024 DST end
+
+    auto ambiguousTimeVector = makeFlatVector<StringView>({
+        "01:00:00.000", // Occurs twice: once before fall-back, once after
+        "01:15:00.000", // Occurs twice during the ambiguous hour
+        "01:30:00.000", // Occurs twice during the ambiguous hour
+        "01:45:00.000", // Occurs twice during the ambiguous hour
+        "01:59:59.999", // Last ambiguous time before 2:00 AM
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result = evaluate(castExpr, makeRowVector({ambiguousTimeVector}));
+
+    // Convert back to VARCHAR to see which time was chosen
+    auto timeToVarcharExpr = makeCastExpr(
+        std::make_shared<core::FieldAccessTypedExpr>(TIME(), "c0"),
+        VARCHAR(),
+        false);
+    auto varcharResult = evaluate(timeToVarcharExpr, makeRowVector({result}));
+
+    auto resultVector =
+        std::dynamic_pointer_cast<FlatVector<StringView>>(varcharResult);
+    ASSERT_TRUE(resultVector != nullptr);
+
+    // During fall-back in LA, we expect the earlier occurrence to be chosen.
+    // The earlier occurrence is when LA is still in PDT (UTC-7).
+    // Times should round-trip correctly since we picked a valid occurrence.
+    EXPECT_EQ(resultVector->valueAt(0), "01:00:00.000");
+    EXPECT_EQ(resultVector->valueAt(1), "01:15:00.000");
+    EXPECT_EQ(resultVector->valueAt(2), "01:30:00.000");
+    EXPECT_EQ(resultVector->valueAt(3), "01:45:00.000");
+    EXPECT_EQ(resultVector->valueAt(4), "01:59:59.999");
+
+    // Verify that we get consistent behavior: casting the same ambiguous time
+    // multiple times should always give the same result (earlier occurrence)
+    auto singleAmbiguousTime = makeFlatVector<StringView>({"01:30:00.000"});
+    auto result1 = evaluate(castExpr, makeRowVector({singleAmbiguousTime}));
+    auto result2 = evaluate(castExpr, makeRowVector({singleAmbiguousTime}));
+
+    // Both results should be identical (picking the same occurrence)
+    assertEqualVectors(result1, result2);
+
+    // Convert both results back to varchar to verify consistency
+    auto varchar1 = evaluate(timeToVarcharExpr, makeRowVector({result1}));
+    auto varchar2 = evaluate(timeToVarcharExpr, makeRowVector({result2}));
+    assertEqualVectors(varchar1, varchar2);
+  }
+
+  {
+    // Test ambiguous time behavior across different DST transitions
+    // to ensure consistent "pick earlier occurrence" behavior
+
+    // Test with a different year's fall-back transition
+    setSessionStartTimeAndTimeZone(
+        1699761600000, "America/Los_Angeles"); // November 5, 2023 DST end
+
+    auto ambiguousTime2023 = makeFlatVector<StringView>({"01:30:00.000"});
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+    auto result2023 = evaluate(castExpr, makeRowVector({ambiguousTime2023}));
+
+    // Convert back to verify round-trip
+    auto timeToVarcharExpr = makeCastExpr(
+        std::make_shared<core::FieldAccessTypedExpr>(TIME(), "c0"),
+        VARCHAR(),
+        false);
+    auto varchar2023 = evaluate(timeToVarcharExpr, makeRowVector({result2023}));
+
+    auto resultVector2023 =
+        std::dynamic_pointer_cast<FlatVector<StringView>>(varchar2023);
+    ASSERT_TRUE(resultVector2023 != nullptr);
+
+    // Should round-trip correctly, confirming we picked a valid occurrence
+    EXPECT_EQ(resultVector2023->valueAt(0), "01:30:00.000");
+
+    // Test with 2025 fall-back transition
+    setSessionStartTimeAndTimeZone(
+        1762160400000, "America/Los_Angeles"); // November 2, 2025 DST end
+
+    auto ambiguousTime2025 = makeFlatVector<StringView>({"01:30:00.000"});
+    auto result2025 = evaluate(castExpr, makeRowVector({ambiguousTime2025}));
+    auto varchar2025 = evaluate(timeToVarcharExpr, makeRowVector({result2025}));
+
+    auto resultVector2025 =
+        std::dynamic_pointer_cast<FlatVector<StringView>>(varchar2025);
+    ASSERT_TRUE(resultVector2025 != nullptr);
+
+    // Should round-trip correctly across different years
+    EXPECT_EQ(resultVector2025->valueAt(0), "01:30:00.000");
+  }
+
+  {
+    // Test that gap times don't round-trip to original values
+    setSessionStartTimeAndTimeZone(
+        1710064800000, "America/Los_Angeles"); // Back to March 10, 2024
+
+    auto gapTimeVector = makeFlatVector<StringView>({
+        "02:01:00.000", // Gap time example
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto tryCastExpr = makeCastExpr(inputField, TIME(), true);
+    auto timeResult = evaluate(tryCastExpr, makeRowVector({gapTimeVector}));
+
+    // Gap time should return null, confirming it doesn't round-trip
+    EXPECT_TRUE(timeResult->isNullAt(0))
+        << "Gap time 02:01:00 should return null during DST spring-forward";
+  }
+
+  {
+    // Test that regular cast (not try_cast) throws exceptions for gap times
+    setSessionStartTimeAndTimeZone(
+        1710064800000, "America/Los_Angeles"); // March 10, 2024 DST transition
+
+    auto gapTimeVector = makeFlatVector<StringView>({
+        "02:01:00.000", // Gap time - should throw exception
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr =
+        makeCastExpr(inputField, TIME(), false); // regular cast, not try_cast
+
+    // Regular cast should throw exception for gap times
+    VELOX_ASSERT_THROW(
+        evaluate(castExpr, makeRowVector({gapTimeVector})),
+        "Cannot cast VARCHAR '02:01:00.000' to TIME. Time does not exist due to DST gap");
+  }
+
+  {
+    // Test multiple gap times all throw exceptions
+    setSessionStartTimeAndTimeZone(
+        1710064800000, "America/Los_Angeles"); // March 10, 2024 DST transition
+
+    // Test different gap times individually since one exception will stop
+    // evaluation
+    std::vector<std::string> gapTimes = {
+        "02:00:00.000", // Start of gap
+        "02:15:00.000", // Middle of gap
+        "02:30:00.000", // Middle of gap
+        "02:45:00.000", // Near end of gap
+        "02:59:59.999", // End of gap
+    };
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    for (const auto& gapTime : gapTimes) {
+      auto gapTimeVector = makeFlatVector<StringView>({StringView(gapTime)});
+
+      // Each gap time should throw an exception
+      VELOX_ASSERT_THROW(
+          evaluate(castExpr, makeRowVector({gapTimeVector})),
+          "Cannot cast VARCHAR '" + gapTime +
+              "' to TIME. Time does not exist due to DST gap");
+    }
+  }
+
+  {
+    // Test that times right before and after gap work with regular cast
+    setSessionStartTimeAndTimeZone(
+        1710064800000, "America/Los_Angeles"); // March 10, 2024 DST transition
+
+    auto validTimeVector = makeFlatVector<StringView>({
+        "01:59:59.999", // Just before gap - should work
+        "03:00:00.000", // Just after gap - should work
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    // These should not throw exceptions
+    ASSERT_NO_THROW(evaluate(castExpr, makeRowVector({validTimeVector})));
+  }
+
+  {
+    // Test exception throwing during fall-back transition (November)
+    // Fall-back doesn't have gaps, so all times should work
+    setSessionStartTimeAndTimeZone(
+        1730620800000, "America/Los_Angeles"); // November 3, 2024 DST end
+
+    auto ambiguousTimeVector = makeFlatVector<StringView>({
+        "01:30:00.000", // Ambiguous time - occurs twice during fall-back
+    });
+
+    auto inputField =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto castExpr = makeCastExpr(inputField, TIME(), false);
+
+    // Fall-back times should not throw exceptions (just ambiguous, not gaps)
+    ASSERT_NO_THROW(evaluate(castExpr, makeRowVector({ambiguousTimeVector})));
+  }
+}
+
+TEST_F(CastExprTest, timeToTimestampCast) {
+  {
+    // Test casting TIME to TIMESTAMP
+    // TIME values represent milliseconds since midnight
+    // When cast to TIMESTAMP, they should become milliseconds since epoch
+
+    // Test various TIME values (milliseconds since midnight)
+    // 0 = 00:00:00.000
+    // 3661000 = 01:01:01.000
+    // 43200000 = 12:00:00.000 (noon)
+    // 86399999 = 23:59:59.999
+    auto timeVector =
+        makeFlatVector<int64_t>({0, 3661000, 43200000, 86399999}, TIME());
+
+    auto result = evaluate<FlatVector<Timestamp>>(
+        "cast(c0 as timestamp)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<Timestamp>({
+        Timestamp::fromMillis(0),
+        Timestamp::fromMillis(3661000),
+        Timestamp::fromMillis(43200000),
+        Timestamp::fromMillis(86399999),
+    });
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting TIME to TIMESTAMP with nulls
+    auto timeVector = makeNullableFlatVector<int64_t>(
+        {0, std::nullopt, 43200000, std::nullopt}, TIME());
+
+    auto result = evaluate<FlatVector<Timestamp>>(
+        "cast(c0 as timestamp)", makeRowVector({timeVector}));
+
+    auto expected = makeNullableFlatVector<Timestamp>({
+        Timestamp::fromMillis(0),
+        std::nullopt,
+        Timestamp::fromMillis(43200000),
+        std::nullopt,
+    });
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test try_cast for TIME to TIMESTAMP
+    auto timeVector = makeFlatVector<int64_t>({0, 43200000}, TIME());
+
+    auto result = evaluate<FlatVector<Timestamp>>(
+        "try_cast(c0 as timestamp)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<Timestamp>({
+        Timestamp::fromMillis(0),
+        Timestamp::fromMillis(43200000),
+    });
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test constant TIME vector cast to TIMESTAMP (non-null)
+    auto constantTimeVector = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({43200000}, TIME()));
+
+    auto result =
+        evaluate("cast(c0 as timestamp)", makeRowVector({constantTimeVector}));
+
+    // Should return a constant vector with the same value
+    auto expected = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<Timestamp>({Timestamp::fromMillis(43200000)}));
+
+    assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded - optimization
+    ASSERT_TRUE(result->isConstantEncoding());
+  }
+
+  {
+    // Test constant TIME vector cast to TIMESTAMP (null)
+    auto nullTimeVector = BaseVector::createNullConstant(TIME(), 500, pool());
+
+    auto result =
+        evaluate("cast(c0 as timestamp)", makeRowVector({nullTimeVector}));
+
+    // Should return a null constant vector
+    auto expected = BaseVector::createNullConstant(TIMESTAMP(), 500, pool());
+
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test TIME to TIMESTAMP cast with various edge cases
+    auto timeVector = makeFlatVector<int64_t>(
+        {
+            1, // 1 millisecond after midnight
+            1000, // 1 second after midnight
+            60000, // 1 minute after midnight
+            3600000, // 1 hour after midnight
+            86399000, // 1 second before midnight
+            86399990, // 10 milliseconds before midnight
+        },
+        TIME());
+
+    auto result = evaluate<FlatVector<Timestamp>>(
+        "cast(c0 as timestamp)", makeRowVector({timeVector}));
+
+    auto expected = makeFlatVector<Timestamp>({
+        Timestamp::fromMillis(1),
+        Timestamp::fromMillis(1000),
+        Timestamp::fromMillis(60000),
+        Timestamp::fromMillis(3600000),
+        Timestamp::fromMillis(86399000),
+        Timestamp::fromMillis(86399990),
+    });
+
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(CastExprTest, timestampToTimeCast) {
+  // Test casting TIMESTAMP to TIME
+  // TIME values represent milliseconds since midnight (time-of-day)
+  // TIMESTAMP to TIME extracts the time-of-day component
+  // This matches Presto's behavior (see TestTimestampBase.java:185-188)
+
+  std::vector<std::optional<Timestamp>> inputTimestamps = {
+      Timestamp::fromMillis(0), // 00:00:00.000
+      Timestamp::fromMillis(3661000), // 01:01:01.000
+      Timestamp::fromMillis(43200000), // 12:00:00.000
+      Timestamp::fromMillis(86399999), // 23:59:59.999
+      Timestamp::fromMillis(86400000), // Next day 00:00:00.000
+      Timestamp::fromMillis(86400000 + 3661000), // Next day 01:01:01.000
+      Timestamp::fromMillis(2 * 86400000 + 43200000), // Two days later
+                                                      // 12:00:00.000
+      std::nullopt};
+
+  std::vector<std::optional<int64_t>> expectedTime = {
+      0, // 00:00:00.000
+      3661000, // 01:01:01.000
+      43200000, // 12:00:00.000
+      86399999, // 23:59:59.999
+      0, // 00:00:00.000 (wraps to midnight)
+      3661000, // 01:01:01.000
+      43200000, // 12:00:00.000
+      std::nullopt};
+
+  testCast(TIMESTAMP(), TIME(), inputTimestamps, expectedTime);
+
+  // Test with negative timestamps (before epoch)
+  // Negative timestamps should correctly wrap around to positive time-of-day
+  std::vector<std::optional<Timestamp>> negativeTimestamps = {
+      Timestamp::fromMillis(-1), // 1ms before epoch -> 23:59:59.999
+      Timestamp::fromMillis(-3600000), // 1 hour before epoch -> 23:00:00.000
+      Timestamp::fromMillis(-86400000), // Exactly 1 day before epoch ->
+                                        // 00:00:00.000
+      Timestamp::fromMillis(-86400000 - 3661000), // 1 day + 1:01:01 before
+                                                  // epoch -> 22:58:59.000
+  };
+
+  std::vector<std::optional<int64_t>> expectedNegativeTime = {
+      86399999, // 23:59:59.999
+      82800000, // 23:00:00.000 (86400000 - 3600000)
+      0, // 00:00:00.000
+      82739000, // 22:58:59.000
+  };
+
+  testCast(TIMESTAMP(), TIME(), negativeTimestamps, expectedNegativeTime);
+
+  // Test specific timestamps that span multiple days
+  std::vector<std::optional<Timestamp>> realTimestamps = {
+      parseTimestamp("2023-05-15 14:30:45.123"),
+      parseTimestamp("1990-01-01 08:15:30.500"),
+      parseTimestamp("2050-12-31 23:59:59.999"),
+  };
+
+  std::vector<std::optional<int64_t>> expectedRealTime = {
+      14 * 3600000 + 30 * 60000 + 45 * 1000 + 123, // 14:30:45.123
+      8 * 3600000 + 15 * 60000 + 30 * 1000 + 500, // 08:15:30.500
+      23 * 3600000 + 59 * 60000 + 59 * 1000 + 999, // 23:59:59.999
+  };
+
+  testCast(TIMESTAMP(), TIME(), realTimestamps, expectedRealTime);
+}
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/expression/tests/CoalesceRewriteTest.cpp b/velox/expression/tests/CoalesceRewriteTest.cpp
new file mode 100644
index 000000000000..40ade8887b03
--- /dev/null
+++ b/velox/expression/tests/CoalesceRewriteTest.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/expression/tests/SpecialFormRewriteTestBase.h"
+
+namespace facebook::velox::expression {
+namespace {
+
+class CoalesceRewriteTest
+    : public expression::test::SpecialFormRewriteTestBase {};
+
+TEST_F(CoalesceRewriteTest, basic) {
+  auto type = ROW({"a", "b"}, {BIGINT(), BIGINT()});
+  testRewrite("coalesce(null::bigint, 1, a)", "1", type);
+  testRewrite(
+      "coalesce(null::bigint, 6 * a, 5 * b, 1, null::bigint)",
+      "coalesce(6 * a, 5 * b, 1)",
+      type);
+  testRewrite(
+      "coalesce(null::bigint, coalesce(null::bigint, a, coalesce(1, b)))",
+      "coalesce(a, 1)",
+      type);
+  testRewrite("coalesce(a, null::bigint, a)", "a", type);
+  testRewrite(
+      "coalesce(a, b, a, coalesce(coalesce(b, a), b))", "coalesce(a, b)", type);
+  testRewrite(
+      "coalesce(a, coalesce(2, coalesce(b, a)), b)", "coalesce(a, 2)", type);
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/ConjunctRewriteTest.cpp b/velox/expression/tests/ConjunctRewriteTest.cpp
new file mode 100644
index 000000000000..6c288ded8731
--- /dev/null
+++ b/velox/expression/tests/ConjunctRewriteTest.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 <gtest/gtest.h>
+
+#include "velox/expression/tests/SpecialFormRewriteTestBase.h"
+
+namespace facebook::velox::expression {
+namespace {
+
+class ConjunctRewriteTest
+    : public expression::test::SpecialFormRewriteTestBase {};
+
+TEST_F(ConjunctRewriteTest, basic) {
+  const auto type = ROW({"a", "b"}, {VARCHAR(), BIGINT()});
+  testRewrite(
+      "null::boolean and a = 'z' and true", "null::boolean and a = 'z'", type);
+  testRewrite(
+      "a = 'z' or null::boolean or false", "a = 'z' or null::boolean", type);
+  testRewrite("true and a = 'z' and true", "a = 'z'", type);
+  testRewrite("false or a = 'z' or false", "a = 'z'", type);
+  testRewrite("a = 'z' and b = 2 and false", "false", type);
+  testRewrite("((a = 'z' and b = 2) and false)", "false", type);
+  testRewrite("a = 'z' or b = 2 or true", "true", type);
+  testRewrite("(a = 'z' or (b = 2 or true))", "true", type);
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/ConjunctTest.cpp b/velox/expression/tests/ConjunctTest.cpp
index 280180664c27..b4e6b4e4d14a 100644
--- a/velox/expression/tests/ConjunctTest.cpp
+++ b/velox/expression/tests/ConjunctTest.cpp
@@ -103,3 +103,18 @@ TEST_F(ConjunctTest, constant) {
         plan, "select c0, c1, c2, if (c0 < 9, c1 and c2, c1 or c2) from tmp");
   }
 }
+
+TEST_F(ConjunctTest, notOperator) {
+  auto data = makeRowVector(
+      {makeFlatVector<int32_t>(10, [](auto row) { return row; }),
+       makeFlatVector<bool>(
+           10,
+           [](auto row) { return row % 2 == 0; },
+           [](auto row) { return row == 5; })});
+
+  auto plan =
+      PlanBuilder().values({data}).project({"c0", "c1", "not c1"}).planNode();
+  createDuckDbTable({data});
+
+  assertQuery(plan, "select c0, c1, not c1 from tmp");
+}
diff --git a/velox/expression/tests/CustomTypeTest.cpp b/velox/expression/tests/CustomTypeTest.cpp
index dd92c83a2dca..c4a712aa4156 100644
--- a/velox/expression/tests/CustomTypeTest.cpp
+++ b/velox/expression/tests/CustomTypeTest.cpp
@@ -20,6 +20,8 @@
 #include "velox/functions/Macros.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/SfmSketchRegistration.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/type/OpaqueCustomTypes.h"
 
 namespace facebook::velox::test {
@@ -34,14 +36,12 @@ struct FancyInt {
 };
 
 class FancyIntType : public OpaqueType {
-  FancyIntType() : OpaqueType(std::type_index(typeid(FancyInt))) {}
+  FancyIntType() : OpaqueType{std::type_index(typeid(FancyInt))} {}
 
  public:
-  static const std::shared_ptr<const FancyIntType>& get() {
-    static const std::shared_ptr<const FancyIntType> instance{
-        new FancyIntType()};
-
-    return instance;
+  static std::shared_ptr<const FancyIntType> get() {
+    static const FancyIntType kInstance;
+    return {std::shared_ptr<const FancyIntType>{}, &kInstance};
   }
 
   std::string toString() const override {
@@ -53,7 +53,7 @@ class FancyIntType : public OpaqueType {
   }
 };
 
-class FancyIntTypeFactories : public CustomTypeFactories {
+class FancyIntTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -144,7 +144,7 @@ struct FancyPlusFunction {
   }
 };
 
-class AlwaysFailingTypeFactories : public CustomTypeFactories {
+class AlwaysFailingTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -167,11 +167,11 @@ class AlwaysFailingTypeFactories : public CustomTypeFactories {
 /// simple function that takes and returns this type. Verify function signatures
 /// and evaluate some expressions.
 TEST_F(CustomTypeTest, customType) {
-  ASSERT_TRUE(registerCustomType(
-      "fancy_int", std::make_unique<FancyIntTypeFactories>()));
+  ASSERT_TRUE(
+      registerCustomType("fancy_int", std::make_unique<FancyIntTypeFactory>()));
 
-  ASSERT_FALSE(registerCustomType(
-      "fancy_int", std::make_unique<AlwaysFailingTypeFactories>()));
+  ASSERT_FALSE(
+      registerCustomType("fancy_int", std::make_unique<FancyIntTypeFactory>()));
 
   registerFunction<FancyPlusFunction, TheFancyInt, TheFancyInt, TheFancyInt>(
       {"fancy_plus"});
@@ -221,44 +221,46 @@ TEST_F(CustomTypeTest, customType) {
 }
 
 TEST_F(CustomTypeTest, getCustomTypeNames) {
-  auto names = getCustomTypeNames();
-  ASSERT_EQ(
-      (std::unordered_set<std::string>{
-          "JSON",
-          "HYPERLOGLOG",
-          "TIMESTAMP WITH TIME ZONE",
-          "UUID",
-          "IPADDRESS",
-          "IPPREFIX",
-          "BINGTILE",
-          "TDIGEST",
-          "GEOMETRY"}),
-      names);
-
-  ASSERT_TRUE(registerCustomType(
-      "fancy_int", std::make_unique<FancyIntTypeFactories>()));
-
-  names = getCustomTypeNames();
-  ASSERT_EQ(
-      (std::unordered_set<std::string>{
-          "JSON",
-          "HYPERLOGLOG",
-          "TIMESTAMP WITH TIME ZONE",
-          "UUID",
-          "IPADDRESS",
-          "IPPREFIX",
-          "BINGTILE",
-          "FANCY_INT",
-          "TDIGEST",
-          "GEOMETRY"}),
-      names);
+  // SFMSKETCH is a newly registered custom type, unlike others,
+  // registerSfmSketchType() is not called in the constructor of CustomTypeTest,
+  // so we explicitly call it here.
+  registerSfmSketchType();
+
+  auto expectedTypes = std::unordered_set<std::string>{
+      "JSON",
+      "HYPERLOGLOG",
+      "KHYPERLOGLOG",
+      "TIMESTAMP WITH TIME ZONE",
+      "UUID",
+      "IPADDRESS",
+      "IPPREFIX",
+      "BINGTILE",
+      "TDIGEST",
+      "QDIGEST",
+      "SETDIGEST",
+      "SFMSKETCH",
+      "BIGINT_ENUM",
+      "VARCHAR_ENUM",
+      "P4HYPERLOGLOG",
+      "TIME WITH TIME ZONE"};
+#ifdef VELOX_ENABLE_GEO
+  expectedTypes.insert("GEOMETRY");
+  expectedTypes.insert("SPHERICALGEOGRAPHY");
+#endif
+  ASSERT_EQ(expectedTypes, getCustomTypeNames());
+
+  ASSERT_TRUE(
+      registerCustomType("fancy_int", std::make_unique<FancyIntTypeFactory>()));
+  expectedTypes.insert("FANCY_INT");
+
+  ASSERT_EQ(expectedTypes, getCustomTypeNames());
 
   ASSERT_TRUE(unregisterCustomType("fancy_int"));
 }
 
 TEST_F(CustomTypeTest, nullConstant) {
-  ASSERT_TRUE(registerCustomType(
-      "fancy_int", std::make_unique<FancyIntTypeFactories>()));
+  ASSERT_TRUE(
+      registerCustomType("fancy_int", std::make_unique<FancyIntTypeFactory>()));
   auto checkNullConstant = [&](const TypePtr& type,
                                const std::string& expectedTypeString) {
     auto null = BaseVector::createNullConstant(type, 10, pool());
@@ -275,6 +277,26 @@ TEST_F(CustomTypeTest, nullConstant) {
     if (name == "TDIGEST") {
       auto type = getCustomType(name, {TypeParameter(DOUBLE())});
       checkNullConstant(type, "TDIGEST(DOUBLE)");
+    } else if (name == "QDIGEST") {
+      for (const auto& parameter :
+           std::vector<TypePtr>{BIGINT(), DOUBLE(), REAL()}) {
+        auto type = getCustomType(name, {TypeParameter(parameter)});
+        checkNullConstant(
+            type, fmt::format("QDIGEST({})", parameter->toString()));
+      }
+    } else if (name == "BIGINT_ENUM") {
+      LongEnumParameter moodInfo(
+          "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
+      auto type = getCustomType(name, {TypeParameter(moodInfo)});
+      checkNullConstant(
+          type, "test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0})");
+    } else if (name == "VARCHAR_ENUM") {
+      VarcharEnumParameter colorInfo(
+          "test.enum.color", {{"RED", "red"}, {"BLUE", "blue"}});
+      auto type = getCustomType(name, {TypeParameter(colorInfo)});
+      checkNullConstant(
+          type,
+          "test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"})");
     } else {
       auto type = getCustomType(name, {});
       checkNullConstant(type, type->toString());
@@ -382,4 +404,62 @@ TEST_F(CustomTypeTest, testOpaqueCustomTypeAutoCreation) {
           "reduce_tuple(make_tuple_untyped(c0, c0))", makeRowVector({data})),
       "");
 }
+
+template <typename T>
+struct TimeWithTimezonePlusOneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(
+      out_type<TimeWithTimezone>& out,
+      const arg_type<TimeWithTimezone>& input) {
+    out = *input + 1;
+  }
+};
+
+template <typename T>
+struct ArrayTimeWithTimezoneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(
+      out_type<Array<TimeWithTimezone>>& out,
+      const arg_type<Array<TimeWithTimezone>>& input) {
+    for (int i = 0; i < input.size(); i++) {
+      if (input[i].has_value()) {
+        out.push_back(*input[i].value());
+      }
+    }
+  }
+};
+
+TEST_F(CustomTypeTest, timeWithTimezoneTypeTest) {
+  registerFunction<
+      TimeWithTimezonePlusOneFunction,
+      TimeWithTimezone,
+      TimeWithTimezone>({"time_with_timezone_plus_one"});
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1000, 2000, 3000}, TIME_WITH_TIME_ZONE()),
+  });
+  auto result = evaluate("time_with_timezone_plus_one(c0)", data);
+  auto expected =
+      makeFlatVector<int64_t>({1001, 2001, 3001}, TIME_WITH_TIME_ZONE());
+  assertEqualVectors(expected, result);
+
+  // Test out TimeWithTimezone in complex type.
+  {
+    registerFunction<
+        ArrayTimeWithTimezoneFunction,
+        Array<TimeWithTimezone>,
+        Array<TimeWithTimezone>>({"array_time_with_timezone"});
+
+    auto data = makeRowVector({
+        makeArrayVector<int64_t>(
+            {{1000, 2000, 3000}, {4000, 5000, 6000}}, TIME_WITH_TIME_ZONE()),
+    });
+
+    auto result = evaluate("array_time_with_timezone(c0)", data);
+    auto expected = makeArrayVector<int64_t>(
+        {{1000, 2000, 3000}, {4000, 5000, 6000}}, TIME_WITH_TIME_ZONE());
+    assertEqualVectors(expected, result);
+  }
+}
 } // namespace facebook::velox::test
diff --git a/velox/expression/tests/EvalCtxTest.cpp b/velox/expression/tests/EvalCtxTest.cpp
index 5c21e2af5f65..30a864b1c916 100644
--- a/velox/expression/tests/EvalCtxTest.cpp
+++ b/velox/expression/tests/EvalCtxTest.cpp
@@ -96,13 +96,17 @@ TEST_F(EvalCtxTest, vectorRecycler) {
   auto newVector = context.getVector(BIGINT(), 1'00);
   ASSERT_EQ(newVector.get(), vectorPtr);
   vector.reset();
-  { VectorRecycler vectorRecycler(vector, context.vectorPool()); }
+  {
+    VectorRecycler vectorRecycler(vector, context.vectorPool());
+  }
 
   // Hold the allocated vector on scoped vector destruction.
   vector = context.getVector(BIGINT(), 1'00);
   ASSERT_NE(vector.get(), newVector.get());
   newVector = vector;
-  { VectorRecycler vectorRecycler(vector, context.vectorPool()); }
+  {
+    VectorRecycler vectorRecycler(vector, context.vectorPool());
+  }
   vector = context.getVector(BIGINT(), 1'00);
   ASSERT_NE(vector.get(), newVector.get());
 }
diff --git a/velox/expression/tests/ExprCompilerTest.cpp b/velox/expression/tests/ExprCompilerTest.cpp
index e541a270f9b8..626cd19f54b6 100644
--- a/velox/expression/tests/ExprCompilerTest.cpp
+++ b/velox/expression/tests/ExprCompilerTest.cpp
@@ -15,11 +15,11 @@
  */
 #include "gtest/gtest.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.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"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -49,15 +49,13 @@ class ExprCompilerTest : public testing::Test,
   core::TypedExprPtr andCall(
       const core::TypedExprPtr& a,
       const core::TypedExprPtr& b) {
-    return std::make_shared<core::CallTypedExpr>(
-        BOOLEAN(), std::vector<core::TypedExprPtr>{a, b}, "and");
+    return std::make_shared<core::CallTypedExpr>(BOOLEAN(), "and", a, b);
   }
 
   core::TypedExprPtr orCall(
       const core::TypedExprPtr& a,
       const core::TypedExprPtr& b) {
-    return std::make_shared<core::CallTypedExpr>(
-        BOOLEAN(), std::vector<core::TypedExprPtr>{a, b}, "or");
+    return std::make_shared<core::CallTypedExpr>(BOOLEAN(), "or", a, b);
   }
 
   core::TypedExprPtr concatCall(
@@ -89,6 +87,10 @@ class ExprCompilerTest : public testing::Test,
     return std::make_shared<core::ConstantTypedExpr>(VARCHAR(), variant(value));
   }
 
+  core::TypedExprPtr double_(double value) {
+    return std::make_shared<core::ConstantTypedExpr>(DOUBLE(), value);
+  }
+
   std::function<core::TypedExprPtr(const std::string& name)> makeField(
       const RowTypePtr& rowType) {
     return [&](const std::string& name) -> core::TypedExprPtr {
@@ -195,12 +197,10 @@ TEST_F(ExprCompilerTest, concatStringFlattening) {
       {field("a"), concatCall({field("b"), field("c")}), field("d")});
   ASSERT_EQ("concat(a, b, c, d)", compile(expression)->toString());
 
-  // Constant folding happens after flattening.
+  // Inner concatCall is constant folded during expression compilation.
   expression = concatCall(
       {field("a"), concatCall({varchar("---"), varchar("...")}), field("b")});
-  ASSERT_EQ(
-      "concat(a, ---:VARCHAR, ...:VARCHAR, b)",
-      compile(expression)->toString());
+  ASSERT_EQ("concat(a, ---...:VARCHAR, b)", compile(expression)->toString());
 }
 
 TEST_F(ExprCompilerTest, concatArrayFlattening) {
@@ -252,9 +252,7 @@ TEST_F(ExprCompilerTest, concatArrayFlattening) {
 
 TEST_F(ExprCompilerTest, functionNameNotRegistered) {
   auto expression = std::make_shared<core::CallTypedExpr>(
-      VARCHAR(),
-      std::vector<core::TypedExprPtr>{varchar("---"), varchar("...")},
-      "not_registered_function");
+      VARCHAR(), "not_registered_function", varchar("---"), varchar("..."));
 
   VELOX_ASSERT_THROW(
       compile(expression),
@@ -294,12 +292,13 @@ TEST_F(ExprCompilerTest, rewrites) {
   auto arraySortSql =
       "array_sort(c0, (x, y) -> if(length(x) < length(y), -1, if(length(x) > length(y), 1, 0)))";
 
-  ASSERT_NO_THROW(std::make_unique<ExprSet>(
-      std::vector<core::TypedExprPtr>{
-          makeTypedExpr(arraySortSql, rowType),
-          makeTypedExpr("c1 + 5", rowType),
-      },
-      execCtx_.get()));
+  ASSERT_NO_THROW(
+      std::make_unique<ExprSet>(
+          std::vector<core::TypedExprPtr>{
+              makeTypedExpr(arraySortSql, rowType),
+              makeTypedExpr("c1 + 5", rowType),
+          },
+          execCtx_.get()));
 
   auto exprSet = compile(makeTypedExpr(
       "reduce(c0, 1, (s, x) -> s + x * 2, s -> s)",
@@ -355,4 +354,93 @@ TEST_F(ExprCompilerTest, lambdaExpr) {
   ASSERT_EQ(distinctFields.size(), 2);
 }
 
+TEST_F(ExprCompilerTest, exprDeduplication) {
+  auto testExprDedup = [&](const core::TypedExprPtr& expression,
+                           bool shouldDedup,
+                           bool expectDedup,
+                           const std::string& description) {
+    std::unordered_map<std::string, std::string> configData(
+        {{core::QueryConfig::kExprDedupNonDeterministic,
+          shouldDedup ? "true" : "false"}});
+    auto queryCtx = velox::core::QueryCtx::create(
+        nullptr, core::QueryConfig(std::move(configData)));
+    auto execCtx = std::make_unique<core::ExecCtx>(pool_.get(), queryCtx.get());
+
+    auto exprSet = std::make_unique<ExprSet>(
+        std::vector<core::TypedExprPtr>{expression}, execCtx.get());
+
+    ASSERT_EQ(exprSet->size(), 1);
+    auto& expr = exprSet->expr(0);
+    auto& leftInput = expr->inputs()[0];
+    auto& rightInput = expr->inputs()[1];
+
+    if (expectDedup) {
+      EXPECT_EQ(leftInput.get(), rightInput.get()) << description;
+    } else {
+      EXPECT_NE(leftInput.get(), rightInput.get()) << description;
+    }
+  };
+
+  // Test deterministic expressions - should always be deduplicated regardless
+  // of config
+  auto rowType = ROW({"c0"}, {BIGINT()});
+  auto deterministicExpr = call(
+      "plus",
+      {call("plus", {makeField(rowType)("c0"), bigint(1)}),
+       call("plus", {makeField(rowType)("c0"), bigint(1)})});
+
+  testExprDedup(
+      deterministicExpr,
+      true,
+      true,
+      "Deterministic expressions should be deduplicated when config is true");
+  testExprDedup(
+      deterministicExpr,
+      false,
+      true,
+      "Deterministic expressions should always be deduplicated regardless of config");
+
+  // Test non-deterministic expressions - behavior depends on config
+  auto nonDeterministicExpr =
+      call("plus", {call("rand", {}), call("rand", {})});
+
+  testExprDedup(
+      nonDeterministicExpr,
+      true,
+      true,
+      "Non-deterministic expressions should be deduplicated when config is true");
+  testExprDedup(
+      nonDeterministicExpr,
+      false,
+      false,
+      "Non-deterministic expressions should NOT be deduplicated when config is false");
+}
+
+TEST_F(ExprCompilerTest, simpleFunctionMemoryPool) {
+  // Test that MemoryPool is correctly passed through ExprCompiler to
+  // SimpleFunctions that have initialize() with memoryPool parameter.
+  // empty_approx_set() creates an HLL sketch.
+  auto expression = call("empty_approx_set", {});
+  auto exprSet = compile(expression);
+  ASSERT_EQ(exprSet->size(), 1);
+
+  auto input = makeRowVector(ROW({}, {}), 1);
+  SelectivityVector rows(1);
+  EvalCtx evalCtx(execCtx_.get(), exprSet.get(), input.get());
+  std::vector<VectorPtr> results(1);
+  exprSet->eval(rows, evalCtx, results);
+
+  // Verify result - eval should create the vector
+  ASSERT_TRUE(results[0] != nullptr) << "Result vector was not created";
+  ASSERT_EQ(results[0]->size(), 1) << "Result vector has wrong size";
+  ASSERT_FALSE(results[0]->isNullAt(0));
+
+  // empty_approx_set() returns a constant.
+  DecodedVector decoded(*results[0], rows);
+  ASSERT_FALSE(decoded.isNullAt(0)) << "Decoded result is null";
+
+  auto stringView = decoded.valueAt<StringView>(0);
+  ASSERT_GT(stringView.size(), 0) << "HLL sketch is empty";
+}
+
 } // namespace facebook::velox::exec::test
diff --git a/velox/expression/tests/ExprEncodingsTest.cpp b/velox/expression/tests/ExprEncodingsTest.cpp
index 28d573bfaeef..cb5822829295 100644
--- a/velox/expression/tests/ExprEncodingsTest.cpp
+++ b/velox/expression/tests/ExprEncodingsTest.cpp
@@ -490,7 +490,7 @@ class ExprEncodingsTest
         execCtx_->pool(),
         vector->type(),
         vector->size(),
-        std::make_unique<SimpleVectorLoader>([=](RowSet /*rows*/) {
+        std::make_unique<SimpleVectorLoader>([=, this](RowSet /*rows*/) {
           auto indices =
               makeIndices(vector->size(), [](auto row) { return row; });
           return wrapInDictionary(indices, vector->size(), vector);
diff --git a/velox/expression/tests/ExprOptimizerTest.cpp b/velox/expression/tests/ExprOptimizerTest.cpp
new file mode 100644
index 000000000000..fbc7a4de8947
--- /dev/null
+++ b/velox/expression/tests/ExprOptimizerTest.cpp
@@ -0,0 +1,383 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/expression/ExprOptimizer.h"
+#include "velox/expression/ExprRewriteRegistry.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/functions/prestosql/types/TimestampWithTimeZoneType.h"
+
+namespace facebook::velox::expression {
+namespace {
+
+class ExprOptimizerTest : public functions::test::FunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    functions::prestosql::registerAllScalarFunctions("");
+    parse::registerTypeResolver();
+    options_.parseDecimalAsDouble = false;
+  }
+
+  void TearDown() override {
+    expression::ExprRewriteRegistry::instance().clear();
+  }
+
+  /// Validates expression::optimize API. The input expression is optimized and
+  /// then evaluated with a randomly generated input vector.
+  /// @param input String representation of input SQL expression to be
+  /// optimized.
+  /// @param expected String representation of expected SQL expression after
+  /// optimization of `input`.
+  /// @param type Type of `input` and `expected`.
+  /// @param makeFailExpr Callback that returns an expression to replace any
+  /// failing subexpression(s) during optimization of `input`.
+  /// @param evalError Expected error message upon evaluating optimized `input`.
+  /// Should be used iff `makeFailExpr` returns an expression that throws upon
+  /// evaluation (eg: Presto `fail` function).
+  void testExpression(
+      const std::string& input,
+      const std::string& expected,
+      const RowTypePtr& type = ROW({}),
+      const MakeFailExpr& makeFailExpr = nullptr,
+      const std::string& evalError = "") {
+    const auto typedExpr = makeTypedExpr(input, type);
+    auto optimized =
+        expression::optimize(typedExpr, queryCtx_.get(), pool(), makeFailExpr);
+    const auto expectedTypedExpr = makeTypedExpr(expected, type);
+    SCOPED_TRACE(
+        fmt::format(
+            "Input: {}\nOptimized: {}\nExpected: {}",
+            typedExpr->toString(),
+            optimized->toString(),
+            expectedTypedExpr->toString()));
+    ASSERT_TRUE(*optimized == *expectedTypedExpr);
+
+    // Generate random values with fuzzer to validate evaluation of optimized
+    // expression.
+    const auto data = fuzzFlat(type);
+    if (makeFailExpr != nullptr && !evalError.empty()) {
+      VELOX_ASSERT_THROW(evaluate(optimized, data), evalError);
+    } else {
+      const auto optimizedResult = evaluate(optimized, data);
+      const auto expectedResult = evaluate(expectedTypedExpr, data);
+      test::assertEqualVectors(optimizedResult, expectedResult);
+    }
+  }
+
+  void setQueryTimeZone(const std::string& timeZone) {
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kSessionTimezone, timeZone},
+         {core::QueryConfig::kAdjustTimestampToTimezone, "true"}});
+  }
+
+ private:
+  RowVectorPtr fuzzFlat(const RowTypePtr& rowType) {
+    VectorFuzzer::Options options;
+    options.vectorSize = 100;
+    VectorFuzzer fuzzer(options, pool());
+    return fuzzer.fuzzInputFlatRow(rowType);
+  }
+
+  std::shared_ptr<core::QueryCtx> queryCtx_{core::QueryCtx::create()};
+  std::unique_ptr<core::ExecCtx> execCtx_{
+      std::make_unique<core::ExecCtx>(pool_.get(), queryCtx_.get())};
+  parse::ParseOptions options_;
+};
+
+TEST_F(ExprOptimizerTest, constantFolding) {
+  // comparison.
+  testExpression("'a' = substr('abc', 1, 1)", "true");
+  testExpression("'a' = cast(null as varchar)", "cast(null AS BOOLEAN)");
+  testExpression(
+      "cast((12345678901234567890.000 + 0.123) AS DECIMAL(23, 3)) = cast(12345678901234567890.123 AS DECIMAL(23, 3))",
+      "true");
+  testExpression("'0ab01c' LIKE '%ab%c%'", "true");
+  testExpression("3 between (4 - 2) and 2 * 2", "true");
+  testExpression(
+      "3 between cast(null AS BIGINT) and 4", "cast(null AS BOOLEAN)");
+  testExpression("IF(2 = 2, 3, 4)", "3");
+  testExpression("IF(cast(null AS BOOLEAN), 3, 4)", "4");
+  testExpression("IF('hello' = 'foo', cast(null AS BIGINT), 4)", "4");
+  testExpression(
+      "IF('hello' = 'hello', cast(null AS BIGINT), 4)", "cast(null AS BIGINT)");
+  testExpression("random() = random()", "random() = random()");
+  testExpression("current_date() = current_date()", "true");
+
+  // cast.
+  testExpression("cast('-123' as BIGINT)", "-123");
+  testExpression("cast(DECIMAL '1234567890.123' as BIGINT)", "1234567890");
+  testExpression("cast('t' as BOOLEAN)", "true");
+  testExpression("cast('f' as BOOLEAN)", "false");
+  testExpression("cast('1' as BOOLEAN)", "true");
+  testExpression("cast('0' as BOOLEAN)", "false");
+  testExpression("cast(-123.456E0 as VARCHAR)", "'-123.456'");
+  testExpression("cast(cast('abcxyz' as VARCHAR) as VARCHAR)", "'abcxyz'");
+
+  // Partial constant folding in expression tree.
+  testExpression(
+      "1234 between a and 2000 + 1",
+      "1234 between a and 2001",
+      ROW({"a"}, {BIGINT()}));
+  testExpression(
+      "concat(substr(a, 1 + 5 - 2), substr(b, 2 * 3))",
+      "concat(substr(a, 4), substr(b, 6))",
+      ROW({"a", "b"}, {VARCHAR(), VARCHAR()}));
+  testExpression(
+      "a = 'z' and b = (1 + 1) or c = (5 - 1) * 3",
+      "a = 'z' and b = 2 or c = 12",
+      ROW({"a", "b", "c"}, {VARCHAR(), BIGINT(), INTEGER()}));
+}
+
+TEST_F(ExprOptimizerTest, specialFormConstantFolding) {
+  // AND, OR.
+  testExpression("true and true", "true");
+  testExpression("false or false", "false");
+  testExpression("null::boolean and false", "false");
+  testExpression("true or null::boolean", "true");
+  testExpression(
+      "null::boolean and null::boolean and null::boolean", "null::boolean");
+  testExpression(
+      "null::boolean or null::boolean or null::boolean", "null::boolean");
+  testExpression("null::boolean and true", "null::boolean");
+  testExpression("false or null::boolean", "null::boolean");
+
+  // IF, SWITCH.
+  testExpression("if(true, 'hello', 'world')", "'hello'");
+  testExpression("case when false then 1 when true then 3 end", "3");
+  testExpression(
+      "case when false then 1 when false then 3 end", "null::bigint");
+  testExpression("case when false then 1 when false then 3 else 2 end", "2");
+  testExpression(
+      "case when false then 'hello' when false then 'world' when true then 'foo' else 'bar' end",
+      "'foo'");
+}
+
+TEST_F(ExprOptimizerTest, lambdas) {
+  auto type = ROW({"a"}, {ARRAY(BIGINT())});
+  testExpression(
+      "filter(a, (x) -> abs(x + (1 + 2)) = (6 / 2))",
+      "filter(a, (x) -> abs(x + 3) = 3)",
+      type);
+  testExpression(
+      "filter(a, (x) -> 1 * (4 / 2) = abs(-4 * 3))",
+      "filter(a, (x) -> false)",
+      type);
+  type = ROW({"a"}, {ARRAY(VARCHAR())});
+  testExpression(
+      "filter(a, (x) -> length(x) + (3 - 2) = 4 / 2)",
+      "filter(a, (x) -> length(x) + 1 = 2)",
+      type);
+  testExpression(
+      "array_sort(a, x -> length(x) * abs(-1 * 3 * 2))",
+      "array_sort(a, x -> length(x) * 6)",
+      type);
+  testExpression(
+      "reduce(c0, (89.0E0 + 11.0E0), (s, x) -> s + x * (0.2E0 - 0.1E0), s -> (s < (100.0E0 + 1.0E0)))",
+      "reduce(c0, 100.0E0, (s, x) -> s + x * 0.1E0, s -> (s < 101.0E0))",
+      ROW({"c0"}, {ARRAY(DOUBLE())}));
+  testExpression(
+      "reduce(c0, 1 - 1, (s, x) -> s + x, s -> coalesce(s, abs(2 - 10)) * (5 * 2))",
+      "reduce(c0, 0, (s, x) -> s + x, s -> coalesce(s, 8) * 10)",
+      ROW({"c0"}, {ARRAY(SMALLINT())}));
+}
+
+TEST_F(ExprOptimizerTest, rewritesWithConstantFolding) {
+  auto type = ROW({"c0"}, {ARRAY(VARCHAR())});
+  testExpression(
+      "array_sort(c0, (x, y) -> if(length(x) < length(y), (-1 * 1), if(length(x) = length(y), abs(0), (2 / 2))))",
+      "array_sort(c0, x -> length(x))",
+      type);
+  testExpression(
+      "array_sort(c0, (x, y) -> if(length(x) < length(y), abs(-1), if(length(x) > length(y), -4 / 3, 0 / 3)))",
+      "array_sort_desc(c0, x -> length(x))",
+      type);
+
+  testExpression(
+      "reduce(c0, 8 / 2, (s, x) -> if(x % 2 = 0, s + 1, s), s -> s)",
+      "4 + cast(array_sum_propagate_element_null(transform(c0, x -> if(x % 2 = 0, 1, 0))) AS BIGINT)",
+      ROW({"c0"}, {ARRAY(INTEGER())}));
+  testExpression(
+      "reduce(c0, length(concat('abc', 'xyz')) * 3, (s, x) -> s + (abs(-2) + (5 - 4)) - x, s -> s)",
+      "18 + cast(array_sum_propagate_element_null(transform(c0, x -> 3 - x)) AS BIGINT)",
+      ROW({"c0"}, {ARRAY(TINYINT())}));
+
+  // Conjunct rewrites with constant folding.
+  type = ROW({"a"}, {ARRAY(BIGINT())});
+  testExpression("if(array_position(a, 1) > 10 and false, 0, 1)", "1", type);
+  testExpression("if(cardinality(a) > 10 or true, 0, 1)", "0", type);
+  testExpression(
+      "filter(a, x -> (2 * 3) = x and abs(-4) = (3 - 1))",
+      "filter(a, x -> false)",
+      type);
+  testExpression(
+      "filter(a, x -> (2 * 3) = x or (8 / 2) = (3 + 1))",
+      "filter(a, x -> true)",
+      type);
+
+  // Switch rewrite with constant folding.
+  testExpression(
+      "case when ARRAY[abs(-1)] = ARRAY[2] then 'not_matched' when ARRAY[1] = ARRAY[2 - 1] then 'matched' else 'default' end",
+      "'matched'");
+  testExpression(
+      "case when 10 + a = 100 / 2 then 10 - 2 when a / (2 + 1) = abs(-5) then 10 * 10 when (123 * 10) + 4 = abs(-1234) then 11 * 3 else a end",
+      "case when 10 + a = 50 then 8 when a / 3 = 5 then 100 else 33 end",
+      ROW({"a"}, {BIGINT()}));
+
+  // Coalesce rewrite with constant folding.
+  type = ROW({"a", "b"}, {BIGINT(), BIGINT()});
+  testExpression(
+      "coalesce(a - (4 / 2), a - (1 * 2), null::bigint, 1 - 1, b, null::bigint)",
+      "coalesce(a - 2, 0)",
+      type);
+  testExpression(
+      "coalesce(null::bigint, a / abs(-2 * 3), coalesce(coalesce(b, 8 / 2), a * b), b)",
+      "coalesce(a / 6, b, 4)",
+      type);
+}
+
+/// Test to ensure session queryCtx is used during expression optimization.
+TEST_F(ExprOptimizerTest, queryCtx) {
+  auto testFromUnixtime = [&](const std::string& function,
+                              const std::string& timezone,
+                              const std::string& expected) {
+    setQueryTimeZone(timezone);
+    testExpression(
+        fmt::format("{}(from_unixtime(9.98489045321E8))", function), expected);
+  };
+
+  testFromUnixtime("hour", "Pacific/Apia", "3");
+  testFromUnixtime("hour", "America/Los_Angeles", "7");
+  testFromUnixtime("minute", "Pacific/Apia", "4");
+  testFromUnixtime("minute", "America/Los_Angeles", "4");
+}
+
+/// Test cast optimization that avoids expression evaluation when input to
+/// cast is same as the type of cast expression.
+TEST_F(ExprOptimizerTest, castExpr) {
+  auto testCast = [&](const TypePtr& type, const std::string& typeString = "") {
+    const auto rowType = ROW({"a"}, {type});
+    if (type->isPrimitiveType()) {
+      testExpression(
+          fmt::format("cast(a as {})", type->toString()), "a", rowType);
+    } else {
+      testExpression(fmt::format("cast(a as {})", typeString), "a", rowType);
+    }
+  };
+
+  // Primitive types.
+  std::vector<TypePtr> primitiveTypes = {
+      TINYINT(),
+      SMALLINT(),
+      INTEGER(),
+      BIGINT(),
+      DOUBLE(),
+      REAL(),
+      VARBINARY(),
+      VARCHAR(),
+      DECIMAL(5, 2),
+      DECIMAL(25, 10),
+      DATE(),
+      TIMESTAMP_WITH_TIME_ZONE()};
+  for (const auto& type : primitiveTypes) {
+    testCast(type);
+  }
+
+  // Complex types.
+  testCast(ARRAY(DATE()), "DATE[]");
+  testCast(MAP(DOUBLE(), VARCHAR()), "map(DOUBLE, VARCHAR)");
+  testCast(
+      ROW({"c0", "c1", "c2"},
+          {BIGINT(), DECIMAL(5, 2), TIMESTAMP_WITH_TIME_ZONE()}),
+      "struct(c0 BIGINT, c1 DECIMAL(5, 2), c2 TIMESTAMP WITH TIME ZONE)");
+
+  // Functions.
+  auto type = ROW({"a"}, {VARCHAR()});
+  testExpression(
+      "cast(concat(a, 'test') as VARCHAR)", "concat(a, 'test')", type);
+  testExpression(
+      "cast(substr(a, abs(-2) * (3 / 1)) as VARCHAR)", "substr(a, 6)", type);
+  testExpression(
+      "cast((a = (5 / 1) * abs(-3)) as BOOLEAN) and cast((b = concat('hello', 'world')) as BOOLEAN)",
+      "a = 15 and b = 'helloworld'",
+      ROW({"a", "b"}, {BIGINT(), VARCHAR()}));
+}
+
+/// Test to validate `makeFailExpr` returns an expression that replaces all
+/// failing subexpressions in the expression tree.
+TEST_F(ExprOptimizerTest, makeFailExpr) {
+  const auto divideByZeroError = "division by zero";
+  auto assertPrestoFailExpr = [&](const std::string& expression,
+                                  const std::string& expected,
+                                  const RowTypePtr& type) {
+    const static MakeFailExpr prestoFailExpr =
+        [&](const std::string& error,
+            const TypePtr& type) -> core::TypedExprPtr {
+      return makeTypedExpr(
+          fmt::format("cast(fail('{}') AS {})", error, type->toString()),
+          ROW({}));
+    };
+    testExpression(
+        expression, expected, type, prestoFailExpr, divideByZeroError);
+  };
+  auto prestoFailCall = [&]() {
+    return fmt::format("cast(fail('{}') AS BIGINT)", divideByZeroError);
+  };
+
+  // Primitive types.
+  assertPrestoFailExpr("0 / 0", prestoFailCall(), ROW({}));
+  assertPrestoFailExpr(
+      "if(a = 2 * 2, a / abs(-1 * 3), 0 / 0)",
+      fmt::format("if(a = 4, a / 3, {})", prestoFailCall()),
+      ROW({"a"}, {BIGINT()}));
+  assertPrestoFailExpr(
+      "json_extract(a, substr(b, 1 / 0))",
+      fmt::format("json_extract(a, substr(b, {}))", prestoFailCall()),
+      ROW({"a", "b"}, {JSON(), VARCHAR()}));
+
+  // Complex types.
+  assertPrestoFailExpr(
+      "filter(a, x -> (1 / 0) > 1)",
+      fmt::format("filter(a, x -> {} > 1)", prestoFailCall()),
+      ROW({"a"}, {ARRAY(BIGINT())}));
+  assertPrestoFailExpr(
+      "map_top_n(a, 1 / 0)",
+      fmt::format("map_top_n(a, {})", prestoFailCall()),
+      ROW({"a"}, {MAP(VARCHAR(), BIGINT())}));
+
+  // Special form expressions.
+  assertPrestoFailExpr(
+      "coalesce(0 / 0 > 1, a, 0 / 0 = 0)",
+      fmt::format(
+          "coalesce({} > 1, a, {} = 0)", prestoFailCall(), prestoFailCall()),
+      ROW({"a"}, {BOOLEAN()}));
+  assertPrestoFailExpr(
+      "CASE abs(-1234) WHEN a + (2 + 3) THEN 2 / 1 WHEN 0 / 0 THEN abs(-2) ELSE length('abc') END",
+      fmt::format(
+          "CASE 1234 WHEN a + 5 THEN 2 WHEN {} THEN 2 ELSE 3 END",
+          prestoFailCall()),
+      ROW({"a"}, {BIGINT()}));
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/ExprRewriteRegistryTest.cpp b/velox/expression/tests/ExprRewriteRegistryTest.cpp
new file mode 100644
index 000000000000..2581a0066960
--- /dev/null
+++ b/velox/expression/tests/ExprRewriteRegistryTest.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/expression/ExprRewriteRegistry.h"
+#include "gtest/gtest.h"
+
+namespace facebook::velox::expression {
+
+namespace {
+
+class ExprRewriteRegistryTest : public testing::Test {};
+
+TEST_F(ExprRewriteRegistryTest, basic) {
+  expression::ExprRewriteRegistry registry;
+  expression::ExpressionRewrite testRewrite =
+      [&](const core::TypedExprPtr& input) {
+        return std::make_shared<core::CallTypedExpr>(
+            input->type(), "rewritten_expr", input, input);
+      };
+  registry.registerRewrite(testRewrite);
+
+  auto input = std::make_shared<core::CallTypedExpr>(
+      BIGINT(),
+      "original_expr",
+      std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "a"));
+  const auto rewritten = registry.rewrite(input);
+  ASSERT_TRUE(rewritten->isCallKind());
+  ASSERT_TRUE(rewritten->type()->isBigint());
+  const auto rewrittenCall = rewritten->asUnchecked<core::CallTypedExpr>();
+  ASSERT_EQ(rewrittenCall->inputs().size(), 2);
+  ASSERT_EQ(rewrittenCall->name(), "rewritten_expr");
+
+  registry.clear();
+  const auto rewriteAfterClear = registry.rewrite(input);
+  ASSERT_TRUE(*rewriteAfterClear == *input);
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/ExprStatsTest.cpp b/velox/expression/tests/ExprStatsTest.cpp
index 70394b4ce917..ce7592ac33ba 100644
--- a/velox/expression/tests/ExprStatsTest.cpp
+++ b/velox/expression/tests/ExprStatsTest.cpp
@@ -423,3 +423,87 @@ TEST_F(ExprStatsTest, complexConstants) {
 
   ASSERT_TRUE(exec::unregisterExprSetListener(listener));
 }
+TEST_F(ExprStatsTest, selectiveCpuTrackingForUdfs) {
+  // Test selective CPU tracking for specific UDFs using
+  // kExprTrackCpuUsageUdfs config.
+  vector_size_t inputSize = 10;
+
+  auto data = makeRowVector({
+      makeFlatVector<int32_t>(inputSize, [](auto row) { return row; }),
+      makeFlatVector<int32_t>(inputSize, [](auto row) { return row % 7; }),
+  });
+
+  auto rowType = asRowType(data->type());
+
+  // Helper to test selective CPU tracking with specified configuration.
+  auto testCpuTracking =
+      [&](bool enableGlobalTracking,
+          const std::string& funcList,
+          const std::vector<std::string>& expressions,
+          const std::unordered_set<std::string>& expectedFuncsWithNonZeroCpu) {
+        queryCtx_->testingOverrideConfigUnsafe({
+            {core::QueryConfig::kExprTrackCpuUsage,
+             enableGlobalTracking ? "true" : "false"},
+            {core::QueryConfig::kExprTrackCpuUsageForFunctions, funcList},
+        });
+
+        std::vector<Event> events;
+        auto listener = std::make_shared<TestListener>(events);
+        ASSERT_TRUE(exec::registerExprSetListener(listener));
+
+        {
+          auto exprSet = compileExpressions(expressions, rowType);
+          evaluate(*exprSet, data);
+        }
+
+        // Ensure listener is unregistered before accessing events.
+        ASSERT_TRUE(exec::unregisterExprSetListener(listener));
+
+        ASSERT_EQ(1, events.size());
+        auto stats = events.back().stats;
+
+        // Verify selective CPU tracking for the specified functions.
+        for (const auto& [funcName, funcStats] : stats) {
+          if (expectedFuncsWithNonZeroCpu.count(funcName)) {
+            ASSERT_GT(funcStats.timing.cpuNanos, 0) << funcName;
+          } else {
+            ASSERT_EQ(funcStats.timing.cpuNanos, 0) << funcName;
+          }
+        }
+      };
+
+  // Test with empty config - should work same as before.
+  testCpuTracking(false, "", {"c0 + c1", "c0 * c1"}, {});
+
+  // Test with single function name.
+  testCpuTracking(false, "plus", {"c0 + c1", "c0 * c1"}, {"plus"});
+
+  // Test with multiple function names.
+  testCpuTracking(
+      false, "plus,mod", {"c0 + c1", "c0 * c1", "c0 % 5"}, {"plus", "mod"});
+
+  // Test with mixed case function names (should be normalized to lowercase).
+  testCpuTracking(
+      false,
+      "PLUS,Multiply",
+      {"c0 + c1", "c0 * c1", "c0 % 5"},
+      {"plus", "multiply"});
+
+  // Test with extra commas and empty entries (should be handled gracefully).
+  testCpuTracking(
+      false, "plus,,multiply,", {"c0 + c1", "c0 * c1"}, {"plus", "multiply"});
+
+  // Test with larger expression trees.
+  testCpuTracking(
+      false,
+      "plus,pow",
+      {"(c0 + c1) * c1", "pow(c0 + c1, 2)"},
+      {"plus", "pow"});
+
+  // Test with global CPU tracking enabled.
+  testCpuTracking(
+      true,
+      "plus,pow",
+      {"(c0 + c1) * c1", "pow(c0 + c1, 2)"},
+      {"plus", "pow", "multiply", "cast"});
+}
diff --git a/velox/expression/tests/ExprTest.cpp b/velox/expression/tests/ExprTest.cpp
index 0a162f916776..9d813b91cd6e 100644
--- a/velox/expression/tests/ExprTest.cpp
+++ b/velox/expression/tests/ExprTest.cpp
@@ -22,21 +22,21 @@
 #include "glog/logging.h"
 #include "gtest/gtest.h"
 
-#include "velox/expression/Expr.h"
-
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
 #include "velox/expression/CoalesceExpr.h"
 #include "velox/expression/ConjunctExpr.h"
 #include "velox/expression/ConstantExpr.h"
+#include "velox/expression/Expr.h"
 #include "velox/expression/SwitchExpr.h"
 #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"
+#include "velox/vector/BaseVector.h"
 #include "velox/vector/SelectivityVector.h"
 #include "velox/vector/VectorSaver.h"
 #include "velox/vector/tests/TestingAlwaysThrowsFunction.h"
@@ -58,6 +58,13 @@ class ExprTest : public testing::Test, public VectorTestBase {
     parse::registerTypeResolver();
   }
 
+  void setQueryTimeZone(const std::string& timeZone) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+
   core::TypedExprPtr parseExpression(
       const std::string& text,
       const RowTypePtr& rowType,
@@ -512,14 +519,10 @@ TEST_P(ParameterizedExprTest, constantNull) {
   // Builds the following expression: "plus(c0, plus(c0, null))"
   auto expression = std::make_shared<core::CallTypedExpr>(
       INTEGER(),
-      std::vector<core::TypedExprPtr>{
-          inputExpr,
-          std::make_shared<core::CallTypedExpr>(
-              INTEGER(),
-              std::vector<core::TypedExprPtr>{inputExpr, nullConstant},
-              "plus"),
-      },
-      "plus");
+      "plus",
+      inputExpr,
+      std::make_shared<core::CallTypedExpr>(
+          INTEGER(), "plus", inputExpr, nullConstant));
 
   // Execute it and check it returns all null results.
   auto vector = makeNullableFlatVector<int32_t>({1, std::nullopt, 3});
@@ -544,7 +547,7 @@ TEST_P(ParameterizedExprTest, validateReturnType) {
 
   // Builds a "eq(c0, c0)" expression.
   auto expression = std::make_shared<core::CallTypedExpr>(
-      INTEGER(), std::vector<core::TypedExprPtr>{inputExpr, inputExpr}, "eq");
+      INTEGER(), "eq", inputExpr, inputExpr);
 
   // Execute it and check it returns all null results.
   auto vector = makeNullableFlatVector<int32_t>({1, 2, 3});
@@ -2569,21 +2572,120 @@ TEST_P(ParameterizedExprTest, stdExceptionContext) {
 
 /// Verify the output of ConstantExpr::toString().
 TEST_P(ParameterizedExprTest, constantToString) {
-  auto arrayVector =
-      makeNullableArrayVector<float>({{1.2, 3.4, std::nullopt, 5.6}});
+  auto arrayVector = makeArrayVectorFromJson<int32_t>(
+      {"[1, 2, null, 4]", "[1, 2, 3, 4, 5, 6, 7, 8, 9]"});
 
   exec::ExprSet exprSet(
-      {std::make_shared<core::ConstantTypedExpr>(INTEGER(), 23),
-       std::make_shared<core::ConstantTypedExpr>(
-           DOUBLE(), variant::null(TypeKind::DOUBLE)),
-       makeConstantExpr(arrayVector, 0)},
+      {
+          std::make_shared<core::ConstantTypedExpr>(INTEGER(), 23),
+          std::make_shared<core::ConstantTypedExpr>(
+              DOUBLE(), variant::null(TypeKind::DOUBLE)),
+          makeConstantExpr(arrayVector, 0),
+          makeConstantExpr(arrayVector, 1),
+      },
       execCtx_.get());
 
-  ASSERT_EQ("23:INTEGER", exprSet.exprs()[0]->toString());
-  ASSERT_EQ("null:DOUBLE", exprSet.exprs()[1]->toString());
-  ASSERT_EQ(
-      "4 elements starting at 0 {1.2000000476837158, 3.4000000953674316, null, 5.599999904632568}:ARRAY<REAL>",
-      exprSet.exprs()[2]->toString());
+  const auto& exprs = exprSet.exprs();
+
+  EXPECT_EQ("23:INTEGER", exprs[0]->toString());
+  EXPECT_EQ("null:DOUBLE", exprs[1]->toString());
+  EXPECT_EQ("{1, 2, null, 4}:ARRAY<INTEGER>", exprs[2]->toString());
+  EXPECT_EQ("{1, 2, 3, 4, 5, ...4 more}:ARRAY<INTEGER>", exprs[3]->toString());
+}
+
+TEST_F(ExprTest, constantEqualsNullConsistency) {
+  // Constant expr created using variant
+  auto nullVariantToExpr = std::make_shared<core::ConstantTypedExpr>(
+      VARCHAR(), variant::null(TypeKind::VARCHAR));
+  auto nonNullVariantToExpr =
+      std::make_shared<core::ConstantTypedExpr>(VARCHAR(), Variant{"test"});
+
+  // Constant expr created using vectors
+  auto nullBaseVectorToExpr = std::make_shared<core::ConstantTypedExpr>(
+      BaseVector::createNullConstant(VARCHAR(), 1, pool()));
+  auto nonNullBaseVectorToExpr = std::make_shared<core::ConstantTypedExpr>(
+      BaseVector::createConstant(VARCHAR(), Variant{"test"}, 1, pool()));
+
+  EXPECT_FALSE(nonNullVariantToExpr->equals(*nullBaseVectorToExpr));
+  EXPECT_FALSE(nullVariantToExpr->equals(*nonNullBaseVectorToExpr));
+  EXPECT_TRUE(nonNullVariantToExpr->equals(*nonNullBaseVectorToExpr));
+  EXPECT_TRUE(nullVariantToExpr->equals(*nullBaseVectorToExpr));
+}
+
+// Verify consistency of ConstantTypeExpr::toString/hash/equals APIs. The
+// outcome should not depend on whether expression was created using a Variant
+// of a Vector.
+TEST_F(ExprTest, constantToStringEqualsHashConsistency) {
+  auto testValue = [&](const TypePtr& type, const Variant& value) {
+    SCOPED_TRACE(
+        fmt::format(
+            "Type: {}, Value: {}", type->toString(), value.toJson(type)));
+
+    auto a = std::make_shared<core::ConstantTypedExpr>(type, value);
+
+    auto b = std::make_shared<core::ConstantTypedExpr>(
+        BaseVector::createConstant(type, value, 1, pool()));
+
+    EXPECT_EQ(a->toString(), b->toString());
+
+    EXPECT_TRUE(a->equals(*b));
+    EXPECT_TRUE(b->equals(*a));
+
+    EXPECT_EQ(a->hash(), b->hash());
+
+    auto baseVector = BaseVector::create(type, 2, pool());
+    baseVector->setNull(0, true);
+    baseVector->copy(b->valueVector().get(), 1, 0, 1);
+
+    auto c = std::make_shared<core::ConstantTypedExpr>(
+        wrapInDictionary(makeIndices({1, 0}), baseVector));
+
+    EXPECT_EQ(a->toString(), c->toString());
+
+    EXPECT_TRUE(a->equals(*c));
+    EXPECT_TRUE(c->equals(*a));
+
+    EXPECT_EQ(a->hash(), c->hash());
+  };
+
+  testValue(TINYINT(), Variant::create<TypeKind::TINYINT>(1));
+  testValue(SMALLINT(), Variant::create<TypeKind::SMALLINT>(123));
+  testValue(INTEGER(), 12345);
+  testValue(BIGINT(), -12345678LL);
+
+  testValue(BOOLEAN(), true);
+  testValue(BOOLEAN(), false);
+
+  testValue(VARCHAR(), "test");
+  testValue(VARBINARY(), Variant::binary("test"));
+
+  testValue(ARRAY(INTEGER()), Variant::array({1, 2, 3, 4, 5, 6, 7}));
+  testValue(ARRAY(VARCHAR()), Variant::array({}));
+
+  testValue(
+      MAP(INTEGER(), INTEGER()), Variant::map({{1, 10}, {2, 20}, {3, 30}}));
+  testValue(MAP(INTEGER(), REAL()), Variant::map({}));
+
+  testValue(
+      ROW({BOOLEAN(), INTEGER(), VARCHAR(), ARRAY(INTEGER())}),
+      Variant::row({false, 123, "apples", Variant::array({1, 2, 3})}));
+
+  testValue(ROW({}), Variant::row({}));
+
+  auto opaqueType = OpaqueType::create<OpaqueState>();
+
+  OpaqueType::registerSerialization<OpaqueState>(
+      "test-serde",
+      [](const std::shared_ptr<OpaqueState>& value) {
+        return std::to_string(value->x);
+      },
+      [](const std::string& value) -> std::shared_ptr<OpaqueState> {
+        return std::make_shared<OpaqueState>(atoi(value.c_str()));
+      });
+
+  testValue(
+      opaqueType,
+      Variant::opaque(std::make_shared<OpaqueState>(123), opaqueType));
 }
 
 TEST_P(ParameterizedExprTest, fieldAccessToString) {
@@ -2608,12 +2710,14 @@ TEST_P(ParameterizedExprTest, fieldAccessToString) {
            "e")},
       execCtx_.get());
 
-  ASSERT_EQ("a", exprSet.exprs()[0]->toString());
-  ASSERT_EQ("a", exprSet.exprs()[0]->toString(/*recursive*/ false));
-  ASSERT_EQ("(b).c", exprSet.exprs()[1]->toString());
-  ASSERT_EQ("c", exprSet.exprs()[1]->toString(/*recursive*/ false));
-  ASSERT_EQ("((b).d).e", exprSet.exprs()[2]->toString());
-  ASSERT_EQ("e", exprSet.exprs()[2]->toString(/*recursive*/ false));
+  const auto& exprs = exprSet.exprs();
+
+  EXPECT_EQ("a", exprs[0]->toString());
+  EXPECT_EQ("a", exprs[0]->toString(/*recursive*/ false));
+  EXPECT_EQ("(b).c", exprs[1]->toString());
+  EXPECT_EQ("c", exprs[1]->toString(/*recursive*/ false));
+  EXPECT_EQ("((b).d).e", exprs[2]->toString());
+  EXPECT_EQ("e", exprs[2]->toString(/*recursive*/ false));
 }
 
 TEST_P(ParameterizedExprTest, constantToSql) {
@@ -2715,9 +2819,10 @@ TEST_P(ParameterizedExprTest, constantToSql) {
   ASSERT_EQ(toSql(variant::null(TypeKind::ARRAY)), "NULL");
 
   ASSERT_EQ(
-      toSqlComplex(makeMapVector<int32_t, int32_t>({
-          {{1, 10}, {2, 20}, {3, 30}},
-      })),
+      toSqlComplex(
+          makeMapVector<int32_t, int32_t>({
+              {{1, 10}, {2, 20}, {3, 30}},
+          })),
       "map(ARRAY['1'::INTEGER, '2'::INTEGER, '3'::INTEGER], ARRAY['10'::INTEGER, '20'::INTEGER, '30'::INTEGER])");
   ASSERT_EQ(
       toSqlComplex(
@@ -2728,8 +2833,9 @@ TEST_P(ParameterizedExprTest, constantToSql) {
           1),
       "map(ARRAY['1'::INTEGER, '2'::INTEGER, '3'::INTEGER], ARRAY['10'::INTEGER, '20'::INTEGER, '30'::INTEGER])");
   ASSERT_EQ(
-      toSqlComplex(BaseVector::createNullConstant(
-          MAP(INTEGER(), VARCHAR()), 10, pool())),
+      toSqlComplex(
+          BaseVector::createNullConstant(
+              MAP(INTEGER(), VARCHAR()), 10, pool())),
       "NULL::MAP(INTEGER, VARCHAR)");
 
   ASSERT_EQ(
@@ -2739,22 +2845,23 @@ TEST_P(ParameterizedExprTest, constantToSql) {
       })),
       "row_constructor('1'::INTEGER, TRUE)");
   ASSERT_EQ(
-      toSqlComplex(BaseVector::createNullConstant(
-          ROW({"a", "b"}, {BOOLEAN(), DOUBLE()}), 10, pool())),
+      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())),
+      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");
+      VARCHAR(), "json_format", makeConstantExpr("[1, 2, 3]", JSON()));
 
   auto exprSet = compileNoConstantFolding(expression);
 
@@ -3550,10 +3657,10 @@ TEST_P(ParameterizedExprTest, applyFunctionNoResult) {
   // not.  Conjuncts have the nice property that they set throwOnError to
   // false and don't check if the result VectorPtr is nullptr.
   assertError(
-      "always_throws_vector_function(c0) AND true",
+      "always_throws_vector_function(c0) AND (c0 = 1)",
       makeFlatVector<int32_t>({1, 2, 3}),
       "always_throws_vector_function(c0)",
-      "Top-level Expression: and(always_throws_vector_function(c0), true:BOOLEAN)",
+      "Top-level Expression: and(always_throws_vector_function(c0), eq(cast((c0) as BIGINT), 1:BIGINT))",
       TestingAlwaysThrowsVectorFunction::kVeloxErrorMessage);
 
   exec::registerVectorFunction(
@@ -3562,10 +3669,10 @@ TEST_P(ParameterizedExprTest, applyFunctionNoResult) {
       std::make_unique<NoOpVectorFunction>());
 
   assertError(
-      "no_op(c0) AND true",
+      "no_op(c0) AND (c0 = 2)",
       makeFlatVector<int32_t>({1, 2, 3}),
       "no_op(c0)",
-      "Top-level Expression: and(no_op(c0), true:BOOLEAN)",
+      "Top-level Expression: and(no_op(c0), eq(cast((c0) as BIGINT), 2:BIGINT))",
       "Function neither returned results nor threw exception.");
 }
 
@@ -3971,7 +4078,7 @@ TEST_P(ParameterizedExprTest, cseOverLazyDictionary) {
           pool(),
           BIGINT(),
           5,
-          std::make_unique<SimpleVectorLoader>([=](RowSet /*rows*/) {
+          std::make_unique<SimpleVectorLoader>([=, this](RowSet /*rows*/) {
             return wrapInDictionary(
                 makeIndicesInReverse(5),
                 makeFlatVector<int64_t>({8, 9, 10, 11, 12}));
@@ -4320,8 +4427,9 @@ TEST_F(ExprTest, commonSubExpressionWithPeeling) {
       // is evaluated twice.
       auto queryCtx = velox::core::QueryCtx::create(
           nullptr,
-          core::QueryConfig(std::unordered_map<std::string, std::string>{
-              {core::QueryConfig::kMaxSharedSubexprResultsCached, "1"}}));
+          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));
@@ -4598,7 +4706,8 @@ TEST_P(ParameterizedExprTest, switchRowInputTypesAreTheSame) {
       EXPECT_TRUE(false) << "Expected an error";
     } catch (VeloxException& e) {
       EXPECT_EQ(
-          "Switch expression type different than then clause. Expected ROW<f1:BOOLEAN> but got Actual ROW<c0:BOOLEAN>.",
+          "Switch expression type different than then clause. "
+          "Expected ROW<f1:BOOLEAN>, but got ROW<c0:BOOLEAN>.",
           e.message());
     }
   }
@@ -4624,7 +4733,8 @@ TEST_P(ParameterizedExprTest, coalesceRowInputTypesAreTheSame) {
       EXPECT_TRUE(false) << "Expected an error";
     } catch (VeloxException& e) {
       EXPECT_EQ(
-          "Coalesce expression type different than its inputs. Expected ROW<f1:BOOLEAN> but got Actual ROW<c0:BOOLEAN>.",
+          "Coalesce expression type different than its inputs. "
+          "Expected ROW<f1:BOOLEAN>, but got ROW<c0:BOOLEAN>.",
           e.message());
     }
   }
@@ -4635,14 +4745,12 @@ TEST_P(ParameterizedExprTest, coalesceRowInputTypesAreTheSame) {
     // different.
     auto call1 = std::make_shared<const core::CallTypedExpr>(
         ROW({"row_field0"}, {BIGINT()}),
-        std::vector<core::TypedExprPtr>{
-            std::make_shared<const core::FieldAccessTypedExpr>(BIGINT(), "c0")},
-        "foo");
+        "foo",
+        std::make_shared<const core::FieldAccessTypedExpr>(BIGINT(), "c0"));
     auto call2 = std::make_shared<const core::CallTypedExpr>(
         ROW({""}, {BIGINT()}),
-        std::vector<core::TypedExprPtr>{
-            std::make_shared<const core::FieldAccessTypedExpr>(BIGINT(), "c0")},
-        "foo");
+        "foo",
+        std::make_shared<const core::FieldAccessTypedExpr>(BIGINT(), "c0"));
     ASSERT_FALSE(*call1 == *call2);
 
     auto fieldAccess1 = std::make_shared<const core::FieldAccessTypedExpr>(
@@ -4683,11 +4791,10 @@ TEST_P(ParameterizedExprTest, coalesceRowInputTypesAreTheSame) {
                 BIGINT(), "c0")});
     core::TypedExprPtr coalesce = std::make_shared<const core::CallTypedExpr>(
         ROW({"row_field0"}, {BIGINT()}),
-        std::vector<core::TypedExprPtr>{
-            std::make_shared<const core::FieldAccessTypedExpr>(
-                ROW({"row_field0"}, {BIGINT()}), "c1"),
-            concat},
-        "coalesce");
+        "coalesce",
+        std::make_shared<const core::FieldAccessTypedExpr>(
+            ROW({"row_field0"}, {BIGINT()}), "c1"),
+        concat);
     core::TypedExprPtr dereference =
         std::make_shared<const core::FieldAccessTypedExpr>(
             BIGINT(), coalesce, "row_field0");
@@ -4698,16 +4805,12 @@ TEST_P(ParameterizedExprTest, coalesceRowInputTypesAreTheSame) {
                 BIGINT(), "c0")});
     ASSERT_FALSE(*concat == *concat2);
     core::TypedExprPtr cast = std::make_shared<const core::CallTypedExpr>(
-        ROW({"row_field0"}, {BIGINT()}),
-        std::vector<core::TypedExprPtr>{concat2},
-        "cast");
+        ROW({"row_field0"}, {BIGINT()}), "cast", concat2);
     core::TypedExprPtr dereference2 =
         std::make_shared<const core::FieldAccessTypedExpr>(
             BIGINT(), cast, "row_field0");
     core::TypedExprPtr plus = std::make_shared<const core::CallTypedExpr>(
-        BIGINT(),
-        std::vector<core::TypedExprPtr>{dereference2, dereference},
-        "plus");
+        BIGINT(), "plus", dereference2, dereference);
 
     ASSERT_NO_THROW(compileExpression(plus));
   }
@@ -4986,8 +5089,14 @@ TEST_F(ExprTest, disabledeferredLazyLoading) {
 
 TEST_F(ExprTest, evaluateConstantExpression) {
   auto eval = [&](const std::string& sql) {
-    auto expr = parseExpression(sql, ROW({}));
-    return exec::evaluateConstantExpression(expr, pool());
+    auto expr = parseExpression(sql, ROW({"a"}, {BIGINT()}));
+    return exec::tryEvaluateConstantExpression(expr, pool(), queryCtx_);
+  };
+
+  auto evalNoThrow = [&](const std::string& sql) {
+    auto expr = parseExpression(sql, ROW({"a"}, {BIGINT()}));
+    return exec::tryEvaluateConstantExpression(
+        expr, pool(), queryCtx_, true /* supressEvaluationFailures */);
   };
 
   assertEqualVectors(eval("1 + 2"), makeConstant<int64_t>(3, 1));
@@ -4995,6 +5104,65 @@ TEST_F(ExprTest, evaluateConstantExpression) {
   assertEqualVectors(
       eval("transform(array[1, 2, 3], x -> (x * 2))"),
       makeArrayVectorFromJson<int64_t>({"[2, 4, 6]"}));
+
+  assertEqualVectors(
+      eval("transform(array[1, 2, 3], x -> (x * (3 - 1)))"),
+      makeArrayVectorFromJson<int64_t>({"[2, 4, 6]"}));
+
+  assertEqualVectors(
+      eval("transform(array[1, 2, 3], x -> 2)"),
+      makeArrayVectorFromJson<int64_t>({"[2, 2, 2]"}));
+
+  assertEqualVectors(
+      eval(
+          "try(coalesce(array_min_by(array[1, 2, 3], x -> x / 0), 0::INTEGER))"),
+      makeNullConstant(TypeKind::INTEGER, 1));
+
+  // Verify that constant folding takes into account query config.
+  setQueryTimeZone("America/Los_Angeles");
+  assertEqualVectors(
+      eval("date_format(from_unixtime(0.0), '%Y-%m-%d %H:%i')"),
+      makeConstant<std::string>("1969-12-31 16:00", 1));
+
+  setQueryTimeZone("America/New_York");
+  assertEqualVectors(
+      eval("date_format(from_unixtime(0.0), '%Y-%m-%d %H:%i')"),
+      makeConstant<std::string>("1969-12-31 19:00", 1));
+
+  EXPECT_TRUE(eval("a + 1") == nullptr);
+
+  EXPECT_TRUE(eval("rand() + 1.0") == nullptr);
+
+  EXPECT_TRUE(eval("transform(array[1, 2, 3], x -> (x * 2) + a)") == nullptr);
+
+  EXPECT_TRUE(eval("transform(array[1, 2, 3], x -> x + rand())") == nullptr);
+
+  VELOX_ASSERT_THROW(eval("5 / 0"), "division by zero");
+  EXPECT_TRUE(evalNoThrow("5 / 0") == nullptr);
+
+  VELOX_ASSERT_THROW(eval("1 + 5 / 0"), "division by zero");
+  EXPECT_TRUE(evalNoThrow("1 + 5 / 0") == nullptr);
+
+  VELOX_ASSERT_THROW(
+      eval("transform(array[1, 2, 3], x -> x / 0)"), "division by zero");
+  EXPECT_TRUE(evalNoThrow("transform(array[1, 2, 3], x -> x / 0)") == nullptr);
+}
+
+TEST_F(ExprTest, isDeterministic) {
+  auto isDeterministic = [&](const std::string& sql) {
+    SCOPED_TRACE(sql);
+    auto exprSet = compileExpression(sql, ROW({"c0"}, {ARRAY(DOUBLE())}));
+    return exprSet->expr(0)->isDeterministic();
+  };
+
+  EXPECT_TRUE(isDeterministic("cardinality(c0) + 5"));
+  EXPECT_TRUE(isDeterministic("transform(c0, x -> x + 5.0)"));
+  EXPECT_TRUE(isDeterministic("filter(c0, x -> (x < 5.0))"));
+
+  EXPECT_FALSE(isDeterministic("rand()"));
+  EXPECT_FALSE(isDeterministic("c0[1] + rand()"));
+  EXPECT_FALSE(isDeterministic("transform(c0, x -> x + rand())"));
+  EXPECT_FALSE(isDeterministic("filter(c0, x -> (x < rand()))"));
 }
 
 TEST_F(ExprTest, peelingOnDeterministicFunctionInNonDeterministicExpr) {
@@ -5014,5 +5182,78 @@ TEST_F(ExprTest, peelingOnDeterministicFunctionInNonDeterministicExpr) {
   ASSERT_EQ(stats["plus"].numProcessedRows, input->size() / 2);
 }
 
+TEST_F(ExprTest, lambdaConstantFolded) {
+  const auto makeTypedExpr =
+      [this](const std::string& text, const RowTypePtr& rowType) {
+        auto untyped = parse::parseExpr(text, {});
+        return core::Expressions::inferTypes(untyped, rowType, pool());
+      };
+
+  // Test the resource clear of lambda constant folding which relies on an
+  // uninitialized ExprSet for eval.
+  std::string expression =
+      "reduce(regexp_split('a,b,c,d,e,f,g,h',','), array[array['']], (acc, x) -> array[array[x]], (id) -> id)";
+  auto typedExpr = makeTypedExpr(expression, ROW({"c0"}, {INTEGER()}));
+  exec::ExprSet exprSet({typedExpr}, execCtx_.get());
+  exprSet.clear();
+}
+
+TEST_F(ExprTest, simpleExpressionEvaluator) {
+  exec::SimpleExpressionEvaluator evaluator{queryCtx_.get(), pool_.get()};
+  const auto rowType = ROW({"c0", "c1"}, {ARRAY(INTEGER()), INTEGER()});
+  const auto array = makeArrayVectorFromJson<int32_t>(
+      {"[1, 2, 3, 4]", "null", "[5, 6]", "[]", "[null]", "[7, 8, 9]"});
+  const auto data = makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6});
+  const auto input = makeRowVector({array, data});
+
+  const auto parseExpr = [&](const std::string& sql) {
+    return parseExpression(sql, rowType);
+  };
+  const auto arrayExpr = parseExpr("element_at(c0, 1)");
+  const auto expectedArrayExprResult = makeNullableFlatVector<int32_t>(
+      {1, std::nullopt, 5, std::nullopt, std::nullopt, 7});
+  const auto scalarExpr = parseExpr("cast(c1 + 1 as integer)");
+  const auto expectedScalarExprResult =
+      makeFlatVector<int32_t>({2, 3, 4, 5, 6, 7});
+
+  auto validateSingleExpr = [&](const core::TypedExprPtr typedExpr,
+                                const RowVectorPtr& input,
+                                const VectorPtr& expected) {
+    auto exprSet = evaluator.compile(typedExpr);
+    SelectivityVector rows;
+    rows.resize(input->size());
+    VectorPtr result;
+    evaluator.evaluate(exprSet.get(), rows, *input, result);
+    assertEqualVectors(expected, result);
+  };
+  validateSingleExpr(arrayExpr, input, expectedArrayExprResult);
+  validateSingleExpr(scalarExpr, input, expectedScalarExprResult);
+
+  auto validateMultiExprs =
+      [&](const std::vector<core::TypedExprPtr>& typedExprs,
+          const RowVectorPtr& input,
+          const std::vector<VectorPtr>& expectedResults) {
+        auto exprSet = evaluator.compile(typedExprs);
+        SelectivityVector rows;
+        rows.resize(input->size());
+        std::vector<VectorPtr> results;
+        evaluator.evaluate(exprSet.get(), rows, *input, results);
+        ASSERT_EQ(results.size(), expectedResults.size());
+        for (int i = 0; i < expectedResults.size(); ++i) {
+          assertEqualVectors(expectedResults[i], results[i]);
+        }
+      };
+  validateMultiExprs(
+      {arrayExpr, arrayExpr},
+      input,
+      {expectedArrayExprResult, expectedArrayExprResult});
+  validateMultiExprs({scalarExpr}, input, {expectedScalarExprResult});
+  validateMultiExprs(
+      {arrayExpr, scalarExpr, arrayExpr},
+      input,
+      {expectedArrayExprResult,
+       expectedScalarExprResult,
+       expectedArrayExprResult});
+}
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/expression/tests/ExprToSubfieldFilterTest.cpp b/velox/expression/tests/ExprToSubfieldFilterTest.cpp
index d720275c8213..8adae5e766fd 100644
--- a/velox/expression/tests/ExprToSubfieldFilterTest.cpp
+++ b/velox/expression/tests/ExprToSubfieldFilterTest.cpp
@@ -16,19 +16,20 @@
 
 #include "velox/expression/ExprToSubfieldFilter.h"
 #include <gtest/gtest.h>
-#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/Expr.h"
-#include "velox/functions/lib/IsNull.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
 #include "velox/parse/TypeResolver.h"
 
+using facebook::velox::common::Subfield;
+
+#define VELOX_ASSERT_FILTER(expected, actual)   \
+  ASSERT_TRUE(expected->testingEquals(*actual)) \
+      << expected->toString() << " vs " << actual->toString();
+
 namespace facebook::velox::exec {
 namespace {
 
-using namespace facebook::velox::common;
-
 void validateSubfield(
     const Subfield& subfield,
     const std::vector<std::string>& expectedPath) {
@@ -67,6 +68,19 @@ class ExprToSubfieldFilterTest : public testing::Test {
     return &evaluator_;
   }
 
+  std::pair<common::Subfield, std::unique_ptr<common::Filter>>
+  leafCallToSubfieldFilter(
+      const core::CallTypedExprPtr& call,
+      bool negated = false) {
+    if (auto result =
+            ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
+                *call, evaluator(), negated)) {
+      return std::move(result.value());
+    }
+
+    return std::make_pair(common::Subfield(), nullptr);
+  }
+
  private:
   std::shared_ptr<memory::MemoryPool> pool_ =
       memory::memoryManager()->addLeafPool();
@@ -75,288 +89,467 @@ class ExprToSubfieldFilterTest : public testing::Test {
 };
 
 TEST_F(ExprToSubfieldFilterTest, eq) {
-  auto call = parseCallExpr("a = 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a = 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  auto bigintRange = dynamic_cast<BigintRange*>(filter.get());
-  ASSERT_TRUE(bigintRange);
-  ASSERT_EQ(bigintRange->lower(), 42);
-  ASSERT_EQ(bigintRange->upper(), 42);
-  ASSERT_FALSE(bigintRange->testNull());
+
+  VELOX_ASSERT_FILTER(equal(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, eqExpr) {
-  auto call = parseCallExpr("a = 21 * 2", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a = 21 * 2", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  auto bigintRange = dynamic_cast<BigintRange*>(filter.get());
-  ASSERT_TRUE(bigintRange);
-  ASSERT_EQ(bigintRange->lower(), 42);
-  ASSERT_EQ(bigintRange->upper(), 42);
-  ASSERT_FALSE(bigintRange->testNull());
+
+  VELOX_ASSERT_FILTER(equal(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, eqSubfield) {
-  auto call = parseCallExpr("a.b = 42", ROW({{"a", ROW({{"b", BIGINT()}})}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a.b = 42", ROW("a", ROW("b", BIGINT())));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a", "b"});
-  auto bigintRange = dynamic_cast<BigintRange*>(filter.get());
-  ASSERT_TRUE(bigintRange);
-  ASSERT_EQ(bigintRange->lower(), 42);
-  ASSERT_EQ(bigintRange->upper(), 42);
-  ASSERT_FALSE(bigintRange->testNull());
+
+  VELOX_ASSERT_FILTER(equal(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, neq) {
-  auto call = parseCallExpr("a <> 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a <> 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_TRUE(filter->testInt64(41));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testInt64(43));
+
+  // TODO Optimize to notEqual(42).
+  VELOX_ASSERT_FILTER(bigintOr(lessThan(42), greaterThan(42)), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, lte) {
-  auto call = parseCallExpr("a <= 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a <= 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_TRUE(filter->testInt64(41));
-  ASSERT_TRUE(filter->testInt64(42));
-  ASSERT_FALSE(filter->testInt64(43));
+
+  VELOX_ASSERT_FILTER(lessThanOrEqual(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, lt) {
-  auto call = parseCallExpr("a < 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a < 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_TRUE(filter->testInt64(41));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_FALSE(filter->testInt64(43));
+
+  VELOX_ASSERT_FILTER(lessThan(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, gte) {
-  auto call = parseCallExpr("a >= 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a >= 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_FALSE(filter->testInt64(41));
-  ASSERT_TRUE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testInt64(43));
+
+  VELOX_ASSERT_FILTER(greaterThanOrEqual(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, gt) {
-  auto call = parseCallExpr("a > 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a > 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_FALSE(filter->testInt64(41));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testInt64(43));
+
+  VELOX_ASSERT_FILTER(greaterThan(42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, between) {
-  auto call = parseCallExpr("a between 40 and 42", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a between 40 and 42", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  for (int i = 39; i <= 43; ++i) {
-    ASSERT_EQ(filter->testInt64(i), 40 <= i && i <= 42);
-  }
+
+  VELOX_ASSERT_FILTER(between(40, 42), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, in) {
-  auto call = parseCallExpr("a in (40, 42)", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
-  ASSERT_TRUE(filter);
-  validateSubfield(subfield, {"a"});
-  for (int i = 39; i <= 43; ++i) {
-    ASSERT_EQ(filter->testInt64(i), i == 40 || i == 42);
+  {
+    auto call = parseCallExpr("a in (40, 42)", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    VELOX_ASSERT_FILTER(in({40, 42}), filter);
+  }
+
+  {
+    auto call = parseCallExpr("a in (40, 42, null)", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    VELOX_ASSERT_FILTER(in({40, 42}), filter);
   }
 }
 
-TEST_F(ExprToSubfieldFilterTest, isNull) {
-  auto call = parseCallExpr("a is null", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
-  ASSERT_TRUE(filter);
-  validateSubfield(subfield, {"a"});
-  ASSERT_FALSE(filter->testInt64(0));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testNull());
+TEST_F(ExprToSubfieldFilterTest, notIn) {
+  {
+    auto call = parseCallExpr("a in (40, 42)", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call, true);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    VELOX_ASSERT_FILTER(notIn({40, 42}), filter);
+  }
+
+  {
+    auto call = parseCallExpr("a in (40, 42, null)", ROW("a", BIGINT()));
+    auto [subfield, filter] = leafCallToSubfieldFilter(call, true);
+
+    ASSERT_TRUE(filter);
+    validateSubfield(subfield, {"a"});
+
+    auto expected = std::make_unique<common::AlwaysFalse>();
+    VELOX_ASSERT_FILTER(expected, filter);
+  }
 }
 
-TEST_F(ExprToSubfieldFilterTest, isNotNull) {
-  auto call = parseCallExpr("a is not null", ROW({{"a", BIGINT()}}));
-  auto [subfield, filter] = toSubfieldFilter(call, evaluator());
+TEST_F(ExprToSubfieldFilterTest, isNull) {
+  auto call = parseCallExpr("a is null", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_TRUE(filter->testInt64(0));
-  ASSERT_TRUE(filter->testInt64(42));
-  ASSERT_FALSE(filter->testNull());
+
+  VELOX_ASSERT_FILTER(isNull(), filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, like) {
-  auto call = parseCallExpr("a like 'foo%'", ROW({{"a", VARCHAR()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a like 'foo%'", ROW("a", VARCHAR()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_FALSE(filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, nonConstant) {
-  auto call =
-      parseCallExpr("a = b + 1", ROW({{"a", BIGINT()}, {"b", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a = b + 1", ROW({"a", "b"}, BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_FALSE(filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, userError) {
-  auto call = parseCallExpr("a = 1 / 0", ROW({{"a", BIGINT()}}));
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+  auto call = parseCallExpr("a = 1 / 0", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_FALSE(filter);
 }
 
 TEST_F(ExprToSubfieldFilterTest, dereferenceWithEmptyField) {
   auto call = std::make_shared<core::CallTypedExpr>(
       BOOLEAN(),
-      std::vector<core::TypedExprPtr>{
-          std::make_shared<core::DereferenceTypedExpr>(
-              REAL(),
-              std::make_shared<core::FieldAccessTypedExpr>(
-                  ROW({{"", DOUBLE()}, {"", REAL()}, {"", BIGINT()}}),
-                  std::make_shared<core::InputTypedExpr>(ROW(
-                      {{"c0",
-                        ROW({{"", DOUBLE()}, {"", REAL()}, {"", BIGINT()}})}})),
-                  "c0"),
-              1)},
-      "is_null");
-  Subfield subfield;
-  auto filter =
-      ExprToSubfieldFilterParser::getInstance()->leafCallToSubfieldFilter(
-          *call, subfield, evaluator());
+      "is_null",
+      std::make_shared<core::DereferenceTypedExpr>(
+          REAL(),
+          std::make_shared<core::FieldAccessTypedExpr>(
+              ROW({DOUBLE(), REAL(), BIGINT()}),
+              std::make_shared<core::InputTypedExpr>(
+                  ROW("c0", ROW({DOUBLE(), REAL(), BIGINT()}))),
+              "c0"),
+          1));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_FALSE(filter);
 }
 
-class CustomExprToSubfieldFilterParser : public ExprToSubfieldFilterParser {
- public:
-  std::unique_ptr<common::Filter> leafCallToSubfieldFilter(
-      const core::CallTypedExpr& call,
-      common::Subfield& subfield,
-      core::ExpressionEvaluator* evaluator,
-      bool negated) override {
-    if (call.inputs().empty()) {
-      return nullptr;
-    }
+template <typename... Disjuncts>
+static std::unique_ptr<common::Filter> makeOr(Disjuncts&&... disjuncts) {
+  return ExprToSubfieldFilterParser::makeOrFilter(
+      std::forward<Disjuncts>(disjuncts)...);
+}
 
-    const auto* leftSide = call.inputs()[0].get();
-
-    if (call.name() == "custom_eq") {
-      if (toSubfield(leftSide, subfield)) {
-        return negated ? makeNotEqualFilter(call.inputs()[1], evaluator)
-                       : makeEqualFilter(call.inputs()[1], evaluator);
-      }
-    } else if (call.name() == "is_null") {
-      if (toSubfield(call.inputs()[0].get(), subfield)) {
-        if (negated) {
-          return isNotNull();
-        }
-        return isNull();
-      }
-    }
-    return nullptr;
+TEST_F(ExprToSubfieldFilterTest, makeOrFilterBigint) {
+  // a = 1 or a = 5
+  {
+    auto expected = in({1, 5});
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(1), equal(5)));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(5), equal(1)));
   }
-};
 
-class CustomExprToSubfieldFilterTest : public ExprToSubfieldFilterTest {
- public:
-  static void SetUpTestSuite() {
-    functions::prestosql::registerAllScalarFunctions("custom_");
-    functions::registerIsNullFunction("is_null");
-    parse::registerTypeResolver();
-    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
-    ExprToSubfieldFilterParser::registerParserFactory(
-        []() { return std::make_unique<CustomExprToSubfieldFilterParser>(); });
+  // a = 1 or a = 2 ==> a between 1 and 2
+  {
+    auto expected = between(1, 2);
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(1), equal(2)));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(2), equal(1)));
+    VELOX_ASSERT_FILTER(expected, makeOr(between(1, 2), equal(1)));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(2), between(1, 2)));
   }
 
-  static void TearDownTestSuite() {
-    ExprToSubfieldFilterParser::registerParserFactory(
-        []() { return std::make_unique<PrestoExprToSubfieldFilterParser>(); });
+  // a = 1 or a between 5 and 10 or a = 11 ==> a = 1 or a between 5 and 11
+  {
+    auto expected = bigintOr(equal(1), between(5, 11));
+
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(1), between(5, 10), equal(11)));
+    VELOX_ASSERT_FILTER(expected, makeOr(equal(1), equal(11), between(5, 10)));
+    VELOX_ASSERT_FILTER(expected, makeOr(between(5, 10), equal(11), equal(1)));
   }
-};
 
-TEST_F(CustomExprToSubfieldFilterTest, isNull) {
-  auto call = parseCallExpr("a is null", ROW({{"a", BIGINT()}}));
-  auto [subfield, filter] = toSubfieldFilter(call, evaluator());
+  // a < 10 or a > 0
+  {
+    VELOX_ASSERT_FILTER(isNotNull(), makeOr(lessThan(10), greaterThan(0)));
+    VELOX_ASSERT_FILTER(
+        alwaysTrue(),
+        makeOr(lessThan(10), greaterThan(0, /*nullAllowed=*/true)));
+  }
+
+  // a > 10 or a between 12 and 100
+  {
+    auto expected = greaterThanOrEqual(11);
+    VELOX_ASSERT_FILTER(expected, makeOr(greaterThan(10), between(12, 100)));
+    VELOX_ASSERT_FILTER(expected, makeOr(between(12, 100), greaterThan(10)));
+  }
+}
+
+TEST_F(ExprToSubfieldFilterTest, makeOrFilterDouble) {
+  // a < 1.5 or a > 1.0 ==> not null
+  {
+    VELOX_ASSERT_FILTER(
+        isNotNull(), makeOr(lessThanDouble(1.5), greaterThanDouble(1.0)));
+
+    VELOX_ASSERT_FILTER(
+        alwaysTrue(),
+        makeOr(
+            lessThanDouble(1.5, /*nullAllowed=*/true), greaterThanDouble(1.0)));
+  }
+
+  // a < 10.1 or a between 9.0 and 12.0 or a between 11.0 and 15.0 ==> a <= 15.0
+  {
+    auto expected = lessThanOrEqualDouble(15.0);
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(
+            lessThanDouble(10.1),
+            betweenDouble(9.0, 12.0),
+            betweenDouble(11.0, 15.0)));
+  }
+
+  // a < 0.0 or a > 4.5
+  {
+    auto expected = orFilter(lessThanDouble(0.0), greaterThanDouble(4.5));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(lessThanDouble(0.0), greaterThanDouble(4.5)));
+  }
+}
+
+TEST_F(ExprToSubfieldFilterTest, makeOrFilterFloat) {
+  // a < 1.5 or a > 1.0 ==> not null
+  {
+    VELOX_ASSERT_FILTER(
+        isNotNull(), makeOr(lessThanFloat(1.5), greaterThanFloat(1.0)));
+
+    VELOX_ASSERT_FILTER(
+        alwaysTrue(),
+        makeOr(
+            lessThanFloat(1.5, /*nullAllowed=*/true), greaterThanFloat(1.0)));
+  }
+
+  // a < 10.1 or a between 9.0 and 12.0 or a between 11.0 and 15.0 ==> a <= 15.0
+  {
+    auto expected = lessThanOrEqualFloat(15.0);
+    VELOX_ASSERT_FILTER(
+        expected,
+        makeOr(
+            lessThanFloat(10.1),
+            betweenFloat(9.0, 12.0),
+            betweenFloat(11.0, 15.0)));
+  }
+
+  // a < 0.0 or a > 4.5
+  {
+    auto expected = orFilter(lessThanFloat(0.0), greaterThanFloat(4.5));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(lessThanFloat(0.0), greaterThanFloat(4.5)));
+  }
+
+  // a < 1 or a > 1
+  {
+    auto expected = orFilter(lessThanFloat(1.0), greaterThanFloat(1.0));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(lessThanFloat(1.0), greaterThanFloat(1.0)));
+    VELOX_ASSERT_FILTER(
+        expected, makeOr(greaterThanFloat(1.0), lessThanFloat(1.0)));
+  }
+}
+
+// Test NULL comparison handling - comparisons with NULL should return
+// AlwaysFalse as per SQL three-valued logic
+TEST_F(ExprToSubfieldFilterTest, eqNull) {
+  auto call = parseCallExpr("a = cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  ASSERT_FALSE(filter->testInt64(0));
-  ASSERT_FALSE(filter->testInt64(42));
-  ASSERT_TRUE(filter->testNull());
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
 }
 
-TEST_F(CustomExprToSubfieldFilterTest, eq) {
-  auto call = parseCallExpr("custom_eq(a, 42)", ROW({{"a", BIGINT()}}));
-  auto [subfield, filter] = toSubfieldFilter(call, evaluator());
+TEST_F(ExprToSubfieldFilterTest, eqNullVarchar) {
+  auto call = parseCallExpr("a = cast(null as varchar)", ROW("a", VARCHAR()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
   ASSERT_TRUE(filter);
   validateSubfield(subfield, {"a"});
-  auto bigintRange = dynamic_cast<BigintRange*>(filter.get());
-  ASSERT_TRUE(bigintRange);
-  ASSERT_EQ(bigintRange->lower(), 42);
-  ASSERT_EQ(bigintRange->upper(), 42);
-  ASSERT_FALSE(bigintRange->testNull());
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
 }
 
-TEST_F(CustomExprToSubfieldFilterTest, unsupported) {
-  auto call = parseCallExpr("custom_neq(a, 42)", ROW({{"a", BIGINT()}}));
-  VELOX_ASSERT_USER_THROW(
-      toSubfieldFilter(call, evaluator()),
-      "Unsupported expression for range filter");
+TEST_F(ExprToSubfieldFilterTest, eqNullTimestamp) {
+  auto call =
+      parseCallExpr("a = cast(null as timestamp)", ROW("a", TIMESTAMP()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, neqNull) {
+  auto call = parseCallExpr("a <> cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, ltNull) {
+  auto call = parseCallExpr("a < cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, ltNullDouble) {
+  auto call = parseCallExpr("a < cast(null as double)", ROW("a", DOUBLE()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, ltNullVarchar) {
+  auto call = parseCallExpr("a < cast(null as varchar)", ROW("a", VARCHAR()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, lteNull) {
+  auto call = parseCallExpr("a <= cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, lteNullReal) {
+  auto call = parseCallExpr("a <= cast(null as real)", ROW("a", REAL()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, gtNull) {
+  auto call = parseCallExpr("a > cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, gtNullInteger) {
+  auto call = parseCallExpr("a > cast(null as integer)", ROW("a", INTEGER()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, gteNull) {
+  auto call = parseCallExpr("a >= cast(null as bigint)", ROW("a", BIGINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, gteNullSmallint) {
+  auto call =
+      parseCallExpr("a >= cast(null as smallint)", ROW("a", SMALLINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
+}
+
+TEST_F(ExprToSubfieldFilterTest, gteNullTinyint) {
+  auto call = parseCallExpr("a >= cast(null as tinyint)", ROW("a", TINYINT()));
+  auto [subfield, filter] = leafCallToSubfieldFilter(call);
+
+  ASSERT_TRUE(filter);
+  validateSubfield(subfield, {"a"});
+
+  auto expected = std::make_unique<common::AlwaysFalse>();
+  VELOX_ASSERT_FILTER(expected, filter);
 }
 
 } // namespace
 } // namespace facebook::velox::exec
+
+#undef VELOX_ASSERT_FILTER
diff --git a/velox/expression/tests/ExpressionRunnerTest.cpp b/velox/expression/tests/ExpressionRunnerTest.cpp
index a0087f2d68a6..e96dba950262 100644
--- a/velox/expression/tests/ExpressionRunnerTest.cpp
+++ b/velox/expression/tests/ExpressionRunnerTest.cpp
@@ -285,8 +285,6 @@ int main(int argc, char** argv) {
   memory::initializeMemoryManager(memory::MemoryManager::Options{});
 
   filesystems::registerLocalFileSystem();
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
   exec::test::registerHiveConnector({});
   dwrf::registerDwrfWriterFactory();
 
diff --git a/velox/expression/tests/ExpressionRunnerUnitTest.cpp b/velox/expression/tests/ExpressionRunnerUnitTest.cpp
index a5ec77762812..6246dcb811cc 100644
--- a/velox/expression/tests/ExpressionRunnerUnitTest.cpp
+++ b/velox/expression/tests/ExpressionRunnerUnitTest.cpp
@@ -70,19 +70,20 @@ TEST_F(ExpressionRunnerUnitTest, run) {
 
   for (bool useSeperatePoolForInput : {true, false}) {
     LOG(INFO) << "Using useSeperatePoolForInput: " << useSeperatePoolForInput;
-    EXPECT_NO_THROW(ExpressionRunner::run(
-        inputPathStr.data(),
-        selectivityVectorPathStr.data(),
-        "length(c0)",
-        "",
-        resultPathStr.data(),
-        "verify",
-        0,
-        "",
-        "",
-        nullptr,
-        false,
-        useSeperatePoolForInput));
+    EXPECT_NO_THROW(
+        ExpressionRunner::run(
+            inputPathStr.data(),
+            selectivityVectorPathStr.data(),
+            "length(c0)",
+            "",
+            resultPathStr.data(),
+            "verify",
+            0,
+            "",
+            "",
+            nullptr,
+            false,
+            useSeperatePoolForInput));
   }
 }
 
@@ -95,8 +96,7 @@ TEST_F(ExpressionRunnerUnitTest, persistAndReproComplexSql) {
       BaseVector::wrapInConstant(1, 0, arrVector));
 
   ASSERT_EQ(
-      constantExpr->toString(),
-      "4 elements starting at 0 {[0->2] 3, [1->4] 5, [2->0] 1, [3->1] 2}");
+      constantExpr->toString(), "{[0->2] 3, [1->4] 5, [2->0] 1, [3->1] 2}");
 
   auto sqlExpr = exec::ExprSet({constantExpr}, &execCtx_, false).expr(0);
 
@@ -132,9 +132,8 @@ TEST_F(ExpressionRunnerUnitTest, persistAndReproComplexSql) {
   auto reproExprs = ExpressionRunner::parseSql(
       reproSql, nullptr, pool_.get(), reproComplexConstants);
   ASSERT_EQ(reproExprs.size(), 1);
-  // Note that ConstantExpr makes a copy of sharedConstantValue_ to guard
-  // against race conditions, which in effect falttens the array.
-  ASSERT_EQ(reproExprs[0]->toString(), "4 elements starting at 0 {3, 5, 1, 2}");
+  // Restored vector should have the exact same structure as the original one.
+  ASSERT_EQ(reproExprs[0]->toString(), constantExpr->toString());
 }
 
 TEST_F(ExpressionRunnerUnitTest, primitiveConstantsInexpressibleInSql) {
diff --git a/velox/expression/tests/ExpressionVerifier.cpp b/velox/expression/tests/ExpressionVerifier.cpp
index 3f5270892986..f096cd9c3dd8 100644
--- a/velox/expression/tests/ExpressionVerifier.cpp
+++ b/velox/expression/tests/ExpressionVerifier.cpp
@@ -15,10 +15,14 @@
  */
 
 #include "velox/expression/tests/ExpressionVerifier.h"
+#include <boost/lexical_cast.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
 #include "velox/common/base/Fs.h"
 #include "velox/core/PlanNode.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
 #include "velox/expression/Expr.h"
+#include "velox/parse/TypeResolver.h"
 #include "velox/vector/VectorSaver.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
@@ -47,11 +51,20 @@ void logInputs(const std::vector<fuzzer::InputTestCase>& inputTestCases) {
   }
 }
 
+// Generate random id for plannode. Eventually used for fuzzer table
+// uniqueness in Presto SOT tests.
+std::string generateRandomId() {
+  auto id = boost::uuids::to_string(boost::uuids::random_generator()());
+  folly::MutableStringPiece msp(&id[0], id.size());
+  msp.replaceAll("-", "_");
+  return id;
+}
+
 core::PlanNodePtr makeSourcePlan(
     const RowVectorPtr& input,
     const std::vector<core::TypedExprPtr>& transformProjections) {
   core::PlanNodePtr source = std::make_shared<core::ValuesNode>(
-      "values", std::vector<RowVectorPtr>{input});
+      generateRandomId(), std::vector<RowVectorPtr>{input});
 
   std::vector<std::string> transformNames(transformProjections.size());
   // If we need to transform types into intermediate types, add an extra
@@ -181,12 +194,14 @@ void transformInputTestCases(
   const auto [transformedInputs, transformProjections] =
       referenceQueryRunner->inputProjections(input);
   for (const auto& expr : transformProjections) {
-    transformPlans.push_back(core::Expressions::inferTypes(
-        expr, transformedInputs[0]->type(), pool));
+    transformPlans.push_back(
+        core::Expressions::inferTypes(
+            expr, transformedInputs[0]->type(), pool));
   }
   for (int i = 0; i < transformedInputs.size(); ++i) {
-    transformedInputTestCases.push_back(fuzzer::InputTestCase{
-        transformedInputs[i], inputTestCases[i].activeRows});
+    transformedInputTestCases.push_back(
+        fuzzer::InputTestCase{
+            transformedInputs[i], inputTestCases[i].activeRows});
   }
 }
 
@@ -419,6 +434,7 @@ ExpressionVerifier::verify(
             // Throws in case only one evaluation path throws exception.
             // Otherwise, return false to signal that the expression failed.
             if (exceptionCommonPtr && exceptionReference) {
+              LOG(INFO) << "Both paths threw exception.";
               verificationStates.push_back(VerificationState::kBothPathsThrow);
             } else {
               verificationStates.push_back(
diff --git a/velox/expression/tests/GenericWriterTest.cpp b/velox/expression/tests/GenericWriterTest.cpp
index 99ba9eab6aa8..667d91011686 100644
--- a/velox/expression/tests/GenericWriterTest.cpp
+++ b/velox/expression/tests/GenericWriterTest.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 #include <optional>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/VectorReaders.h"
 #include "velox/expression/VectorWriters.h"
 #include "velox/functions/Udf.h"
@@ -32,6 +33,8 @@ using namespace facebook::velox::exec;
 namespace facebook::velox {
 namespace {
 
+static constexpr vector_size_t invalidSize = -1;
+
 class GenericWriterTest : public functions::test::FunctionBaseTest {};
 
 TEST_F(GenericWriterTest, boolean) {
@@ -39,6 +42,7 @@ TEST_F(GenericWriterTest, boolean) {
   BaseVector::ensureWritable(SelectivityVector(5), BOOLEAN(), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   for (int i = 0; i < 5; ++i) {
@@ -65,6 +69,7 @@ TEST_F(GenericWriterTest, integer) {
   BaseVector::ensureWritable(SelectivityVector(100), BIGINT(), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   for (int i = 0; i < 100; ++i) {
@@ -87,6 +92,7 @@ TEST_F(GenericWriterTest, ArrayOfGeneric) {
       SelectivityVector(2), ARRAY(BIGINT()), pool(), result);
 
   VectorWriter<Array<Any>> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result->as<ArrayVector>());
 
   for (int i = 0; i < 2; ++i) {
@@ -140,6 +146,7 @@ TEST_F(GenericWriterTest, ensureSizeDoesNotResize) {
   BaseVector::ensureWritable(SelectivityVector(6), VARCHAR(), pool(), result);
   EXPECT_EQ(result->size(), 6);
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
   writer.ensureSize(1);
   EXPECT_EQ(result->size(), 6);
@@ -150,6 +157,7 @@ TEST_F(GenericWriterTest, varchar) {
   BaseVector::ensureWritable(SelectivityVector(6), VARCHAR(), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   for (int i = 0; i < 5; ++i) {
@@ -177,6 +185,7 @@ TEST_F(GenericWriterTest, arrayAnyCast) {
       SelectivityVector(5), ARRAY(BIGINT()), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
   for (int i = 0; i < 5; ++i) {
     writer.setOffset(i);
@@ -209,6 +218,7 @@ TEST_F(GenericWriterTest, castToDifferentTypesNotSupported) {
   BaseVector::ensureWritable(
       SelectivityVector(5), ARRAY(BIGINT()), pool(), result);
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   writer.setOffset(0);
@@ -232,6 +242,7 @@ TEST_F(GenericWriterTest, arrayIntCast) {
       SelectivityVector(5), ARRAY(BIGINT()), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
   for (int i = 0; i < 5; ++i) {
     writer.setOffset(i);
@@ -266,6 +277,7 @@ TEST_F(GenericWriterTest, arrayWriteThenCommitNull) {
   BaseVector::ensureWritable(rows, ARRAY(BIGINT()), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
   {
     writer.setOffset(0);
@@ -300,6 +312,7 @@ TEST_F(GenericWriterTest, genericWriteThenCommitNull) {
   BaseVector::ensureWritable(rows, CppToType<test_t>::create(), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
   {
     writer.setOffset(0);
@@ -335,6 +348,7 @@ TEST_F(GenericWriterTest, mapAnyAnyCast) {
       SelectivityVector(4), MAP(VARCHAR(), BIGINT()), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   for (int i = 0; i < 4; ++i) {
@@ -370,6 +384,7 @@ TEST_F(GenericWriterTest, mapVarcharIntCast) {
       SelectivityVector(4), MAP(VARCHAR(), BIGINT()), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   for (int i = 0; i < 4; ++i) {
@@ -408,6 +423,7 @@ TEST_F(GenericWriterTest, row) {
       result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   for (int i = 0; i < 3; ++i) {
@@ -470,6 +486,7 @@ TEST_F(GenericWriterTest, dynamicRow) {
       SelectivityVector(6), ROW({BIGINT(), DOUBLE()}), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   writer.setOffset(0);
@@ -551,6 +568,7 @@ TEST_F(GenericWriterTest, nested) {
       result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   for (int i = 0; i < 3; ++i) {
@@ -627,6 +645,7 @@ TEST_F(GenericWriterTest, commitNull) {
   BaseVector::ensureWritable(SelectivityVector(3), BIGINT(), pool(), result);
 
   VectorWriter<Any> writer;
+  VELOX_ASSERT_THROW(writer.ensureSize(invalidSize), "");
   writer.init(*result);
 
   for (int i = 0; i < 3; ++i) {
diff --git a/velox/expression/tests/MapViewTest.cpp b/velox/expression/tests/MapViewTest.cpp
index 570897f91717..df92232797fa 100644
--- a/velox/expression/tests/MapViewTest.cpp
+++ b/velox/expression/tests/MapViewTest.cpp
@@ -775,7 +775,7 @@ TEST_F(NullFreeMapViewTest, materialize) {
 
 TEST_F(NullableMapViewTest, materialize) {
   auto result = evaluate(
-      "map(array_constructor(1, 2),array_constructor(1, NULL))",
+      "map(array_constructor(1, 2),array_constructor(1, null::bigint))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -789,7 +789,7 @@ TEST_F(NullableMapViewTest, materialize) {
 
 TEST_F(NullableMapViewTest, materializeNested) {
   auto result = evaluate(
-      "map(array_constructor(1, 2), array_constructor(array_constructor(1, null), null))",
+      "map(array_constructor(1, 2), array_constructor(array_constructor(1, null::bigint), null::bigint[]))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
diff --git a/velox/expression/tests/MapWriterTest.cpp b/velox/expression/tests/MapWriterTest.cpp
index 3394ed965687..d793ea83767b 100644
--- a/velox/expression/tests/MapWriterTest.cpp
+++ b/velox/expression/tests/MapWriterTest.cpp
@@ -20,16 +20,18 @@
 #include <optional>
 #include <tuple>
 
-#include <velox/expression/VectorReaders.h>
-#include <velox/vector/ComplexVector.h>
-#include <velox/vector/DecodedVector.h>
-#include <velox/vector/SelectivityVector.h>
 #include "folly/container/F14Map.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/testutil/TestValue.h"
+#include "velox/expression/VectorReaders.h"
 #include "velox/expression/VectorWriters.h"
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/StringView.h"
 #include "velox/type/Type.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/SelectivityVector.h"
 namespace facebook::velox {
 namespace {
 
@@ -138,6 +140,12 @@ class MapWriterTest : public functions::test::FunctionBaseTest {
     writer.writer->setOffset(0);
     return writer;
   }
+
+ protected:
+  static void SetUpTestCase() {
+    FunctionBaseTest::SetUpTestCase();
+    common::testutil::TestValue::enable();
+  }
 };
 
 TEST_F(MapWriterTest, addNull) {
@@ -556,7 +564,7 @@ TEST_F(MapWriterTest, copyFromNullableMapView) {
       Map<int64_t, int64_t>>({"copy_from_nullable_map_view"});
 
   auto result = evaluate(
-      "copy_from_nullable_map_view(map(array_constructor(1,2,3),array_constructor(4,null,6)))",
+      "copy_from_nullable_map_view(map(array_constructor(1,2,3),array_constructor(4,null::bigint,6)))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   // Test results.
@@ -802,5 +810,69 @@ TEST_F(MapWriterTest, errorHandlingE2E) {
   assertEqualVectors(result, expected);
 }
 
+DEBUG_ONLY_TEST_F(MapWriterTest, resizeErrorHandling) {
+  // When resizing the child Vectors it's possible that an error is thrown, e.g.
+  // due to running out of memory or the Driver shutting down, ensure the Writer
+  // does not end up in an inconsistent state when this happens.
+  auto [result, vectorWriter] = makeTestWriter();
+  const auto keysVector = vectorWriter->vector().mapKeys();
+  const auto valuesVector = vectorWriter->vector().mapValues();
+
+  vectorWriter->setOffset(0);
+  auto& mapWriter = vectorWriter->current();
+  mapWriter.add_item() = std::make_tuple(100, 100);
+
+  // Simulate an error growing the Values Buffer in the key's Vector.
+  {
+    const std::string errorMessage = "Simulated failure in memory allocation";
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::FlatVector::resizeValues",
+        std::function<void(FlatVector<int64_t>*)>(
+            [&](FlatVector<int64_t>*) { VELOX_FAIL(errorMessage); }));
+    VELOX_ASSERT_THROW(mapWriter.add_item(), errorMessage);
+  }
+
+  // The child Vectors should not have been resized due to the error.
+  VELOX_CHECK_EQ(keysVector->size(), 1);
+  VELOX_CHECK_EQ(valuesVector->size(), 1);
+
+  // If we call add_item again it should resize the child Vectors to accommodate
+  // the new entry. If the MapWriter is in an invalid state it will think the
+  // children have already been resized.
+  mapWriter.add_item() = std::make_tuple(200, 200);
+  VELOX_CHECK_EQ(keysVector->size(), 2);
+  VELOX_CHECK_EQ(valuesVector->size(), 2);
+
+  // Simulate an error growing the Values Buffer in the value's Vector.
+  {
+    const std::string errorMessage = "Simulated failure in memory allocation";
+    // Fail on the second call since the first call will be for the key's
+    // Vector.
+    size_t callCount = 0;
+    SCOPED_TESTVALUE_SET(
+        "facebook::velox::FlatVector::resizeValues",
+        std::function<void(FlatVector<int64_t>*)>([&](FlatVector<int64_t>*) {
+          callCount++;
+
+          if (callCount == 2) {
+            VELOX_FAIL(errorMessage);
+          }
+        }));
+    VELOX_ASSERT_THROW(mapWriter.add_item(), errorMessage);
+  }
+
+  // The key Vector should have been resized by the value Vector should not have
+  // been due to the error.
+  VELOX_CHECK_EQ(keysVector->size(), 4);
+  VELOX_CHECK_EQ(valuesVector->size(), 2);
+
+  // If we call add_item again it should resize the value Vector to accommodate
+  // the new entry. If the MapWriter is in an invalid state it will think the
+  // children have already been resized.
+  mapWriter.add_item() = std::make_tuple(300, 300);
+  VELOX_CHECK_EQ(keysVector->size(), 4);
+  VELOX_CHECK_EQ(valuesVector->size(), 4);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/expression/tests/ReverseSignatureBinderTest.cpp b/velox/expression/tests/ReverseSignatureBinderTest.cpp
index a79c19114be2..dabe0483262e 100644
--- a/velox/expression/tests/ReverseSignatureBinderTest.cpp
+++ b/velox/expression/tests/ReverseSignatureBinderTest.cpp
@@ -109,5 +109,18 @@ TEST_F(ReverseSignatureBinderTest, unsupported) {
   testBindingFailure(signature, DECIMAL(13, 6));
 }
 
+TEST_F(ReverseSignatureBinderTest, integerConstraint) {
+  auto signature = exec::FunctionSignatureBuilder()
+                       .integerVariable("r_precision", "38")
+                       .integerVariable("r_scale", "0")
+                       .returnType("decimal(r_precision, r_scale)")
+                       .argumentType("varchar")
+                       .build();
+
+  // The precision and scale are fixed to the constraints.
+  testBindingSuccess(signature, DECIMAL(38, 0), {});
+  testBindingFailure(signature, DECIMAL(13, 6));
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/expression/tests/RowViewTest.cpp b/velox/expression/tests/RowViewTest.cpp
index 58864c9f753e..992c521c58c9 100644
--- a/velox/expression/tests/RowViewTest.cpp
+++ b/velox/expression/tests/RowViewTest.cpp
@@ -23,11 +23,10 @@
 #include "velox/functions/prestosql/Comparisons.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
+namespace facebook::velox::functions::test {
 namespace {
 
-using namespace facebook::velox;
-using namespace facebook::velox::functions;
-using namespace facebook::velox::test;
+using velox::test::assertEqualVectors;
 
 DecodedVector* decode(DecodedVector& decoder, const BaseVector& vector) {
   SelectivityVector rows(vector.size());
@@ -397,7 +396,7 @@ TEST_F(NullFreeRowViewTest, e2eCompare) {
 
 TEST_F(NullableRowViewTest, materialize) {
   auto result = evaluate(
-      "row_constructor(1, 'hi', array_constructor(1, 2, null))",
+      "row_constructor(1, 'hi', array_constructor(1, 2, null::bigint))",
       makeRowVector({makeFlatVector<int64_t>(1)}));
 
   DecodedVector decoded;
@@ -406,7 +405,7 @@ TEST_F(NullableRowViewTest, materialize) {
 
   std::tuple<
       std::optional<int64_t>,
-      std::optional<std::string>,
+      std::optional<StringView>,
       std::optional<std::vector<std::optional<int64_t>>>>
       expected{1, "hi", {{1, 2, std::nullopt}}};
   ASSERT_EQ(reader[0].materialize(), expected);
@@ -517,4 +516,6 @@ TEST_F(DynamicRowViewTest, castToDynamicRowInFunction) {
     assertEqualVectors(makeFlatVector<int64_t>({2, 2}), result);
   }
 }
+
 } // namespace
+} // namespace facebook::velox::functions::test
diff --git a/velox/expression/tests/SignatureBinderTest.cpp b/velox/expression/tests/SignatureBinderTest.cpp
index 7f1c747f4e31..0bb82540e5fa 100644
--- a/velox/expression/tests/SignatureBinderTest.cpp
+++ b/velox/expression/tests/SignatureBinderTest.cpp
@@ -15,33 +15,127 @@
  */
 #include "velox/expression/SignatureBinder.h"
 #include <gtest/gtest.h>
-#include <velox/type/HugeInt.h>
 #include <vector>
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/types/BigintEnumRegistration.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/HugeInt.h"
 #include "velox/type/OpaqueCustomTypes.h"
 
 namespace facebook::velox::exec::test {
 namespace {
 
+std::string toString(const std::vector<TypePtr>& types) {
+  std::stringstream out;
+
+  for (auto i = 0; i < types.size(); ++i) {
+    if (i > 0) {
+      out << ", ";
+    }
+    out << types.at(i)->toString();
+  }
+
+  return out.str();
+}
+
 void testSignatureBinder(
     const std::shared_ptr<exec::FunctionSignature>& signature,
     const std::vector<TypePtr>& actualTypes,
     const TypePtr& expectedReturnType) {
+  SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
+  SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
+
+  {
+    exec::SignatureBinder binder(*signature, actualTypes);
+    ASSERT_TRUE(binder.tryBind());
+  }
+
   exec::SignatureBinder binder(*signature, actualTypes);
-  ASSERT_TRUE(binder.tryBind());
+  std::vector<Coercion> coercions;
+  ASSERT_TRUE(binder.tryBindWithCoercions(coercions));
+
+  ASSERT_EQ(coercions.size(), actualTypes.size());
+  for (const auto& coercion : coercions) {
+    ASSERT_TRUE(coercion.type == nullptr);
+  }
 
   auto returnType = binder.tryResolveReturnType();
   ASSERT_TRUE(returnType != nullptr);
   ASSERT_EQ(*expectedReturnType, *returnType);
 }
 
+void assertCannotBind(
+    const std::shared_ptr<exec::FunctionSignature>& signature,
+    const std::vector<TypePtr>& actualTypes,
+    bool allowCoercion = false) {
+  SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
+  SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
+
+  {
+    exec::SignatureBinder binder(*signature, actualTypes);
+    ASSERT_FALSE(binder.tryBind());
+  }
+
+  if (allowCoercion) {
+    exec::SignatureBinder binder(*signature, actualTypes);
+    std::vector<Coercion> coercions;
+    ASSERT_FALSE(binder.tryBindWithCoercions(coercions));
+  }
+}
+
 void assertCannotResolve(
     const std::shared_ptr<exec::FunctionSignature>& signature,
     const std::vector<TypePtr>& actualTypes) {
+  SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
+  SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
+
+  {
+    exec::SignatureBinder binder(*signature, actualTypes);
+    ASSERT_TRUE(binder.tryBind());
+  }
+
   exec::SignatureBinder binder(*signature, actualTypes);
-  ASSERT_FALSE(binder.tryBind());
+  std::vector<Coercion> coercions;
+  ASSERT_TRUE(binder.tryBindWithCoercions(coercions));
+
+  ASSERT_EQ(coercions.size(), actualTypes.size());
+  for (const auto& coercion : coercions) {
+    ASSERT_TRUE(coercion.type == nullptr);
+  }
+
+  auto returnType = binder.tryResolveReturnType();
+  ASSERT_TRUE(returnType == nullptr);
+}
+
+TEST(SignatureBinderTest, unknown) {
+  {
+    // (T, T) -> array(T)
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("array(T)")
+                         .argumentType("T")
+                         .argumentType("T")
+                         .build();
+
+    testSignatureBinder(signature, {INTEGER(), INTEGER()}, ARRAY(INTEGER()));
+    assertCannotBind(signature, {INTEGER(), UNKNOWN()});
+    assertCannotBind(signature, {UNKNOWN(), INTEGER()});
+  }
+
+  {
+    // (T...) -> array(T)
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("array(T)")
+                         .variableArity("T")
+                         .build();
+
+    testSignatureBinder(signature, {INTEGER(), INTEGER()}, ARRAY(INTEGER()));
+    assertCannotBind(signature, {INTEGER(), UNKNOWN()});
+    assertCannotBind(signature, {UNKNOWN(), INTEGER()});
+  }
 }
 
 TEST(SignatureBinderTest, decimals) {
@@ -231,7 +325,7 @@ TEST(SignatureBinderTest, decimals) {
       std::unordered_map<std::string, int> integerVariables;
       ASSERT_EQ(
           exec::SignatureBinder::tryResolveType(
-              typeSignature, {}, {}, integerVariables),
+              typeSignature, {}, {}, integerVariables, {}, {}),
           nullptr);
     }
     // Type parameter + constraint = error.
@@ -251,7 +345,7 @@ TEST(SignatureBinderTest, decimals) {
                            .argumentType("DECIMAL(precision, 6)")
                            .build();
       testSignatureBinder(signature, {DECIMAL(11, 6)}, BOOLEAN());
-      assertCannotResolve(signature, {DECIMAL(11, 8)});
+      assertCannotBind(signature, {DECIMAL(11, 8)});
     }
     {
       auto signature = exec::FunctionSignatureBuilder()
@@ -263,10 +357,23 @@ TEST(SignatureBinderTest, decimals) {
                            .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)});
+      assertCannotBind(signature, {DECIMAL(11, 6), DECIMAL(20, 4)});
+      assertCannotBind(signature, {DECIMAL(11, 8), DECIMAL(18, 4)});
     }
   }
+
+  // The precision and scale are fixed to the constraints.
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .integerVariable("a_precision", "38")
+                         .integerVariable("a_scale", "0")
+                         .returnType("varchar")
+                         .argumentType("decimal(a_precision, a_scale)")
+                         .build();
+
+    testSignatureBinder(signature, {DECIMAL(38, 0)}, VARCHAR());
+    assertCannotBind(signature, {DECIMAL(18, 6)});
+  }
 }
 
 TEST(SignatureBinderTest, computation) {
@@ -532,7 +639,7 @@ TEST(SignatureBinderTest, generics) {
     testSignatureBinder(signature, {ARRAY(BIGINT()), BIGINT()}, BOOLEAN());
     testSignatureBinder(
         signature, {ARRAY(DECIMAL(20, 3)), DECIMAL(20, 3)}, BOOLEAN());
-    assertCannotResolve(signature, {ARRAY(DECIMAL(20, 3)), DECIMAL(20, 4)});
+    assertCannotBind(signature, {ARRAY(DECIMAL(20, 3)), DECIMAL(20, 4)});
   }
 
   // array(array(T)), array(T) -> boolean
@@ -653,11 +760,11 @@ TEST(SignatureBinderTest, unresolvable) {
                          .build();
 
     // wrong type
-    assertCannotResolve(signature, {BIGINT()});
+    assertCannotBind(signature, {BIGINT()});
 
     // wrong number of arguments
-    assertCannotResolve(signature, {});
-    assertCannotResolve(signature, {INTEGER(), DOUBLE()});
+    assertCannotBind(signature, {});
+    assertCannotBind(signature, {INTEGER(), DOUBLE()});
   }
 
   // integer, double -> varchar
@@ -669,12 +776,12 @@ TEST(SignatureBinderTest, unresolvable) {
                          .build();
 
     // wrong type
-    assertCannotResolve(signature, {BIGINT()});
-    assertCannotResolve(signature, {INTEGER(), INTEGER()});
-    assertCannotResolve(signature, {INTEGER(), DOUBLE(), INTEGER()});
+    assertCannotBind(signature, {BIGINT()});
+    assertCannotBind(signature, {INTEGER(), INTEGER()});
+    assertCannotBind(signature, {INTEGER(), DOUBLE(), INTEGER()});
 
     // wrong number of arguments
-    assertCannotResolve(signature, {});
+    assertCannotBind(signature, {});
   }
 
   // integer... -> varchar
@@ -685,8 +792,8 @@ TEST(SignatureBinderTest, unresolvable) {
                          .build();
 
     // wrong type
-    assertCannotResolve(signature, {BIGINT()});
-    assertCannotResolve(signature, {INTEGER(), BIGINT()});
+    assertCannotBind(signature, {BIGINT()});
+    assertCannotBind(signature, {INTEGER(), BIGINT()});
   }
 
   // row(bigint, varchar) -> bigint
@@ -699,8 +806,8 @@ TEST(SignatureBinderTest, unresolvable) {
     testSignatureBinder(signature, {ROW({BIGINT(), VARCHAR()})}, BIGINT());
 
     // wrong type
-    assertCannotResolve(signature, {ROW({BIGINT()})});
-    assertCannotResolve(signature, {ROW({BIGINT(), VARCHAR(), BOOLEAN()})});
+    assertCannotBind(signature, {ROW({BIGINT()})});
+    assertCannotBind(signature, {ROW({BIGINT(), VARCHAR(), BOOLEAN()})});
   }
 
   // array(row(boolean)) -> bigint
@@ -713,8 +820,8 @@ TEST(SignatureBinderTest, unresolvable) {
     testSignatureBinder(signature, {ARRAY(ROW({BOOLEAN()}))}, BIGINT());
 
     // wrong type
-    assertCannotResolve(signature, {ARRAY(ROW({BOOLEAN(), BIGINT()}))});
-    assertCannotResolve(signature, {ARRAY(ROW({BIGINT()}))});
+    assertCannotBind(signature, {ARRAY(ROW({BOOLEAN(), BIGINT()}))});
+    assertCannotBind(signature, {ARRAY(ROW({BIGINT()}))});
   }
 }
 
@@ -790,6 +897,7 @@ TEST(SignatureBinderTest, logicalType) {
 
 TEST(SignatureBinderTest, customType) {
   registerTimestampWithTimeZoneType();
+  registerBigintEnumType();
 
   // Custom type as an argument type.
   {
@@ -825,6 +933,18 @@ TEST(SignatureBinderTest, customType) {
     testSignatureBinder(signature, {INTEGER()}, TIMESTAMP_WITH_TIME_ZONE());
   }
 
+  {
+    // bigint_enum(enumParameters) -> bigint
+    auto signature = exec::FunctionSignatureBuilder()
+                         .enumVariable("E")
+                         .returnType("bigint")
+                         .argumentType("bigint_enum(E)")
+                         .build();
+    LongEnumParameter moodInfo(
+        "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
+    testSignatureBinder(signature, {BIGINT_ENUM(moodInfo)}, BIGINT());
+  }
+
   // Unknown custom type.
   VELOX_ASSERT_THROW(
       exec::FunctionSignatureBuilder()
@@ -910,7 +1030,7 @@ TEST(SignatureBinderTest, namedRows) {
     testSignatureBinder(signature, {ROW({{"bla", VARCHAR()}})}, VARCHAR());
 
     // Cannot bind if field doesn't have the same name set.
-    assertCannotResolve(signature, {ROW({{VARCHAR()}})});
+    assertCannotBind(signature, {ROW({{VARCHAR()}})});
   }
 
   // Multiple named row field.
@@ -931,7 +1051,7 @@ TEST(SignatureBinderTest, namedRows) {
         VARCHAR());
 
     // But not if one of the named fields is not.
-    assertCannotResolve(
+    assertCannotBind(
         signature,
         {ROW({{"foo", VARCHAR()}, {"fighters", BIGINT()}, {"bla", DOUBLE()}})});
   }
@@ -983,5 +1103,412 @@ TEST(SignatureBinderTest, namedRows) {
   }
 }
 
+void testCoercions(
+    const exec::FunctionSignaturePtr& signature,
+    const std::vector<TypePtr>& actualTypes,
+    const std::vector<TypePtr>& expectedCoercions,
+    const TypePtr& expectedReturnType) {
+  SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
+  SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
+
+  {
+    exec::SignatureBinder binder(*signature, actualTypes);
+    ASSERT_FALSE(binder.tryBind());
+  }
+
+  exec::SignatureBinder binder(*signature, actualTypes);
+
+  std::vector<Coercion> coercions;
+  ASSERT_TRUE(binder.tryBindWithCoercions(coercions));
+
+  ASSERT_EQ(expectedCoercions.size(), coercions.size());
+  for (auto i = 0; i < expectedCoercions.size(); ++i) {
+    const auto& coercionType = coercions[i].type;
+    VELOX_ASSERT_EQ_TYPES(coercionType, expectedCoercions[i]);
+  }
+
+  auto returnType = binder.tryResolveReturnType();
+  VELOX_ASSERT_EQ_TYPES(returnType, expectedReturnType);
+}
+
+void testNoCoercions(
+    const exec::FunctionSignaturePtr& signature,
+    const std::vector<TypePtr>& actualTypes,
+    const TypePtr& expectedReturnType) {
+  SCOPED_TRACE(fmt::format("Signature: {}", signature->toString()));
+  SCOPED_TRACE(fmt::format("Actual types: {}", toString(actualTypes)));
+
+  {
+    exec::SignatureBinder binder(*signature, actualTypes);
+    ASSERT_TRUE(binder.tryBind());
+
+    auto returnType = binder.tryResolveReturnType();
+    ASSERT_TRUE(returnType != nullptr);
+    ASSERT_EQ(*expectedReturnType, *returnType);
+  }
+
+  {
+    exec::SignatureBinder binder(*signature, actualTypes);
+
+    std::vector<Coercion> coercions;
+    ASSERT_TRUE(binder.tryBindWithCoercions(coercions));
+
+    auto returnType = binder.tryResolveReturnType();
+    ASSERT_TRUE(returnType != nullptr);
+    ASSERT_EQ(*expectedReturnType, *returnType);
+
+    ASSERT_EQ(actualTypes.size(), coercions.size());
+    for (auto i = 0; i < actualTypes.size(); ++i) {
+      ASSERT_TRUE(coercions[i].type == nullptr);
+    }
+  }
+}
+
+TEST(SignatureBinderTest, coercions) {
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("smallint")
+                         .argumentType("integer")
+                         .argumentType("bigint")
+                         .argumentType("real")
+                         .argumentType("double")
+                         .build();
+
+    testCoercions(
+        signature,
+        {TINYINT(), TINYINT(), TINYINT(), TINYINT(), TINYINT()},
+        {SMALLINT(), INTEGER(), BIGINT(), REAL(), DOUBLE()},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {SMALLINT(), SMALLINT(), SMALLINT(), REAL(), REAL()},
+        {nullptr, INTEGER(), BIGINT(), nullptr, DOUBLE()},
+        BOOLEAN());
+
+    testNoCoercions(
+        signature,
+        {SMALLINT(), INTEGER(), BIGINT(), REAL(), DOUBLE()},
+        BOOLEAN());
+
+    assertCannotBind(
+        signature,
+        {INTEGER(), INTEGER(), INTEGER(), INTEGER(), INTEGER()},
+        /*allowCoercion*/ true);
+
+    assertCannotBind(
+        signature,
+        {SMALLINT(), INTEGER(), VARCHAR(), INTEGER(), INTEGER()},
+        /*allowCoercion*/ true);
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("smallint")
+                         .variableArity("integer")
+                         .build();
+
+    testCoercions(
+        signature,
+        {TINYINT(), TINYINT(), TINYINT()},
+        {SMALLINT(), INTEGER(), INTEGER()},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {TINYINT(), INTEGER(), TINYINT()},
+        {SMALLINT(), nullptr, INTEGER()},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {SMALLINT(), TINYINT(), INTEGER()},
+        {nullptr, INTEGER(), nullptr},
+        BOOLEAN());
+
+    testNoCoercions(signature, {SMALLINT(), INTEGER()}, BOOLEAN());
+    testNoCoercions(signature, {SMALLINT(), INTEGER(), INTEGER()}, BOOLEAN());
+
+    assertCannotBind(
+        signature,
+        {SMALLINT(), INTEGER(), VARCHAR(), INTEGER(), INTEGER()},
+        /*allowCoercion*/ true);
+
+    assertCannotBind(
+        signature,
+        {SMALLINT(), INTEGER(), BIGINT(), INTEGER(), INTEGER()},
+        /*allowCoercion*/ true);
+  }
+}
+
+TEST(SignatureBinderTest, complexTypeCoercions) {
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .argumentType("array(bigint)")
+                         .argumentType("map(bigint, double)")
+                         .argumentType("row(integer, bigint, double)")
+                         .argumentType("row(a integer,b bigint,c double)")
+                         .build();
+    testCoercions(
+        signature,
+        {
+            ARRAY(INTEGER()),
+            MAP(INTEGER(), REAL()),
+            ROW({TINYINT(), SMALLINT(), REAL()}),
+            ROW({"a", "b", "c"}, {TINYINT(), SMALLINT(), REAL()}),
+        },
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        BOOLEAN());
+
+    testNoCoercions(
+        signature,
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        BOOLEAN());
+
+    // Wrong array type.
+    assertCannotBind(
+        signature,
+        {
+            ARRAY(VARCHAR()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        /*allowCoercion*/ true);
+
+    // Wrong map value type.
+    assertCannotBind(
+        signature,
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), VARCHAR()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        /*allowCoercion*/ true);
+
+    // Wrong struct field type.
+    assertCannotBind(
+        signature,
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), VARCHAR(), DOUBLE()}),
+            ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        /*allowCoercion*/ true);
+
+    // Wrong struct field name.
+    assertCannotBind(
+        signature,
+        {
+            ARRAY(BIGINT()),
+            MAP(BIGINT(), DOUBLE()),
+            ROW({INTEGER(), BIGINT(), DOUBLE()}),
+            ROW({"A", "b", "c"}, {INTEGER(), BIGINT(), DOUBLE()}),
+        },
+        /*allowCoercion*/ true);
+  }
+}
+
+TEST(SignatureBinderTest, genericCoercions) {
+  // (T,..) -> boolean
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .typeVariable("T")
+                         .argumentType("T")
+                         .variableArity("T")
+                         .build();
+
+    testCoercions(
+        signature,
+        {TINYINT(), SMALLINT(), INTEGER()},
+        {INTEGER(), INTEGER(), nullptr},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {INTEGER(), SMALLINT(), TINYINT()},
+        {nullptr, INTEGER(), INTEGER()},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {ARRAY(TINYINT()), ARRAY(INTEGER())},
+        {ARRAY(INTEGER()), nullptr},
+        BOOLEAN());
+
+    testCoercions(
+        signature,
+        {MAP(TINYINT(), DOUBLE()), MAP(INTEGER(), REAL())},
+        {MAP(INTEGER(), DOUBLE()), MAP(INTEGER(), DOUBLE())},
+        BOOLEAN());
+
+    testNoCoercions(signature, {INTEGER(), INTEGER()}, BOOLEAN());
+
+    assertCannotBind(signature, {INTEGER(), VARCHAR()}, /*allowCoercion*/ true);
+  }
+
+  // (T, array(T)) -> boolean
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("boolean")
+                         .typeVariable("T")
+                         .argumentType("T")
+                         .argumentType("array(T)")
+                         .build();
+
+    testCoercions(
+        signature,
+        {TINYINT(), ARRAY(INTEGER())},
+        {INTEGER(), nullptr},
+        BOOLEAN());
+
+    testNoCoercions(signature, {INTEGER(), ARRAY(INTEGER())}, BOOLEAN());
+
+    assertCannotBind(
+        signature, {INTEGER(), ARRAY(VARCHAR())}, /*allowCoercion=*/true);
+    assertCannotBind(
+        signature, {VARCHAR(), ARRAY(INTEGER())}, /*allowCoercion=*/true);
+  }
+}
+
+TEST(SignatureBinderTest, homogeneousRow) {
+  // row(T, ...) -> boolean
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("boolean")
+                         .argumentType("row(T, ...)")
+                         .build();
+
+    testSignatureBinder(signature, {ROW({BIGINT()})}, BOOLEAN());
+
+    testSignatureBinder(
+        signature, {ROW({BIGINT(), BIGINT(), BIGINT()})}, BOOLEAN());
+
+    testSignatureBinder(signature, {ROW({VARCHAR(), VARCHAR()})}, BOOLEAN());
+
+    testSignatureBinder(
+        signature,
+        {ROW({MAP(INTEGER(), REAL()), MAP(INTEGER(), REAL())})},
+        BOOLEAN());
+
+    // Named row fields should also bind when types are homogeneous.
+    testSignatureBinder(
+        signature,
+        {ROW({{"first", VARCHAR()}, {"second", VARCHAR()}})},
+        BOOLEAN());
+
+    // Mixed named-row element types should fail to bind.
+    assertCannotBind(signature, {ROW({{"x", BIGINT()}, {"y", VARCHAR()}})});
+
+    testSignatureBinder(signature, {ROW({})}, BOOLEAN());
+
+    assertCannotBind(signature, {ROW({BIGINT(), VARCHAR()})});
+
+    assertCannotBind(signature, {BIGINT()});
+    assertCannotBind(signature, {ARRAY(BIGINT())});
+  }
+
+  // row(T:orderable, ...) -> boolean
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .orderableTypeVariable("T")
+                         .returnType("boolean")
+                         .argumentType("row(T, ...)")
+                         .build();
+
+    testSignatureBinder(signature, {ROW({BIGINT()})}, BOOLEAN());
+
+    // MAP type is not orderable.
+    assertCannotBind(signature, {ROW({MAP(INTEGER(), REAL())})});
+  }
+
+  // (row(T, ...), row(T, ...)) -> T
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("T")
+                         .argumentType("row(T, ...)")
+                         .argumentType("row(T, ...)")
+                         .build();
+
+    testSignatureBinder(
+        signature,
+        {ROW({BIGINT(), BIGINT()}), ROW({BIGINT(), BIGINT(), BIGINT()})},
+        BIGINT());
+
+    testSignatureBinder(
+        signature, {ROW({}), ROW({BIGINT(), BIGINT(), BIGINT()})}, BIGINT());
+
+    assertCannotResolve(signature, {ROW({}), ROW({})});
+    assertCannotBind(
+        signature, {ROW({BIGINT(), BIGINT()}), ROW({VARCHAR(), VARCHAR()})});
+  }
+
+  // (row(T,...), row(U,...)) -> map(T,U)
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .typeVariable("U")
+                         .returnType("map(T,U)")
+                         .argumentType("row(T, ...)")
+                         .argumentType("row(U, ...)")
+                         .build();
+
+    testSignatureBinder(
+        signature,
+        {ROW({BIGINT(), BIGINT()}), ROW({VARCHAR(), VARCHAR(), VARCHAR()})},
+        MAP(BIGINT(), VARCHAR()));
+
+    assertCannotResolve(signature, {ROW({BIGINT(), BIGINT()}), ROW({})});
+    assertCannotBind(
+        signature, {ROW({BIGINT(), BIGINT()}), ROW({BIGINT(), VARCHAR()})});
+  }
+
+  // row(array(bigint), ...) -> bigint
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .returnType("bigint")
+                         .argumentType("row(array(bigint), ...)")
+                         .build();
+
+    testSignatureBinder(signature, {ROW({})}, BIGINT());
+    testSignatureBinder(signature, {ROW({ARRAY(BIGINT())})}, BIGINT());
+    testSignatureBinder(
+        signature, {ROW({ARRAY(BIGINT()), ARRAY(BIGINT())})}, BIGINT());
+  }
+
+  // array(row(T, ...)) -> array(T)
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .returnType("array(T)")
+                         .argumentType("array(row(T, ...))")
+                         .build();
+
+    testSignatureBinder(signature, {ARRAY(ROW({INTEGER()}))}, ARRAY(INTEGER()));
+    testSignatureBinder(
+        signature, {ARRAY(ROW({"a", "b"}, REAL()))}, ARRAY(REAL()));
+
+    assertCannotResolve(signature, {ARRAY(ROW({}))});
+  }
+}
+
 } // namespace
 } // namespace facebook::velox::exec::test
diff --git a/velox/expression/tests/SimpleFunctionInitTest.cpp b/velox/expression/tests/SimpleFunctionInitTest.cpp
index b0ea89621343..05452a74b327 100644
--- a/velox/expression/tests/SimpleFunctionInitTest.cpp
+++ b/velox/expression/tests/SimpleFunctionInitTest.cpp
@@ -17,7 +17,7 @@
 #include <glog/logging.h>
 #include <gtest/gtest.h>
 
-#include "velox/expression/Expr.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/Udf.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/type/Type.h"
@@ -99,8 +99,9 @@ TEST_F(SimpleFunctionInitTest, initializationArray) {
 
         auto rhsArrayVector = makeNullableArrayVector(
             std::vector<std::vector<std::optional<int32_t>>>{second});
-        args.push_back(std::make_shared<core::ConstantTypedExpr>(
-            BaseVector::wrapInConstant(1, 0, rhsArrayVector)));
+        args.push_back(
+            std::make_shared<core::ConstantTypedExpr>(
+                BaseVector::wrapInConstant(1, 0, rhsArrayVector)));
         exec::ExprSet expr(
             {std::make_shared<core::CallTypedExpr>(
                 ARRAY(INTEGER()), args, "non_default_behavior_with_init")},
@@ -181,8 +182,9 @@ TEST_F(SimpleFunctionInitTest, initializationMap) {
   std::vector<core::TypedExprPtr> args;
   args.push_back(std::make_shared<core::FieldAccessTypedExpr>(INTEGER(), "c0"));
 
-  args.push_back(std::make_shared<core::ConstantTypedExpr>(
-      BaseVector::wrapInConstant(1, 0, mapVectorPtr)));
+  args.push_back(
+      std::make_shared<core::ConstantTypedExpr>(
+          BaseVector::wrapInConstant(1, 0, mapVectorPtr)));
   exec::ExprSet expr(
       {std::make_shared<core::CallTypedExpr>(
           BIGINT(), args, "non_default_behavior_with_map_init")},
diff --git a/velox/expression/tests/SimpleFunctionTest.cpp b/velox/expression/tests/SimpleFunctionTest.cpp
index b800cf1a712e..d21a78be344c 100644
--- a/velox/expression/tests/SimpleFunctionTest.cpp
+++ b/velox/expression/tests/SimpleFunctionTest.cpp
@@ -574,8 +574,9 @@ TEST_F(SimpleFunctionTest, defaultNullBehavior) {
 
   // Check that default null behavior functions don't get called on a null
   // input.
-  EXPECT_NO_THROW(evaluate<SimpleVector<bool>>(
-      "default_null_behavior(c0)", makeRowVector({flatVector})));
+  EXPECT_NO_THROW(
+      evaluate<SimpleVector<bool>>(
+          "default_null_behavior(c0)", makeRowVector({flatVector})));
 }
 
 // Test that function with non-default null behavior receives parameters as
@@ -991,11 +992,11 @@ VectorPtr testVariadicArgReuse(
   // This is a bit of a round about way of creating the SimpleFunctionAdapter,
   // especially since it requires the caller to register the function as well,
   // but it should be easier to maintain.
-  auto function =
-      exec::simpleFunctions()
-          .resolveFunction(functionName, {})
-          ->createFunction()
-          ->createVectorFunction({}, {}, execCtx->queryCtx()->queryConfig());
+  auto resolved = exec::simpleFunctions().resolveFunction(functionName, {});
+  EXPECT_TRUE(resolved.has_value());
+
+  auto function = resolved->createFunction()->createVectorFunction(
+      {}, {}, execCtx->queryCtx()->queryConfig());
 
   // Create a dummy EvalCtx.
   SelectivityVector rows(inputs[0]->size());
@@ -1141,8 +1142,9 @@ TEST_F(SimpleFunctionTest, callAscii) {
   registerFunction<StringInputIntOutputFunction, int32_t, Varchar>(
       {"get_input_size"});
   auto asciiInput = makeFlatVector<std::string>({"abc123", "10% #\0"});
-  EXPECT_NO_THROW(evaluate<SimpleVector<int32_t>>(
-      "get_input_size(c0)", makeRowVector({asciiInput})));
+  EXPECT_NO_THROW(
+      evaluate<SimpleVector<int32_t>>(
+          "get_input_size(c0)", makeRowVector({asciiInput})));
 }
 
 // Return false always.
@@ -1655,4 +1657,50 @@ TEST_F(SimpleFunctionTest, toDebugString) {
       "Priority: 999997\nDefaultNullBehavior: true");
 }
 
+template <typename T>
+struct TimePlusOneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(out_type<Time>& out, const arg_type<Time>& input) {
+    out = input + 1;
+  }
+};
+
+template <typename T>
+struct ArrayTimeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void call(out_type<Array<Time>>& out, const arg_type<Array<Time>>& input) {
+    for (int i = 0; i < input.size(); i++) {
+      if (input[i].has_value()) {
+        out.push_back(input[i].value());
+      }
+    }
+  }
+};
+
+TEST_F(SimpleFunctionTest, timeTypeTest) {
+  registerFunction<TimePlusOneFunction, Time, Time>({"time_plus_one"});
+  auto data = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}, TIME()),
+  });
+  auto result = evaluate("time_plus_one(c0)", data);
+  auto expected = makeFlatVector<int64_t>({2, 3, 4}, TIME());
+  assertEqualVectors(expected, result);
+
+  // Test out Time in complex type.
+  {
+    registerFunction<ArrayTimeFunction, Array<Time>, Array<Time>>(
+        {"array_time"});
+
+    auto data = makeRowVector({
+        makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 6}}, TIME()),
+    });
+
+    auto result = evaluate("array_time(c0)", data);
+    auto expected = makeArrayVector<int64_t>({{1, 2, 3}, {4, 5, 6}}, TIME());
+    assertEqualVectors(expected, result);
+  }
+}
+
 } // namespace
diff --git a/velox/expression/tests/SpecialFormRewriteTestBase.cpp b/velox/expression/tests/SpecialFormRewriteTestBase.cpp
new file mode 100644
index 000000000000..279280e0b02e
--- /dev/null
+++ b/velox/expression/tests/SpecialFormRewriteTestBase.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/expression/tests/SpecialFormRewriteTestBase.h"
+#include "velox/expression/ExprRewriteRegistry.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+
+namespace facebook::velox::expression::test {
+
+void SpecialFormRewriteTestBase::SetUpTestCase() {
+  memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+}
+
+void SpecialFormRewriteTestBase::SetUp() {
+  functions::prestosql::registerAllScalarFunctions("");
+  parse::registerTypeResolver();
+}
+
+void SpecialFormRewriteTestBase::TearDown() {
+  expression::ExprRewriteRegistry::instance().clear();
+}
+
+void SpecialFormRewriteTestBase::testRewrite(
+    const std::string& expr,
+    const std::string& expected,
+    const RowTypePtr& type) {
+  const auto typedExpr = makeTypedExpr(expr, type);
+  const auto rewritten =
+      expression::ExprRewriteRegistry::instance().rewrite(typedExpr);
+  const auto expectedExpr = makeTypedExpr(expected, type);
+  if (*rewritten != *expectedExpr) {
+    SCOPED_TRACE(fmt::format("Input: {}", typedExpr->toString()));
+    SCOPED_TRACE(fmt::format("Rewritten: {}", rewritten->toString()));
+    SCOPED_TRACE(fmt::format("Expected: {}", expectedExpr->toString()));
+  }
+
+  ASSERT_TRUE(*rewritten == *expectedExpr);
+}
+
+} // namespace facebook::velox::expression::test
diff --git a/velox/expression/tests/SpecialFormRewriteTestBase.h b/velox/expression/tests/SpecialFormRewriteTestBase.h
new file mode 100644
index 000000000000..c792398d6c53
--- /dev/null
+++ b/velox/expression/tests/SpecialFormRewriteTestBase.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.
+ */
+
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox::expression::test {
+
+class SpecialFormRewriteTestBase : public functions::test::FunctionBaseTest {
+ protected:
+  static void SetUpTestCase();
+
+  void SetUp() override;
+
+  void TearDown() override;
+
+  /// Validates special form expression rewrites that can short circuit
+  /// expression evaluation.
+  /// @param expr Input SQL expression to be rewritten.
+  /// @param expected Expected SQL expression after rewriting `expr`.
+  /// @param type Row type containing input fields referenced by `expr`.
+  void testRewrite(
+      const std::string& expr,
+      const std::string& expected,
+      const RowTypePtr& type = ROW({}));
+};
+
+} // namespace facebook::velox::expression::test
diff --git a/velox/expression/tests/SwitchRewriteTest.cpp b/velox/expression/tests/SwitchRewriteTest.cpp
new file mode 100644
index 000000000000..c3f955c40e84
--- /dev/null
+++ b/velox/expression/tests/SwitchRewriteTest.cpp
@@ -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 <gtest/gtest.h>
+
+#include "velox/expression/tests/SpecialFormRewriteTestBase.h"
+
+namespace facebook::velox::expression {
+namespace {
+
+class SwitchRewriteTest : public expression::test::SpecialFormRewriteTestBase {
+};
+
+TEST_F(SwitchRewriteTest, basic) {
+  const auto type = ROW({"a"}, {BIGINT()});
+  testRewrite("case when false then 1234 when true then a end", "a", type);
+  testRewrite(
+      "case when false then 1234 when false then 3456 else a end", "a", type);
+  testRewrite(
+      "case when false then 100 when a > 2 then 200 when a > 4 then 300 else 5678 end",
+      "case when a > 2 then 200 when a > 4 then 300 else 5678 end",
+      type);
+  testRewrite(
+      "case when a < 5 then 1234 when a > 10 then 3456 when true then 6789 else 0 end",
+      "case when a < 5 then 1234 when a > 10 then 3456 else 6789 end",
+      type);
+}
+
+} // namespace
+} // namespace facebook::velox::expression
diff --git a/velox/expression/tests/VariadicViewTest.cpp b/velox/expression/tests/VariadicViewTest.cpp
index 346da8a43fde..715044d1e636 100644
--- a/velox/expression/tests/VariadicViewTest.cpp
+++ b/velox/expression/tests/VariadicViewTest.cpp
@@ -293,8 +293,9 @@ TEST_F(NullableVariadicViewTest, variadicIntMoreArgs) {
       {makeNullableFlatVector(std::vector<std::optional<int64_t>>{-1, -2, -3}),
        makeNullableFlatVector(
            std::vector<std::optional<int64_t>>{-4, std::nullopt, -6}),
-       makeNullableFlatVector(std::vector<std::optional<int64_t>>{
-           std::nullopt, std::nullopt, std::nullopt})});
+       makeNullableFlatVector(
+           std::vector<std::optional<int64_t>>{
+               std::nullopt, std::nullopt, std::nullopt})});
 }
 
 TEST_F(NullableVariadicViewTest, notNullContainer) {
@@ -351,8 +352,9 @@ TEST_F(NullFreeVariadicViewTest, variadicIntMoreArgs) {
       {makeNullableFlatVector(std::vector<std::optional<int64_t>>{-1, -2, -3}),
        makeNullableFlatVector(
            std::vector<std::optional<int64_t>>{-4, std::nullopt, -6}),
-       makeNullableFlatVector(std::vector<std::optional<int64_t>>{
-           std::nullopt, std::nullopt, std::nullopt})});
+       makeNullableFlatVector(
+           std::vector<std::optional<int64_t>>{
+               std::nullopt, std::nullopt, std::nullopt})});
 }
 
 TEST_F(NullFreeVariadicViewTest, iteratorDifference) {
diff --git a/velox/expression/type_calculation/CMakeLists.txt b/velox/expression/type_calculation/CMakeLists.txt
index 0c0a3b114b1c..b44851fbaa42 100644
--- a/velox/expression/type_calculation/CMakeLists.txt
+++ b/velox/expression/type_calculation/CMakeLists.txt
@@ -13,22 +13,27 @@
 # limitations under the License.
 
 bison_target(
-  TypeCalculationParser TypeCalculation.yy
+  TypeCalculationParser
+  TypeCalculation.yy
   ${CMAKE_CURRENT_BINARY_DIR}/TypeCalculation.yy.cc
   DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/TypeCalculation.yy.h
-  COMPILE_FLAGS "-Werror -Wno-deprecated")
+  COMPILE_FLAGS "-Werror -Wno-deprecated"
+)
 
 flex_target(
-  TypeCalculationScanner TypeCalculation.ll
-  ${CMAKE_CURRENT_BINARY_DIR}/Scanner.cpp COMPILE_FLAGS "-Cf --prefix=veloxtc")
+  TypeCalculationScanner
+  TypeCalculation.ll
+  ${CMAKE_CURRENT_BINARY_DIR}/Scanner.cpp
+  COMPILE_FLAGS "-Cf --prefix=veloxtc"
+)
 
 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})
+    DEPENDS ${BISON_TypeCalculationParser_OUTPUTS} ${FLEX_TypeCalculationScanner_OUTPUTS}
+  )
   add_dependencies(velox velox_type_calculation_gen_src)
 endif()
 
@@ -39,5 +44,6 @@ velox_add_library(
   ${BISON_TypeCalculationParser_OUTPUTS}
   ${FLEX_TypeCalculationScanner_OUTPUTS}
   Scanner.h
-  TypeCalculation.h)
+  TypeCalculation.h
+)
 velox_link_libraries(velox_type_calculation velox_common_base)
diff --git a/velox/external/date/date.h b/velox/external/date/date.h
index b0ae226e29a0..75f324448413 100644
--- a/velox/external/date/date.h
+++ b/velox/external/date/date.h
@@ -973,8 +973,8 @@ operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday_last&
 inline namespace literals
 {
 
-CONSTCD11 date::day  operator "" _d(unsigned long long d) NOEXCEPT;
-CONSTCD11 date::year operator "" _y(unsigned long long y) NOEXCEPT;
+CONSTCD11 date::day  operator ""_d(unsigned long long d) NOEXCEPT;
+CONSTCD11 date::year operator ""_y(unsigned long long y) NOEXCEPT;
 
 }  // inline namespace literals
 #endif // !defined(_MSC_VER) || (_MSC_VER >= 1900)
@@ -1883,7 +1883,7 @@ inline namespace literals
 CONSTCD11
 inline
 date::day
-operator "" _d(unsigned long long d) NOEXCEPT
+operator ""_d(unsigned long long d) NOEXCEPT
 {
     return date::day{static_cast<unsigned>(d)};
 }
@@ -1891,7 +1891,7 @@ operator "" _d(unsigned long long d) NOEXCEPT
 CONSTCD11
 inline
 date::year
-operator "" _y(unsigned long long y) NOEXCEPT
+operator ""_y(unsigned long long y) NOEXCEPT
 {
     return date::year(static_cast<int>(y));
 }
diff --git a/velox/external/date/iso_week.h b/velox/external/date/iso_week.h
index e5572b8e4192..f1c266616a44 100644
--- a/velox/external/date/iso_week.h
+++ b/velox/external/date/iso_week.h
@@ -343,7 +343,7 @@ inline namespace literals
 CONSTCD11
 inline
 date::year
-operator "" _y(unsigned long long y) NOEXCEPT
+operator ""_y(unsigned long long y) NOEXCEPT
 {
     return date::year(static_cast<int64_t>(y));
 }
@@ -351,7 +351,7 @@ operator "" _y(unsigned long long y) NOEXCEPT
 CONSTCD11
 inline
 iso_week::weeknum
-operator "" _w(unsigned long long wn) NOEXCEPT
+operator ""_w(unsigned long long wn) NOEXCEPT
 {
     return iso_week::weeknum(static_cast<unsigned>(wn));
 }
diff --git a/velox/external/hdfs/ArrowHdfsInternal.cpp b/velox/external/hdfs/ArrowHdfsInternal.cpp
index c9a0c7dd81f0..dc22b64ce306 100644
--- a/velox/external/hdfs/ArrowHdfsInternal.cpp
+++ b/velox/external/hdfs/ArrowHdfsInternal.cpp
@@ -62,7 +62,6 @@ namespace {
 
 void* GetLibrarySymbol(LibraryHandle handle, const char* symbol) {
   if (handle == NULL) {
-    printf("handle is null\n");
     return NULL;
   }
 
@@ -72,7 +71,6 @@ void* GetLibrarySymbol(LibraryHandle handle, const char* symbol) {
 
   void* ret = reinterpret_cast<void*>(GetProcAddress(, symbol));
   if (ret == NULL) {
-    printf("ret  is null\n");
     // logstream(LOG_INFO) << "GetProcAddress error: "
     //                     << get_last_err_str(GetLastError()) << std::endl;
   }
diff --git a/velox/external/tzdb/tzdb.cpp b/velox/external/tzdb/tzdb.cpp
index 8f85d2e33274..c4e16b139b93 100644
--- a/velox/external/tzdb/tzdb.cpp
+++ b/velox/external/tzdb/tzdb.cpp
@@ -708,6 +708,10 @@ static void __parse_zone(
   } while (std::isdigit(__input.peek()) || __input.peek() == '-');
 
   std::filesystem::path __root = __libcpp_tzdb_directory();
+  if (!std::filesystem::exists(__root/ __p->__name())) {
+    // in case the zonefile does not exists
+    return;
+  }
   std::ifstream zone_file{__root / __p->__name()};
   date::populate_transitions(__p->transitions(), __p->ttinfos(), zone_file);
 
@@ -724,7 +728,8 @@ static void __parse_link(tzdb& __tzdb, std::istream& __input) {
   __tzdb.links.emplace_back(std::move(__name), std::move(__target));
 }
 
-static void __parse_tzdata(
+template <int recordType>
+static void __parse_tzdata_record_type(
     tzdb& __db,
     __rules_storage_type& __rules,
     std::istream& __input) {
@@ -745,26 +750,57 @@ static void __parse_tzdata(
         break;
 
       case 'r':
-        __skip(__input, "ule");
-        __parse_rule(__db, __rules, __input);
+        if constexpr (recordType == 'r') {
+          __skip(__input, "ule");
+          __parse_rule(__db, __rules, __input);
+        } else {
+          __skip_line(__input);
+        }
         break;
 
-      case 'z':
-        __skip(__input, "one");
-        __parse_zone(__db, __rules, __input);
+      case 'l':
+        if constexpr (recordType == 'l') {
+          __skip(__input, "ink");
+          __parse_link(__db, __input);
+        } else {
+          __skip_line(__input);
+        }
         break;
 
-      case 'l':
-        __skip(__input, "ink");
-        __parse_link(__db, __input);
+      case 'z':
+        if constexpr (recordType == 'z') {
+          __skip(__input, "one");
+          __parse_zone(__db, __rules, __input);
+        } else {
+          __skip_line(__input);
+        }
         break;
 
       default:
-        std::__throw_runtime_error("corrupt tzdb: unexpected input");
+        if constexpr (recordType == 'z') {
+          // Only z (Zones) have continuation lines.
+          // When parsing z, any token not matched by the earlier cases is invalid.
+          // (continuations are consumed inside __parse_zone)
+          std::__throw_runtime_error("corrupt tzdb: unexpected input");
+        } else {
+          __skip_line(__input);
+        }
     }
   }
 }
 
+static void __parse_tzdata(
+    tzdb& __db,
+    __rules_storage_type& __rules,
+    std::istream& __input) {
+  // Parse tzdata.zi in order: Rules → Zones → Links.
+  // Zones may reference Rules; Links alias Zones.
+  const std::string buf{std::istreambuf_iterator<char>(__input), {}};
+  { std::istringstream iss(buf); __parse_tzdata_record_type<'r'>(__db, __rules, iss); }
+  { std::istringstream iss(buf); __parse_tzdata_record_type<'z'>(__db, __rules, iss); }
+  { std::istringstream iss(buf); __parse_tzdata_record_type<'l'>(__db, __rules, iss); }
+}
+
 static void __parse_leap_seconds(
     std::vector<leap_second>& __leap_seconds,
     std::istream&& __input) {
diff --git a/velox/external/tzdb/tzdb_list_private.h b/velox/external/tzdb/tzdb_list_private.h
index 9fa8dbab56b8..e60888d1baa3 100644
--- a/velox/external/tzdb/tzdb_list_private.h
+++ b/velox/external/tzdb/tzdb_list_private.h
@@ -43,7 +43,7 @@ class tzdb_list::__impl {
 
   [[nodiscard]] const tzdb& __load() {
 #if _LIBCPP_HAS_THREADS
-    unique_lock __lock{__mutex_};
+    std::unique_lock __lock{__mutex_};
 #endif
     __load_no_lock();
     return __tzdb_.front();
@@ -53,14 +53,14 @@ class tzdb_list::__impl {
 
   const tzdb& __front() const noexcept {
 #if _LIBCPP_HAS_THREADS
-    unique_lock __lock{__mutex_};
+    std::unique_lock __lock{__mutex_};
 #endif
     return __tzdb_.front();
   }
 
   const_iterator __erase_after(const_iterator __p) {
 #if _LIBCPP_HAS_THREADS
-    unique_lock __lock{__mutex_};
+    std::unique_lock __lock{__mutex_};
 #endif
 
     __rules_.erase_after(
@@ -70,7 +70,7 @@ class tzdb_list::__impl {
 
   const_iterator __begin() const noexcept {
 #if _LIBCPP_HAS_THREADS
-    unique_lock __lock{__mutex_};
+    std::unique_lock __lock{__mutex_};
 #endif
     return __tzdb_.begin();
   }
@@ -88,7 +88,7 @@ class tzdb_list::__impl {
   }
 
 #if _LIBCPP_HAS_THREADS
-  mutable mutex __mutex_;
+  mutable std::mutex __mutex_;
 #endif
   std::forward_list<tzdb> __tzdb_;
 
diff --git a/velox/flag_definitions/flags.cpp b/velox/flag_definitions/flags.cpp
index 1c12d3651592..8648e80a68e1 100644
--- a/velox/flag_definitions/flags.cpp
+++ b/velox/flag_definitions/flags.cpp
@@ -100,11 +100,6 @@ DEFINE_bool(
     false,
     "If true, check fails on any memory leaks in memory pool and memory manager");
 
-DEFINE_bool(
-    velox_memory_pool_debug_enabled,
-    false,
-    "If true, 'MemoryPool' will be running in debug mode to track the allocation and free call sites to detect the source of memory leak for testing purpose");
-
 // TODO: deprecate this after solves all the use cases that can cause
 // significant performance regression by memory usage tracking.
 DEFINE_bool(
diff --git a/velox/functions/CMakeLists.txt b/velox/functions/CMakeLists.txt
index 77e5f83428d5..3401db234e0a 100644
--- a/velox/functions/CMakeLists.txt
+++ b/velox/functions/CMakeLists.txt
@@ -14,12 +14,7 @@
 velox_add_library(velox_function_registry FunctionRegistry.cpp)
 velox_add_library(velox_coverage_util CoverageUtil.cpp)
 
-velox_link_libraries(
-  velox_function_registry
-  velox_expression
-  velox_type
-  velox_core
-  velox_exception)
+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})
@@ -37,3 +32,7 @@ endif()
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
 endif()
+
+if(${VELOX_ENABLE_ICEBERG_FUNCTIONS})
+  add_subdirectory(iceberg)
+endif()
diff --git a/velox/functions/CoverageUtil.cpp b/velox/functions/CoverageUtil.cpp
index a767ce3938b7..25b842e0d10b 100644
--- a/velox/functions/CoverageUtil.cpp
+++ b/velox/functions/CoverageUtil.cpp
@@ -21,6 +21,7 @@
 #include <iostream>
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/WindowFunction.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/functions/FunctionRegistry.h"
 
 namespace facebook::velox::functions {
@@ -297,7 +298,9 @@ bool isCompanionFunctionName(
 /// excluding companion functions.
 std::vector<std::string> getSortedScalarNames() {
   // Do not print "internal" functions.
-  static const std::unordered_set<std::string> kBlockList = {"row_constructor"};
+  static const folly::F14FastSet<std::string_view> kBlockList{
+      expression::kRowConstructor,
+  };
 
   auto functions = getFunctionSignatures();
 
diff --git a/velox/functions/FunctionRegistry.cpp b/velox/functions/FunctionRegistry.cpp
index 2ce84364a34a..d7086223caae 100644
--- a/velox/functions/FunctionRegistry.cpp
+++ b/velox/functions/FunctionRegistry.cpp
@@ -32,13 +32,6 @@
 namespace facebook::velox {
 namespace {
 
-void populateSimpleFunctionSignatures(FunctionSignatureMap& map) {
-  const auto& simpleFunctions = exec::simpleFunctions();
-  for (const auto& functionName : simpleFunctions.getFunctionNames()) {
-    map[functionName] = simpleFunctions.getFunctionSignatures(functionName);
-  }
-}
-
 void populateVectorFunctionSignatures(FunctionSignatureMap& map) {
   auto vectorFunctions = exec::vectorFunctionFactories();
   vectorFunctions.withRLock([&map](const auto& locked) {
@@ -58,8 +51,8 @@ void populateVectorFunctionSignatures(FunctionSignatureMap& map) {
 } // namespace
 
 FunctionSignatureMap getFunctionSignatures() {
-  FunctionSignatureMap result;
-  populateSimpleFunctionSignatures(result);
+  const auto& simpleFunctions = exec::simpleFunctions();
+  FunctionSignatureMap result = simpleFunctions.getFunctionSignatureMap();
   populateVectorFunctionSignatures(result);
   return result;
 }
@@ -128,6 +121,22 @@ TypePtr resolveFunction(
   return resolveVectorFunction(functionName, argTypes);
 }
 
+TypePtr resolveFunctionWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  // Check if this is a simple function.
+  if (auto resolvedFunction =
+          exec::simpleFunctions().resolveFunctionWithCoercions(
+              functionName, argTypes, coercions)) {
+    return resolvedFunction->type();
+  }
+
+  // Check if VectorFunctions has this function name + signature.
+  return exec::resolveVectorFunctionWithCoercions(
+      functionName, argTypes, coercions);
+}
+
 std::optional<std::pair<TypePtr, exec::VectorFunctionMetadata>>
 resolveFunctionWithMetadata(
     const std::string& functionName,
@@ -151,12 +160,32 @@ TypePtr resolveFunctionOrCallableSpecialForm(
   return resolveFunction(functionName, argTypes);
 }
 
+TypePtr resolveFunctionOrCallableSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  if (auto returnType = resolveCallableSpecialFormWithCoercions(
+          functionName, argTypes, coercions)) {
+    return returnType;
+  }
+
+  return resolveFunctionWithCoercions(functionName, argTypes, coercions);
+}
+
 TypePtr resolveCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
   return exec::resolveTypeForSpecialForm(functionName, argTypes);
 }
 
+TypePtr resolveCallableSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions) {
+  return exec::resolveTypeForSpecialFormWithCoercions(
+      functionName, argTypes, coercions);
+}
+
 TypePtr resolveSimpleFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes) {
diff --git a/velox/functions/FunctionRegistry.h b/velox/functions/FunctionRegistry.h
index 706fe5d4f4c4..3285768a9b83 100644
--- a/velox/functions/FunctionRegistry.h
+++ b/velox/functions/FunctionRegistry.h
@@ -52,6 +52,26 @@ TypePtr resolveFunction(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+/// Like 'resolveFunction', but with support for applying type conversions if no
+/// signature matches 'argTypes' exactly.
+///
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve the function successfully. Contains one entry per argument. The
+/// entry is null if no coercion is required for that argument. The entry is not
+/// null if coercions is necessary.
+///
+/// Example, given functin plus(bigint, bigint) -> bigint and arguments
+/// (integer, bigint), returns bigint with coercions = {bigint, null}. The first
+/// argument needs to be coersed to bigint, while the second argument doesn't
+/// require coercion.
+///
+/// TODO: Add support for coercion for complex and user-defined types,
+/// signatures with generic types and variadic arguments.
+TypePtr resolveFunctionWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions);
+
 /// 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>>
@@ -66,6 +86,19 @@ TypePtr resolveFunctionOrCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+/// Like 'resolveFunctionOrCallableSpecialForm', but with support for applying
+/// type conversions if a function or a special form signature doesn't match
+/// 'argTypes' exactly.
+///
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve a function or a special form successfully. Contains one entry per
+/// argument. The entry is null if no coercion is required for that argument.
+/// The entry is not null if coercion is necessary.
+TypePtr resolveFunctionOrCallableSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions);
+
 /// Given the name of a special form and argument types, returns
 /// the return type if the special form exists and is supported, otherwise
 /// returns nullptr.
@@ -78,6 +111,19 @@ TypePtr resolveCallableSpecialForm(
     const std::string& functionName,
     const std::vector<TypePtr>& argTypes);
 
+/// Like 'resolveCallableSpecialForm', but with support for applying
+/// type conversions if a special form signature doesn't match 'argTypes'
+/// exactly.
+///
+/// @param coercions A list of optional type coercions that were applied to
+/// resolve a special form successfully. Contains one entry per argument. The
+/// entry is null if no coercion is required for that argument. The entry is not
+/// null if coercion is necessary.
+TypePtr resolveCallableSpecialFormWithCoercions(
+    const std::string& functionName,
+    const std::vector<TypePtr>& argTypes,
+    std::vector<TypePtr>& coercions);
+
 /// Given name of simple function and argument types, returns
 /// the return type if function exists otherwise returns nullptr
 TypePtr resolveSimpleFunction(
diff --git a/velox/functions/UDFOutputString.h b/velox/functions/UDFOutputString.h
index 6271a6b5d191..c14340f3d8a6 100644
--- a/velox/functions/UDFOutputString.h
+++ b/velox/functions/UDFOutputString.h
@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <algorithm>
 #include <cstring>
 #include <string_view>
 
diff --git a/velox/functions/iceberg/BucketFunction.cpp b/velox/functions/iceberg/BucketFunction.cpp
new file mode 100644
index 000000000000..39f2f14b433d
--- /dev/null
+++ b/velox/functions/iceberg/BucketFunction.cpp
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/iceberg/BucketFunction.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/iceberg/Murmur3Hash32.h"
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+
+FOLLY_ALWAYS_INLINE int32_t
+getBucketIndex(int32_t numBuckets, int32_t hashedValue) {
+  return (hashedValue & std::numeric_limits<int32_t>::max()) % numBuckets;
+}
+
+// bucket(numBuckets, decimal) -> bucketIndex
+// Hash the minimal bytes of the decimal unscaled value, then MOD numBuckets to
+// get the bucket index.
+template <typename TExec>
+struct BucketDecimalFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(int32_t& out, int32_t numBuckets, T input) {
+    VELOX_USER_RETURN_LE(numBuckets, 0, "Invalid number of buckets.");
+    char bytes[sizeof(int128_t)];
+    const auto length = DecimalUtil::toByteArray(input, bytes);
+    const auto hash = Murmur3Hash32::hashBytes(bytes, length);
+    out = getBucketIndex(numBuckets, hash);
+    return Status::OK();
+  }
+};
+
+// bucket(numBuckets, input) -> bucketIndex
+// Bucket all other Iceberg supported types including the integral type,
+// varchar, varbinary, date and timestamp type.
+template <typename TExec>
+struct BucketFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // Value of type INTEGER and BIGINT is treated as unsigned type.
+  // For the schema evolution, may promote int to int64, treat int32 as uint64.
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(int32_t& out, int32_t numBuckets, T input) {
+    VELOX_USER_RETURN_LE(numBuckets, 0, "Invalid number of buckets.");
+    const auto hash = Murmur3Hash32::hashInt64(input);
+    out = getBucketIndex(numBuckets, hash);
+    return Status::OK();
+  }
+
+  FOLLY_ALWAYS_INLINE Status
+  call(int32_t& out, int32_t numBuckets, const arg_type<Varchar>& input) {
+    VELOX_USER_RETURN_LE(numBuckets, 0, "Invalid number of buckets.");
+    const auto hash = Murmur3Hash32::hashBytes(input.data(), input.size());
+    out = getBucketIndex(numBuckets, hash);
+    return Status::OK();
+  }
+
+  FOLLY_ALWAYS_INLINE Status
+  call(int32_t& out, int32_t numBuckets, const arg_type<Timestamp>& input) {
+    VELOX_USER_RETURN_LE(numBuckets, 0, "Invalid number of buckets.");
+    const auto hash = Murmur3Hash32::hashInt64(input.toMicros());
+    out = getBucketIndex(numBuckets, hash);
+    return Status::OK();
+  }
+};
+
+} // namespace
+
+void registerBucketFunctions(const std::string& prefix) {
+  registerFunction<BucketFunction, int32_t, int32_t, int32_t>(
+      {prefix + "bucket"});
+  registerFunction<BucketFunction, int32_t, int32_t, int64_t>(
+      {prefix + "bucket"});
+  registerFunction<BucketFunction, int32_t, int32_t, Varchar>(
+      {prefix + "bucket"});
+  registerFunction<BucketFunction, int32_t, int32_t, Varbinary>(
+      {prefix + "bucket"});
+  registerFunction<BucketFunction, int32_t, int32_t, Date>({prefix + "bucket"});
+  registerFunction<BucketFunction, int32_t, int32_t, Timestamp>(
+      {prefix + "bucket"});
+
+  registerFunction<
+      BucketDecimalFunction,
+      int32_t,
+      int32_t,
+      LongDecimal<P1, S1>>({prefix + "bucket"});
+
+  registerFunction<
+      BucketDecimalFunction,
+      int32_t,
+      int32_t,
+      ShortDecimal<P1, S1>>({prefix + "bucket"});
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/substrait/TypeUtils.h b/velox/functions/iceberg/BucketFunction.h
similarity index 73%
rename from velox/substrait/TypeUtils.h
rename to velox/functions/iceberg/BucketFunction.h
index 599af3dd53b5..2744e4e4a80f 100644
--- a/velox/substrait/TypeUtils.h
+++ b/velox/functions/iceberg/BucketFunction.h
@@ -13,12 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#pragma once
 
-#include "velox/type/Type.h"
+#include <string>
 
-namespace facebook::velox::substrait {
+namespace facebook::velox::functions::iceberg {
 
-std::string_view getNameBeforeDelimiter(
-    const std::string& compoundName,
-    const std::string& delimiter);
-} // namespace facebook::velox::substrait
+void registerBucketFunctions(const std::string& prefix);
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/CMakeLists.txt b/velox/functions/iceberg/CMakeLists.txt
new file mode 100644
index 000000000000..2dcccd4041e6
--- /dev/null
+++ b/velox/functions/iceberg/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.
+
+velox_add_library(velox_functions_iceberg_hash Murmur3Hash32.cpp)
+
+velox_link_libraries(velox_functions_iceberg_hash velox_common_base velox_functions_util)
+
+velox_add_library(
+  velox_functions_iceberg
+  BucketFunction.cpp
+  DateTimeFunctions.cpp
+  Register.cpp
+  Truncate.cpp
+)
+
+velox_link_libraries(
+  velox_functions_iceberg
+  velox_functions_iceberg_hash
+  velox_functions_lib
+  Folly::folly
+)
+
+if(NOT VELOX_MONO_LIBRARY)
+  set_property(TARGET velox_functions_iceberg PROPERTY JOB_POOL_COMPILE high_memory_pool)
+endif()
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/functions/iceberg/DateTimeFunctions.cpp b/velox/functions/iceberg/DateTimeFunctions.cpp
new file mode 100644
index 000000000000..4e0f6e480f1a
--- /dev/null
+++ b/velox/functions/iceberg/DateTimeFunctions.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/functions/iceberg/DateTimeFunctions.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/iceberg/DateTimeUtil.h"
+
+namespace facebook::velox::functions::iceberg {
+
+// years(input) -> years from 1970
+// Input is date or timestamp.
+template <typename TExec>
+struct YearsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = epochYear(timestamp);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = epochYear(date);
+  }
+};
+
+// months(input) -> months from 1970-01-01
+// Input is date or timestamp.
+template <typename TExec>
+struct MonthsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = epochMonth(timestamp);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int32_t& result, const arg_type<Date>& date) {
+    result = epochMonth(date);
+  }
+};
+
+// days(input) -> days from 1970-01-01
+// Input is date or timestamp.
+template <typename TExec>
+struct DaysFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Date>& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = epochDay(timestamp);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Date>& result,
+      const arg_type<Date>& date) {
+    result = date;
+  }
+};
+
+// hours(input) -> hours from 1970-01-01 00:00:00
+// Input is timestamp.
+template <typename TExec>
+struct HoursFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int32_t& result,
+      const arg_type<Timestamp>& timestamp) {
+    result = epochHour(timestamp);
+  }
+};
+
+void registerDateTimeFunctions(const std::string& prefix) {
+  registerFunction<YearsFunction, int32_t, Timestamp>({prefix + "years"});
+  registerFunction<YearsFunction, int32_t, Date>({prefix + "years"});
+  registerFunction<MonthsFunction, int32_t, Timestamp>({prefix + "months"});
+  registerFunction<MonthsFunction, int32_t, Date>({prefix + "months"});
+  registerFunction<DaysFunction, Date, Timestamp>({prefix + "days"});
+  registerFunction<DaysFunction, Date, Date>({prefix + "days"});
+  registerFunction<HoursFunction, int32_t, Timestamp>({prefix + "hours"});
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/substrait/tests/JsonToProtoConverter.h b/velox/functions/iceberg/DateTimeFunctions.h
similarity index 72%
rename from velox/substrait/tests/JsonToProtoConverter.h
rename to velox/functions/iceberg/DateTimeFunctions.h
index ebaf613b6abf..496aae48bb8c 100644
--- a/velox/substrait/tests/JsonToProtoConverter.h
+++ b/velox/functions/iceberg/DateTimeFunctions.h
@@ -16,12 +16,10 @@
 
 #pragma once
 
-#include <google/protobuf/util/json_util.h>
+#include <string>
 
-class JsonToProtoConverter {
- public:
-  /// Reconstruct Protobuf message from Json file.
-  static void readFromFile(
-      const std::string& msgPath,
-      google::protobuf::Message& msg);
-};
+namespace facebook::velox::functions::iceberg {
+
+void registerDateTimeFunctions(const std::string& prefix);
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/DateTimeUtil.h b/velox/functions/iceberg/DateTimeUtil.h
new file mode 100644
index 000000000000..375159889160
--- /dev/null
+++ b/velox/functions/iceberg/DateTimeUtil.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/lib/TimeUtils.h"
+
+namespace facebook::velox::functions::iceberg {
+
+/// Extract a date year, as years from 1970.
+FOLLY_ALWAYS_INLINE int32_t epochYear(int32_t daysSinceEpoch) {
+  return functions::getYear(functions::getDateTime(daysSinceEpoch)) - 1970;
+}
+
+/// Extract a timestamp year, as years from 1970.
+FOLLY_ALWAYS_INLINE int32_t epochYear(Timestamp ts) {
+  return functions::getYear(functions::getDateTime(ts, nullptr)) - 1970;
+}
+
+/// Extract a date month, as months from 1970-01-01.
+FOLLY_ALWAYS_INLINE int32_t epochMonth(int32_t daysSinceEpoch) {
+  const std::tm tm = functions::getDateTime(daysSinceEpoch);
+  return (functions::getYear(tm) - 1970) * 12 + tm.tm_mon;
+}
+
+/// Extract a timestamp month, as months from 1970-01-01.
+FOLLY_ALWAYS_INLINE int32_t epochMonth(Timestamp ts) {
+  const std::tm tm = functions::getDateTime(ts, nullptr);
+  return (functions::getYear(tm) - 1970) * 12 + tm.tm_mon;
+}
+
+/// Extract a timestamp day, as days from 1970-01-01.
+FOLLY_ALWAYS_INLINE int32_t epochDay(Timestamp ts) {
+  const auto seconds = ts.getSeconds();
+  return (seconds >= 0) ? seconds / Timestamp::kSecondsInDay
+                        : ((seconds + 1) / Timestamp::kSecondsInDay) - 1;
+}
+
+/// Extract a timestamp hour, as hours from 1970-01-01 00:00:00.
+FOLLY_ALWAYS_INLINE int32_t epochHour(Timestamp ts) {
+  const auto seconds = ts.getSeconds();
+  return (seconds >= 0) ? seconds / 3'600 : ((seconds + 1) / 3'600) - 1;
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/Murmur3Hash32.cpp b/velox/functions/iceberg/Murmur3Hash32.cpp
new file mode 100644
index 000000000000..0270b3ef2d95
--- /dev/null
+++ b/velox/functions/iceberg/Murmur3Hash32.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/iceberg/Murmur3Hash32.h"
+#include "velox/common/base/BitUtil.h"
+
+namespace facebook::velox::functions::iceberg {
+
+namespace {
+
+constexpr int32_t kSeed = 0;
+} // namespace
+
+int32_t Murmur3Hash32::hashInt64(uint64_t input) {
+  return Murmur3Hash32Base::hashInt64(input, kSeed);
+}
+
+int32_t Murmur3Hash32::hashBytes(const char* input, uint32_t len) {
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(input);
+  const int32_t nblocks = len / 4;
+
+  uint32_t h1 = kSeed;
+
+  // Process 4-byte chunks.
+  for (auto i = 0; i < nblocks; i++) {
+    uint32_t k1 = *reinterpret_cast<const uint32_t*>(data + i * 4);
+    k1 = mixK1(k1);
+    h1 = mixH1(h1, k1);
+  }
+
+  // Process remaining bytes.
+  const uint8_t* tail = data + nblocks * 4;
+  uint32_t k1 = 0;
+  switch (len & 3) {
+    case 3:
+      k1 ^= static_cast<uint32_t>(tail[2]) << 16;
+      [[fallthrough]];
+    case 2:
+      k1 ^= static_cast<uint32_t>(tail[1]) << 8;
+      [[fallthrough]];
+    case 1:
+      k1 ^= static_cast<uint32_t>(tail[0]);
+      h1 ^= mixK1(k1);
+  }
+
+  return fmix(h1, len);
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/Murmur3Hash32.h b/velox/functions/iceberg/Murmur3Hash32.h
new file mode 100644
index 000000000000..81712f2b88d8
--- /dev/null
+++ b/velox/functions/iceberg/Murmur3Hash32.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 <cstdint>
+#include "velox/functions/lib/Murmur3Hash32Base.h"
+
+namespace facebook::velox::functions::iceberg {
+
+/// This implementation should align with Iceberg bucket transform hash
+/// algorithm which uses Guava hash
+/// https://github.com/google/guava/blob/master/guava/src/com/google/common/hash/Murmur3_32HashFunction.java,
+/// Bucket partition transforms use a 32-bit hash of the source value. The
+/// 32-bit hash implementation is the 32-bit Murmur3 hash, x86 variant, seeded
+/// with 0. If not same with Iceberg java version, the partition will be
+/// different and can not read with Iceberg java.
+class Murmur3Hash32 : Murmur3Hash32Base {
+ public:
+  /// Value of type INTEGER and BIGINT is treated as unsigned type.
+  /// For the schema evolution, promote int to int64, treat int32 as uint64.
+  static int32_t hashInt64(uint64_t input);
+
+  /// Hash the bytes every 4 bytes, XOR on remaining bytes. Processing for the
+  /// remaining bytes is different with Spark murmur3 which combine with the
+  /// remaining bytes.
+  static int32_t hashBytes(const char* input, uint32_t len);
+};
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/Register.cpp b/velox/functions/iceberg/Register.cpp
new file mode 100644
index 000000000000..ab8afc4ed7bb
--- /dev/null
+++ b/velox/functions/iceberg/Register.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/functions/iceberg/Register.h"
+#include "velox/functions/iceberg/BucketFunction.h"
+#include "velox/functions/iceberg/DateTimeFunctions.h"
+#include "velox/functions/iceberg/Truncate.h"
+
+namespace facebook::velox::functions::iceberg {
+
+void registerFunctions(const std::string& prefix) {
+  registerBucketFunctions(prefix);
+  registerTruncateFunctions(prefix);
+  registerDateTimeFunctions(prefix);
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/connectors/hive/HivePartitionUtil.h b/velox/functions/iceberg/Register.h
similarity index 69%
rename from velox/connectors/hive/HivePartitionUtil.h
rename to velox/functions/iceberg/Register.h
index a1047869b800..117d405535e3 100644
--- a/velox/connectors/hive/HivePartitionUtil.h
+++ b/velox/functions/iceberg/Register.h
@@ -15,12 +15,10 @@
  */
 #pragma once
 
-#include "velox/vector/ComplexVector.h"
+#include <string>
 
-namespace facebook::velox::connector::hive {
+namespace facebook::velox::functions::iceberg {
 
-std::vector<std::pair<std::string, std::string>> extractPartitionKeyValues(
-    const RowVectorPtr& partitionsVector,
-    vector_size_t row);
+void registerFunctions(const std::string& prefix = "");
 
-} // namespace facebook::velox::connector::hive
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/Truncate.cpp b/velox/functions/iceberg/Truncate.cpp
new file mode 100644
index 000000000000..82e166d1b9b0
--- /dev/null
+++ b/velox/functions/iceberg/Truncate.cpp
@@ -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.
+ */
+
+#include "velox/functions/iceberg/Truncate.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+#include "velox/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+// truncate(width, input) -> truncatedValue
+// For numeric values, truncate to the nearest lower multiple of width works
+// consistently for both positive and negative values of input, even in
+// languages where the % operator can return a negative remainder. The width is
+// used to truncate decimal values is applied using unscaled value to avoid
+// additional (and potentially conflicting) parameters. For string values, it
+// truncates a valid UTF-8 string with no more than width code points. In
+// contrast to strings, binary values do not have an assumed encoding and are
+// truncated to width bytes.
+template <typename TExec>
+struct TruncateFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // ASCII input always produces ASCII result.
+  static constexpr bool is_default_ascii_behavior = true;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      const int32_t* /*width*/,
+      const arg_type<Varchar>* /*input*/) {
+    inputIsVarbinary_ = inputTypes[1]->isVarbinary();
+  }
+
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(T& out, int32_t width, T input) {
+    VELOX_USER_RETURN_LE(width, 0, "Invalid truncate width");
+    // Truncate to the nearest lower multiple of width.
+    out = input - ((input % width) + width) % width;
+    return Status::OK();
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Varchar>& result,
+      int32_t width,
+      const arg_type<Varchar>& input) {
+    VELOX_USER_RETURN_LE(width, 0, "Invalid truncate width");
+    const auto truncatedwidth = inputIsVarbinary_
+        ? stringImpl::cappedByteLength<true>(input, width)
+        : stringImpl::cappedByteLength<false>(input, width);
+    result = StringView(input.data(), truncatedwidth);
+    return Status::OK();
+  }
+
+  FOLLY_ALWAYS_INLINE Status callAscii(
+      out_type<Varchar>& result,
+      int32_t width,
+      const arg_type<Varchar>& input) {
+    VELOX_USER_RETURN_LE(width, 0, "Invalid truncate width");
+    auto truncatedwidth = stringImpl::cappedLength<true>(input, width);
+    result = StringView(input.data(), truncatedwidth);
+    return Status::OK();
+  }
+
+ private:
+  bool inputIsVarbinary_ = false;
+};
+} // namespace
+
+void registerTruncateFunctions(const std::string& prefix) {
+  registerFunction<TruncateFunction, int8_t, int32_t, int8_t>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, int16_t, int32_t, int16_t>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, int32_t, int32_t, int32_t>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, int64_t, int32_t, int64_t>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, Varchar, int32_t, Varchar>(
+      {prefix + "truncate"});
+  registerFunction<TruncateFunction, Varbinary, int32_t, Varbinary>(
+      {prefix + "truncate"});
+  registerFunction<
+      TruncateFunction,
+      LongDecimal<P1, S1>,
+      int32_t,
+      LongDecimal<P1, S1>>({prefix + "truncate"});
+
+  registerFunction<
+      TruncateFunction,
+      ShortDecimal<P1, S1>,
+      int32_t,
+      ShortDecimal<P1, S1>>({prefix + "truncate"});
+}
+
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/type/TypeParser.h b/velox/functions/iceberg/Truncate.h
similarity index 69%
rename from velox/type/TypeParser.h
rename to velox/functions/iceberg/Truncate.h
index 0ffc0e7ef328..e31376d43623 100644
--- a/velox/type/TypeParser.h
+++ b/velox/functions/iceberg/Truncate.h
@@ -16,16 +16,10 @@
 
 #pragma once
 
-#include "velox/type/Type.h"
+#include <string>
 
-namespace facebook::velox::type {
+namespace facebook::velox::functions::iceberg {
 
-class TypeParser {
- public:
-  TypeParser() = default;
-  virtual ~TypeParser() = default;
+void registerTruncateFunctions(const std::string& prefix);
 
-  virtual std::shared_ptr<const velox::Type> parse(const std::string& ser) = 0;
-};
-
-} // namespace facebook::velox::type
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/tests/BucketFunctionTest.cpp b/velox/functions/iceberg/tests/BucketFunctionTest.cpp
new file mode 100644
index 000000000000..f12242d17dbd
--- /dev/null
+++ b/velox/functions/iceberg/tests/BucketFunctionTest.cpp
@@ -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.
+ */
+#include "velox/functions/iceberg/BucketFunction.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/iceberg/tests/IcebergFunctionBaseTest.h"
+
+#include <gtest/gtest.h>
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+
+class BucketFunctionTest
+    : public functions::iceberg::test::IcebergFunctionBaseTest {
+ protected:
+  template <typename T>
+  std::optional<int32_t> bucket(
+      std::optional<int32_t> numBuckets,
+      std::optional<T> value) {
+    return evaluateOnce<int32_t>("bucket(c0, c1)", numBuckets, value);
+  }
+
+  template <typename T>
+  std::optional<int32_t> bucket(
+      const TypePtr& type,
+      std::optional<int32_t> numBuckets,
+      std::optional<T> value) {
+    return evaluateOnce<int32_t>(
+        "bucket(c0, c1)", {INTEGER(), type}, numBuckets, value);
+  }
+};
+
+TEST_F(BucketFunctionTest, integerTypes) {
+  EXPECT_EQ(bucket<int32_t>(10, 8), 3);
+  EXPECT_EQ(bucket<int32_t>(10, 42), 6);
+  EXPECT_EQ(bucket<int32_t>(100, 34), 79);
+  EXPECT_EQ(bucket<int32_t>(1000, INT_MAX), 606);
+  EXPECT_EQ(bucket<int32_t>(1000, INT_MIN), 856);
+  EXPECT_EQ(bucket<int64_t>(10, 8), 3);
+  EXPECT_EQ(bucket<int64_t>(10, 42), 6);
+  EXPECT_EQ(bucket<int64_t>(100, -34), 97);
+  EXPECT_EQ(bucket<int64_t>(2, -1), 0);
+  VELOX_ASSERT_THROW(
+      bucket<int64_t>(0, 34),
+      "Reason: (0 vs. 0) Invalid number of buckets.\nExpression: numBuckets <= 0\n");
+  VELOX_ASSERT_THROW(
+      bucket<int64_t>(-3, 34),
+      "Reason: (-3 vs. 0) Invalid number of buckets.\nExpression: numBuckets <= 0\n");
+}
+
+TEST_F(BucketFunctionTest, string) {
+  EXPECT_EQ(bucket<std::string>(5, "abcdefg"), 4);
+  EXPECT_EQ(bucket<std::string>(128, "abc"), 122);
+  EXPECT_EQ(bucket<std::string>(128, "abcd"), 106);
+  EXPECT_EQ(bucket<std::string>(64, "abcde"), 54);
+  EXPECT_EQ(bucket<std::string>(12, "测试"), 8);
+  EXPECT_EQ(bucket<std::string>(16, "测试raul试测"), 1);
+  EXPECT_EQ(bucket<std::string>(16, ""), 0);
+  EXPECT_EQ(bucket<std::string>(16, "Товары"), 10);
+  EXPECT_EQ(bucket<std::string>(120, "😀"), 58);
+  VELOX_ASSERT_THROW(
+      bucket<std::string>(0, "abc"),
+      "Reason: (0 vs. 0) Invalid number of buckets.\nExpression: numBuckets <= 0\n");
+  VELOX_ASSERT_THROW(
+      bucket<std::string>(-3, "abc"),
+      "Reason: (-3 vs. 0) Invalid number of buckets.\nExpression: numBuckets <= 0\n");
+}
+
+TEST_F(BucketFunctionTest, binary) {
+  EXPECT_EQ(bucket<StringView>(VARBINARY(), 128, "abc"), 122);
+  EXPECT_EQ(bucket<StringView>(VARBINARY(), 5, "abcdefg"), 4);
+}
+
+TEST_F(BucketFunctionTest, timestamp) {
+  EXPECT_EQ(bucket<Timestamp>(20, Timestamp(1633046400, 0)), 17);
+  EXPECT_EQ(bucket<Timestamp>(20, Timestamp(0, 123456789)), 0);
+  EXPECT_EQ(bucket<Timestamp>(20, Timestamp(-62167219200, 0)), 5);
+  VELOX_ASSERT_THROW(
+      bucket<Timestamp>(0, Timestamp(-62167219200, 0)),
+      "Reason: (0 vs. 0) Invalid number of buckets.\nExpression: numBuckets <= 0\n");
+  VELOX_ASSERT_THROW(
+      bucket<Timestamp>(-3, Timestamp(-62167219200, 0)),
+      "Reason: (-3 vs. 0) Invalid number of buckets.\nExpression: numBuckets <= 0\n");
+}
+
+TEST_F(BucketFunctionTest, date) {
+  EXPECT_EQ(bucket<int32_t>(DATE(), 10, 8), 3);
+  EXPECT_EQ(bucket<int32_t>(DATE(), 10, 42), 6);
+}
+
+TEST_F(BucketFunctionTest, decimal) {
+  EXPECT_EQ(bucket<int64_t>(DECIMAL(9, 2), 64, 1234), 56);
+  EXPECT_EQ(bucket<int64_t>(DECIMAL(9, 2), 18, 1230), 13);
+  EXPECT_EQ(bucket<int64_t>(DECIMAL(9, 2), 16, 12999), 2);
+  EXPECT_EQ(bucket<int64_t>(DECIMAL(9, 2), 128, 5), 85);
+  EXPECT_EQ(bucket<int64_t>(DECIMAL(9, 2), 18, 5), 3);
+
+  EXPECT_EQ(bucket<int128_t>(DECIMAL(38, 2), 10, 12), 7);
+  EXPECT_EQ(bucket<int128_t>(DECIMAL(38, 2), 10, 0), 7);
+  EXPECT_EQ(bucket<int128_t>(DECIMAL(38, 2), 10, 234), 6);
+  EXPECT_EQ(
+      bucket<int128_t>(DECIMAL(38, 2), 10, DecimalUtil::kLongDecimalMax), 4);
+}
+
+} // namespace
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/tests/CMakeLists.txt b/velox/functions/iceberg/tests/CMakeLists.txt
new file mode 100644
index 000000000000..a755179e2f8a
--- /dev/null
+++ b/velox/functions/iceberg/tests/CMakeLists.txt
@@ -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.
+add_executable(
+  velox_functions_iceberg_test
+  BucketFunctionTest.cpp
+  DateTimeFunctionsTest.cpp
+  Murmur3Hash32Test.cpp
+  TruncateTest.cpp
+)
+
+add_test(
+  NAME velox_functions_iceberg_test
+  COMMAND velox_functions_iceberg_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(
+  velox_functions_iceberg_test
+  velox_functions_iceberg
+  velox_functions_test_lib
+  velox_expression
+  velox_memory
+  GTest::gtest
+  GTest::gtest_main
+)
diff --git a/velox/functions/iceberg/tests/DateTimeFunctionsTest.cpp b/velox/functions/iceberg/tests/DateTimeFunctionsTest.cpp
new file mode 100644
index 000000000000..ba4b10cffeea
--- /dev/null
+++ b/velox/functions/iceberg/tests/DateTimeFunctionsTest.cpp
@@ -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.
+ */
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/iceberg/tests/IcebergFunctionBaseTest.h"
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+
+class DateTimeFunctionsTest
+    : public functions::iceberg::test::IcebergFunctionBaseTest {};
+
+TEST_F(DateTimeFunctionsTest, years) {
+  const auto years = [&](const std::string& ts) {
+    return evaluateOnce<int32_t>(
+        "years(c0)", std::make_optional<Timestamp>(parseTimestamp(ts)));
+  };
+  EXPECT_EQ(47, years("2017-12-01 10:12:55.038194"));
+  EXPECT_EQ(0, years("1970-01-01 00:00:01.000001"));
+  EXPECT_EQ(-1, years("1969-12-31 23:59:58.999999"));
+
+  const auto yearsDate = [&](const std::string& date) {
+    return evaluateOnce<int32_t>(
+        "years(c0)", DATE(), std::make_optional<int32_t>(parseDate(date)));
+  };
+  EXPECT_EQ(47, yearsDate("2017-12-01"));
+  EXPECT_EQ(0, yearsDate("1970-01-01"));
+  EXPECT_EQ(-1, yearsDate("1969-12-31"));
+}
+
+TEST_F(DateTimeFunctionsTest, months) {
+  const auto months = [&](const std::string& ts) {
+    return evaluateOnce<int32_t>(
+        "months(c0)", std::make_optional<Timestamp>(parseTimestamp(ts)));
+  };
+  EXPECT_EQ(575, months("2017-12-01 10:12:55.038194"));
+  EXPECT_EQ(0, months("1970-01-01 00:00:01.000001"));
+  EXPECT_EQ(-1, months("1969-12-31 23:59:58.999999"));
+
+  const auto monthsDate = [&](const std::string& date) {
+    return evaluateOnce<int32_t>(
+        "months(c0)", DATE(), std::make_optional<int32_t>(parseDate(date)));
+  };
+  EXPECT_EQ(575, monthsDate("2017-12-01"));
+  EXPECT_EQ(0, monthsDate("1970-01-01"));
+  EXPECT_EQ(-1, monthsDate("1969-12-31"));
+}
+
+TEST_F(DateTimeFunctionsTest, days) {
+  const auto days = [&](const std::string& ts) {
+    return evaluateOnce<int32_t>(
+        "days(c0)", std::make_optional<Timestamp>(parseTimestamp(ts)));
+  };
+
+  const auto daysDate = [&](const std::string& date) {
+    return evaluateOnce<int32_t>(
+        "days(c0)", DATE(), std::make_optional<int32_t>(parseDate(date)));
+  };
+  EXPECT_EQ(days("2017-12-01 10:12:55.038194"), daysDate("2017-12-01"));
+  EXPECT_EQ(days("1970-01-01 00:00:01.000001"), daysDate("1970-01-01"));
+  EXPECT_EQ(days("1969-12-31 23:59:58.999999"), daysDate("1969-12-31"));
+}
+
+TEST_F(DateTimeFunctionsTest, hours) {
+  const auto hours = [&](const std::string& ts) {
+    return evaluateOnce<int32_t>(
+        "hours(c0)", std::make_optional<Timestamp>(parseTimestamp(ts)));
+  };
+  EXPECT_EQ(420034, hours("2017-12-01 10:12:55.038194"));
+  EXPECT_EQ(0, hours("1970-01-01 00:00:01.000001"));
+  EXPECT_EQ(-1, hours("1969-12-31 23:59:58.999999"));
+}
+
+} // namespace
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/tests/IcebergFunctionBaseTest.h b/velox/functions/iceberg/tests/IcebergFunctionBaseTest.h
new file mode 100644
index 000000000000..4c68155c9876
--- /dev/null
+++ b/velox/functions/iceberg/tests/IcebergFunctionBaseTest.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/functions/iceberg/Register.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/parse/TypeResolver.h"
+
+namespace facebook::velox::functions::iceberg::test {
+
+class IcebergFunctionBaseTest
+    : public facebook::velox::functions::test::FunctionBaseTest {
+ protected:
+  static void SetUpTestCase() {
+    FunctionBaseTest::SetUpTestCase();
+    registerFunctions("");
+  }
+
+  void SetUp() override {
+    options_.parseDecimalAsDouble = false;
+  }
+};
+
+} // namespace facebook::velox::functions::iceberg::test
diff --git a/velox/functions/iceberg/tests/Murmur3Hash32Test.cpp b/velox/functions/iceberg/tests/Murmur3Hash32Test.cpp
new file mode 100644
index 000000000000..a395e0e0fccb
--- /dev/null
+++ b/velox/functions/iceberg/tests/Murmur3Hash32Test.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/iceberg/Murmur3Hash32.h"
+
+#include <gtest/gtest.h>
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+
+TEST(Murmur3Hash32Test, bigint) {
+  Murmur3Hash32 func;
+  EXPECT_EQ(func.hashInt64(10), -289985220);
+  EXPECT_EQ(func.hashInt64(0), 1669671676);
+  EXPECT_EQ(func.hashInt64(-5), 1222806974);
+}
+
+TEST(Murmur3Hash32Test, string) {
+  Murmur3Hash32 func;
+
+  const auto hash = [&](std::string input) {
+    return func.hashBytes(input.c_str(), input.size());
+  };
+
+  EXPECT_EQ(hash("abcdefg"), -2009294074);
+  EXPECT_EQ(hash("abc"), -1277324294);
+  EXPECT_EQ(hash("abcd"), 1139631978);
+  EXPECT_EQ(hash("abcde"), -392455434);
+  EXPECT_EQ(hash("测试"), -25843656);
+  EXPECT_EQ(hash("测试raul试测"), -912788207);
+  EXPECT_EQ(hash(""), 0);
+  EXPECT_EQ(hash("Товары"), 1817480714);
+  EXPECT_EQ(hash("😀"), -1095487750);
+}
+} // namespace
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/iceberg/tests/TruncateTest.cpp b/velox/functions/iceberg/tests/TruncateTest.cpp
new file mode 100644
index 000000000000..ff4a50510022
--- /dev/null
+++ b/velox/functions/iceberg/tests/TruncateTest.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 "velox/functions/iceberg/Truncate.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
+#include "velox/functions/iceberg/tests/IcebergFunctionBaseTest.h"
+
+namespace facebook::velox::functions::iceberg {
+namespace {
+class TruncateTest : public facebook::velox::functions::iceberg::test::
+                         IcebergFunctionBaseTest {
+ protected:
+  template <typename T>
+  std::optional<T> truncate(
+      std::optional<int32_t> width,
+      std::optional<T> value) {
+    return evaluateOnce<T>("truncate(c0, c1)", width, value);
+  }
+
+  template <typename T>
+  std::optional<T> truncate(
+      const TypePtr& type,
+      std::optional<int32_t> width,
+      std::optional<T> value) {
+    return evaluateOnce<T>("truncate(c0, c1)", {INTEGER(), type}, width, value);
+  }
+};
+
+TEST_F(TruncateTest, tinyInt) {
+  EXPECT_EQ(truncate<int8_t>(10, 0), 0);
+  EXPECT_EQ(truncate<int8_t>(10, 1), 0);
+  EXPECT_EQ(truncate<int8_t>(10, 5), 0);
+  EXPECT_EQ(truncate<int8_t>(10, 9), 0);
+  EXPECT_EQ(truncate<int8_t>(10, 10), 10);
+  EXPECT_EQ(truncate<int8_t>(10, 11), 10);
+  EXPECT_EQ(truncate<int8_t>(10, -1), -10);
+  EXPECT_EQ(truncate<int8_t>(10, -5), -10);
+  EXPECT_EQ(truncate<int8_t>(10, -10), -10);
+  EXPECT_EQ(truncate<int8_t>(10, -11), -20);
+
+  // Different widths.
+  EXPECT_EQ(truncate<int8_t>(2, -1), -2);
+
+  // Null handling.
+  EXPECT_EQ(truncate<int8_t>(10, std::nullopt), std::nullopt);
+}
+
+TEST_F(TruncateTest, smallInt) {
+  EXPECT_EQ(truncate<int16_t>(10, 0), 0);
+  EXPECT_EQ(truncate<int16_t>(10, 1), 0);
+  EXPECT_EQ(truncate<int16_t>(10, 5), 0);
+  EXPECT_EQ(truncate<int16_t>(10, 9), 0);
+  EXPECT_EQ(truncate<int16_t>(10, 10), 10);
+  EXPECT_EQ(truncate<int16_t>(10, 11), 10);
+  EXPECT_EQ(truncate<int16_t>(10, -1), -10);
+  EXPECT_EQ(truncate<int16_t>(10, -5), -10);
+  EXPECT_EQ(truncate<int16_t>(10, -10), -10);
+  EXPECT_EQ(truncate<int16_t>(10, -11), -20);
+  EXPECT_EQ(truncate<int16_t>(7, 22), 21);
+  EXPECT_EQ(truncate<int16_t>(2, -1), -2);
+  EXPECT_EQ(truncate<int16_t>(10, std::nullopt), std::nullopt);
+}
+
+TEST_F(TruncateTest, integer) {
+  EXPECT_EQ(truncate<int32_t>(10, 0), 0);
+  EXPECT_EQ(truncate<int32_t>(10, 1), 0);
+  EXPECT_EQ(truncate<int32_t>(10, 5), 0);
+  EXPECT_EQ(truncate<int32_t>(10, 9), 0);
+  EXPECT_EQ(truncate<int32_t>(10, 10), 10);
+  EXPECT_EQ(truncate<int32_t>(10, 11), 10);
+  EXPECT_EQ(truncate<int32_t>(10, -1), -10);
+  EXPECT_EQ(truncate<int32_t>(10, -5), -10);
+  EXPECT_EQ(truncate<int32_t>(10, -10), -10);
+  EXPECT_EQ(truncate<int32_t>(10, -11), -20);
+
+  // Different widths.
+  EXPECT_EQ(truncate<int32_t>(2, -1), -2);
+  EXPECT_EQ(truncate<int32_t>(300, 1), 0);
+
+  EXPECT_EQ(truncate<int32_t>(10, std::nullopt), std::nullopt);
+}
+
+TEST_F(TruncateTest, bigint) {
+  EXPECT_EQ(truncate<int64_t>(10, 0), 0);
+  EXPECT_EQ(truncate<int64_t>(10, 1), 0);
+  EXPECT_EQ(truncate<int64_t>(10, 5), 0);
+  EXPECT_EQ(truncate<int64_t>(10, 9), 0);
+  EXPECT_EQ(truncate<int64_t>(10, 10), 10);
+  EXPECT_EQ(truncate<int64_t>(10, 11), 10);
+  EXPECT_EQ(truncate<int64_t>(10, -1), -10);
+  EXPECT_EQ(truncate<int64_t>(10, -5), -10);
+  EXPECT_EQ(truncate<int64_t>(10, -10), -10);
+  EXPECT_EQ(truncate<int64_t>(10, -11), -20);
+
+  EXPECT_EQ(truncate<int64_t>(2, -1), -2);
+  EXPECT_EQ(truncate<int64_t>(10, std::nullopt), std::nullopt);
+  VELOX_ASSERT_THROW(
+      truncate<int64_t>(0, 34),
+      "Reason: (0 vs. 0) Invalid truncate width\nExpression: width <= 0");
+  VELOX_ASSERT_THROW(
+      truncate<int64_t>(-3, 34),
+      "Reason: (-3 vs. 0) Invalid truncate width\nExpression: width <= 0");
+}
+
+TEST_F(TruncateTest, string) {
+  // Basic truncation cases.
+  EXPECT_EQ(truncate<std::string>(5, "abcdefg"), "abcde");
+  EXPECT_EQ(truncate<std::string>(5, "abc"), "abc");
+  EXPECT_EQ(truncate<std::string>(5, "abcde"), "abcde");
+
+  // Empty string handling.
+  EXPECT_EQ(truncate<std::string>(10, ""), "");
+
+  // Unicode handling (4-byte characters).
+  std::string twoFourByteChars = "\U00010000\U00010000"; // Two 𐀀 characters
+  EXPECT_EQ(truncate<std::string>(1, twoFourByteChars), "\U00010000");
+
+  // Mixed character sizes.
+  EXPECT_EQ(truncate<std::string>(4, "测试raul试测"), "测试ra");
+
+  // Explicit varchar/char types (treated same as string).
+  EXPECT_EQ(truncate<std::string>(4, "测试raul试测"), "测试ra");
+
+  VELOX_ASSERT_THROW(
+      truncate<std::string>(0, "abc"),
+      "Reason: (0 vs. 0) Invalid truncate width\nExpression: width <= 0");
+  VELOX_ASSERT_THROW(
+      truncate<std::string>(-3, "abc"),
+      "Reason: (-3 vs. 0) Invalid truncate width\nExpression: width <= 0");
+  VELOX_ASSERT_THROW(
+      truncate<std::string>(0, "测试"),
+      "Reason: (0 vs. 0) Invalid truncate width\nExpression: width <= 0");
+  VELOX_ASSERT_THROW(
+      truncate<std::string>(-3, "测试"),
+      "Reason: (-3 vs. 0) Invalid truncate width\nExpression: width <= 0");
+}
+
+TEST_F(TruncateTest, unicodeBoundaries) {
+  // Japanese characters (3-byte UTF-8).
+  std::string japanese = "イロハニホヘト";
+  EXPECT_EQ(truncate<std::string>(2, japanese), "イロ");
+  EXPECT_EQ(truncate<std::string>(3, japanese), "イロハ");
+  EXPECT_EQ(truncate<std::string>(7, japanese), japanese);
+
+  // Chinese characters (3-byte UTF-8).
+  EXPECT_EQ(truncate<std::string>(1, "测试"), "测");
+}
+
+TEST_F(TruncateTest, binary) {
+  EXPECT_EQ(truncate<std::string>(VARBINARY(), 10, "abc\0\0"), "abc\0\0");
+  EXPECT_EQ(truncate<std::string>(VARBINARY(), 3, "abcdefg"), "abc");
+  EXPECT_EQ(truncate<std::string>(VARBINARY(), 3, "abc"), "abc");
+  EXPECT_EQ(truncate<std::string>(VARBINARY(), 6, "测试"), "测试");
+}
+
+TEST_F(TruncateTest, decimal) {
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 2), 10, 1234), 1230);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 2), 10, 1239), 1230);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 2), 10, 5), 0);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 2), 10, -5), -10);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 3), 10, 12299), 12290);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(9, 3), 1, 1), 1);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(5, 2), 3, 5), 3);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(10, 4), 10, 123453482), 123453480);
+  EXPECT_EQ(truncate<int64_t>(DECIMAL(6, 4), 10, -500), -500);
+  EXPECT_EQ(truncate<int128_t>(DECIMAL(38, 2), 10, 5), 0);
+  EXPECT_EQ(truncate<int128_t>(DECIMAL(38, 2), 10, -5), -10);
+}
+} // namespace
+} // namespace facebook::velox::functions::iceberg
diff --git a/velox/functions/lib/ApproxMostFrequentStreamSummary.h b/velox/functions/lib/ApproxMostFrequentStreamSummary.h
index b34197c15c30..24de5e59d630 100644
--- a/velox/functions/lib/ApproxMostFrequentStreamSummary.h
+++ b/velox/functions/lib/ApproxMostFrequentStreamSummary.h
@@ -44,8 +44,9 @@ struct ApproxMostFrequentStreamSummary {
 
   void setCapacity(int);
 
-  /// Add one or multiple new values to the summary.
-  void insert(T value, int64_t count = 1);
+  /// Add a value with the given count to the summary.
+  /// Returns the evicted value if at capacity, std::nullopt otherwise.
+  std::optional<T> insert(T value, int64_t count = 1);
 
   /// Get the top `k` frequent elements with their estimated counts, sorted from
   /// most hits to least hits.
@@ -131,17 +132,25 @@ int ApproxMostFrequentStreamSummary<T, A>::capacity() const {
 }
 
 template <typename T, typename A>
-void ApproxMostFrequentStreamSummary<T, A>::insert(T value, int64_t count) {
+std::optional<T> ApproxMostFrequentStreamSummary<T, A>::insert(
+    T value,
+    int64_t count) {
   auto index = queue_.getValueIndex(value);
   if (index.has_value()) {
-    auto oldCount = queue_.priorities()[*index];
+    const auto oldCount = queue_.priorities()[*index];
     queue_.updatePriority(*index, oldCount + count);
-  } else if (size() < capacity_) {
+    return std::nullopt;
+  }
+  if (size() < capacity_) {
     queue_.addNewValue(value, count);
-  } else {
-    auto oldCount = queue_.topPriority();
-    queue_.replaceTop(value, oldCount + count);
+    return std::nullopt;
   }
+
+  // At capacity - need to evict the minimum entry.
+  std::optional<T> evictedValue{queue_.top()};
+  auto evictedCount = queue_.topPriority();
+  queue_.replaceTop(value, evictedCount + count);
+  return evictedValue;
 }
 
 template <typename T, typename A>
@@ -149,7 +158,7 @@ void ApproxMostFrequentStreamSummary<T, A>::topK(
     int k,
     T* values,
     int64_t* counts) const {
-  VELOX_CHECK(k >= 0);
+  VELOX_CHECK_GE(k, 0);
   k = std::min(k, size());
   if (k == 0) {
     return;
@@ -180,7 +189,7 @@ void ApproxMostFrequentStreamSummary<T, A>::topK(
 template <typename T, typename A>
 std::vector<std::pair<T, int64_t>> ApproxMostFrequentStreamSummary<T, A>::topK(
     int k) const {
-  VELOX_CHECK(k >= 0);
+  VELOX_CHECK_GE(k, 0);
   k = std::min(k, size());
   std::vector<T> values(k);
   std::vector<int64_t> counts(k);
diff --git a/velox/functions/lib/ArrayShuffle.cpp b/velox/functions/lib/ArrayShuffle.cpp
index b0f9c3685e1c..bfa3f47f0a73 100644
--- a/velox/functions/lib/ArrayShuffle.cpp
+++ b/velox/functions/lib/ArrayShuffle.cpp
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 #include <random>
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/EvalCtx.h"
-#include "velox/expression/Expr.h"
 #include "velox/expression/VectorFunction.h"
 
 namespace facebook::velox::functions {
diff --git a/velox/functions/lib/ArraySort.cpp b/velox/functions/lib/ArraySort.cpp
new file mode 100644
index 000000000000..8bfb16badb06
--- /dev/null
+++ b/velox/functions/lib/ArraySort.cpp
@@ -0,0 +1,586 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/F14Set.h>
+
+#include "velox/expression/EvalCtx.h"
+#include "velox/expression/Expr.h"
+#include "velox/functions/lib/ArraySort.h"
+#include "velox/functions/lib/LambdaFunctionUtil.h"
+#include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+BufferPtr sortElements(
+    const SelectivityVector& rows,
+    const ArrayVector& inputArray,
+    const BaseVector& inputElements,
+    bool ascending,
+    bool nullsFirst,
+    exec::EvalCtx& context,
+    bool throwOnNestedNull) {
+  const SelectivityVector inputElementRows =
+      toElementRows(inputElements.size(), rows, &inputArray);
+  exec::LocalDecodedVector decodedElements(
+      context, inputElements, inputElementRows);
+  const auto* baseElementsVector = decodedElements->base();
+
+  // Allocate new vectors for indices.
+  BufferPtr indices = allocateIndices(inputElements.size(), context.pool());
+  vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
+
+  CompareFlags flags{.nullsFirst = nullsFirst, .ascending = ascending};
+  if (throwOnNestedNull) {
+    flags.nullHandlingMode =
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate;
+  }
+
+  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 && bNull) {
+            return false;
+          }
+          if (aNull) {
+            return nullsFirst;
+          }
+          if (bNull) {
+            return !nullsFirst;
+          }
+
+          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;
+        });
+  });
+
+  return indices;
+}
+
+void applyComplexType(
+    const SelectivityVector& rows,
+    ArrayVector* inputArray,
+    bool ascending,
+    bool nullsFirst,
+    exec::EvalCtx& context,
+    VectorPtr& resultElements,
+    bool throwOnNestedNull) {
+  auto inputElements = inputArray->elements();
+  auto indices = sortElements(
+      rows,
+      *inputArray,
+      *inputElements,
+      ascending,
+      nullsFirst,
+      context,
+      throwOnNestedNull);
+  resultElements = BaseVector::transpose(indices, std::move(inputElements));
+}
+
+template <typename T>
+inline void swapWithNull(
+    FlatVector<T>* vector,
+    vector_size_t index,
+    vector_size_t nullIndex) {
+  // Values are already present in vector stringBuffers. Don't create additional
+  // copy.
+  if constexpr (std::is_same_v<T, StringView>) {
+    vector->setNoCopy(nullIndex, vector->valueAt(index));
+  } else {
+    vector->set(nullIndex, vector->valueAt(index));
+  }
+  vector->setNull(index, true);
+}
+
+template <TypeKind kind>
+void applyScalarType(
+    const SelectivityVector& rows,
+    const ArrayVector* inputArray,
+    bool ascending,
+    bool nullsFirst,
+    exec::EvalCtx& context,
+    VectorPtr& resultElements) {
+  using T = typename TypeTraits<kind>::NativeType;
+
+  // Copy array elements to new vector.
+  const VectorPtr& inputElements = inputArray->elements();
+  VELOX_DCHECK(kind == inputElements->typeKind());
+  const SelectivityVector inputElementRows =
+      toElementRows(inputElements->size(), rows, inputArray);
+  const vector_size_t elementsCount = inputElementRows.size();
+
+  // TODO: consider to use dictionary wrapping to avoid the direct sorting on
+  // the scalar values as we do for complex data type if this runs slow in
+  // practice.
+  resultElements =
+      BaseVector::create(inputElements->type(), elementsCount, context.pool());
+  resultElements->copy(
+      inputElements.get(), inputElementRows, /*toSourceRow=*/nullptr);
+
+  auto flatResults = resultElements->asFlatVector<T>();
+
+  auto processRow = [&](vector_size_t row) {
+    const auto size = inputArray->sizeAt(row);
+    const auto offset = inputArray->offsetAt(row);
+    if (size == 0) {
+      return;
+    }
+    vector_size_t numNulls = 0;
+    if (nullsFirst) {
+      // Move nulls to beginning of array.
+      for (vector_size_t i = 0; i < size; ++i) {
+        if (flatResults->isNullAt(offset + i)) {
+          swapWithNull<T>(flatResults, offset + numNulls, offset + i);
+          ++numNulls;
+        }
+      }
+    } else {
+      // Move nulls to end of array.
+      for (vector_size_t i = size - 1; i >= 0; --i) {
+        if (flatResults->isNullAt(offset + i)) {
+          swapWithNull<T>(
+              flatResults, offset + size - numNulls - 1, offset + i);
+          ++numNulls;
+        }
+      }
+    }
+    // Exclude null values while sorting.
+    const auto startRow = offset + (nullsFirst ? numNulls : 0);
+    const auto endRow = startRow + size - numNulls;
+
+    if constexpr (kind == TypeKind::BOOLEAN) {
+      uint64_t* rawBits = flatResults->template mutableRawValues<uint64_t>();
+      const auto numOneBits = bits::countBits(rawBits, startRow, endRow);
+
+      if (ascending) {
+        const auto endZeroRow = endRow - numOneBits;
+        bits::fillBits(rawBits, startRow, endZeroRow, false);
+        bits::fillBits(rawBits, endZeroRow, endRow, true);
+      } else {
+        bits::fillBits(rawBits, startRow, startRow + numOneBits, true);
+        bits::fillBits(rawBits, startRow + numOneBits, 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) {
+        std::sort(resultRawValues + startRow, resultRawValues + endRow);
+      } else {
+        std::sort(
+            resultRawValues + startRow,
+            resultRawValues + endRow,
+            std::greater<T>());
+      }
+    }
+  };
+  rows.applyToSelected(processRow);
+}
+
+// See documentation at https://prestodb.io/docs/current/functions/array.html
+template <TypeKind Kind>
+class ArraySortFunction : public exec::VectorFunction {
+ public:
+  /// This class implements the array_sort query function. Takes an array as
+  /// input and sorts it in ascending order and null elements will be placed at
+  /// the end of the returned array.
+  ///
+  /// Along with the set, we maintain a `hasNull` flag that indicates whether
+  /// null is present in the array.
+  ///
+  /// Zero element copy for complex data type:
+  ///
+  /// In order to prevent copies of array elements with complex data type, the
+  /// function reuses the internal elements() vector from the original
+  /// ArrayVector. A new vector is created containing the indices of the sorted
+  /// elements in the output, and wrapped into a DictionaryVector. The 'lengths'
+  /// and 'offsets' vectors that control where output arrays start and end
+  /// remain the same in the output ArrayVector.
+
+  explicit ArraySortFunction(
+      bool ascending,
+      bool nullsFirst,
+      bool throwOnNestedNull)
+      : ascending_{ascending},
+        nullsFirst_{nullsFirst},
+        throwOnNestedNull_{throwOnNestedNull} {}
+
+  // Execute function.
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /*outputType*/,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    auto& arg = args[0];
+
+    VectorPtr localResult;
+
+    // Input can be constant or flat.
+    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();
+
+      exec::LocalSingleRow singleRow(context, flatIndex);
+      localResult = applyFlat(*singleRow, flatArray, context);
+      localResult =
+          BaseVector::wrapInConstant(rows.end(), flatIndex, localResult);
+    } else {
+      localResult = applyFlat(rows, arg, context);
+    }
+
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+ private:
+  VectorPtr applyFlat(
+      const SelectivityVector& rows,
+      const VectorPtr& arg,
+      exec::EvalCtx& context) const {
+    // Acquire the array elements vector.
+    auto inputArray = arg->as<ArrayVector>();
+    VectorPtr resultElements;
+
+    if constexpr (velox::TypeTraits<Kind>::isPrimitiveType) {
+      VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          applyScalarType,
+          Kind,
+          rows,
+          inputArray,
+          ascending_,
+          nullsFirst_,
+          context,
+          resultElements);
+
+    } else {
+      applyComplexType(
+          rows,
+          inputArray,
+          ascending_,
+          nullsFirst_,
+          context,
+          resultElements,
+          throwOnNestedNull_);
+    }
+
+    return std::make_shared<ArrayVector>(
+        context.pool(),
+        inputArray->type(),
+        inputArray->nulls(),
+        rows.end(),
+        inputArray->offsets(),
+        inputArray->sizes(),
+        resultElements,
+        inputArray->getNullCount());
+  }
+
+  const bool ascending_;
+  const bool nullsFirst_;
+  const bool throwOnNestedNull_;
+};
+
+class ArraySortLambdaFunction : public exec::VectorFunction {
+ public:
+  explicit ArraySortLambdaFunction(bool ascending, bool throwOnNestedNull)
+      : ascending_{ascending}, throwOnNestedNull_(throwOnNestedNull) {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /*outputType*/,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    // Flatten input array.
+    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
+    auto& decodedArray = *arrayDecoder.get();
+
+    auto flatArray = flattenArray(rows, args[0], decodedArray);
+
+    std::vector<VectorPtr> lambdaArgs = {flatArray->elements()};
+    auto newNumElements = flatArray->elements()->size();
+
+    SelectivityVector validRowsInReusedResult =
+        toElementRows<ArrayVector>(newNumElements, rows, flatArray.get());
+
+    // Compute sorting keys.
+    VectorPtr newElements;
+
+    auto elementToTopLevelRows = getElementToTopLevelRows(
+        newNumElements, rows, flatArray.get(), context.pool());
+
+    // Loop over lambda functions and apply these to elements of the base array.
+    // In most cases there will be only one function and the loop will run once.
+    auto it = args[1]->asUnchecked<FunctionVector>()->iterator(&rows);
+    while (auto entry = it.next()) {
+      auto elementRows = toElementRows<ArrayVector>(
+          newNumElements, *entry.rows, flatArray.get());
+      auto wrapCapture = toWrapCapture<ArrayVector>(
+          newNumElements, entry.callable, *entry.rows, flatArray);
+
+      entry.callable->apply(
+          elementRows,
+          &validRowsInReusedResult,
+          wrapCapture,
+          &context,
+          lambdaArgs,
+          elementToTopLevelRows,
+          &newElements);
+    }
+
+    // Sort 'newElements'.
+    auto indices = sortElements(
+        rows,
+        *flatArray,
+        *newElements,
+        ascending_,
+        false /*nullsFirst*/,
+        context,
+        throwOnNestedNull_);
+    auto sortedElements = BaseVector::wrapInDictionary(
+        nullptr,
+        indices,
+        indices->size() / sizeof(vector_size_t),
+        flatArray->elements());
+
+    // Set nulls for rows not present in 'rows'.
+    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
+
+    VectorPtr localResult = std::make_shared<ArrayVector>(
+        flatArray->pool(),
+        flatArray->type(),
+        std::move(newNulls),
+        rows.end(),
+        flatArray->offsets(),
+        flatArray->sizes(),
+        sortedElements);
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+ 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 nullsFirst,
+    bool throwOnNestedNull = true) {
+  return std::make_shared<ArraySortFunction<kind>>(
+      ascending, nullsFirst, throwOnNestedNull);
+}
+
+// Define function signature.
+std::vector<std::shared_ptr<exec::FunctionSignature>> signatures(
+    bool withComparator) {
+  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
+      // array(T) -> array(T)
+      exec::FunctionSignatureBuilder()
+          .orderableTypeVariable("T")
+          .returnType("array(T)")
+          .argumentType("array(T)")
+          .build(),
+      // array(T), function(T,U), boolean -> array(T)
+      exec::FunctionSignatureBuilder()
+          .typeVariable("T")
+          .orderableTypeVariable("U")
+          .returnType("array(T)")
+          .argumentType("array(T)")
+          .constantArgumentType("function(T,U)")
+          .build(),
+  };
+
+  if (withComparator) {
+    signatures.push_back(
+        // array(T), function(T,T,bigint) -> array(T)
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("array(T)")
+            .argumentType("array(T)")
+            .constantArgumentType("function(T,T,bigint)")
+            .build());
+  }
+  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> makeArraySortAscNoThrowOnNestedNull(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  return makeArraySort(
+      name,
+      inputArgs,
+      config,
+      true,
+      false /*nullsFirst=*/,
+      false /*throwOnNestedNull=*/);
+}
+
+core::CallTypedExprPtr asArraySortCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr) {
+  if (auto call = std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
+    if (call->name() == prefix + "array_sort") {
+      return call;
+    }
+  }
+  return nullptr;
+}
+
+} // namespace
+
+std::shared_ptr<exec::VectorFunction> makeArraySortLambdaFunction(
+    const std::string& /*name*/,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& /*config*/,
+    bool ascending,
+    bool throwOnNestedNull) {
+  VELOX_CHECK_EQ(inputArgs.size(), 2);
+  return std::make_shared<ArraySortLambdaFunction>(
+      ascending, throwOnNestedNull);
+}
+
+std::shared_ptr<exec::VectorFunction> makeArraySort(
+    const std::string& /*name*/,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& /*config*/,
+    bool ascending,
+    bool nullsFirst,
+    bool throwOnNestedNull) {
+  const auto elementType = inputArgs.front().type->childAt(0);
+  if (elementType->isUnKnown()) {
+    return createTyped<TypeKind::UNKNOWN>(
+        inputArgs, ascending, nullsFirst, throwOnNestedNull);
+  }
+
+  return VELOX_DYNAMIC_TYPE_DISPATCH(
+      createTyped,
+      elementType->kind(),
+      inputArgs,
+      ascending,
+      nullsFirst,
+      throwOnNestedNull);
+}
+
+std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortSignatures(
+    bool withComparator) {
+  return signatures(withComparator);
+}
+
+core::TypedExprPtr rewriteArraySortCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr,
+    const std::shared_ptr<SimpleComparisonChecker> checker) {
+  auto call = asArraySortCall(prefix, expr);
+  if (call == nullptr || call->inputs().size() != 2) {
+    return nullptr;
+  }
+  auto lambda =
+      dynamic_cast<const core::LambdaTypedExpr*>(call->inputs()[1].get());
+  VELOX_CHECK_NOT_NULL(lambda);
+  // Extract 'transform' from the comparison lambda:
+  //  (x, y) -> if(func(x) < func(y),...) ===> x -> func(x).
+  if (lambda->signature()->size() != 2) {
+    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 = checker->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(),
+        name,
+        call->inputs()[0],
+        std::make_shared<core::LambdaTypedExpr>(
+            ROW({lambda->signature()->nameOf(0)},
+                {lambda->signature()->childAt(0)}),
+            comparison->expr));
+
+    return rewritten;
+  }
+
+  VELOX_USER_FAIL(kNotSupported, lambda->toString());
+}
+
+// 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(),
+    makeArraySortAscNoThrowOnNestedNull);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/ArraySort.h b/velox/functions/lib/ArraySort.h
new file mode 100644
index 000000000000..915c2f738bd1
--- /dev/null
+++ b/velox/functions/lib/ArraySort.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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"
+#include "velox/functions/lib/SimpleComparisonMatcher.h"
+
+namespace facebook::velox::functions {
+
+/// Creates array_sort function.
+///
+/// @param ascending If true, sort in ascending order; otherwise, sort in
+/// descending order.
+/// @param nullsFirst If true, nulls are placed first; otherwise, nulls are
+/// placed last.
+/// @param throwOnNestedNull If true, throw an exception if a nested null is
+/// encountered.
+std::shared_ptr<exec::VectorFunction> makeArraySort(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config,
+    bool ascending,
+    bool nullsFirst,
+    bool throwOnNestedNull);
+
+/// Creates array_sort with a lambda function.
+///
+/// @param ascending If true, sort in ascending order; otherwise, sort in
+/// descending order.
+/// @param throwOnNestedNull If true, throw an exception if a nested null is
+/// encountered.
+std::shared_ptr<exec::VectorFunction> makeArraySortLambdaFunction(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config,
+    bool ascending,
+    bool throwOnNestedNull);
+
+/// Returns signatures for array_sort function.
+///
+/// @param withComparator If true, includes a signature for sorting with a
+/// comparator function.
+std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortSignatures(
+    bool withComparator);
+
+/// Analyzes array_sort(array, lambda) call to determine whether it can be
+/// re-written into a simpler call that specifies sort-by expression.
+///
+/// For example, rewrites
+///     array_sort(a, (x, y) -> if(length(x) < length(y), -1, if(length(x) >
+///     length(y), 1, 0))
+/// into
+///     array_sort(a, x -> length(x))
+///
+/// Returns the rewritten expression. If rewrite is not possible, throw a user
+/// error.
+core::TypedExprPtr rewriteArraySortCall(
+    const std::string& prefix,
+    const core::TypedExprPtr& expr,
+    const std::shared_ptr<SimpleComparisonChecker> checker);
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/CMakeLists.txt b/velox/functions/lib/CMakeLists.txt
index bdff97bba2d9..bd95e846c442 100644
--- a/velox/functions/lib/CMakeLists.txt
+++ b/velox/functions/lib/CMakeLists.txt
@@ -16,19 +16,27 @@ velox_add_library(velox_is_null_functions IsNull.cpp)
 
 velox_link_libraries(velox_is_null_functions velox_expression)
 
-velox_add_library(velox_functions_util LambdaFunctionUtil.cpp
-                  RowsTranslationUtil.cpp)
+velox_add_library(
+  velox_functions_util
+  Murmur3Hash32Base.cpp
+  LambdaFunctionUtil.cpp
+  RowsTranslationUtil.cpp
+)
 
 velox_link_libraries(velox_functions_util velox_vector velox_common_base)
 
-velox_add_library(velox_functions_lib_date_time_formatter DateTimeFormatter.cpp
-                  DateTimeFormatterBuilder.cpp)
+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
+  ArraySort.cpp
   CheckDuplicateKeys.cpp
   CheckNestedNulls.cpp
   KllSketch.cpp
@@ -36,20 +44,26 @@ velox_add_library(
   Re2Functions.cpp
   Repeat.cpp
   Slice.cpp
+  SimpleComparisonMatcher.cpp
   StringEncodingUtils.cpp
   SubscriptUtil.cpp
   TimeUtils.cpp
-  Utf8Utils.cpp)
+  Utf8Utils.cpp
+)
 
 velox_link_libraries(
   velox_functions_lib
+  velox_expression
   velox_functions_util
   velox_vector
   velox_type_tz
+  velox_common_hyperloglog
   re2::re2
-  Folly::folly)
+  Folly::folly
+)
 
 add_subdirectory(aggregates)
+add_subdirectory(sfm)
 add_subdirectory(string)
 add_subdirectory(window)
 if(${VELOX_BUILD_TESTING})
diff --git a/velox/functions/lib/CheckNestedNulls.cpp b/velox/functions/lib/CheckNestedNulls.cpp
index 348535c9ce6b..6e0d0b27bb27 100644
--- a/velox/functions/lib/CheckNestedNulls.cpp
+++ b/velox/functions/lib/CheckNestedNulls.cpp
@@ -18,13 +18,10 @@
 
 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,
+    vector_size_t baseIndex,
     bool throwOnNestedNulls) {
   if (decoded.isNullAt(index)) {
     return true;
@@ -32,11 +29,12 @@ bool checkNestedNulls(
 
   if (throwOnNestedNulls) {
     VELOX_USER_CHECK(
-        !decoded.base()->containsNullAt(indices[index]),
+        !decoded.base()->containsNullAt(baseIndex),
         "{} comparison not supported for values that contain nulls",
-        mapTypeKindToName(decoded.base()->typeKind()));
+        TypeKindName::toName(decoded.base()->typeKind()));
   }
 
   return false;
 }
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/CheckNestedNulls.h b/velox/functions/lib/CheckNestedNulls.h
index eafbbe95c736..01d6d1e5cbd1 100644
--- a/velox/functions/lib/CheckNestedNulls.h
+++ b/velox/functions/lib/CheckNestedNulls.h
@@ -20,12 +20,17 @@
 
 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.
+/// Checks nested nulls in a complex type vector.
+///
+/// @param decoded The decoded vector to check
+/// @param index The index in the decoded vector to check
+/// @param baseIndex The index in the base vector to check for nested nulls
+/// @param throwOnNestedNulls If true, throws exception when base vector
+/// contains nulls
+/// @return true if the value at specified index is null, false otherwise
 bool checkNestedNulls(
     const DecodedVector& decoded,
-    const vector_size_t* indices,
     vector_size_t index,
+    vector_size_t baseIndex,
     bool throwOnNestedNulls = false);
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/DateTimeFormatter.cpp b/velox/functions/lib/DateTimeFormatter.cpp
index 4d5d70c0197b..7551a31eb504 100644
--- a/velox/functions/lib/DateTimeFormatter.cpp
+++ b/velox/functions/lib/DateTimeFormatter.cpp
@@ -310,10 +310,11 @@ parseFail(const std::string_view& input, const char* cur, const char* 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)));
+  return folly::makeUnexpected(
+      Status::UserError(
+          "Invalid date format: '{}' is malformed at '{}'",
+          input,
+          std::string_view(cur, end - cur)));
 }
 
 // Joda only supports parsing a few three-letter prefixes. The list is available
@@ -1221,10 +1222,10 @@ uint32_t DateTimeFormatter::maxResultSize(const tz::TimeZone* timezone) const {
         break;
       case DateTimeFormatSpecifier::TIMEZONE:
         if (token.pattern.minRepresentDigits <= 3) {
-          // The longest timezone abbreviation is 6 in the case of negative or
-          // explicitly positive numeric representations (e.g., +01:00, -08:00)
-          // https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
-          size += 6;
+          // The longest timezone abbreviation is 9 in the case of timezones
+          // that do not have an abbreviation and use GMT offset (e.g.,
+          // GMT+01:00, GMT-08:00)
+          size += 9;
         } else {
           // The longest time zone long name is 40, Australian Central Western
           // Standard Time.
@@ -1618,13 +1619,14 @@ Expected<DateTimeResult> DateTimeFormatter::parse(
       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),
-          date.year,
-          date.month));
+      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),
+              date.year,
+              date.month));
     }
   }
 
@@ -1634,13 +1636,14 @@ Expected<DateTimeResult> DateTimeFormatter::parse(
       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,
-          date.year,
-          date.month));
+      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,
+              date.year,
+              date.month));
     }
   }
 
@@ -1797,8 +1800,9 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildMysqlDateTimeFormatter(
           if (threadSkipErrorDetails()) {
             return folly::makeUnexpected(Status::UserError());
           }
-          return folly::makeUnexpected(Status::UserError(
-              "Date format specifier is not supported: %{}", *tokenEnd));
+          return folly::makeUnexpected(
+              Status::UserError(
+                  "Date format specifier is not supported: %{}", *tokenEnd));
         default:
           builder.appendLiteral(tokenEnd, 1);
           break;
@@ -1936,8 +1940,9 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildJodaDateTimeFormatter(
             if (threadSkipErrorDetails()) {
               return folly::makeUnexpected(Status::UserError());
             }
-            return folly::makeUnexpected(Status::UserError(
-                "Specifier {} is not supported.", *startTokenPtr));
+            return folly::makeUnexpected(
+                Status::UserError(
+                    "Specifier {} is not supported.", *startTokenPtr));
           } else {
             builder.appendLiteral(startTokenPtr, cur - startTokenPtr);
           }
@@ -2015,9 +2020,6 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildSimpleDateTimeFormatter(
         case 'D':
           builder.appendDayOfYear(count);
           break;
-        case 'e':
-          builder.appendDayOfWeek1Based(count);
-          break;
         case 'E':
           builder.appendDayOfWeekText(count);
           break;
@@ -2052,6 +2054,9 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildSimpleDateTimeFormatter(
         case 'S':
           builder.appendFractionOfSecond(count);
           break;
+        case 'u':
+          builder.appendDayOfWeek1Based(count);
+          break;
         case 'w':
           builder.appendWeekOfWeekYear(count);
           break;
@@ -2078,8 +2083,9 @@ Expected<std::shared_ptr<DateTimeFormatter>> buildSimpleDateTimeFormatter(
             if (threadSkipErrorDetails()) {
               return folly::makeUnexpected(Status::UserError());
             }
-            return folly::makeUnexpected(Status::UserError(
-                "Specifier {} is not supported.", *startTokenPtr));
+            return folly::makeUnexpected(
+                Status::UserError(
+                    "Specifier {} is not supported.", *startTokenPtr));
           } else {
             builder.appendLiteral(startTokenPtr, cur - startTokenPtr);
           }
diff --git a/velox/functions/lib/DateTimeFormatter.h b/velox/functions/lib/DateTimeFormatter.h
index 012c0b9ef981..a4568429f658 100644
--- a/velox/functions/lib/DateTimeFormatter.h
+++ b/velox/functions/lib/DateTimeFormatter.h
@@ -131,6 +131,10 @@ enum class DateTimeUnit {
   kYear
 };
 
+FOLLY_ALWAYS_INLINE bool isTimeUnit(const DateTimeUnit unit) {
+  return unit < DateTimeUnit::kDay;
+}
+
 struct FormatPattern {
   DateTimeFormatSpecifier specifier;
 
diff --git a/velox/functions/lib/DateTimeFormatterBuilder.cpp b/velox/functions/lib/DateTimeFormatterBuilder.cpp
index aa80058ac8f3..afa808fd398e 100644
--- a/velox/functions/lib/DateTimeFormatterBuilder.cpp
+++ b/velox/functions/lib/DateTimeFormatterBuilder.cpp
@@ -204,8 +204,9 @@ DateTimeFormatterBuilder& DateTimeFormatterBuilder::appendLiteral(
     tokens_.back().literal =
         std::string_view(prev.data(), prev.size() + literalSize);
   } else {
-    tokens_.emplace_back(std::string_view(
-        literalBuf_.get() + bufEnd_ - literalSize, literalSize));
+    tokens_.emplace_back(
+        std::string_view(
+            literalBuf_.get() + bufEnd_ - literalSize, literalSize));
   }
   return *this;
 }
diff --git a/velox/functions/lib/DateTimeUtil.h b/velox/functions/lib/DateTimeUtil.h
new file mode 100644
index 000000000000..5b9e8c9a125e
--- /dev/null
+++ b/velox/functions/lib/DateTimeUtil.h
@@ -0,0 +1,442 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/external/date/date.h"
+#include "velox/functions/lib/DateTimeFormatter.h"
+#include "velox/type/Timestamp.h"
+#include "velox/type/Type.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox::functions {
+
+/// Returns toTimestamp - fromTimestamp expressed in terms of unit.
+/// @param respectLastDay If true, the last day of a year-month is respected.
+/// For example, the difference between '2020-01-31' and '2020-02-01' is 1 day.
+/// If false, the last day of a year-month is not respected. For example, the
+/// difference between '2020-01-31' and '2020-02-01' is 0 day.
+/// This is useful for Spark compatibility, as Spark does not respect the last
+/// day of a year-month.
+FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
+    DateTimeUnit unit,
+    const Timestamp& fromTimestamp,
+    const Timestamp& toTimestamp,
+    bool respectLastDay = true) {
+  // TODO: Handle overflow and underflow with 64-bit representation.
+  if (fromTimestamp == toTimestamp) {
+    return 0;
+  }
+
+  const int8_t sign = fromTimestamp < toTimestamp ? 1 : -1;
+
+  // The microsecond unit is handled independently to prevent overflow while
+  // converting all timestamps to microseconds for each unit.
+  if (unit == DateTimeUnit::kMicrosecond) {
+    const std::chrono::time_point<std::chrono::system_clock>
+        fromMicrosecondpoint(
+            std::chrono::microseconds(
+                std::min(fromTimestamp, toTimestamp).toMicros()));
+    const std::chrono::time_point<std::chrono::system_clock> toMicrosecondpoint(
+        std::chrono::microseconds(
+            std::max(fromTimestamp, toTimestamp).toMicros()));
+    return sign *
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            toMicrosecondpoint - fromMicrosecondpoint)
+            .count();
+  }
+
+  // fromTimepoint is less than or equal to toTimepoint.
+  const std::chrono::
+      time_point<std::chrono::system_clock, std::chrono::milliseconds>
+          fromTimepoint(
+              std::chrono::milliseconds(
+                  std::min(fromTimestamp, toTimestamp).toMillis()));
+  const std::chrono::
+      time_point<std::chrono::system_clock, std::chrono::milliseconds>
+          toTimepoint(
+              std::chrono::milliseconds(
+                  std::max(fromTimestamp, toTimestamp).toMillis()));
+
+  // Millisecond, second, minute, hour and day have fixed conversion ratio.
+  switch (unit) {
+    case DateTimeUnit::kMillisecond: {
+      return sign *
+          std::chrono::duration_cast<std::chrono::milliseconds>(
+              toTimepoint - fromTimepoint)
+              .count();
+    }
+    case DateTimeUnit::kSecond: {
+      return sign *
+          std::chrono::duration_cast<std::chrono::seconds>(
+              toTimepoint - fromTimepoint)
+              .count();
+    }
+    case DateTimeUnit::kMinute: {
+      return sign *
+          std::chrono::duration_cast<std::chrono::minutes>(
+              toTimepoint - fromTimepoint)
+              .count();
+    }
+    case DateTimeUnit::kHour: {
+      return sign *
+          std::chrono::duration_cast<std::chrono::hours>(
+              toTimepoint - fromTimepoint)
+              .count();
+    }
+    case DateTimeUnit::kDay: {
+      return sign *
+          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;
+  }
+
+  // Month, quarter and year do not have fixed conversion ratio. Ex. a month can
+  // have 28, 29, 30 or 31 days. A year can have 365 or 366 days.
+  const std::chrono::time_point<std::chrono::system_clock, date::days>
+      fromDaysTimepoint = std::chrono::floor<date::days>(fromTimepoint);
+  const std::chrono::time_point<std::chrono::system_clock, date::days>
+      toDaysTimepoint = std::chrono::floor<date::days>(toTimepoint);
+  const date::year_month_day fromCalDate(fromDaysTimepoint);
+  const date::year_month_day toCalDate(toDaysTimepoint);
+  const uint64_t fromTimeInstantOfDay =
+      std::chrono::duration_cast<std::chrono::milliseconds>(
+          fromTimepoint - fromDaysTimepoint)
+          .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()),
+                toMonth = static_cast<unsigned>(toCalDate.month());
+  const date::year_month_day toCalLastYearMonthDay(
+      toCalDate.year() / toCalDate.month() / date::last);
+  const uint8_t toLastYearMonthDay =
+      static_cast<unsigned>(toCalLastYearMonthDay.day());
+
+  if (unit == DateTimeUnit::kMonth || unit == DateTimeUnit::kQuarter) {
+    int64_t diff =
+        (int64_t(toCalDate.year()) - int64_t(fromCalDate.year())) * 12 +
+        int(toMonth) - int(fromMonth);
+
+    if (((!respectLastDay || toDay != toLastYearMonthDay) && fromDay > toDay) ||
+        (fromDay == toDay && fromTimeInstantOfDay > toTimeInstantOfDay)) {
+      diff--;
+    }
+
+    diff = (unit == DateTimeUnit::kMonth) ? diff : diff / 3;
+    return sign * diff;
+  }
+
+  if (unit == DateTimeUnit::kYear) {
+    int64_t diff = (toCalDate.year() - fromCalDate.year()).count();
+
+    if (fromMonth > toMonth ||
+        (fromMonth == toMonth && fromDay > toDay &&
+         (!respectLastDay || toDay != toLastYearMonthDay)) ||
+        (fromMonth == toMonth && fromDay == toDay &&
+         fromTimeInstantOfDay > toTimeInstantOfDay)) {
+      diff--;
+    }
+    return sign * diff;
+  }
+
+  VELOX_UNREACHABLE();
+}
+
+FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
+    DateTimeUnit unit,
+    const Timestamp& fromTimestamp,
+    const Timestamp& toTimestamp,
+    const tz::TimeZone* timeZone,
+    bool respectLastDay = true) {
+  if (LIKELY(timeZone != nullptr)) {
+    // sessionTimeZone not null means that the config
+    // adjust_timestamp_to_timezone is on.
+    Timestamp fromZonedTimestamp = fromTimestamp;
+    fromZonedTimestamp.toTimezone(*timeZone);
+
+    Timestamp toZonedTimestamp = toTimestamp;
+    if (isTimeUnit(unit)) {
+      const int64_t offset =
+          static_cast<Timestamp>(fromTimestamp).getSeconds() -
+          fromZonedTimestamp.getSeconds();
+      toZonedTimestamp = Timestamp(
+          toZonedTimestamp.getSeconds() - offset, toZonedTimestamp.getNanos());
+    } else {
+      toZonedTimestamp.toTimezone(*timeZone);
+    }
+    return diffTimestamp(
+        unit, fromZonedTimestamp, toZonedTimestamp, respectLastDay);
+  }
+  return diffTimestamp(unit, fromTimestamp, toTimestamp, respectLastDay);
+}
+
+/// Year, quarter or month are not uniformly incremented. Months have different
+/// total days, and leap years have more days than the rest. If the new year,
+/// quarter or month has less total days than the given one, it will be coerced
+/// to use the valid last day of the new month. This could result in weird
+/// arithmetic behavior. For example,
+///
+/// 2022-01-30 + (1 month) = 2022-02-28
+/// 2022-02-28 - (1 month) = 2022-01-28
+///
+/// 2022-08-31 + (1 quarter) = 2022-11-30
+/// 2022-11-30 - (1 quarter) = 2022-08-30
+///
+/// 2020-02-29 + (1 year) = 2021-02-28
+/// 2021-02-28 - (1 year) = 2020-02-28
+FOLLY_ALWAYS_INLINE
+int32_t addToDate(int32_t input, DateTimeUnit unit, int32_t value) {
+  // TODO: Handle overflow and underflow with 64-bit representation
+  if (value == 0) {
+    return input;
+  }
+
+  const std::chrono::time_point<std::chrono::system_clock, date::days> inDate{
+      date::days(input)};
+  std::chrono::time_point<std::chrono::system_clock, date::days> outDate;
+
+  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;
+
+    if (unit == DateTimeUnit::kMonth) {
+      outCalDate = inCalDate + date::months(value);
+    } else if (unit == DateTimeUnit::kQuarter) {
+      outCalDate = inCalDate + date::months(3 * value);
+    } else if (unit == DateTimeUnit::kYear) {
+      outCalDate = inCalDate + date::years(value);
+    } else {
+      VELOX_UNREACHABLE();
+    }
+
+    if (!outCalDate.ok()) {
+      outCalDate = outCalDate.year() / outCalDate.month() / date::last;
+    }
+    outDate = date::sys_days{outCalDate};
+  }
+
+  return outDate.time_since_epoch().count();
+}
+
+FOLLY_ALWAYS_INLINE Timestamp
+addToTimestamp(const Timestamp& timestamp, DateTimeUnit unit, int32_t value) {
+  // TODO: Handle overflow and underflow with 64-bit representation.
+  if (value == 0) {
+    return timestamp;
+  }
+
+  // The microsecond unit is handled independently to prevent overflow while
+  // converting all timestamps to microseconds for each unit.
+  if (unit == DateTimeUnit::kMicrosecond) {
+    const std::chrono::time_point<std::chrono::system_clock> inMicroTimestamp(
+        std::chrono::microseconds(timestamp.toMicros()));
+    const std::chrono::time_point<std::chrono::system_clock> outMicroTimestamp =
+        inMicroTimestamp + std::chrono::microseconds(value);
+    const Timestamp microTimestamp = Timestamp::fromMicros(
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            outMicroTimestamp.time_since_epoch())
+            .count());
+    return Timestamp(
+        microTimestamp.getSeconds(),
+        microTimestamp.getNanos() +
+            timestamp.getNanos() % Timestamp::kNanosecondsInMicrosecond);
+  }
+
+  const std::chrono::
+      time_point<std::chrono::system_clock, std::chrono::milliseconds>
+          inTimestamp(std::chrono::milliseconds(timestamp.toMillis()));
+  std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>
+      outTimestamp;
+
+  switch (unit) {
+    // Year, quarter, month or week are not uniformly incremented in terms of
+    // number of days. So we treat them differently.
+    case DateTimeUnit::kYear:
+    case DateTimeUnit::kQuarter:
+    case DateTimeUnit::kMonth:
+    case DateTimeUnit::kWeek:
+    case DateTimeUnit::kDay: {
+      const int32_t inDate =
+          std::chrono::duration_cast<date::days>(inTimestamp.time_since_epoch())
+              .count();
+      const int32_t outDate = addToDate(inDate, unit, value);
+      outTimestamp =
+          inTimestamp + date::days(checkedMinus<int32_t>(outDate, inDate));
+      break;
+    }
+    case DateTimeUnit::kHour: {
+      outTimestamp = inTimestamp + std::chrono::hours(value);
+      break;
+    }
+    case DateTimeUnit::kMinute: {
+      outTimestamp = inTimestamp + std::chrono::minutes(value);
+      break;
+    }
+    case DateTimeUnit::kSecond: {
+      outTimestamp = inTimestamp + std::chrono::seconds(value);
+      break;
+    }
+    case DateTimeUnit::kMillisecond: {
+      outTimestamp = inTimestamp + std::chrono::milliseconds(value);
+      break;
+    }
+    default:
+      VELOX_UNREACHABLE("Unsupported datetime unit");
+  }
+
+  Timestamp milliTimestamp =
+      Timestamp::fromMillis(outTimestamp.time_since_epoch().count());
+  return Timestamp(
+      milliTimestamp.getSeconds(),
+      milliTimestamp.getNanos() +
+          timestamp.getNanos() % Timestamp::kNanosecondsInMillisecond);
+}
+
+FOLLY_ALWAYS_INLINE Timestamp addToTimestamp(
+    DateTimeUnit unit,
+    int32_t value,
+    const Timestamp& timestamp,
+    const tz::TimeZone* timeZone) {
+  Timestamp result;
+  if (LIKELY(timeZone != nullptr)) {
+    // timeZone not null means that the config
+    // adjust_timestamp_to_timezone is on.
+    Timestamp zonedTimestamp = timestamp;
+    zonedTimestamp.toTimezone(*timeZone);
+
+    Timestamp resultTimestamp = addToTimestamp(zonedTimestamp, unit, value);
+
+    if (isTimeUnit(unit)) {
+      const int64_t offset =
+          timestamp.getSeconds() - zonedTimestamp.getSeconds();
+      result = Timestamp(
+          resultTimestamp.getSeconds() + offset, resultTimestamp.getNanos());
+    } else {
+      result = Timestamp(
+          timeZone
+              ->correct_nonexistent_time(
+                  std::chrono::seconds(resultTimestamp.getSeconds()))
+              .count(),
+          resultTimestamp.getNanos());
+      result.toGMT(*timeZone);
+    }
+  } else {
+    result = addToTimestamp(timestamp, unit, value);
+  }
+  return result;
+}
+
+/// Adds the specified unit and value to a TIME value, handling 24-hour
+/// wraparound. TIME represents milliseconds since midnight (0 to 86399999ms).
+/// For units < DAY, the time of day changes.
+/// For units >= DAY, the time of day doesn't change.
+FOLLY_ALWAYS_INLINE int64_t addToTime(int64_t time, int64_t valueInMillis) {
+  VELOX_USER_CHECK(
+      time >= 0 && time < kMillisInDay,
+      "TIME value {} is out of range [0, 86400000)",
+      time);
+
+  if (FOLLY_UNLIKELY(valueInMillis == 0)) {
+    return time;
+  }
+
+  // Use std::chrono for safe duration arithmetic with overflow protection
+  const auto timeDuration = std::chrono::milliseconds(time);
+  const auto valueDuration = std::chrono::milliseconds(valueInMillis);
+  const auto resultDuration = timeDuration + valueDuration;
+
+  // Handle 24-hour wraparound using modulo
+  const auto dayDuration = std::chrono::milliseconds(kMillisInDay);
+  auto newTime = resultDuration % dayDuration;
+
+  // Ensure result is positive (C++ modulo can return negative values)
+  if (FOLLY_UNLIKELY(newTime.count() < 0)) {
+    newTime += dayDuration;
+  }
+
+  return newTime.count();
+}
+
+/// Truncates a TIME value to the specified unit. TIME represents milliseconds
+/// since midnight (0 to 86399999ms). Only time-related units (millisecond,
+/// second, minute, hour) are supported.
+FOLLY_ALWAYS_INLINE int64_t truncateTime(int64_t time, DateTimeUnit unit) {
+  VELOX_USER_CHECK(
+      time >= 0 && time < kMillisInDay,
+      "TIME value {} is out of range [0, 86400000)",
+      time);
+
+  // Validate that the unit is appropriate for TIME type
+  VELOX_USER_CHECK(isTimeUnit(unit), "Unsupported time unit for TIME type");
+
+  const auto duration = std::chrono::milliseconds(time);
+
+  switch (unit) {
+    case DateTimeUnit::kMillisecond:
+      return time;
+    case DateTimeUnit::kSecond: {
+      const auto seconds =
+          std::chrono::duration_cast<std::chrono::seconds>(duration);
+      return std::chrono::duration_cast<std::chrono::milliseconds>(seconds)
+          .count();
+    }
+    case DateTimeUnit::kMinute: {
+      const auto minutes =
+          std::chrono::duration_cast<std::chrono::minutes>(duration);
+      return std::chrono::duration_cast<std::chrono::milliseconds>(minutes)
+          .count();
+    }
+    case DateTimeUnit::kHour: {
+      const auto hours =
+          std::chrono::duration_cast<std::chrono::hours>(duration);
+      return std::chrono::duration_cast<std::chrono::milliseconds>(hours)
+          .count();
+    }
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/JsonUtil.h b/velox/functions/lib/JsonUtil.h
new file mode 100644
index 000000000000..2703a06defe7
--- /dev/null
+++ b/velox/functions/lib/JsonUtil.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 "velox/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::functions {
+
+inline std::string_view trimToken(std::string_view token) {
+  VELOX_DCHECK(!stringImpl::isAsciiWhiteSpace(token[0]));
+  auto size = token.size();
+  while (stringImpl::isAsciiWhiteSpace(token[size - 1])) {
+    --size;
+  }
+  return std::string_view(token.data(), size);
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/MakeRowFromMap.h b/velox/functions/lib/MakeRowFromMap.h
new file mode 100644
index 000000000000..68d212737045
--- /dev/null
+++ b/velox/functions/lib/MakeRowFromMap.h
@@ -0,0 +1,313 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/expression/EvalCtx.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/SimpleVector.h"
+
+namespace facebook::velox::functions {
+
+// Used to create a vector of a given type with default values. For primitive
+// types, it will be set to the c++ default, like 0 for INTEGER and empty string
+// for VARCHAR. For Array/Map they will be set to an empty array or map. Not
+// supported for ROW or UNKNOWN types.
+class MakeRowFromMapDefaults {
+ public:
+  // Returns a vector with flat encoding of the given type and size with default
+  // values. Optionally accepts a vector pool to enable recycling of vectors.
+  static VectorPtr createFlat(
+      const TypePtr& type,
+      const vector_size_t size,
+      memory::MemoryPool& pool,
+      VectorPool* vectorPool) {
+    VectorPtr result = vectorPool ? vectorPool->get(type, size)
+                                  : BaseVector::create(type, size, &pool);
+    VELOX_DYNAMIC_TYPE_DISPATCH_ALL(fillWithDefaultValue, type->kind(), result);
+    return result;
+  }
+
+  // Returns a vector with constant encoding of the given type and size with
+  // default values.
+  static VectorPtr createConstant(
+      const TypePtr& type,
+      const vector_size_t size,
+      memory::MemoryPool& pool) {
+    VectorPtr result = velox::BaseVector::create(type, 1, &pool);
+    VELOX_DYNAMIC_TYPE_DISPATCH_ALL(fillWithDefaultValue, type->kind(), result);
+    result = velox::BaseVector::wrapInConstant(size, 0, result);
+    return result;
+  }
+
+ private:
+  template <TypeKind ValueKind>
+  static void fillWithDefaultValue(VectorPtr& vector) {
+    VELOX_CHECK_NOT_NULL(vector);
+    if constexpr (
+        (TypeTraits<ValueKind>::isPrimitiveType ||
+         ValueKind == TypeKind::OPAQUE) &&
+        ValueKind != TypeKind::UNKNOWN) {
+      using T = typename TypeTraits<ValueKind>::NativeType;
+      VELOX_CHECK(vector->isFlatEncoding());
+      auto* rawValues = vector->asFlatVector<T>()->mutableRawValues();
+      std::fill(rawValues, rawValues + vector->size(), T());
+    } else if constexpr (
+        ValueKind == TypeKind::ARRAY || ValueKind == TypeKind::MAP) {
+      auto vectorSize = vector->size();
+      auto arrayBaseVector = vector->asChecked<ArrayVectorBase>();
+      VELOX_CHECK_NOT_NULL(arrayBaseVector);
+      auto* rawOffsets = arrayBaseVector->mutableOffsets(vectorSize)
+                             ->asMutable<vector_size_t>();
+      auto* rawSizes =
+          arrayBaseVector->mutableSizes(vectorSize)->asMutable<vector_size_t>();
+      std::fill(rawOffsets, rawOffsets + vectorSize, 0);
+      std::fill(rawSizes, rawSizes + vectorSize, 0);
+    } else {
+      VELOX_USER_FAIL(
+          "Unsupported type for replacing nulls: {}",
+          vector->type()->toString());
+    }
+  }
+};
+
+struct MakeRowFromMapOptions {
+  /// The list of keys to extract from each map. The type should be the same
+  /// as the key type in the map and the typeKind template specified when
+  /// creating MakeRowFromMap object. Should be the same size as
+  /// 'outputFieldNames'. Cannot be empty or null.
+  VectorPtr keysToProject;
+
+  /// The names to assign to the corresponding fields in the output RowVector.
+  ///  The i-th key in 'keysToProject' will be mapped to the i-th field name and
+  ///  therefore it should be the same size as 'keysToProject'. Cannot contain
+  ///  empty or duplicate entries.
+  std::vector<std::string> outputFieldNames;
+
+  /// When set to false, if the map is null, a key is missing, or the
+  /// value is null, the output field will also be null.
+  /// If set to true, replaces null output values with type-specific defaults
+  /// like for primitive types, they will be set to the c++ default
+  /// initialized value, like 0 for INTEGER and empty string for VARCHAR. For
+  /// Array/Map they will be set to an empty array or map. Not supported for
+  /// ROW or UNKNOWN types.
+  bool replaceNulls{false};
+
+  /// Only valid if replaceNulls is false. If set to true, a null map will
+  /// result in a null row in the output. Otherwise, the top level row will
+  /// not be null but every field in the output row will be null.
+  bool allowTopLevelNulls{false};
+
+  /// If true, duplicate keys are allowed and the last value is used.
+  bool throwOnDuplicateKeys{true};
+};
+
+///  A utility class for projecting specific keys from a vector of MAP type
+///  (which may be encoded) into a RowVector with named fields corresponding to
+///  each projected key. For each active row, it extracts the values
+///  corresponding to the specified keys and assigns them to their respective
+///  fields in an output RowVector. The output RowVector contains one field for
+///  each specified key, and its size will be equal to the last active row in
+///  the selectivity vector. It optionally accepts an exec::EvalCtx object
+///  pointer for use within Vector Functions. This allows it to leverage the
+///  vector and decodedVector pool within that context and apply per-row error
+///  handling as required by expression evaluation.
+///
+///  Note:
+/// - Only keys of types SMALLINT, INTEGER, and BIGINT are currently
+/// supported. TODO: Support other key types
+/// (https://github.com/facebookincubator/velox/issues/14790)
+/// - Rows marked as inactive in the 'rows' selectivity vector will result in
+/// valid rows in the output; however, no guarantees are made regarding their
+/// assigned values.
+template <TypeKind KeyKind>
+class MakeRowFromMap {
+  using KeyType = typename TypeTraits<KeyKind>::NativeType;
+
+ public:
+  MakeRowFromMap(const MakeRowFromMapOptions& options)
+      : replaceNulls_(options.replaceNulls),
+        allowTopLevelNulls_(options.allowTopLevelNulls),
+        throwOnDuplicateKeys_(options.throwOnDuplicateKeys),
+        outputFieldNames_(options.outputFieldNames),
+        inputKeyType_(options.keysToProject->type()) {
+    VELOX_USER_CHECK_NOT_NULL(options.keysToProject);
+    VELOX_USER_CHECK_GT(
+        options.keysToProject->size(), 0, "Keys to project cannot be empty");
+    VELOX_USER_CHECK_EQ(
+        options.keysToProject->size(),
+        options.outputFieldNames.size(),
+        "Number of keys to project and output field names must be the same");
+    ensureValidFieldNames(options.outputFieldNames);
+
+    VELOX_USER_CHECK_EQ(
+        KeyKind, inputKeyType_->kind(), "Unexptected key TypeKind");
+    if (inputKeyType_ != SMALLINT() && inputKeyType_ != INTEGER() &&
+        inputKeyType_ != BIGINT()) {
+      VELOX_NYI(
+          "Only SMALLINT, INTEGER, BIGINT keys are currently supported, instead got {}",
+          inputKeyType_->toString());
+    }
+    createKeyToFieldIndexMap(options.keysToProject);
+  }
+
+  VectorPtr apply(
+      const BaseVector& map,
+      const SelectivityVector& rows,
+      exec::EvalCtx* evalCtx) {
+    VELOX_USER_CHECK_EQ(
+        map.type()->kind(), TypeKind::MAP, "Input must be of MAP typeKind");
+
+    // Ensure that the key type from the map and type of keysToProject is the
+    // same.
+    const auto& keyType = map.type()->asMap().keyType();
+    VELOX_USER_CHECK_EQ(
+        keyType,
+        inputKeyType_,
+        "Map key type and the type of keys to project are not the same");
+
+    return toRowVectorImpl(map, rows, evalCtx);
+  }
+
+ private:
+  void createKeyToFieldIndexMap(const VectorPtr& keysToProject) {
+    keyToIndex_.reserve(keysToProject->size());
+    auto keysToProjectVec = keysToProject->template as<SimpleVector<KeyType>>();
+    for (size_t i = 0; i < keysToProjectVec->size(); ++i) {
+      VELOX_USER_CHECK(
+          !keysToProjectVec->isNullAt(i),
+          "Keys to project cannot contain null");
+      auto key = keysToProjectVec->valueAt(i);
+      bool ok = keyToIndex_.insert({key, i}).second;
+      // Key must be unique.
+      VELOX_USER_CHECK(ok, "Duplicate keys cannot be projected: {}", key);
+    }
+  }
+
+  VectorPtr toRowVectorImpl(
+      const BaseVector& vector,
+      const SelectivityVector& rows,
+      exec::EvalCtx* evalCtx) {
+    exec::LocalDecodedVector decodedMap(evalCtx);
+    decodedMap.get()->decode(vector, rows);
+    auto mapBase = decodedMap->base()->asUnchecked<MapVector>();
+    exec::LocalDecodedVector decodedKeys(evalCtx);
+    decodedKeys.get()->decode(*mapBase->mapKeys());
+    exec::LocalDecodedVector decodedValues(evalCtx);
+    decodedValues.get()->decode(*mapBase->mapValues());
+    auto valueType = mapBase->mapValues()->type();
+    auto* offsets = mapBase->rawOffsets();
+    auto* sizes = mapBase->rawSizes();
+    auto outputSize = rows.end();
+
+    std::vector<VectorPtr> children;
+    children.reserve(keyToIndex_.size());
+    auto vectorPool = evalCtx ? evalCtx->vectorPool() : nullptr;
+    for (size_t i = 0; i < keyToIndex_.size(); ++i) {
+      if (replaceNulls_) {
+        children.push_back(
+            MakeRowFromMapDefaults::createFlat(
+                valueType, outputSize, *mapBase->pool(), vectorPool));
+      } else {
+        children.push_back(
+            vectorPool
+                ? vectorPool->get(valueType, outputSize)
+                : BaseVector::create(valueType, outputSize, mapBase->pool()));
+        auto rawNulls = children.back()->mutableRawNulls();
+        bits::fillBits(rawNulls, 0, outputSize, bits::kNull);
+      }
+    }
+    auto outputNulls =
+        (!replaceNulls_ && allowTopLevelNulls_ && decodedMap->mayHaveNulls())
+        ? allocateNulls(outputSize, mapBase->pool(), bits::kNotNull)
+        : nullptr;
+    auto* rawNulls =
+        outputNulls ? outputNulls->template asMutable<uint64_t>() : nullptr;
+    std::vector<bool> visited(keyToIndex_.size());
+    std::vector<std::vector<BaseVector::CopyRange>> copyRangesFromBase(
+        keyToIndex_.size());
+    rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
+      std::fill(visited.begin(), visited.end(), false);
+      if (!decodedMap->isNullAt(row)) {
+        auto decodedIndex = decodedMap->index(row);
+        auto offset = offsets[decodedIndex];
+        auto size = sizes[decodedIndex];
+        for (auto i = offset; i < offset + size; ++i) {
+          if (decodedKeys->isNullAt(i) || decodedValues->isNullAt(i)) {
+            continue;
+          }
+          auto key = decodedKeys->valueAt<KeyType>(i);
+          auto it = keyToIndex_.find(key);
+          if (it == keyToIndex_.end()) {
+            continue;
+          }
+          auto index = it->second;
+          if (visited[index]) {
+            if (throwOnDuplicateKeys_) {
+              auto errorMessage =
+                  fmt::format("Duplicate keys not allowed: {}", key);
+              if (evalCtx) {
+                evalCtx->setStatus(row, Status::UserError(errorMessage));
+              } else {
+                VELOX_USER_FAIL(errorMessage);
+              }
+              return;
+            }
+            VELOX_CHECK(!copyRangesFromBase[index].empty());
+            VELOX_CHECK_EQ(copyRangesFromBase[index].back().targetIndex, row);
+            copyRangesFromBase[index].back().sourceIndex =
+                decodedValues->index(i);
+          } else {
+            visited[index] = true;
+            copyRangesFromBase[index].push_back(
+                {decodedValues->index(i), row, 1});
+          }
+        }
+      } else if (rawNulls) {
+        bits::setNull(rawNulls, row, true);
+      }
+    });
+    for (size_t i = 0; i < children.size(); ++i) {
+      children[i]->copyRanges(decodedValues->base(), copyRangesFromBase[i]);
+    }
+
+    return std::make_shared<RowVector>(
+        vector.pool(),
+        ROW(outputFieldNames_, valueType),
+        std::move(outputNulls),
+        outputSize,
+        std::move(children));
+  }
+
+  void ensureValidFieldNames(const std::vector<std::string>& fieldNames) {
+    std::unordered_set<std::string> fieldNamesSet;
+    for (const auto& fieldName : fieldNames) {
+      VELOX_USER_CHECK(!fieldName.empty(), "Field name cannot be empty");
+      auto ok = fieldNamesSet.insert(fieldName).second;
+      VELOX_USER_CHECK(
+          ok, "Duplicate field names are not allowed: {}", fieldName);
+    }
+  }
+
+  const bool replaceNulls_{false};
+  const bool allowTopLevelNulls_{false};
+  const bool throwOnDuplicateKeys_{true};
+  const std::vector<std::string> outputFieldNames_;
+  const TypePtr inputKeyType_;
+  folly::F14FastMap<KeyType, size_t> keyToIndex_;
+};
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/MapConcat.cpp b/velox/functions/lib/MapConcat.cpp
index 57105ff3893a..993571d6bf20 100644
--- a/velox/functions/lib/MapConcat.cpp
+++ b/velox/functions/lib/MapConcat.cpp
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "MapConcat.h"
-#include "velox/expression/Expr.h"
+#include "velox/functions/lib/MapConcat.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/vector/TypeAliases.h"
 
@@ -186,8 +186,8 @@ class MapConcatFunction : public exec::VectorFunction {
 void registerMapConcatFunction(const std::string& name) {
   exec::registerVectorFunction(
       name,
-      MapConcatFunction</*EmptyForNull=*/false, /*AllowSingleArg=*/false>::
-          signatures(),
+      MapConcatFunction</*EmptyForNull=*/false,
+                        /*AllowSingleArg=*/false>::signatures(),
       std::make_unique<MapConcatFunction<
           /*EmptyForNull=*/false,
           /*AllowSingleArg=*/false>>());
@@ -196,8 +196,8 @@ void registerMapConcatFunction(const std::string& name) {
 void registerMapConcatAllowSingleArg(const std::string& name) {
   exec::registerVectorFunction(
       name,
-      MapConcatFunction</*EmptyForNull=*/false, /*AllowSingleArg=*/true>::
-          signatures(),
+      MapConcatFunction</*EmptyForNull=*/false,
+                        /*AllowSingleArg=*/true>::signatures(),
       std::make_unique<MapConcatFunction<
           /*EmptyForNull=*/false,
           /*AllowSingleArg=*/true>>());
@@ -206,8 +206,8 @@ void registerMapConcatAllowSingleArg(const std::string& name) {
 void registerMapConcatEmptyNullsFunction(const std::string& name) {
   exec::registerVectorFunction(
       name,
-      MapConcatFunction</*EmptyForNull=*/true, /*AllowSingleArg=*/false>::
-          signatures(),
+      MapConcatFunction</*EmptyForNull=*/true,
+                        /*AllowSingleArg=*/false>::signatures(),
       std::make_unique<MapConcatFunction<
           /*EmptyForNull=*/true,
           /*AllowSingleArg=*/false>>(),
diff --git a/velox/functions/lib/Murmur3Hash32Base.cpp b/velox/functions/lib/Murmur3Hash32Base.cpp
new file mode 100644
index 000000000000..7d344cf0e1d6
--- /dev/null
+++ b/velox/functions/lib/Murmur3Hash32Base.cpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/Murmur3Hash32Base.h"
+#include "velox/common/base/BitUtil.h"
+
+namespace facebook::velox::functions {
+
+uint32_t Murmur3Hash32Base::hashInt64(uint64_t input, uint32_t seed) {
+  uint32_t low = input;
+  uint32_t high = input >> 32;
+
+  uint32_t k1 = mixK1(low);
+  uint32_t h1 = mixH1(seed, k1);
+
+  k1 = mixK1(high);
+  h1 = mixH1(h1, k1);
+
+  return fmix(h1, 8);
+}
+
+uint32_t Murmur3Hash32Base::mixK1(uint32_t k1) {
+  k1 *= 0xcc9e2d51;
+  k1 = bits::rotateLeft(k1, 15);
+  k1 *= 0x1b873593;
+  return k1;
+}
+
+uint32_t Murmur3Hash32Base::mixH1(uint32_t h1, uint32_t k1) {
+  h1 ^= k1;
+  h1 = bits::rotateLeft(h1, 13);
+  h1 = h1 * 5 + 0xe6546b64;
+  return h1;
+}
+
+uint32_t Murmur3Hash32Base::fmix(uint32_t h1, uint32_t length) {
+  h1 ^= length;
+  h1 ^= h1 >> 16;
+  h1 *= 0x85ebca6b;
+  h1 ^= h1 >> 13;
+  h1 *= 0xc2b2ae35;
+  h1 ^= h1 >> 16;
+  return h1;
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Murmur3Hash32Base.h b/velox/functions/lib/Murmur3Hash32Base.h
new file mode 100644
index 000000000000..52db1235a3a5
--- /dev/null
+++ b/velox/functions/lib/Murmur3Hash32Base.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 <cstdint>
+
+namespace facebook::velox::functions {
+/// Murmur3 aligns with Austin Appleby
+/// https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp
+///
+/// Signed integer types have been remapped to unsigned types (as in the
+/// original) to avoid undefined signed integer overflow and sign extension.
+class Murmur3Hash32Base {
+ protected:
+  /// Hash the lower int, then combine with higher int, is a fast path of
+  /// hashBytes.
+  static uint32_t hashInt64(uint64_t input, uint32_t seed);
+
+  static uint32_t mixK1(uint32_t k1);
+
+  static uint32_t mixH1(uint32_t h1, uint32_t k1);
+
+  // Finalization mix - force all bits of a hash block to avalanche.
+  static uint32_t fmix(uint32_t h1, uint32_t length);
+};
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/QuantileDigest.h b/velox/functions/lib/QuantileDigest.h
index ade0d60135d5..ca9ded610cc0 100644
--- a/velox/functions/lib/QuantileDigest.h
+++ b/velox/functions/lib/QuantileDigest.h
@@ -19,6 +19,7 @@
 #include <folly/Bits.h>
 
 #include "velox/common/base/CheckedArithmetic.h"
+#include "velox/common/base/Doubles.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Portability.h"
 #include "velox/common/memory/HashStringAllocator.h"
@@ -28,6 +29,7 @@ namespace facebook::velox::functions {
 namespace qdigest {
 
 constexpr double kZeroWeightThreshold = 1.0E-5;
+constexpr double kUninitializedMaxError = 0.0;
 
 /// Implementation of Q-Digest that matches Presto Java behavior. The
 /// serialization format is same as Java. There is one performance improvement:
@@ -50,6 +52,10 @@ class QuantileDigest {
 
   QuantileDigest(const Allocator& allocator, const char* serialized);
 
+  void setMaxError(double maxError);
+
+  double getMaxError() const;
+
   void add(T value, double weight);
 
   void mergeSerialized(const char* other);
@@ -62,17 +68,17 @@ class QuantileDigest {
 
   /// Estimate the values of the given quantiles and write the results in order
   /// directly into 'result'.
-  void estimateQuantiles(const std::vector<double>& quantiles, T* result);
+  void estimateQuantiles(const std::vector<double>& quantiles, T* result) const;
 
-  T estimateQuantile(double quantile);
+  T estimateQuantile(double quantile) const;
 
   int64_t serializedByteSize() const;
 
   int64_t serialize(char* out);
 
-  T getMin();
+  T getMin() const;
 
-  T getMax();
+  T getMax() const;
 
   // For testing only. Calling this method with 'other' being constructed from
   // QuantileDigest(const Allocator& allocator, const char* serialized) is
@@ -80,6 +86,50 @@ class QuantileDigest {
   // on 'serialized'.
   void testingMerge(const QuantileDigest& other);
 
+  // Returns nullopt when the digest is empty or the value is out of the
+  // min/max range.
+  std::optional<double> quantileAtValue(T value) const;
+
+  struct CdfEntry {
+    T upperBound;
+    double cumulativeProbability;
+  };
+
+  /// Returns the cumulative distribution function as a vector of entries
+  /// mapping upper bounds to cumulative probabilities for values within
+  /// the specified range [rangeStart, rangeEnd]. The CDF provides
+  /// a lower bound estimate for the proportion of items <= x with error
+  /// bounded by the digest's maxError parameter. This is a
+  /// right-continous step function, i.e., values in between entries
+  /// have the same estimated cumulative probability as the
+  /// previous entry.
+  const std::vector<
+      CdfEntry,
+      typename std::allocator_traits<Allocator>::template rebind_alloc<
+          CdfEntry>>
+  getDistributionFunction(T rangeStart, T rangeEnd) const;
+
+  struct ValueCountPair {
+    T value;
+    double count;
+  };
+
+  /// Get values and their counts within the specified quantile bounds.
+  /// Returns a vector of (value, count) pairs for all nodes that fall
+  /// within the [lowerQuantileBound, upperQuantileBound] range.
+  /// This allows UDFs to compute various statistics (mean, median, stddev,
+  /// etc.) from the same underlying data.
+  ///
+  /// Example: For data [1, 10, 11, 12, 100] with bounds [0.25, 0.75], this
+  /// returns the values and counts for the middle quantile range,
+  /// excluding the outliers (1, 100).
+  std::vector<
+      ValueCountPair,
+      typename std::allocator_traits<Allocator>::template rebind_alloc<
+          ValueCountPair>>
+  getValuesInQuantileRange(double lowerQuantileBound, double upperQuantileBound)
+      const;
+
  private:
   using U = std::conditional_t<sizeof(T) == sizeof(int64_t), int64_t, int32_t>;
 
@@ -134,7 +184,7 @@ class QuantileDigest {
       int32_t node,
       Func callback,
       const std::vector<int32_t, RebindAlloc<int32_t>>& firstChildren,
-      const std::vector<int32_t, RebindAlloc<int32_t>>& secondChildren) {
+      const std::vector<int32_t, RebindAlloc<int32_t>>& secondChildren) const {
     if (node == -1) {
       return false;
     } else {
@@ -217,6 +267,8 @@ class QuantileDigest {
 
   U upperBound(int32_t node) const;
 
+  bool validateDigest() const;
+
   double maxError_;
   double weightedCount_;
   U min_;
@@ -426,6 +478,16 @@ QuantileDigest<T, Allocator>::QuantileDigest(
   root_ = nodeCount - 1;
 }
 
+template <typename T, typename Allocator>
+void QuantileDigest<T, Allocator>::setMaxError(double maxError) {
+  maxError_ = maxError;
+}
+
+template <typename T, typename Allocator>
+double QuantileDigest<T, Allocator>::getMaxError() const {
+  return maxError_;
+}
+
 template <typename T, typename Allocator>
 int32_t QuantileDigest<T, Allocator>::calculateHeight(int32_t nodeCount) {
   int32_t height;
@@ -486,7 +548,7 @@ double QuantileDigest<T, Allocator>::getCount() const {
 
 template <typename T, typename Allocator>
 void QuantileDigest<T, Allocator>::scale(double scaleFactor) {
-  VELOX_USER_CHECK(scaleFactor > 0.0, "scale factor must be > 0");
+  VELOX_USER_CHECK(scaleFactor > 0.0, "Scale factor should be positive.");
   for (auto i = 0; i < counts_.size(); ++i) {
     counts_[i] *= scaleFactor;
   }
@@ -525,6 +587,7 @@ T QuantileDigest<T, Allocator>::postprocessByType(U bits) const {
 
 template <typename T, typename Allocator>
 void QuantileDigest<T, Allocator>::add(T value, double weight) {
+  VELOX_DCHECK_NE(maxError_, kUninitializedMaxError);
   VELOX_USER_CHECK(weight > 0.0, "weight must be > 0");
   bool needsCompression{false};
   auto processedValue = preprocessByType(value);
@@ -536,7 +599,7 @@ void QuantileDigest<T, Allocator>::add(T value, double weight) {
 
   VELOX_USER_CHECK_LT(
       weightedCount_,
-      std::numeric_limits<int64_t>::max(),
+      kMaxDoubleBelowInt64Max,
       "Weighted count in digest is too large: {}",
       weightedCount_);
   if (needsCompression ||
@@ -700,6 +763,42 @@ void QuantileDigest<T, Allocator>::setChild(
   }
 }
 
+template <typename T, typename Allocator>
+bool QuantileDigest<T, Allocator>::validateDigest() const {
+  std::unordered_set<
+      int32_t,
+      std::hash<int32_t>,
+      std::equal_to<int32_t>,
+      RebindAlloc<int32_t>>
+      free(lefts_.get_allocator());
+  auto iterator = firstFree_;
+  while (iterator != -1) {
+    free.insert(iterator);
+    iterator = lefts_[iterator];
+  }
+  std::vector<bool, RebindAlloc<bool>> visited(
+      lefts_.size(), false, RebindAlloc<bool>(lefts_.get_allocator()));
+
+  // Check that visited nodes are not in the free list and are visited only
+  // once.
+  postOrderTraverse(
+      root_,
+      [&free, &visited](int32_t node) {
+        VELOX_CHECK_EQ(free.count(node), 0);
+        VELOX_CHECK_EQ(bool(visited[node]), false);
+        visited[node] = true;
+
+        return true;
+      },
+      lefts_,
+      rights_);
+  // Check that all nodes that are not in the free list are visited.
+  for (auto i = 0; i < visited.size(); ++i) {
+    VELOX_CHECK(visited[i] == true || free.count(i) == 1);
+  }
+  return true;
+}
+
 template <typename T, typename Allocator>
 void QuantileDigest<T, Allocator>::compress() {
   double bound = std::floor(
@@ -736,6 +835,7 @@ void QuantileDigest<T, Allocator>::compress() {
   if (root_ != -1 && counts_[root_] < qdigest::kZeroWeightThreshold) {
     root_ = tryRemove(root_);
   }
+  VELOX_DCHECK(validateDigest());
 }
 
 template <typename T, typename Allocator>
@@ -793,6 +893,11 @@ int32_t QuantileDigest<T, Allocator>::popFree() {
 template <typename T, typename Allocator>
 void QuantileDigest<T, Allocator>::testingMerge(
     const QuantileDigest<T, Allocator>& other) {
+  if (maxError_ == kUninitializedMaxError) {
+    maxError_ = other.getMaxError();
+  } else {
+    VELOX_CHECK_EQ(other.getMaxError(), maxError_);
+  }
   root_ = mergeRecursive(root_, other, other.root_);
   max_ = std::max(max_, other.max_);
   min_ = std::min(min_, other.min_);
@@ -808,7 +913,11 @@ void QuantileDigest<T, Allocator>::mergeSerialized(const char* other) {
   int32_t nodeCount;
   SerDe::readMetadata(other, version, maxError, min, max, nodeCount);
   VELOX_CHECK_EQ(version, 0);
-  VELOX_CHECK_EQ(maxError, maxError_);
+  if (maxError_ == kUninitializedMaxError) {
+    maxError_ = maxError;
+  } else {
+    VELOX_CHECK_EQ(maxError, maxError_);
+  }
 
   if (nodeCount == 0) {
     return;
@@ -821,6 +930,8 @@ void QuantileDigest<T, Allocator>::mergeSerialized(const char* other) {
   std::tie(root_, pos) = mergeSerializedRecursive(root_, other, other + size);
   max_ = std::max(max_, max);
   min_ = std::min(min_, min);
+  VELOX_DCHECK(validateDigest());
+
   compress();
 }
 
@@ -877,6 +988,8 @@ QuantileDigest<T, Allocator>::mergeSerializedRecursive(
       if (branch == 0) {
         if (hasRight) {
           std::tie(right, position) = copySerializedRecursive(start, position);
+        } else {
+          right = -1;
         }
         if (hasLeft) {
           std::tie(left, position) =
@@ -889,6 +1002,8 @@ QuantileDigest<T, Allocator>::mergeSerializedRecursive(
         }
         if (hasLeft) {
           std::tie(left, position) = copySerializedRecursive(start, position);
+        } else {
+          left = -1;
         }
       }
 
@@ -1050,7 +1165,7 @@ inline bool validateQuantiles(const std::vector<double>& quantiles) {
 template <typename T, typename Allocator>
 void QuantileDigest<T, Allocator>::estimateQuantiles(
     const std::vector<double>& quantiles,
-    T* result) {
+    T* result) const {
   VELOX_DCHECK(validateQuantiles(quantiles));
   int i = -1;
   double sum = 0.0;
@@ -1073,14 +1188,14 @@ void QuantileDigest<T, Allocator>::estimateQuantiles(
 }
 
 template <typename T, typename Allocator>
-T QuantileDigest<T, Allocator>::estimateQuantile(double quantile) {
+T QuantileDigest<T, Allocator>::estimateQuantile(double quantile) const {
   T result;
   estimateQuantiles({quantile}, &result);
   return result;
 }
 
 template <typename T, typename Allocator>
-T QuantileDigest<T, Allocator>::getMin() {
+T QuantileDigest<T, Allocator>::getMin() const {
   T result = std::numeric_limits<T>::min();
   postOrderTraverse(
       root_,
@@ -1098,7 +1213,7 @@ T QuantileDigest<T, Allocator>::getMin() {
 }
 
 template <typename T, typename Allocator>
-T QuantileDigest<T, Allocator>::getMax() {
+T QuantileDigest<T, Allocator>::getMax() const {
   T result = std::numeric_limits<T>::max();
   postOrderTraverse(
       root_,
@@ -1165,6 +1280,7 @@ int64_t QuantileDigest<T, Allocator>::serializedByteSize() const {
 
 template <typename T, typename Allocator>
 int64_t QuantileDigest<T, Allocator>::serialize(char* out) {
+  VELOX_DCHECK(validateDigest());
   compress();
   const char* outStart = out;
   SerDe::writeMetadata(
@@ -1194,6 +1310,144 @@ int64_t QuantileDigest<T, Allocator>::serialize(char* out) {
   return out - outStart;
 }
 
+template <typename T, typename Allocator>
+std::optional<double> QuantileDigest<T, Allocator>::quantileAtValue(
+    T value) const {
+  if (weightedCount_ == 0 || root_ == -1) {
+    return std::nullopt;
+  }
+
+  auto sortableValue = preprocessByType(value);
+  if (sortableValue > preprocessByType(getMax()) ||
+      sortableValue < preprocessByType(getMin())) {
+    return std::nullopt;
+  }
+
+  double bucketCount = 0.0;
+  postOrderTraverse(
+      root_,
+      [this, sortableValue, &bucketCount](int32_t node) {
+        if (upperBound(node) >= sortableValue) {
+          return false;
+        }
+        bucketCount += counts_[node];
+        return true;
+      },
+      lefts_,
+      rights_);
+  return bucketCount / weightedCount_;
+}
+
+template <typename T, typename Allocator>
+const std::vector<
+    typename QuantileDigest<T, Allocator>::CdfEntry,
+    typename QuantileDigest<T, Allocator>::template RebindAlloc<
+        typename QuantileDigest<T, Allocator>::CdfEntry>>
+QuantileDigest<T, Allocator>::getDistributionFunction(T rangeStart, T rangeEnd)
+    const {
+  std::vector<CdfEntry, RebindAlloc<CdfEntry>> cdf(
+      RebindAlloc<CdfEntry>(counts_.get_allocator()));
+
+  if (weightedCount_ == 0 || root_ == -1) {
+    return cdf;
+  }
+
+  VELOX_USER_CHECK_LE(
+      rangeStart,
+      rangeEnd,
+      "rangeStart must be less than or equal to rangeEnd");
+
+  // Always start with (rangeStart, 0) as the starting point.
+  cdf.push_back({rangeStart, 0.0});
+
+  // Build CDF during post-order traversal.
+  double cumulativeProbability = 0.0;
+  postOrderTraverse(
+      root_,
+      [this, &cdf, &cumulativeProbability, rangeStart, rangeEnd](int32_t node) {
+        if (counts_[node] > 0) {
+          T nodeUpper = postprocessByType(this->upperBound(node));
+          cumulativeProbability += counts_[node] / weightedCount_;
+          // Only include values within the specified range.
+          if (nodeUpper >= rangeEnd) {
+            return false;
+          } else if (nodeUpper >= rangeStart) {
+            // Take the largest probability for the same upperBound.
+            if (nodeUpper == cdf.back().upperBound) {
+              cdf.back().cumulativeProbability = cumulativeProbability;
+            } else {
+              cdf.push_back({nodeUpper, cumulativeProbability});
+            }
+          }
+        }
+        return true;
+      },
+      lefts_,
+      rights_);
+
+  // Always end with (rangeEnd, 1) as the endpoint.
+  cdf.push_back({rangeEnd, 1.0});
+
+  return cdf;
+}
+
+template <typename T, typename Allocator>
+std::vector<
+    typename QuantileDigest<T, Allocator>::ValueCountPair,
+    typename QuantileDigest<T, Allocator>::template RebindAlloc<
+        typename QuantileDigest<T, Allocator>::ValueCountPair>>
+QuantileDigest<T, Allocator>::getValuesInQuantileRange(
+    double lowerQuantileBound,
+    double upperQuantileBound) const {
+  std::vector<ValueCountPair, RebindAlloc<ValueCountPair>> result(
+      RebindAlloc<ValueCountPair>(counts_.get_allocator()));
+
+  VELOX_USER_CHECK(
+      0 <= lowerQuantileBound && lowerQuantileBound <= 1,
+      "lowerQuantileBound must be between 0 and 1");
+  VELOX_USER_CHECK(
+      0 <= upperQuantileBound && upperQuantileBound <= 1,
+      "upperQuantileBound must be between 0 and 1");
+
+  if (weightedCount_ == 0 || lowerQuantileBound >= upperQuantileBound) {
+    return result;
+  }
+
+  double lowerRank = lowerQuantileBound * weightedCount_;
+  double upperRank = upperQuantileBound * weightedCount_;
+  double sum = 0.0;
+
+  postOrderTraverse(
+      root_,
+      [this, &result, &sum, lowerRank, upperRank](int32_t node) {
+        double nodeCount = counts_[node];
+        if (nodeCount == 0) {
+          return true;
+        }
+
+        double previous = sum;
+        sum += nodeCount;
+
+        // Calculate what portion of this node falls within [lowerRank,
+        // upperRank]
+        double startInRange = std::max(previous, lowerRank);
+        double endInRange = std::min(sum, upperRank);
+        double countInRange = std::max(0.0, endInRange - startInRange);
+
+        // Only add if there's actually something in range
+        if (countInRange > 0) {
+          T value = postprocessByType(std::min(upperBound(node), max_));
+          result.push_back({value, countInRange});
+        }
+
+        return sum < upperRank;
+      },
+      lefts_,
+      rights_);
+
+  return result;
+}
+
 } // namespace qdigest
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Re2Functions.cpp b/velox/functions/lib/Re2Functions.cpp
index 3113131138b5..2407a4e06edf 100644
--- a/velox/functions/lib/Re2Functions.cpp
+++ b/velox/functions/lib/Re2Functions.cpp
@@ -36,7 +36,7 @@ re2::StringPiece toStringPiece(const T& s) {
 namespace detail {
 
 Expected<RE2*> ReCache::tryFindOrCompile(const StringView& pattern) {
-  const std::string key = pattern;
+  const auto key = std::string(pattern);
 
   auto reIt = cache_.find(key);
   if (reIt != cache_.end()) {
@@ -106,7 +106,7 @@ FlatVector<StringView>& ensureWritableStringView(
     VectorPtr& result) {
   context.ensureWritable(rows, VARCHAR(), result);
   auto* flat = result->as<FlatVector<StringView>>();
-  flat->mutableValues(rows.end());
+  flat->mutableValues();
   return *flat;
 }
 
@@ -870,8 +870,9 @@ class LikeWithRe2 final : public exec::VectorFunction {
     VELOX_CHECK(args.size() == 2 || args.size() == 3);
 
     if (!validPattern_) {
-      auto error = std::make_exception_ptr(std::invalid_argument(
-          "Escape character must be followed by '%', '_' or the escape character itself"));
+      auto error = std::make_exception_ptr(
+          std::invalid_argument(
+              "Escape character must be followed by '%', '_' or the escape character itself"));
       context.setErrors(rows, error);
       return;
     }
@@ -1258,10 +1259,13 @@ std::shared_ptr<exec::VectorFunction> makeRe2MatchImpl(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config) {
-  if (inputArgs.size() != 2 || !inputArgs[0].type->isVarchar() ||
-      !inputArgs[1].type->isVarchar()) {
+  if (inputArgs.size() != 2 ||
+      (!inputArgs[0].type->isVarchar() &&
+       inputArgs[0].type->kind() != TypeKind::UNKNOWN) ||
+      (!inputArgs[1].type->isVarchar() &&
+       inputArgs[1].type->kind() != TypeKind::UNKNOWN)) {
     VELOX_UNSUPPORTED(
-        "{} expected (VARCHAR, VARCHAR) but got ({})",
+        "{} expected (VARCHAR, VARCHAR) or (VARCHAR, UNKNOWN) but got ({})",
         name,
         printTypesCsv(inputArgs));
   }
@@ -1670,11 +1674,27 @@ std::shared_ptr<exec::VectorFunction> makeRe2Search(
 
 std::vector<std::shared_ptr<exec::FunctionSignature>> re2SearchSignatures() {
   // varchar, varchar -> boolean
-  return {exec::FunctionSignatureBuilder()
-              .returnType("boolean")
-              .argumentType("varchar")
-              .argumentType("varchar")
-              .build()};
+  return {
+      exec::FunctionSignatureBuilder()
+          .returnType("boolean")
+          .argumentType("varchar")
+          .argumentType("varchar")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("boolean")
+          .argumentType("varchar")
+          .argumentType("unknown")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("boolean")
+          .argumentType("unknown")
+          .argumentType("varchar")
+          .build(),
+      exec::FunctionSignatureBuilder()
+          .returnType("boolean")
+          .argumentType("unknown")
+          .argumentType("unknown")
+          .build()};
 }
 
 std::shared_ptr<exec::VectorFunction> makeRe2Extract(
@@ -1709,7 +1729,7 @@ std::shared_ptr<exec::VectorFunction> makeRe2Extract(
             groupIdTypeKind == TypeKind::BIGINT,
         "{} requires third argument of type INTEGER or BIGINT, but got {}",
         name,
-        mapTypeKindToName(groupIdTypeKind));
+        TypeKindName::toName(groupIdTypeKind));
   }
 
   BaseVector* constantPattern = inputArgs[1].constantValue.get();
@@ -2141,16 +2161,18 @@ PatternMetadata determinePatternKind(
           return PatternMetadata::prefix(
               std::string(unescapedPattern, 0, firstSubPatternLength));
         } else if (lastSubPatternKind == SubPatternKind::kLiteralString) {
-          return PatternMetadata::suffix(std::string(
-              unescapedPattern, lastSubPatternStart, lastSubPatternLength));
+          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));
+          return PatternMetadata::substring(
+              std::string(
+                  unescapedPattern,
+                  subPatternRanges[1].first,
+                  subPatternRanges[1].second));
         }
       }
 
@@ -2360,7 +2382,7 @@ std::shared_ptr<exec::VectorFunction> makeRe2ExtractAll(
             groupIdTypeKind == TypeKind::BIGINT,
         "{} requires third argument of type INTEGER or BIGINT, but got {}",
         name,
-        mapTypeKindToName(groupIdTypeKind));
+        TypeKindName::toName(groupIdTypeKind));
   }
 
   BaseVector* constantPattern = inputArgs[1].constantValue.get();
diff --git a/velox/functions/lib/Re2Functions.h b/velox/functions/lib/Re2Functions.h
index c1447c947fce..ad9d8d64cd68 100644
--- a/velox/functions/lib/Re2Functions.h
+++ b/velox/functions/lib/Re2Functions.h
@@ -384,61 +384,6 @@ struct Re2RegexpReplace {
   std::string result_;
 };
 
-template <typename TExec>
-struct Re2RegexpSplit {
-  Re2RegexpSplit() : cache_(0) {}
-
-  VELOX_DEFINE_FUNCTION_TYPES(TExec);
-
-  FOLLY_ALWAYS_INLINE void initialize(
-      const std::vector<TypePtr>& /*inputTypes*/,
-      const core::QueryConfig& config,
-      const arg_type<Varchar>* /*string*/,
-      const arg_type<Varchar>* /*pattern*/) {
-    cache_.setMaxCompiledRegexes(config.exprMaxCompiledRegexes());
-  }
-
-  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,
diff --git a/velox/functions/lib/RegistrationHelpers.h b/velox/functions/lib/RegistrationHelpers.h
index 3b7f55c55b7b..fb783e4de105 100644
--- a/velox/functions/lib/RegistrationHelpers.h
+++ b/velox/functions/lib/RegistrationHelpers.h
@@ -28,6 +28,15 @@ void registerBinaryIntegral(const std::vector<std::string>& aliases) {
   registerFunction<T, int64_t, int64_t, int64_t>(aliases);
 }
 
+template <template <class> class T, typename TReturn>
+void registerBinaryIntegralWithTReturn(
+    const std::vector<std::string>& aliases) {
+  registerFunction<T, TReturn, int8_t, int8_t>(aliases);
+  registerFunction<T, TReturn, int16_t, int16_t>(aliases);
+  registerFunction<T, TReturn, int32_t, int32_t>(aliases);
+  registerFunction<T, TReturn, int64_t, int64_t>(aliases);
+}
+
 template <template <class> typename T>
 void registerBinaryFloatingPoint(const std::vector<std::string>& aliases) {
   registerFunction<T, double, double, double>(aliases);
@@ -42,10 +51,7 @@ void registerBinaryNumeric(const std::vector<std::string>& aliases) {
 
 template <template <class> class T, typename TReturn>
 void registerBinaryScalar(const std::vector<std::string>& aliases) {
-  registerFunction<T, TReturn, int8_t, int8_t>(aliases);
-  registerFunction<T, TReturn, int16_t, int16_t>(aliases);
-  registerFunction<T, TReturn, int32_t, int32_t>(aliases);
-  registerFunction<T, TReturn, int64_t, int64_t>(aliases);
+  registerBinaryIntegralWithTReturn<T, TReturn>(aliases);
   registerFunction<T, TReturn, double, double>(aliases);
   registerFunction<T, TReturn, float, float>(aliases);
   registerFunction<T, TReturn, Varchar, Varchar>(aliases);
@@ -77,6 +83,13 @@ void registerUnaryFloatingPoint(const std::vector<std::string>& aliases) {
   registerFunction<T, float, float>(aliases);
 }
 
+template <template <class> class T, typename TReturn>
+void registerUnaryFloatingPointWithTReturn(
+    const std::vector<std::string>& aliases) {
+  registerFunction<T, TReturn, double>(aliases);
+  registerFunction<T, TReturn, float>(aliases);
+}
+
 template <template <class> class T>
 void registerUnaryNumeric(const std::vector<std::string>& aliases) {
   registerUnaryIntegral<T>(aliases);
diff --git a/velox/functions/lib/SIMDComparisonUtil.h b/velox/functions/lib/SIMDComparisonUtil.h
index a27b51f192bf..c205fb1a6ad0 100644
--- a/velox/functions/lib/SIMDComparisonUtil.h
+++ b/velox/functions/lib/SIMDComparisonUtil.h
@@ -39,28 +39,38 @@ inline uint64_t to64Bits(const int8_t* resultData) {
       "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))));
+    res = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData)) != 0));
   } 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) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData)) != 0));
     *(addr + 1) = simd::toBitMask(
-        xsimd::batch_bool<int8_t>(simd::reinterpretBatch<uint8_t>(
-            d_type::load_unaligned(resultData + 32))));
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData + 32)) != 0));
   } 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) = simd::toBitMask(
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData)) != 0));
     *(addr + 1) = simd::toBitMask(
-        xsimd::batch_bool<int8_t>(simd::reinterpretBatch<uint8_t>(
-            d_type::load_unaligned(resultData + 16))));
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData + 16)) != 0));
     *(addr + 2) = simd::toBitMask(
-        xsimd::batch_bool<int8_t>(simd::reinterpretBatch<uint8_t>(
-            d_type::load_unaligned(resultData + 32))));
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData + 32)) != 0));
     *(addr + 3) = simd::toBitMask(
-        xsimd::batch_bool<int8_t>(simd::reinterpretBatch<uint8_t>(
-            d_type::load_unaligned(resultData + 48))));
+        xsimd::batch_bool<int8_t>(
+            simd::reinterpretBatch<uint8_t>(
+                d_type::load_unaligned(resultData + 48)) != 0));
   }
   return res;
 }
diff --git a/velox/functions/lib/SetDigest.h b/velox/functions/lib/SetDigest.h
new file mode 100644
index 000000000000..d13c9f081e71
--- /dev/null
+++ b/velox/functions/lib/SetDigest.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 "velox/common/base/Status.h"
+#include "velox/common/hyperloglog/HllAccumulator.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/type/StringView.h"
+
+#include <cstdint>
+#include <map>
+#include <type_traits>
+
+namespace facebook::velox::functions {
+
+/// SetDigest is a probabilistic data structure for estimating set cardinality
+/// and performing set operations. It combines HyperLogLog for cardinality
+/// estimation with MinHash for exact counting and intersection operations.
+///
+/// Template parameters:
+/// - T: The element type, which must be either int64_t or StringView.
+template <typename T>
+class SetDigest {
+  static_assert(
+      std::is_same_v<T, int64_t> || std::is_same_v<T, StringView>,
+      "SetDigest only supports int64_t or StringView");
+
+ public:
+  template <typename U>
+  using TStlAllocator = HashStringAllocator::TStlAllocator<U>;
+
+  static constexpr int32_t kDefaultMaxHashes = 8192;
+  static constexpr int32_t kNumberOfBuckets = 2048;
+  static constexpr int8_t kDefaultIndexBitLength = 11;
+
+  /// Construct a SetDigest with specified parameters.
+  /// @param allocator Memory allocator for internal data structures.
+  /// @param indexBitLength Number of bits for HLL indexing (default 11 = 2048
+  /// buckets). Must be in range (0, 16].
+  /// @param maxHashes Maximum number of hashes to store in MinHash (default
+  /// 8192). When exceeded, digest becomes approximate.
+  explicit SetDigest(
+      HashStringAllocator* allocator,
+      int8_t indexBitLength = kDefaultIndexBitLength,
+      int32_t maxHashes = kDefaultMaxHashes);
+
+  /// Add a new value to the digest.
+  /// @param value The value to add.
+  void add(T value);
+
+  /// Merge this digest with another digest.
+  /// @param other The other digest to merge into this one.
+  void mergeWith(const SetDigest& other);
+
+  /// Returns true if the digest is exact (cardinality < maxHashes).
+  /// When exact, cardinality() returns the exact count.
+  /// Used in exactIntersectionCardinality().
+  bool isExact() const;
+
+  /// Returns the estimated cardinality of the set.
+  /// If isExact() is true, returns the exact count.
+  /// Otherwise, returns HyperLogLog estimate.
+  int64_t cardinality() const;
+
+  /// Calculate the exact intersection cardinality between two digests.
+  /// Both digests must be exact (isExact() == true).
+  /// @param left First digest (must be exact).
+  /// @param right Second digest (must be exact).
+  /// @return The exact number of elements in the intersection.
+  static int64_t exactIntersectionCardinality(
+      const SetDigest& left,
+      const SetDigest& right);
+
+  /// Compute the Jaccard index (similarity coefficient) between two digests.
+  /// Uses MinHash estimation. Returns a value in [0, 1] where 1 means
+  /// identical sets and 0 means disjoint sets.
+  /// @param left First digest.
+  /// @param right Second digest.
+  /// @return Estimated Jaccard index.
+  static double jaccardIndex(const SetDigest& left, const SetDigest& right);
+
+  /// Calculate the size needed for serialization.
+  /// @return The number of bytes needed to serialize this digest.
+  int32_t estimatedSerializedSize() const;
+
+  /// Serialize the digest into bytes. The serialization is versioned and
+  /// compatible with Presto Java.
+  /// @param out Pre-allocated memory at least estimatedSerializedSize() in
+  /// size.
+  void serialize(char* out) const;
+
+  /// Deserialize a SetDigest from serialized input.
+  /// Serialization produced by Presto Java can be used as input.
+  /// @param data The input serialization.
+  /// @param size The size of the serialization in bytes.
+  /// @return Status::OK() on success, or an error Status on failure.
+  Status deserialize(const char* data, int32_t size);
+
+  /// Get a copy of the MinHash hash counts.
+  /// Returns a map from hash value to count.
+  /// @return A map of hash values to their counts.
+  std::map<int64_t, int16_t> getHashCounts() const;
+
+ private:
+  void addHash(uint64_t hash);
+
+  void increaseTotalHllSize();
+  void decreaseTotalHllSize();
+
+  using MinHashAllocator = TStlAllocator<std::pair<const int64_t, int16_t>>;
+  std::map<int64_t, int16_t, std::less<int64_t>, MinHashAllocator> minhash_;
+
+  common::hll::HllAccumulator<int64_t, true, HashStringAllocator>
+      hllAccumulator_;
+  int32_t maxHashes_{kDefaultMaxHashes};
+  HashStringAllocator* allocator_;
+
+  /// Tracks the HLL serialized size, updated when HLL changes.
+  int32_t hllTotalEstimatedSerializedSize_{0};
+};
+
+} // namespace facebook::velox::functions
+
+#include "velox/functions/lib/SetDigestImpl.h"
diff --git a/velox/functions/lib/SetDigestImpl.h b/velox/functions/lib/SetDigestImpl.h
new file mode 100644
index 000000000000..82c4e07e354f
--- /dev/null
+++ b/velox/functions/lib/SetDigestImpl.h
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/Exceptions.h"
+#include "velox/common/base/IOUtils.h"
+#include "velox/common/hyperloglog/Murmur3Hash128.h"
+
+#include <limits>
+#include <vector>
+
+namespace facebook::velox::functions {
+
+namespace detail {
+constexpr int8_t kUncompressedFormat = 1;
+
+inline uint64_t computeHash(int64_t value) {
+  return common::hll::Murmur3Hash128::hash64ForLong(value, 0);
+}
+
+inline uint64_t computeHash(StringView value) {
+  return common::hll::Murmur3Hash128::hash64(value.data(), value.size(), 0);
+}
+} // namespace detail
+
+template <typename T>
+SetDigest<T>::SetDigest(
+    HashStringAllocator* allocator,
+    int8_t indexBitLength,
+    int32_t maxHashes)
+    : minhash_{MinHashAllocator(allocator)},
+      hllAccumulator_{indexBitLength, allocator},
+      maxHashes_{maxHashes},
+      allocator_{allocator},
+      hllTotalEstimatedSerializedSize_{0} {
+  // Validate indexBitLength matches Java validation
+  VELOX_CHECK_GT(indexBitLength, 0, "indexBitLength must be > 0");
+  VELOX_CHECK_LE(indexBitLength, 16, "indexBitLength must be <= 16");
+
+  // Validate maxHashes
+  VELOX_CHECK_GT(maxHashes, 0, "maxHashes must be > 0");
+
+  // Verify default indexBitLength matches kNumberOfBuckets
+  static_assert(
+      (1 << SetDigest<T>::kDefaultIndexBitLength) ==
+          SetDigest<T>::kNumberOfBuckets,
+      "Default index bit length must match NUMBER_OF_BUCKETS");
+
+  // Initialize HLL size after HLL is constructed
+  increaseTotalHllSize();
+}
+
+template <typename T>
+bool SetDigest<T>::isExact() const {
+  return static_cast<int32_t>(minhash_.size()) < maxHashes_;
+}
+
+template <typename T>
+void SetDigest<T>::add(T value) {
+  uint64_t hash = detail::computeHash(value);
+  addHash(hash);
+  decreaseTotalHllSize();
+  hllAccumulator_.insertHash(hash);
+  increaseTotalHllSize();
+}
+
+template <typename T>
+void SetDigest<T>::addHash(uint64_t hash) {
+  int64_t signedHash = static_cast<int64_t>(hash);
+  auto it = minhash_.find(signedHash);
+  int16_t currentCount = (it != minhash_.end()) ? it->second : 0;
+
+  if (currentCount < std::numeric_limits<int16_t>::max()) {
+    minhash_[signedHash] = static_cast<int16_t>(currentCount + 1);
+  }
+
+  while (static_cast<int32_t>(minhash_.size()) > maxHashes_) {
+    minhash_.erase(std::prev(minhash_.end()));
+  }
+}
+
+template <typename T>
+inline void SetDigest<T>::increaseTotalHllSize() {
+  hllTotalEstimatedSerializedSize_ += hllAccumulator_.serializedSize();
+}
+
+template <typename T>
+inline void SetDigest<T>::decreaseTotalHllSize() {
+  hllTotalEstimatedSerializedSize_ -= hllAccumulator_.serializedSize();
+}
+
+template <typename T>
+int32_t SetDigest<T>::estimatedSerializedSize() const {
+  return static_cast<int32_t>(
+      sizeof(int8_t) + // format byte
+      sizeof(int32_t) + // HLL length
+      hllTotalEstimatedSerializedSize_ + // HLL data
+      sizeof(int32_t) + // maxHashes
+      sizeof(int32_t) + // minhash size
+      minhash_.size() * (sizeof(int64_t) + sizeof(int16_t))); // keys + values
+}
+
+template <typename T>
+void SetDigest<T>::serialize(char* out) const {
+  common::OutputByteStream stream(out);
+
+  stream.appendOne(detail::kUncompressedFormat);
+  stream.appendOne(hllTotalEstimatedSerializedSize_);
+
+  // Use const_cast because HllAccumulator::serialize() is not const,
+  // but serialization does not logically modify the object.
+  const_cast<common::hll::HllAccumulator<int64_t, true, HashStringAllocator>&>(
+      hllAccumulator_)
+      .serialize(out + stream.offset());
+  stream = common::OutputByteStream(
+      out, stream.offset() + hllTotalEstimatedSerializedSize_);
+
+  stream.appendOne(maxHashes_);
+  stream.appendOne(static_cast<int32_t>(minhash_.size()));
+
+  for (const auto& entry : minhash_) {
+    stream.appendOne(entry.first);
+  }
+
+  for (const auto& entry : minhash_) {
+    stream.appendOne(entry.second);
+  }
+
+  VELOX_CHECK_EQ(stream.offset(), estimatedSerializedSize());
+}
+
+template <typename T>
+Status SetDigest<T>::deserialize(const char* data, int32_t size) {
+  if (size < static_cast<int32_t>(sizeof(int8_t) + sizeof(int32_t))) {
+    return Status::UserError("Input too small to be a valid SetDigest");
+  }
+
+  common::InputByteStream stream(data);
+
+  int8_t format = stream.read<int8_t>();
+  if (format != detail::kUncompressedFormat) {
+    return Status::UserError(
+        "Unexpected SetDigest format: expected {}, got {}",
+        detail::kUncompressedFormat,
+        format);
+  }
+
+  // Read HLL length
+  int32_t hllLength = stream.read<int32_t>();
+  if (hllLength < 0) {
+    return Status::UserError("Invalid HLL length in SetDigest serialization");
+  }
+  if (hllLength >
+      size - static_cast<int32_t>(sizeof(int8_t) + sizeof(int32_t))) {
+    return Status::UserError("HLL length exceeds input size");
+  }
+
+  // Deserialize HLL using HllAccumulator
+  auto deserializedHll =
+      common::hll::HllAccumulator<int64_t, true, HashStringAllocator>::
+          deserialize(data + stream.offset(), allocator_);
+  decreaseTotalHllSize();
+  hllAccumulator_ = std::move(*deserializedHll);
+  increaseTotalHllSize();
+
+  stream = common::InputByteStream(data + stream.offset() + hllLength);
+
+  // Calculate remaining bytes after HLL data
+  int32_t bytesConsumed = sizeof(int8_t) + sizeof(int32_t) + hllLength;
+  int32_t remainingBytes = size - bytesConsumed;
+
+  if (remainingBytes < static_cast<int32_t>(2 * sizeof(int32_t))) {
+    return Status::UserError(
+        "Input too small to contain maxHashes and minhash size");
+  }
+
+  maxHashes_ = stream.read<int32_t>();
+  if (maxHashes_ <= 0) {
+    return Status::UserError("maxHashes must be > 0");
+  }
+
+  int32_t minhashSize = stream.read<int32_t>();
+  if (minhashSize < 0) {
+    return Status::UserError("minhash size cannot be negative");
+  }
+
+  // Validate that there's enough data for the minhash entries
+  int32_t expectedMinhashBytes =
+      minhashSize * (sizeof(int64_t) + sizeof(int16_t));
+  if (remainingBytes - 2 * static_cast<int32_t>(sizeof(int32_t)) <
+      expectedMinhashBytes) {
+    return Status::UserError("Input too small to contain minhash entries");
+  }
+
+  std::vector<int64_t> keys;
+  keys.reserve(minhashSize);
+  for (int32_t i = 0; i < minhashSize; i++) {
+    keys.push_back(stream.read<int64_t>());
+  }
+
+  for (int32_t i = 0; i < minhashSize; i++) {
+    int16_t count = stream.read<int16_t>();
+    minhash_[keys[i]] = count;
+  }
+
+  return Status::OK();
+}
+
+template <typename T>
+void SetDigest<T>::mergeWith(const SetDigest& other) {
+  // Merge HyperLogLog using HllAccumulator
+  decreaseTotalHllSize();
+  hllAccumulator_.mergeWith(other.hllAccumulator_);
+  increaseTotalHllSize();
+
+  // Merge minhash maps
+  for (const auto& entry : other.minhash_) {
+    int64_t key = entry.first;
+    int16_t otherCount = entry.second;
+
+    auto it = minhash_.find(key);
+    int16_t currentCount = (it != minhash_.end()) ? it->second : 0;
+
+    // Add counts, saturating at int16_t max
+    int32_t newCount =
+        static_cast<int32_t>(currentCount) + static_cast<int32_t>(otherCount);
+    if (newCount > std::numeric_limits<int16_t>::max()) {
+      minhash_[key] = std::numeric_limits<int16_t>::max();
+    } else {
+      minhash_[key] = static_cast<int16_t>(newCount);
+    }
+  }
+
+  // Remove largest hash values when we exceed maxHashes
+  while (static_cast<int32_t>(minhash_.size()) > maxHashes_) {
+    minhash_.erase(std::prev(minhash_.end()));
+  }
+}
+
+template <typename T>
+int64_t SetDigest<T>::cardinality() const {
+  if (isExact()) {
+    return static_cast<int64_t>(minhash_.size());
+  }
+  return hllAccumulator_.cardinality();
+}
+
+template <typename T>
+int64_t SetDigest<T>::exactIntersectionCardinality(
+    const SetDigest& left,
+    const SetDigest& right) {
+  VELOX_USER_CHECK(
+      left.isExact(), "exact intersection cannot operate on approximate sets");
+  VELOX_USER_CHECK(
+      right.isExact(), "exact intersection cannot operate on approximate sets");
+
+  const auto& [smaller, larger] = left.minhash_.size() <= right.minhash_.size()
+      ? std::tie(left, right)
+      : std::tie(right, left);
+
+  int64_t count = 0;
+  for (const auto& entry : smaller.minhash_) {
+    if (larger.minhash_.count(entry.first)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+template <typename T>
+double SetDigest<T>::jaccardIndex(
+    const SetDigest& left,
+    const SetDigest& right) {
+  if (left.minhash_.empty() && right.minhash_.empty()) {
+    return 1.0;
+  }
+
+  int32_t sizeOfSmallerSet = std::min(
+      static_cast<int32_t>(left.minhash_.size()),
+      static_cast<int32_t>(right.minhash_.size()));
+
+  if (sizeOfSmallerSet == 0) {
+    return 0.0;
+  }
+
+  auto itLeft = left.minhash_.begin();
+  auto itRight = right.minhash_.begin();
+
+  int32_t intersectionCnt = 0;
+  int32_t unionCnt = 0;
+
+  while (itLeft != left.minhash_.end() && itRight != right.minhash_.end() &&
+         unionCnt < sizeOfSmallerSet) {
+    if (itLeft->first < itRight->first) {
+      ++itLeft;
+    } else if (itRight->first < itLeft->first) {
+      ++itRight;
+    } else {
+      intersectionCnt++;
+      ++itLeft;
+      ++itRight;
+    }
+    unionCnt++;
+  }
+
+  return static_cast<double>(intersectionCnt) /
+      static_cast<double>(sizeOfSmallerSet);
+}
+
+template <typename T>
+std::map<int64_t, int16_t> SetDigest<T>::getHashCounts() const {
+  std::map<int64_t, int16_t> result;
+  for (const auto& entry : minhash_) {
+    result[entry.first] = entry.second;
+  }
+  return result;
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/SimpleComparisonMatcher.cpp b/velox/functions/lib/SimpleComparisonMatcher.cpp
new file mode 100644
index 000000000000..0dc6cab335ca
--- /dev/null
+++ b/velox/functions/lib/SimpleComparisonMatcher.cpp
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/SimpleComparisonMatcher.h"
+#include "velox/expression/ExprConstants.h"
+
+namespace facebook::velox::functions {
+
+bool Matcher::allMatch(
+    const std::vector<core::TypedExprPtr>& exprs,
+    std::vector<std::shared_ptr<Matcher>>& matchers) {
+  for (auto i = 0; i < exprs.size(); ++i) {
+    if (!matchers[i]->match(exprs[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IfMatcher::match(const core::TypedExprPtr& expr) {
+  if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
+    if (call->name() == expression::kIf &&
+        allMatch(call->inputs(), inputMatchers_)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ComparisonMatcher::match(const core::TypedExprPtr& expr) {
+  if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
+    const auto& name = call->name();
+    if (exprNameMatch(name)) {
+      if (allMatch(call->inputs(), inputMatchers_)) {
+        *op_ = name;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+bool AnySingleInputMatcher::match(const core::TypedExprPtr& expr) {
+  // Check if 'expr' depends on a single column.
+  std::unordered_set<core::FieldAccessTypedExprPtr> inputs;
+  collectInputs(expr, inputs);
+
+  if (inputs.size() == 1) {
+    *expr_ = expr;
+    *input_ = *inputs.begin();
+    return true;
+  }
+
+  return false;
+}
+
+void AnySingleInputMatcher::collectInputs(
+    const core::TypedExprPtr& expr,
+    std::unordered_set<core::FieldAccessTypedExprPtr>& inputs) {
+  if (auto field =
+          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(expr)) {
+    if (field->isInputColumn()) {
+      inputs.insert(field);
+      return;
+    }
+  }
+
+  for (const auto& input : expr->inputs()) {
+    collectInputs(input, inputs);
+  }
+}
+
+bool ComparisonConstantMatcher::match(const core::TypedExprPtr& expr) {
+  if (auto constant = asConstant(expr.get())) {
+    auto v = constant.value();
+    if (v == 0 || v == 1 || v == -1) {
+      *value_ = v;
+      return true;
+    }
+  }
+  return false;
+}
+
+std::optional<int64_t> ComparisonConstantMatcher::asConstant(
+    const core::ITypedExpr* expr) {
+  if (auto constant = dynamic_cast<const core::ConstantTypedExpr*>(expr)) {
+    if (constant->hasValueVector()) {
+      auto constantVector =
+          constant->valueVector()->as<SimpleVector<int64_t>>();
+      if (!constantVector->isNullAt(0)) {
+        return constantVector->valueAt(0);
+      }
+    } else {
+      if (!constant->value().isNull()) {
+        if (constant->value().kind() == TypeKind::BIGINT) {
+          return constant->value().value<int64_t>();
+        }
+
+        if (constant->value().kind() == TypeKind::INTEGER) {
+          return constant->value().value<int32_t>();
+        }
+      }
+    }
+  }
+
+  return std::nullopt;
+}
+
+bool SimpleComparisonChecker::isLessThen(
+    const std::string& prefix,
+    const std::string& operation,
+    const core::FieldAccessTypedExprPtr& left,
+    int64_t result,
+    const std::string& inputLeft) {
+  std::string op =
+      (left->name() == inputLeft) ? operation : invert(prefix, operation);
+
+  if (op == ltName(prefix)) {
+    return result < 0;
+  }
+
+  return result > 0;
+}
+
+std::optional<SimpleComparison> SimpleComparisonChecker::isSimpleComparison(
+    const std::string& prefix,
+    const core::LambdaTypedExpr& expr) {
+  // First, check the shape of the expression.
+  // if (x(a) < y(b), c1, if (u(c) > v(d), c2, c3))
+  core::FieldAccessTypedExprPtr a, b, c, d;
+  core::TypedExprPtr x, y, u, v;
+  std::string op1, op2;
+  int64_t c1, c2, c3;
+
+  auto matcher = ifelse(
+      comparison(prefix, anySingleInput(&x, &a), anySingleInput(&y, &b), &op1),
+      comparisonConstant(&c1),
+      ifelse(
+          comparison(
+              prefix, anySingleInput(&u, &c), anySingleInput(&v, &d), &op2),
+          comparisonConstant(&c2),
+          comparisonConstant(&c3)));
+
+  if (!matcher->match(expr.body())) {
+    return std::nullopt;
+  }
+
+  // Verify that a != b, c != d.
+  if (a == b || c == d) {
+    return std::nullopt;
+  }
+
+  // Verify that x, y, u, v are the same (except for input column).
+  std::unordered_map<std::string, core::TypedExprPtr> inputMapping;
+  inputMapping.emplace(
+      a->name(),
+      std::make_shared<core::FieldAccessTypedExpr>(a->type(), b->name()));
+  const auto xRewritten = x->rewriteInputNames(inputMapping);
+  if (!(*xRewritten == *y->rewriteInputNames(inputMapping) &&
+        *xRewritten == *u->rewriteInputNames(inputMapping) &&
+        *xRewritten == *v->rewriteInputNames(inputMapping))) {
+    return std::nullopt;
+  }
+
+  // Verify all constants are different.
+  if (c1 == c2 || c2 == c3 || c1 == c3) {
+    return std::nullopt;
+  }
+
+  const auto eq = eqName(prefix);
+
+  // Verify that equality comparisons return zero.
+  // if (x(a) = y(a), 0,..) is good. if (x(a) = y(a), 1,..) is not good.
+  // Also, verify that non-equality comparisons return non-zero.
+  // if (x(a) < y(a), 1,..) is good. if (x(a) < y(a), 0,..) is not good.
+  if ((op1 == eq && c1 != 0) || (op1 != eq && c1 == 0)) {
+    return std::nullopt;
+  }
+
+  if ((op2 == eq && c2 != 0) || (op2 != eq && c2 == 0)) {
+    return std::nullopt;
+  }
+
+  const auto left = expr.signature()->nameOf(0);
+
+  const auto transform = a->name() == left ? x : y;
+
+  if (op1 == eq) {
+    // if (x(a) = y(b), 0,...)
+    return {{transform, isLessThen(prefix, op2, c, c2, left)}};
+  }
+
+  if (op2 == eq) {
+    return {{transform, isLessThen(prefix, op1, a, c1, left)}};
+  }
+
+  // Make sure op1 and op2 are aligned.
+  auto b1 = isLessThen(prefix, op1, a, c1, left);
+  auto b2 = isLessThen(prefix, op2, c, c2, left);
+  if (b1 != b2) {
+    return std::nullopt;
+  }
+
+  return {{transform, b1}};
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/SimpleComparisonMatcher.h b/velox/functions/lib/SimpleComparisonMatcher.h
new file mode 100644
index 000000000000..5113d1542b22
--- /dev/null
+++ b/velox/functions/lib/SimpleComparisonMatcher.h
@@ -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.
+ */
+#pragma once
+
+#include "velox/core/Expressions.h"
+#include "velox/vector/ConstantVector.h"
+
+namespace facebook::velox::functions {
+
+struct SimpleComparison {
+  core::TypedExprPtr expr;
+  bool isLessThen;
+};
+
+class Matcher {
+ public:
+  virtual bool match(const core::TypedExprPtr& expr) = 0;
+
+  virtual ~Matcher() = default;
+
+  // Checks if all expressions match the corresponding matchers.
+  static bool allMatch(
+      const std::vector<core::TypedExprPtr>& exprs,
+      std::vector<std::shared_ptr<Matcher>>& matchers);
+};
+
+// Matches the if expression that children match the given matchers.
+class IfMatcher : public Matcher {
+ public:
+  explicit IfMatcher(std::vector<std::shared_ptr<Matcher>> inputMatchers)
+      : inputMatchers_{std::move(inputMatchers)} {
+    VELOX_CHECK_EQ(3, inputMatchers_.size());
+  }
+
+  bool match(const core::TypedExprPtr& expr) override;
+
+ private:
+  std::vector<std::shared_ptr<Matcher>> inputMatchers_;
+};
+
+// Matches comparison expression that represents `eq`, `lt`, or `gt`.
+class ComparisonMatcher : public Matcher {
+ public:
+  ComparisonMatcher(
+      const std::string& prefix,
+      const std::vector<std::shared_ptr<Matcher>>& inputMatchers,
+      std::string* op)
+      : prefix_{prefix}, inputMatchers_{inputMatchers}, op_{op} {
+    VELOX_CHECK_EQ(2, inputMatchers_.size());
+  }
+
+  /// Checks if the given name specifies a comparison expression. Can be
+  /// overriden to use different function names for Spark.
+  virtual bool exprNameMatch(const std::string& name) {
+    return name == prefix_ + "eq" || name == prefix_ + "lt" ||
+        name == prefix_ + "gt";
+  }
+
+  bool match(const core::TypedExprPtr& expr) override;
+
+ protected:
+  const std::string prefix_;
+
+ private:
+  std::vector<std::shared_ptr<Matcher>> inputMatchers_;
+  std::string* op_;
+};
+
+class AnySingleInputMatcher : public Matcher {
+ public:
+  AnySingleInputMatcher(
+      core::TypedExprPtr* expr,
+      core::FieldAccessTypedExprPtr* input)
+      : expr_{expr}, input_{input} {}
+
+  bool match(const core::TypedExprPtr& expr) override;
+
+ private:
+  static void collectInputs(
+      const core::TypedExprPtr& expr,
+      std::unordered_set<core::FieldAccessTypedExprPtr>& inputs);
+
+  core::TypedExprPtr* const expr_;
+  core::FieldAccessTypedExprPtr* const input_;
+};
+
+/// Matches constant expression that represents values 1, 0, or -1 of type
+/// BIGINT.
+class ComparisonConstantMatcher : public Matcher {
+ public:
+  explicit ComparisonConstantMatcher(int64_t* value) : value_{value} {}
+
+  bool match(const core::TypedExprPtr& expr) override;
+
+ private:
+  static std::optional<int64_t> asConstant(const core::ITypedExpr* expr);
+
+  int64_t* const value_;
+};
+
+class SimpleComparisonChecker {
+ protected:
+  std::shared_ptr<Matcher> ifelse(
+      const std::shared_ptr<Matcher>& condition,
+      const std::shared_ptr<Matcher>& thenClause,
+      const std::shared_ptr<Matcher>& elseClause) {
+    return std::make_shared<IfMatcher>(std::vector<std::shared_ptr<Matcher>>{
+        condition, thenClause, elseClause});
+  }
+
+  std::shared_ptr<Matcher> anySingleInput(
+      core::TypedExprPtr* expr,
+      core::FieldAccessTypedExprPtr* input) {
+    return std::make_shared<AnySingleInputMatcher>(expr, input);
+  }
+
+  std::shared_ptr<Matcher> comparisonConstant(int64_t* value) {
+    return std::make_shared<ComparisonConstantMatcher>(value);
+  }
+
+  std::string invert(const std::string& prefix, const std::string& op) {
+    return op == ltName(prefix) ? gtName(prefix) : ltName(prefix);
+  }
+
+  // Returns true for a < b -> -1.
+  bool isLessThen(
+      const std::string& prefix,
+      const std::string& operation,
+      const core::FieldAccessTypedExprPtr& left,
+      int64_t result,
+      const std::string& inputLeft);
+
+  virtual std::shared_ptr<Matcher> comparison(
+      const std::string& prefix,
+      const std::shared_ptr<Matcher>& left,
+      const std::shared_ptr<Matcher>& right,
+      std::string* op) {
+    return std::make_shared<ComparisonMatcher>(
+        prefix, std::vector<std::shared_ptr<Matcher>>{left, right}, op);
+  }
+
+  virtual std::string eqName(const std::string& prefix) {
+    return prefix + "eq";
+  }
+
+  virtual std::string ltName(const std::string& prefix) {
+    return prefix + "lt";
+  }
+
+  virtual std::string gtName(const std::string& prefix) {
+    return prefix + "gt";
+  }
+
+ public:
+  virtual ~SimpleComparisonChecker() = default;
+
+  /// Given a lambda expression, checks it if represents a simple comparator and
+  /// returns the summary of the same.
+  ///
+  /// For example, identifies
+  ///     (x, y) -> if(length(x) < length(y), -1, if(length(x) > length(y), 1,
+  ///     0))
+  /// expression as a "less than" comparison over length(x).
+  ///
+  /// Recognizes different variations of this expression, e.g.
+  ///
+  ///     (x, y) -> if(expr(x) = expr(y), 0, if(expr(x) < expr(y), -1, 1))
+  ///     (x, y) -> if(expr(x) = expr(y), 0, if(expr(y) > expr(x), -1, 1))
+  ///
+  /// Returns std::nullopt if expression is not recognized as a simple
+  /// comparator.
+  ///
+  /// Can be used to re-write generic lambda expressions passed to array_sort
+  /// into simpler ones that can be evaluated more efficiently.
+  std::optional<SimpleComparison> isSimpleComparison(
+      const std::string& prefix,
+      const core::LambdaTypedExpr& expr);
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/Slice.cpp b/velox/functions/lib/Slice.cpp
index cfe75296e18f..52a66ca6794a 100644
--- a/velox/functions/lib/Slice.cpp
+++ b/velox/functions/lib/Slice.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "velox/functions/lib/Slice.h"
-#include "velox/expression/Expr.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
 
 namespace facebook::velox::functions {
@@ -54,7 +54,7 @@ class SliceFunction : public exec::VectorFunction {
     VELOX_CHECK(
         kind == TypeKind::BIGINT || kind == TypeKind::INTEGER,
         "Unsupported parameter type {} to register slice function",
-        mapTypeKindToName(kind));
+        TypeKindName::toName(kind));
   }
 
   void apply(
@@ -71,7 +71,7 @@ class SliceFunction : public exec::VectorFunction {
         args[1]->typeKind(),
         kind_,
         "Function slice() requires second argument of type {}",
-        mapTypeKindToName(kind_));
+        TypeKindName::toName(kind_));
     VELOX_USER_CHECK_EQ(
         args[1]->typeKind(),
         args[2]->typeKind(),
@@ -213,7 +213,7 @@ class SliceFunction : public exec::VectorFunction {
 
 // @param kind The type kind of start and length.
 void registerSliceFunction(const std::string& prefix, TypeKind kind) {
-  auto kindName = exec::sanitizeName(mapTypeKindToName(kind));
+  auto kindName = exec::sanitizeName(std::string(TypeKindName::toName(kind)));
 
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
       exec::FunctionSignatureBuilder()
diff --git a/velox/functions/lib/SubscriptUtil.cpp b/velox/functions/lib/SubscriptUtil.cpp
index 55031e0c31ee..7a345e520762 100644
--- a/velox/functions/lib/SubscriptUtil.cpp
+++ b/velox/functions/lib/SubscriptUtil.cpp
@@ -22,6 +22,7 @@
 #include "velox/common/memory/MemoryPool.h"
 #include "velox/functions/lib/SubscriptUtil.h"
 #include "velox/type/Type.h"
+#include "velox/vector/FlatMapVector.h"
 #include "velox/vector/TypeAliases.h"
 
 namespace facebook::velox::functions {
@@ -60,7 +61,7 @@ VectorPtr applyMapTyped(
     bool triggerCaching,
     std::shared_ptr<detail::LookupTableBase>& cachedLookupTablePtr,
     const SelectivityVector& rows,
-    const VectorPtr& mapArg,
+    const DecodedVector& decodedMap,
     const VectorPtr& indexArg,
     exec::EvalCtx& context) {
   static constexpr vector_size_t kMinCachedMapSize = 100;
@@ -85,10 +86,8 @@ VectorPtr applyMapTyped(
 
   // 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();
+  auto baseMap = decodedMap.base()->as<MapVector>();
+  auto mapIndices = decodedMap.indices();
 
   // Get map keys.
   auto mapKeys = baseMap->mapKeys();
@@ -186,9 +185,73 @@ VectorPtr applyMapTyped(
       true /*flattenIfRedundant*/);
 }
 
+/// Applies logic to vectors of FlatMapVector encoding. The implementation is
+/// far simpler than the regular map encoding because FlatMapVector already
+/// supports feature projection. This implementation will serve as a fast-path
+/// execution for now-wrapped vectors.
+VectorPtr applyFlatMap(
+    const SelectivityVector& rows,
+    const DecodedVector& decodedMap,
+    const VectorPtr& elementAt,
+    exec::EvalCtx& context) {
+  // Decode input flat map vector.
+  auto flatMap = decodedMap.base()->as<FlatMapVector>();
+
+  // Optimal use case: unwrapped vector and constant key. We can simply project
+  // the feature using the first value in the arg vector.
+  if (decodedMap.isIdentityMapping() && elementAt->isConstantEncoding()) {
+    if (auto projection = flatMap->projectKey(elementAt, 0)) {
+      return projection;
+    }
+  }
+
+  // Next base case: wrapped vector and constant key. In this scenario we just
+  // need to decode and simply project onto the first index again.
+  else if (elementAt->isConstantEncoding()) {
+    // Define nulls and indices buffers.
+    BufferPtr indices =
+        AlignedBuffer::allocate<vector_size_t>(rows.size(), flatMap->pool());
+    BufferPtr nulls = allocateNulls(rows.size(), flatMap->pool());
+    auto mutableIndices = indices->asMutable<vector_size_t>();
+    auto rawNulls = nulls->asMutable<uint64_t>();
+    for (int i = 0; i < decodedMap.size(); i++) {
+      mutableIndices[i] = decodedMap.indices()[i];
+      if (decodedMap.isNullAt(i)) {
+        bits::setNull(rawNulls, i, true);
+      }
+    }
+
+    if (auto projection = flatMap->projectKey(elementAt, 0)) {
+      // Wrap underlying projected feature stream. This will also help with
+      // memory pressure for large feature element vectors.
+      return BaseVector::wrapInDictionary(
+          std::move(nulls), indices, rows.end(), projection);
+    }
+  }
+
+  // In the case that elementAt is not constant, we will need to stitch together
+  // projected values from across our mapValues list.
+  else {
+    auto result =
+        BaseVector::create(flatMap->valueType(), rows.size(), context.pool());
+    rows.applyToSelected([&](vector_size_t row) {
+      if (auto projection = flatMap->projectKey(elementAt, row)) {
+        result->copy(projection.get(), row, decodedMap.indices()[row], 1);
+      } else {
+        result->setNull(row, true);
+      }
+    });
+    return result;
+  }
+
+  // Key doesn't exist, return null constant vector.
+  return BaseVector::createNullConstant(
+      flatMap->valueType(), rows.end(), context.pool());
+}
+
 VectorPtr applyMapComplexType(
     const SelectivityVector& rows,
-    const VectorPtr& mapArg,
+    const DecodedVector& decodedMap,
     const VectorPtr& indexArg,
     exec::EvalCtx& context,
     bool triggerCaching,
@@ -202,11 +265,9 @@ VectorPtr applyMapComplexType(
   // 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 base MapVector
+  auto baseMap = decodedMap.base()->as<MapVector>();
+  auto mapIndices = decodedMap.indices();
 
   // Get map keys.
   auto mapKeys = baseMap->mapKeys();
@@ -255,7 +316,9 @@ VectorPtr applyMapComplexType(
       auto numKeys = rawSizes[0];
       hashMapPtr->reserve(numKeys * 1.3);
       for (auto i = 0; i < numKeys; ++i) {
-        hashMapPtr->insert(detail::MapKey{mapKeysBase, mapKeysIndices[i], i});
+        const vector_size_t offset = rawOffsets[0] + i;
+        hashMapPtr->insert(
+            detail::MapKey{mapKeysBase, mapKeysIndices[offset], offset});
       }
     }
 
@@ -328,6 +391,16 @@ VectorPtr MapSubscript::applyMap(
   // Ensure map key type and second argument are the same.
   VELOX_CHECK(mapArg->type()->childAt(0)->equivalent(*indexArg->type()));
 
+  // Short-circuit for FlatMapVector encoding. FlatMapVector doesn't need to
+  // distinguish between primitive and complex types (where the former requires
+  // a type dispatch).
+  exec::LocalDecodedVector mapDecoder(context, *mapArg, rows);
+  auto decodedMap = mapDecoder.get();
+  if (decodedMap->base()->encoding() == VectorEncoding::Simple::FLAT_MAP) {
+    return applyFlatMap(rows, *decodedMap, indexArg, context);
+  }
+
+  // Regular map encoding with two paths for complex and primitive types.
   bool triggerCaching = shouldTriggerCaching(mapArg);
   if (indexArg->type()->isPrimitiveType() &&
       !indexArg->type()->providesCustomComparison()) {
@@ -337,7 +410,7 @@ VectorPtr MapSubscript::applyMap(
         triggerCaching,
         lookupTable_,
         rows,
-        mapArg,
+        *decodedMap,
         indexArg,
         context);
   } else {
@@ -347,50 +420,9 @@ VectorPtr MapSubscript::applyMap(
     // Vector's equalValueAt method, which calls the Types custom comparison
     // operator internally.
     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&) {
-    return std::current_exception();
-  }
-}
-
-std::exception_ptr makeBadSubscriptError() {
-  try {
-    VELOX_USER_FAIL("Array subscript out of bounds.");
-  } catch (const std::exception&) {
-    return std::current_exception();
+        rows, *decodedMap, indexArg, context, triggerCaching, lookupTable_);
   }
 }
-
-std::exception_ptr makeNegativeSubscriptError() {
-  try {
-    VELOX_USER_FAIL("Array subscript is negative.");
-  } catch (const std::exception&) {
-    return std::current_exception();
-  }
-}
-} // namespace
-
-const std::exception_ptr& zeroSubscriptError() {
-  static std::exception_ptr error = makeZeroSubscriptError();
-  return error;
-}
-
-const std::exception_ptr& badSubscriptError() {
-  static std::exception_ptr error = makeBadSubscriptError();
-  return error;
-}
-
-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 adb526d22cd1..93de96b5659e 100644
--- a/velox/functions/lib/SubscriptUtil.h
+++ b/velox/functions/lib/SubscriptUtil.h
@@ -31,10 +31,8 @@
 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();
+constexpr static inline std::string_view kZeroSubscriptErrorMsg =
+    "SQL array indices start at 1. Got 0.";
 const std::exception_ptr& negativeSubscriptError();
 
 // A flat vector of map keys, an index into that vector and an index into
@@ -277,7 +275,7 @@ class SubscriptImpl : public exec::Subscript {
       default:
         VELOX_UNSUPPORTED(
             "Unsupported type for element_at index {}",
-            mapTypeKindToName(indexArg->typeKind()));
+            TypeKindName::toName(indexArg->typeKind()));
     }
   }
 
@@ -286,22 +284,24 @@ class SubscriptImpl : public exec::Subscript {
 
     // 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());
+      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());
+    signatures.push_back(
+        exec::FunctionSignatureBuilder()
+            .typeVariable("K")
+            .typeVariable("V")
+            .returnType("V")
+            .argumentType("map(K,V)")
+            .argumentType("K")
+            .build());
 
     return signatures;
   }
@@ -336,17 +336,25 @@ class SubscriptImpl : public exec::Subscript {
       bool allFailed = false;
       // If index is invalid, capture the error and mark all rows as failed.
       bool isZeroSubscriptError = false;
+      const I originalIndex = decodedIndices->valueAt<I>(0);
       const auto adjustedIndex =
-          adjustIndex(decodedIndices->valueAt<I>(0), isZeroSubscriptError);
+          adjustIndex(originalIndex, isZeroSubscriptError);
       if (isZeroSubscriptError) {
-        context.setErrors(rows, detail::zeroSubscriptError());
+        context.setStatuses(
+            rows, Status::UserError(detail::kZeroSubscriptErrorMsg));
         allFailed = true;
       }
 
       if (!allFailed) {
         rows.applyToSelected([&](auto row) {
           const auto elementIndex = getIndex(
-              adjustedIndex, row, rawSizes, rawOffsets, arrayIndices, context);
+              originalIndex,
+              adjustedIndex,
+              row,
+              rawSizes,
+              rawOffsets,
+              arrayIndices,
+              context);
           rawIndices[row] = elementIndex;
           if (elementIndex == -1) {
             nullsBuilder.setNull(row);
@@ -355,16 +363,23 @@ class SubscriptImpl : public exec::Subscript {
       }
     } else {
       rows.applyToSelected([&](auto row) {
-        const auto originalIndex = decodedIndices->valueAt<I>(row);
+        const I originalIndex = decodedIndices->valueAt<I>(row);
         bool isZeroSubscriptError = false;
         const auto adjustedIndex =
             adjustIndex(originalIndex, isZeroSubscriptError);
         if (isZeroSubscriptError) {
-          context.setVeloxExceptionError(row, detail::zeroSubscriptError());
+          context.setStatus(
+              row, Status::UserError(detail::kZeroSubscriptErrorMsg));
           return;
         }
         const auto elementIndex = getIndex(
-            adjustedIndex, row, rawSizes, rawOffsets, arrayIndices, context);
+            originalIndex,
+            adjustedIndex,
+            row,
+            rawSizes,
+            rawOffsets,
+            arrayIndices,
+            context);
         rawIndices[row] = elementIndex;
         if (elementIndex == -1) {
           nullsBuilder.setNull(row);
@@ -416,7 +431,8 @@ class SubscriptImpl : public exec::Subscript {
   // above).
   template <typename I>
   vector_size_t getIndex(
-      I index,
+      I originalIndex,
+      vector_size_t index,
       vector_size_t row,
       const vector_size_t* rawSizes,
       const vector_size_t* rawOffsets,
@@ -433,7 +449,11 @@ class SubscriptImpl : public exec::Subscript {
           index += arraySize;
         }
       } else {
-        context.setVeloxExceptionError(row, detail::negativeSubscriptError());
+        context.setStatus(
+            row,
+            Status::UserError(
+                "Array subscript index cannot be negative, Index: {}",
+                originalIndex));
         return -1;
       }
     }
@@ -444,7 +464,12 @@ class SubscriptImpl : public exec::Subscript {
       if constexpr (allowOutOfBound) {
         return -1;
       } else {
-        context.setVeloxExceptionError(row, detail::badSubscriptError());
+        context.setStatus(
+            row,
+            Status::UserError(
+                "Array subscript index out of bounds, Index: {} Array size: {}",
+                originalIndex,
+                arraySize));
         return -1;
       }
     }
diff --git a/velox/functions/lib/TDigest.h b/velox/functions/lib/TDigest.h
index c5ce5d27b4ab..08fddeaace90 100644
--- a/velox/functions/lib/TDigest.h
+++ b/velox/functions/lib/TDigest.h
@@ -338,7 +338,11 @@ void TDigest<A>::mergeImpl(
   }
   weightSoFar += weights_[j];
   ++numMerged_;
-  VELOX_CHECK_LT(std::abs(weightSoFar - totalWeight), kEpsilon);
+  // Use relative epsilon to handle floating-point precision issues
+  // with large totalWeight values
+  double relativeEpsilon =
+      std::max(kEpsilon, totalWeight * kRelativeErrorEpsilon);
+  VELOX_CHECK_LT(std::abs(weightSoFar - totalWeight), relativeEpsilon);
   if constexpr (kReverse) {
     std::copy(weights_.begin() + j, weights_.end(), weights_.begin());
     std::copy(means_.begin() + j, means_.end(), means_.begin());
diff --git a/velox/functions/lib/TimeUtils.cpp b/velox/functions/lib/TimeUtils.cpp
index bc790730a283..4128a1566c8a 100644
--- a/velox/functions/lib/TimeUtils.cpp
+++ b/velox/functions/lib/TimeUtils.cpp
@@ -85,10 +85,10 @@ void adjustDateTime(std::tm& dateTime, const DateTimeUnit& unit) {
     case DateTimeUnit::kYear:
       dateTime.tm_mon = 0;
       dateTime.tm_yday = 0;
-      FMT_FALLTHROUGH;
+      [[fallthrough]];
     case DateTimeUnit::kQuarter:
       dateTime.tm_mon = dateTime.tm_mon / 3 * 3;
-      FMT_FALLTHROUGH;
+      [[fallthrough]];
     case DateTimeUnit::kMonth:
       dateTime.tm_mday = 1;
       dateTime.tm_hour = 0;
@@ -134,10 +134,10 @@ void adjustDateTime(std::tm& dateTime, const DateTimeUnit& unit) {
       break;
     case DateTimeUnit::kDay:
       dateTime.tm_hour = 0;
-      FMT_FALLTHROUGH;
+      [[fallthrough]];
     case DateTimeUnit::kHour:
       dateTime.tm_min = 0;
-      FMT_FALLTHROUGH;
+      [[fallthrough]];
     case DateTimeUnit::kMinute:
       dateTime.tm_sec = 0;
       break;
diff --git a/velox/functions/lib/TimeUtils.h b/velox/functions/lib/TimeUtils.h
index 424a4ba3d3a2..4e1c1908d26c 100644
--- a/velox/functions/lib/TimeUtils.h
+++ b/velox/functions/lib/TimeUtils.h
@@ -27,6 +27,9 @@
 
 namespace facebook::velox::functions {
 
+inline constexpr int64_t kSecondsInMinute = 60;
+inline constexpr int64_t kMinutesInHour = 60;
+inline constexpr int64_t kSecondsInHour = kSecondsInMinute * kMinutesInHour;
 inline constexpr int64_t kSecondsInDay = 86'400;
 inline constexpr int64_t kDaysInWeek = 7;
 extern const folly::F14FastMap<std::string, int8_t> kDayOfWeekNames;
diff --git a/velox/functions/lib/UpperLower.h b/velox/functions/lib/UpperLower.h
new file mode 100644
index 000000000000..1c17510c9022
--- /dev/null
+++ b/velox/functions/lib/UpperLower.h
@@ -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/StringWriter.h"
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/StringEncodingUtils.h"
+#include "velox/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::functions {
+
+/// Function to convert string to upper or lower case. Ascii and unicode
+/// conversion are supported.
+/// @tparam isLower Instantiate for upper or lower.
+/// @tparam turkishCasing If true, Spark's specific behavior on Turkish casing
+/// is considered. For 'İ' Spark's lower case is 'i̇' and Presto's is 'i'.
+/// @tparam greekFinalSigma If true, Greek final sigma rule is applied. For
+/// the uppercase letter Σ, if it appears at the end of a word, it becomes ς. In
+/// all other positions, it becomes σ. If false, it is always converted to σ.
+template <bool isLower, bool turkishCasing, bool greekFinalSigma>
+class UpperLowerTemplateFunction : public exec::VectorFunction {
+ private:
+  // String encoding wrappable function.
+  template <bool isAscii>
+  struct ApplyInternal {
+    static void apply(
+        const SelectivityVector& rows,
+        const DecodedVector* decodedInput,
+        FlatVector<StringView>* results) {
+      rows.applyToSelected([&](auto row) {
+        auto proxy = exec::StringWriter(results, row);
+        if constexpr (isLower) {
+          stringImpl::lower<isAscii, turkishCasing, greekFinalSigma>(
+              proxy, decodedInput->valueAt<StringView>(row));
+        } else {
+          stringImpl::upper<isAscii, turkishCasing>(
+              proxy, decodedInput->valueAt<StringView>(row));
+        }
+        proxy.finalize();
+      });
+    }
+  };
+
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /*outputType*/,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VELOX_CHECK(args.size() == 1);
+    VELOX_CHECK(args[0]->typeKind() == TypeKind::VARCHAR);
+
+    // Read content before calling prepare results.
+    BaseVector* inputStringsVector = args[0].get();
+    exec::LocalDecodedVector inputHolder(context, *inputStringsVector, rows);
+    auto decodedInput = inputHolder.get();
+
+    auto ascii = isAscii(inputStringsVector, rows);
+
+    // Not in place path.
+    VectorPtr emptyVectorPtr;
+    prepareFlatResultsVector(result, rows, context, emptyVectorPtr);
+    auto* resultFlatVector = result->as<FlatVector<StringView>>();
+
+    StringEncodingTemplateWrapper<ApplyInternal>::apply(
+        ascii, rows, decodedInput, resultFlatVector);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    // varchar -> varchar
+    return {exec::FunctionSignatureBuilder()
+                .returnType("varchar")
+                .argumentType("varchar")
+                .build()};
+  }
+
+  bool ensureStringEncodingSetAtAllInputs() const override {
+    return true;
+  }
+
+  bool propagateStringEncodingFromAllInputs() const override {
+    return true;
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/aggregates/BitwiseAggregateBase.h b/velox/functions/lib/aggregates/BitwiseAggregateBase.h
index 972ae40c0adb..c3de6145d203 100644
--- a/velox/functions/lib/aggregates/BitwiseAggregateBase.h
+++ b/velox/functions/lib/aggregates/BitwiseAggregateBase.h
@@ -72,6 +72,7 @@ class BitwiseAggregateBase : public SimpleNumericAggregate<T, T, T> {
 template <template <typename U> class T>
 exec::AggregateRegistrationResult registerBitwise(
     const std::string& name,
+    bool ignoreDuplicates,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite) {
@@ -81,11 +82,12 @@ exec::AggregateRegistrationResult registerBitwise(
     typeList = {"bigint"};
   }
   for (const auto& inputType : typeList) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(inputType)
-                             .intermediateType(inputType)
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(inputType)
+            .intermediateType(inputType)
+            .argumentType(inputType)
+            .build());
   }
 
   return exec::registerAggregateFunction(
@@ -114,7 +116,7 @@ exec::AggregateRegistrationResult registerBitwise(
                 inputType->kindName());
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.ignoreDuplicates = ignoreDuplicates, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/lib/aggregates/CMakeLists.txt b/velox/functions/lib/aggregates/CMakeLists.txt
index a291e51be33c..a0865831f721 100644
--- a/velox/functions/lib/aggregates/CMakeLists.txt
+++ b/velox/functions/lib/aggregates/CMakeLists.txt
@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+add_subdirectory(noisy_aggregation)
+
 velox_add_library(
   velox_functions_aggregates
   AverageAggregateBase.cpp
@@ -22,10 +24,10 @@ velox_add_library(
   SingleValueAccumulator.cpp
   ValueList.cpp
   ValueSet.cpp
-  VarianceAggregatesBase.cpp)
+  VarianceAggregatesBase.cpp
+)
 
-velox_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)
diff --git a/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h b/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h
index e44d0077e41d..237b9389cef0 100644
--- a/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h
+++ b/velox/functions/lib/aggregates/CentralMomentsAggregatesBase.h
@@ -384,9 +384,6 @@ class CentralMomentsAggregatesBase : public exec::Aggregate {
       override {
     auto rowVector = (*result)->as<RowVector>();
     rowVector->resize(numGroups);
-    for (auto& child : rowVector->children()) {
-      child->resize(numGroups);
-    }
 
     uint64_t* rawNulls = getRawNulls(rowVector);
 
diff --git a/velox/functions/lib/aggregates/Compare.cpp b/velox/functions/lib/aggregates/Compare.cpp
index 469a9cd347b1..774cecdef4bf 100644
--- a/velox/functions/lib/aggregates/Compare.cpp
+++ b/velox/functions/lib/aggregates/Compare.cpp
@@ -28,7 +28,7 @@ int32_t compare(
       result.has_value(),
       fmt::format(
           "{} comparison not supported for values that contain nulls",
-          mapTypeKindToName(decoded.base()->typeKind())));
+          TypeKindName::toName(decoded.base()->typeKind())));
   return result.value();
 }
 } // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/CovarianceAggregatesBase.h b/velox/functions/lib/aggregates/CovarianceAggregatesBase.h
index 64a9b1b8b6a1..55adb218ac61 100644
--- a/velox/functions/lib/aggregates/CovarianceAggregatesBase.h
+++ b/velox/functions/lib/aggregates/CovarianceAggregatesBase.h
@@ -350,9 +350,6 @@ class CovarianceAggregate : public exec::Aggregate {
       override {
     auto rowVector = (*result)->as<RowVector>();
     rowVector->resize(numGroups);
-    for (auto& child : rowVector->children()) {
-      child->resize(numGroups);
-    }
 
     uint64_t* rawNulls = getRawNulls(rowVector);
 
diff --git a/velox/functions/lib/aggregates/DecimalAggregate.h b/velox/functions/lib/aggregates/DecimalAggregate.h
index 8e78a545d70c..aa3f63bac627 100644
--- a/velox/functions/lib/aggregates/DecimalAggregate.h
+++ b/velox/functions/lib/aggregates/DecimalAggregate.h
@@ -59,7 +59,7 @@ struct LongDecimalWithOverflowState {
    * Total size = sizeOf(count) + sizeOf(overflow) + sizeOf(sum)
    *            = 8 + 8 + 16 = 32.
    */
-  inline static size_t serializedSize() {
+  static constexpr size_t serializedSize() {
     return sizeof(int64_t) * 4;
   }
 
diff --git a/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp b/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp
index e3edcf7fc9e3..9e62083d2cbd 100644
--- a/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp
+++ b/velox/functions/lib/aggregates/MinMaxAggregateBase.cpp
@@ -17,12 +17,12 @@
 #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"
+#include "velox/vector/AggregationHook.h"
 
 namespace facebook::velox::functions::aggregate {
 
@@ -114,7 +114,8 @@ class SimpleNumericMaxAggregate : public SimpleNumericMinMaxAggregate<T> {
       bool mayPushdown) override {
     if constexpr (BaseAggregate::template kMayPushdown<T>) {
       if (!args[0]->type()->isDecimal()) {
-        if (mayPushdown && args[0]->isLazy()) {
+        if (mayPushdown && args[0]->isLazy() &&
+            args[0]->asChecked<const LazyVector>()->supportsHook()) {
           BaseAggregate::template pushdown<
               velox::aggregate::MinMaxHook<T, false>>(groups, rows, args[0]);
           return;
@@ -215,7 +216,8 @@ class SimpleNumericMinAggregate : public SimpleNumericMinMaxAggregate<T> {
       bool mayPushdown) override {
     if constexpr (BaseAggregate::template kMayPushdown<T>) {
       if (!args[0]->type()->isDecimal()) {
-        if (mayPushdown && args[0]->isLazy()) {
+        if (mayPushdown && args[0]->isLazy() &&
+            args[0]->asChecked<const LazyVector>()->supportsHook()) {
           BaseAggregate::template pushdown<
               velox::aggregate::MinMaxHook<T, true>>(groups, rows, args[0]);
           return;
@@ -325,7 +327,7 @@ class MinMaxAggregateBase : public exec::Aggregate {
       auto indices = decoded.indices();
       rows.applyToSelected([&](vector_size_t i) {
         velox::functions::checkNestedNulls(
-            decoded, indices, i, throwOnNestedNulls_);
+            decoded, i, indices[i], throwOnNestedNulls_);
       });
     }
 
@@ -404,7 +406,7 @@ class MinMaxAggregateBase : public exec::Aggregate {
 
     rows.applyToSelected([&](vector_size_t i) {
       if (velox::functions::checkNestedNulls(
-              decoded, indices, i, throwOnNestedNulls_)) {
+              decoded, i, indices[i], throwOnNestedNulls_)) {
         return;
       }
 
@@ -425,7 +427,6 @@ class MinMaxAggregateBase : public exec::Aggregate {
       const VectorPtr& arg,
       TCompareTest compareTest) {
     DecodedVector decoded(*arg, rows, true);
-    auto indices = decoded.indices();
     auto baseVector = decoded.base();
     const CompareFlags compareFlags{
         true, // nullsFirst
@@ -434,23 +435,39 @@ class MinMaxAggregateBase : public exec::Aggregate {
         nullHandlingMode};
 
     if (decoded.isConstantMapping()) {
+      vector_size_t baseIndex = decoded.index(0);
       if (velox::functions::checkNestedNulls(
-              decoded, indices, 0, throwOnNestedNulls_)) {
+              decoded, 0, baseIndex, throwOnNestedNulls_)) {
         return;
       }
 
       auto accumulator = value<SingleValueAccumulator>(group);
       if (!accumulator->hasValue() ||
           compareTest(compare(accumulator, decoded, 0, compareFlags))) {
-        accumulator->write(baseVector, indices[0], allocator_);
+        accumulator->write(baseVector, baseIndex, allocator_);
       }
       return;
     }
 
     auto accumulator = value<SingleValueAccumulator>(group);
+    if (decoded.isIdentityMapping()) {
+      rows.applyToSelected([&](vector_size_t i) {
+        if (velox::functions::checkNestedNulls(
+                decoded, i, i, throwOnNestedNulls_)) {
+          return;
+        }
+        if (!accumulator->hasValue() ||
+            compareTest(compare(accumulator, decoded, i, compareFlags))) {
+          accumulator->write(baseVector, i, allocator_);
+        }
+      });
+      return;
+    }
+
+    auto indices = decoded.indices();
     rows.applyToSelected([&](vector_size_t i) {
       if (velox::functions::checkNestedNulls(
-              decoded, indices, i, throwOnNestedNulls_)) {
+              decoded, i, indices[i], throwOnNestedNulls_)) {
         return;
       }
       if (!accumulator->hasValue() ||
@@ -572,10 +589,9 @@ class MinAggregate : public MinMaxAggregateBase {
 };
 
 template <
-    template <typename T>
-    class TSimpleNumericAggregate,
-    template <CompareFlags::NullHandlingMode nullHandlingMode>
-    typename TAggregate>
+    template <typename T> class TSimpleNumericAggregate,
+    template <
+        CompareFlags::NullHandlingMode nullHandlingMode> typename TAggregate>
 exec::AggregateFunctionFactory getMinMaxFunctionFactoryInternal(
     const std::string& name,
     CompareFlags::NullHandlingMode nullHandlingMode,
diff --git a/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h b/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
index db29a96923d4..d269eff5b370 100644
--- a/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
+++ b/velox/functions/lib/aggregates/MinMaxByAggregatesBase.h
@@ -310,7 +310,7 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     if (decodedValue_.mayHaveNulls() || decodedComparison_.mayHaveNulls()) {
       rows.applyToSelected([&](vector_size_t i) {
         if (checkNestedNulls(
-                decodedComparison_, indices, i, throwOnNestedNulls_)) {
+                decodedComparison_, i, indices[i], throwOnNestedNulls_)) {
           return;
         }
         updateValues(
@@ -324,7 +324,8 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     } else {
       rows.applyToSelected([&](vector_size_t i) {
         if (throwOnNestedNulls_) {
-          checkNestedNulls(decodedComparison_, indices, i, throwOnNestedNulls_);
+          checkNestedNulls(
+              decodedComparison_, i, indices[i], throwOnNestedNulls_);
         }
         updateValues(
             groups[i], decodedValue_, decodedComparison_, i, false, mayUpdate);
@@ -388,12 +389,14 @@ 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 (checkNestedNulls(
-              decodedComparison_, indices, 0, throwOnNestedNulls_)) {
+              decodedComparison_,
+              0,
+              decodedComparison_.index(0),
+              throwOnNestedNulls_)) {
         return;
       }
       updateValues(
@@ -403,11 +406,14 @@ class MinMaxByAggregateBase : public exec::Aggregate {
           0,
           decodedValue_.isNullAt(0),
           mayUpdate);
-    } else if (
-        decodedValue_.mayHaveNulls() || decodedComparison_.mayHaveNulls()) {
+      return;
+    }
+
+    const auto* indices = decodedComparison_.indices();
+    if (decodedValue_.mayHaveNulls() || decodedComparison_.mayHaveNulls()) {
       rows.applyToSelected([&](vector_size_t i) {
         if (checkNestedNulls(
-                decodedComparison_, indices, i, throwOnNestedNulls_)) {
+                decodedComparison_, i, indices[i], throwOnNestedNulls_)) {
           return;
         }
         updateValues(
@@ -421,7 +427,8 @@ class MinMaxByAggregateBase : public exec::Aggregate {
     } else {
       rows.applyToSelected([&](vector_size_t i) {
         if (throwOnNestedNulls_) {
-          checkNestedNulls(decodedComparison_, indices, i, throwOnNestedNulls_);
+          checkNestedNulls(
+              decodedComparison_, i, indices[i], throwOnNestedNulls_);
         }
         updateValues(
             group, decodedValue_, decodedComparison_, i, false, mayUpdate);
@@ -573,8 +580,12 @@ class MinMaxByAggregateBase : public exec::Aggregate {
 };
 
 template <
-    template <typename U, typename V, bool B1, class C, bool B2>
-    class Aggregate,
+    template <
+        typename U,
+        typename V,
+        bool B1,
+        class C,
+        bool B2> class Aggregate,
     bool isMaxFunc,
     class Comparator,
     bool compareTypeUsesCustomComparison,
@@ -682,8 +693,12 @@ std::unique_ptr<exec::Aggregate> create(
 }
 
 template <
-    template <typename U, typename V, bool B1, class C, bool B2>
-    class Aggregate,
+    template <
+        typename U,
+        typename V,
+        bool B1,
+        class C,
+        bool B2> class Aggregate,
     class Comparator,
     bool isMaxFunc,
     bool compareTypeUsesCustomComparison = false>
diff --git a/velox/functions/lib/aggregates/SimpleNumericAggregate.h b/velox/functions/lib/aggregates/SimpleNumericAggregate.h
index 6a2c9d7368d0..a5327ea3c195 100644
--- a/velox/functions/lib/aggregates/SimpleNumericAggregate.h
+++ b/velox/functions/lib/aggregates/SimpleNumericAggregate.h
@@ -16,7 +16,7 @@
 #pragma once
 
 #include "velox/exec/Aggregate.h"
-#include "velox/exec/AggregationHook.h"
+#include "velox/vector/AggregationHook.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
 #include "velox/vector/LazyVector.h"
@@ -98,22 +98,24 @@ class SimpleNumericAggregate : public exec::Aggregate {
       UpdateSingleValue updateSingleValue,
       bool mayPushdown) {
     DecodedVector decoded(*arg, rows, !mayPushdown);
-    auto encoding = decoded.base()->encoding();
     if constexpr (kMayPushdown<TData>) {
-      if (encoding == VectorEncoding::Simple::LAZY &&
+      if (mayPushdown &&
+          decoded.base()->encoding() == VectorEncoding::Simple::LAZY &&
           !arg->type()->isDecimal()) {
-        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* lazy = decoded.base()->asChecked<const LazyVector>();
+        if (lazy->supportsHook()) {
+          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();
+          lazy->load(RowSet(indices, arg->size()), &hook);
+          return;
+        }
+        decoded.decode(*arg, rows);
       }
     }
 
@@ -226,9 +228,9 @@ class SimpleNumericAggregate : public exec::Aggregate {
         numIndices = numSelected;
       }
     }
-
-    decoded.base()->as<const LazyVector>()->load(
-        RowSet(indices, numIndices), &hook);
+    auto* lazy = decoded.base()->asChecked<const LazyVector>();
+    VELOX_CHECK(lazy->supportsHook());
+    lazy->load(RowSet(indices, numIndices), &hook);
   }
 
  private:
diff --git a/velox/functions/lib/aggregates/SumAggregateBase.h b/velox/functions/lib/aggregates/SumAggregateBase.h
index dd44cd3c8726..ed310a6c95aa 100644
--- a/velox/functions/lib/aggregates/SumAggregateBase.h
+++ b/velox/functions/lib/aggregates/SumAggregateBase.h
@@ -124,7 +124,8 @@ class SumAggregateBase
       bool mayPushdown) {
     const auto& arg = args[0];
 
-    if (mayPushdown && arg->isLazy()) {
+    if (mayPushdown && arg->isLazy() &&
+        arg->asChecked<const LazyVector>()->supportsHook()) {
       BaseAggregate::template pushdown<
           facebook::velox::aggregate::SumHook<TData, Overflow>>(
           groups, rows, arg);
diff --git a/velox/functions/lib/aggregates/ValueList.cpp b/velox/functions/lib/aggregates/ValueList.cpp
index 2d602db44c74..8844c6985932 100644
--- a/velox/functions/lib/aggregates/ValueList.cpp
+++ b/velox/functions/lib/aggregates/ValueList.cpp
@@ -65,8 +65,9 @@ void ValueList::appendNonNull(
   allocator->extendWrite(dataCurrent_, 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);
+  // Set isKey to false to avoid unnecessary sorting.
+  static const exec::ContainerRowSerdeOptions kOptions{/*isKey=*/false};
+  exec::ContainerRowSerde::serialize(values, index, stream, kOptions);
   ++size_;
   bytes_ += stream.size() - initialSize;
 
diff --git a/velox/functions/lib/aggregates/ValueSet.cpp b/velox/functions/lib/aggregates/ValueSet.cpp
index ff06f0da35dc..cff7b1b9c69b 100644
--- a/velox/functions/lib/aggregates/ValueSet.cpp
+++ b/velox/functions/lib/aggregates/ValueSet.cpp
@@ -29,8 +29,9 @@ void ValueSet::write(
     allocator_->extendWrite(position, stream);
   }
 
-  static const exec::ContainerRowSerdeOptions options{};
-  exec::ContainerRowSerde::serialize(vector, index, stream, options);
+  // Set isKey to false to avoid unnecessary sorting.
+  static const exec::ContainerRowSerdeOptions kOptions{/*isKey=*/false};
+  exec::ContainerRowSerde::serialize(vector, index, stream, kOptions);
   allocator_->finishWrite(stream, 0);
 }
 
diff --git a/velox/functions/lib/aggregates/VarianceAggregatesBase.h b/velox/functions/lib/aggregates/VarianceAggregatesBase.h
index 654fa4df695e..96424e7321ad 100644
--- a/velox/functions/lib/aggregates/VarianceAggregatesBase.h
+++ b/velox/functions/lib/aggregates/VarianceAggregatesBase.h
@@ -87,9 +87,6 @@ class VarianceAggregate : public exec::Aggregate {
     auto m2Vector = rowVector->childAt(kM2Idx)->asFlatVector<double>();
 
     rowVector->resize(numGroups);
-    for (auto& child : rowVector->children()) {
-      child->resize(numGroups);
-    }
     uint64_t* rawNulls = getRawNulls(rowVector);
 
     int64_t* rawCounts = countVector->mutableRawValues();
diff --git a/velox/functions/lib/aggregates/noisy_aggregation/CMakeLists.txt b/velox/functions/lib/aggregates/noisy_aggregation/CMakeLists.txt
new file mode 100644
index 000000000000..a598690b32e5
--- /dev/null
+++ b/velox/functions/lib/aggregates/noisy_aggregation/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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_install_library_headers()
diff --git a/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountAccumulator.h b/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountAccumulator.h
deleted file mode 100644
index a4c59b84af07..000000000000
--- a/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountAccumulator.h
+++ /dev/null
@@ -1,64 +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) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
-
-#pragma once
-
-#include <cstdint>
-#include "velox/common/base/CheckedArithmetic.h"
-#include "velox/common/base/Exceptions.h"
-#include "velox/common/base/IOUtils.h"
-
-namespace facebook::velox::functions::aggregate {
-
-struct NoisyCountAccumulator {
-  uint64_t count{0};
-  // Initial noise scale is an invalid noise scale,
-  // indicating that we have not updated it yet
-  double noiseScale{-1.0};
-
-  void increaseCount(uint64_t value) {
-    count = facebook::velox::checkedPlus<uint64_t>(count, value);
-  }
-
-  void checkAndSetNoiseScale(double newNoiseScale) {
-    VELOX_USER_CHECK_GE(
-        newNoiseScale, 0, "Noise scale must be a non-negative value");
-
-    noiseScale = newNoiseScale;
-  }
-
-  static int32_t serializedSize() {
-    return sizeof(uint64_t) + sizeof(double);
-  }
-
-  void serialize(char* output) {
-    common::OutputByteStream stream(output);
-    stream.appendOne(count);
-    stream.appendOne(noiseScale);
-  }
-
-  static NoisyCountAccumulator deserialize(const char* serialized) {
-    common::InputByteStream stream(serialized);
-
-    auto count = stream.read<uint64_t>();
-    auto noiseScale = stream.read<double>();
-
-    return NoisyCountAccumulator{count, noiseScale};
-  }
-};
-
-} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h b/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h
new file mode 100644
index 000000000000..09168f2d21f0
--- /dev/null
+++ b/velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/CheckedArithmetic.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/IOUtils.h"
+
+namespace facebook::velox::functions::aggregate {
+
+class NoisyCountSumAvgAccumulator {
+ public:
+  NoisyCountSumAvgAccumulator() = default;
+  NoisyCountSumAvgAccumulator(
+      double sum,
+      uint64_t count,
+      double noiseScale,
+      std::optional<int64_t> randomSeed,
+      std::optional<double> lowerBound,
+      std::optional<double> upperBound)
+      : sum_{sum},
+        count_{count},
+        noiseScale_{noiseScale},
+        randomSeed_(randomSeed),
+        lowerBound_(lowerBound),
+        upperBound_(upperBound) {}
+
+  void updateCount(uint64_t value) {
+    count_ = facebook::velox::checkedPlus<uint64_t>(count_, value);
+  }
+
+  void updateSum(double value) {
+    sum_ += value;
+  }
+
+  void clipUpdateSum(double value) {
+    if (lowerBound_.has_value() && upperBound_.has_value()) {
+      auto clippedValue = std::max(*lowerBound_, std::min(*upperBound_, value));
+      this->sum_ += clippedValue;
+    } else {
+      this->sum_ += value;
+    }
+  }
+
+  void checkAndSetNoiseScale(double newNoiseScale) {
+    VELOX_USER_CHECK_GE(
+        newNoiseScale, 0, "Noise scale must be a non-negative value.");
+    noiseScale_ = newNoiseScale;
+  }
+
+  void checkAndSetBounds(double lowerBound, double upperBound) {
+    VELOX_USER_CHECK_LE(
+        lowerBound,
+        upperBound,
+        "Lower bound must be less than or equal to upper bound.");
+    this->lowerBound_ = lowerBound;
+    this->upperBound_ = upperBound;
+  }
+
+  void setRandomSeed(int64_t randomSeed) {
+    this->randomSeed_ = randomSeed;
+  }
+
+  double getSum() const {
+    return sum_;
+  }
+
+  uint64_t getCount() const {
+    return count_;
+  }
+
+  double getNoiseScale() const {
+    return noiseScale_;
+  }
+
+  std::optional<double> getLowerBound() const {
+    return lowerBound_;
+  }
+
+  std::optional<double> getUpperBound() const {
+    return upperBound_;
+  }
+
+  std::optional<int64_t> getRandomSeed() const {
+    return randomSeed_;
+  }
+
+  // sizeof(double) for sum_
+  // sizeof(uint64_t) for count_
+  // sizeof(double) for noiseScale_
+  // sizeof(bool) for has_bound flag
+  // sizeof(double) for lowerBound_ value
+  // sizeof(double) for upperBound_ value
+  // sizeof(bool) for randomSeed_ has_value flag
+  // sizeof(int32_t) for randomSeed_ value
+  static size_t serializedSize() {
+    return sizeof(double) + sizeof(uint64_t) + sizeof(double) + sizeof(bool) +
+        sizeof(double) + sizeof(double) + sizeof(bool) + sizeof(int64_t);
+  }
+
+  void serialize(char* buffer) const {
+    common::OutputByteStream stream(buffer);
+    stream.appendOne(sum_);
+    stream.appendOne(count_);
+    stream.appendOne(noiseScale_);
+    // Serialize lowerBound_ and upperBound_(append 0 if has_value is false).
+    stream.appendOne(lowerBound_.has_value());
+    stream.appendOne(lowerBound_.has_value() ? *lowerBound_ : 0.0);
+    stream.appendOne(upperBound_.has_value() ? *upperBound_ : 0.0);
+
+    // Serialize randomSeed_(append 0 if has_value is false).
+    stream.appendOne(randomSeed_.has_value());
+    stream.appendOne(randomSeed_.has_value() ? *randomSeed_ : 0);
+  }
+
+  static NoisyCountSumAvgAccumulator deserialize(const char* buffer) {
+    common::InputByteStream stream(buffer);
+    double sum = stream.read<double>();
+    uint64_t count = stream.read<uint64_t>();
+    double noiseScale = stream.read<double>();
+    bool hasBounds = stream.read<bool>();
+    std::optional<double> lowerBound = stream.read<double>();
+    std::optional<double> upperBound = stream.read<double>();
+    bool hasRandomSeed = stream.read<bool>();
+    std::optional<int32_t> randomSeed = stream.read<int64_t>();
+    return NoisyCountSumAvgAccumulator(
+        sum,
+        count,
+        noiseScale,
+        hasRandomSeed ? randomSeed : std::nullopt,
+        hasBounds ? lowerBound : std::nullopt,
+        hasBounds ? upperBound : std::nullopt);
+  }
+
+ private:
+  double sum_{0};
+  uint64_t count_{0};
+  double noiseScale_{-1};
+  std::optional<int64_t> randomSeed_{std::nullopt};
+  std::optional<double> lowerBound_{std::nullopt};
+  std::optional<double> upperBound_{std::nullopt};
+};
+
+} // namespace facebook::velox::functions::aggregate
diff --git a/velox/functions/lib/aggregates/tests/CMakeLists.txt b/velox/functions/lib/aggregates/tests/CMakeLists.txt
index cd51532cc277..88e4765bb36e 100644
--- a/velox/functions/lib/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/lib/aggregates/tests/CMakeLists.txt
@@ -16,8 +16,7 @@ add_subdirectory(utils)
 
 add_executable(velox_functions_aggregates_test ValueListTest.cpp)
 
-add_test(NAME velox_functions_aggregates_test
-         COMMAND velox_functions_aggregates_test)
+add_test(NAME velox_functions_aggregates_test COMMAND velox_functions_aggregates_test)
 
 target_link_libraries(
   velox_functions_aggregates_test
@@ -26,4 +25,5 @@ target_link_libraries(
   Folly::folly
   GTest::gtest
   GTest::gtest_main
-  glog::glog)
+  glog::glog
+)
diff --git a/velox/functions/lib/aggregates/tests/SumTestBase.h b/velox/functions/lib/aggregates/tests/SumTestBase.h
index 4ddf57515f8c..29584cb73d03 100644
--- a/velox/functions/lib/aggregates/tests/SumTestBase.h
+++ b/velox/functions/lib/aggregates/tests/SumTestBase.h
@@ -17,10 +17,10 @@
 #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"
+#include "velox/vector/AggregationHook.h"
 
 namespace facebook::velox::functions::aggregate::test {
 
diff --git a/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp b/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp
index e96b14c30b6e..b604f6601bf2 100644
--- a/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp
+++ b/velox/functions/lib/aggregates/tests/utils/AggregationTestBase.cpp
@@ -22,10 +22,9 @@
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/dwio/common/tests/utils/BatchMaker.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
-#include "velox/dwio/dwrf/RegisterDwrfWriter.h"
-#include "velox/dwio/dwrf/reader/DwrfReader.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/exec/AggregateCompanionSignatures.h"
+#include "velox/exec/AggregateFunctionRegistry.h"
 #include "velox/exec/PlanNodeStats.h"
 #include "velox/exec/Spill.h"
 #include "velox/exec/tests/utils/TempDirectoryPath.h"
@@ -51,6 +50,14 @@ void enableAbandonPartialAggregation(AssertQueryBuilder& queryBuilder) {
       .maxDrivers(1);
 }
 
+// Companion function names for an aggregate function.
+struct CompanionFunctions {
+  std::string partialFunction;
+  std::string mergeFunction;
+  std::string mergeExtractFunction;
+  std::string extractFunction;
+};
+
 } // namespace
 
 std::vector<RowVectorPtr> AggregationTestBase::makeVectors(
@@ -69,15 +76,11 @@ std::vector<RowVectorPtr> AggregationTestBase::makeVectors(
 void AggregationTestBase::SetUp() {
   OperatorTestBase::SetUp();
   filesystems::registerLocalFileSystem();
-  connector::registerConnectorFactory(
-      std::make_shared<connector::hive::HiveConnectorFactory>());
-  auto hiveConnector =
-      connector::getConnectorFactory(
-          connector::hive::HiveConnectorFactory::kHiveConnectorName)
-          ->newConnector(
-              kHiveConnectorId,
-              std::make_shared<config::ConfigBase>(
-                  std::unordered_map<std::string, std::string>()));
+  connector::hive::HiveConnectorFactory factory;
+  auto hiveConnector = factory.newConnector(
+      kHiveConnectorId,
+      std::make_shared<config::ConfigBase>(
+          std::unordered_map<std::string, std::string>()));
   connector::registerConnector(hiveConnector);
   dwrf::registerDwrfReaderFactory();
 }
@@ -85,8 +88,6 @@ void AggregationTestBase::SetUp() {
 void AggregationTestBase::TearDown() {
   dwrf::unregisterDwrfReaderFactory();
   connector::unregisterConnector(kHiveConnectorId);
-  connector::unregisterConnectorFactory(
-      connector::hive::HiveConnectorFactory::kHiveConnectorName);
   OperatorTestBase::TearDown();
 }
 
@@ -206,6 +207,29 @@ std::vector<RowVectorPtr> addExtraGroupingKey(
   return newData;
 }
 
+// Given the name of the original aggregate function and the argument types,
+// return the name of the merge_extract companion function with a suffix of the
+// result type. Merge_extract function names with suffixes should only be used
+// when the original aggregate function has multiple signatures with the same
+// intermediate type.
+std::string getMergeExtractFunctionNameWithSuffix(
+    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 resolvedType = binder.tryResolveReturnType()) {
+        return exec::CompanionSignatures::mergeExtractFunctionNameWithSuffix(
+            name, signature->returnType());
+      }
+    }
+  }
+  VELOX_UNREACHABLE("Could not find a function bound to argTypes.");
+}
+
 // 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
@@ -229,12 +253,13 @@ std::string getExtractFunctionNameWithSuffix(
   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(
+// Given the `index`-th aggregation expression, e.g., "avg(c0)", return the
+// names of its partial companion aggregation expression, merge companion
+// aggregation expression, merge_extract companion expression and extract
+// companion expression, e.g., CompanionFunctions{"avg_partial(c0)",
+// "avg_merge(a0)", "avg_merge_extract_double(a0)", "avg_extract_double(a0)"}
+// when `index` is 0.
+CompanionFunctions getCompanionAggregates(
     column_index_t index,
     const exec::CompanionFunctionSignatureMap& companionFunctions,
     const std::string& functionName,
@@ -248,9 +273,24 @@ std::tuple<std::string, std::string, std::string> getCompanionAggregates(
   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 projections, if exist, can apply with no change.
+  // Construct the merge_extract expression. Rename the result of the expression
+  // to be the same as the original aggregation result, so that post-aggregation
+  // projections, if exist, can apply with no change.
+  std::string mergeExtractExpression;
+  if (companionFunctions.mergeExtract.size() == 1) {
+    mergeExtractExpression = fmt::format(
+        "{0}(a{1}) as a{1}",
+        companionFunctions.mergeExtract.front().functionName,
+        index);
+  } else {
+    VELOX_CHECK_GT(companionFunctions.mergeExtract.size(), 1);
+    auto mergeExtractFunctionName =
+        getMergeExtractFunctionNameWithSuffix(functionName, argTypes);
+    mergeExtractExpression =
+        fmt::format("{0}(a{1}) as a{1}", mergeExtractFunctionName, index);
+  }
+
+  // Construct the extract expression.
   std::string extractExpression;
   if (companionFunctions.extract.size() == 1) {
     extractExpression = fmt::format(
@@ -264,7 +304,11 @@ std::tuple<std::string, std::string, std::string> getCompanionAggregates(
     extractExpression =
         fmt::format("{0}(a{1}) as a{1}", extractFunctionName, index);
   }
-  return std::make_tuple(partialAggregate, mergeAggregate, extractExpression);
+  return CompanionFunctions{
+      partialAggregate,
+      mergeAggregate,
+      mergeExtractExpression,
+      extractExpression};
 }
 
 // Given a list of aggregation expressions, e.g., {"avg(c0)"}, return a list of
@@ -390,6 +434,7 @@ void AggregationTestBase::testAggregationsWithCompanion(
 
   std::vector<std::string> partialAggregates;
   std::vector<std::string> mergeAggregates;
+  std::vector<std::string> mergeExtractAggregates;
   std::vector<std::string> extractExpressions;
   extractExpressions.insert(
       extractExpressions.end(), groupingKeys.begin(), groupingKeys.end());
@@ -400,16 +445,16 @@ void AggregationTestBase::testAggregationsWithCompanion(
         exec::getCompanionFunctionSignatures(functionNames[i]);
     VELOX_CHECK(companionSignatures.has_value());
 
-    const auto& [partialAggregate, mergeAggregate, extractAggregate] =
-        getCompanionAggregates(
-            i,
-            *companionSignatures,
-            functionNames[i],
-            aggregateArgs[i],
-            aggregatesArgTypes[i]);
-    partialAggregates.push_back(partialAggregate);
-    mergeAggregates.push_back(mergeAggregate);
-    extractExpressions.push_back(extractAggregate);
+    const auto& companionFunctions = getCompanionAggregates(
+        i,
+        *companionSignatures,
+        functionNames[i],
+        aggregateArgs[i],
+        aggregatesArgTypes[i]);
+    partialAggregates.push_back(companionFunctions.partialFunction);
+    mergeAggregates.push_back(companionFunctions.mergeFunction);
+    mergeExtractAggregates.push_back(companionFunctions.mergeExtractFunction);
+    extractExpressions.push_back(companionFunctions.extractFunction);
   }
 
   {
@@ -534,6 +579,28 @@ void AggregationTestBase::testAggregationsWithCompanion(
     assertResults(queryBuilder);
   }
 
+  {
+    SCOPED_TRACE("Run partial + intermediate + final merge extract");
+    PlanBuilder builder(pool());
+    builder.values(dataWithExtraGroupingKey);
+    preAggregationProcessing(builder);
+
+    builder.partialAggregation(groupingKeysWithPartialKey, partialAggregates)
+        .intermediateAggregation()
+        .finalAggregation()
+        .partialAggregation(groupingKeys, mergeExtractAggregates)
+        .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());
@@ -709,8 +776,9 @@ void AggregationTestBase::testReadFromFiles(
     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));
+    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.
@@ -1202,30 +1270,6 @@ void AggregationTestBase::testAggregations(
   }
 }
 
-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,
@@ -1254,7 +1298,9 @@ std::unique_ptr<exec::Aggregate> createAggregateFunction(
     const std::vector<TypePtr>& inputTypes,
     HashStringAllocator& allocator,
     const std::unordered_map<std::string, std::string>& config) {
-  auto [intermediateType, finalType] = getResultTypes(functionName, inputTypes);
+  auto finalType = exec::resolveResultType(functionName, inputTypes);
+  auto intermediateType =
+      exec::resolveIntermediateType(functionName, inputTypes);
   core::QueryConfig queryConfig({config});
   auto func = exec::Aggregate::create(
       functionName,
@@ -1265,10 +1311,6 @@ std::unique_ptr<exec::Aggregate> createAggregateFunction(
   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;
 }
 
@@ -1324,10 +1366,13 @@ void AggregationTestBase::testIncrementalAggregation(
     func->addSingleGroupRawInput(
         group.data(), SelectivityVector(inputSize), input, false);
 
+    auto finalType =
+        exec::resolveResultType(functionName, aggregate.rawInputTypes);
+    auto intermediateType =
+        exec::resolveIntermediateType(functionName, aggregate.rawInputTypes);
+
     // 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);
@@ -1380,7 +1425,11 @@ VectorPtr AggregationTestBase::testStreaming(
     func->addRawInput(
         groups.data(), SelectivityVector(rawInput1Size), rawInput1, false);
   }
-  auto intermediateType = func->intermediateType(functionName, rawInputTypes);
+
+  auto finalType = exec::resolveResultType(functionName, rawInputTypes);
+  auto intermediateType =
+      exec::resolveIntermediateType(functionName, rawInputTypes);
+
   auto intermediate = BaseVector::create(intermediateType, 1, pool());
   func->extractAccumulators(groups.data(), 1, &intermediate);
   // Destroy accumulators to avoid memory leak.
diff --git a/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt b/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt
index 13845ff4f9bd..bdb9ebe1ef8c 100644
--- a/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt
+++ b/velox/functions/lib/aggregates/tests/utils/CMakeLists.txt
@@ -14,5 +14,4 @@
 
 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)
+target_link_libraries(velox_functions_aggregates_test_lib velox_exec_test_lib velox_vector_test_lib)
diff --git a/velox/functions/lib/benchmarks/CMakeLists.txt b/velox/functions/lib/benchmarks/CMakeLists.txt
index 19306d2b3138..86f62a40ccc6 100644
--- a/velox/functions/lib/benchmarks/CMakeLists.txt
+++ b/velox/functions/lib/benchmarks/CMakeLists.txt
@@ -21,4 +21,5 @@ target_link_libraries(
   velox_vector_test_lib
   velox_vector_fuzzer
   Folly::folly
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
diff --git a/velox/functions/lib/sfm/CMakeLists.txt b/velox/functions/lib/sfm/CMakeLists.txt
new file mode 100644
index 000000000000..fa8fe5169852
--- /dev/null
+++ b/velox/functions/lib/sfm/CMakeLists.txt
@@ -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.
+
+velox_add_library(velox_functions_sfm SfmSketch.cpp SfmSketchAccumulator.cpp)
+
+velox_link_libraries(velox_functions_sfm velox_common_base velox_memory Folly::folly)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/functions/lib/sfm/MersenneTwisterRandomizationStrategy.h b/velox/functions/lib/sfm/MersenneTwisterRandomizationStrategy.h
new file mode 100644
index 000000000000..00cba06fc2fd
--- /dev/null
+++ b/velox/functions/lib/sfm/MersenneTwisterRandomizationStrategy.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 <optional>
+#include <random>
+#include "velox/functions/lib/sfm/RandomizationStrategy.h"
+
+namespace facebook::velox::functions::sfm {
+
+/// A pseudorandomness strategy used to merge SfmSketches.
+class MersenneTwisterRandomizationStrategy : public RandomizationStrategy {
+ public:
+  explicit MersenneTwisterRandomizationStrategy(
+      std::optional<int32_t> seed = {}) {
+    if (seed.has_value()) {
+      rng_.seed(seed.value());
+    }
+  }
+
+  bool nextBoolean(double probability) override {
+    std::uniform_real_distribution<double> dist(0.0, 1.0);
+    return dist(rng_) < probability;
+  }
+
+ private:
+  std::mt19937_64 rng_;
+};
+} // namespace facebook::velox::functions::sfm
diff --git a/velox/functions/lib/sfm/RandomizationStrategy.h b/velox/functions/lib/sfm/RandomizationStrategy.h
new file mode 100644
index 000000000000..e7767ca0a482
--- /dev/null
+++ b/velox/functions/lib/sfm/RandomizationStrategy.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
+
+namespace facebook::velox::functions::sfm {
+
+/// Interface for randomization strategy. We will implement different
+/// randomization strategies in merging, enable-privacy and testing.
+class RandomizationStrategy {
+ public:
+  virtual bool nextBoolean(double probability) = 0;
+
+  virtual ~RandomizationStrategy() = default;
+};
+
+} // namespace facebook::velox::functions::sfm
diff --git a/velox/functions/lib/sfm/SecureRandomizationStrategy.h b/velox/functions/lib/sfm/SecureRandomizationStrategy.h
new file mode 100644
index 000000000000..5fcab41ef12c
--- /dev/null
+++ b/velox/functions/lib/sfm/SecureRandomizationStrategy.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 <folly/Random.h>
+#include "velox/functions/lib/sfm/RandomizationStrategy.h"
+
+namespace facebook::velox::functions::sfm {
+
+/// A secure randomization strategy used to enable differential privacy for
+/// SfmSketch.
+class SecureRandomizationStrategy : public RandomizationStrategy {
+ public:
+  bool nextBoolean(double probability) override {
+    // folly random generate random number in [0, 1)
+    return folly::Random::secureRandDouble01() < probability;
+  }
+};
+
+} // namespace facebook::velox::functions::sfm
diff --git a/velox/functions/lib/sfm/SfmSketch.cpp b/velox/functions/lib/sfm/SfmSketch.cpp
new file mode 100644
index 000000000000..cc26300be683
--- /dev/null
+++ b/velox/functions/lib/sfm/SfmSketch.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 "velox/functions/lib/sfm/SfmSketch.h"
+#include <cmath>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/base/IOUtils.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/sfm/MersenneTwisterRandomizationStrategy.h"
+#include "velox/functions/lib/sfm/SecureRandomizationStrategy.h"
+
+namespace facebook::velox::functions::sfm {
+
+namespace {
+void validateNumIndexBits(int32_t numIndexBits) {
+  VELOX_CHECK_LE(numIndexBits, 16, "numIndexBits must be <= 16.");
+  VELOX_CHECK_GE(numIndexBits, 1, "numIndexBits must be >= 1.");
+}
+
+int32_t numberOfTrailingZeros(uint64_t hash, int32_t numIndexBits) {
+  // Set the lowest bit in the prefix to ensure value is non-zero.
+  constexpr int32_t kBitWidth = sizeof(uint64_t) * 8;
+  const uint64_t value = hash | (1ULL << (kBitWidth - numIndexBits));
+
+  // Safe to call because value is guaranteed non-zero.
+  return __builtin_ctzll(value);
+}
+} // namespace
+
+using Allocator = StlAllocator<int8_t>;
+
+SfmSketch::SfmSketch(
+    HashStringAllocator* allocator,
+    std::optional<int32_t> seed)
+    : bits_{Allocator(allocator)} {
+  if (seed.has_value()) {
+    randomizationStrategy_ = MersenneTwisterRandomizationStrategy(*seed);
+  }
+}
+
+void SfmSketch::initialize(int32_t buckets, int32_t precision) {
+  const auto numIndexBits = SfmSketch::numIndexBits(buckets);
+  validateNumIndexBits(numIndexBits);
+
+  VELOX_CHECK_LE(
+      precision + numIndexBits,
+      64,
+      "Precision + numIndexBits cannot exceed 64");
+  numBuckets_ = buckets;
+  numIndexBits_ = numIndexBits;
+  precision_ = precision;
+
+  bits_.resize(bits::nbytes(buckets * precision));
+  rawBits_ = reinterpret_cast<uint64_t*>(bits_.data());
+}
+
+void SfmSketch::addHash(uint64_t hash) {
+  const auto bucketIndex = computeIndex(hash, numIndexBits_);
+  // Cap the number of trailing zeros to precision - 1, to avoid out of
+  // bounds.
+  const auto zeros =
+      std::min(precision_ - 1, numberOfTrailingZeros(hash, numIndexBits_));
+  setBitTrue(bucketIndex, zeros);
+}
+
+void SfmSketch::addIndexAndZeros(int32_t bucketIndex, int32_t zeros) {
+  VELOX_CHECK_GE(bucketIndex, 0, "Bucket index out of range.");
+  VELOX_CHECK_LT(bucketIndex, numBuckets_, "Bucket index out of range.");
+  VELOX_CHECK_GE(zeros, 0, "Zeros must be greater than or equal to 0.");
+  VELOX_CHECK_LE(zeros, 64, "Zeros must be less than or equal to 64.");
+  VELOX_CHECK(isInitialized(), "Sketch is not initialized.");
+
+  // Count of zeros in range [0, precision - 1].
+  zeros = std::min(precision_ - 1, zeros);
+  setBitTrue(bucketIndex, zeros);
+}
+
+// static
+int32_t SfmSketch::computeIndex(uint64_t hash, int32_t numIndexBits) {
+  validateNumIndexBits(numIndexBits);
+  constexpr int32_t kBitWidth = 64; // The hash is 64 bits.
+  return static_cast<int32_t>(hash >> (kBitWidth - numIndexBits));
+}
+
+// static
+int32_t SfmSketch::numBuckets(int32_t numIndexBits) {
+  validateNumIndexBits(numIndexBits);
+  return 1 << numIndexBits;
+}
+
+// static
+int32_t SfmSketch::numIndexBits(int32_t buckets) {
+  VELOX_CHECK_GT(buckets, 0, "Number of buckets must be greater than 0.");
+  VELOX_CHECK_EQ(
+      buckets & (buckets - 1), 0, "Number of buckets must be power of 2.");
+  return static_cast<int32_t>(std::log2(buckets));
+}
+
+// static
+double SfmSketch::calculateRandomizedResponseProbability(double epsilon) {
+  if (epsilon == kNonPrivateEpsilon) {
+    return 0.0;
+  }
+  return 1.0 / (1.0 + exp(epsilon));
+}
+
+void SfmSketch::mergeWith(const SfmSketch& other) {
+  VELOX_CHECK_EQ(
+      precision_,
+      other.precision_,
+      "Cannot merge two SFM sketches with different precision");
+  VELOX_CHECK_EQ(
+      numIndexBits_,
+      other.numIndexBits_,
+      "Cannot merge two SFM sketches with different numIndexBits");
+  VELOX_CHECK(isInitialized(), "Sketch is not initialized.");
+  const auto numBits = precision_ * numBuckets_;
+
+  // If neither sketch is private, we just take the OR of the sketches.
+  if (!privacyEnabled() && !other.privacyEnabled()) {
+    bits::orBits(rawBits_, other.rawBits_, 0, numBits);
+  } else {
+    // If either sketch is private, we combine using a randomized merge.
+    const double p1 = randomizedResponseProbability_;
+    const double p2 = other.randomizedResponseProbability_;
+    const double p = mergeRandomizedResponseProbabilities(p1, p2);
+    const double normalizer = (1 - 2 * p) / ((1 - 2 * p1) * (1 - 2 * p2));
+
+    if (!randomizationStrategy_.has_value()) {
+      randomizationStrategy_ = MersenneTwisterRandomizationStrategy();
+    }
+
+    for (int32_t i = 0; i < numBits; i++) {
+      const double bit1 = bits::isBitSet(rawBits_, i) ? 1.0 : 0.0;
+      const double bit2 = bits::isBitSet(other.rawBits_, i) ? 1.0 : 0.0;
+      const double x =
+          1 - 2 * p - normalizer * (1 - p1 - bit1) * (1 - p2 - bit2);
+      double probability = p + normalizer * x;
+      probability = std::min(1.0, std::max(0.0, probability));
+
+      bits::setBit(
+          rawBits_, i, randomizationStrategy_->nextBoolean(probability));
+    }
+  }
+
+  randomizedResponseProbability_ = mergeRandomizedResponseProbabilities(
+      randomizedResponseProbability_, other.randomizedResponseProbability_);
+}
+
+void SfmSketch::enablePrivacy(double epsilon) {
+  VELOX_CHECK(isInitialized(), "Sketch is not initialized.");
+  VELOX_CHECK(!privacyEnabled(), "Privacy is already enabled.");
+  VELOX_CHECK_GT(
+      epsilon, 0, "Epsilon must be greater than zero or equal to infinity");
+  randomizedResponseProbability_ =
+      calculateRandomizedResponseProbability(epsilon);
+
+  auto applyRandomization = [this](auto& randomizationStrategy) {
+    // Toggle each bit with a randomly generated probability.
+    // If seed is provided, use it to generate a deterministic randomization.
+    // Otherwise, use a secure randomization strategy.
+    const auto numBits = precision_ * numBuckets_;
+    for (int32_t i = 0; i < numBits; ++i) {
+      if (randomizationStrategy.nextBoolean(randomizedResponseProbability_)) {
+        bits::negateBit(bits_.data(), i);
+      }
+    }
+  };
+
+  // If randomizationStrategy_ is now set, it's guaranteed to be a deterministic
+  // randomization strategy set in constructor, otherwise it would have
+  // been set in private sketch merge which only happens after enablePrivacy().
+  if (randomizationStrategy_.has_value()) {
+    applyRandomization(*randomizationStrategy_);
+  } else {
+    SecureRandomizationStrategy randomizationStrategy;
+    applyRandomization(randomizationStrategy);
+  }
+}
+
+int32_t SfmSketch::countBits() const {
+  return bits::countBits(rawBits_, 0, precision_ * numBuckets_);
+}
+
+int64_t SfmSketch::cardinality() const {
+  VELOX_CHECK(isInitialized(), "Sketch is not initialized.");
+  // Handle empty sketch case.
+  if (countBits() == 0) {
+    return 0;
+  }
+
+  double guess = 1.0;
+  double changeInGuess = std::numeric_limits<double>::infinity();
+  int32_t iterations = 0;
+
+  while (std::abs(changeInGuess) > 0.1 && iterations < kMaxIteration) {
+    changeInGuess = -logLikelihoodFirstDerivative(guess) /
+        logLikelihoodSecondDerivative(guess);
+    guess += changeInGuess;
+    iterations++;
+  }
+
+  // Handle NaN values, which is unlikely from any real sketch but can happen.
+  // We add the check here to avoid undefined behavior.
+  if (std::isnan(guess)) {
+    return 0;
+  }
+
+  // Clamp negative values to 0 before rounding to avoid undefined behavior
+  // when casting negative values to unsigned types.
+  const double clampedGuess = std::max(0.0, guess);
+  const double roundedGuess = std::round(clampedGuess);
+  VELOX_CHECK_LT(
+      roundedGuess, static_cast<double>(std::numeric_limits<int64_t>::max()));
+  return static_cast<int64_t>(roundedGuess);
+}
+
+// Java-compatible format: FORMAT_TAG + numIndexBits + precision +
+// randomizedResponseProbability + compactBitSize + bitsData.
+int32_t SfmSketch::serializedSize() const {
+  return static_cast<int32_t>(
+      sizeof(int8_t) + sizeof(int32_t) + sizeof(int32_t) + sizeof(double) +
+      sizeof(int32_t) + compactBitSize());
+}
+
+void SfmSketch::serialize(char* out) const {
+  common::OutputByteStream stream(out);
+  stream.appendOne(kFormatTag);
+  stream.appendOne(numIndexBits_);
+  stream.appendOne(precision_);
+  stream.appendOne(randomizedResponseProbability_);
+  const auto compactBitSize = this->compactBitSize();
+  stream.appendOne(compactBitSize);
+
+  // Only append data if the vector is not empty to avoid null pointer issues.
+  if (compactBitSize > 0) {
+    stream.append(reinterpret_cast<const char*>(bits_.data()), compactBitSize);
+  }
+}
+
+SfmSketch SfmSketch::deserialize(
+    const char* in,
+    HashStringAllocator* allocator) {
+  common::InputByteStream stream(in);
+  const auto formatTag = stream.read<int8_t>();
+  const auto numIndexBits = stream.read<int32_t>();
+  const auto precision = stream.read<int32_t>();
+  const auto randomizedResponseProbability = stream.read<double>();
+  const auto compactBitSize = stream.read<int32_t>();
+
+  // Validate format tag.
+  VELOX_CHECK_EQ(formatTag, kFormatTag, "Invalid format tag");
+
+  // Validate numIndexBits before calling numBuckets.
+  validateNumIndexBits(numIndexBits);
+
+  // Create the sketch.
+  SfmSketch sketch(allocator);
+  const auto buckets = numBuckets(numIndexBits);
+  sketch.initialize(buckets, precision);
+
+  // Set the randomized response probability.
+  sketch.randomizedResponseProbability_ = randomizedResponseProbability;
+
+  // Read the serialized bitmap data directly into the sketch's bitset.
+  // The sketch's bitset is already the correct size and zero-initialized.
+  // We just need to copy the serialized data (which may be truncated).
+  stream.copyTo(sketch.bits_.data(), compactBitSize);
+
+  return sketch;
+}
+
+double SfmSketch::observationProbability(int32_t level) const {
+  return std::pow(2.0, -(level + 1.0)) / numBuckets_;
+}
+
+int32_t SfmSketch::compactBitSize() const {
+  // Find the last non-zero byte.
+  const int32_t lastSetBit =
+      bits::findLastBit(rawBits_, 0, precision_ * numBuckets_);
+
+  if (lastSetBit < 0) {
+    // No bits are set.
+    return 0;
+  }
+  return bits::nbytes(lastSetBit + 1);
+}
+
+double SfmSketch::logLikelihoodFirstDerivative(double n) const {
+  double result = 0.0;
+  for (int32_t level = 0; level < precision_; level++) {
+    const double termOn = logLikelihoodTermFirstDerivative(level, true, n);
+    const double termOff = logLikelihoodTermFirstDerivative(level, false, n);
+    for (int32_t bucket = 0; bucket < numBuckets_; bucket++) {
+      int32_t bitPosition = level * numBuckets_ + bucket;
+      result += bits::isBitSet(bits_.data(), bitPosition) ? termOn : termOff;
+    }
+  }
+  return result;
+}
+
+double SfmSketch::logLikelihoodTermFirstDerivative(
+    int32_t level,
+    bool on,
+    double n) const {
+  const double p = observationProbability(level);
+  const int32_t sign = on ? -1 : 1;
+  const double c1 = on ? onProbability() : 1 - onProbability();
+  const double c2 = onProbability() - randomizedResponseProbability_;
+  return std::log1p(-p) * (1 - c1 / (c1 + sign * c2 * std::pow(1 - p, n)));
+}
+
+double SfmSketch::logLikelihoodSecondDerivative(double n) const {
+  double result = 0.0;
+  for (int32_t level = 0; level < precision_; level++) {
+    const double termOn = logLikelihoodTermSecondDerivative(level, true, n);
+    const double termOff = logLikelihoodTermSecondDerivative(level, false, n);
+    for (int32_t bucket = 0; bucket < numBuckets_; bucket++) {
+      const int32_t bitPosition = level * numBuckets_ + bucket;
+      result += bits::isBitSet(bits_.data(), bitPosition) ? termOn : termOff;
+    }
+  }
+  return result;
+}
+
+double SfmSketch::logLikelihoodTermSecondDerivative(
+    int32_t level,
+    bool on,
+    double n) const {
+  const double p = observationProbability(level);
+  const int32_t sign = on ? -1 : 1;
+  const double c1 = on ? onProbability() : 1 - onProbability();
+  const double c2 = onProbability() - randomizedResponseProbability_;
+  return sign * c1 * c2 * std::pow(std::log1p(-p), 2) * std::pow(1 - p, n) *
+      std::pow(c1 + sign * c2 * std::pow(1 - p, n), -2);
+}
+
+void SfmSketch::setBitTrue(int32_t bucketIndex, int32_t zeros) {
+  VELOX_CHECK(!privacyEnabled(), "Private sketch is immutable.");
+  // It's more likely to have a hash with less zeros than more zeros.
+  // We keep the bitmap in the form of a bit matrix, where each row is a zero
+  // level instead of a bucket.
+  // In this way, we can save space by dropping the trailing zeros in
+  // serialization.
+  const auto bitPosition = zeros * numBuckets_ + bucketIndex;
+  bits::setBit(bits_.data(), bitPosition, true);
+}
+
+} // namespace facebook::velox::functions::sfm
diff --git a/velox/functions/lib/sfm/SfmSketch.h b/velox/functions/lib/sfm/SfmSketch.h
new file mode 100644
index 000000000000..9e529a280a3b
--- /dev/null
+++ b/velox/functions/lib/sfm/SfmSketch.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
+
+#define XXH_INLINE_ALL
+#include <xxhash.h> // @manual=third-party//xxHash:xxhash
+
+#include <folly/Range.h>
+#include <cstdint>
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/sfm/MersenneTwisterRandomizationStrategy.h"
+
+namespace facebook::velox::functions::sfm {
+
+/// SFM sketch is used for estimating distinct count, very similar to
+/// HyperLogLog. This sketch is introduced in the paper Sketch-Flip-Merge:
+/// Mergeable Sketches for Private Distinct Counting
+/// <https://arxiv.org/pdf/2302.02056.pdf>.
+
+/// The primary differences between SFM sketch and HyperLogLog are that
+///  (a) SFM sketch supports noise addition.
+///  (b) SFM sketch tracks a larger number of hash statistics (and is therefore
+///  larger).
+
+/// The SFM sketch data structure is initially created without noise.
+/// Noise is added by randomizing the bits of the sketch via the
+/// enablePrivacy() function. Once noise has been added, further items
+/// cannot be added to the sketch. However, two or more noisy sketches may be
+/// merged together. A typical work flow is: initialize -> add -> merge/
+/// enablePrivacy -> cardinality.
+
+/// The noise level is quantified by the parameter 'epsilon', a positive real
+/// number. A smaller value of 'epsilon' corresponds to a more noisy sketch.
+/// An 'epsilon' of 0 would yield a summary that is entirely noise, while an
+/// 'epsilon' that is infinite yields no noise. The estimated cardinality
+/// becomes less accurate with the addition of more noise (i.e., smaller
+/// 'epsilon' yield less accurate results. bits of the sketch are randomized
+/// with probability 1 / (1 + exp(epsilon)), an epsilon of 1 will flip about
+/// 1 / (1 + exp(1)) = 27% of the bits of the sketch).
+class SfmSketch {
+ public:
+  /// Creates an uninitialized instance. The caller must call initialize()
+  /// before using this instance. If seed is provided, the instance will
+  /// initialize a deterministic randomization strategy, which is useful for
+  /// testing. The deterministic randomization strategy is not retained in the
+  /// serialized sketch.
+  SfmSketch(HashStringAllocator* allocator, std::optional<int32_t> seed = {});
+
+  /// Specify the sketch size. The size is determined by the number of buckets
+  /// and precision. The sketch uses buckets * precision bits or (buckets *
+  /// precision) / 8 bytes.
+
+  /// When adding items to the sketch, we compute a 64-bit hash of the item,
+  /// then use first n bits as a bucket index and last precision bits to count
+  /// zeros. n = log2(buckets) so that buckets = 2^n. Hence, buckets must be a
+  /// power of two and n + precision must be <= 64.
+
+  /// This function should be called before any other functions.
+
+  /// @param buckets The number of buckets, should be a power of 2:
+  /// buckets = 2 ^ n. Later, n is referred to as numIndexBits.
+  /// @param precision The number of bits to count trailing zeros in a hash.
+  /// precision + n must be <= 64.
+  void initialize(int32_t buckets, int32_t precision);
+
+  /// @tparam T StringView, bigint, or double.
+  template <typename T>
+  void add(T value) {
+    VELOX_CHECK(isInitialized(), "Sketch is not initialized.");
+    addHash(XXH64(
+        reinterpret_cast<const void*>(&value),
+        sizeof(value),
+        /*seed*/ 0));
+  }
+
+  /// Another way to add an element to the sketch. Explicitly toggle the bit at
+  /// 'bucketIndex' and 'zeros' position.
+  void addIndexAndZeros(int32_t bucketIndex, int32_t zeros);
+
+  /// Compute the bit index with the given hash and numIndexBits.
+  static int32_t computeIndex(uint64_t hash, int32_t numIndexBits);
+
+  /// Compute the number of buckets given the numIndexBits.
+  /// @return 2 ^ numIndexBits.
+  static int32_t numBuckets(int32_t numIndexBits);
+
+  /// Compute the number of bits needed to represent the index of a bucket.
+  /// Range of numIndexBits is [1, 16].
+  /// @return log2(buckets).
+  static int32_t numIndexBits(int32_t buckets);
+
+  /// Merge another sketch into the current sketch. Items can be added to the
+  /// sketch after merging as long as the sketch is not private.
+  void mergeWith(const SfmSketch& other);
+
+  /// Make a non-private sketch private. This function is called
+  /// after adding all the items to the sketch to add noise to the sketch and
+  /// before calling cardinality().
+  /// @param epsilon The privacy parameter, the larger the epsilon, the less
+  /// noise will be added. The range of epsilon is (0, inf].
+  void enablePrivacy(double epsilon);
+
+  /// Estimate the number of distinct items added to the sketch via maximum
+  /// pseudolikelihood (Newton's method).
+  int64_t cardinality() const;
+
+  /// Return the size of the serialized sketch in bytes.
+  int32_t serializedSize() const;
+
+  /// Serialize the sketch into pre-allocated buffer of at least
+  /// 'serializedSize()' bytes. The Java serialization format is used in
+  /// production, so we need to ensure that the C++ implementation can read and
+  /// write the same format.
+  /// The Java serialization format is as follows:
+  /// 1. 1 byte for the FORMAT_TAG = 7, constant.
+  /// 2. 4 bytes for the numIndexBits.
+  /// 3. 4 bytes for the precision.
+  /// 4. 8 bytes for the randomized response probability.
+  /// 5. 4 bytes for the actual number of bytes in the serialized bits.
+  /// 6. The bits data.
+  void serialize(char* out) const;
+
+  /// Deserialize the sketch from a pre-allocated buffer of at least
+  /// 'serializedSize()' bytes.
+  static SfmSketch deserialize(const char* in, HashStringAllocator* allocator);
+
+  int32_t numIndexBits() const {
+    return numIndexBits_;
+  }
+
+  int32_t precision() const {
+    return precision_;
+  }
+
+  bool privacyEnabled() const {
+    return randomizedResponseProbability_ > 0;
+  }
+
+  // Check if the sketch is initialized.
+  bool isInitialized() const {
+    return numIndexBits_ > 0;
+  }
+
+ private:
+  // Epsilon for non-private sketch.
+  static constexpr double kNonPrivateEpsilon =
+      std::numeric_limits<double>::infinity();
+
+  // Maximum number of iterations for Newton's method.
+  static constexpr int32_t kMaxIteration = 1000;
+
+  // Java implementation use a format_tag to identify the sketch.
+  // We need this tag to be able to deserialize the sketch from Java.
+  static constexpr int8_t kFormatTag = 7;
+
+  // Calculate the RandomizedResponseProbabilities for merged sketches.
+  // For math details, see Theorem 4.8,
+  // <a href="https://arxiv.org/pdf/2302.02056.pdf">arXiv:2302.02056</a>.
+  static double mergeRandomizedResponseProbabilities(double p1, double p2) {
+    return (p1 + p2 - 3 * p1 * p2) / (1 - 2 * p1 * p2);
+  }
+
+  // Calculate the randomized response probability given epsilon.
+  static double calculateRandomizedResponseProbability(double epsilon);
+
+  // Add a hash to the sketch.
+  void addHash(uint64_t hash);
+
+  // Probability of a 1-bit remaining a 1-bit under randomized response.
+  double onProbability() const {
+    return 1 - randomizedResponseProbability_;
+  }
+
+  // Get the number of bits that are set to 1.
+  int32_t countBits() const;
+
+  // Return the size of the bits in bytes after dropping the trailing zeros.
+  int32_t compactBitSize() const;
+
+  // Probability of observing a run of zeros of length level in any single
+  // bucket.
+  double observationProbability(int32_t level) const;
+
+  // Set the bit at given bucketIndex and zeros position.
+  void setBitTrue(int32_t bucketIndex, int32_t zeros);
+
+  // Helper functions for cardinality estimation using Newton's method.
+  double logLikelihoodFirstDerivative(double n) const;
+  double logLikelihoodTermFirstDerivative(int32_t level, bool on, double n)
+      const;
+  double logLikelihoodSecondDerivative(double n) const;
+  double logLikelihoodTermSecondDerivative(int32_t level, bool on, double n)
+      const;
+
+  // Number of buckets in the sketch.
+  int32_t numBuckets_{0};
+
+  // Number of bits to represent the index of a bucket. We use first
+  // numIndexBits bits of a hash to represent the index of a bucket, meaning
+  // that total number of buckets is 2 ^ numIndexBits, and max index is
+  // 2 ^ numIndexBits - 1.
+  int32_t numIndexBits_{0};
+
+  // Number of bits to count trailing zeros in a hash value.
+  int32_t precision_{0};
+
+  // Probability of a bit being flipped.
+  double randomizedResponseProbability_{0.0};
+
+  // The underline bit representation of the sketch.
+  std::vector<int8_t, facebook::velox::StlAllocator<int8_t>> bits_;
+
+  // Pointer to the raw bits.
+  uint64_t* rawBits_{nullptr};
+
+  // Optional randomization strategy. If seed is provided at construction, the
+  // instance will initialize a deterministic randomization strategy.
+  // Otherwise the randomization strategy will be initialized unseeded when
+  // merging private sketches.
+  std::optional<MersenneTwisterRandomizationStrategy> randomizationStrategy_;
+};
+} // namespace facebook::velox::functions::sfm
diff --git a/velox/functions/lib/sfm/SfmSketchAccumulator.cpp b/velox/functions/lib/sfm/SfmSketchAccumulator.cpp
new file mode 100644
index 000000000000..67d1addd81fa
--- /dev/null
+++ b/velox/functions/lib/sfm/SfmSketchAccumulator.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 "velox/functions/lib/sfm/SfmSketchAccumulator.h"
+#include "velox/common/base/IOUtils.h"
+
+namespace facebook::velox::functions::sfm {
+SfmSketchAccumulator::SfmSketchAccumulator(HashStringAllocator* allocator)
+    : sketch_(allocator) {}
+
+SfmSketchAccumulator::SfmSketchAccumulator(
+    double epsilon,
+    int32_t buckets,
+    int32_t precision,
+    SfmSketch&& sketch)
+    : epsilon_{epsilon},
+      buckets_{buckets},
+      precision_{precision},
+      sketch_{std::move(sketch)} {}
+
+void SfmSketchAccumulator::initialize(
+    std::optional<int32_t> buckets,
+    std::optional<int32_t> precision) {
+  const auto initBuckets = buckets.value_or(kDefaultBuckets);
+  const auto initPrecision = precision.value_or(kDefaultPrecision);
+  sketch_.initialize(initBuckets, initPrecision);
+  buckets_ = initBuckets;
+  precision_ = initPrecision;
+}
+
+const SfmSketch& SfmSketchAccumulator::sketch() {
+  VELOX_CHECK(isInitialized(), "Sketch is not set");
+  if (!sketch_.privacyEnabled() && epsilon_ > 0) {
+    sketch_.enablePrivacy(epsilon_);
+  }
+  return sketch_;
+}
+
+size_t SfmSketchAccumulator::serializedSize() const {
+  return sizeof(epsilon_) + sizeof(buckets_) + sizeof(precision_) +
+      sketch_.serializedSize();
+}
+
+void SfmSketchAccumulator::serialize(char* outputBuffer) const {
+  common::OutputByteStream stream(outputBuffer);
+  stream.appendOne(epsilon_);
+  stream.appendOne(buckets_);
+  stream.appendOne(precision_);
+  sketch_.serialize(outputBuffer + stream.offset());
+}
+
+SfmSketchAccumulator SfmSketchAccumulator::deserialize(
+    const char* inputBuffer,
+    HashStringAllocator* allocator) {
+  common::InputByteStream stream(inputBuffer);
+  const auto epsilon = stream.read<double>();
+  const auto buckets = stream.read<int32_t>();
+  const auto precision = stream.read<int32_t>();
+  return SfmSketchAccumulator{
+      epsilon,
+      buckets,
+      precision,
+      SfmSketch::deserialize(inputBuffer + stream.offset(), allocator)};
+}
+
+void SfmSketchAccumulator::mergeWith(SfmSketchAccumulator& other) {
+  if (!other.isInitialized()) {
+    return;
+  }
+  if (!isInitialized()) {
+    epsilon_ = other.epsilon_;
+    this->initialize(other.buckets_, other.precision_);
+  }
+  sketch_.mergeWith(other.sketch_);
+}
+
+void SfmSketchAccumulator::addIndexAndZeros(
+    int32_t bucketIndex,
+    int32_t zeros) {
+  VELOX_CHECK(isInitialized(), "Sketch is not set");
+  sketch_.addIndexAndZeros(bucketIndex, zeros);
+}
+
+int64_t SfmSketchAccumulator::cardinality() {
+  VELOX_CHECK(
+      isInitialized(), "Cardinality is not available for empty sketch.");
+  // Add noise to the sketch before computing cardinality.
+  if (!sketch_.privacyEnabled() && epsilon_ > 0) {
+    sketch_.enablePrivacy(epsilon_);
+  }
+  return sketch_.cardinality();
+}
+} // namespace facebook::velox::functions::sfm
diff --git a/velox/functions/lib/sfm/SfmSketchAccumulator.h b/velox/functions/lib/sfm/SfmSketchAccumulator.h
new file mode 100644
index 000000000000..de6ea40c6a84
--- /dev/null
+++ b/velox/functions/lib/sfm/SfmSketchAccumulator.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/sfm/SfmSketch.h"
+
+namespace facebook::velox::functions::sfm {
+
+class SfmSketchAccumulator {
+  static constexpr int32_t kDefaultBuckets = 4096;
+  static constexpr int32_t kDefaultPrecision = 24;
+
+ public:
+  explicit SfmSketchAccumulator(HashStringAllocator* allocator);
+
+  // Constructor with all member variables, used for deserialization.
+  explicit SfmSketchAccumulator(
+      double epsilon,
+      int32_t buckets,
+      int32_t precision,
+      SfmSketch&& sketch);
+
+  // Initialize the sketch with the given parameters.
+  void initialize(
+      std::optional<int32_t> buckets = std::nullopt,
+      std::optional<int32_t> precision = std::nullopt);
+
+  // Apply privacy and return the sketch.
+  const SfmSketch& sketch();
+
+  double epsilon() const {
+    return epsilon_;
+  }
+
+  void setEpsilon(double epsilon) {
+    epsilon_ = epsilon;
+  }
+
+  // Check if the sketch is initialized. If not, the group is null or input is
+  // empty.
+  bool isInitialized() const {
+    return sketch_.isInitialized();
+  }
+
+  size_t serializedSize() const;
+
+  void serialize(char* outputBuffer) const;
+
+  static SfmSketchAccumulator deserialize(
+      const char* inputBuffer,
+      HashStringAllocator* allocator);
+
+  // Add a value to the sketch.
+  template <typename T>
+  void add(T value) {
+    VELOX_CHECK(isInitialized(), "Sketch is not set");
+    sketch_.add(value);
+  }
+
+  // Add a value to the sketch through index and zeros.
+  void addIndexAndZeros(int32_t bucketIndex, int32_t zeros);
+
+  // Merge with another accumulator.
+  void mergeWith(SfmSketchAccumulator& other);
+
+  // Apply privacy with epsilon and return the estimated cardinality.
+  int64_t cardinality();
+
+ private:
+  // Epsilon to make the sketch private.
+  double epsilon_{-1.0};
+
+  // Buckets of the sketch.
+  int32_t buckets_{kDefaultBuckets};
+
+  // Precision of the sketch.
+  int32_t precision_{kDefaultPrecision};
+
+  // The sketch to aggregate cardinality.
+  SfmSketch sketch_;
+};
+
+} // namespace facebook::velox::functions::sfm
diff --git a/velox/functions/lib/sfm/tests/CMakeLists.txt b/velox/functions/lib/sfm/tests/CMakeLists.txt
new file mode 100644
index 000000000000..4fe1b17cd05b
--- /dev/null
+++ b/velox/functions/lib/sfm/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_functions_sfm_test SfmSketchTest.cpp)
+
+add_test(velox_functions_sfm_test velox_functions_sfm_test)
+
+target_link_libraries(
+  velox_functions_sfm_test
+  velox_functions_sfm
+  velox_memory
+  GTest::gtest
+  GTest::gtest_main
+)
diff --git a/velox/functions/lib/sfm/tests/SfmSketchTest.cpp b/velox/functions/lib/sfm/tests/SfmSketchTest.cpp
new file mode 100644
index 000000000000..2c10448cfd68
--- /dev/null
+++ b/velox/functions/lib/sfm/tests/SfmSketchTest.cpp
@@ -0,0 +1,322 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/sfm/SfmSketch.h"
+#include "gtest/gtest.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/encode/Base64.h"
+#include "velox/common/memory/Memory.h"
+
+namespace facebook::velox::functions::sfm {
+
+class SfmSketchTest : public ::testing::Test {
+ public:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+ protected:
+  const int32_t numBuckets_ = 4096;
+  const int32_t precision_ = 24;
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  HashStringAllocator allocator_{pool_.get()};
+};
+
+TEST_F(SfmSketchTest, add) {
+  SfmSketch a(&allocator_, 1);
+  VELOX_ASSERT_THROW(a.add(1), "Sketch is not initialized.");
+
+  a.initialize(numBuckets_, precision_);
+
+  for (int32_t i = 0; i < 1000; i++) {
+    a.add(i);
+  }
+  a.enablePrivacy(3.0);
+  const auto cardinality = a.cardinality();
+
+  // Add the same values through addIndexAndZeros, and check that the
+  // cardinality is the same.
+  auto computeIndexAndZeros = [&](int32_t value) {
+    const auto hash = XXH64(&value, sizeof(value), 0);
+    const int32_t kBitWidth = sizeof(uint64_t) * 8;
+    const auto numIndexBits = static_cast<int32_t>(std::log2(numBuckets_));
+    const uint64_t trailing = hash | (1ULL << (kBitWidth - numIndexBits));
+    const auto index = static_cast<int32_t>(hash >> (kBitWidth - numIndexBits));
+    const auto zeros = __builtin_ctzll(trailing);
+    return std::make_pair(index, zeros);
+  };
+
+  SfmSketch b(&allocator_, 1);
+  b.initialize(numBuckets_, precision_);
+
+  for (int32_t i = 0; i < 1000; i++) {
+    const auto [index, zeros] = computeIndexAndZeros(i);
+    b.addIndexAndZeros(index, zeros);
+  }
+
+  b.enablePrivacy(3.0);
+  ASSERT_EQ(b.cardinality(), cardinality);
+}
+
+TEST_F(SfmSketchTest, enablePrivacy) {
+  SfmSketch sketch(&allocator_);
+  VELOX_ASSERT_THROW(sketch.enablePrivacy(3.0), "Sketch is not initialized.");
+
+  sketch.initialize(numBuckets_, precision_);
+  ASSERT_FALSE(sketch.privacyEnabled());
+
+  sketch.enablePrivacy(std::numeric_limits<double>::infinity());
+  ASSERT_FALSE(sketch.privacyEnabled());
+
+  sketch.enablePrivacy(1.0);
+  ASSERT_TRUE(sketch.privacyEnabled());
+
+  VELOX_ASSERT_THROW(sketch.enablePrivacy(1.0), "Privacy is already enabled.");
+  VELOX_ASSERT_THROW(sketch.add(1), "Private sketch is immutable.");
+}
+
+TEST_F(SfmSketchTest, merge) {
+  SfmSketch a(&allocator_);
+  SfmSketch b(&allocator_);
+  VELOX_ASSERT_THROW(a.mergeWith(b), "Sketch is not initialized.");
+
+  a.initialize(numBuckets_, precision_);
+  b.initialize(numBuckets_, precision_);
+
+  a.add(1);
+  b.add(1);
+
+  a.mergeWith(b);
+
+  // Merging two non-private sketches results in a non-private sketch.
+  ASSERT_FALSE(a.privacyEnabled());
+
+  b.enablePrivacy(3.0);
+  a.mergeWith(b);
+
+  // Merging a private sketch with a non-private sketch results in a private
+  // sketch.
+  ASSERT_TRUE(a.privacyEnabled());
+}
+
+TEST_F(SfmSketchTest, cardinality) {
+  SfmSketch sketch(&allocator_, 3);
+  VELOX_ASSERT_THROW(sketch.cardinality(), "Sketch is not initialized.");
+  sketch.initialize(numBuckets_, precision_);
+
+  // Non-private sketch should have 0 cardinality.
+  ASSERT_EQ(sketch.cardinality(), 0);
+
+  // Private sketch should have approximately 0 cardinality, but not exactly 0.
+  sketch.enablePrivacy(3.0);
+  ASSERT_EQ(sketch.cardinality(), 4);
+
+  struct TestParams {
+    int32_t numDistinct;
+    double epsilon;
+    int32_t expectedCardinality;
+  };
+
+  std::vector<TestParams> testParams = {
+      {10000, 2.0, 9804},
+      {10000, 4.0, 9898},
+      {10000, std::numeric_limits<double>::infinity(), 9926},
+      {100000, 2.0, 101130},
+      {100000, 4.0, 100044},
+      {100000, std::numeric_limits<double>::infinity(), 100332},
+      {1000000, 2.0, 1017354},
+      {1000000, 4.0, 1003236},
+      {1000000, std::numeric_limits<double>::infinity(), 999603}};
+
+  for (const auto& params : testParams) {
+    SCOPED_TRACE(
+        "numDistinct = " + std::to_string(params.numDistinct) +
+        ", epsilon = " + std::to_string(params.epsilon));
+    SfmSketch sketch(&allocator_, 1);
+    sketch.initialize(numBuckets_, precision_);
+
+    for (auto i = 0; i < params.numDistinct; i++) {
+      sketch.add(i);
+    }
+    sketch.enablePrivacy(params.epsilon);
+
+    ASSERT_EQ(sketch.cardinality(), params.expectedCardinality);
+  }
+}
+
+TEST_F(SfmSketchTest, serializationRoundTrip) {
+  SfmSketch sketch(&allocator_);
+  sketch.initialize(numBuckets_, precision_);
+
+  for (int32_t i = 0; i < 10000; i++) {
+    sketch.add(i);
+  }
+
+  sketch.enablePrivacy(4.0);
+  const auto originalCardinality = sketch.cardinality();
+
+  // Allocate buffer for serialization.
+  const auto serializedSize = sketch.serializedSize();
+  std::vector<char> buffer(serializedSize);
+  char* out = buffer.data();
+
+  sketch.serialize(out);
+  auto deserialized = SfmSketch::deserialize(out, &allocator_);
+
+  // Test that the deserialized sketch is the same as the
+  // original.
+  ASSERT_EQ(deserialized.cardinality(), originalCardinality);
+  ASSERT_TRUE(deserialized.privacyEnabled());
+  ASSERT_EQ(sketch.numIndexBits(), deserialized.numIndexBits());
+  ASSERT_EQ(sketch.precision(), deserialized.precision());
+}
+
+TEST_F(SfmSketchTest, cardinalityConsistency) {
+  // This test validates the cardinality estimation functionality of SfmSketch
+  // across multiple scenarios and data sizes:
+  // 1. Duplicate handling
+  // 2. Order independence
+  // 3. Merge consistency
+  // 4. Serialization integrity
+  // 5. Privacy noise behavior
+
+  std::vector<int32_t> dataSizes = {1000, 10000, 100000};
+
+  auto testCardinalityConsistency = [&](int32_t dataSize) {
+    SCOPED_TRACE("dataSize = " + std::to_string(dataSize));
+
+    SfmSketch base(&allocator_, 1);
+    base.initialize(numBuckets_, precision_);
+    for (int32_t i = 0; i < dataSize; i++) {
+      base.add(i);
+    }
+    base.enablePrivacy(8.0);
+
+    // This is the baseCardinality other scenarios will be compared against.
+    // baseCardinality should be approximately dataSize, with a relative error
+    // tolerance.
+    const auto baseCardinality = base.cardinality();
+    ASSERT_NEAR(baseCardinality, dataSize, dataSize * 0.05);
+
+    // Test duplicate handling.
+    SfmSketch a(&allocator_, 1);
+    a.initialize(numBuckets_, precision_);
+    for (int j = 0; j < 10; j++) {
+      for (int32_t i = 0; i < dataSize; i++) {
+        a.add(i);
+      }
+    }
+    a.enablePrivacy(8.0);
+    ASSERT_EQ(baseCardinality, a.cardinality());
+
+    // Test order independence.
+    SfmSketch b(&allocator_, 1);
+    b.initialize(numBuckets_, precision_);
+    // We make sure that 0 - (dataSize-1) are all present in the sketch, but in
+    // random order.
+    std::vector<int32_t> values;
+    values.reserve(dataSize);
+    for (int32_t i = 0; i < dataSize; i++) {
+      values.emplace_back(i);
+    }
+    std::shuffle(values.begin(), values.end(), folly::ThreadLocalPRNG());
+    for (int32_t i = 0; i < dataSize; i++) {
+      b.add(values[i]);
+    }
+
+    // Then we add random duplicate values to the sketch.
+    int32_t duplicateCount = std::max(1, dataSize / 10);
+    for (int32_t i = 0; i < duplicateCount; i++) {
+      b.add(folly::Random::rand32(dataSize));
+    }
+
+    b.enablePrivacy(8.0);
+    ASSERT_EQ(baseCardinality, b.cardinality());
+
+    // Test merge consistency.
+    SfmSketch c(&allocator_, 1);
+    c.initialize(numBuckets_, precision_);
+    SfmSketch d(&allocator_, 1);
+    d.initialize(numBuckets_, precision_);
+    SfmSketch e(&allocator_, 1);
+    e.initialize(numBuckets_, precision_);
+    for (int32_t i = 0; i < dataSize; i++) {
+      if (i % 3 == 0) {
+        c.add(i);
+      } else if (i % 3 == 1) {
+        d.add(i);
+      } else {
+        e.add(i);
+      }
+    }
+    // Merge before enabling privacy.
+    c.mergeWith(d);
+    c.mergeWith(e);
+    c.enablePrivacy(8.0);
+    ASSERT_EQ(baseCardinality, c.cardinality());
+
+    // Test serialization integrity.
+    const auto serializedSize = c.serializedSize();
+    std::vector<char> buffer(serializedSize);
+    char* out = buffer.data();
+    c.serialize(out);
+    auto deserialized = SfmSketch::deserialize(out, &allocator_);
+    ASSERT_EQ(baseCardinality, deserialized.cardinality());
+
+    // Test privacy noise behavior.
+    // Now enable privacy for d and e and merge them into c.
+    // There should be noise added to the merged sketch.
+    d.enablePrivacy(8.0);
+    e.enablePrivacy(8.0);
+    c.mergeWith(d);
+    c.mergeWith(e);
+    ASSERT_NE(baseCardinality, c.cardinality());
+    ASSERT_NEAR(baseCardinality, c.cardinality(), baseCardinality * 0.05);
+  };
+
+  for (const auto dataSize : dataSizes) {
+    testCardinalityConsistency(dataSize);
+  }
+}
+
+TEST_F(SfmSketchTest, javaSerializationCompatibility) {
+  // This test is to ensure that the C++ serialization format is compatible
+  // with the Java serialization format.
+
+  // The string is from a Java sketch serialized with the Java SfmSketch.
+  std::string javaSketchBase64 =
+      "BwgAAAAQAAAAw8JDHvpqkj//AQAA77//////////////v///////////3////7//"
+      "////////////3/////////////////////////////////v//+/+ff/////////"
+      "f///v//+//////////////////////7//////3////v//////3////v/f//////"
+      "///3////v///////v/f///////////////////////////////f///////v/////"
+      "////f///////7////+////9///////////////v//////////////////////////"
+      "////////////f////////////3//////////////7////+////////////////////"
+      "3///////////////////////9///33///v///3////f//f//9//+//////r/3///"
+      "///9//Dfz/e/++vvfV3W//qtq33z//a7///+/m3/fz7/1///1v5hmo/ayTcv3l3Vv"
+      "XmnMr+t/B72YloTNgmBy7+IKv+mIBmaBwSO4GwxBMCwWChIoYSVFTAAIIhLylIEj"
+      "mJLamBAAooMYLQgikgBAUACEAQYJUAmxMGAhDAoBJGgRgAkBCCCAABAAkIIAAAAA"
+      "EQAYEECAQYACgAACEAAQEBAACCAgAAAAQgAAAAAKgAoERABAMAAQbABAAgADEAAQ"
+      "IABQ==";
+
+  // Decode base64 to binary data.
+  std::string decoded = encoding::Base64::decode(javaSketchBase64);
+
+  auto sketch = SfmSketch::deserialize(decoded.c_str(), &allocator_);
+  // Test that the deserialized sketch is the same as the original.
+  ASSERT_EQ(sketch.cardinality(), 927499);
+}
+} // namespace facebook::velox::functions::sfm
diff --git a/velox/functions/lib/string/CMakeLists.txt b/velox/functions/lib/string/CMakeLists.txt
index c24c196c6dfc..4f9f69f90931 100644
--- a/velox/functions/lib/string/CMakeLists.txt
+++ b/velox/functions/lib/string/CMakeLists.txt
@@ -13,8 +13,7 @@
 # limitations under the License.
 velox_add_library(velox_functions_string INTERFACE)
 
-velox_link_libraries(velox_functions_string INTERFACE velox_common_base
-                                                      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 eff3008903e1..745e1ae985de 100644
--- a/velox/functions/lib/string/StringCore.h
+++ b/velox/functions/lib/string/StringCore.h
@@ -43,6 +43,30 @@
 #endif
 
 namespace facebook::velox::functions {
+namespace detail {
+
+// Helper function to check if a character is cased. Compatible with the
+// 'isCased' implementation in 'ConditionalSpecialCasting.java' of JDK, which is
+// used by 'toLowerCase' function in Spark SQL.
+FOLLY_ALWAYS_INLINE bool isCased(utf8proc_int32_t ch) {
+  auto type = utf8proc_category(ch);
+  // Lowercase letter, uppercase letter or titlecase letter.
+  if (type == UTF8PROC_CATEGORY_LL || type == UTF8PROC_CATEGORY_LU ||
+      type == UTF8PROC_CATEGORY_LT) {
+    return true;
+  }
+  // Modifier letters and special cases.
+  if ((ch >= 0x02B0 && ch <= 0x02B8) || (ch >= 0x02C0 && ch <= 0x02C1) ||
+      (ch >= 0x02E0 && ch <= 0x02E4) || ch == 0x0345 || ch == 0x037A ||
+      (ch >= 0x1D2C && ch <= 0x1D61) || (ch >= 0x2160 && ch <= 0x217F) ||
+      (ch >= 0x24B6 && ch <= 0x24E9)) {
+    return true;
+  }
+  return false;
+}
+
+} // namespace detail
+
 namespace stringCore {
 
 /// Check if a given string is ascii
@@ -75,19 +99,20 @@ FOLLY_ALWAYS_INLINE bool isAscii(const char* str, size_t length) {
 FOLLY_ALWAYS_INLINE static void
 reverseAscii(char* output, const char* input, size_t length) {
   auto j = length - 1;
-  VECTORIZE_LOOP_IF_POSSIBLE for (auto i = 0; i < length; ++i, --j) {
+  VECTORIZE_LOOP_IF_POSSIBLE for (size_t i = 0; i < length; ++i, --j) {
     output[i] = input[j];
   }
 }
 
 /// Perform reverse for utf8 string input
 FOLLY_ALWAYS_INLINE static void
-reverseUnicode(char* output, const char* input, size_t length) {
-  auto inputIdx = 0;
-  auto outputIdx = length;
+reverseUnicode(char* output, const char* input, int64_t length) {
+  int64_t inputIdx = 0;
+  int64_t outputIdx = static_cast<int64_t>(length);
   while (inputIdx < length) {
     int size = 1;
-    auto valid = utf8proc_codepoint(&input[inputIdx], input + length, size);
+    const auto valid =
+        utf8proc_codepoint(&input[inputIdx], input + length, size);
 
     // if invalid utf8 gets byte sequence with nextCodePoint==-1 and size==1,
     // continue reverse invalid sequence byte by byte.
@@ -107,7 +132,7 @@ reverseUnicode(char* output, const char* input, size_t length) {
 /// Perform upper for ascii string input
 FOLLY_ALWAYS_INLINE static void
 upperAscii(char* output, const char* input, size_t length) {
-  VECTORIZE_LOOP_IF_POSSIBLE for (auto i = 0; i < length; i++) {
+  VECTORIZE_LOOP_IF_POSSIBLE for (size_t i = 0; i < length; i++) {
     if (input[i] >= 'a' && input[i] <= 'z') {
       output[i] = input[i] - 32;
     } else {
@@ -119,7 +144,7 @@ upperAscii(char* output, const char* input, size_t length) {
 /// Perform lower for ascii string input
 FOLLY_ALWAYS_INLINE static void
 lowerAscii(char* output, const char* input, size_t length) {
-  VECTORIZE_LOOP_IF_POSSIBLE for (auto i = 0; i < length; i++) {
+  VECTORIZE_LOOP_IF_POSSIBLE for (size_t i = 0; i < length; i++) {
     if (input[i] >= 'A' && input[i] <= 'Z') {
       output[i] = input[i] + 32;
     } else {
@@ -137,8 +162,8 @@ FOLLY_ALWAYS_INLINE size_t upperUnicode(
     size_t outputLength,
     const char* input,
     size_t inputLength) {
-  auto inputIdx = 0;
-  auto outputIdx = 0;
+  size_t inputIdx = 0;
+  size_t outputIdx = 0;
 
   while (inputIdx < inputLength) {
     utf8proc_int32_t nextCodePoint;
@@ -171,14 +196,20 @@ FOLLY_ALWAYS_INLINE size_t upperUnicode(
 /// Perform lower for utf8 string input, output should be pre-allocated and
 /// large enough for the results outputLength refers to the number of bytes
 /// available in the output buffer, and inputLength is the number of bytes in
-/// the input string
+/// the input string.
+/// @tparam turkishCasing If true, Spark's specific behavior on Turkish casing
+/// is considered. For 'İ' Spark's lower case is 'i̇' and Presto's is 'i'.
+/// @tparam greekFinalSigma If true, Greek final sigma rule is applied. For the
+/// uppercase letter Σ, if it appears at the end of a word, it becomes ς. In all
+/// other positions, it becomes σ. If false, it is always converted to σ.
+template <bool turkishCasing, bool greekFinalSigma>
 FOLLY_ALWAYS_INLINE size_t lowerUnicode(
     char* output,
     size_t outputLength,
     const char* input,
     size_t inputLength) {
-  auto inputIdx = 0;
-  auto outputIdx = 0;
+  size_t inputIdx = 0;
+  size_t outputIdx = 0;
 
   while (inputIdx < inputLength) {
     utf8proc_int32_t nextCodePoint;
@@ -194,6 +225,41 @@ FOLLY_ALWAYS_INLINE size_t lowerUnicode(
     }
 
     inputIdx += size;
+
+    if constexpr (turkishCasing) {
+      // Handle Turkish-specific case for İ (U+0130).
+      if (UNLIKELY(nextCodePoint == 0x0130)) {
+        // Map to i̇ (U+0069 U+0307).
+        output[outputIdx++] = 0x69;
+        output[outputIdx++] = 0xCC;
+        output[outputIdx++] = 0x87;
+        continue;
+      }
+    }
+
+    if constexpr (greekFinalSigma) {
+      // Handle Greek final sigma for Σ (U+03A3).
+      if (nextCodePoint == 0x03A3) {
+        // Look ahead to see if this is the end of a word.
+        bool isFinal = true;
+        if (inputIdx < inputLength) {
+          int lookaheadSize;
+          utf8proc_int32_t lookaheadCodePoint = utf8proc_codepoint(
+              &input[inputIdx], input + inputLength, lookaheadSize);
+          if (lookaheadCodePoint != -1 && detail::isCased(lookaheadCodePoint)) {
+            // If the next code point is cased, not the final.
+            isFinal = false;
+          }
+        }
+        // Convert to ς or σ.
+        utf8proc_int32_t lowerSigma = isFinal ? 0x03C2 : 0x03C3;
+        auto newSize = utf8proc_encode_char(
+            lowerSigma, reinterpret_cast<unsigned char*>(&output[outputIdx]));
+        outputIdx += newSize;
+        continue;
+      }
+    }
+
     auto lowerCodePoint = utf8proc_tolower(nextCodePoint);
 
     assert(
@@ -266,7 +332,7 @@ lengthUnicode(const char* inputBuffer, size_t bufferLength) {
  * @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) {
+cappedLengthUnicode(const char* input, size_t size, int64_t maxChars) {
   // First address after the last byte in the input
   auto end = input + size;
   auto currentChar = input;
@@ -300,9 +366,9 @@ cappedLengthUnicode(const char* input, size_t size, size_t maxChars) {
 /// maxChars
 ///
 FOLLY_ALWAYS_INLINE int64_t
-cappedByteLengthUnicode(const char* input, size_t size, int64_t maxChars) {
-  size_t utf8Position = 0;
-  size_t numCharacters = 0;
+cappedByteLengthUnicode(const char* input, int64_t size, int64_t maxChars) {
+  int64_t utf8Position = 0;
+  int64_t numCharacters = 0;
   while (utf8Position < size && numCharacters < maxChars) {
     auto charSize = utf8proc_char_length(input + utf8Position);
     utf8Position += UNLIKELY(charSize < 0) ? 1 : charSize;
@@ -482,7 +548,7 @@ inline static size_t replace(
     }
 
     // add replacement before and after each char in inputString
-    for (auto i = 0; i < inputString.size(); i++) {
+    for (size_t i = 0; i < inputString.size(); i++) {
       writeReplacement();
 
       outputString[writePosition] = inputString[i];
@@ -567,7 +633,7 @@ static inline std::pair<size_t, size_t> getByteRange(
     skipContBytes();
 
     // Find startByteIndex
-    for (auto i = 0; nextCharOffset < strLength && i < startCharPosition - 1;
+    for (size_t i = 0; nextCharOffset < strLength && i < startCharPosition - 1;
          i++) {
       nextCharOffset++;
 
@@ -578,7 +644,7 @@ static inline std::pair<size_t, size_t> getByteRange(
     size_t charCountInRange = 0;
 
     // Find endByteIndex
-    for (auto i = 0; nextCharOffset < strLength && i < length; i++) {
+    for (size_t i = 0; nextCharOffset < strLength && i < length; i++) {
       nextCharOffset++;
       charCountInRange++;
 
diff --git a/velox/functions/lib/string/StringImpl.h b/velox/functions/lib/string/StringImpl.h
index d1b8896fa01d..3322ac36991a 100644
--- a/velox/functions/lib/string/StringImpl.h
+++ b/velox/functions/lib/string/StringImpl.h
@@ -17,14 +17,15 @@
 
 #include <assert.h>
 #include <fmt/format.h>
+#include <folly/CPortability.h>
+#include <folly/Likely.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <cstdint>
 #include <cstring>
 #include <string_view>
 #include <vector>
-#include "folly/CPortability.h"
-#include "folly/Likely.h"
+
 #include "velox/common/base/Exceptions.h"
 #include "velox/external/md5/md5.h"
 #include "velox/functions/lib/Utf8Utils.h"
@@ -35,7 +36,11 @@ namespace facebook::velox::functions::stringImpl {
 using namespace stringCore;
 
 /// Perform upper for a UTF8 string
-template <bool ascii, typename TOutString, typename TInString>
+template <
+    bool ascii,
+    bool turkishCasing = false,
+    typename TOutString,
+    typename TInString>
 FOLLY_ALWAYS_INLINE bool upper(TOutString& output, const TInString& input) {
   if constexpr (ascii) {
     output.resize(input.size());
@@ -50,20 +55,32 @@ FOLLY_ALWAYS_INLINE bool upper(TOutString& output, const TInString& input) {
 }
 
 /// Perform lower for a UTF8 string
-template <bool ascii, typename TOutString, typename TInString>
+template <
+    bool ascii,
+    bool turkishCasing = false,
+    bool greekFinalSigma = false,
+    typename TOutString,
+    typename TInString>
 FOLLY_ALWAYS_INLINE bool lower(TOutString& output, const TInString& input) {
   if constexpr (ascii) {
     output.resize(input.size());
     lowerAscii(output.data(), input.data(), input.size());
   } else {
     output.resize(input.size() * 4);
-    auto size =
-        lowerUnicode(output.data(), output.size(), input.data(), input.size());
+    auto size = lowerUnicode<turkishCasing, greekFinalSigma>(
+        output.data(), output.size(), input.data(), input.size());
     output.resize(size);
   }
   return true;
 }
 
+// Return the lower-case string of a UTF8 string.
+FOLLY_ALWAYS_INLINE std::string utf8StrToLowerCopy(const std::string& str) {
+  std::string lowerStr;
+  functions::stringImpl::lower<false>(lowerStr, str);
+  return lowerStr;
+}
+
 /// Apply a set of appenders on an output string, an appender is a lambda
 /// that takes an output string and append a string to it. This can be used by
 /// code-gen to reduce copying in concat by evaluating nested expressions
@@ -120,23 +137,21 @@ cappedByteLength(const TString& input, size_t maxCharacters) {
   }
 }
 
-/// Write the Unicode codePoint as string to the output string. The function
+/// Write the Unicode codePoint as string to an output StringView. The function
 /// behavior is undefined when code point it invalid. Implements the logic of
 /// presto chr function.
-template <typename TOutString>
-FOLLY_ALWAYS_INLINE void codePointToString(
-    TOutString& output,
-    const int64_t codePoint) {
+///
+/// Returns an StringView with an inlined buffer (since the maximum string size
+/// is only 4 bytes).
+FOLLY_ALWAYS_INLINE StringView codePointToString(const int64_t codePoint) {
   auto validCodePoint =
       codePoint <= INT32_MAX && utf8proc_codepoint_valid(codePoint);
   VELOX_USER_CHECK(
       validCodePoint, "Not a valid Unicode code point: {}", codePoint);
 
-  output.reserve(4);
-  auto size = utf8proc_encode_char(
-      codePoint, reinterpret_cast<unsigned char*>(output.data()));
-
-  output.resize(size);
+  unsigned char output[4];
+  auto size = utf8proc_encode_char(codePoint, output);
+  return StringView((const char*)output, size);
 }
 
 /// Returns the Unicode code point of the first char in a single char input
@@ -673,4 +688,130 @@ FOLLY_ALWAYS_INLINE void pad(
       padPrefixByteLength);
 }
 
+namespace detail {
+
+template <bool strictSpace>
+inline bool isSpaceAscii(unsigned char ch) {
+  if constexpr (strictSpace) {
+    return ch == ' ';
+  } else {
+    return std::isspace(ch);
+  }
+}
+
+template <bool strictSpace>
+inline bool isSpaceUtf8(utf8proc_int32_t cp) {
+  if constexpr (strictSpace) {
+    return cp == 0x20;
+  } else {
+    return isUnicodeWhiteSpace(cp);
+  }
+}
+
+template <bool strictSpace, typename TOutString, typename TInString>
+FOLLY_ALWAYS_INLINE void initcapAsciiImpl(
+    TOutString& output,
+    const TInString& input) {
+  output.resize(input.size());
+  const char* inputChars = input.data();
+  char* outputChars = output.data();
+
+  bool isStartOfWord = true;
+  for (size_t i = 0; i < input.size(); ++i) {
+    unsigned char currentChar = static_cast<unsigned char>(inputChars[i]);
+
+    if (isSpaceAscii<strictSpace>(currentChar)) {
+      isStartOfWord = true;
+      outputChars[i] = currentChar;
+    } else if (isStartOfWord) {
+      outputChars[i] = std::toupper(currentChar);
+      isStartOfWord = false;
+    } else {
+      outputChars[i] = std::tolower(currentChar);
+    }
+  }
+}
+
+template <
+    bool strictSpace,
+    bool turkishCasing,
+    bool greekFinalSigma,
+    typename TOutString,
+    typename TInString>
+FOLLY_ALWAYS_INLINE bool initcapUtf8Impl(
+    TOutString& output,
+    const TInString& input) {
+  const char* inputBytes = input.data();
+  const char* inputEnd = inputBytes + input.size();
+
+  output.resize(input.size() * 4);
+  char* outputStart = output.data();
+  char* outputBytes = outputStart;
+
+  bool isStartOfWord = true;
+
+  while (inputBytes < inputEnd) {
+    utf8proc_int32_t originalCodepoint;
+    auto numBytesRead = utf8proc_iterate(
+        reinterpret_cast<const uint8_t*>(inputBytes),
+        inputEnd - inputBytes,
+        &originalCodepoint);
+    if (numBytesRead < 0) {
+      return false;
+    }
+
+    if (isSpaceUtf8<strictSpace>(originalCodepoint)) {
+      isStartOfWord = true;
+      // Copy delimiter as is.
+      std::memcpy(outputBytes, inputBytes, numBytesRead);
+      outputBytes += numBytesRead;
+    } else if (isStartOfWord) {
+      auto upperSize = upperUnicode(
+          outputBytes,
+          static_cast<size_t>(outputStart + output.size() - outputBytes),
+          inputBytes,
+          numBytesRead);
+      outputBytes += upperSize;
+      isStartOfWord = false;
+    } else {
+      auto lowerSize = lowerUnicode<turkishCasing, greekFinalSigma>(
+          outputBytes,
+          static_cast<size_t>(outputStart + output.size() - outputBytes),
+          inputBytes,
+          numBytesRead);
+      outputBytes += lowerSize;
+    }
+    inputBytes += numBytesRead;
+  }
+
+  output.resize(outputBytes - outputStart);
+  return true;
+}
+
+} // namespace detail
+
+/// Converts the first character of each word to uppercase and all other
+/// characters in the word to lowercase. Words are separated by whitespace.
+/// @tparam strictSpace If true, only ASCII space is considered as word
+/// separators. If false, other ASCII or Unicode whitespace characters are also
+/// considered as word separators.
+/// @tparam turkishCasing If true, handles special Turkish case during
+/// the unicode lower-casing.
+template <
+    bool strictSpace,
+    bool isAscii,
+    bool turkishCasing,
+    bool greekFinalSigma,
+    typename TOutString,
+    typename TInString>
+FOLLY_ALWAYS_INLINE bool initcap(TOutString& output, const TInString& input) {
+  if constexpr (isAscii) {
+    detail::initcapAsciiImpl<strictSpace>(output, input);
+    return true;
+  } else {
+    return detail::initcapUtf8Impl<strictSpace, turkishCasing, greekFinalSigma>(
+        output, input);
+  }
+}
+
 } // namespace facebook::velox::functions::stringImpl
diff --git a/velox/functions/lib/string/tests/CMakeLists.txt b/velox/functions/lib/string/tests/CMakeLists.txt
index 54b2302de5d2..baf38f88322c 100644
--- a/velox/functions/lib/string/tests/CMakeLists.txt
+++ b/velox/functions/lib/string/tests/CMakeLists.txt
@@ -22,4 +22,5 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
   gflags::gflags
-  glog::glog)
+  glog::glog
+)
diff --git a/velox/functions/lib/string/tests/StringImplTest.cpp b/velox/functions/lib/string/tests/StringImplTest.cpp
index 545d457bcc76..7a9e48f8c4ec 100644
--- a/velox/functions/lib/string/tests/StringImplTest.cpp
+++ b/velox/functions/lib/string/tests/StringImplTest.cpp
@@ -42,7 +42,35 @@ class StringImplTest : public testing::Test {
         {"àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ", "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ"},
         {"αβγδεζηθικλμνξοπρςστυφχψ", "ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΣΤΥΦΧΨ"},
         {"абвгдежзийклмнопрстуфхцчшщъыьэюя",
-         "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"}};
+         "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"},
+        {"\u0069", "\u0049"},
+        {"\u03C3", "\u03A3"},
+        {"i\xCC\x87", "I\xCC\x87"},
+        {"\u010B", "\u010A"},
+        {"\u0117", "\u0116"},
+        {"\u0121", "\u0120"},
+        {"\u017C", "\u017B"},
+        {"\u0227", "\u0226"},
+        {"\u022F", "\u022E"},
+        {"\u1E03", "\u1E02"},
+        {"\u1E0B", "\u1E0A"},
+        {"\u1E1F", "\u1E1E"},
+        {"\u1E23", "\u1E22"},
+        {"\u1E41", "\u1E40"},
+        {"\u1E45", "\u1E44"},
+        {"\u1E57", "\u1E56"},
+        {"\u1E59", "\u1E58"},
+        {"\u1E61", "\u1E60"},
+        {"\u1E65", "\u1E64"},
+        {"\u1E67", "\u1E66"},
+        {"\u1E69", "\u1E68"},
+        {"\u1E6B", "\u1E6A"},
+        {"\u1E87", "\u1E86"},
+        {"\u1E8B", "\u1E8A"},
+        {"\u1E8F", "\u1E8E"},
+        {"πας", "ΠΑΣ"},
+        {"παςa", "ΠΑΣA"},
+    };
   }
 
   std::vector<std::tuple<std::string, std::string>> getLowerAsciiTestData() {
@@ -58,7 +86,132 @@ class StringImplTest : public testing::Test {
         {"ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ", "àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ"},
         {"ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΣΤΥΦΧΨ", "αβγδεζηθικλμνξοπρσστυφχψ"},
         {"АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ",
-         "абвгдежзийклмнопрстуфхцчшщъыьэюя"}};
+         "абвгдежзийклмнопрстуфхцчшщъыьэюя"},
+        {"\u0130", "\u0069"},
+        {"\u03A3", "\u03C3"},
+        {"I\xCC\x87", "i\xCC\x87"},
+        {"\u010A", "\u010B"},
+        {"\u0116", "\u0117"},
+        {"\u0120", "\u0121"},
+        {"\u017B", "\u017C"},
+        {"\u0226", "\u0227"},
+        {"\u022E", "\u022F"},
+        {"\u1E02", "\u1E03"},
+        {"\u1E0A", "\u1E0B"},
+        {"\u1E1E", "\u1E1F"},
+        {"\u1E22", "\u1E23"},
+        {"\u1E40", "\u1E41"},
+        {"\u1E44", "\u1E45"},
+        {"\u1E56", "\u1E57"},
+        {"\u1E58", "\u1E59"},
+        {"\u1E60", "\u1E61"},
+        {"\u1E64", "\u1E65"},
+        {"\u1E66", "\u1E67"},
+        {"\u1E68", "\u1E69"},
+        {"\u1E6A", "\u1E6B"},
+        {"\u1E86", "\u1E87"},
+        {"\u1E8A", "\u1E8B"},
+        {"\u1E8E", "\u1E8F"},
+        {"ΠΑΣ", "πασ"},
+        {"ΠΑΣA", "πασa"},
+    };
+  }
+
+  static std::vector<std::pair<std::string, std::string>>
+  getInitcapUnicodePrestoTestData() {
+    return {
+        {"BİLGİ", "Bilgi"},
+        {"\u0130\u0130", "\u0130\u0069"},
+        {"foo\u0020bar", "Foo\u0020Bar"},
+        {"foo\u0009bar", "Foo\u0009Bar"},
+        {"foo\u000Abar", "Foo\u000ABar"},
+        {"foo\u000Dbar", "Foo\u000DBar"},
+        {"foo\u000Bbar", "Foo\u000BBar"},
+        {"foo\u000Cbar", "Foo\u000CBar"},
+        {"foo\u0009\u000A\u000D\u000B\u000Cbar",
+         "Foo\u0009\u000A\u000D\u000B\u000CBar"},
+        {"foo\u0020\u0009\u000Abar", "Foo\u0020\u0009\u000ABar"},
+        {"foo\u1680bar", "Foo\u1680Bar"},
+        {"foo\u2000bar", "Foo\u2000Bar"},
+        {"foo\u2001bar", "Foo\u2001Bar"},
+        {"foo\u2002bar", "Foo\u2002Bar"},
+        {"foo\u2003bar", "Foo\u2003Bar"},
+        {"foo\u2004bar", "Foo\u2004Bar"},
+        {"foo\u2005bar", "Foo\u2005Bar"},
+        {"foo\u2006bar", "Foo\u2006Bar"},
+        {"foo\u2008bar", "Foo\u2008Bar"},
+        {"foo\u2009bar", "Foo\u2009Bar"},
+        {"foo\u200Abar", "Foo\u200ABar"},
+        {"foo\u2028bar", "Foo\u2028Bar"},
+        {"foo\u2029bar", "Foo\u2029Bar"},
+        {"foo\u205Fbar", "Foo\u205FBar"},
+        {"foo\u3000bar", "Foo\u3000Bar"},
+        {"foo\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2008\u2009\u200Abar",
+         "Foo\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2008\u2009\u200ABar"},
+        {"\u00E9l\u00E8ve\u000Atr\u00E8s-intelligent",
+         "\u00C9l\u00E8ve\u000ATr\u00E8s-intelligent"},
+        // Below whitespaces are not considered as whitespace in presto
+        {"foo\u0085Bar", "Foo\u0085bar"},
+        {"foo\u00A0Bar", "Foo\u00A0bar"},
+        {"foo\u2007Bar", "Foo\u2007bar"},
+    };
+  }
+
+  static std::vector<std::pair<std::string, std::string>>
+  getInitcapAsciiPrestoTestData() {
+    return {
+        {"foo bar", "Foo Bar"},
+        {"foo\nbar", "Foo\nBar"},
+        {"foo \t\nbar", "Foo \t\nBar"}};
+  }
+
+  static std::vector<std::pair<std::string, std::string>>
+  getInitcapUnicodeSparkTestData() {
+    return {
+        {"àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ", "Àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ"},
+        {"αβγδεζηθικλμνξοπρςστυφχψ", "Αβγδεζηθικλμνξοπρςστυφχψ"},
+        {"абвгдежзийклмнопрстуфхцчшщъыьэюя",
+         "Абвгдежзийклмнопрстуфхцчшщъыьэюя"},
+        {"hello world", "Hello World"},
+        {"HELLO WORLD", "Hello World"},
+        {"1234", "1234"},
+        {"1234", "1234"},
+        {"", ""},
+        {"élève très-intelligent", "Élève Très-intelligent"},
+        {"mañana-por_la_tarde!", "Mañana-por_la_tarde!"},
+        {"добро-пожаловать.тест", "Добро-пожаловать.тест"},
+        {"çalışkan öğrenci@üniversite.tr", "Çalışkan Öğrenci@üniversite.tr"},
+        {"emoji😊test🚀case", "Emoji😊test🚀case"},
+        {"тест@пример.рф", "Тест@пример.рф"},
+        {"BİLGİ", "Bi̇lgi̇"},
+        {"\u0130\u0130", "\u0130\u0069\u0307"},
+        {"İstanbul", "İstanbul"}};
+  }
+
+  static std::vector<std::pair<std::string, std::string>>
+  getInitcapAsciiSparkTestData() {
+    return {
+        {"abcdefg", "Abcdefg"},
+        {" abcdefg", " Abcdefg"},
+        {" abc defg", " Abc Defg"},
+        {"ABCDEFG", "Abcdefg"},
+        {"a B c D e F g", "A B C D E F G"},
+        {"hello world", "Hello World"},
+        {"HELLO WORLD", "Hello World"},
+        {"1234", "1234"},
+        {"", ""},
+        {"urna.Ut@egetdictumplacerat.edu", "Urna.ut@egetdictumplacerat.edu"},
+        {"nibh.enim@egestas.ca", "Nibh.enim@egestas.ca"},
+        {"in@Donecat.ca", "In@donecat.ca"},
+        {"sodales@blanditviverraDonec.ca", "Sodales@blanditviverradonec.ca"},
+        {"sociis.natoque.penatibus@vitae.org",
+         "Sociis.natoque.penatibus@vitae.org"},
+        {"john_doe-123@example-site.com", "John_doe-123@example-site.com"},
+        {"MIXED.case-EMAIL_42@domain.NET", "Mixed.case-email_42@domain.net"},
+        {"...weird..case@@", "...weird..case@@"},
+        {"user-name+filter@sub.mail.org", "User-name+filter@sub.mail.org"},
+        {"CAPS_LOCK@DOMAIN.COM", "Caps_lock@domain.com"},
+        {"__init__.py@example.dev", "__init__.py@example.dev"}};
   }
 };
 
@@ -313,15 +466,11 @@ TEST_F(StringImplTest, badUnicodeLength) {
 TEST_F(StringImplTest, codePointToString) {
   auto testValidInput = [](const int64_t codePoint,
                            const std::string& expectedString) {
-    core::StringWriter output;
-    codePointToString(output, codePoint);
-    ASSERT_EQ(
-        StringView(expectedString), StringView(output.data(), output.size()));
+    ASSERT_EQ(StringView(expectedString), codePointToString(codePoint));
   };
 
   auto testInvalidCodePoint = [](const int64_t codePoint) {
-    core::StringWriter output;
-    EXPECT_THROW(codePointToString(output, codePoint), VeloxUserError)
+    EXPECT_THROW(codePointToString(codePoint), VeloxUserError)
         << "codePoint " << codePoint;
   };
 
@@ -341,9 +490,8 @@ TEST_F(StringImplTest, charToCodePoint) {
   };
 
   auto testValidInputRoundTrip = [](const int64_t codePoint) {
-    core::StringWriter string;
-    codePointToString(string, codePoint);
-    ASSERT_EQ(charToCodePoint(string), codePoint) << "codePoint " << codePoint;
+    ASSERT_EQ(charToCodePoint(codePointToString(codePoint)), codePoint)
+        << "codePoint " << codePoint;
   };
 
   auto testExpectDeath = [](const std::string& charString) {
@@ -839,3 +987,50 @@ TEST_F(StringImplTest, isAscii) {
   ASSERT_FALSE(isAscii(s.data(), strlen(alpha)));
   ASSERT_FALSE(isAscii(s.data(), s.size()));
 }
+
+TEST_F(StringImplTest, initcapUnicodePresto) {
+  for (const auto& [input, expected] : getInitcapUnicodePrestoTestData()) {
+    std::string output;
+    initcap<
+        /*strictSpace=*/false,
+        /*isAscii=*/false,
+        /*turkishCasing=*/false,
+        /*greekFinalSigma=*/false>(output, input);
+    ASSERT_EQ(output, expected);
+  }
+}
+
+TEST_F(StringImplTest, initcapAsciiPresto) {
+  for (const auto& [input, expected] : getInitcapAsciiPrestoTestData()) {
+    std::string output;
+    initcap<
+        /*strictSpace=*/false,
+        /*isAscii=*/true,
+        /*turkishCasing=*/false,
+        /*greekFinalSigma=*/false>(output, input);
+    ASSERT_EQ(output, expected);
+  }
+}
+TEST_F(StringImplTest, initcapUnicodeSpark) {
+  for (const auto& [input, expected] : getInitcapUnicodeSparkTestData()) {
+    std::string output;
+    initcap<
+        /*strictSpace=*/true,
+        /*isAscii=*/false,
+        /*turkishCasing=*/true,
+        /*greekFinalSigma=*/true>(output, input);
+    ASSERT_EQ(output, expected);
+  }
+}
+
+TEST_F(StringImplTest, initcapAsciiSpark) {
+  for (const auto& [input, expected] : getInitcapAsciiSparkTestData()) {
+    std::string output;
+    initcap<
+        /*strictSpace=*/true,
+        /*isAscii=*/true,
+        /*turkishCasing=*/true,
+        /*greekFinalSigma=*/true>(output, input);
+    ASSERT_EQ(output, expected);
+  }
+}
diff --git a/velox/functions/lib/tests/CMakeLists.txt b/velox/functions/lib/tests/CMakeLists.txt
index 6e567d2d8e3d..c41d4d7fa109 100644
--- a/velox/functions/lib/tests/CMakeLists.txt
+++ b/velox/functions/lib/tests/CMakeLists.txt
@@ -21,6 +21,7 @@ add_executable(
   IsNotNullTest.cpp
   KllSketchTest.cpp
   LambdaFunctionUtilTest.cpp
+  MakeRowFromMapTest.cpp
   MapConcatTest.cpp
   QuantileDigestTest.cpp
   Re2FunctionsTest.cpp
@@ -28,12 +29,14 @@ add_executable(
   TDigestTest.cpp
   TimeUtilsTest.cpp
   Utf8Test.cpp
-  ZetaDistributionTest.cpp)
+  ZetaDistributionTest.cpp
+)
 
 add_test(
   NAME velox_functions_lib_test
   COMMAND velox_functions_lib_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_functions_lib_test
@@ -46,4 +49,5 @@ target_link_libraries(
   velox_dwio_common_test_utils
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
diff --git a/velox/functions/lib/tests/CheckNestedNullsTest.cpp b/velox/functions/lib/tests/CheckNestedNullsTest.cpp
index 3b033644383f..df716b164537 100644
--- a/velox/functions/lib/tests/CheckNestedNullsTest.cpp
+++ b/velox/functions/lib/tests/CheckNestedNullsTest.cpp
@@ -40,15 +40,15 @@ TEST_F(CheckNestedNullsTest, array) {
 
   for (bool throwOnNestedNulls : {true, false}) {
     ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 0, indices[0], throwOnNestedNulls));
     ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 1, indices[1], throwOnNestedNulls));
   }
 
   VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
+      checkNestedNulls(decodedVector, 2, indices[2], true),
       "ARRAY comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+  ASSERT_FALSE(checkNestedNulls(decodedVector, 2, indices[2], false));
 }
 
 TEST_F(CheckNestedNullsTest, map) {
@@ -62,15 +62,15 @@ TEST_F(CheckNestedNullsTest, map) {
 
   for (bool throwOnNestedNulls : {true, false}) {
     ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 0, indices[0], throwOnNestedNulls));
     ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 1, indices[1], throwOnNestedNulls));
   }
 
   VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
+      checkNestedNulls(decodedVector, 2, indices[2], true),
       "MAP comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+  ASSERT_FALSE(checkNestedNulls(decodedVector, 2, indices[2], false));
 }
 
 TEST_F(CheckNestedNullsTest, row) {
@@ -93,14 +93,14 @@ TEST_F(CheckNestedNullsTest, row) {
 
   for (bool throwOnNestedNulls : {true, false}) {
     ASSERT_TRUE(
-        checkNestedNulls(decodedVector, indices, 0, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 0, indices[0], throwOnNestedNulls));
     ASSERT_FALSE(
-        checkNestedNulls(decodedVector, indices, 1, throwOnNestedNulls));
+        checkNestedNulls(decodedVector, 1, indices[1], throwOnNestedNulls));
   }
 
   VELOX_ASSERT_THROW(
-      checkNestedNulls(decodedVector, indices, 2, true),
+      checkNestedNulls(decodedVector, 2, indices[2], true),
       "ROW comparison not supported for values that contain nulls");
-  ASSERT_FALSE(checkNestedNulls(decodedVector, indices, 2, false));
+  ASSERT_FALSE(checkNestedNulls(decodedVector, 2, 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 218bd4a50977..724c8ff4b087 100644
--- a/velox/functions/lib/tests/DateTimeFormatterTest.cpp
+++ b/velox/functions/lib/tests/DateTimeFormatterTest.cpp
@@ -1347,7 +1347,7 @@ TEST_F(JodaDateTimeFormatterTest, formatResultSize) {
   EXPECT_EQ(getJodaDateTimeFormatter("CCCCCCCCC")->maxResultSize(timezone), 9);
 
   EXPECT_EQ(
-      getJodaDateTimeFormatter("yyyy-MM-dd z")->maxResultSize(timezone), 23);
+      getJodaDateTimeFormatter("yyyy-MM-dd z")->maxResultSize(timezone), 26);
   EXPECT_EQ(
       getJodaDateTimeFormatter("yyyy-MM-dd Z")->maxResultSize(timezone), 25);
   EXPECT_EQ(
@@ -2368,16 +2368,16 @@ TEST_F(SimpleDateTimeFormatterTest, parseSimpleWeekOfMonth) {
     // Format contains year, month, weekOfMonth and dayOfWeek.
     EXPECT_EQ(
         fromTimestampString("2024-08-02"),
-        parseSimple("2024 08 01 5", "yyyy MM WW e", lenient).timestamp);
+        parseSimple("2024 08 01 5", "yyyy MM WW u", lenient).timestamp);
     EXPECT_EQ(
         fromTimestampString("2024-08-03"),
-        parseSimple("2024 08 01 6", "yyyy MM WW e", lenient).timestamp);
+        parseSimple("2024 08 01 6", "yyyy MM WW u", lenient).timestamp);
     EXPECT_EQ(
         fromTimestampString("2024-08-09"),
-        parseSimple("2024 08 02 5", "yyyy MM WW e", lenient).timestamp);
+        parseSimple("2024 08 02 5", "yyyy MM WW u", lenient).timestamp);
     EXPECT_EQ(
         fromTimestampString("2024-08-12"),
-        parseSimple("2024 08 03 1", "yyyy MM WW e", lenient).timestamp);
+        parseSimple("2024 08 03 1", "yyyy MM WW u", lenient).timestamp);
 
     // Format contains year, month and weekOfMonth.
     EXPECT_EQ(
@@ -2398,25 +2398,25 @@ TEST_F(SimpleDateTimeFormatterTest, parseSimpleWeekOfMonth) {
   // Field out of range for lenient mode.
   EXPECT_EQ(
       fromTimestampString("2024-09-30"),
-      parseSimple("2024 08 10 1", "yyyy MM WW e", true).timestamp);
+      parseSimple("2024 08 10 1", "yyyy MM WW u", true).timestamp);
   EXPECT_EQ(
       fromTimestampString("2024-07-28"),
       parseSimple("2024 08 01", "yyyy MM WW", true).timestamp);
   EXPECT_EQ(
       fromTimestampString("2025-02-24"),
-      parseSimple("2024 15 01 1", "yyyy MM WW e", true).timestamp);
+      parseSimple("2024 15 01 1", "yyyy MM WW u", true).timestamp);
   EXPECT_EQ(
       fromTimestampString("2024-07-29"),
-      parseSimple("2024 08 01 9", "yyyy MM WW e", true).timestamp);
+      parseSimple("2024 08 01 9", "yyyy MM WW u", true).timestamp);
 
   // Field out of range for strict mode.
   EXPECT_THROW(
-      parseSimple("2024 08 10 1", "yyyy MM WW e", false), VeloxUserError);
+      parseSimple("2024 08 10 1", "yyyy MM WW u", false), VeloxUserError);
   EXPECT_THROW(parseSimple("2024 08 10", "yyyy MM WW", false), VeloxUserError);
   EXPECT_THROW(
-      parseSimple("2024 15 01 1", "yyyy MM WW e", false), VeloxUserError);
+      parseSimple("2024 15 01 1", "yyyy MM WW u", false), VeloxUserError);
   EXPECT_THROW(
-      parseSimple("2024 08 01 9", "yyyy MM WW e", false), VeloxUserError);
+      parseSimple("2024 08 01 9", "yyyy MM WW u", false), VeloxUserError);
 }
 
 TEST_F(SimpleDateTimeFormatterTest, formatResultSize) {
diff --git a/velox/functions/lib/tests/MakeRowFromMapTest.cpp b/velox/functions/lib/tests/MakeRowFromMapTest.cpp
new file mode 100644
index 000000000000..4e0bcecf4852
--- /dev/null
+++ b/velox/functions/lib/tests/MakeRowFromMapTest.cpp
@@ -0,0 +1,709 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <cstdint>
+#include <optional>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
+#include "velox/core/QueryCtx.h"
+#include "velox/expression/Expr.h"
+#include "velox/functions/lib/MakeRowFromMap.h"
+#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/SelectivityVector.h"
+#include "velox/vector/SimpleVector.h"
+#include "velox/vector/TypeAliases.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+// For testing Opaque types.
+struct NonPOD {
+  static int alive;
+
+  int x;
+  NonPOD(int x = 123) : x(x) {
+    ++alive;
+  }
+  ~NonPOD() {
+    --alive;
+  }
+  bool operator==(const NonPOD& other) const {
+    return x == other.x;
+  }
+};
+
+int NonPOD::alive = 0;
+
+class MakeRowFroMapTest : public testing::Test, public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    functions::prestosql::registerAllScalarFunctions();
+    parse::registerTypeResolver();
+  }
+
+  template <TypeKind Kind>
+  VectorPtr toRowVector(
+      const BaseVector& map,
+      const MakeRowFromMapOptions& options,
+      const SelectivityVector& rows,
+      exec::EvalCtx* evalCtx = nullptr) {
+    return MakeRowFromMap<Kind>(options).apply(map, rows, evalCtx);
+  }
+
+  // Generates a set of test cases for toRowVector. Each test case
+  // is a MapVector with the same keys but different value types.
+  std::vector<MapVectorPtr> makeTestCases() {
+    std::vector<MapVectorPtr> testCases;
+    auto map = makeMapVectorFromJson<int64_t, int64_t>(
+        {"{1:1, 2:2, 3:3}", // All valid values
+         "{2:20, 4:40, 7:3}", // Only one projected key
+         "{1:100, 2:null, 6:600}", // Null Value
+         "{4:4000, 6:6000}", // No projected keys
+         "{1:10000}", // single element, projected key
+         "{}", // empty map
+         "null"}); // null map
+    auto keyType = map->type()->asMap().keyType();
+    auto intValues = map->mapValues();
+    VELOX_CHECK_EQ(intValues->size(), 12);
+    testCases.push_back(map);
+
+    auto makeCopyWithValues = [&](VectorPtr& values) {
+      return std::make_shared<MapVector>(
+          pool(),
+          MAP(keyType, values->type()),
+          map->nulls(),
+          map->size(),
+          map->offsets(),
+          map->sizes(),
+          map->mapKeys(),
+          values);
+    };
+
+    // With String Values.
+    VectorFuzzer::Options opts{.nullRatio = 0};
+    VectorFuzzer fuzzer(opts, pool());
+    auto stringValues = fuzzer.fuzzFlat(VARCHAR(), intValues->size());
+    stringValues->setNulls(intValues->nulls());
+    testCases.push_back(makeCopyWithValues(stringValues));
+
+    // With Array Values.
+    auto arrayValues = fuzzer.fuzzFlat(ARRAY(BIGINT()), intValues->size());
+    arrayValues->setNulls(intValues->nulls());
+    testCases.push_back(makeCopyWithValues(arrayValues));
+
+    // With Row Values.
+    auto rowValues = fuzzer.fuzzFlat(ROW({BIGINT()}), intValues->size());
+    rowValues->setNulls(intValues->nulls());
+    testCases.push_back(makeCopyWithValues(rowValues));
+
+    // With Map Values.
+    auto mapValues =
+        fuzzer.fuzzFlat(MAP(BIGINT(), BIGINT()), intValues->size());
+    mapValues->setNulls(intValues->nulls());
+    testCases.push_back(makeCopyWithValues(mapValues));
+
+    auto opaqueValues =
+        BaseVector::create(OPAQUE<int>(), intValues->size(), pool());
+    auto flat = opaqueValues->asFlatVector<std::shared_ptr<void>>();
+    for (int i = 0; i < intValues->size(); i++) {
+      flat->set(i, std::make_shared<NonPOD>(i));
+    }
+    testCases.push_back(makeCopyWithValues(opaqueValues));
+
+    return testCases;
+  }
+
+  template <TypeKind ValueKind>
+  void verifyDefaultValue(VectorPtr& vector, vector_size_t row) {
+    if constexpr (
+        (TypeTraits<ValueKind>::isPrimitiveType ||
+         ValueKind == TypeKind::OPAQUE) &&
+        ValueKind != TypeKind::UNKNOWN) {
+      using NativeType = typename TypeTraits<ValueKind>::NativeType;
+      static NativeType defaultValue;
+      ASSERT_EQ(vector->asFlatVector<NativeType>()->valueAt(row), defaultValue);
+    } else if constexpr (
+        ValueKind == TypeKind::ARRAY || ValueKind == TypeKind::MAP) {
+      auto arrayBaseVector = vector->asChecked<ArrayVectorBase>();
+      ASSERT_NE(arrayBaseVector, nullptr);
+      ASSERT_EQ(arrayBaseVector->offsetAt(row), 0);
+      ASSERT_EQ(arrayBaseVector->sizeAt(row), 0);
+    } else {
+      VELOX_USER_FAIL(
+          "Unsupported type for replacing nulls: {}",
+          TypeTraits<ValueKind>::TypeTraits::name);
+    }
+  }
+
+  // For the case where 'replaceNulls' and 'allowTopLevelNulls' is false, we
+  // use this helper function to verify the result by evaluating an expression
+  // that mimics the map to row projection.
+  void verifyResultUsingExprEval(
+      const VectorPtr& result,
+      const VectorPtr& input,
+      SelectivityVector& rows) {
+    auto inputRow = makeRowVector({input});
+    // Evaluate an expression the mimics the map to row projection.
+    // eg: cast(row_constructor(c0[1], c0[2]) as row(key1 bigint, key2 bigint))
+    // Extract keys and wrap it in a struct
+    auto typedExpr = core::Expressions::inferTypes(
+        parse::parseExpr("row_constructor(c0[1], c0[2])", {}),
+        inputRow->type(),
+        execCtx_->pool());
+    // Wrap the struct in a cast to get the correct field names
+    typedExpr =
+        std::make_shared<core::CastTypedExpr>(result->type(), typedExpr, false);
+    exec::ExprSet exprSet({typedExpr}, execCtx_.get());
+    std::vector<VectorPtr> output;
+    exec::EvalCtx context(execCtx_.get(), &exprSet, inputRow.get());
+    exprSet.eval(rows, context, output);
+    test::assertEqualVectors(result, output[0], rows);
+  }
+
+  // Helper function that verifies the output of toRowVector. For
+  // each row in the result, it retrieves the corresponding value from the
+  // original MapVector by looking up the key for that row, if present. If the
+  // key is not found, it checks that the value is set to null or to the default
+  // value, depending on whether replaceNulls is enabled. As a sanity check, for
+  // cases that can be represented as valid expressions, the verification is
+  // also performed using expression evaluation to ensure the logic is correct.
+  void verifyResult(
+      const VectorPtr& result,
+      const VectorPtr& input,
+      SelectivityVector& rows,
+      MakeRowFromMapOptions& options) {
+    ASSERT_TRUE(result != nullptr);
+    // Assert expected types and field names
+    ASSERT_EQ(result->type()->asRow().children().size(), 2);
+    ASSERT_EQ(result->type()->asRow().nameOf(0), "key1");
+    ASSERT_EQ(result->type()->asRow().nameOf(1), "key2");
+    ASSERT_EQ(
+        result->type()->asRow().childAt(0), input->type()->asMap().valueType());
+    ASSERT_EQ(
+        result->type()->asRow().childAt(1), input->type()->asMap().valueType());
+
+    // Assert expected number of rows
+    ASSERT_EQ(result->size(), rows.end());
+
+    if (!options.replaceNulls && !options.allowTopLevelNulls) {
+      verifyResultUsingExprEval(result, input, rows);
+    }
+
+    DecodedVector decodedInput(*input);
+    auto map = decodedInput.base()->as<MapVector>();
+    auto mapKeys = map->mapKeys()->as<SimpleVector<int64_t>>();
+    auto mapValues = map->mapValues();
+    auto rawOffsets = map->rawOffsets();
+    auto rawSizes = map->rawSizes();
+
+    auto findValueIdx = [&](vector_size_t row,
+                            int64_t key) -> std::optional<vector_size_t> {
+      if (decodedInput.isNullAt(row)) {
+        return std::nullopt;
+      }
+      auto offset = rawOffsets[decodedInput.index(row)];
+      auto size = rawSizes[decodedInput.index(row)];
+      for (auto i = offset; i < offset + size; ++i) {
+        if (mapKeys->valueAt(i) == key) {
+          return i;
+        }
+      }
+      return std::nullopt;
+    };
+    // Verify expected values
+    rows.applyToSelected([&](auto row) {
+      // Check for top-level nulls if allowed
+      if (options.allowTopLevelNulls && !options.replaceNulls &&
+          decodedInput.isNullAt(row)) {
+        ASSERT_TRUE(result->isNullAt(row)) << " row idx: " << row;
+        return;
+      }
+      // For every projected key, find the corresponding value in the original
+      // map and verify its correctly set in the result.
+      for (int64_t key : {1, 2}) {
+        auto valueIdx = findValueIdx(row, key);
+        auto child = result->as<RowVector>()->childAt(key - 1);
+        if (valueIdx.has_value() && !mapValues->isNullAt(valueIdx.value())) {
+          ASSERT_TRUE(!child->isNullAt(row));
+          if (child->type()->kind() == TypeKind::OPAQUE) {
+            auto opaqueValue =
+                child->asFlatVector<std::shared_ptr<void>>()->valueAt(row);
+            auto expectedOpaqueValue =
+                mapValues->as<SimpleVector<std::shared_ptr<void>>>()->valueAt(
+                    valueIdx.value());
+            EXPECT_EQ(
+                *std::static_pointer_cast<NonPOD>(opaqueValue),
+                *std::static_pointer_cast<NonPOD>(expectedOpaqueValue));
+          } else {
+            child->compare(mapValues.get(), row, valueIdx.value());
+          }
+        } else if (options.replaceNulls) {
+          VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+              verifyDefaultValue, child->type()->kind(), child, row);
+        } else {
+          ASSERT_TRUE(child->isNullAt(row));
+        }
+      }
+    });
+  }
+
+  // Helper to create SelectivityVector for different selected patterns
+  SelectivityVector createSelectivityVector(
+      vector_size_t size,
+      const std::string& pattern) {
+    SelectivityVector rows(size);
+    if (pattern == "all") {
+      // All rows selected (default)
+    } else if (pattern == "start") {
+      // First half selected
+      rows.setValidRange(size / 2, size, false);
+    } else if (pattern == "end") {
+      // Second half selected
+      rows.setValidRange(0, size / 2, false);
+    } else if (pattern == "mid") {
+      // Middle quarter selected
+      auto start = size / 4;
+      auto end = 3 * size / 4;
+      rows.setValidRange(0, start, false);
+      rows.setValidRange(end, size, false);
+    } else if (pattern == "scattered") {
+      // Every 3rd row selected
+      rows.clearAll();
+      for (auto i = 0; i < size; i += 3) {
+        rows.setValid(i, true);
+      }
+    }
+    rows.updateBounds();
+    return rows;
+  }
+
+  // Helper functions to execute a single test case with different parameters
+  // like selected rows and replaceNulls verify the result.
+  void executeTestCase(MapVectorPtr& testCase) {
+    auto keysToProject = makeFlatVector<int64_t>({1, 2});
+    auto outputFieldNames = std::vector<std::string>{"key1", "key2"};
+    MakeRowFromMapOptions options{
+        .keysToProject = keysToProject,
+        .outputFieldNames = outputFieldNames,
+        .replaceNulls = false,
+        .allowTopLevelNulls = false,
+        .throwOnDuplicateKeys = false};
+    for (bool replaceNulls : {false, true}) {
+      for (bool allowTopLevelNulls : {false, true}) {
+        for (bool useEvalCtx : {false, true}) {
+          for (std::string selectedRowsStr :
+               {"all", "start", "end", "mid", "scattered"}) {
+            if (replaceNulls &&
+                testCase->type()->asMap().valueType()->kind() ==
+                    TypeKind::ROW) {
+              continue;
+            }
+            SCOPED_TRACE(
+                "Selected Rows: " + selectedRowsStr +
+                " replaceNulls: " + std::to_string(replaceNulls) +
+                " allowTopLevelNulls: " + std::to_string(allowTopLevelNulls) +
+                " useEvalCtx: " + std::to_string(useEvalCtx) +
+                " MapType: " + testCase->type()->toString());
+            auto rows =
+                createSelectivityVector(testCase->size(), selectedRowsStr);
+            options.replaceNulls = replaceNulls;
+            options.allowTopLevelNulls = allowTopLevelNulls;
+            std::optional<exec::EvalCtx> evalCtx;
+            if (useEvalCtx) {
+              exec::EvalCtx evalCtx(
+                  execCtx_.get(), &dummyExprSet, dummyRowVector.get());
+              auto result = toRowVector<TypeKind::BIGINT>(
+                  *testCase, options, rows, &evalCtx);
+              verifyResult(result, testCase, rows, options);
+            } else {
+              auto result =
+                  toRowVector<TypeKind::BIGINT>(*testCase, options, rows);
+              verifyResult(result, testCase, rows, options);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  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())};
+  // Dummy EvalCtx and related objects to pass to MakeRowFroMap when
+  // testing the code path that uses EvalCtx.
+  exec::ExprSet dummyExprSet{{}, execCtx_.get()};
+  RowVectorPtr dummyRowVector = makeRowVector({});
+};
+
+TEST_F(MakeRowFroMapTest, basic) {
+  EXPECT_EQ(NonPOD::alive, 0);
+  auto testCases = makeTestCases();
+  for (auto& testCase : testCases) {
+    executeTestCase(testCase);
+    break;
+  }
+  testCases.clear();
+  EXPECT_EQ(NonPOD::alive, 0);
+}
+
+TEST_F(MakeRowFroMapTest, unknownTypeValues) {
+  auto testCase = makeMapVectorFromJson<int64_t, int64_t>(
+      {"{1:1, 2:2, 3:3}", // All valid values
+       "{2:20, 4:40, 7:3}", // Only one projected key
+       "{1:100, 2:null, 6:600}", // Null Value
+       "{4:4000, 6:6000}", // No projected keys
+       "{1:10000}", // single element, projected key
+       "{}", // empty map
+       "null"}); // null map
+  auto unknownTypeValues =
+      BaseVector::create(UNKNOWN(), testCase->mapValues()->size(), pool());
+
+  testCase = std::make_shared<MapVector>(
+      pool(),
+      MAP(BIGINT(), UNKNOWN()),
+      testCase->nulls(),
+      testCase->size(),
+      testCase->offsets(),
+      testCase->sizes(),
+      testCase->mapKeys(),
+      unknownTypeValues);
+
+  SelectivityVector rows(testCase->size());
+  auto keysToProject = makeFlatVector<int64_t>({1, 2});
+  auto outputFieldNames = std::vector<std::string>{"key1", "key2"};
+  MakeRowFromMapOptions options{
+      .keysToProject = keysToProject,
+      .outputFieldNames = outputFieldNames,
+      .replaceNulls = false,
+      .allowTopLevelNulls = false,
+      .throwOnDuplicateKeys = false};
+  auto result = toRowVector<TypeKind::BIGINT>(*testCase, options, rows);
+
+  auto expectedType = ROW(outputFieldNames, {UNKNOWN(), UNKNOWN()});
+  ASSERT_EQ(*result->type(), *expectedType);
+  ASSERT_EQ(result->size(), testCase->size());
+
+  options.replaceNulls = true;
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*testCase, options, rows),
+      "Unsupported type for replacing nulls: UNKNOWN");
+}
+
+TEST_F(MakeRowFroMapTest, encoded) {
+  EXPECT_EQ(NonPOD::alive, 0);
+  auto testCases = makeTestCases();
+  auto reverseIndices = makeIndicesInReverse(testCases[0]->size());
+  auto reverseElementIndices =
+      makeIndicesInReverse(testCases[0]->mapKeys()->size());
+
+  // Wrap the top level map with a dictionary and a constant encoding.
+  for (auto& testCase : testCases) {
+    auto dictOnMap = BaseVector::wrapInDictionary(
+        nullptr, reverseIndices, testCase->size(), testCase);
+    executeTestCase(testCase);
+
+    auto constOnMap =
+        BaseVector::wrapInConstant(testCase->size(), 0, dictOnMap);
+    executeTestCase(testCase);
+  }
+
+  // Wrap the keys and values with a dictionary encoding.
+  for (auto& testCase : testCases) {
+    auto elementsSizes = testCase->mapValues()->size();
+    auto dictKeys = BaseVector::wrapInDictionary(
+        nullptr, reverseElementIndices, elementsSizes, testCase->mapKeys());
+    auto dictValues = BaseVector::wrapInDictionary(
+        nullptr, reverseElementIndices, elementsSizes, testCase->mapValues());
+    testCase->setKeysAndValues(dictKeys, dictValues);
+    executeTestCase(testCase);
+  }
+  testCases.clear();
+  EXPECT_EQ(NonPOD::alive, 0);
+}
+
+TEST_F(MakeRowFroMapTest, errorCases) {
+  SelectivityVector rows(1);
+  auto validMap = makeMapVectorFromJson<int64_t, int64_t>({"{1:1, 2:2, 3:3}"});
+
+  // Input of typeKind other than Map used
+  MakeRowFromMapOptions options{
+      .keysToProject = makeFlatVector<int64_t>({1, 2}),
+      .outputFieldNames = {"1", "2"},
+      .replaceNulls = false,
+      .allowTopLevelNulls = false,
+      .throwOnDuplicateKeys = false};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*(validMap->mapKeys()), options, rows),
+      "Input must be of MAP typeKind");
+
+  // Mismatched Type between keysToProject and map keys
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(
+          *makeMapVectorFromJson<int32_t, int64_t>({"{1:1}"}), options, rows),
+      "(INTEGER vs. BIGINT) Map key type and the type of keys to project are not the same");
+
+  // Mismatched Type between keysToProject and template type of toRowVector
+  options.keysToProject = makeFlatVector<int32_t>({1, 2});
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Unexptected key TypeKind");
+
+  // Invalid key type
+  options.keysToProject = makeFlatVector<int32_t>({1, 2});
+  options.keysToProject->setType(DATE());
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::INTEGER>(*validMap, options, rows),
+      "Only SMALLINT, INTEGER, BIGINT keys are currently supported, instead got DATE");
+
+  // Keys to project are not empty
+  options.keysToProject->resize(0);
+  options.outputFieldNames = {"key1", "key2"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Keys to project cannot be empty");
+
+  // Mismatched size between keysToProject and outputFieldNames
+  options.keysToProject = makeFlatVector<int64_t>({1, 2});
+  options.outputFieldNames = {"key1"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Number of keys to project and output field names must be the same");
+
+  // One of the outputFieldNames is empty.
+  options.keysToProject = makeFlatVector<int64_t>({1, 2});
+  options.outputFieldNames = {"", "key2"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Field name cannot be empty");
+
+  // One of the outputFieldNames is duplicate.
+  options.keysToProject = makeFlatVector<int64_t>({1, 2});
+  options.outputFieldNames = {"key1", "key1"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Duplicate field names are not allowed: key1");
+
+  // Keys to project cannot contain null
+  options.keysToProject = makeNullableFlatVector<int64_t>({1, std::nullopt});
+  options.outputFieldNames = {"key1", "key2"};
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Keys to project cannot contain null");
+
+  // Duplicate keys not allowed
+  options.keysToProject = makeFlatVector<int64_t>({1, 1});
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*validMap, options, rows),
+      "Duplicate keys cannot be projected");
+
+  // Replace nulls is true, but map values are of ROW type
+  auto rowValues = makeRowVector({makeFlatVector<int64_t>({1, 2, 3})});
+  options.keysToProject = makeFlatVector<int64_t>({1, 2});
+  options.replaceNulls = true;
+  auto mapWithRowValues = std::make_shared<MapVector>(
+      pool(),
+      MAP(validMap->mapKeys()->type(), rowValues->type()),
+      validMap->nulls(),
+      validMap->size(),
+      validMap->offsets(),
+      validMap->sizes(),
+      validMap->mapKeys(),
+      rowValues);
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*mapWithRowValues, options, rows),
+      "Unsupported type for replacing nulls: ROW");
+}
+
+TEST_F(MakeRowFroMapTest, duplicateKey) {
+  auto testCase = makeMapVector<int64_t, int64_t>({
+      {{1, 1}, {2, 2}, {2, 3}},
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  MakeRowFromMapOptions options{
+      .keysToProject = makeFlatVector<int64_t>({1, 2}),
+      .outputFieldNames = std::vector<std::string>{"key1", "key2"},
+      .replaceNulls = false,
+      .allowTopLevelNulls = false,
+      .throwOnDuplicateKeys = true};
+  SelectivityVector rows(testCase->size());
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*testCase, options, rows),
+      "Duplicate keys not allowed");
+  exec::EvalCtx evalCtx(execCtx_.get(), &dummyExprSet, dummyRowVector.get());
+  VELOX_ASSERT_THROW(
+      toRowVector<TypeKind::BIGINT>(*testCase, options, rows, &evalCtx),
+      "Duplicate keys not allowed");
+
+  // Verify that the error is thrown only for the first duplicate key and the
+  // rest of the rows are evaluated.
+  exec::EvalCtx contextNoThrow(
+      execCtx_.get(), &dummyExprSet, dummyRowVector.get());
+  *contextNoThrow.mutableThrowOnError() = false;
+  auto result =
+      toRowVector<TypeKind::BIGINT>(*testCase, options, rows, &contextNoThrow);
+  auto expected = makeRowVector(
+      options.outputFieldNames,
+      {makeNullableFlatVector<int64_t>({std::nullopt, 10}),
+       makeNullableFlatVector<int64_t>({std::nullopt, 20})});
+  ASSERT_TRUE(contextNoThrow.errors()->hasErrorAt(0));
+  SelectivityVector expectedRows(result->size());
+  contextNoThrow.deselectErrors(expectedRows);
+  test::assertEqualVectors(expected, result, expectedRows);
+
+  // Verify that the value from the last encountered duplicate key is used when
+  // duplicate keys are allowed.
+  options.throwOnDuplicateKeys = false;
+  result = toRowVector<TypeKind::BIGINT>(*testCase, options, rows);
+  expected = makeRowVector(
+      options.outputFieldNames,
+      {makeFlatVector<int64_t>({1, 10}), makeFlatVector<int64_t>({3, 20})});
+  test::assertEqualVectors(expected, result);
+
+  // Ensure no error is thrown if the row with the duplicate key is not
+  // selected and duplicate keys are not allowed.
+  rows.setValid(0, false);
+  rows.updateBounds();
+  options.throwOnDuplicateKeys = true;
+  result = toRowVector<TypeKind::BIGINT>(*testCase, options, rows);
+  test::assertEqualVectors(expected, result, rows);
+}
+
+class MakeRowFromMapDefaultsTest : public testing::Test,
+                                   public test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  template <typename T>
+  void verifyPrimitiveDefaults(const VectorPtr& vector, T expectedDefault) {
+    ASSERT_TRUE(vector->isFlatEncoding());
+    auto flatVector = vector->asFlatVector<T>();
+    for (auto i = 0; i < vector->size(); ++i) {
+      ASSERT_EQ(flatVector->valueAt(i), expectedDefault) << " at row " << i;
+    }
+  }
+
+  void verifyArrayVectorBaseDefaults(const VectorPtr& vector) {
+    ASSERT_TRUE(
+        vector->encoding() == VectorEncoding::Simple::ARRAY ||
+        vector->encoding() == VectorEncoding::Simple::MAP);
+    auto arrayVectorBase = vector->asUnchecked<ArrayVectorBase>();
+    for (auto i = 0; i < vector->size(); ++i) {
+      ASSERT_EQ(arrayVectorBase->sizeAt(i), 0) << " at row " << i;
+      ASSERT_EQ(arrayVectorBase->offsetAt(i), 0) << " at row " << i;
+    }
+  }
+};
+
+TEST_F(MakeRowFromMapDefaultsTest, createFlatPrimitiveTypes) {
+  vector_size_t size = 5;
+  // Test INTEGER
+  auto integerVector =
+      MakeRowFromMapDefaults::createFlat(INTEGER(), size, *pool(), nullptr);
+  verifyPrimitiveDefaults<int32_t>(integerVector, 0);
+
+  // Test VARCHAR
+  auto varcharVector =
+      MakeRowFromMapDefaults::createFlat(VARCHAR(), size, *pool(), nullptr);
+  verifyPrimitiveDefaults<StringView>(varcharVector, StringView());
+
+  // Test TIMESTAMP
+  auto timestampVector =
+      MakeRowFromMapDefaults::createFlat(TIMESTAMP(), size, *pool(), nullptr);
+  verifyPrimitiveDefaults<Timestamp>(timestampVector, Timestamp());
+}
+
+TEST_F(MakeRowFromMapDefaultsTest, createFlatComplexTypes) {
+  vector_size_t size = 5;
+
+  // Test ARRAY
+  auto arrayVector = MakeRowFromMapDefaults::createFlat(
+      ARRAY(INTEGER()), size, *pool(), nullptr);
+  verifyArrayVectorBaseDefaults(arrayVector);
+
+  // Test MAP
+  auto mapVector = MakeRowFromMapDefaults::createFlat(
+      MAP(INTEGER(), VARCHAR()), size, *pool(), nullptr);
+  verifyArrayVectorBaseDefaults(mapVector);
+}
+
+TEST_F(MakeRowFromMapDefaultsTest, createConstantPrimitiveTypes) {
+  vector_size_t size = 5;
+
+  // Test BIGINT constant
+  auto bigintConstant =
+      MakeRowFromMapDefaults::createConstant(BIGINT(), size, *pool());
+  ASSERT_TRUE(bigintConstant->isConstantEncoding());
+  ASSERT_EQ(bigintConstant->size(), size);
+  ASSERT_EQ(
+      bigintConstant->asUnchecked<ConstantVector<int64_t>>()->valueAt(0), 0);
+
+  // Test VARCHAR constant
+  auto varcharConstant =
+      MakeRowFromMapDefaults::createConstant(VARCHAR(), size, *pool());
+  ASSERT_TRUE(varcharConstant->isConstantEncoding());
+  ASSERT_EQ(varcharConstant->size(), size);
+  ASSERT_EQ(
+      varcharConstant->asUnchecked<ConstantVector<StringView>>()->valueAt(0),
+      StringView());
+}
+
+TEST_F(MakeRowFromMapDefaultsTest, createConstantComplexTypes) {
+  vector_size_t size = 5;
+
+  // Test ARRAY constant
+  auto arrayConstant =
+      MakeRowFromMapDefaults::createConstant(ARRAY(INTEGER()), size, *pool());
+  ASSERT_TRUE(arrayConstant->isConstantEncoding());
+  ASSERT_EQ(arrayConstant->size(), size);
+  verifyArrayVectorBaseDefaults(arrayConstant->valueVector());
+
+  // Test MAP constant
+  auto mapConstant = MakeRowFromMapDefaults::createConstant(
+      MAP(BIGINT(), VARCHAR()), size, *pool());
+  ASSERT_TRUE(mapConstant->isConstantEncoding());
+  ASSERT_EQ(mapConstant->size(), size);
+  verifyArrayVectorBaseDefaults(mapConstant->valueVector());
+}
+
+TEST_F(MakeRowFromMapDefaultsTest, unsupportedTypes) {
+  vector_size_t size = 5;
+
+  VELOX_ASSERT_THROW(
+      MakeRowFromMapDefaults::createConstant(ROW({BIGINT()}), size, *pool()),
+      "Unsupported type for replacing nulls: ROW<\"\":BIGINT>");
+
+  VELOX_ASSERT_THROW(
+      MakeRowFromMapDefaults::createConstant(UNKNOWN(), size, *pool()),
+      "Unsupported type for replacing nulls: UNKNOWN");
+}
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/lib/tests/QuantileDigestTest.cpp b/velox/functions/lib/tests/QuantileDigestTest.cpp
index 7a918f327a07..59b62e7b86c7 100644
--- a/velox/functions/lib/tests/QuantileDigestTest.cpp
+++ b/velox/functions/lib/tests/QuantileDigestTest.cpp
@@ -26,6 +26,8 @@ namespace facebook::velox::functions {
 
 class QuantileDigestTest : public QuantileDigestTestBase {
  protected:
+  static constexpr double kTruncatedMeanTolerance = 1e-2;
+
   memory::MemoryPool* pool() {
     return pool_.get();
   }
@@ -73,13 +75,308 @@ class QuantileDigestTest : public QuantileDigestTestBase {
   void testHugeWeight() {
     constexpr int N = 10;
     constexpr double kAccuracy = 0.99;
-    constexpr T kMaxValue = std::numeric_limits<T>::max();
+    constexpr double kMaxValue = std::numeric_limits<double>::max();
     QuantileDigest<T> digest{StlAllocator<T>(allocator()), kAccuracy};
     for (auto i = 0; i < N; ++i) {
       digest.add(T(i), kMaxValue);
     }
   }
 
+  template <typename T>
+  void testQuantileAtValueWithData(
+      const std::vector<T>& inputValues,
+      const std::vector<std::pair<T, double>>& testCases,
+      const std::vector<T>& outOfRangeValues) {
+    constexpr double kAccuracy = 1.0E-2;
+    constexpr double kTolerance = 1.0E-3;
+
+    QuantileDigest<T> digest{StlAllocator<T>(allocator()), kAccuracy};
+    for (const auto& value : inputValues) {
+      digest.add(value, 1.0);
+    }
+
+    for (const auto& [testValue, expectedQuantile] : testCases) {
+      EXPECT_NEAR(
+          *digest.quantileAtValue(testValue), expectedQuantile, kTolerance);
+    }
+
+    for (const auto& outOfRangeValue : outOfRangeValues) {
+      EXPECT_FALSE(digest.quantileAtValue(outOfRangeValue).has_value());
+    }
+  }
+
+  template <typename T>
+  void testQuantileAtValueWithDigest(
+      const QuantileDigest<T>& digest,
+      const std::vector<T>& testData,
+      const std::vector<std::optional<double>>& expectedData,
+      const double tokerance) {
+    for (auto i = 0; i < testData.size(); ++i) {
+      if (expectedData[i].has_value()) {
+        EXPECT_NEAR(
+            *digest.quantileAtValue(testData[i]),
+            expectedData[i].value(),
+            tokerance);
+      } else {
+        EXPECT_FALSE(digest.quantileAtValue(testData[i]).has_value());
+      }
+    }
+  }
+
+  // A helper function to verify ValueCountPair vectors match.
+  template <typename VectorType, typename T>
+  void verifyValueCountPairs(
+      const VectorType& actual,
+      const std::vector<std::pair<T, double>>& expected) {
+    EXPECT_EQ(actual.size(), expected.size());
+    for (size_t i = 0; i < expected.size(); ++i) {
+      EXPECT_EQ(actual[i].value, expected[i].first);
+      EXPECT_EQ(actual[i].count, expected[i].second);
+    }
+  }
+
+  // A helper function to compute truncated mean for testing.
+  template <typename T>
+  std::optional<double> getTruncatedMean(
+      const QuantileDigest<T>& digest,
+      double lowerQuantileBound,
+      double upperQuantileBound) {
+    auto valuesAndCounts =
+        digest.getValuesInQuantileRange(lowerQuantileBound, upperQuantileBound);
+
+    if (valuesAndCounts.empty()) {
+      return std::nullopt;
+    }
+
+    double totalValue = 0.0;
+    double totalCount = 0.0;
+
+    for (const auto& pair : valuesAndCounts) {
+      totalValue += pair.value * pair.count;
+      totalCount += pair.count;
+    }
+
+    return totalValue / totalCount;
+  }
+
+  // A helper function to get the expected quantile at value for
+  // qdigest comes from a query "SELECT QDIGEST_AGG(CAST(c0 AS BIGINT), 1, 0.99)
+  // FROM UNNEST(SEQUENCE(-5000, 4999)) AS t(c0)".
+  template <typename T>
+  std::vector<std::optional<double>> getExpectedQuantileAtValue() {
+    // Expected quantile values for different data types at specific test points
+    // Format: {int64_t_result, double_result, float_result} // test_value
+    // std::nullopt indicates the value is out of digest range
+    std::vector<std::vector<std::optional<double>>> expectedDatas{
+        {std::nullopt, std::nullopt, std::nullopt}, // -5001 (out of range)
+        {0, 0, std::nullopt}, // -5000 (min boundary)
+        {0, 0, std::nullopt}, // -4996
+        {0.0302, 0.0128, std::nullopt}, // -4990
+        {0.0302, 0.0128, std::nullopt}, // -4980
+        {0.0302, 0.0217, 0}, // -4850
+        {0.2884, 0.2789, 0.2919}, // -2000
+        {0.5, 0.4925, 0.5}, //     0 (median)
+        {0.6718, 0.6492, 0.6567}, //  2000
+        {0.7099, 0.6873, 0.6948}, //  2111
+        {0.8017, 0.7791, 0.7866}, //  3111
+        {0.9019, 0.8687, 0.8762}, //  4111
+        {0.9645, 0.9313, 0.9388}, //  4879
+        {std::nullopt, std::nullopt, std::nullopt}, //  4880 (out of range)
+        {std::nullopt, std::nullopt, std::nullopt}, //  5000 (out of range)
+    };
+
+    std::vector<std::optional<double>> result;
+    constexpr int typeIndex = std::is_same_v<T, int64_t> ? 0
+        : std::is_same_v<T, double>                      ? 1
+                                                         : 2;
+
+    result.reserve(expectedDatas.size());
+    for (const auto& row : expectedDatas) {
+      result.push_back(row[typeIndex]);
+    }
+    return result;
+  }
+
+  template <typename T>
+  void testQuantileAtValue() {
+    constexpr double kAccuracy = 1.0E-2;
+    constexpr double kTolerance = 1.0E-3;
+
+    // Test: Histogram-equivalent test with values 0-9 (from Java test)
+    {
+      QuantileDigest<T> digest{StlAllocator<T>(allocator()), 1.0};
+      for (int i = 0; i < 10; ++i) {
+        digest.add(static_cast<T>(i), 1.0);
+      }
+
+      for (int i = 0; i <= 9; ++i) {
+        auto q = digest.quantileAtValue(static_cast<T>(i));
+        EXPECT_TRUE(q.has_value());
+        EXPECT_NEAR(q.value(), i / 10.0, kTolerance);
+      }
+
+      // Values outside the range [0, 9] should return no value
+      EXPECT_FALSE(digest.quantileAtValue(static_cast<T>(-1)).has_value());
+      EXPECT_FALSE(digest.quantileAtValue(static_cast<T>(10)).has_value());
+      EXPECT_FALSE(
+          digest.quantileAtValue(std::numeric_limits<T>::max()).has_value());
+    }
+
+    // Test: Basic weighted test
+    {
+      QuantileDigest<T> digest{StlAllocator<T>(allocator()), kAccuracy};
+      digest.add(static_cast<T>(1), 1.0);
+      digest.add(static_cast<T>(2), 2.0);
+      digest.add(static_cast<T>(3), 3.0);
+      digest.add(static_cast<T>(4), 4.0);
+      EXPECT_NEAR(*digest.quantileAtValue(static_cast<T>(1)), 0.0, kTolerance);
+      EXPECT_NEAR(*digest.quantileAtValue(static_cast<T>(2)), 0.1, kTolerance);
+      EXPECT_NEAR(*digest.quantileAtValue(static_cast<T>(3)), 0.3, kTolerance);
+      EXPECT_NEAR(*digest.quantileAtValue(static_cast<T>(4)), 0.6, kTolerance);
+    }
+
+    // Test: Values from -4999 to 4999 to cover both negative and positive
+    // QDigest
+    {
+      std::vector<T> inputValues;
+      for (int64_t i = -4999; i <= 4999; i++) {
+        inputValues.push_back(static_cast<T>(i));
+      }
+
+      std::vector<std::pair<T, double>> testCases = {
+          {static_cast<T>(-4996), 0.0},
+          {static_cast<T>(-4995), 0.0002},
+          {static_cast<T>(-4994), 0.0002},
+          {static_cast<T>(-4990), 0.0006},
+          {static_cast<T>(-4980), 0.0016},
+          {static_cast<T>(-2000), 0.2998},
+          {static_cast<T>(0), 0.4999},
+          {static_cast<T>(2000), 0.6999},
+          {static_cast<T>(4980), 0.9979},
+          {static_cast<T>(4990), 0.9989},
+          {static_cast<T>(4994), 0.9993},
+          {static_cast<T>(4995), 0.9994},
+          {static_cast<T>(4996), 0.9995},
+          {static_cast<T>(4997), 0.9996},
+          {static_cast<T>(4997), 0.9998},
+      };
+
+      std::vector<T> outOfRangeValues = {
+          static_cast<T>(-5000), static_cast<T>(5000)};
+
+      testQuantileAtValueWithData(inputValues, testCases, outOfRangeValues);
+    }
+
+    // Additional floating point test with fractional values
+    if constexpr (std::is_floating_point_v<T>) {
+      std::vector<T> inputValues;
+      for (int i = -4999; i <= 4999; i++) {
+        inputValues.push_back(static_cast<T>(i + 0.1 * i));
+      }
+
+      std::vector<std::pair<T, double>> testCases = {
+          {static_cast<T>(-5498), 0.0001},
+          {static_cast<T>(-5493.99), 0.0005},
+          {static_cast<T>(-5491.99), 0.0007},
+          {static_cast<T>(-5488.99), 0.0010},
+          {static_cast<T>(0.0), 0.4999},
+          {static_cast<T>(100.001), 0.5090},
+          {static_cast<T>(200.001), 0.5181},
+          {static_cast<T>(1999.009), 0.6817},
+          {static_cast<T>(4999.009), 0.9544},
+          {static_cast<T>(5497.999), 0.9998},
+      };
+
+      std::vector<T> outOfRangeValues = {
+          static_cast<T>(-5500), static_cast<T>(5500.0)};
+
+      testQuantileAtValueWithData(inputValues, testCases, outOfRangeValues);
+    }
+
+    // Test with qdigest directly deserialized from FROM_BASE64 string
+    {
+      // Test the quantile at value for below data points
+      std::vector<T> testData = {
+          static_cast<T>(-5001),
+          static_cast<T>(-5000),
+          static_cast<T>(-4996),
+          static_cast<T>(-4990),
+          static_cast<T>(-4980),
+          static_cast<T>(-4850),
+          static_cast<T>(-2000),
+          static_cast<T>(0),
+          static_cast<T>(2000),
+          static_cast<T>(2111),
+          static_cast<T>(3111),
+          static_cast<T>(4111),
+          static_cast<T>(4879),
+          static_cast<T>(4880),
+          static_cast<T>(5000),
+      };
+      std::string serializeStr = []() {
+        if constexpr (std::is_same_v<T, int64_t>) {
+          return decodeBase64(
+              "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAHjs////////hxMAAAAAAABUAAAAFAAAAAAA4HJAeOz//////38MAAAAAACAWUAa7v//////fxAAAAAAAABnQAHv//////9/IwAAAAAAwGNAGu7//////38nAAAAAAAAAAB47P//////fxAAAAAAAIBtQBTw//////9/EAAAAAAAAGFADPL//////38QAAAAAAAAb0AI8///////fyMAAAAAAAAAAAzy//////9/JwAAAAAAAHFAFPD//////38UAAAAAABgdEAg9P//////fxQAAAAAAKBzQAr2//////9/JwAAAAAAgGdAIPT//////38rAAAAAACAZEAU8P//////fxAAAAAAAMBvQAL4//////9/EAAAAAAAAHBAAPn//////38jAAAAAAAAAAAC+P//////fyUAAAAAAIBvQAL4//////9/EAAAAAAAgGlANP3//////38AAAAAAAAAAED+////////fx4AAAAAAABlQFb///////9/IgAAAAAAAHVABv7//////38nAAAAAADAckAO/P//////fysAAAAAACBxQAL4//////9/LwAAAAAAAAAAFPD//////38zAAAAAABAdEB47P//////fwgAAAAAAABNQEYAAAAAAACADAAAAAAAQF5AhwAAAAAAAIAfAAAAAAAAAAAAAAAAAAAAgAwAAAAAAABgQAABAAAAAACADAAAAAAAAGBAgAEAAAAAAIAfAAAAAAAAAAAAAQAAAAAAgCMAAAAAAAAAAAAAAAAAAACADAAAAAAAAGBAAAIAAAAAAIAMAAAAAAAAYECAAgAAAAAAgB8AAAAAAAAAAAACAAAAAACAIQAAAAAAQFtAAAIAAAAAAIAnAAAAAABgYkAAAAAAAAAAgAwAAAAAAABgQAAEAAAAAACADAAAAAAAAGBAgAQAAAAAAIAfAAAAAAAAAAAABAAAAAAAgAwAAAAAAEBZQJsFAAAAAACAIwAAAAAAQFBAAAQAAAAAAIAMAAAAAAAAYEAABgAAAAAAgAwAAAAAAABgQIAGAAAAAACAHwAAAAAAAAAAAAYAAAAAAIAMAAAAAABAV0CjBwAAAAAAgB4AAAAAAEBQQGIHAAAAAACAIwAAAAAAgFhAAAYAAAAAAIAnAAAAAACAVkAABAAAAAAAgCsAAAAAAAAAAAAAAAAAAACADAAAAAAAAGBAAAgAAAAAAIAMAAAAAAAAYECACAAAAAAAgB8AAAAAAAAAAAAIAAAAAACAIQAAAAAAwGJAAAgAAAAAAIAMAAAAAAAAYEAACgAAAAAAgAwAAAAAAABgQIAKAAAAAACAHwAAAAAAAAAAAAoAAAAAAIAQAAAAAADAYUByCwAAAAAAgCMAAAAAAIBcQAAKAAAAAACAJwAAAAAAAAAAAAgAAAAAAIAMAAAAAAAAYEAADAAAAAAAgAwAAAAAAABgQIAMAAAAAACAHwAAAAAAAAAAAAwAAAAAAIAhAAAAAADAYEAADAAAAAAAgAwAAAAAAABgQAAOAAAAAACADAAAAAAAAGBAgA4AAAAAAIAfAAAAAAAAAAAADgAAAAAAgAwAAAAAAIBfQIIPAAAAAACAIwAAAAAAQGBAAA4AAAAAAIAnAAAAAAAAAAAADAAAAAAAgCsAAAAAAIBeQAAIAAAAAACALwAAAAAAgFpAAAAAAAAAAIAMAAAAAACAXkCGEAAAAAAAgAwAAAAAAIBdQIoRAAAAAACAHgAAAAAAQGBACBEAAAAAAIAjAAAAAAAAAAAEEAAAAAAAgAwAAAAAAIBcQI4SAAAAAACAHgAAAAAAwGFAABIAAAAAAIAQAAAAAAAAYUAAEwAAAAAAgCMAAAAAAAAAAAASAAAAAACAJwAAAAAAQGFABBAAAAAAAIAzAAAAAABAVEAAAAAAAAAAgP8AAAAAAAAAAHjs//////9/");
+        }
+        if constexpr (std::is_same_v<T, double>) {
+          return decodeBase64(
+              "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");
+        }
+        return decodeBase64(
+            "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");
+      }();
+
+      QuantileDigest<T> digest{
+          StlAllocator<T>(allocator()), serializeStr.data()};
+      const auto expectedData = getExpectedQuantileAtValue<T>();
+
+      testQuantileAtValueWithDigest(digest, testData, expectedData, kTolerance);
+    }
+
+    // Test with empty digest
+    {
+      QuantileDigest<T> digest{StlAllocator<T>(allocator()), kAccuracy};
+      EXPECT_FALSE(digest.quantileAtValue(static_cast<T>(1)).has_value());
+    }
+
+    // Test: Inverse relationship with estimateQuantile
+    if constexpr (std::is_floating_point_v<T>) {
+      QuantileDigest<T> digest{StlAllocator<T>(allocator()), kAccuracy};
+      for (int i = -10000; i <= 10000; ++i) {
+        digest.add(static_cast<T>(i), 1.0);
+      }
+
+      std::vector<double> quantiles = {
+          0.01, 0.0011, 0.02, 0.25, 0.5, 0.75, 0.9, 0.98, 0.99, 0.999, 1.0};
+      for (double q : quantiles) {
+        T value = digest.estimateQuantile(q);
+        auto inverseQ = digest.quantileAtValue(value);
+        EXPECT_TRUE(inverseQ.has_value());
+        EXPECT_NEAR(*inverseQ, q, kTolerance);
+      }
+    }
+
+    // Test Inverse relationship with estimateQuantile with random weights
+    if constexpr (std::is_floating_point_v<T>) {
+      QuantileDigest<T> digest{StlAllocator<T>(allocator()), kAccuracy};
+      std::default_random_engine gen(common::testutil::getRandomSeed(42));
+      std::uniform_real_distribution<T> dist;
+      for (int i = -10000; i <= 10000; ++i) {
+        auto weight = dist(gen);
+        digest.add(static_cast<T>(i), weight);
+      }
+
+      std::vector<double> quantiles = {
+          0.01, 0.0011, 0.02, 0.25, 0.5, 0.75, 0.9, 0.98, 0.99, 0.999, 1.0};
+      for (double q : quantiles) {
+        T value = digest.estimateQuantile(q);
+        auto inverseQ = digest.quantileAtValue(value);
+        EXPECT_TRUE(inverseQ.has_value());
+        EXPECT_NEAR(*inverseQ, q, kTolerance);
+      }
+    }
+  }
+
   template <typename T>
   void testLargeInputSize() {
     constexpr int N = 1e5;
@@ -545,6 +842,74 @@ TEST_F(QuantileDigestTest, scale) {
   testScale<float>();
 }
 
+TEST_F(QuantileDigestTest, scaleMatchesJava) {
+  // Test with int64_t QDigest
+  {
+    std::string encodedBuf =
+        "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAHjs////////hxMAAAAAAABUAAAAFAAAAAAA4HJAeOz//////38MAAAAAACAWUAa7v//////fxAAAAAAAABnQAHv//////9/IwAAAAAAwGNAGu7//////38nAAAAAAAAAAB47P//////fxAAAAAAAIBtQBTw//////9/EAAAAAAAAGFADPL//////38QAAAAAAAAb0AI8///////fyMAAAAAAAAAAAzy//////9/JwAAAAAAAHFAFPD//////38UAAAAAABgdEAg9P//////fxQAAAAAAKBzQAr2//////9/JwAAAAAAgGdAIPT//////38rAAAAAACAZEAU8P//////fxAAAAAAAMBvQAL4//////9/EAAAAAAAAHBAAPn//////38jAAAAAAAAAAAC+P//////fyUAAAAAAIBvQAL4//////9/EAAAAAAAgGlANP3//////38AAAAAAAAAAED+////////fx4AAAAAAABlQFb///////9/IgAAAAAAAHVABv7//////38nAAAAAADAckAO/P//////fysAAAAAACBxQAL4//////9/LwAAAAAAAAAAFPD//////38zAAAAAABAdEB47P//////fwgAAAAAAABNQEYAAAAAAACADAAAAAAAQF5AhwAAAAAAAIAfAAAAAAAAAAAAAAAAAAAAgAwAAAAAAABgQAABAAAAAACADAAAAAAAAGBAgAEAAAAAAIAfAAAAAAAAAAAAAQAAAAAAgCMAAAAAAAAAAAAAAAAAAACADAAAAAAAAGBAAAIAAAAAAIAMAAAAAAAAYECAAgAAAAAAgB8AAAAAAAAAAAACAAAAAACAIQAAAAAAQFtAAAIAAAAAAIAnAAAAAABgYkAAAAAAAAAAgAwAAAAAAABgQAAEAAAAAACADAAAAAAAAGBAgAQAAAAAAIAfAAAAAAAAAAAABAAAAAAAgAwAAAAAAEBZQJsFAAAAAACAIwAAAAAAQFBAAAQAAAAAAIAMAAAAAAAAYEAABgAAAAAAgAwAAAAAAABgQIAGAAAAAACAHwAAAAAAAAAAAAYAAAAAAIAMAAAAAABAV0CjBwAAAAAAgB4AAAAAAEBQQGIHAAAAAACAIwAAAAAAgFhAAAYAAAAAAIAnAAAAAACAVkAABAAAAAAAgCsAAAAAAAAAAAAAAAAAAACADAAAAAAAAGBAAAgAAAAAAIAMAAAAAAAAYECACAAAAAAAgB8AAAAAAAAAAAAIAAAAAACAIQAAAAAAwGJAAAgAAAAAAIAMAAAAAAAAYEAACgAAAAAAgAwAAAAAAABgQIAKAAAAAACAHwAAAAAAAAAAAAoAAAAAAIAQAAAAAADAYUByCwAAAAAAgCMAAAAAAIBcQAAKAAAAAACAJwAAAAAAAAAAAAgAAAAAAIAMAAAAAAAAYEAADAAAAAAAgAwAAAAAAABgQIAMAAAAAACAHwAAAAAAAAAAAAwAAAAAAIAhAAAAAADAYEAADAAAAAAAgAwAAAAAAABgQAAOAAAAAACADAAAAAAAAGBAgA4AAAAAAIAfAAAAAAAAAAAADgAAAAAAgAwAAAAAAIBfQIIPAAAAAACAIwAAAAAAQGBAAA4AAAAAAIAnAAAAAAAAAAAADAAAAAAAgCsAAAAAAIBeQAAIAAAAAACALwAAAAAAgFpAAAAAAAAAAIAMAAAAAACAXkCGEAAAAAAAgAwAAAAAAIBdQIoRAAAAAACAHgAAAAAAQGBACBEAAAAAAIAjAAAAAAAAAAAEEAAAAAAAgAwAAAAAAIBcQI4SAAAAAACAHgAAAAAAwGFAABIAAAAAAIAQAAAAAAAAYUAAEwAAAAAAgCMAAAAAAAAAAAASAAAAAACAJwAAAAAAQGFABBAAAAAAAIAzAAAAAABAVEAAAAAAAAAAgP8AAAAAAAAAAHjs//////9/";
+    std::string decodedBuf = decodeBase64(encodedBuf);
+    QuantileDigest<int64_t> digest{
+        StlAllocator<int64_t>(allocator()), decodedBuf.data()};
+
+    double scaleFactor = 2.5;
+    digest.scale(scaleFactor);
+
+    std::string scaledBuf(digest.serializedByteSize(), '\0');
+    digest.serialize(scaledBuf.data());
+
+    // Expected serialized form after scaling
+    std::string expectedScaledBuf = decodeBase64(
+        "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAHjs////////hxMAAAAAAABUAAAAEAAAAAAAmIdAeOz//////38IAAAAAADgb0Aa7v//////fwwAAAAAAMB8QAHv//////9/IwAAAAAAsHhAGu7//////38nAAAAAAAAAAB47P//////fwwAAAAAAHCCQBTw//////9/DAAAAAAAQHVADPL//////38MAAAAAABgg0AI8///////fyMAAAAAAAAAAAzy//////9/JwAAAAAAQIVAFPD//////38QAAAAAAB4iUAg9P//////fxAAAAAAAIiIQAr2//////9/JwAAAAAAYH1AIPT//////38rAAAAAACgeUAU8P//////fwwAAAAAANiDQAL4//////9/DAAAAAAAAIRAAPn//////38jAAAAAAAAAAAC+P//////fyUAAAAAALCDQAL4//////9/DAAAAAAA4H9ANP3//////38AAAAAAAAAFED+////////fx4AAAAAAEB6QFb///////9/IgAAAAAAQIpABv7//////38nAAAAAABwh0AO/P//////fysAAAAAAGiFQAL4//////9/LwAAAAAAAAAAFPD//////38zAAAAAABQiUB47P//////fwQAAAAAACBiQEYAAAAAAACACAAAAAAA6HJAhwAAAAAAAIAfAAAAAAAAAAAAAAAAAAAAgAgAAAAAAAB0QAABAAAAAACACAAAAAAAAHRAgAEAAAAAAIAfAAAAAAAAAAAAAQAAAAAAgCMAAAAAAAAAAAAAAAAAAACACAAAAAAAAHRAAAIAAAAAAIAIAAAAAAAAdECAAgAAAAAAgB8AAAAAAAAAAAACAAAAAACAIQAAAAAACHFAAAIAAAAAAIAnAAAAAAD4dkAAAAAAAAAAgAgAAAAAAAB0QAAEAAAAAACACAAAAAAAAHRAgAQAAAAAAIAfAAAAAAAAAAAABAAAAAAAgAgAAAAAAJBvQJsFAAAAAACAIwAAAAAAUGRAAAQAAAAAAIAIAAAAAAAAdEAABgAAAAAAgAgAAAAAAAB0QIAGAAAAAACAHwAAAAAAAAAAAAYAAAAAAIAIAAAAAAAQbUCjBwAAAAAAgB4AAAAAAFBkQGIHAAAAAACAIwAAAAAAoG5AAAYAAAAAAIAnAAAAAAAgbEAABAAAAAAAgCsAAAAAAAAAAAAAAAAAAACACAAAAAAAAHRAAAgAAAAAAIAIAAAAAAAAdECACAAAAAAAgB8AAAAAAAAAAAAIAAAAAACAIQAAAAAAcHdAAAgAAAAAAIAIAAAAAAAAdEAACgAAAAAAgAgAAAAAAAB0QIAKAAAAAACAHwAAAAAAAAAAAAoAAAAAAIAMAAAAAAAwdkByCwAAAAAAgCMAAAAAANBxQAAKAAAAAACAJwAAAAAAAAAAAAgAAAAAAIAIAAAAAAAAdEAADAAAAAAAgAgAAAAAAAB0QIAMAAAAAACAHwAAAAAAAAAAAAwAAAAAAIAhAAAAAADwdEAADAAAAAAAgAgAAAAAAAB0QAAOAAAAAACACAAAAAAAAHRAgA4AAAAAAIAfAAAAAAAAAAAADgAAAAAAgAgAAAAAALBzQIIPAAAAAACAIwAAAAAAUHRAAA4AAAAAAIAnAAAAAAAAAAAADAAAAAAAgCsAAAAAABBzQAAIAAAAAACALwAAAAAAkHBAAAAAAAAAAIAIAAAAAAAQc0CGEAAAAAAAgAgAAAAAAHByQIoRAAAAAACAHgAAAAAAUHRACBEAAAAAAIAjAAAAAAAAAAAEEAAAAAAAgAgAAAAAANBxQI4SAAAAAACAHgAAAAAAMHZAABIAAAAAAIAMAAAAAABAdUAAEwAAAAAAgCMAAAAAAAAAAAASAAAAAACAJwAAAAAAkHVABBAAAAAAAIAzAAAAAABQaUAAAAAAAAAAgP8AAAAAAAAAAHjs//////9/");
+
+    ASSERT_EQ(scaledBuf, expectedScaledBuf);
+  }
+
+  // Test with double QDigest
+  {
+    std::string encodedBuf =
+        "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAP//////d0y/AAAAAACHs0B0AAAAsAAAAAAAAGBA//////93TD+sAAAAAABAVkD//////wBNP6wAAAAAAABUQP//////gE0/vwAAAAAAwFRA//////8ATT/DAAAAAAAAAAD//////3dMP6wAAAAAAABUQP//////gE4/sAAAAAAAAGBA//////8ATz/DAAAAAAAAAAD//////wBOP8cAAAAAAABaQP//////d0w/sAAAAAAAAFhA//////8BUD+wAAAAAAAAUED//////wFRP8MAAAAAAAAAAP//////AVA/rAAAAAAAAFBA//////8BUj+wAAAAAAAAWED//////wFTP8MAAAAAAAAAAP//////AVI/xwAAAAAA4GBA//////8BUD+0AAAAAAAAYED//////wFUP7AAAAAAAMBfQP//////A1Y/rAAAAAAAAFBA//////8BVz/DAAAAAAAAAAD//////wNWP8cAAAAAAIBcQP//////AVQ/ywAAAAAAQFVA//////8BUD+0AAAAAAAAYED//////wFYP6wAAAAAAABQQP//////AVo/rAAAAAAAAFBA//////+BWz/DAAAAAAAAWUD//////wFaP8cAAAAAAABVQP//////AVg/tAAAAAAAoGJA//////9XXD+wAAAAAADAVkD//////wFfP8IAAAAAAMBcQP//////B14/xwAAAAAAAFZA//////9XXD/LAAAAAABAV0D//////wFYP88AAAAAAAAAAP//////AVA/0wAAAAAAgGJA//////93TD+0AAAAAAAAV0D//////wNkP7QAAAAAAIBbQP//////S2Y/xwAAAAAAAAAA//////8DZD/KAAAAAAAAYED//////0dgP7QAAAAAAABgQP//////A2g/xQAAAAAAwFZA//////8DaD+0AAAAAADAX0D//////wduP8YAAAAAAIBbQP//////T2w/ywAAAAAAAAAA//////8DaD/PAAAAAACAXUD//////0dgP7gAAAAAAABgQP//////B3A/uAAAAAAAAGBA//////8HeD+4AAAAAABAVkD//////z99P8sAAAAAAAAAAP//////B3g/zwAAAAAAAFdA//////8HcD/TAAAAAABgYED//////0dgP9cAAAAAAIBYQP//////d0w/vAAAAAAAAGBA//////8PiD/AAAAAAAAAYED//////x+QP9MAAAAAAIBcQP//////74A/xAAAAAAAAFhA//////8/oD/XAAAAAAAAAAD//////++AP98AAAAAAABZQP//////d0w/vAAAAAAAAExAAAAAAAAAacC4AAAAAAAAS0AAAAAAAKB0wLwAAAAAAEBdQAAAAAAAsHjAzwAAAAAAAFNAAAAAAACQcMDTAAAAAACAUkAAAAAAAOBgwLQAAAAAAABJQAAAAAAAcILAuAAAAAAAQFxAAAAAAAB4hMDLAAAAAAAAAAAAAAAAAGiAwLgAAAAAAABgQAAAAAAAAIjAuAAAAAAAAGBAAAAAAAAAjMDLAAAAAAAAAAAAAAAAAACIwM8AAAAAAAAAAAAAAAAAaIDAtAAAAAAAAGBAAAAAAAAAkMC0AAAAAAAAYEAAAAAAAACSwMcAAAAAAAAAAAAAAAAAAJDAtAAAAAAAQFlAAAAAAABslsDLAAAAAABAUEAAAAAAAACQwLQAAAAAAABgQAAAAAAAAJjAtAAAAAAAAGBAAAAAAAAAmsDHAAAAAAAAAAAAAAAAAACYwLQAAAAAAEBXQAAAAAAAjJ7AxgAAAAAAQFBAAAAAAACIncDLAAAAAACAWEAAAAAAAACYwM8AAAAAAAAAAAAAAAAAAJDA0wAAAAAAgFZAAAAAAABogMCwAAAAAAAAYEAAAAAAAACgwLAAAAAAAABgQAAAAAAAAKHAwwAAAAAAAAAAAAAAAAAAoMDFAAAAAADAYkAAAAAAAACgwLAAAAAAAABgQAAAAAAAAKTAsAAAAAAAAGBAAAAAAAAApcDDAAAAAAAAAAAAAAAAAACkwLQAAAAAAMBhQAAAAAAA5KbAxwAAAAAAgFxAAAAAAAAApMDLAAAAAAAAAAAAAAAAAACgwLAAAAAAAABgQAAAAAAAAKjAsAAAAAAAAGBAAAAAAAAAqcDDAAAAAAAAAAAAAAAAAACowMUAAAAAAMBgQAAAAAAAAKjAsAAAAAAAAGBAAAAAAAAArMCwAAAAAAAAYEAAAAAAAACtwMMAAAAAAAAAAAAAAAAAAKzAsAAAAAAAgF9AAAAAAAAEr8DHAAAAAABAYEAAAAAAAACswMsAAAAAAAAAAAAAAAAAAKjAzwAAAAAAgF5AAAAAAAAAoMCsAAAAAACAXkAAAAAAAIawwKwAAAAAAIBdQAAAAAAAirHAvgAAAAAAQGBAAAAAAAAIscDDAAAAAAAAAAAAAAAAAASwwKwAAAAAAIBcQAAAAAAAjrLAvgAAAAAAwGFAAAAAAAAAssCwAAAAAAAAYUAAAAAAAACzwMMAAAAAAAAAAAAAAAAAALLAxwAAAAAAQGFAAAAAAAAEsMDTAAAAAACAW0AAAAAAAACgwNcAAAAAAABUQAAAAAAAaIDA3wAAAAAAgFNAAAAAAACAUcD/AAAAAAAgYkD//////3dMPw==";
+    std::string decodedBuf = decodeBase64(encodedBuf);
+
+    QuantileDigest<double> digest{
+        StlAllocator<double>(allocator()), decodedBuf.data()};
+
+    double scaleFactor = 2.5;
+    digest.scale(scaleFactor);
+
+    std::string scaledBuf(digest.serializedByteSize(), '\0');
+    digest.serialize(scaledBuf.data());
+
+    // Expected serialized form after scaling
+    std::string expectedScaledBuf = decodeBase64(
+        "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");
+    ASSERT_EQ(scaledBuf, expectedScaledBuf);
+  }
+
+  // Test with float QDigest
+  {
+    std::string encodedBuf =
+        "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAP+/Y7r/////ADicRQAAAABuAAAAPAAAAAAA4GJA/wdouv///39OAAAAAAAAZUD/v2O6////fzwAAAAAAEBiQP8fcLr///9/PAAAAAAAIGNA/wd4uv///39PAAAAAACAYkD/H3C6////f1MAAAAAAMBbQP+/Y7r///9/QAAAAAAAwGJA/w+Auv///388AAAAAACAXED/75C6////f1MAAAAAAMBhQP8PgLr///9/PAAAAAAAAGBA/w+guv///388AAAAAACAX0D/L7C6////fzgAAAAAAABLQP+vvLr///9/TwAAAAAAAAAA/y+wuv///39TAAAAAABgYkD/D6C6////f1cAAAAAAMBaQP8PgLr///9/PAAAAAAAwFpA/1/Buv///388AAAAAAAAYED/D8i6////f08AAAAAAAAAAP9fwbr///9/UQAAAAAAwGRA/1/Buv///388AAAAAADAXUD/n+C6////fzwAAAAAAABgQP8P6Lr///9/TwAAAAAAAAAA/5/guv///39AAAAAAAAgY0D/f/a6////f1MAAAAAAMBZQP+f4Lr///9/VwAAAAAAAFVA/1/Buv///39bAAAAAACAVUD/D4C6////f18AAAAAAAAAAP+/Y7r///9/QAAAAAAAQFxA//8hu////39AAAAAAAAAYED/HzC7////f1MAAAAAAAAAAP//Ibv///9/VgAAAAAAQFZA//8Hu////39AAAAAAAAAYED/H0C7////f0AAAAAAAABgQP8fULv///9/UwAAAAAAAAAA/x9Au////39EAAAAAAAgYED//2+7////f1cAAAAAAMBfQP8fQLv///9/WwAAAAAAAAAA//8Hu////39EAAAAAABAUkD//627////f0QAAAAAAMBXQP9/6Lv///9/VgAAAAAAgGNA/3/Bu////39bAAAAAAAAAAD//4a7////f18AAAAAACBkQP//B7v///9/YwAAAAAAQGJA/79juv///39IAAAAAABAWED//0+8////f0wAAAAAAEBcQP//j7z///9/XwAAAAAAYGNA//8JvP///39QAAAAAAAAWED//wG9////f2MAAAAAAAAAAP//Cbz///9/ZQAAAAAAAD5A//8JvP///39rAAAAAAAAAAD/v2O6////f3kAAAAAAEBdQP+/Y7r///9/SAAAAAAAAExAAABIQwAAAIBEAAAAAAAAS0AAAKVDAAAAgEgAAAAAAEBdQACAxUMAAACAWwAAAAAAAFNAAICEQwAAAIBfAAAAAACAUkAAAAdDAAAAgEAAAAAAAABJQACAE0QAAACARAAAAAAAQFxAAMAjRAAAAIBXAAAAAAAAAAAAQANEAAAAgEQAAAAAAABgQAAAQEQAAACARAAAAAAAAGBAAABgRAAAAIBXAAAAAAAAAAAAAEBEAAAAgFsAAAAAAAAAAABAA0QAAACAQAAAAAAAAGBAAACARAAAAIBAAAAAAAAAYEAAAJBEAAAAgFMAAAAAAAAAAAAAgEQAAACAQAAAAAAAQFlAAGCzRAAAAIBXAAAAAABAUEAAAIBEAAAAgEAAAAAAAABgQAAAwEQAAACAQAAAAAAAAGBAAADQRAAAAIBTAAAAAAAAAAAAAMBEAAAAgEAAAAAAAEBXQABg9EQAAACAUgAAAAAAQFBAAEDsRAAAAIBXAAAAAACAWEAAAMBEAAAAgFsAAAAAAAAAAAAAgEQAAACAXwAAAAAAgFZAAEADRAAAAIA8AAAAAAAAYEAAAABFAAAAgDwAAAAAAABgQAAACEUAAACATwAAAAAAAAAAAAAARQAAAIBRAAAAAADAYkAAAABFAAAAgDwAAAAAAABgQAAAIEUAAACAPAAAAAAAAGBAAAAoRQAAAIBPAAAAAAAAAAAAACBFAAAAgEAAAAAAAMBhQAAgN0UAAACAUwAAAAAAgFxAAAAgRQAAAIBXAAAAAAAAAAAAAABFAAAAgDwAAAAAAABgQAAAQEUAAACAPAAAAAAAAGBAAABIRQAAAIBPAAAAAAAAAAAAAEBFAAAAgFEAAAAAAMBgQAAAQEUAAACAPAAAAAAAAGBAAABgRQAAAIA8AAAAAAAAYEAAAGhFAAAAgE8AAAAAAAAAAAAAYEUAAACAPAAAAAAAgF9AACB4RQAAAIBTAAAAAABAYEAAAGBFAAAAgFcAAAAAAAAAAAAAQEUAAACAWwAAAAAAgF5AAAAARQAAAIA4AAAAAACAXkAAMIRFAAAAgDgAAAAAAIBdQABQjEUAAACASgAAAAAAQGBAAECIRQAAAIBPAAAAAAAAAAAAIIBFAAAAgDgAAAAAAIBcQABwlEUAAACASgAAAAAAwGFAAACQRQAAAIA8AAAAAAAAYUAAAJhFAAAAgE8AAAAAAAAAAAAAkEUAAACAUwAAAAAAQGFAACCARQAAAIBfAAAAAACAW0AAAABFAAAAgGMAAAAAAABUQABAA0QAAACAawAAAAAAgFNAAACMQgAAAID/AAAAAACAUUD/v2O6////fw==";
+    std::string decodedBuf = decodeBase64(encodedBuf);
+
+    QuantileDigest<float> digest{
+        StlAllocator<float>(allocator()), decodedBuf.data()};
+
+    // Scale the digest
+    double scaleFactor = 2.5;
+    digest.scale(scaleFactor);
+
+    // Serialize the scaled digest
+    std::string scaledBuf(digest.serializedByteSize(), '\0');
+    digest.serialize(scaledBuf.data());
+
+    // Expected serialized form after scaling
+    std::string expectedScaledBuf = decodeBase64(
+        "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");
+
+    ASSERT_EQ(scaledBuf, expectedScaledBuf);
+  }
+}
+
 TEST_F(QuantileDigestTest, hugeWeight) {
   VELOX_ASSERT_THROW(
       testHugeWeight<int64_t>(), "Weighted count in digest is too large");
@@ -554,4 +919,505 @@ TEST_F(QuantileDigestTest, hugeWeight) {
       testHugeWeight<float>(), "Weighted count in digest is too large");
 }
 
+TEST_F(QuantileDigestTest, quantileAtValue) {
+  testQuantileAtValue<int64_t>();
+  testQuantileAtValue<double>();
+  testQuantileAtValue<float>();
+}
+
+template <typename T>
+void testGetDistributionFunction() {
+  std::allocator<T> allocator;
+  // Add values within the range.
+  QuantileDigest<T, std::allocator<T>> digest1(allocator, 0.01);
+  for (T i = 1; i <= 10; i++) {
+    digest1.add(i, 1);
+  }
+  auto cdf1 = digest1.getDistributionFunction(0, 100);
+  std::vector<T> expectedCdfUpperBound = {
+      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100};
+  std::vector<double> expectedCdfCumulativeProbability = {
+      0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 1};
+  for (auto i = 0; i < cdf1.size(); i++) {
+    SCOPED_TRACE(fmt::format("non-clip round: {}", i));
+    EXPECT_NEAR(
+        cdf1[i].cumulativeProbability,
+        expectedCdfCumulativeProbability[i],
+        1e-5);
+    EXPECT_EQ(cdf1[i].upperBound, expectedCdfUpperBound[i]);
+  }
+
+  // clip the range start.
+  QuantileDigest<T, std::allocator<T>> digest2(allocator, 0.01);
+  for (T i = 1; i <= 10; i++) {
+    digest2.add(i, 1);
+  }
+  auto cdf2 = digest2.getDistributionFunction(5, 100);
+  std::vector<T> expectedCdfUpperBound2 = {5, 6, 7, 8, 9, 10, 100};
+  std::vector<double> expectedCdfCumulativeProbability2 = {
+      0.5, 0.6, 0.7, 0.8, 0.9, 1, 1};
+  for (auto i = 0; i < cdf2.size(); i++) {
+    SCOPED_TRACE(fmt::format("clip lower round: {}", i));
+    EXPECT_NEAR(
+        cdf2[i].cumulativeProbability,
+        expectedCdfCumulativeProbability2[i],
+        1e-5);
+    EXPECT_EQ(cdf2[i].upperBound, expectedCdfUpperBound2[i]);
+  }
+
+  // clip the range end.
+  QuantileDigest<T, std::allocator<T>> digest3(allocator, 0.01);
+  for (T i = 1; i <= 10; i++) {
+    digest3.add(i, 1);
+  }
+  auto cdf3 = digest3.getDistributionFunction(0, 5);
+  std::vector<T> expectedCdfUpperBound3 = {0, 1, 2, 3, 4, 5};
+  std::vector<double> expectedCdfCumulativeProbability3 = {
+      0, 0.1, 0.2, 0.3, 0.4, 1.0};
+  for (auto i = 0; i < cdf3.size(); i++) {
+    SCOPED_TRACE(fmt::format("clip upper round: {}", i));
+    EXPECT_NEAR(
+        cdf3[i].cumulativeProbability,
+        expectedCdfCumulativeProbability3[i],
+        1e-5);
+    EXPECT_EQ(cdf3[i].upperBound, expectedCdfUpperBound3[i]);
+  }
+}
+
+TEST_F(QuantileDigestTest, getDistributionFunction) {
+  testGetDistributionFunction<int64_t>();
+  testGetDistributionFunction<double>();
+  testGetDistributionFunction<float>();
+}
+
+TEST_F(QuantileDigestTest, getValuesInQuantileRangeBigInt) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
+
+  digest.add(1, 2.0);
+  digest.add(5, 3.0);
+  digest.add(10, 1.0);
+  digest.add(15, 4.0);
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.1, 0.7),
+      std::vector<std::pair<int64_t, double>>{
+          {1, 1.0}, {5, 3.0}, {10, 1.0}, {15, 1.0}});
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.2, 0.6),
+      std::vector<std::pair<int64_t, double>>{{5, 3.0}, {10, 1.0}});
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.5, 0.8),
+      std::vector<std::pair<int64_t, double>>{{10, 1.0}, {15, 2.0}});
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.3, 0.3),
+      std::vector<std::pair<int64_t, double>>{});
+
+  QuantileDigest<int64_t> singleDigest{
+      StlAllocator<int64_t>(allocator()), 0.01};
+  singleDigest.add(42, 5.0);
+
+  verifyValueCountPairs(
+      singleDigest.getValuesInQuantileRange(0.0, 1.0),
+      std::vector<std::pair<int64_t, double>>{{42, 5.0}});
+
+  // Test with fractional bounds that create non-integer
+  // lower/upperQuantileBound * weightedCount_
+  QuantileDigest<int64_t> nonIntegerDigest{
+      StlAllocator<int64_t>(allocator()), 0.01};
+  for (int i = 1; i <= 101; ++i) {
+    nonIntegerDigest.add(i, 1.0);
+  }
+
+  auto result6 = nonIntegerDigest.getValuesInQuantileRange(0.33, 0.67);
+  EXPECT_GT(result6.size(), 0);
+
+  double totalWeight = 0.0;
+  for (const auto& pair : result6) {
+    totalWeight += pair.count;
+  }
+  EXPECT_NEAR(totalWeight, 34.34, 0.1);
+
+  QuantileDigest<int64_t> fractionalDigest{
+      StlAllocator<int64_t>(allocator()), 0.01};
+  for (int i = 1; i <= 100; ++i) {
+    fractionalDigest.add(i, 1.0);
+  }
+
+  // These bounds will result in non-integer values when multiplied by
+  // weightedCount_
+  verifyValueCountPairs(
+      fractionalDigest.getValuesInQuantileRange(0.015, 0.085),
+      std::vector<std::pair<int64_t, double>>{
+          {2, 0.5},
+          {3, 1.0},
+          {4, 1.0},
+          {5, 1.0},
+          {6, 1.0},
+          {7, 1.0},
+          {8, 1.0},
+          {9, 0.5}});
+
+  verifyValueCountPairs(
+      fractionalDigest.getValuesInQuantileRange(0.01, 0.05),
+      std::vector<std::pair<int64_t, double>>{
+          {2, 1.0}, {3, 1.0}, {4, 1.0}, {5, 1.0}});
+}
+
+TEST_F(QuantileDigestTest, getValuesInQuantileRangeDouble) {
+  QuantileDigest<double> digest{StlAllocator<double>(allocator()), 0.01};
+
+  digest.add(1.5, 2.0);
+  digest.add(5.5, 3.0);
+  digest.add(10.5, 1.0);
+  digest.add(15.5, 4.0);
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.1, 0.7),
+      std::vector<std::pair<double, double>>{
+          {1.5, 1.0}, {5.5, 3.0}, {10.5, 1.0}, {15.5, 1.0}});
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.2, 0.6),
+      std::vector<std::pair<double, double>>{{5.5, 3.0}, {10.5, 1.0}});
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.5, 0.8),
+      std::vector<std::pair<double, double>>{{10.5, 1.0}, {15.5, 2.0}});
+
+  // Test with fractional bounds that create non-integer
+  // lower/upperQuantileBound * weightedCount_
+  QuantileDigest<double> fractionalDigest{
+      StlAllocator<double>(allocator()), 0.01};
+  for (int i = 1; i <= 100; ++i) {
+    fractionalDigest.add(static_cast<double>(i), 1.0);
+  }
+
+  // These bounds will result in non-integer values when multiplied by
+  // weightedCount_
+  verifyValueCountPairs(
+      fractionalDigest.getValuesInQuantileRange(0.015, 0.085),
+      std::vector<std::pair<double, double>>{
+          {2.0, 0.5},
+          {3.0, 1.0},
+          {4.0, 1.0},
+          {5.0, 1.0},
+          {6.0, 1.0},
+          {7.0, 1.0},
+          {8.0, 1.0},
+          {9.0, 0.5}});
+
+  verifyValueCountPairs(
+      fractionalDigest.getValuesInQuantileRange(0.01, 0.05),
+      std::vector<std::pair<double, double>>{
+          {2.0, 1.0}, {3.0, 1.0}, {4.0, 1.0}, {5.0, 1.0}});
+}
+
+TEST_F(QuantileDigestTest, getValuesInQuantileRangeFloat) {
+  // Test with fractional bounds that create non-integer
+  // lower/upperQuantileBound * weightedCount_
+  QuantileDigest<float> digest{StlAllocator<float>(allocator()), 0.01};
+
+  digest.add(1.0f, 2.0);
+  digest.add(5.0f, 3.0);
+  digest.add(10.0f, 1.0);
+  digest.add(15.0f, 4.0);
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.1, 0.7),
+      std::vector<std::pair<float, double>>{
+          {1.0f, 1.0}, {5.0f, 3.0}, {10.0f, 1.0}, {15.0f, 1.0}});
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.2, 0.6),
+      std::vector<std::pair<float, double>>{{5.0f, 3.0}, {10.0f, 1.0}});
+
+  verifyValueCountPairs(
+      digest.getValuesInQuantileRange(0.5, 0.8),
+      std::vector<std::pair<float, double>>{{10.0f, 1.0}, {15.0f, 2.0}});
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanBaseCases) {
+  // Empty digest
+  QuantileDigest<int64_t> emptyDigest{
+      StlAllocator<int64_t>(allocator()), 0.001};
+  EXPECT_FALSE(getTruncatedMean(emptyDigest, 0.0, 1.0).has_value());
+
+  // Single element
+  QuantileDigest<int64_t> singleDigest{
+      StlAllocator<int64_t>(allocator()), 0.001};
+  singleDigest.add(1, 1.0);
+  EXPECT_NEAR(
+      getTruncatedMean(singleDigest, 0.0, 1.0).value(),
+      1.0,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(singleDigest, 0.4999, 0.5).value(),
+      1.0,
+      kTruncatedMeanTolerance);
+  EXPECT_FALSE(getTruncatedMean(singleDigest, 0.5, 0.5).has_value());
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanShortList) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.001};
+  digest.add(1, 1.0);
+  digest.add(2, 1.0);
+  digest.add(3, 1.0);
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 1.0).value(), 2.0, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.5, 1.0).value(),
+      4.0 / 1.5,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.5).value(),
+      2.0 / 1.5,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.1).value(), 1.0, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.9, 0.99).value(),
+      3.0,
+      kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanSkewed) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
+  digest.add(1, 1.0);
+  digest.add(5, 1.0);
+  digest.add(10, 1.0);
+  digest.add(20, 1.0);
+  digest.add(50, 1.0);
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.25, 0.75).value(),
+      11.5,
+      kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanRepeated) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
+  digest.add(1, 1.0);
+  for (int i = 0; i < 8; i++) {
+    digest.add(2, 1.0);
+  }
+  digest.add(5, 1.0);
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.5).value(), 1.8, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.4, 0.6).value(), 2.0, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.8, 1.0).value(), 3.5, kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanSigned) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
+  digest.add(-2, 1.0);
+  digest.add(-1, 1.0);
+  digest.add(0, 1.0);
+  digest.add(1, 1.0);
+  digest.add(2, 1.0);
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.4).value(),
+      -1.5,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.4, 0.6).value(), 0.0, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.2, 0.8).value(), 0.0, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.4, 1.0).value(), 1.0, kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanDoubles) {
+  QuantileDigest<double> digest{StlAllocator<double>(allocator()), 0.01};
+  digest.add(0.2, 1.0);
+  digest.add(0.8, 1.0);
+  digest.add(1.4, 1.0);
+  digest.add(2.0, 1.0);
+  digest.add(2.6, 1.0);
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 1.0).value(), 1.4, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.6, 1.0).value(), 2.3, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.4).value(), 0.5, kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanWeighted) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
+  digest.add(2, 1.0);
+  digest.add(4, 2.0);
+  digest.add(5, 3.0);
+  digest.add(6, 3.0);
+  digest.add(10, 1.0);
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.1).value(), 2.0, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.2, 0.8).value(),
+      31.0 / 6.0,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.6, 1.0).value(),
+      28.0 / 4.0,
+      kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanBoundaries) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
+  for (int64_t i = 1; i <= 10; i++) {
+    digest.add(i, 1.0);
+  }
+
+  // Test exact boundaries
+  EXPECT_NEAR(getTruncatedMean(digest, 0.0, 1.0).value(), 5.5, 0.1);
+  EXPECT_FALSE(getTruncatedMean(digest, 0.0, 0.0).has_value());
+  EXPECT_FALSE(getTruncatedMean(digest, 1.0, 1.0).has_value());
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.01, 0.99).value(),
+      5.5,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.99).value(),
+      5.45,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.01, 1.0).value(),
+      5.55,
+      kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanInvalidInputs) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
+  for (int i = 1; i <= 5; i++) {
+    digest.add(i, 1.0);
+  }
+
+  // Test invalid quantile ranges
+  VELOX_ASSERT_THROW(
+      getTruncatedMean(digest, -0.1, 0.5),
+      "lowerQuantileBound must be between 0 and 1");
+  VELOX_ASSERT_THROW(
+      getTruncatedMean(digest, 0.5, 1.1),
+      "upperQuantileBound must be between 0 and 1");
+
+  // Test equal bounds - should return null
+  EXPECT_FALSE(getTruncatedMean(digest, 0.6, 0.6).has_value());
+  EXPECT_FALSE(getTruncatedMean(digest, 0.6, 0.4).has_value());
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanFloatingPointPrecision) {
+  QuantileDigest<double> digest{StlAllocator<double>(allocator()), 0.01};
+
+  // Add some very small and very large values
+  digest.add(1e-10, 1.0);
+  digest.add(1e-5, 1.0);
+  digest.add(1.0, 1.0);
+  digest.add(1e5, 1.0);
+  digest.add(1e10, 1.0);
+
+  // Test that truncated mean handles large ranges correctly
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.6).value(),
+      (1e-10 + 1e-5 + 1.0) / 3.0,
+      1e-10);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.4, 1.0).value(),
+      (1.0 + 1e5 + 1e10) / 3.0,
+      1e5);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanSkew) {
+  QuantileDigest<int64_t> digest{StlAllocator<int64_t>(allocator()), 0.01};
+  std::vector<int64_t> vals = {1, 1, 1, 1, 1, 2,  2,   2,   2,   2,
+                               3, 3, 3, 3, 3, 50, 100, 200, 400, 1000};
+  for (auto val : vals) {
+    digest.add(val, 1.0);
+  }
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.75).value(),
+      2.0,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.8).value(),
+      80.0 / 16.0,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.85).value(),
+      180.0 / 17.0,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.9).value(),
+      380.0 / 18.0,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.95).value(),
+      780.0 / 19.0,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.99).value(),
+      1580.0 / 19.8,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 1.0).value(),
+      1780.0 / 20.0,
+      kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanDoubleSkew) {
+  QuantileDigest<double> digest{StlAllocator<double>(allocator()), 0.01};
+  std::vector<double> vals = {
+      0.2, 0.2, 0.2, 0.2, 0.2, 5.0, 10.5, 50.5, 99.5, 9999.5};
+  for (auto val : vals) {
+    digest.add(val, 1.0);
+  }
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.6).value(),
+      6.0 / 6,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.8).value(),
+      67.0 / 8,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.9).value(),
+      166.5 / 9,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 1.0).value(),
+      10166.0 / 10,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.5, 1.0).value(),
+      10165.0 / 5,
+      kTruncatedMeanTolerance);
+}
+
+TEST_F(QuantileDigestTest, truncatedMeanDoubleSigned) {
+  QuantileDigest<double> digest{StlAllocator<double>(allocator()), 0.01};
+  std::vector<double> vals = {-2.5, -0.5, 0.0, 0.5, 2.5};
+  for (auto val : vals) {
+    digest.add(val, 1.0);
+  }
+
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.0, 0.6).value(),
+      -1.0,
+      kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.2, 0.8).value(), 0.0, kTruncatedMeanTolerance);
+  EXPECT_NEAR(
+      getTruncatedMean(digest, 0.4, 1.0).value(), 1.0, kTruncatedMeanTolerance);
+}
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/tests/Re2FunctionsTest.cpp b/velox/functions/lib/tests/Re2FunctionsTest.cpp
index ac59cda435bc..6054df6fd031 100644
--- a/velox/functions/lib/tests/Re2FunctionsTest.cpp
+++ b/velox/functions/lib/tests/Re2FunctionsTest.cpp
@@ -21,6 +21,7 @@
 #include <functional>
 #include <optional>
 #include <string>
+#include <vector>
 
 #include "velox/common/base/VeloxException.h"
 #include "velox/common/base/tests/GTestUtils.h"
@@ -325,6 +326,32 @@ void testRe2Search(F&& regexSearch) {
   EXPECT_EQ(std::nullopt, regexSearch("", std::nullopt));
 }
 
+TEST_F(Re2FunctionsTest, regexSearchUnknown) {
+  // varchar, unknown
+  EXPECT_EQ(
+      std::nullopt,
+      evaluateOnce<bool>(
+          "re2_search(c0, c1)",
+          std::optional<std::string>("hello123"),
+          std::vector<std::optional<UnknownValue>>{std::nullopt}[0]));
+
+  // unknown, varchar
+  EXPECT_EQ(
+      std::nullopt,
+      evaluateOnce<bool>(
+          "re2_search(c0, c1)",
+          std::optional<std::string>(std::nullopt),
+          std::optional<std::string>("hello123")));
+
+  // unknown, unknown
+  EXPECT_EQ(
+      std::nullopt,
+      evaluateOnce<bool>(
+          "re2_search(c0, c1)",
+          std::vector<std::optional<UnknownValue>>{std::nullopt}[0],
+          std::vector<std::optional<UnknownValue>>{std::nullopt}[0]));
+}
+
 TEST_F(Re2FunctionsTest, regexSearchConstantPattern) {
   testRe2Search([&](std::optional<std::string> str,
                     std::optional<std::string> pattern) {
@@ -501,11 +528,12 @@ TEST_F(Re2FunctionsTest, likeDeterminePatternKind) {
         PatternMetadata patternMetadata =
             determinePatternKind(pattern, std::nullopt);
 
-        SCOPED_TRACE(fmt::format(
-            "pattern: '{}', length: {}, actualLength: {}",
-            pattern,
-            length,
-            patternMetadata.length()));
+        SCOPED_TRACE(
+            fmt::format(
+                "pattern: '{}', length: {}, actualLength: {}",
+                pattern,
+                length,
+                patternMetadata.length()));
         EXPECT_EQ(patternMetadata.patternKind(), patternKind);
         EXPECT_EQ(patternMetadata.length(), length);
       };
@@ -513,8 +541,9 @@ TEST_F(Re2FunctionsTest, likeDeterminePatternKind) {
   auto testPatternString = [&](std::string_view pattern,
                                PatternKind patternKind,
                                std::string_view fixedPattern) {
-    SCOPED_TRACE(fmt::format(
-        "pattern: '{}', fixedPattern: '{}'", pattern, fixedPattern));
+    SCOPED_TRACE(
+        fmt::format(
+            "pattern: '{}', fixedPattern: '{}'", pattern, fixedPattern));
 
     PatternMetadata patternMetadata =
         determinePatternKind(pattern, std::nullopt);
@@ -1535,35 +1564,6 @@ TEST_F(Re2FunctionsTest, limit) {
   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);
-}
-
 TEST_F(Re2FunctionsTest, parseSubstrings) {
   auto test = [&](const std::string& input,
                   const std::vector<std::string>& expected) {
@@ -1586,5 +1586,6 @@ TEST_F(Re2FunctionsTest, parseSubstrings) {
   test("%aa%bb%%", {"aa", "bb"});
   test("%aa%bb%%%cc%", {"aa", "bb", "cc"});
 }
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/tests/SetDigestTest.cpp b/velox/functions/lib/tests/SetDigestTest.cpp
new file mode 100644
index 000000000000..974af80391fb
--- /dev/null
+++ b/velox/functions/lib/tests/SetDigestTest.cpp
@@ -0,0 +1,717 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/SetDigest.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/type/StringView.h"
+
+#include <folly/base64.h>
+#include <gtest/gtest.h>
+#include <cmath>
+#include <random>
+
+using namespace facebook::velox::functions;
+using facebook::velox::HashStringAllocator;
+using facebook::velox::StringView;
+
+namespace {
+// SetDigest uses HllAccumulator with 2048 buckets.
+// The theoretical relative standard error formula from the HyperLogLog paper
+// (Flajolet et al.) is: 1.04 / sqrt(num_buckets)
+const double kStandardError =
+    1.04 / std::sqrt(SetDigest<int64_t>::kNumberOfBuckets);
+} // namespace
+
+class SetDigestTest : public ::testing::Test {
+ protected:
+  static void SetUpTestSuite() {
+    facebook::velox::memory::MemoryManager::testingSetInstance({});
+  }
+
+  void SetUp() override {
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool();
+    allocator_ =
+        std::make_unique<facebook::velox::HashStringAllocator>(pool_.get());
+  }
+
+  // Helper for Java-equivalent intersection cardinality tests
+  void testIntersectionCardinalityHelper(
+      int32_t maxHashes1,
+      int32_t numBuckets1,
+      int32_t maxHashes2,
+      int32_t numBuckets2);
+
+  std::string decodeBase64(const std::string& encoded) {
+    return folly::base64Decode(encoded);
+  }
+
+  std::shared_ptr<facebook::velox::memory::MemoryPool> pool_;
+  std::unique_ptr<facebook::velox::HashStringAllocator> allocator_;
+};
+
+TEST_F(SetDigestTest, roundTripSerialization) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(1L);
+  digest1.add(1L);
+  digest1.add(2L);
+  digest1.add(2L);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  EXPECT_EQ(size1, size2);
+
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+
+  EXPECT_EQ(digest1.isExact(), digest2.isExact());
+  EXPECT_EQ(digest1.cardinality(), digest2.cardinality());
+}
+
+TEST_F(SetDigestTest, roundTripWithStrings) {
+  SetDigest<StringView> digest1(allocator_.get());
+
+  digest1.add(facebook::velox::StringView("apple"));
+  digest1.add(facebook::velox::StringView("banana"));
+  digest1.add(facebook::velox::StringView("apple"));
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<StringView> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  EXPECT_EQ(size1, size2);
+
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+}
+
+TEST_F(SetDigestTest, mergeWithRoundTrip) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(2L);
+  digest1.add(3L);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(3L);
+  digest2.add(4L);
+  digest2.add(5L);
+
+  digest1.mergeWith(digest2);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<int64_t> digest3(allocator_.get());
+  ASSERT_TRUE(digest3.deserialize(buffer1.data(), size1).ok());
+
+  int32_t size2 = digest3.estimatedSerializedSize();
+  EXPECT_EQ(size1, size2);
+
+  std::vector<char> buffer2(size2);
+  digest3.serialize(buffer2.data());
+
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+
+  EXPECT_TRUE(digest1.isExact());
+  EXPECT_EQ(digest1.cardinality(), 5);
+  EXPECT_EQ(digest3.cardinality(), 5);
+}
+
+TEST_F(SetDigestTest, mergeWithDuplicates) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(1L);
+  digest1.add(1L);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(1L);
+  digest2.add(2L);
+
+  digest1.mergeWith(digest2);
+
+  EXPECT_TRUE(digest1.isExact());
+  EXPECT_EQ(digest1.cardinality(), 2);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<int64_t> digest3(allocator_.get());
+  ASSERT_TRUE(digest3.deserialize(buffer1.data(), size1).ok());
+
+  int32_t size2 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest3.serialize(buffer2.data());
+
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+}
+
+TEST_F(SetDigestTest, javaCompatibility) {
+  // Query used: SELECT to_base64(cast(make_set_digest(value) as varbinary))
+  // FROM (VALUES 1, 1, 1, 2, 2) T(value);
+  SetDigest<int64_t> digest(allocator_.get());
+
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(2L);
+  digest.add(2L);
+
+  int32_t size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  std::string base64Output =
+      folly::base64Encode(folly::StringPiece(buffer.data(), size));
+
+  EXPECT_TRUE(digest.isExact());
+  EXPECT_EQ(digest.cardinality(), 2);
+  EXPECT_GT(size, 0);
+}
+
+TEST_F(SetDigestTest, javaCompatibilityEmptyDigest) {
+  // Query: SELECT to_base64(cast(make_set_digest(value) as varbinary))
+  // FROM (SELECT NULL as value WHERE 1=0) T(value);
+  SetDigest<int64_t> digest(allocator_.get());
+
+  int32_t size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  std::string base64Output =
+      folly::base64Encode(folly::StringPiece(buffer.data(), size));
+
+  EXPECT_TRUE(digest.isExact());
+  EXPECT_EQ(digest.cardinality(), 0);
+}
+
+TEST_F(SetDigestTest, cardinality) {
+  SetDigest<int64_t> digest(allocator_.get());
+
+  EXPECT_EQ(digest.cardinality(), 0);
+
+  digest.add(1L);
+  EXPECT_EQ(digest.cardinality(), 1);
+
+  digest.add(1L);
+  EXPECT_EQ(digest.cardinality(), 1);
+
+  digest.add(2L);
+  EXPECT_EQ(digest.cardinality(), 2);
+}
+
+TEST_F(SetDigestTest, exactIntersectionCardinality) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(2L);
+  digest1.add(3L);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(2L);
+  digest2.add(3L);
+  digest2.add(4L);
+
+  int64_t intersection =
+      SetDigest<int64_t>::exactIntersectionCardinality(digest1, digest2);
+  EXPECT_EQ(intersection, 2);
+
+  SetDigest<int64_t> digest3(allocator_.get());
+  digest3.add(5L);
+  digest3.add(6L);
+
+  intersection =
+      SetDigest<int64_t>::exactIntersectionCardinality(digest1, digest3);
+  EXPECT_EQ(intersection, 0);
+}
+
+TEST_F(SetDigestTest, jaccardIndex) {
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(1L);
+  digest1.add(2L);
+  digest1.add(3L);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(2L);
+  digest2.add(3L);
+  digest2.add(4L);
+
+  double jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest2);
+  EXPECT_GE(jaccard, 0.0);
+  EXPECT_LE(jaccard, 1.0);
+
+  // Test identical sets - should always be 1.0
+  SetDigest<int64_t> digest3(allocator_.get());
+  digest3.add(1L);
+  digest3.add(2L);
+  digest3.add(3L);
+
+  jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest3);
+  EXPECT_NEAR(jaccard, 1.0, 0.001);
+
+  // Test disjoint sets - should be 0.0
+  SetDigest<int64_t> digest4(allocator_.get());
+  digest4.add(10L);
+  digest4.add(20L);
+  digest4.add(30L);
+
+  jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest4);
+  EXPECT_NEAR(jaccard, 0.0, 0.001);
+}
+
+TEST_F(SetDigestTest, getHashCounts) {
+  SetDigest<int64_t> digest(allocator_.get());
+
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(2L);
+  digest.add(2L);
+
+  auto hashCounts = digest.getHashCounts();
+  EXPECT_EQ(hashCounts.size(), 2);
+  int totalCount = 0;
+  for (const auto& entry : hashCounts) {
+    totalCount += entry.second;
+  }
+  EXPECT_EQ(totalCount, 5);
+}
+
+TEST_F(SetDigestTest, hashCountsJavaCompatibility) {
+  // This test matches the Java TestSetDigest.testHashCounts() test
+  SetDigest<int64_t> digest1(allocator_.get());
+  digest1.add(0L);
+  digest1.add(0L);
+  digest1.add(1L);
+
+  auto hashCounts1 = digest1.getHashCounts();
+  EXPECT_EQ(hashCounts1.size(), 2);
+
+  std::set<int16_t> counts1;
+  for (const auto& entry : hashCounts1) {
+    counts1.insert(entry.second);
+  }
+  std::set<int16_t> expected1 = {1, 2};
+  EXPECT_EQ(counts1, expected1);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  digest2.add(0L);
+  digest2.add(0L);
+  digest2.add(2L);
+  digest2.add(2L);
+
+  auto hashCounts2 = digest2.getHashCounts();
+  EXPECT_EQ(hashCounts2.size(), 2);
+
+  std::set<int16_t> counts2;
+  for (const auto& entry : hashCounts2) {
+    counts2.insert(entry.second);
+  }
+  std::set<int16_t> expected2 = {2, 2};
+  EXPECT_EQ(counts2, expected2);
+
+  // Merge digest2 into digest1
+  digest1.mergeWith(digest2);
+
+  auto hashCountsMerged = digest1.getHashCounts();
+  EXPECT_EQ(hashCountsMerged.size(), 3);
+
+  std::set<int16_t> countsMerged;
+  for (const auto& entry : hashCountsMerged) {
+    countsMerged.insert(entry.second);
+  }
+  std::set<int16_t> expectedMerged = {1, 2, 4};
+  // hash(0): 2 + 2 = 4
+  // hash(1): 1 + 0 = 1
+  // hash(2): 0 + 2 = 2
+  EXPECT_EQ(countsMerged, expectedMerged);
+}
+
+TEST_F(SetDigestTest, javaSerializationCompatibilityIntegerValues) {
+  SCOPED_TRACE(
+      "SELECT to_base64(cast(make_set_digest(col) as varbinary)) "
+      "FROM (VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10)) AS t(col)");
+
+  // Base64 encoded SetDigest generated by Java Presto for values 1-10
+  auto data = decodeBase64(
+      "ASwAAAACCwoAgANEAEDsyQbAxdQPADQvEoYdNBuBKeEwgtKHOQBYPVsB0hm0gCAI3gAgAAAKAAAAwbZqSBDSGbSowHZsoCAI3krEBfu3A0QAUyYs1XjsyQYbd2yb9sXUD3IeYiw5NC8S5tfq34AdNBuyj38lkynhMHnf8AaM0oc5DItIsjlYPVsBAAEAAQABAAEAAQABAAEAAQABAA==");
+
+  SetDigest<int64_t> digest(allocator_.get());
+  ASSERT_TRUE(digest.deserialize(data.data(), data.size()).ok());
+
+  EXPECT_TRUE(digest.isExact());
+  EXPECT_EQ(digest.cardinality(), 10);
+
+  SetDigest<int64_t> expectedDigest(allocator_.get());
+  for (int64_t i = 1; i <= 10; i++) {
+    expectedDigest.add(i);
+  }
+  EXPECT_EQ(expectedDigest.cardinality(), 10);
+  EXPECT_TRUE(expectedDigest.isExact());
+
+  int64_t intersection =
+      SetDigest<int64_t>::exactIntersectionCardinality(digest, expectedDigest);
+  EXPECT_EQ(intersection, 10);
+
+  auto hashCounts = digest.getHashCounts();
+  auto expectedHashCounts = expectedDigest.getHashCounts();
+  EXPECT_EQ(hashCounts.size(), expectedHashCounts.size());
+
+  for (const auto& entry : hashCounts) {
+    EXPECT_EQ(entry.second, 1);
+  }
+
+  int32_t size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  EXPECT_EQ(size, data.size());
+  EXPECT_EQ(std::string(buffer.begin(), buffer.end()), data);
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer.data(), size).ok());
+  EXPECT_EQ(digest2.cardinality(), 10);
+  EXPECT_TRUE(digest2.isExact());
+
+  int64_t intersection2 =
+      SetDigest<int64_t>::exactIntersectionCardinality(digest2, expectedDigest);
+  EXPECT_EQ(intersection2, 10);
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(std::string(buffer2.begin(), buffer2.end()), data);
+}
+
+TEST_F(SetDigestTest, javaSerializationCompatibilityStringValues) {
+  SCOPED_TRACE(
+      "SELECT to_base64(cast(make_set_digest(col) as varbinary)) "
+      "FROM (VALUES ('apple'), ('banana'), ('cherry')) AS t(col)");
+
+  SetDigest<StringView> digest1(allocator_.get());
+  digest1.add(StringView("apple"));
+  digest1.add(StringView("banana"));
+  digest1.add(StringView("cherry"));
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigest<StringView> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  EXPECT_TRUE(digest2.isExact());
+  EXPECT_EQ(digest2.cardinality(), 3);
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(size1, size2);
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+
+  SetDigest<StringView> digest3(allocator_.get());
+  ASSERT_TRUE(digest3.deserialize(buffer2.data(), size2).ok());
+  int32_t size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+
+  EXPECT_EQ(
+      std::string(buffer3.begin(), buffer3.end()),
+      std::string(buffer1.begin(), buffer1.end()));
+}
+
+TEST_F(SetDigestTest, sparseHllToDenseConversion) {
+  SetDigest<int64_t> digest(allocator_.get());
+
+  // digest is still exact (5000 < 8192 maxHashes)
+  constexpr int32_t kNumValues = 5000;
+  for (int32_t i = 0; i < kNumValues; i++) {
+    digest.add(static_cast<int64_t>(i));
+  }
+
+  EXPECT_TRUE(digest.isExact());
+  EXPECT_EQ(digest.cardinality(), kNumValues);
+
+  int32_t size1 = digest.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest.serialize(buffer1.data());
+
+  SetDigest<int64_t> digest2(allocator_.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  EXPECT_TRUE(digest2.isExact());
+  EXPECT_EQ(digest2.cardinality(), kNumValues);
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(size1, size2);
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+
+  digest2.add(static_cast<int64_t>(kNumValues));
+  EXPECT_EQ(digest2.cardinality(), kNumValues + 1);
+
+  // add enough values to exceed maxHashes (8192) and become approximate
+  constexpr int32_t kNumAdditionalValues = 5000;
+  for (int32_t i = kNumValues; i < kNumValues + kNumAdditionalValues; i++) {
+    digest.add(static_cast<int64_t>(i));
+  }
+
+  EXPECT_FALSE(digest.isExact());
+
+  int64_t actualCardinality = kNumValues + kNumAdditionalValues;
+  int64_t estimatedCardinality = digest.cardinality();
+
+  // The error bound relates to HyperLogLog cardinality estimation.
+  // Theoretical standard error: 1.04 / sqrt(2048 buckets) ≈ 2.3%
+  // Use 3x standard error for 99.7% confidence (3-sigma rule).
+  EXPECT_NEAR(
+      estimatedCardinality,
+      actualCardinality,
+      actualCardinality * 3 * kStandardError);
+
+  int32_t size3 = digest.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest.serialize(buffer3.data());
+
+  SetDigest<int64_t> digest3(allocator_.get());
+  ASSERT_TRUE(digest3.deserialize(buffer3.data(), size3).ok());
+
+  EXPECT_FALSE(digest3.isExact());
+  EXPECT_EQ(digest3.cardinality(), digest.cardinality());
+
+  int32_t size4 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer4(size4);
+  digest3.serialize(buffer4.data());
+
+  EXPECT_EQ(size3, size4);
+  EXPECT_EQ(
+      std::string(buffer3.begin(), buffer3.end()),
+      std::string(buffer4.begin(), buffer4.end()));
+}
+
+// Java-equivalent tests matching TestSetDigest.java
+
+TEST_F(SetDigestTest, testIntersectionCardinality) {
+  // Equivalent to Java's testIntersectionCardinality() with default parameters
+  testIntersectionCardinalityHelper(
+      SetDigest<int64_t>::kDefaultMaxHashes,
+      SetDigest<int64_t>::kNumberOfBuckets,
+      SetDigest<int64_t>::kDefaultMaxHashes,
+      SetDigest<int64_t>::kNumberOfBuckets);
+}
+
+TEST_F(SetDigestTest, testUnevenIntersectionCardinality) {
+  // Equivalent to Java's testUnevenIntersectionCardinality()
+  testIntersectionCardinalityHelper(
+      SetDigest<int64_t>::kDefaultMaxHashes / 4,
+      SetDigest<int64_t>::kNumberOfBuckets,
+      SetDigest<int64_t>::kDefaultMaxHashes,
+      SetDigest<int64_t>::kNumberOfBuckets);
+}
+
+void SetDigestTest::testIntersectionCardinalityHelper(
+    int32_t maxHashes1,
+    int32_t numBuckets1,
+    int32_t maxHashes2,
+    int32_t numBuckets2) {
+  std::vector<int32_t> sizes;
+
+  std::mt19937 rand(0); // Same seed as Java for reproducibility
+  // Generate random size from each power of ten in [10, 100,000,000]
+  for (int32_t i = 10; i < 100000000; i *= 10) {
+    std::uniform_int_distribution<int32_t> dist(10, i + 9);
+    sizes.push_back(dist(rand));
+  }
+
+  for (int32_t size : sizes) {
+    int32_t expectedCardinality = 0;
+    SetDigest<int64_t> digest1(
+        allocator_.get(),
+        static_cast<int8_t>(std::log2(numBuckets1)),
+        maxHashes1);
+    SetDigest<int64_t> digest2(
+        allocator_.get(),
+        static_cast<int8_t>(std::log2(numBuckets2)),
+        maxHashes2);
+
+    std::uniform_int_distribution<int64_t> valueDist;
+    std::uniform_real_distribution<double> probDist(0.0, 1.0);
+
+    for (int32_t j = 0; j < size; j++) {
+      int32_t added = 0;
+      int64_t value = valueDist(rand);
+
+      if (probDist(rand) < 0.5) {
+        digest1.add(value);
+        added++;
+      }
+      if (probDist(rand) < 0.5) {
+        digest2.add(value);
+        added++;
+      }
+      if (added == 2) {
+        expectedCardinality++;
+      }
+    }
+
+    // Skip test if expectedCardinality is too small
+    if (expectedCardinality < 10) {
+      continue;
+    }
+
+    // Calculate intersection using C++ implementation
+    int64_t estimatedCardinality;
+    if (digest1.isExact() && digest2.isExact()) {
+      estimatedCardinality =
+          SetDigest<int64_t>::exactIntersectionCardinality(digest1, digest2);
+    } else {
+      // Use Jaccard index for approximate intersection
+      int64_t cardinality1 = digest1.cardinality();
+      int64_t cardinality2 = digest2.cardinality();
+      double jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest2);
+
+      // Merge to get union cardinality
+      SetDigest<int64_t> tempDigest(
+          allocator_.get(),
+          static_cast<int8_t>(std::log2(numBuckets1)),
+          maxHashes1);
+      tempDigest.mergeWith(digest1);
+      tempDigest.mergeWith(digest2);
+      int64_t unionCardinality = tempDigest.cardinality();
+
+      estimatedCardinality =
+          static_cast<int64_t>(std::round(jaccard * unionCardinality));
+      estimatedCardinality =
+          std::min(estimatedCardinality, std::min(cardinality1, cardinality2));
+    }
+
+    double errorRate = std::abs(expectedCardinality - estimatedCardinality) /
+        static_cast<double>(expectedCardinality);
+    EXPECT_LT(errorRate, 0.10);
+  }
+}
+
+TEST_F(SetDigestTest, testSmallLargeIntersections) {
+  // Equivalent to Java's testSmallLargeIntersections()
+  std::vector<int32_t> sizes;
+
+  std::mt19937 rand(0); // Same seed as Java
+  for (int32_t i = 1000; i < 1000000; i *= 10) {
+    std::uniform_int_distribution<int32_t> dist(10, i + 9);
+    sizes.push_back(dist(rand));
+  }
+
+  for (size_t size1_idx = 0; size1_idx < sizes.size(); ++size1_idx) {
+    int32_t size1 = sizes[size1_idx];
+    SetDigest<int64_t> digest1(allocator_.get());
+    std::vector<std::pair<std::unique_ptr<SetDigest<int64_t>>, int32_t>>
+        smallerSets;
+
+    std::uniform_int_distribution<int64_t> valueDist;
+    std::uniform_real_distribution<double> probDist(0.0, 1.0);
+
+    for (size_t size2_idx = 0; size2_idx < size1_idx; ++size2_idx) {
+      int32_t size2 = sizes[size2_idx];
+
+      for (int32_t overlap = 2; overlap <= 10; overlap += 2) {
+        int32_t expectedCardinality = 0;
+        auto digest2 = std::make_unique<SetDigest<int64_t>>(allocator_.get());
+
+        // Reset rand for this iteration to generate same values for digest1
+        std::mt19937 innerRand(rand());
+
+        for (int32_t j = 0; j < size1; j++) {
+          int64_t value = valueDist(innerRand);
+          digest1.add(value);
+
+          if (probDist(innerRand) < size2 / static_cast<double>(size1)) {
+            if (probDist(innerRand) * 10 < overlap) {
+              digest2->add(value);
+              expectedCardinality++;
+            } else {
+              digest2->add(valueDist(innerRand));
+            }
+          }
+        }
+
+        smallerSets.emplace_back(std::move(digest2), expectedCardinality);
+      }
+    }
+
+    for (const auto& [digest2Ptr, expectedCardinality] : smallerSets) {
+      const SetDigest<int64_t>& digest2 = *digest2Ptr;
+
+      // Calculate estimated intersection
+      int64_t estIntersectionCardinality;
+      if (digest1.isExact() && digest2.isExact()) {
+        estIntersectionCardinality =
+            SetDigest<int64_t>::exactIntersectionCardinality(digest1, digest2);
+      } else {
+        int64_t cardinality1 = digest1.cardinality();
+        int64_t cardinality2 = digest2.cardinality();
+        double jaccard = SetDigest<int64_t>::jaccardIndex(digest1, digest2);
+
+        SetDigest<int64_t> tempDigest(allocator_.get());
+        tempDigest.mergeWith(digest1);
+        tempDigest.mergeWith(digest2);
+        int64_t unionCardinality = tempDigest.cardinality();
+
+        estIntersectionCardinality =
+            static_cast<int64_t>(std::round(jaccard * unionCardinality));
+        estIntersectionCardinality = std::min(
+            estIntersectionCardinality, std::min(cardinality1, cardinality2));
+      }
+
+      int64_t size2 = digest2.cardinality();
+      EXPECT_LE(estIntersectionCardinality, size2);
+
+      double errorRate =
+          std::abs(expectedCardinality - estIntersectionCardinality) /
+          static_cast<double>(size1);
+      EXPECT_LT(errorRate, 0.05);
+    }
+  }
+}
diff --git a/velox/functions/lib/tests/TDigestTest.cpp b/velox/functions/lib/tests/TDigestTest.cpp
index c42c14f8d853..af7dce158d57 100644
--- a/velox/functions/lib/tests/TDigestTest.cpp
+++ b/velox/functions/lib/tests/TDigestTest.cpp
@@ -346,12 +346,13 @@ TEST_F(TDigestTest, merge) {
   std::vector<double> values;
   std::string buf;
   auto test = [&](int numDigests, int size, double mean, double stddev) {
-    SCOPED_TRACE(fmt::format(
-        "numDigests={} size={} mean={} stddev={}",
-        numDigests,
-        size,
-        mean,
-        stddev));
+    SCOPED_TRACE(
+        fmt::format(
+            "numDigests={} size={} mean={} stddev={}",
+            numDigests,
+            size,
+            mean,
+            stddev));
     values.clear();
     values.reserve(numDigests * size);
     std::normal_distribution<> dist(mean, stddev);
@@ -556,5 +557,23 @@ TEST_F(TDigestTest, quantileAtValue) {
   }
 }
 
+// Test the fix for floating-point precision issues with large totalWeight
+// values. Before the fix, large weights could cause weightSoFar - totalWeight
+// to exceed kEpsilon, throwing an error in Velox check.
+TEST_F(TDigestTest, largeWeightFloatingPointPrecision) {
+  std::vector<int16_t> positions;
+  TDigest digest;
+  // Create a scenario with very large weights that would have failed before the
+  // fix
+  constexpr double largeWeight = 1e12;
+  constexpr int numValues = 100;
+  for (int i = 0; i < numValues; ++i) {
+    digest.add(positions, i * 1.0, static_cast<int64_t>(largeWeight));
+  }
+  ASSERT_NO_THROW(digest.compress(positions));
+  ASSERT_GT(digest.totalWeight(), 0);
+  ASSERT_FALSE(std::isnan(digest.estimateQuantile(0.5)));
+}
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/lib/window/CMakeLists.txt b/velox/functions/lib/window/CMakeLists.txt
index 9594f3814569..43994bfb98e1 100644
--- a/velox/functions/lib/window/CMakeLists.txt
+++ b/velox/functions/lib/window/CMakeLists.txt
@@ -12,15 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-velox_add_library(
-  velox_functions_window
-  NthValue.cpp
-  Ntile.cpp
-  Rank.cpp
-  RowNumber.cpp)
+velox_add_library(velox_functions_window NthValue.cpp Ntile.cpp Rank.cpp RowNumber.cpp)
 
-velox_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 5ef33fc303cd..3b1f44c7fcc3 100644
--- a/velox/functions/lib/window/NthValue.cpp
+++ b/velox/functions/lib/window/NthValue.cpp
@@ -312,7 +312,7 @@ void registerNthValue(const std::string& name, TypeKind offsetTypeKind) {
           .typeVariable("T")
           .returnType("T")
           .argumentType("T")
-          .argumentType(mapTypeKindToName(offsetTypeKind))
+          .argumentType(std::string(TypeKindName::toName(offsetTypeKind)))
           .build(),
   };
 
diff --git a/velox/functions/lib/window/RowNumber.cpp b/velox/functions/lib/window/RowNumber.cpp
index 81fc7e5e0c6d..67d34933061d 100644
--- a/velox/functions/lib/window/RowNumber.cpp
+++ b/velox/functions/lib/window/RowNumber.cpp
@@ -68,7 +68,7 @@ class RowNumberFunction : public exec::WindowFunction {
 void registerRowNumber(const std::string& name, TypeKind resultTypeKind) {
   std::vector<exec::FunctionSignaturePtr> signatures{
       exec::FunctionSignatureBuilder()
-          .returnType(mapTypeKindToName(resultTypeKind))
+          .returnType(std::string(TypeKindName::toName(resultTypeKind)))
           .build(),
   };
 
diff --git a/velox/functions/lib/window/tests/CMakeLists.txt b/velox/functions/lib/window/tests/CMakeLists.txt
index e86924274d64..0320b47d22ab 100644
--- a/velox/functions/lib/window/tests/CMakeLists.txt
+++ b/velox/functions/lib/window/tests/CMakeLists.txt
@@ -19,4 +19,5 @@ target_link_libraries(
   velox_exec_test_lib
   velox_vector_fuzzer
   velox_vector_test_lib
-  GTest::gtest)
+  GTest::gtest
+)
diff --git a/velox/functions/lib/window/tests/WindowTestBase.cpp b/velox/functions/lib/window/tests/WindowTestBase.cpp
index 9e8c0d546638..07a255974ca5 100644
--- a/velox/functions/lib/window/tests/WindowTestBase.cpp
+++ b/velox/functions/lib/window/tests/WindowTestBase.cpp
@@ -20,7 +20,6 @@
 
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/duckdb/conversion/DuckParser.h"
-#include "velox/exec/tests/utils/OperatorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
 
@@ -65,10 +64,8 @@ WindowTestBase::QueryInfo WindowTestBase::buildStreamingWindowQuery(
   }
 
   // Extract the order by keys.
-  const auto& orderBy = windowExpr.orderBy;
-  for (auto i = 0; i < orderBy.size(); ++i) {
-    orderByClauses.push_back(
-        orderBy[i].first->toString() + " " + orderBy[i].second.toString());
+  for (const auto& clause : windowExpr.orderBy) {
+    orderByClauses.push_back(clause.toString());
   }
 
   // Sort the input data before streaming window.
diff --git a/velox/functions/prestosql/Arithmetic.h b/velox/functions/prestosql/Arithmetic.h
index e90b87edbd04..836e073befc6 100644
--- a/velox/functions/prestosql/Arithmetic.h
+++ b/velox/functions/prestosql/Arithmetic.h
@@ -655,103 +655,5 @@ struct WilsonIntervalLowerFunction {
   }
 };
 
-template <typename T>
-struct CosineSimilarityFunctionMap {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  double normalize(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 dotProduct(
-      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 = normalize(leftMap);
-    if (normLeftMap == 0.0) {
-      result = std::numeric_limits<double>::quiet_NaN();
-      return;
-    }
-
-    double normRightMap = normalize(rightMap);
-    if (normRightMap == 0.0) {
-      result = std::numeric_limits<double>::quiet_NaN();
-      return;
-    }
-
-    double product = dotProduct(leftMap, rightMap);
-    result = product / (normLeftMap * normRightMap);
-  }
-};
-
-template <typename T>
-struct CosineSimilarityFunctionArray {
-  VELOX_DEFINE_FUNCTION_TYPES(T);
-
-  double normalize(const null_free_arg_type<Array<double>>& map) {
-    double norm = 0.0;
-    for (const auto value : map) {
-      norm += (value * value);
-    }
-    return std::sqrt(norm);
-  }
-
-  double dotProduct(
-      const null_free_arg_type<Array<double>>& leftArray,
-      const null_free_arg_type<Array<double>>& rightArray) {
-    double result = 0.0;
-    for (size_t i = 0; i < leftArray.size(); i++) {
-      result += leftArray[i] * rightArray[i];
-    }
-    return result;
-  }
-
-  void callNullFree(
-      out_type<double>& result,
-      const null_free_arg_type<Array<double>>& leftArray,
-      const null_free_arg_type<Array<double>>& rightArray) {
-    VELOX_USER_CHECK(
-        leftArray.size() == rightArray.size(),
-        "Both arrays need to have identical size");
-
-    double normLeftArray = normalize(leftArray);
-    if (normLeftArray == 0.0) {
-      result = std::numeric_limits<double>::quiet_NaN();
-      return;
-    }
-
-    double normRightArray = normalize(rightArray);
-    if (normRightArray == 0.0) {
-      result = std::numeric_limits<double>::quiet_NaN();
-      return;
-    }
-
-    double product = dotProduct(leftArray, rightArray);
-    result = product / (normLeftArray * normRightArray);
-  }
-};
-
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArithmeticImpl.h b/velox/functions/prestosql/ArithmeticImpl.h
index 2e9bb325f668..cb12ac645cbf 100644
--- a/velox/functions/prestosql/ArithmeticImpl.h
+++ b/velox/functions/prestosql/ArithmeticImpl.h
@@ -76,7 +76,7 @@ round(const TNum& number, const TDecimals& decimals = 0) {
   // 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) {
+    if (fabs(number) < 17592186044415.F) {
       return std::round(number * factor) / factor;
     }
   }
@@ -157,6 +157,12 @@ T negate(const T& arg) {
 
 template <typename T>
 T abs(const T& arg) {
+  if constexpr (std::is_integral_v<T>) {
+    if (arg == std::numeric_limits<T>::min()) {
+      VELOX_USER_FAIL(
+          "Value {} is out of range for abs({})", arg, CppToType<T>::name);
+    }
+  }
   T results = std::abs(arg);
   return results;
 }
diff --git a/velox/functions/prestosql/ArrayFlatten.cpp b/velox/functions/prestosql/ArrayFlatten.cpp
new file mode 100644
index 000000000000..4201b71d6880
--- /dev/null
+++ b/velox/functions/prestosql/ArrayFlatten.cpp
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/ArrayFunctions.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+class ArrayFlattenFunction : public exec::VectorFunction {
+ public:
+  static std::vector<exec::FunctionSignaturePtr> signatures() {
+    // array(array(T)) -> array(T)
+    return {exec::FunctionSignatureBuilder()
+                .returnType("array(T)")
+                .argumentType("array(array(T))")
+                .typeVariable("T")
+                .build()};
+  }
+
+  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);
+    const auto& arrayVector = args[0];
+    VELOX_CHECK_EQ(arrayVector->encoding(), VectorEncoding::Simple::ARRAY);
+    const auto* arrayVectorPtr = arrayVector->as<ArrayVector>();
+    auto state =
+        ProcessState::create(outputType, rows.end(), arrayVectorPtr, context);
+    rows.applyToSelected(
+        [&](vector_size_t row) { processOneInputArray(row, row, state); });
+    VectorPtr localResult;
+    if (state.flattenElementsConsecutive) {
+      localResult = flattenArray(state);
+    } else {
+      localResult = flattenArrayWithDictionary(rows, state);
+    }
+    context.moveOrCopyResult(localResult, rows, result);
+  }
+
+ private:
+  struct ProcessState {
+    TypePtr resultType;
+    vector_size_t numRows{0};
+
+    const vector_size_t* arrayOffsets{};
+    const vector_size_t* arraySizes{};
+
+    std::unique_ptr<exec::LocalSelectivityVector> innerArrayRowSelector;
+    std::unique_ptr<exec::LocalDecodedVector> decodedInnerArrayHolder;
+    const DecodedVector* decodedInnerArray{nullptr};
+    VectorPtr elements{nullptr};
+    const vector_size_t* elementOffsets{nullptr};
+    const vector_size_t* elementSizes{nullptr};
+
+    BufferPtr flattenArrayOffsets{nullptr};
+    vector_size_t* rawFlattenArrayOffsets{nullptr};
+    BufferPtr flattenArraySizes{nullptr};
+    vector_size_t* rawFlattenArraySizes{nullptr};
+
+    // Indicates if the flatten elements are consecutive in source base element
+    // vector. If so, we can directly reference the source element vector.
+    // Otherwise, we need to build a dictionary mapping on top of the source
+    // element vector.
+    bool flattenElementsConsecutive{true};
+    vector_size_t numFlattenElements{0};
+    BufferPtr flattenElementIndices{nullptr};
+    vector_size_t* rawFlattenElementIndices{nullptr};
+    VectorPtr flattenElementsWithDictionary{nullptr};
+
+    memory::MemoryPool* pool{nullptr};
+
+    std::pair<vector_size_t, vector_size_t> elementOffsetAndSize(
+        vector_size_t elementIndex) const {
+      return {elementOffsets[elementIndex], elementSizes[elementIndex]};
+    }
+
+    // @param arrayVector ARRAY(ARRAY(E)) vector.
+    static ProcessState create(
+        const TypePtr& resultType,
+        size_t numRows,
+        const ArrayVector* arrayVector,
+        exec::EvalCtx& context) {
+      VELOX_CHECK_NOT_NULL(arrayVector);
+      ProcessState state;
+      state.resultType = resultType;
+      state.numRows = numRows;
+      state.pool = context.pool();
+
+      state.arrayOffsets = arrayVector->rawOffsets();
+      state.arraySizes = arrayVector->rawSizes();
+
+      const auto innerArrayVector = arrayVector->elements();
+      state.flattenElementsConsecutive =
+          innerArrayVector->encoding() == VectorEncoding::Simple::ARRAY;
+      state.innerArrayRowSelector =
+          std::make_unique<exec::LocalSelectivityVector>(
+              context, innerArrayVector->size());
+      state.innerArrayRowSelector->get()->setAll();
+      state.decodedInnerArrayHolder =
+          std::make_unique<exec::LocalDecodedVector>(
+              context, *innerArrayVector, *state.innerArrayRowSelector->get());
+      state.decodedInnerArray = state.decodedInnerArrayHolder->get();
+
+      auto* innerArrayVectorPtr =
+          state.decodedInnerArray->base()->as<ArrayVector>();
+      state.elements = innerArrayVectorPtr->elements();
+      state.elementOffsets = innerArrayVectorPtr->rawOffsets();
+      state.elementSizes = innerArrayVectorPtr->rawSizes();
+
+      state.flattenArrayOffsets = allocateIndices(state.numRows, state.pool);
+      state.rawFlattenArrayOffsets =
+          state.flattenArrayOffsets->asMutable<velox::vector_size_t>();
+
+      state.flattenArraySizes = allocateIndices(state.numRows, state.pool);
+      state.rawFlattenArraySizes =
+          state.flattenArraySizes->asMutable<velox::vector_size_t>();
+      return state;
+    }
+  };
+
+  VectorPtr flattenArrayWithDictionary(
+      const SelectivityVector& rows,
+      ProcessState& state) const {
+    createFlattenElementIndices(state);
+    vector_size_t flattenElementOffset{0};
+    rows.applyToSelected([&](vector_size_t row) {
+      processOneOutputRow(row, row, state, flattenElementOffset);
+    });
+    return std::make_shared<velox::ArrayVector>(
+        state.pool,
+        state.resultType,
+        nullptr,
+        state.numRows,
+        state.flattenArrayOffsets,
+        state.flattenArraySizes,
+        state.flattenElementsWithDictionary);
+  }
+
+  static void createFlattenElementIndices(ProcessState& state) {
+    VELOX_CHECK(!state.flattenElementsConsecutive);
+    VELOX_CHECK_NULL(state.flattenElementIndices);
+    VELOX_CHECK_NULL(state.flattenElementsWithDictionary);
+    state.flattenElementIndices =
+        allocateIndices(state.numFlattenElements, state.pool);
+    state.rawFlattenElementIndices =
+        state.flattenElementIndices->asMutable<vector_size_t>();
+    state.flattenElementsWithDictionary = BaseVector::wrapInDictionary(
+        nullptr,
+        state.flattenElementIndices,
+        state.numFlattenElements,
+        state.elements);
+  }
+
+  VectorPtr flattenArray(const ProcessState& state) const {
+    return std::make_shared<velox::ArrayVector>(
+        state.pool,
+        state.resultType,
+        nullptr,
+        state.numRows,
+        state.flattenArrayOffsets,
+        state.flattenArraySizes,
+        state.elements);
+  }
+
+  // @param inputRow The row index in the input ARRAY(ARRAY(E)) vector.
+  // @param outputRow The row index in the output ARRAY(E) vector.
+  void processOneInputArray(
+      vector_size_t inputRow,
+      vector_size_t outputRow,
+      ProcessState& state) const {
+    vector_size_t nextElementOffset{-1};
+    for (auto i = 0, offset = state.arrayOffsets[inputRow];
+         i < state.arraySizes[inputRow];
+         ++i, ++offset) {
+      if (FOLLY_UNLIKELY(state.decodedInnerArray->isNullAt(offset))) {
+        continue;
+      }
+      const auto elementArrayIndex = state.decodedInnerArray->index(offset);
+      const auto [elementOffset, numElements] =
+          state.elementOffsetAndSize(elementArrayIndex);
+      state.numFlattenElements += numElements;
+      state.rawFlattenArraySizes[outputRow] += numElements;
+      if (nextElementOffset == -1) {
+        state.rawFlattenArrayOffsets[outputRow] = elementOffset;
+      } else if (nextElementOffset != elementOffset) {
+        state.flattenElementsConsecutive = false;
+      }
+      nextElementOffset = elementOffset + numElements;
+    }
+  }
+
+  void processOneOutputRow(
+      vector_size_t inputRow,
+      vector_size_t outputRow,
+      const ProcessState& state,
+      vector_size_t& flattenElementOffset) const {
+    state.rawFlattenArrayOffsets[outputRow] = flattenElementOffset;
+    vector_size_t numFlattenElements{0};
+    for (auto i = 0, elementArrayOffset = state.arrayOffsets[inputRow];
+         i < state.arraySizes[inputRow];
+         ++i, ++elementArrayOffset) {
+      if (FOLLY_UNLIKELY(
+              state.decodedInnerArray->isNullAt(elementArrayOffset))) {
+        continue;
+      }
+      const auto elementArrayIndex =
+          state.decodedInnerArray->index(elementArrayOffset);
+      const auto [elementOffset, numElements] =
+          state.elementOffsetAndSize(elementArrayIndex);
+      for (auto elementIndex = elementOffset;
+           elementIndex < elementOffset + numElements;
+           ++elementIndex) {
+        state.rawFlattenElementIndices[flattenElementOffset++] = elementIndex;
+      }
+      numFlattenElements += numElements;
+    }
+    VELOX_CHECK_EQ(numFlattenElements, state.rawFlattenArraySizes[outputRow]);
+  }
+};
+
+} // namespace
+
+VELOX_DECLARE_VECTOR_FUNCTION(
+    udf_array_flatten,
+    ArrayFlattenFunction::signatures(),
+    std::make_unique<ArrayFlattenFunction>());
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArrayFunctions.h b/velox/functions/prestosql/ArrayFunctions.h
index 36b8541577f6..e17137c8e767 100644
--- a/velox/functions/prestosql/ArrayFunctions.h
+++ b/velox/functions/prestosql/ArrayFunctions.h
@@ -27,6 +27,7 @@
 #include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/type/Conversions.h"
 #include "velox/type/FloatingPointUtil.h"
+#include "velox/type/SimpleFunctionApi.h"
 
 #include <queue>
 
@@ -449,19 +450,20 @@ struct ArraySumFunction {
 template <typename TExecCtx, typename T>
 struct ArrayCumSumFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExecCtx)
+  using NativeType = typename SimpleTypeTrait<T>::NativeType;
 
   FOLLY_ALWAYS_INLINE void call(
       out_type<velox::Array<T>>& out,
       const arg_type<velox::Array<T>>& in) {
-    T sum = 0;
+    NativeType 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>) {
+        if constexpr (std::is_floating_point_v<NativeType>) {
           sum += in[i].value();
         } else {
-          sum = checkedPlus<T>(sum, in[i].value());
+          sum = checkedPlus<NativeType>(sum, in[i].value());
         }
         out.add_item() = sum;
       } else {
@@ -477,13 +479,13 @@ struct ArrayCumSumFunction {
   FOLLY_ALWAYS_INLINE void callNullFree(
       out_type<velox::Array<T>>& out,
       const null_free_arg_type<velox::Array<T>>& in) {
-    T sum = 0;
+    NativeType sum = 0;
 
     for (const auto& item : in) {
-      if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+      if constexpr (std::is_floating_point_v<NativeType>) {
         sum += item;
       } else {
-        sum = checkedPlus<T>(sum, item);
+        sum = checkedPlus<NativeType>(sum, item);
       }
       out.add_item() = sum;
     }
@@ -684,24 +686,22 @@ template <typename TExec, typename T>
 struct ArrayConcatFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExec)
 
-  static constexpr int32_t kMinArity = 2;
-  static constexpr int32_t kMaxArity = 254;
+  static constexpr int32_t kMaxArity = 252;
 
   void call(
       out_type<Array<T>>& out,
+      const arg_type<Array<T>>& array1,
+      const arg_type<Array<T>>& array2,
       const arg_type<Variadic<Array<T>>>& arrays) {
-    VELOX_USER_CHECK_GE(
-        arrays.size(),
-        kMinArity,
-        "There must be {} or more arguments to concat",
-        kMinArity);
     VELOX_USER_CHECK_LE(
         arrays.size(), kMaxArity, "Too many arguments for concat function");
-    int64_t elementCount = 0;
+    int64_t elementCount = array1.size() + array2.size();
     for (const auto& array : arrays) {
       elementCount += array.value().size();
     }
     out.reserve(elementCount);
+    out.add_items(array1);
+    out.add_items(array2);
     for (const auto& array : arrays) {
       out.add_items(array.value());
     }
@@ -1028,34 +1028,6 @@ struct ArrayNGramsFunctionString {
   }
 };
 
-/// This class implements the array flatten function.
-///
-/// DEFINITION:
-/// flatten(x) → array
-/// Flattens an array(array(T)) to an array(T) by concatenating the contained
-/// arrays.
-template <typename T>
-struct ArrayFlattenFunction {
-  VELOX_DEFINE_FUNCTION_TYPES(T)
-
-  FOLLY_ALWAYS_INLINE void 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();
-      }
-    }
-    out.reserve(elementCount);
-    for (const auto& array : arrays) {
-      if (array.has_value()) {
-        out.add_items(array.value());
-      }
-    }
-  }
-};
-
 /// This class implements the array union function.
 ///
 /// DEFINITION:
@@ -1161,7 +1133,7 @@ struct ArrayRemoveFunctionString {
       if (item.has_value()) {
         auto result = element.compare(item.value());
         if (result) {
-          out.push_back(item.value());
+          out.add_item().setNoCopy(item.value());
         }
       } else {
         out.add_null();
diff --git a/velox/functions/prestosql/ArrayPosition.cpp b/velox/functions/prestosql/ArrayPosition.cpp
index f509fe4a1fe0..4935ba6b84bb 100644
--- a/velox/functions/prestosql/ArrayPosition.cpp
+++ b/velox/functions/prestosql/ArrayPosition.cpp
@@ -15,7 +15,7 @@
  */
 #include <folly/CPortability.h>
 
-#include "velox/expression/Expr.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/type/FloatingPointUtil.h"
 #include "velox/vector/DecodedVector.h"
@@ -437,22 +437,23 @@ class ArrayPositionFunction : public exec::VectorFunction {
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    return {// array(T), T -> int64_t
-            exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("bigint")
-                .argumentType("array(T)")
-                .argumentType("T")
-                .build(),
-
-            // array(T), T, int64_t -> int64_t
-            exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("bigint")
-                .argumentType("array(T)")
-                .argumentType("T")
-                .argumentType("bigint")
-                .build()};
+    return {
+        // array(T), T -> int64_t
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("bigint")
+            .argumentType("array(T)")
+            .argumentType("T")
+            .build(),
+
+        // array(T), T, int64_t -> int64_t
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("bigint")
+            .argumentType("array(T)")
+            .argumentType("T")
+            .argumentType("bigint")
+            .build()};
   }
 };
 
diff --git a/velox/functions/prestosql/ArraySort.cpp b/velox/functions/prestosql/ArraySort.cpp
index a959f3c25bf3..c417fd96f6ce 100644
--- a/velox/functions/prestosql/ArraySort.cpp
+++ b/velox/functions/prestosql/ArraySort.cpp
@@ -14,552 +14,32 @@
  * 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/LambdaFunctionUtil.h"
-#include "velox/functions/lib/RowsTranslationUtil.h"
-#include "velox/functions/prestosql/SimpleComparisonMatcher.h"
-#include "velox/type/FloatingPointUtil.h"
+#include "velox/functions/prestosql/ArraySort.h"
 
 namespace facebook::velox::functions {
-namespace {
-
-BufferPtr sortElements(
-    const SelectivityVector& rows,
-    const ArrayVector& inputArray,
-    const BaseVector& inputElements,
-    bool ascending,
-    exec::EvalCtx& context,
-    bool throwOnNestedNull) {
-  const SelectivityVector inputElementRows =
-      toElementRows(inputElements.size(), rows, &inputArray);
-  exec::LocalDecodedVector decodedElements(
-      context, inputElements, inputElementRows);
-  const auto* baseElementsVector = decodedElements->base();
-
-  // Allocate new vectors for indices.
-  BufferPtr indices = allocateIndices(inputElements.size(), context.pool());
-  vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
-
-  CompareFlags flags{.nullsFirst = false, .ascending = ascending};
-  if (throwOnNestedNull) {
-    flags.nullHandlingMode =
-        CompareFlags::NullHandlingMode::kNullAsIndeterminate;
-  }
-
-  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) {
-            return false;
-          }
-          if (bNull) {
-            return true;
-          }
-
-          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;
-        });
-  });
-
-  return indices;
-}
-
-void applyComplexType(
-    const SelectivityVector& rows,
-    ArrayVector* inputArray,
-    bool ascending,
-    exec::EvalCtx& context,
-    VectorPtr& resultElements,
-    bool throwOnNestedNull) {
-  auto inputElements = inputArray->elements();
-  auto indices = sortElements(
-      rows, *inputArray, *inputElements, ascending, context, throwOnNestedNull);
-  resultElements = BaseVector::transpose(indices, std::move(inputElements));
-}
-
-template <typename T>
-inline void swapWithNull(
-    FlatVector<T>* vector,
-    vector_size_t index,
-    vector_size_t nullIndex) {
-  // Values are already present in vector stringBuffers. Don't create additional
-  // copy.
-  if constexpr (std::is_same_v<T, StringView>) {
-    vector->setNoCopy(nullIndex, vector->valueAt(index));
-  } else {
-    vector->set(nullIndex, vector->valueAt(index));
-  }
-  vector->setNull(index, true);
-}
-
-template <TypeKind kind>
-void applyScalarType(
-    const SelectivityVector& rows,
-    const ArrayVector* inputArray,
-    bool ascending,
-    exec::EvalCtx& context,
-    VectorPtr& resultElements) {
-  using T = typename TypeTraits<kind>::NativeType;
-
-  // Copy array elements to new vector.
-  const VectorPtr& inputElements = inputArray->elements();
-  VELOX_DCHECK(kind == inputElements->typeKind());
-  const SelectivityVector inputElementRows =
-      toElementRows(inputElements->size(), rows, inputArray);
-  const vector_size_t elementsCount = inputElementRows.size();
-
-  // TODO: consider to use dictionary wrapping to avoid the direct sorting on
-  // the scalar values as we do for complex data type if this runs slow in
-  // practice.
-  resultElements =
-      BaseVector::create(inputElements->type(), elementsCount, context.pool());
-  resultElements->copy(
-      inputElements.get(), inputElementRows, /*toSourceRow=*/nullptr);
-
-  auto flatResults = resultElements->asFlatVector<T>();
-
-  auto processRow = [&](vector_size_t row) {
-    const auto size = inputArray->sizeAt(row);
-    const auto offset = inputArray->offsetAt(row);
-    if (size == 0) {
-      return;
-    }
-    vector_size_t numNulls = 0;
-    // Move nulls to end of array.
-    for (vector_size_t i = size - 1; i >= 0; --i) {
-      if (flatResults->isNullAt(offset + i)) {
-        swapWithNull<T>(flatResults, offset + size - numNulls - 1, offset + i);
-        ++numNulls;
-      }
-    }
-    // Exclude null values while sorting.
-    const auto startRow = offset;
-    const auto endRow = startRow + size - numNulls;
-
-    if constexpr (kind == TypeKind::BOOLEAN) {
-      uint64_t* rawBits = flatResults->template mutableRawValues<uint64_t>();
-      const auto numOneBits = bits::countBits(rawBits, startRow, endRow);
-      const auto endZeroRow = endRow - numOneBits;
-
-      if (ascending) {
-        bits::fillBits(rawBits, startRow, endZeroRow, false);
-        bits::fillBits(rawBits, endZeroRow, endRow, true);
-      } else {
-        bits::fillBits(rawBits, startRow, startRow + numOneBits, true);
-        bits::fillBits(rawBits, startRow + numOneBits, 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) {
-        std::sort(resultRawValues + startRow, resultRawValues + endRow);
-      } else {
-        std::sort(
-            resultRawValues + startRow,
-            resultRawValues + endRow,
-            std::greater<T>());
-      }
-    }
-  };
-  rows.applyToSelected(processRow);
-}
-
-// See documentation at https://prestodb.io/docs/current/functions/array.html
-template <TypeKind Kind>
-class ArraySortFunction : public exec::VectorFunction {
- public:
-  /// This class implements the array_sort query function. Takes an array as
-  /// input and sorts it in ascending order and null elements will be placed at
-  /// the end of the returned array.
-  ///
-  /// Along with the set, we maintain a `hasNull` flag that indicates whether
-  /// null is present in the array.
-  ///
-  /// Zero element copy for complex data type:
-  ///
-  /// In order to prevent copies of array elements with complex data type, the
-  /// function reuses the internal elements() vector from the original
-  /// ArrayVector. A new vector is created containing the indices of the sorted
-  /// elements in the output, and wrapped into a DictionaryVector. The 'lengths'
-  /// and 'offsets' vectors that control where output arrays start and end
-  /// remain the same in the output ArrayVector.
-
-  explicit ArraySortFunction(bool ascending, bool throwOnNestedNull)
-      : ascending_{ascending}, throwOnNestedNull_(throwOnNestedNull) {}
-
-  // Execute function.
-  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);
-    auto& arg = args[0];
-
-    VectorPtr localResult;
-
-    // Input can be constant or flat.
-    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();
-
-      exec::LocalSingleRow singleRow(context, flatIndex);
-      localResult = applyFlat(*singleRow, flatArray, context);
-      localResult =
-          BaseVector::wrapInConstant(rows.end(), flatIndex, localResult);
-    } else {
-      localResult = applyFlat(rows, arg, context);
-    }
-
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-
- private:
-  VectorPtr applyFlat(
-      const SelectivityVector& rows,
-      const VectorPtr& arg,
-      exec::EvalCtx& context) const {
-    // Acquire the array elements vector.
-    auto inputArray = arg->as<ArrayVector>();
-    VectorPtr resultElements;
-
-    if constexpr (velox::TypeTraits<Kind>::isPrimitiveType) {
-      VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-          applyScalarType,
-          Kind,
-          rows,
-          inputArray,
-          ascending_,
-          context,
-          resultElements);
-
-    } else {
-      applyComplexType(
-          rows,
-          inputArray,
-          ascending_,
-          context,
-          resultElements,
-          throwOnNestedNull_);
-    }
-
-    return std::make_shared<ArrayVector>(
-        context.pool(),
-        inputArray->type(),
-        inputArray->nulls(),
-        rows.end(),
-        inputArray->offsets(),
-        inputArray->sizes(),
-        resultElements,
-        inputArray->getNullCount());
-  }
-
-  const bool ascending_;
-  const bool throwOnNestedNull_;
-};
-
-class ArraySortLambdaFunction : public exec::VectorFunction {
- public:
-  explicit ArraySortLambdaFunction(bool ascending, bool throwOnNestedNull)
-      : ascending_{ascending}, throwOnNestedNull_(throwOnNestedNull) {}
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /*outputType*/,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    // Flatten input array.
-    exec::LocalDecodedVector arrayDecoder(context, *args[0], rows);
-    auto& decodedArray = *arrayDecoder.get();
-
-    auto flatArray = flattenArray(rows, args[0], decodedArray);
-
-    std::vector<VectorPtr> lambdaArgs = {flatArray->elements()};
-    auto newNumElements = flatArray->elements()->size();
-
-    SelectivityVector validRowsInReusedResult =
-        toElementRows<ArrayVector>(newNumElements, rows, flatArray.get());
-
-    // Compute sorting keys.
-    VectorPtr newElements;
-
-    auto elementToTopLevelRows = getElementToTopLevelRows(
-        newNumElements, rows, flatArray.get(), context.pool());
 
-    // Loop over lambda functions and apply these to elements of the base array.
-    // In most cases there will be only one function and the loop will run once.
-    auto it = args[1]->asUnchecked<FunctionVector>()->iterator(&rows);
-    while (auto entry = it.next()) {
-      auto elementRows = toElementRows<ArrayVector>(
-          newNumElements, *entry.rows, flatArray.get());
-      auto wrapCapture = toWrapCapture<ArrayVector>(
-          newNumElements, entry.callable, *entry.rows, flatArray);
-
-      entry.callable->apply(
-          elementRows,
-          &validRowsInReusedResult,
-          wrapCapture,
-          &context,
-          lambdaArgs,
-          elementToTopLevelRows,
-          &newElements);
-    }
-
-    // Sort 'newElements'.
-    auto indices = sortElements(
-        rows,
-        *flatArray,
-        *newElements,
-        ascending_,
-        context,
-        throwOnNestedNull_);
-    auto sortedElements = BaseVector::wrapInDictionary(
-        nullptr,
-        indices,
-        indices->size() / sizeof(vector_size_t),
-        flatArray->elements());
-
-    // Set nulls for rows not present in 'rows'.
-    BufferPtr newNulls = addNullsForUnselectedRows(flatArray, rows);
-
-    VectorPtr localResult = std::make_shared<ArrayVector>(
-        flatArray->pool(),
-        flatArray->type(),
-        std::move(newNulls),
-        rows.end(),
-        flatArray->offsets(),
-        flatArray->sizes(),
-        sortedElements);
-    context.moveOrCopyResult(localResult, rows, result);
-  }
-
- 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 throwOnNestedNull = true) {
-  VELOX_CHECK_EQ(inputArgs.size(), 1);
-  return std::make_shared<ArraySortFunction<kind>>(
-      ascending, throwOnNestedNull);
-}
-
-// Create function.
-std::shared_ptr<exec::VectorFunction> create(
+std::shared_ptr<exec::VectorFunction> makeArraySortAsc(
+    const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
-    bool ascending,
-    bool throwOnNestedNull = true) {
+    const core::QueryConfig& config) {
   if (inputArgs.size() == 2) {
-    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);
-  }
-
-  return VELOX_DYNAMIC_TYPE_DISPATCH(
-      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, 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, true);
-}
-
-// Define function signature.
-std::vector<std::shared_ptr<exec::FunctionSignature>> signatures(
-    bool withComparator) {
-  std::vector<std::shared_ptr<exec::FunctionSignature>> signatures = {
-      // array(T) -> array(T)
-      exec::FunctionSignatureBuilder()
-          .orderableTypeVariable("T")
-          .returnType("array(T)")
-          .argumentType("array(T)")
-          .build(),
-      // array(T), function(T,U), boolean -> array(T)
-      exec::FunctionSignatureBuilder()
-          .typeVariable("T")
-          .orderableTypeVariable("U")
-          .returnType("array(T)")
-          .argumentType("array(T)")
-          .constantArgumentType("function(T,U)")
-          .build(),
-  };
-
-  if (withComparator) {
-    signatures.push_back(
-        // array(T), function(T,T,bigint) -> array(T)
-        exec::FunctionSignatureBuilder()
-            .typeVariable("T")
-            .returnType("array(T)")
-            .argumentType("array(T)")
-            .constantArgumentType("function(T,T,bigint)")
-            .build());
+    return makeArraySortLambdaFunction(name, inputArgs, config, true, true);
   }
-  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;
+  VELOX_CHECK_EQ(inputArgs.size(), 1);
+  return makeArraySort(name, inputArgs, config, true, false, true);
 }
 
-std::shared_ptr<exec::VectorFunction> createAscNoThrowOnNestedNull(
-    const std::string& /* name */,
+std::shared_ptr<exec::VectorFunction> makeArraySortDesc(
+    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) {
-  if (auto call = std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
-    if (call->name() == prefix + "array_sort") {
-      return call;
-    }
-  }
-  return nullptr;
-}
-
-} // namespace
-
-core::TypedExprPtr rewriteArraySortCall(
-    const std::string& prefix,
-    const core::TypedExprPtr& expr) {
-  auto call = asArraySortCall(prefix, expr);
-  if (call == nullptr || call->inputs().size() != 2) {
-    return nullptr;
-  }
-
-  auto lambda =
-      dynamic_cast<const core::LambdaTypedExpr*>(call->inputs()[1].get());
-  VELOX_CHECK_NOT_NULL(lambda);
-
-  // Extract 'transform' from the comparison lambda:
-  //  (x, y) -> if(func(x) < func(y),...) ===> x -> func(x).
-  if (lambda->signature()->size() != 2) {
-    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>{
-            call->inputs()[0],
-            std::make_shared<core::LambdaTypedExpr>(
-                ROW({lambda->signature()->nameOf(0)},
-                    {lambda->signature()->childAt(0)}),
-                comparison->expr),
-        },
-        name);
-
-    return rewritten;
+    const core::QueryConfig& config) {
+  if (inputArgs.size() == 2) {
+    return makeArraySortLambdaFunction(name, inputArgs, config, false, true);
   }
 
-  VELOX_USER_FAIL(kNotSupported, lambda->toString());
+  VELOX_CHECK_EQ(inputArgs.size(), 1);
+  return makeArraySort(name, inputArgs, config, false, false, true);
 }
 
-// Register function.
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_array_sort,
-    signatures(true),
-    createAsc);
-
-VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION(
-    udf_array_sort_desc,
-    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/ArraySort.h b/velox/functions/prestosql/ArraySort.h
index ffe5414ef2dd..e26a812dc153 100644
--- a/velox/functions/prestosql/ArraySort.h
+++ b/velox/functions/prestosql/ArraySort.h
@@ -16,21 +16,18 @@
 #pragma once
 
 #include "velox/core/Expressions.h"
+#include "velox/functions/lib/ArraySort.h"
 
 namespace facebook::velox::functions {
 
-/// Analyzes array_sort(array, lambda) call to determine whether it can be
-/// re-written into a simpler call that specifies sort-by expression.
-///
-/// For example, rewrites
-///     array_sort(a, (x, y) -> if(length(x) < length(y), -1, if(length(x) >
-///     length(y), 1, 0))
-/// into
-///     array_sort(a, x -> length(x))
-///
-/// Returns new expression or nullptr if rewrite is not possible.
-core::TypedExprPtr rewriteArraySortCall(
-    const std::string& prefix,
-    const core::TypedExprPtr& expr);
+std::shared_ptr<exec::VectorFunction> makeArraySortAsc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
+
+std::shared_ptr<exec::VectorFunction> makeArraySortDesc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArraySubset.h b/velox/functions/prestosql/ArraySubset.h
new file mode 100644
index 000000000000..5a5af0c85cf6
--- /dev/null
+++ b/velox/functions/prestosql/ArraySubset.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 "velox/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for constant indices: array_subset(arr, array[1, 2, 3]).
+template <typename TExec, typename T>
+struct ArraySubsetFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Array<T>>& out,
+      const arg_type<Array<T>>& inputArray,
+      const arg_type<Array<int32_t>>& indices) {
+    // If indices is empty, return empty array
+    if (indices.empty()) {
+      return;
+    }
+
+    // Collect valid indices with explicit bounds checking
+    folly::F14FastSet<int32_t> validIndices;
+
+    for (const auto& index : indices.skipNulls()) {
+      // Only store positive indices (1-based) and check bounds
+      if (index > 0 && index <= inputArray.size()) {
+        validIndices.emplace(index);
+      }
+    }
+
+    // If no valid indices, return empty array
+    if (validIndices.empty()) {
+      return;
+    }
+
+    // Sort indices to maintain order in output
+    std::vector<int32_t> sortedIndices(
+        validIndices.begin(), validIndices.end());
+    std::sort(sortedIndices.begin(), sortedIndices.end());
+
+    for (int32_t index : sortedIndices) {
+      // Convert 1-based to 0-based index
+      int32_t zeroBasedIndex = index - 1;
+
+      // Check bounds - only add elements that exist in the input array
+      if (zeroBasedIndex >= 0 && zeroBasedIndex < inputArray.size()) {
+        if (inputArray[zeroBasedIndex].has_value()) {
+          if constexpr (std::is_same_v<T, Varchar>) {
+            out.add_item().setNoCopy(inputArray[zeroBasedIndex].value());
+          } else {
+            out.push_back(inputArray[zeroBasedIndex].value());
+          }
+        } else {
+          // Include null elements in output
+          out.add_null();
+        }
+      }
+      // Note: Out-of-bounds indices are silently ignored (no element added)
+    }
+  }
+};
+
+/// String version that avoids copy of strings.
+template <typename TExec>
+struct ArraySubsetVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  void call(
+      out_type<Array<Varchar>>& out,
+      const arg_type<Array<Varchar>>& inputArray,
+      const arg_type<Array<int32_t>>& indices) {
+    // If indices is empty, return empty array
+    if (indices.empty()) {
+      return;
+    }
+
+    // Collect valid indices with explicit bounds checking
+    folly::F14FastSet<int32_t> validIndices;
+
+    for (const auto& index : indices.skipNulls()) {
+      // Only store positive indices (1-based) and check bounds
+      if (index > 0 && index <= inputArray.size()) {
+        validIndices.emplace(index);
+      }
+    }
+
+    // If no valid indices, return empty array
+    if (validIndices.empty()) {
+      return;
+    }
+
+    // Sort indices to maintain order in output
+    std::vector<int32_t> sortedIndices(
+        validIndices.begin(), validIndices.end());
+    std::sort(sortedIndices.begin(), sortedIndices.end());
+
+    for (int32_t index : sortedIndices) {
+      // Convert 1-based to 0-based index
+      int32_t zeroBasedIndex = index - 1;
+
+      // Check bounds - only add elements that exist in the input array
+      if (zeroBasedIndex >= 0 && zeroBasedIndex < inputArray.size()) {
+        if (inputArray[zeroBasedIndex].has_value()) {
+          out.add_item().setNoCopy(inputArray[zeroBasedIndex].value());
+        } else {
+          // Include null elements in output
+          out.add_null();
+        }
+      }
+      // Note: Out-of-bounds indices are silently ignored (no element added)
+    }
+  }
+};
+
+/// Generic implementation for complex types.
+template <typename TExec>
+struct ArraySubsetGenericFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Array<Generic<T1>>>& out,
+      const arg_type<Array<Generic<T1>>>& inputArray,
+      const arg_type<Array<int32_t>>& indices) {
+    // If indices is empty, return empty array
+    if (indices.empty()) {
+      return;
+    }
+
+    const auto arraySize = inputArray.size();
+
+    // Early return for large arrays to prevent overflow
+    if (arraySize == 0) {
+      return;
+    }
+
+    // Collect valid 1-based indices and convert to 0-based
+    std::vector<vector_size_t> validZeroBasedIndices;
+
+    for (const auto& index : indices.skipNulls()) {
+      // Only store positive indices (1-based) and check bounds
+      if (index > 0 && static_cast<vector_size_t>(index) <= arraySize) {
+        validZeroBasedIndices.push_back(static_cast<vector_size_t>(index - 1));
+      }
+    }
+
+    // If no valid indices, return empty array
+    if (validZeroBasedIndices.empty()) {
+      return;
+    }
+
+    // Sort indices to maintain order in output
+    std::sort(validZeroBasedIndices.begin(), validZeroBasedIndices.end());
+
+    // Remove duplicates
+    validZeroBasedIndices.erase(
+        std::unique(validZeroBasedIndices.begin(), validZeroBasedIndices.end()),
+        validZeroBasedIndices.end());
+
+    // Use safe iteration approach
+    vector_size_t currentPos = 0;
+    auto it = inputArray.begin();
+
+    for (vector_size_t targetIndex : validZeroBasedIndices) {
+      // Advance iterator to target position
+      while (currentPos < targetIndex && it != inputArray.end()) {
+        ++it;
+        ++currentPos;
+      }
+
+      if (it != inputArray.end() && currentPos == targetIndex) {
+        if (it->has_value()) {
+          out.push_back(it->value());
+        } else {
+          out.add_null();
+        }
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/ArraySum.cpp b/velox/functions/prestosql/ArraySum.cpp
index 1021137323f2..edbbee84e954 100644
--- a/velox/functions/prestosql/ArraySum.cpp
+++ b/velox/functions/prestosql/ArraySum.cpp
@@ -285,10 +285,11 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
   signatures.reserve(typePairs.size());
   for (const auto& [argType, returnType] : typePairs) {
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .returnType(returnType)
-                                .argumentType(fmt::format("array({})", argType))
-                                .build());
+    signatures.emplace_back(
+        exec::FunctionSignatureBuilder()
+            .returnType(returnType)
+            .argumentType(fmt::format("array({})", argType))
+            .build());
   }
   return signatures;
 }
diff --git a/velox/functions/prestosql/BinaryFunctions.h b/velox/functions/prestosql/BinaryFunctions.h
index a5e86e421449..96e84017e380 100644
--- a/velox/functions/prestosql/BinaryFunctions.h
+++ b/velox/functions/prestosql/BinaryFunctions.h
@@ -21,6 +21,7 @@
 
 #include "folly/ssl/OpenSSLHash.h"
 #include "velox/common/base/BitUtil.h"
+#include "velox/common/encode/Base32.h"
 #include "velox/common/encode/Base64.h"
 #include "velox/common/hyperloglog/Murmur3Hash128.h"
 #include "velox/external/md5/md5.h"
@@ -44,15 +45,19 @@ struct CRC32Function {
 };
 
 /// xxhash64(varbinary) → varbinary
-/// Return an 8-byte binary to hash64 of input (varbinary such as string)
+/// Return an 8-byte binary to hash64 of input (varbinary such as string) with
+/// optional seed
 template <typename T>
 struct XxHash64Function {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE
-  void call(out_type<Varbinary>& result, const arg_type<Varbinary>& input) {
-    // Seed is set to 0.
-    int64_t hash = folly::Endian::swap64(XXH64(input.data(), input.size(), 0));
+  void call(
+      out_type<Varbinary>& result,
+      const arg_type<Varbinary>& input,
+      const arg_type<int64_t>& seed = 0) {
+    int64_t hash =
+        folly::Endian::swap64(XXH64(input.data(), input.size(), seed));
     static constexpr auto kLen = sizeof(int64_t);
 
     // Resizing output and copy
@@ -253,9 +258,10 @@ template <typename T>
 struct FromHexFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  template <typename TInput>
   FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
-      const arg_type<Varbinary>& input) {
+      const TInput& input) {
     VELOX_USER_CHECK_EQ(
         input.size() % 2,
         0,
@@ -307,11 +313,33 @@ struct FromBase64Function {
   }
 };
 
+template <typename TExec>
+struct FromBase32Function {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  // 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 Status call(out_type<Varbinary>& result, const T& input) {
+    auto inputSize = input.size();
+    auto decodedSize =
+        encoding::Base32::calculateDecodedSize(input.data(), inputSize);
+    if (decodedSize.hasError()) {
+      return decodedSize.error();
+    }
+    result.resize(decodedSize.value());
+    return encoding::Base32::decode(
+        input.data(), inputSize, result.data(), result.size());
+  }
+};
+
 template <typename T>
 struct FromBase64UrlFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  template <typename TInput>
   FOLLY_ALWAYS_INLINE Status
-  call(out_type<Varbinary>& result, const arg_type<Varchar>& input) {
+  call(out_type<Varbinary>& result, const TInput& input) {
     auto inputSize = input.size();
     auto decodedSize =
         encoding::Base64::calculateDecodedSize(input.data(), inputSize);
diff --git a/velox/functions/prestosql/BingTileFunctions.h b/velox/functions/prestosql/BingTileFunctions.h
index 1be19e25af09..3277ef3ac005 100644
--- a/velox/functions/prestosql/BingTileFunctions.h
+++ b/velox/functions/prestosql/BingTileFunctions.h
@@ -16,11 +16,27 @@
 #pragma once
 
 #include "velox/common/base/Status.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
 
 namespace facebook::velox::functions {
 
+FOLLY_ALWAYS_INLINE Status checkBingTileZoom(int32_t zoom) {
+  if (FOLLY_UNLIKELY(zoom < 0)) {
+    return Status::UserError(
+        fmt::format("Bing tile zoom {} cannot be negative", zoom));
+  }
+  if (FOLLY_UNLIKELY(zoom > BingTileType::kBingTileMaxZoomLevel)) {
+    return Status::UserError(
+        fmt::format(
+            "Bing tile zoom {} cannot be greater than max zoom {}",
+            zoom,
+            BingTileType::kBingTileMaxZoomLevel));
+  }
+  return Status::OK();
+}
+
 template <typename T>
 struct BingTileFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -29,7 +45,7 @@ struct BingTileFunction {
       out_type<BingTile>& result,
       const arg_type<int32_t>& x,
       const arg_type<int32_t>& y,
-      const arg_type<int8_t>& zoom) {
+      const arg_type<int32_t>& zoom) {
     if (FOLLY_UNLIKELY(x < 0)) {
       return Status::UserError(
           fmt::format("Bing tile X coordinate {} cannot be negative", x));
@@ -38,9 +54,10 @@ struct BingTileFunction {
       return Status::UserError(
           fmt::format("Bing tile Y coordinate {} cannot be negative", y));
     }
-    if (FOLLY_UNLIKELY(zoom < 0)) {
-      return Status::UserError(
-          fmt::format("Bing tile zoom {} cannot be negative", zoom));
+
+    Status zoomCheck = checkBingTileZoom(zoom);
+    if (FOLLY_UNLIKELY(!zoomCheck.ok())) {
+      return zoomCheck;
     }
 
     uint64_t tile = BingTileType::bingTileCoordsToInt(
@@ -53,11 +70,12 @@ struct BingTileFunction {
       if (reason.has_value()) {
         return Status::UserError(reason.value());
       } else {
-        return Status::UnknownError(fmt::format(
-            "Velox Error constructing BingTile from x {} y {} zoom {}; please report this.",
-            x,
-            y,
-            zoom));
+        return Status::UnknownError(
+            fmt::format(
+                "Velox Error constructing BingTile from x {} y {} zoom {}; please report this.",
+                x,
+                y,
+                zoom));
       }
     }
     result = tile;
@@ -143,12 +161,37 @@ struct BingTileParentFunction {
     result = parent.value();
     return Status::OK();
   }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<BingTile>& result,
+      const arg_type<BingTile>& tile,
+      const arg_type<int32_t>& parentZoom) {
+    if (FOLLY_UNLIKELY(parentZoom > BingTileType::kBingTileMaxZoomLevel)) {
+      return Status::UserError(
+          fmt::format(
+              "newZoom {} is greater than max zoom {}",
+              parentZoom,
+              BingTileType::kBingTileMaxZoomLevel));
+    }
+    return call(result, tile, static_cast<int8_t>(parentZoom));
+  }
 };
 
 template <typename T>
 struct BingTileChildrenFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  uint8_t maxZoomShift = 5;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      const arg_type<BingTile>* /* tile */,
+      const arg_type<int32_t>* /* childZoom */) {
+    maxZoomShift =
+        std::max<uint8_t>(config.debugBingTileChildrenMaxZoomShift(), 1);
+  }
+
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Array<BingTile>>& result, const arg_type<BingTile>& tile) {
     uint64_t tileInt = tile;
@@ -158,7 +201,8 @@ struct BingTileChildrenFunction {
       return Status::UserError(
           fmt::format("Cannot call bing_tile_children on zoom 23 tile"));
     }
-    auto childrenRes = BingTileType::bingTileChildren(tileInt, tileZoom + 1);
+    auto childrenRes =
+        BingTileType::bingTileChildren(tileInt, tileZoom + 1, maxZoomShift);
     if (FOLLY_UNLIKELY(childrenRes.hasError())) {
       return Status::UserError(childrenRes.error());
     }
@@ -171,14 +215,15 @@ struct BingTileChildrenFunction {
   FOLLY_ALWAYS_INLINE Status call(
       out_type<Array<BingTile>>& result,
       const arg_type<BingTile>& tile,
-      const arg_type<int8_t>& childZoom) {
+      const arg_type<int32_t>& childZoom) {
     uint64_t tileInt = tile;
     VELOX_DCHECK(BingTileType::isBingTileIntValid(tileInt));
-    if (FOLLY_UNLIKELY(childZoom < 0)) {
-      return Status::UserError(
-          fmt::format("Cannot call bing_tile_children with negative zoom"));
+    Status zoomCheck = checkBingTileZoom(childZoom);
+    if (FOLLY_UNLIKELY(!zoomCheck.ok())) {
+      return zoomCheck;
     }
-    auto childrenRes = BingTileType::bingTileChildren(tileInt, childZoom);
+    auto childrenRes =
+        BingTileType::bingTileChildren(tileInt, childZoom, maxZoomShift);
     if (FOLLY_UNLIKELY(childrenRes.hasError())) {
       return Status::UserError(childrenRes.error());
     }
@@ -210,10 +255,10 @@ struct BingTileAtFunction {
       out_type<BingTile>& result,
       const arg_type<double>& latitude,
       const arg_type<double>& longitude,
-      const arg_type<int8_t>& zoomLevel) {
-    if (FOLLY_UNLIKELY(zoomLevel < 0)) {
-      return Status::UserError(
-          fmt::format("Bing tile zoom {} cannot be negative", zoomLevel));
+      const arg_type<int32_t>& zoomLevel) {
+    Status zoomCheck = checkBingTileZoom(zoomLevel);
+    if (FOLLY_UNLIKELY(!zoomCheck.ok())) {
+      return zoomCheck;
     }
     auto latitudeLongitudeToTileResult = BingTileType::latitudeLongitudeToTile(
         latitude, longitude, static_cast<uint8_t>(zoomLevel));
@@ -233,10 +278,10 @@ struct BingTilesAroundFunction {
       out_type<Array<BingTile>>& result,
       const arg_type<double>& latitude,
       const arg_type<double>& longitude,
-      const arg_type<int8_t>& zoomLevel) {
-    if (FOLLY_UNLIKELY(zoomLevel < 0)) {
-      return Status::UserError(
-          fmt::format("Bing tile zoom {} cannot be negative", zoomLevel));
+      const arg_type<int32_t>& zoomLevel) {
+    Status zoomCheck = checkBingTileZoom(zoomLevel);
+    if (FOLLY_UNLIKELY(!zoomCheck.ok())) {
+      return zoomCheck;
     }
     auto bingTilesAroundResult = BingTileType::bingTilesAround(
         latitude, longitude, static_cast<uint8_t>(zoomLevel));
@@ -253,11 +298,11 @@ struct BingTilesAroundFunction {
       out_type<Array<BingTile>>& result,
       const arg_type<double>& latitude,
       const arg_type<double>& longitude,
-      const arg_type<int8_t>& zoomLevel,
+      const arg_type<int32_t>& zoomLevel,
       const arg_type<double>& radiusInKm) {
-    if (FOLLY_UNLIKELY(zoomLevel < 0)) {
-      return Status::UserError(
-          fmt::format("Bing tile zoom {} cannot be negative", zoomLevel));
+    Status zoomCheck = checkBingTileZoom(zoomLevel);
+    if (FOLLY_UNLIKELY(!zoomCheck.ok())) {
+      return zoomCheck;
     }
     auto bingTilesAroundResult = BingTileType::bingTilesAround(
         latitude, longitude, static_cast<uint8_t>(zoomLevel), radiusInKm);
diff --git a/velox/functions/prestosql/CMakeLists.txt b/velox/functions/prestosql/CMakeLists.txt
index 34f48edc4dc6..a9dd8a8b8942 100644
--- a/velox/functions/prestosql/CMakeLists.txt
+++ b/velox/functions/prestosql/CMakeLists.txt
@@ -21,6 +21,7 @@ velox_add_library(
   ArrayContains.cpp
   ArrayDistinct.cpp
   ArrayDuplicates.cpp
+  ArrayFlatten.cpp
   ArrayIntersectExcept.cpp
   ArrayAndMapMatch.cpp
   ArrayMinMaxBy.cpp
@@ -39,13 +40,14 @@ velox_add_library(
   MapEntries.cpp
   MapFromEntries.cpp
   MapKeysAndValues.cpp
+  MapSubset.cpp
   MapZipWith.cpp
   Not.cpp
   Reduce.cpp
   Reverse.cpp
   RowFunction.cpp
   Sequence.cpp
-  SimpleComparisonMatcher.cpp
+  SfmSketchFunctions.cpp
   Split.cpp
   SplitToMap.cpp
   StringFunctions.cpp
@@ -55,12 +57,13 @@ velox_add_library(
   TransformKeys.cpp
   TransformValues.cpp
   TypeOf.cpp
+  UpperLower.cpp
   URIParser.cpp
-  URLFunctions.cpp
   VectorArithmetic.cpp
   WidthBucketArray.cpp
   Zip.cpp
-  ZipWith.cpp)
+  ZipWith.cpp
+)
 
 velox_link_libraries(
   velox_functions_prestosql_impl
@@ -73,7 +76,14 @@ velox_link_libraries(
   velox_presto_types
   velox_functions_util
   Folly::folly
-  stemmer::stemmer)
+  FastFloat::fast_float
+  stemmer::stemmer
+)
+
+if(VELOX_ENABLE_FAISS)
+  velox_link_libraries(velox_functions_prestosql_impl FAISS::faiss)
+  velox_compile_definitions(velox_functions_prestosql_impl PRIVATE VELOX_ENABLE_FAISS)
+endif()
 
 if(VELOX_ENABLE_GEO)
   add_subdirectory(geospatial)
@@ -81,8 +91,7 @@ if(VELOX_ENABLE_GEO)
 endif()
 
 if(NOT VELOX_MONO_LIBRARY)
-  set_property(TARGET velox_functions_prestosql_impl PROPERTY JOB_POOL_COMPILE
-                                                              high_memory_pool)
+  set_property(TARGET velox_functions_prestosql_impl PROPERTY JOB_POOL_COMPILE high_memory_pool)
 endif()
 
 if(${VELOX_ENABLE_AGGREGATES})
diff --git a/velox/functions/prestosql/Comparisons.cpp b/velox/functions/prestosql/Comparisons.cpp
index 89015f9f7f2e..d89237b11ee9 100644
--- a/velox/functions/prestosql/Comparisons.cpp
+++ b/velox/functions/prestosql/Comparisons.cpp
@@ -190,19 +190,21 @@ class ComparisonSimdFunction : public exec::VectorFunction {
              "interval day to second",
              "interval year to month",
          }) {
-      signatures.push_back(exec::FunctionSignatureBuilder()
-                               .returnType("boolean")
-                               .argumentType(inputType)
-                               .argumentType(inputType)
-                               .build());
+      signatures.push_back(
+          exec::FunctionSignatureBuilder()
+              .returnType("boolean")
+              .argumentType(inputType)
+              .argumentType(inputType)
+              .build());
     }
-    signatures.push_back(exec::FunctionSignatureBuilder()
-                             .integerVariable("a_precision")
-                             .integerVariable("a_scale")
-                             .returnType("boolean")
-                             .argumentType("DECIMAL(a_precision, a_scale)")
-                             .argumentType("DECIMAL(a_precision, a_scale)")
-                             .build());
+    signatures.push_back(
+        exec::FunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("boolean")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .build());
     return signatures;
   }
 
diff --git a/velox/functions/prestosql/DataSizeFunctions.h b/velox/functions/prestosql/DataSizeFunctions.h
index 7486dcbb6bcc..881bb61bd183 100644
--- a/velox/functions/prestosql/DataSizeFunctions.h
+++ b/velox/functions/prestosql/DataSizeFunctions.h
@@ -35,8 +35,8 @@ enum class Unit : int128_t {
   YOTTABYTE = int128_t(1) << 80
 };
 
-inline Unit parseUnit(const std::string& dataSize, const size_t& valueLength) {
-  static const std::map<std::string, Unit> unitMap = {
+inline Unit parseUnit(std::string_view dataSize, size_t valueLength) {
+  static const std::map<std::string_view, Unit> unitMap = {
       {"B", Unit::BYTE},
       {"kB", Unit::KILOBYTE},
       {"MB", Unit::MEGABYTE},
@@ -45,9 +45,10 @@ inline Unit parseUnit(const std::string& dataSize, const size_t& valueLength) {
       {"PB", Unit::PETABYTE},
       {"EB", Unit::EXABYTE},
       {"ZB", Unit::ZETTABYTE},
-      {"YB", Unit::YOTTABYTE}};
+      {"YB", Unit::YOTTABYTE},
+  };
   try {
-    std::string unitString = dataSize.substr(valueLength);
+    std::string_view unitString = dataSize.substr(valueLength);
     auto it = unitMap.find(unitString);
     VELOX_USER_CHECK(it != unitMap.end(), "Invalid data size: '{}'", dataSize);
     return it->second;
@@ -55,18 +56,16 @@ inline Unit parseUnit(const std::string& dataSize, const size_t& valueLength) {
     VELOX_USER_FAIL("Invalid data size: '{}'", dataSize);
   }
 }
-inline double parseValue(
-    const std::string& dataSize,
-    const size_t& valueLength) {
+inline double parseValue(std::string_view dataSize, size_t valueLength) {
   try {
-    std::string value = dataSize.substr(0, valueLength);
-    return std::stod(value);
+    std::string_view value = dataSize.substr(0, valueLength);
+    return folly::to<double>(value);
   } catch (const std::exception&) {
     VELOX_USER_FAIL("Invalid data size: '{}'", dataSize);
   }
 }
 
-inline int128_t getDecimal(const std::string& dataSize) {
+inline int128_t getDecimal(std::string_view dataSize) {
   size_t valueLength = 0;
   while (valueLength < dataSize.length() &&
          (isdigit(dataSize[valueLength]) || dataSize[valueLength] == '.')) {
@@ -98,13 +97,19 @@ struct ParsePrestoDataSizeFunction {
   FOLLY_ALWAYS_INLINE void callAscii(
       out_type<LongDecimal<P1, S1>>& result,
       const arg_type<Varchar>& input) {
-    result = getDecimal(input);
+    // TODO: Remove explicit std::string_view cast.
+    result = getDecimal(std::string_view(input));
   }
-  // Fail Non-ASCII characters in input.
   FOLLY_ALWAYS_INLINE void call(
       out_type<LongDecimal<P1, S1>>& result,
       const arg_type<Varchar>& input) {
-    VELOX_USER_FAIL("Invalid data size: '{}'", input);
+    // If ASCII input process else fail.
+    if (stringCore::isAscii(input.data(), input.size())) {
+      // TODO: Remove explicit std::string_view cast.
+      result = getDecimal(std::string_view(input));
+    } else {
+      VELOX_USER_FAIL("Invalid data size: '{}'", input);
+    }
   }
 };
 
diff --git a/velox/functions/prestosql/DateTimeFunctions.h b/velox/functions/prestosql/DateTimeFunctions.h
index 3c51061da83a..72354ca60703 100644
--- a/velox/functions/prestosql/DateTimeFunctions.h
+++ b/velox/functions/prestosql/DateTimeFunctions.h
@@ -16,17 +16,23 @@
 #pragma once
 
 #define XXH_INLINE_ALL
-#include <boost/regex.hpp>
+#include <fast_float/fast_float.h>
+#include <re2/re2.h>
 #include <xxhash.h>
 #include <string_view>
-#include "velox/expression/ComplexViewTypes.h"
+#include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/DateTimeFormatter.h"
 #include "velox/functions/lib/TimeUtils.h"
 #include "velox/functions/prestosql/DateTimeImpl.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Time.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/type/Type.h"
 #include "velox/type/tz/TimeZoneMap.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/ConstantVector.h"
+#include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::functions {
 
@@ -44,7 +50,7 @@ struct ToUnixtimeFunction {
       double& result,
       const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
     const auto milliseconds = unpackMillisUtc(*timestampWithTimezone);
-    result = (double)milliseconds / kMillisecondsInSecond;
+    result = (double)milliseconds / Timestamp::kMillisecondsInSecond;
   }
 };
 
@@ -97,8 +103,9 @@ struct FromUnixtimeFunction {
       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(
-        checkedPlus(checkedMultiply<int64_t>(hours, 60), minutes)));
+    int16_t timezoneId = tzID_.value_or(
+        tz::getTimeZoneID(
+            checkedPlus(checkedMultiply<int64_t>(hours, 60), minutes)));
     result = pack(fromUnixtime(unixtime).toMillis(), timezoneId);
   }
 
@@ -534,6 +541,136 @@ struct TimestampPlusInterval {
   const tz::TimeZone* sessionTimeZone_ = nullptr;
 };
 
+template <typename T>
+struct TimePlusInterval {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<Time>& time,
+      const arg_type<IntervalDayTime>& interval) {
+    result = addToTime(time, interval);
+  }
+};
+
+template <typename T>
+struct TimeMinusInterval {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<Time>& time,
+      const arg_type<IntervalDayTime>& interval) {
+    result = addToTime(time, -interval);
+  }
+};
+
+template <typename T>
+struct TimeMinusFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<IntervalDayTime>& result,
+      const arg_type<Time>& a,
+      const arg_type<Time>& b) {
+    // Validate inputs are in valid TIME range [0, 86400000)
+    VELOX_USER_CHECK(
+        a >= 0 && a < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        a);
+    VELOX_USER_CHECK(
+        b >= 0 && b < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        b);
+
+    // Simple subtraction returns interval in milliseconds
+    result = a - b;
+  }
+};
+
+// Optimized vector function for Time +/- IntervalYearMonth
+// This case is special because result = time (identity function), allowing
+// for significant optimizations.
+// For plus: supports both (time, interval) and (interval, time)
+// For minus: only supports (time, interval) - not (interval, time)
+class TimeIntervalYearMonthVectorFunction : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VectorPtr& timeVector = args[0]->type()->isTime() ? args[0] : args[1];
+
+    // Constant vector case
+    // If time input is constant, create constant result - no iteration!
+    if (timeVector->isConstantEncoding()) {
+      auto constantTime = timeVector->as<ConstantVector<int64_t>>();
+      if (constantTime->isNullAt(0)) {
+        result = BaseVector::createNullConstant(
+            outputType, rows.size(), context.pool());
+      } else {
+        auto value = constantTime->valueAt(0);
+        result = BaseVector::createConstant(
+            outputType, value, rows.size(), context.pool());
+      }
+      return;
+    }
+
+    // Single reference case
+    // If input vector is singly referenced, reuse it directly - zero copy!
+    if (!result && BaseVector::isVectorWritable(timeVector)) {
+      result = std::move(timeVector); // Move input to result - zero copy!
+      return;
+    }
+
+    // FALLBACK: Standard processing for other cases
+    context.ensureWritable(rows, outputType, result);
+    auto* flatResult = result->asFlatVector<int64_t>();
+    // Fast path for flat vectors - use FlatVector::copy for efficient copying
+    flatResult->copy(timeVector.get(), rows, nullptr);
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>>
+  signaturesPlus() {
+    return {
+        // Signature 1: (time, interval year to month) -> time
+        exec::FunctionSignatureBuilder()
+            .returnType("time")
+            .argumentType("time")
+            .argumentType("interval year to month")
+            .build(),
+        // Signature 2: (interval year to month, time) -> time
+        exec::FunctionSignatureBuilder()
+            .returnType("time")
+            .argumentType("interval year to month")
+            .argumentType("time")
+            .build()};
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>>
+  signaturesMinus() {
+    return {// Only support: (time, interval year to month) -> time
+            exec::FunctionSignatureBuilder()
+                .returnType("time")
+                .argumentType("time")
+                .argumentType("interval year to month")
+                .build()};
+  }
+};
+
+template <typename T>
+struct IntervalPlusTime {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<IntervalDayTime>& interval,
+      const arg_type<Time>& time) {
+    result = addToTime(time, interval);
+  }
+};
+
 template <typename T>
 struct IntervalPlusTimestamp {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -765,6 +902,16 @@ struct HourFunction : public InitSessionTimezone<T>,
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     result = getDateTime(timestamp, nullptr).tm_hour;
   }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Time>& time) {
+    VELOX_USER_CHECK(
+        time >= 0 && time < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        time);
+    result = std::chrono::duration_cast<std::chrono::hours>(
+                 std::chrono::milliseconds(time))
+                 .count();
+  }
 };
 
 template <typename T>
@@ -799,6 +946,16 @@ struct MinuteFunction : public InitSessionTimezone<T>,
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     result = getDateTime(timestamp, nullptr).tm_min;
   }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Time>& time) {
+    VELOX_USER_CHECK(
+        time >= 0 && time < kMillisInDay,
+        "TIME value {} is out of valid range [0, 86399999]",
+        time);
+    auto duration = std::chrono::milliseconds(time);
+    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration);
+    result = minutes.count() % kMinutesInHour;
+  }
 };
 
 template <typename T>
@@ -832,6 +989,16 @@ struct SecondFunction : public TimestampWithTimezoneSupport<T> {
     auto timestamp = this->toTimestamp(timestampWithTimezone);
     result = getDateTime(timestamp, nullptr).tm_sec;
   }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Time>& time) {
+    VELOX_USER_CHECK(
+        time >= 0 && time < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        time);
+    auto duration = std::chrono::milliseconds(time);
+    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
+    result = seconds.count() % kSecondsInMinute;
+  }
 };
 
 template <typename T>
@@ -852,7 +1019,7 @@ struct MillisecondFunction : public TimestampWithTimezoneSupport<T> {
   FOLLY_ALWAYS_INLINE void call(
       int64_t& result,
       const arg_type<Timestamp>& timestamp) {
-    result = timestamp.getNanos() / kNanosecondsInMillisecond;
+    result = timestamp.getNanos() / Timestamp::kNanosecondsInMillisecond;
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -866,7 +1033,16 @@ struct MillisecondFunction : public TimestampWithTimezoneSupport<T> {
       int64_t& result,
       const arg_type<TimestampWithTimezone>& timestampWithTimezone) {
     auto timestamp = this->toTimestamp(timestampWithTimezone);
-    result = timestamp.getNanos() / kNanosecondsInMillisecond;
+    result = timestamp.getNanos() / Timestamp::kNanosecondsInMillisecond;
+  }
+
+  FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Time>& time) {
+    VELOX_USER_CHECK(
+        time >= 0 && time < kMillisInDay,
+        "TIME value {} is out of range [0, 86400000)",
+        time);
+    auto time_duration = std::chrono::milliseconds(time);
+    result = (time_duration % std::chrono::seconds(1)).count();
   }
 };
 
@@ -877,16 +1053,11 @@ struct MillisecondFromIntervalFunction {
   FOLLY_ALWAYS_INLINE void call(
       int64_t& result,
       const arg_type<IntervalDayTime>& millis) {
-    result = millis % kMillisecondsInSecond;
+    result = millis % Timestamp::kMillisecondsInSecond;
   }
 };
 
 namespace {
-inline bool isTimeUnit(const DateTimeUnit unit) {
-  return unit == DateTimeUnit::kMillisecond || unit == DateTimeUnit::kSecond ||
-      unit == DateTimeUnit::kMinute || unit == DateTimeUnit::kHour;
-}
-
 inline bool isDateUnit(const DateTimeUnit unit) {
   return unit == DateTimeUnit::kDay || unit == DateTimeUnit::kMonth ||
       unit == DateTimeUnit::kQuarter || unit == DateTimeUnit::kYear ||
@@ -919,6 +1090,35 @@ inline std::optional<DateTimeUnit> getTimestampUnit(
   return unit;
 }
 
+inline std::optional<DateTimeUnit> getTimeUnit(
+    const StringView& unitString,
+    bool throwIfInvalid = true) {
+  std::optional<DateTimeUnit> unit =
+      fromDateTimeUnitString(unitString, /*throwIfInvalid=*/false);
+
+  // Presto does not support microseconds for TIME type operations.
+  // Only millisecond, second, minute, and hour are valid TIME fields.
+  // See: presto-main-base/.../DateTimeFunctions.java:getTimeField()
+  if (unit.has_value() && isTimeUnit(unit.value()) &&
+      unit.value() != DateTimeUnit::kMicrosecond) {
+    return unit;
+  }
+
+  if (throwIfInvalid) {
+    VELOX_USER_FAIL("{} is not a valid TIME field", unitString);
+  }
+  return std::nullopt;
+}
+
+inline void checkValueInInt32Range(int64_t value) {
+  if (value != static_cast<int32_t>(value)) {
+    VELOX_UNSUPPORTED(
+        "Value should be in range [{}, {}]",
+        std::numeric_limits<int32_t>::min(),
+        std::numeric_limits<int32_t>::max());
+  }
+}
+
 } // namespace
 
 template <typename T>
@@ -960,6 +1160,16 @@ 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<Time>* /*time*/) {
+    if (unitString != nullptr) {
+      unit_ = getTimeUnit(*unitString);
+    }
+  }
+
   FOLLY_ALWAYS_INLINE void call(
       out_type<Timestamp>& result,
       const arg_type<Varchar>& unitString,
@@ -1041,6 +1251,19 @@ struct DateTruncFunction : public TimestampWithTimezoneSupport<T> {
 
     result = pack(resultMillis, unpackZoneKeyId(*timestampWithTimezone));
   }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<Varchar>& unitString,
+      const arg_type<Time>& time) {
+    DateTimeUnit unit;
+    if (unit_.has_value()) {
+      unit = unit_.value();
+    } else {
+      unit = getTimeUnit(unitString).value();
+    }
+    result = truncateTime(time, unit);
+  }
 };
 
 template <typename T>
@@ -1058,7 +1281,7 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
       const arg_type<Timestamp>* /*timestamp*/) {
     sessionTimeZone_ = getTimeZoneFromConfig(config);
     if (unitString != nullptr) {
-      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/false);
+      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/true);
     }
   }
 
@@ -1073,6 +1296,17 @@ 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*/,
+      const arg_type<Time>* /*time*/) {
+    if (unitString != nullptr) {
+      unit_ = getTimeUnit(*unitString, /*throwIfInvalid=*/true);
+    }
+  }
+
   FOLLY_ALWAYS_INLINE void call(
       out_type<Timestamp>& result,
       const arg_type<Varchar>& unitString,
@@ -1082,36 +1316,9 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
         ? unit_.value()
         : fromDateTimeUnitString(unitString, /*throwIfInvalid=*/true).value();
 
-    if (value != (int32_t)value) {
-      VELOX_UNSUPPORTED("integer overflow");
-    }
-
-    if (LIKELY(sessionTimeZone_ != nullptr)) {
-      // sessionTimeZone not null means that the config
-      // adjust_timestamp_to_timezone is on.
-      Timestamp zonedTimestamp = timestamp;
-      zonedTimestamp.toTimezone(*sessionTimeZone_);
-
-      Timestamp resultTimestamp =
-          addToTimestamp(zonedTimestamp, unit, (int32_t)value);
-
-      if (isTimeUnit(unit)) {
-        const int64_t offset = static_cast<Timestamp>(timestamp).getSeconds() -
-            zonedTimestamp.getSeconds();
-        result = Timestamp(
-            resultTimestamp.getSeconds() + offset, resultTimestamp.getNanos());
-      } else {
-        result = Timestamp(
-            sessionTimeZone_
-                ->correct_nonexistent_time(
-                    std::chrono::seconds(resultTimestamp.getSeconds()))
-                .count(),
-            resultTimestamp.getNanos());
-        result.toGMT(*sessionTimeZone_);
-      }
-    } else {
-      result = addToTimestamp(timestamp, unit, (int32_t)value);
-    }
+    checkValueInInt32Range(value);
+    result = addToTimestamp(
+        unit, static_cast<int32_t>(value), timestamp, sessionTimeZone_);
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -1122,12 +1329,10 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
     const auto unit = unit_.value_or(
         fromDateTimeUnitString(unitString, /*throwIfInvalid=*/true).value());
 
-    if (value != (int32_t)value) {
-      VELOX_UNSUPPORTED("integer overflow");
-    }
+    checkValueInInt32Range(value);
 
     result = addToTimestampWithTimezone(
-        *timestampWithTimezone, unit, (int32_t)value);
+        *timestampWithTimezone, unit, static_cast<int32_t>(value));
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -1139,11 +1344,26 @@ struct DateAddFunction : public TimestampWithTimezoneSupport<T> {
         ? unit_.value()
         : getDateUnit(unitString, true).value();
 
-    if (value != (int32_t)value) {
-      VELOX_UNSUPPORTED("integer overflow");
+    checkValueInInt32Range(value);
+
+    result = addToDate(date, unit, static_cast<int32_t>(value));
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Time>& result,
+      const arg_type<Varchar>& unitString,
+      const int64_t value,
+      const arg_type<Time>& time) {
+    DateTimeUnit unit;
+    if (unit_.has_value()) {
+      unit = unit_.value();
+    } else {
+      unit = getTimeUnit(unitString, /*throwIfInvalid=*/true).value();
     }
 
-    result = addToDate(date, unit, (int32_t)value);
+    checkValueInInt32Range(value);
+
+    result = addToTime(unit, static_cast<int32_t>(value), time);
   }
 };
 
@@ -1161,7 +1381,7 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
       const arg_type<Timestamp>* /*timestamp1*/,
       const arg_type<Timestamp>* /*timestamp2*/) {
     if (unitString != nullptr) {
-      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/false);
+      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/true);
     }
 
     sessionTimeZone_ = getTimeZoneFromConfig(config);
@@ -1185,7 +1405,18 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
       const arg_type<TimestampWithTimezone>* /*timestampWithTimezone1*/,
       const arg_type<TimestampWithTimezone>* /*timestampWithTimezone2*/) {
     if (unitString != nullptr) {
-      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/false);
+      unit_ = fromDateTimeUnitString(*unitString, /*throwIfInvalid=*/true);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      const arg_type<Varchar>* unitString,
+      const arg_type<Time>* /*time1*/,
+      const arg_type<Time>* /*time2*/) {
+    if (unitString != nullptr) {
+      unit_ = getTimeUnit(*unitString, /*throwIfInvalid=*/true);
     }
   }
 
@@ -1196,27 +1427,7 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
       const arg_type<Timestamp>& timestamp2) {
     const auto unit = unit_.value_or(
         fromDateTimeUnitString(unitString, /*throwIfInvalid=*/true).value());
-
-    if (LIKELY(sessionTimeZone_ != nullptr)) {
-      // sessionTimeZone not null means that the config
-      // adjust_timestamp_to_timezone is on.
-      Timestamp fromZonedTimestamp = timestamp1;
-      fromZonedTimestamp.toTimezone(*sessionTimeZone_);
-
-      Timestamp toZonedTimestamp = timestamp2;
-      if (isTimeUnit(unit)) {
-        const int64_t offset = static_cast<Timestamp>(timestamp1).getSeconds() -
-            fromZonedTimestamp.getSeconds();
-        toZonedTimestamp = Timestamp(
-            toZonedTimestamp.getSeconds() - offset,
-            toZonedTimestamp.getNanos());
-      } else {
-        toZonedTimestamp.toTimezone(*sessionTimeZone_);
-      }
-      result = diffTimestamp(unit, fromZonedTimestamp, toZonedTimestamp);
-    } else {
-      result = diffTimestamp(unit, timestamp1, timestamp2);
-    }
+    result = diffTimestamp(unit, timestamp1, timestamp2, sessionTimeZone_);
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -1249,6 +1460,21 @@ struct DateDiffFunction : public TimestampWithTimezoneSupport<T> {
         *timestampWithTz1,
         pack(unpackMillisUtc(*timestampWithTz2), timeZoneId));
   }
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<Varchar>& unitString,
+      const arg_type<Time>& time1,
+      const arg_type<Time>& time2) {
+    DateTimeUnit unit;
+    if (unit_.has_value()) {
+      unit = unit_.value();
+    } else {
+      unit = getTimeUnit(unitString, /*throwIfInvalid=*/true).value();
+    }
+
+    result = diffTime(unit, time1, time2);
+  }
 };
 
 template <typename T>
@@ -1580,6 +1806,44 @@ struct CurrentDateFunction {
   }
 };
 
+template <typename T>
+struct CurrentTimezoneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  std::string tzName_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>&,
+      const core::QueryConfig& config) {
+    tzName_ = config.sessionTimezone();
+  }
+  FOLLY_ALWAYS_INLINE void call(out_type<Varchar>& result) {
+    result = std::string_view(tzName_);
+  }
+};
+
+template <typename T>
+struct CurrentTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  int64_t result_{0};
+  const tz::TimeZone* timeZone_ = nullptr;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /* type */,
+      const core::QueryConfig& config) {
+    Timestamp ts = Timestamp::fromMillis(config.sessionStartTimeMs());
+    timeZone_ = getTimeZoneFromConfig(config);
+    if (timeZone_ == nullptr) {
+      VELOX_USER_FAIL("Timezone cannot be null");
+    }
+    result_ = pack(ts, timeZone_->id());
+  }
+
+  FOLLY_ALWAYS_INLINE void call(out_type<TimestampWithTimezone>& result) {
+    result = result_;
+  }
+};
+
 template <typename T>
 struct TimeZoneHourFunction : public TimestampWithTimezoneSupport<T> {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -1701,6 +1965,40 @@ struct AtTimezoneFunction : public TimestampWithTimezoneSupport<T> {
   }
 };
 
+template <typename T>
+struct AtTimezoneTimeWithTimezoneFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<TimeWithTimezone>& result,
+      const arg_type<TimeWithTimezone>& timeWithTz,
+      const arg_type<Varchar>& targetTimezone) {
+    // Extract milliseconds UTC from the input
+    auto millisUtc = util::unpackMillisUtc(*timeWithTz);
+
+    // Parse the target timezone offset from the VARCHAR string
+    auto offsetResult = util::parseTimezoneOffset(
+        targetTimezone.data(),
+        targetTimezone.size(),
+        /*allowCompactFormat*/ false);
+    if (offsetResult.hasError()) {
+      if (offsetResult.error().isUserError()) {
+        VELOX_USER_FAIL(offsetResult.error().message());
+      } else {
+        VELOX_FAIL(offsetResult.error().message());
+      }
+    }
+
+    auto targetOffsetMinutes = offsetResult.value();
+
+    // Encode the timezone offset using bias encoding
+    auto encodedOffset = util::biasEncode(targetOffsetMinutes);
+
+    // Pack and return the result with the same UTC time but new timezone
+    result = util::pack(millisUtc, encodedOffset);
+  }
+};
+
 template <typename TExec>
 struct ToMillisecondFunction {
   VELOX_DEFINE_FUNCTION_TYPES(TExec);
@@ -1740,48 +2038,79 @@ struct XxHash64TimestampFunction {
   }
 };
 
+/// xxhash64(Time) → bigint
+/// Return a xxhash64 of input Time
 template <typename T>
-struct ParseDurationFunction {
+struct XxHash64TimeFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
-  std::unique_ptr<boost::regex> durationRegex_;
-
-  FOLLY_ALWAYS_INLINE void initialize(
-      const std::vector<TypePtr>& /*inputTypes*/,
-      const core::QueryConfig& /*config*/,
-      const arg_type<Varchar>* /*amountUnit*/) {
-    durationRegex_ = std::make_unique<boost::regex>(
-        "^\\s*(\\d+(?:\\.\\d+)?)\\s*([a-zA-Z]+)\\s*$");
+  FOLLY_ALWAYS_INLINE
+  void call(out_type<int64_t>& result, const arg_type<Time>& input) {
+    // TIME is represented as milliseconds since midnight
+    // Convert to big-endian to match Presto's xxhash64 behavior
+    auto bigEndianValue = folly::Endian::big(input);
+    result = XXH64(&bigEndianValue, sizeof(bigEndianValue), 0);
   }
+};
+
+template <typename T>
+struct ParseDurationFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void call(
       out_type<IntervalDayTime>& result,
       const arg_type<Varchar>& amountUnit) {
-    std::string strAmountUnit = (std::string)amountUnit;
-    boost::smatch match;
-    bool isMatch = boost::regex_search(strAmountUnit, match, *durationRegex_);
-    if (!isMatch) {
+    static const LazyRE2 kDurationRegex{
+        .pattern_ = R"(^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]+)\s*$)",
+        .options_ = {},
+    };
+    // TODO: Remove re2::StringPiece != std::string_view hacks.
+    // It's needed because for some systems in CI,
+    // re2 and abseil libraries are old.
+    re2::StringPiece valueStr;
+    re2::StringPiece unitStr;
+    re2::StringPiece amountUnitStr{amountUnit.data(), amountUnit.size()};
+    if (!RE2::FullMatch(amountUnitStr, *kDurationRegex, &valueStr, &unitStr)) {
       VELOX_USER_FAIL(
-          "Input duration is not a valid data duration string: {}", amountUnit);
+          "Input duration is not a valid data duration string: {}",
+          std::string_view(amountUnitStr.data(), amountUnitStr.size()));
     }
-    VELOX_USER_CHECK_EQ(
-        match.size(),
-        3,
-        "Input duration does not have value and unit components only: {}",
-        amountUnit);
-    try {
-      double value = std::stod(match[1].str());
-      std::string unit = match[2].str();
-      result = valueOfTimeUnitToMillis(value, unit);
-    } catch (std::out_of_range&) {
+
+    double value{};
+    auto [_, error] = fast_float::from_chars(
+        valueStr.data(), valueStr.data() + valueStr.size(), value);
+    if (error == std::errc::result_out_of_range) {
       VELOX_USER_FAIL(
           "Input duration value is out of range for double: {}",
-          match[1].str());
-    } catch (std::invalid_argument&) {
+          std::string_view(valueStr.data(), valueStr.size()));
+    } else if (error != std::errc{}) {
       VELOX_USER_FAIL(
-          "Input duration value is not a valid number: {}", match[1].str());
+          "Input duration value is not a valid number: {}",
+          std::string_view(valueStr.data(), valueStr.size()));
     }
+
+    result = valueOfTimeUnitToMillis(value, {unitStr.data(), unitStr.size()});
   }
 };
 
+template <typename T>
+struct LocalTimeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config) {
+    auto sessionStartTimeMs = config.sessionStartTimeMs();
+    localTimeSinceMidnight_ = sessionStartTimeMs % kMillisInDay;
+  }
+
+  // LocalTime just returns the time from midnight in UTC.
+  FOLLY_ALWAYS_INLINE void call(out_type<Time>& result) {
+    result = localTimeSinceMidnight_;
+  }
+
+ private:
+  int64_t localTimeSinceMidnight_;
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/DateTimeImpl.h b/velox/functions/prestosql/DateTimeImpl.h
index e19805904910..54fb632c350e 100644
--- a/velox/functions/prestosql/DateTimeImpl.h
+++ b/velox/functions/prestosql/DateTimeImpl.h
@@ -15,27 +15,21 @@
  */
 #pragma once
 
-#include <boost/numeric/conversion/cast.hpp>
-#include <chrono>
-#include <optional>
+#include "velox/common/base/CheckedArithmetic.h"
 #include "velox/common/base/Doubles.h"
-#include "velox/external/date/date.h"
 #include "velox/functions/lib/DateTimeFormatter.h"
+#include "velox/functions/lib/DateTimeUtil.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/type/Timestamp.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::functions {
-namespace {
-constexpr double kNanosecondsInSecond = 1'000'000'000;
-constexpr int64_t kNanosecondsInMillisecond = 1'000'000;
-constexpr int64_t kMillisecondsInSecond = 1'000;
-} // namespace
 
 FOLLY_ALWAYS_INLINE double toUnixtime(const Timestamp& timestamp) {
   double result = timestamp.getSeconds();
-  result += static_cast<double>(timestamp.getNanos()) / kNanosecondsInSecond;
+  result +=
+      static_cast<double>(timestamp.getNanos()) / Timestamp::kNanosInSecond;
   return result;
 }
 
@@ -64,12 +58,11 @@ FOLLY_ALWAYS_INLINE Timestamp fromUnixtime(double unixtime) {
     ++seconds;
     milliseconds = 0;
   }
-  return Timestamp(seconds, milliseconds * kNanosecondsInMillisecond);
+  return Timestamp(
+      seconds, milliseconds * Timestamp::kNanosecondsInMillisecond);
 }
 
-FOLLY_ALWAYS_INLINE boost::int64_t fromUnixtime(
-    double unixtime,
-    int16_t timeZoneId) {
+FOLLY_ALWAYS_INLINE int64_t fromUnixtime(double unixtime, int16_t timeZoneId) {
   if (FOLLY_UNLIKELY(std::isnan(unixtime))) {
     return pack(0, timeZoneId);
   }
@@ -89,127 +82,8 @@ FOLLY_ALWAYS_INLINE boost::int64_t fromUnixtime(
                         : pack(std::numeric_limits<int64_t>::max(), timeZoneId);
   }
 
-  return pack(std::llround(unixtime * kMillisecondsInSecond), timeZoneId);
-}
-
-// Year, quarter or month are not uniformly incremented. Months have different
-// total days, and leap years have more days than the rest. If the new year,
-// quarter or month has less total days than the given one, it will be coerced
-// to use the valid last day of the new month. This could result in weird
-// arithmetic behavior. For example,
-//
-// 2022-01-30 + (1 month) = 2022-02-28
-// 2022-02-28 - (1 month) = 2022-01-28
-//
-// 2022-08-31 + (1 quarter) = 2022-11-30
-// 2022-11-30 - (1 quarter) = 2022-08-30
-//
-// 2020-02-29 + (1 year) = 2021-02-28
-// 2021-02-28 - (1 year) = 2020-02-28
-FOLLY_ALWAYS_INLINE
-int32_t
-addToDate(const int32_t input, const DateTimeUnit unit, const int32_t value) {
-  // TODO(gaoge): Handle overflow and underflow with 64-bit representation
-  if (value == 0) {
-    return input;
-  }
-
-  const std::chrono::time_point<std::chrono::system_clock, date::days> inDate{
-      date::days(input)};
-  std::chrono::time_point<std::chrono::system_clock, date::days> outDate;
-
-  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;
-
-    if (unit == DateTimeUnit::kMonth) {
-      outCalDate = inCalDate + date::months(value);
-    } else if (unit == DateTimeUnit::kQuarter) {
-      outCalDate = inCalDate + date::months(3 * value);
-    } else if (unit == DateTimeUnit::kYear) {
-      outCalDate = inCalDate + date::years(value);
-    } else {
-      VELOX_UNREACHABLE();
-    }
-
-    if (!outCalDate.ok()) {
-      outCalDate = outCalDate.year() / outCalDate.month() / date::last;
-    }
-    outDate = date::sys_days{outCalDate};
-  }
-
-  return outDate.time_since_epoch().count();
-}
-
-FOLLY_ALWAYS_INLINE Timestamp addToTimestamp(
-    const Timestamp& timestamp,
-    const DateTimeUnit unit,
-    const int32_t value) {
-  // TODO(gaoge): Handle overflow and underflow with 64-bit representation
-  if (value == 0) {
-    return timestamp;
-  }
-
-  const std::chrono::
-      time_point<std::chrono::system_clock, std::chrono::milliseconds>
-          inTimestamp(std::chrono::milliseconds(timestamp.toMillis()));
-  std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>
-      outTimestamp;
-
-  switch (unit) {
-    // Year, quarter or month are not uniformly incremented in terms of number
-    // of days. So we treat them differently.
-    case DateTimeUnit::kYear:
-    case DateTimeUnit::kQuarter:
-    case DateTimeUnit::kMonth:
-    case DateTimeUnit::kDay: {
-      const int32_t inDate =
-          std::chrono::duration_cast<date::days>(inTimestamp.time_since_epoch())
-              .count();
-      const int32_t outDate = addToDate(inDate, unit, value);
-      outTimestamp =
-          inTimestamp + date::days(checkedMinus<int32_t>(outDate, inDate));
-      break;
-    }
-    case DateTimeUnit::kHour: {
-      outTimestamp = inTimestamp + std::chrono::hours(value);
-      break;
-    }
-    case DateTimeUnit::kMinute: {
-      outTimestamp = inTimestamp + std::chrono::minutes(value);
-      break;
-    }
-    case DateTimeUnit::kSecond: {
-      outTimestamp = inTimestamp + std::chrono::seconds(value);
-      break;
-    }
-    case DateTimeUnit::kMillisecond: {
-      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("Unsupported datetime unit");
-  }
-
-  Timestamp milliTimestamp =
-      Timestamp::fromMillis(outTimestamp.time_since_epoch().count());
-  return Timestamp(
-      milliTimestamp.getSeconds(),
-      milliTimestamp.getNanos() +
-          timestamp.getNanos() % kNanosecondsInMillisecond);
+  return pack(
+      std::llround(unixtime * Timestamp::kMillisecondsInSecond), timeZoneId);
 }
 
 // If time zone is provided, use it for the arithmetic operation (convert to it,
@@ -248,11 +122,12 @@ FOLLY_ALWAYS_INLINE int64_t addToTimestampWithTimezone(
       // results if we use local time.
       const tz::TimeZone* timeZone =
           tz::locateZone(unpackZoneKeyId(timestampWithTimezone));
-      auto originalTimestamp =
-          Timestamp::fromMillis(timeZone
-                                    ->to_local(std::chrono::milliseconds(
-                                        unpackMillisUtc(timestampWithTimezone)))
-                                    .count());
+      auto originalTimestamp = Timestamp::fromMillis(
+          timeZone
+              ->to_local(
+                  std::chrono::milliseconds(
+                      unpackMillisUtc(timestampWithTimezone)))
+              .count());
       auto updatedTimeStamp =
           addToTimestamp(originalTimestamp, unit, (int32_t)value);
       updatedTimeStamp = Timestamp(
@@ -273,138 +148,6 @@ FOLLY_ALWAYS_INLINE int64_t addToTimestampWithTimezone(
   }
 }
 
-FOLLY_ALWAYS_INLINE int64_t diffTimestamp(
-    const DateTimeUnit unit,
-    const Timestamp& fromTimestamp,
-    const Timestamp& toTimestamp) {
-  // TODO(gaoge): Handle overflow and underflow with 64-bit representation
-  if (fromTimestamp == toTimestamp) {
-    return 0;
-  }
-
-  const int8_t sign = fromTimestamp < toTimestamp ? 1 : -1;
-
-  // fromTimepoint is less than or equal to toTimepoint
-  const std::chrono::
-      time_point<std::chrono::system_clock, std::chrono::milliseconds>
-          fromTimepoint(std::chrono::milliseconds(
-              std::min(fromTimestamp, toTimestamp).toMillis()));
-  const std::chrono::
-      time_point<std::chrono::system_clock, std::chrono::milliseconds>
-          toTimepoint(std::chrono::milliseconds(
-              std::max(fromTimestamp, toTimestamp).toMillis()));
-
-  // Millisecond, second, minute, hour and day have fixed conversion ratio
-  switch (unit) {
-    case DateTimeUnit::kMillisecond: {
-      return sign *
-          std::chrono::duration_cast<std::chrono::milliseconds>(
-              toTimepoint - fromTimepoint)
-              .count();
-    }
-    case DateTimeUnit::kSecond: {
-      return sign *
-          std::chrono::duration_cast<std::chrono::seconds>(
-              toTimepoint - fromTimepoint)
-              .count();
-    }
-    case DateTimeUnit::kMinute: {
-      return sign *
-          std::chrono::duration_cast<std::chrono::minutes>(
-              toTimepoint - fromTimepoint)
-              .count();
-    }
-    case DateTimeUnit::kHour: {
-      return sign *
-          std::chrono::duration_cast<std::chrono::hours>(
-              toTimepoint - fromTimepoint)
-              .count();
-    }
-    case DateTimeUnit::kDay: {
-      return sign *
-          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;
-  }
-
-  // Month, quarter and year do not have fixed conversion ratio. Ex. a month can
-  // have 28, 29, 30 or 31 days. A year can have 365 or 366 days.
-  const std::chrono::time_point<std::chrono::system_clock, date::days>
-      fromDaysTimepoint = std::chrono::floor<date::days>(fromTimepoint);
-  const std::chrono::time_point<std::chrono::system_clock, date::days>
-      toDaysTimepoint = std::chrono::floor<date::days>(toTimepoint);
-  const date::year_month_day fromCalDate(fromDaysTimepoint);
-  const date::year_month_day toCalDate(toDaysTimepoint);
-  const uint64_t fromTimeInstantOfDay =
-      std::chrono::duration_cast<std::chrono::milliseconds>(
-          fromTimepoint - fromDaysTimepoint)
-          .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()),
-                toMonth = static_cast<unsigned>(toCalDate.month());
-  const date::year_month_day toCalLastYearMonthDay(
-      toCalDate.year() / toCalDate.month() / date::last);
-  const uint8_t toLastYearMonthDay =
-      static_cast<unsigned>(toCalLastYearMonthDay.day());
-
-  if (unit == DateTimeUnit::kMonth || unit == DateTimeUnit::kQuarter) {
-    int64_t diff =
-        (int64_t(toCalDate.year()) - int64_t(fromCalDate.year())) * 12 +
-        int(toMonth) - int(fromMonth);
-
-    if ((toDay != toLastYearMonthDay && fromDay > toDay) ||
-        (fromDay == toDay && fromTimeInstantOfDay > toTimeInstantOfDay)) {
-      diff--;
-    }
-
-    diff = (unit == DateTimeUnit::kMonth) ? diff : diff / 3;
-    return sign * diff;
-  }
-
-  if (unit == DateTimeUnit::kYear) {
-    int64_t diff = (toCalDate.year() - fromCalDate.year()).count();
-
-    if (fromMonth > toMonth ||
-        (fromMonth == toMonth && fromDay > toDay &&
-         toDay != toLastYearMonthDay) ||
-        (fromMonth == toMonth && fromDay == toDay &&
-         fromTimeInstantOfDay > toTimeInstantOfDay)) {
-      diff--;
-    }
-    return sign * diff;
-  }
-
-  VELOX_UNREACHABLE("Unsupported datetime unit");
-}
-
 FOLLY_ALWAYS_INLINE int64_t diffTimestampWithTimeZone(
     const DateTimeUnit unit,
     const int64_t fromTimestampWithTimeZone,
@@ -429,15 +172,17 @@ FOLLY_ALWAYS_INLINE int64_t diffTimestampWithTimeZone(
     // doesn't affect time units less than a day, and will produce incorrect
     // results if we use local time.
     const tz::TimeZone* timeZone = tz::locateZone(fromTimeZoneId);
-    fromTimestamp = Timestamp::fromMillis(
-        timeZone
-            ->to_local(std::chrono::milliseconds(
-                unpackMillisUtc(fromTimestampWithTimeZone)))
-            .count());
+    fromTimestamp =
+        Timestamp::fromMillis(timeZone
+                                  ->to_local(
+                                      std::chrono::milliseconds(unpackMillisUtc(
+                                          fromTimestampWithTimeZone)))
+                                  .count());
     toTimestamp =
         Timestamp::fromMillis(timeZone
-                                  ->to_local(std::chrono::milliseconds(
-                                      unpackMillisUtc(toTimestampWithTimeZone)))
+                                  ->to_local(
+                                      std::chrono::milliseconds(unpackMillisUtc(
+                                          toTimestampWithTimeZone)))
                                   .count());
   }
 
@@ -459,6 +204,71 @@ int64_t diffDate(
       Timestamp((int64_t)toDate * util::kSecsPerDay, 0));
 }
 
+FOLLY_ALWAYS_INLINE
+int64_t diffTime(
+    const DateTimeUnit unit,
+    const int64_t fromTime,
+    const int64_t toTime) {
+  // Validate time inputs are in valid range [0, 86400000)
+  VELOX_USER_CHECK(
+      fromTime >= 0 && fromTime < kMillisInDay,
+      "from TIME value {} is out of range [0, 86400000)",
+      fromTime);
+  VELOX_USER_CHECK(
+      toTime >= 0 && toTime < kMillisInDay,
+      "to TIME value {} is out of range [0, 86400000)",
+      toTime);
+
+  if (fromTime == toTime) {
+    return 0;
+  }
+
+  // Use std::chrono for safe duration arithmetic
+  const auto fromDuration = std::chrono::milliseconds(fromTime);
+  const auto toDuration = std::chrono::milliseconds(toTime);
+  const auto diff = toDuration - fromDuration;
+
+  switch (unit) {
+    case DateTimeUnit::kMillisecond:
+      return diff.count();
+    case DateTimeUnit::kSecond:
+      return std::chrono::duration_cast<std::chrono::seconds>(diff).count();
+    case DateTimeUnit::kMinute:
+      return std::chrono::duration_cast<std::chrono::minutes>(diff).count();
+    case DateTimeUnit::kHour:
+      return std::chrono::duration_cast<std::chrono::hours>(diff).count();
+    default:
+      VELOX_USER_FAIL("Unsupported time unit for TIME type");
+  }
+}
+
+FOLLY_ALWAYS_INLINE int64_t
+addToTime(const DateTimeUnit unit, const int32_t value, const int64_t time) {
+  if (value == 0) {
+    return time;
+  }
+
+  int64_t valueInMillis;
+  switch (unit) {
+    case DateTimeUnit::kMillisecond:
+      valueInMillis = value;
+      break;
+    case DateTimeUnit::kSecond:
+      valueInMillis = checkedMultiply<int64_t>(value, kMillisInSecond);
+      break;
+    case DateTimeUnit::kMinute:
+      valueInMillis = checkedMultiply<int64_t>(value, kMillisInMinute);
+      break;
+    case DateTimeUnit::kHour:
+      valueInMillis = checkedMultiply<int64_t>(value, kMillisInHour);
+      break;
+    default:
+      VELOX_USER_FAIL("Unsupported time unit for TIME type");
+  }
+
+  return addToTime(time, valueInMillis);
+}
+
 FOLLY_ALWAYS_INLINE int64_t
 valueOfTimeUnitToMillis(const double value, std::string_view unit) {
   double convertedValue = value;
@@ -478,15 +288,14 @@ valueOfTimeUnitToMillis(const double value, std::string_view unit) {
   } else {
     VELOX_USER_FAIL("Unknown time unit: {}", unit);
   }
-  try {
-    return boost::numeric_cast<int64_t>(std::round(convertedValue));
-  } catch (const boost::bad_numeric_cast&) {
-    VELOX_USER_FAIL(
-        "Value in {} unit is too large to be represented in ms unit as an int64_t",
-        unit,
-        value);
+
+  auto result = folly::tryTo<int64_t>(std::round(convertedValue));
+  if (result.hasValue()) {
+    return result.value();
   }
-  VELOX_UNREACHABLE();
+  VELOX_USER_FAIL(
+      "Value in {} unit is too large to be represented in ms unit as an int64_t",
+      unit);
 }
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/DistanceFunctions.h b/velox/functions/prestosql/DistanceFunctions.h
new file mode 100644
index 000000000000..db6a51414440
--- /dev/null
+++ b/velox/functions/prestosql/DistanceFunctions.h
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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 <vector>
+#include "velox/functions/Macros.h"
+#include "velox/functions/Registerer.h"
+
+#ifdef VELOX_ENABLE_FAISS
+#include "faiss/utils/distances.h"
+#endif
+
+namespace facebook::velox::functions {
+namespace {
+
+#ifdef VELOX_ENABLE_FAISS
+
+template <typename T>
+struct CosineSimilarityFunctionMap {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  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;
+    }
+    // dimension of the vectors, and be conservative assume no overlap.
+    int d = static_cast<int>(leftMap.size() + rightMap.size());
+    // Make a vector to store values of left and right maps
+    std::vector<float> x(d * 2, 0);
+    size_t i = 0;
+    // TODO: optimize this and avoid copying.
+    for (const auto& [key, value] : leftMap) {
+      auto it = rightMap.find(key);
+      double right = (it != rightMap.end()) ? it->second : 0;
+      if (i < d) { // Check buffer bounds
+        x[i] = static_cast<float>(value);
+      }
+      if (static_cast<size_t>(d + i) < x.size()) { // Check buffer bounds
+        x[d + i] = static_cast<float>(right);
+      }
+      i++;
+    }
+    // For the remaining keys in rightMap that does not appear in leftMap
+    for (const auto& [key, value] : rightMap) {
+      if (leftMap.find(key) == leftMap.end()) {
+        x[d + i++] = static_cast<float>(value);
+      }
+    }
+    // Compute the L2 norms by calling faiss
+    float norms[2] = {0};
+    faiss::fvec_norms_L2(norms, /*x=*/x.data(), /*d=*/d, /*nx=*/2);
+    float product = faiss::fvec_inner_product(x.data(), /*y=*/x.data() + d, d);
+    if (norms[0] == 0 || norms[1] == 0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+    // Cosine similarity
+    result = static_cast<double>(product / (norms[0] * norms[1]));
+  }
+};
+
+template <typename T>
+struct CosineSimilarityFunctionArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void callNullFree(
+      out_type<double>& result,
+      const null_free_arg_type<Array<double>>& leftArray,
+      const null_free_arg_type<Array<double>>& rightArray) {
+    VELOX_USER_CHECK(
+        leftArray.size() == rightArray.size(),
+        "Both arrays need to have identical size");
+
+    size_t d = leftArray.size();
+    std::vector<float> x(static_cast<std::vector<float>::size_type>(d * 2), 0);
+    for (size_t i = 0; i < leftArray.size(); i++) {
+      if (i < x.size()) { // Check buffer bounds
+        x[i] = static_cast<float>(leftArray[i]);
+      }
+    }
+    for (size_t i = 0; i < rightArray.size(); i++) {
+      if (i + d < x.size()) { // Check buffer bounds
+        x[i + d] = static_cast<float>(rightArray[i]);
+      }
+    }
+
+    float norms[2] = {0};
+    faiss::fvec_norms_L2(norms, /*x=*/x.data(), /*d=*/d, /*nx=*/2);
+    if (norms[0] == 0 || norms[1] == 0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+    float product = faiss::fvec_inner_product(x.data(), /*y=*/x.data() + d, d);
+
+    result = static_cast<double>(product / (norms[0] * norms[1]));
+  }
+};
+
+template <typename T>
+const T* getArrayDataOrCopy(
+    const facebook::velox::exec::ArrayView<false, T>& array,
+    std::vector<T>& buffer) {
+  if (array.isFlatElements()) {
+    auto flatVec = dynamic_cast<const facebook::velox::FlatVector<T>*>(
+        array.elementsVectorBase());
+    if (flatVec) {
+      return flatVec->template rawValues<T>() + array.offset();
+    }
+  }
+  // Not flat: must copy
+  buffer.resize(array.size());
+  for (size_t i = 0; i < array.size(); ++i) {
+    buffer[i] = array[i];
+  }
+  return buffer.data();
+}
+
+template <typename T>
+struct CosineSimilarityFunctionFloatArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void callNullFree(
+      out_type<float>& result,
+      const facebook::velox::exec::ArrayView<false, float>& leftArray,
+      const facebook::velox::exec::ArrayView<false, float>& rightArray) {
+    VELOX_USER_CHECK(
+        leftArray.size() == rightArray.size(),
+        "Both arrays need to have identical size");
+    size_t d = leftArray.size();
+    if (d == 0) {
+      result = std::numeric_limits<float>::quiet_NaN();
+      return;
+    }
+
+    std::vector<float> leftBuffer, rightBuffer;
+    const float* x = getArrayDataOrCopy(leftArray, leftBuffer);
+    const float* y = getArrayDataOrCopy(rightArray, rightBuffer);
+
+    float normX = 0, normY = 0;
+    faiss::fvec_norms_L2(&normX, x, d, 1);
+    faiss::fvec_norms_L2(&normY, y, d, 1);
+    if (normX == 0 || normY == 0) {
+      result = std::numeric_limits<float>::quiet_NaN();
+      return;
+    }
+    float product = faiss::fvec_inner_product(x, y, d);
+    result = static_cast<float>(product / (normX * normY));
+  }
+};
+
+template <typename T>
+struct L2SquaredFunctionFloatArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void callNullFree(
+      out_type<float>& result,
+      const facebook::velox::exec::ArrayView<false, float>& leftArray,
+      const facebook::velox::exec::ArrayView<false, float>& rightArray) {
+    VELOX_USER_CHECK(
+        leftArray.size() == rightArray.size(),
+        "Both arrays need to have identical size");
+    size_t d = leftArray.size();
+    if (d == 0) {
+      result = std::numeric_limits<float>::quiet_NaN();
+      return;
+    }
+
+    std::vector<float> leftBuffer, rightBuffer;
+    const float* x = getArrayDataOrCopy(leftArray, leftBuffer);
+    const float* y = getArrayDataOrCopy(rightArray, rightBuffer);
+    result = faiss::fvec_L2sqr(x, y, d);
+  }
+};
+
+template <typename T>
+struct L2SquaredFunctionDoubleArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void callNullFree(
+      out_type<double>& result,
+      const facebook::velox::exec::ArrayView<false, double>& leftArray,
+      const facebook::velox::exec::ArrayView<false, double>& rightArray) {
+    VELOX_USER_CHECK(
+        leftArray.size() == rightArray.size(),
+        "Both arrays need to have identical size");
+    size_t d = leftArray.size();
+    if (d == 0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+
+    std::vector<float> x(static_cast<std::vector<float>::size_type>(d), 0);
+    std::vector<float> y(static_cast<std::vector<float>::size_type>(d), 0);
+
+    for (size_t i = 0; i < leftArray.size(); i++) {
+      if (i < x.size()) {
+        x[i] = static_cast<float>(leftArray[i]);
+      }
+    }
+    for (size_t i = 0; i < rightArray.size(); i++) {
+      if (i < x.size()) {
+        y[i] = static_cast<float>(rightArray[i]);
+      }
+    }
+
+    float l2_sqr = faiss::fvec_L2sqr(x.data(), y.data(), d);
+    result = static_cast<double>(l2_sqr);
+  }
+};
+
+template <typename T>
+struct DotProductFloatArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void callNullFree(
+      out_type<float>& result,
+      const facebook::velox::exec::ArrayView<false, float>& leftArray,
+      const facebook::velox::exec::ArrayView<false, float>& rightArray) {
+    VELOX_USER_CHECK(
+        leftArray.size() == rightArray.size(),
+        "Both array arguments must have identical sizes");
+    size_t d = leftArray.size();
+    if (d == 0) {
+      result = std::numeric_limits<float>::quiet_NaN();
+      return;
+    }
+
+    std::vector<float> leftBuffer, rightBuffer;
+    const float* x = getArrayDataOrCopy(leftArray, leftBuffer);
+    const float* y = getArrayDataOrCopy(rightArray, rightBuffer);
+
+    result = faiss::fvec_inner_product(x, y, d);
+  }
+};
+
+template <typename T>
+struct DotProductArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void callNullFree(
+      out_type<double>& result,
+      const facebook::velox::exec::ArrayView<false, double>& leftArray,
+      const facebook::velox::exec::ArrayView<false, double>& rightArray) {
+    VELOX_USER_CHECK(
+        leftArray.size() == rightArray.size(),
+        "Both array arguments must have identical sizes");
+    size_t d = leftArray.size();
+    if (d == 0) {
+      result = std::numeric_limits<float>::quiet_NaN();
+      return;
+    }
+
+    std::vector<float> x(static_cast<std::vector<float>::size_type>(d * 2), 0);
+    for (size_t i = 0; i < leftArray.size(); i++) {
+      if (i < x.size()) { // Check buffer bounds
+        x[i] = static_cast<float>(leftArray[i]);
+      }
+    }
+    for (size_t i = 0; i < rightArray.size(); i++) {
+      if (i + d < x.size()) { // Check buffer bounds
+        x[i + d] = static_cast<float>(rightArray[i]);
+      }
+    }
+
+    result = static_cast<double>(
+        faiss::fvec_inner_product(x.data(), /*y=*/x.data() + d, d));
+  }
+};
+
+#else // VELOX_ENABLE_FAISS
+
+template <typename T>
+struct CosineSimilarityFunctionMap {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  double normalize(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 dotProduct(
+      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 = normalize(leftMap);
+    if (normLeftMap == 0.0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+
+    double normRightMap = normalize(rightMap);
+    if (normRightMap == 0.0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+
+    double product = dotProduct(leftMap, rightMap);
+    result = product / (normLeftMap * normRightMap);
+  }
+};
+
+template <typename T>
+struct CosineSimilarityFunctionArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  double normalize(const null_free_arg_type<Array<double>>& map) {
+    double norm = 0.0;
+    for (const auto value : map) {
+      norm += (value * value);
+    }
+    return std::sqrt(norm);
+  }
+
+  double dotProduct(
+      const null_free_arg_type<Array<double>>& leftArray,
+      const null_free_arg_type<Array<double>>& rightArray) {
+    double result = 0.0;
+    for (size_t i = 0; i < leftArray.size(); i++) {
+      result += leftArray[i] * rightArray[i];
+    }
+    return result;
+  }
+
+  void callNullFree(
+      out_type<double>& result,
+      const null_free_arg_type<Array<double>>& leftArray,
+      const null_free_arg_type<Array<double>>& rightArray) {
+    VELOX_USER_CHECK(
+        leftArray.size() == rightArray.size(),
+        "Both arrays need to have identical size");
+
+    double normLeftArray = normalize(leftArray);
+    if (normLeftArray == 0.0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+
+    double normRightArray = normalize(rightArray);
+    if (normRightArray == 0.0) {
+      result = std::numeric_limits<double>::quiet_NaN();
+      return;
+    }
+
+    double product = dotProduct(leftArray, rightArray);
+    result = product / (normLeftArray * normRightArray);
+  }
+};
+
+template <typename T>
+struct DotProductArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  void callNullFree(
+      out_type<double>& result,
+      const facebook::velox::exec::ArrayView<false, double>& leftArray,
+      const facebook::velox::exec::ArrayView<false, double>& rightArray) {
+    VELOX_USER_CHECK(
+        leftArray.size() == rightArray.size(),
+        "Both array arguments must have identical sizes");
+    size_t d = leftArray.size();
+    if (d == 0) {
+      result = std::numeric_limits<float>::quiet_NaN();
+      return;
+    }
+
+    double dotProduct = 0.0;
+    for (size_t i = 0; i < leftArray.size(); i++) {
+      dotProduct += leftArray[i] * rightArray[i];
+    }
+
+    result = dotProduct;
+  }
+};
+
+#endif // VELOX_ENABLE_FAISS
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/EnumFunctions.h b/velox/functions/prestosql/EnumFunctions.h
new file mode 100644
index 000000000000..326d3f610878
--- /dev/null
+++ b/velox/functions/prestosql/EnumFunctions.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/common/base/Status.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec, typename EnumTypePtr>
+struct EnumKeyFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      const arg_type<BigintEnum<E1>>* /*input*/) {
+    VELOX_USER_CHECK_EQ(
+        inputTypes.size(), 1, "Expected 1 input type for enum_key function.");
+    enumPtr_ = asBigintEnum(inputTypes[0]);
+    VELOX_USER_CHECK_NOT_NULL(
+        enumPtr_, "Input type for enum_key function must be a BigintEnumType.");
+  }
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      const arg_type<VarcharEnum<E1>>* /*input*/) {
+    VELOX_USER_CHECK_EQ(
+        inputTypes.size(), 1, "Expected 1 input type for enum_key function.");
+    enumPtr_ = asVarcharEnum(inputTypes[0]);
+    VELOX_USER_CHECK_NOT_NULL(
+        enumPtr_,
+        "Input type for enum_key function must be a VarcharEnumType.");
+  }
+
+  Status call(out_type<Varchar>& result, const int64_t& input) {
+    auto keyAt = enumPtr_->keyAt(input);
+    if (!keyAt.has_value()) {
+      return Status::UserError(
+          "Value '{}' not in BigintEnum: {}", input, enumPtr_->toString());
+    }
+    result = keyAt.value();
+    return Status::OK();
+  }
+
+  Status call(out_type<Varchar>& result, const arg_type<Varchar>& input) {
+    auto keyAt = enumPtr_->keyAt(std::string(input));
+    if (!keyAt.has_value()) {
+      return Status::UserError(
+          "Value '{}' not in VarcharEnum: {}", input, enumPtr_->toString());
+    }
+    result = keyAt.value();
+    return Status::OK();
+  }
+
+ private:
+  EnumTypePtr enumPtr_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/FilterFunctions.cpp b/velox/functions/prestosql/FilterFunctions.cpp
index 63519caafe5a..7c972d2b4707 100644
--- a/velox/functions/prestosql/FilterFunctions.cpp
+++ b/velox/functions/prestosql/FilterFunctions.cpp
@@ -18,6 +18,7 @@
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
+#include "velox/vector/FlatMapVector.h"
 #include "velox/vector/FunctionVector.h"
 
 namespace facebook::velox::functions {
@@ -34,7 +35,7 @@ class FilterFunctionBase : public exec::VectorFunction {
   static vector_size_t doApply(
       const SelectivityVector& rows,
       const std::shared_ptr<T>& input,
-      const VectorPtr& lambdas,
+      const VectorPtr& lambda,
       const std::vector<VectorPtr>& lambdaArgs,
       exec::EvalCtx& context,
       BufferPtr& resultOffsets,
@@ -60,7 +61,7 @@ class FilterFunctionBase : public exec::VectorFunction {
         getElementToTopLevelRows(numElements, rows, input.get(), pool);
 
     exec::LocalDecodedVector bitsDecoder(context);
-    auto iter = lambdas->asUnchecked<FunctionVector>()->iterator(&rows);
+    auto iter = lambda->asUnchecked<FunctionVector>()->iterator(&rows);
     while (auto entry = iter.next()) {
       auto elementRows =
           toElementRows<T>(numElements, *entry.rows, input.get());
@@ -173,27 +174,184 @@ class ArrayFilterFunction : public FilterFunctionBase {
 //    - https://prestodb.io/docs/current/functions/lambda.html
 //    - https://prestodb.io/blog/2020/03/02/presto-lambda
 class MapFilterFunction : public FilterFunctionBase {
- public:
-  void apply(
+ private:
+  // Builds a SelectivityVector based upon FlatMapVector's inMap buffer. This
+  // buffer indicates whether or not a particular key is present in that map's
+  // row. When applying lambda functions we should avoid executing on key-value
+  // pairs that are not present in that particular row. SelectivityVector
+  // rowsToFilterOn is used to filter out those rows.
+  void buildInMapSelectivityVector(
+      SelectivityVector& rowsToFilterOn,
+      BufferPtr flattenedInMap,
+      BufferPtr inMap,
+      vector_size_t inMapSize,
+      const SelectivityVector& rows,
+      const vector_size_t* decodedIndices) const {
+    // Flatten inMap buffer.
+    auto* mutableFlattedInMap = flattenedInMap->asMutable<uint64_t>();
+    bits::fillBits(mutableFlattedInMap, 0, inMapSize, false);
+    auto* mutableInMap = inMap ? inMap->asMutable<uint64_t>() : nullptr;
+    rows.applyToSelected([&](vector_size_t row) {
+      // If inMap is null, short circuit and set bit because key is present in
+      // all rows.
+      if (!inMap || bits::isBitSet(mutableInMap, decodedIndices[row])) {
+        bits::setBit(mutableFlattedInMap, decodedIndices[row]);
+      }
+    });
+
+    // Extract flattened inMap buffer values for next lambda call.
+    rowsToFilterOn.clearAll();
+    auto bits = rowsToFilterOn.asMutableRange().bits();
+    bits::orBits(bits, mutableFlattedInMap, 0, rowsToFilterOn.size());
+    rowsToFilterOn.updateBounds();
+  }
+
+  // Apply filter function to vector of encoding FlatMapVector. Because the
+  // entirety of the map values are stored in in a list of vectors (one vector
+  // per key), we will need to apply the filter function on each vector and
+  // associated inMap buffer. Additionally, we will have to reduce the number of
+  // distinct keys stored in the FlatMapVector if they key list changes.
+  void applyFlatMapVector(
+      DecodedVector& decodedMap,
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args,
       const TypePtr& outputType,
       exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    VELOX_CHECK_EQ(args.size(), 2);
-    exec::LocalDecodedVector mapDecoder(context, *args[0], rows);
-    auto& decodedMap = *mapDecoder.get();
+      VectorPtr& result) const {
+    // Current map and fields
+    const FlatMapVector& flatMap =
+        *(decodedMap.base())->template as<FlatMapVector>();
+    auto distinctKeys = flatMap.distinctKeys();
+    auto mapValues = flatMap.mapValues();
+    auto numRows = rows.size();
+    BufferPtr decodedIndices =
+        AlignedBuffer::allocate<vector_size_t>(numRows, flatMap.pool());
+    BufferPtr nulls = allocateNulls(numRows, flatMap.pool());
+    auto mutableIndices = decodedIndices->asMutable<vector_size_t>();
+    auto rawNulls = nulls->asMutable<uint64_t>();
+    for (int i = 0; i < decodedMap.size(); i++) {
+      mutableIndices[i] = decodedMap.indices()[i];
+      if (decodedMap.isNullAt(i)) {
+        bits::setNull(rawNulls, i, true);
+      }
+    }
+
+    // Result map fields
+    auto filteredKeysIndices = AlignedBuffer::allocate<vector_size_t>(
+        distinctKeys->size(), context.pool());
+    std::vector<VectorPtr> filteredMapValues;
+    std::vector<BufferPtr> filteredInMaps;
+    uint64_t* filteredInMap;
+    auto numDistinct = 0;
+    auto rawIndices = filteredKeysIndices->asMutable<vector_size_t>();
+
+    // Lambda function
+    auto iter = args[1]->asUnchecked<FunctionVector>()->iterator(&rows);
+    exec::LocalDecodedVector bitsDecoder(context);
+    SelectivityVector rowsToFilterOn(flatMap.size());
+    // Selectivity vector to help ignore filtering for key-value pairs
+    // identified by inMap buffer. Let's allocate here to avoid during each
+    // iteration.
+    auto flattenedInMap =
+        AlignedBuffer::allocate<bool>(flatMap.size(), context.pool(), 0);
+
+    // Apply lambda function to each map value vector and its associated key
+    // from our flat map vector. If the key is not filtered out, we will copy it
+    // to our result vector.
+    while (auto entry = iter.next()) {
+      for (int channel = 0; channel < mapValues.size(); ++channel) {
+        // Only apply lambda function to values that are in the map.
+        buildInMapSelectivityVector(
+            rowsToFilterOn,
+            flattenedInMap,
+            flatMap.inMaps()[channel],
+            flatMap.size(),
+            *entry.rows,
+            decodedMap.indices());
+
+        // Call lambda function and decode its output bit vector. We will
+        // use it to determine what will persist to the final result vector.
+        VectorPtr lambdaResultBits;
+        entry.callable->apply(
+            rowsToFilterOn,
+            nullptr,
+            nullptr,
+            &context,
+            {
+                BaseVector::wrapInConstant(
+                    flatMap.size(), channel, distinctKeys),
+                mapValues[channel],
+            },
+            decodedIndices,
+            &lambdaResultBits);
+        bitsDecoder.get()->decode(*lambdaResultBits);
+
+        bool isFilteredIn = false;
+        entry.rows->applyToSelected([&](vector_size_t row) {
+          row = decodedMap.indices()[row];
+          if (rowsToFilterOn.isValid(row) &&
+              !bitsDecoder.get()->isNullAt(row) &&
+              bitsDecoder.get()->valueAt<bool>(row)) {
+            // First time seeing this key; let's copy over its associated values
+            // vector and define a new filtered inMap buffer. Let's also note
+            // the index of this key for key filtering.
+            if (!isFilteredIn) {
+              filteredMapValues.push_back(
+                  BaseVector::copy(*mapValues[channel]));
+              filteredInMaps.push_back(
+                  AlignedBuffer::allocate<bool>(numRows, context.pool(), 0));
+              filteredInMap = filteredInMaps.back()->asMutable<uint64_t>();
+              rawIndices[numDistinct++] = channel;
+              isFilteredIn = true;
+            }
+            bits::setBit(filteredInMap, row);
+          }
+        });
+      }
+    }
+
+    // Resize filtered distinct keys indices in order to wrap in dictionary and
+    // create our result filtered flat map vector
+    filteredKeysIndices->setSize(numDistinct * sizeof(vector_size_t));
+    auto localResult = std::make_shared<FlatMapVector>(
+        context.pool(),
+        outputType,
+        flatMap.nulls(),
+        flatMap.size(),
+        BaseVector::wrapInDictionary(
+            BufferPtr(nullptr), filteredKeysIndices, numDistinct, distinctKeys),
+        std::move(filteredMapValues),
+        std::move(filteredInMaps));
 
-    auto flatMap = flattenMap(rows, args[0], decodedMap);
+    // Handle wrapped encoding if necessary
+    if (decodedMap.isIdentityMapping()) {
+      context.moveOrCopyResult(localResult, rows, result);
+    } else {
+      context.moveOrCopyResult(
+          BaseVector::wrapInDictionary(
+              std::move(nulls), decodedIndices, decodedMap.size(), localResult),
+          rows,
+          result);
+    }
+  }
 
-    VectorPtr keys = flatMap->mapKeys();
-    VectorPtr values = flatMap->mapValues();
+  // Applies filter function on traditional map vector.
+  void applyMapVector(
+      DecodedVector& decodedMap,
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const {
+    auto mapVector = flattenMap(rows, args[0], decodedMap);
+    VectorPtr keys = mapVector->mapKeys();
+    VectorPtr values = mapVector->mapValues();
     BufferPtr resultSizes;
     BufferPtr resultOffsets;
     BufferPtr selectedIndices;
     auto numSelected = doApply(
         rows,
-        flatMap,
+        mapVector,
         args[1],
         {keys, values},
         context,
@@ -220,9 +378,9 @@ class MapFilterFunction : public FilterFunctionBase {
                                            true /*flattenIfRedundant*/)
                                      : nullptr;
     // Set nulls for rows not present in 'rows'.
-    BufferPtr newNulls = addNullsForUnselectedRows(flatMap, rows);
+    BufferPtr newNulls = addNullsForUnselectedRows(mapVector, rows);
     auto localResult = std::make_shared<MapVector>(
-        flatMap->pool(),
+        mapVector->pool(),
         outputType,
         std::move(newNulls),
         rows.end(),
@@ -233,6 +391,35 @@ class MapFilterFunction : public FilterFunctionBase {
     context.moveOrCopyResult(localResult, rows, result);
   }
 
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    VELOX_CHECK_EQ(args.size(), 2);
+    exec::LocalDecodedVector mapDecoder(context, *args[0], rows);
+    auto& decodedMap = *mapDecoder.get();
+
+    // Flattening input maps will peel if possible, but may simply cast if the
+    // vector is an identify mapping.
+    switch (decodedMap.base()->encoding()) {
+      case VectorEncoding::Simple::FLAT_MAP: {
+        applyFlatMapVector(decodedMap, rows, args, outputType, context, result);
+        break;
+      }
+      case VectorEncoding::Simple::MAP: {
+        applyMapVector(decodedMap, rows, args, outputType, context, result);
+        break;
+      }
+      default:
+        VELOX_UNSUPPORTED(
+            "map_filter not supported for encoding: {}",
+            decodedMap.base()->encoding());
+    }
+  }
+
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // map(K,V), function(K,V,boolean) -> map(K,V)
     return {exec::FunctionSignatureBuilder()
diff --git a/velox/functions/prestosql/FromUtf8.cpp b/velox/functions/prestosql/FromUtf8.cpp
index 70d09643bfa6..8736d39e552e 100644
--- a/velox/functions/prestosql/FromUtf8.cpp
+++ b/velox/functions/prestosql/FromUtf8.cpp
@@ -43,7 +43,7 @@ class FromUtf8Function : public exec::VectorFunction {
     // 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;
+    StringView constantReplacementValue = kReplacementChar;
 
     if (constantReplacement) {
       if (args.size() > 1) {
@@ -146,24 +146,17 @@ class FromUtf8Function : public exec::VectorFunction {
   }
 
  private:
-  static const std::string kReplacementChar;
+  static const StringView kReplacementChar;
 
-  static std::string codePointToString(int64_t codePoint) {
-    std::string result;
-    result.resize(4);
-    stringImpl::codePointToString(result, codePoint);
-    return result;
-  }
-
-  std::string getReplacementCharacter(
+  StringView getReplacementCharacter(
       const TypePtr& type,
       DecodedVector& decoded,
       vector_size_t row) const {
     if (type->isBigint()) {
-      return codePointToString(decoded.valueAt<int64_t>(row));
+      return stringImpl::codePointToString(decoded.valueAt<int64_t>(row));
     }
 
-    auto replacement = decoded.valueAt<StringView>(row);
+    StringView replacement = decoded.valueAt<StringView>(row);
     if (!replacement.empty()) {
       int32_t codePoint;
       auto charLength = tryGetUtf8CharLength(
@@ -260,7 +253,7 @@ class FromUtf8Function : public exec::VectorFunction {
 
   void fixInvalidUtf8(
       StringView input,
-      const std::string& replacement,
+      const StringView& replacement,
       exec::StringWriter& fixedWriter) const {
     if (input.empty()) {
       fixedWriter.setEmpty();
@@ -290,8 +283,9 @@ class FromUtf8Function : public exec::VectorFunction {
 };
 
 // static
-const std::string FromUtf8Function::kReplacementChar =
-    codePointToString(0xFFFD);
+const StringView FromUtf8Function::kReplacementChar =
+    stringImpl::codePointToString(0xFFFD);
+
 } // namespace
 
 VELOX_DECLARE_VECTOR_FUNCTION(
diff --git a/velox/functions/prestosql/GeometryFunctions.h b/velox/functions/prestosql/GeometryFunctions.h
index 54da162f3048..c68669fa035a 100644
--- a/velox/functions/prestosql/GeometryFunctions.h
+++ b/velox/functions/prestosql/GeometryFunctions.h
@@ -17,24 +17,33 @@
 #pragma once
 
 #include <geos/geom/Coordinate.h>
+#include <geos/geom/CoordinateArraySequence.h>
+#include <geos/geom/Envelope.h>
+#include <geos/io/GeoJSON.h>
+#include <geos/io/GeoJSONReader.h>
+#include <geos/io/GeoJSONWriter.h>
 #include <geos/io/WKBReader.h>
 #include <geos/io/WKBWriter.h>
 #include <geos/io/WKTReader.h>
 #include <geos/io/WKTWriter.h>
+#include <geos/linearref/LengthIndexedLine.h>
+#include <geos/operation/distance/DistanceOp.h>
+#include <geos/simplify/TopologyPreservingSimplifier.h>
 #include <geos/util/AssertionFailedException.h>
 #include <geos/util/UnsupportedOperationException.h>
 #include <cmath>
 
 #include <velox/type/StringView.h>
+#include "velox/common/geospatial/GeometrySerde.h"
 #include "velox/functions/Macros.h"
-#include "velox/functions/prestosql/geospatial/GeometrySerde.h"
 #include "velox/functions/prestosql/geospatial/GeometryUtils.h"
+#include "velox/functions/prestosql/types/BingTileType.h"
 #include "velox/functions/prestosql/types/GeometryType.h"
+#include "velox/functions/prestosql/types/SphericalGeographyType.h"
+#include "velox/type/Variant.h"
 
 namespace facebook::velox::functions {
 
-// Constructors and Serde
-
 template <typename T>
 struct StGeometryFromTextFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -45,10 +54,10 @@ struct StGeometryFromTextFunction {
     GEOS_TRY(
         {
           geos::io::WKTReader reader;
-          geosGeometry = reader.read(wkt);
+          geosGeometry = reader.read(std::string(wkt));
         },
         "Failed to parse WKT");
-    result = geospatial::serializeGeometry(*geosGeometry);
+    common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
     return Status::OK();
   }
 };
@@ -68,7 +77,7 @@ struct StGeomFromBinaryFunction {
               reinterpret_cast<const uint8_t*>(wkb.data()), wkb.size());
         },
         "Failed to parse WKB");
-    result = geospatial::serializeGeometry(*geosGeometry);
+    common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
     return Status::OK();
   }
 };
@@ -80,7 +89,28 @@ struct StAsTextFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Varchar>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::deserializeGeometry(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    GEOS_TRY(
+        {
+          geos::io::WKTWriter writer;
+          writer.setTrim(true);
+          result = writer.write(geosGeometry.get());
+        },
+        "Failed to write WKT");
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct SphericalAsTextFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Varchar>& result,
+      const arg_type<SphericalGeography>& geography) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geography);
 
     GEOS_TRY(
         {
@@ -100,7 +130,7 @@ struct StAsBinaryFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<Varbinary>& result, const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::deserializeGeometry(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
     GEOS_TRY(
         {
           geos::io::WKBWriter writer;
@@ -115,6 +145,10 @@ struct StAsBinaryFunction {
 
 template <typename T>
 struct StPointFunction {
+  StPointFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE Status call(
@@ -122,21 +156,46 @@ struct StPointFunction {
       const arg_type<double>& x,
       const arg_type<double>& y) {
     if (!std::isfinite(x) || !std::isfinite(y)) {
-      return Status::UserError(fmt::format(
-          "ST_Point requires finite coordinates, got x={} y={}", x, y));
+      return Status::UserError(
+          fmt::format(
+              "ST_Point requires finite coordinates, got x={} y={}", x, y));
     }
     GEOS_TRY(
         {
-          geos::geom::GeometryFactory::Ptr factory =
-              geos::geom::GeometryFactory::create();
-          geos::geom::Point* point =
-              factory->createPoint(geos::geom::Coordinate(x, y));
-          result = geospatial::serializeGeometry(*point);
-          factory->destroyGeometry(point);
+          auto point = std::unique_ptr<geos::geom::Point>(
+              factory_->createPoint(geos::geom::Coordinate(x, y)));
+          common::geospatial::GeometrySerializer::serialize(*point, result);
         },
         "Failed to create point geometry");
     return Status::OK();
   }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StPolygonFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Geometry>& result, const arg_type<Varchar>& wkt) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry;
+    GEOS_TRY(
+        {
+          geos::io::WKTReader reader;
+          geosGeometry = reader.read(std::string(wkt));
+        },
+        "Failed to parse WKT");
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_POLYGON},
+        "ST_Polygon");
+
+    common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+
+    return validate;
+  }
 };
 
 // Predicates
@@ -151,11 +210,13 @@ struct StRelateFunction {
       const arg_type<Geometry>& rightGeometry,
       const arg_type<Varchar>& relation) {
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->relate(*rightGeosGeometry, relation);
-             , "Failed to check geometry relation");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result =
+            leftGeosGeometry->relate(*rightGeosGeometry, std::string(relation));
+        , "Failed to check geometry relation");
 
     return Status::OK();
   }
@@ -171,11 +232,12 @@ struct StContainsFunction {
       const arg_type<Geometry>& rightGeometry) {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->contains(&*rightGeosGeometry);
-             , "Failed to check geometry contains");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result = leftGeosGeometry->contains(&*rightGeosGeometry);
+        , "Failed to check geometry contains");
 
     return Status::OK();
   }
@@ -191,11 +253,12 @@ struct StCrossesFunction {
       const arg_type<Geometry>& rightGeometry) {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->crosses(&*rightGeosGeometry);
-             , "Failed to check geometry crosses");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result = leftGeosGeometry->crosses(&*rightGeosGeometry);
+        , "Failed to check geometry crosses");
 
     return Status::OK();
   }
@@ -211,11 +274,12 @@ struct StDisjointFunction {
       const arg_type<Geometry>& rightGeometry) {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->disjoint(&*rightGeosGeometry);
-             , "Failed to check geometry disjoint");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result = leftGeosGeometry->disjoint(&*rightGeosGeometry);
+        , "Failed to check geometry disjoint");
 
     return Status::OK();
   }
@@ -231,11 +295,12 @@ struct StEqualsFunction {
       const arg_type<Geometry>& rightGeometry) {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->equals(&*rightGeosGeometry);
-             , "Failed to check geometry equals");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result = leftGeosGeometry->equals(&*rightGeosGeometry);
+        , "Failed to check geometry equals");
 
     return Status::OK();
   }
@@ -251,11 +316,12 @@ struct StIntersectsFunction {
       const arg_type<Geometry>& rightGeometry) {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->intersects(&*rightGeosGeometry);
-             , "Failed to check geometry intersects");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result = leftGeosGeometry->intersects(&*rightGeosGeometry);
+        , "Failed to check geometry intersects");
 
     return Status::OK();
   }
@@ -271,11 +337,12 @@ struct StOverlapsFunction {
       const arg_type<Geometry>& rightGeometry) {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->overlaps(&*rightGeosGeometry);
-             , "Failed to check geometry overlaps");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result = leftGeosGeometry->overlaps(&*rightGeosGeometry);
+        , "Failed to check geometry overlaps");
 
     return Status::OK();
   }
@@ -291,11 +358,12 @@ struct StTouchesFunction {
       const arg_type<Geometry>& rightGeometry) {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->touches(&*rightGeosGeometry);
-             , "Failed to check geometry touches");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result = leftGeosGeometry->touches(&*rightGeosGeometry);
+        , "Failed to check geometry touches");
 
     return Status::OK();
   }
@@ -311,11 +379,12 @@ struct StWithinFunction {
       const arg_type<Geometry>& rightGeometry) {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
-    GEOS_TRY(result = leftGeosGeometry->within(&*rightGeosGeometry);
-             , "Failed to check geometry within");
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+    GEOS_TRY(
+        result = leftGeosGeometry->within(&*rightGeosGeometry);
+        , "Failed to check geometry within");
 
     return Status::OK();
   }
@@ -334,15 +403,36 @@ struct StDifferenceFunction {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     // if envelopes are disjoint
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+
+    std::unique_ptr<geos::geom::Geometry> outputGeometry;
+    GEOS_TRY(
+        outputGeometry = leftGeosGeometry->difference(&*rightGeosGeometry);
+        , "Failed to compute geometry difference");
+
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct StBoundaryFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Geometry>& result, const arg_type<Geometry>& input) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(input);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
-    GEOS_TRY(outputGeometry = leftGeosGeometry->difference(&*rightGeosGeometry);
-             , "Failed to compute geometry difference");
 
-    result = geospatial::serializeGeometry(*outputGeometry);
+    GEOS_TRY(
+        common::geospatial::GeometrySerializer::serialize(
+            *geosGeometry->getBoundary(), result);
+        , "Failed to compute geometry boundary");
+
     return Status::OK();
   }
 };
@@ -358,16 +448,16 @@ struct StIntersectionFunction {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     // if envelopes are disjoint
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
     GEOS_TRY(
         outputGeometry = leftGeosGeometry->intersection(&*rightGeosGeometry);
         , "Failed to compute geometry intersection");
 
-    result = geospatial::serializeGeometry(*outputGeometry);
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
     return Status::OK();
   }
 };
@@ -383,16 +473,16 @@ struct StSymDifferenceFunction {
     // TODO: When #12771 is merged, check envelopes and short-circuit
     // if envelopes are disjoint
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
     GEOS_TRY(
         outputGeometry = leftGeosGeometry->symDifference(&*rightGeosGeometry);
         , "Failed to compute geometry symdifference");
 
-    result = geospatial::serializeGeometry(*outputGeometry);
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
     return Status::OK();
   }
 };
@@ -408,21 +498,75 @@ struct StUnionFunction {
     // TODO: When #12771 is merged, check envelopes and short-circuit if
     // one/both are empty
     std::unique_ptr<geos::geom::Geometry> leftGeosGeometry =
-        geospatial::deserializeGeometry(leftGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
     std::unique_ptr<geos::geom::Geometry> rightGeosGeometry =
-        geospatial::deserializeGeometry(rightGeometry);
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
-    GEOS_TRY(outputGeometry = leftGeosGeometry->Union(&*rightGeosGeometry);
-             , "Failed to compute geometry union");
+    GEOS_TRY(
+        outputGeometry = leftGeosGeometry->Union(&*rightGeosGeometry);
+        , "Failed to compute geometry union");
 
-    result = geospatial::serializeGeometry(*outputGeometry);
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
     return Status::OK();
   }
 };
 
 // Accessors
 
+template <typename T>
+struct StIsValidFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<bool>& result, const arg_type<Geometry>& input) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+
+    GEOS_TRY(
+        result = geosGeometry->isValid();, "Failed to check geometry isValid");
+
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct StIsSimpleFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<bool>& result, const arg_type<Geometry>& input) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+
+    GEOS_TRY(
+        result = geosGeometry->isSimple();
+        , "Failed to check geometry isSimple");
+
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct GeometryInvalidReasonFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Geometry>& input) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+
+    std::optional<std::string> messageOpt =
+        geospatial::geometryInvalidReason(geosGeometry.get());
+
+    if (messageOpt.has_value()) {
+      result = messageOpt.value();
+    }
+    return messageOpt.has_value();
+  }
+};
+
 template <typename T>
 struct StAreaFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -430,13 +574,61 @@ struct StAreaFunction {
   FOLLY_ALWAYS_INLINE Status
   call(out_type<double>& result, const arg_type<Geometry>& input) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::deserializeGeometry(input);
+        common::geospatial::GeometryDeserializer::deserialize(input);
 
     std::unique_ptr<geos::geom::Geometry> outputGeometry;
 
-    GEOS_TRY(result = geosGeometry->getArea();
-             , "Failed to compute geometry area");
+    GEOS_TRY(
+        result = geosGeometry->getArea();, "Failed to compute geometry area");
+
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct StCentroidFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Geometry>& result, const arg_type<Geometry>& input) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+
+    auto validate = facebook::velox::functions::geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_POINT,
+         geos::geom::GeometryTypeId::GEOS_MULTIPOINT,
+         geos::geom::GeometryTypeId::GEOS_LINESTRING,
+         geos::geom::GeometryTypeId::GEOS_MULTILINESTRING,
+         geos::geom::GeometryTypeId::GEOS_POLYGON,
+         geos::geom::GeometryTypeId::GEOS_MULTIPOLYGON},
+        "ST_Centroid");
+
+    if (!validate.ok()) {
+      return validate;
+    }
+
+    geos::geom::GeometryTypeId type = geosGeometry->getGeometryTypeId();
+    if (type == geos::geom::GeometryTypeId::GEOS_POINT) {
+      result = input;
+      return Status::OK();
+    }
+
+    if (geosGeometry->getNumPoints() == 0) {
+      GEOS_TRY(
+          {
+            geos::geom::GeometryFactory::Ptr factory =
+                geos::geom::GeometryFactory::create();
+            std::unique_ptr<geos::geom::Point> point = factory->createPoint();
+            common::geospatial::GeometrySerializer::serialize(*point, result);
+            factory->destroyGeometry(point.release());
+          },
+          "Failed to create point geometry");
+      return Status::OK();
+    }
 
+    common::geospatial::GeometrySerializer::serialize(
+        *(geosGeometry->getCentroid()), result);
     return Status::OK();
   }
 };
@@ -449,12 +641,13 @@ struct StXFunction {
       out_type<double>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::deserializeGeometry(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
     if (geosGeometry->getGeometryTypeId() !=
         geos::geom::GeometryTypeId::GEOS_POINT) {
-      throw Status::UserError(fmt::format(
-          "ST_X requires a Point geometry, found {}",
-          geosGeometry->getGeometryType()));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "ST_X requires a Point geometry, found {}",
+              geosGeometry->getGeometryType()));
     }
     if (geosGeometry->isEmpty()) {
       return false;
@@ -473,12 +666,13 @@ struct StYFunction {
       out_type<double>& result,
       const arg_type<Geometry>& geometry) {
     std::unique_ptr<geos::geom::Geometry> geosGeometry =
-        geospatial::deserializeGeometry(geometry);
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
     if (geosGeometry->getGeometryTypeId() !=
         geos::geom::GeometryTypeId::GEOS_POINT) {
-      throw Status::UserError(fmt::format(
-          "ST_Y requires a Point geometry, found {}",
-          geosGeometry->getGeometryType()));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "ST_Y requires a Point geometry, found {}",
+              geosGeometry->getGeometryType()));
     }
     if (geosGeometry->isEmpty()) {
       return false;
@@ -489,4 +683,1588 @@ struct StYFunction {
   }
 };
 
+template <typename T>
+struct StXMinFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  bool call(out_type<double>& result, const arg_type<Geometry>& geometry) {
+    const std::unique_ptr<geos::geom::Envelope> env =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+    if (env->isNull()) {
+      return false;
+    }
+    result = env->getMinX();
+    return true;
+  }
+};
+
+template <typename T>
+struct StYMinFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  bool call(out_type<double>& result, const arg_type<Geometry>& geometry) {
+    const std::unique_ptr<geos::geom::Envelope> env =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+    if (env->isNull()) {
+      return false;
+    }
+    result = env->getMinY();
+    return true;
+  }
+};
+
+template <typename T>
+struct StXMaxFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  bool call(out_type<double>& result, const arg_type<Geometry>& geometry) {
+    const std::unique_ptr<geos::geom::Envelope> env =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+    if (env->isNull()) {
+      return false;
+    }
+    result = env->getMaxX();
+    return true;
+  }
+};
+
+template <typename T>
+struct StYMaxFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  bool call(out_type<double>& result, const arg_type<Geometry>& geometry) {
+    const std::unique_ptr<geos::geom::Envelope> env =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+    if (env->isNull()) {
+      return false;
+    }
+    result = env->getMaxY();
+    return true;
+  }
+};
+
+template <typename T>
+struct SimplifyGeometryFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<double>& tolerance) {
+    if (!std::isfinite(tolerance) || tolerance < 0) {
+      return Status::UserError(
+          "simplification tolerance must be a non-negative finite number");
+    }
+    if (tolerance == 0) {
+      result = geometry;
+      return Status::OK();
+    }
+
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    if (geosGeometry->isEmpty()) {
+      result = geometry;
+      return Status::OK();
+    }
+
+    std::unique_ptr<geos::geom::Geometry> outputGeometry;
+    GEOS_TRY(
+        {
+          outputGeometry =
+              geos::simplify::TopologyPreservingSimplifier::simplify(
+                  geosGeometry.get(), tolerance);
+        },
+        "Failed to compute simplified geometry");
+
+    common::geospatial::GeometrySerializer::serialize(*outputGeometry, result);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct StGeometryTypeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Varchar>& result, const arg_type<Geometry>& input) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+
+    if (geosGeometry->getGeometryTypeId() ==
+        geos::geom::GeometryTypeId::GEOS_GEOMETRYCOLLECTION) {
+      result = "ST_GeomCollection";
+    } else {
+      result = "ST_" + geosGeometry->getGeometryType();
+    }
+
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct StDistanceFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<Geometry>& geometry1,
+      const arg_type<Geometry>& geometry2) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry1 =
+        common::geospatial::GeometryDeserializer::deserialize(geometry1);
+    std::unique_ptr<geos::geom::Geometry> geosGeometry2 =
+        common::geospatial::GeometryDeserializer::deserialize(geometry2);
+
+    if (geosGeometry1->getSRID() != geosGeometry2->getSRID()) {
+      VELOX_USER_FAIL(
+          fmt::format(
+              "Input geometries must have the same spatial reference, found {} and {}",
+              geosGeometry1->getSRID(),
+              geosGeometry2->getSRID()));
+    }
+
+    if (geosGeometry1->isEmpty() || geosGeometry2->isEmpty()) {
+      return false;
+    }
+
+    GEOS_RETHROW(
+        result = geosGeometry1->distance(geosGeometry2.get());
+        , "Failed to calculate geometry distance");
+
+    return true;
+  }
+};
+
+template <typename T>
+struct StIsClosedFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<bool>& result, const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING,
+         geos::geom::GeometryTypeId::GEOS_MULTILINESTRING},
+        "ST_IsClosed");
+
+    if (!validate.ok()) {
+      return validate;
+    };
+
+    if (geos::geom::LineString* lineString =
+            dynamic_cast<geos::geom::LineString*>(geosGeometry.get())) {
+      result = lineString->isClosed();
+      return validate;
+    }
+    if (geos::geom::MultiLineString* multiLineString =
+            dynamic_cast<geos::geom::MultiLineString*>(geosGeometry.get())) {
+      result = multiLineString->isClosed();
+      return validate;
+    }
+
+    VELOX_FAIL(
+        "Validation passed but type not recognized as LineString or MultiLineString");
+  }
+};
+
+template <typename T>
+struct StIsEmptyFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<bool>& result, const arg_type<Geometry>& geometry) {
+    GEOS_TRY(
+        {
+          const std::unique_ptr<geos::geom::Envelope> env =
+              common::geospatial::GeometryDeserializer::deserializeEnvelope(
+                  geometry);
+          result = env->isNull();
+        },
+        "Failed to get envelope from geometry");
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct StIsRingFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<bool>& result, const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING},
+        "ST_IsRing");
+
+    if (!validate.ok()) {
+      return validate;
+    };
+
+    if (geos::geom::LineString* lineString =
+            dynamic_cast<geos::geom::LineString*>(geosGeometry.get())) {
+      result = lineString->isRing();
+      return validate;
+    }
+
+    VELOX_FAIL("Validation passed but type not recognized as LineString");
+  }
+};
+
+template <typename T>
+struct StLengthFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<double>& result, const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING,
+         geos::geom::GeometryTypeId::GEOS_MULTILINESTRING},
+        "ST_Length");
+
+    if (!validate.ok()) {
+      return validate;
+    };
+
+    if (geos::geom::LineString* lineString =
+            dynamic_cast<geos::geom::LineString*>(geosGeometry.get())) {
+      result = lineString->getLength();
+      return validate;
+    }
+    if (geos::geom::MultiLineString* multiLineString =
+            dynamic_cast<geos::geom::MultiLineString*>(geosGeometry.get())) {
+      result = multiLineString->getLength();
+      return validate;
+    }
+
+    VELOX_FAIL(
+        "Validation passed but type not recognized as LineString or MultiLineString");
+  }
+};
+
+template <typename T>
+struct StPointNFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<int32_t>& index) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING},
+        "ST_PointN");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    };
+
+    if (geos::geom::LineString* lineString =
+            dynamic_cast<geos::geom::LineString*>(geosGeometry.get())) {
+      if (index < 1 || index > lineString->getNumPoints()) {
+        return false;
+      }
+      common::geospatial::GeometrySerializer::serialize(
+          *lineString->getPointN(index - 1), result);
+      return true;
+    }
+
+    VELOX_FAIL(
+        "Validation passed but type not recognized as LineString or MultiLineString");
+  }
+};
+
+template <typename T>
+struct StStartPointFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING},
+        "ST_StartPoint");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+    geos::geom::LineString* lineString =
+        static_cast<geos::geom::LineString*>(geosGeometry.get());
+    common::geospatial::GeometrySerializer::serialize(
+        *(lineString->getStartPoint()), result);
+
+    return true;
+  }
+};
+
+template <typename T>
+struct StEndPointFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING},
+        "ST_EndPoint");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+    geos::geom::LineString* lineString =
+        static_cast<geos::geom::LineString*>(geosGeometry.get());
+    common::geospatial::GeometrySerializer::serialize(
+        *lineString->getEndPoint(), result);
+
+    return true;
+  }
+};
+
+template <typename T>
+struct StGeometryNFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<int32_t>& index) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+
+    if (!geospatial::isMultiType(*geosGeometry)) {
+      if (index == 1) {
+        common::geospatial::GeometrySerializer::serialize(
+            *geosGeometry, result);
+        return true;
+      }
+      return false;
+    }
+
+    if (geos::geom::GeometryCollection* geomCollection =
+            dynamic_cast<geos::geom::GeometryCollection*>(geosGeometry.get())) {
+      if (index < 1 || index > geomCollection->getNumGeometries()) {
+        return false;
+      }
+      common::geospatial::GeometrySerializer::serialize(
+          *(geosGeometry->getGeometryN(index - 1)), result);
+      return true;
+    }
+
+    return false;
+  }
+};
+
+template <typename T>
+struct StInteriorRingNFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<int32_t>& index) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_POLYGON},
+        "ST_InteriorRingN");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    geos::geom::Polygon* polygon =
+        static_cast<geos::geom::Polygon*>(geosGeometry.get());
+    if (index < 1 || index > polygon->getNumInteriorRing()) {
+      return false;
+    }
+    common::geospatial::GeometrySerializer::serialize(
+        *(polygon->getInteriorRingN(index - 1)), result);
+    return true;
+  }
+};
+
+template <typename T>
+struct StNumGeometriesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<int32_t>& result, const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    if (geosGeometry->isEmpty()) {
+      result = 0;
+    } else {
+      uint64_t numGeometries = geosGeometry->getNumGeometries();
+      if (numGeometries > std::numeric_limits<int32_t>::max()) {
+        return Status::UserError(
+            "Number of geometries exceeds the maximum value of int32");
+      }
+      result = static_cast<int32_t>(numGeometries);
+    }
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct StNumInteriorRingFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<int64_t>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_POLYGON},
+        "ST_NumInteriorRing");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+
+    geos::geom::Polygon* polygon =
+        static_cast<geos::geom::Polygon*>(geosGeometry.get());
+    uint64_t numInteriorRings = polygon->getNumInteriorRing();
+    if (numInteriorRings > std::numeric_limits<int32_t>::max()) {
+      VELOX_USER_FAIL(
+          "Number of interior rings exceeds the maximum value of int32");
+    }
+    result = static_cast<int64_t>(numInteriorRings);
+    return true;
+  }
+};
+
+template <typename T>
+struct StConvexHullFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Geometry>& result, const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    if (geosGeometry->isEmpty() ||
+        geosGeometry->getGeometryTypeId() ==
+            geos::geom::GeometryTypeId::GEOS_POINT) {
+      result = geometry;
+    } else {
+      common::geospatial::GeometrySerializer::serialize(
+          *(geosGeometry->convexHull()), result);
+    }
+    return Status::OK();
+  }
+};
+class StCoordDimFunction : public facebook::velox::exec::VectorFunction {
+ public:
+  void apply(
+      const facebook::velox::SelectivityVector& rows,
+      std::vector<facebook::velox::VectorPtr>& /*args*/,
+      const std::shared_ptr<const facebook::velox::Type>& outputType,
+      facebook::velox::exec::EvalCtx& context,
+      facebook::velox::VectorPtr& result) const override {
+    // Create a constant vector of value 2, with size equal to the number of
+    // rows
+    result = facebook::velox::BaseVector::createConstant(
+        outputType, static_cast<int8_t>(2), rows.size(), context.pool());
+  }
+  static std::vector<std::shared_ptr<facebook::velox::exec::FunctionSignature>>
+  signatures() {
+    return {facebook::velox::exec::FunctionSignatureBuilder()
+                .returnType("tinyint")
+                .argumentType("geometry")
+                .build()};
+  }
+};
+
+template <typename T>
+struct StDimensionFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<int8_t>& result, const arg_type<Geometry>& geometry) {
+    result = common::geospatial::GeometryDeserializer::deserialize(geometry)
+                 ->getDimension();
+
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct StExteriorRingFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_POLYGON},
+        "ST_ExteriorRing");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+
+    geos::geom::Polygon* polygon =
+        dynamic_cast<geos::geom::Polygon*>(geosGeometry.get());
+
+    VELOX_CHECK_NOT_NULL(
+        polygon, "Validation passed but type not recognized as Polygon");
+
+    common::geospatial::GeometrySerializer::serialize(
+        *(polygon->getExteriorRing()), result);
+
+    return true;
+  }
+};
+
+template <typename T>
+struct StEnvelopeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  StEnvelopeFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Geometry>& result, const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Envelope> env =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+
+    common::geospatial::GeometrySerializer::serializeEnvelope(*env, result);
+
+    return Status::OK();
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StBufferFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<double>& distance) {
+    if (distance < 0) {
+      VELOX_USER_FAIL(
+          fmt::format(
+              "Provided distance must not be negative. Provided distance: {}",
+              distance));
+    }
+    if (distance == 0) {
+      result = geometry;
+      return true;
+    }
+
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+    common::geospatial::GeometrySerializer::serialize(
+        *(geosGeometry->buffer(distance)), result);
+    return true;
+  }
+};
+
+template <typename T>
+struct StPointsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Array<Geometry>>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+
+    auto numPoints = geosGeometry->getNumPoints();
+    result.reserve(static_cast<vector_size_t>(numPoints));
+
+    writePoints(geosGeometry.get(), result);
+    return true;
+  }
+
+ private:
+  void writePoints(
+      const geos::geom::Geometry* geosGeometry,
+      out_type<Array<Geometry>>& result) {
+    auto geometryType = geosGeometry->getGeometryTypeId();
+
+    if (geometryType == geos::geom::GeometryTypeId::GEOS_POINT) {
+      common::geospatial::GeometrySerializer::serialize(
+          *geosGeometry, result.add_item());
+    } else if (
+        geometryType == geos::geom::GeometryTypeId::GEOS_GEOMETRYCOLLECTION) {
+      auto geometryCollection =
+          static_cast<const geos::geom::GeometryCollection*>(geosGeometry);
+      for (int i = 0; i < geometryCollection->getNumGeometries(); i++) {
+        auto entry = geometryCollection->getGeometryN(i);
+        writePoints(entry, result);
+      }
+    } else {
+      auto geometryFactory = geosGeometry->getFactory();
+      auto vertices = geosGeometry->getCoordinates();
+      auto vertexCount = vertices->getSize();
+      for (auto i = 0; i < vertexCount; i++) {
+        const geos::geom::Coordinate& coordinate = vertices->getAt(i);
+        auto point = std::unique_ptr<geos::geom::Point>(
+            geometryFactory->createPoint(coordinate));
+        common::geospatial::GeometrySerializer::serialize(
+            *point, result.add_item());
+      }
+    }
+  }
+};
+
+template <typename T>
+struct StEnvelopeAsPtsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  StEnvelopeAsPtsFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Array<Geometry>>& result,
+      const arg_type<Geometry>& geometry) {
+    auto envelope =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+
+    if (envelope->isNull()) {
+      return false;
+    }
+
+    auto lowerLeft = std::unique_ptr<geos::geom::Point>(factory_->createPoint(
+        geos::geom::Coordinate(envelope->getMinX(), envelope->getMinY())));
+
+    auto upperRight = std::unique_ptr<geos::geom::Point>(factory_->createPoint(
+        geos::geom::Coordinate(envelope->getMaxX(), envelope->getMaxY())));
+
+    common::geospatial::GeometrySerializer::serialize(
+        *lowerLeft, result.add_item());
+    common::geospatial::GeometrySerializer::serialize(
+        *upperRight, result.add_item());
+
+    return true;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StNumPointsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int64_t>& result,
+      const arg_type<Geometry>& geometry) {
+    auto geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    result = pointCount(*geosGeometry);
+  }
+
+ private:
+  int32_t pointCount(const geos::geom::Geometry& geometry) {
+    if (geometry.isEmpty()) {
+      return 0;
+    }
+    if (geometry.getGeometryTypeId() ==
+        geos::geom::GeometryTypeId::GEOS_POINT) {
+      return 1;
+    }
+    if (geometry.getGeometryTypeId() ==
+        geos::geom::GeometryTypeId::GEOS_LINESTRING) {
+      return static_cast<int32_t>(geometry.getNumPoints());
+    }
+    if (geospatial::isMultiType(geometry)) {
+      auto numGeometries = geometry.getNumGeometries();
+      auto multiTypePointCount = 0;
+      for (int i = 0; i < numGeometries; i++) {
+        auto entry = geometry.getGeometryN(i);
+        multiTypePointCount += pointCount(*entry);
+      }
+      return multiTypePointCount;
+    }
+    if (geometry.getGeometryTypeId() ==
+        geos::geom::GeometryTypeId::GEOS_POLYGON) {
+      auto polygon = static_cast<const geos::geom::Polygon*>(&geometry);
+      // Subtract 1 to remove closing point, since we don't count the closing
+      // point in Java.
+      auto polygonPointCount = polygon->getExteriorRing()->getNumPoints() - 1;
+      for (int i = 0; i < polygon->getNumInteriorRing(); i++) {
+        auto interiorRing = polygon->getInteriorRingN(i);
+        polygonPointCount += interiorRing->getNumPoints() - 1;
+      }
+      return static_cast<int32_t>(polygonPointCount);
+    }
+    VELOX_FAIL(
+        fmt::format(
+            "Unexpected failure in ST_NumPoints: geometry type {}",
+            geometry.getGeometryType()));
+  }
+};
+
+template <typename T>
+struct GeometryNearestPointsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  GeometryNearestPointsFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Array<Geometry>>& result,
+      const arg_type<Geometry>& leftGeometry,
+      const arg_type<Geometry>& rightGeometry) {
+    auto left =
+        common::geospatial::GeometryDeserializer::deserialize(leftGeometry);
+    auto right =
+        common::geospatial::GeometryDeserializer::deserialize(rightGeometry);
+
+    if (left->isEmpty() || right->isEmpty()) {
+      return false;
+    }
+
+    GEOS_RETHROW(
+        {
+          std::unique_ptr<geos::geom::CoordinateSequence> nearestCoordinates =
+              geos::operation::distance::DistanceOp::nearestPoints(
+                  left.get(), right.get());
+
+          auto pointA =
+              std::unique_ptr<geos::geom::Point>(factory_->createPoint(
+                  geos::geom::Coordinate(nearestCoordinates->getAt(0))));
+          auto pointB =
+              std::unique_ptr<geos::geom::Point>(factory_->createPoint(
+                  geos::geom::Coordinate(nearestCoordinates->getAt(1))));
+
+          result.reserve(2);
+          common::geospatial::GeometrySerializer::serialize(
+              *pointA, result.add_item());
+          common::geospatial::GeometrySerializer::serialize(
+              *pointB, result.add_item());
+        },
+        "Failed to compute nearest points between geometries");
+
+    return true;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct LineLocatePointFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<Geometry>& inputLine,
+      const arg_type<Geometry>& inputPoint) {
+    auto line =
+        common::geospatial::GeometryDeserializer::deserialize(inputLine);
+    auto point =
+        common::geospatial::GeometryDeserializer::deserialize(inputPoint);
+
+    if (line->isEmpty() || point->isEmpty()) {
+      return false;
+    }
+
+    auto lineType = line->getGeometryTypeId();
+    if (lineType != geos::geom::GeometryTypeId::GEOS_LINESTRING &&
+        lineType != geos::geom::GeometryTypeId::GEOS_MULTILINESTRING) {
+      VELOX_USER_FAIL(
+          fmt::format(
+              "First argument to line_locate_point must be a LineString or a MultiLineString. Got: {}",
+              line->getGeometryType()));
+    }
+
+    auto pointType = point->getGeometryTypeId();
+    if (pointType != geos::geom::GeometryTypeId::GEOS_POINT) {
+      VELOX_USER_FAIL(
+          fmt::format(
+              "Second argument to line_locate_point must be a Point. Got: {}",
+              point->getGeometryType()));
+    }
+
+    result = geos::linearref::LengthIndexedLine(line.get())
+                 .indexOf(*(point->getCoordinate())) /
+        line->getLength();
+
+    return true;
+  }
+};
+
+template <typename T>
+struct LineInterpolatePointFunction {
+  LineInterpolatePointFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& inputLine,
+      const arg_type<double>& fraction) {
+    if (!(0.0 <= fraction && fraction <= 1.0)) {
+      return Status::UserError(
+          fmt::format(
+              "line_interpolate_point: Fraction must be between 0 and 1, but is {}",
+              fraction));
+    }
+    auto line =
+        common::geospatial::GeometryDeserializer::deserialize(inputLine);
+    Status validate = Status::OK();
+    validate = geospatial::validateType(
+        *line,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING},
+        "line_interpolate_point");
+
+    if (!validate.ok()) {
+      return validate;
+    }
+
+    if (line->isEmpty()) {
+      common::geospatial::GeometrySerializer::serialize(
+          *(factory_->createPoint()), result);
+    }
+
+    geos::geom::Coordinate coordinate =
+        geos::linearref::LengthIndexedLine(line.get())
+            .extractPoint(fraction * line->getLength());
+
+    auto resultPoint =
+        std::unique_ptr<geos::geom::Point>(factory_->createPoint(coordinate));
+    common::geospatial::GeometrySerializer::serialize(*resultPoint, result);
+
+    return validate;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StInteriorRingsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Array<Geometry>>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_POLYGON},
+        "ST_InteriorRings");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+
+    geos::geom::Polygon* polygon =
+        dynamic_cast<geos::geom::Polygon*>(geosGeometry.get());
+    VELOX_CHECK_NOT_NULL(
+        polygon, "Validation passed but type not recognized as Polygon");
+
+    auto numInteriorRings = polygon->getNumInteriorRing();
+    result.reserve(static_cast<int32_t>(numInteriorRings));
+
+    for (int i = 0; i < numInteriorRings; i++) {
+      common::geospatial::GeometrySerializer::serialize(
+          *(polygon->getInteriorRingN(i)), result.add_item());
+    }
+
+    return true;
+  }
+};
+
+template <typename T>
+struct StGeometriesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Array<Geometry>>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    if (geosGeometry->isEmpty()) {
+      return false;
+    }
+
+    if (!geospatial::isMultiType(*geosGeometry)) {
+      result.reserve(1);
+      common::geospatial::GeometrySerializer::serialize(
+          *(geosGeometry), result.add_item());
+      return true;
+    }
+
+    geos::geom::GeometryCollection* geomCollection =
+        dynamic_cast<geos::geom::GeometryCollection*>(geosGeometry.get());
+
+    VELOX_CHECK_NOT_NULL(
+        geomCollection,
+        "Failure in ST_Geometries: geometry should be multi type but cast to GeometryCollection failed");
+
+    int32_t numGeometries =
+        static_cast<int32_t>(geomCollection->getNumGeometries());
+    result.reserve(numGeometries);
+
+    for (int i = 0; i < numGeometries; i++) {
+      common::geospatial::GeometrySerializer::serialize(
+          *(geomCollection->getGeometryN(i)), result.add_item());
+    }
+
+    return true;
+  }
+};
+
+template <typename T>
+struct FlattenGeometryCollectionsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Array<Geometry>>& result, const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    geospatial::GeometryCollectionIterator it(geosGeometry.get());
+    while (it.hasNext()) {
+      common::geospatial::GeometrySerializer::serialize(
+          *(it.next()), result.add_item());
+    }
+
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct ExpandEnvelopeFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  ExpandEnvelopeFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Geometry>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<double>& distance) {
+    if (std::isnan(distance)) {
+      return Status::UserError("Distance must be a non-NaN number");
+    }
+    if (distance < 0) {
+      return Status::UserError("Distance must be a non-negative number");
+    }
+    if (distance == std::numeric_limits<double>::infinity()) {
+      common::geospatial::GeometrySerializer::serialize(
+          *factory_->createPolygon(), result);
+      return Status::OK();
+    }
+
+    const std::unique_ptr<geos::geom::Envelope> envelope =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+    if (envelope->isNull()) {
+      common::geospatial::GeometrySerializer::serializeEnvelope(
+          *envelope, result);
+      return Status::OK();
+    }
+
+    envelope->expandBy(distance);
+    common::geospatial::GeometrySerializer::serializeEnvelope(
+        *envelope, result);
+
+    return Status::OK();
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct BingTilePolygonFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Geometry>& result,
+      const arg_type<BingTile>& tile) {
+    auto x = BingTileType::bingTileX(tile);
+    auto y = BingTileType::bingTileY(tile);
+    auto zoom = BingTileType::bingTileZoom(tile);
+
+    double minX = BingTileType::tileXToLongitude(x, zoom);
+    double maxX = BingTileType::tileXToLongitude(x + 1, zoom);
+    double minY = BingTileType::tileYToLatitude(y, zoom);
+    double maxY = BingTileType::tileYToLatitude(y + 1, zoom);
+
+    common::geospatial::GeometrySerializer::serializeEnvelope(
+        minX, minY, maxX, maxY, result);
+  }
+};
+
+template <typename T>
+struct GeometryAsGeoJsonFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Geometry>& geometry) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry =
+        common::geospatial::GeometryDeserializer::deserialize(geometry);
+    if (geospatial::isAtomicType(*geosGeometry) && geosGeometry->isEmpty()) {
+      return false;
+    }
+
+    auto writer = geos::io::GeoJSONWriter();
+    result = writer.write(geosGeometry.get());
+    return true;
+  }
+};
+
+template <typename T>
+struct GeometryFromGeoJsonFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Geometry>& result,
+      const arg_type<Varchar>& geometry) {
+    auto reader = geos::io::GeoJSONReader();
+    auto geosGeometry = reader.read(std::string(geometry));
+    common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+  }
+};
+
+template <typename T>
+struct GreatCircleDistanceFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<double>& result,
+      const arg_type<double>& lat1,
+      const arg_type<double>& long1,
+      const arg_type<double>& lat2,
+      const arg_type<double>& long2) {
+    Status status = geospatial::validateLatitudeLongitude(lat1, long1);
+    if (FOLLY_UNLIKELY(!status.ok())) {
+      return status;
+    }
+
+    status = geospatial::validateLatitudeLongitude(lat2, long2);
+    if (FOLLY_UNLIKELY(!status.ok())) {
+      return status;
+    }
+
+    result = BingTileType::greatCircleDistance(lat1, long1, lat2, long2);
+    return status;
+  }
+};
+
+template <typename T>
+struct GeometryToBingTilesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  uint8_t maxZoomShift = 5;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /* inputTypes */,
+      const core::QueryConfig& config,
+      const arg_type<Geometry>* /* geometry */,
+      const arg_type<int32_t>* /* zoom */) {
+    maxZoomShift =
+        std::max<uint8_t>(config.debugBingTileChildrenMaxZoomShift(), 1);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Array<BingTile>>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<int32_t>& zoom) {
+    if (zoom < 0 || zoom > 23) {
+      return Status::UserError("Zoom level must be between 0 and 23");
+    }
+    auto envelope =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(geometry);
+    if (envelope->isNull()) {
+      return Status::OK();
+    }
+
+    std::vector<int64_t> covering;
+    auto geom = common::geospatial::GeometryDeserializer::deserialize(geometry);
+
+    if (geom->getGeometryTypeId() == geos::geom::GeometryTypeId::GEOS_POINT) {
+      covering = geospatial::getMinimalTilesCoveringGeometry(*envelope, zoom);
+    } else {
+      if (geospatial::isPointOrRectangle(*geom)) {
+        covering = geospatial::getMinimalTilesCoveringGeometry(*envelope, zoom);
+      } else {
+        covering = geospatial::getMinimalTilesCoveringGeometry(
+            *geom, zoom, maxZoomShift);
+      }
+    }
+
+    result.add_items(covering);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct GeometryToDissolvedBingTilesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Array<BingTile>>& result,
+      const arg_type<Geometry>& geometry,
+      const arg_type<int32_t>& zoom) {
+    if (zoom < 0 || zoom > 23) {
+      return Status::UserError("Zoom level must be between 0 and 23");
+    }
+    auto geom = common::geospatial::GeometryDeserializer::deserialize(geometry);
+    if (geom->isEmpty()) {
+      return Status::OK();
+    }
+
+    std::vector<int64_t> covering =
+        geospatial::getDissolvedTilesCoveringGeometry(*geom, zoom);
+
+    result.add_items(covering);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct GeometryUnionFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  GeometryUnionFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Array<Geometry>>& geometries) {
+    std::vector<std::unique_ptr<geos::geom::Geometry>> geometryVector;
+    if (geometries.size() == 0) {
+      return false;
+    }
+    // There seems to be a bug in the current version of geos where union with
+    // all empty geometries is returning incorrect results or even crashing.
+    // The isCompletelyEmpty check is a hack to avoid this case.
+    bool isCompletelyEmpty = true;
+
+    for (int i = 0; i < geometries.size(); i++) {
+      // Ignore null inputs
+      if (!geometries[i].has_value()) {
+        continue;
+      }
+      std::unique_ptr<geos::geom::Geometry> geosGeometry =
+          common::geospatial::GeometryDeserializer::deserialize(*geometries[i]);
+      if (!geosGeometry->isEmpty()) {
+        isCompletelyEmpty = false;
+      }
+      geometryVector.push_back(std::move(geosGeometry));
+    }
+
+    if (FOLLY_UNLIKELY(isCompletelyEmpty)) {
+      auto emptyCollection = factory_->createPolygon();
+      common::geospatial::GeometrySerializer::serialize(
+          *emptyCollection, result);
+      return true;
+    }
+
+    std::unique_ptr<geos::geom::Geometry> collection(
+        factory_->createGeometryCollection(std::move(geometryVector)));
+
+    // If geometry is not completely empty, we can proceed with union.
+    std::unique_ptr<geos::geom::Geometry> geomUnion = collection->Union();
+    common::geospatial::GeometrySerializer::serialize(*geomUnion, result);
+    return true;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StLineFromTextFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Geometry>& result, const arg_type<Varchar>& wkt) {
+    std::unique_ptr<geos::geom::Geometry> geosGeometry;
+    GEOS_TRY(
+        {
+          geos::io::WKTReader reader;
+          geosGeometry = reader.read(std::string(wkt));
+        },
+        "Failed to parse WKT");
+    auto validate = geospatial::validateType(
+        *geosGeometry,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING},
+        "ST_LineFromText");
+
+    if (validate.ok()) {
+      common::geospatial::GeometrySerializer::serialize(*geosGeometry, result);
+    }
+
+    return validate;
+  }
+};
+
+template <typename T>
+struct StLineStringFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  StLineStringFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Geometry>& result,
+      const arg_type<Array<Geometry>>& input) {
+    std::unique_ptr<geos::geom::CoordinateArraySequence> coords =
+        common::geospatial::GeometryDeserializer::deserializePointsToCoordinate<
+            Geometry>(input, "ST_LineString", true);
+
+    std::unique_ptr<geos::geom::LineString> lineString;
+    if (input.size() < 2) {
+      lineString = factory_->createLineString();
+    } else {
+      lineString = factory_->createLineString(std::move(coords));
+    }
+    common::geospatial::GeometrySerializer::serialize(*lineString, result);
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StMultiPointFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  StMultiPointFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Geometry>& result,
+      const arg_type<Array<Geometry>>& input) {
+    std::unique_ptr<geos::geom::CoordinateArraySequence> coords =
+        common::geospatial::GeometryDeserializer::deserializePointsToCoordinate<
+            Geometry>(input, "ST_MultiPoint", false);
+
+    if (coords->size() == 0) {
+      return false;
+    }
+
+    auto multiPoint = std::unique_ptr<geos::geom::MultiPoint>(
+        factory_->createMultiPoint(*coords));
+    common::geospatial::GeometrySerializer::serialize(*multiPoint, result);
+    return true;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct ToGeometryFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Geometry>& result,
+      const arg_type<SphericalGeography>& input) {
+    // Every SphericalGeography object is a valid geometry object
+    result = input;
+  }
+};
+
+template <typename T>
+struct ToSphericalGeographyFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<SphericalGeography>& result, const arg_type<Geometry>& input) {
+    std::unique_ptr<geos::geom::Envelope> env =
+        common::geospatial::GeometryDeserializer::deserializeEnvelope(input);
+    Status status = Status::OK();
+    if (!env->isNull()) {
+      status =
+          geospatial::validateLatitudeLongitude(env->getMinY(), env->getMinX());
+      if (FOLLY_UNLIKELY(!status.ok())) {
+        return status;
+      }
+      status =
+          geospatial::validateLatitudeLongitude(env->getMaxY(), env->getMaxX());
+      if (FOLLY_UNLIKELY(!status.ok())) {
+        return status;
+      }
+    }
+
+    result = input;
+    return status;
+  }
+};
+
+template <typename T>
+struct StSphericalCentroidFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  StSphericalCentroidFunction() {
+    factory_ = geos::geom::GeometryFactory::create();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<SphericalGeography>& result,
+      const arg_type<SphericalGeography>& input) {
+    std::unique_ptr<geos::geom::Geometry> geometry =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+
+    if (geometry->isEmpty()) {
+      return false;
+    }
+
+    // Validate type is POINT or MULTI_POINT
+    auto validate = geospatial::validateType(
+        *geometry,
+        {geos::geom::GeometryTypeId::GEOS_POINT,
+         geos::geom::GeometryTypeId::GEOS_MULTIPOINT},
+        "ST_Centroid[SphericalGeography]");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    auto geometryType = geometry->getGeometryTypeId();
+    // Handle single point case
+    if (geometryType == geos::geom::GeometryTypeId::GEOS_POINT) {
+      common::geospatial::GeometrySerializer::serialize(*geometry, result);
+      return true;
+    }
+
+    const geos::geom::MultiPoint& multiPoint =
+        static_cast<const geos::geom::MultiPoint&>(*geometry);
+
+    // Compute the spherical centroid
+    auto centroidCoords = geospatial::computeSphericalCentroid(multiPoint);
+
+    // Create a Point geometry from the spherical coordinates
+    auto centroidPoint =
+        std::unique_ptr<geos::geom::Point>(factory_->createPoint(
+            geos::geom::Coordinate(
+                centroidCoords.first, centroidCoords.second)));
+
+    common::geospatial::GeometrySerializer::serialize(*centroidPoint, result);
+    return true;
+  }
+
+ private:
+  geos::geom::GeometryFactory::Ptr factory_;
+};
+
+template <typename T>
+struct StSphericalDistanceFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SphericalGeography>& left,
+      const arg_type<SphericalGeography>& right) {
+    std::unique_ptr<geos::geom::Geometry> leftGeom =
+        common::geospatial::GeometryDeserializer::deserialize(left);
+    std::unique_ptr<geos::geom::Geometry> rightGeom =
+        common::geospatial::GeometryDeserializer::deserialize(right);
+
+    auto validateLeft = geospatial::validateType(
+        *leftGeom,
+        {geos::geom::GeometryTypeId::GEOS_POINT},
+        "ST_Distance[SphericalGeography]");
+    if (!validateLeft.ok()) {
+      VELOX_USER_FAIL(validateLeft.message());
+    };
+
+    auto validateRight = geospatial::validateType(
+        *rightGeom,
+        {geos::geom::GeometryTypeId::GEOS_POINT},
+        "ST_Distance[SphericalGeography]");
+    if (!validateRight.ok()) {
+      VELOX_USER_FAIL(validateRight.message());
+    }
+
+    if (leftGeom->isEmpty() || rightGeom->isEmpty()) {
+      return false;
+    }
+
+    geos::geom::Point* leftPoint =
+        static_cast<geos::geom::Point*>(leftGeom.get());
+    geos::geom::Point* rightPoint =
+        static_cast<geos::geom::Point*>(rightGeom.get());
+
+    result = BingTileType::greatCircleDistance(
+                 leftPoint->getY(),
+                 leftPoint->getX(),
+                 rightPoint->getY(),
+                 rightPoint->getX()) *
+        1000;
+
+    return true;
+  }
+};
+
+template <typename T>
+struct StSphericalLengthFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SphericalGeography>& input) {
+    std::unique_ptr<geos::geom::Geometry> geom =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+    if (geom->isEmpty()) {
+      return false;
+    }
+
+    auto validate = geospatial::validateType(
+        *geom,
+        {geos::geom::GeometryTypeId::GEOS_LINESTRING,
+         geos::geom::GeometryTypeId::GEOS_MULTILINESTRING},
+        "ST_Length[SphericalGeography]");
+
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    double sum = 0.0;
+    if (geom->getGeometryTypeId() ==
+        geos::geom::GeometryTypeId::GEOS_LINESTRING) {
+      const geos::geom::LineString* lineString =
+          static_cast<const geos::geom::LineString*>(geom.get());
+      sum += geospatial::getSphericalLength(*lineString);
+
+    } else { // Multipoint
+      geos::geom::MultiLineString* multiLineString =
+          static_cast<geos::geom::MultiLineString*>(geom.get());
+      auto numLineStrings = multiLineString->getNumGeometries();
+      for (int i = 0; i < numLineStrings; i++) {
+        const geos::geom::LineString* lineString =
+            multiLineString->getGeometryN(i);
+        sum += geospatial::getSphericalLength(*lineString);
+      }
+    }
+
+    result = sum * 1000;
+    return true;
+  }
+};
+
+template <typename T>
+struct StSphericalAreaFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SphericalGeography>& input) {
+    std::unique_ptr<geos::geom::Geometry> geom =
+        common::geospatial::GeometryDeserializer::deserialize(input);
+    if (geom->isEmpty()) {
+      return false;
+    }
+
+    auto validate = geospatial::validateType(
+        *geom,
+        {geos::geom::GeometryTypeId::GEOS_POLYGON,
+         geos::geom::GeometryTypeId::GEOS_MULTIPOLYGON},
+        "ST_Area[SphericalGeography]");
+    if (!validate.ok()) {
+      VELOX_USER_FAIL(validate.message());
+    }
+
+    double sphericalExcess = 0.0;
+    if (geom->getGeometryTypeId() == geos::geom::GEOS_POLYGON) {
+      geos::geom::Polygon* polygon =
+          static_cast<geos::geom::Polygon*>(geom.get());
+      // Single polygon: calculate excess for that polygon only
+      sphericalExcess = geospatial::computeSphericalExcess(*polygon);
+    } else if (geom->getGeometryTypeId() == geos::geom::GEOS_MULTIPOLYGON) {
+      geos::geom::MultiPolygon* multiPolygon =
+          static_cast<geos::geom::MultiPolygon*>(geom.get());
+      // MultiPolygon: calculate sum excess of all Polygons
+      auto polygonCount = multiPolygon->getNumGeometries();
+      for (int i = 0; i < polygonCount; i++) {
+        sphericalExcess +=
+            geospatial::computeSphericalExcess(*multiPolygon->getGeometryN(i));
+      }
+    } else {
+      VELOX_FAIL(
+          fmt::format(
+              "Unexpected failure in ST_Area initial type validation. Type: {}",
+              geom->getGeometryType()));
+    }
+
+    // abs is required here because for Polygons with a 2D area of 0
+    // isExteriorRing returns false for the exterior ring
+    result = std::abs(
+        (sphericalExcess * (BingTileType::kEarthRadiusKm * 1000.0) *
+         (BingTileType::kEarthRadiusKm * 1000.0)));
+
+    return true;
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/GreatestLeast.h b/velox/functions/prestosql/GreatestLeast.h
index c4b04e95d54b..5c9aa77d916e 100644
--- a/velox/functions/prestosql/GreatestLeast.h
+++ b/velox/functions/prestosql/GreatestLeast.h
@@ -16,6 +16,7 @@
 #pragma once
 
 #include <cmath>
+#include <optional>
 #include "velox/expression/ComplexViewTypes.h"
 #include "velox/functions/Macros.h"
 
@@ -41,23 +42,32 @@ struct ExtremeValueFunction {
       out_type<T>& result,
       const arg_type<T>& firstElement,
       const arg_type<Variadic<T>>& remainingElement) {
-    auto currentValue = extractValue(firstElement);
+    // Track the winner: nullopt means firstElement, a value means index in
+    // remainingElement
+    std::optional<vector_size_t> winnerIdx;
 
-    for (auto element : remainingElement) {
-      auto candidateValue = extractValue(element.value());
+    for (size_t i = 0; i < remainingElement.size(); ++i) {
+      const auto& cur = remainingElement[i].value();
+      const auto& best = winnerIdx.has_value()
+          ? remainingElement[*winnerIdx].value()
+          : firstElement;
 
       if constexpr (isLeast) {
-        if (smallerThan(candidateValue, currentValue)) {
-          currentValue = candidateValue;
+        if (smallerThan(cur, best)) {
+          winnerIdx = i;
         }
       } else {
-        if (greaterThan(candidateValue, currentValue)) {
-          currentValue = candidateValue;
+        if (greaterThan(cur, best)) {
+          winnerIdx = i;
         }
       }
     }
 
-    result = currentValue;
+    if (!winnerIdx.has_value()) {
+      result = extractValue(firstElement);
+    } else {
+      result = extractValue(remainingElement[*winnerIdx].value());
+    }
   }
 
  private:
diff --git a/velox/functions/prestosql/HyperLogLogFunctions.h b/velox/functions/prestosql/HyperLogLogFunctions.h
index 8dc85d1ef58f..93004a69c1b6 100644
--- a/velox/functions/prestosql/HyperLogLogFunctions.h
+++ b/velox/functions/prestosql/HyperLogLogFunctions.h
@@ -18,6 +18,7 @@
 #include "velox/common/hyperloglog/DenseHll.h"
 #include "velox/common/hyperloglog/HllUtils.h"
 #include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/common/memory/HashStringAllocator.h"
 #include "velox/functions/Macros.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
 
@@ -30,13 +31,10 @@ struct CardinalityFunction {
   FOLLY_ALWAYS_INLINE bool call(
       int64_t& result,
       const arg_type<HyperLogLog>& hll) {
-    using common::hll::DenseHll;
-    using common::hll::SparseHll;
-
-    if (SparseHll::canDeserialize(hll.data())) {
-      result = SparseHll::cardinality(hll.data());
+    if (common::hll::SparseHlls::canDeserialize(hll.data())) {
+      result = common::hll::SparseHlls::cardinality(hll.data());
     } else {
-      result = DenseHll::cardinality(hll.data());
+      result = common::hll::DenseHlls::cardinality(hll.data());
     }
     return true;
   }
@@ -48,7 +46,7 @@ struct EmptyApproxSetFunction {
 
   FOLLY_ALWAYS_INLINE bool call(out_type<HyperLogLog>& result) {
     static const std::string kEmpty =
-        common::hll::SparseHll::serializeEmpty(12);
+        common::hll::SparseHlls::serializeEmpty(12);
 
     result.resize(kEmpty.size());
     memcpy(result.data(), kEmpty.data(), kEmpty.size());
@@ -69,7 +67,7 @@ struct EmptyApproxSetWithMaxErrorFunction {
         maxStandardError,
         "empty_approx_set function requires constant value for maxStandardError argument");
     common::hll::checkMaxStandardError(*maxStandardError);
-    serialized_ = common::hll::SparseHll::serializeEmpty(
+    serialized_ = common::hll::SparseHlls::serializeEmpty(
         common::hll::toIndexBitLength(*maxStandardError));
   }
 
@@ -81,4 +79,118 @@ struct EmptyApproxSetWithMaxErrorFunction {
     return true;
   }
 };
+
+template <typename T>
+struct MergeHllFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Array<HyperLogLog>>* /*constantArg*/) {
+    VELOX_USER_CHECK_NOT_NULL(
+        pool, "merge_hll requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<HyperLogLog>& result,
+      const arg_type<Array<HyperLogLog>>& hllArray) {
+    using SparseHll = common::hll::SparseHll<HashStringAllocator>;
+    using DenseHll = common::hll::DenseHll<HashStringAllocator>;
+
+    std::optional<int8_t> indexBitLength;
+    std::optional<SparseHll> sparseHll;
+    std::optional<DenseHll> denseHll;
+
+    for (const auto& hllData : hllArray) {
+      // Skip null elements
+      if (!hllData.has_value()) {
+        continue;
+      }
+
+      // Skip empty HLL data
+      const auto& hllValue = hllData.value();
+      if (hllValue.empty()) {
+        continue;
+      }
+
+      const bool isSparseHllData =
+          common::hll::SparseHlls::canDeserialize(hllValue.data());
+      const bool isDenseHllData = !isSparseHllData &&
+          common::hll::DenseHlls::canDeserialize(hllValue.data());
+
+      VELOX_USER_CHECK(
+          isSparseHllData || isDenseHllData, "Invalid HLL data format");
+
+      const auto hllIndexBitLength = isSparseHllData
+          ? common::hll::SparseHlls::deserializeIndexBitLength(hllValue.data())
+          : common::hll::DenseHlls::deserializeIndexBitLength(hllValue.data());
+
+      if (indexBitLength.has_value()) {
+        VELOX_USER_CHECK_EQ(
+            indexBitLength.value(),
+            hllIndexBitLength,
+            "Cannot merge HLLs with different indexBitLength");
+      } else {
+        indexBitLength = hllIndexBitLength;
+      }
+
+      if (isSparseHllData) {
+        if (denseHll.has_value()) {
+          SparseHll temp{hllValue.data(), allocator_.get()};
+          temp.toDense(*denseHll);
+        } else {
+          if (!sparseHll.has_value()) {
+            sparseHll.emplace(allocator_.get());
+            sparseHll->setSoftMemoryLimit(
+                common::hll::DenseHlls::estimateInMemorySize(
+                    indexBitLength.value()));
+          }
+
+          sparseHll->mergeWith(hllValue.data());
+          if (sparseHll->overLimit()) {
+            denseHll.emplace(allocator_.get());
+            denseHll->initialize(indexBitLength.value());
+            sparseHll->toDense(*denseHll);
+            sparseHll.reset();
+          }
+        }
+      } else {
+        if (sparseHll.has_value()) {
+          denseHll.emplace(allocator_.get());
+          denseHll->initialize(indexBitLength.value());
+          sparseHll->toDense(*denseHll);
+          sparseHll.reset();
+        } else if (!denseHll.has_value()) {
+          denseHll.emplace(allocator_.get());
+          denseHll->initialize(indexBitLength.value());
+        }
+        denseHll->mergeWith(hllValue.data());
+      }
+    }
+
+    // Return null if no valid HLLs were merged
+    if (!sparseHll.has_value() && !denseHll.has_value()) {
+      return false;
+    }
+
+    // Serialize the result
+    if (sparseHll.has_value()) {
+      auto size = sparseHll->serializedSize();
+      result.resize(size);
+      sparseHll->serialize(indexBitLength.value(), result.data());
+    } else {
+      auto size = denseHll->serializedSize();
+      result.resize(size);
+      denseHll->serialize(result.data());
+    }
+
+    return true;
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/IPAddressFunctions.h b/velox/functions/prestosql/IPAddressFunctions.h
index 6339fdfbcb8a..7902ebe5b4c0 100644
--- a/velox/functions/prestosql/IPAddressFunctions.h
+++ b/velox/functions/prestosql/IPAddressFunctions.h
@@ -69,7 +69,8 @@ struct IPPrefixFunction {
       out_type<IPPrefix>& result,
       const arg_type<Varchar>& ipString,
       const arg_type<int64_t>& prefixBits) {
-    auto tryIp = folly::IPAddress::tryFromString(ipString);
+    // TODO: Remove explicit std::string_view cast.
+    auto tryIp = folly::IPAddress::tryFromString(std::string_view(ipString));
     if (tryIp.hasError()) {
       VELOX_USER_FAIL("Cannot cast value to IPADDRESS: {}", ipString);
     }
@@ -195,8 +196,9 @@ struct IPPrefixCollapseFunction {
 
     for (const auto& ipPrefix : ipPrefixes) {
       if (ipPrefix.has_value()) {
-        prefixes.push_back(std::make_tuple(
-            *ipPrefix->template at<0>(), *ipPrefix->template at<1>()));
+        prefixes.push_back(
+            std::make_tuple(
+                *ipPrefix->template at<0>(), *ipPrefix->template at<1>()));
       } else {
         // ip_prefix_collapse does not support null elements. Thus we throw here
         // with the same error message as Presto java.
@@ -423,10 +425,11 @@ struct IPPrefixSubnetsFunction {
 
     if (newPrefixLength < 0 || (inputIsIpV4 && newPrefixLength > 32) ||
         (!inputIsIpV4 && newPrefixLength > 128)) {
-      VELOX_USER_FAIL(fmt::format(
-          "Invalid prefix length for IPv{}: {}",
-          inputIsIpV4 ? 4 : 6,
-          newPrefixLength));
+      VELOX_USER_FAIL(
+          fmt::format(
+              "Invalid prefix length for IPv{}: {}",
+              inputIsIpV4 ? 4 : 6,
+              newPrefixLength));
     }
 
     int8_t inputPrefixLength = *prefix.template at<1>();
diff --git a/velox/functions/prestosql/JsonFunctions.cpp b/velox/functions/prestosql/JsonFunctions.cpp
index cd23a33e1083..2c9141bf12b5 100644
--- a/velox/functions/prestosql/JsonFunctions.cpp
+++ b/velox/functions/prestosql/JsonFunctions.cpp
@@ -18,7 +18,7 @@
 #include "velox/common/base/SortingNetwork.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/expression/VectorWriters.h"
-#include "velox/functions/lib/string/StringImpl.h"
+#include "velox/functions/lib/JsonUtil.h"
 #include "velox/functions/prestosql/json/JsonStringUtil.h"
 #include "velox/functions/prestosql/json/SIMDJsonExtractor.h"
 #include "velox/functions/prestosql/json/SIMDJsonUtil.h"
@@ -29,6 +29,66 @@ namespace facebook::velox::functions {
 
 namespace {
 
+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::unknown: {
+      // In simdjson 4.0.7+, unknown type is returned for invalid JSON values
+      // like NaN, Infinity, etc. Return INCORRECT_TYPE to indicate invalid
+      // JSON.
+      return simdjson::INCORRECT_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();
+}
+
+} // namespace
+
+simdjson::error_code jsonParsingError(simdjson::ondemand::document& doc) {
+  SIMDJSON_TRY(validate<simdjson::ondemand::document&>(doc));
+  if (!doc.at_end()) {
+    return simdjson::TRAILING_CONTENT;
+  }
+  // Rewind the document to go through a document more than once without
+  // rescanning all of the input data again.
+  doc.rewind();
+  return simdjson::SUCCESS;
+}
+
+simdjson::error_code jsonParsingError(const simdjson::padded_string& json) {
+  SIMDJSON_ASSIGN_OR_RAISE(auto doc, simdjsonParse(json));
+  return jsonParsingError(doc);
+}
+
+namespace {
+
 const std::string_view kArrayStart = "[";
 const std::string_view kArrayEnd = "]";
 const std::string_view kSeparator = ",";
@@ -68,15 +128,6 @@ void addOrMergeChar(JsonViews& views, std::string_view view) {
   }
 }
 
-std::string_view trimToken(std::string_view token) {
-  VELOX_DCHECK(!stringImpl::isAsciiWhiteSpace(token[0]));
-  auto size = token.size();
-  while (stringImpl::isAsciiWhiteSpace(token[size - 1])) {
-    --size;
-  }
-  return std::string_view(token.data(), size);
-}
-
 struct JsonField {
   std::string_view key;
   int32_t offset;
@@ -344,6 +395,12 @@ class JsonParseImpl {
   simdjson::error_code generateViews(T value) const {
     SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
     switch (type) {
+      case simdjson::ondemand::json_type::unknown: {
+        // In simdjson 4.0.7+, unknown type is returned for invalid JSON values
+        // like NaN, Infinity, etc. Return INCORRECT_TYPE to indicate invalid
+        // JSON.
+        return simdjson::INCORRECT_TYPE;
+      }
       case simdjson::ondemand::json_type::array: {
         SIMDJSON_ASSIGN_OR_RAISE(auto array, value.get_array());
         return generateViewsFromArray<kNeedNormalize>(array);
@@ -612,6 +669,9 @@ class JsonFunctionTemplate : public exec::VectorFunction {
           }
           nullResult = true;
           context.setErrors(rows, std::current_exception());
+        } catch (const std::exception&) {
+          nullResult = true;
+          context.setErrors(rows, std::current_exception());
         }
       }
 
@@ -713,6 +773,12 @@ struct JsonExtractImpl {
       // contents directly) and we might miss invalid JSON.
       SIMDJSON_ASSIGN_OR_RAISE(auto vtype, v.type());
       switch (vtype) {
+        case simdjson::ondemand::json_type::unknown: {
+          // In simdjson 4.0.7+, unknown type is returned for invalid JSON
+          // values like NaN, Infinity, etc. Return INCORRECT_TYPE to indicate
+          // invalid JSON.
+          return simdjson::INCORRECT_TYPE;
+        }
         case simdjson::ondemand::json_type::object: {
           SIMDJSON_ASSIGN_OR_RAISE(
               auto jsonStr, simdjson::to_json_string(v.get_object()));
@@ -739,21 +805,19 @@ struct JsonExtractImpl {
       return simdjson::SUCCESS;
     };
 
-    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    // TODO: Remove explicit std::string_view cast.
+    auto& extractor =
+        SIMDJsonExtractor::getInstance(std::string_view(jsonPath));
     bool isDefinitePath = true;
     simdjson::padded_string paddedJson(json.data(), json.size());
 
     // Check for valid json
-    {
-      SIMDJSON_ASSIGN_OR_RAISE(auto jsonDoc, simdjsonParse(paddedJson));
-      simdjson::ondemand::document parsedDoc;
-      if (auto errorCode = simdjsonParse(paddedJson).get(parsedDoc);
-          errorCode != simdjson::SUCCESS) {
-        return errorCode;
-      }
+    SIMDJSON_ASSIGN_OR_RAISE(auto doc, simdjsonParse(paddedJson));
+    if (auto error = jsonParsingError(doc)) {
+      return error;
     }
 
-    SIMDJSON_TRY(extractor.extract(paddedJson, consumer, isDefinitePath));
+    SIMDJSON_TRY(extractor.extract(doc, consumer, isDefinitePath));
 
     if (results.size() == 0) {
       if (isDefinitePath) {
diff --git a/velox/functions/prestosql/JsonFunctions.h b/velox/functions/prestosql/JsonFunctions.h
index 7daf7e5e6b6f..608eb2cd48cb 100644
--- a/velox/functions/prestosql/JsonFunctions.h
+++ b/velox/functions/prestosql/JsonFunctions.h
@@ -25,6 +25,18 @@
 
 namespace facebook::velox::functions {
 
+/// Utility function that takes a padded string and determines whether
+/// the json is valid or not.
+/// @returns simdjson::SUCCESS if passed json is valid else returns a
+/// failure code.
+simdjson::error_code jsonParsingError(const simdjson::padded_string& json);
+
+/// Utility function that takes a parsed json document and determines whether
+/// the json is valid or not.
+/// @returns simdjson::SUCCESS if passed json is valid else returns a
+/// failure code.
+simdjson::error_code jsonParsingError(simdjson::ondemand::document& doc);
+
 template <typename T>
 struct IsJsonScalarFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -33,7 +45,8 @@ struct IsJsonScalarFunction {
     simdjson::ondemand::document jsonDoc;
 
     simdjson::padded_string paddedJson(json.data(), json.size());
-    if (auto errorCode = simdjsonParse(paddedJson).get(jsonDoc)) {
+    auto errorCode = simdjsonParse(paddedJson).get(jsonDoc);
+    if (errorCode || jsonParsingError(jsonDoc)) {
       if (threadSkipErrorDetails()) {
         return Status::UserError();
       }
@@ -68,9 +81,11 @@ struct JsonArrayContainsFunction {
     simdjson::ondemand::document jsonDoc;
 
     simdjson::padded_string paddedJson(json.data(), json.size());
-    if (simdjsonParse(paddedJson).get(jsonDoc)) {
+    auto errorCode = simdjsonParse(paddedJson).get(jsonDoc);
+    if (errorCode || jsonParsingError(jsonDoc)) {
       return false;
     }
+
     if (jsonDoc.type().error()) {
       return false;
     }
@@ -133,7 +148,8 @@ struct JsonArrayGetFunction {
     simdjson::ondemand::document jsonDoc;
 
     simdjson::padded_string paddedJson(jsonArray.data(), jsonArray.size());
-    if (simdjsonParse(paddedJson).get(jsonDoc)) {
+    auto errorCode = simdjsonParse(paddedJson).get(jsonDoc);
+    if (errorCode || jsonParsingError(jsonDoc)) {
       return false;
     }
     if (jsonDoc.type().error()) {
@@ -225,20 +241,19 @@ struct JsonExtractScalarFunction {
       return simdjson::SUCCESS;
     };
 
-    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    // TODO: Remove explicit std::string_view cast.
+    auto& extractor =
+        SIMDJsonExtractor::getInstance(std::string_view(jsonPath));
 
     // Check for valid json
     simdjson::padded_string paddedJson(json.data(), json.size());
-    {
-      SIMDJSON_ASSIGN_OR_RAISE(auto jsonDoc, simdjsonParse(paddedJson));
-      simdjson::ondemand::document parsedDoc;
-      if (simdjsonParse(paddedJson).get(parsedDoc)) {
-        return simdjson::TAPE_ERROR;
-      }
+    SIMDJSON_ASSIGN_OR_RAISE(auto doc, simdjsonParse(paddedJson));
+    if (auto val = jsonParsingError(doc)) {
+      return val;
     }
 
     bool isDefinitePath = true;
-    SIMDJSON_TRY(extractor.extract(paddedJson, consumer, isDefinitePath));
+    SIMDJSON_TRY(extractor.extract(doc, consumer, isDefinitePath));
 
     if (resultStr.has_value()) {
       result.copy_from(*resultStr);
@@ -290,12 +305,17 @@ struct JsonSizeFunction {
           case simdjson::ondemand::json_type::null:
             singleResultSize = 0;
             break;
+          case simdjson::ondemand::json_type::unknown: {
+            return simdjson::INCORRECT_TYPE;
+          }
         }
       }
       return simdjson::SUCCESS;
     };
 
-    auto& extractor = SIMDJsonExtractor::getInstance(jsonPath);
+    // TODO: Remove explicit std::string_view cast.
+    auto& extractor =
+        SIMDJsonExtractor::getInstance(std::string_view(jsonPath));
     bool isDefinitePath = true;
     simdjson::padded_string paddedJson(json.data(), json.size());
     SIMDJSON_TRY(extractor.extract(paddedJson, consumer, isDefinitePath));
@@ -328,7 +348,9 @@ struct JsonArrayLengthFunction {
     simdjson::ondemand::document jsonDoc;
 
     simdjson::padded_string paddedJson(json.data(), json.size());
-    if (simdjsonParse(paddedJson).get(jsonDoc)) {
+    auto errorCode = simdjsonParse(paddedJson).get(jsonDoc);
+    // Check for valid json
+    if (errorCode || jsonParsingError(jsonDoc)) {
       return false;
     }
     if (jsonDoc.type().error()) {
diff --git a/velox/functions/prestosql/KHyperLogLogFunctions.h b/velox/functions/prestosql/KHyperLogLogFunctions.h
new file mode 100644
index 000000000000..cfd67eff8b1c
--- /dev/null
+++ b/velox/functions/prestosql/KHyperLogLogFunctions.h
@@ -0,0 +1,351 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/Status.h"
+#include "velox/common/hyperloglog/KHyperLogLog.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+namespace facebook::velox::functions {
+
+template <typename T>
+struct KHyperLogLogCardinalityFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status
+  call(int64_t& result, const arg_type<KHyperLogLog>& khllData) {
+    auto khllInstance = KHyperLogLogUtils::deserialize(
+        khllData.data(), khllData.size(), allocator_.get());
+    if (khllInstance.hasError()) {
+      return khllInstance.error();
+    }
+    result = khllInstance.value()->cardinality();
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct KHyperLogLogIntersectionCardinalityFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg1*/,
+      const arg_type<KHyperLogLog>* /*constantArg2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog intersection_cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      int64_t& result,
+      const arg_type<KHyperLogLog>& khll1Data,
+      const arg_type<KHyperLogLog>& khll2Data) {
+    auto khll1Instance = KHyperLogLogUtils::deserialize(
+        khll1Data.data(), khll1Data.size(), allocator_.get());
+    if (khll1Instance.hasError()) {
+      return khll1Instance.error();
+    }
+    auto khll1 = std::move(khll1Instance.value());
+    auto khll2Instance = KHyperLogLogUtils::deserialize(
+        khll2Data.data(), khll2Data.size(), allocator_.get());
+    if (khll2Instance.hasError()) {
+      return khll2Instance.error();
+    }
+    auto khll2 = std::move(khll2Instance.value());
+
+    // If both khlls are exact, return the exact intersection cardinality.
+    if (khll1->isExact() && khll2->isExact()) {
+      result = KHyperLogLogUtils::exactIntersectionCardinality(*khll1, *khll2);
+      return Status::OK();
+    }
+
+    // If either of the khlls are not exact, return an approximation of the
+    // intersection cardinality using the Jaccard Index like a similarity
+    // index between the 2 key sets.
+    int64_t lowestCardinality =
+        std::min(khll1->cardinality(), khll2->cardinality());
+    double jaccard = KHyperLogLogUtils::jaccardIndex(*khll1, *khll2);
+    auto setUnion =
+        KHyperLogLogUtils::merge(std::move(khll1), std::move(khll2));
+    int64_t computedResult =
+        static_cast<int64_t>(std::round(jaccard * setUnion->cardinality()));
+
+    // In a special case where one set is much smaller and almost a true
+    // subset of the other, return the size of the smaller set. For example:
+    // Set1 = {1,2,3,4,5,6}
+    // Set2 = {1,2}
+    // Jaccard Index = 1
+    // Approximated intersection cardinality = 6
+    // This result does not make sense as Set2 does not even have 6
+    // elements. Thus return 2 instead.
+    result = std::min(computedResult, lowestCardinality);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct KHyperLogLogJaccardIndexFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg1*/,
+      const arg_type<KHyperLogLog>* /*constantArg2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog jaccard_index requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      double& result,
+      const arg_type<KHyperLogLog>& khll1Data,
+      const arg_type<KHyperLogLog>& khll2Data) {
+    auto khll1Instance = KHyperLogLogUtils::deserialize(
+        khll1Data.data(), khll1Data.size(), allocator_.get());
+    if (khll1Instance.hasError()) {
+      return khll1Instance.error();
+    }
+    auto khll2Instance = KHyperLogLogUtils::deserialize(
+        khll2Data.data(), khll2Data.size(), allocator_.get());
+    if (khll2Instance.hasError()) {
+      return khll2Instance.error();
+    }
+
+    result = KHyperLogLogUtils::jaccardIndex(
+        *khll1Instance.value(), *khll2Instance.value());
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct KHyperLogLogReidentificationPotentialFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg1*/,
+      const int64_t* /*constantArg2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog reidentification_potential requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      double& result,
+      const arg_type<KHyperLogLog>& khllData,
+      int64_t threshold) {
+    auto khllInstance = KHyperLogLogUtils::deserialize(
+        khllData.data(), khllData.size(), allocator_.get());
+    if (khllInstance.hasError()) {
+      return khllInstance.error();
+    }
+    result = khllInstance.value()->reidentificationPotential(threshold);
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct KHyperLogLogUniquenessDistributionFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog uniqueness_distribution requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<KHyperLogLog>* /*constantArg1*/,
+      const int64_t* /*constantArg2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog uniqueness_distribution requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Map<int64_t, double>>& result,
+      const arg_type<KHyperLogLog>& khllData) {
+    // When histogramSize is not provided, use the minhash size of the KHLL
+    // instance as the default.
+    auto khllInstance = KHyperLogLogUtils::deserialize(
+        khllData.data(), khllData.size(), allocator_.get());
+    if (khllInstance.hasError()) {
+      return khllInstance.error();
+    }
+    int64_t histogramSize =
+        static_cast<int64_t>(khllInstance.value()->minhashSize());
+    return uniquenessDistribution(result, *khllInstance.value(), histogramSize);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Map<int64_t, double>>& result,
+      const arg_type<KHyperLogLog>& khllData,
+      int64_t histogramSize) {
+    auto khllInstance = KHyperLogLogUtils::deserialize(
+        khllData.data(), khllData.size(), allocator_.get());
+    if (khllInstance.hasError()) {
+      return khllInstance.error();
+    }
+    return uniquenessDistribution(result, *khllInstance.value(), histogramSize);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE Status uniquenessDistribution(
+      out_type<Map<int64_t, double>>& result,
+      KHyperLogLogUtils& khll,
+      int64_t histogramSize) {
+    auto distribution = khll.uniquenessDistribution(histogramSize);
+
+    // Sort the distribution by key to ensure sorted output
+    std::vector<std::pair<int64_t, double>> sortedDistribution(
+        distribution.begin(), distribution.end());
+    std::sort(
+        sortedDistribution.begin(),
+        sortedDistribution.end(),
+        [](const auto& a, const auto& b) { return a.first < b.first; });
+
+    // Populate the result map
+    for (const auto& [key, value] : sortedDistribution) {
+      result.add_item() = std::make_tuple(key, value);
+    }
+
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct MergeKHyperLogLogFunction {
+  using KHyperLogLogUtils =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Array<KHyperLogLog>>* /*constantArg*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "KHyperLogLog merge_khll requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<KHyperLogLog>& result,
+      const arg_type<Array<KHyperLogLog>>& hllArray) {
+    std::unique_ptr<KHyperLogLogUtils> merged = nullptr;
+
+    for (const auto& khllData : hllArray) {
+      // Skip null elements
+      if (!khllData.has_value()) {
+        continue;
+      }
+
+      // Skip empty HLL data
+      const auto& khllValue = khllData.value();
+      if (khllValue.empty()) {
+        continue;
+      }
+
+      if (!merged) {
+        // Initialize with first non-null element.
+        auto deserializeResult = KHyperLogLogUtils::deserialize(
+            khllValue.data(), khllValue.size(), allocator_.get());
+        VELOX_CHECK(
+            deserializeResult.hasValue(),
+            "Failed to deserialize KHyperLogLog: {}",
+            deserializeResult.error().message());
+        merged = std::move(deserializeResult.value());
+      } else {
+        auto currentKhll = KHyperLogLogUtils::deserialize(
+            khllValue.data(), khllValue.size(), allocator_.get());
+        VELOX_CHECK(
+            currentKhll.hasValue(),
+            "Failed to deserialize KHyperLogLog: {}",
+            currentKhll.error().message());
+        merged->mergeWith(*currentKhll.value());
+      }
+    }
+
+    // Return null if all elements were null.
+    if (!merged) {
+      return false;
+    }
+
+    size_t serializedSize = merged->estimatedSerializedSize();
+    result.resize(serializedSize);
+    merged->serialize(result.data());
+
+    return true;
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Map.cpp b/velox/functions/prestosql/Map.cpp
index 37165a5a9032..e24fadd467ba 100644
--- a/velox/functions/prestosql/Map.cpp
+++ b/velox/functions/prestosql/Map.cpp
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/Expr.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/CheckDuplicateKeys.h"
 
diff --git a/velox/functions/prestosql/MapAppend.h b/velox/functions/prestosql/MapAppend.h
new file mode 100644
index 000000000000..501c3eca444e
--- /dev/null
+++ b/velox/functions/prestosql/MapAppend.h
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/Macros.h"
+#include "velox/type/FloatingPointUtil.h"
+
+namespace facebook::velox::functions {
+
+/// Fast path for primitive type keys: map_append(m, array[1, 2], array[10,
+/// 20]).
+template <typename TExec, typename Key>
+struct MapAppendPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Key, Generic<T1>>>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& keys,
+      const arg_type<Array<Generic<T1>>>& values) {
+    // Check that keys and values arrays have the same size
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build a set of existing keys for fast lookup
+    util::floating_point::HashSetNaNAware<arg_type<Key>> existingKeys;
+    for (const auto& entry : inputMap) {
+      existingKeys.emplace(entry.first);
+    }
+
+    // Build a set of new keys to check for duplicates and verify they don't
+    // exist
+    util::floating_point::HashSetNaNAware<arg_type<Key>> newKeys;
+
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        const auto& key = keysIt->value();
+
+        // Check if key already exists in the input map
+        VELOX_USER_CHECK(
+            !existingKeys.contains(key), "Key already exists in the map");
+
+        // Check for duplicate keys in the new keys array
+        VELOX_USER_CHECK(
+            newKeys.emplace(key).second, "Duplicate key in keys array");
+      }
+    }
+
+    // First, copy all existing entries from the input map
+    for (const auto& entry : inputMap) {
+      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());
+      }
+    }
+
+    // Then, add new entries from keys and values arrays
+    keysIt = keys.begin();
+    valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter = keysIt->value();
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter = keysIt->value();
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+/// String version for varchar keys.
+template <typename TExec>
+struct MapAppendVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& keys,
+      const arg_type<Array<Generic<T1>>>& values) {
+    // Check that keys and values arrays have the same size
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build a set of existing keys for fast lookup
+    folly::F14FastSet<StringView> existingKeys;
+    for (const auto& entry : inputMap) {
+      existingKeys.emplace(entry.first);
+    }
+
+    // Build a set of new keys to check for duplicates and verify they don't
+    // exist
+    folly::F14FastSet<StringView> newKeys;
+
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        const auto& key = keysIt->value();
+
+        // Check if key already exists in the input map
+        VELOX_USER_CHECK(
+            !existingKeys.contains(key), "Key already exists in the map");
+
+        // Check for duplicate keys in the new keys array
+        VELOX_USER_CHECK(
+            newKeys.emplace(key).second, "Duplicate key in keys array");
+      }
+    }
+
+    // First, copy all existing entries from the input map
+    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.copy_from(entry.second.value());
+      }
+    }
+
+    // Then, add new entries from keys and values arrays
+    keysIt = keys.begin();
+    valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(keysIt->value());
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(keysIt->value());
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+struct MapAppendFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    VELOX_USER_CHECK(
+        result.has_value(), "Comparison on null elements is not supported");
+
+    return result.value() == 0;
+  }
+};
+
+/// Generic implementation for complex types.
+template <typename TExec>
+struct MapAppendFunction {
+  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,
+      const arg_type<Array<Generic<T2>>>& values) {
+    // Check that keys and values arrays have the same size
+    VELOX_USER_CHECK_EQ(
+        keys.size(),
+        values.size(),
+        "Keys and values arrays must have the same length");
+
+    // Build a set of existing keys for fast lookup
+    folly::F14FastSet<
+        exec::GenericView,
+        std::hash<exec::GenericView>,
+        MapAppendFunctionEqualComparator>
+        existingKeys;
+
+    for (const auto& entry : inputMap) {
+      existingKeys.emplace(entry.first);
+    }
+
+    // Build a set of new keys to check for duplicates and verify they don't
+    // exist
+    folly::F14FastSet<
+        exec::GenericView,
+        std::hash<exec::GenericView>,
+        MapAppendFunctionEqualComparator>
+        newKeys;
+
+    auto keysIt = keys.begin();
+    auto valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        const auto& key = keysIt->value();
+
+        // Check if key already exists in the input map
+        VELOX_USER_CHECK(
+            !existingKeys.contains(key), "Key already exists in the map");
+
+        // Check for duplicate keys in the new keys array
+        VELOX_USER_CHECK(
+            newKeys.emplace(key).second, "Duplicate key in keys array");
+      }
+    }
+
+    // First, copy all existing entries from the input map
+    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.copy_from(entry.second.value());
+      }
+    }
+
+    // Then, add new entries from keys and values arrays
+    keysIt = keys.begin();
+    valuesIt = values.begin();
+
+    for (; keysIt != keys.end(); ++keysIt, ++valuesIt) {
+      if (keysIt->has_value()) {
+        if (!valuesIt->has_value()) {
+          auto& keyWriter = out.add_null();
+          keyWriter.copy_from(keysIt->value());
+        } else {
+          auto [keyWriter, valueWriter] = out.add_item();
+          keyWriter.copy_from(keysIt->value());
+          valueWriter.copy_from(valuesIt->value());
+        }
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapExcept.h b/velox/functions/prestosql/MapExcept.h
new file mode 100644
index 000000000000..cc9dd474703f
--- /dev/null
+++ b/velox/functions/prestosql/MapExcept.h
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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_except(m, array[1, 2, 3]).
+template <typename TExec, typename Key>
+struct MapExceptPrimitiveFunction {
+  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;
+      searchKeys_.clear();
+      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 (!constantSearchKeys_) {
+      searchKeys_.clear();
+      initializeSearchKeys(keys);
+    }
+
+    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());
+      }
+    }
+  }
+
+ 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_except(m, array['a', 'b', 'c']).
+template <typename TExec>
+struct MapExceptVarcharFunction {
+  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;
+      searchKeys_.clear();
+      searchKeyStrings_.clear();
+
+      searchKeys_.reserve(keys->size());
+      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 (!constantSearchKeys_) {
+      searchKeys_.clear();
+      for (const auto& key : keys.skipNulls()) {
+        searchKeys_.emplace(key);
+      }
+    }
+
+    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());
+      }
+    }
+  }
+
+ private:
+  bool constantSearchKeys_{false};
+  folly::F14FastSet<StringView> searchKeys_;
+  std::vector<std::string> searchKeyStrings_;
+};
+
+struct MapExceptFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    // If comparison returns indeterminate (null), treat as not equal.
+    // This is consistent with SQL semantics where NULL != NULL.
+    if (!result.has_value()) {
+      return false;
+    }
+
+    return result.value() == 0;
+  }
+};
+
+/// Generic implementation. Doesn't provide an optimization for constant search
+/// keys.
+template <typename TExec>
+struct MapExceptFunction {
+  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) {
+    searchKeys_.clear();
+    for (const auto& key : keys.skipNulls()) {
+      searchKeys_.emplace(key);
+    }
+
+    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());
+      }
+    }
+  }
+
+ private:
+  folly::F14FastSet<
+      exec::GenericView,
+      std::hash<exec::GenericView>,
+      MapExceptFunctionEqualComparator>
+      searchKeys_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapFromEntries.cpp b/velox/functions/prestosql/MapFromEntries.cpp
index 91e4c260ea3d..9abd0d2dab73 100644
--- a/velox/functions/prestosql/MapFromEntries.cpp
+++ b/velox/functions/prestosql/MapFromEntries.cpp
@@ -64,23 +64,24 @@ class MapFromEntriesFunction : public exec::VectorFunction {
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    return {// unknown -> map(unknown, unknown)
-            exec::FunctionSignatureBuilder()
-                .returnType("map(unknown, unknown)")
-                .argumentType("unknown")
-                .build(),
-            // array(unknown) -> map(unknown, unknown)
-            exec::FunctionSignatureBuilder()
-                .returnType("map(unknown, unknown)")
-                .argumentType("array(unknown)")
-                .build(),
-            // array(row(K,V)) -> map(K,V)
-            exec::FunctionSignatureBuilder()
-                .typeVariable("K")
-                .typeVariable("V")
-                .returnType("map(K,V)")
-                .argumentType("array(row(K,V))")
-                .build()};
+    return {
+        // unknown -> map(unknown, unknown)
+        exec::FunctionSignatureBuilder()
+            .returnType("map(unknown, unknown)")
+            .argumentType("unknown")
+            .build(),
+        // array(unknown) -> map(unknown, unknown)
+        exec::FunctionSignatureBuilder()
+            .returnType("map(unknown, unknown)")
+            .argumentType("array(unknown)")
+            .build(),
+        // array(row(K,V)) -> map(K,V)
+        exec::FunctionSignatureBuilder()
+            .typeVariable("K")
+            .typeVariable("V")
+            .returnType("map(K,V)")
+            .argumentType("array(row(K,V))")
+            .build()};
   }
 
  private:
diff --git a/velox/functions/prestosql/MapIntersect.h b/velox/functions/prestosql/MapIntersect.h
new file mode 100644
index 000000000000..0c0ebf7bf6f0
--- /dev/null
+++ b/velox/functions/prestosql/MapIntersect.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/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_intersect(m, array[1, 2,
+/// 3]).
+template <typename TExec, typename Key>
+struct MapIntersectPrimitiveFunction {
+  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;
+    }
+
+    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());
+      }
+    }
+  }
+
+ 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_intersect(m, array['a', 'b', 'c']).
+template <typename TExec>
+struct MapIntersectVarcharFunction {
+  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;
+    }
+
+    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());
+      }
+    }
+  }
+
+ private:
+  bool constantSearchKeys_{false};
+  folly::F14FastSet<StringView> searchKeys_;
+  std::vector<std::string> searchKeyStrings_;
+};
+
+struct MapIntersectFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    // If comparison returns indeterminate (null), treat as not equal
+    if (!result.has_value()) {
+      return false;
+    }
+
+    return result.value() == 0;
+  }
+};
+
+/// Generic implementation. Doesn't provide an optimization for constant search
+/// keys.
+template <typename TExec>
+struct MapIntersectFunction {
+  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;
+    }
+
+    searchKeys_.clear();
+    for (const auto& key : keys.skipNulls()) {
+      searchKeys_.emplace(key);
+    }
+
+    if (searchKeys_.empty()) {
+      return;
+    }
+
+    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());
+      }
+    }
+  }
+
+ private:
+  folly::F14FastSet<
+      exec::GenericView,
+      std::hash<exec::GenericView>,
+      MapIntersectFunctionEqualComparator>
+      searchKeys_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapKeysAndValues.cpp b/velox/functions/prestosql/MapKeysAndValues.cpp
index 50a03310dae8..5d9c98f70cc4 100644
--- a/velox/functions/prestosql/MapKeysAndValues.cpp
+++ b/velox/functions/prestosql/MapKeysAndValues.cpp
@@ -71,7 +71,7 @@ class MapKeysFunction : public MapKeyValueFunction {
     VELOX_CHECK(
         arg->typeKind() == TypeKind::MAP,
         "Unsupported type for map_keys function {}",
-        mapTypeKindToName(arg->typeKind()));
+        TypeKindName::toName(arg->typeKind()));
 
     auto mapVector = arg->as<MapVector>();
     auto mapKeys = mapVector->mapKeys();
@@ -108,7 +108,7 @@ class MapValuesFunction : public MapKeyValueFunction {
     VELOX_CHECK(
         arg->typeKind() == TypeKind::MAP,
         "Unsupported type for map_values function {}",
-        mapTypeKindToName(arg->typeKind()));
+        TypeKindName::toName(arg->typeKind()));
 
     auto mapVector = arg->as<MapVector>();
     auto mapValues = mapVector->mapValues();
diff --git a/velox/functions/prestosql/MapKeysOverlap.h b/velox/functions/prestosql/MapKeysOverlap.h
new file mode 100644
index 000000000000..a18e3a766e15
--- /dev/null
+++ b/velox/functions/prestosql/MapKeysOverlap.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/expression/ComplexViewTypes.h"
+#include "velox/functions/Udf.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec, typename Key>
+struct MapKeysOverlapPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<bool>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& keys) {
+    if (inputMap.empty() || keys.empty()) {
+      out = false;
+      return;
+    }
+
+    folly::F14FastSet<arg_type<Key>> keySet;
+
+    for (const auto& key : keys) {
+      if (key.has_value()) {
+        keySet.insert(key.value());
+      }
+    }
+
+    for (const auto& entry : inputMap) {
+      if (keySet.find(entry.first) != keySet.end()) {
+        out = true;
+        return;
+      }
+    }
+
+    out = false;
+  }
+};
+
+template <typename TExec>
+struct MapKeysOverlapVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<bool>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& keys) {
+    if (inputMap.empty() || keys.empty()) {
+      out = false;
+      return;
+    }
+
+    folly::F14FastSet<StringView> keySet;
+
+    for (const auto& key : keys) {
+      if (key.has_value()) {
+        keySet.insert(key.value());
+      }
+    }
+
+    for (const auto& entry : inputMap) {
+      if (keySet.find(entry.first) != keySet.end()) {
+        out = true;
+        return;
+      }
+    }
+
+    out = false;
+  }
+};
+
+struct MapKeysOverlapFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    // If comparison returns indeterminate (null), treat as not equal
+    if (!result.has_value()) {
+      return false;
+    }
+
+    return result.value() == 0;
+  }
+};
+
+template <typename TExec>
+struct MapKeysOverlapFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<bool>& out,
+      const arg_type<Map<Generic<T1>, Generic<T2>>>& inputMap,
+      const arg_type<Array<Generic<T1>>>& keys) {
+    if (inputMap.empty() || keys.empty()) {
+      out = false;
+      return;
+    }
+
+    searchKeys_.clear();
+    for (const auto& key : keys) {
+      if (key.has_value()) {
+        searchKeys_.emplace(key.value());
+      }
+    }
+
+    if (searchKeys_.empty()) {
+      out = false;
+      return;
+    }
+
+    for (const auto& entry : inputMap) {
+      if (searchKeys_.contains(entry.first)) {
+        out = true;
+        return;
+      }
+    }
+
+    out = false;
+  }
+
+ private:
+  folly::F14FastSet<
+      exec::GenericView,
+      std::hash<exec::GenericView>,
+      MapKeysOverlapFunctionEqualComparator>
+      searchKeys_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapSubset.cpp b/velox/functions/prestosql/MapSubset.cpp
new file mode 100644
index 000000000000..d446f535634f
--- /dev/null
+++ b/velox/functions/prestosql/MapSubset.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/functions/prestosql/MapSubset.h"
+#include "velox/functions/Registerer.h"
+
+namespace facebook::velox::functions {
+template <typename T>
+void registerMapSubsetPrimitive(const std::string& name) {
+  registerFunction<
+      ParameterBinder<MapSubsetPrimitiveFunction, T>,
+      Map<T, Generic<T1>>,
+      Map<T, Generic<T1>>,
+      Array<T>>({name});
+}
+
+void registerMapSubset(const std::string& name) {
+  registerMapSubsetPrimitive<bool>(name);
+  registerMapSubsetPrimitive<int8_t>(name);
+  registerMapSubsetPrimitive<int16_t>(name);
+  registerMapSubsetPrimitive<int32_t>(name);
+  registerMapSubsetPrimitive<int64_t>(name);
+  registerMapSubsetPrimitive<float>(name);
+  registerMapSubsetPrimitive<double>(name);
+  registerMapSubsetPrimitive<Timestamp>(name);
+  registerMapSubsetPrimitive<Date>(name);
+
+  registerFunction<
+      MapSubsetVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>>({name});
+
+  registerFunction<
+      MapSubsetFunction,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>>({name});
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapSubset.h b/velox/functions/prestosql/MapSubset.h
index 007cd59c8898..4c39f60bd519 100644
--- a/velox/functions/prestosql/MapSubset.h
+++ b/velox/functions/prestosql/MapSubset.h
@@ -15,8 +15,9 @@
  */
 #pragma once
 
+#include "velox/core/QueryConfig.h"
 #include "velox/expression/ComplexViewTypes.h"
-#include "velox/functions/Udf.h"
+#include "velox/functions/Macros.h"
 #include "velox/type/FloatingPointUtil.h"
 
 namespace facebook::velox::functions {
@@ -234,4 +235,6 @@ struct MapSubsetFunction {
       searchKeys_;
 };
 
+void registerMapSubset(const std::string& name);
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/MapZipWith.cpp b/velox/functions/prestosql/MapZipWith.cpp
index 81718d7918c3..2cdd951d8a85 100644
--- a/velox/functions/prestosql/MapZipWith.cpp
+++ b/velox/functions/prestosql/MapZipWith.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include <optional>
-#include "velox/expression/Expr.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
@@ -207,7 +207,7 @@ class MapZipWithFunction : public exec::VectorFunction {
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
     // map(K, V1), map(K, V2), function(K, V1, V2, V3) -> map(K, V3)
     return {exec::FunctionSignatureBuilder()
-                .knownTypeVariable("K")
+                .typeVariable("K")
                 .typeVariable("V1")
                 .typeVariable("V2")
                 .typeVariable("V3")
diff --git a/velox/functions/prestosql/Probability.h b/velox/functions/prestosql/Probability.h
index 6a2173c925ce..8e9c0957f3eb 100644
--- a/velox/functions/prestosql/Probability.h
+++ b/velox/functions/prestosql/Probability.h
@@ -18,6 +18,7 @@
 #include <boost/math/distributions.hpp>
 #include <boost/math/distributions/cauchy.hpp>
 #include <boost/math/distributions/laplace.hpp>
+#include <boost/math/distributions/students_t.hpp>
 #include <boost/math/distributions/weibull.hpp>
 #include "boost/math/distributions/beta.hpp"
 #include "boost/math/distributions/binomial.hpp"
@@ -97,6 +98,11 @@ struct BinomialCDFFunction {
       return;
     }
 
+    if (value >= numOfTrials) {
+      result = 1.0;
+      return;
+    }
+
     boost::math::binomial_distribution<> dist(numOfTrials, successProb);
     result = boost::math::cdf(dist, value);
   }
@@ -407,5 +413,96 @@ struct InversePoissonCDFFunction {
   }
 };
 
+template <typename T>
+struct InverseFCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void
+  call(double& result, double df1, double df2, double p) {
+    static constexpr double kInf = std::numeric_limits<double>::infinity();
+
+    VELOX_USER_CHECK(
+        p >= 0 && p <= 1 && p != kInf,
+        "inverseFCdf Function: p must be in the interval [0, 1]");
+    VELOX_USER_CHECK(
+        df1 > 0 && df1 != kInf,
+        "inverseFCdf Function: numerator df must be greater than 0");
+    VELOX_USER_CHECK(
+        df2 > 0 && df2 != kInf,
+        "inverseFCdf Function: denominator df must be greater than 0");
+
+    if (p == 0.0) {
+      result = 0.0;
+      return;
+    } else if (p == 1.0) {
+      result = std::numeric_limits<double>::infinity();
+      return;
+    }
+    boost::math::fisher_f_distribution<> dist(df1, df2);
+    result = boost::math::quantile(dist, p);
+  }
+};
+
+template <typename T>
+struct InverseChiSquaredCdf {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(double& result, double df, double p) {
+    static constexpr double kInf = std::numeric_limits<double>::infinity();
+
+    VELOX_USER_CHECK(
+        p >= 0 && p <= 1 && p != kInf,
+        "inverseChiSquaredCdf Function: p must be in the interval [0, 1]");
+    VELOX_USER_CHECK(
+        df > 0 && df != kInf,
+        "inverseChiSquaredCdf Function: df must be greater than 0");
+
+    if (p == 0.0) {
+      result = 0.0;
+      return;
+    } else if (p == 1.0) {
+      result = std::numeric_limits<double>::infinity();
+      return;
+    }
+    boost::math::chi_squared_distribution<> dist(df);
+    result = boost::math::quantile(dist, p);
+  }
+};
+
+template <typename T>
+struct TCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(double& result, double df, double value) {
+    VELOX_USER_CHECK_GT(df, 0, "df must be greater than 0");
+
+    boost::math::students_t_distribution<> dist(df);
+    result = boost::math::cdf(dist, value);
+  }
+};
+
+template <typename T>
+struct InverseTCDFFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(double& result, double df, double p) {
+    static constexpr double kInf = std::numeric_limits<double>::infinity();
+
+    VELOX_USER_CHECK_GT(df, 0, "df must be greater than 0");
+    VELOX_USER_CHECK(
+        p >= 0 && p <= 1 && p != kInf, "p must be in the interval [0, 1]");
+
+    if (p == 0.0) {
+      result = -std::numeric_limits<double>::infinity();
+      return;
+    } else if (p == 1.0) {
+      result = std::numeric_limits<double>::infinity();
+      return;
+    }
+    boost::math::students_t_distribution<> dist(df);
+    result = boost::math::quantile(dist, p);
+  }
+};
+
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/QDigestFunctions.h b/velox/functions/prestosql/QDigestFunctions.h
new file mode 100644
index 000000000000..071783a9b637
--- /dev/null
+++ b/velox/functions/prestosql/QDigestFunctions.h
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/lib/QuantileDigest.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+
+namespace facebook::velox::functions {
+
+template <typename TExec>
+struct ValueAtQuantileFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<double>& result,
+      const arg_type<SimpleQDigest<double>>& input,
+      const arg_type<double>& quantile) {
+    callImpl<double>(result, input, quantile);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<int64_t>& result,
+      const arg_type<SimpleQDigest<int64_t>>& input,
+      const arg_type<double>& quantile) {
+    callImpl<int64_t>(result, input, quantile);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<float>& result,
+      const arg_type<SimpleQDigest<float>>& input,
+      const arg_type<double>& quantile) {
+    callImpl<float>(result, input, quantile);
+  }
+
+ private:
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void callImpl(
+      out_type<T>& result,
+      const arg_type<SimpleQDigest<T>>& input,
+      const arg_type<double>& quantile) {
+    VELOX_USER_CHECK(
+        quantile >= 0.0 && quantile <= 1.0,
+        "Quantile must be between 0 and 1, got: {}",
+        quantile);
+
+    std::allocator<T> allocator;
+    qdigest::QuantileDigest<T, std::allocator<T>> digest(
+        allocator, input.data());
+    result = digest.estimateQuantile(quantile);
+  }
+};
+
+template <typename TExec>
+struct ValuesAtQuantilesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Array<double>>& result,
+      const arg_type<SimpleQDigest<double>>& input,
+      const arg_type<Array<double>>& quantiles) {
+    callImpl<double>(result, input, quantiles);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Array<int64_t>>& result,
+      const arg_type<SimpleQDigest<int64_t>>& input,
+      const arg_type<Array<double>>& quantiles) {
+    callImpl<int64_t>(result, input, quantiles);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Array<float>>& result,
+      const arg_type<SimpleQDigest<float>>& input,
+      const arg_type<Array<double>>& quantiles) {
+    callImpl<float>(result, input, quantiles);
+  }
+
+ private:
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void callImpl(
+      out_type<Array<T>>& result,
+      const arg_type<SimpleQDigest<T>>& input,
+      const arg_type<Array<double>>& quantiles) {
+    std::allocator<T> allocator;
+    qdigest::QuantileDigest<T, std::allocator<T>> digest(
+        allocator, input.data());
+
+    result.reserve(quantiles.size());
+    for (size_t i = 0; i < quantiles.size(); ++i) {
+      VELOX_USER_CHECK(
+          quantiles[i].has_value(), "All quantiles should be non - null.");
+      double quantile = quantiles[i].value();
+      VELOX_USER_CHECK(
+          quantile >= 0.0 && quantile <= 1.0,
+          "Quantile must be between 0 and 1, got: {}",
+          quantile);
+      result.push_back(digest.estimateQuantile(quantile));
+    }
+  }
+};
+
+template <typename TExec>
+struct QuantileAtValueFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SimpleQDigest<double>>& input,
+      const arg_type<double>& value) {
+    return callImpl<double>(result, input, value);
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SimpleQDigest<int64_t>>& input,
+      const arg_type<int64_t>& value) {
+    return callImpl<int64_t>(result, input, value);
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<double>& result,
+      const arg_type<SimpleQDigest<float>>& input,
+      const arg_type<float>& value) {
+    return callImpl<float>(result, input, value);
+  }
+
+ private:
+  template <typename T>
+  FOLLY_ALWAYS_INLINE bool callImpl(
+      out_type<double>& result,
+      const arg_type<SimpleQDigest<T>>& input,
+      const arg_type<T>& value) {
+    std::allocator<T> allocator;
+    qdigest::QuantileDigest<T, std::allocator<T>> digest(
+        allocator, input.data());
+
+    auto quantile = digest.quantileAtValue(value);
+    if (quantile.has_value()) {
+      result = quantile.value();
+      return true;
+    }
+    return false; // Return false for null result when value is out of range
+  }
+};
+
+struct ScaleQDigestBase {
+ protected:
+  template <typename T, typename ResultT, typename InputT>
+  FOLLY_ALWAYS_INLINE void
+  callImpl(ResultT& result, const InputT& input, double scaleFactor) {
+    std::allocator<T> allocator;
+    qdigest::QuantileDigest<T, std::allocator<T>> digest(
+        allocator, input.data());
+    digest.scale(scaleFactor);
+    int64_t size = digest.serializedByteSize();
+    result.resize(size);
+    digest.serialize(result.data());
+  }
+};
+
+template <typename TExec>
+struct ScaleQDigestDoubleFunction : public ScaleQDigestBase {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<SimpleQDigest<double>>& result,
+      const arg_type<SimpleQDigest<double>>& input,
+      const arg_type<double>& scaleFactor) {
+    this->template callImpl<double>(result, input, scaleFactor);
+  }
+};
+
+template <typename TExec>
+struct ScaleQDigestBigintFunction : public ScaleQDigestBase {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<SimpleQDigest<int64_t>>& result,
+      const arg_type<SimpleQDigest<int64_t>>& input,
+      const arg_type<double>& scaleFactor) {
+    this->template callImpl<int64_t>(result, input, scaleFactor);
+  }
+};
+
+template <typename TExec>
+struct ScaleQDigestRealFunction : public ScaleQDigestBase {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<SimpleQDigest<float>>& result,
+      const arg_type<SimpleQDigest<float>>& input,
+      const arg_type<double>& scaleFactor) {
+    this->template callImpl<float>(result, input, scaleFactor);
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/Reduce.cpp b/velox/functions/prestosql/Reduce.cpp
index d65bb5354ec0..f73e2d85be8c 100644
--- a/velox/functions/prestosql/Reduce.cpp
+++ b/velox/functions/prestosql/Reduce.cpp
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 #include "velox/common/base/RuntimeMetrics.h"
+#include "velox/core/Expressions.h"
+#include "velox/expression/ExprConstants.h"
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/LambdaFunctionUtil.h"
 
@@ -324,19 +327,13 @@ core::TypedExprPtr toArraySum(
   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");
+      ARRAY(expr->type()), prefix + "transform", reduce.inputs()[0], lambda);
   auto arraySum = std::make_shared<core::CallTypedExpr>(
-      sumType,
-      std::vector<core::TypedExprPtr>({transform}),
-      prefix + "array_sum_propagate_element_null");
+      sumType, prefix + "array_sum_propagate_element_null", transform);
   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");
+      initial->type(), prefix + "plus", initial, cast);
   VLOG(1) << "Rewrite expression: " << reduce.toString() << " => "
           << plus->toString();
   addThreadLocalRuntimeStat("numReduceRewrite", RuntimeCounter(1));
@@ -392,11 +389,10 @@ core::TypedExprPtr rewriteReduce(
       return nullptr;
     }
     auto minus = std::make_shared<core::CallTypedExpr>(
-        fx->type(),
-        std::vector<core::TypedExprPtr>({fx, inputBody->inputs()[1]}),
-        prefix + "minus");
+        fx->type(), prefix + "minus", fx, inputBody->inputs()[1]);
     return toArraySum(prefix, *reduce, inputArgs, minus);
-  } else if (inputBody->name() == "if" && inputBody->inputs().size() == 3) {
+  } else if (
+      inputBody->name() == expression::kIf && 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);
@@ -408,9 +404,7 @@ core::TypedExprPtr rewriteReduce(
       return nullptr;
     }
     auto ifExpr = std::make_shared<core::CallTypedExpr>(
-        fx->type(),
-        std::vector<core::TypedExprPtr>({inputBody->inputs()[0], fx, gx}),
-        "if");
+        fx->type(), expression::kIf, inputBody->inputs()[0], fx, gx);
     return toArraySum(prefix, *reduce, inputArgs, ifExpr);
   }
   return nullptr;
@@ -430,7 +424,7 @@ VELOX_DECLARE_VECTOR_FUNCTION_WITH_METADATA(
     std::make_unique<ReduceFunction>());
 
 void registerReduceRewrites(const std::string& prefix) {
-  exec::registerExpressionRewrite(
+  expression::ExprRewriteRegistry::instance().registerRewrite(
       [prefix](const auto& expr) { return rewriteReduce(prefix, expr); });
 }
 
diff --git a/velox/functions/prestosql/RegexpSplit.h b/velox/functions/prestosql/RegexpSplit.h
new file mode 100644
index 000000000000..bd379d4ca8a0
--- /dev/null
+++ b/velox/functions/prestosql/RegexpSplit.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
+
+namespace facebook::velox::functions {
+template <typename TExec>
+struct Re2RegexpSplit {
+  Re2RegexpSplit() : cache_(0) {}
+
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Varchar>* /*string*/,
+      const arg_type<Varchar>* /*pattern*/) {
+    cache_.setMaxCompiledRegexes(config.exprMaxCompiledRegexes());
+  }
+
+  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;
+    size_t lastEnd = 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() + lastEnd, offset - lastEnd));
+
+      lastEnd = offset + size;
+      if (UNLIKELY(size == 0)) {
+        pos = lastEnd + 1;
+      } else {
+        pos = lastEnd;
+      }
+    }
+
+    if (LIKELY(pos <= string.size())) {
+      out.add_item().setNoCopy(
+          StringView(string.data() + pos, string.size() - pos));
+    } else {
+      static const StringView kEmptyString(nullptr, 0);
+      out.add_item().setNoCopy(kEmptyString);
+    }
+  }
+
+ private:
+  detail::ReCache cache_;
+};
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/RemapKeys.h b/velox/functions/prestosql/RemapKeys.h
new file mode 100644
index 000000000000..1bb6c5c30d9a
--- /dev/null
+++ b/velox/functions/prestosql/RemapKeys.h
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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.
+template <typename TExec, typename Key>
+struct RemapKeysPrimitiveFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  void call(
+      out_type<Map<Key, Generic<T1>>>& out,
+      const arg_type<Map<Key, Generic<T1>>>& inputMap,
+      const arg_type<Array<Key>>& oldKeys,
+      const arg_type<Array<Key>>& newKeys) {
+    if (inputMap.empty()) {
+      return;
+    }
+
+    // Build mapping from old keys to new keys
+    folly::F14FastMap<arg_type<Key>, arg_type<Key>> keyMapping;
+
+    // The old and new key arrays don't need to be the same size.
+    // If they differ, we only process up to the shorter array's length.
+    auto oldKeysSize = oldKeys.size();
+    auto newKeysSize = newKeys.size();
+    auto minSize = std::min(oldKeysSize, newKeysSize);
+
+    auto oldIt = oldKeys.begin();
+    auto newIt = newKeys.begin();
+
+    for (size_t i = 0; i < minSize; ++i, ++oldIt, ++newIt) {
+      if (oldIt->has_value() && newIt->has_value()) {
+        keyMapping[oldIt->value()] = newIt->value();
+      }
+    }
+
+    // Iterate through input map and remap keys
+    for (const auto& entry : inputMap) {
+      auto it = keyMapping.find(entry.first);
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        if (it != keyMapping.end()) {
+          keyWriter = it->second;
+        } else {
+          keyWriter = entry.first;
+        }
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        if (it != keyMapping.end()) {
+          keyWriter = it->second;
+        } else {
+          keyWriter = entry.first;
+        }
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+/// String version that avoids copy of strings.
+template <typename TExec>
+struct RemapKeysVarcharFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  static constexpr int32_t reuse_strings_from_arg = 0;
+
+  void call(
+      out_type<Map<Varchar, Generic<T1>>>& out,
+      const arg_type<Map<Varchar, Generic<T1>>>& inputMap,
+      const arg_type<Array<Varchar>>& oldKeys,
+      const arg_type<Array<Varchar>>& newKeys) {
+    if (inputMap.empty()) {
+      return;
+    }
+
+    // Build mapping from old keys to new keys
+    folly::F14FastMap<StringView, StringView> keyMapping;
+
+    auto oldKeysSize = oldKeys.size();
+    auto newKeysSize = newKeys.size();
+    auto minSize = std::min(oldKeysSize, newKeysSize);
+
+    auto oldIt = oldKeys.begin();
+    auto newIt = newKeys.begin();
+
+    for (size_t i = 0; i < minSize; ++i, ++oldIt, ++newIt) {
+      if (oldIt->has_value() && newIt->has_value()) {
+        keyMapping[oldIt->value()] = newIt->value();
+      }
+    }
+
+    // Iterate through input map and remap keys
+    for (const auto& entry : inputMap) {
+      auto it = keyMapping.find(entry.first);
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        if (it != keyMapping.end()) {
+          // Key is remapped - must copy from newKeys array
+          keyWriter.copy_from(it->second);
+        } else {
+          // Key is not remapped - can reuse from inputMap
+          keyWriter.setNoCopy(entry.first);
+        }
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        if (it != keyMapping.end()) {
+          // Key is remapped - must copy from newKeys array
+          keyWriter.copy_from(it->second);
+        } else {
+          // Key is not remapped - can reuse from inputMap
+          keyWriter.setNoCopy(entry.first);
+        }
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+struct RemapKeysFunctionEqualComparator {
+  bool operator()(const exec::GenericView& lhs, const exec::GenericView& rhs)
+      const {
+    static constexpr auto kEqualValueAtFlags = CompareFlags::equality(
+        CompareFlags::NullHandlingMode::kNullAsIndeterminate);
+
+    auto result = lhs.compare(rhs, kEqualValueAtFlags);
+
+    VELOX_USER_CHECK(
+        result.has_value(), "Comparison on null elements is not supported");
+
+    return result.value() == 0;
+  }
+};
+
+struct RemapKeysFunctionHasher {
+  size_t operator()(const exec::GenericView& value) const {
+    return value.hash();
+  }
+};
+
+/// Generic implementation for complex types.
+template <typename TExec>
+struct RemapKeysFunction {
+  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>>>& oldKeys,
+      const arg_type<Array<Generic<T1>>>& newKeys) {
+    if (inputMap.empty()) {
+      return;
+    }
+
+    auto oldKeysSize = oldKeys.size();
+    auto newKeysSize = newKeys.size();
+    auto minSize = std::min(oldKeysSize, newKeysSize);
+
+    // Iterate through input map and remap keys
+    for (const auto& entry : inputMap) {
+      std::optional<size_t> matchIndex;
+
+      // Search for matching old key
+      auto oldIt = oldKeys.begin();
+      for (size_t i = 0; i < minSize; ++i, ++oldIt) {
+        if (oldIt->has_value()) {
+          RemapKeysFunctionEqualComparator comparator;
+          if (comparator(entry.first, oldIt->value())) {
+            matchIndex = i;
+            break;
+          }
+        }
+      }
+
+      if (!entry.second.has_value()) {
+        auto& keyWriter = out.add_null();
+        if (matchIndex.has_value()) {
+          auto newIt = newKeys.begin();
+          std::advance(newIt, matchIndex.value());
+          if (newIt->has_value()) {
+            keyWriter.copy_from(newIt->value());
+          } else {
+            keyWriter.copy_from(entry.first);
+          }
+        } else {
+          keyWriter.copy_from(entry.first);
+        }
+      } else {
+        auto [keyWriter, valueWriter] = out.add_item();
+        if (matchIndex.has_value()) {
+          auto newIt = newKeys.begin();
+          std::advance(newIt, matchIndex.value());
+          if (newIt->has_value()) {
+            keyWriter.copy_from(newIt->value());
+          } else {
+            keyWriter.copy_from(entry.first);
+          }
+        } else {
+          keyWriter.copy_from(entry.first);
+        }
+        valueWriter.copy_from(entry.second.value());
+      }
+    }
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SetDigestFunctions.h b/velox/functions/prestosql/SetDigestFunctions.h
new file mode 100644
index 000000000000..1e981e7abddc
--- /dev/null
+++ b/velox/functions/prestosql/SetDigestFunctions.h
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/lib/SetDigest.h"
+
+namespace facebook::velox::functions {
+
+/// Scalar function: cardinality(setdigest) -> bigint
+/// Returns the estimated cardinality of the set digest.
+template <typename T>
+struct CardinalitySetDigestFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Varbinary>* /*input*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool, "cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<int64_t>& result, const arg_type<Varbinary>& input) {
+    SetDigest<int64_t> digest(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest.deserialize(input.data(), input.size()));
+    result = digest.cardinality();
+    return Status::OK();
+  }
+};
+
+/// Scalar function: intersection_cardinality(setdigest, setdigest) -> bigint
+/// Returns the intersection cardinality between two set digests.
+/// - If both digests are exact: returns exact intersection count
+/// - If either digest is approximate: returns estimated intersection using
+/// Jaccard index
+template <typename T>
+struct IntersectionCardinalityFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Varbinary>* /*input1*/,
+      const arg_type<Varbinary>* /*input2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool,
+        "intersection_cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<int64_t>& result,
+      const arg_type<Varbinary>& input1,
+      const arg_type<Varbinary>& input2) {
+    using SetDigestType = SetDigest<int64_t>;
+
+    SetDigestType digest1(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest1.deserialize(input1.data(), input1.size()));
+
+    SetDigestType digest2(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest2.deserialize(input2.data(), input2.size()));
+
+    // If both are exact, use exact intersection
+    if (digest1.isExact() && digest2.isExact()) {
+      result = SetDigestType::exactIntersectionCardinality(digest1, digest2);
+      return Status::OK();
+    }
+
+    // Otherwise, estimate using Jaccard index (matching Java behavior)
+    int64_t cardinality1 = digest1.cardinality();
+    int64_t cardinality2 = digest2.cardinality();
+    double jaccard = SetDigestType::jaccardIndex(digest1, digest2);
+    digest1.mergeWith(digest2);
+    int64_t estimatedIntersection =
+        std::llround(jaccard * digest1.cardinality());
+
+    // When one set is much smaller and approaches being a subset of the other,
+    // the computed cardinality may exceed the smaller set's cardinality.
+    // In this case, the smaller cardinality is a better estimate.
+    result =
+        std::min(estimatedIntersection, std::min(cardinality1, cardinality2));
+    return Status::OK();
+  }
+};
+
+/// Scalar function: jaccard_index(setdigest, setdigest) -> double
+/// Returns the Jaccard index (similarity coefficient) between two set digests.
+/// The Jaccard index is a value in [0, 1] where:
+/// - 1.0 means the sets are identical
+/// - 0.0 means the sets are disjoint (no overlap)
+/// Uses MinHash estimation for efficient computation.
+template <typename T>
+struct JaccardIndexFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Varbinary>* /*input1*/,
+      const arg_type<Varbinary>* /*input2*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool, "jaccard_index requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<double>& result,
+      const arg_type<Varbinary>& input1,
+      const arg_type<Varbinary>& input2) {
+    using SetDigestType = SetDigest<int64_t>;
+
+    SetDigestType digest1(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest1.deserialize(input1.data(), input1.size()));
+
+    SetDigestType digest2(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest2.deserialize(input2.data(), input2.size()));
+
+    result = SetDigestType::jaccardIndex(digest1, digest2);
+    return Status::OK();
+  }
+};
+
+/// Scalar function: hash_counts(setdigest) -> map(bigint, smallint)
+/// Returns a map of hash values to their occurrence counts.
+/// This exposes the MinHash component of the SetDigest, showing which
+/// hash values were tracked and how many times each value was added.
+/// Only available when the digest is exact (cardinality < maxHashes).
+template <typename T>
+struct HashCountsFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Varbinary>* /*input*/) {
+    VELOX_CHECK_NOT_NULL(
+        pool, "hash_counts requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE Status call(
+      out_type<Map<int64_t, int16_t>>& result,
+      const arg_type<Varbinary>& input) {
+    SetDigest<int64_t> digest(allocator_.get());
+    VELOX_RETURN_NOT_OK(digest.deserialize(input.data(), input.size()));
+
+    auto hashCounts = digest.getHashCounts();
+    result.reserve(hashCounts.size());
+
+    for (const auto& [key, value] : hashCounts) {
+      auto item = result.add_item();
+      std::get<0>(item) = key;
+      std::get<1>(item) = value;
+    }
+
+    return Status::OK();
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SfmSketchFunctions.cpp b/velox/functions/prestosql/SfmSketchFunctions.cpp
new file mode 100644
index 000000000000..fd022675cc14
--- /dev/null
+++ b/velox/functions/prestosql/SfmSketchFunctions.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/prestosql/SfmSketchFunctions.h"
+#include "velox/functions/lib/sfm/SfmSketch.h"
+
+namespace facebook::velox::functions {
+
+std::string createEmptySfmSketch(
+    HashStringAllocator* allocator,
+    double epsilon,
+    std::optional<int64_t> buckets,
+    std::optional<int64_t> precison) {
+  using SfmSketch = facebook::velox::functions::sfm::SfmSketch;
+
+  constexpr int64_t kDefaultBuckets = 4096;
+  constexpr int64_t kDefaultPrecision = 24;
+
+  int64_t initBuckets = buckets.has_value() ? buckets.value() : kDefaultBuckets;
+  int64_t initPrecision =
+      precison.has_value() ? precison.value() : kDefaultPrecision;
+  SfmSketch sketch(allocator);
+  sketch.initialize(
+      static_cast<int32_t>(initBuckets), static_cast<int32_t>(initPrecision));
+  sketch.enablePrivacy(epsilon);
+
+  // Serialize the sketch.
+  auto serializedSize = sketch.serializedSize();
+  std::string result(serializedSize, '\0');
+  sketch.serialize(result.data());
+
+  return result;
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SfmSketchFunctions.h b/velox/functions/prestosql/SfmSketchFunctions.h
new file mode 100644
index 000000000000..7f117c4c3d60
--- /dev/null
+++ b/velox/functions/prestosql/SfmSketchFunctions.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/memory/HashStringAllocator.h"
+#include "velox/core/QueryConfig.h"
+#include "velox/functions/Macros.h"
+#include "velox/functions/lib/sfm/SfmSketch.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
+
+namespace facebook::velox::functions {
+
+// Helper function to create empty SfmSketch.
+std::string createEmptySfmSketch(
+    HashStringAllocator* allocator,
+    double epsilon,
+    std::optional<int64_t> buckets = std::nullopt,
+    std::optional<int64_t> precison = std::nullopt);
+
+template <typename T>
+struct SfmSketchCardinality {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<SfmSketch>* /*input*/) {
+    VELOX_USER_CHECK_NOT_NULL(
+        pool,
+        "sfm_sketch_cardinality requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<SfmSketch>& input) {
+    using SfmSketch = facebook::velox::functions::sfm::SfmSketch;
+    result = SfmSketch::deserialize(
+                 reinterpret_cast<const char*>(input.data()), allocator_.get())
+                 .cardinality();
+  }
+};
+
+template <typename T>
+struct NoisyEmptyApproxSetSfm {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const double* /*epsilon*/,
+      const int64_t* /*buckets*/ = nullptr,
+      const int64_t* /*precision*/ = nullptr) {
+    VELOX_USER_CHECK_NOT_NULL(
+        pool,
+        "noisy_empty_approx_set_sfm requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<SfmSketch>& result,
+      const double& epsilon) {
+    auto serialized = createEmptySfmSketch(allocator_.get(), epsilon);
+    result.resize(serialized.size());
+    // SfmSketch is a binary type, so we can just copy the serialized data.
+    memcpy(result.data(), serialized.data(), serialized.size());
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<SfmSketch>& result,
+      const double& epsilon,
+      const int64_t& buckets) {
+    auto serialized = createEmptySfmSketch(allocator_.get(), epsilon, buckets);
+    result.resize(serialized.size());
+    memcpy(result.data(), serialized.data(), serialized.size());
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<SfmSketch>& result,
+      const double& epsilon,
+      const int64_t& buckets,
+      const int64_t& precision) {
+    auto serialized =
+        createEmptySfmSketch(allocator_.get(), epsilon, buckets, precision);
+    result.resize(serialized.size());
+    memcpy(result.data(), serialized.data(), serialized.size());
+  }
+};
+
+template <typename T>
+struct mergeSfmSketchArray {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  std::unique_ptr<HashStringAllocator> allocator_;
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& /*config*/,
+      memory::MemoryPool* pool,
+      const arg_type<Array<SfmSketch>>* /*input*/) {
+    VELOX_USER_CHECK_NOT_NULL(
+        pool, "merge_sfm requires MemoryPool for HashStringAllocator");
+    allocator_ = std::make_unique<HashStringAllocator>(pool);
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<SfmSketch>& result,
+      const arg_type<Array<SfmSketch>>& input) {
+    if (input.size() == 0) {
+      return false;
+    }
+
+    using SfmSketch = facebook::velox::functions::sfm::SfmSketch;
+
+    // Collect all non-null sketches.
+    std::vector<const char*> validSketches;
+    for (auto i = 0; i < input.size(); ++i) {
+      if (input[i].has_value()) {
+        const auto& value = input[i].value();
+        validSketches.push_back(reinterpret_cast<const char*>(value.data()));
+      }
+    }
+
+    if (validSketches.empty()) {
+      return false;
+    }
+
+    auto mergedSketch =
+        SfmSketch::deserialize(validSketches[0], allocator_.get());
+
+    for (size_t i = 1; i < validSketches.size(); ++i) {
+      mergedSketch.mergeWith(
+          SfmSketch::deserialize(validSketches[i], allocator_.get()));
+    }
+
+    // Serialize the merged sketch back to result.
+    auto serializedSize = mergedSketch.serializedSize();
+    result.resize(serializedSize);
+    mergedSketch.serialize(result.data());
+
+    return true;
+  }
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SimpleComparisonMatcher.cpp b/velox/functions/prestosql/SimpleComparisonMatcher.cpp
deleted file mode 100644
index db194840b08d..000000000000
--- a/velox/functions/prestosql/SimpleComparisonMatcher.cpp
+++ /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.
- */
-
-#include "velox/functions/prestosql/SimpleComparisonMatcher.h"
-#include "velox/vector/ConstantVector.h"
-
-namespace facebook::velox::functions::prestosql {
-
-namespace {
-
-class Matcher {
- public:
-  virtual bool match(const core::TypedExprPtr& expr) = 0;
-
-  virtual ~Matcher() = default;
-
-  static bool allMatch(
-      const std::vector<core::TypedExprPtr>& exprs,
-      std::vector<std::shared_ptr<Matcher>>& matchers) {
-    for (auto i = 0; i < exprs.size(); ++i) {
-      if (!matchers[i]->match(exprs[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-using MatcherPtr = std::shared_ptr<Matcher>;
-
-class IfMatcher : public Matcher {
- public:
-  explicit IfMatcher(std::vector<MatcherPtr> inputMatchers)
-      : inputMatchers_{std::move(inputMatchers)} {
-    VELOX_CHECK_EQ(3, inputMatchers_.size());
-  }
-
-  bool match(const core::TypedExprPtr& expr) override {
-    if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
-      if (call->name() == "if" && allMatch(call->inputs(), inputMatchers_)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
- private:
-  std::vector<MatcherPtr> inputMatchers_;
-};
-
-using IfMatcherPtr = std::shared_ptr<IfMatcher>;
-
-class ComparisonMatcher : public Matcher {
- public:
-  ComparisonMatcher(
-      const std::string& prefix,
-      std::vector<MatcherPtr> inputMatchers,
-      std::string* op)
-      : prefix_{prefix}, inputMatchers_{std::move(inputMatchers)}, op_{op} {
-    VELOX_CHECK_EQ(2, inputMatchers_.size());
-  }
-
-  bool match(const core::TypedExprPtr& expr) override {
-    if (auto call = dynamic_cast<const core::CallTypedExpr*>(expr.get())) {
-      const auto& name = call->name();
-      if (name == prefix_ + "eq" || name == prefix_ + "lt" ||
-          name == prefix_ + "gt") {
-        if (allMatch(call->inputs(), inputMatchers_)) {
-          *op_ = name;
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
- private:
-  const std::string prefix_;
-  std::vector<MatcherPtr> inputMatchers_;
-  std::string* op_;
-};
-
-using ComparisonMatcherPtr = std::shared_ptr<ComparisonMatcher>;
-
-class AnySingleInputMatcher : public Matcher {
- public:
-  AnySingleInputMatcher(
-      core::TypedExprPtr* expr,
-      core::FieldAccessTypedExprPtr* input)
-      : expr_{expr}, input_{input} {}
-
-  bool match(const core::TypedExprPtr& expr) override {
-    // Check if 'expr' depends on a single column.
-    std::unordered_set<core::FieldAccessTypedExprPtr> inputs;
-    collectInputs(expr, inputs);
-
-    if (inputs.size() == 1) {
-      *expr_ = expr;
-      *input_ = *inputs.begin();
-      return true;
-    }
-
-    return false;
-  }
-
- private:
-  static void collectInputs(
-      const core::TypedExprPtr& expr,
-      std::unordered_set<core::FieldAccessTypedExprPtr>& inputs) {
-    if (auto field =
-            std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(expr)) {
-      if (field->isInputColumn()) {
-        inputs.insert(field);
-        return;
-      }
-    }
-
-    for (const auto& input : expr->inputs()) {
-      collectInputs(input, inputs);
-    }
-  }
-
-  core::TypedExprPtr* const expr_;
-  core::FieldAccessTypedExprPtr* const input_;
-};
-
-/// Matches constant expression that represents values 1, 0, or -1 of type
-/// BIGINT.
-class ComparisonConstantMatcher : public Matcher {
- public:
-  explicit ComparisonConstantMatcher(int64_t* value) : value_{value} {}
-
-  bool match(const core::TypedExprPtr& expr) override {
-    if (auto constant = asConstant(expr.get())) {
-      auto v = constant.value();
-      if (v == 0 || v == 1 || v == -1) {
-        *value_ = v;
-        return true;
-      }
-    }
-    return false;
-  }
-
- private:
-  static std::optional<int64_t> asConstant(const core::ITypedExpr* expr) {
-    if (auto constant = dynamic_cast<const core::ConstantTypedExpr*>(expr)) {
-      if (constant->hasValueVector()) {
-        auto constantVector =
-            constant->valueVector()->as<SimpleVector<int64_t>>();
-        if (!constantVector->isNullAt(0)) {
-          return constantVector->valueAt(0);
-        }
-      } else {
-        if (!constant->value().isNull()) {
-          if (constant->value().kind() == TypeKind::BIGINT) {
-            return constant->value().value<int64_t>();
-          }
-
-          if (constant->value().kind() == TypeKind::INTEGER) {
-            return constant->value().value<int32_t>();
-          }
-        }
-      }
-    }
-
-    return std::nullopt;
-  }
-
-  int64_t* const value_;
-};
-
-using ComparisonConstantMatcherPtr = std::shared_ptr<ComparisonConstantMatcher>;
-
-MatcherPtr ifelse(
-    const MatcherPtr& condition,
-    const MatcherPtr& thenClause,
-    const MatcherPtr& elseClause) {
-  return std::make_shared<IfMatcher>(
-      std::vector<MatcherPtr>{condition, thenClause, elseClause});
-}
-
-MatcherPtr comparison(
-    const std::string& prefix,
-    const MatcherPtr& left,
-    const MatcherPtr& right,
-    std::string* op) {
-  return std::make_shared<ComparisonMatcher>(
-      prefix, std::vector<MatcherPtr>{left, right}, op);
-}
-
-MatcherPtr anySingleInput(
-    core::TypedExprPtr* expr,
-    core::FieldAccessTypedExprPtr* input) {
-  return std::make_shared<AnySingleInputMatcher>(expr, input);
-}
-
-MatcherPtr comparisonConstant(int64_t* value) {
-  return std::make_shared<ComparisonConstantMatcher>(value);
-}
-
-std::string invert(const std::string& prefix, const std::string& op) {
-  return op == prefix + "lt" ? prefix + "gt" : prefix + "lt";
-}
-
-/// Returns true for a < b -> -1.
-bool isLessThen(
-    const std::string& prefix,
-    const std::string& operation,
-    const core::FieldAccessTypedExprPtr& left,
-    int64_t result,
-    const std::string& inputLeft) {
-  std::string op =
-      (left->name() == inputLeft) ? operation : invert(prefix, operation);
-
-  if (op == prefix + "lt") {
-    return result < 0;
-  }
-
-  return result > 0;
-}
-
-} // namespace
-
-std::optional<SimpleComparison> isSimpleComparison(
-    const std::string& prefix,
-    const core::LambdaTypedExpr& expr) {
-  // First, check the shape of the expression.
-  // if (x(a) < y(b), c1, if (u(c) > v(d), c2, c3))
-  core::FieldAccessTypedExprPtr a, b, c, d;
-  core::TypedExprPtr x, y, u, v;
-  std::string op1, op2;
-  int64_t c1, c2, c3;
-
-  auto matcher = ifelse(
-      comparison(prefix, anySingleInput(&x, &a), anySingleInput(&y, &b), &op1),
-      comparisonConstant(&c1),
-      ifelse(
-          comparison(
-              prefix, anySingleInput(&u, &c), anySingleInput(&v, &d), &op2),
-          comparisonConstant(&c2),
-          comparisonConstant(&c3)));
-
-  if (!matcher->match(expr.body())) {
-    return std::nullopt;
-  }
-
-  // Verify that a != b, c != d.
-  if (a == b || c == d) {
-    return std::nullopt;
-  }
-
-  // Verify that x, y, u, v are the same (except for input column).
-  std::unordered_map<std::string, core::TypedExprPtr> inputMapping;
-  inputMapping.emplace(
-      a->name(),
-      std::make_shared<core::FieldAccessTypedExpr>(a->type(), b->name()));
-  const auto xRewritten = x->rewriteInputNames(inputMapping);
-  if (!(*xRewritten == *y->rewriteInputNames(inputMapping) &&
-        *xRewritten == *u->rewriteInputNames(inputMapping) &&
-        *xRewritten == *v->rewriteInputNames(inputMapping))) {
-    return std::nullopt;
-  }
-
-  // Verify all constants are different.
-  if (c1 == c2 || c2 == c3 || c1 == c3) {
-    return std::nullopt;
-  }
-
-  const auto eq = prefix + "eq";
-
-  // Verify that equality comparisons return zero.
-  // if (x(a) = y(a), 0,..) is good. if (x(a) = y(a), 1,..) is not good.
-  // Also, verify that non-equality comparisons return non-zerp.
-  // if (x(a) < y(a), 1,..) is good. if (x(a) < y(a), 0,..) is not good.
-  if ((op1 == eq && c1 != 0) || (op1 != eq && c1 == 0)) {
-    return std::nullopt;
-  }
-
-  if ((op2 == eq && c2 != 0) || (op2 != eq && c2 == 0)) {
-    return std::nullopt;
-  }
-
-  const auto left = expr.signature()->nameOf(0);
-
-  const auto transform = a->name() == left ? x : y;
-
-  if (op1 == eq) {
-    // if (x(a) = y(b), 0,...)
-    return {{transform, isLessThen(prefix, op2, c, c2, left)}};
-  }
-
-  if (op2 == eq) {
-    return {{transform, isLessThen(prefix, op1, a, c1, left)}};
-  }
-
-  // Make sure op1 and op2 are aligned.
-  auto b1 = isLessThen(prefix, op1, a, c1, left);
-  auto b2 = isLessThen(prefix, op2, c, c2, left);
-  if (b1 != b2) {
-    return std::nullopt;
-  }
-
-  return {{transform, b1}};
-}
-
-} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/SimpleComparisonMatcher.h b/velox/functions/prestosql/SimpleComparisonMatcher.h
deleted file mode 100644
index 05f891345210..000000000000
--- a/velox/functions/prestosql/SimpleComparisonMatcher.h
+++ /dev/null
@@ -1,47 +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"
-
-namespace facebook::velox::functions::prestosql {
-
-struct SimpleComparison {
-  core::TypedExprPtr expr;
-  bool isLessThen;
-};
-
-/// Given a lambda expression, checks it if represents a simple comparator and
-/// returns the summary of the same.
-///
-/// For example, identifies
-///     (x, y) -> if(length(x) < length(y), -1, if(length(x) > length(y), 1, 0))
-/// expression as a "less than" comparison over length(x).
-///
-/// Recognizes different variations of this expression, e.g.
-///
-///     (x, y) -> if(expr(x) = expr(y), 0, if(expr(x) < expr(y), -1, 1))
-///     (x, y) -> if(expr(x) = expr(y), 0, if(expr(y) > expr(x), -1, 1))
-///
-/// Returns std::nullopt if expression is not recognized as a simple comparator.
-///
-/// Can be used to re-write generic lambda expressions passed to array_sort into
-/// simpler ones that can be evaluated more efficiently.
-std::optional<SimpleComparison> isSimpleComparison(
-    const std::string& prefix,
-    const core::LambdaTypedExpr& expr);
-
-} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/Split.cpp b/velox/functions/prestosql/Split.cpp
index 74230cbfc3ff..116ff66aedbc 100644
--- a/velox/functions/prestosql/Split.cpp
+++ b/velox/functions/prestosql/Split.cpp
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/EvalCtx.h"
-#include "velox/expression/Expr.h"
 #include "velox/expression/StringWriter.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/expression/VectorWriters.h"
@@ -42,20 +42,22 @@ class SplitFunction : public exec::VectorFunction {
     std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
 
     // varchar, varchar -> array(varchar)
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .returnType("array(varchar)")
-                                .argumentType("varchar")
-                                .argumentType("varchar")
-                                .build());
+    signatures.emplace_back(
+        exec::FunctionSignatureBuilder()
+            .returnType("array(varchar)")
+            .argumentType("varchar")
+            .argumentType("varchar")
+            .build());
 
     // varchar, varchar, integer|bigint -> array(varchar)
     for (const auto& limitType : {"integer", "bigint"}) {
-      signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                  .returnType("array(varchar)")
-                                  .argumentType("varchar")
-                                  .argumentType("varchar")
-                                  .argumentType(limitType)
-                                  .build());
+      signatures.emplace_back(
+          exec::FunctionSignatureBuilder()
+              .returnType("array(varchar)")
+              .argumentType("varchar")
+              .argumentType("varchar")
+              .argumentType(limitType)
+              .build());
     }
     return signatures;
   }
@@ -85,7 +87,7 @@ class SplitFunction : public exec::VectorFunction {
       default:
         VELOX_FAIL(
             "Unsupported type for 'limit' argument of 'split' function: {}",
-            mapTypeKindToName(limitType));
+            TypeKindName::toName(limitType));
     }
   }
 
diff --git a/velox/functions/prestosql/SplitToMap.cpp b/velox/functions/prestosql/SplitToMap.cpp
index 29360136fee8..16e7d13a3f35 100644
--- a/velox/functions/prestosql/SplitToMap.cpp
+++ b/velox/functions/prestosql/SplitToMap.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/functions/prestosql/SplitToMap.h"
+#include "velox/core/Expressions.h"
 
 namespace facebook::velox::functions {
 
@@ -69,13 +70,11 @@ core::TypedExprPtr rewriteSplitToMapCall(
 
   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");
+      "$internal$split_to_map",
+      call->inputs()[0],
+      call->inputs()[1],
+      call->inputs()[2],
+      std::make_shared<core::ConstantTypedExpr>(BOOLEAN(), keepFirst.value()));
 }
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/SplitToMap.h b/velox/functions/prestosql/SplitToMap.h
index 341e507405fc..08e82213b59e 100644
--- a/velox/functions/prestosql/SplitToMap.h
+++ b/velox/functions/prestosql/SplitToMap.h
@@ -91,16 +91,12 @@ struct SplitToMapFunction {
       std::string_view entryDelimiter,
       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));
+    VELOX_USER_RETURN(entryDelimiter.empty(), "entryDelimiter is empty.");
+    VELOX_USER_RETURN(keyValueDelimiter.empty(), "keyValueDelimiter is empty");
+    VELOX_USER_RETURN_EQ(
+        entryDelimiter,
+        keyValueDelimiter,
+        "entryDelimiter and keyValueDelimiter must not be the same.");
 
     if (input.empty()) {
       return Status::OK();
@@ -149,19 +145,17 @@ struct SplitToMapFunction {
       folly::F14FastMap<std::string_view, std::string_view>& keyValuePairs)
       const {
     const auto delimiterPos = entry.find(keyValueDelimiter, 0);
-
-    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(
+    VELOX_USER_RETURN_EQ(
+        delimiterPos,
+        std::string::npos,
+        "No delimiter found. Key-value delimiter must appear exactly once in each entry. Bad input: '{}'",
+        entry);
+    VELOX_USER_RETURN(
         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));
+        "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);
     const auto value = std::string_view(
diff --git a/velox/functions/prestosql/StringFunctions.cpp b/velox/functions/prestosql/StringFunctions.cpp
index 22207ad5274e..f29bf1581547 100644
--- a/velox/functions/prestosql/StringFunctions.cpp
+++ b/velox/functions/prestosql/StringFunctions.cpp
@@ -27,76 +27,6 @@ namespace facebook::velox::functions {
 using namespace stringCore;
 
 namespace {
-/**
- * Upper and Lower functions have a fast path for ascii where the functions
- * can be applied in place.
- * */
-template <bool isLower /*instantiate for upper or lower*/>
-class UpperLowerTemplateFunction : public exec::VectorFunction {
- private:
-  /// String encoding wrappable function
-  template <bool isAscii>
-  struct ApplyInternal {
-    static void apply(
-        const SelectivityVector& rows,
-        const DecodedVector* decodedInput,
-        FlatVector<StringView>* results) {
-      rows.applyToSelected([&](int row) {
-        auto proxy = exec::StringWriter(results, row);
-        if constexpr (isLower) {
-          stringImpl::lower<isAscii>(
-              proxy, decodedInput->valueAt<StringView>(row));
-        } else {
-          stringImpl::upper<isAscii>(
-              proxy, decodedInput->valueAt<StringView>(row));
-        }
-        proxy.finalize();
-      });
-    }
-  };
-
- public:
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /* outputType */,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    VELOX_CHECK(args.size() == 1);
-    VELOX_CHECK(args[0]->typeKind() == TypeKind::VARCHAR);
-
-    // Read content before calling prepare results
-    BaseVector* inputStringsVector = args[0].get();
-    exec::LocalDecodedVector inputHolder(context, *inputStringsVector, rows);
-    auto decodedInput = inputHolder.get();
-
-    auto ascii = isAscii(inputStringsVector, rows);
-
-    // Not in place path.
-    VectorPtr emptyVectorPtr;
-    prepareFlatResultsVector(result, rows, context, emptyVectorPtr);
-    auto* resultFlatVector = result->as<FlatVector<StringView>>();
-
-    StringEncodingTemplateWrapper<ApplyInternal>::apply(
-        ascii, rows, decodedInput, resultFlatVector);
-  }
-
-  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    // varchar -> varchar
-    return {exec::FunctionSignatureBuilder()
-                .returnType("varchar")
-                .argumentType("varchar")
-                .build()};
-  }
-
-  bool ensureStringEncodingSetAtAllInputs() const override {
-    return true;
-  }
-
-  bool propagateStringEncodingFromAllInputs() const override {
-    return true;
-  }
-};
 
 /**
  * concat(string1, ..., stringN) → varchar
@@ -387,16 +317,6 @@ class Replace : public exec::VectorFunction {
 };
 } // namespace
 
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_upper,
-    UpperLowerTemplateFunction<false /*isLower*/>::signatures(),
-    std::make_unique<UpperLowerTemplateFunction<false /*isLower*/>>());
-
-VELOX_DECLARE_VECTOR_FUNCTION(
-    udf_lower,
-    UpperLowerTemplateFunction<true /*isLower*/>::signatures(),
-    std::make_unique<UpperLowerTemplateFunction<true /*isLower*/>>());
-
 VELOX_DECLARE_STATEFUL_VECTOR_FUNCTION_WITH_METADATA(
     udf_concat,
     ConcatFunction::signatures(),
diff --git a/velox/functions/prestosql/StringFunctions.h b/velox/functions/prestosql/StringFunctions.h
index b076b9a7d17c..037a6226b400 100644
--- a/velox/functions/prestosql/StringFunctions.h
+++ b/velox/functions/prestosql/StringFunctions.h
@@ -33,7 +33,7 @@ struct ChrFunction {
   FOLLY_ALWAYS_INLINE void call(
       out_type<Varchar>& result,
       const int64_t& codePoint) {
-    stringImpl::codePointToString(result, codePoint);
+    result = stringImpl::codePointToString(codePoint);
   }
 };
 
@@ -602,13 +602,14 @@ 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>
+  // Map for holding normalization form options.
+  const static inline std::unordered_map<std::string_view, 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)}};
+          {"NFKD", (UTF8PROC_STABLE | UTF8PROC_DECOMPOSE | UTF8PROC_COMPAT)},
+      };
 
   FOLLY_ALWAYS_INLINE void initialize(
       const std::vector<TypePtr>& /*inputTypes*/,
@@ -616,8 +617,10 @@ struct NormalizeFunction {
       const arg_type<Varchar>* /*string*/,
       const arg_type<Varchar>* form) {
     VELOX_USER_CHECK_NOT_NULL(form);
+
+    // TODO: Remove explicit std::string_view cast.
     VELOX_USER_CHECK_NE(
-        normalizationOptions.count(*form),
+        normalizationOptions.count(std::string_view(*form)),
         0,
         "Normalization form must be one of [NFD, NFC, NFKD, NFKC]");
   }
@@ -646,7 +649,8 @@ struct NormalizeFunction {
         (utf8proc_uint8_t*)string.data(),
         string.size(),
         &output,
-        normalizationOptions.at(form));
+        // TODO: Remove explicit std::string_view cast.
+        normalizationOptions.at(std::string_view(form)));
     if (outputLength < 0) {
       result = string;
     } else {
@@ -660,6 +664,19 @@ struct NormalizeFunction {
   }
 };
 
+/// bit_length(string) → bigint
+/// Returns the length in bits of the input string.
+template <typename T>
+struct BitLengthFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      int64_t& result,
+      const arg_type<Varchar>& input) {
+    result = static_cast<int64_t>(input.size()) * 8;
+  }
+};
+
 /// xxhash64(varchar) → bigint
 /// Return a hash64 of input (Varchar such as string)
 template <typename T>
@@ -672,4 +689,239 @@ struct XxHash64StringFunction {
   }
 };
 
+/// longest_common_prefix(string1, string2) → varchar
+/// Returns the longest common prefix between two strings.
+template <typename T>
+struct LongestCommonPrefixFunction {
+  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>& left,
+      const arg_type<Varchar>& right) {
+    doCall<false>(result, left, right);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    doCall<true>(result, left, right);
+  }
+
+ private:
+  template <bool isAscii>
+  FOLLY_ALWAYS_INLINE void doCall(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    // Validate both strings are valid UTF-8.
+    stringImpl::stringToCodePoints(left);
+    stringImpl::stringToCodePoints(right);
+
+    if constexpr (isAscii) {
+      // Fast path for ASCII: simple byte comparison.
+      const char* leftData = left.data();
+      const char* rightData = right.data();
+      const size_t minLength = std::min(left.size(), right.size());
+
+      size_t commonLength = 0;
+      while (commonLength < minLength &&
+             leftData[commonLength] == rightData[commonLength]) {
+        commonLength++;
+      }
+
+      if (commonLength == 0) {
+        result.setEmpty();
+      } else {
+        result.setNoCopy(StringView(leftData, commonLength));
+      }
+    } else {
+      // Unicode path: lazy codepoint iteration.
+      const char* leftData = left.data();
+      const char* rightData = right.data();
+      const size_t leftLength = left.size();
+      const size_t rightLength = right.size();
+      size_t leftPos = 0;
+      size_t rightPos = 0;
+
+      while (leftPos < leftLength && rightPos < rightLength) {
+        int leftSize = 0;
+        int rightSize = 0;
+        auto codePointLeft = utf8proc_codepoint(
+            leftData + leftPos, leftData + leftLength, leftSize);
+        auto codePointRight = utf8proc_codepoint(
+            rightData + rightPos, rightData + rightLength, rightSize);
+
+        if (codePointLeft != codePointRight) {
+          break;
+        }
+
+        leftPos += leftSize;
+        rightPos += rightSize;
+      }
+
+      if (leftPos == 0) {
+        result.setEmpty();
+      } else {
+        result.setNoCopy(StringView(leftData, leftPos));
+      }
+    }
+  }
+};
+
+/// jarowinkler_similarity(string1, string2) → double
+/// Computes the Jaro-Winkler similarity between two strings.
+template <typename T>
+struct JaroWinklerSimilarityFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+  void call(
+      out_type<double>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    auto leftCodePoints = stringImpl::stringToCodePoints(left);
+    auto rightCodePoints = stringImpl::stringToCodePoints(right);
+
+    // Validate size before checking equality to ensure we throw for
+    // oversized inputs even when they're identical.
+    static const int64_t kMaxCombinedInputSize = 1'000'000;
+    auto combinedInputSize = static_cast<int64_t>(leftCodePoints.size()) *
+        (static_cast<int64_t>(rightCodePoints.size()) - 1);
+    VELOX_USER_CHECK_LE(
+        combinedInputSize,
+        kMaxCombinedInputSize,
+        "The combined inputs for Jaro-Winkler similarity are too large");
+
+    // If the strings are identical (same content), return 1.0.
+    // This is deterministic and handles all cases including empty strings.
+    if (left == right) {
+      result = 1.0;
+      return;
+    }
+
+    doCall<int32_t>(
+        result,
+        leftCodePoints.data(),
+        rightCodePoints.data(),
+        leftCodePoints.size(),
+        rightCodePoints.size());
+  }
+  void callAscii(
+      out_type<double>& result,
+      const arg_type<Varchar>& left,
+      const arg_type<Varchar>& right) {
+    // Validate size before checking equality to ensure we throw for
+    // oversized inputs even when they're identical.
+    static const int64_t kMaxCombinedInputSize = 1'000'000;
+    auto combinedInputSize = static_cast<int64_t>(left.size()) *
+        (static_cast<int64_t>(right.size()) - 1);
+    VELOX_USER_CHECK_LE(
+        combinedInputSize,
+        kMaxCombinedInputSize,
+        "The combined inputs for Jaro-Winkler similarity are too large");
+
+    // If the strings are identical (same content), return 1.0.
+    // This is deterministic and handles all cases including empty strings.
+    if (left == right) {
+      result = 1.0;
+      return;
+    }
+
+    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());
+  }
+
+  template <typename TCodePoint>
+  void doCall(
+      out_type<double>& result,
+      const TCodePoint* leftCodePoints,
+      const TCodePoint* rightCodePoints,
+      size_t leftLength,
+      size_t rightLength) {
+    static const int64_t kMaxCombinedInputSize = 1'000'000;
+    // Cast to int64_t to avoid unsigned underflow
+    auto combinedInputSize = static_cast<int64_t>(leftLength) *
+        (static_cast<int64_t>(rightLength) - 1);
+    VELOX_USER_CHECK_LE(
+        combinedInputSize,
+        kMaxCombinedInputSize,
+        "The combined inputs for Jaro-Winkler similarity are too large");
+
+    int maxDist = std::max(leftLength, rightLength) / 2 - 1;
+    if (maxDist < 0) {
+      maxDist = 0;
+    }
+
+    int match = 0;
+    std::vector<int> leftHash(leftLength, 0);
+    std::vector<int> rightHash(rightLength, 0);
+
+    for (int i = 0; i < leftLength; i++) {
+      for (int j = std::max(0, i - maxDist);
+           j < std::min(static_cast<int>(rightLength), i + maxDist + 1);
+           j++) {
+        if (leftCodePoints[i] == rightCodePoints[j] && rightHash[j] == 0) {
+          leftHash[i] = 1;
+          rightHash[j] = 1;
+          match++;
+          break;
+        }
+      }
+    }
+
+    if (match == 0) {
+      result = 0.0;
+      return;
+    }
+
+    double t = 0;
+    int point = 0;
+
+    for (int i = 0; i < leftLength; i++) {
+      if (leftHash[i] == 1) {
+        while (rightHash[point] == 0) {
+          point++;
+        }
+
+        if (leftCodePoints[i] != rightCodePoints[point++]) {
+          t++;
+        }
+      }
+    }
+
+    t /= 2;
+
+    double jaroDist = ((static_cast<double>(match) / leftLength) +
+                       (static_cast<double>(match) / rightLength) +
+                       (static_cast<double>(match) - t) / match) /
+        3.0;
+
+    if (jaroDist > 0.7) {
+      int prefix = 0;
+
+      for (int i = 0; i < std::min(leftLength, rightLength); i++) {
+        if (leftCodePoints[i] == rightCodePoints[i]) {
+          prefix++;
+        } else {
+          break;
+        }
+      }
+
+      prefix = std::min(4, prefix);
+
+      jaroDist += 0.1 * prefix * (1 - jaroDist);
+    }
+
+    result = std::round(jaroDist * 100.0) / 100.0;
+  }
+};
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/TDigestFunctions.h b/velox/functions/prestosql/TDigestFunctions.h
index 3cfa84a7b204..37192a35d613 100644
--- a/velox/functions/prestosql/TDigestFunctions.h
+++ b/velox/functions/prestosql/TDigestFunctions.h
@@ -46,6 +46,8 @@ struct ValuesAtQuantilesFunction {
     auto digest = TDigest<>::fromSerialized(input.data());
     result.resize(quantiles.size());
     for (size_t i = 0; i < quantiles.size(); ++i) {
+      VELOX_USER_CHECK(
+          quantiles[i].has_value(), "All quantiles should be non-null.");
       double quantile = quantiles[i].value();
       VELOX_USER_CHECK(0 <= quantile && quantile <= 1);
       result[i] = digest.estimateQuantile(quantile);
@@ -113,7 +115,23 @@ struct QuantileAtValueFunction {
     return true;
   }
 };
+template <typename T>
+struct QuantilesAtValuesFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
 
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Array<double>>& result,
+      const arg_type<SimpleTDigest<double>>& input,
+      const arg_type<Array<double>>& values) {
+    auto digest = TDigest<>::fromSerialized(input.data());
+    result.resize(values.size());
+    for (size_t i = 0; i < values.size(); ++i) {
+      VELOX_USER_CHECK(values[i].has_value(), "All values should be non-null.");
+      double value = values[i].value();
+      result[i] = digest.getCdf(value);
+    }
+  }
+};
 template <typename T>
 struct ConstructTDigestFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -188,14 +206,15 @@ struct DestructureTDigestFunction {
       count += tDigestWeights[i];
     }
     // Create the result row
-    result.copy_from(std::make_tuple(
-        std::move(means),
-        std::move(weights),
-        compression,
-        min,
-        max,
-        sum,
-        count));
+    result.copy_from(
+        std::make_tuple(
+            std::move(means),
+            std::move(weights),
+            compression,
+            min,
+            max,
+            sum,
+            count));
 
     return true;
   }
diff --git a/velox/functions/prestosql/TypeOf.cpp b/velox/functions/prestosql/TypeOf.cpp
index 928eee846e28..16d68a49c162 100644
--- a/velox/functions/prestosql/TypeOf.cpp
+++ b/velox/functions/prestosql/TypeOf.cpp
@@ -14,128 +14,114 @@
  * limitations under the License.
  */
 #include "velox/expression/VectorFunction.h"
-#include "velox/functions/prestosql/types/BingTileType.h"
-#include "velox/functions/prestosql/types/GeometryType.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
-#include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
-#include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/P4HyperLogLogType.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
-#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
-#include "velox/functions/prestosql/types/UuidType.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
 
 namespace facebook::velox::functions {
 namespace {
 
+// Converts a TypePtr to its string representation. Handles most types by
+// default, but provides special handling for types with mixed casing, custom
+// names, or complex formatting.
 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());
-      }
-      if (isBingTileType(type)) {
-        return "bingtile";
-      }
-      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());
+  // Handle decimal types with precision and scale
+  if (type->isDecimal()) {
+    auto precision = type->isShortDecimal() ? type->asShortDecimal().precision()
+                                            : type->asLongDecimal().precision();
+    auto scale = type->isShortDecimal() ? type->asShortDecimal().scale()
+                                        : type->asLongDecimal().scale();
+    return fmt::format("decimal({},{})", precision, scale);
+  }
+
+  // Handle complex types with recursive formatting
+  if (type->kind() == TypeKind::ARRAY) {
+    return fmt::format("array({})", typeName(type->childAt(0)));
+  }
+
+  if (type->kind() == TypeKind::MAP) {
+    return fmt::format(
+        "map({}, {})", typeName(type->childAt(0)), typeName(type->childAt(1)));
+  }
+
+  if (type->kind() == TypeKind::ROW) {
+    if (isIPPrefixType(type)) {
+      return "ipprefix";
     }
-    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";
-      }
-      if (isGeometryType(type)) {
-        return "geometry";
-      }
-      if (*type == *TDIGEST(DOUBLE())) {
-        return "tdigest(double)";
-      }
-      if (*type == *QDIGEST(BIGINT())) {
-        return "qdigest(bigint)";
-      }
-      if (*type == *QDIGEST(REAL())) {
-        return "qdigest(real)";
-      }
-      if (*type == *QDIGEST(DOUBLE())) {
-        return "qdigest(double)";
-      }
-      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: {
-      if (isIPPrefixType(type)) {
-        return "ipprefix";
+    const auto& rowType = type->asRow();
+    std::ostringstream out;
+    out << "row(";
+    for (auto i = 0; i < type->size(); ++i) {
+      if (i > 0) {
+        out << ", ";
       }
-      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));
+      if (!rowType.nameOf(i).empty()) {
+        out << "\"" << rowType.nameOf(i) << "\" ";
       }
-      out << ")";
-      return out.str();
+      out << typeName(type->childAt(i));
     }
-    case TypeKind::UNKNOWN:
-      return "unknown";
-    default:
-      VELOX_UNSUPPORTED("Unsupported type: {}", type->toString());
+    out << ")";
+    return out.str();
   }
+
+  // Handle enum types that have custom names
+  if (isBigintEnumType(*type)) {
+    return asBigintEnum(type)->enumName();
+  }
+  if (isVarcharEnumType(*type)) {
+    return asVarcharEnum(type)->enumName();
+  }
+
+  // Handle HyperLogLog types that use mixed case
+  if (isHyperLogLogType(type)) {
+    return "HyperLogLog";
+  }
+  if (isP4HyperLogLogType(type)) {
+    return "P4HyperLogLog";
+  }
+  if (isKHyperLogLogType(type)) {
+    return "KHyperLogLog";
+  }
+
+  // Handle SetDigest types
+  if (isSetDigestType(type)) {
+    return "SetDigest";
+  }
+
+  // Handle special digest types that need parameter formatting
+  if (*type == *TDIGEST(DOUBLE())) {
+    return "tdigest(double)";
+  }
+  if (*type == *QDIGEST(BIGINT())) {
+    return "qdigest(bigint)";
+  }
+  if (*type == *QDIGEST(REAL())) {
+    return "qdigest(real)";
+  }
+  if (*type == *QDIGEST(DOUBLE())) {
+    return "qdigest(double)";
+  }
+
+  if (type->kind() == TypeKind::UNKNOWN) {
+    return "unknown";
+  }
+
+  // Handle unsupported types
+  if (type->kind() == TypeKind::OPAQUE || type->kind() == TypeKind::FUNCTION ||
+      type->kind() == TypeKind::INVALID) {
+    VELOX_UNSUPPORTED("Unsupported type: {}", type->toString());
+  }
+
+  // Default: use type->name() and lowercase it
+  std::string name = type->name();
+  folly::toLowerAscii(name);
+  return name;
 }
 
 class TypeOfFunction : public exec::VectorFunction {
diff --git a/velox/functions/prestosql/URIParser.h b/velox/functions/prestosql/URIParser.h
index 1417d6f19b2d..8e5b9f75ed9d 100644
--- a/velox/functions/prestosql/URIParser.h
+++ b/velox/functions/prestosql/URIParser.h
@@ -15,17 +15,11 @@
  */
 #pragma once
 
-#include <boost/regex.hpp>
-#include "velox/functions/lib/Utf8Utils.h"
+#include <re2/re2.h>
+#include <optional>
 #include "velox/type/StringView.h"
 
 namespace facebook::velox::functions {
-namespace detail {
-FOLLY_ALWAYS_INLINE StringView submatch(const boost::cmatch& match, int idx) {
-  const auto& sub = match[idx];
-  return StringView(sub.first, sub.length());
-}
-} // namespace detail
 /// A struct containing the parts of the URI that were extracted during parsing.
 /// If the field was not found, it is empty.
 ///
@@ -52,35 +46,46 @@ bool parseUri(const StringView& uriStr, URI& uri);
 /// false and pos is unchanged.
 bool tryConsumeIPV6Address(const char* str, const size_t len, int32_t& pos);
 
-/// Find an extract the value for the parameter with key `param` from the query
+/// Find and extract the value for the parameter with key `param` from the query
 /// portion of a URI `query`. `query` should already be decoded if necessary.
 template <typename TString>
 std::optional<StringView> extractParameter(
     const StringView& query,
     const TString& param) {
   if (!query.empty()) {
-    // Parse query string.
-    static const boost::regex kQueryParamRegex(
+    // Parse query string using RE2.
+    static const RE2 kQueryParamRegex(
         "(^|&)" // start of query or start of parameter "&"
         "([^=&]*)=?" // parameter name and "=" if value is expected
         "([^&]*)" // parameter value (allows "=" to appear)
-        "(?=(&|$))" // forward reference, next should be end of query or
-                    // start of next parameter
     );
 
-    const boost::cregex_iterator begin(
-        query.data(), query.data() + query.size(), kQueryParamRegex);
-    boost::cregex_iterator end;
+    re2::StringPiece input(query.data(), query.size());
+    re2::StringPiece matches[4]; // Group 0 (full match) + 3 capturing groups
+    size_t pos = 0;
 
-    for (auto it = begin; it != end; ++it) {
-      if (it->length(2) != 0 && (*it)[2].matched) { // key shouldnt be empty.
-        auto key = detail::submatch((*it), 2);
+    while (pos < input.size() &&
+           kQueryParamRegex.Match(
+               input, pos, input.size(), RE2::UNANCHORED, matches, 4)) {
+      // Check if key (group 2) is not empty and matched
+      if (matches[2].size() > 0) {
+        StringView key(matches[2].data(), matches[2].size());
         if (param.compare(key) == 0) {
-          return detail::submatch((*it), 3);
+          // Return the value (group 3)
+          return std::optional<StringView>(
+              StringView(matches[3].data(), matches[3].size()));
         }
       }
+
+      // Move past this match to continue searching
+      pos = matches[0].end() - input.data();
+      if (pos == matches[0].data() - input.data()) {
+        // Avoid infinite loop on zero-width matches
+        ++pos;
+      }
     }
   }
   return std::nullopt;
 }
+
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/URLFunctions.cpp b/velox/functions/prestosql/URLFunctions.cpp
deleted file mode 100644
index d943cdf183c7..000000000000
--- a/velox/functions/prestosql/URLFunctions.cpp
+++ /dev/null
@@ -1,57 +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 "URLFunctions.h"
-#include <optional>
-#include "velox/type/Type.h"
-
-namespace facebook::velox::functions::detail {
-
-std::optional<StringView> matchAuthorityAndPath(
-    StringView authorityAndPath,
-    boost::cmatch& authorityMatch,
-    int subGroup) {
-  boost::cmatch authAndPathMatch;
-  static const boost::regex kAuthorityAndPathRegex("//([^/]*)(/.*)?");
-  if (!boost::regex_match(
-          authorityAndPath.begin(),
-          authorityAndPath.end(),
-          authAndPathMatch,
-          kAuthorityAndPathRegex)) {
-    // Does not start with //, doesn't have authority.
-    return std::nullopt;
-  }
-
-  static const boost::regex kAuthorityRegex(
-      "(?:([^@:]*)(?::([^@]*))?@)?" // username, password.
-      "(\\[[^\\]]*\\]|[^\\[:]*)" // host (IP-literal (e.g. '['+IPv6+']',
-      // dotted-IPv4, or named host).
-      "(?::(\\d*))?"); // port.
-
-  const auto authority = authAndPathMatch[1];
-  if (!boost::regex_match(
-          authority.first, authority.second, authorityMatch, kAuthorityRegex)) {
-    return std::nullopt; // Invalid URI Authority.
-  }
-
-  if (authorityMatch[subGroup].matched) {
-    return detail::submatch(authorityMatch, subGroup);
-  }
-
-  return std::nullopt;
-}
-
-} // namespace facebook::velox::functions::detail
diff --git a/velox/functions/prestosql/URLFunctions.h b/velox/functions/prestosql/URLFunctions.h
index e96be9223ec0..6d3c01d196be 100644
--- a/velox/functions/prestosql/URLFunctions.h
+++ b/velox/functions/prestosql/URLFunctions.h
@@ -232,6 +232,7 @@ FOLLY_ALWAYS_INLINE void urlUnescape(
   }
   output.resize(outputBuffer - output.data());
 }
+
 } // namespace detail
 
 template <typename T>
diff --git a/velox/functions/prestosql/UpperLower.cpp b/velox/functions/prestosql/UpperLower.cpp
new file mode 100644
index 000000000000..be43d7d02f22
--- /dev/null
+++ b/velox/functions/prestosql/UpperLower.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/UpperLower.h"
+
+namespace facebook::velox::functions {
+
+using PrestoUpperFunction = UpperLowerTemplateFunction<
+    /*isLower=*/false,
+    /*turkishCasing=*/false,
+    /*greekFinalSigma=*/false>;
+using PrestoLowerFunction = UpperLowerTemplateFunction<
+    /*isLower=*/true,
+    /*turkishCasing=*/false,
+    /*greekFinalSigma=*/false>;
+
+VELOX_DECLARE_VECTOR_FUNCTION(
+    udf_upper,
+    PrestoUpperFunction::signatures(),
+    (std::make_unique<PrestoUpperFunction>()));
+
+VELOX_DECLARE_VECTOR_FUNCTION(
+    udf_lower,
+    PrestoLowerFunction::signatures(),
+    (std::make_unique<PrestoLowerFunction>()));
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/VectorArithmetic.cpp b/velox/functions/prestosql/VectorArithmetic.cpp
index b7ad76f7f729..6e508476436c 100644
--- a/velox/functions/prestosql/VectorArithmetic.cpp
+++ b/velox/functions/prestosql/VectorArithmetic.cpp
@@ -149,8 +149,7 @@ class VectorArithmetic : public VectorFunction {
       context.ensureWritable(rows, outputType, result);
     }
     // Here we provide a pointer to the raw flat results.
-    BufferPtr resultValues =
-        result->as<FlatVector<T>>()->mutableValues(rows.end());
+    BufferPtr resultValues = result->as<FlatVector<T>>()->mutableValues();
     T* __restrict rawResult = resultValues->asMutable<T>();
 
     // Step 2: handle input encodings and call the inner kernels
@@ -362,11 +361,12 @@ class ArithmeticRegistration {
         "tinyint", "smallint", "integer", "bigint", "real", "double"};
     std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
     for (const auto& type : types) {
-      signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                  .returnType(type)
-                                  .argumentType(type)
-                                  .argumentType(type)
-                                  .build());
+      signatures.emplace_back(
+          exec::FunctionSignatureBuilder()
+              .returnType(type)
+              .argumentType(type)
+              .argumentType(type)
+              .build());
     }
 
     registerVectorFunction(
diff --git a/velox/functions/prestosql/WidthBucketArray.cpp b/velox/functions/prestosql/WidthBucketArray.cpp
index daa136a95904..994c4977ff95 100644
--- a/velox/functions/prestosql/WidthBucketArray.cpp
+++ b/velox/functions/prestosql/WidthBucketArray.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/functions/prestosql/WidthBucketArray.h"
-#include "velox/expression/Expr.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
 #include "velox/vector/DecodedVector.h"
diff --git a/velox/functions/prestosql/WordStem.h b/velox/functions/prestosql/WordStem.h
index 41b01bb9aa35..616f9dbc0cc4 100644
--- a/velox/functions/prestosql/WordStem.h
+++ b/velox/functions/prestosql/WordStem.h
@@ -97,8 +97,8 @@ struct WordStemFunction {
   FOLLY_ALWAYS_INLINE void doCall(
       out_type<Varchar>& result,
       const arg_type<Varchar>& input,
-      const std::string& lang = "en") {
-    auto* stemmer = getStemmer(lang);
+      const arg_type<Varchar>& lang = "en") {
+    auto* stemmer = getStemmer(std::string(lang));
     VELOX_USER_CHECK_NOT_NULL(
         stemmer, "Unsupported stemmer language: {}", lang);
 
diff --git a/velox/functions/prestosql/Zip.cpp b/velox/functions/prestosql/Zip.cpp
index 6e9b17a61652..9fbeaea14039 100644
--- a/velox/functions/prestosql/Zip.cpp
+++ b/velox/functions/prestosql/Zip.cpp
@@ -13,11 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <boost/algorithm/string/join.hpp>
 #include <limits>
-#include "velox/expression/Expr.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
-#include "velox/functions/lib/LambdaFunctionUtil.h"
 
 namespace facebook::velox::functions {
 
diff --git a/velox/functions/prestosql/ZipWith.cpp b/velox/functions/prestosql/ZipWith.cpp
index 032237cbd53e..f43f00b48a4c 100644
--- a/velox/functions/prestosql/ZipWith.cpp
+++ b/velox/functions/prestosql/ZipWith.cpp
@@ -13,9 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/Expr.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
-#include "velox/functions/lib/LambdaFunctionUtil.h"
 #include "velox/functions/lib/RowsTranslationUtil.h"
 #include "velox/vector/FunctionVector.h"
 
diff --git a/velox/functions/prestosql/aggregates/AggregateNames.h b/velox/functions/prestosql/aggregates/AggregateNames.h
index 71032da0d32b..9f5a25663c10 100644
--- a/velox/functions/prestosql/aggregates/AggregateNames.h
+++ b/velox/functions/prestosql/aggregates/AggregateNames.h
@@ -22,6 +22,7 @@ const char* const kApproxDistinct = "approx_distinct";
 const char* const kApproxMostFrequent = "approx_most_frequent";
 const char* const kApproxPercentile = "approx_percentile";
 const char* const kApproxSet = "approx_set";
+const char* const kQDigestAgg = "qdigest_agg";
 const char* const kArbitrary = "arbitrary";
 const char* const kAnyValue = "any_value";
 const char* const kArrayAgg = "array_agg";
@@ -37,6 +38,7 @@ const char* const kClassificationPrecision = "classification_precision";
 const char* const kClassificationRecall = "classification_recall";
 const char* const kClassificationMissRate = "classification_miss_rate";
 const char* const kClassificationThreshold = "classification_thresholds";
+const char* const kConvexHull = "convex_hull_agg";
 const char* const kCorr = "corr";
 const char* const kCount = "count";
 const char* const kCountIf = "count_if";
@@ -45,18 +47,25 @@ const char* const kCovarSamp = "covar_samp";
 const char* const kEntropy = "entropy";
 const char* const kEvery = "every";
 const char* const kGeometricMean = "geometric_mean";
+const char* const kGeometryUnion = "geometry_union_agg";
 const char* const kHistogram = "histogram";
 const char* const kKurtosis = "kurtosis";
 const char* const kMapAgg = "map_agg";
 const char* const kMapUnion = "map_union";
 const char* const kMapUnionSum = "map_union_sum";
+const char* const kMakeSetDigest = "make_set_digest";
+const char* const kMergeSetDigest = "merge_set_digest";
 const char* const kMax = "max";
 const char* const kMaxBy = "max_by";
 const char* const kMerge = "merge";
 const char* const kMin = "min";
 const char* const kMinBy = "min_by";
 const char* const kMultiMapAgg = "multimap_agg";
+const char* const kNoisyAvgGaussian = "noisy_avg_gaussian";
 const char* const kNoisyCountIfGaussian = "noisy_count_if_gaussian";
+const char* const kNoisyCountGaussian = "noisy_count_gaussian";
+const char* const kNoisySumGaussian = "noisy_sum_gaussian";
+const char* const kNumericHistogram = "numeric_histogram";
 const char* const kReduceAgg = "reduce_agg";
 const char* const kRegrIntercept = "regr_intercept";
 const char* const kRegrSlop = "regr_slope";
@@ -67,6 +76,7 @@ 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 kReservoirSample = "reservoir_sample";
 const char* const kSetAgg = "set_agg";
 const char* const kSetUnion = "set_union";
 const char* const kSkewness = "skewness";
@@ -74,9 +84,15 @@ const char* const kStdDev = "stddev"; // Alias for stddev_samp.
 const char* const kStdDevPop = "stddev_pop";
 const char* const kStdDevSamp = "stddev_samp";
 const char* const kSum = "sum";
+const char* const kTDigestAgg = "tdigest_agg";
 const char* const kVariance = "variance"; // Alias for var_samp.
 const char* const kVarPop = "var_pop";
 const char* const kVarSamp = "var_samp";
 const char* const kMaxSizeForStats = "max_data_size_for_stats";
 const char* const kSumDataSizeForStats = "sum_data_size_for_stats";
+const char* const kNoisyApproxSetSfm = "noisy_approx_set_sfm";
+const char* const kNoisyApproxDistinctSfm = "noisy_approx_distinct_sfm";
+const char* const kNoisyApproxSetSfmFromIndexAndZeros =
+    "noisy_approx_set_sfm_from_index_and_zeros";
+const char* const kKHyperLogLogAgg = "khyperloglog_agg";
 } // namespace facebook::velox::aggregate
diff --git a/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
index fcd7c808d90d..e838b96c8dc1 100644
--- a/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxDistinctAggregate.cpp
@@ -49,42 +49,47 @@ exec::AggregateRegistrationResult registerApproxDistinct(
             "date",
             "unknown"};
   for (const auto& inputType : inputTypes) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(returnType)
-                             .intermediateType("varbinary")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(returnType)
+            .intermediateType("varbinary")
+            .argumentType(inputType)
+            .build());
 
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(returnType)
-                             .intermediateType("varbinary")
-                             .argumentType(inputType)
-                             .argumentType("double")
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(returnType)
+            .intermediateType("varbinary")
+            .argumentType(inputType)
+            .argumentType("double")
+            .build());
   }
   if (!hllAsFinalResult) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("bigint")
-                             .intermediateType("tinyint")
-                             .argumentType("boolean")
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("bigint")
+            .intermediateType("tinyint")
+            .argumentType("boolean")
+            .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());
+  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),
diff --git a/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
index d32f6ebcb500..594f0815ddc7 100644
--- a/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/functions/prestosql/aggregates/ApproxMostFrequentAggregate.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/exec/SimpleAggregateAdapter.h"
 #include "velox/exec/Strings.h"
@@ -27,53 +28,126 @@ namespace facebook::velox::aggregate::prestosql {
 
 namespace {
 
+template <typename T, typename A = AlignedStlAllocator<T, 16>>
+using Summary = functions::ApproxMostFrequentStreamSummary<T, A>;
+
 template <typename T>
 struct Accumulator {
-  functions::ApproxMostFrequentStreamSummary<T, AlignedStlAllocator<T, 16>>
-      summary;
+  Summary<T> summary;
 
   explicit Accumulator(HashStringAllocator* allocator)
       : summary(AlignedStlAllocator<T, 16>(allocator)) {}
 
-  void insert(T value, int64_t count = 1) {
+  void insert(T value, int64_t count) {
     summary.insert(value, count);
   }
 };
 
 template <>
 struct Accumulator<StringView> {
-  functions::ApproxMostFrequentStreamSummary<
-      StringView,
-      AlignedStlAllocator<StringView, 16>>
-      summary;
+  Summary<StringView> summary;
   HashStringAllocator* allocator;
   Strings strings;
+  size_t activeBytes_{0};
+  size_t evictedBytes_{0};
 
-  explicit Accumulator(HashStringAllocator* allocator)
-      : summary(AlignedStlAllocator<StringView, 16>(allocator)),
-        allocator(allocator) {}
+  explicit Accumulator(HashStringAllocator* _allocator)
+      : summary(AlignedStlAllocator<StringView, 16>(_allocator)),
+        allocator(_allocator) {}
 
   ~Accumulator() {
     strings.free(*allocator);
   }
 
-  void insert(StringView value, int64_t count = 1) {
+  void insert(
+      StringView value,
+      int64_t count,
+      uint64_t compactionBytesThreshold = 0,
+      double compactionUnusedMemoryRatio = 0) {
     if (!value.isInline() && !summary.contains(value)) {
+      activeBytes_ += value.size();
       value = strings.append(value, *allocator);
     }
-    summary.insert(value, count);
+
+    auto evicted = summary.insert(value, count);
+    if (evicted.has_value() && !evicted->isInline()) {
+      const auto evictedSize = evicted->size();
+      evictedBytes_ += evictedSize;
+      VELOX_CHECK_GE(activeBytes_, evictedSize);
+      activeBytes_ -= evictedSize;
+
+      // Trigger compaction to reclaim memory from evicted strings.
+      // Compact only when:
+      // 1. Total string storage exceeds compactionBytesThreshold, AND
+      // 2. Evicted bytes exceed compactionUnusedMemoryRatio of the threshold.
+      if (compactionBytesThreshold > 0) {
+        if (FOLLY_UNLIKELY(
+                (evictedBytes_ + activeBytes_ > compactionBytesThreshold) &&
+                (evictedBytes_ >
+                 compactionBytesThreshold * compactionUnusedMemoryRatio))) {
+          compact();
+        }
+      }
+    }
+  }
+
+ private:
+  // Copies active strings to new storage and frees old storage. Peak memory
+  // is approximately 2x activeBytes + evictedBytes, since both storages coexist
+  // temporarily.
+  void compact() {
+    if (summary.size() == 0) {
+      return;
+    }
+
+    const auto capacity = summary.capacity();
+    const auto currentSize = summary.size();
+
+    Strings compactedStrings;
+    Summary<StringView> compactedSummary{
+        AlignedStlAllocator<StringView, 16>{allocator}};
+    compactedSummary.setCapacity(capacity);
+
+    uint64_t compactedActiveBytes = 0;
+    for (auto i = 0; i < currentSize; ++i) {
+      StringView v = summary.values()[i];
+      int64_t cnt = summary.counts()[i];
+      if (!v.isInline()) {
+        compactedActiveBytes += v.size();
+        v = compactedStrings.append(v, *allocator);
+      }
+      compactedSummary.insert(v, cnt);
+    }
+
+    VELOX_CHECK_EQ(compactedActiveBytes, activeBytes_);
+
+    // Free old storage.
+    strings.free(*allocator);
+
+    strings = std::move(compactedStrings);
+    summary = std::move(compactedSummary);
+    evictedBytes_ = 0;
   }
 };
 
 template <typename T>
 struct ApproxMostFrequentAggregate : exec::Aggregate {
-  explicit ApproxMostFrequentAggregate(const TypePtr& resultType)
-      : Aggregate(resultType) {}
+  explicit ApproxMostFrequentAggregate(
+      const TypePtr& resultType,
+      uint64_t compactionBytesThreshold,
+      double compactionUnusedMemoryRatio)
+      : Aggregate(resultType),
+        compactionBytesThreshold_(compactionBytesThreshold),
+        compactionUnusedMemoryRatio_(compactionUnusedMemoryRatio) {}
 
   int32_t accumulatorFixedWidthSize() const override {
     return sizeof(Accumulator<T>);
   }
 
+  bool isFixedSize() const override {
+    return false;
+  }
+
   void addRawInput(
       char** groups,
       const SelectivityVector& rows,
@@ -83,7 +157,8 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     rows.applyToSelected([&](auto row) {
       if (!decodedValues_.isNullAt(row)) {
         auto* accumulator = initAccumulator(groups[row]);
-        accumulator->insert(decodedValues_.valueAt<T>(row));
+        auto tracker = trackRowSize(groups[row]);
+        accumulator->insert(decodedValues_.valueAt<T>(row), 1);
       }
     });
   }
@@ -103,9 +178,18 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
       bool) override {
     decodeArguments(rows, args);
     auto* accumulator = initAccumulator(group);
+    auto tracker = trackRowSize(group);
     rows.applyToSelected([&](auto row) {
       if (!decodedValues_.isNullAt(row)) {
-        accumulator->insert(decodedValues_.valueAt<T>(row));
+        if constexpr (std::is_same_v<T, StringView>) {
+          accumulator->insert(
+              decodedValues_.valueAt<T>(row),
+              1,
+              compactionBytesThreshold_,
+              compactionUnusedMemoryRatio_);
+        } else {
+          accumulator->insert(decodedValues_.valueAt<T>(row), 1);
+        }
       }
     });
   }
@@ -135,7 +219,7 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     vector_size_t entryCount = 0;
     for (int i = 0; i < numGroups; ++i) {
       auto* summary = &value<Accumulator<T>>(groups[i])->summary;
-      int size = std::min<int>(buckets_, summary->size());
+      const int size = std::min<int>(buckets_, summary->size());
       if (size == 0) {
         mapVector->setNull(i, true);
       } else {
@@ -157,8 +241,8 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
 
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
-    auto rowVec = (*result)->as<RowVector>();
-    VELOX_CHECK(rowVec);
+    auto* rowVec = (*result)->as<RowVector>();
+    VELOX_CHECK_NOT_NULL(rowVec);
     rowVec->childAt(0) = std::make_shared<ConstantVector<int64_t>>(
         rowVec->pool(),
         numGroups,
@@ -171,14 +255,14 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
         false,
         BIGINT(),
         static_cast<int64_t&&>(capacity_));
-    auto values = rowVec->childAt(2)->as<ArrayVector>();
-    auto counts = rowVec->childAt(3)->as<ArrayVector>();
+    auto* values = rowVec->childAt(2)->as<ArrayVector>();
+    auto* counts = rowVec->childAt(3)->as<ArrayVector>();
     rowVec->resize(numGroups);
     values->resize(numGroups);
     counts->resize(numGroups);
 
-    auto v = values->elements()->template asFlatVector<T>();
-    auto c = counts->elements()->template asFlatVector<int64_t>();
+    auto* v = values->elements()->template asFlatVector<T>();
+    auto* c = counts->elements()->template asFlatVector<int64_t>();
     vector_size_t entryCount = 0;
     for (int i = 0; i < numGroups; ++i) {
       auto* accumulator = value<const Accumulator<T>>(groups[i]);
@@ -278,52 +362,71 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     VELOX_CHECK_EQ(args.size(), 1);
     DecodedVector decoded(*args[0], rows);
     auto rowVec = static_cast<const RowVector*>(decoded.base());
-    auto buckets = rowVec->childAt(0)->as<SimpleVector<int64_t>>();
-    auto capacity = rowVec->childAt(1)->as<SimpleVector<int64_t>>();
-    auto values = rowVec->childAt(2)->as<ArrayVector>();
-    auto counts = rowVec->childAt(3)->as<ArrayVector>();
-    VELOX_CHECK(buckets);
-    VELOX_CHECK(capacity);
-    VELOX_CHECK(values);
-    VELOX_CHECK(counts);
-
-    auto v = values->elements()->template asFlatVector<T>();
-    auto c = counts->elements()->template asFlatVector<int64_t>();
-    VELOX_CHECK(v);
-    VELOX_CHECK(c);
-
-    Accumulator<T>* accumulator = nullptr;
+    auto* buckets = rowVec->childAt(0)->as<SimpleVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(buckets);
+    auto* capacity = rowVec->childAt(1)->as<SimpleVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(capacity);
+    auto* values = rowVec->childAt(2)->as<ArrayVector>();
+    VELOX_CHECK_NOT_NULL(values);
+    auto* counts = rowVec->childAt(3)->as<ArrayVector>();
+    VELOX_CHECK_NOT_NULL(counts);
+
+    auto* v = values->elements()->template asFlatVector<T>();
+    VELOX_CHECK_NOT_NULL(v);
+    auto* c = counts->elements()->template asFlatVector<int64_t>();
+    VELOX_CHECK_NOT_NULL(c);
+
+    Accumulator<T>* accumulator{nullptr};
     rows.applyToSelected([&](auto row) {
       if (decoded.isNullAt(row)) {
         return;
       }
-      int i = decoded.index(row);
+      const int i = decoded.index(row);
       setConstantArgument("Buckets", buckets_, buckets->valueAt(i));
       setConstantArgument("Capacity", capacity_, capacity->valueAt(i));
       if constexpr (kSingleGroup) {
-        if (!accumulator) {
+        if (accumulator == nullptr) {
           accumulator = initAccumulator(group);
         }
+        auto tracker = trackRowSize(group);
+        const auto size = values->sizeAt(i);
+        VELOX_DCHECK_EQ(counts->sizeAt(i), size);
+        const auto vo = values->offsetAt(i);
+        const auto co = counts->offsetAt(i);
+        if constexpr (std::is_same_v<T, StringView>) {
+          for (int j = 0; j < size; ++j) {
+            accumulator->insert(
+                v->valueAt(vo + j),
+                c->valueAt(co + j),
+                compactionBytesThreshold_,
+                compactionUnusedMemoryRatio_);
+          }
+        } else {
+          for (int j = 0; j < size; ++j) {
+            accumulator->insert(v->valueAt(vo + j), c->valueAt(co + j));
+          }
+        }
       } else {
         accumulator = initAccumulator(group[row]);
-      }
-      auto size = values->sizeAt(i);
-      VELOX_DCHECK_EQ(counts->sizeAt(i), size);
-      auto vo = values->offsetAt(i);
-      auto co = counts->offsetAt(i);
-      for (int j = 0; j < size; ++j) {
-        accumulator->insert(v->valueAt(vo + j), c->valueAt(co + j));
+        auto tracker = trackRowSize(group[row]);
+        const auto size = values->sizeAt(i);
+        VELOX_DCHECK_EQ(counts->sizeAt(i), size);
+        const auto vo = values->offsetAt(i);
+        const auto co = counts->offsetAt(i);
+        for (int j = 0; j < size; ++j) {
+          accumulator->insert(v->valueAt(vo + j), c->valueAt(co + j));
+        }
       }
     });
   }
 
   std::pair<FlatVector<T>*, FlatVector<int64_t>*>
   prepareFinalResult(char** groups, int32_t numGroups, MapVector* result) {
-    VELOX_CHECK(result);
-    auto keys = result->mapKeys()->asUnchecked<FlatVector<T>>();
-    auto values = result->mapValues()->asUnchecked<FlatVector<int64_t>>();
-    VELOX_CHECK(keys);
-    VELOX_CHECK(values);
+    VELOX_CHECK_NOT_NULL(result);
+    auto* keys = result->mapKeys()->asUnchecked<FlatVector<T>>();
+    VELOX_CHECK_NOT_NULL(keys);
+    auto* values = result->mapValues()->asUnchecked<FlatVector<int64_t>>();
+    VELOX_CHECK_NOT_NULL(values);
     vector_size_t entryCount = 0;
     for (int i = 0; i < numGroups; ++i) {
       auto* summary = &value<const Accumulator<T>>(groups[i])->summary;
@@ -334,10 +437,16 @@ struct ApproxMostFrequentAggregate : exec::Aggregate {
     return std::make_pair(keys, values);
   }
 
-  static constexpr int64_t kMissingArgument = -1;
+  static constexpr int64_t kMissingArgument{-1};
+
+  // NOTE: compaction is currently only applied for global aggregation
+  // addSingleGroupRawInput with StringView type
+  const uint64_t compactionBytesThreshold_;
+  const double compactionUnusedMemoryRatio_;
+
   DecodedVector decodedValues_;
-  int64_t buckets_ = kMissingArgument;
-  int64_t capacity_ = kMissingArgument;
+  int64_t buckets_{kMissingArgument};
+  int64_t capacity_{kMissingArgument};
 };
 
 class ApproxMostFrequentBooleanAggregate {
@@ -345,11 +454,10 @@ class ApproxMostFrequentBooleanAggregate {
   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 IntermediateType = Row</*buckets*/ int64_t,
+                               /*capacity*/ int64_t,
+                               /*values*/ Array<bool>,
+                               /*counts*/ Array<int64_t>>;
 
   using OutputType = Map<bool, int64_t>;
 
@@ -452,14 +560,16 @@ std::unique_ptr<exec::Aggregate> makeApproxMostFrequentAggregate(
     core::AggregationNode::Step step,
     const std::vector<TypePtr>& argTypes,
     const TypePtr& resultType,
-    const TypePtr& valueType) {
+    const TypePtr& valueType,
+    uint64_t compactionBytesThreshold,
+    double compactionUnusedMemoryRatio) {
   if constexpr (
       kKind == TypeKind::TINYINT || kKind == TypeKind::SMALLINT ||
       kKind == TypeKind::INTEGER || kKind == TypeKind::BIGINT ||
       kKind == TypeKind::VARCHAR) {
     return std::make_unique<
         ApproxMostFrequentAggregate<typename TypeTraits<kKind>::NativeType>>(
-        resultType);
+        resultType, compactionBytesThreshold, compactionUnusedMemoryRatio);
   }
 
   if (kKind == TypeKind::BOOLEAN) {
@@ -492,8 +602,9 @@ void registerApproxMostFrequentAggregate(
     signatures.push_back(
         exec::AggregateFunctionSignatureBuilder()
             .returnType(fmt::format("map({},bigint)", valueType))
-            .intermediateType(fmt::format(
-                "row(bigint, bigint, array({}), array(bigint))", valueType))
+            .intermediateType(
+                fmt::format(
+                    "row(bigint, bigint, array({}), array(bigint))", valueType))
             .argumentType("bigint")
             .argumentType(valueType)
             .argumentType("bigint")
@@ -507,8 +618,7 @@ void registerApproxMostFrequentAggregate(
           core::AggregationNode::Step step,
           const 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> {
         auto& valueType = exec::isPartialOutput(step)
             ? resultType->childAt(2)->childAt(0)
             : resultType->childAt(0);
@@ -519,7 +629,9 @@ void registerApproxMostFrequentAggregate(
             step,
             argTypes,
             resultType,
-            valueType);
+            valueType,
+            config.aggregationCompactionBytesThreshold(),
+            config.aggregationCompactionUnusedMemoryRatio());
       },
       withCompanionFunctions,
       overwrite);
diff --git a/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp b/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
index ea092bc691f6..1713794790df 100644
--- a/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ApproxPercentileAggregate.cpp
@@ -855,34 +855,38 @@ void addSignatures(
   auto intermediateType = fmt::format(
       "row(array(double), boolean, double, integer, bigint, {0}, {0}, array({0}), array(integer))",
       inputType);
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType(returnType)
-                           .intermediateType(intermediateType)
-                           .argumentType(inputType)
-                           .argumentType(percentileType)
-                           .build());
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType(returnType)
-                           .intermediateType(intermediateType)
-                           .argumentType(inputType)
-                           .argumentType("bigint")
-                           .argumentType(percentileType)
-                           .build());
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType(returnType)
-                           .intermediateType(intermediateType)
-                           .argumentType(inputType)
-                           .argumentType(percentileType)
-                           .argumentType("double")
-                           .build());
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType(returnType)
-                           .intermediateType(intermediateType)
-                           .argumentType(inputType)
-                           .argumentType("bigint")
-                           .argumentType(percentileType)
-                           .argumentType("double")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(returnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType(percentileType)
+          .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(returnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("bigint")
+          .argumentType(percentileType)
+          .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(returnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType(percentileType)
+          .argumentType("double")
+          .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType(returnType)
+          .intermediateType(intermediateType)
+          .argumentType(inputType)
+          .argumentType("bigint")
+          .argumentType(percentileType)
+          .argumentType("double")
+          .build());
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp b/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
index 1a57bcac0734..fffee4f253c2 100644
--- a/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ArbitraryAggregate.cpp
@@ -176,12 +176,10 @@ class NonNumericArbitrary : public exec::Aggregate {
 
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
-    VELOX_CHECK(result);
+    VELOX_CHECK_NOT_NULL(result);
     (*result)->resize(numGroups);
-
-    auto* rawNulls = exec::Aggregate::getRawNulls(result->get());
-
     if (clusteredInput_) {
+      bool singleSource{true};
       VectorPtr* currentSource = nullptr;
       VELOX_DCHECK(copyRanges_.empty());
       for (vector_size_t i = 0; i < numGroups; ++i) {
@@ -190,8 +188,9 @@ class NonNumericArbitrary : public exec::Aggregate {
           (*result)->setNull(i, true);
           continue;
         }
-        if (currentSource &&
-            currentSource->get() != accumulator->vector.get()) {
+        if ((currentSource != nullptr) &&
+            (currentSource->get() != accumulator->vector.get())) {
+          singleSource = false;
           result->get()->copyRanges(currentSource->get(), copyRanges_);
           copyRanges_.clear();
         }
@@ -203,11 +202,33 @@ class NonNumericArbitrary : public exec::Aggregate {
           copyRanges_.push_back(range);
         }
       }
-      if (currentSource) {
-        result->get()->copyRanges(currentSource->get(), copyRanges_);
+      if (currentSource != nullptr) {
+        if (!singleSource) {
+          result->get()->copyRanges(currentSource->get(), copyRanges_);
+        } else {
+          if (copyRanges_.size() == 1 && copyRanges_[0].count == numGroups) {
+            *result = currentSource->get()->slice(
+                copyRanges_[0].sourceIndex, copyRanges_[0].count);
+          } else {
+            prepareGroupIndices(numGroups, result->get()->pool());
+            applyToEachRange(
+                copyRanges_,
+                [&](auto targetIndex, auto sourceIndex, auto count) {
+                  for (auto i = 0; i < count; ++i) {
+                    rawGroupIndices_[targetIndex + i] = sourceIndex + i;
+                  }
+                });
+            *result = BaseVector::wrapInDictionary(
+                result->get()->nulls(),
+                groupIndices_,
+                numGroups,
+                *currentSource);
+          }
+        }
         copyRanges_.clear();
       }
     } else {
+      auto* rawNulls = exec::Aggregate::getRawNulls(result->get());
       for (int32_t i = 0; i < numGroups; ++i) {
         auto* accumulator = value<SingleValueAccumulator>(groups[i]);
         if (!accumulator->hasValue()) {
@@ -220,6 +241,16 @@ class NonNumericArbitrary : public exec::Aggregate {
     }
   }
 
+  void prepareGroupIndices(size_t numGroups, memory::MemoryPool* pool) {
+    const auto groupByteSize = numGroups * sizeof(vector_size_t);
+    if ((groupIndices_ == nullptr) || !groupIndices_->unique() ||
+        (groupIndices_->capacity() < groupByteSize)) {
+      groupIndices_ = allocateIndices(numGroups, pool);
+      rawGroupIndices_ = groupIndices_->asMutable<vector_size_t>();
+    }
+    groupIndices_->setSize(groupByteSize);
+  }
+
   void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
       override {
     extractValues(groups, numGroups, result);
@@ -372,6 +403,10 @@ class NonNumericArbitrary : public exec::Aggregate {
 
   // Copy ranges used when extracting from ClusteredNonNumericAccumulator.
   std::vector<BaseVector::CopyRange> copyRanges_;
+
+  // Reusable buffers.
+  BufferPtr groupIndices_;
+  vector_size_t* rawGroupIndices_{};
 };
 
 } // namespace
diff --git a/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp b/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
index 8ec496dd425c..1610f19143bd 100644
--- a/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ArrayAggAggregate.cpp
@@ -112,8 +112,8 @@ class ArrayAggAggregate : public exec::Aggregate {
 
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
       override {
-    auto vector = (*result)->as<ArrayVector>();
-    VELOX_CHECK(vector);
+    auto* vector = (*result)->as<ArrayVector>();
+    VELOX_CHECK_NOT_NULL(vector);
     vector->resize(numGroups);
     uint64_t* rawNulls = getRawNulls(vector);
     auto* resultOffsets =
@@ -121,48 +121,105 @@ class ArrayAggAggregate : public exec::Aggregate {
     auto* resultSizes =
         vector->mutableSizes(numGroups)->asMutable<vector_size_t>();
     auto& elements = vector->elements();
-    elements->resize(countElements(groups, numGroups));
-    vector_size_t arrayOffset = 0;
+    const auto numElements = countElements(groups, numGroups);
+    elements->resize(numElements);
 
+    vector_size_t arrayOffset = 0;
     if (clusteredInput_) {
-      VectorPtr* currentSource = nullptr;
-      std::vector<BaseVector::CopyRange> ranges;
+      bool singleSource{true};
+      VectorPtr* currentSource{nullptr};
+      bool contiguousElementsPerGroup = true;
+      // check if we can get a contiguous range for each group
+      std::vector<BaseVector::CopyRange> rangeMap;
+      rangeMap.resize(numGroups, {0, 0, 0});
       for (int32_t i = 0; i < numGroups; ++i) {
         auto* accumulator = value<ClusteredAccumulator>(groups[i]);
-        resultOffsets[i] = arrayOffset;
-        vector_size_t arraySize = 0;
+        if (accumulator->sources.empty()) {
+          continue;
+        }
         for (auto& source : accumulator->sources) {
-          if (currentSource && currentSource->get() != source.vector.get()) {
-            elements->copyRanges(currentSource->get(), ranges);
-            ranges.clear();
-          }
-          if (!currentSource || currentSource->get() != source.vector.get()) {
+          if (!currentSource) {
             currentSource = &source.vector;
-            ranges.push_back({source.offset, arrayOffset, source.size});
-          } else if (
-              ranges.back().sourceIndex + ranges.back().count ==
-              source.offset) {
-            ranges.back().count += source.size;
           } else {
-            VELOX_DCHECK_LT(
-                ranges.back().sourceIndex + ranges.back().count, source.offset);
-            ranges.push_back({source.offset, arrayOffset, source.size});
+            singleSource =
+                singleSource && (currentSource->get() == source.vector.get());
           }
-          arrayOffset += source.size;
-          arraySize += source.size;
         }
-        resultSizes[i] = arraySize;
-        if (arraySize == 0) {
-          vector->setNull(i, true);
+        if (singleSource) {
+          vector_size_t offset = accumulator->sources[0].offset;
+          vector_size_t size = accumulator->sources[0].size;
+          for (auto j = 1; j < accumulator->sources.size(); ++j) {
+            if (accumulator->sources[j].offset !=
+                accumulator->sources[j - 1].offset +
+                    accumulator->sources[j - 1].size) {
+              contiguousElementsPerGroup = false;
+              break;
+            } else {
+              size += accumulator->sources[j].size;
+            }
+          }
+          if (contiguousElementsPerGroup) {
+            rangeMap[i] = {offset, 0, size};
+          }
         } else {
-          clearNull(rawNulls, i);
+          contiguousElementsPerGroup = false;
+          break;
         }
       }
-      if (currentSource) {
-        VELOX_DCHECK(!ranges.empty());
-        elements->copyRanges(currentSource->get(), ranges);
+      // fallback to copy if we can't get a contiguous range for each group
+      std::vector<BaseVector::CopyRange> ranges;
+      if (currentSource != nullptr && !contiguousElementsPerGroup) {
+        currentSource = nullptr;
+        for (int32_t i = 0; i < numGroups; ++i) {
+          auto* accumulator = value<ClusteredAccumulator>(groups[i]);
+          resultOffsets[i] = arrayOffset;
+          vector_size_t arraySize = 0;
+          for (auto& source : accumulator->sources) {
+            if (currentSource && currentSource->get() != source.vector.get()) {
+              elements->copyRanges(currentSource->get(), ranges);
+              ranges.clear();
+            }
+            if (!currentSource || currentSource->get() != source.vector.get()) {
+              currentSource = &source.vector;
+              ranges.push_back({source.offset, arrayOffset, source.size});
+            } else if (
+                ranges.back().sourceIndex + ranges.back().count ==
+                source.offset) {
+              ranges.back().count += source.size;
+            } else {
+              VELOX_DCHECK_LT(
+                  ranges.back().sourceIndex + ranges.back().count,
+                  source.offset);
+              ranges.push_back({source.offset, arrayOffset, source.size});
+            }
+            arrayOffset += source.size;
+            arraySize += source.size;
+          }
+          resultSizes[i] = arraySize;
+          if (arraySize == 0) {
+            vector->setNull(i, true);
+          } else {
+            clearNull(rawNulls, i);
+          }
+        }
+      }
+      if (currentSource != nullptr) {
+        VELOX_DCHECK(contiguousElementsPerGroup || !ranges.empty());
+        if (singleSource && contiguousElementsPerGroup) {
+          elements = BaseVector::loadedVectorShared(*currentSource);
+          for (int32_t i = 0; i < numGroups; ++i) {
+            if (rangeMap[i].count > 0) {
+              resultOffsets[i] = rangeMap[i].sourceIndex;
+              resultSizes[i] = rangeMap[i].count;
+              clearNull(rawNulls, i);
+            } else {
+              vector->setNull(i, true);
+            }
+          }
+        } else {
+          elements->copyRanges(currentSource->get(), ranges);
+        }
       }
-
     } else {
       for (int32_t i = 0; i < numGroups; ++i) {
         auto& values = value<ArrayAccumulator>(groups[i])->elements;
@@ -219,7 +276,7 @@ class ArrayAggAggregate : public exec::Aggregate {
     decodedElements_.decode(*args[0]);
     vector_size_t groupStart = 0;
     auto forEachAccumulator = [&](auto func) {
-      for (auto groupEnd : groupBoundaries) {
+      for (const vector_size_t groupEnd : groupBoundaries) {
         auto* accumulator = value<ClusteredAccumulator>(groups[groupEnd - 1]);
         func(groupEnd, accumulator);
         groupStart = groupEnd;
@@ -227,27 +284,29 @@ class ArrayAggAggregate : public exec::Aggregate {
     };
     if (rows.isAllSelected() &&
         (!ignoreNulls_ || !decodedElements_.mayHaveNulls())) {
-      forEachAccumulator([&](auto groupEnd, auto* accumulator) {
-        accumulator->sources.push_back(
-            {args[0], groupStart, groupEnd - groupStart});
-      });
+      forEachAccumulator(
+          [&](vector_size_t groupEnd, ClusteredAccumulator* accumulator) {
+            accumulator->sources.push_back(
+                {args[0], groupStart, groupEnd - groupStart});
+          });
     } else {
-      forEachAccumulator([&](auto groupEnd, auto* accumulator) {
-        for (auto i = groupStart; i < groupEnd; ++i) {
-          if (!rows.isValid(i) ||
-              (ignoreNulls_ && decodedElements_.isNullAt(i))) {
-            if (i > groupStart) {
+      forEachAccumulator(
+          [&](vector_size_t groupEnd, ClusteredAccumulator* accumulator) {
+            for (auto i = groupStart; i < groupEnd; ++i) {
+              if (!rows.isValid(i) ||
+                  (ignoreNulls_ && decodedElements_.isNullAt(i))) {
+                if (i > groupStart) {
+                  accumulator->sources.push_back(
+                      {args[0], groupStart, i - groupStart});
+                }
+                groupStart = i + 1;
+              }
+            }
+            if (groupEnd > groupStart) {
               accumulator->sources.push_back(
-                  {args[0], groupStart, i - groupStart});
+                  {args[0], groupStart, groupEnd - groupStart});
             }
-            groupStart = i + 1;
-          }
-        }
-        if (groupEnd > groupStart) {
-          accumulator->sources.push_back(
-              {args[0], groupStart, groupEnd - groupStart});
-        }
-      });
+          });
     }
   }
 
diff --git a/velox/functions/prestosql/aggregates/AverageAggregate.cpp b/velox/functions/prestosql/aggregates/AverageAggregate.cpp
index a18bab0784f4..4647956b9a3b 100644
--- a/velox/functions/prestosql/aggregates/AverageAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/AverageAggregate.cpp
@@ -37,35 +37,39 @@ void registerAverageAggregate(
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   for (const auto& inputType : {"smallint", "integer", "bigint", "double"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,bigint)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,bigint)")
+            .argumentType(inputType)
+            .build());
   }
 
   // Interval input type in Presto has special case and returns INTERVAL, not
   // DOUBLE.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType("interval day to second")
-                           .intermediateType("row(double,bigint)")
-                           .argumentType("interval day to second")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("interval day to second")
+          .intermediateType("row(double,bigint)")
+          .argumentType("interval day to second")
+          .build());
 
   // Real input type in Presto has special case and returns REAL, not DOUBLE.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType("real")
-                           .intermediateType("row(double,bigint)")
-                           .argumentType("real")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("real")
+          .intermediateType("row(double,bigint)")
+          .argumentType("real")
+          .build());
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .integerVariable("a_precision")
-                           .integerVariable("a_scale")
-                           .argumentType("DECIMAL(a_precision, a_scale)")
-                           .intermediateType("varbinary")
-                           .returnType("DECIMAL(a_precision, a_scale)")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("varbinary")
+          .returnType("DECIMAL(a_precision, a_scale)")
+          .build());
 
   auto name = prefix + kAvg;
   exec::registerAggregateFunction(
@@ -156,7 +160,7 @@ void registerAverageAggregate(
           }
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp b/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
index 1039ae39787e..a706086bcba8 100644
--- a/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/BitwiseAggregates.cpp
@@ -109,11 +109,13 @@ void registerBitwiseAggregates(
     bool overwrite) {
   registerBitwise<BitwiseOrAggregate>(
       prefix + kBitwiseOr,
+      true,
       withCompanionFunctions,
       onlyPrestoSignatures,
       overwrite);
   registerBitwise<BitwiseAndAggregate>(
       prefix + kBitwiseAnd,
+      true,
       withCompanionFunctions,
       onlyPrestoSignatures,
       overwrite);
diff --git a/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp b/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
index 120d92cb49f7..594e7ecf71c6 100644
--- a/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/BitwiseXorAggregate.cpp
@@ -82,11 +82,12 @@ void registerBitwiseXorAggregate(
     typeList = {"bigint"};
   }
   for (const auto& inputType : typeList) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(inputType)
-                             .intermediateType(inputType)
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(inputType)
+            .intermediateType(inputType)
+            .argumentType(inputType)
+            .build());
   }
 
   exec::registerAggregateFunction(
diff --git a/velox/functions/prestosql/aggregates/BoolAggregates.cpp b/velox/functions/prestosql/aggregates/BoolAggregates.cpp
index c9d690b7eb52..eb1bd8609da0 100644
--- a/velox/functions/prestosql/aggregates/BoolAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/BoolAggregates.cpp
@@ -210,7 +210,7 @@ exec::AggregateRegistrationResult registerBool(
             inputType->kindName());
         return std::make_unique<T>();
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.ignoreDuplicates = true, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/CMakeLists.txt b/velox/functions/prestosql/aggregates/CMakeLists.txt
index bcc5cf908b7e..adf7f00c2c5b 100644
--- a/velox/functions/prestosql/aggregates/CMakeLists.txt
+++ b/velox/functions/prestosql/aggregates/CMakeLists.txt
@@ -32,23 +32,35 @@ velox_add_library(
   EntropyAggregates.cpp
   GeometricMeanAggregate.cpp
   HistogramAggregate.cpp
+  KHyperLogLogAggregate.cpp
   MapAggAggregate.cpp
   MapUnionAggregate.cpp
   MapUnionSumAggregate.cpp
   MaxSizeForStatsAggregate.cpp
   MergeAggregate.cpp
+  NumericHistogramAggregate.cpp
   MinMaxAggregates.cpp
   MaxByAggregate.cpp
   MinByAggregate.cpp
   MultiMapAggAggregate.cpp
   PrestoHasher.cpp
+  QDigestAggAggregate.cpp
   ReduceAgg.cpp
+  ReservoirSampleAggregate.cpp
   RegisterAggregateFunctions.cpp
+  NoisyAvgGaussianAggregate.cpp
   NoisyCountIfGaussianAggregate.cpp
+  NoisyCountGaussianAggregate.cpp
+  NoisyHelperFunctionFactory.cpp
+  NoisySumGaussianAggregate.cpp
+  NoisyApproxSfmAggregate.cpp
   SetAggregates.cpp
+  SetDigestAggregate.cpp
   SumAggregate.cpp
   SumDataSizeForStatsAggregate.cpp
-  VarianceAggregates.cpp)
+  TDigestAggregate.cpp
+  VarianceAggregates.cpp
+)
 
 velox_link_libraries(
   velox_aggregates
@@ -56,11 +68,20 @@ velox_link_libraries(
   velox_exec
   velox_expression
   velox_presto_serializer
+  velox_presto_types
   velox_functions_aggregates
   velox_functions_lib
   velox_functions_util
   velox_presto_types
-  Folly::folly)
+  velox_functions_sfm
+  Folly::folly
+)
+
+if(${VELOX_ENABLE_GEO})
+  velox_sources(velox_aggregates PRIVATE GeometryAggregate.cpp)
+  velox_link_libraries(velox_aggregates velox_functions_geo)
+  velox_compile_definitions(velox_aggregates PRIVATE VELOX_ENABLE_GEO)
+endif()
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp b/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
index 110e5f7a9a40..53850486105c 100644
--- a/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/ChecksumAggregate.cpp
@@ -285,7 +285,7 @@ void registerChecksumAggregate(
 
         return std::make_unique<ChecksumAggregate>(VARBINARY());
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/CountAggregate.cpp b/velox/functions/prestosql/aggregates/CountAggregate.cpp
index a92d6cfcf26a..5e14e55527df 100644
--- a/velox/functions/prestosql/aggregates/CountAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/CountAggregate.cpp
@@ -183,7 +183,7 @@ void registerCountAggregate(
             argTypes.size(), 1, "{} takes at most one argument", name);
         return std::make_unique<CountAggregate>();
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/CountIfAggregate.cpp b/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
index 1b1fc3944515..ae896b7d9f3e 100644
--- a/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/CountIfAggregate.cpp
@@ -207,7 +207,7 @@ void registerCountIfAggregate(
 
         return std::make_unique<CountIfAggregate>();
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/EntropyAggregates.cpp b/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
index 3c1c5b877a19..1ec3c93b3418 100644
--- a/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/EntropyAggregates.cpp
@@ -348,11 +348,12 @@ void registerEntropyAggregate(
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   std::vector<std::string> inputTypes = {"smallint", "integer", "bigint"};
   for (const auto& inputType : inputTypes) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,double)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,double)")
+            .argumentType(inputType)
+            .build());
   }
 
   auto name = prefix + kEntropy;
diff --git a/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp b/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
index 05a1f75db976..9c4fc87aa6d4 100644
--- a/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/GeometricMeanAggregate.cpp
@@ -30,9 +30,8 @@ class GeometricMeanAggregate {
  public:
   using InputType = Row<TInput>;
 
-  using IntermediateType =
-      Row</*logSum*/ double,
-          /*count*/ int64_t>;
+  using IntermediateType = Row</*logSum*/ double,
+                               /*count*/ int64_t>;
 
   using OutputType = TResult;
 
@@ -94,19 +93,21 @@ void registerGeometricMeanAggregate(
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
   for (const auto& inputType : {"bigint", "double"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,bigint)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,bigint)")
+            .argumentType(inputType)
+            .build());
   }
 
   // Register for real input type.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .returnType("real")
-                           .intermediateType("row(double,bigint)")
-                           .argumentType("real")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("real")
+          .intermediateType("row(double,bigint)")
+          .argumentType("real")
+          .build());
 
   exec::registerAggregateFunction(
       name,
@@ -140,7 +141,7 @@ void registerGeometricMeanAggregate(
                 inputType->toString());
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/GeometryAggregate.cpp b/velox/functions/prestosql/aggregates/GeometryAggregate.cpp
new file mode 100644
index 000000000000..0a498b81563d
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/GeometryAggregate.cpp
@@ -0,0 +1,344 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/GeometryAggregate.h"
+
+#include <geos/geom/CoordinateSequence.h>
+#include <geos/geom/Geometry.h>
+
+#include "velox/common/geospatial/GeometrySerde.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/exec/Strings.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/functions/prestosql/types/GeometryRegistration.h"
+#include "velox/functions/prestosql/types/GeometryType.h"
+
+using namespace facebook::velox::exec;
+using facebook::velox::common::geospatial::GeometryDeserializer;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+// Take the convex hull of all the geometries.
+// This is more efficient than taking the pairwise convex hull.
+template <typename T>
+class ConvexHullAggregate {
+ public:
+  using InputType = Row<Geometry>;
+  using IntermediateType = Geometry;
+  using OutputType = Geometry;
+
+  struct AccumulatorType {
+    static constexpr bool use_external_memory_ = true;
+    static constexpr bool is_fixed_size_ = false;
+    static constexpr bool is_aligned_ = true;
+
+    ConvexHullAggregate* fn_;
+    std::vector<StringView> geometryData_{};
+    Strings strings_;
+
+    AccumulatorType() = delete;
+
+    explicit AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        ConvexHullAggregate* /*fn*/) {}
+
+    void destroy(HashStringAllocator* allocator) {
+      geometryData_.clear();
+      geometryData_.shrink_to_fit();
+      strings_.free(*allocator);
+    }
+
+    void addInput(
+        HashStringAllocator* allocator,
+        exec::arg_type<Geometry> value) {
+      addGeometry(allocator, value);
+    }
+
+    void combine(
+        HashStringAllocator* allocator,
+        arg_type<IntermediateType> other) {
+      addGeometry(allocator, other);
+    }
+
+    // If there are geometries, write to `out` and return true.
+    // Otherwise, return false.
+    bool writeGeometry(exec::out_type<OutputType>& out) {
+      std::unique_ptr<geos::geom::Geometry> hull = makeHull();
+      if (hull != nullptr) {
+        common::geospatial::GeometrySerializer::serialize(*hull, out);
+      }
+      return hull != nullptr;
+    }
+
+    bool writeFinalResult(exec::out_type<OutputType>& out) {
+      return writeGeometry(out);
+    }
+
+    bool writeIntermediateResult(out_type<IntermediateType>& out) {
+      return writeGeometry(out);
+    }
+
+   private:
+    void addGeometry(
+        HashStringAllocator* allocator,
+        exec::arg_type<Geometry> value) {
+      // Must add empty geometries here, because geometryData_.empty() will
+      // tell us if there has been at least one input (and thus will have
+      // non-null output).
+      if (!value.isInline()) {
+        value = strings_.append(value, *allocator);
+      }
+      geometryData_.push_back(value);
+    }
+
+    // Create a convex hull from all the stored coordinates.
+    // Returns a nullptr if there are no geometries to make a hull from.
+    std::unique_ptr<geos::geom::Geometry> makeHull() {
+      // No geometryData_ means no inputs, so return NULL
+      if (geometryData_.empty()) {
+        return nullptr;
+      }
+
+      std::vector<std::unique_ptr<geos::geom::Geometry>> geometries;
+      geometries.reserve(geometryData_.size());
+      for (const auto& data : geometryData_) {
+        auto geom = common::geospatial::GeometryDeserializer::deserialize(data);
+        VELOX_DCHECK_NOT_NULL(geom);
+        if (!geom->isEmpty()) {
+          geometries.push_back(std::move(geom));
+        }
+      }
+      if (geometries.empty()) {
+        return GeometryDeserializer::getGeometryFactory()
+            ->createEmptyGeometry();
+      }
+
+      // Calculate total number of points for efficient memory allocation
+      size_t totalPoints = 0;
+      for (const auto& geom : geometries) {
+        totalPoints += geom->getNumPoints();
+      }
+
+      // Create a single CoordinateSequence from all coordinates
+      auto coords =
+          std::make_unique<geos::geom::CoordinateArraySequence>(totalPoints, 2);
+      size_t index = 0;
+
+      // Add all coordinates from coordinate sequences
+      for (const auto& geom : geometries) {
+        auto coordSeq = geom->getCoordinates();
+        for (size_t i = 0; i < coordSeq->size(); ++i) {
+          VELOX_DCHECK_GT(coords->size(), index);
+          coords->setAt(coordSeq->getAt(i), index++);
+        }
+      }
+
+      auto points = std::unique_ptr<geos::geom::MultiPoint>(
+          GeometryDeserializer::getGeometryFactory()->createMultiPoint(
+              *coords));
+      return points->convexHull();
+    }
+  };
+};
+
+void registerConvexHullAggregate(const std::string& prefix, bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("geometry")
+          .intermediateType("geometry")
+          .argumentType("geometry")
+          .build());
+
+  std::string name = prefix + kConvexHull;
+  exec::registerAggregateFunction(
+      name,
+      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 (!isGeometryType(inputType)) {
+          VELOX_FAIL(
+              "Unexpected input type for {} aggregation {}",
+              name,
+              inputType->kindName());
+        }
+        return std::make_unique<
+            exec::SimpleAggregateAdapter<ConvexHullAggregate<Geometry>>>(
+            step, argTypes, resultType);
+      },
+      true /*registerCompanionFunctions*/,
+      overwrite);
+}
+
+template <typename T>
+class GeometryUnionAggregate {
+ public:
+  using InputType = Row<Geometry>;
+  using IntermediateType = Geometry;
+  using OutputType = Geometry;
+
+  struct AccumulatorType {
+    static constexpr bool use_external_memory_ = true;
+    static constexpr bool is_fixed_size_ = false;
+    static constexpr bool is_aligned_ = true;
+
+    GeometryUnionAggregate* fn_;
+    std::vector<StringView> geometryData_{};
+    Strings strings_;
+
+    AccumulatorType() = delete;
+
+    explicit AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        GeometryUnionAggregate* /*fn*/) {}
+
+    void destroy(HashStringAllocator* allocator) {
+      geometryData_.clear();
+      geometryData_.shrink_to_fit();
+      strings_.free(*allocator);
+    }
+
+    void addInput(
+        HashStringAllocator* allocator,
+        exec::arg_type<Geometry> value) {
+      addGeometry(allocator, value);
+    }
+
+    void combine(
+        HashStringAllocator* allocator,
+        arg_type<IntermediateType> other) {
+      addGeometry(allocator, other);
+    }
+
+    // If there are geometries, write to `out` and return true.
+    // Otherwise, return false.
+    bool writeGeometry(exec::out_type<OutputType>& out) {
+      std::unique_ptr<geos::geom::Geometry> geomUnion = makeUnion();
+      if (geomUnion != nullptr) {
+        common::geospatial::GeometrySerializer::serialize(*geomUnion, out);
+      }
+      return geomUnion != nullptr;
+    }
+
+    bool writeFinalResult(exec::out_type<OutputType>& out) {
+      return writeGeometry(out);
+    }
+
+    bool writeIntermediateResult(out_type<IntermediateType>& out) {
+      return writeGeometry(out);
+    }
+
+   private:
+    void addGeometry(
+        HashStringAllocator* allocator,
+        exec::arg_type<Geometry> value) {
+      // Must add empty geometries here, because geometryData_.empty() will
+      // tell us if there has been at least one input (and thus will have
+      // non-null output).
+      if (!value.isInline()) {
+        value = strings_.append(value, *allocator);
+      }
+      geometryData_.push_back(value);
+    }
+
+    // Create the geometries union from all the stored coordinates.
+    // Returns a nullptr if there has been no input.
+    std::unique_ptr<geos::geom::Geometry> makeUnion() {
+      // No geometryData_ means no inputs, so return NULL
+      if (geometryData_.empty()) {
+        return nullptr;
+      }
+
+      std::vector<std::unique_ptr<geos::geom::Geometry>> geometries;
+      geometries.reserve(geometryData_.size());
+      for (const auto& data : geometryData_) {
+        auto geom = common::geospatial::GeometryDeserializer::deserialize(data);
+        VELOX_DCHECK_NOT_NULL(geom);
+        if (!geom->isEmpty()) {
+          geometries.push_back(std::move(geom));
+        }
+      }
+      if (geometries.empty()) {
+        return GeometryDeserializer::getGeometryFactory()
+            ->createEmptyGeometry();
+      }
+
+      auto collection =
+          GeometryDeserializer::getGeometryFactory()->createGeometryCollection(
+              std::move(geometries));
+      return collection->Union();
+    }
+  };
+};
+
+void registerGeometryUnionAggregate(const std::string& prefix, bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("geometry")
+          .intermediateType("geometry")
+          .argumentType("geometry")
+          .build());
+
+  std::string name = prefix + kGeometryUnion;
+  exec::registerAggregateFunction(
+      name,
+      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 (!isGeometryType(inputType)) {
+          VELOX_FAIL(
+              "Unexpected input type for {} aggregation {}",
+              name,
+              inputType->kindName());
+        }
+        return std::make_unique<
+            exec::SimpleAggregateAdapter<GeometryUnionAggregate<Geometry>>>(
+            step, argTypes, resultType);
+      },
+      true /*registerCompanionFunctions*/,
+      overwrite);
+}
+
+} // namespace
+
+void registerGeometryAggregate(const std::string& prefix, bool overwrite) {
+  registerGeometryType();
+  registerConvexHullAggregate(prefix, overwrite);
+  registerGeometryUnionAggregate(prefix, overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/GeometryAggregate.h b/velox/functions/prestosql/aggregates/GeometryAggregate.h
new file mode 100644
index 000000000000..e649beea8512
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/GeometryAggregate.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::aggregate::prestosql {
+
+void registerGeometryAggregate(const std::string& prefix, bool overwrite);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/HistogramAggregate.cpp b/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
index e73acd9b257c..bd2465384c77 100644
--- a/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/HistogramAggregate.cpp
@@ -638,7 +638,7 @@ void registerHistogramAggregate(
                 inputType->toString());
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/HyperLogLogAggregate.h b/velox/functions/prestosql/aggregates/HyperLogLogAggregate.h
index e3a697620b4a..42c330cd8443 100644
--- a/velox/functions/prestosql/aggregates/HyperLogLogAggregate.h
+++ b/velox/functions/prestosql/aggregates/HyperLogLogAggregate.h
@@ -18,175 +18,17 @@
 #define XXH_INLINE_ALL
 #include <xxhash.h> // @manual=third-party//xxHash:xxhash
 
-#include "velox/common/hyperloglog/DenseHll.h"
+#include "velox/common/hyperloglog/HllAccumulator.h"
 #include "velox/common/hyperloglog/HllUtils.h"
-#include "velox/common/hyperloglog/Murmur3Hash128.h"
 #include "velox/common/hyperloglog/SparseHll.h"
-#include "velox/common/memory/HashStringAllocator.h"
 #include "velox/exec/Aggregate.h"
 #include "velox/vector/DecodedVector.h"
 #include "velox/vector/FlatVector.h"
 
-using facebook::velox::common::hll::DenseHll;
 using facebook::velox::common::hll::SparseHll;
 
 namespace facebook::velox::aggregate::prestosql {
 
-template <typename T, bool HllAsFinalResult>
-inline uint64_t hashOne(T value) {
-  if constexpr (HllAsFinalResult) {
-    if constexpr (std::is_same_v<T, int64_t>) {
-      return common::hll::Murmur3Hash128::hash64ForLong(value, 0);
-    } else if constexpr (std::is_same_v<T, double>) {
-      return common::hll::Murmur3Hash128::hash64ForLong(
-          *reinterpret_cast<int64_t*>(&value), 0);
-    }
-    return common::hll::Murmur3Hash128::hash64(&value, sizeof(T), 0);
-  } else {
-    return XXH64(&value, sizeof(T), 0);
-  }
-}
-
-// Use timestamp.toMillis() to compute hash value.
-template <>
-inline uint64_t hashOne<Timestamp, false>(Timestamp value) {
-  return hashOne<int64_t, false>(value.toMillis());
-}
-
-template <>
-inline uint64_t hashOne<Timestamp, true>(Timestamp /*value*/) {
-  VELOX_UNREACHABLE("approx_set(timestamp) is not supported.");
-}
-
-template <>
-inline uint64_t hashOne<StringView, false>(StringView value) {
-  return XXH64(value.data(), value.size(), 0);
-}
-
-template <>
-inline uint64_t hashOne<StringView, true>(StringView value) {
-  return common::hll::Murmur3Hash128::hash64(value.data(), value.size(), 0);
-}
-
-template <typename T, bool HllAsFinalResult>
-struct HllAccumulator {
-  explicit HllAccumulator(HashStringAllocator* allocator)
-      : sparseHll_{allocator}, denseHll_{allocator} {}
-
-  void setIndexBitLength(int8_t indexBitLength) {
-    indexBitLength_ = indexBitLength;
-    sparseHll_.setSoftMemoryLimit(
-        DenseHll::estimateInMemorySize(indexBitLength_));
-  }
-
-  void append(T value) {
-    const auto hash = hashOne<T, HllAsFinalResult>(value);
-
-    if (isSparse_) {
-      if (sparseHll_.insertHash(hash)) {
-        toDense();
-      }
-    } else {
-      denseHll_.insertHash(hash);
-    }
-  }
-
-  int64_t cardinality() const {
-    return isSparse_ ? sparseHll_.cardinality() : denseHll_.cardinality();
-  }
-
-  void mergeWith(StringView serialized, HashStringAllocator* allocator) {
-    auto input = serialized.data();
-    if (SparseHll::canDeserialize(input)) {
-      if (isSparse_) {
-        sparseHll_.mergeWith(input);
-        if (indexBitLength_ < 0) {
-          setIndexBitLength(DenseHll::deserializeIndexBitLength(input));
-        }
-        if (sparseHll_.overLimit()) {
-          toDense();
-        }
-      } else {
-        SparseHll other{input, allocator};
-        other.toDense(denseHll_);
-      }
-    } else if (DenseHll::canDeserialize(input)) {
-      if (isSparse_) {
-        if (indexBitLength_ < 0) {
-          setIndexBitLength(DenseHll::deserializeIndexBitLength(input));
-        }
-        toDense();
-      }
-      denseHll_.mergeWith(input);
-    } else {
-      VELOX_USER_FAIL("Unexpected type of HLL");
-    }
-  }
-
-  int32_t serializedSize() {
-    return isSparse_ ? sparseHll_.serializedSize() : denseHll_.serializedSize();
-  }
-
-  void serialize(char* outputBuffer) {
-    return isSparse_ ? sparseHll_.serialize(indexBitLength_, outputBuffer)
-                     : denseHll_.serialize(outputBuffer);
-  }
-
- private:
-  void toDense() {
-    isSparse_ = false;
-    denseHll_.initialize(indexBitLength_);
-    sparseHll_.toDense(denseHll_);
-    sparseHll_.reset();
-  }
-
-  bool isSparse_{true};
-  int8_t indexBitLength_{-1};
-  SparseHll sparseHll_;
-  DenseHll denseHll_;
-};
-
-template <>
-struct HllAccumulator<bool, false> {
-  explicit HllAccumulator(HashStringAllocator* /*allocator*/) {}
-
-  void append(bool value) {
-    approxDistinctState_ |= (1 << value);
-  }
-
-  int64_t cardinality() const {
-    return (approxDistinctState_ & 1) + ((approxDistinctState_ & 2) >> 1);
-  }
-
-  void mergeWith(
-      StringView /*serialized*/,
-      HashStringAllocator* /*allocator*/) {
-    VELOX_UNREACHABLE(
-        "APPROX_DISTINCT<BOOLEAN> unsupported mergeWith(StringView, HashStringAllocator*)");
-  }
-
-  void mergeWith(int8_t data) {
-    approxDistinctState_ |= data;
-  }
-
-  int32_t serializedSize() const {
-    return sizeof(int8_t);
-  }
-
-  void serialize(char* /*outputBuffer*/) {
-    VELOX_UNREACHABLE("APPROX_DISTINCT<BOOLEAN> unsupported serialize(char*)");
-  }
-
-  void setIndexBitLength(int8_t /*indexBitLength*/) {}
-
-  int8_t getState() const {
-    return approxDistinctState_;
-  }
-
- private:
-  int8_t approxDistinctState_{0};
-};
-
 template <typename T, bool HllAsFinalResult>
 class HyperLogLogAggregate : public exec::Aggregate {
  public:
@@ -200,11 +42,11 @@ class HyperLogLogAggregate : public exec::Aggregate {
         indexBitLength_{common::hll::toIndexBitLength(defaultError)} {}
 
   int32_t accumulatorFixedWidthSize() const override {
-    return sizeof(HllAccumulator<T, HllAsFinalResult>);
+    return sizeof(velox::common::hll::HllAccumulator<T, HllAsFinalResult>);
   }
 
   int32_t accumulatorAlignmentSize() const override {
-    return alignof(HllAccumulator<T, HllAsFinalResult>);
+    return alignof(velox::common::hll::HllAccumulator<T, HllAsFinalResult>);
   }
 
   bool isFixedSize() const override {
@@ -234,7 +76,8 @@ class HyperLogLogAggregate : public exec::Aggregate {
           groups,
           numGroups,
           flatResult,
-          [](HllAccumulator<T, HllAsFinalResult>* accumulator,
+          [](velox::common::hll::HllAccumulator<T, HllAsFinalResult>*
+                 accumulator,
              FlatVector<int64_t>* result,
              vector_size_t index) {
             result->set(index, accumulator->cardinality());
@@ -251,7 +94,8 @@ class HyperLogLogAggregate : public exec::Aggregate {
 
       for (auto i = 0; i < numGroups; ++i) {
         char* group = groups[i];
-        auto* accumulator = value<HllAccumulator<bool, false>>(group);
+        auto* accumulator =
+            value<velox::common::hll::HllAccumulator<bool, false>>(group);
         flatResult->set(i, accumulator->getState());
       }
 
@@ -262,7 +106,8 @@ class HyperLogLogAggregate : public exec::Aggregate {
           groups,
           numGroups,
           flatResult,
-          [&](HllAccumulator<T, HllAsFinalResult>* accumulator,
+          [&](velox::common::hll::HllAccumulator<T, HllAsFinalResult>*
+                  accumulator,
               FlatVector<StringView>* result,
               vector_size_t index) {
             auto size = accumulator->serializedSize();
@@ -298,7 +143,9 @@ class HyperLogLogAggregate : public exec::Aggregate {
 
         auto group = groups[row];
         auto tracker = trackRowSize(group);
-        auto accumulator = value<HllAccumulator<T, HllAsFinalResult>>(group);
+        auto accumulator =
+            value<velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(
+                group);
         clearNull(group);
         accumulator->setIndexBitLength(indexBitLength_);
         accumulator->append(decodedValue_.valueAt<T>(row));
@@ -342,7 +189,9 @@ class HyperLogLogAggregate : public exec::Aggregate {
           return;
         }
 
-        auto accumulator = value<HllAccumulator<T, HllAsFinalResult>>(group);
+        auto accumulator =
+            value<velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(
+                group);
         clearNull(group);
         accumulator->setIndexBitLength(indexBitLength_);
 
@@ -376,24 +225,26 @@ class HyperLogLogAggregate : public exec::Aggregate {
     setAllNulls(groups, indices);
     for (auto i : indices) {
       auto group = groups[i];
-      new (group + offset_) HllAccumulator<T, HllAsFinalResult>(allocator_);
+      new (group + offset_)
+          velox::common::hll::HllAccumulator<T, HllAsFinalResult>(allocator_);
     }
   }
 
   void destroyInternal(folly::Range<char**> groups) override {
-    destroyAccumulators<HllAccumulator<T, HllAsFinalResult>>(groups);
+    destroyAccumulators<
+        velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(groups);
   }
 
  private:
   void mergeToAccumulator(char* group, const vector_size_t row) {
     if constexpr (std::is_same_v<T, bool>) {
       static_assert(!HllAsFinalResult);
-      value<HllAccumulator<bool, false>>(group)->mergeWith(
+      value<velox::common::hll::HllAccumulator<bool, false>>(group)->mergeWith(
           decodedHll_.valueAt<int8_t>(row));
     } else {
       auto serialized = decodedHll_.valueAt<StringView>(row);
-      HllAccumulator<T, HllAsFinalResult>* accumulator =
-          value<HllAccumulator<T, HllAsFinalResult>>(group);
+      velox::common::hll::HllAccumulator<T, HllAsFinalResult>* accumulator =
+          value<velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(group);
       accumulator->mergeWith(serialized, allocator_);
     }
   }
@@ -432,7 +283,9 @@ class HyperLogLogAggregate : public exec::Aggregate {
           bits::clearBit(rawNulls, i);
         }
 
-        auto accumulator = value<HllAccumulator<T, HllAsFinalResult>>(group);
+        auto accumulator =
+            value<velox::common::hll::HllAccumulator<T, HllAsFinalResult>>(
+                group);
         extractFunction(accumulator, result, i);
       }
     }
diff --git a/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.cpp b/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.cpp
new file mode 100644
index 000000000000..09e5d3b3366f
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.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/functions/prestosql/aggregates/KHyperLogLogAggregate.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+
+using namespace facebook::velox::aggregate;
+
+namespace facebook::velox::aggregate::prestosql {
+namespace {
+
+template <TypeKind TValueKind, TypeKind TUiiKind>
+std::unique_ptr<exec::Aggregate> createKHyperLogLogAggregate(
+    const TypePtr& resultType) {
+  using TValue = typename TypeTraits<TValueKind>::NativeType;
+  using TUii = typename TypeTraits<TUiiKind>::NativeType;
+  return std::make_unique<KHyperLogLogAggregate<TValue, TUii>>(resultType);
+}
+
+template <TypeKind TJoinKeyKind>
+std::unique_ptr<exec::Aggregate> dispatchOnUiiType(
+    TypeKind uiiKind,
+    const TypePtr& resultType) {
+  return VELOX_DYNAMIC_SCALAR_TEMPLATE_TYPE_DISPATCH(
+      createKHyperLogLogAggregate, TJoinKeyKind, uiiKind, resultType);
+}
+
+/// Registration for khyperloglog_agg aggregate function.
+exec::AggregateRegistrationResult registerKHyperLogLogAgg(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  // Register all physical types for both JoinKey and UII.
+  std::vector<std::string> inputTypes = {
+      "boolean",
+      "tinyint",
+      "smallint",
+      "integer",
+      "bigint",
+      "real",
+      "double",
+      "varchar",
+      "varbinary",
+      "timestamp",
+      "date"};
+
+  // Generate all combinations of (joinKeyType, uiiType)
+  for (const auto& valueType : inputTypes) {
+    for (const auto& uiiType : inputTypes) {
+      signatures.push_back(
+          exec::AggregateFunctionSignatureBuilder()
+              .returnType("khyperloglog")
+              .intermediateType("khyperloglog")
+              .argumentType(valueType)
+              .argumentType(uiiType)
+              .build());
+    }
+  }
+
+  return exec::registerAggregateFunction(
+      name,
+      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(), 2, "{}: unexpected number of arguments", name);
+
+        auto joinKeyKind = argTypes[0]->kind();
+        auto uiiKind = argTypes[1]->kind();
+
+        // First dispatch on JoinKey type, then on UII type.
+        return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+            dispatchOnUiiType, joinKeyKind, uiiKind, resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+} // namespace
+
+void registerKHyperLogLogAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerKHyperLogLogAgg(
+      prefix + kKHyperLogLogAgg, withCompanionFunctions, overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h b/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h
new file mode 100644
index 000000000000..76dd0743f2b1
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/hyperloglog/KHyperLogLog.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+template <typename TValue, typename TUii>
+class KHyperLogLogAggregate : public exec::Aggregate {
+  using KHllAccumulator = common::hll::KHyperLogLog<TUii, HashStringAllocator>;
+
+ public:
+  explicit KHyperLogLogAggregate(const TypePtr& resultType)
+      : exec::Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(KHllAccumulator);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(KHllAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractAccumulators(groups, numGroups, result);
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    VELOX_CHECK(result);
+    auto* flatResult = (*result)->asFlatVector<StringView>();
+    flatResult->resize(numGroups);
+
+    BufferPtr& nulls = flatResult->mutableNulls(flatResult->size());
+    uint64_t* rawNulls = nulls->asMutable<uint64_t>();
+
+    // Calculate total size needed for non-inline strings.
+    int64_t totalSize = 0;
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<KHllAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+        if (!StringView::isInline(size)) {
+          totalSize += size;
+        }
+      }
+    }
+
+    // Allocate all required space at once.
+    char* rawBuffer = flatResult->getRawStringBufferWithSpace(totalSize);
+
+    // Serialize accumulators.
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        bits::clearBit(rawNulls, i);
+
+        auto* accumulator = value<KHllAccumulator>(group);
+        size_t size = accumulator->estimatedSerializedSize();
+
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+          rawBuffer += size;
+        }
+        flatResult->setNoCopy(i, serialized);
+      }
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows, true);
+    decodedUii_.decode(*args[1], rows, true);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row) || decodedUii_.isNullAt(row)) {
+        return;
+      }
+
+      auto group = groups[row];
+      auto tracker = trackRowSize(group);
+      auto* accumulator = value<KHllAccumulator>(group);
+      clearNull(group);
+
+      auto val = decodedValue_.valueAt<TValue>(row);
+      auto uii = decodedUii_.valueAt<TUii>(row);
+      accumulator->add(val, uii);
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows, true);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      auto group = groups[row];
+      auto tracker = trackRowSize(group);
+      clearNull(group);
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+      auto* accumulator = value<KHllAccumulator>(group);
+      accumulator->mergeWith(serialized, allocator_);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    auto tracker = trackRowSize(group);
+
+    decodedValue_.decode(*args[0], rows, true);
+    decodedUii_.decode(*args[1], rows, true);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row) || decodedUii_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<KHllAccumulator>(group);
+      clearNull(group);
+
+      auto val = decodedValue_.valueAt<TValue>(row);
+      auto uii = decodedUii_.valueAt<TUii>(row);
+      accumulator->add(val, uii);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows, true);
+
+    auto tracker = trackRowSize(group);
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+      auto* accumulator = value<KHllAccumulator>(group);
+      accumulator->mergeWith(serialized, allocator_);
+    });
+  }
+
+ 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_) KHllAccumulator(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<KHllAccumulator>(groups);
+  }
+
+ private:
+  DecodedVector decodedValue_;
+  DecodedVector decodedUii_;
+  DecodedVector decodedIntermediate_;
+};
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MapAggAggregate.cpp b/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
index 66986c8eb8e7..6c5a4cc5a1fe 100644
--- a/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MapAggAggregate.cpp
@@ -48,7 +48,7 @@ class MapAggAggregate : public MapAggregateBase<K, AccumulatorType> {
       const auto* indices = decodedKeys.indices();
       rows.applyToSelected([&](vector_size_t i) {
         velox::functions::checkNestedNulls(
-            decodedKeys, indices, i, throwOnNestedNulls_);
+            decodedKeys, i, indices[i], throwOnNestedNulls_);
       });
     }
 
@@ -105,7 +105,7 @@ class MapAggAggregate : public MapAggregateBase<K, AccumulatorType> {
 
     rows.applyToSelected([&](vector_size_t row) {
       if (velox::functions::checkNestedNulls(
-              Base::decodedKeys_, indices, row, throwOnNestedNulls_)) {
+              Base::decodedKeys_, row, indices[row], throwOnNestedNulls_)) {
         return;
       }
 
@@ -131,7 +131,7 @@ class MapAggAggregate : public MapAggregateBase<K, AccumulatorType> {
     auto tracker = Base::trackRowSize(group);
     rows.applyToSelected([&](vector_size_t row) {
       if (velox::functions::checkNestedNulls(
-              Base::decodedKeys_, indices, row, throwOnNestedNulls_)) {
+              Base::decodedKeys_, row, indices[row], throwOnNestedNulls_)) {
         return;
       }
 
@@ -225,7 +225,7 @@ void registerMapAggAggregate(
             return std::make_unique<MapAggAggregate<int32_t>>(resultType);
           default:
             VELOX_UNREACHABLE(
-                "Unexpected type {}", mapTypeKindToName(typeKind));
+                "Unexpected type {}", TypeKindName::toName(typeKind));
         }
       },
       withCompanionFunctions,
diff --git a/velox/functions/prestosql/aggregates/MapAggregateBase.h b/velox/functions/prestosql/aggregates/MapAggregateBase.h
index b49284b4ca45..e4df357d533b 100644
--- a/velox/functions/prestosql/aggregates/MapAggregateBase.h
+++ b/velox/functions/prestosql/aggregates/MapAggregateBase.h
@@ -200,8 +200,9 @@ class MapAggregateBase : public exec::Aggregate {
   DecodedVector decodedMaps_;
 };
 
-template <template <typename K, typename Accumulator = MapAccumulator<K>>
-          class TAggregate>
+template <template <
+    typename K,
+    typename Accumulator = MapAccumulator<K>> class TAggregate>
 std::unique_ptr<exec::Aggregate> createMapAggregate(const TypePtr& resultType) {
   auto typeKind = resultType->childAt(0)->kind();
   switch (typeKind) {
@@ -232,7 +233,7 @@ std::unique_ptr<exec::Aggregate> createMapAggregate(const TypePtr& resultType) {
     case TypeKind::UNKNOWN:
       return std::make_unique<TAggregate<int32_t>>(resultType);
     default:
-      VELOX_UNREACHABLE("Unexpected type {}", mapTypeKindToName(typeKind));
+      VELOX_UNREACHABLE("Unexpected type {}", TypeKindName::toName(typeKind));
   }
 }
 
diff --git a/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp b/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
index 449072bff8e5..807f295f9e7f 100644
--- a/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MapUnionSumAggregate.cpp
@@ -481,7 +481,7 @@ std::unique_ptr<exec::Aggregate> createMapUnionSumAggregate(
       return std::make_unique<MapUnionSumAggregate<K, double>>(resultType);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected value type {}", mapTypeKindToName(valueKind));
+          "Unexpected value type {}", TypeKindName::toName(valueKind));
   }
 }
 
@@ -563,7 +563,7 @@ void registerMapUnionSumAggregate(
                   valueTypeKind, resultType);
             }
             VELOX_UNREACHABLE(
-                "Unexpected key type {}", mapTypeKindToName(keyTypeKind));
+                "Unexpected key type {}", TypeKindName::toName(keyTypeKind));
         }
       },
       withCompanionFunctions,
diff --git a/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp b/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
index 936236a00c27..03955e42cd82 100644
--- a/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MaxSizeForStatsAggregate.cpp
@@ -211,12 +211,13 @@ void registerMaxDataSizeForStatsAggregate(
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .typeVariable("T")
-                           .returnType("bigint")
-                           .intermediateType("bigint")
-                           .argumentType("T")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("bigint")
+          .argumentType("T")
+          .build());
 
   auto name = prefix + kMaxSizeForStats;
   exec::registerAggregateFunction(
@@ -233,6 +234,7 @@ void registerMaxDataSizeForStatsAggregate(
 
         return std::make_unique<MaxSizeForStatsAggregate>(resultType);
       },
+      {.ignoreDuplicates = true, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/MergeAggregate.cpp b/velox/functions/prestosql/aggregates/MergeAggregate.cpp
index 47aec428220d..213ec0b65592 100644
--- a/velox/functions/prestosql/aggregates/MergeAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MergeAggregate.cpp
@@ -17,8 +17,16 @@
 #include "velox/expression/FunctionSignature.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/functions/prestosql/aggregates/HyperLogLogAggregate.h"
+#include "velox/functions/prestosql/aggregates/MergeKHyperLogLogAggregate.h"
+#include "velox/functions/prestosql/aggregates/MergeQDigestAggregate.h"
 #include "velox/functions/prestosql/aggregates/MergeTDigestAggregate.h"
+#include "velox/functions/prestosql/aggregates/SfmSketchAggregate.h"
 #include "velox/functions/prestosql/types/HyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/SfmSketchRegistration.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
 #include "velox/functions/prestosql/types/TDigestRegistration.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 
@@ -32,14 +40,22 @@ exec::AggregateRegistrationResult registerMerge(
     bool overwrite,
     double defaultError) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  auto inputTypes = std::vector<std::string>{"hyperloglog", "tdigest(double)"};
+  auto inputTypes = std::vector<std::string>{
+      "hyperloglog",
+      "khyperloglog",
+      "sfmsketch",
+      "tdigest(double)",
+      "qdigest(bigint)",
+      "qdigest(real)",
+      "qdigest(double)"};
   signatures.reserve(inputTypes.size());
   for (const auto& inputType : inputTypes) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType(inputType)
-                             .intermediateType("varbinary")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(inputType)
+            .intermediateType("varbinary")
+            .argumentType(inputType)
+            .build());
   }
   bool hllAsRawInput = true;
   bool hllAsFinalResult = true;
@@ -55,6 +71,22 @@ exec::AggregateRegistrationResult registerMerge(
         if (*argTypes[0] == *TDIGEST(DOUBLE())) {
           return createMergeTDigestAggregate(resultType);
         }
+        if (*argTypes[0] == *QDIGEST(BIGINT()) ||
+            *argTypes[0] == *QDIGEST(REAL()) ||
+            *argTypes[0] == *QDIGEST(DOUBLE())) {
+          return createMergeQDigestAggregate(resultType, argTypes[0]);
+        }
+        if (argTypes[0] == SFMSKETCH()) {
+          if (exec::isPartialOutput(step)) {
+            return std::make_unique<SfmSketchAggregate<true, false, true>>(
+                VARBINARY());
+          }
+          return std::make_unique<SfmSketchAggregate<true, false, true>>(
+              resultType);
+        }
+        if (argTypes[0] == KHYPERLOGLOG()) {
+          return std::make_unique<MergeKHyperLogLogAggregate>(resultType);
+        }
         if (argTypes[0]->isUnKnown()) {
           return std::make_unique<HyperLogLogAggregate<UnknownValue, true>>(
               resultType, hllAsRawInput, defaultError);
@@ -82,8 +114,11 @@ void registerMergeAggregate(
     const std::string& prefix,
     bool /* withCompanionFunctions */,
     bool overwrite) {
+  registerSfmSketchType();
   registerHyperLogLogType();
+  registerKHyperLogLogType();
   registerTDigestType();
+  registerQDigestType();
   // merge is companion function for approx_distinct. Don't register companion
   // functions for it.
   registerMerge(
diff --git a/velox/functions/prestosql/aggregates/MergeKHyperLogLogAggregate.h b/velox/functions/prestosql/aggregates/MergeKHyperLogLogAggregate.h
new file mode 100644
index 000000000000..9dc0b3652a79
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/MergeKHyperLogLogAggregate.h
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/hyperloglog/KHyperLogLog.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+class MergeKHyperLogLogAggregate : public exec::Aggregate {
+  using MergeKHllAccumulator =
+      common::hll::KHyperLogLog<int64_t, HashStringAllocator>;
+
+ public:
+  explicit MergeKHyperLogLogAggregate(const TypePtr& resultType)
+      : exec::Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(MergeKHllAccumulator);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(MergeKHllAccumulator);
+  }
+
+  bool accumulatorUsesExternalMemory() const override {
+    return true;
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  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)
+      override {
+    extractAccumulators(groups, numGroups, result);
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    VELOX_CHECK(result);
+    auto* flatResult = (*result)->asFlatVector<StringView>();
+    flatResult->resize(numGroups);
+
+    uint64_t* rawNulls = nullptr;
+    if (flatResult->mayHaveNulls()) {
+      BufferPtr& nulls = flatResult->mutableNulls(flatResult->size());
+      rawNulls = nulls->asMutable<uint64_t>();
+    }
+
+    // Calculate total size needed for non-inline strings.
+    int64_t totalSize = 0;
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<MergeKHllAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+        if (!StringView::isInline(size)) {
+          totalSize += size;
+        }
+      }
+    }
+
+    // Allocate all required space at once.
+    char* rawBuffer = flatResult->getRawStringBufferWithSpace(totalSize);
+
+    // Serialize accumulators.
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        if (rawNulls) {
+          bits::clearBit(rawNulls, i);
+        }
+
+        auto* accumulator = value<MergeKHllAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+          rawBuffer += size;
+        }
+        flatResult->setNoCopy(i, serialized);
+      }
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediateResults(groups, rows, args, false);
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedKHll_.decode(*args[0], rows, true);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedKHll_.isNullAt(row)) {
+        return;
+      }
+
+      auto group = groups[row];
+      auto tracker = trackRowSize(group);
+      clearNull(group);
+
+      auto serialized = decodedKHll_.valueAt<StringView>(row);
+      auto* accumulator = value<MergeKHllAccumulator>(group);
+      accumulator->mergeWith(serialized, allocator_);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addSingleGroupIntermediateResults(group, rows, args, false);
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedKHll_.decode(*args[0], rows, true);
+
+    auto tracker = trackRowSize(group);
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedKHll_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedKHll_.valueAt<StringView>(row);
+      auto* accumulator = value<MergeKHllAccumulator>(group);
+      accumulator->mergeWith(serialized, allocator_);
+    });
+  }
+
+ 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_) MergeKHllAccumulator(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<MergeKHllAccumulator>(groups);
+  }
+
+ private:
+  DecodedVector decodedKHll_;
+};
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MergeQDigestAggregate.h b/velox/functions/prestosql/aggregates/MergeQDigestAggregate.h
new file mode 100644
index 000000000000..cca856374824
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/MergeQDigestAggregate.h
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/functions/lib/QuantileDigest.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+template <typename T>
+struct QDigestAccumulator {
+  explicit QDigestAccumulator(HashStringAllocator* allocator)
+      : digest_(
+            StlAllocator<T>(allocator),
+            facebook::velox::functions::qdigest::kUninitializedMaxError) {}
+
+  void mergeWith(StringView serialized) {
+    if (serialized.empty()) {
+      return;
+    }
+    digest_.mergeSerialized(serialized.data());
+  }
+
+  int64_t serializedSize() {
+    return digest_.serializedByteSize();
+  }
+
+  void serialize(char* outputBuffer) {
+    // merge(qdigest) result and intermediate result should aways have maxError
+    // set
+    VELOX_USER_CHECK_NE(
+        digest_.getMaxError(),
+        facebook::velox::functions::qdigest::kUninitializedMaxError,
+        "QDigest maxError is uninitialized");
+    digest_.serialize(outputBuffer);
+  }
+
+ private:
+  facebook::velox::functions::qdigest::QuantileDigest<T, StlAllocator<T>>
+      digest_;
+};
+
+template <typename T>
+class MergeQDigestAggregate : public exec::Aggregate {
+ public:
+  explicit MergeQDigestAggregate(const TypePtr& resultType)
+      : exec::Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(QDigestAccumulator<T>);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(QDigestAccumulator<T>);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  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)
+      override {
+    extractAccumulators(groups, numGroups, result);
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    VELOX_CHECK(result);
+    auto* flatResult = (*result)->asFlatVector<StringView>();
+    extract(groups, numGroups, flatResult);
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediateResults(groups, rows, args, false /*unused*/);
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedQDigest_.decode(*args[0], rows, true);
+
+    rows.applyToSelected([&](auto row) {
+      if (decodedQDigest_.isNullAt(row)) {
+        return;
+      }
+
+      auto group = groups[row];
+      auto tracker = trackRowSize(group);
+      clearNull(group);
+
+      mergeToAccumulator(group, row);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addSingleGroupIntermediateResults(group, rows, args, false /*unused*/);
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedQDigest_.decode(*args[0], rows, true);
+
+    auto tracker = trackRowSize(group);
+    rows.applyToSelected([&](auto row) {
+      if (decodedQDigest_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+      mergeToAccumulator(group, row);
+    });
+  }
+
+ 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_) QDigestAccumulator<T>(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<QDigestAccumulator<T>>(groups);
+  }
+
+ private:
+  void mergeToAccumulator(char* group, const vector_size_t row) {
+    auto serialized = decodedQDigest_.valueAt<StringView>(row);
+    QDigestAccumulator<T>* accumulator = value<QDigestAccumulator<T>>(group);
+    accumulator->mergeWith(serialized);
+  }
+
+  void
+  extract(char** groups, int32_t numGroups, FlatVector<StringView>* result) {
+    VELOX_CHECK(result);
+    result->resize(numGroups);
+
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        // Set null for null input
+        result->setNull(i, true);
+      } else {
+        auto accumulator = value<QDigestAccumulator<T>>(group);
+        auto size = accumulator->serializedSize();
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          char* rawBuffer = result->getRawStringBufferWithSpace(size);
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+        }
+        result->setNoCopy(i, serialized);
+      }
+    }
+  }
+  DecodedVector decodedQDigest_;
+};
+
+inline std::unique_ptr<exec::Aggregate> createMergeQDigestAggregate(
+    const TypePtr& resultType,
+    const TypePtr& argType = nullptr) {
+  VELOX_CHECK_NOT_NULL(argType);
+  if (*argType == *QDIGEST(BIGINT())) {
+    return std::make_unique<MergeQDigestAggregate<int64_t>>(resultType);
+  } else if (*argType == *QDIGEST(REAL())) {
+    return std::make_unique<MergeQDigestAggregate<float>>(resultType);
+  } else if (*argType == *QDIGEST(DOUBLE())) {
+    return std::make_unique<MergeQDigestAggregate<double>>(resultType);
+  }
+  VELOX_UNSUPPORTED("QDigest {} type is not supported.", argType->toString());
+}
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp b/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
index 3acd58788b46..25c812e48c0f 100644
--- a/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/MinMaxAggregates.cpp
@@ -17,12 +17,12 @@
 #include "velox/functions/prestosql/aggregates/MinMaxAggregates.h"
 #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/ValueSet.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
 #include "velox/type/FloatingPointUtil.h"
+#include "velox/vector/AggregationHook.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -497,12 +497,13 @@ exec::AggregateRegistrationResult registerMinMax(
     bool overwrite,
     bool registerMin) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .orderableTypeVariable("T")
-                           .returnType("T")
-                           .intermediateType("T")
-                           .argumentType("T")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .orderableTypeVariable("T")
+          .returnType("T")
+          .intermediateType("T")
+          .argumentType("T")
+          .build());
   for (const auto& type :
        {"tinyint",
         "integer",
@@ -594,7 +595,7 @@ exec::AggregateRegistrationResult registerMinMax(
           }
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h b/velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h
index 5329df3ca5cf..a0899b370b58 100644
--- a/velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h
+++ b/velox/functions/prestosql/aggregates/MinMaxByAggregateBase.h
@@ -1127,25 +1127,24 @@ template <
         typename V,
         bool B1,
         class C,
-        bool compareTypeUsesCustomComparison>
-    class Aggregate,
+        bool compareTypeUsesCustomComparison> class Aggregate,
     bool isMaxFunc,
-    template <typename U, typename V>
-    class NAggregate>
+    template <typename U, typename V> class NAggregate>
 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")
-                           .orderableTypeVariable("C")
-                           .returnType("V")
-                           .intermediateType("row(V,C)")
-                           .argumentType("V")
-                           .argumentType("C")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("V")
+          .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",
@@ -1163,15 +1162,16 @@ exec::AggregateRegistrationResult registerMinMaxBy(
   // Add support for all value types to 3-arg version of the aggregate.
   for (const auto& compareType : supportedCompareTypes) {
     // V, C, bigint -> row(bigint, array(C), array(V)) -> array(V).
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .typeVariable("V")
-                             .returnType("array(V)")
-                             .intermediateType(fmt::format(
-                                 "row(bigint,array({}),array(V))", compareType))
-                             .argumentType("V")
-                             .argumentType(compareType)
-                             .argumentType("bigint")
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .typeVariable("V")
+            .returnType("array(V)")
+            .intermediateType(
+                fmt::format("row(bigint,array({}),array(V))", compareType))
+            .argumentType("V")
+            .argumentType(compareType)
+            .argumentType("bigint")
+            .build());
   }
   signatures.push_back(
       exec::AggregateFunctionSignatureBuilder()
diff --git a/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp b/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
index 917230589519..727b035066e2 100644
--- a/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/MultiMapAggAggregate.cpp
@@ -666,7 +666,7 @@ void registerMultiMapAggAggregate(
             return std::make_unique<MultiMapAggAggregate<int32_t>>(resultType);
           default:
             VELOX_UNREACHABLE(
-                "Unexpected type {}", mapTypeKindToName(typeKind));
+                "Unexpected type {}", TypeKindName::toName(typeKind));
         }
       },
       withCompanionFunctions,
diff --git a/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.cpp b/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.cpp
new file mode 100644
index 000000000000..dfa1a2c527be
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.cpp
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/expression/FunctionSignature.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/functions/prestosql/aggregates/SfmSketchAggregate.h"
+#include "velox/functions/prestosql/types/SfmSketchRegistration.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+void registerNoisyApproxSfmAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  // Register the SfmSketch type.
+  registerSfmSketchType();
+
+  std::vector<std::string> supportedInputTypes = {
+      "bigint", "double", "varchar", "varbinary"};
+
+  auto setBuilder = []() {
+    return exec::AggregateFunctionSignatureBuilder()
+        .returnType("sfmsketch")
+        .intermediateType("varbinary");
+  };
+  auto countBuilder = []() {
+    return exec::AggregateFunctionSignatureBuilder()
+        .returnType("bigint")
+        .intermediateType("varbinary");
+  };
+
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> setSignatures;
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>
+      countSignatures;
+  for (const auto& inputType : supportedInputTypes) {
+    setSignatures.push_back(
+        setBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .build());
+    setSignatures.push_back(
+        setBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .constantArgumentType("bigint")
+            .build());
+    setSignatures.push_back(
+        setBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .constantArgumentType("bigint")
+            .constantArgumentType("bigint")
+            .build());
+    countSignatures.push_back(
+        countBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .build());
+    countSignatures.push_back(
+        countBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .constantArgumentType("bigint")
+            .build());
+    countSignatures.push_back(
+        countBuilder()
+            .argumentType(inputType)
+            .constantArgumentType("double")
+            .constantArgumentType("bigint")
+            .constantArgumentType("bigint")
+            .build());
+  }
+
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>
+      setFromIndexAndZerosSignatures;
+
+  setFromIndexAndZerosSignatures.push_back(
+      setBuilder()
+          .argumentType("bigint") // col_index
+          .argumentType("bigint") // col_zeros
+          .constantArgumentType("double") // epsilon
+          .constantArgumentType("bigint") // buckets
+          .build());
+  setFromIndexAndZerosSignatures.push_back(
+      setBuilder()
+          .argumentType("bigint") // col_index
+          .argumentType("bigint") // col_zeros
+          .constantArgumentType("double") // epsilon
+          .constantArgumentType("bigint") // buckets
+          .constantArgumentType("bigint") // precision
+          .build());
+
+  exec::registerAggregateFunction(
+      prefix + kNoisyApproxSetSfm,
+      setSignatures,
+      [prefix](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& /*argTypes*/,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        if (exec::isPartialOutput(step)) {
+          return std::make_unique<SfmSketchAggregate<true, false, false>>(
+              VARBINARY());
+        }
+        return std::make_unique<SfmSketchAggregate<true, false, false>>(
+            resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+
+  exec::registerAggregateFunction(
+      prefix + kNoisyApproxDistinctSfm,
+      countSignatures,
+      [prefix](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& /*argTypes*/,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        if (exec::isPartialOutput(step)) {
+          return std::make_unique<SfmSketchAggregate<false, false, false>>(
+              VARBINARY());
+        }
+        return std::make_unique<SfmSketchAggregate<false, false, false>>(
+            resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+
+  exec::registerAggregateFunction(
+      prefix + kNoisyApproxSetSfmFromIndexAndZeros,
+      setFromIndexAndZerosSignatures,
+      [prefix](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& /*argTypes*/,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        if (exec::isPartialOutput(step)) {
+          return std::make_unique<SfmSketchAggregate<true, true, false>>(
+              VARBINARY());
+        }
+        return std::make_unique<SfmSketchAggregate<true, true, false>>(
+            resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.h b/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.h
new file mode 100644
index 000000000000..7eb6937dff91
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.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::aggregate::prestosql {
+
+void registerNoisyApproxSfmAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.cpp b/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.cpp
new file mode 100644
index 000000000000..4cfd8623908c
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.cpp
@@ -0,0 +1,361 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/NoisyAvgGaussianAggregate.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+class NoisyAvgGaussianAggregate : public exec::Aggregate {
+ public:
+  explicit NoisyAvgGaussianAggregate(TypePtr resultType)
+      : exec::Aggregate(std::move(resultType)) {}
+
+  using AccumulatorType = functions::aggregate::NoisyCountSumAvgAccumulator;
+
+  bool isFixedSize() const override {
+    return true;
+  }
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return static_cast<int32_t>(sizeof(AccumulatorType));
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    NoisyHelperFunctionFactory::decodeInputData(
+        decodedValue_,
+        decodedNoiseScale_,
+        decodedLowerBound_,
+        decodedUpperBound_,
+        decodedRandomSeed_,
+        rows,
+        args);
+    bool hasBounds = NoisyHelperFunctionFactory::checkBounds(args);
+    bool hasRandomSeed = NoisyHelperFunctionFactory::checkRandomSeed(args);
+
+    // Process the args data and update the accumulator for each group.
+    rows.applyToSelected([&](vector_size_t i) {
+      auto accumulator = value<AccumulatorType>(groups[i]);
+      NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+          decodedValue_,
+          decodedNoiseScale_,
+          decodedLowerBound_,
+          decodedUpperBound_,
+          decodedRandomSeed_,
+          args,
+          *accumulator,
+          i,
+          hasBounds,
+          hasRandomSeed);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    NoisyHelperFunctionFactory::decodeInputData(
+        decodedValue_,
+        decodedNoiseScale_,
+        decodedLowerBound_,
+        decodedUpperBound_,
+        decodedRandomSeed_,
+        rows,
+        args);
+    bool hasBounds = NoisyHelperFunctionFactory::checkBounds(args);
+    bool hasRandomSeed = NoisyHelperFunctionFactory::checkRandomSeed(args);
+
+    auto accumulator = exec::Aggregate::value<AccumulatorType>(group);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+          decodedValue_,
+          decodedNoiseScale_,
+          decodedLowerBound_,
+          decodedUpperBound_,
+          decodedRandomSeed_,
+          args,
+          *accumulator,
+          i,
+          hasBounds,
+          hasRandomSeed);
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    DecodedVector decodedVector(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      auto* accumulator = exec::Aggregate::value<AccumulatorType>(groups[i]);
+      NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+          *accumulator, decodedVector, i);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    DecodedVector decodedVector(*args[0], rows);
+    auto* accumulator = exec::Aggregate::value<AccumulatorType>(group);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+          *accumulator, decodedVector, i);
+    });
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    std::function<bool(char*)> isNull = [this](char* group) {
+      return this->isNull(group);
+    };
+
+    std::function<AccumulatorType(char*)> getAccumulator = [this](char* group) {
+      return *this->value<AccumulatorType>(group);
+    };
+
+    NoisyHelperFunctionFactory::extractAccumulators(
+        isNull, getAccumulator, groups, numGroups, result);
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto* vector = (*result)->as<FlatVector<double>>();
+    VELOX_CHECK(vector);
+    vector->resize(numGroups);
+
+    std::function<bool(char*)> isNull = [this](char* group) {
+      return this->isNull(group);
+    };
+    std::function<AccumulatorType(char*)> getAccumulator = [this](char* group) {
+      return *this->value<AccumulatorType>(group);
+    };
+
+    auto [noiseScale, randomSeed] =
+        NoisyHelperFunctionFactory::getFinalNoiseScaleAndRandomSeed(
+            isNull, getAccumulator, groups, numGroups);
+
+    if (noiseScale < 0) {
+      for (auto i = 0; i < numGroups; ++i) {
+        vector->setNull(i, true);
+      }
+      return;
+    }
+
+    NoisyHelperFunctionFactory::NoiseGenerator gen{noiseScale, randomSeed};
+
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      auto accumulator = value<AccumulatorType>(group);
+      if (isNull(group)) {
+        vector->setNull(i, true);
+        continue;
+      }
+      // For groups that have allNull Values
+      if (accumulator->getNoiseScale() < 0) {
+        vector->setNull(i, true);
+        continue;
+      }
+
+      uint64_t trueCount = accumulator->getCount();
+      double trueSum = accumulator->getSum();
+      VELOX_CHECK_LE(trueCount, std::numeric_limits<double>::max());
+      double trueAvg = trueSum / static_cast<double>(trueCount);
+      double noise = gen.nextNoise();
+
+      double noisyAvg = trueAvg + noise;
+      double finalResult = NoisyHelperFunctionFactory::postProcessNoisyValue(
+          noisyAvg, *accumulator);
+      vector->set(i, finalResult);
+    }
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    // Initialize the accumulator for each group
+    for (auto i : indices) {
+      *value<AccumulatorType>(groups[i]) = AccumulatorType();
+    }
+  }
+
+ private:
+  DecodedVector decodedValue_;
+  DecodedVector decodedNoiseScale_;
+  DecodedVector decodedLowerBound_;
+  DecodedVector decodedUpperBound_;
+  DecodedVector decodedRandomSeed_;
+};
+} // namespace
+
+void registerNoisyAvgGaussianAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  // Helper function to create a signature builder with return and
+  // intermediate types
+  auto createBuilder = []() {
+    return exec::AggregateFunctionSignatureBuilder()
+        .returnType("double")
+        .intermediateType("varbinary");
+  };
+
+  // List of possible argument types.
+  const std::vector<std::string> simpleDataTypes = {
+      "tinyint", "smallint", "integer", "bigint", "real", "double"};
+  const std::vector<std::string> noiseScaleTypes = {"double", "bigint"};
+  const std::vector<std::string> boundTypes = {"double", "bigint"};
+  const std::string randomSeedType = "bigint";
+
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  // Generate signatures for all type combinations.
+  for (const auto& noiseScaleType : noiseScaleTypes) {
+    // Handle simple types.
+    for (const auto& dataType : simpleDataTypes) {
+      // Signature 1: (col, noise_scale)
+      signatures.push_back(
+          createBuilder()
+              .argumentType(dataType)
+              .argumentType(noiseScaleType)
+              .build());
+      // Signature 2: (col, noise_scale, random_seed)
+      signatures.push_back(
+          createBuilder()
+              .argumentType(dataType)
+              .argumentType(noiseScaleType)
+              .argumentType(randomSeedType)
+              .build());
+
+      for (const auto& lowerBoundType : boundTypes) {
+        for (const auto& upperBoundType : boundTypes) {
+          // Signature 3: (col, noise_scale, lower_bound, upper_bound)
+          signatures.push_back(
+              createBuilder()
+                  .argumentType(dataType)
+                  .argumentType(noiseScaleType)
+                  .argumentType(lowerBoundType)
+                  .argumentType(upperBoundType)
+                  .build());
+          // Signature 4: (col, noise_scale, lower_bound, upper_bound,
+          // random_seed)
+          signatures.push_back(
+              createBuilder()
+                  .argumentType(dataType)
+                  .argumentType(noiseScaleType)
+                  .argumentType(lowerBoundType)
+                  .argumentType(upperBoundType)
+                  .argumentType(randomSeedType)
+                  .build());
+        }
+      }
+    }
+    // Handle decimal types separately.
+    // Signature 1: (col, noise_scale)
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("double")
+            .intermediateType("varbinary")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType(noiseScaleType)
+            .build());
+    // Signature 2: (col, noise_scale, random_seed)
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("double")
+            .intermediateType("varbinary")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType(noiseScaleType)
+            .argumentType(randomSeedType)
+            .build());
+
+    for (const auto& lowerBoundType : boundTypes) {
+      for (const auto& upperBoundType : boundTypes) {
+        // Signature 3: (col, noise_scale, lower_bound, upper_bound)
+        signatures.push_back(
+            exec::AggregateFunctionSignatureBuilder()
+                .integerVariable("a_precision")
+                .integerVariable("a_scale")
+                .returnType("double")
+                .intermediateType("varbinary")
+                .argumentType("DECIMAL(a_precision, a_scale)")
+                .argumentType(noiseScaleType)
+                .argumentType(lowerBoundType)
+                .argumentType(upperBoundType)
+                .build());
+        // Signature 4: (col, noise_scale, lower_bound, upper_bound,
+        // random_seed)
+        signatures.push_back(
+            exec::AggregateFunctionSignatureBuilder()
+                .integerVariable("a_precision")
+                .integerVariable("a_scale")
+                .returnType("double")
+                .intermediateType("varbinary")
+                .argumentType("DECIMAL(a_precision, a_scale)")
+                .argumentType(noiseScaleType)
+                .argumentType(lowerBoundType)
+                .argumentType(upperBoundType)
+                .argumentType(randomSeedType)
+                .build());
+      }
+    }
+  }
+
+  auto name = prefix + kNoisyAvgGaussian;
+  exec::registerAggregateFunction(
+      name,
+      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_GE(
+            argTypes.size(), 2, "{} takes at least 2 arguments", name);
+
+        if (exec::isPartialOutput(step)) {
+          return std::make_unique<NoisyAvgGaussianAggregate>(VARBINARY());
+        }
+        return std::make_unique<NoisyAvgGaussianAggregate>(DOUBLE());
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.h b/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.h
new file mode 100644
index 000000000000..6aae61c25713
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.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::aggregate::prestosql {
+
+void registerNoisyAvgGaussianAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.cpp b/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.cpp
new file mode 100644
index 000000000000..bab27306a66f
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.cpp
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/NoisyCountGaussianAggregate.h"
+#include <cmath>
+#include "velox/exec/Aggregate.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h"
+#include "velox/vector/FlatVector.h"
+
+using namespace facebook::velox::functions::aggregate;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+class NoisyCountGaussianAggregate : public exec::Aggregate {
+ public:
+  explicit NoisyCountGaussianAggregate(TypePtr resultType)
+      : exec::Aggregate(std::move(resultType)) {}
+
+  using AccumulatorType = functions::aggregate::NoisyCountSumAvgAccumulator;
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return static_cast<int32_t>(sizeof(AccumulatorType));
+  }
+
+  bool isFixedSize() const override {
+    return true;
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    NoisyHelperFunctionFactory::decodeInputData(
+        decodedValue_, decodedNoiseScale_, decodedRandomSeed_, rows, args);
+    bool hasRandomSeed = NoisyHelperFunctionFactory::checkRandomSeed(args);
+
+    // Process the args data and update the accumulator for each group.
+    rows.applyToSelected([&](vector_size_t i) {
+      auto accumulator = exec::Aggregate::value<AccumulatorType>(groups[i]);
+      NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+          decodedValue_,
+          decodedNoiseScale_,
+          decodedRandomSeed_,
+          args,
+          *accumulator,
+          i,
+          hasRandomSeed);
+    });
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    std::function<bool(char*)> isNull = [this](char* group) {
+      return this->isNull(group);
+    };
+
+    std::function<AccumulatorType(char*)> getAccumulator = [this](char* group) {
+      return *this->value<AccumulatorType>(group);
+    };
+
+    NoisyHelperFunctionFactory::extractAccumulators(
+        isNull, getAccumulator, groups, numGroups, result);
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    auto decodedVector = DecodedVector(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      auto* accumulator = exec::Aggregate::value<AccumulatorType>(groups[i]);
+      NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+          *accumulator, decodedVector, i);
+    });
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto* vector = (*result)->as<FlatVector<int64_t>>();
+    VELOX_CHECK(vector);
+    vector->resize(numGroups);
+
+    std::function<bool(char*)> isNull = [this](char* group) {
+      return this->isNull(group);
+    };
+    std::function<AccumulatorType(char*)> getAccumulator = [this](char* group) {
+      return *this->value<AccumulatorType>(group);
+    };
+
+    auto [noiseScale, randomSeed] =
+        NoisyHelperFunctionFactory::getFinalNoiseScaleAndRandomSeed(
+            isNull, getAccumulator, groups, numGroups);
+
+    if (noiseScale < 0) {
+      for (auto i = 0; i < numGroups; ++i) {
+        vector->setNull(i, true);
+      }
+      return;
+    }
+
+    NoisyHelperFunctionFactory::NoiseGenerator gen{noiseScale, randomSeed};
+
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        vector->setNull(i, true);
+        continue;
+      }
+      auto* accumulator = value<AccumulatorType>(group);
+      // For groups that have allNull Values
+      if (accumulator->getNoiseScale() < 0) {
+        vector->setNull(i, true);
+        continue;
+      }
+
+      double rawNoise = gen.nextNoise();
+
+      VELOX_USER_CHECK_GE(
+          rawNoise,
+          static_cast<double>(std::numeric_limits<int64_t>::min()),
+          "Noise is too large. Please reduce noise scale.");
+      VELOX_USER_CHECK_LE(
+          rawNoise,
+          static_cast<double>(std::numeric_limits<int64_t>::max()),
+          "Noise is too large. Please reduce noise scale.");
+      auto noise = static_cast<int64_t>(
+          std::round(rawNoise)); // Need to round back to int64_t because
+                                 // we want to return int64_t
+
+      uint64_t trueCount = accumulator->getCount();
+      // Check that true count won't overflow converting from unsigned int to
+      // signed int. We need the conversion because noise is signed int.
+      VELOX_CHECK_LT(
+          trueCount,
+          static_cast<uint64_t>(std::numeric_limits<int64_t>::max()));
+      int64_t noisyCount = checkedPlus(static_cast<int64_t>(trueCount), noise);
+
+      // Post-process the noisy count to make sure it is non-negative
+      vector->set(i, std::max<int64_t>(noisyCount, 0L));
+    }
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    DecodedVector decodedVector(*args[0], rows);
+    auto accumulator = exec::Aggregate::value<AccumulatorType>(group);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+          *accumulator, decodedVector, i);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    NoisyHelperFunctionFactory::decodeInputData(
+        decodedValue_, decodedNoiseScale_, decodedRandomSeed_, rows, args);
+    bool hasRandomSeed = NoisyHelperFunctionFactory::checkRandomSeed(args);
+
+    auto accumulator = exec::Aggregate::value<AccumulatorType>(group);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+          decodedValue_,
+          decodedNoiseScale_,
+          decodedRandomSeed_,
+          args,
+          *accumulator,
+          i,
+          hasRandomSeed);
+    });
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    // Initialize the accumulator for each group
+    for (auto i : indices) {
+      *value<AccumulatorType>(groups[i]) = AccumulatorType();
+    }
+  }
+
+ private:
+  DecodedVector decodedValue_;
+  DecodedVector decodedNoiseScale_;
+  DecodedVector decodedRandomSeed_;
+};
+} // namespace
+
+void registerNoisyCountGaussianAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("varbinary")
+          .argumentType("T")
+          .argumentType("double") // support DOUBLE noise scale
+          .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("varbinary")
+          .argumentType("T")
+          .argumentType("bigint") // support BIGINT noise scale
+          .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("varbinary")
+          .argumentType("T")
+          .argumentType("double") // support DOUBLE noise scale
+          .argumentType("bigint") // support BIGINT random seed
+          .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("varbinary")
+          .argumentType("T")
+          .argumentType("bigint") // support BIGINT noise scale
+          .argumentType("bigint") // support BIGINT random seed
+          .build(),
+  };
+
+  auto name = prefix + kNoisyCountGaussian;
+
+  exec::registerAggregateFunction(
+      name,
+      signatures,
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          [[maybe_unused]] const TypePtr& resultType,
+          [[maybe_unused]] const core::QueryConfig& config)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_LE(
+            argTypes.size(), 3, "{} takes at most 3 arguments", name);
+        VELOX_CHECK_GE(
+            argTypes.size(), 2, "{} takes at least 2 arguments", name);
+
+        if (exec::isPartialOutput(step)) {
+          return std::make_unique<NoisyCountGaussianAggregate>(VARBINARY());
+        }
+
+        return std::make_unique<NoisyCountGaussianAggregate>(BIGINT());
+      },
+      {.orderSensitive = false},
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.h b/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.h
new file mode 100644
index 000000000000..9bfda08708df
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.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::aggregate::prestosql {
+
+void registerNoisyCountGaussianAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.cpp b/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.cpp
index fbee3090492d..2f12d3f6f502 100644
--- a/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.cpp
@@ -18,9 +18,9 @@
 #include <cmath>
 #include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionSignature.h"
-#include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountAccumulator.h"
+#include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
 #include "velox/functions/prestosql/aggregates/AggregateNames.h"
-#include "velox/vector/DecodedVector.h"
+#include "velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h"
 #include "velox/vector/FlatVector.h"
 
 using namespace facebook::velox::functions::aggregate;
@@ -34,7 +34,7 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
   explicit NoisyCountIfGaussianAggregate(TypePtr resultType)
       : exec::Aggregate(std::move(resultType)) {}
 
-  using AccumulatorType = NoisyCountAccumulator;
+  using AccumulatorType = functions::aggregate::NoisyCountSumAvgAccumulator;
 
   bool isFixedSize() const override {
     return true;
@@ -50,34 +50,16 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
     // So we convert the accumulators (in group) to strings where each is
     // serialized version of the accumulator and store the strings in the result
     // vector
-    auto* flatResult = (*result)->asFlatVector<StringView>();
-    flatResult->resize(numGroups);
+    std::function<bool(char*)> isNull = [this](char* group) {
+      return this->isNull(group);
+    };
 
-    // Determine the total size needed for the buffer
-    int64_t numNonNullGroups = 0;
-    for (auto i = 0; i < numGroups; ++i) {
-      numNonNullGroups += isNull(groups[i]) ? 0 : 1;
-    }
-    size_t totalSize = numNonNullGroups * AccumulatorType::serializedSize();
+    std::function<AccumulatorType(char*)> getAccumulator = [this](char* group) {
+      return *this->value<AccumulatorType>(group);
+    };
 
-    // Allocate the buffer once
-    char* rawBuffer = flatResult->getRawStringBufferWithSpace(totalSize);
-    size_t offset = 0;
-
-    for (auto i = 0; i < numGroups; ++i) {
-      char* group = groups[i];
-      if (isNull(group)) {
-        flatResult->setNull(i, true);
-      } else {
-        auto* accumulator = value<AccumulatorType>(group);
-        auto size = accumulator->serializedSize();
-
-        // Write to the pre-allocated buffer
-        accumulator->serialize(rawBuffer + offset);
-        flatResult->setNoCopy(i, StringView(rawBuffer + offset, size));
-        offset += size;
-      }
-    }
+    NoisyHelperFunctionFactory::extractAccumulators(
+        isNull, getAccumulator, groups, numGroups, result);
   }
 
   void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
@@ -88,15 +70,16 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
 
     // Find noise scale. Because noise scale is the same for all groups, we can
     // find it once and reuse it for all groups
-    double noiseScale = -1;
-    for (auto i = 0; i < numGroups; ++i) {
-      char* group = groups[i];
-      if (!isNull(group)) {
-        auto* accumulator = value<AccumulatorType>(group);
-        noiseScale = accumulator->noiseScale;
-        break;
-      }
-    }
+    std::function<bool(char*)> isNull = [this](char* group) {
+      return this->isNull(group);
+    };
+    std::function<AccumulatorType(char*)> getAccumulator = [this](char* group) {
+      return *this->value<AccumulatorType>(group);
+    };
+
+    auto [noiseScale, randomSeed] =
+        NoisyHelperFunctionFactory::getFinalNoiseScaleAndRandomSeed(
+            isNull, getAccumulator, groups, numGroups);
 
     if (noiseScale < 0) {
       // Because we checked noiseScale >= 0 whenever we update noise scale,
@@ -108,50 +91,40 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
       return;
     }
 
-    // Generate a cryptographically secure random byte string as the seed for
-    // random generator
-    folly::Random::DefaultGenerator rng;
-    rng.seed(folly::Random::secureRand32());
-
-    // This is to deal with the case when noiseScale == 0, which means we do not
-    // need to add noise. We assume noiseScale = 0, thus no need to add noise,
-    // and set dist to standard normal distribution
-    std::normal_distribution<double> dist(0.0, 1.0);
-    bool addNoise = false;
-
-    if (noiseScale > 0) {
-      // We need to add noise
-      dist = std::normal_distribution<double>(0.0, noiseScale);
-      addNoise = true;
-    }
+    // If noise_scale is 0, gen will always return 0.
+    NoisyHelperFunctionFactory::NoiseGenerator gen{noiseScale, randomSeed};
 
-    auto* rawValues = vector->mutableRawValues();
     for (auto i = 0; i < numGroups; ++i) {
       char* group = groups[i];
       if (isNull(group)) {
-        rawValues[i] = 0; // Return 0 for null group to match Java behavior
-      } else {
-        auto* accumulator = value<AccumulatorType>(group);
-
-        int64_t noise = 0;
-        if (addNoise) {
-          noise = static_cast<int64_t>(
-              std::round(dist(rng))); // Need to round back to int64_t because
-                                      // we want to return int64_t
-        }
-
-        // Check and make sure the count is within int64_t range
-        int64_t trueCount = static_cast<int64_t>(accumulator->count);
-        VELOX_DCHECK_LT(trueCount, std::numeric_limits<int64_t>::max());
-        int64_t noisyCount = trueCount + noise;
-
-        // Post-process the noisy count to make sure it is non-negative
-        if (noisyCount < 0) {
-          noisyCount = 0;
-        }
-
-        rawValues[i] = noisyCount;
+        vector->setNull(i, true);
+        continue;
       }
+      auto* accumulator = value<AccumulatorType>(group);
+      double rawNoise = gen.nextNoise();
+
+      VELOX_USER_CHECK_GE(
+          rawNoise,
+          static_cast<double>(std::numeric_limits<int64_t>::min()),
+          "Noise is too large. Please reduce noise scale.");
+      VELOX_USER_CHECK_LE(
+          rawNoise,
+          static_cast<double>(std::numeric_limits<int64_t>::max()),
+          "Noise is too large. Please reduce noise scale.");
+      auto noise = static_cast<int64_t>(
+          std::round(rawNoise)); // Need to round back to int64_t because
+                                 // we want to return int64_t
+
+      uint64_t trueCount = accumulator->getCount();
+      // Check that true count won't overflow converting from unsigned int to
+      // signed int. We need the conversion because noise is signed int.
+      VELOX_CHECK_LT(
+          trueCount,
+          static_cast<uint64_t>(std::numeric_limits<int64_t>::max()));
+      int64_t noisyCount = checkedPlus(static_cast<int64_t>(trueCount), noise);
+
+      // Post-process the noisy count to make sure it is non-negative
+      vector->set(i, std::max<int64_t>(noisyCount, 0L));
     }
   }
 
@@ -160,31 +133,22 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       bool /*unused*/) override {
-    // Add raw input to the accumulator
-    decodedValue_.decode(*args[0], rows);
-    decodedNoiseScale_.decode(*args[1], rows);
+    NoisyHelperFunctionFactory::decodeInputData(
+        decodedValue_, decodedNoiseScale_, decodedRandomSeed_, rows, args);
+    bool hasRandomSeed = NoisyHelperFunctionFactory::checkRandomSeed(args);
 
+    // Process the args data and update the accumulator for each group.
     rows.applyToSelected([&](vector_size_t i) {
-      if (decodedValue_.isNullAt(i) || decodedNoiseScale_.isNullAt(i)) {
-        return;
-      }
-
-      auto* group = groups[i];
-
-      auto* accumulator = value<AccumulatorType>(group);
-      if (decodedValue_.valueAt<bool>(i)) {
-        accumulator->increaseCount(1);
-      }
-
-      double noiseScaleValue = 0.0;
-      auto noiseScaleType = args[1]->typeKind();
-      if (noiseScaleType == TypeKind::DOUBLE) {
-        noiseScaleValue = decodedNoiseScale_.valueAt<double>(i);
-      } else if (noiseScaleType == TypeKind::BIGINT) {
-        noiseScaleValue =
-            static_cast<double>(decodedNoiseScale_.valueAt<uint64_t>(i));
-      }
-      accumulator->checkAndSetNoiseScale(noiseScaleValue);
+      auto accumulator = exec::Aggregate::value<AccumulatorType>(groups[i]);
+      NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+          decodedValue_,
+          decodedNoiseScale_,
+          decodedRandomSeed_,
+          args,
+          *accumulator,
+          i,
+          hasRandomSeed,
+          true /*isCountIf*/);
     });
   }
 
@@ -197,21 +161,9 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
     DecodedVector decoded(*args[0], rows);
 
     rows.applyToSelected([&](vector_size_t i) {
-      if (decoded.isNullAt(i)) {
-        return;
-      }
-
-      auto* group = groups[i];
-      auto* accumulator = value<AccumulatorType>(group);
-
-      auto serialized = decoded.valueAt<StringView>(i);
-      auto otherAccumulator = AccumulatorType::deserialize(serialized.data());
-
-      if (accumulator->noiseScale != otherAccumulator.noiseScale &&
-          otherAccumulator.noiseScale >= 0) {
-        accumulator->checkAndSetNoiseScale(otherAccumulator.noiseScale);
-      }
-      accumulator->increaseCount(otherAccumulator.count);
+      auto* accumulator = exec::Aggregate::value<AccumulatorType>(groups[i]);
+      NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+          *accumulator, decoded, i);
     });
   }
 
@@ -220,29 +172,21 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
       const SelectivityVector& rows,
       const std::vector<VectorPtr>& args,
       bool /*mayPushdown*/) override {
-    // Add raw input to the accumulator for Global Aggregation
-    decodedValue_.decode(*args[0], rows);
-    decodedNoiseScale_.decode(*args[1], rows);
-
-    auto* accumulator = value<AccumulatorType>(group);
+    NoisyHelperFunctionFactory::decodeInputData(
+        decodedValue_, decodedNoiseScale_, decodedRandomSeed_, rows, args);
+    bool hasRandomSeed = NoisyHelperFunctionFactory::checkRandomSeed(args);
+    auto accumulator = exec::Aggregate::value<AccumulatorType>(group);
 
     rows.applyToSelected([&](vector_size_t i) {
-      if (decodedValue_.isNullAt(i) || decodedNoiseScale_.isNullAt(i)) {
-        return;
-      }
-      if (decodedValue_.valueAt<bool>(i)) {
-        accumulator->increaseCount(1);
-      }
-      double noiseScaleValue = 0.0;
-      auto noiseScaleType = args[1]->typeKind();
-      if (noiseScaleType == TypeKind::DOUBLE) {
-        noiseScaleValue = decodedNoiseScale_.valueAt<double>(i);
-      } else if (noiseScaleType == TypeKind::BIGINT) {
-        noiseScaleValue =
-            static_cast<double>(decodedNoiseScale_.valueAt<uint64_t>(i));
-      }
-
-      accumulator->checkAndSetNoiseScale(noiseScaleValue);
+      NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+          decodedValue_,
+          decodedNoiseScale_,
+          decodedRandomSeed_,
+          args,
+          *accumulator,
+          i,
+          hasRandomSeed,
+          true /*isCountIf*/);
     });
   }
 
@@ -257,14 +201,8 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
     auto* accumulator = value<AccumulatorType>(group);
 
     rows.applyToSelected([&](vector_size_t i) {
-      auto serialized = decoded.valueAt<StringView>(i);
-      auto otherAccumulator = AccumulatorType::deserialize(serialized.data());
-
-      if (accumulator->noiseScale != otherAccumulator.noiseScale &&
-          otherAccumulator.noiseScale >= 0) {
-        accumulator->checkAndSetNoiseScale(otherAccumulator.noiseScale);
-      }
-      accumulator->increaseCount(otherAccumulator.count);
+      NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+          *accumulator, decoded, i);
     });
   }
 
@@ -281,6 +219,7 @@ class NoisyCountIfGaussianAggregate : public exec::Aggregate {
  private:
   DecodedVector decodedValue_;
   DecodedVector decodedNoiseScale_;
+  DecodedVector decodedRandomSeed_;
 };
 
 } // namespace
@@ -302,6 +241,20 @@ void registerNoisyCountIfGaussianAggregate(
           .argumentType("boolean")
           .argumentType("bigint") // support BIGINT noise scale
           .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("bigint")
+          .intermediateType("varbinary")
+          .argumentType("boolean")
+          .argumentType("double")
+          .argumentType("bigint") // support random seed
+          .build(),
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("bigint")
+          .intermediateType("varbinary")
+          .argumentType("boolean")
+          .argumentType("bigint")
+          .argumentType("bigint") // support random seed
+          .build(),
   };
 
   auto name = prefix + kNoisyCountIfGaussian;
@@ -314,7 +267,8 @@ void registerNoisyCountIfGaussianAggregate(
           const TypePtr& /*resultType*/,
           const core::QueryConfig& /*config*/)
           -> std::unique_ptr<exec::Aggregate> {
-        VELOX_CHECK_EQ(argTypes.size(), 2, "{} takes 2 arguments", name);
+        VELOX_CHECK_LE(argTypes.size(), 3, "{} takes 2 or 3 arguments", name);
+        VELOX_CHECK_GE(argTypes.size(), 2, "{} takes 2 or 3 arguments", name);
 
         if (exec::isPartialOutput(step)) {
           VELOX_CHECK_EQ(
@@ -331,7 +285,7 @@ void registerNoisyCountIfGaussianAggregate(
 
         return std::make_unique<NoisyCountIfGaussianAggregate>(BIGINT());
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.cpp b/velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.cpp
new file mode 100644
index 000000000000..f0779928b459
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.cpp
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/NoisyHelperFunctionFactory.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+void NoisyHelperFunctionFactory::decodeInputData(
+    DecodedVector& decodedValue_,
+    DecodedVector& decodedNoiseScale_,
+    DecodedVector& decodedLowerBound_,
+    DecodedVector& decodedUpperBound_,
+    DecodedVector& decodedRandomSeed_,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args) {
+  decodedValue_.decode(*args[0], rows);
+  decodedNoiseScale_.decode(*args[1], rows);
+
+  // Decode lower and upper bounds if provided.
+  if (args.size() > 3) {
+    decodedLowerBound_.decode(*args[2], rows);
+    decodedUpperBound_.decode(*args[3], rows);
+  }
+
+  // Decode random seed if provided.
+  if (args.size() == 3) {
+    decodedRandomSeed_.decode(*args[2], rows);
+  }
+
+  if (args.size() == 5) {
+    decodedRandomSeed_.decode(*args[4], rows);
+  }
+}
+
+// Overloaded version for functions that don't use bounds (like noisy_count)
+void NoisyHelperFunctionFactory::decodeInputData(
+    DecodedVector& decodedValue_,
+    DecodedVector& decodedNoiseScale_,
+    DecodedVector& decodedRandomSeed_,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args) {
+  decodedValue_.decode(*args[0], rows);
+  decodedNoiseScale_.decode(*args[1], rows);
+
+  // Decode random seed if provided.
+  if (args.size() == 3) {
+    decodedRandomSeed_.decode(*args[2], rows);
+  }
+}
+
+void NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+    DecodedVector& decodedValue_,
+    DecodedVector& decodedNoiseScale_,
+    DecodedVector& decodedLowerBound_,
+    DecodedVector& decodedUpperBound_,
+    DecodedVector& decodedRandomSeed_,
+    const std::vector<VectorPtr>& args,
+    AccumulatorType& accumulator,
+    vector_size_t i,
+    bool hasBounds,
+    bool hasRandomSeed) {
+  if (decodedValue_.isNullAt(i)) {
+    return;
+  }
+
+  // Update the noise scale.
+  NoisyHelperFunctionFactory::updateNoiseScale(
+      decodedNoiseScale_, args, accumulator, i);
+
+  // Update the lower and upper bounds if provided.
+  if (hasBounds) {
+    NoisyHelperFunctionFactory::updateBounds(
+        decodedLowerBound_, decodedUpperBound_, args, accumulator, i);
+  }
+
+  // Update random seed if provided.
+  if (hasRandomSeed) {
+    NoisyHelperFunctionFactory::updateRandomSeed(
+        decodedRandomSeed_, accumulator, i);
+  }
+
+  // Update sum and count. check input value and dispatch to corresponding
+  // type.
+  auto inputType = args[0]->typeKind();
+  VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      updateTemplate, inputType, accumulator, decodedValue_, i);
+}
+
+void NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+    DecodedVector& decodedValue_,
+    DecodedVector& decodedNoiseScale_,
+    DecodedVector& decodedRandomSeed_,
+    const std::vector<VectorPtr>& args,
+    AccumulatorType& accumulator,
+    vector_size_t i,
+    bool hasRandomSeed,
+    bool isCountIf) {
+  if (decodedValue_.isNullAt(i)) {
+    return;
+  }
+
+  // Update the noise scale.
+  NoisyHelperFunctionFactory::updateNoiseScale(
+      decodedNoiseScale_, args, accumulator, i);
+
+  // Update random seed if provided.
+  if (hasRandomSeed) {
+    NoisyHelperFunctionFactory::updateRandomSeed(
+        decodedRandomSeed_, accumulator, i);
+  }
+
+  if (isCountIf) {
+    if (decodedValue_.valueAt<bool>(i)) {
+      accumulator.updateCount(1);
+    }
+  } else {
+    accumulator.updateCount(1);
+  }
+}
+
+void NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+    AccumulatorType& accumulator,
+    DecodedVector& decodedVector,
+    vector_size_t i) {
+  if (decodedVector.isNullAt(i)) {
+    return;
+  }
+
+  auto serialized = decodedVector.valueAt<StringView>(i);
+  auto otherAccumulator = AccumulatorType::deserialize(serialized.data());
+  accumulator.updateSum(otherAccumulator.getSum());
+  accumulator.updateCount(otherAccumulator.getCount());
+  if (otherAccumulator.getNoiseScale() >= 0) {
+    accumulator.checkAndSetNoiseScale(otherAccumulator.getNoiseScale());
+  }
+  if (otherAccumulator.getLowerBound().has_value() &&
+      otherAccumulator.getUpperBound().has_value()) {
+    accumulator.checkAndSetBounds(
+        *otherAccumulator.getLowerBound(), *otherAccumulator.getUpperBound());
+  }
+  if (otherAccumulator.getRandomSeed().has_value()) {
+    accumulator.setRandomSeed(*otherAccumulator.getRandomSeed());
+  }
+}
+
+double NoisyHelperFunctionFactory::postProcessNoisyValue(
+    double noisyValue,
+    const AccumulatorType& accumulator) {
+  if (accumulator.getLowerBound().has_value() &&
+      accumulator.getUpperBound().has_value()) {
+    if (accumulator.getLowerBound().value() >= 0) {
+      noisyValue = std::max(noisyValue, 0.0);
+    } else if (accumulator.getUpperBound().value() <= 0) {
+      noisyValue = std::min(noisyValue, 0.0);
+    }
+  }
+  return noisyValue;
+}
+
+void NoisyHelperFunctionFactory::extractAccumulators(
+    const std::function<bool(char*)>& isNull,
+    const std::function<AccumulatorType(char*)>& getAccumulator,
+    char** groups,
+    int32_t numGroups,
+    VectorPtr* result) {
+  auto flatResult = (*result)->asFlatVector<StringView>();
+  VELOX_CHECK(flatResult);
+  flatResult->resize(numGroups);
+
+  int32_t numOfValidGroups = 0;
+  for (auto i = 0; i < numGroups; i++) {
+    numOfValidGroups += !isNull(groups[i]);
+  }
+  size_t totalSize = numOfValidGroups * AccumulatorType::serializedSize();
+
+  // Allocate buffer for serialized data.
+  auto rawBuffer = flatResult->getRawStringBufferWithSpace(totalSize);
+  size_t offset = 0;
+  auto size = AccumulatorType::serializedSize();
+
+  for (auto i = 0; i < numGroups; i++) {
+    auto group = groups[i];
+    if (isNull(group)) {
+      flatResult->setNull(i, true);
+    } else {
+      auto accumulator = getAccumulator(group);
+
+      // Write to the pre-allocated buffer.
+      accumulator.serialize(rawBuffer + offset);
+      flatResult->setNoCopy(
+          i, StringView(rawBuffer + offset, static_cast<int32_t>(size)));
+      offset += size;
+    }
+  }
+}
+
+const std::pair<double, std::optional<int64_t>>
+NoisyHelperFunctionFactory::getFinalNoiseScaleAndRandomSeed(
+    const std::function<bool(char*)>& isNull,
+    const std::function<AccumulatorType(char*)>& getAccumulator,
+    char** groups,
+    int32_t numGroups) {
+  double noiseScale = -1;
+  std::optional<int64_t> randomSeed = std::nullopt;
+  for (auto i = 0; i < numGroups; ++i) {
+    char* group = groups[i];
+    if (!isNull(group)) {
+      auto accumulator = getAccumulator(group);
+      noiseScale = accumulator.getNoiseScale();
+      randomSeed = accumulator.getRandomSeed();
+      // Only exit when a valid noise_scale is found.
+      if (noiseScale >= 0) {
+        break;
+      }
+    }
+  }
+  return std::make_pair(noiseScale, randomSeed);
+}
+
+void NoisyHelperFunctionFactory::updateNoiseScale(
+    DecodedVector& decodedNoiseScale_,
+    const std::vector<VectorPtr>& args,
+    AccumulatorType& accumulator,
+    vector_size_t i) {
+  double noiseScale = 0;
+  auto noiseScaleType = args[1]->typeKind();
+  if (noiseScaleType == TypeKind::DOUBLE) {
+    noiseScale = decodedNoiseScale_.valueAt<double>(i);
+  } else if (noiseScaleType == TypeKind::BIGINT) {
+    noiseScale = static_cast<double>(decodedNoiseScale_.valueAt<uint64_t>(i));
+  }
+  accumulator.checkAndSetNoiseScale(noiseScale);
+}
+
+void NoisyHelperFunctionFactory::updateBounds(
+    DecodedVector& decodedLowerBound_,
+    DecodedVector& decodedUpperBound_,
+    const std::vector<VectorPtr>& args,
+    AccumulatorType& accumulator,
+    vector_size_t i) {
+  double lowerBound = 0;
+  double upperBound = 0;
+  auto lowerBoundType = args[2]->typeKind();
+  auto upperBoundType = args[3]->typeKind();
+  if (lowerBoundType == TypeKind::DOUBLE) {
+    lowerBound = decodedLowerBound_.valueAt<double>(i);
+  } else if (lowerBoundType == TypeKind::BIGINT) {
+    lowerBound = static_cast<double>(decodedLowerBound_.valueAt<int64_t>(i));
+  }
+
+  if (upperBoundType == TypeKind::DOUBLE) {
+    upperBound = decodedUpperBound_.valueAt<double>(i);
+  } else if (upperBoundType == TypeKind::BIGINT) {
+    upperBound = static_cast<double>(decodedUpperBound_.valueAt<int64_t>(i));
+  }
+  accumulator.checkAndSetBounds(lowerBound, upperBound);
+}
+
+void NoisyHelperFunctionFactory::updateRandomSeed(
+    DecodedVector& decodedRandomSeed_,
+    AccumulatorType& accumulator,
+    vector_size_t i) {
+  accumulator.setRandomSeed(decodedRandomSeed_.valueAt<int64_t>(i));
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h b/velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h
new file mode 100644
index 000000000000..4d7159dd4a6b
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+class NoisyHelperFunctionFactory {
+  using AccumulatorType = functions::aggregate::NoisyCountSumAvgAccumulator;
+
+ public:
+  class NoiseGenerator {
+   public:
+    NoiseGenerator(double noiseScale, std::optional<int64_t> randomSeed)
+        : noiseScale_(noiseScale), randomSeed_(randomSeed) {
+      if (randomSeed_.has_value()) {
+        rng_.seed(randomSeed_.value());
+      } else {
+        rng_.seed(folly::Random::secureRand64());
+      }
+      // Only create normal distribution if noiseScale > 0
+      // When noiseScale is 0, we want no noise (deterministic behavior)
+      if (noiseScale_ > 0) {
+        dist_ = std::normal_distribution<double>(0, noiseScale_);
+      }
+    }
+
+    double nextNoise() {
+      // If noise scale is 0, return 0 (no noise)
+      if (noiseScale_ <= 0) {
+        return 0.0;
+      }
+      return dist_(rng_);
+    }
+
+   private:
+    double noiseScale_;
+    std::optional<int64_t> randomSeed_;
+    folly::Random::DefaultGenerator rng_;
+    std::normal_distribution<double> dist_;
+  };
+
+  static void decodeInputData(
+      DecodedVector& decodedValue_,
+      DecodedVector& decodedNoiseScale_,
+      DecodedVector& decodedLowerBound_,
+      DecodedVector& decodedUpperBound_,
+      DecodedVector& decodedRandomSeed_,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args);
+
+  // Overloaded version for functions that don't use bounds (noisy_count and
+  // noisy_count_if)
+  static void decodeInputData(
+      DecodedVector& decodedValue_,
+      DecodedVector& decodedNoiseScale_,
+      DecodedVector& decodedRandomSeed_,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args);
+
+  static void updateAccumulatorFromInput(
+      DecodedVector& decodedValue_,
+      DecodedVector& decodedNoiseScale_,
+      DecodedVector& decodedLowerBound_,
+      DecodedVector& decodedUpperBound_,
+      DecodedVector& decodedRandomSeed_,
+      const std::vector<VectorPtr>& args,
+      AccumulatorType& accumulator,
+      vector_size_t i,
+      bool hasBounds,
+      bool hasRandomSeed);
+
+  // Overloaded version for functions that don't use bounds (noisy_count and
+  // noisy_count_if)
+  static void updateAccumulatorFromInput(
+      DecodedVector& decodedValue_,
+      DecodedVector& decodedNoiseScale_,
+      DecodedVector& decodedRandomSeed_,
+      const std::vector<VectorPtr>& args,
+      AccumulatorType& accumulator,
+      vector_size_t i,
+      bool hasRandomSeed,
+      bool isCountIf = false);
+
+  static void updateAccumulatorFromIntermediateResult(
+      AccumulatorType& accumulator,
+      DecodedVector& decodedVector,
+      vector_size_t i);
+
+  static double postProcessNoisyValue(
+      double noisyValue,
+      const AccumulatorType& accumulator);
+
+  static void extractAccumulators(
+      const std::function<bool(char*)>& isNull,
+      const std::function<AccumulatorType(char*)>& getAccumulator,
+      char** groups,
+      int32_t numGroups,
+      VectorPtr* result);
+
+  template <TypeKind TData>
+  static void updateTemplate(
+      AccumulatorType& accumulator,
+      const DecodedVector& decodedValue,
+      vector_size_t i) {
+    using T = typename TypeTraits<TData>::NativeType;
+    // Handle decimal types separately.
+    if constexpr (std::is_same_v<T, int64_t> || std::is_same_v<T, int128_t>) {
+      const auto& type = decodedValue.base()->type();
+      if (type->isDecimal()) {
+        auto value = decodedValue.valueAt<T>(i);
+        auto scale = type->isShortDecimal() ? type->asShortDecimal().scale()
+                                            : type->asLongDecimal().scale();
+        double doubleValue = static_cast<double>(value) / pow(10, scale);
+
+        accumulator.clipUpdateSum(doubleValue);
+        accumulator.updateCount(1);
+        return;
+      }
+    }
+    // Handle other types.
+    if constexpr (
+        std::is_same_v<T, TypeTraits<TypeKind::TIMESTAMP>> ||
+        std::is_same_v<T, TypeTraits<TypeKind::VARBINARY>> ||
+        std::is_same_v<T, TypeTraits<TypeKind::VARCHAR>> ||
+        std::is_same_v<T, facebook::velox::StringView> ||
+        std::is_same_v<T, facebook::velox::Timestamp>) {
+      VELOX_FAIL("Noisy function does not support this data type.");
+    } else {
+      // Handle not a number.
+      if (std::isnan(decodedValue.valueAt<T>(i))) {
+        return;
+      }
+      accumulator.clipUpdateSum(
+          static_cast<double>(decodedValue.valueAt<T>(i)));
+      accumulator.updateCount(1);
+    }
+  }
+
+  static bool checkBounds(const std::vector<VectorPtr>& args) {
+    // If size of args is GREATER THAN 3, it means lower and upper bounds are
+    // provided.
+    return args.size() > 3;
+  }
+
+  static bool checkRandomSeed(const std::vector<VectorPtr>& args) {
+    // If size of args is 3 or 5, it means random seed is provided.
+    return args.size() == 3 || args.size() == 5;
+  }
+
+  static const std::pair<double, std::optional<int64_t>>
+  getFinalNoiseScaleAndRandomSeed(
+      const std::function<bool(char*)>& isNull,
+      const std::function<AccumulatorType(char*)>& getAccumulator,
+      char** groups,
+      int32_t numGroups);
+
+ private:
+  // Private helper functions
+  static void updateNoiseScale(
+      DecodedVector& decodedNoiseScale_,
+      const std::vector<VectorPtr>& args,
+      AccumulatorType& accumulator,
+      vector_size_t i);
+
+  static void updateBounds(
+      DecodedVector& decodedLowerBound_,
+      DecodedVector& decodedUpperBound_,
+      const std::vector<VectorPtr>& args,
+      AccumulatorType& accumulator,
+      vector_size_t i);
+
+  static void updateRandomSeed(
+      DecodedVector& decodedRandomSeed_,
+      AccumulatorType& accumulator,
+      vector_size_t i);
+};
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.cpp b/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.cpp
new file mode 100644
index 000000000000..106d8071b80a
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.cpp
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/expression/FunctionSignature.h"
+#include "velox/functions/lib/aggregates/noisy_aggregation/NoisyCountSumAvgAccumulator.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/functions/prestosql/aggregates/NoisyHelperFunctionFactory.h"
+#include "velox/vector/FlatVector.h"
+
+using namespace facebook::velox::functions::aggregate;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+class NoisySumGaussianAggregate : public exec::Aggregate {
+ public:
+  explicit NoisySumGaussianAggregate(TypePtr resultType)
+      : exec::Aggregate(resultType) {}
+
+  using AccumulatorType = functions::aggregate::NoisyCountSumAvgAccumulator;
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return static_cast<int32_t>(sizeof(AccumulatorType));
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    NoisyHelperFunctionFactory::decodeInputData(
+        decodedValue_,
+        decodedNoiseScale_,
+        decodedLowerBound_,
+        decodedUpperBound_,
+        decodedRandomSeed_,
+        rows,
+        args);
+    bool hasRandomSeed = NoisyHelperFunctionFactory::checkRandomSeed(args);
+    bool hasBounds = NoisyHelperFunctionFactory::checkBounds(args);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      auto* accumulator = exec::Aggregate::value<AccumulatorType>(groups[i]);
+      NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+          decodedValue_,
+          decodedNoiseScale_,
+          decodedLowerBound_,
+          decodedUpperBound_,
+          decodedRandomSeed_,
+          args,
+          *accumulator,
+          i,
+          hasBounds,
+          hasRandomSeed);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    NoisyHelperFunctionFactory::decodeInputData(
+        decodedValue_,
+        decodedNoiseScale_,
+        decodedLowerBound_,
+        decodedUpperBound_,
+        decodedRandomSeed_,
+        rows,
+        args);
+    bool hasRandomSeed = NoisyHelperFunctionFactory::checkRandomSeed(args);
+    bool hasBounds = NoisyHelperFunctionFactory::checkBounds(args);
+    auto* accumulator = exec::Aggregate::value<AccumulatorType>(group);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      NoisyHelperFunctionFactory::updateAccumulatorFromInput(
+          decodedValue_,
+          decodedNoiseScale_,
+          decodedLowerBound_,
+          decodedUpperBound_,
+          decodedRandomSeed_,
+          args,
+          *accumulator,
+          i,
+          hasBounds,
+          hasRandomSeed);
+    });
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    std::function<bool(char*)> isNull = [this](char* group) {
+      return this->isNull(group);
+    };
+
+    std::function<AccumulatorType(char*)> getAccumulator = [this](char* group) {
+      return *this->value<AccumulatorType>(group);
+    };
+
+    NoisyHelperFunctionFactory::extractAccumulators(
+        isNull, getAccumulator, groups, numGroups, result);
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto* vector = (*result)->as<FlatVector<double>>();
+    VELOX_CHECK(vector);
+    vector->resize(numGroups);
+
+    std::function<bool(char*)> isNull = [this](char* group) {
+      return this->isNull(group);
+    };
+    std::function<AccumulatorType(char*)> getAccumulator = [this](char* group) {
+      return *this->value<AccumulatorType>(group);
+    };
+
+    auto [noiseScale, randomSeed] =
+        NoisyHelperFunctionFactory::getFinalNoiseScaleAndRandomSeed(
+            isNull, getAccumulator, groups, numGroups);
+
+    if (noiseScale < 0) {
+      for (auto i = 0; i < numGroups; ++i) {
+        vector->setNull(i, true);
+      }
+      return;
+    }
+
+    NoisyHelperFunctionFactory::NoiseGenerator gen{noiseScale, randomSeed};
+
+    for (auto i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      auto accumulator = value<AccumulatorType>(group);
+      if (isNull(group)) {
+        vector->setNull(i, true);
+        continue;
+      }
+      // For groups that have allNull Values
+      if (accumulator->getNoiseScale() < 0) {
+        vector->setNull(i, true);
+        continue;
+      }
+      double noise = gen.nextNoise();
+
+      // Check the sign of noisy sum is consistent with the bounds.
+      double nosiySum = accumulator->getSum() + noise;
+      auto finalResult = NoisyHelperFunctionFactory::postProcessNoisyValue(
+          nosiySum, *accumulator);
+      vector->set(i, finalResult);
+    }
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    DecodedVector decoded(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      auto* accumulator = exec::Aggregate::value<AccumulatorType>(groups[i]);
+      NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+          *accumulator, decoded, i);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    DecodedVector decoded(*args[0], rows);
+
+    auto* accumulator = exec::Aggregate::value<AccumulatorType>(group);
+    rows.applyToSelected([&](vector_size_t i) {
+      NoisyHelperFunctionFactory::updateAccumulatorFromIntermediateResult(
+          *accumulator, decoded, i);
+    });
+  }
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    // Initialize the accumulator for each group
+    for (auto i : indices) {
+      *value<AccumulatorType>(groups[i]) = AccumulatorType();
+    }
+  }
+
+ private:
+  DecodedVector decodedValue_;
+  DecodedVector decodedNoiseScale_;
+  DecodedVector decodedLowerBound_;
+  DecodedVector decodedUpperBound_;
+  DecodedVector decodedRandomSeed_;
+};
+} // namespace
+
+void registerNoisySumGaussianAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  // Helper function to create a signature builder with return and
+  // intermediate types
+  auto createBuilder = []() {
+    return exec::AggregateFunctionSignatureBuilder()
+        .returnType("double") // noisy_sum_guassian always returns double
+        .intermediateType("varbinary");
+  };
+
+  // List of possible argument types.
+  const std::vector<std::string> simpleDataTypes = {
+      "tinyint", "smallint", "integer", "bigint", "real", "double"};
+  const std::vector<std::string> noiseScaleTypes = {"double", "bigint"};
+  const std::string randomSeedType = "bigint";
+  const std::vector<std::string> boundTypes = {"double", "bigint"};
+
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  // Generate signatures for all type combinations.
+  for (const auto& noiseScaleType : noiseScaleTypes) {
+    // Handle simple types.
+    for (const auto& dataType : simpleDataTypes) {
+      // Signature 1: (col, noise_scale)
+      signatures.push_back(
+          createBuilder()
+              .argumentType(dataType)
+              .argumentType(noiseScaleType)
+              .build());
+      // Signature 2: (col, noise_scale, random_seed)
+      signatures.push_back(
+          createBuilder()
+              .argumentType(dataType)
+              .argumentType(noiseScaleType)
+              .argumentType(randomSeedType)
+              .build());
+
+      for (const auto& lowerBoundType : boundTypes) {
+        for (const auto& upperBoundType : boundTypes) {
+          // Signature 3: (col, noise_scale, lower_bound, upper_bound)
+          signatures.push_back(
+              createBuilder()
+                  .argumentType(dataType)
+                  .argumentType(noiseScaleType)
+                  .argumentType(lowerBoundType)
+                  .argumentType(upperBoundType)
+                  .build());
+          // Signature 4: (col, noise_scale, lower_bound, upper_bound,
+          // random_seed)
+          signatures.push_back(
+              createBuilder()
+                  .argumentType(dataType)
+                  .argumentType(noiseScaleType)
+                  .argumentType(lowerBoundType)
+                  .argumentType(upperBoundType)
+                  .argumentType(randomSeedType)
+                  .build());
+        }
+      }
+    }
+    // Handle decimal types separately.
+    // Signature 1: (col, noise_scale)
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("double")
+            .intermediateType("varbinary")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType(noiseScaleType)
+            .build());
+    // Signature 2: (col, noise_scale, random_seed)
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .returnType("double")
+            .intermediateType("varbinary")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .argumentType(noiseScaleType)
+            .argumentType(randomSeedType)
+            .build());
+
+    for (const auto& lowerBoundType : boundTypes) {
+      for (const auto& upperBoundType : boundTypes) {
+        // Signature 3: (col, noise_scale, lower_bound, upper_bound)
+        signatures.push_back(
+            exec::AggregateFunctionSignatureBuilder()
+                .integerVariable("a_precision")
+                .integerVariable("a_scale")
+                .returnType("double")
+                .intermediateType("varbinary")
+                .argumentType("DECIMAL(a_precision, a_scale)")
+                .argumentType(noiseScaleType)
+                .argumentType(lowerBoundType)
+                .argumentType(upperBoundType)
+                .build());
+        // Signature 4: (col, noise_scale, lower_bound, upper_bound,
+        // random_seed)
+        signatures.push_back(
+            exec::AggregateFunctionSignatureBuilder()
+                .integerVariable("a_precision")
+                .integerVariable("a_scale")
+                .returnType("double")
+                .intermediateType("varbinary")
+                .argumentType("DECIMAL(a_precision, a_scale)")
+                .argumentType(noiseScaleType)
+                .argumentType(lowerBoundType)
+                .argumentType(upperBoundType)
+                .argumentType(randomSeedType)
+                .build());
+      }
+    }
+  }
+
+  auto name = prefix + kNoisySumGaussian;
+  exec::registerAggregateFunction(
+      name,
+      signatures,
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          [[maybe_unused]] const TypePtr& resultType,
+          [[maybe_unused]] const core::QueryConfig&)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_CHECK_GE(
+            argTypes.size(), 2, "{} takes at least 2 arguments", name);
+        VELOX_CHECK_LE(
+            argTypes.size(), 5, "{} takes at most 5 arguments", name);
+
+        if (exec::isPartialOutput(step)) {
+          return std::make_unique<NoisySumGaussianAggregate>(VARBINARY());
+        }
+        return std::make_unique<NoisySumGaussianAggregate>(DOUBLE());
+      },
+      {.orderSensitive = false},
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.h b/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.h
new file mode 100644
index 000000000000..c078beba66b2
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.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::aggregate::prestosql {
+
+void registerNoisySumGaussianAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NumericHistogramAggregate.cpp b/velox/functions/prestosql/aggregates/NumericHistogramAggregate.cpp
new file mode 100644
index 000000000000..f3da85ee366a
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NumericHistogramAggregate.cpp
@@ -0,0 +1,594 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/IOUtils.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+
+#include <algorithm>
+#include <limits>
+#include <queue>
+
+#include <vector>
+#include "velox/exec/SimpleAggregateAdapter.h"
+
+using namespace facebook::velox::exec;
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+// todo(wangke): move it to functions/lib
+class NumericHistogram {
+ private:
+  class Entry {
+   public:
+    int id_;
+    double value_;
+    double weight_;
+    double penalty_;
+    Entry* right_;
+    Entry* left_;
+    mutable bool valid_;
+
+    Entry(
+        int id,
+        double value,
+        double weight,
+        Entry* right = nullptr,
+        Entry* left = nullptr)
+        : id_(id),
+          value_(value),
+          weight_(weight),
+          right_(right),
+          left_(left),
+          valid_(true) {
+      if (right != nullptr) {
+        penalty_ = computePenalty(value, weight, right->value_, right->weight_);
+      } else {
+        penalty_ = std::numeric_limits<double>::quiet_NaN();
+      }
+      if (left != nullptr) {
+        left->right_ = this;
+      }
+      if (right != nullptr) {
+        right->left_ = this;
+      }
+    }
+
+    struct Compare {
+      bool operator()(const Entry* current, const Entry* other) const {
+        const auto penaltyComparison =
+            doubleCompare(current->penalty_, other->penalty_);
+        if (penaltyComparison == 0) {
+          return current->id_ > other->id_;
+        }
+        return penaltyComparison == 1;
+      }
+    };
+
+    void invalidate() {
+      valid_ = false;
+    }
+  };
+
+  double static computePenalty(
+      double value1,
+      double weight1,
+      double value2,
+      double weight2) {
+    double weight = weight1 + weight2;
+    double squaredDifference = (value1 - value2) * (value1 - value2);
+    double proportionsProduct =
+        (weight1 * weight2) / ((weight1 + weight2) * (weight1 + weight2));
+    return weight * squaredDifference * proportionsProduct;
+  }
+
+  int maxBuckets_;
+  int nextIndex_;
+  std::vector<double, StlAllocator<double>> values_;
+  std::vector<double, StlAllocator<double>> weights_;
+  static const int ENTRY_BUFFER_SIZE = 100;
+
+ public:
+  NumericHistogram(int maxBuckets, HashStringAllocator* allocator)
+      : maxBuckets_(maxBuckets),
+        nextIndex_(0),
+        values_{StlAllocator<double>(allocator)},
+        weights_{StlAllocator<double>(allocator)} {
+    VELOX_USER_CHECK_GE(
+        maxBuckets,
+        2,
+        "numeric_histogram bucket count must be greater than one");
+    values_.reserve(maxBuckets_ + ENTRY_BUFFER_SIZE);
+    weights_.reserve(maxBuckets_ + ENTRY_BUFFER_SIZE);
+  }
+
+  NumericHistogram(common::InputByteStream& in, HashStringAllocator* allocator)
+      : values_{StlAllocator<double>(allocator)},
+        weights_{StlAllocator<double>(allocator)} {
+    maxBuckets_ = in.read<int>();
+    VELOX_USER_CHECK_GE(
+        maxBuckets_,
+        2,
+        "numeric_histogram bucket count must be greater than one");
+    values_.reserve(maxBuckets_ + ENTRY_BUFFER_SIZE);
+    weights_.reserve(maxBuckets_ + ENTRY_BUFFER_SIZE);
+    nextIndex_ = in.read<int>();
+    for (int i = 0; i < nextIndex_; ++i) {
+      values_.push_back(in.read<double>());
+      weights_.push_back(in.read<double>());
+    }
+  }
+
+  size_t serializedSize() const {
+    size_t size = sizeof(maxBuckets_) + sizeof(nextIndex_) +
+        nextIndex_ * sizeof(double) // size of values_
+        + nextIndex_ * sizeof(double); // size of weights_
+    return size;
+  }
+
+  void serialize(velox::common::OutputByteStream& out) {
+    out.appendOne(maxBuckets_);
+    out.appendOne(nextIndex_);
+    VELOX_CHECK_GE(values_.size(), nextIndex_);
+    for (int i = 0; i < nextIndex_; ++i) {
+      out.appendOne(values_[i]);
+      out.appendOne(weights_[i]);
+    }
+  }
+
+  // Add a value to the histogram
+  void add(double value, double weight = 1.0) {
+    if (nextIndex_ >= maxBuckets_ + ENTRY_BUFFER_SIZE) {
+      compact();
+    }
+    if (nextIndex_ < values_.size()) {
+      values_[nextIndex_] = value;
+      weights_[nextIndex_] = weight;
+    } else {
+      values_.push_back(value);
+      weights_.push_back(weight);
+    }
+    // After compact, nextIndex_ should be equal to maxbuckets
+
+    ++nextIndex_;
+  }
+
+  void mergeWith(NumericHistogram& other) {
+    VELOX_CHECK_GE(other.values_.size(), other.nextIndex_);
+    VELOX_CHECK_GE(other.weights_.size(), other.nextIndex_);
+    for (auto i = 0; i < other.nextIndex_; ++i) {
+      add(other.values_[i], other.weights_[i]);
+    }
+    compact();
+  }
+
+  // Compact does the following:
+  // 1. Merge the same buckets, which may or may not reduce nextIndex_ (if there
+  // are no elements with the same value)
+  // 2. If step1 did not reduce it enough, mergeAndReduceBuckets will
+  // merge and reduce it until nextIndex_ is smaller than maxBuckets
+  void compact() {
+    mergeSameBuckets();
+    mergeAndReduceBuckets();
+  }
+
+  // Initialize a priority queue with Entries for each value and weight
+  std::priority_queue<Entry*, std::vector<Entry*>, Entry::Compare> initQueue(
+      std::vector<Entry*>& allocatedEntries) {
+    VELOX_CHECK_GE(values_.size(), nextIndex_);
+    VELOX_CHECK_GE(weights_.size(), nextIndex_);
+
+    std::priority_queue<Entry*, std::vector<Entry*>, Entry::Compare> queue;
+    Entry* right = new Entry(
+        nextIndex_ - 1, values_[nextIndex_ - 1], weights_[nextIndex_ - 1]);
+    allocatedEntries.push_back(right);
+    queue.push(right);
+    for (int i = nextIndex_ - 2; i >= 0; i--) {
+      Entry* current = new Entry(i, values_[i], weights_[i], right);
+      queue.push(current);
+      allocatedEntries.push_back(current);
+      right = current;
+    }
+
+    return queue;
+  }
+
+  // Merge and reduce buckets to max number of buckets
+  void mergeAndReduceBuckets() {
+    if (nextIndex_ <= maxBuckets_) {
+      return;
+    }
+
+    std::vector<Entry*> allocatedEntries;
+    auto queue = initQueue(allocatedEntries);
+
+    // Merge and reduce entries in queue until the count is equal to targetCount
+    while (nextIndex_ > maxBuckets_) {
+      Entry* current = queue.top();
+      queue.pop();
+      if (!current->valid_) {
+        // already replaced, move on
+        continue;
+      }
+      nextIndex_--;
+      current->invalidate();
+
+      // Right is guaranteed to exist because we set the penalty of the last
+      // bucket to infinity so the first current in the queue can never be the
+      // last bucket
+      Entry* right = current->right_;
+
+      VELOX_CHECK(right != nullptr, "Right entry is null");
+      VELOX_CHECK(right->valid_, "Right entry is not valid");
+
+      right->invalidate();
+
+      // Merge "current" with "right" and mark "right" as invalid so we don't
+      // visit it again
+      double newWeight = current->weight_ + right->weight_;
+      double newValue = (current->value_ * current->weight_ +
+                         right->value_ * right->weight_) /
+          newWeight;
+
+      Entry* merged =
+          new Entry(current->id_, newValue, newWeight, right->right_);
+
+      allocatedEntries.push_back(merged);
+      queue.push(merged);
+
+      // Update left's penalty
+      Entry* left = current->left_;
+      if (left != nullptr) {
+        VELOX_CHECK(left->valid_, "Left entry is not valid");
+
+        left->invalidate();
+        Entry* newLeft = new Entry(
+            left->id_, left->value_, left->weight_, merged, left->left_);
+        allocatedEntries.push_back(newLeft);
+        queue.push(newLeft);
+      }
+    }
+    // Re populate values_ and weights_ with the reduced queue
+    nextIndex_ = 0;
+    while (!queue.empty()) {
+      Entry* entry = queue.top();
+      queue.pop();
+      if (entry->valid_) {
+        values_[nextIndex_] = entry->value_;
+        weights_[nextIndex_] = entry->weight_;
+        ++nextIndex_;
+      }
+    }
+
+    sortValuesAndWeights();
+    for (Entry* entry : allocatedEntries) {
+      delete entry;
+    }
+  }
+  // Following Java Standard:
+  // https://docs.oracle.com/javase/7/docs/api/java/lang/Double.html#compare(double,%20double)
+  static int doubleCompare(double d1, double d2) {
+    // Handle NaN: NaN is considered greater than any other value, including
+    // infinity
+    if (std::isnan(d1)) {
+      return std::isnan(d2) ? 0 : 1;
+    }
+    if (std::isnan(d2)) {
+      return -1;
+    }
+    // Handle infinities
+    if (d1 == d2) {
+      // Covers +0.0 vs -0.0, +Inf vs +Inf, -Inf vs -Inf
+      return 0;
+    }
+    if (d1 < d2) {
+      return -1;
+    }
+    return 1;
+  }
+
+  // Merge same buckets in place and update nextIndex_
+  void mergeSameBuckets() {
+    sortValuesAndWeights();
+    VELOX_CHECK_GE(values_.size(), nextIndex_);
+    VELOX_CHECK_GE(weights_.size(), nextIndex_);
+
+    int current = 0;
+    for (int i = 1; i < nextIndex_; ++i) {
+      if (doubleCompare(values_[current], values_[i]) == 0) {
+        weights_[current] += weights_[i];
+      } else {
+        ++current;
+        values_[current] = values_[i];
+        weights_[current] = weights_[i];
+      }
+    }
+
+    nextIndex_ = current + 1;
+  }
+
+  // Sort the values and weights
+  void sortValuesAndWeights() {
+    std::vector<std::pair<double, double>> pairs(nextIndex_);
+    VELOX_CHECK_GE(values_.size(), nextIndex_);
+    VELOX_CHECK_GE(weights_.size(), nextIndex_);
+    for (int i = 0; i < nextIndex_; ++i) {
+      pairs[i] = {values_[i], weights_[i]};
+    }
+    std::sort(
+        pairs.begin(),
+        pairs.end(),
+        [this](std::pair<double, double>& a, std::pair<double, double>& b) {
+          return doubleCompare(a.first, b.first) == -1;
+        });
+    for (int i = 0; i < nextIndex_; ++i) {
+      values_[i] = pairs[i].first;
+      weights_[i] = pairs[i].second;
+    }
+  }
+
+  void getBuckets(exec::out_type<Map<double, double>>& out) {
+    compact();
+    VELOX_CHECK_GE(values_.size(), nextIndex_);
+    VELOX_CHECK_GE(weights_.size(), nextIndex_);
+    for (int i = 0; i < nextIndex_; ++i) {
+      auto [keyWriter, valueWriter] = out.add_item();
+      keyWriter = values_[i];
+      valueWriter = weights_[i];
+    }
+  }
+
+  void getBuckets(exec::out_type<Map<float, float>>& out) {
+    compact();
+    VELOX_CHECK_GE(values_.size(), nextIndex_);
+    VELOX_CHECK_GE(weights_.size(), nextIndex_);
+    for (int i = 0; i < nextIndex_; ++i) {
+      auto [keyWriter, valueWriter] = out.add_item();
+      keyWriter = values_[i];
+      valueWriter = weights_[i];
+    }
+  }
+};
+
+template <typename TValue, typename TWeight, typename Func>
+struct NumericHistogramAccumulator {
+  static constexpr bool is_fixed_size_ = false;
+  static constexpr bool use_external_memory_ = true;
+  static constexpr bool is_aligned_ = true;
+
+  std::optional<NumericHistogram> histogram_;
+
+  NumericHistogramAccumulator() = delete;
+
+  explicit NumericHistogramAccumulator(
+      HashStringAllocator* /*allocator*/,
+      Func* /*fn*/) {}
+
+  bool addInput(
+      HashStringAllocator* allocator,
+      exec::arg_type<int64_t> buckets,
+      exec::arg_type<TValue> value) {
+    if (!histogram_.has_value()) {
+      histogram_.emplace(buckets, allocator);
+    }
+    histogram_.value().add(value);
+    return true;
+  }
+
+  bool addInput(
+      HashStringAllocator* allocator,
+      exec::arg_type<int64_t> buckets,
+      exec::arg_type<TValue> value,
+      exec::arg_type<TWeight> weight) {
+    if (!histogram_.has_value()) {
+      histogram_.emplace(buckets, allocator);
+    }
+    histogram_.value().add(value, weight);
+    return true;
+  }
+
+  void combine(
+      HashStringAllocator* allocator,
+      exec::arg_type<Varbinary> other) {
+    common::InputByteStream stream((other.data()));
+    auto otherHistogram = NumericHistogram(stream, allocator);
+
+    if (!histogram_.has_value()) {
+      histogram_.emplace(otherHistogram);
+    } else {
+      histogram_.value().mergeWith(otherHistogram);
+    }
+  }
+
+  bool writeIntermediateResult(exec::out_type<Varbinary>& out) {
+    if (histogram_.has_value()) {
+      const auto serializedSize = histogram_.value().serializedSize();
+      out.reserve(serializedSize);
+      common::OutputByteStream stream(out.data());
+      histogram_.value().serialize(stream);
+
+      out.resize(serializedSize);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  // According to the query plan, The output type is Map<TValue, TValue> rather
+  // than Map<TValue, TWeight>
+  bool writeFinalResult(exec::out_type<Map<TValue, TValue>>& out) {
+    if (histogram_.has_value()) {
+      histogram_.value().getBuckets(out);
+      return true;
+    }
+
+    return false;
+  }
+};
+
+template <typename TValue, typename TWeight, int NumArgs>
+class NumericHistogramAggregate {};
+
+template <typename TValue, typename TWeight>
+class NumericHistogramAggregate<TValue, TWeight, 2> {
+ public:
+  using InputType = Row<int64_t, TValue>;
+
+  using IntermediateType = Varbinary;
+
+  using OutputType = Map<TValue, TValue>;
+
+  using AccumulatorType = NumericHistogramAccumulator<
+      TValue,
+      TWeight,
+      NumericHistogramAggregate<TValue, TWeight, 2>>;
+};
+
+template <typename TValue, typename TWeight>
+class NumericHistogramAggregate<TValue, TWeight, 3> {
+ public:
+  using InputType = Row<int64_t, TValue, TWeight>;
+
+  using IntermediateType = Varbinary;
+
+  using OutputType = Map<TValue, TValue>;
+
+  using AccumulatorType = NumericHistogramAccumulator<
+      TValue,
+      TWeight,
+      NumericHistogramAggregate<TValue, TWeight, 3>>;
+};
+} // namespace
+
+void registerNumericHistogramAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+  const auto valueTypes = {"real", "double"};
+  // todo(wangke): We can enhance the function by adding more types, at least
+  // REAL type in weight, though we don't support real weight in Presto
+  const auto weightTypes = {"real", "double"};
+  for (const auto& valueType : valueTypes) {
+    const auto returnType = fmt::format("map({}, {})", valueType, valueType);
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(returnType)
+            .intermediateType("varbinary")
+            .argumentType("bigint")
+            .argumentType(valueType)
+            .build());
+    for (const auto& weightType : weightTypes) {
+      signatures.push_back(
+          exec::AggregateFunctionSignatureBuilder()
+              .returnType(returnType)
+              .intermediateType("varbinary")
+              .argumentType("bigint")
+              .argumentType(valueType)
+              .argumentType(weightType)
+              .build());
+    }
+  }
+  auto name = prefix + kNumericHistogram;
+
+  exec::registerAggregateFunction(
+      name,
+      signatures,
+      [name](
+          core::AggregationNode::Step step,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultType,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        VELOX_USER_CHECK_GE(
+            argTypes.size(), 2, "{} takes at least two arguments", name);
+        VELOX_USER_CHECK_LE(
+            argTypes.size(), 3, "{} takes at most three arguments", name);
+        if (argTypes[0]->kind() != TypeKind::BIGINT) {
+          VELOX_USER_FAIL(
+              "Aggregation {}: Buckets must be bigint {}, but is {}",
+              name,
+              argTypes[0]->kindName());
+        }
+        if (argTypes[1]->kind() != TypeKind::REAL &&
+            argTypes[1]->kind() != TypeKind::DOUBLE) {
+          VELOX_USER_FAIL(
+              "Aggregation {}: Value must be REAL or DOUBLE {}, but is {}",
+              name,
+              argTypes[1]->kindName());
+        }
+        if (argTypes.size() == 2) {
+          switch (argTypes[1]->kind()) {
+            case TypeKind::REAL:
+              return std::make_unique<exec::SimpleAggregateAdapter<
+                  NumericHistogramAggregate<float, double, 2>>>(
+                  step, argTypes, resultType);
+            case TypeKind::DOUBLE:
+              return std::make_unique<exec::SimpleAggregateAdapter<
+                  NumericHistogramAggregate<double, double, 2>>>(
+                  step, argTypes, resultType);
+
+            default:
+              VELOX_USER_FAIL("Unknown input type for {} aggregation {}", name);
+          }
+        } else {
+          // argTypes.size() == 3
+          if (argTypes[2]->kind() != TypeKind::REAL &&
+              argTypes[2]->kind() != TypeKind::DOUBLE) {
+            VELOX_USER_FAIL(
+                "Aggregation {}: Weight must be REAL or DOUBLE {}, but is {}",
+                name,
+                argTypes[1]->kindName());
+          }
+          switch (argTypes[1]->kind()) {
+            case TypeKind::REAL:
+              switch (argTypes[2]->kind()) {
+                case TypeKind::REAL:
+                  return std::make_unique<exec::SimpleAggregateAdapter<
+                      NumericHistogramAggregate<float, float, 3>>>(
+                      step, argTypes, resultType);
+                case TypeKind::DOUBLE:
+                  return std::make_unique<exec::SimpleAggregateAdapter<
+                      NumericHistogramAggregate<float, double, 3>>>(
+                      step, argTypes, resultType);
+                default:
+                  VELOX_USER_FAIL(
+                      "Unknown weight type for aggregation {}", name);
+              }
+            case TypeKind::DOUBLE:
+              switch (argTypes[2]->kind()) {
+                case TypeKind::REAL:
+                  return std::make_unique<exec::SimpleAggregateAdapter<
+                      NumericHistogramAggregate<double, float, 3>>>(
+                      step, argTypes, resultType);
+                case TypeKind::DOUBLE:
+                  return std::make_unique<exec::SimpleAggregateAdapter<
+                      NumericHistogramAggregate<double, double, 3>>>(
+                      step, argTypes, resultType);
+                default:
+                  VELOX_USER_FAIL(
+                      "Unknown weight type for aggregation {}", name);
+              }
+            default:
+              VELOX_USER_FAIL("Unknown input type for {} aggregation {}", name);
+          }
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/NumericHistogramAggregate.h b/velox/functions/prestosql/aggregates/NumericHistogramAggregate.h
new file mode 100644
index 000000000000..fea9d905e8ef
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/NumericHistogramAggregate.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 <string>
+
+namespace facebook::velox::aggregate::prestosql {
+
+void registerNumericHistogramAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/PrestoHasher.cpp b/velox/functions/prestosql/aggregates/PrestoHasher.cpp
index b6fff3a2e617..2b89ad5b3f5c 100644
--- a/velox/functions/prestosql/aggregates/PrestoHasher.cpp
+++ b/velox/functions/prestosql/aggregates/PrestoHasher.cpp
@@ -104,8 +104,7 @@ FOLLY_ALWAYS_INLINE void hashFloating(
 #if defined(__clang__)
 __attribute__((no_sanitize("integer")))
 #endif
-FOLLY_ALWAYS_INLINE int64_t
-safeHash(const int64_t& a, const int64_t& b) {
+FOLLY_ALWAYS_INLINE int64_t safeHash(const int64_t& a, const int64_t& b) {
   return a * 31 + b;
 }
 
diff --git a/velox/functions/prestosql/aggregates/QDigestAggAggregate.cpp b/velox/functions/prestosql/aggregates/QDigestAggAggregate.cpp
new file mode 100644
index 000000000000..ff4fce84e85f
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/QDigestAggAggregate.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/aggregates/QDigestAggAggregate.h"
+
+#include "velox/exec/Aggregate.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
+#include "velox/expression/FunctionSignature.h"
+#include "velox/functions/lib/QuantileDigest.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions::qdigest;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+template <typename T, typename Func, bool DefaultMaxError>
+struct QDigestAccumulator {
+  static constexpr bool is_fixed_size_ = false;
+  static constexpr bool is_aligned_ = true;
+
+  QuantileDigest<T> digest;
+
+  explicit QDigestAccumulator(HashStringAllocator* allocator, Func* /*fn*/)
+      : digest(
+            StlAllocator<T>(allocator),
+            DefaultMaxError ? 0.01 : kUninitializedMaxError) {}
+
+  void addInput(HashStringAllocator* /*allocator*/, exec::arg_type<T> value) {
+    digest.add(value, 1);
+  }
+
+  void addInput(
+      HashStringAllocator* /*allocator*/,
+      exec::arg_type<T> value,
+      int64_t weight) {
+    digest.add(value, static_cast<double>(weight));
+  }
+
+  void addInput(
+      HashStringAllocator* /*allocator*/,
+      exec::arg_type<T> value,
+      int64_t weight,
+      double accuracy) {
+    checkSetAccuracy(accuracy);
+    digest.add(value, static_cast<double>(weight));
+  }
+
+  void combine(
+      HashStringAllocator* /*allocator*/,
+      exec::arg_type<Varbinary> other) {
+    digest.mergeSerialized(other.data());
+  }
+
+  bool writeFinalResult(exec::out_type<Varbinary>& out) {
+    out.resize(digest.serializedByteSize());
+    digest.serialize(out.data());
+    return true;
+  }
+
+  bool writeIntermediateResult(exec::out_type<Varbinary>& out) {
+    out.resize(digest.serializedByteSize());
+    digest.serialize(out.data());
+    return true;
+  }
+
+ private:
+  void checkSetAccuracy(double accuracy) {
+    VELOX_USER_CHECK(
+        accuracy > 0.0 && accuracy < 1.0,
+        "{}: accuracy must be in range (0.0, 1.0), got {}",
+        kQDigestAgg,
+        accuracy);
+    if (digest.getMaxError() == kUninitializedMaxError) {
+      digest.setMaxError(accuracy);
+    } else if (digest.getMaxError() != accuracy) {
+      VELOX_USER_FAIL(
+          "{}: accuracy must be the same for all rows in the group, got {} and {}",
+          kQDigestAgg,
+          digest.getMaxError(),
+          accuracy);
+    }
+  }
+};
+
+template <typename T, int NumArgs>
+class QDigestAggAggregate {};
+
+template <typename T>
+class QDigestAggAggregate<T, 1> {
+ public:
+  // Type(s) of input vector(s) wrapped in Row.
+  using InputType = Row<T>;
+
+  // Type of intermediate result vector.
+  using IntermediateType = Varbinary;
+
+  // Type of output vector.
+  using OutputType = Varbinary;
+
+  using AccumulatorType =
+      QDigestAccumulator<T, QDigestAggAggregate<T, 1>, true>;
+};
+
+template <typename T>
+class QDigestAggAggregate<T, 2> {
+ public:
+  // Type(s) of input vector(s) wrapped in Row.
+  using InputType = Row<T, int64_t>;
+
+  // Type of intermediate result vector.
+  using IntermediateType = Varbinary;
+
+  // Type of output vector.
+  using OutputType = Varbinary;
+
+  using AccumulatorType =
+      QDigestAccumulator<T, QDigestAggAggregate<T, 2>, true>;
+};
+
+template <typename T>
+class QDigestAggAggregate<T, 3> {
+ public:
+  // Type(s) of input vector(s) wrapped in Row.
+  using InputType = Row<T, int64_t, double>;
+
+  // Type of intermediate result vector.
+  using IntermediateType = Varbinary;
+
+  // Type of output vector.
+  using OutputType = Varbinary;
+
+  using AccumulatorType =
+      QDigestAccumulator<T, QDigestAggAggregate<T, 3>, false>;
+};
+
+template <int NumArgs>
+std::unique_ptr<exec::Aggregate> createQDigestAggAggregate(
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& argTypes,
+    const TypePtr& resultType) {
+  VELOX_CHECK_GE(argTypes.size(), 1);
+  if (argTypes[0]->kind() == TypeKind::BIGINT) {
+    return std::make_unique<
+        SimpleAggregateAdapter<QDigestAggAggregate<int64_t, NumArgs>>>(
+        step, argTypes, resultType);
+  } else if (argTypes[0]->kind() == TypeKind::REAL) {
+    return std::make_unique<
+        SimpleAggregateAdapter<QDigestAggAggregate<float, NumArgs>>>(
+        step, argTypes, resultType);
+  } else if (argTypes[0]->kind() == TypeKind::DOUBLE) {
+    return std::make_unique<
+        SimpleAggregateAdapter<QDigestAggAggregate<double, NumArgs>>>(
+        step, argTypes, resultType);
+  }
+  VELOX_UNREACHABLE("Unsupported argument type: {}", argTypes.size());
+}
+
+} // namespace
+
+void registerQDigestAggAggregate(const std::string& prefix, bool overwrite) {
+  registerQDigestType();
+
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+  for (const auto& type : {"bigint", "real", "double"}) {
+    const auto digestType = fmt::format("qdigest({})", type);
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(digestType)
+            .intermediateType("varbinary")
+            .argumentType(type)
+            .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(digestType)
+            .intermediateType("varbinary")
+            .argumentType(type)
+            .argumentType("bigint")
+            .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(digestType)
+            .intermediateType("varbinary")
+            .argumentType(type)
+            .argumentType("bigint")
+            .argumentType("double")
+            .build());
+  }
+
+  auto name = prefix + kQDigestAgg;
+  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> {
+        if (argTypes.size() == 1) {
+          return createQDigestAggAggregate<1>(step, argTypes, resultType);
+        } else if (argTypes.size() == 2) {
+          return createQDigestAggAggregate<2>(step, argTypes, resultType);
+        } else if (argTypes.size() == 3) {
+          return createQDigestAggAggregate<3>(step, argTypes, resultType);
+        } else {
+          VELOX_UNREACHABLE(
+              "Unexpected number of arguments: {}", argTypes.size());
+        }
+      },
+      false /*registerCompanionFunctions*/,
+      overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/QDigestAggAggregate.h b/velox/functions/prestosql/aggregates/QDigestAggAggregate.h
new file mode 100644
index 000000000000..2e6c5ddb30e7
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/QDigestAggAggregate.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::aggregate::prestosql {
+
+void registerQDigestAggAggregate(const std::string& prefix, bool overwrite);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ReduceAgg.cpp b/velox/functions/prestosql/aggregates/ReduceAgg.cpp
index a651da01f92b..3c8a9b72f402 100644
--- a/velox/functions/prestosql/aggregates/ReduceAgg.cpp
+++ b/velox/functions/prestosql/aggregates/ReduceAgg.cpp
@@ -818,7 +818,7 @@ void registerReduceAgg(
           const core::QueryConfig& config) -> std::unique_ptr<exec::Aggregate> {
         return std::make_unique<ReduceAgg>(resultType);
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp b/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
index af69f0eaea80..f429010db7d5 100644
--- a/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
+++ b/velox/functions/prestosql/aggregates/RegisterAggregateFunctions.cpp
@@ -32,6 +32,7 @@
 #include "velox/functions/prestosql/aggregates/EntropyAggregates.h"
 #include "velox/functions/prestosql/aggregates/GeometricMeanAggregate.h"
 #include "velox/functions/prestosql/aggregates/HistogramAggregate.h"
+#include "velox/functions/prestosql/aggregates/KHyperLogLogAggregate.h"
 #include "velox/functions/prestosql/aggregates/MapAggAggregate.h"
 #include "velox/functions/prestosql/aggregates/MapUnionAggregate.h"
 #include "velox/functions/prestosql/aggregates/MapUnionSumAggregate.h"
@@ -41,26 +42,199 @@
 #include "velox/functions/prestosql/aggregates/MinByAggregate.h"
 #include "velox/functions/prestosql/aggregates/MinMaxAggregates.h"
 #include "velox/functions/prestosql/aggregates/MultiMapAggAggregate.h"
+#include "velox/functions/prestosql/aggregates/NoisyApproxSfmAggregate.h"
+#include "velox/functions/prestosql/aggregates/NoisyAvgGaussianAggregate.h"
+#include "velox/functions/prestosql/aggregates/NoisyCountGaussianAggregate.h"
 #include "velox/functions/prestosql/aggregates/NoisyCountIfGaussianAggregate.h"
+#include "velox/functions/prestosql/aggregates/NoisySumGaussianAggregate.h"
+#include "velox/functions/prestosql/aggregates/NumericHistogramAggregate.h"
+#include "velox/functions/prestosql/aggregates/QDigestAggAggregate.h"
 #include "velox/functions/prestosql/aggregates/ReduceAgg.h"
+#include "velox/functions/prestosql/aggregates/ReservoirSampleAggregate.h"
 #include "velox/functions/prestosql/aggregates/SetAggregates.h"
+#include "velox/functions/prestosql/aggregates/SetDigestAggregate.h"
 #include "velox/functions/prestosql/aggregates/SumAggregate.h"
 #include "velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.h"
 #include "velox/functions/prestosql/aggregates/VarianceAggregates.h"
 #include "velox/functions/prestosql/types/JsonRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/TDigestRegistration.h"
+#ifdef VELOX_ENABLE_GEO
+#include "velox/functions/prestosql/aggregates/GeometryAggregate.h"
+#endif
 
 namespace facebook::velox::aggregate::prestosql {
 
+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 registerClassificationFunctions(
+    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);
+#ifdef VELOX_ENABLE_GEO
+extern void registerGeometryAggregate(
+    const std::string& prefix,
+    bool overwrite);
+#endif
+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 registerMakeSetDigestAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMergeSetDigestAggregate(
+    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);
+
+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 registerMaxByAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerMinByAggregates(
+    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);
+extern void registerTDigestAggregate(const std::string& prefix, bool overwrite);
+extern void registerKHyperLogLogAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+extern void registerTDigestAggregate(const std::string& prefix, bool overwrite);
+extern void registerKHyperLogLogAggregates(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
 void registerAllAggregateFunctions(
     const std::string& prefix,
     bool withCompanionFunctions,
     bool onlyPrestoSignatures,
     bool overwrite) {
   registerJsonType();
+  registerSetDigestType();
+  registerTDigestType();
+  registerKHyperLogLogType();
   registerApproxDistinctAggregates(prefix, withCompanionFunctions, overwrite);
   registerApproxMostFrequentAggregate(
       prefix, withCompanionFunctions, overwrite);
   registerApproxPercentileAggregate(prefix, withCompanionFunctions, overwrite);
+  registerQDigestAggAggregate(prefix, overwrite);
   registerArbitraryAggregate(prefix, withCompanionFunctions, overwrite);
   registerArrayAggAggregate(prefix, withCompanionFunctions, overwrite);
   registerAverageAggregate(prefix, withCompanionFunctions, overwrite);
@@ -77,10 +251,15 @@ void registerAllAggregateFunctions(
   registerCovarianceAggregates(prefix, withCompanionFunctions, overwrite);
   registerEntropyAggregate(prefix, withCompanionFunctions, overwrite);
   registerGeometricMeanAggregate(prefix, withCompanionFunctions, overwrite);
+#ifdef VELOX_ENABLE_GEO
+  registerGeometryAggregate(prefix, overwrite);
+#endif
   registerHistogramAggregate(prefix, withCompanionFunctions, overwrite);
   registerMapAggAggregate(prefix, withCompanionFunctions, overwrite);
   registerMapUnionAggregate(prefix, withCompanionFunctions, overwrite);
   registerMapUnionSumAggregate(prefix, withCompanionFunctions, overwrite);
+  registerMakeSetDigestAggregate(prefix, withCompanionFunctions, overwrite);
+  registerMergeSetDigestAggregate(prefix, withCompanionFunctions, overwrite);
   registerMaxDataSizeForStatsAggregate(
       prefix, withCompanionFunctions, overwrite);
   registerMultiMapAggAggregate(prefix, withCompanionFunctions, overwrite);
@@ -90,13 +269,22 @@ void registerAllAggregateFunctions(
   registerMinMaxAggregates(prefix, withCompanionFunctions, overwrite);
   registerMaxByAggregates(prefix, withCompanionFunctions, overwrite);
   registerMinByAggregates(prefix, withCompanionFunctions, overwrite);
+  registerNoisyAvgGaussianAggregate(prefix, withCompanionFunctions, overwrite);
   registerNoisyCountIfGaussianAggregate(
       prefix, withCompanionFunctions, overwrite);
+  registerNoisyCountGaussianAggregate(
+      prefix, withCompanionFunctions, overwrite);
+  registerNoisySumGaussianAggregate(prefix, withCompanionFunctions, overwrite);
   registerReduceAgg(prefix, withCompanionFunctions, overwrite);
+  registerReservoirSampleAggregate(prefix, withCompanionFunctions, overwrite);
   registerSetAggAggregate(prefix, withCompanionFunctions, overwrite);
   registerSetUnionAggregate(prefix, withCompanionFunctions, overwrite);
   registerSumAggregate(prefix, withCompanionFunctions, overwrite);
   registerVarianceAggregates(prefix, withCompanionFunctions, overwrite);
+  registerTDigestAggregate(prefix, overwrite);
+  registerNoisyApproxSfmAggregate(prefix, withCompanionFunctions, overwrite);
+  registerNumericHistogramAggregate(prefix, withCompanionFunctions, overwrite);
+  registerKHyperLogLogAggregates(prefix, withCompanionFunctions, overwrite);
 }
 
 void registerInternalAggregateFunctions(const std::string& prefix) {
diff --git a/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.cpp b/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.cpp
new file mode 100644
index 000000000000..9a696cacf350
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.cpp
@@ -0,0 +1,892 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/ReservoirSampleAggregate.h"
+
+#include <folly/Random.h>
+
+#include "velox/common/base/Exceptions.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+struct ReservoirSampleAccumulator {
+  VectorPtr samples = nullptr;
+  std::optional<int32_t> maxSampleSize = std::nullopt;
+  std::optional<int64_t> processedCount = std::nullopt;
+  VectorPtr initialSamples = nullptr;
+  // -1 indicates no initialSamples. Use -1 for simplicity for writing and
+  // reading intermediate results. Allowed values of initialSeenCount are -1, 0,
+  // and positive integers.
+  int64_t initialSeenCount = -1;
+
+  void initialize(
+      int32_t desiredSampleSize,
+      const TypePtr& elementType,
+      memory::MemoryPool* pool);
+
+  bool isInitialized() const {
+    if (samples == nullptr) {
+      return false;
+    }
+    VELOX_DCHECK(maxSampleSize.has_value());
+    VELOX_DCHECK(processedCount.has_value());
+    return true;
+  }
+
+  vector_size_t initialSampleCount() const {
+    return initialSamples ? initialSamples->size() : 0;
+  }
+
+  vector_size_t sampleCount() const {
+    return std::min<vector_size_t>(
+        processedCount.value_or(0), maxSampleSize.value_or(0));
+  }
+
+  /// Adds a single value to the reservoir sample using reservoir sampling
+  /// algorithm.
+  /// @param vector The vector containing the value to add.
+  /// @param row The row within the vector to add.
+  /// @param isNull Whether the value at the given row is null.
+  void addValueToReservoir(
+      const BaseVector* vector,
+      vector_size_t row,
+      bool isNull = false);
+
+  /// Adds multiple values from a vector to the reservoir sample using
+  /// reservoir sampling algorithm.
+  /// @param vector The vector containing the values to add.
+  /// @param offset Starting offset within the vector.
+  /// @param size Number of values to add from the vector.
+  void addValuesToReservoir(
+      const BaseVector* vector,
+      vector_size_t offset,
+      vector_size_t size);
+
+  /// Merges reservoir samples from an ArrayVector row into this accumulator.
+  /// @param otherSampleArrayVector ArrayVector containing the samples to merge.
+  /// @param otherRow Row within otherSampleArrayVector containing the samples
+  /// to merge.
+  /// @param otherProcessedCount Total number of processed input elements.
+  /// @param otherMaxSampleSize: Max sample size to maintain in the reservoir.
+  void mergeSamples(
+      const ArrayVector& otherSampleArrayVector,
+      vector_size_t otherRow,
+      int64_t otherProcessedCount,
+      int32_t otherMaxSampleSize,
+      memory::MemoryPool* pool);
+
+  /// Merges reservoir samples from another vector into this accumulator.
+  /// @param otherSampleVector Vector containing the samples to merge.
+  /// @param otherOffset Starting offset within otherSampleVector.
+  /// @param otherSize Number of samples to merge from otherSampleVector.
+  /// @param otherProcessedCount Total number of processed input elements.
+  /// @param otherMaxSampleSize: Max sample size to maintain in the reservoir.
+  void mergeSamples(
+      const VectorPtr& otherSampleVector,
+      vector_size_t otherOffset,
+      vector_size_t otherSize,
+      int64_t otherProcessedCount,
+      int32_t otherMaxSampleSize,
+      memory::MemoryPool* pool);
+
+  /// Sets the samples for this accumulator from a source vector.
+  /// @param sampleVector Source vector containing the samples to copy.
+  /// @param offset Starting offset within sampleVector to copy from.
+  /// @param size Number of samples to copy from sampleVector.
+  /// @param seenCount Total number of elements that have been processed.
+  /// @param desiredSampleSize Max sample size to maintain in the reservoir.
+  void setSamples(
+      const VectorPtr& sampleVector,
+      vector_size_t offset,
+      vector_size_t size,
+      int64_t seenCount,
+      int32_t desiredSampleSize,
+      memory::MemoryPool* pool);
+
+  /// Sets the initial samples for this accumulator from a source vector.
+  /// This is used to initialize the reservoir with a pre-existing sample set
+  /// and its associated processed count from a previous sampling operation.
+  /// @param initialSampleVector Source vector containing the initial samples to
+  /// copy.
+  /// @param offset Starting offset within initialSampleVector to copy from.
+  /// @param size Number of initial samples to copy from initialSampleVector.
+  /// @param initialProcessedCount Total number of elements that were processed
+  ///        to generate the initial samples.
+  void setInitialSamples(
+      const VectorPtr initialSampleVector,
+      vector_size_t offset,
+      vector_size_t size,
+      int64_t initialProcessedCount,
+      memory::MemoryPool* pool);
+};
+
+void ReservoirSampleAccumulator::initialize(
+    int32_t desiredSampleSize,
+    const TypePtr& elementType,
+    memory::MemoryPool* pool) {
+  VELOX_USER_CHECK_GT(desiredSampleSize, 0, "sample size must be positive");
+  maxSampleSize = desiredSampleSize;
+  samples = BaseVector::create(elementType, desiredSampleSize, pool);
+  VELOX_DCHECK(samples->isFlatEncoding());
+  processedCount = 0;
+
+  initialSamples = nullptr;
+  initialSeenCount = -1;
+}
+
+void ReservoirSampleAccumulator::setSamples(
+    const VectorPtr& sampleVector,
+    vector_size_t offset,
+    vector_size_t size,
+    int64_t seenCount,
+    int32_t desiredSampleSize,
+    memory::MemoryPool* pool) {
+  VELOX_DCHECK_NOT_NULL(sampleVector);
+  VELOX_DCHECK_GE(seenCount, 0);
+  VELOX_DCHECK(size == seenCount || size == desiredSampleSize);
+
+  if (samples == nullptr) {
+    samples = BaseVector::create(sampleVector->type(), desiredSampleSize, pool);
+  }
+  samples->copy(sampleVector.get(), 0, offset, size);
+  processedCount = seenCount;
+  maxSampleSize = desiredSampleSize;
+}
+
+void ReservoirSampleAccumulator::setInitialSamples(
+    const VectorPtr initialSampleVector,
+    vector_size_t offset,
+    vector_size_t size,
+    int64_t initialProcessedCount,
+    memory::MemoryPool* pool) {
+  if (initialProcessedCount <= 0) {
+    VELOX_USER_CHECK(
+        initialSampleVector == nullptr || size == 0,
+        "Initial state array must be null or empty "
+        "when initial processed count is <= 0.");
+  }
+
+  if (initialSeenCount >= 0) {
+    return;
+  }
+
+  if (initialSampleVector && size > 0) {
+    VELOX_USER_CHECK_GE(
+        initialProcessedCount,
+        size,
+        "InitialProcessedCount must be greater than or equal to the number "
+        "of positions in the initial sample.");
+  }
+
+  // When initialSamples == nullptr, initialSeenCount can be any of
+  // -1, 0, or positive.
+  initialSeenCount = initialProcessedCount;
+
+  if (initialProcessedCount <= 0 || initialSampleVector == nullptr) {
+    initialSamples = nullptr;
+    return;
+  }
+  initialSamples = BaseVector::create(initialSampleVector->type(), size, pool);
+  initialSamples->copy(initialSampleVector.get(), 0, offset, size);
+}
+
+void ReservoirSampleAccumulator::addValueToReservoir(
+    const BaseVector* vector,
+    vector_size_t row,
+    bool isNull) {
+  VELOX_CHECK(isInitialized());
+
+  processedCount = processedCount.value_or(0) + 1;
+
+  vector_size_t targetIndex = -1;
+  if (processedCount.value() <= maxSampleSize) {
+    targetIndex = processedCount.value() - 1;
+  } else {
+    const uint64_t random = folly::Random::rand64(processedCount.value());
+    if (random < samples->size()) {
+      targetIndex = random;
+    }
+  }
+
+  if (targetIndex >= 0) {
+    if (isNull) {
+      samples->setNull(targetIndex, true);
+    } else {
+      samples->copy(vector, targetIndex, row, 1);
+    }
+  }
+}
+
+void ReservoirSampleAccumulator::addValuesToReservoir(
+    const BaseVector* vector,
+    vector_size_t offset,
+    vector_size_t size) {
+  VELOX_CHECK(isInitialized());
+
+  SelectivityVector rows(maxSampleSize.value(), false);
+  std::vector<vector_size_t> toSource(maxSampleSize.value());
+
+  for (vector_size_t i = 0; i < size; i++) {
+    if (processedCount.value() < maxSampleSize) {
+      toSource[processedCount.value()] = offset + i;
+      rows.setValid(processedCount.value(), true);
+
+      processedCount = processedCount.value_or(0) + 1;
+    } else {
+      processedCount = processedCount.value_or(0) + 1;
+
+      const uint64_t random = folly::Random::rand64(processedCount.value());
+      if (random < samples->size()) {
+        toSource[random] = offset + i;
+        rows.setValid(random, true);
+      }
+    }
+  }
+  rows.updateBounds();
+
+  samples->copy(vector, rows, toSource.data());
+}
+
+void ReservoirSampleAccumulator::mergeSamples(
+    const ArrayVector& otherSampleArrayVector,
+    vector_size_t otherRow,
+    int64_t otherProcessedCount,
+    int32_t otherMaxSampleSize,
+    memory::MemoryPool* pool) {
+  if (otherSampleArrayVector.isNullAt(otherRow)) {
+    return;
+  }
+  mergeSamples(
+      otherSampleArrayVector.elements(),
+      otherSampleArrayVector.offsetAt(otherRow),
+      otherSampleArrayVector.sizeAt(otherRow),
+      otherProcessedCount,
+      otherMaxSampleSize,
+      pool);
+}
+
+BufferPtr makeShuffledIndex(
+    vector_size_t size,
+    vector_size_t offset,
+    folly::ThreadLocalPRNG& randGen,
+    memory::MemoryPool* pool) {
+  BufferPtr index = allocateIndices(size, pool);
+  vector_size_t* rawIndex = index->asMutable<vector_size_t>();
+  std::iota(rawIndex, rawIndex + size, offset);
+  std::shuffle(rawIndex, rawIndex + size, randGen);
+  return index;
+}
+
+void ReservoirSampleAccumulator::mergeSamples(
+    const VectorPtr& otherSampleVector,
+    vector_size_t otherOffset,
+    vector_size_t otherSize,
+    int64_t otherProcessedCount,
+    int32_t otherMaxSampleSize,
+    memory::MemoryPool* pool) {
+  VELOX_DCHECK_GE(otherProcessedCount, 0);
+  VELOX_DCHECK_GT(otherMaxSampleSize, 0);
+  VELOX_CHECK_NOT_NULL(otherSampleVector);
+
+  const TypePtr& elementType = otherSampleVector->type();
+
+  if (!isInitialized()) {
+    initialize(otherMaxSampleSize, elementType, pool);
+  }
+
+  VELOX_DCHECK(
+      samples->type()->equivalent(*elementType),
+      "Samples to be merged are of different types.");
+  VELOX_USER_CHECK_EQ(
+      maxSampleSize.value(),
+      otherMaxSampleSize,
+      "maximum number of samples {} must be equal to that of other {}",
+      maxSampleSize.value(),
+      otherMaxSampleSize);
+
+  if (otherProcessedCount < maxSampleSize.value()) {
+    addValuesToReservoir(otherSampleVector.get(), otherOffset, otherSize);
+    return;
+  }
+
+  if (processedCount.value() < maxSampleSize.value()) {
+    const VectorPtr tempSamples = std::move(samples);
+    samples = nullptr;
+    const int64_t tempProcessedCount = processedCount.value();
+
+    setSamples(
+        otherSampleVector,
+        otherOffset,
+        otherSize,
+        otherProcessedCount,
+        otherMaxSampleSize,
+        pool);
+
+    addValuesToReservoir(tempSamples.get(), 0, tempProcessedCount);
+    return;
+  }
+
+  VectorPtr mergedSamples =
+      BaseVector::create(elementType, maxSampleSize.value(), pool);
+  vector_size_t oneSelected = 0;
+  for (vector_size_t i = 0; i < maxSampleSize.value(); ++i) {
+    if (folly::Random::rand64(processedCount.value() + otherProcessedCount) <
+        processedCount.value()) {
+      oneSelected++;
+    }
+  }
+
+  SelectivityVector rows(maxSampleSize.value(), false);
+  folly::ThreadLocalPRNG rng;
+  if (oneSelected > 0) {
+    rows.setValidRange(0, oneSelected, true);
+    rows.updateBounds();
+
+    const BufferPtr oneIndex = makeShuffledIndex(sampleCount(), 0, rng, pool);
+    mergedSamples->copy(samples.get(), rows, oneIndex->as<vector_size_t>());
+  }
+
+  vector_size_t otherSelected = maxSampleSize.value() - oneSelected;
+  if (otherSelected > 0) {
+    rows.clearAll();
+    rows.setValidRange(oneSelected, maxSampleSize.value(), true);
+    rows.updateBounds();
+
+    BufferPtr otherIndex = makeShuffledIndex(otherSize, otherOffset, rng, pool);
+    // Shift the source indices of the mapping forward by oneSelected.
+    auto* otherRawIndex = otherIndex->asMutable<vector_size_t>();
+    for (vector_size_t i = 0; i < otherSelected; ++i) {
+      otherRawIndex[maxSampleSize.value() - 1 - i] =
+          otherRawIndex[maxSampleSize.value() - 1 - i - oneSelected];
+    }
+
+    mergedSamples->copy(
+        otherSampleVector.get(), rows, otherIndex->as<vector_size_t>());
+  }
+
+  samples = std::move(mergedSamples);
+  processedCount = processedCount.value() + otherProcessedCount;
+}
+
+class ReservoirSampleAggregate : public exec::Aggregate {
+ public:
+  explicit ReservoirSampleAggregate(TypePtr resultType);
+
+  int32_t accumulatorFixedWidthSize() const override;
+
+  bool accumulatorUsesExternalMemory() const override;
+
+  bool isFixedSize() const override;
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override;
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override;
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool mayPushdown) 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;
+
+ protected:
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override;
+
+  void destroyInternal(folly::Range<char**> groups) override;
+
+ private:
+  template <bool kSingleGroup>
+  void addRaw(
+      std::conditional_t<kSingleGroup, char*, char**> group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args);
+
+  template <bool kSingleGroup>
+  void addIntermediate(
+      std::conditional_t<kSingleGroup, char*, char**> group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args);
+
+  static void validateArguments(const std::vector<VectorPtr>& args);
+
+  std::tuple<vector_size_t, vector_size_t, vector_size_t> computeTotalSamples(
+      char** groups,
+      int32_t numGroups) const;
+};
+
+ReservoirSampleAggregate::ReservoirSampleAggregate(TypePtr resultType)
+    : exec::Aggregate(std::move(resultType)) {}
+
+int32_t ReservoirSampleAggregate::accumulatorFixedWidthSize() const {
+  return sizeof(ReservoirSampleAccumulator);
+}
+
+bool ReservoirSampleAggregate::accumulatorUsesExternalMemory() const {
+  return true;
+}
+
+bool ReservoirSampleAggregate::isFixedSize() const {
+  return false;
+}
+
+void ReservoirSampleAggregate::extractValues(
+    char** groups,
+    int32_t numGroups,
+    VectorPtr* result) {
+  auto* rowVector = (*result)->asChecked<RowVector>();
+  rowVector->resetNulls();
+  rowVector->resize(numGroups);
+
+  auto* processedCountVector =
+      rowVector->childAt(0)->asChecked<FlatVector<int64_t>>();
+  processedCountVector->resetNulls();
+
+  auto* sampleArrayVector = rowVector->childAt(1)->asChecked<ArrayVector>();
+  sampleArrayVector->resetNulls();
+  const auto [_, __, totalMergedSamples] =
+      computeTotalSamples(groups, numGroups);
+  const VectorPtr& sampleElementsVector = sampleArrayVector->elements();
+  sampleElementsVector->resize(totalMergedSamples);
+
+  vector_size_t offset = 0;
+  for (int32_t i = 0; i < numGroups; i++) {
+    const auto* accumulator = value<ReservoirSampleAccumulator>(groups[i]);
+
+    if (!accumulator->isInitialized()) {
+      sampleArrayVector->setNull(i, true);
+      processedCountVector->setNull(i, true);
+      continue;
+    }
+
+    // Merge the initial sample at last in the final aggregation before
+    // extracting output.
+    VELOX_USER_CHECK(
+        accumulator->initialSeenCount <= 0 ||
+            (accumulator->initialSeenCount ==
+                 accumulator->initialSampleCount() &&
+             accumulator->initialSampleCount() <=
+                 accumulator->maxSampleSize.value()) ||
+            accumulator->maxSampleSize.value() ==
+                accumulator->initialSampleCount(),
+        "When a positive initial_processed_count is provided, "
+        "the size of the initial sample must be equal to desired_sample_size parameter.");
+
+    ReservoirSampleAccumulator finalAccumulator;
+    const VectorPtr nonNullInitialSample = BaseVector::getOrCreateEmpty(
+        accumulator->initialSamples,
+        accumulator->samples->type(),
+        allocator_->pool());
+    finalAccumulator.setSamples(
+        nonNullInitialSample,
+        0,
+        accumulator->initialSampleCount(),
+        std::max<int64_t>(accumulator->initialSeenCount, 0),
+        accumulator->maxSampleSize.value(),
+        allocator_->pool());
+    finalAccumulator.mergeSamples(
+        accumulator->samples,
+        0,
+        accumulator->sampleCount(),
+        accumulator->processedCount.value(),
+        accumulator->maxSampleSize.value(),
+        allocator_->pool());
+
+    sampleArrayVector->setNull(i, false);
+    const vector_size_t sampleSize = finalAccumulator.sampleCount();
+    sampleElementsVector->copy(
+        finalAccumulator.samples.get(), offset, 0, sampleSize);
+    sampleArrayVector->setOffsetAndSize(i, offset, sampleSize);
+    offset += sampleSize;
+
+    processedCountVector->set(i, finalAccumulator.processedCount.value());
+  }
+}
+
+void ReservoirSampleAggregate::extractAccumulators(
+    char** groups,
+    int32_t numGroups,
+    VectorPtr* result) {
+  // Order of RowVector children is determined by protocol.
+  auto* rowVector = (*result)->asChecked<RowVector>();
+  rowVector->resetNulls();
+  rowVector->resize(numGroups);
+
+  const auto [totalSamples, totalInitialSamples, _] =
+      computeTotalSamples(groups, numGroups);
+
+  auto* initialSampleVector = rowVector->childAt(0)->asChecked<ArrayVector>();
+  initialSampleVector->resetNulls();
+  const VectorPtr& initialSampleElementsVector =
+      initialSampleVector->elements();
+  initialSampleElementsVector->resize(totalInitialSamples);
+
+  auto* initialSeenCountVector =
+      rowVector->childAt(1)->asChecked<FlatVector<int64_t>>();
+  initialSeenCountVector->resetNulls();
+
+  auto* seenCountVector =
+      rowVector->childAt(2)->asChecked<FlatVector<int64_t>>();
+  seenCountVector->resetNulls();
+
+  auto* maxSampleSizeVector =
+      rowVector->childAt(3)->asChecked<FlatVector<int32_t>>();
+  maxSampleSizeVector->resetNulls();
+
+  auto* sampleVector = rowVector->childAt(4)->asChecked<ArrayVector>();
+  sampleVector->resetNulls();
+  const VectorPtr& sampleElementsVector = sampleVector->elements();
+  sampleElementsVector->resize(totalSamples);
+
+  vector_size_t offset = 0;
+  vector_size_t initialSampleOffset = 0;
+
+  for (int32_t i = 0; i < numGroups; i++) {
+    const auto* accumulator = value<ReservoirSampleAccumulator>(groups[i]);
+
+    if (!accumulator->isInitialized()) {
+      rowVector->setNull(i, true);
+      sampleVector->setNull(i, true);
+      maxSampleSizeVector->setNull(i, true);
+      seenCountVector->setNull(i, true);
+      initialSampleVector->setNull(i, true);
+      initialSeenCountVector->setNull(i, true);
+      continue;
+    }
+
+    rowVector->setNull(i, false);
+    sampleVector->setNull(i, false);
+    const vector_size_t sampleSize = accumulator->sampleCount();
+    sampleElementsVector->copy(
+        accumulator->samples.get(), offset, 0, sampleSize);
+    sampleVector->setOffsetAndSize(i, offset, sampleSize);
+    offset += sampleSize;
+
+    maxSampleSizeVector->set(i, accumulator->maxSampleSize.value());
+    seenCountVector->set(i, accumulator->processedCount.value());
+
+    if (accumulator->initialSamples == nullptr) {
+      initialSampleVector->setNull(i, true);
+    } else {
+      initialSampleVector->setNull(i, false);
+      const vector_size_t initialSampleSize = accumulator->initialSampleCount();
+      initialSampleElementsVector->copy(
+          accumulator->initialSamples.get(),
+          initialSampleOffset,
+          0,
+          initialSampleSize);
+      initialSampleVector->setOffsetAndSize(
+          i, initialSampleOffset, initialSampleSize);
+      initialSampleOffset += initialSampleSize;
+    }
+
+    initialSeenCountVector->set(i, accumulator->initialSeenCount);
+  }
+}
+
+template <bool kSingleGroup>
+void ReservoirSampleAggregate::addRaw(
+    std::conditional_t<kSingleGroup, char*, char**> group,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args) {
+  validateArguments(args);
+
+  const DecodedVector initialSampleDecoded(*args[0], rows);
+  const DecodedVector initialProcessedCountDecoded(*args[1], rows);
+  const DecodedVector valuesToSampleDecoded(*args[2], rows);
+  const DecodedVector desiredSampleSizeDecoded(*args[3], rows);
+
+  rows.applyToSelected([&](vector_size_t row) {
+    if (desiredSampleSizeDecoded.isNullAt(row) ||
+        initialProcessedCountDecoded.isNullAt(row)) {
+      return;
+    }
+
+    ReservoirSampleAccumulator* accumulator;
+    if constexpr (kSingleGroup) {
+      accumulator = value<ReservoirSampleAccumulator>(group);
+    } else {
+      accumulator = value<ReservoirSampleAccumulator>(group[row]);
+    }
+
+    if (!accumulator->isInitialized()) {
+      accumulator->initialize(
+          desiredSampleSizeDecoded.valueAt<int32_t>(row),
+          valuesToSampleDecoded.base()->type(),
+          allocator_->pool());
+    }
+
+    const auto* initialSampleBase =
+        initialSampleDecoded.base()->asChecked<ArrayVector>();
+    accumulator->setInitialSamples(
+        initialSampleDecoded.isNullAt(row) ? nullptr
+                                           : initialSampleBase->elements(),
+        initialSampleBase->offsetAt(initialSampleDecoded.index(row)),
+        initialSampleBase->sizeAt(initialSampleDecoded.index(row)),
+        initialProcessedCountDecoded.valueAt<int64_t>(row),
+        allocator_->pool());
+
+    accumulator->addValueToReservoir(
+        valuesToSampleDecoded.base(),
+        valuesToSampleDecoded.index(row),
+        valuesToSampleDecoded.isNullAt(row));
+  });
+}
+
+template <bool kSingleGroup>
+void ReservoirSampleAggregate::addIntermediate(
+    std::conditional_t<kSingleGroup, char*, char**> group,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args) {
+  VELOX_CHECK_EQ(args.size(), 1, "Intermediate results requires 1 argument");
+
+  const DecodedVector decodedIntermediate(*args[0], rows);
+  const auto* rowVector = decodedIntermediate.base()->asChecked<RowVector>();
+  VELOX_CHECK_EQ(rowVector->childrenSize(), 5);
+  const auto* initialSampleArrayVector =
+      rowVector->childAt(0)->asChecked<ArrayVector>();
+  const auto* initialSeenCountVector =
+      rowVector->childAt(1)->asChecked<FlatVector<int64_t>>();
+  const auto* seenCountVector =
+      rowVector->childAt(2)->asChecked<FlatVector<int64_t>>();
+  const auto* maxSampleSizeVector =
+      rowVector->childAt(3)->asChecked<FlatVector<int32_t>>();
+  const auto* sampleArrayVector =
+      rowVector->childAt(4)->asChecked<ArrayVector>();
+
+  const auto& elementType = sampleArrayVector->elements()->type();
+
+  rows.applyToSelected([&](vector_size_t row) {
+    if (decodedIntermediate.isNullAt(row)) {
+      return;
+    }
+
+    const auto decodedRow = decodedIntermediate.index(row);
+
+    if (sampleArrayVector->isNullAt(decodedRow)) {
+      return;
+    }
+    VELOX_DCHECK(!maxSampleSizeVector->isNullAt(decodedRow));
+    VELOX_DCHECK(!seenCountVector->isNullAt(decodedRow));
+    VELOX_DCHECK(!initialSeenCountVector->isNullAt(decodedRow));
+
+    ReservoirSampleAccumulator* accumulator;
+    if constexpr (kSingleGroup) {
+      accumulator = value<ReservoirSampleAccumulator>(group);
+    } else {
+      accumulator = value<ReservoirSampleAccumulator>(group[row]);
+    }
+
+    if (!accumulator->isInitialized()) {
+      accumulator->initialize(
+          maxSampleSizeVector->valueAt(decodedRow),
+          elementType,
+          allocator_->pool());
+    }
+
+    accumulator->mergeSamples(
+        *sampleArrayVector,
+        decodedRow,
+        seenCountVector->valueAt(decodedRow),
+        maxSampleSizeVector->valueAt(decodedRow),
+        allocator_->pool());
+    accumulator->setInitialSamples(
+        initialSampleArrayVector->isNullAt(decodedRow)
+            ? nullptr
+            : initialSampleArrayVector->elements(),
+        initialSampleArrayVector->offsetAt(decodedRow),
+        initialSampleArrayVector->sizeAt(decodedRow),
+        initialSeenCountVector->valueAt(decodedRow),
+        allocator_->pool());
+  });
+}
+
+void ReservoirSampleAggregate::addRawInput(
+    char** groups,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args,
+    bool /* mayPushdown */) {
+  addRaw<false>(groups, rows, args);
+}
+
+void ReservoirSampleAggregate::addIntermediateResults(
+    char** groups,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args,
+    bool /* mayPushdown */) {
+  addIntermediate<false>(groups, rows, args);
+}
+
+void ReservoirSampleAggregate::addSingleGroupRawInput(
+    char* group,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args,
+    bool /* mayPushdown */) {
+  addRaw<true>(group, rows, args);
+}
+
+void ReservoirSampleAggregate::addSingleGroupIntermediateResults(
+    char* group,
+    const SelectivityVector& rows,
+    const std::vector<VectorPtr>& args,
+    bool /* mayPushdown */) {
+  addIntermediate<true>(group, rows, args);
+}
+
+void ReservoirSampleAggregate::initializeNewGroupsInternal(
+    char** groups,
+    folly::Range<const vector_size_t*> indices) {
+  for (auto index : indices) {
+    new (groups[index] + offset_) ReservoirSampleAccumulator();
+  }
+}
+
+void ReservoirSampleAggregate::destroyInternal(folly::Range<char**> groups) {
+  for (auto group : groups) {
+    if (isInitialized(group)) {
+      auto* accumulator = value<ReservoirSampleAccumulator>(group);
+      std::destroy_at(accumulator);
+    }
+  }
+}
+
+// static
+void ReservoirSampleAggregate::validateArguments(
+    const std::vector<VectorPtr>& args) {
+  static constexpr size_t kInitialSampleIndex = 0;
+  static constexpr size_t kInitialProcessedCountIndex = 1;
+  static constexpr size_t kSampleIndex = 2;
+  static constexpr size_t kMaxSampleSizeIndex = 3;
+
+  VELOX_USER_CHECK_EQ(args.size(), 4, "reservoir_sample requires 4 arguments");
+  VELOX_USER_CHECK(args[kInitialProcessedCountIndex]->type()->isBigint());
+  VELOX_USER_CHECK(args[kMaxSampleSizeIndex]->type()->isInteger());
+
+  auto elementType = args[kSampleIndex]->type();
+  // TODO: extend to ComplexType
+  VELOX_USER_CHECK(elementType->isPrimitiveType());
+  auto initialSampleType = args[kInitialSampleIndex]->type();
+  VELOX_USER_CHECK(initialSampleType->isArray());
+  VELOX_USER_CHECK(
+      initialSampleType->asArray().elementType()->equivalent(*elementType),
+      "Initial samples and values to sample must have the same type.");
+}
+
+std::tuple<vector_size_t, vector_size_t, vector_size_t>
+ReservoirSampleAggregate::computeTotalSamples(char** groups, int32_t numGroups)
+    const {
+  vector_size_t totalSamples = 0;
+  vector_size_t totalInitialSamples = 0;
+  vector_size_t totalMergedSamples = 0;
+
+  for (int32_t i = 0; i < numGroups; i++) {
+    const auto* accumulator = value<ReservoirSampleAccumulator>(groups[i]);
+    totalSamples += accumulator->sampleCount();
+    totalInitialSamples += accumulator->initialSampleCount();
+    totalMergedSamples += std::min<vector_size_t>(
+        accumulator->sampleCount() + accumulator->initialSampleCount(),
+        accumulator->maxSampleSize.value_or(0));
+  }
+
+  return std::make_tuple(totalSamples, totalInitialSamples, totalMergedSamples);
+}
+
+} // namespace
+
+void registerReservoirSampleAggregate(
+    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",
+           "varchar",
+           "boolean",
+           "timestamp",
+       }) {
+    // argumentType, intermediateType and returnType and their field order need
+    // to be consistent with those defined in protocol.
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType(
+                fmt::format(
+                    "row(processed_count bigint, sample array({}))", inputType))
+            .intermediateType(
+                fmt::format(
+                    "row(initialSample array({}), initialSeenCount bigint, "
+                    "seenCount bigint, maxSampleSize integer, sample array({}))",
+                    inputType,
+                    inputType))
+            .argumentType(fmt::format("array({})", inputType))
+            .argumentType("bigint")
+            .argumentType(inputType)
+            .argumentType("integer")
+            .build());
+  }
+
+  auto name = prefix + kReservoirSample;
+  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(), 4, "reservoir_sample requires 4 arguments");
+
+        return std::make_unique<ReservoirSampleAggregate>(resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.h b/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.h
new file mode 100644
index 000000000000..fa679bf407d8
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/ReservoirSampleAggregate.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::aggregate::prestosql {
+
+void registerReservoirSampleAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite);
+
+}
diff --git a/velox/functions/prestosql/aggregates/SetAggregates.cpp b/velox/functions/prestosql/aggregates/SetAggregates.cpp
index 6b7cee1edd8a..a42a53a89e4e 100644
--- a/velox/functions/prestosql/aggregates/SetAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/SetAggregates.cpp
@@ -158,8 +158,7 @@ class CountDistinctAggregate
 };
 
 template <
-    template <typename T, typename AccumulatorType>
-    class Aggregate,
+    template <typename T, typename AccumulatorType> class Aggregate,
     TypeKind Kind>
 std::unique_ptr<exec::Aggregate> create(const TypePtr& resultType) {
   return std::make_unique<Aggregate<
@@ -167,8 +166,9 @@ std::unique_ptr<exec::Aggregate> create(const TypePtr& resultType) {
       aggregate::prestosql::CustomComparisonSetAccumulator<Kind>>>(resultType);
 }
 
-template <template <typename T, typename AcumulatorType = SetAccumulator<T>>
-          class Aggregate>
+template <template <
+    typename T,
+    typename AcumulatorType = SetAccumulator<T>> class Aggregate>
 std::unique_ptr<exec::Aggregate> create(
     const TypePtr& inputType,
     const TypePtr& resultType) {
@@ -213,7 +213,7 @@ std::unique_ptr<exec::Aggregate> create(
       return std::make_unique<Aggregate<UnknownValue>>(resultType);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type {}", mapTypeKindToName(inputType->kind()));
+          "Unexpected type {}", TypeKindName::toName(inputType->kind()));
   }
 }
 
@@ -309,9 +309,10 @@ void registerSetAggAggregate(
             return std::make_unique<SetAggAggregate<UnknownValue>>(resultType);
           default:
             VELOX_UNREACHABLE(
-                "Unexpected type {}", mapTypeKindToName(typeKind));
+                "Unexpected type {}", TypeKindName::toName(typeKind));
         }
       },
+      {.ignoreDuplicates = true},
       withCompanionFunctions,
       overwrite);
 }
@@ -342,6 +343,7 @@ void registerSetUnionAggregate(
 
         return create<SetUnionAggregate>(argTypes[0]->childAt(0), resultType);
       },
+      {.ignoreDuplicates = true},
       withCompanionFunctions,
       overwrite);
 }
@@ -427,7 +429,7 @@ void registerCountDistinctAggregate(
                 resultType, argTypes[0]);
           default:
             VELOX_UNREACHABLE(
-                "Unexpected type {}", mapTypeKindToName(typeKind));
+                "Unexpected type {}", TypeKindName::toName(typeKind));
         }
       },
       withCompanionFunctions,
diff --git a/velox/functions/prestosql/aggregates/SetDigestAggregate.cpp b/velox/functions/prestosql/aggregates/SetDigestAggregate.cpp
new file mode 100644
index 000000000000..43f86d9abead
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/SetDigestAggregate.cpp
@@ -0,0 +1,594 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/expression/FunctionSignature.h"
+#include "velox/functions/lib/SetDigest.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+// SetDigest only supports int64_t and StringView as element types.
+// Template specializations ensure compile-time errors for unsupported types.
+template <typename T>
+struct SetDigestElementType;
+
+template <>
+struct SetDigestElementType<bool> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<int8_t> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<int16_t> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<int32_t> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<int64_t> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<float> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<double> {
+  using type = int64_t;
+};
+
+template <>
+struct SetDigestElementType<StringView> {
+  using type = StringView;
+};
+
+template <typename T>
+class SetDigestAggregate : public exec::Aggregate {
+ private:
+  using SetDigestAccumulator =
+      functions::SetDigest<typename SetDigestElementType<T>::type>;
+
+ public:
+  explicit SetDigestAggregate(const TypePtr& resultType)
+      : Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(SetDigestAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) SetDigestAccumulator(allocator_);
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<SetDigestAccumulator>(groups[row]);
+      clearNull(groups[row]);
+
+      auto tracker = trackRowSize(groups[row]);
+      addValueToAccumulator(accumulator, row);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows);
+
+    auto* accumulator = value<SetDigestAccumulator>(group);
+    auto tracker = trackRowSize(group);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+      addValueToAccumulator(accumulator, row);
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<SetDigestAccumulator>(groups[row]);
+      clearNull(groups[row]);
+
+      auto tracker = trackRowSize(groups[row]);
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+
+    auto* accumulator = value<SetDigestAccumulator>(group);
+    auto tracker = trackRowSize(group);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto* flatResult = (*result)->as<FlatVector<StringView>>();
+    flatResult->resize(numGroups);
+
+    // Calculate total buffer size needed for all non-inline
+    // strings.
+    int64_t totalBufferSize = 0;
+    std::vector<int32_t> sizes(numGroups);
+    for (vector_size_t i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<SetDigestAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+        sizes[i] = size;
+        if (!StringView::isInline(size)) {
+          totalBufferSize += size;
+        }
+      }
+    }
+
+    // Allocate buffer once for all non-inline strings.
+    char* rawBuffer = nullptr;
+    if (totalBufferSize > 0) {
+      rawBuffer = flatResult->getRawStringBufferWithSpace(totalBufferSize);
+    }
+
+    // Serialize into pre-allocated buffer.
+    for (vector_size_t i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        auto* accumulator = value<SetDigestAccumulator>(group);
+        auto size = sizes[i];
+
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          // For small serialized data (<= 12 bytes), use inline StringView
+          // storage to avoid heap allocation overhead.
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+          rawBuffer += size;
+        }
+        flatResult->setNoCopy(i, serialized);
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractValues(groups, numGroups, result);
+  }
+
+ protected:
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<SetDigestAccumulator>(groups);
+  }
+
+ private:
+  void addValueToAccumulator(
+      SetDigestAccumulator* accumulator,
+      vector_size_t row) {
+    if constexpr (std::is_same_v<T, StringView>) {
+      accumulator->add(decodedValue_.valueAt<StringView>(row));
+    } else if constexpr (std::is_same_v<T, float>) {
+      float val = decodedValue_.valueAt<float>(row);
+      int32_t bits;
+      std::memcpy(&bits, &val, sizeof(float));
+      accumulator->add(static_cast<int64_t>(bits));
+    } else if constexpr (std::is_same_v<T, double>) {
+      double val = decodedValue_.valueAt<double>(row);
+      int64_t bits;
+      std::memcpy(&bits, &val, sizeof(double));
+      accumulator->add(bits);
+    } else {
+      accumulator->add(static_cast<int64_t>(decodedValue_.valueAt<T>(row)));
+    }
+  }
+
+  DecodedVector decodedValue_;
+  DecodedVector decodedIntermediate_;
+};
+
+template <typename T>
+std::unique_ptr<exec::Aggregate> createSetDigestAggregate(
+    const TypePtr& resultType) {
+  return std::make_unique<SetDigestAggregate<T>>(resultType);
+}
+
+exec::AggregateRegistrationResult registerMakeSetDigest(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  // Support all common input types
+  std::vector<std::string> inputTypes = {
+      "boolean",
+      "tinyint",
+      "smallint",
+      "integer",
+      "bigint",
+      "real", // float (32-bit)
+      "double", // double (64-bit)
+      "date", // int32 days since epoch (handled by INTEGER case)
+      "varchar",
+      "varbinary",
+  };
+
+  signatures.reserve(inputTypes.size());
+  for (const auto& inputType : inputTypes) {
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("varbinary")
+            .intermediateType("varbinary")
+            .argumentType(inputType)
+            .build());
+  }
+
+  return exec::registerAggregateFunction(
+      name,
+      signatures,
+      [](core::AggregationNode::Step /*step*/,
+         const std::vector<TypePtr>& argTypes,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        const auto& inputType = argTypes[0];
+
+        switch (inputType->kind()) {
+          case TypeKind::BOOLEAN:
+            return createSetDigestAggregate<bool>(resultType);
+          case TypeKind::TINYINT:
+            return createSetDigestAggregate<int8_t>(resultType);
+          case TypeKind::SMALLINT:
+            return createSetDigestAggregate<int16_t>(resultType);
+          case TypeKind::INTEGER:
+            return createSetDigestAggregate<int32_t>(resultType);
+          case TypeKind::BIGINT:
+            return createSetDigestAggregate<int64_t>(resultType);
+          case TypeKind::REAL:
+            return createSetDigestAggregate<float>(resultType);
+          case TypeKind::DOUBLE:
+            return createSetDigestAggregate<double>(resultType);
+          case TypeKind::VARCHAR:
+          case TypeKind::VARBINARY:
+            return createSetDigestAggregate<StringView>(resultType);
+          default:
+            VELOX_UNREACHABLE(
+                "Unsupported input type for make_set_digest: {}",
+                inputType->toString());
+        }
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+void registerMakeSetDigestAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerMakeSetDigest(
+      prefix + kMakeSetDigest, withCompanionFunctions, overwrite);
+}
+
+class MergeSetDigestAggregate : public exec::Aggregate {
+ private:
+  using SetDigestAccumulator = functions::SetDigest<int64_t>;
+
+ public:
+  explicit MergeSetDigestAggregate(const TypePtr& resultType)
+      : Aggregate(resultType) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(SetDigestAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      new (groups[i] + offset_) SetDigestAccumulator(allocator_);
+    }
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<SetDigestAccumulator>(groups[row]);
+      clearNull(groups[row]);
+
+      auto tracker = trackRowSize(groups[row]);
+      auto serialized = decodedValue_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedValue_.decode(*args[0], rows);
+
+    auto* accumulator = value<SetDigestAccumulator>(group);
+    auto tracker = trackRowSize(group);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedValue_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      auto* accumulator = value<SetDigestAccumulator>(groups[row]);
+      clearNull(groups[row]);
+
+      auto tracker = trackRowSize(groups[row]);
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodedIntermediate_.decode(*args[0], rows);
+
+    auto* accumulator = value<SetDigestAccumulator>(group);
+    auto tracker = trackRowSize(group);
+
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedIntermediate_.isNullAt(row)) {
+        return;
+      }
+
+      clearNull(group);
+
+      auto serialized = decodedIntermediate_.valueAt<StringView>(row);
+
+      SetDigestAccumulator other(allocator_);
+      auto status = other.deserialize(serialized.data(), serialized.size());
+      VELOX_CHECK(
+          status.ok(), "Failed to deserialize SetDigest: {}", status.message());
+      accumulator->mergeWith(other);
+    });
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    auto* flatResult = (*result)->as<FlatVector<StringView>>();
+    flatResult->resize(numGroups);
+
+    // Calculate total buffer size needed for all non-inline
+    // strings.
+    int64_t totalBufferSize = 0;
+    std::vector<int32_t> sizes(numGroups);
+    for (vector_size_t i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<SetDigestAccumulator>(group);
+        auto size = accumulator->estimatedSerializedSize();
+        sizes[i] = size;
+        if (!StringView::isInline(size)) {
+          totalBufferSize += size;
+        }
+      }
+    }
+
+    // Allocate buffer once for all non-inline strings.
+    char* rawBuffer = nullptr;
+    if (totalBufferSize > 0) {
+      rawBuffer = flatResult->getRawStringBufferWithSpace(totalBufferSize);
+    }
+
+    // Serialize into pre-allocated buffer.
+    for (vector_size_t i = 0; i < numGroups; ++i) {
+      char* group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        auto* accumulator = value<SetDigestAccumulator>(group);
+        auto size = sizes[i];
+
+        StringView serialized;
+        if (StringView::isInline(size)) {
+          // For small serialized data (<= 12 bytes), use inline StringView
+          // storage to avoid heap allocation overhead.
+          std::string buffer(size, '\0');
+          accumulator->serialize(buffer.data());
+          serialized = StringView::makeInline(buffer);
+        } else {
+          accumulator->serialize(rawBuffer);
+          serialized = StringView(rawBuffer, size);
+          rawBuffer += size;
+        }
+        flatResult->setNoCopy(i, serialized);
+      }
+    }
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractValues(groups, numGroups, result);
+  }
+
+ protected:
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<SetDigestAccumulator>(groups);
+  }
+
+ private:
+  DecodedVector decodedValue_;
+  DecodedVector decodedIntermediate_;
+};
+
+exec::AggregateRegistrationResult registerMergeSetDigest(
+    const std::string& name,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
+
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .returnType("setdigest")
+          .intermediateType("varbinary")
+          .argumentType("setdigest")
+          .build());
+
+  return exec::registerAggregateFunction(
+      name,
+      signatures,
+      [](core::AggregationNode::Step /*step*/,
+         const std::vector<TypePtr>& /*argTypes*/,
+         const TypePtr& resultType,
+         const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        return std::make_unique<MergeSetDigestAggregate>(resultType);
+      },
+      withCompanionFunctions,
+      overwrite);
+}
+
+void registerMergeSetDigestAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions,
+    bool overwrite) {
+  registerMergeSetDigest(
+      prefix + kMergeSetDigest, withCompanionFunctions, overwrite);
+}
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SetDigestAggregate.h b/velox/functions/prestosql/aggregates/SetDigestAggregate.h
new file mode 100644
index 000000000000..ba8f269c6431
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/SetDigestAggregate.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 <string>
+
+namespace facebook::velox::aggregate::prestosql {
+
+void registerMakeSetDigestAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions = true,
+    bool overwrite = true);
+
+void registerMergeSetDigestAggregate(
+    const std::string& prefix,
+    bool withCompanionFunctions = true,
+    bool overwrite = true);
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SfmSketchAggregate.h b/velox/functions/prestosql/aggregates/SfmSketchAggregate.h
new file mode 100644
index 000000000000..7caf175903cb
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/SfmSketchAggregate.h
@@ -0,0 +1,383 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/functions/lib/sfm/SfmSketch.h"
+#include "velox/functions/lib/sfm/SfmSketchAccumulator.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::aggregate::prestosql {
+
+template <bool sketchAsFinalResult, bool indexAsInput, bool sketchAsInput>
+class SfmSketchAggregate : public exec::Aggregate {
+  // When the input is a sketch which happens in merge aggregation,
+  // we use SfmSketch as the accumulator type. Otherwise, we use
+  // SfmSketchAccumulator as the accumulator type.
+  using Accumulator = typename std::conditional<
+      sketchAsInput,
+      facebook::velox::functions::sfm::SfmSketch,
+      facebook::velox::functions::sfm::SfmSketchAccumulator>::type;
+  using SfmSketch = facebook::velox::functions::sfm::SfmSketch;
+
+ public:
+  explicit SfmSketchAggregate(TypePtr resultType)
+      : exec::Aggregate(std::move(resultType)) {}
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return static_cast<int32_t>(sizeof(Accumulator));
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(Accumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    if constexpr (sketchAsInput) {
+      addIntermediateResults(groups, rows, args, false /*unused*/);
+      return;
+    }
+    decodeInput(rows, args);
+    rows.applyToSelected([&](vector_size_t i) {
+      auto group = groups[i];
+      updateFromInput(group, i);
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    if constexpr (sketchAsInput) {
+      addSingleGroupIntermediateResults(group, rows, args, false /*unused*/);
+      return;
+    }
+    decodeInput(rows, args);
+    rows.applyToSelected([&](vector_size_t i) { updateFromInput(group, i); });
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    serializeToStringVector(
+        groups,
+        numGroups,
+        result,
+        [](const Accumulator& accumulator) -> size_t {
+          return accumulator.serializedSize();
+        },
+        [](const Accumulator& accumulator, char* buffer) -> void {
+          accumulator.serialize(buffer);
+        });
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    if constexpr (sketchAsFinalResult) {
+      // For final sketch result, serialize only the SfmSketch, not the
+      // SfmSketchAccumulator.
+      if constexpr (sketchAsInput) {
+        serializeToStringVector(
+            groups,
+            numGroups,
+            result,
+            [](const Accumulator& accumulator) -> size_t {
+              return accumulator.serializedSize();
+            },
+            [](const Accumulator& accumulator, char* buffer) -> void {
+              accumulator.serialize(buffer);
+            });
+      } else {
+        serializeToStringVector(
+            groups,
+            numGroups,
+            result,
+            [](Accumulator& accumulator) -> size_t {
+              return accumulator.sketch().serializedSize();
+            },
+            [](Accumulator& accumulator, char* buffer) -> void {
+              accumulator.sketch().serialize(buffer);
+            });
+      }
+      return;
+    }
+
+    auto flatResult = (*result)->asFlatVector<int64_t>();
+    flatResult->resize(numGroups);
+
+    for (auto i = 0; i < numGroups; i++) {
+      auto group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        auto accumulator = value<Accumulator>(group);
+        if (!accumulator->isInitialized()) {
+          flatResult->setNull(i, true);
+          continue;
+        }
+        flatResult->set(i, accumulator->cardinality());
+      }
+    }
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    DecodedVector decodedVector(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      auto group = groups[i];
+      updateFromIntermediate(decodedVector, group, i);
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      [[maybe_unused]] bool mayPushdown) override {
+    DecodedVector decodedVector(*args[0], rows);
+
+    rows.applyToSelected([&](vector_size_t i) {
+      updateFromIntermediate(decodedVector, group, i);
+    });
+  }
+
+ protected:
+  DecodedVector decodedValue_;
+  DecodedVector decodedIndex_;
+  DecodedVector decodedZeros_;
+  DecodedVector decodedEpsilon_;
+  DecodedVector decodedBuckets_;
+  DecodedVector decodedPrecision_;
+  size_t numArgs_ = 0;
+
+  void initializeNewGroupsInternal(
+      char** groups,
+      folly::Range<const vector_size_t*> indices) override {
+    setAllNulls(groups, indices);
+    for (auto i : indices) {
+      auto* group = groups[i];
+      new (value<Accumulator>(group)) Accumulator(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    destroyAccumulators<Accumulator>(groups);
+  }
+
+ private:
+  // Helper function to serialize data to StringView result.
+  template <typename SizeFunc, typename SerializeFunc>
+  void serializeToStringVector(
+      char** groups,
+      int32_t numGroups,
+      VectorPtr* result,
+      SizeFunc sizeFunc,
+      SerializeFunc serializeFunc) {
+    auto flatResult = (*result)->asFlatVector<StringView>();
+    flatResult->resize(numGroups);
+
+    // Calculate total size needed for all valid groups.
+    size_t totalSize = 0;
+    std::vector<size_t> groupSizes(numGroups, 0);
+
+    for (auto i = 0; i < numGroups; i++) {
+      auto group = groups[i];
+      if (!isNull(group)) {
+        auto* accumulator = value<Accumulator>(group);
+        if (accumulator->isInitialized()) {
+          groupSizes[i] = sizeFunc(*accumulator);
+          totalSize += groupSizes[i];
+        }
+      }
+    }
+
+    // Allocate buffer for all serializations.
+    auto rawBuffer = flatResult->getRawStringBufferWithSpace(totalSize);
+    size_t offset = 0;
+
+    for (auto i = 0; i < numGroups; i++) {
+      auto group = groups[i];
+      if (isNull(group)) {
+        flatResult->setNull(i, true);
+      } else {
+        auto* accumulator = value<Accumulator>(group);
+        if (!accumulator->isInitialized()) {
+          flatResult->setNull(i, true);
+        } else {
+          // Serialize the data.
+          serializeFunc(*accumulator, rawBuffer + offset);
+          flatResult->setNoCopy(
+              i,
+              StringView(
+                  rawBuffer + offset, static_cast<int32_t>(groupSizes[i])));
+          offset += groupSizes[i];
+        }
+      }
+    }
+  }
+
+  void decodeInput(
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) {
+    numArgs_ = args.size();
+    // This is for function noisy_approx_set_sfm_from_index_and_zeros.
+    if constexpr (indexAsInput) {
+      VELOX_CHECK_GE(numArgs_, 4);
+      decodedIndex_.decode(*args[0], rows);
+      decodedZeros_.decode(*args[1], rows);
+      decodedEpsilon_.decode(*args[2], rows);
+      decodedBuckets_.decode(*args[3], rows);
+      if (numArgs_ > 4) {
+        decodedPrecision_.decode(*args[4], rows);
+      }
+      return;
+    }
+
+    VELOX_CHECK_GE(numArgs_, 2);
+    decodedValue_.decode(*args[0], rows);
+    decodedEpsilon_.decode(*args[1], rows);
+    if (numArgs_ > 2) {
+      decodedBuckets_.decode(*args[2], rows);
+    }
+    if (numArgs_ > 3) {
+      decodedPrecision_.decode(*args[3], rows);
+    }
+  }
+
+  void updateFromInput(char* group, vector_size_t i) {
+    bool shouldProcess = indexAsInput
+        ? (!decodedIndex_.isNullAt(i) && !decodedZeros_.isNullAt(i))
+        : !decodedValue_.isNullAt(i);
+
+    if (!shouldProcess) {
+      return;
+    }
+    auto tracker = trackRowSize(group);
+    auto* accumulator = value<Accumulator>(group);
+    clearNull(group);
+
+    if constexpr (sketchAsInput) {
+      // When sketchAsInput is true, we should be using updateFromIntermediate
+      // instead of updateFromInput. This code should never be reached.
+      // This branch exists only to avoid compiler errors because compiler
+      // need to compile all combinations of template parameters.
+      VELOX_FAIL(
+          "updateFromInput should never be called with sketchAsInput=true.");
+    } else {
+      std::optional<int32_t> buckets;
+      std::optional<int32_t> precision;
+
+      if constexpr (indexAsInput) {
+        // For index input: args[3] = buckets, args[4] = precision
+        buckets = getValue(decodedBuckets_, i);
+        precision =
+            numArgs_ > 4 ? getValue(decodedPrecision_, i) : std::nullopt;
+      } else {
+        // For value input: args[2] = buckets, args[3] = precision
+        buckets = numArgs_ > 2 ? getValue(decodedBuckets_, i) : std::nullopt;
+        precision =
+            numArgs_ > 3 ? getValue(decodedPrecision_, i) : std::nullopt;
+      }
+
+      if (!accumulator->isInitialized()) {
+        accumulator->initialize(buckets, precision);
+        accumulator->setEpsilon(decodedEpsilon_.valueAt<double>(i));
+      }
+
+      if constexpr (indexAsInput) {
+        auto index = decodedIndex_.valueAt<int64_t>(i);
+        auto zeros = decodedZeros_.valueAt<int64_t>(i);
+        accumulator->addIndexAndZeros(
+            static_cast<int32_t>(index), static_cast<int32_t>(zeros));
+      } else {
+        // Handle different input types.
+        auto inputType = decodedValue_.base()->type();
+        switch (inputType->kind()) {
+          case TypeKind::BIGINT:
+            accumulator->add(decodedValue_.valueAt<int64_t>(i));
+            break;
+          case TypeKind::DOUBLE:
+            accumulator->add(decodedValue_.valueAt<double>(i));
+            break;
+          case TypeKind::VARCHAR:
+          case TypeKind::VARBINARY: {
+            auto stringValue = decodedValue_.valueAt<StringView>(i);
+            accumulator->add(stringValue);
+            break;
+          }
+          default:
+            VELOX_UNSUPPORTED(
+                "Unsupported input type for SfmSketch: {}",
+                inputType->toString());
+        }
+      }
+    }
+  }
+
+  void updateFromIntermediate(
+      DecodedVector& decodedVector,
+      char* group,
+      vector_size_t i) {
+    if (decodedVector.isNullAt(i)) {
+      return;
+    }
+    auto tracker = trackRowSize(group);
+    auto* accumulator = value<Accumulator>(group);
+    clearNull(group);
+    auto serialized = decodedVector.valueAt<StringView>(i);
+    if constexpr (sketchAsInput) {
+      auto otherAccumulator =
+          SfmSketch::deserialize(serialized.data(), allocator_);
+      if (!otherAccumulator.isInitialized()) {
+        return;
+      }
+      if (!accumulator->isInitialized()) {
+        accumulator->initialize(
+            SfmSketch::numBuckets(otherAccumulator.numIndexBits()),
+            otherAccumulator.precision());
+      }
+      accumulator->mergeWith(otherAccumulator);
+    } else {
+      auto otherAccumulator =
+          Accumulator::deserialize(serialized.data(), allocator_);
+      accumulator->mergeWith(otherAccumulator);
+    }
+  }
+
+  std::optional<int32_t> getValue(
+      const DecodedVector& vector,
+      vector_size_t index) const {
+    if (vector.isNullAt(index)) {
+      return std::nullopt;
+    }
+    return {vector.valueAt<int64_t>(index)};
+  }
+};
+
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/SumAggregate.cpp b/velox/functions/prestosql/aggregates/SumAggregate.cpp
index 009d18617333..ee79b2abe3f0 100644
--- a/velox/functions/prestosql/aggregates/SumAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/SumAggregate.cpp
@@ -55,11 +55,12 @@ exec::AggregateRegistrationResult registerSum(
         "integer",
         "bigint",
         INTERVAL_DAY_TIME()->name()}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("bigint")
-                             .intermediateType("bigint")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("bigint")
+            .intermediateType("bigint")
+            .argumentType(inputType)
+            .build());
   }
 
   return exec::registerAggregateFunction(
@@ -115,7 +116,7 @@ exec::AggregateRegistrationResult registerSum(
                 inputType->kindName());
         }
       },
-      {false /*orderSensitive*/, false /*companionFunction*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp b/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
index 196261e3c9f7..c2180d084a0f 100644
--- a/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
+++ b/velox/functions/prestosql/aggregates/SumDataSizeForStatsAggregate.cpp
@@ -191,12 +191,13 @@ void registerSumDataSizeForStatsAggregate(
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .typeVariable("T")
-                           .returnType("bigint")
-                           .intermediateType("bigint")
-                           .argumentType("T")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("T")
+          .returnType("bigint")
+          .intermediateType("bigint")
+          .argumentType("T")
+          .build());
 
   auto name = prefix + kSumDataSizeForStats;
   exec::registerAggregateFunction(
@@ -213,6 +214,7 @@ void registerSumDataSizeForStatsAggregate(
 
         return std::make_unique<SumDataSizeForStatsAggregate>(resultType);
       },
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/prestosql/aggregates/TDigestAggregate.cpp b/velox/functions/prestosql/aggregates/TDigestAggregate.cpp
new file mode 100644
index 000000000000..2e7b886b5ba0
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/TDigestAggregate.cpp
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// #include <functional>
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/functions/lib/TDigest.h"
+#include "velox/functions/prestosql/aggregates/AggregateNames.h"
+#include "velox/vector/FlatVector.h"
+
+using namespace facebook::velox::exec;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+struct TDigestAccumulator {
+  explicit TDigestAccumulator(HashStringAllocator* allocator)
+      : digest(StlAllocator<double>(allocator)) {}
+
+  double compression = 0.0;
+  facebook::velox::functions::TDigest<StlAllocator<double>> digest;
+};
+
+template <typename T>
+class TDigestAggregate : public exec::Aggregate {
+ private:
+  bool hasWeight_;
+  bool hasCompression_;
+  double compression = 0.0;
+  DecodedVector decodedValue_;
+  DecodedVector decodedWeight_;
+  DecodedVector decodedCompression_;
+
+ public:
+  TDigestAggregate(
+      bool hasWeight,
+      bool hasCompression,
+      const TypePtr& resultType)
+      : exec::Aggregate(resultType),
+        hasWeight_{hasWeight},
+        hasCompression_{hasCompression} {}
+
+  void decodeArguments(
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) {
+    size_t argIndex = 0;
+    decodedValue_.decode(*args[argIndex++], rows, true);
+    if (hasWeight_) {
+      decodedWeight_.decode(*args[argIndex++], rows, true);
+    }
+    if (hasCompression_) {
+      decodedCompression_.decode(*args[argIndex++], rows, true);
+    }
+    VELOX_CHECK_EQ(argIndex, args.size());
+  }
+
+  int32_t accumulatorFixedWidthSize() const override {
+    return sizeof(TDigestAccumulator);
+  }
+
+  int32_t accumulatorAlignmentSize() const override {
+    return alignof(TDigestAccumulator);
+  }
+
+  bool isFixedSize() const override {
+    return false;
+  }
+
+  void extractValues(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractCommon(groups, numGroups, result);
+  }
+
+  void extractAccumulators(char** groups, int32_t numGroups, VectorPtr* result)
+      override {
+    extractCommon(groups, numGroups, result);
+  }
+
+  TDigestAccumulator* getAccumulator(char* group) {
+    return value<TDigestAccumulator>(group);
+  }
+
+  void addRawInput(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodeArguments(rows, args);
+    std::vector<int16_t> positions;
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+      double value = decodedValue_.valueAt<double>(row);
+      if (std::isnan(value)) {
+        VELOX_USER_FAIL("Cannot add NaN to t-digest");
+      }
+      auto* accumulator = getAccumulator(groups[row]);
+      if (hasCompression_) {
+        checkAndSetCompression(accumulator, row);
+      }
+      if (hasWeight_) {
+        if (!decodedWeight_.isNullAt(row)) {
+          int64_t weight = decodedWeight_.valueAt<int64_t>(row);
+          VELOX_USER_CHECK_GT(weight, 0, "weight must be > 0");
+          accumulator->digest.add(positions, value, weight);
+        } else {
+          VELOX_USER_FAIL("Weight value must be greater than zero.");
+        }
+      } else {
+        accumulator->digest.add(positions, value);
+      }
+    });
+  }
+
+  void addIntermediateResults(
+      char** groups,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediate<false>(groups, rows, args);
+  }
+
+  template <bool kSingleGroup>
+  void addIntermediate(
+      std::conditional_t<kSingleGroup, char*, char**> group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args) {
+    DecodedVector decodedSerializedDigests;
+    TDigestAccumulator* accumulator = nullptr;
+    decodedSerializedDigests.decode(*args[0], rows);
+    std::vector<int16_t> positions;
+    rows.applyToSelected([&](vector_size_t row) {
+      // Skip null serialized digests
+      if (decodedSerializedDigests.isNullAt(row)) {
+        return;
+      }
+      if constexpr (kSingleGroup) {
+        if (!accumulator) {
+          accumulator = getAccumulator(group);
+        }
+      } else {
+        accumulator = getAccumulator(group[row]);
+      }
+      auto serialized =
+          decodedSerializedDigests.valueAt<facebook::velox::StringView>(row);
+      accumulator->digest.mergeDeserialized(positions, serialized.data());
+    });
+  }
+
+  void addSingleGroupRawInput(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    decodeArguments(rows, args);
+    auto* accumulator = getAccumulator(group);
+    std::vector<int16_t> positions;
+    rows.applyToSelected([&](vector_size_t row) {
+      if (decodedValue_.isNullAt(row)) {
+        return;
+      }
+      double value = decodedValue_.valueAt<double>(row);
+      if (std::isnan(value)) {
+        VELOX_USER_FAIL("Cannot add NaN to t-digest");
+      }
+      if (hasCompression_) {
+        checkAndSetCompression(accumulator, row);
+      }
+      if (hasWeight_) {
+        if (!decodedWeight_.isNullAt(row)) {
+          int64_t weight = decodedWeight_.valueAt<int64_t>(row);
+          VELOX_USER_CHECK_GT(weight, 0, "weight must be > 0");
+          accumulator->digest.add(positions, value, weight);
+        } else {
+          VELOX_USER_FAIL("Weight value must be greater than zero.");
+        }
+      } else {
+        accumulator->digest.add(positions, value);
+      }
+    });
+  }
+
+  void addSingleGroupIntermediateResults(
+      char* group,
+      const SelectivityVector& rows,
+      const std::vector<VectorPtr>& args,
+      bool /*mayPushdown*/) override {
+    addIntermediate<true>(group, rows, args);
+  }
+
+ 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_) TDigestAccumulator(allocator_);
+    }
+  }
+
+  void destroyInternal(folly::Range<char**> groups) override {
+    for (auto group : groups) {
+      if (isInitialized(group)) {
+        value<TDigestAccumulator>(group)->~TDigestAccumulator();
+      }
+    }
+  }
+
+  void checkAndSetCompression(
+      TDigestAccumulator* accumulator,
+      vector_size_t row) {
+    double compressionValue = decodedCompression_.valueAt<double>(row);
+    VELOX_USER_CHECK(
+        !std::isnan(compressionValue), "Compression factor must not be NaN.");
+    VELOX_USER_CHECK_GT(
+        compressionValue, 0, "Compression factor must be positive.");
+    VELOX_USER_CHECK_LE(
+        compressionValue, 1000, "Compression must be at most 1000");
+    // Ensure compression is at least 10.
+    compressionValue = std::max(compressionValue, 10.0);
+    // Set compression if not set
+    if (compression == 0.0) {
+      compression = compressionValue;
+    } else if (compression != compressionValue) {
+      VELOX_USER_FAIL("Compression factor must be same for all rows");
+    }
+    if (accumulator->compression == 0.0) {
+      accumulator->compression = compression;
+    } else if (accumulator->compression != compressionValue) {
+      VELOX_USER_FAIL("Compression factor must be same for all rows");
+    }
+    // Set compression at most once.
+    if (accumulator->digest.compression() != compression) {
+      accumulator->digest.setCompression(compression);
+    }
+  }
+
+  void extractCommon(char** groups, int32_t numGroups, VectorPtr* result) {
+    // If there are no groups, ensure the result vector is empty or
+    // appropriately initialized
+    if (numGroups == 0) {
+      (*result)->resize(0);
+      return;
+    }
+    auto flatResult = (*result)->asFlatVector<facebook::velox::StringView>();
+    flatResult->resize(numGroups);
+    std::vector<int16_t> positions;
+    for (int32_t i = 0; i < numGroups; ++i) {
+      auto group = groups[i];
+      if (!group) {
+        flatResult->setNull(i, true);
+        continue;
+      }
+      auto accumulator = getAccumulator(group);
+      if ((!isInitialized(group)) || accumulator->digest.size() == 0) {
+        flatResult->setNull(i, true);
+        continue;
+      }
+      accumulator->digest.compress(positions);
+      auto size = accumulator->digest.serializedByteSize();
+      facebook::velox::StringView serialized;
+      if (facebook::velox::StringView::isInline(size)) {
+        std::string buffer(size, '\0');
+        accumulator->digest.serialize(buffer.data());
+        serialized = facebook::velox::StringView::makeInline(buffer);
+      } else {
+        char* rawBuffer = flatResult->getRawStringBufferWithSpace(size);
+        accumulator->digest.serialize(rawBuffer);
+        serialized = facebook::velox::StringView(rawBuffer, size);
+      }
+      flatResult->setNoCopy(i, serialized);
+    }
+  }
+};
+} // namespace
+
+void registerTDigestAggregate(const std::string& prefix, bool overwrite) {
+  std::vector<std::shared_ptr<AggregateFunctionSignature>> signatures;
+  for (const auto& signature :
+       {AggregateFunctionSignatureBuilder()
+            .returnType("tdigest(double)")
+            .intermediateType("varbinary")
+            .argumentType("double")
+            .build(),
+        AggregateFunctionSignatureBuilder()
+            .returnType("tdigest(double)")
+            .intermediateType("varbinary")
+            .argumentType("double")
+            .argumentType("bigint")
+            .build(),
+        AggregateFunctionSignatureBuilder()
+            .returnType("tdigest(double)")
+            .intermediateType("varbinary")
+            .argumentType("double")
+            .argumentType("bigint")
+            .argumentType("double")
+            .build()}) {
+    signatures.push_back(signature);
+  }
+  auto name = prefix + kTDigestAgg;
+  exec::registerAggregateFunction(
+      name,
+      signatures,
+      [name](
+          core::AggregationNode::Step /*step*/,
+          const std::vector<TypePtr>& argTypes,
+          const TypePtr& resultTypes,
+          const core::QueryConfig& /*config*/)
+          -> std::unique_ptr<exec::Aggregate> {
+        if (argTypes.empty() || argTypes[0]->kind() != TypeKind::DOUBLE) {
+          VELOX_USER_FAIL(
+              "The first argument of {} must be of type DOUBLE", name);
+        }
+        bool hasWeight =
+            argTypes.size() >= 2 && argTypes[1]->kind() == TypeKind::BIGINT;
+        bool hasCompression =
+            argTypes.size() >= 3 && argTypes[2]->kind() == TypeKind::DOUBLE;
+        VELOX_USER_CHECK_EQ(
+            argTypes.size(),
+            1 + hasWeight + hasCompression,
+            "Wrong number of arguments passed to {}",
+            name);
+        if (hasWeight) {
+          VELOX_USER_CHECK_EQ(
+              argTypes[1]->kind(),
+              TypeKind::BIGINT,
+              "The type of the weight argument of {} must be BIGINT",
+              name);
+        }
+        if (hasCompression) {
+          VELOX_USER_CHECK_EQ(
+              argTypes[2]->kind(),
+              TypeKind::DOUBLE,
+              "The type of the compression argument of {} must be DOUBLE",
+              name);
+        }
+        return std::make_unique<TDigestAggregate<double>>(
+            hasWeight, hasCompression, resultTypes);
+      },
+      {},
+      false /*registerCompanionFunctions*/,
+      overwrite);
+}
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/VarianceAggregates.cpp b/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
index 86d58216727a..afb103197872 100644
--- a/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/VarianceAggregates.cpp
@@ -115,11 +115,12 @@ exec::AggregateRegistrationResult registerVariance(
   std::vector<std::string> inputTypes = {
       "smallint", "integer", "bigint", "real", "double"};
   for (const auto& inputType : inputTypes) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(bigint,double,double)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(bigint,double,double)")
+            .argumentType(inputType)
+            .build());
   }
 
   return exec::registerAggregateFunction(
diff --git a/velox/functions/prestosql/aggregates/benchmarks/CMakeLists.txt b/velox/functions/prestosql/aggregates/benchmarks/CMakeLists.txt
index 0112dadb919f..c903f295a1da 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/CMakeLists.txt
+++ b/velox/functions/prestosql/aggregates/benchmarks/CMakeLists.txt
@@ -25,7 +25,8 @@ target_link_libraries(
   velox_vector_test_lib
   Folly::folly
   Folly::follybenchmark
-  gflags::gflags)
+  gflags::gflags
+)
 
 add_executable(velox_aggregates_string_keys_bm TwoStringKeys.cpp)
 
@@ -41,7 +42,8 @@ target_link_libraries(
   velox_vector_test_lib
   Folly::folly
   Folly::follybenchmark
-  gflags::gflags)
+  gflags::gflags
+)
 
 add_executable(velox_aggregates_reduce_agg_bm ReduceAgg.cpp)
 
@@ -57,4 +59,5 @@ target_link_libraries(
   velox_vector_test_lib
   Folly::folly
   Folly::follybenchmark
-  gflags::gflags)
+  gflags::gflags
+)
diff --git a/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp b/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
index 2397d0f84a1d..b3b9d4796505 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
+++ b/velox/functions/prestosql/aggregates/benchmarks/ReduceAgg.cpp
@@ -190,7 +190,8 @@ class ReduceAggBenchmark : public HiveConnectorTestBase {
         std::move(plan),
         0,
         core::QueryCtx::create(executor_.get()),
-        exec::Task::ExecutionMode::kSerial);
+        exec::Task::ExecutionMode::kSerial,
+        exec::Consumer{});
 
     task->addSplit(
         "0", exec::Split(makeHiveConnectorSplit(filePath_->getPath())));
diff --git a/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp b/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
index 474051c86466..cf3ee5b47ff2 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
+++ b/velox/functions/prestosql/aggregates/benchmarks/SimpleAggregates.cpp
@@ -64,8 +64,9 @@ class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
 
       // Generate key with a small number of unique values from a small range
       // (0-16).
-      children.emplace_back(makeFlatVector<int32_t>(
-          kRowsPerVector, [](auto row) { return row % 17; }));
+      children.emplace_back(
+          makeFlatVector<int32_t>(
+              kRowsPerVector, [](auto row) { return row % 17; }));
 
       // Generate key with a small number of unique values from a large range
       // (300 total values).
@@ -165,7 +166,8 @@ class SimpleAggregatesBenchmark : public HiveConnectorTestBase {
         std::move(plan),
         0,
         core::QueryCtx::create(executor_.get()),
-        exec::Task::ExecutionMode::kSerial);
+        exec::Task::ExecutionMode::kSerial,
+        exec::Consumer{});
   }
 
  private:
diff --git a/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp b/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp
index 30e51c2f3470..835671c9534d 100644
--- a/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp
+++ b/velox/functions/prestosql/aggregates/benchmarks/TwoStringKeys.cpp
@@ -113,7 +113,8 @@ class TwoStringKeysBenchmark : public HiveConnectorTestBase {
         std::move(plan),
         0,
         core::QueryCtx::create(executor_.get()),
-        exec::Task::ExecutionMode::kSerial);
+        exec::Task::ExecutionMode::kSerial,
+        exec::Consumer{});
 
     task->addSplit(
         "0", exec::Split(makeHiveConnectorSplit((filePath_->getPath()))));
diff --git a/velox/functions/prestosql/aggregates/tests/AggregationFunctionRegTest.cpp b/velox/functions/prestosql/aggregates/tests/AggregationFunctionRegTest.cpp
index 6862e3b88622..515ce9afab11 100644
--- a/velox/functions/prestosql/aggregates/tests/AggregationFunctionRegTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/AggregationFunctionRegTest.cpp
@@ -81,7 +81,13 @@ TEST_F(AggregationFunctionRegTest, orderSensitive) {
 
   // Test some but not all order sensitive functions
   std::set<std::string> orderSensitiveFunctions = {
-      "array_agg", "arbitrary", "any_value", "map_agg", "map_union", "set_agg"};
+      "array_agg",
+      "arbitrary",
+      "any_value",
+      "map_agg",
+      "map_union",
+      "set_agg",
+      "tdigest_agg"};
   for (const auto& entry : orderSensitiveFunctions) {
     ASSERT_TRUE(exec::getAggregateFunctionMetadata(entry).orderSensitive);
   }
@@ -107,6 +113,8 @@ TEST_F(AggregationFunctionRegTest, prestoSupportedSignatures) {
   EXPECT_EQ(aggrFuncMapBase[kBitwiseOr].signatures.size(), 1);
   EXPECT_EQ(aggrFuncMapBase[kBitwiseXor].signatures.size(), 1);
 
+  EXPECT_EQ(aggrFuncMapBase[kTDigestAgg].signatures.size(), 3);
+
   // Revert to previous state.
   clearAndCheckRegistry();
 }
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
index bf9932d4292a..339952a995e2 100644
--- a/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ApproxMostFrequentTest.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/QueryConfig.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 
@@ -181,6 +183,121 @@ TEST_F(ApproxMostFrequentTestStringView, stringLifeCycle) {
       {rows, rows}, {}, {"approx_most_frequent(3, c0, 31)"}, {expected});
 }
 
+TEST_F(ApproxMostFrequentTestStringView, globalAggregationWithCompaction) {
+  // Test setup: 1024 unique strings of 1MB each = 1GB total input.
+  // With capacity=100, only 100 strings are kept at any time, so without
+  // compaction, ~924 dead strings accumulate in memory.
+  constexpr int kNumStrings = 1024;
+  constexpr int kCapacity = 100;
+  constexpr size_t kStringLen = 1 << 20; // 1MB
+  constexpr size_t kTotalInputBytes = kNumStrings * kStringLen; // 1GB
+  constexpr size_t kActiveBytes = kCapacity * kStringLen; // 100MB
+
+  // Use a smaller compaction threshold for testing.
+  constexpr uint64_t kCompactionBytes = 256UL << 20; // 256MB
+  constexpr uint64_t kMemoryLimit = 512UL << 20; // 512MB
+
+  std::vector<std::string> strings;
+  strings.reserve(kNumStrings);
+  for (int i = 0; i < kNumStrings; ++i) {
+    auto& s = strings.emplace_back(kStringLen, 'a' + (i % 26));
+    auto indexStr = folly::to<std::string>(i);
+    s.replace(kStringLen - indexStr.size(), indexStr.size(), indexStr);
+  }
+
+  auto values = makeFlatVector<StringView>(
+      kNumStrings, [&](auto row) { return StringView(strings[row]); });
+  auto rows = makeRowVector({values});
+
+  auto plan =
+      exec::test::PlanBuilder()
+          .values({rows})
+          .partialAggregation(
+              {}, {fmt::format("approx_most_frequent(10, c0, {})", kCapacity)})
+          .planNode();
+
+  struct TestSettings {
+    std::string name;
+    std::string compactionBytesConfig;
+    uint64_t memoryLimit;
+    bool expectOOM;
+    std::function<void(uint64_t)> validatePeakMemory;
+
+    std::string debugString() const {
+      return fmt::format(
+          "name: {}, compactionBytesConfig: {}, memoryLimit: {}, expectOOM: {}",
+          name,
+          compactionBytesConfig,
+          memoryLimit,
+          expectOOM);
+    }
+  };
+
+  std::vector<TestSettings> testSettings = {
+      {
+          "compaction-enabled",
+          folly::to<std::string>(kCompactionBytes),
+          kMemoryLimit,
+          false,
+          [=](uint64_t peakMemory) {
+            ASSERT_LT(peakMemory, kCompactionBytes + 2 * kActiveBytes)
+                << "With compaction enabled, peak memory should be bounded near "
+                   "compaction threshold plus active bytes";
+          },
+      },
+      {
+          "oom-without-compaction",
+          "0",
+          kMemoryLimit,
+          true,
+          nullptr,
+      },
+      {
+          "compaction-disabled-large-memory",
+          "0",
+          2UL << 30,
+          false,
+          [=](uint64_t peakMemory) {
+            // Without compaction, peak memory should exceed total input size.
+            ASSERT_GT(peakMemory, kTotalInputBytes)
+                << "Without compaction, peak memory should exceed total input "
+                   "size due to dead string accumulation";
+          },
+      },
+  };
+
+  for (const auto& testSetting : testSettings) {
+    SCOPED_TRACE(testSetting.debugString());
+
+    auto queryPool = memory::memoryManager()->addRootPool(
+        testSetting.name,
+        testSetting.memoryLimit,
+        exec::MemoryReclaimer::create());
+    auto queryCtx = core::QueryCtx::create(
+        executor_.get(), core::QueryConfig{{}}, {}, {}, std::move(queryPool));
+
+    exec::test::AssertQueryBuilder queryBuilder(plan);
+    queryBuilder.queryCtx(queryCtx);
+    if (!testSetting.compactionBytesConfig.empty()) {
+      queryBuilder.config(
+          core::QueryConfig::kAggregationCompactionBytesThreshold,
+          testSetting.compactionBytesConfig);
+    }
+
+    if (testSetting.expectOOM) {
+      VELOX_ASSERT_THROW(
+          queryBuilder.copyResults(pool()), "Exceeded memory pool capacity");
+    } else {
+      auto result = queryBuilder.copyResults(pool());
+      ASSERT_EQ(result->size(), 1);
+      ASSERT_FALSE(result->isNullAt(0));
+
+      auto peakMemory = queryCtx->pool()->peakBytes();
+      testSetting.validatePeakMemory(peakMemory);
+    }
+  }
+}
+
 class ApproxMostFrequentTestBoolean : public AggregationTestBase {
  protected:
   void SetUp() override {
diff --git a/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp b/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
index a5cb8d8adabd..b08e62e830bf 100644
--- a/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ApproxPercentileTest.cpp
@@ -102,11 +102,12 @@ class ApproxPercentileTest : public AggregationTestBase {
       double percentile,
       double accuracy,
       std::optional<T> expectedResult) {
-    SCOPED_TRACE(fmt::format(
-        "weighted={} percentile={} accuracy={}",
-        weights != nullptr,
-        percentile,
-        accuracy));
+    SCOPED_TRACE(
+        fmt::format(
+            "weighted={} percentile={} accuracy={}",
+            weights != nullptr,
+            percentile,
+            accuracy));
     auto rows =
         weights ? makeRowVector({values, weights}) : makeRowVector({values});
 
diff --git a/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp b/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
index c250870ec034..370bf0f32ec5 100644
--- a/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ArbitraryTest.cpp
@@ -352,18 +352,19 @@ TEST_F(ArbitraryTest, interval) {
 }
 
 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 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}),
@@ -379,18 +380,19 @@ TEST_F(ArbitraryTest, longDecimal) {
 }
 
 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 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}),
@@ -491,8 +493,12 @@ TEST_F(ArbitraryTest, clusteredInput) {
       }
       auto plan = builder.finalAggregation().planNode();
       for (int32_t flushRows : {0, 1}) {
-        SCOPED_TRACE(fmt::format(
-            "mask={} batchRows={} flushRows={}", mask, batchRows, flushRows));
+        SCOPED_TRACE(
+            fmt::format(
+                "mask={} batchRows={} flushRows={}",
+                mask,
+                batchRows,
+                flushRows));
         AssertQueryBuilder(plan, duckDbQueryRunner_)
             .config(core::QueryConfig::kPreferredOutputBatchRows, batchRows)
             .config(
diff --git a/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp b/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
index 76c672f74381..e16d25f85b95 100644
--- a/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/ArrayAggTest.cpp
@@ -586,8 +586,12 @@ TEST_F(ArrayAggTest, clusteredInput) {
       }
       auto plan = builder.finalAggregation().planNode();
       for (int32_t flushRows : {0, 1}) {
-        SCOPED_TRACE(fmt::format(
-            "mask={} batchRows={} flushRows={}", mask, batchRows, flushRows));
+        SCOPED_TRACE(
+            fmt::format(
+                "mask={} batchRows={} flushRows={}",
+                mask,
+                batchRows,
+                flushRows));
         AssertQueryBuilder(plan, duckDbQueryRunner_)
             .config(core::QueryConfig::kPreferredOutputBatchRows, batchRows)
             .config(
diff --git a/velox/functions/prestosql/aggregates/tests/AverageAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/AverageAggregationTest.cpp
index f00e86ba8525..04635f99f055 100644
--- a/velox/functions/prestosql/aggregates/tests/AverageAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/AverageAggregationTest.cpp
@@ -482,6 +482,24 @@ TEST_F(AverageAggregationTest, avgDecimal) {
       {makeRowVector(
           {makeFlatVector(std::vector<int64_t>{337}, DECIMAL(3, 2))})});
 
+  // Round-up average when sum overflows the max int128_t limit.
+  testAggregations(
+      {makeRowVector({makeFlatVector<int128_t>(
+          {HugeInt::parse("99999999999999999999999999999999999999"),
+           HugeInt::parse("99999999999999999999999999999999999998"),
+           HugeInt::parse("99999999999999999999999999999999999997"),
+           HugeInt::parse("99999999999999999999999999999999999995"),
+           HugeInt::parse("99999999999999999999999999999999999995"),
+           HugeInt::parse("99999999999999999999999999999999999995")},
+          DECIMAL(38, 7))})},
+      {},
+      {"avg(c0)"},
+      {},
+      {makeRowVector({makeFlatVector(
+          std::vector<int128_t>{
+              HugeInt::parse("99999999999999999999999999999999999997")},
+          DECIMAL(38, 7))})});
+
   // The total sum overflows the max int128_t limit.
   std::vector<int128_t> rawVector;
   for (int i = 0; i < 10; ++i) {
diff --git a/velox/functions/prestosql/aggregates/tests/CMakeLists.txt b/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
index 8bace7b20499..b72b9030f385 100644
--- a/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/aggregates/tests/CMakeLists.txt
@@ -33,28 +33,39 @@ add_executable(
   EntropyAggregationTest.cpp
   GeometricMeanTest.cpp
   HistogramTest.cpp
+  KHyperLogLogAggregateTest.cpp
   Main.cpp
   MapAccumulatorTest.cpp
   MapAggTest.cpp
   MapUnionAggregationTest.cpp
   MapUnionSumTest.cpp
+  NumericHistogramTest.cpp
   MaxSizeForStatsTest.cpp
   MinMaxByAggregationTest.cpp
   MinMaxTest.cpp
   MultiMapAggTest.cpp
+  NoisyCountGaussianAggregationTest.cpp
   NoisyCountIfGaussianAggregationTest.cpp
+  NoisySumGaussianAggregationTest.cpp
+  NoisyApproxSfmAggregationTest.cpp
   PrestoHasherTest.cpp
+  QDigestAggTest.cpp
   ReduceAggTest.cpp
+  ReservoirSampleTest.cpp
   SetAggTest.cpp
+  SetDigestAggregateTest.cpp
   SetUnionTest.cpp
   SumDataSizeForStatsTest.cpp
   SumTest.cpp
-  VarianceAggregationTest.cpp)
+  VarianceAggregationTest.cpp
+)
 
-add_test(
-  NAME velox_aggregates_test
-  COMMAND velox_aggregates_test
-  WORKING_DIRECTORY .)
+if(${VELOX_ENABLE_GEO})
+  target_sources(velox_aggregates_test PRIVATE GeometryAggregateTest.cpp)
+  target_link_libraries(velox_aggregates_test velox_functions_geo)
+endif()
+
+add_test(NAME velox_aggregates_test COMMAND velox_aggregates_test WORKING_DIRECTORY .)
 
 target_link_libraries(
   velox_aggregates_test
@@ -77,4 +88,5 @@ target_link_libraries(
   velox_temp_path
   gflags::gflags
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
index 1b4ca57329cf..bd5125dbd675 100644
--- a/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/CountAggregationTest.cpp
@@ -213,8 +213,9 @@ TEST_F(CountAggregationTest, distinct) {
                         {"c0"}, {fmt::format("count(distinct {})", input)})
                     .planNode();
     AssertQueryBuilder(plan, duckDbQueryRunner_)
-        .assertResults(fmt::format(
-            "SELECT c0, count(distinct {}) FROM tmp GROUP BY 1", input));
+        .assertResults(
+            fmt::format(
+                "SELECT c0, count(distinct {}) FROM tmp GROUP BY 1", input));
   };
 
   testGroupBy("c1");
diff --git a/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp b/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
index 9a6a46dcd119..b9c8e1077b4b 100644
--- a/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/GeometricMeanTest.cpp
@@ -79,9 +79,10 @@ TEST_F(GeometricMeanTest, globalIntegers) {
   });
 
   auto expected = makeRowVector({
-      makeFlatVector(std::vector<double>{
-          geometricMean<double>(1, 100, 1, [](int32_t i) { return i / 7; }),
-      }),
+      makeFlatVector(
+          std::vector<double>{
+              geometricMean<double>(1, 100, 1, [](int32_t i) { return i / 7; }),
+          }),
   });
 
   testAggregations({data}, {}, {"geometric_mean(c0)"}, {expected});
@@ -143,8 +144,9 @@ TEST_F(GeometricMeanTest, globalDoubles) {
   });
 
   auto expected = makeRowVector({
-      makeFlatVector(std::vector<double>{geometricMean<double>(
-          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});
@@ -175,8 +177,9 @@ TEST_F(GeometricMeanTest, globalReals) {
   });
 
   auto expected = makeRowVector({
-      makeFlatVector(std::vector<float>{geometricMean<float>(
-          0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
+      makeFlatVector(
+          std::vector<float>{geometricMean<float>(
+              0, 100, 1, [&](int32_t i) { return i * 0.1 / 7; })}),
   });
 
   testAggregations({data}, {}, {"geometric_mean(c0)"}, {expected});
diff --git a/velox/functions/prestosql/aggregates/tests/GeometryAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/GeometryAggregateTest.cpp
new file mode 100644
index 000000000000..2fb29206b094
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/GeometryAggregateTest.cpp
@@ -0,0 +1,442 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/PlanBuilder.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::aggregate::test {
+
+namespace {
+
+class GeometryAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+
+  void testGeometryAggregate(
+      const std::vector<std::string>& inputWkts,
+      std::string_view aggregation,
+      std::optional<std::string> outputWkt) {
+    auto data = makeRowVector({
+        makeFlatVector(inputWkts),
+    });
+
+    std::string outputSql;
+    if (outputWkt.has_value()) {
+      outputSql = fmt::format("SELECT '{}'", outputWkt.value());
+    } else {
+      outputSql = "SELECT NULL";
+    }
+
+    testAggregations(
+        [&](exec::test::PlanBuilder& builder) {
+          builder.values({data}).project({"st_geometryfromtext(c0) AS geom"});
+        },
+        {},
+        {fmt::format("{}(geom) as agg", aggregation)},
+        {"st_astext(agg)"},
+        [&](auto& builder) { return builder.assertResults(outputSql); });
+  }
+};
+
+TEST_F(GeometryAggregateTest, convexHullNoRows) {
+  testGeometryAggregate({}, "convex_hull_agg", std::nullopt);
+}
+
+TEST_F(GeometryAggregateTest, convexHullSingleEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY"}, "convex_hull_agg", "GEOMETRYCOLLECTION EMPTY");
+}
+
+TEST_F(GeometryAggregateTest, convexHullSinglePoint) {
+  testGeometryAggregate({"POINT (1 2)"}, "convex_hull_agg", "POINT (1 2)");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultiplePoints) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POINT (1 1)", "POINT (1 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultipleLinearPoints) {
+  testGeometryAggregate(
+      {"POINT (1 2)", "POINT (3 4)", "POINT (4 5)"},
+      "convex_hull_agg",
+      "LINESTRING (1 2, 4 5)");
+}
+
+TEST_F(GeometryAggregateTest, convexHullSinglePolygon) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 1 1, 1 0, 0 0), (0.5 0.5, 0.6 0.6, 0.6 0.5, 0.5 0.5))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullLineString) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 1, 2 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultipleLineStrings) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 1)", "LINESTRING (1 0, 2 1)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultiPoint) {
+  testGeometryAggregate(
+      {"MULTIPOINT (0 0, 1 1, 2 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultiLineString) {
+  testGeometryAggregate(
+      {"MULTILINESTRING ((0 0, 1 1), (1 0, 2 1))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultiPolygon) {
+  testGeometryAggregate(
+      {"MULTIPOLYGON (((0 0, 1 0, 1 1, 0 1, 0 0)), ((2 2, 3 2, 3 3, 2 3, 2 2)))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 1, 2 3, 3 3, 3 2, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullGeometryCollection) {
+  testGeometryAggregate(
+      {"GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 1), POLYGON ((3 0, 4 0, 4 1, 3 1, 3 0)))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 4 1, 4 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMixedGeometryTypes) {
+  testGeometryAggregate(
+      {"POINT (0 0)",
+       "LINESTRING (1 1, 2 1)",
+       "POLYGON ((3 0, 4 0, 4 1, 3 1, 3 0))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 4 1, 4 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullOverlappingPoints) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POINT (0 0)", "POINT (1 1)", "POINT (1 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullOverlappingPolygons) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0))",
+       "POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 2, 1 3, 3 3, 3 1, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullNonOverlappingPolygons) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))",
+       "POLYGON ((3 3, 4 3, 4 4, 3 4, 3 3))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 1, 3 4, 4 4, 4 3, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullDuplicateCoordinatesAcrossGeometries) {
+  testGeometryAggregate(
+      {"POINT (0 0)",
+       "LINESTRING (0 0, 1 1)",
+       "POLYGON ((0 0, 2 0, 1 1, 0 0))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 1 1, 2 0, 0 0))");
+}
+
+TEST_F(
+    GeometryAggregateTest,
+    convexHullDuplicateCoordinatesMultipleGeometries) {
+  testGeometryAggregate(
+      {"POINT (1 1)",
+       "POINT (1 1)",
+       "LINESTRING (1 1, 2 2)",
+       "POLYGON ((1 1, 3 1, 2 2, 1 1))"},
+      "convex_hull_agg",
+      "POLYGON ((1 1, 2 2, 3 1, 1 1))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMixedWithEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY", "POINT (1 1)", "POINT (2 2)", "POINT (1 2)"},
+      "convex_hull_agg",
+      "POLYGON ((1 1, 1 2, 2 2, 1 1))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMultipleEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY", "LINESTRING EMPTY", "POLYGON EMPTY"},
+      "convex_hull_agg",
+      "GEOMETRYCOLLECTION EMPTY");
+}
+
+TEST_F(GeometryAggregateTest, convexHullComplexGeometryCollection) {
+  testGeometryAggregate(
+      {"GEOMETRYCOLLECTION (POINT (0 0), MULTIPOINT (1 1, 2 2))",
+       "GEOMETRYCOLLECTION (LINESTRING (3 3, 4 4), POLYGON ((5 5, 6 5, 6 6, 5 6, 5 5)))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 5 6, 6 6, 6 5, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullOverlappingLineStrings) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 2 2)",
+       "LINESTRING (1 1, 3 3)",
+       "LINESTRING (0 2, 2 0)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 2, 3 3, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullNonOverlappingLineStrings) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 0)", "LINESTRING (5 5, 6 5)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 5 5, 6 5, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullAllSamePoint) {
+  testGeometryAggregate(
+      {"POINT (5 5)", "POINT (5 5)", "POINT (5 5)"},
+      "convex_hull_agg",
+      "POINT (5 5)");
+}
+
+TEST_F(GeometryAggregateTest, convexHullCollinearPoints) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POINT (1 1)", "POINT (2 2)", "POINT (3 3)"},
+      "convex_hull_agg",
+      "LINESTRING (0 0, 3 3)");
+}
+
+TEST_F(GeometryAggregateTest, convexHullMixedDimensionalGeometries) {
+  testGeometryAggregate(
+      {"POINT (0 0)",
+       "LINESTRING (1 0, 2 0)",
+       "POLYGON ((0 1, 1 2, 2 1, 0 1))"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 1, 1 2, 2 1, 2 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullNestedGeometryCollections) {
+  testGeometryAggregate(
+      {"GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (0 0), POINT (1 1)), POINT (2 2))",
+       "POINT (0 2)"},
+      "convex_hull_agg",
+      "POLYGON ((0 0, 0 2, 2 2, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullLargeCoordinates) {
+  testGeometryAggregate(
+      {"POINT (1000000 2000000)",
+       "POINT (3000000 4000000)",
+       "POINT (1000000 4000000)"},
+      "convex_hull_agg",
+      "POLYGON ((1000000 2000000, 1000000 4000000, 3000000 4000000, 1000000 2000000))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullNegativeCoordinates) {
+  testGeometryAggregate(
+      {"POINT (-1 -1)", "POINT (1 1)", "POINT (-1 1)", "POINT (1 -1)"},
+      "convex_hull_agg",
+      "POLYGON ((-1 -1, -1 1, 1 1, 1 -1, -1 -1))");
+}
+
+TEST_F(GeometryAggregateTest, convexHullDecimalCoordinates) {
+  testGeometryAggregate(
+      {"POINT (0.5 0.5)",
+       "POINT (1.5 1.5)",
+       "POINT (0.5 1.5)",
+       "POINT (1.5 0.5)"},
+      "convex_hull_agg",
+      "POLYGON ((0.5 0.5, 0.5 1.5, 1.5 1.5, 1.5 0.5, 0.5 0.5))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionNoRows) {
+  testGeometryAggregate({}, "geometry_union_agg", std::nullopt);
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionSingleEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY"}, "geometry_union_agg", "GEOMETRYCOLLECTION EMPTY");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMultipleEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY", "LINESTRING EMPTY", "POLYGON EMPTY"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION EMPTY");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionSinglePoint) {
+  testGeometryAggregate({"POINT (1 2)"}, "geometry_union_agg", "POINT (1 2)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionRepeatedPoints) {
+  testGeometryAggregate(
+      {"POINT (1 2)", "POINT (1 2)", "POINT (1 2)"},
+      "geometry_union_agg",
+      "POINT (1 2)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMultiplePoints) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POINT (1 1)", "POINT (2 0)"},
+      "geometry_union_agg",
+      "MULTIPOINT (0 0, 1 1, 2 0)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionRepeatedGeometries) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))",
+       "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0)))"},
+      "geometry_union_agg",
+      "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionOverlappingPolygons) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 0 2, 2 2, 2 0, 0 0))",
+       "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"},
+      "geometry_union_agg",
+      "POLYGON ((0 2, 1 2, 1 3, 3 3, 3 1, 2 1, 2 0, 0 0, 0 2))"
+
+  );
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedDimensionsPointLine) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "LINESTRING (1 1, 2 2)"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 2))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedDimensionsPointPolygon) {
+  testGeometryAggregate(
+      {"POINT (0 0)", "POLYGON ((1 1, 2 1, 2 2, 1 2, 1 1))"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (POINT (0 0), POLYGON ((1 1, 1 2, 2 2, 2 1, 1 1)))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedDimensionsLinePolygon) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 1)", "POLYGON ((2 2, 3 2, 3 3, 2 3, 2 2))"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedDimensionsAll) {
+  testGeometryAggregate(
+      {"POINT (0 0)",
+       "LINESTRING (1 1, 2 2)",
+       "POLYGON ((3 3, 4 3, 4 4, 3 4, 3 3))"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 2), POLYGON ((3 3, 3 4, 4 4, 4 3, 3 3)))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMixedWithEmpty) {
+  testGeometryAggregate(
+      {"POINT EMPTY", "POINT (1 1)", "POINT (2 2)"},
+      "geometry_union_agg",
+      "MULTIPOINT (1 1, 2 2)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionLineStrings) {
+  testGeometryAggregate(
+      {"LINESTRING (0 0, 1 1)", "LINESTRING (1 1, 2 2)"},
+      "geometry_union_agg",
+      "MULTILINESTRING ((0 0, 1 1), (1 1, 2 2))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionAdjacentPolygons) {
+  testGeometryAggregate(
+      {"POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))",
+       "POLYGON ((1 0, 2 0, 2 1, 1 1, 1 0))"},
+      "geometry_union_agg",
+      "POLYGON ((0 1, 1 1, 2 1, 2 0, 1 0, 0 0, 0 1))"
+
+  );
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMultiPoint) {
+  testGeometryAggregate(
+      {"MULTIPOINT (0 0, 1 1)", "POINT (2 2)"},
+      "geometry_union_agg",
+      "MULTIPOINT (0 0, 1 1, 2 2)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionMultiLineString) {
+  testGeometryAggregate(
+      {"MULTILINESTRING ((0 0, 1 1), (2 2, 3 3))", "LINESTRING (4 4, 5 5)"},
+      "geometry_union_agg",
+      "MULTILINESTRING ((0 0, 1 1), (2 2, 3 3), (4 4, 5 5))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionGeometryCollection) {
+  testGeometryAggregate(
+      {"GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 2))"},
+      "geometry_union_agg",
+      "GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (1 1, 2 2))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionPointInsidePolygon) {
+  testGeometryAggregate(
+      {"POINT (0.5 0.5)", "POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))"},
+      "geometry_union_agg",
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionLineInsidePolygon) {
+  testGeometryAggregate(
+      {"LINESTRING (0.2 0.5, 0.8 0.5)", "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))"},
+      "geometry_union_agg",
+      "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))"
+
+  );
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionNegativeCoordinates) {
+  testGeometryAggregate(
+      {"POINT (-1 -1)", "POINT (1 1)"},
+      "geometry_union_agg",
+      "MULTIPOINT (-1 -1, 1 1)");
+}
+
+TEST_F(GeometryAggregateTest, geometryUnionDecimalCoordinates) {
+  testGeometryAggregate(
+      {"POINT (0.5 0.5)", "POINT (1.5 1.5)"},
+      "geometry_union_agg",
+      "MULTIPOINT (0.5 0.5, 1.5 1.5)");
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/KHyperLogLogAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/KHyperLogLogAggregateTest.cpp
new file mode 100644
index 000000000000..02a62431dad8
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/KHyperLogLogAggregateTest.cpp
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <map>
+
+#include "velox/common/hyperloglog/KHyperLogLog.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+using namespace facebook::velox::memory;
+
+namespace facebook::velox::aggregate::test {
+namespace {
+class KHyperLogLogAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerKHyperLogLogType();
+    // Disable tests which do raw binary comparison.
+    disableTestStreaming();
+    disableTestIncremental();
+    pool_ = facebook::velox::memory::memoryManager()->addLeafPool();
+    hsa_ = std::make_unique<HashStringAllocator>(pool_.get());
+    allocator_ = hsa_.get();
+  }
+  void TearDown() override {
+    // Clean up allocator before pool.
+    hsa_.reset();
+    pool_.reset();
+    AggregationTestBase::TearDown();
+  }
+
+  // Helper to create KHLL with test data
+  std::string createKHLL(
+      const std::vector<int64_t>& values,
+      const std::vector<int64_t>& uiis) {
+    EXPECT_EQ(values.size(), uiis.size());
+    auto khll = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(allocator_);
+
+    for (size_t i = 0; i < values.size(); ++i) {
+      khll->add(values[i], uiis[i]);
+    }
+
+    std::string serialized(khll->estimatedSerializedSize(), '\0');
+    khll->serialize(serialized.data());
+    return serialized;
+  }
+
+  // Extract cardinality from KHLL varbinary.
+  int64_t getCardinality(const StringView& khllData) {
+    auto khll = common::hll::KHyperLogLog<int32_t, MemoryPool>::deserialize(
+        khllData.data(), khllData.size(), pool_.get());
+    VELOX_CHECK(!khll.hasError());
+    return khll.value()->cardinality();
+  }
+
+  // Helper to verify aggregation results have expected cardinalities.
+  // Uses testAggregations with a custom assert function to test all
+  // aggregation plan paths.
+  void testAggregationWithCardinality(
+      const std::vector<RowVectorPtr>& data,
+      const std::vector<std::string>& groupingKeys,
+      const std::vector<std::string>& aggregates,
+      const std::map<int32_t, int64_t>& keysToExpectedCardinalities) {
+    testAggregations(
+        [&](PlanBuilder& builder) { builder.values(data); },
+        groupingKeys,
+        aggregates,
+        {},
+        [&](AssertQueryBuilder& builder) {
+          std::shared_ptr<exec::Task> task;
+          auto result = builder.copyResults(pool_.get(), task);
+          EXPECT_EQ(result->size(), keysToExpectedCardinalities.size());
+
+          if (groupingKeys.empty()) {
+            // Global aggregation - single row result
+            EXPECT_EQ(keysToExpectedCardinalities.size(), 1);
+            auto expectedCardinality =
+                keysToExpectedCardinalities.begin()->second;
+
+            auto khllVector = result->childAt(0)->as<FlatVector<StringView>>();
+            EXPECT_EQ(
+                getCardinality(khllVector->valueAt(0)), expectedCardinality);
+          } else {
+            // Group-by aggregation - map keys to cardinalities
+            auto khllVector = result->childAt(groupingKeys.size())
+                                  ->as<FlatVector<StringView>>();
+            auto keyVector = result->childAt(0)->as<FlatVector<int32_t>>();
+
+            // Build map of key -> actual cardinality
+            std::map<int32_t, int64_t> actualCardinalities;
+            for (size_t i = 0; i < result->size(); ++i) {
+              int32_t key = keyVector->valueAt(i);
+              if (!khllVector->isNullAt(i)) {
+                actualCardinalities[key] =
+                    getCardinality(khllVector->valueAt(i));
+              }
+            }
+
+            // Verify each key has expected cardinality
+            for (const auto& [key, expectedCardinality] :
+                 keysToExpectedCardinalities) {
+              auto it = actualCardinalities.find(key);
+              EXPECT_TRUE(it != actualCardinalities.end())
+                  << "Missing result for key " << key;
+              EXPECT_EQ(it->second, expectedCardinality)
+                  << "Cardinality mismatch for key " << key;
+            }
+          }
+          return task;
+        });
+  }
+
+ protected:
+  std::shared_ptr<MemoryPool> pool_;
+  std::unique_ptr<HashStringAllocator> hsa_;
+  HashStringAllocator* allocator_{};
+};
+
+TEST_F(KHyperLogLogAggregateTest, globalAggIntegers) {
+  vector_size_t size = 1'000;
+  auto values =
+      makeFlatVector<int64_t>(size, [](auto row) { return row % 17; });
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 17}});
+
+  // Test high cardinality
+  values = makeFlatVector<int64_t>(size, [](auto row) { return row; });
+  uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 1000}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggIntegersWithNulls) {
+  testAggregationWithCardinality(
+      {makeRowVector({
+          makeNullableFlatVector<int64_t>({1, 2, std::nullopt, 4, 5}),
+          makeNullableFlatVector<int64_t>({10, 10, 20, std::nullopt, 30}),
+      })},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 3}});
+
+  // All nulls
+  auto expected = makeRowVector({makeNullConstant(TypeKind::VARBINARY, 1)});
+  testAggregations(
+      {makeRowVector({
+          makeNullableFlatVector<int64_t>(
+              {std::nullopt, std::nullopt, std::nullopt}),
+          makeNullableFlatVector<int64_t>(
+              {std::nullopt, std::nullopt, std::nullopt}),
+      })},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {expected});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggStrings) {
+  vector_size_t size = 1'000;
+  static const std::vector<std::string> kFruits = {
+      "apple",
+      "banana",
+      "cherry",
+      "unknown fruit with a long name",
+      "watermelon"};
+
+  auto values = makeFlatVector<StringView>(size, [&](auto row) {
+    return StringView(kFruits[row % kFruits.size()]);
+  });
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, static_cast<int64_t>(kFruits.size())}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggVarbinary) {
+  vector_size_t size = 1'000;
+  static const std::vector<std::string> kFruits = {
+      "apple", "banana", "unknown fruit with a long name", "watermelon"};
+
+  auto values = makeFlatVector<std::string>(
+      size,
+      [&](auto row) { return kFruits[row % kFruits.size()]; },
+      nullptr,
+      VARBINARY());
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, static_cast<int64_t>(kFruits.size())}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggTimeStamp) {
+  auto data = makeFlatVector<Timestamp>(
+      1'000, [](auto row) { return Timestamp::fromMillis(row); });
+  auto uii = makeFlatVector<int64_t>(1'000, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({data, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 1000}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, globalAggBoolean) {
+  vector_size_t size = 2'000;
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  auto values =
+      makeFlatVector<bool>(size, [](auto row) { return row % 2 == 0; });
+  testAggregationWithCardinality(
+      {makeRowVector({values, uii})},
+      {},
+      {"khyperloglog_agg(c0, c1)"},
+      {{0, 2}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, groupByIntegers) {
+  vector_size_t size = 1'000;
+  auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 2; });
+  auto values = makeFlatVector<int64_t>(
+      size, [](auto row) { return row % 2 == 0 ? row % 17 : row % 23; });
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({keys, values, uii})},
+      {"c0"},
+      {"khyperloglog_agg(c1, c2)"},
+      {{0, 17}, {1, 23}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, groupByHighCardinalityIntegers) {
+  vector_size_t size = 1'000;
+  auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 2; });
+  auto values = makeFlatVector<int64_t>(size, [](auto row) { return row; });
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  testAggregationWithCardinality(
+      {makeRowVector({keys, values, uii})},
+      {"c0"},
+      {"khyperloglog_agg(c1, c2)"},
+      {{0, 500}, {1, 500}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, groupByAllNulls) {
+  vector_size_t size = 1'000;
+  auto keys = makeFlatVector<int32_t>(size, [](auto row) { return row % 2; });
+  auto values = makeFlatVector<int32_t>(
+      size, [](auto row) { return row % 2 == 0 ? 27 : row % 3; }, nullEvery(2));
+  auto uii = makeFlatVector<int64_t>(size, [](auto /*row*/) { return 1; });
+
+  auto vectors = makeRowVector({keys, values, uii});
+
+  // When a group has all nulls, khyperloglog_agg returns NULL, not KHLL with
+  // cardinality 0
+  auto result = AssertQueryBuilder(
+                    PlanBuilder()
+                        .values({vectors})
+                        .singleAggregation({"c0"}, {"khyperloglog_agg(c1, c2)"})
+                        .planNode())
+                    .copyResults(pool_.get());
+
+  ASSERT_EQ(result->size(), 2);
+  auto khllVector = result->childAt(1)->as<FlatVector<StringView>>();
+
+  // At group 0, all values are null, so result is NULL.
+  ASSERT_TRUE(khllVector->isNullAt(0));
+
+  // Group 1 should have (0, 1, 2)
+  ASSERT_FALSE(khllVector->isNullAt(1));
+  EXPECT_EQ(getCardinality(khllVector->valueAt(1)), 3);
+}
+
+TEST_F(KHyperLogLogAggregateTest, mergeKHyperLogLog) {
+  // Create two separate KHLL sketches
+  auto khll1 = createKHLL({1, 2, 3, 4, 5}, {1, 1, 1, 1, 1});
+  auto khll2 = createKHLL({6, 7, 8, 9, 10}, {1, 1, 1, 1, 1});
+
+  auto khllData = makeFlatVector<StringView>(
+      {StringView(khll1), StringView(khll2)}, KHYPERLOGLOG());
+
+  // Merge the two sketches - should have cardinality 10
+  testAggregationWithCardinality(
+      {makeRowVector({khllData})}, {}, {"merge(c0)"}, {{0, 10}});
+}
+
+TEST_F(KHyperLogLogAggregateTest, mergeToIntermediate) {
+  constexpr int kSize = 1000;
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(kSize, folly::identity),
+      makeFlatVector<int64_t>(kSize, [](auto /*row*/) { return 1; }),
+      makeFlatVector<int64_t>(kSize, [](auto /*row*/) { return 1; }),
+  });
+
+  // Create KHLL sketches per group
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .singleAggregation({"c0"}, {"khyperloglog_agg(c1, c2)"})
+                  .planNode();
+
+  auto digests = split(AssertQueryBuilder(plan).copyResults(pool()), 2);
+
+  // Merge the split digests - each group should still have cardinality 1
+  std::map<int32_t, int64_t> expectedCardinalities;
+  for (int32_t i = 0; i < kSize; ++i) {
+    expectedCardinalities[i] = 1;
+  }
+  testAggregationWithCardinality(
+      digests, {"c0"}, {"merge(a0)"}, expectedCardinalities);
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/MergeAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/MergeAggregateTest.cpp
index f010fcf151a9..45af8efd0796 100644
--- a/velox/functions/prestosql/aggregates/tests/MergeAggregateTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MergeAggregateTest.cpp
@@ -14,24 +14,32 @@
  * limitations under the License.
  */
 #include <folly/base64.h>
-
 #include "velox/core/Expressions.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/QuantileDigest.h"
 #include "velox/functions/lib/TDigest.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/lib/sfm/SfmSketch.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SfmSketchRegistration.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
 #include "velox/functions/prestosql/types/TDigestRegistration.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
 
 using namespace facebook::velox::exec;
 using namespace facebook::velox::exec::test;
 using namespace facebook::velox::functions::aggregate::test;
+using namespace facebook::velox::functions::qdigest;
+using SfmSketchIn = facebook::velox::functions::sfm::SfmSketch;
 
 namespace facebook::velox::aggregate::test {
 namespace {
 
 class MergeAggregateTest : public AggregationTestBase {
  protected:
-  static const std::vector<double> kQuantiles;
+  // Helper Methods for TDigest and QDigest
+  static const std::vector<double> kTDigestQuantiles;
 
   facebook::velox::functions::TDigest<> createTDigest(const char* inputData) {
     facebook::velox::functions::TDigest<> tdigest;
@@ -41,7 +49,7 @@ class MergeAggregateTest : public AggregationTestBase {
     return tdigest;
   }
 
-  // Helper function to check TDigest equality similar to Java's
+  // Function to check TDigest equality similar to Java's
   // TDIGEST_EQUALITY
   bool tdigestEquals(
       const std::string& actualBase64,
@@ -64,7 +72,7 @@ class MergeAggregateTest : public AggregationTestBase {
         createTDigest(expectedBinary.data());
 
     // Compare quantiles
-    for (double quantile : kQuantiles) {
+    for (double quantile : kTDigestQuantiles) {
       double actualQuantile = actual.estimateQuantile(quantile);
       double expectedQuantile = expected.estimateQuantile(quantile);
       double tolerance = std::max(1.0, std::abs(actualQuantile * 0.01));
@@ -83,11 +91,97 @@ class MergeAggregateTest : public AggregationTestBase {
         actual.min() == expected.min() && actual.max() == expected.max() &&
         actual.compression() == expected.compression();
   }
+
+  template <typename T>
+  facebook::velox::functions::qdigest::QuantileDigest<T, std::allocator<T>>
+  createQDigest(const char* inputData) {
+    if (inputData == nullptr || *inputData == '\0') {
+      // Use uninitialized max error, if empty input data
+      return facebook::velox::functions::qdigest::
+          QuantileDigest<T, std::allocator<T>>(
+              std::allocator<T>(),
+              facebook::velox::functions::qdigest::kUninitializedMaxError);
+    }
+    return facebook::velox::functions::qdigest::
+        QuantileDigest<T, std::allocator<T>>(std::allocator<T>(), inputData);
+  }
+
+  // Function to check QDigest equality
+  template <typename T>
+  bool qdigestEquals(
+      const std::string& actualBase64,
+      const std::string& expectedBase64) {
+    if (actualBase64.empty() && expectedBase64.empty()) {
+      return true;
+    }
+    if (actualBase64.empty() || expectedBase64.empty()) {
+      return false;
+    }
+    auto actualBinary = folly::base64Decode(actualBase64);
+    auto expectedBinary = folly::base64Decode(expectedBase64);
+    // Create QDigest objects
+    auto actual = createQDigest<T>(actualBinary.data());
+    auto expected = createQDigest<T>(expectedBinary.data());
+    // Use same quantiles as in QuantileDigestTestBase
+    const double quantiles[] = {
+        0.0001, 0.0200, 0.0300, 0.04000, 0.0500, 0.1000, 0.2000,
+        0.3000, 0.4000, 0.5000, 0.6000,  0.7000, 0.8000, 0.9000,
+        0.9500, 0.9600, 0.9700, 0.9800,  0.9999,
+    };
+    // Compare value at quantiles
+    const double epsilon = 0.00001;
+    for (auto q : quantiles) {
+      auto actualValue = actual.estimateQuantile(q);
+      auto expectedValue = expected.estimateQuantile(q);
+      // Use double to avoid overflow
+      double absExpected = std::abs(static_cast<double>(expectedValue));
+      if (absExpected > 1e-6) {
+        double relativeError = std::abs(
+            static_cast<double>(actualValue - expectedValue) / expectedValue);
+        if (relativeError > epsilon) {
+          return false;
+        }
+      } else {
+        if (std::abs(static_cast<double>(actualValue - expectedValue)) >
+            epsilon) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  // Helper Methods for both types
+  template <typename T>
+  core::PlanNodePtr createMergePlan(
+      const RowVectorPtr& input,
+      const TypePtr& digestType) {
+    auto fieldAccess =
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
+    auto fromBase64 = std::make_shared<core::CallTypedExpr>(
+        VARBINARY(), "from_base64", fieldAccess);
+    auto castToDigest =
+        std::make_shared<core::CastTypedExpr>(digestType, fromBase64, true);
+    auto aggResultAccess =
+        std::make_shared<core::FieldAccessTypedExpr>(digestType, "a0");
+    auto castToVarbinary = std::make_shared<core::CastTypedExpr>(
+        VARBINARY(), aggResultAccess, true);
+    auto toBase64 = std::make_shared<core::CallTypedExpr>(
+        VARCHAR(), "to_base64", castToVarbinary);
+
+    return PlanBuilder()
+        .values({input})
+        .projectExpressions({castToDigest})
+        .singleAggregation({}, {"merge(p0)"})
+        .projectExpressions({toBase64})
+        .planNode();
+  }
 };
 
-const std::vector<double> MergeAggregateTest::kQuantiles =
+const std::vector<double> MergeAggregateTest::kTDigestQuantiles =
     {0.01, 0.05, 0.1, 0.25, 0.50, 0.75, 0.9, 0.95, 0.99};
 
+// TDigest merge tests
 TEST_F(MergeAggregateTest, mergeTDigestMatchJava) {
   registerTDigestType();
   // Base64-encoded TDigests from Presto Java
@@ -97,33 +191,19 @@ TEST_F(MergeAggregateTest, mergeTDigestMatchJava) {
   // TDigest: values 51.0 - 100.0
   const std::string kTDigest2 =
       "AQAAAAAAAIBJQAAAAAAAAFlAAAAAAAB+rUAAAAAAAABZQAAAAAAAAElAJgAAAAAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAIBJQAAAAAAAAEpAAAAAAACASkAAAAAAAABLQAAAAAAAgEtAAAAAAAAATEAAAAAAAIBMQAAAAAAAAE1AAAAAAACATUAAAAAAAABOQAAAAAAAgE5AAAAAAAAAT0AAAAAAAIBPQAAAAAAAIFBAAAAAAACgUEAAAAAAACBRQAAAAAAAoFFAAAAAAAAgUkAAAAAAAKBSQAAAAAAAIFNAAAAAAACgU0AAAAAAACBUQAAAAAAAoFRAAAAAAAAgVUAAAAAAAKBVQAAAAAAAAFZAAAAAAABAVkAAAAAAAIBWQAAAAAAAwFZAAAAAAAAAV0AAAAAAAEBXQAAAAAAAgFdAAAAAAADAV0AAAAAAAABYQAAAAAAAQFhAAAAAAACAWEAAAAAAAMBYQAAAAAAAAFlA";
+
   // Create TDigest vectors from base64 strings
   auto tdigestData = makeFlatVector<std::string>({kTDigest1, kTDigest2});
-  // Create plan. Project expressions is used instead as DuckDB does not
-  // recognize tdigest(double) in a projection string.
-  std::vector<core::TypedExprPtr> projectExprs;
-  auto fieldAccess =
-      std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
-  auto fromBase64 = std::make_shared<core::CallTypedExpr>(
-      VARBINARY(), std::vector<core::TypedExprPtr>{fieldAccess}, "from_base64");
-  auto castToTDigest = std::make_shared<core::CastTypedExpr>(
-      TDIGEST(DOUBLE()), fromBase64, true);
-  auto aggResultAccess =
-      std::make_shared<core::FieldAccessTypedExpr>(TDIGEST(DOUBLE()), "a0");
-  auto castToVarbinary =
-      std::make_shared<core::CastTypedExpr>(VARBINARY(), aggResultAccess, true);
-  auto toBase64 = std::make_shared<core::CallTypedExpr>(
-      VARCHAR(), std::vector<core::TypedExprPtr>{castToVarbinary}, "to_base64");
-  auto op = PlanBuilder()
-                .values({makeRowVector({tdigestData})})
-                .projectExpressions({castToTDigest})
-                .singleAggregation({}, {"merge(p0)"})
-                .projectExpressions({toBase64})
-                .planNode();
+
+  // Create plan and execute
+  auto op =
+      createMergePlan<double>(makeRowVector({tdigestData}), TDIGEST(DOUBLE()));
   auto result = readSingleValue(op);
+
   // Expected merged TDigest base64 string from Java
   const std::string expectedMergedTDigest =
       "AQAAAAAAAADwPwAAAAAAAFlAAAAAAAC6s0AAAAAAAABZQAAAAAAAAFlAKgAAAAAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAACEAAAAAAAAAIQAAAAAAAABBAAAAAAAAAEEAAAAAAAAAUQAAAAAAAABRAAAAAAAAAFEAAAAAAAAAUQAAAAAAAABRAAAAAAAAAFEAAAAAAAAAUQAAAAAAAABRAAAAAAAAAEEAAAAAAAAAQQAAAAAAAAAhAAAAAAAAACEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAAAEAAAAAAAAAIQAAAAAAAABBAAAAAAAAAFEAAAAAAAAAYQAAAAAAAABxAAAAAAAAAIEAAAAAAAAAiQAAAAAAAACRAAAAAAAAAJ0AAAAAAAAArQAAAAAAAAC9AAAAAAAAAMkAAAAAAAAA1QAAAAAAAgDhAAAAAAACAPEAAAAAAAIBAQAAAAAAAAENAAAAAAACARUAAAAAAAABIQAAAAAAAgEpAAAAAAAAATUAAAAAAAIBPQAAAAAAAAFFAAAAAAAAgUkAAAAAAACBTQAAAAAAAAFRAAAAAAADAVEAAAAAAAGBVQAAAAAAA4FVAAAAAAABgVkAAAAAAAMBWQAAAAAAAAFdAAAAAAABAV0AAAAAAAIBXQAAAAAAAwFdAAAAAAAAAWEAAAAAAAEBYQAAAAAAAgFhAAAAAAADAWEAAAAAAAABZQA==";
+
   ASSERT_TRUE(
       tdigestEquals(result.value<TypeKind::VARCHAR>(), expectedMergedTDigest));
 }
@@ -136,35 +216,179 @@ TEST_F(MergeAggregateTest, mergeTDigestOneNullMatchJava) {
       "AQAAAAAAAADwPwAAAAAAAAhAAAAAAAAAGEAAAAAAAABZQAAAAAAAAAhAAwAAAAAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAAAEAAAAAAAAAIQA==";
   // Null TDigest
   const std::string kTDigest2;
+
   // Create TDigest vectors from base64 strings
   auto tdigestData = makeFlatVector<std::string>({kTDigest1, kTDigest2});
-  // Create plan. Project expressions is used instead as DuckDB does not
-  // recognize tdigest(double) in a projection string.
-  std::vector<core::TypedExprPtr> projectExprs;
-  auto fieldAccess =
-      std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
-  auto fromBase64 = std::make_shared<core::CallTypedExpr>(
-      VARBINARY(), std::vector<core::TypedExprPtr>{fieldAccess}, "from_base64");
-  auto castToTDigest = std::make_shared<core::CastTypedExpr>(
-      TDIGEST(DOUBLE()), fromBase64, true);
-  auto aggResultAccess =
-      std::make_shared<core::FieldAccessTypedExpr>(TDIGEST(DOUBLE()), "a0");
-  auto castToVarbinary =
-      std::make_shared<core::CastTypedExpr>(VARBINARY(), aggResultAccess, true);
-  auto toBase64 = std::make_shared<core::CallTypedExpr>(
-      VARCHAR(), std::vector<core::TypedExprPtr>{castToVarbinary}, "to_base64");
-  auto op = PlanBuilder()
-                .values({makeRowVector({tdigestData})})
-                .projectExpressions({castToTDigest})
-                .singleAggregation({}, {"merge(p0)"})
-                .projectExpressions({toBase64})
-                .planNode();
+
+  // Create plan and execute
+  auto op =
+      createMergePlan<double>(makeRowVector({tdigestData}), TDIGEST(DOUBLE()));
   auto result = readSingleValue(op);
+
   // Expected merged TDigest base64 string from Java
   const std::string expectedMergedTDigest =
       "AQAAAAAAAADwPwAAAAAAAAhAAAAAAAAAGEAAAAAAAABZQAAAAAAAAAhAAwAAAAAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAAAEAAAAAAAAAIQA==";
+
   ASSERT_TRUE(
       tdigestEquals(result.value<TypeKind::VARCHAR>(), expectedMergedTDigest));
 }
+
+// QDigest merge tests
+TEST_F(MergeAggregateTest, mergeQDigestDoubleMatchJava) {
+  registerQDigestType();
+  // Base64-encoded QDigests from Presto Java
+  // QDigest: values 1 to 50
+  const std::string kQDigest1 =
+      "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";
+  // QDigest: values 51 to 100
+  const std::string kQDigest2 =
+      "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";
+
+  // Create QDigest vectors from base64 strings
+  auto qdigestData = makeFlatVector<std::string>({kQDigest1, kQDigest2});
+
+  // Create plan and execute
+  auto op =
+      createMergePlan<double>(makeRowVector({qdigestData}), QDIGEST(DOUBLE()));
+  auto result = readSingleValue(op);
+
+  const std::string expectedMergedQDigest =
+      "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";
+
+  ASSERT_TRUE(
+      qdigestEquals<double>(
+          result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
+}
+
+TEST_F(MergeAggregateTest, mergeQDigestBigIntMatchJava) {
+  registerQDigestType();
+  // Base64-encoded QDigests from Presto Java
+  // QDigest: values 1 to 50
+  const std::string kQDigest1 =
+      "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAMgAAAAAAAAASAAAAAAAAAAAAABBABAAAAAAAAIAAAAAAAAAAEEAMAAAAAAAAgA8AAAAAAAAUQAEAAAAAAACAAAAAAAAAABBAEAAAAAAAAIAAAAAAAAAAEEAUAAAAAAAAgAsAAAAAAAAAABAAAAAAAACAAAAAAAAAAAhAGQAAAAAAAIAAAAAAAAAAEEAcAAAAAAAAgAsAAAAAAAAAABkAAAAAAACADwAAAAAAAAAAEAAAAAAAAIATAAAAAAAACEABAAAAAAAAgAAAAAAAAAAQQCAAAAAAAACAAAAAAAAAABBAJAAAAAAAAIALAAAAAAAAAAAgAAAAAAAAgA0AAAAAAAAUQCAAAAAAAACAAAAAAAAAAPA/MgAAAAAAAIATAAAAAAAAFEAgAAAAAAAAgBcAAAAAAAAAAAEAAAAAAACA";
+  // QDigest: values 51 to 100
+  const std::string kQDigest2 =
+      "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAADMAAAAAAAAAZAAAAAAAAAARAAAAAAAAAAAAABBAOAAAAAAAAIAAAAAAAAAAAEA+AAAAAAAAgAsAAAAAAAAAADgAAAAAAACADgAAAAAAABBAMwAAAAAAAIAAAAAAAAAAEEBEAAAAAAAAgAAAAAAAAAAQQEgAAAAAAACAAAAAAAAAABBATAAAAAAAAIALAAAAAAAAAABIAAAAAAAAgA8AAAAAAAAIQEAAAAAAAACAAAAAAAAAABBAUAAAAAAAAIAAAAAAAAAAEEBUAAAAAAAAgAsAAAAAAAAAAFAAAAAAAACAAAAAAAAAABRAWwAAAAAAAIAPAAAAAAAACEBQAAAAAAAAgBMAAAAAAAAAAEAAAAAAAACAFQAAAAAAABRAQAAAAAAAAIAbAAAAAAAAEEAzAAAAAAAAgA==";
+
+  // Create QDigest vectors from base64 strings
+  auto qdigestData = makeFlatVector<std::string>({kQDigest1, kQDigest2});
+
+  // Create plan and execute
+  auto op =
+      createMergePlan<int64_t>(makeRowVector({qdigestData}), QDIGEST(BIGINT()));
+  auto result = readSingleValue(op);
+
+  // Expected merged QDigest base64 string from Java
+  const std::string expectedMergedQDigest =
+      "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAZAAAAAAAAAATAAAAAAAAAAAAABBABAAAAAAAAIAAAAAAAAAAEEAMAAAAAAAAgA8AAAAAAAAUQAEAAAAAAACAAAAAAAAAACBAEAAAAAAAAIANAAAAAAAAHEAQAAAAAAAAgBMAAAAAAAAAAAEAAAAAAACAAAAAAAAAACBAIAAAAAAAAIANAAAAAAAAFEAgAAAAAAAAgAAAAAAAAAAcQDkAAAAAAACADgAAAAAAABxAMgAAAAAAAIATAAAAAAAAAAAgAAAAAAAAgBcAAAAAAAAAAAEAAAAAAACAAAAAAAAAACBAQAAAAAAAAIAAAAAAAAAAIEBIAAAAAAAAgA8AAAAAAAAAAEAAAAAAAACAEQAAAAAAABxAQAAAAAAAAIAAAAAAAAAAEEBhAAAAAAAAgBcAAAAAAAAiQEAAAAAAAACAGwAAAAAAACJAAQAAAAAAAIA=";
+
+  ASSERT_TRUE(
+      qdigestEquals<int64_t>(
+          result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
+}
+
+TEST_F(MergeAggregateTest, mergeQDigestRealMatchJava) {
+  registerQDigestType();
+  // Base64-encoded QDigests from Presto Java
+  // QDigest: values 1 to 50
+  const std::string kQDigest1 =
+      "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";
+  // QDigest: values 51 to 100
+  const std::string
+      kQDigest2 =
+          "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";
+
+  // Create QDigest vectors from base64 strings
+  auto qdigestData = makeFlatVector<std::string>({kQDigest1, kQDigest2});
+
+  // Create plan and execute
+  auto op =
+      createMergePlan<float>(makeRowVector({qdigestData}), QDIGEST(REAL()));
+  auto result = readSingleValue(op);
+
+  // Expected merged QDigest base64 string from Java
+  const std::string expectedMergedQDigest =
+      "AK5H4XoUru8/AAAAAAAAAAAAAAAAAAAAAAAAgD8AAAAAAADIQgAAAABgAAAAVAAAAAAAAABAAACAQAAAAIBUAAAAAAAAAEAAAMBAAAAAgFsAAAAAAAAAAAAAgEAAAACAUAAAAAAAAABAAAAAQQAAAIBQAAAAAAAAAEAAACBBAAAAgFcAAAAAAAAAAAAAAEEAAACAUAAAAAAAAABAAABAQQAAAIBQAAAAAAAAAEAAAGBBAAAAgFcAAAAAAAAAAAAAQEEAAACAWwAAAAAAAAAAAAAAQQAAAIBMAAAAAAAAAEAAAIBBAAAAgEwAAAAAAAAAQAAAkEEAAACAUwAAAAAAAAAAAACAQQAAAIBMAAAAAAAAAEAAAKBBAAAAgEwAAAAAAAAAQAAAsEEAAACAUwAAAAAAAAAAAACgQQAAAIBXAAAAAAAAAAAAAIBBAAAAgEwAAAAAAAAAQAAAwEEAAACATAAAAAAAAABAAADQQQAAAIBTAAAAAAAAAAAAAMBBAAAAgEwAAAAAAAAAQAAA4EEAAACATAAAAAAAAABAAADwQQAAAIBTAAAAAAAAAAAAAOBBAAAAgFcAAAAAAAAAAAAAwEEAAACAWwAAAAAAAAAAAACAQQAAAIBfAAAAAAAAAAAAAABBAAAAgGMAAAAAAAAAQAAAAEAAAACASAAAAAAAAABAAAAAQgAAAIBIAAAAAAAAAEAAAAhCAAAAgE8AAAAAAAAAAAAAAEIAAACASAAAAAAAAABAAAAQQgAAAIBIAAAAAAAAAEAAABhCAAAAgE8AAAAAAAAAAAAAEEIAAACAUwAAAAAAAAAAAAAAQgAAAIBIAAAAAAAAAEAAACBCAAAAgEgAAAAAAAAAQAAAKEIAAACATwAAAAAAAAAAAAAgQgAAAIBIAAAAAAAAAEAAADBCAAAAgEgAAAAAAAAAQAAAOEIAAACATwAAAAAAAAAAAAAwQgAAAIBTAAAAAAAAAAAAACBCAAAAgFcAAAAAAAAAAAAAAEIAAACASAAAAAAAAABAAABAQgAAAIAAAAAAAAAA8D8AAEhCAAAAgE8AAAAAAAAAAAAAQEIAAACASAAAAAAAAABAAABQQgAAAIBIAAAAAAAAAEAAAFhCAAAAgE8AAAAAAAAAAAAAUEIAAACAUwAAAAAAAAAAAABAQgAAAIBIAAAAAAAAAEAAAGBCAAAAgEgAAAAAAAAAQAAAaEIAAACATwAAAAAAAAAAAABgQgAAAIBIAAAAAAAAAEAAAHBCAAAAgEgAAAAAAAAAQAAAeEIAAACATwAAAAAAAAAAAABwQgAAAIBTAAAAAAAAAAAAAGBCAAAAgFcAAAAAAAAAAAAATEIAAACAWwAAAAAAAAAAAAAAQgAAAIBEAAAAAAAAAEAAAIBCAAAAgEQAAAAAAAAAQAAAhEIAAACASwAAAAAAAAAAAACAQgAAAIBEAAAAAAAAAEAAAIhCAAAAgEQAAAAAAAAAQAAAjEIAAACASwAAAAAAAAAAAACIQgAAAIBPAAAAAAAAAAAAAIBCAAAAgEQAAAAAAAAAQAAAkEIAAACARAAAAAAAAABAAACUQgAAAIBLAAAAAAAAAAAAAJBCAAAAgEQAAAAAAAAAQAAAmEIAAACARAAAAAAAAABAAACcQgAAAIBLAAAAAAAAAAAAAJhCAAAAgE8AAAAAAAAAAAAAkEIAAACAUwAAAAAAAAAAAACAQgAAAIBEAAAAAAAAAEAAAKBCAAAAgEQAAAAAAAAAQAAApEIAAACASwAAAAAAAAAAAACgQgAAAIBEAAAAAAAAAEAAAKhCAAAAgEQAAAAAAAAAQAAArEIAAACASwAAAAAAAAAAAACoQgAAAIBPAAAAAAAAAAAAAKBCAAAAgEQAAAAAAAAAQAAAsEIAAACARAAAAAAAAABAAAC0QgAAAIBLAAAAAAAAAAAAALBCAAAAgEQAAAAAAAAAQAAAuEIAAACARAAAAAAAAABAAAC8QgAAAIBLAAAAAAAAAAAAALhCAAAAgE8AAAAAAAAAAAAAsEIAAACAUwAAAAAAAAAAAACgQgAAAIBXAAAAAAAAAAAAAIBCAAAAgEQAAAAAAAAAQAAAwEIAAACARAAAAAAAAABAAADEQgAAAIBLAAAAAAAAAAAAAMBCAAAAgFsAAAAAAAAAAAAAgEIAAACAXwAAAAAAAABAAABMQgAAAIBnAAAAAAAAAAAAAABAAAAAgHoAAAAAAADwPwAAgD8AAACA";
+
+  ASSERT_TRUE(
+      qdigestEquals<float>(
+          result.value<TypeKind::VARCHAR>(), expectedMergedQDigest));
+}
+
+TEST_F(MergeAggregateTest, mergeQDigestOneNullMatchJava) {
+  registerQDigestType();
+  // Base64-encoded QDigests from Presto Java
+  // QDigest: values 1 to 50
+  const std::string kQDigest1 =
+      "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";
+  // Empty QDigest string
+  const std::string kQDigest2;
+
+  // Create QDigest vectors from base64 strings
+  auto qdigestData = makeFlatVector<std::string>({kQDigest1, kQDigest2});
+
+  // Create plan and execute
+  auto op =
+      createMergePlan<int64_t>(makeRowVector({qdigestData}), QDIGEST(BIGINT()));
+  auto result = readSingleValue(op);
+
+  // When merging with a null QDigest, the result should be the same as the
+  // original QDigest
+  ASSERT_TRUE(
+      qdigestEquals<float>(result.value<TypeKind::VARCHAR>(), kQDigest1));
+}
+
+TEST_F(MergeAggregateTest, mergeSfmSketch) {
+  registerSfmSketchType();
+  using SfmSketch = functions::sfm::SfmSketch;
+  HashStringAllocator allocator_{pool_.get()};
+
+  // non-private sketch1: values [1, 2, 3]
+  const std::string s1 =
+      "BwkAAAAIAAAAAAAAAAAAAAA7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg";
+  // non-private sketch2: values [4, 5, 6, 7, 8]
+  const std::string s2 =
+      "BwkAAAAIAAAAAAAAAAAAAAB9AAAAAAABAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA=";
+  const auto s1Binary = folly::base64Decode(s1);
+  const auto s2Binary = folly::base64Decode(s2);
+
+  auto vectors = makeRowVector({makeFlatVector<StringView>(
+      {StringView(s1Binary), StringView(s2Binary)}, SFMSKETCH())});
+
+  auto result1 = AssertQueryBuilder(
+                     PlanBuilder()
+                         .values({vectors})
+                         .singleAggregation({}, {"merge(c0)"}, {})
+                         .planNode())
+                     .copyResults(pool());
+
+  auto result2 = AssertQueryBuilder(
+                     PlanBuilder()
+                         .values({vectors})
+                         .partialAggregation({}, {"merge(c0)"}, {})
+                         .finalAggregation()
+                         .planNode())
+                     .copyResults(pool());
+
+  const std::string expectedMerge =
+      "BwkAAAAIAAAAAAAAAAAAAAA7AQAAAAABAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAgAAAAgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg";
+  const auto expectedMergeBinary = folly::base64Decode(expectedMerge);
+
+  ASSERT_EQ(result1->size(), 1);
+  auto resultBinary1 =
+      result1->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+  ASSERT_EQ(resultBinary1, StringView(expectedMergeBinary));
+  ASSERT_EQ(
+      SfmSketch::deserialize(resultBinary1.data(), &allocator_).cardinality(),
+      8);
+
+  ASSERT_EQ(result2->size(), 1);
+  auto resultBinary2 =
+      result2->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+  ASSERT_EQ(resultBinary2, StringView(expectedMergeBinary));
+  ASSERT_EQ(
+      SfmSketch::deserialize(resultBinary2.data(), &allocator_).cardinality(),
+      8);
+}
 } // namespace
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
index e37c88acc636..865fc90ff316 100644
--- a/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/MinMaxByAggregationTest.cpp
@@ -59,82 +59,82 @@ std::vector<TestParam> getTestParams() {
   return params;
 }
 
-#define EXECUTE_TEST_BY_VALUE_TYPE(testFunc, valueType)              \
-  do {                                                               \
-    switch (GetParam().comparisonType) {                             \
-      case TypeKind::BOOLEAN:                                        \
-        testFunc<valueType, bool>();                                 \
-        break;                                                       \
-      case TypeKind::TINYINT:                                        \
-        testFunc<valueType, int8_t>();                               \
-        break;                                                       \
-      case TypeKind::SMALLINT:                                       \
-        testFunc<valueType, int16_t>();                              \
-        break;                                                       \
-      case TypeKind::INTEGER:                                        \
-        testFunc<valueType, int32_t>();                              \
-        break;                                                       \
-      case TypeKind::BIGINT:                                         \
-        testFunc<valueType, int64_t>();                              \
-        break;                                                       \
-      case TypeKind::HUGEINT:                                        \
-        testFunc<valueType, int128_t>();                             \
-        break;                                                       \
-      case TypeKind::REAL:                                           \
-        testFunc<valueType, float>();                                \
-        break;                                                       \
-      case TypeKind::DOUBLE:                                         \
-        testFunc<valueType, double>();                               \
-        break;                                                       \
-      case TypeKind::VARCHAR:                                        \
-        testFunc<valueType, StringView>();                           \
-        break;                                                       \
-      case TypeKind::TIMESTAMP:                                      \
-        testFunc<valueType, Timestamp>();                            \
-        break;                                                       \
-      default:                                                       \
-        LOG(FATAL) << "Unsupported comparison type of minmax_by(): " \
-                   << mapTypeKindToName(GetParam().comparisonType);  \
-    }                                                                \
+#define EXECUTE_TEST_BY_VALUE_TYPE(testFunc, valueType)                \
+  do {                                                                 \
+    switch (GetParam().comparisonType) {                               \
+      case TypeKind::BOOLEAN:                                          \
+        testFunc<valueType, bool>();                                   \
+        break;                                                         \
+      case TypeKind::TINYINT:                                          \
+        testFunc<valueType, int8_t>();                                 \
+        break;                                                         \
+      case TypeKind::SMALLINT:                                         \
+        testFunc<valueType, int16_t>();                                \
+        break;                                                         \
+      case TypeKind::INTEGER:                                          \
+        testFunc<valueType, int32_t>();                                \
+        break;                                                         \
+      case TypeKind::BIGINT:                                           \
+        testFunc<valueType, int64_t>();                                \
+        break;                                                         \
+      case TypeKind::HUGEINT:                                          \
+        testFunc<valueType, int128_t>();                               \
+        break;                                                         \
+      case TypeKind::REAL:                                             \
+        testFunc<valueType, float>();                                  \
+        break;                                                         \
+      case TypeKind::DOUBLE:                                           \
+        testFunc<valueType, double>();                                 \
+        break;                                                         \
+      case TypeKind::VARCHAR:                                          \
+        testFunc<valueType, StringView>();                             \
+        break;                                                         \
+      case TypeKind::TIMESTAMP:                                        \
+        testFunc<valueType, Timestamp>();                              \
+        break;                                                         \
+      default:                                                         \
+        LOG(FATAL) << "Unsupported comparison type of minmax_by(): "   \
+                   << TypeKindName::toName(GetParam().comparisonType); \
+    }                                                                  \
   } while (0);
 
-#define EXECUTE_TEST(testFunc)                                  \
-  do {                                                          \
-    switch (GetParam().valueType) {                             \
-      case TypeKind::BOOLEAN:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, bool);             \
-        break;                                                  \
-      case TypeKind::TINYINT:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int8_t);           \
-        break;                                                  \
-      case TypeKind::SMALLINT:                                  \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int16_t);          \
-        break;                                                  \
-      case TypeKind::INTEGER:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int32_t);          \
-        break;                                                  \
-      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;                                                  \
-      case TypeKind::DOUBLE:                                    \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, double);           \
-        break;                                                  \
-      case TypeKind::VARCHAR:                                   \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, StringView);       \
-        break;                                                  \
-      case TypeKind::TIMESTAMP:                                 \
-        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, Timestamp);        \
-        break;                                                  \
-      default:                                                  \
-        LOG(FATAL) << "Unsupported value type of minmax_by(): " \
-                   << mapTypeKindToName(GetParam().valueType);  \
-    }                                                           \
+#define EXECUTE_TEST(testFunc)                                    \
+  do {                                                            \
+    switch (GetParam().valueType) {                               \
+      case TypeKind::BOOLEAN:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, bool);               \
+        break;                                                    \
+      case TypeKind::TINYINT:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int8_t);             \
+        break;                                                    \
+      case TypeKind::SMALLINT:                                    \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int16_t);            \
+        break;                                                    \
+      case TypeKind::INTEGER:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, int32_t);            \
+        break;                                                    \
+      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;                                                    \
+      case TypeKind::DOUBLE:                                      \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, double);             \
+        break;                                                    \
+      case TypeKind::VARCHAR:                                     \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, StringView);         \
+        break;                                                    \
+      case TypeKind::TIMESTAMP:                                   \
+        EXECUTE_TEST_BY_VALUE_TYPE(testFunc, Timestamp);          \
+        break;                                                    \
+      default:                                                    \
+        LOG(FATAL) << "Unsupported value type of minmax_by(): "   \
+                   << TypeKindName::toName(GetParam().valueType); \
+    }                                                             \
   } while (0);
 
 template <typename T>
@@ -194,7 +194,7 @@ class MinMaxByAggregationTestBase : public AggregationTestBase {
     }
     VELOX_FAIL(
         "Type {} is not found in rowType_: ",
-        mapTypeKindToName(kind),
+        TypeKindName::toName(kind),
         rowType_->toString());
   }
 
@@ -305,7 +305,7 @@ VectorPtr MinMaxByAggregationTestBase::buildDataVector(
       return buildDataVector<Timestamp>(size, values);
     default:
       LOG(FATAL) << "Unsupported value/comparison type of minmax_by(): "
-                 << mapTypeKindToName(kind);
+                 << TypeKindName::toName(kind);
   }
 }
 
@@ -369,7 +369,7 @@ void MinMaxByAggregationTestBase::SetUp() {
             type, buildDataVector<StringView>(numValues_));
         break;
       default:
-        LOG(FATAL) << "Unsupported data type: " << mapTypeKindToName(type);
+        LOG(FATAL) << "Unsupported data type: " << TypeKindName::toName(type);
     }
   }
   ASSERT_EQ(dataVectorsByType_.size(), kSupportedTypes.size());
@@ -722,11 +722,12 @@ class MinMaxByGroupByAggregationTest
           aggregate,
           groupByColumnName);
     }
-    SCOPED_TRACE(fmt::format(
-        "{} GROUP BY {}\nverifyDuckDbSql: {}",
-        aggregate,
-        groupByColumnName,
-        verifyDuckDbSql));
+    SCOPED_TRACE(
+        fmt::format(
+            "{} GROUP BY {}\nverifyDuckDbSql: {}",
+            aggregate,
+            groupByColumnName,
+            verifyDuckDbSql));
     testAggregations(
         vectors, {groupByColumnName}, {aggregate}, {}, verifyDuckDbSql);
   }
@@ -2507,32 +2508,33 @@ TEST_F(MinMaxByTest, nans) {
 }
 
 TEST_F(MinMaxByTest, TimestampWithTimezone) {
-  auto data = makeRowVector({// output column for min_by/max_by
-                             makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8}),
-                             // group by column
-                             makeFlatVector<int32_t>({1, 2, 2, 1, 1, 1, 2, 2}),
-                             // regular ordering
-                             makeFlatVector<int64_t>(
-                                 {pack(-1, 2),
-                                  pack(-3, 1),
-                                  pack(0, 4),
-                                  pack(2, 4),
-                                  pack(3, 1),
-                                  pack(-4, 5),
-                                  pack(1, 3),
-                                  pack(4, 0)},
-                                 TIMESTAMP_WITH_TIME_ZONE()),
-                             // with nulls
-                             makeNullableFlatVector<int64_t>(
-                                 {pack(-1, 2),
-                                  std::nullopt,
-                                  pack(0, 4),
-                                  pack(2, 4),
-                                  pack(3, 1),
-                                  std::nullopt,
-                                  pack(1, 3),
-                                  pack(4, 0)},
-                                 TIMESTAMP_WITH_TIME_ZONE())});
+  auto data = makeRowVector(
+      {// output column for min_by/max_by
+       makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6, 7, 8}),
+       // group by column
+       makeFlatVector<int32_t>({1, 2, 2, 1, 1, 1, 2, 2}),
+       // regular ordering
+       makeFlatVector<int64_t>(
+           {pack(-1, 2),
+            pack(-3, 1),
+            pack(0, 4),
+            pack(2, 4),
+            pack(3, 1),
+            pack(-4, 5),
+            pack(1, 3),
+            pack(4, 0)},
+           TIMESTAMP_WITH_TIME_ZONE()),
+       // with nulls
+       makeNullableFlatVector<int64_t>(
+           {pack(-1, 2),
+            std::nullopt,
+            pack(0, 4),
+            pack(2, 4),
+            pack(3, 1),
+            std::nullopt,
+            pack(1, 3),
+            pack(4, 0)},
+           TIMESTAMP_WITH_TIME_ZONE())});
 
   // Global aggregation.
   {
diff --git a/velox/functions/prestosql/aggregates/tests/NoisyApproxSfmAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/NoisyApproxSfmAggregationTest.cpp
new file mode 100644
index 000000000000..1bc2ea108f87
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/NoisyApproxSfmAggregationTest.cpp
@@ -0,0 +1,403 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/lib/sfm/SfmSketch.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::aggregate::test {
+
+using SfmSketch = functions::sfm::SfmSketch;
+using namespace facebook::velox::exec::test;
+
+class NoisyApproxSfmAggregationTest
+    : public functions::aggregate::test::AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+
+  // Template helper to count distinct values for a specific type.
+  template <typename T>
+  size_t countDistinctForType(const VectorPtr& vector) {
+    const auto size = vector->size();
+    const auto* nulls = vector->rawNulls();
+    std::unordered_set<T> uniqueValues;
+    auto* flatVector = vector->asFlatVector<T>();
+
+    for (vector_size_t i = 0; i < size; ++i) {
+      if (!nulls || !bits::isBitNull(nulls, i)) {
+        uniqueValues.insert(flatVector->valueAt(i));
+      }
+    }
+    return uniqueValues.size();
+  }
+
+  // Dispatch function to count distinct non-null values in a vector.
+  size_t countDistinct(const VectorPtr& vector) {
+    if (!vector) {
+      return 0;
+    }
+
+    switch (vector->typeKind()) {
+      case TypeKind::BIGINT:
+        return countDistinctForType<int64_t>(vector);
+
+      case TypeKind::DOUBLE:
+        return countDistinctForType<double>(vector);
+
+      case TypeKind::VARCHAR:
+      case TypeKind::VARBINARY:
+        return countDistinctForType<StringView>(vector);
+
+      default:
+        VELOX_FAIL("Unsupported type.");
+    }
+  }
+
+  // Helper method to test noisy_approx_sfm with a specific type.
+  void testFuzzerWithType(const TypePtr& type) {
+    const uint32_t seed = 1234;
+    const vector_size_t numElements = 100'000;
+    const double epsilon = 8.0;
+
+    VectorFuzzer::Options options;
+    options.vectorSize = numElements;
+    options.nullRatio = 0.1;
+    options.stringVariableLength = true;
+    options.stringLength = 10;
+
+    VectorFuzzer fuzzer(options, pool_.get(), seed);
+
+    const auto inputVector = fuzzer.fuzzFlat(type);
+    const auto vectors = makeRowVector(
+        {inputVector, makeConstant<double>(epsilon, numElements)});
+
+    const size_t actualCardinality = countDistinct(inputVector);
+
+    const auto distinctResult =
+        AssertQueryBuilder(
+            PlanBuilder()
+                .values({vectors})
+                .singleAggregation(
+                    {}, {"noisy_approx_distinct_sfm(c0, c1)"}, {})
+                .planNode())
+            .copyResults(pool());
+
+    const auto calculatedCardinality =
+        distinctResult->childAt(0)->asFlatVector<int64_t>()->valueAt(0);
+
+    ASSERT_NEAR(
+        calculatedCardinality, actualCardinality, actualCardinality * 0.25);
+
+    const auto setResult =
+        AssertQueryBuilder(
+            PlanBuilder()
+                .values({vectors})
+                .singleAggregation({}, {"noisy_approx_set_sfm(c0, c1)"}, {})
+                .planNode())
+            .copyResults(pool());
+
+    const auto serializedView =
+        setResult->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+    const auto deserialized =
+        SfmSketch::deserialize(serializedView.data(), &allocator_);
+
+    ASSERT_NEAR(
+        deserialized.cardinality(),
+        actualCardinality,
+        actualCardinality * 0.25);
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  HashStringAllocator allocator_{pool_.get()};
+};
+
+TEST_F(NoisyApproxSfmAggregationTest, distinctNonPrivacy) {
+  const auto vectors = makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}),
+       makeConstant(std::numeric_limits<double>::infinity(), 10)});
+
+  const auto expectedResult = makeRowVector({makeConstant<int64_t>(10, 1)});
+  testAggregations(
+      {vectors}, {}, {"noisy_approx_distinct_sfm(c0, c1)"}, {expectedResult});
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, setNonPrivacy) {
+  const auto vectors = makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}),
+       makeConstant(std::numeric_limits<double>::infinity(), 10)});
+
+  const auto returnedSketch =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation({}, {"noisy_approx_set_sfm(c0, c1)"}, {})
+              .planNode())
+          .copyResults(pool());
+
+  const auto serializedView =
+      returnedSketch->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+  const auto deserialized =
+      SfmSketch::deserialize(serializedView.data(), &allocator_);
+  ASSERT_EQ(deserialized.cardinality(), 10);
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, distinctPrivacy) {
+  const vector_size_t numElements = 100'000;
+  const auto vectors = makeRowVector(
+      {makeFlatVector<int64_t>(
+           numElements, [](vector_size_t row) { return row + 1; }),
+       makeConstant(8.0, numElements)});
+
+  const auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation({}, {"noisy_approx_distinct_sfm(c0, c1)"}, {})
+              .planNode())
+          .copyResults(pool());
+
+  ASSERT_NEAR(
+      result->childAt(0)->asFlatVector<int64_t>()->valueAt(0),
+      numElements,
+      numElements * 0.25); // 25% tolerance for 100k elements, 8.0 epsilon.
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, setPrivacy) {
+  const vector_size_t numElements = 100'000;
+  const auto vectors = makeRowVector(
+      {makeFlatVector<int64_t>(
+           numElements, [](vector_size_t row) { return row + 1; }),
+       makeConstant(8.0, numElements)});
+
+  const auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation({}, {"noisy_approx_set_sfm(c0, c1)"}, {})
+              .planNode())
+          .copyResults(pool());
+
+  const auto serializedView =
+      result->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+  const auto deserialized =
+      SfmSketch::deserialize(serializedView.data(), &allocator_);
+  ASSERT_NEAR(deserialized.cardinality(), numElements, numElements * 0.25);
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, setBuckets) {
+  const vector_size_t numElements = 100'000;
+  const auto vectors = makeRowVector(
+      {makeFlatVector<int64_t>(
+           numElements, [](vector_size_t row) { return row + 1; }),
+       makeConstant<double>(8.0, numElements),
+       makeConstant<int64_t>(8192, numElements)}); // specify buckets.
+
+  const auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation({}, {"noisy_approx_set_sfm(c0, c1, c2)"}, {})
+              .planNode())
+          .copyResults(pool());
+
+  const auto serializedView =
+      result->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+  const auto deserialized =
+      SfmSketch::deserialize(serializedView.data(), &allocator_);
+  ASSERT_NEAR(deserialized.cardinality(), numElements, numElements * 0.25);
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, distinctBuckets) {
+  const vector_size_t numElements = 100'000;
+  const auto vectors = makeRowVector(
+      {makeFlatVector<int64_t>(
+           numElements, [](vector_size_t row) { return row + 1; }),
+       makeConstant<double>(8.0, numElements),
+       makeConstant<int64_t>(8192, numElements)});
+
+  const auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation(
+                  {}, {"noisy_approx_distinct_sfm(c0, c1, c2)"}, {})
+              .planNode())
+          .copyResults(pool());
+
+  ASSERT_NEAR(
+      result->childAt(0)->asFlatVector<int64_t>()->valueAt(0),
+      numElements,
+      numElements * 0.25);
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, setBucketsAndPrecison) {
+  const vector_size_t numElements = 100'000;
+  const auto vectors = makeRowVector(
+      {makeFlatVector<int64_t>(
+           numElements, [](vector_size_t row) { return row + 1; }),
+       makeConstant<double>(8.0, numElements),
+       makeConstant<int64_t>(8192, numElements), // specify buckets.
+       makeConstant<int64_t>(30, numElements)}); // specify precision.
+
+  const auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation(
+                  {}, {"noisy_approx_set_sfm(c0, c1, c2, c3)"}, {})
+              .planNode())
+          .copyResults(pool());
+
+  const auto serializedView =
+      result->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+  const auto deserialized =
+      SfmSketch::deserialize(serializedView.data(), &allocator_);
+  ASSERT_NEAR(deserialized.cardinality(), numElements, numElements * 0.25);
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, distinctBucketsAndPrecison) {
+  const vector_size_t numElements = 100'000;
+  const auto vectors = makeRowVector(
+      {makeFlatVector<int64_t>(
+           numElements, [](vector_size_t row) { return row + 1; }),
+       makeConstant<double>(8.0, numElements),
+       makeConstant<int64_t>(8192, numElements),
+       makeConstant<int64_t>(30, numElements)});
+
+  const auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation(
+                  {}, {"noisy_approx_distinct_sfm(c0, c1, c2, c3)"}, {})
+              .planNode())
+          .copyResults(pool());
+
+  ASSERT_NEAR(
+      result->childAt(0)->asFlatVector<int64_t>()->valueAt(0),
+      numElements,
+      numElements * 0.25);
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, emptyInput) {
+  const auto vectors =
+      makeRowVector({makeFlatVector<int64_t>({}), makeConstant(3.0, 0)});
+
+  const auto expectedResult =
+      makeRowVector({makeNullConstant(TypeKind::BIGINT, 1)});
+  testAggregations(
+      {vectors}, {}, {"noisy_approx_distinct_sfm(c0, c1)"}, {expectedResult});
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, fuzzerInput) {
+  // Test with different data types.
+  testFuzzerWithType(VARCHAR());
+  testFuzzerWithType(DOUBLE());
+  testFuzzerWithType(BIGINT());
+  testFuzzerWithType(VARBINARY());
+}
+
+TEST_F(NoisyApproxSfmAggregationTest, addFromIndexAndZeros) {
+  const vector_size_t numElements = 100'000;
+  const int32_t numBuckets_ = 4096;
+
+  auto computeIndexAndZeros = [&](int32_t value) {
+    const auto hash = XXH64(&value, sizeof(value), 0);
+    const int32_t kBitWidth = sizeof(uint64_t) * 8;
+    const auto numIndexBits = static_cast<int32_t>(std::log2(numBuckets_));
+    const uint64_t trailing = hash | (1ULL << (kBitWidth - numIndexBits));
+    const auto index = static_cast<int32_t>(hash >> (kBitWidth - numIndexBits));
+    const auto zeros = __builtin_ctzll(trailing);
+    return std::make_pair(index, zeros);
+  };
+
+  auto indexVector = makeFlatVector<int64_t>(numElements);
+  auto zerosVector = makeFlatVector<int64_t>(numElements);
+  for (int32_t i = 0; i < numElements; i++) {
+    const auto [index, zeros] = computeIndexAndZeros(i);
+    indexVector->set(i, index);
+    zerosVector->set(i, zeros);
+  }
+
+  auto vectors = makeRowVector(
+      {indexVector,
+       zerosVector,
+       makeConstant<double>(8.0, numElements), // epsilon
+       makeConstant<int64_t>(4096, numElements), // buckets
+       makeConstant<int64_t>(36, numElements)}); // precision
+
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation(
+                  {},
+                  {"noisy_approx_set_sfm_from_index_and_zeros(c0, c1, c2, c3)"},
+                  {})
+              .planNode())
+          .copyResults(pool());
+
+  auto serializedView =
+      result->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+  auto deserialized =
+      SfmSketch::deserialize(serializedView.data(), &allocator_);
+
+  ASSERT_NEAR(deserialized.cardinality(), numElements, numElements * 0.25);
+
+  // Specify precision.
+  result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation(
+                  {},
+                  {"noisy_approx_set_sfm_from_index_and_zeros(c0, c1, c2, c3, c4)"},
+                  {})
+              .planNode())
+          .copyResults(pool());
+
+  serializedView = result->childAt(0)->asFlatVector<StringView>()->valueAt(0);
+  deserialized = SfmSketch::deserialize(serializedView.data(), &allocator_);
+
+  ASSERT_NEAR(deserialized.cardinality(), numElements, numElements * 0.25);
+
+  // Input is null.
+  vectors = makeRowVector({
+      makeAllNullFlatVector<int64_t>(numElements), // index
+      makeAllNullFlatVector<int64_t>(numElements), // zeros
+      makeConstant<double>(8.0, numElements), // epsilon
+      makeConstant<int64_t>(4096, numElements), // buckets
+  });
+
+  result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({vectors})
+              .singleAggregation(
+                  {},
+                  {"noisy_approx_set_sfm_from_index_and_zeros(c0, c1, c2, c3)"},
+                  {})
+              .planNode())
+          .copyResults(pool());
+
+  ASSERT_TRUE(result->childAt(0)->isNullAt(0));
+}
+
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/NoisyAvgGaussianAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/NoisyAvgGaussianAggregationTest.cpp
new file mode 100644
index 000000000000..3e62546bab3f
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/NoisyAvgGaussianAggregationTest.cpp
@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::aggregate::test {
+class NoisyAvgGaussianAggregationTest
+    : public functions::aggregate::test::AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+
+  RowTypePtr doubleRowType_{
+      ROW({"c0", "c1", "c2"}, {DOUBLE(), DOUBLE(), DOUBLE()})};
+  RowTypePtr bigintRowType_{
+      ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), BIGINT()})};
+  RowTypePtr decimalRowType_{
+      ROW({"c0", "c1", "c2"},
+          {DECIMAL(20, 5), DECIMAL(20, 5), DECIMAL(20, 5)})};
+  RowTypePtr realRowType_{ROW({"c0", "c1", "c2"}, {REAL(), REAL(), REAL()})};
+  RowTypePtr integerRowType_{
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()})};
+  RowTypePtr smallintRowType_{
+      ROW({"c0", "c1", "c2"}, {SMALLINT(), SMALLINT(), SMALLINT()})};
+  RowTypePtr tinyintRowType_{
+      ROW({"c0", "c1", "c2"}, {TINYINT(), TINYINT(), TINYINT()})};
+};
+
+TEST_F(NoisyAvgGaussianAggregationTest, basicNoNoise) {
+  auto vectors = {makeRowVector({
+      makeFlatVector<int32_t>({1, 2, 3, 4, 5}),
+      makeFlatVector<int32_t>({1, 1, 1, 1, 1}),
+      makeFlatVector<double>({1, 2, 3, 4, 5}),
+  })};
+
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      {vectors},
+      {},
+      {"noisy_avg_gaussian(c2, 0.0)"},
+      "SELECT AVG(c2) FROM tmp");
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, basicWithNoise) {
+  auto vectors = {makeRowVector({
+      makeFlatVector<double>({1, 2, 3, 4, 5}),
+  })};
+
+  // Set the noise scale to 0.1, true average is 3.0.
+  // use +/- 50*SD and test the result is within range [-2.0, 8.0].
+
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              .singleAggregation({}, {"noisy_avg_gaussian(c0, 0.1)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  ASSERT_TRUE(result->childAt(0)->asFlatVector<double>()->valueAt(0) >= -2.0);
+  ASSERT_TRUE(result->childAt(0)->asFlatVector<double>()->valueAt(0) <= 8.0);
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, invalidNoiseScale) {
+  auto vectors = makeVectors(doubleRowType_, 3, 3);
+  createDuckDbTable(vectors);
+
+  // Test invalid noise scale.
+  testFailingAggregations(
+      vectors,
+      {},
+      {"noisy_avg_gaussian(c2, -1.0)"},
+      "Noise scale must be a non-negative value.");
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, groupbyNullsNoNoise) {
+  auto vectors = {makeRowVector({
+      makeNullableFlatVector<double>({std::nullopt, 1, 1, 1, std::nullopt}),
+      makeNullableFlatVector<double>({1, 2, 3, 4, 5}),
+  })};
+
+  // Group by c0, aggregate c1. Expected result:
+  // c0   | noisy_avg_gaussian(c1, 0.0)
+  // NULL | 3.0
+  // 1    | 3.0
+  auto expectedResult = makeRowVector(
+      {makeNullableFlatVector<double>({std::nullopt, 1.0}),
+       makeFlatVector<double>({3.0, 3.0})});
+
+  testAggregations(
+      vectors, {"c0"}, {"noisy_avg_gaussian(c1, 0.0)"}, {expectedResult});
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, aggregateNullsNoNoise) {
+  auto vectors = {makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 2}),
+      makeNullableFlatVector<double>({std::nullopt, std::nullopt, 1, 1, 1}),
+  })};
+
+  // group by c0, aggregate c1. Expected result:
+  // c0   | noisy_avg_gaussian(c1, 0.1)
+  // 1    | NULL
+  // 2    | 1.0
+  auto expectedResult = makeRowVector(
+      {makeFlatVector<int32_t>({1, 2}),
+       makeNullableFlatVector<double>({std::nullopt, 1.0})});
+
+  testAggregations(
+      vectors, {"c0"}, {"noisy_avg_gaussian(c1, 0.0)"}, {expectedResult});
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, singleGroupSingleAggregateNoNoise) {
+  auto vectors = makeVectors(doubleRowType_, 5, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_avg_gaussian(c1, 0.0)"},
+      {"SELECT AVG(c1) FROM tmp"});
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, singleGroupMultipleAggregationNoNoise) {
+  auto vectors = makeVectors(doubleRowType_, 5, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_avg_gaussian(c1, 0.0)", "noisy_avg_gaussian(c2, 0.0)"},
+      {"SELECT AVG(c1), AVG(c2) FROM tmp"});
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, multipleGroupSingleAggregationNoNoise) {
+  auto vectors = makeVectors(doubleRowType_, 5, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {"c0"},
+      {"noisy_avg_gaussian(c2, 0.0)"},
+      {"SELECT c0, AVG(c2) FROM tmp GROUP BY c0"});
+}
+
+TEST_F(
+    NoisyAvgGaussianAggregationTest,
+    multipleGroupMultipleAggregationNoNoise) {
+  auto vectors = makeVectors(doubleRowType_, 5, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {"c0"},
+      {"noisy_avg_gaussian(c1, 0.0)", "noisy_avg_gaussian(c2, 0.0)"},
+      {"SELECT c0, AVG(c1), AVG(c2) FROM tmp GROUP BY c0"});
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, emptyInputTest) {
+  auto vectors = {makeRowVector({
+      makeFlatVector<int32_t>({}),
+      makeFlatVector<int32_t>({}),
+      makeFlatVector<double>({}),
+  })};
+
+  createDuckDbTable(vectors);
+  // Should return NULL for empty input. consistent with DuckDB.
+  testAggregations(
+      vectors, {}, {"noisy_avg_gaussian(c2, 0.0)"}, "SELECT AVG(c2) FROM tmp");
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, bigintNoiseScaleType) {
+  auto vectors = makeVectors(doubleRowType_, 3, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors, {}, {"noisy_avg_gaussian(c2, 0)"}, "SELECT AVG(c2) FROM tmp");
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, numericInputTypeTestNoNoise) {
+  auto rowTypes = {
+      doubleRowType_,
+      bigintRowType_,
+      decimalRowType_,
+      realRowType_,
+      integerRowType_,
+      smallintRowType_,
+      tinyintRowType_};
+
+  for (const auto& rowType : rowTypes) {
+    auto vectors = makeVectors(rowType, 3, 3);
+    createDuckDbTable(vectors);
+
+    testAggregations(
+        vectors,
+        {},
+        {"noisy_avg_gaussian(c2, 0.0)"},
+        "SELECT AVG(c2) FROM tmp");
+  }
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, boundsClipTestNoNoise) {
+  auto vectors = {makeRowVector({makeFlatVector<double>({1, 2, 3, 4, 5})})};
+
+  // set the bounds to [4, 4].
+  // The clipped sum should be 20 and the average should be 4.
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              // lower bigint, upper bigint
+              .singleAggregation({}, {"noisy_avg_gaussian(c0, 0.0, 4, 4)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  ASSERT_EQ(result->childAt(0)->asFlatVector<double>()->valueAt(0), 4);
+
+  result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              // lower double, upper bigint
+              .singleAggregation({}, {"noisy_avg_gaussian(c0, 0, 4.0, 4)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  ASSERT_EQ(result->childAt(0)->asFlatVector<double>()->valueAt(0), 4);
+
+  result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              // lower bigint, upper double
+              .singleAggregation({}, {"noisy_avg_gaussian(c0, 0, 4, 4.0)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  ASSERT_EQ(result->childAt(0)->asFlatVector<double>()->valueAt(0), 4);
+
+  result = AssertQueryBuilder(
+               PlanBuilder()
+                   .values(vectors)
+                   // lower double, upper double
+                   .singleAggregation(
+                       {}, {"noisy_avg_gaussian(c0, 0, 4.0, 4.0)"}, {})
+                   .planNode(),
+               duckDbQueryRunner_)
+               .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  ASSERT_EQ(result->childAt(0)->asFlatVector<double>()->valueAt(0), 4);
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, boundsClipTestWithNoise) {
+  // True AVG of c0 is always 0.
+  auto vectors = {
+      makeRowVector({makeFlatVector<double>({0.0, 0.0, 0.0, 0.0, 0.0})})};
+
+  // Test that if upper bound <= 0, then the noisy avg is always <= 0.
+  for (int i = 0; i < 10; i++) {
+    auto result = AssertQueryBuilder(
+                      PlanBuilder()
+                          .values(vectors)
+                          .singleAggregation(
+                              {}, {"noisy_avg_gaussian(c0, 2, -2, -0.1)"}, {})
+                          .planNode(),
+                      duckDbQueryRunner_)
+                      .copyResults(pool());
+
+    ASSERT_TRUE(result->childAt(0)->asFlatVector<double>()->valueAt(0) <= 0);
+  }
+
+  // Test that if lower bound >= 0, then the noisy avg is always >= 0.
+  for (int i = 0; i < 10; i++) {
+    auto result = AssertQueryBuilder(
+                      PlanBuilder()
+                          .values(vectors)
+                          .singleAggregation(
+                              {}, {"noisy_avg_gaussian(c0, 2, 0.1, 2)"}, {})
+                          .planNode(),
+                      duckDbQueryRunner_)
+                      .copyResults(pool());
+
+    ASSERT_TRUE(result->childAt(0)->asFlatVector<double>()->valueAt(0) >= 0);
+  }
+}
+TEST_F(NoisyAvgGaussianAggregationTest, randomSeedNoNoise) {
+  auto vectors = makeVectors(doubleRowType_, 3, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_avg_gaussian(c2, 0.0, 12345)"},
+      "SELECT AVG(c2) FROM tmp");
+}
+
+TEST_F(NoisyAvgGaussianAggregationTest, randomSeedDeterminismTestWithNoise) {
+  auto vectors = makeVectors(doubleRowType_, 10, 5);
+
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              .singleAggregation({}, {"noisy_avg_gaussian(c2, 0.5, 12345)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  // Test that the noise is deterministic given the same noise_scale,
+  // random_seed.
+  for (int i = 0; i < 10; i++) {
+    testAggregations(
+        vectors, {}, {"noisy_avg_gaussian(c2, 0.5, 12345)"}, {result});
+  }
+}
+
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/NoisyCountGaussianAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/NoisyCountGaussianAggregationTest.cpp
new file mode 100644
index 000000000000..32bfd4370a83
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/NoisyCountGaussianAggregationTest.cpp
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::aggregate::test {
+class NoisyCountGaussianAggregationTest
+    : public functions::aggregate::test::AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+  RowTypePtr rowType1_{
+      ROW({"c0", "c1", "c2"}, {INTEGER(), BOOLEAN(), VARCHAR()})};
+  RowTypePtr rowType2_{
+      ROW({"c0", "c1", "c2"}, {DOUBLE(), TIMESTAMP(), BIGINT()})};
+  RowTypePtr rowType3_{
+      ROW({"c0", "c1", "c2"},
+          {REAL(), ARRAY(BIGINT()), MAP(BIGINT(), BIGINT())})};
+};
+
+// Test normal count(*)
+TEST_F(NoisyCountGaussianAggregationTest, countStarNoNoise) {
+  auto vectors = makeVectors(rowType1_, 10, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(1, 0.0)"}, // Normal count(*) should be rewriten
+                                        // and call noisy_count_gaussian(1, 0.0)
+      "SELECT count(*) FROM tmp");
+}
+
+// Test cases that take different input types without noise.
+TEST_F(NoisyCountGaussianAggregationTest, constNoNoise) {
+  auto vectors = {makeRowVector({
+      makeFlatVector<int64_t>(10, [](vector_size_t row) { return row / 3; }),
+      makeConstant(true, 10),
+      makeConstant("foo", 10),
+  })};
+  createDuckDbTable(vectors);
+
+  // Aggregate on column c2 which contains string values.
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c2, 0.0)"},
+      "SELECT count(c2) FROM tmp");
+
+  // Aggregate on column c1 which contains boolean values.
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c1, 0.0)"},
+      "SELECT count(c1) FROM tmp");
+
+  // Aggregate on column c0 which contains integer values.
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c0, 0.0)"},
+      "SELECT count(c0) FROM tmp");
+}
+
+// Test cases where the noise scale is invalid.
+TEST_F(NoisyCountGaussianAggregationTest, inValidNoise) {
+  auto vectors = makeVectors(rowType1_, 10, 5);
+  createDuckDbTable(vectors);
+
+  // Test should fail and output expected error message.
+  testFailingAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c2, -1.0)"},
+      "Noise scale must be a non-negative value");
+}
+
+// Test cases where the input vector has nulls and non-nulls.
+TEST_F(NoisyCountGaussianAggregationTest, aggregateMixedNoNoise) {
+  // Make a single row vector with nulls, null every 4th row (0, 4, 8, ...).
+  auto vectors = {
+      makeRowVector({makeFlatVector<bool>(
+          10, [](auto row) { return row % 3 == 0; }, nullEvery(4))}),
+  };
+
+  createDuckDbTable(vectors);
+
+  // Test against the DuckDB result.
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c0, 0.0)"},
+      "SELECT count(c0) FROM tmp");
+
+  // Test against the expected result, 3 out of 10 rows are null.
+  auto expectedResult =
+      makeRowVector({makeConstant(static_cast<int64_t>(7 /*valid rows*/), 1)});
+
+  testAggregations(
+      vectors, {}, {"noisy_count_gaussian(c0, 0.0)"}, {expectedResult});
+}
+
+// Test cases where the input vector has all null values.
+TEST_F(NoisyCountGaussianAggregationTest, aggregateAllNullsNoNoise) {
+  auto vectors = {makeRowVector({makeAllNullFlatVector<int>(10)})};
+
+  // DuckDB will output 0 in this case while Presto JAVA noisy functions
+  // will output NULL.
+  // Test against the expected result, which is NULL.
+  auto expectedResult = makeRowVector({makeAllNullFlatVector<int64_t>(1)});
+
+  testAggregations(
+      vectors, {}, {"noisy_count_gaussian(c0, 0.0)"}, {expectedResult});
+}
+
+// Test cases where the input vector has nulls with multiple groups, no noise.
+TEST_F(NoisyCountGaussianAggregationTest, groupByNullNoNoise) {
+  // Make a bactch of vectors of which the first contains all nulls, and the
+  // second contains integers, and the third contains strings.
+  auto vectors = {
+      makeRowVector(
+          {makeAllNullFlatVector<int>(10),
+           makeFlatVector<int>(10, [](auto row) { return row % 3; }),
+           makeConstant("foo", 10)}),
+  };
+
+  createDuckDbTable(vectors);
+
+  // Test against the DuckDB result.
+  testAggregations(
+      vectors,
+      {"c0", "c1"},
+      {"noisy_count_gaussian(c2, 0.0)"},
+      "SELECT c0, c1, count(c2) FROM tmp GROUP BY c0, c1");
+
+  // Test against the expected result. Expected result is:
+  // c0    c1    noisy_count_gaussian(c2, 0.0)
+  // NULL  0     4
+  // NULL  1     3
+  // NULL  2     3
+  auto expectedResult = makeRowVector({
+      makeAllNullFlatVector<int>(3), // group by c0 is null
+      makeFlatVector<int>(3, [](auto row) { return row % 3; }), // group by c1
+      makeFlatVector<int64_t>(
+          3, [](auto row) { return row == 0 ? 4 : 3; }), // noisy count.
+  });
+
+  testAggregations(
+      vectors,
+      {"c0", "c1"},
+      {"noisy_count_gaussian(c2, 0.0)"},
+      {expectedResult});
+}
+
+// Test cases where the input vector is empty. Return null.
+TEST_F(NoisyCountGaussianAggregationTest, emptyInputNoNoise) {
+  auto vectors = makeVectors(rowType1_, 0, 1);
+
+  // Test against the expected result, will return NULL.
+  auto expectedResult = makeRowVector({makeAllNullFlatVector<int64_t>(1)});
+
+  testAggregations(
+      vectors, {}, {"noisy_count_gaussian(c0, 0.0)"}, {expectedResult});
+}
+
+TEST_F(NoisyCountGaussianAggregationTest, oneAggregateSingleGroupNoNoise) {
+  // Make two batches of rows: one with nulls; another without.
+  auto vectors = makeVectors(rowType1_, 10, 2);
+
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c0, 0.0)"},
+      "SELECT count(c0) FROM tmp");
+}
+
+TEST_F(NoisyCountGaussianAggregationTest, oneAggregateMultipleGroupsNoNoise) {
+  auto vectors = {
+      // This test case is designed to test the senario where the aggregated
+      // column has null values for one of the groupby keys.
+      // c0: 0, 1, 0, 1, 0, 1, 0, 1, 0, 1
+      // c1: null, 1, null, 1, null, 1, null, 1, null, 1
+      // c2: "foo", "foo", ... "foo", "foo"
+      makeRowVector({
+          makeFlatVector<int>(10, [](auto row) { return row % 2; }), // c0
+          makeFlatVector<int>(
+              10, [](auto row) { return row % 2; }, nullEvery(2)), // c1
+          makeFlatVector<std::string>(
+              10, [](auto row) { return std::to_string(row) + "foo"; }) // c2
+      }),
+  };
+
+  // EXPECTED RESULT:
+  // C0 | noisy_count_gaussian(c1, 0.0)
+  // 0  | NULL
+  // 1  | 5
+  auto expectedResult = makeRowVector(
+      {makeFlatVector<int>({0, 1}),
+       makeNullableFlatVector<int64_t>({std::nullopt, 5})});
+
+  testAggregations(
+      vectors, {"c0"}, {"noisy_count_gaussian(c1, 0.0)"}, {expectedResult});
+}
+
+TEST_F(NoisyCountGaussianAggregationTest, twoAggregatesSingleGroupNoNoise) {
+  auto vectors = makeVectors(rowType1_, 10, 4);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c1, 0.0)", "noisy_count_gaussian(c2, 0.0)"},
+      "SELECT count(c1), count(c2) FROM tmp");
+
+  // Test with non-zero noise_scale.
+  auto vectors2 = {makeRowVector({makeConstant(1, 100)})}; // 100 rows of 1
+
+  // Theoretically, the outcome of noisy_count_gaussian(1, noise_scale) should
+  // be unpredictable, but with about 95% of the valuesfall within +/- 2 *
+  // noise_scale, and 99.7% within +/- 3 * noise_scale. We set the noise_scale
+  // to 1.0, To avoid any failure by chance, we expect the noisy count to be
+  // within +/- 50 of the actual 100. check if the noisy count is within [50,
+  // 150].
+
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors2)
+              .singleAggregation({}, {"noisy_count_gaussian(c0, 1.0)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+  ASSERT_TRUE(result->size() == 1);
+  ASSERT_TRUE(result->childAt(0)->asFlatVector<int64_t>()->valueAt(0) >= 50);
+  ASSERT_TRUE(result->childAt(0)->asFlatVector<int64_t>()->valueAt(0) <= 150);
+}
+
+// Test distinct noisy_count.
+TEST_F(NoisyCountGaussianAggregationTest, distinctCount) {
+  auto vectors = makeVectors(rowType1_, 4, 3);
+  createDuckDbTable(vectors);
+
+  // Use singleAggregation directly instead of testAggregations to avoid partial
+  // aggregation which doesn't support distinct aggregations
+  auto result = AssertQueryBuilder(
+                    PlanBuilder()
+                        .values(vectors)
+                        .markDistinct("distinct", {"c0"})
+                        .singleAggregation(
+                            {}, {"noisy_count_gaussian(c0, 0.0)"}, {"distinct"})
+                        .planNode(),
+                    duckDbQueryRunner_)
+                    .assertResults("SELECT count(distinct c0) FROM tmp");
+}
+
+// Test non-scalar input types.
+TEST_F(NoisyCountGaussianAggregationTest, nonScalarInputNoNoise) {
+  auto vectors = makeVectors(rowType3_, 10, 3);
+  createDuckDbTable(vectors);
+
+  // Aggregate on column c1 which contains array values.
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c1, 0.0)"},
+      "SELECT count(c1) FROM tmp");
+
+  // Aggregate on column c2 which contains map values.
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c2, 0.0)"},
+      "SELECT count(c2) FROM tmp");
+}
+
+// Test cases where the noise_scale is BIGINT.
+TEST_F(NoisyCountGaussianAggregationTest, noiseScaleBigintNoNoise) {
+  auto vectors = makeVectors(rowType1_, 10, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c0, 0)"},
+      "SELECT count(c0) FROM tmp");
+}
+
+TEST_F(NoisyCountGaussianAggregationTest, twoAggregatesMultipleGroupsNoNoise) {
+  // Test case that do not contain nulls.
+  auto vectors = {
+      makeRowVector({
+          makeFlatVector<int>(1'000, [](auto row) { return row % 5; }), // c0
+          makeFlatVector<int>(1'000, [](auto row) { return row % 2; }), // c1
+          makeFlatVector<std::string>(
+              1'000, [](auto row) { return std::to_string(row) + "foo"; }) // c2
+      }),
+  };
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {"c0"},
+      {"noisy_count_gaussian(c1, 0.0, 1234)", "noisy_count_gaussian(c2, 0.0)"},
+      "SELECT c0, count(c1), count(c2) FROM tmp GROUP BY c0");
+
+  // Test case that contains nulls.
+  auto vectors2 = {
+      // This test case is designed to test the senario where the aggregated
+      // column has null values for one of the groupby keys.
+      // c0: null,  1,  0,   1,  0,  null,  0,   1,  0,   1
+      // c1: null,  1, null, 1, null,  1,  null, 1, null, 1
+      // c2: null, "foo", ... "foo", "foo"
+      makeRowVector({
+          makeFlatVector<int>(
+              10, [](auto row) { return row % 2; }, nullEvery(5)), // c0
+          makeFlatVector<int>(
+              10, [](auto row) { return row % 2; }, nullEvery(2)), // c1
+          makeFlatVector<std::string>(
+              10,
+              [](auto row) { return std::to_string(row) + "foo"; },
+              nullEvery(10)) // c2
+      }),
+  };
+
+  // EXPECTED RESULT:
+  // C0   | noisy_count_gaussian(c1, 0.0) | noisy_count_gaussian(c2, 0.0)
+  // NULL | 1                             | 1
+  // 0    | NULL                          | 4
+  // 1    | 4                             | 4
+  auto expectedResult = makeRowVector(
+      {makeNullableFlatVector<int>({std::nullopt, 0, 1}),
+       makeNullableFlatVector<int64_t>({1, std::nullopt, 4}),
+       makeNullableFlatVector<int64_t>({1, 4, 4})});
+
+  testAggregations(
+      vectors2,
+      {"c0"},
+      {"noisy_count_gaussian(c1, 0.0, 1234)",
+       "noisy_count_gaussian(c2, 0.0, 5678)"},
+      {expectedResult});
+}
+
+TEST_F(
+    NoisyCountGaussianAggregationTest,
+    twoAggregatesMultipleGroupsWrappedNoNoise) {
+  auto vectors = makeVectors(rowType1_, 10, 4);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      [&](auto& builder) {
+        builder.values(vectors)
+            .filter("c0 % 2 = 0")
+            .project({"c0 % 11 AS c0_mod_11", "c1", "c2"});
+      },
+      {"c0_mod_11"},
+      {"noisy_count_gaussian(c1, 0.0, 000)",
+       "noisy_count_gaussian(c2, 0.0, 000)"},
+      "SELECT c0 % 11, count(c1), count(c2) FROM tmp WHERE c0 % 2 = 0 GROUP BY 1");
+}
+
+// Test that the aggregation random seed as input
+TEST_F(NoisyCountGaussianAggregationTest, randomSeedNoNoise) {
+  auto vectors = makeVectors(rowType2_, 10, 4);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_gaussian(c1, 0.0, 456)",
+       "noisy_count_gaussian(c2, 0.0, 456)"},
+      "SELECT count(c1), count(c2) FROM tmp");
+}
+
+// Test that given a random seed, the aggregation is deterministic.
+TEST_F(NoisyCountGaussianAggregationTest, randomSeedDeterminism) {
+  auto vectors = makeVectors(rowType1_, 10, 4);
+
+  // Now run the aggregation with the given random seed and extract the result
+  auto expectedResult =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              .singleAggregation({}, {"noisy_count_gaussian(c1, 3.0, 456)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  // The result should be the same for the same input, noise scale, and seed
+  int numRuns = 10;
+  for (int i = 0; i < numRuns; i++) {
+    testAggregations(
+        vectors, {}, {"noisy_count_gaussian(c1, 3, 456)"}, {expectedResult});
+  }
+}
+
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/NoisyCountIfGaussianAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/NoisyCountIfGaussianAggregationTest.cpp
index 323856d5a379..d5218993daf9 100644
--- a/velox/functions/prestosql/aggregates/tests/NoisyCountIfGaussianAggregationTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/NoisyCountIfGaussianAggregationTest.cpp
@@ -201,4 +201,47 @@ TEST_F(NoisyCountIfGaussianAggregationTest, bigIntNoiseScaleTypeNoNoise) {
       "SELECT sum(if(c1, 1, 0)), sum(if(c2, 1, 0)) FROM tmp");
 }
 
+// Test that the aggregation random seed as input
+TEST_F(NoisyCountIfGaussianAggregationTest, randomSeedNoNoise) {
+  auto vectors = makeVectors(rowType_, 10, 4);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_count_if_gaussian(c1, 0.0, 456)",
+       "noisy_count_if_gaussian(c2, 0.0, 456)"},
+      "SELECT sum(if(c1, 1, 0)), sum(if(c2, 1, 0)) FROM tmp");
+}
+
+// Test that given a random seed, the aggregation is deterministic.
+TEST_F(NoisyCountIfGaussianAggregationTest, randomSeedDeterminism) {
+  auto vectors = {
+      makeRowVector({
+          makeFlatVector<int64_t>(
+              20, [](vector_size_t row) { return row / 3; }),
+          makeConstant(true, 20),
+          makeConstant(false, 20),
+      }),
+  };
+
+  // Now run the aggregation with the given random seed and extract the result
+  auto expectedResult =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              .singleAggregation(
+                  {}, {"noisy_count_if_gaussian(c1, 3.0, 456)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  // The result should be the same for the same input, noise scale, and seed
+  int numRuns = 10;
+  for (int i = 0; i < numRuns; i++) {
+    testAggregations(
+        vectors, {}, {"noisy_count_if_gaussian(c1, 3, 456)"}, {expectedResult});
+  }
+}
+
 } // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/NoisySumGaussianAggregationTest.cpp b/velox/functions/prestosql/aggregates/tests/NoisySumGaussianAggregationTest.cpp
new file mode 100644
index 000000000000..a29aac7a2e9a
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/NoisySumGaussianAggregationTest.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 <gtest/gtest.h>
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::aggregate::test {
+
+class NoisySumGaussianAggregationTest
+    : public functions::aggregate::test::AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+
+  RowTypePtr doubleRowType_{
+      ROW({"c0", "c1", "c2"}, {DOUBLE(), DOUBLE(), DOUBLE()})};
+  RowTypePtr bigintRowType_{
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), BIGINT()})};
+  RowTypePtr decimalRowType_{
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), DECIMAL(20, 5)})};
+  RowTypePtr realRowType_{
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), REAL()})};
+  RowTypePtr integerRowType_{
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), INTEGER()})};
+  RowTypePtr smallintRowType_{
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), SMALLINT()})};
+  RowTypePtr tinyintRowType_{
+      ROW({"c0", "c1", "c2"}, {INTEGER(), INTEGER(), TINYINT()})};
+};
+
+TEST_F(NoisySumGaussianAggregationTest, simpleTestNoNoise) {
+  auto vectors = {makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+       makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+       makeFlatVector<double>({1.0, 2.0, 3.0, 4.0, 5.0})})};
+
+  // Expect the result to be 15.0
+  auto expectedResult = makeRowVector({makeConstant(15.0, 1)});
+  testAggregations(
+      {vectors}, {}, {"noisy_sum_gaussian(c2, 0.0)"}, {expectedResult});
+
+  // test nosie scale of bigint type.
+  testAggregations(
+      {vectors}, {}, {"noisy_sum_gaussian(c2, 0)"}, {expectedResult});
+}
+
+// Test cases where the noise scale is invalid.
+TEST_F(NoisySumGaussianAggregationTest, inValidNoise) {
+  auto vectors = makeVectors(doubleRowType_, 10, 5);
+  createDuckDbTable(vectors);
+
+  // Test should fail and output expected error message.
+  testFailingAggregations(
+      vectors,
+      {},
+      {"noisy_sum_gaussian(c2, -1.0)"},
+      "Noise scale must be a non-negative value.");
+}
+
+TEST_F(NoisySumGaussianAggregationTest, nullTestNoNoise) {
+  // Test non-null and null values mixed.
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>({1, 2, 3, 4, 5}),
+       makeFlatVector<double>({1, 2, 3, 4, 5}),
+       makeNullableFlatVector<double>({std::nullopt, 2, std::nullopt, 4, 5})});
+
+  // Expect the result to be 11.0
+  auto expectedResult = makeRowVector({makeConstant(11.0, 1)});
+  testAggregations(
+      {vectors}, {}, {"noisy_sum_gaussian(c2, 0.0)"}, {expectedResult});
+
+  // Test all null values.
+  auto vectors2 = makeRowVector({makeAllNullFlatVector<double>(10)});
+
+  // Expect the result to be NULL
+  auto expectedResult2 = makeRowVector({makeNullConstant(TypeKind::DOUBLE, 1)});
+  testAggregations(
+      {vectors2}, {}, {"noisy_sum_gaussian(c0, 0.0)"}, {expectedResult2});
+}
+
+TEST_F(NoisySumGaussianAggregationTest, emptyTestNoNoise) {
+  // Test empty input.
+  auto vectors = {makeRowVector(
+      {makeFlatVector<int64_t>({}),
+       makeFlatVector<int64_t>({}),
+       makeFlatVector<double>({})})};
+
+  // Expect the result to be NULL
+  auto expectedResult = makeRowVector({makeNullConstant(TypeKind::DOUBLE, 1)});
+  testAggregations(
+      {vectors}, {}, {"noisy_sum_gaussian(c2, 0.0)"}, {expectedResult});
+}
+
+TEST_F(
+    NoisySumGaussianAggregationTest,
+    singleGroupMultipleAggregationTestNoNoise) {
+  auto vectors = makeVectors(doubleRowType_, 5, 3);
+  createDuckDbTable(vectors);
+
+  // Single group by key, multiple aggregation functions.
+  testAggregations(
+      vectors,
+      {},
+      {"noisy_sum_gaussian(c1, 0.0)", "noisy_sum_gaussian(c2, 0.0)"},
+      "SELECT SUM(c1), SUM(c2) FROM tmp");
+}
+
+TEST_F(
+    NoisySumGaussianAggregationTest,
+    multipleGroupSingleAggregationTestNoNoise) {
+  auto vectors = makeVectors(doubleRowType_, 5, 3);
+  createDuckDbTable(vectors);
+
+  // Multiple group by keys, single aggregation functions.
+  testAggregations(
+      vectors,
+      {"c0", "c1"},
+      {"noisy_sum_gaussian(c2, 0.0)"},
+      "SELECT c0, c1, SUM(c2) FROM tmp GROUP BY c0, c1");
+}
+
+TEST_F(
+    NoisySumGaussianAggregationTest,
+    multipleGroupMultipleAggregationTestNoNoise) {
+  auto vectors = makeVectors(doubleRowType_, 5, 3);
+  createDuckDbTable(vectors);
+
+  // Multiple group by keys, multiple aggregation functions.
+  testAggregations(
+      vectors,
+      {"c0"},
+      {"noisy_sum_gaussian(c1, 0.0)", "noisy_sum_gaussian(c2, 0.0)"},
+      "SELECT c0, SUM(c1), SUM(c2) FROM tmp GROUP BY c0");
+}
+
+TEST_F(NoisySumGaussianAggregationTest, groupByNullTestNoNoise) {
+  // Test group
+  auto vectors = makeRowVector(
+      {makeNullableFlatVector<double>({std::nullopt, 2, std::nullopt, 2, 2}),
+       makeFlatVector<double>({1, 1, 3, 3, 3}),
+       makeNullableFlatVector<double>({std::nullopt, 2, std::nullopt, 2, 2})});
+
+  // Group by c0, aggregate c1, expect the result:
+  // c0   | noisy_sum_gaussian(c1, 0.0)
+  // NULL | 4
+  // 2    | 7
+  auto expectedResult = makeRowVector(
+      {makeNullableFlatVector<double>({std::nullopt, 2}),
+       makeNullableFlatVector<double>({4, 7})});
+  testAggregations(
+      {vectors}, {"c0"}, {"noisy_sum_gaussian(c1, 0.0)"}, {expectedResult});
+
+  // Group by c0, aggregate c2, expect the result:
+  // c0   | noisy_sum_gaussian(c2, 0.0)
+  // NULL | NULL
+  // 2    | 6
+  auto expectedResult2 = makeRowVector(
+      {makeNullableFlatVector<double>({std::nullopt, 2}),
+       makeNullableFlatVector<double>({std::nullopt, 6})});
+
+  testAggregations(
+      {vectors}, {"c0"}, {"noisy_sum_gaussian(c2, 0.0)"}, {expectedResult2});
+}
+
+TEST_F(NoisySumGaussianAggregationTest, inputTypeTestNoNoise) {
+  // Test that the function supports various input types.
+  auto doubleVector = makeVectors(doubleRowType_, 5, 3);
+  auto bigintVector = makeVectors(bigintRowType_, 5, 3);
+  auto decimalVector = makeVectors(decimalRowType_, 5, 3);
+  auto realVector = makeVectors(realRowType_, 5, 3);
+  auto integerVector = makeVectors(integerRowType_, 5, 3);
+  auto smallintVector = makeVectors(smallintRowType_, 5, 3);
+  auto tinyintVector = makeVectors(tinyintRowType_, 5, 3);
+
+  createDuckDbTable(doubleVector);
+  testAggregations(
+      doubleVector,
+      {},
+      {"noisy_sum_gaussian(c2, 0.0)"}, // double noise_scale
+      "SELECT sum(c2) FROM tmp");
+
+  createDuckDbTable(bigintVector);
+  testAggregations(
+      bigintVector,
+      {},
+      {"noisy_sum_gaussian(c2, 0.0)"},
+      "SELECT sum(c2) FROM tmp");
+
+  createDuckDbTable(decimalVector);
+  testAggregations(
+      decimalVector,
+      {},
+      {"noisy_sum_gaussian(c2, 0.0)"},
+      "SELECT sum(c2) FROM tmp");
+
+  createDuckDbTable(realVector);
+  testAggregations(
+      realVector,
+      {},
+      {"noisy_sum_gaussian(c2, 0)"}, // bigint noise_scale
+      "SELECT sum(c2) FROM tmp");
+
+  createDuckDbTable(integerVector);
+  testAggregations(
+      integerVector,
+      {},
+      {"noisy_sum_gaussian(c2, 0)"},
+      "SELECT sum(c2) FROM tmp");
+
+  createDuckDbTable(smallintVector);
+  testAggregations(
+      smallintVector,
+      {},
+      {"noisy_sum_gaussian(c2, 0)"},
+      "SELECT sum(c2) FROM tmp");
+
+  createDuckDbTable(tinyintVector);
+  testAggregations(
+      tinyintVector,
+      {},
+      {"noisy_sum_gaussian(c2, 0)"},
+      "SELECT sum(c2) FROM tmp");
+}
+
+TEST_F(NoisySumGaussianAggregationTest, randomSeedTestNoNoise) {
+  // Test that the function support random seed, no noise.
+  auto vectors = makeVectors(integerRowType_, 5, 3);
+  createDuckDbTable(vectors);
+
+  testAggregations(
+      vectors,
+      {},
+      // noisy_sum_gaussian(col, noise_scale, randon_seed)
+      {"noisy_sum_gaussian(c2, 0.0, 12345)"},
+      "SELECT SUM(CASE WHEN c2 IS NOT NULL THEN c2 END) FROM tmp");
+}
+
+TEST_F(NoisySumGaussianAggregationTest, randomSeedTestWithNoise) {
+  auto vectors = makeVectors(integerRowType_, 5, 3);
+  createDuckDbTable(vectors);
+  // Test that the noise is deterministic given the same noise_scale,
+  // random_seed. noisy_sum_gaussian(col, noise_scale, randon_seed)
+  auto expectedResult =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              .singleAggregation({}, {"noisy_sum_gaussian(c2, 20, 12345)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  int numRuns = 10;
+  for (int i = 0; i < numRuns; i++) {
+    testAggregations(
+        vectors, {}, {"noisy_sum_gaussian(c2, 20, 12345)"}, {expectedResult});
+  }
+}
+
+TEST_F(NoisySumGaussianAggregationTest, boundsTestNoNoise) {
+  // Test easy case with lower and upper bounds.
+  auto vectors1 = {makeRowVector(
+      {makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+       makeFlatVector<int64_t>({1, 2, 3, 4, 5}),
+       makeFlatVector<double>({1.0, 2.0, 3.0, 4.0, 5.0})})};
+
+  // With lower bound = 3.0 and upper bound = 5.0
+  // Expect the result to be 18.0
+  auto expectedResult = makeRowVector({makeConstant(18.0, 1)});
+  testAggregations(
+      {vectors1},
+      {},
+      {"noisy_sum_gaussian(c2, 0.0, 3.0, 5.0)"},
+      {expectedResult});
+
+  // Test against DuckDB.
+  auto vectors2 = makeVectors(doubleRowType_, 5, 3);
+  createDuckDbTable(vectors2);
+
+  // Test double lower bound and double upper bound.
+  testAggregations(
+      vectors2,
+      {},
+      {"noisy_sum_gaussian(c2, 0.0, 0.1, 0.8)"},
+      "SELECT SUM(CASE WHEN c2 IS NOT NULL THEN GREATEST(LEAST(c2, 0.8), 0.1) END) FROM tmp");
+
+  // Test double lower bound and bigint upper bound.
+  testAggregations(
+      vectors2,
+      {},
+      {"noisy_sum_gaussian(c2, 0.0, 0.1, 800)"},
+      "SELECT SUM(CASE WHEN c2 IS NOT NULL THEN GREATEST(LEAST(c2, 800), 0.1) END) FROM tmp");
+
+  // Test bigint lower bound and double upper bound.
+  testAggregations(
+      vectors2,
+      {},
+      {"noisy_sum_gaussian(c2, 0.0, 10, 50.8)"},
+      "SELECT SUM(CASE WHEN c2 IS NOT NULL THEN GREATEST(LEAST(c2, 50.8), 10) END) FROM tmp");
+
+  // Test bigint lower bound and bigint upper bound.
+  testAggregations(
+      vectors2,
+      {},
+      {"noisy_sum_gaussian(c2, 0.0, 100, 800)"},
+      "SELECT SUM(CASE WHEN c2 IS NOT NULL THEN GREATEST(LEAST(c2, 800), 100) END) FROM tmp");
+
+  // Test lower bound > upper bound.
+  testFailingAggregations(
+      vectors2,
+      {},
+      {"noisy_sum_gaussian(c2, 0.0, 100, 80)"},
+      "Lower bound must be less than or equal to upper bound.");
+}
+
+TEST_F(NoisySumGaussianAggregationTest, boundsTestWithNoise) {
+  auto vectors = makeVectors(integerRowType_, 5, 3);
+  createDuckDbTable(vectors);
+  // Test that the noise is deterministic given the same noise_scale,
+  // random_seed. noisy_sum_gaussian(col, noise_scale, lower_bound, upper_bound,
+  // randon_seed)
+  auto expectedResult =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values(vectors)
+              .singleAggregation(
+                  {}, {"noisy_sum_gaussian(c2, 20, 10, 100, 12345)"}, {})
+              .planNode(),
+          duckDbQueryRunner_)
+          .copyResults(pool());
+
+  for (int i = 0; i < 10; i++) {
+    testAggregations(
+        vectors,
+        {},
+        {"noisy_sum_gaussian(c2, 20, 10, 100, 12345)"},
+        {expectedResult});
+  }
+}
+
+TEST_F(NoisySumGaussianAggregationTest, noisySumAndBoundConsistencyTest) {
+  // True sum of c0 is always 0.
+  auto vectors = {
+      makeRowVector({makeFlatVector<double>({0.0, 0.0, 0.0, 0.0, 0.0})})};
+
+  // Test that if upper bound <= 0, then the noisy sum is always <= 0.
+  for (int i = 0; i < 10; i++) {
+    auto result =
+        AssertQueryBuilder(
+            PlanBuilder()
+                .values(vectors)
+                .singleAggregation(
+                    {}, {"noisy_sum_gaussian(c0, 2, -2, -0.1, 12345)"}, {})
+                .planNode(),
+            duckDbQueryRunner_)
+            .copyResults(pool());
+
+    ASSERT_TRUE(result->childAt(0)->asFlatVector<double>()->valueAt(0) <= 0);
+  }
+
+  // Test that if lower bound >= 0, then the noisy sum is always >= 0.
+  for (int i = 0; i < 10; i++) {
+    auto result =
+        AssertQueryBuilder(
+            PlanBuilder()
+                .values(vectors)
+                .singleAggregation(
+                    {}, {"noisy_sum_gaussian(c0, 2, 0.1, 2, 12345)"}, {})
+                .planNode(),
+            duckDbQueryRunner_)
+            .copyResults(pool());
+
+    ASSERT_TRUE(result->childAt(0)->asFlatVector<double>()->valueAt(0) >= 0);
+  }
+}
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/NumericHistogramTest.cpp b/velox/functions/prestosql/aggregates/tests/NumericHistogramTest.cpp
new file mode 100644
index 000000000000..e4c16e04cf67
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/NumericHistogramTest.cpp
@@ -0,0 +1,633 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::aggregate::test {
+
+namespace {
+
+class NumericHistogramTest : public AggregationTestBase {
+ protected:
+  template <typename TValue>
+  void runTwoArgsTests() {
+    disableTestIncremental();
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10, 20, 30, 80, 90, 100}),
+      });
+
+      auto expectedTwoBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{20, 3}, {90, 3}},
+          }),
+      });
+      auto expectedFourBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{15, 2}, {30, 1}, {85, 2}, {100, 1}},
+          }),
+      });
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{15, 2}, {30, 1}, {80, 1}, {90, 1}, {100, 1}},
+          }),
+      });
+
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0)"},
+          {expectedFiveBuckets});
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(2, c0)"},
+          {expectedTwoBuckets});
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(4, c0)"},
+          {expectedFourBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10, 20, 30, 40, 50, 60, 70, 80}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{15.0, 2}, {35.0, 2}, {55.0, 2}, {70.0, 1}, {80.0, 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10, 50, 60, 70, 80, 90, 100}),
+      });
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{10.0, 1}, {55.0, 2}, {100.0, 1}, {75.0, 2}, {90.0, 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{10, 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10, 20, 30, 40, 50, 60, 70, 80, 90}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{15, 2}, {35.0, 2}, {55, 2}, {75, 2}, {90.0, 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({makeNullableFlatVector<TValue>(
+          {1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0})});
+
+      auto expectedFourBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{1.0, 5}, {2.0, 5}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(4, c0)"},
+          {expectedFourBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {0, 0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+               1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+               0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+               0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0,
+               0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+               0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 1, 0, 0, 1, 0, 0, 0, 0, 0, 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, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0,
+               0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+               0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+               0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{0, 285}, {1, 31}, {2, 5}},
+          }),
+      });
+
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto variousBuckets = makeRowVector({
+          makeNullableFlatVector<int64_t>({4, 3, 1, 4, 2, 1, 3, 2}),
+          makeNullableFlatVector<TValue>(
+              {1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{1.0, 4}, {2.0, 4}},
+          }),
+      });
+      testAggregations(
+          {variousBuckets},
+          {},
+          {"numeric_histogram(c0, c1)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto variousBuckets = makeRowVector({
+          makeNullableFlatVector<int64_t>({5, 3, 1, 4, 2, 1, 3, 2, 1}),
+          makeNullableFlatVector<TValue>({10, 20, 30, 40, 50, 60, 70, 80, 90}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{15, 2}, {35.0, 2}, {55, 2}, {75, 2}, {90.0, 1}},
+          }),
+      });
+      testAggregations(
+          {variousBuckets},
+          {},
+          {"numeric_histogram(c0, c1)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {std::numeric_limits<TValue>::quiet_NaN()}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{std::numeric_limits<TValue>::quiet_NaN(), 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(2, c0)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {2, std::numeric_limits<TValue>::quiet_NaN(), 2, 3}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{std::numeric_limits<TValue>::quiet_NaN(), 1}, {2, 2}, {3, 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(3, c0)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {2,
+               std::numeric_limits<TValue>::quiet_NaN(),
+               2,
+               std::numeric_limits<TValue>::infinity(),
+               2,
+               std::numeric_limits<TValue>::infinity()}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{std::numeric_limits<TValue>::quiet_NaN(), 1},
+               {2, 3},
+               {std::numeric_limits<TValue>::infinity(), 2}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(3, c0)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {std::nullopt,
+               2,
+               std::numeric_limits<TValue>::quiet_NaN(),
+               2,
+               std::numeric_limits<TValue>::infinity(),
+               2,
+               std::nullopt,
+               std::numeric_limits<TValue>::infinity()}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{std::numeric_limits<TValue>::quiet_NaN(), 1},
+               {2, 3},
+               {std::numeric_limits<TValue>::infinity(), 2}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(3, c0)"},
+          {expectedFiveBuckets});
+    }
+  }
+
+  template <typename TValue, typename TWeight>
+  void runThreeArgsTests() {
+    disableTestIncremental();
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10, 20, 30, 80, 90, 100}),
+          makeNullableFlatVector<TWeight>({2, 3, 1, 2, 1, 4}),
+      });
+
+      auto expectedTwoBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{18.333333333333332, 6}, {92.85714285714286, 7}},
+          }),
+      });
+      auto expectedFourBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{10, 2}, {22.5, 4}, {83.33333333333333, 3}, {100, 4}},
+          }),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{10, 2}, {20, 3}, {30, 1}, {100, 4}, {83.33333333333333, 3}},
+          }),
+      });
+
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(2, c0, c1)"},
+          {expectedTwoBuckets});
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(4, c0, c1)"},
+          {expectedFourBuckets});
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10, 20, 30, 40, 50, 60, 70, 80}),
+          makeNullableFlatVector<TWeight>({2, 3, 1, 4, 2, 1, 3, 2}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{10.0, 2},
+               {40.0, 4},
+               {53.333333333333336, 3},
+               {22.5, 4},
+               {74.0, 5}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10, 50, 60, 70, 80, 90, 100}),
+          makeNullableFlatVector<TWeight>({2, 2, 1, 3, 2, 1, 4}),
+      });
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{10.0, 2},
+               {53.333333333333336, 3},
+               {100.0, 4},
+               {70.0, 3},
+               {83.33333333333333, 3}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10}),
+          makeNullableFlatVector<TWeight>({2}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{10, 2}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({10, 20, 30, 40, 50, 60, 70, 80, 90}),
+          makeNullableFlatVector<TWeight>({2, 3, 1, 4, 2, 1, 3, 2, 1}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{18.333333333333332, 6},
+               {40.0, 4},
+               {53.333333333333336, 3},
+               {70, 3},
+               {83.33333333333333, 3}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(5, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0}),
+          makeNullableFlatVector<TWeight>({3, 5, 3, 5, 3, 5, 3, 5, 3, 5}),
+      });
+
+      auto expectedFourBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{1.0, 15}, {2.0, 25}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(4, c0, c1)"},
+          {expectedFourBuckets});
+    }
+    {
+      auto variousBuckets = makeRowVector({
+          makeNullableFlatVector<int64_t>({4, 3, 1, 4, 2, 1, 3, 2}),
+          makeNullableFlatVector<TValue>(
+              {1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0}),
+          makeNullableFlatVector<TWeight>({1, 1, 1, 1, 1, 1, 1, 1}),
+
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{1.0, 4}, {2.0, 4}},
+          }),
+      });
+      testAggregations(
+          {variousBuckets},
+          {},
+          {"numeric_histogram(c0, c1, c2)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto variousBuckets = makeRowVector({
+          makeNullableFlatVector<int64_t>({5, 3, 1, 4, 2, 1, 3, 2, 1}),
+          makeNullableFlatVector<TValue>({10, 20, 30, 40, 50, 60, 70, 80, 90}),
+          makeNullableFlatVector<TWeight>({1, 1, 1, 1, 1, 1, 1, 1, 1}),
+
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{15, 2}, {35.0, 2}, {55, 2}, {75, 2}, {90.0, 1}},
+          }),
+      });
+      testAggregations(
+          {variousBuckets},
+          {},
+          {"numeric_histogram(c0, c1, c2)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {std::nullopt,
+               2,
+               std::numeric_limits<TValue>::quiet_NaN(),
+               2,
+               std::numeric_limits<TValue>::infinity(),
+               2,
+               std::nullopt,
+               std::numeric_limits<TValue>::infinity()}),
+          makeNullableFlatVector<TWeight>({1, 1, 1, 1, 1, 1, 1, 1}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{std::numeric_limits<TValue>::quiet_NaN(), 1},
+               {2, 3},
+               {std::numeric_limits<TValue>::infinity(), 2}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(3, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({1, 2, 3}),
+          makeNullableFlatVector<TWeight>(
+              {std::numeric_limits<TWeight>::quiet_NaN(), 1, 1}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{1, std::numeric_limits<TValue>::quiet_NaN()}, {2.5, 2}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(2, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {std::nullopt,
+               2,
+               std::numeric_limits<TValue>::quiet_NaN(),
+               2,
+               std::numeric_limits<TValue>::infinity(),
+               2,
+               std::nullopt,
+               std::numeric_limits<TValue>::infinity()}),
+          makeNullableFlatVector<TWeight>(
+              {1,
+               std::nullopt,
+               1,
+               std::nullopt,
+               1,
+               std::nullopt,
+               1,
+               std::nullopt}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{std::numeric_limits<TValue>::quiet_NaN(), 1},
+               {std::numeric_limits<TValue>::infinity(), 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(3, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+    // Java implementation has some correctness issues and will fail this test
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>(
+              {std::numeric_limits<TValue>::quiet_NaN(),
+               2,
+               std::numeric_limits<TValue>::quiet_NaN()}),
+          makeNullableFlatVector<TWeight>({1, 1, 1}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{std::numeric_limits<TValue>::quiet_NaN(), 2}, {2, 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(2, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+    {
+      auto valuesAndWeights = makeRowVector({
+          makeNullableFlatVector<TValue>({1, -1, 50}),
+          makeNullableFlatVector<TWeight>({-1, 1, 1}),
+      });
+
+      auto expectedFiveBuckets = makeRowVector({
+          makeMapVector<TValue, TValue>({
+              {{-std::numeric_limits<TValue>::infinity(), 0}, {50, 1}},
+          }),
+      });
+      testAggregations(
+          {valuesAndWeights},
+          {},
+          {"numeric_histogram(2, c0, c1)"},
+          {expectedFiveBuckets});
+    }
+  }
+};
+
+TEST_F(NumericHistogramTest, twoArgsDouble) {
+  runTwoArgsTests<double>();
+}
+
+TEST_F(NumericHistogramTest, twoArgsFloat) {
+  runTwoArgsTests<float>();
+}
+
+TEST_F(NumericHistogramTest, threeArgsDoubleDouble) {
+  runThreeArgsTests<double, double>();
+}
+
+TEST_F(NumericHistogramTest, threeArgsDoubleFloat) {
+  runThreeArgsTests<double, float>();
+}
+
+TEST_F(NumericHistogramTest, threeArgsFloatDouble) {
+  runThreeArgsTests<float, double>();
+}
+
+TEST_F(NumericHistogramTest, threeArgsFloatFloat) {
+  runThreeArgsTests<float, float>();
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp b/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
index 2f38263e52de..4f6d4ab1eac5 100644
--- a/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/PrestoHasherTest.cpp
@@ -433,7 +433,7 @@ TEST_F(PrestoHasherTest, timestampWithTimezone) {
 }
 
 TEST_F(PrestoHasherTest, ipAddress) {
-  auto makeIpAdressFromString = [](const std::string& ipAddr) -> int128_t {
+  auto makeIpAdressFromString = [](std::string_view ipAddr) -> int128_t {
     auto ret = ipaddress::tryGetIPv6asInt128FromString(ipAddr);
     return ret.value();
   };
diff --git a/velox/functions/prestosql/aggregates/tests/QDigestAggTest.cpp b/velox/functions/prestosql/aggregates/tests/QDigestAggTest.cpp
new file mode 100644
index 000000000000..9e26a1f4b52a
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/QDigestAggTest.cpp
@@ -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.
+ */
+#include <folly/base64.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/exec/Aggregate.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+
+// using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::aggregate::test {
+namespace {
+class QDigestAggTest : public AggregationTestBase {
+ protected:
+  const std::vector<bool> kGroupByKeys{false, false, false, true, true, true};
+  const std::vector<int64_t> kWeights{1, 2, 3, 4, 5, 6};
+  const double kAccuracy = 0.75;
+
+  template <typename T>
+  void testThrow(
+      const std::vector<T>& inputs,
+      const std::vector<double>& accuracies) {
+    auto type = CppToType<T>::create();
+    auto inputVector = makeRowVector(
+        {makeFlatVector<T>(inputs), makeFlatVector<double>(accuracies)});
+    auto dummyExpected = makeRowVector(
+        {makeExpectedVector({inputs.size(), std::nullopt}, type)});
+    testAggregations(
+        {inputVector}, {}, {"qdigest_agg(c0, 1, c1)"}, {dummyExpected});
+  }
+
+  template <typename T>
+  void testQDigestAgg(
+      const std::vector<T>& inputs,
+      const std::optional<std::vector<bool>>& groupByKeys,
+      const std::vector<std::optional<std::string>>& expected,
+      const std::optional<std::vector<int64_t>>& weights = std::nullopt,
+      std::optional<double> accuracy = std::nullopt) {
+    auto type = CppToType<T>::create();
+    std::vector<std::string> inputNames{"c0"};
+    std::vector<VectorPtr> inputVectors{makeFlatVector<T>(inputs)};
+    std::vector<VectorPtr> expectedVectors{};
+    std::vector<std::string> groupByNames{};
+    auto call = "qdigest_agg(c0)";
+    if (groupByKeys.has_value()) {
+      inputNames.emplace_back("g0");
+      inputVectors.emplace_back(makeFlatVector<bool>(groupByKeys.value()));
+      expectedVectors.emplace_back(makeFlatVector<bool>({false, true}));
+      groupByNames.emplace_back("g0");
+    }
+    if (weights.has_value()) {
+      inputNames.emplace_back("c1");
+      inputVectors.emplace_back(makeFlatVector<int64_t>(weights.value()));
+      call = "qdigest_agg(c0, c1)";
+    }
+    if (accuracy.has_value()) {
+      inputNames.emplace_back("c2");
+      inputVectors.emplace_back(
+          makeConstant<double>(accuracy.value(), inputs.size()));
+      call = "qdigest_agg(c0, c1, c2)";
+    }
+
+    auto inputVector = makeRowVector(inputNames, inputVectors);
+    expectedVectors.emplace_back(makeExpectedVector(expected, type));
+    auto expectedRowVector = makeRowVector(expectedVectors);
+    testAggregations({inputVector}, groupByNames, {call}, {expectedRowVector});
+  }
+
+ private:
+  VectorPtr makeExpectedVector(
+      const std::vector<std::optional<std::string>>& expected,
+      const TypePtr& type) {
+    std::vector<std::optional<std::string>> decodedExpected;
+    decodedExpected.reserve(expected.size());
+    for (const auto& value : expected) {
+      decodedExpected.emplace_back(decodeBase64(value));
+    }
+    return makeNullableFlatVector<std::string>(
+        decodedExpected, facebook::velox::QDigestType::get(type));
+  }
+
+  std::optional<std::string> decodeBase64(
+      const std::optional<std::string>& encoded) {
+    if (!encoded.has_value()) {
+      return std::nullopt;
+    }
+    std::string decoded(folly::base64DecodedSize(encoded.value()), '\0');
+    folly::base64Decode(encoded.value(), decoded.data());
+    return decoded;
+  }
+};
+
+TEST_F(QDigestAggTest, metadata) {
+  core::QueryConfig config{{}};
+  auto function = exec::Aggregate::create(
+      "qdigest_agg",
+      core::AggregationNode::Step::kSingle,
+      {BIGINT()},
+      QDIGEST(BIGINT()),
+      config);
+  EXPECT_FALSE(function->isFixedSize());
+  EXPECT_FALSE(function->accumulatorUsesExternalMemory());
+  EXPECT_EQ(function->accumulatorAlignmentSize(), 8);
+}
+
+TEST_F(QDigestAggTest, basic) {
+  testQDigestAgg<int64_t>(
+      {1, 2, 3, 4, 5, 6},
+      std::nullopt,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAABgAAAAAAAAALAAAAAAAAAAAAAPA/AQAAAAAAAIAAAAAAAAAA8D8CAAAAAAAAgAAAAAAAAADwPwMAAAAAAACAAwAAAAAAAAAAAgAAAAAAAIAHAAAAAAAAAAABAAAAAAAAgAAAAAAAAADwPwQAAAAAAACAAAAAAAAAAPA/BQAAAAAAAIADAAAAAAAAAAAEAAAAAAAAgAAAAAAAAADwPwYAAAAAAACABwAAAAAAAAAABAAAAAAAAIALAAAAAAAAAAABAAAAAAAAgA=="});
+  testQDigestAgg<float>(
+      {1.0, 2.0, 3.0, 4.0, 5.0, 6.0},
+      std::nullopt,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAAAAgD8AAAAAAADAQAAAAAALAAAAAAAAAAAAAPA/AACAPwAAAIAAAAAAAAAA8D8AAABAAAAAgAAAAAAAAADwPwAAQEAAAACAWwAAAAAAAAAAAAAAQAAAAIAAAAAAAAAA8D8AAIBAAAAAgAAAAAAAAADwPwAAoEAAAACAVwAAAAAAAAAAAACAQAAAAIAAAAAAAAAA8D8AAMBAAAAAgFsAAAAAAAAAAAAAgEAAAACAXwAAAAAAAAAAAAAAQAAAAIB7AAAAAAAAAAAAAIA/AAAAgA=="});
+  testQDigestAgg<double>(
+      {1.0, 2.0, 3.0, 4.0, 5.0, 6.0},
+      std::nullopt,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPA/AAAAAAAAGEALAAAAAAAAAAAAAPA/AAAAAAAA8L8AAAAAAAAA8D8AAAAAAAAAwAAAAAAAAADwPwAAAAAAAAjAzwAAAAAAAAAAAAAAAAAAAMAAAAAAAAAA8D8AAAAAAAAQwAAAAAAAAADwPwAAAAAAABTAywAAAAAAAAAAAAAAAAAAEMAAAAAAAAAA8D8AAAAAAAAYwM8AAAAAAAAAAAAAAAAAABDA0wAAAAAAAAAAAAAAAAAAAMD7AAAAAAAAAAAAAAAAAADwvw=="});
+
+  testQDigestAgg<int64_t>(
+      {-1, -2, 3, -4, 5, -6},
+      kGroupByKeys,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP7/////////AwAAAAAAAAAFAAAAAAAAAAAAAPA//v///////38AAAAAAAAA8D//////////fwMAAAAAAAAAAP////////9/AAAAAAAAAPA/AwAAAAAAAID/AAAAAAAAAAD/////////fw==",
+       "AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAPr/////////BQAAAAAAAAAFAAAAAAAAAAAAAPA/+v///////38AAAAAAAAA8D/8////////fwsAAAAAAAAAAPz///////9/AAAAAAAAAPA/BQAAAAAAAID/AAAAAAAAAAD8////////fw=="});
+  testQDigestAgg<float>(
+      {-1.0, -2.0, 3.0, -4.0, 5.0, -6.0},
+      kGroupByKeys,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP///7//////AABAQAAAAAAFAAAAAAAAAAAAAPA/////v////38AAAAAAAAA8D///3/A////f3sAAAAAAAAAAP//f8D///9/AAAAAAAAAPA/AABAQAAAAID/AAAAAAAAAAD//3/A////fw==",
+       "AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP//P7//////AACgQAAAAAAFAAAAAAAAAAAAAPA///8/v////38AAAAAAAAA8D///3+/////f1sAAAAAAAAAAP//f7////9/AAAAAAAAAPA/AACgQAAAAID/AAAAAAAAAAD//3+/////fw=="});
+  testQDigestAgg<double>(
+      {-1.0, -2.0, 3.0, -4.0, 5.0, -6.0},
+      kGroupByKeys,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP////////+/AAAAAAAACEAFAAAAAAAAAAAAAPA//////////z8AAAAAAAAA8D////////8PQPsAAAAAAAAAAP///////w9AAAAAAAAAAPA/AAAAAAAACMD/AAAAAAAAAAD///////8PQA==",
+       "AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP///////+e/AAAAAAAAFEAFAAAAAAAAAAAAAPA/////////5z8AAAAAAAAA8D/////////vP88AAAAAAAAAAP///////+8/AAAAAAAAAPA/AAAAAAAAFMD/AAAAAAAAAAD////////vPw=="});
+}
+
+TEST_F(QDigestAggTest, withWeights) {
+  testQDigestAgg<int64_t>(
+      {1, 2, 3, 4, 5, 6},
+      std::nullopt,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAABgAAAAAAAAALAAAAAAAAAAAAAPA/AQAAAAAAAIAAAAAAAAAAAEACAAAAAAAAgAAAAAAAAAAIQAMAAAAAAACAAwAAAAAAAAAAAgAAAAAAAIAHAAAAAAAAAAABAAAAAAAAgAAAAAAAAAAQQAQAAAAAAACAAAAAAAAAABRABQAAAAAAAIADAAAAAAAAAAAEAAAAAAAAgAAAAAAAAAAYQAYAAAAAAACABwAAAAAAAAAABAAAAAAAAIALAAAAAAAAAAABAAAAAAAAgA=="},
+      kWeights);
+  testQDigestAgg<float>(
+      {1.0, 2.0, 3.0, 4.0, 5.0, 6.0},
+      std::nullopt,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAAAAgD8AAAAAAADAQAAAAAALAAAAAAAAAAAAAPA/AACAPwAAAIAAAAAAAAAAAEAAAABAAAAAgAAAAAAAAAAIQAAAQEAAAACAWwAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAEEAAAIBAAAAAgAAAAAAAAAAUQAAAoEAAAACAVwAAAAAAAAAAAACAQAAAAIAAAAAAAAAAGEAAAMBAAAAAgFsAAAAAAAAAAAAAgEAAAACAXwAAAAAAAAAAAAAAQAAAAIB7AAAAAAAAAAAAAIA/AAAAgA=="},
+      kWeights);
+  testQDigestAgg<double>(
+      {1.0, 2.0, 3.0, 4.0, 5.0, 6.0},
+      std::nullopt,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPA/AAAAAAAAGEALAAAAAAAAAAAAAPA/AAAAAAAA8L8AAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAIQAAAAAAAAAjAzwAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAEEAAAAAAAAAQwAAAAAAAAAAUQAAAAAAAABTAywAAAAAAAAAAAAAAAAAAEMAAAAAAAAAAGEAAAAAAAAAYwM8AAAAAAAAAAAAAAAAAABDA0wAAAAAAAAAAAAAAAAAAAMD7AAAAAAAAAAAAAAAAAADwvw=="},
+      kWeights);
+
+  testQDigestAgg<int64_t>(
+      {-1, -2, 3, -4, 5, -6},
+      kGroupByKeys,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP7/////////AwAAAAAAAAAFAAAAAAAAAAAAAABA/v///////38AAAAAAAAA8D//////////fwMAAAAAAAAAAP////////9/AAAAAAAAAAhAAwAAAAAAAID/AAAAAAAAAAD/////////fw==",
+       "AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAPr/////////BQAAAAAAAAAFAAAAAAAAAAAAABhA+v///////38AAAAAAAAAEED8////////fwsAAAAAAAAAAPz///////9/AAAAAAAAABRABQAAAAAAAID/AAAAAAAAAAD8////////fw=="},
+      kWeights);
+  testQDigestAgg<float>(
+      {-1, -2, 3, -4, 5, -6},
+      kGroupByKeys,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP///7//////AABAQAAAAAAFAAAAAAAAAAAAAABA////v////38AAAAAAAAA8D///3/A////f3sAAAAAAAAAAP//f8D///9/AAAAAAAAAAhAAABAQAAAAID/AAAAAAAAAAD//3/A////fw==",
+       "AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP//P7//////AACgQAAAAAAFAAAAAAAAAAAAABhA//8/v////38AAAAAAAAAEED//3+/////f1sAAAAAAAAAAP//f7////9/AAAAAAAAABRAAACgQAAAAID/AAAAAAAAAAD//3+/////fw=="},
+      kWeights);
+  testQDigestAgg<double>(
+      {-1, -2, 3, -4, 5, -6},
+      kGroupByKeys,
+      {"AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP////////+/AAAAAAAACEAFAAAAAAAAAAAAAABA/////////z8AAAAAAAAA8D////////8PQPsAAAAAAAAAAP///////w9AAAAAAAAAAAhAAAAAAAAACMD/AAAAAAAAAAD///////8PQA==",
+       "AHsUrkfheoQ/AAAAAAAAAAAAAAAAAAAAAP///////+e/AAAAAAAAFEAFAAAAAAAAAAAAABhA////////5z8AAAAAAAAAEED////////vP88AAAAAAAAAAP///////+8/AAAAAAAAABRAAAAAAAAAFMD/AAAAAAAAAAD////////vPw=="},
+      kWeights);
+}
+
+TEST_F(QDigestAggTest, withAccuracy) {
+  testQDigestAgg<int64_t>(
+      {1, 2, 3, 4, 5, 6},
+      std::nullopt,
+      {"AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAABgAAAAAAAAAJAAAAAAAAAAAAAABAAgAAAAAAAIAAAAAAAAAACEADAAAAAAAAgAMAAAAAAAAAAAIAAAAAAACAAAAAAAAAABBABAAAAAAAAIAAAAAAAAAAFEAFAAAAAAAAgAMAAAAAAAAAAAQAAAAAAACAAAAAAAAAABhABgAAAAAAAIAHAAAAAAAAAAAEAAAAAAAAgAsAAAAAAADwPwEAAAAAAACA"},
+      kWeights,
+      kAccuracy);
+  testQDigestAgg<float>(
+      {1, 2, 3, 4, 5, 6},
+      std::nullopt,
+      {"AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAAAAgD8AAAAAAADAQAAAAAALAAAAAAAAAAAAAPA/AACAPwAAAIAAAAAAAAAAAEAAAABAAAAAgAAAAAAAAAAIQAAAQEAAAACAWwAAAAAAAAAAAAAAQAAAAIAAAAAAAAAAEEAAAIBAAAAAgAAAAAAAAAAUQAAAoEAAAACAVwAAAAAAAAAAAACAQAAAAIAAAAAAAAAAGEAAAMBAAAAAgFsAAAAAAAAAAAAAgEAAAACAXwAAAAAAAAAAAAAAQAAAAIB7AAAAAAAAAAAAAIA/AAAAgA=="},
+      kWeights,
+      kAccuracy);
+  testQDigestAgg<double>(
+      {1, 2, 3, 4, 5, 6},
+      std::nullopt,
+      {"AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPA/AAAAAAAAGEALAAAAAAAAAAAAAPA/AAAAAAAA8L8AAAAAAAAAAEAAAAAAAAAAwAAAAAAAAAAIQAAAAAAAAAjAzwAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAEEAAAAAAAAAQwAAAAAAAAAAUQAAAAAAAABTAywAAAAAAAAAAAAAAAAAAEMAAAAAAAAAAGEAAAAAAAAAYwM8AAAAAAAAAAAAAAAAAABDA0wAAAAAAAAAAAAAAAAAAAMD7AAAAAAAAAAAAAAAAAADwvw=="},
+      kWeights,
+      kAccuracy);
+
+  testQDigestAgg<int64_t>(
+      {-1, -2, 3, -4, 5, -6},
+      kGroupByKeys,
+      {"AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAP7/////////AwAAAAAAAAAFAAAAAAAAAAAAAABA/v///////38AAAAAAAAA8D//////////fwMAAAAAAAAAAP////////9/AAAAAAAAAAhAAwAAAAAAAID/AAAAAAAAAAD/////////fw==",
+       "AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAPr/////////BQAAAAAAAAAFAAAAAAAAAAAAABhA+v///////38AAAAAAAAAEED8////////fwsAAAAAAAAAAPz///////9/AAAAAAAAABRABQAAAAAAAID/AAAAAAAAAAD8////////fw=="},
+      kWeights,
+      kAccuracy);
+  testQDigestAgg<float>(
+      {-1, -2, 3, -4, 5, -6},
+      kGroupByKeys,
+      {"AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAP///7//////AABAQAAAAAAFAAAAAAAAAAAAAABA////v////38AAAAAAAAA8D///3/A////f3sAAAAAAAAAAP//f8D///9/AAAAAAAAAAhAAABAQAAAAID/AAAAAAAAAAD//3/A////fw==",
+       "AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAP//P7//////AACgQAAAAAAFAAAAAAAAAAAAABhA//8/v////38AAAAAAAAAEED//3+/////f1sAAAAAAAAAAP//f7////9/AAAAAAAAABRAAACgQAAAAID/AAAAAAAAAAD//3+/////fw=="},
+      kWeights,
+      kAccuracy);
+  testQDigestAgg<double>(
+      {-1, -2, 3, -4, 5, -6},
+      kGroupByKeys,
+      {"AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAP////////+/AAAAAAAACEAFAAAAAAAAAAAAAABA/////////z8AAAAAAAAA8D////////8PQPsAAAAAAAAAAP///////w9AAAAAAAAAAAhAAAAAAAAACMD/AAAAAAAAAAD///////8PQA==",
+       "AAAAAAAAAOg/AAAAAAAAAAAAAAAAAAAAAP///////+e/AAAAAAAAFEAFAAAAAAAAAAAAABhA////////5z8AAAAAAAAAEED////////vP88AAAAAAAAAAP///////+8/AAAAAAAAABRAAAAAAAAAFMD/AAAAAAAAAAD////////vPw=="},
+      kWeights,
+      kAccuracy);
+}
+
+TEST_F(QDigestAggTest, emptyInput) {
+  testQDigestAgg<int64_t>({}, std::nullopt, {std::nullopt});
+  testQDigestAgg<float>({}, std::nullopt, {std::nullopt});
+  testQDigestAgg<double>({}, std::nullopt, {std::nullopt});
+}
+
+TEST_F(QDigestAggTest, invalid) {
+  VELOX_ASSERT_THROW(
+      testThrow<int64_t>({1, 2}, {0.1, 0.2}),
+      "accuracy must be the same for all rows in the group");
+  VELOX_ASSERT_THROW(
+      testThrow<float>({1, 2}, {0.1, 0.2}),
+      "accuracy must be the same for all rows in the group");
+  VELOX_ASSERT_THROW(
+      testThrow<double>({1, 2}, {0.1, 0.2}),
+      "accuracy must be the same for all rows in the group");
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/ReservoirSampleTest.cpp b/velox/functions/prestosql/aggregates/tests/ReservoirSampleTest.cpp
new file mode 100644
index 000000000000..002dca17ba76
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/ReservoirSampleTest.cpp
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::aggregate::prestosql {
+
+namespace {
+
+class ReservoirSampleTest : public AggregationTestBase {
+ protected:
+  RowVectorPtr makeResultDouble(
+      int64_t seenCount,
+      const std::vector<std::optional<double>>& sample) {
+    std::vector<std::optional<std::vector<std::optional<double>>>> data = {
+        sample};
+    return makeRowVector({makeRowVector({
+        makeFlatVector<int64_t>({seenCount}),
+        makeNullableArrayVector<double>(data),
+    })});
+  }
+
+  VectorPtr makeNullArray(int count, const TypePtr& elementType) {
+    auto arrayType = ARRAY(elementType);
+    auto builder = BaseVector::create(arrayType, count, pool());
+    for (int i = 0; i < count; i++) {
+      builder->setNull(i, true);
+    }
+    return builder;
+  }
+
+  template <typename T>
+  VectorPtr makeFlatConstantVector(T value, int count) {
+    return makeFlatVector<T>(std::vector<T>(count, value));
+  }
+};
+
+TEST_F(ReservoirSampleTest, testNoInitialSample) {
+  auto data = makeRowVector({
+      makeNullArray(5, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  auto expected = makeResultDouble(5L, {1.0, 1.0});
+
+  testAggregations(
+      {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(ReservoirSampleTest, testLarge) {
+  const int sampleSize = 5000;
+  const int inputSize = 15000;
+
+  std::vector<double> inputValues(inputSize, 1.0);
+  std::vector<std::optional<double>> expectedSample(sampleSize, 1.0);
+
+  auto data = makeRowVector({
+      makeNullArray(inputSize, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, inputSize),
+      makeFlatVector<double>(inputValues),
+      makeFlatConstantVector<int32_t>(sampleSize, inputSize),
+  });
+
+  auto expected =
+      makeResultDouble(static_cast<int64_t>(inputSize), expectedSample);
+
+  testAggregations(
+      {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(ReservoirSampleTest, testInvalidSampleSizeZero) {
+  auto data = makeRowVector({
+      makeNullArray(5, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(0, 5),
+  });
+
+  EXPECT_THROW(
+      testAggregations(
+          {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, "Throws exception"),
+      VeloxException);
+}
+
+TEST_F(ReservoirSampleTest, testInvalidSampleSizeNegative) {
+  auto data = makeRowVector({
+      makeNullArray(5, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(-1, 5),
+  });
+
+  EXPECT_THROW(
+      testAggregations(
+          {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, "Throws exception"),
+      VeloxException);
+}
+
+TEST_F(ReservoirSampleTest, testInitialSampleSameSize) {
+  auto data = makeRowVector({
+      makeArrayVector<double>(
+          {std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0}}),
+      makeFlatConstantVector<int64_t>(10, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  auto expected = makeResultDouble(15L, {1.0, 1.0});
+
+  testAggregations(
+      {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(ReservoirSampleTest, testInitialSampleWrongSize) {
+  auto data = makeRowVector({
+      makeArrayVector<double>(
+          {std::vector<double>{1.0, 1.0, 2.0},
+           std::vector<double>{1.0, 1.0, 2.0},
+           std::vector<double>{1.0, 1.0, 2.0},
+           std::vector<double>{1.0, 1.0, 2.0},
+           std::vector<double>{1.0, 1.0, 2.0}}),
+      makeFlatConstantVector<int64_t>(10, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  EXPECT_THROW(
+      testAggregations(
+          {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, "Throws exception"),
+      VeloxException);
+}
+
+TEST_F(ReservoirSampleTest, testInitialSampleSmallerThanMaxSize) {
+  auto data = makeRowVector({
+      makeArrayVector<double>(
+          {std::vector<double>{1.0},
+           std::vector<double>{1.0},
+           std::vector<double>{1.0},
+           std::vector<double>{1.0},
+           std::vector<double>{1.0}}),
+      makeFlatConstantVector<int64_t>(1, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  auto expected = makeResultDouble(6L, {1.0, 1.0});
+
+  testAggregations(
+      {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, {expected});
+}
+
+TEST_F(
+    ReservoirSampleTest,
+    testInitialSampleSeenCountSmallerThanInitialSample) {
+  auto data = makeRowVector({
+      makeArrayVector<double>(
+          {std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0},
+           std::vector<double>{1.0, 1.0}}),
+      makeFlatConstantVector<int64_t>(1, 5),
+      makeFlatVector<double>({1.0, 1.0, 1.0, 1.0, 1.0}),
+      makeFlatConstantVector<int32_t>(2, 5),
+  });
+
+  EXPECT_THROW(
+      testAggregations(
+          {data}, {}, {"reservoir_sample(c0, c1, c2, c3)"}, "Throws exception"),
+      VeloxException);
+}
+
+TEST_F(ReservoirSampleTest, testValidResults) {
+  auto data = makeRowVector({
+      makeNullArray(10, DOUBLE()),
+      makeFlatConstantVector<int64_t>(0, 10),
+      makeFlatVector<double>(
+          {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}),
+      makeFlatConstantVector<int32_t>(4, 10),
+  });
+
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({data})
+              .singleAggregation({}, {"reservoir_sample(c0, c1, c2, c3)"})
+              .planNode())
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto rowResult = result->childAt(0)->as<RowVector>();
+  ASSERT_EQ(rowResult->size(), 1);
+
+  auto processedCount =
+      rowResult->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0);
+  EXPECT_EQ(processedCount, 10L);
+
+  auto sampleArray = rowResult->childAt(1)->as<ArrayVector>();
+  ASSERT_EQ(sampleArray->size(), 1);
+
+  auto sampleSize = sampleArray->sizeAt(0);
+  EXPECT_EQ(sampleSize, 4);
+
+  std::set<double> allValues = {
+      0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
+  auto sampleElements = sampleArray->elements()->as<FlatVector<double>>();
+  auto offset = sampleArray->offsetAt(0);
+
+  for (int i = 0; i < sampleSize; i++) {
+    double value = sampleElements->valueAt(offset + i);
+    EXPECT_TRUE(allValues.count(value) > 0)
+        << "Sample contains value " << value << " which is not in input set";
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::aggregate::prestosql
diff --git a/velox/functions/prestosql/aggregates/tests/SetDigestAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/SetDigestAggregateTest.cpp
new file mode 100644
index 000000000000..d0da19cccd94
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/SetDigestAggregateTest.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/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/lib/SetDigest.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+
+using namespace facebook::velox::exec::test;
+using namespace facebook::velox::functions::aggregate::test;
+using namespace facebook::velox::functions;
+
+namespace facebook::velox::aggregate::test {
+
+namespace {
+
+using SetDigestType = functions::SetDigest<int64_t>;
+
+class SetDigestAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+    registerSetDigestType();
+  }
+
+  // Helper to deserialize and verify a SetDigest result.
+  void verifySetDigest(
+      const RowVectorPtr& result,
+      int64_t expectedCardinality,
+      bool expectExact = true,
+      int32_t rowIndex = 0) {
+    ASSERT_LT(rowIndex, result->size());
+    auto resultVector = result->childAt(result->type()->size() - 1)
+                            ->as<FlatVector<StringView>>();
+    ASSERT_FALSE(resultVector->isNullAt(rowIndex));
+
+    auto serialized = resultVector->valueAt(rowIndex);
+    auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+    SetDigestType digest(allocator.get());
+    auto status = digest.deserialize(serialized.data(), serialized.size());
+    ASSERT_TRUE(status.ok()) << status.message();
+
+    EXPECT_EQ(digest.cardinality(), expectedCardinality);
+    if (expectExact) {
+      EXPECT_TRUE(digest.isExact());
+    }
+  }
+
+  // Helper to verify result is null.
+  void verifySetDigestNull(const RowVectorPtr& result, int32_t rowIndex = 0) {
+    ASSERT_LT(rowIndex, result->size());
+    auto resultVector = result->childAt(result->type()->size() - 1)
+                            ->as<FlatVector<StringView>>();
+    EXPECT_TRUE(resultVector->isNullAt(rowIndex));
+  }
+
+  // Helper to create a serialized SetDigest from int64_t values.
+  std::string serializeSetDigest(const std::vector<int64_t>& values) {
+    auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+    SetDigestType digest(allocator.get());
+    for (auto value : values) {
+      digest.add(value);
+    }
+    auto size = digest.estimatedSerializedSize();
+    std::string buffer(size, '\0');
+    digest.serialize(buffer.data());
+    return buffer;
+  }
+
+  // Helper to run make_set_digest and get result.
+  RowVectorPtr runMakeSetDigest(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys = {}) {
+    auto op = PlanBuilder()
+                  .values(input)
+                  .singleAggregation(groupingKeys, {"make_set_digest(c0)"})
+                  .planNode();
+    return AssertQueryBuilder(op).copyResults(pool());
+  }
+
+  // Helper to run merge_set_digest and get result.
+  RowVectorPtr runMergeSetDigest(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<std::string>& groupingKeys = {}) {
+    auto op = PlanBuilder()
+                  .values(input)
+                  .project({"cast(a0 as setdigest)"})
+                  .singleAggregation(groupingKeys, {"merge_set_digest(p0)"})
+                  .planNode();
+    return AssertQueryBuilder(op).copyResults(pool());
+  }
+};
+
+TEST_F(SetDigestAggregateTest, intValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int64_t>({1, 1, 1, 2, 2, 3, 3, 3, 3}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, withNullValues) {
+  auto vectors = makeRowVector({
+      makeNullableFlatVector<int64_t>(
+          {1, std::nullopt, 2, std::nullopt, 3, std::nullopt, 1}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, allNullValues) {
+  auto vectors = makeRowVector({
+      makeNullableFlatVector<int64_t>(
+          {std::nullopt, std::nullopt, std::nullopt}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigestNull(result);
+}
+
+TEST_F(SetDigestAggregateTest, emptyInput) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int64_t>({}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigestNull(result);
+}
+
+TEST_F(SetDigestAggregateTest, stringValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<std::string>(
+          {"apple",
+           "banana",
+           "apple",
+           "cherry",
+           "banana",
+           "a longer string with more than 12 characters",
+           "another extended string for testing",
+           "a longer string with more than 12 characters"}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 5);
+}
+
+TEST_F(SetDigestAggregateTest, groupBy) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2, 1, 2}),
+      makeFlatVector<int64_t>({10, 20, 30, 40, 10, 30}),
+  });
+
+  auto op = PlanBuilder()
+                .values({vectors})
+                .singleAggregation({"c0"}, {"make_set_digest(c1)"})
+                .planNode();
+
+  auto result = AssertQueryBuilder(op).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 2);
+
+  auto groupVector = result->childAt(0)->as<FlatVector<int32_t>>();
+  auto digestVector = result->childAt(1)->as<FlatVector<StringView>>();
+
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+
+  for (auto i = 0; i < result->size(); ++i) {
+    auto group = groupVector->valueAt(i);
+    auto serialized = digestVector->valueAt(i);
+
+    SetDigestType digest(allocator.get());
+    auto status = digest.deserialize(serialized.data(), serialized.size());
+    ASSERT_TRUE(status.ok()) << status.message();
+
+    if (group == 1) {
+      EXPECT_EQ(digest.cardinality(), 2);
+      EXPECT_TRUE(digest.isExact());
+    } else if (group == 2) {
+      EXPECT_EQ(digest.cardinality(), 2);
+      EXPECT_TRUE(digest.isExact());
+    }
+  }
+}
+
+TEST_F(SetDigestAggregateTest, differentNumericTypes) {
+  auto testType = [&](const std::string& typeStr, auto makeVector) {
+    auto result = runMakeSetDigest({makeRowVector({makeVector})});
+    verifySetDigest(result, 3);
+  };
+
+  testType("TINYINT", makeFlatVector<int8_t>({1, 2, 3, 1, 2}));
+  testType("SMALLINT", makeFlatVector<int16_t>({1, 2, 3, 1, 2}));
+  testType("INTEGER", makeFlatVector<int32_t>({1, 2, 3, 1, 2}));
+  testType("BIGINT", makeFlatVector<int64_t>({1, 2, 3, 1, 2}));
+}
+
+TEST_F(SetDigestAggregateTest, largeExactSet) {
+  std::vector<int64_t> values;
+  values.reserve(1000);
+  for (int64_t i = 0; i < 1000; ++i) {
+    values.push_back(i);
+  }
+
+  auto result =
+      runMakeSetDigest({makeRowVector({makeFlatVector<int64_t>(values)})});
+  verifySetDigest(result, 1000);
+}
+
+TEST_F(SetDigestAggregateTest, largeApproximateSet) {
+  std::vector<int64_t> values;
+  values.reserve(50000);
+  for (int64_t i = 0; i < 50000; ++i) {
+    values.push_back(i);
+  }
+
+  auto result =
+      runMakeSetDigest({makeRowVector({makeFlatVector<int64_t>(values)})});
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType digest(allocator.get());
+  ASSERT_TRUE(digest.deserialize(serialized.data(), serialized.size()).ok());
+
+  EXPECT_FALSE(digest.isExact());
+
+  auto estimatedCardinality = digest.cardinality();
+  double errorRate = std::abs(estimatedCardinality - 50000) / 50000.0;
+
+  EXPECT_LT(errorRate, 0.05)
+      << "HLL estimate should be within 5% of actual. "
+      << "Actual: 50000, Estimated: " << estimatedCardinality;
+}
+
+TEST_F(SetDigestAggregateTest, partialAggregation) {
+  auto vectors = {
+      makeRowVector({makeFlatVector<int64_t>({1, 2, 3})}),
+      makeRowVector({makeFlatVector<int64_t>({3, 4, 5})}),
+      makeRowVector({makeFlatVector<int64_t>({5, 6, 7})}),
+  };
+
+  auto result = AssertQueryBuilder(
+                    PlanBuilder()
+                        .values(vectors)
+                        .partialAggregation({}, {"make_set_digest(c0)"})
+                        .intermediateAggregation()
+                        .finalAggregation()
+                        .planNode())
+                    .copyResults(pool());
+
+  verifySetDigest(result, 7);
+}
+
+TEST_F(SetDigestAggregateTest, roundTripSerialization) {
+  auto result = runMakeSetDigest(
+      {makeRowVector({makeFlatVector<int64_t>({1, 2, 3, 4, 5})})});
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType digest1(allocator.get());
+  ASSERT_TRUE(digest1.deserialize(serialized.data(), serialized.size()).ok());
+
+  auto size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  SetDigestType digest2(allocator.get());
+  ASSERT_TRUE(digest2.deserialize(buffer1.data(), size1).ok());
+
+  auto size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  EXPECT_EQ(size1, size2);
+  EXPECT_EQ(
+      std::string(buffer1.begin(), buffer1.end()),
+      std::string(buffer2.begin(), buffer2.end()));
+}
+
+TEST_F(SetDigestAggregateTest, booleanValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<bool>({true, false, true, false, true}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 2);
+}
+
+TEST_F(SetDigestAggregateTest, javaCompatibilityInteger) {
+  // Tests serialization/deserialization round-trip to ensure compatibility
+  // with Java implementation. Unlike other tests which only verify
+  // cardinality, this explicitly tests that the serialized format can be
+  // deserialized correctly (serialize → deserialize → verify).
+  auto result = runMakeSetDigest(
+      {makeRowVector({makeFlatVector<int64_t>({1, 1, 1, 2, 2})})});
+
+  verifySetDigest(result, 2);
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+
+  SetDigestType digest(allocator.get());
+  ASSERT_TRUE(digest.deserialize(serialized.data(), serialized.size()).ok());
+
+  auto size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  SetDigestType digest2(allocator.get());
+  ASSERT_TRUE(digest2.deserialize(buffer.data(), size).ok());
+  EXPECT_EQ(digest2.cardinality(), 2);
+}
+
+TEST_F(SetDigestAggregateTest, javaCompatibilityString) {
+  auto result = runMakeSetDigest(
+      {makeRowVector({makeFlatVector<std::string>({"abc", "def"})})});
+
+  verifySetDigest(result, 2);
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+
+  SetDigestType digest(allocator.get());
+  ASSERT_TRUE(digest.deserialize(serialized.data(), serialized.size()).ok());
+
+  auto size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  SetDigestType digest2(allocator.get());
+  ASSERT_TRUE(digest2.deserialize(buffer.data(), size).ok());
+  EXPECT_EQ(digest2.cardinality(), 2);
+}
+
+TEST_F(SetDigestAggregateTest, floatValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<float>({1.2f, 2.3f, 1.2f, 3.4f, 2.3f}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, doubleValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<double>({1.5, 2.7, 1.5, 3.9, 2.7}),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, dateValues) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int32_t>(
+          {0, 18262, 0, -5, 18262}, // Various dates including epoch
+          DATE()),
+  });
+
+  auto result = runMakeSetDigest({vectors});
+  verifySetDigest(result, 3);
+}
+
+TEST_F(SetDigestAggregateTest, mergeBasic) {
+  auto data1 = makeRowVector({makeFlatVector<int64_t>({1, 2, 3})});
+  auto data2 = makeRowVector({makeFlatVector<int64_t>({3, 4, 5})});
+
+  std::vector<RowVectorPtr> digestVectors;
+  for (auto& data : {data1, data2}) {
+    digestVectors.push_back(runMakeSetDigest({data}));
+  }
+
+  auto result = runMergeSetDigest(digestVectors);
+  verifySetDigest(result, 5);
+}
+
+TEST_F(SetDigestAggregateTest, mergeWithNullValues) {
+  auto data1 = makeRowVector({makeFlatVector<int64_t>({1, 2})});
+
+  auto op1 = PlanBuilder()
+                 .values({data1})
+                 .singleAggregation({}, {"make_set_digest(c0)"})
+                 .planNode();
+  auto result1 = AssertQueryBuilder(op1).copyResults(pool());
+
+  auto combined = makeRowVector({
+      makeNullableFlatVector<StringView>(
+          {result1->childAt(0)->as<FlatVector<StringView>>()->valueAt(0),
+           std::nullopt,
+           result1->childAt(0)->as<FlatVector<StringView>>()->valueAt(0)}),
+  });
+
+  auto mergeOp = PlanBuilder()
+                     .values({combined})
+                     .project({"cast(c0 as setdigest)"})
+                     .singleAggregation({}, {"merge_set_digest(p0)"})
+                     .planNode();
+
+  auto result = AssertQueryBuilder(mergeOp).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto resultVector = result->childAt(0)->as<FlatVector<StringView>>();
+  ASSERT_FALSE(resultVector->isNullAt(0));
+
+  auto serialized = resultVector->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType digest(allocator.get());
+  auto status = digest.deserialize(serialized.data(), serialized.size());
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  EXPECT_EQ(digest.cardinality(), 2);
+}
+
+TEST_F(SetDigestAggregateTest, mergeWithGroupBy) {
+  auto data1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2}),
+      makeFlatVector<int64_t>({10, 20, 30, 40}),
+  });
+
+  auto partialOp =
+      PlanBuilder()
+          .values({data1})
+          .singleAggregation({"c0"}, {"make_set_digest(c1) as digest"})
+          .planNode();
+  auto partialResult = AssertQueryBuilder(partialOp).copyResults(pool());
+
+  auto mergeOp = PlanBuilder()
+                     .values({partialResult})
+                     .project({"c0", "cast(digest as setdigest) as digest"})
+                     .singleAggregation({"c0"}, {"merge_set_digest(digest)"})
+                     .planNode();
+
+  auto result = AssertQueryBuilder(mergeOp).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 2);
+
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  auto digestVector = result->childAt(1)->as<FlatVector<StringView>>();
+
+  for (auto i = 0; i < result->size(); ++i) {
+    auto serialized = digestVector->valueAt(i);
+
+    SetDigestType mergedDigest(allocator.get());
+    auto status =
+        mergedDigest.deserialize(serialized.data(), serialized.size());
+    ASSERT_TRUE(status.ok()) << status.message();
+
+    EXPECT_EQ(mergedDigest.cardinality(), 2);
+    EXPECT_TRUE(mergedDigest.isExact());
+  }
+}
+
+TEST_F(SetDigestAggregateTest, mergeDistributedAggregation) {
+  std::vector<RowVectorPtr> partialResults;
+
+  for (int64_t i = 0; i < 3; ++i) {
+    std::vector<int64_t> values;
+    for (int64_t j = i * 10; j < (i + 1) * 10; ++j) {
+      values.push_back(j);
+    }
+    partialResults.push_back(
+        runMakeSetDigest({makeRowVector({makeFlatVector<int64_t>(values)})}));
+  }
+
+  auto result = runMergeSetDigest(partialResults);
+  verifySetDigest(result, 30);
+}
+
+TEST_F(SetDigestAggregateTest, mergeLargeApproximateDigests) {
+  std::vector<RowVectorPtr> partialResults;
+
+  for (int64_t i = 0; i < 5; ++i) {
+    std::vector<int64_t> values;
+    values.reserve(20000);
+    for (int64_t j = i * 20000; j < (i + 1) * 20000; ++j) {
+      values.push_back(j);
+    }
+    partialResults.push_back(
+        runMakeSetDigest({makeRowVector({makeFlatVector<int64_t>(values)})}));
+  }
+
+  auto result = runMergeSetDigest(partialResults);
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType mergedDigest(allocator.get());
+  ASSERT_TRUE(
+      mergedDigest.deserialize(serialized.data(), serialized.size()).ok());
+
+  EXPECT_FALSE(mergedDigest.isExact());
+
+  auto estimatedCardinality = mergedDigest.cardinality();
+  double errorRate = std::abs(estimatedCardinality - 100000) / 100000.0;
+
+  EXPECT_LT(errorRate, 0.05)
+      << "HLL estimate should be within 5% of actual. "
+      << "Actual: 100000, Estimated: " << estimatedCardinality;
+}
+
+TEST_F(SetDigestAggregateTest, mergeMakeSetDigestOutput) {
+  auto vectors = makeRowVector({
+      makeFlatVector<int32_t>({1, 1, 2, 2}),
+      makeFlatVector<int64_t>({10, 20, 30, 40}),
+  });
+
+  auto partialOp =
+      PlanBuilder()
+          .values({vectors})
+          .singleAggregation({"c0"}, {"make_set_digest(c1) as digest"})
+          .planNode();
+
+  auto partialResult = AssertQueryBuilder(partialOp).copyResults(pool());
+
+  auto mergeOp = PlanBuilder()
+                     .values({partialResult})
+                     .project({"cast(digest as setdigest) as digest"})
+                     .singleAggregation({}, {"merge_set_digest(digest)"})
+                     .planNode();
+
+  auto result = AssertQueryBuilder(mergeOp).copyResults(pool());
+
+  ASSERT_EQ(result->size(), 1);
+  auto resultVector = result->childAt(0)->as<FlatVector<StringView>>();
+  ASSERT_FALSE(resultVector->isNullAt(0));
+
+  auto serialized = resultVector->valueAt(0);
+
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+  SetDigestType mergedDigest(allocator.get());
+  auto status = mergedDigest.deserialize(serialized.data(), serialized.size());
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  EXPECT_EQ(mergedDigest.cardinality(), 4);
+  EXPECT_TRUE(mergedDigest.isExact());
+}
+
+TEST_F(SetDigestAggregateTest, mergeRoundTripSerialization) {
+  auto allocator = std::make_unique<HashStringAllocator>(pool_.get());
+
+  SetDigestType digest1(allocator.get());
+  digest1.add(1);
+  digest1.add(2);
+  digest1.add(3);
+
+  auto size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  auto vectors = makeRowVector({
+      makeFlatVector<std::string>(
+          {std::string(buffer1.data(), size1)}, VARBINARY()),
+  });
+
+  auto op = PlanBuilder()
+                .values({vectors})
+                .project({"cast(c0 as setdigest)"})
+                .singleAggregation({}, {"merge_set_digest(p0)"})
+                .planNode();
+
+  auto result = AssertQueryBuilder(op).copyResults(pool());
+
+  auto serialized =
+      result->childAt(0)->as<FlatVector<StringView>>()->valueAt(0);
+
+  SetDigestType digest2(allocator.get());
+  auto status = digest2.deserialize(serialized.data(), serialized.size());
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  auto size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+
+  SetDigestType digest3(allocator.get());
+  status = digest3.deserialize(buffer2.data(), size2);
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  auto size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+
+  EXPECT_EQ(size2, size3);
+  EXPECT_EQ(digest2.cardinality(), 3);
+  EXPECT_EQ(digest3.cardinality(), 3);
+  EXPECT_EQ(
+      std::string(buffer2.begin(), buffer2.end()),
+      std::string(buffer3.begin(), buffer3.end()));
+}
+
+TEST_F(SetDigestAggregateTest, mergeSetDigestGlobalIntermediate) {
+  auto batch1 = makeRowVector({makeFlatVector<std::string>(
+      {serializeSetDigest({1, 2, 3})}, VARBINARY())});
+  auto batch2 = makeRowVector({makeFlatVector<std::string>(
+      {serializeSetDigest({4, 5, 6})}, VARBINARY())});
+  auto batch3 = makeRowVector({makeFlatVector<std::string>(
+      {serializeSetDigest({7, 8, 9})}, VARBINARY())});
+
+  auto result = AssertQueryBuilder(
+                    PlanBuilder()
+                        .values({batch1, batch2, batch3})
+                        .project({"cast(c0 as setdigest)"})
+                        .partialAggregation({}, {"merge_set_digest(p0)"})
+                        .finalAggregation()
+                        .planNode())
+                    .copyResults(pool());
+
+  verifySetDigest(result, 9);
+}
+
+TEST_F(SetDigestAggregateTest, mergeSetDigestGroupedIntermediate) {
+  auto batchWithKey1 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<std::string>(
+          {serializeSetDigest({1, 2, 3}), serializeSetDigest({10, 20})},
+          VARBINARY()),
+  });
+  auto batchWithKey2 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<std::string>(
+          {serializeSetDigest({4, 5, 6}), serializeSetDigest({30, 40})},
+          VARBINARY()),
+  });
+  auto batchWithKey3 = makeRowVector({
+      makeFlatVector<int32_t>({1, 2}),
+      makeFlatVector<std::string>(
+          {serializeSetDigest({7, 8, 9}), serializeSetDigest({50, 60})},
+          VARBINARY()),
+  });
+
+  auto result =
+      AssertQueryBuilder(
+          PlanBuilder()
+              .values({batchWithKey1, batchWithKey2, batchWithKey3})
+              .project({"c0", "cast(c1 as setdigest) as digest"})
+              .partialAggregation({"c0"}, {"merge_set_digest(digest)"})
+              .finalAggregation()
+              .planNode())
+          .copyResults(pool());
+
+  ASSERT_EQ(result->size(), 2);
+  verifySetDigest(result, 9, true, 0);
+  verifySetDigest(result, 6, true, 1);
+}
+
+} // namespace
+
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/aggregates/tests/SumTest.cpp b/velox/functions/prestosql/aggregates/tests/SumTest.cpp
index c30257db0c8d..e95ab24311ee 100644
--- a/velox/functions/prestosql/aggregates/tests/SumTest.cpp
+++ b/velox/functions/prestosql/aggregates/tests/SumTest.cpp
@@ -15,10 +15,10 @@
  */
 
 #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/SumTestBase.h"
+#include "velox/vector/AggregationHook.h"
 
 using facebook::velox::exec::test::PlanBuilder;
 using namespace facebook::velox::exec::test;
diff --git a/velox/functions/prestosql/aggregates/tests/TDigestAggregateTest.cpp b/velox/functions/prestosql/aggregates/tests/TDigestAggregateTest.cpp
new file mode 100644
index 000000000000..c8394ec77e14
--- /dev/null
+++ b/velox/functions/prestosql/aggregates/tests/TDigestAggregateTest.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 <folly/base64.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/lib/TDigest.h"
+#include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
+#include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/vector/ComplexVector.h"
+
+using namespace facebook::velox::functions::aggregate::test;
+
+namespace facebook::velox::aggregate::test {
+
+class TDigestAggregateTest : public AggregationTestBase {
+ protected:
+  void SetUp() override {
+    AggregationTestBase::SetUp();
+  }
+
+  RowVectorPtr createExpectedVector(const std::string& base64EncodedString) {
+    std::string encodedString = decodeBase64(base64EncodedString);
+    auto expectedVector =
+        makeRowVector({makeFlatVector<facebook::velox::StringView>(
+            {facebook::velox::StringView(
+                encodedString.data(),
+                static_cast<int32_t>(encodedString.size()))},
+            facebook::velox::TDigestType::get(DOUBLE()))});
+    return expectedVector;
+  }
+
+  std::string decodeBase64(std::string_view input) {
+    std::string decoded(folly::base64DecodedSize(input), '\0');
+    folly::base64Decode(input, decoded.data());
+    return decoded;
+  }
+};
+
+TEST_F(TDigestAggregateTest, testAggregation) {
+  std::vector<double> inputs = {1.0, 2.0, 3.0, 4.0, 5.0};
+  std::vector<int64_t> weights = {1, 1, 1, 1, 1};
+  auto vectors = makeRowVector({makeFlatVector<double>(inputs)});
+  createDuckDbTable({vectors});
+  auto expected = createExpectedVector(
+      "AQAAAAAAAADwPwAAAAAAABRAAAAAAAAALkAAAAAAAABZQAAAAAAAABRABQAAAAAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAABAAAAAAAAACEAAAAAAAAAQQAAAAAAAABRA");
+  testAggregations({vectors}, {}, {"tdigest_agg(c0)"}, {expected});
+}
+
+TEST_F(TDigestAggregateTest, testAggregationWithWeight) {
+  std::vector<double> inputs = {1.0, 2.0, 3.0, 4.0, 5.0};
+  int64_t weight = 2;
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>(inputs),
+       makeConstant<int64_t>(
+           weight, static_cast<vector_size_t>(inputs.size()))});
+  createDuckDbTable({vectors});
+  auto expected = createExpectedVector(
+      "AQAAAAAAAADwPwAAAAAAABRAAAAAAAAAPkAAAAAAAABZQAAAAAAAACRABQAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAADwPwAAAAAAAABAAAAAAAAACEAAAAAAAAAQQAAAAAAAABRA");
+  testAggregations({vectors}, {}, {"tdigest_agg(c0, c1)"}, {expected});
+}
+
+TEST_F(TDigestAggregateTest, testAggregationWithWeightAndCompression) {
+  std::vector<double> inputs = {1.0, 2.0, 3.0, 4.0, 5.0};
+  int64_t weight = 2;
+  double compression = 50.0;
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>(inputs),
+       makeConstant<int64_t>(weight, static_cast<vector_size_t>(inputs.size())),
+       makeConstant<double>(
+           compression, static_cast<vector_size_t>(inputs.size()))});
+  createDuckDbTable({vectors});
+  auto expected = createExpectedVector(
+      "AQAAAAAAAADwPwAAAAAAABRAAAAAAAAAPkAAAAAAAABJQAAAAAAAACRABQAAAAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAADwPwAAAAAAAABAAAAAAAAACEAAAAAAAAAQQAAAAAAAABRA");
+  testAggregations({vectors}, {}, {"tdigest_agg(c0, c1, c2)"}, {expected});
+}
+
+TEST_F(TDigestAggregateTest, testAggregationWithVaryingWeights) {
+  std::vector<double> inputs = {1.0, 2.0, 3.0, 4.0, 5.0};
+  std::vector<int64_t> weights = {1, 2, 3, 4, 5};
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>(inputs), makeFlatVector<int64_t>(weights)});
+  createDuckDbTable({vectors});
+  auto expected = createExpectedVector(
+      "AQAAAAAAAADwPwAAAAAAABRAAAAAAACAS0AAAAAAAABZQAAAAAAAAC5ABQAAAAAAAAAAAPA/AAAAAAAAAEAAAAAAAAAIQAAAAAAAABBAAAAAAAAAFEAAAAAAAADwPwAAAAAAAABAAAAAAAAACEAAAAAAAAAQQAAAAAAAABRA");
+  testAggregations({vectors}, {}, {"tdigest_agg(c0, c1)"}, {expected});
+}
+
+TEST_F(TDigestAggregateTest, testAggregationWithVaryingCompression) {
+  std::vector<double> inputs = {1.0, 2.0, 3.0, 4.0, 5.0};
+  int64_t weight = 2;
+  std::vector<double> compression = {10.0, 11.0, 12.0, 13.0, 14.0};
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>(inputs),
+       makeConstant<int64_t>(weight, static_cast<vector_size_t>(inputs.size())),
+       makeFlatVector<double>(compression)});
+  createDuckDbTable({vectors});
+  VELOX_ASSERT_THROW(
+      testAggregations({vectors}, {}, {"tdigest_agg(c0, c1, c2)"}, {""}),
+      "Compression factor must be same for all rows");
+}
+
+TEST_F(TDigestAggregateTest, testAggregationMap) {
+  std::vector<double> inputs = {891.25};
+  std::vector<int64_t> weights = {636};
+  std::vector<double> compression = {83.72};
+  std::vector<bool> mask = {false};
+  auto vectors = makeRowVector(
+      {makeFlatVector<double>(inputs),
+       makeFlatVector<int64_t>(weights),
+       makeFlatVector<double>(compression),
+       makeFlatVector<bool>(mask)});
+  createDuckDbTable({vectors});
+  //   auto expected = makeRowVector({makeAllNullFlatVector<Varbinary>(1)});
+  //  facebook::velox::TDigestType::get(DOUBLE())});
+  testAggregations(
+      {vectors},
+      {},
+      {"tdigest_agg(c0, c1, c2) filter (where c3)"},
+      {"VALUES (NULL)"});
+}
+
+} // namespace facebook::velox::aggregate::test
diff --git a/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp b/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
index 4bcd170e2720..42528cfd92c6 100644
--- a/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/ArrayConstructorBenchmark.cpp
@@ -60,7 +60,7 @@ int main(int argc, char** argv) {
         .addBenchmarkSet(
             fmt::format(
                 "array_constructor_{}_{}{}",
-                mapTypeKindToName(type->kind()),
+                TypeKindName::toName(type->kind()),
                 withNulls ? "nulls" : "nullfree",
                 suffix),
             input)
diff --git a/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h b/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
index 75cbd8112fc8..25ade62db6f9 100644
--- a/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
+++ b/velox/functions/prestosql/benchmarks/ArrayPositionBasic.h
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/expression/Expr.h"
+#include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
 #include "velox/vector/DecodedVector.h"
 
@@ -254,22 +254,23 @@ class ArrayPositionFunctionBasic : public exec::VectorFunction {
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    return {// array(T), T -> int64_t
-            exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("bigint")
-                .argumentType("array(T)")
-                .argumentType("T")
-                .build(),
-
-            // array(T), T, int64_t -> int64_t
-            exec::FunctionSignatureBuilder()
-                .typeVariable("T")
-                .returnType("bigint")
-                .argumentType("array(T)")
-                .argumentType("T")
-                .argumentType("bigint")
-                .build()};
+    return {
+        // array(T), T -> int64_t
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("bigint")
+            .argumentType("array(T)")
+            .argumentType("T")
+            .build(),
+
+        // array(T), T, int64_t -> int64_t
+        exec::FunctionSignatureBuilder()
+            .typeVariable("T")
+            .returnType("bigint")
+            .argumentType("array(T)")
+            .argumentType("T")
+            .argumentType("bigint")
+            .build()};
   }
 };
 
diff --git a/velox/functions/prestosql/benchmarks/CMakeLists.txt b/velox/functions/prestosql/benchmarks/CMakeLists.txt
index c8a967ead895..2b1d774aaa0d 100644
--- a/velox/functions/prestosql/benchmarks/CMakeLists.txt
+++ b/velox/functions/prestosql/benchmarks/CMakeLists.txt
@@ -12,195 +12,159 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(BENCHMARK_DEPENDENCIES_NO_FUNC
-    velox_functions_test_lib
-    velox_exec
-    velox_exec_test_lib
-    gflags::gflags
-    Folly::folly
-    Folly::follybenchmark
-    velox_benchmark_builder)
-
-set(BENCHMARK_DEPENDENCIES
-    velox_functions_prestosql velox_functions_lib velox_vector_fuzzer
-    ${BENCHMARK_DEPENDENCIES_NO_FUNC})
-
-add_executable(velox_functions_prestosql_benchmarks_array_contains
-               ArrayContainsBenchmark.cpp)
-target_link_libraries(
-  velox_functions_prestosql_benchmarks_array_contains ${BENCHMARK_DEPENDENCIES})
+set(
+  BENCHMARK_DEPENDENCIES_NO_FUNC
+  velox_functions_test_lib
+  velox_exec
+  velox_exec_test_lib
+  gflags::gflags
+  Folly::folly
+  Folly::follybenchmark
+  velox_benchmark_builder
+)
 
-add_executable(velox_functions_prestosql_benchmarks_array_min_max
-               ArrayMinMaxBenchmark.cpp)
-target_link_libraries(
-  velox_functions_prestosql_benchmarks_array_min_max ${BENCHMARK_DEPENDENCIES})
+set(
+  BENCHMARK_DEPENDENCIES
+  velox_functions_prestosql
+  velox_functions_lib
+  velox_vector_fuzzer
+  ${BENCHMARK_DEPENDENCIES_NO_FUNC}
+)
 
-add_executable(velox_functions_prestosql_benchmarks_array_position
-               ArrayPositionBenchmark.cpp)
-target_link_libraries(
-  velox_functions_prestosql_benchmarks_array_position ${BENCHMARK_DEPENDENCIES})
+add_executable(velox_functions_prestosql_benchmarks_array_contains ArrayContainsBenchmark.cpp)
+target_link_libraries(velox_functions_prestosql_benchmarks_array_contains ${BENCHMARK_DEPENDENCIES})
 
-add_executable(velox_functions_prestosql_benchmarks_array_sum
-               ArraySumBenchmark.cpp)
+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_sum ${BENCHMARK_DEPENDENCIES})
+add_executable(velox_functions_prestosql_benchmarks_array_position ArrayPositionBenchmark.cpp)
+target_link_libraries(velox_functions_prestosql_benchmarks_array_position ${BENCHMARK_DEPENDENCIES})
 
-add_executable(velox_functions_prestosql_benchmarks_field_reference
-               FieldReferenceBenchmark.cpp)
+add_executable(velox_functions_prestosql_benchmarks_array_sum ArraySumBenchmark.cpp)
+
+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})
+  ${BENCHMARK_DEPENDENCIES}
+)
 
-add_executable(velox_functions_prestosql_benchmarks_width_bucket
-               WidthBucketBenchmark.cpp)
-target_link_libraries(
-  velox_functions_prestosql_benchmarks_width_bucket ${BENCHMARK_DEPENDENCIES})
+add_executable(velox_functions_prestosql_benchmarks_width_bucket WidthBucketBenchmark.cpp)
+target_link_libraries(velox_functions_prestosql_benchmarks_width_bucket ${BENCHMARK_DEPENDENCIES})
 
-add_executable(velox_functions_prestosql_benchmarks_string_ascii_utf_functions
-               StringAsciiUTFFunctionBenchmarks.cpp)
+add_executable(
+  velox_functions_prestosql_benchmarks_string_ascii_utf_functions
+  StringAsciiUTFFunctionBenchmarks.cpp
+)
 target_link_libraries(
   velox_functions_prestosql_benchmarks_string_ascii_utf_functions
-  ${BENCHMARK_DEPENDENCIES} velox_common_fuzzer_util)
+  ${BENCHMARK_DEPENDENCIES}
+  velox_common_fuzzer_util
+)
 
 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)
+add_executable(velox_functions_prestosql_benchmarks_date_time DateTimeBenchmark.cpp)
 target_link_libraries(
-  velox_functions_prestosql_benchmarks_date_time velox_type_tz
-  ${BENCHMARK_DEPENDENCIES})
+  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})
+add_executable(velox_functions_prestosql_benchmarks_bitwise BitwiseBenchmark.cpp)
+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})
+add_executable(velox_functions_prestosql_benchmarks_map_input MapInputBenchmark.cpp)
+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_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})
 
 add_executable(velox_benchmark_array_writer_no_nulls ArrayWriterBenchmark.cpp)
-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)
+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)
+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_compile_definitions(velox_benchmark_nested_array_writer_no_nulls
-                           PUBLIC WITH_NULLS=false)
-
-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)
+  ${BENCHMARK_DEPENDENCIES_NO_FUNC}
+)
+target_compile_definitions(velox_benchmark_nested_array_writer_no_nulls PUBLIC WITH_NULLS=false)
+
+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})
+  ${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_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})
 
 add_executable(velox_benchmark_map_writer_no_nulls MapWriterBenchmarks.cpp)
-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)
+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)
+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})
+  ${BENCHMARK_DEPENDENCIES_NO_FUNC}
+)
 
-add_executable(velox_functions_benchmarks_string_writer_no_nulls
-               StringWriterBenchmark.cpp)
+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})
+  ${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})
+add_executable(velox_functions_prestosql_benchmarks_comparisons ComparisonsBenchmark.cpp)
+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})
+add_executable(velox_functions_prestosql_benchmarks_zip_with ZipWithBenchmark.cpp)
+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})
+add_executable(velox_functions_prestosql_benchmarks_map_zip_with MapZipWithBenchmark.cpp)
+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})
+add_executable(velox_functions_prestosql_benchmarks_cardinality CardinalityBenchmark.cpp)
+target_link_libraries(velox_functions_prestosql_benchmarks_cardinality ${BENCHMARK_DEPENDENCIES})
 
-add_executable(velox_functions_benchmarks_simdjson_function_with_expr
-               JsonExprBenchmark.cpp)
+add_executable(velox_functions_benchmarks_simdjson_function_with_expr JsonExprBenchmark.cpp)
 target_link_libraries(
   velox_functions_benchmarks_simdjson_function_with_expr
-  ${BENCHMARK_DEPENDENCIES})
+  ${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_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_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_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})
+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/JsonExprBenchmark.cpp b/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
index 8fbb27617a3b..7e54d4e74192 100644
--- a/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/JsonExprBenchmark.cpp
@@ -13,10 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * This file tests the performance of each JsonXXXFunction.call() with
- * expression framework and Velox vectors.
- */
+
 #include <folly/Benchmark.h>
 #include <folly/init/Init.h>
 #include "velox/functions/Registerer.h"
@@ -26,10 +23,15 @@
 #include "velox/functions/prestosql/types/JsonRegistration.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 
+/// This file tests the performance of each JsonXXXFunction.call() with
+/// expression framework and Velox vectors.
+
 namespace facebook::velox::functions {
+
 void registerJsonVectorFunctions() {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_json_extract, "json_extract");
 }
+
 } // namespace facebook::velox::functions
 
 namespace facebook::velox::functions::prestosql {
@@ -40,7 +42,7 @@ struct FollyIsJsonScalarFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
 
   FOLLY_ALWAYS_INLINE void call(bool& result, const arg_type<Json>& json) {
-    auto parsedJson = folly::parseJson(json);
+    auto parsedJson = folly::parseJson(std::string_view(json));
     result = parsedJson.isNumber() || parsedJson.isString() ||
         parsedJson.isBool() || parsedJson.isNull();
   }
@@ -59,11 +61,10 @@ struct FollyJsonExtractScalarFunction {
       out_type<Varchar>& result,
       const arg_type<Json>& json,
       const arg_type<Varchar>& jsonPath) {
-    const folly::StringPiece& jsonStringPiece = json;
-    const folly::StringPiece& jsonPathStringPiece = jsonPath;
+    // TODO: Remove explicit std::string_view cast.
     auto extractResult =
-        jsonExtractScalar(jsonStringPiece, jsonPathStringPiece);
-    if (extractResult.hasValue()) {
+        jsonExtractScalar(std::string_view(json), std::string_view(jsonPath));
+    if (extractResult.has_value()) {
       UDFOutputString::assign(result, *extractResult);
       return true;
     } else {
@@ -80,9 +81,10 @@ struct FollyJsonExtractFunction {
       out_type<Json>& result,
       const arg_type<Json>& json,
       const arg_type<Varchar>& jsonPath) {
+    // TODO: Remove explicit std::string_view cast.
     auto extractResult =
-        jsonExtract(folly::StringPiece(json), folly::StringPiece(jsonPath));
-    if (!extractResult.hasValue() || extractResult.value().isNull()) {
+        jsonExtract(std::string_view(json), std::string_view(jsonPath));
+    if (!extractResult.has_value() || extractResult.value().isNull()) {
       return false;
     }
 
@@ -101,7 +103,7 @@ 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);
+    auto parsedJson = folly::parseJson(std::string_view(json));
     if (!parsedJson.isArray()) {
       return false;
     }
@@ -118,7 +120,7 @@ struct FollyJsonArrayContainsFunction {
   template <typename TInput>
   FOLLY_ALWAYS_INLINE bool
   call(bool& result, const arg_type<Json>& json, const TInput& value) {
-    auto parsedJson = folly::parseJson(json);
+    auto parsedJson = folly::parseJson(std::string_view(json));
     if (!parsedJson.isArray()) {
       return false;
     }
@@ -159,9 +161,9 @@ struct FollyJsonSizeFunction {
       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);
+    // TODO: Remove explicit std::string_view cast.
+    auto extractResult =
+        jsonExtract(std::string_view(json), std::string_view(jsonPath));
     if (!extractResult.has_value()) {
       return false;
     }
@@ -177,6 +179,85 @@ struct FollyJsonSizeFunction {
   }
 };
 
+template <typename T, bool document>
+struct JsonParsingErrorFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  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 constexpr (document) {
+      // jsonParsingError with document
+      auto errorCode = simdjsonParse(paddedJson).get(jsonDoc);
+      if (errorCode || jsonParsingError(jsonDoc)) {
+        if (threadSkipErrorDetails()) {
+          return Status::UserError();
+        }
+        return Status::UserError(
+            "Failed to parse JSON: {}", simdjson::error_message(errorCode));
+      }
+    } else {
+      // jsonParsingError with paddedString
+      if (auto errorCode = jsonParsingError(paddedJson)) {
+        if (threadSkipErrorDetails()) {
+          return Status::UserError();
+        }
+        return Status::UserError(
+            "Failed to parse JSON: {}", simdjson::error_message(errorCode));
+      }
+
+      if (simdjsonParse(paddedJson).get(jsonDoc)) {
+        return Status::UserError("Failed to parse JSON");
+      }
+    }
+    result = true;
+    return Status::OK();
+  }
+};
+
+template <typename T>
+struct JsonParsingErrorWithDocumentFunction
+    : public JsonParsingErrorFunction<T, true> {};
+
+template <typename T>
+struct JsonParsingErrorWithPaddedStringFunction
+    : public JsonParsingErrorFunction<T, false> {};
+
+template <typename T, bool rewind>
+struct SimdjsonParseFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE bool call(bool& result, const arg_type<Json>& json) {
+    return callImpl(result, json) == simdjson::SUCCESS;
+  }
+  FOLLY_ALWAYS_INLINE simdjson::error_code callImpl(
+      bool& result,
+      const arg_type<Json>& json) {
+    simdjson::ondemand::document jsonDoc;
+
+    simdjson::padded_string paddedJson(json.data(), json.size());
+    if constexpr (rewind) {
+      SIMDJSON_ASSIGN_OR_RAISE(jsonDoc, simdjsonParse(paddedJson));
+      jsonDoc.rewind();
+    } else {
+      SIMDJSON_ASSIGN_OR_RAISE(auto doc, simdjsonParse(paddedJson));
+      // Parse paddedJson again.
+      std::ignore = simdjsonParse(paddedJson).get(jsonDoc);
+    }
+    result = true;
+    return simdjson::SUCCESS;
+  }
+};
+
+template <typename T>
+struct SimdjsonParseWithRewindFunction : public SimdjsonParseFunction<T, true> {
+};
+
+template <typename T>
+struct SimdjsonParseWithParseAgainFunction
+    : public SimdjsonParseFunction<T, false> {};
+
 const std::string smallJson = R"({"k1":"v1"})";
 
 class JsonBenchmark : public velox::functions::test::FunctionBenchmarkBase {
@@ -203,6 +284,14 @@ class JsonBenchmark : public velox::functions::test::FunctionBenchmarkBase {
     registerFunction<JsonSizeFunction, int64_t, Json, Varchar>({"json_size"});
     registerFunction<FollyJsonSizeFunction, int64_t, Json, Varchar>(
         {"folly_json_size"});
+    registerFunction<JsonParsingErrorWithDocumentFunction, bool, Json>(
+        {"json_parse_error_with_document"});
+    registerFunction<JsonParsingErrorWithPaddedStringFunction, bool, Json>(
+        {"json_parse_error_with_paddedstring"});
+    registerFunction<SimdjsonParseWithRewindFunction, bool, Json>(
+        {"simdjsonParse_with_rewind"});
+    registerFunction<SimdjsonParseWithParseAgainFunction, bool, Json>(
+        {"simdjsonParse_with_parse_again"});
     registerJsonVectorFunctions();
   }
 
@@ -390,6 +479,41 @@ void SIMDJsonSize(int iter, int vectorSize, int jsonSize) {
   benchmark.runWithJsonExtract(iter, vectorSize, "json_size", json, "$.key");
 }
 
+void JsonParsingErrorWithDocument(int iter, int vectorSize, int jsonSize) {
+  folly::BenchmarkSuspender suspender;
+  JsonBenchmark benchmark;
+  auto json = benchmark.prepareData(jsonSize);
+  suspender.dismiss();
+  benchmark.runWithJson(
+      iter, vectorSize, "json_parse_error_with_document", json);
+}
+
+void JsonParsingErrorWithPaddedString(int iter, int vectorSize, int jsonSize) {
+  folly::BenchmarkSuspender suspender;
+  JsonBenchmark benchmark;
+  auto json = benchmark.prepareData(jsonSize);
+  suspender.dismiss();
+  benchmark.runWithJson(
+      iter, vectorSize, "json_parse_error_with_paddedstring", json);
+}
+
+void SimdjsonParseWithRewind(int iter, int vectorSize, int jsonSize) {
+  folly::BenchmarkSuspender suspender;
+  JsonBenchmark benchmark;
+  auto json = benchmark.prepareData(jsonSize);
+  suspender.dismiss();
+  benchmark.runWithJson(iter, vectorSize, "simdjsonParse_with_rewind", json);
+}
+
+void SimdjsonParseWithParseAgain(int iter, int vectorSize, int jsonSize) {
+  folly::BenchmarkSuspender suspender;
+  JsonBenchmark benchmark;
+  auto json = benchmark.prepareData(jsonSize);
+  suspender.dismiss();
+  benchmark.runWithJson(
+      iter, vectorSize, "simdjsonParse_with_parse_again", json);
+}
+
 BENCHMARK_DRAW_LINE();
 
 BENCHMARK_NAMED_PARAM(FollyIsJsonScalar, 100_iters_10bytes_size, 100, 10);
@@ -613,6 +737,102 @@ BENCHMARK_RELATIVE_NAMED_PARAM(
     10000);
 BENCHMARK_DRAW_LINE();
 
+BENCHMARK_NAMED_PARAM(
+    JsonParsingErrorWithPaddedString,
+    100_iters_10bytes_size,
+    100,
+    10);
+BENCHMARK_RELATIVE_NAMED_PARAM(
+    JsonParsingErrorWithDocument,
+    100_iters_10bytes_size,
+    100,
+    10);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(
+    JsonParsingErrorWithPaddedString,
+    100_iters_100bytes_size,
+    100,
+    100);
+BENCHMARK_RELATIVE_NAMED_PARAM(
+    JsonParsingErrorWithDocument,
+    100_iters_100bytes_size,
+    100,
+    100);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(
+    JsonParsingErrorWithPaddedString,
+    100_iters_1000bytes_size,
+    100,
+    1000);
+BENCHMARK_RELATIVE_NAMED_PARAM(
+    JsonParsingErrorWithDocument,
+    100_iters_1000bytes_size,
+    100,
+    1000);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(
+    JsonParsingErrorWithPaddedString,
+    100_iters_10000bytes_size,
+    100,
+    10000);
+BENCHMARK_RELATIVE_NAMED_PARAM(
+    JsonParsingErrorWithDocument,
+    100_iters_10000bytes_size,
+    100,
+    10000);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(
+    SimdjsonParseWithParseAgain,
+    100_iters_10bytes_size,
+    100,
+    10);
+BENCHMARK_RELATIVE_NAMED_PARAM(
+    SimdjsonParseWithRewind,
+    100_iters_10bytes_size,
+    100,
+    10);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(
+    SimdjsonParseWithParseAgain,
+    100_iters_100bytes_size,
+    100,
+    100);
+BENCHMARK_RELATIVE_NAMED_PARAM(
+    SimdjsonParseWithRewind,
+    100_iters_100bytes_size,
+    100,
+    100);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(
+    SimdjsonParseWithParseAgain,
+    100_iters_1000bytes_size,
+    100,
+    1000);
+BENCHMARK_RELATIVE_NAMED_PARAM(
+    SimdjsonParseWithRewind,
+    100_iters_1000bytes_size,
+    100,
+    1000);
+BENCHMARK_DRAW_LINE();
+
+BENCHMARK_NAMED_PARAM(
+    SimdjsonParseWithParseAgain,
+    100_iters_10000bytes_size,
+    100,
+    10000);
+BENCHMARK_RELATIVE_NAMED_PARAM(
+    SimdjsonParseWithRewind,
+    100_iters_10000bytes_size,
+    100,
+    10000);
+BENCHMARK_DRAW_LINE();
+
 } // namespace
 } // namespace facebook::velox::functions::prestosql
 
diff --git a/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp b/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
index 26f2a03136fa..ae9f3675623c 100644
--- a/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/MapInputBenchmark.cpp
@@ -166,8 +166,6 @@ class NestedMapWithMapView : public exec::VectorFunction {
       exec::EvalCtx& context,
       VectorPtr& result) const override {
     LocalDecodedVector decoded_(context, *args[0], rows);
-    using exec_in_t = typename VectorExec::template resolver<
-        Map<int64_t, Map<int64_t, int64_t>>>::in_type;
     VectorReader<Map<int64_t, Map<int64_t, int64_t>>> reader{decoded_.get()};
 
     // Prepare results
diff --git a/velox/functions/prestosql/benchmarks/URLBenchmark.cpp b/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
index 0cd63aedf060..4d0d6535dcb3 100644
--- a/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
+++ b/velox/functions/prestosql/benchmarks/URLBenchmark.cpp
@@ -32,7 +32,7 @@ template <typename Fn, typename TOutString, typename TInputString>
 FOLLY_ALWAYS_INLINE bool
 runURIFn(Fn func, TOutString& result, TInputString& url) {
   try {
-    auto parsedUrl = folly::Uri(url);
+    auto parsedUrl = folly::Uri(std::string_view(url));
     auto datum = (parsedUrl.*func)();
     result.resize(datum.size());
     if (datum.size() != 0) {
@@ -123,7 +123,7 @@ struct FollyUrlExtractPortFunction {
 
   FOLLY_ALWAYS_INLINE bool call(int64_t& result, const arg_type<Varchar>& url) {
     try {
-      auto parsedUrl = folly::Uri(url);
+      auto parsedUrl = folly::Uri(std::string_view(url));
       result = parsedUrl.port();
     } catch (const folly::ConversionError&) {
       return false;
@@ -145,7 +145,7 @@ struct FollyUrlExtractParameterFunction {
       const arg_type<Varchar>& url,
       const arg_type<Varchar>& param) {
     try {
-      auto parsedUrl = folly::Uri(url);
+      auto parsedUrl = folly::Uri(std::string_view(url));
       auto params = parsedUrl.getQueryParams();
 
       for (const auto& pair : params) {
diff --git a/velox/functions/prestosql/coverage/CMakeLists.txt b/velox/functions/prestosql/coverage/CMakeLists.txt
index 3dc06261c865..fc3db38e0bbc 100644
--- a/velox/functions/prestosql/coverage/CMakeLists.txt
+++ b/velox/functions/prestosql/coverage/CMakeLists.txt
@@ -20,4 +20,5 @@ target_link_libraries(
   velox_aggregates
   velox_row_fast
   velox_window
-  velox_coverage_util)
+  velox_coverage_util
+)
diff --git a/velox/functions/prestosql/coverage/data/all_scalar_functions.txt b/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
index 7faa98d22d94..ced264053809 100644
--- a/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
+++ b/velox/functions/prestosql/coverage/data/all_scalar_functions.txt
@@ -44,6 +44,7 @@ bing_tile_zoom_level
 bing_tiles_around
 binomial_cdf
 bit_count
+bit_length
 bitwise_and
 bitwise_arithmetic_shift_right
 bitwise_left_shift
@@ -86,6 +87,7 @@ day_of_month
 day_of_week
 day_of_year
 degrees
+dot_product
 dow
 doy
 e
@@ -130,6 +132,8 @@ geometry_nearest_points
 geometry_to_bing_tiles
 geometry_to_dissolved_bing_tiles
 geometry_union
+google_polyline_decode
+google_polyline_encode
 great_circle_distance
 greatest
 hamming_distance
@@ -173,6 +177,7 @@ json_format
 json_parse
 json_size
 key_sampling_percent
+l2_squared
 laplace_cdf
 last_day_of_month
 least
@@ -185,6 +190,7 @@ localtime
 localtimestamp
 log10
 log2
+longest_common_prefix
 lower
 lpad
 ltrim
diff --git a/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
index fffb800ae620..604a0f7e9117 100644
--- a/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
+++ b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
@@ -33,6 +33,19 @@
 #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/fuzzer/NoisyAvgInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/NoisyAvgResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/NoisyCountIfInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/NoisyCountIfResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/NoisyCountInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/NoisyCountResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/NoisySumInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/NoisySumResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/NumericHistogramInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/QDigestAggInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/QDigestAggResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/TDigestAggregateResultVerifier.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -78,7 +91,15 @@ getCustomInputGenerators() {
       {"approx_distinct", std::make_shared<ApproxDistinctInputGenerator>()},
       {"approx_set", std::make_shared<ApproxDistinctInputGenerator>()},
       {"approx_percentile", std::make_shared<ApproxPercentileInputGenerator>()},
+      {"tdigest_agg", std::make_shared<TDigestAggregateInputGenerator>()},
+      {"qdigest_agg", std::make_shared<QDigestAggInputGenerator>()},
       {"map_union_sum", std::make_shared<MapUnionSumInputGenerator>()},
+      {"noisy_avg_gaussian", std::make_shared<NoisyAvgInputGenerator>()},
+      {"noisy_count_if_gaussian",
+       std::make_shared<NoisyCountIfInputGenerator>()},
+      {"noisy_count_gaussian", std::make_shared<NoisyCountInputGenerator>()},
+      {"noisy_sum_gaussian", std::make_shared<NoisySumInputGenerator>()},
+      {"numeric_histogram", std::make_shared<NumericHistogramInputGenerator>()},
   };
 }
 
@@ -129,10 +150,37 @@ int main(int argc, char** argv) {
       "reduce_agg",
       "max_data_size_for_stats",
       "any_value",
+      // Skip non-deterministic functions.
+      "noisy_approx_set_sfm",
+      "noisy_approx_distinct_sfm",
+      "noisy_approx_set_sfm_from_index_and_zeros",
+      "reservoir_sample",
+      // https://github.com/facebookincubator/velox/issues/13547
+      "merge",
+      // https://github.com/facebookincubator/velox/issues/14423
+      "numeric_histogram",
+      // Come back to SetDigest and KHLL aggregate functions.
+      "make_set_digest",
+      "merge_set_digest",
+      "khyperloglog_agg", // TODO: Remove from skip list once the KHLL result
+      // verifier is added.
+      // The list below also contains their companion functions.
+      "convex_hull_agg",
+      "geometry_union_agg",
+      "geometry_union_agg_partial",
+      "geometry_union_agg_merge",
+      "geometry_union_agg_extract",
+      "geometry_union_agg_merge_extract",
+      "convex_hull_agg_partial",
+      "convex_hull_agg_merge",
+      "convex_hull_agg_extract",
+      "convex_hull_agg_merge_extract",
+
   };
 
   static const std::unordered_set<std::string> functionsRequireSortedInput = {
       "tdigest_agg",
+      "qdigest_agg",
   };
 
   using facebook::velox::exec::test::ApproxDistinctResultVerifier;
@@ -140,7 +188,13 @@ int main(int argc, char** argv) {
   using facebook::velox::exec::test::ArbitraryResultVerifier;
   using facebook::velox::exec::test::AverageResultVerifier;
   using facebook::velox::exec::test::MinMaxByResultVerifier;
+  using facebook::velox::exec::test::NoisyAvgResultVerifier;
+  using facebook::velox::exec::test::NoisyCountIfResultVerifier;
+  using facebook::velox::exec::test::NoisyCountResultVerifier;
+  using facebook::velox::exec::test::NoisySumResultVerifier;
+  using facebook::velox::exec::test::QDigestAggResultVerifier;
   using facebook::velox::exec::test::setupReferenceQueryRunner;
+  using facebook::velox::exec::test::TDigestAggregateResultVerifier;
   using facebook::velox::exec::test::TransformResultVerifier;
 
   auto makeArrayVerifier = []() {
@@ -168,6 +222,8 @@ int main(int argc, char** argv) {
           {"approx_set", std::make_shared<ApproxDistinctResultVerifier>(true)},
           {"approx_percentile",
            std::make_shared<ApproxPercentileResultVerifier>()},
+          {"tdigest_agg", std::make_shared<TDigestAggregateResultVerifier>()},
+          {"qdigest_agg", std::make_shared<QDigestAggResultVerifier>()},
           {"arbitrary", std::make_shared<ArbitraryResultVerifier>()},
           {"any_value", nullptr},
           {"array_agg", makeArrayVerifier()},
@@ -189,6 +245,22 @@ int main(int argc, char** argv) {
           // https://github.com/facebookincubator/velox/issues/6330
           {"max_data_size_for_stats", nullptr},
           {"sum_data_size_for_stats", nullptr},
+          {"noisy_avg_gaussian", std::make_shared<NoisyAvgResultVerifier>()},
+          {"noisy_count_if_gaussian",
+           std::make_shared<NoisyCountIfResultVerifier>()},
+          {"noisy_count_gaussian",
+           std::make_shared<NoisyCountResultVerifier>()},
+          {"noisy_sum_gaussian", std::make_shared<NoisySumResultVerifier>()},
+          {"convex_hull_agg", nullptr},
+          {"geometry_union_agg", nullptr},
+          {"geometry_union_agg_partial", nullptr},
+          {"geometry_union_agg_merge", nullptr},
+          {"geometry_union_agg_extract", nullptr},
+          {"geometry_union_agg_merge_extract", nullptr},
+          {"convex_hull_agg_partial", nullptr},
+          {"convex_hull_agg_merge", nullptr},
+          {"convex_hull_agg_extract", nullptr},
+          {"convex_hull_agg_merge_extract", nullptr},
       };
 
   using Runner = facebook::velox::exec::test::AggregationFuzzerRunner;
diff --git a/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h b/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h
index 3d0e2eb43e6c..49f2486a2744 100644
--- a/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h
+++ b/velox/functions/prestosql/fuzzer/ApproxDistinctResultVerifier.h
@@ -255,7 +255,7 @@ class ApproxDistinctResultVerifier : public ResultVerifier {
 
     // We expect large deviations (>2 stddev) in < 5% of values.
     if (numGroups >= 50) {
-      return largeGaps.size() <= 0.05 * numGroups;
+      return largeGaps.size() <= std::ceil(0.05 * numGroups);
     }
 
     return numGroups == 1 || largeGaps.empty();
diff --git a/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h b/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h
index 74fdc9048ac2..7d3fe9736bcb 100644
--- a/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h
+++ b/velox/functions/prestosql/fuzzer/ApproxPercentileInputGenerator.h
@@ -56,8 +56,9 @@ class ApproxPercentileInputGenerator : public InputGenerator {
         percentile_ = pickPercentile(fuzzer, rng);
       }
 
-      inputs.push_back(BaseVector::createConstant(
-          DOUBLE(), percentile_.value(), size, pool));
+      inputs.push_back(
+          BaseVector::createConstant(
+              DOUBLE(), percentile_.value(), size, pool));
     } else {
       VELOX_CHECK(percentileType->isArray());
       VELOX_CHECK(percentileType->childAt(0)->isDouble());
diff --git a/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h b/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h
index 71b2b44d7d8d..09b2b344043c 100644
--- a/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h
+++ b/velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h
@@ -250,9 +250,10 @@ class ApproxPercentileResultVerifier : public ResultVerifier {
 
     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"));
+    projections.push_back(
+        fmt::format(
+            "{} as w",
+            weightField.has_value() ? weightField.value() : "1::bigint"));
 
     PlanBuilder planBuilder;
     planBuilder.values(input).projectExpressions(inputProjections);
diff --git a/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h b/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h
index 337be08243b2..946d8ff573ef 100644
--- a/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h
+++ b/velox/functions/prestosql/fuzzer/ArbitraryResultVerifier.h
@@ -51,8 +51,9 @@ class ArbitraryResultVerifier : public ResultVerifier {
     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(
+        fmt::format(
+            "cast(NULL as {}) as {}", aggregateTypeSql_, aggregateName));
     projectColumns.push_back("expected");
 
     auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
diff --git a/velox/functions/prestosql/fuzzer/CMakeLists.txt b/velox/functions/prestosql/fuzzer/CMakeLists.txt
index 07695c74f1a9..880c5e23981e 100644
--- a/velox/functions/prestosql/fuzzer/CMakeLists.txt
+++ b/velox/functions/prestosql/fuzzer/CMakeLists.txt
@@ -20,7 +20,8 @@ target_link_libraries(
   velox_aggregation_fuzzer_base
   velox_exec_test_lib
   velox_vector
-  velox_vector_test_lib)
+  velox_vector_test_lib
+)
 
 add_executable(velox_aggregation_fuzzer_test AggregationFuzzerTest.cpp)
 
@@ -34,7 +35,8 @@ target_link_libraries(
   velox_vector_fuzzer
   velox_vector_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 # Window Fuzzer
 add_executable(velox_window_fuzzer_test WindowFuzzerTest.cpp)
@@ -49,7 +51,8 @@ target_link_libraries(
   velox_functions_prestosql
   velox_vector_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 # Writer Fuzzer
 add_executable(velox_writer_fuzzer_test WriterFuzzerTest.cpp)
@@ -59,4 +62,5 @@ target_link_libraries(
   velox_writer_fuzzer
   velox_fuzzer_util
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/functions/prestosql/fuzzer/NoisyAvgInputGenerator.h b/velox/functions/prestosql/fuzzer/NoisyAvgInputGenerator.h
new file mode 100644
index 000000000000..0013c436105c
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NoisyAvgInputGenerator.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 "velox/functions/prestosql/fuzzer/NoisySumInputGenerator.h"
+
+namespace facebook::velox::exec::test {
+class NoisyAvgInputGenerator : public NoisySumInputGenerator {};
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NoisyAvgResultVerifier.h b/velox/functions/prestosql/fuzzer/NoisyAvgResultVerifier.h
new file mode 100644
index 000000000000..ae45e2094cf7
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NoisyAvgResultVerifier.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/functions/prestosql/fuzzer/NoisySumResultVerifier.h"
+
+namespace facebook::velox::exec::test {
+class NoisyAvgResultVerifier : public NoisySumResultVerifier {
+ public:
+  void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<core::ExprPtr>& projections,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    groupingKeys_ = groupingKeys;
+    name_ = aggregateName;
+    // Extract the noise scale from the function call.
+    const auto& args = aggregate.call->inputs();
+    extractNoiseScaleAndBound(input[0], args);
+
+    // Extract aggregate column name before deduplication
+    auto field = core::TypedExprs::asFieldAccess(args[0]);
+    VELOX_CHECK_NOT_NULL(field);
+    aggregateColumn_ = field->name();
+
+    // When distinct is true, we should deduplicate the input before clipping.
+    // if mask is provided, mask should apply to the input before
+    // deduplication.
+    auto deduplicatedInput = input;
+    if (aggregate.distinct) {
+      deduplicatedInput = deduplicateInput(input, aggregate.mask);
+    }
+    // Clip the input to the specified bounds and convert to double. This is
+    // needed because the noisy_avg_gaussian function only return double
+    // outputs.
+    clipInput(deduplicatedInput);
+
+    auto sumCall = fmt::format("avg({})", aggregateColumn_);
+
+    // If distinct is false, mask has not been applied yet.
+    if (aggregate.mask != nullptr && !aggregate.distinct) {
+      sumCall += fmt::format(" filter (where {})", aggregate.mask->name());
+    }
+
+    core::PlanNodePtr plan = PlanBuilder()
+                                 .values(clippedInput_)
+                                 .projectExpressions(projections)
+                                 .singleAggregation(groupingKeys, {sumCall})
+                                 .planNode();
+
+    expectedNoNoise_ = AssertQueryBuilder(plan).copyResults(input[0]->pool());
+  }
+};
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NoisyCountIfInputGenerator.h b/velox/functions/prestosql/fuzzer/NoisyCountIfInputGenerator.h
new file mode 100644
index 000000000000..2d342aa60ca2
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NoisyCountIfInputGenerator.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/Executor.h>
+#include <folly/executors/CPUThreadPoolExecutor.h>
+#include <vector>
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+class NoisyCountIfInputGenerator : public InputGenerator {
+ public:
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    vector_size_t size = static_cast<int32_t>(fuzzer.getOptions().vectorSize);
+    std::vector<VectorPtr> result;
+
+    // Make sure to use the same value of 'noiseScale' for all batches inputs,
+    // so we only set it once.
+    if (!noiseScale_.has_value()) {
+      noiseScale_ =
+          boost::random::uniform_real_distribution<double>(0.0, 10.0)(rng);
+    }
+
+    // Process each type in the input.
+    // Types of parameters in noisy_count_if(col, noiseScale, randomSeed)
+    VELOX_CHECK(types.size() >= 2);
+    for (size_t i = 0; i < types.size(); ++i) {
+      const auto& type = types[i];
+
+      // For the first boolean argument(col)
+      if (i == 0 && type->isBoolean()) {
+        // Create a simple boolean vector with alternating true/false values
+        auto flatVector = std::static_pointer_cast<BaseVector>(
+            BaseVector::create<FlatVector<bool>>(BOOLEAN(), size, pool));
+
+        // Add some nulls
+        for (vector_size_t j = 0; j < size; j += 10) {
+          if (j < size) {
+            flatVector->setNull(j, true);
+          }
+        }
+
+        result.push_back(flatVector);
+      }
+      // For the second argument (noise scale)
+      else if (i == 1) {
+        if (type->isDouble()) {
+          result.push_back(
+              BaseVector::createConstant(DOUBLE(), *noiseScale_, size, pool));
+        } else if (type->isBigint()) {
+          // Create a variant with the correct integer value
+          variant intValue = static_cast<int64_t>(*noiseScale_);
+          result.push_back(
+              BaseVector::createConstant(BIGINT(), intValue, size, pool));
+        }
+      }
+      // For the third argument (random seed)
+      else if (i == 2 && type->isBigint()) {
+        if (!randomSeed_.has_value()) {
+          randomSeed_ =
+              boost::random::uniform_int_distribution<int64_t>(0, 12345)(rng);
+        }
+        result.push_back(
+            BaseVector::createConstant(BIGINT(), *randomSeed_, size, pool));
+      }
+    }
+
+    return result;
+  }
+  void reset() override {
+    noiseScale_.reset();
+  }
+
+ private:
+  std::optional<double> noiseScale_;
+  std::optional<int64_t> randomSeed_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NoisyCountIfResultVerifier.h b/velox/functions/prestosql/fuzzer/NoisyCountIfResultVerifier.h
new file mode 100644
index 000000000000..0b58157ce604
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NoisyCountIfResultVerifier.h
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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 {
+
+class NoisyCountIfResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return false;
+  }
+
+  bool supportsVerify() override {
+    return true;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<core::ExprPtr>& projections,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    VELOX_CHECK(!input.empty());
+    // Extract the noise scale from the function call.
+    extractNoiseScale(input[0]);
+
+    // Extract the column name to aggregate on
+    const auto& args = aggregate.call->inputs();
+    VELOX_CHECK_GE(args.size(), 1);
+    auto field = core::TypedExprs::asFieldAccess(args[0]);
+    VELOX_CHECK_NOT_NULL(field);
+    aggregateColumn_ = field->name();
+
+    groupingKeys_ = groupingKeys;
+    name_ = aggregateName;
+
+    std::string countIfCall;
+    if (aggregate.distinct) {
+      countIfCall = fmt::format("count_if(DISTINCT {})", aggregateColumn_);
+    } else {
+      countIfCall = fmt::format("count_if({})", aggregateColumn_);
+    }
+
+    // Add filter if mask exists
+    if (aggregate.mask != nullptr) {
+      countIfCall += fmt::format(" filter (where {})", aggregate.mask->name());
+    }
+
+    // Execute plan to get expected result without noise
+    core::PlanNodePtr plan = PlanBuilder()
+                                 .values(input)
+                                 .projectExpressions(projections)
+                                 .singleAggregation(groupingKeys, {countIfCall})
+                                 .planNode();
+
+    expectedNoNoise_ = AssertQueryBuilder(plan).copyResults(input[0]->pool());
+  }
+
+  bool compare(
+      [[maybe_unused]] const RowVectorPtr& result,
+      [[maybe_unused]] const RowVectorPtr& otherResult) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  bool verify(const RowVectorPtr& result) override {
+    // The expected result and actual result are grouped by the same keys,
+    // but the rows may be in different order. So we need to union the results.
+    // Create sources for expected and actual results
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto expectedSource = PlanBuilder(planNodeIdGenerator)
+                              .values({expectedNoNoise_})
+                              .appendColumns({"'expected' as label"})
+                              .planNode();
+    auto actualSource = PlanBuilder(planNodeIdGenerator)
+                            .values({result})
+                            .appendColumns({"'actual' as label"})
+                            .planNode();
+
+    // Combine expected and actual results by grouping keys using map_agg
+    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());
+
+    // Extract actual and expected values
+    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());
+
+    // Calculate allowed difference based on noise scale
+    const int64_t deviationMultiple = 50;
+    const double allowedFailureRate = 0.001;
+    const auto allowedDifference =
+        static_cast<int64_t>(deviationMultiple * noiseScale_);
+    const auto lowerBound = -allowedDifference;
+    const auto upperBound = allowedDifference;
+
+    // Check each group's result
+    int failures = 0;
+    for (auto i = 0; i < numGroups; ++i) {
+      // Skip verification for null rows
+      if (expected->isNullAt(i) || actual->isNullAt(i)) {
+        continue;
+      }
+
+      const auto actualValue = actual->valueAt(i);
+      const auto expectedValue = expected->valueAt(i);
+      const auto difference = actualValue - expectedValue;
+
+      // Check if actual value is within expected +/- allowedDifference
+      if (difference < lowerBound || difference > upperBound) {
+        LOG(ERROR) << fmt::format(
+            "noisy_count_if_gaussian result is outside the expected range.\n"
+            "  Group: {}\n"
+            "  Actual: {}\n"
+            "  Expected: {}\n"
+            "  Difference: {}\n"
+            "  Allowed range: [{}, {}] (noise_scale = {})",
+            i,
+            actualValue,
+            expectedValue,
+            difference,
+            expectedValue + lowerBound,
+            expectedValue + upperBound,
+            noiseScale_);
+        failures++;
+      }
+    }
+
+    // Allow a very small percentage of failures for large result sets
+    if (numGroups >= 50) {
+      const auto maxFailures = static_cast<int>(allowedFailureRate * numGroups);
+      if (failures > maxFailures) {
+        LOG(ERROR) << fmt::format(
+            "Too many failures: {} out of {} groups (max allowed: {})",
+            failures,
+            numGroups,
+            maxFailures);
+        return false;
+      }
+      return true;
+    }
+
+    // For small result sets, require all groups to pass
+    return failures == 0;
+  }
+
+  void reset() override {
+    noiseScale_ = 0.0;
+    name_.clear();
+    groupingKeys_.clear();
+    aggregateColumn_.clear();
+    expectedNoNoise_.reset();
+  }
+
+ protected:
+  void extractNoiseScale(const RowVectorPtr& input) {
+    auto secondArg = input->childAt(1);
+    if (secondArg->type()->isDouble()) {
+      noiseScale_ = secondArg->as<SimpleVector<double>>()->valueAt(0);
+      return;
+    } else if (secondArg->type()->isBigint()) {
+      noiseScale_ = static_cast<double>(
+          secondArg->as<SimpleVector<int64_t>>()->valueAt(0));
+      return;
+    }
+  }
+
+  double noiseScale_{0.0};
+  std::string name_;
+  std::vector<std::string> groupingKeys_;
+  std::string aggregateColumn_;
+  RowVectorPtr expectedNoNoise_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NoisyCountInputGenerator.h b/velox/functions/prestosql/fuzzer/NoisyCountInputGenerator.h
new file mode 100644
index 000000000000..5def5107a89a
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NoisyCountInputGenerator.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 <folly/executors/CPUThreadPoolExecutor.h>
+#include <vector>
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+class NoisyCountInputGenerator : public InputGenerator {
+ public:
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    vector_size_t size = static_cast<int32_t>(fuzzer.getOptions().vectorSize);
+    std::vector<VectorPtr> result;
+
+    // Make sure to use the same value of 'noiseScale' for all batches inputs,
+    // so we only set it once.
+    if (!noiseScale_.has_value()) {
+      noiseScale_ =
+          boost::random::uniform_real_distribution<double>(0.0, 10.0)(rng);
+    }
+
+    // Process each type in the input.
+    // Types of parameters in noisy_count_(col, noiseScale, randomSeed)
+    VELOX_CHECK(types.size() >= 2);
+    for (size_t i = 0; i < types.size(); ++i) {
+      const auto& type = types[i];
+
+      // For the first argument(col), can be any type.
+      if (i == 0) {
+        // Create a fuzzer vector.
+        auto flatVector = fuzzer.fuzzFlat(type, size);
+        result.push_back(flatVector);
+      }
+      // For the second argument (noise scale)
+      else if (i == 1) {
+        if (type->isDouble()) {
+          result.push_back(
+              BaseVector::createConstant(DOUBLE(), *noiseScale_, size, pool));
+        } else if (type->isBigint()) {
+          // Create a variant with the correct integer value
+          variant intValue = static_cast<int64_t>(*noiseScale_);
+          result.push_back(
+              BaseVector::createConstant(BIGINT(), intValue, size, pool));
+        }
+      }
+      // For the third argument (random seed)
+      else if (i == 2) {
+        if (type->isBigint()) {
+          // Create a variant with the correct integer value
+          if (!randomSeed_.has_value()) {
+            randomSeed_ =
+                boost::random::uniform_int_distribution<int64_t>(0, 12345)(rng);
+          }
+          result.push_back(
+              BaseVector::createConstant(BIGINT(), *randomSeed_, size, pool));
+        }
+      }
+    }
+    return result;
+  }
+  void reset() override {
+    noiseScale_.reset();
+  }
+
+ private:
+  std::optional<double> noiseScale_;
+  std::optional<int64_t> randomSeed_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NoisyCountResultVerifier.h b/velox/functions/prestosql/fuzzer/NoisyCountResultVerifier.h
new file mode 100644
index 000000000000..876f53ec6fc3
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NoisyCountResultVerifier.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 <string>
+
+#include "velox/core/PlanNode.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/functions/prestosql/fuzzer/NoisyCountIfResultVerifier.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+class NoisyCountResultVerifier : public NoisyCountIfResultVerifier {
+ public:
+  void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<core::ExprPtr>& projections,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    VELOX_CHECK(!input.empty());
+    // Extract the noise scale from the function call.
+    extractNoiseScale(input[0]);
+
+    // Extract the column name to aggregate on
+    const auto& args = aggregate.call->inputs();
+    auto field = core::TypedExprs::asFieldAccess(args[0]);
+    VELOX_CHECK_NOT_NULL(field);
+    aggregateColumn_ = field->name();
+
+    groupingKeys_ = groupingKeys;
+    name_ = aggregateName;
+
+    std::string countCall;
+    if (aggregate.distinct) {
+      countCall = fmt::format("count(DISTINCT {})", aggregateColumn_);
+    } else {
+      countCall = fmt::format("count({})", aggregateColumn_);
+    }
+
+    // Add filter if mask exists
+    if (aggregate.mask != nullptr) {
+      countCall += fmt::format(" filter (where {})", aggregate.mask->name());
+    }
+
+    core::PlanNodePtr plan = PlanBuilder()
+                                 .values(input)
+                                 .projectExpressions(projections)
+                                 .singleAggregation(groupingKeys, {countCall})
+                                 .planNode();
+
+    expectedNoNoise_ = AssertQueryBuilder(plan).copyResults(input[0]->pool());
+  }
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NoisySumInputGenerator.h b/velox/functions/prestosql/fuzzer/NoisySumInputGenerator.h
new file mode 100644
index 000000000000..9d79e1488b38
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NoisySumInputGenerator.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/executors/CPUThreadPoolExecutor.h>
+#include <vector>
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+class NoisySumInputGenerator : public InputGenerator {
+ public:
+  /// Generate input for the noisy_sum_gaussian function.
+  /// The signature takes 2-5 arguments.
+  /// noisy_sum_gaussian(col, noiseScale[[, lower, upper], randomSeed])
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    vector_size_t size = static_cast<int32_t>(fuzzer.getOptions().vectorSize);
+    std::vector<VectorPtr> result;
+
+    // Make sure to use the same value of 'noiseScale' for all batches inputs,
+    // so we only set it once.
+    if (!noiseScale_.has_value()) {
+      noiseScale_ =
+          boost::random::uniform_real_distribution<double>(0.0, 100.0)(rng);
+    }
+
+    // Process each type in the input.
+    // Types of parameters in noisy_sum_gaussian(col, noiseScale, lower, upper,
+    // randomSeed)
+    VELOX_CHECK(types.size() >= 2);
+    VELOX_CHECK(types.size() <= 5);
+    for (size_t i = 0; i < types.size(); ++i) {
+      const auto& type = types[i];
+
+      // For the first argument which is a numeric column
+      if (i == 0) {
+        // Create a flat vector for sum aggregation. Signature only accept
+        // numeric type.
+        auto flatVector = fuzzer.fuzzFlat(type, size);
+        result.push_back(flatVector);
+      }
+      // For the second argument (noise scale)
+      else if (i == 1) {
+        if (type->isDouble()) {
+          result.push_back(
+              BaseVector::createConstant(DOUBLE(), *noiseScale_, size, pool));
+        } else if (type->isBigint()) {
+          // Create a variant with the correct integer value
+          variant intValue = static_cast<int64_t>(*noiseScale_);
+          result.push_back(
+              BaseVector::createConstant(BIGINT(), intValue, size, pool));
+        }
+      }
+      // For the third argument
+      else if (i == 2) {
+        // If the third arg is random seed
+        if (types.size() == 3) {
+          if (!randomSeed_.has_value()) {
+            randomSeed_ =
+                boost::random::uniform_int_distribution<int64_t>(0, 12345)(rng);
+          }
+          result.push_back(
+              BaseVector::createConstant(BIGINT(), *randomSeed_, size, pool));
+        }
+        // size >= 4 means it has lower and upper bound.
+        else {
+          // Generate lower and upper bound if they are not set.
+          if (!lowerBound_.has_value()) {
+            lowerBound_ = boost::random::uniform_real_distribution<double>(
+                -1000.0, 1000.0)(rng);
+            // Make sure lower bound is less than upper bound.
+            upperBound_ = boost::random::uniform_real_distribution<double>(
+                              100.0, 1000.0)(rng) +
+                *lowerBound_;
+          }
+
+          if (type->isDouble()) {
+            result.push_back(
+                BaseVector::createConstant(DOUBLE(), *lowerBound_, size, pool));
+          } else if (type->isBigint()) {
+            // Create a variant with the correct integer value
+            variant intValue = static_cast<int64_t>(*lowerBound_);
+            result.push_back(
+                BaseVector::createConstant(BIGINT(), intValue, size, pool));
+          }
+        }
+      }
+      // For the fourth argument(upper bound)
+      else if (i == 3) {
+        // When type size is GE 4, it is guaranteed to have lower and upper
+        // bound.
+        if (type->isDouble()) {
+          result.push_back(
+              BaseVector::createConstant(DOUBLE(), *upperBound_, size, pool));
+        } else if (type->isBigint()) {
+          // Create a variant with the correct integer value
+          variant intValue = static_cast<int64_t>(*upperBound_);
+          result.push_back(
+              BaseVector::createConstant(BIGINT(), intValue, size, pool));
+        }
+      }
+      // For the fifth argument(random seed)
+      else if (i == 4) {
+        VELOX_CHECK(type->isBigint());
+        if (!randomSeed_.has_value()) {
+          randomSeed_ =
+              boost::random::uniform_int_distribution<int64_t>(0, 12345)(rng);
+        }
+        result.push_back(
+            BaseVector::createConstant(BIGINT(), *randomSeed_, size, pool));
+      }
+    }
+
+    return result;
+  }
+  void reset() override {
+    noiseScale_.reset();
+    lowerBound_.reset();
+    upperBound_.reset();
+    randomSeed_.reset();
+  }
+
+ private:
+  std::optional<double> noiseScale_;
+  std::optional<double> lowerBound_;
+  std::optional<double> upperBound_;
+  std::optional<int64_t> randomSeed_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NoisySumResultVerifier.h b/velox/functions/prestosql/fuzzer/NoisySumResultVerifier.h
new file mode 100644
index 000000000000..c698772f513d
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NoisySumResultVerifier.h
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/algorithm/string/join.hpp>
+#include <fmt/ranges.h>
+#include <cstdint>
+#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 {
+
+/// Verifier for the noisy_sum_gaussian function.
+/// The function takes 2-5 arguments:
+/// If the signature takes 5 arguments, the function clips
+/// the input to the specified bounds, and then sums the clipped values.
+/// At the last step, it adds Gaussian noise to the sum with the specified
+/// noise scale. Random seed is used to generate a determined sequence of
+/// noises.
+/// The idea of this verifier is to create a benchmark plan that simulates the
+/// function without adding noise. Then we can compare the result of the actual
+/// function with the result of the benchmark plan. If the difference is within
+/// the expected range, we consider the result as correct.
+/// To create the benchmark, we cannot use noisy_sum_gaussian directly and we
+/// need to use a sequence of other functions to replicate the same behavior.
+/// Basically we need to:
+/// 1. Deduplicate the input with window function if distinct is true.
+/// 2. Clip the input to the specified bounds and convert the aggregate column
+///    to double to ensure the result is always double, keeping consistent with
+///    noisy_sum_gaussian. This process returns a new vector with clipped input.
+/// 3. Sum the clipped values.
+/// 4. Call noisy_sum_gaussian on the input.
+/// 5. Compare the result with the expected result.
+class NoisySumResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return false;
+  }
+
+  bool supportsVerify() override {
+    return true;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<core::ExprPtr>& projections,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    VELOX_CHECK(!input.empty());
+
+    groupingKeys_ = groupingKeys;
+    name_ = aggregateName;
+    // Extract the noise scale from the function call.
+    const auto& args = aggregate.call->inputs();
+    extractNoiseScaleAndBound(input[0], args);
+
+    // Extract aggregate column name before deduplication
+    auto field = core::TypedExprs::asFieldAccess(args[0]);
+    VELOX_CHECK_NOT_NULL(field);
+    aggregateColumn_ = field->name();
+
+    // When distinct is true, we should deduplicate the input before clipping.
+    // if mask is provided, mask should apply to the input before
+    // deduplication.
+    auto deduplicatedInput = input;
+    if (aggregate.distinct) {
+      deduplicatedInput = deduplicateInput(input, aggregate.mask);
+    }
+    // Clip the input to the specified bounds and convert to double. This is
+    // needed because the noisy_sum_gaussian function only return double
+    // outputs.
+    clipInput(deduplicatedInput);
+
+    auto sumCall = fmt::format("sum({})", aggregateColumn_);
+
+    // If distinct is false, mask has not been applied yet.
+    if (aggregate.mask != nullptr && !aggregate.distinct) {
+      sumCall += fmt::format(" filter (where {})", aggregate.mask->name());
+    }
+
+    core::PlanNodePtr plan = PlanBuilder()
+                                 .values(clippedInput_)
+                                 .projectExpressions(projections)
+                                 .singleAggregation(groupingKeys, {sumCall})
+                                 .planNode();
+
+    expectedNoNoise_ = AssertQueryBuilder(plan).copyResults(input[0]->pool());
+  }
+
+  bool compare(
+      [[maybe_unused]] const RowVectorPtr& result,
+      [[maybe_unused]] const RowVectorPtr& otherResult) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  bool verify(const RowVectorPtr& result) override {
+    // The expected result and actual result are grouped by the same keys,
+    // but the rows may be in different order. So we need to union the results.
+    // Create sources for expected and actual results
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto expectedSource = PlanBuilder(planNodeIdGenerator)
+                              .values({expectedNoNoise_})
+                              .appendColumns({"'expected' as label"})
+                              .planNode();
+    auto actualSource = PlanBuilder(planNodeIdGenerator)
+                            .values({result})
+                            .appendColumns({"'actual' as label"})
+                            .planNode();
+
+    // Combine expected and actual results by grouping keys using map_agg
+    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());
+
+    // Extract actual and expected values, handling type differences
+    auto actualColumn = combined->childAt(0);
+    auto expectedColumn = combined->childAt(1);
+
+    const auto numGroups = result->size();
+    VELOX_CHECK_EQ(numGroups, combined->size());
+
+    // Calculate allowed difference based on noise scale
+    const int64_t deviationMultiple = 50;
+    const double allowedFailureRate = 0.001;
+    // When noise_scale is 0, we expect exact match.
+    // But type conversion may lose precision, especially for very large result.
+    // so we allow a small percentage of differences.
+    const double allowedDifferencePercent = 0.000000001;
+    const auto allowedDifference = deviationMultiple * noiseScale_;
+    auto lowerBound = -allowedDifference;
+    auto upperBound = allowedDifference;
+
+    // Check each group's result
+    int failures = 0;
+    for (auto i = 0; i < numGroups; ++i) {
+      // Skip verification for null rows
+      if (expectedColumn->isNullAt(i) || actualColumn->isNullAt(i)) {
+        continue;
+      }
+
+      const auto actualValue =
+          actualColumn->as<SimpleVector<double>>()->valueAt(i);
+      const auto expectedValue =
+          expectedColumn->as<SimpleVector<double>>()->valueAt(i);
+      const auto difference = actualValue - expectedValue;
+
+      // Allow a small percentage of difference for noise_scale = 0
+      lowerBound =
+          std::min(lowerBound, -allowedDifferencePercent * expectedValue);
+      upperBound =
+          std::max(upperBound, allowedDifferencePercent * expectedValue);
+
+      // Check if actual value is within expected +/- allowedDifference
+      if (difference < lowerBound || difference > upperBound) {
+        LOG(ERROR) << fmt::format(
+            "noisy_sum_gaussian result is outside the expected range.\n"
+            "  Group: {}\n"
+            "  Actual: {}\n"
+            "  Expected: {}\n"
+            "  Difference: {}\n"
+            "  Allowed range: [{}, {}] (noise_scale = {})",
+            i,
+            actualValue,
+            expectedValue,
+            difference,
+            expectedValue + lowerBound,
+            expectedValue + upperBound,
+            noiseScale_);
+        failures++;
+      }
+    }
+
+    // Allow a very small percentage of failures for large result sets
+    if (numGroups >= 50) {
+      const auto maxFailures = static_cast<int>(allowedFailureRate * numGroups);
+      if (failures > maxFailures) {
+        LOG(ERROR) << fmt::format(
+            "Too many failures: {} out of {} groups (max allowed: {})",
+            failures,
+            numGroups,
+            maxFailures);
+        return false;
+      }
+      return true;
+    }
+
+    // For small result sets, require all groups to pass
+    return failures == 0;
+  }
+
+  void reset() override {
+    noiseScale_ = 0.0;
+    lowerBound_.reset();
+    upperBound_.reset();
+    name_.clear();
+    groupingKeys_.clear();
+    aggregateColumn_.clear();
+    expectedNoNoise_.reset();
+    clippedInput_.clear();
+  }
+
+ protected:
+  std::vector<RowVectorPtr> deduplicateInput(
+      const std::vector<RowVectorPtr>& input,
+      const core::FieldAccessTypedExprPtr& mask) {
+    // Deduplicate the input by using window functions to identify unique
+    // combinations of grouping keys and aggregate column, preserving the
+    // original row type.
+    VELOX_CHECK(!input.empty());
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+
+    // Create partition keys that include both the original grouping keys
+    // and the aggregate column to ensure proper deduplication for DISTINCT
+    // aggregation
+    auto partitionKeys = groupingKeys_;
+    partitionKeys.push_back(aggregateColumn_);
+
+    // Build partition by clause for window function
+    std::string partitionBy;
+    if (!partitionKeys.empty()) {
+      partitionBy = fmt::format(
+          "partition by {}", boost::algorithm::join(partitionKeys, ", "));
+    }
+
+    // Use row_number() window function to identify first occurrence of each
+    // unique combination, then filter to keep only those rows(row number = 1)
+    auto windowExpr = fmt::format("row_number() over ({}) as rn", partitionBy);
+
+    auto builder = PlanBuilder(planNodeIdGenerator).values(input);
+
+    // Apply mask filter first if it exists
+    if (mask != nullptr) {
+      builder = builder.filter(mask->name());
+    }
+
+    auto source = builder.window({windowExpr})
+                      .filter("rn = 1")
+                      .project(asRowType(input[0]->type())->names())
+                      .planNode();
+    auto deduplicated =
+        AssertQueryBuilder(source).copyResults(input[0]->pool());
+    return {deduplicated};
+  }
+
+  void extractNoiseScaleAndBound(
+      const RowVectorPtr& input,
+      const std::vector<core::TypedExprPtr>& args) {
+    auto secondArg = input->childAt(1);
+    if (secondArg->type()->isDouble()) {
+      noiseScale_ = secondArg->as<SimpleVector<double>>()->valueAt(0);
+    } else if (secondArg->type()->isBigint()) {
+      noiseScale_ = static_cast<double>(
+          secondArg->as<SimpleVector<int64_t>>()->valueAt(0));
+    }
+
+    // Extract lower and upper bound if they exist
+    if (args.size() > 3) {
+      auto thirdArg = input->childAt(2);
+      if (thirdArg->type()->isDouble()) {
+        lowerBound_ = thirdArg->as<SimpleVector<double>>()->valueAt(0);
+      } else if (thirdArg->type()->isBigint()) {
+        lowerBound_ = static_cast<double>(
+            thirdArg->as<SimpleVector<int64_t>>()->valueAt(0));
+      }
+
+      auto fourthArg = input->childAt(3);
+      if (fourthArg->type()->isDouble()) {
+        upperBound_ = fourthArg->as<SimpleVector<double>>()->valueAt(0);
+      } else if (fourthArg->type()->isBigint()) {
+        upperBound_ = static_cast<double>(
+            fourthArg->as<SimpleVector<int64_t>>()->valueAt(0));
+      }
+    }
+  }
+
+  void clipInput(const std::vector<RowVectorPtr>& input) {
+    auto pool = input[0]->pool();
+    for (const auto& rowVector : input) {
+      std::vector<VectorPtr> clippedChildren;
+
+      for (auto i = 0; i < rowVector->childrenSize(); ++i) {
+        auto column = rowVector->childAt(i);
+
+        if (i == 0) {
+          // Clip first column values within bounds and convert to double
+          auto size = column->size();
+          auto clippedColumn = BaseVector::create(DOUBLE(), size, pool);
+
+          for (auto j = 0; j < size; ++j) {
+            if (column->isNullAt(j)) {
+              clippedColumn->setNull(j, true);
+            } else {
+              auto type = column->type()->kind();
+              VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+                  updateValueByType, type, column, clippedColumn, j);
+            }
+          }
+          clippedChildren.push_back(clippedColumn);
+        } else {
+          // For other columns, just copy them as-is
+          clippedChildren.push_back(column);
+        }
+      }
+
+      // Create a new RowType with first column changed to double
+      auto originalRowType = asRowType(rowVector->type());
+      std::vector<std::string> names = originalRowType->names();
+      std::vector<TypePtr> types = originalRowType->children();
+
+      // Change first column type to double
+      types[0] = DOUBLE();
+
+      auto newRowType = ROW(std::move(names), std::move(types));
+
+      auto clippedRowVector = std::make_shared<RowVector>(
+          pool, newRowType, nullptr, rowVector->size(), clippedChildren);
+
+      clippedInput_.push_back(clippedRowVector);
+    }
+  }
+
+  // Helper function to update the value in the clipped column based on the
+  // data type.
+  template <TypeKind TData>
+  void updateValueByType(
+      VectorPtr& column,
+      VectorPtr& clippedColumn,
+      vector_size_t i) {
+    using T = typename TypeTraits<TData>::NativeType;
+    // Skip testing decimal types.
+    // Skip non-numeric types.
+    if constexpr (
+        std::is_same_v<T, TypeTraits<TypeKind::TIMESTAMP>> ||
+        std::is_same_v<T, TypeTraits<TypeKind::VARBINARY>> ||
+        std::is_same_v<T, TypeTraits<TypeKind::VARCHAR>> ||
+        std::is_same_v<T, facebook::velox::StringView> ||
+        std::is_same_v<T, facebook::velox::Timestamp>) {
+      VELOX_FAIL("NoisySumGaussianAggregate does not support this data type.");
+    } else {
+      // Convert the value to double and set it in the clipped column
+      auto rawValue = column->asFlatVector<T>()->valueAt(i);
+      // Skip NaN.
+      if (std::isnan(rawValue)) {
+        clippedColumn->setNull(i, true);
+        return;
+      }
+
+      // Apply clipping if bounds are set
+      double clippedValue = static_cast<double>(rawValue);
+      if (lowerBound_.has_value() && upperBound_.has_value()) {
+        clippedValue =
+            std::min(*upperBound_, std::max(*lowerBound_, clippedValue));
+      }
+
+      clippedColumn->asFlatVector<double>()->set(i, clippedValue);
+    }
+  }
+
+  double noiseScale_{0.0};
+  std::optional<double> lowerBound_;
+  std::optional<double> upperBound_;
+  std::string name_;
+  std::vector<std::string> groupingKeys_;
+  std::string aggregateColumn_;
+  RowVectorPtr expectedNoNoise_;
+  std::vector<RowVectorPtr> clippedInput_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/NumericHistogramInputGenerator.h b/velox/functions/prestosql/fuzzer/NumericHistogramInputGenerator.h
new file mode 100644
index 000000000000..5efce2f2c0f6
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/NumericHistogramInputGenerator.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 <boost/random/uniform_int_distribution.hpp>
+#include <boost/random/uniform_real_distribution.hpp>
+
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/type/Type.h"
+#include "velox/type/Variant.h"
+#include "velox/vector/BaseVector.h"
+
+namespace facebook::velox::exec::test {
+
+class PositiveNumberGenerator : public AbstractInputGenerator {
+ public:
+  PositiveNumberGenerator(size_t seed, const TypePtr& type)
+      : AbstractInputGenerator(seed, type, nullptr, 0.2) {}
+
+  Variant generate() override {
+    if (fuzzer::coinToss(rng_, nullRatio_)) {
+      return variant::null(type_->kind());
+    }
+    if (type_->isReal()) {
+      float value =
+          fuzzer::rand<float>(rng_, 0.0, std::numeric_limits<float>::max());
+      return variant(value);
+    } else if (type_->isDouble()) {
+      double value =
+          fuzzer::rand<double>(rng_, 0.0, std::numeric_limits<double>::max());
+      return variant(value);
+    }
+
+    // Should not reach here given the type checks in
+    // NumericHistogramInputGenerator
+    VELOX_UNREACHABLE("Unsupported type for PositiveNumberGenerator");
+  }
+};
+
+class NumericHistogramInputGenerator : public InputGenerator {
+ public:
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    VELOX_CHECK_GE(types.size(), 2);
+    VELOX_CHECK_LE(types.size(), 3);
+
+    std::vector<VectorPtr> inputs;
+    inputs.reserve(types.size());
+    const auto size = fuzzer.getOptions().vectorSize;
+    if (!bucketsSize_.has_value()) {
+      bucketsSize_ = fuzzer::rand<int64_t>(rng, 0, 9999);
+    }
+    inputs.push_back(
+        BaseVector::createConstant(BIGINT(), bucketsSize_.value(), size, pool));
+
+    if (types.size() > 1) {
+      VELOX_CHECK(types[1]->isDouble() || types[1]->isReal());
+      // Fixed some of the bugs in the original implementation, which makes the
+      // behavior non-matching in certain edge cases. We set the range to be
+      // positive to avoid these edge cases, which will succeed in velox but
+      // fail in Presto Java.
+      auto positiveGenerator =
+          std::make_shared<PositiveNumberGenerator>(rng(), types[1]);
+      auto valuesVector = fuzzer.fuzz(types[1], positiveGenerator);
+      inputs.push_back(valuesVector);
+    }
+
+    if (types.size() > 2) {
+      VELOX_CHECK(types[2]->isDouble() || types[2]->isReal());
+      // Same as above.
+      auto positiveGenerator =
+          std::make_shared<PositiveNumberGenerator>(rng(), types[2]);
+      auto weightsVector = fuzzer.fuzz(types[2], positiveGenerator);
+      inputs.push_back(weightsVector);
+    }
+    return inputs;
+  }
+
+  void reset() override {
+    bucketsSize_.reset();
+  }
+
+ private:
+  std::optional<int64_t> bucketsSize_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/QDigestAggInputGenerator.h b/velox/functions/prestosql/fuzzer/QDigestAggInputGenerator.h
new file mode 100644
index 000000000000..d1192a44c4a6
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/QDigestAggInputGenerator.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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"
+
+namespace facebook::velox::exec::test {
+
+class QDigestAggInputGenerator : public InputGenerator {
+ public:
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    VELOX_CHECK_GE(types.size(), 1);
+    VELOX_CHECK_LE(types.size(), 3);
+
+    std::vector<VectorPtr> inputs;
+    inputs.reserve(types.size());
+    auto valuesVector = fuzzer.fuzz(types[0]);
+    inputs.push_back(valuesVector);
+
+    if (types.size() > 1) {
+      VELOX_CHECK(types[1]->isBigint());
+      auto weightsVector = fuzzer.fuzz(types[1]);
+      inputs.push_back(weightsVector);
+    }
+
+    if (types.size() > 2) {
+      VELOX_CHECK(types[2]->isDouble());
+      const auto size = fuzzer.getOptions().vectorSize;
+      // Make sure to use the same value of 'accuracy' for all batches in a
+      // given Fuzzer iteration.
+      if (!accuracy_.has_value()) {
+        boost::random::uniform_real_distribution<double> dist(0.00001, 1.0);
+        accuracy_ = dist(rng);
+      }
+      inputs.push_back(
+          BaseVector::createConstant(DOUBLE(), accuracy_.value(), size, pool));
+    }
+    return inputs;
+  }
+
+  void reset() override {
+    accuracy_.reset();
+  }
+
+ private:
+  std::optional<double> accuracy_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/QDigestAggResultVerifier.h b/velox/functions/prestosql/fuzzer/QDigestAggResultVerifier.h
new file mode 100644
index 000000000000..6e6b84ddca28
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/QDigestAggResultVerifier.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/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/functions/lib/QuantileDigest.h"
+
+namespace facebook::velox::exec::test {
+
+class QDigestAggResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return true;
+  }
+
+  bool supportsVerify() override {
+    return false;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<core::ExprPtr>& /*projections*/,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    keys_ = groupingKeys;
+    resultName_ = aggregateName;
+    argumentTypeKind_ = aggregate.call->inputs()[0]->type()->kind();
+  }
+
+  void initializeWindow(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<core::ExprPtr>& /*projections*/,
+      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 {
+    keys_ = {"row_number"};
+    resultName_ = windowName;
+    argumentTypeKind_ = function.functionCall->inputs()[0]->type()->kind();
+  }
+
+  bool compare(const RowVectorPtr& result, const RowVectorPtr& altResult)
+      override {
+    VELOX_CHECK_EQ(result->size(), altResult->size());
+
+    auto projection = keys_;
+    projection.push_back(resultName_);
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto builder = PlanBuilder(planNodeIdGenerator).values({result});
+    if (!keys_.empty()) {
+      builder = builder.orderBy(keys_, false);
+    }
+    auto sortByKeys = builder.project(projection).planNode();
+    auto sortedResult =
+        AssertQueryBuilder(sortByKeys).copyResults(result->pool());
+
+    builder = PlanBuilder(planNodeIdGenerator).values({altResult});
+    if (!keys_.empty()) {
+      builder = builder.orderBy(keys_, false);
+    }
+    sortByKeys = builder.project(projection).planNode();
+    auto sortedAltResult =
+        AssertQueryBuilder(sortByKeys).copyResults(altResult->pool());
+
+    VELOX_CHECK_EQ(sortedResult->size(), sortedAltResult->size());
+    auto size = sortedResult->size();
+    for (auto i = 0; i < size; i++) {
+      auto resultIsNull = sortedResult->childAt(resultName_)->isNullAt(i);
+      auto altResultIsNull = sortedAltResult->childAt(resultName_)->isNullAt(i);
+      if (resultIsNull || altResultIsNull) {
+        VELOX_CHECK(resultIsNull && altResultIsNull);
+        continue;
+      }
+
+      auto resultValue = sortedResult->childAt(resultName_)
+                             ->as<SimpleVector<StringView>>()
+                             ->valueAt(i);
+      auto altResultValue = sortedAltResult->childAt(resultName_)
+                                ->as<SimpleVector<StringView>>()
+                                ->valueAt(i);
+      if (resultValue == altResultValue) {
+        continue;
+      } else {
+        if (argumentTypeKind_ == TypeKind::BIGINT) {
+          checkEquivalentQDigest<int64_t>(resultValue, altResultValue);
+        } else if (argumentTypeKind_ == TypeKind::DOUBLE) {
+          checkEquivalentQDigest<double>(resultValue, altResultValue);
+        } else if (argumentTypeKind_ == TypeKind::REAL) {
+          checkEquivalentQDigest<float>(resultValue, altResultValue);
+        } else {
+          VELOX_UNSUPPORTED("Unsupported argument type");
+        }
+      }
+    }
+    return true;
+  }
+
+  bool verify(const RowVectorPtr& /*result*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void reset() override {
+    keys_.clear();
+    resultName_.clear();
+  }
+
+ private:
+  template <typename T>
+  void checkEquivalentQDigest(
+      const StringView& result,
+      const StringView& altResult) {
+    functions::qdigest::QuantileDigest<T, std::allocator<T>> resultDigest{
+        std::allocator<T>(), result.data()};
+    functions::qdigest::QuantileDigest<T, std::allocator<T>> altResultDigest{
+        std::allocator<T>(), altResult.data()};
+
+    for (auto quantile : kQuantiles) {
+      variant resultValue = resultDigest.estimateQuantile(quantile);
+      variant altResultValue = altResultDigest.estimateQuantile(quantile);
+      VELOX_CHECK(
+          resultValue.equalsWithEpsilon(altResultValue),
+          "{} vs. {}",
+          resultValue.value<T>(),
+          altResultValue.value<T>());
+    }
+  }
+
+  static constexpr double kQuantiles[] = {
+      0.01,
+      0.05,
+      0.1,
+      0.25,
+      0.50,
+      0.75,
+      0.9,
+      0.95,
+      0.99,
+  };
+
+  std::vector<std::string> keys_;
+  std::string resultName_;
+  TypeKind argumentTypeKind_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/SortArrayTransformer.h b/velox/functions/prestosql/fuzzer/SortArrayTransformer.h
index 905ea3419dcd..ee19f32e124a 100644
--- a/velox/functions/prestosql/fuzzer/SortArrayTransformer.h
+++ b/velox/functions/prestosql/fuzzer/SortArrayTransformer.h
@@ -41,7 +41,9 @@ class SortArrayTransformer : public ExprTransformer {
           type, facebook::velox::variant::null(type->kind()));
     } else {
       return std::make_shared<facebook::velox::core::CallTypedExpr>(
-          type, std::vector<TypedExprPtr>{std::move(expr)}, "array_sort");
+          type,
+          std::vector<TypedExprPtr>{std::move(expr)},
+          "$internal$canonicalize");
     }
   }
 
diff --git a/velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h b/velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h
new file mode 100644
index 000000000000..8b78a0f139e2
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.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 <boost/random/uniform_int_distribution.hpp>
+#include <boost/random/uniform_real_distribution.hpp>
+
+#include "velox/exec/fuzzer/InputGenerator.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+namespace facebook::velox::exec::test {
+
+class TDigestAggregateInputGenerator : public InputGenerator {
+ public:
+  std::vector<VectorPtr> generate(
+      const std::vector<TypePtr>& types,
+      VectorFuzzer& fuzzer,
+      FuzzerGenerator& rng,
+      memory::MemoryPool* pool) override {
+    VELOX_CHECK_GE(types.size(), 1);
+    VELOX_CHECK_LE(types.size(), 3);
+
+    std::vector<VectorPtr> inputs;
+    inputs.reserve(types.size());
+
+    // Values vector
+    VELOX_CHECK(types[0]->isDouble());
+    auto valuesVector = fuzzer.fuzz(types[0]);
+    inputs.push_back(valuesVector);
+
+    // Weight is optional
+    if (types.size() > 1) {
+      VELOX_CHECK(types[1]->isBigint());
+      auto weightsVector = fuzzer.fuzz(types[1]);
+      inputs.push_back(weightsVector);
+    }
+
+    // Compression is optional
+    if (types.size() > 2) {
+      VELOX_CHECK(types[2]->isDouble());
+      const auto size = fuzzer.getOptions().vectorSize;
+      // Make sure to use the same value of 'compression' for all batches in a
+      // given Fuzzer iteration.
+      if (!compression_.has_value()) {
+        boost::random::uniform_real_distribution<double> dist(10.0, 1000.0);
+        compression_ = dist(rng);
+      }
+      inputs.push_back(
+          BaseVector::createConstant(
+              DOUBLE(), compression_.value(), size, pool));
+    }
+
+    return inputs;
+  }
+
+  void reset() override {
+    compression_.reset();
+  }
+
+ private:
+  std::optional<double> compression_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/TDigestAggregateResultVerifier.h b/velox/functions/prestosql/fuzzer/TDigestAggregateResultVerifier.h
new file mode 100644
index 000000000000..b5a8c2b24ff2
--- /dev/null
+++ b/velox/functions/prestosql/fuzzer/TDigestAggregateResultVerifier.h
@@ -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.
+ */
+#pragma once
+
+#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/functions/lib/TDigest.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::exec::test {
+
+class TDigestAggregateResultVerifier : public ResultVerifier {
+ public:
+  bool supportsCompare() override {
+    return true;
+  }
+
+  bool supportsVerify() override {
+    return false;
+  }
+
+  void initialize(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<core::ExprPtr>& /*projections*/,
+      const std::vector<std::string>& groupingKeys,
+      const core::AggregationNode::Aggregate& aggregate,
+      const std::string& aggregateName) override {
+    keys_ = groupingKeys;
+    resultName_ = aggregateName;
+    argumentTypeKind_ = aggregate.call->inputs()[0]->type()->kind();
+  }
+
+  void initializeWindow(
+      const std::vector<RowVectorPtr>& /*input*/,
+      const std::vector<core::ExprPtr>& /*projections*/,
+      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 {
+    keys_ = {"row_number"};
+    resultName_ = windowName;
+    argumentTypeKind_ = function.functionCall->inputs()[0]->type()->kind();
+  }
+
+  bool compare(const RowVectorPtr& result, const RowVectorPtr& altResult)
+      override {
+    VELOX_CHECK_EQ(result->size(), altResult->size());
+
+    auto projection = keys_;
+    projection.push_back(resultName_);
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto builder = PlanBuilder(planNodeIdGenerator).values({result});
+    if (!keys_.empty()) {
+      builder = builder.orderBy(keys_, false);
+    }
+    auto sortByKeys = builder.project(projection).planNode();
+    auto sortedResult =
+        AssertQueryBuilder(sortByKeys).copyResults(result->pool());
+
+    builder = PlanBuilder(planNodeIdGenerator).values({altResult});
+    if (!keys_.empty()) {
+      builder = builder.orderBy(keys_, false);
+    }
+    sortByKeys = builder.project(projection).planNode();
+    auto sortedAltResult =
+        AssertQueryBuilder(sortByKeys).copyResults(altResult->pool());
+
+    VELOX_CHECK_EQ(sortedResult->size(), sortedAltResult->size());
+    auto size = sortedResult->size();
+    for (auto i = 0; i < size; i++) {
+      auto resultIsNull = sortedResult->childAt(resultName_)->isNullAt(i);
+      auto altResultIsNull = sortedAltResult->childAt(resultName_)->isNullAt(i);
+      if (resultIsNull || altResultIsNull) {
+        VELOX_CHECK(resultIsNull && altResultIsNull);
+        continue;
+      }
+
+      auto resultValue = sortedResult->childAt(resultName_)
+                             ->as<SimpleVector<StringView>>()
+                             ->valueAt(i);
+      auto altResultValue = sortedAltResult->childAt(resultName_)
+                                ->as<SimpleVector<StringView>>()
+                                ->valueAt(i);
+      if (resultValue == altResultValue) {
+        continue;
+      } else {
+        if (argumentTypeKind_ == TypeKind::DOUBLE) {
+          checkEquivalentTDigest(resultValue, altResultValue);
+        } else {
+          VELOX_UNSUPPORTED("Unsupported argument type");
+        }
+      }
+    }
+    return true;
+  }
+
+  bool verify(const RowVectorPtr& /*result*/) override {
+    VELOX_UNSUPPORTED();
+  }
+
+  void reset() override {
+    keys_.clear();
+    resultName_.clear();
+  }
+
+ private:
+  void checkEquivalentTDigest(
+      const StringView& result,
+      const StringView& altResult) {
+    // Create TDigests from serialized data
+    facebook::velox::functions::TDigest<> resultTdigest;
+    facebook::velox::functions::TDigest<> altResultTdigest;
+    std::vector<int16_t> positions;
+
+    try {
+      resultTdigest.mergeDeserialized(positions, result.data());
+      resultTdigest.compress(positions);
+
+      positions.clear();
+      altResultTdigest.mergeDeserialized(positions, altResult.data());
+      altResultTdigest.compress(positions);
+    } catch (const std::exception& e) {
+      VELOX_FAIL("Failed to deserialize TDigest: {}", e.what());
+    }
+
+    // Compare TDigest values at specific quantiles
+    for (auto quantile : kQuantiles) {
+      double resultQuantile = resultTdigest.estimateQuantile(quantile);
+      double altResultQuantile = altResultTdigest.estimateQuantile(quantile);
+
+      variant resultVariant(resultQuantile);
+      variant altResultVariant(altResultQuantile);
+      VELOX_CHECK(
+          resultVariant.equalsWithEpsilon(altResultVariant),
+          "TDigest quantile values differ at {}: {} vs {}",
+          quantile,
+          resultQuantile,
+          altResultQuantile);
+    }
+  }
+
+  static constexpr double kQuantiles[] = {
+      0.01,
+      0.05,
+      0.1,
+      0.25,
+      0.50,
+      0.75,
+      0.9,
+      0.95,
+      0.99,
+  };
+
+  std::vector<std::string> keys_;
+  std::string resultName_;
+  TypeKind argumentTypeKind_;
+};
+
+} // namespace facebook::velox::exec::test
diff --git a/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
index 3b6c37343eaa..d96f90340808 100644
--- a/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
+++ b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
@@ -27,6 +27,11 @@
 #include "velox/functions/prestosql/fuzzer/ApproxPercentileResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/AverageResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/MinMaxInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/NumericHistogramInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/QDigestAggInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/QDigestAggResultVerifier.h"
+#include "velox/functions/prestosql/fuzzer/TDigestAggregateInputGenerator.h"
+#include "velox/functions/prestosql/fuzzer/TDigestAggregateResultVerifier.h"
 #include "velox/functions/prestosql/fuzzer/WindowOffsetInputGenerator.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/functions/prestosql/window/WindowFunctionsRegistration.h"
@@ -73,10 +78,14 @@ getCustomInputGenerators() {
       {"approx_distinct", std::make_shared<ApproxDistinctInputGenerator>()},
       {"approx_set", std::make_shared<ApproxDistinctInputGenerator>()},
       {"approx_percentile", std::make_shared<ApproxPercentileInputGenerator>()},
+      {"tdigest_agg", std::make_shared<TDigestAggregateInputGenerator>()},
+      {"qdigest_agg", std::make_shared<QDigestAggInputGenerator>()},
       {"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)}};
+      {"ntile", std::make_shared<WindowOffsetInputGenerator>(0)},
+      {"numeric_histogram", std::make_shared<NumericHistogramInputGenerator>()},
+  };
 }
 
 } // namespace
@@ -101,7 +110,7 @@ int main(int argc, char** 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 = {
+  std::unordered_set<std::string> skipFunctions = {
       // https://github.com/prestodb/presto/issues/24936
       "classification_fall_out",
       "classification_precision",
@@ -117,12 +126,45 @@ int main(int argc, char** argv) {
       "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",
+      // Skip non-deterministic functions.
+      "noisy_avg_gaussian",
+      "noisy_count_if_gaussian",
+      "noisy_count_gaussian",
+      "noisy_sum_gaussian",
+      "noisy_approx_set_sfm",
+      "noisy_approx_distinct_sfm",
+      "noisy_approx_set_sfm_from_index_and_zeros",
+      "reservoir_sample",
+      // https://github.com/facebookincubator/velox/issues/13547
+      "merge",
+      // https://github.com/facebookincubator/velox/issues/14423
+      "numeric_histogram",
+      // Come back to SetDigest and KHLL aggregate functions.
+      "make_set_digest",
+      "merge_set_digest",
+      "khyperloglog_agg", // TODO: Remove from skip list once the KHLL result
+      // verifier is added.
+      "convex_hull_agg",
+      "geometry_union_agg",
+      "geometry_union_agg_partial",
+      "geometry_union_agg_merge",
+      "geometry_union_agg_extract",
+      "geometry_union_agg_merge_extract",
+      "convex_hull_agg_partial",
+      "convex_hull_agg_merge",
+      "convex_hull_agg_extract",
+      "convex_hull_agg_merge_extract",
   };
 
+  if (!FLAGS_presto_url.empty()) {
+    skipFunctions.insert({
+        // min_by and max_by with 3 arguments produces results with different
+        // orders of elements from Presto.
+        "min_by",
+        "max_by",
+    });
+  }
+
   // Functions whose results verification should be skipped. These can be
   // functions that return complex-typed results containing floating-point
   // fields.
@@ -130,6 +172,8 @@ int main(int argc, char** argv) {
   using facebook::velox::exec::test::ApproxDistinctResultVerifier;
   using facebook::velox::exec::test::ApproxPercentileResultVerifier;
   using facebook::velox::exec::test::AverageResultVerifier;
+  using facebook::velox::exec::test::QDigestAggResultVerifier;
+  using facebook::velox::exec::test::TDigestAggregateResultVerifier;
 
   static const std::unordered_map<
       std::string,
@@ -141,6 +185,8 @@ int main(int argc, char** argv) {
           {"approx_percentile",
            std::make_shared<ApproxPercentileResultVerifier>()},
           {"approx_most_frequent", nullptr},
+          {"tdigest_agg", std::make_shared<TDigestAggregateResultVerifier>()},
+          {"qdigest_agg", std::make_shared<QDigestAggResultVerifier>()},
           {"merge", nullptr},
           // Semantically inconsistent functions
           {"skewness", nullptr},
@@ -177,6 +223,8 @@ int main(int argc, char** argv) {
       "max_by",
       "min_by",
       "multimap_agg",
+      "tdigest_agg",
+      "qdigest_agg",
   };
 
   using Runner = facebook::velox::exec::test::WindowFuzzerRunner;
diff --git a/velox/functions/prestosql/geospatial/CMakeLists.txt b/velox/functions/prestosql/geospatial/CMakeLists.txt
index c24ec8e6d7d9..6ab2f90dc677 100644
--- a/velox/functions/prestosql/geospatial/CMakeLists.txt
+++ b/velox/functions/prestosql/geospatial/CMakeLists.txt
@@ -11,6 +11,11 @@
 # WITHOUT 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_geo GeometrySerde.cpp)
+velox_add_library(velox_functions_geo GeometryUtils.cpp)
 
-velox_link_libraries(velox_functions_geo velox_functions_lib GEOS::geos)
+velox_link_libraries(
+  velox_functions_geo
+  velox_common_geospatial_serde
+  velox_functions_lib
+  GEOS::geos
+)
diff --git a/velox/functions/prestosql/geospatial/GeometrySerde.cpp b/velox/functions/prestosql/geospatial/GeometrySerde.cpp
deleted file mode 100644
index ebc8a6f2518b..000000000000
--- a/velox/functions/prestosql/geospatial/GeometrySerde.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 "velox/functions/prestosql/geospatial/GeometrySerde.h"
-
-#include <geos/io/WKBReader.h>
-#include <geos/io/WKBWriter.h>
-
-namespace facebook::velox::functions::geospatial {
-
-std::unique_ptr<geos::geom::Geometry> deserializeGeometry(
-    const StringView& geometryString) {
-  std::istringstream inputString(geometryString);
-  geos::io::WKBReader reader;
-  std::unique_ptr<geos::geom::Geometry> geosGeometry = reader.read(inputString);
-  VELOX_DCHECK_NOT_NULL(geosGeometry);
-  return geosGeometry;
-}
-
-std::string serializeGeometry(const geos::geom::Geometry& geosGeometry) {
-  std::ostringstream outputStream;
-  geos::io::WKBWriter writer;
-  writer.write(geosGeometry, outputStream);
-  const std::string outputString = outputStream.str();
-  return outputString;
-}
-
-} // namespace facebook::velox::functions::geospatial
diff --git a/velox/functions/prestosql/geospatial/GeometrySerde.h b/velox/functions/prestosql/geospatial/GeometrySerde.h
deleted file mode 100644
index 8028db47b1cd..000000000000
--- a/velox/functions/prestosql/geospatial/GeometrySerde.h
+++ /dev/null
@@ -1,33 +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 <geos/geom/Geometry.h>
-#include "velox/type/StringView.h"
-
-namespace facebook::velox::functions::geospatial {
-
-/// Deserialize Velox's internal format to a geometry.  Do not call this within
-/// GEOS_TRY macro: it will catch the exceptions that need to bubble up.
-std::unique_ptr<geos::geom::Geometry> deserializeGeometry(
-    const StringView& geometryString);
-
-/// Serialize geometry into Velox's internal format.  Do not call this within
-/// GEOS_TRY macro: it will catch the exceptions that need to bubble up.
-std::string serializeGeometry(const geos::geom::Geometry& geosGeometry);
-
-} // namespace facebook::velox::functions::geospatial
diff --git a/velox/functions/prestosql/geospatial/GeometryUtils.cpp b/velox/functions/prestosql/geospatial/GeometryUtils.cpp
new file mode 100644
index 000000000000..0e2ad4be61c5
--- /dev/null
+++ b/velox/functions/prestosql/geospatial/GeometryUtils.cpp
@@ -0,0 +1,735 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/geospatial/GeometryUtils.h"
+#include <geos/geom/prep/PreparedGeometryFactory.h>
+#include <geos/operation/valid/IsSimpleOp.h>
+#include <geos/operation/valid/IsValidOp.h>
+#include <queue>
+#include "velox/common/base/Exceptions.h"
+#include "velox/common/geospatial/GeometryConstants.h"
+#include "velox/functions/prestosql/types/BingTileType.h"
+
+using geos::operation::valid::IsSimpleOp;
+using geos::operation::valid::IsValidOp;
+
+namespace {
+
+class SphericalExcessCalculator {
+  static constexpr double TWO_PI = 2 * M_PI;
+  static constexpr double THREE_PI = 3 * M_PI;
+
+  double sphericalExcess = 0.0;
+  double courseDelta = 0.0;
+
+  bool firstPoint = true;
+  double firstInitialBearing = 0.0;
+  double previousFinalBearing = 0.0;
+
+  double previousPhi = 0.0;
+  double previousCos = 0.0;
+  double previousSin = 0.0;
+  double previousTan = 0.0;
+  double previousLongitude = 0.0;
+
+  bool done = false;
+
+  static double toRadians(double deg) {
+    return deg * M_PI / 180.0;
+  }
+
+ public:
+  explicit SphericalExcessCalculator(const geos::geom::Coordinate& endPoint) {
+    previousPhi = toRadians(endPoint.y);
+    previousSin = std::sin(previousPhi);
+    previousCos = std::cos(previousPhi);
+    previousTan = std::tan(previousPhi / 2);
+    previousLongitude = toRadians(endPoint.x);
+  }
+
+  void add(const geos::geom::Coordinate& point) {
+    VELOX_CHECK(!done, "Computation of spherical excess is complete");
+
+    double phi = toRadians(point.y);
+    double tan = std::tan(phi / 2);
+    double longitude = toRadians(point.x);
+
+    VELOX_USER_CHECK(
+        (longitude != previousLongitude || phi != previousPhi),
+        "Polygon is not valid: it has two identical consecutive vertices");
+
+    double deltaLongitude = longitude - previousLongitude;
+    sphericalExcess += 2 *
+        std::atan2(std::tan(deltaLongitude / 2) * (previousTan + tan),
+                   1 + previousTan * tan);
+
+    double cos = std::cos(phi);
+    double sin = std::sin(phi);
+    double sinOfDeltaLongitude = std::sin(deltaLongitude);
+    double cosOfDeltaLongitude = std::cos(deltaLongitude);
+
+    // Initial bearing from previous to current
+    double y = sinOfDeltaLongitude * cos;
+    double x = previousCos * sin - previousSin * cos * cosOfDeltaLongitude;
+    double initialBearing = std::fmod(std::atan2(y, x) + TWO_PI, TWO_PI);
+
+    // Final bearing from previous to current = opposite of bearing from current
+    // to previous
+    double finalY = -sinOfDeltaLongitude * previousCos;
+    double finalX = previousSin * cos - previousCos * sin * cosOfDeltaLongitude;
+    double finalBearing = std::fmod(std::atan2(finalY, finalX) + M_PI, TWO_PI);
+
+    if (firstPoint) {
+      // Keep our initial bearing around, and we'll use it at the end
+      // with the last final bearing
+      firstInitialBearing = initialBearing;
+      firstPoint = false;
+    } else {
+      courseDelta +=
+          std::fmod(initialBearing - previousFinalBearing + THREE_PI, TWO_PI) -
+          M_PI;
+    }
+
+    courseDelta +=
+        std::fmod(finalBearing - initialBearing + THREE_PI, TWO_PI) - M_PI;
+
+    previousFinalBearing = finalBearing;
+    previousCos = cos;
+    previousSin = sin;
+    previousPhi = phi;
+    previousTan = tan;
+    previousLongitude = longitude;
+  }
+
+  double computeSphericalExcess() {
+    if (!done) {
+      courseDelta +=
+          std::fmod(
+              firstInitialBearing - previousFinalBearing + THREE_PI, TWO_PI) -
+          M_PI;
+
+      // The courseDelta should be 2Pi or - 2Pi, unless a pole is enclosed (and
+      // then it should be ~ 0) In which case we need to correct the spherical
+      // excess by 2Pi
+      if (std::abs(courseDelta) < M_PI / 4) {
+        sphericalExcess = std::abs(sphericalExcess) - TWO_PI;
+      }
+      done = true;
+    }
+    return sphericalExcess;
+  }
+
+  static double excessFromCoordinates(
+      const geos::geom::CoordinateSequence& coords) {
+    int start = 0;
+    size_t end = coords.size();
+    // Our calculations rely on not processing the same point twice
+    if (coords.getAt(end - 1).equals(coords.getAt(start))) {
+      end = end - 1;
+    }
+
+    // A path with less than 3 distinct points is not valid for calculating an
+    // area
+    VELOX_USER_CHECK(
+        end - start > 2,
+        "Polygon is not valid: a loop contains less then 3 vertices.");
+
+    // Initialize the calculator with the last point
+    SphericalExcessCalculator calculator(coords.getAt(end - 1));
+
+    for (int i = start; i < end; i++) {
+      calculator.add(coords.getAt(i));
+    }
+
+    return calculator.computeSphericalExcess();
+  }
+};
+} // namespace
+
+namespace facebook::velox::functions::geospatial {
+
+static constexpr int32_t kMaxCoveringCount = 1'000'000;
+
+GeometryCollectionIterator::GeometryCollectionIterator(
+    const geos::geom::Geometry* geometry) {
+  if (!geometry) {
+    VELOX_USER_FAIL("geometry is null");
+  }
+  geometriesDeque.push_back(geometry);
+}
+// Returns true if there is a next geometry to iterate over
+bool GeometryCollectionIterator::hasNext() {
+  while (!geometriesDeque.empty()) {
+    const geos::geom::Geometry* top = geometriesDeque.back();
+    // Check if top is a GeometryCollection
+    if (top->getGeometryTypeId() == geos::geom::GEOS_GEOMETRYCOLLECTION) {
+      geometriesDeque.pop_back();
+      const geos::geom::GeometryCollection* collection =
+          dynamic_cast<const geos::geom::GeometryCollection*>(top);
+      if (collection) {
+        // Push children in reverse order so that the first child is on top of
+        // the stack
+        for (int i = static_cast<int>(collection->getNumGeometries()) - 1;
+             i >= 0;
+             --i) {
+          geometriesDeque.push_back(collection->getGeometryN(i));
+        }
+        continue; // Check again with new top
+      } else {
+        VELOX_FAIL("Failed to cast to GeometryCollection");
+      }
+    } else {
+      // Top is not a collection, so we have a next geometry
+      return true;
+    }
+  }
+  return false;
+}
+
+const geos::geom::Geometry* GeometryCollectionIterator::next() {
+  if (!hasNext()) {
+    throw std::out_of_range("No more geometries");
+  }
+  const geos::geom::Geometry* nextGeometry = geometriesDeque.back(); // NOLINT
+  geometriesDeque.pop_back();
+  return nextGeometry;
+}
+
+std::vector<const geos::geom::Geometry*> flattenCollection(
+    const geos::geom::Geometry* geometry) {
+  std::vector<const geos::geom::Geometry*> result;
+  GeometryCollectionIterator it(geometry);
+  while (it.hasNext()) {
+    result.push_back(it.next());
+  }
+  return result;
+}
+
+std::optional<std::string> geometryInvalidReason(
+    const geos::geom::Geometry* geometry) {
+  if (geometry == nullptr) {
+    // Null geometries are a problem, but they not invalid or non-simple.
+    return std::nullopt;
+  }
+
+  IsValidOp isValidOp(geometry);
+  const geos::operation::valid::TopologyValidationError*
+      topologyValidationError = isValidOp.getValidationError();
+  if (topologyValidationError != nullptr) {
+    return fmt::format(
+        "Invalid {}: {}",
+        geometry->getGeometryType(),
+        topologyValidationError->getMessage());
+  }
+
+  IsSimpleOp isSimpleOp(geometry);
+  if (isSimpleOp.isSimple()) {
+    return std::nullopt;
+  }
+
+  std::string_view description;
+  switch (geometry->getGeometryTypeId()) {
+    case geos::geom::GeometryTypeId::GEOS_POINT:
+      description = "Invalid point";
+      break;
+    case geos::geom::GeometryTypeId::GEOS_MULTIPOINT:
+      description = "Repeated point";
+      break;
+    case geos::geom::GeometryTypeId::GEOS_LINESTRING:
+    case geos::geom::GeometryTypeId::GEOS_LINEARRING:
+    case geos::geom::GeometryTypeId::GEOS_MULTILINESTRING:
+      description = "Self-intersection at or near";
+      break;
+    case geos::geom::GeometryTypeId::GEOS_POLYGON:
+    case geos::geom::GeometryTypeId::GEOS_MULTIPOLYGON:
+    case geos::geom::GeometryTypeId::GEOS_GEOMETRYCOLLECTION:
+      // In OGC (which GEOS follows): Polygons, MultiPolygons, Geometry
+      // Collections are simple.
+      // This shouldn't happen, but in case it does, return a reasonable
+      // generic message.
+      description = "Topology exception at or near";
+      break;
+    default:
+      return fmt::format(
+          "Unknown Geometry type: {}", geometry->getGeometryType());
+  }
+  geos::geom::Coordinate nonSimpleLocation = isSimpleOp.getNonSimpleLocation();
+  return fmt::format(
+      "Non-simple {}: {} ({} {})",
+      geometry->getGeometryType(),
+      description,
+      nonSimpleLocation.x,
+      nonSimpleLocation.y);
+}
+
+Status validateLatitudeLongitude(double latitude, double longitude) {
+  if (FOLLY_UNLIKELY(
+          latitude < common::geospatial::kMinLatitude ||
+          latitude > common::geospatial::kMaxLatitude ||
+          longitude < common::geospatial::kMinLongitude ||
+          longitude > common::geospatial::kMaxLongitude ||
+          std::isnan(latitude) || std::isnan(longitude))) {
+    return Status::UserError(
+        fmt::format(
+            "Latitude must be in range [{}, {}] and longitude must be in range [{}, {}]. Got latitude: {} and longitude: {}",
+            common::geospatial::kMinLatitude,
+            common::geospatial::kMaxLatitude,
+            common::geospatial::kMinLongitude,
+            common::geospatial::kMaxLongitude,
+            latitude,
+            longitude));
+  }
+  return Status::OK();
+}
+
+namespace {
+
+FOLLY_ALWAYS_INLINE void checkLatitudeLongitudeBounds(
+    double latitude,
+    double longitude) {
+  if (FOLLY_UNLIKELY(
+          latitude > common::geospatial::kMaxBingTileLatitude ||
+          latitude < common::geospatial::kMinBingTileLatitude)) {
+    VELOX_USER_FAIL(
+        fmt::format(
+            "Latitude span for the geometry must be in [{:.2f}, {:.2f}] range",
+            common::geospatial::kMinBingTileLatitude,
+            common::geospatial::kMaxBingTileLatitude));
+  }
+  if (FOLLY_UNLIKELY(
+          longitude > common::geospatial::kMaxLongitude ||
+          longitude < common::geospatial::kMinLongitude)) {
+    VELOX_USER_FAIL(
+        fmt::format(
+            "Longitude span for the geometry must be in [{:.2f}, {:.2f}] range",
+            common::geospatial::kMinLongitude,
+            common::geospatial::kMaxLongitude));
+  }
+}
+
+std::optional<std::vector<int64_t>> handleTrivialMinimalTileCoveringCases(
+    const geos::geom::Envelope& envelope,
+    int32_t zoom) {
+  if (envelope.isNull()) {
+    return std::vector<int64_t>{};
+  }
+
+  checkLatitudeLongitudeBounds(envelope.getMinY(), envelope.getMinX());
+  checkLatitudeLongitudeBounds(envelope.getMaxY(), envelope.getMaxX());
+
+  if (FOLLY_UNLIKELY(zoom == 0)) {
+    return std::vector<int64_t>{
+        static_cast<int64_t>(BingTileType::bingTileCoordsToInt(0, 0, 0))};
+  }
+
+  if (FOLLY_UNLIKELY(
+          envelope.getMaxX() == envelope.getMinX() &&
+          envelope.getMaxY() == envelope.getMinY())) {
+    auto res = BingTileType::latitudeLongitudeToTile(
+        envelope.getMaxY(), envelope.getMaxX(), zoom);
+    if (res.hasError()) {
+      VELOX_FAIL(res.error());
+    }
+    return std::vector<int64_t>{static_cast<int64_t>(res.value())};
+  }
+  return std::nullopt;
+}
+
+std::unique_ptr<geos::geom::Envelope> tileToEnvelope(int64_t tile) {
+  uint8_t zoom = BingTileType::bingTileZoom(tile);
+  uint32_t x = BingTileType::bingTileX(tile);
+  uint32_t y = BingTileType::bingTileY(tile);
+
+  double minX = BingTileType::tileXToLongitude(x, zoom);
+  double maxX = BingTileType::tileXToLongitude(x + 1, zoom);
+  double minY = BingTileType::tileYToLatitude(y, zoom);
+  double maxY = BingTileType::tileYToLatitude(y + 1, zoom);
+
+  return std::make_unique<geos::geom::Envelope>(minX, maxX, minY, maxY);
+}
+
+struct TilingEntry {
+  TilingEntry(int64_t tile, geos::geom::GeometryFactory* factory)
+      : tile{tile},
+        envelope{tileToEnvelope(tile)},
+        geometry{factory->toGeometry(envelope.get())} {}
+
+  int64_t tile;
+  std::unique_ptr<geos::geom::Envelope> envelope;
+  std::unique_ptr<geos::geom::Geometry> geometry;
+};
+
+bool satisfiesTileEdgeCondition(
+    const geos::geom::Envelope& query,
+    const TilingEntry& tilingEntry) {
+  int64_t tile = tilingEntry.tile;
+
+  int64_t maxXy = (1 << BingTileType::bingTileZoom(tile)) - 1;
+  if (BingTileType::bingTileY(tile) < maxXy &&
+      query.getMaxY() == tilingEntry.envelope->getMinY()) {
+    return false;
+  }
+  if (BingTileType::bingTileX(tile) < maxXy &&
+      query.getMinX() == tilingEntry.envelope->getMaxX()) {
+    return false;
+  }
+  return true;
+}
+
+std::vector<int64_t> getRawTilesCoveringGeometry(
+    const geos::geom::Geometry& geometry,
+    int32_t maxZoom) {
+  const geos::geom::Envelope* envelope = geometry.getEnvelopeInternal();
+  geos::geom::GeometryFactory::Ptr factory =
+      geos::geom::GeometryFactory::create();
+
+  std::optional<std::vector<int64_t>> trivialCases =
+      handleTrivialMinimalTileCoveringCases(*envelope, maxZoom);
+  if (trivialCases.has_value()) {
+    return trivialCases.value();
+  }
+
+  auto preparedGeometry =
+      geos::geom::prep::PreparedGeometryFactory::prepare(&geometry);
+  std::stack<TilingEntry> stack;
+
+  auto addIntersecting = [&](std::int64_t tile) {
+    auto tilingEntry = TilingEntry(tile, factory.get());
+    if (satisfiesTileEdgeCondition(*envelope, tilingEntry) &&
+        preparedGeometry->intersects(tilingEntry.geometry.get())) {
+      stack.push(std::move(tilingEntry));
+    }
+  };
+
+  std::vector<uint64_t> baseTiles = {
+      BingTileType::bingTileCoordsToInt(0, 0, 1),
+      BingTileType::bingTileCoordsToInt(0, 1, 1),
+      BingTileType::bingTileCoordsToInt(1, 0, 1),
+      BingTileType::bingTileCoordsToInt(1, 1, 1)};
+  std::for_each(baseTiles.begin(), baseTiles.end(), addIntersecting);
+
+  std::vector<int64_t> outputTiles;
+
+  while (!stack.empty()) {
+    TilingEntry entry = std::move(stack.top());
+    stack.pop();
+    if (BingTileType::bingTileZoom(entry.tile) == maxZoom ||
+        preparedGeometry->contains(entry.geometry.get())) {
+      outputTiles.push_back(entry.tile);
+    } else {
+      auto children = BingTileType::bingTileChildren(
+          entry.tile, BingTileType::bingTileZoom(entry.tile) + 1, 1);
+      if (FOLLY_UNLIKELY(children.hasError())) {
+        VELOX_FAIL(children.error());
+      }
+      std::for_each(
+          children.value().begin(), children.value().end(), addIntersecting);
+      VELOX_CHECK(
+          outputTiles.size() + stack.size() <= kMaxCoveringCount,
+          "The zoom level is too high or the geometry is too large to compute a set of covering Bing tiles. Please use a lower zoom level, or tile only a section of the geometry.");
+    }
+  }
+  return outputTiles;
+}
+} // namespace
+
+std::vector<int64_t> getMinimalTilesCoveringGeometry(
+    const geos::geom::Geometry& geometry,
+    int32_t zoom,
+    uint8_t maxZoomShift) {
+  std::vector<int64_t> outputTiles;
+
+  std::stack<int64_t, std::vector<int64_t>> stack(
+      getRawTilesCoveringGeometry(geometry, zoom));
+
+  while (!stack.empty()) {
+    int64_t thisTile = stack.top();
+    stack.pop();
+    auto expectedChildren =
+        BingTileType::bingTileChildren(thisTile, zoom, maxZoomShift);
+    if (FOLLY_UNLIKELY(expectedChildren.hasError())) {
+      VELOX_FAIL(expectedChildren.error());
+    }
+    outputTiles.insert(
+        outputTiles.end(),
+        expectedChildren.value().begin(),
+        expectedChildren.value().end());
+    if (FOLLY_UNLIKELY(outputTiles.size() + stack.size() > kMaxCoveringCount)) {
+      VELOX_USER_FAIL(
+          "The zoom level is too high or the geometry is too large to compute a set of covering Bing tiles. Please use a lower zoom level, or tile only a section of the geometry.");
+    }
+  }
+
+  return outputTiles;
+}
+
+std::vector<int64_t> getMinimalTilesCoveringGeometry(
+    const geos::geom::Envelope& envelope,
+    int32_t zoom) {
+  auto trivialCases = handleTrivialMinimalTileCoveringCases(envelope, zoom);
+  if (trivialCases.has_value()) {
+    return trivialCases.value();
+  }
+
+  // envelope x,y (longitude,latitude) goes NE as they increase.
+  // tile x,y goes SE as they increase
+  auto seRes = BingTileType::latitudeLongitudeToTile(
+      envelope.getMinY(), envelope.getMaxX(), zoom);
+  if (FOLLY_UNLIKELY(seRes.hasError())) {
+    VELOX_FAIL(seRes.error());
+  }
+
+  auto nwRes = BingTileType::latitudeLongitudeToTile(
+      envelope.getMaxY(), envelope.getMinX(), zoom);
+  if (FOLLY_UNLIKELY(nwRes.hasError())) {
+    VELOX_FAIL(nwRes.error());
+  }
+
+  uint64_t seTile = seRes.value();
+  uint64_t nwTile = nwRes.value();
+
+  uint32_t minY = BingTileType::bingTileY(nwTile);
+  uint32_t minX = BingTileType::bingTileX(nwTile);
+  uint32_t maxY = BingTileType::bingTileY(seTile);
+  uint32_t maxX = BingTileType::bingTileX(seTile);
+
+  uint32_t numTiles = (maxX - minX + 1) * (maxY - minY + 1);
+  if (numTiles > kMaxCoveringCount) {
+    VELOX_USER_FAIL(
+        "The zoom level is too high or the geometry is too large to compute a set of covering Bing tiles. Please use a lower zoom level, or tile only a section of the geometry.");
+  }
+
+  std::vector<int64_t> results;
+  results.reserve((maxX - minX + 1) * (maxY - minY + 1));
+
+  for (uint32_t y = minY; y <= maxY; ++y) {
+    for (uint32_t x = minX; x <= maxX; ++x) {
+      results.push_back(
+          static_cast<int64_t>(BingTileType::bingTileCoordsToInt(x, y, zoom)));
+    }
+  }
+  return results;
+}
+std::vector<int64_t> getDissolvedTilesCoveringGeometry(
+    const geos::geom::Geometry& geometry,
+    int32_t zoom) {
+  std::vector<int64_t> rawTiles = getRawTilesCoveringGeometry(geometry, zoom);
+
+  const geos::geom::Envelope* envelope = geometry.getEnvelopeInternal();
+  checkLatitudeLongitudeBounds(envelope->getMinY(), envelope->getMinX());
+  checkLatitudeLongitudeBounds(envelope->getMaxY(), envelope->getMaxX());
+
+  std::vector<int64_t> results;
+  if (rawTiles.empty()) {
+    return results;
+  }
+
+  results.reserve(rawTiles.size());
+  std::set<int64_t> candidates;
+
+  auto tileComparator = [](int64_t a, int64_t b) {
+    uint8_t za = BingTileType::bingTileZoom(a),
+            zb = BingTileType::bingTileZoom(b);
+    if (za != zb) {
+      return za < zb;
+    }
+    return BingTileType::bingTileToQuadKey(a) <
+        BingTileType::bingTileToQuadKey(b);
+  };
+
+  std::priority_queue<int64_t, std::vector<int64_t>, decltype(tileComparator)>
+      queue(tileComparator);
+
+  for (auto t : rawTiles) {
+    queue.push(t);
+  }
+
+  while (!queue.empty()) {
+    int64_t candidate = queue.top();
+    queue.pop();
+
+    if (BingTileType::bingTileZoom(candidate) == 0) {
+      results.push_back(candidate);
+      continue;
+    }
+
+    auto parentZoom = BingTileType::bingTileZoom(candidate) - 1;
+    auto parentResult = BingTileType::bingTileParent(candidate, parentZoom);
+    VELOX_CHECK(parentResult.hasValue(), parentResult.error());
+    uint64_t parent = parentResult.value();
+    candidates.insert(candidate);
+
+    while (!queue.empty() &&
+           (BingTileType::bingTileParent(queue.top(), parentZoom).value() ==
+            parent)) {
+      candidates.insert(queue.top());
+      queue.pop();
+    }
+
+    if (candidates.size() == 4) {
+      // All siblings present, coalesce to parent
+      queue.push(static_cast<int64_t>(parent));
+    } else {
+      results.insert(results.end(), candidates.begin(), candidates.end());
+    }
+    candidates.clear();
+  }
+
+  return results;
+}
+
+bool isPointOrRectangle(const geos::geom::Geometry& geometry) {
+  if (geometry.getGeometryTypeId() == geos::geom::GeometryTypeId::GEOS_POINT) {
+    return true;
+  }
+  if (geometry.getGeometryTypeId() !=
+      geos::geom::GeometryTypeId::GEOS_POLYGON) {
+    return false;
+  }
+  const geos::geom::Polygon& polygon =
+      static_cast<const geos::geom::Polygon&>(geometry);
+
+  if (polygon.getNumPoints() != 5) {
+    return false;
+  }
+
+  auto envelope = geometry.getEnvelopeInternal();
+
+  std::vector<std::tuple<int32_t, int32_t>> coords;
+  coords.emplace_back(envelope->getMinX(), envelope->getMinY());
+  coords.emplace_back(envelope->getMinX(), envelope->getMaxY());
+  coords.emplace_back(envelope->getMaxX(), envelope->getMinY());
+  coords.emplace_back(envelope->getMaxX(), envelope->getMaxY());
+
+  for (int i = 0; i < 4; i++) {
+    const geos::geom::Point* point =
+        static_cast<const geos::geom::Point*>(polygon.getGeometryN(i));
+    auto query = std::tuple<int32_t, int32_t>(point->getX(), point->getY());
+    if (std::find(coords.begin(), coords.end(), query) == coords.end()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::pair<double, double> computeSphericalCentroid(
+    const geos::geom::MultiPoint& multiPoint) {
+  VELOX_CHECK(
+      !multiPoint.isEmpty(),
+      "computeSphericalCentroid does not handle empty geometries");
+  auto numPoints = multiPoint.getNumGeometries();
+
+  // If only one point in the multipoint, return it
+  if (numPoints == 1) {
+    const geos::geom::Point* point =
+        static_cast<const geos::geom::Point*>(multiPoint.getGeometryN(0));
+    double longitude = point->getX();
+    double latitude = point->getY();
+
+    return {longitude, latitude};
+  }
+
+  // Convert all points to Cartesian coordinates and sum
+  double x3DTotal = 0.0;
+  double y3DTotal = 0.0;
+  double z3DTotal = 0.0;
+
+  for (int i = 0; i < numPoints; i++) {
+    const geos::geom::Point* point = multiPoint.getGeometryN(i);
+    double longitude = point->getX();
+    double latitude = point->getY();
+
+    // Convert to Cartesian coordinates
+    CartesianPoint cp(longitude, latitude);
+    x3DTotal += cp.getX();
+    y3DTotal += cp.getY();
+    z3DTotal += cp.getZ();
+  }
+
+  // Calculate the length of the centroid vector
+  double centroidVectorLength = std::sqrt(
+      x3DTotal * x3DTotal + y3DTotal * y3DTotal + z3DTotal * z3DTotal);
+
+  VELOX_CHECK(
+      centroidVectorLength != 0.0,
+      fmt::format(
+          "Unexpected error. Average vector length adds to zero ({}, {}, {})",
+          x3DTotal,
+          y3DTotal,
+          z3DTotal));
+
+  // Normalize and convert back to spherical coordinates
+  CartesianPoint centroid(
+      x3DTotal / centroidVectorLength,
+      y3DTotal / centroidVectorLength,
+      z3DTotal / centroidVectorLength);
+
+  return centroid.toSphericalPoint();
+}
+
+CartesianPoint::CartesianPoint(double longitude, double latitude) {
+  // Angle from North Pole down to Latitude, in Radians
+  double phi = (90.0 - latitude) * M_PI / 180.0;
+  double sinPhi = std::sin(phi);
+  // Angle from Greenwich to Longitude, in Radians
+  double theta = longitude * M_PI / 180.0;
+
+  x_ = BingTileType::kEarthRadiusKm * sinPhi * std::cos(theta);
+  y_ = BingTileType::kEarthRadiusKm * sinPhi * std::sin(theta);
+  z_ = BingTileType::kEarthRadiusKm * std::cos(phi);
+}
+
+CartesianPoint::CartesianPoint(double x, double y, double z)
+    : x_(x), y_(y), z_(z) {}
+
+std::pair<double, double> CartesianPoint::toSphericalPoint() const {
+  // Angle from North Pole down to Latitude, in Radians
+  double phi = std::atan2(std::sqrt(x_ * x_ + y_ * y_), z_);
+  // Angle from Greenwich to Longitude, in Radians
+  double theta = std::atan2(y_, x_);
+  double latitude = 90.0 - phi * 180.0 / M_PI;
+  double longitude = theta * 180.0 / M_PI;
+  return {longitude, latitude};
+}
+
+double getSphericalLength(const geos::geom::LineString& lineString) {
+  double sum = 0.0;
+  auto numPoints = lineString.getNumPoints();
+  auto lastPoint = lineString.getCoordinateN(0);
+
+  for (int i = 1; i < numPoints; i++) {
+    auto thisPoint = lineString.getCoordinateN(i);
+    sum += BingTileType::greatCircleDistance(
+        lastPoint.y, lastPoint.x, thisPoint.y, thisPoint.x);
+    lastPoint = thisPoint;
+  }
+
+  return sum;
+}
+
+double computeSphericalExcess(const geos::geom::Polygon& polygon) {
+  double sphericalExcess = std::abs(
+      SphericalExcessCalculator::excessFromCoordinates(
+          *polygon.getExteriorRing()->getCoordinates()));
+  auto interiorRingCount = polygon.getNumInteriorRing();
+  for (int i = 0; i < interiorRingCount; i++) {
+    sphericalExcess -= std::abs(
+        SphericalExcessCalculator::excessFromCoordinates(
+            *polygon.getInteriorRingN(i)->getCoordinates()));
+  }
+  return sphericalExcess;
+}
+
+} // namespace facebook::velox::functions::geospatial
diff --git a/velox/functions/prestosql/geospatial/GeometryUtils.h b/velox/functions/prestosql/geospatial/GeometryUtils.h
index b65d044fe296..5025c13709c4 100644
--- a/velox/functions/prestosql/geospatial/GeometryUtils.h
+++ b/velox/functions/prestosql/geospatial/GeometryUtils.h
@@ -16,8 +16,13 @@
 
 #pragma once
 
+#include <fmt/ranges.h>
+#include <geos/geom/Geometry.h>
+#include <geos/io/WKTReader.h>
+
 #include <geos/util/AssertionFailedException.h>
 #include <geos/util/UnsupportedOperationException.h>
+#include <optional>
 
 #include "velox/common/base/Status.h"
 
@@ -39,4 +44,176 @@ namespace facebook::velox::functions::geospatial {
         fmt::format("{}: {}", user_error_message, e.what()));    \
   }
 
+/// Utility macro used to wrap GEOS library calls in a try-catch block,
+/// throwing a velox::Status with error message if an exception is caught.
+#define GEOS_RETHROW(func, user_error_message)                             \
+  try {                                                                    \
+    func                                                                   \
+  } catch (const geos::util::UnsupportedOperationException& e) {           \
+    VELOX_USER_FAIL(fmt::format("Internal geometry error: {}", e.what())); \
+  } catch (const geos::util::AssertionFailedException& e) {                \
+    VELOX_FAIL(fmt::format("Internal geometry error: {}", e.what()));      \
+  } catch (const geos::util::GEOSException& e) {                           \
+    VELOX_FAIL(fmt::format("{}: {}", user_error_message, e.what()));       \
+  }
+
+class GeometryCollectionIterator {
+ public:
+  explicit GeometryCollectionIterator(const geos::geom::Geometry* geometry);
+  bool hasNext();
+  const geos::geom::Geometry* next();
+
+ private:
+  std::deque<const geos::geom::Geometry*> geometriesDeque;
+};
+
+FOLLY_ALWAYS_INLINE const
+    std::unordered_map<geos::geom::GeometryTypeId, std::string>&
+    getGeosTypeToStringIdentifier() {
+  static const geos::geom::GeometryFactory::Ptr factory =
+      geos::geom::GeometryFactory::create();
+
+  static const std::unordered_map<geos::geom::GeometryTypeId, std::string>
+      geosTypeToStringIdentifier{
+          {geos::geom::GeometryTypeId::GEOS_POINT,
+           factory->createPoint()->getGeometryType()},
+          {geos::geom::GeometryTypeId::GEOS_LINESTRING,
+           factory->createLineString()->getGeometryType()},
+          {geos::geom::GeometryTypeId::GEOS_LINEARRING,
+           factory->createLinearRing()->getGeometryType()},
+          {geos::geom::GeometryTypeId::GEOS_POLYGON,
+           factory->createPolygon()->getGeometryType()},
+          {geos::geom::GeometryTypeId::GEOS_MULTIPOINT,
+           factory->createMultiPoint()->getGeometryType()},
+          {geos::geom::GeometryTypeId::GEOS_MULTILINESTRING,
+           factory->createMultiLineString()->getGeometryType()},
+          {geos::geom::GeometryTypeId::GEOS_MULTIPOLYGON,
+           factory->createMultiPolygon()->getGeometryType()},
+          {geos::geom::GeometryTypeId::GEOS_GEOMETRYCOLLECTION,
+           factory->createGeometryCollection()->getGeometryType()}};
+  return geosTypeToStringIdentifier;
+};
+
+FOLLY_ALWAYS_INLINE std::vector<std::string> getGeosTypeNames(
+    const std::vector<geos::geom::GeometryTypeId>& geometryTypeIds) {
+  std::vector<std::string> geometryTypeNames;
+  geometryTypeNames.reserve(geometryTypeIds.size());
+  for (auto geometryTypeId : geometryTypeIds) {
+    geometryTypeNames.push_back(
+        getGeosTypeToStringIdentifier().at(geometryTypeId));
+  }
+  return geometryTypeNames;
+}
+
+FOLLY_ALWAYS_INLINE Status validateType(
+    const geos::geom::Geometry& geometry,
+    const std::vector<geos::geom::GeometryTypeId>& validTypes,
+    std::string callerFunctionName) {
+  geos::geom::GeometryTypeId type = geometry.getGeometryTypeId();
+  if (!std::count(validTypes.begin(), validTypes.end(), type)) {
+    return Status::UserError(
+        fmt::format(
+            "{} only applies to {}. Input type is: {}",
+            callerFunctionName,
+            fmt::join(getGeosTypeNames(validTypes), " or "),
+            getGeosTypeToStringIdentifier().at(type)));
+  }
+  return Status::OK();
+}
+
+FOLLY_ALWAYS_INLINE bool isMultiType(const geos::geom::Geometry& geometry) {
+  geos::geom::GeometryTypeId type = geometry.getGeometryTypeId();
+
+  static const std::vector<geos::geom::GeometryTypeId> multiTypes{
+      geos::geom::GeometryTypeId::GEOS_MULTILINESTRING,
+      geos::geom::GeometryTypeId::GEOS_MULTIPOINT,
+      geos::geom::GeometryTypeId::GEOS_MULTIPOLYGON,
+      geos::geom::GeometryTypeId::GEOS_GEOMETRYCOLLECTION};
+
+  return std::count(multiTypes.begin(), multiTypes.end(), type);
+}
+
+FOLLY_ALWAYS_INLINE bool isAtomicType(const geos::geom::Geometry& geometry) {
+  geos::geom::GeometryTypeId type = geometry.getGeometryTypeId();
+
+  static const std::vector<geos::geom::GeometryTypeId> atomicTypes{
+      geos::geom::GeometryTypeId::GEOS_LINESTRING,
+      geos::geom::GeometryTypeId::GEOS_POLYGON,
+      geos::geom::GeometryTypeId::GEOS_POINT};
+
+  return std::count(atomicTypes.begin(), atomicTypes.end(), type);
+}
+
+std::optional<std::string> geometryInvalidReason(
+    const geos::geom::Geometry* geometry);
+
+Status validateLatitudeLongitude(double latitude, double longitude);
+
+std::vector<const geos::geom::Geometry*> flattenCollection(
+    const geos::geom::Geometry* geometry);
+
+std::vector<int64_t> getMinimalTilesCoveringGeometry(
+    const geos::geom::Envelope& envelope,
+    int32_t zoom);
+
+std::vector<int64_t> getMinimalTilesCoveringGeometry(
+    const geos::geom::Geometry& geometry,
+    int32_t zoom,
+    uint8_t maxZoomShift);
+
+std::vector<int64_t> getDissolvedTilesCoveringGeometry(
+    const geos::geom::Geometry& geometry,
+    int32_t zoom);
+
+bool isPointOrRectangle(const geos::geom::Geometry& geometry);
+
+/// Computes the centroid of a non-empty MultiPoint geometry on a sphere.
+/// Uses 3D Cartesian coordinates to properly average points on a spherical
+/// surface.
+/// @param geometry A MultiPoint geometry (must not be empty)
+/// @return A pair of (longitude, latitude) in degrees representing the centroid
+std::pair<double, double> computeSphericalCentroid(
+    const geos::geom::MultiPoint& multiPoint);
+
+/// Represents a point in 3D Cartesian coordinates, useful for spherical
+/// geometry calculations. Provides conversions to/from spherical coordinates
+/// (longitude, latitude).
+class CartesianPoint {
+ public:
+  /// Constructs a CartesianPoint from a spherical point (longitude, latitude)
+  /// in degrees. Assumes the point is on Earth's surface.
+  /// @param longitude Longitude in degrees (x-coordinate in spherical system)
+  /// @param latitude Latitude in degrees (y-coordinate in spherical system)
+  CartesianPoint(double longitude, double latitude);
+
+  /// Constructs a CartesianPoint from Cartesian coordinates.
+  /// @param x X-coordinate in Cartesian system
+  /// @param y Y-coordinate in Cartesian system
+  /// @param z Z-coordinate in Cartesian system
+  CartesianPoint(double x, double y, double z);
+
+  double getX() const {
+    return x_;
+  }
+  double getY() const {
+    return y_;
+  }
+  double getZ() const {
+    return z_;
+  }
+
+  /// Converts this Cartesian point back to spherical coordinates.
+  /// @return A pair of (longitude, latitude) in degrees
+  std::pair<double, double> toSphericalPoint() const;
+
+ private:
+  double x_;
+  double y_;
+  double z_;
+};
+
+double getSphericalLength(const geos::geom::LineString& lineString);
+
+double computeSphericalExcess(const geos::geom::Polygon& polygon);
+
 } // namespace facebook::velox::functions::geospatial
diff --git a/velox/functions/prestosql/json/CMakeLists.txt b/velox/functions/prestosql/json/CMakeLists.txt
index a08269db54ec..ad048feb1d9e 100644
--- a/velox/functions/prestosql/json/CMakeLists.txt
+++ b/velox/functions/prestosql/json/CMakeLists.txt
@@ -17,13 +17,12 @@ velox_add_library(
   JsonPathTokenizer.cpp
   JsonStringUtil.cpp
   SIMDJsonExtractor.cpp
-  SIMDJsonUtil.cpp)
+  SIMDJsonUtil.cpp
+)
 
-velox_link_libraries(velox_functions_json velox_functions_lib
-                     simdjson::simdjson)
+velox_link_libraries(velox_functions_json velox_functions_lib simdjson::simdjson)
 
-velox_compile_definitions(velox_functions_json
-                          PRIVATE SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON)
+velox_compile_definitions(velox_functions_json PRIVATE SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/prestosql/json/JsonExtractor.cpp b/velox/functions/prestosql/json/JsonExtractor.cpp
index b8fc2b9d1dbd..d77dec70116b 100644
--- a/velox/functions/prestosql/json/JsonExtractor.cpp
+++ b/velox/functions/prestosql/json/JsonExtractor.cpp
@@ -27,7 +27,6 @@
 #include "velox/functions/prestosql/json/JsonPathTokenizer.h"
 
 namespace facebook::velox::functions {
-
 namespace {
 
 using JsonVector = std::vector<const folly::dynamic*>;
@@ -35,9 +34,9 @@ using JsonVector = std::vector<const folly::dynamic*>;
 class JsonExtractor {
  public:
   // Use this method to get an instance of JsonExtractor given a json path.
-  static JsonExtractor& getInstance(folly::StringPiece path) {
+  static JsonExtractor& getInstance(std::string_view path) {
     // Pre-process
-    auto trimedPath = folly::trimWhitespace(path).str();
+    std::string trimedPath = folly::trimWhitespace(path).str();
 
     std::shared_ptr<JsonExtractor> op;
     if (kExtractorCache.count(trimedPath)) {
@@ -53,7 +52,7 @@ class JsonExtractor {
     return *op;
   }
 
-  folly::Optional<folly::dynamic> extract(const folly::dynamic& json);
+  std::optional<folly::dynamic> extract(const folly::dynamic& json);
 
   // Shouldn't instantiate directly - use getInstance().
   explicit JsonExtractor(const std::string& path) {
@@ -139,7 +138,7 @@ void extractArray(
   }
 }
 
-folly::Optional<folly::dynamic> JsonExtractor::extract(
+std::optional<folly::dynamic> JsonExtractor::extract(
     const folly::dynamic& json) {
   JsonVector input;
   // Temporary extraction result holder, swap with input after
@@ -156,7 +155,7 @@ folly::Optional<folly::dynamic> JsonExtractor::extract(
       }
     }
     if (result.empty()) {
-      return folly::none;
+      return std::nullopt;
     }
     input.clear();
     result.swap(input);
@@ -164,7 +163,7 @@ folly::Optional<folly::dynamic> JsonExtractor::extract(
 
   auto len = input.size();
   if (0 == len) {
-    return folly::none;
+    return std::nullopt;
   } else if (1 == len) {
     return *input.front();
   } else {
@@ -176,20 +175,20 @@ folly::Optional<folly::dynamic> JsonExtractor::extract(
   }
 }
 
-bool isScalarType(const folly::Optional<folly::dynamic>& json) {
+bool isScalarType(const std::optional<folly::dynamic>& json) {
   return json.has_value() && !json->isObject() && !json->isArray() &&
       !json->isNull();
 }
 
 } // namespace
 
-folly::Optional<folly::dynamic> jsonExtract(
-    folly::StringPiece json,
-    folly::StringPiece path) {
+std::optional<folly::dynamic> jsonExtract(
+    std::string_view json,
+    std::string_view path) {
   try {
     // If extractor fails to parse the path, this will throw a VeloxUserError,
     // and we want to let this exception bubble up to the client. We only catch
-    // json parsing failures (in which cases we return folly::none instead of
+    // json parsing failures (in which cases we return std::nullopt instead of
     // throw).
     auto& extractor = JsonExtractor::getInstance(path);
     return extractor.extract(folly::parseJson(json));
@@ -198,28 +197,22 @@ folly::Optional<folly::dynamic> jsonExtract(
     // Folly might throw a conversion error while parsing the input json. In
     // this case, let it return null.
   }
-  return folly::none;
-}
-
-folly::Optional<folly::dynamic> jsonExtract(
-    const std::string& json,
-    const std::string& path) {
-  return jsonExtract(folly::StringPiece(json), folly::StringPiece(path));
+  return std::nullopt;
 }
 
-folly::Optional<folly::dynamic> jsonExtract(
+std::optional<folly::dynamic> jsonExtractFromDynamic(
     const folly::dynamic& json,
-    folly::StringPiece path) {
+    std::string_view path) {
   try {
     return JsonExtractor::getInstance(path).extract(json);
   } catch (const folly::json::parse_error&) {
   }
-  return folly::none;
+  return std::nullopt;
 }
 
-folly::Optional<std::string> jsonExtractScalar(
-    folly::StringPiece json,
-    folly::StringPiece path) {
+std::optional<std::string> jsonExtractScalar(
+    std::string_view json,
+    std::string_view path) {
   auto res = jsonExtract(json, path);
   // Not a scalar value
   if (isScalarType(res)) {
@@ -229,16 +222,7 @@ folly::Optional<std::string> jsonExtractScalar(
       return res->asString();
     }
   }
-  return folly::none;
-}
-
-folly::Optional<std::string> jsonExtractScalar(
-    const std::string& json,
-    const std::string& path) {
-  folly::StringPiece jsonPiece{json};
-  folly::StringPiece pathPiece{path};
-
-  return jsonExtractScalar(jsonPiece, pathPiece);
+  return std::nullopt;
 }
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/JsonExtractor.h b/velox/functions/prestosql/json/JsonExtractor.h
index d96c42d15f4a..5aad82c7fe42 100644
--- a/velox/functions/prestosql/json/JsonExtractor.h
+++ b/velox/functions/prestosql/json/JsonExtractor.h
@@ -18,57 +18,46 @@
 
 #include <string>
 
-#include "folly/Range.h"
 #include "folly/dynamic.h"
 
 namespace facebook::velox::functions {
 
-/**
- * Extract a json object from path
- * @param json: A json object
- * @param path: Path to locate a json object. Following operators are supported
- *              "$"      Root member of a json structure no matter it's an
- *                       object or an array
- *              "./[]"   Child operator to get a children object
- *              "[]"     Subscript operator for array and map
- *              "*"      Wildcard for [], get all the elements of an array
- * @return Return json string object on success.
- *         On invalid json path, returns folly::none (not json null) value
- *         On non-json value, returns the original value.
- * Example:
- * For the following example: ,
- * "{\"store\":,
- *   {\"fruit\":\\[{\"weight\":8,\"type\":\"apple\"},
- *                 {\"weight\":9,\"type\":\"pear\"}],
- *    \"bicycle\":{\"price\":19.95,\"color\":\"red\"}
- *   },
- *  \"email\":\"amy@only_for_json_udf_test.net\",
- *  \"owner\":\"amy\",
- * }",
- * jsonExtract(json, "$.owner") = "amy",
- * jsonExtract(json, "$.store.fruit[0]") =
- *    "{\"weight\":8,\"type\":\"apple\"}",
- * jsonExtract(json, "$.non_exist_key") = NULL
- * jsonExtract(json, "$.store.fruit[*].type") = "[\"apple\", \"pear\"]"
- */
-folly::Optional<folly::dynamic> jsonExtract(
-    folly::StringPiece json,
-    folly::StringPiece path);
-
-folly::Optional<folly::dynamic> jsonExtract(
+/// Extract a json object from path
+/// @param json: A json object
+/// @param path: Path to locate a json object. Following operators are supported
+///              "$"      Root member of a json structure no matter it's an
+///                       object or an array
+///              "./[]"   Child operator to get a children object
+///              "[]"     Subscript operator for array and map
+///              "*"      Wildcard for [], get all the elements of an array
+/// @return Return json string object on success.
+///         On invalid json path, returns std::nullopt (not json null) value
+///         On non-json value, returns the original value.
+/// Example:
+/// For the following example: ,
+/// "{\"store\":,
+///   {\"fruit\":\\[{\"weight\":8,\"type\":\"apple\"},
+///                 {\"weight\":9,\"type\":\"pear\"}],
+///    \"bicycle\":{\"price\":19.95,\"color\":\"red\"}
+///   },
+///  \"email\":\"amy@only_for_json_udf_test.net\",
+///  \"owner\":\"amy\",
+/// }",
+/// jsonExtract(json, "$.owner") = "amy",
+/// jsonExtract(json, "$.store.fruit[0]") =
+///    "{\"weight\":8,\"type\":\"apple\"}",
+/// jsonExtract(json, "$.non_exist_key") = NULL
+/// jsonExtract(json, "$.store.fruit[*].type") = "[\"apple\", \"pear\"]"
+std::optional<folly::dynamic> jsonExtract(
+    std::string_view json,
+    std::string_view path);
+
+std::optional<folly::dynamic> jsonExtractFromDynamic(
     const folly::dynamic& json,
-    folly::StringPiece path);
-
-folly::Optional<std::string> jsonExtractScalar(
-    folly::StringPiece json,
-    folly::StringPiece path);
-
-folly::Optional<folly::dynamic> jsonExtract(
-    const std::string& json,
-    const std::string& path);
+    std::string_view path);
 
-folly::Optional<std::string> jsonExtractScalar(
-    const std::string& json,
-    const std::string& path);
+std::optional<std::string> jsonExtractScalar(
+    std::string_view json,
+    std::string_view path);
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/json/JsonStringUtil.cpp b/velox/functions/prestosql/json/JsonStringUtil.cpp
index fea9cef2b51a..c830c1b7d089 100644
--- a/velox/functions/prestosql/json/JsonStringUtil.cpp
+++ b/velox/functions/prestosql/json/JsonStringUtil.cpp
@@ -163,6 +163,7 @@ void normalizeForJsonCast(const char* input, size_t length, char* output) {
       }
     }
   }
+  VELOX_DCHECK_EQ(pos - output, normalizedSizeForJsonCast(input, length));
 }
 
 size_t normalizedSizeForJsonCast(const char* input, size_t length) {
@@ -178,19 +179,22 @@ size_t normalizedSizeForJsonCast(const char* input, size_t length) {
     switch (count) {
       case 1:
         outSize += encodedAsciiSizes[int8_t(*start)];
+        ++start;
         break;
       case 2:
       case 3:
         outSize += count;
+        start += count;
         break;
-      case 4:
-        outSize += kEncodedHexSize * 2;
+      case 4: {
+        auto codePoint = folly::utf8ToCodePoint(start, end, true);
+        outSize += codePoint < 0x10000u ? kEncodedHexSize : 2 * kEncodedHexSize;
         break;
+      }
       default:
         outSize += kEncodedHexSize;
-        count = 1;
+        ++start;
     }
-    start += count;
   }
 
   return outSize;
@@ -424,6 +428,7 @@ size_t normalizeForJsonParse(const char* input, size_t length, char* output) {
       }
     }
   }
+  VELOX_DCHECK_EQ(pos - output, normalizedSizeForJsonParse(input, length));
   return pos - output;
 }
 
diff --git a/velox/functions/prestosql/json/SIMDJsonExtractor.cpp b/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
index 0766b1dd0f2a..da5272d01803 100644
--- a/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
+++ b/velox/functions/prestosql/json/SIMDJsonExtractor.cpp
@@ -17,12 +17,9 @@
 #include "velox/functions/prestosql/json/SIMDJsonExtractor.h"
 
 namespace facebook::velox::functions {
-namespace {
-using JsonVector = std::vector<simdjson::ondemand::value>;
-}
 
 /* static */ SIMDJsonExtractor& SIMDJsonExtractor::getInstance(
-    folly::StringPiece path) {
+    std::string_view path) {
   // Cache tokenize operations in JsonExtractor across invocations in the same
   // thread for the same JsonPath.
   thread_local static std::
@@ -77,7 +74,8 @@ simdjson::error_code extractObject(
   for (auto field : jsonObj) {
     SIMDJSON_ASSIGN_OR_RAISE(auto currentKey, field.unescaped_key());
     if (currentKey == key) {
-      ret.emplace(field.value());
+      SIMDJSON_ASSIGN_OR_RAISE(auto value, field.value());
+      ret.emplace(value);
       return simdjson::SUCCESS;
     }
   }
@@ -103,7 +101,7 @@ simdjson::error_code extractArray(
     }
     auto val = jsonArray.at(i);
     if (!val.error()) {
-      ret.emplace(std::move(val));
+      ret.emplace(std::move(val.value()));
     }
   }
   return simdjson::SUCCESS;
diff --git a/velox/functions/prestosql/json/SIMDJsonExtractor.h b/velox/functions/prestosql/json/SIMDJsonExtractor.h
index 42a667ad15fe..59885c6799a7 100644
--- a/velox/functions/prestosql/json/SIMDJsonExtractor.h
+++ b/velox/functions/prestosql/json/SIMDJsonExtractor.h
@@ -68,6 +68,12 @@ class SIMDJsonExtractor {
       TConsumer& consumer,
       bool& isDefinitePath);
 
+  template <typename TConsumer>
+  simdjson::error_code extract(
+      simdjson::ondemand::document& jsonDoc,
+      TConsumer& consumer,
+      bool& isDefinitePath);
+
   /// Returns true if this extractor was initialized with the trivial path "$".
   bool isRootOnlyPath() {
     return tokens_.empty();
@@ -76,7 +82,7 @@ class SIMDJsonExtractor {
   /// Use this method to get an instance of SIMDJsonExtractor given a JSON path.
   /// Uses a thread local cache, therefore the caller must ensure the returned
   /// instance is not passed between threads.
-  static SIMDJsonExtractor& getInstance(folly::StringPiece path);
+  static SIMDJsonExtractor& getInstance(std::string_view path);
 
  private:
   // Shouldn't instantiate directly - use getInstance().
@@ -127,6 +133,14 @@ simdjson::error_code SIMDJsonExtractor::extract(
     TConsumer& consumer,
     bool& isDefinitePath) {
   SIMDJSON_ASSIGN_OR_RAISE(auto jsonDoc, simdjsonParse(paddedJson));
+  return extract(jsonDoc, consumer, isDefinitePath);
+}
+
+template <typename TConsumer>
+simdjson::error_code SIMDJsonExtractor::extract(
+    simdjson::ondemand::document& jsonDoc,
+    TConsumer& consumer,
+    bool& isDefinitePath) {
   SIMDJSON_ASSIGN_OR_RAISE(auto isScalar, jsonDoc.is_scalar());
   if (isScalar) {
     // Note, we cannot convert this to a value as this is not supported if the
@@ -167,7 +181,7 @@ simdjson::error_code SIMDJsonExtractor::extractInternal(
       if (selector == JsonPathTokenizer::Selector::WILDCARD) {
         SIMDJSON_ASSIGN_OR_RAISE(auto jsonObj, input.get_object());
         for (auto field : jsonObj) {
-          simdjson::ondemand::value val = field.value();
+          SIMDJSON_ASSIGN_OR_RAISE(auto val, field.value());
           if (tokenIndex == tokens_.size() - 1) {
             // Consume each element in the object.
             SIMDJSON_TRY(consumer(val));
@@ -189,7 +203,11 @@ simdjson::error_code SIMDJsonExtractor::extractInternal(
       }
     } else if (input.type() == simdjson::ondemand::json_type::array) {
       if (selector == JsonPathTokenizer::Selector::WILDCARD) {
-        for (auto child : input.get_array()) {
+        SIMDJSON_ASSIGN_OR_RAISE(auto array, input.get_array());
+        for (auto child : array) {
+          if (child.error()) {
+            return child.error();
+          }
           if (tokenIndex == tokens_.size() - 1) {
             // Consume each element in the object.
             SIMDJSON_TRY(consumer(child.value()));
@@ -235,7 +253,7 @@ simdjson::error_code SIMDJsonExtractor::visitRecursive(
   simdjson::padded_string_view paddedJson = reusePaddedStringView(jsonString);
   simdjson::ondemand::parser localParser;
   SIMDJSON_ASSIGN_OR_RAISE(auto jsonDoc, localParser.iterate(paddedJson));
-  simdjson::ondemand::value jsonDocVal = jsonDoc.get_value();
+  SIMDJSON_ASSIGN_OR_RAISE(auto jsonDocVal, jsonDoc.get_value());
   // Visit the current node.
   SIMDJSON_TRY(
       extractInternal(jsonDocVal, consumer, isDefinitePath, startTokenIdx));
@@ -243,11 +261,11 @@ simdjson::error_code SIMDJsonExtractor::visitRecursive(
   // Reset the local parser for the next round of iteration where we visit the
   // children.
   SIMDJSON_ASSIGN_OR_RAISE(jsonDoc, localParser.iterate(paddedJson));
-  jsonDocVal = jsonDoc.get_value();
+  SIMDJSON_ASSIGN_OR_RAISE(jsonDocVal, jsonDoc.get_value());
   if (jsonDocVal.type() == simdjson::ondemand::json_type::object) {
     SIMDJSON_ASSIGN_OR_RAISE(auto jsonObj, jsonDocVal.get_object());
     for (auto field : jsonObj) {
-      simdjson::ondemand::value val = field.value();
+      SIMDJSON_ASSIGN_OR_RAISE(auto val, field.value());
       if (val.type() != simdjson::ondemand::json_type::object &&
           val.type() != simdjson::ondemand::json_type::array) {
         continue;
@@ -256,7 +274,11 @@ simdjson::error_code SIMDJsonExtractor::visitRecursive(
           visitRecursive(val, consumer, isDefinitePath, startTokenIdx));
     }
   } else if (jsonDocVal.type() == simdjson::ondemand::json_type::array) {
-    for (auto child : jsonDocVal.get_array()) {
+    SIMDJSON_ASSIGN_OR_RAISE(auto array, jsonDocVal.get_array());
+    for (auto child : array) {
+      if (child.error()) {
+        return child.error();
+      }
       simdjson::ondemand::value val = child.value();
       if (val.type() != simdjson::ondemand::json_type::object &&
           val.type() != simdjson::ondemand::json_type::array) {
diff --git a/velox/functions/prestosql/json/tests/CMakeLists.txt b/velox/functions/prestosql/json/tests/CMakeLists.txt
index 8126c5c1aa2c..c4fedc1e904e 100644
--- a/velox/functions/prestosql/json/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/json/tests/CMakeLists.txt
@@ -12,8 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 add_executable(
-  velox_functions_json_test JsonExtractorTest.cpp JsonPathTokenizerTest.cpp
-                            SIMDJsonExtractorTest.cpp)
+  velox_functions_json_test
+  JsonExtractorTest.cpp
+  JsonPathTokenizerTest.cpp
+  SIMDJsonExtractorTest.cpp
+)
 
 add_test(velox_functions_json_test velox_functions_json_test)
 
@@ -23,4 +26,5 @@ target_link_libraries(
   Folly::folly
   GTest::gtest
   GTest::gtest_main
-  glog::glog)
+  glog::glog
+)
diff --git a/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp b/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
index 8fc1c0d6238b..45aaaef8b0ed 100644
--- a/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
+++ b/velox/functions/prestosql/json/tests/JsonExtractorTest.cpp
@@ -20,43 +20,43 @@
 #include "gtest/gtest.h"
 #include "velox/common/base/VeloxException.h"
 
-using facebook::velox::VeloxUserError;
-using facebook::velox::functions::jsonExtract;
-using facebook::velox::functions::jsonExtractScalar;
 using folly::json::parse_error;
 using namespace std::string_literals;
 
 #define EXPECT_SCALAR_VALUE_EQ(json, path, ret) \
   {                                             \
     auto val = jsonExtractScalar(json, path);   \
-    EXPECT_TRUE(val.hasValue());                \
+    EXPECT_TRUE(val.has_value());               \
     EXPECT_EQ(val.value(), ret);                \
   }
 
 #define EXPECT_SCALAR_VALUE_NULL(json, path) \
-  EXPECT_FALSE(jsonExtractScalar(json, path).hasValue())
+  EXPECT_FALSE(jsonExtractScalar(json, path).has_value())
 
-#define EXPECT_JSON_VALUE_EQ(json, path, ret)        \
-  {                                                  \
-    auto val = json_format(jsonExtract(json, path)); \
-    EXPECT_TRUE(val.hasValue());                     \
-    EXPECT_EQ(val.value(), ret);                     \
+#define EXPECT_JSON_VALUE_EQ(json, path, ret)       \
+  {                                                 \
+    auto val = jsonFormat(jsonExtract(json, path)); \
+    EXPECT_TRUE(val.has_value());                   \
+    EXPECT_EQ(val.value(), ret);                    \
   }
 
 #define EXPECT_JSON_VALUE_NULL(json, path) \
-  EXPECT_FALSE(json_format(jsonExtract(json, path)).hasValue())
+  EXPECT_FALSE(jsonFormat(jsonExtract(json, path)).has_value())
 
 #define EXPECT_THROW_INVALID_ARGUMENT(json, path) \
   EXPECT_THROW(jsonExtract(json, path), VeloxUserError)
 
+namespace facebook::velox::functions::test {
 namespace {
-folly::Optional<std::string> json_format(
-    const folly::Optional<folly::dynamic>& json) {
+
+std::optional<std::string> jsonFormat(
+    const std::optional<folly::dynamic>& json) {
   if (json.has_value()) {
     return folly::toJson(json.value());
   }
-  return folly::none;
+  return std::nullopt;
 }
+
 } // namespace
 
 TEST(JsonExtractorTest, generalJsonTest) {
@@ -92,60 +92,60 @@ TEST(JsonExtractorTest, generalJsonTest) {
         "owner":"amy"})DELIM";
   // clang-format on
   std::replace(json.begin(), json.end(), '\'', '\"');
-  auto res = json_format(jsonExtract(json, "$.store.fruit[0].weight"s));
+  auto res = jsonFormat(jsonExtract(json, "$.store.fruit[0].weight"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("8", res.value());
-  res = json_format(jsonExtract(json, "$.store.fruit[1].weight"s));
+  res = jsonFormat(jsonExtract(json, "$.store.fruit[1].weight"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("9", res.value());
   EXPECT_FALSE(
-      json_format(jsonExtract(json, "$.store.fruit[2].weight"s)).has_value());
-  res = json_format(jsonExtract(json, "$.store.fruit[*].weight"s));
+      jsonFormat(jsonExtract(json, "$.store.fruit[2].weight"s)).has_value());
+  res = jsonFormat(jsonExtract(json, "$.store.fruit[*].weight"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[8,9]", res.value());
-  res = json_format(jsonExtract(json, "$.store.fruit[*].type"s));
+  res = jsonFormat(jsonExtract(json, "$.store.fruit[*].type"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[\"apple\",\"pear\"]", res.value());
-  res = json_format(jsonExtract(json, "$.store.book[0].price"s));
+  res = jsonFormat(jsonExtract(json, "$.store.book[0].price"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("8.95", res.value());
-  res = json_format(jsonExtract(json, "$.store.book[2].category"s));
+  res = jsonFormat(jsonExtract(json, "$.store.book[2].category"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("\"fiction\"", res.value());
-  res = json_format(jsonExtract(json, "$.store.basket[1]"s));
+  res = jsonFormat(jsonExtract(json, "$.store.basket[1]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[3,4]", res.value());
-  res = json_format(jsonExtract(json, "$.store.basket[0]"s));
+  res = jsonFormat(jsonExtract(json, "$.store.basket[0]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(
       folly::parseJson("[1,2,{\"a\":\"x\",\"b\":\"y\"}]"),
       folly::parseJson(res.value()));
   EXPECT_FALSE(
-      json_format(jsonExtract(json, "$.store.baskets[1]"s)).has_value());
-  res = json_format(jsonExtract(json, "$[\"e mail\"]"s));
+      jsonFormat(jsonExtract(json, "$.store.baskets[1]"s)).has_value());
+  res = jsonFormat(jsonExtract(json, "$[\"e mail\"]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("\"amy@only_for_json_udf_test.net\"", res.value());
-  res = json_format(jsonExtract(json, "$.owner"s));
+  res = jsonFormat(jsonExtract(json, "$.owner"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("\"amy\"", res.value());
-  res = json_format(
+  res = jsonFormat(
       jsonExtract("[[1.1,[2.1,2.2]],2,{\"a\":\"b\"}]"s, "$[0][1][1]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("2.2", res.value());
-  res = json_format(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[1]"s));
+  res = jsonFormat(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[1]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("2", res.value());
-  res = json_format(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[2]"s));
+  res = jsonFormat(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[2]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("{\"a\":\"b\"}", res.value());
   EXPECT_FALSE(
-      json_format(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[3]"s)).has_value());
-  res = json_format(jsonExtract("[{\"a\":\"b\"}]"s, "$[0]"s));
+      jsonFormat(jsonExtract("[1,2,{\"a\":\"b\"}]"s, "$[3]"s)).has_value());
+  res = jsonFormat(jsonExtract("[{\"a\":\"b\"}]"s, "$[0]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("{\"a\":\"b\"}", res.value());
   EXPECT_FALSE(
-      json_format(jsonExtract("[{\"a\":\"b\"}]"s, "$[2]"s)).has_value());
-  res = json_format(jsonExtract("{\"a\":\"b\"}"s, " $ "s));
+      jsonFormat(jsonExtract("[{\"a\":\"b\"}]"s, "$[2]"s)).has_value());
+  res = jsonFormat(jsonExtract("{\"a\":\"b\"}"s, " $ "s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("{\"a\":\"b\"}", res.value());
 
@@ -161,7 +161,7 @@ TEST(JsonExtractorTest, generalJsonTest) {
   expected.append("[{\"key\":3,\"value\":6},{\"key\":4,\"value\":8},")
       .append("{\"key\":5,\"value\":10}]]");
   auto expectedJson = folly::parseJson(expected);
-  res = json_format(jsonExtract(json2, "$[*]"s));
+  res = jsonFormat(jsonExtract(json2, "$[*]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(expectedJson, folly::parseJson(res.value()));
 
@@ -170,31 +170,31 @@ TEST(JsonExtractorTest, generalJsonTest) {
       .append("{\"key\":3,\"value\":6},")
       .append("{\"key\":4,\"value\":8},{\"value\":10,\"key\":5}]");
   expectedJson = folly::parseJson(expected);
-  res = json_format(jsonExtract(json2, "$[*][*]"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][*]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(expectedJson, folly::parseJson(res.value()));
 
-  res = json_format(jsonExtract(json2, "$[*][*].key"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][*].key"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[1,2,3,4,5]", res.value());
 
   expected = "[{\"key\":1,\"value\":2},{\"key\":3,\"value\":6}]";
   expectedJson = folly::parseJson(expected);
-  res = json_format(jsonExtract(json2, "$[*][0]"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][0]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(expectedJson, folly::parseJson(res.value()));
 
   expected = "{\"key\":5,\"value\":10}";
   expectedJson = folly::parseJson(expected);
-  res = json_format(jsonExtract(json2, "$[*][2]"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][2]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ(expectedJson, folly::parseJson(res.value()));
 
   // TEST WiteSpaces in Path and Json
-  res = json_format(jsonExtract(json2, "$[*][*].key"s));
+  res = jsonFormat(jsonExtract(json2, "$[*][*].key"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("[1,2,3,4,5]", res.value());
-  res = json_format(
+  res = jsonFormat(
       jsonExtract(" [ [1.1,[2.1,2.2]],2, {\"a\": \"b\"}]"s, " $[0][1][1]"s));
   EXPECT_TRUE(res.has_value());
   EXPECT_EQ("2.2", res.value());
@@ -476,10 +476,13 @@ TEST(JsonExtractorTest, reextractJsonTest) {
         "e mail":"amy@only_for_json_udf_test.net",
         "owner":"amy"})DELIM";
   auto originalJsonObj = jsonExtract(json, "$");
-  // extract the same json json by giving the root path
-  auto reExtractedJsonObj = jsonExtract(originalJsonObj.value(), "$");
-  ASSERT_TRUE(reExtractedJsonObj.hasValue());
-  // expect the re-extracted json object to be the same as the original jsonObj
+
+  // Extract the same json json by giving the root path.
+  auto reExtractedJsonObj =
+      jsonExtractFromDynamic(originalJsonObj.value(), "$");
+  ASSERT_TRUE(reExtractedJsonObj.has_value());
+
+  // Expect the re-extracted json object to be the same as the original jsonObj.
   EXPECT_EQ(originalJsonObj.value(), reExtractedJsonObj.value());
 }
 
@@ -514,8 +517,10 @@ TEST(JsonExtractorTest, jsonMultipleExtractsTest) {
         "e mail":"amy@only_for_json_udf_test.net",
         "owner":"amy"})DELIM";
   auto extract1 = jsonExtract(json, "$.store");
-  ASSERT_TRUE(extract1.hasValue());
-  auto extract2 = jsonExtract(extract1.value(), "$.fruit");
-  ASSERT_TRUE(extract2.hasValue());
+  ASSERT_TRUE(extract1.has_value());
+  auto extract2 = jsonExtractFromDynamic(extract1.value(), "$.fruit");
+  ASSERT_TRUE(extract2.has_value());
   EXPECT_EQ(jsonExtract(json, "$.store.fruit").value(), extract2.value());
 }
+
+} // namespace facebook::velox::functions::test
diff --git a/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp b/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp
index b3e2faa05948..d9528d5c23c0 100644
--- a/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp
+++ b/velox/functions/prestosql/registration/ArrayConcatRegistration.cpp
@@ -34,6 +34,8 @@ inline void registerArrayConcatFunctions(const std::string& prefix) {
   registerFunction<
       ParameterBinder<ArrayConcatFunction, T>,
       Array<T>,
+      Array<T>,
+      Array<T>,
       Variadic<Array<T>>>({prefix + "concat"});
 }
 } // namespace
diff --git a/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
index 63302b4f5f92..da00791dc70f 100644
--- a/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/ArrayFunctionsRegistration.cpp
@@ -16,6 +16,7 @@
 
 #include <string>
 
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/ArrayRemoveNullFunction.h"
 #include "velox/functions/lib/ArrayShuffle.h"
@@ -24,6 +25,7 @@
 #include "velox/functions/prestosql/ArrayConstructor.h"
 #include "velox/functions/prestosql/ArrayFunctions.h"
 #include "velox/functions/prestosql/ArraySort.h"
+#include "velox/functions/prestosql/ArraySubset.h"
 #include "velox/functions/prestosql/WidthBucketArray.h"
 #include "velox/functions/prestosql/types/JsonRegistration.h"
 
@@ -123,6 +125,15 @@ inline void registerArrayRemoveFunctions(const std::string& prefix) {
       {prefix + "array_remove"});
 }
 
+template <typename T>
+inline void registerArraySubsetFunctions(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<ArraySubsetFunction, T>,
+      Array<T>,
+      Array<T>,
+      Array<int32_t>>({prefix + "array_subset"});
+}
+
 void registerInternalArrayFunctions() {
   VELOX_REGISTER_VECTOR_FUNCTION(
       udf_$internal$canonicalize, "$internal$canonicalize");
@@ -158,16 +169,22 @@ void registerArrayFunctions(const std::string& prefix) {
       makeArrayShuffle,
       getMetadataForArrayShuffle());
 
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_sort, prefix + "array_sort");
-  VELOX_REGISTER_VECTOR_FUNCTION(
-      udf_array_sort_desc, prefix + "array_sort_desc");
-
+  exec::registerStatefulVectorFunction(
+      prefix + "array_sort", arraySortSignatures(true), makeArraySortAsc);
+  exec::registerStatefulVectorFunction(
+      prefix + "array_sort_desc",
+      arraySortSignatures(false),
+      makeArraySortDesc);
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_max_by, prefix + "array_max_by");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_min_by, prefix + "array_min_by");
 
-  exec::registerExpressionRewrite([prefix](const auto& expr) {
-    return rewriteArraySortCall(prefix, expr);
-  });
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_array_flatten, prefix + "flatten");
+
+  auto checker = std::make_shared<SimpleComparisonChecker>();
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      [prefix, checker](const auto& expr) {
+        return rewriteArraySortCall(prefix, expr, checker);
+      });
 
   VELOX_REGISTER_VECTOR_FUNCTION(udf_array_sum, prefix + "array_sum");
   exec::registerStatefulVectorFunction(
@@ -212,11 +229,6 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayConcatFunctions(prefix);
   registerArrayNGramsFunctions(prefix);
 
-  registerFunction<
-      ArrayFlattenFunction,
-      Array<Generic<T1>>,
-      Array<Array<Generic<T1>>>>({prefix + "flatten"});
-
   registerArrayRemoveFunctions<int8_t>(prefix);
   registerArrayRemoveFunctions<int16_t>(prefix);
   registerArrayRemoveFunctions<int32_t>(prefix);
@@ -316,6 +328,8 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayCumSumFunction<int128_t>(prefix);
   registerArrayCumSumFunction<float>(prefix);
   registerArrayCumSumFunction<double>(prefix);
+  registerArrayCumSumFunction<LongDecimal<P1, S1>>(prefix);
+  registerArrayCumSumFunction<ShortDecimal<P1, S1>>(prefix);
 
   registerArrayHasDuplicatesFunctions<int8_t>(prefix);
   registerArrayHasDuplicatesFunctions<int16_t>(prefix);
@@ -343,5 +357,28 @@ void registerArrayFunctions(const std::string& prefix) {
   registerArrayNormalizeFunctions<int64_t>(prefix);
   registerArrayNormalizeFunctions<float>(prefix);
   registerArrayNormalizeFunctions<double>(prefix);
+
+  registerArraySubsetFunctions<int8_t>(prefix);
+  registerArraySubsetFunctions<int16_t>(prefix);
+  registerArraySubsetFunctions<int32_t>(prefix);
+  registerArraySubsetFunctions<int64_t>(prefix);
+  registerArraySubsetFunctions<int128_t>(prefix);
+  registerArraySubsetFunctions<float>(prefix);
+  registerArraySubsetFunctions<double>(prefix);
+  registerArraySubsetFunctions<bool>(prefix);
+  registerArraySubsetFunctions<Timestamp>(prefix);
+  registerArraySubsetFunctions<Date>(prefix);
+  registerArraySubsetFunctions<Varbinary>(prefix);
+  registerArraySubsetFunctions<Generic<T1>>(prefix);
+  registerFunction<
+      ArraySubsetVarcharFunction,
+      Array<Varchar>,
+      Array<Varchar>,
+      Array<int32_t>>({prefix + "array_subset"});
+  registerFunction<
+      ArraySubsetGenericFunction,
+      Array<Generic<T1>>,
+      Array<Generic<T1>>,
+      Array<int32_t>>({prefix + "array_subset"});
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp b/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
index 9b37f44ad4a8..cccfe4d3585e 100644
--- a/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/BinaryFunctionsRegistration.cpp
@@ -24,6 +24,8 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<CRC32Function, int64_t, Varbinary>({prefix + "crc32"});
   registerFunction<XxHash64Function, Varbinary, Varbinary>(
       {prefix + "xxhash64"});
+  registerFunction<XxHash64Function, Varbinary, Varbinary, int64_t>(
+      {prefix + "xxhash64"});
   registerFunction<Md5Function, Varbinary, Varbinary>({prefix + "md5"});
   registerFunction<Murmur3X64_128Function, Varbinary, Varbinary>(
       {prefix + "murmur3_x64_128"});
@@ -45,6 +47,8 @@ void registerSimpleFunctions(const std::string& prefix) {
 
   registerFunction<ToHexFunction, Varchar, Varbinary>({prefix + "to_hex"});
   registerFunction<FromHexFunction, Varbinary, Varchar>({prefix + "from_hex"});
+  registerFunction<FromHexFunction, Varbinary, Varbinary>(
+      {prefix + "from_hex"});
   registerFunction<ToBase64Function, Varchar, Varbinary>(
       {prefix + "to_base64"});
 
@@ -53,10 +57,17 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<FromBase64Function, Varbinary, Varbinary>(
       {prefix + "from_base64"});
 
+  registerFunction<FromBase32Function, Varbinary, Varchar>(
+      {prefix + "from_base32"});
+  registerFunction<FromBase32Function, Varbinary, Varbinary>(
+      {prefix + "from_base32"});
+
   registerFunction<ToBase64UrlFunction, Varchar, Varbinary>(
       {prefix + "to_base64url"});
   registerFunction<FromBase64UrlFunction, Varbinary, Varchar>(
       {prefix + "from_base64url"});
+  registerFunction<FromBase64UrlFunction, Varbinary, Varbinary>(
+      {prefix + "from_base64url"});
 
   registerFunction<FromBigEndian32, int32_t, Varbinary>(
       {prefix + "from_big_endian_32"});
diff --git a/velox/functions/prestosql/registration/BingTileFunctionsRegistration.cpp b/velox/functions/prestosql/registration/BingTileFunctionsRegistration.cpp
index 87747572fdc3..3b328f8a215e 100644
--- a/velox/functions/prestosql/registration/BingTileFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/BingTileFunctionsRegistration.cpp
@@ -27,7 +27,7 @@ namespace {
 
 void registerSimpleBingTileFunctions(const std::string& prefix) {
   // BingTile constructors
-  registerFunction<BingTileFunction, BingTile, int32_t, int32_t, int8_t>(
+  registerFunction<BingTileFunction, BingTile, int32_t, int32_t, int32_t>(
       {prefix + "bing_tile"});
   registerFunction<BingTileFunction, BingTile, Varchar>({prefix + "bing_tile"});
 
@@ -44,26 +44,31 @@ void registerSimpleBingTileFunctions(const std::string& prefix) {
       {prefix + "bing_tile_parent"});
   registerFunction<BingTileParentFunction, BingTile, BingTile, int8_t>(
       {prefix + "bing_tile_parent"});
+  registerFunction<BingTileParentFunction, BingTile, BingTile, int32_t>(
+      {prefix + "bing_tile_parent"});
   registerFunction<BingTileChildrenFunction, Array<BingTile>, BingTile>(
       {prefix + "bing_tile_children"});
-  registerFunction<BingTileChildrenFunction, Array<BingTile>, BingTile, int8_t>(
-      {prefix + "bing_tile_children"});
+  registerFunction<
+      BingTileChildrenFunction,
+      Array<BingTile>,
+      BingTile,
+      int32_t>({prefix + "bing_tile_children"});
   registerFunction<BingTileToQuadKeyFunction, Varchar, BingTile>(
       {prefix + "bing_tile_quadkey"});
-  registerFunction<BingTileAtFunction, BingTile, double, double, int8_t>(
+  registerFunction<BingTileAtFunction, BingTile, double, double, int32_t>(
       {prefix + "bing_tile_at"});
   registerFunction<
       BingTilesAroundFunction,
       Array<BingTile>,
       double,
       double,
-      int8_t>({prefix + "bing_tiles_around"});
+      int32_t>({prefix + "bing_tiles_around"});
   registerFunction<
       BingTilesAroundFunction,
       Array<BingTile>,
       double,
       double,
-      int8_t,
+      int32_t,
       double>({prefix + "bing_tiles_around"});
 }
 
diff --git a/velox/functions/prestosql/registration/CMakeLists.txt b/velox/functions/prestosql/registration/CMakeLists.txt
index 22f5d95cce39..a21623b6de77 100644
--- a/velox/functions/prestosql/registration/CMakeLists.txt
+++ b/velox/functions/prestosql/registration/CMakeLists.txt
@@ -24,33 +24,56 @@ velox_add_library(
   ComparisonFunctionsRegistration.cpp
   DateTimeFunctionsRegistration.cpp
   DataSizeFunctionsRegistration.cpp
+  EnumFunctionsRegistration.cpp
   GeneralFunctionsRegistration.cpp
-  GeometryFunctionsRegistration.cpp
   HyperLogFunctionsRegistration.cpp
   IntegerFunctionsRegistration.cpp
   FloatingPointFunctionsRegistration.cpp
   JsonFunctionsRegistration.cpp
+  KHyperLogLogFunctionsRegistration.cpp
   MapFunctionsRegistration.cpp
   MathematicalFunctionsRegistration.cpp
   MathematicalOperatorsRegistration.cpp
   ProbabilityTrigonometricFunctionsRegistration.cpp
   RegistrationFunctions.cpp
+  SetDigestFunctionsRegistration.cpp
+  SfmSketchFunctionsRegistration.cpp
   StringFunctionsRegistration.cpp
   TDigestFunctionsRegistration.cpp
-  URLFunctionsRegistration.cpp)
+  QDigestFunctionsRegistration.cpp
+  URLFunctionsRegistration.cpp
+)
+
+if(VELOX_ENABLE_GEO)
+  velox_compile_definitions(velox_functions_prestosql PRIVATE VELOX_ENABLE_GEO)
+  velox_sources(
+    velox_functions_prestosql
+    PRIVATE GeometryFunctionsRegistration.cpp SphericalGeographyFunctionsRegistration.cpp
+  )
+endif()
+
+if(VELOX_ENABLE_FAISS)
+  set_source_files_properties(
+    MathematicalFunctionsRegistration.cpp
+    PROPERTIES COMPILE_DEFINITIONS VELOX_ENABLE_FAISS
+  )
+endif()
 
 # 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" AND NOT VELOX_MONO_LIBRARY)
-  target_compile_options(velox_functions_prestosql
-                         PRIVATE -Wno-deprecated-declarations)
+  target_compile_options(velox_functions_prestosql PRIVATE -Wno-deprecated-declarations)
 endif()
 
-velox_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
+  velox_functions_sfm
+  simdjson::simdjson
+)
 
 if(NOT VELOX_MONO_LIBRARY)
-  set_property(TARGET velox_functions_prestosql PROPERTY JOB_POOL_COMPILE
-                                                         high_memory_pool)
+  set_property(TARGET velox_functions_prestosql PROPERTY JOB_POOL_COMPILE high_memory_pool)
 endif()
diff --git a/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
index dab8925e3d00..f30c1dc2b7fe 100644
--- a/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/ComparisonFunctionsRegistration.cpp
@@ -19,6 +19,8 @@
 #include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixRegistration.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneRegistration.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
@@ -33,6 +35,8 @@ void registerNonSimdizableScalar(const std::vector<std::string>& aliases) {
   registerFunction<T, TReturn, Timestamp, Timestamp>(aliases);
   registerFunction<T, TReturn, TimestampWithTimezone, TimestampWithTimezone>(
       aliases);
+  registerFunction<T, TReturn, Time, Time>(aliases);
+  registerFunction<T, TReturn, TimeWithTimezone, TimeWithTimezone>(aliases);
   registerFunction<T, TReturn, IPAddress, IPAddress>(aliases);
 }
 } // namespace
@@ -41,6 +45,7 @@ void registerComparisonFunctions(const std::string& prefix) {
   // Comparison functions also need TimestampWithTimezoneType,
   // independent of DateTimeFunctions
   registerTimestampWithTimeZoneType();
+  registerTimeWithTimezoneType();
   registerIPAddressType();
   registerIPPrefixType();
 
@@ -94,6 +99,14 @@ void registerComparisonFunctions(const std::string& prefix) {
       {prefix + "between"});
   registerFunction<BetweenFunction, bool, Timestamp, Timestamp, Timestamp>(
       {prefix + "between"});
+  registerFunction<BetweenFunction, bool, Time, Time, Time>(
+      {prefix + "between"});
+  registerFunction<
+      BetweenFunction,
+      bool,
+      TimeWithTimezone,
+      TimeWithTimezone,
+      TimeWithTimezone>({prefix + "between"});
   registerFunction<
       BetweenFunction,
       bool,
diff --git a/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp b/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
index d57faae1d112..7aa6ec67620a 100644
--- a/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/DateTimeFunctionsRegistration.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/DateTimeFunctions.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneRegistration.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.h"
 
 namespace facebook::velox::functions {
@@ -89,6 +90,10 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "to_unixtime"});
 
   registerFromUnixtime(prefix + "from_unixtime");
+  registerFunction<CurrentTimezoneFunction, Varchar>(
+      {prefix + "current_timezone"});
+  registerFunction<CurrentTimestampFunction, TimestampWithTimezone>(
+      {prefix + "current_timestamp", prefix + "now"});
 
   registerFunction<DateFunction, Date, Varchar>({prefix + "date"});
   registerFunction<DateFunction, Date, Timestamp>({prefix + "date"});
@@ -146,6 +151,35 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerTimestampPlusInterval<TimestampWithTimezone>({prefix + "plus"});
   registerTimestampMinusInterval<TimestampWithTimezone>({prefix + "minus"});
 
+  // Register Time + Interval and Interval + Time functions
+  registerFunction<TimePlusInterval, Time, Time, IntervalDayTime>(
+      {prefix + "plus"});
+
+  registerFunction<IntervalPlusTime, Time, IntervalDayTime, Time>(
+      {prefix + "plus"});
+
+  // Register Time - Interval function
+  registerFunction<TimeMinusInterval, Time, Time, IntervalDayTime>(
+      {prefix + "minus"});
+
+  // Register Time - Time function (returns IntervalDayTime)
+  registerFunction<TimeMinusFunction, IntervalDayTime, Time, Time>(
+      {prefix + "minus"});
+
+  // Use optimized vector function for Time + IntervalYearMonth (identity
+  // function)
+  exec::registerVectorFunction(
+      prefix + "plus",
+      TimeIntervalYearMonthVectorFunction::signaturesPlus(),
+      std::make_unique<TimeIntervalYearMonthVectorFunction>());
+
+  // Use optimized vector function for Time - IntervalYearMonth (identity
+  // function). Only supports (time, interval), not (interval, time).
+  exec::registerVectorFunction(
+      prefix + "minus",
+      TimeIntervalYearMonthVectorFunction::signaturesMinus(),
+      std::make_unique<TimeIntervalYearMonthVectorFunction>());
+
   registerFunction<
       TimestampMinusFunction,
       IntervalDayTime,
@@ -183,6 +217,7 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<HourFunction, int64_t, Date>({prefix + "hour"});
   registerFunction<HourFunction, int64_t, TimestampWithTimezone>(
       {prefix + "hour"});
+  registerFunction<HourFunction, int64_t, Time>({prefix + "hour"});
   registerFunction<HourFromIntervalFunction, int64_t, IntervalDayTime>(
       {prefix + "hour"});
 
@@ -197,6 +232,7 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<MinuteFunction, int64_t, Date>({prefix + "minute"});
   registerFunction<MinuteFunction, int64_t, TimestampWithTimezone>(
       {prefix + "minute"});
+  registerFunction<MinuteFunction, int64_t, Time>({prefix + "minute"});
   registerFunction<MinuteFromIntervalFunction, int64_t, IntervalDayTime>(
       {prefix + "minute"});
 
@@ -204,6 +240,7 @@ void registerSimpleFunctions(const std::string& prefix) {
   registerFunction<SecondFunction, int64_t, Date>({prefix + "second"});
   registerFunction<SecondFunction, int64_t, TimestampWithTimezone>(
       {prefix + "second"});
+  registerFunction<SecondFunction, int64_t, Time>({prefix + "second"});
   registerFunction<SecondFromIntervalFunction, int64_t, IntervalDayTime>(
       {prefix + "second"});
 
@@ -213,6 +250,8 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "millisecond"});
   registerFunction<MillisecondFunction, int64_t, TimestampWithTimezone>(
       {prefix + "millisecond"});
+  registerFunction<MillisecondFunction, int64_t, Time>(
+      {prefix + "millisecond"});
   registerFunction<MillisecondFromIntervalFunction, int64_t, IntervalDayTime>(
       {prefix + "millisecond"});
 
@@ -225,6 +264,8 @@ void registerSimpleFunctions(const std::string& prefix) {
       TimestampWithTimezone,
       Varchar,
       TimestampWithTimezone>({prefix + "date_trunc"});
+  registerFunction<DateTruncFunction, Time, Varchar, Time>(
+      {prefix + "date_trunc"});
   registerFunction<DateAddFunction, Date, Varchar, int64_t, Date>(
       {prefix + "date_add"});
   registerFunction<DateAddFunction, Timestamp, Varchar, int64_t, Timestamp>(
@@ -235,6 +276,8 @@ void registerSimpleFunctions(const std::string& prefix) {
       Varchar,
       int64_t,
       TimestampWithTimezone>({prefix + "date_add"});
+  registerFunction<DateAddFunction, Time, Varchar, int64_t, Time>(
+      {prefix + "date_add"});
   registerFunction<DateDiffFunction, int64_t, Varchar, Date, Date>(
       {prefix + "date_diff"});
   registerFunction<DateDiffFunction, int64_t, Varchar, Timestamp, Timestamp>(
@@ -245,6 +288,8 @@ void registerSimpleFunctions(const std::string& prefix) {
       Varchar,
       TimestampWithTimezone,
       TimestampWithTimezone>({prefix + "date_diff"});
+  registerFunction<DateDiffFunction, int64_t, Varchar, Time, Time>(
+      {prefix + "date_diff"});
   registerFunction<DateFormatFunction, Varchar, Timestamp, Varchar>(
       {prefix + "date_format"});
   registerFunction<DateFormatFunction, Varchar, TimestampWithTimezone, Varchar>(
@@ -281,6 +326,12 @@ void registerSimpleFunctions(const std::string& prefix) {
       TimestampWithTimezone,
       Varchar>({prefix + "at_timezone"});
 
+  registerFunction<
+      AtTimezoneTimeWithTimezoneFunction,
+      TimeWithTimezone,
+      TimeWithTimezone,
+      Varchar>({prefix + "at_timezone"});
+
   registerFunction<ToMillisecondFunction, int64_t, IntervalDayTime>(
       {prefix + "to_milliseconds"});
 
@@ -288,15 +339,19 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "xxhash64_internal"});
   registerFunction<XxHash64TimestampFunction, int64_t, Timestamp>(
       {prefix + "xxhash64_internal"});
+  registerFunction<XxHash64TimeFunction, int64_t, Time>(
+      {prefix + "xxhash64_internal"});
 
   registerFunction<ParseDurationFunction, IntervalDayTime, Varchar>(
       {prefix + "parse_duration"});
+
+  registerFunction<LocalTimeFunction, Time>({prefix + "localtime"});
 }
 } // namespace
 
 void registerDateTimeFunctions(const std::string& prefix) {
   registerTimestampWithTimeZoneType();
-
+  registerTimeWithTimezoneType();
   registerSimpleFunctions(prefix);
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/EnumFunctionsRegistration.cpp b/velox/functions/prestosql/registration/EnumFunctionsRegistration.cpp
new file mode 100644
index 000000000000..477f796e7317
--- /dev/null
+++ b/velox/functions/prestosql/registration/EnumFunctionsRegistration.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/functions/Registerer.h"
+#include "velox/functions/prestosql/EnumFunctions.h"
+#include "velox/functions/prestosql/types/BigintEnumRegistration.h"
+#include "velox/functions/prestosql/types/VarcharEnumRegistration.h"
+#include "velox/type/SimpleFunctionApi.h"
+
+namespace facebook::velox::functions {
+
+void registerEnumFunctions(const std::string& prefix) {
+  registerBigintEnumType();
+  registerVarcharEnumType();
+
+  registerFunction<
+      ParameterBinder<EnumKeyFunction, BigintEnumTypePtr>,
+      Varchar,
+      BigintEnum<E1>>({prefix + "enum_key"});
+  registerFunction<
+      ParameterBinder<EnumKeyFunction, VarcharEnumTypePtr>,
+      Varchar,
+      VarcharEnum<E1>>({prefix + "enum_key"});
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp b/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
index a33d0a62a6bf..d49b9ac4d5fb 100644
--- a/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/GeneralFunctionsRegistration.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/RegisterSpecialForm.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/IsNull.h"
@@ -22,6 +23,7 @@
 #include "velox/functions/prestosql/InPredicate.h"
 #include "velox/functions/prestosql/Reduce.h"
 #include "velox/functions/prestosql/types/IPAddressType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 
 namespace facebook::velox::functions {
@@ -59,6 +61,8 @@ void registerAllGreatestLeastFunctions(const std::string& prefix) {
   registerGreatestLeastFunction<Timestamp>(prefix);
   registerGreatestLeastFunction<TimestampWithTimezone>(prefix);
   registerGreatestLeastFunction<IPAddress>(prefix);
+  registerGreatestLeastFunction<Time>(prefix);
+  registerGreatestLeastFunction<TimeWithTimezone>(prefix);
 }
 } // namespace
 
@@ -78,7 +82,7 @@ void registerAllSpecialFormGeneralFunctions() {
       bool,
       Generic<T1>,
       Variadic<Generic<T1>>>({"in"});
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_concat_row, "row_constructor");
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_concat_row, expression::kRowConstructor);
   registerIsNullFunction("is_null");
 }
 
diff --git a/velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp b/velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp
index 018a78bfa5c4..478b568a2524 100644
--- a/velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/GeometryFunctionsRegistration.cpp
@@ -17,7 +17,9 @@
 #include <string>
 #include "velox/functions/Registerer.h"
 #include "velox/functions/prestosql/GeometryFunctions.h"
+#include "velox/functions/prestosql/types/BingTileType.h"
 #include "velox/functions/prestosql/types/GeometryRegistration.h"
+#include "velox/functions/prestosql/types/SphericalGeographyRegistration.h"
 
 namespace facebook::velox::functions {
 
@@ -30,10 +32,35 @@ void registerConstructors(const std::string& prefix) {
       {{prefix + "ST_GeomFromBinary"}});
   registerFunction<StAsTextFunction, Varchar, Geometry>(
       {{prefix + "ST_AsText"}});
+  registerFunction<SphericalAsTextFunction, Varchar, SphericalGeography>(
+      {{prefix + "ST_AsText"}});
   registerFunction<StAsBinaryFunction, Varbinary, Geometry>(
       {{prefix + "ST_AsBinary"}});
   registerFunction<StPointFunction, Geometry, double, double>(
       {{prefix + "ST_Point"}});
+  registerFunction<StLineFromTextFunction, Geometry, Varchar>(
+      {{prefix + "ST_LineFromText"}});
+  registerFunction<StLineStringFunction, Geometry, Array<Geometry>>(
+      {{prefix + "ST_LineString"}});
+  registerFunction<StMultiPointFunction, Geometry, Array<Geometry>>(
+      {{prefix + "ST_MultiPoint"}});
+  registerFunction<ToSphericalGeographyFunction, SphericalGeography, Geometry>(
+      {{prefix + "to_spherical_geography"}});
+  registerFunction<ToGeometryFunction, Geometry, SphericalGeography>(
+      {{prefix + "to_geometry"}});
+  registerFunction<
+      StSphericalCentroidFunction,
+      SphericalGeography,
+      SphericalGeography>({{prefix + "st_centroid"}});
+  registerFunction<
+      StSphericalDistanceFunction,
+      double,
+      SphericalGeography,
+      SphericalGeography>({{prefix + "st_distance"}});
+  registerFunction<StSphericalLengthFunction, double, SphericalGeography>(
+      {{prefix + "st_length"}});
+  registerFunction<StSphericalAreaFunction, double, SphericalGeography>(
+      {{prefix + "st_area"}});
 }
 
 void registerRelationPredicates(const std::string& prefix) {
@@ -59,6 +86,8 @@ void registerRelationPredicates(const std::string& prefix) {
 }
 
 void registerOverlayOperations(const std::string& prefix) {
+  registerFunction<StBoundaryFunction, Geometry, Geometry>(
+      {{prefix + "St_Boundary"}});
   registerFunction<StDifferenceFunction, Geometry, Geometry, Geometry>(
       {{prefix + "ST_Difference"}});
   registerFunction<StIntersectionFunction, Geometry, Geometry, Geometry>(
@@ -67,22 +96,134 @@ void registerOverlayOperations(const std::string& prefix) {
       {{prefix + "ST_SymDifference"}});
   registerFunction<StUnionFunction, Geometry, Geometry, Geometry>(
       {{prefix + "ST_Union"}});
+  registerFunction<StEnvelopeAsPtsFunction, Array<Geometry>, Geometry>(
+      {{prefix + "ST_EnvelopeAsPts"}});
+  registerFunction<ExpandEnvelopeFunction, Geometry, Geometry, double>(
+      {{prefix + "expand_envelope"}});
 }
 
 void registerAccessors(const std::string& prefix) {
+  registerFunction<StIsValidFunction, bool, Geometry>(
+      {{prefix + "ST_IsValid"}});
+  registerFunction<StIsSimpleFunction, bool, Geometry>(
+      {{prefix + "ST_IsSimple"}});
+  registerFunction<GeometryInvalidReasonFunction, Varchar, Geometry>(
+      {{prefix + "geometry_invalid_reason"}});
+  registerFunction<SimplifyGeometryFunction, Geometry, Geometry, double>(
+      {{prefix + "simplify_geometry"}});
+
   registerFunction<StAreaFunction, double, Geometry>({{prefix + "ST_Area"}});
+  registerFunction<StCentroidFunction, Geometry, Geometry>(
+      {{prefix + "ST_Centroid"}});
   registerFunction<StXFunction, double, Geometry>({{prefix + "ST_X"}});
   registerFunction<StYFunction, double, Geometry>({{prefix + "ST_Y"}});
+  registerFunction<StXMinFunction, double, Geometry>({{prefix + "ST_XMin"}});
+  registerFunction<StYMinFunction, double, Geometry>({{prefix + "ST_YMin"}});
+  registerFunction<StXMaxFunction, double, Geometry>({{prefix + "ST_XMax"}});
+  registerFunction<StYMaxFunction, double, Geometry>({{prefix + "ST_YMax"}});
+  registerFunction<StGeometryTypeFunction, Varchar, Geometry>(
+      {{prefix + "ST_GeometryType"}});
+  registerFunction<StDistanceFunction, double, Geometry, Geometry>(
+      {{prefix + "ST_Distance"}});
+  registerFunction<StPolygonFunction, Geometry, Varchar>(
+      {{prefix + "ST_Polygon"}});
+  registerFunction<StIsClosedFunction, bool, Geometry>(
+      {{prefix + "ST_IsClosed"}});
+  registerFunction<StIsEmptyFunction, bool, Geometry>(
+      {{prefix + "ST_IsEmpty"}});
+  registerFunction<StIsRingFunction, bool, Geometry>({{prefix + "ST_IsRing"}});
+  registerFunction<StLengthFunction, double, Geometry>(
+      {{prefix + "ST_Length"}});
+  registerFunction<StPointNFunction, Geometry, Geometry, int32_t>(
+      {{prefix + "ST_PointN"}});
+  registerFunction<StStartPointFunction, Geometry, Geometry>(
+      {{prefix + "ST_StartPoint"}});
+  registerFunction<StEndPointFunction, Geometry, Geometry>(
+      {{prefix + "ST_EndPoint"}});
+  registerFunction<StGeometryNFunction, Geometry, Geometry, int32_t>(
+      {{prefix + "ST_GeometryN"}});
+  registerFunction<StInteriorRingNFunction, Geometry, Geometry, int32_t>(
+      {{prefix + "ST_InteriorRingN"}});
+  registerFunction<StNumGeometriesFunction, int32_t, Geometry>(
+      {{prefix + "ST_NumGeometries"}});
+  registerFunction<StNumInteriorRingFunction, int64_t, Geometry>(
+      {{prefix + "ST_NumInteriorRing"}});
+  registerFunction<StConvexHullFunction, Geometry, Geometry>(
+      {{prefix + "ST_ConvexHull"}});
+  registerFunction<StDimensionFunction, int8_t, Geometry>(
+      {{prefix + "ST_Dimension"}});
+  registerFunction<StExteriorRingFunction, Geometry, Geometry>(
+      {{prefix + "ST_ExteriorRing"}});
+  registerFunction<StEnvelopeFunction, Geometry, Geometry>(
+      {{prefix + "ST_Envelope"}});
+  registerFunction<StBufferFunction, Geometry, Geometry, double>(
+      {{prefix + "ST_Buffer"}});
+  registerFunction<LineLocatePointFunction, double, Geometry, Geometry>(
+      {{prefix + "line_locate_point"}});
+  registerFunction<LineInterpolatePointFunction, Geometry, Geometry, double>(
+      {{prefix + "line_interpolate_point"}});
+
+  velox::exec::registerVectorFunction(
+      prefix + "ST_CoordDim",
+      StCoordDimFunction::signatures(),
+      std::make_unique<StCoordDimFunction>());
+  registerFunction<StPointsFunction, Array<Geometry>, Geometry>(
+      {{prefix + "ST_Points"}});
+  registerFunction<StNumPointsFunction, int64_t, Geometry>(
+      {{prefix + "ST_NumPoints"}});
+  registerFunction<StInteriorRingsFunction, Array<Geometry>, Geometry>(
+      {{prefix + "ST_InteriorRings"}});
+  registerFunction<StGeometriesFunction, Array<Geometry>, Geometry>(
+      {{prefix + "ST_Geometries"}});
+  registerFunction<GeometryAsGeoJsonFunction, Varchar, Geometry>(
+      {{prefix + "geometry_as_geojson"}});
+  registerFunction<GeometryFromGeoJsonFunction, Geometry, Varchar>(
+      {{prefix + "geometry_from_geojson"}});
+  registerFunction<GeometryUnionFunction, Geometry, Array<Geometry>>(
+      {{prefix + "geometry_union"}});
+  registerFunction<
+      GeometryNearestPointsFunction,
+      Array<Geometry>,
+      Geometry,
+      Geometry>({{prefix + "geometry_nearest_points"}});
+  registerFunction<
+      FlattenGeometryCollectionsFunction,
+      Array<Geometry>,
+      Geometry>({{prefix + "flatten_geometry_collections"}});
+  registerFunction<
+      GreatCircleDistanceFunction,
+      double,
+      double,
+      double,
+      double,
+      double>({{prefix + "great_circle_distance"}});
+}
+
+void registerBingTileGeometryFunctions(const std::string& prefix) {
+  registerFunction<BingTilePolygonFunction, Geometry, BingTile>(
+      {{prefix + "bing_tile_polygon"}});
+  registerFunction<
+      GeometryToBingTilesFunction,
+      Array<BingTile>,
+      Geometry,
+      int32_t>({{prefix + "geometry_to_bing_tiles"}});
+  registerFunction<
+      GeometryToDissolvedBingTilesFunction,
+      Array<BingTile>,
+      Geometry,
+      int32_t>({{prefix + "geometry_to_dissolved_bing_tiles"}});
 }
 
 } // namespace
 
 void registerGeometryFunctions(const std::string& prefix) {
   registerGeometryType();
+  registerSphericalGeographyType();
   registerConstructors(prefix);
   registerRelationPredicates(prefix);
   registerOverlayOperations(prefix);
   registerAccessors(prefix);
+  registerBingTileGeometryFunctions(prefix);
 }
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp b/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
index 67e2294bcf43..772e0d31d87b 100644
--- a/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/HyperLogFunctionsRegistration.cpp
@@ -31,5 +31,8 @@ void registerHyperLogFunctions(const std::string& prefix) {
       Constant<double>>({prefix + "empty_approx_set"});
   registerFunction<EmptyApproxSetFunction, HyperLogLog>(
       {prefix + "empty_approx_set"});
+
+  registerFunction<MergeHllFunction, HyperLogLog, Array<HyperLogLog>>(
+      {prefix + "merge_hll"});
 }
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/KHyperLogLogFunctionsRegistration.cpp b/velox/functions/prestosql/registration/KHyperLogLogFunctionsRegistration.cpp
new file mode 100644
index 000000000000..c26d069d5696
--- /dev/null
+++ b/velox/functions/prestosql/registration/KHyperLogLogFunctionsRegistration.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/Registerer.h"
+#include "velox/functions/prestosql/KHyperLogLogFunctions.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+
+namespace facebook::velox::functions {
+
+void registerKHyperLogLogFunctions(const std::string& prefix) {
+  registerKHyperLogLogType();
+
+  registerFunction<KHyperLogLogCardinalityFunction, int64_t, KHyperLogLog>(
+      {prefix + "cardinality"});
+
+  registerFunction<
+      KHyperLogLogIntersectionCardinalityFunction,
+      int64_t,
+      KHyperLogLog,
+      KHyperLogLog>({prefix + "intersection_cardinality"});
+
+  registerFunction<
+      KHyperLogLogJaccardIndexFunction,
+      double,
+      KHyperLogLog,
+      KHyperLogLog>({prefix + "jaccard_index"});
+
+  registerFunction<
+      KHyperLogLogReidentificationPotentialFunction,
+      double,
+      KHyperLogLog,
+      int64_t>({prefix + "reidentification_potential"});
+
+  registerFunction<
+      KHyperLogLogUniquenessDistributionFunction,
+      Map<int64_t, double>,
+      KHyperLogLog>({prefix + "uniqueness_distribution"});
+
+  registerFunction<
+      KHyperLogLogUniquenessDistributionFunction,
+      Map<int64_t, double>,
+      KHyperLogLog,
+      int64_t>({prefix + "uniqueness_distribution"});
+
+  registerFunction<
+      MergeKHyperLogLogFunction,
+      KHyperLogLog,
+      Array<KHyperLogLog>>({prefix + "merge_khll"});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp b/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
index aba5494aed8a..ed0116dc9657 100644
--- a/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/MapFunctionsRegistration.cpp
@@ -18,50 +18,192 @@
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/MapConcat.h"
 #include "velox/functions/prestosql/Map.h"
+#include "velox/functions/prestosql/MapAppend.h"
+#include "velox/functions/prestosql/MapExcept.h"
 #include "velox/functions/prestosql/MapFunctions.h"
+#include "velox/functions/prestosql/MapIntersect.h"
 #include "velox/functions/prestosql/MapKeysByTopNValues.h"
+#include "velox/functions/prestosql/MapKeysOverlap.h"
 #include "velox/functions/prestosql/MapNormalize.h"
 #include "velox/functions/prestosql/MapSubset.h"
 #include "velox/functions/prestosql/MapTopN.h"
 #include "velox/functions/prestosql/MapTopNKeys.h"
 #include "velox/functions/prestosql/MapTopNValues.h"
 #include "velox/functions/prestosql/MultimapFromEntries.h"
+#include "velox/functions/prestosql/RemapKeys.h"
 
 namespace facebook::velox::functions {
 
 namespace {
+template <typename T>
+void registerRemapKeysPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<RemapKeysPrimitiveFunction, T>,
+      Map<T, Generic<T1>>,
+      Map<T, Generic<T1>>,
+      Array<T>,
+      Array<T>>({prefix + "remap_keys"});
+}
+
+void registerRemapKeys(const std::string& prefix) {
+  registerRemapKeysPrimitive<bool>(prefix);
+  registerRemapKeysPrimitive<int8_t>(prefix);
+  registerRemapKeysPrimitive<int16_t>(prefix);
+  registerRemapKeysPrimitive<int32_t>(prefix);
+  registerRemapKeysPrimitive<int64_t>(prefix);
+  registerRemapKeysPrimitive<float>(prefix);
+  registerRemapKeysPrimitive<double>(prefix);
+  registerRemapKeysPrimitive<Timestamp>(prefix);
+  registerRemapKeysPrimitive<Date>(prefix);
+
+  registerFunction<
+      RemapKeysVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>,
+      Array<Varchar>>({prefix + "remap_keys"});
+
+  registerFunction<
+      RemapKeysFunction,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>,
+      Array<Generic<T1>>>({prefix + "remap_keys"});
+}
 
 template <typename T>
-void registerMapSubsetPrimitive(const std::string& prefix) {
+void registerMapIntersectPrimitive(const std::string& prefix) {
   registerFunction<
-      ParameterBinder<MapSubsetPrimitiveFunction, T>,
+      ParameterBinder<MapIntersectPrimitiveFunction, T>,
       Map<T, Generic<T1>>,
       Map<T, Generic<T1>>,
-      Array<T>>({prefix + "map_subset"});
+      Array<T>>({prefix + "map_intersect"});
 }
 
-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);
+void registerMapIntersect(const std::string& prefix) {
+  registerMapIntersectPrimitive<bool>(prefix);
+  registerMapIntersectPrimitive<int8_t>(prefix);
+  registerMapIntersectPrimitive<int16_t>(prefix);
+  registerMapIntersectPrimitive<int32_t>(prefix);
+  registerMapIntersectPrimitive<int64_t>(prefix);
+  registerMapIntersectPrimitive<float>(prefix);
+  registerMapIntersectPrimitive<double>(prefix);
+  registerMapIntersectPrimitive<Timestamp>(prefix);
+  registerMapIntersectPrimitive<Date>(prefix);
 
   registerFunction<
-      MapSubsetVarcharFunction,
+      MapIntersectVarcharFunction,
       Map<Varchar, Generic<T1>>,
       Map<Varchar, Generic<T1>>,
-      Array<Varchar>>({prefix + "map_subset"});
+      Array<Varchar>>({prefix + "map_intersect"});
 
   registerFunction<
-      MapSubsetFunction,
+      MapIntersectFunction,
       Map<Generic<T1>, Generic<T2>>,
       Map<Generic<T1>, Generic<T2>>,
-      Array<Generic<T1>>>({prefix + "map_subset"});
+      Array<Generic<T1>>>({prefix + "map_intersect"});
+}
+
+template <typename T>
+void registerMapExceptPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<MapExceptPrimitiveFunction, T>,
+      Map<T, Generic<T1>>,
+      Map<T, Generic<T1>>,
+      Array<T>>({prefix + "map_except"});
+}
+
+void registerMapExcept(const std::string& prefix) {
+  registerMapExceptPrimitive<bool>(prefix);
+  registerMapExceptPrimitive<int8_t>(prefix);
+  registerMapExceptPrimitive<int16_t>(prefix);
+  registerMapExceptPrimitive<int32_t>(prefix);
+  registerMapExceptPrimitive<int64_t>(prefix);
+  registerMapExceptPrimitive<float>(prefix);
+  registerMapExceptPrimitive<double>(prefix);
+  registerMapExceptPrimitive<Timestamp>(prefix);
+  registerMapExceptPrimitive<Date>(prefix);
+
+  registerFunction<
+      MapExceptVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>>({prefix + "map_except"});
+
+  registerFunction<
+      MapExceptFunction,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>>({prefix + "map_except"});
+}
+
+template <typename T>
+void registerMapKeysOverlapPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<MapKeysOverlapPrimitiveFunction, T>,
+      bool,
+      Map<T, Generic<T1>>,
+      Array<T>>({prefix + "map_keys_overlap"});
+}
+
+void registerMapKeysOverlap(const std::string& prefix) {
+  registerMapKeysOverlapPrimitive<bool>(prefix);
+  registerMapKeysOverlapPrimitive<int8_t>(prefix);
+  registerMapKeysOverlapPrimitive<int16_t>(prefix);
+  registerMapKeysOverlapPrimitive<int32_t>(prefix);
+  registerMapKeysOverlapPrimitive<int64_t>(prefix);
+  registerMapKeysOverlapPrimitive<float>(prefix);
+  registerMapKeysOverlapPrimitive<double>(prefix);
+  registerMapKeysOverlapPrimitive<Timestamp>(prefix);
+  registerMapKeysOverlapPrimitive<Date>(prefix);
+
+  registerFunction<
+      MapKeysOverlapVarcharFunction,
+      bool,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>>({prefix + "map_keys_overlap"});
+
+  registerFunction<
+      MapKeysOverlapFunction,
+      bool,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>>({prefix + "map_keys_overlap"});
+}
+
+template <typename Key>
+void registerMapAppendPrimitive(const std::string& prefix) {
+  registerFunction<
+      ParameterBinder<MapAppendPrimitiveFunction, Key>,
+      Map<Key, Generic<T1>>,
+      Map<Key, Generic<T1>>,
+      Array<Key>,
+      Array<Generic<T1>>>({prefix + "map_append"});
+}
+
+void registerMapAppend(const std::string& prefix) {
+  registerMapAppendPrimitive<bool>(prefix);
+  registerMapAppendPrimitive<int8_t>(prefix);
+  registerMapAppendPrimitive<int16_t>(prefix);
+  registerMapAppendPrimitive<int32_t>(prefix);
+  registerMapAppendPrimitive<int64_t>(prefix);
+  registerMapAppendPrimitive<float>(prefix);
+  registerMapAppendPrimitive<double>(prefix);
+  registerMapAppendPrimitive<Timestamp>(prefix);
+  registerMapAppendPrimitive<Date>(prefix);
+
+  registerFunction<
+      MapAppendVarcharFunction,
+      Map<Varchar, Generic<T1>>,
+      Map<Varchar, Generic<T1>>,
+      Array<Varchar>,
+      Array<Generic<T1>>>({prefix + "map_append"});
+
+  registerFunction<
+      MapAppendFunction,
+      Map<Generic<T1>, Generic<T2>>,
+      Map<Generic<T1>, Generic<T2>>,
+      Array<Generic<T1>>,
+      Array<Generic<T2>>>({prefix + "map_append"});
 }
 
 void registerMapRemoveNullValues(const std::string& prefix) {
@@ -134,7 +276,17 @@ void registerMapFunctions(const std::string& prefix) {
       Map<Orderable<T1>, Orderable<T2>>,
       int64_t>({prefix + "map_top_n_values"});
 
-  registerMapSubset(prefix);
+  registerMapSubset(prefix + "map_subset");
+
+  registerRemapKeys(prefix);
+
+  registerMapIntersect(prefix);
+
+  registerMapExcept(prefix);
+
+  registerMapKeysOverlap(prefix);
+
+  registerMapAppend(prefix);
 
   registerMapRemoveNullValues(prefix);
 
diff --git a/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp b/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp
index cd7b5e9e590a..aedf99a8965a 100644
--- a/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/MathematicalFunctionsRegistration.cpp
@@ -17,6 +17,7 @@
 #include "velox/functions/lib/RegistrationHelpers.h"
 #include "velox/functions/prestosql/Arithmetic.h"
 #include "velox/functions/prestosql/DecimalFunctions.h"
+#include "velox/functions/prestosql/DistanceFunctions.h"
 #include "velox/functions/prestosql/Rand.h"
 
 namespace facebook::velox::functions {
@@ -123,6 +124,27 @@ void registerMathFunctions(const std::string& prefix) {
       double,
       Array<double>,
       Array<double>>({prefix + "cosine_similarity"});
+  registerFunction<DotProductArray, double, Array<double>, Array<double>>(
+      {prefix + "dot_product"});
+#ifdef VELOX_ENABLE_FAISS
+  registerFunction<
+      CosineSimilarityFunctionFloatArray,
+      float,
+      Array<float>,
+      Array<float>>({prefix + "cosine_similarity"});
+  registerFunction<
+      L2SquaredFunctionFloatArray,
+      float,
+      Array<float>,
+      Array<float>>({prefix + "l2_squared"});
+  registerFunction<
+      L2SquaredFunctionDoubleArray,
+      double,
+      Array<double>,
+      Array<double>>({prefix + "l2_squared"});
+  registerFunction<DotProductFloatArray, float, Array<float>, Array<float>>(
+      {prefix + "dot_product"});
+#endif
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp b/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp
index 2c96f95b10f8..818a3d9145bb 100644
--- a/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/ProbabilityTrigonometricFunctionsRegistration.cpp
@@ -89,6 +89,13 @@ void registerProbTrigFunctions(const std::string& prefix) {
       double>({prefix + "inverse_binomial_cdf"});
   registerFunction<InversePoissonCDFFunction, int32_t, double, double>(
       {prefix + "inverse_poisson_cdf"});
+  registerFunction<InverseFCDFFunction, double, double, double, double>(
+      {prefix + "inverse_f_cdf"});
+  registerFunction<InverseChiSquaredCdf, double, double, double>(
+      {prefix + "inverse_chi_squared_cdf"});
+  registerFunction<TCDFFunction, double, double, double>({prefix + "t_cdf"});
+  registerFunction<InverseTCDFFunction, double, double, double>(
+      {prefix + "inverse_t_cdf"});
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/registration/QDigestFunctionsRegistration.cpp b/velox/functions/prestosql/registration/QDigestFunctionsRegistration.cpp
new file mode 100644
index 000000000000..a0b083a15514
--- /dev/null
+++ b/velox/functions/prestosql/registration/QDigestFunctionsRegistration.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/functions/Registerer.h"
+#include "velox/functions/prestosql/QDigestFunctions.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+
+namespace facebook::velox::functions {
+
+void registerQDigestFunctions(const std::string& prefix) {
+  facebook::velox::registerQDigestType();
+
+  registerFunction<
+      ValueAtQuantileFunction,
+      int64_t,
+      SimpleQDigest<int64_t>,
+      double>({prefix + "value_at_quantile"});
+
+  registerFunction<
+      ValueAtQuantileFunction,
+      double,
+      SimpleQDigest<double>,
+      double>({prefix + "value_at_quantile"});
+
+  registerFunction<
+      ValueAtQuantileFunction,
+      float,
+      SimpleQDigest<float>,
+      double>({prefix + "value_at_quantile"});
+
+  registerFunction<
+      ValuesAtQuantilesFunction,
+      Array<int64_t>,
+      SimpleQDigest<int64_t>,
+      Array<double>>({prefix + "values_at_quantiles"});
+
+  registerFunction<
+      ValuesAtQuantilesFunction,
+      Array<double>,
+      SimpleQDigest<double>,
+      Array<double>>({prefix + "values_at_quantiles"});
+
+  registerFunction<
+      ValuesAtQuantilesFunction,
+      Array<float>,
+      SimpleQDigest<float>,
+      Array<double>>({prefix + "values_at_quantiles"});
+
+  registerFunction<
+      QuantileAtValueFunction,
+      double,
+      SimpleQDigest<double>,
+      double>({prefix + "quantile_at_value"});
+
+  registerFunction<
+      QuantileAtValueFunction,
+      double,
+      SimpleQDigest<int64_t>,
+      int64_t>({prefix + "quantile_at_value"});
+
+  registerFunction<
+      QuantileAtValueFunction,
+      double,
+      SimpleQDigest<float>,
+      float>({prefix + "quantile_at_value"});
+
+  registerFunction<
+      ScaleQDigestDoubleFunction,
+      SimpleQDigest<double>,
+      SimpleQDigest<double>,
+      double>({prefix + "scale_qdigest"});
+
+  registerFunction<
+      ScaleQDigestBigintFunction,
+      SimpleQDigest<int64_t>,
+      SimpleQDigest<int64_t>,
+      double>({prefix + "scale_qdigest"});
+
+  registerFunction<
+      ScaleQDigestRealFunction,
+      SimpleQDigest<float>,
+      SimpleQDigest<float>,
+      double>({prefix + "scale_qdigest"});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/RegistrationFunctions.cpp b/velox/functions/prestosql/registration/RegistrationFunctions.cpp
index 72487607a9fd..065f946351c9 100644
--- a/velox/functions/prestosql/registration/RegistrationFunctions.cpp
+++ b/velox/functions/prestosql/registration/RegistrationFunctions.cpp
@@ -16,6 +16,7 @@
 #include <string>
 #include "velox/functions/prestosql/IPAddressFunctions.h"
 #include "velox/functions/prestosql/UuidFunctions.h"
+#include "velox/functions/prestosql/types/P4HyperLogLogRegistration.h"
 
 namespace facebook::velox::functions {
 
@@ -29,7 +30,12 @@ extern void registerComparisonFunctions(const std::string& prefix);
 extern void registerDateTimeFunctions(const std::string& prefix);
 extern void registerGeneralFunctions(const std::string& prefix);
 extern void registerHyperLogFunctions(const std::string& prefix);
+extern void registerKHyperLogLogFunctions(const std::string& prefix);
 extern void registerTDigestFunctions(const std::string& prefix);
+extern void registerQDigestFunctions(const std::string& prefix);
+extern void registerSetDigestFunctions(const std::string& prefix);
+extern void registerSfmSketchFunctions(const std::string& prefix);
+extern void registerEnumFunctions(const std::string& prefix);
 extern void registerIntegerFunctions(const std::string& prefix);
 extern void registerFloatingPointFunctions(const std::string& prefix);
 extern void registerJsonFunctions(const std::string& prefix);
@@ -42,7 +48,10 @@ extern void registerMapAllowingDuplicates(
     const std::string& name,
     const std::string& prefix);
 extern void registerBingTileFunctions(const std::string& prefix);
+#ifdef VELOX_ENABLE_GEO
 extern void registerGeometryFunctions(const std::string& prefix);
+extern void registerSphericalGeographyFunctions();
+#endif
 extern void registerInternalArrayFunctions();
 
 namespace prestosql {
@@ -80,6 +89,18 @@ void registerTDigestFunctions(const std::string& prefix) {
   functions::registerTDigestFunctions(prefix);
 }
 
+void registerQDigestFunctions(const std::string& prefix) {
+  functions::registerQDigestFunctions(prefix);
+}
+
+void registerSfmSketchFunctions(const std::string& prefix) {
+  functions::registerSfmSketchFunctions(prefix);
+}
+
+void registerEnumFunctions(const std::string& prefix) {
+  functions::registerEnumFunctions(prefix);
+}
+
 void registerIntegerFunctions(const std::string& prefix) {
   functions::registerIntegerFunctions(prefix);
 }
@@ -92,10 +113,16 @@ void registerBingTileFunctions(const std::string& prefix) {
   functions::registerBingTileFunctions(prefix);
 }
 
+#ifdef VELOX_ENABLE_GEO
 void registerGeometryFunctions(const std::string& prefix) {
   functions::registerGeometryFunctions(prefix);
 }
 
+void registerSphericalGeographyFunctions() {
+  functions::registerSphericalGeographyFunctions();
+}
+#endif
+
 void registerGeneralFunctions(const std::string& prefix) {
   functions::registerGeneralFunctions(prefix);
 }
@@ -121,6 +148,7 @@ void registerBitwiseFunctions(const std::string& prefix) {
 }
 
 void registerAllScalarFunctions(const std::string& prefix) {
+  registerP4HyperLogLogType();
   registerArithmeticFunctions(prefix);
   registerCheckedArithmeticFunctions(prefix);
   registerComparisonFunctions(prefix);
@@ -128,11 +156,19 @@ void registerAllScalarFunctions(const std::string& prefix) {
   registerArrayFunctions(prefix);
   registerJsonFunctions(prefix);
   registerHyperLogFunctions(prefix);
+  registerKHyperLogLogFunctions(prefix);
   registerTDigestFunctions(prefix);
+  registerQDigestFunctions(prefix);
+  registerSfmSketchFunctions(prefix);
+  registerSetDigestFunctions(prefix);
+  registerEnumFunctions(prefix);
   registerIntegerFunctions(prefix);
   registerFloatingPointFunctions(prefix);
   registerBingTileFunctions(prefix);
+#ifdef VELOX_ENABLE_GEO
   registerGeometryFunctions(prefix);
+  registerSphericalGeographyFunctions();
+#endif
   registerGeneralFunctions(prefix);
   registerDateTimeFunctions(prefix);
   registerURLFunctions(prefix);
diff --git a/velox/functions/prestosql/registration/RegistrationFunctions.h b/velox/functions/prestosql/registration/RegistrationFunctions.h
index b75a5376d054..0ad07c32fd4e 100644
--- a/velox/functions/prestosql/registration/RegistrationFunctions.h
+++ b/velox/functions/prestosql/registration/RegistrationFunctions.h
@@ -33,10 +33,18 @@ void registerJsonFunctions(const std::string& prefix = "");
 
 void registerHyperLogFunctions(const std::string& prefix = "");
 
+void registerKHyperLogLogFunctions(const std::string& prefix = "");
+
 void registerTDigestFunctions(const std::string& prefix = "");
 
+void registerQDigestFunctions(const std::string& prefix = "");
+
+void registerSfmSketchFunctions(const std::string& prefix = "");
+
 void registerBingTileFunctions(const std::string& prefix = "");
 
+void registerEnumFunctions(const std::string& prefix = "");
+
 void registerGeneralFunctions(const std::string& prefix = "");
 
 void registerDateTimeFunctions(const std::string& prefix = "");
diff --git a/velox/functions/prestosql/registration/SetDigestFunctionsRegistration.cpp b/velox/functions/prestosql/registration/SetDigestFunctionsRegistration.cpp
new file mode 100644
index 000000000000..4d2252119011
--- /dev/null
+++ b/velox/functions/prestosql/registration/SetDigestFunctionsRegistration.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/Registerer.h"
+#include "velox/functions/prestosql/SetDigestFunctions.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+
+namespace facebook::velox::functions {
+
+void registerSetDigestFunctions(const std::string& prefix) {
+  facebook::velox::registerSetDigestType();
+
+  // Register cardinality(setdigest) -> bigint
+  registerFunction<
+      CardinalitySetDigestFunction,
+      int64_t,
+      facebook::velox::SetDigest>({prefix + "cardinality"});
+
+  // Register intersection_cardinality(setdigest, setdigest) -> bigint
+  registerFunction<
+      IntersectionCardinalityFunction,
+      int64_t,
+      facebook::velox::SetDigest,
+      facebook::velox::SetDigest>({prefix + "intersection_cardinality"});
+
+  // Register jaccard_index(setdigest, setdigest) -> double
+  registerFunction<
+      JaccardIndexFunction,
+      double,
+      facebook::velox::SetDigest,
+      facebook::velox::SetDigest>({prefix + "jaccard_index"});
+
+  // Register hash_counts(setdigest) -> map(bigint, smallint)
+  registerFunction<
+      HashCountsFunction,
+      Map<int64_t, int16_t>,
+      facebook::velox::SetDigest>({prefix + "hash_counts"});
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/SfmSketchFunctionsRegistration.cpp b/velox/functions/prestosql/registration/SfmSketchFunctionsRegistration.cpp
new file mode 100644
index 000000000000..39a1b4887027
--- /dev/null
+++ b/velox/functions/prestosql/registration/SfmSketchFunctionsRegistration.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/functions/Registerer.h"
+#include "velox/functions/prestosql/SfmSketchFunctions.h"
+#include "velox/functions/prestosql/types/SfmSketchRegistration.h"
+
+namespace facebook::velox::functions {
+
+void registerSfmSketchFunctions(const std::string& prefix) {
+  registerSfmSketchType();
+
+  registerFunction<SfmSketchCardinality, int64_t, SfmSketch>(
+      {prefix + "cardinality"});
+
+  registerFunction<NoisyEmptyApproxSetSfm, SfmSketch, Constant<double>>(
+      {prefix + "noisy_empty_approx_set_sfm"});
+  registerFunction<
+      NoisyEmptyApproxSetSfm,
+      SfmSketch,
+      Constant<double>,
+      Constant<int64_t>>({prefix + "noisy_empty_approx_set_sfm"});
+  registerFunction<
+      NoisyEmptyApproxSetSfm,
+      SfmSketch,
+      Constant<double>,
+      Constant<int64_t>,
+      Constant<int64_t>>({prefix + "noisy_empty_approx_set_sfm"});
+
+  registerFunction<mergeSfmSketchArray, SfmSketch, Array<SfmSketch>>(
+      {prefix + "merge_sfm"});
+}
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/SphericalGeographyFunctionsRegistration.cpp b/velox/functions/prestosql/registration/SphericalGeographyFunctionsRegistration.cpp
new file mode 100644
index 000000000000..447a9904883f
--- /dev/null
+++ b/velox/functions/prestosql/registration/SphericalGeographyFunctionsRegistration.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 "velox/functions/prestosql/types/SphericalGeographyRegistration.h"
+
+namespace facebook::velox::functions {
+
+void registerSphericalGeographyFunctions() {
+  registerSphericalGeographyType();
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp b/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
index 75bd33567385..57fcf0943dda 100644
--- a/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/StringFunctionsRegistration.cpp
@@ -13,9 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/functions/Registerer.h"
 #include "velox/functions/lib/Re2Functions.h"
 #include "velox/functions/prestosql/RegexpReplace.h"
+#include "velox/functions/prestosql/RegexpSplit.h"
 #include "velox/functions/prestosql/SplitPart.h"
 #include "velox/functions/prestosql/SplitToMap.h"
 #include "velox/functions/prestosql/SplitToMultiMap.h"
@@ -42,7 +44,13 @@ void registerSimpleFunctions(const std::string& prefix) {
       {prefix + "hamming_distance"});
   registerFunction<LevenshteinDistanceFunction, int64_t, Varchar, Varchar>(
       {prefix + "levenshtein_distance"});
+  registerFunction<JaroWinklerSimilarityFunction, double, Varchar, Varchar>(
+      {prefix + "jarowinkler_similarity"});
+  registerFunction<LongestCommonPrefixFunction, Varchar, Varchar, Varchar>(
+      {prefix + "longest_common_prefix"});
   registerFunction<LengthFunction, int64_t, Varchar>({prefix + "length"});
+  registerFunction<BitLengthFunction, int64_t, Varchar>(
+      {prefix + "bit_length"});
   registerFunction<XxHash64StringFunction, int64_t, Varchar>(
       {prefix + "xxhash64_internal"});
 
@@ -188,9 +196,10 @@ void registerSplitToMap(const std::string& prefix) {
       Varchar,
       Varchar,
       bool>({"$internal$split_to_map"});
-  exec::registerExpressionRewrite([prefix](const auto& expr) {
-    return rewriteSplitToMapCall(prefix, expr);
-  });
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      [prefix](const auto& expr) {
+        return rewriteSplitToMapCall(prefix, expr);
+      });
 }
 } // namespace
 
diff --git a/velox/functions/prestosql/registration/TDigestFunctionsRegistration.cpp b/velox/functions/prestosql/registration/TDigestFunctionsRegistration.cpp
index cad0503de97a..347fd8518000 100644
--- a/velox/functions/prestosql/registration/TDigestFunctionsRegistration.cpp
+++ b/velox/functions/prestosql/registration/TDigestFunctionsRegistration.cpp
@@ -45,6 +45,11 @@ void registerTDigestFunctions(const std::string& prefix) {
       double,
       SimpleTDigest<double>,
       double>({prefix + "quantile_at_value"});
+  registerFunction<
+      QuantilesAtValuesFunction,
+      Array<double>,
+      SimpleTDigest<double>,
+      Array<double>>({prefix + "quantiles_at_values"});
   registerFunction<
       ConstructTDigestFunction,
       SimpleTDigest<double>,
diff --git a/velox/functions/prestosql/tests/ArithmeticTest.cpp b/velox/functions/prestosql/tests/ArithmeticTest.cpp
index 21a850b007cb..e589ee78b709 100644
--- a/velox/functions/prestosql/tests/ArithmeticTest.cpp
+++ b/velox/functions/prestosql/tests/ArithmeticTest.cpp
@@ -181,6 +181,12 @@ class ArithmeticTest : public functions::test::FunctionBaseTest {
     assertExpression("c0 * c1", op1, doubleOp, expected);
     assertExpression("c1 * c0", op1, doubleOp, expected);
   }
+
+  template <typename T>
+  std::optional<T> getAbs(const T& input) {
+    const auto a = std::make_optional<T>(input);
+    return evaluateOnce<T>("abs(c0)", a);
+  }
 };
 
 TEST_F(ArithmeticTest, plus) {
@@ -1042,77 +1048,23 @@ 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());
-}
-
-TEST_F(ArithmeticTest, cosineSimilarityArray) {
-  const auto cosineSimilarity = [&](const std::vector<double>& left,
-                                    const std::vector<double>& right) {
-    auto leftMap = makeArrayVector<double>({left});
-    auto rightMap = makeArrayVector<double>({right});
-    return evaluateOnce<double>(
-               "cosine_similarity(c0,c1)", makeRowVector({leftMap, rightMap}))
-        .value();
-  };
-
-  EXPECT_DOUBLE_EQ(
-      (1 * 1 * 1 + 2 * 3) / (std::sqrt(5.0) * std::sqrt(10.0)),
-      cosineSimilarity({{1, 2}}, {{1, 3}}));
-
-  EXPECT_DOUBLE_EQ(
-      (1 * 1 + 2 * 3 + (-1) * 5) /
-          (std::sqrt(1 + 4 + 1) * std::sqrt(1 + 9 + 25)),
-      cosineSimilarity({{1, 2, -1}}, {{1, 3, 5}}));
-
-  EXPECT_TRUE(std::isnan(cosineSimilarity({}, {})));
+TEST_F(ArithmeticTest, abs) {
+  ASSERT_EQ(getAbs<int8_t>(-127), 127);
+  VELOX_ASSERT_THROW(
+      getAbs<int8_t>(std::numeric_limits<int8_t>::min()),
+      "Value -128 is out of range for abs(TINYINT)");
+  ASSERT_EQ(getAbs<int16_t>(-32767), 32767);
+  VELOX_ASSERT_THROW(
+      getAbs<int16_t>(std::numeric_limits<int16_t>::min()),
+      "Value -32768 is out of range for abs(SMALLINT)");
+  ASSERT_EQ(getAbs<int32_t>(-2147483647), 2147483647);
+  VELOX_ASSERT_THROW(
+      getAbs<int32_t>(std::numeric_limits<int32_t>::min()),
+      "Value -2147483648 is out of range for abs(INTEGER)");
+  ASSERT_EQ(getAbs<int64_t>(-9223372036854775807), 9223372036854775807);
   VELOX_ASSERT_THROW(
-      cosineSimilarity({1, 3}, {}), "Both arrays need to have identical size");
-  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {0, 0})));
-  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {kNan, 1})));
-  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {kInf, 1})));
+      getAbs<int64_t>(std::numeric_limits<int64_t>::min()),
+      "Value -9223372036854775808 is out of range for abs(BIGINT)");
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/tests/ArrayConcatTest.cpp b/velox/functions/prestosql/tests/ArrayConcatTest.cpp
index 446d8d7ed721..e7e73a41290c 100644
--- a/velox/functions/prestosql/tests/ArrayConcatTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayConcatTest.cpp
@@ -124,7 +124,9 @@ TEST_F(ArrayConcatTest, arity) {
       "concat(c0, c1, c2, c3)", {array1, array4, array3, array2}, expected);
 
   testExpressionWithError(
-      "concat(c0)", {array1}, "There must be 2 or more arguments to concat");
+      "concat(c0)",
+      {array1},
+      "Scalar function signature is not supported: concat(ARRAY<BIGINT>).");
 
   std::stringstream expression;
   std::vector<VectorPtr> inputArrayVector;
diff --git a/velox/functions/prestosql/tests/ArrayConstructorTest.cpp b/velox/functions/prestosql/tests/ArrayConstructorTest.cpp
index af9f95ddf131..21f986eff329 100644
--- a/velox/functions/prestosql/tests/ArrayConstructorTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayConstructorTest.cpp
@@ -187,7 +187,8 @@ TEST_F(ArrayConstructorTest, literals) {
 
   // Add null literals.
   result = evaluate(
-      "array_constructor(1, 2, null, 4, null)", makeRowVector(ROW({}), 1));
+      "array_constructor(1, 2, null::bigint, 4, null::bigint)",
+      makeRowVector(ROW({}), 1));
   expected =
       makeNullableArrayVector<int64_t>({{1, 2, std::nullopt, 4, std::nullopt}});
   test::assertEqualVectors(expected, result);
diff --git a/velox/functions/prestosql/tests/ArrayCumSumTest.cpp b/velox/functions/prestosql/tests/ArrayCumSumTest.cpp
index 11cdd3d2879a..80f9818b2588 100644
--- a/velox/functions/prestosql/tests/ArrayCumSumTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayCumSumTest.cpp
@@ -180,4 +180,77 @@ TEST_F(ArrayCumSumTest, doubleLimits) {
        {kMax, kNan, kNan}});
   testArrayCumSum<double>(expected, input);
 }
+
+TEST_F(ArrayCumSumTest, shortDecimal) {
+  constexpr int64_t kMax = std::numeric_limits<int64_t>::max();
+  constexpr int64_t kMin = std::numeric_limits<int64_t>::min();
+  auto input = makeNullableArrayVector<int64_t>(
+      {{}, // Empty
+       {100, 200, 300},
+       {kMax, -1, -2},
+       {kMax, kMin},
+       {kMax, kMin, kMax},
+       {std::nullopt, 500, -200, std::nullopt, 100}},
+      ARRAY(DECIMAL(10, 3)));
+
+  auto expected = makeNullableArrayVector<int64_t>(
+      {{},
+       {100, 300, 600},
+       {kMax, kMax - 1, kMax - 3},
+       {kMax, -1},
+       {kMax, -1, kMax - 1},
+       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt}},
+      ARRAY(DECIMAL(10, 3)));
+
+  testArrayCumSum<int64_t>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, shortDecimalOverflow) {
+  constexpr int64_t kMin = std::numeric_limits<int64_t>::min();
+  constexpr int64_t kMax = std::numeric_limits<int64_t>::max();
+
+  auto input = makeNullableArrayVector<int64_t>({{kMax, 1}});
+  VELOX_ASSERT_THROW(
+      evaluate("array_cum_sum(c0)", makeRowVector({input})), "overflow");
+
+  input = makeNullableArrayVector<int64_t>({{kMin, -1}});
+  VELOX_ASSERT_THROW(
+      evaluate("array_cum_sum(c0)", makeRowVector({input})), "overflow");
+}
+
+TEST_F(ArrayCumSumTest, longDecimal) {
+  auto input = makeNullableArrayVector<int128_t>(
+      {{},
+       {1, 2, 3},
+       {std::numeric_limits<int128_t>::max(), -1, -2},
+       {std::nullopt, 5, -2, std::nullopt, 1}},
+      ARRAY(DECIMAL(38, 10)));
+
+  auto expected = makeNullableArrayVector<int128_t>(
+      {{},
+       {1, 3, 6},
+       {std::numeric_limits<int128_t>::max(),
+        std::numeric_limits<int128_t>::max() - 1,
+        std::numeric_limits<int128_t>::max() - 3},
+       {std::nullopt, std::nullopt, std::nullopt, std::nullopt, std::nullopt}},
+      ARRAY(DECIMAL(38, 10)));
+
+  testArrayCumSum<int128_t>(expected, input);
+}
+
+TEST_F(ArrayCumSumTest, longDecimalOverflow) {
+  constexpr int128_t kMin = std::numeric_limits<int128_t>::min();
+  constexpr int128_t kMax = std::numeric_limits<int128_t>::max();
+
+  auto input = makeNullableArrayVector<int128_t>({{kMax, 1}});
+
+  VELOX_ASSERT_THROW(
+      evaluate("array_cum_sum(c0)", makeRowVector({input})), "overflow");
+
+  input = makeNullableArrayVector<int128_t>({{kMin, -1}});
+
+  VELOX_ASSERT_THROW(
+      evaluate("array_cum_sum(c0)", makeRowVector({input})), "overflow");
+}
+
 } // namespace
diff --git a/velox/functions/prestosql/tests/ArrayFlattenTest.cpp b/velox/functions/prestosql/tests/ArrayFlattenTest.cpp
index 92be38e09db9..5a468d894875 100644
--- a/velox/functions/prestosql/tests/ArrayFlattenTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayFlattenTest.cpp
@@ -25,19 +25,20 @@ namespace {
 
 class ArrayFlattenTest : public FunctionBaseTest {
  protected:
-  void testExpression(
+  VectorPtr testExpression(
       const std::string& expression,
       const std::vector<VectorPtr>& input,
       const VectorPtr& expected) {
     auto result = evaluate(expression, makeRowVector(input));
     assertEqualVectors(expected, result);
+    return result;
   }
 };
 
 /// Flatten integer arrays.
 TEST_F(ArrayFlattenTest, intArrays) {
-  const auto baseVector = makeArrayVector<int64_t>(
-      {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}});
+  const auto baseVector = makeArrayVectorFromJson<int64_t>(
+      {"[1, 1]", "[2,2]", "[3, 3]", "[4,4]", "[5, 5]", "[6, 6]"});
 
   // Create arrays of array vector using above base vector.
   // [[1, 1], [2, 2], [3, 3]]
@@ -55,7 +56,7 @@ TEST_F(ArrayFlattenTest, intArrays) {
 }
 
 /// Flatten arrays with null.
-TEST_F(ArrayFlattenTest, nullArray) {
+TEST_F(ArrayFlattenTest, nullArrayWithConsecutiveBaseElements) {
   const auto baseVector = makeNullableArrayVector<int64_t>(
       {{{1, 1}},
        std::nullopt,
@@ -77,4 +78,96 @@ TEST_F(ArrayFlattenTest, nullArray) {
 
   testExpression("flatten(c0)", {arrayOfArrays}, expected);
 }
+
+TEST_F(ArrayFlattenTest, nullArrayWithoutConsecutiveBaseElements) {
+  const auto baseVector = makeArrayVectorFromJson<int64_t>(
+      {"[1, 1]", "null", "[3, 3]", "[]", "[5, null]", "[null, 6]"});
+
+  // Create arrays of array vector using above base vector.
+  const auto reversedIndices = makeIndicesInReverse(6);
+  const auto mappedVector = wrapInDictionary(reversedIndices, baseVector);
+
+  // Create arrays of array vector using above mapped vector.
+  // [[null, 6], [5, null]]
+  // null
+  // [[3, 3], null, [1, 1]]
+  const auto arrayOfArrays = makeArrayVector({0, 3, 3}, mappedVector, {1});
+
+  // [[null, 6, 5, null]]
+  // null
+  // [[3, 3, 1, 1]]
+  const auto expected = makeNullableArrayVector<int64_t>(
+      {{{std::nullopt, 6, 5, std::nullopt}}, std::nullopt, {{3, 3, 1, 1}}});
+
+  testExpression("flatten(c0)", {arrayOfArrays}, expected);
+}
+
+TEST_F(ArrayFlattenTest, constantArrayWithConsecutiveBaseElements) {
+  const auto baseVector = makeArrayVectorFromJson<int64_t>(
+      {"[1, 1]", "null", "[3, 3]", "[]", "[5, null]", "[null, 6]"});
+  // Create arrays of array vector using above base vector.
+  // [[1, 1], null, [3, 3]]
+  // null
+  // [[], [5, null], [null, 6]]
+  const auto arrayOfArrays = makeArrayVector({0, 3, 3}, baseVector, {1});
+
+  // Create three element constant array by referencing the first element in
+  // 'arrayOfArrays'.
+  const auto constArrayOfArrays =
+      BaseVector::wrapInConstant(3, 0, arrayOfArrays);
+  // [[1, 1, 3, 3]]
+  // [[1, 1, 3, 3]]
+  // [[1, 1, 3, 3]]
+  const auto expected = makeArrayVector<int64_t>(
+      {{{1, 1, 3, 3}}, {{1, 1, 3, 3}}, {{1, 1, 3, 3}}});
+
+  // Enforce the constant encoding flatten path to trigger.
+  testExpression("flatten(c0)", {constArrayOfArrays}, expected);
+}
+
+TEST_F(ArrayFlattenTest, constantArrayWithoutConsecutiveBaseElements) {
+  const auto baseVector = makeArrayVectorFromJson<int64_t>(
+      {"[1, 1]", "null", "[3, 3]", "[]", "[5, null]", "[null, 6]"});
+  // Create arrays of array vector using above base vector.
+  const auto reversedIndices = makeIndicesInReverse(6);
+  const auto mappedVector = wrapInDictionary(reversedIndices, baseVector);
+  // Create arrays of array vector using above base vector.
+  // [[null, 6], [5, null], []]
+  // null
+  // [[3, 3], null, [1, 1]]
+  const auto arrayOfArrays = makeArrayVector({0, 3, 3}, mappedVector, {1});
+
+  // Create three element constant array by referencing the first element in
+  // 'arrayOfArrays'.
+  const auto constArrayOfArrays =
+      BaseVector::wrapInConstant(3, 0, arrayOfArrays);
+  // [[null, 6, 5, null]
+  // [[null, 6, 5, null]
+  // [[null, 6, 5, null]
+  const auto expected = makeNullableArrayVector<int64_t>(
+      std::vector<std::vector<std::optional<int64_t>>>{
+          {std::nullopt, 6, 5, std::nullopt},
+          {std::nullopt, 6, 5, std::nullopt},
+          {std::nullopt, 6, 5, std::nullopt}});
+  testExpression("flatten(c0)", {constArrayOfArrays}, expected);
+}
+
+TEST_F(ArrayFlattenTest, arrayOfConstantArrayWithConsecutiveIndices) {
+  const auto baseVector = makeArrayVector<int64_t>({{1, 1}});
+  const auto constVector = BaseVector::wrapInConstant(3, 0, baseVector);
+
+  // Create arrays of array vector using above constant vector.
+  // [[1, 1]]
+  // [[1, 1]]
+  // [[1, 1]]
+  const auto arrayOfArrays = makeArrayVector({0, 1, 2}, constVector);
+
+  // [1, 1]
+  // [1, 1]
+  // [1, 1]
+  const auto expected = makeArrayVector<int64_t>({{1, 1}, {1, 1}, {1, 1}});
+
+  const auto actual = testExpression("flatten(c0)", {arrayOfArrays}, expected);
+  ASSERT_FALSE(actual->as<ArrayVector>()->hasOverlappingRanges());
+}
 } // namespace
diff --git a/velox/functions/prestosql/tests/ArrayShuffleTest.cpp b/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
index 5129a69ed877..95a1f322cca1 100644
--- a/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
+++ b/velox/functions/prestosql/tests/ArrayShuffleTest.cpp
@@ -95,8 +95,9 @@ class ArrayShuffleTest : public FunctionBaseTest {
       auto expectedArray = readerExpected[i].materialize();
 
       // Assert the two vectors contain the same elements (ignoring order).
-      ASSERT_TRUE(std::is_permutation(
-          actualArray.begin(), actualArray.end(), expectedArray.begin()))
+      ASSERT_TRUE(
+          std::is_permutation(
+              actualArray.begin(), actualArray.end(), expectedArray.begin()))
           << "Actual array " << printArray(actualArray) << " at " << i
           << " must produce a permutation of expected array "
           << printArray(expectedArray);
@@ -181,8 +182,9 @@ class ArrayShuffleTest : public FunctionBaseTest {
       auto actualArray = readerActual.readNullFree(i).materialize();
       auto expectedArray = readerExpected.readNullFree(i).materialize();
 
-      ASSERT_TRUE(std::is_permutation(
-          actualArray.begin(), actualArray.end(), expectedArray.begin()))
+      ASSERT_TRUE(
+          std::is_permutation(
+              actualArray.begin(), actualArray.end(), expectedArray.begin()))
           << "Actual " << inputVector->encoding() << " array "
           << printArray(actualArray) << " at " << i
           << " must produce a permutation of expected array "
diff --git a/velox/functions/prestosql/tests/ArraySortTest.cpp b/velox/functions/prestosql/tests/ArraySortTest.cpp
index 3a5512cd5b94..9217e7c70c0b 100644
--- a/velox/functions/prestosql/tests/ArraySortTest.cpp
+++ b/velox/functions/prestosql/tests/ArraySortTest.cpp
@@ -224,7 +224,8 @@ class ArraySortTest : public FunctionBaseTest,
         break;
       default:
         VELOX_FAIL(
-            "Unsupported data type of sort_array: {}", mapTypeKindToName(kind));
+            "Unsupported data type of sort_array: {}",
+            TypeKindName::toName(kind));
     }
   }
 
@@ -367,7 +368,8 @@ void ArraySortTest::SetUp() {
         break;
       default:
         VELOX_FAIL(
-            "Unsupported data type of sort_array: {}", mapTypeKindToName(type));
+            "Unsupported data type of sort_array: {}",
+            TypeKindName::toName(type));
     }
   }
   ASSERT_LE(dataVectorsByType_.size(), kSupportedTypes.size());
@@ -610,7 +612,7 @@ TEST_F(ArraySortTest, unsupporteLambda) {
 
 TEST_F(ArraySortTest, failOnMapTypeSort) {
   static const std::string kErrorMessage =
-      "Scalar function signature is not supported"_sv;
+      "Scalar function signature is not supported";
   auto data = makeRowVector({BaseVector::createNullConstant(
       ARRAY(MAP(BIGINT(), VARCHAR())), 8, pool())});
   auto testFail = [&](const std::string& name) {
diff --git a/velox/functions/prestosql/tests/ArraySubsetTest.cpp b/velox/functions/prestosql/tests/ArraySubsetTest.cpp
new file mode 100644
index 000000000000..5fa3cf2c04b3
--- /dev/null
+++ b/velox/functions/prestosql/tests/ArraySubsetTest.cpp
@@ -0,0 +1,460 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class ArraySubsetTest : public test::FunctionBaseTest {
+ protected:
+  void testArraySubset(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(ArraySubsetTest, integerArray) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5, 6},
+      {10, 20, 30, 40},
+      {},
+      {100, 200},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 3, 5},
+      {2, 4, 6},
+      {1, 2},
+      {1, 2, 3},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 3, 5},
+      {20, 40},
+      {},
+      {100, 200},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, constantIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+      {100, 200, 300, 400, 500},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 3, 5},
+      {10, 30},
+      {100, 300, 500},
+  });
+
+  auto result = evaluate(
+      "array_subset(c0, array_constructor(cast(1 as integer), cast(3 as integer), cast(5 as integer)))",
+      makeRowVector({inputArray}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(ArraySubsetTest, outOfBoundsIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {10, 20},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 5, 2}, // Index 5 is out of bounds
+      {1, 3, 4}, // Indices 3 and 4 are out of bounds
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 2}, // Only valid indices 1 and 2
+      {10}, // Only valid index 1
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, negativeAndZeroIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {-1, 0, 1, 3}, // Negative and zero indices should be ignored
+      {0, 2, -5}, // Only index 2 is valid
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 3}, // Only indices 1 and 3 are valid
+      {20}, // Only index 2 is valid
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, duplicateIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 1, 2, 2, 3}, // Duplicate indices
+      {2, 2, 1, 1}, // Duplicate indices
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 2, 3}, // Duplicates removed, sorted order
+      {10, 20}, // Duplicates removed, sorted order (1-based: 1->10, 2->20)
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, emptyIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, emptyIndicesWithEmptyArray) {
+  // Test edge case: empty array with empty indices
+  auto inputArray = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, emptyArrayWithValidIndices) {
+  // Test edge case: empty array with valid indices (should return empty)
+  auto inputArray = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2, 3},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, emptyArray) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {1},
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, nullElementsInArray) {
+  auto inputArray = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3, 4, std::nullopt},
+      {std::nullopt, 20, std::nullopt, 40},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2, 3, 5}, // Includes indices pointing to null elements
+      {1, 2, 3, 4}, // Includes indices pointing to null elements
+  });
+
+  // Null elements should be included in output
+  auto expected = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3, std::nullopt}, // Elements at indices 1, 2, 3, 5
+      {std::nullopt, 20, std::nullopt, 40}, // Elements at indices 1, 2, 3, 4
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, nullElementsInIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+      {10, 20, 30},
+  });
+
+  auto indices = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3, std::nullopt, 5}, // Null indices should be ignored
+      {std::nullopt, 2, std::nullopt}, // Null indices should be ignored
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1, 3, 5}, // Only valid non-null indices
+      {20}, // Only valid non-null index
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, stringArray) {
+  auto inputArray = makeArrayVector<StringView>({
+      {"apple", "banana", "cherry", "date"},
+      {"hello", "world"},
+      {"a", "b", "c", "d", "e"},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {2, 4, 1},
+      {1, 2, 3},
+      {1, 3, 5},
+  });
+
+  auto expected = makeArrayVector<StringView>({
+      {"apple", "banana", "date"}, // Sorted by index: 1, 2, 4
+      {"hello", "world"}, // Indices 1, 2 (3 is out of bounds)
+      {"a", "c", "e"}, // Indices 1, 3, 5
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, floatArray) {
+  auto inputArray = makeArrayVector<float>({
+      {1.1f, 2.2f, 3.3f, 4.4f},
+      {10.5f, 20.5f, 30.5f},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 3, 4},
+      {2, 1, 3},
+  });
+
+  auto expected = makeArrayVector<float>({
+      {1.1f, 3.3f, 4.4f},
+      {10.5f, 20.5f, 30.5f},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, booleanArray) {
+  auto inputArray = makeArrayVector<bool>({
+      {true, false, true, false, true},
+      {false, true, false},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 3, 5},
+      {2, 1, 3},
+  });
+
+  auto expected = makeArrayVector<bool>({
+      {true, true, true},
+      {false, true, false},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, largeIndices) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {1, 2, 3},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1000, 2000, 1, 3000}, // Very large indices mixed with valid ones
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {1}, // Only index 1 is valid
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, singleElementArray) {
+  auto inputArray = makeArrayVector<int32_t>({
+      {42},
+      {100},
+  });
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2, 3}, // Only index 1 is valid
+      {1}, // Valid index
+  });
+
+  auto expected = makeArrayVector<int32_t>({
+      {42},
+      {100},
+  });
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, complexArray) {
+  // Test with array of arrays
+  auto innerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+      {7, 8, 9, 10},
+  });
+
+  auto inputArray = makeArrayVector({0, 2, 4}, innerArrays);
+
+  auto indices = makeArrayVector<int32_t>({
+      {1, 2},
+      {2, 1},
+  });
+
+  // Row 0: array_subset([{1,2}, {3,4,5}], [1,2]) = [{1,2}, {3,4,5}]
+  // Row 1: array_subset([{6}, {7,8,9,10}], [2,1]) = [{6}, {7,8,9,10}] (sorted
+  // by index)
+  auto expectedInnerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+      {7, 8, 9, 10},
+  });
+
+  auto expected = makeArrayVector({0, 2, 4}, expectedInnerArrays);
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, nullAtFirstIndex) {
+  // Test the specific case: array_subset(array[null,1], array[1]) = array[null]
+  std::vector<std::vector<std::optional<int32_t>>> inputData = {
+      {std::nullopt, 1}};
+  auto inputArray = makeNullableArrayVector(inputData);
+
+  auto indices = makeArrayVector<int32_t>({{1}});
+
+  std::vector<std::vector<std::optional<int32_t>>> expectedData = {
+      {std::nullopt}};
+  auto expected = makeNullableArrayVector(expectedData);
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, nullArguments) {
+  // Test when either argument is null, result should be null
+  auto inputArray = makeArrayVector<int32_t>({{1, 2, 3}});
+  auto indices = makeArrayVector<int32_t>({{1, 2}});
+
+  // Create null array and null indices with proper types
+  auto nullArray = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  auto nullIndices =
+      BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+
+  // Test null input array
+  auto result1 =
+      evaluate("array_subset(c0, c1)", makeRowVector({nullArray, indices}));
+  auto expected1 = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  assertEqualVectors(expected1, result1);
+
+  // Test null indices array
+  auto result2 = evaluate(
+      "array_subset(c0, c1)", makeRowVector({inputArray, nullIndices}));
+  auto expected2 = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  assertEqualVectors(expected2, result2);
+
+  // Test both null
+  auto result3 =
+      evaluate("array_subset(c0, c1)", makeRowVector({nullArray, nullIndices}));
+  auto expected3 = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+  assertEqualVectors(expected3, result3);
+}
+
+TEST_F(ArraySubsetTest, duplicateIndicesWithNullAndOutOfBounds) {
+  // Test the specific case: array_subset(array[null,1], array[1,1,3,1]) =
+  // array[null]
+  std::vector<std::vector<std::optional<int32_t>>> inputData = {
+      {std::nullopt, 1}};
+  auto inputArray = makeNullableArrayVector(inputData);
+
+  auto indices = makeArrayVector<int32_t>({{1, 1, 3, 1}});
+
+  std::vector<std::vector<std::optional<int32_t>>> expectedData = {
+      {std::nullopt}};
+  auto expected = makeNullableArrayVector(expectedData);
+
+  testArraySubset("array_subset(c0, c1)", {inputArray, indices}, expected);
+}
+
+TEST_F(ArraySubsetTest, basicTest) {
+  auto inputArray = makeArrayVector<int32_t>({{1, 2, 3, 4, 5}});
+  auto indices = makeArrayVector<int32_t>({{1, 3, 5}});
+  auto expected = makeArrayVector<int32_t>({{1, 3, 5}});
+
+  auto result =
+      evaluate("array_subset(c0, c1)", makeRowVector({inputArray, indices}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(ArraySubsetTest, nullTest) {
+  // Test array_subset(array[null,1], array[1]) = array[null]
+  std::vector<std::vector<std::optional<int32_t>>> inputData = {
+      {std::nullopt, 1}};
+  auto inputArray = makeNullableArrayVector(inputData);
+  auto indices = makeArrayVector<int32_t>({{1}});
+  std::vector<std::vector<std::optional<int32_t>>> expectedData = {
+      {std::nullopt}};
+  auto expected = makeNullableArrayVector(expectedData);
+
+  auto result =
+      evaluate("array_subset(c0, c1)", makeRowVector({inputArray, indices}));
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/BigintEnumCastTest.cpp b/velox/functions/prestosql/tests/BigintEnumCastTest.cpp
new file mode 100644
index 000000000000..2f71bfe1729f
--- /dev/null
+++ b/velox/functions/prestosql/tests/BigintEnumCastTest.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/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/BigintEnumRegistration.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
+
+using namespace facebook::velox::test;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox {
+namespace {
+
+class BigintEnumCastTest : public functions::test::CastBaseTest {
+ protected:
+  BigintEnumCastTest() {
+    registerBigintEnumType();
+    LongEnumParameter moodInfo(
+        "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
+    moodEnum_ = BIGINT_ENUM(moodInfo);
+  }
+
+  BigintEnumTypePtr moodEnum_;
+};
+
+TEST_F(BigintEnumCastTest, castTo) {
+  // Cast different integer types to enum type.
+  testCast<int64_t, int64_t>(
+      BIGINT(), moodEnum_, {0, -2, std::nullopt}, {0, -2, std::nullopt});
+
+  testCast<int8_t, int64_t>(
+      TINYINT(), moodEnum_, {0, -2, std::nullopt}, {0, -2, std::nullopt});
+
+  testCast<int16_t, int64_t>(
+      SMALLINT(), moodEnum_, {0, -2, std::nullopt}, {0, -2, std::nullopt});
+
+  testCast<int32_t, int64_t>(
+      INTEGER(), moodEnum_, {0, -2, std::nullopt}, {0, -2, std::nullopt});
+
+  // Cast enum type to same enum type.
+  testCast<int64_t, int64_t>(
+      moodEnum_, moodEnum_, {0, -2, std::nullopt}, {0, -2, std::nullopt});
+}
+
+TEST_F(BigintEnumCastTest, invalidCastTo) {
+  // Cast is only permitted from integer types to enum type.
+  VELOX_ASSERT_THROW(
+      evaluateCast(
+          VARCHAR(),
+          moodEnum_,
+          makeRowVector({makeNullableFlatVector<StringView>(
+              {"a"_sv, "b"_sv, std::nullopt})})),
+      "Cannot cast VARCHAR to test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}).");
+
+  VELOX_ASSERT_THROW(
+      evaluateCast(
+          BOOLEAN(),
+          moodEnum_,
+          makeRowVector(
+              {makeNullableFlatVector<bool>({true, false, std::nullopt})})),
+      "Cannot cast BOOLEAN to test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}).");
+
+  // Cast base type to enum type where the value does not exist in the enum.
+  VELOX_ASSERT_THROW(
+      evaluateCast(
+          BIGINT(),
+          moodEnum_,
+          makeRowVector({makeNullableFlatVector<int64_t>(
+              {0, 1, std::nullopt}, BIGINT())})),
+      "No value '1' in test.enum.mood");
+
+  // Cast enum type to different enum type.
+  std::unordered_map<std::string, int64_t> differentMap = {
+      {"CURIOUS", -2}, {"HAPPY", 3}};
+  LongEnumParameter differentEnumInfo("someEnumType", differentMap);
+  VELOX_ASSERT_THROW(
+      evaluateCast(
+          moodEnum_,
+          BIGINT_ENUM(differentEnumInfo),
+          makeRowVector({makeNullableFlatVector<int64_t>(
+              {0, 1, std::nullopt}, moodEnum_)})),
+      "Cannot cast test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}) to someEnumType:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 3}).");
+
+  // Cast enum type to different enum type with same name.
+  LongEnumParameter sameNameDifferentMap("test.enum.mood", differentMap);
+  VELOX_ASSERT_THROW(
+      evaluateCast(
+          moodEnum_,
+          BIGINT_ENUM(sameNameDifferentMap),
+          makeRowVector({makeNullableFlatVector<int64_t>(
+              {0, 1, std::nullopt}, moodEnum_)})),
+      "Cannot cast test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}) to test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 3})");
+}
+
+TEST_F(BigintEnumCastTest, fromBigintEnum) {
+  // Cast enum type to base type.
+  testCast<int64_t, int64_t>(
+      moodEnum_, BIGINT(), {0, -2, std::nullopt}, {0, -2, std::nullopt});
+
+  // Casting enum type to all other types including other integer types is not
+  // permitted.
+  auto enumInput = makeRowVector(
+      {makeNullableFlatVector<int64_t>({0, 1, std::nullopt}, moodEnum_)});
+  VELOX_ASSERT_THROW(
+      evaluateCast(moodEnum_, TINYINT(), enumInput),
+      "Cannot cast test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}) to TINYINT.");
+
+  VELOX_ASSERT_THROW(
+      evaluateCast(moodEnum_, SMALLINT(), enumInput),
+      "Cannot cast test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}) to SMALLINT.");
+
+  VELOX_ASSERT_THROW(
+      evaluateCast(moodEnum_, INTEGER(), enumInput),
+      "Cannot cast test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}) to INTEGER.");
+
+  VELOX_ASSERT_THROW(
+      evaluateCast(moodEnum_, VARCHAR(), enumInput),
+      "Cannot cast test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}) to VARCHAR.");
+
+  VELOX_ASSERT_THROW(
+      evaluateCast(
+          moodEnum_,
+          BOOLEAN(),
+          makeRowVector({makeNullableFlatVector<int64_t>(
+              {0, 1, std::nullopt}, moodEnum_)})),
+      "Cannot cast test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}) to BOOLEAN.");
+}
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp b/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
index 9e725f882a23..0b35996d6e56 100644
--- a/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/BinaryFunctionsTest.cpp
@@ -315,6 +315,20 @@ TEST_F(BinaryFunctionsTest, xxhash64) {
       hexToDec("D73C92CF24E6EC82"), xxhash64("more_than_12_characters_string"));
 }
 
+TEST_F(BinaryFunctionsTest, xxhash64WithSeed) {
+  const auto xxhash64WithSeed = [&](std::optional<std::string> value,
+                                    std::optional<int64_t> seed) {
+    return evaluateOnce<std::string>(
+        "xxhash64(c0, c1)", {VARBINARY(), BIGINT()}, value, seed);
+  };
+
+  EXPECT_EQ(hexToDec("F9D96E0E1165E892"), xxhash64WithSeed("hashme", 0));
+  EXPECT_NE(hexToDec("F9D96EAE1165E892"), xxhash64WithSeed("hashme", 0));
+  EXPECT_NE(hexToDec("F9D96E0E1165E892"), xxhash64WithSeed("hashme", 1));
+  EXPECT_EQ(hexToDec("26C7827D889F6DA3"), xxhash64WithSeed("hello", 0));
+  EXPECT_NE(hexToDec("26C7827D889F6DA3"), xxhash64WithSeed("hello", 1224));
+}
+
 TEST_F(BinaryFunctionsTest, toHex) {
   const auto toHex = [&](std::optional<std::string> value) {
     return evaluateOnce<std::string>("to_hex(cast(c0 as varbinary))", value);
@@ -368,6 +382,23 @@ TEST_F(BinaryFunctionsTest, fromHex) {
   EXPECT_EQ(
       "12PasXXaWBQ0k1T88jiF",
       fromHexToBase64("D763DAB175DA5814349354FCF23885"));
+
+  // Test from_hex with VARBINARY input
+  const auto fromHexVarbinary = [&](std::optional<std::string> value) {
+    return evaluateOnce<std::string>(
+        "from_hex(cast(c0 as varbinary))", std::move(value));
+  };
+
+  EXPECT_EQ(std::nullopt, fromHexVarbinary(std::nullopt));
+  EXPECT_EQ("", fromHexVarbinary(""));
+  EXPECT_EQ("a", fromHexVarbinary("61"));
+  EXPECT_EQ("abc", fromHexVarbinary("616263"));
+  EXPECT_EQ("hello world", fromHexVarbinary("68656C6C6F20776F726C64"));
+  EXPECT_EQ(
+      "Hello World from Velox!",
+      fromHexVarbinary("48656C6C6F20576F726C642066726F6D2056656C6F7821"));
+
+  EXPECT_THROW(fromHexVarbinary("fff"), VeloxUserError);
 }
 
 TEST_F(BinaryFunctionsTest, toBase64) {
@@ -480,6 +511,25 @@ TEST_F(BinaryFunctionsTest, fromBase64Url) {
   EXPECT_THROW(fromBase64Url("YQ==="), VeloxUserError);
   EXPECT_THROW(fromBase64Url("YQ=+"), VeloxUserError);
   EXPECT_THROW(fromBase64Url("YQ=/"), VeloxUserError);
+
+  // Test from_base64url with VARBINARY input
+  const auto fromBase64UrlVarbinary = [&](std::optional<std::string> value) {
+    return evaluateOnce<std::string>(
+        "from_base64url(cast(c0 as varbinary))", std::move(value));
+  };
+
+  EXPECT_EQ(std::nullopt, fromBase64UrlVarbinary(std::nullopt));
+  EXPECT_EQ("", fromBase64UrlVarbinary(""));
+  EXPECT_EQ("a", fromBase64UrlVarbinary("YQ=="));
+  EXPECT_EQ("a", fromBase64UrlVarbinary("YQ"));
+  EXPECT_EQ("abc", fromBase64UrlVarbinary("YWJj"));
+  EXPECT_EQ("hello world", fromBase64UrlVarbinary("aGVsbG8gd29ybGQ="));
+  EXPECT_EQ(
+      "Hello World from Velox!",
+      fromBase64UrlVarbinary("SGVsbG8gV29ybGQgZnJvbSBWZWxveCE="));
+
+  EXPECT_EQ(fromHex("FF4FBF50"), fromBase64UrlVarbinary("_0-_UA=="));
+  EXPECT_THROW(fromBase64UrlVarbinary("YQ="), VeloxUserError);
 }
 
 TEST_F(BinaryFunctionsTest, fromBigEndian32) {
@@ -766,10 +816,11 @@ TEST_F(BinaryFunctionsTest, fromIEEE754Bits32) {
       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::numeric_limits<float>::signaling_NaN()))
+              .value()));
   EXPECT_TRUE(
       std::isnan(fromIEEE754Bits32(toIEEE754Bits32(std::nan("nan"))).value()));
   VELOX_ASSERT_THROW(
@@ -852,4 +903,67 @@ TEST_F(BinaryFunctionsTest, murmur3_x64_128) {
   EXPECT_EQ(murmur3_x64_128(std::nullopt), std::nullopt);
 }
 
+TEST_F(BinaryFunctionsTest, fromBase32) {
+  const auto fromBase32 = [&](const std::optional<std::string>& value) {
+    // from_base32 allows VARCHAR and VARBINARY inputs.
+    auto result =
+        evaluateOnce<std::string>("from_base32(c0)", VARCHAR(), value);
+    auto otherResult =
+        evaluateOnce<std::string>("from_base32(c0)", VARBINARY(), value);
+
+    VELOX_CHECK_EQ(result.has_value(), otherResult.has_value());
+
+    if (!result.has_value()) {
+      return result;
+    }
+
+    EXPECT_EQ(result.value(), otherResult.value());
+    return result;
+  };
+
+  // Basic decoding tests
+  EXPECT_EQ("", fromBase32(""));
+  EXPECT_EQ("a", fromBase32("ME======"));
+  EXPECT_EQ("abc", fromBase32("MFRGG==="));
+  EXPECT_EQ("hello world", fromBase32("NBSWY3DPEB3W64TMMQ======"));
+
+  // Null handling
+  EXPECT_EQ(std::nullopt, fromBase32(std::nullopt));
+
+  // Test padding is optional (RFC 4648)
+  EXPECT_EQ("a", fromBase32("ME"));
+  EXPECT_EQ("abc", fromBase32("MFRGG"));
+
+  // Invalid input tests
+  VELOX_ASSERT_USER_THROW(fromBase32("1="), "Unrecognized character: 1");
+  VELOX_ASSERT_USER_THROW(fromBase32("M1======"), "Unrecognized character: 1");
+  VELOX_ASSERT_USER_THROW(fromBase32("M!======"), "Unrecognized character: !");
+
+  // Test lowercase is rejected
+  VELOX_ASSERT_USER_THROW(fromBase32("me======"), "Unrecognized character: m");
+  VELOX_ASSERT_USER_THROW(fromBase32("MFRGG===a"), "Unrecognized character: a");
+
+  // Test invalid Base32 characters 0, 1, 8, 9
+  VELOX_ASSERT_USER_THROW(fromBase32("M0======"), "Unrecognized character: 0");
+  VELOX_ASSERT_USER_THROW(fromBase32("M8======"), "Unrecognized character: 8");
+  VELOX_ASSERT_USER_THROW(fromBase32("M9======"), "Unrecognized character: 9");
+
+  // Test invalid input lengths (matching Google Guava's Base32 behavior)
+  // Invalid lengths mod 8 are: 1, 3, 6
+  // Single character (1 mod 8)
+  VELOX_ASSERT_USER_THROW(fromBase32("A"), "Invalid input length 1");
+  VELOX_ASSERT_USER_THROW(fromBase32("M======="), "Invalid input length 1");
+  // Three characters (3 mod 8)
+  VELOX_ASSERT_USER_THROW(fromBase32("XEV"), "Invalid input length 3");
+  VELOX_ASSERT_USER_THROW(fromBase32("ABC"), "Invalid input length 3");
+  // Six characters (6 mod 8)
+  VELOX_ASSERT_USER_THROW(fromBase32("ABCDEF"), "Invalid input length 6");
+  VELOX_ASSERT_USER_THROW(fromBase32("MFRGGM"), "Invalid input length 6");
+  // 11 characters (3 mod 8)
+  VELOX_ASSERT_USER_THROW(fromBase32("NBSWY3DPEB3"), "Invalid input length 11");
+  // 14 characters (6 mod 8)
+  VELOX_ASSERT_USER_THROW(
+      fromBase32("NBSWY3DPEB3W64"), "Invalid input length 14");
+}
+
 } // namespace
diff --git a/velox/functions/prestosql/tests/BingTileFunctionsTest.cpp b/velox/functions/prestosql/tests/BingTileFunctionsTest.cpp
index 4f2aa064940f..b6e3673e897b 100644
--- a/velox/functions/prestosql/tests/BingTileFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/BingTileFunctionsTest.cpp
@@ -90,7 +90,8 @@ class BingTileFunctionsTest : public functions::test::FunctionBaseTest {
     uint64_t tileInt = BingTileType::bingTileCoordsToInt(x, y, tileZoom);
     // Making children is tested in BingTileTypeTest; this test is for whether
     // we call it correctly.
-    auto childrenRes = BingTileType::bingTileChildren(tileInt, childZoom);
+    auto childrenRes = BingTileType::bingTileChildren(
+        tileInt, childZoom, childZoom - tileZoom);
     if (childrenRes.hasError()) {
       return folly::makeUnexpected(childrenRes.error());
     }
@@ -106,7 +107,7 @@ class BingTileFunctionsTest : public functions::test::FunctionBaseTest {
 TEST_F(BingTileFunctionsTest, toBingTileCoordinates) {
   const auto testToBingTile = [&](std::optional<int32_t> x,
                                   std::optional<int32_t> y,
-                                  std::optional<int8_t> zoom) {
+                                  std::optional<int32_t> zoom) {
     std::optional<int64_t> tile = evaluateOnce<int64_t>(
         "CAST(bing_tile(c0, c1, c2) AS BIGINT)", x, y, zoom);
     if (x.has_value() && y.has_value() && zoom.has_value()) {
@@ -135,13 +136,16 @@ TEST_F(BingTileFunctionsTest, toBingTileCoordinates) {
       "Bing tile X coordinate 256 is greater than max coordinate 255 at zoom 8");
   VELOX_ASSERT_USER_THROW(
       testToBingTile(0, 0, 24),
-      "Bing tile zoom 24 is greater than max zoom 23");
+      "Bing tile zoom 24 cannot be greater than max zoom 23");
   VELOX_ASSERT_USER_THROW(
       testToBingTile(-1, 1, 2), "Bing tile X coordinate -1 cannot be negative");
   VELOX_ASSERT_USER_THROW(
       testToBingTile(1, -1, 2), "Bing tile Y coordinate -1 cannot be negative");
   VELOX_ASSERT_USER_THROW(
       testToBingTile(1, 1, -1), "Bing tile zoom -1 cannot be negative");
+  VELOX_ASSERT_USER_THROW(
+      testToBingTile(1, 1, 1000),
+      "Bing tile zoom 1000 cannot be greater than max zoom 23");
 }
 
 TEST_F(BingTileFunctionsTest, quadKeyToBingTile) {
@@ -315,19 +319,31 @@ TEST_F(BingTileFunctionsTest, bingTileParentZoom) {
         y,
         zoom,
         parentZoom);
-    if (x.has_value() && y.has_value() && zoom.has_value() &&
-        parentZoom.has_value()) {
-      ASSERT_TRUE(tile.has_value());
-      int32_t shift = *zoom - *parentZoom;
-      ASSERT_EQ(
-          BingTileType::bingTileCoordsToInt(
-              static_cast<uint32_t>(*x) >> shift,
-              static_cast<uint32_t>(*y) >> shift,
-              *parentZoom),
-          *tile);
-    } else {
-      ASSERT_FALSE(tile.has_value());
-    }
+    auto validate = [&]() {
+      if (x.has_value() && y.has_value() && zoom.has_value() &&
+          parentZoom.has_value()) {
+        ASSERT_TRUE(tile.has_value());
+        int32_t shift = *zoom - *parentZoom;
+        ASSERT_EQ(
+            BingTileType::bingTileCoordsToInt(
+                static_cast<uint32_t>(*x) >> shift,
+                static_cast<uint32_t>(*y) >> shift,
+                *parentZoom),
+            *tile);
+      } else {
+        ASSERT_FALSE(tile.has_value());
+      }
+    };
+
+    validate();
+
+    tile = evaluateOnce<int64_t>(
+        "CAST(bing_tile_parent(bing_tile(c0, c1, c2), cast(c3 as integer)) AS BIGINT)",
+        x,
+        y,
+        zoom,
+        parentZoom);
+    validate();
   };
 
   testBingTileParent(0, 0, 0, 0);
@@ -350,12 +366,20 @@ TEST_F(BingTileFunctionsTest, bingTileParentZoom) {
       testBingTileParent(0, 0, 0, 1), "Parent zoom 1 must be <= tile zoom 0");
   VELOX_ASSERT_USER_THROW(
       testBingTileParent(5, 17, 5, 8), "Parent zoom 8 must be <= tile zoom 5");
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<int64_t>(
+          "CAST(bing_tile_parent(bing_tile(c0, c1, c2), c3) AS BIGINT)",
+          std::optional<int32_t>(0),
+          std::optional<int32_t>(0),
+          std::optional<int8_t>(0),
+          std::optional<int32_t>(99)),
+      "newZoom 99 is greater than max zoom 23");
 }
 
 TEST_F(BingTileFunctionsTest, bingTileChildren) {
   const auto testBingTileChildren = [&](std::optional<int32_t> x,
                                         std::optional<int32_t> y,
-                                        std::optional<int8_t> zoom) {
+                                        std::optional<int32_t> zoom) {
     RowVectorPtr input = makeSingleXYZoomRow(x, y, zoom);
 
     VectorPtr output = evaluate(
@@ -431,15 +455,32 @@ TEST_F(BingTileFunctionsTest, bingTileChildrenZoom) {
 
   VELOX_ASSERT_USER_THROW(
       testBingTileChildren(0, 0, 1, -1),
-      "Cannot call bing_tile_children with negative zoom");
+      "Bing tile zoom -1 cannot be negative");
   VELOX_ASSERT_USER_THROW(
       testBingTileChildren(0, 0, 2, 1), "Child zoom 1 must be >= tile zoom 2");
+  VELOX_ASSERT_USER_THROW(
+      testBingTileChildren(0, 0, 1, 9),
+      "Difference between parent zoom (1) and child zoom (9) must be <= 7");
+
+  {
+    RowVectorPtr input = makeSingleXYZoomZoomRow(0, 0, 1, 7);
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kDebugBingTileChildrenMaxZoomShift, "10"}});
+    evaluate("bing_tile_children(bing_tile(c0, c1, c2), c3)", input);
+
+    input = makeSingleXYZoomZoomRow(0, 0, 1, 15);
+    VELOX_ASSERT_USER_THROW(
+        evaluate("bing_tile_children(bing_tile(c0, c1, c2), c3)", input),
+        "Difference between parent zoom (1) and child zoom (15) must be <= 10");
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kDebugBingTileChildrenMaxZoomShift, "6"}});
+  }
 }
 
 TEST_F(BingTileFunctionsTest, bingTileAt) {
   const auto testBingTileAtFunc = [&](std::optional<double> latitude,
                                       std::optional<double> longitude,
-                                      std::optional<int8_t> zoom,
+                                      std::optional<int32_t> zoom,
                                       std::optional<int64_t> expectedTile =
                                           std::nullopt) {
     std::optional<int64_t> tile = evaluateOnce<int64_t>(
@@ -474,7 +515,7 @@ TEST_F(BingTileFunctionsTest, bingTileAt) {
       "Longitude -181 is outside of valid range [-180, 180]");
   VELOX_ASSERT_USER_THROW(
       testBingTileAtFunc(-85, -180, 24, 335544351),
-      "Zoom level 24 is greater than max zoom 23");
+      "Bing tile zoom 24 cannot be greater than max zoom 23");
   VELOX_ASSERT_USER_THROW(
       testBingTileAtFunc(-85, -180, -1, 335544351),
       "Bing tile zoom -1 cannot be negative");
@@ -483,7 +524,7 @@ TEST_F(BingTileFunctionsTest, bingTileAt) {
 TEST_F(BingTileFunctionsTest, bingTilesAround) {
   const auto testBingTilesAroundFunc = [&](std::optional<double> latitude,
                                            std::optional<double> longitude,
-                                           std::optional<int8_t> zoom,
+                                           std::optional<int32_t> zoom,
                                            std::optional<std::vector<int64_t>>
                                                expectedTiles) {
     auto input = makeSingleLatLongZoomRow(latitude, longitude, zoom);
@@ -547,7 +588,7 @@ TEST_F(BingTileFunctionsTest, bingTilesAround) {
       "Longitude -181 is outside of valid range [-180, 180]");
   VELOX_ASSERT_USER_THROW(
       testBingTilesAroundFunc(-85, -180, 24, std::nullopt),
-      "Zoom level 24 is greater than max zoom 23");
+      "Bing tile zoom 24 cannot be greater than max zoom 23");
   VELOX_ASSERT_USER_THROW(
       testBingTilesAroundFunc(-85, -180, -1, std::nullopt),
       "Bing tile zoom -1 cannot be negative");
@@ -618,7 +659,7 @@ TEST_F(BingTileFunctionsTest, bingTilesAroundWithRadius) {
       "Longitude -181 is outside of valid range [-180, 180]");
   VELOX_ASSERT_USER_THROW(
       testBingTilesAroundWithRadiusFunc(-85, -180, 24, 500, std::nullopt),
-      "Zoom level 24 is greater than max zoom 23");
+      "Bing tile zoom 24 cannot be greater than max zoom 23");
   VELOX_ASSERT_USER_THROW(
       testBingTilesAroundWithRadiusFunc(-85, -180, -1, 500, std::nullopt),
       "Bing tile zoom -1 cannot be negative");
@@ -629,3 +670,18 @@ TEST_F(BingTileFunctionsTest, bingTilesAroundWithRadius) {
       testBingTilesAroundWithRadiusFunc(-85, -180, 1, 1001, std::nullopt),
       "Radius in km must between 0 and 1000, got 1001");
 }
+
+TEST_F(BingTileFunctionsTest, bingTileOrdering) {
+  auto bingTileType = BINGTILE();
+  ASSERT_FALSE(bingTileType->isOrderable());
+  ASSERT_TRUE(bingTileType->isComparable());
+
+  // Test that ARRAY_SORT fails with BingTile arrays since they're not orderable
+  VELOX_ASSERT_THROW(
+      evaluateOnce<int64_t>(
+          "CAST(ARRAY_SORT(ARRAY[bing_tile(c0, c1, c2), bing_tile(c0, c1, c2)])[1] AS BIGINT)",
+          std::optional<int32_t>(1),
+          std::optional<int32_t>(1),
+          std::optional<int32_t>(5)),
+      "Scalar function signature is not supported: array_sort(ARRAY<BINGTILE>).");
+}
diff --git a/velox/functions/prestosql/tests/CMakeLists.txt b/velox/functions/prestosql/tests/CMakeLists.txt
index fb8a2329ec8e..4641d3a34bbc 100644
--- a/velox/functions/prestosql/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/tests/CMakeLists.txt
@@ -44,6 +44,7 @@ add_executable(
   ArrayRemoveTest.cpp
   ArrayShuffleTest.cpp
   ArraySortTest.cpp
+  ArraySubsetTest.cpp
   ArrayTopNTest.cpp
   ArraysOverlapTest.cpp
   ArraySumTest.cpp
@@ -52,21 +53,27 @@ add_executable(
   ArgTypesGeneratorTest.cpp
   BinaryFunctionsTest.cpp
   BingTileCastTest.cpp
+  BingTileFunctionsTest.cpp
   BitwiseTest.cpp
   CardinalityTest.cpp
   CeilFloorTest.cpp
   ComparisonsTest.cpp
   DateTimeFunctionsTest.cpp
   DecimalArithmeticTest.cpp
+  DistanceFunctionsTest.cpp
   ElementAtTest.cpp
+  EnumFunctionsTest.cpp
   FailTest.cpp
   FindFirstTest.cpp
   FloatingPointFunctionsTest.cpp
   FromUtf8Test.cpp
-  GeometryFunctionsTest.cpp
   GreatestLeastTest.cpp
   HyperLogLogCastTest.cpp
   HyperLogLogFunctionsTest.cpp
+  KHyperLogLogCastTest.cpp
+  KHyperLogLogFunctionsTest.cpp
+  P4HyperLogLogCastTest.cpp
+  SetDigestCastTest.cpp
   InPredicateTest.cpp
   IntegerFunctionsTest.cpp
   IPAddressCastTest.cpp
@@ -77,25 +84,33 @@ add_executable(
   MapEntriesTest.cpp
   MapFilterTest.cpp
   MapFromEntriesTest.cpp
+  MapIntersectTest.cpp
+  MapKeysOverlapTest.cpp
   MapNormalizeTest.cpp
+  RemapKeysTest.cpp
   MapTopNTest.cpp
   MapTopNKeysTest.cpp
   MapTopNValuesTest.cpp
   MapKeysAndValuesTest.cpp
   MapKeysByTopNValuesTest.cpp
   MapMatchTest.cpp
+  MapAppendTest.cpp
   MapTest.cpp
   MapZipWithTest.cpp
+  MapExceptTest.cpp
   MultimapFromEntriesTest.cpp
   NotTest.cpp
+  ParsePrestoDataSizeTest.cpp
   ProbabilityTest.cpp
   RandTest.cpp
   ReduceTest.cpp
+  RegexpSplitTest.cpp
   RegexpReplaceTest.cpp
   ReverseTest.cpp
   RoundTest.cpp
   ScalarFunctionRegTest.cpp
   SequenceTest.cpp
+  SfmSketchFunctionsTest.cpp
   SimpleComparisonMatcherTest.cpp
   SliceTest.cpp
   SplitTest.cpp
@@ -103,6 +118,7 @@ add_executable(
   SplitToMultiMapTest.cpp
   StringFunctionsTest.cpp
   TimestampWithTimeZoneCastTest.cpp
+  TimeWithTimezoneCastTest.cpp
   TransformKeysTest.cpp
   TransformTest.cpp
   TransformValuesTest.cpp
@@ -110,12 +126,25 @@ add_executable(
   TypeOfTest.cpp
   TDigestCastTest.cpp
   QDigestCastTest.cpp
+  QDigestFunctionsTest.cpp
   URLFunctionsTest.cpp
   UuidFunctionsTest.cpp
   WidthBucketArrayTest.cpp
   WordStemTest.cpp
   ZipTest.cpp
-  ZipWithTest.cpp)
+  ZipWithTest.cpp
+)
+
+if(VELOX_ENABLE_GEO)
+  target_sources(velox_functions_test PRIVATE GeometryFunctionsTest.cpp)
+endif()
+
+if(VELOX_ENABLE_FAISS)
+  set_source_files_properties(
+    DistanceFunctionsTest.cpp
+    PROPERTIES COMPILE_DEFINITIONS VELOX_ENABLE_FAISS
+  )
+endif()
 
 add_test(velox_functions_test velox_functions_test)
 
@@ -134,4 +163,5 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
   GTest::gmock
-  GTest::gmock_main)
+  GTest::gmock_main
+)
diff --git a/velox/functions/prestosql/tests/CastBaseTest.h b/velox/functions/prestosql/tests/CastBaseTest.h
index 7359f50ad747..8bbdf715533c 100644
--- a/velox/functions/prestosql/tests/CastBaseTest.h
+++ b/velox/functions/prestosql/tests/CastBaseTest.h
@@ -209,8 +209,9 @@ class CastBaseTest : public FunctionBaseTest {
       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()));
+    SCOPED_TRACE(
+        fmt::format(
+            "Cast from {} to {}", fromType->toString(), toType->toString()));
     const auto copy = createCopy(input);
     // Test with flat encoding.
     {
@@ -312,9 +313,9 @@ class CastBaseTest : public FunctionBaseTest {
   std::shared_ptr<core::CastTypedExpr> makeCastExpr(
       const core::TypedExprPtr& input,
       const TypePtr& toType,
-      bool nullOnFailure) {
+      bool isTryCast) {
     std::vector<core::TypedExprPtr> inputs = {input};
-    return std::make_shared<core::CastTypedExpr>(toType, inputs, nullOnFailure);
+    return std::make_shared<core::CastTypedExpr>(toType, inputs, isTryCast);
   }
 
   const float kInf = std::numeric_limits<float>::infinity();
diff --git a/velox/functions/prestosql/tests/ComparisonsTest.cpp b/velox/functions/prestosql/tests/ComparisonsTest.cpp
index b3655e2f9f31..370f9feb9bb5 100644
--- a/velox/functions/prestosql/tests/ComparisonsTest.cpp
+++ b/velox/functions/prestosql/tests/ComparisonsTest.cpp
@@ -1450,7 +1450,7 @@ TEST_F(ComparisonsTest, IPPrefixType) {
 }
 
 TEST_F(ComparisonsTest, IpAddressType) {
-  auto makeIpAdressFromString = [](const std::string& ipAddr) -> int128_t {
+  auto makeIpAdressFromString = [](std::string_view ipAddr) -> int128_t {
     auto ret = ipaddress::tryGetIPv6asInt128FromString(ipAddr);
     return ret.value();
   };
diff --git a/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp b/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
index c160fc1e2b2c..c0647a050a7c 100644
--- a/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/DateTimeFunctionsTest.cpp
@@ -20,6 +20,7 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/external/tzdb/zoned_time.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
@@ -84,6 +85,13 @@ class DateTimeFunctionsTest : public functions::test::FunctionBaseTest {
     });
   }
 
+  void setQuerySessionStartTime(int64_t sessionStartTime) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionStartTime,
+         std::to_string(sessionStartTime)},
+    });
+  }
+
  public:
   // Helper class to manipulate timestamp with timezone types in tests. Provided
   // only for convenience.
@@ -147,12 +155,13 @@ class DateTimeFunctionsTest : public functions::test::FunctionBaseTest {
   }
 
   int32_t getCurrentDate(const std::optional<std::string>& timeZone) {
-    return parseDate(date::format(
-        "%Y-%m-%d",
-        timeZone.has_value()
-            ? tzdb::zoned_time(
-                  timeZone.value(), std::chrono::system_clock::now())
-            : tzdb::zoned_time(std::chrono::system_clock::now())));
+    return parseDate(
+        date::format(
+            "%Y-%m-%d",
+            timeZone.has_value()
+                ? tzdb::zoned_time(
+                      timeZone.value(), std::chrono::system_clock::now())
+                : tzdb::zoned_time(std::chrono::system_clock::now())));
   }
 };
 
@@ -165,7 +174,7 @@ bool operator==(
 
 TEST_F(DateTimeFunctionsTest, dateTruncSignatures) {
   auto signatures = getSignatureStrings("date_trunc");
-  ASSERT_EQ(3, signatures.size());
+  ASSERT_EQ(4, signatures.size());
 
   ASSERT_EQ(
       1,
@@ -173,6 +182,7 @@ TEST_F(DateTimeFunctionsTest, dateTruncSignatures) {
           "(varchar,timestamp with time zone) -> timestamp with time zone"));
   ASSERT_EQ(1, signatures.count("(varchar,date) -> date"));
   ASSERT_EQ(1, signatures.count("(varchar,timestamp) -> timestamp"));
+  ASSERT_EQ(1, signatures.count("(varchar,time) -> time"));
 }
 
 TEST_F(DateTimeFunctionsTest, parseDatetimeSignatures) {
@@ -269,8 +279,9 @@ TEST_F(DateTimeFunctionsTest, fromUnixtimeRountTrip) {
 TEST_F(DateTimeFunctionsTest, fromUnixtimeWithTimeZone) {
   const auto fromUnixtime = [&](std::optional<double> timestamp,
                                 std::optional<std::string> timezoneName) {
-    return TimestampWithTimezone::unpack(evaluateOnce<int64_t>(
-        "from_unixtime(c0, c1)", timestamp, timezoneName));
+    return TimestampWithTimezone::unpack(
+        evaluateOnce<int64_t>(
+            "from_unixtime(c0, c1)", timestamp, timezoneName));
   };
 
   // Check null behavior.
@@ -745,6 +756,42 @@ TEST_F(DateTimeFunctionsTest, hourDate) {
   EXPECT_EQ(0, hour(-18262));
 }
 
+TEST_F(DateTimeFunctionsTest, hourTime) {
+  const auto hour = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>("hour(c0)", TIME(), time);
+  };
+
+  // null handling
+  EXPECT_EQ(std::nullopt, hour(std::nullopt));
+
+  // boundary tests - core optimization: simple integer division by
+  // kMillisInHour (3600000) lower boundary: 0 <= time < 86400000
+  EXPECT_EQ(0, hour(0)); // exactly midnight
+  EXPECT_EQ(0, hour(3599999)); // 00:59:59.999 - last millisecond of hour 0
+  EXPECT_EQ(1, hour(3600000)); // 01:00:00.000 - first millisecond of hour 1
+  EXPECT_EQ(23, hour(82800000)); // 23:00:00.000 - first millisecond of hour 23
+  EXPECT_EQ(23, hour(86399999)); // 23:59:59.999 - upper boundary exclusive
+
+  // representative samples across all hours
+  EXPECT_EQ(12, hour(43200000)); // noon exactly
+  EXPECT_EQ(18, hour(64800000)); // 18:00:00.000
+
+  // verify optimization correctness: hour = time / kMillisInHour
+  // random test cases to ensure division behaves correctly
+  EXPECT_EQ(5, hour(19800000)); // 05:30:00.000
+  EXPECT_EQ(10, hour(37800000)); // 10:30:00.000
+  EXPECT_EQ(15, hour(54000000)); // 15:00:00.000
+
+  // error conditions - invalid range validation
+  EXPECT_THROW(hour(-1), VeloxUserError); // negative time
+  EXPECT_THROW(
+      hour(86400000),
+      VeloxUserError); // exactly 24:00:00.000 (exclusive upper bound)
+  EXPECT_THROW(
+      hour(std::numeric_limits<int64_t>::max()),
+      VeloxUserError); // overflow case
+}
+
 TEST_F(DateTimeFunctionsTest, dayOfMonth) {
   const auto day = [&](std::optional<Timestamp> date) {
     return evaluateOnce<int64_t>("day_of_month(c0)", date);
@@ -1110,6 +1157,337 @@ TEST_F(DateTimeFunctionsTest, minusTimestamp) {
       "Could not convert Timestamp(-9223372036854776, 0) to milliseconds");
 }
 
+TEST_F(DateTimeFunctionsTest, timeIntervalDayTime) {
+  // Test TIME + IntervalDayTime and IntervalDayTime + TIME arithmetic
+
+  // Helper for Time + IntervalDayTime (also tests commutativity)
+  const auto testTimePlusIntervalCommutative =
+      [&](int64_t time, int64_t interval) -> std::optional<int64_t> {
+    auto result1 = evaluateOnce<int64_t>(
+        "plus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({time}, TIME()),
+            makeNullableFlatVector<int64_t>({interval}, INTERVAL_DAY_TIME()),
+        }));
+
+    auto result2 = evaluateOnce<int64_t>(
+        "plus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({interval}, INTERVAL_DAY_TIME()),
+            makeNullableFlatVector<int64_t>({time}, TIME()),
+        }));
+
+    EXPECT_EQ(result1, result2);
+    return result1;
+  };
+
+  // Basic hour addition: 03:04:05.321 + 3 hours = 06:04:05.321
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  // 3 hours = 3*60*60*1000 = 10800000 ms
+  // 06:04:05.321 = (6*3600 + 4*60 + 5)*1000 + 321 = 21845321 ms
+  const int64_t time1 = 11045321; // 03:04:05.321
+  const int64_t threeHours = 3 * kMillisInHour; // 3 hours
+  EXPECT_EQ(21845321, testTimePlusIntervalCommutative(time1, threeHours));
+
+  // Test 24-hour wraparound: 22:00:00 + 3 hours = 01:00:00
+  // 22:00:00 = 22*3600*1000 = 79200000 ms
+  // 01:00:00 = 1*3600*1000 = 3600000 ms
+  const int64_t time2 = 22 * kMillisInHour; // 22:00:00
+  EXPECT_EQ(3600000, testTimePlusIntervalCommutative(time2, threeHours));
+
+  // Test minute addition: 03:04:05.321 + 90 minutes = 04:34:05.321
+  // 90 minutes = 90*60*1000 = 5400000 ms
+  // 04:34:05.321 = (4*3600 + 34*60 + 5)*1000 + 321 = 16445321 ms
+  const int64_t ninetyMinutes = 90 * kMillisInMinute;
+  EXPECT_EQ(16445321, testTimePlusIntervalCommutative(time1, ninetyMinutes));
+
+  // Test negative intervals: 03:04:05.321 - 2 hours = 01:04:05.321
+  // 01:04:05.321 = (1*3600 + 4*60 + 5)*1000 + 321 = 3845321 ms
+  const int64_t twoHours = 2 * kMillisInHour;
+  EXPECT_EQ(3845321, testTimePlusIntervalCommutative(time1, -twoHours));
+
+  // Test negative wraparound: 01:00:00 - 3 hours = 22:00:00 (previous day)
+  // 01:00:00 = 1*3600*1000 = 3600000 ms
+  const int64_t time3 = kMillisInHour; // 01:00:00
+  EXPECT_EQ(79200000, testTimePlusIntervalCommutative(time3, -threeHours));
+
+  // Test millisecond precision: 03:04:05.321 + 679 milliseconds = 03:04:06.000
+  EXPECT_EQ(11046000, testTimePlusIntervalCommutative(time1, 679));
+
+  // Test day intervals (should not change time of day per Presto behavior)
+  // 12:30:45.123 = (12*3600 + 30*60 + 45)*1000 + 123 = 45045123 ms
+  const int64_t time4 = 45045123; // 12:30:45.123
+  const int64_t oneDay = kMillisInDay;
+  EXPECT_EQ(45045123, testTimePlusIntervalCommutative(time4, oneDay));
+}
+
+TEST_F(DateTimeFunctionsTest, timeMinusIntervalDayTime) {
+  // Test TIME - IntervalDayTime arithmetic (does not support Interval - Time)
+
+  const auto timeMinusInterval =
+      [&](int64_t time, int64_t interval) -> std::optional<int64_t> {
+    return evaluateOnce<int64_t>(
+        "minus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({time}, TIME()),
+            makeNullableFlatVector<int64_t>({interval}, INTERVAL_DAY_TIME()),
+        }));
+  };
+
+  // Basic hour subtraction: 06:04:05.321 - 3 hours = 03:04:05.321
+  // 06:04:05.321 = (6*3600 + 4*60 + 5)*1000 + 321 = 21845321 ms
+  // 3 hours = 3*60*60*1000 = 10800000 ms
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  const int64_t time1 = 21845321; // 06:04:05.321
+  const int64_t threeHours = 3 * kMillisInHour;
+  EXPECT_EQ(11045321, timeMinusInterval(time1, threeHours));
+
+  // Test 24-hour wraparound: 01:00:00 - 3 hours = 22:00:00 (previous day)
+  // 01:00:00 = 1*3600*1000 = 3600000 ms
+  // 22:00:00 = 22*3600*1000 = 79200000 ms
+  const int64_t time2 = kMillisInHour; // 01:00:00
+  EXPECT_EQ(79200000, timeMinusInterval(time2, threeHours));
+
+  // Test minute subtraction: 04:34:05.321 - 90 minutes = 03:04:05.321
+  // 04:34:05.321 = (4*3600 + 34*60 + 5)*1000 + 321 = 16445321 ms
+  // 90 minutes = 90*60*1000 = 5400000 ms
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  const int64_t time3 = 16445321; // 04:34:05.321
+  const int64_t ninetyMinutes = 90 * kMillisInMinute;
+  EXPECT_EQ(11045321, timeMinusInterval(time3, ninetyMinutes));
+
+  // Test millisecond precision: 03:04:06.000 - 679 milliseconds = 03:04:05.321
+  // 03:04:06.000 = (3*3600 + 4*60 + 6)*1000 = 11046000 ms
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  const int64_t time4 = 11046000; // 03:04:06.000
+  EXPECT_EQ(11045321, timeMinusInterval(time4, 679));
+
+  // Test day intervals (should not change time of day per Presto behavior)
+  // 12:30:45.123 = (12*3600 + 30*60 + 45)*1000 + 123 = 45045123 ms
+  const int64_t time5 = 45045123; // 12:30:45.123
+  const int64_t oneDay = kMillisInDay;
+  EXPECT_EQ(45045123, timeMinusInterval(time5, oneDay));
+
+  // Test subtracting negative intervals (double negative = addition)
+  // 03:04:05.321 - (-3 hours) = 03:04:05.321 + 3 hours = 06:04:05.321
+  // 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  // 06:04:05.321 = (6*3600 + 4*60 + 5)*1000 + 321 = 21845321 ms
+  const int64_t time6 = 11045321; // 03:04:05.321
+  EXPECT_EQ(21845321, timeMinusInterval(time6, -threeHours));
+
+  // Test negative interval with wraparound: 22:00:00 - (-3 hours) = 01:00:00
+  // 22:00:00 = 22*3600*1000 = 79200000 ms
+  // 01:00:00 = 1*3600*1000 = 3600000 ms
+  const int64_t time7 = 22 * kMillisInHour; // 22:00:00
+  EXPECT_EQ(3600000, timeMinusInterval(time7, -threeHours));
+}
+
+TEST_F(DateTimeFunctionsTest, timeMinusTime) {
+  // Test TIME - TIME arithmetic returning INTERVAL_DAY_TIME
+
+  const auto timeMinusTime = [&](int64_t time1,
+                                 int64_t time2) -> std::optional<int64_t> {
+    return evaluateOnce<int64_t>(
+        "minus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({time1}, TIME()),
+            makeNullableFlatVector<int64_t>({time2}, TIME()),
+        }));
+  };
+
+  // Test basic subtraction: 10:00:00 - 08:00:00 = 2 hours = 7200000 ms
+  const int64_t tenAM = 10 * kMillisInHour; // 36000000 ms
+  const int64_t eightAM = 8 * kMillisInHour; // 28800000 ms
+  const int64_t twoHours = 2 * kMillisInHour; // 7200000 ms
+  EXPECT_EQ(twoHours, timeMinusTime(tenAM, eightAM));
+
+  // Test reverse (negative result): 08:00:00 - 10:00:00 = -2 hours
+  EXPECT_EQ(-twoHours, timeMinusTime(eightAM, tenAM));
+
+  // Test same time: 10:00:00 - 10:00:00 = 0
+  EXPECT_EQ(0, timeMinusTime(tenAM, tenAM));
+
+  // Test with millisecond precision
+  // 12:30:45.123 - 06:04:05.321 = 23199802 ms
+  const int64_t time1 = 12 * kMillisInHour + 30 * kMillisInMinute +
+      45 * kMillisInSecond + 123; // 45045123
+  const int64_t time2 = 6 * kMillisInHour + 4 * kMillisInMinute +
+      5 * kMillisInSecond + 321; // 21845321
+  EXPECT_EQ(23199802, timeMinusTime(time1, time2));
+
+  // Test midnight cases
+  // 23:59:59.999 - 00:00:00.000 = 86399999 ms (almost full day)
+  const int64_t almostMidnight = kMillisInDay - 1; // 86399999
+  const int64_t midnight = 0;
+  EXPECT_EQ(86399999, timeMinusTime(almostMidnight, midnight));
+
+  // 00:00:00.000 - 23:59:59.999 = -86399999 ms (negative almost full day)
+  EXPECT_EQ(-86399999, timeMinusTime(midnight, almostMidnight));
+
+  // Test with NULL values
+  const auto timeMinusTimeWithNull =
+      [&](std::optional<int64_t> time1,
+          std::optional<int64_t> time2) -> std::optional<int64_t> {
+    return evaluateOnce<int64_t>(
+        "minus(c0, c1)",
+        makeRowVector({
+            makeNullableFlatVector<int64_t>({time1}, TIME()),
+            makeNullableFlatVector<int64_t>({time2}, TIME()),
+        }));
+  };
+
+  EXPECT_EQ(std::nullopt, timeMinusTimeWithNull(std::nullopt, std::nullopt));
+  EXPECT_EQ(std::nullopt, timeMinusTimeWithNull(tenAM, std::nullopt));
+  EXPECT_EQ(std::nullopt, timeMinusTimeWithNull(std::nullopt, eightAM));
+}
+
+// Comprehensive tests for TimePlusIntervalYearMonthVectorFunction optimizations
+// and IntervalYearMonthPlusTimeVectorFunction optimizations
+TEST_F(DateTimeFunctionsTest, timeIntervalYearMonthVectorOptimizations) {
+  // Helper to create interval year-month values (in months)
+  auto months = [](int32_t value) { return value; };
+
+  // Helper to create time values (milliseconds since midnight)
+  auto timeMs = [](int32_t hours,
+                   int32_t minutes = 0,
+                   int32_t seconds = 0,
+                   int32_t millis = 0) {
+    return static_cast<int64_t>(hours) * 3600000 +
+        static_cast<int64_t>(minutes) * 60000 +
+        static_cast<int64_t>(seconds) * 1000 + static_cast<int64_t>(millis);
+  };
+
+  // Helper to verify time +/- interval results (should be identity function)
+  // Tests commutativity for plus: interval + time gives the same result
+  // Tests minus: time - interval (only this ordering supported for minus)
+  auto testTimePlusMinusIntervalYearMonth =
+      [&](const VectorPtr& timeVector,
+          const VectorPtr& intervalVector,
+          const VectorPtr& expectedResult) {
+        // Test: Time + Interval
+        auto resultPlus1 = evaluate(
+            "plus(c0, c1)", makeRowVector({timeVector, intervalVector}));
+        assertEqualVectors(expectedResult, resultPlus1);
+
+        // Test: Interval + Time (commutative for plus)
+        auto resultPlus2 = evaluate(
+            "plus(c0, c1)", makeRowVector({intervalVector, timeVector}));
+        assertEqualVectors(expectedResult, resultPlus2);
+
+        // Test: Time - Interval (identity function, only this ordering)
+        auto resultMinus = evaluate(
+            "minus(c0, c1)", makeRowVector({timeVector, intervalVector}));
+        assertEqualVectors(expectedResult, resultMinus);
+      };
+
+  // TEST 1: Constant Vector Optimization - Non-null constant
+  {
+    const auto timeValue = timeMs(14, 30, 15, 123); // 14:30:15.123
+    const auto intervalValue = months(6); // 6 months
+
+    // Create constant vectors
+    auto constantTime =
+        BaseVector::createConstant(TIME(), timeValue, 1000, pool());
+    auto constantInterval = BaseVector::createConstant(
+        INTERVAL_YEAR_MONTH(), intervalValue, 1000, pool());
+
+    // Expected result should be same constant time (identity function)
+    auto expectedResult =
+        BaseVector::createConstant(TIME(), timeValue, 1000, pool());
+
+    // Test: Time + Interval, Interval + Time, and Time - Interval
+    testTimePlusMinusIntervalYearMonth(
+        constantTime, constantInterval, expectedResult);
+
+    // Verify the result is also constant encoded for efficiency
+    auto result = evaluate(
+        "plus(c0, c1)", makeRowVector({constantTime, constantInterval}));
+
+    EXPECT_TRUE(result->isConstantEncoding());
+    EXPECT_EQ(result->size(), 1000);
+    EXPECT_EQ(result->as<ConstantVector<int64_t>>()->valueAt(0), timeValue);
+  }
+
+  // TEST 2: Constant Vector Optimization - mixed null and non-null values
+  {
+    const auto intervalValue = months(12); // 12 months
+
+    // Create time vector with mixed null and non-null values to test null
+    // handling
+    auto timeVector = makeNullableFlatVector<int64_t>(
+        {std::nullopt, timeMs(17, 30, 0), std::nullopt}, TIME());
+
+    auto intervalVector = makeFlatVector<int32_t>(
+        {intervalValue, intervalValue, intervalValue}, INTERVAL_YEAR_MONTH());
+
+    // Expected result: null, non-null, null
+    auto expectedResult = makeNullableFlatVector<int64_t>(
+        {std::nullopt, timeMs(17, 30, 0), std::nullopt}, TIME());
+
+    // Test: Time + Interval, Interval + Time, and Time - Interval
+    testTimePlusMinusIntervalYearMonth(
+        timeVector, intervalVector, expectedResult);
+  }
+
+  // TEST 3: Flat Vector with Nulls
+  {
+    const std::vector<std::optional<int64_t>> timeValues = {
+        timeMs(10, 30, 0), // 10:30:00
+        std::nullopt, // null
+        timeMs(16, 45, 30), // 16:45:30
+        std::nullopt, // null
+        timeMs(20, 0, 0) // 20:00:00
+    };
+
+    const std::vector<int32_t> intervalValues = {
+        months(3), months(6), months(9), months(12), months(18)};
+
+    auto timeVector = makeNullableFlatVector<int64_t>(timeValues, TIME());
+    auto intervalVector =
+        makeFlatVector<int32_t>(intervalValues, INTERVAL_YEAR_MONTH());
+
+    // Expected result should preserve nulls and non-null values identically
+    auto expectedResult = makeNullableFlatVector<int64_t>(timeValues, TIME());
+
+    // Test: Time + Interval, Interval + Time, and Time - Interval
+    testTimePlusMinusIntervalYearMonth(
+        timeVector, intervalVector, expectedResult);
+  }
+
+  // TEST 4: Dictionary Vector (Fallback Path)
+  {
+    // Create base values for dictionary
+    const std::vector<int64_t> baseTimeValues = {
+        timeMs(9, 0, 0), // 09:00:00
+        timeMs(17, 30, 0), // 17:30:00
+        timeMs(12, 0, 0) // 12:00:00
+    };
+
+    // Create indices that repeat base values
+    const std::vector<vector_size_t> indices = {0, 1, 2, 0, 1, 2, 1, 0};
+
+    auto baseVector = makeFlatVector<int64_t>(baseTimeValues, TIME());
+
+    auto dictionaryTimeVector = wrapInDictionary(
+        makeIndices(indices), (vector_size_t)indices.size(), baseVector);
+
+    auto intervalVector = makeFlatVector<int32_t>(
+        std::vector<int32_t>(indices.size(), months(6)), INTERVAL_YEAR_MONTH());
+
+    // Expected result should decode dictionary and preserve values
+    std::vector<int64_t> expectedValues;
+    expectedValues.reserve(indices.size());
+    for (auto idx : indices) {
+      expectedValues.push_back(baseTimeValues[idx]);
+    }
+    auto expectedResult = makeFlatVector<int64_t>(expectedValues, TIME());
+
+    // Test: Time + Interval, Interval + Time, and Time - Interval
+    testTimePlusMinusIntervalYearMonth(
+        dictionaryTimeVector, intervalVector, expectedResult);
+  }
+}
+
 TEST_F(DateTimeFunctionsTest, minusTimestampWithTimezone) {
   auto minus = [&](const std::string& a, const std::string& b) {
     const auto sql =
@@ -1466,6 +1844,127 @@ TEST_F(DateTimeFunctionsTest, minuteTimestampWithTimezone) {
       29, minuteTimestampWithTimezone(TimestampWithTimezone(-1000, "+05:30")));
 }
 
+TEST_F(DateTimeFunctionsTest, minuteTime) {
+  const auto minute = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>(
+        "minute(c0)",
+        makeRowVector({makeNullableFlatVector<int64_t>({time}, TIME())}));
+  };
+
+  // null handling
+  EXPECT_EQ(std::nullopt, minute(std::nullopt));
+
+  // edge cases: beginning and end of valid range
+  EXPECT_EQ(0, minute(0)); // 00:00:00.000
+  EXPECT_EQ(59, minute(86399999)); // 23:59:59.999
+
+  // boundary values for optimization testing
+  EXPECT_EQ(0, minute(59999)); // 00:00:59.999 - last second of first minute
+  EXPECT_EQ(1, minute(60000)); // 00:01:00.000 - first second of second minute
+  EXPECT_EQ(59, minute(3599999)); // 00:59:59.999 - last second of first hour
+  EXPECT_EQ(0, minute(3600000)); // 01:00:00.000 - first second of second hour
+
+  // time values spanning different hours to test optimization
+  EXPECT_EQ(
+      15,
+      minute(
+          15 * kMillisInMinute + 30 * kMillisInSecond + 123)); // 00:15:30.123
+  EXPECT_EQ(
+      30,
+      minute(5 * kMillisInHour + 30 * kMillisInMinute + 45000)); // 05:30:45.000
+  EXPECT_EQ(
+      45, minute(12 * kMillisInHour + 45 * kMillisInMinute)); // 12:45:00.000
+  EXPECT_EQ(0, minute(23 * kMillisInHour)); // 23:00:00.000
+
+  // comprehensive minute coverage for edge case testing
+  for (int m = 0; m < 60; ++m) {
+    EXPECT_EQ(m, minute(m * kMillisInMinute)); // exact minute boundaries
+    EXPECT_EQ(m, minute(m * kMillisInMinute + 500)); // mid-second
+    EXPECT_EQ(m, minute(m * kMillisInMinute + 59999)); // end of minute
+  }
+
+  // hour boundaries with different minute values
+  for (int h = 0; h < 24; ++h) {
+    EXPECT_EQ(0, minute(h * kMillisInHour)); // start of each hour
+    EXPECT_EQ(
+        30,
+        minute(
+            h * kMillisInHour + 30 * kMillisInMinute)); // 30 minutes into hour
+    EXPECT_EQ(
+        59,
+        minute(
+            h * kMillisInHour + 59 * kMillisInMinute +
+            59999)); // last moment of hour
+  }
+
+  // comprehensive data type coverage - test various millisecond precision
+  // values
+  EXPECT_EQ(
+      42,
+      minute(13 * kMillisInHour + 42 * kMillisInMinute + 1)); // precision: 1ms
+  EXPECT_EQ(
+      42,
+      minute(
+          13 * kMillisInHour + 42 * kMillisInMinute + 10)); // precision: 10ms
+  EXPECT_EQ(
+      42,
+      minute(
+          13 * kMillisInHour + 42 * kMillisInMinute + 100)); // precision: 100ms
+  EXPECT_EQ(
+      42,
+      minute(
+          13 * kMillisInHour + 42 * kMillisInMinute + 999)); // precision: 999ms
+
+  // performance critical values for optimization validation
+  int64_t performanceTestValues[] = {
+      0, // midnight
+      kMillisInHour / 2, // 30 minutes
+      kMillisInHour - 1, // 59:59.999
+      kMillisInHour, // 01:00:00.000
+      12 * kMillisInHour + 30 * kMillisInMinute, // 12:30:00.000 (noon+)
+      86399999 // 23:59:59.999 (end of day)
+  };
+
+  int64_t expectedMinutes[] = {0, 30, 59, 0, 30, 59};
+
+  for (size_t i = 0;
+       i < sizeof(performanceTestValues) / sizeof(performanceTestValues[0]);
+       ++i) {
+    EXPECT_EQ(expectedMinutes[i], minute(performanceTestValues[i]));
+  }
+}
+
+TEST_F(DateTimeFunctionsTest, minuteTimeInvalidRange) {
+  const auto minute = [&](int64_t time) {
+    return evaluateOnce<int64_t>(
+        "minute(c0)", makeRowVector({makeFlatVector<int64_t>({time}, TIME())}));
+  };
+
+  // test out-of-range values that should throw errors
+  VELOX_ASSERT_THROW(
+      minute(-1), "TIME value -1 is out of valid range [0, 86399999]");
+
+  VELOX_ASSERT_THROW(
+      minute(86400000),
+      "TIME value 86400000 is out of valid range [0, 86399999]");
+
+  VELOX_ASSERT_THROW(
+      minute(-86400000),
+      "TIME value -86400000 is out of valid range [0, 86399999]");
+
+  VELOX_ASSERT_THROW(
+      minute(std::numeric_limits<int64_t>::max()),
+      fmt::format(
+          "TIME value {} is out of valid range [0, 86399999]",
+          std::numeric_limits<int64_t>::max()));
+
+  VELOX_ASSERT_THROW(
+      minute(std::numeric_limits<int64_t>::min()),
+      fmt::format(
+          "TIME value {} is out of valid range [0, 86399999]",
+          std::numeric_limits<int64_t>::min()));
+}
+
 TEST_F(DateTimeFunctionsTest, second) {
   const auto second = [&](std::optional<Timestamp> timestamp) {
     return evaluateOnce<int64_t>("second(c0)", timestamp);
@@ -1515,6 +2014,52 @@ TEST_F(DateTimeFunctionsTest, secondTimestampWithTimezone) {
       59, secondTimestampWithTimezone(TimestampWithTimezone(-1000, "+05:30")));
 }
 
+TEST_F(DateTimeFunctionsTest, secondTime) {
+  const auto second = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>("second(c0)", TIME(), time);
+  };
+
+  // null handling
+  EXPECT_EQ(std::nullopt, second(std::nullopt));
+
+  // boundary tests - optimization: (time / 1000) % 60
+  // lower boundary: 0 <= time < 86400000
+  EXPECT_EQ(0, second(0)); // exactly midnight - 00:00:00.000
+  EXPECT_EQ(0, second(999)); // 00:00:00.999 - last millisecond of second 0
+  EXPECT_EQ(1, second(1000)); // 00:00:01.000 - first millisecond of second 1
+  EXPECT_EQ(59, second(59000)); // 00:00:59.000 - first millisecond of second 59
+  EXPECT_EQ(0, second(60000)); // 00:01:00.000 - first second of next minute
+  EXPECT_EQ(59, second(86399000)); // 23:59:59.000
+  EXPECT_EQ(59, second(86399999)); // 23:59:59.999 - upper boundary exclusive
+
+  // representative test cases across different times
+  EXPECT_EQ(30, second(30000)); // 00:00:30.000
+  EXPECT_EQ(15, second(75000)); // 00:01:15.000
+  // 01:01:25 = 3600000 + 60000 + 25000 = 3685000
+  EXPECT_EQ(25, second(3685000)); // 01:01:25.000
+  EXPECT_EQ(3, second(3723123)); // 01:02:03.123
+
+  // verify optimization correctness with modulo boundary conditions
+  // seconds should cycle every 60 seconds regardless of hours/minutes
+  EXPECT_EQ(0, second(3600000)); // 01:00:00.000
+  EXPECT_EQ(30, second(3630000)); // 01:00:30.000
+  EXPECT_EQ(0, second(7200000)); // 02:00:00.000
+  EXPECT_EQ(45, second(43245000)); // 12:00:45.000
+
+  // test millisecond precision is correctly truncated
+  EXPECT_EQ(15, second(15123)); // 00:00:15.123
+  EXPECT_EQ(15, second(15999)); // 00:00:15.999
+
+  // error conditions - invalid range validation
+  EXPECT_THROW(second(-1), VeloxUserError); // negative time
+  EXPECT_THROW(
+      second(86400000),
+      VeloxUserError); // exactly 24:00:00.000 (exclusive upper bound)
+  EXPECT_THROW(
+      second(std::numeric_limits<int64_t>::max()),
+      VeloxUserError); // overflow case
+}
+
 TEST_F(DateTimeFunctionsTest, millisecond) {
   const auto millisecond = [&](std::optional<Timestamp> timestamp) {
     return evaluateOnce<int64_t>("millisecond(c0)", timestamp);
@@ -1568,6 +2113,111 @@ TEST_F(DateTimeFunctionsTest, millisecondTimestampWithTimezone) {
       millisecondTimestampWithTimezone(TimestampWithTimezone(-980, "+05:30")));
 }
 
+TEST_F(DateTimeFunctionsTest, millisecondTime) {
+  const auto millisecond = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>("millisecond(c0)", TIME(), time);
+  };
+
+  // Null handling
+  EXPECT_EQ(std::nullopt, millisecond(std::nullopt));
+
+  // Basic cases
+  EXPECT_EQ(0, millisecond(0)); // 00:00:00.000
+  EXPECT_EQ(0, millisecond(1000)); // 00:00:01.000
+  EXPECT_EQ(123, millisecond(1123)); // 00:00:01.123
+  EXPECT_EQ(456, millisecond(2456)); // 00:00:02.456
+  EXPECT_EQ(999, millisecond(999)); // 00:00:00.999
+  EXPECT_EQ(123, millisecond(3661123)); // 01:01:01.123
+
+  // Boundary values
+  EXPECT_EQ(0, millisecond(86399000)); // 23:59:59.000
+  EXPECT_EQ(999, millisecond(86399999)); // 23:59:59.999 (max valid TIME)
+
+  // Different time components to verify only millisecond part matters
+  EXPECT_EQ(500, millisecond(3600500)); // 01:00:00.500
+  EXPECT_EQ(500, millisecond(7200500)); // 02:00:00.500
+  EXPECT_EQ(500, millisecond(43200500)); // 12:00:00.500
+
+  // Second boundaries
+  EXPECT_EQ(0, millisecond(60000)); // 00:01:00.000
+  EXPECT_EQ(999, millisecond(60999)); // 00:01:00.999
+  EXPECT_EQ(1, millisecond(60001)); // 00:01:00.001
+
+  // Comprehensive modulo testing - verify millisecond() == time % 1000
+  for (int64_t base : {0, 1000, 60000, 3600000, 86399000}) {
+    for (int64_t ms = 0; ms < 1000; ms += 100) {
+      int64_t timeValue = base + ms;
+      if (timeValue <= 86399999) { // Ensure within valid range
+        EXPECT_EQ(ms, millisecond(timeValue));
+      }
+    }
+  }
+
+  // Test all possible millisecond values (0-999) in first second
+  for (int64_t ms = 0; ms < 1000; ++ms) {
+    EXPECT_EQ(ms, millisecond(ms));
+  }
+
+  // Test across all hours to ensure hour component doesn't affect result
+  for (int hour = 0; hour < 24; ++hour) {
+    int64_t baseTime = hour * 3600000; // Convert hour to milliseconds
+    EXPECT_EQ(0, millisecond(baseTime)); // .000
+    EXPECT_EQ(1, millisecond(baseTime + 1)); // .001
+    EXPECT_EQ(500, millisecond(baseTime + 500)); // .500
+    EXPECT_EQ(999, millisecond(baseTime + 999)); // .999
+  }
+
+  // Test edge cases just before and after boundaries
+  EXPECT_EQ(998, millisecond(86399998)); // 23:59:59.998
+  EXPECT_EQ(1, millisecond(1001)); // 00:00:01.001
+  EXPECT_EQ(999, millisecond(1999)); // 00:00:01.999
+  EXPECT_EQ(0, millisecond(2000)); // 00:00:02.000
+
+  // Error cases - values outside valid TIME range [0, 86399999]
+  VELOX_ASSERT_THROW(
+      millisecond(-1), "TIME value -1 is out of range [0, 86400000)");
+  VELOX_ASSERT_THROW(
+      millisecond(-1000), "TIME value -1000 is out of range [0, 86400000)");
+  VELOX_ASSERT_THROW(
+      millisecond(86400000),
+      "TIME value 86400000 is out of range [0, 86400000)");
+  VELOX_ASSERT_THROW(
+      millisecond(100000000),
+      "TIME value 100000000 is out of range [0, 86400000)");
+
+  // Test vectorized execution with mixed valid values
+  auto timeVector = makeFlatVector<int64_t>(
+      {0, // 00:00:00.000
+       1123, // 00:00:01.123
+       60999, // 00:01:00.999
+       3661456, // 01:01:01.456
+       43200789, // 12:00:00.789
+       86399999}, // 23:59:59.999
+      TIME());
+
+  auto result = evaluate<FlatVector<int64_t>>(
+      "millisecond(c0)", makeRowVector({timeVector}));
+
+  auto expected = makeFlatVector<int64_t>({0, 123, 999, 456, 789, 999});
+  assertEqualVectors(expected, result);
+
+  // Test vectorized execution with nulls
+  auto timeVectorWithNulls = makeNullableFlatVector<int64_t>(
+      {0, // 00:00:00.000
+       std::nullopt, // null
+       1123, // 00:00:01.123
+       std::nullopt, // null
+       86399999}, // 23:59:59.999
+      TIME());
+
+  auto resultWithNulls = evaluate<FlatVector<int64_t>>(
+      "millisecond(c0)", makeRowVector({timeVectorWithNulls}));
+
+  auto expectedWithNulls = makeNullableFlatVector<int64_t>(
+      {0, std::nullopt, 123, std::nullopt, 999});
+  assertEqualVectors(expectedWithNulls, resultWithNulls);
+}
+
 TEST_F(DateTimeFunctionsTest, extractFromIntervalDayTime) {
   const auto millis = 5 * kMillisInDay + 7 * kMillisInHour +
       11 * kMillisInMinute + 13 * kMillisInSecond + 17;
@@ -2608,6 +3258,115 @@ TEST_F(DateTimeFunctionsTest, dateAddTimestampWithTimeZone) {
           "day", -45, "2023-04-26 02:30:00.000 America/Los_Angeles"));
 }
 
+TEST_F(DateTimeFunctionsTest, dateAddTime) {
+  const auto dateAdd = [&](const std::string& unit,
+                           std::optional<int32_t> value,
+                           std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>(
+        fmt::format("date_add('{}', c0, c1)", unit),
+        {INTEGER(), TIME()},
+        value,
+        time);
+  };
+
+  // basic time additions
+  // add milliseconds
+  EXPECT_EQ(1000, dateAdd("millisecond", 1000, 0)); // 00:00:00.000 + 1s
+  EXPECT_EQ(500, dateAdd("millisecond", -500, 1000)); // 00:00:01.000 - 500ms
+  EXPECT_EQ(2000, dateAdd("millisecond", 1000, 1000)); // 00:00:01.000 + 1s
+
+  // add seconds
+  EXPECT_EQ(1000, dateAdd("second", 1, 0)); // 00:00:00 + 1s
+  EXPECT_EQ(0, dateAdd("second", -1, 1000)); // 00:00:01 - 1s
+  EXPECT_EQ(3661000, dateAdd("second", 3661, 0)); // 1 hour 1 minute 1 second
+
+  // add minutes
+  EXPECT_EQ(60000, dateAdd("minute", 1, 0)); // 00:00:00 + 1 minute
+  EXPECT_EQ(0, dateAdd("minute", -1, 60000)); // 00:01:00 - 1 minute
+  EXPECT_EQ(300000, dateAdd("minute", 5, 0)); // 00:00:00 + 5 minutes
+
+  // add hours
+  EXPECT_EQ(3600000, dateAdd("hour", 1, 0)); // 00:00:00 + 1 hour
+  EXPECT_EQ(0, dateAdd("hour", -1, 3600000)); // 01:00:00 - 1 hour
+  EXPECT_EQ(43200000, dateAdd("hour", 12, 0)); // 00:00:00 + 12 hours
+
+  // test wraparound behavior (24-hour modulo)
+  EXPECT_EQ(
+      3600000,
+      dateAdd("hour", 25, 0)); // 00:00:00 + 25 hours = 01:00:00 (wraps)
+  EXPECT_EQ(
+      82800000, dateAdd("hour", -1, 0)); // 00:00:00 - 1 hour = 23:00:00 (wraps)
+  EXPECT_EQ(
+      0, dateAdd("hour", 24, 0)); // 00:00:00 + 24 hours = 00:00:00 (wraps)
+  EXPECT_EQ(
+      0, dateAdd("hour", -24, 0)); // 00:00:00 - 24 hours = 00:00:00 (wraps)
+
+  // test real-world scenario: 09:30:15.500 + various units
+  int64_t morning = 9 * 3600000 + 30 * 60000 + 15 * 1000 + 500; // 34215500ms
+  EXPECT_EQ(34215750, dateAdd("millisecond", 250, morning)); // +250ms
+  EXPECT_EQ(34245500, dateAdd("second", 30, morning)); // +30s
+  EXPECT_EQ(35415500, dateAdd("minute", 20, morning)); // +20 minutes
+  EXPECT_EQ(48615500, dateAdd("hour", 4, morning)); // +4 hours
+
+  // test boundary values for TIME type (0 to 86399999 ms in a day)
+  EXPECT_EQ(0, dateAdd("millisecond", 0, 0)); // 00:00:00.000 + 0ms
+  EXPECT_EQ(
+      86399999, dateAdd("millisecond", 86399999, 0)); // 00:00:00.000 + max time
+  EXPECT_EQ(
+      0, dateAdd("millisecond", -86399999, 86399999)); // max time - max time
+
+  // test wraparound with large values
+  EXPECT_EQ(
+      1000,
+      dateAdd(
+          "millisecond",
+          86401000,
+          0)); // 00:00:00 + (24h + 1s) wraps to 00:00:01
+  EXPECT_EQ(
+      86398000,
+      dateAdd(
+          "millisecond",
+          -2000,
+          0)); // 00:00:00 - 2s wraps to 23:59:58
+
+  // negative additions
+  EXPECT_EQ(0, dateAdd("second", -60, 60000)); // 00:01:00 - 60s
+  EXPECT_EQ(0, dateAdd("minute", -60, 3600000)); // 01:00:00 - 60min
+  EXPECT_EQ(75600000, dateAdd("hour", -2, 82800000)); // 23:00:00 - 2h = 21:00
+
+  // test null handling
+  EXPECT_EQ(std::nullopt, dateAdd("second", 1, std::nullopt));
+  EXPECT_EQ(std::nullopt, dateAdd("second", std::nullopt, 1000));
+  EXPECT_EQ(std::nullopt, dateAdd("second", std::nullopt, std::nullopt));
+
+  // test invalid units (TIME only supports time-related units, not
+  // date-related, and not microsecond which is not supported in Presto)
+  VELOX_ASSERT_THROW(
+      dateAdd("microsecond", 1, 0), "microsecond is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateAdd("day", 1, 0), "day is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateAdd("week", 1, 0), "week is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateAdd("month", 1, 0), "month is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateAdd("quarter", 1, 0), "quarter is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateAdd("year", 1, 0), "year is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateAdd("invalid", 1, 0), "invalid is not a valid TIME field");
+
+  // edge cases: multiple full day additions
+  EXPECT_EQ(
+      7200000,
+      dateAdd("hour", 50, 0)); // 00:00:00 + 50 hours = 02:00:00 (wraps twice)
+  EXPECT_EQ(
+      0,
+      dateAdd("hour", 72, 0)); // 00:00:00 + 72 hours = 00:00:00 (wraps 3 times)
+
+  // test midnight transitions
+  EXPECT_EQ(
+      1000, dateAdd("millisecond", 2000, 86399000)); // 23:59:59 + 2s wraps
+  EXPECT_EQ(
+      86399000, dateAdd("millisecond", -1000, 0)); // 00:00:00 - 1s = 23:59:59
+}
+
 TEST_F(DateTimeFunctionsTest, dateDiffDate) {
   const auto dateDiff = [&](const std::string& unit,
                             std::optional<int32_t> date1,
@@ -3490,29 +4249,19 @@ TEST_F(DateTimeFunctionsTest, formatDateTime) {
   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(parseTimestamp(StringView{date}), "e"));
+        std::to_string(i % 7 + 1), formatDatetime(parseTimestamp(date), "e"));
   }
   EXPECT_EQ("000001", formatDatetime(parseTimestamp("2022-08-01"), "eeeeee"));
 
   // 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(parseTimestamp(date), "E"));
+    EXPECT_EQ(daysShort[i % 7], formatDatetime(parseTimestamp(date), "EE"));
+    EXPECT_EQ(daysShort[i % 7], formatDatetime(parseTimestamp(date), "EEE"));
+    EXPECT_EQ(daysLong[i % 7], formatDatetime(parseTimestamp(date), "EEEE"));
     EXPECT_EQ(
-        daysShort[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "E"));
-    EXPECT_EQ(
-        daysShort[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "EE"));
-    EXPECT_EQ(
-        daysShort[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "EEE"));
-    EXPECT_EQ(
-        daysLong[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "EEEE"));
-    EXPECT_EQ(
-        daysLong[i % 7],
-        formatDatetime(parseTimestamp(StringView{date}), "EEEEEEEE"));
+        daysLong[i % 7], formatDatetime(parseTimestamp(date), "EEEEEEEE"));
   }
 
   // Year test cases - 'y'
@@ -3550,21 +4299,11 @@ TEST_F(DateTimeFunctionsTest, formatDateTime) {
   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(parseTimestamp(StringView{date}), "M"));
-    EXPECT_EQ(
-        padNumber(month),
-        formatDatetime(parseTimestamp(StringView{date}), "MM"));
-    EXPECT_EQ(
-        monthsShort[i],
-        formatDatetime(parseTimestamp(StringView{date}), "MMM"));
-    EXPECT_EQ(
-        monthsLong[i],
-        formatDatetime(parseTimestamp(StringView{date}), "MMMM"));
-    EXPECT_EQ(
-        monthsLong[i],
-        formatDatetime(parseTimestamp(StringView{date}), "MMMMMMMM"));
+    EXPECT_EQ(std::to_string(month), formatDatetime(parseTimestamp(date), "M"));
+    EXPECT_EQ(padNumber(month), formatDatetime(parseTimestamp(date), "MM"));
+    EXPECT_EQ(monthsShort[i], formatDatetime(parseTimestamp(date), "MMM"));
+    EXPECT_EQ(monthsLong[i], formatDatetime(parseTimestamp(date), "MMMM"));
+    EXPECT_EQ(monthsLong[i], formatDatetime(parseTimestamp(date), "MMMMMMMM"));
   }
 
   // Day of month test cases - 'd'
@@ -3725,6 +4464,8 @@ TEST_F(DateTimeFunctionsTest, formatDateTime) {
   EXPECT_EQ("+05:30", formatDatetime(parseTimestamp("1970-01-01"), "ZZ"));
   EXPECT_EQ("+0530", formatDatetime(parseTimestamp("1970-01-01"), "Z"));
 
+  // Time zone test cases - 'z'
+  // Timezone that has an abbreviation
   EXPECT_EQ("IST", formatDatetime(parseTimestamp("1970-01-01"), "zzz"));
   EXPECT_EQ("IST", formatDatetime(parseTimestamp("1970-01-01"), "zz"));
   EXPECT_EQ("IST", formatDatetime(parseTimestamp("1970-01-01"), "z"));
@@ -3735,6 +4476,18 @@ TEST_F(DateTimeFunctionsTest, formatDateTime) {
       "India Standard Time",
       formatDatetime(parseTimestamp("1970-01-01"), "zzzzzzzzzzzzzzzzzzzzzz"));
 
+  // Timezone that has no abbreviations so uses GMT offset
+  setQueryTimeZone("Asia/Atyrau");
+  EXPECT_EQ("GMT+05:00", formatDatetime(parseTimestamp("1970-01-01"), "zzz"));
+  EXPECT_EQ("GMT+05:00", formatDatetime(parseTimestamp("1970-01-01"), "zz"));
+  EXPECT_EQ("GMT+05:00", formatDatetime(parseTimestamp("1970-01-01"), "z"));
+  EXPECT_EQ(
+      "West Kazakhstan Time",
+      formatDatetime(parseTimestamp("1970-01-01"), "zzzz"));
+  EXPECT_EQ(
+      "West Kazakhstan Time",
+      formatDatetime(parseTimestamp("1970-01-01"), "zzzzzzzzzzzzzzzzzzzzzz"));
+
   // Test daylight savings.
   setQueryTimeZone("America/Los_Angeles");
   EXPECT_EQ("PST", formatDatetime(parseTimestamp("1970-01-01"), "z"));
@@ -3983,11 +4736,9 @@ TEST_F(DateTimeFunctionsTest, dateFormat) {
   for (int i = 0; i < 8; i++) {
     std::string date("1996-01-0" + std::to_string(i + 1));
     // Full length name.
-    EXPECT_EQ(
-        daysLong[i % 7], dateFormat(parseTimestamp(StringView{date}), "%W"));
+    EXPECT_EQ(daysLong[i % 7], dateFormat(parseTimestamp(date), "%W"));
     // Abbreviated name.
-    EXPECT_EQ(
-        daysShort[i % 7], dateFormat(parseTimestamp(StringView{date}), "%a"));
+    EXPECT_EQ(daysShort[i % 7], dateFormat(parseTimestamp(date), "%a"));
   }
 
   // Month cases.
@@ -3996,23 +4747,19 @@ TEST_F(DateTimeFunctionsTest, dateFormat) {
     std::string monthNum = std::to_string(i + 1);
 
     // Full length name.
-    EXPECT_EQ(
-        monthsLong[i % 12], dateFormat(parseTimestamp(StringView{date}), "%M"));
+    EXPECT_EQ(monthsLong[i % 12], dateFormat(parseTimestamp(date), "%M"));
 
     // Abbreviated name.
-    EXPECT_EQ(
-        monthsShort[i % 12],
-        dateFormat(parseTimestamp(StringView{date}), "%b"));
+    EXPECT_EQ(monthsShort[i % 12], dateFormat(parseTimestamp(date), "%b"));
 
     // Numeric.
-    EXPECT_EQ(monthNum, dateFormat(parseTimestamp(StringView{date}), "%c"));
+    EXPECT_EQ(monthNum, dateFormat(parseTimestamp(date), "%c"));
 
     // Numeric 0-padded.
     if (i + 1 < 10) {
-      EXPECT_EQ(
-          "0" + monthNum, dateFormat(parseTimestamp(StringView{date}), "%m"));
+      EXPECT_EQ("0" + monthNum, dateFormat(parseTimestamp(date), "%m"));
     } else {
-      EXPECT_EQ(monthNum, dateFormat(parseTimestamp(StringView{date}), "%m"));
+      EXPECT_EQ(monthNum, dateFormat(parseTimestamp(date), "%m"));
     }
   }
 
@@ -4020,12 +4767,11 @@ TEST_F(DateTimeFunctionsTest, dateFormat) {
   for (int i = 1; i <= 31; i++) {
     std::string dayOfMonth = std::to_string(i);
     std::string date("1970-01-" + dayOfMonth);
-    EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%e"));
+    EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(date), "%e"));
     if (i < 10) {
-      EXPECT_EQ(
-          "0" + dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%d"));
+      EXPECT_EQ("0" + dayOfMonth, dateFormat(parseTimestamp(date), "%d"));
     } else {
-      EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(StringView{date}), "%d"));
+      EXPECT_EQ(dayOfMonth, dateFormat(parseTimestamp(date), "%d"));
     }
   }
 
@@ -5036,6 +5782,230 @@ TEST_F(DateTimeFunctionsTest, timestampWithTimezoneComparisons) {
   runAndCompare("c0 between c0 and c1", inputs, expectedBetween);
 }
 
+TEST_F(DateTimeFunctionsTest, timeComparisons) {
+  const auto eq = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 = c1", {TIME(), TIME()}, a, b);
+  };
+  const auto neq = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 != c1", {TIME(), TIME()}, a, b);
+  };
+  const auto lt = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 < c1", {TIME(), TIME()}, a, b);
+  };
+  const auto lte = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 <= c1", {TIME(), TIME()}, a, b);
+  };
+  const auto gt = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 > c1", {TIME(), TIME()}, a, b);
+  };
+  const auto gte = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>("c0 >= c1", {TIME(), TIME()}, a, b);
+  };
+  const auto between = [&](std::optional<int64_t> value,
+                           std::optional<int64_t> lower,
+                           std::optional<int64_t> upper) {
+    return evaluateOnce<bool>(
+        "c0 between c1 and c2", {TIME(), TIME(), TIME()}, value, lower, upper);
+  };
+
+  // test equality
+  EXPECT_EQ(true, eq(0, 0));
+  EXPECT_EQ(false, eq(0, 1000));
+  EXPECT_EQ(true, eq(3600000, 3600000)); // 01:00:00
+  EXPECT_EQ(std::nullopt, eq(std::nullopt, 0));
+  EXPECT_EQ(std::nullopt, eq(0, std::nullopt));
+
+  // test inequality
+  EXPECT_EQ(false, neq(0, 0));
+  EXPECT_EQ(true, neq(0, 1000));
+  EXPECT_EQ(false, neq(3600000, 3600000));
+
+  // test less than
+  EXPECT_EQ(false, lt(0, 0));
+  EXPECT_EQ(true, lt(0, 1000));
+  EXPECT_EQ(false, lt(1000, 0));
+  EXPECT_EQ(true, lt(3600000, 7200000)); // 01:00:00 < 02:00:00
+
+  // test less than or equal
+  EXPECT_EQ(true, lte(0, 0));
+  EXPECT_EQ(true, lte(0, 1000));
+  EXPECT_EQ(false, lte(1000, 0));
+
+  // test greater than
+  EXPECT_EQ(false, gt(0, 0));
+  EXPECT_EQ(false, gt(0, 1000));
+  EXPECT_EQ(true, gt(1000, 0));
+  EXPECT_EQ(true, gt(7200000, 3600000)); // 02:00:00 > 01:00:00
+
+  // test greater than or equal
+  EXPECT_EQ(true, gte(0, 0));
+  EXPECT_EQ(false, gte(0, 1000));
+  EXPECT_EQ(true, gte(1000, 0));
+
+  // test between
+  EXPECT_EQ(true, between(1000, 0, 2000));
+  EXPECT_EQ(true, between(0, 0, 2000)); // inclusive lower
+  EXPECT_EQ(true, between(2000, 0, 2000)); // inclusive upper
+  EXPECT_EQ(false, between(3000, 0, 2000));
+  EXPECT_EQ(false, between(0, 1000, 2000));
+  EXPECT_EQ(
+      true,
+      between(
+          3600000, 3600000, 7200000)); // 01:00:00 between 01:00:00 and 02:00:00
+  EXPECT_EQ(std::nullopt, between(std::nullopt, 0, 1000));
+  EXPECT_EQ(std::nullopt, between(500, std::nullopt, 1000));
+  EXPECT_EQ(std::nullopt, between(500, 0, std::nullopt));
+}
+
+TEST_F(DateTimeFunctionsTest, timeWithTimezoneComparisons) {
+  const auto eq = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 = c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto neq = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 != c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto lt = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 < c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto lte = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 <= c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto gt = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 > c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto gte = [&](std::optional<int64_t> a, std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 >= c1", {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()}, a, b);
+  };
+  const auto between = [&](std::optional<int64_t> value,
+                           std::optional<int64_t> lower,
+                           std::optional<int64_t> upper) {
+    return evaluateOnce<bool>(
+        "c0 between c1 and c2",
+        {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()},
+        value,
+        lower,
+        upper);
+  };
+
+  // test distinct_from - unlike regular comparison operators,
+  // distinct_from treats NULLs as values that can be compared
+  const auto distinctFrom = [&](std::optional<int64_t> a,
+                                std::optional<int64_t> b) {
+    return evaluateOnce<bool>(
+        "c0 is distinct from c1",
+        {TIME_WITH_TIME_ZONE(), TIME_WITH_TIME_ZONE()},
+        a,
+        b);
+  };
+
+  // Helper to parse TIME WITH TIME ZONE from string
+  const auto parse = [](const std::string& timeStr) -> std::optional<int64_t> {
+    auto result =
+        util::fromTimeWithTimezoneString(timeStr.c_str(), timeStr.size());
+    if (result.hasError()) {
+      throw std::runtime_error("Parse error: " + result.error().message());
+    }
+    return result.value();
+  };
+
+  // test equality - same UTC time in different timezones should be equal
+  EXPECT_EQ(true, eq(parse("00:00:00.000+00:00"), parse("01:00:00.000+01:00")));
+  EXPECT_EQ(true, eq(parse("12:30:45.123+00:00"), parse("20:30:45.123+08:00")));
+  EXPECT_EQ(
+      false, eq(parse("00:00:00.000+00:00"), parse("00:00:01.000+00:00")));
+  EXPECT_EQ(std::nullopt, eq(std::nullopt, parse("00:00:00.000+00:00")));
+
+  // test inequality
+  EXPECT_EQ(
+      true, neq(parse("00:00:00.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(
+      true, neq(parse("00:00:00.000+00:00"), parse("00:00:01.000+00:00")));
+  EXPECT_EQ(
+      true, neq(parse("01:00:00.000+01:00"), parse("01:00:00.000+03:00")));
+
+  // test less than
+  EXPECT_EQ(
+      false, lt(parse("00:00:00.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(true, lt(parse("00:00:01.000+01:00"), parse("00:00:00.000+00:00")));
+  EXPECT_EQ(
+      false, lt(parse("00:00:01.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(
+      false, lt(parse("01:00:00.000+01:00"), parse("02:00:00.000+03:00")));
+
+  // test less than or equal
+  EXPECT_EQ(
+      false, lte(parse("00:00:00.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(
+      false, lte(parse("00:00:01.000+00:00"), parse("00:00:00.000+01:00")));
+
+  // test greater than
+  EXPECT_EQ(true, gt(parse("00:00:00.000+00:00"), parse("00:00:00.000+01:00")));
+  EXPECT_EQ(
+      false, gt(parse("01:00:00.000+03:00"), parse("02:00:00.000+01:00")));
+
+  // test greater than or equal
+  EXPECT_EQ(
+      true, gte(parse("00:00:00.000+00:00"), parse("00:00:00.000+00:00")));
+  EXPECT_EQ(
+      true, gte(parse("00:00:00.000+00:00"), parse("00:00:01.000+01:00")));
+  EXPECT_EQ(
+      true, gte(parse("00:00:01.000+00:00"), parse("00:00:00.000+01:00")));
+
+  // test between
+  EXPECT_EQ(
+      true,
+      between(
+          parse("02:00:00.000+02:00"),
+          parse("00:00:00.000+01:00"),
+          parse("00:00:01.000+00:00")));
+  EXPECT_EQ(
+      std::nullopt,
+      between(
+          parse("00:00:00.500+00:00"),
+          parse("00:00:00.000+01:00"),
+          std::nullopt));
+
+  // test distinct from
+  // Same UTC time in different timezones should not be distinct
+  EXPECT_EQ(
+      false,
+      distinctFrom(parse("01:00:00.000+01:00"), parse("02:00:00.000+02:00")));
+
+  // Different times should be distinct
+  EXPECT_EQ(
+      true,
+      distinctFrom(parse("00:00:00.000+00:00"), parse("00:00:01.000+00:00")));
+  EXPECT_EQ(
+      true,
+      distinctFrom(parse("01:00:00.000+01:00"), parse("02:00:00.000+03:00")));
+
+  // NULL handling: NULL is distinct from non-NULL
+  EXPECT_EQ(true, distinctFrom(std::nullopt, parse("00:00:00.000+00:00")));
+
+  // NULL is NOT distinct from NULL
+  EXPECT_EQ(false, distinctFrom(std::nullopt, std::nullopt));
+
+  // Test edge cases with day wrap-around (normalization logic)
+  EXPECT_EQ(
+      false, eq(parse("01:00:00.000+08:00"), parse("02:00:00.000+00:00")));
+  EXPECT_EQ(
+      false, gt(parse("01:00:00.000+08:00"), parse("02:00:00.000+00:00")));
+
+  EXPECT_EQ(
+      false, eq(parse("23:00:00.000-08:00"), parse("16:00:00.000+08:00")));
+  EXPECT_EQ(true, lt(parse("23:00:00.000-08:00"), parse("18:00:00.000-14:00")));
+
+  EXPECT_EQ(
+      false, eq(parse("00:30:00.000-02:00"), parse("00:30:00.000+02:00")));
+  EXPECT_EQ(true, gt(parse("00:30:00.000-02:00"), parse("00:30:00.000+02:00")));
+}
+
 TEST_F(DateTimeFunctionsTest, castDateToTimestamp) {
   const int64_t kSecondsInDay = kMillisInDay / 1'000;
   const auto castDateToTimestamp = [&](const std::optional<int32_t> date) {
@@ -5361,6 +6331,99 @@ TEST_F(DateTimeFunctionsTest, atTimezoneTest) {
   EXPECT_EQ(at_timezone(std::nullopt, "Pacific/Fiji"), std::nullopt);
 }
 
+TEST_F(DateTimeFunctionsTest, atTimezoneTimeWithTimezoneTest) {
+  using namespace facebook::velox::util;
+
+  const auto at_timezone = [&](std::optional<int64_t> timeWithTimezone,
+                               std::optional<std::string> targetTimezone) {
+    return evaluateOnce<int64_t>(
+        "at_timezone(c0, c1)",
+        {TIME_WITH_TIME_ZONE(), VARCHAR()},
+        timeWithTimezone,
+        targetTimezone);
+  };
+
+  // Helper to create TIME WITH TIME ZONE values
+  const auto makeTimeWithTz = [](const std::string& timeStr) -> int64_t {
+    auto result = fromTimeWithTimezoneString(timeStr.c_str(), timeStr.size());
+    if (result.hasError()) {
+      throw std::runtime_error("Parse error: " + result.error().message());
+    }
+    return result.value();
+  };
+
+  // Test 1: Change from +05:30 to +08:00
+  // Input: 10:30:00+05:30 (which is 05:00:00 UTC)
+  // Output: Same UTC time (05:00:00 UTC) with +08:00 offset
+  auto input1 = makeTimeWithTz("10:30:00+05:30");
+  auto expected1 = makeTimeWithTz("13:00:00+08:00"); // Same UTC moment
+  EXPECT_EQ(at_timezone(input1, "+08:00"), expected1);
+
+  // Test 2: Change from -08:00 to +00:00 (UTC)
+  // Input: 14:00:00-08:00 (which is 22:00:00 UTC)
+  // Output: Same UTC time with +00:00 offset
+  auto input2 = makeTimeWithTz("14:00:00-08:00");
+  auto expected2 = makeTimeWithTz("22:00:00+00:00");
+  EXPECT_EQ(at_timezone(input2, "+00:00"), expected2);
+
+  // Test 3: Change from +00:00 to -05:00
+  // Input: 12:00:00+00:00 (which is 12:00:00 UTC)
+  // Output: Same UTC time with -05:00 offset
+  auto input3 = makeTimeWithTz("12:00:00+00:00");
+  auto expected3 = makeTimeWithTz("07:00:00-05:00");
+  EXPECT_EQ(at_timezone(input3, "-05:00"), expected3);
+
+  // Test 4: Change from +01:00 to -11:00
+  // Input: 23:30:00+01:00 (which is 22:30:00 UTC)
+  // Output: Same UTC time with -11:00 offset
+  auto input4 = makeTimeWithTz("23:30:00+01:00");
+  auto expected4 = makeTimeWithTz("11:30:00-11:00");
+  EXPECT_EQ(at_timezone(input4, "-11:00"), expected4);
+
+  // Test 5: With milliseconds - +05:30 to -08:00
+  // Input: 10:30:45.123+05:30 (which is 05:00:45.123 UTC)
+  // Output: Same UTC time with -08:00 offset
+  auto input5 = makeTimeWithTz("10:30:45.123+05:30");
+  auto expected5 = makeTimeWithTz("21:00:45.123-08:00");
+  EXPECT_EQ(at_timezone(input5, "-08:00"), expected5);
+
+  // Test 6: Different offset format - using +HH format
+  auto input6 = makeTimeWithTz("15:00:00+02:00");
+  auto expected6 = makeTimeWithTz("08:00:00-05:00");
+  EXPECT_EQ(at_timezone(input6, "-05"), expected6);
+
+  // Test 7: Different offset format - using +HH:mm format (Presto-compatible)
+  // Note: at_timezone uses allowCompactFormat=false to match Presto behavior,
+  // so we must use +HH:mm format, not +HHmm
+  auto input7 = makeTimeWithTz("08:15:30+00:00");
+  auto expected7 = makeTimeWithTz("13:45:30+05:30");
+  EXPECT_EQ(at_timezone(input7, "+05:30"), expected7);
+
+  // Test 8: Null input time
+  EXPECT_EQ(at_timezone(std::nullopt, "+05:00"), std::nullopt);
+
+  // Test 9: Null target timezone
+  EXPECT_EQ(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), std::nullopt),
+      std::nullopt);
+
+  // Test 10: Invalid timezone offset format should throw
+  EXPECT_THROW(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), "invalid"), VeloxUserError);
+
+  // Test 11: Timezone offset out of valid range should throw
+  EXPECT_THROW(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), "+15:00"), VeloxUserError);
+
+  EXPECT_THROW(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), "-15:00"), VeloxUserError);
+
+  // Test 12: timezone IANA Names should throw
+  EXPECT_THROW(
+      at_timezone(makeTimeWithTz("12:00:00+00:00"), "America/Los_Angeles"),
+      VeloxUserError);
+}
+
 TEST_F(DateTimeFunctionsTest, toMilliseconds) {
   EXPECT_EQ(
       123,
@@ -5494,3 +6557,443 @@ TEST_F(DateTimeFunctionsTest, xxHash64FunctionTimestamp) {
   EXPECT_EQ(
       7585368295023641328, xxhash64(parseTimestamp("1900-01-01 00:00:00.000")));
 }
+
+TEST_F(DateTimeFunctionsTest, xxHash64FunctionTime) {
+  const auto xxhash64 = [&](std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>("xxhash64_internal(c0)", TIME(), time);
+  };
+
+  // Test NULL handling
+  EXPECT_EQ(std::nullopt, xxhash64(std::nullopt));
+
+  // Test determinism - same input should give same output
+  auto result1 = xxhash64(43200000);
+  auto result2 = xxhash64(43200000);
+  EXPECT_EQ(result1, result2);
+
+  // Test that different inputs give different outputs
+  auto hash0 = xxhash64(0);
+  auto hash1 = xxhash64(1);
+  auto hashNoon = xxhash64(43200000);
+  auto hashEnd = xxhash64(86399999);
+
+  EXPECT_NE(hash0, hash1);
+  EXPECT_NE(hash0, hashNoon);
+  EXPECT_NE(hash0, hashEnd);
+  EXPECT_NE(hashNoon, hashEnd);
+
+  // Test boundary values don't crash
+  EXPECT_TRUE(xxhash64(0).has_value());
+  EXPECT_TRUE(xxhash64(86399999).has_value());
+
+  // Test known hash values validated against Presto xxhash64
+  // Query: SELECT from_big_endian_64(xxhash64(to_big_endian_64(value)))
+  EXPECT_EQ(3803688792395291579, xxhash64(0)); // Midnight
+  EXPECT_EQ(-6980583299780818982, xxhash64(1)); // 1 millisecond after midnight
+  EXPECT_EQ(7848233046982034517, xxhash64(43200000)); // Noon (12:00:00.000)
+  EXPECT_EQ(
+      5892092673475229733, xxhash64(86399999)); // End of day (23:59:59.999)
+  EXPECT_EQ(-3599997350390034763, xxhash64(1234)); // Arbitrary value
+}
+
+TEST_F(DateTimeFunctionsTest, currentTimestamp) {
+  const auto callCurrentTimestamp =
+      [&](int64_t sessionStartTime,
+          const std::optional<std::string>& timeZone) {
+        if (timeZone.has_value()) {
+          setSessionStartTimeAndTimeZone(sessionStartTime, timeZone.value());
+        } else {
+          setQuerySessionStartTime(sessionStartTime);
+        }
+
+        auto rowVector = makeRowVector({});
+        rowVector->resize(1);
+
+        auto result = evaluate("current_timestamp()", rowVector);
+        DecodedVector decoded(*result);
+        return decoded.valueAt<int64_t>(0);
+      };
+
+  // Test without timezone
+  EXPECT_THROW(
+      {
+        try {
+          callCurrentTimestamp(0, std::nullopt);
+        } catch (const VeloxException& e) {
+          EXPECT_EQ(e.exceptionType(), VeloxException::Type::kUser);
+          throw;
+        }
+      },
+      VeloxException);
+
+  // Test with timezone America/Los_Angeles
+  auto laPacked = callCurrentTimestamp(1758499200000, "America/Los_Angeles");
+  auto la = TimestampWithTimezone::unpack(laPacked);
+  ASSERT_TRUE(la.has_value());
+
+  EXPECT_EQ(la->timezone_->name(), "America/Los_Angeles");
+  EXPECT_EQ(la->milliSeconds_, 1758499200000);
+}
+
+TEST_F(DateTimeFunctionsTest, localtime) {
+  const auto localtime = [&](int64_t sessionStartTime,
+                             const std::optional<std::string>& timeZone) {
+    if (timeZone.has_value()) {
+      setSessionStartTimeAndTimeZone(sessionStartTime, timeZone.value());
+    } else {
+      setQuerySessionStartTime(sessionStartTime);
+    }
+
+    auto rowVector = makeRowVector({});
+    rowVector->resize(1);
+    auto result = evaluate("localtime()", rowVector);
+    DecodedVector decoded(*result);
+    return decoded.valueAt<int64_t>(0);
+  };
+
+  auto utcVal = localtime(0, std::nullopt);
+  EXPECT_EQ(utcVal, 0);
+
+  auto localVal =
+      localtime(1758499200000, "America/Los_Angeles"); // Midnight UTC
+  EXPECT_EQ(localVal, 0);
+
+  // Test during daylight saving time
+  localVal = localtime(1710061200000, "America/Los_Angeles");
+  EXPECT_EQ(localVal, 32400000); // 9 AM UTC
+}
+
+TEST_F(DateTimeFunctionsTest, dateDiffTime) {
+  const auto dateDiff = [&](const std::string& unit,
+                            std::optional<int64_t> time1,
+                            std::optional<int64_t> time2) {
+    return evaluateOnce<int64_t>(
+        fmt::format("date_diff('{}', c0, c1)", unit),
+        {TIME(), TIME()},
+        time1,
+        time2);
+  };
+
+  // Basic time differences - following Presto's date_diff(unit, x1, x2) = x2 -
+  // x1 pattern
+
+  // Test millisecond differences
+  EXPECT_EQ(
+      1000, dateDiff("millisecond", 0, 1000)); // 00:00:00.000 to 00:00:01.000
+  EXPECT_EQ(
+      -1000,
+      dateDiff(
+          "millisecond", 1000, 0)); // 00:00:01.000 to 00:00:00.000 (negative)
+  EXPECT_EQ(0, dateDiff("millisecond", 1000, 1000)); // Same time
+  EXPECT_EQ(
+      500, dateDiff("millisecond", 500, 1000)); // 00:00:00.500 to 00:00:01.000
+
+  // Test second differences
+  EXPECT_EQ(1, dateDiff("second", 0, 1000)); // 1 second difference
+  EXPECT_EQ(-1, dateDiff("second", 1000, 0)); // Negative 1 second
+  EXPECT_EQ(0, dateDiff("second", 1000, 1000)); // Same time
+  EXPECT_EQ(30, dateDiff("second", 15000, 45000)); // 30 seconds (15s to 45s)
+  EXPECT_EQ(3661, dateDiff("second", 0, 3661000)); // 1 hour 1 minute 1 second
+
+  // Test minute differences
+  EXPECT_EQ(1, dateDiff("minute", 0, 60000)); // 1 minute (00:00 to 00:01)
+  EXPECT_EQ(-1, dateDiff("minute", 60000, 0)); // Negative 1 minute
+  EXPECT_EQ(0, dateDiff("minute", 60000, 60000)); // Same time
+  EXPECT_EQ(5, dateDiff("minute", 0, 300000)); // 5 minutes (00:00 to 00:05)
+  EXPECT_EQ(61, dateDiff("minute", 0, 3660000)); // 1 hour 1 minute
+
+  // Test hour differences
+  EXPECT_EQ(1, dateDiff("hour", 0, 3600000)); // 1 hour (00:00 to 01:00)
+  EXPECT_EQ(-1, dateDiff("hour", 3600000, 0)); // Negative 1 hour
+  EXPECT_EQ(0, dateDiff("hour", 3600000, 3600000)); // Same time
+  EXPECT_EQ(12, dateDiff("hour", 0, 43200000)); // 12 hours (00:00 to 12:00)
+  EXPECT_EQ(23, dateDiff("hour", 0, 82800000)); // 23 hours (00:00 to 23:00)
+
+  // Test boundary values for TIME type (0 to 86399999 ms in a day)
+  EXPECT_EQ(0, dateDiff("millisecond", 0, 0)); // 00:00:00.000 to 00:00:00.000
+  EXPECT_EQ(
+      86399999,
+      dateDiff("millisecond", 0, 86399999)); // 00:00:00.000 to 23:59:59.999
+  EXPECT_EQ(
+      -86399999,
+      dateDiff("millisecond", 86399999, 0)); // 23:59:59.999 to 00:00:00.000
+  EXPECT_EQ(
+      86399, dateDiff("second", 0, 86399999)); // Full day minus 1ms in seconds
+  EXPECT_EQ(
+      1439, dateDiff("minute", 0, 86399999)); // Full day minus 1ms in minutes
+  EXPECT_EQ(23, dateDiff("hour", 0, 86399999)); // Full day minus 1ms in hours
+
+  // Test fractional truncation behavior (consistent with Presto integer
+  // division)
+  EXPECT_EQ(0, dateDiff("second", 0, 999)); // 999ms < 1000ms, truncates to 0
+  EXPECT_EQ(
+      59, dateDiff("minute", 0, 3599999)); // 59.99999 minutes truncates to 59
+  EXPECT_EQ(0, dateDiff("hour", 0, 3599999)); // 0.99999 hours truncates to 0
+
+  // Test real-world scenario: 09:30:15.500 to 14:45:30.750
+  int64_t morning = 9 * 3600000 + 30 * 60000 + 15 * 1000 + 500; // 34215500ms
+  int64_t afternoon = 14 * 3600000 + 45 * 60000 + 30 * 1000 + 750; // 53130750ms
+
+  EXPECT_EQ(18915250, dateDiff("millisecond", morning, afternoon));
+  EXPECT_EQ(
+      18915,
+      dateDiff("second", morning, afternoon)); // 18915.25s truncated to 18915
+  EXPECT_EQ(
+      315,
+      dateDiff(
+          "minute", morning, afternoon)); // 315.254... minutes truncated to 315
+  EXPECT_EQ(
+      5, dateDiff("hour", morning, afternoon)); // 5.254... hours truncated to 5
+  EXPECT_EQ(
+      315,
+      dateDiff(
+          "minute", morning, afternoon)); // 315.254... minutes truncated to 315
+  EXPECT_EQ(
+      5, dateDiff("hour", morning, afternoon)); // 5.254... hours truncated to 5
+
+  // Test null handling (consistent with Presto null propagation)
+  EXPECT_EQ(std::nullopt, dateDiff("second", 1000, std::nullopt));
+  EXPECT_EQ(std::nullopt, dateDiff("second", std::nullopt, 1000));
+  EXPECT_EQ(std::nullopt, dateDiff("second", std::nullopt, std::nullopt));
+
+  // Test invalid units (TIME only supports millisecond, second, minute, and
+  // hour - microsecond is not supported in Presto)
+  VELOX_ASSERT_THROW(
+      dateDiff("microsecond", 0, 1000),
+      "microsecond is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateDiff("day", 0, 1000), "day is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("week", 0, 1000), "week is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("month", 0, 1000), "month is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("quarter", 0, 1000), "quarter is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("year", 0, 1000), "year is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateDiff("invalid", 0, 1000), "invalid is not a valid TIME field");
+
+  // Additional edge cases
+  // Note: This represents going from 23:59:59.999 to 00:00:00.000 of next day,
+  // but since TIME type represents time within a single day, this results in
+  // negative difference
+  EXPECT_EQ(
+      -86399999,
+      dateDiff(
+          "millisecond",
+          86399999,
+          0)); // 23:59:59.999 to 00:00:00.000 (negative)
+}
+
+TEST_F(DateTimeFunctionsTest, dateDiffTimeVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), the function correctly processes
+  // each row with its own unit value rather than incorrectly caching a single
+  // unit. This tests batch processing with varying units in a single
+  // evaluation.
+  auto data = makeRowVector({
+      makeFlatVector<std::string>(
+          {"millisecond", "second", "minute", "hour", "millisecond"}),
+      makeFlatVector<int64_t>({0, 0, 0, 0, 1000}, TIME()),
+      makeFlatVector<int64_t>({1000, 1000, 60000, 3600000, 2000}, TIME()),
+  });
+
+  auto result = evaluate("date_diff(c0, c1, c2)", data);
+  auto expected = makeFlatVector<int64_t>({
+      1000, // millisecond: 0 to 1000
+      1, // second: 0 to 1000
+      1, // minute: 0 to 60000
+      1, // hour: 0 to 3600000
+      1000, // millisecond: 1000 to 2000
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, dateTruncTimestampVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), date_trunc correctly processes each
+  // row with its own unit value rather than incorrectly caching a single unit.
+  auto timestamps = makeFlatVector<Timestamp>({
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+      Timestamp(998474645, 321001234), // 2001-08-22 03:04:05.321001234
+  });
+
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"second", "minute", "hour", "day", "month"}),
+      timestamps,
+  });
+
+  auto result = evaluate("date_trunc(c0, c1)", data);
+
+  auto expected = makeFlatVector<Timestamp>({
+      Timestamp(998474645, 0), // second: 2001-08-22 03:04:05.000
+      Timestamp(998474640, 0), // minute: 2001-08-22 03:04:00.000
+      Timestamp(998474400, 0), // hour: 2001-08-22 03:00:00.000
+      Timestamp(998438400, 0), // day: 2001-08-22 00:00:00.000
+      Timestamp(996624000, 0), // month: 2001-08-01 00:00:00.000
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, dateTruncDateVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), date_trunc correctly processes each
+  // row with its own unit value for DATE type.
+  auto dates = makeFlatVector<int32_t>(
+      {parseDate("2020-02-29"),
+       parseDate("2020-02-29"),
+       parseDate("2020-02-29"),
+       parseDate("2020-02-29")},
+      DATE());
+
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"day", "week", "month", "quarter"}),
+      dates,
+  });
+
+  auto result = evaluate("date_trunc(c0, c1)", data);
+
+  auto expected = makeFlatVector<int32_t>(
+      {parseDate("2020-02-29"), // day: same
+       parseDate("2020-02-24"), // week: Monday of that week
+       parseDate("2020-02-01"), // month: first day of month
+       parseDate("2020-01-01")}, // quarter: first day of quarter
+      DATE());
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, dateTruncTime) {
+  const auto dateTrunc = [&](const std::string& unit,
+                             std::optional<int64_t> time) {
+    return evaluateOnce<int64_t>(
+        fmt::format("date_trunc('{}', c0)", unit), TIME(), time);
+  };
+
+  EXPECT_EQ(std::nullopt, dateTrunc("second", std::nullopt));
+
+  // TIME value: 03:04:05.321 = (3*3600 + 4*60 + 5)*1000 + 321 = 11045321 ms
+  const int64_t time1 = 11045321;
+
+  EXPECT_EQ(11045321, dateTrunc("millisecond", time1)); // no change
+  EXPECT_EQ(11045000, dateTrunc("second", time1)); // 03:04:05.000
+  EXPECT_EQ(11040000, dateTrunc("minute", time1)); // 03:04:00.000
+  EXPECT_EQ(10800000, dateTrunc("hour", time1)); // 03:00:00.000
+
+  // TIME value: 00:00:00.000 = 0 ms (midnight)
+  EXPECT_EQ(0, dateTrunc("millisecond", 0));
+  EXPECT_EQ(0, dateTrunc("second", 0));
+  EXPECT_EQ(0, dateTrunc("minute", 0));
+  EXPECT_EQ(0, dateTrunc("hour", 0));
+
+  // TIME value: 23:59:59.999 = (23*3600 + 59*60 + 59)*1000 + 999 = 86399999 ms
+  const int64_t time2 = 86399999;
+  EXPECT_EQ(86399999, dateTrunc("millisecond", time2)); // no change
+  EXPECT_EQ(86399000, dateTrunc("second", time2)); // 23:59:59.000
+  EXPECT_EQ(86340000, dateTrunc("minute", time2)); // 23:59:00.000
+  EXPECT_EQ(82800000, dateTrunc("hour", time2)); // 23:00:00.000
+
+  // TIME value: 12:30:45.123 = (12*3600 + 30*60 + 45)*1000 + 123 = 45045123 ms
+  const int64_t time3 = 45045123;
+  EXPECT_EQ(45045123, dateTrunc("millisecond", time3)); // no change
+  EXPECT_EQ(45045000, dateTrunc("second", time3)); // 12:30:45.000
+  EXPECT_EQ(45000000, dateTrunc("minute", time3)); // 12:30:00.000
+  EXPECT_EQ(43200000, dateTrunc("hour", time3)); // 12:00:00.000
+
+  // Invalid unit tests - TIME only supports millisecond, second, minute, and
+  // hour (microsecond is not supported in Presto)
+  VELOX_ASSERT_THROW(
+      dateTrunc("microsecond", time1), "microsecond is not a valid TIME field");
+  VELOX_ASSERT_THROW(dateTrunc("day", time1), "day is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateTrunc("week", time1), "week is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateTrunc("month", time1), "month is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateTrunc("quarter", time1), "quarter is not a valid TIME field");
+  VELOX_ASSERT_THROW(
+      dateTrunc("year", time1), "year is not a valid TIME field");
+}
+
+TEST_F(DateTimeFunctionsTest, dateAddTimestampVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), date_add correctly processes each
+  // row with its own unit value.
+  auto timestamps = makeFlatVector<Timestamp>({
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+      Timestamp(0, 0), // 1970-01-01 00:00:00.000
+  });
+
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"second", "minute", "hour", "day", "month"}),
+      makeFlatVector<int64_t>({1, 1, 1, 1, 1}),
+      timestamps,
+  });
+
+  auto result = evaluate("date_add(c0, c1, c2)", data);
+
+  auto expected = makeFlatVector<Timestamp>({
+      Timestamp(1, 0), // second: 1970-01-01 00:00:01.000
+      Timestamp(60, 0), // minute: 1970-01-01 00:01:00.000
+      Timestamp(3600, 0), // hour: 1970-01-01 01:00:00.000
+      Timestamp(86400, 0), // day: 1970-01-02 00:00:00.000
+      Timestamp(2678400, 0), // month: 1970-02-01 00:00:00.000
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, dateAddDateVariableUnit) {
+  // This test validates that when the unit parameter is variable (passed as a
+  // column with different values per row), date_add correctly processes each
+  // row with its own unit value for DATE type.
+  auto dates = makeFlatVector<int32_t>(
+      {parseDate("2020-01-31"),
+       parseDate("2020-01-31"),
+       parseDate("2020-01-31"),
+       parseDate("2020-01-31")},
+      DATE());
+
+  auto data = makeRowVector({
+      makeFlatVector<std::string>({"day", "week", "month", "year"}),
+      makeFlatVector<int64_t>({1, 1, 1, 1}),
+      dates,
+  });
+
+  auto result = evaluate("date_add(c0, c1, c2)", data);
+
+  auto expected = makeFlatVector<int32_t>(
+      {parseDate("2020-02-01"), // day: 2020-01-31 + 1 day
+       parseDate("2020-02-07"), // week: 2020-01-31 + 7 days
+       parseDate("2020-02-29"), // month: 2020-01-31 + 1 month (leap year)
+       parseDate("2021-01-31")}, // year: 2020-01-31 + 1 year
+      DATE());
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(DateTimeFunctionsTest, currentTimezone) {
+  {
+    setQueryTimeZone("Asia/Kolkata");
+    auto tz = evaluateOnce<std::string>(
+        "current_timezone()", makeRowVector(ROW({}), 1));
+    ASSERT_TRUE(tz.has_value());
+    EXPECT_EQ(tz.value(), "Asia/Kolkata");
+  }
+
+  {
+    setQueryTimeZone("America/New_York");
+    auto tz = evaluateOnce<std::string>(
+        "current_timezone()", makeRowVector(ROW({}), 1));
+    ASSERT_TRUE(tz.has_value());
+    EXPECT_EQ(tz.value(), "America/New_York");
+  }
+}
diff --git a/velox/functions/prestosql/tests/DistanceFunctionsTest.cpp b/velox/functions/prestosql/tests/DistanceFunctionsTest.cpp
new file mode 100644
index 000000000000..ad793285641b
--- /dev/null
+++ b/velox/functions/prestosql/tests/DistanceFunctionsTest.cpp
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <limits>
+#include <optional>
+
+#include <gmock/gmock.h>
+
+#include <velox/common/base/VeloxException.h>
+#include <velox/vector/SimpleVector.h>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+
+namespace facebook::velox {
+namespace {
+
+constexpr double kInf = std::numeric_limits<double>::infinity();
+constexpr double kNan = std::numeric_limits<double>::quiet_NaN();
+constexpr float kInfFloat = std::numeric_limits<float>::infinity();
+constexpr float kNanFloat = std::numeric_limits<float>::quiet_NaN();
+
+MATCHER(IsNan, "is NaN") {
+  return arg && std::isnan(*arg);
+}
+MATCHER(IsInf, "is Infinity") {
+  return arg && std::isinf(*arg);
+}
+
+class DistanceFunctionsTest : public functions::test::FunctionBaseTest {};
+
+TEST_F(DistanceFunctionsTest, 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_NEAR(
+      (2.0 * 3.0) / (std::sqrt(5.0) * std::sqrt(10.0)),
+      cosineSimilarity({{"a", 1}, {"b", 2}}, {{"c", 1}, {"b", 3}}),
+      1e-6);
+
+  EXPECT_NEAR(
+      (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}}),
+      1e-6);
+
+  EXPECT_NEAR(
+      ((-1) * 1) / (std::sqrt(1 + 4 + 1) * std::sqrt(1 + 9)),
+      cosineSimilarity({{"a", 1}, {"b", 2}, {"c", -1}}, {{"c", 1}, {"d", 3}}),
+      1e-6);
+  // Two maps have no common keys.
+  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());
+}
+
+TEST_F(DistanceFunctionsTest, cosineSimilarityArray) {
+  const auto cosineSimilarity = [&](const std::vector<double>& left,
+                                    const std::vector<double>& right) {
+    auto leftMap = makeArrayVector<double>({left});
+    auto rightMap = makeArrayVector<double>({right});
+    return evaluateOnce<double>(
+               "cosine_similarity(c0,c1)", makeRowVector({leftMap, rightMap}))
+        .value();
+  };
+  EXPECT_NEAR(
+      (1 * 1 * 1 + 2 * 3) / (std::sqrt(5.0) * std::sqrt(10.0)),
+      cosineSimilarity({{1, 2}}, {{1, 3}}),
+      1e-6);
+
+  EXPECT_NEAR(
+      (1 * 1 + 2 * 3 + (-1) * 5) /
+          (std::sqrt(1 + 4 + 1) * std::sqrt(1 + 9 + 25)),
+      cosineSimilarity({{1, 2, -1}}, {{1, 3, 5}}),
+      1e-6);
+
+  EXPECT_TRUE(std::isnan(cosineSimilarity({}, {})));
+  VELOX_ASSERT_THROW(
+      cosineSimilarity({1, 3}, {}), "Both arrays need to have identical size");
+  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {0, 0})));
+  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {kNan, 1})));
+  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {kInf, 1})));
+}
+
+TEST_F(DistanceFunctionsTest, dotProductArray) {
+  const auto dotProduct = [&](const std::vector<double>& left,
+                              const std::vector<double>& right) {
+    auto leftArray = makeArrayVector<double>({left});
+    auto rightArray = makeArrayVector<double>({right});
+    return evaluateOnce<double>(
+               "dot_product(c0,c1)", makeRowVector({leftArray, rightArray}))
+        .value();
+  };
+  EXPECT_NEAR((1 * 1 + 2 * 3), dotProduct({{1, 2}}, {{1, 3}}), 1e-6);
+
+  EXPECT_NEAR(
+      (1 * 1 + 2 * 3 + (-1) * 5), dotProduct({{1, 2, -1}}, {{1, 3, 5}}), 1e-6);
+
+  EXPECT_TRUE(std::isnan(dotProduct({}, {})));
+  VELOX_ASSERT_THROW(
+      dotProduct({1, 3}, {}), "Both array arguments must have identical sizes");
+}
+
+#ifdef VELOX_ENABLE_FAISS
+
+TEST_F(DistanceFunctionsTest, cosineSimilarityFloatArray) {
+  const auto cosineSimilarity = [&](const std::vector<float>& left,
+                                    const std::vector<float>& right) {
+    auto leftMap = makeArrayVector<float>({left});
+    auto rightMap = makeArrayVector<float>({right});
+    return evaluateOnce<float>(
+               "cosine_similarity(c0,c1)", makeRowVector({leftMap, rightMap}))
+        .value();
+  };
+  EXPECT_NEAR(
+      (1 * 1 * 1 + 2 * 3) / (std::sqrt(5.0) * std::sqrt(10.0)),
+      cosineSimilarity({{1, 2}}, {{1, 3}}),
+      1e-6);
+
+  EXPECT_NEAR(
+      (1 * 1 + 2 * 3 + (-1) * 5) /
+          (std::sqrt(1 + 4 + 1) * std::sqrt(1 + 9 + 25)),
+      cosineSimilarity({{1, 2, -1}}, {{1, 3, 5}}),
+      1e-6);
+
+  EXPECT_TRUE(std::isnan(cosineSimilarity({}, {})));
+  VELOX_ASSERT_THROW(
+      cosineSimilarity({1, 3}, {}), "Both arrays need to have identical size");
+  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {0, 0})));
+  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {kNanFloat, 1})));
+  EXPECT_TRUE(std::isnan(cosineSimilarity({1, 3}, {kInfFloat, 1})));
+}
+
+TEST_F(DistanceFunctionsTest, l2SquaredFunctionFloatArray) {
+  const auto l2Squared = [&](const std::vector<float>& left,
+                             const std::vector<float>& right) {
+    auto leftArray = makeArrayVector<float>({left});
+    auto rightArray = makeArrayVector<float>({right});
+    return evaluateOnce<float>(
+               "l2_squared(c0,c1)", makeRowVector({leftArray, rightArray}))
+        .value();
+  };
+
+  EXPECT_NEAR(
+      (1.234 - 2.345) * (1.234 - 2.345) + (2.456 - 3.567) * (2.456 - 3.567),
+      l2Squared({1.234, 2.456}, {2.345, 3.567}),
+      1e-6);
+  EXPECT_NEAR(
+      (1.789 - 4.012) * (1.789 - 4.012) + (2.345 * 2.345) +
+          (-1.678 - 5.901) * (-1.678 - 5.901),
+      l2Squared({1.789, 2.345, -1.678}, {4.012, 0.0, 5.901}),
+      1e-5);
+  EXPECT_TRUE(std::isnan(l2Squared({}, {})));
+  VELOX_ASSERT_THROW(
+      l2Squared({1.234, 3.456}, {}), "Both arrays need to have identical size");
+}
+
+TEST_F(DistanceFunctionsTest, l2SquaredFunctionDoubleArray) {
+  const auto l2Squared = [&](const std::vector<double>& left,
+                             const std::vector<double>& right) {
+    auto leftArray = makeArrayVector<double>({left});
+    auto rightArray = makeArrayVector<double>({right});
+    return evaluateOnce<double>(
+               "l2_squared(c0,c1)", makeRowVector({leftArray, rightArray}))
+        .value();
+  };
+
+  EXPECT_NEAR(
+      (1.5 - 2.3) * (1.5 - 2.3) + (2.7 - 3.8) * (2.7 - 3.8),
+      l2Squared({1.5, 2.7}, {2.3, 3.8}),
+      1e-6);
+  EXPECT_NEAR(
+      (1.1 - 4.2) * (1.1 - 4.2) + (2.5 * 2.5) + (-1.3 - 5.6) * (-1.3 - 5.6),
+      l2Squared({1.1, 2.5, -1.3}, {4.2, 0.0, 5.6}),
+      1e-5);
+  EXPECT_TRUE(std::isnan(l2Squared({}, {})));
+  VELOX_ASSERT_THROW(
+      l2Squared({1.0, 3.0}, {}), "Both arrays need to have identical size");
+}
+
+TEST_F(DistanceFunctionsTest, dotProductFloatArray) {
+  const auto dotProduct = [&](const std::vector<float>& left,
+                              const std::vector<float>& right) {
+    auto leftArray = makeArrayVector<float>({left});
+    auto rightArray = makeArrayVector<float>({right});
+    return evaluateOnce<float>(
+               "dot_product(c0,c1)", makeRowVector({leftArray, rightArray}))
+        .value();
+  };
+  EXPECT_NEAR((1 * 1 + 2 * 3), dotProduct({{1, 2}}, {{1, 3}}), 1e-6);
+
+  EXPECT_NEAR(
+      (1 * 1 + 2 * 3 + (-1) * 5), dotProduct({{1, 2, -1}}, {{1, 3, 5}}), 1e-6);
+
+  EXPECT_TRUE(std::isnan(dotProduct({}, {})));
+  VELOX_ASSERT_THROW(
+      dotProduct({1, 3}, {}), "Both array arguments must have identical sizes");
+}
+#endif // VELOX_ENABLE_FAISS
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/ElementAtTest.cpp b/velox/functions/prestosql/tests/ElementAtTest.cpp
index 6b8d3f976792..292995c0cd86 100644
--- a/velox/functions/prestosql/tests/ElementAtTest.cpp
+++ b/velox/functions/prestosql/tests/ElementAtTest.cpp
@@ -232,6 +232,248 @@ TEST_F(ElementAtTest, mapWithDictionaryKeys) {
   }
 }
 
+TEST_F(ElementAtTest, flatMapTest) {
+  // Null map.
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {makeFlatMapVectorFromJson<int64_t, int32_t>({"null"})})));
+
+  // Empty map.
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {makeFlatMapVectorFromJson<int64_t, int32_t>({"{}"})})));
+
+  // Single row.
+  test::assertEqualVectors(
+      makeFlatVector<int32_t>({10}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector({makeFlatMapVectorFromJson<int64_t, int32_t>(
+              {"{1:10, 2:20, 4:40, 5:50, 6:60}"})})));
+
+  // Multiple rows.
+  auto input = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{1:11, 4:41}",
+      "{}",
+      "{2:23, 4:43}",
+  });
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate("element_at(c0, 1)", makeRowVector({input})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({40, 41, std::nullopt, 43}),
+      evaluate("element_at(c0, 4)", makeRowVector({input})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>(
+          {50, std::nullopt, std::nullopt, std::nullopt}),
+      evaluate("element_at(c0, 5)", makeRowVector({input})));
+  // Key doesn't exist
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, std::nullopt, std::nullopt, std::nullopt}),
+      evaluate("element_at(c0, 7)", makeRowVector({input})));
+  // Column elementAt
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector({input, makeConstant<int32_t>(1, 4)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({20, 11, std::nullopt, 43}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector({input, makeFlatVector<int32_t>({2, 1, 1, 4})})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {input,
+               BaseVector::wrapInConstant(
+                   4, 0, makeFlatVector<int32_t>({1, 2, 3, 4}))})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({20, std::nullopt, std::nullopt, 23}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {input,
+               BaseVector::wrapInConstant(
+                   4, 1, makeFlatVector<int32_t>({1, 2, 3, 4}))})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>(
+          {std::nullopt, std::nullopt, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {input,
+               BaseVector::wrapInConstant(
+                   4, 2, makeFlatVector<int32_t>({1, 2, 3, 4}))})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({40, 41, std::nullopt, 43}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {input,
+               BaseVector::wrapInConstant(
+                   4, 3, makeFlatVector<int32_t>({1, 2, 3, 4}))})));
+}
+
+TEST_F(ElementAtTest, flatMapTestDictionaryWrapped) {
+  vector_size_t size = 4, halved = 2;
+
+  auto base = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{1:11, 4:41}",
+      "{}",
+      "{2:23, 4:43}",
+  });
+
+  auto same = [](vector_size_t row) { return row; };
+  auto shifted = [](auto row) { return (row + 2) % 4; };
+
+  // Same size between base vector and wrapped dictionary vector.
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, same), size, base)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt, 10, 11}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, shifted), size, base)})));
+
+  // Cardinality mismatch between wrapped vector and base.
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, same), halved, base)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, shifted), halved, base)})));
+
+  // Column elementAt
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11, std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, same), size, base),
+               makeConstant<int32_t>(1, size)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, std::nullopt, std::nullopt, 43}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, same), size, base),
+               makeFlatVector<int32_t>({1, 2, 3, 4})})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt, 10, 11}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, shifted), size, base),
+               makeConstant<int32_t>(1, size)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, 23, std::nullopt, 41}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(size, shifted), size, base),
+               makeFlatVector<int32_t>({1, 2, 3, 4})})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, 11}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, same), halved, base),
+               makeConstant<int32_t>(1, halved)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({10, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, same), halved, base),
+               makeFlatVector<int32_t>({1, 2})})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, std::nullopt}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, shifted), halved, base),
+               makeConstant<int32_t>(1, halved)})));
+  test::assertEqualVectors(
+      makeNullableFlatVector<int32_t>({std::nullopt, 23}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {wrapInDictionary(makeIndices(halved, shifted), halved, base),
+               makeFlatVector<int32_t>({1, 2})})));
+}
+
+TEST_F(ElementAtTest, flatMapTestConstantWrapped) {
+  auto base = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{1:11, 4:41}",
+      "{}",
+      "{2:23, 4:43}",
+  });
+  test::assertEqualVectors(
+      makeConstant<int32_t>(10, 10),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector({BaseVector::wrapInConstant(10, 0, base)})));
+  test::assertEqualVectors(
+      makeConstant<int32_t>(11, 10),
+      evaluate(
+          "element_at(c0, 1)",
+          makeRowVector({BaseVector::wrapInConstant(10, 1, base)})));
+  test::assertEqualVectors(
+      makeConstant<int32_t>(10, 10),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {BaseVector::wrapInConstant(10, 0, base),
+               makeConstant<int32_t>(1, 10)})));
+  test::assertEqualVectors(
+      makeConstant<int32_t>(10, 10),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {BaseVector::wrapInConstant(10, 0, base),
+               BaseVector::wrapInConstant(
+                   10, 0, makeFlatVector<int32_t>({1, 2}))})));
+  test::assertEqualVectors(
+      makeConstant<int32_t>(20, 10),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {BaseVector::wrapInConstant(10, 0, base),
+               BaseVector::wrapInConstant(
+                   10, 1, makeFlatVector<int32_t>({1, 2}))})));
+  test::assertEqualVectors(
+      makeFlatVector<int32_t>({10, 20}),
+      evaluate(
+          "element_at(c0, c1)",
+          makeRowVector(
+              {BaseVector::wrapInConstant(2, 0, base),
+               makeFlatVector<int32_t>({1, 2})})));
+}
+
 TEST_F(ElementAtTest, arrayWithDictionaryElements) {
   {
     auto elementsIndices = makeIndices({6, 5, 4, 3, 2, 1, 0});
@@ -295,33 +537,44 @@ TEST_F(ElementAtTest, constantInputArray) {
 // #2 - allow out of bounds access for array and map.
 // #3 - allow negative indices.
 TEST_F(ElementAtTest, allFlavors1) {
-  // Case 1: Simple arrays and maps
-  auto arrayVector = makeArrayVector<int64_t>({{10, 11, 12}});
-  auto mapVector = getSimpleMapVector();
-
-  // #1
-  VELOX_ASSERT_THROW(
-      elementAtSimple("element_at(C0, 0)", {arrayVector}),
-      "SQL array indices start at 1");
+  // Case 1: Simple arrays and maps (also test constant inputs)
+  auto simpleArray = makeArrayVector<int64_t>({{10, 11, 12}});
+  auto simpleMap = getSimpleMapVector();
+
+  for (bool wrapInConstant : {false, true}) {
+    auto arrayVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleArray)
+        : simpleArray;
+    auto mapVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleMap)
+        : simpleMap;
+    // #1
+    VELOX_ASSERT_THROW(
+        elementAtSimple("element_at(C0, 0)", {arrayVector}),
+        "SQL array indices start at 1. Got 0.");
 
-  EXPECT_EQ(
-      elementAtSimple("try(element_at(C0, 0))", {arrayVector}), std::nullopt);
+    EXPECT_EQ(
+        elementAtSimple("try(element_at(C0, 0))", {arrayVector}), std::nullopt);
 
-  EXPECT_EQ(elementAtSimple("element_at(C0, 1)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("element_at(C0, 2)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("element_at(C0, 3)", {arrayVector}), 12);
+    EXPECT_EQ(elementAtSimple("element_at(C0, 1)", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("element_at(C0, 2)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("element_at(C0, 3)", {arrayVector}), 12);
 
-  // #2
-  EXPECT_EQ(elementAtSimple("element_at(C0, 4)", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("element_at(C0, 5)", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("element_at(C0, 1001)", {mapVector}), std::nullopt);
-
-  // #3
-  EXPECT_EQ(elementAtSimple("element_at(C0, -1)", {arrayVector}), 12);
-  EXPECT_EQ(elementAtSimple("element_at(C0, -2)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("element_at(C0, -3)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("element_at(C0, -4)", {arrayVector}), std::nullopt);
+    // #2
+    EXPECT_EQ(
+        elementAtSimple("element_at(C0, 4)", {arrayVector}), std::nullopt);
+    EXPECT_EQ(
+        elementAtSimple("element_at(C0, 5)", {arrayVector}), std::nullopt);
+    EXPECT_EQ(
+        elementAtSimple("element_at(C0, 1001)", {mapVector}), std::nullopt);
 
+    // #3
+    EXPECT_EQ(elementAtSimple("element_at(C0, -1)", {arrayVector}), 12);
+    EXPECT_EQ(elementAtSimple("element_at(C0, -2)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("element_at(C0, -3)", {arrayVector}), 10);
+    EXPECT_EQ(
+        elementAtSimple("element_at(C0, -4)", {arrayVector}), std::nullopt);
+  }
   // Case 2: Empty values vector
   auto emptyValues = makeFlatVector<int64_t>({});
   auto emptyKeys = makeFlatVector<int64_t>(std::vector<int64_t>{1});
@@ -341,7 +594,7 @@ TEST_F(ElementAtTest, allFlavors1) {
   // #1
   VELOX_ASSERT_THROW(
       elementAtSimple("element_at(C0, 0)", {emptyValuesArray}),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   EXPECT_EQ(
@@ -371,7 +624,7 @@ TEST_F(ElementAtTest, allFlavors1) {
   // #1
   VELOX_ASSERT_THROW(
       elementAtSimple("element_at(C0, 0)", {emptyContainerNonEmptyValuesArray}),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   EXPECT_EQ(
@@ -418,7 +671,7 @@ TEST_F(ElementAtTest, allFlavors1) {
           makeRowVector({partiallyEmptyArray}),
           rows,
           result),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   auto expected = makeNullConstant(TypeKind::BIGINT, 1);
@@ -441,42 +694,52 @@ TEST_F(ElementAtTest, allFlavors1) {
 // #2 - do not allow out of bounds access for arrays.
 // #3 - do not allow negative indices.
 TEST_F(ElementAtTest, allFlavors2) {
-  // Case 1: Simple arrays and maps
-  auto arrayVector = makeArrayVector<int64_t>({{10, 11, 12}});
-  auto mapVector = getSimpleMapVector();
-
-  // #1
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[0]", {arrayVector}), "SQL array indices start at 1");
-
-  EXPECT_EQ(elementAtSimple("try(C0[0])", {arrayVector}), std::nullopt);
-
-  EXPECT_EQ(elementAtSimple("C0[1]", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("C0[2]", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("C0[3]", {arrayVector}), 12);
-
-  // #2
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[4]", {arrayVector}),
-      "Array subscript out of bounds.");
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[5]", {arrayVector}),
-      "Array subscript out of bounds.");
-
-  EXPECT_EQ(elementAtSimple("try(C0[4])", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("try(C0[5])", {arrayVector}), std::nullopt);
-
-  // Maps are ok.
-  EXPECT_EQ(elementAtSimple("C0[1001]", {mapVector}), std::nullopt);
-
-  // #3
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[-1]", {arrayVector}), "Array subscript is negative.");
-  VELOX_ASSERT_THROW(
-      elementAtSimple("C0[-4]", {arrayVector}), "Array subscript is negative.");
-
-  EXPECT_EQ(elementAtSimple("try(C0[-1])", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("try(C0[-4])", {arrayVector}), std::nullopt);
+  // Case 1: Simple arrays and maps (also test constant inputs)
+  auto simpleArray = makeArrayVector<int64_t>({{10, 11, 12}});
+  auto simpleMap = getSimpleMapVector();
+  for (bool wrapInConstant : {false, true}) {
+    auto arrayVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleArray)
+        : simpleArray;
+    auto mapVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleMap)
+        : simpleMap;
+    // #1
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[0]", {arrayVector}),
+        "SQL array indices start at 1. Got 0.");
+
+    EXPECT_EQ(elementAtSimple("try(C0[0])", {arrayVector}), std::nullopt);
+
+    EXPECT_EQ(elementAtSimple("C0[1]", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("C0[2]", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("C0[3]", {arrayVector}), 12);
+
+    // #2
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[4]", {arrayVector}),
+        "Array subscript index out of bounds, Index: 4 Array size: 3");
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[5]", {arrayVector}),
+        "Array subscript index out of bounds, Index: 5 Array size: 3");
+
+    EXPECT_EQ(elementAtSimple("try(C0[4])", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("try(C0[5])", {arrayVector}), std::nullopt);
+
+    // Maps are ok.
+    EXPECT_EQ(elementAtSimple("C0[1001]", {mapVector}), std::nullopt);
+
+    // #3
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[-1]", {arrayVector}),
+        "Array subscript index cannot be negative, Index: -1");
+    VELOX_ASSERT_THROW(
+        elementAtSimple("C0[-4]", {arrayVector}),
+        "Array subscript index cannot be negative, Index: -4");
+
+    EXPECT_EQ(elementAtSimple("try(C0[-1])", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("try(C0[-4])", {arrayVector}), std::nullopt);
+  }
 
   // Case 2: Empty values vector
   auto emptyValues = makeFlatVector<int64_t>({});
@@ -497,19 +760,20 @@ TEST_F(ElementAtTest, allFlavors2) {
   // #1
   VELOX_ASSERT_THROW(
       elementAtSimple("C0[0]", {emptyValuesArray}),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   VELOX_ASSERT_THROW(
-      elementAtSimple("C0[4]", {arrayVector}),
-      "Array subscript out of bounds.");
+      elementAtSimple("C0[4]", {emptyValuesArray}),
+      "Array subscript index out of bounds, Index: 4 Array size: 0");
   EXPECT_EQ(elementAtSimple("try(C0[4])", {emptyValuesArray}), std::nullopt);
   // Maps are ok.
   EXPECT_EQ(elementAtSimple("C0[1001]", {emptyValuesMap}), std::nullopt);
 
   // #3
   VELOX_ASSERT_THROW(
-      elementAtSimple("C0[-1]", {arrayVector}), "Array subscript is negative.");
+      elementAtSimple("C0[-1]", {emptyValuesArray}),
+      "Array subscript index cannot be negative, Index: -1");
 
   // Case 3: Empty individual arrays/maps and non-empty values vector
   auto nonEmptyValues = makeFlatVector<int64_t>(std::vector<int64_t>{2});
@@ -529,12 +793,12 @@ TEST_F(ElementAtTest, allFlavors2) {
   // #1
   VELOX_ASSERT_THROW(
       elementAtSimple("C0[0]", {emptyContainerNonEmptyValuesArray}),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   VELOX_ASSERT_THROW(
       elementAtSimple("C0[4]", {emptyContainerNonEmptyValuesArray}),
-      "Array subscript out of bounds.");
+      "Array subscript index out of bounds, Index: 4 Array size: 0");
   EXPECT_EQ(
       elementAtSimple("try(C0[4])", {emptyContainerNonEmptyValuesArray}),
       std::nullopt);
@@ -546,7 +810,7 @@ TEST_F(ElementAtTest, allFlavors2) {
   // #3
   VELOX_ASSERT_THROW(
       elementAtSimple("C0[-1]", {emptyContainerNonEmptyValuesArray}),
-      "Array subscript is negative.");
+      "Array subscript index cannot be negative, Index: -1");
 
   // Case 4: Intermittently empty individual arrays/maps and non-empty values
   // vector
@@ -576,13 +840,13 @@ TEST_F(ElementAtTest, allFlavors2) {
   VELOX_ASSERT_THROW(
       evaluate<SimpleVector<int64_t>>(
           "C0[0]", makeRowVector({partiallyEmptyArray}), rows, result),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   // #2
   VELOX_ASSERT_THROW(
       evaluate<SimpleVector<int64_t>>(
           "C0[4]", makeRowVector({partiallyEmptyArray}), rows, result),
-      "Array subscript out of bounds.");
+      "Array subscript index out of bounds, Index: 4 Array size: 0");
   auto expected = makeNullConstant(TypeKind::BIGINT, 1);
   evaluate<SimpleVector<int64_t>>(
       "try(C0[4])", makeRowVector({partiallyEmptyArray}), rows, result);
@@ -596,7 +860,7 @@ TEST_F(ElementAtTest, allFlavors2) {
   VELOX_ASSERT_THROW(
       evaluate<SimpleVector<int64_t>>(
           "C0[-1]", makeRowVector({partiallyEmptyArray}), rows, result),
-      "Array subscript is negative.");
+      "Array subscript index cannot be negative, Index: -1");
 }
 
 // Third flavor:
@@ -604,41 +868,49 @@ TEST_F(ElementAtTest, allFlavors2) {
 // #2 - do not allow out of bound access for arrays (throw).
 // #3 - null on negative indices.
 TEST_F(ElementAtTest, allFlavors3) {
-  auto arrayVector = makeArrayVector<int64_t>({{10, 11, 12}});
-  auto mapVector = getSimpleMapVector();
+  auto simpleArray = makeArrayVector<int64_t>({{10, 11, 12}});
+  auto simpleMap = getSimpleMapVector();
 
   exec::registerVectorFunction(
       "__f2",
       SubscriptImpl<false, true, false, false>::signatures(),
       std::make_unique<SubscriptImpl<false, true, false, false>>(false));
+  for (bool wrapInConstant : {false, true}) {
+    auto arrayVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleArray)
+        : simpleArray;
+    auto mapVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleMap)
+        : simpleMap;
+    // #1
+    EXPECT_EQ(elementAtSimple("__f2(C0, 0)", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("__f2(C0, 1)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("__f2(C0, 2)", {arrayVector}), 12);
+
+    // #2
+    VELOX_ASSERT_THROW(
+        elementAtSimple("__f2(C0, 3)", {arrayVector}),
+        "Array subscript index out of bounds, Index: 3 Array size: 3");
+    VELOX_ASSERT_THROW(
+        elementAtSimple("__f2(C0, 4)", {arrayVector}),
+        "Array subscript index out of bounds, Index: 4 Array size: 3");
+    VELOX_ASSERT_THROW(
+        elementAtSimple("__f2(C0, 100)", {arrayVector}),
+        "Array subscript index out of bounds, Index: 100 Array size: 3");
+
+    EXPECT_EQ(elementAtSimple("try(__f2(C0, 3))", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("try(__f2(C0, 4))", {arrayVector}), std::nullopt);
+    EXPECT_EQ(
+        elementAtSimple("try(__f2(C0, 100))", {arrayVector}), std::nullopt);
 
-  // #1
-  EXPECT_EQ(elementAtSimple("__f2(C0, 0)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("__f2(C0, 1)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("__f2(C0, 2)", {arrayVector}), 12);
-
-  // #2
-  VELOX_ASSERT_THROW(
-      elementAtSimple("__f2(C0, 3)", {arrayVector}),
-      "Array subscript out of bounds.");
-  VELOX_ASSERT_THROW(
-      elementAtSimple("__f2(C0, 4)", {arrayVector}),
-      "Array subscript out of bounds.");
-  VELOX_ASSERT_THROW(
-      elementAtSimple("__f2(C0, 100)", {arrayVector}),
-      "Array subscript out of bounds.");
-
-  EXPECT_EQ(elementAtSimple("try(__f2(C0, 3))", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("try(__f2(C0, 4))", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("try(__f2(C0, 100))", {arrayVector}), std::nullopt);
-
-  // We still allow non-existent map keys, even if out of bounds is disabled for
-  // arrays.
-  EXPECT_EQ(elementAtSimple("__f2(C0, 1001)", {mapVector}), std::nullopt);
+    // We still allow non-existent map keys, even if out of bounds is disabled
+    // for arrays.
+    EXPECT_EQ(elementAtSimple("__f2(C0, 1001)", {mapVector}), std::nullopt);
 
-  // #3
-  EXPECT_EQ(elementAtSimple("__f2(C0, -1)", {mapVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("__f2(C0, -5)", {mapVector}), std::nullopt);
+    // #3
+    EXPECT_EQ(elementAtSimple("__f2(C0, -1)", {mapVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("__f2(C0, -5)", {mapVector}), std::nullopt);
+  }
 }
 
 // Fourth flavor:
@@ -646,25 +918,32 @@ TEST_F(ElementAtTest, allFlavors3) {
 // #2 - allow out of bound access (throw).
 // #3 - allow negative indices.
 TEST_F(ElementAtTest, allFlavors4) {
-  auto arrayVector = makeArrayVector<int64_t>({{10, 11, 12}});
-  auto mapVector = getSimpleMapVector();
+  auto simpleArray = makeArrayVector<int64_t>({{10, 11, 12}});
+  auto simpleMap = getSimpleMapVector();
 
   exec::registerVectorFunction(
       "__f3",
       SubscriptImpl<true, false, true, false>::signatures(),
       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);
-  EXPECT_EQ(elementAtSimple("__f3(C0, 2)", {arrayVector}), 12);
-  EXPECT_EQ(elementAtSimple("__f3(C0, 3)", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("__f3(C0, 4)", {arrayVector}), std::nullopt);
-  EXPECT_EQ(elementAtSimple("__f3(C0, -1)", {arrayVector}), 12);
-  EXPECT_EQ(elementAtSimple("__f3(C0, -2)", {arrayVector}), 11);
-  EXPECT_EQ(elementAtSimple("__f3(C0, -3)", {arrayVector}), 10);
-  EXPECT_EQ(elementAtSimple("__f3(C0, -4)", {arrayVector}), std::nullopt);
-
-  EXPECT_EQ(elementAtSimple("__f3(C0, 1001)", {mapVector}), std::nullopt);
+  for (bool wrapInConstant : {false, true}) {
+    auto arrayVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleArray)
+        : simpleArray;
+    auto mapVector = wrapInConstant
+        ? BaseVector::wrapInConstant(1, 0, simpleMap)
+        : simpleMap;
+    EXPECT_EQ(elementAtSimple("__f3(C0, 0)", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("__f3(C0, 1)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("__f3(C0, 2)", {arrayVector}), 12);
+    EXPECT_EQ(elementAtSimple("__f3(C0, 3)", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("__f3(C0, 4)", {arrayVector}), std::nullopt);
+    EXPECT_EQ(elementAtSimple("__f3(C0, -1)", {arrayVector}), 12);
+    EXPECT_EQ(elementAtSimple("__f3(C0, -2)", {arrayVector}), 11);
+    EXPECT_EQ(elementAtSimple("__f3(C0, -3)", {arrayVector}), 10);
+    EXPECT_EQ(elementAtSimple("__f3(C0, -4)", {arrayVector}), std::nullopt);
+
+    EXPECT_EQ(elementAtSimple("__f3(C0, 1001)", {mapVector}), std::nullopt);
+  }
 }
 
 TEST_F(ElementAtTest, constantInputMap) {
@@ -1023,7 +1302,7 @@ TEST_F(ElementAtTest, errorStatesArray) {
   VELOX_ASSERT_THROW(
       testElementAt<int64_t>(
           "element_at(C0, C1)", {arrayVector, indicesVector}, expectedValueAt),
-      "SQL array indices start at 1");
+      "SQL array indices start at 1. Got 0.");
 
   testElementAt<int64_t>(
       "try(element_at(C0, C1))",
@@ -1176,6 +1455,46 @@ TEST_F(ElementAtTest, testCachingOptimization) {
   }
 }
 
+TEST_F(ElementAtTest, testCachingOptimizationNonZeroOffset) {
+  // Test the case where the input map has a non-zero offset when caching is
+  // enabled.
+
+  // Make a dummy eval context.
+  exec::ExprSet exprSet({}, &execCtx_);
+  auto inputs = makeRowVector({});
+  exec::EvalCtx evalCtx(&execCtx_, &exprSet, inputs.get());
+
+  SelectivityVector rows(1);
+  auto key = makeArrayVectorFromJson<int64_t>({"[1]", "[2]"});
+  auto value = makeFlatVector<int64_t>({10, 20});
+  // The map's offset is 1 (non-zero).
+  auto map = makeMapVector({1}, key, value);
+  auto search = makeArrayVectorFromJson<int64_t>({"[2]"});
+
+  std::vector<VectorPtr> args = {map, search};
+
+  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);
+
+  mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  auto result = mapSubscriptWithCaching.applyMap(rows, args, evalCtx);
+  test::assertEqualVectors(
+      makeFlatVector<int64_t>(1, [](auto) { return 20; }), result);
+}
+
 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
@@ -1248,8 +1567,9 @@ TEST_F(ElementAtTest, testCachingOptimizationComplexKey) {
     for (int i = 0; i < keysVector->size(); i += 3) {
       EXPECT_NE(
           cachedMap.end(),
-          cachedMap.find(facebook::velox::functions::detail::MapKey{
-              keysVector.get(), 0, 0}));
+          cachedMap.find(
+              facebook::velox::functions::detail::MapKey{
+                  keysVector.get(), 0, 0}));
     }
   };
 
diff --git a/velox/functions/prestosql/tests/EnumFunctionsTest.cpp b/velox/functions/prestosql/tests/EnumFunctionsTest.cpp
new file mode 100644
index 000000000000..5a81d6ccf6d8
--- /dev/null
+++ b/velox/functions/prestosql/tests/EnumFunctionsTest.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 "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox::functions::test;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class EnumFunctionsTest : public FunctionBaseTest {
+ protected:
+  void SetUp() override {
+    FunctionBaseTest::SetUp();
+  }
+  std::optional<std::string> enumKey(
+      std::optional<int64_t> val,
+      TypePtr inputType) {
+    return evaluateOnce<std::string>("enum_key(c0)", inputType, val);
+  }
+
+  std::optional<std::string> enumKey(
+      std::optional<std::string> val,
+      TypePtr inputType) {
+    return evaluateOnce<std::string>("enum_key(c0)", inputType, std::move(val));
+  }
+};
+
+TEST_F(EnumFunctionsTest, enumKeyBigintEnum) {
+  LongEnumParameter moodInfo("test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
+  auto bigintEnum = BIGINT_ENUM(moodInfo);
+
+  EXPECT_EQ("CURIOUS", enumKey(-2, bigintEnum));
+  EXPECT_EQ(std::nullopt, enumKey(std::optional<int64_t>{}, bigintEnum));
+
+  VELOX_ASSERT_THROW(
+      enumKey(1, bigintEnum),
+      "Value '1' not in BigintEnum: test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0})");
+
+  VELOX_ASSERT_THROW(
+      enumKey(1, BIGINT()),
+      "Scalar function signature is not supported: enum_key(BIGINT). Supported signatures: (varchar_enum(E1)) -> varchar, (bigint_enum(E1)) -> varchar.");
+
+  VELOX_ASSERT_THROW(
+      evaluateOnce<std::string>(
+          "enum_key(c0, c1)",
+          {bigintEnum, BIGINT()},
+          std::optional<int64_t>(0),
+          std::optional<int64_t>(5)),
+      "Scalar function signature is not supported: enum_key(test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0}), BIGINT). Supported signatures: (varchar_enum(E1)) -> varchar, (bigint_enum(E1)) -> varchar.");
+}
+
+TEST_F(EnumFunctionsTest, enumKeyVarcharEnum) {
+  VarcharEnumParameter colorInfo(
+      "test.enum.color",
+      {{"RED", "red_value"}, {"BLUE", "blue_value"}, {"GREEN", "green_value"}});
+  auto varcharEnum = VARCHAR_ENUM(colorInfo);
+
+  EXPECT_EQ("RED", enumKey("red_value", varcharEnum));
+  EXPECT_EQ(std::nullopt, enumKey(std::optional<std::string>{}, varcharEnum));
+
+  VELOX_ASSERT_THROW(
+      enumKey("non-existent value", varcharEnum),
+      "Value 'non-existent value' not in VarcharEnum: test.enum.color:VarcharEnum({\"BLUE\": \"blue_value\", \"GREEN\": \"green_value\", \"RED\": \"red_value\"})");
+
+  VELOX_ASSERT_THROW(
+      enumKey("red_value", VARCHAR()),
+      "Scalar function signature is not supported: enum_key(VARCHAR). Supported signatures: (varchar_enum(E1)) -> varchar, (bigint_enum(E1)) -> varchar.");
+
+  VELOX_ASSERT_THROW(
+      evaluateOnce<std::string>(
+          "enum_key(c0, c1)",
+          {varcharEnum, BIGINT()},
+          std::optional<std::string>("red_value"),
+          std::optional<int64_t>(5)),
+      "Scalar function signature is not supported: enum_key(test.enum.color:VarcharEnum({\"BLUE\": \"blue_value\", \"GREEN\": \"green_value\", \"RED\": \"red_value\"}), BIGINT). Supported signatures: (varchar_enum(E1)) -> varchar, (bigint_enum(E1)) -> varchar.");
+}
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/GeometryFunctionsTest.cpp b/velox/functions/prestosql/tests/GeometryFunctionsTest.cpp
index fa307e631af9..cc55eb732faf 100644
--- a/velox/functions/prestosql/tests/GeometryFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/GeometryFunctionsTest.cpp
@@ -17,9 +17,14 @@
 #include <gtest/gtest.h>
 #include <array>
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/geospatial/GeometryConstants.h"
+#include "velox/common/testutil/OptionalEmpty.h"
+#include "velox/functions/prestosql/tests/resources/GeometryTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 
 using facebook::velox::functions::test::FunctionBaseTest;
+using namespace facebook::velox;
+using namespace facebook::velox::common::geospatial;
 
 class GeometryFunctionsTest : public FunctionBaseTest {
  public:
@@ -56,6 +61,10 @@ class GeometryFunctionsTest : public FunctionBaseTest {
       "POINT (2 0.5)" // 7
   };
 
+  // Complex input polygon
+  static constexpr const char* largeWkt =
+      "MULTIPOLYGON (((-106.8668100 39.4333730, -106.8639910 39.4335190, -106.8622250 39.4336220, -106.8568070 39.4341570, -106.8567080 39.4341240, -106.8563840 39.4340160, -106.8559870 39.4342060, -106.8556890 39.4342510, -106.8553310 39.4342150, -106.8548870 39.4343270, -106.8545630 39.4344820, -106.8543240 39.4348160, -106.8541650 39.4349460, -106.8537070 39.4348980, -106.8532490 39.4348090, -106.8528780 39.4348840, -106.8526660 39.4350520, -106.8521110 39.4353510, -106.8514920 39.4357270, -106.8513320 39.4358650, -106.8510130 39.4359010, -106.8507060 39.4358990, -106.8504900 39.4359460, -106.8501740 39.4361500, -106.8498650 39.4361950, -106.8494020 39.4362500, -106.8488510 39.4364700, -106.8484010 39.4366930, -106.8478530 39.4368080, -106.8472030 39.4369370, -106.8468210 39.4370190, -106.8464930 39.4373020, -106.8463150 39.4376380, -106.8461720 39.4378800, -106.8460790 39.4381310, -106.8454250 39.4383640, -106.8452490 39.4386370, -106.8448210 39.4388440, -106.8442480 39.4390950, -106.8439600 39.4393710, -106.8437970 39.4396810, -106.8433000 39.4403780, -106.8435170 39.4408920, -106.8432390 39.4415700, -106.8429990 39.4419930, -106.8427580 39.4427570, -106.8426530 39.4431050, -106.8426130 39.4433350, -106.8425690 39.4438310, -106.8424250 39.4440780, -106.8423390 39.4442090, -106.8420210 39.4445630, -106.8421780 39.4449090, -106.8421790 39.4465380, -106.8426620 39.4482500, -106.8428010 39.4511016, -106.8429860 39.4540610, -106.8430810 39.4543610, -106.8436780 39.4551190, -106.8414510 39.4552500, -106.8292410 39.4553950, -106.8161060 39.4561950, -106.8050950 39.4561240, -106.7940650 39.4560720, -106.7870330 39.4560790, -106.7773920 39.4560940, -106.7646640 39.4564290, -106.7516710 39.4564950, -106.7486050 39.4565240, -106.7480860 39.4569030, -106.7476970 39.4575880, -106.7476300 39.4604340, -106.7472420 39.4612370, -106.7467300 39.4616880, -106.7462291 39.4618463, -106.7452780 39.4621470, -106.7450691 39.4622613, -106.7448850 39.4623620, -106.7437120 39.4636410, -106.7428740 39.4649650, -106.7427550 39.4652710, -106.7427600 39.4659540, -106.7431010 39.4666560, -106.7422856 39.4694222, -106.7421175 39.4693936, -106.7419082 39.4693894, -106.7416776 39.4694308, -106.7414168 39.4695313, -106.7411808 39.4697052, -106.7409286 39.4698708, -106.7404673 39.4700738, -106.7403064 39.4701193, -106.7401293 39.4701400, -106.7398987 39.4701796, -106.7416770 39.4712450, -106.7434880 39.4722230, -106.7442150 39.4726370, -106.7465272 39.4740356, -106.7483535 39.4751444, -106.7499620 39.4761650, -106.7506860 39.4766040, -106.7524547 39.4775919, -106.7533244 39.4780915, -106.7576840 39.4806170, -106.7625610 39.4844450, -106.7692930 39.4882140, -106.7714778 39.4882466, -106.7714501 39.4884412, -106.7713390 39.4886050, -106.7712623 39.4888801, -106.7712275 39.4893189, -106.7712355 39.4896749, -106.7712650 39.4899751, -106.7713643 39.4902794, -106.7714635 39.4904470, -106.7718337 39.4909086, -106.7719544 39.4910390, -106.7720724 39.4910887, -106.7721984 39.4911011, -106.7724935 39.4910473, -106.7727420 39.4909450, -106.7729792 39.4908918, -106.7732606 39.4908279, -106.7735556 39.4908031, -106.7739285 39.4908155, -106.7744880 39.4908880, -106.7748565 39.4909956, -106.7749665 39.4910804, -106.7750412 39.4912573, -106.7750228 39.4913992, -106.7749209 39.4917242, -106.7748833 39.4918463, -106.7748640 39.4919546, -106.7748753 39.4920429, -106.7749745 39.4921444, -106.7751740 39.4922200, -106.7747790 39.4928870, -106.7745190 39.4932210, -106.7744375 39.4933878, -106.7744347 39.4934229, -106.7744420 39.4934780, -106.7744930 39.4935371, -106.7745663 39.4935730, -106.7746238 39.4935841, -106.7748380 39.4935240, -106.7752640 39.4931430, -106.7755880 39.4928960, -106.7761480 39.4926340, -106.7766270 39.4924950, -106.7769950 39.4924670, -106.7775070 39.4925360, -106.7783440 39.4925670, -106.7791410 39.4926640, -106.7800360 39.4927710, -106.7807870 39.4929610, -106.7811500 39.4930730, -106.7817260 39.4934160, -106.7827480 39.4940380, -106.7833950 39.4943910, -106.7837790 39.4944290, -106.7840770 39.4944470, -106.7843340 39.4945090, -106.7845490 39.4946160, -106.7849540 39.4949060, -106.7855630 39.4954470, -106.7857500 39.4955540, -106.7860640 39.4956150, -106.7867610 39.4957030, -106.7875420 39.4957680, -106.7879550 39.4958610, -106.7882680 39.4959000, -106.7888050 39.4958260, -106.7890330 39.4958440, -106.7894340 39.4959920, -106.7899350 39.4961820, -106.7904920 39.4963490, -106.7908900 39.4963980, -106.7918750 39.4966580, -106.7931310 39.4969910, -106.7933480 39.4971630, -106.7935390 39.4974130, -106.7936930 39.4978950, -106.7937910 39.4984110, -106.7939310 39.4994320, -106.7939500 39.4999360, -106.7940420 39.5001980, -106.7940840 39.5007240, -106.7940660 39.5011190, -106.7941540 39.5012600, -106.7944000 39.5014430, -106.7950870 39.5016950, -106.7960470 39.5020640, -106.7963250 39.5024000, -106.7968450 39.5027970, -106.7970780 39.5030130, -106.7972560 39.5033280, -106.7973090 39.5037110, -106.7974520 39.5043120, -106.7974000 39.5044990, -106.7971940 39.5047660, -106.7971160 39.5050520, -106.7971800 39.5053150, -106.7975690 39.5061200, -106.7977950 39.5066100, -106.7979140 39.5073980, -106.7981930 39.5083150, -106.7984140 39.5086080, -106.7987200 39.5089320, -106.7989210 39.5090280, -106.7990480 39.5090040, -106.7995350 39.5085320, -106.7999580 39.5080020, -106.8001950 39.5078560, -106.8005190 39.5077520, -106.8009700 39.5076580, -106.8022020 39.5075940, -106.8026100 39.5074680, -106.8030030 39.5073190, -106.8035910 39.5070350, -106.8039150 39.5069540, -106.8045100 39.5069000, -106.8048360 39.5068950, -106.8057340 39.5066050, -106.8060320 39.5065590, -106.8063580 39.5065540, -106.8067170 39.5067010, -106.8068760 39.5068420, -106.8069230 39.5069940, -106.8068700 39.5071380, -106.8067750 39.5073260, -106.8065210 39.5079000, -106.8065560 39.5087110, -106.8065090 39.5090850, -106.8065310 39.5096020, -106.8064950 39.5101710, -106.8064830 39.5108190, -106.8067250 39.5119560, -106.8070650 39.5135740, -106.8070740 39.5144510, -106.8070240 39.5152530, -106.8071010 39.5155040, -106.8072890 39.5156330, -106.8077140 39.5156260, -106.8080960 39.5155980, -106.8084100 39.5156590, -106.8087140 39.5158850, -106.8090480 39.5161980, -106.8093080 39.5163050, -106.8096330 39.5163200, -106.8099150 39.5162610, -106.8101770 39.5159830, -106.8105670 39.5157240, -106.8109620 39.5156300, -106.8115160 39.5156440, -106.8115841 39.5156252, -106.8118960 39.5155390, -106.8124300 39.5153550, -106.8127370 39.5151860, -106.8128820 39.5149790, -106.8129910 39.5145790, -106.8129220 39.5141190, -106.8128450 39.5138900, -106.8129410 39.5137670, -106.8131950 39.5136980, -106.8136630 39.5137120, -106.8141480 39.5138030, -106.8154940 39.5142870, -106.8158920 39.5143250, -106.8164860 39.5142720, -106.8167430 39.5143330, -106.8171580 39.5144810, -106.8175690 39.5144850, -106.8181170 39.5142680, -106.8185950 39.5141290, -106.8189370 39.5141780, -106.8192620 39.5142700, -106.8195110 39.5144550, -106.8196320 39.5147160, -106.8196940 39.5149240, -106.8201620 39.5154870, -106.8203840 39.5158460, -106.8205330 39.5166330, -106.8206660 39.5168400, -106.8208690 39.5170340, -106.8211550 39.5171170, -106.8219670 39.5172250, -106.8224080 39.5173060, -106.8226680 39.5174670, -106.8229030 39.5178030, -106.8232120 39.5182150, -106.8236950 39.5188000, -106.8240320 39.5191900, -106.8243770 39.5193820, -106.8250920 39.5195800, -106.8260040 39.5197740, -106.8268260 39.5199890, -106.8274920 39.5202550, -106.8280810 39.5206630, -106.8283570 39.5208170, -106.8287480 39.5209230, -106.8289810 39.5210480, -106.8292090 39.5211950, -106.8294240 39.5214080, -106.8296760 39.5215880, -106.8299280 39.5217610, -106.8304420 39.5218230, -106.8308330 39.5218200, -106.8313330 39.5217340, -106.8319540 39.5216910, -106.8321890 39.5216800, -106.8324050 39.5217240, -106.8327060 39.5219200, -106.8328750 39.5221680, -106.8330670 39.5224290, -106.8334210 39.5227900, -106.8336930 39.5229930, -106.8340140 39.5234130, -106.8352950 39.5240950, -106.8359850 39.5242440, -106.8368050 39.5243680, -106.8376690 39.5245410, -106.8385620 39.5248120, -106.8391740 39.5249010, -106.8396280 39.5249050, -106.8399150 39.5250220, -106.8400600 39.5251620, -106.8413290 39.5259430, -106.8417750 39.5261560, -106.8425050 39.5264080, -106.8434770 39.5267110, -106.8444050 39.5269270, -106.8445800 39.5271110, -106.8446020 39.5273960, -106.8446020 39.5279340, -106.8445160 39.5284510, -106.8444710 39.5289010, -106.8444710 39.5299440, -106.8444580 39.5305370, -106.8445680 39.5309520, -106.8447290 39.5311470, -106.8453870 39.5313570, -106.8461390 39.5316910, -106.8470090 39.5322940, -106.8477450 39.5325160, -106.8480430 39.5327970, -106.8490190 39.5331090, -106.8497920 39.5332420, -106.8503750 39.5332650, -106.8509160 39.5333450, -106.8512460 39.5334930, -106.8516790 39.5337610, -106.8520460 39.5342380, -106.8523960 39.5345950, -106.8528230 39.5351810, -106.8532140 39.5354830, -106.8534460 39.5356760, -106.8536500 39.5358710, -106.8539490 39.5364370, -106.8541680 39.5366640, -106.8544560 39.5368350, -106.8549870 39.5370580, -106.8551330 39.5372310, -106.8554550 39.5375880, -106.8557340 39.5379460, -106.8562010 39.5384610, -106.8564240 39.5388140, -106.8565850 39.5395360, -106.8569020 39.5402450, -106.8571020 39.5408340, -106.8571850 39.5412940, -106.8569980 39.5417360, -106.8569280 39.5422750, -106.8570480 39.5430640, -106.8574140 39.5433320, -106.8577460 39.5453960, -106.8585240 39.5472180, -106.8591900 39.5478870, -106.8593910 39.5484630, -106.8602110 39.5488670, -106.8607890 39.5492760, -106.8613540 39.5497060, -106.8614750 39.5505280, -106.8607020 39.5502430, -106.8602280 39.5500420, -106.8598670 39.5498170, -106.8594490 39.5495710, -106.8588120 39.5490760, -106.8583940 39.5488300, -106.8579780 39.5486610, -106.8576340 39.5485450, -106.8572820 39.5486280, -106.8567630 39.5488660, -106.8556520 39.5492570, -106.8546910 39.5493710, -106.8539990 39.5495020, -106.8534650 39.5496860, -106.8532260 39.5497780, -106.8531730 39.5499220, -106.8532770 39.5501070, -106.8537500 39.5502970, -106.8544800 39.5505270, -106.8550550 39.5507930, -106.8560650 39.5514470, -106.8566900 39.5519860, -106.8578600 39.5532750, -106.8582780 39.5535430, -106.8587510 39.5537000, -106.8592920 39.5537800, -106.8602590 39.5538420, -106.8612960 39.5539130, -106.8619520 39.5540130, -106.8624960 39.5542020, -106.8629890 39.5546120, -106.8633260 39.5550020, -106.8635350 39.5553610, -106.8637150 39.5557430, -106.8637150 39.5562920, -106.8637310 39.5568850, -106.8638420 39.5573120, -106.8640890 39.5575170, -106.8645080 39.5578070, -106.8652260 39.5581250, -106.8660720 39.5584630, -106.8669310 39.5587240, -106.8675770 39.5590000, -106.8681800 39.5592650, -106.8672150 39.5592580, -106.8662220 39.5592850, -106.8655440 39.5593830, -106.8654959 39.5593947, -106.8648099 39.5595616, -106.8645290 39.5596300, -106.8641630 39.5597450, -106.8638940 39.5597710, -106.8632700 39.5598030, -106.8631730 39.5598024, -106.8627740 39.5598000, -106.8631841 39.5599718, -106.8633040 39.5600220, -106.8640060 39.5602640, -106.8646900 39.5603520, -106.8659110 39.5603660, -106.8669800 39.5605470, -106.8679520 39.5608170, -106.8682950 39.5609110, -106.8686970 39.5610700, -106.8691420 39.5612490, -106.8696310 39.5615270, -106.8723290 39.5611000, -106.8740390 39.5599100, -106.8745260 39.5595440, -106.8755970 39.5596580, -106.8760060 39.5595520, -106.8762610 39.5595480, -106.8765610 39.5596080, -106.8771050 39.5597970, -106.8775520 39.5600640, -106.8780150 39.5603970, -106.8782010 39.5604490, -106.8784280 39.5604230, -106.8786460 39.5603390, -106.8778110 39.5609830, -106.8755330 39.5637520, -106.8779520 39.5640550, -106.8793388 39.5640758, -106.8794200 39.5640770, -106.8789910 39.5648410, -106.8786450 39.5652590, -106.8781230 39.5657720, -106.8780070 39.5659580, -106.8772250 39.5667280, -106.8763490 39.5673400, -106.8753560 39.5683890, -106.8750170 39.5686000, -106.8733560 39.5706480, -106.8714800 39.5728830, -106.8712230 39.5733010, -106.8711970 39.5734610, -106.8711390 39.5735080, -106.8709420 39.5740150, -106.8705120 39.5746190, -106.8694350 39.5754880, -106.8690890 39.5758840, -106.8689770 39.5761840, -106.8688390 39.5766450, -106.8685260 39.5772460, -106.8684730 39.5775210, -106.8669850 39.5799550, -106.8664940 39.5806100, -106.8664110 39.5807220, -106.8657810 39.5812470, -106.8656862 39.5812908, -106.8656666 39.5813093, -106.8656608 39.5813273, -106.8656660 39.5814240, -106.8651880 39.5818680, -106.8644110 39.5823600, -106.8630980 39.5836690, -106.8628890 39.5839260, -106.8627690 39.5840200, -106.8621140 39.5849530, -106.8611000 39.5861670, -106.8607358 39.5864957, -106.8601150 39.5870560, -106.8596990 39.5876400, -106.8588080 39.5892250, -106.8585090 39.5896230, -106.8580900 39.5898800, -106.8571920 39.5902570, -106.8567430 39.5905850, -106.8566460 39.5908230, -106.8582950 39.5916809, -106.8606710 39.5929170, -106.8607670 39.5929670, -106.8621070 39.5931050, -106.8625600 39.5932910, -106.8629240 39.5936750, -106.8629230 39.5937400, -106.8634760 39.5946360, -106.8635840 39.5949040, -106.8636290 39.5955680, -106.8637380 39.5957910, -106.8642720 39.5962440, -106.8646270 39.5970690, -106.8648500 39.5973390, -106.8649890 39.5975630, -106.8661940 39.5986930, -106.8665500 39.5990460, -106.8663840 39.5992470, -106.8662480 39.5994690, -106.8661550 39.5996900, -106.8658090 39.6000360, -106.8656750 39.6003140, -106.8654660 39.6004710, -106.8651990 39.6005850, -106.8651532 39.6006482, -106.8650620 39.6007740, -106.8649160 39.6011500, -106.8647490 39.6012740, -106.8649700 39.6015670, -106.8653480 39.6019130, -106.8655550 39.6021960, -106.8657340 39.6025230, -106.8657700 39.6027980, -106.8657480 39.6030620, -106.8657150 39.6034030, -106.8658490 39.6036540, -106.8660870 39.6040250, -106.8664420 39.6045800, -106.8667340 39.6048610, -106.8668380 39.6050580, -106.8668890 39.6053540, -106.8669220 39.6055290, -106.8670710 39.6057800, -106.8672160 39.6059210, -106.8674060 39.6061160, -106.8676000 39.6064650, -106.8676050 39.6066520, -106.8675010 39.6069940, -106.8674350 39.6072040, -106.8675710 39.6074880, -106.8676640 39.6077730, -106.8675990 39.6080050, -106.8675480 39.6082260, -106.8676260 39.6084880, -106.8680740 39.6092960, -106.8684060 39.6100310, -106.8684820 39.6102130, -106.8687130 39.6103750, -106.8690450 39.6105670, -106.8692620 39.6107290, -106.8693520 39.6109040, -106.8692750 39.6111800, -106.8692940 39.6113890, -106.8695530 39.6115060, -106.8702790 39.6115710, -106.8709510 39.6117260, -106.8711660 39.6118100, -106.8714400 39.6119710, -106.8716450 39.6121880, -106.8718650 39.6124600, -106.8722120 39.6126630, -106.8728440 39.6129610, -106.8732920 39.6132510, -106.8735550 39.6135110, -106.8735890 39.6137090, -106.8735230 39.6138970, -106.8733240 39.6144390, -106.8732310 39.6146720, -106.8732390 39.6149580, -106.8734000 39.6151530, -106.8737340 39.6154230, -106.8745180 39.6160490, -106.8750400 39.6164370, -106.8751150 39.6166010, -106.8750920 39.6168100, -106.8752110 39.6170170, -106.8755840 39.6171560, -106.8759420 39.6172820, -106.8764260 39.6173070, -106.8766550 39.6173690, -106.8767570 39.6174660, -106.8767220 39.6177420, -106.8767530 39.6178740, -106.8770060 39.6182980, -106.8771670 39.6184720, -106.8779630 39.6190090, -106.8782530 39.6192350, -106.8783870 39.6194860, -106.8784680 39.6198480, -106.8786770 39.6202180, -106.8789690 39.6204990, -106.8792990 39.6206260, -106.8795600 39.6208200, -106.8796390 39.6211260, -106.8796670 39.6216430, -106.8798260 39.6222790, -106.8797620 39.6225440, -106.8796379 39.6226198, -106.8795950 39.6226460, -106.8793290 39.6228040, -106.8792090 39.6229014, -106.8791931 39.6229564, -106.8792025 39.6230157, -106.8792660 39.6230910, -106.8796100 39.6232070, -106.8798710 39.6234230, -106.8800750 39.6236060, -106.8801220 39.6237600, -106.8802000 39.6245510, -106.8801240 39.6249040, -106.8802130 39.6250560, -106.8804540 39.6250630, -106.8808110 39.6251220, -106.8813880 39.6254310, -106.8817810 39.6257750, -106.8823010 39.6261060, -106.8824190 39.6262580, -106.8824650 39.6264000, -106.8823700 39.6265550, -106.8818820 39.6269030, -106.8818280 39.6270020, -106.8818460 39.6271230, -106.8820320 39.6271860, -106.8824150 39.6271570, -106.8829180 39.6270240, -106.8833210 39.6268900, -106.8834758 39.6268206, -106.8836670 39.6267350, -106.8839356 39.6265974, -106.8845030 39.6263570, -106.8849940 39.6262240, -106.8854260 39.6262020, -106.8858880 39.6262460, -106.8863200 39.6264680, -106.8866370 39.6265570, -106.8876180 39.6266240, -106.8881080 39.6267790, -106.8884850 39.6268970, -106.8885490 39.6269990, -106.8912910 39.6275630, -106.8916410 39.6279080, -106.8920880 39.6281170, -106.8929040 39.6283870, -106.8943430 39.6293300, -106.8948280 39.6297340, -106.8953910 39.6301390, -106.8959820 39.6311820, -106.8962840 39.6316170, -106.8966680 39.6320410, -106.8967700 39.6322430, -106.8967990 39.6326320, -106.8967520 39.6333300, -106.8967050 39.6339130, -106.8968080 39.6345250, -106.8969760 39.6348200, -106.8974340 39.6352380, -106.8977060 39.6356770, -106.8978460 39.6359070, -106.8980890 39.6362600, -106.8981820 39.6364550, -106.8981820 39.6368870, -106.8984990 39.6371820, -106.8993220 39.6374700, -106.8996400 39.6378440, -106.8996120 39.6384420, -106.8996680 39.6387800, -106.8999670 39.6391980, -106.9007430 39.6398750, -106.9008090 39.6401270, -106.9009080 39.6401520, -106.9008930 39.6402390, -106.9009420 39.6404440, -106.9007740 39.6413020, -106.9007220 39.6417320, -106.9005530 39.6418610, -106.9003740 39.6420560, -106.9002060 39.6425420, -106.9001240 39.6429200, -106.8999310 39.6438110, -106.8998990 39.6441800, -106.8995690 39.6449140, -106.8993860 39.6456370, -106.8995980 39.6461010, -106.8996140 39.6463180, -106.8995647 39.6464978, -106.8995383 39.6465561, -106.8995080 39.6465990, -106.8992700 39.6470430, -106.8988730 39.6474760, -106.8987250 39.6473840, -106.8982530 39.6472930, -106.8973060 39.6472910, -106.8968040 39.6470400, -106.8964790 39.6469710, -106.8952070 39.6474270, -106.8943210 39.6476080, -106.8937890 39.6475850, -106.8919280 39.6471730, -106.8903910 39.6472170, -106.8897700 39.6471710, -106.8890310 39.6471010, -106.8865780 39.6474420, -106.8851880 39.6477840, -106.8844490 39.6477820, -106.8837990 39.6475080, -106.8832670 39.6473010, -106.8817600 39.6471860, -106.8796030 39.6472060, -106.8785400 39.6470740, -106.8784010 39.6471170, -106.8780779 39.6471546, -106.8769820 39.6472820, -106.8762330 39.6474890, -106.8761090 39.6476900, -106.8761880 39.6479500, -106.8763750 39.6482050, -106.8764540 39.6483490, -106.8764520 39.6484960, -106.8764210 39.6485740, -106.8763060 39.6487360, -106.8760950 39.6490990, -106.8760480 39.6491530, -106.8759790 39.6492090, -106.8758480 39.6492790, -106.8757710 39.6493310, -106.8756390 39.6494860, -106.8754630 39.6496500, -106.8754120 39.6497270, -106.8753680 39.6499430, -106.8753420 39.6500110, -106.8752140 39.6501370, -106.8750540 39.6504350, -106.8749170 39.6506460, -106.8748390 39.6508310, -106.8747720 39.6511360, -106.8746120 39.6514960, -106.8746420 39.6516430, -106.8746760 39.6516990, -106.8748100 39.6517680, -106.8746870 39.6519870, -106.8743360 39.6521740, -106.8743520 39.6522630, -106.8744140 39.6523110, -106.8746200 39.6524790, -106.8747210 39.6525870, -106.8748000 39.6526620, -106.8749560 39.6528090, -106.8751470 39.6527180, -106.8752250 39.6527860, -106.8753690 39.6529140, -106.8755650 39.6530150, -106.8757120 39.6530810, -106.8757680 39.6531000, -106.8758380 39.6531220, -106.8759070 39.6531370, -106.8759670 39.6531460, -106.8760690 39.6531530, -106.8762490 39.6531480, -106.8763920 39.6527010, -106.8763190 39.6524980, -106.8765760 39.6524050, -106.8773670 39.6523130, -106.8772750 39.6525170, -106.8778840 39.6528370, -106.8808280 39.6552300, -106.8818420 39.6562480, -106.8827950 39.6573670, -106.8836750 39.6583580, -106.8844080 39.6595340, -106.8845660 39.6598600, -106.8850430 39.6610540, -106.8853930 39.6617310, -106.8858210 39.6624120, -106.8860860 39.6629860, -106.8860410 39.6631770, -106.8859320 39.6632390, -106.8859320 39.6633620, -106.8860480 39.6640840, -106.8860730 39.6645010, -106.8861360 39.6647300, -106.8861840 39.6649270, -106.8860520 39.6653030, -106.8860440 39.6655000, -106.8861440 39.6660480, -106.8860640 39.6662580, -106.8863590 39.6671530, -106.8865200 39.6673480, -106.8867220 39.6674650, -106.8867540 39.6675860, -106.8865870 39.6677200, -106.8865350 39.6678750, -106.8868170 39.6688360, -106.8868230 39.6690890, -106.8866930 39.6695080, -106.8866880 39.6698480, -106.8867620 39.6704840, -106.8866850 39.6707820, -106.8868790 39.6716460, -106.8870900 39.6726090, -106.8874670 39.6734150, -106.8875980 39.6740610, -106.8877020 39.6747290, -106.8879760 39.6754050, -106.8880550 39.6757000, -106.8880640 39.6760190, -106.8882430 39.6763450, -106.8882520 39.6766740, -106.8881530 39.6777190, -106.8878190 39.6779160, -106.8877890 39.6779340, -106.8875360 39.6780260, -106.8873080 39.6779970, -106.8868610 39.6777740, -106.8865570 39.6775590, -106.8862010 39.6775430, -106.8858660 39.6777800, -106.8851140 39.6783630, -106.8847080 39.6790950, -106.8836410 39.6801120, -106.8831980 39.6805370, -106.8822320 39.6811020, -106.8814790 39.6816530, -106.8810300 39.6818580, -106.8805420 39.6822180, -106.8801130 39.6826530, -106.8798570 39.6831630, -106.8796610 39.6838030, -106.8795200 39.6843770, -106.8794170 39.6847850, -106.8792160 39.6852170, -106.8790480 39.6854500, -106.8789120 39.6855400, -106.8788300 39.6855550, -106.8783320 39.6856490, -106.8775230 39.6856950, -106.8770660 39.6856370, -106.8765060 39.6854380, -106.8762900 39.6853100, -106.8760140 39.6851050, -106.8757810 39.6849000, -106.8754720 39.6848520, -106.8741880 39.6846740, -106.8732280 39.6844040, -106.8724990 39.6842500, -106.8714860 39.6841340, -106.8707030 39.6840810, -106.8701740 39.6839900, -106.8694100 39.6838470, -106.8685730 39.6836640, -106.8682430 39.6835150, -106.8680400 39.6833750, -106.8678530 39.6833120, -106.8673250 39.6832330, -106.8665960 39.6830690, -106.8659250 39.6829800, -106.8654120 39.6829330, -106.8643260 39.6827410, -106.8636120 39.6826100, -106.8627860 39.6825570, -106.8623170 39.6825640, -106.8616090 39.6826630, -106.8613400 39.6826890, -106.8610530 39.6826060, -106.8606960 39.6825340, -106.8602390 39.6824650, -106.8598970 39.6824260, -106.8596070 39.6822330, -106.8592140 39.6818880, -106.8588960 39.6816730, -106.8584810 39.6816020, -106.8580850 39.6816740, -106.8576050 39.6818030, -106.8571380 39.6818540, -106.8568010 39.6820130, -106.8559900 39.6825310, -106.8556490 39.6825250, -106.8553350 39.6824860, -106.8547590 39.6821990, -106.8541580 39.6820540, -106.8537880 39.6820380, -106.8532360 39.6821350, -106.8527820 39.6821640, -106.8523540 39.6821370, -106.8521460 39.6821160, -106.8519090 39.6820240, -106.8517070 39.6818510, -106.8515990 39.6815340, -106.8513830 39.6813970, -106.8510690 39.6812930, -106.8507020 39.6812180, -106.8503940 39.6811950, -106.8502150 39.6812240, -106.8500500 39.6812580, -106.8499150 39.6812810, -106.8498480 39.6812470, -106.8498180 39.6811720, -106.8497280 39.6810740, -106.8495930 39.6810390, -106.8493750 39.6810480, -106.8490310 39.6810390, -106.8487610 39.6810100, -106.8485890 39.6809990, -106.8484610 39.6810390, -106.8482740 39.6810790, -106.8479820 39.6811020, -106.8475850 39.6810970, -106.8472400 39.6810740, -106.8469260 39.6810740, -106.8466940 39.6811020, -106.8465660 39.6811720, -106.8464610 39.6813500, -106.8463860 39.6815060, -106.8462440 39.6815580, -106.8460340 39.6815920, -106.8458400 39.6815750, -106.8456150 39.6815010, -106.8449400 39.6811030, -106.8444680 39.6808780, -106.8441840 39.6807170, -106.8439740 39.6805670, -106.8437340 39.6803190, -106.8436520 39.6801510, -106.8435770 39.6800530, -106.8434500 39.6799380, -106.8433450 39.6798060, -106.8432550 39.6796560, -106.8431950 39.6794310, -106.8431350 39.6792750, -106.8430450 39.6791660, -106.8427910 39.6790560, -106.8423790 39.6789460, -106.8421310 39.6789520, -106.8419290 39.6790040, -106.8417190 39.6790160, -106.8414190 39.6789350, -106.8411050 39.6787560, -106.8409470 39.6786640, -106.8407670 39.6786530, -106.8405730 39.6787860, -106.8404110 39.6789740, -106.8403090 39.6791930, -106.8401870 39.6794510, -106.8400540 39.6796000, -106.8397900 39.6798190, -106.8394540 39.6800540, -106.8390980 39.6803050, -106.8385790 39.6807670, -106.8382940 39.6809230, -106.8380810 39.6810330, -106.8378970 39.6811030, -106.8376940 39.6811110, -106.8375720 39.6810560, -106.8374600 39.6810090, -106.8372560 39.6808920, -106.8370630 39.6808530, -106.8367370 39.6808290, -106.8365640 39.6807820, -106.8365030 39.6806570, -106.8365140 39.6804930, -106.8365240 39.6802580, -106.8364120 39.6801090, -106.8361570 39.6798980, -106.8358620 39.6797570, -106.8355780 39.6796940, -106.8352620 39.6797250, -106.8349980 39.6798190, -106.8348350 39.6802730, -106.8347230 39.6805310, -106.8343870 39.6811810, -106.8342760 39.6815020, -106.8342350 39.6817450, -106.8343330 39.6823200, -106.8341770 39.6844870, -106.8341330 39.6849600, -106.8340150 39.6853240, -106.8340240 39.6862140, -106.8341140 39.6869260, -106.8339930 39.6872030, -106.8335030 39.6880010, -106.8332950 39.6882130, -106.8327110 39.6892660, -106.8325080 39.6896430, -106.8322350 39.6900540, -106.8320070 39.6905840, -106.8319590 39.6909260, -106.8320280 39.6919360, -106.8321530 39.6923620, -106.8323750 39.6926880, -106.8325370 39.6929060, -106.8326290 39.6931460, -106.8326370 39.6934420, -106.8327190 39.6938370, -106.8329020 39.6943170, -106.8331640 39.6951040, -106.8337590 39.6960730, -106.8341120 39.6965070, -106.8343600 39.6967670, -106.8346650 39.6970150, -106.8351270 39.6972600, -106.8357610 39.6975910, -106.8360240 39.6978620, -106.8366890 39.6987850, -106.8370720 39.6993180, -106.8372370 39.6996340, -106.8373290 39.6998960, -106.8376970 39.7003520, -106.8379200 39.7007110, -106.8380180 39.7012150, -106.8381760 39.7017840, -106.8381980 39.7020810, -106.8381630 39.7023890, -106.8380810 39.7030500, -106.8381460 39.7038840, -106.8382540 39.7042010, -106.8384600 39.7044400, -106.8387640 39.7046660, -106.8390320 39.7051120, -106.8391870 39.7055830, -106.8394830 39.7060290, -106.8398030 39.7062870, -106.8401120 39.7066890, -106.8408400 39.7078650, -106.8411190 39.7081900, -106.8415140 39.7086020, -106.8420190 39.7094290, -106.8422700 39.7097550, -106.8424350 39.7100930, -106.8424150 39.7103910, -106.8422090 39.7106800, -106.8419920 39.7110680, -106.8421270 39.7113620, -106.8424690 39.7119180, -106.8426250 39.7124100, -106.8426940 39.7128710, -106.8426900 39.7132560, -106.8424570 39.7136000, -106.8423650 39.7138980, -106.8424150 39.7141720, -106.8425820 39.7145550, -106.8426020 39.7147740, -106.8425740 39.7153130, -106.8427150 39.7158280, -106.8428550 39.7162660, -106.8427880 39.7164320, -106.8426230 39.7166430, -106.8418610 39.7173920, -106.8415700 39.7176930, -106.8414900 39.7178810, -106.8414980 39.7181780, -106.8413500 39.7190490, -106.8411890 39.7194250, -106.8408830 39.7196610, -106.8404120 39.7201300, -106.8401460 39.7203210, -106.8397390 39.7205040, -106.8394040 39.7207620, -106.8391010 39.7211290, -106.8381110 39.7218600, -106.8378180 39.7221060, -106.8377800 39.7222500, -106.8378270 39.7224250, -106.8381050 39.7227280, -106.8382570 39.7231000, -106.8387170 39.7237970, -106.8388070 39.7240040, -106.8390120 39.7242100, -106.8396740 39.7245070, -106.8397920 39.7246490, -106.8399860 39.7250080, -106.8402060 39.7252360, -106.8402260 39.7254670, -106.8400790 39.7258210, -106.8401810 39.7266320, -106.8401870 39.7266770, -106.8404520 39.7275310, -106.8406880 39.7278790, -106.8412220 39.7281460, -106.8414270 39.7283730, -106.8415620 39.7286350, -106.8417220 39.7287870, -106.8423830 39.7289960, -106.8425580 39.7291910, -106.8429640 39.7299990, -106.8431440 39.7303370, -106.8433920 39.7305750, -106.8436950 39.7307470, -106.8441830 39.7309260, -106.8450280 39.7311330, -106.8452050 39.7313720, -106.8452400 39.7316140, -106.8454780 39.7319950, -106.8457680 39.7321990, -106.8463740 39.7325200, -106.8473850 39.7330870, -106.8476880 39.7332580, -106.8479460 39.7332980, -106.8482020 39.7333270, -106.8485530 39.7336740, -106.8488000 39.7338790, -106.8493030 39.7340690, -106.8509470 39.7348900, -106.8520900 39.7355880, -106.8523530 39.7358480, -106.8525290 39.7359460, -106.8527022 39.7360417, -106.8528730 39.7361360, -106.8537390 39.7366070, -106.8552240 39.7373650, -106.8557440 39.7376430, -106.8561630 39.7378890, -106.8570060 39.7385580, -106.8575740 39.7390330, -106.8578390 39.7393810, -106.8580040 39.7396870, -106.8580820 39.7399390, -106.8582860 39.7401110, -106.8583720 39.7401430, -106.8585240 39.7402070, -106.8586740 39.7402700, -106.8589200 39.7404090, -106.8593130 39.7407550, -106.8594920 39.7410610, -106.8595550 39.7412910, -106.8597610 39.7415520, -106.8600510 39.7417230, -106.8609520 39.7419180, -106.8613400 39.7420440, -106.8615730 39.7422490, -106.8617820 39.7426420, -106.8619290 39.7428160, -106.8621180 39.7429450, -106.8628040 39.7430670, -106.8631520 39.7432810, -106.8638760 39.7437870, -106.8645470 39.7444040, -106.8647690 39.7446970, -106.8649310 39.7448930, -106.8652910 39.7450630, -106.8654550 39.7451120, -106.8662090 39.7453350, -106.8664700 39.7455070, -106.8668460 39.7457430, -106.8674660 39.7460530, -106.8677320 39.7464010, -106.8680140 39.7468370, -106.8683790 39.7471940, -106.8690020 39.7475910, -106.8696480 39.7478230, -106.8700620 39.7480560, -106.8703130 39.7482490, -106.8706360 39.7485410, -106.8709570 39.7487650, -106.8716240 39.7492580, -106.8717570 39.7494140, -106.8718620 39.7499490, -106.8719240 39.7501130, -106.8726090 39.7507270, -106.8727740 39.7510320, -106.8732860 39.7520770, -106.8735170 39.7527090, -106.8736170 39.7532340, -106.8736830 39.7536060, -106.8739370 39.7540400, -106.8742910 39.7544960, -106.8746100 39.7547100, -106.8750000 39.7549340, -106.8752610 39.7551170, -106.8755740 39.7554680, -106.8757530 39.7556130, -106.8758550 39.7557240, -106.8758980 39.7557870, -106.8760030 39.7560050, -106.8761550 39.7562060, -106.8762610 39.7562620, -106.8764250 39.7562910, -106.8766580 39.7562740, -106.8767640 39.7562720, -106.8768930 39.7563100, -106.8770420 39.7564340, -106.8773710 39.7567390, -106.8775210 39.7568900, -106.8777890 39.7570700, -106.8778730 39.7571630, -106.8779600 39.7573370, -106.8780510 39.7574890, -106.8780680 39.7575190, -106.8780820 39.7575420, -106.8781330 39.7577130, -106.8781790 39.7578920, -106.8783550 39.7581460, -106.8786050 39.7585420, -106.8786500 39.7586940, -106.8786430 39.7588740, -106.8785680 39.7591010, -106.8783490 39.7596450, -106.8781290 39.7601340, -106.8780690 39.7605230, -106.8780270 39.7611040, -106.8780800 39.7613550, -106.8782340 39.7618350, -106.8784960 39.7624520, -106.8788040 39.7630410, -106.8789570 39.7633310, -106.8790200 39.7637040, -106.8790570 39.7637930, -106.8792190 39.7639940, -106.8793470 39.7641530, -106.8795350 39.7644060, -106.8796770 39.7647010, -106.8798150 39.7650410, -106.8799610 39.7652370, -106.8800870 39.7653740, -106.8803420 39.7655410, -106.8805520 39.7657270, -106.8806970 39.7659140, -106.8808420 39.7661090, -106.8810160 39.7662550, -106.8813890 39.7664470, -106.8818490 39.7666420, -106.8822690 39.7668510, -106.8824220 39.7668890, -106.8829540 39.7669300, -106.8836050 39.7670190, -106.8838280 39.7670640, -106.8840410 39.7671780, -106.8842920 39.7673900, -106.8844610 39.7675850, -106.8845830 39.7677900, -106.8846240 39.7679920, -106.8846990 39.7684470, -106.8847450 39.7685800, -106.8848660 39.7687310, -106.8851230 39.7689520, -106.8855470 39.7693060, -106.8858380 39.7694990, -106.8860130 39.7696900, -106.8863930 39.7701650, -106.8866080 39.7705580, -106.8867290 39.7707090, -106.8869450 39.7708950, -106.8873250 39.7711320, -106.8875150 39.7712550, -106.8877170 39.7714050, -106.8878830 39.7714870, -106.8881680 39.7716490, -106.8885060 39.7718650, -106.8888020 39.7719810, -106.8892020 39.7720960, -106.8897680 39.7723080, -106.8898570 39.7723780, -106.8900520 39.7726810, -106.8902250 39.7728090, -106.8903390 39.7729020, -106.8904010 39.7730540, -106.8904300 39.7732510, -106.8904470 39.7734450, -106.8907000 39.7739500, -106.8908540 39.7744650, -106.8908460 39.7746000, -106.8907750 39.7747680, -106.8905800 39.7751090, -106.8905678 39.7751860, -106.8905150 39.7755200, -106.8905360 39.7756280, -106.8905900 39.7756990, -106.8907760 39.7758630, -106.8909440 39.7760260, -106.8912480 39.7762560, -106.8918830 39.7768580, -106.8922090 39.7772490, -106.8923480 39.7774360, -106.8925040 39.7775770, -106.8926760 39.7776870, -106.8928480 39.7777740, -106.8930840 39.7778650, -106.8932310 39.7779070, -106.8936830 39.7782150, -106.8942430 39.7785940, -106.8945420 39.7788630, -106.8947460 39.7790720, -106.8948630 39.7792860, -106.8949880 39.7795770, -106.8950370 39.7798780, -106.8950310 39.7800940, -106.8949460 39.7804200, -106.8948480 39.7806560, -106.8947410 39.7808290, -106.8945420 39.7810030, -106.8942960 39.7811920, -106.8941960 39.7813600, -106.8940800 39.7816140, -106.8939950 39.7819040, -106.8939660 39.7821390, -106.8938880 39.7822610, -106.8937920 39.7824070, -106.8936280 39.7826040, -106.8935630 39.7827710, -106.8935290 39.7830110, -106.8935210 39.7833800, -106.8935380 39.7839790, -106.8936260 39.7844330, -106.8936620 39.7848780, -106.8937420 39.7854670, -106.8938200 39.7857630, -106.8940160 39.7862920, -106.8942000 39.7868560, -106.8942810 39.7872510, -106.8944290 39.7879520, -106.8945100 39.7883650, -106.8946680 39.7889930, -106.8947030 39.7892270, -106.8947440 39.7894380, -106.8948380 39.7896660, -106.8950010 39.7900690, -106.8950410 39.7902530, -106.8951490 39.7905890, -106.8951990 39.7907060, -106.8953320 39.7908700, -106.8956170 39.7912390, -106.8957230 39.7914720, -106.8957680 39.7916430, -106.8958960 39.7918390, -106.8959590 39.7919910, -106.8959850 39.7921120, -106.8959690 39.7925850, -106.8958330 39.7931380, -106.8957600 39.7934630, -106.8956550 39.7936950, -106.8954360 39.7940000, -106.8952310 39.7941840, -106.8950470 39.7943040, -106.8946720 39.7944540, -106.8941570 39.7946250, -106.8935540 39.7947880, -106.8929750 39.7949600, -106.8922930 39.7952230, -106.8920020 39.7952910, -106.8903950 39.7958590, -106.8902330 39.7959150, -106.8899990 39.7959100, -106.8897460 39.7958560, -106.8893030 39.7956780, -106.8888530 39.7954510, -106.8886930 39.7953530, -106.8878000 39.7947930, -106.8877780 39.7947870, -106.8877490 39.7947890, -106.8877340 39.7948110, -106.8879080 39.7950430, -106.8881290 39.7954360, -106.8883880 39.7959280, -106.8884570 39.7961250, -106.8885360 39.7964520, -106.8885740 39.7967490, -106.8886150 39.7969690, -106.8886310 39.7975690, -106.8886020 39.7977720, -106.8884970 39.7980210, -106.8881610 39.7987660, -106.8876440 39.7999330, -106.8870750 39.8012990, -106.8869190 39.8015990, -106.8868420 39.8017760, -106.8867780 39.8019840, -106.8867590 39.8021420, -106.8864490 39.8027830, -106.8862960 39.8031820, -106.8858690 39.8039960, -106.8855240 39.8048220, -106.8851820 39.8055710, -106.8850280 39.8059440, -106.8848400 39.8062980, -106.8845260 39.8070020, -106.8842450 39.8076150, -106.8841390 39.8078200, -106.8839990 39.8080430, -106.8836820 39.8083960, -106.8835340 39.8085510, -106.8833690 39.8086890, -106.8827720 39.8090690, -106.8820410 39.8094910, -106.8802690 39.8104670, -106.8790650 39.8110770, -106.8778160 39.8117470, -106.8772630 39.8120490, -106.8769470 39.8122530, -106.8766430 39.8124600, -106.8765170 39.8125700, -106.8764400 39.8127110, -106.8763740 39.8128830, -106.8761950 39.8131830, -106.8760030 39.8134070, -106.8756150 39.8137050, -106.8752030 39.8142490, -106.8746650 39.8149170, -106.8741870 39.8156610, -106.8738590 39.8161490, -106.8732140 39.8170820, -106.8721710 39.8185380, -106.8715130 39.8194820, -106.8708240 39.8203280, -106.8703980 39.8208950, -106.8699220 39.8212210, -106.8695610 39.8215560, -106.8684950 39.8226940, -106.8677500 39.8235960, -106.8672110 39.8242190, -106.8664620 39.8249560, -106.8657030 39.8258470, -106.8649590 39.8267930, -106.8635720 39.8287050, -106.8628680 39.8295520, -106.8624190 39.8298110, -106.8619270 39.8300500, -106.8611560 39.8305020, -106.8603850 39.8309860, -106.8595640 39.8316920, -106.8587460 39.8325400, -106.8574300 39.8339450, -106.8565890 39.8346220, -106.8565380 39.8346630, -106.8551991 39.8356631, -106.8551550 39.8356960, -106.8544140 39.8362240, -106.8537400 39.8366080, -106.8526170 39.8372090, -106.8522790 39.8373680, -106.8518430 39.8375840, -106.8508590 39.8380720, -106.8505220 39.8382530, -106.8500200 39.8386890, -106.8492280 39.8394050, -106.8486720 39.8399640, -106.8484680 39.8403190, -106.8484240 39.8407810, -106.8484320 39.8410780, -106.8486310 39.8415920, -106.8486800 39.8418220, -106.8485590 39.8421320, -106.8483890 39.8426950, -106.8482340 39.8432910, -106.8480730 39.8441840, -106.8480460 39.8447570, -106.8479130 39.8456710, -106.8475770 39.8469410, -106.8474470 39.8474160, -106.8472200 39.8479690, -106.8470560 39.8482470, -106.8467540 39.8486590, -106.8461690 39.8491740, -106.8457240 39.8495980, -106.8461900 39.8499870, -106.8462670 39.8501730, -106.8462730 39.8504040, -106.8461120 39.8507800, -106.8455900 39.8515250, -106.8447850 39.8523410, -106.8441750 39.8529550, -106.8434490 39.8535270, -106.8420220 39.8545070, -106.8415860 39.8547330, -106.8414410 39.8548670, -106.8412100 39.8550800, -106.8408530 39.8555810, -106.8406250 39.8561230, -106.8405300 39.8564220, -106.8404670 39.8566210, -106.8403120 39.8572060, -106.8400230 39.8576070, -106.8397050 39.8579640, -106.8391860 39.8582990, -106.8386520 39.8585740, -106.8380300 39.8587490, -106.8364540 39.8589710, -106.8357590 39.8591030, -106.8352090 39.8593100, -106.8349347 39.8595567, -106.8348610 39.8596230, -106.8343150 39.8605340, -106.8340180 39.8611880, -106.8340290 39.8615840, -106.8342510 39.8624270, -106.8343760 39.8628430, -106.8344250 39.8630960, -106.8344300 39.8632610, -106.8344360 39.8634910, -106.8343040 39.8640420, -106.8342820 39.8641320, -106.8341520 39.8645850, -106.8341630 39.8650250, -106.8342330 39.8655300, -106.8343680 39.8657700, -106.8346930 39.8661940, -106.8351820 39.8666730, -106.8357310 39.8671790, -106.8361520 39.8674590, -106.8366440 39.8677480, -106.8371390 39.8681140, -106.8375460 39.8684160, -106.8379280 39.8688610, -106.8380800 39.8692110, -106.8382380 39.8697700, -106.8383820 39.8703840, -106.8384790 39.8709510, -106.8384920 39.8712840, -106.8384320 39.8717030, -106.8382810 39.8724760, -106.8382790 39.8729250, -106.8382820 39.8732490, -106.8382250 39.8735880, -106.8380700 39.8740760, -106.8380370 39.8745940, -106.8380720 39.8750200, -106.8382220 39.8773630, -106.8382830 39.8770240, -106.8383080 39.8768620, -106.8383880 39.8765860, -106.8385100 39.8763410, -106.8386720 39.8760240, -106.8387080 39.8758430, -106.8387350 39.8755500, -106.8387920 39.8752970, -106.8389250 39.8750030, -106.8390030 39.8748530, -106.8393170 39.8744300, -106.8397960 39.8738950, -106.8400200 39.8735270, -106.8402700 39.8732700, -106.8407290 39.8729350, -106.8411500 39.8725960, -106.8417130 39.8723450, -106.8420940 39.8722310, -106.8421380 39.8722180, -106.8425140 39.8722520, -106.8428460 39.8723450, -106.8436290 39.8725570, -106.8450050 39.8728330, -106.8456660 39.8730210, -106.8463010 39.8731710, -106.8464240 39.8731960, -106.8470750 39.8732840, -106.8477960 39.8733400, -106.8486970 39.8733760, -106.8496450 39.8734190, -106.8502530 39.8734550, -106.8508540 39.8735230, -106.8533430 39.8738470, -106.8581480 39.8744210, -106.8586650 39.8744920, -106.8593360 39.8745900, -106.8609260 39.8748730, -106.8636050 39.8753080, -106.8640210 39.8753550, -106.8644080 39.8753760, -106.8683010 39.8753550, -106.8693870 39.8753010, -106.8706940 39.8752000, -106.8713000 39.8751270, -106.8722460 39.8749050, -106.8725403 39.8748758, -106.8742580 39.8747060, -106.8744082 39.8746898, -106.8756720 39.8745540, -106.8760770 39.8745020, -106.8765310 39.8744410, -106.8769980 39.8744110, -106.8772380 39.8744070, -106.8776470 39.8744140, -106.8779760 39.8744540, -106.8782250 39.8744430, -106.8783140 39.8744390, -106.8785760 39.8743860, -106.8795320 39.8740940, -106.8801060 39.8739130, -106.8803850 39.8738460, -106.8806400 39.8737880, -106.8810790 39.8737940, -106.8813760 39.8737530, -106.8816430 39.8736860, -106.8819100 39.8736270, -106.8823010 39.8735980, -106.8827990 39.8736170, -106.8831850 39.8736380, -106.8836180 39.8736580, -106.8848190 39.8735160, -106.8850750 39.8734720, -106.8856460 39.8734260, -106.8860670 39.8734110, -106.8863000 39.8733890, -106.8866150 39.8733430, -106.8868830 39.8733210, -106.8871880 39.8733520, -106.8874570 39.8734430, -106.8877300 39.8734910, -106.8878230 39.8735080, -106.8881460 39.8735250, -106.8884490 39.8735150, -106.8887240 39.8735290, -106.8890660 39.8736220, -106.8894800 39.8738090, -106.8897040 39.8738730, -106.8900450 39.8739300, -106.8906020 39.8740020, -106.8908900 39.8740510, -106.8910850 39.8741340, -106.8911400 39.8742140, -106.8911560 39.8743670, -106.8911820 39.8744650, -106.8913320 39.8746070, -106.8914530 39.8747530, -106.8915390 39.8748960, -106.8916330 39.8751150, -106.8916650 39.8752450, -106.8916940 39.8754420, -106.8916990 39.8756310, -106.8916750 39.8757940, -106.8916000 39.8760510, -106.8915970 39.8761730, -106.8916290 39.8762400, -106.8916770 39.8763180, -106.8917790 39.8763990, -106.8918680 39.8764610, -106.8918820 39.8769600, -106.8919100 39.8771130, -106.8920100 39.8773630, -106.8920980 39.8777090, -106.8921190 39.8779200, -106.8922010 39.8781340, -106.8923120 39.8783400, -106.8924130 39.8786170, -106.8924750 39.8789580, -106.8925210 39.8791370, -106.8926150 39.8793880, -106.8926980 39.8798370, -106.8927870 39.8801140, -106.8928290 39.8803570, -106.8927860 39.8804920, -106.8927910 39.8806540, -106.8927890 39.8807940, -106.8928510 39.8809320, -106.8929660 39.8810700, -106.8931570 39.8812020, -106.8933840 39.8813870, -106.8934520 39.8815080, -106.8934980 39.8816870, -106.8935380 39.8818930, -106.8937250 39.8823130, -106.8938640 39.8824820, -106.8940460 39.8826950, -106.8942100 39.8829270, -106.8943560 39.8831220, -106.8945770 39.8833210, -106.8947980 39.8834710, -106.8950470 39.8835930, -106.8952480 39.8836700, -106.8955180 39.8837320, -106.8957600 39.8837880, -106.8957000 39.8839600, -106.8956350 39.8841370, -106.8955460 39.8843090, -106.8954550 39.8843920, -106.8953730 39.8843930, -106.8952670 39.8843680, -106.8951600 39.8842880, -106.8950400 39.8841820, -106.8948850 39.8840950, -106.8947080 39.8840350, -106.8944850 39.8840110, -106.8942270 39.8839620, -106.8940500 39.8839020, -106.8939660 39.8838440, -106.8937330 39.8836680, -106.8934820 39.8834560, -106.8932730 39.8832840, -106.8930570 39.8831170, -106.8928320 39.8830120, -106.8926730 39.8829740, -106.8925270 39.8829680, -106.8923520 39.8829980, -106.8922610 39.8830620, -106.8922440 39.8831170, -106.8923160 39.8831690, -106.8925700 39.8832460, -106.8926650 39.8833030, -106.8927250 39.8833650, -106.8928470 39.8835430, -106.8928980 39.8836960, -106.8929080 39.8838390, -106.8929920 39.8841310, -106.8931290 39.8844570, -106.8932040 39.8846180, -106.8932070 39.8847300, -106.8931980 39.8848340, -106.8931540 39.8849290, -106.8930630 39.8850210, -106.8928100 39.8851960, -106.8926210 39.8853300, -106.8925010 39.8854400, -106.8924680 39.8855170, -106.8924840 39.8856420, -106.8925690 39.8857540, -106.8927780 39.8859120, -106.8928550 39.8859740, -106.8928690 39.8860550, -106.8928190 39.8861460, -106.8927510 39.8862280, -106.8925910 39.8863740, -106.8924430 39.8865120, -106.8922890 39.8866410, -106.8921090 39.8869050, -106.8918130 39.8874050, -106.8915560 39.8878500, -106.8913710 39.8881410, -106.8912110 39.8884680, -106.8911190 39.8887670, -106.8910320 39.8890020, -106.8909260 39.8891890, -106.8907630 39.8894250, -106.8905380 39.8897530, -106.8903220 39.8899690, -106.8900930 39.8901390, -106.8896120 39.8904980, -106.8894440 39.8905730, -106.8892070 39.8906850, -106.8890340 39.8907690, -106.8887870 39.8909260, -106.8886150 39.8910550, -106.8882400 39.8914570, -106.8881780 39.8915260, -106.8881320 39.8915580, -106.8879030 39.8917190, -106.8877963 39.8917914, -106.8876040 39.8919220, -106.8874420 39.8919970, -106.8872510 39.8920680, -106.8870010 39.8921170, -106.8868210 39.8921420, -106.8865640 39.8921560, -106.8864120 39.8921720, -106.8862650 39.8921330, -106.8861450 39.8920500, -106.8859920 39.8920030, -106.8858460 39.8920010, -106.8856650 39.8920220, -106.8854580 39.8921470, -106.8852240 39.8923530, -106.8851280 39.8924810, -106.8850400 39.8926850, -106.8848120 39.8933370, -106.8845080 39.8941980, -106.8844460 39.8944780, -106.8844296 39.8945459, -106.8843730 39.8947810, -106.8842810 39.8950660, -106.8841470 39.8952840, -106.8837270 39.8957730, -106.8831650 39.8963990, -106.8825140 39.8971660, -106.8819410 39.8978150, -106.8815230 39.8983540, -106.8812940 39.8985560, -106.8811450 39.8986620, -106.8808920 39.8987960, -106.8805960 39.8989000, -106.8803580 39.8989670, -106.8799320 39.8990540, -106.8787300 39.8992980, -106.8783870 39.8993620, -106.8780090 39.8994400, -106.8773700 39.8995850, -106.8771090 39.8996700, -106.8766980 39.8998160, -106.8763900 39.8999070, -106.8759770 39.9000040, -106.8756010 39.9001400, -106.8751960 39.9002910, -106.8750150 39.9003390, -106.8746900 39.9004160, -106.8739920 39.9005670, -106.8730120 39.9008520, -106.8728150 39.9009100, -106.8726410 39.9009750, -106.8725200 39.9010450, -106.8723410 39.9011470, -106.8721700 39.9013070, -106.8720000 39.9015080, -106.8719570 39.9016260, -106.8719030 39.9018070, -106.8718840 39.9019690, -106.8718950 39.9021490, -106.8718510 39.9022630, -106.8717480 39.9023360, -106.8715970 39.9023790, -106.8714450 39.9023590, -106.8712210 39.9023090, -106.8709490 39.9022140, -106.8707480 39.9021270, -106.8705930 39.9020210, -106.8704730 39.9019020, -106.8704460 39.9017720, -106.8703900 39.9016460, -106.8702280 39.9014910, -106.8700670 39.9013860, -106.8697820 39.9012280, -106.8697040 39.9028350, -106.8697280 39.9029920, -106.8697504 39.9031408, -106.8698230 39.9036230, -106.8701660 39.9044010, -106.8701700 39.9045600, -106.8701740 39.9050200, -106.8693020 39.9062600, -106.8690110 39.9064920, -106.8684690 39.9069240, -106.8680840 39.9074960, -106.8674300 39.9079080, -106.8670450 39.9082520, -106.8668872 39.9084842, -106.8663920 39.9092130, -106.8657390 39.9099220, -106.8651258 39.9107839, -106.8649080 39.9110900, -106.8633340 39.9118000, -106.8616110 39.9124640, -106.8602750 39.9132650, -106.8599950 39.9135250, -106.8594140 39.9140660, -106.8593840 39.9142490, -106.8592360 39.9143180, -106.8590580 39.9145930, -106.8588210 39.9159420, -106.8584350 39.9164920, -106.8582280 39.9170410, -106.8583470 39.9178190, -106.8581100 39.9182080, -106.8576650 39.9191460, -106.8580510 39.9192140, -106.8755990 39.9188160, -106.8805780 39.9188220, -106.8859240 39.9188280, -106.8931390 39.9188370, -106.8984830 39.9188440, -106.9011190 39.9188470, -106.9094660 39.9188410, -106.9149210 39.9189110, -106.9256170 39.9188280, -106.9361690 39.9187430, -106.9462610 39.9187790, -106.9563540 39.9188160, -106.9650480 39.9187850, -106.9837370 39.9188710, -106.9918185 39.9188110, -106.9935710 39.9187980, -107.0006030 39.9190520, -107.0139240 39.9189980, -107.0272440 39.9189450, -107.0317600 39.9189210, -107.0319650 39.9292950, -107.0321720 39.9396700, -107.0322550 39.9438800, -107.0324270 39.9525510, -107.0324420 39.9533480, -107.0326490 39.9637260, -107.0317730 39.9637280, -107.0318720 39.9737310, -107.0319050 39.9770810, -107.0319720 39.9837340, -107.0319990 39.9918600, -107.0320270 39.9999860, -107.0320490 40.0029410, -107.0349540 40.0030180, -107.0373580 40.0030830, -107.0373510 40.0061100, -107.0373410 40.0104420, -107.0373220 40.0196210, -107.0373050 40.0276610, -107.0372880 40.0357010, -107.0372710 40.0437410, -107.0372100 40.0516600, -107.0372290 40.0533850, -107.0372680 40.0553250, -107.0372890 40.0563680, -107.0373130 40.0652110, -107.0373272 40.0725170, -107.0373300 40.0739870, -107.0373470 40.0827630, -107.0373640 40.0915390, -107.0536310 40.0915350, -107.0698920 40.0915260, -107.0742480 40.0914850, -107.0750540 40.0914830, -107.1018360 40.0914630, -107.1137210 40.0912770, -107.1256080 40.0910910, -107.1399920 40.0910530, -107.1543770 40.0910150, -107.1687620 40.0909780, -107.1831470 40.0909410, -107.1841790 40.0909380, -107.1998420 40.0908970, -107.2030750 40.0908890, -107.2155060 40.0908570, -107.2187800 40.0908480, -107.2346950 40.0908530, -107.2506110 40.0908590, -107.2542060 40.0908540, -107.2669650 40.0908360, -107.2780440 40.0908200, -107.2891240 40.0908040, -107.2887810 40.0903800, -107.2882450 40.0891450, -107.2881260 40.0884580, -107.2888710 40.0874290, -107.2888420 40.0864910, -107.2896160 40.0854620, -107.2896460 40.0850270, -107.2893780 40.0843180, -107.2882170 40.0830140, -107.2889630 40.0823510, -107.2892910 40.0818250, -107.2897380 40.0806580, -107.2905420 40.0794690, -107.2914060 40.0788520, -107.2934300 40.0784170, -107.2952470 40.0776170, -107.2966170 40.0772970, -107.3006370 40.0758790, -107.3019470 40.0752390, -107.3028700 40.0745300, -107.3035250 40.0735690, -107.3040610 40.0730430, -107.3051030 40.0723800, -107.3066810 40.0721740, -107.3074360 40.0721480, -107.3093700 40.0723750, -107.3098220 40.0723030, -107.3105170 40.0720230, -107.3115410 40.0713930, -107.3130510 40.0709230, -107.3136440 40.0706450, -107.3137080 40.0706140, -107.3141030 40.0704010, -107.3147490 40.0702460, -107.3160270 40.0701110, -107.3165650 40.0699650, -107.3170270 40.0557890, -107.3161590 40.0547260, -107.3150830 40.0541990, -107.3137630 40.0536210, -107.3134860 40.0534620, -107.3131200 40.0532060, -107.3126630 40.0527980, -107.3121800 40.0524560, -107.3114670 40.0520640, -107.3101410 40.0513320, -107.3093410 40.0509200, -107.3088590 40.0506120, -107.3084940 40.0503880, -107.3082140 40.0501190, -107.3073420 40.0492580, -107.3066300 40.0485040, -107.3062020 40.0480840, -107.3058070 40.0478290, -107.3053580 40.0476400, -107.3049980 40.0475700, -107.3042970 40.0475400, -107.3037670 40.0474960, -107.3034220 40.0474480, -107.3030710 40.0472250, -107.3021950 40.0466710, -107.3012160 40.0460100, -107.3007780 40.0457330, -107.3004010 40.0455760, -107.2998230 40.0454010, -107.2995030 40.0453260, -107.2994340 40.0453100, -107.2992590 40.0452150, -107.2991540 40.0450630, -107.2989140 40.0442990, -107.2986550 40.0437990, -107.2983410 40.0434100, -107.2976170 40.0426890, -107.2969240 40.0420440, -107.2965110 40.0416680, -107.2958240 40.0411990, -107.2952830 40.0408480, -107.2947020 40.0405520, -107.2932810 40.0399440, -107.2919340 40.0394000, -107.2910770 40.0390000, -107.2906130 40.0388010, -107.2904090 40.0386620, -107.2896850 40.0383910, -107.2892350 40.0381690, -107.2888140 40.0379910, -107.2883070 40.0377710, -107.2872310 40.0374450, -107.2863870 40.0371940, -107.2859400 40.0370720, -107.2846020 40.0368130, -107.2838540 40.0366520, -107.2830320 40.0364380, -107.2814290 40.0359320, -107.2809670 40.0357880, -107.2805440 40.0355110, -107.2800270 40.0349940, -107.2797780 40.0348350, -107.2789670 40.0345110, -107.2786320 40.0343200, -107.2772960 40.0336550, -107.2755800 40.0327570, -107.2745640 40.0323050, -107.2741280 40.0320610, -107.2738040 40.0317710, -107.2734510 40.0312510, -107.2731730 40.0308400, -107.2728790 40.0305940, -107.2723850 40.0303400, -107.2714920 40.0296990, -107.2710900 40.0292140, -107.2709980 40.0290290, -107.2705900 40.0287850, -107.2698160 40.0287120, -107.2692840 40.0286130, -107.2688190 40.0283920, -107.2684840 40.0282010, -107.2682490 40.0280080, -107.2678430 40.0278190, -107.2660350 40.0271530, -107.2656280 40.0269410, -107.2654210 40.0267370, -107.2651640 40.0262920, -107.2649960 40.0259770, -107.2647620 40.0258070, -107.2643850 40.0256500, -107.2640360 40.0254590, -107.2639420 40.0254010, -107.2636570 40.0252250, -107.2633240 40.0250890, -107.2629080 40.0250430, -107.2619800 40.0250720, -107.2616490 40.0249800, -107.2612550 40.0247570, -107.2608580 40.0244140, -107.2604640 40.0241590, -107.2598980 40.0238960, -107.2592490 40.0236890, -107.2581620 40.0232390, -107.2574520 40.0229240, -107.2561450 40.0222810, -107.2550880 40.0218520, -107.2543310 40.0214400, -107.2535300 40.0209730, -107.2524330 40.0201830, -107.2520660 40.0198830, -107.2518160 40.0196800, -107.2517260 40.0195390, -107.2516030 40.0192780, -107.2514280 40.0191720, -107.2506760 40.0188790, -107.2490260 40.0182460, -107.2486640 40.0181000, -107.2485570 40.0179900, -107.2484860 40.0179170, -107.2485040 40.0175760, -107.2486820 40.0169150, -107.2486740 40.0166840, -107.2484390 40.0164800, -107.2475770 40.0159150, -107.2472010 40.0157580, -107.2466720 40.0157570, -107.2459650 40.0159680, -107.2457970 40.0160690, -107.2455530 40.0164690, -107.2454120 40.0165370, -107.2451850 40.0165640, -107.2443990 40.0165560, -107.2441160 40.0166280, -107.2432990 40.0165440, -107.2424130 40.0165500, -107.2418830 40.0164940, -107.2406310 40.0162220, -107.2402440 40.0161960, -107.2398880 40.0162030, -107.2394890 40.0162330, -107.2392050 40.0162820, -107.2386500 40.0163470, -107.2383320 40.0163120, -107.2383220 40.0163100, -107.2383150 40.0163060, -107.2381910 40.0161760, -107.2381880 40.0161700, -107.2381890 40.0161620, -107.2382240 40.0160050, -107.2383040 40.0158380, -107.2383550 40.0156400, -107.2382620 40.0154220, -107.2378860 40.0148480, -107.2377210 40.0145980, -107.2369020 40.0140330, -107.2365920 40.0137200, -107.2363820 40.0134170, -107.2363230 40.0129250, -107.2363860 40.0122100, -107.2365170 40.0114070, -107.2364640 40.0111010, -107.2362980 40.0108300, -107.2360620 40.0106040, -107.2354390 40.0103530, -107.2351050 40.0101730, -107.2348930 40.0098150, -107.2345710 40.0095680, -107.2343070 40.0093540, -107.2342010 40.0091590, -107.2342500 40.0089270, -107.2344250 40.0085950, -107.2346850 40.0082500, -107.2350730 40.0078810, -107.2352790 40.0076360, -107.2354690 40.0073360, -107.2355630 40.0071260, -107.2355820 40.0068620, -107.2354470 40.0066460, -107.2351680 40.0064310, -107.2348620 40.0062290, -107.2346110 40.0059920, -107.2341760 40.0053320, -107.2338500 40.0049870, -107.2333440 40.0046570, -107.2330260 40.0042350, -107.2329120 40.0038090, -107.2329000 40.0034370, -107.2325690 40.0029490, -107.2323040 40.0027020, -107.2323360 40.0025300, -107.2323290 40.0020000, -107.2322090 40.0017150, -107.2319510 40.0014600, -107.2316650 40.0013110, -107.2314950 40.0011610, -107.2314820 40.0011410, -107.2314800 40.0011220, -107.2315350 40.0009840, -107.2315490 40.0009640, -107.2315780 40.0009510, -107.2317540 40.0009150, -107.2317840 40.0009140, -107.2318120 40.0009210, -107.2319950 40.0009990, -107.2321740 40.0012190, -107.2323460 40.0014510, -107.2324780 40.0018110, -107.2326060 40.0021320, -107.2326180 40.0021460, -107.2326370 40.0021580, -107.2327760 40.0021980, -107.2329480 40.0021560, -107.2329750 40.0021460, -107.2329900 40.0021290, -107.2330360 40.0020220, -107.2330280 40.0018680, -107.2328450 40.0013990, -107.2327190 40.0009990, -107.2325240 39.9999450, -107.2326330 39.9997740, -107.2328510 39.9995810, -107.2331490 39.9994270, -107.2353150 39.9988390, -107.2356130 39.9987120, -107.2357680 39.9985580, -107.2358310 39.9983820, -107.2358370 39.9979040, -107.2356990 39.9974470, -107.2353210 39.9969560, -107.2353210 39.9967010, -107.2353670 39.9965340, -107.2354470 39.9963850, -107.2379050 39.9942860, -107.2381120 39.9942120, -107.2383120 39.9941550, -107.2395160 39.9944360, -107.2398250 39.9945800, -107.2399630 39.9946600, -107.2401350 39.9946990, -107.2403990 39.9946020, -107.2407190 39.9943260, -107.2409430 39.9941850, -107.2410060 39.9941590, -107.2411320 39.9941240, -107.2413010 39.9940840, -107.2415830 39.9942530, -107.2419590 39.9943430, -107.2421840 39.9941770, -107.2421870 39.9938050, -107.2424040 39.9938230, -107.2424220 39.9941180, -107.2426880 39.9951910, -107.2427870 39.9955000, -107.2427940 39.9955160, -107.2431250 39.9967570, -107.2428010 39.9976800, -107.2429470 39.9981310, -107.2435610 39.9991460, -107.2435600 39.9995320, -107.2439650 39.9999830, -107.2533860 39.9983150, -107.2624970 39.9965620, -107.2718670 39.9949060, -107.2787320 39.9882580, -107.2855960 39.9816100, -107.2922120 39.9750580, -107.3016390 39.9713150, -107.3111850 39.9676590, -107.3190560 39.9654370, -107.3190280 39.9616040, -107.3189710 39.9539290, -107.3189150 39.9462540, -107.3188600 39.9385790, -107.3187910 39.9236020, -107.3187520 39.9149700, -107.3288270 39.9152470, -107.3405240 39.9155280, -107.3522200 39.9158110, -107.3639160 39.9160940, -107.3756120 39.9163770, -107.3869160 39.9166490, -107.3982200 39.9169210, -107.4095250 39.9171930, -107.4208300 39.9174650, -107.4316640 39.9177260, -107.4316520 39.9100980, -107.4316410 39.9024700, -107.4316390 39.9016390, -107.4316320 39.8967680, -107.4316160 39.8860980, -107.4316010 39.8749810, -107.4316730 39.8648070, -107.4317460 39.8546330, -107.4313770 39.8545170, -107.4309620 39.8542430, -107.4298940 39.8539000, -107.4295670 39.8535560, -107.4279650 39.8532130, -107.4275790 39.8528930, -107.4272230 39.8523440, -107.4267180 39.8521270, -107.4259470 39.8517950, -107.4250270 39.8516120, -107.4232460 39.8515660, -107.4228310 39.8514970, -107.4220890 39.8511770, -107.4211100 39.8511310, -107.4195670 39.8508340, -107.4187950 39.8509250, -107.4171930 39.8506730, -107.4163020 39.8504220, -107.4139290 39.8495980, -107.4119400 39.8490260, -107.4106050 39.8484760, -107.4094480 39.8474240, -107.4086770 39.8467830, -107.4084700 39.8457540, -107.4081440 39.8451360, -107.4075800 39.8444270, -107.4073130 39.8439240, -107.4070760 39.8427340, -107.4068690 39.8424140, -107.4064530 39.8420940, -107.4059490 39.8418650, -107.4056520 39.8414530, -107.4055050 39.8400800, -107.4061580 39.8390280, -107.4061880 39.8380680, -107.4060690 39.8377930, -107.4058020 39.8375190, -107.4039330 39.8368320, -107.4033110 39.8363060, -107.4020950 39.8349100, -107.4010270 39.8344070, -107.4007600 39.8341320, -107.4004640 39.8331710, -107.4002270 39.8329190, -107.3992180 39.8325530, -107.3988330 39.8322100, -107.3987440 39.8319810, -107.3980910 39.8321410, -107.3971120 39.8327810, -107.3968740 39.8328730, -107.3958950 39.8328270, -107.3937290 39.8332610, -107.3935810 39.8333520, -107.3926310 39.8334660, -107.3915040 39.8338090, -107.3888930 39.8338760, -107.3884180 39.8340590, -107.3873200 39.8339900, -107.3864900 39.8339900, -107.3848570 39.8346070, -107.3834030 39.8349720, -107.3815340 39.8357720, -107.3807320 39.8363660, -107.3801380 39.8365720, -107.3788920 39.8368910, -107.3784760 39.8375770, -107.3782380 39.8383780, -107.3780010 39.8386290, -107.3775550 39.8388580, -107.3774660 39.8394300, -107.3771100 39.8395670, -107.3756120 39.8396110, -107.3750970 39.8398150, -107.3746520 39.8400890, -107.3739110 39.8402730, -107.3736740 39.8409820, -107.3732890 39.8412800, -107.3715090 39.8418980, -107.3704410 39.8423790, -107.3684250 39.8439590, -107.3671490 39.8444170, -107.3664080 39.8450580, -107.3659040 39.8452180, -107.3651910 39.8452410, -107.3644490 39.8449900, -107.3631430 39.8443730, -107.3629060 39.8443500, -107.3617780 39.8444880, -107.3605320 39.8445110, -107.3594350 39.8450840, -107.3587520 39.8452210, -107.3561700 39.8447650, -107.3548930 39.8448120, -107.3538550 39.8455450, -107.3534990 39.8454990, -107.3522820 39.8451330, -107.3509170 39.8460680, -107.3502060 39.8462260, -107.3493160 39.8459500, -107.3490210 39.8455840, -107.3486360 39.8453320, -107.3482510 39.8453090, -107.3472120 39.8460600, -107.3468270 39.8462650, -107.3461150 39.8463100, -107.3454920 39.8466510, -107.3446020 39.8467410, -107.3432990 39.8465780, -107.3416700 39.8457520, -107.3404850 39.8454530, -107.3392690 39.8453820, -107.3370480 39.8443490, -107.3371510 39.8429840, -107.3369530 39.8428710, -107.3368650 39.8428720, -107.3367780 39.8429010, -107.3362530 39.8433050, -107.3361620 39.8433230, -107.3360630 39.8433300, -107.3359210 39.8432970, -107.3357230 39.8431390, -107.3355650 39.8429620, -107.3352830 39.8427600, -107.3350590 39.8425030, -107.3349630 39.8424470, -107.3346100 39.8423640, -107.3345010 39.8422580, -107.3344440 39.8421330, -107.3343530 39.8420450, -107.3342760 39.8419880, -107.3341680 39.8419220, -107.3337220 39.8417020, -107.3335890 39.8415650, -107.3334880 39.8413460, -107.3333930 39.8412800, -107.3332870 39.8412560, -107.3330140 39.8413150, -107.3329380 39.8413030, -107.3327300 39.8411950, -107.3326211 39.8411676, -107.3320810 39.8410320, -107.3317150 39.8409090, -107.3312510 39.8406660, -107.3311210 39.8406370, -107.3309870 39.8406310, -107.3305660 39.8406260, -107.3303080 39.8406130, -107.3299240 39.8406660, -107.3294130 39.8407440, -107.3291060 39.8408400, -107.3287940 39.8409180, -107.3286330 39.8410030, -107.3283970 39.8411250, -107.3279430 39.8415030, -107.3276540 39.8417930, -107.3275590 39.8419120, -107.3272150 39.8422700, -107.3269080 39.8425150, -107.3252540 39.8437330, -107.3247680 39.8442250, -107.3244230 39.8444640, -107.3242770 39.8446260, -107.3241270 39.8447920, -107.3240520 39.8450010, -107.3240230 39.8453480, -107.3239800 39.8454570, -107.3231670 39.8464820, -107.3226560 39.8471010, -107.3218760 39.8478650, -107.3215060 39.8481560, -107.3210020 39.8484860, -107.3200510 39.8492120, -107.3192200 39.8498640, -107.3191210 39.8498930, -107.3190400 39.8499040, -107.3189690 39.8498780, -107.3188960 39.8497990, -107.3188570 39.8496830, -107.3188070 39.8495750, -107.3186780 39.8494110, -107.3186380 39.8492410, -107.3186090 39.8490880, -107.3185460 39.8489590, -107.3184490 39.8488350, -107.3184350 39.8487720, -107.3184430 39.8486590, -107.3184400 39.8485920, -107.3183840 39.8484850, -107.3183400 39.8483860, -107.3183280 39.8482070, -107.3183020 39.8481210, -107.3182100 39.8479880, -107.3181900 39.8479250, -107.3181940 39.8478670, -107.3182030 39.8477770, -107.3181530 39.8476830, -107.3180980 39.8476210, -107.3181000 39.8475080, -107.3181240 39.8473590, -107.3181060 39.8471700, -107.3180660 39.8470230, -107.3179700 39.8467680, -107.3179720 39.8466420, -107.3179650 39.8460920, -107.3179700 39.8459070, -107.3180390 39.8455140, -107.3180040 39.8453530, -107.3179290 39.8451880, -107.3178770 39.8450490, -107.3178690 39.8447970, -107.3178420 39.8446940, -107.3177180 39.8444890, -107.3176280 39.8442570, -107.3175510 39.8433530, -107.3174800 39.8429580, -107.3174720 39.8427280, -107.3172020 39.8420050, -107.3170440 39.8416560, -107.3168850 39.8414340, -107.3165350 39.8409560, -107.3162320 39.8406330, -107.3159260 39.8402110, -107.3157300 39.8399630, -107.3155470 39.8397190, -107.3154980 39.8396440, -107.3154530 39.8395500, -107.3153600 39.8393670, -107.3153220 39.8392960, -107.3152680 39.8392340, -107.3150800 39.8390390, -107.3149950 39.8389420, -107.3149510 39.8388480, -107.3149070 39.8387590, -107.3147740 39.8386220, -107.3147250 39.8385690, -107.3146600 39.8385290, -107.3145460 39.8384550, -107.3145040 39.8384110, -107.3144550 39.8383490, -107.3144170 39.8382770, -107.3143290 39.8380860, -107.3143100 39.8380360, -107.3142730 39.8379880, -107.3140670 39.8377530, -107.3139950 39.8377090, -107.3139580 39.8376430, -107.3139000 39.8369590, -107.3138050 39.8365740, -107.3137040 39.8363410, -107.3135640 39.8360020, -107.3135050 39.8358140, -107.3134780 39.8357150, -107.3134180 39.8356490, -107.3132310 39.8354860, -107.3131470 39.8354250, -107.3131100 39.8353490, -107.3129500 39.8349510, -107.3127350 39.8344690, -107.3127070 39.8343120, -107.3126450 39.8341740, -107.3125290 39.8340680, -107.3123500 39.8339450, -107.3120650 39.8338110, -107.3119620 39.8337230, -107.3119010 39.8336390, -107.3118500 39.8335140, -107.3117570 39.8331480, -107.3116860 39.8329770, -107.3114420 39.8324740, -107.3111770 39.8320640, -107.3110470 39.8318680, -107.3109550 39.8317440, -107.3108100 39.8315840, -107.3106770 39.8314560, -107.3105560 39.8313330, -107.3103000 39.8310000, -107.3101980 39.8309250, -107.3101300 39.8308320, -107.3100990 39.8307560, -107.3100320 39.8306770, -107.3099410 39.8305930, -107.3097800 39.8305020, -107.3096670 39.8304020, -107.3096050 39.8303160, -107.3095230 39.8301330, -107.3094790 39.8300570, -107.3094120 39.8299730, -107.3091540 39.8297620, -107.3087740 39.8293760, -107.3081130 39.8288500, -107.3079680 39.8287270, -107.3078840 39.8286430, -107.3078230 39.8285770, -107.3078100 39.8285370, -107.3077600 39.8284390, -107.3076920 39.8283360, -107.3075780 39.8282350, -107.3074820 39.8281560, -107.3073920 39.8280860, -107.3073130 39.8280060, -107.3072520 39.8279310, -107.3072090 39.8278730, -107.3071490 39.8278160, -107.3071060 39.8277670, -107.3070350 39.8277230, -107.3069280 39.8276720, -107.3065020 39.8273470, -107.3064540 39.8272850, -107.3063810 39.8272140, -107.3062290 39.8270410, -107.3060870 39.8269630, -107.3060440 39.8269060, -107.3057680 39.8267040, -107.3056850 39.8266650, -107.3056310 39.8266120, -107.3054080 39.8264230, -107.3053360 39.8263700, -107.3052480 39.8263360, -107.3049460 39.8262110, -107.3046480 39.8260550, -107.3045050 39.8259770, -107.3043150 39.8258900, -107.3041380 39.8258130, -107.3040130 39.8257610, -107.3033640 39.8255670, -107.3024990 39.8253900, -107.3023700 39.8253570, -107.3022510 39.8253050, -107.3019610 39.8251890, -107.3019020 39.8251640, -107.3018010 39.8251300, -107.3011890 39.8249750, -107.3010710 39.8249640, -107.3009540 39.8249480, -107.3007140 39.8249350, -107.3003350 39.8249420, -107.2998670 39.8249340, -107.2997450 39.8249580, -107.2993570 39.8250520, -107.2992460 39.8250670, -107.2991140 39.8251150, -107.2987340 39.8252800, -107.2986360 39.8253270, -107.2985370 39.8253510, -107.2984270 39.8253630, -107.2982050 39.8253800, -107.2980770 39.8253960, -107.2979800 39.8254430, -107.2977960 39.8255370, -107.2975530 39.8256180, -107.2974190 39.8256390, -107.2972920 39.8256730, -107.2967770 39.8258230, -107.2966960 39.8258560, -107.2966220 39.8259110, -107.2965720 39.8259660, -107.2964860 39.8260180, -107.2963770 39.8260740, -107.2962600 39.8260940, -107.2961210 39.8261150, -107.2956760 39.8262500, -107.2955130 39.8262750, -107.2953900 39.8262730, -107.2953140 39.8262570, -107.2952300 39.8262090, -107.2952100 39.8261840, -107.2951690 39.8261330, -107.2949330 39.8256970, -107.2948710 39.8255950, -107.2947920 39.8255150, -107.2947160 39.8253410, -107.2947010 39.8252380, -107.2946850 39.8250890, -107.2947150 39.8249490, -107.2947400 39.8248180, -107.2947490 39.8247330, -107.2947340 39.8246430, -107.2946670 39.8245630, -107.2946470 39.8244730, -107.2946370 39.8243700, -107.2945870 39.8242630, -107.2945260 39.8241740, -107.2944650 39.8240530, -107.2944260 39.8239740, -107.2943640 39.8238890, -107.2942680 39.8238010, -107.2941370 39.8237360, -107.2940070 39.8236800, -107.2938720 39.8236560, -107.2938120 39.8236340, -107.2937820 39.8235940, -107.2937800 39.8235840, -107.2937820 39.8235740, -107.2938090 39.8235350, -107.2938890 39.8234840, -107.2939460 39.8234290, -107.2939670 39.8233610, -107.2937880 39.8229060, -107.2937210 39.8228220, -107.2936100 39.8226430, -107.2935660 39.8225630, -107.2935690 39.8224730, -107.2935640 39.8223200, -107.2935220 39.8221140, -107.2935020 39.8220480, -107.2934900 39.8220070, -107.2934510 39.8218950, -107.2933780 39.8218060, -107.2932990 39.8217180, -107.2932380 39.8216330, -107.2931880 39.8215350, -107.2931440 39.8214460, -107.2930780 39.8212310, -107.2930500 39.8211020, -107.2930110 39.8209810, -107.2929610 39.8208830, -107.2929010 39.8208080, -107.2928340 39.8207460, -107.2927960 39.8206610, -107.2927760 39.8205800, -107.2927850 39.8204900, -107.2929180 39.8201000, -107.2929420 39.8199430, -107.2930220 39.8195310, -107.2930290 39.8194050, -107.2930140 39.8192970, -107.2929840 39.8189290, -107.2929510 39.8188080, -107.2929360 39.8187140, -107.2929620 39.8186050, -107.2929980 39.8184740, -107.2930120 39.8183750, -107.2929960 39.8182440, -107.2930210 39.8181040, -107.2930900 39.8173870, -107.2931320 39.8172430, -107.2931820 39.8171420, -107.2932260 39.8170610, -107.2932690 39.8169610, -107.2932950 39.8168700, -107.2933270 39.8167700, -107.2934140 39.8165930, -107.2935030 39.8164390, -107.2935480 39.8163790, -107.2935800 39.8163110, -107.2935840 39.8162340, -107.2935400 39.8161630, -107.2934180 39.8160130, -107.2933750 39.8159410, -107.2933560 39.8158790, -107.2933530 39.8157840, -107.2933680 39.8157210, -107.2934120 39.8156530, -107.2934520 39.8156020, -107.2934610 39.8155440, -107.2934530 39.8154720, -107.2934380 39.8153820, -107.2934410 39.8152740, -107.2935840 39.8148300, -107.2936200 39.8146940, -107.2936520 39.8145950, -107.2937350 39.8144810, -107.2938250 39.8144170, -107.2939120 39.8143510, -107.2939680 39.8142830, -107.2939660 39.8142020, -107.2939450 39.8141070, -107.2939320 39.8140540, -107.2939170 39.8139770, -107.2939200 39.8138870, -107.2939400 39.8137880, -107.2939660 39.8136970, -107.2939800 39.8135890, -107.2939880 39.8134670, -107.2940010 39.8133500, -107.2939870 39.8132600, -107.2939710 39.8131350, -107.2939450 39.8130540, -107.2939610 39.8128380, -107.2939960 39.8126620, -107.2939980 39.8125310, -107.2940220 39.8123880, -107.2940820 39.8122650, -107.2940970 39.8121840, -107.2941050 39.8120750, -107.2941410 39.8119340, -107.2941920 39.8118790, -107.2942590 39.8117790, -107.2942730 39.8116710, -107.2943800 39.8112010, -107.2944050 39.8111010, -107.2943920 39.8110290, -107.2943300 39.8109500, -107.2942520 39.8108700, -107.2941960 39.8107720, -107.2941750 39.8106600, -107.2941540 39.8102150, -107.2941330 39.8100940, -107.2941000 39.8099780, -107.2940730 39.8098970, -107.2940010 39.8097430, -107.2939250 39.8095740, -107.2938260 39.8093870, -107.2937850 39.8092250, -107.2937670 39.8090280, -107.2937380 39.8088570, -107.2937190 39.8087110, -107.2936540 39.8081840, -107.2936220 39.8079060, -107.2936170 39.8077700, -107.2936410 39.8076120, -107.2937130 39.8074750, -107.2938820 39.8072920, -107.2942070 39.8070600, -107.2948050 39.8065930, -107.2950450 39.8064310, -107.2952100 39.8063190, -107.2953810 39.8061890, -107.2954530 39.8060530, -107.2954950 39.8059300, -107.2955490 39.8057850, -107.2957820 39.8052390, -107.2958360 39.8051210, -107.2958560 39.8050130, -107.2958640 39.8049090, -107.2958310 39.8047830, -107.2957800 39.8046620, -107.2957070 39.8045600, -107.2956640 39.8044930, -107.2955740 39.8044410, -107.2954850 39.8044020, -107.2953850 39.8043820, -107.2952370 39.8043080, -107.2951410 39.8042290, -107.2950380 39.8041320, -107.2949250 39.8040570, -107.2946120 39.8039510, -107.2944690 39.8038720, -107.2943840 39.8037660, -107.2943510 39.8036630, -107.2943610 39.8035520, -107.2943890 39.8034050, -107.2944440 39.8032920, -107.2945340 39.8031910, -107.2946130 39.8031120, -107.2947200 39.8029930, -107.2948050 39.8029060, -107.2948730 39.8028550, -107.2949710 39.8028030, -107.2950620 39.8027480, -107.2951420 39.8026920, -107.2952210 39.8025960, -107.2952520 39.8024820, -107.2952540 39.8023610, -107.2952440 39.8022480, -107.2952940 39.8021570, -107.2953780 39.8020610, -107.2954860 39.8019590, -107.2956060 39.8018980, -107.2957400 39.8018600, -107.2958420 39.8017900, -107.2959270 39.8016980, -107.2959760 39.8015890, -107.2960260 39.8015210, -107.2960810 39.8014200, -107.2962720 39.8011910, -107.2963230 39.8011230, -107.2963720 39.8010310, -107.2964860 39.8007720, -107.2965530 39.8006810, -107.2966880 39.8005340, -107.2968980 39.8003270, -107.2969540 39.8002780, -107.2970450 39.8001980, -107.2971130 39.8001250, -107.2971570 39.8000560, -107.2973940 39.7996140, -107.2974660 39.7995140, -107.2975460 39.7994450, -107.2976310 39.7993750, -107.2976870 39.7992980, -107.2976900 39.7992210, -107.2976870 39.7991170, -107.2977070 39.7990270, -107.2977560 39.7989310, -107.2978240 39.7988580, -107.2981110 39.7983700, -107.2981820 39.7982240, -107.2982420 39.7980740, -107.2983010 39.7979200, -107.2983660 39.7978330, -107.2984980 39.7977000, -107.2985820 39.7975990, -107.2986940 39.7974430, -107.2987820 39.7972840, -107.2988250 39.7971790, -107.2988560 39.7970530, -107.2988740 39.7968810, -107.2988630 39.7967420, -107.2988870 39.7965880, -107.2989580 39.7964240, -107.2990680 39.7962420, -107.2991050 39.7961290, -107.2991590 39.7959700, -107.2992180 39.7958240, -107.2992640 39.7956300, -107.2993070 39.7955120, -107.2993990 39.7953160, -107.2995450 39.7951190, -107.2995930 39.7949880, -107.2996070 39.7948750, -107.2996130 39.7947030, -107.2995480 39.7945200, -107.2994910 39.7943900, -107.2994620 39.7942150, -107.2994230 39.7940810, -107.2993780 39.7939830, -107.2992300 39.7937290, -107.2991380 39.7936000, -107.2990940 39.7935110, -107.2990430 39.7933810, -107.2990390 39.7932460, -107.2990750 39.7931010, -107.2992010 39.7928640, -107.2992550 39.7927420, -107.2993030 39.7925870, -107.2993640 39.7924910, -107.2994870 39.7923400, -107.2996090 39.7921440, -107.3000470 39.7916260, -107.3001200 39.7915260, -107.3002340 39.7914380, -107.3010600 39.7908360, -107.3014470 39.7905270, -107.3015670 39.7904390, -107.3016530 39.7903870, -107.3017090 39.7903320, -107.3017880 39.7902360, -107.3019390 39.7900300, -107.3019780 39.7899710, -107.3020400 39.7899290, -107.3020980 39.7898920, -107.3021610 39.7898680, -107.3022480 39.7898390, -107.3023570 39.7897920, -107.3024490 39.7897450, -107.3025170 39.7896760, -107.3025720 39.7895940, -107.3026110 39.7895210, -107.3026790 39.7894700, -107.3027710 39.7894240, -107.3028400 39.7893770, -107.3029010 39.7893080, -107.3029280 39.7892220, -107.3029700 39.7891000, -107.3030890 39.7889710, -107.3032360 39.7888330, -107.3033560 39.7887590, -107.3034770 39.7886980, -107.3038990 39.7883970, -107.3040410 39.7882860, -107.3041440 39.7882250, -107.3044520 39.7880030, -107.3045420 39.7879200, -107.3045980 39.7878290, -107.3046280 39.7876890, -107.3048340 39.7873780, -107.3049270 39.7872010, -107.3050110 39.7870950, -107.3051140 39.7870120, -107.3052560 39.7869190, -107.3053360 39.7868640, -107.3053860 39.7867860, -107.3054240 39.7866770, -107.3054550 39.7865780, -107.3054980 39.7864550, -107.3056100 39.7863090, -107.3057160 39.7861580, -107.3059910 39.7858370, -107.3060410 39.7857640, -107.3061170 39.7855780, -107.3062270 39.7853820, -107.3062940 39.7853040, -107.3063320 39.7852270, -107.3063530 39.7851270, -107.3064070 39.7850050, -107.3064800 39.7849350, -107.3065540 39.7848620, -107.3066570 39.7847920, -107.3067760 39.7846820, -107.3068830 39.7845900, -107.3069210 39.7844940, -107.3069240 39.7844130, -107.3068940 39.7841930, -107.3069310 39.7840800, -107.3069980 39.7839930, -107.3071210 39.7838460, -107.3073960 39.7835030, -107.3075380 39.7833780, -107.3076580 39.7833130, -107.3077790 39.7832660, -107.3079300 39.7832310, -107.3080330 39.7831750, -107.3080830 39.7831070, -107.3080920 39.7830300, -107.3080720 39.7829540, -107.3079700 39.7826720, -107.3079820 39.7825140, -107.3080480 39.7823820, -107.3081490 39.7822630, -107.3082960 39.7821470, -107.3084280 39.7820680, -107.3085250 39.7819940, -107.3087970 39.7815830, -107.3093130 39.7809380, -107.3094210 39.7808500, -107.3095480 39.7808160, -107.3097050 39.7807910, -107.3098320 39.7807520, -107.3099760 39.7807000, -107.3101890 39.7806150, -107.3103920 39.7805570, -107.3106120 39.7805070, -107.3107390 39.7804690, -107.3108360 39.7804130, -107.3108150 39.7802870, -107.3107930 39.7801660, -107.3107320 39.7800770, -107.3106370 39.7800340, -107.3105090 39.7800360, -107.3100650 39.7800360, -107.3099690 39.7800260, -107.3098890 39.7800170, -107.3097760 39.7799650, -107.3096000 39.7799230, -107.3094420 39.7799270, -107.3092450 39.7799760, -107.3091240 39.7800090, -107.3089670 39.7800220, -107.3088380 39.7800240, -107.3082050 39.7799370, -107.3078940 39.7798890, -107.3076480 39.7798580, -107.3074840 39.7798530, -107.3073330 39.7798870, -107.3071960 39.7799710, -107.3061570 39.7805000, -107.3059970 39.7805890, -107.3058600 39.7806950, -107.3057530 39.7807970, -107.3056670 39.7808520, -107.3051880 39.7810240, -107.3051010 39.7810350, -107.3049890 39.7810100, -107.3046010 39.7809180, -107.3044640 39.7808440, -107.3043210 39.7807610, -107.3041610 39.7806840, -107.3040130 39.7806280, -107.3038320 39.7806220, -107.3036170 39.7806540, -107.3033040 39.7807140, -107.3031240 39.7807580, -107.3029210 39.7807800, -107.3026930 39.7807710, -107.3024860 39.7807120, -107.3023490 39.7806250, -107.3022770 39.7805540, -107.3022040 39.7804700, -107.3016210 39.7799720, -107.3014710 39.7798630, -107.3012690 39.7797450, -107.3007130 39.7793550, -107.3005930 39.7792670, -107.3004380 39.7791760, -107.3002650 39.7790620, -107.3001280 39.7789700, -107.3000150 39.7788960, -107.2999290 39.7787890, -107.2998960 39.7786550, -107.2998860 39.7785250, -107.2999470 39.7782800, -107.3000830 39.7779710, -107.3001930 39.7777570, -107.3002490 39.7775310, -107.2999170 39.7776300, -107.2996860 39.7776970, -107.2993960 39.7777480, -107.2992010 39.7777630, -107.2990210 39.7778160, -107.2988200 39.7778970, -107.2987040 39.7779260, -107.2985870 39.7779200, -107.2984220 39.7778730, -107.2982210 39.7778010, -107.2980380 39.7777280, -107.2978970 39.7777080, -107.2976520 39.7777310, -107.2973560 39.7777720, -107.2971760 39.7777990, -107.2970640 39.7777830, -107.2969510 39.7777130, -107.2968770 39.7775970, -107.2967860 39.7774910, -107.2966470 39.7773590, -107.2965150 39.7772490, -107.2963540 39.7771480, -107.2962520 39.7770470, -107.2961840 39.7769260, -107.2961380 39.7767700, -107.2960370 39.7765460, -107.2959870 39.7764440, -107.2958780 39.7763380, -107.2957170 39.7762190, -107.2955380 39.7761190, -107.2953550 39.7760510, -107.2946200 39.7759030, -107.2944140 39.7758490, -107.2941960 39.7757810, -107.2938890 39.7756880, -107.2937710 39.7756500, -107.2936070 39.7756170, -107.2934770 39.7755750, -107.2933120 39.7755280, -107.2931770 39.7755130, -107.2930080 39.7755120, -107.2928970 39.7755180, -107.2928110 39.7755560, -107.2927020 39.7756300, -107.2925790 39.7757720, -107.2925430 39.7759260, -107.2924990 39.7760130, -107.2924090 39.7761090, -107.2922770 39.7761790, -107.2919640 39.7762660, -107.2917270 39.7763290, -107.2915520 39.7763380, -107.2914300 39.7763580, -107.2913200 39.7763740, -107.2912080 39.7763490, -107.2911360 39.7762920, -107.2910700 39.7762340, -107.2909870 39.7761820, -107.2908750 39.7761570, -107.2906590 39.7761660, -107.2904910 39.7761960, -107.2903920 39.7762120, -107.2902650 39.7762500, -107.2901910 39.7762920, -107.2900300 39.7763850, -107.2897130 39.7765820, -107.2895930 39.7767410, -107.2894520 39.7769010, -107.2894120 39.7769380, -107.2893330 39.7770070, -107.2892240 39.7770590, -107.2891070 39.7770610, -107.2887430 39.7769920, -107.2880920 39.7769190, -107.2878870 39.7769000, -107.2876950 39.7769040, -107.2874910 39.7769260, -107.2873110 39.7769570, -107.2871260 39.7770150, -107.2866940 39.7771720, -107.2865190 39.7771840, -107.2863500 39.7772100, -107.2861770 39.7772490, -107.2860140 39.7772710, -107.2858560 39.7772740, -107.2856750 39.7772640, -107.2854990 39.7772360, -107.2853520 39.7772030, -107.2852340 39.7771640, -107.2851100 39.7771220, -107.2849320 39.7770350, -107.2848000 39.7769340, -107.2847580 39.7768860, -107.2846810 39.7768550, -107.2845640 39.7768530, -107.2844310 39.7768740, -107.2843150 39.7769120, -107.2841700 39.7769470, -107.2839900 39.7769820, -107.2838810 39.7770330, -107.2838130 39.7770890, -107.2833920 39.7775880, -107.2833060 39.7776480, -107.2832140 39.7776810, -107.2831030 39.7776790, -107.2829960 39.7776360, -107.2829000 39.7775390, -107.2828260 39.7774370, -107.2827470 39.7773440, -107.2826090 39.7772340, -107.2825190 39.7771640, -107.2824070 39.7771030, -107.2822250 39.7770700, -107.2819430 39.7770310, -107.2818020 39.7770070, -107.2816560 39.7769960, -107.2815330 39.7770030, -107.2814180 39.7770410, -107.2813140 39.7770840, -107.2811590 39.7771450, -107.2808930 39.7772270, -107.2806090 39.7773050, -107.2805050 39.7773200, -107.2804040 39.7773180, -107.2802220 39.7772780, -107.2799540 39.7772110, -107.2797210 39.7771670, -107.2791040 39.7770220, -107.2789590 39.7770110, -107.2788060 39.7770220, -107.2786750 39.7771390, -107.2786550 39.7773100, -107.2780430 39.7764300, -107.2782030 39.7762790, -107.2784070 39.7761400, -107.2782140 39.7758890, -107.2774730 39.7754310, -107.2763840 39.7750290, -107.2752500 39.7746380, -107.2751780 39.7746050, -107.2746550 39.7743030, -107.2745680 39.7739350, -107.2740880 39.7734770, -107.2737250 39.7731640, -107.2735220 39.7728180, -107.2734290 39.7727780, -107.2734220 39.7727730, -107.2734190 39.7727660, -107.2733920 39.7725930, -107.2733900 39.7725860, -107.2733850 39.7725790, -107.2733790 39.7725750, -107.2725050 39.7721050, -107.2719960 39.7721160, -107.2713570 39.7719370, -107.2707910 39.7716250, -107.2695270 39.7704750, -107.2690760 39.7704080, -107.2678130 39.7705080, -107.2661850 39.7701400, -107.2655170 39.7702290, -107.2649070 39.7706760, -107.2641520 39.7709210, -107.2630330 39.7716920, -107.2624080 39.7718700, -107.2616530 39.7719370, -107.2608690 39.7721830, -107.2597640 39.7728290, -107.2592710 39.7732650, -107.2586460 39.7743480, -107.2582100 39.7746940, -107.2577160 39.7749280, -107.2559150 39.7752970, -107.2558630 39.7753310, -107.2555680 39.7755200, -107.2553300 39.7760000, -107.2549150 39.7762290, -107.2539660 39.7764570, -107.2520980 39.7767310, -107.2506100 39.7772200, -107.2495360 39.7775050, -107.2478760 39.7775290, -107.2472530 39.7773010, -107.2468670 39.7769580, -107.2465400 39.7758600, -107.2458580 39.7753800, -107.2440190 39.7745110, -107.2436340 39.7741680, -107.2435440 39.7738940, -107.2433070 39.7736200, -107.2423880 39.7732540, -107.2417650 39.7728650, -107.2412910 39.7727650, -107.2412510 39.7727590, -107.2412120 39.7727590, -107.2411720 39.7727690, -107.2411380 39.7727850, -107.2408780 39.7729800, -107.2404440 39.7731010, -107.2404070 39.7731090, -107.2403720 39.7731100, -107.2403380 39.7731020, -107.2403110 39.7730870, -107.2400750 39.7729350, -107.2398670 39.7724090, -107.2392450 39.7719290, -107.2389780 39.7718140, -107.2386510 39.7709680, -107.2378790 39.7686810, -107.2374040 39.7677200, -107.2369880 39.7671260, -107.2363060 39.7664170, -107.2347940 39.7655940, -107.2341120 39.7654800, -107.2326590 39.7647480, -107.2318580 39.7645660, -107.2304060 39.7645890, -107.2300500 39.7644750, -107.2299310 39.7642920, -107.2299010 39.7635830, -107.2289510 39.7624620, -107.2288330 39.7621650, -107.2286540 39.7616160, -107.2282090 39.7608150, -107.2269340 39.7598090, -107.2267270 39.7595350, -107.2263410 39.7592370, -107.2245630 39.7588260, -107.2237030 39.7582550, -107.2226950 39.7577750, -107.2215090 39.7574780, -107.2195530 39.7575920, -107.2181300 39.7570440, -107.2177450 39.7570440, -107.2125300 39.7589440, -107.2119960 39.7593330, -107.2115810 39.7597450, -107.2098630 39.7606140, -107.2084400 39.7608210, -107.2079940 39.7610040, -107.2076390 39.7614380, -107.2065720 39.7618050, -107.2044080 39.7619880, -107.2041410 39.7618960, -107.2037860 39.7616450, -107.2026290 39.7600440, -107.1986570 39.7566810, -107.1978570 39.7558350, -107.1969970 39.7551030, -107.1969970 39.7550110, -107.1950120 39.7547140, -107.1940340 39.7543710, -107.1911290 39.7528380, -107.1907140 39.7524720, -107.1905840 39.7521880, -107.1902100 39.7523580, -107.1895880 39.7519230, -107.1891730 39.7514890, -107.1881650 39.7507570, -107.1869500 39.7504710, -107.1867730 39.7504020, -107.1868350 39.7499830, -107.1868070 39.7496380, -107.1865700 39.7495120, -107.1860960 39.7492900, -107.1849400 39.7493130, -107.1842880 39.7494500, -107.1833820 39.7499830, -107.1832160 39.7503220, -107.1821200 39.7504140, -107.1814090 39.7503680, -107.1810850 39.7499830, -107.1809100 39.7495700, -107.1790130 39.7485130, -107.1783610 39.7485360, -107.1768500 39.7490390, -107.1758420 39.7495130, -107.1751310 39.7495470, -107.1748940 39.7496040, -107.1747140 39.7499840, -107.1737920 39.7508940, -107.1726960 39.7513060, -107.1713320 39.7515800, -107.1702650 39.7515800, -107.1682500 39.7514190, -107.1650490 39.7518760, -107.1633010 39.7520590, -107.1616710 39.7521040, -107.1598630 39.7519210, -107.1590330 39.7517610, -107.1582920 39.7515090, -107.1574930 39.7510050, -107.1566620 39.7504810, -107.1573980 39.7501810, -107.1572880 39.7429610, -107.1572040 39.7416090, -107.1573530 39.7378730, -107.1576420 39.7322070, -107.1577010 39.7292160, -107.1579360 39.7241690, -107.1580290 39.7191110, -107.1581020 39.7164600, -107.1580430 39.7147810, -107.1580850 39.7126700, -107.1581430 39.7070980, -107.1581460 39.6998630, -107.1580910 39.6950870, -107.1580340 39.6908890, -107.1579890 39.6872690, -107.1580400 39.6839130, -107.1579490 39.6790960, -107.1579170 39.6778050, -107.1594630 39.6778140, -107.1593110 39.6755640, -107.1592810 39.6716570, -107.1592360 39.6676730, -107.1593380 39.6601660, -107.1580650 39.6605710, -107.1574080 39.6605980, -107.1568210 39.6610050, -107.1563480 39.6611880, -107.1555780 39.6613030, -107.1553770 39.6612610, -107.1551050 39.6613720, -107.1541570 39.6614630, -107.1524410 39.6612790, -107.1519380 39.6611190, -107.1511690 39.6605930, -107.1504410 39.6603820, -107.1498660 39.6604090, -107.1492940 39.6605140, -107.1448920 39.6613230, -107.1432650 39.6613910, -107.1425050 39.6613480, -107.1416160 39.6613220, -107.1397010 39.6611170, -107.1382350 39.6606660, -107.1369880 39.6604670, -107.1360980 39.6600230, -107.1351430 39.6594410, -107.1323830 39.6582050, -107.1311960 39.6580040, -107.1303500 39.6580970, -107.1289650 39.6584160, -107.1266670 39.6585500, -107.1254390 39.6589580, -107.1251690 39.6590580, -107.1238530 39.6596080, -107.1232680 39.6599340, -107.1228310 39.6600380, -107.1210990 39.6600980, -107.1196280 39.6597740, -107.1195420 39.6597450, -107.1185320 39.6594530, -107.1152440 39.6580770, -107.1142860 39.6570870, -107.1141060 39.6568110, -107.1137460 39.6565360, -107.1134830 39.6564950, -107.1134860 39.6540400, -107.1135050 39.6404660, -107.1135314 39.6378789, -107.1135493 39.6360648, -107.1135696 39.6342482, -107.1136307 39.6322583, -107.1136944 39.6303066, -107.1137631 39.6283090, -107.1138293 39.6263599, -107.1138522 39.6255063, -107.1138677 39.6250839, -107.1138714 39.6250419, -107.1138738 39.6249925, -107.1138740 39.6248000, -107.1138660 39.6246620, -107.1138680 39.6246220, -107.1138740 39.6244980, -107.1138660 39.6243480, -107.1137740 39.6131570, -107.1136830 39.6018520, -107.1135990 39.5914060, -107.1135980 39.5912690, -107.1136340 39.5825840, -107.1136710 39.5738990, -107.1137028 39.5664400, -107.1137080 39.5652140, -107.1137450 39.5565300, -107.1137920 39.5453600, -107.1138390 39.5341910, -107.1138790 39.5246920, -107.1139130 39.5166520, -107.1139470 39.5086130, -107.1097821 39.5101574, -107.1034240 39.5125150, -107.0984806 39.5143307, -107.0983988 39.5143782, -107.0975909 39.5146777, -107.0975064 39.5146952, -107.0929000 39.5164170, -107.0895520 39.5176210, -107.0892530 39.5180850, -107.0892070 39.5180720, -107.0888810 39.5180050, -107.0886460 39.5179560, -107.0884600 39.5179870, -107.0884200 39.5180260, -107.0883470 39.5180970, -107.0882180 39.5184410, -107.0881420 39.5186050, -107.0879260 39.5187710, -107.0876160 39.5189110, -107.0874370 39.5191580, -107.0865380 39.5202100, -107.0861460 39.5207120, -107.0859090 39.5209690, -107.0855450 39.5212360, -107.0846800 39.5218640, -107.0837920 39.5225110, -107.0834720 39.5227150, -107.0807800 39.5241240, -107.0796720 39.5247920, -107.0794080 39.5249050, -107.0791680 39.5249290, -107.0785400 39.5249900, -107.0783330 39.5250480, -107.0782360 39.5251260, -107.0777650 39.5256190, -107.0774580 39.5258500, -107.0767830 39.5262400, -107.0761080 39.5265950, -107.0756140 39.5268200, -107.0752060 39.5271790, -107.0749590 39.5274890, -107.0746750 39.5277200, -107.0743110 39.5279960, -107.0739100 39.5282110, -107.0736600 39.5284140, -107.0735260 39.5285780, -107.0735310 39.5287580, -107.0735840 39.5289650, -107.0737930 39.5293480, -107.0738430 39.5294730, -107.0738130 39.5296270, -107.0735940 39.5297030, -107.0734080 39.5297060, -107.0732080 39.5296470, -107.0726580 39.5295310, -107.0723210 39.5295550, -107.0718860 39.5295970, -107.0714010 39.5297600, -107.0709960 39.5298380, -107.0706080 39.5299720, -107.0699260 39.5302990, -107.0693840 39.5303780, -107.0691280 39.5303750, -107.0678170 39.5301100, -107.0667550 39.5301020, -107.0664090 39.5300720, -107.0660900 39.5299350, -107.0650700 39.5293130, -107.0644090 39.5289200, -107.0642070 39.5288700, -107.0637980 39.5288680, -107.0635190 39.5288720, -107.0631010 39.5289050, -107.0622190 39.5291370, -107.0614320 39.5293830, -107.0609340 39.5294850, -107.0594150 39.5297790, -107.0592070 39.5298430, -107.0590130 39.5299910, -107.0585341 39.5302371, -107.0552200 39.5319400, -107.0548530 39.5321360, -107.0546110 39.5322120, -107.0542500 39.5321910, -107.0536900 39.5321470, -107.0531900 39.5321560, -107.0529700 39.5321780, -107.0528210 39.5322790, -107.0526750 39.5324350, -107.0524830 39.5326460, -107.0522200 39.5327940, -107.0518710 39.5328090, -107.0515660 39.5327070, -107.0514860 39.5326240, -107.0513260 39.5324580, -107.0512530 39.5323140, -107.0511900 39.5321910, -107.0510250 39.5313200, -107.0509480 39.5310960, -107.0508520 39.5309710, -107.0506580 39.5307310, -107.0502640 39.5303870, -107.0497410 39.5299910, -107.0493260 39.5297280, -107.0488430 39.5295200, -107.0484460 39.5294640, -107.0480120 39.5294510, -107.0477320 39.5294380, -107.0475460 39.5294460, -107.0473970 39.5295290, -107.0472500 39.5296720, -107.0471550 39.5297900, -107.0470520 39.5298420, -107.0469100 39.5298600, -107.0470210 39.5296780, -107.0472230 39.5294400, -107.0473690 39.5292660, -107.0475520 39.5291370, -107.0477220 39.5289990, -107.0485220 39.5280930, -107.0486420 39.5279400, -107.0487130 39.5277810, -107.0487150 39.5276500, -107.0485980 39.5273690, -107.0484430 39.5269950, -107.0484000 39.5267350, -107.0484300 39.5261580, -107.0484940 39.5255620, -107.0485490 39.5250750, -107.0486450 39.5247760, -107.0487440 39.5245760, -107.0487940 39.5243050, -107.0488100 39.5240340, -107.0487900 39.5237730, -107.0486910 39.5235680, -107.0486400 39.5234160, -107.0486520 39.5229650, -107.0486800 39.5227190, -107.0486720 39.5224180, -107.0486450 39.5221120, -107.0485440 39.5216450, -107.0484640 39.5212950, -107.0483410 39.5208830, -107.0483360 39.5206110, -107.0483100 39.5197290, -107.0482350 39.5195320, -107.0481740 39.5194340, -107.0481590 39.5193350, -107.0482830 39.5191890, -107.0484200 39.5190960, -107.0484810 39.5188160, -107.0484710 39.5184650, -107.0483840 39.5182860, -107.0483570 39.5181340, -107.0483990 39.5179980, -107.0485200 39.5177340, -107.0485780 39.5173550, -107.0486550 39.5168050, -107.0487020 39.5164440, -107.0486230 39.5161210, -107.0483610 39.5159180, -107.0480190 39.5157440, -107.0477500 39.5157040, -107.0469130 39.5157090, -107.0466100 39.5156790, -107.0464350 39.5155940, -107.0464050 39.5155340, -107.0463340 39.5153950, -107.0462680 39.5151350, -107.0462490 39.5148830, -107.0462310 39.5146850, -107.0463070 39.5144680, -107.0467850 39.5133520, -107.0468750 39.5128460, -107.0469440 39.5124130, -107.0468900 39.5121710, -107.0467810 39.5120010, -107.0466380 39.5119050, -107.0464150 39.5118280, -107.0462370 39.5117050, -107.0461030 39.5115000, -107.0459650 39.5112750, -107.0458120 39.5110820, -107.0457250 39.5109220, -107.0454910 39.5108540, -107.0452450 39.5108130, -107.0449320 39.5108450, -107.0447010 39.5108850, -107.0446300 39.5108390, -107.0444870 39.5107450, -107.0442960 39.5105680, -107.0440840 39.5104820, -107.0439090 39.5104580, -107.0437120 39.5104890, -107.0433100 39.5106760, -107.0430260 39.5108880, -107.0428700 39.5111250, -107.0427150 39.5113880, -107.0424430 39.5116450, -107.0421730 39.5119290, -107.0419210 39.5120780, -107.0413830 39.5123750, -107.0410950 39.5124790, -107.0407480 39.5125210, -107.0404460 39.5125630, -107.0401570 39.5125950, -107.0398060 39.5125200, -107.0396620 39.5124950, -107.0392910 39.5124300, -107.0388940 39.5123650, -107.0386820 39.5122870, -107.0385270 39.5121550, -107.0383460 39.5119420, -107.0381790 39.5118010, -107.0379670 39.5117050, -107.0377320 39.5116110, -107.0375640 39.5114330, -107.0373570 39.5111220, -107.0371750 39.5108820, -107.0369490 39.5106970, -107.0365350 39.5104700, -107.0363100 39.5103210, -107.0362000 39.5101430, -107.0362010 39.5097910, -107.0362370 39.5094210, -107.0362230 39.5089450, -107.0361120 39.5083160, -107.0359900 39.5077330, -107.0358770 39.5074470, -107.0356570 39.5070820, -107.0353820 39.5068250, -107.0350970 39.5066140, -107.0348010 39.5064480, -107.0344230 39.5062480, -107.0340660 39.5059660, -107.0338670 39.5059160, -107.0336250 39.5060010, -107.0333520 39.5062130, -107.0330950 39.5065680, -107.0328750 39.5070130, -107.0326580 39.5071520, -107.0324070 39.5073010, -107.0320890 39.5075760, -107.0317620 39.5079150, -107.0315040 39.5082620, -107.0310930 39.5089260, -107.0308450 39.5091740, -107.0306280 39.5093120, -107.0304310 39.5093340, -107.0299530 39.5093060, -107.0292890 39.5092730, -107.0287540 39.5092730, -107.0284150 39.5092160, -107.0280160 39.5090700, -107.0278700 39.5089580, -107.0278640 39.5089470, -107.0277870 39.5088040, -107.0276690 39.5086460, -107.0274420 39.5085580, -107.0271890 39.5085550, -107.0269680 39.5085640, -107.0267440 39.5086350, -107.0265050 39.5087180, -107.0262140 39.5087230, -107.0258160 39.5086310, -107.0232120 39.5078750, -107.0228010 39.5077290, -107.0223520 39.5075120, -107.0219620 39.5073030, -107.0215960 39.5070930, -107.0212980 39.5068470, -107.0210210 39.5065090, -107.0208270 39.5062610, -107.0205630 39.5059590, -107.0203830 39.5057820, -107.0201570 39.5056060, -107.0195650 39.5052470, -107.0192330 39.5050370, -107.0188900 39.5048360, -107.0186190 39.5046970, -107.0183600 39.5046020, -107.0180090 39.5045180, -107.0175650 39.5044630, -107.0173320 39.5044400, -107.0171080 39.5043450, -107.0168930 39.5041420, -107.0162890 39.5033690, -107.0156690 39.5024680, -107.0155010 39.5022390, -107.0153780 39.5020310, -107.0153220 39.5017340, -107.0153820 39.5010680, -107.0153210 39.5007890, -107.0152420 39.5006470, -107.0150430 39.5005220, -107.0146220 39.5004210, -107.0138930 39.5001360, -107.0134470 39.4999020, -107.0130880 39.4997730, -107.0126500 39.4997000, -107.0124520 39.4996620, -107.0122170 39.4996170, -107.0118170 39.4994440, -107.0113700 39.4992720, -107.0106810 39.4989770, -107.0103660 39.4987210, -107.0102090 39.4985250, -107.0101800 39.4983180, -107.0103270 39.4977750, -107.0102750 39.4975770, -107.0100540 39.4973870, -107.0097600 39.4972750, -107.0087840 39.4970890, -107.0083030 39.4969310, -107.0080080 39.4967960, -107.0075950 39.4965690, -107.0071170 39.4961540, -107.0068300 39.4960600, -107.0066380 39.4960630, -107.0062390 39.4961240, -107.0055650 39.4961720, -107.0050630 39.4962850, -107.0044470 39.4962910, -107.0041090 39.4962880, -107.0036630 39.4961420, -107.0029460 39.4958750, -107.0025550 39.4958010, -107.0019530 39.4956940, -107.0016940 39.4956000, -107.0010390 39.4952640, -107.0004780 39.4949410, -107.0000320 39.4947060, -106.9997800 39.4943140, -106.9995860 39.4939660, -106.9993970 39.4937930, -106.9990640 39.4935780, -106.9985050 39.4933670, -106.9972930 39.4930910, -106.9968920 39.4929760, -106.9966040 39.4927940, -106.9957640 39.4921810, -106.9955270 39.4918330, -106.9952570 39.4913090, -106.9951530 39.4911460, -106.9949350 39.4909400, -106.9942140 39.4905340, -106.9940580 39.4905370, -106.9938630 39.4906390, -106.9935290 39.4908760, -106.9933050 39.4909560, -106.9927950 39.4909870, -106.9922160 39.4910630, -106.9916310 39.4911610, -106.9912140 39.4912220, -106.9884130 39.4910250, -106.9879190 39.4910020, -106.9874160 39.4912530, -106.9853340 39.4923330, -106.9848710 39.4925060, -106.9845640 39.4926870, -106.9844770 39.4931060, -106.9843880 39.4934930, -106.9840950 39.4941580, -106.9837430 39.4947470, -106.9831950 39.4953950, -106.9827100 39.4957990, -106.9823770 39.4960460, -106.9818150 39.4962320, -106.9814880 39.4962040, -106.9812020 39.4960990, -106.9808540 39.4958520, -106.9806180 39.4955150, -106.9803440 39.4943530, -106.9798720 39.4932050, -106.9789890 39.4915580, -106.9786980 39.4907930, -106.9786030 39.4904320, -106.9785960 39.4901790, -106.9787650 39.4896480, -106.9789680 39.4893140, -106.9793760 39.4882070, -106.9794100 39.4879100, -106.9792290 39.4875170, -106.9787730 39.4869190, -106.9782060 39.4864230, -106.9778010 39.4861320, -106.9774950 39.4858510, -106.9770990 39.4853850, -106.9764140 39.4847140, -106.9759070 39.4843160, -106.9758160 39.4842740, -106.9754900 39.4841250, -106.9750760 39.4840210, -106.9743810 39.4840000, -106.9726650 39.4839630, -106.9705240 39.4839650, -106.9699030 39.4840530, -106.9690290 39.4842430, -106.9684220 39.4843190, -106.9679360 39.4843358, -106.9677850 39.4843410, -106.9670880 39.4842650, -106.9665880 39.4841300, -106.9660570 39.4838750, -106.9653630 39.4834250, -106.9649390 39.4829590, -106.9646450 39.4825680, -106.9642840 39.4823210, -106.9637270 39.4821870, -106.9633430 39.4821600, -106.9627340 39.4821810, -106.9612200 39.4822620, -106.9594790 39.4823350, -106.9568850 39.4823560, -106.9562890 39.4823330, -106.9550980 39.4823310, -106.9549540 39.4822230, -106.9538240 39.4808670, -106.9523240 39.4789340, -106.9518530 39.4783040, -106.9511550 39.4776780, -106.9504860 39.4770510, -106.9500360 39.4766620, -106.9497190 39.4764700, -106.9484970 39.4758520, -106.9481390 39.4757490, -106.9475000 39.4756820, -106.9460070 39.4755200, -106.9454790 39.4753970, -106.9450210 39.4752290, -106.9445020 39.4749290, -106.9435480 39.4742630, -106.9433280 39.4739810, -106.9429960 39.4737780, -106.9418620 39.4732470, -106.9417150 39.4731690, -106.9414590 39.4730330, -106.9411600 39.4729940, -106.9407230 39.4730680, -106.9399350 39.4732900, -106.9396670 39.4733050, -106.9392810 39.4731910, -106.9383118 39.4727874, -106.9378330 39.4725880, -106.9375440 39.4723840, -106.9349140 39.4710970, -106.9344250 39.4708410, -106.9340350 39.4705510, -106.9336540 39.4701180, -106.9333970 39.4695280, -106.9329430 39.4684800, -106.9327070 39.4681540, -106.9322440 39.4677990, -106.9319220 39.4674420, -106.9317820 39.4670040, -106.9315300 39.4662670, -106.9314900 39.4661510, -106.9312790 39.4657150, -106.9309600 39.4654570, -106.9305890 39.4653420, -106.9301490 39.4653490, -106.9299400 39.4654520, -106.9296620 39.4656540, -106.9287880 39.4663390, -106.9285930 39.4664861, -106.9283850 39.4666430, -106.9280060 39.4667480, -106.9266010 39.4666950, -106.9254390 39.4666810, -106.9249400 39.4666010, -106.9243830 39.4664350, -106.9240070 39.4661440, -106.9226870 39.4645390, -106.9226660 39.4645140, -106.9223350 39.4641050, -106.9218700 39.4636840, -106.9214510 39.4634050, -106.9210790 39.4632790, -106.9202840 39.4632160, -106.9192740 39.4630900, -106.9186600 39.4629130, -106.9178430 39.4625530, -106.9169530 39.4621390, -106.9167158 39.4620424, -106.9164080 39.4619170, -106.9159300 39.4615510, -106.9155510 39.4611510, -106.9149470 39.4602920, -106.9144960 39.4593760, -106.9142000 39.4588980, -106.9138770 39.4584970, -106.9132950 39.4574180, -106.9129630 39.4566760, -106.9126890 39.4559660, -106.9126280 39.4553080, -106.9124920 39.4549910, -106.9122000 39.4546880, -106.9118960 39.4544520, -106.9114510 39.4542760, -106.9111230 39.4541460, -106.9108630 39.4539850, -106.9106000 39.4536820, -106.9103490 39.4533010, -106.9100760 39.4526570, -106.9097970 39.4517720, -106.9095450 39.4508530, -106.9094620 39.4504260, -106.9094430 39.4497230, -106.9096120 39.4486540, -106.9096270 39.4481590, -106.9095010 39.4477000, -106.9092780 39.4473190, -106.9089580 39.4469940, -106.9080000 39.4462500, -106.9079740 39.4462300, -106.9064750 39.4453100, -106.9053530 39.4446810, -106.9033670 39.4435490, -106.9028050 39.4432070, -106.9023600 39.4429950, -106.9019260 39.4426390, -106.9013280 39.4420340, -106.9009760 39.4415780, -106.9006420 39.4412870, -106.8998640 39.4408170, -106.8992700 39.4403320, -106.8985490 39.4398610, -106.8981740 39.4396250, -106.8966800 39.4388480, -106.8962060 39.4385930, -106.8958880 39.4383560, -106.8955140 39.4381650, -106.8950300 39.4380960, -106.8945130 39.4381350, -106.8939610 39.4383550, -106.8931260 39.4389190, -106.8926710 39.4393770, -106.8923180 39.4398130, -106.8923010 39.4398330, -106.8918830 39.4400820, -106.8911670 39.4403350, -106.8904610 39.4404240, -106.8894140 39.4404640, -106.8889430 39.4403620, -106.8883440 39.4402070, -106.8876350 39.4401750, -106.8871420 39.4402820, -106.8864700 39.4405900, -106.8859690 39.4409060, -106.8855560 39.4413520, -106.8852780 39.4415650, -106.8849130 39.4416920, -106.8843080 39.4418450, -106.8829360 39.4419010, -106.8823540 39.4418670, -106.8817150 39.4418220, -106.8813730 39.4417620, -106.8803760 39.4415260, -106.8798310 39.4413050, -106.8791570 39.4410080, -106.8786930 39.4406090, -106.8783710 39.4402300, -106.8775590 39.4389800, -106.8771890 39.4384040, -106.8770520 39.4380550, -106.8769020 39.4377280, -106.8768750 39.4372560, -106.8767900 39.4362030, -106.8766520 39.4357990, -106.8764480 39.4355930, -106.8761460 39.4354230, -106.8758600 39.4353170, -106.8756030 39.4352560, -106.8745410 39.4350380, -106.8729340 39.4348100, -106.8713690 39.4345600, -106.8701140 39.4342170, -106.8692870 39.4340210, -106.8685560 39.4337030, -106.8681970 39.4335330, -106.8677710 39.4334850, -106.8673630 39.4336010, -106.8671930 39.4335930, -106.8669190 39.4334210, -106.8668100 39.4333730)))";
+
   void assertRelation(
       std::string_view relation,
       std::optional<std::string_view> leftWkt,
@@ -96,8 +105,100 @@ class GeometryFunctionsTest : public FunctionBaseTest {
       EXPECT_FALSE(actual.has_value());
     }
   }
+  facebook::velox::RowVectorPtr makeSingleStringInputRow(
+      std::optional<std::string> input) {
+    auto vec = makeNullableFlatVector<std::string>({input});
+    return makeRowVector({vec});
+  }
+
+  bool aboutEquals(double a, double b) {
+    double diff = std::abs(a - b);
+    double scale = std::max(std::abs(a), std::abs(b));
+    return diff <= std::max(1e-5, 1e-5 * scale);
+  }
 };
 
+TEST_F(GeometryFunctionsTest, errorStGeometryFromTextAndParsing) {
+  const auto assertGeomFromText = [&](const std::optional<std::string>& a) {
+    return evaluateOnce<std::string>("ST_GeometryFromText(c0)", a);
+  };
+  const auto assertGeomFromBinary = [&](const std::optional<std::string>& wkt) {
+    return evaluateOnce<std::string>(
+        "to_hex(ST_AsBinary(ST_GeomFromBinary(from_hex(c0))))", wkt);
+  };
+
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("xyz"),
+      "Failed to parse WKT: ParseException: Unknown type: 'XYZ'");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("LINESTRING (-71.3839245 42.3128124)"),
+      "Failed to parse WKT: IllegalArgumentException: point array must contain 0 or >1 elements");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText(
+          "POLYGON ((-13.637339 9.617113, -13.637339 9.617113))"),
+      "Failed to parse WKT: IllegalArgumentException: Invalid number of points in LinearRing found 2 - must be 0 or >= 4");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("POLYGON(0 0)"),
+      "Failed to parse WKT: ParseException: Expected word but encountered number: '0'");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("POLYGON((0 0))"),
+      "Failed to parse WKT: IllegalArgumentException: point array must contain 0 or >1 elements");
+
+  // WKT invalid cases
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText(""), "Expected word but encountered end of stream");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("RANDOM_TEXT"), "Unknown type: 'RANDOM_TEXT'");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("LINESTRING (1 1)"),
+      "point array must contain 0 or >1 elements");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("LINESTRING ()"),
+      "Expected number but encountered ')'");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("POLYGON ((0 0, 0 0))"),
+      "Invalid number of points in LinearRing found 2 - must be 0 or >= 4");
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromText("POLYGON ((0 0, 0 1, 1 1, 1 0))"),
+      "Points of LinearRing do not form a closed linestring");
+
+  // WKB invalid cases
+  // Empty
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromBinary(""), "Unexpected EOF parsing WKB");
+
+  // Random bytes
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromBinary("ABCDEF"), "Unexpected EOF parsing WKB");
+
+  // Unrecognized geometry type
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromBinary("0109000000000000000000F03F0000000000000040"),
+      "Unknown WKB type 9");
+
+  // Point with missing y
+  VELOX_ASSERT_USER_THROW(
+      assertGeomFromBinary("0101000000000000000000F03F"),
+      "Unexpected EOF parsing WKB");
+
+  // LineString with only one point
+  VELOX_ASSERT_THROW(
+      assertGeomFromBinary(
+          "010200000001000000000000000000F03F000000000000F03F"),
+      "point array must contain 0 or >1 elements");
+
+  // Polygon with unclosed LinString
+  VELOX_ASSERT_THROW(
+      assertGeomFromBinary(
+          "01030000000100000004000000000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F000000000000F03F0000000000000000"),
+      "Points of LinearRing do not form a closed linestring");
+
+  VELOX_ASSERT_THROW(
+      assertGeomFromBinary(
+          "010300000001000000020000000000000000000000000000000000000000000000000000000000000000000000"),
+      "Invalid number of points in LinearRing found 2 - must be 0 or >= 4");
+}
+
 TEST_F(GeometryFunctionsTest, wktAndWkb) {
   const auto wktRoundTrip = [&](const std::optional<std::string>& a) {
     return evaluateOnce<std::string>("ST_AsText(ST_GeometryFromText(c0))", a);
@@ -118,6 +219,11 @@ TEST_F(GeometryFunctionsTest, wktAndWkb) {
         "to_hex(ST_AsBinary(ST_GeomFromBinary(from_hex(c0))))", wkt);
   };
 
+  const auto wktRoundTripSpherical = [&](const std::optional<std::string>& a) {
+    return evaluateOnce<std::string>(
+        "ST_AsText(to_spherical_geography(ST_GeometryFromText(c0)))", a);
+  };
+
   const std::vector<std::string> wkts = {
       "POINT (1 2)",
       "LINESTRING (0 0, 10 10)",
@@ -126,32 +232,31 @@ TEST_F(GeometryFunctionsTest, wktAndWkb) {
       "MULTIPOINT (1 2, 3 4)",
       "MULTILINESTRING ((0 0, 1 1), (2 2, 3 3))",
       "MULTIPOLYGON (((0 0, 0 1, 1 1, 1 0, 0 0)), ((2 2, 2 3, 3 3, 3 2, 2 2)))",
-      "GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (3 4, 5 6))"};
-
-  const std::vector<std::string> wkbs = {
-      "0101000000000000000000F03F0000000000000040",
-      "0102000000020000000000000000000000000000000000000000000000000024400000000000002440",
-      "010300000001000000050000000000000000000000000000000000000000000000000000000000000000001440000000000000144000000000000014400000000000001440000000000000000000000000000000000000000000000000",
-      "01030000000200000005000000000000000000000000000000000000000000000000000000000000000000144000000000000014400000000000001440000000000000144000000000000000000000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000001040000000000000F03F00000000000010400000000000001040000000000000F03F0000000000001040000000000000F03F000000000000F03F",
-      "0104000000020000000101000000000000000000F03F0000000000000040010100000000000000000008400000000000001040",
-      "01050000000200000001020000000200000000000000000000000000000000000000000000000000F03F000000000000F03F0102000000020000000000000000000040000000000000004000000000000008400000000000000840",
-      "01060000000200000001030000000100000005000000000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F000000000000F03F000000000000000000000000000000000000000000000000010300000001000000050000000000000000000040000000000000004000000000000000400000000000000840000000000000084000000000000008400000000000000840000000000000004000000000000000400000000000000040",
-      "0107000000020000000101000000000000000000F03F00000000000000400102000000020000000000000000000840000000000000104000000000000014400000000000001840"};
+      "MULTIPOLYGON (((0 0, 0 4, 4 4, 4 0, 0 0), (1 1, 3 1, 3 3, 1 3, 1 1)), ((5 5, 5 7, 7 7, 7 5, 5 5)))",
+      "GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (3 4, 5 6))",
+      "GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), GEOMETRYCOLLECTION (POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)))))",
+      "GEOMETRYCOLLECTION (MULTILINESTRING ((0 0, 1 1), (2 2, 3 3)), MULTIPOLYGON (((0 0, 0 1, 1 1, 1 0, 0 0)), ((2 2, 2 3, 3 3, 3 2, 2 2))))"};
+
+  const std::vector<std::string> wkbs = {"0101000000000000000000F03F0000000000000040", "0102000000020000000000000000000000000000000000000000000000000024400000000000002440", "010300000001000000050000000000000000000000000000000000000000000000000000000000000000001440000000000000144000000000000014400000000000001440000000000000000000000000000000000000000000000000", "01030000000200000005000000000000000000000000000000000000000000000000000000000000000000144000000000000014400000000000001440000000000000144000000000000000000000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000001040000000000000F03F00000000000010400000000000001040000000000000F03F0000000000001040000000000000F03F000000000000F03F", "0104000000020000000101000000000000000000F03F0000000000000040010100000000000000000008400000000000001040", "01050000000200000001020000000200000000000000000000000000000000000000000000000000F03F000000000000F03F0102000000020000000000000000000040000000000000004000000000000008400000000000000840", "01060000000200000001030000000100000005000000000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F000000000000F03F000000000000000000000000000000000000000000000000010300000001000000050000000000000000000040000000000000004000000000000000400000000000000840000000000000084000000000000008400000000000000840000000000000004000000000000000400000000000000040", "01060000000200000001030000000200000005000000000000000000000000000000000000000000000000000000000000000000104000000000000010400000000000001040000000000000104000000000000000000000000000000000000000000000000005000000000000000000F03F000000000000F03F0000000000000840000000000000F03F00000000000008400000000000000840000000000000F03F0000000000000840000000000000F03F000000000000F03F010300000001000000050000000000000000001440000000000000144000000000000014400000000000001C400000000000001C400000000000001C400000000000001C40000000000000144000000000000014400000000000001440", "0107000000020000000101000000000000000000F03F00000000000000400102000000020000000000000000000840000000000000104000000000000014400000000000001840", "0107000000020000000101000000000000000000F03F000000000000F03F01070000000200000001020000000200000000000000000000000000000000000000000000000000F03F000000000000F03F010700000001000000010300000001000000050000000000000000000040000000000000004000000000000000400000000000000840000000000000084000000000000008400000000000000840000000000000004000000000000000400000000000000040", "01070000000200000001050000000200000001020000000200000000000000000000000000000000000000000000000000F03F000000000000F03F010200000002000000000000000000004000000000000000400000000000000840000000000000084001060000000200000001030000000100000005000000000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F000000000000F03F000000000000000000000000000000000000000000000000010300000001000000050000000000000000000040000000000000004000000000000000400000000000000840000000000000084000000000000008400000000000000840000000000000004000000000000000400000000000000040"};
 
   const std::vector<std::string> bigEndianWkbs = {
       "00000000013FF00000000000004000000000000000",
       "0000000002000000020000000000000000000000000000000040240000000000004024000000000000",
       "000000000300000001000000050000000000000000000000000000000000000000000000004014000000000000401400000000000040140000000000004014000000000000000000000000000000000000000000000000000000000000",
-      "000000000300000002000000050000000000000000000000000000000000000000000000004014000000000000401400000000000040140000000000004014000000000000000000000000000000000000000000000000000000000000000000053ff00000000000003ff000000000000040100000000000003ff0000000000000401000000000000040100000000000003ff000000000000040100000000000003ff00000000000003ff0000000000000",
-      "00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000",
-      "000000000500000002000000000200000002000000000000000000000000000000003ff00000000000003ff00000000000000000000002000000024000000000000000400000000000000040080000000000004008000000000000",
-      "000000000600000002000000000300000001000000050000000000000000000000000000000000000000000000003ff00000000000003ff00000000000003ff00000000000003ff0000000000000000000000000000000000000000000000000000000000000000000000300000001000000054000000000000000400000000000000040000000000000004008000000000000400800000000000040080000000000004008000000000000400000000000000040000000000000004000000000000000",
-      "00000000070000000200000000013ff000000000000040000000000000000000000002000000024008000000000000401000000000000040140000000000004018000000000000",
-  };
+      "000000000300000002000000050000000000000000000000000000000000000000000000004014000000000000401400000000000040140000000000004014000000000000000000000000000000000000000000000000000000000000000000053FF00000000000003FF000000000000040100000000000003FF0000000000000401000000000000040100000000000003FF000000000000040100000000000003FF00000000000003FF0000000000000",
+      "00000000040000000200000000013FF00000000000004000000000000000000000000140080000000000004010000000000000",
+      "000000000500000002000000000200000002000000000000000000000000000000003FF00000000000003FF00000000000000000000002000000024000000000000000400000000000000040080000000000004008000000000000",
+      "000000000600000002000000000300000001000000050000000000000000000000000000000000000000000000003FF00000000000003FF00000000000003FF00000000000003FF0000000000000000000000000000000000000000000000000000000000000000000000300000001000000054000000000000000400000000000000040000000000000004008000000000000400800000000000040080000000000004008000000000000400000000000000040000000000000004000000000000000",
+      "000000000600000002000000000300000002000000050000000000000000000000000000000000000000000000004010000000000000401000000000000040100000000000004010000000000000000000000000000000000000000000000000000000000000000000053FF00000000000003FF00000000000003FF000000000000040080000000000004008000000000000400800000000000040080000000000003FF00000000000003FF00000000000003FF000000000000000000000030000000100000005401400000000000040140000000000004014000000000000401c000000000000401c000000000000401c000000000000401c000000000000401400000000000040140000000000004014000000000000",
+      "00000000070000000200000000013FF000000000000040000000000000000000000002000000024008000000000000401000000000000040140000000000004018000000000000",
+      "00000000070000000200000000013FF00000000000003FF0000000000000000000000700000002000000000200000002000000000000000000000000000000003FF00000000000003FF0000000000000000000000700000001000000000300000001000000054000000000000000400000000000000040080000000000004000000000000000400800000000000040080000000000004000000000000000400800000000000040000000000000004000000000000000",
+      //      "000000000700000002000000000500000002000000000200000002000000000000000000000000000000003FF00000000000003FF0000000000000000000000200000002400000000000000040000000000000004008000000000000400800000000000000000000060000000200000000030000000100000005000000000000000000000000000000000000000000000000000000000000f03f000000000000f03f000000000000f03f000000000000f03f000000000000000000000000000000000000000000000000010300000001000000050000000000000000000040000000000000004000000000000000400000000000000840000000000000084000000000000008400000000000000840000000000000004000000000000000400000000000000040"
+      "000000000700000002000000000500000002000000000200000002000000000000000000000000000000003FF00000000000003FF00000000000000000000002000000024000000000000000400000000000000040080000000000004008000000000000000000000600000002000000000300000001000000050000000000000000000000000000000000000000000000003FF00000000000003FF00000000000003FF00000000000003FF0000000000000000000000000000000000000000000000000000000000000000000000300000001000000054000000000000000400000000000000040000000000000004008000000000000400800000000000040080000000000004008000000000000400000000000000040000000000000004000000000000000"};
 
   for (size_t i = 0; i < wkts.size(); i++) {
     assert(i < wkbs.size() && i < bigEndianWkbs.size());
     EXPECT_EQ(wkts[i], wktRoundTrip(wkts[i]));
+    EXPECT_EQ(wkts[i], wktRoundTripSpherical(wkts[i]));
     EXPECT_EQ(wkbs[i], wktToWkb(wkts[i]));
     EXPECT_EQ(wkts[i], wkbToWkT(wkbs[i]));
     EXPECT_EQ(wkbs[i], wkbRoundTrip(wkbs[i]));
@@ -181,59 +286,14 @@ TEST_F(GeometryFunctionsTest, wktAndWkb) {
   for (size_t i = 0; i < emptyGeometryWkts.size(); i++) {
     assert(i < emptyGeometryWkbs.size());
     EXPECT_EQ(wktRoundTrip(emptyGeometryWkts[i]), emptyGeometryWkts[i]);
+    EXPECT_EQ(
+        wktRoundTripSpherical(emptyGeometryWkts[i]), emptyGeometryWkts[i]);
     EXPECT_EQ(emptyGeometryWkbs[i], wktToWkb(emptyGeometryWkts[i]));
     EXPECT_EQ(emptyGeometryWkts[i], wkbToWkT(emptyGeometryWkbs[i]));
     EXPECT_EQ(emptyGeometryWkbs[i], wkbRoundTrip(emptyGeometryWkbs[i]));
   }
-
-  // WKT invalid cases
-  VELOX_ASSERT_USER_THROW(
-      wktRoundTrip(""), "Expected word but encountered end of stream");
-  VELOX_ASSERT_USER_THROW(
-      wktRoundTrip("RANDOM_TEXT"), "Unknown type: 'RANDOM_TEXT'");
-  VELOX_ASSERT_USER_THROW(
-      wktRoundTrip("LINESTRING (1 1)"),
-      "point array must contain 0 or >1 elements");
-  VELOX_ASSERT_USER_THROW(
-      wktRoundTrip("LINESTRING ()"), "Expected number but encountered ')'");
-  VELOX_ASSERT_USER_THROW(
-      wktRoundTrip("POLYGON ((0 0, 0 0))"),
-      "Invalid number of points in LinearRing found 2 - must be 0 or >= 4");
-  VELOX_ASSERT_USER_THROW(
-      wktRoundTrip("POLYGON ((0 0, 0 1, 1 1, 1 0))"),
-      "Points of LinearRing do not form a closed linestring");
-
-  // WKB invalid cases
-  // Empty
-  VELOX_ASSERT_USER_THROW(wkbRoundTrip(""), "Unexpected EOF parsing WKB");
-
-  // Random bytes
-  VELOX_ASSERT_USER_THROW(wkbRoundTrip("ABCDEF"), "Unexpected EOF parsing WKB");
-
-  // Unrecognized geometry type
-  VELOX_ASSERT_USER_THROW(
-      wkbRoundTrip("0109000000000000000000F03F0000000000000040"),
-      "Unknown WKB type 9");
-
-  // Point with missing y
-  VELOX_ASSERT_USER_THROW(
-      wkbRoundTrip("0101000000000000000000F03F"), "Unexpected EOF parsing WKB");
-
-  // LineString with only one point
-  VELOX_ASSERT_THROW(
-      wkbRoundTrip("010200000001000000000000000000F03F000000000000F03F"),
-      "point array must contain 0 or >1 elements");
-
-  // Polygon with unclosed LinString
-  VELOX_ASSERT_THROW(
-      wkbRoundTrip(
-          "01030000000100000004000000000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F000000000000F03F0000000000000000"),
-      "Points of LinearRing do not form a closed linestring");
-
-  VELOX_ASSERT_THROW(
-      wkbRoundTrip(
-          "010300000001000000020000000000000000000000000000000000000000000000000000000000000000000000"),
-      "Invalid number of points in LinearRing found 2 - must be 0 or >= 4");
+  wktRoundTrip(
+      "POLYGON ((73.3644 -53.0331, 73.3652 -53.0327, 73.3661 -53.0327, 73.3677 -53.0323, 73.3686 -53.0324, 73.3691 -53.0326, 73.3698 -53.0333, 73.3699 -53.0342, 73.3692 -53.0346, 73.3695 -53.0348, 73.3698 -53.0344, 73.3707 -53.0345, 73.3713 -53.034, 73.3718 -53.0339, 73.3722 -53.0329, 73.3713 -53.0323, 73.3711 -53.0319, 73.3701 -53.0311, 73.3685 -53.0305, 73.3666 -53.0302, 73.366 -53.0299, 73.3655 -53.03, 73.3653 -53.0304, 73.3646 -53.031, 73.3636 -53.0308, 73.363 -53.0311, 73.3629 -53.0313, 73.3627 -53.0316, 73.3619 -53.0315, 73.3611 -53.0318, 73.3611 -53.0322, 73.3606 -53.0327, 73.3601 -53.0326, 73.3603 -53.0316, 73.361 -53.0312, 73.3617 -53.0311, 73.362 -53.0308, 73.3625 -53.0307, 73.3646 -53.03, 73.3656 -53.0293, 73.3669 -53.0293, 73.3684 -53.0301, 73.3701 -53.0304, 73.3705 -53.0298, 73.3711 -53.0293, 73.3712 -53.029, 73.3717 -53.0287, 73.3717 -53.0284, 73.3722 -53.0278, 73.3722 -53.0271, 73.3721 -53.0268, 73.3718 -53.0267, 73.3719 -53.0263, 73.373 -53.0266, 73.3735 -53.0273, 73.3761 -53.0272, 73.3765 -53.0274, 73.377 -53.0272, 73.3781 -53.0272, 73.3792 -53.0267, 73.3798 -53.0266, 73.3801 -53.0264, 73.3806 -53.0263, 73.3808 -53.0257, 73.3811 -53.0256, 73.3815 -53.0257, 73.3815 -53.0275, 73.3818 -53.0277, 73.3817 -53.028, 73.382 -53.0282, 73.382 -53.0284, 73.3815 -53.0287, 73.3825 -53.0288, 73.3831 -53.0284, 73.3839 -53.0286, 73.3847 -53.0284, 73.3854 -53.0285, 73.3872 -53.028, 73.3879 -53.0276, 73.3887 -53.0275, 73.3892 -53.0272, 73.3897 -53.0272, 73.3908 -53.0265, 73.3912 -53.0265, 73.3915 -53.0263, 73.3919 -53.0265, 73.3918 -53.027, 73.3911 -53.0275, 73.3905 -53.0276, 73.3905 -53.0278, 73.3901 -53.0279, 73.3902 -53.0282, 73.3898 -53.0285, 73.3885 -53.0287, 73.3874 -53.0291, 73.3874 -53.0293, 73.3872 -53.0294, 73.3862 -53.0292, 73.3839 -53.0293, 73.3836 -53.0291, 73.3832 -53.0294, 73.3836 -53.0298, 73.3843 -53.0297, 73.3847 -53.0299, 73.3849 -53.0296, 73.3853 -53.0296, 73.3858 -53.0299, 73.3862 -53.0299, 73.3861 -53.0295, 73.3866 -53.0293, 73.3868 -53.0294, 73.3869 -53.0296, 73.3866 -53.0299, 73.3863 -53.0299, 73.3865 -53.03, 73.3874 -53.0298, 73.388 -53.0298, 73.3882 -53.0293, 73.3891 -53.0292, 73.3898 -53.0292, 73.39 -53.0291, 73.39 -53.0288, 73.3903 -53.0286, 73.3908 -53.0285, 73.391 -53.0281, 73.3914 -53.028, 73.3923 -53.0284, 73.3923 -53.0292, 73.3926 -53.0294, 73.3926 -53.0296, 73.3922 -53.0297, 73.3916 -53.0303, 73.3916 -53.0306, 73.392 -53.0309, 73.3936 -53.0309, 73.3941 -53.0307, 73.3946 -53.031, 73.3947 -53.0308, 73.3951 -53.0307, 73.3954 -53.0309, 73.3952 -53.0312, 73.3955 -53.0313, 73.3965 -53.0316, 73.3977 -53.0317, 73.3979 -53.0313, 73.3977 -53.0309, 73.3972 -53.0307, 73.3968 -53.0301, 73.3962 -53.0297, 73.396 -53.029, 73.3951 -53.029, 73.3947 -53.0286, 73.3933 -53.0282, 73.393 -53.028, 73.3929 -53.0276, 73.3922 -53.0271, 73.3923 -53.0265, 73.3921 -53.0261, 73.3923 -53.0259, 73.3923 -53.0253, 73.3928 -53.0249, 73.3931 -53.024, 73.393 -53.0235, 73.3933 -53.023, 73.3931 -53.0228, 73.3931 -53.0222, 73.3937 -53.0221, 73.3928 -53.0218, 73.3925 -53.021, 73.3917 -53.0203, 73.3909 -53.0198, 73.3906 -53.0197, 73.3897 -53.0201, 73.3894 -53.0202, 73.3892 -53.02, 73.3893 -53.0195, 73.3901 -53.0193, 73.3905 -53.019, 73.3913 -53.019, 73.3916 -53.0185, 73.3927 -53.0184, 73.3936 -53.0177, 73.3943 -53.0175, 73.3944 -53.017, 73.3952 -53.0161, 73.3956 -53.016, 73.396 -53.0155, 73.3967 -53.0151, 73.3971 -53.015, 73.3974 -53.0147, 73.3985 -53.0143, 73.3995 -53.0142, 73.4 -53.0143, 73.4002 -53.0147, 73.4006 -53.0147, 73.4008 -53.0145, 73.4007 -53.014, 73.4011 -53.0138, 73.402 -53.0136, 73.4031 -53.0137, 73.404 -53.0132, 73.4054 -53.0133, 73.4063 -53.0138, 73.4071 -53.0135, 73.4078 -53.0137, 73.4083 -53.0136, 73.4084 -53.0131, 73.4087 -53.0129, 73.4093 -53.0129, 73.4106 -53.0132, 73.4116 -53.0128, 73.4118 -53.0122, 73.4109 -53.0121, 73.4104 -53.0117, 73.4104 -53.0114, 73.4109 -53.0108, 73.4118 -53.0106, 73.4118 -53.0103, 73.4114 -53.01, 73.4116 -53.009, 73.412 -53.0087, 73.4129 -53.0089, 73.4131 -53.0086, 73.4134 -53.0083, 73.414 -53.0083, 73.4145 -53.0085, 73.4145 -53.0082, 73.4147 -53.008, 73.4154 -53.008, 73.4158 -53.0085, 73.4157 -53.009, 73.4154 -53.0092, 73.415 -53.0091, 73.4147 -53.0089, 73.4147 -53.009, 73.4155 -53.0095, 73.4156 -53.0112, 73.4158 -53.0114, 73.4159 -53.0122, 73.4167 -53.013, 73.4165 -53.0144, 73.4162 -53.0148, 73.4136 -53.0163, 73.4135 -53.0169, 73.413 -53.0169, 73.4126 -53.0168, 73.4117 -53.0173, 73.41 -53.0184, 73.4085 -53.0198, 73.4085 -53.0204, 73.4083 -53.0207, 73.4085 -53.0209, 73.4085 -53.0212, 73.4092 -53.0222, 73.4102 -53.0231, 73.4105 -53.0235, 73.4104 -53.0237, 73.4097 -53.024, 73.4091 -53.0247, 73.4095 -53.0247, 73.4095 -53.025, 73.4102 -53.025, 73.4101 -53.0253, 73.4097 -53.0254, 73.4098 -53.0259, 73.4103 -53.0263, 73.4106 -53.0263, 73.4102 -53.0256, 73.4103 -53.0251, 73.4109 -53.0251, 73.4112 -53.0247, 73.4123 -53.0248, 73.4131 -53.0254, 73.4137 -53.0255, 73.4142 -53.0258, 73.4149 -53.0258, 73.4152 -53.0263, 73.4162 -53.0262, 73.4164 -53.0265, 73.4169 -53.0264, 73.4173 -53.0267, 73.4186 -53.0268, 73.419 -53.0271, 73.42 -53.0274, 73.4208 -53.0274, 73.4222 -53.0279, 73.4224 -53.0283, 73.4222 -53.0284, 73.4207 -53.0286, 73.4202 -53.029, 73.4203 -53.0294, 73.4211 -53.0296, 73.4212 -53.0301, 73.4201 -53.0311, 73.4184 -53.0318, 73.4178 -53.0318, 73.4175 -53.0316, 73.4167 -53.0318, 73.4161 -53.0325, 73.4149 -53.0325, 73.4144 -53.033, 73.414 -53.0331, 73.4138 -53.0334, 73.414 -53.0336, 73.4148 -53.0334, 73.4151 -53.0336, 73.4146 -53.0353, 73.4153 -53.0362, 73.4152 -53.0377, 73.4155 -53.0379, 73.4155 -53.0382, 73.4153 -53.0401, 73.4134 -53.0412, 73.4109 -53.042, 73.4096 -53.044, 73.4101 -53.0462, 73.4117 -53.0477, 73.4122 -53.0485, 73.4119 -53.0493, 73.4101 -53.0511, 73.4101 -53.0517, 73.4107 -53.0523, 73.4103 -53.0535, 73.4132 -53.0569, 73.4154 -53.0579, 73.4161 -53.0579, 73.4163 -53.0583, 73.4171 -53.0587, 73.423 -53.0615, 73.4235 -53.0618, 73.4237 -53.0621, 73.4246 -53.062, 73.4258 -53.0624, 73.426 -53.0628, 73.4266 -53.0627, 73.427 -53.063, 73.427 -53.0632, 73.4267 -53.0635, 73.4276 -53.0631, 73.4281 -53.0631, 73.4287 -53.0637, 73.4294 -53.0637, 73.4297 -53.0638, 73.4299 -53.0642, 73.4291 -53.0646, 73.429 -53.0651, 73.4286 -53.0652, 73.4285 -53.0657, 73.428 -53.0661, 73.4274 -53.0659, 73.4274 -53.0654, 73.427 -53.0651, 73.4273 -53.0648, 73.4281 -53.0647, 73.4276 -53.0644, 73.4271 -53.0643, 73.427 -53.064, 73.4265 -53.0639, 73.4265 -53.0641, 73.4267 -53.0643, 73.4267 -53.0645, 73.4251 -53.0653, 73.4242 -53.0652, 73.4237 -53.0646, 73.4225 -53.0648, 73.4221 -53.0647, 73.4219 -53.0644, 73.4215 -53.0644, 73.4212 -53.0642, 73.4205 -53.0643, 73.4198 -53.0639, 73.4198 -53.0637, 73.4192 -53.0638, 73.4188 -53.0635, 73.4189 -53.0632, 73.4194 -53.0632, 73.4194 -53.0624, 73.4191 -53.0621, 73.4185 -53.0621, 73.4177 -53.0625, 73.4174 -53.0628, 73.4166 -53.0627, 73.4159 -53.0624, 73.4158 -53.0621, 73.4151 -53.0621, 73.4142 -53.0617, 73.4138 -53.0614, 73.4111 -53.0603, 73.4105 -53.0595, 73.4098 -53.0592, 73.4094 -53.0593, 73.4087 -53.0593, 73.4071 -53.0577, 73.4054 -53.0575, 73.4049 -53.057, 73.4039 -53.0567, 73.4024 -53.0554, 73.4011 -53.0552, 73.4005 -53.0549, 73.3994 -53.0553, 73.3976 -53.0553, 73.3972 -53.055, 73.3963 -53.0549, 73.3962 -53.055, 73.3964 -53.0552, 73.3964 -53.0556, 73.3955 -53.0562, 73.3946 -53.0562, 73.394 -53.0557, 73.3937 -53.0557, 73.3937 -53.0561, 73.3942 -53.0564, 73.3942 -53.0569, 73.3938 -53.0572, 73.3906 -53.0582, 73.3894 -53.0584, 73.3891 -53.0586, 73.3883 -53.0586, 73.3882 -53.0589, 73.3877 -53.0593, 73.3859 -53.0606, 73.3851 -53.0608, 73.3848 -53.0606, 73.3848 -53.0602, 73.385 -53.06, 73.385 -53.0596, 73.3848 -53.0594, 73.384 -53.0591, 73.3836 -53.0595, 73.3834 -53.0615, 73.384 -53.0616, 73.3842 -53.0618, 73.3842 -53.0624, 73.384 -53.0626, 73.3841 -53.0628, 73.3841 -53.0646, 73.384 -53.0648, 73.384 -53.0657, 73.3867 -53.0656, 73.3873 -53.0657, 73.3879 -53.0652, 73.389 -53.0655, 73.3891 -53.0661, 73.3886 -53.0665, 73.3884 -53.0668, 73.3885 -53.0674, 73.3888 -53.0676, 73.3888 -53.0679, 73.3884 -53.0683, 73.3893 -53.0687, 73.3893 -53.0695, 73.3888 -53.0697, 73.3888 -53.0702, 73.389 -53.0703, 73.3896 -53.0703, 73.3901 -53.07, 73.3906 -53.0701, 73.3908 -53.0702, 73.3908 -53.0708, 73.3915 -53.0708, 73.3919 -53.0712, 73.392 -53.0716, 73.3916 -53.0719, 73.3923 -53.0724, 73.3927 -53.0729, 73.3925 -53.0734, 73.3919 -53.0734, 73.3913 -53.0739, 73.3907 -53.074, 73.3904 -53.0744, 73.3893 -53.0748, 73.3885 -53.0748, 73.3883 -53.0753, 73.3872 -53.076, 73.3867 -53.076, 73.3861 -53.0768, 73.3855 -53.0771, 73.3855 -53.0773, 73.3863 -53.0779, 73.3863 -53.079, 73.386 -53.0795, 73.3853 -53.0796, 73.385 -53.0792, 73.3834 -53.0781, 73.3818 -53.0775, 73.3808 -53.0769, 73.3794 -53.0764, 73.3788 -53.0764, 73.3776 -53.0768, 73.3775 -53.0771, 73.3773 -53.0773, 73.3768 -53.0773, 73.3763 -53.0776, 73.3758 -53.0775, 73.3757 -53.0771, 73.3764 -53.0769, 73.3756 -53.0769, 73.3755 -53.0766, 73.3757 -53.0764, 73.3762 -53.0763, 73.3765 -53.0761, 73.3759 -53.0759, 73.3758 -53.0755, 73.375 -53.0751, 73.375 -53.0747, 73.3749 -53.0746, 73.3741 -53.0744, 73.3735 -53.0747, 73.3729 -53.0745, 73.3727 -53.0741, 73.3727 -53.0733, 73.3731 -53.073, 73.3736 -53.0729, 73.3733 -53.0726, 73.3721 -53.0726, 73.3718 -53.0724, 73.3708 -53.0723, 73.3689 -53.0732, 73.367 -53.0737, 73.3654 -53.0738, 73.3645 -53.0738, 73.3638 -53.0743, 73.3638 -53.0748, 73.3625 -53.075, 73.3622 -53.0755, 73.3617 -53.0755, 73.3615 -53.0753, 73.3615 -53.0748, 73.3616 -53.0745, 73.3624 -53.0739, 73.3631 -53.0738, 73.3632 -53.0733, 73.3635 -53.073, 73.3654 -53.0726, 73.368 -53.0724, 73.3689 -53.0718, 73.3723 -53.0711, 73.374 -53.07, 73.3754 -53.0682, 73.3773 -53.0674, 73.3787 -53.0661, 73.3798 -53.0648, 73.3806 -53.0633, 73.3812 -53.0626, 73.3814 -53.062, 73.3819 -53.0614, 73.3817 -53.0609, 73.3818 -53.0604, 73.3816 -53.0597, 73.3818 -53.0592, 73.3824 -53.0587, 73.3824 -53.0581, 73.3827 -53.0579, 73.382 -53.057, 73.3821 -53.0565, 73.3815 -53.0561, 73.3816 -53.0556, 73.3812 -53.0552, 73.3812 -53.0549, 73.3816 -53.0548, 73.3815 -53.0538, 73.3818 -53.0535, 73.3813 -53.0533, 73.3813 -53.0529, 73.3818 -53.0525, 73.3815 -53.0522, 73.3812 -53.0516, 73.3807 -53.052, 73.38 -53.0518, 73.3799 -53.0511, 73.3796 -53.0509, 73.3795 -53.0505, 73.3796 -53.0498, 73.3806 -53.0499, 73.3802 -53.0497, 73.3804 -53.049, 73.3802 -53.0487, 73.3803 -53.0483, 73.3799 -53.0478, 73.3795 -53.0476, 73.3795 -53.0465, 73.3801 -53.0462, 73.3794 -53.046, 73.3786 -53.0453, 73.3779 -53.0454, 73.3777 -53.0453, 73.3778 -53.0451, 73.3774 -53.0451, 73.3773 -53.0454, 73.3769 -53.0454, 73.3768 -53.0451, 73.3772 -53.045, 73.3772 -53.0447, 73.3775 -53.0443, 73.3763 -53.0437, 73.3759 -53.0429, 73.3746 -53.0425, 73.3732 -53.0424, 73.3725 -53.0421, 73.3722 -53.0421, 73.3721 -53.0424, 73.3709 -53.0425, 73.3707 -53.0429, 73.3714 -53.0435, 73.3714 -53.0437, 73.3707 -53.0441, 73.3694 -53.0446, 73.3686 -53.0445, 73.3681 -53.0442, 73.3674 -53.0441, 73.3665 -53.0437, 73.3657 -53.0431, 73.3651 -53.0418, 73.3651 -53.0415, 73.3656 -53.041, 73.3661 -53.0402, 73.3676 -53.0396, 73.3678 -53.0393, 73.3696 -53.0393, 73.3701 -53.0392, 73.3702 -53.0389, 73.3708 -53.0388, 73.371 -53.0384, 73.371 -53.0378, 73.3706 -53.0376, 73.3705 -53.0371, 73.3709 -53.0364, 73.3699 -53.0356, 73.3697 -53.0351, 73.3693 -53.0353, 73.3688 -53.0353, 73.3682 -53.0349, 73.3677 -53.0349, 73.3674 -53.0345, 73.3669 -53.0345, 73.3667 -53.0342, 73.3648 -53.0339, 73.3654 -53.0344, 73.3654 -53.0347, 73.3644 -53.0349, 73.3639 -53.0351, 73.3625 -53.0351, 73.3616 -53.0348, 73.3614 -53.0343, 73.361 -53.0342, 73.3607 -53.0336, 73.3607 -53.0332, 73.3613 -53.0326, 73.3622 -53.0322, 73.3625 -53.0319, 73.363 -53.0319, 73.3633 -53.0321, 73.3632 -53.0327, 73.3634 -53.0329, 73.3634 -53.0334, 73.3643 -53.0333, 73.3644 -53.0331), (73.3938 -53.0223, 73.3938 -53.0222, 73.3937 -53.0221, 73.3938 -53.0222, 73.3938 -53.0223), (73.4095 -53.0252, 73.4094 -53.0253, 73.4095 -53.0253, 73.4095 -53.0253, 73.4095 -53.0252), (73.4162 -53.0267, 73.4163 -53.0267, 73.4163 -53.0266, 73.4162 -53.0267, 73.4162 -53.0267), (73.4259 -53.0629, 73.4259 -53.0631, 73.4263 -53.0632, 73.426 -53.063, 73.4259 -53.0629), (73.3805 -53.0503, 73.3801 -53.0504, 73.3806 -53.0505, 73.3806 -53.0508, 73.3807 -53.0508, 73.3809 -53.0505, 73.3805 -53.0503), (73.3809 -53.0512, 73.3811 -53.0513, 73.3812 -53.0514, 73.3812 -53.0512, 73.3809 -53.0512), (73.3783 -53.045, 73.378 -53.0449, 73.3778 -53.045, 73.378 -53.045, 73.3783 -53.045), (73.3899 -53.0275, 73.39 -53.0274, 73.3899 -53.0274, 73.3899 -53.0275, 73.3899 -53.0275), (73.3962 -53.0287, 73.3965 -53.0286, 73.3965 -53.0284, 73.397 -53.0279, 73.3969 -53.0273, 73.3965 -53.0269, 73.3971 -53.0267, 73.3968 -53.0266, 73.3967 -53.0263, 73.3972 -53.0263, 73.3974 -53.0266, 73.3989 -53.0263, 73.3988 -53.0262, 73.3983 -53.0262, 73.3982 -53.026, 73.3993 -53.0255, 73.3989 -53.025, 73.3987 -53.0249, 73.3986 -53.0253, 73.3978 -53.0255, 73.3976 -53.0254, 73.3976 -53.0252, 73.398 -53.0251, 73.3981 -53.0248, 73.3985 -53.0248, 73.397 -53.0246, 73.3962 -53.0249, 73.3959 -53.0252, 73.396 -53.0265, 73.3957 -53.0267, 73.3953 -53.0267, 73.3938 -53.026, 73.3935 -53.0261, 73.3936 -53.0263, 73.3941 -53.0264, 73.394 -53.0266, 73.3936 -53.0266, 73.3938 -53.0268, 73.3939 -53.0274, 73.395 -53.028, 73.395 -53.0284, 73.3962 -53.0287), (73.3825 -53.0548, 73.3828 -53.0554, 73.3828 -53.0559, 73.3834 -53.0562, 73.3837 -53.0566, 73.384 -53.0567, 73.3845 -53.0565, 73.385 -53.056, 73.3864 -53.055, 73.3871 -53.055, 73.3877 -53.0547, 73.3883 -53.0546, 73.3877 -53.054, 73.3877 -53.0537, 73.3879 -53.0535, 73.3896 -53.0531, 73.3899 -53.0529, 73.3905 -53.0529, 73.3917 -53.0532, 73.3921 -53.0536, 73.3928 -53.0538, 73.3929 -53.0537, 73.393 -53.0534, 73.3936 -53.053, 73.3948 -53.0528, 73.396 -53.053, 73.3968 -53.0526, 73.3981 -53.0526, 73.3985 -53.0525, 73.3982 -53.0522, 73.3985 -53.0513, 73.399 -53.0511, 73.3997 -53.0504, 73.4012 -53.0503, 73.4019 -53.0505, 73.403 -53.0514, 73.403 -53.0525, 73.4029 -53.0527, 73.403 -53.0531, 73.4038 -53.0536, 73.4042 -53.0545, 73.4052 -53.0549, 73.4056 -53.0546, 73.4054 -53.0526, 73.4056 -53.0518, 73.4061 -53.0512, 73.406 -53.0508, 73.4057 -53.0505, 73.4058 -53.05, 73.4054 -53.0497, 73.4054 -53.0493, 73.4048 -53.0487, 73.4048 -53.0483, 73.405 -53.0479, 73.4054 -53.0478, 73.4055 -53.0473, 73.4058 -53.0469, 73.4058 -53.0466, 73.4045 -53.0457, 73.4045 -53.0454, 73.4047 -53.0451, 73.4047 -53.045, 73.4039 -53.045, 73.4036 -53.0453, 73.403 -53.0455, 73.402 -53.0454, 73.4015 -53.0445, 73.4015 -53.0437, 73.4016 -53.0434, 73.4022 -53.0433, 73.4018 -53.043, 73.4015 -53.0429, 73.4011 -53.0432, 73.401 -53.0435, 73.4004 -53.0441, 73.4006 -53.0444, 73.4006 -53.0448, 73.4004 -53.0451, 73.3999 -53.0452, 73.3996 -53.0455, 73.3986 -53.0457, 73.3983 -53.0461, 73.396 -53.0459, 73.3954 -53.0461, 73.3952 -53.0466, 73.3937 -53.047, 73.3932 -53.0478, 73.3924 -53.0481, 73.3926 -53.0484, 73.3926 -53.0487, 73.3923 -53.0491, 73.3918 -53.0493, 73.3915 -53.0496, 73.3907 -53.0499, 73.3902 -53.0502, 73.3892 -53.0504, 73.3884 -53.051, 73.3876 -53.051, 73.3864 -53.0516, 73.3855 -53.0516, 73.3848 -53.052, 73.3845 -53.0524, 73.3843 -53.053, 73.3831 -53.0538, 73.3829 -53.0545, 73.3825 -53.0548))");
 }
 
 // Constructors and accessors
@@ -413,7 +473,7 @@ TEST_F(GeometryFunctionsTest, testStContains) {
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT (1 1)",
           false),
-      "Failed to check geometry contains: TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
+      "TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
 }
 
 TEST_F(GeometryFunctionsTest, testStCrosses) {
@@ -478,7 +538,7 @@ TEST_F(GeometryFunctionsTest, testStCrosses) {
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT (1 1)",
           false),
-      "Failed to check geometry crosses: TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
+      "TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
 }
 
 TEST_F(GeometryFunctionsTest, testStDisjoint) {
@@ -514,7 +574,7 @@ TEST_F(GeometryFunctionsTest, testStDisjoint) {
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT (1 1)",
           false),
-      "Failed to check geometry disjoint: TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
+      "TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
 }
 
 TEST_F(GeometryFunctionsTest, testStEquals) {
@@ -604,7 +664,7 @@ TEST_F(GeometryFunctionsTest, testStIntersects) {
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT (1 1)",
           false),
-      "Failed to check geometry intersects: TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
+      "TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
 }
 
 TEST_F(GeometryFunctionsTest, testStOverlaps) {
@@ -658,7 +718,7 @@ TEST_F(GeometryFunctionsTest, testStOverlaps) {
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT (1 1)",
           false),
-      "Failed to check geometry overlaps: TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
+      "TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
 }
 
 TEST_F(GeometryFunctionsTest, testStTouches) {
@@ -729,7 +789,7 @@ TEST_F(GeometryFunctionsTest, testStTouches) {
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT (1 1)",
           false),
-      "Failed to check geometry touches: TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
+      "TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
 }
 
 TEST_F(GeometryFunctionsTest, testStWithin) {
@@ -804,7 +864,7 @@ TEST_F(GeometryFunctionsTest, testStWithin) {
           "POINT (0 0)",
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           false),
-      "Failed to check geometry within: TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
+      "TopologyException: side location conflict at 1 2. This can occur if the input geometry is invalid.");
 }
 
 // Overlay operations
@@ -839,13 +899,13 @@ TEST_F(GeometryFunctionsTest, testStDifference) {
       "POLYGON ((0 1, 3 1, 3 3, 0 3, 0 1))",
       "POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))");
 
-  VELOX_ASSERT_USER_THROW(
+  ASSERT_THROW(
       assertOverlay(
           "ST_Difference",
           "LINESTRING (0 0, 1 1, 1 0, 0 1)",
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT EMPTY"),
-      "Failed to compute geometry difference: TopologyException: Input geom 1 is invalid: Self-intersection at 1 2");
+      facebook::velox::VeloxUserError);
 }
 
 TEST_F(GeometryFunctionsTest, testStIntersection) {
@@ -888,13 +948,13 @@ TEST_F(GeometryFunctionsTest, testStIntersection) {
       "LINESTRING (0 0, 1 -1, 1 2)",
       "GEOMETRYCOLLECTION (LINESTRING (1 1, 1 0), POINT (0 0))");
 
-  VELOX_ASSERT_USER_THROW(
+  ASSERT_THROW(
       assertOverlay(
           "ST_Intersection",
           "LINESTRING (0 0, 1 1, 1 0, 0 1)",
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT EMPTY"),
-      "Failed to compute geometry intersection: TopologyException: Input geom 1 is invalid: Self-intersection at 1 2");
+      facebook::velox::VeloxUserError);
 }
 
 TEST_F(GeometryFunctionsTest, testStSymDifference) {
@@ -930,13 +990,13 @@ TEST_F(GeometryFunctionsTest, testStSymDifference) {
       "POLYGON ((0 0, 0 3, 3 3, 3 0, 0 0))",
       "MULTIPOLYGON (((0 2, 0 3, 2 3, 2 2, 0 2)), ((2 2, 3 2, 3 0, 2 0, 2 2)), ((2 4, 4 4, 4 2, 3 2, 3 3, 2 3, 2 4)))");
 
-  VELOX_ASSERT_USER_THROW(
+  ASSERT_THROW(
       assertOverlay(
           "ST_SymDifference",
           "LINESTRING (0 0, 1 1, 1 0, 0 1)",
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT EMPTY"),
-      "Failed to compute geometry symdifference: TopologyException: Input geom 1 is invalid: Self-intersection at 1 2");
+      facebook::velox::VeloxUserError);
 }
 
 TEST_F(GeometryFunctionsTest, testStUnion) {
@@ -1067,13 +1127,135 @@ TEST_F(GeometryFunctionsTest, testStUnion) {
       "GEOMETRYCOLLECTION (POLYGON ((2 2, 4 2, 4 4, 2 4, 2 2)), LINESTRING (2 1, 4 1))",
       "GEOMETRYCOLLECTION (LINESTRING (3 1, 4 1), POLYGON ((1 1, 1 3, 2 3, 2 4, 4 4, 4 2, 3 2, 3 1, 2 1, 1 1)))");
 
-  VELOX_ASSERT_USER_THROW(
+  ASSERT_THROW(
       assertOverlay(
           "ST_Union",
           "LINESTRING (0 0, 1 1, 1 0, 0 1)",
           "MULTIPOLYGON ( ((0 0, 0 2, 2 2, 2 0, 0 0)), ((1 1, 1 3, 3 3, 3 1, 1 1)) )",
           "POINT EMPTY"),
-      "Failed to compute geometry union: TopologyException: Input geom 1 is invalid: Self-intersection at 1 2");
+      facebook::velox::VeloxUserError);
+}
+
+// Accessors
+
+TEST_F(GeometryFunctionsTest, testStIsSimpleValid) {
+  const auto assertStIsValidSimpleFunc = [&](std::optional<std::string> wkt,
+                                             bool expectedValid,
+                                             bool expectedSimple) {
+    std::optional<bool> validResult =
+        evaluateOnce<bool>("ST_IsValid(ST_GeometryFromText(c0))", wkt);
+    std::optional<bool> simpleResult =
+        evaluateOnce<bool>("ST_IsSimple(ST_GeometryFromText(c0))", wkt);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(validResult.has_value());
+      ASSERT_TRUE(simpleResult.has_value());
+      ASSERT_EQ(validResult.value(), expectedValid)
+          << " from WKT: " << wkt.value();
+      ASSERT_EQ(simpleResult.value(), expectedSimple)
+          << " from WKT: " << wkt.value();
+    } else {
+      ASSERT_FALSE(validResult.has_value());
+      ASSERT_FALSE(simpleResult.has_value());
+    }
+  };
+
+  assertStIsValidSimpleFunc(std::nullopt, true, true);
+  assertStIsValidSimpleFunc("POINT EMPTY", true, true);
+  assertStIsValidSimpleFunc("MULTIPOINT EMPTY", true, true);
+  assertStIsValidSimpleFunc("LINESTRING EMPTY", true, true);
+  assertStIsValidSimpleFunc("MULTILINESTRING EMPTY", true, true);
+  assertStIsValidSimpleFunc("POLYGON EMPTY", true, true);
+  assertStIsValidSimpleFunc("MULTIPOLYGON EMPTY", true, true);
+  assertStIsValidSimpleFunc("GEOMETRYCOLLECTION EMPTY", true, true);
+
+  // valid geometries
+  assertStIsValidSimpleFunc("POINT (1.5 2.5)", true, true);
+
+  assertStIsValidSimpleFunc("MULTIPOINT (1 2, 3 4)", true, true);
+  assertStIsValidSimpleFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", true, true);
+  // Repeated point
+  assertStIsValidSimpleFunc(
+      "MULTIPOINT ((0 0), (0 1), (0 1), (1 1))", true, false);
+  // Duplicate point
+  assertStIsValidSimpleFunc("MULTIPOINT (1 2, 2 4, 3 6, 1 2)", true, false);
+
+  assertStIsValidSimpleFunc("LINESTRING (0 0, 1 2, 3 4)", true, true);
+  // Geos/JTS considers LineStrings with repeated points valid/simple (it drops
+  // the dupes), even though ISO says they should be invalid.
+  assertStIsValidSimpleFunc(
+      "LINESTRING (0 0, 0 1, 0 1, 1 1, 1 0, 0 0)", true, true);
+  // Valid but not simple: Self-intersection at (0, 1) (vertex)
+  assertStIsValidSimpleFunc(
+      "LINESTRING (0 0, -1 0.5, 0 1, 1 1, 1 0, 0 1, 0 0)", true, false);
+  assertStIsValidSimpleFunc("LINESTRING (8 4, 5 7)", true, true);
+  assertStIsValidSimpleFunc("LINESTRING (1 1, 2 2, 1 3, 1 1)", true, true);
+  // Valid but not simple: Self-intersection at (0.5, 0.5) (in segment)
+  assertStIsValidSimpleFunc("LINESTRING (0 0, 1 1, 1 0, 0 1)", true, false);
+
+  assertStIsValidSimpleFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", true, true);
+  // Valid but not simple: Self-intersection at (2, 1)
+  assertStIsValidSimpleFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 0))", true, false);
+
+  assertStIsValidSimpleFunc("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", true, true);
+  // Hole outside of shell
+  assertStIsValidSimpleFunc(
+      "POLYGON ((0 0, 0 1, 0 1, 1 1, 1 0, 0 0), (2 2, 2 3, 3 3, 3 2, 2 2))",
+      false,
+      true);
+  // Hole outside of shell
+  assertStIsValidSimpleFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0), (2 2, 2 3, 3 3, 3 2, 2 2))",
+      false,
+      true);
+  // Backtrack from (2, 1) to (1, 1)
+  assertStIsValidSimpleFunc(
+      "POLYGON ((0 0, 0 1, 2 1, 1 1, 1 0, 0 0))", false, false);
+  // Hole segment (0 1, 1 1) overlaps shell segment
+  assertStIsValidSimpleFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0), (0 1, 1 1, 0.5 0.5, 0 1))",
+      false,
+      true);
+  // Hole intersects shell at two points (0, 0) and (1, 1)
+  assertStIsValidSimpleFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0), (0 0, 0.5 0.7, 1 1, 0.5 0.4, 0 0))",
+      false,
+      true);
+  // Shell intersects self at (0, 1)
+  assertStIsValidSimpleFunc(
+      "POLYGON ((0 0, -1 0.5, 0 1, 1 1, 1 0, 0 1, 0 0))", false, false);
+  assertStIsValidSimpleFunc("POLYGON ((2 0, 2 1, 3 1, 2 0))", true, true);
+
+  assertStIsValidSimpleFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      true,
+      true);
+  // Overlapping rectangles.  This is invalid but simple because multipolygon
+  // rules are weird.
+  assertStIsValidSimpleFunc(
+      "MULTIPOLYGON (((0 0, 0 1, 1 1, 1 0, 0 0)), ((0.5 0.5, 0.5 2, 2 2, 2 0.5, 0.5 0.5)))",
+      false,
+      true);
+
+  assertStIsValidSimpleFunc(
+      "GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (0 0, 1 2, 3 4), POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))) ",
+      true,
+      true);
+  // Invalid Polygon
+  assertStIsValidSimpleFunc(
+      "GEOMETRYCOLLECTION (POINT (1 2), POLYGON ((0 0, 0 1, 2 1, 1 1, 1 0, 0 0)))",
+      false,
+      false);
+  assertStIsValidSimpleFunc(
+      "MULTIPOLYGON (((18.6317421 49.9605785, 18.6318832 49.9607979, 18.6324683 49.9607312, 18.6332842 49.9605658, 18.6332003 49.9603557, 18.6339711 49.9602283, 18.6341994 49.9601905, 18.6343455 49.96016, 18.6344167 49.9601452, 18.6346696 49.9600919, 18.6349643 49.9600567, 18.6352271 49.9601455, 18.6354493 49.9600501, 18.6358024 49.9601071, 18.6358911 49.9600263, 18.6336542 49.9592453, 18.6334794 49.9591838, 18.6337483 49.9581339, 18.6335303 49.9580562, 18.6331284 49.9579122, 18.6324931 49.9576885, 18.6322503 49.9575998, 18.6321381 49.9581593, 18.6321172 49.9582692, 18.6324683 49.9583852, 18.6325255 49.9584004, 18.6327588 49.958489, 18.6324792 49.9588351, 18.6323941 49.9588049, 18.6323261 49.9587807, 18.6320354 49.9586789, 18.6319443 49.9592903, 18.6326731 49.9595648, 18.6331388 49.9594836, 18.6335981 49.959673, 18.6333065 49.9597934, 18.6328096 49.9600844, 18.6330209 49.9601348, 18.633424 49.9602597, 18.6332263 49.960317, 18.6315633 49.9597642, 18.6309331 49.9600741, 18.6317421 49.9605785)), ((18.6298591 49.9606201, 18.6298592 49.96062, 18.6298589 49.9606193, 18.6298591 49.9606201)))",
+      true,
+      true);
+  assertStIsValidSimpleFunc(
+      "MULTIPOLYGON (((18.6317421 49.9605785, 18.6318832 49.9607979, 18.6324683 49.9607312, 18.6332842 49.9605658, 18.6332003 49.9603557, 18.6339711 49.9602283, 18.6341994 49.9601905, 18.6343455 49.96016, 18.6344167 49.9601452, 18.6346696 49.9600919, 18.6349643 49.9600567, 18.6352271 49.9601455, 18.6354493 49.9600501, 18.6358024 49.9601071, 18.6358911 49.9600263, 18.6336542 49.9592453, 18.6334794 49.9591838, 18.6337483 49.9581339, 18.6335303 49.9580562, 18.6331284 49.9579122, 18.6324931 49.9576885, 18.6322503 49.9575998, 18.6321381 49.9581593, 18.6321172 49.9582692, 18.6324683 49.9583852, 18.6325255 49.9584004, 18.6327588 49.958489, 18.6324792 49.9588351, 18.6323941 49.9588049, 18.6323261 49.9587807, 18.6320354 49.9586789, 18.6319443 49.9592903, 18.6326731 49.9595648, 18.6331388 49.9594836, 18.6335981 49.959673, 18.6333065 49.9597934, 18.6328096 49.9600844, 18.6330209 49.9601348, 18.633424 49.9602597, 18.6332263 49.960317, 18.6315633 49.9597642, 18.6309331 49.9600741, 18.6317421 49.9605785)), ((18.6298591 49.9606201, 18.6298592 49.96062, 18.6298592 49.96062, 18.6298591 49.9606201)))",
+      false,
+      false);
 }
 
 TEST_F(GeometryFunctionsTest, testStArea) {
@@ -1114,3 +1296,3269 @@ TEST_F(GeometryFunctionsTest, testStArea) {
       "GEOMETRYCOLLECTION (POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)), GEOMETRYCOLLECTION (POINT (8 8), LINESTRING (5 5, 6 6), POLYGON ((1 1, 3 1, 3 4, 1 4, 1 1))))",
       14.0);
 }
+
+TEST_F(GeometryFunctionsTest, testGeometryInvalidReason) {
+  const auto assertInvalidReason =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expectedMessage) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "geometry_invalid_reason(ST_GeometryFromText(c0))", wkt);
+
+        if (wkt.has_value() && expectedMessage.has_value()) {
+          ASSERT_TRUE(result.has_value()) << " from WKT: " << wkt.value();
+          ASSERT_EQ(result.value(), expectedMessage.value())
+              << " from WKT: " << wkt.value();
+        } else {
+          ASSERT_FALSE(result.has_value()) << " from WKT: " << wkt.value();
+        }
+      };
+
+  // Invalid geometries
+  assertInvalidReason(
+      "POLYGON ((0 0, 0 1, 0 1, 1 1, 1 0, 0 0), (2 2, 2 3, 3 3, 3 2, 2 2))",
+      "Invalid Polygon: Hole lies outside shell");
+  assertInvalidReason(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0), (2 2, 2 3, 3 3, 3 2, 2 2))",
+      "Invalid Polygon: Hole lies outside shell");
+  assertInvalidReason(
+      "POLYGON ((0 0, 0 1, 2 1, 1 1, 1 0, 0 0))",
+      "Invalid Polygon: Ring Self-intersection");
+  assertInvalidReason(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0), (0 1, 1 1, 0.5 0.5, 0 1))",
+      "Invalid Polygon: Self-intersection");
+  assertInvalidReason(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0), (0 0, 0.5 0.7, 1 1, 0.5 0.4, 0 0))",
+      "Invalid Polygon: Interior is disconnected");
+  assertInvalidReason(
+      "POLYGON ((0 0, -1 0.5, 0 1, 1 1, 1 0, 0 1, 0 0))",
+      "Invalid Polygon: Ring Self-intersection");
+  assertInvalidReason(
+      "MULTIPOLYGON (((0 0, 0 1, 1 1, 1 0, 0 0)), ((0.5 0.5, 0.5 2, 2 2, 2 0.5, 0.5 0.5)))",
+      "Invalid MultiPolygon: Self-intersection");
+  assertInvalidReason(
+      "GEOMETRYCOLLECTION (POINT (1 2), POLYGON ((0 0, 0 1, 2 1, 1 1, 1 0, 0 0)))",
+      "Invalid GeometryCollection: Ring Self-intersection");
+
+  // non-simple geometries
+  assertInvalidReason(
+      "LINESTRING (0 0, -1 0.5, 0 1, 1 1, 1 0, 0 1, 0 0)",
+      "Non-simple LineString: Self-intersection at or near (0 1)");
+  assertInvalidReason(
+      "MULTIPOINT (1 2, 2 4, 3 6, 1 2)",
+      "Non-simple MultiPoint: Repeated point (1 2)");
+  assertInvalidReason(
+      "LINESTRING (0 0, 1 1, 1 0, 0 1)",
+      "Non-simple LineString: Self-intersection at or near (0.5 0.5)");
+  assertInvalidReason(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 0))",
+      "Non-simple MultiLineString: Self-intersection at or near (3.5 1)");
+
+  // valid geometries
+  assertInvalidReason(std::nullopt, std::nullopt);
+  assertInvalidReason("LINESTRING EMPTY", std::nullopt);
+  assertInvalidReason("POINT (1 2)", std::nullopt);
+  assertInvalidReason("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))", std::nullopt);
+  assertInvalidReason(
+      "GEOMETRYCOLLECTION (MULTIPOINT (1 0, 1 1, 0 1, 0 0))", std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testSimplifyGeometry) {
+  const auto assertSimplifyGeometry = [&](const std::optional<std::string>& wkt,
+                                          std::optional<double> tolerance,
+                                          const std::optional<std::string>&
+                                              expectedWkt) {
+    std::optional<bool> result = evaluateOnce<bool>(
+        "ST_Equals(simplify_geometry(ST_GeometryFromText(c0), c1), ST_GeometryFromText(c2))",
+        wkt,
+        tolerance,
+        expectedWkt);
+
+    if (wkt.has_value() && tolerance.has_value() && expectedWkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_TRUE(result.value()) << " from WKT: " << wkt.value();
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  assertSimplifyGeometry("POLYGON EMPTY", 1.0, "POLYGON EMPTY");
+  assertSimplifyGeometry(
+      "POLYGON ((1 0, 2 1, 3 1, 3 1, 4 1, 1 0))",
+      1.5,
+      "POLYGON ((1 0, 2 1, 4 1, 1 0))");
+  // Simplifying by 0.0 leaves the geometry unchanged
+  assertSimplifyGeometry(
+      "POLYGON ((1 0, 2 1, 3 1, 3 1, 4 1, 1 0))",
+      0.0,
+      "POLYGON ((1 0, 2 1, 3 1, 3 1, 4 1, 1 0))");
+
+  // Check different tolerance produce different answers
+  assertSimplifyGeometry(
+      "POLYGON ((1 0, 1 1, 2 1, 2 3, 3 3, 3 1, 4 1, 4 0, 1 0))",
+      1.0,
+      "POLYGON ((1 0, 2 3, 3 3, 4 0, 1 0))");
+  assertSimplifyGeometry(
+      "POLYGON ((1 0, 1 1, 2 1, 2 3, 3 3, 3 1, 4 1, 4 0, 1 0))",
+      0.5,
+      "POLYGON ((1 0, 1 1, 2 1, 2 3, 3 3, 3 1, 4 1, 4 0, 1 0))");
+
+  assertSimplifyGeometry(
+      "POLYGON ((1 0, 2 1, 3 1, 3 1, 4 1, 1 0))",
+      std::nullopt,
+      "POLYGON ((1 0, 2 1, 4 1, 1 0))");
+  assertSimplifyGeometry(std::nullopt, 1.0, "POLYGON ((1 0, 2 1, 4 1, 1 0))");
+
+  VELOX_ASSERT_USER_THROW(
+      assertSimplifyGeometry(
+          "POLYGON ((1 0, 1 1, 2 1, 2 3, 3 3, 3 1, 4 1, 4 0, 1 0))",
+          -0.5,
+          "POLYGON ((1 0, 1 1, 2 1, 2 3, 3 3, 3 1, 4 1, 4 0, 1 0))"),
+      "simplification tolerance must be a non-negative finite number");
+
+  VELOX_ASSERT_USER_THROW(
+      assertSimplifyGeometry(
+          "POLYGON ((1 0, 1 1, 2 1, 2 3, 3 3, 3 1, 4 1, 4 0, 1 0))",
+          std::nan("1"),
+          "POLYGON ((1 0, 1 1, 2 1, 2 3, 3 3, 3 1, 4 1, 4 0, 1 0))"),
+      "simplification tolerance must be a non-negative finite number");
+}
+
+TEST_F(GeometryFunctionsTest, testStBoundary) {
+  const auto testStBoundaryFunc = [&](const std::optional<std::string>& wkt,
+                                      const std::optional<std::string>&
+                                          expected) {
+    std::optional<bool> result = evaluateOnce<bool>(
+        "ST_Equals(ST_Boundary(ST_GeometryFromText(c0)), ST_GeometryFromText(c1))",
+        wkt,
+        expected);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_TRUE(expected.has_value());
+      ASSERT_TRUE(result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStBoundaryFunc("POINT (1 2)", "GEOMETRYCOLLECTION EMPTY");
+  testStBoundaryFunc(
+      "MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "GEOMETRYCOLLECTION EMPTY");
+  testStBoundaryFunc("LINESTRING EMPTY", "MULTIPOINT EMPTY");
+  testStBoundaryFunc("LINESTRING (8 4, 5 7)", "MULTIPOINT (8 4, 5 7)");
+  testStBoundaryFunc(
+      "LINESTRING (100 150, 50 60, 70 80, 160 170)",
+      "MULTIPOINT (100 150, 160 170)");
+  testStBoundaryFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))",
+      "MULTIPOINT (1 1, 2 4, 4 4, 5 1)");
+  testStBoundaryFunc(
+      "POLYGON ((1 1, 4 1, 1 4, 1 1))", "LINESTRING (1 1, 1 4, 4 1, 1 1)");
+  testStBoundaryFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((0 0, 0 2, 2 2, 2 0, 0 0)))",
+      "MULTILINESTRING ((1 1, 1 3, 3 3, 3 1, 1 1), (0 0, 0 2, 2 2, 2 0, 0 0))");
+}
+
+TEST_F(GeometryFunctionsTest, testStCentroid) {
+  const auto testStCentroidFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_Centroid(ST_GeometryFromText(c0)))", wkt);
+
+        if (wkt.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_TRUE(expected.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStCentroidFunc("LINESTRING EMPTY", "POINT EMPTY");
+  testStCentroidFunc("POINT (3 5)", "POINT (3 5)");
+  testStCentroidFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "POINT (2.5 5)");
+  testStCentroidFunc("LINESTRING (1 1, 2 2, 3 3)", "POINT (2 2)");
+  testStCentroidFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", "POINT (3 2)");
+  testStCentroidFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", "POINT (2.5 2.5)");
+  testStCentroidFunc("POLYGON ((1 1, 5 1, 3 4, 1 1))", "POINT (3 2)");
+  testStCentroidFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      "POINT (3.3333333333333335 4)");
+  testStCentroidFunc(
+      "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0), (1 1, 1 2, 2 2, 2 1, 1 1))",
+      "POINT (2.5416666666666665 2.5416666666666665)");
+
+  VELOX_ASSERT_USER_THROW(
+      testStCentroidFunc(
+          "GEOMETRYCOLLECTION (POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)), GEOMETRYCOLLECTION (POINT (8 8), LINESTRING (5 5, 6 6), POLYGON ((1 1, 3 1, 3 4, 1 4, 1 1))))",
+          std::nullopt),
+      "ST_Centroid only applies to Point or MultiPoint or LineString or MultiLineString or Polygon or MultiPolygon. Input type is: GeometryCollection");
+}
+
+TEST_F(GeometryFunctionsTest, testSTMin) {
+  const auto assertPointMin = [&](const std::optional<std::string>& wkt,
+                                  const std::optional<double> expectedXMin,
+                                  const std::optional<double> expectedYMin) {
+    std::optional<double> xMin =
+        evaluateOnce<double>("ST_XMin(ST_GeometryFromText(c0))", wkt);
+    std::optional<double> yMin =
+        evaluateOnce<double>("ST_YMin(ST_GeometryFromText(c0))", wkt);
+    if (expectedXMin.has_value() && expectedYMin.has_value()) {
+      EXPECT_TRUE(xMin.has_value());
+      EXPECT_TRUE(yMin.has_value());
+      EXPECT_EQ(expectedXMin.value(), xMin.value());
+      EXPECT_EQ(expectedYMin.value(), yMin.value());
+    } else {
+      EXPECT_FALSE(xMin.has_value());
+      EXPECT_FALSE(yMin.has_value());
+    }
+  };
+
+  assertPointMin("POINT (1.5 2.5)", 1.5, 2.5);
+  assertPointMin("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 1.0, 2.0);
+  assertPointMin("LINESTRING (8 4, 5 7)", 5.0, 4.0);
+  assertPointMin("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 1.0, 1.0);
+  assertPointMin("POLYGON ((2 0, 2 1, 3 1, 2 0))", 2.0, 0.0);
+  assertPointMin(
+      "MULTIPOLYGON (((1 10, 1 3, 3 3, 3 10, 1 10)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      1.0,
+      3.0);
+  assertPointMin(
+      "GEOMETRYCOLLECTION (POINT (5 1), LINESTRING (3 4, 4 4))", 3.0, 1.0);
+  assertPointMin(std::nullopt, std::nullopt, std::nullopt);
+  assertPointMin("POLYGON EMPTY", std::nullopt, std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testSTMax) {
+  const auto assertPointMax = [&](const std::optional<std::string>& wkt,
+                                  const std::optional<double> expectedXMax,
+                                  const std::optional<double> expectedYMax) {
+    std::optional<double> xMax =
+        evaluateOnce<double>("ST_XMax(ST_GeometryFromText(c0))", wkt);
+    std::optional<double> yMax =
+        evaluateOnce<double>("ST_YMax(ST_GeometryFromText(c0))", wkt);
+    if (expectedXMax.has_value() && expectedYMax.has_value()) {
+      EXPECT_TRUE(xMax.has_value());
+      EXPECT_TRUE(yMax.has_value());
+      EXPECT_EQ(expectedXMax.value(), xMax.value());
+      EXPECT_EQ(expectedYMax.value(), yMax.value());
+    } else {
+      EXPECT_FALSE(xMax.has_value());
+      EXPECT_FALSE(yMax.has_value());
+    }
+  };
+
+  assertPointMax("POINT (1.5 2.5)", 1.5, 2.5);
+  assertPointMax("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 4.0, 8.0);
+  assertPointMax("LINESTRING (8 4, 5 7)", 8.0, 7.0);
+  assertPointMax("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 5.0, 4.0);
+  assertPointMax("POLYGON ((2 0, 2 1, 3 1, 2 0))", 3.0, 1.0);
+  assertPointMax(
+      "MULTIPOLYGON (((1 10, 1 3, 3 3, 3 10, 1 10)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      6.0,
+      10.0);
+  assertPointMax(
+      "GEOMETRYCOLLECTION (POINT (5 1), LINESTRING (3 4, 4 4))", 5.0, 4.0);
+  assertPointMax(std::nullopt, std::nullopt, std::nullopt);
+  assertPointMax("POLYGON EMPTY", std::nullopt, std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testStGeometryType) {
+  const auto testStGeometryTypeFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_GeometryType(ST_GeometryFromText(c0))", wkt);
+
+        if (wkt.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_TRUE(expected.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStGeometryTypeFunc("POINT EMPTY", "ST_Point");
+  testStGeometryTypeFunc("POINT (3 5)", "ST_Point");
+  testStGeometryTypeFunc("LINESTRING EMPTY", "ST_LineString");
+  testStGeometryTypeFunc("LINESTRING (1 1, 2 2, 3 3)", "ST_LineString");
+  testStGeometryTypeFunc("LINEARRING EMPTY", "ST_LineString");
+  testStGeometryTypeFunc("POLYGON EMPTY", "ST_Polygon");
+  testStGeometryTypeFunc("POLYGON ((1 1, 4 1, 1 4, 1 1))", "ST_Polygon");
+  testStGeometryTypeFunc("MULTIPOINT EMPTY", "ST_MultiPoint");
+  testStGeometryTypeFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "ST_MultiPoint");
+  testStGeometryTypeFunc("MULTILINESTRING EMPTY", "ST_MultiLineString");
+  testStGeometryTypeFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", "ST_MultiLineString");
+  testStGeometryTypeFunc("MULTIPOLYGON EMPTY", "ST_MultiPolygon");
+  testStGeometryTypeFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      "ST_MultiPolygon");
+  testStGeometryTypeFunc("GEOMETRYCOLLECTION EMPTY", "ST_GeomCollection");
+  testStGeometryTypeFunc(
+      "GEOMETRYCOLLECTION (POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)), GEOMETRYCOLLECTION (POINT (8 8), LINESTRING (5 5, 6 6), POLYGON ((1 1, 3 1, 3 4, 1 4, 1 1))))",
+      "ST_GeomCollection");
+}
+
+TEST_F(GeometryFunctionsTest, testStDistance) {
+  const auto testStDistanceFunc = [&](const std::optional<std::string>& wkt1,
+                                      const std::optional<std::string>& wkt2,
+                                      const std::optional<double>& expected =
+                                          std::nullopt) {
+    std::optional<double> result = evaluateOnce<double>(
+        "ST_Distance(ST_GeometryFromText(c0), ST_GeometryFromText(c1))",
+        wkt1,
+        wkt2);
+
+    if (wkt1.has_value() && wkt2.has_value()) {
+      if (expected.has_value()) {
+        ASSERT_TRUE(result.has_value());
+        ASSERT_EQ(result.value(), expected.value());
+      } else {
+        ASSERT_FALSE(result.has_value());
+      }
+    } else {
+      ASSERT_FALSE(expected.has_value());
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStDistanceFunc("POINT (50 100)", "POINT (150 150)", 111.80339887498948);
+  testStDistanceFunc("MULTIPOINT (50 100, 50 200)", "POINT (50 100)", 0.0);
+  testStDistanceFunc(
+      "LINESTRING (50 100, 50 200)",
+      "LINESTRING (10 10, 20 20)",
+      85.44003745317531);
+  testStDistanceFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))",
+      "LINESTRING (10 20, 20 50)'))",
+      17.08800749063506);
+  testStDistanceFunc(
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((4 4, 4 5, 5 5, 5 4, 4 4))",
+      1.4142135623730951);
+  testStDistanceFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((0 0, 0 2, 2 2, 2 0, 0 0)))",
+      "POLYGON ((10 100, 30 10, 30 100, 10 100))",
+      27.892651361962706);
+
+  testStDistanceFunc("POINT EMPTY", "POINT (150 150)");
+  testStDistanceFunc("MULTIPOINT EMPTY", "POINT (50 100)");
+  testStDistanceFunc("LINESTRING EMPTY", "LINESTRING (10 10, 20 20)");
+  testStDistanceFunc("MULTILINESTRING EMPTY", "LINESTRING (10 20, 20 50)'))");
+  testStDistanceFunc("POLYGON EMPTY", "POLYGON ((4 4, 4 5, 5 5, 5 4, 4 4))");
+  testStDistanceFunc(
+      "MULTIPOLYGON EMPTY", "POLYGON ((10 100, 30 10, 30 100, 10 100))");
+  testStDistanceFunc(std::nullopt, "POINT (50 100)");
+}
+
+TEST_F(GeometryFunctionsTest, testStXY) {
+  const auto testStX = [&](const std::optional<std::string>& wkt,
+                           const std::optional<double>& expectedX =
+                               std::nullopt) {
+    std::optional<double> resultX =
+        evaluateOnce<double>("ST_X(ST_GeometryFromText(c0))", wkt);
+
+    if (expectedX.has_value()) {
+      ASSERT_TRUE(resultX.has_value());
+      ASSERT_EQ(expectedX.value(), resultX.value());
+    } else {
+      ASSERT_FALSE(resultX.has_value());
+    }
+  };
+  const auto testStY = [&](const std::optional<std::string>& wkt,
+                           const std::optional<double>& expectedY =
+                               std::nullopt) {
+    std::optional<double> resultY =
+        evaluateOnce<double>("ST_Y(ST_GeometryFromText(c0))", wkt);
+
+    if (expectedY.has_value()) {
+      ASSERT_TRUE(resultY.has_value());
+      ASSERT_EQ(expectedY.value(), resultY.value());
+    } else {
+      ASSERT_FALSE(resultY.has_value());
+    }
+  };
+
+  testStX("POINT (1 2)", 1.0);
+  testStY("POINT (1 2)", 2.0);
+  testStX("POINT EMPTY", std::nullopt);
+  testStY("POINT EMPTY", std::nullopt);
+  VELOX_ASSERT_USER_THROW(
+      testStX("GEOMETRYCOLLECTION EMPTY"),
+      "ST_X requires a Point geometry, found GeometryCollection");
+  VELOX_ASSERT_USER_THROW(
+      testStY("GEOMETRYCOLLECTION EMPTY"),
+      "ST_Y requires a Point geometry, found GeometryCollection");
+  VELOX_ASSERT_USER_THROW(
+      testStX("POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"),
+      "ST_X requires a Point geometry, found Polygon");
+  VELOX_ASSERT_USER_THROW(
+      testStY("POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"),
+      "ST_Y requires a Point geometry, found Polygon");
+}
+
+TEST_F(GeometryFunctionsTest, testStPolygon) {
+  const auto testStPolygonFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result =
+            evaluateOnce<std::string>("ST_AsText(ST_Polygon(c0))", wkt);
+
+        if (wkt.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStPolygonFunc("POLYGON EMPTY", "POLYGON EMPTY");
+  testStPolygonFunc(
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))'))",
+      "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))");
+
+  VELOX_ASSERT_USER_THROW(
+      testStPolygonFunc("LINESTRING (1 1, 2 2, 1 3)", std::nullopt),
+      "ST_Polygon only applies to Polygon. Input type is: LineString");
+
+  VELOX_ASSERT_USER_THROW(
+      testStPolygonFunc("POLYGON((-1 1, 1 -1))", std::nullopt),
+      "Failed to parse WKT: IllegalArgumentException: Points of LinearRing do not form a closed linestring");
+}
+
+TEST_F(GeometryFunctionsTest, testStIsClosed) {
+  const auto testStIsClosedFunc = [&](const std::optional<std::string>& wkt,
+                                      const std::optional<bool>& expected) {
+    std::optional<bool> result =
+        evaluateOnce<bool>("ST_IsClosed(ST_GeometryFromText(c0))", wkt);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStIsClosedFunc("LINESTRING (1 1, 2 2, 1 3, 1 1)", true);
+  testStIsClosedFunc("LINESTRING (1 1, 2 2, 1 3)", false);
+  testStIsClosedFunc(
+      "MULTILINESTRING ((1 1, 2 2, 1 3, 1 1), (4 4, 5 5))", false);
+  testStIsClosedFunc(
+      "MULTILINESTRING ((1 1, 2 2, 1 3, 1 1), (4 4, 5 4, 5 5, 4 5, 4 4))",
+      true);
+
+  VELOX_ASSERT_USER_THROW(
+      testStIsClosedFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", std::nullopt),
+      "ST_IsClosed only applies to LineString or MultiLineString. Input type is: Polygon");
+}
+
+TEST_F(GeometryFunctionsTest, testStIsEmpty) {
+  const auto testStIsClosedFunc = [&](const std::optional<std::string>& wkt,
+                                      const std::optional<bool>& expected) {
+    std::optional<bool> result =
+        evaluateOnce<bool>("ST_IsEmpty(ST_GeometryFromText(c0))", wkt);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStIsClosedFunc("POINT (1.5 2.5)", false);
+  testStIsClosedFunc("POLYGON EMPTY", true);
+}
+
+TEST_F(GeometryFunctionsTest, testStIsRing) {
+  const auto testStIsRingFunc = [&](const std::optional<std::string>& wkt,
+                                    const std::optional<bool>& expected) {
+    std::optional<bool> result =
+        evaluateOnce<bool>("ST_IsRing(ST_GeometryFromText(c0))", wkt);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStIsRingFunc("LINESTRING (8 4, 4 8)", false);
+  testStIsRingFunc("LINESTRING (0 0, 1 1, 0 2, 0 0)", true);
+
+  VELOX_ASSERT_USER_THROW(
+      testStIsRingFunc("POLYGON ((2 0, 2 1, 3 1, 2 0))", true),
+      "ST_IsRing only applies to LineString. Input type is: Polygon");
+}
+
+TEST_F(GeometryFunctionsTest, testStLength) {
+  const auto testStLengthFunc = [&](const std::optional<std::string>& wkt,
+                                    const std::optional<double>& expected) {
+    std::optional<double> result =
+        evaluateOnce<double>("ST_Length(ST_GeometryFromText(c0))", wkt);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStLengthFunc("LINESTRING EMPTY", 0.0);
+  testStLengthFunc("LINESTRING (0 0, 2 2)", 2.8284271247461903);
+  testStLengthFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 6.0);
+
+  VELOX_ASSERT_USER_THROW(
+      testStLengthFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", std::nullopt),
+      "ST_Length only applies to LineString or MultiLineString. Input type is: Polygon");
+}
+
+TEST_F(GeometryFunctionsTest, testStPointN) {
+  const auto testStPointNFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<int32_t>& index,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_PointN(ST_GeometryFromText(c0), c1))", wkt, index);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStPointNFunc("LINESTRING(1 2, 3 4, 5 6, 7 8)", 1, "POINT (1 2)");
+  testStPointNFunc("LINESTRING(1 2, 3 4, 5 6, 7 8)", 3, "POINT (5 6)");
+  testStPointNFunc("LINESTRING(1 2, 3 4, 5 6, 7 8)", 10, std::nullopt);
+  testStPointNFunc("LINESTRING(1 2, 3 4, 5 6, 7 8)", 0, std::nullopt);
+  testStPointNFunc("LINESTRING(1 2, 3 4, 5 6, 7 8)", -1, std::nullopt);
+
+  VELOX_ASSERT_USER_THROW(
+      testStPointNFunc("POINT (1 2)", -1, std::nullopt),
+      "ST_PointN only applies to LineString. Input type is: Point");
+}
+
+TEST_F(GeometryFunctionsTest, testStStartPoint) {
+  const auto testStStartPointFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_StartPoint(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStStartPointFunc("LINESTRING (8 4, 4 8, 5 6)", "POINT (8 4)");
+  testStStartPointFunc("LINESTRING (8 2, 4 12, 0 0)", "POINT (8 2)");
+  testStStartPointFunc("LINESTRING (0 0, 4 12, 2 2)", "POINT (0 0)");
+  testStStartPointFunc("LINESTRING EMPTY", std::nullopt);
+
+  VELOX_ASSERT_USER_THROW(
+      testStStartPointFunc("POINT (1 2)", std::nullopt),
+      "ST_StartPoint only applies to LineString. Input type is: Point");
+}
+
+TEST_F(GeometryFunctionsTest, testStEndPoint) {
+  const auto testStEndPointFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_EndPoint(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStEndPointFunc("LINESTRING (8 4, 4 8, 5 6)", "POINT (5 6)");
+  testStEndPointFunc("LINESTRING (8 2, 4 12, 0 0)", "POINT (0 0)");
+  testStEndPointFunc("LINESTRING (0 0, 4 12, 2 2)", "POINT (2 2)");
+  testStEndPointFunc("LINESTRING EMPTY", std::nullopt);
+
+  VELOX_ASSERT_USER_THROW(
+      testStEndPointFunc("POINT (1 2)", std::nullopt),
+      "ST_EndPoint only applies to LineString. Input type is: Point");
+}
+
+TEST_F(GeometryFunctionsTest, testStGeometryN) {
+  const auto testStGeometryNFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<int32_t>& index,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_GeometryN(ST_GeometryFromText(c0), c1))", wkt, index);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStGeometryNFunc("POINT EMPTY", 1, std::nullopt);
+  testStGeometryNFunc("LINESTRING EMPTY", 1, std::nullopt);
+  testStGeometryNFunc(
+      "LINESTRING(77.29 29.07, 77.42 29.26, 77.27 29.31, 77.29 29.07)",
+      1,
+      "LINESTRING (77.29 29.07, 77.42 29.26, 77.27 29.31, 77.29 29.07)");
+
+  testStGeometryNFunc(
+      "LINESTRING(77.29 29.07, 77.42 29.26, 77.27 29.31, 77.29 29.07)",
+      2,
+      std::nullopt);
+  testStGeometryNFunc(
+      "LINESTRING(77.29 29.07, 77.42 29.26, 77.27 29.31, 77.29 29.07)",
+      -1,
+      std::nullopt);
+  testStGeometryNFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))",
+      1,
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))");
+  testStGeometryNFunc("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", 2, std::nullopt);
+  testStGeometryNFunc("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", -1, std::nullopt);
+  testStGeometryNFunc("POLYGON EMPTY", 0, std::nullopt);
+  testStGeometryNFunc("POLYGON EMPTY", 2, std::nullopt);
+  testStGeometryNFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 1, "POINT (1 2)");
+  testStGeometryNFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 2, "POINT (2 4)");
+  testStGeometryNFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 0, std::nullopt);
+  testStGeometryNFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 5, std::nullopt);
+  testStGeometryNFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", -1, std::nullopt);
+  testStGeometryNFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 1, "LINESTRING (1 1, 5 1)");
+  testStGeometryNFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 2, "LINESTRING (2 4, 4 4)");
+  testStGeometryNFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 0, std::nullopt);
+  testStGeometryNFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 3, std::nullopt);
+  testStGeometryNFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", -1, std::nullopt);
+  testStGeometryNFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      1,
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))");
+  testStGeometryNFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      2,
+      "POLYGON ((2 4, 2 6, 6 6, 6 4, 2 4))");
+  testStGeometryNFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      0,
+      std::nullopt);
+  testStGeometryNFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      3,
+      std::nullopt);
+  testStGeometryNFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      -1,
+      std::nullopt);
+  testStGeometryNFunc(
+      "GEOMETRYCOLLECTION(POINT(2 3), LINESTRING (2 3, 3 4))",
+      1,
+      "POINT (2 3)");
+  testStGeometryNFunc(
+      "GEOMETRYCOLLECTION(POINT(2 3), LINESTRING (2 3, 3 4))",
+      2,
+      "LINESTRING (2 3, 3 4)");
+  testStGeometryNFunc(
+      "GEOMETRYCOLLECTION(POINT(2 3), LINESTRING (2 3, 3 4))", 3, std::nullopt);
+  testStGeometryNFunc(
+      "GEOMETRYCOLLECTION(POINT(2 3), LINESTRING (2 3, 3 4))", 0, std::nullopt);
+  testStGeometryNFunc(
+      "GEOMETRYCOLLECTION(POINT(2 3), LINESTRING (2 3, 3 4))",
+      -1,
+      std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testStInteriorRingN) {
+  const auto testStInteriorRingNFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<int32_t>& index,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_InteriorRingN(ST_GeometryFromText(c0), c1))",
+            wkt,
+            index);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStInteriorRingNFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", 1, std::nullopt);
+
+  testStInteriorRingNFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", 2, std::nullopt);
+  testStInteriorRingNFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", -1, std::nullopt);
+  testStInteriorRingNFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", 0, std::nullopt);
+  testStInteriorRingNFunc("POLYGON EMPTY", 1, std::nullopt);
+  testStInteriorRingNFunc(
+      "POLYGON ((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))",
+      1,
+      "LINESTRING (1 1, 2 1, 2 2, 1 2, 1 1)");
+  testStInteriorRingNFunc(
+      "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+      2,
+      "LINESTRING (3 3, 4 3, 4 4, 3 4, 3 3)");
+
+  VELOX_ASSERT_USER_THROW(
+      testStInteriorRingNFunc("POINT EMPTY", 0, std::nullopt),
+      "ST_InteriorRingN only applies to Polygon. Input type is: Point");
+}
+
+TEST_F(GeometryFunctionsTest, testStNumInteriorRing) {
+  const auto testStNumInteriorRingFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<int64_t>& expected) {
+        std::optional<int64_t> result = evaluateOnce<int64_t>(
+            "ST_NumInteriorRing(ST_GeometryFromText(c0))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStNumInteriorRingFunc("POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))", 0);
+  testStNumInteriorRingFunc(
+      "POLYGON ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))", 1);
+  testStNumInteriorRingFunc("POLYGON EMPTY", std::nullopt);
+
+  VELOX_ASSERT_USER_THROW(
+      testStNumInteriorRingFunc("LINESTRING (8 4, 5 7)", std::nullopt),
+      "ST_NumInteriorRing only applies to Polygon. Input type is: LineString");
+}
+
+TEST_F(GeometryFunctionsTest, testStNumGeometries) {
+  const auto testStNumGeometriesFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<int32_t>& expected) {
+        std::optional<int32_t> result = evaluateOnce<int32_t>(
+            "ST_NumGeometries(ST_GeometryFromText(c0))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  // GeometryCollections with only empty geometries always return 0
+  testStNumGeometriesFunc("GEOMETRYCOLLECTION (POINT EMPTY, POINT EMPTY)", 0);
+  testStNumGeometriesFunc("GEOMETRYCOLLECTION (POINT EMPTY)", 0);
+  // GeometryCollections with at least 1 non-empty geometry return the number of
+  // geometries
+  testStNumGeometriesFunc("GEOMETRYCOLLECTION(POINT EMPTY, POINT (1 2))", 2);
+
+  testStNumGeometriesFunc("POINT EMPTY", 0);
+  testStNumGeometriesFunc("GEOMETRYCOLLECTION EMPTY", 0);
+  testStNumGeometriesFunc("MULTIPOLYGON EMPTY", 0);
+  testStNumGeometriesFunc("POINT (1 2)", 1);
+  testStNumGeometriesFunc(
+      "LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)", 1);
+  testStNumGeometriesFunc("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))", 1);
+  testStNumGeometriesFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 4);
+  testStNumGeometriesFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 2);
+  testStNumGeometriesFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      2);
+  testStNumGeometriesFunc(
+      "GEOMETRYCOLLECTION(POINT(2 3), LINESTRING (2 3, 3 4))", 2);
+}
+
+TEST_F(GeometryFunctionsTest, testStConvexHull) {
+  const auto testStConvexHullFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_ConvexHull(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  // test empty geometry
+  testStConvexHullFunc("POINT EMPTY", "POINT EMPTY");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (POINT (1 1), POINT EMPTY)", "POINT (1 1)");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (POINT (1 5), POINT (4 5), GEOMETRYCOLLECTION (POINT (3 4), POINT EMPTY))))",
+      "POLYGON ((1 1, 1 5, 4 5, 1 1))");
+
+  // test single geometry
+  testStConvexHullFunc("POINT (1 1)", "POINT (1 1)");
+  testStConvexHullFunc(
+      "LINESTRING (1 1, 1 9, 2 2)", "POLYGON ((1 1, 1 9, 2 2, 1 1))");
+
+  // convex single geometry
+  testStConvexHullFunc(
+      "LINESTRING (1 1, 1 9, 2 2, 1 1)", "POLYGON ((1 1, 1 9, 2 2, 1 1))");
+  testStConvexHullFunc(
+      "POLYGON ((0 0, 0 3, 2 4, 4 2, 3 0, 0 0))",
+      "POLYGON ((0 0, 0 3, 2 4, 4 2, 3 0, 0 0))");
+
+  // non-convex geometry
+  testStConvexHullFunc(
+      "LINESTRING (1 1, 1 9, 2 2, 1 1, 4 0)", "POLYGON ((4 0, 1 1, 1 9, 4 0))");
+  testStConvexHullFunc(
+      "POLYGON ((0 0, 0 3, 4 4, 1 1, 3 0, 0 0))",
+      "POLYGON ((0 0, 0 3, 4 4, 3 0, 0 0))");
+
+  // all points are on the same line
+  testStConvexHullFunc(
+      "LINESTRING (20 20, 30 30)", "LINESTRING (20 20, 30 30)");
+  testStConvexHullFunc(
+      "MULTILINESTRING ((0 0, 3 3), (1 1, 2 2), (2 2, 4 4), (5 5, 8 8))",
+      "LINESTRING (0 0, 8 8)");
+  testStConvexHullFunc(
+      "MULTIPOINT (0 1, 1 2, 2 3, 3 4, 4 5, 5 6)", "LINESTRING (0 1, 5 6)");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (2 2), POINT (1 1)), POINT(3 3))",
+      "LINESTRING (1 1, 3 3)");
+
+  // not all points are on the same line
+  testStConvexHullFunc(
+      "MULTILINESTRING ((1 1, 5 1, 6 6), (2 4, 4 0), (2 -4, 4 4), (3 -2, 4 -3))",
+      "POLYGON ((2 -4, 1 1, 2 4, 6 6, 5 1, 4 -3, 2 -4))");
+  testStConvexHullFunc(
+      "MULTIPOINT (0 2, 1 0, 3 0, 4 0, 4 2, 2 2, 2 4)",
+      "POLYGON ((1 0, 0 2, 2 4, 4 2, 4 0, 1 0))");
+  testStConvexHullFunc(
+      "MULTIPOLYGON (((0 3, 2 0, 3 6, 0 3), (2 1, 2 3, 5 3, 5 1, 2 1), (1 7, 2 4, 4 2, 5 6, 3 8, 1 7)))",
+      "POLYGON ((2 0, 0 3, 1 7, 3 8, 5 6, 5 1, 2 0))");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (POINT (2 3), LINESTRING (2 8, 7 10), POINT (8 10), POLYGON ((4 4, 4 8, 9 8, 6 6, 6 4, 8 3, 6 1, 4 4)), POINT (4 2), LINESTRING (3 6, 5 5), POLYGON ((7 5, 7 6, 8 6, 8 5, 7 5)))",
+      "POLYGON ((6 1, 2 3, 2 8, 7 10, 8 10, 9 8, 8 3, 6 1))");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (2 3), LINESTRING (2 8, 7 10), GEOMETRYCOLLECTION (POINT (8 10))), POLYGON ((4 4, 4 8, 9 8, 6 6, 6 4, 8 3, 6 1, 4 4)), POINT (4 2), LINESTRING (3 6, 5 5), POLYGON ((7 5, 7 6, 8 6, 8 5, 7 5)))",
+      "POLYGON ((6 1, 2 3, 2 8, 7 10, 8 10, 9 8, 8 3, 6 1))");
+
+  // single-element multi-geometries and geometry collections
+  testStConvexHullFunc(
+      "MULTILINESTRING ((1 1, 5 1, 6 6))", "POLYGON ((1 1, 6 6, 5 1, 1 1))");
+  testStConvexHullFunc(
+      "MULTILINESTRING ((1 1, 5 1, 1 4, 5 4))",
+      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))");
+  testStConvexHullFunc("MULTIPOINT (0 2)", "POINT (0 2)");
+  testStConvexHullFunc(
+      "MULTIPOLYGON (((0 3, 3 6, 2 0, 0 3)))",
+      "POLYGON ((2 0, 0 3, 3 6, 2 0))");
+  testStConvexHullFunc(
+      "MULTIPOLYGON (((0 0, 4 0, 4 4, 0 4, 2 2, 0 0)))",
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))");
+  testStConvexHullFunc("GEOMETRYCOLLECTION (POINT (2 3))", "POINT (2 3)");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (LINESTRING (1 1, 5 1, 6 6))",
+      "POLYGON ((1 1, 6 6, 5 1, 1 1))");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (LINESTRING (1 1, 5 1, 1 4, 5 4))",
+      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (POLYGON ((0 3, 3 6, 2 0, 0 3)))",
+      "POLYGON ((2 0, 0 3, 3 6, 2 0))");
+  testStConvexHullFunc(
+      "GEOMETRYCOLLECTION (POLYGON ((0 0, 4 0, 4 4, 0 4, 2 2, 0 0)))",
+      "POLYGON ((0 0, 0 4, 4 4, 4 0, 0 0))");
+}
+
+TEST_F(GeometryFunctionsTest, testStCoordDim) {
+  const auto testStCoordDimFunc = [&](const std::optional<std::string>& wkt,
+                                      const std::optional<int8_t>& expected) {
+    std::optional<int8_t> result =
+        evaluateOnce<int8_t>("ST_CoordDim(ST_GeometryFromText(c0))", wkt);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStCoordDimFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", 2);
+  testStCoordDimFunc("POLYGON EMPTY))", 2);
+  testStCoordDimFunc("LINESTRING (1 1, 1 2)", 2);
+  testStCoordDimFunc("POINT (1 4)", 2);
+
+  testStCoordDimFunc("LINESTRING EMPTY", 2);
+}
+
+TEST_F(GeometryFunctionsTest, testStDimension) {
+  const auto testStDimensionFunc = [&](const std::optional<std::string>& wkt,
+                                       const std::optional<int8_t>& expected) {
+    std::optional<int8_t> result =
+        evaluateOnce<int8_t>("ST_Dimension(ST_GeometryFromText(c0))", wkt);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStDimensionFunc("POLYGON EMPTY", 2);
+  testStDimensionFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", 2);
+  testStDimensionFunc("LINESTRING EMPTY", 1);
+  testStDimensionFunc("POINT (1 4))", 0);
+}
+
+TEST_F(GeometryFunctionsTest, testStBuffer) {
+  const auto testStBufferFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<double>& distance,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_Buffer(ST_GeometryFromText(c0), c1))", wkt, distance);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStBufferFunc(
+      "POINT (0 0)",
+      0.5,
+      "POLYGON ((0.5 0, 0.4903926402016152 -0.0975451610080641, 0.4619397662556434 -0.1913417161825449, 0.4157348061512726 -0.2777851165098011, 0.3535533905932738 -0.3535533905932737, 0.2777851165098011 -0.4157348061512726, 0.1913417161825449 -0.4619397662556434, 0.0975451610080642 -0.4903926402016152, 0 -0.5, -0.0975451610080641 -0.4903926402016152, -0.1913417161825449 -0.4619397662556434, -0.277785116509801 -0.4157348061512727, -0.3535533905932737 -0.3535533905932738, -0.4157348061512727 -0.2777851165098011, -0.4619397662556434 -0.191341716182545, -0.4903926402016152 -0.0975451610080643, -0.5 -0.0000000000000001, -0.4903926402016152 0.0975451610080642, -0.4619397662556434 0.1913417161825448, -0.4157348061512727 0.277785116509801, -0.3535533905932738 0.3535533905932737, -0.2777851165098011 0.4157348061512726, -0.1913417161825452 0.4619397662556433, -0.0975451610080643 0.4903926402016152, -0.0000000000000001 0.5, 0.0975451610080642 0.4903926402016152, 0.191341716182545 0.4619397662556433, 0.2777851165098009 0.4157348061512727, 0.3535533905932737 0.3535533905932738, 0.4157348061512726 0.2777851165098011, 0.4619397662556433 0.1913417161825452, 0.4903926402016152 0.0975451610080644, 0.5 0))");
+  testStBufferFunc(
+      "LINESTRING (0 0, 1 1, 2 0.5)",
+      .2,
+      "POLYGON ((0.8585786437626906 1.1414213562373094, 0.8908600605480863 1.167596162296255, 0.9278541681368628 1.1865341227356967, 0.9679635513986066 1.1974174915274993, 1.0094562767938988 1.1997763219933664, 1.050540677712335 1.1935087592239118, 1.0894427190999916 1.1788854381999831, 2.0894427190999916 0.6788854381999831, 2.1226229200749436 0.6579987957938098, 2.1510907909991412 0.6310403482720258, 2.173752327557934 0.5990460936544217, 2.189736659610103 0.5632455532033676, 2.198429518239 0.5250145216112229, 2.1994968417625285 0.4858221959818642, 2.192897613536241 0.4471747154099183, 2.178885438199983 0.4105572809000084, 2.1579987957938096 0.3773770799250564, 2.131040348272026 0.3489092090008588, 2.099046093654422 0.3262476724420662, 2.0632455532033678 0.3102633403898972, 2.0250145216112228 0.3015704817609999, 1.985822195981864 0.3005031582374715, 1.9471747154099184 0.3071023864637593, 1.9105572809000084 0.3211145618000168, 1.0394906098164267 0.7566478973418077, 0.1414213562373095 -0.1414213562373095, 0.1111140466039205 -0.1662939224605091, 0.076536686473018 -0.1847759065022574, 0.0390180644032257 -0.1961570560806461, 0 -0.2, -0.0390180644032256 -0.1961570560806461, -0.076536686473018 -0.1847759065022574, -0.1111140466039204 -0.1662939224605091, -0.1414213562373095 -0.1414213562373095, -0.1662939224605091 -0.1111140466039204, -0.1847759065022574 -0.076536686473018, -0.1961570560806461 -0.0390180644032257, -0.2 0, -0.1961570560806461 0.0390180644032257, -0.1847759065022574 0.0765366864730179, -0.1662939224605091 0.1111140466039204, -0.1414213562373095 0.1414213562373095, 0.8585786437626906 1.1414213562373094))");
+  testStBufferFunc(
+      "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))",
+      1.2,
+      "POLYGON ((0 -1.2, -0.2341083864193544 -1.1769423364838763, -0.4592201188381084 -1.1086554390135437, -0.6666842796235226 -0.9977635347630542, -0.8485281374238572 -0.8485281374238569, -0.9977635347630545 -0.6666842796235223, -1.1086554390135441 -0.4592201188381076, -1.1769423364838765 -0.234108386419354, -1.2 0, -1.2 5, -1.1769423364838765 5.234108386419354, -1.1086554390135441 5.4592201188381075, -0.9977635347630543 5.666684279623523, -0.8485281374238569 5.848528137423857, -0.6666842796235223 5.997763534763054, -0.4592201188381076 6.108655439013544, -0.2341083864193538 6.176942336483877, 0 6.2, 5 6.2, 5.234108386419354 6.176942336483877, 5.4592201188381075 6.108655439013544, 5.666684279623523 5.997763534763054, 5.848528137423857 5.848528137423857, 5.997763534763054 5.666684279623523, 6.108655439013544 5.4592201188381075, 6.176942336483877 5.234108386419354, 6.2 5, 6.2 0, 6.176942336483877 -0.2341083864193539, 6.108655439013544 -0.4592201188381077, 5.997763534763054 -0.6666842796235226, 5.848528137423857 -0.8485281374238569, 5.666684279623523 -0.9977635347630542, 5.4592201188381075 -1.1086554390135441, 5.234108386419354 -1.1769423364838765, 5 -1.2, 0 -1.2))");
+
+  // Zero distance
+  testStBufferFunc("POINT (0 0)", 0, "POINT (0 0)");
+  testStBufferFunc(
+      "LINESTRING (0 0, 1 1, 2 0.5)", 0, "LINESTRING (0 0, 1 1, 2 0.5)");
+  testStBufferFunc(
+      "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))",
+      0,
+      "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))");
+
+  // GeometryCollection
+  testStBufferFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))",
+      .2,
+      "MULTIPOLYGON (((5 1.2, 5.039018064403225 1.196157056080646, 5.076536686473018 1.1847759065022574, 5.11111404660392 1.1662939224605091, 5.141421356237309 1.1414213562373094, 5.166293922460509 1.1111140466039204, 5.184775906502257 1.076536686473018, 5.196157056080646 1.0390180644032256, 5.2 1, 5.196157056080646 0.9609819355967744, 5.184775906502257 0.9234633135269821, 5.166293922460509 0.8888859533960796, 5.141421356237309 0.8585786437626906, 5.11111404660392 0.8337060775394909, 5.076536686473018 0.8152240934977426, 5.039018064403225 0.803842943919354, 5 0.8, 1 0.8, 0.9609819355967743 0.803842943919354, 0.923463313526982 0.8152240934977427, 0.8888859533960796 0.8337060775394909, 0.8585786437626904 0.8585786437626906, 0.8337060775394909 0.8888859533960796, 0.8152240934977426 0.9234633135269821, 0.803842943919354 0.9609819355967744, 0.8 1, 0.803842943919354 1.0390180644032256, 0.8152240934977426 1.076536686473018, 0.8337060775394909 1.1111140466039204, 0.8585786437626906 1.1414213562373094, 0.8888859533960796 1.1662939224605091, 0.9234633135269821 1.1847759065022574, 0.9609819355967744 1.196157056080646, 1 1.2, 5 1.2)), ((4 4.2, 4.039018064403225 4.196157056080646, 4.076536686473018 4.184775906502257, 4.11111404660392 4.166293922460509, 4.141421356237309 4.141421356237309, 4.166293922460509 4.11111404660392, 4.184775906502257 4.076536686473018, 4.196157056080646 4.039018064403225, 4.2 4, 4.196157056080646 3.960981935596774, 4.184775906502257 3.923463313526982, 4.166293922460509 3.8888859533960796, 4.141421356237309 3.8585786437626903, 4.11111404660392 3.833706077539491, 4.076536686473018 3.8152240934977426, 4.039018064403225 3.8038429439193537, 4 3.8, 2 3.8, 1.9609819355967744 3.8038429439193537, 1.9234633135269819 3.8152240934977426, 1.8888859533960796 3.833706077539491, 1.8585786437626906 3.8585786437626903, 1.8337060775394909 3.8888859533960796, 1.8152240934977426 3.923463313526982, 1.803842943919354 3.960981935596774, 1.8 4, 1.803842943919354 4.039018064403225, 1.8152240934977426 4.076536686473018, 1.8337060775394909 4.11111404660392, 1.8585786437626906 4.141421356237309, 1.8888859533960796 4.166293922460509, 1.923463313526982 4.184775906502257, 1.9609819355967744 4.196157056080646, 2 4.2, 4 4.2)))");
+
+  // Empty
+  testStBufferFunc("POINT EMPTY", .2, std::nullopt);
+
+  // Negative distance
+  VELOX_ASSERT_USER_THROW(
+      testStBufferFunc("POINT (0 0)", -1.2, "POINT (0 0)"),
+      "Provided distance must not be negative. Provided distance: -1.2");
+}
+
+TEST_F(GeometryFunctionsTest, testStExteriorRing) {
+  const auto testStExteriorRingFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(ST_ExteriorRing(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStExteriorRingFunc("POLYGON EMPTY", std::nullopt);
+  testStExteriorRingFunc(
+      "POLYGON ((1 1, 1 4, 4 1, 1 1))", "LINESTRING (1 1, 1 4, 4 1, 1 1)");
+
+  testStExteriorRingFunc(
+      "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0), (1 1, 1 2, 2 2, 2 1, 1 1))",
+      "LINESTRING (0 0, 0 5, 5 5, 5 0, 0 0)");
+
+  VELOX_ASSERT_USER_THROW(
+      testStExteriorRingFunc("LINESTRING (1 1, 2 2, 1 3)", std::nullopt),
+      "ST_ExteriorRing only applies to Polygon. Input type is: LineString");
+  VELOX_ASSERT_USER_THROW(
+      testStExteriorRingFunc(
+          "MULTIPOLYGON (((1 1, 2 2, 1 3, 1 1)), ((4 4, 5 5, 4 6, 4 4)))",
+          std::nullopt),
+      "ST_ExteriorRing only applies to Polygon. Input type is: MultiPolygon");
+}
+
+TEST_F(GeometryFunctionsTest, testStEnvelope) {
+  const auto testStEnvelopeFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(st_envelope(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testStEnvelopeFunc(
+      "MULTIPOINT (1 2, 2 4, 3 6, 4 8)", "POLYGON ((1 2, 1 8, 4 8, 4 2, 1 2))");
+  testStEnvelopeFunc(
+      "LINESTRING (1 1, 2 2, 1 3)", "POLYGON ((1 1, 1 3, 2 3, 2 1, 1 1))");
+  testStEnvelopeFunc(
+      "LINESTRING (8 4, 5 7)", "POLYGON ((5 4, 5 7, 8 7, 8 4, 5 4))");
+  testStEnvelopeFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))",
+      "POLYGON ((1 1, 1 4, 5 4, 5 1, 1 1))");
+  testStEnvelopeFunc(
+      "POLYGON ((1 1, 4 1, 1 4, 1 1))", "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))");
+  testStEnvelopeFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((0 0, 0 2, 2 2, 2 0, 0 0)))",
+      "POLYGON ((0 0, 0 3, 3 3, 3 0, 0 0))");
+  testStEnvelopeFunc(
+      "GEOMETRYCOLLECTION (POINT (5 1), LINESTRING (3 4, 4 4))",
+      "POLYGON ((3 1, 3 4, 5 4, 5 1, 3 1))");
+  testStEnvelopeFunc(
+      "MULTIPOLYGON (((119.094024 -27.2871725, 119.094124 -27.2846569, 119.094124 -27.2868119, 119.094024 -27.2871725)))",
+      "POLYGON ((119.094024 -27.2871725, 119.094024 -27.2846569, 119.094124 -27.2846569, 119.094124 -27.2871725, 119.094024 -27.2871725))");
+
+  // Zero area envelope is valid
+  testStEnvelopeFunc(
+      "LINESTRING (1 1, 1 2)", "POLYGON ((1 1, 1 2, 1 2, 1 1, 1 1))");
+
+  testStEnvelopeFunc("POLYGON EMPTY", "POLYGON EMPTY");
+  testStEnvelopeFunc("MULTIPOLYGON EMPTY", "POLYGON EMPTY");
+  testStEnvelopeFunc("GEOMETRYCOLLECTION EMPTY", "POLYGON EMPTY");
+  testStEnvelopeFunc("POINT EMPTY", "POLYGON EMPTY");
+  testStEnvelopeFunc("MULTIPOINT EMPTY", "POLYGON EMPTY");
+  testStEnvelopeFunc("LINESTRING EMPTY", "POLYGON EMPTY");
+  testStEnvelopeFunc("MULTILINESTRING EMPTY", "POLYGON EMPTY");
+}
+
+TEST_F(GeometryFunctionsTest, testStPoints) {
+  const auto testStPointsFunc = [&](const std::optional<std::string>& wkt,
+                                    const std::optional<std::vector<
+                                        std::optional<std::string>>>&
+                                        expectedPoints) {
+    auto input = makeSingleStringInputRow(wkt);
+
+    facebook::velox::VectorPtr output = evaluate(
+        "transform(ST_Points(ST_GeometryFromText(c0)), x -> substr(ST_AsText(x), 7))",
+        input);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    ASSERT_TRUE(arrayVector != nullptr);
+
+    auto expected = makeNullableArrayVector<std::string>({{expectedPoints}});
+    facebook::velox::test::assertEqualVectors(expected, output);
+  };
+
+  testStPointsFunc("LINESTRING (0 0, 0 0)", {{"(0 0)", "(0 0)"}});
+  testStPointsFunc("LINESTRING (8 4, 3 9, 8 4)", {{"(8 4)", "(3 9)", "(8 4)"}});
+  testStPointsFunc("LINESTRING (8 4, 3 9, 5 6)", {{"(8 4)", "(3 9)", "(5 6)"}});
+  testStPointsFunc(
+      "LINESTRING (8 4, 3 9, 5 6, 3 9, 8 4)",
+      {{"(8 4)", "(3 9)", "(5 6)", "(3 9)", "(8 4)"}});
+
+  testStPointsFunc(
+      "POLYGON ((8 4, 3 9, 5 6, 8 4))", {{"(8 4)", "(5 6)", "(3 9)", "(8 4)"}});
+  testStPointsFunc(
+      "POLYGON ((8 4, 3 9, 5 6, 7 2, 8 4))",
+      {{"(8 4)", "(7 2)", "(5 6)", "(3 9)", "(8 4)"}});
+
+  testStPointsFunc("POINT (0 0)", {{"(0 0)"}});
+  testStPointsFunc("POINT (0 1)", {{"(0 1)"}});
+
+  testStPointsFunc("MULTIPOINT (0 0)", {{"(0 0)"}});
+  testStPointsFunc("MULTIPOINT (0 0, 1 2)", {{"(0 0)", "(1 2)"}});
+
+  testStPointsFunc(
+      "MULTILINESTRING ((0 0, 1 1), (2 3, 3 2))",
+      {{"(0 0)", "(1 1)", "(2 3)", "(3 2)"}});
+  testStPointsFunc(
+      "MULTILINESTRING ((0 0, 1 1, 1 2), (2 3, 3 2, 5 4))",
+      {{"(0 0)", "(1 1)", "(1 2)", "(2 3)", "(3 2)", "(5 4)"}});
+  testStPointsFunc(
+      "MULTILINESTRING ((0 0, 1 1, 1 2), (1 2, 3 2, 5 4))",
+      {{"(0 0)", "(1 1)", "(1 2)", "(1 2)", "(3 2)", "(5 4)"}});
+
+  testStPointsFunc(
+      "MULTIPOLYGON (((0 0, 4 0, 4 4, 0 4, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), ((-1 -1, -1 -2, -2 -2, -2 -1, -1 -1)))",
+      {{
+          "(0 0)",
+          "(0 4)",
+          "(4 4)",
+          "(4 0)",
+          "(0 0)",
+          "(1 1)",
+          "(2 1)",
+          "(2 2)",
+          "(1 2)",
+          "(1 1)",
+          "(-1 -1)",
+          "(-1 -2)",
+          "(-2 -2)",
+          "(-2 -1)",
+          "(-1 -1)",
+      }});
+
+  testStPointsFunc(
+      "GEOMETRYCOLLECTION(POINT(0 1),LINESTRING(0 3,3 4),POLYGON((2 0,2 3,0 2,2 0)),POLYGON((3 0,3 3,6 3,6 0,3 0),(5 1,4 2,5 2,5 1)),MULTIPOLYGON(((0 5,0 8,4 8,4 5,0 5),(1 6,3 6,2 7,1 6)),((5 4,5 8,6 7,5 4))))",
+      {{"(0 1)", "(0 3)", "(3 4)", "(2 0)", "(0 2)", "(2 3)", "(2 0)", "(3 0)",
+        "(3 3)", "(6 3)", "(6 0)", "(3 0)", "(5 1)", "(5 2)", "(4 2)", "(5 1)",
+        "(0 5)", "(0 8)", "(4 8)", "(4 5)", "(0 5)", "(1 6)", "(3 6)", "(2 7)",
+        "(1 6)", "(5 4)", "(5 8)", "(6 7)", "(5 4)"}});
+
+  const auto testStPointsNullAndEmptyFunc =
+      [&](const std::optional<std::string>& wkt) {
+        std::optional<bool> result = evaluateOnce<bool>(
+            "ST_Points(ST_GeometryFromText(c0)) IS NULL", wkt);
+
+        ASSERT_TRUE(result.has_value());
+        ASSERT_TRUE(result.value());
+      };
+
+  testStPointsNullAndEmptyFunc("POINT EMPTY");
+  testStPointsNullAndEmptyFunc("LINESTRING EMPTY");
+  testStPointsNullAndEmptyFunc("POLYGON EMPTY");
+  testStPointsNullAndEmptyFunc("MULTIPOINT EMPTY");
+  testStPointsNullAndEmptyFunc("MULTILINESTRING EMPTY");
+  testStPointsNullAndEmptyFunc("MULTIPOLYGON EMPTY");
+  testStPointsNullAndEmptyFunc("GEOMETRYCOLLECTION EMPTY");
+  testStPointsNullAndEmptyFunc(std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testStEnvelopeAsPts) {
+  const auto testStEnvelopeAsPtsFunc = [&](const std::optional<std::string>&
+                                               wkt,
+                                           const std::optional<std::vector<
+                                               std::optional<std::string>>>&
+                                               expectedPoints) {
+    auto input = makeSingleStringInputRow(wkt);
+
+    facebook::velox::VectorPtr output = evaluate(
+        "transform(ST_EnvelopeAsPts(ST_GeometryFromText(c0)), x -> substr(ST_AsText(x), 7))",
+        input);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    ASSERT_TRUE(arrayVector != nullptr);
+
+    std::vector<std::vector<std::optional<std::string>>> vec = {
+        expectedPoints.value()};
+    auto expected = makeNullableArrayVector<std::string>(vec);
+    facebook::velox::test::assertEqualVectors(expected, output);
+  };
+
+  testStEnvelopeAsPtsFunc(
+      "MULTIPOINT (1 2, 2 4, 3 6, 4 8)", {{"(1 2)", "(4 8)"}});
+  testStEnvelopeAsPtsFunc("LINESTRING (1 1, 2 2, 1 3)", {{"(1 1)", "(2 3)"}});
+  testStEnvelopeAsPtsFunc("LINESTRING (8 4, 5 7)", {{"(5 4)", "(8 7)"}});
+  testStEnvelopeAsPtsFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", {{"(1 1)", "(5 4)"}});
+  testStEnvelopeAsPtsFunc(
+      "POLYGON ((1 1, 4 1, 1 4, 1 1))", {{"(1 1)", "(4 4)"}});
+  testStEnvelopeAsPtsFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((0 0, 0 2, 2 2, 2 0, 0 0)))",
+      {{"(0 0)", "(3 3)"}});
+  testStEnvelopeAsPtsFunc(
+      "GEOMETRYCOLLECTION (POINT (5 1), LINESTRING (3 4, 4 4))",
+      {{"(3 1)", "(5 4)"}});
+  testStEnvelopeAsPtsFunc("POINT (1 2)", {{"(1 2)", "(1 2)"}});
+
+  const auto testStEnvelopeAsPtsNullAndEmptyFunc =
+      [&](const std::optional<std::string>& wkt) {
+        std::optional<bool> result = evaluateOnce<bool>(
+            "ST_EnvelopeAsPts(ST_GeometryFromText(c0)) IS NULL", wkt);
+
+        ASSERT_TRUE(result.has_value());
+        ASSERT_TRUE(result.value());
+      };
+
+  testStEnvelopeAsPtsNullAndEmptyFunc("POINT EMPTY");
+  testStEnvelopeAsPtsNullAndEmptyFunc("LINESTRING EMPTY");
+  testStEnvelopeAsPtsNullAndEmptyFunc("POLYGON EMPTY");
+  testStEnvelopeAsPtsNullAndEmptyFunc("MULTIPOINT EMPTY");
+  testStEnvelopeAsPtsNullAndEmptyFunc("MULTILINESTRING EMPTY");
+  testStEnvelopeAsPtsNullAndEmptyFunc("MULTIPOLYGON EMPTY");
+  testStEnvelopeAsPtsNullAndEmptyFunc("GEOMETRYCOLLECTION EMPTY");
+  testStEnvelopeAsPtsNullAndEmptyFunc(std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testStNumPoints) {
+  const auto testStNumPointsFunc = [&](const std::optional<std::string>& wkt,
+                                       const std::optional<int64_t>& expected) {
+    std::optional<int64_t> result =
+        evaluateOnce<int64_t>("ST_NumPoints(ST_GeometryFromText(c0))", wkt);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testStNumPointsFunc("POINT EMPTY", 0);
+  testStNumPointsFunc("MULTIPOINT EMPTY", 0);
+  testStNumPointsFunc("LINESTRING EMPTY", 0);
+  testStNumPointsFunc("MULTILINESTRING EMPTY", 0);
+  testStNumPointsFunc("POLYGON EMPTY", 0);
+  testStNumPointsFunc("MULTIPOLYGON EMPTY", 0);
+  testStNumPointsFunc("GEOMETRYCOLLECTION EMPTY", 0);
+
+  testStNumPointsFunc("POINT (1 2)", 1);
+  testStNumPointsFunc("MULTIPOINT (1 2, 2 4, 3 6, 4 8)", 4);
+  testStNumPointsFunc("LINESTRING (8 4, 5 7)", 2);
+  testStNumPointsFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))", 4);
+  testStNumPointsFunc("POLYGON ((0 0, 8 0, 0 8, 0 0))", 3);
+  testStNumPointsFunc(
+      "POLYGON ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))", 6);
+  testStNumPointsFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))",
+      8);
+  testStNumPointsFunc(
+      "GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), GEOMETRYCOLLECTION (POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)))))",
+      7);
+}
+
+TEST_F(GeometryFunctionsTest, testGeometryNearestPoints) {
+  const auto testGeometryNearestPointsFunc = [&](const std::optional<
+                                                     std::string>& wkt1,
+                                                 const std::optional<
+                                                     std::string>& wkt2,
+                                                 const std::optional<
+                                                     std::vector<std::optional<
+                                                         std::string>>>&
+                                                     expectedPoints) {
+    auto inputVec1 = makeNullableFlatVector<std::string>({wkt1});
+    auto inputVec2 = makeNullableFlatVector<std::string>({wkt2});
+    auto input = makeRowVector({inputVec1, inputVec2});
+
+    facebook::velox::VectorPtr output = evaluate(
+        "transform(geometry_nearest_points(ST_GeometryFromText(c0), ST_GeometryFromText(c1)), x -> substr(ST_AsText(x), 7))",
+        input);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    ASSERT_TRUE(arrayVector != nullptr);
+
+    std::vector<std::vector<std::optional<std::string>>> vec = {
+        expectedPoints.value()};
+    auto expected = makeNullableArrayVector<std::string>(vec);
+    facebook::velox::test::assertEqualVectors(expected, output);
+  };
+
+  testGeometryNearestPointsFunc(
+      "POINT (50 100)", "POINT (150 150)", {{"(50 100)", "(150 150)"}});
+  testGeometryNearestPointsFunc(
+      "MULTIPOINT (50 100, 50 200)",
+      "POINT (50 100)",
+      {{"(50 100)", "(50 100)"}});
+  testGeometryNearestPointsFunc(
+      "LINESTRING (50 100, 50 200)",
+      "LINESTRING (10 10, 20 20)",
+      {{"(50 100)", "(20 20)"}});
+  testGeometryNearestPointsFunc(
+      "MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))",
+      "LINESTRING (10 20, 20 50)",
+      {{"(4 4)", "(10 20)"}});
+  testGeometryNearestPointsFunc(
+      "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))",
+      "POLYGON ((4 4, 4 5, 5 5, 5 4, 4 4))",
+      {{"(3 3)", "(4 4)"}});
+  testGeometryNearestPointsFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((0 0, 0 2, 2 2, 2 0, 0 0)))",
+      "POLYGON ((10 100, 30 10, 30 100, 10 100))",
+      {{"(3 3)", "(30 10)"}});
+  testGeometryNearestPointsFunc(
+      "GEOMETRYCOLLECTION (POINT (0 0), LINESTRING (0 20, 20 0))",
+      "POLYGON ((5 5, 5 6, 6 6, 6 5, 5 5))",
+      {{"(10 10)", "(6 6)"}});
+
+  const auto noNearestPointsFunc = [&](const std::optional<std::string>& wkt1,
+                                       const std::optional<std::string>& wkt2) {
+    std::optional<bool> result = evaluateOnce<bool>(
+        "geometry_nearest_points(ST_GeometryFromText(c0), ST_GeometryFromText(c1)) IS NULL",
+        wkt1,
+        wkt2);
+
+    ASSERT_TRUE(result.has_value());
+    ASSERT_TRUE(result.value());
+  };
+
+  noNearestPointsFunc("POINT EMPTY", "POINT (150 150)");
+  noNearestPointsFunc("POINT (50 100)", "POINT EMPTY");
+  noNearestPointsFunc("POINT EMPTY", "POINT EMPTY");
+  noNearestPointsFunc("MULTIPOINT EMPTY", "POINT (50 100)");
+  noNearestPointsFunc("LINESTRING (50 100, 50 200)", "LINESTRING EMPTY");
+  noNearestPointsFunc("MULTILINESTRING EMPTY", "LINESTRING (10 20, 20 50)");
+  noNearestPointsFunc("POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))", "POLYGON EMPTY");
+  noNearestPointsFunc(
+      "MULTIPOLYGON EMPTY", "POLYGON ((10 100, 30 10, 30 100, 10 100))");
+
+  noNearestPointsFunc(
+      std::nullopt, "POLYGON ((10 100, 30 10, 30 100, 10 100))");
+  noNearestPointsFunc("LINESTRING (50 100, 50 200)", std::nullopt);
+  noNearestPointsFunc(std::nullopt, std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testLineLocatePoint) {
+  const auto testLineLocatePointFunc = [&](const std::optional<std::string>&
+                                               lineWkt,
+                                           const std::optional<std::string>&
+                                               pointWkt,
+                                           const std::optional<double>&
+                                               expected) {
+    std::optional<double> result = evaluateOnce<double>(
+        "line_locate_point(ST_GeometryFromText(c0), ST_GeometryFromText(c1))",
+        lineWkt,
+        pointWkt);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expected.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testLineLocatePointFunc("LINESTRING (0 0, 0 1)", "POINT (0 0.2)", .2);
+  testLineLocatePointFunc("LINESTRING (0 0, 0 1)", "POINT (0 0)", 0.0);
+  testLineLocatePointFunc("LINESTRING (0 0, 0 1)", "POINT (0 -1)", 0.0);
+  testLineLocatePointFunc("LINESTRING (0 0, 0 1)", "POINT (0 1)", 1.0);
+  testLineLocatePointFunc("LINESTRING (0 0, 0 1)", "POINT (0 2)", 1.0);
+  testLineLocatePointFunc(
+      "LINESTRING (0 0, 0 1, 2 1)", "POINT (0 0.2)", 0.06666666666666667);
+  testLineLocatePointFunc(
+      "LINESTRING (0 0, 0 1, 2 1)", "POINT (0.9 1)", 0.6333333333333333);
+  testLineLocatePointFunc("LINESTRING (1 3, 5 4)", "POINT (1 3)", 0.0);
+  testLineLocatePointFunc(
+      "LINESTRING (1 3, 5 4)", "POINT (2 3)", 0.23529411764705882);
+  testLineLocatePointFunc("LINESTRING (1 3, 5 4)", "POINT (5 4)", 1.0);
+  testLineLocatePointFunc(
+      "MULTILINESTRING ((0 0, 0 1), (2 2, 4 2))",
+      "POINT (3 1)",
+      0.6666666666666666);
+
+  testLineLocatePointFunc("LINESTRING EMPTY", "POINT (5 4)", std::nullopt);
+  testLineLocatePointFunc("LINESTRING (1 3, 5 4)", "POINT EMPTY", std::nullopt);
+
+  testLineLocatePointFunc(std::nullopt, "POINT (5 4)", std::nullopt);
+  testLineLocatePointFunc("LINESTRING (1 3, 5 4)", std::nullopt, std::nullopt);
+
+  VELOX_ASSERT_USER_THROW(
+      testLineLocatePointFunc(
+          "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", "POINT (5 4)", std::nullopt),
+      "First argument to line_locate_point must be a LineString or a MultiLineString. Got: Polygon");
+
+  VELOX_ASSERT_USER_THROW(
+      testLineLocatePointFunc(
+          "LINESTRING (0 0, 0 1)", "LINESTRING (1 3, 5 4)", std::nullopt),
+      "Second argument to line_locate_point must be a Point. Got: LineString");
+}
+
+TEST_F(GeometryFunctionsTest, testLineInterpolatePoint) {
+  const auto testLineInterpolatePointFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<double>& fraction,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(line_interpolate_point(ST_GeometryFromText(c0), c1))",
+            wkt,
+            fraction);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testLineInterpolatePointFunc("LINESTRING EMPTY", .5, "POINT EMPTY");
+  testLineInterpolatePointFunc("LINESTRING (0 0, 0 1)", .2, "POINT (0 0.2)");
+  testLineInterpolatePointFunc("LINESTRING (0 0, 0 1)", 0.0, "POINT (0 0)");
+  testLineInterpolatePointFunc("LINESTRING (0 0, 0 1)", 1.0, "POINT (0 1)");
+  testLineInterpolatePointFunc(
+      "LINESTRING (0 0, 0 1, 3 1)", .0625, "POINT (0 0.25)");
+  testLineInterpolatePointFunc(
+      "LINESTRING (0 0, 0 1, 3 1)", .75, "POINT (2 1)");
+  testLineInterpolatePointFunc("LINESTRING (1 3, 5 4)", 0.0, "POINT (1 3)");
+  testLineInterpolatePointFunc("LINESTRING (1 3, 5 4)", 0.25, "POINT (2 3.25)");
+  testLineInterpolatePointFunc("LINESTRING (1 3, 5 4)", 1.0, "POINT (5 4)");
+
+  VELOX_ASSERT_USER_THROW(
+      testLineInterpolatePointFunc(
+          "POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))", .5, std::nullopt),
+      "line_interpolate_point only applies to LineString. Input type is: Polygon");
+
+  VELOX_ASSERT_USER_THROW(
+      testLineInterpolatePointFunc(
+          "MULTILINESTRING ((0 0, 0 1), (2 2, 4 2))", .5, std::nullopt),
+      "line_interpolate_point only applies to LineString. Input type is: MultiLineString");
+
+  VELOX_ASSERT_USER_THROW(
+      testLineInterpolatePointFunc(
+          "LINESTRING (0 0, 0 1, 2 1)", -1.0, std::nullopt),
+      "line_interpolate_point: Fraction must be between 0 and 1, but is -1");
+
+  VELOX_ASSERT_USER_THROW(
+      testLineInterpolatePointFunc(
+          "LINESTRING (0 0, 0 1, 2 1)", 1.5, std::nullopt),
+      "line_interpolate_point: Fraction must be between 0 and 1, but is 1.5");
+}
+
+TEST_F(GeometryFunctionsTest, testStInteriorRings) {
+  const auto testStInteriorRingsFunc = [&](const std::optional<std::string>&
+                                               wkt,
+                                           const std::optional<std::vector<
+                                               std::optional<std::string>>>&
+                                               expectedGeoms) {
+    auto input = makeSingleStringInputRow(wkt);
+
+    facebook::velox::VectorPtr output = evaluate(
+        "transform(ST_InteriorRings(ST_GeometryFromText(c0)), x -> ST_AsText(x))",
+        input);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    if (expectedGeoms.has_value()) {
+      ASSERT_TRUE(arrayVector != nullptr);
+
+      std::vector<std::vector<std::optional<std::string>>> vec = {
+          expectedGeoms.value()};
+      auto expected = makeNullableArrayVector<std::string>(vec);
+      facebook::velox::test::assertEqualVectors(expected, output);
+    } else {
+      ASSERT_TRUE(output->isNullAt(0));
+    }
+  };
+
+  testStInteriorRingsFunc(
+      "POLYGON ((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))",
+      {{"LINESTRING (1 1, 2 1, 2 2, 1 2, 1 1)"}});
+  testStInteriorRingsFunc(
+      "POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+      {{"LINESTRING (1 1, 2 1, 2 2, 1 2, 1 1)",
+        "LINESTRING (3 3, 4 3, 4 4, 3 4, 3 3)"}});
+  testStInteriorRingsFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))",
+      facebook::velox::common::testutil::optionalEmpty);
+  testStInteriorRingsFunc("POLYGON EMPTY", std::nullopt);
+
+  VELOX_ASSERT_USER_THROW(
+      testStInteriorRingsFunc("POINT (2 3)", std::nullopt),
+      "ST_InteriorRings only applies to Polygon. Input type is: Point");
+}
+
+TEST_F(GeometryFunctionsTest, testStGeometries) {
+  const auto testStGeometriesFunc = [&](const std::optional<std::string>& wkt,
+                                        const std::optional<std::vector<
+                                            std::optional<std::string>>>&
+                                            expectedGeoms) {
+    auto input = makeSingleStringInputRow(wkt);
+    facebook::velox::VectorPtr output = evaluate(
+        "transform(ST_Geometries(ST_GeometryFromText(c0)), x -> ST_AsText(x))",
+        input);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    if (expectedGeoms.has_value()) {
+      ASSERT_TRUE(arrayVector != nullptr);
+
+      std::vector<std::vector<std::optional<std::string>>> vec = {
+          expectedGeoms.value()};
+      auto expected = makeNullableArrayVector<std::string>(vec);
+      facebook::velox::test::assertEqualVectors(expected, output);
+    } else {
+      ASSERT_TRUE(output->isNullAt(0));
+    }
+  };
+
+  testStGeometriesFunc("POINT (1 5)", {{"POINT (1 5)"}});
+
+  testStGeometriesFunc(
+      "LINESTRING (77.29 29.07, 77.42 29.26, 77.27 29.31, 77.29 29.07)",
+      {{"LINESTRING (77.29 29.07, 77.42 29.26, 77.27 29.31, 77.29 29.07)"}});
+  testStGeometriesFunc(
+      "POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))",
+      {{"POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))"}});
+  testStGeometriesFunc(
+      "MULTIPOINT (1 2, 4 8, 16 32)",
+      {{"POINT (1 2)", "POINT (4 8)", "POINT (16 32)"}});
+  testStGeometriesFunc(
+      "MULTILINESTRING ((1 1, 2 2))", {{"LINESTRING (1 1, 2 2)"}});
+  testStGeometriesFunc(
+      "MULTIPOLYGON (((0 0, 0 1, 1 1, 1 0, 0 0)), ((1 1, 3 1, 3 3, 1 3, 1 1)))",
+      {{"POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))",
+        "POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))"}});
+  testStGeometriesFunc(
+      "GEOMETRYCOLLECTION (POINT (2 3), LINESTRING (2 3, 3 4))",
+      {{"POINT (2 3)", "LINESTRING (2 3, 3 4)"}});
+  testStGeometriesFunc(
+      "GEOMETRYCOLLECTION(MULTIPOINT(0 0, 1 1), GEOMETRYCOLLECTION(MULTILINESTRING((2 2, 3 3))))",
+      {{"MULTIPOINT (0 0, 1 1)",
+        "GEOMETRYCOLLECTION (MULTILINESTRING ((2 2, 3 3)))"}});
+
+  std::optional<bool> emptyGeomReturnsNull = evaluateOnce<bool>(
+      "ST_Geometries(ST_GeometryFromText(c0)) IS NULL",
+      std::optional<std::string>("POLYGON EMPTY"));
+
+  ASSERT_TRUE(emptyGeomReturnsNull.has_value());
+  ASSERT_TRUE(emptyGeomReturnsNull.value());
+}
+
+TEST_F(GeometryFunctionsTest, testFlattenGeometryCollections) {
+  const auto testFlattenGeometryCollectionsFunc = [&](const std::optional<
+                                                          std::string>& wkt,
+                                                      const std::optional<
+                                                          std::vector<
+                                                              std::optional<
+                                                                  std::
+                                                                      string>>>&
+                                                          expectedGeoms) {
+    auto input = makeSingleStringInputRow(wkt);
+    facebook::velox::VectorPtr output = evaluate(
+        "transform(flatten_geometry_collections(ST_GeometryFromText(c0)), x -> ST_AsText(x))",
+        input);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    if (expectedGeoms.has_value()) {
+      ASSERT_TRUE(arrayVector != nullptr);
+
+      std::vector<std::vector<std::optional<std::string>>> vec = {
+          expectedGeoms.value()};
+      auto expected = makeNullableArrayVector<std::string>(vec);
+      facebook::velox::test::assertEqualVectors(expected, output);
+    } else {
+      ASSERT_TRUE(output->isNullAt(0));
+    }
+  };
+
+  testFlattenGeometryCollectionsFunc("POINT (1 5)", {{"POINT (1 5)"}});
+  testFlattenGeometryCollectionsFunc(
+      "MULTIPOINT ((0 0), (1 1))", {{"MULTIPOINT (0 0, 1 1)"}});
+  testFlattenGeometryCollectionsFunc(
+      "GEOMETRYCOLLECTION EMPTY",
+      facebook::velox::common::testutil::optionalEmpty);
+  testFlattenGeometryCollectionsFunc(
+      "GEOMETRYCOLLECTION (POINT EMPTY)", {{"POINT EMPTY"}});
+  testFlattenGeometryCollectionsFunc(
+      "GEOMETRYCOLLECTION (POINT (0 0))", {{"POINT (0 0)"}});
+  testFlattenGeometryCollectionsFunc(
+      "GEOMETRYCOLLECTION (POINT (0 0), GEOMETRYCOLLECTION (POINT (1 1)))",
+      {{"POINT (0 0)", "POINT (1 1)"}});
+
+  std::optional<std::string> wkt = std::nullopt;
+  std::optional<bool> expectNullResult = evaluateOnce<bool>(
+      "flatten_geometry_collections(ST_GeometryFromText(c0)) IS NULL", wkt);
+
+  ASSERT_TRUE(expectNullResult.has_value());
+  ASSERT_TRUE(expectNullResult.value());
+}
+
+TEST_F(GeometryFunctionsTest, testExpandEnvelope) {
+  const auto testExpandEnvelopeFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<double>& distance,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(expand_envelope(ST_GeometryFromText(c0), c1))",
+            wkt,
+            distance);
+
+        if (wkt.has_value() && distance.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testExpandEnvelopeFunc(
+      "POINT (1 10)", 3, "POLYGON ((-2 7, -2 13, 4 13, 4 7, -2 7))");
+  testExpandEnvelopeFunc(
+      "LINESTRING (1 10, 3 15)", 2, "POLYGON ((-1 8, -1 17, 5 17, 5 8, -1 8))");
+  testExpandEnvelopeFunc(
+      "GEOMETRYCOLLECTION (POINT (5 1), LINESTRING (3 4, 4 4))",
+      1,
+      "POLYGON ((2 0, 2 5, 6 5, 6 0, 2 0))");
+
+  testExpandEnvelopeFunc("POINT EMPTY", 3, "POLYGON EMPTY");
+  testExpandEnvelopeFunc("POLYGON EMPTY", 3, "POLYGON EMPTY");
+
+  testExpandEnvelopeFunc(std::nullopt, 3, "POLYGON EMPTY");
+  testExpandEnvelopeFunc("POINT EMPTY", std::nullopt, "POLYGON EMPTY");
+  testExpandEnvelopeFunc(std::nullopt, std::nullopt, "POLYGON EMPTY");
+
+  // presto-java returns empty envelopes when expand_envelope is called with
+  // infinity distance, so we do the same for consistency.
+  testExpandEnvelopeFunc(
+      "POINT (1 1)", std::numeric_limits<double>::infinity(), "POLYGON EMPTY");
+
+  VELOX_ASSERT_USER_THROW(
+      testExpandEnvelopeFunc(
+          "POINT (1 10)", -1, "POLYGON ((-2 7, -2 13, 4 13, 4 7, -2 7))"),
+      "Distance must be a non-negative number");
+
+  VELOX_ASSERT_USER_THROW(
+      testExpandEnvelopeFunc(
+          "POINT (1 10)",
+          std::numeric_limits<double>::quiet_NaN(),
+          std::nullopt),
+      "Distance must be a non-NaN number");
+
+  VELOX_ASSERT_USER_THROW(
+      testExpandEnvelopeFunc(
+          "POINT (1 10)",
+          std::numeric_limits<double>::signaling_NaN(),
+          std::nullopt),
+      "Distance must be a non-NaN number");
+
+  std::optional<std::string> wrappedEnvelopeResult = evaluateOnce<std::string>(
+      "ST_AsText(expand_envelope(ST_Envelope(ST_GeometryFromText(c0)), c1))",
+      std::optional<std::string>("POINT (1 10)"),
+      std::optional<double>(3));
+  ASSERT_TRUE(wrappedEnvelopeResult.has_value());
+  ASSERT_EQ(
+      wrappedEnvelopeResult.value(),
+      "POLYGON ((-2 7, -2 13, 4 13, 4 7, -2 7))");
+}
+
+TEST_F(GeometryFunctionsTest, testBingTilePolygon) {
+  const auto testBingTilePolygonFunc =
+      [&](const std::optional<int32_t>& x,
+          const std::optional<int32_t>& y,
+          const std::optional<int8_t>& zoom,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(bing_tile_polygon(bing_tile(c0, c1, c2)))", x, y, zoom);
+
+        if (x.has_value() && y.has_value() && zoom.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(result.value(), expected.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testBingTilePolygonFunc(
+      0,
+      0,
+      0,
+      "POLYGON ((-180 85.05112877980659, -180 -85.05112877980659, 180 -85.05112877980659, 180 85.05112877980659, -180 85.05112877980659))");
+  testBingTilePolygonFunc(
+      1,
+      1,
+      1,
+      "POLYGON ((0 0, 0 -85.05112877980659, 180 -85.05112877980659, 180 0, 0 0))");
+  testBingTilePolygonFunc(
+      3,
+      3,
+      2,
+      "POLYGON ((90 -66.51326044311185, 90 -85.05112877980659, 180 -85.05112877980659, 180 -66.51326044311185, 90 -66.51326044311185))");
+  testBingTilePolygonFunc(
+      7,
+      7,
+      3,
+      "POLYGON ((135 -79.17133464081945, 135 -85.05112877980659, 180 -85.05112877980659, 180 -79.17133464081945, 135 -79.17133464081945))");
+  testBingTilePolygonFunc(
+      15,
+      15,
+      4,
+      "POLYGON ((157.5 -82.67628497834906, 157.5 -85.05112877980659, 180 -85.05112877980659, 180 -82.67628497834906, 157.5 -82.67628497834906))");
+
+  testBingTilePolygonFunc(
+      31,
+      31,
+      5,
+      "POLYGON ((168.75 -83.97925949886206, 168.75 -85.05112877980659, 180 -85.05112877980659, 180 -83.97925949886206, 168.75 -83.97925949886206))");
+  testBingTilePolygonFunc(
+      0,
+      0,
+      1,
+      "POLYGON ((-180 85.05112877980659, -180 0, 0 0, 0 85.05112877980659, -180 85.05112877980659))");
+  testBingTilePolygonFunc(
+      1,
+      1,
+      2,
+      "POLYGON ((-90 66.51326044311186, -90 0, 0 0, 0 66.51326044311186, -90 66.51326044311186))");
+  testBingTilePolygonFunc(
+      1,
+      1,
+      23,
+      "POLYGON ((-179.99995708465576 85.05112507763845, -179.99995708465576 85.05112137546752, -179.99991416931152 85.05112137546752, -179.99991416931152 85.05112507763845, -179.99995708465576 85.05112507763845))");
+}
+
+TEST_F(GeometryFunctionsTest, testGeometryToFromGeoJson) {
+  const auto testGeometryToFromGeoJsonFunc = [&](const std::optional<
+                                                     std::string>& wkt,
+                                                 const std::optional<
+                                                     std::string>& expected =
+                                                     std::nullopt) {
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "ST_AsText(geometry_from_geojson(geometry_as_geojson(ST_GeometryFromText(c0))))",
+        wkt);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      if (expected.has_value()) {
+        ASSERT_EQ(expected.value(), result.value());
+      } else {
+        ASSERT_EQ(wkt.value(), result.value());
+      }
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  const auto testGeometryToJsonFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "geometry_as_geojson(ST_GeometryFromText(c0))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(expected.value(), result.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  const auto testGeometryFromJsonFunc =
+      [&](const std::optional<std::string>& json,
+          const std::optional<std::string>& expected) {
+        std::optional<std::string> result = evaluateOnce<std::string>(
+            "ST_AsText(geometry_from_geojson(c0))", json);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_EQ(expected.value(), result.value());
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  // empty atomic (non-multi) geometries should return null
+  testGeometryToJsonFunc("POINT EMPTY", std::nullopt);
+  testGeometryToJsonFunc("POLYGON EMPTY", std::nullopt);
+  testGeometryToJsonFunc("LINESTRING EMPTY", std::nullopt);
+
+  testGeometryToJsonFunc(std::nullopt, std::nullopt);
+
+  // empty multi geometries should return empty
+  testGeometryToFromGeoJsonFunc("MULTIPOINT EMPTY");
+  testGeometryToFromGeoJsonFunc("MULTIPOLYGON EMPTY");
+  testGeometryToFromGeoJsonFunc("MULTILINESTRING EMPTY");
+  testGeometryToFromGeoJsonFunc("GEOMETRYCOLLECTION EMPTY");
+
+  // valid nonempty geometries should return as is.
+  testGeometryToFromGeoJsonFunc("POINT (1 2)");
+  testGeometryToFromGeoJsonFunc("MULTIPOINT (1 2, 3 4)");
+  testGeometryToFromGeoJsonFunc("LINESTRING (0 0, 1 2, 3 4)");
+  testGeometryToFromGeoJsonFunc("MULTILINESTRING ((1 1, 5 1), (2 4, 4 4))");
+  testGeometryToFromGeoJsonFunc("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))");
+  testGeometryToFromGeoJsonFunc(
+      "POLYGON ((0 0, 0 3, 3 3, 3 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))");
+  testGeometryToFromGeoJsonFunc(
+      "MULTIPOLYGON (((1 1, 1 3, 3 3, 3 1, 1 1)), ((2 4, 2 6, 6 6, 6 4, 2 4)))");
+  testGeometryToFromGeoJsonFunc(
+      "GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (0 0, 1 2, 3 4), POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0)))");
+
+  // Nested geometry collections
+  testGeometryToFromGeoJsonFunc(
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (0 0, 1 2, 3 4), POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))))");
+  testGeometryToFromGeoJsonFunc(
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (0 0, 1 2, 3 4), POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0)))))");
+  testGeometryToFromGeoJsonFunc(
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION EMPTY, LINESTRING (0 0, 1 2, 3 4), POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0)))",
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (LINESTRING (0 0, 1 2, 3 4), POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))))");
+  testGeometryToFromGeoJsonFunc(
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (GEOMETRYCOLLECTION EMPTY, LINESTRING EMPTY, POLYGON EMPTY))",
+      "GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (LINESTRING EMPTY, POLYGON EMPTY)))");
+  testGeometryToFromGeoJsonFunc(
+      "GEOMETRYCOLLECTION (LINESTRING EMPTY, MULTIPOINT EMPTY)");
+  testGeometryToFromGeoJsonFunc(
+      "GEOMETRYCOLLECTION (POINT EMPTY, POINT EMPTY)");
+
+  // invalid geometries should return as is.
+  testGeometryToFromGeoJsonFunc("MULTIPOINT (0 0, 0 1, 1 1, 0 1)");
+  testGeometryToFromGeoJsonFunc("LINESTRING (0 0, 0 1, 0 1, 1 1, 1 0, 0 0)");
+  testGeometryToFromGeoJsonFunc("LINESTRING (0 0, 1 1, 1 0, 0 1)");
+
+  testGeometryFromJsonFunc(
+      "{\"type\":\"LineString\",\"coordinates\":[]}", "LINESTRING EMPTY");
+  testGeometryFromJsonFunc(
+      "{\"type\":\"MultiPoint\",\"coordinates\":[]}", "MULTIPOINT EMPTY");
+  testGeometryFromJsonFunc(
+      "{\"type\":\"MultiPolygon\",\"coordinates\":[]}", "MULTIPOLYGON EMPTY");
+  testGeometryFromJsonFunc(
+      "{\"type\":\"MultiLineString\",\"coordinates\":[[[0.0,0.0],[1,10]],[[10,10],[20,30]],[[123,123],[456,789]]]}",
+      "MULTILINESTRING ((0 0, 1 10), (10 10, 20 30), (123 123, 456 789))");
+  testGeometryFromJsonFunc(
+      "{\"type\":\"Polygon\",\"coordinates\":[]}", "POLYGON EMPTY");
+
+  testGeometryFromJsonFunc(std::nullopt, std::nullopt);
+
+  VELOX_ASSERT_USER_THROW(
+      testGeometryFromJsonFunc(
+          "{\"type\":\"MultiPoint\",\"invalidField\":[]}", std::nullopt),
+      "Error parsing JSON");
+
+  VELOX_ASSERT_USER_THROW(
+      testGeometryFromJsonFunc(
+          "{\"coordinates\":[[[0.0,0.0],[1,10]],[[10,10],[20,30]],[[123,123],[456,789]]]}",
+          std::nullopt),
+      "Error parsing JSON");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryFromJsonFunc(
+          "{\"type\":\"MultiPoint\",\"crashMe\"}", std::nullopt),
+      "Error parsing JSON");
+}
+
+TEST_F(GeometryFunctionsTest, testGreatCircleDistance) {
+  const auto testGreatCircleDistanceFunc =
+      [&](const std::optional<double>& lat1,
+          const std::optional<double>& long1,
+          const std::optional<double>& lat2,
+          const std::optional<double>& long2,
+          const std::optional<double>& expected) {
+        std::optional<double> result = evaluateOnce<double>(
+            "great_circle_distance(c0, c1, c2, c3)", lat1, long1, lat2, long2);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(result.has_value());
+          ASSERT_TRUE(std::abs(result.value() - expected.value()) < .0001);
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  testGreatCircleDistanceFunc(
+      36.12, -86.67, 33.94, -118.40, 2886.4489734366994);
+  testGreatCircleDistanceFunc(
+      33.94, -118.40, 36.12, -86.67, 2886.4489734366994);
+  testGreatCircleDistanceFunc(
+      42.3601, -71.0589, 42.4430, -71.2290, 16.734697434573437);
+  testGreatCircleDistanceFunc(36.12, -86.67, 36.12, -86.67, 0.0);
+
+  VELOX_ASSERT_USER_THROW(
+      testGreatCircleDistanceFunc(91, 20, 30, 40, std::nullopt),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: 91 and longitude: 20");
+  VELOX_ASSERT_USER_THROW(
+      testGreatCircleDistanceFunc(10, 20, 91, 40, std::nullopt),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: 91 and longitude: 40");
+  VELOX_ASSERT_USER_THROW(
+      testGreatCircleDistanceFunc(10, 181, 30, 40, std::nullopt),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: 10 and longitude: 181");
+  VELOX_ASSERT_USER_THROW(
+      testGreatCircleDistanceFunc(10, 20, 30, -181, std::nullopt),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: 30 and longitude: -181");
+  VELOX_ASSERT_USER_THROW(
+      testGreatCircleDistanceFunc(
+          std::numeric_limits<double>::infinity(), 20, 30, 40, std::nullopt),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: inf and longitude: 20");
+  VELOX_ASSERT_USER_THROW(
+      testGreatCircleDistanceFunc(
+          10, 20, 30, std::numeric_limits<double>::quiet_NaN(), std::nullopt),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: 30 and longitude: nan");
+  VELOX_ASSERT_USER_THROW(
+      testGreatCircleDistanceFunc(
+          10,
+          20,
+          30,
+          std::numeric_limits<double>::signaling_NaN(),
+          std::nullopt),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: 30 and longitude: nan");
+}
+
+TEST_F(GeometryFunctionsTest, testGeometryToBingTiles) {
+  const auto testGeometryToBingTilesFunc = [&](const std::optional<std::string>&
+                                                   wkt,
+                                               const std::optional<int32_t>
+                                                   zoom,
+                                               const std::optional<std::vector<
+                                                   std::optional<std::string>>>&
+                                                   expectedQuadKeys) {
+    std::vector<std::optional<std::string>> wktVec = {wkt};
+    auto inputWkt = makeNullableFlatVector<std::string>(wktVec);
+    std::vector<std::optional<int32_t>> zoomVec = {zoom};
+    auto inputZoom = makeNullableFlatVector<int32_t>(zoomVec);
+    auto inputVec = makeRowVector({inputWkt, inputZoom});
+
+    facebook::velox::VectorPtr output = evaluate(
+        "ARRAY_SORT(TRANSFORM(geometry_to_bing_tiles(ST_GeometryFromText(c0), c1), x -> bing_tile_quadkey(x)))",
+        inputVec);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    if (expectedQuadKeys.has_value()) {
+      ASSERT_TRUE(arrayVector != nullptr);
+      auto expected = makeNullableArrayVector<std::string>({expectedQuadKeys});
+      facebook::velox::test::assertEqualVectors(expected, output);
+    } else {
+      ASSERT_TRUE(output->isNullAt(0));
+    }
+  };
+
+  const auto assertPointInCoveringFunc = [&](const std::optional<std::string>&
+                                                 wkt,
+                                             const std::optional<double> x,
+                                             const std::optional<double> y,
+                                             const std::optional<int8_t> zoom) {
+    std::optional<bool> result = evaluateOnce<bool>(
+        "contains(geometry_to_bing_tiles(ST_GeometryFromText(c0), c1), geometry_to_bing_tiles(ST_Point(c2, c3), c1)[1])",
+        wkt,
+        zoom,
+        x,
+        y);
+    ASSERT_TRUE(result.has_value());
+    ASSERT_TRUE(result.value());
+  };
+
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kDebugBingTileChildrenMaxZoomShift, "20"}});
+
+  // Geometries at boundaries of tiles
+  testGeometryToBingTilesFunc("POINT (0 0)", 1, {{"3"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMinLongitude), 1, {{"2"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMaxLongitude), 1, {{"3"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT (0 {})", kMinBingTileLatitude), 1, {{"3"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT (0 {})", kMaxBingTileLatitude), 1, {{"1"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMinBingTileLatitude),
+      1,
+      {{"2"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMaxBingTileLatitude),
+      1,
+      {{"0"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMaxBingTileLatitude),
+      1,
+      {{"1"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMinBingTileLatitude),
+      1,
+      {{"3"}});
+  testGeometryToBingTilesFunc("LINESTRING (-1 0, -2 0)", 1, {{"2"}});
+  testGeometryToBingTilesFunc("LINESTRING (1 0, 2 0)", 1, {{"3"}});
+  testGeometryToBingTilesFunc("LINESTRING (0 -1, 0 -2)", 1, {{"3"}});
+  testGeometryToBingTilesFunc("LINESTRING (0 1, 0 2)", 1, {{"1"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("LINESTRING ({} 1, {} 2)", kMinLongitude, kMinLongitude),
+      1,
+      {{"0"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("LINESTRING ({} -1, {} -2)", kMinLongitude, kMinLongitude),
+      1,
+      {{"2"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("LINESTRING ({} 1, {} 2)", kMaxLongitude, kMaxLongitude),
+      1,
+      {{"1"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("LINESTRING ({} -1, {} -2)", kMaxLongitude, kMaxLongitude),
+      1,
+      {{"3"}});
+
+  // Make sure corners are included
+  assertPointInCoveringFunc("POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))", 6, 0, 0);
+  assertPointInCoveringFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))", 6, 0, 10);
+  assertPointInCoveringFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))", 6, 10, 10);
+  assertPointInCoveringFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))", 6, 10, 0);
+
+  // General geometries
+  testGeometryToBingTilesFunc("POINT (60 30.12)", 0, {{""}});
+  testGeometryToBingTilesFunc("POINT (60 30.12)", 10, {{"1230301230"}});
+  testGeometryToBingTilesFunc("POINT (60 30.12)", 15, {{"123030123010121"}});
+  testGeometryToBingTilesFunc("POINT (60 30.12)", 16, {{"1230301230101212"}});
+  testGeometryToBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
+      6,
+      {{"122220", "122221", "122222", "122223", "300000", "300001"}});
+  testGeometryToBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 0 0))",
+      6,
+      {{"122220", "122221", "122222", "300000"}});
+  testGeometryToBingTilesFunc(
+      "POLYGON ((10 10, -10 10, -20 -15, 10 10))", 3, {{"033", "122", "211"}});
+  testGeometryToBingTilesFunc(
+      "POLYGON ((10 10, -10 10, -20 -15, 10 10))",
+      6,
+      {{"033321",
+        "033323",
+        "033330",
+        "033331",
+        "033332",
+        "033333",
+        "122220",
+        "122221",
+        "122222",
+        "211101",
+        "211102",
+        "211103",
+        "211110",
+        "211111",
+        "211112",
+        "211120",
+        "211121"}});
+
+  testGeometryToBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12))", 10, {{"1230301230"}});
+  testGeometryToBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12))", 15, {{"123030123010121"}});
+  testGeometryToBingTilesFunc(
+      "GEOMETRYCOLLECTION (POLYGON ((10 10, -10 10, -20 -15, 10 10)))",
+      3,
+      {{"033", "122", "211"}});
+  testGeometryToBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12), POLYGON ((10 10, -10 10, -20 -15, 10 10)))",
+      3,
+      {{"033", "122", "123", "211"}});
+
+  testGeometryToBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))", 1, {{"1", "3"}});
+  testGeometryToBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 0 0))", 1, {{"1", "3"}});
+  testGeometryToBingTilesFunc(
+      "POLYGON ((10 10, 10 20, 20 20, 20 10, 10 10), (12 12, 12 14, 14 14, 14 12, 12 12))",
+      1,
+      {{"1"}});
+
+  testGeometryToBingTilesFunc("POINT (0 0)", 1, {{"3"}});
+  testGeometryToBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 0 0))", 1, {{"1", "3"}});
+
+  // Empty geometries
+  testGeometryToBingTilesFunc(
+      "POINT EMPTY", 10, common::testutil::optionalEmpty);
+  testGeometryToBingTilesFunc(
+      "POLYGON EMPTY", 10, common::testutil::optionalEmpty);
+  testGeometryToBingTilesFunc(
+      "GEOMETRYCOLLECTION EMPTY", 10, common::testutil::optionalEmpty);
+
+  // Geometries at MIN_LONGITUDE/MAX_LATITUDE
+  testGeometryToBingTilesFunc(
+      "LINESTRING (-180 -79.19245, -180 -79.17133464081945)",
+      8,
+      {{"22200000"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMinLongitude), 5, {{"20000"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT (0 {})", kMaxBingTileLatitude), 5, {{"10000"}});
+  testGeometryToBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMaxBingTileLatitude),
+      5,
+      {{"00000"}});
+
+  // Invalid inputs
+  // Longitude out of range
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToBingTilesFunc("POINT (600 30.12)", 10, std::nullopt),
+      "Longitude span for the geometry must be in [-180.00, 180.00] range");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToBingTilesFunc(
+          "POLYGON ((1000 10, -10 10, -20 -15, 1000 10))", 10, std::nullopt),
+      "Longitude span for the geometry must be in [-180.00, 180.00] range");
+  // Latitude out of range
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToBingTilesFunc("POINT (60 300.12)", 10, std::nullopt),
+      "Latitude span for the geometry must be in [-85.05, 85.05] range");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToBingTilesFunc(
+          "POLYGON ((10 1000, -10 10, -20 -15, 10 1000))", 10, std::nullopt),
+      "Latitude span for the geometry must be in [-85.05, 85.05] range");
+  // Invalid zoom
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToBingTilesFunc("POINT (60 30.12)", -1, std::nullopt),
+      "Zoom level must be between 0 and 23");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToBingTilesFunc("POINT (60 30.12)", 24, std::nullopt),
+      "Zoom level must be between 0 and 23");
+  // Input rectangle too large
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<int64_t>(
+          "geometry_to_bing_tiles(ST_Envelope(ST_GeometryFromText(c0)), c1)[1]",
+          std::optional<std::string>("LINESTRING (0 0, 80 80)"),
+          std::optional<int32_t>(16)),
+      "The zoom level is too high or the geometry is too large to compute a set of covering Bing tiles. Please use a lower zoom level, or tile only a section of the geometry.");
+  ASSERT_EQ(
+      112,
+      evaluateOnce<int64_t>(
+          "cardinality(geometry_to_bing_tiles(ST_Envelope(ST_GeometryFromText(c0)), c1))",
+          std::optional<std::string>("LINESTRING (0 0, 80 80)"),
+          std::optional<int32_t>(5)));
+
+  ASSERT_EQ(
+      9043,
+      evaluateOnce<int64_t>(
+          "cardinality(geometry_to_bing_tiles(ST_GeometryFromText(c0), c1))",
+          std::optional<std::string>(largeWkt),
+          std::optional<int32_t>(16)));
+  ASSERT_EQ(
+      19939,
+      evaluateOnce<int64_t>(
+          "cardinality(geometry_to_bing_tiles(ST_Envelope(ST_GeometryFromText(c0)), c1))",
+          std::optional<std::string>(largeWkt),
+          std::optional<int32_t>(16)));
+
+  // Zoom level is too high
+  VELOX_ASSERT_USER_THROW(
+      evaluateOnce<int64_t>(
+          "cardinality(geometry_to_bing_tiles(ST_GeometryFromText(c0), c1))",
+          std::optional<std::string>("POLYGON ((0 0, 0 20, 20 20, 0 0))"),
+          std::optional<int32_t>(20)),
+      "The zoom level is too high or the geometry is too large to compute a set of covering Bing tiles. Please use a lower zoom level, or tile only a section of the geometry.");
+  ASSERT_EQ(
+      428788,
+      evaluateOnce<int64_t>(
+          "cardinality(geometry_to_bing_tiles(ST_GeometryFromText(c0), c1))",
+          std::optional<std::string>("POLYGON ((0 0, 0 20, 20 20, 0 0))"),
+          std::optional<int32_t>(14)));
+}
+
+TEST_F(GeometryFunctionsTest, testGeometryToDissolvedBingTiles) {
+  const auto testGeometryToDissolvedBingTilesFunc = [&](const std::optional<
+                                                            std::string>& wkt,
+                                                        const std::optional<
+                                                            int32_t> zoom,
+                                                        const std::optional<
+                                                            std::vector<
+                                                                std::optional<
+                                                                    std::
+                                                                        string>>>&
+                                                            expectedQuadKeys) {
+    std::vector<std::optional<std::string>> wktVec = {wkt};
+    auto inputWkt = makeNullableFlatVector<std::string>(wktVec);
+    std::vector<std::optional<int32_t>> zoomVec = {zoom};
+    auto inputZoom = makeNullableFlatVector<int32_t>(zoomVec);
+    auto inputVec = makeRowVector({inputWkt, inputZoom});
+
+    facebook::velox::VectorPtr output = evaluate(
+        "ARRAY_SORT(TRANSFORM(geometry_to_dissolved_bing_tiles(ST_GeometryFromText(c0), c1), x -> bing_tile_quadkey(x)))",
+        inputVec);
+
+    auto arrayVector =
+        std::dynamic_pointer_cast<facebook::velox::ArrayVector>(output);
+
+    if (expectedQuadKeys.has_value()) {
+      ASSERT_TRUE(arrayVector != nullptr);
+      auto expected = makeNullableArrayVector<std::string>({expectedQuadKeys});
+      facebook::velox::test::assertEqualVectors(expected, output);
+    } else {
+      ASSERT_TRUE(output->isNullAt(0));
+    }
+  };
+
+  // Empty geometries
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT EMPTY", 0, common::testutil::optionalEmpty);
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT EMPTY", 10, common::testutil::optionalEmpty);
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT EMPTY", 23, common::testutil::optionalEmpty);
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON EMPTY", 10, common::testutil::optionalEmpty);
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION EMPTY", 10, common::testutil::optionalEmpty);
+
+  // Geometries at tile borders
+  testGeometryToDissolvedBingTilesFunc("POINT (0 0)", 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMinLongitude), 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMaxLongitude), 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT (0 {})", kMinBingTileLatitude), 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT (0 {})", kMaxBingTileLatitude), 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMinBingTileLatitude),
+      0,
+      {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMaxBingTileLatitude),
+      0,
+      {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMaxBingTileLatitude),
+      0,
+      {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMinBingTileLatitude),
+      0,
+      {{""}});
+  testGeometryToDissolvedBingTilesFunc("POINT (0 0)", 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMinLongitude), 1, {{"2"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} 0)", kMaxLongitude), 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT (0 {})", kMinBingTileLatitude), 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT (0 {})", kMaxBingTileLatitude), 1, {{"1"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMinBingTileLatitude),
+      1,
+      {{"2"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMinLongitude, kMaxBingTileLatitude),
+      1,
+      {{"0"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMaxBingTileLatitude),
+      1,
+      {{"1"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("POINT ({} {})", kMaxLongitude, kMinBingTileLatitude),
+      1,
+      {{"3"}});
+  testGeometryToDissolvedBingTilesFunc("LINESTRING (-1 0, -2 0)", 1, {{"2"}});
+  testGeometryToDissolvedBingTilesFunc("LINESTRING (1 0, 2 0)", 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc("LINESTRING (0 -1, 0 -2)", 1, {{"3"}});
+  testGeometryToDissolvedBingTilesFunc("LINESTRING (0 1, 0 2)", 1, {{"1"}});
+
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("LINESTRING ({} 1, {} 2)", kMinLongitude, kMinLongitude),
+      1,
+      {{"0"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("LINESTRING ({} -1, {} -2)", kMinLongitude, kMinLongitude),
+      1,
+      {{"2"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("LINESTRING ({} 1, {} 2)", kMaxLongitude, kMaxLongitude),
+      1,
+      {{"1"}});
+  testGeometryToDissolvedBingTilesFunc(
+      fmt::format("LINESTRING ({} -1, {} -2)", kMaxLongitude, kMaxLongitude),
+      1,
+      {{"3"}});
+
+  // General Geometries
+  testGeometryToDissolvedBingTilesFunc("POINT (60 30.12)", 0, {{""}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT (60 30.12)", 10, {{"1230301230"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT (60 30.12)", 15, {{"123030123010121"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POINT (60 30.12)", 16, {{"1230301230101212"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))",
+      6,
+      {{"12222", "300000", "300001"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 0 0))",
+      6,
+      {{"122220", "122221", "122222", "300000"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON ((10 10, -10 10, -20 -15, 10 10))", 3, {{"033", "122", "211"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "POLYGON ((10 10, -10 10, -20 -15, 10 10))",
+      6,
+      {{"033321",
+        "033323",
+        "03333",
+        "122220",
+        "122221",
+        "122222",
+        "211101",
+        "211102",
+        "211103",
+        "211110",
+        "211111",
+        "211112",
+        "211120",
+        "211121"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12))", 10, {{"1230301230"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12))", 15, {{"123030123010121"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POLYGON ((10 10, -10 10, -20 -15, 10 10)))",
+      3,
+      {{"033", "122", "211"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (60 30.12), POLYGON ((10 10, -10 10, -20 -15, 10 10)))",
+      3,
+      {{"033", "122", "123", "211"}});
+  testGeometryToDissolvedBingTilesFunc(
+      "GEOMETRYCOLLECTION (POINT (0.1 0.1), POINT(0.1 -0.1), POINT(-0.1 -0.1), POINT(-0.1 0.1))",
+      3,
+      {{"033", "122", "211", "300"}});
+
+  ASSERT_EQ(
+      2320,
+      evaluateOnce<int64_t>(
+          "cardinality(geometry_to_dissolved_bing_tiles(ST_GeometryFromText(c0), c1))",
+          std::optional<std::string>("POLYGON ((0 0, 0 20, 20 20, 0 0))"),
+          std::optional<int32_t>(14)));
+
+  // Invalid inputs
+  // Longitude out of range
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POINT (600 30.12)", 10, std::nullopt),
+      "Longitude span for the geometry must be in [-180.00, 180.00] range");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POLYGON ((1000 10, -10 10, -20 -15, 1000 10))", 10, std::nullopt),
+      "Longitude span for the geometry must be in [-180.00, 180.00] range");
+  // Latitude out of range
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POINT (60 300.12)", 10, std::nullopt),
+      "Latitude span for the geometry must be in [-85.05, 85.05] range");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POLYGON ((10 1000, -10 10, -20 -15, 10 1000))", 10, std::nullopt),
+      "Latitude span for the geometry must be in [-85.05, 85.05] range");
+  // Invalid zoom
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POINT (60 30.12)", -1, std::nullopt),
+      "Zoom level must be between 0 and 23");
+  VELOX_ASSERT_USER_THROW(
+      testGeometryToDissolvedBingTilesFunc(
+          "POINT (60 30.12)", 24, std::nullopt),
+      "Zoom level must be between 0 and 23");
+}
+
+TEST_F(GeometryFunctionsTest, testGeometryUnion) {
+  const auto testGeometryUnionFunc = [&](const std::optional<std::vector<
+                                             std::optional<std::string>>>& wkts,
+                                         const std::optional<std::string>&
+                                             expected) {
+    auto arrayVec = makeNullableArrayVector<std::string>({{wkts}});
+    auto input = makeRowVector(
+        {arrayVec, makeNullableFlatVector<std::string>({expected})});
+    std::optional<bool> result = evaluateOnce<bool>(
+        "ST_Equals(GEOMETRY_UNION(transform(c0, x -> ST_GEOMETRYFROMTEXT(x))), ST_GeometryFromText(c1))",
+        input);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_TRUE(result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  testGeometryUnionFunc({{"POINT EMPTY", "POINT (1 1)"}}, "POINT (1 1)");
+  testGeometryUnionFunc({{"POINT (1 1)", "POINT (1 1)"}}, "POINT (1 1)");
+  testGeometryUnionFunc({{"POINT (1 1)"}}, "POINT (1 1)");
+  testGeometryUnionFunc(
+      {{"POINT (1 2)", "POINT (3 4)"}}, "MULTIPOINT (1 2, 3 4)");
+
+  testGeometryUnionFunc({{"LINESTRING (0 0, 1 1)"}}, "LINESTRING (0 0, 1 1)");
+
+  testGeometryUnionFunc({{"POINT EMPTY", "LINESTRING EMPTY"}}, "POLYGON EMPTY");
+
+  testGeometryUnionFunc(
+      {{"POINT EMPTY", "POLYGON EMPTY", "MULTIPOINT EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION ( POLYGON ((2 2, 3 1, 1 1, 2 2)), POLYGON ((3 2, 4 1, 2 1, 3 2)) )",
+        "GEOMETRYCOLLECTION ( POLYGON ((4 2, 5 1, 3 1, 4 2)) )"}},
+      "POLYGON ((2.5 1.5, 3 2, 3.5 1.5, 4 2, 5 1, 4 1, 3 1, 2 1, 1 1, 2 2, 2.5 1.5))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "POINT (5 2)"}},
+      "GEOMETRYCOLLECTION (POINT (5 2), POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1)))");
+
+  // Point test cases
+  testGeometryUnionFunc(
+      {{"POINT (1 2)", "POINT (1 2)", "POINT (1 2)"}}, "POINT (1 2)");
+
+  testGeometryUnionFunc({{"POINT EMPTY", "POINT (1 2)"}}, "POINT (1 2)");
+
+  testGeometryUnionFunc(
+      {{"POINT (1 2)", "POINT (3 4)"}}, "MULTIPOINT (1 2, 3 4)");
+
+  // Linestring test cases
+  testGeometryUnionFunc(
+      {{"LINESTRING (1 1, 2 2)",
+        "LINESTRING (1 1, 2 2)",
+        "LINESTRING (1 1, 2 2)"}},
+      "LINESTRING (1 1, 2 2)");
+
+  testGeometryUnionFunc(
+      {{"LINESTRING EMPTY", "LINESTRING (1 1, 2 2)"}}, "LINESTRING (1 1, 2 2)");
+
+  testGeometryUnionFunc(
+      {{"LINESTRING (1 1, 2 2, 3 3)", "LINESTRING (2 2, 3 3, 4 4)"}},
+      "LINESTRING (1 1, 2 2, 3 3, 4 4)");
+
+  testGeometryUnionFunc(
+      {{"LINESTRING (1 1, 2 2, 3 3)", "LINESTRING (1 2, 2 3, 3 4)"}},
+      "MULTILINESTRING ((1 1, 2 2, 3 3), (1 2, 2 3, 3 4))");
+
+  testGeometryUnionFunc(
+      {{"LINESTRING (1 1, 3 3)",
+        "LINESTRING (3 1, 2 2)",
+        "LINESTRING (2 2, 3 3)",
+        "LINESTRING (2 2, 1 3)"}},
+      "MULTILINESTRING ((1 1, 2 2, 3 3), (3 1, 1 3))");
+
+  // Polygon test cases
+  testGeometryUnionFunc(
+      {{"POLYGON ((2 2, 1 1, 3 1, 2 2))",
+        "POLYGON ((2 2, 1 1, 3 1, 2 2))",
+        "POLYGON ((2 2, 1 1, 3 1, 2 2))"}},
+      "POLYGON ((2 2, 1 1, 3 1, 2 2))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON EMPTY)", "POLYGON ((2 2, 1 1, 3 1, 2 2))"}},
+      "POLYGON ((2 2, 1 1, 3 1, 2 2))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((2 2, 3 1, 1 1, 2 2))",
+        "POLYGON ((3 2, 4 1, 2 1, 3 2))",
+        "POLYGON ((4 2, 5 1, 3 1, 4 2))"}},
+      "POLYGON ((1 1, 2 1, 3 1, 4 1, 5 1, 4 2, 3.5 1.5, 3 2, 2.5 1.5, 2 2, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((2 2, 3 1, 1 1, 2 2))", "POLYGON ((4 2, 5 1, 3 1, 4 2))"}},
+      "MULTIPOLYGON (((1 1, 3 1, 2 2, 1 1)), ((3 1, 5 1, 4 2, 3 1)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((2 2, 3 1, 1 1, 2 2))", "POLYGON ((5 2, 6 1, 4 1, 5 2))"}},
+      "MULTIPOLYGON (((1 1, 3 1, 2 2, 1 1)), ((4 1, 6 1, 5 2, 4 1)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+        "POLYGON ((3 3, 4 3, 4 4, 3 4, 3 3))"}},
+      "POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+        "POLYGON ((2 2, 5 2, 5 5, 2 5, 2 2))"}},
+      "POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+        "POLYGON ((3.25 3.25, 3.75 3.25, 3.75 3.75, 3.25 3.75, 3.25 3.25))"}},
+      "MULTIPOLYGON (((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3)), ((3.25 3.25, 3.75 3.25, 3.75 3.75, 3.25 3.75, 3.25 3.25)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1), (3 3, 4 3, 4 4, 3 4, 3 3))",
+        "POLYGON ((3 3, 3 3.5, 3.5 3.5, 3.5 3, 3 3))",
+        "POLYGON ((3.5 3.5, 3.5 4, 4 4, 4 3.5, 3.5 3.5))",
+        "POLYGON ((3 3.5, 3 4, 3.5 4, 3.5 3.5, 3 3.5))",
+        "POLYGON ((3.5 3, 3.5 3.5, 4 3.5, 4 3, 3.5 3))"}},
+      "POLYGON ((1 1, 6 1, 6 6, 1 6, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 3, 1 4, 6 4, 6 3, 1 3))",
+        "POLYGON ((3 1, 4 1, 4 6, 3 6, 3 1))"}},
+      "POLYGON ((3 1, 4 1, 4 3, 6 3, 6 4, 4 4, 4 6, 3 6, 3 4, 1 4, 1 3, 3 3, 3 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 3, 1 4, 3 4, 3 3, 1 3))",
+        "POLYGON ((3 3, 3 4, 4 4, 4 3, 3 3))",
+        "POLYGON ((4 3, 4 4, 6 4, 6 3, 4 3))",
+        "POLYGON ((3 1, 4 1, 4 3, 3 3, 3 1))",
+        "POLYGON ((3 4, 3 6, 4 6, 4 4, 3 4))"}},
+      "POLYGON ((3 1, 4 1, 4 3, 6 3, 6 4, 4 4, 4 6, 3 6, 3 4, 1 4, 1 3, 3 3, 3 1))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "POINT (3 2)"}},
+      "POLYGON ((1 1, 3 1, 3 2, 3 3, 1 3, 1 1))");
+
+  // Multipoint test cases
+  testGeometryUnionFunc(
+      {{"MULTIPOINT ((1 2), (2 4), (3 6), (4 8))",
+        "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))",
+        "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))"}},
+      "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOINT EMPTY", "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))"}},
+      "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOINT ((1 2), (2 4))", "MULTIPOINT ((3 6), (4 8))"}},
+      "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOINT ((1 2), (2 4))",
+        "MULTIPOINT ((2 4), (3 6))",
+        "MULTIPOINT ((3 6), (4 8))"}},
+      "MULTIPOINT ((1 2), (2 4), (3 6), (4 8))");
+
+  // Multilinestring test cases
+  testGeometryUnionFunc(
+      {{"MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))",
+        "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))",
+        "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))"}},
+      "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))");
+
+  testGeometryUnionFunc(
+      {{"MULTILINESTRING EMPTY", "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))"}},
+      "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1))");
+
+  testGeometryUnionFunc(
+      {{"MULTILINESTRING ((1 5, 4 1), (3 5, 6 1))",
+        "MULTILINESTRING ((2 5, 5 1), (4 5, 7 1))"}},
+      "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1), (3 5, 6 1), (4 5, 7 1))");
+
+  testGeometryUnionFunc(
+      {{"MULTILINESTRING ((1 5, 4 1), (3 5, 6 1))",
+        "MULTILINESTRING ((2 5, 5 1), (4 5, 7 1))",
+        "LINESTRING (1 3, 8 3)"}},
+      "MULTILINESTRING ((1 5, 4 1), (2 5, 5 1), (3 5, 6 1), (4 5, 7 1), (1 3, 8 3))");
+
+  // Multipolygon test cases
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON(((4 2, 5 1, 3 1, 4 2)), ((14 12, 15 11, 13 11, 14 12)))",
+        "MULTIPOLYGON(((4 2, 5 1, 3 1, 4 2)), ((14 12, 15 11, 13 11, 14 12)))"}},
+      "MULTIPOLYGON (((4 2, 3 1, 5 1, 4 2)), ((14 12, 13 11, 15 11, 14 12)))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON EMPTY",
+        "MULTIPOLYGON (((4 2, 5 1, 3 1, 4 2)), ((14 12, 15 11, 13 11, 14 12)))"}},
+      "MULTIPOLYGON (((4 2, 3 1, 5 1, 4 2)), ((14 12, 13 11, 15 11, 14 12)))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON ((( 0 0, 0 2, 2 2, 2 0, 0 0 )), (( 0 3, 0 5, 2 5, 2 3, 0 3 )))",
+        "MULTIPOLYGON ((( 3 0, 3 2, 5 2, 5 0, 3 0 )), (( 3 3, 3 5, 5 5, 5 3, 3 3 )))"}},
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)), ((0 3, 2 3, 2 5, 0 5, 0 3)), ((3 3, 5 3, 5 5, 3 5, 3 3)))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON (((2 2, 3 1, 1 1, 2 2)), ((3 2, 4 1, 2 1, 3 2)))",
+        "MULTIPOLYGON(((4 2, 5 1, 3 1, 4 2)))"}},
+      "POLYGON ((1 1, 2 1, 3 1, 4 1, 5 1, 4 2, 3.5 1.5, 3 2, 2.5 1.5, 2 2, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON (((1 3, 1 4, 3 4, 3 3, 1 3)), ((3 3, 3 4, 4 4, 4 3, 3 3)), ((4 3, 4 4, 6 4, 6 3, 4 3)))",
+        "MULTIPOLYGON (((3 1, 4 1, 4 3, 3 3, 3 1)), ((3 4, 3 6, 4 6, 4 4, 3 4)))"}},
+      "POLYGON ((3 1, 4 1, 4 3, 6 3, 6 4, 4 4, 4 6, 3 6, 3 4, 1 4, 1 3, 3 3, 3 1))");
+
+  // GeometryCollection test cases
+  testGeometryUnionFunc(
+      {{"MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)))",
+        "GEOMETRYCOLLECTION ( POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((3 0, 5 0, 5 2, 3 2, 3 0)))",
+        "GEOMETRYCOLLECTION ( POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((3 0, 5 0, 5 2, 3 2, 3 0)))"}},
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)))");
+
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION EMPTY", "GEOMETRYCOLLECTION EMPTY"}},
+      "GEOMETRYCOLLECTION EMPTY");
+
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION EMPTY",
+        "GEOMETRYCOLLECTION ( POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0)), POLYGON ((3 0, 5 0, 5 2, 3 2, 3 0)))"}},
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)))");
+
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION ( POLYGON ((2 2, 3 1, 1 1, 2 2)), POLYGON ((3 2, 4 1, 2 1, 3 2)) )",
+        "GEOMETRYCOLLECTION ( POLYGON ((4 2, 5 1, 3 1, 4 2)) )"}},
+      "POLYGON ((1 1, 2 1, 3 1, 4 1, 5 1, 4 2, 3.5 1.5, 3 2, 2.5 1.5, 2 2, 1 1))");
+
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION ( POLYGON (( 0 0, 0 2, 2 2, 2 0, 0 0 )), POLYGON (( 0 3, 0 5, 2 5, 2 3, 0 3 )) )",
+        "GEOMETRYCOLLECTION ( POLYGON (( 3 0, 3 2, 5 2, 5 0, 3 0 )), POLYGON (( 3 3, 3 5, 5 5, 5 3, 3 3 )) )"}},
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((3 0, 5 0, 5 2, 3 2, 3 0)), ((0 3, 2 3, 2 5, 0 5, 0 3)), ((3 3, 5 3, 5 5, 3 5, 3 3)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "LINESTRING (0 2, 5 2)"}},
+      "GEOMETRYCOLLECTION (MULTILINESTRING ((0 2, 1 2), (3 2, 5 2)), POLYGON ((1 1, 3 1, 3 2, 3 3, 1 3, 1 2, 1 1)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "LINESTRING (0 5, 5 5)"}},
+      "GEOMETRYCOLLECTION (LINESTRING (0 5, 5 5), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)))");
+
+  testGeometryUnionFunc(
+      {{"POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1))", "POINT (5 2)"}},
+      "GEOMETRYCOLLECTION (POINT (5 2), POLYGON ((1 1, 3 1, 3 3, 1 3, 1 1)))");
+
+  testGeometryUnionFunc({{"POINT EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"MULTIPOINT EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"POLYGON EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"MULTIPOLYGON EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"LINESTRING EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"MULTILINESTRING EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc({{"GEOMETRYCOLLECTION EMPTY"}}, "POLYGON EMPTY");
+  testGeometryUnionFunc(
+      {{"GEOMETRYCOLLECTION EMPTY",
+        "MULTILINESTRING EMPTY",
+        "LINESTRING EMPTY",
+        "MULTIPOLYGON EMPTY",
+        "POLYGON EMPTY",
+        "MULTIPOINT EMPTY",
+        "POINT EMPTY"}},
+      "POLYGON EMPTY");
+
+  // Empty array should return null
+  testGeometryUnionFunc(common::testutil::optionalEmpty, std::nullopt);
+
+  // Null elements in input array should be ignored
+  testGeometryUnionFunc({{std::nullopt, "POINT (1 2)"}}, "POINT (1 2)");
+}
+
+TEST_F(GeometryFunctionsTest, testStLineFromText) {
+  const auto testStLineFromTextFunc =
+      [&](const std::optional<std::string>& wkt) {
+        auto res =
+            evaluateOnce<std::string>("ST_AsText(ST_LineFromText(c0))", wkt);
+
+        if (wkt.has_value()) {
+          ASSERT_TRUE(res.has_value());
+          ASSERT_EQ(wkt.value(), res.value());
+        } else {
+          ASSERT_FALSE(res.has_value());
+        }
+      };
+
+  testStLineFromTextFunc("LINESTRING EMPTY");
+  testStLineFromTextFunc("LINESTRING (1 1, 2 2, 1 3)");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("xyz"),
+      "Failed to parse WKT: ParseException: Unknown type: 'XYZ'");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("MULTILINESTRING EMPTY"),
+      "ST_LineFromText only applies to LineString. Input type is: MultiLineString");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("POLYGON ((1 1, 1 4, 4 4, 4 1, 1 1))"),
+      "ST_LineFromText only applies to LineString. Input type is: Polygon");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("LINESTRING (0 0)"),
+      "Failed to parse WKT: IllegalArgumentException: point array must contain 0 or >1 elements");
+  VELOX_ASSERT_USER_THROW(
+      testStLineFromTextFunc("LINESTRING (0 0, 1)"),
+      "Failed to parse WKT: ParseException: Expected number but encountered ')'");
+  testStLineFromTextFunc(std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testStLineString) {
+  const auto testStLineStringFunc = [&](const std::optional<std::vector<
+                                            std::optional<std::string>>>& wkts,
+                                        const std::optional<std::string>&
+                                            expected) {
+    auto arrayVec = makeNullableArrayVector<std::string>({{wkts}});
+    auto input = makeRowVector({arrayVec});
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "St_AsText(ST_LineString(transform(c0, x -> ST_GEOMETRYFROMTEXT(x))))",
+        input);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(expected.value(), result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Happy cases
+  testStLineStringFunc(
+      {{"POINT (1 2)", "POINT (3 4)"}}, "LINESTRING (1 2, 3 4)");
+  testStLineStringFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (5 6)"}},
+      "LINESTRING (1 2, 3 4, 5 6)");
+  testStLineStringFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (5 6)", "POINT (7 8)"}},
+      "LINESTRING (1 2, 3 4, 5 6, 7 8)");
+
+  // < 2 Points returns empty
+  testStLineStringFunc({{"POINT (1 2)"}}, "LINESTRING EMPTY");
+  testStLineStringFunc(common::testutil::optionalEmpty, "LINESTRING EMPTY");
+  // Duplicate consecutive points throws exception
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{"POINT (1 2)", "POINT (1 2)"}}, std::nullopt),
+      "Repeated point sequence in ST_LineString: point 1,2 at index 1.");
+  // Only points can be passed
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          {{"POLYGON ((1 2, 3 4, 5 6, 1 2))", "POINT (1 2)"}}, std::nullopt),
+      "Non-point geometry in ST_LineString input at index 0.");
+  // Empty points are invalid
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{"POINT (1 2)", "POINT EMPTY"}}, std::nullopt),
+      "Empty point in ST_LineString input at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          {{"POINT (1 2)", "POINT EMPTY", "POINT (1 2)"}}, std::nullopt),
+      "Empty point in ST_LineString input at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          {{"POINT (1 2)", "POINT EMPTY", "POINT (1 2)", "POINT EMPTY"}},
+          std::nullopt),
+      "Empty point in ST_LineString input at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{"POINT EMPTY"}}, std::nullopt),
+      "Empty point in ST_LineString input at index 0.");
+
+  // Null elements in array are invalid
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{"POINT (1 2)", std::nullopt}}, std::nullopt),
+      "Invalid input to ST_LineString: input array contains null at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc({{std::nullopt, "POINT (1 2)"}}, std::nullopt),
+      "Invalid input to ST_LineString: input array contains null at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          std::vector<std::optional<std::string>>{std::nullopt}, std::nullopt),
+      "Invalid input to ST_LineString: input array contains null at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStLineStringFunc(
+          std::vector<std::optional<std::string>>{std::nullopt, std::nullopt},
+          std::nullopt),
+      "Invalid input to ST_LineString: input array contains null at index 0.");
+}
+
+TEST_F(GeometryFunctionsTest, testStMultiPoint) {
+  const auto testStMultiPointFunc = [&](const std::optional<std::vector<
+                                            std::optional<std::string>>>& wkts,
+                                        const std::optional<std::string>&
+                                            expected) {
+    auto arrayVec = makeNullableArrayVector<std::string>({{wkts}});
+    auto input = makeRowVector({arrayVec});
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "St_AsText(ST_MultiPoint(transform(c0, x -> ST_GEOMETRYFROMTEXT(x))))",
+        input);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(expected.value(), result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Happy cases
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (3 4)"}}, "MULTIPOINT (1 2, 3 4)");
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (5 6)"}},
+      "MULTIPOINT (1 2, 3 4, 5 6)");
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (5 6)", "POINT (7 8)"}},
+      "MULTIPOINT (1 2, 3 4, 5 6, 7 8)");
+
+  // Duplicate points work
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (1 2)"}}, "MULTIPOINT (1 2, 1 2)");
+  testStMultiPointFunc(
+      {{"POINT (1 2)", "POINT (3 4)", "POINT (1 2)"}},
+      "MULTIPOINT (1 2, 3 4, 1 2)");
+
+  // Single point
+  testStMultiPointFunc({{"POINT (1 2)"}}, "MULTIPOINT (1 2)");
+
+  // Empty array
+  testStMultiPointFunc(common::testutil::optionalEmpty, std::nullopt);
+
+  // Only points can be passed
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc(
+          {{"POINT (7 8)", "LINESTRING (1 2, 3 4)"}}, std::nullopt),
+      "Non-point geometry in ST_MultiPoint input at index 1.");
+
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc(
+          {{"POINT (7 8)", "MULTIPOINT ((1 2), (3 4))"}}, std::nullopt),
+      "Non-point geometry in ST_MultiPoint input at index 1.");
+
+  // Null elements in array are invalid
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc({{"POINT (1 2)", std::nullopt}}, std::nullopt),
+      "Invalid input to ST_MultiPoint: input array contains null at index 1.");
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc({{std::nullopt, "POINT (1 2)"}}, std::nullopt),
+      "Invalid input to ST_MultiPoint: input array contains null at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc(
+          std::vector<std::optional<std::string>>{std::nullopt}, std::nullopt),
+      "Invalid input to ST_MultiPoint: input array contains null at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc(
+          std::vector<std::optional<std::string>>{std::nullopt, std::nullopt},
+          std::nullopt),
+      "Invalid input to ST_MultiPoint: input array contains null at index 0.");
+
+  // Empty elements in array are invalid
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc({{"POINT EMPTY"}}, std::nullopt),
+      "Empty point in ST_MultiPoint input at index 0.");
+  VELOX_ASSERT_USER_THROW(
+      testStMultiPointFunc({{"POINT (1 2)", "POINT EMPTY"}}, std::nullopt),
+      "Empty point in ST_MultiPoint input at index 1.");
+}
+
+TEST_F(GeometryFunctionsTest, testToFromSphericalGeography) {
+  const auto testToFromSphericalGeographyFunc = [&](const std::optional<
+                                                    std::string>& wkt) {
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "ST_AsText(to_geometry(to_spherical_geography(ST_GeometryFromText(c0))))",
+        wkt);
+
+    if (wkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(wkt.value(), result.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Happy cases
+  testToFromSphericalGeographyFunc("POINT EMPTY");
+  testToFromSphericalGeographyFunc("MULTIPOINT EMPTY");
+  testToFromSphericalGeographyFunc("POLYGON EMPTY");
+  testToFromSphericalGeographyFunc("MULTIPOLYGON EMPTY");
+  testToFromSphericalGeographyFunc("LINESTRING EMPTY");
+  testToFromSphericalGeographyFunc("MULTILINESTRING EMPTY");
+  testToFromSphericalGeographyFunc("GEOMETRYCOLLECTION EMPTY");
+
+  testToFromSphericalGeographyFunc("POINT (180 90)");
+  testToFromSphericalGeographyFunc("POINT (-180 -90)");
+  testToFromSphericalGeographyFunc("POINT (1 2)");
+  testToFromSphericalGeographyFunc("MULTIPOINT (1 2, 3 4, 5 6, 7 8)");
+  testToFromSphericalGeographyFunc("POLYGON ((1 3, 1 4, 3 4, 3 3, 1 3))");
+  testToFromSphericalGeographyFunc(
+      "MULTIPOLYGON (((0 0, 0 2, 2 2, 2 0, 0 0)), ((3 0, 3 2, 5 2, 5 0, 3 0)), ((0 3, 0 5, 2 5, 2 3, 0 3)), ((3 3, 3 5, 5 5, 5 3, 3 3)))");
+  testToFromSphericalGeographyFunc(
+      "GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), GEOMETRYCOLLECTION (POLYGON ((2 2, 2 3, 3 3, 3 2, 2 2)))))");
+
+  // Error cases
+  VELOX_ASSERT_USER_THROW(
+      testToFromSphericalGeographyFunc("POINT (200 200)"),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: 200 and longitude: 200");
+  VELOX_ASSERT_USER_THROW(
+      testToFromSphericalGeographyFunc(
+          "GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION (LINESTRING (0 0, 1 1), GEOMETRYCOLLECTION (POLYGON ((2 2, 2 -300, 3 3, 3 2, 2 2)))))"),
+      "Latitude must be in range [-90, 90] and longitude must be in range [-180, 180]. Got latitude: -300 and longitude: 0");
+}
+
+TEST_F(GeometryFunctionsTest, testStSphericalCentroid) {
+  const auto testStSphericalCentroidFunction = [&](const std::optional<
+                                                       std::string>& wkt,
+                                                   const std::optional<
+                                                       std::string>&
+                                                       expectedWkt) {
+    std::optional<std::string> result = evaluateOnce<std::string>(
+        "st_astext(to_geometry(st_centroid(to_spherical_geography(ST_GeometryFromText(c0)))))",
+        wkt);
+
+    if (expectedWkt.has_value()) {
+      ASSERT_TRUE(result.has_value());
+      ASSERT_EQ(result.value(), expectedWkt.value());
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Empty geometries return null. Note that functions that return empty
+  // geometries might choose any type, so we should cover all types.
+  testStSphericalCentroidFunction("POINT EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("MULTIPOINT EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("LINESTRING EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("MULTILINESTRING EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("POLYGON EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("MULTIPOLYGON EMPTY", std::nullopt);
+  testStSphericalCentroidFunction("GEOMETRYCOLLECTION EMPTY", std::nullopt);
+
+  // Single point returns same point
+  testStSphericalCentroidFunction("POINT (3 5)", "POINT (3 5)");
+
+  // Single point in multipoint returns same point
+  testStSphericalCentroidFunction("MULTIPOINT (3 5)", "POINT (3 5)");
+
+  // Two points on opposite sides of equator at same longitude
+  testStSphericalCentroidFunction("MULTIPOINT (0 -45, 0 45)", "POINT (0 0)");
+
+  // Two points on equator at opposite longitudes
+  testStSphericalCentroidFunction("MULTIPOINT (45 0, -45 0)", "POINT (0 0)");
+
+  // Two antipodal points on the equator (0, 0) and (-180, 0)
+  // The result is arbitrary but GEOS calculates it as (-90 45)
+  testStSphericalCentroidFunction("MULTIPOINT (0 0, -180 0)", "POINT (-90 45)");
+
+  // Three points - the Java test expects (12.36780515862267, 0)
+  // We'll check with some tolerance
+  auto result = evaluateOnce<std::string>(
+      "st_astext(to_geometry(st_centroid(to_spherical_geography(ST_GeometryFromText(c0)))))",
+      std::optional<std::string>("MULTIPOINT (0 -45, 0 45, 30 0)"));
+  ASSERT_TRUE(result.has_value());
+
+  // Parse the result to check longitude is approximately 12.3678
+  std::string resultStr = result.value();
+  ASSERT_TRUE(resultStr.find("POINT (12.3678") != std::string::npos);
+
+  // Four symmetric points should give centroid at (0, 0)
+  testStSphericalCentroidFunction(
+      "MULTIPOINT (0 -45, 0 45, 30 0, -30 0)", "POINT (0 0)");
+
+  // Non-point/multipoint geometries should throw
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalCentroidFunction("LINESTRING (0 0, 1 1)", std::nullopt),
+      "ST_Centroid[SphericalGeography] only applies to Point or MultiPoint. Input type is: LineString");
+
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalCentroidFunction(
+          "POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))", std::nullopt),
+      "ST_Centroid[SphericalGeography] only applies to Point or MultiPoint. Input type is: Polygon");
+}
+TEST_F(GeometryFunctionsTest, testStSphericalDistance) {
+  const auto testStSphericalDistanceFunc = [&](const std::optional<std::string>&
+                                                   leftWkt,
+                                               const std::optional<std::string>&
+                                                   rightWkt,
+                                               const std::optional<double>&
+                                                   expected) {
+    std::optional<double> result = evaluateOnce<double>(
+        "st_distance(to_spherical_geography(ST_GeometryFromText(c0)), to_spherical_geography(ST_GeometryFromText(c1)))",
+        leftWkt,
+        rightWkt);
+
+    if (expected.has_value()) {
+      ASSERT_TRUE(aboutEquals(expected.value(), result.value()));
+    } else {
+      ASSERT_FALSE(result.has_value());
+    }
+  };
+
+  // Happy cases
+  testStSphericalDistanceFunc(
+      "POINT (-86.67 36.12)", "POINT (-118.40 33.94)", 2886448.973436703);
+  testStSphericalDistanceFunc(
+      "POINT (-118.40 33.94)", "POINT (-86.67 36.12)", 2886448.973436703);
+  testStSphericalDistanceFunc(
+      "POINT (-71.0589 42.3601)",
+      "POINT (-71.2290 42.4430)",
+      16734.69743457461);
+  testStSphericalDistanceFunc(
+      "POINT (-86.67 36.12)", "POINT (-86.67 36.12)", 0.0);
+
+  // Non-point geometries should throw
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalDistanceFunc(
+          "POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))",
+          "POLYGON((0 0, 0 2, 2 2, 2 0, 0 0))",
+          std::nullopt),
+      "ST_Distance[SphericalGeography] only applies to Point. Input type is: Polygon");
+
+  // Empty points should return null
+  testStSphericalDistanceFunc("POINT EMPTY", "POINT (40 30)", std::nullopt);
+  testStSphericalDistanceFunc("POINT (20 10)", "POINT EMPTY", std::nullopt);
+  testStSphericalDistanceFunc("POINT EMPTY", "POINT EMPTY", std::nullopt);
+}
+
+TEST_F(GeometryFunctionsTest, testStSphericalLength) {
+  const auto testStSphericalLengthFunction =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<double>& expected) {
+        std::optional<double> result = evaluateOnce<double>(
+            "st_length(to_spherical_geography(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(aboutEquals(expected.value(), result.value()));
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  double length = 4350866.6362;
+
+  // Empty linestring returns null
+  testStSphericalLengthFunction("LINESTRING EMPTY", std::nullopt);
+
+  // ST_Length is equivalent to sums of ST_DISTANCE between points in the
+  // LineString
+  testStSphericalLengthFunction(
+      "LINESTRING (-71.05 42.36, -87.62 41.87, -122.41 37.77)", length);
+
+  // Linestring has same length as its reverse
+  testStSphericalLengthFunction(
+      "LINESTRING (-122.41 37.77, -87.62 41.87, -71.05 42.36)", length);
+
+  // Path north pole -> south pole -> north pole should be roughly the
+  // circumference of the Earth
+  testStSphericalLengthFunction(
+      "LINESTRING (0.0 90.0, 0.0 -90.0, 0.0 90.0)", 4.003e7);
+
+  // Empty multi-linestring returns null
+  testStSphericalLengthFunction("MULTILINESTRING EMPTY", std::nullopt);
+
+  // Multi-linestring with one path is equivalent to a single linestring
+  testStSphericalLengthFunction(
+      "MULTILINESTRING ((-71.05 42.36, -87.62 41.87, -122.41 37.77))", length);
+
+  // Multi-linestring with two disjoint paths has length equal to sum of lengths
+  // of lines
+  testStSphericalLengthFunction(
+      "MULTILINESTRING ((-71.05 42.36, -87.62 41.87, -122.41 37.77), (-73.05 42.36, -89.62 41.87, -124.41 37.77))",
+      2 * length);
+
+  // Multi-linestring with adjacent paths is equivalent to a single linestring
+  testStSphericalLengthFunction(
+      "MULTILINESTRING ((-71.05 42.36, -87.62 41.87), (-87.62 41.87, -122.41 37.77))",
+      length);
+
+  // Non-linestring geometries should throw
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalLengthFunction(
+          "POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))", std::nullopt),
+      "ST_Length[SphericalGeography] only applies to LineString or MultiLineString. Input type is: Polygon");
+
+  // Invalid linestring should throw
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalLengthFunction("LINESTRING (0.0)", std::nullopt),
+      "Failed to parse WKT: ParseException: Expected number but encountered ')'");
+}
+
+TEST_F(GeometryFunctionsTest, testDegeneratePolygons) {
+  const auto testDegeneratePolygonsFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<std::string>& expected) {
+        auto res = evaluateOnce<std::string>(
+            "ST_AsText(ST_GeometryFromText(c0))", wkt);
+        if (expected.has_value()) {
+          ASSERT_TRUE(res.has_value());
+          ASSERT_EQ(expected.value(), res.value());
+        } else {
+          ASSERT_FALSE(res.has_value());
+        }
+      };
+
+  // Single polygon with CCW orientation - should orient to CW
+  testDegeneratePolygonsFunc(
+      "POLYGON ((1 2, 3 4, 5 7, 1 2))",
+      "POLYGON ((1 2, 5 7, 3 4, 1 2))"); // note: this should be fine
+
+  // Single polygons with zero area
+  testDegeneratePolygonsFunc(
+      "POLYGON ((1 2, 5 6, 3 4, 1 2))", "POLYGON ((1 2, 3 4, 5 6, 1 2))");
+
+  testDegeneratePolygonsFunc(
+      "POLYGON ((1 2, 3 4, 5 6, 1 2))", "POLYGON ((1 2, 5 6, 3 4, 1 2))");
+
+  // Single polygons with interior rings- should canonicalize so any shells have
+  // CW orientation and holes have CCW orientation.
+  testDegeneratePolygonsFunc(
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3))",
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))");
+
+  testDegeneratePolygonsFunc(
+      "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))",
+      "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))");
+
+  // Multipolygons where polygons after the first are CCW for shell or CW for
+  // hole. These should be correctly oriented after serde.
+
+  // First polygon has CW shell and CCW hole, second polygon has CCW
+  // shell and CCW hole -> second polygon shell should be reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CW shell and CW hole, second polygon has CCW
+  // shell and CCW hole -> first polygon hole and second polygon shell should be
+  // reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CCW shell and CW hole, second polygon has CCW
+  // shell and CW hole -> both polygons should have shell and hole reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 6 14, 14 14, 14 6, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CCW shell and CCW hole, second polygon has CCW
+  // shell and CCW hole -> both polygons should have shells reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CW shell and CW hole, second polygon has CW
+  // shell and CW hole -> both polygons should have holes reoriented
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 6 14, 14 14, 14 6, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // MultiPolygons with zero-area rings. These rings are considered CCW before
+  // and after rotation, and can cause deformed multipolygons. This is being
+  // included to reach bug parity with Java, but we should alter these tests
+  // once we are able to implement the correct behavior!
+
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((1 1, 1 2, 1 3, 1 1)))",
+      "MULTIPOLYGON (((1 1, 1 3, 1 2, 1 1)))");
+
+  // First polygon has CW shell and CCW hole, second polygon has CW shell and
+  // zero-area hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 6 6)))");
+
+  // First polygon has CW shell and CCW hole, second polygon has zero-area shell
+  // and CCW hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 0 10, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3), (0 0, 0 10, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CW shell and CCW hole, second polygon has CW shell
+  // and zero-area hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 9 9, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 9 9, 6 6)))");
+
+  // First polygon has CW shell and CCW hole, second polygon has zero-area shell
+  // and zero-area hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 0 10, 0 0), (6 6, 9 9, 14 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3), (0 0, 0 10, 0 20, 0 0), (6 6, 9 9, 14 14, 6 6)))");
+
+  // First polygon has zero-area shell and CCW hole, second polygon has CW shell
+  // and CCW hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 0 15, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6))))",
+      "MULTIPOLYGON (((0 0, 0 15, 0 10, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has CW shell and zero-area hole, second polygon has CW shell
+  // and CCW hole-
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+  // First polygon has zero-area shell and zero-area hole, second polygon has CW
+  // shell and CCW hole
+  testDegeneratePolygonsFunc(
+      "MULTIPOLYGON (((0 0, 0 10, 0 5, 0 10, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+      "MULTIPOLYGON (((0 0, 0 10, 0 5, 0 10, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+}
+
+TEST_F(GeometryFunctionsTest, testStSphericalArea) {
+  const auto testStSphericalAreaFunc =
+      [&](const std::optional<std::string>& wkt,
+          const std::optional<double>& expected) {
+        std::optional<double> result = evaluateOnce<double>(
+            "st_area(to_spherical_geography(ST_GeometryFromText(c0)))", wkt);
+
+        if (expected.has_value()) {
+          ASSERT_TRUE(aboutEquals(expected.value(), result.value()));
+        } else {
+          ASSERT_FALSE(result.has_value());
+        }
+      };
+
+  // Happy cases
+  testStSphericalAreaFunc("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))", 123.64E8);
+  testStSphericalAreaFunc(
+      "POLYGON((-122.150124 37.486095, -122.149201 37.486606, -122.145725 37.486580, -122.145923 37.483961, -122.149324 37.482480, -122.150837 37.483238,  -122.150901 37.485392, -122.150124 37.486095))",
+      163290.93943428437);
+
+  double angleOfOneKm = 0.008993201943349;
+  testStSphericalAreaFunc(
+      fmt::format(
+          "POLYGON((0 0, {} 0, {} {}, 0 {}, 0 0))",
+          angleOfOneKm,
+          angleOfOneKm,
+          angleOfOneKm,
+          angleOfOneKm),
+      1E6);
+
+  // 1/4th of an hemisphere, ie 1/8th of the planet, should be close to 4PiR2/8
+  // = 637.58E11
+  testStSphericalAreaFunc("POLYGON((90 0, 0 0, 0 90, 90 0))", 637.58E11);
+
+  // A Polygon with a large hole
+  testStSphericalAreaFunc(
+      "POLYGON((90 0, 0 0, 0 90, 90 0), (89 1, 1 1, 1 89, 89 1))", 348.04E10);
+
+  // Empty input should return null
+  testStSphericalAreaFunc("POLYGON EMPTY", std::nullopt);
+  testStSphericalAreaFunc("MULTIPOLYGON EMPTY", std::nullopt);
+  // Empty invalid types return null rather than throw in java, so we do the
+  // same here.
+  testStSphericalAreaFunc("POINT EMPTY", std::nullopt);
+
+  // Invalid data types
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc("POINT (0 1)", std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: Point");
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc("MULTIPOINT (1 2, 3 4)", std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: MultiPoint");
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc("LINESTRING (1 2, 3 4)", std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: LineString");
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc(
+          "MULTILINESTRING ((0 0, 1 1), (2 2, 3 3))", std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: MultiLineString");
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc(
+          "GEOMETRYCOLLECTION (POINT (1 2), LINESTRING (3 4, 5 6))",
+          std::nullopt),
+      "ST_Area[SphericalGeography] only applies to Polygon or MultiPolygon. Input type is: GeometryCollection");
+
+  // Invalid Polygon (duplicated point)
+  VELOX_ASSERT_USER_THROW(
+      testStSphericalAreaFunc(
+          "POLYGON((0 0, 0 1, 1 1, 1 1, 1 0, 0 0))", std::nullopt),
+      "Polygon is not valid: it has two identical consecutive vertices");
+
+  // Test areas for all 50 US states
+  for (const auto& [stateName, area] :
+       facebook::velox::geometry_test_utils::usStateAreas) {
+    const auto& wkt =
+        facebook::velox::geometry_test_utils::usStateWkts.at(stateName);
+    testStSphericalAreaFunc(std::optional<std::string>(wkt), area);
+  }
+
+  testStSphericalAreaFunc(
+      "POLYGON((-135 85, -45 85, 45 85, 135 85, -135 85))", 619.00E9);
+}
diff --git a/velox/functions/prestosql/tests/GreatestLeastTest.cpp b/velox/functions/prestosql/tests/GreatestLeastTest.cpp
index 028081ccf99a..b9e9d7ed38dd 100644
--- a/velox/functions/prestosql/tests/GreatestLeastTest.cpp
+++ b/velox/functions/prestosql/tests/GreatestLeastTest.cpp
@@ -19,6 +19,8 @@
 #include <optional>
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/type/Time.h"
 
 using namespace facebook::velox;
 
@@ -286,6 +288,104 @@ TEST_F(GreatestLeastTest, leastDate) {
       DATE());
 }
 
+TEST_F(GreatestLeastTest, greatestLeastTime) {
+  using namespace facebook::velox::util;
+
+  // Helper to parse TIME from string
+  const auto parseTime = [](const std::string& timeStr) -> int64_t {
+    auto result = fromTimeString(timeStr.c_str(), timeStr.size());
+    if (result.hasError()) {
+      throw std::runtime_error("Parse error: " + result.error().message());
+    }
+    return result.value();
+  };
+
+  // Test greatest
+  runTest<int64_t>(
+      "greatest(c0, c1, c2)",
+      {
+          {parseTime("10:00:00"),
+           parseTime("00:00:00"),
+           parseTime("12:00:00.001")}, // c0
+          {parseTime("12:30:00"),
+           parseTime("12:00:00"),
+           parseTime("12:00:00.500")}, // c1
+          {parseTime("15:30:45.100"),
+           parseTime("23:59:59.999"),
+           parseTime("12:00:00.999")}, // c2
+      },
+      {parseTime("15:30:45.100"),
+       parseTime("23:59:59.999"),
+       parseTime("12:00:00.999")},
+      std::nullopt,
+      TIME(),
+      TIME());
+
+  // Test least
+  runTest<int64_t>(
+      "least(c0, c1, c2)",
+      {
+          {parseTime("10:00:00"),
+           parseTime("00:00:00"),
+           parseTime("12:00:00.001")}, // c0
+          {parseTime("12:30:00"),
+           parseTime("12:00:00"),
+           parseTime("12:00:00.500")}, // c1
+          {parseTime("15:30:45.100"),
+           parseTime("23:59:59.999"),
+           parseTime("12:00:00.999")}, // c2
+      },
+      {parseTime("10:00:00"), parseTime("00:00:00"), parseTime("12:00:00.001")},
+      std::nullopt,
+      TIME(),
+      TIME());
+}
+
+TEST_F(GreatestLeastTest, greatestLeastTimeWithTimezone) {
+  using namespace facebook::velox::util;
+
+  // Helper to parse TIME WITH TIME ZONE from string
+  const auto parseTimeWithTz = [](const std::string& timeStr) -> int64_t {
+    auto result = fromTimeWithTimezoneString(timeStr.c_str(), timeStr.size());
+    if (result.hasError()) {
+      throw std::runtime_error("Parse error: " + result.error().message());
+    }
+    return result.value();
+  };
+
+  // Test greatest
+  runTest<int64_t>(
+      "greatest(c0, c1, c2)",
+      {
+          {parseTimeWithTz("10:00:00+00:00"),
+           parseTimeWithTz("20:00:00-08:00")}, // c0
+          {parseTimeWithTz("10:00:00-08:00"),
+           parseTimeWithTz("23:59:59.999+00:00")}, // c1
+          {parseTimeWithTz("10:00:00+08:00"),
+           parseTimeWithTz("00:00:00+08:00")}, // c2
+      },
+      {parseTimeWithTz("10:00:00-08:00"), parseTimeWithTz("20:00:00-08:00")},
+      std::nullopt,
+      TIME_WITH_TIME_ZONE(),
+      TIME_WITH_TIME_ZONE());
+
+  // Test least
+  runTest<int64_t>(
+      "least(c0, c1, c2)",
+      {
+          {parseTimeWithTz("10:00:00+00:00"),
+           parseTimeWithTz("00:00:00-08:00")}, // c0
+          {parseTimeWithTz("10:00:00-08:00"),
+           parseTimeWithTz("23:59:59.999+00:00")}, // c1
+          {parseTimeWithTz("10:00:00+08:00"),
+           parseTimeWithTz("00:00:00+08:00")}, // c2
+      },
+      {parseTimeWithTz("10:00:00+08:00"), parseTimeWithTz("00:00:00+08:00")},
+      std::nullopt,
+      TIME_WITH_TIME_ZONE(),
+      TIME_WITH_TIME_ZONE());
+}
+
 TEST_F(GreatestLeastTest, greatestLeastIpAddress) {
   auto greatest = [&](const std::optional<std::string>& a,
                       const std::optional<std::string>& b,
@@ -324,6 +424,14 @@ TEST_F(GreatestLeastTest, greatestLeastIpAddress) {
       "255.255.255.255",
       "2001:0db8:0000:0000:0000:ff00:0042:832");
   EXPECT_FALSE(leastValueWithNulls.has_value());
+
+  // Case where raw comparison of values will give
+  // different result than comparison of IPAddress values byte by byte.
+  auto greatValue = greatest("ffff::1", "1::1", "1::2");
+  EXPECT_EQ("ffff::1", greatValue.value());
+
+  auto lessValue = least("ffff::1", "1::1", "ffff::2");
+  EXPECT_EQ("1::1", lessValue.value());
 }
 
 TEST_F(GreatestLeastTest, stringBuffersMoved) {
diff --git a/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp b/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
index a6062e3a30a3..179b8df823bf 100644
--- a/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/HyperLogLogFunctionsTest.cpp
@@ -13,14 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/hyperloglog/SparseHll.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
 #define XXH_INLINE_ALL
 #include <xxhash.h>
 
-using facebook::velox::common::hll::DenseHll;
-using facebook::velox::common::hll::SparseHll;
+using namespace facebook::velox::common::hll;
 
 namespace facebook::velox {
 namespace {
@@ -32,22 +32,46 @@ uint64_t hashOne(T value) {
 
 class HyperLogLogFunctionsTest : public functions::test::FunctionBaseTest {
  protected:
+  template <typename TAllocator>
   static std::string serialize(
       int8_t indexBitLength,
-      const SparseHll& sparseHll) {
+      const SparseHll<TAllocator>& sparseHll) {
     std::string serialized;
     serialized.resize(sparseHll.serializedSize());
     sparseHll.serialize(indexBitLength, serialized.data());
     return serialized;
   }
 
-  static std::string serialize(DenseHll& denseHll) {
+  template <typename TAllocator>
+  static std::string serialize(DenseHll<TAllocator>& denseHll) {
     std::string serialized;
     serialized.resize(denseHll.serializedSize());
     denseHll.serialize(serialized.data());
     return serialized;
   }
 
+  // Creates sparse HLL with values from start (inclusive) to end (exclusive).
+  // modValue applies modulo operation if non-zero.
+  std::string
+  createSparse(int8_t indexBitLength, int start, int end, int modValue = 0) {
+    SparseHll<> hll{&allocator_};
+    for (int i = start; i < end; i++) {
+      hll.insertHash(hashOne(modValue ? (i % modValue) : i));
+    }
+    return serialize(indexBitLength, hll);
+  }
+
+  // Creates dense HLL with values from start (inclusive) to end (exclusive).
+  // modValue applies modulo operation if non-zero.
+  std::string
+  createDense(int8_t indexBitLength, int start, int end, int modValue = 0) {
+    DenseHll<> hll{indexBitLength, &allocator_};
+    for (int i = start; i < end; i++) {
+      hll.insertHash(hashOne(modValue ? (i % modValue) : i));
+    }
+    return serialize(hll);
+  }
+
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
   HashStringAllocator allocator_{pool_.get()};
@@ -55,7 +79,7 @@ class HyperLogLogFunctionsTest : public functions::test::FunctionBaseTest {
 
 TEST_F(HyperLogLogFunctionsTest, cardinalitySignatures) {
   auto signatures = getSignatureStrings("cardinality");
-  ASSERT_EQ(3, signatures.size());
+  ASSERT_LE(3, signatures.size());
 
   ASSERT_EQ(1, signatures.count("(map(__user_T1,__user_T2)) -> bigint"));
   ASSERT_EQ(1, signatures.count("(array(__user_T1)) -> bigint"));
@@ -75,12 +99,7 @@ TEST_F(HyperLogLogFunctionsTest, cardinalitySparse) {
     return evaluateOnce<int64_t>("cardinality(c0)", HYPERLOGLOG(), input);
   };
 
-  SparseHll sparseHll{&allocator_};
-  for (int i = 0; i < 1'000; i++) {
-    sparseHll.insertHash(hashOne(i % 17));
-  }
-
-  auto serialized = serialize(11, sparseHll);
+  auto serialized = createSparse(11, 0, 1000, 17);
   EXPECT_EQ(17, cardinality(serialized));
 }
 
@@ -89,13 +108,14 @@ TEST_F(HyperLogLogFunctionsTest, cardinalityDense) {
     return evaluateOnce<int64_t>("cardinality(c0)", HYPERLOGLOG(), input);
   };
 
-  DenseHll denseHll{12, &allocator_};
+  DenseHll<> expectedHll{12, &allocator_};
   for (int i = 0; i < 10'000'000; i++) {
-    denseHll.insertHash(hashOne(i));
+    expectedHll.insertHash(hashOne(i));
   }
+  auto expectedCardinality = expectedHll.cardinality();
 
-  auto serialized = serialize(denseHll);
-  EXPECT_EQ(denseHll.cardinality(), cardinality(serialized));
+  auto serialized = createDense(12, 0, 10'000'000);
+  EXPECT_EQ(expectedCardinality, cardinality(serialized));
 }
 
 TEST_F(HyperLogLogFunctionsTest, emptyApproxSet) {
@@ -110,5 +130,180 @@ TEST_F(HyperLogLogFunctionsTest, emptyApproxSet) {
           "cardinality(empty_approx_set(0.1))", makeRowVector(ROW({}), 1)));
 }
 
+TEST_F(HyperLogLogFunctionsTest, mergeHll) {
+  // Test merging two HLL instances with different value ranges.
+  const int8_t indexBitLength = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createSparse(indexBitLength, 0, 10),
+      createSparse(indexBitLength, 10, 20)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  auto cardinality = evaluateOnce<int64_t>(
+      "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+
+  EXPECT_EQ(20, cardinality);
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllMixedSparseAndDense) {
+  // Test merging sparse and dense HLL instances.
+  const int8_t indexBitLength = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createSparse(indexBitLength, 0, 50),
+      createDense(indexBitLength, 50, 2000)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  auto cardinality = evaluateOnce<int64_t>(
+      "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+
+  EXPECT_EQ(1978, cardinality);
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllWithNull) {
+  auto serialized = createSparse(12, 0, 10);
+  auto elements = makeNullableFlatVector<std::string>(
+      {serialized, std::nullopt, serialized}, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 3}, elements);
+
+  auto cardinality = evaluateOnce<int64_t>(
+      "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+  EXPECT_EQ(10, cardinality);
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllEmpty) {
+  auto input = makeRowVector(
+      {makeArrayVectorFromJson<std::string>({"null"}, ARRAY(HYPERLOGLOG()))});
+  auto result = evaluate("merge_hll(c0)", input);
+  ASSERT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllNullArray) {
+  auto input = makeRowVector({makeNullableArrayVector<std::string>(
+      {std::nullopt}, ARRAY(HYPERLOGLOG()))});
+  auto result = evaluate("merge_hll(c0)", input);
+  ASSERT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllAllNulls) {
+  auto input = makeRowVector({makeArrayVectorFromJson<std::string>(
+      {"[null, null, null]"}, ARRAY(HYPERLOGLOG()))});
+  auto result = evaluate("merge_hll(c0)", input);
+  ASSERT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllInvalidData) {
+  // Test with invalid HLL data format.
+  std::string invalidData = "invalid_hll_data";
+  auto elements = makeFlatVector<std::string>({invalidData}, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 1}, elements);
+
+  VELOX_ASSERT_THROW(
+      evaluate("merge_hll(c0)", makeRowVector({arrayVector})),
+      "Invalid HLL data format");
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllMismatchedIndexBitLength) {
+  const int8_t indexBitLength1 = 11;
+  const int8_t indexBitLength2 = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createSparse(indexBitLength1, 0, 5),
+      createSparse(indexBitLength2, 5, 10)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  VELOX_ASSERT_THROW(
+      evaluate("merge_hll(c0)", makeRowVector({arrayVector})),
+      "Cannot merge HLLs with different indexBitLength");
+}
+
+TEST_F(
+    HyperLogLogFunctionsTest,
+    mergeHllMismatchedIndexBitLengthDenseVsSparse) {
+  const int8_t indexBitLength1 = 11;
+  const int8_t indexBitLength2 = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createSparse(indexBitLength1, 0, 50),
+      createDense(indexBitLength2, 50, 2000)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  VELOX_ASSERT_THROW(
+      evaluate("merge_hll(c0)", makeRowVector({arrayVector})),
+      "Cannot merge HLLs with different indexBitLength");
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllDenseFirstThenSparse) {
+  const int8_t indexBitLength = 12;
+
+  std::vector<std::string> serializedHlls = {
+      createDense(indexBitLength, 0, 2000),
+      createSparse(indexBitLength, 2000, 2050)};
+
+  auto elements = makeFlatVector(serializedHlls, HYPERLOGLOG());
+  auto arrayVector = makeArrayVector({0, 2}, elements);
+
+  auto cardinality = evaluateOnce<int64_t>(
+      "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+
+  EXPECT_EQ(2035, cardinality);
+}
+
+TEST_F(HyperLogLogFunctionsTest, mergeHllDictionaryEncoded) {
+  // Test merge_hll can handle encoded array elements.
+  const int8_t indexBitLength = 12;
+
+  auto baseElements = makeFlatVector(
+      {createSparse(indexBitLength, 0, 10),
+       createSparse(indexBitLength, 10, 20)},
+      HYPERLOGLOG());
+
+  struct TestCase {
+    std::vector<vector_size_t> indices;
+    std::optional<std::vector<bool>> nulls;
+    int64_t expectedCardinality;
+  };
+
+  std::vector<TestCase> testCases = {
+      // Dictionary indices without nulls.
+      {{0, 1}, std::nullopt, 20},
+      {{1, 0}, std::nullopt, 20},
+      {{1, 1, 1}, std::nullopt, 10},
+      {{0, 0, 0, 0}, std::nullopt, 10},
+      {{1, 1, 0, 0, 1, 0}, std::nullopt, 20},
+      // Dictionary adds nulls: [1, null]
+      {{1, 0}, {{false, true}}, 10},
+      // Dictionary adds nulls: [null, 0, null]
+      {{0, 0, 0}, {{true, false, true}}, 10},
+      // Dictionary adds nulls: [null, null, 1, 1, null, 0]
+      {{0, 0, 1, 1, 0, 0}, {{true, true, false, false, true, false}}, 20},
+  };
+
+  for (const auto& testCase : testCases) {
+    auto indices = makeIndices(testCase.indices);
+    VectorPtr encodedElements;
+    if (testCase.nulls.has_value()) {
+      auto nulls = makeNulls(testCase.nulls.value());
+      encodedElements = BaseVector::wrapInDictionary(
+          nulls, indices, testCase.indices.size(), baseElements);
+    } else {
+      encodedElements = wrapInDictionary(indices, baseElements);
+    }
+    auto arrayVector = makeArrayVector(
+        {0, static_cast<int>(testCase.indices.size())}, encodedElements);
+    auto cardinality = evaluateOnce<int64_t>(
+        "cardinality(merge_hll(c0))", makeRowVector({arrayVector}));
+    EXPECT_EQ(testCase.expectedCardinality, cardinality);
+  }
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/InPredicateTest.cpp b/velox/functions/prestosql/tests/InPredicateTest.cpp
index 0ea2768c9dce..84ef4bdcab5e 100644
--- a/velox/functions/prestosql/tests/InPredicateTest.cpp
+++ b/velox/functions/prestosql/tests/InPredicateTest.cpp
@@ -13,12 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/OptionalEmpty.h"
-#include "velox/functions/lib/DateTimeFormatter.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
-#include "velox/type/tz/TimeZoneMap.h"
 
 using namespace facebook::velox::test;
 using namespace facebook::velox::functions::test;
@@ -30,7 +28,7 @@ class InPredicateTest : public FunctionBaseTest {
  protected:
   template <typename T>
   ArrayVectorPtr getInList(
-      std::vector<std::optional<T>> input,
+      const std::vector<std::optional<T>>& input,
       const TypePtr& type) {
     FlatVectorPtr<T> flatVec = makeNullableFlatVector<T>(input, type);
 
@@ -43,10 +41,9 @@ class InPredicateTest : public FunctionBaseTest {
       const TypePtr& type) {
     return std::make_shared<core::CallTypedExpr>(
         BOOLEAN(),
-        std::vector<core::TypedExprPtr>{
-            std::make_shared<core::FieldAccessTypedExpr>(type, probe),
-            std::make_shared<core::ConstantTypedExpr>(inList)},
-        "in");
+        "in",
+        std::make_shared<core::FieldAccessTypedExpr>(type, probe),
+        std::make_shared<core::ConstantTypedExpr>(inList));
   }
 
   template <typename T>
@@ -243,19 +240,16 @@ class InPredicateTest : public FunctionBaseTest {
 
     return std::make_shared<core::CallTypedExpr>(
         BOOLEAN(),
-        std::vector<core::TypedExprPtr>{
-            field(values->type(), "c0"),
-            std::make_shared<core::ConstantTypedExpr>(
-                std::make_shared<ArrayVector>(
-                    pool(),
-                    ARRAY(values->type()),
-                    nullptr,
-                    1,
-                    offsets,
-                    sizes,
-                    values)),
-        },
-        "in");
+        "in",
+        field(values->type(), "c0"),
+        std::make_shared<core::ConstantTypedExpr>(std::make_shared<ArrayVector>(
+            pool(),
+            ARRAY(values->type()),
+            nullptr,
+            1,
+            offsets,
+            sizes,
+            values)));
   }
 
   VectorPtr makeTimestampVector(const std::vector<int64_t>& millis) {
@@ -280,12 +274,10 @@ class InPredicateTest : public FunctionBaseTest {
                                    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");
+          "in",
+          field(columnFloatType, "c0"),
+          std::make_shared<core::ConstantTypedExpr>(
+              makeArrayVector<T>({inlist})));
       auto data = makeRowVector({
           makeFlatVector<T>(input),
       });
@@ -311,11 +303,9 @@ class InPredicateTest : public FunctionBaseTest {
                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");
+          "in",
+          field(ROW({columnFloatType, INTEGER()}), "c0"),
+          std::make_shared<core::ConstantTypedExpr>(inlist));
       // Input is [row{kNaN, 1}, row{kSNaN, 1}, row{kNaN, 2}].
       auto data = makeRowVector({makeRowVector(
           {makeFlatVector<T>(std::vector<T>({kNaN, kSNaN, kNaN})),
@@ -335,12 +325,10 @@ class InPredicateTest : public FunctionBaseTest {
       // 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");
+          "in",
+          field(columnFloatType, "c0"),
+          field(columnFloatType, "c1"),
+          field(columnFloatType, "c2"));
       auto expectedResults = makeFlatVector<bool>({
           true, // kNaN in (kNaN, 1)
           true, // kSNaN in (kNaN, 1)
@@ -365,11 +353,9 @@ class InPredicateTest : public FunctionBaseTest {
       // 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");
+          "in",
+          field(ROW({columnFloatType, INTEGER()}), "c0"),
+          field(ROW({columnFloatType, INTEGER()}), "c1"));
       auto expectedResults = makeFlatVector<bool>({true, true, false});
       auto result = evaluate(inWithVariableInList, data);
       assertEqualVectors(expectedResults, result);
@@ -1061,13 +1047,11 @@ TEST_F(InPredicateTest, nonConstantInList) {
 
   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");
+      "in",
+      field(INTEGER(), "c0"),
+      field(INTEGER(), "c1"),
+      field(INTEGER(), "c2"),
+      field(INTEGER(), "c3"));
 
   auto result = evaluate(in, data);
   assertEqualVectors(expected, result);
@@ -1104,11 +1088,10 @@ TEST_F(InPredicateTest, nonConstantInList) {
   });
   in = std::make_shared<core::CallTypedExpr>(
       BOOLEAN(),
-      std::vector<core::TypedExprPtr>{
-          field(INTEGER(), "c0"),
-          field(INTEGER(), "c1"),
-          field(INTEGER(), "c2")},
-      "in");
+      "in",
+      field(INTEGER(), "c0"),
+      field(INTEGER(), "c1"),
+      field(INTEGER(), "c2"));
   expected = makeNullableFlatVector<bool>({
       std::nullopt, // [1, null] in ([1, null], [1, 2])
       false, // [1, 2] in ([1, 3], [1, 3])
@@ -1159,9 +1142,7 @@ TEST_F(InPredicateTest, BadTimestampsWithTry) {
   auto expected = BaseVector::createNullConstant(BOOLEAN(), 1, pool());
 
   auto expression = std::make_shared<core::CallTypedExpr>(
-      BOOLEAN(),
-      std::vector<core::TypedExprPtr>{makeInExpression(inValues)},
-      "try");
+      BOOLEAN(), "try", makeInExpression(inValues));
 
   auto result = evaluate(expression, makeRowVector({flatVectorWithoutNulls}));
   assertEqualVectors(expected, result);
diff --git a/velox/functions/prestosql/tests/JsonCastTest.cpp b/velox/functions/prestosql/tests/JsonCastTest.cpp
index 2ac77dc835b4..7ab84abcfb8c 100644
--- a/velox/functions/prestosql/tests/JsonCastTest.cpp
+++ b/velox/functions/prestosql/tests/JsonCastTest.cpp
@@ -316,6 +316,14 @@ TEST_F(JsonCastTest, fromVarchar) {
         VARCHAR(), {StringView(utf8String)}, {StringView(expected)});
   }
 
+  {
+    SCOPED_TRACE("Invalid unicode size estimation");
+    testCastToJson<StringView>(
+        VARCHAR(),
+        {"\xf0\x88\xba\xaa\xdb\x9a\x4a\x71\x08\xae\x85\xd2\x6b\x26\x72\x2a"_sv},
+        {R"("\uFFFD\uFFFD\uFFFD\uFFFDۚJq\b\uFFFD\uFFFD\uFFFDk&r*")"_sv});
+  }
+
   testCastToJson<StringView>(
       VARCHAR(),
       {""_sv, std::nullopt, "\xc0"_sv},
@@ -1114,12 +1122,12 @@ TEST_F(JsonCastTest, toDouble) {
       JSON(),
       DOUBLE(),
       {"Infinity"_sv},
-      "The JSON document has an improper structure");
+      "The JSON element does not have the requested type");
   testThrow<JsonNativeType>(
       JSON(),
       DOUBLE(),
       {"NaN"_sv},
-      "The JSON document has an improper structure");
+      "The JSON element does not have the requested type");
 
   testThrow<JsonNativeType>(
       JSON(),
@@ -1814,3 +1822,18 @@ TEST_F(JsonCastTest, castFromJsonWithEscapingForSpecialUniocodeCharacters) {
   testCast(R"(["\u007F"])", "\u007F");
   testCast(R"(["\u008A"])", "\u008A");
 }
+
+TEST_F(JsonCastTest, uniqueErrorContextMessage) {
+  // Verify that exceptions thrown have the correct error context information.
+  testContextMessageOnThrow(
+      "cast((c0) as DOUBLE)",
+      makeRowVector({makeNullableFlatVector<JsonNativeType>({"\"abc\""_sv})}),
+      "Top-level Expression: cast((c0) as DOUBLE)");
+
+  // Test twice to ensure that the context is correctly generated for each
+  // expression and not cached and reused.
+  testContextMessageOnThrow(
+      "cast((c0) as BIGINT)",
+      makeRowVector({makeNullableFlatVector<JsonNativeType>({"\"abc\""_sv})}),
+      "Top-level Expression: cast((c0) as BIGINT)");
+}
diff --git a/velox/functions/prestosql/tests/JsonExtractScalarTest.cpp b/velox/functions/prestosql/tests/JsonExtractScalarTest.cpp
index 9ccbf9c0a64b..5d3ec4e91458 100644
--- a/velox/functions/prestosql/tests/JsonExtractScalarTest.cpp
+++ b/velox/functions/prestosql/tests/JsonExtractScalarTest.cpp
@@ -239,6 +239,18 @@ TEST_F(JsonExtractScalarTest, wildcardSelect) {
       std::nullopt);
 }
 
+TEST_F(JsonExtractScalarTest, nanJson) {
+  std::vector<std::string> badReplacements = {"garbage", "NaN", "}", "0/0"};
+
+  for (const auto& badReplacement : badReplacements) {
+    std::string js = fmt::format(
+        fmt::runtime(
+            "{{\"hands_v1\": {}, \"over_occlusion_rate\": 0.0358322490205352}}"),
+        badReplacement);
+    EXPECT_EQ(jsonExtractScalar(js, "$.over_occlusion_rate"), std::nullopt);
+  }
+}
+
 } // namespace
 
 } // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/tests/JsonFunctionsTest.cpp b/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
index bd018163143e..12101b9adf81 100644
--- a/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/JsonFunctionsTest.cpp
@@ -17,6 +17,7 @@
 #include "folly/Unicode.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/testutil/OptionalEmpty.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/prestosql/types/JsonType.h"
 
@@ -149,11 +150,11 @@ class JsonFunctionsTest : public functions::test::FunctionBaseTest {
       const TypePtr& returnType,
       const RowVectorPtr& data,
       const VectorPtr& expected) {
-    auto inputFeild =
+    auto inputField =
         std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0");
 
     auto expression = std::make_shared<core::CallTypedExpr>(
-        returnType, std::vector<core::TypedExprPtr>{inputFeild}, functionName);
+        returnType, functionName, inputField);
 
     SelectivityVector rows(data->size());
     std::vector<VectorPtr> result(1);
@@ -174,6 +175,12 @@ class JsonFunctionsTest : public functions::test::FunctionBaseTest {
     return evaluateJsonVectorFunction("json_array_get", json, index, wrapInTry);
   }
 
+  const std::vector<std::string> badReplacements_ = {
+      "garbage",
+      "NaN",
+      "}",
+      "0/0"};
+
  private:
   // Utility function to evaluate a function both with and without constant
   // inputs. Ensures that the results are same in both cases. 'wrapInTry' is
@@ -244,6 +251,18 @@ TEST_F(JsonFunctionsTest, jsonFormat) {
   velox::test::assertEqualVectors(expected, result);
 }
 
+TEST_F(JsonFunctionsTest, jsonParseErrorContext) {
+  auto data = makeRowVector(
+      {makeFlatVector<StringView>({"1]"}), makeFlatVector<StringView>({"2]"})});
+  // Verify that exceptions thrown have the correct error context information.
+  testContextMessageOnThrow(
+      "json_parse(c0)", data, "Top-level Expression: json_parse(c0)");
+  // Test twice to ensure that the context is correctly generated for each
+  // expression and not cached and reused.
+  testContextMessageOnThrow(
+      "json_parse(c1)", data, "Top-level Expression: json_parse(c1)");
+}
+
 TEST_F(JsonFunctionsTest, jsonParse) {
   const auto jsonParse = [&](std::optional<std::string> value) {
     return evaluateOnce<StringView>("json_parse(c0)", value);
@@ -303,10 +322,13 @@ TEST_F(JsonFunctionsTest, jsonParse) {
       R"([{"response":"[\"fusil a peinture\",\"�uD83E\\uDE2Dau bois\"]"}])");
 
   VELOX_ASSERT_THROW(
-      jsonParse(R"({"k1":})"), "The JSON document has an improper structure");
+      jsonParse(R"({"k1":})"),
+      "The JSON element does not have the requested type");
   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");
+  // The exact exception message can change based on the simdjson version used.
+  // Instead, check that VeloxUserError for invalid Json is returned.
+  ASSERT_THROW(jsonParse(R"(not_json)"), VeloxUserError);
   VELOX_ASSERT_THROW(
       jsonParse("[1"),
       "JSON document ended early in the middle of an object or array");
@@ -683,6 +705,16 @@ TEST_F(JsonFunctionsTest, isJsonScalar) {
   EXPECT_EQ(isJsonScalar(R"({"k1":""})"), false);
 }
 
+TEST_F(JsonFunctionsTest, isJsonScalarBadJsons) {
+  for (const auto& badReplacement : badReplacements_) {
+    std::string js = fmt::format(
+        fmt::runtime(
+            "{{\"hands_v1\": {}, \"over_occlusion_rate\": 0.0358322490205352}}"),
+        badReplacement);
+    EXPECT_THROW(isJsonScalar(js), VeloxUserError);
+  }
+}
+
 TEST_F(JsonFunctionsTest, jsonArrayLength) {
   EXPECT_EQ(jsonArrayLength(R"([])"), 0);
   EXPECT_EQ(jsonArrayLength(R"([1])"), 1);
@@ -702,6 +734,14 @@ TEST_F(JsonFunctionsTest, jsonArrayLength) {
 
   // Malformed Json.
   EXPECT_EQ(jsonArrayLength(R"((})"), std::nullopt);
+
+  for (const auto& badReplacement : badReplacements_) {
+    std::string js = fmt::format(
+        fmt::runtime(
+            "{{\"hands_v1\": {}, \"over_occlusion_rate\": 0.0358322490205352}}"),
+        badReplacement);
+    EXPECT_EQ(jsonArrayLength(js), std::nullopt);
+  }
 }
 
 TEST_F(JsonFunctionsTest, jsonArrayGet) {
@@ -711,7 +751,7 @@ TEST_F(JsonFunctionsTest, jsonArrayGet) {
     std::optional<StringView> s = json.has_value()
         ? std::make_optional(StringView(json.value()))
         : std::nullopt;
-    auto jsonInput = makeNullableFlatVector<std::string>({s}, jsontype);
+    auto jsonInput = makeNullableFlatVector<StringView>({s}, jsontype);
     auto indexInput = makeFlatVector<int64_t>(std::vector<int64_t>{index});
     return JsonFunctionsTest::jsonArrayGet(jsonInput, indexInput);
   };
@@ -752,6 +792,15 @@ TEST_F(JsonFunctionsTest, jsonArrayGet) {
     EXPECT_FALSE(arrayGet("[1, 2, ...", 1, type).has_value());
     EXPECT_FALSE(arrayGet("not json", 1, type).has_value());
   }
+
+  // Test it fails on bad jsons
+  for (const auto& badReplacement : badReplacements_) {
+    std::string js = fmt::format(
+        fmt::runtime(
+            "{{\"hands_v1\": {}, \"over_occlusion_rate\": 0.0358322490205352}}"),
+        badReplacement);
+    EXPECT_EQ(arrayGet(js.data(), 1, JSON()), std::nullopt);
+  }
 }
 
 TEST_F(JsonFunctionsTest, jsonArrayContainsBool) {
@@ -791,8 +840,9 @@ true, true, true, true, true, true, true, true, true, true, true])",
 
   // Test errors of getting the specified type of json value.
   // Error code is "INCORRECT_TYPE".
-  EXPECT_EQ(jsonArrayContains<bool>(R"([truet])", false), false);
-  EXPECT_EQ(jsonArrayContains<bool>(R"([truet, false])", false), true);
+  // Bad jsons will return null.
+  EXPECT_EQ(jsonArrayContains<bool>(R"([truet])", false), std::nullopt);
+  EXPECT_EQ(jsonArrayContains<bool>(R"([truet, false])", false), std::nullopt);
 }
 
 TEST_F(JsonFunctionsTest, jsonArrayContainsBigint) {
@@ -840,8 +890,8 @@ TEST_F(JsonFunctionsTest, jsonArrayContainsBigint) {
   EXPECT_EQ(
       jsonArrayContains<int64_t>(R"([-9223372036854775809,-9])", -9), true);
   // Error code is "NUMBER_ERROR".
-  EXPECT_EQ(jsonArrayContains<int64_t>(R"([01])", 4), false);
-  EXPECT_EQ(jsonArrayContains<int64_t>(R"([01, 4])", 4), true);
+  EXPECT_EQ(jsonArrayContains<int64_t>(R"([01])", 4), std::nullopt);
+  EXPECT_EQ(jsonArrayContains<int64_t>(R"([01, 4])", 4), std::nullopt);
 }
 
 TEST_F(JsonFunctionsTest, jsonArrayContainsDouble) {
@@ -889,8 +939,8 @@ TEST_F(JsonFunctionsTest, jsonArrayContainsDouble) {
 
   // Test errors of getting the specified type of json value.
   // Error code is "NUMBER_ERROR".
-  EXPECT_EQ(jsonArrayContains<double>(R"([9.6E400])", 4.2), false);
-  EXPECT_EQ(jsonArrayContains<double>(R"([9.6E400,4.2])", 4.2), true);
+  EXPECT_EQ(jsonArrayContains<double>(R"([9.6E400])", 4.2), std::nullopt);
+  EXPECT_EQ(jsonArrayContains<double>(R"([9.6E400,4.2])", 4.2), std::nullopt);
 }
 
 TEST_F(JsonFunctionsTest, jsonArrayContainsString) {
@@ -958,6 +1008,14 @@ TEST_F(JsonFunctionsTest, jsonArrayContainsMalformed) {
       evaluateOnce<bool>(
           "json_array_contains(c0, 'a')", makeRowVector({jsonVector})),
       std::nullopt);
+
+  for (const auto& badReplacement : badReplacements_) {
+    std::string js = fmt::format(
+        fmt::runtime(
+            "{{\"hands_v1\": {}, \"over_occlusion_rate\": 0.0358322490205352}}"),
+        badReplacement);
+    EXPECT_EQ(jsonArrayContains<std::string>(js, {""}), std::nullopt);
+  }
 }
 
 TEST_F(JsonFunctionsTest, jsonSize) {
@@ -974,6 +1032,14 @@ TEST_F(JsonFunctionsTest, jsonSize) {
       jsonSize(
           R"({"k1":{"k2": 999, "k3": [{"k4": [1, 2, 3]}]}})", "$.k1.k3[0].k4"),
       3);
+
+  for (const auto& badReplacement : badReplacements_) {
+    std::string js = fmt::format(
+        fmt::runtime(
+            "{{\"hands_v1\": {}, \"over_occlusion_rate\": 0.0358322490205352}}"),
+        badReplacement);
+    EXPECT_EQ(jsonSize(js, "$.k1"), std::nullopt);
+  }
 }
 
 TEST_F(JsonFunctionsTest, invalidPath) {
@@ -1018,6 +1084,23 @@ TEST_F(JsonFunctionsTest, jsonExtract) {
 
   EXPECT_EQ(std::nullopt, jsonExtract("INVALID_JSON", "$"));
   VELOX_ASSERT_THROW(jsonExtract("{\"\":\"\"}", ""), "Invalid JSON path");
+  // This is a special case where the input is only identified as invalid once
+  // jsonExtract starts to traverse the path.
+  EXPECT_EQ(
+      std::nullopt,
+      jsonExtract(
+          R"({3436654998315577471:-768009352,3684989847712002091:-317930923,5235625120989803984:1278962211,6359026774420146638:651644866,6614027999037539496:528067092})",
+          "$.*"));
+  EXPECT_EQ(
+      std::nullopt,
+      jsonExtract(R"({"a" : 1, "b" : {4422863654280672950:43}})", "$..*"));
+  EXPECT_EQ(
+      std::nullopt,
+      jsonExtract(R"([6849,26,"a",{4422863654280672950:43},26,"a"])", "$.*"));
+  EXPECT_EQ(
+      std::nullopt,
+      jsonExtract(
+          R"([6849,26,"a",[{4422863654280672950:43}],26,"a"])", "$..*"));
 
   EXPECT_EQ(
       "[\"0-553-21311-3\",\"0-395-19395-8\"]",
@@ -1049,7 +1132,7 @@ TEST_F(JsonFunctionsTest, jsonExtract) {
   EXPECT_EQ(std::nullopt, jsonExtract(R"({"a": [{"b": 123}]})", "$.a[0].c"));
 
   // Wildcard on empty object and array
-  EXPECT_EQ("[]", jsonExtract("{\"a\": {}", "$.a.[*]"));
+  EXPECT_EQ("[]", jsonExtract("{\"a\": {}}", "$.a.[*]"));
   EXPECT_EQ("[]", jsonExtract("{\"a\": []}", "$.a.[*]"));
 
   // Calling wildcard on a scalar
@@ -1112,6 +1195,9 @@ TEST_F(JsonFunctionsTest, jsonExtract) {
   EXPECT_EQ(std::nullopt, jsonExtract(kJson, "max($..price)", true));
   EXPECT_EQ(std::nullopt, jsonExtract(kJson, "concat($..category)", true));
   EXPECT_EQ(std::nullopt, jsonExtract(kJson, "$.store.keys()", true));
+
+  // Invalid JSON
+  EXPECT_EQ(std::nullopt, jsonExtract("{\"a\": {}", "$.a.[*]"));
 }
 
 TEST_F(JsonFunctionsTest, jsonExtractVarcharInput) {
@@ -1121,7 +1207,7 @@ TEST_F(JsonFunctionsTest, jsonExtractVarcharInput) {
     std::optional<StringView> s = json.has_value()
         ? std::make_optional(StringView(json.value()))
         : std::nullopt;
-    auto varcharInput = makeNullableFlatVector<std::string>({s}, VARCHAR());
+    auto varcharInput = makeNullableFlatVector<StringView>({s}, VARCHAR());
     auto pathInput = makeFlatVector<std::string>({path});
     return JsonFunctionsTest::jsonExtract(varcharInput, pathInput, wrapInTry);
   };
@@ -1155,11 +1241,12 @@ TEST_F(JsonFunctionsTest, jsonExtractVarcharInput) {
 
 TEST_F(JsonFunctionsTest, jsonStringToArrayCast) {
   // Array of strings.
-  auto data = makeRowVector({makeNullableFlatVector<std::string>(
-      {R"(["red","blue"])"_sv,
-       R"([null,null,"purple"])"_sv,
-       "[]"_sv,
-       "null"_sv})});
+  auto data = makeRowVector({makeNullableFlatVector<StringView>({
+      R"(["red","blue"])"_sv,
+      R"([null,null,"purple"])"_sv,
+      "[]"_sv,
+      "null"_sv,
+  })});
   auto expected = makeNullableArrayVector<StringView>(
       {{{"red"_sv, "blue"_sv}},
        {{std::nullopt, std::nullopt, "purple"_sv}},
@@ -1170,8 +1257,10 @@ TEST_F(JsonFunctionsTest, jsonStringToArrayCast) {
       "$internal$json_string_to_array_cast", ARRAY(VARCHAR()), data, expected);
 
   // Array of integers.
-  data = makeRowVector({makeNullableFlatVector<std::string>(
-      {R"(["10212","1015353"])"_sv, R"(["10322","285000"])"})});
+  data = makeRowVector({makeNullableFlatVector<StringView>({
+      R"(["10212","1015353"])"_sv,
+      R"(["10322","285000"])",
+  })});
   expected =
       makeNullableArrayVector<int64_t>({{10212, 1015353}, {10322, 285000}});
 
@@ -1181,19 +1270,21 @@ TEST_F(JsonFunctionsTest, jsonStringToArrayCast) {
 
 TEST_F(JsonFunctionsTest, jsonStringToMapCast) {
   // Map of strings.
-  auto data = makeRowVector({makeFlatVector<std::string>(
-      {R"({"red":1,"blue":2})"_sv,
-       R"({"green":3,"magenta":4})"_sv,
-       R"({"violet":1,"blue":2})"_sv,
-       R"({"yellow":1,"blue":2})"_sv,
-       R"({"purple":10,"cyan":5})"_sv})});
-
-  auto expected = makeMapVector<StringView, int64_t>(
-      {{{"red"_sv, 1}, {"blue"_sv, 2}},
-       {{"green"_sv, 3}, {"magenta"_sv, 4}},
-       {{"violet"_sv, 1}, {"blue"_sv, 2}},
-       {{"yellow"_sv, 1}, {"blue"_sv, 2}},
-       {{"purple"_sv, 10}, {"cyan"_sv, 5}}});
+  auto data = makeRowVector({makeFlatVector<StringView>({
+      R"({"red":1,"blue":2})"_sv,
+      R"({"green":3,"magenta":4})"_sv,
+      R"({"violet":1,"blue":2})"_sv,
+      R"({"yellow":1,"blue":2})"_sv,
+      R"({"purple":10,"cyan":5})"_sv,
+  })});
+
+  auto expected = makeMapVector<StringView, int64_t>({
+      {{"red"_sv, 1}, {"blue"_sv, 2}},
+      {{"green"_sv, 3}, {"magenta"_sv, 4}},
+      {{"violet"_sv, 1}, {"blue"_sv, 2}},
+      {{"yellow"_sv, 1}, {"blue"_sv, 2}},
+      {{"purple"_sv, 10}, {"cyan"_sv, 5}},
+  });
 
   checkInternalFn(
       "$internal$json_string_to_map_cast",
@@ -1204,12 +1295,13 @@ TEST_F(JsonFunctionsTest, jsonStringToMapCast) {
 
 TEST_F(JsonFunctionsTest, jsonStringToRowCast) {
   // Row of strings.
-  auto data = makeRowVector({makeFlatVector<std::string>(
-      {R"({"red":1,"blue":2})"_sv,
-       R"({"red":3,"blue":4})"_sv,
-       R"({"red":1,"blue":2})"_sv,
-       R"({"red":1,"blue":2})"_sv,
-       R"({"red":10,"blue":5})"_sv})});
+  auto data = makeRowVector({makeFlatVector<StringView>({
+      R"({"red":1,"blue":2})"_sv,
+      R"({"red":3,"blue":4})"_sv,
+      R"({"red":1,"blue":2})"_sv,
+      R"({"red":1,"blue":2})"_sv,
+      R"({"red":10,"blue":5})"_sv,
+  })});
 
   auto expected = makeRowVector(
       {makeFlatVector<int64_t>({1, 3, 1, 1, 10}),
diff --git a/velox/functions/prestosql/tests/KHyperLogLogCastTest.cpp b/velox/functions/prestosql/tests/KHyperLogLogCastTest.cpp
new file mode 100644
index 000000000000..e285d4942cb5
--- /dev/null
+++ b/velox/functions/prestosql/tests/KHyperLogLogCastTest.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/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+using namespace facebook::velox;
+
+class KHyperLogLogCastTest : public functions::test::CastBaseTest {};
+
+TEST_F(KHyperLogLogCastTest, toKHyperLogLog) {
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      KHYPERLOGLOG(),
+      {"aaa"_sv, ""_sv, std::nullopt},
+      {"aaa"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      KHYPERLOGLOG(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
+
+TEST_F(KHyperLogLogCastTest, fromKHyperLogLog) {
+  testCast<StringView, StringView>(
+      KHYPERLOGLOG(),
+      VARBINARY(),
+      {"aaa"_sv, ""_sv, std::nullopt},
+      {"aaa"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      KHYPERLOGLOG(),
+      VARBINARY(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
diff --git a/velox/functions/prestosql/tests/KHyperLogLogFunctionsTest.cpp b/velox/functions/prestosql/tests/KHyperLogLogFunctionsTest.cpp
new file mode 100644
index 000000000000..18b88aa0ffe4
--- /dev/null
+++ b/velox/functions/prestosql/tests/KHyperLogLogFunctionsTest.cpp
@@ -0,0 +1,690 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/KHyperLogLog.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::common::hll;
+using namespace facebook::velox::functions::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class KHyperLogLogFunctionsTest : public functions::test::FunctionBaseTest {
+ protected:
+  void SetUp() override {
+    FunctionBaseTest::SetUp();
+    pool_ = memory::memoryManager()->addLeafPool();
+    allocator_ = std::make_unique<HashStringAllocator>(pool_.get());
+  }
+
+  // Helper to create a KHLL with specific value-UII pairs.
+  std::string createKHLL(
+      const std::vector<std::pair<int64_t, int64_t>>& valueUiiPairs) {
+    auto khll = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_.get());
+
+    for (const auto& [value, uii] : valueUiiPairs) {
+      khll->add(value, uii);
+    }
+
+    size_t totalSize = khll->estimatedSerializedSize();
+    std::string outputBuffer(totalSize, '\0');
+    khll->serialize(outputBuffer.data());
+    return outputBuffer;
+  }
+
+  // Helper to create array of KHLLs for merge_khll SQL function.
+  VectorPtr createKHLLArray(const std::vector<std::string>& serializedKHLLs) {
+    return makeArrayVector<std::string>({serializedKHLLs}, KHYPERLOGLOG());
+  }
+
+  // Build a map from the result vector for easier verification.
+  std::map<int64_t, double> createResultMap(MapVector* mapVector) {
+    auto mapSize = mapVector->sizeAt(0);
+
+    auto offset = mapVector->offsetAt(0);
+    auto keys = mapVector->mapKeys()->as<SimpleVector<int64_t>>();
+    auto values = mapVector->mapValues()->as<SimpleVector<double>>();
+
+    std::map<int64_t, double> resultMap;
+    for (vector_size_t i = 0; i < mapSize; ++i) {
+      resultMap[keys->valueAt(offset + i)] = values->valueAt(offset + i);
+    }
+    return resultMap;
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+  std::unique_ptr<HashStringAllocator> allocator_;
+};
+
+TEST_F(KHyperLogLogFunctionsTest, cardinalityBasic) {
+  auto serialized = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+  auto input =
+      makeFlatVector<StringView>({StringView(serialized)}, KHYPERLOGLOG());
+  auto result = evaluate("cardinality(c0)", makeRowVector({input}));
+  auto expected = makeFlatVector<int64_t>({3});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(KHyperLogLogFunctionsTest, mergeKhll) {
+  // Merge KHLLs with completely disjoint key sets.
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto khll2 = createKHLL({{3, 13}, {4, 14}, {5, 15}});
+    auto khll3 = createKHLL({{6, 16}, {7, 17}, {8, 18}});
+
+    auto arrayInput = createKHLLArray({khll1, khll2, khll3});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+    EXPECT_FALSE(result->isNullAt(0));
+    EXPECT_EQ(result->type(), KHYPERLOGLOG());
+
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({9});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // Merge KHLLs with overlapping key sets.
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+    auto khll2 = createKHLL({{3, 13}, {4, 14}, {5, 15}, {6, 16}, {7, 17}});
+
+    auto arrayInput = createKHLLArray({khll1, khll2});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({8});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // Merge KHLL with single element.
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto arrayInput = createKHLLArray({khll});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({3});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // Merge same KHLL multiple times.
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto arrayInput = createKHLLArray({khll, khll, khll});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    // Cardinality should still be 3.
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({3});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // Empty array
+  {
+    auto elements = makeFlatVector<StringView>({}, KHYPERLOGLOG());
+    auto arrayInput = makeArrayVector({0}, elements);
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+
+  // Array with nulls
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+
+    std::vector<std::string> serializedData;
+    serializedData.push_back(khll);
+
+    auto elements = makeNullableFlatVector<StringView>(
+        {StringView(serializedData[0]),
+         std::nullopt,
+         StringView(serializedData[0])},
+        KHYPERLOGLOG());
+    auto arrayInput = makeArrayVector({0}, elements, {3});
+
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    EXPECT_FALSE(result->isNullAt(0));
+
+    auto cardinalityResult =
+        evaluate("cardinality(c0)", makeRowVector({result}));
+    auto expected = makeFlatVector<int64_t>({3});
+    assertEqualVectors(expected, cardinalityResult);
+  }
+
+  // All nulls in array
+  {
+    auto elements = makeNullableFlatVector<StringView>(
+        {std::nullopt, std::nullopt, std::nullopt}, KHYPERLOGLOG());
+    auto arrayInput = makeArrayVector({0}, elements, {3});
+    auto result = evaluate("merge_khll(c0)", makeRowVector({arrayInput}));
+
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+
+  // Null array
+  {
+    auto nullArray =
+        makeNullableFlatVector<int64_t>({std::nullopt}, ARRAY(KHYPERLOGLOG()));
+    auto result = evaluate("merge_khll(c0)", makeRowVector({nullArray}));
+
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, intersectionCardinalityExact) {
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+    auto khll2 = createKHLL({{3, 13}, {4, 14}, {5, 15}, {6, 16}, {7, 17}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({2});
+    assertEqualVectors(expected, result);
+  }
+
+  // Intersection cardinality of completely overlapping KHLLs.
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({5});
+    assertEqualVectors(expected, result);
+  }
+
+  // Intersection cardinality of empty sets.
+  {
+    auto emptyKhll = createKHLL({});
+    auto nonEmptyKhll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(emptyKhll)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(nonEmptyKhll)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({0});
+    assertEqualVectors(expected, result);
+
+    // Test in reverse order.
+    result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input2, input1}));
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    auto emptyKhll1 = createKHLL({});
+    auto emptyKhll2 = createKHLL({});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(emptyKhll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(emptyKhll2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Intersection cardinality of completely disjoint sets
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto khll2 = createKHLL({{100, 110}, {101, 111}, {102, 112}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Intersection where one is a subset of the other.
+  {
+    auto khll1 = createKHLL(
+        {{0, 10},
+         {1, 11},
+         {2, 12},
+         {3, 13},
+         {4, 14},
+         {5, 15},
+         {6, 16},
+         {7, 17},
+         {8, 18},
+         {9, 19}});
+    auto khll2 = createKHLL({{2, 12}, {3, 13}, {4, 14}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<int64_t>({3});
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, intersectionCardinalityApproximate) {
+  // KHLL1: 0-4999 (5000 values), KHLL2: 2500-5499 (3000 values).
+  // Expected intersection: 2500-4999 (2500 elements).
+  {
+    auto khll1 = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_.get());
+    auto khll2 = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_.get());
+
+    for (int64_t i = 0; i < 5000; ++i) {
+      khll1->add(i, 100);
+    }
+
+    for (int64_t i = 2500; i < 5500; ++i) {
+      khll2->add(i, 100);
+    }
+
+    std::string serialized1(khll1->estimatedSerializedSize(), '\0');
+    khll1->serialize(serialized1.data());
+
+    std::string serialized2(khll2->estimatedSerializedSize(), '\0');
+    khll2->serialize(serialized2.data());
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(serialized1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(serialized2)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+
+    // Allow 5% error for approximation
+    auto actualResult = result->as<FlatVector<int64_t>>()->valueAt(0);
+    EXPECT_NEAR(actualResult, 2500, 2500 * 0.05);
+  }
+
+  {
+    auto khll = std::make_unique<
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>>(
+        allocator_.get());
+
+    for (int64_t i = 0; i < 5000; ++i) {
+      khll->add(i, 100);
+    }
+
+    std::string serialized(khll->estimatedSerializedSize(), '\0');
+    khll->serialize(serialized.data());
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(serialized)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(serialized)}, KHYPERLOGLOG());
+
+    auto result = evaluate(
+        "intersection_cardinality(c0, c1)", makeRowVector({input1, input2}));
+
+    auto actualResult = result->as<FlatVector<int64_t>>()->valueAt(0);
+    EXPECT_NEAR(actualResult, 5000, 5000 * 0.05);
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, uniquenessDistribution) {
+  auto serialized = createKHLL(
+      {{0, 0}, {1, 0}, {1, 1}, {2, 0}, {2, 1}, {3, 0}, {3, 1}, {3, 2}});
+  auto input =
+      makeFlatVector<StringView>({StringView(serialized)}, KHYPERLOGLOG());
+
+  // Uniqueness distribution with default histogram size of 4.
+  {
+    auto result =
+        evaluate("uniqueness_distribution(c0)", makeRowVector({input}));
+
+    EXPECT_FALSE(result->isNullAt(0));
+    EXPECT_EQ(result->type()->kind(), TypeKind::MAP);
+
+    auto mapVector = result->as<MapVector>();
+    auto mapSize = mapVector->sizeAt(0);
+    EXPECT_EQ(mapSize, 4);
+
+    auto resultMap = createResultMap(mapVector);
+
+    std::map<int64_t, double> expected;
+    for (int i = 1; i <= mapSize; ++i) {
+      expected[i] = 0;
+    }
+    expected[1] = 0.25;
+    expected[2] = 0.5;
+    expected[3] = 0.25;
+
+    EXPECT_EQ(resultMap, expected);
+  }
+
+  // Uniqueness distribution with custom histogram size.
+  {
+    auto histSize = makeFlatVector<int64_t>({128});
+    auto result = evaluate(
+        "uniqueness_distribution(c0, c1)", makeRowVector({input, histSize}));
+
+    EXPECT_FALSE(result->isNullAt(0));
+    EXPECT_EQ(result->type()->kind(), TypeKind::MAP);
+
+    auto mapVector = result->as<MapVector>();
+    auto mapSize = mapVector->sizeAt(0);
+    EXPECT_EQ(mapSize, 128);
+
+    auto resultMap = createResultMap(mapVector);
+
+    std::map<int64_t, double> expected;
+    for (int i = 1; i <= mapSize; ++i) {
+      expected[i] = 0;
+    }
+    expected[1] = 0.25;
+    expected[2] = 0.5;
+    expected[3] = 0.25;
+
+    EXPECT_EQ(resultMap, expected);
+  }
+
+  // Uniqueness distribution with empty KHLL. Since minhashSize is 0, the
+  // histogram size is 0 and the returned map is empty.
+  {
+    auto emptyKhll = createKHLL({});
+    auto emptyInput =
+        makeFlatVector<StringView>({StringView(emptyKhll)}, KHYPERLOGLOG());
+    auto result =
+        evaluate("uniqueness_distribution(c0)", makeRowVector({emptyInput}));
+
+    EXPECT_FALSE(result->isNullAt(0));
+    auto mapVector = result->as<MapVector>();
+    auto mapSize = mapVector->sizeAt(0);
+    EXPECT_EQ(mapSize, 0);
+  }
+
+  // Null inputs
+  {
+    auto nullKhll =
+        makeNullableFlatVector<StringView>({std::nullopt}, KHYPERLOGLOG());
+    auto result =
+        evaluate("uniqueness_distribution(c0)", makeRowVector({nullKhll}));
+    EXPECT_TRUE(result->isNullAt(0));
+    auto nullHistSize = makeNullableFlatVector<int64_t>({std::nullopt});
+    result = evaluate(
+        "uniqueness_distribution(c0, c1)",
+        makeRowVector({input, nullHistSize}));
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, jaccardIndex) {
+  // Jaccard index with identical sets.
+  {
+    auto khll = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({1.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Jaccard index with completely disjoint sets.
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+    auto khll2 = createKHLL({{100, 110}, {101, 111}, {102, 112}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Jaccard index with some overlapping elements.
+  {
+    auto khll1 = createKHLL({{0, 10}, {1, 11}, {2, 12}, {3, 13}, {4, 14}});
+    auto khll2 = createKHLL({{3, 13}, {4, 14}, {5, 15}, {6, 16}, {7, 17}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({0.2});
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    auto khll1 = createKHLL(
+        {{0, 10},
+         {1, 11},
+         {2, 12},
+         {3, 13},
+         {4, 14},
+         {5, 15},
+         {6, 16},
+         {7, 17},
+         {8, 18},
+         {9, 19}});
+    auto khll2 = createKHLL({{2, 12}, {3, 13}, {4, 14}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(khll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(khll2)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({0.6666666666666666});
+    assertEqualVectors(expected, result);
+  }
+
+  // Jaccard index with both sets empty. Jaccard index of two empty sets is
+  // defined as 1.0
+  {
+    auto emptyKhll1 = createKHLL({});
+    auto emptyKhll2 = createKHLL({});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(emptyKhll1)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(emptyKhll2)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({1.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Jaccard index with an empty and non empty set.
+  {
+    auto emptyKhll = createKHLL({});
+    auto nonEmptyKhll = createKHLL({{0, 10}, {1, 11}, {2, 12}});
+
+    auto input1 =
+        makeFlatVector<StringView>({StringView(emptyKhll)}, KHYPERLOGLOG());
+    auto input2 =
+        makeFlatVector<StringView>({StringView(nonEmptyKhll)}, KHYPERLOGLOG());
+
+    auto result =
+        evaluate("jaccard_index(c0, c1)", makeRowVector({input1, input2}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+
+    // Test in reverse order
+    result = evaluate("jaccard_index(c0, c1)", makeRowVector({input2, input1}));
+    assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(KHyperLogLogFunctionsTest, reidentificationPotential) {
+  // Different reidentification potential cases
+  {
+    auto khll = createKHLL({{0, 0}, {1, 0}, {2, 0}});
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({1.0});
+    assertEqualVectors(expected, result);
+  }
+
+  {
+    auto khll = createKHLL({
+        {0, 0},
+        {0, 1},
+        {0, 2},
+        {0, 3},
+        {0, 4}, // Value 0: 5 UIIs
+        {1, 0},
+        {1, 1},
+        {1, 2},
+        {1, 3}, // Value 1: 4 UIIs
+        {2, 0},
+        {2, 1},
+        {2, 2} // Value 2: 3 UIIs
+    });
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // 2 out of 3 values at risk.
+  {
+    auto khll = createKHLL({
+        {0, 0},
+        {0, 1}, // Value 0: 2 UIIs
+        {1, 0},
+        {1, 1},
+        {1, 2}, // Value 1: 3 UIIs
+        {2, 0} // Value 2: 1 UII
+    });
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.6666666666666666});
+    assertEqualVectors(expected, result);
+  }
+
+  // Reidentification potential with threshold of 0.
+  {
+    auto khll = createKHLL({{0, 0}, {1, 0}, {2, 0}});
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({0});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Reidentification potential with empty KHLL
+  {
+    auto emptyKhll = createKHLL({});
+    auto input =
+        makeFlatVector<StringView>({StringView(emptyKhll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Reidentification potential with single value with multiple UIIs.
+  {
+    auto khll = createKHLL({{0, 0}, {0, 1}, {0, 2}});
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, threshold}));
+    auto expected = makeFlatVector<double>({0.0});
+    assertEqualVectors(expected, result);
+  }
+
+  // Null inputs
+  {
+    auto nullKhll =
+        makeNullableFlatVector<StringView>({std::nullopt}, KHYPERLOGLOG());
+    auto threshold = makeFlatVector<int64_t>({2});
+
+    auto result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({nullKhll, threshold}));
+    EXPECT_TRUE(result->isNullAt(0));
+
+    auto khll = createKHLL({{0, 0}, {1, 0}});
+    auto input = makeFlatVector<StringView>({StringView(khll)}, KHYPERLOGLOG());
+    auto nullThreshold = makeNullableFlatVector<int64_t>({std::nullopt});
+    result = evaluate(
+        "reidentification_potential(c0, c1)",
+        makeRowVector({input, nullThreshold}));
+    EXPECT_TRUE(result->isNullAt(0));
+  }
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapAppendTest.cpp b/velox/functions/prestosql/tests/MapAppendTest.cpp
new file mode 100644
index 000000000000..5726fa13fac4
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapAppendTest.cpp
@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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 MapAppendTest : public test::FunctionBaseTest {};
+
+TEST_F(MapAppendTest, basicIntegerMap) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30}",
+          "{10:100, 20:200}",
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[4, 5]",
+          "[30, 40]",
+          "[1, 2]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[40, 50]",
+          "[300, 400]",
+          "[10, 20]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+      "{10:100, 20:200, 30:300, 40:400}",
+      "{1:10, 2:20}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, varcharKeyMap) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<std::string, int32_t>({
+          R"({"a": 1, "b": 2})",
+          R"({"x": 10})",
+      }),
+      makeArrayVectorFromJson<std::string>({
+          R"(["c", "d"])",
+          R"(["y", "z"])",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[3, 4]",
+          "[20, 30]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"a": 1, "b": 2, "c": 3, "d": 4})",
+      R"({"x": 10, "y": 20, "z": 30})",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, emptyArrays) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[]",
+          "[]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[]",
+          "[]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20}",
+      "{}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, nullValues) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[3, 4]",
+      }),
+      makeNullableArrayVector<int32_t>({
+          {std::nullopt, 40},
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:null, 4:40}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, duplicateKeyInNewKeys) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[3, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_append(c0, c1, c2)", data), "Duplicate key in keys array");
+}
+
+TEST_F(MapAppendTest, keyAlreadyExistsInMap) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_append(c0, c1, c2)", data),
+      "Key already exists in the map");
+}
+
+TEST_F(MapAppendTest, mismatchedArrayLengths) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[3, 4]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30]",
+      }),
+  });
+
+  VELOX_ASSERT_THROW(
+      evaluate("map_append(c0, c1, c2)", data),
+      "Keys and values arrays must have the same length");
+}
+
+TEST_F(MapAppendTest, floatKeys) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<float, int32_t>({
+          "{1.5:10, 2.5:20}",
+      }),
+      makeArrayVectorFromJson<float>({
+          "[3.5, 4.5]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<float, int32_t>({
+      "{1.5:10, 2.5:20, 3.5:30, 4.5:40}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, booleanKeys) {
+  auto data = makeRowVector({
+      makeMapVector<bool, int32_t>({{{true, 10}}}),
+      makeArrayVector<bool>({{false}}),
+      makeArrayVector<int32_t>({{20}}),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVector<bool, int32_t>({{{true, 10}, {false, 20}}});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, nullKeysIgnored) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20}",
+      }),
+      makeNullableArrayVector<int64_t>({
+          {3, std::nullopt, 4},
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[30, 40, 50]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:50}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, emptyMapWithNewEntries) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[1, 2, 3]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[10, 20, 30]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, complexValueTypes) {
+  // Create value arrays for the map
+  auto inputMapValues = makeArrayVectorFromJson<int32_t>({
+      "[1, 2]",
+      "[3, 4]",
+  });
+
+  // Create a map with keys [1, 2] and values [[1,2], [3,4]]
+  auto inputMap =
+      makeMapVector({0}, makeFlatVector<int64_t>({1, 2}), inputMapValues);
+
+  // Keys to append: [3, 4] (single row with 2 keys)
+  auto newKeys = makeArrayVectorFromJson<int64_t>({
+      "[3, 4]",
+  });
+
+  // Values to append: [[5,6], [7,8]] (single row with 2 array values)
+  auto newValues = makeNestedArrayVectorFromJson<int32_t>({
+      "[[5, 6], [7, 8]]",
+  });
+
+  auto data = makeRowVector({inputMap, newKeys, newValues});
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expectedValues = makeArrayVectorFromJson<int32_t>({
+      "[1, 2]",
+      "[3, 4]",
+      "[5, 6]",
+      "[7, 8]",
+  });
+
+  auto expected =
+      makeMapVector({0}, makeFlatVector<int64_t>({1, 2, 3, 4}), expectedValues);
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, largeMap) {
+  // Create a map with 10 entries and append 3 more
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 3:30, 4:40, 5:50, 6:60, 7:70, 8:80, 9:90, 10:100}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[11, 12, 13]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[110, 120, 130]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:30, 4:40, 5:50, 6:60, 7:70, 8:80, 9:90, 10:100, 11:110, 12:120, 13:130}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, timestampKeys) {
+  auto data = makeRowVector({
+      makeMapVector<Timestamp, int32_t>(
+          {{{Timestamp(1, 0), 10}, {Timestamp(2, 0), 20}}}),
+      makeArrayVector<Timestamp>({{Timestamp(3, 0), Timestamp(4, 0)}}),
+      makeArrayVector<int32_t>({{30, 40}}),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVector<Timestamp, int32_t>(
+      {{{Timestamp(1, 0), 10},
+        {Timestamp(2, 0), 20},
+        {Timestamp(3, 0), 30},
+        {Timestamp(4, 0), 40}}});
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapAppendTest, preserveMapOrder) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<int64_t, int32_t>({
+          "{5:50, 3:30, 1:10}",
+      }),
+      makeArrayVectorFromJson<int64_t>({
+          "[2, 4]",
+      }),
+      makeArrayVectorFromJson<int32_t>({
+          "[20, 40]",
+      }),
+  });
+
+  auto result = evaluate("map_append(c0, c1, c2)", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{5:50, 3:30, 1:10, 2:20, 4:40}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapExceptTest.cpp b/velox/functions/prestosql/tests/MapExceptTest.cpp
new file mode 100644
index 000000000000..12ad0ddd7c2b
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapExceptTest.cpp
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/TimestampWithTimeZoneType.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapExceptTest : 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>({
+        "{3:null, 4:40, 6:60}",
+        "{}",
+    });
+    auto result = evaluate("map_except(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>({
+        "{3:null, 4:40, 6:60}",
+        "{}",
+    });
+    result = evaluate("map_except(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]]",
+        }),
+    });
+    // Row 0: Exclude [{1, NaN, 3}, {4, 5}] from [{1, NaN, 3}: 1, {4, 5}: 2] →
+    // empty Row 1: Exclude [[1, 2, 3], [NaN, 3]] from [{kSNaN, 3}: 3, {1, 2}:
+    // 4]
+    //        [NaN, 3] matches {kSNaN, 3} (NaN equality), so exclude it
+    //        [1, 2, 3] does NOT match {1, 2}, so keep {1, 2}: 4
+    expected = makeMapVector(
+        {0, 0}, makeArrayVector<T>({{1, 2}}), makeFlatVector<int32_t>({4}));
+
+    result = evaluate("map_except(c0, c1)", data);
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(MapExceptTest, 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_except(c0, array_constructor(1, 3, 5))", data);
+
+  auto expected = makeMapVectorFromJson<int64_t, int32_t>({
+      "{2:20, 4:40, 6:60}",
+      "{2:20, 4:40}",
+      "{}",
+      "{2:20, 4:40, 6:60}",
+  });
+
+  assertEqualVectors(expected, result);
+
+  // Non-constant keys.
+  result = evaluate("map_except(c0, c1)", data);
+  assertEqualVectors(expected, result);
+
+  // Empty list of keys. Expect all map entries returned.
+  result = evaluate("map_except(c0, array_constructor()::bigint[])", data);
+
+  expected = 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}",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapExceptTest, varcharKey) {
+  auto data = makeRowVector({
+      makeMapVectorFromJson<std::string, int32_t>({
+          R"({"apple": 1, "banana": 2, "Cucurbitaceae": null, "date": 4, "eggplant": 5, "fig": 6})",
+          R"({"banana": 2, "orange": 4})",
+          R"({"banana": 2, "fig": 4, "date": 5})",
+      }),
+      makeArrayVectorFromJson<std::string>({
+          R"(["apple", "Cucurbitaceae", "fig"])",
+          R"(["apple", "Cucurbitaceae", "date", "eggplant"])",
+          R"(["fig"])",
+      }),
+  });
+
+  // Constant keys.
+  auto result = evaluate(
+      "map_except(c0, array_constructor('apple', 'some very looooong name', 'fig', 'Cucurbitaceae'))",
+      data);
+
+  auto expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"banana": 2, "date": 4, "eggplant": 5})",
+      R"({"banana": 2, "orange": 4})",
+      R"({"banana": 2, "date": 5})",
+  });
+
+  assertEqualVectors(expected, result);
+
+  // Non-constant keys.
+  result = evaluate("map_except(c0, c1)", data);
+  assertEqualVectors(expected, result);
+
+  // Empty list of keys. Expect all map entries returned.
+  result = evaluate("map_except(c0, array_constructor()::varchar[])", data);
+
+  expected = makeMapVectorFromJson<std::string, int32_t>({
+      R"({"apple": 1, "banana": 2, "Cucurbitaceae": null, "date": 4, "eggplant": 5, "fig": 6})",
+      R"({"banana": 2, "orange": 4})",
+      R"({"banana": 2, "fig": 4, "date": 5})",
+  });
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapExceptTest, 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_except(c0, c1)", data);
+
+  auto expected = makeMapVector(
+      {0, 1},
+      makeArrayVectorFromJson<int32_t>({
+          "[4, 5]",
+          "[1, 2]",
+      }),
+      makeFlatVector<std::string>({"orange", "date"}));
+
+  assertEqualVectors(expected, result);
+}
+
+// Verify that complex keys with null descendants are handled gracefully.
+// When comparing two keys that both contain nulls, the comparison returns
+// "indeterminate" which we treat as not equal (consistent with SQL semantics
+// where NULL != NULL).
+TEST_F(MapExceptTest, complexKeyWithNullElements) {
+  // Map with key [1, 2] and exclusion keys [[1, null], [1, null]].
+  // The key [1, 2] does not match [1, null], so it should be kept in the
+  // result.
+  auto data = makeRowVector({
+      makeMapVector(
+          {0},
+          makeArrayVectorFromJson<int32_t>({
+              "[1, 2]",
+          }),
+          makeFlatVector<int32_t>({10})),
+      makeNestedArrayVectorFromJson<int32_t>({
+          "[[1, null], [1, null]]",
+      }),
+  });
+
+  auto result = evaluate("map_except(c0, c1)", data);
+
+  // The key [1, 2] doesn't match [1, null] (null != 2), so it should remain.
+  auto expected = makeMapVector(
+      {0},
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2]",
+      }),
+      makeFlatVector<int32_t>({10}));
+
+  assertEqualVectors(expected, result);
+
+  // Test case from the bug: the hash set compares two null-containing keys
+  // during collision resolution. Previously this threw an exception due to
+  // inconsistent behavior depending on hash bucket count from previous rows.
+  // Now it should succeed by treating null comparisons as not equal.
+  data = makeRowVector({
+      makeMapVector(
+          {0, 2},
+          makeArrayVectorFromJson<int32_t>({
+              "[1, 2]",
+              "[3, 4]",
+              "[5, 6]",
+              "[7, 8]",
+          }),
+          makeFlatVector<int32_t>({10, 20, 30, 40})),
+      makeNestedArrayVectorFromJson<int32_t>({
+          "[[1, null], [1, null]]",
+          "[[null, 2], [null, 3]]",
+      }),
+  });
+
+  result = evaluate("map_except(c0, c1)", data);
+
+  // Row 0: [1, 2] and [3, 4] don't match [1, null] (different keys).
+  // Row 1: [5, 6] and [7, 8] don't match [null, 2] or [null, 3].
+  expected = makeMapVector(
+      {0, 2},
+      makeArrayVectorFromJson<int32_t>({
+          "[1, 2]",
+          "[3, 4]",
+          "[5, 6]",
+          "[7, 8]",
+      }),
+      makeFlatVector<int32_t>({10, 20, 30, 40}));
+
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapExceptTest, floatNaNs) {
+  testFloatNaNs<float>();
+  testFloatNaNs<double>();
+}
+
+TEST_F(MapExceptTest, timestampWithTimeZone) {
+  const auto keys = makeFlatVector<int64_t>(
+      {pack(1, 1),
+       pack(2, 2),
+       pack(3, 3),
+       pack(4, 4),
+       pack(5, 5),
+       pack(6, 6),
+       pack(1, 7),
+       pack(2, 8),
+       pack(4, 9),
+       pack(5, 10)},
+      TIMESTAMP_WITH_TIME_ZONE());
+  const auto values = makeNullableFlatVector<int32_t>(
+      {10, 20, std::nullopt, 40, 50, 60, 70, 80, 90, 100});
+  const auto maps = makeMapVector({0, 6, 10}, keys, values);
+
+  // For map_except, we want the inverse of map_subset.
+  // Test map with TimestampWithTimeZone keys and constant second arg.
+  // The lookup is [pack(1, 1), pack(3, 2), pack(5, 3)].
+  // These match pack(1, 1), pack(3, 3), pack(5, 5) from the maps.
+  const auto constLookup = BaseVector::wrapInConstant(
+      2,
+      0,
+      makeArrayVector(
+          {0},
+          makeFlatVector<int64_t>(
+              {pack(1, 1), pack(3, 2), pack(5, 3)},
+              TIMESTAMP_WITH_TIME_ZONE())));
+  const auto exceptKeys = makeFlatVector<int64_t>(
+      {pack(2, 2), pack(4, 4), pack(6, 6), pack(2, 8), pack(4, 9)},
+      TIMESTAMP_WITH_TIME_ZONE());
+  const auto exceptValues =
+      makeNullableFlatVector<int32_t>({20, 40, 60, 80, 90});
+  const auto expected = makeMapVector({0, 3, 5}, exceptKeys, exceptValues);
+  auto result =
+      evaluate("map_except(c0, c1)", makeRowVector({maps, constLookup}));
+
+  assertEqualVectors(expected, result);
+
+  // Test map with TimestampWithTimeZone keys and non-constant second arg.
+  const auto lookupKeys = makeFlatVector<int64_t>(
+      {pack(1, 1),
+       pack(3, 3),
+       pack(5, 5),
+       pack(1, 10),
+       pack(3, 12),
+       pack(5, 13),
+       pack(7, 14)},
+      TIMESTAMP_WITH_TIME_ZONE());
+  const auto lookup = makeArrayVector({0, 3, 7}, lookupKeys);
+
+  result = evaluate("map_except(c0, c1)", makeRowVector({maps, lookup}));
+  assertEqualVectors(expected, result);
+
+  // Test map with TimestampWithTimeZone wrapped in a complex type as keys.
+  const auto mapsWithRowKeys =
+      makeMapVector({0, 6, 10}, makeRowVector({keys}), values);
+  const auto lookupWithRowKeys =
+      makeArrayVector({0, 3, 7}, makeRowVector({lookupKeys}));
+  const auto expectedWithRowKeys =
+      makeMapVector({0, 3, 5}, makeRowVector({exceptKeys}), exceptValues);
+
+  result = evaluate(
+      "map_except(c0, c1)",
+      makeRowVector({mapsWithRowKeys, lookupWithRowKeys}));
+  assertEqualVectors(expectedWithRowKeys, result);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapFilterTest.cpp b/velox/functions/prestosql/tests/MapFilterTest.cpp
index 61ca65b9f495..1cdc5bafab0c 100644
--- a/velox/functions/prestosql/tests/MapFilterTest.cpp
+++ b/velox/functions/prestosql/tests/MapFilterTest.cpp
@@ -70,24 +70,49 @@ class MapFilterTest : public functions::test::FunctionBaseTest {
 };
 
 TEST_F(MapFilterTest, filter) {
-  auto rowType =
-      ROW({"long_val", "map_val"}, {BIGINT(), MAP(BIGINT(), INTEGER())});
-  auto data = std::static_pointer_cast<RowVector>(
-      BatchMaker::createBatch(rowType, 1'000, *execCtx_.pool()));
-
-  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(),
-      *result,
-      [&](SimpleVector<int64_t>* keys,
-          SimpleVector<int32_t>* values,
-          vector_size_t elementRow,
-          vector_size_t row) {
-        return cutoff->isNullAt(row) || keys->isNullAt(elementRow)
-            ? false
-            : keys->valueAt(elementRow) > cutoff->valueAt(row);
-      });
+  {
+    auto rowType =
+        ROW({"long_val", "map_val"}, {BIGINT(), MAP(BIGINT(), INTEGER())});
+    auto data = std::static_pointer_cast<RowVector>(
+        BatchMaker::createBatch(rowType, 1'000, *execCtx_.pool()));
+
+    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(),
+        *result,
+        [&](SimpleVector<int64_t>* keys,
+            SimpleVector<int32_t>* values,
+            vector_size_t elementRow,
+            vector_size_t row) {
+          return cutoff->isNullAt(row) || keys->isNullAt(elementRow)
+              ? false
+              : keys->valueAt(elementRow) > cutoff->valueAt(row);
+        });
+  }
+  {
+    const auto rowType = ROW({"map_val"}, {MAP(BIGINT(), INTEGER())});
+    const auto map = makeMapVectorFromJson<int64_t, int32_t>(
+        {"{1: \"1\", 2: \"2\", 5: \"5\"}",
+         "{3: \"3\", 7: \"7\"}",
+         "{4: \"4\", 5: \"5\"}",
+         "{6: \"6\", 7: \"7\"}",
+         "{1: \"1\", 8: \"8\"}",
+         "{4: \"4\", 9: \"9\"}"});
+    const auto data = makeRowVector({"map_val"}, {map});
+    const auto result = evaluate(
+        "map_filter(map_val, (k, v) -> (contains(ARRAY[1,2,7], k))) as map_val",
+        data);
+    const auto expectedMap = makeMapVectorFromJson<int64_t, int32_t>(
+        {"{1: \"1\", 2: \"2\"}",
+         "{7: \"7\"}",
+         "{}",
+         "{7: \"7\"}",
+         "{1: \"1\"}",
+         "{}"});
+    assertEqualVectors(expectedMap, result);
+  }
 }
 
 TEST_F(MapFilterTest, empty) {
@@ -251,6 +276,324 @@ TEST_F(MapFilterTest, lambdaSelectivityVector) {
   assertEqualVectors(expected, result[0]);
 }
 
+TEST_F(MapFilterTest, fuzzFlatMap) {
+  auto options = VectorFuzzer::Options();
+  options.allowFlatMapVector = true;
+  VectorFuzzer fuzzer(options, execCtx_.pool());
+  constexpr vector_size_t size = 100;
+  auto num_iterations = 100;
+  while (num_iterations--) {
+    auto flatMap = fuzzer.fuzzFlatMap(INTEGER(), INTEGER(), size);
+
+    // Convert to a regular map vector.
+    auto map = flatMap->as<FlatMapVector>()->toMapVector();
+
+    // Wrap in a row vector for evaluation.
+    auto dataFlat = makeRowVector({"c0"}, {flatMap});
+    auto dataMap = makeRowVector({"c0"}, {map});
+
+    // Try a few different filters.
+    std::vector<std::string> filters = {
+        "(k, v) -> (v IS NOT NULL)",
+        "(k, v) -> (k % 2 = 0)",
+        "(k, v) -> (v > 50)",
+        "(k, v) -> (k < 5 OR v IS NULL)",
+    };
+
+    for (const auto& filter : filters) {
+      auto expr = fmt::format("map_filter(c0, {})", filter);
+      auto resultFlat = evaluate(expr, dataFlat);
+      auto resultMap = evaluate(expr, dataMap);
+      assertEqualVectors(resultMap, resultFlat);
+    }
+  }
+}
+
+TEST_F(MapFilterTest, fromFlatMapEncodings) {
+  // Case 1: Verify value filter
+  assertEqualVectors(
+      makeFlatMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 4:40, 5:50, 6:60}",
+      }),
+      evaluate(
+          "map_filter(c0, (k, v) -> (v IS NOT NULL))",
+          makeRowVector({
+              makeFlatMapVectorFromJson<int64_t, int32_t>({
+                  "{1:10, 2:20, 3:null, 4:40, 5:50, 6:60}",
+              }),
+          })));
+  assertEqualVectors(
+      makeFlatMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 4:40}",
+          "{}",
+          "{2:20}",
+      }),
+      evaluate(
+          "map_filter(c0, (k, v) -> (v IS NOT NULL))",
+          makeRowVector({
+              makeFlatMapVectorFromJson<int64_t, int32_t>({
+                  "{1:10, 2:20, 3:null, 4:40, 5:50, 6:null}",
+                  "{1:10, 2:null, 4:40, 5:null}",
+                  "{}",
+                  "{2:20, 4:null, 6:null}",
+              }),
+          })));
+  assertEqualVectors(
+      makeFlatMapVectorFromJson<int64_t, int32_t>({
+          "{4:40, 5:50}",
+          "{4:40}",
+          "{}",
+          "{}",
+      }),
+      evaluate(
+          "map_filter(c0, (k, v) -> (v > 30))",
+          makeRowVector({
+              makeFlatMapVectorFromJson<int64_t, int32_t>({
+                  "{1:10, 2:20, 3:null, 4:40, 5:50, 6:null}",
+                  "{1:10, 2:null, 4:40, 5:null}",
+                  "{}",
+                  "{2:20, 4:null, 6:null}",
+              }),
+          })));
+
+  // Case 2: Verify key filter
+  assertEqualVectors(
+      makeFlatMapVectorFromJson<int64_t, int32_t>({
+          "{4:40, 5:50, 6:null}",
+          "{4:40, 5:null}",
+          "{}",
+          "{4:null, 6:null}",
+      }),
+      evaluate(
+          "map_filter(c0, (k, v) -> (k > 3))",
+          makeRowVector({
+              makeFlatMapVectorFromJson<int64_t, int32_t>({
+                  "{1:10, 2:20, 3:null, 4:40, 5:50, 6:null}",
+                  "{1:10, 2:null, 4:40, 5:null}",
+                  "{}",
+                  "{2:20, 4:null, 6:null}",
+              }),
+          })));
+
+  // Case 3: Verify key and value filter
+  assertEqualVectors(
+      makeFlatMapVectorFromJson<int64_t, int32_t>({
+          "{4:40, 5:50}",
+          "{4:40}",
+          "{}",
+          "{}",
+      }),
+      evaluate(
+          "map_filter(c0, (k, v) -> (k > 3 AND v is NOT NULL))",
+          makeRowVector({
+              makeFlatMapVectorFromJson<int64_t, int32_t>({
+                  "{1:10, 2:20, 3:null, 4:40, 5:50, 6:null}",
+                  "{1:10, 2:null, 4:40, 5:null}",
+                  "{}",
+                  "{2:20, 4:null, 6:null}",
+              }),
+          })));
+  assertEqualVectors(
+      makeFlatMapVectorFromJson<int64_t, int32_t>({
+          "{}",
+          "{}",
+          "{}",
+          "{}",
+      }),
+      evaluate(
+          "map_filter(c0, (k, v) -> (k > 3 AND v < 30))",
+          makeRowVector({
+              makeFlatMapVectorFromJson<int64_t, int32_t>({
+                  "{1:10, 2:20, 3:null, 4:40, 5:50, 6:null}",
+                  "{1:10, 2:null, 4:40, 5:null}",
+                  "{}",
+                  "{2:20, 4:null, 6:null}",
+              }),
+          })));
+}
+
+TEST_F(MapFilterTest, fromFlatMapEncodingsWrappedInDictionary) {
+  auto input = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:null, 4:40, 5:50}",
+      "{1:10, 2:20, 3:null, 4:40, 5:50}",
+      "{1:10, 2:null, 4:40, 5:null}",
+      "{}",
+      "{2:20, 4:null, 5:null}",
+      "{2:20, 4:null, 5:50}",
+      "{1:10, 4:null, 5:null}",
+      "{2:20, 3:30, 5:null}",
+      "{}",
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+  auto expected = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{1:10, 2:20, 4:40, 5:50}",
+      "{1:10, 4:40}",
+      "{}",
+      "{2:20}",
+      "{2:20, 5:50}",
+      "{1:10}",
+      "{2:20, 3:30}",
+      "{}",
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+
+  auto same = [](vector_size_t row) { return row; };
+  auto scattered = [](auto row) { return (row * 17 + 3) % 10; };
+
+  // Flattening handled by preprocessing peeling logic
+  assertEqualVectors(
+      expected,
+      evaluate(
+          "map_filter(c0, (k, v) -> (v IS NOT NULL))",
+          makeRowVector({BaseVector::wrapInDictionary(
+              nullptr,
+              makeIndices(input->size(), same),
+              input->size(),
+              input)})));
+
+  // Flattened internally by our filter function. This will test our ability to
+  // filter wrapped flat maps and preserve their indices. We will use our
+  // scattered function above to produce shuffled indices. The second assert
+  // uses the same function but half the indices to verify our logic on length
+  // mismatched dictionary indices
+  assertEqualVectors(
+      wrapInDictionary(
+          makeIndices(expected->size(), scattered), expected->size(), expected),
+      evaluate(
+          "map_filter(c1, (k, v) -> (v IS NOT NULL and c0 is not null))",
+          makeRowVector(
+              {makeFlatVector<int32_t>(input->size(), same),
+               wrapInDictionary(
+                   makeIndices(input->size(), scattered),
+                   input->size(),
+                   input)})));
+  assertEqualVectors(
+      wrapInDictionary(
+          makeIndices(expected->size() / 2, scattered),
+          expected->size() / 2,
+          expected),
+      evaluate(
+          "map_filter(c1, (k, v) -> (v IS NOT NULL and c0 is not null))",
+          makeRowVector(
+              {makeFlatVector<int32_t>(input->size() / 2, same),
+               wrapInDictionary(
+                   makeIndices(input->size() / 2, scattered),
+                   input->size() / 2,
+                   input)})));
+  assertEqualVectors(
+      wrapInDictionary(
+          makeIndices(expected->size() / 2, scattered),
+          expected->size() / 2,
+          makeFlatMapVectorFromJson<int64_t, int32_t>({
+              "{4:40, 5:50}",
+              "{4:40, 5:50}",
+              "{4:40}",
+              "{}",
+              "{}",
+              "{5:50}",
+              "{}",
+              "{}",
+              "{}",
+              "{4:40, 5:50}",
+          })),
+      evaluate(
+          "map_filter(c1, (k, v) -> (v IS NOT NULL and v > 30 and c0 is not null))",
+          makeRowVector(
+              {makeFlatVector<int32_t>(input->size() / 2, same),
+               wrapInDictionary(
+                   makeIndices(input->size() / 2, scattered),
+                   input->size() / 2,
+                   input)})));
+  assertEqualVectors(
+      wrapInDictionary(
+          makeIndices(expected->size() / 2, scattered),
+          expected->size() / 2,
+          makeFlatMapVectorFromJson<int64_t, int32_t>({
+              "{5:50}",
+              "{5:50}",
+              "{}",
+              "{}",
+              "{}",
+              "{5:50}",
+              "{}",
+              "{}",
+              "{}",
+              "{5:50}",
+          })),
+      evaluate(
+          "map_filter(c1, (k, v) -> (v IS NOT NULL and v > 30 and k > 4 and c0 is not null))",
+          makeRowVector(
+              {makeFlatVector<int32_t>(input->size() / 2, same),
+               wrapInDictionary(
+                   makeIndices(input->size() / 2, scattered),
+                   input->size() / 2,
+                   input)})));
+}
+
+TEST_F(MapFilterTest, fromFlatMapEncodingsWrappedInConstant) {
+  assertEqualVectors(
+      makeFlatMapVectorFromJson<int64_t, int32_t>({
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+          "{1:10, 2:20, 4:40, 5:50}",
+      }),
+      evaluate(
+          "map_filter(c0, (k, v) -> (v IS NOT NULL))",
+          makeRowVector({BaseVector::wrapInConstant(
+              10,
+              0,
+              makeFlatMapVectorFromJson<int64_t, int32_t>({
+                  "{1:10, 2:20, 3:null, 4:40, 5:50}",
+                  "{1:10, 2:20, 3:null, 4:40, 5:50}",
+                  "{1:10, 2:null, 4:40, 5:null}",
+                  "{}",
+                  "{2:20, 4:null, 5:null}",
+                  "{2:20, 4:null, 5:50}",
+                  "{1:10, 4:null, 5:null}",
+                  "{2:20, 3:30, 5:null}",
+                  "{}",
+                  "{1:10, 2:20, 3:30, 4:40, 5:50}",
+              }))})));
+}
+
+TEST_F(MapFilterTest, fromFlatMapEncodingsWithNullInMaps) {
+  auto distinctKeys = makeFlatVector<int32_t>({1, 2, 3});
+  std::vector<VectorPtr> mapValues(distinctKeys->size());
+  mapValues[0] = makeFlatVector<int32_t>({10, 10, 10});
+  mapValues[1] = makeFlatVector<int32_t>({20, 20, 20});
+  mapValues[2] = makeFlatVector<int32_t>({30, 30, 30});
+  std::vector<BufferPtr> inMaps(distinctKeys->size());
+  inMaps[1] =
+      AlignedBuffer::allocate<bool>(distinctKeys->size(), pool_.get(), 0);
+  FlatMapVectorPtr flatMap = std::make_shared<FlatMapVector>(
+      pool_.get(),
+      MAP(INTEGER(), INTEGER()),
+      nullptr,
+      distinctKeys->size(),
+      distinctKeys,
+      mapValues,
+      inMaps);
+
+  // Will fail without inMap null check during
+  // MapFilterFunction::buildInMapSelectivityVector
+  assertEqualVectors(
+      makeFlatMapVectorFromJson<int32_t, int32_t>({
+          "{1:10, 3:30}",
+          "{1:10, 3:30}",
+          "{1:10, 3:30}",
+      }),
+      evaluate("map_filter(c0, (k, v) -> true)", makeRowVector({flatMap})));
+}
+
 TEST_F(MapFilterTest, try) {
   auto data = makeRowVector({
       makeMapVector<int64_t, int64_t>({
diff --git a/velox/functions/prestosql/tests/MapIntersectTest.cpp b/velox/functions/prestosql/tests/MapIntersectTest.cpp
new file mode 100644
index 000000000000..9c2555ea7809
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapIntersectTest.cpp
@@ -0,0 +1,356 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapIntersectTest : public test::FunctionBaseTest {
+ protected:
+  void testMapIntersect(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(MapIntersectTest, integerMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}},
+      {{5, 50}, {6, 60}, {7, 70}},
+      {},
+      {{8, 80}, {9, 90}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 3},
+      {5, 7, 8},
+      {1, 2},
+      {8, 9, 10},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {3, 30}},
+      {{5, 50}, {7, 70}},
+      {},
+      {{8, 80}, {9, 90}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, constantKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{1, 100}, {2, 200}, {3, 300}},
+      {{1, 1000}, {2, 2000}, {3, 3000}, {4, 4000}, {5, 5000}},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {3, 30}, {5, 50}},
+      {{1, 100}, {3, 300}},
+      {{1, 1000}, {3, 3000}, {5, 5000}},
+  });
+
+  auto result = evaluate(
+      "map_intersect(c0, array_constructor(cast(1 as integer), cast(3 as integer), cast(5 as integer)))",
+      makeRowVector({inputMap}));
+  assertEqualVectors(expected, result);
+}
+
+TEST_F(MapIntersectTest, nonExistentKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {4, 5, 6},
+      {1, 2, 3},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {},
+      {},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, duplicateKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}, {8, 80}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 1, 2, 2, 3},
+      {6, 6, 7, 7},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{6, 60}, {7, 70}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, emptyKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {},
+      {},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, emptyMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {},
+      {},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {4, 5},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {},
+      {},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, nullKeysInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}, {8, 80}},
+  });
+
+  auto keys = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3, std::nullopt, 5},
+      {std::nullopt, 7, std::nullopt},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {3, 30}, {5, 50}},
+      {{7, 70}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, stringMap) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"apple", 1}, {"banana", 2}, {"cherry", 3}, {"date", 4}},
+      {{"hello", 10}, {"world", 20}},
+      {{"a", 100}, {"b", 200}, {"c", 300}, {"d", 400}, {"e", 500}},
+  });
+
+  auto keys = makeArrayVector<StringView>({
+      {"banana", "date", "apple"},
+      {"hello", "world", "foo"},
+      {"a", "c", "e"},
+  });
+
+  auto expected = makeMapVector<StringView, int32_t>({
+      {{"apple", 1}, {"banana", 2}, {"date", 4}},
+      {{"hello", 10}, {"world", 20}},
+      {{"a", 100}, {"c", 300}, {"e", 500}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, floatMap) {
+  auto inputMap = makeMapVector<float, float>({
+      {{1.1f, 10.1f}, {2.2f, 20.2f}, {3.3f, 30.3f}, {4.4f, 40.4f}},
+      {{5.5f, 50.5f}, {6.6f, 60.6f}, {7.7f, 70.7f}},
+  });
+
+  auto keys = makeArrayVector<float>({
+      {1.1f, 3.3f, 4.4f},
+      {5.5f, 6.6f, 8.8f},
+  });
+
+  auto expected = makeMapVector<float, float>({
+      {{1.1f, 10.1f}, {3.3f, 30.3f}, {4.4f, 40.4f}},
+      {{5.5f, 50.5f}, {6.6f, 60.6f}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, booleanMap) {
+  auto inputMap = makeMapVector<bool, int32_t>({
+      {{true, 1}, {false, 0}},
+      {{true, 10}},
+      {{false, 100}},
+  });
+
+  auto keys = makeArrayVector<bool>({
+      {true},
+      {true, false},
+      {true, false},
+  });
+
+  auto expected = makeMapVector<bool, int32_t>({
+      {{true, 1}},
+      {{true, 10}},
+      {{false, 100}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, complexValueMap) {
+  // Create value arrays that will be used in the maps
+  auto valueArrays = makeArrayVector<int32_t>({
+      {1, 2}, // value for key [1, 2] in map 0
+      {3, 4, 5}, // value for key [3, 4] in map 0
+      {6}, // value for key [5, 6] in map 1
+      {7, 8, 9, 10}, // value for key [7, 8] in map 1
+  });
+
+  // Create input map with 2 maps:
+  // Map 0: {[1,2] => [1,2], [3,4] => [3,4,5]}
+  // Map 1: {[5,6] => [6], [7,8] => [7,8,9,10]}
+  auto inputMap = makeMapVector(
+      {0, 2, 4},
+      makeArrayVector<int32_t>({{1, 2}, {3, 4}, {5, 6}, {7, 8}}),
+      valueArrays);
+
+  // Keys to filter (array of arrays):
+  // Map 0: keep entries with key [1,2]
+  // Map 1: keep entries with key [5,6]
+  auto keys =
+      makeArrayVector({0, 1, 2}, makeArrayVector<int32_t>({{1, 2}, {5, 6}}));
+
+  // Expected output:
+  // Map 0: {[1,2] => [1,2]}
+  // Map 1: {[5,6] => [6]}
+  auto expectedValueArrays = makeArrayVector<int32_t>({
+      {1, 2}, // value for key [1, 2] in map 0
+      {6}, // value for key [5, 6] in map 1
+  });
+
+  auto expected = makeMapVector(
+      {0, 1, 2},
+      makeArrayVector<int32_t>({{1, 2}, {5, 6}}),
+      expectedValueArrays);
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, nullArguments) {
+  auto inputMap =
+      makeMapVector<int32_t, int32_t>({{{1, 10}, {2, 20}, {3, 30}}});
+  auto keys = makeArrayVector<int32_t>({{1, 2}});
+
+  auto nullMap =
+      BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool());
+  auto nullKeys = BaseVector::createNullConstant(ARRAY(INTEGER()), 1, pool());
+
+  auto result1 =
+      evaluate("map_intersect(c0, c1)", makeRowVector({nullMap, keys}));
+  auto expected1 =
+      BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool());
+  assertEqualVectors(expected1, result1);
+
+  auto result2 =
+      evaluate("map_intersect(c0, c1)", makeRowVector({inputMap, nullKeys}));
+  auto expected2 =
+      BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool());
+  assertEqualVectors(expected2, result2);
+
+  auto result3 =
+      evaluate("map_intersect(c0, c1)", makeRowVector({nullMap, nullKeys}));
+  auto expected3 =
+      BaseVector::createNullConstant(MAP(INTEGER(), INTEGER()), 1, pool());
+  assertEqualVectors(expected3, result3);
+}
+
+TEST_F(MapIntersectTest, partialMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}, {8, 80}, {9, 90}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 3, 5, 7, 9},
+      {6, 8, 10, 12},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {3, 30}, {5, 50}},
+      {{6, 60}, {8, 80}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, singleElementMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}},
+      {{2, 20}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {2},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}},
+      {{2, 20}},
+  });
+
+  testMapIntersect("map_intersect(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapIntersectTest, basicTest) {
+  auto inputMap = makeMapVector<int32_t, int32_t>(
+      {{{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}}});
+  auto keys = makeArrayVector<int32_t>({{1, 3, 5}});
+  auto expected =
+      makeMapVector<int32_t, int32_t>({{{1, 10}, {3, 30}, {5, 50}}});
+
+  auto result =
+      evaluate("map_intersect(c0, c1)", makeRowVector({inputMap, keys}));
+  assertEqualVectors(expected, result);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapKeysOverlapTest.cpp b/velox/functions/prestosql/tests/MapKeysOverlapTest.cpp
new file mode 100644
index 000000000000..776e0183e84d
--- /dev/null
+++ b/velox/functions/prestosql/tests/MapKeysOverlapTest.cpp
@@ -0,0 +1,451 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class MapKeysOverlapTest : public test::FunctionBaseTest {
+ protected:
+  void testMapKeysOverlap(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(MapKeysOverlapTest, basicIntegerKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+      {{6, 60}, {7, 70}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 5},
+      {4},
+      {8, 9},
+  });
+
+  auto expected = makeFlatVector<bool>({true, true, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, stringKeys) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"a", 1}, {"b", 2}, {"c", 3}},
+      {{"x", 10}, {"y", 20}},
+      {{"p", 100}, {"q", 200}},
+  });
+
+  auto keys = makeArrayVector<StringView>({
+      {"a", "d"},
+      {"z"},
+      {"p"},
+  });
+
+  auto expected = makeFlatVector<bool>({true, false, true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, emptyMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {},
+      {{1, 10}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 2},
+      {1},
+  });
+
+  auto expected = makeFlatVector<bool>({false, true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, emptyKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+      {{3, 30}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {},
+      {},
+  });
+
+  auto expected = makeFlatVector<bool>({false, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, noMatchingKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {4, 5, 6},
+      {1, 2, 3},
+  });
+
+  auto expected = makeFlatVector<bool>({false, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, allKeysMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, partialMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {3, 5, 6, 7},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, nullValuesInMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, std::nullopt}, {3, 30}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {2},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, nullKeysInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  std::vector<std::vector<std::optional<int32_t>>> keyData = {
+      {std::nullopt, 4, 5},
+  };
+  auto keys = makeNullableArrayVector<int32_t>(keyData);
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, nullKeysMatchInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  std::vector<std::vector<std::optional<int32_t>>> keyData = {
+      {1, std::nullopt, 4},
+  };
+  auto keys = makeNullableArrayVector<int32_t>(keyData);
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, floatKeys) {
+  auto inputMap = makeMapVector<float, int32_t>({
+      {{1.5f, 10}, {2.5f, 20}, {3.5f, 30}},
+  });
+
+  auto keys = makeArrayVector<float>({
+      {1.5f, 10.5f},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, doubleKeys) {
+  auto inputMap = makeMapVector<double, int32_t>({
+      {{1.5, 10}, {2.5, 20}},
+  });
+
+  auto keys = makeArrayVector<double>({
+      {3.5, 4.5},
+  });
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, booleanKeys) {
+  auto inputMap = makeMapVector<bool, int32_t>({
+      {{true, 10}, {false, 20}},
+      {{true, 30}},
+  });
+
+  auto keys = makeArrayVector<bool>({
+      {true},
+      {false},
+  });
+
+  auto expected = makeFlatVector<bool>({true, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, timestampKeys) {
+  auto inputMap = makeMapVector<Timestamp, int32_t>({
+      {{Timestamp(1, 0), 10}, {Timestamp(2, 0), 20}},
+  });
+
+  auto keys = makeArrayVector<Timestamp>({
+      {Timestamp(1, 0), Timestamp(100, 0)},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, complexValues) {
+  auto mapKeys = makeFlatVector<int32_t>({0, 1, 2});
+  auto innerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+  });
+
+  auto inputMap = makeMapVector({0}, mapKeys, innerArrays);
+
+  auto keys = makeArrayVector<int32_t>({
+      {0, 5},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, largeMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{0, 0},
+       {1, 10},
+       {2, 20},
+       {3, 30},
+       {4, 40},
+       {5, 50},
+       {6, 60},
+       {7, 70},
+       {8, 80},
+       {9, 90}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {5, 15, 25},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, largeMapNoMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{0, 0},
+       {1, 10},
+       {2, 20},
+       {3, 30},
+       {4, 40},
+       {5, 50},
+       {6, 60},
+       {7, 70},
+       {8, 80},
+       {9, 90}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {15, 25, 35},
+  });
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, multipleRows) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+      {{3, 30}, {4, 40}},
+      {{5, 50}, {6, 60}},
+      {{7, 70}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {2, 3},
+      {1, 2},
+      {5},
+      {8, 9},
+  });
+
+  auto expected = makeFlatVector<bool>({true, false, true, false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, longStringKeys) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"very_long_key_name_1", 1},
+       {"very_long_key_name_2", 2},
+       {"very_long_key_name_3", 3}},
+  });
+
+  auto keys = makeArrayVector<StringView>({
+      {"very_long_key_name_2", "very_long_key_name_4"},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, singleKeyMatch) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {3},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, duplicateKeysInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto keys = makeArrayVector<int32_t>({
+      {1, 1, 1, 4, 5},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, varcharEmptyStrings) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"", 1}, {"a", 2}, {"b", 3}},
+  });
+
+  auto keys = makeArrayVector<StringView>({
+      {"", "c"},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, allNullKeysInArray) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+  });
+
+  std::vector<std::vector<std::optional<int32_t>>> keyData = {
+      {std::nullopt, std::nullopt},
+  };
+  auto keys = makeNullableArrayVector<int32_t>(keyData);
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, int8Keys) {
+  auto inputMap = makeMapVector<int8_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto keys = makeArrayVector<int8_t>({
+      {2, 5},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, int16Keys) {
+  auto inputMap = makeMapVector<int16_t, int32_t>({
+      {{100, 10}, {200, 20}},
+  });
+
+  auto keys = makeArrayVector<int16_t>({
+      {300, 400},
+  });
+
+  auto expected = makeFlatVector<bool>({false});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+TEST_F(MapKeysOverlapTest, int64Keys) {
+  auto inputMap = makeMapVector<int64_t, int32_t>({
+      {{1000000000, 10}, {2000000000, 20}},
+  });
+
+  auto keys = makeArrayVector<int64_t>({
+      {1000000000},
+  });
+
+  auto expected = makeFlatVector<bool>({true});
+
+  testMapKeysOverlap("map_keys_overlap(c0, c1)", {inputMap, keys}, expected);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/MapZipWithTest.cpp b/velox/functions/prestosql/tests/MapZipWithTest.cpp
index 42f3c5287de0..6d6297b5c4a8 100644
--- a/velox/functions/prestosql/tests/MapZipWithTest.cpp
+++ b/velox/functions/prestosql/tests/MapZipWithTest.cpp
@@ -294,6 +294,30 @@ TEST_F(MapZipWithTest, fuzz) {
   }
 }
 
+TEST_F(MapZipWithTest, unknownType) {
+  auto makeFlatUnknownVector = [&](int size) {
+    auto vector =
+        BaseVector::create<FlatVector<UnknownValue>>(UNKNOWN(), size, pool());
+    for (int i = 0; i < size; ++i) {
+      vector->setNull(i, true);
+    }
+    return vector;
+  };
+
+  auto data = makeRowVector({
+      makeMapVector({0}, makeFlatUnknownVector(3), makeFlatUnknownVector(3)),
+      makeMapVector({0}, makeFlatUnknownVector(3), makeFlatUnknownVector(3)),
+  });
+
+  auto result =
+      evaluate("map_zip_with(c0, c1, (k, v1, v2) -> coalesce(v1, v2))", data);
+
+  auto expected =
+      makeMapVector({0}, makeFlatUnknownVector(3), makeFlatUnknownVector(3));
+
+  assertEqualVectors(expected, result);
+}
+
 TEST_F(MapZipWithTest, try) {
   auto data = makeRowVector(
       {makeMapVector<int64_t, int64_t>(
diff --git a/velox/functions/prestosql/tests/P4HyperLogLogCastTest.cpp b/velox/functions/prestosql/tests/P4HyperLogLogCastTest.cpp
new file mode 100644
index 000000000000..68e5e1f6ca6f
--- /dev/null
+++ b/velox/functions/prestosql/tests/P4HyperLogLogCastTest.cpp
@@ -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.
+ */
+#include "velox/common/encode/Base64.h"
+
+#include "velox/functions/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/functions/prestosql/types/P4HyperLogLogType.h"
+
+using namespace facebook::velox;
+
+class P4HyperLogLogCastTest : public functions::test::CastBaseTest {
+ protected:
+  // Helper to decode base64 to binary string
+  static std::string decodeBase64(const std::string& base64Str) {
+    return encoding::Base64::decode(base64Str);
+  }
+};
+
+TEST_F(P4HyperLogLogCastTest, nullValues) {
+  auto nullData = std::vector<std::optional<StringView>>{
+      std::nullopt, std::nullopt, std::nullopt, std::nullopt};
+
+  // HYPERLOGLOG from/to P4HYPERLOGLOG
+  testCast<StringView, StringView>(
+      HYPERLOGLOG(), P4HYPERLOGLOG(), nullData, nullData);
+  testCast<StringView, StringView>(
+      P4HYPERLOGLOG(), HYPERLOGLOG(), nullData, nullData);
+}
+
+TEST_F(P4HyperLogLogCastTest, emptyValues) {
+  auto emptyData =
+      std::vector<std::optional<StringView>>{""_sv, ""_sv, ""_sv, ""_sv};
+
+  // HYPERLOGLOG from/to P4HYPERLOGLOG
+  testCast<StringView, StringView>(
+      HYPERLOGLOG(), P4HYPERLOGLOG(), emptyData, emptyData);
+  testCast<StringView, StringView>(
+      P4HYPERLOGLOG(), HYPERLOGLOG(), emptyData, emptyData);
+}
+
+TEST_F(P4HyperLogLogCastTest, nonEmptyValues) {
+  // SELECT cast(empty_approx_set(0.01625) as VARBINARY) as input1;
+  // SELECT cast(approx_set('test1', 0.01625) as VARBINARY) as input2;
+  // SELECT cast(approx_set('test_dense', 0.065) as VARBINARY) as input3;
+  std::string input1Binary = decodeBase64("AgwAAA==");
+  std::string input2Binary = decodeBase64("AgwBAELMwgM=");
+  std::string input3Binary = decodeBase64("AggBAED31hA=");
+
+  std::string expected1Binary = decodeBase64(
+      "AwwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); // Empty sparse → dense
+  std::string expected2Binary = decodeBase64(
+      "AwwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); // Sparse → dense
+  std::string expected3Binary = decodeBase64(
+      "AwgAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); // Dense → re-serialized
+
+  auto inputData = std::vector<std::optional<StringView>>{
+      StringView(input1Binary),
+      StringView(input2Binary),
+      StringView(input3Binary)};
+
+  auto expectedP4Data = std::vector<std::optional<StringView>>{
+      StringView(expected1Binary),
+      StringView(expected2Binary),
+      StringView(expected3Binary)};
+
+  // Test HYPERLOGLOG to P4HYPERLOGLOG conversion
+  testCast<StringView, StringView>(
+      HYPERLOGLOG(), P4HYPERLOGLOG(), inputData, expectedP4Data);
+
+  // Test P4HYPERLOGLOG to HYPERLOGLOG (should be direct copy)
+  testCast<StringView, StringView>(
+      P4HYPERLOGLOG(), HYPERLOGLOG(), expectedP4Data, expectedP4Data);
+}
+
+TEST_F(P4HyperLogLogCastTest, oldFormatSparseV1) {
+  // Test casting HLL with deprecated SPARSE_V1 format (tag = 0) to P4HLL
+
+  std::string sparseV1Binary = std::string(1, '\x00') + std::string(11, '\x00');
+
+  auto inputData =
+      std::vector<std::optional<StringView>>{StringView(sparseV1Binary)};
+
+  testThrow<StringView>(
+      HYPERLOGLOG(), P4HYPERLOGLOG(), inputData, "Invalid HyperLogLog format");
+}
+
+TEST_F(P4HyperLogLogCastTest, oldFormatDenseV1) {
+  // Test casting HLL with deprecated DENSE_V1 format (tag = 1) to P4HLL
+  std::string denseV1Binary = std::string(1, '\x01') + std::string(11, '\x00');
+
+  testThrow<StringView>(
+      HYPERLOGLOG(),
+      P4HYPERLOGLOG(),
+      {StringView(denseV1Binary)},
+      "Invalid HyperLogLog format");
+}
diff --git a/velox/functions/prestosql/tests/ProbabilityTest.cpp b/velox/functions/prestosql/tests/ProbabilityTest.cpp
index 2b9ef6ce23b1..71d918630c28 100644
--- a/velox/functions/prestosql/tests/ProbabilityTest.cpp
+++ b/velox/functions/prestosql/tests/ProbabilityTest.cpp
@@ -37,6 +37,11 @@ MATCHER(IsInf, "is Infinity") {
   return arg && std::isinf(*arg);
 }
 
+auto roundToPrecision(double num, int precision) {
+  double factor = pow(10.0, precision);
+  return round(num * factor) / factor;
+};
+
 class ProbabilityTest : public functions::test::FunctionBaseTest {
  protected:
   template <typename ValueType>
@@ -102,6 +107,7 @@ class ProbabilityTest : public functions::test::FunctionBaseTest {
         0.0);
     EXPECT_EQ(binomialCDF<ValueType>(10, 0.1, -2), 0.0);
     EXPECT_EQ(binomialCDF<ValueType>(25, 0.5, -100), 0.0);
+    EXPECT_EQ(binomialCDF<ValueType>(2, 0.1, 3), 1.0);
 
     // Invalid inputs
     VELOX_ASSERT_THROW(
@@ -613,11 +619,6 @@ TEST_F(ProbabilityTest, invGammaCDF) {
         "inverse_gamma_cdf(c0, c1, c2)", shape, scale, p);
   };
 
-  const auto roundToPrecision = [&](double num, int precision) {
-    double factor = pow(10.0, precision);
-    return round(num * factor) / factor;
-  };
-
   EXPECT_EQ(0, invGammaCDF(3, 3.6, 0.0));
   EXPECT_EQ(33.624, roundToPrecision(invGammaCDF(3, 4, 0.99).value(), 3));
   EXPECT_EQ(10.696, roundToPrecision(invGammaCDF(3, 4, 0.50).value(), 3));
@@ -772,5 +773,144 @@ TEST_F(ProbabilityTest, invPoissonCDF) {
       "inversePoissonCdf Function: p must be in the interval [0, 1)");
 }
 
+TEST_F(ProbabilityTest, inverseFCDF) {
+  const auto inverseFCDF = [&](std::optional<double> df1,
+                               std::optional<double> df2,
+                               std::optional<double> p) {
+    return evaluateOnce<double>("inverse_f_cdf(c0, c1, c2)", df1, df2, p);
+  };
+
+  EXPECT_EQ(0, inverseFCDF(2.0, 5.0, 0.0));
+  EXPECT_EQ(0.7988, roundToPrecision((inverseFCDF(2.0, 5.0, 0.5)).value(), 4));
+  EXPECT_EQ(3.7797, roundToPrecision((inverseFCDF(2.0, 5.0, 0.9)).value(), 4));
+
+  VELOX_ASSERT_THROW(
+      inverseFCDF(0, 3, 0.5),
+      "inverseFCdf Function: numerator df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseFCDF(3, 0, 0.5),
+      "inverseFCdf Function: denominator df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseFCDF(3, 5, -0.1),
+      "inverseFCdf Function: p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      inverseFCDF(3, 5, 1.1),
+      "inverseFCdf Function: p must be in the interval [0, 1]");
+
+  VELOX_ASSERT_THROW(
+      inverseFCDF(kNan, 1, 0.5),
+      "inverseFCdf Function: numerator df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseFCDF(kInf, 1, 0.5),
+      "inverseFCdf Function: numerator df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseFCDF(1, kNan, 0.5),
+      "inverseFCdf Function: denominator df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseFCDF(1, kInf, 0.5),
+      "inverseFCdf Function: denominator df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseFCDF(1, 1, kNan),
+      "inverseFCdf Function: p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      inverseFCDF(1, 1, kInf),
+      "inverseFCdf Function: p must be in the interval [0, 1]");
+}
+
+TEST_F(ProbabilityTest, inverseChiSquaredCdf) {
+  const auto inverseChiSquaredCdf = [&](std::optional<double> df,
+                                        std::optional<double> p) {
+    return evaluateOnce<double>("inverse_chi_squared_cdf(c0, c1)", df, p);
+  };
+
+  EXPECT_EQ(0, inverseChiSquaredCdf(3, 0.0));
+  EXPECT_EQ(
+      11.3449, roundToPrecision(inverseChiSquaredCdf(3, 0.99).value(), 4));
+  EXPECT_EQ(1.42, roundToPrecision(inverseChiSquaredCdf(3, 0.3).value(), 2));
+  EXPECT_EQ(7.81, roundToPrecision(inverseChiSquaredCdf(3, 0.95).value(), 2));
+
+  VELOX_ASSERT_THROW(
+      inverseChiSquaredCdf(-3, 0.3),
+      "inverseChiSquaredCdf Function: df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseChiSquaredCdf(3, -0.1),
+      "inverseChiSquaredCdf Function: p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      inverseChiSquaredCdf(3, 1.1),
+      "inverseChiSquaredCdf Function: p must be in the interval [0, 1]");
+
+  VELOX_ASSERT_THROW(
+      inverseChiSquaredCdf(kNan, 0.5),
+      "inverseChiSquaredCdf Function: df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseChiSquaredCdf(kInf, 0.5),
+      "inverseChiSquaredCdf Function: df must be greater than 0");
+  VELOX_ASSERT_THROW(
+      inverseChiSquaredCdf(1, kNan),
+      "inverseChiSquaredCdf Function: p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(
+      inverseChiSquaredCdf(1, kInf),
+      "inverseChiSquaredCdf Function: p must be in the interval [0, 1]");
+}
+
+TEST_F(ProbabilityTest, tCDF) {
+  const auto tCDF = [&](std::optional<double> df, std::optional<double> value) {
+    return evaluateOnce<double>("t_cdf(c0, c1)", df, value);
+  };
+
+  EXPECT_EQ(0.5, tCDF(1000, 0.0));
+  EXPECT_EQ(1.0, tCDF(1000, kInf));
+  EXPECT_EQ(0.0, tCDF(1000, -kInf));
+
+  EXPECT_EQ(std::nullopt, tCDF(std::nullopt, 0.5));
+  EXPECT_EQ(std::nullopt, tCDF(1000, std::nullopt));
+
+  VELOX_ASSERT_THROW(tCDF(0, 0.5), "df must be greater than 0");
+  VELOX_ASSERT_THROW(tCDF(-1, 0.5), "df must be greater than 0");
+
+  EXPECT_NEAR(0.95, tCDF(5, 2.015).value(), 0.001);
+  EXPECT_NEAR(0.05, tCDF(5, -2.015).value(), 0.001);
+
+  EXPECT_NEAR(0.975, tCDF(10, 2.228).value(), 0.001);
+  EXPECT_NEAR(0.025, tCDF(10, -2.228).value(), 0.001);
+
+  EXPECT_NEAR(0.99, tCDF(20, 2.528).value(), 0.001);
+
+  EXPECT_NEAR(0.90, tCDF(30, 1.310).value(), 0.001);
+
+  EXPECT_NEAR(0.95, tCDF(100, 1.660).value(), 0.001);
+}
+
+TEST_F(ProbabilityTest, inverseTCDF) {
+  const auto inverseTCDF = [&](std::optional<double> df,
+                               std::optional<double> p) {
+    return evaluateOnce<double>("inverse_t_cdf(c0, c1)", df, p);
+  };
+
+  EXPECT_EQ(0.0, inverseTCDF(1000, 0.5));
+  EXPECT_EQ(-kInf, inverseTCDF(1000, 0.0));
+  EXPECT_EQ(kInf, inverseTCDF(1000, 1.0));
+
+  EXPECT_EQ(std::nullopt, inverseTCDF(std::nullopt, 0.5));
+  EXPECT_EQ(std::nullopt, inverseTCDF(1000, std::nullopt));
+
+  VELOX_ASSERT_THROW(inverseTCDF(0, 0.5), "df must be greater than 0");
+  VELOX_ASSERT_THROW(inverseTCDF(-1, 0.5), "df must be greater than 0");
+  VELOX_ASSERT_THROW(inverseTCDF(3, -0.1), "p must be in the interval [0, 1]");
+  VELOX_ASSERT_THROW(inverseTCDF(3, 1.1), "p must be in the interval [0, 1]");
+
+  EXPECT_NEAR(2.015, inverseTCDF(5, 0.95).value(), 0.001);
+  EXPECT_NEAR(-2.015, inverseTCDF(5, 0.05).value(), 0.001);
+
+  EXPECT_NEAR(2.228, inverseTCDF(10, 0.975).value(), 0.001);
+  EXPECT_NEAR(-2.228, inverseTCDF(10, 0.025).value(), 0.001);
+
+  EXPECT_NEAR(2.528, inverseTCDF(20, 0.99).value(), 0.001);
+
+  EXPECT_NEAR(1.310, inverseTCDF(30, 0.90).value(), 0.001);
+
+  EXPECT_NEAR(1.660, inverseTCDF(100, 0.95).value(), 0.001);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/QDigestFunctionsTest.cpp b/velox/functions/prestosql/tests/QDigestFunctionsTest.cpp
new file mode 100644
index 000000000000..76caa836ef8f
--- /dev/null
+++ b/velox/functions/prestosql/tests/QDigestFunctionsTest.cpp
@@ -0,0 +1,537 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/base64.h>
+#include <random>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/lib/QuantileDigest.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions::test;
+using namespace facebook::velox::functions::qdigest;
+
+class QDigestFunctionsTest : public FunctionBaseTest {
+ protected:
+  void SetUp() override {
+    FunctionBaseTest::SetUp();
+    registerQDigestType();
+  }
+
+  template <typename T>
+  std::string createQDigest(
+      const std::vector<T>& values,
+      double maxError = kMaxError) {
+    std::allocator<T> allocator;
+    QuantileDigest<T, std::allocator<T>> digest(allocator, maxError);
+
+    for (const auto& value : values) {
+      digest.add(value, 1.0);
+    }
+
+    const auto serializedSize = digest.serializedByteSize();
+    std::vector<char> serializedData(serializedSize);
+    digest.serialize(serializedData.data());
+    return std::string(serializedData.begin(), serializedData.end());
+  }
+
+  // Type definitions
+  const TypePtr QDIGEST_DOUBLE = QDIGEST(DOUBLE());
+  const TypePtr QDIGEST_BIGINT = QDIGEST(BIGINT());
+  const TypePtr QDIGEST_REAL = QDIGEST(REAL());
+  const TypePtr ARRAY_QDIGEST_DOUBLE = ARRAY(QDIGEST(DOUBLE()));
+  static constexpr double kMaxError = 0.01;
+};
+
+TEST_F(QDigestFunctionsTest, valueAtQuantileDouble) {
+  const auto valueAtQuantile = [&](const std::optional<std::string>& input,
+                                   const std::optional<double>& quantile) {
+    return evaluateOnce<double>(
+        "value_at_quantile(c0, c1)", QDIGEST_DOUBLE, input, quantile);
+  };
+
+  std::vector<double> values;
+  for (int i = 1; i <= 1000; i++) {
+    values.push_back(static_cast<double>(i + 0.1 * i));
+  }
+  std::string digest = createQDigest(values);
+
+  ASSERT_NEAR(valueAtQuantile(digest, 0.0).value(), 1.1, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.002).value(), 3.3, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.08).value(), 89.1, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.109).value(), 121.0, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.25).value(), 276.1, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.311).value(), 343.2, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.5).value(), 551.1, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.75).value(), 826.1, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.811).value(), 893.2, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.991).value(), 1091.2, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.9999).value(), 1100.0, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 1.0).value(), 1100.0, kMaxError);
+}
+
+TEST_F(QDigestFunctionsTest, valueAtQuantileBigint) {
+  const auto valueAtQuantile = [&](const std::optional<std::string>& input,
+                                   const std::optional<double>& quantile) {
+    return evaluateOnce<int64_t>(
+        "value_at_quantile(c0, c1)", QDIGEST_BIGINT, input, quantile);
+  };
+
+  std::vector<int64_t> values;
+  for (int64_t i = 1; i <= 1000; i++) {
+    values.push_back(i);
+  }
+  std::string digest = createQDigest(values);
+  constexpr double kMaxError = 0.01;
+
+  ASSERT_NEAR(valueAtQuantile(digest, 0.0).value(), 1, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.002).value(), 3, kMaxError);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.08).value(), 81, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.109).value(), 110, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.25).value(), 251, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.311).value(), 312, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.5).value(), 501, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.75).value(), 751, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.811).value(), 812, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.991).value(), 992, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.9999).value(), 1000, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 1.0).value(), 1000, 0.1);
+}
+
+TEST_F(QDigestFunctionsTest, valueAtQuantileReal) {
+  const auto valueAtQuantile = [&](const std::optional<std::string>& input,
+                                   const std::optional<double>& quantile) {
+    return evaluateOnce<float>(
+        "value_at_quantile(c0, c1)", QDIGEST_REAL, input, quantile);
+  };
+
+  std::vector<float> values;
+  for (int i = 1; i <= 1000; i++) {
+    values.push_back(static_cast<float>(i + 0.1 * i));
+  }
+  std::string digest = createQDigest(values);
+
+  ASSERT_NEAR(valueAtQuantile(digest, 0.0).value(), 1.1f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.002).value(), 3.3f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.08).value(), 89.1f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.109).value(), 121.0f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.25).value(), 276.1f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.311).value(), 343.2f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.5).value(), 551.1f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.75).value(), 826.1f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.811).value(), 893.2f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.991).value(), 1091.2f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 0.9999).value(), 1100.0f, 0.1);
+  ASSERT_NEAR(valueAtQuantile(digest, 1.0).value(), 1100.0f, 0.1);
+}
+
+TEST_F(QDigestFunctionsTest, valueAtQuantileOutOfRange) {
+  const auto valueAtQuantile = [&](const std::optional<std::string>& input,
+                                   const std::optional<double>& quantile) {
+    return evaluateOnce<double>(
+        "value_at_quantile(c0, c1)", QDIGEST_DOUBLE, input, quantile);
+  };
+
+  std::vector<double> values = {1.0, 2.0, 3.0};
+  std::string digest = createQDigest(values);
+
+  EXPECT_THROW(valueAtQuantile(digest, -0.1), VeloxUserError);
+  EXPECT_THROW(valueAtQuantile(digest, 1.1), VeloxUserError);
+}
+
+TEST_F(QDigestFunctionsTest, valueAtQuantileNullInput) {
+  const auto valueAtQuantile = [&](const std::optional<std::string>& input,
+                                   const std::optional<double>& quantile) {
+    return evaluateOnce<double>(
+        "value_at_quantile(c0, c1)", QDIGEST_DOUBLE, input, quantile);
+  };
+
+  ASSERT_EQ(std::nullopt, valueAtQuantile(std::nullopt, 0.5));
+}
+
+TEST_F(QDigestFunctionsTest, valuesAtQuantilesDouble) {
+  std::vector<double> values;
+  for (int i = 1; i <= 1000; i++) {
+    values.push_back(static_cast<double>(i + 0.1 * i));
+  }
+  std::string digest = createQDigest(values);
+
+  auto c0 = makeFlatVector<std::string>({digest}, QDIGEST_DOUBLE);
+  auto c1 = makeNullableArrayVector<double>(
+      {{0,
+        0.002,
+        0.08,
+        0.109,
+        0.25,
+        0.311,
+        0.5,
+        0.75,
+        0.811,
+        0.991,
+        0.9999,
+        1.0}});
+
+  auto result =
+      evaluate("values_at_quantiles(c0, c1)", makeRowVector({c0, c1}));
+  auto arrayResult = result->as<ArrayVector>();
+
+  auto elements = arrayResult->elements()->as<FlatVector<double>>();
+  ASSERT_EQ(elements->size(), 12);
+  std::array<double, 12> rst{
+      1.1,
+      3.3,
+      89.1,
+      121,
+      276.1,
+      343.2,
+      551.1,
+      826.1,
+      893.2,
+      1091.2,
+      1100,
+      1100};
+  for (auto i = 0; i < 12; i++) {
+    ASSERT_NEAR(elements->valueAt(i), rst[i], 1.0);
+  }
+}
+
+TEST_F(QDigestFunctionsTest, valuesAtQuantilesBigint) {
+  std::vector<int64_t> values;
+  for (int64_t i = 1; i <= 1000; i++) {
+    values.push_back(i);
+  }
+  std::string digest = createQDigest(values);
+
+  auto c0 = makeFlatVector<std::string>({digest}, QDIGEST_BIGINT);
+  auto c1 = makeNullableArrayVector<double>(
+      {{0,
+        0.002,
+        0.08,
+        0.109,
+        0.25,
+        0.311,
+        0.5,
+        0.75,
+        0.811,
+        0.991,
+        0.9999,
+        1.0}});
+
+  auto result =
+      evaluate("values_at_quantiles(c0, c1)", makeRowVector({c0, c1}));
+  auto arrayResult = result->as<ArrayVector>();
+
+  auto elements = arrayResult->elements()->as<FlatVector<int64_t>>();
+  ASSERT_EQ(elements->size(), 12);
+  std::array<int64_t, 12> rst{
+      1, 3, 81, 110, 251, 312, 501, 751, 812, 992, 1000, 1000};
+  for (auto i = 0; i < 12; i++) {
+    ASSERT_NEAR(elements->valueAt(i), rst[i], 1.0);
+  }
+}
+
+TEST_F(QDigestFunctionsTest, valuesAtQuantilesReal) {
+  std::vector<float> values;
+  for (int i = 1; i <= 1000; i++) {
+    values.push_back(static_cast<float>(i) + i * 0.1f);
+  }
+  std::string digest = createQDigest(values);
+
+  auto c0 = makeFlatVector<std::string>({digest}, QDIGEST_REAL);
+  auto c1 = makeNullableArrayVector<double>(
+      {{0,
+        0.002,
+        0.08,
+        0.109,
+        0.25,
+        0.311,
+        0.5,
+        0.75,
+        0.811,
+        0.991,
+        0.9999,
+        1.0}});
+
+  auto result =
+      evaluate("values_at_quantiles(c0, c1)", makeRowVector({c0, c1}));
+  auto arrayResult = result->as<ArrayVector>();
+  auto elements = arrayResult->elements()->as<FlatVector<float>>();
+  ASSERT_EQ(elements->size(), 12);
+  std::array<float, 12> rst{
+      1.1,
+      3.3,
+      89.1,
+      121,
+      276.1,
+      343.2,
+      551.1,
+      826.1,
+      893.2,
+      1091.2,
+      1100,
+      1100};
+  for (auto i = 0; i < 12; i++) {
+    ASSERT_NEAR(elements->valueAt(i), rst[i], 0.01);
+  }
+}
+
+TEST_F(QDigestFunctionsTest, valuesAtQuantilesWithNulls) {
+  std::vector<double> values = {1.0, 2.0, 3.0, 4.0, 5.0};
+  std::string digest = createQDigest(values);
+
+  auto c0 = makeFlatVector<std::string>({digest}, QDIGEST_DOUBLE);
+  std::vector<std::vector<std::optional<double>>> data = {
+      {0, std::nullopt, std::nullopt, 1}};
+  auto c1 = makeNullableArrayVector<double>(data);
+
+  ASSERT_THROW(
+      evaluate("values_at_quantiles(c0, c1)", makeRowVector({c0, c1})),
+      VeloxUserError);
+}
+
+TEST_F(QDigestFunctionsTest, valuesAtQuantilesEmptyArray) {
+  std::vector<double> values = {1.0, 2.0, 3.0};
+  std::string digest = createQDigest(values);
+
+  auto arg0 = makeFlatVector<std::string>({digest}, QDIGEST_DOUBLE);
+  std::vector<std::vector<std::optional<double>>> emptyData = {{}};
+  auto arg1 = makeNullableArrayVector<double>(emptyData);
+
+  auto result =
+      evaluate("values_at_quantiles(c0, c1)", makeRowVector({arg0, arg1}));
+  auto arrayResult = result->as<ArrayVector>();
+
+  ASSERT_EQ(arrayResult->sizeAt(0), 0);
+}
+
+TEST_F(QDigestFunctionsTest, quantileAtValueBigint) {
+  const auto quantileAtValue = [&](const std::optional<std::string>& input,
+                                   const std::optional<int64_t>& value) {
+    return evaluateOnce<double>(
+        "quantile_at_value(c0, c1)", QDIGEST_BIGINT, input, value);
+  };
+
+  std::vector<int64_t> values;
+  for (int64_t i = 1; i <= 1000; i++) {
+    values.push_back(i);
+  }
+  std::string digest = createQDigest(values, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1).value(), 0.0, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 2).value(), 0.001, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 3).value(), 0.002, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 333).value(), 0.332, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 500).value(), 0.499, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 666).value(), 0.665, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 998).value(), 0.997, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 999).value(), 0.998, kMaxError);
+  ASSERT_EQ(quantileAtValue(digest, 0), std::nullopt);
+  ASSERT_EQ(quantileAtValue(digest, 1001), std::nullopt);
+}
+
+TEST_F(QDigestFunctionsTest, quantileAtValueDouble) {
+  const auto quantileAtValue = [&](const std::optional<std::string>& input,
+                                   const std::optional<double>& value) {
+    return evaluateOnce<double>(
+        "quantile_at_value(c0, c1)", QDIGEST_DOUBLE, input, value);
+  };
+
+  std::vector<double> values;
+  for (int i = 1; i <= 1000; i++) {
+    values.push_back(static_cast<double>(i + 0.1 * i));
+  }
+
+  std::string digest = createQDigest(values, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1.1).value(), 0.0, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1.111).value(), 0.001, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 2.001).value(), 0.001, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 333.33).value(), 0.303, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 500.001).value(), 0.454, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 666.666).value(), 0.606, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 998.999).value(), 0.908, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1099.999).value(), 0.999, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1100).value(), 0.999, kMaxError);
+  ASSERT_EQ(quantileAtValue(digest, -1.1), std::nullopt);
+  ASSERT_EQ(quantileAtValue(digest, 1100.001), std::nullopt);
+}
+
+TEST_F(QDigestFunctionsTest, quantileAtValueReal) {
+  const auto quantileAtValue = [&](const std::optional<std::string>& input,
+                                   const std::optional<float>& value) {
+    return evaluateOnce<double>(
+        "quantile_at_value(c0, c1)", QDIGEST_REAL, input, value);
+  };
+
+  std::vector<float> values;
+  for (int i = 1; i <= 1000; i++) {
+    values.push_back(static_cast<float>(i + 0.1 * i));
+  }
+
+  std::string digest = createQDigest(values, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1.1).value(), 0.0, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1.111).value(), 0.001, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 2.001).value(), 0.001, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 333.33).value(), 0.303, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 500.001).value(), 0.454, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 666.666).value(), 0.606, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 998.999).value(), 0.908, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1099.999).value(), 0.999, kMaxError);
+  ASSERT_NEAR(quantileAtValue(digest, 1100).value(), 0.999, kMaxError);
+  ASSERT_EQ(quantileAtValue(digest, -1.1), std::nullopt);
+  ASSERT_EQ(quantileAtValue(digest, 1100.001), std::nullopt);
+}
+
+TEST_F(QDigestFunctionsTest, quantileAtValueEmptyDigest) {
+  const auto quantileAtValueBigint =
+      [&](const std::optional<std::string>& input,
+          const std::optional<int64_t>& value) {
+        return evaluateOnce<double>(
+            "quantile_at_value(c0, c1)", QDIGEST_BIGINT, input, value);
+      };
+
+  const auto quantileAtValueDouble =
+      [&](const std::optional<std::string>& input,
+          const std::optional<double>& value) {
+        return evaluateOnce<double>(
+            "quantile_at_value(c0, c1)", QDIGEST_DOUBLE, input, value);
+      };
+
+  std::string emptyDigestBigint = createQDigest(std::vector<int64_t>{});
+  std::string emptyDigestDouble = createQDigest(std::vector<double>{});
+  std::string emptyDigestReal = createQDigest(std::vector<float>{});
+
+  ASSERT_EQ(quantileAtValueBigint(emptyDigestBigint, 1), std::nullopt);
+  ASSERT_EQ(quantileAtValueDouble(emptyDigestDouble, 1), std::nullopt);
+  ASSERT_EQ(quantileAtValueDouble(emptyDigestReal, 51), std::nullopt);
+}
+
+TEST_F(QDigestFunctionsTest, quantileAtValueNullInputs) {
+  const auto quantileAtValueBigint =
+      [&](const std::optional<std::string>& input,
+          const std::optional<int64_t>& value) {
+        return evaluateOnce<double>(
+            "quantile_at_value(c0, c1)", QDIGEST_BIGINT, input, value);
+      };
+
+  const auto quantileAtValueDouble =
+      [&](const std::optional<std::string>& input,
+          const std::optional<double>& value) {
+        return evaluateOnce<double>(
+            "quantile_at_value(c0, c1)", QDIGEST_DOUBLE, input, value);
+      };
+
+  const auto quantileAtValueReal = [&](const std::optional<std::string>& input,
+                                       const std::optional<float>& value) {
+    return evaluateOnce<double>(
+        "quantile_at_value(c0, c1)", QDIGEST_REAL, input, value);
+  };
+
+  // Create valid digests for testing
+  std::vector<int64_t> bigintValues = {1, 2, 3, 4, 5};
+  std::vector<double> doubleValues = {1.1, 2.2, 3.3, 4.4, 5.5};
+  std::vector<float> realValues = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f};
+
+  std::string digestBigint = createQDigest(bigintValues);
+  std::string digestDouble = createQDigest(doubleValues);
+  std::string digestReal = createQDigest(realValues);
+
+  ASSERT_EQ(quantileAtValueBigint(std::nullopt, 3), std::nullopt);
+  ASSERT_EQ(quantileAtValueDouble(std::nullopt, 3.3), std::nullopt);
+  ASSERT_EQ(quantileAtValueReal(std::nullopt, 3.3f), std::nullopt);
+  ASSERT_EQ(quantileAtValueBigint(digestBigint, std::nullopt), std::nullopt);
+  ASSERT_EQ(quantileAtValueDouble(digestDouble, std::nullopt), std::nullopt);
+  ASSERT_EQ(quantileAtValueReal(digestReal, std::nullopt), std::nullopt);
+  ASSERT_EQ(quantileAtValueBigint(std::nullopt, std::nullopt), std::nullopt);
+  ASSERT_EQ(quantileAtValueDouble(std::nullopt, std::nullopt), std::nullopt);
+  ASSERT_EQ(quantileAtValueReal(std::nullopt, std::nullopt), std::nullopt);
+}
+
+TEST_F(QDigestFunctionsTest, scaleQDigestDouble) {
+  std::vector<double> values = {1.0, 2.0, 3.0, 4.0, 5.0};
+  std::string digest = createQDigest(values);
+
+  auto arg0 = makeNullableFlatVector<std::string>({digest}, QDIGEST_DOUBLE);
+
+  auto scaleUpResult =
+      evaluate("scale_qdigest(c0, 2.0)", makeRowVector({arg0}));
+
+  auto scaleDownResult =
+      evaluate("scale_qdigest(c0, 0.5)", makeRowVector({scaleUpResult}));
+
+  test::assertEqualVectors(arg0, scaleDownResult);
+}
+
+TEST_F(QDigestFunctionsTest, scaleQDigestBigint) {
+  std::vector<int64_t> values = {1, 2, 3, 4, 5};
+  std::string digest = createQDigest(values);
+
+  auto arg0 = makeNullableFlatVector<std::string>({digest}, QDIGEST_BIGINT);
+
+  // Scale up by 2
+  auto scaleUpResult =
+      evaluate("scale_qdigest(c0, 2.0)", makeRowVector({arg0}));
+
+  // Scale down by 0.5
+  auto scaleDownResult =
+      evaluate("scale_qdigest(c0, 0.5)", makeRowVector({scaleUpResult}));
+
+  // Should be approximately equal to original
+  test::assertEqualVectors(arg0, scaleDownResult);
+}
+
+TEST_F(QDigestFunctionsTest, scaleQDigestReal) {
+  std::vector<float> values = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+  std::string digest = createQDigest(values);
+
+  auto arg0 = makeNullableFlatVector<std::string>({digest}, QDIGEST_REAL);
+
+  auto scaleUpResult =
+      evaluate("scale_qdigest(c0, 2.5)", makeRowVector({arg0}));
+
+  auto scaleDownResult =
+      evaluate("scale_qdigest(c0, 0.4)", makeRowVector({scaleUpResult}));
+
+  test::assertEqualVectors(arg0, scaleDownResult);
+}
+
+TEST_F(QDigestFunctionsTest, scaleQDigestNegative) {
+  std::vector<double> values = {1.0, 2.0, 3.0};
+  std::string digest = createQDigest(values);
+
+  const auto scaleQDigest = [&](const std::optional<std::string>& input,
+                                const std::optional<double>& scale) {
+    return evaluateOnce<std::string>(
+        "scale_qdigest(c0, c1)", QDIGEST_DOUBLE, input, scale);
+  };
+
+  VELOX_ASSERT_THROW(
+      scaleQDigest(digest, -1.0), "Scale factor should be positive.");
+  VELOX_ASSERT_THROW(
+      scaleQDigest(digest, 0.0), "Scale factor should be positive.");
+}
+
+TEST_F(QDigestFunctionsTest, scaleQDigestNull) {
+  const auto scaleQDigest = [&](const std::optional<std::string>& input,
+                                const std::optional<double>& scale) {
+    return evaluateOnce<std::string>(
+        "scale_qdigest(c0, c1)", QDIGEST_DOUBLE, input, scale);
+  };
+
+  ASSERT_EQ(std::nullopt, scaleQDigest(std::nullopt, 2.0));
+  ASSERT_EQ(std::nullopt, scaleQDigest("digest", std::nullopt));
+}
diff --git a/velox/functions/prestosql/tests/RegexpReplaceTest.cpp b/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
index 008bb16e7305..4eb2e234aba8 100644
--- a/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
+++ b/velox/functions/prestosql/tests/RegexpReplaceTest.cpp
@@ -157,7 +157,7 @@ TEST_F(RegexpReplaceTest, lambda) {
       (evaluate(
           "regexp_replace(c0, '\\w(\\w*)', x -> (concat(upper(x[1]), lower(x[2]))))",
           input)),
-      "Array subscript out of bounds");
+      "Array subscript index out of bounds, Index: 2 Array size: 1");
 
   result = evaluate(
       "regexp_replace(c0, '\\w(\\w*)', x -> try(concat(upper(x[1]), lower(x[2]))))",
@@ -211,7 +211,7 @@ TEST_F(RegexpReplaceTest, lambda) {
       (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");
+      "Array subscript index out of bounds, Index: 10 Array size: 2");
 
   result = evaluate(
       "regexp_replace(c0, '(\\w)(\\w*)', x -> try(if (x[1] = 's', x[10], concat(upper(x[1]), lower(x[2])))))",
diff --git a/velox/functions/prestosql/tests/RegexpSplitTest.cpp b/velox/functions/prestosql/tests/RegexpSplitTest.cpp
new file mode 100644
index 000000000000..a69dec750f68
--- /dev/null
+++ b/velox/functions/prestosql/tests/RegexpSplitTest.cpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/utils/FunctionBaseTest.h"
+
+namespace facebook::velox {
+
+namespace {
+
+class RegexpSplitTest : public functions::test::FunctionBaseTest {};
+
+TEST_F(RegexpSplitTest, 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", ""},
+  });
+  test::assertEqualVectors(expected, result);
+
+  result = evaluate("regexp_split(c0, '\\s*\\d+\\s*')", input);
+  expected = makeArrayVector<std::string>({
+      {"", "a", "b", "m"},
+      {"", "a", "b", ""},
+      {""},
+      {"a", "b"},
+  });
+  test::assertEqualVectors(expected, result);
+
+  // Test for empty matches
+  result = evaluate("regexp_split(c0, '')", input);
+  expected = makeArrayVector<std::string>({
+      {"", "1", "a", " ", "2", "b", " ", "1", "4", "m", ""},
+      {"", "1", "a", " ", "2", "b", " ", "1", "4", ""},
+      {"", ""},
+      {"", "a", "1", "2", "3", "b", ""},
+  });
+  test::assertEqualVectors(expected, result);
+
+  // Test for another case of empty matches
+  result = evaluate("regexp_split(c0, '\\s*[a-z]*\\s*')", input);
+  expected = makeArrayVector<std::string>({
+      {"", "1", "", "2", "", "1", "4", "", ""},
+      {"", "1", "", "2", "", "1", "4", ""},
+      {"", ""},
+      {"", "", "1", "2", "3", "", ""},
+  });
+  test::assertEqualVectors(expected, result);
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/RemapKeysTest.cpp b/velox/functions/prestosql/tests/RemapKeysTest.cpp
new file mode 100644
index 000000000000..84adec8dc4cf
--- /dev/null
+++ b/velox/functions/prestosql/tests/RemapKeysTest.cpp
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/utils/FunctionBaseTest.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions {
+namespace {
+
+class RemapKeysTest : public test::FunctionBaseTest {
+ protected:
+  void testRemapKeys(
+      const std::string& expression,
+      const std::vector<VectorPtr>& input,
+      const VectorPtr& expected) {
+    auto result = evaluate(expression, makeRowVector(input));
+    assertEqualVectors(expected, result);
+  }
+};
+
+TEST_F(RemapKeysTest, basicIntegerKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2},
+      {4},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200},
+      {400},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {3, 30}},
+      {{400, 40}, {5, 50}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, stringKeys) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"a", 1}, {"b", 2}, {"c", 3}},
+      {{"x", 10}, {"y", 20}},
+  });
+
+  auto oldKeys = makeArrayVector<StringView>({
+      {"a", "c"},
+      {"x"},
+  });
+
+  auto newKeys = makeArrayVector<StringView>({
+      {"alpha", "charlie"},
+      {"xray"},
+  });
+
+  auto expected = makeMapVector<StringView, int32_t>({
+      {{"alpha", 1}, {"b", 2}, {"charlie", 3}},
+      {{"xray", 10}, {"y", 20}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, emptyMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {10, 20},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, emptyOldKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, noMatchingKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {4, 5, 6},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {40, 50, 60},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, mismatchedArrayLengths) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+      {{4, 40}, {5, 50}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+      {4, 5},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200},
+      {400, 500, 600},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {3, 30}},
+      {{400, 40}, {500, 50}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, nullValuesInMap) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, std::nullopt}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, std::nullopt}, {3, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, nullKeysInArrays) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeNullableArrayVector<int32_t>({
+      {1, std::nullopt, 3},
+  });
+
+  auto newKeys = makeNullableArrayVector<int32_t>({
+      {100, std::nullopt, 300},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {2, 20}, {300, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, duplicateOldKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 1, 2},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 101, 200},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{101, 10}, {200, 20}, {3, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, floatKeys) {
+  auto inputMap = makeMapVector<float, int32_t>({
+      {{1.5f, 10}, {2.5f, 20}, {3.5f, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<float>({
+      {1.5f, 3.5f},
+  });
+
+  auto newKeys = makeArrayVector<float>({
+      {10.5f, 30.5f},
+  });
+
+  auto expected = makeMapVector<float, int32_t>({
+      {{10.5f, 10}, {2.5f, 20}, {30.5f, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, booleanKeys) {
+  auto inputMap = makeMapVector<bool, int32_t>({
+      {{true, 10}, {false, 20}},
+  });
+
+  auto oldKeys = makeArrayVector<bool>({
+      {true},
+  });
+
+  auto newKeys = makeArrayVector<bool>({
+      {false},
+  });
+
+  auto expected = makeMapVector<bool, int32_t>({
+      {{false, 10}, {false, 20}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, complexValues) {
+  // Test with map of integer keys to array values
+  auto keys = makeFlatVector<int32_t>({0, 1, 2});
+  auto innerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+  });
+
+  auto inputMap = makeMapVector({0}, keys, innerArrays);
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {0, 1},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {10, 11},
+  });
+
+  auto expectedKeys = makeFlatVector<int32_t>({10, 11, 2});
+  auto expectedInnerArrays = makeArrayVector<int32_t>({
+      {1, 2},
+      {3, 4, 5},
+      {6},
+  });
+
+  auto expected = makeMapVector({0}, expectedKeys, expectedInnerArrays);
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, allKeysRemapped) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2, 3},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200, 300},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {300, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, partialRemapping) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {2, 4},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {200, 400},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {200, 20}, {3, 30}, {400, 40}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, largeMap) {
+  // Create a map with 10 entries for testing
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{0, 0},
+       {1, 10},
+       {2, 20},
+       {3, 30},
+       {4, 40},
+       {5, 50},
+       {6, 60},
+       {7, 70},
+       {8, 80},
+       {9, 90}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {0, 5, 9},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {1000, 5000, 9000},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{1000, 0},
+       {1, 10},
+       {2, 20},
+       {3, 30},
+       {4, 40},
+       {5000, 50},
+       {6, 60},
+       {7, 70},
+       {8, 80},
+       {9000, 90}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, timestampKeys) {
+  auto inputMap = makeMapVector<Timestamp, int32_t>({
+      {{Timestamp(1, 0), 10}, {Timestamp(2, 0), 20}},
+  });
+
+  auto oldKeys = makeArrayVector<Timestamp>({
+      {Timestamp(1, 0)},
+  });
+
+  auto newKeys = makeArrayVector<Timestamp>({
+      {Timestamp(100, 0)},
+  });
+
+  auto expected = makeMapVector<Timestamp, int32_t>({
+      {{Timestamp(100, 0), 10}, {Timestamp(2, 0), 20}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, oldKeysLongerThanNewKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {3, 30}, {4, 40}, {5, 50}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, newKeysLongerThanOldKeys) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100, 200, 300, 400, 500},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {200, 20}, {3, 30}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, significantSizeDifference) {
+  auto inputMap = makeMapVector<int32_t, int32_t>({
+      {{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}, {7, 70}},
+  });
+
+  auto oldKeys = makeArrayVector<int32_t>({
+      {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+  });
+
+  auto newKeys = makeArrayVector<int32_t>({
+      {100},
+  });
+
+  auto expected = makeMapVector<int32_t, int32_t>({
+      {{100, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}, {7, 70}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+TEST_F(RemapKeysTest, stringKeysWithDifferentSizes) {
+  auto inputMap = makeMapVector<StringView, int32_t>({
+      {{"apple", 1}, {"banana", 2}, {"cherry", 3}, {"date", 4}},
+  });
+
+  auto oldKeys = makeArrayVector<StringView>({
+      {"apple", "banana", "cherry", "date", "elderberry", "fig"},
+  });
+
+  auto newKeys = makeArrayVector<StringView>({
+      {"APPLE", "BANANA"},
+  });
+
+  auto expected = makeMapVector<StringView, int32_t>({
+      {{"APPLE", 1}, {"BANANA", 2}, {"cherry", 3}, {"date", 4}},
+  });
+
+  testRemapKeys(
+      "remap_keys(c0, c1, c2)", {inputMap, oldKeys, newKeys}, expected);
+}
+
+} // namespace
+} // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/SetDigestCastTest.cpp b/velox/functions/prestosql/tests/SetDigestCastTest.cpp
new file mode 100644
index 000000000000..b2f3f46807bf
--- /dev/null
+++ b/velox/functions/prestosql/tests/SetDigestCastTest.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/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+
+using namespace facebook::velox;
+
+class SetDigestCastTest : public functions::test::CastBaseTest {};
+
+TEST_F(SetDigestCastTest, toSetDigest) {
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      SETDIGEST(),
+      {"aaa"_sv, ""_sv, std::nullopt},
+      {"aaa"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      SETDIGEST(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
+
+TEST_F(SetDigestCastTest, fromSetDigest) {
+  testCast<StringView, StringView>(
+      SETDIGEST(),
+      VARBINARY(),
+      {"aaa"_sv, ""_sv, std::nullopt},
+      {"aaa"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      SETDIGEST(),
+      VARBINARY(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
diff --git a/velox/functions/prestosql/tests/SetDigestFunctionsTest.cpp b/velox/functions/prestosql/tests/SetDigestFunctionsTest.cpp
new file mode 100644
index 000000000000..fa94ab0d1959
--- /dev/null
+++ b/velox/functions/prestosql/tests/SetDigestFunctionsTest.cpp
@@ -0,0 +1,551 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/base64.h>
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/lib/SetDigest.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::functions::test;
+
+class SetDigestFunctionsTest : public FunctionBaseTest {
+ protected:
+  void SetUp() override {
+    FunctionBaseTest::SetUp();
+    registerSetDigestType();
+  }
+};
+
+TEST_F(SetDigestFunctionsTest, testCardinality) {
+  const auto cardinality = [&](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>("cardinality(c0)", SETDIGEST(), input);
+  };
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+  facebook::velox::functions::SetDigest<int64_t> digest(&allocator);
+
+  std::vector<int64_t> values;
+  for (int64_t i = 1; i <= 100; i++) {
+    digest.add(i);
+    values.push_back(i);
+  }
+
+  int64_t expectedCardinality = digest.cardinality();
+  ASSERT_EQ(100, expectedCardinality);
+
+  int32_t serializedSize = digest.estimatedSerializedSize();
+  std::vector<char> buffer(serializedSize);
+  digest.serialize(buffer.data());
+  std::string serializedDigest(buffer.begin(), buffer.end());
+
+  auto result = cardinality(serializedDigest);
+  ASSERT_EQ(expectedCardinality, result.value());
+
+  // Test with duplicates - should not increase cardinality
+  facebook::velox::functions::SetDigest<int64_t> digestWithDuplicates(
+      &allocator);
+  digestWithDuplicates.add(1L);
+  digestWithDuplicates.add(1L);
+  digestWithDuplicates.add(1L);
+  digestWithDuplicates.add(2L);
+  digestWithDuplicates.add(2L);
+
+  expectedCardinality = digestWithDuplicates.cardinality();
+  ASSERT_EQ(2, expectedCardinality);
+
+  serializedSize = digestWithDuplicates.estimatedSerializedSize();
+  buffer.resize(serializedSize);
+  digestWithDuplicates.serialize(buffer.data());
+  serializedDigest = std::string(buffer.begin(), buffer.end());
+
+  result = cardinality(serializedDigest);
+  ASSERT_EQ(expectedCardinality, result.value());
+}
+
+TEST_F(SetDigestFunctionsTest, testIntersectionCardinality) {
+  const auto intersectionCardinality =
+      [&](const std::optional<std::string>& input1,
+          const std::optional<std::string>& input2) {
+        return evaluateOnce<int64_t>(
+            "intersection_cardinality(c0, c1)",
+            {SETDIGEST(), SETDIGEST()},
+            input1,
+            input2);
+      };
+
+  // Create two SetDigest objects in C++ with known overlap
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+
+  facebook::velox::functions::SetDigest<int64_t> digest1(&allocator);
+  for (int64_t i = 1; i <= 10; i++) {
+    digest1.add(i);
+  }
+
+  facebook::velox::functions::SetDigest<int64_t> digest2(&allocator);
+  for (int64_t i = 5; i <= 15; i++) {
+    digest2.add(i);
+  }
+
+  int64_t expectedIntersection = facebook::velox::functions::SetDigest<
+      int64_t>::exactIntersectionCardinality(digest1, digest2);
+  ASSERT_EQ(6, expectedIntersection);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+  std::string serialized1(buffer1.begin(), buffer1.end());
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+  std::string serialized2(buffer2.begin(), buffer2.end());
+
+  auto result = intersectionCardinality(serialized1, serialized2);
+  ASSERT_EQ(expectedIntersection, result.value());
+
+  // Test with no overlap
+  facebook::velox::functions::SetDigest<int64_t> digest3(&allocator);
+  for (int64_t i = 100; i <= 110; i++) {
+    digest3.add(i);
+  }
+
+  expectedIntersection = facebook::velox::functions::SetDigest<
+      int64_t>::exactIntersectionCardinality(digest1, digest3);
+  ASSERT_EQ(0, expectedIntersection);
+
+  int32_t size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+  std::string serialized3(buffer3.begin(), buffer3.end());
+
+  result = intersectionCardinality(serialized1, serialized3);
+  ASSERT_EQ(expectedIntersection, result.value());
+
+  // Test with full overlap (same digest)
+  expectedIntersection = facebook::velox::functions::SetDigest<
+      int64_t>::exactIntersectionCardinality(digest1, digest1);
+  result = intersectionCardinality(serialized1, serialized1);
+  ASSERT_EQ(expectedIntersection, result.value());
+
+  // Test with null inputs.
+  result = intersectionCardinality(std::nullopt, serialized1);
+  ASSERT_FALSE(result.has_value());
+
+  result = intersectionCardinality(serialized1, std::nullopt);
+  ASSERT_FALSE(result.has_value());
+
+  result = intersectionCardinality(std::nullopt, std::nullopt);
+  ASSERT_FALSE(result.has_value());
+}
+
+TEST_F(SetDigestFunctionsTest, testHashCounts) {
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+  facebook::velox::functions::SetDigest<int64_t> digest(&allocator);
+
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(1L);
+  digest.add(2L);
+  digest.add(2L);
+  digest.add(3L);
+
+  auto expectedHashCounts = digest.getHashCounts();
+  ASSERT_EQ(3, expectedHashCounts.size());
+
+  int32_t size = digest.estimatedSerializedSize();
+  std::vector<char> buffer(size);
+  digest.serialize(buffer.data());
+
+  auto inputVector = BaseVector::create(SETDIGEST(), 1, execCtx_.pool());
+  auto flatVector = inputVector->as<FlatVector<StringView>>();
+  flatVector->set(0, StringView(buffer.data(), size));
+
+  auto result = evaluate("hash_counts(c0)", makeRowVector({inputVector}));
+
+  ASSERT_EQ(result->size(), 1);
+  auto mapVector = result->as<MapVector>();
+  ASSERT_NE(mapVector, nullptr);
+
+  ASSERT_EQ(mapVector->sizeAt(0), expectedHashCounts.size());
+
+  auto keys = mapVector->mapKeys()->as<SimpleVector<int64_t>>();
+  auto values = mapVector->mapValues()->as<SimpleVector<int16_t>>();
+
+  auto offset = mapVector->offsetAt(0);
+  auto mapSize = mapVector->sizeAt(0);
+
+  for (auto i = 0; i < mapSize; i++) {
+    auto key = keys->valueAt(offset + i);
+    auto value = values->valueAt(offset + i);
+
+    ASSERT_TRUE(expectedHashCounts.count(key) > 0);
+    ASSERT_EQ(expectedHashCounts.at(key), value);
+  }
+}
+
+TEST_F(SetDigestFunctionsTest, testHashCountsWithMerge) {
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+  facebook::velox::functions::SetDigest<int64_t> digest1(&allocator);
+  digest1.add(0L);
+  digest1.add(0L);
+  digest1.add(1L);
+
+  facebook::velox::functions::SetDigest<int64_t> digest2(&allocator);
+  digest2.add(0L);
+  digest2.add(0L);
+  digest2.add(2L);
+  digest2.add(2L);
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+
+  auto inputVector1 = BaseVector::create(SETDIGEST(), 1, execCtx_.pool());
+  auto flatVector1 = inputVector1->as<FlatVector<StringView>>();
+  flatVector1->set(0, StringView(buffer1.data(), size1));
+
+  auto result1 = evaluate("hash_counts(c0)", makeRowVector({inputVector1}));
+  auto mapVector1 = result1->as<MapVector>();
+  ASSERT_NE(mapVector1, nullptr);
+
+  // Extract count values from digest1 (should be {1, 2})
+  auto values1 = mapVector1->mapValues()->as<SimpleVector<int16_t>>();
+  auto offset1 = mapVector1->offsetAt(0);
+  auto mapSize1 = mapVector1->sizeAt(0);
+
+  std::set<int16_t> countValues1;
+  for (auto i = 0; i < mapSize1; i++) {
+    countValues1.insert(values1->valueAt(offset1 + i));
+  }
+
+  std::set<int16_t> expected1 = {1, 2}; // hash(0)→2, hash(1)→1
+  ASSERT_EQ(countValues1, expected1);
+
+  digest1.mergeWith(digest2);
+
+  // Test hash_counts after merge
+  int32_t sizeMerged = digest1.estimatedSerializedSize();
+  std::vector<char> bufferMerged(sizeMerged);
+  digest1.serialize(bufferMerged.data());
+
+  auto inputVectorMerged = BaseVector::create(SETDIGEST(), 1, execCtx_.pool());
+  auto flatVectorMerged = inputVectorMerged->as<FlatVector<StringView>>();
+  flatVectorMerged->set(0, StringView(bufferMerged.data(), sizeMerged));
+
+  auto resultMerged =
+      evaluate("hash_counts(c0)", makeRowVector({inputVectorMerged}));
+  auto mapVectorMerged = resultMerged->as<MapVector>();
+  ASSERT_NE(mapVectorMerged, nullptr);
+
+  // Extract count values from merged digest (should be {1, 2, 4})
+  auto valuesMerged = mapVectorMerged->mapValues()->as<SimpleVector<int16_t>>();
+  auto offsetMerged = mapVectorMerged->offsetAt(0);
+  auto mapSizeMerged = mapVectorMerged->sizeAt(0);
+
+  std::set<int16_t> countValuesMerged;
+  for (auto i = 0; i < mapSizeMerged; i++) {
+    countValuesMerged.insert(valuesMerged->valueAt(offsetMerged + i));
+  }
+
+  std::set<int16_t> expectedMerged = {
+      1, 2, 4}; // hash(0)→4, hash(1)→1, hash(2)→2
+  ASSERT_EQ(countValuesMerged, expectedMerged);
+}
+
+TEST_F(SetDigestFunctionsTest, testIntersectionCardinalityApproximate) {
+  const auto intersectionCardinality =
+      [&](const std::optional<std::string>& input1,
+          const std::optional<std::string>& input2) {
+        return evaluateOnce<int64_t>(
+            "intersection_cardinality(c0, c1)",
+            {SETDIGEST(), SETDIGEST()},
+            input1,
+            input2);
+      };
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+
+  // Test 1: Both digests approximate
+  // Approximate digest 1: values 0-9999 (10000 elements)
+  facebook::velox::functions::SetDigest<int64_t> approximateDigest1(&allocator);
+  for (int64_t i = 0; i < 10000; i++) {
+    approximateDigest1.add(i);
+  }
+  ASSERT_FALSE(approximateDigest1.isExact());
+
+  // Approximate digest 2: values 5000-14999 (10000 elements)
+  // Intersection: 5000-9999 (5000 elements)
+  // Union: 0-14999 (15000 elements)
+  // Expected Jaccard: 5000/15000 = 0.333
+  facebook::velox::functions::SetDigest<int64_t> approximateDigest2(&allocator);
+  for (int64_t i = 5000; i < 15000; i++) {
+    approximateDigest2.add(i);
+  }
+  ASSERT_FALSE(approximateDigest2.isExact());
+
+  int32_t approx1Size = approximateDigest1.estimatedSerializedSize();
+  std::vector<char> approx1Buffer(approx1Size);
+  approximateDigest1.serialize(approx1Buffer.data());
+  std::string serializedApprox1(approx1Buffer.begin(), approx1Buffer.end());
+
+  int32_t approx2Size = approximateDigest2.estimatedSerializedSize();
+  std::vector<char> approx2Buffer(approx2Size);
+  approximateDigest2.serialize(approx2Buffer.data());
+  std::string serializedApprox2(approx2Buffer.begin(), approx2Buffer.end());
+
+  // Test approximate mode with both digests being approximate
+  // approximateDigest1: 0-9999, approximateDigest2: 5000-14999
+  // Expected intersection: 5000 values (5000-9999)
+  auto result = intersectionCardinality(serializedApprox1, serializedApprox2);
+  ASSERT_TRUE(result.has_value());
+  // Allow reasonable margin of error for HyperLogLog and MinHash estimation
+  EXPECT_GE(result.value(), 3500);
+  EXPECT_LE(result.value(), 6500);
+
+  // Test approximate mode with same digest (self-intersection)
+  // Should return cardinality of the digest
+  result = intersectionCardinality(serializedApprox1, serializedApprox1);
+  ASSERT_TRUE(result.has_value());
+  int64_t cardinality = approximateDigest1.cardinality();
+  EXPECT_EQ(result.value(), cardinality);
+
+  // Test 2: Mixed mode - Exact digest (1000 elements) with Approximate digest
+  // This tests that MinHash can detect overlap when exact set is reasonably
+  // sized. Exact digest: values 0-999 (1000 elements, stays exact since < 8192)
+  facebook::velox::functions::SetDigest<int64_t> exactDigest(&allocator);
+  for (int64_t i = 0; i < 1000; i++) {
+    exactDigest.add(i);
+  }
+  ASSERT_TRUE(exactDigest.isExact());
+
+  // Approximate digest 3: values 0-9999 (10000 elements)
+  // Contains all elements from exactDigest
+  // Intersection: 0-999 (1000 elements)
+  // Union: 0-9999 (10000 elements)
+  // Expected Jaccard: 1000/10000 = 0.1
+  facebook::velox::functions::SetDigest<int64_t> approximateDigest3(&allocator);
+  for (int64_t i = 0; i < 10000; i++) {
+    approximateDigest3.add(i);
+  }
+  ASSERT_FALSE(approximateDigest3.isExact());
+
+  int32_t exactSize = exactDigest.estimatedSerializedSize();
+  std::vector<char> exactBuffer(exactSize);
+  exactDigest.serialize(exactBuffer.data());
+  std::string serializedExact(exactBuffer.begin(), exactBuffer.end());
+
+  int32_t approx3Size = approximateDigest3.estimatedSerializedSize();
+  std::vector<char> approx3Buffer(approx3Size);
+  approximateDigest3.serialize(approx3Buffer.data());
+  std::string serializedApprox3(approx3Buffer.begin(), approx3Buffer.end());
+
+  // Test mixed mode: exact (1000) ∩ approximate (10000 containing all exact)
+  result = intersectionCardinality(serializedExact, serializedApprox3);
+  ASSERT_TRUE(result.has_value());
+  // With 1000 elements, MinHash should be able to estimate the overlap
+  // Expected ~1000, but allow wider margin due to MinHash estimation variance
+  EXPECT_GE(result.value(), 600);
+  EXPECT_LE(result.value(), 1400);
+}
+
+TEST_F(SetDigestFunctionsTest, testJaccardIndex) {
+  const auto jaccardIndex = [&](const std::optional<std::string>& input1,
+                                const std::optional<std::string>& input2) {
+    return evaluateOnce<double>(
+        "jaccard_index(c0, c1)", {SETDIGEST(), SETDIGEST()}, input1, input2);
+  };
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+
+  // Test 1: Identical sets - Jaccard index should be 1.0
+  facebook::velox::functions::SetDigest<int64_t> digest1(&allocator);
+  for (int64_t i = 1; i <= 100; i++) {
+    digest1.add(i);
+  }
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+  std::string serialized1(buffer1.begin(), buffer1.end());
+
+  auto result = jaccardIndex(serialized1, serialized1);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_DOUBLE_EQ(result.value(), 1.0);
+
+  // Test 2: Disjoint sets - Jaccard index should be 0.0
+  facebook::velox::functions::SetDigest<int64_t> digest2(&allocator);
+  for (int64_t i = 101; i <= 200; i++) {
+    digest2.add(i);
+  }
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+  std::string serialized2(buffer2.begin(), buffer2.end());
+
+  result = jaccardIndex(serialized1, serialized2);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_DOUBLE_EQ(result.value(), 0.0);
+
+  // Test 3: Partially overlapping sets
+  // digest1: 1-100, digest3: 50-150
+  // Intersection: 50-100 (51 elements)
+  // Union: 1-150 (150 elements)
+  // Expected Jaccard: 51/150 ≈ 0.34
+  facebook::velox::functions::SetDigest<int64_t> digest3(&allocator);
+  for (int64_t i = 50; i <= 150; i++) {
+    digest3.add(i);
+  }
+
+  int32_t size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+  std::string serialized3(buffer3.begin(), buffer3.end());
+
+  result = jaccardIndex(serialized1, serialized3);
+  ASSERT_TRUE(result.has_value());
+  // Exact expected value: 51/150 = 0.34
+  double expectedJaccard = 51.0 / 150.0;
+  EXPECT_NEAR(result.value(), expectedJaccard, 0.05);
+
+  // Test 4: One set is a subset of the other
+  // digest1: 1-100, digest4: 25-75 (subset of digest1)
+  // Intersection: 25-75 (51 elements)
+  // Union: 1-100 (100 elements)
+  // Expected Jaccard: 51/100 = 0.51
+  facebook::velox::functions::SetDigest<int64_t> digest4(&allocator);
+  for (int64_t i = 25; i <= 75; i++) {
+    digest4.add(i);
+  }
+
+  int32_t size4 = digest4.estimatedSerializedSize();
+  std::vector<char> buffer4(size4);
+  digest4.serialize(buffer4.data());
+  std::string serialized4(buffer4.begin(), buffer4.end());
+
+  result = jaccardIndex(serialized1, serialized4);
+  ASSERT_TRUE(result.has_value());
+  expectedJaccard = 51.0 / 100.0;
+  EXPECT_NEAR(result.value(), expectedJaccard, 0.05);
+
+  // Test 5: Small overlap
+  // digest1: 1-100, digest5: 95-200
+  // Intersection: 95-100 (6 elements)
+  // Union: 1-200 (200 elements)
+  // Expected Jaccard: 6/200 = 0.03
+  facebook::velox::functions::SetDigest<int64_t> digest5(&allocator);
+  for (int64_t i = 95; i <= 200; i++) {
+    digest5.add(i);
+  }
+
+  int32_t size5 = digest5.estimatedSerializedSize();
+  std::vector<char> buffer5(size5);
+  digest5.serialize(buffer5.data());
+  std::string serialized5(buffer5.begin(), buffer5.end());
+
+  result = jaccardIndex(serialized1, serialized5);
+  ASSERT_TRUE(result.has_value());
+  expectedJaccard = 6.0 / 200.0;
+  EXPECT_NEAR(result.value(), expectedJaccard, 0.05);
+
+  // Test with null inputs.
+  result = jaccardIndex(std::nullopt, serialized1);
+  ASSERT_FALSE(result.has_value());
+
+  result = jaccardIndex(serialized1, std::nullopt);
+  ASSERT_FALSE(result.has_value());
+
+  result = jaccardIndex(std::nullopt, std::nullopt);
+  ASSERT_FALSE(result.has_value());
+}
+
+TEST_F(SetDigestFunctionsTest, testJaccardIndexApproximate) {
+  const auto jaccardIndex = [&](const std::optional<std::string>& input1,
+                                const std::optional<std::string>& input2) {
+    return evaluateOnce<double>(
+        "jaccard_index(c0, c1)", {SETDIGEST(), SETDIGEST()}, input1, input2);
+  };
+
+  auto pool = memory::memoryManager()->addLeafPool();
+  HashStringAllocator allocator(pool.get());
+
+  // Create large approximate digests
+  // digest1: 0-14999 (15000 elements)
+  facebook::velox::functions::SetDigest<int64_t> digest1(&allocator);
+  for (int64_t i = 0; i < 15000; i++) {
+    digest1.add(i);
+  }
+  ASSERT_FALSE(digest1.isExact());
+
+  // digest2: 5000-19999 (15000 elements)
+  // Intersection: 5000-14999 (10000 elements)
+  // Union: 0-19999 (20000 elements)
+  // Expected Jaccard: 10000/20000 = 0.5
+  facebook::velox::functions::SetDigest<int64_t> digest2(&allocator);
+  for (int64_t i = 5000; i < 20000; i++) {
+    digest2.add(i);
+  }
+  ASSERT_FALSE(digest2.isExact());
+
+  int32_t size1 = digest1.estimatedSerializedSize();
+  std::vector<char> buffer1(size1);
+  digest1.serialize(buffer1.data());
+  std::string serialized1(buffer1.begin(), buffer1.end());
+
+  int32_t size2 = digest2.estimatedSerializedSize();
+  std::vector<char> buffer2(size2);
+  digest2.serialize(buffer2.data());
+  std::string serialized2(buffer2.begin(), buffer2.end());
+
+  auto result = jaccardIndex(serialized1, serialized2);
+  ASSERT_TRUE(result.has_value());
+  // Expected value is 0.5, allow reasonable margin for approximation
+  EXPECT_GE(result.value(), 0.0);
+  EXPECT_LE(result.value(), 1.0);
+  EXPECT_NEAR(result.value(), 0.5, 0.15);
+
+  // Test with same approximate digest (self-similarity)
+  result = jaccardIndex(serialized1, serialized1);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_DOUBLE_EQ(result.value(), 1.0);
+
+  // Test with disjoint approximate sets
+  // digest3: 30000-44999 (15000 elements, no overlap with digest1)
+  facebook::velox::functions::SetDigest<int64_t> digest3(&allocator);
+  for (int64_t i = 30000; i < 45000; i++) {
+    digest3.add(i);
+  }
+  ASSERT_FALSE(digest3.isExact());
+
+  int32_t size3 = digest3.estimatedSerializedSize();
+  std::vector<char> buffer3(size3);
+  digest3.serialize(buffer3.data());
+  std::string serialized3(buffer3.begin(), buffer3.end());
+
+  result = jaccardIndex(serialized1, serialized3);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_NEAR(result.value(), 0.0, 0.1);
+}
diff --git a/velox/functions/prestosql/tests/SfmSketchFunctionsTest.cpp b/velox/functions/prestosql/tests/SfmSketchFunctionsTest.cpp
new file mode 100644
index 000000000000..81805caaa58d
--- /dev/null
+++ b/velox/functions/prestosql/tests/SfmSketchFunctionsTest.cpp
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/sfm/SfmSketch.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
+
+namespace facebook::velox::functions::test {
+using SfmSketch = facebook::velox::functions::sfm::SfmSketch;
+
+class SfmSketchFunctionsTest : public functions::test::FunctionBaseTest {
+ protected:
+  std::shared_ptr<memory::MemoryPool> pool_{
+      memory::memoryManager()->addLeafPool()};
+  HashStringAllocator allocator_{pool_.get()};
+};
+
+TEST_F(SfmSketchFunctionsTest, cardinalityTest) {
+  const auto cardinality = [&](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>("cardinality(c0)", SFMSKETCH(), input);
+  };
+
+  // Test empty sketch.
+  SfmSketch sketch{&allocator_, /* seed */ 1};
+  sketch.initialize(4096, 24);
+
+  const auto serializedSize = sketch.serializedSize();
+
+  std::vector<char> buffer(serializedSize);
+  sketch.serialize(buffer.data());
+  std::string serializedEmpty(buffer.begin(), buffer.end());
+  EXPECT_EQ(*cardinality(serializedEmpty), 0);
+
+  // Add distinct elements
+  const int64_t numElements = 100'000;
+  for (auto i = 0; i < numElements; i++) {
+    sketch.add(i);
+  }
+  // Add noise to the sketch.
+  sketch.enablePrivacy(8.0);
+
+  std::vector<char> buffer2(sketch.serializedSize());
+  sketch.serialize(buffer2.data());
+  std::string serialized2(buffer2.begin(), buffer2.end());
+  const auto result = cardinality(serialized2);
+
+  // SfmSketch is an approximate algorithm, typically we allow 25% error.
+  // In the unit test, we are using deterministic seed.
+  EXPECT_EQ(*result, 100'305);
+}
+
+TEST_F(SfmSketchFunctionsTest, cardinalityWithDuplicates) {
+  const auto cardinality = [&](const std::optional<std::string>& input) {
+    return evaluateOnce<int64_t>("cardinality(c0)", SFMSKETCH(), input);
+  };
+
+  SfmSketch sketch{&allocator_, 1};
+  sketch.initialize(4096, 24);
+
+  for (int i = 0; i < 100000; i++) {
+    sketch.add(i % 100);
+  }
+
+  std::string buffer(sketch.serializedSize(), '\0');
+  sketch.serialize(buffer.data());
+  const auto result = cardinality(buffer);
+
+  EXPECT_EQ(*result, 99);
+}
+
+TEST_F(SfmSketchFunctionsTest, noisyEmptyApproxSetSfm) {
+  // Test with epsilon only.
+  auto a = evaluateOnce<int64_t>(
+      "cardinality(noisy_empty_approx_set_sfm(INFINITY()))",
+      makeRowVector(ROW({}), 1));
+  ASSERT_EQ(*a, 0);
+
+  // Test with epsilon and buckets.
+  auto b = evaluateOnce<int64_t>(
+      "cardinality(noisy_empty_approx_set_sfm(INFINITY(), 1024))",
+      makeRowVector(ROW({}), 1));
+  ASSERT_EQ(*b, 0);
+
+  // Test with epsilon, buckets, and precision.
+  auto c = evaluateOnce<int64_t>(
+      "cardinality(noisy_empty_approx_set_sfm(INFINITY(), 1024, 20))",
+      makeRowVector(ROW({}), 1));
+  ASSERT_EQ(*c, 0);
+}
+
+TEST_F(SfmSketchFunctionsTest, mergeSfmSketchArray) {
+  // Create two sketches with overlapping elements.
+  SfmSketch a{&allocator_};
+  a.initialize(4096, 24);
+  for (int i = 0; i < 50; i++) {
+    a.add(i);
+  }
+
+  SfmSketch b{&allocator_};
+  b.initialize(4096, 24);
+  for (int i = 25; i < 75; i++) {
+    b.add(i);
+  }
+
+  std::string aString(a.serializedSize(), '\0');
+  a.serialize(aString.data());
+
+  std::string bString(b.serializedSize(), '\0');
+  b.serialize(bString.data());
+
+  // Test merging array of sketches.
+  const auto mergedResult = evaluateOnce<std::string>(
+      "merge_sfm(c0)",
+      makeRowVector(
+          {makeArrayVector<std::string>({{aString, bString}}, SFMSKETCH())}));
+
+  const auto mergedCardinality =
+      evaluateOnce<int64_t>("cardinality(c0)", SFMSKETCH(), mergedResult);
+
+  // There are 75 distinct elements in the sketch.
+  ASSERT_EQ(mergedCardinality, 75);
+}
+
+TEST_F(SfmSketchFunctionsTest, mergeSfmSketchEmpty) {
+  // Test merging empty array should return null.
+  const auto result = evaluate(
+      "merge_sfm(c0)",
+      makeRowVector({makeArrayVector<std::string>({}, SFMSKETCH())}));
+
+  EXPECT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(SfmSketchFunctionsTest, mergeSfmSketchAllNulls) {
+  // Test merging array with all null sketches should return null.
+  const auto result = evaluate(
+      "merge_sfm(c0)",
+      makeRowVector({makeNullableArrayVector<std::string>(
+          {std::nullopt, std::nullopt}, ARRAY(SFMSKETCH()))}));
+
+  EXPECT_TRUE(result->isNullAt(0));
+}
+
+TEST_F(SfmSketchFunctionsTest, cardinalityNull) {
+  // Test cardinality with null input.
+  const auto result = evaluate(
+      "cardinality(c0)",
+      makeRowVector(
+          {makeNullableFlatVector<std::string>({std::nullopt}, SFMSKETCH())}));
+
+  EXPECT_TRUE(result->isNullAt(0));
+}
+
+} // namespace facebook::velox::functions::test
diff --git a/velox/functions/prestosql/tests/SfmsketchCastTest.cpp b/velox/functions/prestosql/tests/SfmsketchCastTest.cpp
new file mode 100644
index 000000000000..bf984cbde313
--- /dev/null
+++ b/velox/functions/prestosql/tests/SfmsketchCastTest.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/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
+
+using namespace facebook::velox;
+
+class SfmsketchCastTest : public functions::test::CastBaseTest {};
+
+TEST_F(SfmsketchCastTest, toSfmSketch) {
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      SFMSKETCH(),
+      {"sfm_sketch"_sv, ""_sv, std::nullopt},
+      {"sfm_sketch"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      VARBINARY(),
+      SFMSKETCH(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
+
+TEST_F(SfmsketchCastTest, fromSfmSketch) {
+  testCast<StringView, StringView>(
+      SFMSKETCH(),
+      VARBINARY(),
+      {"sfm_sketch"_sv, ""_sv, std::nullopt},
+      {"sfm_sketch"_sv, ""_sv, std::nullopt});
+  testCast<StringView, StringView>(
+      SFMSKETCH(),
+      VARBINARY(),
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt},
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+}
diff --git a/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp b/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
index a12f21e2ed47..c732197dea02 100644
--- a/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
+++ b/velox/functions/prestosql/tests/SimpleComparisonMatcherTest.cpp
@@ -16,7 +16,7 @@
 #include <gtest/gtest.h>
 
 #include "velox/expression/VectorFunction.h"
-#include "velox/functions/prestosql/SimpleComparisonMatcher.h"
+#include "velox/functions/lib/SimpleComparisonMatcher.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
@@ -83,6 +83,8 @@ TEST_F(SimpleComparisonMatcherTest, basic) {
   const auto inputType =
       ROW({"a"}, {ARRAY(ROW({"f", "g"}, {BIGINT(), BIGINT()}))});
 
+  auto checker = std::make_unique<SimpleComparisonChecker>();
+
   auto testMatcher = [&](const std::string& expr,
                          std::optional<bool> lessThan) {
     SCOPED_TRACE(expr);
@@ -92,8 +94,7 @@ TEST_F(SimpleComparisonMatcherTest, basic) {
     auto lambdaExpr = std::dynamic_pointer_cast<const core::LambdaTypedExpr>(
         parsedExpr->inputs()[1]);
 
-    auto comparison =
-        functions::prestosql::isSimpleComparison(prefix_, *lambdaExpr);
+    auto comparison = checker->isSimpleComparison(prefix_, *lambdaExpr);
 
     ASSERT_EQ(lessThan.has_value(), comparison.has_value());
     if (lessThan.has_value()) {
diff --git a/velox/functions/prestosql/tests/StringFunctionsTest.cpp b/velox/functions/prestosql/tests/StringFunctionsTest.cpp
index 03dc87f6f548..5cbf2c31f39d 100644
--- a/velox/functions/prestosql/tests/StringFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/StringFunctionsTest.cpp
@@ -315,6 +315,10 @@ class StringFunctionsTest : public FunctionBaseTest {
       const std::string& left,
       const std::string& right);
 
+  double jaroWinklerSimilarity(
+      const std::string& left,
+      const std::string& right);
+
   using replace_input_test_t = std::vector<std::pair<
       std::tuple<std::string, std::string, std::string>,
       std::string>>;
@@ -1048,6 +1052,44 @@ TEST_F(StringFunctionsTest, length) {
   }
 }
 
+TEST_F(StringFunctionsTest, bitLength) {
+  const auto bitLength = [&](std::optional<std::string> arg) {
+    return evaluateOnce<int64_t>("bit_length(c0)", std::move(arg));
+  };
+
+  // Test basic cases
+  EXPECT_EQ(bitLength(""), 0);
+  EXPECT_EQ(bitLength("hello"), 40);
+
+  // Test non-ASCII characters
+  EXPECT_EQ(bitLength("hell o\u00EF"), 64);
+  EXPECT_EQ(bitLength("中123"), 48);
+
+  // Single byte characters
+  EXPECT_EQ(bitLength("a"), 8);
+  EXPECT_EQ(bitLength("ab"), 16);
+  EXPECT_EQ(bitLength("abc"), 24);
+
+  // Multi-byte UTF-8 characters
+  EXPECT_EQ(bitLength("é"), 16);
+  EXPECT_EQ(bitLength("€"), 24);
+  EXPECT_EQ(bitLength("\U0001F408"), 32);
+
+  // Mixed ASCII and Unicode
+  EXPECT_EQ(bitLength("hello世界"), 88);
+
+  // Test with null input
+  EXPECT_EQ(bitLength(std::nullopt), std::nullopt);
+
+  // Test constant vectors
+  auto rows = makeRowVector({makeRowVector(
+      {makeFlatVector<int32_t>(5, [](vector_size_t row) { return row; })})});
+  auto result = evaluate<SimpleVector<int64_t>>("bit_length('test')", rows);
+  for (int i = 0; i < 5; ++i) {
+    EXPECT_EQ(result->valueAt(i), 32);
+  }
+}
+
 TEST_F(StringFunctionsTest, startsWith) {
   auto startsWith = [&](const std::string& x, const std::string& y) {
     return evaluateOnce<bool>(
@@ -1415,6 +1457,122 @@ TEST_F(StringFunctionsTest, invalidLevenshteinDistance) {
       "The combined inputs size exceeded max Levenshtein distance combined input size");
 }
 
+double StringFunctionsTest::jaroWinklerSimilarity(
+    const std::string& left,
+    const std::string& right) {
+  return evaluateOnce<double>(
+             "jarowinkler_similarity(c0, c1)",
+             std::optional(left),
+             std::optional(right))
+      .value();
+}
+
+TEST_F(StringFunctionsTest, asciiJaroWinklerSimilarity) {
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("", ""), 1.0);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("TRACE", "TRACE"), 1.0);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("TRATE", "TRACE"), 0.91);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("TRACE", "TRATE"), 0.91);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("arnab", "aranb"), 0.95);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("DwAyNE", "DuANE"), 0.84);
+
+  // Test edge cases with empty strings
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("abc", ""), 0.0);
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("", "xyz"), 0.0);
+}
+
+TEST_F(StringFunctionsTest, unicodeJaroWinklerSimilarity) {
+  // Test for non-ASCII
+  EXPECT_DOUBLE_EQ(jaroWinklerSimilarity("TRA\u00EFE", "TRACE"), 0.91);
+  EXPECT_DOUBLE_EQ(
+      jaroWinklerSimilarity(
+          "\u4FE1\u5FF5\u7231\u00EF\u671B", "\u4FE1\u5FF5\u7231\u5E0C\u671B"),
+      0.91);
+  EXPECT_DOUBLE_EQ(
+      jaroWinklerSimilarity(
+          "\u4FE1\u00EF\u7231y\u5E0C\u671B", "\u4FE1\u5FF5\u7231\u5E0C\u671B"),
+      0.84);
+}
+
+TEST_F(StringFunctionsTest, invalidJaroWinklerSimilarity) {
+  // Test for invalid utf-8 characters
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity("hello world", "a\xA9ü"),
+      "Invalid UTF-8 encoding in characters");
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity("hello world", "Ψ\xFF\xFFΣΓΔA"),
+      "Invalid UTF-8 encoding in characters");
+
+  // Test for maximum length
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity(std::string(1001, 'x'), std::string(1001, 'x')),
+      "The combined inputs for Jaro-Winkler similarity are too large");
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity("hello", std::string(500000, 'x')),
+      "The combined inputs for Jaro-Winkler similarity are too large");
+  VELOX_ASSERT_THROW(
+      jaroWinklerSimilarity(std::string(500000, 'x'), "hello"),
+      "The combined inputs for Jaro-Winkler similarity are too large");
+}
+
+TEST_F(StringFunctionsTest, longestCommonPrefix) {
+  const auto longestCommonPrefix = [&](std::optional<std::string> left,
+                                       std::optional<std::string> right) {
+    return evaluateOnce<std::string>(
+        "longest_common_prefix(c0, c1)", std::move(left), std::move(right));
+  };
+
+  // Test basic cases.
+  EXPECT_EQ(longestCommonPrefix("", ""), "");
+  EXPECT_EQ(longestCommonPrefix("", "hello"), "");
+  EXPECT_EQ(longestCommonPrefix("hello", ""), "");
+  EXPECT_EQ(longestCommonPrefix("hello", "hello"), "hello");
+  EXPECT_EQ(longestCommonPrefix("hello world", "hello"), "hello");
+  EXPECT_EQ(longestCommonPrefix("hello", "hello world"), "hello");
+  EXPECT_EQ(longestCommonPrefix("hello world", "hel wold"), "hel");
+  EXPECT_EQ(longestCommonPrefix("hel wold", "hello world"), "hel");
+
+  // Test for non-ASCII.
+  EXPECT_EQ(longestCommonPrefix("\u4FE1\u5FF5,\u7231,\u5E0C\u671B", ""), "");
+  EXPECT_EQ(longestCommonPrefix("", "\u4FE1\u5FF5,\u7231,\u5E0C\u671B"), "");
+  EXPECT_EQ(
+      longestCommonPrefix(
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B",
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B"),
+      "\u4FE1\u5FF5,\u7231,\u5E0C\u671B");
+  EXPECT_EQ(
+      longestCommonPrefix(
+          "\u4FE1\u5FF5,\u7221,\u5E0C\u671B",
+          "\u4FE1\u5FF5,\u7231,\u5E0C\u671B"),
+      "\u4FE1\u5FF5,");
+  EXPECT_EQ(
+      longestCommonPrefix("hello na\u00EFve world", "hello na\u00EFve"),
+      "hello na\u00EFve");
+
+  // Test null cases.
+  EXPECT_EQ(longestCommonPrefix(std::nullopt, "hello"), std::nullopt);
+  EXPECT_EQ(longestCommonPrefix("hello", std::nullopt), std::nullopt);
+  EXPECT_EQ(longestCommonPrefix(std::nullopt, std::nullopt), std::nullopt);
+
+  // Test different lengths.
+  EXPECT_EQ(longestCommonPrefix("a", "abcdef"), "a");
+  EXPECT_EQ(longestCommonPrefix("abcdef", "a"), "a");
+
+  // Additional Unicode tests.
+  EXPECT_EQ(longestCommonPrefix("café", "cat"), "ca");
+  EXPECT_EQ(longestCommonPrefix("préfix", "prefix"), "pr");
+  EXPECT_EQ(longestCommonPrefix("🚀🌟", "🚀🔥"), "🚀");
+  EXPECT_EQ(longestCommonPrefix("Ψ", "Ψmore"), "Ψ");
+  EXPECT_EQ(longestCommonPrefix("hellö", "hell"), "hell");
+
+  // Test for invalid UTF-8 characters.
+  VELOX_ASSERT_THROW(
+      longestCommonPrefix("hello world", "\x81"),
+      "Invalid UTF-8 encoding in characters");
+  VELOX_ASSERT_THROW(
+      longestCommonPrefix("hello world", "2\x81"),
+      "Invalid UTF-8 encoding in characters");
+}
+
 void StringFunctionsTest::testReplaceFlatVector(
     const replace_input_test_t& tests,
     bool withReplaceArgument,
@@ -1737,10 +1895,11 @@ TEST_F(StringFunctionsTest, toUtf8) {
   // during execution) to a vector of size 2 and passed on to to_utf8(). Here,
   // if the intermediate flat vector is created for a size > 2 then the function
   // throws.
-  EXPECT_NO_THROW(evaluateSimplified<FlatVector<bool>>(
-      "to_utf8(c0) = to_utf8('this')",
-      makeRowVector({makeNullableFlatVector<StringView>(
-          {std::nullopt, "test"_sv, std::nullopt})})));
+  EXPECT_NO_THROW(
+      evaluateSimplified<FlatVector<bool>>(
+          "to_utf8(c0) = to_utf8('this')",
+          makeRowVector({makeNullableFlatVector<StringView>(
+              {std::nullopt, "test"_sv, std::nullopt})})));
 }
 
 namespace {
diff --git a/velox/functions/prestosql/tests/TDigestFunctionsTest.cpp b/velox/functions/prestosql/tests/TDigestFunctionsTest.cpp
index c2a8144c6731..f8c9e6c4d795 100644
--- a/velox/functions/prestosql/tests/TDigestFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/TDigestFunctionsTest.cpp
@@ -127,6 +127,17 @@ TEST_F(TDigestFunctionsTest, valuesAtQuantiles) {
   test::assertEqualVectors(expected, result);
 }
 
+TEST_F(TDigestFunctionsTest, valuesAtQuantilesWithNulls) {
+  const std::string input = decodeBase64(
+      "AQAAAAAAAADwPwAAAAAAABRAAAAAAAAALkAAAAAAAABZQAAAAAAAABRABQAAAAAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAABAAAAAAAAACEAAAAAAAAAQQAAAAAAAABRA");
+  auto arg0 = makeFlatVector<std::string>({input}, TDIGEST_DOUBLE);
+  auto arg1 = makeNullableArrayVector<double>({{0.1, std::nullopt, 0.9, 0.99}});
+
+  VELOX_ASSERT_THROW(
+      evaluate("values_at_quantiles(c0, c1)", makeRowVector({arg0, arg1})),
+      "All quantiles should be non-null.");
+}
+
 TEST_F(TDigestFunctionsTest, testMergeTDigestNullInput) {
   auto arg0 = makeNullableArrayVector<std::string>(
       {std::nullopt}, ARRAY_TDIGEST_DOUBLE);
@@ -433,6 +444,29 @@ TEST_F(TDigestFunctionsTest, quantileAtValueExponentialDistribution) {
   }
 }
 
+// Test quantiles_at_values
+TEST_F(TDigestFunctionsTest, quantilesAtValues) {
+  const std::string input = decodeBase64(
+      "AQAAAAAAAADwPwAAAAAAABRAAAAAAAAALkAAAAAAAABZQAAAAAAAABRABQAAAAAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAABAAAAAAAAACEAAAAAAAAAQQAAAAAAAABRA");
+  auto arg0 = makeFlatVector<std::string>({input}, TDIGEST_DOUBLE);
+  auto arg1 = makeNullableArrayVector<double>({{1.0, 3.0, 5.0}});
+  auto expected = makeNullableArrayVector<double>({{0.1, 0.5, 0.9}});
+  auto result =
+      evaluate("quantiles_at_values(c0, c1)", makeRowVector({arg0, arg1}));
+  test::assertEqualVectors(expected, result);
+}
+
+// Test quantiles_at_values
+TEST_F(TDigestFunctionsTest, quantilesAtValuesNull) {
+  const std::string input = decodeBase64(
+      "AQAAAAAAAADwPwAAAAAAABRAAAAAAAAALkAAAAAAAABZQAAAAAAAABRABQAAAAAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAABAAAAAAAAACEAAAAAAAAAQQAAAAAAAABRA");
+  auto arg0 = makeFlatVector<std::string>({input}, TDIGEST_DOUBLE);
+  auto arg1 = makeNullableArrayVector<double>({{1.0, std::nullopt, 3.0, 5.0}});
+  VELOX_ASSERT_THROW(
+      evaluate("quantiles_at_values(c0, c1)", makeRowVector({arg0, arg1})),
+      "All values should be non-null.");
+}
+
 TEST_F(TDigestFunctionsTest, testConstructTDigest) {
   // Create arrays for centroid means and weights
   std::vector<std::vector<double>> means = {
diff --git a/velox/functions/prestosql/tests/TimeWithTimezoneCastTest.cpp b/velox/functions/prestosql/tests/TimeWithTimezoneCastTest.cpp
new file mode 100644
index 000000000000..6d45ab601fbe
--- /dev/null
+++ b/velox/functions/prestosql/tests/TimeWithTimezoneCastTest.cpp
@@ -0,0 +1,790 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/Time.h"
+
+using facebook::velox::util::biasEncode;
+using facebook::velox::util::pack;
+
+namespace facebook::velox {
+namespace {
+
+inline int64_t getUTCMillis(
+    int64_t hours,
+    int64_t minutes = 0,
+    int64_t seconds = 0,
+    int64_t millis = 0) {
+  return hours * util::kMillisInHour + minutes * util::kMillisInMinute +
+      seconds * util::kMillisInSecond + millis;
+}
+
+class TimeWithTimezoneCastTest : public functions::test::CastBaseTest {
+ protected:
+  void setQueryTimeZone(const std::string& timeZone) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+
+  void setQueryTimeZoneAndStartTime(
+      const std::string& timeZone,
+      int64_t startTimeMs) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+        {core::QueryConfig::kSessionStartTime, std::to_string(startTimeMs)},
+    });
+  }
+
+  void disableAdjustTimestampToTimezone() {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kAdjustTimestampToTimezone, "false"},
+    });
+  }
+
+  // Helper to pack TIME WITH TIME ZONE value
+  int64_t packTimeWithTZ(int64_t timeMillis, int16_t offsetMinutes) {
+    auto encodedOffset = biasEncode(offsetMinutes);
+    return pack(timeMillis, encodedOffset);
+  }
+};
+
+TEST_F(TimeWithTimezoneCastTest, toVarchar) {
+  // Test comprehensive scenarios: various times, timezones, boundary values,
+  // and nulls. Note: Time is stored in UTC, so when displaying, we convert
+  // UTC time to local time by adding the timezone offset.
+  auto input = makeNullableFlatVector<int64_t>(
+      {
+          // Constant values to test any regressions
+          // in pack and biasEncode functions.
+          58755883008,
+          // 11:31:37.123 UTC with timezone +05:30 -> displays as 17:01:37.123
+          169972216978,
+          // 11:31:37.123 UTC with timezone -05:00 -> displays as 06:31:37.123
+          169972216349,
+          // UTC time 06:11:37.123 with UTC timezone -> displays as
+          // 06:11:37.123+00:00
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(0)),
+          // UTC time 06:11:37.123 with -05:00 timezone -> displays as
+          // 01:11:37.123-05:00
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(-5 * 60)),
+          // UTC time 06:11:37.123 with +05:30 timezone -> displays as
+          // 11:41:37.123+05:30
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(5 * 60 + 30)),
+          // Boundary: Midnight UTC with UTC timezone
+          pack(0, biasEncode(0)),
+          // Boundary: Almost end of day UTC with UTC timezone
+          pack(getUTCMillis(23, 59, 59, 999), biasEncode(0)),
+          // Null value.
+          std::nullopt,
+          // UTC time 12:00:00 with +14:00 timezone -> displays as
+          // 02:00:00.000+14:00 (next day wrap)
+          pack(getUTCMillis(12), biasEncode(14 * 60)),
+          // UTC time 12:00:00 with -14:00 timezone -> displays as
+          // 22:00:00.000-14:00 (prev day wrap)
+          pack(getUTCMillis(12), biasEncode(-14 * 60)),
+          // Edge case: 1 millisecond after midnight UTC with UTC timezone
+          pack(1, biasEncode(0)),
+          // UTC time 12:34:56.789 with -04:30 timezone -> displays as
+          // 08:04:56.789-04:30
+          pack(getUTCMillis(12, 34, 56, 789), biasEncode(-4 * 60 - 30)),
+          // UTC time 09:08:07 with +05:45 timezone -> displays as
+          // 14:53:07.000+05:45
+          pack(getUTCMillis(9, 8, 7), biasEncode(5 * 60 + 45)),
+          // Another null value.
+          std::nullopt,
+      },
+      TIME_WITH_TIME_ZONE());
+
+  auto expected = makeNullableFlatVector<std::string>({
+      "03:59:04.698+00:00",
+      "17:01:37.123+05:30",
+      "06:31:37.123-05:00",
+      "06:11:37.123+00:00",
+      "01:11:37.123-05:00",
+      "11:41:37.123+05:30",
+      "00:00:00.000+00:00",
+      "23:59:59.999+00:00",
+      std::nullopt,
+      "02:00:00.000+14:00",
+      "22:00:00.000-14:00",
+      "00:00:00.001+00:00",
+      "08:04:56.789-04:30",
+      "14:53:07.000+05:45",
+      std::nullopt,
+  });
+
+  testCast(input, expected);
+}
+
+TEST_F(TimeWithTimezoneCastTest, fromVarchar) {
+  // Test casting VARCHAR to TIME WITH TIME ZONE with various formats.
+  // Note: Input strings represent local time, which gets converted to UTC for
+  // storage.
+  auto input = makeNullableFlatVector<std::string>({
+      // Basic format: H:m:s.SSS+HH:mm
+      "6:11:37.123+00:00",
+      "6:11:37.123-05:00", // Local 06:11:37.123 in UTC-5 = 11:11:37.123 UTC
+      "6:11:37.123+05:30", // Local 06:11:37.123 in UTC+5:30 = 00:41:37.123 UTC
+      // Format without milliseconds: H:m:s+HH:mm
+      "12:34:56+01:00", // Local 12:34:56 in UTC+1 = 11:34:56 UTC
+      "12:34:56-08:00", // Local 12:34:56 in UTC-8 = 20:34:56 UTC
+      // Compact format: H:m+HH:mm
+      "1:30+05:30", // Local 01:30 in UTC+5:30 = 20:00 UTC (prev day)
+      "23:45-07:00", // Local 23:45 in UTC-7 = 06:45 UTC (next day)
+      // Format with space before timezone: H:m:s.SSS +HH:mm
+      "14:22:11.456 +02:00", // Local 14:22:11.456 in UTC+2 = 12:22:11.456 UTC
+      "9:15:30.789 -04:30", // Local 09:15:30.789 in UTC-4:30 = 13:45:30.789 UTC
+      // Compact timezone format (no colon): H:m:s+HHmm
+      "3:4:5+0709", // Local 03:04:05 in UTC+7:09 = 19:55:05 UTC (prev day)
+      "15:45:30-0800", // Local 15:45:30 in UTC-8 = 23:45:30 UTC
+      // Short timezone format: H:m:s+HH
+      "8:30:00+05", // Local 08:30:00 in UTC+5 = 03:30:00 UTC
+      "16:45:30-08", // Local 16:45:30 in UTC-8 = 00:45:30 UTC (next day)
+      // Boundary: Midnight with UTC
+      "0:0:0.000+00:00",
+      // Boundary: Almost end of day
+      "23:59:59.999+00:00",
+      // Boundary: Maximum positive timezone offset (+14:00)
+      "12:00:00.000+14:00", // Local 12:00 in UTC+14 = 22:00 UTC (prev day)
+      // Boundary: Maximum negative timezone offset (-14:00)
+      "12:00:00.000-14:00", // Local 12:00 in UTC-14 = 02:00 UTC (next day)
+      // Edge case: 1 millisecond after midnight
+      "0:0:0.001+00:00",
+      // Various valid formats with different hour/minute combinations
+      "9:8:7.000+05:45", // Local 09:08:07 in UTC+5:45 = 03:23:07 UTC
+      "1:2:3+01:30", // Local 01:02:03 in UTC+1:30 = 23:32:03 UTC (prev day)
+      // Null value
+      std::nullopt,
+      // Compact format with space: H:m +HH
+      "7:30 +03", // Local 07:30 in UTC+3 = 04:30 UTC
+      "18:45 -06", // Local 18:45 in UTC-6 = 00:45 UTC (next day)
+      // Double-digit hours and minutes: HH:mm:ss.SSS+HH:mm
+      "06:11:37.123+00:00",
+      "12:34:56.789-04:30", // Local 12:34:56.789 in UTC-4:30 = 17:04:56.789 UTC
+      "03:59:04.698+00:00",
+      "17:01:37.123+05:30",
+      "06:31:37.123-05:00",
+  });
+
+  auto expected = makeNullableFlatVector<int64_t>(
+      {
+          // "6:11:37.123+00:00" -> UTC 06:11:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(0)),
+          // "6:11:37.123-05:00" -> UTC 11:11:37.123
+          pack(getUTCMillis(11, 11, 37, 123), biasEncode(-5 * 60)),
+          // "6:11:37.123+05:30" -> UTC 00:41:37.123
+          pack(getUTCMillis(0, 41, 37, 123), biasEncode(5 * 60 + 30)),
+          // "12:34:56+01:00" -> UTC 11:34:56
+          pack(getUTCMillis(11, 34, 56), biasEncode(1 * 60)),
+          // "12:34:56-08:00" -> UTC 20:34:56
+          pack(getUTCMillis(20, 34, 56), biasEncode(-8 * 60)),
+          // "1:30+05:30" -> UTC 20:00:00 (prev day wraps to 20:00)
+          pack(getUTCMillis(20, 0), biasEncode(5 * 60 + 30)),
+          // "23:45-07:00" -> UTC 06:45:00 (next day wraps to 06:45)
+          pack(getUTCMillis(6, 45), biasEncode(-7 * 60)),
+          // "14:22:11.456 +02:00" -> UTC 12:22:11.456
+          pack(getUTCMillis(12, 22, 11, 456), biasEncode(2 * 60)),
+          // "9:15:30.789 -04:30" -> UTC 13:45:30.789
+          pack(getUTCMillis(13, 45, 30, 789), biasEncode(-4 * 60 - 30)),
+          // "3:4:5+0709" -> UTC 19:55:05 (prev day wraps to 19:55:05)
+          pack(getUTCMillis(19, 55, 5), biasEncode(7 * 60 + 9)),
+          // "15:45:30-0800" -> UTC 23:45:30
+          pack(getUTCMillis(23, 45, 30), biasEncode(-8 * 60)),
+          // "8:30:00+05" -> UTC 03:30:00
+          pack(getUTCMillis(3, 30), biasEncode(5 * 60)),
+          // "16:45:30-08" -> UTC 00:45:30 (next day wraps to 00:45:30)
+          pack(getUTCMillis(0, 45, 30), biasEncode(-8 * 60)),
+          // "0:0:0.000+00:00" -> UTC 00:00:00.000
+          pack(0, biasEncode(0)),
+          // "23:59:59.999+00:00" -> UTC 23:59:59.999
+          pack(getUTCMillis(23, 59, 59, 999), biasEncode(0)),
+          // "12:00:00.000+14:00" -> UTC 22:00:00 (prev day wraps to 22:00)
+          pack(getUTCMillis(22, 0, 0), biasEncode(14 * 60)),
+          // "12:00:00.000-14:00" -> UTC 02:00:00 (next day wraps to 02:00)
+          pack(getUTCMillis(2, 0, 0), biasEncode(-14 * 60)),
+          // "0:0:0.001+00:00" -> UTC 00:00:00.001
+          pack(1, biasEncode(0)),
+          // "9:8:7.000+05:45" -> UTC 03:23:07
+          pack(getUTCMillis(3, 23, 7), biasEncode(5 * 60 + 45)),
+          // "1:2:3+01:30" -> UTC 23:32:03 (prev day wraps to 23:32:03)
+          pack(getUTCMillis(23, 32, 3), biasEncode(1 * 60 + 30)),
+          // Null value
+          std::nullopt,
+          // "7:30 +03" -> UTC 04:30
+          pack(getUTCMillis(4, 30), biasEncode(3 * 60)),
+          // "18:45 -06" -> UTC 00:45 (next day wraps to 00:45)
+          pack(getUTCMillis(0, 45), biasEncode(-6 * 60)),
+          // "06:11:37.123+00:00" -> UTC 06:11:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(0)),
+          // "12:34:56.789-04:30" -> UTC 17:04:56.789
+          pack(getUTCMillis(17, 4, 56, 789), biasEncode(-4 * 60 - 30)),
+          // Constant values to test any regressions
+          // in pack and biasEncode functions.
+          58755883008,
+          // 11:31:37.123 UTC with timezone +05:30 -> displays as 17:01:37.123
+          169972216978,
+          // 11:31:37.123 UTC with timezone -05:00 -> displays as 06:31:37.123
+          169972216349,
+      },
+      TIME_WITH_TIME_ZONE());
+
+  testCast(input, expected);
+}
+
+TEST_F(TimeWithTimezoneCastTest, fromVarcharInvalid) {
+  // Test invalid VARCHAR inputs that should throw errors.
+  auto testInvalidCast = [&](const std::string& input,
+                             const std::string& expectedError) {
+    VELOX_ASSERT_THROW(
+        evaluateCast(
+            VARCHAR(),
+            TIME_WITH_TIME_ZONE(),
+            makeRowVector({makeFlatVector<std::string>({input})})),
+        expectedError);
+  };
+
+  // Invalid: Missing timezone offset
+  testInvalidCast("12:34:56", "missing timezone offset");
+
+  // Invalid: Hour out of range (25 > 23)
+  testInvalidCast("25:00:00+00:00", "Invalid hour value");
+
+  // Invalid: Minute out of range (60 >= 60)
+  testInvalidCast("12:60:00+00:00", "Invalid minute value");
+
+  // Invalid: Second out of range (60 >= 60)
+  testInvalidCast("12:34:60+00:00", "Invalid second value");
+
+  // Invalid: Microsecond precision not supported (4 digits after decimal)
+  testInvalidCast("12:34:56.1234+00:00", "Microsecond precision not supported");
+
+  // Invalid: Timezone offset out of range (+15:00 > +14:00)
+  testInvalidCast("12:00:00+15:00", "out of range");
+
+  // Invalid: Timezone offset out of range (-15:00 < -14:00)
+  testInvalidCast("12:00:00-15:00", "out of range");
+
+  // Invalid: Missing time component
+  testInvalidCast("+05:00", "missing time component");
+
+  // Invalid: Empty string
+  testInvalidCast("", "empty string");
+
+  // Invalid: Malformed format (missing colon in time)
+  testInvalidCast("1234+00:00", "expected ':' after hour");
+
+  // Invalid: Trailing characters after timezone
+  testInvalidCast("12:34:56+00:00extra", "unexpected trailing characters");
+
+  // Invalid: Number of digits in timezone offset hours is not 2
+  testInvalidCast("12:34:56+1:00", "digits before ':' not equal to 2");
+
+  // Invalid: Number of digits in timezone offset hours is not 2
+  testInvalidCast("12:34:56+01:", "failed to parse minutes after ':'");
+
+  // Invalid: IANA/Named timezones not supported (e.g., America/Los_Angeles)
+  testInvalidCast("12:34:56 America/Los_Angeles", "missing timezone offset");
+
+  // Invalid: IANA/Named timezones not supported (e.g., UTC)
+  testInvalidCast("14:30:45 UTC", "missing timezone offset");
+
+  // Invalid: IANA/Named timezones not supported (e.g., Asia/Tokyo)
+  testInvalidCast("09:15:30.123 Asia/Tokyo", "missing timezone offset");
+}
+
+TEST_F(TimeWithTimezoneCastTest, toTime) {
+  // Test casting TIME WITH TIME ZONE to TIME extracts the local time component
+  // (UTC time converted to local time by adding the timezone offset),
+  // discarding the timezone information.
+  auto input = makeNullableFlatVector<int64_t>(
+      {
+          // UTC 06:11:37.123 with +00:00 -> Local 06:11:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(0)),
+          // UTC 06:11:37.123 with -05:00 -> Local 01:11:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(-5 * 60)),
+          // UTC 06:11:37.123 with +05:30 -> Local 11:41:37.123
+          pack(getUTCMillis(6, 11, 37, 123), biasEncode(5 * 60 + 30)),
+          // Boundary: Midnight UTC with +00:00 -> Local 00:00:00.000
+          pack(0, biasEncode(0)),
+          // Boundary: Almost end of day UTC with +00:00 -> Local 23:59:59.999
+          pack(getUTCMillis(23, 59, 59, 999), biasEncode(0)),
+          // Null value.
+          std::nullopt,
+          // UTC 12:30:00 with +14:00 -> Local 02:30:00 (next day wrap)
+          pack(getUTCMillis(12, 30), biasEncode(14 * 60)),
+          // UTC 12:30:00 with -14:00 -> Local 22:30:00 (prev day wrap)
+          pack(getUTCMillis(12, 30), biasEncode(-14 * 60)),
+          // Edge case: 1 millisecond after midnight UTC with +00:00 -> Local
+          // 00:00:00.001
+          pack(1, biasEncode(0)),
+          // UTC 15:45:30.500 with -08:00 -> Local 07:45:30.500
+          pack(getUTCMillis(15, 45, 30, 500), biasEncode(-8 * 60)),
+          // Another null value.
+          std::nullopt,
+      },
+      TIME_WITH_TIME_ZONE());
+
+  auto expected = makeNullableFlatVector<int64_t>(
+      {
+          // UTC 06:11:37.123 + 0 = 06:11:37.123
+          getUTCMillis(6, 11, 37, 123),
+          // UTC 06:11:37.123 - 5 hours = 01:11:37.123
+          getUTCMillis(1, 11, 37, 123),
+          // UTC 06:11:37.123 + 5:30 = 11:41:37.123
+          getUTCMillis(11, 41, 37, 123),
+          // Midnight
+          0,
+          // Almost end of day
+          getUTCMillis(23, 59, 59, 999),
+          // Null
+          std::nullopt,
+          // UTC 12:30 + 14 hours = 26:30 -> wraps to 02:30
+          getUTCMillis(2, 30),
+          // UTC 12:30 - 14 hours = -1:30 -> wraps to 22:30
+          getUTCMillis(22, 30),
+          // 1 millisecond after midnight
+          1,
+          // UTC 15:45:30.500 - 8 hours = 07:45:30.500
+          getUTCMillis(7, 45, 30, 500),
+          // Null
+          std::nullopt,
+      },
+      TIME());
+
+  testCast(input, expected);
+
+  // UTC 14:22:11.456 with +05:30 -> Local 19:52:11.456
+  const int64_t timeWithTz =
+      pack(getUTCMillis(14, 22, 11, 456), biasEncode(5 * 60 + 30));
+
+  auto inputConstantVector =
+      makeConstant(timeWithTz, 10, TIME_WITH_TIME_ZONE());
+
+  const int64_t expectedTime = getUTCMillis(19, 52, 11, 456);
+  auto expectedConstantVector = makeConstant(expectedTime, 10, TIME());
+
+  testCast(inputConstantVector, expectedConstantVector);
+}
+
+TEST_F(TimeWithTimezoneCastTest, fromTime) {
+  {
+    // Test casting TIME to TIME WITH TIME ZONE with various times
+    // TIME values are in local time, and get converted to UTC for storage
+    auto input = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 (midnight) local
+            3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                321, // 03:04:05.321 local
+            12 * kMillisInHour, // 12:00:00.000 (noon) local
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999, // 23:59:59.999 (end of day) local
+        },
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+    // LA is UTC-8, so offset is -8 * 60 = -480 minutes
+    // Local times are converted to UTC: local - (-8 hours) = local + 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 08:00:00 UTC
+            packTimeWithTZ(8 * kMillisInHour, -480),
+            // 03:04:05.321 local -> 11:04:05.321 UTC
+            packTimeWithTZ(
+                11 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                    321,
+                -480),
+            // 12:00:00 local -> 20:00:00 UTC
+            packTimeWithTZ(20 * kMillisInHour, -480),
+            // 23:59:59.999 local -> 07:59:59.999 UTC (next day, wraps to
+            // 07:59:59.999)
+            packTimeWithTZ(
+                7 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with nulls
+    auto input = makeNullableFlatVector<int64_t>(
+        {0,
+         std::nullopt,
+         12 * kMillisInHour,
+         std::nullopt,
+         23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+             999},
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+    // LA is UTC-8, local times are converted to UTC: local + 8 hours
+
+    auto expected = makeNullableFlatVector<int64_t>(
+        {// 00:00:00 local -> 08:00:00 UTC
+         packTimeWithTZ(8 * kMillisInHour, -480),
+         std::nullopt,
+         // 12:00:00 local -> 20:00:00 UTC
+         packTimeWithTZ(20 * kMillisInHour, -480),
+         std::nullopt,
+         // 23:59:59.999 local -> 07:59:59.999 UTC (wraps to next day)
+         packTimeWithTZ(
+             7 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                 999,
+             -480)},
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with different timezone (Asia/Shanghai, UTC+8)
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            12 * kMillisInHour,
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999,
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+
+    // Shanghai is UTC+8, so offset is 8 * 60 = 480 minutes
+    // Local times are converted to UTC: local - 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 16:00:00 UTC (previous day, wraps to 16:00)
+            packTimeWithTZ(16 * kMillisInHour, 480),
+            // 12:00:00 local -> 04:00:00 UTC
+            packTimeWithTZ(4 * kMillisInHour, 480),
+            // 23:59:59.999 local -> 15:59:59.999 UTC
+            packTimeWithTZ(
+                15 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with adjustTimestampToTimezone disabled
+    // When disabled, offset should be 0 (UTC)
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond + 321,
+            12 * kMillisInHour,
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+    disableAdjustTimestampToTimezone();
+
+    // When adjustTimestampToTimezone is false, offset is 0 (UTC)
+    auto expected = makeFlatVector<int64_t>(
+        {
+            packTimeWithTZ(0, 0),
+            packTimeWithTZ(
+                3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                    321,
+                0),
+            packTimeWithTZ(12 * kMillisInHour, 0),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test constant TIME vector cast to TIME WITH TIME ZONE (non-null)
+    auto constantTimeVector = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({12 * kMillisInHour}, TIME()));
+
+    setQueryTimeZone("America/New_York");
+
+    // NY is UTC-5, so offset is -5 * 60 = -300 minutes
+    // 12:00:00 local -> 17:00:00 UTC
+    auto expected = BaseVector::wrapInConstant(
+        1000,
+        0,
+        makeFlatVector<int64_t>(
+            {packTimeWithTZ(17 * kMillisInHour, -300)}, TIME_WITH_TIME_ZONE()));
+
+    testCast(constantTimeVector, expected);
+  }
+
+  {
+    // Test constant TIME vector cast to TIME WITH TIME ZONE (null)
+    auto nullTimeVector = BaseVector::createNullConstant(TIME(), 500, pool());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto expected =
+        BaseVector::createNullConstant(TIME_WITH_TIME_ZONE(), 500, pool());
+
+    testCast(nullTimeVector, expected);
+  }
+
+  {
+    // Test constant TIME vector with different sizes
+    setQueryTimeZone("America/Los_Angeles");
+
+    for (auto size : {1, 10, 100, 1000}) {
+      auto constantTimeVector = BaseVector::wrapInConstant(
+          size,
+          0,
+          makeFlatVector<int64_t>(
+              {3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+               321},
+              TIME()));
+
+      // LA is UTC-8, so offset is -8 * 60 = -480 minutes
+      // 03:04:05.321 local -> 11:04:05.321 UTC
+      auto expected = BaseVector::wrapInConstant(
+          size,
+          0,
+          makeFlatVector<int64_t>(
+              {packTimeWithTZ(
+                  11 * kMillisInHour + 4 * kMillisInMinute +
+                      5 * kMillisInSecond + 321,
+                  -480)},
+              TIME_WITH_TIME_ZONE()));
+
+      testCast(constantTimeVector, expected);
+    }
+  }
+
+  {
+    // Test basic cast for completeness
+    auto input =
+        makeFlatVector<int64_t>({0, 12 * kMillisInHour, 86399999}, TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    // LA is UTC-8, local times are converted to UTC: local + 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 08:00:00 UTC
+            packTimeWithTZ(8 * kMillisInHour, -480),
+            // 12:00:00 local -> 20:00:00 UTC
+            packTimeWithTZ(20 * kMillisInHour, -480),
+            // 23:59:59.999 local -> 07:59:59.999 UTC (wraps to next day)
+            packTimeWithTZ(
+                7 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with session start time during DST (summer)
+    // 2023-07-15 12:00:00 UTC (during DST in America/Los_Angeles)
+    // LA is UTC-7 during DST, so offset is -7 * 60 = -420 minutes
+    int64_t sessionStartMs = 1689426000000LL; // 2023-07-15 12:00:00 UTC
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            12 * kMillisInHour,
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999,
+        },
+        TIME());
+
+    setQueryTimeZoneAndStartTime("America/Los_Angeles", sessionStartMs);
+
+    // During DST, LA is UTC-7 (PDT), so offset is -420 minutes
+    // Local times are converted to UTC: local - (-7 hours) = local + 7 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 07:00:00 UTC
+            packTimeWithTZ(7 * kMillisInHour, -420),
+            // 12:00:00 local -> 19:00:00 UTC
+            packTimeWithTZ(19 * kMillisInHour, -420),
+            // 23:59:59.999 local -> 06:59:59.999 UTC (next day wraps to
+            // 06:59:59.999)
+            packTimeWithTZ(
+                6 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                -420),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test with session start time during standard time (winter)
+    // 2023-01-15 12:00:00 UTC (during standard time in America/Los_Angeles)
+    // LA is UTC-8 during standard time, so offset is -8 * 60 = -480 minutes
+    int64_t sessionStartMs = 1673779200000LL; // 2023-01-15 12:00:00 UTC
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            12 * kMillisInHour,
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999,
+        },
+        TIME());
+
+    setQueryTimeZoneAndStartTime("America/Los_Angeles", sessionStartMs);
+
+    // During standard time, LA is UTC-8 (PST), so offset is -480 minutes
+    // Local times are converted to UTC: local - (-8 hours) = local + 8 hours
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // 00:00:00 local -> 08:00:00 UTC
+            packTimeWithTZ(8 * kMillisInHour, -480),
+            // 12:00:00 local -> 20:00:00 UTC
+            packTimeWithTZ(20 * kMillisInHour, -480),
+            // 23:59:59.999 local -> 07:59:59.999 UTC (next day wraps to
+            // 07:59:59.999)
+            packTimeWithTZ(
+                7 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+}
+
+TEST_F(TimeWithTimezoneCastTest, fromTimeVerifyUtcStorage) {
+  // This test verifies that when casting TIME to TIME WITH TIME ZONE,
+  // the time component is stored as UTC milliseconds, not local milliseconds.
+  // TIME WITH TIME ZONE stores:
+  // - Upper 52 bits: UTC milliseconds since midnight
+  // - Lower 12 bits: timezone offset
+
+  {
+    // TIME '14:00:00' in America/Los_Angeles (UTC-8)
+    // Local time: 14:00:00 -> UTC time: 22:00:00
+    auto input = makeFlatVector<int64_t>(
+        {
+            14 * kMillisInHour, // 14:00:00 local
+        },
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+    // LA is UTC-8, so offset is -8 * 60 = -480 minutes
+
+    // Cast TIME to TIME WITH TIME ZONE using testCast
+    auto expected = makeFlatVector<int64_t>(
+        {
+            packTimeWithTZ(22 * kMillisInHour, -480), // Expected: UTC 22:00
+        },
+        TIME_WITH_TIME_ZONE());
+
+    // This will fail with the current buggy implementation
+    testCast(input, expected);
+  }
+
+  {
+    // TIME '06:00:00' in Asia/Shanghai (UTC+8)
+    // Local time: 06:00:00 -> UTC time: 22:00:00 (previous day)
+    auto input = makeFlatVector<int64_t>(
+        {
+            6 * kMillisInHour, // 06:00:00 local
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+    // Shanghai is UTC+8, so offset is 8 * 60 = 480 minutes
+
+    auto expected = makeFlatVector<int64_t>(
+        {
+            // BUG: This will fail because current code stores local time
+            // (06:00), not UTC time (22:00)
+            packTimeWithTZ(22 * kMillisInHour, 480), // Expected: UTC 22:00
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, expected);
+  }
+
+  {
+    // Test case 3: Round-trip test
+    // TIME -> TIME WITH TIME ZONE -> TIME should preserve the original value
+    auto input = makeFlatVector<int64_t>(
+        {
+            14 * kMillisInHour + 30 * kMillisInMinute, // 14:30:00
+        },
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    // First cast TIME to TIME WITH TIME ZONE
+    auto timeWithTzExpected = makeFlatVector<int64_t>(
+        {
+            // UTC time should be 22:30:00 (14:30 - (-8:00) = 22:30)
+            packTimeWithTZ(22 * kMillisInHour + 30 * kMillisInMinute, -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    testCast(input, timeWithTzExpected);
+
+    // Then cast back to TIME - should preserve original local time
+    auto timeExpected = makeFlatVector<int64_t>(
+        {
+            14 * kMillisInHour + 30 * kMillisInMinute,
+        },
+        TIME());
+
+    testCast(timeWithTzExpected, timeExpected);
+  }
+
+  {
+    // Verify consistency with fromVarchar
+    // Casting "14:00:00-08:00" from VARCHAR should produce the same result
+    // as casting TIME '14:00:00' with America/Los_Angeles timezone
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    // Cast TIME to TIME WITH TIME ZONE
+    auto timeInput = makeFlatVector<int64_t>({14 * kMillisInHour}, TIME());
+
+    // Cast VARCHAR to TIME WITH TIME ZONE
+    auto varcharInput = makeFlatVector<std::string>({"14:00:00.000-08:00"});
+
+    // Both should produce the same result: UTC 22:00:00 with offset -480
+    auto expected = makeFlatVector<int64_t>(
+        {
+            packTimeWithTZ(22 * kMillisInHour, -480),
+        },
+        TIME_WITH_TIME_ZONE());
+
+    // Test TIME cast
+    testCast(timeInput, expected);
+
+    // Test VARCHAR cast
+    testCast(varcharInput, expected);
+  }
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp b/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
index d4f973e99fac..44b18a0803e4 100644
--- a/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
+++ b/velox/functions/prestosql/tests/TimestampWithTimeZoneCastTest.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/functions/prestosql/tests/CastBaseTest.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/type/TimestampConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox {
@@ -36,6 +37,22 @@ class TimestampWithTimeZoneCastTest : public functions::test::CastBaseTest {
         TIMESTAMP_WITH_TIME_ZONE());
   }
 
+  // Helper to parse a timestamp with timezone string and return packed value
+  // e.g., "2023-08-05 10:15:00.000 Europe/London"
+  int64_t parseTimestampWithTz(const std::string& str) {
+    auto parsed =
+        util::fromTimestampWithTimezoneString(
+            str.c_str(), str.size(), util::TimestampParseMode::kPrestoCast)
+            .thenOrThrow(folly::identity, [&](const Status& status) {
+              VELOX_USER_FAIL("{}", status.message());
+            });
+
+    // The parsed timestamp is in local time, need to convert to UTC
+    auto ts = parsed.timestamp;
+    ts.toGMT(*parsed.timeZone);
+    return pack(ts.toMillis(), parsed.timeZone->id());
+  }
+
  protected:
   void setQueryTimeZone(const std::string& timeZone) {
     queryCtx_->testingOverrideConfigUnsafe({
@@ -44,6 +61,16 @@ class TimestampWithTimeZoneCastTest : public functions::test::CastBaseTest {
     });
   }
 
+  void setQueryTimeZoneAndStartTime(
+      const std::string& timeZone,
+      int64_t startTimeMs) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionTimezone, timeZone},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+        {core::QueryConfig::kSessionStartTime, std::to_string(startTimeMs)},
+    });
+  }
+
   void disableAdjustTimestampToTimezone() {
     queryCtx_->testingOverrideConfigUnsafe({
         {core::QueryConfig::kAdjustTimestampToTimezone, "false"},
@@ -314,5 +341,351 @@ TEST_F(TimestampWithTimeZoneCastTest, fromDate) {
   test::assertEqualVectors(expected, result);
 }
 
+TEST_F(TimestampWithTimeZoneCastTest, fromTime) {
+  {
+    // Test casting TIME to TIMESTAMP WITH TIME ZONE with default session start
+    // time (epoch). TIME values represent time since midnight (in milliseconds)
+    auto input = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 (midnight)
+            3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                321, // 03:04:05.321
+            12 * kMillisInHour, // 12:00:00.000 (noon)
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999, // 23:59:59.999 (end of day)
+        },
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+    // When session start time is not set (default = 0), uses epoch (1970-01-01)
+    // LA is -8 hours from UTC (PST), so 00:00:00 PST = 08:00:00 UTC
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(8 * kMillisInHour, tzId), // 00:00:00.000 PST -> 08:00:00 UTC
+            pack(
+                3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                    321 + 8 * kMillisInHour,
+                tzId), // 03:04:05.321 PST -> 11:04:05.321 UTC
+            pack(
+                12 * kMillisInHour + 8 * kMillisInHour,
+                tzId), // 12:00:00.000 PST -> 20:00:00 UTC
+            pack(
+                23 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999 + 8 * kMillisInHour,
+                tzId), // 23:59:59.999 PST -> 07:59:59.999 UTC (next day)
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test casting TIME to TIMESTAMP WITH TIME ZONE with session start time set
+    // to 2023-01-15 10:30:00 UTC (1673780400000 ms)
+    // This should use the date from session start time (2023-01-15), not epoch
+    auto input = makeFlatVector<int64_t>(
+        {
+            0, // 00:00:00.000 (midnight)
+            12 * kMillisInHour, // 12:00:00.000 (noon)
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999, // 23:59:59.999
+        },
+        TIME());
+
+    // Session start time: 2023-01-15 10:30:00 UTC = 1673779800000 ms
+    // In LA timezone (PST, -8 hours), this is 2023-01-15 02:30:00 PST
+    // The date portion is 2023-01-15, which is 19372 days from epoch
+    // 2023-01-15 00:00:00 UTC = 19372 * 86400 * 1000 = 1673740800000 ms
+    int64_t sessionStartMs = 1673779800000LL; // 2023-01-15 10:30:00 UTC
+    setQueryTimeZoneAndStartTime("America/Los_Angeles", sessionStartMs);
+
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+    // Date portion: 2023-01-15 in LA timezone = 2023-01-15 00:00:00 PST
+    // = 2023-01-15 08:00:00 UTC = 1673740800000 + 8*3600*1000 = 1673769600000
+    int64_t dateBaseMs = 1673769600000LL; // 2023-01-15 00:00:00 UTC
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(
+                dateBaseMs,
+                tzId), // 2023-01-15 00:00:00.000 PST in UTC
+            pack(
+                dateBaseMs + 12 * kMillisInHour,
+                tzId), // 2023-01-15 12:00:00.000 PST in UTC
+            pack(
+                dateBaseMs + 23 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999,
+                tzId), // 2023-01-15 23:59:59.999 PST in UTC
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with nulls
+    auto input = makeNullableFlatVector<int64_t>(
+        {0,
+         std::nullopt,
+         12 * kMillisInHour,
+         std::nullopt,
+         23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+             999},
+        TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+    auto expected = makeNullableFlatVector<int64_t>(
+        {pack(8 * kMillisInHour, tzId),
+         std::nullopt,
+         pack(12 * kMillisInHour + 8 * kMillisInHour, tzId),
+         std::nullopt,
+         pack(
+             23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                 999 + 8 * kMillisInHour,
+             tzId)},
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with different timezone (Asia/Shanghai, +8 hours from UTC)
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            12 * kMillisInHour,
+            23 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond +
+                999,
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+
+    auto tzId = tz::getTimeZoneID("Asia/Shanghai");
+    // Shanghai is +8 hours from UTC, so 00:00:00 Shanghai = 16:00:00 UTC (prev
+    // day)
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(
+                -8 * kMillisInHour,
+                tzId), // 00:00:00 CST -> 16:00:00 UTC (prev day)
+            pack(
+                12 * kMillisInHour - 8 * kMillisInHour,
+                tzId), // 12:00:00 CST -> 04:00:00 UTC
+            pack(
+                23 * kMillisInHour + 59 * kMillisInMinute +
+                    59 * kMillisInSecond + 999 - 8 * kMillisInHour,
+                tzId), // 23:59:59.999 CST -> 15:59:59.999 UTC
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test with adjustTimestampToTimezone disabled
+    // When disabled, TIME values are treated as already in UTC
+    auto input = makeFlatVector<int64_t>(
+        {
+            0,
+            3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond + 321,
+            12 * kMillisInHour,
+        },
+        TIME());
+
+    setQueryTimeZone("Asia/Shanghai");
+    disableAdjustTimestampToTimezone();
+
+    auto tzId = tz::getTimeZoneID("Asia/Shanghai");
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(0, tzId),
+            pack(
+                3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+                    321,
+                tzId),
+            pack(12 * kMillisInHour, tzId),
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+
+  {
+    // Test constant TIME vector cast to TIMESTAMP WITH TIME ZONE (non-null)
+    // This tests the optimization path for constant vectors
+    auto constantTimeVector = BaseVector::wrapInConstant(
+        1000, 0, makeFlatVector<int64_t>({12 * kMillisInHour}, TIME()));
+
+    setQueryTimeZone("America/New_York");
+
+    auto tzId = tz::getTimeZoneID("America/New_York");
+    // NY is -5 hours from UTC (EST), so 12:00:00 EST = 17:00:00 UTC
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)",
+        makeRowVector({constantTimeVector}));
+
+    // Should return a constant vector with the adjusted value
+    auto expected = BaseVector::wrapInConstant(
+        1000,
+        0,
+        makeFlatVector<int64_t>(
+            {pack(12 * kMillisInHour + 5 * kMillisInHour, tzId)},
+            TIMESTAMP_WITH_TIME_ZONE()));
+
+    test::assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded (optimization worked)
+    ASSERT_TRUE(result->isConstantEncoding());
+  }
+
+  {
+    // Test constant TIME vector cast to TIMESTAMP WITH TIME ZONE (null)
+    // This tests the optimization path for null constant vectors
+    auto nullTimeVector = BaseVector::createNullConstant(TIME(), 500, pool());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto result = evaluate(
+        "cast(c0 as timestamp with time zone)",
+        makeRowVector({nullTimeVector}));
+
+    // Should return a null constant vector
+    auto expected =
+        BaseVector::createNullConstant(TIMESTAMP_WITH_TIME_ZONE(), 500, pool());
+
+    test::assertEqualVectors(expected, result);
+    // Verify the result is actually constant-encoded (optimization worked)
+    ASSERT_TRUE(result->isConstantEncoding());
+    ASSERT_TRUE(result->isNullAt(0));
+  }
+
+  {
+    // Test constant TIME vector with different sizes
+    // This ensures the optimization correctly handles different vector sizes
+    setQueryTimeZone("America/Los_Angeles");
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+
+    for (auto size : {1, 10, 100, 1000}) {
+      auto constantTimeVector = BaseVector::wrapInConstant(
+          size,
+          0,
+          makeFlatVector<int64_t>(
+              {3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond +
+               321},
+              TIME()));
+
+      auto result = evaluate(
+          "cast(c0 as timestamp with time zone)",
+          makeRowVector({constantTimeVector}));
+
+      auto expected = BaseVector::wrapInConstant(
+          size,
+          0,
+          makeFlatVector<int64_t>(
+              {pack(
+                  3 * kMillisInHour + 4 * kMillisInMinute +
+                      5 * kMillisInSecond + 321 + 8 * kMillisInHour,
+                  tzId)},
+              TIMESTAMP_WITH_TIME_ZONE()));
+
+      test::assertEqualVectors(expected, result);
+      ASSERT_TRUE(result->isConstantEncoding());
+      ASSERT_EQ(result->size(), size);
+    }
+  }
+
+  {
+    // Test try_cast for TIME to TIMESTAMP WITH TIME ZONE
+    auto input =
+        makeFlatVector<int64_t>({0, 12 * kMillisInHour, 86399999}, TIME());
+
+    setQueryTimeZone("America/Los_Angeles");
+
+    auto tzId = tz::getTimeZoneID("America/Los_Angeles");
+    auto expected = makeFlatVector<int64_t>(
+        {
+            pack(8 * kMillisInHour, tzId), // 00:00:00 PST -> 08:00:00 UTC
+            pack(
+                12 * kMillisInHour + 8 * kMillisInHour,
+                tzId), // 12:00:00 PST -> 20:00:00 UTC
+            pack(
+                86399999 + 8 * kMillisInHour,
+                tzId), // 23:59:59.999 PST -> 07:59:59.999 UTC (next day)
+        },
+        TIMESTAMP_WITH_TIME_ZONE());
+
+    auto result = evaluate(
+        "try_cast(c0 as timestamp with time zone)", makeRowVector({input}));
+    test::assertEqualVectors(expected, result);
+  }
+}
+
+TEST_F(TimestampWithTimeZoneCastTest, toTime) {
+  // Test casting TIMESTAMP WITH TIME ZONE to TIME
+  // The TIME value should represent the local time in the given timezone
+  // This matches Presto's behavior (see TestTimestampWithTimeZone.java:34-59)
+
+  // Test data with named timezones to verify DST handling
+  // DST rules are applied based on the UTC timestamp's date, not current date
+  auto input = makeNullableFlatVector<int64_t>(
+      {// May 15, 2023 10:30:45.123 EDT (America/New_York in DST)
+       parseTimestampWithTz("2023-05-15 10:30:45.123 America/New_York"),
+       // January 10, 2023 08:15:30.500 GMT (Europe/London in standard time)
+       parseTimestampWithTz("2023-01-10 08:15:30.500 Europe/London"),
+       // January 15, 2023 09:30:00.000 EST (America/New_York in standard time)
+       parseTimestampWithTz("2023-01-15 09:30:00.000 America/New_York"),
+       // August 5, 2023 10:15:00.000 BST (Europe/London in DST)
+       parseTimestampWithTz("2023-08-05 10:15:00.000 Europe/London"),
+       // July 20, 2023 08:59:59.999 JST (Asia/Tokyo, no DST)
+       parseTimestampWithTz("2023-07-21 08:59:59.999 Asia/Tokyo"),
+       // Epoch in UTC
+       parseTimestampWithTz("1970-01-01 00:00:00.000 UTC"),
+       // December 24, 2023 22:00:00.000 PST (America/Los_Angeles in standard
+       // time)
+       parseTimestampWithTz("2023-12-24 22:00:00.000 America/Los_Angeles"),
+       // Null value
+       std::nullopt,
+       // Presto test case: 2001-01-22 03:04:05.321 +07:09
+       parseTimestampWithTz("2001-01-22 03:04:05.321 +07:09")},
+      TIMESTAMP_WITH_TIME_ZONE());
+
+  auto expected = makeNullableFlatVector<int64_t>(
+      {// 10:30:45.123
+       10 * kMillisInHour + 30 * kMillisInMinute + 45 * kMillisInSecond + 123,
+       // 08:15:30.500
+       8 * kMillisInHour + 15 * kMillisInMinute + 30 * kMillisInSecond + 500,
+       // 09:30:00.000 (EST, demonstrates standard time for America/New_York)
+       9 * kMillisInHour + 30 * kMillisInMinute,
+       // 10:15:00.000 (BST, demonstrates DST for Europe/London)
+       10 * kMillisInHour + 15 * kMillisInMinute,
+       // 08:59:59.999
+       8 * kMillisInHour + 59 * kMillisInMinute + 59 * kMillisInSecond + 999,
+       // 00:00:00.000
+       0,
+       // 22:00:00.000
+       22 * kMillisInHour,
+       // Null value
+       std::nullopt,
+       // 03:04:05.321
+       3 * kMillisInHour + 4 * kMillisInMinute + 5 * kMillisInSecond + 321},
+      TIME());
+
+  testCast(input, expected);
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/TypeOfTest.cpp b/velox/functions/prestosql/tests/TypeOfTest.cpp
index 2dd2ff8a8795..656275392528 100644
--- a/velox/functions/prestosql/tests/TypeOfTest.cpp
+++ b/velox/functions/prestosql/tests/TypeOfTest.cpp
@@ -15,27 +15,35 @@
  */
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
 #include "velox/functions/prestosql/types/BingTileType.h"
 #include "velox/functions/prestosql/types/GeometryType.h"
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/P4HyperLogLogType.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/functions/prestosql/types/SphericalGeographyType.h"
 #include "velox/functions/prestosql/types/TDigestType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
 #include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
 
 namespace facebook::velox::functions {
 namespace {
 
-class TypeOfTest : public functions::test::FunctionBaseTest {};
-
-TEST_F(TypeOfTest, basic) {
-  const auto typeOf = [&](const TypePtr& type) {
+class TypeOfTest : public functions::test::FunctionBaseTest {
+ public:
+  std::string typeOf(const TypePtr& type) {
     auto data = makeRowVector({
         BaseVector::createNullConstant(type, 1, pool()),
     });
     return evaluateOnce<std::string>("typeof(c0)", data).value();
-  };
+  }
+};
 
+TEST_F(TypeOfTest, basic) {
   EXPECT_EQ("boolean", typeOf(BOOLEAN()));
 
   EXPECT_EQ("tinyint", typeOf(TINYINT()));
@@ -53,21 +61,8 @@ TEST_F(TypeOfTest, basic) {
   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("bingtile", typeOf(BINGTILE()));
-  EXPECT_EQ("geometry", typeOf(GEOMETRY()));
-
-  EXPECT_EQ("json", typeOf(JSON()));
-
-  EXPECT_EQ("HyperLogLog", typeOf(HYPERLOGLOG()));
-
-  EXPECT_EQ("tdigest(double)", typeOf(TDIGEST(DOUBLE())));
-
-  EXPECT_EQ("qdigest(bigint)", typeOf(QDIGEST(BIGINT())));
-  EXPECT_EQ("qdigest(real)", typeOf(QDIGEST(REAL())));
-  EXPECT_EQ("qdigest(double)", typeOf(QDIGEST(DOUBLE())));
+  EXPECT_EQ("time", typeOf(TIME()));
 
   EXPECT_EQ("unknown", typeOf(UNKNOWN()));
 
@@ -83,5 +78,39 @@ TEST_F(TypeOfTest, basic) {
   VELOX_ASSERT_THROW(typeOf(OPAQUE<int>()), "Unsupported type: OPAQUE<int>");
 }
 
+TEST_F(TypeOfTest, customTypes) {
+  EXPECT_EQ("timestamp with time zone", typeOf(TIMESTAMP_WITH_TIME_ZONE()));
+  EXPECT_EQ("time with time zone", typeOf(TIME_WITH_TIME_ZONE()));
+  EXPECT_EQ("bingtile", typeOf(BINGTILE()));
+  EXPECT_EQ("geometry", typeOf(GEOMETRY()));
+  EXPECT_EQ("sphericalgeography", typeOf(SPHERICAL_GEOGRAPHY()));
+
+  EXPECT_EQ("json", typeOf(JSON()));
+
+  EXPECT_EQ("HyperLogLog", typeOf(HYPERLOGLOG()));
+  EXPECT_EQ("KHyperLogLog", typeOf(KHYPERLOGLOG()));
+  EXPECT_EQ("P4HyperLogLog", typeOf(P4HYPERLOGLOG()));
+  EXPECT_EQ("SetDigest", typeOf(SETDIGEST()));
+
+  EXPECT_EQ("tdigest(double)", typeOf(TDIGEST(DOUBLE())));
+
+  EXPECT_EQ("qdigest(bigint)", typeOf(QDIGEST(BIGINT())));
+  EXPECT_EQ("qdigest(real)", typeOf(QDIGEST(REAL())));
+  EXPECT_EQ("qdigest(double)", typeOf(QDIGEST(DOUBLE())));
+
+  std::unordered_map<std::string, int64_t> enumMap = {
+      {"CURIOUS", -2}, {"HAPPY", 0}};
+  LongEnumParameter moodInfo("test.enum.mood", enumMap);
+  LongEnumParameter otherInfo("someEnumType", enumMap);
+  EXPECT_EQ("test.enum.mood", typeOf(BIGINT_ENUM(moodInfo)));
+  EXPECT_EQ("someEnumType", typeOf(BIGINT_ENUM(otherInfo)));
+
+  std::unordered_map<std::string, std::string> varcharEnumMap = {
+      {"RED", "red"}, {"BLUE", "blue"}};
+  VarcharEnumParameter colorInfo("test.enum.color", varcharEnumMap);
+  VarcharEnumParameter otherColorInfo("someColorType", varcharEnumMap);
+  EXPECT_EQ("test.enum.color", typeOf(VARCHAR_ENUM(colorInfo)));
+  EXPECT_EQ("someColorType", typeOf(VARCHAR_ENUM(otherColorInfo)));
+}
 } // namespace
 } // namespace facebook::velox::functions
diff --git a/velox/functions/prestosql/tests/URLFunctionsTest.cpp b/velox/functions/prestosql/tests/URLFunctionsTest.cpp
index 19742ba36f7a..22de905d021c 100644
--- a/velox/functions/prestosql/tests/URLFunctionsTest.cpp
+++ b/velox/functions/prestosql/tests/URLFunctionsTest.cpp
@@ -553,6 +553,20 @@ TEST_F(URLFunctionsTest, extractParameter) {
       extractParam(
           "http://example.com/path1/p.php?k1=v1&k2=v2&k3%3Dv3.1%3Dv3.2%26k4=v4",
           "k3"));
+
+  // Test zero-width match edge case - parameters that could result in
+  // zero-width regex matches should not cause infinite loops
+  EXPECT_EQ(
+      std::nullopt,
+      extractParam("http://example.com/path1/p.php?&&&", "param"));
+  EXPECT_EQ(
+      "value",
+      extractParam("http://example.com/path1/p.php?&&&param=value", "param"));
+  // Test consecutive empty parameters
+  EXPECT_EQ(
+      std::nullopt,
+      extractParam("http://example.com/path1/p.php?&=&=&", "nonexistent"));
+  EXPECT_EQ("", extractParam("http://example.com/path1/p.php?key=", "key"));
 }
 
 TEST_F(URLFunctionsTest, urlEncode) {
diff --git a/velox/functions/prestosql/tests/VarcharEnumCastTest.cpp b/velox/functions/prestosql/tests/VarcharEnumCastTest.cpp
new file mode 100644
index 000000000000..d3cea0dd64a1
--- /dev/null
+++ b/velox/functions/prestosql/tests/VarcharEnumCastTest.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/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/tests/CastBaseTest.h"
+#include "velox/functions/prestosql/types/VarcharEnumRegistration.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
+
+using namespace facebook::velox::test;
+using namespace facebook::velox::exec;
+
+namespace facebook::velox {
+namespace {
+
+class VarcharEnumCastTest : public functions::test::CastBaseTest {
+ protected:
+  VarcharEnumCastTest() {
+    registerVarcharEnumType();
+    VarcharEnumParameter colorInfo(
+        "test.enum.color", {{"RED", "red"}, {"BLUE", "blue"}});
+    colorEnum_ = VARCHAR_ENUM(colorInfo);
+  }
+
+  VarcharEnumTypePtr colorEnum_;
+};
+
+TEST_F(VarcharEnumCastTest, castTo) {
+  // Cast VARCHAR type to enum type.
+  testCast<StringView, StringView>(
+      VARCHAR(),
+      colorEnum_,
+      {"red"_sv, "blue"_sv, std::nullopt},
+      {"red"_sv, "blue"_sv, std::nullopt});
+
+  // Cast enum type to same enum type.
+  testCast<StringView, StringView>(
+      colorEnum_,
+      colorEnum_,
+      {"red"_sv, "blue"_sv, std::nullopt},
+      {"red"_sv, "blue"_sv, std::nullopt});
+}
+
+TEST_F(VarcharEnumCastTest, invalidCastTo) {
+  // Cast is only permitted from VARCHAR types to enum type.
+  testThrow<int64_t>(
+      BIGINT(),
+      colorEnum_,
+      {1},
+      "Cannot cast BIGINT to test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"}).");
+
+  testThrow<StringView>(
+      VARBINARY(),
+      colorEnum_,
+      {"red"_sv, ""_sv},
+      "Cannot cast VARBINARY to test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"}).");
+
+  testThrow<bool>(
+      BOOLEAN(),
+      colorEnum_,
+      {1},
+      "Cannot cast BOOLEAN to test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"}).");
+
+  // Cast base type to enum type where the value does not exist in the enum.
+  // Casting is case-sensitive.
+  testThrow<StringView>(
+      VARCHAR(),
+      colorEnum_,
+      {"green"_sv},
+      "No value 'green' in test.enum.color");
+
+  testThrow<StringView>(
+      VARCHAR(), colorEnum_, {"RED"_sv}, "No value 'RED' in test.enum.color");
+
+  // Cast enum type to different enum type.
+  std::unordered_map<std::string, std::string> differentMap = {
+      {"RED", "red"}, {"BLUE", "navy"}};
+  VarcharEnumParameter differentEnumInfo("someEnumType", differentMap);
+  testThrow<StringView>(
+      VARCHAR_ENUM(differentEnumInfo),
+      colorEnum_,
+      {"red"_sv},
+      "Cannot cast someEnumType:VarcharEnum({\"BLUE\": \"navy\", \"RED\": \"red\"}) to test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"}).");
+
+  // Cast enum type to different enum type with same name.
+  VarcharEnumParameter sameNameDifferentMap("test.enum.color", differentMap);
+  testThrow<StringView>(
+      VARCHAR_ENUM(sameNameDifferentMap),
+      colorEnum_,
+      {"red"_sv},
+      "Cannot cast test.enum.color:VarcharEnum({\"BLUE\": \"navy\", \"RED\": \"red\"}) to test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"})");
+}
+
+TEST_F(VarcharEnumCastTest, fromVarcharEnum) {
+  // Cast enum type to base type.
+  testCast<StringView, StringView>(
+      colorEnum_,
+      VARCHAR(),
+      {"red"_sv, "blue"_sv, std::nullopt},
+      {"red"_sv, "blue"_sv, std::nullopt});
+
+  // Casting enum type to all other types including other string types is not
+  // permitted.
+  testThrow<StringView>(
+      colorEnum_,
+      VARBINARY(),
+      {"red"_sv},
+      "Cannot cast test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"}) to VARBINARY.");
+
+  testThrow<StringView>(
+      colorEnum_,
+      BIGINT(),
+      {"red"_sv},
+      "Cannot cast test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"}) to BIGINT.");
+}
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/tests/ZipTest.cpp b/velox/functions/prestosql/tests/ZipTest.cpp
index 92e9166a9980..7abe61d5e0cd 100644
--- a/velox/functions/prestosql/tests/ZipTest.cpp
+++ b/velox/functions/prestosql/tests/ZipTest.cpp
@@ -69,7 +69,7 @@ TEST_F(ZipTest, combineInt) {
 
   auto firstResult = makeNullableFlatVector<int64_t>(
       {1, 1, 1, 1, 2, 2, 2, std::nullopt, std::nullopt});
-  auto secondResult = makeNullableFlatVector<std::string>(
+  auto secondResult = makeNullableFlatVector<StringView>(
       {S("a"),
        S("a"),
        S("a"),
@@ -127,17 +127,19 @@ TEST_F(ZipTest, arity) {
   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]",
-      }));
+      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]",
-      }));
+      inputs.push_back(
+          makeArrayVectorFromJson<double>({
+              "[1.1, 1.1, 1.1, 1.1]",
+              "[2.2, 2.2, 2.2]",
+              "[3.3, 3.3]",
+          }));
     }
   }
 
diff --git a/velox/functions/prestosql/tests/resources/GeometryTestUtils.h b/velox/functions/prestosql/tests/resources/GeometryTestUtils.h
new file mode 100644
index 000000000000..5ab62c5eb0a7
--- /dev/null
+++ b/velox/functions/prestosql/tests/resources/GeometryTestUtils.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 <string_view>
+#include <unordered_map>
+namespace facebook::velox::geometry_test_utils {
+
+const inline std::unordered_map<std::string_view, double> usStateAreas{
+    {{"AK", 1512029420919.75}, {"AL", 133798433564.089},
+     {"AR", 138078359306.101}, {"AZ", 295735747077.462},
+     {"CA", 409564647161.456}, {"CO", 269308715698.849},
+     {"CT", 12873955652.9009}, {"DE", 5083481242.97432},
+     {"FL", 149761362689.816}, {"GA", 152560105310.888},
+     {"HI", 14715710071.3397}, {"IA", 146458043140.78},
+     {"ID", 215644605503.279}, {"IL", 146057753165.062},
+     {"IN", 93432145009.3321}, {"KS", 213667500120.875},
+     {"KY", 104609030725.925}, {"LA", 122087680157.417},
+     {"MA", 20641289915.7922}, {"MD", 33030573282.338},
+     {"ME", 84380140281.5444}, {"MI", 150263386643.448},
+     {"MN", 217052585631.816}, {"MO", 180004456640.739},
+     {"MS", 123528032272.534}, {"MT", 381032417364.706},
+     {"NC", 130662589411.403}, {"ND", 181977969472.119},
+     {"NE", 198367040634.306}, {"NH", 23917283751.4951},
+     {"NJ", 19994599703.4562}, {"NM", 314665412870.469},
+     {"NV", 286314845000.724}, {"NY", 126235067447.09},
+     {"OH", 106856948024.766}, {"OK", 182094848972.64},
+     {"OR", 250811798127.051}, {"PA", 117328433660.695},
+     {"RI", 2665065564.06665}, {"SC", 80925225017.8581},
+     {"SD", 201400533632.426}, {"TN", 109289108111.592},
+     {"TX", 687081639377.503}, {"UT", 219262788661.858},
+     {"VA", 254920255235320},  {"VT", 24673886252.5229},
+     {"WA", 176010024082.492}, {"WI", 144941233960.424},
+     {"WV", 63015759782.3764}, {"WY", 253076654001.191}}};
+
+const inline std::
+    unordered_map<std::string_view, std::string_view>
+        usStateWkts{
+            {{"AL",
+              "POLYGON ((-87.359296 35.00118, -85.606675 34.984749, -85.431413 34.124869, -85.184951 32.859696, -85.069935 32.580372, -84.960397 32.421541, -85.004212 32.322956, -84.889196 32.262709, -85.058981 32.13674, -85.053504 32.01077, -85.141136 31.840985, -85.042551 31.539753, -85.113751 31.27686, -85.004212 31.003013, -85.497137 30.997536, -87.600282 30.997536, -87.633143 30.86609, -87.408589 30.674397, -87.446927 30.510088, -87.37025 30.427934, -87.518128 30.280057, -87.655051 30.247195, -87.90699 30.411504, -87.934375 30.657966, -88.011052 30.685351, -88.10416 30.499135, -88.137022 30.318396, -88.394438 30.367688, -88.471115 31.895754, -88.241084 33.796253, -88.098683 34.891641, -88.202745 34.995703, -87.359296 35.00118))"},
+             {"AK",
+              "MULTIPOLYGON (((-131.602021 55.117982, -131.569159 55.28229, -131.355558 55.183705, -131.38842 55.01392, -131.645836 55.035827, -131.602021 55.117982)), ((-131.832052 55.42469, -131.645836 55.304197, -131.749898 55.128935, -131.832052 55.189182, -131.832052 55.42469)), ((-132.976733 56.437924, -132.735747 56.459832, -132.631685 56.421493, -132.664547 56.273616, -132.878148 56.240754, -133.069841 56.333862, -132.976733 56.437924)), ((-133.595627 56.350293, -133.162949 56.317431, -133.05341 56.125739, -132.620732 55.912138, -132.472854 55.780691, -132.4619 55.671152, -132.357838 55.649245, -132.341408 55.506844, -132.166146 55.364444, -132.144238 55.238474, -132.029222 55.276813, -131.97993 55.178228, -131.958022 54.789365, -132.029222 54.701734, -132.308546 54.718165, -132.385223 54.915335, -132.483808 54.898904, -132.686455 55.046781, -132.746701 54.997489, -132.916486 55.046781, -132.889102 54.898904, -132.73027 54.937242, -132.626209 54.882473, -132.675501 54.679826, -132.867194 54.701734, -133.157472 54.95915, -133.239626 55.090597, -133.223195 55.22752, -133.453227 55.216566, -133.453227 55.320628, -133.277964 55.331582, -133.102702 55.42469, -133.17938 55.588998, -133.387503 55.62186, -133.420365 55.884753, -133.497042 56.0162, -133.639442 55.923092, -133.694212 56.070969, -133.546335 56.142169, -133.666827 56.311955, -133.595627 56.350293)), ((-133.738027 55.556137, -133.546335 55.490413, -133.414888 55.572568, -133.283441 55.534229, -133.420365 55.386352, -133.633966 55.430167, -133.738027 55.556137)), ((-133.907813 56.930849, -134.050213 57.029434, -133.885905 57.095157, -133.343688 57.002049, -133.102702 57.007526, -132.932917 56.82131, -132.620732 56.667956, -132.653593 56.55294, -132.817901 56.492694, -133.042456 56.520078, -133.201287 56.448878, -133.420365 56.492694, -133.66135 56.448878, -133.710643 56.684386, -133.688735 56.837741, -133.869474 56.843218, -133.907813 56.930849)), ((-134.115936 56.48174, -134.25286 56.558417, -134.400737 56.722725, -134.417168 56.848695, -134.296675 56.908941, -134.170706 56.848695, -134.143321 56.952757, -133.748981 56.772017, -133.710643 56.596755, -133.847566 56.574848, -133.935197 56.377678, -133.836612 56.322908, -133.957105 56.092877, -134.110459 56.142169, -134.132367 55.999769, -134.230952 56.070969, -134.291198 56.350293, -134.115936 56.48174)), ((-134.636246 56.28457, -134.669107 56.169554, -134.806031 56.235277, -135.178463 56.67891, -135.413971 56.810356, -135.331817 56.914418, -135.424925 57.166357, -135.687818 57.369004, -135.419448 57.566174, -135.298955 57.48402, -135.063447 57.418296, -134.849846 57.407343, -134.844369 57.248511, -134.636246 56.728202, -134.636246 56.28457)), ((-134.712923 58.223407, -134.373353 58.14673, -134.176183 58.157683, -134.187137 58.081006, -133.902336 57.807159, -134.099505 57.850975, -134.148798 57.757867, -133.935197 57.615466, -133.869474 57.363527, -134.083075 57.297804, -134.154275 57.210173, -134.499322 57.029434, -134.603384 57.034911, -134.6472 57.226604, -134.575999 57.341619, -134.608861 57.511404, -134.729354 57.719528, -134.707446 57.829067, -134.784123 58.097437, -134.91557 58.212453, -134.953908 58.409623, -134.712923 58.223407)), ((-135.857603 57.330665, -135.715203 57.330665, -135.567326 57.149926, -135.633049 57.023957, -135.857603 56.996572, -135.824742 57.193742, -135.857603 57.330665)), ((-136.279328 58.206976, -135.978096 58.201499, -135.780926 58.28913, -135.496125 58.168637, -135.64948 58.037191, -135.59471 57.987898, -135.45231 58.135776, -135.107263 58.086483, -134.91557 57.976944, -135.025108 57.779775, -134.937477 57.763344, -134.822462 57.500451, -135.085355 57.462112, -135.572802 57.675713, -135.556372 57.456635, -135.709726 57.369004, -135.890465 57.407343, -136.000004 57.544266, -136.208128 57.637374, -136.366959 57.829067, -136.569606 57.916698, -136.558652 58.075529, -136.421728 58.130299, -136.377913 58.267222, -136.279328 58.206976)), ((-147.079854 60.200582, -147.501579 59.948643, -147.53444 59.850058, -147.874011 59.784335, -147.80281 59.937689, -147.435855 60.09652, -147.205824 60.271782, -147.079854 60.200582)), ((-147.561825 60.578491, -147.616594 60.370367, -147.758995 60.156767, -147.956165 60.227967, -147.791856 60.474429, -147.561825 60.578491)), ((-147.786379 70.245291, -147.682318 70.201475, -147.162008 70.15766, -146.888161 70.185044, -146.510252 70.185044, -146.099482 70.146706, -145.858496 70.168614, -145.622988 70.08646, -145.195787 69.993352, -144.620708 69.971444, -144.461877 70.026213, -144.078491 70.059075, -143.914183 70.130275, -143.497935 70.141229, -143.503412 70.091936, -143.25695 70.119321, -142.747594 70.042644, -142.402547 69.916674, -142.079408 69.856428, -142.008207 69.801659, -141.712453 69.790705, -141.433129 69.697597, -141.378359 69.63735, -141.208574 69.686643, -141.00045 69.648304, -141.00045 60.304644, -140.53491 60.22249, -140.474664 60.310121, -139.987216 60.184151, -139.696939 60.342983, -139.088998 60.359413, -139.198537 60.091043, -139.045183 59.997935, -138.700135 59.910304, -138.623458 59.767904, -137.604747 59.242118, -137.445916 58.908024, -137.265177 59.001132, -136.827022 59.159963, -136.580559 59.16544, -136.465544 59.285933, -136.476498 59.466672, -136.301236 59.466672, -136.25742 59.625503, -135.945234 59.663842, -135.479694 59.800766, -135.025108 59.565257, -135.068924 59.422857, -134.959385 59.280456, -134.701969 59.247595, -134.378829 59.033994, -134.400737 58.973748, -134.25286 58.858732, -133.842089 58.727285, -133.173903 58.152206, -133.075318 57.998852, -132.867194 57.845498, -132.560485 57.505928, -132.253777 57.21565, -132.368792 57.095157, -132.05113 57.051341, -132.127807 56.876079, -131.870391 56.804879, -131.837529 56.602232, -131.580113 56.613186, -131.087188 56.405062, -130.78048 56.366724, -130.621648 56.268139, -130.468294 56.240754, -130.424478 56.142169, -130.101339 56.114785, -130.002754 55.994292, -130.150631 55.769737, -130.128724 55.583521, -129.986323 55.276813, -130.095862 55.200136, -130.336847 54.920812, -130.687372 54.718165, -130.785957 54.822227, -130.917403 54.789365, -131.010511 54.997489, -130.983126 55.08512, -131.092665 55.189182, -130.862634 55.298721, -130.928357 55.337059, -131.158389 55.200136, -131.284358 55.287767, -131.426759 55.238474, -131.843006 55.457552, -131.700606 55.698537, -131.963499 55.616383, -131.974453 55.49589, -132.182576 55.588998, -132.226392 55.704014, -132.083991 55.829984, -132.127807 55.955953, -132.324977 55.851892, -132.522147 56.076446, -132.642639 56.032631, -132.719317 56.218847, -132.527624 56.339339, -132.341408 56.339339, -132.396177 56.487217, -132.297592 56.67891, -132.450946 56.673433, -132.768609 56.837741, -132.993164 57.034911, -133.51895 57.177311, -133.507996 57.577128, -133.677781 57.62642, -133.639442 57.790728, -133.814705 57.834544, -134.072121 58.053622, -134.143321 58.168637, -134.586953 58.206976, -135.074401 58.502731, -135.282525 59.192825, -135.38111 59.033994, -135.337294 58.891593, -135.140124 58.617746, -135.189417 58.573931, -135.05797 58.349376, -135.085355 58.201499, -135.277048 58.234361, -135.430402 58.398669, -135.633049 58.426053, -135.91785 58.382238, -135.912373 58.617746, -136.087635 58.814916, -136.246466 58.75467, -136.876314 58.962794, -136.931084 58.902547, -136.586036 58.836824, -136.317666 58.672516, -136.213604 58.667039, -136.180743 58.535592, -136.043819 58.382238, -136.388867 58.294607, -136.591513 58.349376, -136.59699 58.212453, -136.859883 58.316515, -136.947514 58.393192, -137.111823 58.393192, -137.566409 58.590362, -137.900502 58.765624, -137.933364 58.869686, -138.11958 59.02304, -138.634412 59.132579, -138.919213 59.247595, -139.417615 59.379041, -139.746231 59.505011, -139.718846 59.641934, -139.625738 59.598119, -139.5162 59.68575, -139.625738 59.88292, -139.488815 59.992458, -139.554538 60.041751, -139.801 59.833627, -140.315833 59.696704, -140.92925 59.745996, -141.444083 59.871966, -141.46599 59.970551, -141.706976 59.948643, -141.964392 60.019843, -142.539471 60.085566, -142.873564 60.091043, -143.623905 60.036274, -143.892275 59.997935, -144.231845 60.140336, -144.65357 60.206059, -144.785016 60.29369, -144.834309 60.441568, -145.124586 60.430614, -145.223171 60.299167, -145.738004 60.474429, -145.820158 60.551106, -146.351421 60.408706, -146.608837 60.238921, -146.718376 60.397752, -146.608837 60.485383, -146.455483 60.463475, -145.951604 60.578491, -146.017328 60.666122, -146.252836 60.622307, -146.345944 60.737322, -146.565022 60.753753, -146.784099 61.044031, -146.866253 60.972831, -147.172962 60.934492, -147.271547 60.972831, -147.375609 60.879723, -147.758995 60.912584, -147.775426 60.808523, -148.032842 60.781138, -148.153334 60.819476, -148.065703 61.005692, -148.175242 61.000215, -148.350504 60.803046, -148.109519 60.737322, -148.087611 60.594922, -147.939734 60.441568, -148.027365 60.277259, -148.219058 60.332029, -148.273827 60.249875, -148.087611 60.217013, -147.983549 59.997935, -148.251919 59.95412, -148.399797 59.997935, -148.635305 59.937689, -148.755798 59.986981, -149.067984 59.981505, -149.05703 60.063659, -149.204907 60.008889, -149.287061 59.904827, -149.418508 59.997935, -149.582816 59.866489, -149.511616 59.806242, -149.741647 59.729565, -149.949771 59.718611, -150.031925 59.61455, -150.25648 59.521442, -150.409834 59.554303, -150.579619 59.444764, -150.716543 59.450241, -151.001343 59.225687, -151.308052 59.209256, -151.406637 59.280456, -151.592853 59.159963, -151.976239 59.253071, -151.888608 59.422857, -151.636669 59.483103, -151.47236 59.472149, -151.423068 59.537872, -151.127313 59.669319, -151.116359 59.778858, -151.505222 59.63098, -151.828361 59.718611, -151.8667 59.778858, -151.702392 60.030797, -151.423068 60.211536, -151.379252 60.359413, -151.297098 60.386798, -151.264237 60.545629, -151.406637 60.720892, -151.06159 60.786615, -150.404357 61.038554, -150.245526 60.939969, -150.042879 60.912584, -149.741647 61.016646, -150.075741 61.15357, -150.207187 61.257632, -150.47008 61.246678, -150.656296 61.29597, -150.711066 61.252155, -151.023251 61.180954, -151.165652 61.044031, -151.477837 61.011169, -151.800977 60.852338, -151.833838 60.748276, -152.080301 60.693507, -152.13507 60.578491, -152.310332 60.507291, -152.392486 60.304644, -152.732057 60.173197, -152.567748 60.069136, -152.704672 59.915781, -153.022334 59.888397, -153.049719 59.691227, -153.345474 59.620026, -153.438582 59.702181, -153.586459 59.548826, -153.761721 59.543349, -153.72886 59.433811, -154.117723 59.368087, -154.1944 59.066856, -153.750768 59.050425, -153.400243 58.968271, -153.301658 58.869686, -153.444059 58.710854, -153.679567 58.612269, -153.898645 58.606793, -153.920553 58.519161, -154.062953 58.4863, -153.99723 58.376761, -154.145107 58.212453, -154.46277 58.059098, -154.643509 58.059098, -154.818771 58.004329, -154.988556 58.015283, -155.120003 57.955037, -155.081664 57.872883, -155.328126 57.829067, -155.377419 57.708574, -155.547204 57.785251, -155.73342 57.549743, -156.045606 57.566174, -156.023698 57.440204, -156.209914 57.473066, -156.34136 57.418296, -156.34136 57.248511, -156.549484 56.985618, -156.883577 56.952757, -157.157424 56.832264, -157.20124 56.766541, -157.376502 56.859649, -157.672257 56.607709, -157.754411 56.67891, -157.918719 56.657002, -157.957058 56.514601, -158.126843 56.459832, -158.32949 56.48174, -158.488321 56.339339, -158.208997 56.295524, -158.510229 55.977861, -159.375585 55.873799, -159.616571 55.594475, -159.676817 55.654722, -159.643955 55.829984, -159.813741 55.857368, -160.027341 55.791645, -160.060203 55.720445, -160.394296 55.605429, -160.536697 55.473983, -160.580512 55.567091, -160.668143 55.457552, -160.865313 55.528752, -161.232268 55.358967, -161.506115 55.364444, -161.467776 55.49589, -161.588269 55.62186, -161.697808 55.517798, -161.686854 55.408259, -162.053809 55.074166, -162.179779 55.15632, -162.218117 55.03035, -162.470057 55.052258, -162.508395 55.249428, -162.661749 55.293244, -162.716519 55.222043, -162.579595 55.134412, -162.645319 54.997489, -162.847965 54.926289, -163.00132 55.079643, -163.187536 55.090597, -163.220397 55.03035, -163.034181 54.942719, -163.373752 54.800319, -163.14372 54.76198, -163.138243 54.696257, -163.329936 54.74555, -163.587352 54.614103, -164.085754 54.61958, -164.332216 54.531949, -164.354124 54.466226, -164.638925 54.389548, -164.847049 54.416933, -164.918249 54.603149, -164.710125 54.663395, -164.551294 54.88795, -164.34317 54.893427, -163.894061 55.041304, -163.532583 55.046781, -163.39566 54.904381, -163.291598 55.008443, -163.313505 55.128935, -163.105382 55.183705, -162.880827 55.183705, -162.579595 55.446598, -162.245502 55.682106, -161.807347 55.89023, -161.292514 55.983338, -161.078914 55.939523, -160.87079 55.999769, -160.816021 55.912138, -160.931036 55.813553, -160.805067 55.736876, -160.766728 55.857368, -160.509312 55.868322, -160.438112 55.791645, -160.27928 55.76426, -160.273803 55.857368, -160.536697 55.939523, -160.558604 55.994292, -160.383342 56.251708, -160.147834 56.399586, -159.830171 56.541986, -159.326293 56.667956, -158.959338 56.848695, -158.784076 56.782971, -158.641675 56.810356, -158.701922 56.925372, -158.658106 57.034911, -158.378782 57.264942, -157.995396 57.41282, -157.688688 57.609989, -157.705118 57.719528, -157.458656 58.497254, -157.07527 58.705377, -157.119086 58.869686, -158.039212 58.634177, -158.32949 58.661562, -158.40069 58.760147, -158.564998 58.803962, -158.619768 58.913501, -158.767645 58.864209, -158.860753 58.694424, -158.701922 58.480823, -158.893615 58.387715, -159.0634 58.420577, -159.392016 58.760147, -159.616571 58.929932, -159.731586 58.929932, -159.808264 58.803962, -159.906848 58.782055, -160.054726 58.886116, -160.235465 58.902547, -160.317619 59.072332, -160.854359 58.88064, -161.33633 58.743716, -161.374669 58.667039, -161.752577 58.552023, -161.938793 58.656085, -161.769008 58.776578, -161.829255 59.061379, -161.955224 59.36261, -161.703285 59.48858, -161.911409 59.740519, -162.092148 59.88292, -162.234548 60.091043, -162.448149 60.178674, -162.502918 59.997935, -162.760334 59.959597, -163.171105 59.844581, -163.66403 59.795289, -163.9324 59.806242, -164.162431 59.866489, -164.189816 60.02532, -164.386986 60.074613, -164.699171 60.29369, -164.962064 60.337506, -165.268773 60.578491, -165.060649 60.68803, -165.016834 60.890677, -165.175665 60.846861, -165.197573 60.972831, -165.120896 61.076893, -165.323543 61.170001, -165.34545 61.071416, -165.591913 61.109754, -165.624774 61.279539, -165.816467 61.301447, -165.920529 61.416463, -165.915052 61.558863, -166.106745 61.49314, -166.139607 61.630064, -165.904098 61.662925, -166.095791 61.81628, -165.756221 61.827233, -165.756221 62.013449, -165.674067 62.139419, -165.044219 62.539236, -164.912772 62.659728, -164.819664 62.637821, -164.874433 62.807606, -164.633448 63.097884, -164.425324 63.212899, -164.036462 63.262192, -163.73523 63.212899, -163.313505 63.037637, -163.039658 63.059545, -162.661749 63.22933, -162.272887 63.486746, -162.075717 63.514131, -162.026424 63.448408, -161.555408 63.448408, -161.13916 63.503177, -160.766728 63.771547, -160.766728 63.837271, -160.952944 64.08921, -160.974852 64.237087, -161.26513 64.395918, -161.374669 64.532842, -161.078914 64.494503, -160.79959 64.609519, -160.783159 64.719058, -161.144637 64.921705, -161.413007 64.762873, -161.664946 64.790258, -161.900455 64.702627, -162.168825 64.680719, -162.234548 64.620473, -162.541257 64.532842, -162.634365 64.384965, -162.787719 64.324718, -162.858919 64.49998, -163.045135 64.538319, -163.176582 64.401395, -163.253259 64.467119, -163.598306 64.565704, -164.304832 64.560227, -164.80871 64.450688, -165.000403 64.434257, -165.411174 64.49998, -166.188899 64.576658, -166.391546 64.636904, -166.484654 64.735489, -166.413454 64.872412, -166.692778 64.987428, -166.638008 65.113398, -166.462746 65.179121, -166.517516 65.337952, -166.796839 65.337952, -167.026871 65.381768, -167.47598 65.414629, -167.711489 65.496784, -168.072967 65.578938, -168.105828 65.682999, -167.541703 65.819923, -166.829701 66.049954, -166.3313 66.186878, -166.046499 66.110201, -165.756221 66.09377, -165.690498 66.203309, -165.86576 66.21974, -165.88219 66.312848, -165.186619 66.466202, -164.403417 66.581218, -163.981692 66.592172, -163.751661 66.553833, -163.872153 66.389525, -163.828338 66.274509, -163.915969 66.192355, -163.768091 66.060908, -163.494244 66.082816, -163.149197 66.060908, -162.749381 66.088293, -162.634365 66.039001, -162.371472 66.028047, -162.14144 66.077339, -161.840208 66.02257, -161.549931 66.241647, -161.341807 66.252601, -161.199406 66.208786, -161.128206 66.334755, -161.528023 66.395002, -161.911409 66.345709, -161.87307 66.510017, -162.174302 66.68528, -162.502918 66.740049, -162.601503 66.89888, -162.344087 66.937219, -162.015471 66.778388, -162.075717 66.652418, -161.916886 66.553833, -161.571838 66.438817, -161.489684 66.55931, -161.884024 66.718141, -161.714239 67.002942, -161.851162 67.052235, -162.240025 66.991988, -162.639842 67.008419, -162.700088 67.057712, -162.902735 67.008419, -163.740707 67.128912, -163.757138 67.254881, -164.009077 67.534205, -164.211724 67.638267, -164.534863 67.725898, -165.192096 67.966884, -165.493328 68.059992, -165.794559 68.081899, -166.243668 68.246208, -166.681824 68.339316, -166.703731 68.372177, -166.375115 68.42147, -166.227238 68.574824, -166.216284 68.881533, -165.329019 68.859625, -164.255539 68.930825, -163.976215 68.985595, -163.532583 69.138949, -163.110859 69.374457, -163.023228 69.609966, -162.842489 69.812613, -162.470057 69.982398, -162.311225 70.108367, -161.851162 70.311014, -161.779962 70.256245, -161.396576 70.239814, -160.837928 70.343876, -160.487404 70.453415, -159.649432 70.792985, -159.33177 70.809416, -159.298908 70.760123, -158.975769 70.798462, -158.658106 70.787508, -158.033735 70.831323, -157.420318 70.979201, -156.812377 71.285909, -156.565915 71.351633, -156.522099 71.296863, -155.585543 71.170894, -155.508865 71.083263, -155.832005 70.968247, -155.979882 70.96277, -155.974405 70.809416, -155.503388 70.858708, -155.476004 70.940862, -155.262403 71.017539, -155.191203 70.973724, -155.032372 71.148986, -154.566832 70.990155, -154.643509 70.869662, -154.353231 70.8368, -154.183446 70.7656, -153.931507 70.880616, -153.487874 70.886093, -153.235935 70.924431, -152.589656 70.886093, -152.26104 70.842277, -152.419871 70.606769, -151.817408 70.546523, -151.773592 70.486276, -151.187559 70.382214, -151.182082 70.431507, -150.760358 70.49723, -150.355064 70.491753, -150.349588 70.436984, -150.114079 70.431507, -149.867617 70.508184, -149.462323 70.519138, -149.177522 70.486276, -148.78866 70.404122, -148.607921 70.420553, -148.350504 70.305537, -148.202627 70.349353, -147.961642 70.316491, -147.786379 70.245291)), ((-152.94018 58.026237, -152.945657 57.982421, -153.290705 58.048145, -153.044242 58.305561, -152.819688 58.327469, -152.666333 58.562977, -152.496548 58.354853, -152.354148 58.426053, -152.080301 58.311038, -152.080301 58.152206, -152.480117 58.130299, -152.655379 58.059098, -152.94018 58.026237)), ((-153.958891 57.538789, -153.67409 57.670236, -153.931507 57.69762, -153.936983 57.812636, -153.723383 57.889313, -153.570028 57.834544, -153.548121 57.719528, -153.46049 57.796205, -153.455013 57.96599, -153.268797 57.889313, -153.235935 57.998852, -153.071627 57.933129, -152.874457 57.933129, -152.721103 57.993375, -152.469163 57.889313, -152.469163 57.599035, -152.151501 57.620943, -152.359625 57.42925, -152.74301 57.505928, -152.60061 57.379958, -152.710149 57.275896, -152.907319 57.325188, -152.912796 57.128019, -153.214027 57.073249, -153.312612 56.991095, -153.498828 57.067772, -153.695998 56.859649, -153.849352 56.837741, -154.013661 56.744633, -154.073907 56.969187, -154.303938 56.848695, -154.314892 56.919895, -154.523016 56.991095, -154.539447 57.193742, -154.742094 57.275896, -154.627078 57.511404, -154.227261 57.659282, -153.980799 57.648328, -153.958891 57.538789)), ((-154.53397 56.602232, -154.742094 56.399586, -154.807817 56.432447, -154.53397 56.602232)), ((-155.634835 55.923092, -155.476004 55.912138, -155.530773 55.704014, -155.793666 55.731399, -155.837482 55.802599, -155.634835 55.923092)), ((-159.890418 55.28229, -159.950664 55.068689, -160.257373 54.893427, -160.109495 55.161797, -160.005433 55.134412, -159.890418 55.28229)), ((-160.520266 55.358967, -160.33405 55.358967, -160.339527 55.249428, -160.525743 55.128935, -160.690051 55.211089, -160.794113 55.134412, -160.854359 55.320628, -160.79959 55.380875, -160.520266 55.358967)), ((-162.256456 54.981058, -162.234548 54.893427, -162.349564 54.838658, -162.437195 54.931766, -162.256456 54.981058)), ((-162.415287 63.634624, -162.563165 63.536039, -162.612457 63.62367, -162.415287 63.634624)), ((-162.80415 54.488133, -162.590549 54.449795, -162.612457 54.367641, -162.782242 54.373118, -162.80415 54.488133)), ((-165.548097 54.29644, -165.476897 54.181425, -165.630251 54.132132, -165.685021 54.252625, -165.548097 54.29644)), ((-165.73979 54.15404, -166.046499 54.044501, -166.112222 54.121178, -165.980775 54.219763, -165.73979 54.15404)), ((-166.364161 60.359413, -166.13413 60.397752, -166.084837 60.326552, -165.88219 60.342983, -165.685021 60.277259, -165.646682 59.992458, -165.750744 59.89935, -166.00816 59.844581, -166.062929 59.745996, -166.440838 59.855535, -166.6161 59.850058, -166.994009 59.992458, -167.125456 59.992458, -167.344534 60.074613, -167.421211 60.206059, -167.311672 60.238921, -166.93924 60.206059, -166.763978 60.310121, -166.577762 60.321075, -166.495608 60.392275, -166.364161 60.359413)), ((-166.375115 54.01164, -166.210807 53.934962, -166.5449 53.748746, -166.539423 53.715885, -166.117699 53.852808, -166.112222 53.776131, -166.282007 53.683023, -166.555854 53.622777, -166.583239 53.529669, -166.878994 53.431084, -167.13641 53.425607, -167.306195 53.332499, -167.623857 53.250345, -167.793643 53.337976, -167.459549 53.442038, -167.355487 53.425607, -167.103548 53.513238, -167.163794 53.611823, -167.021394 53.715885, -166.807793 53.666592, -166.785886 53.732316, -167.015917 53.754223, -167.141887 53.825424, -167.032348 53.945916, -166.643485 54.017116, -166.561331 53.880193, -166.375115 54.01164)), ((-168.790446 53.157237, -168.40706 53.34893, -168.385152 53.431084, -168.237275 53.524192, -168.007243 53.568007, -167.886751 53.518715, -167.842935 53.387268, -168.270136 53.244868, -168.500168 53.036744, -168.686384 52.965544, -168.790446 53.157237)), ((-169.74891 52.894344, -169.705095 52.795759, -169.962511 52.790282, -169.989896 52.856005, -169.74891 52.894344)), ((-170.148727 57.221127, -170.28565 57.128019, -170.313035 57.221127, -170.148727 57.221127)), ((-170.669036 52.697174, -170.603313 52.604066, -170.789529 52.538343, -170.816914 52.636928, -170.669036 52.697174)), ((-171.742517 63.716778, -170.94836 63.5689, -170.488297 63.69487, -170.280174 63.683916, -170.093958 63.612716, -170.044665 63.492223, -169.644848 63.4265, -169.518879 63.366254, -168.99857 63.338869, -168.686384 63.295053, -168.856169 63.147176, -169.108108 63.180038, -169.376478 63.152653, -169.513402 63.08693, -169.639372 62.939052, -169.831064 63.075976, -170.055619 63.169084, -170.263743 63.180038, -170.362328 63.2841, -170.866206 63.415546, -171.101715 63.421023, -171.463193 63.306007, -171.73704 63.366254, -171.852055 63.486746, -171.742517 63.716778)), ((-172.432611 52.390465, -172.41618 52.275449, -172.607873 52.253542, -172.569535 52.352127, -172.432611 52.390465)), ((-173.626584 52.14948, -173.495138 52.105664, -173.122706 52.111141, -173.106275 52.07828, -173.549907 52.028987, -173.626584 52.14948)), ((-174.322156 52.280926, -174.327632 52.379511, -174.185232 52.41785, -173.982585 52.319265, -174.059262 52.226157, -174.179755 52.231634, -174.141417 52.127572, -174.333109 52.116618, -174.738403 52.007079, -174.968435 52.039941, -174.902711 52.116618, -174.656249 52.105664, -174.322156 52.280926)), ((-176.469116 51.853725, -176.288377 51.870156, -176.288377 51.744186, -176.518409 51.760617, -176.80321 51.61274, -176.912748 51.80991, -176.792256 51.815386, -176.775825 51.963264, -176.627947 51.968741, -176.627947 51.859202, -176.469116 51.853725)), ((-177.153734 51.946833, -177.044195 51.897541, -177.120872 51.727755, -177.274226 51.678463, -177.279703 51.782525, -177.153734 51.946833)), ((-178.123152 51.919448, -177.953367 51.913971, -177.800013 51.793479, -177.964321 51.651078, -178.123152 51.919448)), ((173.107557 52.992929, 173.293773 52.927205, 173.304726 52.823143, 172.90491 52.762897, 172.642017 52.927205, 172.642017 53.003883, 173.107557 52.992929)))"},
+             {"AZ",
+              "POLYGON ((-109.042503 37.000263, -109.04798 31.331629, -111.074448 31.331629, -112.246513 31.704061, -114.815198 32.492741, -114.72209 32.717295, -114.524921 32.755634, -114.470151 32.843265, -114.524921 33.029481, -114.661844 33.034958, -114.727567 33.40739, -114.524921 33.54979, -114.497536 33.697668, -114.535874 33.933176, -114.415382 34.108438, -114.256551 34.174162, -114.136058 34.305608, -114.333228 34.448009, -114.470151 34.710902, -114.634459 34.87521, -114.634459 35.00118, -114.574213 35.138103, -114.596121 35.324319, -114.678275 35.516012, -114.738521 36.102045, -114.371566 36.140383, -114.251074 36.01989, -114.152489 36.025367, -114.048427 36.195153, -114.048427 37.000263, -110.499369 37.00574, -109.042503 37.000263))"},
+             {"AR",
+              "POLYGON ((-94.473842 36.501861, -90.152536 36.496384, -90.064905 36.304691, -90.218259 36.184199, -90.377091 35.997983, -89.730812 35.997983, -89.763673 35.811767, -89.911551 35.756997, -89.944412 35.603643, -90.130628 35.439335, -90.114197 35.198349, -90.212782 35.023087, -90.311367 34.995703, -90.251121 34.908072, -90.409952 34.831394, -90.481152 34.661609, -90.585214 34.617794, -90.568783 34.420624, -90.749522 34.365854, -90.744046 34.300131, -90.952169 34.135823, -90.891923 34.026284, -91.072662 33.867453, -91.231493 33.560744, -91.056231 33.429298, -91.143862 33.347144, -91.089093 33.13902, -91.16577 33.002096, -93.608485 33.018527, -94.041164 33.018527, -94.041164 33.54979, -94.183564 33.593606, -94.380734 33.544313, -94.484796 33.637421, -94.430026 35.395519, -94.616242 36.501861, -94.473842 36.501861))"},
+             {"CA",
+              "POLYGON ((-123.233256 42.006186, -122.378853 42.011663, -121.037003 41.995232, -120.001861 41.995232, -119.996384 40.264519, -120.001861 38.999346, -118.71478 38.101128, -117.498899 37.21934, -116.540435 36.501861, -115.85034 35.970598, -114.634459 35.00118, -114.634459 34.87521, -114.470151 34.710902, -114.333228 34.448009, -114.136058 34.305608, -114.256551 34.174162, -114.415382 34.108438, -114.535874 33.933176, -114.497536 33.697668, -114.524921 33.54979, -114.727567 33.40739, -114.661844 33.034958, -114.524921 33.029481, -114.470151 32.843265, -114.524921 32.755634, -114.72209 32.717295, -116.04751 32.624187, -117.126467 32.536556, -117.24696 32.668003, -117.252437 32.876127, -117.329114 33.122589, -117.471515 33.297851, -117.7837 33.538836, -118.183517 33.763391, -118.260194 33.703145, -118.413548 33.741483, -118.391641 33.840068, -118.566903 34.042715, -118.802411 33.998899, -119.218659 34.146777, -119.278905 34.26727, -119.558229 34.415147, -119.875891 34.40967, -120.138784 34.475393, -120.472878 34.448009, -120.64814 34.579455, -120.609801 34.858779, -120.670048 34.902595, -120.631709 35.099764, -120.894602 35.247642, -120.905556 35.450289, -121.004141 35.461243, -121.168449 35.636505, -121.283465 35.674843, -121.332757 35.784382, -121.716143 36.195153, -121.896882 36.315645, -121.935221 36.638785, -121.858544 36.6114, -121.787344 36.803093, -121.929744 36.978355, -122.105006 36.956447, -122.335038 37.115279, -122.417192 37.241248, -122.400761 37.361741, -122.515777 37.520572, -122.515777 37.783465, -122.329561 37.783465, -122.406238 38.15042, -122.488392 38.112082, -122.504823 37.931343, -122.701993 37.893004, -122.937501 38.029928, -122.97584 38.265436, -123.129194 38.451652, -123.331841 38.566668, -123.44138 38.698114, -123.737134 38.95553, -123.687842 39.032208, -123.824765 39.366301, -123.764519 39.552517, -123.85215 39.831841, -124.109566 40.105688, -124.361506 40.259042, -124.410798 40.439781, -124.158859 40.877937, -124.109566 41.025814, -124.158859 41.14083, -124.065751 41.442061, -124.147905 41.715908, -124.257444 41.781632, -124.213628 42.000709, -123.233256 42.006186))"},
+             {"CO",
+              "POLYGON ((-107.919731 41.003906, -105.728954 40.998429, -104.053011 41.003906, -102.053927 41.003906, -102.053927 40.001626, -102.042974 36.994786, -103.001438 37.000263, -104.337812 36.994786, -106.868158 36.994786, -107.421329 37.000263, -109.042503 37.000263, -109.042503 38.166851, -109.058934 38.27639, -109.053457 39.125316, -109.04798 40.998429, -107.919731 41.003906))"},
+             {"CT",
+              "POLYGON ((-73.053528 42.039048, -71.799309 42.022617, -71.799309 42.006186, -71.799309 41.414677, -71.859555 41.321569, -71.947186 41.338, -72.385341 41.261322, -72.905651 41.28323, -73.130205 41.146307, -73.371191 41.102491, -73.655992 40.987475, -73.727192 41.102491, -73.48073 41.21203, -73.55193 41.294184, -73.486206 42.050002, -73.053528 42.039048))"},
+             {"DE",
+              "POLYGON ((-75.414089 39.804456, -75.507197 39.683964, -75.611259 39.61824, -75.589352 39.459409, -75.441474 39.311532, -75.403136 39.065069, -75.189535 38.807653, -75.09095 38.796699, -75.047134 38.451652, -75.693413 38.462606, -75.786521 39.722302, -75.616736 39.831841, -75.414089 39.804456))"},
+             {"FL",
+              "POLYGON ((-85.497137 30.997536, -85.004212 31.003013, -84.867289 30.712735, -83.498053 30.647012, -82.216449 30.570335, -82.167157 30.356734, -82.046664 30.362211, -82.002849 30.564858, -82.041187 30.751074, -81.948079 30.827751, -81.718048 30.745597, -81.444201 30.707258, -81.383954 30.27458, -81.257985 29.787132, -80.967707 29.14633, -80.524075 28.461713, -80.589798 28.41242, -80.56789 28.094758, -80.381674 27.738757, -80.091397 27.021277, -80.03115 26.796723, -80.036627 26.566691, -80.146166 25.739673, -80.239274 25.723243, -80.337859 25.465826, -80.304997 25.383672, -80.49669 25.197456, -80.573367 25.241272, -80.759583 25.164595, -81.077246 25.120779, -81.170354 25.224841, -81.126538 25.378195, -81.351093 25.821827, -81.526355 25.903982, -81.679709 25.843735, -81.800202 26.090198, -81.833064 26.292844, -82.041187 26.517399, -82.09048 26.665276, -82.057618 26.878877, -82.172634 26.917216, -82.145249 26.791246, -82.249311 26.758384, -82.566974 27.300601, -82.692943 27.437525, -82.391711 27.837342, -82.588881 27.815434, -82.720328 27.689464, -82.851774 27.886634, -82.676512 28.434328, -82.643651 28.888914, -82.764143 28.998453, -82.802482 29.14633, -82.994175 29.179192, -83.218729 29.420177, -83.399469 29.518762, -83.410422 29.66664, -83.536392 29.721409, -83.640454 29.885717, -84.02384 30.104795, -84.357933 30.055502, -84.341502 29.902148, -84.451041 29.929533, -84.867289 29.743317, -85.310921 29.699501, -85.299967 29.80904, -85.404029 29.940487, -85.924338 30.236241, -86.29677 30.362211, -86.630863 30.395073, -86.910187 30.373165, -87.518128 30.280057, -87.37025 30.427934, -87.446927 30.510088, -87.408589 30.674397, -87.633143 30.86609, -87.600282 30.997536, -85.497137 30.997536))"},
+             {"GA",
+              "POLYGON ((-83.109191 35.00118, -83.322791 34.787579, -83.339222 34.683517, -83.005129 34.469916, -82.901067 34.486347, -82.747713 34.26727, -82.714851 34.152254, -82.55602 33.94413, -82.325988 33.81816, -82.194542 33.631944, -81.926172 33.462159, -81.937125 33.347144, -81.761863 33.160928, -81.493493 33.007573, -81.42777 32.843265, -81.416816 32.629664, -81.279893 32.558464, -81.121061 32.290094, -81.115584 32.120309, -80.885553 32.032678, -81.132015 31.693108, -81.175831 31.517845, -81.279893 31.364491, -81.290846 31.20566, -81.400385 31.13446, -81.444201 30.707258, -81.718048 30.745597, -81.948079 30.827751, -82.041187 30.751074, -82.002849 30.564858, -82.046664 30.362211, -82.167157 30.356734, -82.216449 30.570335, -83.498053 30.647012, -84.867289 30.712735, -85.004212 31.003013, -85.113751 31.27686, -85.042551 31.539753, -85.141136 31.840985, -85.053504 32.01077, -85.058981 32.13674, -84.889196 32.262709, -85.004212 32.322956, -84.960397 32.421541, -85.069935 32.580372, -85.184951 32.859696, -85.431413 34.124869, -85.606675 34.984749, -84.319594 34.990226, -83.618546 34.984749, -83.109191 35.00118))"},
+             {"HI",
+              "MULTIPOLYGON (((-155.634835 18.948267, -155.881297 19.035898, -155.919636 19.123529, -155.886774 19.348084, -156.062036 19.73147, -155.925113 19.857439, -155.826528 20.032702, -155.897728 20.147717, -155.87582 20.26821, -155.596496 20.12581, -155.284311 20.021748, -155.092618 19.868393, -155.092618 19.736947, -154.807817 19.523346, -154.983079 19.348084, -155.295265 19.26593, -155.514342 19.134483, -155.634835 18.948267)), ((-156.587823 21.029505, -156.472807 20.892581, -156.324929 20.952827, -156.00179 20.793996, -156.051082 20.651596, -156.379699 20.580396, -156.445422 20.60778, -156.461853 20.783042, -156.631638 20.821381, -156.697361 20.919966, -156.587823 21.029505)), ((-156.982162 21.210244, -157.080747 21.106182, -157.310779 21.106182, -157.239579 21.221198, -156.982162 21.210244)), ((-157.951581 21.697691, -157.842042 21.462183, -157.896811 21.325259, -158.110412 21.303352, -158.252813 21.582676, -158.126843 21.588153, -157.951581 21.697691)), ((-159.468693 22.228955, -159.353678 22.218001, -159.298908 22.113939, -159.33177 21.966061, -159.446786 21.872953, -159.764448 21.987969, -159.726109 22.152277, -159.468693 22.228955)))"},
+             {"ID",
+              "POLYGON ((-116.04751 49.000239, -116.04751 47.976051, -115.724371 47.696727, -115.718894 47.42288, -115.527201 47.302388, -115.324554 47.258572, -115.302646 47.187372, -114.930214 46.919002, -114.886399 46.809463, -114.623506 46.705401, -114.612552 46.639678, -114.322274 46.645155, -114.464674 46.272723, -114.492059 46.037214, -114.387997 45.88386, -114.568736 45.774321, -114.497536 45.670259, -114.546828 45.560721, -114.333228 45.456659, -114.086765 45.593582, -113.98818 45.703121, -113.807441 45.604536, -113.834826 45.522382, -113.736241 45.330689, -113.571933 45.128042, -113.45144 45.056842, -113.456917 44.865149, -113.341901 44.782995, -113.133778 44.772041, -113.002331 44.448902, -112.887315 44.394132, -112.783254 44.48724, -112.471068 44.481763, -112.241036 44.569394, -112.104113 44.520102, -111.868605 44.563917, -111.819312 44.509148, -111.616665 44.547487, -111.386634 44.75561, -111.227803 44.580348, -111.047063 44.476286, -111.047063 42.000709, -112.164359 41.995232, -114.04295 41.995232, -117.027882 42.000709, -117.027882 43.830007, -116.896436 44.158624, -116.97859 44.240778, -117.170283 44.257209, -117.241483 44.394132, -117.038836 44.750133, -116.934774 44.782995, -116.830713 44.930872, -116.847143 45.02398, -116.732128 45.144473, -116.671881 45.319735, -116.463758 45.61549, -116.545912 45.752413, -116.78142 45.823614, -116.918344 45.993399, -116.92382 46.168661, -117.055267 46.343923, -117.038836 46.426077, -117.044313 47.762451, -117.033359 49.000239, -116.04751 49.000239))"},
+             {"IL",
+              "POLYGON ((-90.639984 42.510065, -88.788778 42.493634, -87.802929 42.493634, -87.83579 42.301941, -87.682436 42.077386, -87.523605 41.710431, -87.529082 39.34987, -87.63862 39.169131, -87.512651 38.95553, -87.49622 38.780268, -87.62219 38.637868, -87.655051 38.506421, -87.83579 38.292821, -87.950806 38.27639, -87.923421 38.15042, -88.000098 38.101128, -88.060345 37.865619, -88.027483 37.799896, -88.15893 37.657496, -88.065822 37.482234, -88.476592 37.389126, -88.514931 37.285064, -88.421823 37.153617, -88.547792 37.071463, -88.914747 37.224817, -89.029763 37.213863, -89.183118 37.038601, -89.133825 36.983832, -89.292656 36.994786, -89.517211 37.279587, -89.435057 37.34531, -89.517211 37.537003, -89.517211 37.690357, -89.84035 37.903958, -89.949889 37.88205, -90.059428 38.013497, -90.355183 38.216144, -90.349706 38.374975, -90.179921 38.632391, -90.207305 38.725499, -90.10872 38.845992, -90.251121 38.917192, -90.470199 38.961007, -90.585214 38.867899, -90.661891 38.928146, -90.727615 39.256762, -91.061708 39.470363, -91.368417 39.727779, -91.494386 40.034488, -91.50534 40.237135, -91.417709 40.379535, -91.401278 40.560274, -91.121954 40.669813, -91.09457 40.823167, -90.963123 40.921752, -90.946692 41.097014, -91.111001 41.239415, -91.045277 41.414677, -90.656414 41.463969, -90.344229 41.589939, -90.311367 41.743293, -90.179921 41.809016, -90.141582 42.000709, -90.168967 42.126679, -90.393521 42.225264, -90.420906 42.329326, -90.639984 42.510065))"},
+             {"IN",
+              "POLYGON ((-85.990061 41.759724, -84.807042 41.759724, -84.807042 41.694001, -84.801565 40.500028, -84.817996 39.103408, -84.894673 39.059592, -84.812519 38.785745, -84.987781 38.780268, -85.173997 38.68716, -85.431413 38.730976, -85.42046 38.533806, -85.590245 38.451652, -85.655968 38.325682, -85.83123 38.27639, -85.924338 38.024451, -86.039354 37.958727, -86.263908 38.051835, -86.302247 38.166851, -86.521325 38.040881, -86.504894 37.931343, -86.729448 37.893004, -86.795172 37.991589, -87.047111 37.893004, -87.129265 37.788942, -87.381204 37.93682, -87.512651 37.903958, -87.600282 37.975158, -87.682436 37.903958, -87.934375 37.893004, -88.027483 37.799896, -88.060345 37.865619, -88.000098 38.101128, -87.923421 38.15042, -87.950806 38.27639, -87.83579 38.292821, -87.655051 38.506421, -87.62219 38.637868, -87.49622 38.780268, -87.512651 38.95553, -87.63862 39.169131, -87.529082 39.34987, -87.523605 41.710431, -87.42502 41.644708, -87.118311 41.644708, -86.822556 41.759724, -85.990061 41.759724))"},
+             {"IA",
+              "POLYGON ((-91.368417 43.501391, -91.215062 43.501391, -91.204109 43.353514, -91.056231 43.254929, -91.176724 43.134436, -91.143862 42.909881, -91.067185 42.75105, -90.711184 42.636034, -90.639984 42.510065, -90.420906 42.329326, -90.393521 42.225264, -90.168967 42.126679, -90.141582 42.000709, -90.179921 41.809016, -90.311367 41.743293, -90.344229 41.589939, -90.656414 41.463969, -91.045277 41.414677, -91.111001 41.239415, -90.946692 41.097014, -90.963123 40.921752, -91.09457 40.823167, -91.121954 40.669813, -91.401278 40.560274, -91.417709 40.379535, -91.527248 40.412397, -91.729895 40.615043, -91.833957 40.609566, -93.257961 40.582182, -94.632673 40.571228, -95.7664 40.587659, -95.881416 40.719105, -95.826646 40.976521, -95.925231 41.201076, -95.919754 41.453015, -96.095016 41.540646, -96.122401 41.67757, -96.062155 41.798063, -96.127878 41.973325, -96.264801 42.039048, -96.44554 42.488157, -96.631756 42.707235, -96.544125 42.855112, -96.511264 43.052282, -96.434587 43.123482, -96.560556 43.222067, -96.527695 43.397329, -96.582464 43.479483, -96.451017 43.501391, -91.368417 43.501391))"},
+             {"KS",
+              "POLYGON ((-101.90605 40.001626, -95.306337 40.001626, -95.207752 39.908518, -94.884612 39.831841, -95.109167 39.541563, -94.983197 39.442978, -94.824366 39.20747, -94.610765 39.158177, -94.616242 37.000263, -100.087706 37.000263, -102.042974 36.994786, -102.053927 40.001626, -101.90605 40.001626))"},
+             {"KY",
+              "POLYGON ((-83.903347 38.769315, -83.678792 38.632391, -83.519961 38.703591, -83.142052 38.626914, -83.032514 38.725499, -82.890113 38.758361, -82.846298 38.588575, -82.731282 38.561191, -82.594358 38.424267, -82.621743 38.123036, -82.50125 37.931343, -82.342419 37.783465, -82.293127 37.668449, -82.101434 37.553434, -81.969987 37.537003, -82.353373 37.268633, -82.720328 37.120755, -82.720328 37.044078, -82.868205 36.978355, -82.879159 36.890724, -83.070852 36.852385, -83.136575 36.742847, -83.673316 36.600446, -83.689746 36.584015, -84.544149 36.594969, -85.289013 36.627831, -85.486183 36.616877, -86.592525 36.655216, -87.852221 36.633308, -88.071299 36.677123, -88.054868 36.496384, -89.298133 36.507338, -89.418626 36.496384, -89.363857 36.622354, -89.215979 36.578538, -89.133825 36.983832, -89.183118 37.038601, -89.029763 37.213863, -88.914747 37.224817, -88.547792 37.071463, -88.421823 37.153617, -88.514931 37.285064, -88.476592 37.389126, -88.065822 37.482234, -88.15893 37.657496, -88.027483 37.799896, -87.934375 37.893004, -87.682436 37.903958, -87.600282 37.975158, -87.512651 37.903958, -87.381204 37.93682, -87.129265 37.788942, -87.047111 37.893004, -86.795172 37.991589, -86.729448 37.893004, -86.504894 37.931343, -86.521325 38.040881, -86.302247 38.166851, -86.263908 38.051835, -86.039354 37.958727, -85.924338 38.024451, -85.83123 38.27639, -85.655968 38.325682, -85.590245 38.451652, -85.42046 38.533806, -85.431413 38.730976, -85.173997 38.68716, -84.987781 38.780268, -84.812519 38.785745, -84.894673 39.059592, -84.817996 39.103408, -84.43461 39.103408, -84.231963 38.895284, -84.215533 38.807653, -83.903347 38.769315))"},
+             {"LA",
+              "POLYGON ((-93.608485 33.018527, -91.16577 33.002096, -91.072662 32.887081, -91.143862 32.843265, -91.154816 32.640618, -91.006939 32.514649, -90.985031 32.218894, -91.105524 31.988862, -91.341032 31.846462, -91.401278 31.621907, -91.499863 31.643815, -91.516294 31.27686, -91.636787 31.265906, -91.565587 31.068736, -91.636787 30.997536, -89.747242 30.997536, -89.845827 30.66892, -89.681519 30.449842, -89.643181 30.285534, -89.522688 30.181472, -89.818443 30.044549, -89.84035 29.945964, -89.599365 29.88024, -89.495303 30.039072, -89.287179 29.88024, -89.30361 29.754271, -89.424103 29.699501, -89.648657 29.748794, -89.621273 29.655686, -89.69795 29.513285, -89.506257 29.387316, -89.199548 29.348977, -89.09001 29.2011, -89.002379 29.179192, -89.16121 29.009407, -89.336472 29.042268, -89.484349 29.217531, -89.851304 29.310638, -89.851304 29.480424, -90.032043 29.425654, -90.021089 29.283254, -90.103244 29.151807, -90.23469 29.129899, -90.333275 29.277777, -90.563307 29.283254, -90.645461 29.129899, -90.798815 29.086084, -90.963123 29.179192, -91.09457 29.190146, -91.220539 29.436608, -91.445094 29.546147, -91.532725 29.529716, -91.620356 29.73784, -91.883249 29.710455, -91.888726 29.836425, -92.146142 29.715932, -92.113281 29.622824, -92.31045 29.535193, -92.617159 29.579009, -92.97316 29.715932, -93.2251 29.776178, -93.767317 29.726886, -93.838517 29.688547, -93.926148 29.787132, -93.690639 30.143133, -93.767317 30.334826, -93.696116 30.438888, -93.728978 30.575812, -93.630393 30.679874, -93.526331 30.93729, -93.542762 31.15089, -93.816609 31.556184, -93.822086 31.775262, -94.041164 31.994339, -94.041164 33.018527, -93.608485 33.018527))"},
+             {"ME",
+              "POLYGON ((-70.703921 43.057759, -70.824413 43.128959, -70.807983 43.227544, -70.966814 43.34256, -71.032537 44.657025, -71.08183 45.303304, -70.649151 45.440228, -70.720352 45.511428, -70.556043 45.664782, -70.386258 45.735983, -70.41912 45.796229, -70.260289 45.889337, -70.309581 46.064599, -70.210996 46.327492, -70.057642 46.415123, -69.997395 46.694447, -69.225147 47.461219, -69.044408 47.428357, -69.033454 47.242141, -68.902007 47.176418, -68.578868 47.285957, -68.376221 47.285957, -68.233821 47.357157, -67.954497 47.198326, -67.790188 47.066879, -67.779235 45.944106, -67.801142 45.675736, -67.456095 45.604536, -67.505388 45.48952, -67.417757 45.379982, -67.488957 45.281397, -67.346556 45.128042, -67.16034 45.160904, -66.979601 44.804903, -67.187725 44.646072, -67.308218 44.706318, -67.406803 44.596779, -67.549203 44.624164, -67.565634 44.531056, -67.75185 44.54201, -68.047605 44.328409, -68.118805 44.476286, -68.222867 44.48724, -68.173574 44.328409, -68.403606 44.251732, -68.458375 44.377701, -68.567914 44.311978, -68.82533 44.311978, -68.830807 44.459856, -68.984161 44.426994, -68.956777 44.322932, -69.099177 44.103854, -69.071793 44.043608, -69.258008 43.923115, -69.444224 43.966931, -69.553763 43.840961, -69.707118 43.82453, -69.833087 43.720469, -69.986442 43.742376, -70.030257 43.851915, -70.254812 43.676653, -70.194565 43.567114, -70.358873 43.528776, -70.369827 43.435668, -70.556043 43.320652, -70.703921 43.057759))"},
+             {"MD",
+              "POLYGON ((-79.4778 39.7220,-78.3600 39.7220,-75.7878 39.7220,-75.7809 39.5655,-75.7617 39.3152,-75.7329 38.9498,-75.6944 38.4611,-74.8581 38.4482,-74.9721 38.0200,-75.2316 38.0275,-75.6079 37.9962,-75.6230 37.9951,-75.6436 37.9464,-75.7288 37.9529,-75.8084 37.9117,-75.9512 37.9095,-75.9430 37.9464,-76.0584 37.9529,-76.2396 37.8889,-76.3454 37.9474,-76.4154 37.9669,-76.4703 38.0146,-76.5170 38.0275,-76.5363 38.0751,-76.6063 38.1464,-76.6928 38.1616,-76.7601 38.1670,-76.8494 38.1637,-76.9482 38.2080,-76.9908 38.2748,-77.0306 38.3093,-77.0114 38.3761,-77.0430 38.4009,-77.0897 38.3697,-77.1432 38.3697,-77.2627 38.3320,-77.3135 38.4525,-77.2737 38.5514,-77.2490 38.5954,-77.1281 38.6373,-77.1378 38.6737,-77.0760 38.7112,-77.0361 38.7187,-77.0416 38.7766,-77.0320 38.8451,-77.0708 38.9025,-77.1395 38.9570,-77.2335 38.9773,-77.2462 39.0240,-77.3431 39.0634,-77.4351 39.0717,-77.4636 39.0792,-77.5202 39.1218,-77.5092 39.1804,-77.4577 39.2269,-77.5666 39.3051,-77.6321 39.3067,-77.7159 39.3202,-77.7626 39.3383,-77.7544 39.3810,-77.7602 39.4288,-77.8038 39.4367,-77.7997 39.4606,-77.7859 39.5019,-77.8436 39.5062,-77.8217 39.5210,-77.8354 39.5337,-77.8656 39.5231,-77.8848 39.5591,-77.8821 39.6015,-77.9974 39.6078,-78.0222 39.6247,-78.1430 39.6924,-78.1924 39.6945,-78.2062 39.6839,-78.2419 39.6839,-78.2281 39.6586,-78.2776 39.6226,-78.3517 39.6438,-78.3765 39.6120,-78.4067 39.6036,-78.4177 39.5824,-78.4245 39.5750,-78.4232 39.5464,-78.4698 39.5146,-78.5687 39.5189,-78.6676 39.5337,-78.7390 39.5888,-78.7720 39.6015,-78.7363 39.6184,-78.7775 39.6438,-78.7912 39.6036,-78.8187 39.6036,-78.8571 39.5549,-78.9203 39.4913,-78.9725 39.4426,-79.0542 39.4834,-79.0604 39.4738,-79.1043 39.4553,-79.1936 39.3853,-79.2705 39.3449,-79.3282 39.3014,-79.4044 39.2535,-79.4696 39.2073,-79.4861 39.2051,-79.4861 39.2546,-79.4854 39.3444,-79.4840 39.3454,-79.4833 39.5316,-79.4772 39.7214,-79.4778 39.7220))"},
+             {"MA",
+              "POLYGON ((-70.917521 42.887974, -70.818936 42.871543, -70.780598 42.696281, -70.824413 42.55388, -70.983245 42.422434, -70.988722 42.269079, -70.769644 42.247172, -70.638197 42.08834, -70.660105 41.962371, -70.550566 41.929509, -70.539613 41.814493, -70.260289 41.715908, -69.937149 41.809016, -70.008349 41.672093, -70.484843 41.5516, -70.660105 41.546123, -70.764167 41.639231, -70.928475 41.611847, -70.933952 41.540646, -71.120168 41.496831, -71.196845 41.67757, -71.22423 41.710431, -71.328292 41.781632, -71.383061 42.01714, -71.530939 42.01714, -71.799309 42.006186, -71.799309 42.022617, -73.053528 42.039048, -73.486206 42.050002, -73.508114 42.08834, -73.267129 42.745573, -72.456542 42.729142, -71.29543 42.696281, -71.185891 42.789389, -70.917521 42.887974))"},
+             {"MI",
+              "MULTIPOLYGON (((-83.454238 41.732339, -84.807042 41.694001, -84.807042 41.759724, -85.990061 41.759724, -86.822556 41.759724, -86.619909 41.891171, -86.482986 42.115725, -86.357016 42.252649, -86.263908 42.444341, -86.209139 42.718189, -86.231047 43.013943, -86.526801 43.594499, -86.433693 43.813577, -86.499417 44.07647, -86.269385 44.34484, -86.220093 44.569394, -86.252954 44.689887, -86.088646 44.73918, -86.066738 44.903488, -85.809322 44.947303, -85.612152 45.128042, -85.628583 44.766564, -85.524521 44.750133, -85.393075 44.930872, -85.387598 45.237581, -85.305444 45.314258, -85.031597 45.363551, -85.119228 45.577151, -84.938489 45.75789, -84.713934 45.768844, -84.461995 45.653829, -84.215533 45.637398, -84.09504 45.494997, -83.908824 45.484043, -83.596638 45.352597, -83.4871 45.358074, -83.317314 45.144473, -83.454238 45.029457, -83.322791 44.88158, -83.273499 44.711795, -83.333745 44.339363, -83.536392 44.246255, -83.585684 44.054562, -83.82667 43.988839, -83.958116 43.758807, -83.908824 43.671176, -83.667839 43.589022, -83.481623 43.714992, -83.262545 43.972408, -82.917498 44.070993, -82.747713 43.994316, -82.643651 43.851915, -82.539589 43.435668, -82.523158 43.227544, -82.413619 42.975605, -82.517681 42.614127, -82.681989 42.559357, -82.687466 42.690804, -82.797005 42.652465, -82.922975 42.351234, -83.125621 42.236218, -83.185868 42.006186, -83.437807 41.814493, -83.454238 41.732339)), ((-85.508091 45.730506, -85.49166 45.610013, -85.623106 45.588105, -85.568337 45.75789, -85.508091 45.730506)), ((-87.589328 45.095181, -87.742682 45.199243, -87.649574 45.341643, -87.885083 45.363551, -87.791975 45.500474, -87.781021 45.675736, -87.989145 45.796229, -88.10416 45.922199, -88.531362 46.020784, -88.662808 45.987922, -89.09001 46.135799, -90.119674 46.338446, -90.229213 46.508231, -90.415429 46.568478, -90.026566 46.672539, -89.851304 46.793032, -89.413149 46.842325, -89.128348 46.990202, -88.996902 46.995679, -88.887363 47.099741, -88.575177 47.247618, -88.416346 47.373588, -88.180837 47.455742, -87.956283 47.384542, -88.350623 47.077833, -88.443731 46.973771, -88.438254 46.787555, -88.246561 46.929956, -87.901513 46.908048, -87.633143 46.809463, -87.392158 46.535616, -87.260711 46.486323, -87.008772 46.530139, -86.948526 46.469893, -86.696587 46.437031, -86.159846 46.667063, -85.880522 46.68897, -85.508091 46.678016, -85.256151 46.754694, -85.064458 46.760171, -85.02612 46.480847, -84.82895 46.442508, -84.63178 46.486323, -84.549626 46.4206, -84.418179 46.502754, -84.127902 46.530139, -84.122425 46.179615, -83.990978 46.031737, -83.793808 45.993399, -83.7719 46.091984, -83.580208 46.091984, -83.476146 45.987922, -83.563777 45.911245, -84.111471 45.976968, -84.374364 45.933153, -84.659165 46.053645, -84.741319 45.944106, -84.70298 45.850998, -84.82895 45.872906, -85.015166 46.00983, -85.338305 46.091984, -85.502614 46.097461, -85.661445 45.966014, -85.924338 45.933153, -86.209139 45.960537, -86.324155 45.905768, -86.351539 45.796229, -86.663725 45.703121, -86.647294 45.834568, -86.784218 45.861952, -86.838987 45.725029, -87.069019 45.719552, -87.17308 45.659305, -87.326435 45.423797, -87.611236 45.122565, -87.589328 45.095181)), ((-88.805209 47.976051, -89.057148 47.850082, -89.188594 47.833651, -89.177641 47.937713, -88.547792 48.173221, -88.668285 48.008913, -88.805209 47.976051)))"},
+             {"MN",
+              "POLYGON ((-92.014696 46.705401, -92.091373 46.749217, -92.29402 46.667063, -92.29402 46.075553, -92.354266 46.015307, -92.639067 45.933153, -92.869098 45.719552, -92.885529 45.577151, -92.770513 45.566198, -92.644544 45.440228, -92.75956 45.286874, -92.737652 45.117088, -92.808852 44.750133, -92.545959 44.569394, -92.337835 44.552964, -92.233773 44.443425, -91.927065 44.333886, -91.877772 44.202439, -91.592971 44.032654, -91.43414 43.994316, -91.242447 43.775238, -91.269832 43.616407, -91.215062 43.501391, -91.368417 43.501391, -96.451017 43.501391, -96.451017 45.297827, -96.681049 45.412843, -96.856311 45.604536, -96.582464 45.818137, -96.560556 45.933153, -96.598895 46.332969, -96.719387 46.437031, -96.801542 46.656109, -96.785111 46.924479, -96.823449 46.968294, -96.856311 47.609096, -97.053481 47.948667, -97.130158 48.140359, -97.16302 48.545653, -97.097296 48.682577, -97.228743 49.000239, -95.152983 49.000239, -95.152983 49.383625, -94.955813 49.372671, -94.824366 49.295994, -94.69292 48.775685, -94.588858 48.715438, -94.260241 48.699007, -94.221903 48.649715, -93.838517 48.627807, -93.794701 48.518268, -93.466085 48.545653, -93.466085 48.589469, -93.208669 48.644238, -92.984114 48.62233, -92.726698 48.540176, -92.655498 48.436114, -92.50762 48.447068, -92.370697 48.222514, -92.304974 48.315622, -92.053034 48.359437, -92.009219 48.266329, -91.713464 48.200606, -91.713464 48.112975, -91.565587 48.041775, -91.264355 48.080113, -91.083616 48.178698, -90.837154 48.238944, -90.749522 48.091067, -90.579737 48.123929, -90.377091 48.091067, -90.141582 48.112975, -89.873212 47.987005, -89.615796 48.008913, -89.637704 47.954144, -89.971797 47.828174, -90.437337 47.729589, -90.738569 47.625527, -91.171247 47.368111, -91.357463 47.20928, -91.642264 47.028541, -92.091373 46.787555, -92.014696 46.705401))"},
+             {"MS",
+              "POLYGON ((-88.471115 34.995703, -88.202745 34.995703, -88.098683 34.891641, -88.241084 33.796253, -88.471115 31.895754, -88.394438 30.367688, -88.503977 30.323872, -88.744962 30.34578, -88.843547 30.411504, -89.084533 30.367688, -89.418626 30.252672, -89.522688 30.181472, -89.643181 30.285534, -89.681519 30.449842, -89.845827 30.66892, -89.747242 30.997536, -91.636787 30.997536, -91.565587 31.068736, -91.636787 31.265906, -91.516294 31.27686, -91.499863 31.643815, -91.401278 31.621907, -91.341032 31.846462, -91.105524 31.988862, -90.985031 32.218894, -91.006939 32.514649, -91.154816 32.640618, -91.143862 32.843265, -91.072662 32.887081, -91.16577 33.002096, -91.089093 33.13902, -91.143862 33.347144, -91.056231 33.429298, -91.231493 33.560744, -91.072662 33.867453, -90.891923 34.026284, -90.952169 34.135823, -90.744046 34.300131, -90.749522 34.365854, -90.568783 34.420624, -90.585214 34.617794, -90.481152 34.661609, -90.409952 34.831394, -90.251121 34.908072, -90.311367 34.995703, -88.471115 34.995703))"},
+             {"MO",
+              "POLYGON ((-91.833957 40.609566, -91.729895 40.615043, -91.527248 40.412397, -91.417709 40.379535, -91.50534 40.237135, -91.494386 40.034488, -91.368417 39.727779, -91.061708 39.470363, -90.727615 39.256762, -90.661891 38.928146, -90.585214 38.867899, -90.470199 38.961007, -90.251121 38.917192, -90.10872 38.845992, -90.207305 38.725499, -90.179921 38.632391, -90.349706 38.374975, -90.355183 38.216144, -90.059428 38.013497, -89.949889 37.88205, -89.84035 37.903958, -89.517211 37.690357, -89.517211 37.537003, -89.435057 37.34531, -89.517211 37.279587, -89.292656 36.994786, -89.133825 36.983832, -89.215979 36.578538, -89.363857 36.622354, -89.418626 36.496384, -89.484349 36.496384, -89.539119 36.496384, -89.533642 36.249922, -89.730812 35.997983, -90.377091 35.997983, -90.218259 36.184199, -90.064905 36.304691, -90.152536 36.496384, -94.473842 36.501861, -94.616242 36.501861, -94.616242 37.000263, -94.610765 39.158177, -94.824366 39.20747, -94.983197 39.442978, -95.109167 39.541563, -94.884612 39.831841, -95.207752 39.908518, -95.306337 40.001626, -95.552799 40.264519, -95.7664 40.587659, -94.632673 40.571228, -93.257961 40.582182, -91.833957 40.609566))"},
+             {"MT",
+              "POLYGON ((-104.047534 49.000239, -104.042057 47.861036, -104.047534 45.944106, -104.042057 44.996596, -104.058488 44.996596, -105.91517 45.002073, -109.080842 45.002073, -111.05254 45.002073, -111.047063 44.476286, -111.227803 44.580348, -111.386634 44.75561, -111.616665 44.547487, -111.819312 44.509148, -111.868605 44.563917, -112.104113 44.520102, -112.241036 44.569394, -112.471068 44.481763, -112.783254 44.48724, -112.887315 44.394132, -113.002331 44.448902, -113.133778 44.772041, -113.341901 44.782995, -113.456917 44.865149, -113.45144 45.056842, -113.571933 45.128042, -113.736241 45.330689, -113.834826 45.522382, -113.807441 45.604536, -113.98818 45.703121, -114.086765 45.593582, -114.333228 45.456659, -114.546828 45.560721, -114.497536 45.670259, -114.568736 45.774321, -114.387997 45.88386, -114.492059 46.037214, -114.464674 46.272723, -114.322274 46.645155, -114.612552 46.639678, -114.623506 46.705401, -114.886399 46.809463, -114.930214 46.919002, -115.302646 47.187372, -115.324554 47.258572, -115.527201 47.302388, -115.718894 47.42288, -115.724371 47.696727, -116.04751 47.976051, -116.04751 49.000239, -111.50165 48.994762, -109.453274 49.000239, -104.047534 49.000239))"},
+             {"NE",
+              "POLYGON ((-103.324578 43.002989, -101.626726 42.997512, -98.499393 42.997512, -98.466531 42.94822, -97.951699 42.767481, -97.831206 42.866066, -97.688806 42.844158, -97.217789 42.844158, -96.692003 42.657942, -96.626279 42.515542, -96.44554 42.488157, -96.264801 42.039048, -96.127878 41.973325, -96.062155 41.798063, -96.122401 41.67757, -96.095016 41.540646, -95.919754 41.453015, -95.925231 41.201076, -95.826646 40.976521, -95.881416 40.719105, -95.7664 40.587659, -95.552799 40.264519, -95.306337 40.001626, -101.90605 40.001626, -102.053927 40.001626, -102.053927 41.003906, -104.053011 41.003906, -104.053011 43.002989, -103.324578 43.002989))"},
+             {"NV",
+              "POLYGON ((-117.027882 42.000709, -114.04295 41.995232, -114.048427 37.000263, -114.048427 36.195153, -114.152489 36.025367, -114.251074 36.01989, -114.371566 36.140383, -114.738521 36.102045, -114.678275 35.516012, -114.596121 35.324319, -114.574213 35.138103, -114.634459 35.00118, -115.85034 35.970598, -116.540435 36.501861, -117.498899 37.21934, -118.71478 38.101128, -120.001861 38.999346, -119.996384 40.264519, -120.001861 41.995232, -118.698349 41.989755, -117.027882 42.000709))"},
+             {"NH",
+              "POLYGON ((-71.08183 45.303304, -71.032537 44.657025, -70.966814 43.34256, -70.807983 43.227544, -70.824413 43.128959, -70.703921 43.057759, -70.818936 42.871543, -70.917521 42.887974, -71.185891 42.789389, -71.29543 42.696281, -72.456542 42.729142, -72.544173 42.80582, -72.533219 42.953697, -72.445588 43.008466, -72.456542 43.150867, -72.379864 43.572591, -72.204602 43.769761, -72.116971 43.994316, -72.02934 44.07647, -72.034817 44.322932, -71.700724 44.41604, -71.536416 44.585825, -71.629524 44.750133, -71.4926 44.914442, -71.503554 45.013027, -71.361154 45.270443, -71.131122 45.243058, -71.08183 45.303304))"},
+             {"NJ",
+              "POLYGON ((-74.236547 41.14083, -73.902454 40.998429, -74.022947 40.708151, -74.187255 40.642428, -74.274886 40.489074, -74.001039 40.412397, -73.979131 40.297381, -74.099624 39.760641, -74.411809 39.360824, -74.614456 39.245808, -74.795195 38.993869, -74.888303 39.158177, -75.178581 39.240331, -75.534582 39.459409, -75.55649 39.607286, -75.561967 39.629194, -75.507197 39.683964, -75.414089 39.804456, -75.145719 39.88661, -75.129289 39.963288, -74.82258 40.127596, -74.773287 40.215227, -75.058088 40.417874, -75.069042 40.543843, -75.195012 40.576705, -75.205966 40.691721, -75.052611 40.866983, -75.134765 40.971045, -74.882826 41.179168, -74.828057 41.288707, -74.69661 41.359907, -74.236547 41.14083))"},
+             {"NM",
+              "POLYGON ((-107.421329 37.000263, -106.868158 36.994786, -104.337812 36.994786, -103.001438 37.000263, -103.001438 36.501861, -103.039777 36.501861, -103.045254 34.01533, -103.067161 33.002096, -103.067161 31.999816, -106.616219 31.999816, -106.643603 31.901231, -106.528588 31.786216, -108.210008 31.786216, -108.210008 31.331629, -109.04798 31.331629, -109.042503 37.000263, -107.421329 37.000263))"},
+             {"NY",
+              "POLYGON ((-73.343806 45.013027, -73.332852 44.804903, -73.387622 44.618687, -73.294514 44.437948, -73.321898 44.246255, -73.436914 44.043608, -73.349283 43.769761, -73.404052 43.687607, -73.245221 43.523299, -73.278083 42.833204, -73.267129 42.745573, -73.508114 42.08834, -73.486206 42.050002, -73.55193 41.294184, -73.48073 41.21203, -73.727192 41.102491, -73.655992 40.987475, -73.22879 40.905321, -73.141159 40.965568, -72.774204 40.965568, -72.587988 40.998429, -72.28128 41.157261, -72.259372 41.042245, -72.100541 40.992952, -72.467496 40.845075, -73.239744 40.625997, -73.562884 40.582182, -73.776484 40.593136, -73.935316 40.543843, -74.022947 40.708151, -73.902454 40.998429, -74.236547 41.14083, -74.69661 41.359907, -74.740426 41.431108, -74.89378 41.436584, -75.074519 41.60637, -75.052611 41.754247, -75.173104 41.869263, -75.249781 41.863786, -75.35932 42.000709, -79.76278 42.000709, -79.76278 42.252649, -79.76278 42.269079, -79.149363 42.55388, -79.050778 42.690804, -78.853608 42.783912, -78.930285 42.953697, -79.012439 42.986559, -79.072686 43.260406, -78.486653 43.375421, -77.966344 43.369944, -77.75822 43.34256, -77.533665 43.233021, -77.391265 43.276836, -76.958587 43.271359, -76.695693 43.34256, -76.41637 43.523299, -76.235631 43.528776, -76.230154 43.802623, -76.137046 43.961454, -76.3616 44.070993, -76.312308 44.196962, -75.912491 44.366748, -75.764614 44.514625, -75.282643 44.848718, -74.828057 45.018503, -74.148916 44.991119, -73.343806 45.013027))"},
+             {"NC",
+              "POLYGON ((-80.978661 36.562108, -80.294043 36.545677, -79.510841 36.5402, -75.868676 36.551154, -75.75366 36.151337, -76.032984 36.189676, -76.071322 36.140383, -76.410893 36.080137, -76.460185 36.025367, -76.68474 36.008937, -76.673786 35.937736, -76.399939 35.987029, -76.3616 35.943213, -76.060368 35.992506, -75.961783 35.899398, -75.781044 35.937736, -75.715321 35.696751, -75.775568 35.581735, -75.89606 35.570781, -76.147999 35.324319, -76.482093 35.313365, -76.536862 35.14358, -76.394462 34.973795, -76.279446 34.940933, -76.493047 34.661609, -76.673786 34.694471, -76.991448 34.667086, -77.210526 34.60684, -77.555573 34.415147, -77.82942 34.163208, -77.971821 33.845545, -78.179944 33.916745, -78.541422 33.851022, -79.675149 34.80401, -80.797922 34.820441, -80.781491 34.935456, -80.934845 35.105241, -81.038907 35.044995, -81.044384 35.149057, -82.276696 35.198349, -82.550543 35.160011, -82.764143 35.066903, -83.109191 35.00118, -83.618546 34.984749, -84.319594 34.990226, -84.29221 35.225734, -84.09504 35.247642, -84.018363 35.41195, -83.7719 35.559827, -83.498053 35.565304, -83.251591 35.718659, -82.994175 35.773428, -82.775097 35.997983, -82.638174 36.063706, -82.610789 35.965121, -82.216449 36.156814, -82.03571 36.118475, -81.909741 36.304691, -81.723525 36.353984, -81.679709 36.589492, -80.978661 36.562108))"},
+             {"ND",
+              "POLYGON ((-97.228743 49.000239, -97.097296 48.682577, -97.16302 48.545653, -97.130158 48.140359, -97.053481 47.948667, -96.856311 47.609096, -96.823449 46.968294, -96.785111 46.924479, -96.801542 46.656109, -96.719387 46.437031, -96.598895 46.332969, -96.560556 45.933153, -104.047534 45.944106, -104.042057 47.861036, -104.047534 49.000239, -97.228743 49.000239))"},
+             {"OH",
+              "POLYGON ((-80.518598 41.978802, -80.518598 40.636951, -80.666475 40.582182, -80.595275 40.472643, -80.600752 40.319289, -80.737675 40.078303, -80.830783 39.711348, -81.219646 39.388209, -81.345616 39.344393, -81.455155 39.410117, -81.57017 39.267716, -81.685186 39.273193, -81.811156 39.0815, -81.783771 38.966484, -81.887833 38.873376, -82.03571 39.026731, -82.221926 38.785745, -82.172634 38.632391, -82.293127 38.577622, -82.331465 38.446175, -82.594358 38.424267, -82.731282 38.561191, -82.846298 38.588575, -82.890113 38.758361, -83.032514 38.725499, -83.142052 38.626914, -83.519961 38.703591, -83.678792 38.632391, -83.903347 38.769315, -84.215533 38.807653, -84.231963 38.895284, -84.43461 39.103408, -84.817996 39.103408, -84.801565 40.500028, -84.807042 41.694001, -83.454238 41.732339, -83.065375 41.595416, -82.933929 41.513262, -82.835344 41.589939, -82.616266 41.431108, -82.479343 41.381815, -82.013803 41.513262, -81.739956 41.485877, -81.444201 41.672093, -81.011523 41.852832, -80.518598 41.978802))"},
+             {"OK",
+              "POLYGON ((-100.087706 37.000263, -94.616242 37.000263, -94.616242 36.501861, -94.430026 35.395519, -94.484796 33.637421, -94.868182 33.74696, -94.966767 33.861976, -95.224183 33.960561, -95.289906 33.87293, -95.547322 33.878407, -95.602092 33.933176, -95.8376 33.834591, -95.936185 33.889361, -96.149786 33.840068, -96.346956 33.686714, -96.423633 33.774345, -96.631756 33.845545, -96.850834 33.845545, -96.922034 33.960561, -97.173974 33.736006, -97.256128 33.861976, -97.371143 33.823637, -97.458774 33.905791, -97.694283 33.982469, -97.869545 33.851022, -97.946222 33.987946, -98.088623 34.004376, -98.170777 34.113915, -98.36247 34.157731, -98.488439 34.064623, -98.570593 34.146777, -98.767763 34.135823, -98.986841 34.223454, -99.189488 34.2125, -99.260688 34.404193, -99.57835 34.415147, -99.698843 34.382285, -99.923398 34.573978, -100.000075 34.563024, -100.000075 36.501861, -101.812942 36.501861, -103.001438 36.501861, -103.001438 37.000263, -102.042974 36.994786, -100.087706 37.000263))"},
+             {"OR",
+              "POLYGON ((-123.211348 46.174138, -123.11824 46.185092, -122.904639 46.08103, -122.811531 45.960537, -122.762239 45.659305, -122.247407 45.549767, -121.809251 45.708598, -121.535404 45.725029, -121.217742 45.670259, -121.18488 45.604536, -120.637186 45.746937, -120.505739 45.697644, -120.209985 45.725029, -119.963522 45.823614, -119.525367 45.911245, -119.125551 45.933153, -118.988627 45.998876, -116.918344 45.993399, -116.78142 45.823614, -116.545912 45.752413, -116.463758 45.61549, -116.671881 45.319735, -116.732128 45.144473, -116.847143 45.02398, -116.830713 44.930872, -116.934774 44.782995, -117.038836 44.750133, -117.241483 44.394132, -117.170283 44.257209, -116.97859 44.240778, -116.896436 44.158624, -117.027882 43.830007, -117.027882 42.000709, -118.698349 41.989755, -120.001861 41.995232, -121.037003 41.995232, -122.378853 42.011663, -123.233256 42.006186, -124.213628 42.000709, -124.356029 42.115725, -124.432706 42.438865, -124.416275 42.663419, -124.553198 42.838681, -124.454613 43.002989, -124.383413 43.271359, -124.235536 43.55616, -124.169813 43.8081, -124.060274 44.657025, -124.076705 44.772041, -123.97812 45.144473, -123.939781 45.659305, -123.994551 45.944106, -123.945258 46.113892, -123.545441 46.261769, -123.370179 46.146753, -123.211348 46.174138))"},
+             {"PA",
+              "POLYGON ((-79.76278 42.252649, -79.76278 42.000709, -75.35932 42.000709, -75.249781 41.863786, -75.173104 41.869263, -75.052611 41.754247, -75.074519 41.60637, -74.89378 41.436584, -74.740426 41.431108, -74.69661 41.359907, -74.828057 41.288707, -74.882826 41.179168, -75.134765 40.971045, -75.052611 40.866983, -75.205966 40.691721, -75.195012 40.576705, -75.069042 40.543843, -75.058088 40.417874, -74.773287 40.215227, -74.82258 40.127596, -75.129289 39.963288, -75.145719 39.88661, -75.414089 39.804456, -75.616736 39.831841, -75.786521 39.722302, -79.477979 39.722302, -80.518598 39.722302, -80.518598 40.636951, -80.518598 41.978802, -80.332382 42.033571, -79.76278 42.269079, -79.76278 42.252649))"},
+             {"RI",
+              "MULTIPOLYGON (((-71.196845 41.67757, -71.120168 41.496831, -71.317338 41.474923, -71.196845 41.67757)), ((-71.530939 42.01714, -71.383061 42.01714, -71.328292 41.781632, -71.22423 41.710431, -71.344723 41.726862, -71.448785 41.578985, -71.481646 41.370861, -71.859555 41.321569, -71.799309 41.414677, -71.799309 42.006186, -71.530939 42.01714)))"},
+             {"SC",
+              "POLYGON ((-82.764143 35.066903, -82.550543 35.160011, -82.276696 35.198349, -81.044384 35.149057, -81.038907 35.044995, -80.934845 35.105241, -80.781491 34.935456, -80.797922 34.820441, -79.675149 34.80401, -78.541422 33.851022, -78.716684 33.80173, -78.935762 33.637421, -79.149363 33.380005, -79.187701 33.171881, -79.357487 33.007573, -79.582041 33.007573, -79.631334 32.887081, -79.866842 32.755634, -79.998289 32.613234, -80.206412 32.552987, -80.430967 32.399633, -80.452875 32.328433, -80.660998 32.246279, -80.885553 32.032678, -81.115584 32.120309, -81.121061 32.290094, -81.279893 32.558464, -81.416816 32.629664, -81.42777 32.843265, -81.493493 33.007573, -81.761863 33.160928, -81.937125 33.347144, -81.926172 33.462159, -82.194542 33.631944, -82.325988 33.81816, -82.55602 33.94413, -82.714851 34.152254, -82.747713 34.26727, -82.901067 34.486347, -83.005129 34.469916, -83.339222 34.683517, -83.322791 34.787579, -83.109191 35.00118, -82.764143 35.066903))"},
+             {"SD",
+              "POLYGON ((-104.047534 45.944106, -96.560556 45.933153, -96.582464 45.818137, -96.856311 45.604536, -96.681049 45.412843, -96.451017 45.297827, -96.451017 43.501391, -96.582464 43.479483, -96.527695 43.397329, -96.560556 43.222067, -96.434587 43.123482, -96.511264 43.052282, -96.544125 42.855112, -96.631756 42.707235, -96.44554 42.488157, -96.626279 42.515542, -96.692003 42.657942, -97.217789 42.844158, -97.688806 42.844158, -97.831206 42.866066, -97.951699 42.767481, -98.466531 42.94822, -98.499393 42.997512, -101.626726 42.997512, -103.324578 43.002989, -104.053011 43.002989, -104.058488 44.996596, -104.042057 44.996596, -104.047534 45.944106))"},
+             {"TN",
+              "POLYGON ((-88.054868 36.496384, -88.071299 36.677123, -87.852221 36.633308, -86.592525 36.655216, -85.486183 36.616877, -85.289013 36.627831, -84.544149 36.594969, -83.689746 36.584015, -83.673316 36.600446, -81.679709 36.589492, -81.723525 36.353984, -81.909741 36.304691, -82.03571 36.118475, -82.216449 36.156814, -82.610789 35.965121, -82.638174 36.063706, -82.775097 35.997983, -82.994175 35.773428, -83.251591 35.718659, -83.498053 35.565304, -83.7719 35.559827, -84.018363 35.41195, -84.09504 35.247642, -84.29221 35.225734, -84.319594 34.990226, -85.606675 34.984749, -87.359296 35.00118, -88.202745 34.995703, -88.471115 34.995703, -90.311367 34.995703, -90.212782 35.023087, -90.114197 35.198349, -90.130628 35.439335, -89.944412 35.603643, -89.911551 35.756997, -89.763673 35.811767, -89.730812 35.997983, -89.533642 36.249922, -89.539119 36.496384, -89.484349 36.496384, -89.418626 36.496384, -89.298133 36.507338, -88.054868 36.496384))"},
+             {"TX",
+              "POLYGON ((-101.812942 36.501861, -100.000075 36.501861, -100.000075 34.563024, -99.923398 34.573978, -99.698843 34.382285, -99.57835 34.415147, -99.260688 34.404193, -99.189488 34.2125, -98.986841 34.223454, -98.767763 34.135823, -98.570593 34.146777, -98.488439 34.064623, -98.36247 34.157731, -98.170777 34.113915, -98.088623 34.004376, -97.946222 33.987946, -97.869545 33.851022, -97.694283 33.982469, -97.458774 33.905791, -97.371143 33.823637, -97.256128 33.861976, -97.173974 33.736006, -96.922034 33.960561, -96.850834 33.845545, -96.631756 33.845545, -96.423633 33.774345, -96.346956 33.686714, -96.149786 33.840068, -95.936185 33.889361, -95.8376 33.834591, -95.602092 33.933176, -95.547322 33.878407, -95.289906 33.87293, -95.224183 33.960561, -94.966767 33.861976, -94.868182 33.74696, -94.484796 33.637421, -94.380734 33.544313, -94.183564 33.593606, -94.041164 33.54979, -94.041164 33.018527, -94.041164 31.994339, -93.822086 31.775262, -93.816609 31.556184, -93.542762 31.15089, -93.526331 30.93729, -93.630393 30.679874, -93.728978 30.575812, -93.696116 30.438888, -93.767317 30.334826, -93.690639 30.143133, -93.926148 29.787132, -93.838517 29.688547, -94.002825 29.68307, -94.523134 29.546147, -94.70935 29.622824, -94.742212 29.787132, -94.873659 29.672117, -94.966767 29.699501, -95.016059 29.557101, -94.911997 29.496854, -94.895566 29.310638, -95.081782 29.113469, -95.383014 28.867006, -95.985477 28.604113, -96.045724 28.647929, -96.226463 28.582205, -96.23194 28.642452, -96.478402 28.598636, -96.593418 28.724606, -96.664618 28.697221, -96.401725 28.439805, -96.593418 28.357651, -96.774157 28.406943, -96.801542 28.226204, -97.026096 28.039988, -97.256128 27.694941, -97.404005 27.333463, -97.513544 27.360848, -97.540929 27.229401, -97.425913 27.262263, -97.480682 26.99937, -97.557359 26.988416, -97.562836 26.840538, -97.469728 26.758384, -97.442344 26.457153, -97.332805 26.353091, -97.30542 26.161398, -97.217789 25.991613, -97.524498 25.887551, -97.650467 26.018997, -97.885976 26.06829, -98.198161 26.057336, -98.466531 26.221644, -98.669178 26.238075, -98.822533 26.369522, -99.030656 26.413337, -99.173057 26.539307, -99.266165 26.840538, -99.446904 27.021277, -99.424996 27.174632, -99.50715 27.33894, -99.479765 27.48134, -99.605735 27.640172, -99.709797 27.656603, -99.879582 27.799003, -99.934351 27.979742, -100.082229 28.14405, -100.29583 28.280974, -100.399891 28.582205, -100.498476 28.66436, -100.629923 28.905345, -100.673738 29.102515, -100.799708 29.244915, -101.013309 29.370885, -101.062601 29.458516, -101.259771 29.535193, -101.413125 29.754271, -101.851281 29.803563, -102.114174 29.792609, -102.338728 29.869286, -102.388021 29.765225, -102.629006 29.732363, -102.809745 29.524239, -102.919284 29.190146, -102.97953 29.184669, -103.116454 28.987499, -103.280762 28.982022, -103.527224 29.135376, -104.146119 29.381839, -104.266611 29.513285, -104.507597 29.639255, -104.677382 29.924056, -104.688336 30.181472, -104.858121 30.389596, -104.896459 30.570335, -105.005998 30.685351, -105.394861 30.855136, -105.602985 31.085167, -105.77277 31.167321, -105.953509 31.364491, -106.205448 31.468553, -106.38071 31.731446, -106.528588 31.786216, -106.643603 31.901231, -106.616219 31.999816, -103.067161 31.999816, -103.067161 33.002096, -103.045254 34.01533, -103.039777 36.501861, -103.001438 36.501861, -101.812942 36.501861))"},
+             {"UT",
+              "POLYGON ((-112.164359 41.995232, -111.047063 42.000709, -111.047063 40.998429, -109.04798 40.998429, -109.053457 39.125316, -109.058934 38.27639, -109.042503 38.166851, -109.042503 37.000263, -110.499369 37.00574, -114.048427 37.000263, -114.04295 41.995232, -112.164359 41.995232))"},
+             {"VT",
+              "POLYGON ((-71.503554 45.013027, -71.4926 44.914442, -71.629524 44.750133, -71.536416 44.585825, -71.700724 44.41604, -72.034817 44.322932, -72.02934 44.07647, -72.116971 43.994316, -72.204602 43.769761, -72.379864 43.572591, -72.456542 43.150867, -72.445588 43.008466, -72.533219 42.953697, -72.544173 42.80582, -72.456542 42.729142, -73.267129 42.745573, -73.278083 42.833204, -73.245221 43.523299, -73.404052 43.687607, -73.349283 43.769761, -73.436914 44.043608, -73.321898 44.246255, -73.294514 44.437948, -73.387622 44.618687, -73.332852 44.804903, -73.343806 45.013027, -72.308664 45.002073, -71.503554 45.013027))"},
+             {"VA",
+              "POLYGON ((-83.6753 36.6017,-83.5613 36.6519,-83.4432 36.6673,-83.3080 36.7108,-83.1974 36.7389,-83.1363 36.7433,-83.1047 36.8032,-83.1033 36.8302,-83.0704 36.8544,-83.0127 36.8478,-82.8534 36.9839,-82.7971 37.0086,-82.7360 37.0442,-82.3494 37.2664,-82.3027 37.3046,-82.0136 37.5054,-81.9681 37.5380,-81.9259 37.5139,-81.9707 37.4889,-81.9800 37.4563,-81.9374 37.4389,-81.9319 37.3592,-81.8619 37.3134,-81.7987 37.2872,-81.7259 37.2424,-81.6792 37.2008,-81.5549 37.2083,-81.4988 37.2588,-81.4856 37.2456,-81.4367 37.2742,-81.3675 37.3243,-81.2741 37.2653,-81.1560 37.2719,-80.9802 37.3025,-80.8566 37.3396,-80.8786 37.3876,-80.8511 37.4247,-80.7715 37.3702,-80.5518 37.4749,-80.5133 37.4792,-80.4803 37.4247,-80.3018 37.5097,-80.2798 37.5359,-80.3293 37.5380,-80.2249 37.6316,-80.3018 37.6903,-80.2551 37.7251,-80.2551 37.7707,-80.1961 37.8347,-80.1508 37.8749,-79.9722 38.0394,-79.9448 38.1302,-79.9063 38.1972,-79.7882 38.2684,-79.8129 38.3093,-79.7662 38.3589,-79.7401 38.3513,-79.7333 38.3869,-79.6893 38.4321,-79.6948 38.4987,-79.6495 38.5857,-79.5328 38.5492,-79.4724 38.4557,-79.3103 38.4149,-79.2087 38.5138,-79.1016 38.6576,-79.0851 38.6941,-79.1016 38.7112,-79.0576 38.7712,-79.0604 38.7926,-79.0247 38.7926,-78.9944 38.8504,-78.8736 38.7637,-78.7830 38.8857,-78.7198 38.9327,-78.7129 38.9071,-78.6291 38.9850,-78.6044 38.9658,-78.5522 39.0170,-78.5770 39.0384,-78.5083 39.0938,-78.4314 39.1492,-78.4039 39.1684,-78.4314 39.1939,-78.3380 39.3470,-78.3380 39.3853,-78.3469 39.4659,-77.9744 39.2283,-77.8302 39.1338,-77.7355 39.3130,-77.7090 39.3213,-77.6218 39.3043,-77.5686 39.3067,-77.4567 39.2248,-77.5226 39.1543,-77.5243 39.1277,-77.4687 39.0914,-77.4485 39.0720,-77.3427 39.0634,-77.2936 39.0456,-77.2459 39.0168,-77.2445 38.9829,-77.1834 38.9680,-77.1120 38.9250,-77.0464 38.8798,-77.0444 38.7538,-77.0409 38.7142,-77.1312 38.6635,-77.1285 38.6319,-77.2456 38.5935,-77.3094 38.4547,-77.3046 38.3904,-77.2188 38.3500,-77.0622 38.4041,-77.0265 38.4256,-76.9826 38.3039,-76.8851 38.2155,-76.5926 38.1745,-76.2424 37.9496,-76.0501 37.9561,-75.9416 37.9474,-75.9512 37.9085,-75.8002 37.9139,-75.6931 37.9539,-75.6477 37.9474,-75.6258 37.9962,-75.4596 38.0091,-74.9707 38.0373,-75.5777 37.3625,-75.8180 36.8994,-75.8043 36.5516,-76.1476 36.5516,-76.8617 36.5516,-76.9180 36.5516,-76.9180 36.5438,-77.1803 36.5505,-77.5278 36.5449,-80.2730 36.5427,-80.5971 36.5571,-80.7248 36.5626,-80.8511 36.5593,-81.1066 36.5681,-81.4746 36.5813,-81.5007 36.5802,-81.6792 36.5902,-81.6476 36.6122,-81.9237 36.6177,-81.9360 36.5935,-82.3961 36.5957,-82.9344 36.5935,-83.2654 36.5957,-83.6746 36.6023,-83.6753 36.6017))"},
+             {"WA",
+              "MULTIPOLYGON (((-117.033359 49.000239, -117.044313 47.762451, -117.038836 46.426077, -117.055267 46.343923, -116.92382 46.168661, -116.918344 45.993399, -118.988627 45.998876, -119.125551 45.933153, -119.525367 45.911245, -119.963522 45.823614, -120.209985 45.725029, -120.505739 45.697644, -120.637186 45.746937, -121.18488 45.604536, -121.217742 45.670259, -121.535404 45.725029, -121.809251 45.708598, -122.247407 45.549767, -122.762239 45.659305, -122.811531 45.960537, -122.904639 46.08103, -123.11824 46.185092, -123.211348 46.174138, -123.370179 46.146753, -123.545441 46.261769, -123.72618 46.300108, -123.874058 46.239861, -124.065751 46.327492, -124.027412 46.464416, -123.895966 46.535616, -124.098612 46.74374, -124.235536 47.285957, -124.31769 47.357157, -124.427229 47.740543, -124.624399 47.88842, -124.706553 48.184175, -124.597014 48.381345, -124.394367 48.288237, -123.983597 48.162267, -123.704273 48.167744, -123.424949 48.118452, -123.162056 48.167744, -123.036086 48.080113, -122.800578 48.08559, -122.636269 47.866512, -122.515777 47.882943, -122.493869 47.587189, -122.422669 47.318818, -122.324084 47.346203, -122.422669 47.576235, -122.395284 47.800789, -122.230976 48.030821, -122.362422 48.123929, -122.373376 48.288237, -122.471961 48.468976, -122.422669 48.600422, -122.488392 48.753777, -122.647223 48.775685, -122.795101 48.8907, -122.756762 49.000239, -117.033359 49.000239)), ((-122.718423 48.310145, -122.586977 48.35396, -122.608885 48.151313, -122.767716 48.227991, -122.718423 48.310145)), ((-123.025132 48.583992, -122.915593 48.715438, -122.767716 48.556607, -122.811531 48.419683, -123.041563 48.458022, -123.025132 48.583992)))"},
+             {"WV",
+              "POLYGON ((-80.518598 40.636951, -80.518598 39.722302, -79.477979 39.722302, -79.488933 39.20747, -79.291763 39.300578, -79.094593 39.470363, -78.963147 39.437501, -78.765977 39.585379, -78.470222 39.514178, -78.431884 39.623717, -78.267575 39.61824, -78.174467 39.694917, -78.004682 39.601809, -77.834897 39.601809, -77.719881 39.322485, -77.82942 39.130793, -78.349729 39.464886, -78.404499 39.169131, -78.870039 38.763838, -78.996008 38.851469, -79.209609 38.495467, -79.313671 38.413313, -79.477979 38.457129, -79.647764 38.594052, -79.724442 38.364021, -79.921611 38.177805, -79.998289 37.997066, -80.184505 37.849189, -80.294043 37.690357, -80.29952 37.509618, -80.474782 37.421987, -80.513121 37.482234, -80.967707 37.290541, -81.225123 37.235771, -81.362047 37.339833, -81.55374 37.208387, -81.679709 37.20291, -81.849494 37.285064, -81.986418 37.454849, -81.969987 37.537003, -82.101434 37.553434, -82.293127 37.668449, -82.342419 37.783465, -82.50125 37.931343, -82.621743 38.123036, -82.594358 38.424267, -82.331465 38.446175, -82.293127 38.577622, -82.172634 38.632391, -82.221926 38.785745, -82.03571 39.026731, -81.887833 38.873376, -81.783771 38.966484, -81.811156 39.0815, -81.685186 39.273193, -81.57017 39.267716, -81.455155 39.410117, -81.345616 39.344393, -81.219646 39.388209, -80.830783 39.711348, -80.737675 40.078303, -80.600752 40.319289, -80.595275 40.472643, -80.666475 40.582182, -80.518598 40.636951))"},
+             {"WI",
+              "POLYGON ((-90.415429 46.568478, -90.229213 46.508231, -90.119674 46.338446, -89.09001 46.135799, -88.662808 45.987922, -88.531362 46.020784, -88.10416 45.922199, -87.989145 45.796229, -87.781021 45.675736, -87.791975 45.500474, -87.885083 45.363551, -87.649574 45.341643, -87.742682 45.199243, -87.589328 45.095181, -87.627666 44.974688, -87.819359 44.95278, -87.983668 44.722749, -88.043914 44.563917, -87.928898 44.536533, -87.775544 44.640595, -87.611236 44.837764, -87.403112 44.914442, -87.238804 45.166381, -87.03068 45.22115, -87.047111 45.089704, -87.189511 44.969211, -87.468835 44.552964, -87.545512 44.322932, -87.540035 44.158624, -87.644097 44.103854, -87.737205 43.8793, -87.704344 43.687607, -87.791975 43.561637, -87.912467 43.249452, -87.885083 43.002989, -87.76459 42.783912, -87.802929 42.493634, -88.788778 42.493634, -90.639984 42.510065, -90.711184 42.636034, -91.067185 42.75105, -91.143862 42.909881, -91.176724 43.134436, -91.056231 43.254929, -91.204109 43.353514, -91.215062 43.501391, -91.269832 43.616407, -91.242447 43.775238, -91.43414 43.994316, -91.592971 44.032654, -91.877772 44.202439, -91.927065 44.333886, -92.233773 44.443425, -92.337835 44.552964, -92.545959 44.569394, -92.808852 44.750133, -92.737652 45.117088, -92.75956 45.286874, -92.644544 45.440228, -92.770513 45.566198, -92.885529 45.577151, -92.869098 45.719552, -92.639067 45.933153, -92.354266 46.015307, -92.29402 46.075553, -92.29402 46.667063, -92.091373 46.749217, -92.014696 46.705401, -91.790141 46.694447, -91.09457 46.864232, -90.837154 46.95734, -90.749522 46.88614, -90.886446 46.754694, -90.55783 46.584908, -90.415429 46.568478))"},
+             {"WY",
+              "POLYGON ((-109.080842 45.002073, -105.91517 45.002073, -104.058488 44.996596, -104.053011 43.002989, -104.053011 41.003906, -105.728954 40.998429, -107.919731 41.003906, -109.04798 40.998429, -111.047063 40.998429, -111.047063 42.000709, -111.047063 44.476286, -111.05254 45.002073, -109.080842 45.002073))"}}};
+
+} // namespace facebook::velox::geometry_test_utils
diff --git a/velox/functions/prestosql/tests/utils/CMakeLists.txt b/velox/functions/prestosql/tests/utils/CMakeLists.txt
index 9fad6d743a6d..c9a16116f79e 100644
--- a/velox/functions/prestosql/tests/utils/CMakeLists.txt
+++ b/velox/functions/prestosql/tests/utils/CMakeLists.txt
@@ -19,4 +19,5 @@ target_link_libraries(
   velox_exec
   velox_exec_test_lib
   velox_vector_test_lib
-  velox_parse_parser)
+  velox_parse_parser
+)
diff --git a/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp b/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
index c55971bef9d3..d69109cc1c8d 100644
--- a/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
+++ b/velox/functions/prestosql/tests/utils/FunctionBaseTest.cpp
@@ -16,12 +16,16 @@
 #include "FunctionBaseTest.h"
 #include "velox/functions/FunctionRegistry.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
 #include "velox/parse/TypeResolver.h"
 
 namespace facebook::velox::functions::test {
 
 void FunctionBaseTest::SetUpTestCase() {
   parse::registerTypeResolver();
+  // TODO: remove the registration of KHyperLogLog here once it is registered
+  // through registerAllScalarFunctions().
+  registerKHyperLogLogType();
   functions::prestosql::registerAllScalarFunctions();
   memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
 }
diff --git a/velox/functions/prestosql/tests/utils/FunctionBaseTest.h b/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
index 4ff9dd37d965..86bb28e3be60 100644
--- a/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
+++ b/velox/functions/prestosql/tests/utils/FunctionBaseTest.h
@@ -19,8 +19,8 @@
 #include <utility>
 
 #include "velox/expression/Expr.h"
-#include "velox/parse/Expressions.h"
 #include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
 #include "velox/type/Type.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -61,6 +61,17 @@ class FunctionBaseTest : public testing::Test,
     });
   }
 
+  void setSessionStartTimeAndTimeZone(
+      const int64_t sessionStartTimeMs,
+      const std::string& timeZoneName) {
+    queryCtx_->testingOverrideConfigUnsafe({
+        {core::QueryConfig::kSessionStartTime,
+         std::to_string(sessionStartTimeMs)},
+        {core::QueryConfig::kSessionTimezone, timeZoneName},
+        {core::QueryConfig::kAdjustTimestampToTimezone, "true"},
+    });
+  }
+
  protected:
   static void SetUpTestCase();
 
@@ -244,9 +255,10 @@ class FunctionBaseTest : public testing::Test,
       std::optional<TArgs>... args) {
     return evaluateOnce<TReturn>(
         expr,
-        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
-            std::vector<TypePtr>{types},
-            std::forward<std::optional<TArgs>>(std::move(args))...)));
+        makeRowVector(
+            unpackEvaluateParams<std::optional<TArgs>...>(
+                std::vector<TypePtr>{types},
+                std::forward<std::optional<TArgs>>(std::move(args))...)));
   }
 
   template <typename TReturn, typename... TArgs>
@@ -255,8 +267,9 @@ class FunctionBaseTest : public testing::Test,
       std::optional<TArgs>... args) {
     return evaluateOnce<TReturn>(
         expr,
-        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
-            {}, std::forward<std::optional<TArgs>>(std::move(args))...)));
+        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
@@ -278,8 +291,10 @@ class FunctionBaseTest : public testing::Test,
       std::optional<TArgs>... args) {
     return evaluateOnce<TReturn>(
         expr,
-        makeRowVector(unpackEvaluateParams<std::optional<TArgs>...>(
-            {type}, std::forward<std::optional<TArgs>>(std::move(args))...)));
+        makeRowVector(
+            unpackEvaluateParams<std::optional<TArgs>...>(
+                {type},
+                std::forward<std::optional<TArgs>>(std::move(args))...)));
   }
 
   template <typename TReturn>
@@ -321,7 +336,7 @@ class FunctionBaseTest : public testing::Test,
     return std::make_unique<exec::ExprSet>(std::move(expressions), &execCtx_);
   }
 
-  VectorPtr evaluate(
+  virtual VectorPtr evaluate(
       exec::ExprSet& exprSet,
       const RowVectorPtr& input,
       const std::optional<SelectivityVector>& rows = std::nullopt) {
@@ -339,7 +354,7 @@ class FunctionBaseTest : public testing::Test,
 
   /// Parses a timestamp string into Timestamp.
   /// Accepts strings formatted as 'YYYY-MM-DD HH:mm:ss[.nnn]'.
-  static Timestamp parseTimestamp(const std::string& text) {
+  static Timestamp parseTimestamp(std::string_view text) {
     return util::fromTimestampString(
                text.data(), text.size(), util::TimestampParseMode::kPrestoCast)
         .thenOrThrow(folly::identity, [&](const Status& status) {
@@ -347,12 +362,28 @@ class FunctionBaseTest : public testing::Test,
         });
   }
 
+  // TODO: Remove explicit std::string_view cast.
+  static Timestamp parseTimestamp(StringView text) {
+    return parseTimestamp(std::string_view(text));
+  }
+  static Timestamp parseTimestamp(const char* text) {
+    return parseTimestamp(std::string_view(text));
+  }
+
   /// Parses a date string into days since epoch.
   /// Accepts strings formatted as 'YYYY-MM-DD'.
-  static int32_t parseDate(const std::string& text) {
+  static int32_t parseDate(std::string_view text) {
     return DATE()->toDays(text);
   }
 
+  // TODO: Remove explicit std::string_view cast.
+  static int32_t parseDate(StringView text) {
+    return parseDate(std::string_view(text));
+  }
+  static int32_t parseDate(const char* text) {
+    return parseDate(std::string_view(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
@@ -378,6 +409,21 @@ class FunctionBaseTest : public testing::Test,
   core::ExecCtx execCtx_{pool_.get(), queryCtx_.get()};
   parse::ParseOptions options_;
 
+  void testContextMessageOnThrow(
+      const std::string& expression,
+      const RowVectorPtr& data,
+      const std::string& expectedContextMessage) {
+    try {
+      evaluate(expression, data);
+      FAIL() << "Expected an exception";
+    } catch (const VeloxUserError& e) {
+      ASSERT_TRUE(e.context().find(expectedContextMessage) != std::string::npos)
+          << "Expected additional context in error message to contain '"
+          << expectedContextMessage << "', but received '" << e.context()
+          << "'.";
+    }
+  }
+
  private:
   template <typename T>
   std::shared_ptr<T> castEvaluateResult(
diff --git a/velox/functions/prestosql/types/BigintEnumRegistration.cpp b/velox/functions/prestosql/types/BigintEnumRegistration.cpp
new file mode 100644
index 000000000000..9cf151226312
--- /dev/null
+++ b/velox/functions/prestosql/types/BigintEnumRegistration.cpp
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/BigintEnumRegistration.h"
+#include "velox/expression/CastExpr.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
+
+namespace facebook::velox {
+namespace {
+class BigintEnumCastOperator : public exec::CastOperator {
+ public:
+  static const std::shared_ptr<const CastOperator>& get() {
+    static const std::shared_ptr<const CastOperator> kInstance =
+        std::make_shared<const BigintEnumCastOperator>();
+
+    return kInstance;
+  }
+
+  // Casting is supported from all integer types.
+  bool isSupportedFromType(const TypePtr& other) const override {
+    return BIGINT()->equivalent(*other) || TINYINT()->equivalent(*other) ||
+        SMALLINT()->equivalent(*other) || INTEGER()->equivalent(*other);
+  }
+
+  // Casting is only supported to BIGINT type.
+  bool isSupportedToType(const TypePtr& other) const override {
+    return BIGINT()->equivalent(*other);
+  }
+
+  void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    switch (input.typeKind()) {
+      case TypeKind::TINYINT:
+        castFromInteger<int8_t>(input, context, rows, resultType, result);
+        break;
+      case TypeKind::SMALLINT:
+        castFromInteger<int16_t>(input, context, rows, resultType, result);
+        break;
+      case TypeKind::INTEGER:
+        castFromInteger<int32_t>(input, context, rows, resultType, result);
+        break;
+      case TypeKind::BIGINT:
+        castFromInteger<int64_t>(input, context, rows, resultType, result);
+        break;
+      default:
+        VELOX_UNREACHABLE(
+            "Cannot cast {} to {} type",
+            input.type()->toString(),
+            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);
+    auto* flatResult = result->asChecked<FlatVector<int64_t>>();
+    flatResult->copy(&input, rows, nullptr);
+  }
+
+ private:
+  template <typename T>
+  void castFromInteger(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const {
+    context.ensureWritable(rows, resultType, result);
+    auto* flatResult = result->asChecked<FlatVector<int64_t>>();
+    flatResult->clearNulls(rows);
+
+    auto enumType = asBigintEnum(resultType);
+    const auto* intVector = input.as<SimpleVector<T>>();
+    rows.applyToSelected([&](vector_size_t row) {
+      const int64_t intToCast = intVector->valueAt(row);
+      if (!enumType->containsValue(intToCast)) {
+        context.setStatus(
+            row,
+            Status::UserError(
+                "No value '{}' in {}", intToCast, enumType->enumName()));
+        return;
+      }
+      flatResult->set(row, intToCast);
+    });
+  }
+};
+
+class BigintEnumTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK_EQ(
+        parameters.size(),
+        1,
+        "Expected exactly one type parameters for BigintEnumType");
+    VELOX_CHECK(
+        parameters[0].longEnumLiteral.has_value(),
+        "BigintEnumType parameter must be longEnumLiteral");
+    return BIGINT_ENUM(parameters[0].longEnumLiteral.value());
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return BigintEnumCastOperator::get();
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& /*config*/) const override {
+    return nullptr;
+  }
+};
+} // namespace
+
+void registerBigintEnumType() {
+  registerCustomType(
+      "bigint_enum", std::make_unique<const BigintEnumTypeFactory>());
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/BigintEnumRegistration.h b/velox/functions/prestosql/types/BigintEnumRegistration.h
new file mode 100644
index 000000000000..8680471210d7
--- /dev/null
+++ b/velox/functions/prestosql/types/BigintEnumRegistration.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
+
+namespace facebook::velox {
+
+void registerBigintEnumType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/BigintEnumType.cpp b/velox/functions/prestosql/types/BigintEnumType.cpp
new file mode 100644
index 000000000000..0958c7ac0caa
--- /dev/null
+++ b/velox/functions/prestosql/types/BigintEnumType.cpp
@@ -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 "velox/functions/prestosql/types/BigintEnumType.h"
+
+namespace facebook::velox {
+
+// Should only be called from get() to create a new instance.
+BigintEnumType::BigintEnumType(const LongEnumParameter& parameters)
+    : EnumTypeBase<int64_t, LongEnumParameter, BigintType>(parameters) {}
+
+std::string BigintEnumType::toString() const {
+  return fmt::format("{}:BigintEnum({})", name_, flippedMapToString());
+}
+
+BigintEnumTypePtr BigintEnumType::get(const LongEnumParameter& parameter) {
+  return getCached<BigintEnumType>(parameter);
+}
+
+folly::dynamic BigintEnumType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "Type";
+  obj["type"] = name();
+  // parameters_[0].longEnumLiteral is assumed to have a value since it is
+  // constructed from a LongEnumParameter.
+  obj["kLongEnumParam"] = parameters_[0].longEnumLiteral.value().serialize();
+  return obj;
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/BigintEnumType.h b/velox/functions/prestosql/types/BigintEnumType.h
new file mode 100644
index 000000000000..37c39a85097d
--- /dev/null
+++ b/velox/functions/prestosql/types/BigintEnumType.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/types/EnumTypeBase.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+class BigintEnumType;
+using BigintEnumTypePtr = std::shared_ptr<const BigintEnumType>;
+
+/// Represents an enumerated value where the physical type is a bigint. Each
+/// enum type has a name and a set of string keys which map to bigint values,
+/// passed in as a LongEnumParameter TypeParameterKind.
+class BigintEnumType
+    : public EnumTypeBase<int64_t, LongEnumParameter, BigintType> {
+ public:
+  static BigintEnumTypePtr get(const LongEnumParameter& parameter);
+
+  const char* name() const override {
+    return "BIGINT_ENUM";
+  }
+
+  std::string toString() const override;
+
+  folly::dynamic serialize() const override;
+
+ private:
+  explicit BigintEnumType(const LongEnumParameter& parameters);
+  friend class EnumTypeBase<int64_t, LongEnumParameter, BigintType>;
+};
+
+inline BigintEnumTypePtr BIGINT_ENUM(const LongEnumParameter& parameter) {
+  return BigintEnumType::get(parameter);
+}
+
+FOLLY_ALWAYS_INLINE bool isBigintEnumType(const Type& type) {
+  return type.kind() == TypeKind::BIGINT &&
+      dynamic_cast<const BigintEnumType*>(&type) != nullptr;
+}
+
+FOLLY_ALWAYS_INLINE BigintEnumTypePtr asBigintEnum(const TypePtr& type) {
+  return std::dynamic_pointer_cast<const BigintEnumType>(type);
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/BingTileRegistration.cpp b/velox/functions/prestosql/types/BingTileRegistration.cpp
index 723dff1c416e..e51999356338 100644
--- a/velox/functions/prestosql/types/BingTileRegistration.cpp
+++ b/velox/functions/prestosql/types/BingTileRegistration.cpp
@@ -24,13 +24,13 @@ namespace facebook::velox {
 
 namespace {
 
-class BingTileCastOperator : public exec::CastOperator {
- public:
-  static const std::shared_ptr<const CastOperator>& get() {
-    static const std::shared_ptr<const CastOperator> instance{
-        new BingTileCastOperator()};
+class BingTileCastOperator final : public exec::CastOperator {
+  BingTileCastOperator() = default;
 
-    return instance;
+ public:
+  static std::shared_ptr<const CastOperator> get() {
+    VELOX_CONSTEXPR_SINGLETON BingTileCastOperator kInstance;
+    return {std::shared_ptr<const CastOperator>{}, &kInstance};
   }
 
   bool isSupportedFromType(const TypePtr& other) const override {
@@ -113,12 +113,9 @@ class BingTileCastOperator : public exec::CastOperator {
           "Cast from BINGTILE to {} not yet supported", resultType->toString());
     }
   }
-
- private:
-  BingTileCastOperator() = default;
 };
 
-class BingTileTypeFactories : public CustomTypeFactories {
+class BingTileTypeFactory : public CustomTypeFactory {
  public:
   velox::TypePtr getType(
       const std::vector<velox::TypeParameter>& parameters) const override {
@@ -140,8 +137,7 @@ class BingTileTypeFactories : public CustomTypeFactories {
 } // namespace
 
 void registerBingTileType() {
-  registerCustomType(
-      "bingtile", std::make_unique<const BingTileTypeFactories>());
+  registerCustomType("bingtile", std::make_unique<const BingTileTypeFactory>());
 }
 
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/BingTileType.cpp b/velox/functions/prestosql/types/BingTileType.cpp
index bf54897ce850..f5b2a1756164 100644
--- a/velox/functions/prestosql/types/BingTileType.cpp
+++ b/velox/functions/prestosql/types/BingTileType.cpp
@@ -19,16 +19,18 @@
 #include <algorithm>
 #include <optional>
 #include <string>
+#include "velox/common/geospatial/GeometryConstants.h"
 
 namespace facebook::velox {
 
 namespace {
 folly::Expected<int64_t, std::string> mapSize(uint8_t zoomLevel) {
   if (FOLLY_UNLIKELY(zoomLevel > BingTileType::kBingTileMaxZoomLevel)) {
-    return folly::makeUnexpected(fmt::format(
-        "Zoom level {} is greater than max zoom {}",
-        zoomLevel,
-        BingTileType::kBingTileMaxZoomLevel));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Zoom level {} is greater than max zoom {}",
+            zoomLevel,
+            BingTileType::kBingTileMaxZoomLevel));
   }
   return 256L << zoomLevel;
 }
@@ -44,23 +46,24 @@ int32_t axisToCoordinates(double axis, long mapSize) {
 /**
  * Given longitude in degrees, and the level of detail, the tile X coordinate
  * can be calculated as follows: pixelX = ((longitude + 180) / 360) * 2**level
- * The latitude and longitude are assumed to be on the WGS 84 datum. Even though
- * Bing Maps uses a spherical projection, it’s important to convert all
- * geographic coordinates into a common datum, and WGS 84 was chosen to be that
- * datum. The longitude is assumed to range from -180 to +180 degrees. <p>
- * reference: https://msdn.microsoft.com/en-us/library/bb259689.aspx
+ * The latitude and longitude are assumed to be on the WGS 84 datum. Even
+ * though Bing Maps uses a spherical projection, it’s important to convert all
+ * geographic coordinates into a common datum, and WGS 84 was chosen to be
+ * that datum. The longitude is assumed to range from -180 to +180 degrees.
+ * <p> reference: https://msdn.microsoft.com/en-us/library/bb259689.aspx
  */
 folly::Expected<uint32_t, std::string> longitudeToTileX(
     double longitude,
     uint8_t zoomLevel) {
   if (FOLLY_UNLIKELY(
-          longitude > BingTileType::kMaxLongitude ||
-          longitude < BingTileType::kMinLongitude)) {
-    return folly::makeUnexpected(fmt::format(
-        "Longitude {} is outside of valid range [{}, {}]",
-        longitude,
-        BingTileType::kMinLongitude,
-        BingTileType::kMaxLongitude));
+          longitude > common::geospatial::kMaxLongitude ||
+          longitude < common::geospatial::kMinLongitude)) {
+    return folly::makeUnexpected(
+        fmt::format(
+            "Longitude {} is outside of valid range [{}, {}]",
+            longitude,
+            common::geospatial::kMinLongitude,
+            common::geospatial::kMaxLongitude));
   }
   double x = (longitude + 180) / 360;
 
@@ -73,13 +76,13 @@ folly::Expected<uint32_t, std::string> longitudeToTileX(
 }
 
 /**
- * Given latitude in degrees, and the level of detail, the tile Y coordinate can
- * be calculated as follows: sinLatitude = sin(latitude * pi/180) pixelY = (0.5
- * – log((1 + sinLatitude) / (1 – sinLatitude)) / (4 * pi)) * 2**level The
- * latitude and longitude are assumed to be on the WGS 84 datum. Even though
- * Bing Maps uses a spherical projection, it’s important to convert all
- * geographic coordinates into a common datum, and WGS 84 was chosen to be that
- * datum. The latitude must be clipped to range from -85.05112878
+ * Given latitude in degrees, and the level of detail, the tile Y coordinate
+ * can be calculated as follows: sinLatitude = sin(latitude * pi/180) pixelY =
+ * (0.5 – log((1 + sinLatitude) / (1 – sinLatitude)) / (4 * pi)) * 2**level
+ * The latitude and longitude are assumed to be on the WGS 84 datum. Even
+ * though Bing Maps uses a spherical projection, it’s important to convert all
+ * geographic coordinates into a common datum, and WGS 84 was chosen to be
+ * that datum. The latitude must be clipped to range from -85.05112878
  * to 85.05112878. This avoids a singularity at the poles, and it causes the
  * projected map to be square. <p> reference:
  * https://msdn.microsoft.com/en-us/library/bb259689.aspx
@@ -88,13 +91,14 @@ folly::Expected<uint32_t, std::string> latitudeToTileY(
     double latitude,
     uint8_t zoomLevel) {
   if (FOLLY_UNLIKELY(
-          latitude > BingTileType::kMaxLatitude ||
-          latitude < BingTileType::kMinLatitude)) {
-    return folly::makeUnexpected(fmt::format(
-        "Latitude {} is outside of valid range [{}, {}]",
-        latitude,
-        BingTileType::kMinLatitude,
-        BingTileType::kMaxLatitude));
+          latitude > common::geospatial::kMaxBingTileLatitude ||
+          latitude < common::geospatial::kMinBingTileLatitude)) {
+    return folly::makeUnexpected(
+        fmt::format(
+            "Latitude {} is outside of valid range [{}, {}]",
+            latitude,
+            common::geospatial::kMinBingTileLatitude,
+            common::geospatial::kMaxBingTileLatitude));
   }
   double sinLatitude = sin(latitude * M_PI / 180);
   double y = 0.5 - log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * M_PI);
@@ -130,14 +134,14 @@ double addDistanceToLongitude(
           sin(bearingInRadians) * sin(radiusRatio) * cos(latitudeInRadians),
           cos(radiusRatio) - sin(latitudeInRadians) * sin(latitudeInRadians)));
 
-  if (newLongitude > BingTileType::kMaxLongitude) {
-    return BingTileType::kMinLongitude +
-        (newLongitude - BingTileType::kMaxLongitude);
+  if (newLongitude > common::geospatial::kMaxLongitude) {
+    return common::geospatial::kMinLongitude +
+        (newLongitude - common::geospatial::kMaxLongitude);
   }
 
-  if (newLongitude < BingTileType::kMinLongitude) {
-    return BingTileType::kMaxLongitude +
-        (newLongitude - BingTileType::kMinLongitude);
+  if (newLongitude < common::geospatial::kMinLongitude) {
+    return common::geospatial::kMaxLongitude +
+        (newLongitude - common::geospatial::kMinLongitude);
   }
 
   return newLongitude;
@@ -152,33 +156,15 @@ addDistanceToLatitude(double latitude, double radiusInKm, double bearing) {
   double newLatitude = toDegrees(asin(
       sin(latitudeInRadians) * cos(radiusRatio) +
       cos(latitudeInRadians) * sin(radiusRatio) * cos(bearingInRadians)));
-  if (newLatitude > BingTileType::kMaxLatitude) {
-    return BingTileType::kMaxLatitude;
+  if (newLatitude > common::geospatial::kMaxBingTileLatitude) {
+    return common::geospatial::kMaxBingTileLatitude;
   }
-  if (newLatitude < BingTileType::kMinLatitude) {
-    return BingTileType::kMinLatitude;
+  if (newLatitude < common::geospatial::kMinBingTileLatitude) {
+    return common::geospatial::kMinBingTileLatitude;
   }
   return newLatitude;
 }
 
-/**
- * Return the longitude (in degrees) of the west edge of the tile.
- */
-double tileXToLongitude(uint32_t tileX, uint8_t zoomLevel) {
-  int32_t mapTileSize = 1 << zoomLevel;
-  double x = (std::clamp<double>(tileX, 0, mapTileSize) / mapTileSize) - 0.5;
-  return 360 * x;
-}
-
-/**
- * Return the latitude (in degrees) of the north edge of the tile.
- */
-double tileYToLatitude(uint32_t tileY, uint8_t zoomLevel) {
-  int32_t mapTileSize = 1 << zoomLevel;
-  double y = 0.5 - (std::clamp<double>(tileY, 0, mapTileSize) / mapTileSize);
-  return 90 - 360 * atan(exp(-y * 2 * M_PI)) / M_PI;
-}
-
 struct GreatCircleDistanceToPoint {
  public:
   GreatCircleDistanceToPoint(double latitude, double longitude) {
@@ -263,15 +249,19 @@ folly::Expected<uint64_t, std::string> BingTileType::bingTileParent(
   uint32_t y = bingTileY(tile);
 
   if (FOLLY_UNLIKELY(tileZoom < parentZoom)) {
-    return folly::makeUnexpected(fmt::format(
-        "Parent zoom {} must be <= tile zoom {}", parentZoom, tileZoom));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Parent zoom {} must be <= tile zoom {}", parentZoom, tileZoom));
   }
   uint8_t shift = tileZoom - parentZoom;
   return bingTileCoordsToInt((x >> shift), (y >> shift), parentZoom);
 }
 
 folly::Expected<std::vector<uint64_t>, std::string>
-BingTileType::bingTileChildren(uint64_t tile, uint8_t childZoom) {
+BingTileType::bingTileChildren(
+    uint64_t tile,
+    uint8_t childZoom,
+    uint8_t maxZoomShift) {
   uint8_t tileZoom = bingTileZoom(tile);
   if (FOLLY_UNLIKELY(tileZoom == childZoom)) {
     return std::vector<uint64_t>{tile};
@@ -280,17 +270,27 @@ BingTileType::bingTileChildren(uint64_t tile, uint8_t childZoom) {
   uint32_t y = bingTileY(tile);
 
   if (FOLLY_UNLIKELY(childZoom < tileZoom)) {
-    return folly::makeUnexpected(fmt::format(
-        "Child zoom {} must be >= tile zoom {}", childZoom, tileZoom));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Child zoom {} must be >= tile zoom {}", childZoom, tileZoom));
   }
   if (FOLLY_UNLIKELY(childZoom > kBingTileMaxZoomLevel)) {
-    return folly::makeUnexpected(fmt::format(
-        "Child zoom {} must be <= max zoom {}",
-        childZoom,
-        kBingTileMaxZoomLevel));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Child zoom {} must be <= max zoom {}",
+            childZoom,
+            kBingTileMaxZoomLevel));
   }
 
   uint8_t shift = childZoom - tileZoom;
+  if (shift > maxZoomShift) {
+    return folly::makeUnexpected(
+        fmt::format(
+            "Difference between parent zoom ({}) and child zoom ({}) must be <= {}",
+            tileZoom,
+            childZoom,
+            maxZoomShift));
+  }
   uint32_t xBase = (x << shift);
   uint32_t yBase = (y << shift);
   uint32_t numChildrenPerOrdinate = 1 << shift;
@@ -309,10 +309,11 @@ folly::Expected<uint64_t, std::string> BingTileType::bingTileFromQuadKey(
     const std::string_view& quadKey) {
   size_t zoomLevelInt32 = quadKey.size();
   if (FOLLY_UNLIKELY(zoomLevelInt32 > kBingTileMaxZoomLevel)) {
-    return folly::makeUnexpected(fmt::format(
-        "Zoom level {} is greater than max zoom {}",
-        zoomLevelInt32,
-        kBingTileMaxZoomLevel));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Zoom level {} is greater than max zoom {}",
+            zoomLevelInt32,
+            kBingTileMaxZoomLevel));
   }
   uint8_t zoomLevel = static_cast<uint8_t>(zoomLevelInt32);
   uint32_t tileX = 0;
@@ -387,6 +388,18 @@ folly::Expected<uint64_t, std::string> BingTileType::latitudeLongitudeToTile(
   return bingTileCoordsToInt(tileX.value(), tileY.value(), zoomLevel);
 }
 
+double BingTileType::tileXToLongitude(uint32_t tileX, uint8_t zoomLevel) {
+  int32_t mapTileSize = 1 << zoomLevel;
+  double x = (std::clamp<double>(tileX, 0, mapTileSize) / mapTileSize) - 0.5;
+  return 360 * x;
+}
+
+double BingTileType::tileYToLatitude(uint32_t tileY, uint8_t zoomLevel) {
+  int32_t mapTileSize = 1 << zoomLevel;
+  double y = 0.5 - (std::clamp<double>(tileY, 0, mapTileSize) / mapTileSize);
+  return 90 - 360 * atan(exp(-y * 2 * M_PI)) / M_PI;
+}
+
 // Given a (longitude, latitude) point, returns the surrounding Bing tiles at
 // the specified zoom level
 folly::Expected<std::vector<uint64_t>, std::string>
@@ -407,14 +420,14 @@ BingTileType::bingTilesAround(
     return folly::makeUnexpected(mpSize.error());
   }
 
-  int64_t mapTileIndex = (mpSize.value() / kTilePixels) - 1;
+  int64_t maxTileIndex = (mpSize.value() / kTilePixels) - 1;
   std::vector<uint64_t> tiles;
   tiles.reserve(9);
   for (int32_t i = -1; i <= 1; ++i) {
     for (int32_t j = -1; j <= 1; ++j) {
       int32_t x = static_cast<int32_t>(tileX.value()) + i;
       int32_t y = static_cast<int32_t>(tileY.value()) + j;
-      if (x >= 0 && x <= mapTileIndex && y >= 0 && y <= mapTileIndex) {
+      if (x >= 0 && x <= maxTileIndex && y >= 0 && y <= maxTileIndex) {
         tiles.push_back(bingTileCoordsToInt(x, y, zoomLevel));
       }
     }
@@ -429,8 +442,9 @@ BingTileType::bingTilesAround(
     uint8_t zoomLevel,
     double radiusInKm) {
   if (FOLLY_UNLIKELY(radiusInKm < 0 || radiusInKm > 1000)) {
-    return folly::makeUnexpected(fmt::format(
-        "Radius in km must between 0 and 1000, got {}", radiusInKm));
+    return folly::makeUnexpected(
+        fmt::format(
+            "Radius in km must between 0 and 1000, got {}", radiusInKm));
   }
   auto tileX = longitudeToTileX(longitude, zoomLevel);
   if (FOLLY_UNLIKELY(tileX.hasError())) {
@@ -497,9 +511,10 @@ BingTileType::bingTilesAround(
 
   uint32_t totalTileCount = tileCountX * tileCountY;
   if (totalTileCount > 1000000) {
-    return folly::makeUnexpected(fmt::format(
-        "The number of tiles covering input rectangle exceeds the limit of 1M. Number of tiles: {}.",
-        totalTileCount));
+    return folly::makeUnexpected(
+        fmt::format(
+            "The number of tiles covering input rectangle exceeds the limit of 1M. Number of tiles: {}.",
+            totalTileCount));
   }
 
   std::vector<uint64_t> result;
@@ -601,4 +616,13 @@ BingTileType::bingTilesAround(
   return result;
 }
 
+double BingTileType::greatCircleDistance(
+    double latitude1,
+    double longitude1,
+    double latitude2,
+    double longitude2) {
+  return GreatCircleDistanceToPoint(latitude1, longitude1)
+      .distance(latitude2, longitude2);
+}
+
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/BingTileType.h b/velox/functions/prestosql/types/BingTileType.h
index 6074ea4ed565..8a3cb561d2c9 100644
--- a/velox/functions/prestosql/types/BingTileType.h
+++ b/velox/functions/prestosql/types/BingTileType.h
@@ -46,15 +46,13 @@ namespace facebook::velox {
 /// 41-63: y-coordinate (23 bits)
 /// (high bits first, low bits last). This peculiar arrangement maximizes
 /// low-bit entropy for the Java long hash function.
-class BingTileType : public BigintType {
-  BingTileType() : BigintType() {}
+class BingTileType final : public BigintType {
+  BingTileType() = default;
 
  public:
-  static const std::shared_ptr<const BingTileType>& get() {
-    static const std::shared_ptr<const BingTileType> instance =
-        std::shared_ptr<BingTileType>(new BingTileType());
-
-    return instance;
+  static std::shared_ptr<const BingTileType> get() {
+    VELOX_CONSTEXPR_SINGLETON BingTileType kInstance;
+    return {std::shared_ptr<const BingTileType>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -66,11 +64,6 @@ class BingTileType : public BigintType {
     return "BINGTILE";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
-  }
-
   std::string toString() const override {
     return name();
   }
@@ -82,6 +75,10 @@ class BingTileType : public BigintType {
     return obj;
   }
 
+  bool isOrderable() const override {
+    return false;
+  }
+
   static constexpr uint8_t kBingTileVersion = 0;
   static constexpr uint8_t kBingTileMaxZoomLevel = 23;
   static constexpr uint8_t kBingTileZoomBitWidth = 5;
@@ -89,10 +86,6 @@ class BingTileType : public BigintType {
   static constexpr uint8_t kBingTileZoomOffset = 31 - kBingTileZoomBitWidth;
   static constexpr uint64_t kBits23Mask = (1 << 24) - 1;
   static constexpr uint64_t kBits5Mask = (1 << 6) - 1;
-  static constexpr double kMaxLatitude = 85.05112878;
-  static constexpr double kMinLatitude = -85.05112878;
-  static constexpr double kMaxLongitude = 180.0;
-  static constexpr double kMinLongitude = -180.0;
   static constexpr uint16_t kTilePixels = 256;
   static constexpr double kEarthRadiusKm = 6371.01;
 
@@ -142,9 +135,8 @@ class BingTileType : public BigintType {
       uint64_t tile,
       uint8_t parentZoom);
 
-  static folly::Expected<std::vector<uint64_t>, std::string> bingTileChildren(
-      uint64_t tile,
-      uint8_t childZoom);
+  static folly::Expected<std::vector<uint64_t>, std::string>
+  bingTileChildren(uint64_t tile, uint8_t childZoom, uint8_t maxZoomShift);
 
   static folly::Expected<uint64_t, std::string> bingTileFromQuadKey(
       const std::string_view& quadKey);
@@ -154,6 +146,16 @@ class BingTileType : public BigintType {
   static folly::Expected<uint64_t, std::string>
   latitudeLongitudeToTile(double latitude, double longitude, uint8_t zoomLevel);
 
+  /**
+   * Return the longitude (in degrees) of the west edge of the tile.
+   */
+  static double tileXToLongitude(uint32_t tileX, uint8_t zoomLevel);
+
+  /**
+   * Return the latitude (in degrees) of the north edge of the tile.
+   */
+  static double tileYToLatitude(uint32_t tileY, uint8_t zoomLevel);
+
   static folly::Expected<std::vector<uint64_t>, std::string>
   bingTilesAround(double latitude, double longitude, uint8_t zoomLevel);
 
@@ -162,6 +164,15 @@ class BingTileType : public BigintType {
       double longitude,
       uint8_t zoomLevel,
       double radiusInKm);
+
+  // This isn't used in BingTiles, but since it relies on
+  // GreatCircleDistanceToPoint this is exposed here for use in Geometry
+  // functions.
+  static double greatCircleDistance(
+      double latitude1,
+      double longitude1,
+      double latitude2,
+      double longitude2);
 };
 
 inline bool isBingTileType(const TypePtr& type) {
diff --git a/velox/functions/prestosql/types/CMakeLists.txt b/velox/functions/prestosql/types/CMakeLists.txt
index 642a6ee5d006..abb1401b17fd 100644
--- a/velox/functions/prestosql/types/CMakeLists.txt
+++ b/velox/functions/prestosql/types/CMakeLists.txt
@@ -11,20 +11,39 @@
 # WITHOUT 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(parser)
 velox_add_library(
   velox_presto_types
+  BigintEnumRegistration.cpp
+  BigintEnumType.cpp
   BingTileRegistration.cpp
   BingTileType.cpp
-  GeometryRegistration.cpp
+  EnumTypeBase.cpp
   HyperLogLogRegistration.cpp
   IPAddressRegistration.cpp
   IPPrefixRegistration.cpp
   JsonCastOperator.cpp
   JsonRegistration.cpp
-  TDigestRegistration.cpp
+  KHyperLogLogRegistration.cpp
   QDigestRegistration.cpp
+  P4HyperLogLogRegistration.cpp
+  SfmSketchRegistration.cpp
+  TDigestRegistration.cpp
   TimestampWithTimeZoneRegistration.cpp
-  UuidRegistration.cpp)
+  TimeWithTimezoneRegistration.cpp
+  TimeWithTimezoneType.cpp
+  SetDigestRegistration.cpp
+  UuidRegistration.cpp
+  VarcharEnumRegistration.cpp
+  VarcharEnumType.cpp
+)
+if(VELOX_ENABLE_GEO)
+  velox_sources(
+    velox_presto_types
+    PRIVATE GeometryRegistration.cpp SphericalGeographyRegistration.cpp
+  )
+endif()
 
 velox_link_libraries(
   velox_presto_types
@@ -35,7 +54,9 @@ velox_link_libraries(
   velox_functions_json
   velox_functions_lib_date_time_formatter
   velox_constrained_input_generators
-  velox_presto_types_fuzzer_utils)
+  velox_presto_types_fuzzer_utils
+  velox_common_hyperloglog
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/prestosql/types/EnumTypeBase.cpp b/velox/functions/prestosql/types/EnumTypeBase.cpp
new file mode 100644
index 000000000000..0032feaeda1b
--- /dev/null
+++ b/velox/functions/prestosql/types/EnumTypeBase.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/functions/prestosql/types/EnumTypeBase.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
+
+namespace facebook::velox {
+namespace {
+// Flips the keys and values of the original map and validates that all values
+// are unique.
+template <typename TValue>
+static std::unordered_map<TValue, std::string> toFlippedMap(
+    const std::unordered_map<std::string, TValue>& map,
+    const std::string& name) {
+  std::unordered_map<TValue, std::string> flippedMap;
+  for (const auto& [key, value] : map) {
+    bool ok = flippedMap.emplace(value, key).second;
+    VELOX_USER_CHECK(
+        ok, "Invalid enum type {}, contains duplicate value {}", name, value);
+  }
+  return flippedMap;
+}
+} // namespace
+
+template <typename TValue, typename TParameter, typename TPhysical>
+EnumTypeBase<TValue, TParameter, TPhysical>::EnumTypeBase(
+    const TParameter& parameters)
+    : parameters_{TypeParameter(parameters)},
+      name_{parameters.name},
+      flippedMap_{toFlippedMap<TValue>(parameters.valuesMap, name_)} {}
+
+template <typename TValue, typename TParameter, typename TPhysical>
+std::string EnumTypeBase<TValue, TParameter, TPhysical>::flippedMapToString()
+    const {
+  std::ostringstream oss;
+  oss << "{";
+  std::map<std::string, TValue> sortedMap;
+  for (const auto& [key, value] : flippedMap_) {
+    sortedMap[value] = key;
+  }
+  for (auto it = sortedMap.begin(); it != sortedMap.end(); ++it) {
+    if (it != sortedMap.begin()) {
+      oss << ", ";
+    }
+    oss << "\"" << it->first << "\"" << ": ";
+    if constexpr (std::is_same_v<TValue, std::string>) {
+      oss << "\"" << it->second << "\"";
+    } else {
+      oss << it->second;
+    }
+  }
+  oss << "}";
+  return oss.str();
+}
+
+template <typename TValue, typename TParameter, typename TPhysical>
+template <typename EnumType>
+std::shared_ptr<const EnumType>
+EnumTypeBase<TValue, TParameter, TPhysical>::getCached(
+    const TParameter& parameter) {
+  static const int maxCacheSize = 1000;
+  static folly::Synchronized<Cache> kCache{Cache(maxCacheSize)};
+  return kCache.withWLock([&](auto& cache) -> std::shared_ptr<const EnumType> {
+    auto it = cache.find(parameter);
+    if (it != cache.end()) {
+      return std::static_pointer_cast<const EnumType>(it->second);
+    }
+    // Can't use std::make_shared because calling private ctor.
+    auto instance = std::shared_ptr<const EnumType>(new EnumType(parameter));
+    cache.insert(parameter, instance);
+    return instance;
+  });
+}
+
+template class EnumTypeBase<int64_t, LongEnumParameter, BigintType>;
+template class EnumTypeBase<std::string, VarcharEnumParameter, VarcharType>;
+
+template BigintEnumTypePtr
+EnumTypeBase<int64_t, LongEnumParameter, BigintType>::getCached<BigintEnumType>(
+    const LongEnumParameter&);
+template VarcharEnumTypePtr
+EnumTypeBase<std::string, VarcharEnumParameter, VarcharType>::getCached<
+    VarcharEnumType>(const VarcharEnumParameter&);
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/EnumTypeBase.h b/velox/functions/prestosql/types/EnumTypeBase.h
new file mode 100644
index 000000000000..964e62c380da
--- /dev/null
+++ b/velox/functions/prestosql/types/EnumTypeBase.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 <folly/Synchronized.h>
+#include <folly/container/EvictingCacheMap.h>
+
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+/// Template base class for enum types that provides common functionality
+/// for BigintEnumType and VarcharEnumType.
+/// @tparam TValue Type of enum value, either int64_t or std::string
+/// @tparam TParameter TypeParameter used to instantiate enum type, either
+/// LongEnumParameter or VarcharEnumParameter
+/// @tparam TPhysical Type extended by the enum type.
+template <typename TValue, typename TParameter, typename TPhysical>
+class EnumTypeBase : public TPhysical {
+ public:
+  using TReverseMap = std::unordered_map<TValue, std::string>;
+
+  /// Stores instances of enum types using the type parameters as keys.
+  using Cache = folly::EvictingCacheMap<
+      TParameter,
+      std::shared_ptr<const EnumTypeBase>,
+      typename TParameter::Hash>;
+
+  bool equivalent(const Type& other) const override {
+    return this == &other;
+  }
+
+  std::span<const TypeParameter> parameters() const override {
+    return parameters_;
+  }
+
+  bool containsValue(const TValue& value) const {
+    return flippedMap_.contains(value);
+  }
+
+  /// Returns the string key given a value. If the value does not exist
+  /// in the flippedMap_, return std::nullopt.
+  const std::optional<std::string> keyAt(const TValue& value) const {
+    auto it = flippedMap_.find(value);
+    if (it != flippedMap_.end()) {
+      return it->second;
+    }
+    return std::nullopt;
+  }
+
+  const std::string& enumName() const {
+    return name_;
+  }
+
+ protected:
+  explicit EnumTypeBase(const TParameter& parameters);
+
+  /// Converts the flipped map to a string representation for toString() method.
+  std::string flippedMapToString() const;
+
+  /// Returns cached instance of enum type or creates and returns a new enum
+  /// type if the type has not already been instantiated with the given
+  /// parameters.
+  template <typename EnumType>
+  static std::shared_ptr<const EnumType> getCached(const TParameter& parameter);
+
+  const std::vector<TypeParameter> parameters_;
+  const std::string name_;
+  const TReverseMap flippedMap_;
+};
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/GeometryRegistration.cpp b/velox/functions/prestosql/types/GeometryRegistration.cpp
index b9fe212ce42b..004f9c0f7e45 100644
--- a/velox/functions/prestosql/types/GeometryRegistration.cpp
+++ b/velox/functions/prestosql/types/GeometryRegistration.cpp
@@ -22,7 +22,7 @@
 namespace facebook::velox {
 
 namespace {
-class GeometryTypeFactories : public CustomTypeFactories {
+class GeometryTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -42,8 +42,7 @@ class GeometryTypeFactories : public CustomTypeFactories {
 
 void registerGeometryType() {
   // Register the geometry type with the type registry.
-  registerCustomType(
-      "geometry", std::make_unique<const GeometryTypeFactories>());
+  registerCustomType("geometry", std::make_unique<const GeometryTypeFactory>());
 }
 
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/GeometryType.h b/velox/functions/prestosql/types/GeometryType.h
index 1f55cda0eb06..5bbbbe34f219 100644
--- a/velox/functions/prestosql/types/GeometryType.h
+++ b/velox/functions/prestosql/types/GeometryType.h
@@ -16,20 +16,18 @@
 
 #pragma once
 
-#include "velox/expression/CastExpr.h"
 #include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
 
-class GeometryType : public VarbinaryType {
+class GeometryType final : public VarbinaryType {
   GeometryType() = default;
 
  public:
-  static const std::shared_ptr<const GeometryType>& get() {
-    static const std::shared_ptr<const GeometryType> instance{
-        new GeometryType()};
-    return instance;
+  static std::shared_ptr<const GeometryType> get() {
+    VELOX_CONSTEXPR_SINGLETON GeometryType kInstance;
+    return {std::shared_ptr<const GeometryType>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -51,6 +49,10 @@ class GeometryType : public VarbinaryType {
     obj["type"] = name();
     return obj;
   }
+
+  bool isOrderable() const override {
+    return false;
+  }
 };
 
 FOLLY_ALWAYS_INLINE bool isGeometryType(const TypePtr& type) {
diff --git a/velox/functions/prestosql/types/HyperLogLogRegistration.cpp b/velox/functions/prestosql/types/HyperLogLogRegistration.cpp
index 629b079133fb..5e5ebaad11c9 100644
--- a/velox/functions/prestosql/types/HyperLogLogRegistration.cpp
+++ b/velox/functions/prestosql/types/HyperLogLogRegistration.cpp
@@ -17,11 +17,12 @@
 #include "velox/functions/prestosql/types/HyperLogLogRegistration.h"
 
 #include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
 namespace {
-class HyperLogLogTypeFactories : public CustomTypeFactories {
+class HyperLogLogTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -34,13 +35,14 @@ class HyperLogLogTypeFactories : public CustomTypeFactories {
   }
 
   AbstractInputGeneratorPtr getInputGenerator(
-      const InputGeneratorConfig& /*config*/) const override {
-    return nullptr;
+      const InputGeneratorConfig& config) const override {
+    return std::make_shared<fuzzer::HyperLogLogInputGenerator>(
+        config.seed_, config.nullRatio_, config.pool_);
   }
 };
 } // namespace
 void registerHyperLogLogType() {
   registerCustomType(
-      "hyperloglog", std::make_unique<const HyperLogLogTypeFactories>());
+      "hyperloglog", std::make_unique<const HyperLogLogTypeFactory>());
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/HyperLogLogType.h b/velox/functions/prestosql/types/HyperLogLogType.h
index 30449303b1ee..8f9dd7c320cf 100644
--- a/velox/functions/prestosql/types/HyperLogLogType.h
+++ b/velox/functions/prestosql/types/HyperLogLogType.h
@@ -20,15 +20,13 @@
 
 namespace facebook::velox {
 
-class HyperLogLogType : public VarbinaryType {
+class HyperLogLogType final : public VarbinaryType {
   HyperLogLogType() = default;
 
  public:
-  static const std::shared_ptr<const HyperLogLogType>& get() {
-    static const std::shared_ptr<const HyperLogLogType> instance =
-        std::shared_ptr<HyperLogLogType>(new HyperLogLogType());
-
-    return instance;
+  static std::shared_ptr<const HyperLogLogType> get() {
+    VELOX_CONSTEXPR_SINGLETON HyperLogLogType kInstance;
+    return {std::shared_ptr<const HyperLogLogType>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -50,6 +48,10 @@ class HyperLogLogType : public VarbinaryType {
     obj["type"] = name();
     return obj;
   }
+
+  bool isOrderable() const override {
+    return false;
+  }
 };
 
 inline bool isHyperLogLogType(const TypePtr& type) {
diff --git a/velox/functions/prestosql/types/IPAddressRegistration.cpp b/velox/functions/prestosql/types/IPAddressRegistration.cpp
index 4d8290ca0d60..a3bb39c47012 100644
--- a/velox/functions/prestosql/types/IPAddressRegistration.cpp
+++ b/velox/functions/prestosql/types/IPAddressRegistration.cpp
@@ -16,6 +16,9 @@
 
 #include "velox/functions/prestosql/types/IPAddressRegistration.h"
 
+#include <limits>
+
+#include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include "velox/expression/CastExpr.h"
 #include "velox/functions/prestosql/types/IPAddressType.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
@@ -133,8 +136,9 @@ class IPAddressCastOperator : public exec::CastOperator {
 
     context.applyToSelectedNoThrow(rows, [&](auto row) {
       const auto ipAddressString = ipAddressStrings->valueAt(row);
-      auto maybeIpAsInt128 =
-          ipaddress::tryGetIPv6asInt128FromString(ipAddressString);
+      // TODO: Remove explicit std::string_view cast.
+      auto maybeIpAsInt128 = ipaddress::tryGetIPv6asInt128FromString(
+          std::string_view(ipAddressString));
 
       if (maybeIpAsInt128.hasError()) {
         if (threadSkipErrorDetails()) {
@@ -253,9 +257,9 @@ class IPAddressCastOperator : public exec::CastOperator {
   }
 };
 
-class IPAddressTypeFactories : public CustomTypeFactories {
+class IPAddressTypeFactory : public CustomTypeFactory {
  public:
-  IPAddressTypeFactories() = default;
+  IPAddressTypeFactory() = default;
 
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -267,14 +271,19 @@ class IPAddressTypeFactories : public CustomTypeFactories {
   }
 
   AbstractInputGeneratorPtr getInputGenerator(
-      const InputGeneratorConfig& /*config*/) const override {
-    return nullptr;
+      const InputGeneratorConfig& config) const override {
+    return std::make_shared<fuzzer::RangeConstrainedGenerator<int128_t>>(
+        config.seed_,
+        IPADDRESS(),
+        config.nullRatio_,
+        0,
+        std::numeric_limits<int128_t>::max());
   }
 };
 } // namespace
 
 void registerIPAddressType() {
   registerCustomType(
-      "ipaddress", std::make_unique<const IPAddressTypeFactories>());
+      "ipaddress", std::make_unique<const IPAddressTypeFactory>());
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/IPAddressType.h b/velox/functions/prestosql/types/IPAddressType.h
index 075565a6eb1f..e708a11d28e6 100644
--- a/velox/functions/prestosql/types/IPAddressType.h
+++ b/velox/functions/prestosql/types/IPAddressType.h
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #pragma once
 
 #include <folly/IPAddress.h>
@@ -21,8 +22,8 @@
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
-
 namespace ipaddress {
+
 constexpr int kIPV4AddressBytes = 4;
 constexpr int kIPV4ToV6FFIndex = 10;
 constexpr int kIPV4ToV6Index = 12;
@@ -31,6 +32,7 @@ constexpr int kIPAddressBytes = 16;
 inline folly::ByteArray16 toIPv6ByteArray(const int128_t& ipAddr) {
   folly::ByteArray16 bytes{{0}};
   memcpy(bytes.data(), &ipAddr, sizeof(ipAddr));
+
   // Reverse because the velox is always on little endian system
   // and the byte array needs to be big endian (network byte order)
   std::reverse(bytes.begin(), bytes.end());
@@ -38,7 +40,7 @@ inline folly::ByteArray16 toIPv6ByteArray(const int128_t& ipAddr) {
 }
 
 inline folly::Expected<int128_t, folly::IPAddressFormatError>
-tryGetIPv6asInt128FromString(const std::string& ipAddressStr) {
+tryGetIPv6asInt128FromString(const std::string_view& ipAddressStr) {
   auto maybeIp = folly::IPAddress::tryFromString(ipAddressStr);
   if (maybeIp.hasError()) {
     return folly::makeUnexpected(maybeIp.error());
@@ -51,25 +53,24 @@ tryGetIPv6asInt128FromString(const std::string& ipAddressStr) {
   memcpy(&intAddr, &addrBytes, kIPAddressBytes);
   return intAddr;
 }
+
 } // namespace ipaddress
 
-class IPAddressType : public HugeintType {
-  IPAddressType() : HugeintType(/*providesCustomComparison*/ true) {}
+class IPAddressType final : public HugeintType {
+  constexpr IPAddressType() : HugeintType{ProvideCustomComparison{}} {}
 
  public:
-  static const std::shared_ptr<const IPAddressType>& get() {
-    static const std::shared_ptr<const IPAddressType> instance{
-        new IPAddressType()};
-
-    return instance;
+  static std::shared_ptr<const IPAddressType> get() {
+    VELOX_CONSTEXPR_SINGLETON IPAddressType kInstance;
+    return {std::shared_ptr<const IPAddressType>{}, &kInstance};
   }
 
   int32_t compare(const int128_t& left, const int128_t& right) const override {
     const auto leftAddrBytes = ipaddress::toIPv6ByteArray(left);
     const auto rightAddrBytes = ipaddress::toIPv6ByteArray(right);
     return memcmp(
-        leftAddrBytes.begin(),
-        rightAddrBytes.begin(),
+        leftAddrBytes.data(),
+        rightAddrBytes.data(),
         ipaddress::kIPAddressBytes);
   }
 
diff --git a/velox/functions/prestosql/types/IPPrefixRegistration.cpp b/velox/functions/prestosql/types/IPPrefixRegistration.cpp
index 1dcab097fd69..0b2ca94f67ca 100644
--- a/velox/functions/prestosql/types/IPPrefixRegistration.cpp
+++ b/velox/functions/prestosql/types/IPPrefixRegistration.cpp
@@ -16,6 +16,9 @@
 
 #include "velox/functions/prestosql/types/IPPrefixRegistration.h"
 
+#include <limits>
+
+#include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include "velox/expression/CastExpr.h"
 #include "velox/functions/prestosql/types/IPPrefixType.h"
 
@@ -167,7 +170,10 @@ class IPPrefixCastOperator : public exec::CastOperator {
 
     context.applyToSelectedNoThrow(rows, [&](auto row) {
       auto ipAddressStringView = decoded.valueAt<StringView>(row);
-      auto tryIpPrefix = ipaddress::tryParseIpPrefixString(ipAddressStringView);
+
+      // TODO: Remove explicit std::string_view cast.
+      auto tryIpPrefix = ipaddress::tryParseIpPrefixString(
+          std::string_view(ipAddressStringView));
       if (tryIpPrefix.hasError()) {
         context.setStatus(row, std::move(tryIpPrefix.error()));
         return;
@@ -180,7 +186,7 @@ class IPPrefixCastOperator : public exec::CastOperator {
   }
 };
 
-class IPPrefixTypeFactories : public CustomTypeFactories {
+class IPPrefixTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -192,14 +198,19 @@ class IPPrefixTypeFactories : public CustomTypeFactories {
   }
 
   AbstractInputGeneratorPtr getInputGenerator(
-      const InputGeneratorConfig& /*config*/) const override {
-    return nullptr;
+      const InputGeneratorConfig& config) const override {
+    std::vector<std::unique_ptr<AbstractInputGenerator>> fields(2);
+    fields[0] = std::make_unique<fuzzer::RangeConstrainedGenerator<int128_t>>(
+        config.seed_, IPADDRESS(), 0, 0, std::numeric_limits<int128_t>::max());
+    fields[1] = std::make_unique<fuzzer::RangeConstrainedGenerator<int8_t>>(
+        config.seed_, TINYINT(), 0, 0, 127);
+    return std::make_shared<fuzzer::RandomInputGenerator<RowType>>(
+        config.seed_, IPPREFIX(), std::move(fields), config.nullRatio_);
   }
 };
 } // namespace
 
 void registerIPPrefixType() {
-  registerCustomType(
-      "ipprefix", std::make_unique<const IPPrefixTypeFactories>());
+  registerCustomType("ipprefix", std::make_unique<const IPPrefixTypeFactory>());
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/IPPrefixType.h b/velox/functions/prestosql/types/IPPrefixType.h
index 6c6ae7d81309..a4b061f84af1 100644
--- a/velox/functions/prestosql/types/IPPrefixType.h
+++ b/velox/functions/prestosql/types/IPPrefixType.h
@@ -23,8 +23,8 @@
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
-
 namespace ipaddress {
+
 constexpr uint8_t kIPV4Bits = 32;
 constexpr uint8_t kIPV6Bits = 128;
 constexpr int kIPPrefixLengthIndex = 16;
@@ -50,7 +50,7 @@ inline folly::Expected<int8_t, Status> tryIpPrefixLengthFromIPAddressType(
 }
 
 inline folly::Expected<std::pair<int128_t, int8_t>, Status>
-tryParseIpPrefixString(folly::StringPiece ipprefixString) {
+tryParseIpPrefixString(std::string_view ipprefixString) {
   // Ensure '/' is present
   if (ipprefixString.find('/') == std::string::npos) {
     return folly::makeUnexpected(
@@ -92,20 +92,19 @@ tryParseIpPrefixString(folly::StringPiece ipprefixString) {
   memcpy(&intAddr, &addrBytes, ipaddress::kIPAddressBytes);
   return std::make_pair(intAddr, prefix);
 }
+
 }; // namespace ipaddress
 
-class IPPrefixType : public RowType {
+class IPPrefixType final : public RowType {
   IPPrefixType()
       : RowType(
             {ipaddress::kIpRowIndex, ipaddress::kIpPrefixRowIndex},
             {IPADDRESS(), TINYINT()}) {}
 
  public:
-  static const std::shared_ptr<const IPPrefixType>& get() {
-    static const std::shared_ptr<const IPPrefixType> instance{
-        new IPPrefixType()};
-
-    return instance;
+  static std::shared_ptr<const IPPrefixType> get() {
+    static const IPPrefixType kInstance;
+    return {std::shared_ptr<const IPPrefixType>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -128,9 +127,8 @@ class IPPrefixType : public RowType {
     return obj;
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
+  std::span<const TypeParameter> parameters() const override {
+    return {};
   }
 };
 
diff --git a/velox/functions/prestosql/types/JsonCastOperator.cpp b/velox/functions/prestosql/types/JsonCastOperator.cpp
index cca43a29d00b..169f1ae316ae 100644
--- a/velox/functions/prestosql/types/JsonCastOperator.cpp
+++ b/velox/functions/prestosql/types/JsonCastOperator.cpp
@@ -50,9 +50,10 @@ void generateJsonTyped(
         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()));
+          result.append(
+              fmt::format(
+                  "\"{}\"",
+                  util::Converter<TypeKind::VARCHAR>::tryCast(value).value()));
         } else {
           result.append(
               util::Converter<TypeKind::VARCHAR>::tryCast(value).value());
diff --git a/velox/functions/prestosql/types/JsonRegistration.cpp b/velox/functions/prestosql/types/JsonRegistration.cpp
index c29c2a2210b6..4952aa0360ea 100644
--- a/velox/functions/prestosql/types/JsonRegistration.cpp
+++ b/velox/functions/prestosql/types/JsonRegistration.cpp
@@ -23,9 +23,9 @@
 
 namespace facebook::velox {
 namespace {
-class JsonTypeFactories : public CustomTypeFactories {
+class JsonTypeFactory : public CustomTypeFactory {
  public:
-  JsonTypeFactories() = default;
+  JsonTypeFactory() = default;
 
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -63,6 +63,6 @@ class JsonTypeFactories : public CustomTypeFactories {
 } // namespace
 
 void registerJsonType() {
-  registerCustomType("json", std::make_unique<const JsonTypeFactories>());
+  registerCustomType("json", std::make_unique<const JsonTypeFactory>());
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/JsonType.h b/velox/functions/prestosql/types/JsonType.h
index 45cd5e13f1c7..990a8e46831e 100644
--- a/velox/functions/prestosql/types/JsonType.h
+++ b/velox/functions/prestosql/types/JsonType.h
@@ -21,14 +21,13 @@
 namespace facebook::velox {
 
 /// Represents JSON as a string.
-class JsonType : public VarcharType {
+class JsonType final : public VarcharType {
   JsonType() = default;
 
  public:
-  static const std::shared_ptr<const JsonType>& get() {
-    static const std::shared_ptr<const JsonType> instance{new JsonType()};
-
-    return instance;
+  static std::shared_ptr<const JsonType> get() {
+    VELOX_CONSTEXPR_SINGLETON JsonType kInstance;
+    return {std::shared_ptr<const JsonType>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -50,6 +49,10 @@ class JsonType : public VarcharType {
     obj["type"] = name();
     return obj;
   }
+
+  bool isOrderable() const override {
+    return false;
+  }
 };
 
 FOLLY_ALWAYS_INLINE bool isJsonType(const TypePtr& type) {
diff --git a/velox/functions/prestosql/types/KHyperLogLogRegistration.cpp b/velox/functions/prestosql/types/KHyperLogLogRegistration.cpp
new file mode 100644
index 000000000000..ec726f8e2175
--- /dev/null
+++ b/velox/functions/prestosql/types/KHyperLogLogRegistration.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 "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+namespace {
+class KHyperLogLogTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return KHYPERLOGLOG();
+  }
+
+  // KHyperLogLog should be treated as Varbinary during type castings.
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& config) const override {
+    return std::static_pointer_cast<AbstractInputGenerator>(
+        std::make_shared<fuzzer::KHyperLogLogInputGenerator>(
+            config.seed_, config.nullRatio_, config.pool_));
+  }
+};
+} // namespace
+void registerKHyperLogLogType() {
+  registerCustomType(
+      "khyperloglog", std::make_unique<const KHyperLogLogTypeFactory>());
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/KHyperLogLogRegistration.h b/velox/functions/prestosql/types/KHyperLogLogRegistration.h
new file mode 100644
index 000000000000..b084ca2f5c3b
--- /dev/null
+++ b/velox/functions/prestosql/types/KHyperLogLogRegistration.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
+
+namespace facebook::velox {
+
+void registerKHyperLogLogType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/KHyperLogLogType.h b/velox/functions/prestosql/types/KHyperLogLogType.h
new file mode 100644
index 000000000000..0cd7fd10a091
--- /dev/null
+++ b/velox/functions/prestosql/types/KHyperLogLogType.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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 KHyperLogLogType final : public VarbinaryType {
+  KHyperLogLogType() = default;
+
+ public:
+  static std::shared_ptr<const KHyperLogLogType> get() {
+    VELOX_CONSTEXPR_SINGLETON KHyperLogLogType kInstance;
+    return {std::shared_ptr<const KHyperLogLogType>{}, &kInstance};
+  }
+
+  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 "KHYPERLOGLOG";
+  }
+
+  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;
+  }
+
+  bool isOrderable() const override {
+    return false;
+  }
+};
+
+inline bool isKHyperLogLogType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return KHyperLogLogType::get() == type;
+}
+
+inline std::shared_ptr<const KHyperLogLogType> KHYPERLOGLOG() {
+  return KHyperLogLogType::get();
+}
+
+// Type to use for inputs and outputs of simple functions, e.g.
+// arg_type<KHyperLogLog> and out_type<KHyperLogLog>.
+struct KHyperLogLogT {
+  using type = Varbinary;
+  static constexpr const char* typeName = "khyperloglog";
+};
+
+using KHyperLogLog = CustomType<KHyperLogLogT>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/P4HyperLogLogRegistration.cpp b/velox/functions/prestosql/types/P4HyperLogLogRegistration.cpp
new file mode 100644
index 000000000000..34212fcc1d57
--- /dev/null
+++ b/velox/functions/prestosql/types/P4HyperLogLogRegistration.cpp
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/P4HyperLogLogRegistration.h"
+
+#include "velox/common/hyperloglog/DenseHll.h"
+#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/expression/CastExpr.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/functions/prestosql/types/P4HyperLogLogType.h"
+#include "velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.h"
+
+namespace facebook::velox {
+namespace {
+
+class P4HyperLogLogCastOperator : public exec::CastOperator {
+ public:
+  bool isSupportedFromType(const TypePtr& other) const override {
+    return other->equivalent(*HYPERLOGLOG());
+  }
+
+  bool isSupportedToType(const TypePtr& other) const override {
+    return other->equivalent(*HYPERLOGLOG());
+  }
+
+  void castTo(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& /*resultType*/,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, P4HYPERLOGLOG(), result);
+
+    if (input.type()->equivalent(*HYPERLOGLOG())) {
+      // Cast from HYPERLOGLOG to P4HYPERLOGLOG - sparse to dense conversion
+      castFromHyperLogLog(input, context, rows, *result);
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from {} to P4HyperLogLog not supported",
+          input.type()->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->equivalent(*HYPERLOGLOG())) {
+      // Cast to HYPERLOGLOG - direct copy (already dense)
+      directCopy(input, context, rows, *result);
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from P4HyperLogLog to {} not supported",
+          resultType->toString());
+    }
+  }
+
+ private:
+  // Direct copy for P4HYPERLOGLOG to HYPERLOGLOG conversion.
+  // No conversion needed since P4HyperLogLog is already in dense format.
+  void directCopy(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) const {
+    auto* flatResult = result.as<FlatVector<StringView>>();
+    const auto* inputVector = input.as<SimpleVector<StringView>>();
+
+    flatResult->acquireSharedStringBuffers(&input);
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto data = inputVector->valueAt(row);
+      flatResult->setNoCopy(row, data);
+    });
+  }
+
+  // The meaningful conversion: HYPERLOGLOG to P4HYPERLOGLOG (sparse to dense)
+  static void castFromHyperLogLog(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      BaseVector& result) {
+    auto* flatResult = result.as<FlatVector<StringView>>();
+    const auto* hllInput = input.as<SimpleVector<StringView>>();
+
+    memory::MemoryPool* memoryPool = context.pool();
+    using SparseHll = common::hll::SparseHll<memory::MemoryPool>;
+    using DenseHll = common::hll::DenseHll<memory::MemoryPool>;
+    using common::hll::DenseHlls;
+    using common::hll::SparseHlls;
+
+    context.applyToSelectedNoThrow(rows, [&](auto row) {
+      const auto hllData = hllInput->valueAt(row);
+      exec::StringWriter writer(flatResult, row);
+
+      if (hllData.size() == 0 || hllData.data() == nullptr) {
+        writer.resize(0);
+        writer.finalize();
+        return;
+      }
+
+      if (SparseHlls::canDeserialize(hllData.data())) {
+        // Input is sparse - convert to dense
+        int8_t indexBitLength =
+            SparseHlls::deserializeIndexBitLength(hllData.data());
+
+        SparseHll sparseHll(hllData.data(), memoryPool);
+        DenseHll denseHll(indexBitLength, memoryPool);
+        sparseHll.toDense(denseHll);
+
+        int32_t serializedSize = denseHll.serializedSize();
+        writer.resize(serializedSize);
+        denseHll.serialize(writer.data());
+      } else if (DenseHlls::canDeserialize(hllData.data())) {
+        // Input is already dense - direct copy.
+        writer.copy_from(hllData);
+      } else {
+        VELOX_USER_FAIL("Invalid HyperLogLog format");
+      }
+
+      writer.finalize();
+    });
+  }
+};
+
+class P4HyperLogLogTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return P4HYPERLOGLOG();
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return std::make_shared<P4HyperLogLogCastOperator>();
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& config) const override {
+    return std::static_pointer_cast<AbstractInputGenerator>(
+        std::make_shared<fuzzer::P4HyperLogLogInputGenerator>(
+            config.seed_, config.nullRatio_, config.pool_));
+  }
+};
+} // namespace
+void registerP4HyperLogLogType() {
+  registerCustomType(
+      "p4hyperloglog", std::make_unique<const P4HyperLogLogTypeFactory>());
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/P4HyperLogLogRegistration.h b/velox/functions/prestosql/types/P4HyperLogLogRegistration.h
new file mode 100644
index 000000000000..e006365ed067
--- /dev/null
+++ b/velox/functions/prestosql/types/P4HyperLogLogRegistration.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
+
+namespace facebook::velox {
+
+void registerP4HyperLogLogType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/P4HyperLogLogType.h b/velox/functions/prestosql/types/P4HyperLogLogType.h
new file mode 100644
index 000000000000..9371b760135a
--- /dev/null
+++ b/velox/functions/prestosql/types/P4HyperLogLogType.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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 P4HyperLogLogType final : public VarbinaryType {
+  P4HyperLogLogType() = default;
+
+ public:
+  static std::shared_ptr<const P4HyperLogLogType> get() {
+    VELOX_CONSTEXPR_SINGLETON P4HyperLogLogType kInstance;
+    return {std::shared_ptr<const P4HyperLogLogType>{}, &kInstance};
+  }
+
+  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 "P4HYPERLOGLOG";
+  }
+
+  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;
+  }
+
+  bool isOrderable() const override {
+    return false;
+  }
+};
+
+inline bool isP4HyperLogLogType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return P4HyperLogLogType::get() == type;
+}
+
+inline std::shared_ptr<const P4HyperLogLogType> P4HYPERLOGLOG() {
+  return P4HyperLogLogType::get();
+}
+
+// Type to use for inputs and outputs of simple functions, e.g.
+// arg_type<P4HyperLogLog> and out_type<P4HyperLogLog>.
+struct P4HyperLogLogT {
+  using type = Varbinary;
+  static constexpr const char* typeName = "p4hyperloglog";
+};
+
+using P4HyperLogLog = CustomType<P4HyperLogLogT>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/QDigestRegistration.cpp b/velox/functions/prestosql/types/QDigestRegistration.cpp
index 371f7a6b18d6..af7f0ae5cec9 100644
--- a/velox/functions/prestosql/types/QDigestRegistration.cpp
+++ b/velox/functions/prestosql/types/QDigestRegistration.cpp
@@ -16,11 +16,12 @@
 
 #include "velox/functions/prestosql/types/QDigestRegistration.h"
 
+#include "velox/common/fuzzer/ConstrainedGenerators.h"
 #include "velox/functions/prestosql/types/QDigestType.h"
 
 namespace facebook::velox {
 namespace {
-class QDigestTypeFactories : public CustomTypeFactories {
+class QDigestTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK_EQ(parameters.size(), 1);
@@ -34,13 +35,31 @@ class QDigestTypeFactories : public CustomTypeFactories {
   }
 
   AbstractInputGeneratorPtr getInputGenerator(
-      const InputGeneratorConfig& /*config*/) const override {
-    return nullptr;
+      const InputGeneratorConfig& config) const override {
+    VELOX_USER_CHECK_NOT_NULL(config.type_, "QDigest Type must be provided");
+    auto parameters = config.type_->parameters();
+
+    VELOX_USER_CHECK(
+        parameters.size() == 1 &&
+            parameters[0].kind == TypeParameterKind::kType,
+        "QDigest must have exactly one parameter");
+
+    const auto paramType = parameters[0].type;
+    const auto kind = paramType->kind();
+    VELOX_USER_CHECK(
+        // QDigest supports three types: BIGINT, REAL, and DOUBLE
+        kind == TypeKind::BIGINT || kind == TypeKind::REAL ||
+            kind == TypeKind::DOUBLE,
+        "QDigest only supports BIGINT, REAL, and DOUBLE parameter types, got: {}",
+        paramType->toString());
+
+    return std::make_shared<fuzzer::QDigestInputGenerator>(
+        config.seed_, QDIGEST(paramType), config.nullRatio_, paramType);
   }
 };
 } // namespace
 
 void registerQDigestType() {
-  registerCustomType("qdigest", std::make_unique<const QDigestTypeFactories>());
+  registerCustomType("qdigest", std::make_unique<const QDigestTypeFactory>());
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/QDigestType.h b/velox/functions/prestosql/types/QDigestType.h
index 7c235b2eb677..e42adb08ab90 100644
--- a/velox/functions/prestosql/types/QDigestType.h
+++ b/velox/functions/prestosql/types/QDigestType.h
@@ -20,23 +20,18 @@
 
 namespace facebook::velox {
 
-class QDigestType : public VarbinaryType {
+class QDigestType final : public VarbinaryType {
  public:
-  static const std::shared_ptr<const QDigestType>& get(
-      const TypePtr& dataType) {
-    static const auto bigintInstance =
-        std::shared_ptr<const QDigestType>(new QDigestType(BIGINT()));
-    static const auto realInstance =
-        std::shared_ptr<const QDigestType>(new QDigestType(REAL()));
-    static const auto doubleInstance =
-        std::shared_ptr<const QDigestType>(new QDigestType(DOUBLE()));
-
+  static std::shared_ptr<const QDigestType> get(const TypePtr& dataType) {
     if (dataType->isBigint()) {
-      return bigintInstance;
+      static const QDigestType kInstance{BIGINT()};
+      return {std::shared_ptr<const QDigestType>{}, &kInstance};
     } else if (dataType->isReal()) {
-      return realInstance;
+      static const QDigestType kInstance{REAL()};
+      return {std::shared_ptr<const QDigestType>{}, &kInstance};
     } else if (dataType->isDouble()) {
-      return doubleInstance;
+      static const QDigestType kInstance{DOUBLE()};
+      return {std::shared_ptr<const QDigestType>{}, &kInstance};
     } else {
       VELOX_UNREACHABLE(
           "Only QDIGEST(BIGINT), QDIGEST(REAL), and QDIGEST(DOUBLE) are supported: QDIGEST({})",
@@ -53,12 +48,12 @@ class QDigestType : public VarbinaryType {
     return "QDIGEST";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    return parameters_;
+  std::span<const TypeParameter> parameters() const override {
+    return {&parameter_, 1};
   }
 
   std::string toString() const override {
-    return fmt::format("QDIGEST({})", parameters_[0].type->toString());
+    return fmt::format("QDIGEST({})", parameter_.type->toString());
   }
 
   folly::dynamic serialize() const override {
@@ -66,24 +61,30 @@ class QDigestType : public VarbinaryType {
     obj["name"] = "Type";
     obj["type"] = name();
     folly::dynamic children = folly::dynamic::array;
-    for (auto& param : parameters_) {
-      children.push_back(param.type->serialize());
-    }
+    children.push_back(parameter_.type->serialize());
     obj["cTypes"] = children;
     return obj;
   }
 
+  bool isOrderable() const override {
+    return false;
+  }
+
  private:
-  explicit QDigestType(const TypePtr& dataType)
-      : parameters_({TypeParameter(dataType)}) {}
+  explicit QDigestType(const TypePtr& dataType) : parameter_(dataType) {}
 
-  const std::vector<TypeParameter> parameters_;
+  const TypeParameter parameter_;
 };
 
 inline std::shared_ptr<const QDigestType> QDIGEST(const TypePtr& dataType) {
   return QDigestType::get(dataType);
 }
 
+inline bool isQDigestType(const TypePtr& type) {
+  return QDigestType::get(DOUBLE()) == type ||
+      QDigestType::get(REAL()) == type || QDigestType::get(BIGINT()) == type;
+}
+
 // Type to use for inputs and outputs of simple functions, e.g.
 // arg_type<QDigest> and out_type<QDigest>.
 template <typename T>
diff --git a/velox/functions/prestosql/types/SetDigestRegistration.cpp b/velox/functions/prestosql/types/SetDigestRegistration.cpp
new file mode 100644
index 000000000000..8bdf8749ddb0
--- /dev/null
+++ b/velox/functions/prestosql/types/SetDigestRegistration.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/prestosql/types/SetDigestRegistration.h"
+
+#include "velox/common/fuzzer/ConstrainedGenerators.h"
+#include "velox/functions/prestosql/types/SetDigestType.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+namespace {
+class SetDigestTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return SETDIGEST();
+  }
+
+  // SetDigest should be treated as Varbinary during type castings.
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& config) const override {
+    return std::make_shared<fuzzer::SetDigestInputGenerator>(
+        config.seed_, SETDIGEST(), config.nullRatio_);
+  }
+};
+} // namespace
+void registerSetDigestType() {
+  registerCustomType(
+      "setdigest", std::make_unique<const SetDigestTypeFactory>());
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SetDigestRegistration.h b/velox/functions/prestosql/types/SetDigestRegistration.h
new file mode 100644
index 000000000000..fef3747a1d75
--- /dev/null
+++ b/velox/functions/prestosql/types/SetDigestRegistration.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
+
+namespace facebook::velox {
+
+void registerSetDigestType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SetDigestType.h b/velox/functions/prestosql/types/SetDigestType.h
new file mode 100644
index 000000000000..2dd2f3c19d4f
--- /dev/null
+++ b/velox/functions/prestosql/types/SetDigestType.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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 SetDigestType final : public VarbinaryType {
+  SetDigestType() = default;
+
+ public:
+  static std::shared_ptr<const SetDigestType> get() {
+    VELOX_CONSTEXPR_SINGLETON SetDigestType kInstance;
+    return {std::shared_ptr<const SetDigestType>{}, &kInstance};
+  }
+
+  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 "SETDIGEST";
+  }
+
+  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;
+  }
+
+  bool isOrderable() const override {
+    return false;
+  }
+};
+
+inline bool isSetDigestType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return SetDigestType::get() == type;
+}
+
+inline std::shared_ptr<const SetDigestType> SETDIGEST() {
+  return SetDigestType::get();
+}
+
+// Type to use for inputs and outputs of simple functions, e.g.
+// arg_type<SetDigest> and out_type<SetDigest>.
+struct SetDigestT {
+  using type = Varbinary;
+  static constexpr const char* typeName = "setdigest";
+};
+
+using SetDigest = CustomType<SetDigestT>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SfmSketchRegistration.cpp b/velox/functions/prestosql/types/SfmSketchRegistration.cpp
new file mode 100644
index 000000000000..8aa4a867a428
--- /dev/null
+++ b/velox/functions/prestosql/types/SfmSketchRegistration.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/prestosql/types/SfmSketchRegistration.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
+#include "velox/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+namespace {
+class SfmSketchTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return SFMSKETCH();
+  }
+
+  // SfmSketch supports casting and should be treated as Varbinary during type
+  // casting.
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& config) const override {
+    return std::make_shared<fuzzer::SfmSketchInputGenerator>(
+        config.seed_, config.nullRatio_, config.pool_);
+  }
+};
+} // namespace
+void registerSfmSketchType() {
+  registerCustomType(
+      "sfmsketch", std::make_unique<const SfmSketchTypeFactory>());
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SfmSketchRegistration.h b/velox/functions/prestosql/types/SfmSketchRegistration.h
new file mode 100644
index 000000000000..4fee0400dcaf
--- /dev/null
+++ b/velox/functions/prestosql/types/SfmSketchRegistration.h
@@ -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.
+ */
+#pragma once
+
+namespace facebook::velox {
+void registerSfmSketchType();
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SfmSketchType.h b/velox/functions/prestosql/types/SfmSketchType.h
new file mode 100644
index 000000000000..2473e7964bee
--- /dev/null
+++ b/velox/functions/prestosql/types/SfmSketchType.h
@@ -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.
+ */
+#pragma once
+
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+class SfmSketchType final : public VarbinaryType {
+  SfmSketchType() = default;
+
+ public:
+  static std::shared_ptr<const SfmSketchType> get() {
+    VELOX_CONSTEXPR_SINGLETON SfmSketchType kInstance;
+    return {std::shared_ptr<const SfmSketchType>{}, &kInstance};
+  }
+
+  bool equivalent(const Type& other) const override {
+    return this == &other;
+  }
+
+  const char* name() const override {
+    return "SFMSKETCH";
+  }
+
+  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 bool isSfmSketchType(const TypePtr& type) {
+  return SfmSketchType::get() == type;
+}
+
+inline std::shared_ptr<const SfmSketchType> SFMSKETCH() {
+  return SfmSketchType::get();
+}
+
+// Type used for function registration. e.g. noisy_approx_set_sfm()
+struct SfmSketchTypeT {
+  using type = Varbinary;
+  static constexpr const char* typeName = "sfmsketch";
+};
+
+using SfmSketch = CustomType<SfmSketchTypeT>;
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SphericalGeographyRegistration.cpp b/velox/functions/prestosql/types/SphericalGeographyRegistration.cpp
new file mode 100644
index 000000000000..cf5b02dac8e6
--- /dev/null
+++ b/velox/functions/prestosql/types/SphericalGeographyRegistration.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/functions/prestosql/types/SphericalGeographyRegistration.h"
+
+#include "velox/expression/CastExpr.h"
+#include "velox/functions/prestosql/types/SphericalGeographyType.h"
+
+namespace facebook::velox {
+
+namespace {
+class SphericalGeographyTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return SPHERICAL_GEOGRAPHY();
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& /*config*/) const override {
+    return nullptr;
+  }
+};
+} // namespace
+
+void registerSphericalGeographyType() {
+  // Register the spherical_geography type with the type registry.
+  registerCustomType(
+      "sphericalgeography",
+      std::make_unique<const SphericalGeographyTypeFactory>());
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SphericalGeographyRegistration.h b/velox/functions/prestosql/types/SphericalGeographyRegistration.h
new file mode 100644
index 000000000000..34ab464a2470
--- /dev/null
+++ b/velox/functions/prestosql/types/SphericalGeographyRegistration.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
+namespace facebook::velox {
+
+void registerSphericalGeographyType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/SphericalGeographyType.h b/velox/functions/prestosql/types/SphericalGeographyType.h
new file mode 100644
index 000000000000..85f13a750f31
--- /dev/null
+++ b/velox/functions/prestosql/types/SphericalGeographyType.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/expression/CastExpr.h"
+#include "velox/type/SimpleFunctionApi.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+class SphericalGeographyType final : public VarbinaryType {
+  SphericalGeographyType() = default;
+
+ public:
+  static std::shared_ptr<const SphericalGeographyType> get() {
+    VELOX_CONSTEXPR_SINGLETON SphericalGeographyType kInstance;
+    return {std::shared_ptr<const SphericalGeographyType>{}, &kInstance};
+  }
+
+  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 "SPHERICALGEOGRAPHY";
+  }
+
+  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;
+  }
+
+  bool isOrderable() const override {
+    return false;
+  }
+};
+
+FOLLY_ALWAYS_INLINE bool isSphericalGeographyType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return SphericalGeographyType::get() == type;
+}
+
+FOLLY_ALWAYS_INLINE std::shared_ptr<const SphericalGeographyType>
+SPHERICAL_GEOGRAPHY() {
+  return SphericalGeographyType::get();
+}
+
+// Type used for function registration.
+struct SphericalGeographyT {
+  using type = Varbinary;
+  static constexpr const char* typeName = "sphericalgeography";
+};
+
+using SphericalGeography = CustomType<SphericalGeographyT>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TDigestRegistration.cpp b/velox/functions/prestosql/types/TDigestRegistration.cpp
index fdcb99832bcb..a4d6b3a567e2 100644
--- a/velox/functions/prestosql/types/TDigestRegistration.cpp
+++ b/velox/functions/prestosql/types/TDigestRegistration.cpp
@@ -21,7 +21,7 @@
 
 namespace facebook::velox {
 namespace {
-class TDigestTypeFactories : public CustomTypeFactories {
+class TDigestTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK_EQ(parameters.size(), 1);
@@ -44,6 +44,6 @@ class TDigestTypeFactories : public CustomTypeFactories {
 } // namespace
 
 void registerTDigestType() {
-  registerCustomType("tdigest", std::make_unique<const TDigestTypeFactories>());
+  registerCustomType("tdigest", std::make_unique<const TDigestTypeFactory>());
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TDigestType.h b/velox/functions/prestosql/types/TDigestType.h
index c5516411ef31..a3e48e183f8a 100644
--- a/velox/functions/prestosql/types/TDigestType.h
+++ b/velox/functions/prestosql/types/TDigestType.h
@@ -20,16 +20,14 @@
 
 namespace facebook::velox {
 
-class TDigestType : public VarbinaryType {
+class TDigestType final : public VarbinaryType {
  public:
-  static const std::shared_ptr<const TDigestType>& get(
-      const TypePtr& dataType) {
+  static std::shared_ptr<const TDigestType> get(const TypePtr& dataType) {
     // Only TDIGEST(DOUBLE) exists in Presto so we use a singleton to improve
     // performance.
     VELOX_CHECK(dataType->isDouble());
-    static const auto instance =
-        std::shared_ptr<const TDigestType>(new TDigestType(DOUBLE()));
-    return instance;
+    static const TDigestType kInstance{DOUBLE()};
+    return {std::shared_ptr<const TDigestType>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -41,12 +39,12 @@ class TDigestType : public VarbinaryType {
     return "TDIGEST";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    return parameters_;
+  std::span<const TypeParameter> parameters() const override {
+    return {&parameter_, 1};
   }
 
   std::string toString() const override {
-    return fmt::format("TDIGEST({})", parameters_[0].type->toString());
+    return fmt::format("TDIGEST({})", parameter_.type->toString());
   }
 
   folly::dynamic serialize() const override {
@@ -54,20 +52,26 @@ class TDigestType : public VarbinaryType {
     obj["name"] = "Type";
     obj["type"] = name();
     folly::dynamic children = folly::dynamic::array;
-    for (auto& param : parameters_) {
-      children.push_back(param.type->serialize());
-    }
+    children.push_back(parameter_.type->serialize());
     obj["cTypes"] = children;
     return obj;
   }
 
+  bool isOrderable() const override {
+    return false;
+  }
+
  private:
-  explicit TDigestType(const TypePtr& dataType)
-      : parameters_({TypeParameter(dataType)}) {}
+  explicit TDigestType(const TypePtr& dataType) : parameter_(dataType) {}
 
-  const std::vector<TypeParameter> parameters_;
+  const TypeParameter parameter_;
 };
 
+inline bool isTDigestType(const TypePtr& type) {
+  // Pointer comparison works since this type is a singleton.
+  return TDigestType::get(DOUBLE()) == type;
+}
+
 inline std::shared_ptr<const TDigestType> TDIGEST(const TypePtr& dataType) {
   return TDigestType::get(dataType);
 }
diff --git a/velox/functions/prestosql/types/TimeWithTimezoneRegistration.cpp b/velox/functions/prestosql/types/TimeWithTimezoneRegistration.cpp
new file mode 100644
index 000000000000..811df757b47c
--- /dev/null
+++ b/velox/functions/prestosql/types/TimeWithTimezoneRegistration.cpp
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/TimeWithTimezoneRegistration.h"
+
+#include "velox/expression/CastExpr.h"
+#include "velox/external/tzdb/time_zone.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h"
+#include "velox/type/Time.h"
+#include "velox/type/Type.h"
+#include "velox/type/tz/TimeZoneMap.h"
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox {
+
+namespace {
+void castToTime(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    BaseVector& result) {
+  auto* flatResult = result.asFlatVector<int64_t>();
+
+  auto convertToLocalTime = [](int64_t timeWithTimezone) {
+    int64_t millisUtc = util::unpackMillisUtc(timeWithTimezone);
+    auto timezoneMinutes = util::unpackZoneOffset(timeWithTimezone);
+    int16_t offsetMinutes = util::decodeTimezoneOffset(timezoneMinutes);
+    return util::utcToLocalTime(millisUtc, offsetMinutes);
+  };
+
+  if (input.isConstantEncoding()) {
+    const auto timeWithTimezone =
+        input.as<ConstantVector<int64_t>>()->valueAt(0);
+    context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+      flatResult->set(row, convertToLocalTime(timeWithTimezone));
+    });
+    return;
+  }
+  const auto timeWithTimezones = input.as<FlatVector<int64_t>>();
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto timeWithTimezone = timeWithTimezones->valueAt(row);
+    flatResult->set(row, convertToLocalTime(timeWithTimezone));
+  });
+}
+
+void castToString(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    BaseVector& result) {
+  auto* flatResult = result.asFlatVector<StringView>();
+  DecodedVector decoded(input, rows);
+  Buffer* buffer = flatResult->getBufferWithSpace(
+      rows.countSelected() *
+          TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize,
+      true /*exactSize*/);
+  char* rawBuffer = buffer->asMutable<char>() + buffer->size();
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto timeWithTimezone = decoded.valueAt<int64_t>(row);
+    auto output =
+        TIME_WITH_TIME_ZONE()->valueToString(timeWithTimezone, rawBuffer);
+    flatResult->setNoCopy(row, output);
+    rawBuffer += output.size();
+  });
+  buffer->setSize(rawBuffer - buffer->asMutable<char>());
+}
+
+void castFromString(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    BaseVector& result) {
+  auto* flatResult = result.asFlatVector<int64_t>();
+  DecodedVector decoded(input, rows);
+
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto stringValue = decoded.valueAt<StringView>(row);
+
+    auto parseResult = util::fromTimeWithTimezoneString(stringValue);
+    if (parseResult.hasError()) {
+      context.setStatus(row, parseResult.error());
+      return;
+    }
+
+    flatResult->set(row, parseResult.value());
+  });
+}
+
+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
+}
+
+// Calculate timezone offset in minutes at the given timestamp.
+// Since TIME has no date component, we use session start time to determine
+// which DST offset to apply.
+inline int16_t getTimezoneOffsetMinutes(
+    const tz::TimeZone* sessionTimeZone,
+    int64_t sessionStartTimeMs) {
+  if (auto offset = sessionTimeZone->offset()) {
+    return static_cast<int16_t>(offset->count());
+  }
+  auto sysTime = std::chrono::time_point<std::chrono::system_clock>(
+      std::chrono::milliseconds(sessionStartTimeMs));
+  auto info = sessionTimeZone->tz()->get_info(sysTime);
+  auto offsetMinutes =
+      std::chrono::duration_cast<std::chrono::minutes>(info.offset);
+  return static_cast<int16_t>(offsetMinutes.count());
+}
+
+// Pack time (in milliseconds since midnight) and timezone offset minutes
+inline int64_t packTimeWithTimeZone(
+    int64_t timeMillis,
+    int16_t timezoneOffsetMinutes) {
+  auto encodedOffset = util::biasEncode(timezoneOffsetMinutes);
+  return util::pack(timeMillis, encodedOffset);
+}
+
+void castFromTime(
+    const SimpleVector<int64_t>& inputVector,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    int64_t* rawResults,
+    int16_t offsetMinutes) {
+  context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+    const auto timeMillis = inputVector.valueAt(row);
+    // Convert local time to UTC before packing
+    const auto utcMillis = util::localToUtcTime(timeMillis, offsetMinutes);
+    rawResults[row] = packTimeWithTimeZone(utcMillis, offsetMinutes);
+  });
+}
+
+class TimeWithTimeZoneCastOperator final : public exec::CastOperator {
+  TimeWithTimeZoneCastOperator() = default;
+
+ public:
+  static std::shared_ptr<const CastOperator> get() {
+    VELOX_CONSTEXPR_SINGLETON TimeWithTimeZoneCastOperator kInstance;
+    return {std::shared_ptr<const CastOperator>{}, &kInstance};
+  }
+
+  bool isSupportedFromType(const TypePtr& other) const override {
+    switch (other->kind()) {
+      case TypeKind::BIGINT:
+        return other->isTime();
+      case TypeKind::VARCHAR:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  bool isSupportedToType(const TypePtr& other) const override {
+    switch (other->kind()) {
+      case TypeKind::BIGINT:
+        return other->isTime();
+      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);
+
+    // Handle VARCHAR to TIME WITH TIME ZONE
+    if (input.type() == VARCHAR()) {
+      castFromString(input, context, rows, *result);
+      return;
+    }
+
+    if (input.type()->isTime()) {
+      const auto& config = context.execCtx()->queryCtx()->queryConfig();
+      const auto* sessionTimeZone = getTimeZoneFromConfig(config);
+      const auto sessionStartTimeMs = config.sessionStartTimeMs();
+      int16_t offsetMinutes =
+          getTimezoneOffsetMinutes(sessionTimeZone, sessionStartTimeMs);
+
+      if (input.isConstantEncoding()) {
+        auto constantInput = input.as<ConstantVector<int64_t>>();
+        if (constantInput->isNullAt(0)) {
+          result = BaseVector::createNullConstant(
+              resultType, rows.end(), context.pool());
+          return;
+        }
+
+        const auto timeMillis = constantInput->valueAt(0);
+        // Convert local time to UTC before packing
+        const auto utcMillis = util::localToUtcTime(timeMillis, offsetMinutes);
+        auto packedValue = packTimeWithTimeZone(utcMillis, offsetMinutes);
+
+        result = std::make_shared<ConstantVector<int64_t>>(
+            context.pool(),
+            rows.end(),
+            false, // isNull
+            resultType,
+            std::move(packedValue));
+        return;
+      }
+
+      auto* timeWithTzResult = result->asFlatVector<int64_t>();
+      timeWithTzResult->clearNulls(rows);
+      auto* rawResults = timeWithTzResult->mutableRawValues();
+
+      const auto inputVector = input.as<SimpleVector<int64_t>>();
+      castFromTime(*inputVector, context, rows, rawResults, offsetMinutes);
+      return;
+    } else {
+      VELOX_UNSUPPORTED(
+          "Cast from {} to TIME WITH TIME ZONE not yet supported",
+          input.type()->toString());
+    }
+  }
+
+  void castFrom(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+
+    switch (resultType->kind()) {
+      case TypeKind::BIGINT:
+        if (resultType->isTime()) {
+          castToTime(input, context, rows, *result);
+          return;
+        }
+        break;
+      case TypeKind::VARCHAR:
+        castToString(input, context, rows, *result);
+        return;
+      default:
+        break;
+    }
+
+    VELOX_UNSUPPORTED(
+        "Cast from TIME WITH TIME ZONE to {} not yet supported",
+        resultType->toString());
+  }
+};
+
+class TimeWithTimezoneTypeFactory : public CustomTypeFactory {
+ public:
+  TimeWithTimezoneTypeFactory() = default;
+
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK(parameters.empty());
+    return TIME_WITH_TIME_ZONE();
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return TimeWithTimeZoneCastOperator::get();
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& config) const override {
+    return std::make_shared<fuzzer::TimeWithTimezoneInputGenerator>(
+        config.seed_, config.nullRatio_);
+  }
+};
+
+} // namespace
+
+void registerTimeWithTimezoneType() {
+  registerCustomType(
+      "time with time zone",
+      std::make_unique<const TimeWithTimezoneTypeFactory>());
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimeWithTimezoneRegistration.h b/velox/functions/prestosql/types/TimeWithTimezoneRegistration.h
new file mode 100644
index 000000000000..3be397f134fe
--- /dev/null
+++ b/velox/functions/prestosql/types/TimeWithTimezoneRegistration.h
@@ -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.
+ */
+
+#pragma once
+
+namespace facebook::velox {
+void registerTimeWithTimezoneType();
+}
diff --git a/velox/functions/prestosql/types/TimeWithTimezoneType.cpp b/velox/functions/prestosql/types/TimeWithTimezoneType.cpp
new file mode 100644
index 000000000000..aac069278d35
--- /dev/null
+++ b/velox/functions/prestosql/types/TimeWithTimezoneType.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/functions/prestosql/types/TimeWithTimezoneType.h"
+
+#include "velox/type/Time.h"
+
+namespace facebook::velox {
+
+folly::dynamic TimeWithTimezoneType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "Type";
+  obj["type"] = name();
+  return obj;
+}
+
+StringView TimeWithTimezoneType::valueToString(
+    int64_t value,
+    char* const startPos) const {
+  // TIME WITH TIME ZONE is encoded similarly to TIMESTAMP WITH TIME ZONE
+  // with the most significnat 52 bits representing the time component and the
+  // least 12 bits representing the timezone minutes. This is different from
+  // TIMESTAMP WITH TIMEZONE where the last 12 bits represent the timezone
+  // offset. The timezone offset minutes are stored by value, encoded in the
+  // type itself. This allows the type to be used in a timezone-agnostic manner.
+  //
+  // The time component is a 52 bit value representing the number of
+  // milliseconds since midnight in UTC.
+
+  int64_t millisUtc = util::unpackMillisUtc(value);
+
+  // Ensure time component is within valid range
+  VELOX_CHECK_GE(millisUtc, 0, "Time component is negative");
+  VELOX_CHECK_LE(millisUtc, util::kMillisInDay, "Time component is too large");
+
+  // TimeZone's are encoded as a 12 bit value.
+  // This represents a range of -14:00 to +14:00, with 0 representing UTC.
+  // The range is from -840 to 840 minutes, we thus encode by doing bias
+  // encoding and taking 840 as the bias.
+  auto timezoneMinutes = util::unpackZoneOffset(value);
+
+  VELOX_CHECK_GE(timezoneMinutes, 0, "Timezone offset is less than -14:00");
+  VELOX_CHECK_LE(
+      timezoneMinutes, 1680, "Timezone offset is greater than +14:00");
+
+  // Decode timezone offset from bias-encoded value
+  int16_t offsetMinutes = util::decodeTimezoneOffset(timezoneMinutes);
+  auto decodedMinutes = std::abs(offsetMinutes);
+
+  const auto isBehindUTCString = (offsetMinutes >= 0) ? "+" : "-";
+
+  // Convert UTC time to local time using utility function
+  // Example: If UTC time is 06:30:00 and timezone is +05:30,
+  // the local time is 12:00:00
+  int64_t millisLocal = util::utcToLocalTime(millisUtc, offsetMinutes);
+
+  int64_t hours = millisLocal / util::kMillisInHour;
+  int64_t remainingMs = millisLocal % util::kMillisInHour;
+  int64_t minutes = remainingMs / util::kMillisInMinute;
+  remainingMs = remainingMs % util::kMillisInMinute;
+  int64_t seconds = remainingMs / util::kMillisInSecond;
+  int64_t millis = remainingMs % util::kMillisInSecond;
+
+  int16_t offsetHours = decodedMinutes / util::kMinutesInHour;
+  int16_t remainingOffsetMinutes = decodedMinutes % util::kMinutesInHour;
+
+  fmt::format_to_n(
+      startPos,
+      kTimeWithTimezoneToVarcharRowSize,
+      "{:02d}:{:02d}:{:02d}.{:03d}{}{:02d}:{:02d}",
+      hours,
+      minutes,
+      seconds,
+      millis,
+      isBehindUTCString,
+      offsetHours,
+      remainingOffsetMinutes);
+  return StringView{startPos, kTimeWithTimezoneToVarcharRowSize};
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimeWithTimezoneType.h b/velox/functions/prestosql/types/TimeWithTimezoneType.h
new file mode 100644
index 000000000000..bd323d1262b3
--- /dev/null
+++ b/velox/functions/prestosql/types/TimeWithTimezoneType.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/Time.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+/// Represents TIME WITH TIME ZONE as a bigint.
+/// This type stores time with timezone information, typically encoded as:
+/// - Most significant bits: milliseconds since midnight UTC (similar to TIME)
+/// - Least significant bits : timezone information
+class TimeWithTimezoneType final : public BigintType {
+  constexpr TimeWithTimezoneType() : BigintType{ProvideCustomComparison{}} {}
+
+ public:
+  static constexpr int16_t kTimeWithTimezoneToVarcharRowSize = 18;
+
+  static std::shared_ptr<const TimeWithTimezoneType> get() {
+    VELOX_CONSTEXPR_SINGLETON TimeWithTimezoneType kInstance;
+    return {std::shared_ptr<const TimeWithTimezoneType>{}, &kInstance};
+  }
+
+  bool equivalent(const Type& other) const override {
+    // Pointer comparison works since this type is a singleton.
+    return this == &other;
+  }
+
+  int32_t compare(const int64_t& left, const int64_t& right) const override {
+    const int64_t leftNormalized = normalizeForComparison(left);
+    const int64_t rightNormalized = normalizeForComparison(right);
+
+    // Compare the normalized time values.
+    return leftNormalized < rightNormalized ? -1
+        : leftNormalized == rightNormalized ? 0
+                                            : 1;
+  }
+
+  uint64_t hash(const int64_t& value) const override {
+    return folly::hasher<int64_t>()(util::unpackMillisUtc(value));
+  }
+
+  const char* name() const override {
+    return "TIME WITH TIME ZONE";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  /// Returns the time with timezone 'value' formatted as HH:MM:SS.mmmZZ
+  /// where the timezone offset is included in the representation.
+  StringView valueToString(int64_t value, char* const startPos) const;
+
+  folly::dynamic serialize() const override;
+
+  static TypePtr deserialize(const folly::dynamic& /*obj*/) {
+    return TimeWithTimezoneType::get();
+  }
+
+  bool isOrderable() const override {
+    return true;
+  }
+
+  bool isComparable() const override {
+    return true;
+  }
+
+ private:
+  // Normalizes the UTC time to the range of a day.
+  //
+  // If the local time is outside the range of a day,
+  // this means that during storage there was a wrap around
+  // as UTC would have either exceeded the range of a day
+  // or would have been negative. We need to adjust the UTC
+  // value to restore the original value for comparison.
+  //
+  // For example, if the local time is 00:00:00.000+08:00, then
+  // the UTC time is 16:00:00.000 (the previous day). The previous day
+  // is lost in the conversion. We need to subtract a day to the UTC
+  // time for appropriate comparison.
+  //
+  // Similarly, if the local time is 23:59:59.999-08:00, then
+  // the UTC time is 07:59:59.999 (the next day). The next day
+  // is lost in the conversion. We need to add a day to the UTC
+  // time for appropriate comparison.
+  int64_t normalizeForComparison(int64_t value) const {
+    auto millisUtc = util::unpackMillisUtc(value);
+    auto zoneOffsetMinutes =
+        util::decodeTimezoneOffset(util::unpackZoneOffset(value));
+    auto localMillis = millisUtc + (zoneOffsetMinutes * util::kMillisInMinute);
+
+    if (localMillis < 0) {
+      millisUtc += util::kMillisInDay;
+    }
+
+    if (localMillis >= util::kMillisInDay) {
+      millisUtc -= util::kMillisInDay;
+    }
+    return millisUtc;
+  }
+};
+
+inline bool isTimeWithTimeZone(const TypePtr& other) {
+  return TimeWithTimezoneType::get() == other;
+}
+
+using TimeWithTimezoneTypePtr = std::shared_ptr<const TimeWithTimezoneType>;
+
+FOLLY_ALWAYS_INLINE TimeWithTimezoneTypePtr TIME_WITH_TIME_ZONE() {
+  return TimeWithTimezoneType::get();
+}
+
+struct TimeWithTimezoneT {
+  using type = int64_t;
+  static constexpr const char* typeName = "time with time zone";
+};
+
+using TimeWithTimezone = CustomType<TimeWithTimezoneT, true>;
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.cpp b/velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.cpp
index 00ff68e06d6c..c070b1dcbf7b 100644
--- a/velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.cpp
+++ b/velox/functions/prestosql/types/TimestampWithTimeZoneRegistration.cpp
@@ -34,6 +34,36 @@ const tz::TimeZone* getTimeZoneFromConfig(const core::QueryConfig& config) {
   return tz::locateZone(0); // GMT
 }
 
+// Helper function to calculate midnight in UTC for the given session start
+// time in the session timezone. This can be called once and reused for all
+// rows in a batch.
+int64_t calculateMidnightUtcMs(
+    int64_t sessionStartTimeMs,
+    const tz::TimeZone* sessionTimeZone) {
+  std::chrono::milliseconds localRepresentation;
+
+  if (sessionStartTimeMs != 0) {
+    // Convert session start time to local time in the timezone
+    localRepresentation = sessionTimeZone->to_local(
+        std::chrono::milliseconds(sessionStartTimeMs));
+  } else {
+    // Special case: when session start time is 0 (epoch), treat it as
+    // local representation of epoch (1970-01-01 00:00:00 in local time),
+    // not as UTC epoch converted to local time
+    localRepresentation = std::chrono::milliseconds(0);
+  }
+
+  // Truncate to start of day (midnight) in local time representation
+  auto localMidnight =
+      std::chrono::floor<std::chrono::days>(localRepresentation);
+
+  // Convert the local midnight representation back to UTC
+  auto utcMidnight = sessionTimeZone->to_sys(
+      std::chrono::duration_cast<std::chrono::milliseconds>(localMidnight));
+
+  return utcMidnight.count();
+}
+
 void castFromTimestamp(
     const SimpleVector<Timestamp>& inputVector,
     exec::EvalCtx& context,
@@ -184,13 +214,37 @@ void castToDate(
   });
 }
 
-class TimestampWithTimeZoneCastOperator : public exec::CastOperator {
- public:
-  static const std::shared_ptr<const CastOperator>& get() {
-    static const std::shared_ptr<const CastOperator> instance{
-        new TimestampWithTimeZoneCastOperator()};
+void castToTime(
+    const BaseVector& input,
+    exec::EvalCtx& context,
+    const SelectivityVector& rows,
+    BaseVector& result) {
+  auto* flatResult = result.as<FlatVector<int64_t>>();
+  const auto* timestampVector = input.as<SimpleVector<int64_t>>();
+
+  context.applyToSelectedNoThrow(rows, [&](auto row) {
+    auto timestampWithTimezone = timestampVector->valueAt(row);
+    auto timestamp = unpackTimestampUtc(timestampWithTimezone);
 
-    return instance;
+    // Convert the UTC timestamp to the timezone of the timestamp
+    timestamp.toTimezone(
+        *tz::locateZone(unpackZoneKeyId(timestampWithTimezone)));
+
+    // Extract time-of-day using std::chrono. floor() rounds towards
+    // negative infinity, so this correctly handles negative timestamps.
+    auto millis = std::chrono::milliseconds{timestamp.toMillis()};
+    auto timeOfDay = millis - std::chrono::floor<std::chrono::days>(millis);
+    flatResult->set(row, timeOfDay.count());
+  });
+}
+
+class TimestampWithTimeZoneCastOperator final : public exec::CastOperator {
+  TimestampWithTimeZoneCastOperator() = default;
+
+ public:
+  static std::shared_ptr<const CastOperator> get() {
+    VELOX_CONSTEXPR_SINGLETON TimestampWithTimeZoneCastOperator kInstance;
+    return {std::shared_ptr<const CastOperator>{}, &kInstance};
   }
 
   bool isSupportedFromType(const TypePtr& other) const override {
@@ -201,6 +255,8 @@ class TimestampWithTimeZoneCastOperator : public exec::CastOperator {
         return true;
       case TypeKind::INTEGER:
         return other->isDate();
+      case TypeKind::BIGINT:
+        return other->isTime();
       default:
         return false;
     }
@@ -214,6 +270,8 @@ class TimestampWithTimeZoneCastOperator : public exec::CastOperator {
         return true;
       case TypeKind::INTEGER:
         return other->isDate();
+      case TypeKind::BIGINT:
+        return other->isTime();
       default:
         return false;
     }
@@ -227,6 +285,51 @@ class TimestampWithTimeZoneCastOperator : public exec::CastOperator {
       VectorPtr& result) const override {
     context.ensureWritable(rows, resultType, result);
 
+    if (input.typeKind() == TypeKind::BIGINT && input.type()->isTime()) {
+      const auto& config = context.execCtx()->queryCtx()->queryConfig();
+      const auto* sessionTimeZone = getTimeZoneFromConfig(config);
+      const auto sessionStartTimeMs = config.sessionStartTimeMs();
+
+      // Calculate midnight in UTC once (shared by both constant and
+      // non-constant paths)
+      const auto midnightUtcMs =
+          calculateMidnightUtcMs(sessionStartTimeMs, sessionTimeZone);
+
+      if (input.isConstantEncoding()) {
+        // Optimization for constant TIME input vectors
+        auto constantInput = input.as<ConstantVector<int64_t>>();
+        if (constantInput->isNullAt(0)) {
+          result = BaseVector::createNullConstant(
+              resultType, rows.end(), context.pool());
+          return;
+        }
+
+        const auto timeMillis = constantInput->valueAt(0);
+        auto packedValue =
+            pack(midnightUtcMs + timeMillis, sessionTimeZone->id());
+        result = std::make_shared<ConstantVector<int64_t>>(
+            context.pool(),
+            rows.end(),
+            false, // isNull
+            resultType,
+            std::move(packedValue));
+        return;
+      } else {
+        // Non-constant TIME input
+        auto* timestampWithTzResult = result->asFlatVector<int64_t>();
+        timestampWithTzResult->clearNulls(rows);
+        auto* rawResults = timestampWithTzResult->mutableRawValues();
+
+        const auto inputVector = input.as<SimpleVector<int64_t>>();
+        context.applyToSelectedNoThrow(rows, [&](vector_size_t row) {
+          const auto timeMillis = inputVector->valueAt(row);
+          const auto utcTimestampMs = midnightUtcMs + timeMillis;
+          rawResults[row] = pack(utcTimestampMs, sessionTimeZone->id());
+        });
+        return;
+      }
+    }
+
     auto* timestampWithTzResult = result->asFlatVector<int64_t>();
     timestampWithTzResult->clearNulls(rows);
 
@@ -264,18 +367,18 @@ class TimestampWithTimeZoneCastOperator : public exec::CastOperator {
     } else if (resultType->kind() == TypeKind::INTEGER) {
       VELOX_CHECK(resultType->isDate());
       castToDate(input, context, rows, *result);
+    } else if (resultType->kind() == TypeKind::BIGINT) {
+      VELOX_CHECK(resultType->isTime());
+      castToTime(input, context, rows, *result);
     } else {
       VELOX_UNSUPPORTED(
           "Cast from TIMESTAMP WITH TIME ZONE to {} not yet supported",
           resultType->toString());
     }
   }
-
- private:
-  TimestampWithTimeZoneCastOperator() = default;
 };
 
-class TimestampWithTimeZoneTypeFactories : public CustomTypeFactories {
+class TimestampWithTimeZoneTypeFactory : public CustomTypeFactory {
  public:
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -298,6 +401,6 @@ class TimestampWithTimeZoneTypeFactories : public CustomTypeFactories {
 void registerTimestampWithTimeZoneType() {
   registerCustomType(
       "timestamp with time zone",
-      std::make_unique<const TimestampWithTimeZoneTypeFactories>());
+      std::make_unique<const TimestampWithTimeZoneTypeFactory>());
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/TimestampWithTimeZoneType.h b/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
index ef0f8c9663b9..aa38921d91fd 100644
--- a/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
+++ b/velox/functions/prestosql/types/TimestampWithTimeZoneType.h
@@ -56,16 +56,14 @@ inline Timestamp unpackTimestampUtc(int64_t dateTimeWithTimeZone) {
 
 /// Represents timestamp with time zone as a number of milliseconds since epoch
 /// and time zone ID.
-class TimestampWithTimeZoneType : public BigintType {
-  TimestampWithTimeZoneType() : BigintType(true) {}
+class TimestampWithTimeZoneType final : public BigintType {
+  constexpr TimestampWithTimeZoneType()
+      : BigintType{ProvideCustomComparison{}} {}
 
  public:
-  static const std::shared_ptr<const TimestampWithTimeZoneType>& get() {
-    static const std::shared_ptr<const TimestampWithTimeZoneType> instance =
-        std::shared_ptr<TimestampWithTimeZoneType>(
-            new TimestampWithTimeZoneType());
-
-    return instance;
+  static std::shared_ptr<const TimestampWithTimeZoneType> get() {
+    VELOX_CONSTEXPR_SINGLETON TimestampWithTimeZoneType kInstance;
+    return {std::shared_ptr<const TimestampWithTimeZoneType>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -90,11 +88,6 @@ class TimestampWithTimeZoneType : public BigintType {
     return "TIMESTAMP WITH TIME ZONE";
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
-  }
-
   std::string toString() const override {
     return name();
   }
diff --git a/velox/functions/prestosql/types/UuidRegistration.cpp b/velox/functions/prestosql/types/UuidRegistration.cpp
index f409e1a95fef..e4c9781d8938 100644
--- a/velox/functions/prestosql/types/UuidRegistration.cpp
+++ b/velox/functions/prestosql/types/UuidRegistration.cpp
@@ -180,9 +180,9 @@ class UuidCastOperator : public exec::CastOperator {
   }
 };
 
-class UuidTypeFactories : public CustomTypeFactories {
+class UuidTypeFactory : public CustomTypeFactory {
  public:
-  UuidTypeFactories() = default;
+  UuidTypeFactory() = default;
 
   TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
     VELOX_CHECK(parameters.empty());
@@ -201,6 +201,6 @@ class UuidTypeFactories : public CustomTypeFactories {
 } // namespace
 
 void registerUuidType() {
-  registerCustomType("uuid", std::make_unique<const UuidTypeFactories>());
+  registerCustomType("uuid", std::make_unique<const UuidTypeFactory>());
 }
 } // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/UuidType.h b/velox/functions/prestosql/types/UuidType.h
index 23727589a780..e59257f9003a 100644
--- a/velox/functions/prestosql/types/UuidType.h
+++ b/velox/functions/prestosql/types/UuidType.h
@@ -24,14 +24,13 @@ namespace facebook::velox {
 /// GUID (Globally Unique IDentifier), using the format defined in :rfc:`4122`.
 ///
 /// Example: UUID '12151fd2-7586-11e9-8f9e-2a86e4085a59'
-class UuidType : public HugeintType {
+class UuidType final : 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;
+  static std::shared_ptr<const UuidType> get() {
+    VELOX_CONSTEXPR_SINGLETON UuidType kInstance;
+    return {std::shared_ptr<const UuidType>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
diff --git a/velox/functions/prestosql/types/VarcharEnumRegistration.cpp b/velox/functions/prestosql/types/VarcharEnumRegistration.cpp
new file mode 100644
index 000000000000..251450e0fa30
--- /dev/null
+++ b/velox/functions/prestosql/types/VarcharEnumRegistration.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/functions/prestosql/types/VarcharEnumRegistration.h"
+#include "velox/expression/CastExpr.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
+
+namespace facebook::velox {
+namespace {
+class VarcharEnumCastOperator : public exec::CastOperator {
+ public:
+  static const std::shared_ptr<const CastOperator>& get() {
+    static const std::shared_ptr<const CastOperator> kInstance =
+        std::make_shared<const VarcharEnumCastOperator>();
+
+    return kInstance;
+  }
+
+  // Casting is only supported from VARCHAR type.
+  bool isSupportedFromType(const TypePtr& other) const override {
+    return VARCHAR()->equivalent(*other);
+  }
+
+  // Casting is only supported to VARCHAR type.
+  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);
+    auto* flatResult = result->asChecked<FlatVector<StringView>>();
+    flatResult->clearNulls(rows);
+
+    auto enumType = asVarcharEnum(resultType);
+    const auto* varcharVector = input.as<SimpleVector<StringView>>();
+    rows.applyToSelected([&](vector_size_t row) {
+      const std::string varcharToCast = varcharVector->valueAt(row).str();
+      if (!enumType->containsValue(varcharToCast)) {
+        context.setStatus(
+            row,
+            Status::UserError(
+                "No value '{}' in {}", varcharToCast, enumType->enumName()));
+        return;
+      }
+      flatResult->set(row, StringView(varcharToCast));
+    });
+  }
+
+  void castFrom(
+      const BaseVector& input,
+      exec::EvalCtx& context,
+      const SelectivityVector& rows,
+      const TypePtr& resultType,
+      VectorPtr& result) const override {
+    context.ensureWritable(rows, resultType, result);
+    auto* flatResult = result->asChecked<FlatVector<StringView>>();
+    flatResult->copy(&input, rows, nullptr);
+  }
+};
+
+class VarcharEnumTypeFactory : public CustomTypeFactory {
+ public:
+  TypePtr getType(const std::vector<TypeParameter>& parameters) const override {
+    VELOX_CHECK_EQ(
+        parameters.size(),
+        1,
+        "Expected exactly one type parameters for VarcharEnumType");
+    VELOX_CHECK(
+        parameters[0].varcharEnumLiteral.has_value(),
+        "VarcharEnumType parameter must be varcharEnumLiteral");
+    return VARCHAR_ENUM(parameters[0].varcharEnumLiteral.value());
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return VarcharEnumCastOperator::get();
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& /*config*/) const override {
+    return nullptr;
+  }
+};
+} // namespace
+
+void registerVarcharEnumType() {
+  registerCustomType(
+      "varchar_enum", std::make_unique<const VarcharEnumTypeFactory>());
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/VarcharEnumRegistration.h b/velox/functions/prestosql/types/VarcharEnumRegistration.h
new file mode 100644
index 000000000000..734af78cf66f
--- /dev/null
+++ b/velox/functions/prestosql/types/VarcharEnumRegistration.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
+
+namespace facebook::velox {
+
+void registerVarcharEnumType();
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/VarcharEnumType.cpp b/velox/functions/prestosql/types/VarcharEnumType.cpp
new file mode 100644
index 000000000000..353353d0534f
--- /dev/null
+++ b/velox/functions/prestosql/types/VarcharEnumType.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/functions/prestosql/types/VarcharEnumType.h"
+
+namespace facebook::velox {
+
+// Should only be called from get() to create a new instance.
+VarcharEnumType::VarcharEnumType(const VarcharEnumParameter& parameters)
+    : EnumTypeBase<std::string, VarcharEnumParameter, VarcharType>(parameters) {
+}
+
+std::string VarcharEnumType::toString() const {
+  return fmt::format("{}:VarcharEnum({})", name_, flippedMapToString());
+}
+
+VarcharEnumTypePtr VarcharEnumType::get(const VarcharEnumParameter& parameter) {
+  return getCached<VarcharEnumType>(parameter);
+}
+
+folly::dynamic VarcharEnumType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "Type";
+  obj["type"] = name();
+  // parameters_[0].varcharEnumLiteral is assumed to have a value since it is
+  // constructed from a VarcharEnumParameter.
+  obj["kVarcharEnumParam"] =
+      parameters_[0].varcharEnumLiteral.value().serialize();
+  return obj;
+}
+
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/VarcharEnumType.h b/velox/functions/prestosql/types/VarcharEnumType.h
new file mode 100644
index 000000000000..5f539f41a5bd
--- /dev/null
+++ b/velox/functions/prestosql/types/VarcharEnumType.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/types/EnumTypeBase.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox {
+
+class VarcharEnumType;
+using VarcharEnumTypePtr = std::shared_ptr<const VarcharEnumType>;
+
+/// Represents an enumerated value where the physical type is a varchar. Each
+/// enum type has a name and a set of string keys which map to string values,
+/// passed in as a VarcharEnumParameter TypeParameterKind.
+class VarcharEnumType
+    : public EnumTypeBase<std::string, VarcharEnumParameter, VarcharType> {
+ public:
+  static VarcharEnumTypePtr get(const VarcharEnumParameter& parameter);
+
+  const char* name() const override {
+    return "VARCHAR_ENUM";
+  }
+
+  std::string toString() const override;
+
+  folly::dynamic serialize() const override;
+
+ private:
+  explicit VarcharEnumType(const VarcharEnumParameter& parameters);
+  friend class EnumTypeBase<std::string, VarcharEnumParameter, VarcharType>;
+};
+
+inline VarcharEnumTypePtr VARCHAR_ENUM(const VarcharEnumParameter& parameter) {
+  return VarcharEnumType::get(parameter);
+}
+
+FOLLY_ALWAYS_INLINE bool isVarcharEnumType(const Type& type) {
+  return type.kind() == TypeKind::VARCHAR &&
+      dynamic_cast<const VarcharEnumType*>(&type) != nullptr;
+}
+
+FOLLY_ALWAYS_INLINE VarcharEnumTypePtr asVarcharEnum(const TypePtr& type) {
+  return std::dynamic_pointer_cast<const VarcharEnumType>(type);
+}
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/fuzzer_utils/CMakeLists.txt b/velox/functions/prestosql/types/fuzzer_utils/CMakeLists.txt
index 9145752ae030..2b1c2e262e3d 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/CMakeLists.txt
+++ b/velox/functions/prestosql/types/fuzzer_utils/CMakeLists.txt
@@ -11,15 +11,24 @@
 # WITHOUT 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_presto_types_fuzzer_utils
-                  TimestampWithTimeZoneInputGenerator.cpp)
+velox_add_library(
+  velox_presto_types_fuzzer_utils
+  TimestampWithTimeZoneInputGenerator.cpp
+  TimeWithTimezoneInputGenerator.cpp
+  HyperLogLogInputGenerator.cpp
+  KHyperLogLogInputGenerator.cpp
+  P4HyperLogLogInputGenerator.cpp
+  SfmSketchInputGenerator.cpp
+)
 
 velox_link_libraries(
   velox_presto_types_fuzzer_utils
   velox_type
   velox_common_fuzzer_util
   velox_presto_types
-  velox_type_tz)
+  velox_type_tz
+  velox_functions_sfm
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.cpp b/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.cpp
new file mode 100644
index 000000000000..6afb6d412f79
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.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/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h"
+
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/functions/prestosql/types/HyperLogLogType.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer {
+
+HyperLogLogInputGenerator::HyperLogLogInputGenerator(
+    const size_t seed,
+    const double nullRatio,
+    memory::MemoryPool* pool,
+    int32_t minNumValues)
+    : AbstractInputGenerator{seed, HYPERLOGLOG(), nullptr, nullRatio},
+      minNumValues_{minNumValues},
+      pool_{pool} {
+  static const std::vector<TypePtr> kBaseTypes{
+      BIGINT(), VARCHAR(), DOUBLE(), UNKNOWN()};
+  baseType_ = kBaseTypes[rand<int32_t>(rng_, 0, kBaseTypes.size() - 1)];
+  error_ = rand<double>(rng_, 0.0040625, 0.26000);
+}
+
+variant HyperLogLogInputGenerator::generate() {
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  if (baseType_->isBigint()) {
+    return generateTyped<int64_t>();
+  } else if (baseType_->isVarchar()) {
+    return generateTyped<std::string>();
+  } else if (baseType_->isDouble()) {
+    return generateTyped<double>();
+  } else {
+    return generateTyped<UnknownValue>();
+  }
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h b/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h
new file mode 100644
index 000000000000..e1da24bd6bad
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.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/common/fuzzer/Utils.h"
+#include "velox/functions/prestosql/aggregates/HyperLogLogAggregate.h"
+#include "velox/type/Type.h"
+
+namespace facebook::velox::fuzzer {
+
+using common::hll::HllAccumulator;
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+class HyperLogLogInputGenerator : public AbstractInputGenerator {
+ public:
+  HyperLogLogInputGenerator(
+      const size_t seed,
+      const double nullRatio,
+      memory::MemoryPool* pool,
+      int32_t minNumValues = 1);
+
+  variant generate() override;
+
+ private:
+  template <typename T>
+  variant generateTyped() {
+    HashStringAllocator allocator{pool_};
+    HllAccumulator<T, true> accumulator(&allocator);
+    accumulator.setIndexBitLength(common::hll::toIndexBitLength(error_));
+    static const std::vector<UTF8CharList> encodings{
+        UTF8CharList::ASCII,
+        UTF8CharList::UNICODE_CASE_SENSITIVE,
+        UTF8CharList::EXTENDED_UNICODE,
+        UTF8CharList::MATHEMATICAL_SYMBOLS};
+
+    auto numValues = rand<int32_t>(rng_, minNumValues_, 1000);
+    for (auto i = 0; i < numValues; ++i) {
+      if constexpr (
+          std::is_same_v<T, std::string> || std::is_same_v<T, StringView>) {
+        std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+        auto size = rand<int32_t>(rng_, 0, 100);
+        std::string result;
+        accumulator.append(
+            randString(rng_, size, encodings, result, converter));
+      } else if (std::is_same_v<T, UnknownValue>) {
+        // No-op since approx_set ignores input nulls.
+      } else {
+        accumulator.append(rand<T>(rng_));
+      }
+    }
+    auto size = accumulator.serializedSize();
+    std::string buff(size, '\0');
+    accumulator.serialize(buff.data());
+    return variant::create<TypeKind::VARBINARY>(buff);
+  }
+
+  TypePtr baseType_;
+  double error_;
+  int32_t minNumValues_;
+
+  memory::MemoryPool* pool_;
+};
+#pragma GCC diagnostic pop
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.cpp b/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.cpp
new file mode 100644
index 000000000000..f7fc67f7cd2c
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.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/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h"
+
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/common/hyperloglog/KHyperLogLog.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer {
+
+KHyperLogLogInputGenerator::KHyperLogLogInputGenerator(
+    const size_t seed,
+    const double nullRatio,
+    memory::MemoryPool* pool,
+    int32_t minNumValues)
+    : AbstractInputGenerator{seed, KHYPERLOGLOG(), nullptr, nullRatio},
+      minNumValues_{minNumValues},
+      pool_{pool} {
+  static const std::vector<TypePtr> kBaseTypes{
+      BIGINT(), VARCHAR(), DOUBLE(), UNKNOWN()};
+  baseType_ = kBaseTypes[rand<int32_t>(rng_, 0, kBaseTypes.size() - 1)];
+
+  maxSize_ = rand<int32_t>(rng_, 100, 5000);
+  static const std::vector<int32_t> kValidBuckets{64, 128, 256, 512, 1024};
+  hllBuckets_ = kValidBuckets[rand<int32_t>(rng_, 0, kValidBuckets.size() - 1)];
+}
+
+// General template for numeric types (double)
+template <typename T>
+variant KHyperLogLogInputGenerator::generateTyped() {
+  HashStringAllocator allocator{pool_};
+  common::hll::KHyperLogLog<int64_t, HashStringAllocator> khll{
+      maxSize_, hllBuckets_, &allocator};
+
+  auto numPairs = rand<int32_t>(rng_, minNumValues_, 10000);
+  for (auto i = 0; i < numPairs; ++i) {
+    auto value = rand<T>(rng_);
+    int64_t joinKey = std::hash<T>{}(value);
+    int64_t uii = rand<int64_t>(rng_);
+    khll.add(joinKey, uii);
+  }
+
+  auto size = khll.estimatedSerializedSize();
+  std::string buff(size, '\0');
+  khll.serialize(buff.data());
+  return variant::binary(std::move(buff));
+}
+
+// Specialization for int64_t
+template <>
+variant KHyperLogLogInputGenerator::generateTyped<int64_t>() {
+  HashStringAllocator allocator{pool_};
+  common::hll::KHyperLogLog<int64_t, HashStringAllocator> khll{
+      maxSize_, hllBuckets_, &allocator};
+
+  auto numPairs = rand<int32_t>(rng_, minNumValues_, 10000);
+  for (auto i = 0; i < numPairs; ++i) {
+    int64_t joinKey = rand<int64_t>(rng_);
+    int64_t uii = rand<int64_t>(rng_);
+    khll.add(joinKey, uii);
+  }
+
+  auto size = khll.estimatedSerializedSize();
+  std::string buff(size, '\0');
+  khll.serialize(buff.data());
+  return variant::binary(std::move(buff));
+}
+
+// Specialization for std::string (VARCHAR)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+template <>
+variant KHyperLogLogInputGenerator::generateTyped<std::string>() {
+  HashStringAllocator allocator{pool_};
+  common::hll::KHyperLogLog<int64_t, HashStringAllocator> khll{
+      maxSize_, hllBuckets_, &allocator};
+
+  static const std::vector<UTF8CharList> encodings{
+      UTF8CharList::ASCII,
+      UTF8CharList::UNICODE_CASE_SENSITIVE,
+      UTF8CharList::EXTENDED_UNICODE,
+      UTF8CharList::MATHEMATICAL_SYMBOLS};
+  std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+
+  auto numPairs = rand<int32_t>(rng_, minNumValues_, 10000);
+  for (auto i = 0; i < numPairs; ++i) {
+    auto size = rand<int32_t>(rng_, 0, 100);
+    std::string result;
+    auto str = randString(rng_, size, encodings, result, converter);
+    int64_t joinKey = std::hash<std::string>{}(str);
+    int64_t uii = rand<int64_t>(rng_);
+    khll.add(joinKey, uii);
+  }
+
+  auto size = khll.estimatedSerializedSize();
+  std::string buff(size, '\0');
+  khll.serialize(buff.data());
+  return variant::binary(std::move(buff));
+}
+#pragma GCC diagnostic pop
+
+// Specialization for UnknownValue (NULL type)
+template <>
+variant KHyperLogLogInputGenerator::generateTyped<UnknownValue>() {
+  HashStringAllocator allocator{pool_};
+  common::hll::KHyperLogLog<int64_t, HashStringAllocator> khll{
+      maxSize_, hllBuckets_, &allocator};
+
+  // UnknownValue represents NULL, so create an empty KHyperLogLog
+  // since KHyperLogLog ignores NULL inputs
+
+  auto size = khll.estimatedSerializedSize();
+  std::string buff(size, '\0');
+  khll.serialize(buff.data());
+  return variant::binary(std::move(buff));
+}
+
+variant KHyperLogLogInputGenerator::generate() {
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  if (baseType_->isBigint()) {
+    return generateTyped<int64_t>();
+  } else if (baseType_->isVarchar()) {
+    return generateTyped<std::string>();
+  } else if (baseType_->isDouble()) {
+    return generateTyped<double>();
+  } else {
+    return generateTyped<UnknownValue>();
+  }
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h b/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h
new file mode 100644
index 000000000000..085810f29b8b
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.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/type/Type.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer {
+
+// Suppress warnings about deprecated declarations for AbstractInputGenerator
+// interface and std::hash usage in type conversions.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+class KHyperLogLogInputGenerator : public AbstractInputGenerator {
+ public:
+  KHyperLogLogInputGenerator(
+      const size_t seed,
+      const double nullRatio,
+      memory::MemoryPool* pool,
+      int32_t minNumValues = 1);
+
+  variant generate() override;
+
+ private:
+  template <typename T>
+  variant generateTyped();
+
+  TypePtr baseType_;
+  int32_t maxSize_;
+  int32_t hllBuckets_;
+  int32_t minNumValues_;
+  memory::MemoryPool* pool_;
+};
+#pragma GCC diagnostic pop
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.cpp b/velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.cpp
new file mode 100644
index 000000000000..b957ec7623e9
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.cpp
@@ -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 "velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.h"
+
+#include "velox/functions/prestosql/types/P4HyperLogLogType.h"
+
+namespace facebook::velox::fuzzer {
+
+P4HyperLogLogInputGenerator::P4HyperLogLogInputGenerator(
+    const size_t seed,
+    const double nullRatio,
+    memory::MemoryPool* pool)
+    : HyperLogLogInputGenerator(seed, nullRatio, pool, 100) {
+  // P4HyperLogLog only supports dense format, unlike HyperLogLog which
+  // supports sparse and dense representations. 100 is the minimum number that
+  // generate sufficient values to trigger dense format.
+  type_ = P4HYPERLOGLOG();
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/substrait/VariantToVectorConverter.h b/velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.h
similarity index 63%
rename from velox/substrait/VariantToVectorConverter.h
rename to velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.h
index a7146f76088f..368520af57ae 100644
--- a/velox/substrait/VariantToVectorConverter.h
+++ b/velox/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.h
@@ -13,17 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #pragma once
 
-#include "velox/vector/BaseVector.h"
+#include "velox/functions/prestosql/types/fuzzer_utils/HyperLogLogInputGenerator.h"
 
-namespace facebook::velox::substrait {
+namespace facebook::velox::fuzzer {
 
-/// Create Base Vector from velox variants.
-/// Only scalar types are supported except VARBINARY.
-VectorPtr setVectorFromVariants(
-    const TypePtr& type,
-    const std::vector<velox::variant>& values,
-    velox::memory::MemoryPool* pool);
+class P4HyperLogLogInputGenerator : public HyperLogLogInputGenerator {
+ public:
+  P4HyperLogLogInputGenerator(
+      const size_t seed,
+      const double nullRatio,
+      memory::MemoryPool* pool);
+};
 
-} // namespace facebook::velox::substrait
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.cpp b/velox/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.cpp
new file mode 100644
index 000000000000..7728e86ecdaf
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.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/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/functions/prestosql/types/SfmSketchType.h"
+
+namespace facebook::velox::fuzzer {
+
+SfmSketchInputGenerator::SfmSketchInputGenerator(
+    const size_t seed,
+    const double nullRatio,
+    memory::MemoryPool* pool)
+    : AbstractInputGenerator(seed, SFMSKETCH(), nullptr, nullRatio),
+      pool_(pool) {
+  // Initialize supported input types for SfmSketch.
+  static const std::vector<TypePtr> kBaseTypes{
+      BIGINT(), VARCHAR(), DOUBLE(), UNKNOWN()};
+  baseType_ = kBaseTypes[rand<size_t>(rng_, 0, kBaseTypes.size() - 1)];
+}
+
+variant SfmSketchInputGenerator::generate() {
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(TypeKind::VARBINARY);
+  }
+
+  // Generate based on the type
+  switch (baseType_->kind()) {
+    case TypeKind::BIGINT:
+      return generateTyped<int64_t>();
+    case TypeKind::DOUBLE:
+      return generateTyped<double>();
+    case TypeKind::VARCHAR:
+      return generateTyped<std::string>();
+    case TypeKind::UNKNOWN:
+      return generateTyped<UnknownValue>();
+    default:
+      VELOX_UNREACHABLE("Unsupported type for SfmSketch generation");
+  }
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.h b/velox/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.h
new file mode 100644
index 000000000000..788a0e658cea
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.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/fuzzer/Utils.h"
+#include "velox/functions/lib/sfm/SfmSketch.h"
+#include "velox/type/Type.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer {
+
+using facebook::velox::UnknownValue;
+using facebook::velox::functions::sfm::SfmSketch;
+
+class SfmSketchInputGenerator : public AbstractInputGenerator {
+ public:
+  SfmSketchInputGenerator(
+      const size_t seed,
+      const double nullRatio,
+      memory::MemoryPool* pool);
+
+  variant generate() override;
+
+ private:
+  template <typename T>
+  variant generateTyped() {
+    HashStringAllocator allocator(pool_);
+
+    // SFM sketch require indexBitLength and precision to be the same for
+    // functions such as merge and mergeArray.
+    if (!indexBitLength_.has_value() && !precision_.has_value()) {
+      indexBitLength_ = rand<int32_t>(rng_, 1, 16);
+      numberOfBuckets_ = SfmSketch::numBuckets(*indexBitLength_);
+      precision_ = rand<int32_t>(rng_, 1, 64 - *indexBitLength_);
+    }
+
+    auto sketch = SfmSketch(&allocator, /* seed */ 1);
+    sketch.initialize(*numberOfBuckets_, *precision_);
+
+    // Add values to the sketch
+    auto numValues = rand<int32_t>(rng_, 1, 10);
+    for (auto i = 0; i < numValues; ++i) {
+      if constexpr (
+          std::is_same_v<T, std::string> || std::is_same_v<T, StringView>) {
+        // Generate a random string directly without using randString since it
+        // is deprecated.
+        auto size = rand<int32_t>(rng_, 0, 100); // size of the string.
+        std::string str;
+        str.reserve(size);
+
+        // Generate random ASCII characters.
+        for (int j = 0; j < size; ++j) {
+          char c = static_cast<char>(rand<int32_t>(rng_, 32, 126));
+          str.push_back(c);
+        }
+
+        sketch.add(str);
+      } else if (std::is_same_v<T, UnknownValue>) {
+        // No-op since SfmSketch ignores input nulls.
+      } else {
+        sketch.add(rand<T>(rng_));
+      }
+    }
+
+    // Serialize the sketch.
+    auto size = sketch.serializedSize();
+    std::string buff(size, '\0');
+    sketch.serialize(buff.data());
+    return variant::create<TypeKind::VARBINARY>(buff);
+  }
+
+  TypePtr baseType_;
+  memory::MemoryPool* pool_;
+  std::optional<int32_t> indexBitLength_;
+  std::optional<int32_t> precision_;
+  std::optional<int32_t> numberOfBuckets_;
+};
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.cpp b/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.cpp
new file mode 100644
index 000000000000..691c1b789372
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.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 "velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h"
+
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneType.h"
+#include "velox/type/Time.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer {
+
+TimeWithTimezoneInputGenerator::TimeWithTimezoneInputGenerator(
+    size_t seed,
+    double nullRatio)
+    : AbstractInputGenerator(
+          seed,
+          TIME_WITH_TIME_ZONE(),
+          nullptr /*leafGenerator*/,
+          nullRatio) {}
+
+variant TimeWithTimezoneInputGenerator::generate() {
+  if (coinToss(rng_, nullRatio_)) {
+    return variant::null(type_->kind());
+  }
+
+  const int64_t timeMillis = rand<int64_t>(rng_, 0, util::kMillisInDay - 1);
+
+  // Use shared timezone generation utility (25% frequently used, 75% random)
+  int16_t timezoneOffsetMinutes = generateRandomTimezoneOffset(rng_);
+
+  const int16_t biasEncodedTimezone = util::biasEncode(timezoneOffsetMinutes);
+  return util::pack(timeMillis, biasEncodedTimezone);
+}
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h b/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h
new file mode 100644
index 000000000000..a95f350c137d
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.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/type/Type.h"
+
+namespace facebook::velox::fuzzer {
+
+/// Input generator for TIME WITH TIME ZONE type.
+/// Generates valid TIME WITH TIME ZONE values by combining:
+/// - Time component: milliseconds since midnight (0 to 86399999)
+/// - Timezone offset: bias-encoded minutes (-840 to 840 -> 0 to 1680)
+/// Biases selection toward US timezone offsets (including DST) for better
+/// coverage of DST-related edge cases.
+class TimeWithTimezoneInputGenerator : public AbstractInputGenerator {
+ public:
+  TimeWithTimezoneInputGenerator(size_t seed, double nullRatio);
+
+  Variant generate() override;
+};
+
+} // namespace facebook::velox::fuzzer
diff --git a/velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.cpp b/velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.cpp
index 183db7873e75..abcbcae8bc06 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.cpp
+++ b/velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.cpp
@@ -31,19 +31,19 @@ namespace {
 std::vector<int16_t> excludeProblematicTimeZoneIds(
     std::vector<int16_t> timeZoneIds) {
   static const std::unordered_set<int16_t> kExcludedTimeZones = {
-      1682, 1683, 1685, 1686, 1687, 1688, 1689, 1691, 1692, 1693, 1697, 1698,
-      1699, 1700, 1701, 1703, 1704, 1705, 1707, 1708, 1710, 1711, 1713, 1714,
-      1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1726, 1727, 1728, 1729,
-      1730, 1731, 1737, 1738, 1753, 1754, 1755, 1757, 1762, 1769, 1773, 1775,
-      1776, 1780, 1786, 1790, 1796, 1797, 1798, 1804, 1816, 1822, 1827, 1831,
-      1834, 1837, 1839, 1842, 1845, 1846, 1854, 1860, 1871, 1879, 1881, 1882,
-      1883, 1883, 1884, 1889, 1891, 1893, 1900, 1903, 1906, 1907, 1908, 1909,
-      1910, 1919, 1924, 1926, 1933, 1955, 1957, 1962, 1963, 1969, 1994, 1999,
-      2005, 2006, 2007, 2009, 2049, 2060, 2063, 2065, 2067, 2070, 2071, 2073,
-      2078, 2081, 2089, 2091, 2093, 2098, 2104, 2107, 2109, 2110, 2111, 2112,
-      2113, 2116, 2117, 2118, 2119, 2120, 2124, 2130, 2140, 2142, 2150, 2151,
-      2154, 2159, 2160, 2161, 2162, 2179, 2176, 2177, 2181, 2188, 2195, 2197,
-      2202, 2204, 2209, 2210, 2233,
+      1110, 1682, 1683, 1685, 1686, 1687, 1688, 1689, 1691, 1692, 1693, 1697,
+      1698, 1699, 1700, 1701, 1703, 1704, 1705, 1707, 1708, 1710, 1711, 1713,
+      1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1726, 1727, 1728,
+      1729, 1730, 1731, 1737, 1738, 1753, 1754, 1755, 1757, 1758, 1762, 1769,
+      1773, 1775, 1776, 1780, 1786, 1790, 1796, 1797, 1798, 1804, 1816, 1822,
+      1827, 1831, 1834, 1837, 1839, 1842, 1845, 1846, 1854, 1860, 1871, 1879,
+      1881, 1882, 1883, 1884, 1889, 1891, 1893, 1900, 1903, 1906, 1907, 1908,
+      1909, 1910, 1919, 1924, 1926, 1933, 1955, 1957, 1962, 1963, 1969, 1994,
+      1999, 2005, 2006, 2007, 2009, 2049, 2060, 2063, 2065, 2067, 2070, 2071,
+      2073, 2078, 2081, 2089, 2091, 2093, 2098, 2104, 2107, 2109, 2110, 2111,
+      2112, 2113, 2116, 2117, 2118, 2119, 2120, 2124, 2130, 2140, 2142, 2150,
+      2151, 2153, 2154, 2159, 2160, 2161, 2162, 2179, 2176, 2177, 2181, 2188,
+      2195, 2197, 2202, 2204, 2209, 2210, 2233,
   };
 
   timeZoneIds.erase(
@@ -60,8 +60,8 @@ std::vector<int16_t> excludeProblematicTimeZoneIds(
 } // namespace
 
 TimestampWithTimeZoneInputGenerator::TimestampWithTimeZoneInputGenerator(
-    const size_t seed,
-    const double nullRatio)
+    size_t seed,
+    double nullRatio)
     : AbstractInputGenerator(
           seed,
           TIMESTAMP_WITH_TIME_ZONE(),
diff --git a/velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.h b/velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.h
index 3c88c4ef20e9..d6e9af8baa9d 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.h
+++ b/velox/functions/prestosql/types/fuzzer_utils/TimestampWithTimeZoneInputGenerator.h
@@ -21,11 +21,9 @@
 namespace facebook::velox::fuzzer {
 class TimestampWithTimeZoneInputGenerator : public AbstractInputGenerator {
  public:
-  TimestampWithTimeZoneInputGenerator(
-      const size_t seed,
-      const double nullRatio);
+  TimestampWithTimeZoneInputGenerator(size_t seed, double nullRatio);
 
-  variant generate() override;
+  Variant generate() override;
 
  private:
   const std::vector<int16_t> timeZoneIds_;
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/CMakeLists.txt b/velox/functions/prestosql/types/fuzzer_utils/tests/CMakeLists.txt
index e9771ac085e3..abf03d5209e7 100644
--- a/velox/functions/prestosql/types/fuzzer_utils/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/CMakeLists.txt
@@ -12,17 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_presto_types_fuzzer_utils_test
-               TimestampWithTimeZoneInputGeneratorTest.cpp)
+add_executable(
+  velox_presto_types_fuzzer_utils_test
+  TimestampWithTimeZoneInputGeneratorTest.cpp
+  TimeWithTimezoneInputGeneratorTest.cpp
+  HyperLogLogInputGeneratorTest.cpp
+  KHyperLogLogInputGeneratorTest.cpp
+  P4HyperLogLogInputGeneratorTest.cpp
+  SfmSketchInputGeneratorTest.cpp
+)
 
-add_test(velox_presto_types_fuzzer_utils_test
-         velox_presto_types_fuzzer_utils_test)
+add_test(velox_presto_types_fuzzer_utils_test velox_presto_types_fuzzer_utils_test)
 
 target_link_libraries(
   velox_presto_types_fuzzer_utils_test
   velox_presto_types_fuzzer_utils
+  velox_functions_test_lib
   velox_presto_types
   velox_type
   velox_type_tz
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/HyperLogLogInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/HyperLogLogInputGeneratorTest.cpp
new file mode 100644
index 000000000000..1fb3b08590c7
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/HyperLogLogInputGeneratorTest.cpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/fuzzer_utils/HyperLogLogInputGenerator.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/hyperloglog/DenseHll.h"
+#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer::test {
+
+class HyperLogLogInputGeneratorTest : public functions::test::FunctionBaseTest {
+};
+
+TEST_F(HyperLogLogInputGeneratorTest, generate) {
+  HyperLogLogInputGenerator generator(123, 0.1, pool());
+
+  size_t numTrials = 100;
+  for (size_t i = 0; i < numTrials; ++i) {
+    variant generated = generator.generate();
+
+    if (generated.isNull()) {
+      continue;
+    }
+
+    generated.checkIsKind(TypeKind::VARBINARY);
+    const auto& value = generated.value<TypeKind::VARBINARY>();
+    HashStringAllocator allocator{pool_.get()};
+
+    if (common::hll::SparseHlls::canDeserialize(value.data())) {
+      common::hll::SparseHll<> hll(value.data(), &allocator);
+      hll.cardinality();
+    } else if (common::hll::DenseHlls::canDeserialize(value.data())) {
+      common::hll::DenseHll<> hll(value.data(), &allocator);
+      hll.cardinality();
+    } else {
+      VELOX_FAIL("Invalid HLL value");
+    }
+  }
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/KHyperLogLogInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/KHyperLogLogInputGeneratorTest.cpp
new file mode 100644
index 000000000000..d97fd0ed3bad
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/KHyperLogLogInputGeneratorTest.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/functions/prestosql/types/fuzzer_utils/KHyperLogLogInputGenerator.h"
+
+#include <gtest/gtest.h>
+#include "velox/common/hyperloglog/KHyperLogLog.h"
+#include "velox/common/memory/HashStringAllocator.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/functions/prestosql/types/KHyperLogLogType.h"
+
+namespace facebook::velox::fuzzer::test {
+
+class KHyperLogLogInputGeneratorTest
+    : public functions::test::FunctionBaseTest {};
+
+TEST_F(KHyperLogLogInputGeneratorTest, generate) {
+  KHyperLogLogInputGenerator generator(1, 0.0, pool());
+
+  for (int i = 0; i < 10; ++i) {
+    auto result = generator.generate();
+    ASSERT_FALSE(result.isNull());
+    ASSERT_EQ(result.kind(), TypeKind::VARBINARY);
+
+    // Verify deserialization works
+    const auto& serialized = result.value<TypeKind::VARBINARY>();
+    HashStringAllocator allocator{pool()};
+    auto khll =
+        common::hll::KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+            serialized.data(), serialized.size(), &allocator);
+    ASSERT_TRUE(khll.hasValue())
+        << "Deserialization failed: " << khll.error().message();
+    ASSERT_NE(*khll, nullptr);
+    ASSERT_GE((*khll)->cardinality(), 0);
+  }
+}
+
+TEST_F(KHyperLogLogInputGeneratorTest, generateWithNulls) {
+  KHyperLogLogInputGenerator generator(1, 0.5, pool());
+
+  int nullCount = 0;
+  int nonNullCount = 0;
+
+  for (int i = 0; i < 100; ++i) {
+    auto result = generator.generate();
+    if (result.isNull()) {
+      nullCount++;
+    } else {
+      nonNullCount++;
+      ASSERT_EQ(result.kind(), TypeKind::VARBINARY);
+
+      // Verify deserialization works
+      const auto& serialized = result.value<TypeKind::VARBINARY>();
+      HashStringAllocator allocator{pool()};
+      auto khll =
+          common::hll::KHyperLogLog<int64_t, HashStringAllocator>::deserialize(
+              serialized.data(), serialized.size(), &allocator);
+      ASSERT_TRUE(khll.hasValue())
+          << "Deserialization failed: " << khll.error().message();
+    }
+  }
+
+  // With null ratio 0.5, we should have roughly half nulls
+  ASSERT_GT(nullCount, 0);
+  ASSERT_GT(nonNullCount, 0);
+}
+
+TEST_F(KHyperLogLogInputGeneratorTest, generateDifferentSeeds) {
+  KHyperLogLogInputGenerator generator1(1, 0.0, pool());
+  KHyperLogLogInputGenerator generator2(2, 0.0, pool());
+
+  auto result1 = generator1.generate();
+  auto result2 = generator2.generate();
+
+  ASSERT_FALSE(result1.isNull());
+  ASSERT_FALSE(result2.isNull());
+  ASSERT_EQ(result1.kind(), TypeKind::VARBINARY);
+  ASSERT_EQ(result2.kind(), TypeKind::VARBINARY);
+
+  // Different seeds should produce different results
+  const auto& serialized1 = result1.value<TypeKind::VARBINARY>();
+  const auto& serialized2 = result2.value<TypeKind::VARBINARY>();
+  ASSERT_NE(serialized1, serialized2);
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/P4HyperLogLogInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/P4HyperLogLogInputGeneratorTest.cpp
new file mode 100644
index 000000000000..62f94d4e4c99
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/P4HyperLogLogInputGeneratorTest.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/functions/prestosql/types/fuzzer_utils/P4HyperLogLogInputGenerator.h"
+
+#include <gtest/gtest.h>
+
+#include "velox/common/hyperloglog/DenseHll.h"
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer::test {
+
+class P4HyperLogLogInputGeneratorTest
+    : public functions::test::FunctionBaseTest {};
+
+TEST_F(P4HyperLogLogInputGeneratorTest, generate) {
+  P4HyperLogLogInputGenerator generator(123, 0.1, pool());
+
+  size_t numTrials = 100;
+  for (size_t i = 0; i < numTrials; ++i) {
+    variant generated = generator.generate();
+
+    if (generated.isNull()) {
+      continue;
+    }
+
+    generated.checkIsKind(TypeKind::VARBINARY);
+    const auto& value = generated.value<TypeKind::VARBINARY>();
+    HashStringAllocator allocator{pool_.get()};
+
+    // P4HyperLogLog should only produce dense HLL format
+    if (common::hll::DenseHlls::canDeserialize(value.data())) {
+      common::hll::DenseHll<> hll(value.data(), &allocator);
+      hll.cardinality();
+    } else {
+      VELOX_FAIL("P4HyperLogLog should only produce dense HLL format");
+    }
+  }
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/SfmSketchInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/SfmSketchInputGeneratorTest.cpp
new file mode 100644
index 000000000000..415e6459971a
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/SfmSketchInputGeneratorTest.cpp
@@ -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 "velox/functions/prestosql/types/fuzzer_utils/SfmSketchInputGenerator.h"
+#include <gtest/gtest.h>
+#include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer::test {
+class SfmSketchInputGeneratorTest : public functions::test::FunctionBaseTest {};
+
+TEST_F(SfmSketchInputGeneratorTest, generateTest) {
+  SfmSketchInputGenerator gen(123, 0.1, pool());
+
+  size_t numTrials = 100;
+  for (size_t i = 0; i < numTrials; ++i) {
+    variant generated = gen.generate();
+    if (generated.isNull()) {
+      continue;
+    }
+    generated.checkIsKind(TypeKind::VARBINARY);
+    const auto& value = generated.value<TypeKind::VARBINARY>();
+    HashStringAllocator allocator{pool_.get()};
+    auto sketch = SfmSketch::deserialize(value.data(), &allocator);
+    // Test that the sketch can be deserialized from the generated data.
+    // We don't know anything about the fuzzer generated data.
+    sketch.cardinality();
+  }
+}
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/functions/prestosql/types/fuzzer_utils/tests/TimeWithTimezoneInputGeneratorTest.cpp b/velox/functions/prestosql/types/fuzzer_utils/tests/TimeWithTimezoneInputGeneratorTest.cpp
new file mode 100644
index 000000000000..93747cb77098
--- /dev/null
+++ b/velox/functions/prestosql/types/fuzzer_utils/tests/TimeWithTimezoneInputGeneratorTest.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 "velox/functions/prestosql/types/fuzzer_utils/TimeWithTimezoneInputGenerator.h"
+
+#include <gtest/gtest.h>
+#include <unordered_set>
+
+#include "velox/common/fuzzer/Utils.h"
+#include "velox/type/Time.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox::fuzzer::test {
+
+TEST(TimeWithTimezoneInputGeneratorTest, generate) {
+  TimeWithTimezoneInputGenerator generator(123456, 0.1);
+
+  size_t numTrials = 100;
+  for (size_t i = 0; i < numTrials; ++i) {
+    variant generated = generator.generate();
+
+    if (generated.isNull()) {
+      continue;
+    }
+
+    generated.checkIsKind(TypeKind::BIGINT);
+    const auto value = generated.value<TypeKind::BIGINT>();
+
+    // Verify time component is in valid range [0, kMillisInDay)
+    const auto timeMillis = util::unpackMillisUtc(value);
+    EXPECT_GE(timeMillis, 0);
+    EXPECT_LT(timeMillis, util::kMillisInDay);
+
+    // Verify timezone offset is in valid bias-encoded range [0, 1680]
+    const auto timezoneOffset = util::unpackZoneOffset(value);
+    EXPECT_GE(timezoneOffset, 0);
+    EXPECT_LE(timezoneOffset, 2 * util::kTimeZoneBias);
+  }
+}
+
+TEST(TimeWithTimezoneInputGeneratorTest, generatesBothOffsetTypes) {
+  TimeWithTimezoneInputGenerator generator(12345, 0.0); // Fixed seed, no nulls
+
+  std::unordered_set<int16_t> frequentlyUsed(
+      kFrequentlyUsedTimezoneOffsets.begin(),
+      kFrequentlyUsedTimezoneOffsets.end());
+
+  bool foundFrequentlyUsed = false;
+  bool foundOther = false;
+
+  for (int i = 0; i < 100 && (!foundFrequentlyUsed || !foundOther); ++i) {
+    auto value = generator.generate().value<TypeKind::BIGINT>();
+    auto encoded = util::unpackZoneOffset(value);
+    auto offset = util::decodeTimezoneOffset(encoded);
+
+    if (frequentlyUsed.count(offset)) {
+      foundFrequentlyUsed = true;
+    } else {
+      foundOther = true;
+    }
+  }
+
+  EXPECT_TRUE(foundFrequentlyUsed);
+  EXPECT_TRUE(foundOther);
+}
+
+} // namespace facebook::velox::fuzzer::test
diff --git a/velox/functions/prestosql/types/parser/CMakeLists.txt b/velox/functions/prestosql/types/parser/CMakeLists.txt
new file mode 100644
index 000000000000..c08442ea2f20
--- /dev/null
+++ b/velox/functions/prestosql/types/parser/CMakeLists.txt
@@ -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.
+
+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=veloxprestotp"
+)
+
+add_flex_bison_dependency(TypeParserScanner TypeParser)
+
+if(VELOX_MONO_LIBRARY)
+  add_custom_target(
+    velox_presto_type_parser_gen_src
+    DEPENDS ${BISON_TypeParser_OUTPUTS} ${FLEX_TypeParserScanner_OUTPUTS}
+  )
+  add_dependencies(velox velox_presto_type_parser_gen_src)
+endif()
+velox_add_library(
+  velox_presto_type_parser
+  ${BISON_TypeParser_OUTPUTS}
+  ${FLEX_TypeParserScanner_OUTPUTS}
+  ParserUtil.cpp
+)
+velox_include_directories(
+  velox_presto_type_parser
+  PRIVATE ${PROJECT_BINARY_DIR} ${FLEX_INCLUDE_DIRS}
+)
+velox_link_libraries(velox_presto_type_parser velox_common_base)
diff --git a/velox/functions/prestosql/types/parser/ParserUtil.cpp b/velox/functions/prestosql/types/parser/ParserUtil.cpp
new file mode 100644
index 000000000000..8fffec40908e
--- /dev/null
+++ b/velox/functions/prestosql/types/parser/ParserUtil.cpp
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <string>
+#include "velox/type/Type.h"
+
+namespace facebook::velox::functions::prestosql {
+
+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 == true && inferredType == nullptr) {
+    VELOX_UNSUPPORTED("Failed to parse type [{}]. Type not registered.", type);
+  }
+  return inferredType;
+}
+
+TypePtr customTypeWithChildren(
+    const std::string& name,
+    const std::vector<TypePtr>& children) {
+  std::vector<TypeParameter> params;
+  params.reserve(children.size());
+  for (auto& child : children) {
+    params.emplace_back(child);
+  }
+  auto type = getType(name, params);
+  VELOX_CHECK_NOT_NULL(
+      type, "Failed to parse custom type with children [{}]", name);
+  return type;
+}
+
+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 {
+std::array<int, 256> base32CharMap() {
+  std::array<int, 256> map{};
+  map.fill(-1);
+  const std::string base32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+  for (size_t i = 0; i < base32Chars.size(); ++i) {
+    char upper = base32Chars[i];
+    char lower = std::tolower(upper);
+    map[static_cast<unsigned char>(upper)] = static_cast<int>(i);
+    map[static_cast<unsigned char>(lower)] = static_cast<int>(i);
+  }
+  return map;
+}
+
+static const std::array<int, 256> base32Map = base32CharMap();
+
+std::string base32Decode(const std::string& encoded) {
+  std::vector<uint8_t> decodedBytes;
+  int buffer = 0;
+  int bitsLeft = 0;
+
+  for (char c : encoded) {
+    // Skip padding and whitespace.
+    if (c == '=' || std::isspace(static_cast<unsigned char>(c))) {
+      continue;
+    }
+
+    int val = base32Map[static_cast<unsigned char>(c)];
+    VELOX_CHECK_NE(
+        val,
+        -1,
+        "Failed to parse value {}, invalid Base32 character: {}",
+        encoded,
+        c);
+
+    buffer = (buffer << 5) | val;
+    bitsLeft += 5;
+    if (bitsLeft >= 8) {
+      bitsLeft -= 8;
+      decodedBytes.push_back((buffer >> bitsLeft) & 0xFF);
+    }
+  }
+  std::string decoded(decodedBytes.begin(), decodedBytes.end());
+
+  return decoded;
+}
+
+// The values map of the enum type is passed into this function in the format:
+// "[["CURIOUS",-2], ["HAPPY",0]]" as an array of key-value pairs (as opposed
+// to a JSON map like "{"CURIOUS":-2, "HAPPY":0}") so that the function can
+// fail on duplicate keys and values. folly::parseJson on a JSON map will
+// silently drop duplicate elements.
+template <typename T>
+std::unordered_map<std::string, T> parseMapFromString(
+    const std::string& input) {
+  folly::dynamic obj = folly::parseJson(input);
+  VELOX_CHECK(
+      obj.isArray(),
+      "Expected an array of key-value pairs for input: {}",
+      input);
+  std::unordered_map<std::string, T> result;
+  std::unordered_set<T> seenValues;
+
+  for (const auto& pair : obj) {
+    VELOX_CHECK(
+        pair.isArray() && pair.size() == 2 && pair[0].isString(),
+        "Failed to parse map: {}, each element must be have a string key.",
+        input);
+    std::string key = boost::algorithm::to_upper_copy(pair[0].asString());
+    VELOX_CHECK(
+        !result.contains(key),
+        "Failed to parse map: {}, duplicate key found: {}",
+        input,
+        key);
+    T value;
+    if constexpr (std::is_same_v<T, int64_t>) {
+      VELOX_CHECK(
+          pair[1].isInt(),
+          "Failed to parse map: {}, each element must have an integer value.",
+          input);
+      value = pair[1].asInt();
+    } else if constexpr (std::is_same_v<T, std::string>) {
+      VELOX_CHECK(
+          pair[1].isString(),
+          "Failed to parse map: {}, each element must have a string value.",
+          input);
+      // For a VarcharEnum map where the values are strings, the values from the
+      // Presto coordinator are received as base32-encoded strings to match the
+      // standard Presto TypeSignature format.
+      // Hence decode the value before creating a VarcharEnumParameter.
+      // https://github.com/prestodb/presto/blob/master/presto-common/src/main/java/com/facebook/presto/common/type/VarcharEnumType.java#L128
+      value = base32Decode(pair[1].asString());
+    } else {
+      VELOX_UNSUPPORTED(
+          "parseMapFromString is only supported for int64_t and std::string values.");
+    }
+    VELOX_CHECK(
+        seenValues.insert(value).second,
+        "Failed to parse map: {}, duplicate value found: {}",
+        input,
+        value);
+
+    result[key] = value;
+  }
+  return result;
+}
+} // namespace
+
+TypePtr getEnumType(
+    const std::string& enumType,
+    const std::string& enumName,
+    const std::string& valuesMap) {
+  std::vector<TypeParameter> params;
+  if (enumType == "BigintEnum") {
+    LongEnumParameter longEnumParameter(
+        enumName, parseMapFromString<int64_t>(valuesMap));
+    params.emplace_back(TypeParameter(longEnumParameter));
+    return getType("BIGINT_ENUM", params);
+  } else if (enumType == "VarcharEnum") {
+    VarcharEnumParameter varcharEnumParameter(
+        enumName, parseMapFromString<std::string>(valuesMap));
+    params.emplace_back(TypeParameter(varcharEnumParameter));
+    return getType("VARCHAR_ENUM", params);
+  }
+
+  VELOX_UNREACHABLE(
+      "Invalid type {}, expected BigintEnum or VarcharEnum", enumType);
+}
+} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/types/parser/ParserUtil.h b/velox/functions/prestosql/types/parser/ParserUtil.h
new file mode 100644
index 000000000000..9044e4e0b3c0
--- /dev/null
+++ b/velox/functions/prestosql/types/parser/ParserUtil.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 <string>
+#include "velox/type/Type.h"
+
+namespace facebook::velox::functions::prestosql {
+
+/// Normalize Presto types such as INT and DOUBLE PRECISION and convert to Velox
+/// type.
+TypePtr typeFromString(
+    const std::string& type,
+    bool failIfNotRegistered = true);
+
+TypePtr customTypeWithChildren(
+    const std::string& name,
+    const std::vector<TypePtr>& children);
+
+/// Creates a LongEnumParameter with the enumName and valuesMap and passes it in
+/// as a parameter to BIGINT_ENUM type to return an enum Type.
+/// The valuesMap is assumed to have a format of "[["CURIOUS",-2], ["HAPPY",0]]"
+/// so that folly::parseJson can be used to parse and throw on duplicate keys
+/// and/or values.
+TypePtr getEnumType(
+    const std::string& enumType,
+    const std::string& enumName,
+    const std::string& valuesMap);
+
+/// 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::functions::prestosql
diff --git a/velox/functions/prestosql/types/parser/Scanner.h b/velox/functions/prestosql/types/parser/Scanner.h
new file mode 100644
index 000000000000..2e212ca2aa0b
--- /dev/null
+++ b/velox/functions/prestosql/types/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::functions::prestosql {
+
+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::functions::prestosql
diff --git a/velox/functions/prestosql/types/parser/TypeParser.h b/velox/functions/prestosql/types/parser/TypeParser.h
new file mode 100644
index 000000000000..8098a58c4be6
--- /dev/null
+++ b/velox/functions/prestosql/types/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::functions::prestosql {
+
+/// 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::functions::prestosql
diff --git a/velox/functions/prestosql/types/parser/TypeParser.ll b/velox/functions/prestosql/types/parser/TypeParser.ll
new file mode 100644
index 000000000000..8bd29e4d2b7c
--- /dev/null
+++ b/velox/functions/prestosql/types/parser/TypeParser.ll
@@ -0,0 +1,85 @@
+%{
+#include <vector>
+#include <memory>
+#include <map>
+
+#include "velox/functions/prestosql/types/parser/TypeParser.yy.h"  // @manual
+#include "velox/functions/prestosql/types/parser/Scanner.h"
+#define YY_DECL int facebook::velox::functions::prestosql::Scanner::lex(facebook::velox::functions::prestosql::Parser::semantic_type *yylval)
+%}
+
+%option c++ noyywrap noyylineno nodefault caseless ecs
+
+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         (['"']([^"\n]|"")*['"'])
+NUMBER            ([[:digit:]]+)
+SIGNED_INT        (-?[[:digit:]]+)
+VARIABLE          (VARCHAR|VARBINARY)
+WORD_WITH_SPECIAL_CHAR ([^:({ ,]+)(\.([^:({ ,]+))(\.([^:({ ,]+))
+
+%%
+
+"("                return Parser::token::LPAREN;
+")"                return Parser::token::RPAREN;
+"{"                return Parser::token::LBRACE;
+"}"                return Parser::token::RBRACE;
+","                return Parser::token::COMMA;
+"."                return Parser::token::PERIOD;
+":"                return Parser::token::COLON;
+(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<long long>(YYText())); return Parser::token::NUMBER;
+{SIGNED_INT}       yylval->build<long long>(folly::to<long long>(YYText())); return Parser::token::SIGNED_INT;
+{WORD}             yylval->build<std::string>(YYText()); return Parser::token::WORD;
+{WORD_WITH_SPECIAL_CHAR}             yylval->build<std::string>(YYText()); return Parser::token::WORD_WITH_SPECIAL_CHAR;
+{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/functions/prestosql/types/parser/TypeParser.h"
+
+facebook::velox::TypePtr facebook::velox::functions::prestosql::parseType(const std::string& typeText)
+ {
+    std::istringstream is(typeText);
+    std::ostringstream os;
+    facebook::velox::TypePtr type;
+    facebook::velox::functions::prestosql::Scanner scanner{is, os, type, typeText};
+    facebook::velox::functions::prestosql::Parser parser{ &scanner };
+    parser.parse();
+    VELOX_CHECK(type, "Failed to parse type [{}]", typeText);
+    return type;
+}
diff --git a/velox/functions/prestosql/types/parser/TypeParser.yy b/velox/functions/prestosql/types/parser/TypeParser.yy
new file mode 100644
index 000000000000..705174822fae
--- /dev/null
+++ b/velox/functions/prestosql/types/parser/TypeParser.yy
@@ -0,0 +1,195 @@
+%{
+#include <FlexLexer.h>
+#include "velox/common/base/Exceptions.h"
+#include "velox/type/Type.h"
+#include "velox/functions/prestosql/types/parser/ParserUtil.h"
+%}
+%require "3.0.4"
+%language "C++"
+
+%define parser_class_name {Parser}
+%define api.namespace {facebook::velox::functions::prestosql}
+%define api.value.type variant
+%parse-param {Scanner* scanner}
+%define parse.error verbose
+
+%code requires
+{
+    namespace facebook::velox::functions::prestosql {
+        class Scanner;
+    } // namespace facebook::velox::functions::prestosql
+    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/functions/prestosql/types/parser/Scanner.h>
+    #define yylex(x) scanner->lex(x)
+}
+
+%token               LPAREN RPAREN COMMA PERIOD COLON ARRAY MAP ROW FUNCTION DECIMAL LBRACE RBRACE
+%token <std::string> WORD VARIABLE QUOTED_ID WORD_WITH_SPECIAL_CHAR
+%token <long long>   NUMBER SIGNED_INT
+%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 custom_type_with_children enum_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 enum_name enum_kind enum_map_entry enum_map_entries enum_map_entries_json
+
+%start type_spec
+
+%%
+
+/* The grammar entry point. */
+type_spec : type                 { scanner->setType($1); }
+          | error                { yyerrok; }
+          ;
+
+type : type_single_word  { $$ = $1; }
+     | type_with_spaces  { $$ = facebook::velox::functions::prestosql::inferTypeWithSpaces($1, true).second; }
+     ;
+
+type_single_word : WORD         { $$ = facebook::velox::functions::prestosql::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; }
+             | custom_type_with_children { $$ = $1; }
+             | enum_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  { $$ = facebook::velox::functions::prestosql::typeFromString($1); }
+              | VARIABLE                       { $$ = facebook::velox::functions::prestosql::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)); }
+         ;
+
+custom_type_with_children : WORD LPAREN type_list RPAREN { $$ = facebook::velox::functions::prestosql::customTypeWithChildren($1, $3); }
+
+/* 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        { $$ = facebook::velox::functions::prestosql::inferTypeWithSpaces($1, false); }
+           | QUOTED_ID type          { $1.erase(0, 1); $1.pop_back(); $$ = std::make_pair($1, $2); }  // Remove the quotes.
+           ;
+
+/*
+ * Enum types have a format of:
+ * "test.enum.mood:BigintEnum(test.enum.mood{"CURIOUS":2, "HAPPY":0})"
+ * where "test.enum.mood" is the enum name, "BigintEnum" is the enum kind,
+ * and "CURIOUS":2, "HAPPY":0 are the enum values.
+ * These values are passed as parameters to BIGINT_ENUM type.
+ */
+enum_map_entries : enum_map_entry { $$ = $1; }
+            | enum_map_entries COMMA enum_map_entry { $$ = $1 + ", " + $3; }
+            ;
+
+/*
+ * Formats the values map like "[["CURIOUS",-2], ["HAPPY",0]]"
+ * so that it can be parsed as an array of pairs using folly::parseJson in getEnumType.
+ */
+enum_map_entries_json : LBRACE enum_map_entries RBRACE {$$ = "[" + $2 + "]"; }
+                    ;
+
+enum_map_entry : QUOTED_ID COLON SIGNED_INT {  $$ = "[" + $1 + "," + std::to_string($3) + "]"; }
+               | QUOTED_ID COLON NUMBER     {  $$ = "[" + $1 + "," + std::to_string($3) + "]"; }
+               | QUOTED_ID COLON QUOTED_ID  {  $$ = "[" + $1 + "," + $3 + "]"; }
+               ;
+
+enum_kind : WORD { if ($1 != "BigintEnum" && $1 != "VarcharEnum" )
+                    {
+                        std::string msg = "Invalid type " + $1 + ", expected BigintEnum or VarcharEnum";
+                        error(msg.c_str());
+                    }
+                $$ = $1; }
+                ;
+
+enum_name : WORD_WITH_SPECIAL_CHAR { $$ = $1; }
+          ;
+
+enum_type : enum_name COLON enum_kind LPAREN enum_name enum_map_entries_json RPAREN
+          { $$ = getEnumType($3, $1, $6); }
+          ;
+
+%%
+
+void facebook::velox::functions::prestosql::Parser::error(const std::string& msg) {
+  VELOX_UNSUPPORTED("Failed to parse type [{}]. {}", scanner->input(), msg);
+}
diff --git a/velox/functions/prestosql/types/parser/tests/CMakeLists.txt b/velox/functions/prestosql/types/parser/tests/CMakeLists.txt
new file mode 100644
index 000000000000..fa67a839c74b
--- /dev/null
+++ b/velox/functions/prestosql/types/parser/tests/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_executable(velox_presto_type_parser_test TypeParserTest.cpp)
+
+add_test(NAME velox_presto_type_parser_test COMMAND velox_presto_type_parser_test)
+
+target_link_libraries(
+  velox_presto_type_parser_test
+  velox_presto_type_parser
+  velox_presto_types
+  velox_type
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
+)
diff --git a/velox/functions/prestosql/types/parser/tests/TypeParserTest.cpp b/velox/functions/prestosql/types/parser/tests/TypeParserTest.cpp
new file mode 100644
index 000000000000..c1e702f37df0
--- /dev/null
+++ b/velox/functions/prestosql/types/parser/tests/TypeParserTest.cpp
@@ -0,0 +1,606 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/types/BigintEnumRegistration.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
+#include "velox/functions/prestosql/types/VarcharEnumRegistration.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
+#include "velox/functions/prestosql/types/parser/TypeParser.h"
+
+namespace facebook::velox::functions::prestosql {
+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;
+}
+
+static const TypePtr& TIME_WITH_TIME_ZONE() {
+  static const TypePtr instance{new CustomType()};
+  return instance;
+}
+
+class TypeFactory : public CustomTypeFactory {
+ public:
+  TypeFactory(const TypePtr& type) : type_(type) {}
+
+  TypePtr getType(
+      const std::vector<TypeParameter>& /*parameters*/) const override {
+    return type_;
+  }
+
+  exec::CastOperatorPtr getCastOperator() const override {
+    return nullptr;
+  }
+
+  AbstractInputGeneratorPtr getInputGenerator(
+      const InputGeneratorConfig& /*config*/) 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 TypeFactory>(JSON()));
+    registerCustomType(
+        "timestamp with time zone",
+        std::make_unique<const TypeFactory>(TIMESTAMP_WITH_TIME_ZONE()));
+    registerCustomType(
+        "time with time zone",
+        std::make_unique<const TypeFactory>(TIME_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, charType) {
+  VELOX_ASSERT_UNSUPPORTED_THROW(parseType("char"), "");
+  VELOX_ASSERT_UNSUPPORTED_THROW(parseType("char(4)"), "");
+}
+
+TEST_F(TypeParserTest, varbinary) {
+  ASSERT_EQ(*parseType("varbinary"), *VARBINARY());
+}
+
+TEST_F(TypeParserTest, time) {
+  ASSERT_EQ(*parseType("time"), *TIME());
+}
+
+TEST_F(TypeParserTest, timeWithTimeZoneType) {
+  ASSERT_EQ(*parseType("time with time zone"), *TIME_WITH_TIME_ZONE());
+}
+
+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 RPAREN");
+
+  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_UNSUPPORTED_THROW(
+      parseType("rowxxx(a)"), "Failed to parse type [a]. Type not registered.");
+}
+
+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_UNSUPPORTED_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_UNSUPPORTED_THROW(
+      parseType("asd bigint"),
+      "Failed to parse type [asd bigint]. Type not registered.");
+}
+
+TEST_F(TypeParserTest, typesWithSpaces) {
+  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()}));
+
+  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 filed name with special characters & spaces
+  ASSERT_EQ(
+      *parseType("row(\"Nested Some more weirdtt +- \\:\\: charact\" varchar)"),
+      *ROW({"Nested Some more weirdtt +- \\:\\: charact"}, {VARCHAR()}));
+
+  // quoted field name with invalid type with spaces.
+  VELOX_ASSERT_UNSUPPORTED_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())}));
+}
+
+TEST_F(TypeParserTest, bigintEnumBasic) {
+  registerBigintEnumType();
+  LongEnumParameter moodInfo("test.enum.mood", {{"CURIOUS", 2}, {"HAPPY", 0}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":2, \"HAPPY\":0})"),
+      *BIGINT_ENUM(moodInfo));
+
+  // Parse negative integers.
+  LongEnumParameter moodWithNegativeValue(
+      "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})"),
+      *BIGINT_ENUM(moodWithNegativeValue));
+
+  // Parse large integers.
+  LongEnumParameter moodWithLargeValue(
+      "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 106071912278278}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":106071912278278})"),
+      *BIGINT_ENUM(moodWithLargeValue));
+
+  // Enum name with special characters.
+  LongEnumParameter enumInfoWithSpecialChar(
+      "test.en\\um.\"mood", {{"CURIOUS", 2}, {"HAPPY", 0}});
+  auto enumWithSpecialCharString =
+      "test.en\\um.\"mood:BigintEnum(test.en\\um.\"mood{\"CURIOUS\": 2, \"HAPPY\": 0})";
+  ASSERT_EQ(
+      *parseType(enumWithSpecialCharString),
+      *BIGINT_ENUM(enumInfoWithSpecialChar));
+
+  // Enum names should be in the format catalog.namespace.enum_name. This is
+  // because enum types are part of a UserDefinedType, which has a
+  // 3-part QualifiedObjectName as the type name.
+  auto otherEnumString =
+      "someEnumType:BigintEnum(someEnumType{\"CURIOUS\": 2, \"HAPPY\": 0})";
+  VELOX_ASSERT_THROW(
+      parseType(otherEnumString),
+      "Failed to parse type [someEnumType:BigintEnum(someEnumType{\"CURIOUS\": 2, \"HAPPY\": 0})]. syntax error, unexpected COLON, expecting WORD");
+
+  // Array type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "array(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":2, \"HAPPY\":0}))"),
+      *ARRAY(BIGINT_ENUM(moodInfo)));
+
+  // Map type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "map(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}), bigint)"),
+      *MAP(BIGINT_ENUM(moodWithNegativeValue), BIGINT()));
+  ASSERT_EQ(
+      *parseType(
+          "map(bigint,test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}))"),
+      *MAP(BIGINT(), BIGINT_ENUM(moodWithNegativeValue)));
+
+  // Row type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "row(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}))"),
+      *ROW({BIGINT_ENUM(moodWithNegativeValue)}));
+  ASSERT_EQ(
+      *parseType(
+          "row(c0 test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2,\"HAPPY\":0}))"),
+      *ROW({"c0"}, {BIGINT_ENUM(moodWithNegativeValue)}));
+}
+
+TEST_F(TypeParserTest, invalidBigintEnums) {
+  // Duplicate keys.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"CURIOUS\":0})"),
+      "Failed to parse map: [[\"CURIOUS\",-2], [\"CURIOUS\",0]], duplicate key found: CURIOUS");
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"Curious\":0})"),
+      "Failed to parse map: [[\"CURIOUS\",-2], [\"Curious\",0]], duplicate key found: CURIOUS");
+
+  // Duplicate values.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":-2})"),
+      "Failed to parse map: [[\"CURIOUS\",-2], [\"HAPPY\",-2]], duplicate value found: -2");
+
+  // Invalid enum type SmallintEnum.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:SmallintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})"),
+      "Failed to parse type [test.enum.mood:SmallintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})]. Invalid type SmallintEnum, expected BigintEnum or VarcharEnum");
+
+  // Invalid format: missing ":"
+  VELOX_ASSERT_THROW(
+      parseType("testNoColon(test.enum.mood{“CURIOUS”:-2, “HAPPY”:0})"),
+      "Failed to parse type [testNoColon(test.enum.mood{“CURIOUS”:-2, “HAPPY”:0})]. syntax error, unexpected LBRACE, expecting COLON");
+
+  // Invalid format: missing "("
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.moodCURIOUS”:-2, “HAPPY”:0})"),
+      "Failed to parse type [test.enum.mood:BigintEnum(test.enum.moodCURIOUS”:-2, “HAPPY”:0})]. syntax error, unexpected COLON, expecting LBRACE");
+
+  // Invalid enum type with non integral values.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": \"varchar value\", \"HAPPY\": \"0\"})"),
+      "Failed to parse map: [[\"CURIOUS\",\"varchar value\"], [\"HAPPY\",\"0\"]], each element must have an integer value.");
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": 1.1, \"HAPPY\": -1.0})"),
+      "Failed to parse type [test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": 1.1, \"HAPPY\": -1.0})]. syntax error, unexpected PERIOD, expecting COMMA or RBRACE");
+}
+
+TEST_F(TypeParserTest, varcharEnumBasic) {
+  registerVarcharEnumType();
+  VarcharEnumParameter moodInfo(
+      "test.enum.mood",
+      {{"CURIOUS", "someValue"},
+       {"HAPPY", "some value"},
+       {"SAD", "SOME VALUE"}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})"),
+      *VARCHAR_ENUM(moodInfo));
+
+  auto sameEnumDiffOrderMap =
+      "test.enum.mood:VarcharEnum(test.enum.mood{\"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
+  ASSERT_EQ(*parseType(sameEnumDiffOrderMap), *VARCHAR_ENUM(moodInfo));
+
+  // Enum name with special characters.
+  VarcharEnumParameter moodInfoSpecialChars(
+      "test.enum.\"mood/someMood\"",
+      {{"CURIOUS", "someValue"},
+       {"HAPPY", "some value"},
+       {"SAD", "SOME VALUE"}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.\"mood/someMood\":VarcharEnum(test.enum.\"mood/someMood\"{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})"),
+      *VARCHAR_ENUM(moodInfoSpecialChars));
+
+  // Enum names should be in the format catalog.namespace.enum_name. This is
+  // because enum types are part of a UserDefinedType, which has a
+  // 3-part QualifiedObjectName as the type name.
+  auto otherEnumString =
+      "someEnumType:VarcharEnum(someEnumType{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
+  VELOX_ASSERT_THROW(
+      parseType(otherEnumString),
+      "Failed to parse type [someEnumType:VarcharEnum(someEnumType{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})]. syntax error, unexpected COLON, expecting WORD");
+
+  // Array type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "array(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
+      *ARRAY(VARCHAR_ENUM(moodInfo)));
+
+  // Map type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "map(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}), bigint)"),
+      *MAP(VARCHAR_ENUM(moodInfo), BIGINT()));
+  ASSERT_EQ(
+      *parseType(
+          "map(bigint,test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
+      *MAP(BIGINT(), VARCHAR_ENUM(moodInfo)));
+
+  // Row type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "row(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
+      *ROW({VARCHAR_ENUM(moodInfo)}));
+  ASSERT_EQ(
+      *parseType(
+          "row(c0 test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
+      *ROW({"c0"}, {VARCHAR_ENUM(moodInfo)}));
+}
+
+TEST_F(TypeParserTest, invalidVarcharEnums) {
+  // Duplicate keys or values.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"CURIOUS\":\"ONXW2ZJAOZQWY5LF\"})"),
+      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"CURIOUS\",\"ONXW2ZJAOZQWY5LF\"]], duplicate key found: CURIOUS");
+
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"curious\":\"ONXW2ZJAOZQWY5LF\"})"),
+      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"curious\",\"ONXW2ZJAOZQWY5LF\"]], duplicate key found: CURIOUS");
+
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZKWMFWHKZI=\"})"),
+      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"HAPPY\",\"ONXW2ZKWMFWHKZI=\"]], duplicate value found: someValue");
+
+  // Invalid base 32 encoded values.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"12345\", \"HAPPY\":\"ONXW2ZKWMFWHKZI=\"})"),
+      "Failed to parse value 12345, invalid Base32 character: 1");
+
+  // Invalid format: missing ":"
+  VELOX_ASSERT_THROW(
+      parseType(
+          "testNoColon(test.enum.mood{\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})"),
+      "Failed to parse type [testNoColon(test.enum.mood{\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})]. syntax error, unexpected LBRACE, expecting COLON");
+
+  // Invalid format: missing "{"
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})"),
+      "Failed to parse type [test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})]. syntax error, unexpected COLON, expecting LBRACE");
+
+  // Invalid enum type with values of different types.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\": 0, \"HAPPY\":\"happy\"})"),
+      "Failed to parse map: [[\"CURIOUS\",0], [\"HAPPY\",\"happy\"]], each element must have a string value.");
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\": 0, \"HAPPY\":1})"),
+      "Failed to parse map: [[\"CURIOUS\",0], [\"HAPPY\",1]], each element must have a string value.");
+}
+} // namespace
+} // namespace facebook::velox::functions::prestosql
diff --git a/velox/functions/prestosql/types/tests/BigintEnumTypeTest.cpp b/velox/functions/prestosql/types/tests/BigintEnumTypeTest.cpp
new file mode 100644
index 000000000000..28f5a13ba1f1
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/BigintEnumTypeTest.cpp
@@ -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.
+ */
+#include "velox/functions/prestosql/types/BigintEnumType.h"
+#include "velox/functions/prestosql/types/BigintEnumRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox {
+namespace {
+class BigintEnumTypeTest : public testing::Test, public test::TypeTestBase {
+ protected:
+  BigintEnumTypeTest() {
+    registerBigintEnumType();
+    LongEnumParameter moodInfo(
+        "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
+    moodEnum_ = BIGINT_ENUM(moodInfo);
+  }
+
+  BigintEnumTypePtr moodEnum_;
+};
+
+TEST_F(BigintEnumTypeTest, basic) {
+  ASSERT_TRUE(hasType("BIGINT_ENUM"));
+  LongEnumParameter moodInfo("test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
+  std::vector<TypeParameter> moodParams = {TypeParameter(moodInfo)};
+  ASSERT_EQ(getType("BIGINT_ENUM", moodParams), moodEnum_);
+
+  ASSERT_STREQ(moodEnum_->name(), "BIGINT_ENUM");
+  ASSERT_STREQ(moodEnum_->kindName(), "BIGINT");
+  ASSERT_EQ(moodEnum_->enumName(), "test.enum.mood");
+  ASSERT_EQ(moodEnum_->parameters().size(), 1);
+  ASSERT_EQ(
+      moodEnum_->toString(),
+      "test.enum.mood:BigintEnum({\"CURIOUS\": -2, \"HAPPY\": 0})");
+
+  // Different TypeParameters with different enumName, same enumMap
+  LongEnumParameter differentNameSameMap(
+      "test.enum.mood2", {{"CURIOUS", -2}, {"HAPPY", 0}});
+  ASSERT_NE(moodEnum_, BIGINT_ENUM(differentNameSameMap));
+  EXPECT_FALSE(moodEnum_->equivalent(*BIGINT_ENUM(differentNameSameMap)));
+
+  // Different TypeParameters with same enumName, different enumMap
+  LongEnumParameter sameNameDifferentMap(
+      "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}, {"ANGRY", 1}});
+  ASSERT_NE(moodEnum_, BIGINT_ENUM(sameNameDifferentMap));
+  EXPECT_FALSE(moodEnum_->equivalent(*BIGINT_ENUM(sameNameDifferentMap)));
+
+  // Type Parameter with duplicate value in the enum map.
+  LongEnumParameter duplicateValuesInfo(
+      "duplicate.values.enum", {{"HAPPY", 0}, {"SAD", 0}, {"ANGRY", 0}});
+  VELOX_ASSERT_THROW(
+      BIGINT_ENUM(duplicateValuesInfo),
+      "Invalid enum type duplicate.values.enum, contains duplicate value 0");
+
+  // Different TypeParameters with same enumName and enumMap but in different
+  // order
+  LongEnumParameter differentOrderMapMoodInfo(
+      "test.enum.mood", {{"HAPPY", 0}, {"CURIOUS", -2}});
+  ASSERT_EQ(moodEnum_, BIGINT_ENUM(differentOrderMapMoodInfo));
+  EXPECT_TRUE(moodEnum_->equivalent(*BIGINT_ENUM(differentOrderMapMoodInfo)));
+}
+
+TEST_F(BigintEnumTypeTest, serde) {
+  testTypeSerde(moodEnum_);
+}
+
+TEST_F(BigintEnumTypeTest, keyAt) {
+  // Test existing values
+  ASSERT_EQ(moodEnum_->keyAt(-2), "CURIOUS");
+  ASSERT_EQ(moodEnum_->keyAt(0), "HAPPY");
+
+  // Test non-existent value
+  ASSERT_EQ(moodEnum_->keyAt(999), std::nullopt);
+}
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/types/tests/BingTileTypeTest.cpp b/velox/functions/prestosql/types/tests/BingTileTypeTest.cpp
index 16ed1c7bead7..9b4f75eca045 100644
--- a/velox/functions/prestosql/types/tests/BingTileTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/BingTileTypeTest.cpp
@@ -34,6 +34,8 @@ TEST_F(BingTileTypeTest, basic) {
 
   ASSERT_TRUE(hasType("BINGTILE"));
   ASSERT_EQ(*getType("BINGTILE", {}), *BINGTILE());
+
+  ASSERT_FALSE(BINGTILE()->isOrderable());
 }
 
 TEST_F(BingTileTypeTest, serde) {
@@ -134,10 +136,12 @@ TEST_F(BingTileTypeTest, bingTileChildren) {
                                         uint32_t y,
                                         uint8_t zoom,
                                         uint8_t childZoom,
+                                        uint8_t maxZoomShift,
                                         std::optional<std::string> errorMsg) {
     uint64_t tile = BingTileType::bingTileCoordsToInt(x, y, zoom);
     int32_t shift = childZoom - zoom;
-    auto childrenResult = BingTileType::bingTileChildren(tile, childZoom);
+    auto childrenResult =
+        BingTileType::bingTileChildren(tile, childZoom, maxZoomShift);
     if (errorMsg.has_value()) {
       ASSERT_TRUE(childrenResult.hasError());
       ASSERT_EQ(errorMsg.value(), childrenResult.error());
@@ -167,17 +171,25 @@ TEST_F(BingTileTypeTest, bingTileChildren) {
     }
   };
 
-  testBingTileChildren(0, 0, 0, 0, std::nullopt);
-  testBingTileChildren(0, 0, 0, 1, std::nullopt);
-  testBingTileChildren(0, 0, 0, 2, std::nullopt);
-  testBingTileChildren(1, 1, 1, 2, std::nullopt);
-  testBingTileChildren(0, 127, 8, 12, std::nullopt);
-  testBingTileChildren(0, 127, 8, 8, std::nullopt);
-  testBingTileChildren((1 << 21) - 1, 1 << 20, 21, 23, std::nullopt);
-  testBingTileChildren((1 << 18) - 1, 1 << 17, 18, 23, std::nullopt);
-
-  testBingTileChildren(0, 0, 2, 1, "Child zoom 1 must be >= tile zoom 2");
-  testBingTileChildren(0, 0, 23, 24, "Child zoom 24 must be <= max zoom 23");
+  testBingTileChildren(0, 0, 0, 0, 23, std::nullopt);
+  testBingTileChildren(0, 0, 0, 1, 23, std::nullopt);
+  testBingTileChildren(0, 0, 0, 2, 23, std::nullopt);
+  testBingTileChildren(1, 1, 1, 2, 23, std::nullopt);
+  testBingTileChildren(0, 127, 8, 12, 23, std::nullopt);
+  testBingTileChildren(0, 127, 8, 8, 23, std::nullopt);
+  testBingTileChildren((1 << 21) - 1, 1 << 20, 21, 23, 23, std::nullopt);
+  testBingTileChildren((1 << 18) - 1, 1 << 17, 18, 23, 23, std::nullopt);
+
+  testBingTileChildren(0, 0, 2, 1, 23, "Child zoom 1 must be >= tile zoom 2");
+  testBingTileChildren(
+      0, 0, 23, 24, 23, "Child zoom 24 must be <= max zoom 23");
+  testBingTileChildren(
+      0,
+      0,
+      0,
+      6,
+      5,
+      "Difference between parent zoom (0) and child zoom (6) must be <= 5");
 }
 
 TEST_F(BingTileTypeTest, bingTileToQuadKey) {
diff --git a/velox/functions/prestosql/types/tests/CMakeLists.txt b/velox/functions/prestosql/types/tests/CMakeLists.txt
index 20f23a95f222..7098b86e8b66 100644
--- a/velox/functions/prestosql/types/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/types/tests/CMakeLists.txt
@@ -15,26 +15,37 @@
 add_executable(
   velox_presto_types_test
   BingTileTypeTest.cpp
-  GeometryTypeTest.cpp
   HyperLogLogTypeTest.cpp
   JsonTypeTest.cpp
+  KHyperLogLogTypeTest.cpp
   TimestampWithTimeZoneTypeTest.cpp
+  TimeWithTimezoneTypeTest.cpp
   TDigestTypeTest.cpp
   QDigestTypeTest.cpp
+  SetDigestTypeTest.cpp
   TypeTestBase.cpp
   UuidTypeTest.cpp
   IPAddressTypeTest.cpp
-  IPPrefixTypeTest.cpp)
+  IPPrefixTypeTest.cpp
+)
+
+if(VELOX_ENABLE_GEO)
+  target_sources(
+    velox_presto_types_test
+    PRIVATE GeometryTypeTest.cpp SphericalGeographyTypeTest.cpp
+  )
+endif()
 
 add_test(velox_presto_types_test velox_presto_types_test)
 
 target_link_libraries(
   velox_presto_types_test
   velox_presto_types
-  velox_type_parser
+  velox_presto_type_parser
   Folly::folly
   GTest::gtest
   GTest::gtest_main
   GTest::gmock
   gflags::gflags
-  glog::glog)
+  glog::glog
+)
diff --git a/velox/functions/prestosql/types/tests/GeometryTypeTest.cpp b/velox/functions/prestosql/types/tests/GeometryTypeTest.cpp
index 0577f72fd90a..0beb9f3f91a3 100644
--- a/velox/functions/prestosql/types/tests/GeometryTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/GeometryTypeTest.cpp
@@ -29,12 +29,14 @@ class GeometryTypeTest : public testing::Test, public TypeTestBase {
 
 TEST_F(GeometryTypeTest, basic) {
   ASSERT_EQ(GEOMETRY()->name(), "GEOMETRY");
-  ASSERT_EQ(GEOMETRY()->kindName(), "VARBINARY");
+  ASSERT_STREQ(GEOMETRY()->kindName(), "VARBINARY");
   ASSERT_TRUE(GEOMETRY()->parameters().empty());
   ASSERT_EQ(GEOMETRY()->toString(), "GEOMETRY");
 
   ASSERT_TRUE(hasType("GEOMETRY"));
   ASSERT_EQ(*getType("GEOMETRY", {}), *GEOMETRY());
+
+  ASSERT_FALSE(GEOMETRY()->isOrderable());
 }
 
 TEST_F(GeometryTypeTest, serde) {
diff --git a/velox/functions/prestosql/types/tests/HyperLogLogTypeTest.cpp b/velox/functions/prestosql/types/tests/HyperLogLogTypeTest.cpp
index 3f12ce6b25a3..5de866547e6b 100644
--- a/velox/functions/prestosql/types/tests/HyperLogLogTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/HyperLogLogTypeTest.cpp
@@ -34,6 +34,8 @@ TEST_F(HyperLogLogTypeTest, basic) {
 
   ASSERT_TRUE(hasType("HYPERLOGLOG"));
   ASSERT_EQ(*getType("HYPERLOGLOG", {}), *HYPERLOGLOG());
+
+  ASSERT_FALSE(HYPERLOGLOG()->isOrderable());
 }
 
 TEST_F(HyperLogLogTypeTest, serde) {
diff --git a/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp b/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp
index 2e15f7fb3a9e..f01ed98cae26 100644
--- a/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/IPAddressTypeTest.cpp
@@ -25,7 +25,7 @@ class IPAddressTypeTest : public testing::Test, public TypeTestBase {
     registerIPAddressType();
   }
 
-  int128_t getIPv6asInt128FromStringUnchecked(const std::string& ipAddr) {
+  int128_t getIPv6asInt128FromStringUnchecked(std::string_view ipAddr) {
     auto ret = ipaddress::tryGetIPv6asInt128FromString(ipAddr);
     return ret.value();
   }
diff --git a/velox/functions/prestosql/types/tests/JsonTypeTest.cpp b/velox/functions/prestosql/types/tests/JsonTypeTest.cpp
index 84e2eebe7a72..9e248d236485 100644
--- a/velox/functions/prestosql/types/tests/JsonTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/JsonTypeTest.cpp
@@ -34,6 +34,8 @@ TEST_F(JsonTypeTest, basic) {
 
   ASSERT_TRUE(hasType("JSON"));
   ASSERT_EQ(*getType("JSON", {}), *JSON());
+
+  ASSERT_FALSE(JSON()->isOrderable());
 }
 
 TEST_F(JsonTypeTest, serde) {
diff --git a/velox/functions/prestosql/types/tests/KHyperLogLogTypeTest.cpp b/velox/functions/prestosql/types/tests/KHyperLogLogTypeTest.cpp
new file mode 100644
index 000000000000..25a6d694d1e1
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/KHyperLogLogTypeTest.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/functions/prestosql/types/KHyperLogLogType.h"
+#include "velox/functions/prestosql/types/KHyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class KHyperLogLogTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  KHyperLogLogTypeTest() {
+    registerKHyperLogLogType();
+  }
+};
+
+TEST_F(KHyperLogLogTypeTest, basic) {
+  ASSERT_STREQ(KHYPERLOGLOG()->name(), "KHYPERLOGLOG");
+  ASSERT_EQ(KHYPERLOGLOG()->toString(), "KHYPERLOGLOG");
+  ASSERT_FALSE(KHYPERLOGLOG()->isOrderable());
+  ASSERT_TRUE(KHYPERLOGLOG()->equivalent(*KHYPERLOGLOG()));
+  ASSERT_FALSE(KHYPERLOGLOG()->equivalent(*BIGINT()));
+
+  ASSERT_TRUE(hasType("KHYPERLOGLOG"));
+  ASSERT_EQ(*getType("KHYPERLOGLOG", {}), *KHYPERLOGLOG());
+}
+
+TEST_F(KHyperLogLogTypeTest, isKHyperLogLogType) {
+  ASSERT_TRUE(isKHyperLogLogType(KHYPERLOGLOG()));
+  ASSERT_FALSE(isKHyperLogLogType(BIGINT()));
+  ASSERT_FALSE(isKHyperLogLogType(VARBINARY()));
+}
+
+TEST_F(KHyperLogLogTypeTest, serde) {
+  testTypeSerde(KHYPERLOGLOG());
+}
+
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/P4HyperLogLogTypeTest.cpp b/velox/functions/prestosql/types/tests/P4HyperLogLogTypeTest.cpp
new file mode 100644
index 000000000000..1947d2ddbca6
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/P4HyperLogLogTypeTest.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 "velox/functions/prestosql/types/P4HyperLogLogType.h"
+#include "velox/functions/prestosql/types/P4HyperLogLogRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class P4HyperLogLogTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  P4HyperLogLogTypeTest() {
+    registerP4HyperLogLogType();
+  }
+};
+
+TEST_F(P4HyperLogLogTypeTest, basic) {
+  ASSERT_STREQ(P4HYPERLOGLOG()->name(), "P4HYPERLOGLOG");
+  ASSERT_STREQ(P4HYPERLOGLOG()->kindName(), "VARBINARY");
+  ASSERT_TRUE(P4HYPERLOGLOG()->parameters().empty());
+  ASSERT_EQ(P4HYPERLOGLOG()->toString(), "P4HYPERLOGLOG");
+
+  ASSERT_TRUE(hasType("P4HYPERLOGLOG"));
+  ASSERT_EQ(*getType("P4HYPERLOGLOG", {}), *P4HYPERLOGLOG());
+
+  ASSERT_FALSE(P4HYPERLOGLOG()->isOrderable());
+}
+
+TEST_F(P4HyperLogLogTypeTest, serde) {
+  testTypeSerde(P4HYPERLOGLOG());
+}
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/QDigestTypeTest.cpp b/velox/functions/prestosql/types/tests/QDigestTypeTest.cpp
index 80dee7d07534..94388f58deed 100644
--- a/velox/functions/prestosql/types/tests/QDigestTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/QDigestTypeTest.cpp
@@ -15,8 +15,8 @@
  */
 #include "velox/functions/prestosql/types/QDigestType.h"
 #include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/parser/TypeParser.h"
 #include "velox/functions/prestosql/types/tests/TypeTestBase.h"
-#include "velox/type/parser/TypeParser.h"
 
 namespace facebook::velox::test {
 namespace {
@@ -39,6 +39,8 @@ TEST_F(QDigestTypeTest, basic) {
 
     ASSERT_TRUE(hasType("QDIGEST"));
     ASSERT_EQ(*getType("QDIGEST", {TypeParameter(parameterType)}), *type);
+
+    ASSERT_FALSE(type->isOrderable());
   };
   testType("QDIGEST(BIGINT)", BIGINT());
   testType("QDIGEST(REAL)", REAL());
@@ -52,9 +54,15 @@ TEST_F(QDigestTypeTest, serde) {
 }
 
 TEST_F(QDigestTypeTest, parse) {
-  ASSERT_EQ(*parseType("qdigest(bigint)"), *QDIGEST(BIGINT()));
-  ASSERT_EQ(*parseType("qdigest(real)"), *QDIGEST(REAL()));
-  ASSERT_EQ(*parseType("qdigest(double)"), *QDIGEST(DOUBLE()));
+  ASSERT_EQ(
+      *facebook::velox::functions::prestosql::parseType("qdigest(bigint)"),
+      *QDIGEST(BIGINT()));
+  ASSERT_EQ(
+      *facebook::velox::functions::prestosql::parseType("qdigest(real)"),
+      *QDIGEST(REAL()));
+  ASSERT_EQ(
+      *facebook::velox::functions::prestosql::parseType("qdigest(double)"),
+      *QDIGEST(DOUBLE()));
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/types/tests/SetDigestTypeTest.cpp b/velox/functions/prestosql/types/tests/SetDigestTypeTest.cpp
new file mode 100644
index 000000000000..f1ff72bf0df7
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/SetDigestTypeTest.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/functions/prestosql/types/SetDigestType.h"
+#include "velox/functions/prestosql/types/SetDigestRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class SetDigestTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  SetDigestTypeTest() {
+    registerSetDigestType();
+  }
+};
+
+TEST_F(SetDigestTypeTest, basic) {
+  ASSERT_STREQ(SETDIGEST()->name(), "SETDIGEST");
+  ASSERT_STREQ(SETDIGEST()->kindName(), "VARBINARY");
+  ASSERT_TRUE(SETDIGEST()->parameters().empty());
+  ASSERT_EQ(SETDIGEST()->toString(), "SETDIGEST");
+
+  ASSERT_TRUE(hasType("SETDIGEST"));
+  ASSERT_EQ(*getType("SETDIGEST", {}), *SETDIGEST());
+
+  ASSERT_FALSE(SETDIGEST()->isOrderable());
+}
+
+TEST_F(SetDigestTypeTest, isSetDigestType) {
+  ASSERT_TRUE(isSetDigestType(SETDIGEST()));
+  ASSERT_FALSE(isSetDigestType(BIGINT()));
+  ASSERT_FALSE(isSetDigestType(VARBINARY()));
+}
+
+TEST_F(SetDigestTypeTest, serde) {
+  testTypeSerde(SETDIGEST());
+}
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/SphericalGeographyTypeTest.cpp b/velox/functions/prestosql/types/tests/SphericalGeographyTypeTest.cpp
new file mode 100644
index 000000000000..2a256ef115c3
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/SphericalGeographyTypeTest.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/functions/prestosql/types/SphericalGeographyType.h"
+#include "velox/functions/prestosql/types/SphericalGeographyRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox::test {
+
+class SphericalGeographyTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  SphericalGeographyTypeTest() {
+    registerSphericalGeographyType();
+  }
+};
+
+TEST_F(SphericalGeographyTypeTest, basic) {
+  ASSERT_EQ(SPHERICAL_GEOGRAPHY()->name(), "SPHERICALGEOGRAPHY");
+  ASSERT_STREQ(SPHERICAL_GEOGRAPHY()->kindName(), "VARBINARY");
+  ASSERT_TRUE(SPHERICAL_GEOGRAPHY()->parameters().empty());
+  ASSERT_EQ(SPHERICAL_GEOGRAPHY()->toString(), "SPHERICALGEOGRAPHY");
+
+  ASSERT_TRUE(hasType("SPHERICALGEOGRAPHY"));
+  ASSERT_EQ(*getType("SPHERICALGEOGRAPHY", {}), *SPHERICAL_GEOGRAPHY());
+
+  ASSERT_FALSE(SPHERICAL_GEOGRAPHY()->isOrderable());
+}
+
+TEST_F(SphericalGeographyTypeTest, serde) {
+  testTypeSerde(SPHERICAL_GEOGRAPHY());
+}
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/TDigestTypeTest.cpp b/velox/functions/prestosql/types/tests/TDigestTypeTest.cpp
index 4f99d83bedf4..7d2d5695c654 100644
--- a/velox/functions/prestosql/types/tests/TDigestTypeTest.cpp
+++ b/velox/functions/prestosql/types/tests/TDigestTypeTest.cpp
@@ -15,8 +15,8 @@
  */
 #include "velox/functions/prestosql/types/TDigestType.h"
 #include "velox/functions/prestosql/types/TDigestRegistration.h"
+#include "velox/functions/prestosql/types/parser/TypeParser.h"
 #include "velox/functions/prestosql/types/tests/TypeTestBase.h"
-#include "velox/type/parser/TypeParser.h"
 
 namespace facebook::velox::test {
 namespace {
@@ -36,6 +36,8 @@ TEST_F(TDigestTypeTest, basic) {
 
   ASSERT_TRUE(hasType("TDIGEST"));
   ASSERT_EQ(*getType("TDIGEST", {TypeParameter(DOUBLE())}), *TDIGEST(DOUBLE()));
+
+  ASSERT_FALSE(TDIGEST(DOUBLE())->isOrderable());
 }
 
 TEST_F(TDigestTypeTest, serde) {
@@ -43,7 +45,9 @@ TEST_F(TDigestTypeTest, serde) {
 }
 
 TEST_F(TDigestTypeTest, parse) {
-  ASSERT_EQ(*parseType("tdigest(double)"), *TDIGEST(DOUBLE()));
+  ASSERT_EQ(
+      *facebook::velox::functions::prestosql::parseType("tdigest(double)"),
+      *TDIGEST(DOUBLE()));
 }
 
 } // namespace
diff --git a/velox/functions/prestosql/types/tests/TimeWithTimezoneTypeTest.cpp b/velox/functions/prestosql/types/tests/TimeWithTimezoneTypeTest.cpp
new file mode 100644
index 000000000000..fef6266b85d5
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/TimeWithTimezoneTypeTest.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/TimeWithTimezoneType.h"
+#include "velox/functions/prestosql/types/TimeWithTimezoneRegistration.h"
+#include "velox/functions/prestosql/types/TimestampWithTimeZoneType.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+#include "velox/type/Time.h"
+
+namespace facebook::velox::test {
+
+class TimeWithTimezoneTypeTest : public testing::Test, public TypeTestBase {
+ public:
+  TimeWithTimezoneTypeTest() {
+    registerTimeWithTimezoneType();
+  }
+};
+
+// Basic type properties test - similar to TimestampWithTimeZoneTypeTest
+TEST_F(TimeWithTimezoneTypeTest, basic) {
+  auto type = TIME_WITH_TIME_ZONE();
+
+  // Test type name and properties
+  ASSERT_STREQ(type->name(), "TIME WITH TIME ZONE");
+  ASSERT_STREQ(type->kindName(), "BIGINT");
+  ASSERT_EQ(type->toString(), "TIME WITH TIME ZONE");
+
+  // Test that type is registered and can be retrieved
+  ASSERT_TRUE(hasType("time with time zone"));
+  auto retrievedType = getType("time with time zone", {});
+  ASSERT_TRUE(retrievedType != nullptr);
+}
+
+// Test serialization/deserialization - similar to TimestampWithTimeZoneTypeTest
+TEST_F(TimeWithTimezoneTypeTest, serde) {
+  testTypeSerde(TIME_WITH_TIME_ZONE());
+}
+
+// Test type equivalence
+TEST_F(TimeWithTimezoneTypeTest, equivalent) {
+  auto type1 = TIME_WITH_TIME_ZONE();
+  auto type2 = TIME_WITH_TIME_ZONE();
+
+  // Since it's a singleton, they should be equivalent
+  ASSERT_TRUE(type1->equivalent(*type2));
+  ASSERT_TRUE(type2->equivalent(*type1));
+
+  // Test with different type
+  auto bigintType = BIGINT();
+  ASSERT_FALSE(type1->equivalent(*bigintType));
+}
+
+// Test basic properties
+TEST_F(TimeWithTimezoneTypeTest, properties) {
+  auto type = TIME_WITH_TIME_ZONE();
+
+  ASSERT_TRUE(type->isOrderable());
+  ASSERT_TRUE(type->isComparable());
+}
+
+// Test value to string conversion
+// Note: TIME WITH TIME ZONE stores time in UTC and displays it in local time
+// by adding the timezone offset to the UTC value
+TEST_F(TimeWithTimezoneTypeTest, valueToString) {
+  auto type = TIME_WITH_TIME_ZONE();
+  char buffer[TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize];
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+
+  // Test midnight UTC (00:00:00.000 UTC) at UTC+00:00
+  int64_t timeValue = 0;
+  int16_t timeZone = util::biasEncode(0); // UTC
+  auto value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "00:00:00.000+00:00");
+
+  // Test 01:00:00.000 UTC at UTC+00:00
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  value = util::pack(3600000, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "01:00:00.000+00:00");
+
+  // Test UTC 12:30:45.123 with UTC+00:00 → displays as 12:30:45.123+00:00
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeValue = 12 * 3600000 + 30 * 60000 + 45 * 1000 + 123;
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "12:30:45.123+00:00");
+
+  // Test UTC 12:30:45.123 with UTC-08:00 (PST)
+  // → displays as 04:30:45.123-08:00 (12:30 - 8h = 04:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(-480); // PST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "04:30:45.123-08:00");
+
+  // Test UTC 12:30:45.123 with UTC-05:00 (EST)
+  // → displays as 07:30:45.123-05:00 (12:30 - 5h = 07:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(-300); // EST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "07:30:45.123-05:00");
+
+  // Test UTC 12:30:45.123 with UTC+00:00 (GMT)
+  // → displays as 12:30:45.123+00:00
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(0); // GMT
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "12:30:45.123+00:00");
+
+  // Test UTC 12:30:45.123 with UTC+01:00 (BST)
+  // → displays as 13:30:45.123+01:00 (12:30 + 1h = 13:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(60); // BST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "13:30:45.123+01:00");
+
+  // Test UTC 12:30:45.123 with UTC+09:00 (JST)
+  // → displays as 21:30:45.123+09:00 (12:30 + 9h = 21:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(540); // JST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "21:30:45.123+09:00");
+
+  // Test UTC 12:30:45.123 with UTC+10:00 (AEST)
+  // → displays as 22:30:45.123+10:00 (12:30 + 10h = 22:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(600); // AEST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "22:30:45.123+10:00");
+
+  // Test UTC 12:30:45.123 with UTC+11:00 (AEDT)
+  // → displays as 23:30:45.123+11:00 (12:30 + 11h = 23:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(660); // AEDT
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "23:30:45.123+11:00");
+
+  // Test UTC 12:30:45.123 with UTC+13:00 (NZST)
+  // → displays as 01:30:45.123+13:00 (12:30 + 13h = 25:30 → wraps to 01:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(780); // NZST
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "01:30:45.123+13:00");
+
+  // Test UTC 12:30:45.123 with UTC+14:00 (NZDT)
+  // → displays as 02:30:45.123+14:00 (12:30 + 14h = 26:30 → wraps to 02:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(840); // NZDT
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "02:30:45.123+14:00");
+
+  // Test UTC 12:30:45.123 with UTC-14:00
+  // → displays as 22:30:45.123-14:00 (12:30 - 14h = -1:30 → wraps to 22:30)
+  std::memset(
+      buffer, 0, TimeWithTimezoneType::kTimeWithTimezoneToVarcharRowSize);
+  timeZone = util::biasEncode(-840); // UTC-14:00
+  value = util::pack(timeValue, timeZone);
+  ASSERT_EQ(type->valueToString(value, buffer), "22:30:45.123-14:00");
+}
+
+TEST_F(TimeWithTimezoneTypeTest, compare) {
+  auto compare = [](int32_t expected, int64_t left, int64_t right) {
+    ASSERT_EQ(expected, TIME_WITH_TIME_ZONE()->compare(left, right));
+  };
+
+  // Same UTC time: "12:30:45.123+01:00" == "11:30:45.123+00:00"
+  compare(
+      0,
+      util::pack(41445123, util::biasEncode(60)),
+      util::pack(41445123, util::biasEncode(0)));
+
+  // Different UTC times: "10:00:00.000+01:00" < "15:00:00.000+01:00"
+  compare(
+      -1,
+      util::pack(32400000, util::biasEncode(60)),
+      util::pack(50400000, util::biasEncode(60)));
+  // "15:00:00.000+01:00" > "10:00:00.000+01:00"
+  compare(
+      1,
+      util::pack(50400000, util::biasEncode(60)),
+      util::pack(32400000, util::biasEncode(60)));
+  // "10:00:00.000+01:00" < "15:00:00.000+03:00"
+  compare(
+      -1,
+      util::pack(32400000, util::biasEncode(60)),
+      util::pack(43200000, util::biasEncode(180)));
+
+  // Wrap-around normalization: "00:00:00.000+01:00" < "23:59:59.999+03:00"
+  compare(
+      -1,
+      util::pack(82800000, util::biasEncode(60)),
+      util::pack(75599999, util::biasEncode(180)));
+  // "15:00:00.000+03:00" > "10:00:00.000+01:00"
+  compare(
+      1,
+      util::pack(43200000, util::biasEncode(180)),
+      util::pack(32400000, util::biasEncode(60)));
+  // "23:59:59.999+03:00" > "00:00:00.000+01:00"
+  compare(
+      1,
+      util::pack(75599999, util::biasEncode(180)),
+      util::pack(82800000, util::biasEncode(60)));
+}
+
+TEST_F(TimeWithTimezoneTypeTest, hash) {
+  auto expectHashesEq = [](int64_t millis1,
+                           int16_t tzOffsetMinutes1,
+                           int64_t millis2,
+                           int16_t tzOffsetMinutes2) {
+    int64_t left = util::pack(millis1, util::biasEncode(tzOffsetMinutes1));
+    int64_t right = util::pack(millis2, util::biasEncode(tzOffsetMinutes2));
+
+    ASSERT_EQ(
+        TIME_WITH_TIME_ZONE()->hash(left), TIME_WITH_TIME_ZONE()->hash(right));
+  };
+
+  auto expectHashesNeq = [](int64_t millis1,
+                            int16_t tzOffsetMinutes1,
+                            int64_t millis2,
+                            int16_t tzOffsetMinutes2) {
+    int64_t left = util::pack(millis1, util::biasEncode(tzOffsetMinutes1));
+    int64_t right = util::pack(millis2, util::biasEncode(tzOffsetMinutes2));
+
+    ASSERT_NE(
+        TIME_WITH_TIME_ZONE()->hash(left), TIME_WITH_TIME_ZONE()->hash(right));
+  };
+
+  expectHashesEq(45045123, 60, 45045123, 180);
+  expectHashesEq(45045123, 60, 45045123, -840);
+  expectHashesEq(45045123, 180, 45045123, -840);
+  expectHashesEq(0, 180, 0, -840);
+
+  expectHashesNeq(36000000, 60, 54000000, 180);
+  expectHashesNeq(36000000, 60, 54000000, -840);
+  expectHashesNeq(36000000, 180, 54000000, -840);
+  expectHashesNeq(0, 180, 86399999, -840);
+}
+
+} // namespace facebook::velox::test
diff --git a/velox/functions/prestosql/types/tests/VarcharEnumTypeTest.cpp b/velox/functions/prestosql/types/tests/VarcharEnumTypeTest.cpp
new file mode 100644
index 000000000000..4ca7e25b34fd
--- /dev/null
+++ b/velox/functions/prestosql/types/tests/VarcharEnumTypeTest.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/prestosql/types/VarcharEnumType.h"
+#include "velox/functions/prestosql/types/VarcharEnumRegistration.h"
+#include "velox/functions/prestosql/types/tests/TypeTestBase.h"
+
+namespace facebook::velox {
+namespace {
+class VarcharEnumTypeTest : public testing::Test, public test::TypeTestBase {
+ protected:
+  VarcharEnumTypeTest() {
+    registerVarcharEnumType();
+    VarcharEnumParameter colorInfo(
+        "test.enum.color", {{"RED", "red"}, {"BLUE", "blue"}});
+    colorEnum_ = VARCHAR_ENUM(colorInfo);
+  }
+
+  VarcharEnumTypePtr colorEnum_;
+};
+
+TEST_F(VarcharEnumTypeTest, basic) {
+  ASSERT_TRUE(hasType("VARCHAR_ENUM"));
+  VarcharEnumParameter colorInfo(
+      "test.enum.color", {{"RED", "red"}, {"BLUE", "blue"}});
+  std::vector<TypeParameter> colorParams = {TypeParameter(colorInfo)};
+  ASSERT_EQ(getType("VARCHAR_ENUM", colorParams), colorEnum_);
+
+  ASSERT_STREQ(colorEnum_->name(), "VARCHAR_ENUM");
+  ASSERT_STREQ(colorEnum_->kindName(), "VARCHAR");
+  ASSERT_EQ(colorEnum_->enumName(), "test.enum.color");
+  ASSERT_EQ(colorEnum_->parameters().size(), 1);
+  ASSERT_EQ(
+      colorEnum_->toString(),
+      "test.enum.color:VarcharEnum({\"BLUE\": \"blue\", \"RED\": \"red\"})");
+
+  // Different TypeParameters with different enumName, same enumMap
+  VarcharEnumParameter differentNameSameMap(
+      "test.enum.color2", {{"RED", "red"}, {"BLUE", "blue"}});
+  ASSERT_NE(colorEnum_, VARCHAR_ENUM(differentNameSameMap));
+  EXPECT_FALSE(colorEnum_->equivalent(*VARCHAR_ENUM(differentNameSameMap)));
+
+  // Different TypeParameters with same enumName, different enumMap
+  VarcharEnumParameter sameNameDifferentMap(
+      "test.enum.color",
+      {{"RED", "red"}, {"BLUE", "blue"}, {"GREEN", "green"}});
+  ASSERT_NE(colorEnum_, VARCHAR_ENUM(sameNameDifferentMap));
+  EXPECT_FALSE(colorEnum_->equivalent(*VARCHAR_ENUM(sameNameDifferentMap)));
+
+  // Type Parameter with duplicate value in the enum map.
+  VarcharEnumParameter duplicateValuesInfo(
+      "duplicate.values.enum",
+      {{"RED", "red"}, {"CRIMSON", "red"}, {"BLUE", "blue"}});
+  VELOX_ASSERT_THROW(
+      VARCHAR_ENUM(duplicateValuesInfo),
+      "Invalid enum type duplicate.values.enum, contains duplicate value red");
+
+  // Different TypeParameters with same enumName and enumMap but in different
+  // order
+  VarcharEnumParameter differentOrderMapColorInfo(
+      "test.enum.color", {{"BLUE", "blue"}, {"RED", "red"}});
+  ASSERT_EQ(colorEnum_, VARCHAR_ENUM(differentOrderMapColorInfo));
+  EXPECT_TRUE(
+      colorEnum_->equivalent(*VARCHAR_ENUM(differentOrderMapColorInfo)));
+}
+
+TEST_F(VarcharEnumTypeTest, serde) {
+  testTypeSerde(colorEnum_);
+}
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/functions/prestosql/window/CMakeLists.txt b/velox/functions/prestosql/window/CMakeLists.txt
index 2fa0b2f04f3c..17748049108e 100644
--- a/velox/functions/prestosql/window/CMakeLists.txt
+++ b/velox/functions/prestosql/window/CMakeLists.txt
@@ -20,11 +20,7 @@ velox_add_library(
   CumeDist.cpp
   FirstLastValue.cpp
   LeadLag.cpp
-  WindowFunctionsRegistration.cpp)
+  WindowFunctionsRegistration.cpp
+)
 
-velox_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/tests/CMakeLists.txt b/velox/functions/prestosql/window/tests/CMakeLists.txt
index 53b2167531dc..4172a082d70c 100644
--- a/velox/functions/prestosql/window/tests/CMakeLists.txt
+++ b/velox/functions/prestosql/window/tests/CMakeLists.txt
@@ -12,48 +12,40 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(CMAKE_WINDOW_TEST_LINK_LIBRARIES
-    velox_core
-    velox_exec
-    velox_exec_test_lib
-    velox_functions_window_test_lib
-    velox_vector_fuzzer
-    velox_vector_test_lib
-    velox_window
-    GTest::gtest
-    GTest::gtest_main)
+set(
+  CMAKE_WINDOW_TEST_LINK_LIBRARIES
+  velox_core
+  velox_exec
+  velox_exec_test_lib
+  velox_functions_window_test_lib
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  velox_window
+  GTest::gtest
+  GTest::gtest_main
+)
 
 set(CMAKE_WINDOW_TEST_MAIN_FILES Main.cpp)
 
-add_executable(velox_windows_rank_test NtileTest.cpp RankTest.cpp
-                                       ${CMAKE_WINDOW_TEST_MAIN_FILES})
+add_executable(velox_windows_rank_test NtileTest.cpp RankTest.cpp ${CMAKE_WINDOW_TEST_MAIN_FILES})
 
-add_test(
-  NAME velox_windows_rank_test
-  COMMAND velox_windows_rank_test
-  WORKING_DIRECTORY .)
+add_test(NAME velox_windows_rank_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})
+add_executable(
+  velox_windows_value_test
+  NthValueTest.cpp
+  LeadLagTest.cpp
+  ${CMAKE_WINDOW_TEST_MAIN_FILES}
+)
 
-add_test(
-  NAME velox_windows_value_test
-  COMMAND velox_windows_value_test
-  WORKING_DIRECTORY .)
+add_test(NAME velox_windows_value_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 AggregateWindowTest.cpp
-                                      ${CMAKE_WINDOW_TEST_MAIN_FILES})
+add_executable(velox_windows_agg_test AggregateWindowTest.cpp ${CMAKE_WINDOW_TEST_MAIN_FILES})
 
-add_test(
-  NAME velox_windows_agg_test
-  COMMAND velox_windows_agg_test
-  WORKING_DIRECTORY .)
+add_test(NAME velox_windows_agg_test COMMAND velox_windows_agg_test WORKING_DIRECTORY .)
 
-target_link_libraries(
-  velox_windows_agg_test ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
+target_link_libraries(velox_windows_agg_test ${CMAKE_WINDOW_TEST_LINK_LIBRARIES})
diff --git a/velox/functions/remote/benchmarks/CMakeLists.txt b/velox/functions/remote/benchmarks/CMakeLists.txt
index 1d458c012747..7f43058332ee 100644
--- a/velox/functions/remote/benchmarks/CMakeLists.txt
+++ b/velox/functions/remote/benchmarks/CMakeLists.txt
@@ -12,19 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_benchmark_local_remote_comparison
-               LocalRemoteComparisonBenchmark.cpp)
+add_executable(velox_benchmark_local_remote_comparison LocalRemoteComparisonBenchmark.cpp)
 
 target_link_libraries(
   velox_benchmark_local_remote_comparison
-  PUBLIC velox_type
-         velox_benchmark_builder
-         velox_vector_test_lib
-         velox_function_registry
-         velox_functions_lib
-         velox_functions_remote
-         velox_functions_remote_utils
-         Folly::folly
-         Folly::follybenchmark
-         gflags::gflags
-         glog::glog)
+  PUBLIC
+    velox_type
+    velox_benchmark_builder
+    velox_vector_test_lib
+    velox_function_registry
+    velox_functions_lib
+    velox_functions_remote
+    velox_functions_remote_utils
+    Folly::folly
+    Folly::follybenchmark
+    gflags::gflags
+    glog::glog
+)
diff --git a/velox/functions/remote/benchmarks/LocalRemoteComparisonBenchmark.cpp b/velox/functions/remote/benchmarks/LocalRemoteComparisonBenchmark.cpp
index 40354c2a412e..2914768e6262 100644
--- a/velox/functions/remote/benchmarks/LocalRemoteComparisonBenchmark.cpp
+++ b/velox/functions/remote/benchmarks/LocalRemoteComparisonBenchmark.cpp
@@ -36,7 +36,7 @@ int main(int argc, char** argv) {
   memory::MemoryManager::initialize(memory::MemoryManager::Options{});
 
   auto param = startLocalThriftServiceAndGetParams();
-  RemoteVectorFunctionMetadata metadata;
+  RemoteThriftVectorFunctionMetadata metadata;
   metadata.location = param.serverAddress;
 
   // Register the remote adapter for PlusFunction
diff --git a/velox/functions/remote/client/CMakeLists.txt b/velox/functions/remote/client/CMakeLists.txt
index 56663a29d04b..31153a7fde39 100644
--- a/velox/functions/remote/client/CMakeLists.txt
+++ b/velox/functions/remote/client/CMakeLists.txt
@@ -13,17 +13,21 @@
 # limitations under the License.
 
 velox_add_library(velox_functions_remote_thrift_client ThriftClient.cpp)
-velox_link_libraries(velox_functions_remote_thrift_client
-                     PUBLIC remote_function_thrift FBThrift::thriftcpp2)
+velox_link_libraries(
+  velox_functions_remote_thrift_client
+  PUBLIC remote_function_thrift FBThrift::thriftcpp2
+)
 
-velox_add_library(velox_functions_remote Remote.cpp)
+velox_add_library(velox_functions_remote Remote.cpp RemoteVectorFunction.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 429782e779b4..b09406a628ba 100644
--- a/velox/functions/remote/client/Remote.cpp
+++ b/velox/functions/remote/client/Remote.cpp
@@ -17,149 +17,48 @@
 #include "velox/functions/remote/client/Remote.h"
 
 #include <folly/io/async/EventBase.h>
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
+#include "velox/functions/remote/client/RemoteVectorFunction.h"
 #include "velox/functions/remote/client/ThriftClient.h"
 #include "velox/functions/remote/if/GetSerde.h"
 #include "velox/functions/remote/if/gen-cpp2/RemoteFunctionServiceAsyncClient.h"
-#include "velox/type/fbhive/HiveTypeSerializer.h"
-#include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::functions {
 namespace {
 
-std::string serializeType(const TypePtr& type) {
-  // Use hive type serializer.
-  return type::fbhive::HiveTypeSerializer::serialize(type);
-}
-
-class RemoteFunction : public exec::VectorFunction {
+class RemoteThriftFunction : public RemoteVectorFunction {
  public:
-  RemoteFunction(
+  RemoteThriftFunction(
       const std::string& functionName,
       const std::vector<exec::VectorFunctionArg>& inputArgs,
-      const RemoteVectorFunctionMetadata& metadata)
-      : functionName_(functionName),
+      const RemoteThriftVectorFunctionMetadata& metadata)
+      : RemoteVectorFunction(functionName, inputArgs, metadata),
         location_(metadata.location),
-        thriftClient_(getThriftClient(location_, &eventBase_)),
-        serdeFormat_(metadata.serdeFormat),
-        serde_(getSerde(serdeFormat_)) {
-    std::vector<TypePtr> types;
-    types.reserve(inputArgs.size());
-    serializedInputTypes_.reserve(inputArgs.size());
+        thriftClient_(getThriftClient(location_, &eventBase_)) {}
 
-    for (const auto& arg : inputArgs) {
-      types.emplace_back(arg.type);
-      serializedInputTypes_.emplace_back(serializeType(arg.type));
-    }
-    remoteInputType_ = ROW(std::move(types));
+  std::unique_ptr<remote::RemoteFunctionResponse> invokeRemoteFunction(
+      const remote::RemoteFunctionRequest& request) const override {
+    auto remoteResponse = std::make_unique<remote::RemoteFunctionResponse>();
+    thriftClient_->sync_invokeFunction(*remoteResponse, request);
+    return remoteResponse;
   }
 
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override {
-    try {
-      applyRemote(rows, args, outputType, context, result);
-    } catch (const VeloxRuntimeError&) {
-      throw;
-    } catch (const std::exception&) {
-      context.setErrors(rows, std::current_exception());
-    }
+  std::string remoteLocationToString() const override {
+    return location_.describe();
   }
 
  private:
-  void applyRemote(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& outputType,
-      exec::EvalCtx& context,
-      VectorPtr& result) const {
-    // Create type and row vector for serialization.
-    auto remoteRowVector = std::make_shared<RowVector>(
-        context.pool(),
-        remoteInputType_,
-        BufferPtr{},
-        rows.end(),
-        std::move(args));
-
-    // Send to remote server.
-    remote::RemoteFunctionResponse remoteResponse;
-    remote::RemoteFunctionRequest request;
-    request.throwOnError_ref() = context.throwOnError();
-
-    auto functionHandle = request.remoteFunctionHandle_ref();
-    functionHandle->name_ref() = functionName_;
-    functionHandle->returnType_ref() = serializeType(outputType);
-    functionHandle->argumentTypes_ref() = serializedInputTypes_;
-
-    auto requestInputs = request.inputs_ref();
-    requestInputs->rowCount_ref() = remoteRowVector->size();
-    requestInputs->pageFormat_ref() = serdeFormat_;
-
-    // TODO: serialize only active rows.
-    requestInputs->payload_ref() = rowVectorToIOBuf(
-        remoteRowVector, rows.end(), *context.pool(), serde_.get());
-
-    try {
-      thriftClient_->sync_invokeFunction(remoteResponse, request);
-    } catch (const std::exception& e) {
-      VELOX_FAIL(
-          "Error while executing remote function '{}' at '{}': {}",
-          functionName_,
-          location_.describe(),
-          e.what());
-    }
-
-    auto outputRowVector = IOBufToRowVector(
-        remoteResponse.result().value().payload().value(),
-        ROW({outputType}),
-        *context.pool(),
-        serde_.get());
-    result = outputRowVector->childAt(0);
-
-    if (auto errorPayload = remoteResponse.result().value().errorPayload()) {
-      auto errorsRowVector = IOBufToRowVector(
-          *errorPayload, ROW({VARCHAR()}), *context.pool(), serde_.get());
-      auto errorsVector =
-          errorsRowVector->childAt(0)->asFlatVector<StringView>();
-      VELOX_CHECK(errorsVector, "Should be convertible to flat vector");
-
-      SelectivityVector selectedRows(errorsRowVector->size());
-      selectedRows.applyToSelected([&](vector_size_t i) {
-        if (errorsVector->isNullAt(i)) {
-          return;
-        }
-        try {
-          throw std::runtime_error(errorsVector->valueAt(i));
-        } catch (const std::exception&) {
-          context.setError(i, std::current_exception());
-        }
-      });
-    }
-  }
-
-  const std::string functionName_;
   folly::SocketAddress location_;
-
   folly::EventBase eventBase_;
-  std::unique_ptr<RemoteFunctionClient> thriftClient_;
-  remote::PageFormat serdeFormat_;
-  std::unique_ptr<VectorSerde> serde_;
 
-  // Structures we construct once to cache:
-  RowTypePtr remoteInputType_;
-  std::vector<std::string> serializedInputTypes_;
+  std::unique_ptr<RemoteFunctionClient> thriftClient_;
 };
 
 std::shared_ptr<exec::VectorFunction> createRemoteFunction(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& /*config*/,
-    const RemoteVectorFunctionMetadata& metadata) {
-  return std::make_unique<RemoteFunction>(name, inputArgs, metadata);
+    const RemoteThriftVectorFunctionMetadata& metadata) {
+  return std::make_unique<RemoteThriftFunction>(name, inputArgs, metadata);
 }
 
 } // namespace
@@ -167,7 +66,7 @@ std::shared_ptr<exec::VectorFunction> createRemoteFunction(
 void registerRemoteFunction(
     const std::string& name,
     std::vector<exec::FunctionSignaturePtr> signatures,
-    const RemoteVectorFunctionMetadata& metadata,
+    const RemoteThriftVectorFunctionMetadata& metadata,
     bool overwrite) {
   exec::registerStatefulVectorFunction(
       name,
diff --git a/velox/functions/remote/client/Remote.h b/velox/functions/remote/client/Remote.h
index a6a1e773dc81..457d622bd92c 100644
--- a/velox/functions/remote/client/Remote.h
+++ b/velox/functions/remote/client/Remote.h
@@ -17,24 +17,21 @@
 #pragma once
 
 #include <folly/SocketAddress.h>
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/remote/if/gen-cpp2/RemoteFunction_types.h"
+#include "velox/functions/remote/client/RemoteVectorFunction.h"
 
 namespace facebook::velox::functions {
 
-struct RemoteVectorFunctionMetadata : public exec::VectorFunctionMetadata {
-  /// Network address of the servr to communicate with. Note that this can hold
-  /// a network location (ip/port pair) or a unix domain socket path (see
-  /// SocketAddress::makeFromPath()).
+struct RemoteThriftVectorFunctionMetadata
+    : public RemoteVectorFunctionMetadata {
+  /// Network address of the server to communicate with using a thrift client.
+  /// Note that this can hold a network location (ip/port pair) or a unix domain
+  /// socket path (see SocketAddress::makeFromPath()).
   folly::SocketAddress location;
-
-  /// The serialization format to be used
-  remote::PageFormat serdeFormat{remote::PageFormat::PRESTO_PAGE};
 };
 
 /// Registers a new remote function. It will use the meatadata defined in
-/// `RemoteVectorFunctionMetadata` to control the serialization format and
-/// remote server address.
+/// `RemoteThriftVectorFunctionMetadata` to control the serialization format,
+/// remote server address, and communicate with it using a thrift client.
 //
 /// Remote functions are registered as regular statufull functions (using the
 /// same internal catalog), and hence conflict if there already exists a
@@ -43,7 +40,7 @@ struct RemoteVectorFunctionMetadata : public exec::VectorFunctionMetadata {
 void registerRemoteFunction(
     const std::string& name,
     std::vector<exec::FunctionSignaturePtr> signatures,
-    const RemoteVectorFunctionMetadata& metadata = {},
+    const RemoteThriftVectorFunctionMetadata& metadata = {},
     bool overwrite = true);
 
 } // namespace facebook::velox::functions
diff --git a/velox/functions/remote/client/RemoteVectorFunction.cpp b/velox/functions/remote/client/RemoteVectorFunction.cpp
new file mode 100644
index 000000000000..b8758f068c95
--- /dev/null
+++ b/velox/functions/remote/client/RemoteVectorFunction.cpp
@@ -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.
+ */
+
+#include "velox/functions/remote/client/RemoteVectorFunction.h"
+
+#include "velox/expression/VectorFunction.h"
+#include "velox/functions/remote/if/GetSerde.h"
+#include "velox/type/fbhive/HiveTypeSerializer.h"
+
+namespace facebook::velox::functions {
+namespace {
+
+std::string serializeType(const TypePtr& type) {
+  // Use hive type serializer.
+  return type::fbhive::HiveTypeSerializer::serialize(type);
+}
+
+} // namespace
+
+RemoteVectorFunction::RemoteVectorFunction(
+    const std::string& functionName,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const RemoteVectorFunctionMetadata& metadata)
+    : functionName_(functionName),
+      serdeFormat_(metadata.serdeFormat),
+      serde_(getSerde(serdeFormat_)) {
+  std::vector<TypePtr> types;
+  types.reserve(inputArgs.size());
+  serializedInputTypes_.reserve(inputArgs.size());
+
+  for (const auto& arg : inputArgs) {
+    types.emplace_back(arg.type);
+    serializedInputTypes_.emplace_back(serializeType(arg.type));
+  }
+  remoteInputType_ = ROW(std::move(types));
+}
+
+void RemoteVectorFunction::apply(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    const TypePtr& outputType,
+    exec::EvalCtx& context,
+    VectorPtr& result) const {
+  try {
+    applyRemote(rows, args, outputType, context, result);
+  } catch (const VeloxRuntimeError&) {
+    throw;
+  } catch (const std::exception&) {
+    context.setErrors(rows, std::current_exception());
+  }
+}
+
+void RemoteVectorFunction::applyRemote(
+    const SelectivityVector& rows,
+    std::vector<VectorPtr>& args,
+    const TypePtr& outputType,
+    exec::EvalCtx& context,
+    VectorPtr& result) const {
+  // Create type and row vector for serialization.
+  auto remoteRowVector = std::make_shared<RowVector>(
+      context.pool(),
+      remoteInputType_,
+      BufferPtr{},
+      rows.end(),
+      std::move(args));
+
+  // Create the thrift payload.
+  remote::RemoteFunctionRequest request;
+  request.throwOnError_ref() = context.throwOnError();
+
+  auto functionHandle = request.remoteFunctionHandle_ref();
+  functionHandle->name_ref() = functionName_;
+  functionHandle->returnType_ref() = serializeType(outputType);
+  functionHandle->argumentTypes_ref() = serializedInputTypes_;
+
+  auto requestInputs = request.inputs_ref();
+  requestInputs->rowCount_ref() = remoteRowVector->size();
+  requestInputs->pageFormat_ref() = serdeFormat_;
+
+  // TODO: serialize only active rows.
+  requestInputs->payload_ref() = rowVectorToIOBuf(
+      remoteRowVector, rows.end(), *context.pool(), serde_.get());
+
+  std::unique_ptr<remote::RemoteFunctionResponse> remoteResponse;
+
+  // Invoke function that communicates with the remote host.
+  try {
+    remoteResponse = invokeRemoteFunction(request);
+  } catch (const std::exception& e) {
+    VELOX_FAIL(
+        "Error while executing remote function '{}' at '{}': {}",
+        functionName_,
+        remoteLocationToString(),
+        e.what());
+  }
+
+  const auto& remoteResult = remoteResponse->result().value();
+  auto outputRowVector = IOBufToRowVector(
+      remoteResult.payload().value(),
+      ROW({outputType}),
+      *context.pool(),
+      serde_.get());
+  result = outputRowVector->childAt(0);
+
+  if (auto errorPayload = remoteResult.errorPayload()) {
+    auto errorsRowVector = IOBufToRowVector(
+        *errorPayload, ROW({VARCHAR()}), *context.pool(), serde_.get());
+    auto errorsVector = errorsRowVector->childAt(0)->asFlatVector<StringView>();
+    VELOX_CHECK(
+        errorsVector,
+        "Remote function error payload should be convertible to flat vector.");
+
+    SelectivityVector selectedRows(errorsRowVector->size());
+    selectedRows.applyToSelected([&](vector_size_t i) {
+      if (errorsVector->isNullAt(i)) {
+        return;
+      }
+      try {
+        throw std::runtime_error(std::string(errorsVector->valueAt(i)));
+      } catch (const std::exception&) {
+        context.setError(i, std::current_exception());
+      }
+    });
+  }
+}
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/remote/client/RemoteVectorFunction.h b/velox/functions/remote/client/RemoteVectorFunction.h
new file mode 100644
index 000000000000..677b5acb153d
--- /dev/null
+++ b/velox/functions/remote/client/RemoteVectorFunction.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/expression/VectorFunction.h"
+#include "velox/functions/remote/if/gen-cpp2/RemoteFunction_types.h"
+#include "velox/vector/VectorStream.h"
+
+namespace facebook::velox::functions {
+
+struct RemoteVectorFunctionMetadata : public exec::VectorFunctionMetadata {
+  /// The serialization format to be used to send batches of data to the remote
+  /// process.
+  remote::PageFormat serdeFormat{remote::PageFormat::PRESTO_PAGE};
+};
+
+/// Main vector function logic. Needs to be extended with the transport-specific
+/// logic.
+class RemoteVectorFunction : public exec::VectorFunction {
+ public:
+  RemoteVectorFunction(
+      const std::string& functionName,
+      const std::vector<exec::VectorFunctionArg>& inputArgs,
+      const RemoteVectorFunctionMetadata& metadata);
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override;
+
+ protected:
+  // The actual function to communicates with the remote host.
+  virtual std::unique_ptr<remote::RemoteFunctionResponse> invokeRemoteFunction(
+      const remote::RemoteFunctionRequest& request) const = 0;
+
+  // A string representation of the remote host being connected to. Useful for
+  // exception messages.
+  virtual std::string remoteLocationToString() const = 0;
+
+ private:
+  void applyRemote(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const;
+
+  const std::string functionName_;
+
+  remote::PageFormat serdeFormat_;
+  std::unique_ptr<VectorSerde> serde_;
+
+  // Structures we construct once to cache:
+  RowTypePtr remoteInputType_;
+  std::vector<std::string> serializedInputTypes_;
+};
+
+} // namespace facebook::velox::functions
diff --git a/velox/functions/remote/client/tests/CMakeLists.txt b/velox/functions/remote/client/tests/CMakeLists.txt
index 15c8c6e00ebd..4ad70929b249 100644
--- a/velox/functions/remote/client/tests/CMakeLists.txt
+++ b/velox/functions/remote/client/tests/CMakeLists.txt
@@ -27,4 +27,5 @@ target_link_libraries(
   velox_functions_remote_utils
   GTest::gmock
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/functions/remote/client/tests/RemoteFunctionTest.cpp b/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
index af82db0810d1..712358753895 100644
--- a/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
+++ b/velox/functions/remote/client/tests/RemoteFunctionTest.cpp
@@ -84,7 +84,7 @@ class RemoteFunctionTest
 
   // Registers a few remote functions to be used in this test.
   void registerRemoteFunctions(RemoteFunctionServiceParams params) {
-    RemoteVectorFunctionMetadata metadata;
+    RemoteThriftVectorFunctionMetadata metadata;
     metadata.serdeFormat = GetParam();
     metadata.location = params.serverAddress;
 
@@ -103,7 +103,7 @@ class RemoteFunctionTest
                                .build()};
     registerRemoteFunction("remote_fail", failSignatures, metadata);
 
-    RemoteVectorFunctionMetadata wrongMetadata = metadata;
+    RemoteThriftVectorFunctionMetadata wrongMetadata = metadata;
     wrongMetadata.location = folly::SocketAddress(); // empty address.
     registerRemoteFunction("remote_wrong_port", plusSignatures, wrongMetadata);
 
@@ -167,17 +167,28 @@ TEST_P(RemoteFunctionTest, string) {
 }
 
 TEST_P(RemoteFunctionTest, tryException) {
-  // remote_divide throws if denominator is 0.
+  // `remote_divide` throws if denominator is 0.
   auto numeratorVector = makeFlatVector<double>({0, 1, 4, 9, 16});
   auto denominatorVector = makeFlatVector<double>({0, 1, 2, 3, 4});
-  auto data = makeRowVector({numeratorVector, denominatorVector});
-  auto results =
-      evaluate<SimpleVector<double>>("TRY(remote_divide(c0, c1))", data);
+  auto inputData = makeRowVector({numeratorVector, denominatorVector});
 
-  ASSERT_EQ(results->size(), 5);
-  auto expected = makeFlatVector<double>({0 /* doesn't matter*/, 1, 2, 3, 4});
-  expected->setNull(0, true);
+  auto executeRemote = [&]() {
+    return evaluate<SimpleVector<double>>("remote_divide(c0, c1)", inputData);
+  };
 
+  // Ensure it throws and the right exception is propagated.
+  EXPECT_THROW(executeRemote(), VeloxRuntimeError);
+  try {
+    executeRemote();
+  } catch (const VeloxRuntimeError& e) {
+    EXPECT_THAT(e.message(), testing::HasSubstr("division by zero"));
+  }
+
+  // Execute wih a try() to ensure exceptions are collected but not thrown.
+  auto results =
+      evaluate<SimpleVector<double>>("TRY(remote_divide(c0, c1))", inputData);
+  auto expected = makeNullableFlatVector<double>({std::nullopt, 1, 2, 3, 4});
+  ASSERT_EQ(results->size(), 5);
   assertEqualVectors(expected, results);
 }
 
@@ -216,8 +227,9 @@ TEST_P(RemoteFunctionTest, tryErrorCode) {
 TEST_P(RemoteFunctionTest, opaque) {
   // TODO: Support opaque type serialization in SPARK_UNSAFE_ROW
   if (GetParam() == remote::PageFormat::SPARK_UNSAFE_ROW) {
-    GTEST_SKIP()
+    LOG(WARNING)
         << "opaque type serialization not supported in SPARK_UNSAFE_ROW";
+    return;
   }
   auto inputVector = makeFlatVector<std::shared_ptr<void>>(
       2,
diff --git a/velox/functions/remote/if/CMakeLists.txt b/velox/functions/remote/if/CMakeLists.txt
index 9818b3cc350d..e88fe3cbdbf6 100644
--- a/velox/functions/remote/if/CMakeLists.txt
+++ b/velox/functions/remote/if/CMakeLists.txt
@@ -14,12 +14,17 @@
 
 include(FBThriftCppLibrary)
 
-add_fbthrift_cpp_library(remote_function_thrift RemoteFunction.thrift SERVICES
-                         RemoteFunctionService)
+add_fbthrift_cpp_library(
+  remote_function_thrift
+  RemoteFunction.thrift
+  SERVICES
+  RemoteFunctionService
+)
 
-target_compile_options(remote_function_thrift
-                       PRIVATE -Wno-deprecated-declarations)
+target_compile_options(remote_function_thrift PRIVATE -Wno-deprecated-declarations)
 
 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)
+velox_link_libraries(
+  velox_functions_remote_get_serde
+  PUBLIC remote_function_thrift velox_presto_serializer
+)
diff --git a/velox/functions/remote/if/RemoteFunction.thrift b/velox/functions/remote/if/RemoteFunction.thrift
index 559f0192c155..316261b82610 100644
--- a/velox/functions/remote/if/RemoteFunction.thrift
+++ b/velox/functions/remote/if/RemoteFunction.thrift
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+package "facebook.com/velox/functions"
+
 namespace cpp2 facebook.velox.functions.remote
 namespace java.swift com.facebook.spark.remotefunctionserver.api
 
diff --git a/velox/functions/remote/server/CMakeLists.txt b/velox/functions/remote/server/CMakeLists.txt
index ff2afa0fed6a..e193efbb6512 100644
--- a/velox/functions/remote/server/CMakeLists.txt
+++ b/velox/functions/remote/server/CMakeLists.txt
@@ -16,11 +16,13 @@ add_library(velox_functions_remote_server RemoteFunctionService.cpp)
 
 target_link_libraries(
   velox_functions_remote_server
-  PUBLIC remote_function_thrift velox_functions_remote_get_serde
-         velox_type_fbhive velox_memory)
+  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)
+  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 602ad8caa42b..29122e7af195 100644
--- a/velox/functions/remote/server/RemoteFunctionService.cpp
+++ b/velox/functions/remote/server/RemoteFunctionService.cpp
@@ -15,10 +15,11 @@
  */
 
 #include "velox/functions/remote/server/RemoteFunctionService.h"
-#include "velox/common/base/Exceptions.h"
+#include "velox/core/Expressions.h"
 #include "velox/expression/Expr.h"
 #include "velox/functions/remote/if/GetSerde.h"
 #include "velox/type/fbhive/HiveTypeParser.h"
+#include "velox/vector/FlatVector.h"
 #include "velox/vector/VectorStream.h"
 
 namespace facebook::velox::functions {
@@ -59,8 +60,9 @@ std::vector<core::TypedExprPtr> getExpressions(
     const std::string& functionName) {
   std::vector<core::TypedExprPtr> inputs;
   for (size_t i = 0; i < inputType->size(); ++i) {
-    inputs.push_back(std::make_shared<core::FieldAccessTypedExpr>(
-        inputType->childAt(i), inputType->nameOf(i)));
+    inputs.push_back(
+        std::make_shared<core::FieldAccessTypedExpr>(
+            inputType->childAt(i), inputType->nameOf(i)));
   }
 
   return {std::make_shared<core::CallTypedExpr>(
@@ -102,8 +104,8 @@ void RemoteFunctionServiceHandler::handleErrors(
       BufferPtr(),
       numRows,
       std::vector<VectorPtr>{flatVector});
-  result->errorPayload_ref() =
-      rowVectorToIOBuf(errorRowVector, *pool_, serde.get());
+  result->errorPayload() =
+      rowVectorToIOBufBatch(errorRowVector, *pool_, serde.get());
 }
 
 void RemoteFunctionServiceHandler::invokeFunction(
@@ -148,11 +150,11 @@ void RemoteFunctionServiceHandler::invokeFunction(
   auto outputRowVector = std::make_shared<RowVector>(
       pool_.get(), ROW({outputType}), BufferPtr(), numRows, expressionResult);
 
-  auto result = response.result_ref();
-  result->rowCount_ref() = outputRowVector->size();
-  result->pageFormat_ref() = serdeFormat;
-  result->payload_ref() =
-      rowVectorToIOBuf(outputRowVector, rows.end(), *pool_, serde.get());
+  auto result = response.result();
+  result->rowCount() = outputRowVector->size();
+  result->pageFormat() = serdeFormat;
+  result->payload() =
+      rowVectorToIOBufBatch(outputRowVector, rows.end(), *pool_, serde.get());
 
   auto evalErrors = evalCtx.errors();
   if (evalErrors != nullptr && evalErrors->hasError()) {
diff --git a/velox/functions/remote/utils/CMakeLists.txt b/velox/functions/remote/utils/CMakeLists.txt
index 51192297cf0c..fbf3c95640f2 100644
--- a/velox/functions/remote/utils/CMakeLists.txt
+++ b/velox/functions/remote/utils/CMakeLists.txt
@@ -14,6 +14,4 @@
 
 add_library(velox_functions_remote_utils RemoteFunctionServiceProvider.cpp)
 
-target_link_libraries(
-  velox_functions_remote_utils
-  PUBLIC velox_functions_remote_server)
+target_link_libraries(velox_functions_remote_utils PUBLIC velox_functions_remote_server)
diff --git a/velox/functions/sparksql/Arithmetic.h b/velox/functions/sparksql/Arithmetic.h
index 74b6a1ac98cb..215af7ab9967 100644
--- a/velox/functions/sparksql/Arithmetic.h
+++ b/velox/functions/sparksql/Arithmetic.h
@@ -28,6 +28,41 @@
 
 namespace facebook::velox::functions::sparksql {
 
+// The abs implementation is used for primitive types except for decimal type.
+template <typename TExec>
+struct AbsFunction {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const T* /*a*/) {
+    ansiEnabled_ = config.sparkAnsiEnabled();
+  }
+
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(T& result, const T& a) {
+    if constexpr (std::is_integral_v<T>) {
+      if (FOLLY_UNLIKELY(a == std::numeric_limits<T>::min())) {
+        if (ansiEnabled_) {
+          // In ANSI mode, returns an overflow error.
+          if (threadSkipErrorDetails()) {
+            return Status::UserError();
+          }
+          return Status::UserError("Arithmetic overflow: abs({})", a);
+        }
+        // In ANSI off mode, returns the same negative minimum value.
+        result = a;
+        return Status::OK();
+      }
+    }
+    result = std::abs(a);
+    return Status::OK();
+  }
+
+ private:
+  bool ansiEnabled_ = false;
+};
+
 template <typename T>
 struct RemainderFunction {
   template <
@@ -523,18 +558,15 @@ struct RIntFunction {
 
 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);
-      }
+      VELOX_USER_RETURN(
+          __builtin_add_overflow(a, b, &res),
+          "Arithmetic overflow: {} + {}",
+          a,
+          b);
       result = res;
     } else {
       result = a + b;
@@ -545,17 +577,14 @@ struct CheckedAddFunction {
 
 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);
-      }
+      VELOX_USER_RETURN(
+          __builtin_sub_overflow(a, b, &result),
+          "Arithmetic overflow: {} - {}",
+          a,
+          b);
     } else {
       result = a - b;
     }
@@ -565,17 +594,14 @@ struct CheckedSubtractFunction {
 
 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);
-      }
+      VELOX_USER_RETURN(
+          __builtin_mul_overflow(a, b, &result),
+          "Arithmetic overflow: {} * {}",
+          a,
+          b);
     } else {
       result = a * b;
     }
@@ -585,23 +611,56 @@ struct CheckedMultiplyFunction {
 
 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) {
+    VELOX_USER_RETURN_EQ(b, 0, "division by zero");
+    if constexpr (std::is_integral_v<T>) {
+      VELOX_USER_RETURN(
+          a == std::numeric_limits<T>::min() && b == -1,
+          "Arithmetic overflow: {} / {}",
+          a,
+          b);
+    }
+    result = a / b;
+    return Status::OK();
+  }
+};
+
+/// Implements integral division with truncation towards zero.
+/// Returns Null if divisor is 0.
+template <typename TExec>
+struct IntegralDivideFunction {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE bool call(int64_t& result, const T& a, const T& b) {
     if (b == 0) {
-      if (threadSkipErrorDetails()) {
-        return Status::UserError();
-      }
-      return Status::UserError("division by zero");
+      return false;
     }
-    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);
-      }
+    // In Java, Long.MIN_VALUE is -2^63 and Long.MAX_VALUE is 2^63 - 1.
+    // Dividing Long.MIN_VALUE by -1 overflows because the positive
+    // result (+2^63) cannot be represented in a signed 64-bit integer.
+    // Java integer arithmetic wraps around on overflow (two's complement),
+    // so Long.MIN_VALUE / -1 evaluates to Long.MIN_VALUE itself instead
+    // of throwing an exception.
+    if (a == std::numeric_limits<int64_t>::min() && b == -1) {
+      result = a;
+      return true;
     }
+
+    result = a / b;
+    return true;
+  }
+};
+
+/// Implements integral division with truncation towards zero.
+/// Returns Error if divisor is 0 or overflow.
+template <typename TExec>
+struct CheckedIntegralDivideFunction {
+  template <typename T>
+  FOLLY_ALWAYS_INLINE Status call(int64_t& result, const T& a, const T& b) {
+    VELOX_USER_RETURN_EQ(b, 0, "Division by zero");
+    VELOX_USER_RETURN(
+        a == std::numeric_limits<int64_t>::min() && b == -1,
+        "Overflow in integral divide");
     result = a / b;
     return Status::OK();
   }
diff --git a/velox/functions/sparksql/ArrayGetFunction.cpp b/velox/functions/sparksql/ArrayGetFunction.cpp
index 72d1726cb39d..f2e2c2ca4af2 100644
--- a/velox/functions/sparksql/ArrayGetFunction.cpp
+++ b/velox/functions/sparksql/ArrayGetFunction.cpp
@@ -39,12 +39,13 @@ class ArrayGetFunction : public SubscriptImpl<
 
     // array(T), tinyint|smallint|integer|bigint -> T
     for (const auto& indexType : {"tinyint", "smallint", "integer", "bigint"}) {
-      signatures.push_back(exec::FunctionSignatureBuilder()
-                               .typeVariable("T")
-                               .returnType("T")
-                               .argumentType("array(T)")
-                               .argumentType(indexType)
-                               .build());
+      signatures.push_back(
+          exec::FunctionSignatureBuilder()
+              .typeVariable("T")
+              .returnType("T")
+              .argumentType("array(T)")
+              .argumentType(indexType)
+              .build());
     }
 
     return signatures;
diff --git a/velox/functions/sparksql/ArraySort.cpp b/velox/functions/sparksql/ArraySort.cpp
index 4467bc3cae28..79f3f10e2d4a 100644
--- a/velox/functions/sparksql/ArraySort.cpp
+++ b/velox/functions/sparksql/ArraySort.cpp
@@ -14,243 +14,64 @@
  * limitations under the License.
  */
 #include "velox/functions/sparksql/ArraySort.h"
-
-#include <memory>
-#include "velox/common/base/Exceptions.h"
-#include "velox/expression/EvalCtx.h"
-#include "velox/expression/Expr.h"
-#include "velox/expression/VectorFunction.h"
-#include "velox/functions/lib/RowsTranslationUtil.h"
-#include "velox/functions/sparksql/Comparisons.h"
-#include "velox/type/Type.h"
-#include "velox/vector/BaseVector.h"
-#include "velox/vector/ComplexVector.h"
-#include "velox/vector/SelectivityVector.h"
-#include "velox/vector/SimpleVector.h"
-#include "velox/vector/TypeAliases.h"
+#include "velox/functions/sparksql/SimpleComparisonMatcher.h"
 
 namespace facebook::velox::functions::sparksql {
-namespace {
-
-void applyComplexType(
-    const SelectivityVector& rows,
-    ArrayVector* inputArray,
-    bool ascending,
-    bool nullsFirst,
-    exec::EvalCtx& context,
-    VectorPtr* resultElements) {
-  auto elementsVector = inputArray->elements();
-
-  // Allocate new vectors for indices.
-  BufferPtr indices = allocateIndices(elementsVector->size(), context.pool());
-  vector_size_t* rawIndices = indices->asMutable<vector_size_t>();
-
-  const CompareFlags flags{.nullsFirst = nullsFirst, .ascending = ascending};
-  // Note: Reusing offsets and sizes isn't safe if the input array had two
-  // arrays that had overlapping (but not identical) ranges in the input.
-  rows.applyToSelected([&](vector_size_t row) {
-    auto size = inputArray->sizeAt(row);
-    auto offset = inputArray->offsetAt(row);
-
-    for (auto i = 0; i < size; ++i) {
-      rawIndices[offset + i] = offset + i;
-    }
-    std::sort(
-        rawIndices + offset,
-        rawIndices + offset + size,
-        [&](vector_size_t& a, vector_size_t& b) {
-          return elementsVector->compare(elementsVector.get(), a, b, flags) < 0;
-        });
-  });
-
-  *resultElements = BaseVector::transpose(indices, std::move(elementsVector));
-}
-
-template <typename T>
-inline void swapWithNull(
-    FlatVector<T>* vector,
-    vector_size_t index,
-    vector_size_t nullIndex) {
-  // Values are already present in vector stringBuffers. Don't create additional
-  // copy.
-  if constexpr (std::is_same_v<T, StringView>) {
-    vector->setNoCopy(nullIndex, vector->valueAt(index));
-  } else {
-    vector->set(nullIndex, vector->valueAt(index));
-  }
-  vector->setNull(index, true);
-}
-
-template <TypeKind kind>
-void applyTyped(
-    const SelectivityVector& rows,
-    const ArrayVector* inputArray,
-    bool ascending,
-    bool nullsFirst,
-    exec::EvalCtx& context,
-    VectorPtr* resultElements) {
-  using T = typename TypeTraits<kind>::NativeType;
-
-  // Copy array elements to new vector.
-  const VectorPtr& inputElements = inputArray->elements();
-  SelectivityVector elementRows =
-      toElementRows(inputElements->size(), rows, inputArray);
-
-  *resultElements = BaseVector::create(
-      inputElements->type(), inputElements->size(), context.pool());
-  (*resultElements)
-      ->copy(inputElements.get(), elementRows, /*toSourceRow=*/nullptr);
-
-  auto flatResults = (*resultElements)->asFlatVector<T>();
-  T* resultRawValues = flatResults->mutableRawValues();
-
-  auto processRow = [&](vector_size_t row) {
-    auto size = inputArray->sizeAt(row);
-    auto offset = inputArray->offsetAt(row);
-    if (size == 0) {
-      return;
-    }
-    vector_size_t numNulls = 0;
-    if (nullsFirst) {
-      // Move nulls to beginning of array.
-      for (vector_size_t i = 0; i < size; ++i) {
-        if (flatResults->isNullAt(offset + i)) {
-          swapWithNull<T>(flatResults, offset + numNulls, offset + i);
-          ++numNulls;
-        }
-      }
-    } else {
-      // Move nulls to end of array.
-      for (vector_size_t i = size - 1; i >= 0; --i) {
-        if (flatResults->isNullAt(offset + i)) {
-          swapWithNull<T>(
-              flatResults, offset + size - numNulls - 1, offset + i);
-          ++numNulls;
-        }
-      }
-    }
-    // Exclude null values while sorting.
-    auto rowBegin = offset + (nullsFirst ? numNulls : 0);
-    auto rowEnd = rowBegin + size - numNulls;
-
-    if constexpr (kind == TypeKind::BOOLEAN) {
-      uint64_t* rawBits = flatResults->template mutableRawValues<uint64_t>();
-      auto numSetBits = bits::countBits(rawBits, rowBegin, rowEnd);
-      // If ascending, false is placed before true, otherwise true is placed
-      // before false.
-      bool smallerValue = !ascending;
-      auto mid = ascending ? rowEnd - numSetBits : rowBegin + numSetBits;
-      bits::fillBits(rawBits, rowBegin, mid, smallerValue);
-      bits::fillBits(rawBits, mid, rowEnd, !smallerValue);
-    } else {
-      if (ascending) {
-        std::sort(
-            resultRawValues + rowBegin, resultRawValues + rowEnd, Less<T>());
-      } else {
-        std::sort(
-            resultRawValues + rowBegin, resultRawValues + rowEnd, Greater<T>());
-      }
-    }
-  };
-
-  rows.applyToSelected(processRow);
-}
-} // namespace
-
-void ArraySort::apply(
-    const SelectivityVector& rows,
-    std::vector<VectorPtr>& args,
-    const TypePtr& /*outputType*/,
-    exec::EvalCtx& context,
-    VectorPtr& result) const {
-  auto& arg = args[0];
-
-  VectorPtr localResult;
-
-  // Input can be constant or flat.
-  if (arg->isConstantEncoding()) {
-    auto* constantArray = arg->as<ConstantVector<ComplexType>>();
-    const auto& flatArray = constantArray->valueVector();
-    const auto flatIndex = constantArray->index();
-
-    exec::LocalSingleRow singleRow(context, flatIndex);
-    localResult = applyFlat(*singleRow, flatArray, context);
-    localResult =
-        BaseVector::wrapInConstant(rows.end(), flatIndex, localResult);
-  } else {
-    localResult = applyFlat(rows, arg, context);
+std::shared_ptr<exec::VectorFunction> makeArraySortAsc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  // If the second argument is present, it must be a lambda.
+  if (inputArgs.size() == 2) {
+    return makeArraySortLambdaFunction(name, inputArgs, config, true, false);
   }
 
-  context.moveOrCopyResult(localResult, rows, result);
+  VELOX_CHECK_EQ(inputArgs.size(), 1);
+  // Nulls are considered largest.
+  return facebook::velox::functions::makeArraySort(
+      name,
+      inputArgs,
+      config,
+      true /*ascending*/,
+      false /*nullsFirst*/,
+      false /*throwOnNestedNull*/);
 }
 
-VectorPtr ArraySort::applyFlat(
-    const SelectivityVector& rows,
-    const VectorPtr& arg,
-    exec::EvalCtx& context) const {
-  ArrayVector* inputArray = arg->as<ArrayVector>();
-  VectorPtr resultElements;
-
-  auto typeKind = inputArray->elements()->typeKind();
-  if (typeKind == TypeKind::MAP || typeKind == TypeKind::ARRAY ||
-      typeKind == TypeKind::ROW) {
-    applyComplexType(
-        rows, inputArray, ascending_, nullsFirst_, context, &resultElements);
-  } else {
-    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-        applyTyped,
-        typeKind,
-        rows,
-        inputArray,
-        ascending_,
-        nullsFirst_,
-        context,
-        &resultElements);
-  }
-
-  return std::make_shared<ArrayVector>(
-      context.pool(),
-      inputArray->type(),
-      inputArray->nulls(),
-      rows.end(),
-      inputArray->offsets(),
-      inputArray->sizes(),
-      resultElements,
-      inputArray->getNullCount());
+std::shared_ptr<exec::VectorFunction> makeArraySortDesc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config) {
+  VELOX_CHECK_EQ(inputArgs.size(), 2);
+  return makeArraySortLambdaFunction(name, inputArgs, config, false, false);
 }
 
-// Signature: array_sort(array(T)) -> array(T)
-std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortSignatures() {
+// Signatures:
+//   array_sort_desc(array(T), function(T,U)) -> array(T)
+std::vector<std::shared_ptr<exec::FunctionSignature>>
+arraySortDescSignatures() {
   return {
       exec::FunctionSignatureBuilder()
-          .typeVariable("T")
-          .argumentType("array(T)")
+          .orderableTypeVariable("T")
+          .orderableTypeVariable("U")
           .returnType("array(T)")
+          .argumentType("array(T)")
+          .constantArgumentType("function(T,U)")
           .build(),
   };
 }
 
-std::shared_ptr<exec::VectorFunction> makeArraySort(
-    const std::string& name,
-    const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
-  VELOX_CHECK_EQ(inputArgs.size(), 1);
-  // Nulls are considered largest.
-  return std::make_shared<ArraySort>(/*ascending=*/true, /*nullsFirst=*/false);
-}
-
 // Signatures:
 //   sort_array(array(T)) -> array(T)
 //   sort_array(array(T), boolean) -> array(T)
 std::vector<std::shared_ptr<exec::FunctionSignature>> sortArraySignatures() {
   return {
       exec::FunctionSignatureBuilder()
-          .typeVariable("T")
+          .orderableTypeVariable("T")
           .argumentType("array(T)")
           .returnType("array(T)")
           .build(),
       exec::FunctionSignatureBuilder()
-          .typeVariable("T")
+          .orderableTypeVariable("T")
           .argumentType("array(T)")
           .constantArgumentType("boolean")
           .returnType("array(T)")
@@ -261,7 +82,7 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> sortArraySignatures() {
 std::shared_ptr<exec::VectorFunction> makeSortArray(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
-    const core::QueryConfig& /*config*/) {
+    const core::QueryConfig& config) {
   VELOX_CHECK(
       inputArgs.size() == 1 || inputArgs.size() == 2,
       "Invalid number of arguments {}, expected 1 or 2",
@@ -278,6 +99,13 @@ std::shared_ptr<exec::VectorFunction> makeSortArray(
   }
   // Nulls are considered smallest.
   bool nullsFirst = ascending;
-  return std::make_shared<ArraySort>(ascending, nullsFirst);
+  return facebook::velox::functions::makeArraySort(
+      name,
+      inputArgs,
+      config,
+      ascending /*ascending*/,
+      nullsFirst /*nullsFirst*/,
+      false /*throwOnNestedNull*/);
 }
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/ArraySort.h b/velox/functions/sparksql/ArraySort.h
index dd83018ef3a4..23f1d68f4431 100644
--- a/velox/functions/sparksql/ArraySort.h
+++ b/velox/functions/sparksql/ArraySort.h
@@ -15,53 +15,31 @@
  */
 #pragma once
 
-#include "velox/expression/VectorFunction.h"
+#include "velox/functions/lib/ArraySort.h"
 
 namespace facebook::velox::functions::sparksql {
 
-class ArraySort : public exec::VectorFunction {
-  /// This class implements generic array sort function. Takes an array as input
-  /// and sorts it according to provided comparator |Cmp| as template parameter.
-  /// Additionally |nullsFirst| ctor parameter can be used to configure nulls
-  /// sort order. If |nullsFirst| is  true nulls are moved to front of array,
-  ///  otherwise nulls are moved to end of array.
-  ///
-  /// Sorts floating points as per following ascending order:
-  /// -Inf < Inf < NaN
-
- public:
-  explicit ArraySort(bool ascending, bool nullsFirst)
-      : ascending_(ascending), nullsFirst_(nullsFirst) {}
-
-  void apply(
-      const SelectivityVector& rows,
-      std::vector<VectorPtr>& args,
-      const TypePtr& /* outputType */,
-      exec::EvalCtx& context,
-      VectorPtr& result) const override;
-
- private:
-  VectorPtr applyFlat(
-      const SelectivityVector& rows,
-      const VectorPtr& arg,
-      exec::EvalCtx& context) const;
-
-  const bool ascending_;
-  const bool nullsFirst_;
-};
-
-std::shared_ptr<exec::VectorFunction> makeArraySort(
+std::shared_ptr<exec::VectorFunction> makeArraySortAsc(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config);
 
-std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortSignatures();
+// Sorts an array in descending order. The first argument is the array to sort,
+// and the second argument is a lambda function that maps the array elements
+// to the values to be sorted by.
+//
+// This function is only used in rewriteArraySortCall.
+std::shared_ptr<exec::VectorFunction> makeArraySortDesc(
+    const std::string& name,
+    const std::vector<exec::VectorFunctionArg>& inputArgs,
+    const core::QueryConfig& config);
 
 std::shared_ptr<exec::VectorFunction> makeSortArray(
     const std::string& name,
     const std::vector<exec::VectorFunctionArg>& inputArgs,
     const core::QueryConfig& config);
 
+std::vector<std::shared_ptr<exec::FunctionSignature>> arraySortDescSignatures();
 std::vector<std::shared_ptr<exec::FunctionSignature>> sortArraySignatures();
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Base64Function.h b/velox/functions/sparksql/Base64Function.h
new file mode 100644
index 000000000000..6674f59df983
--- /dev/null
+++ b/velox/functions/sparksql/Base64Function.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/common/encode/Base64.h"
+#include "velox/functions/Macros.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// Encodes the input binary data into a Base64-encoded string using MIME
+/// encoding.
+template <typename T>
+struct Base64Function {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Varchar>& result,
+      const arg_type<Varbinary>& input) {
+    result.resize(encoding::Base64::calculateMimeEncodedSize(input.size()));
+    encoding::Base64::encodeMime(input.data(), input.size(), result.data());
+  }
+};
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/CMakeLists.txt b/velox/functions/sparksql/CMakeLists.txt
index f94dade0e618..3ae83a3dbce1 100644
--- a/velox/functions/sparksql/CMakeLists.txt
+++ b/velox/functions/sparksql/CMakeLists.txt
@@ -17,6 +17,7 @@ velox_add_library(
   velox_functions_spark_impl
   ArrayGetFunction.cpp
   ArraySort.cpp
+  CharVarcharUtils.cpp
   Comparisons.cpp
   ConcatWs.cpp
   DecimalArithmetic.cpp
@@ -30,7 +31,9 @@ velox_add_library(
   RegexFunctions.cpp
   Size.cpp
   String.cpp
-  UnscaledValueFunction.cpp)
+  TimestampUtils.cpp
+  UnscaledValueFunction.cpp
+)
 
 velox_link_libraries(
   velox_functions_spark_impl
@@ -39,11 +42,11 @@ velox_link_libraries(
   velox_functions_spark_specialforms
   velox_functions_util
   Folly::folly
-  simdjson::simdjson)
+  simdjson::simdjson
+)
 
 if(NOT VELOX_MONO_LIBRARY)
-  set_property(TARGET velox_functions_spark_impl PROPERTY JOB_POOL_COMPILE
-                                                          high_memory_pool)
+  set_property(TARGET velox_functions_spark_impl PROPERTY JOB_POOL_COMPILE high_memory_pool)
 endif()
 
 add_subdirectory(window)
diff --git a/velox/functions/sparksql/CharTypeWriteSideCheck.h b/velox/functions/sparksql/CharTypeWriteSideCheck.h
new file mode 100644
index 000000000000..57e1b2464845
--- /dev/null
+++ b/velox/functions/sparksql/CharTypeWriteSideCheck.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/functions/lib/string/StringImpl.h"
+#include "velox/functions/sparksql/CharVarcharUtils.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// Ensures that an input string fits within the specified length `limit` in
+/// characters. If the length of the input string is equal to `limit`, it is
+/// returned as-is. If the length of the input string is less than `limit`, it
+/// is padded with trailing spaces(0x20) to the length of `limit`. If the
+/// length of the input string is greater than `limit`, trailing spaces are
+/// trimmed to fit within `limit`. Throws an exception if the trimmed string
+/// still exceeds `limit` or if `limit` is not a positive value.
+template <typename T>
+struct CharTypeWriteSideCheckFunction {
+  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>& input,
+      int32_t limit) {
+    doCall<false>(result, input, limit);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      int32_t limit) {
+    doCall<true>(result, input, limit);
+  }
+
+ private:
+  template <bool isAscii>
+  FOLLY_ALWAYS_INLINE void doCall(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      int32_t limit) {
+    VELOX_USER_CHECK_GT(limit, 0, "The length limit must be greater than 0.");
+
+    auto numCharacters = stringImpl::length<isAscii>(input);
+
+    if (numCharacters == limit) {
+      result.setNoCopy(input);
+    } else if (numCharacters < limit) {
+      // Rpad spaces(0x20) to limit.
+      stringImpl::pad</*lpad=*/false, isAscii>(result, input, limit, {" "});
+    } else {
+      trimTrailingSpaces(result, input, numCharacters, limit);
+    }
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/CharVarcharUtils.cpp b/velox/functions/sparksql/CharVarcharUtils.cpp
new file mode 100644
index 000000000000..a91e819676e8
--- /dev/null
+++ b/velox/functions/sparksql/CharVarcharUtils.cpp
@@ -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 "velox/functions/sparksql/CharVarcharUtils.h"
+
+namespace facebook::velox::functions::sparksql {
+
+void trimTrailingSpaces(
+    exec::StringWriter& output,
+    StringView inputStr,
+    int32_t numChars,
+    uint32_t limit) {
+  const auto numTailSpacesToTrim = numChars - limit;
+  VELOX_USER_CHECK_GT(numTailSpacesToTrim, 0);
+
+  auto curPos = inputStr.end() - 1;
+  const auto trimTo = inputStr.end() - numTailSpacesToTrim;
+
+  while (curPos >= trimTo && stringImpl::isAsciiSpace(*curPos)) {
+    curPos--;
+  }
+  // Get the length of the trimmed string in characters.
+  const auto trimmedSize = numChars - std::distance(curPos + 1, inputStr.end());
+
+  VELOX_USER_CHECK_LE(
+      trimmedSize, limit, "Exceeds allowed length limitation: {}", limit);
+  output.setNoCopy(
+      StringView(inputStr.data(), std::distance(inputStr.begin(), curPos + 1)));
+}
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/CharVarcharUtils.h b/velox/functions/sparksql/CharVarcharUtils.h
new file mode 100644
index 000000000000..10055736a182
--- /dev/null
+++ b/velox/functions/sparksql/CharVarcharUtils.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 <string>
+
+#include "velox/expression/StringWriter.h"
+#include "velox/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// Trims trailing ASCII space characters (0x20) from `'abc'`
+/// to ensure its length does not exceed the specified Unicode string length
+/// `limit` (must be greater than 0) in characters. Throws an exception if the
+/// string still exceeds `limit` after trimming.
+void trimTrailingSpaces(
+    exec::StringWriter& output,
+    StringView inputStr,
+    int32_t numChars,
+    uint32_t limit);
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Comparisons.cpp b/velox/functions/sparksql/Comparisons.cpp
index 4fdd368faeb9..c794fff64091 100644
--- a/velox/functions/sparksql/Comparisons.cpp
+++ b/velox/functions/sparksql/Comparisons.cpp
@@ -15,8 +15,8 @@
  */
 #include "velox/functions/sparksql/LeastGreatest.h"
 
+#include "velox/expression/DecodedArgs.h"
 #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"
diff --git a/velox/functions/sparksql/Comparisons.h b/velox/functions/sparksql/Comparisons.h
index 7038b5550e14..f3ea55daa1aa 100644
--- a/velox/functions/sparksql/Comparisons.h
+++ b/velox/functions/sparksql/Comparisons.h
@@ -126,13 +126,14 @@ std::shared_ptr<exec::VectorFunction> makeGreaterThanOrEqual(
 inline std::vector<std::shared_ptr<exec::FunctionSignature>>
 comparisonSignatures() {
   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());
+  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",
@@ -147,11 +148,12 @@ comparisonSignatures() {
         "date",
         "interval day to second",
         "interval year to month"}) {
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .returnType("boolean")
-                                .argumentType(inputType)
-                                .argumentType(inputType)
-                                .build());
+    signatures.emplace_back(
+        exec::FunctionSignatureBuilder()
+            .returnType("boolean")
+            .argumentType(inputType)
+            .argumentType(inputType)
+            .build());
   }
   return signatures;
 }
diff --git a/velox/functions/sparksql/DateTimeFunctions.h b/velox/functions/sparksql/DateTimeFunctions.h
index 2da694fb9e0a..b460ca929800 100644
--- a/velox/functions/sparksql/DateTimeFunctions.h
+++ b/velox/functions/sparksql/DateTimeFunctions.h
@@ -20,6 +20,7 @@
 
 #include "velox/functions/lib/DateTimeFormatter.h"
 #include "velox/functions/lib/TimeUtils.h"
+#include "velox/functions/sparksql/TimestampUtils.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
@@ -170,7 +171,8 @@ struct UnixTimestampParseFunction {
     if (dateTimeResult.hasError()) {
       return false;
     }
-    (*dateTimeResult).timestamp.toGMT(*getTimeZone(*dateTimeResult));
+    toGMTWithGapCorrection(
+        (*dateTimeResult).timestamp, *getTimeZone(*dateTimeResult));
     result = (*dateTimeResult).timestamp.getSeconds();
     return true;
   }
@@ -254,7 +256,8 @@ struct UnixTimestampParseWithFormatFunction
     if (dateTimeResult.hasError()) {
       return false;
     }
-    (*dateTimeResult).timestamp.toGMT(*this->getTimeZone(*dateTimeResult));
+    toGMTWithGapCorrection(
+        (*dateTimeResult).timestamp, *this->getTimeZone(*dateTimeResult));
     result = (*dateTimeResult).timestamp.getSeconds();
     return true;
   }
@@ -267,7 +270,7 @@ struct UnixTimestampParseWithFormatFunction
 
   FOLLY_ALWAYS_INLINE void call(int64_t& result, const arg_type<Date>& input) {
     auto timestamp = Timestamp::fromDate(input);
-    timestamp.toGMT(*this->sessionTimeZone_);
+    toGMTWithGapCorrection(timestamp, *this->sessionTimeZone_);
 
     int64_t seconds = timestamp.getSeconds();
     // Spark converts days as microseconds and then divide it by 10e6 to get
@@ -372,7 +375,7 @@ struct ToUtcTimestampFunction {
         : tz::locateZone(std::string_view(timezone), false);
     VELOX_USER_CHECK_NOT_NULL(
         fromTimezone, "Unknown time zone: '{}'", timezone);
-    result.toGMT(*fromTimezone);
+    toGMTWithGapCorrection(result, *fromTimezone);
   }
 
  private:
@@ -456,7 +459,8 @@ struct GetTimestampFunction {
     if (dateTimeResult.hasError()) {
       return false;
     }
-    (*dateTimeResult).timestamp.toGMT(*getTimeZone(*dateTimeResult));
+    toGMTWithGapCorrection(
+        (*dateTimeResult).timestamp, *getTimeZone(*dateTimeResult));
     result = (*dateTimeResult).timestamp;
     return true;
   }
@@ -580,6 +584,51 @@ struct DateTruncFunction {
   const tz::TimeZone* timeZone_ = nullptr;
 };
 
+/// Truncates a date to a specified time unit. Return NULL if the format is
+/// invalid. Format as abbreviated unit string is allowed.
+template <typename T>
+struct TruncFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Date>* /*date*/,
+      const arg_type<Varchar>* format) {
+    if (format != nullptr) {
+      unit_ = fromDateTimeUnitString(
+          *format,
+          /*throwIfInvalid=*/false,
+          /*allowMicro=*/false,
+          /*allowAbbreviated=*/true);
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Date>& result,
+      const arg_type<Date>& date,
+      const arg_type<Varchar>& format) {
+    const auto unitOption = unit_.has_value() ? unit_
+                                              : fromDateTimeUnitString(
+                                                    format,
+                                                    /*throwIfInvalid=*/false,
+                                                    /*allowMicro=*/false,
+                                                    /*allowAbbreviated=*/true);
+    // Return NULL if unit is illegal or unit is less than week.
+    if (!unitOption.has_value() || unitOption.value() < DateTimeUnit::kWeek) {
+      return false;
+    }
+    auto dateTime = getDateTime(date);
+    adjustDateTime(dateTime, unitOption.value());
+
+    result = Timestamp::calendarUtcToEpoch(dateTime) / kSecondsInDay;
+    return true;
+  }
+
+ private:
+  std::optional<DateTimeUnit> unit_;
+};
+
 template <typename T>
 struct DateAddFunction {
   VELOX_DEFINE_FUNCTION_TYPES(T);
@@ -906,4 +955,257 @@ struct MillisToTimestampFunction {
   }
 };
 
+template <typename TExec>
+struct SecondsToTimestampFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename T>
+  FOLLY_ALWAYS_INLINE bool call(out_type<Timestamp>& result, T seconds) {
+    if constexpr (std::is_integral_v<T>) {
+      result = Timestamp(static_cast<int64_t>(seconds), 0);
+      return true;
+    } else {
+      if (FOLLY_UNLIKELY(!std::isfinite(seconds))) {
+        return false;
+      }
+
+      // Cast to double and check bounds to prevent ensuing overflow.
+      const double secondsD = static_cast<double>(seconds);
+
+      if (secondsD >= kMaxSecondsD) {
+        result = Timestamp(kMaxSeconds, kMaxNanoseconds);
+      } else if (secondsD <= kMinSecondsD) {
+        result = Timestamp(kMinSeconds, kMinNanoseconds);
+      } else {
+        // Scale to microseconds and truncate toward zero.
+        const double microsD = secondsD * Timestamp::kMicrosecondsInSecond;
+        const int64_t micros = static_cast<int64_t>(microsD);
+
+        // Split into whole seconds and remaining microseconds.
+        int64_t wholeSeconds = micros / Timestamp::kMicrosecondsInSecond;
+        int64_t remainingMicros = micros % Timestamp::kMicrosecondsInSecond;
+        if (remainingMicros < 0) {
+          wholeSeconds -= 1;
+          remainingMicros += Timestamp::kMicrosecondsInSecond;
+        }
+
+        const int64_t nano =
+            remainingMicros * Timestamp::kNanosecondsInMicrosecond;
+        result = Timestamp(wholeSeconds, nano);
+      }
+      return true;
+    }
+  }
+
+ private:
+  static constexpr double kMaxMicrosD =
+      static_cast<double>(std::numeric_limits<int64_t>::max());
+  static constexpr double kMinMicrosD =
+      static_cast<double>(std::numeric_limits<int64_t>::min());
+  static constexpr double kMaxSecondsD =
+      kMaxMicrosD / Timestamp::kMicrosecondsInSecond;
+  static constexpr double kMinSecondsD =
+      kMinMicrosD / Timestamp::kMicrosecondsInSecond;
+
+  // Cutoff values are based on Java's Long.MAX_VALUE and Long.MIN_VALUE.
+  static constexpr int64_t kMaxSeconds = 9223372036854LL;
+  static constexpr int64_t kMaxNanoseconds = 775807000LL;
+  static constexpr int64_t kMinSeconds = -9223372036855LL;
+  static constexpr int64_t kMinNanoseconds = 224192000LL;
+};
+
+template <typename T>
+struct TimestampDiffFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Varchar>* unitString,
+      const arg_type<Timestamp>* /*timestamp1*/,
+      const arg_type<Timestamp>* /*timestamp2*/) {
+    VELOX_USER_CHECK_NOT_NULL(unitString);
+    unit_ = fromDateTimeUnitString(
+        *unitString, /*throwIfInvalid=*/true, /*allowMicro=*/true);
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+  }
+
+  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_.value();
+    result = diffTimestamp(
+        unit,
+        timestamp1,
+        timestamp2,
+        sessionTimeZone_,
+        /*respectLastDay=*/false);
+  }
+
+ private:
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
+  std::optional<DateTimeUnit> unit_ = std::nullopt;
+};
+
+template <typename T>
+struct TimestampAddFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Varchar>* unitString,
+      const TInput* /*value*/,
+      const arg_type<Timestamp>* /*timestamp*/) {
+    VELOX_USER_CHECK_NOT_NULL(unitString);
+    std::string unitStr(*unitString);
+    folly::toLowerAscii(unitStr);
+    if (unitStr == "dayofyear") {
+      unit_ = DateTimeUnit::kDay;
+    } else {
+      unit_ = fromDateTimeUnitString(
+          *unitString, /*throwIfInvalid=*/true, /*allowMicro=*/true);
+    }
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+  }
+
+  template <typename TInput>
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<Timestamp>& result,
+      const arg_type<Varchar>& /*unitString*/,
+      const TInput value,
+      const arg_type<Timestamp>& timestamp) {
+    const auto unit = unit_.value();
+    result = addToTimestamp(unit, value, timestamp, sessionTimeZone_);
+  }
+
+ private:
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
+  std::optional<DateTimeUnit> unit_ = std::nullopt;
+};
+
+template <typename TExec>
+struct MonthsBetweenFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Timestamp>* /*timestamp1*/,
+      const arg_type<Timestamp>* /*timestamp2*/,
+      const arg_type<bool>* /*roundOff*/) {
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+  }
+
+  FOLLY_ALWAYS_INLINE void call(
+      out_type<double>& result,
+      const arg_type<Timestamp>& timestamp1,
+      const arg_type<Timestamp>& timestamp2,
+      const arg_type<bool>& roundOff) {
+    const auto dateTime1 = getDateTime(timestamp1, sessionTimeZone_);
+    const auto dateTime2 = getDateTime(timestamp2, sessionTimeZone_);
+    result = monthsBetween(dateTime1, dateTime2, roundOff);
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE bool isEndDayOfMonth(const std::tm& tm) {
+    return tm.tm_mday == util::getMaxDayOfMonth(getYear(tm), getMonth(tm));
+  }
+
+  FOLLY_ALWAYS_INLINE double
+  monthsBetween(const std::tm& tm1, const std::tm& tm2, bool roundOff) {
+    const double monthDiff =
+        (tm1.tm_year - tm2.tm_year) * kMonthInYear + tm1.tm_mon - tm2.tm_mon;
+    if (tm1.tm_mday == tm2.tm_mday ||
+        (isEndDayOfMonth(tm1) && isEndDayOfMonth(tm2))) {
+      return monthDiff;
+    }
+    const auto secondsInDay1 = tm1.tm_hour * kSecondsInHour +
+        tm1.tm_min * kSecondsInMinute + tm1.tm_sec;
+    const auto secondsInDay2 = tm2.tm_hour * kSecondsInHour +
+        tm2.tm_min * kSecondsInMinute + tm2.tm_sec;
+    const auto secondsDiff = (tm1.tm_mday - tm2.tm_mday) * kSecondsInDay +
+        secondsInDay1 - secondsInDay2;
+    const auto diff =
+        monthDiff + static_cast<double>(secondsDiff) / kSecondsInMonth;
+    if (roundOff) {
+      return round(diff * kRoundingPrecision) / kRoundingPrecision;
+    }
+    return diff;
+  }
+
+  // Precision factor for 8 decimal places rounding.
+  static constexpr int64_t kRoundingPrecision = 1e8;
+  static constexpr int64_t kSecondsInMonth = kSecondsInDay * 31;
+  const tz::TimeZone* sessionTimeZone_ = nullptr;
+};
+
+template <typename T>
+struct DateFormatFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& /*inputTypes*/,
+      const core::QueryConfig& config,
+      const arg_type<Timestamp>* /*timestamp*/,
+      const arg_type<Varchar>* formatString) {
+    legacyFormatter_ = config.sparkLegacyDateFormatter();
+    sessionTimeZone_ = getTimeZoneFromConfig(config);
+    if (formatString != nullptr) {
+      auto formatter = detail::initializeFormatter(
+          std::string_view(*formatString), legacyFormatter_);
+      if (formatter) {
+        formatter_ = formatter;
+        maxResultSize_ = formatter_->maxResultSize(sessionTimeZone_);
+      } else {
+        invalidFormat_ = true;
+      }
+      isConstFormat_ = true;
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Timestamp>& timestamp,
+      const arg_type<Varchar>& formatString) {
+    if (invalidFormat_) {
+      return false;
+    }
+    if (!isConstFormat_) {
+      auto formatter = detail::initializeFormatter(
+          std::string_view(formatString), legacyFormatter_);
+      if (!formatter) {
+        return false;
+      }
+      formatter_ = formatter;
+      maxResultSize_ = formatter_->maxResultSize(sessionTimeZone_);
+    }
+
+    format(timestamp, sessionTimeZone_, maxResultSize_, result);
+    return true;
+  }
+
+ private:
+  FOLLY_ALWAYS_INLINE void format(
+      const Timestamp& timestamp,
+      const tz::TimeZone* timeZone,
+      uint32_t maxResultSize,
+      out_type<Varchar>& result) const {
+    result.reserve(maxResultSize);
+    const auto resultSize =
+        formatter_->format(timestamp, timeZone, maxResultSize, result.data());
+    result.resize(resultSize);
+  }
+
+  const tz::TimeZone* sessionTimeZone_{nullptr};
+  std::shared_ptr<DateTimeFormatter> formatter_;
+  bool isConstFormat_{false};
+  bool legacyFormatter_{false};
+  bool invalidFormat_{false};
+  uint32_t maxResultSize_;
+};
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalArithmetic.cpp b/velox/functions/sparksql/DecimalArithmetic.cpp
index 2836ef380a58..f33a3f1f78ea 100644
--- a/velox/functions/sparksql/DecimalArithmetic.cpp
+++ b/velox/functions/sparksql/DecimalArithmetic.cpp
@@ -427,7 +427,7 @@ struct DecimalMultiplyFunction {
       return in;
     }
 
-    int256_t divisor = velox::DecimalUtil::kPowersOfTen[reduceBy];
+    int256_t divisor = DecimalUtil::getPowersOfTen(reduceBy);
     auto result = in / divisor;
     auto remainder = in % divisor;
     // Round up.
@@ -455,7 +455,8 @@ struct DecimalDivideFunction {
     auto [aPrecision, aScale] = getDecimalPrecisionScale(*inputTypes[0]);
     auto [bPrecision, bScale] = getDecimalPrecisionScale(*inputTypes[1]);
     auto [rPrecision, rScale] =
-        computeResultPrecisionScale(aPrecision, aScale, bPrecision, bScale);
+        DecimalUtil::computeDivideResultPrecisionScale<allowPrecisionLoss>(
+            aPrecision, aScale, bPrecision, bScale);
     rPrecision_ = rPrecision;
     aRescale_ = rScale - aScale + bScale;
   }
@@ -469,36 +470,116 @@ struct DecimalDivideFunction {
   }
 
  private:
-  // When allowing precision loss, computes the result precision and scale
-  // following Hive's formulas. When denying precision loss, calculates the
-  // number of whole digits and fraction digits. If the total number of digits
-  // exceed 38, we reduce both the number of fraction digits and whole digits to
-  // fit within this limit.
-  static std::pair<uint8_t, uint8_t> computeResultPrecisionScale(
-      uint8_t aPrecision,
-      uint8_t aScale,
-      uint8_t bPrecision,
-      uint8_t bScale) {
-    if constexpr (allowPrecisionLoss) {
-      auto scale = std::max(6, aScale + bPrecision + 1);
-      auto precision = aPrecision - aScale + bScale + scale;
-      return DecimalUtil::adjustPrecisionScale(precision, scale);
-    } else {
-      auto wholeDigits = std::min(38, aPrecision - aScale + bScale);
-      auto fractionDigits = std::min(38, std::max(6, aScale + bPrecision + 1));
-      auto diff = (wholeDigits + fractionDigits) - 38;
-      if (diff > 0) {
-        fractionDigits -= diff / 2 + 1;
-        wholeDigits = 38 - fractionDigits;
-      }
-      return DecimalUtil::bounded(wholeDigits + fractionDigits, fractionDigits);
+  uint8_t aRescale_;
+  uint8_t rPrecision_;
+};
+
+// Decimal integral divide function implementation.
+struct DecimalIntegralDivideBase {
+  void initializeBase(const std::vector<TypePtr>& inputTypes) {
+    auto [aPrecision, aScale] = getDecimalPrecisionScale(*inputTypes[0]);
+    auto bScale = getDecimalPrecisionScale(*inputTypes[1]).second;
+    rPrecision_ = computeResultPrecision(aPrecision, aScale, bScale);
+    aRescale_ = std::max<int8_t>(0, bScale - aScale);
+    bRescale_ = std::max<int8_t>(0, aScale - bScale);
+  }
+
+  // Computes the quotient of 'a' and 'b' and stores it in 'out'. Returns false
+  // if the result exceeds rPrecision_ or if overflow occurs during scaling.
+  // Following Spark's behavior, the result is truncated to int64_t if it
+  // exceeds int64_t range.
+  template <typename A, typename B>
+  bool computeQuotient(int64_t& out, const A& a, const B& b) {
+    // Determine sign and convert to absolute values.
+    bool isNegative = (a < 0) != (b < 0);
+    int128_t absA = static_cast<int128_t>(a < 0 ? -a : a);
+    int128_t absB = static_cast<int128_t>(b < 0 ? -b : b);
+
+    // Scale values, checking for overflow.
+    int128_t scaledA;
+    int128_t scaledB;
+    if (__builtin_mul_overflow(
+            absA, velox::DecimalUtil::kPowersOfTen[aRescale_], &scaledA) ||
+        __builtin_mul_overflow(
+            absB, velox::DecimalUtil::kPowersOfTen[bRescale_], &scaledB)) {
+      return false;
+    }
+
+    if (scaledA < scaledB) {
+      out = 0;
+      return true;
     }
+
+    int128_t quotient = scaledA / scaledB;
+    quotient = isNegative ? -quotient : quotient;
+
+    if (!velox::DecimalUtil::valueInPrecisionRange(quotient, rPrecision_)) {
+      return false;
+    }
+    out = static_cast<int64_t>(quotient);
+    return true;
   }
 
+ private:
+  static uint8_t
+  computeResultPrecision(uint8_t aPrecision, uint8_t aScale, uint8_t bScale) {
+    auto intPrecision = aPrecision - aScale + bScale;
+    if (intPrecision == 0) {
+      intPrecision = 1;
+    }
+    return DecimalUtil::bounded(intPrecision, 0).first;
+  }
+
+ protected:
   uint8_t aRescale_;
+  uint8_t bRescale_;
   uint8_t rPrecision_;
 };
 
+// Decimal integral divide function that returns null on division by zero or
+// overflow.
+template <typename TExec>
+struct DecimalIntegralDivideFunction : DecimalIntegralDivideBase {
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    initializeBase(inputTypes);
+  }
+
+  template <typename A, typename B>
+  bool call(int64_t& out, const A& a, const B& b) {
+    if (b == 0) {
+      return false;
+    }
+    return computeQuotient(out, a, b);
+  }
+};
+
+// Decimal integral divide function that returns error on division by zero or
+// overflow.
+template <typename TExec>
+struct CheckedDecimalIntegralDivideFunction : DecimalIntegralDivideBase {
+  template <typename A, typename B>
+  void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& /*config*/,
+      A* /*a*/,
+      B* /*b*/) {
+    initializeBase(inputTypes);
+  }
+
+  template <typename A, typename B>
+  Status call(int64_t& out, const A& a, const B& b) {
+    VELOX_USER_RETURN_EQ(b, 0, "Division by zero");
+    VELOX_USER_RETURN(
+        !computeQuotient(out, a, b), "Overflow in integral divide");
+    return Status::OK();
+  }
+};
+
 template <template <class> typename Func>
 void registerDecimalBinary(
     const std::string& name,
@@ -672,6 +753,25 @@ void registerDecimalDivide(
       LongDecimal<P1, S1>,
       ShortDecimal<P2, S2>>({functionName}, constraints);
 }
+
+template <template <class> typename Func>
+void registerIntegralDecimalDivide(const std::string& functionName) {
+  // (short, short) -> int64_t
+  registerFunction<Func, int64_t, ShortDecimal<P1, S1>, ShortDecimal<P2, S2>>(
+      {functionName});
+
+  // (long, long) -> int64_t
+  registerFunction<Func, int64_t, LongDecimal<P1, S1>, LongDecimal<P2, S2>>(
+      {functionName});
+
+  // (short, long) -> int64_t
+  registerFunction<Func, int64_t, ShortDecimal<P1, S1>, LongDecimal<P2, S2>>(
+      {functionName});
+
+  // (long, short) -> int64_t
+  registerFunction<Func, int64_t, LongDecimal<P1, S1>, ShortDecimal<P2, S2>>(
+      {functionName});
+}
 } // namespace
 
 void registerDecimalAdd(const std::string& prefix) {
@@ -715,4 +815,10 @@ void registerDecimalDivide(const std::string& prefix) {
       prefix + "divide" + kDenyPrecisionLoss,
       getDivideConstraintsDenyPrecisionLoss());
 }
+
+void registerDecimalIntegralDivide(const std::string& prefix) {
+  registerIntegralDecimalDivide<DecimalIntegralDivideFunction>(prefix + "div");
+  registerIntegralDecimalDivide<CheckedDecimalIntegralDivideFunction>(
+      prefix + "checked_div");
+}
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalArithmetic.h b/velox/functions/sparksql/DecimalArithmetic.h
index f1a94ce01a92..a6f8ff77d30a 100644
--- a/velox/functions/sparksql/DecimalArithmetic.h
+++ b/velox/functions/sparksql/DecimalArithmetic.h
@@ -27,4 +27,6 @@ void registerDecimalMultiply(const std::string& prefix);
 
 void registerDecimalDivide(const std::string& prefix);
 
+void registerDecimalIntegralDivide(const std::string& prefix);
+
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/DecimalUtil.h b/velox/functions/sparksql/DecimalUtil.h
index 28495789dc33..62d8d43f48ff 100644
--- a/velox/functions/sparksql/DecimalUtil.h
+++ b/velox/functions/sparksql/DecimalUtil.h
@@ -186,8 +186,7 @@ class DecimalUtil {
         return R(-1);
       }
       int256_t aLarge = a;
-      int256_t aLargeScaledUp =
-          aLarge * velox::DecimalUtil::kPowersOfTen[aRescale];
+      int256_t aLargeScaledUp = aLarge * getPowersOfTen(aRescale);
       int256_t bLarge = b;
       int256_t resultLarge = aLargeScaledUp / bLarge;
       int256_t remainderLarge = aLargeScaledUp % bLarge;
@@ -211,6 +210,33 @@ class DecimalUtil {
     }
   }
 
+  /// When allowing precision loss, computes the result precision and scale
+  /// following Hive's formulas. When denying precision loss, calculates the
+  /// number of whole digits and fraction digits. If the total number of digits
+  /// exceed 38, we reduce both the number of fraction digits and whole digits
+  /// to fit within this limit.
+  template <bool allowPrecisionLoss>
+  static std::pair<uint8_t, uint8_t> computeDivideResultPrecisionScale(
+      uint8_t aPrecision,
+      uint8_t aScale,
+      uint8_t bPrecision,
+      uint8_t bScale) {
+    if constexpr (allowPrecisionLoss) {
+      auto scale = std::max(6, aScale + bPrecision + 1);
+      auto precision = aPrecision - aScale + bScale + scale;
+      return adjustPrecisionScale(precision, scale);
+    } else {
+      auto wholeDigits = std::min(38, aPrecision - aScale + bScale);
+      auto fractionDigits = std::min(38, std::max(6, aScale + bPrecision + 1));
+      auto diff = (wholeDigits + fractionDigits) - 38;
+      if (diff > 0) {
+        fractionDigits -= diff / 2 + 1;
+        wholeDigits = 38 - fractionDigits;
+      }
+      return bounded(wholeDigits + fractionDigits, fractionDigits);
+    }
+  }
+
   /// This method is used when the function is registered with
   /// ``allowPrecisionLoss`` being false. Caps precision and scale at 38.
   static std::pair<uint8_t, uint8_t> bounded(
@@ -221,6 +247,15 @@ class DecimalUtil {
         std::min(rScale, DecimalType<TypeKind::HUGEINT>::kMaxPrecision)};
   }
 
+  /// Returns 10^scale as int256_t. The input scale should be in range
+  /// [0, 76].
+  static int256_t getPowersOfTen(int32_t scale) {
+    VELOX_CHECK_GE(scale, 0);
+    VELOX_CHECK_LE(scale, kMaxLargeScale);
+
+    return kLargeScalePowersOfTen[scale];
+  }
+
  private:
   /// Maintains the max bits that need to be increased for rescaling a value by
   /// certain scale. The calculation relies on the following formula:
@@ -241,5 +276,21 @@ class DecimalUtil {
     int32_t numOccupied = sizeof(A) * 8 - bits::countLeadingZeros(valueAbs);
     return numOccupied + kMaxBitsRequiredIncreaseAfterScaling[aRescale];
   }
+
+  static constexpr int32_t kMaxLargeScale = 2 * LongDecimalType::kMaxPrecision;
+
+  // Pre-compute the powers of ten for large scales. The maximum scale is
+  // 2 * LongDecimalType::kMaxPrecision, which is 76. The
+  // DecimalUtil::kPowersOfTen array is not large enough to hold these values.
+  static constexpr std::array<int256_t, kMaxLargeScale + 1>
+      kLargeScalePowersOfTen =
+          ([]() -> std::array<int256_t, kMaxLargeScale + 1> {
+            std::array<int256_t, kMaxLargeScale + 1> values;
+            values[0] = 1;
+            for (int32_t idx = 1; idx <= kMaxLargeScale; idx++) {
+              values[idx] = values[idx - 1] * 10;
+            }
+            return values;
+          })();
 };
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/GetJsonObject.h b/velox/functions/sparksql/GetJsonObject.h
index 08f6d7c8b657..ae48040a753b 100644
--- a/velox/functions/sparksql/GetJsonObject.h
+++ b/velox/functions/sparksql/GetJsonObject.h
@@ -14,8 +14,12 @@
  * limitations under the License.
  */
 
+#pragma once
+
 #include "velox/functions/Macros.h"
+#include "velox/functions/lib/JsonUtil.h"
 #include "velox/functions/prestosql/json/SIMDJsonUtil.h"
+#include "velox/type/Conversions.h"
 
 namespace facebook::velox::functions::sparksql {
 
@@ -35,7 +39,7 @@ struct GetJsonObjectFunction {
       const arg_type<Varchar>* /*json*/,
       const arg_type<Varchar>* jsonPath) {
     if (jsonPath != nullptr && checkJsonPath(*jsonPath)) {
-      jsonPath_ = removeSingleQuotes(*jsonPath);
+      jsonPath_ = normalizeJsonPath(*jsonPath);
     }
   }
 
@@ -47,8 +51,10 @@ struct GetJsonObjectFunction {
     if (!checkJsonPath(jsonPath)) {
       return false;
     }
+    const auto formattedJsonPath =
+        jsonPath_.has_value() ? jsonPath_.value() : normalizeJsonPath(jsonPath);
     // jsonPath is "$".
-    if (jsonPath.size() == 1) {
+    if (formattedJsonPath.empty()) {
       result.append(json);
       return true;
     }
@@ -57,9 +63,6 @@ struct GetJsonObjectFunction {
     if (simdjsonParseIncomplete(paddedJson).get(jsonDoc)) {
       return false;
     }
-    const auto formattedJsonPath = jsonPath_.has_value()
-        ? jsonPath_.value()
-        : removeSingleQuotes(jsonPath);
     try {
       // Can return error result or throw exception possibly.
       auto rawResult = jsonDoc.at_path(formattedJsonPath);
@@ -85,10 +88,7 @@ struct GetJsonObjectFunction {
  private:
   FOLLY_ALWAYS_INLINE bool checkJsonPath(StringView jsonPath) {
     // Spark requires the first char in jsonPath is '$'.
-    if (jsonPath.empty() || jsonPath.data()[0] != '$') {
-      return false;
-    }
-    return true;
+    return std::string_view{jsonPath}.starts_with('$');
   }
 
   // Spark's json path requires field name surrounded by single quotes if it is
@@ -96,15 +96,14 @@ struct GetJsonObjectFunction {
   // such single quotes to adapt to simdjson lib, e.g., converts "['a']['b']" to
   // "[a][b]".
   std::string removeSingleQuotes(StringView jsonPath) {
-    // Skip the initial "$".
-    std::string result(jsonPath.data() + 1, jsonPath.size() - 1);
+    std::string result(jsonPath.data(), jsonPath.size());
     size_t pairEnd = 0;
     while (true) {
       auto pairBegin = result.find("['", pairEnd);
       if (pairBegin == std::string::npos) {
         break;
       }
-      pairEnd = result.find("]", pairBegin);
+      pairEnd = result.find(']', pairBegin);
       // If expected pattern, like ['a'], is not found.
       if (pairEnd == std::string::npos || result[pairEnd - 1] != '\'') {
         return "-1";
@@ -116,6 +115,83 @@ struct GetJsonObjectFunction {
     return result;
   }
 
+  // Normalizes the JSON path to be Spark-compatible.
+  //
+  // Rules applied:
+  // 1. Removes single quotes in bracket notation (e.g., "$['a']" -> "$[a]").
+  // 2. Removes spaces after dots (e.g., "$. a" -> "$.a").
+  // 3. Removes trailing spaces after root symbol (e.g., "$ " -> "$").
+  // 4. Invalid cases return "-1":
+  //    - Empty path or path not starting with '$'.
+  //    - Space between $ and dot (e.g., "$ .a").
+  //    - Consecutive dots (e.g., "$..a").
+  //    - Dot at the end (e.g., "$.a. ").
+  std::string normalizeJsonPath(StringView jsonPath) {
+    // First, remove single quotes for bracket notation
+    std::string path = removeSingleQuotes(jsonPath);
+    if (path.empty() || path[0] != '$') {
+      return "-1";
+    }
+
+    enum class State {
+      kAfterDollar,
+      kAfterDot,
+      kToken
+    } state = State::kAfterDollar;
+
+    std::string normalized;
+    normalized.reserve(path.size() - 1);
+
+    for (size_t i = 1; i < path.size(); ++i) {
+      const char c = path[i];
+      if (c == ' ') {
+        if (state == State::kToken) {
+          // Spaces within tokens are preserved.
+          normalized.push_back(c);
+        }
+        continue;
+      }
+      switch (state) {
+        case State::kAfterDollar: {
+          if (c == '.') {
+            state = State::kAfterDot;
+            if (path[i - 1] == ' ') {
+              // Spaces between '$' and '.' are invalid.
+              return "-1";
+            }
+          }
+          normalized.push_back(c);
+          break;
+        }
+        case State::kAfterDot: {
+          if (c == '.') {
+            // Consecutive dots are invalid.
+            return "-1";
+          }
+          normalized.push_back(c);
+          state = State::kToken;
+          break;
+        }
+        case State::kToken: {
+          if (c == '.') {
+            normalized.push_back(c);
+            state = State::kAfterDot;
+          } else {
+            normalized.push_back(c);
+          }
+          break;
+        }
+      }
+    }
+
+    if (state == State::kAfterDot) {
+      // Trailing dot is invalid.
+      return "-1";
+    }
+
+    return normalized;
+  }
+
   // Extracts a string representation from a simdjson result. Handles various
   // JSON types including numbers, booleans, strings, objects, and arrays.
   // Returns true if the conversion is successful. Otherwise, returns false.
@@ -130,35 +206,28 @@ struct GetJsonObjectFunction {
       // can check the validity of ending character.
       case simdjson::ondemand::json_type::number: {
         switch (rawResult.get_number_type()) {
-          case simdjson::ondemand::number_type::unsigned_integer: {
-            uint64_t numberResult;
-            if (!rawResult.get_uint64().get(numberResult)) {
-              ss << numberResult;
-              result.append(ss.str());
-              return true;
-            }
-            return false;
-          }
-          case simdjson::ondemand::number_type::signed_integer: {
-            int64_t numberResult;
-            if (!rawResult.get_int64().get(numberResult)) {
-              ss << numberResult;
-              result.append(ss.str());
-              return true;
-            }
-            return false;
-          }
           case simdjson::ondemand::number_type::floating_point_number: {
             double numberResult;
             if (!rawResult.get_double().get(numberResult)) {
-              ss << rawResult;
-              result.append(ss.str());
+              result.append(
+                  util::Converter<TypeKind::VARCHAR>::tryCast(numberResult)
+                      .value());
               return true;
             }
             return false;
           }
-          default:
-            VELOX_UNREACHABLE();
+          default: {
+            std::string_view intResult = trimToken(rawResult.raw_json_token());
+            // Spark uses Jackson to parse JSON, which does not preserve the
+            // negative sign for -0. See the implementation here:
+            // https://github.com/FasterXML/jackson-core/blob/jackson-core-2.19.2/src/main/java/com/fasterxml/jackson/core/util/TextBuffer.java#L699-L702
+            if (intResult == "-0") {
+              intResult = "0";
+            }
+            result.append(intResult);
+            // Advance the simdjson parsing position.
+            return !rawResult.get_double().error();
+          }
         }
       }
       case simdjson::ondemand::json_type::boolean: {
@@ -177,13 +246,9 @@ struct GetJsonObjectFunction {
         }
         return false;
       }
-      case simdjson::ondemand::json_type::object: {
-        // For nested case, e.g., for "{"my": {"hello": 10}}", "$.my" will
-        // return an object type.
-        ss << rawResult;
-        result.append(ss.str());
-        return true;
-      }
+      // For nested case, e.g., for "{"my": {"hello": 10}}",
+      // "$.my" will return an object type.
+      case simdjson::ondemand::json_type::object:
       case simdjson::ondemand::json_type::array: {
         ss << rawResult;
         result.append(ss.str());
diff --git a/velox/functions/sparksql/Hash.cpp b/velox/functions/sparksql/Hash.cpp
index 480da25596af..dd1de32d5843 100644
--- a/velox/functions/sparksql/Hash.cpp
+++ b/velox/functions/sparksql/Hash.cpp
@@ -19,6 +19,7 @@
 
 #include "velox/common/base/BitUtil.h"
 #include "velox/expression/DecodedArgs.h"
+#include "velox/functions/lib/Murmur3Hash32Base.h"
 #include "velox/vector/FlatVector.h"
 
 namespace facebook::velox::functions::sparksql {
@@ -397,7 +398,7 @@ void applyWithType(
 // Signed integer types have been remapped to unsigned types (as in the
 // original) to avoid undefined signed integer overflow and sign extension.
 
-class Murmur3Hash final {
+class Murmur3Hash final : public Murmur3Hash32Base {
  public:
   using SeedType = int32_t;
   using ReturnType = int32_t;
@@ -408,17 +409,8 @@ class Murmur3Hash final {
     return fmix(h1, 4);
   }
 
-  static uint32_t hashInt64(uint64_t input, uint32_t seed) {
-    uint32_t low = input;
-    uint32_t high = input >> 32;
-
-    uint32_t k1 = mixK1(low);
-    uint32_t h1 = mixH1(seed, k1);
-
-    k1 = mixK1(high);
-    h1 = mixH1(h1, k1);
-
-    return fmix(h1, 8);
+  static uint32_t hashInt64(int64_t input, uint32_t seed) {
+    return Murmur3Hash32Base::hashInt64(input, seed);
   }
 
   // Floating point numbers are hashed as if they are integers, with
@@ -457,32 +449,6 @@ class Murmur3Hash final {
   static uint32_t hashTimestamp(Timestamp input, uint32_t seed) {
     return hashInt64(input.toMicros(), seed);
   }
-
- private:
-  static uint32_t mixK1(uint32_t k1) {
-    k1 *= 0xcc9e2d51;
-    k1 = bits::rotateLeft(k1, 15);
-    k1 *= 0x1b873593;
-    return k1;
-  }
-
-  static uint32_t mixH1(uint32_t h1, uint32_t k1) {
-    h1 ^= k1;
-    h1 = bits::rotateLeft(h1, 13);
-    h1 = h1 * 5 + 0xe6546b64;
-    return h1;
-  }
-
-  // Finalization mix - force all bits of a hash block to avalanche
-  static uint32_t fmix(uint32_t h1, uint32_t length) {
-    h1 ^= length;
-    h1 ^= h1 >> 16;
-    h1 *= 0x85ebca6b;
-    h1 ^= h1 >> 13;
-    h1 *= 0xc2b2ae35;
-    h1 ^= h1 >> 16;
-    return h1;
-  }
 };
 
 class Murmur3HashFunction final : public exec::VectorFunction {
diff --git a/velox/functions/sparksql/InitcapFunction.h b/velox/functions/sparksql/InitcapFunction.h
new file mode 100644
index 000000000000..6de6642ebd3a
--- /dev/null
+++ b/velox/functions/sparksql/InitcapFunction.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/functions/Macros.h"
+#include "velox/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// The InitCapFunction capitalizes the first character of each word in a
+/// string, and lowercases the rest, following Spark SQL semantics. Word
+/// boundaries are determined by whitespace.
+template <typename T>
+struct InitCapFunction {
+  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) {
+    stringImpl::initcap<
+        /*strictSpace=*/true,
+        /*isAscii=*/false,
+        /*turkishCasing=*/true,
+        /*greekFinalSigma=*/true>(result, input);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input) {
+    stringImpl::initcap<
+        /*strictSpace=*/true,
+        /*isAscii=*/true,
+        /*turkishCasing=*/true,
+        /*greekFinalSigma=*/true>(result, input);
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/LeastGreatest.cpp b/velox/functions/sparksql/LeastGreatest.cpp
index 24a77b0c8753..926e9bec7f7f 100644
--- a/velox/functions/sparksql/LeastGreatest.cpp
+++ b/velox/functions/sparksql/LeastGreatest.cpp
@@ -149,19 +149,21 @@ std::vector<std::shared_ptr<exec::FunctionSignature>> leastSignatures() {
   std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
 
   for (const auto& type : types) {
-    signatures.emplace_back(exec::FunctionSignatureBuilder()
-                                .returnType(type)
-                                .argumentType(type)
-                                .variableArity(type)
-                                .build());
+    signatures.emplace_back(
+        exec::FunctionSignatureBuilder()
+            .returnType(type)
+            .argumentType(type)
+            .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());
+  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/MakeTimestamp.cpp b/velox/functions/sparksql/MakeTimestamp.cpp
index a65ab949cbee..08286a9204ce 100644
--- a/velox/functions/sparksql/MakeTimestamp.cpp
+++ b/velox/functions/sparksql/MakeTimestamp.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/expression/DecodedArgs.h"
 #include "velox/expression/VectorFunction.h"
+#include "velox/functions/sparksql/TimestampUtils.h"
 #include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox::functions::sparksql {
@@ -74,7 +75,7 @@ void setTimestampOrNull(
   const auto timeZoneName = timeZoneVector->valueAt<StringView>(row);
   const auto* timeZone = tz::locateZone(std::string_view(timeZoneName));
   if (timestamp.has_value()) {
-    timestamp->toGMT(*timeZone);
+    toGMTWithGapCorrection(timestamp.value(), *timeZone);
     result->set(row, *timestamp);
   } else {
     result->setNull(row, true);
@@ -87,7 +88,7 @@ void setTimestampOrNull(
     const tz::TimeZone* timeZone,
     FlatVector<Timestamp>* result) {
   if (timestamp.has_value()) {
-    timestamp->toGMT(*timeZone);
+    toGMTWithGapCorrection(timestamp.value(), *timeZone);
     result->set(row, *timestamp);
   } else {
     result->setNull(row, true);
diff --git a/velox/functions/sparksql/Map.cpp b/velox/functions/sparksql/Map.cpp
index 7b56f9ab98cb..d1446a0ef905 100644
--- a/velox/functions/sparksql/Map.cpp
+++ b/velox/functions/sparksql/Map.cpp
@@ -33,23 +33,41 @@ namespace {
 
 void setKeysAndValuesResult(
     vector_size_t mapSize,
-    vector_size_t baseOffset,
     std::vector<VectorPtr>& args,
     const VectorPtr& keysResult,
     const VectorPtr& valuesResult,
+    const int32_t* offsets,
+    const int32_t* sizes,
     exec::EvalCtx& context,
     const SelectivityVector& rows) {
   exec::LocalDecodedVector decoded(context);
   SelectivityVector targetRows(keysResult->size(), false);
+  std::vector<vector_size_t> targetIdx(rows.size(), 0);
   std::vector<vector_size_t> toSourceRow(keysResult->size());
   for (vector_size_t i = 0; i < mapSize; i++) {
     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;
+      const auto offset = offsets[row];
+      const auto size = sizes[row];
+      bool duplicate = false;
+      if (size < mapSize) {
+        // Check if the current key at position i is duplicated in any later
+        // position. When a duplicate is found, mark this occurrence as
+        // duplicate and skip further checks. This implements the LAST_WIN
+        // policy where only the last occurrence of any key is kept.
+        for (vector_size_t j = i + 1; j < mapSize; j++) {
+          if (args[i * 2]->equalValueAt(args[j * 2].get(), row, row)) {
+            duplicate = true;
+            break;
+          }
+        }
+      }
+      if (size == mapSize || !duplicate) {
+        targetRows.setValid(offset + targetIdx[row], true);
+        toSourceRow[offset + targetIdx[row]] = row;
+        targetIdx[row]++;
+      }
     });
     targetRows.updateBounds();
     keysResult->copy(args[i * 2].get(), targetRows, toSourceRow.data());
@@ -99,26 +117,52 @@ class MapFunction : public exec::VectorFunction {
     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;
+
+    bool throwExceptionOnDuplicateMapKeys = false;
+    if (auto* ctx = context.execCtx()->queryCtx()) {
+      throwExceptionOnDuplicateMapKeys =
+          ctx->queryConfig().throwExceptionOnDuplicateMapKeys();
+    }
+
+    // Check for duplicate keys and set size & offsets.
     rows.applyToSelected([&](vector_size_t row) {
-      rawSizes[row] = mapSize;
+      vector_size_t duplicateCnt = 0;
+      for (vector_size_t i = 0; i < mapSize; i++) {
+        for (vector_size_t j = i + 1; j < mapSize; j++) {
+          if (args[i * 2]->equalValueAt(args[j * 2].get(), row, row)) {
+            if (throwExceptionOnDuplicateMapKeys) {
+              auto duplicateKey = args[i * 2]->toString(row);
+              VELOX_USER_FAIL(
+                  "Duplicate map key ({}) was found.", duplicateKey);
+            }
+            duplicateCnt++;
+          }
+        }
+      }
+      rawSizes[row] = mapSize - duplicateCnt;
       rawOffsets[row] = offset;
-      offset += mapSize;
+      offset += mapSize - duplicateCnt;
     });
 
     keysResult->resize(offset);
     valuesResult->resize(offset);
     setKeysAndValuesResult(
-        mapSize, baseOffset, args, keysResult, valuesResult, context, rows);
+        mapSize,
+        args,
+        keysResult,
+        valuesResult,
+        rawOffsets,
+        rawSizes,
+        context,
+        rows);
   }
 
   static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
-    // For the purpose of testing we introduce up to 6 inputs
+    // Support up to 10 key-value pairs (20 arguments) for MAP() function.
     // array(K), array(V) -> map(K,V)
     std::vector<std::shared_ptr<exec::FunctionSignature>> signatures;
-    constexpr int kNumberOfSignatures = 3;
+    constexpr int kNumberOfSignatures = 10;
     signatures.reserve(kNumberOfSignatures);
     for (int i = 1; i <= kNumberOfSignatures; i++) {
       auto builder = exec::FunctionSignatureBuilder()
diff --git a/velox/functions/sparksql/ReadSidePaddingFunction.h b/velox/functions/sparksql/ReadSidePaddingFunction.h
new file mode 100644
index 000000000000..ef31923aa4eb
--- /dev/null
+++ b/velox/functions/sparksql/ReadSidePaddingFunction.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/functions/lib/string/StringImpl.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// Right-pads the given input string with spaces(0x20) to the specified length.
+/// If the string's length is already greater than or equal to the specified
+/// length, it is returned as-is. Throws an exception if the specified length is
+/// not greater than 0.
+template <typename T>
+struct ReadSidePaddingFunction {
+  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>& input,
+      int32_t limit) {
+    doCall<false>(result, input, limit);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      int32_t limit) {
+    doCall<true>(result, input, limit);
+  }
+
+ private:
+  template <bool isAscii>
+  FOLLY_ALWAYS_INLINE void doCall(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      int32_t limit) {
+    VELOX_USER_CHECK_GT(limit, 0, "The length limit must be greater than 0.");
+
+    auto numCharacters = stringImpl::length<isAscii>(input);
+
+    if (numCharacters < limit) {
+      // Rpad spaces(0x20) to limit.
+      stringImpl::pad</*lpad=*/false, isAscii>(result, input, limit, {" "});
+    } else {
+      result.setNoCopy(input);
+    }
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/SimpleComparisonMatcher.h b/velox/functions/sparksql/SimpleComparisonMatcher.h
new file mode 100644
index 000000000000..d754d61d0e82
--- /dev/null
+++ b/velox/functions/sparksql/SimpleComparisonMatcher.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/SimpleComparisonMatcher.h"
+
+namespace facebook::velox::functions::sparksql {
+
+namespace {
+inline const std::string eq = "equalto";
+inline const std::string lt = "lessthan";
+inline const std::string gt = "greaterthan";
+} // namespace
+
+class SparkComparisonMatcher : public ComparisonMatcher {
+ public:
+  SparkComparisonMatcher(
+      const std::string& prefix,
+      const std::vector<std::shared_ptr<Matcher>>& inputMatchers,
+      std::string* op)
+      : ComparisonMatcher(prefix, inputMatchers, op) {}
+
+  bool exprNameMatch(const std::string& name) override {
+    return name == prefix_ + eq || name == prefix_ + lt || name == prefix_ + gt;
+  }
+};
+
+class SparkSimpleComparisonChecker : public SimpleComparisonChecker {
+ public:
+  ~SparkSimpleComparisonChecker() override = default;
+
+ protected:
+  std::shared_ptr<Matcher> comparison(
+      const std::string& prefix,
+      const std::shared_ptr<Matcher>& left,
+      const std::shared_ptr<Matcher>& right,
+      std::string* op) override {
+    return std::make_shared<SparkComparisonMatcher>(
+        prefix, std::vector<std::shared_ptr<Matcher>>{left, right}, op);
+  }
+
+  std::string eqName(const std::string& prefix) override {
+    return prefix + eq;
+  }
+
+  std::string ltName(const std::string& prefix) override {
+    return prefix + lt;
+  }
+
+  std::string gtName(const std::string& prefix) override {
+    return prefix + gt;
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/Split.h b/velox/functions/sparksql/Split.h
index e9666b6448da..5ee0272018bc 100644
--- a/velox/functions/sparksql/Split.h
+++ b/velox/functions/sparksql/Split.h
@@ -47,9 +47,13 @@ struct Split {
       const std::vector<TypePtr>& /*inputTypes*/,
       const core::QueryConfig& config,
       const arg_type<Varchar>* /*input*/,
-      const arg_type<Varchar>* /*delimiter*/,
+      const arg_type<Varchar>* delimiter,
       const arg_type<int32_t>* /*limit*/) {
     cache_.setMaxCompiledRegexes(config.exprMaxCompiledRegexes());
+    if (delimiter) {
+      initializeFastPath(delimiter->data(), delimiter->size());
+      isConstantDelimiter_ = true;
+    }
   }
 
   FOLLY_ALWAYS_INLINE void call(
@@ -72,7 +76,7 @@ struct Split {
       out_type<Array<Varchar>>& result,
       const arg_type<Varchar>& input,
       const arg_type<Varchar>& delimiter,
-      int32_t limit) const {
+      int32_t limit) {
     if (delimiter.empty()) {
       splitEmptyDelimiter(result, input, limit);
     } else {
@@ -80,6 +84,26 @@ struct Split {
     }
   }
 
+  // Checks if a string represents an octal-escaped ascii character (e.g.,
+  // \123). If valid, converts it to its decimal value.
+  bool isOctalString(const char* str, char& decimal, size_t size) const {
+    if (size > 4 || str[0] != '\\') {
+      return false;
+    }
+    for (int i = 1; i < size; ++i) {
+      char ch = str[i];
+      if (ch < '0' || ch > '7') {
+        return false;
+      }
+    }
+    // The ascii octal number should not exceed 177.
+    if (std::stoi(str + 1) > 177) {
+      return false;
+    }
+    decimal = std::stoi(str + 1, nullptr, 8);
+    return true;
+  }
+
   // 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", ""].
@@ -113,6 +137,37 @@ struct Split {
     }
   }
 
+  // Fast path if the delimiter is a
+  // (1)one-char string and this character is not one of the RegEx's meta
+  // characters ".$|()[{^?*+\\", or
+  // (2)two-char string and the first char is the backslash and the second is
+  // not the ascii digit or ascii letter, or
+  // (3)octal string that falls within the range of ASCII characters.
+  void initializeFastPath(const char* delimiterStr, size_t delimiterSize) {
+    // Referencing from
+    // https://github.com/openjdk/jdk8/blob/master/jdk/src/share/classes/java/lang/String.java#L2325
+    // to align with Spark.
+    const std::string reservedChars = ".$|()[{^?*+\\";
+
+    if (delimiterSize == 1) {
+      singleCharDelimiter_ = delimiterStr[0];
+      if (reservedChars.find(singleCharDelimiter_) == std::string::npos) {
+        fastPath_ = true;
+      }
+    } else if (delimiterSize == 2 && delimiterStr[0] == '\\') {
+      singleCharDelimiter_ = delimiterStr[1];
+      if (!std::isdigit(singleCharDelimiter_) &&
+          !std::isalpha(singleCharDelimiter_)) {
+        fastPath_ = true;
+      }
+    } else if (isOctalString(
+                   delimiterStr, singleCharDelimiter_, delimiterSize)) {
+      fastPath_ = true;
+    } else {
+      fastPath_ = false;
+    }
+  }
+
   // 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,
@@ -122,7 +177,7 @@ struct Split {
       out_type<Array<Varchar>>& result,
       const arg_type<Varchar>& input,
       const arg_type<Varchar>& delimiter,
-      int32_t limit) const {
+      int32_t limit) {
     VELOX_DCHECK(!delimiter.empty(), "Non-empty delimiter is expected");
 
     // Trivial case of converting string to array with 1 element.
@@ -134,52 +189,69 @@ struct Split {
     // 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;
-      }
+    if (!isConstantDelimiter_) {
+      initializeFastPath(delimiter.data(), delimiter.size());
+    }
 
-      // 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) {
-        int32_t codePoint;
-        auto charLength =
-            tryGetUtf8CharLength(start + pos, end - pos, codePoint);
-        if (charLength <= 0) {
-          // Invalid UTF-8 character, the length of the invalid
-          // character is the absolute value of result of
-          // `tryGetUtf8CharLength`.
-          charLength = -charLength;
+    if (fastPath_) {
+      for (size_t i = 0; i < end; ++i) {
+        if (start[i] == singleCharDelimiter_) {
+          result.add_item().setNoCopy(StringView(start + pos, i - pos));
+          pos = i + 1;
+          ++addedElements;
+          if (addedElements + 1 == limit) {
+            break;
+          }
         }
-        offset += charLength;
       }
-      result.add_item().setNoCopy(StringView(start + pos, offset - pos));
-      pos = offset + size;
+    } else {
+      auto* re = cache_.findOrCompile(delimiter);
+      const auto re2String = re2::StringPiece(start, end);
+      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;
+        }
 
-      ++addedElements;
-      // If the next element should be the last, leave the loop.
-      if (addedElements + 1 == limit) {
-        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) {
+          int32_t codePoint;
+          auto charLength =
+              tryGetUtf8CharLength(start + pos, end - pos, codePoint);
+          if (charLength <= 0) {
+            // Invalid UTF-8 character, the length of the invalid
+            // character is the absolute value of result of
+            // `tryGetUtf8CharLength`.
+            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;
+        }
       }
     }
 
@@ -189,5 +261,9 @@ struct Split {
   }
 
   mutable facebook::velox::functions::detail::ReCache cache_;
+  bool fastPath_{false};
+  // Single character delimiter for fast path.
+  char singleCharDelimiter_;
+  bool isConstantDelimiter_{false};
 };
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/String.cpp b/velox/functions/sparksql/String.cpp
index 8e72c8614cca..4b7b47a24f30 100644
--- a/velox/functions/sparksql/String.cpp
+++ b/velox/functions/sparksql/String.cpp
@@ -18,14 +18,12 @@
 #include "velox/functions/lib/string/StringCore.h"
 
 namespace facebook::velox::functions::sparksql {
+namespace {
 
 using namespace stringCore;
-namespace {
 
 template <bool isAscii>
-int32_t instr(
-    const folly::StringPiece haystack,
-    const folly::StringPiece needle) {
+int32_t instr(const std::string_view haystack, const std::string_view needle) {
   int32_t offset = haystack.find(needle);
   if constexpr (isAscii) {
     return offset + 1;
@@ -58,13 +56,18 @@ class Instr : public exec::VectorFunction {
       selected.applyToSelected([&](vector_size_t row) {
         auto h = haystack->valueAt<StringView>(row);
         auto n = needle->valueAt<StringView>(row);
-        output->set(row, instr<true>(h, n));
+
+        // TODO: Remove explicit std::string_view cast.
+        output->set(row, instr<true>(std::string_view(h), std::string_view(n)));
       });
     } else {
       selected.applyToSelected([&](vector_size_t row) {
         auto h = haystack->valueAt<StringView>(row);
         auto n = needle->valueAt<StringView>(row);
-        output->set(row, instr<false>(h, n));
+
+        // TODO: Remove explicit std::string_view cast.
+        output->set(
+            row, instr<false>(std::string_view(h), std::string_view(n)));
       });
     }
   }
diff --git a/velox/functions/sparksql/String.h b/velox/functions/sparksql/String.h
index b90b9b851d33..46b4080db3be 100644
--- a/velox/functions/sparksql/String.h
+++ b/velox/functions/sparksql/String.h
@@ -1555,5 +1555,4 @@ struct Empty2NullFunction {
     return true;
   }
 };
-
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/TimestampUtils.cpp b/velox/functions/sparksql/TimestampUtils.cpp
new file mode 100644
index 000000000000..3d46f91bba25
--- /dev/null
+++ b/velox/functions/sparksql/TimestampUtils.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/sparksql/TimestampUtils.h"
+
+namespace facebook::velox::functions::sparksql {
+
+void toGMTWithGapCorrection(Timestamp& time, const tz::TimeZone& zone) {
+  time = Timestamp(
+      zone.correct_nonexistent_time(std::chrono::seconds(time.getSeconds()))
+          .count(),
+      time.getNanos());
+  time.toGMT(zone);
+}
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/TimestampUtils.h b/velox/functions/sparksql/TimestampUtils.h
new file mode 100644
index 000000000000..747af21fcbb3
--- /dev/null
+++ b/velox/functions/sparksql/TimestampUtils.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 "velox/type/Timestamp.h"
+#include "velox/type/tz/TimeZoneMap.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// Lenient conversion of local 'time' to the GMT time.
+/// If the 'time' is invalid (DST gap), it will be corrected by
+/// shifting forward to the nearest valid time.
+void toGMTWithGapCorrection(Timestamp& time, const tz::TimeZone& zone);
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/ToJson.h b/velox/functions/sparksql/ToJson.h
new file mode 100644
index 000000000000..e4b81a886e8b
--- /dev/null
+++ b/velox/functions/sparksql/ToJson.h
@@ -0,0 +1,424 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/ComplexViewTypes.h"
+#include "velox/functions/lib/DateTimeFormatter.h"
+#include "velox/functions/lib/TimeUtils.h"
+#include "velox/type/DecimalUtil.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace detail {
+
+struct JsonOptions {
+  const tz::TimeZone* timeZone;
+
+  // Whether to ignore null fields during json generating.
+  const bool ignoreNullFields{true};
+};
+
+template <typename T>
+std::enable_if_t<std::is_floating_point_v<T>, void>
+append(T value, std::string& result, bool isMapKey) {
+  if (!isMapKey && 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());
+  }
+}
+
+template <typename T>
+void appendDecimal(T value, const Type& type, std::string& result) {
+  auto [precision, scale] = getDecimalPrecisionScale(type);
+  const size_t maxSize = DecimalUtil::maxStringViewSize(precision, scale);
+  std::vector<char> buffer(maxSize);
+  size_t len = DecimalUtil::castToString(value, scale, maxSize, buffer.data());
+  result.append(buffer.data(), len);
+}
+
+// Forward declarations for explicit specializations.
+template <TypeKind kind>
+void toJson(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey = false);
+
+template <>
+void toJson<TypeKind::ROW>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey);
+
+template <>
+void toJson<TypeKind::ARRAY>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey);
+
+template <>
+void toJson<TypeKind::MAP>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey);
+
+// Primary specialization for unsupported types.
+template <TypeKind kind>
+void toJson(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey) {
+  VELOX_USER_FAIL("{} is not supported in to_json.", kind);
+}
+
+// Convert primitive-type input to Json string.
+template <>
+inline void toJson<TypeKind::BOOLEAN>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool /*isMapKey*/) {
+  auto value = input.castTo<bool>();
+  constexpr std::string_view kTrue = "true";
+  constexpr std::string_view kFalse = "false";
+  result.append(value ? kTrue : kFalse);
+}
+
+template <>
+inline void toJson<TypeKind::TINYINT>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool /*isMapKey*/) {
+  auto value = input.castTo<int8_t>();
+  folly::toAppend<std::string, int8_t>(value, &result);
+}
+
+template <>
+inline void toJson<TypeKind::SMALLINT>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool /*isMapKey*/) {
+  auto value = input.castTo<int16_t>();
+  folly::toAppend<std::string, int16_t>(value, &result);
+}
+
+template <>
+inline void toJson<TypeKind::INTEGER>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool isMapKey) {
+  auto value = input.castTo<int32_t>();
+  if (!isMapKey && input.type()->isDate()) {
+    result.append("\"").append(DATE()->toString(value)).append("\"");
+  } else {
+    folly::toAppend<std::string, int32_t>(value, &result);
+  }
+}
+
+template <>
+inline void toJson<TypeKind::BIGINT>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool /*isMapKey*/) {
+  auto value = input.castTo<int64_t>();
+  if (input.type()->isDecimal()) {
+    appendDecimal(value, *input.type(), result);
+  } else {
+    folly::toAppend<std::string, int64_t>(value, &result);
+  }
+}
+
+template <>
+inline void toJson<TypeKind::HUGEINT>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool /*isMapKey*/) {
+  VELOX_DCHECK(input.type()->isDecimal(), "HUGEINT must be a decimal type.");
+  auto value = input.castTo<int128_t>();
+  appendDecimal(value, *input.type(), result);
+}
+
+template <>
+inline void toJson<TypeKind::REAL>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool isMapKey) {
+  auto value = input.castTo<float>();
+  append(value, result, isMapKey);
+}
+
+template <>
+inline void toJson<TypeKind::DOUBLE>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool isMapKey) {
+  auto value = input.castTo<double>();
+  append(value, result, isMapKey);
+}
+
+template <>
+inline void toJson<TypeKind::VARCHAR>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& /*options*/,
+    bool isMapKey) {
+  auto value = input.castTo<Varchar>();
+  if (!isMapKey) {
+    folly::json::escapeString(std::string_view(value), result, {});
+  } else {
+    // toJson<TypeKind::MAP> wraps the key with double quotes.
+    // To avoid duplicate quotes, we strip the surrounding quotes after
+    // escaping.
+    std::string quotedString;
+    folly::json::escapeString(std::string_view(value), quotedString, {});
+    result.append(quotedString.substr(1, quotedString.size() - 2));
+  }
+}
+
+template <>
+inline void toJson<TypeKind::TIMESTAMP>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey) {
+  auto value = input.castTo<Timestamp>();
+  if (isMapKey) {
+    folly::toAppend<std::string, int64_t>(value.toMicros(), &result);
+  } else {
+    // Spark converts Timestamp in ISO8601 format by default.
+    static const auto formatter =
+        functions::buildJodaDateTimeFormatter("yyyy-MM-dd'T'HH:mm:ss.SSSZZ")
+            .value();
+    const auto maxSize = formatter->maxResultSize(options.timeZone);
+    std::vector<char> buffer(maxSize);
+    auto size = formatter->format(
+        value, options.timeZone, maxSize, buffer.data(), false, "Z");
+    result.append("\"").append(buffer.data(), size).append("\"");
+  }
+}
+
+// Convert complex-type input to Json string.
+template <>
+inline void toJson<TypeKind::ROW>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey) {
+  auto rowType = std::static_pointer_cast<const RowType>(input.type());
+  auto row = input.castTo<DynamicRow>();
+  result.append(isMapKey ? "[" : "{");
+  bool commaBefore = false;
+  for (int i = 0; i < rowType->size(); i++) {
+    auto data = row.at(i);
+    if (data.has_value()) {
+      if (commaBefore) {
+        result.append(",");
+      }
+      if (!isMapKey) {
+        result.append("\"");
+        result.append(rowType->nameOf(i));
+        result.append("\":");
+      }
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+          detail::toJson,
+          data->kind(),
+          data.value(),
+          result,
+          options,
+          isMapKey);
+      commaBefore = true;
+    } else if (isMapKey) {
+      if (commaBefore) {
+        result.append(",");
+      }
+      result.append("null");
+      commaBefore = true;
+    } else if (!options.ignoreNullFields) {
+      if (commaBefore) {
+        result.append(",");
+      }
+      result.append("\"");
+      result.append(rowType->nameOf(i));
+      result.append("\":null");
+      commaBefore = true;
+    }
+  }
+  result.append(isMapKey ? "]" : "}");
+}
+
+template <>
+inline void toJson<TypeKind::ARRAY>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey) {
+  auto arrayView = input.castTo<Array<Any>>();
+  result.append("[");
+  for (int i = 0; i < arrayView.size(); i++) {
+    if (i > 0) {
+      result.append(",");
+    }
+    if (arrayView[i].has_value()) {
+      auto element = arrayView[i].value();
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+          detail::toJson, element.kind(), element, result, options, isMapKey);
+    } else {
+      result.append("null");
+    }
+  }
+  result.append("]");
+}
+
+template <>
+inline void toJson<TypeKind::MAP>(
+    const exec::GenericView& input,
+    std::string& result,
+    const JsonOptions& options,
+    bool isMapKey) {
+  auto mapView = input.castTo<Map<Any, Any>>();
+  result.append("{");
+  for (int i = 0; i < mapView.size(); i++) {
+    if (i > 0) {
+      result.append(",");
+    }
+    auto element = mapView.atIndex(i);
+    auto key = element.first;
+    auto value = element.second;
+    result.append("\"");
+    VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+        detail::toJson, key.kind(), key, result, options, true);
+    result.append("\":");
+    if (value.has_value()) {
+      VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+          detail::toJson,
+          value.value().kind(),
+          value.value(),
+          result,
+          options,
+          isMapKey);
+    } else {
+      result.append("null");
+    }
+  }
+  result.append("}");
+}
+} // namespace detail
+
+// ToJsonFunction converts a Json object(ROW, ARRAY, or MAP) to a Json string.
+template <typename T>
+struct ToJsonFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      const void* input) {
+    initialize(inputTypes, config, input, nullptr);
+  }
+
+  FOLLY_ALWAYS_INLINE void initialize(
+      const std::vector<TypePtr>& inputTypes,
+      const core::QueryConfig& config,
+      const void* /*input*/,
+      const void* /*timeZone*/) {
+    VELOX_USER_CHECK(
+        isSupportedType(inputTypes[0], true),
+        "to_json function does not support type {}.",
+        inputTypes[0]->toString());
+    sessionTimezone_ = getTimeZoneFromConfig(config);
+    ignoreNullFields_ = config.sparkJsonIgnoreNullFields();
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Generic<T1>>& input) {
+    return callImpl(result, input, sessionTimezone_);
+  }
+
+  FOLLY_ALWAYS_INLINE bool call(
+      out_type<Varchar>& result,
+      const arg_type<Generic<T1>>& input,
+      const arg_type<Varchar>& timeZone) {
+    auto tz = tz::locateZone(std::string_view(timeZone));
+    return callImpl(result, input, tz);
+  }
+
+ private:
+  // Determine whether a given input type is supported.
+  // 1. The root type can only be ROW, ARRAY, and MAP.
+  // 2. The key type of MAP cannot be/contain MAP.
+  bool isSupportedType(
+      const TypePtr& type,
+      bool isRootType = false,
+      bool isMapKey = false) {
+    switch (type->kind()) {
+      case TypeKind::ROW: {
+        for (const auto& child : asRowType(type)->children()) {
+          if (!isSupportedType(child, false, isMapKey)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      case TypeKind::ARRAY: {
+        return isSupportedType(type->childAt(0), false, isMapKey);
+      }
+      case TypeKind::MAP: {
+        return !isMapKey && isSupportedType(type->childAt(0), false, true) &&
+            isSupportedType(type->childAt(1));
+      }
+      default:
+        return !isRootType;
+    }
+  }
+
+  FOLLY_ALWAYS_INLINE bool callImpl(
+      out_type<Varchar>& result,
+      const arg_type<Generic<T1>>& input,
+      const tz::TimeZone* timeZone) {
+    std::string res;
+    VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+        detail::toJson,
+        input.kind(),
+        input,
+        res,
+        detail::JsonOptions{
+            .timeZone = timeZone, .ignoreNullFields = ignoreNullFields_});
+    result.resize(res.size());
+    std::memcpy(result.data(), res.c_str(), res.size());
+    return true;
+  }
+
+  const tz::TimeZone* sessionTimezone_;
+  bool ignoreNullFields_;
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/UnBase64Function.h b/velox/functions/sparksql/UnBase64Function.h
new file mode 100644
index 000000000000..cf9af099afbe
--- /dev/null
+++ b/velox/functions/sparksql/UnBase64Function.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/common/encode/Base64.h"
+#include "velox/functions/Macros.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// UnBase64Function decodes a base64-encoded input string into its original
+/// binary form. It uses the Base64 MIME decoding functions provided by
+/// velox::encoding. Returns a Status indicating success or error during
+/// decoding.
+template <typename T>
+struct UnBase64Function {
+  VELOX_DEFINE_FUNCTION_TYPES(T);
+
+  // Decodes the base64-encoded input and stores the result in 'result'.
+  // Returns a Status object indicating success or failure.
+  FOLLY_ALWAYS_INLINE Status
+  call(out_type<Varbinary>& result, const arg_type<Varchar>& input) {
+    auto decodedSize =
+        encoding::Base64::calculateMimeDecodedSize(input.data(), input.size());
+    if (decodedSize.hasError()) {
+      return decodedSize.error();
+    }
+    result.resize(decodedSize.value());
+    return encoding::Base64::decodeMime(
+        input.data(), input.size(), result.data());
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/VarcharTypeWriteSideCheck.h b/velox/functions/sparksql/VarcharTypeWriteSideCheck.h
new file mode 100644
index 000000000000..70eadd55a8ad
--- /dev/null
+++ b/velox/functions/sparksql/VarcharTypeWriteSideCheck.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 <string>
+
+#include "velox/functions/Macros.h"
+#include "velox/functions/lib/string/StringImpl.h"
+#include "velox/functions/sparksql/CharVarcharUtils.h"
+
+namespace facebook::velox::functions::sparksql {
+
+/// Ensures that `'abc'` fits within the specified length `n` in
+/// characters. If the length of `'abc'` exceeds `n`, trailing spaces
+/// are trimmed to fit within `n`. If the length of `'abc'` is less than
+/// or equal to `n`, it is returned as-is. Throws an exception if the
+/// trimmed string still exceeds `n` or if `n` is negative. This function
+/// will trim at most (length of `'abc'` - `n`) space characters (ASCII 32)
+/// from the end of `'abc'`.
+template <typename T>
+struct VarcharTypeWriteSideCheckFunction {
+  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>& input,
+      int32_t limit) {
+    doCall<false>(result, input, limit);
+  }
+
+  FOLLY_ALWAYS_INLINE void callAscii(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      int32_t limit) {
+    doCall<true>(result, input, limit);
+  }
+
+ private:
+  template <bool isAscii>
+  FOLLY_ALWAYS_INLINE void doCall(
+      out_type<Varchar>& result,
+      const arg_type<Varchar>& input,
+      int32_t limit) {
+    VELOX_USER_CHECK_GT(limit, 0, "The length limit must be greater than 0.");
+
+    auto numCharacters = stringImpl::length<isAscii>(input);
+    if (numCharacters <= limit) {
+      result.setNoCopy(input);
+    } else {
+      trimTrailingSpaces(result, input, numCharacters, limit);
+    }
+  }
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/aggregates/AverageAggregate.cpp b/velox/functions/sparksql/aggregates/AverageAggregate.cpp
index 623657df3a79..7397e1da5447 100644
--- a/velox/functions/sparksql/aggregates/AverageAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/AverageAggregate.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/functions/sparksql/aggregates/AverageAggregate.h"
 #include "velox/functions/lib/aggregates/AverageAggregateBase.h"
+#include "velox/functions/sparksql/aggregates/DecimalAverageAggregate.h"
 
 using namespace facebook::velox::functions::aggregate;
 
@@ -74,6 +75,37 @@ class AverageAggregate
   }
 };
 
+TypePtr getAvgResultType(const TypePtr& rawInputType) {
+  auto [p, s] = getDecimalPrecisionScale(*rawInputType.get());
+  // In Spark,
+  // final avg result precision = input precision + 4
+  // final avg result scale = input scale + 4
+  return DECIMAL(
+      std::min<uint8_t>(LongDecimalType::kMaxPrecision, p + 4),
+      std::min<uint8_t>(LongDecimalType::kMaxPrecision, s + 4));
+}
+
+std::unique_ptr<exec::Aggregate> getDecimalAverageAggregate(
+    core::AggregationNode::Step step,
+    const std::vector<TypePtr>& argTypes,
+    const TypePtr& resultType) {
+  auto inputType = argTypes[0];
+  VELOX_USER_CHECK(inputType->isDecimal());
+  auto avgType = getAvgResultType(inputType);
+  if (inputType->isShortDecimal()) {
+    if (avgType->isShortDecimal()) {
+      return std::make_unique<exec::SimpleAggregateAdapter<
+          DecimalAverageAggregate<int64_t, int64_t>>>(
+          step, argTypes, resultType);
+    }
+    return std::make_unique<exec::SimpleAggregateAdapter<
+        DecimalAverageAggregate<int64_t, int128_t>>>(
+        step, argTypes, resultType);
+  }
+  return std::make_unique<exec::SimpleAggregateAdapter<
+      DecimalAverageAggregate<int128_t, int128_t>>>(step, argTypes, resultType);
+}
+
 } // namespace
 
 /// Count is BIGINT() while sum and the final aggregates type depends on
@@ -92,20 +124,25 @@ exec::AggregateRegistrationResult registerAverage(
 
   for (const auto& inputType :
        {"smallint", "integer", "bigint", "real", "double"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("double")
-                             .intermediateType("row(double,bigint)")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("double")
+            .intermediateType("row(double,bigint)")
+            .argumentType(inputType)
+            .build());
   }
 
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .integerVariable("a_precision")
-                           .integerVariable("a_scale")
-                           .argumentType("DECIMAL(a_precision, a_scale)")
-                           .intermediateType("varbinary")
-                           .returnType("DECIMAL(a_precision, a_scale)")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .integerVariable("i_precision", "min(38, a_precision + 10)")
+          .integerVariable("r_precision", "min(38, a_precision + 4)")
+          .integerVariable("r_scale", "min(38, a_scale + 4)")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("ROW(DECIMAL(i_precision, a_scale), BIGINT)")
+          .returnType("DECIMAL(r_precision, r_scale)")
+          .build());
 
   return exec::registerAggregateFunction(
       name,
@@ -118,7 +155,7 @@ exec::AggregateRegistrationResult registerAverage(
           -> std::unique_ptr<exec::Aggregate> {
         VELOX_CHECK_LE(
             argTypes.size(), 1, "{} takes at most one argument", name);
-        auto inputType = argTypes[0];
+        const auto& inputType = argTypes[0];
         if (exec::isRawInput(step)) {
           switch (inputType->kind()) {
             case TypeKind::SMALLINT:
@@ -129,16 +166,26 @@ exec::AggregateRegistrationResult registerAverage(
                   AverageAggregate<int32_t, double, double>>(resultType);
             case TypeKind::BIGINT: {
               if (inputType->isShortDecimal()) {
-                return std::make_unique<DecimalAverageAggregateBase<int64_t>>(
-                    resultType);
+                auto precision =
+                    getDecimalPrecisionScale(*inputType.get()).first;
+                // Spark has an optimization rule named DecimalAggregate that
+                // converts input data to a Long for average calculation when
+                // the input data is of type decimal and the precision is <= 11.
+                // Therefore, the precision of the decimal inputs received by
+                // the decimal average is guaranteed to be > 11. Since the
+                // precision of the intermediate sum is input precision + 10, it
+                // will definitely be > 21, which means the intermediate sum
+                // will always be a long decimal. We can directly assume that
+                // the physical type of the intermediate sum is int128_t.
+                VELOX_USER_CHECK_GT(precision, 11);
+                return getDecimalAverageAggregate(step, argTypes, resultType);
               }
               return std::make_unique<
                   AverageAggregate<int64_t, double, double>>(resultType);
             }
             case TypeKind::HUGEINT: {
               if (inputType->isLongDecimal()) {
-                return std::make_unique<DecimalAverageAggregateBase<int128_t>>(
-                    resultType);
+                return getDecimalAverageAggregate(step, argTypes, resultType);
               }
               VELOX_NYI();
             }
@@ -162,28 +209,24 @@ exec::AggregateRegistrationResult registerAverage(
                   resultType);
             case TypeKind::DOUBLE:
             case TypeKind::ROW:
+              if (inputType->childAt(0)->isDecimal()) {
+                return std::make_unique<
+                    exec::SimpleAggregateAdapter<DecimalAverageAggregate<
+                        int128_t /*unused*/,
+                        int128_t /*unused*/>>>(step, argTypes, resultType);
+              }
               return std::make_unique<
                   AverageAggregate<int64_t, double, double>>(resultType);
             case TypeKind::BIGINT:
-              return std::make_unique<DecimalAverageAggregateBase<int64_t>>(
-                  resultType);
+              VELOX_USER_CHECK(resultType->isShortDecimal());
+              return std::make_unique<exec::SimpleAggregateAdapter<
+                  DecimalAverageAggregate<int64_t /*unused*/, int64_t>>>(
+                  step, argTypes, resultType);
             case TypeKind::HUGEINT:
-              return std::make_unique<DecimalAverageAggregateBase<int128_t>>(
-                  resultType);
-            case TypeKind::VARBINARY:
-              if (inputType->isLongDecimal()) {
-                return std::make_unique<DecimalAverageAggregateBase<int128_t>>(
-                    resultType);
-              } else if (
-                  inputType->isShortDecimal() ||
-                  inputType->kind() == TypeKind::VARBINARY) {
-                // If the input and out type are VARBINARY, then the
-                // LongDecimalWithOverflowState is used and the template type
-                // does not matter.
-                return std::make_unique<DecimalAverageAggregateBase<int64_t>>(
-                    resultType);
-              }
-              [[fallthrough]];
+              VELOX_USER_CHECK(resultType->isLongDecimal());
+              return std::make_unique<exec::SimpleAggregateAdapter<
+                  DecimalAverageAggregate<int128_t /*unused*/, int128_t>>>(
+                  step, argTypes, resultType);
             default:
               VELOX_FAIL(
                   "Unsupported result type for final aggregation: {}",
diff --git a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
index 13c3deeba7d3..694333eb6c8e 100644
--- a/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/BitwiseXorAggregate.cpp
@@ -70,7 +70,7 @@ exec::AggregateRegistrationResult registerBitwiseXorAggregate(
     bool withCompanionFunctions,
     bool overwrite) {
   return functions::aggregate::registerBitwise<BitwiseXorAggregate>(
-      prefix + "bit_xor", withCompanionFunctions, false, overwrite);
+      prefix + "bit_xor", false, withCompanionFunctions, false, overwrite);
 }
 
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/CMakeLists.txt b/velox/functions/sparksql/aggregates/CMakeLists.txt
index 4c41154a577e..679bb243a7ca 100644
--- a/velox/functions/sparksql/aggregates/CMakeLists.txt
+++ b/velox/functions/sparksql/aggregates/CMakeLists.txt
@@ -27,7 +27,8 @@ velox_add_library(
   Register.cpp
   RegrReplacementAggregate.cpp
   SumAggregate.cpp
-  VarianceAggregate.cpp)
+  VarianceAggregate.cpp
+)
 
 velox_link_libraries(
   velox_functions_spark_aggregates
@@ -35,7 +36,8 @@ velox_link_libraries(
   velox_exec
   velox_expression_functions
   velox_aggregates
-  velox_vector)
+  velox_vector
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp b/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp
index 15ae6dc5514f..07710cae7269 100644
--- a/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/CollectSetAggregate.cpp
@@ -103,9 +103,10 @@ void registerCollectSetAggAggregate(
                 resultType);
           default:
             VELOX_UNSUPPORTED(
-                "Unsupported type {}", mapTypeKindToName(typeKind));
+                "Unsupported type {}", TypeKindName::toName(typeKind));
         }
       },
+      {.ignoreDuplicates = true},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/sparksql/aggregates/CovarianceAggregate.cpp b/velox/functions/sparksql/aggregates/CovarianceAggregate.cpp
index 5beb9aa41c9f..4a79502a7ad6 100644
--- a/velox/functions/sparksql/aggregates/CovarianceAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/CovarianceAggregate.cpp
@@ -40,6 +40,9 @@ struct CovarSampResultAccessor {
           "NaN is returned only when m2 is 0 and nullOnDivideByZero is false.");
       return std::numeric_limits<double>::quiet_NaN();
     }
+    if (FOLLY_UNLIKELY(std::isinf(accumulator.c2()))) {
+      return std::numeric_limits<double>::quiet_NaN();
+    }
     return accumulator.c2() / (accumulator.count() - 1);
   }
 };
@@ -47,24 +50,34 @@ struct CovarSampResultAccessor {
 template <bool nullOnDivideByZero>
 struct CorrResultAccessor {
   static bool hasResult(const CorrAccumulator& accumulator) {
-    if constexpr (nullOnDivideByZero) {
-      if (accumulator.count() == 1) {
+    if (accumulator.count() == 1) {
+      if constexpr (nullOnDivideByZero) {
         return false;
-      }
-      return accumulator.m2X() != 0 && accumulator.m2Y() != 0;
-    } else {
-      if (accumulator.count() == 1) {
+      } else {
         return true;
       }
-      return accumulator.m2X() != 0 && accumulator.m2Y() != 0;
     }
+
+    // Returns true if any of the following conditions are met:
+    // 1. m2Y or m2X or c2 is NaN.
+    // 2. m2Y and m2X are not zero.
+    return std::isnan(accumulator.m2Y()) || std::isnan(accumulator.m2X()) ||
+        std::isnan(accumulator.c2()) ||
+        (accumulator.m2Y() != 0 && accumulator.m2X() != 0);
   }
 
   static double result(const CorrAccumulator& accumulator) {
     if (accumulator.count() == 1) {
-      VELOX_CHECK(
-          !nullOnDivideByZero,
-          "NaN is returned only when m2 is 0 and nullOnDivideByZero is false.");
+      if constexpr (!nullOnDivideByZero) {
+        return std::numeric_limits<double>::quiet_NaN();
+      } else {
+        VELOX_UNREACHABLE();
+      }
+    }
+
+    if (FOLLY_UNLIKELY(
+            std::isnan(accumulator.m2Y()) || std::isnan(accumulator.m2X()) ||
+            std::isnan(accumulator.c2()))) {
       return std::numeric_limits<double>::quiet_NaN();
     }
     double stddevX = std::sqrt(accumulator.m2X());
@@ -77,8 +90,7 @@ template <
     typename TAccumulator,
     typename TIntermediateInput,
     typename TIntermediateResult,
-    template <bool>
-    class TResultAccessor>
+    template <bool> class TResultAccessor>
 exec::AggregateRegistrationResult registerCovariance(
     const std::string& name,
     bool withCompanionFunctions,
diff --git a/velox/functions/sparksql/aggregates/DecimalAverageAggregate.h b/velox/functions/sparksql/aggregates/DecimalAverageAggregate.h
new file mode 100644
index 000000000000..6a35f09f995e
--- /dev/null
+++ b/velox/functions/sparksql/aggregates/DecimalAverageAggregate.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/exec/SimpleAggregateAdapter.h"
+#include "velox/functions/sparksql/DecimalUtil.h"
+
+namespace facebook::velox::functions::aggregate::sparksql {
+namespace detail {
+
+inline TypePtr getSumType(const TypePtr& rawInputType) {
+  if (rawInputType->isRow()) {
+    return rawInputType->childAt(0);
+  }
+  auto [p, s] = getDecimalPrecisionScale(*rawInputType.get());
+  // In Spark,
+  // intermediate sum precision = input precision + 10
+  // intermediate sum scale = input scale
+  return DECIMAL(std::min<uint8_t>(LongDecimalType::kMaxPrecision, p + 10), s);
+}
+
+} // namespace detail
+
+/// @tparam TInputType The raw input data type.
+/// @tparam TResultType The type of the output average value.
+template <typename TInputType, typename TResultType>
+class DecimalAverageAggregate {
+ public:
+  using InputType = Row<TInputType>;
+
+  using IntermediateType = Row</*sum*/ int128_t,
+                               /*count*/ int64_t>;
+
+  using OutputType = TResultType;
+
+  /// 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 count = 0. 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, count = 0. nonNullGroup is only available when
+  /// default-null behavior is disabled.
+  static constexpr bool default_null_behavior_ = false;
+
+  void initialize(
+      core::AggregationNode::Step step,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& resultType) {
+    VELOX_CHECK_EQ(argTypes.size(), 1);
+    auto inputType = argTypes[0];
+    this->sumType_ = detail::getSumType(inputType);
+    this->resultType_ = resultType;
+  }
+
+  static bool toIntermediate(
+      exec::out_type<Row<int128_t, int64_t>>& out,
+      exec::optional_arg_type<TInputType> in) {
+    if (in.has_value()) {
+      out.copy_from(std::make_tuple(in.value(), 1));
+    } else {
+      out.copy_from(std::make_tuple(0, 0));
+    }
+    return true;
+  }
+
+  /// This struct stores the sum of input values, overflow during accumulation,
+  /// and the count number of the input values. If the count is not 0, then if
+  /// sum is nullopt that means an overflow has happened. For null group, the
+  /// variables in accumulator should be meaningless, so the values of sum and
+  /// count are ignored in both writeIntermediateResult and writeFinalResult.
+  struct AccumulatorType {
+    std::optional<int128_t> sum{0};
+    int64_t overflow{0};
+    int64_t count{0};
+
+    DecimalAverageAggregate* fn;
+
+    static constexpr bool is_aligned_ = true;
+
+    AccumulatorType() = delete;
+
+    AccumulatorType(
+        HashStringAllocator* /*allocator*/,
+        DecimalAverageAggregate* fn)
+        : fn(fn) {}
+
+    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
+        // count number of the input values must not be 0.
+        VELOX_CHECK(count != 0);
+        return true;
+      }
+      int128_t result;
+      overflow +=
+          DecimalUtil::addWithOverflow(result, data.value(), sum.value());
+      sum = result;
+      count += 1;
+      return true;
+    }
+
+    bool combine(
+        HashStringAllocator* /*allocator*/,
+        exec::optional_arg_type<Row<int128_t, int64_t>> other) {
+      if (!other.has_value()) {
+        return false;
+      }
+      auto const otherSum = other.value().template at<0>();
+      auto const otherCount = other.value().template at<1>();
+
+      // otherCount is never null.
+      VELOX_CHECK(otherCount.has_value());
+      if (count == 0 && otherCount.value() == 0) {
+        // Both accumulators have no input values, no need to do the
+        // combination.
+        return false;
+      }
+
+      bool currentOverflow = count > 0 && !sum.has_value();
+      bool otherOverflow = otherCount.value() > 0 && !otherSum.has_value();
+      if (currentOverflow || otherOverflow) {
+        sum = std::nullopt;
+        count += otherCount.value();
+      } else {
+        int128_t result;
+        overflow +=
+            DecimalUtil::addWithOverflow(result, otherSum.value(), sum.value());
+        sum = result;
+        count += otherCount.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 count is 0.
+        out =
+            std::make_tuple(static_cast<int128_t>(0), static_cast<int64_t>(0));
+      } else {
+        if (!sum.has_value()) {
+          // Sum should be set to null on overflow.
+          out.template set_null_at<0>();
+          out.template get_writer_at<1>() = count;
+        } else {
+          auto adjustedSum =
+              DecimalUtil::adjustSumForOverflow(sum.value(), overflow);
+          if (adjustedSum.has_value()) {
+            out = std::make_tuple(adjustedSum.value(), count);
+          } else {
+            out.template set_null_at<0>();
+            out.template get_writer_at<1>() = count;
+          }
+        }
+      }
+      return true;
+    }
+
+    bool writeFinalResult(bool nonNullGroup, exec::out_type<OutputType>& out) {
+      if (!nonNullGroup || count == 0) {
+        // In Spark, if all inputs are null, count will be 0, and the result of
+        // average value will be null.
+        return false;
+      }
+      auto finalResult = computeFinalResult();
+      if (finalResult.has_value()) {
+        out = static_cast<TResultType>(finalResult.value());
+        return true;
+      }
+      // Sum should be set to null on overflow.
+      return false;
+    }
+
+   private:
+    std::optional<int128_t> computeFinalResult() const {
+      if (!sum.has_value()) {
+        return std::nullopt;
+      }
+      const auto adjustedSum =
+          DecimalUtil::adjustSumForOverflow(sum.value(), overflow);
+      if (!adjustedSum.has_value()) {
+        // Found overflow during computing adjusted sum.
+        return std::nullopt;
+      }
+
+      auto [resultPrecision, resultScale] =
+          getDecimalPrecisionScale(*fn->resultType_.get());
+      auto [sumPrecision, sumScale] =
+          getDecimalPrecisionScale(*fn->sumType_.get());
+
+      // Spark use DECIMAL(20,0) to represent long value.
+      static const uint8_t countPrecision = 20;
+      static const uint8_t countScale = 0;
+
+      auto [dividePrecision, divideScale] =
+          functions::sparksql::DecimalUtil::computeDivideResultPrecisionScale<
+              true>(sumPrecision, sumScale, countPrecision, countScale);
+      divideScale = std::max<uint8_t>(divideScale, resultScale);
+      auto sumRescale = divideScale - sumScale + countScale;
+      int128_t avg;
+      bool overflow = false;
+      functions::sparksql::DecimalUtil::
+          divideWithRoundUp<int128_t, int128_t, int128_t>(
+              avg, adjustedSum.value(), count, sumRescale, overflow);
+      if (overflow) {
+        return std::nullopt;
+      }
+      TResultType rescaledValue;
+      const auto status =
+          DecimalUtil::rescaleWithRoundUp<int128_t, TResultType>(
+              avg,
+              dividePrecision,
+              divideScale,
+              resultPrecision,
+              resultScale,
+              rescaledValue);
+      return status.ok() ? std::optional<int128_t>(rescaledValue)
+                         : std::nullopt;
+    }
+  };
+
+  TypePtr resultType_;
+  TypePtr sumType_;
+};
+
+} // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/DecimalSumAggregate.h b/velox/functions/sparksql/aggregates/DecimalSumAggregate.h
index 90600879daf8..f2fa17575622 100644
--- a/velox/functions/sparksql/aggregates/DecimalSumAggregate.h
+++ b/velox/functions/sparksql/aggregates/DecimalSumAggregate.h
@@ -30,9 +30,8 @@ class DecimalSumAggregate {
  public:
   using InputType = Row<TInputType>;
 
-  using IntermediateType =
-      Row</*sum*/ TSumType,
-          /*isEmpty*/ bool>;
+  using IntermediateType = Row</*sum*/ TSumType,
+                               /*isEmpty*/ bool>;
 
   using OutputType = TSumType;
 
diff --git a/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp b/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
index 232ecf859be3..4422953ca6ac 100644
--- a/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/FirstLastAggregate.cpp
@@ -444,13 +444,14 @@ AggregateRegistrationResult registerFirstLast(
           .returnType("T")
           .build()};
 
-  signatures.push_back(AggregateFunctionSignatureBuilder()
-                           .integerVariable("a_precision")
-                           .integerVariable("a_scale")
-                           .argumentType("DECIMAL(a_precision, a_scale)")
-                           .intermediateType("DECIMAL(a_precision, a_scale)")
-                           .returnType("DECIMAL(a_precision, a_scale)")
-                           .build());
+  signatures.push_back(
+      AggregateFunctionSignatureBuilder()
+          .integerVariable("a_precision")
+          .integerVariable("a_scale")
+          .argumentType("DECIMAL(a_precision, a_scale)")
+          .intermediateType("DECIMAL(a_precision, a_scale)")
+          .returnType("DECIMAL(a_precision, a_scale)")
+          .build());
 
   return registerAggregateFunction(
       name,
diff --git a/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp b/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp
index 591db8f95d1a..9d0186b428bd 100644
--- a/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/MinMaxAggregate.cpp
@@ -25,12 +25,13 @@ exec::AggregateRegistrationResult registerMin(
     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());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .orderableTypeVariable("T")
+          .returnType("T")
+          .intermediateType("T")
+          .argumentType("T")
+          .build());
   return exec::registerAggregateFunction(
       name,
       std::move(signatures),
@@ -45,7 +46,7 @@ exec::AggregateRegistrationResult registerMin(
             TimestampPrecision::kMicroseconds);
         return factory(step, argTypes, resultType, config);
       },
-      {false /*orderSensitive*/},
+      {.ignoreDuplicates = true, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
@@ -55,12 +56,13 @@ exec::AggregateRegistrationResult registerMax(
     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());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .orderableTypeVariable("T")
+          .returnType("T")
+          .intermediateType("T")
+          .argumentType("T")
+          .build());
   return exec::registerAggregateFunction(
       name,
       std::move(signatures),
@@ -75,7 +77,7 @@ exec::AggregateRegistrationResult registerMax(
             TimestampPrecision::kMicroseconds);
         return factory(step, argTypes, resultType, config);
       },
-      {false /*orderSensitive*/},
+      {.ignoreDuplicates = true, .orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp b/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
index eee3881f3a15..0d23e130cf5e 100644
--- a/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/MinMaxByAggregate.cpp
@@ -78,8 +78,12 @@ std::string toString(const std::vector<TypePtr>& types) {
 }
 
 template <
-    template <typename U, typename V, bool B1, class C, bool B2>
-    class Aggregate,
+    template <
+        typename U,
+        typename V,
+        bool B1,
+        class C,
+        bool B2> class Aggregate,
     bool isMaxFunc>
 exec::AggregateRegistrationResult registerMinMaxBy(
     const std::string& name,
@@ -87,14 +91,15 @@ exec::AggregateRegistrationResult registerMinMaxBy(
     bool overwrite) {
   std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures;
   // V, C -> row(V, C) -> V.
-  signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                           .typeVariable("V")
-                           .orderableTypeVariable("C")
-                           .returnType("V")
-                           .intermediateType("row(V,C)")
-                           .argumentType("V")
-                           .argumentType("C")
-                           .build());
+  signatures.push_back(
+      exec::AggregateFunctionSignatureBuilder()
+          .typeVariable("V")
+          .orderableTypeVariable("C")
+          .returnType("V")
+          .intermediateType("row(V,C)")
+          .argumentType("V")
+          .argumentType("C")
+          .build());
   const std::vector<std::string> supportedCompareTypes = {
       "boolean",
       "tinyint",
@@ -136,6 +141,7 @@ exec::AggregateRegistrationResult registerMinMaxBy(
               resultType, valueType, compareType, errorMessage);
         }
       },
+      {.ignoreDuplicates = true},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/sparksql/aggregates/ModeAggregate.cpp b/velox/functions/sparksql/aggregates/ModeAggregate.cpp
index f43b2ebe4ae1..c13e8abacff9 100644
--- a/velox/functions/sparksql/aggregates/ModeAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/ModeAggregate.cpp
@@ -586,7 +586,7 @@ void registerModeAggregate(
                 inputType->toString());
         }
       },
-      {false /*orderSensitive*/},
+      {.orderSensitive = false},
       withCompanionFunctions,
       overwrite);
 }
diff --git a/velox/functions/sparksql/aggregates/Register.cpp b/velox/functions/sparksql/aggregates/Register.cpp
index a0ffce805ef3..16a12e1c38d8 100644
--- a/velox/functions/sparksql/aggregates/Register.cpp
+++ b/velox/functions/sparksql/aggregates/Register.cpp
@@ -70,15 +70,4 @@ void registerAggregateFunctions(
   registerCovarianceAggregates(prefix, withCompanionFunctions, overwrite);
 }
 
-std::vector<std::string> listAggregateFunctionNames() {
-  std::vector<std::string> names;
-  exec::aggregateFunctions().withRLock([&](const auto& map) {
-    names.reserve(map.size());
-    for (const auto& function : map) {
-      names.push_back(function.first);
-    }
-  });
-
-  return names;
-}
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/Register.h b/velox/functions/sparksql/aggregates/Register.h
index 3680012133a9..fdd5953857cd 100644
--- a/velox/functions/sparksql/aggregates/Register.h
+++ b/velox/functions/sparksql/aggregates/Register.h
@@ -16,14 +16,10 @@
 #pragma once
 
 #include <string>
-#include <vector>
 
 namespace facebook::velox::functions::aggregate::sparksql {
 void registerAggregateFunctions(
     const std::string& prefix,
     bool withCompanionFunctions = true,
     bool overwrite = true);
-
-/// Returns all the registered aggregation function names.
-std::vector<std::string> listAggregateFunctionNames();
 } // namespace facebook::velox::functions::aggregate::sparksql
diff --git a/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp b/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp
index 05c841e20cb1..3514e0ab8e95 100644
--- a/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/RegrReplacementAggregate.cpp
@@ -23,10 +23,9 @@ namespace {
 class RegrReplacementAggregate {
  public:
   using InputType = Row<double>;
-  using IntermediateType =
-      Row</*n*/ double,
-          /*avg*/ double,
-          /*m2*/ double>;
+  using IntermediateType = Row</*n*/ double,
+                               /*avg*/ double,
+                               /*m2*/ double>;
   using OutputType = double;
 
   static bool toIntermediate(
diff --git a/velox/functions/sparksql/aggregates/SumAggregate.cpp b/velox/functions/sparksql/aggregates/SumAggregate.cpp
index 6102f74cbceb..92244d96c1dd 100644
--- a/velox/functions/sparksql/aggregates/SumAggregate.cpp
+++ b/velox/functions/sparksql/aggregates/SumAggregate.cpp
@@ -129,11 +129,12 @@ exec::AggregateRegistrationResult registerSum(
   };
 
   for (const auto& inputType : {"tinyint", "smallint", "integer", "bigint"}) {
-    signatures.push_back(exec::AggregateFunctionSignatureBuilder()
-                             .returnType("bigint")
-                             .intermediateType("bigint")
-                             .argumentType(inputType)
-                             .build());
+    signatures.push_back(
+        exec::AggregateFunctionSignatureBuilder()
+            .returnType("bigint")
+            .intermediateType("bigint")
+            .argumentType(inputType)
+            .build());
   }
 
   return exec::registerAggregateFunction(
@@ -206,7 +207,6 @@ exec::AggregateRegistrationResult registerSum(
                 inputType->childAt(0),
                 inputType->childAt(0));
           }
-            [[fallthrough]];
           default:
             VELOX_UNREACHABLE(
                 "Unknown input type for {} aggregation {}",
diff --git a/velox/functions/sparksql/aggregates/tests/AggregateRegisterTest.cpp b/velox/functions/sparksql/aggregates/tests/AggregateRegisterTest.cpp
deleted file mode 100644
index 18d059e6a607..000000000000
--- a/velox/functions/sparksql/aggregates/tests/AggregateRegisterTest.cpp
+++ /dev/null
@@ -1,44 +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/sparksql/aggregates/Register.h"
-
-#include <gtest/gtest.h>
-
-#include "velox/exec/tests/AggregateRegistryTestUtil.h"
-
-using namespace facebook::velox::exec;
-
-namespace facebook::velox::functions::aggregate::sparksql::test {
-
-class RegisterTest : public testing::Test {
- public:
-  RegisterTest() {
-    registerAggregateFunc("aggregate_func");
-    registerAggregateFunc("Aggregate_Func_Alias");
-  }
-};
-
-TEST_F(RegisterTest, listAggregateFunctions) {
-  auto functions = listAggregateFunctionNames();
-  EXPECT_EQ(functions.size(), 2);
-  std::sort(functions.begin(), functions.end());
-
-  EXPECT_EQ(functions[0], "aggregate_func");
-  EXPECT_EQ(functions[1], "aggregate_func_alias");
-}
-
-} // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
index 93057ef155a5..f0651f91f0d5 100644
--- a/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/AverageAggregationTest.cpp
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include <folly/init/Init.h>
 
-#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
 #include "velox/functions/lib/aggregates/tests/utils/AggregationTestBase.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
@@ -30,12 +30,54 @@ class AverageAggregationTest : public AggregationTestBase {
  protected:
   void SetUp() override {
     AggregationTestBase::SetUp();
-    registerAggregateFunctions("spark_");
+    disableTestIncremental();
+    registerAggregateFunctions("spark_", true);
+  }
+
+  void testGlobalAverage(
+      const std::vector<RowVectorPtr>& input,
+      const std::vector<RowVectorPtr>& expected,
+      const std::vector<TypePtr>& argTypes) {
+    testAggregations(
+        input,
+        {},
+        {"spark_avg(c0)"},
+        {},
+        expected,
+        /*config*/ {});
+  }
+
+  core::PlanNodePtr createMergeExtractDecimal(
+      const RowVectorPtr& intermediateInput,
+      const TypePtr& intermediateType,
+      const TypePtr& resultType) {
+    core::AggregationNode::Aggregate avgAggregate;
+    avgAggregate.call = std::make_shared<core::CallTypedExpr>(
+        resultType,
+        "spark_avg_merge_extract_DECIMAL",
+        std::vector<core::TypedExprPtr>{
+            std::make_shared<core::FieldAccessTypedExpr>(
+                intermediateType, "c0")});
+    avgAggregate.rawInputTypes = {intermediateType};
+
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    auto child =
+        PlanBuilder(planNodeIdGenerator).values({intermediateInput}).planNode();
+
+    return std::make_shared<core::AggregationNode>(
+        planNodeIdGenerator->next(),
+        core::AggregationNode::Step::kSingle,
+        std::vector<core::FieldAccessTypedExprPtr>{},
+        std::vector<core::FieldAccessTypedExprPtr>{},
+        std::vector<std::string>{"c0"},
+        std::vector{avgAggregate},
+        /*ignoreNullKeys=*/false,
+        std::move(child));
   }
 };
 
 TEST_F(AverageAggregationTest, avgAllNulls) {
-  vector_size_t size = 1'000;
+  const vector_size_t size = 1'000;
   // Have two row vectors a least as it triggers different code paths.
   std::vector<RowVectorPtr> vectors = {
       makeRowVector({
@@ -110,5 +152,210 @@ TEST_F(AverageAggregationTest, avgAllNulls) {
   assertQuery(plan, expected);
 }
 
+TEST_F(AverageAggregationTest, avgDecimal) {
+  const int64_t kRescale = DecimalUtil::kPowersOfTen[4];
+  // Short decimal aggregation.
+  auto shortDecimal = makeNullableFlatVector<int64_t>(
+      {1'000, 2'000, 3'000, 4'000, 5'000, std::nullopt}, DECIMAL(12, 1));
+  auto shortDecimalInput = makeRowVector({shortDecimal});
+  auto shortDecimalExpected = makeRowVector(
+      {makeConstant<int64_t>(3'000 * kRescale, 1, DECIMAL(16, 5))});
+  testGlobalAverage(
+      {shortDecimalInput}, {shortDecimalExpected}, {DECIMAL(12, 1)});
+
+  // Long decimal aggregation.
+  auto longDecimalInput = makeRowVector({makeNullableFlatVector<int128_t>(
+      {HugeInt::build(10, 100),
+       HugeInt::build(10, 200),
+       HugeInt::build(10, 300),
+       HugeInt::build(10, 400),
+       HugeInt::build(10, 500),
+       std::nullopt},
+      DECIMAL(23, 4))});
+  auto longDecimalExpected = makeRowVector({makeConstant<int128_t>(
+      HugeInt::build(10, 300) * kRescale, 1, DECIMAL(27, 8))});
+  testGlobalAverage(
+      {longDecimalInput}, {longDecimalExpected}, {DECIMAL(23, 4)});
+
+  // The total sum overflows the max int128_t limit.
+  std::vector<int128_t> rawVector;
+  auto nullExpected = makeRowVector({makeNullableFlatVector(
+      std::vector<std::optional<int128_t>>{std::nullopt}, DECIMAL(38, 4))});
+  for (int i = 0; i < 10; ++i) {
+    rawVector.push_back(DecimalUtil::kLongDecimalMax);
+  }
+  testGlobalAverage(
+      {makeRowVector({makeFlatVector<int128_t>(rawVector, DECIMAL(38, 0))})},
+      {nullExpected},
+      {DECIMAL(38, 4)});
+
+  // The total sum underflows the min int128_t limit.
+  rawVector.clear();
+  for (int i = 0; i < 10; ++i) {
+    rawVector.push_back(DecimalUtil::kLongDecimalMin);
+  }
+  testGlobalAverage(
+      {makeRowVector({makeFlatVector<int128_t>(rawVector, DECIMAL(38, 0))})},
+      {nullExpected},
+      {DECIMAL(38, 4)});
+
+  // Test constant vector.
+  testGlobalAverage(
+      {makeRowVector({makeConstant<int64_t>(100, 10, DECIMAL(12, 2))})},
+      {makeRowVector(
+          {makeConstant<int64_t>(100 * kRescale, 1, DECIMAL(16, 6))})},
+      {DECIMAL(10, 2)});
+  auto newSize = shortDecimal->size() * 2;
+  auto indices = makeIndices(newSize, [&](int row) { return row / 2; });
+  auto dictVector = wrapInDictionary(indices, newSize, shortDecimal);
+  testGlobalAverage(
+      {makeRowVector({dictVector})}, {shortDecimalExpected}, {DECIMAL(12, 1)});
+
+  // Decimal average aggregation with multiple groups.
+  auto inputRows = {
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1, 1}),
+           makeFlatVector<int64_t>({37220, 53450}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2, 2}),
+           makeFlatVector<int64_t>({10410, 9250}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({3, 3}),
+           makeFlatVector<int64_t>({-12783, 0}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1, 2}),
+           makeFlatVector<int64_t>({23178, 41093}, DECIMAL(15, 2))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2, 3}),
+           makeFlatVector<int64_t>({-10023, 5290}, DECIMAL(15, 2))}),
+  };
+  auto expectedResult = {
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({1}),
+           makeFlatVector(std::vector<int128_t>{379493333}, DECIMAL(19, 6))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({2}),
+           makeFlatVector(std::vector<int128_t>{126825000}, DECIMAL(19, 6))}),
+      makeRowVector(
+          {makeNullableFlatVector<int32_t>({3}),
+           makeFlatVector(std::vector<int128_t>{-24976667}, DECIMAL(19, 6))})};
+  testAggregations(
+      inputRows,
+      {"c0"},
+      {"spark_avg(c1)"},
+      expectedResult,
+      /*config*/ {});
+
+  // dividePrecision greater than resultScale in computeFinalResult.
+  auto valueA = HugeInt::parse("11999999998800000000");
+  auto valueB = HugeInt::parse("12000000000000000000");
+  auto longDecimalInputRows = {makeRowVector(
+      {makeNullableFlatVector<int32_t>({1, 1, 1, 1, 1, 1, 1}),
+       makeFlatVector<int128_t>(
+           {valueA, valueA, valueA, valueB, valueB, valueB, valueB},
+           DECIMAL(38, 18))})};
+
+  auto longDecimalExpectedResult = {makeRowVector(
+      {makeNullableFlatVector<int32_t>({1}),
+       makeFlatVector(
+           std::vector<int128_t>{HugeInt::parse("119999999994857142857143")},
+           DECIMAL(38, 22))})};
+
+  testAggregations(
+      longDecimalInputRows,
+      {"c0"},
+      {"spark_avg(c1)"},
+      longDecimalExpectedResult);
+}
+
+TEST_F(AverageAggregationTest, avgDecimalWithMultipleRowVectors) {
+  const int64_t kRescale = DecimalUtil::kPowersOfTen[4];
+  auto inputRows = {
+      makeRowVector({makeFlatVector<int128_t>({100, 200}, DECIMAL(28, 2))}),
+      makeRowVector({makeFlatVector<int128_t>({300, 400}, DECIMAL(28, 2))}),
+      makeRowVector({makeFlatVector<int128_t>({500, 600}, DECIMAL(28, 2))}),
+  };
+  auto expectedResult = {makeRowVector(
+      {makeFlatVector(std::vector<int128_t>{350 * kRescale}, DECIMAL(32, 6))})};
+  testGlobalAverage(inputRows, expectedResult, {DECIMAL(28, 2)});
+}
+
+TEST_F(AverageAggregationTest, avgDecimalEmptyInput) {
+  auto inputRows = {
+      makeRowVector({makeFlatVector<int128_t>({}, DECIMAL(28, 2))}),
+  };
+  auto expectedResult = {makeRowVector({makeNullableFlatVector(
+      std::vector<std::optional<int128_t>>{std::nullopt}, DECIMAL(32, 6))})};
+  testGlobalAverage(inputRows, expectedResult, {DECIMAL(28, 2)});
+}
+
+TEST_F(AverageAggregationTest, avgDecimalZeroCount) {
+  auto intermediateInput = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(std::vector<int128_t>{0, 0, 0}, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(std::vector<int64_t>{0, 0, 0})})});
+
+  auto plan = createMergeExtractDecimal(
+      intermediateInput, ROW({DECIMAL(22, 1), BIGINT()}), DECIMAL(16, 5));
+
+  auto expected = makeRowVector({makeNullableFlatVector<int64_t>(
+      std::vector<std::optional<int64_t>>{std::nullopt}, DECIMAL(16, 5))});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(AverageAggregationTest, avgDecimalCompanionPartial) {
+  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(12, 1))});
+  auto plan = PlanBuilder()
+                  .values({input})
+                  .singleAggregation({}, {"spark_avg_partial(c0)"})
+                  .planNode();
+  const std::vector<int128_t> sumVector = {sum};
+  const std::vector<int64_t> count = {100};
+  const auto expected = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(sumVector, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(count)})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(AverageAggregationTest, avgDecimalCompanionMerge) {
+  auto intermediateInput = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(
+           std::vector<int128_t>{1000, 2000, 3000}, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(std::vector<int64_t>{10, 10, 10})})});
+
+  auto plan = PlanBuilder()
+                  .values({intermediateInput})
+                  .singleAggregation({}, {"spark_avg_merge(c0)"})
+                  .planNode();
+  auto expected = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(std::vector<int128_t>{6000}, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(std::vector<int64_t>{30})})});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
+TEST_F(AverageAggregationTest, avgDecimalCompanionMergeExtract) {
+  auto intermediateInput = makeRowVector({makeRowVector(
+      {makeFlatVector<int128_t>(
+           std::vector<int128_t>{1000, 2000, 3000}, DECIMAL(22, 1)),
+       makeFlatVector<int64_t>(std::vector<int64_t>{10, 10, 10})})});
+
+  // Intermediate sum type is DECIMAL(22, 1), so the input type is
+  // DECIMAL(22-10,1)=DECIMAL(12,1), and the result type is
+  // DECIMAL(12+4,1+4)=DECIMAL(16,5)
+  auto plan = createMergeExtractDecimal(
+      intermediateInput, ROW({DECIMAL(22, 1), BIGINT()}), DECIMAL(16, 5));
+
+  auto expected = makeRowVector(
+      {makeFlatVector<int64_t>(std::vector<int64_t>{2000000}, DECIMAL(16, 5))});
+  AssertQueryBuilder(plan).assertResults(expected);
+}
+
 } // namespace
 } // namespace facebook::velox::functions::aggregate::sparksql::test
diff --git a/velox/functions/sparksql/aggregates/tests/CMakeLists.txt b/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
index 793937d96819..cb95097f93fb 100644
--- a/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/aggregates/tests/CMakeLists.txt
@@ -29,10 +29,10 @@ add_executable(
   ModeAggregateTest.cpp
   RegrReplacementAggregationTest.cpp
   SumAggregationTest.cpp
-  VarianceAggregationTest.cpp)
+  VarianceAggregationTest.cpp
+)
 
-add_test(velox_functions_spark_aggregates_test
-         velox_functions_spark_aggregates_test)
+add_test(velox_functions_spark_aggregates_test velox_functions_spark_aggregates_test)
 
 target_link_libraries(
   velox_functions_spark_aggregates_test
@@ -45,14 +45,5 @@ target_link_libraries(
   velox_vector_fuzzer
   gflags::gflags
   GTest::gtest
-  GTest::gtest_main)
-
-add_executable(velox_spark_aggregate_function_registry_test
-               AggregateRegisterTest.cpp)
-
-add_test(velox_spark_aggregate_function_registry_test
-         velox_spark_aggregate_function_registry_test)
-
-target_link_libraries(
-  velox_spark_aggregate_function_registry_test velox_functions_spark_aggregates
-  GTest::gtest GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/functions/sparksql/aggregates/tests/CovarianceAggregatesTest.cpp b/velox/functions/sparksql/aggregates/tests/CovarianceAggregatesTest.cpp
index 99fef41dd530..a0d45666a8c8 100644
--- a/velox/functions/sparksql/aggregates/tests/CovarianceAggregatesTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/CovarianceAggregatesTest.cpp
@@ -99,6 +99,17 @@ TEST_F(CovarianceAggregatesTest, corr) {
       std::vector<double>{std::numeric_limits<double>::quiet_NaN()})});
   testCovarianceAggResult(agg, input, expected, true);
 
+  // Output NaN when m2x or m2y equals 0 but c2 is NaN.
+  input = makeRowVector(
+      {makeFlatVector<double>({0, 0, 0, 0, 0, 0}),
+       makeFlatVector<double>(
+           {std::numeric_limits<double>::quiet_NaN(), 0, 0, 0, 0, 0})});
+
+  expected = makeRowVector({makeFlatVector<double>(
+      std::vector<double>{std::numeric_limits<double>::quiet_NaN()})});
+  testCovarianceAggResult(agg, input, expected);
+  testCovarianceAggResult(agg, input, expected, true);
+
   // Output NULL when count equals 0 for legacy aggregate.
   input = makeRowVector(
       {makeNullableFlatVector<double>(
@@ -154,6 +165,15 @@ TEST_F(CovarianceAggregatesTest, covarSamp) {
   expected = makeRowVector({makeFlatVector<double>(
       std::vector<double>{std::numeric_limits<double>::quiet_NaN()})});
   testCovarianceAggResult(agg, input, expected, true);
+
+  // Output NaN when c2 is ±inf.
+  input = makeRowVector(
+      {makeFlatVector<double>({22, std::numeric_limits<double>::infinity()}),
+       makeFlatVector<double>({0.688, 0.225})});
+  expected = makeRowVector({makeFlatVector<double>(
+      std::vector<double>{std::numeric_limits<double>::quiet_NaN()})});
+  testCovarianceAggResult(agg, input, expected);
+  testCovarianceAggResult(agg, input, expected, true);
 }
 
 } // namespace
diff --git a/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp b/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp
index aa0e4762a7c7..45b9ce5c93c3 100644
--- a/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp
+++ b/velox/functions/sparksql/aggregates/tests/SumAggregationTest.cpp
@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 
+#include "velox/exec/AggregateUtil.h"
+#include "velox/exec/SimpleAggregateAdapter.h"
 #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/DecimalSumAggregate.h"
 #include "velox/functions/sparksql/aggregates/Register.h"
 
 using facebook::velox::exec::test::PlanBuilder;
@@ -108,6 +111,148 @@ class SumAggregationTest : public SumTestBase {
         {expected},
         {});
   }
+
+  // Registers a dummy sum aggregate function whose result type cannot be
+  // resolved from the intermediate type. The "i_precision" variable is
+  // intentionally added to fail the intermediate-to-result type resolving.
+  exec::AggregateRegistrationResult registerDummySum(const std::string& name) {
+    std::vector<std::shared_ptr<exec::AggregateFunctionSignature>> signatures{
+        exec::AggregateFunctionSignatureBuilder()
+            .integerVariable("a_precision")
+            .integerVariable("a_scale")
+            .integerVariable("i_precision", "min(38, a_precision + 10)")
+            .integerVariable("r_precision", "min(38, a_precision + 10)")
+            .integerVariable("r_scale", "min(38, a_scale)")
+            .argumentType("DECIMAL(a_precision, a_scale)")
+            .intermediateType("ROW(DECIMAL(i_precision, r_scale), boolean)")
+            .returnType("DECIMAL(r_precision, r_scale)")
+            .build(),
+    };
+
+    return exec::registerAggregateFunction(
+        name,
+        std::move(signatures),
+        [this, 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::BIGINT: {
+              if (inputType->isShortDecimal()) {
+                return constructDecimalSumAgg(
+                    step,
+                    argTypes,
+                    resultType,
+                    inputType,
+                    getDecimalSumType(resultType));
+              }
+              VELOX_NYI();
+            }
+            case TypeKind::HUGEINT: {
+              VELOX_CHECK(inputType->isLongDecimal());
+              // If inputType is long decimal,
+              // its output type is always long decimal.
+              return constructDecimalSumAgg(
+                  step,
+                  argTypes,
+                  resultType,
+                  inputType,
+                  getDecimalSumType(resultType));
+            }
+            case TypeKind::ROW: {
+              VELOX_DCHECK(!exec::isRawInput(step));
+              // For the intermediate aggregation step, input intermediate sum
+              // type is equal to final result sum type.
+              return constructDecimalSumAgg(
+                  step,
+                  argTypes,
+                  resultType,
+                  inputType->childAt(0),
+                  inputType->childAt(0));
+            }
+            default:
+              VELOX_NYI();
+          }
+        },
+        /*registerCompanionFunctions=*/true,
+        /*overwrite=*/true);
+  }
+
+ private:
+  // Copied from SumAggregate.cpp
+  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;
+  }
+
+  // Copied from SumAggregate.cpp
+  std::unique_ptr<exec::Aggregate> constructDecimalSumAgg(
+      core::AggregationNode::Step step,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& resultType,
+      const TypePtr& inputType,
+      const TypePtr& sumType) {
+    uint8_t precision = getDecimalPrecisionScale(*sumType).first;
+    switch (precision) {
+      // The sum precision is calculated from the input precision with the
+      // formula min(p + 10, 38). Therefore, the sum precision must >= 11.
+#define PRECISION_CASE(precision)                                         \
+  case precision:                                                         \
+    if (inputType->isShortDecimal() && sumType->isShortDecimal()) {       \
+      return std::make_unique<exec::SimpleAggregateAdapter<               \
+          DecimalSumAggregate<int64_t, int64_t, precision>>>(             \
+          step, argTypes, resultType);                                    \
+    } else if (inputType->isShortDecimal() && sumType->isLongDecimal()) { \
+      return std::make_unique<exec::SimpleAggregateAdapter<               \
+          DecimalSumAggregate<int64_t, int128_t, precision>>>(            \
+          step, argTypes, resultType);                                    \
+    } else {                                                              \
+      return std::make_unique<exec::SimpleAggregateAdapter<               \
+          DecimalSumAggregate<int128_t, int128_t, precision>>>(           \
+          step, argTypes, resultType);                                    \
+    }
+      PRECISION_CASE(11)
+      PRECISION_CASE(12)
+      PRECISION_CASE(13)
+      PRECISION_CASE(14)
+      PRECISION_CASE(15)
+      PRECISION_CASE(16)
+      PRECISION_CASE(17)
+      PRECISION_CASE(18)
+      PRECISION_CASE(19)
+      PRECISION_CASE(20)
+      PRECISION_CASE(21)
+      PRECISION_CASE(22)
+      PRECISION_CASE(23)
+      PRECISION_CASE(24)
+      PRECISION_CASE(25)
+      PRECISION_CASE(26)
+      PRECISION_CASE(27)
+      PRECISION_CASE(28)
+      PRECISION_CASE(29)
+      PRECISION_CASE(30)
+      PRECISION_CASE(31)
+      PRECISION_CASE(32)
+      PRECISION_CASE(33)
+      PRECISION_CASE(34)
+      PRECISION_CASE(35)
+      PRECISION_CASE(36)
+      PRECISION_CASE(37)
+      PRECISION_CASE(38)
+#undef PRECISION_CASE
+      default:
+        VELOX_UNREACHABLE();
+    }
+  }
 };
 
 TEST_F(SumAggregationTest, overflow) {
@@ -486,5 +631,94 @@ TEST_F(SumAggregationTest, sumFloat) {
       {"spark_sum(c0)"},
       "SELECT sum(c0) FROM tmp");
 }
+
+// Spark executes aggregates using a mix of partial, intermediate, and final
+// aggregate functions. The planner translates Spark's aggregate modes into
+// corresponding Velox companion functions and assigns the "single" step to
+// Velox’s AggregationNode. This test verifies that such a plan can execute
+// successfully.
+TEST_F(SumAggregationTest, sumDistinct) {
+  auto input = makeRowVector({
+      makeFlatVector<int32_t>(100, [&](auto row) { return row; }),
+      makeFlatVector<int32_t>(100, [&](auto row) { return row * 2; }),
+  });
+  createDuckDbTable({input});
+
+  auto plan =
+      PlanBuilder()
+          .values({input})
+          .singleAggregation({"c0"}, {"avg_partial(c1)"})
+          .singleAggregation({"c0"}, {"avg_merge(a0)"})
+          .singleAggregation({}, {"sum_partial(c0)", "avg_merge(a0)"})
+          .singleAggregation(
+              {},
+              {"sum_merge_extract_bigint(a0)", "avg_merge_extract_double(a1)"})
+          .planNode();
+
+  assertQuery(plan, "SELECT sum(distinct c0), avg(c1) from tmp");
+}
+
+// A dummy sum aggregate function is registered for testing. This function's
+// result type cannot be inferred from the intermediate type. This test verifies
+// that the companion functions can be registered and that the plan executes
+// successfully.
+TEST_F(SumAggregationTest, dummySum) {
+  registerDummySum("dummy_sum");
+
+  auto input = makeRowVector({
+      makeFlatVector<int64_t>(
+          100, [&](auto row) { return row; }, nullptr, DECIMAL(18, 2)),
+      makeFlatVector<int32_t>(100, [&](auto row) { return row * 2; }),
+  });
+  createDuckDbTable({input});
+
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  auto child =
+      PlanBuilder(planNodeIdGenerator)
+          .values({input})
+          .singleAggregation({"c0"}, {"avg_partial(c1)"})
+          .singleAggregation({"c0"}, {"avg_merge(a0)"})
+          .singleAggregation({}, {"dummy_sum_partial(c0)", "avg_merge(a0)"})
+          .planNode();
+
+  // "PlanBuilder::aggregation" relies on "inferTypes" to resolve the result
+  // type from intermediate type. In this test, we manually construct the
+  // AggregationNode to bypass the type inferring.
+  std::vector<core::AggregationNode::Aggregate> aggregates;
+  core::AggregationNode::Aggregate sumAggregate;
+  // Create the aggregate function: dummy_sum_merge_extract(a0).
+  sumAggregate.call = std::make_shared<core::CallTypedExpr>(
+      DECIMAL(28, 2),
+      "dummy_sum_merge_extract",
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(
+              ROW({DECIMAL(28, 2), BOOLEAN()}), "a0")});
+  sumAggregate.rawInputTypes = {ROW({DECIMAL(28, 2), BOOLEAN()})};
+  aggregates.emplace_back(sumAggregate);
+
+  core::AggregationNode::Aggregate avgAggregate;
+  // Create the aggregate function: avg_merge_extract_double(a1).
+  avgAggregate.call = std::make_shared<core::CallTypedExpr>(
+      DOUBLE(),
+      "avg_merge_extract_double",
+      std::vector<core::TypedExprPtr>{
+          std::make_shared<core::FieldAccessTypedExpr>(
+              ROW({DOUBLE(), BIGINT()}), "a1")});
+  avgAggregate.rawInputTypes = {ROW({DOUBLE(), BIGINT()})};
+  aggregates.emplace_back(avgAggregate);
+
+  auto plan = std::make_shared<core::AggregationNode>(
+      planNodeIdGenerator->next(),
+      core::AggregationNode::Step::kSingle,
+      std::vector<core::FieldAccessTypedExprPtr>{},
+      std::vector<core::FieldAccessTypedExprPtr>{},
+      std::vector<std::string>{"c0", "c1"},
+      std::move(aggregates),
+      /*ignoreNullKeys=*/false,
+      std::move(child));
+
+  assertQuery(plan, "SELECT sum(distinct c0), avg(c1) 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 cbc2db8be960..1321fcbadbd5 100644
--- a/velox/functions/sparksql/benchmarks/CMakeLists.txt
+++ b/velox/functions/sparksql/benchmarks/CMakeLists.txt
@@ -22,19 +22,59 @@ target_link_libraries(
   velox_vector_test_lib
   velox_vector_fuzzer
   Folly::folly
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
 
 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)
+  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)
+  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)
+  velox_sparksql_benchmarks_hash
+  velox_functions_spark
+  velox_benchmark_builder
+  velox_vector_test_lib
+)
+
+add_executable(velox_sparksql_benchmarks_from_json FromJsonBenchmark.cpp)
+target_link_libraries(
+  velox_sparksql_benchmarks_from_json
+  velox_functions_spark
+  velox_exec_test_lib
+  velox_parse_utils
+  Folly::folly
+  Folly::follybenchmark
+)
+
+add_executable(velox_sparksql_benchmarks_split SplitBenchmark.cpp)
+target_link_libraries(
+  velox_sparksql_benchmarks_split
+  velox_functions_spark
+  velox_benchmark_builder
+  velox_vector_test_lib
+  velox_vector_fuzzer
+  velox_functions_lib
+)
+
+add_executable(velox_sparksql_benchmarks_get_funcs FunctionBenchmark.cpp)
+target_link_libraries(
+  velox_sparksql_benchmarks_get_funcs
+  velox_functions_spark
+  velox_exec_test_lib
+  velox_parse_utils
+  Folly::folly
+  Folly::follybenchmark
+)
diff --git a/velox/functions/sparksql/benchmarks/FromJsonBenchmark.cpp b/velox/functions/sparksql/benchmarks/FromJsonBenchmark.cpp
new file mode 100644
index 000000000000..08a3a5b52a23
--- /dev/null
+++ b/velox/functions/sparksql/benchmarks/FromJsonBenchmark.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/core/Expressions.h"
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/sparksql/registration/Register.h"
+
+using namespace facebook::velox;
+namespace {
+class FromJsonBenchmark : public functions::test::FunctionBenchmarkBase {
+ public:
+  FromJsonBenchmark() : FunctionBenchmarkBase() {
+    functions::sparksql::registerFunctions("");
+  }
+
+  RowVectorPtr makeData(const StringView& input) {
+    const vector_size_t size = 1'000;
+
+    return vectorMaker_.rowVector(
+        {"c0"},
+        {vectorMaker_.flatVector<StringView>(
+            size, [&](vector_size_t /*row*/) { return input; })});
+  }
+
+  void run(const StringView& input, const TypePtr& outputType) {
+    folly::BenchmarkSuspender suspender;
+    auto rowVector = makeData(input);
+
+    auto typedExpr = std::make_shared<const core::CallTypedExpr>(
+        outputType,
+        "from_json",
+        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0"));
+    exec::ExprSet exprSet({typedExpr}, &execCtx_);
+    suspender.dismiss();
+
+    doRun(exprSet, rowVector);
+  }
+
+  void doRun(exec::ExprSet& exprSet, const RowVectorPtr& rowVector) {
+    for (auto i = 0; i < 1000; i++) {
+      evaluate(exprSet, rowVector)->size();
+    }
+  }
+};
+
+BENCHMARK(bm_json_depth1_1col) {
+  FromJsonBenchmark benchmark;
+  benchmark.run(StringView(R"({"a": 1})"), ROW({"a"}, {BIGINT()}));
+}
+
+BENCHMARK(bm_json_depth1_4col) {
+  FromJsonBenchmark benchmark;
+  benchmark.run(
+      StringView(R"({"a": 1, "b": 2, "c": 2, "d": 2})"),
+      ROW({"a", "b", "c", "d"}, {BIGINT(), BIGINT(), BIGINT(), BIGINT()}));
+}
+
+BENCHMARK(bm_json_depth1_6col) {
+  FromJsonBenchmark benchmark;
+  benchmark.run(
+      StringView(R"({"a": 1, "b": 2, "c": 2, "d": 2, "e": 1, "f": 2})"),
+      ROW({"a", "b", "c", "d", "e", "f"},
+          {BIGINT(), BIGINT(), BIGINT(), BIGINT(), BIGINT(), BIGINT()}));
+}
+
+BENCHMARK(bm_json_depth1_8col) {
+  FromJsonBenchmark benchmark;
+  benchmark.run(
+      StringView(
+          R"({"a": 1, "b": 2, "c": 2, "d": 2, "e": 1, "f": 2, "g": 2, "h": 2})"),
+      ROW({"a", "b", "c", "d", "e", "f", "g", "h"},
+          {BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT(),
+           BIGINT()}));
+}
+
+BENCHMARK(bm_json_depth2_2col) {
+  FromJsonBenchmark benchmark;
+  benchmark.run(
+      StringView(R"({"a": {"c": 2, "d": 2}, "b": {"e": 2, "f": 2}})"),
+      ROW({"a", "b"},
+          {ROW({"c", "d"}, {BIGINT(), BIGINT()}),
+           ROW({"e", "f"}, {BIGINT(), BIGINT()})}));
+}
+
+BENCHMARK(bm_json_depth3_2col) {
+  FromJsonBenchmark benchmark;
+  benchmark.run(
+      StringView(
+          R"({"a": {"c": {"e": 2, "f": 2}}, "b": {"d": {"g": 2, "h": 2}}})"),
+      ROW({"a", "b"},
+          {ROW({"c"}, {ROW({"e", "f"}, {BIGINT(), BIGINT()})}),
+           ROW({"d"}, {ROW({"g", "h"}, {BIGINT(), BIGINT()})})}));
+}
+
+BENCHMARK(bm_json_depth4_2col) {
+  FromJsonBenchmark benchmark;
+  benchmark.run(
+      StringView(
+          R"({"a": {"c": {"e": {"g": 2, "h": 2}}}, "b": {"d": {"f": {"i": 2, "j": 2}}}})"),
+      ROW({"a", "b"},
+          {ROW({"c"}, {ROW({"e"}, {ROW({"g", "h"}, {BIGINT(), BIGINT()})})}),
+           ROW({"b"}, {ROW({"d"}, {ROW({"i", "j"}, {BIGINT(), BIGINT()})})})}));
+}
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/sparksql/benchmarks/FunctionBenchmark.cpp b/velox/functions/sparksql/benchmarks/FunctionBenchmark.cpp
new file mode 100644
index 000000000000..aeba3e0083f7
--- /dev/null
+++ b/velox/functions/sparksql/benchmarks/FunctionBenchmark.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 <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <functions/FunctionRegistry.h>
+
+#include "velox/benchmarks/ExpressionBenchmarkBuilder.h"
+#include "velox/functions/sparksql/registration/Register.h"
+
+using namespace facebook::velox;
+class FunctionBenchmark : public functions::test::FunctionBenchmarkBase {
+ public:
+  FunctionBenchmark() : FunctionBenchmarkBase() {
+    functions::sparksql::registerFunctions("");
+  }
+
+  void run() {
+    int total = 0;
+    for (auto i = 0; i < 1000; i++) {
+      auto functions = getFunctionSignatures();
+      auto size = functions.size();
+      total = total + size;
+    }
+    std::cout << total << std::endl;
+  }
+};
+
+BENCHMARK(get_function_signatures_1000) {
+  FunctionBenchmark benchmark;
+  benchmark.run();
+}
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  folly::runBenchmarks();
+  return 0;
+}
diff --git a/velox/functions/sparksql/benchmarks/SplitBenchmark.cpp b/velox/functions/sparksql/benchmarks/SplitBenchmark.cpp
new file mode 100644
index 000000000000..5cd526040ff6
--- /dev/null
+++ b/velox/functions/sparksql/benchmarks/SplitBenchmark.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 <folly/Benchmark.h>
+#include <folly/init/Init.h>
+
+#include "velox/functions/lib/benchmarks/FunctionBenchmarkBase.h"
+#include "velox/functions/sparksql/registration/Register.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+
+namespace {
+
+class SplitBenchmark : public functions::test::FunctionBenchmarkBase {
+ public:
+  SplitBenchmark(uint32_t seed) : FunctionBenchmarkBase(), seed_{seed} {
+    parse::registerTypeResolver();
+    functions::sparksql::registerFunctions("");
+    generateData();
+  }
+
+  void generateData() {
+    VectorFuzzer::Options options;
+    options.vectorSize = 10000;
+    options.stringVariableLength = true;
+    options.stringLength = 10;
+
+    VectorFuzzer fuzzer(options, pool(), seed_);
+
+    auto vector = vectorMaker_.rowVector(
+        {fuzzer.fuzzFlat(VARCHAR()),
+         fuzzer.fuzzFlat(VARCHAR()),
+         fuzzer.fuzzFlat(VARCHAR()),
+         fuzzer.fuzzFlat(VARCHAR()),
+         fuzzer.fuzzFlat(VARCHAR())});
+    data_ = vectorMaker_.rowVector({evaluateOnce(kConcatExpression, vector)});
+  }
+
+  VectorPtr evaluateOnce(
+      const std::string& expression,
+      const RowVectorPtr& data) {
+    auto exprSet = compileExpression(expression, asRowType(data->type()));
+    return evaluate(exprSet, data);
+  }
+
+  size_t run(size_t times, const std::string& expression) {
+    folly::BenchmarkSuspender suspender;
+    auto exprSet = compileExpression(expression, asRowType(data_->type()));
+    suspender.dismiss();
+
+    return doRun(exprSet, data_, times);
+  }
+
+  size_t doRun(ExprSet& exprSet, const RowVectorPtr& rowVector, size_t times) {
+    int cnt = 0;
+    for (auto i = 0; i < times * 1'000; i++) {
+      cnt += evaluate(exprSet, rowVector)->size();
+    }
+    return cnt;
+  }
+
+  static const std::string kSplitExpression;
+
+ private:
+  static const std::string kConcatExpression;
+  RowVectorPtr data_ = nullptr;
+
+  const uint32_t seed_;
+};
+
+const std::string SplitBenchmark::kSplitExpression = "split(c0, '\\044')";
+const std::string SplitBenchmark::kConcatExpression =
+    "concat(c0, '$', c1, '$', c2, '$', c3, '$', c4)";
+
+const uint32_t seed = folly::Random::rand32();
+
+std::unique_ptr<SplitBenchmark> benchmark;
+
+BENCHMARK_RELATIVE(split, n) {
+  benchmark->run(n, SplitBenchmark::kSplitExpression);
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+  folly::Init init{&argc, &argv};
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  LOG(INFO) << "Seed: " << seed;
+  benchmark = std::make_unique<SplitBenchmark>(seed);
+  folly::runBenchmarks();
+  benchmark.reset();
+  return 0;
+}
diff --git a/velox/functions/sparksql/coverage/CMakeLists.txt b/velox/functions/sparksql/coverage/CMakeLists.txt
index cfbc16d3b3b4..c381431c9cec 100644
--- a/velox/functions/sparksql/coverage/CMakeLists.txt
+++ b/velox/functions/sparksql/coverage/CMakeLists.txt
@@ -20,4 +20,5 @@ target_link_libraries(
   velox_functions_spark_aggregates
   velox_functions_spark_window
   velox_row_fast
-  velox_coverage_util)
+  velox_coverage_util
+)
diff --git a/velox/functions/sparksql/fuzzer/CMakeLists.txt b/velox/functions/sparksql/fuzzer/CMakeLists.txt
index ecb0ac20f709..4caa7a87f390 100644
--- a/velox/functions/sparksql/fuzzer/CMakeLists.txt
+++ b/velox/functions/sparksql/fuzzer/CMakeLists.txt
@@ -12,41 +12,37 @@
 # 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)
+  CONFIGURE_DEPENDS
+  ${CMAKE_CURRENT_SOURCE_DIR}/spark/connect/*.proto
+)
 foreach(PROTO ${PROTO_FILES})
+  get_filename_component(PROTO_DIR ${PROTO} DIRECTORY)
   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")
+  list(
+    APPEND
+    PROTO_SRCS
+    "${PROJECT_BINARY_DIR}/velox/functions/sparksql/fuzzer/spark/connect/${PROTO_NAME}.pb.cc"
+  )
+  list(
+    APPEND
+    PROTO_HDRS
+    "${PROJECT_BINARY_DIR}/velox/functions/sparksql/fuzzer/spark/connect/${PROTO_NAME}.pb.h"
+  )
+  list(
+    APPEND
+    GRPC_SRCS
+    "${PROJECT_BINARY_DIR}/velox/functions/sparksql/fuzzer/spark/connect/${PROTO_NAME}.grpc.pb.cc"
+  )
+  list(
+    APPEND
+    GRPC_HDRS
+    "${PROJECT_BINARY_DIR}/velox/functions/sparksql/fuzzer/spark/connect/${PROTO_NAME}.grpc.pb.h"
+  )
+  list(APPEND PROTO_FILES_FULL "${PROJECT_SOURCE_DIR}/${PROTO_DIR}/${PROTO_NAME}.proto")
 endforeach()
 
 set(PROTO_OUTPUT_FILES ${PROTO_HDRS} ${PROTO_SRCS})
@@ -56,36 +52,39 @@ 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})
+foreach(PROTO_PATH ${PROJECT_SOURCE_DIR} ${Protobuf_INCLUDE_DIRS})
   list(APPEND PROTO_PATH_ARGS --proto_path=${PROTO_PATH})
 endforeach()
 
-# Generate Spark connect hearders and sources.
+# Generate Spark connect headers and sources.
 add_custom_command(
   OUTPUT ${PROTO_OUTPUT_FILES}
-  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${PROJECT_BINARY_DIR}
-          ${PROTO_FILES_FULL}
+  COMMAND protobuf::protoc ${PROTO_PATH_ARGS} --cpp_out ${PROJECT_BINARY_DIR} ${PROTO_FILES_FULL}
   DEPENDS protobuf::protoc
   COMMENT "Running PROTO compiler"
-  VERBATIM)
+  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}
+    --plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin> ${PROTO_FILES_FULL}
   DEPENDS protobuf::protoc
   COMMENT "Running gRPC C++ protocol buffer compiler"
-  VERBATIM)
+  VERBATIM
+)
 
 add_library(
-  velox_spark_query_runner ${PROTO_SRCS} ${GRPC_SRCS} SparkQueryRunner.cpp
-                           SparkQueryRunnerToSqlPlanNodeVisitor.cpp)
+  velox_spark_query_runner
+  ${PROTO_SRCS}
+  ${GRPC_SRCS}
+  SparkQueryRunner.cpp
+  SparkQueryRunnerToSqlPlanNodeVisitor.cpp
+)
 
-target_include_directories(velox_spark_query_runner
-                           PUBLIC ${PROJECT_BINARY_DIR}/spark/connect/)
+target_include_directories(velox_spark_query_runner PUBLIC ${PROJECT_BINARY_DIR}/spark/connect/)
 
 target_link_libraries(
   velox_spark_query_runner
@@ -97,7 +96,8 @@ target_link_libraries(
   gRPC::grpc++
   gRPC::grpc
   protobuf::libprotobuf
-  arrow)
+  arrow
+)
 
 add_executable(spark_aggregation_fuzzer_test SparkAggregationFuzzerTest.cpp)
 
@@ -106,12 +106,14 @@ target_link_libraries(
   velox_aggregation_fuzzer
   velox_aggregation_fuzzer_base
   velox_functions_spark_aggregates
+  velox_dwio_parquet_writer
   velox_spark_query_runner
   velox_fuzzer_util
   velox_window
   velox_vector_test_lib
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp b/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp
index 43d764361ad2..5026dbe8309e 100644
--- a/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp
+++ b/velox/functions/sparksql/fuzzer/SparkAggregationFuzzerTest.cpp
@@ -19,12 +19,13 @@
 #include <gtest/gtest.h>
 #include <unordered_set>
 
+#include "velox/dwio/parquet/RegisterParquetWriter.h"
 #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"
+#include "velox/functions/sparksql/fuzzer/SparkQueryRunner.h"
 #include "velox/serializers/CompactRowSerializer.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/serializers/UnsafeRowSerializer.h"
@@ -45,6 +46,7 @@ DEFINE_string(
 int main(int argc, char** argv) {
   facebook::velox::functions::aggregate::sparksql::registerAggregateFunctions(
       "", false);
+  facebook::velox::parquet::registerParquetWriterFactory();
 
   ::testing::InitGoogleTest(&argc, argv);
 
@@ -72,10 +74,14 @@ int main(int argc, char** argv) {
   facebook::velox::memory::MemoryManager::initialize(
       facebook::velox::memory::MemoryManager::Options{});
 
-  // 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"};
+  // Spark does not provide user-accessible aggregate functions with the
+  // following names.
+  std::unordered_set<std::string> skipFunctions = {
+      "bloom_filter_agg",
+      "first_ignore_null",
+      "last_ignore_null",
+      "regr_replacement",
+  };
 
   using facebook::velox::exec::test::TransformResultVerifier;
 
@@ -114,21 +120,9 @@ int main(int argc, char** argv) {
   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"});
+  auto sparkQueryRunner = std::make_unique<
+      facebook::velox::functions::sparksql::fuzzer::SparkQueryRunner>(
+      rootPool.get(), "localhost:15002", "fuzzer", "aggregate");
 
   using Runner = facebook::velox::exec::test::AggregationFuzzerRunner;
   using Options = facebook::velox::exec::test::AggregationFuzzerOptions;
@@ -138,5 +132,9 @@ int main(int argc, char** argv) {
   options.skipFunctions = skipFunctions;
   options.customVerificationFunctions = customVerificationFunctions;
   options.orderableGroupKeys = true;
-  return Runner::run(initialSeed, std::move(duckQueryRunner), options);
+  options.timestampPrecision =
+      facebook::velox::VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  options.hiveConfigs = {
+      {facebook::velox::connector::hive::HiveConfig::kReadTimestampUnit, "6"}};
+  return Runner::run(initialSeed, std::move(sparkQueryRunner), options);
 }
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp b/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp
index 1cb400caef3d..e13954f20f5e 100644
--- a/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunner.cpp
@@ -25,9 +25,8 @@
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "grpc/grpc.h" // @manual
-#include "spark/connect/base.pb.h"
-#include "spark/connect/relations.pb.h"
 #include "velox/common/base/Fs.h"
+#include "velox/dwio/common/Arena.h"
 #include "velox/dwio/common/WriterFactory.h"
 #include "velox/dwio/parquet/writer/Writer.h"
 #include "velox/exec/fuzzer/FuzzerUtil.h"
@@ -35,11 +34,16 @@
 #include "velox/exec/tests/utils/QueryAssertions.h"
 #include "velox/exec/tests/utils/TempFilePath.h"
 #include "velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h"
+#include "velox/functions/sparksql/fuzzer/spark/connect/base.pb.h"
+#include "velox/functions/sparksql/fuzzer/spark/connect/relations.pb.h"
 #include "velox/vector/arrow/Bridge.h"
 
 using namespace spark::connect;
 
 namespace facebook::velox::functions::sparksql::fuzzer {
+
+using dwio::common::ArenaCreate;
+
 namespace {
 
 void writeToFile(
@@ -109,53 +113,89 @@ std::optional<std::string> SparkQueryRunner::toSql(
   return context.sql;
 }
 
-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::pair<
+    std::optional<std::multiset<std::vector<variant>>>,
+    exec::test::ReferenceQueryErrorCode>
+SparkQueryRunner::execute(const core::PlanNodePtr& plan) {
+  std::pair<
+      std::optional<std::vector<RowVectorPtr>>,
+      exec::test::ReferenceQueryErrorCode>
+      result = executeAndReturnVector(plan);
+  if (result.first) {
+    return std::make_pair(
+        exec::test::materialize(*result.first), result.second);
+  }
+  return std::make_pair(std::nullopt, result.second);
 }
 
-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);
+std::pair<
+    std::optional<std::vector<RowVectorPtr>>,
+    exec::test::ReferenceQueryErrorCode>
+SparkQueryRunner::executeAndReturnVector(const core::PlanNodePtr& plan) {
+  if (std::optional<std::string> sql = toSql(plan)) {
+    try {
+      std::unordered_map<std::string, std::vector<RowVectorPtr>> inputMap =
+          getAllTables(plan);
+      for (const auto& [tableName, input] : inputMap) {
+        auto inputType = asRowType(input[0]->type());
+        if (inputType->size() == 0) {
+          inputMap[tableName] = {exec::test::makeNullRows(
+              input, fmt::format("{}x", tableName), pool())};
+        }
+      }
+
+      auto writerPool = aggregatePool()->addAggregateChild("writer");
+      std::vector<std::shared_ptr<exec::test::TempFilePath>> tempFiles;
+      tempFiles.reserve(inputMap.size());
+      for (const auto& [tableName, input] : inputMap) {
+        auto tempFile = exec::test::TempFilePath::create();
+        tempFiles.emplace_back(tempFile);
+        const auto& filePath = tempFile->getPath();
+        writeToFile(filePath, input, writerPool.get());
+        // Create temporary view for this table in Spark by reading the
+        // generated Parquet file.
+        execute(
+            fmt::format(
+                "CREATE OR REPLACE TEMPORARY VIEW {} AS (SELECT * from parquet.`file://{}`);",
+                tableName,
+                filePath));
+      }
+
+      // Run the query.
+      return std::make_pair(
+          execute(*sql), exec::test::ReferenceQueryErrorCode::kSuccess);
+    } catch (const VeloxRuntimeError&) {
+      throw;
+    } catch (...) {
+      LOG(WARNING) << "Query failed in Spark";
+      return std::make_pair(
+          std::nullopt,
+          exec::test::ReferenceQueryErrorCode::kReferenceQueryFail);
+    }
   }
 
-  // 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);
+  LOG(INFO) << "Query not supported in Spark";
+  return std::make_pair(
+      std::nullopt,
+      exec::test::ReferenceQueryErrorCode::kReferenceQueryUnsupported);
 }
 
 std::vector<RowVectorPtr> SparkQueryRunner::execute(
     const std::string& content) {
-  auto sql = google::protobuf::Arena::CreateMessage<SQL>(&arena_);
+  auto sql = ArenaCreate<SQL>(&arena_);
   sql->set_query(content);
 
-  auto relation = google::protobuf::Arena::CreateMessage<Relation>(&arena_);
+  auto relation = ArenaCreate<Relation>(&arena_);
   relation->set_allocated_sql(sql);
 
-  auto plan = google::protobuf::Arena::CreateMessage<Plan>(&arena_);
+  auto plan = ArenaCreate<Plan>(&arena_);
   plan->set_allocated_root(relation);
 
-  auto context = google::protobuf::Arena::CreateMessage<UserContext>(&arena_);
+  auto context = ArenaCreate<UserContext>(&arena_);
   context->set_user_id(userId_);
   context->set_user_name(userName_);
 
-  auto request =
-      google::protobuf::Arena::CreateMessage<ExecutePlanRequest>(&arena_);
+  auto request = ArenaCreate<ExecutePlanRequest>(&arena_);
   request->set_session_id(sessionId_);
   request->set_allocated_user_context(context);
   request->set_allocated_plan(plan);
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunner.h b/velox/functions/sparksql/fuzzer/SparkQueryRunner.h
index 07009ae43d00..d7c54ed3e4bc 100644
--- a/velox/functions/sparksql/fuzzer/SparkQueryRunner.h
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunner.h
@@ -19,10 +19,10 @@
 #include "grpc++/client_context.h" // @manual
 #include "grpc++/create_channel.h" // @manual
 #include "grpc++/security/credentials.h" // @manual
-#include "spark/connect/base.grpc.pb.h"
 #include "velox/common/fuzzer/Utils.h"
 #include "velox/common/memory/Memory.h"
 #include "velox/exec/fuzzer/ReferenceQueryRunner.h"
+#include "velox/functions/sparksql/fuzzer/spark/connect/base.grpc.pb.h" // @manual
 #include "velox/vector/ComplexVector.h"
 
 namespace facebook::velox::functions::sparksql::fuzzer {
@@ -44,32 +44,15 @@ class SparkQueryRunner : public velox::exec::test::ReferenceQueryRunner {
         userId_(userId),
         userName_(userName),
         sessionId_(generateUUID()),
-        stub_(spark::connect::SparkConnectService::NewStub(grpc::CreateChannel(
-            coordinatorUri,
-            grpc::InsecureChannelCredentials()))) {
+        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;
   }
@@ -79,17 +62,36 @@ class SparkQueryRunner : public velox::exec::test::ReferenceQueryRunner {
   const std::unordered_map<std::string, DataSpec>&
   aggregationFunctionDataSpecs() const override;
 
+  /// 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;
+
+  // Converts 'plan' into an SQL query and executes it. 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<std::multiset<std::vector<variant>>>,
+      exec::test::ReferenceQueryErrorCode>
+  execute(const core::PlanNodePtr& plan) override;
+
+  /// Similar to 'execute' but returns results in RowVector format.
+  /// Caller should ensure 'supportsVeloxVectorResults' returns true.
+  std::pair<
+      std::optional<std::vector<RowVectorPtr>>,
+      exec::test::ReferenceQueryErrorCode>
+  executeAndReturnVector(const core::PlanNodePtr& plan) override;
+
+  /// Executes Spark SQL query and returns the results. Tables referenced by
+  /// the query must already exist.
+  std::vector<velox::RowVectorPtr> execute(const std::string& sql) 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:
   using ReferenceQueryRunner::toSql;
 
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.cpp b/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.cpp
index f721e0508422..cceb758277cd 100644
--- a/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.cpp
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h"
+#include "velox/exec/fuzzer/ReferenceQueryRunner.h"
 
 namespace facebook::velox::functions::sparksql::fuzzer {
 
@@ -57,7 +58,13 @@ void SparkQueryRunnerToSqlPlanNodeVisitor::visit(
     }
   }
 
-  sql << " FROM tmp";
+  // AggregationNode should have a single source.
+  const auto source = toSql(node.sources()[0]);
+  if (!source) {
+    visitorContext.sql = std::nullopt;
+    return;
+  }
+  sql << " FROM (" << *source << ")";
 
   if (!groupingKeys.empty()) {
     sql << " GROUP BY " << folly::join(", ", groupingKeys);
@@ -106,4 +113,12 @@ void SparkQueryRunnerToSqlPlanNodeVisitor::visit(
   visitorContext.sql = sql.str();
 }
 
+void SparkQueryRunnerToSqlPlanNodeVisitor::visit(
+    const core::ValuesNode& node,
+    core::PlanNodeVisitorContext& ctx) const {
+  exec::test::PrestoSqlPlanNodeVisitorContext& visitorContext =
+      static_cast<exec::test::PrestoSqlPlanNodeVisitorContext&>(ctx);
+  visitorContext.sql = exec::test::ReferenceQueryRunner::getTableName(node);
+}
+
 } // namespace facebook::velox::functions::sparksql::fuzzer
diff --git a/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h b/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h
index 4a8f3f2731e2..febe82780653 100644
--- a/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h
+++ b/velox/functions/sparksql/fuzzer/SparkQueryRunnerToSqlPlanNodeVisitor.h
@@ -122,11 +122,22 @@ class SparkQueryRunnerToSqlPlanNodeVisitor
   void visit(const core::ProjectNode& node, core::PlanNodeVisitorContext& ctx)
       const override;
 
+  void visit(const core::ParallelProjectNode&, core::PlanNodeVisitorContext&)
+      const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::RowNumberNode&, core::PlanNodeVisitorContext&)
       const override {
     VELOX_NYI();
   }
 
+  void visit(
+      const core::SpatialJoinNode& node,
+      core::PlanNodeVisitorContext& ctx) const override {
+    VELOX_NYI();
+  }
+
   void visit(const core::TableScanNode& node, core::PlanNodeVisitorContext& ctx)
       const override {
     PrestoSqlPlanNodeVisitor::visit(node, ctx);
@@ -163,9 +174,7 @@ class SparkQueryRunnerToSqlPlanNodeVisitor
   }
 
   void visit(const core::ValuesNode& node, core::PlanNodeVisitorContext& ctx)
-      const override {
-    PrestoSqlPlanNodeVisitor::visit(node, ctx);
-  }
+      const override;
 
   void visit(const core::WindowNode&, core::PlanNodeVisitorContext&)
       const override {
diff --git a/velox/functions/sparksql/fuzzer/spark/connect/base.proto b/velox/functions/sparksql/fuzzer/spark/connect/base.proto
new file mode 100644
index 000000000000..799cc7215016
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/spark/connect/base.proto
@@ -0,0 +1,852 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE 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.
+ */
+
+syntax = 'proto3';
+
+package spark.connect;
+
+import "google/protobuf/any.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/commands.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/common.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/expressions.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/relations.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/types.proto";
+
+option java_multiple_files = true;
+option java_package = "org.apache.spark.connect.proto";
+option go_package = "internal/generated";
+
+// A [[Plan]] is the structure that carries the runtime information for the
+// execution from the client to the server. A [[Plan]] can either be of the type
+// [[Relation]] which is a reference to the underlying logical plan or it can be
+// of the [[Command]] type that is used to execute commands on the server.
+message Plan {
+  oneof op_type {
+    Relation root = 1;
+    Command command = 2;
+  }
+}
+
+// User Context is used to refer to one particular user session that is
+// executing queries in the backend.
+message UserContext {
+  string user_id = 1;
+  string user_name = 2;
+
+  // To extend the existing user context message that is used to identify
+  // incoming requests, Spark Connect leverages the Any protobuf type that can
+  // be used to inject arbitrary other messages into this message. Extensions
+  // are stored as a `repeated` type to be able to handle multiple active
+  // extensions.
+  repeated google.protobuf.Any extensions = 999;
+}
+
+// Request to perform plan analyze, optionally to explain the plan.
+message AnalyzePlanRequest {
+  // (Required)
+  //
+  // The session_id specifies a spark session for a user id (which is specified
+  // by user_context.user_id). The session_id is set by the client to be able to
+  // collate streaming responses from different queries within the dedicated
+  // session. The id should be an UUID string of the format
+  // `00112233-4455-6677-8899-aabbccddeeff`
+  string session_id = 1;
+
+  // (Required) User context
+  UserContext user_context = 2;
+
+  // Provides optional information about the client sending the request. This
+  // field can be used for language or version specific information and is only
+  // intended for logging purposes and will not be interpreted by the server.
+  optional string client_type = 3;
+
+  oneof analyze {
+    Schema schema = 4;
+    Explain explain = 5;
+    TreeString tree_string = 6;
+    IsLocal is_local = 7;
+    IsStreaming is_streaming = 8;
+    InputFiles input_files = 9;
+    SparkVersion spark_version = 10;
+    DDLParse ddl_parse = 11;
+    SameSemantics same_semantics = 12;
+    SemanticHash semantic_hash = 13;
+    Persist persist = 14;
+    Unpersist unpersist = 15;
+    GetStorageLevel get_storage_level = 16;
+  }
+
+  message Schema {
+    // (Required) The logical plan to be analyzed.
+    Plan plan = 1;
+  }
+
+  // Explains the input plan based on a configurable mode.
+  message Explain {
+    // (Required) The logical plan to be analyzed.
+    Plan plan = 1;
+
+    // (Required) For analyzePlan rpc calls, configure the mode to explain plan
+    // in strings.
+    ExplainMode explain_mode = 2;
+
+    // Plan explanation mode.
+    enum ExplainMode {
+      EXPLAIN_MODE_UNSPECIFIED = 0;
+
+      // Generates only physical plan.
+      EXPLAIN_MODE_SIMPLE = 1;
+
+      // Generates parsed logical plan, analyzed logical plan, optimized logical
+      // plan and physical plan. Parsed Logical plan is a unresolved plan that
+      // extracted from the query. Analyzed logical plans transforms which
+      // translates unresolvedAttribute and unresolvedRelation into fully typed
+      // objects. The optimized logical plan transforms through a set of
+      // optimization rules, resulting in the physical plan.
+      EXPLAIN_MODE_EXTENDED = 2;
+
+      // Generates code for the statement, if any and a physical plan.
+      EXPLAIN_MODE_CODEGEN = 3;
+
+      // If plan node statistics are available, generates a logical plan and
+      // also the statistics.
+      EXPLAIN_MODE_COST = 4;
+
+      // Generates a physical plan outline and also node details.
+      EXPLAIN_MODE_FORMATTED = 5;
+    }
+  }
+
+  message TreeString {
+    // (Required) The logical plan to be analyzed.
+    Plan plan = 1;
+
+    // (Optional) Max level of the schema.
+    optional int32 level = 2;
+  }
+
+  message IsLocal {
+    // (Required) The logical plan to be analyzed.
+    Plan plan = 1;
+  }
+
+  message IsStreaming {
+    // (Required) The logical plan to be analyzed.
+    Plan plan = 1;
+  }
+
+  message InputFiles {
+    // (Required) The logical plan to be analyzed.
+    Plan plan = 1;
+  }
+
+  message SparkVersion {}
+
+  message DDLParse {
+    // (Required) The DDL formatted string to be parsed.
+    string ddl_string = 1;
+  }
+
+  // Returns `true` when the logical query plans  are equal and therefore return
+  // same results.
+  message SameSemantics {
+    // (Required) The plan to be compared.
+    Plan target_plan = 1;
+
+    // (Required) The other plan to be compared.
+    Plan other_plan = 2;
+  }
+
+  message SemanticHash {
+    // (Required) The logical plan to get a hashCode.
+    Plan plan = 1;
+  }
+
+  message Persist {
+    // (Required) The logical plan to persist.
+    Relation relation = 1;
+
+    // (Optional) The storage level.
+    optional StorageLevel storage_level = 2;
+  }
+
+  message Unpersist {
+    // (Required) The logical plan to unpersist.
+    Relation relation = 1;
+
+    // (Optional) Whether to block until all blocks are deleted.
+    optional bool blocking = 2;
+  }
+
+  message GetStorageLevel {
+    // (Required) The logical plan to get the storage level.
+    Relation relation = 1;
+  }
+}
+
+// Response to performing analysis of the query. Contains relevant metadata to
+// be able to reason about the performance.
+message AnalyzePlanResponse {
+  string session_id = 1;
+
+  oneof result {
+    Schema schema = 2;
+    Explain explain = 3;
+    TreeString tree_string = 4;
+    IsLocal is_local = 5;
+    IsStreaming is_streaming = 6;
+    InputFiles input_files = 7;
+    SparkVersion spark_version = 8;
+    DDLParse ddl_parse = 9;
+    SameSemantics same_semantics = 10;
+    SemanticHash semantic_hash = 11;
+    Persist persist = 12;
+    Unpersist unpersist = 13;
+    GetStorageLevel get_storage_level = 14;
+  }
+
+  message Schema {
+    DataType schema = 1;
+  }
+
+  message Explain {
+    string explain_string = 1;
+  }
+
+  message TreeString {
+    string tree_string = 1;
+  }
+
+  message IsLocal {
+    bool is_local = 1;
+  }
+
+  message IsStreaming {
+    bool is_streaming = 1;
+  }
+
+  message InputFiles {
+    // A best-effort snapshot of the files that compose this Dataset
+    repeated string files = 1;
+  }
+
+  message SparkVersion {
+    string version = 1;
+  }
+
+  message DDLParse {
+    DataType parsed = 1;
+  }
+
+  message SameSemantics {
+    bool result = 1;
+  }
+
+  message SemanticHash {
+    int32 result = 1;
+  }
+
+  message Persist {}
+
+  message Unpersist {}
+
+  message GetStorageLevel {
+    // (Required) The StorageLevel as a result of get_storage_level request.
+    StorageLevel storage_level = 1;
+  }
+}
+
+// A request to be executed by the service.
+message ExecutePlanRequest {
+  // (Required)
+  //
+  // The session_id specifies a spark session for a user id (which is specified
+  // by user_context.user_id). The session_id is set by the client to be able to
+  // collate streaming responses from different queries within the dedicated
+  // session. The id should be an UUID string of the format
+  // `00112233-4455-6677-8899-aabbccddeeff`
+  string session_id = 1;
+
+  // (Required) User context
+  //
+  // user_context.user_id and session+id both identify a unique remote spark
+  // session on the server side.
+  UserContext user_context = 2;
+
+  // (Optional)
+  // Provide an id for this request. If not provided, it will be generated by
+  // the server. It is returned in every ExecutePlanResponse.operation_id of the
+  // ExecutePlan response stream. The id must be an UUID string of the format
+  // `00112233-4455-6677-8899-aabbccddeeff`
+  optional string operation_id = 6;
+
+  // (Required) The logical plan to be executed / analyzed.
+  Plan plan = 3;
+
+  // Provides optional information about the client sending the request. This
+  // field can be used for language or version specific information and is only
+  // intended for logging purposes and will not be interpreted by the server.
+  optional string client_type = 4;
+
+  // Repeated element for options that can be passed to the request. This
+  // element is currently unused but allows to pass in an extension value used
+  // for arbitrary options.
+  repeated RequestOption request_options = 5;
+
+  message RequestOption {
+    oneof request_option {
+      ReattachOptions reattach_options = 1;
+      // Extension type for request options
+      google.protobuf.Any extension = 999;
+    }
+  }
+
+  // Tags to tag the given execution with.
+  // Tags cannot contain ',' character and cannot be empty strings.
+  // Used by Interrupt with interrupt.tag.
+  repeated string tags = 7;
+}
+
+// The response of a query, can be one or more for each request. Responses
+// belonging to the same input query, carry the same `session_id`.
+message ExecutePlanResponse {
+  string session_id = 1;
+
+  // Identifies the ExecutePlan execution.
+  // If set by the client in ExecutePlanRequest.operationId, that value is
+  // returned. Otherwise generated by the server. It is an UUID string of the
+  // format `00112233-4455-6677-8899-aabbccddeeff`
+  string operation_id = 12;
+
+  // Identified the response in the stream.
+  // The id is an UUID string of the format
+  // `00112233-4455-6677-8899-aabbccddeeff`
+  string response_id = 13;
+
+  // Union type for the different response messages.
+  oneof response_type {
+    ArrowBatch arrow_batch = 2;
+
+    // Special case for executing SQL commands.
+    SqlCommandResult sql_command_result = 5;
+
+    // Response for a streaming query.
+    WriteStreamOperationStartResult write_stream_operation_start_result = 8;
+
+    // Response for commands on a streaming query.
+    StreamingQueryCommandResult streaming_query_command_result = 9;
+
+    // Response for 'SparkContext.resources'.
+    GetResourcesCommandResult get_resources_command_result = 10;
+
+    // Response for commands on the streaming query manager.
+    StreamingQueryManagerCommandResult streaming_query_manager_command_result =
+        11;
+
+    // Response type informing if the stream is complete in reattachable
+    // execution.
+    ResultComplete result_complete = 14;
+
+    // Support arbitrary result objects.
+    google.protobuf.Any extension = 999;
+  }
+
+  // Metrics for the query execution. Typically, this field is only present in
+  // the last batch of results and then represent the overall state of the query
+  // execution.
+  Metrics metrics = 4;
+
+  // The metrics observed during the execution of the query plan.
+  repeated ObservedMetrics observed_metrics = 6;
+
+  // (Optional) The Spark schema. This field is available when `collect` is
+  // called.
+  DataType schema = 7;
+
+  // A SQL command returns an opaque Relation that can be directly used as input
+  // for the next call.
+  message SqlCommandResult {
+    Relation relation = 1;
+  }
+
+  // Batch results of metrics.
+  message ArrowBatch {
+    int64 row_count = 1;
+    bytes data = 2;
+  }
+
+  message Metrics {
+    repeated MetricObject metrics = 1;
+
+    message MetricObject {
+      string name = 1;
+      int64 plan_id = 2;
+      int64 parent = 3;
+      map<string, MetricValue> execution_metrics = 4;
+    }
+
+    message MetricValue {
+      string name = 1;
+      int64 value = 2;
+      string metric_type = 3;
+    }
+  }
+
+  message ObservedMetrics {
+    string name = 1;
+    repeated Expression.Literal values = 2;
+  }
+
+  message ResultComplete {
+    // If present, in a reattachable execution this means that after server
+    // sends onComplete, the execution is complete. If the server sends
+    // onComplete without sending a ResultComplete, it means that there is more,
+    // and the client should use ReattachExecute RPC to continue.
+  }
+}
+
+// The key-value pair for the config request and response.
+message KeyValue {
+  // (Required) The key.
+  string key = 1;
+  // (Optional) The value.
+  optional string value = 2;
+}
+
+// Request to update or fetch the configurations.
+message ConfigRequest {
+  // (Required)
+  //
+  // The session_id specifies a spark session for a user id (which is specified
+  // by user_context.user_id). The session_id is set by the client to be able to
+  // collate streaming responses from different queries within the dedicated
+  // session. The id should be an UUID string of the format
+  // `00112233-4455-6677-8899-aabbccddeeff`
+  string session_id = 1;
+
+  // (Required) User context
+  UserContext user_context = 2;
+
+  // (Required) The operation for the config.
+  Operation operation = 3;
+
+  // Provides optional information about the client sending the request. This
+  // field can be used for language or version specific information and is only
+  // intended for logging purposes and will not be interpreted by the server.
+  optional string client_type = 4;
+
+  message Operation {
+    oneof op_type {
+      Set set = 1;
+      Get get = 2;
+      GetWithDefault get_with_default = 3;
+      GetOption get_option = 4;
+      GetAll get_all = 5;
+      Unset unset = 6;
+      IsModifiable is_modifiable = 7;
+    }
+  }
+
+  message Set {
+    // (Required) The config key-value pairs to set.
+    repeated KeyValue pairs = 1;
+  }
+
+  message Get {
+    // (Required) The config keys to get.
+    repeated string keys = 1;
+  }
+
+  message GetWithDefault {
+    // (Required) The config key-value paris to get. The value will be used as
+    // the default value.
+    repeated KeyValue pairs = 1;
+  }
+
+  message GetOption {
+    // (Required) The config keys to get optionally.
+    repeated string keys = 1;
+  }
+
+  message GetAll {
+    // (Optional) The prefix of the config key to get.
+    optional string prefix = 1;
+  }
+
+  message Unset {
+    // (Required) The config keys to unset.
+    repeated string keys = 1;
+  }
+
+  message IsModifiable {
+    // (Required) The config keys to check the config is modifiable.
+    repeated string keys = 1;
+  }
+}
+
+// Response to the config request.
+message ConfigResponse {
+  string session_id = 1;
+
+  // (Optional) The result key-value pairs.
+  //
+  // Available when the operation is 'Get', 'GetWithDefault', 'GetOption',
+  // 'GetAll'. Also available for the operation 'IsModifiable' with boolean
+  // string "true" and "false".
+  repeated KeyValue pairs = 2;
+
+  // (Optional)
+  //
+  // Warning messages for deprecated or unsupported configurations.
+  repeated string warnings = 3;
+}
+
+// Request to transfer client-local artifacts.
+message AddArtifactsRequest {
+  // (Required)
+  //
+  // The session_id specifies a spark session for a user id (which is specified
+  // by user_context.user_id). The session_id is set by the client to be able to
+  // collate streaming responses from different queries within the dedicated
+  // session. The id should be an UUID string of the format
+  // `00112233-4455-6677-8899-aabbccddeeff`
+  string session_id = 1;
+
+  // User context
+  UserContext user_context = 2;
+
+  // Provides optional information about the client sending the request. This
+  // field can be used for language or version specific information and is only
+  // intended for logging purposes and will not be interpreted by the server.
+  optional string client_type = 6;
+
+  // A chunk of an Artifact.
+  message ArtifactChunk {
+    // Data chunk.
+    bytes data = 1;
+    // CRC to allow server to verify integrity of the chunk.
+    int64 crc = 2;
+  }
+
+  // An artifact that is contained in a single `ArtifactChunk`.
+  // Generally, this message represents tiny artifacts such as REPL-generated
+  // class files.
+  message SingleChunkArtifact {
+    // The name of the artifact is expected in the form of a "Relative Path"
+    // that is made up of a sequence of directories and the final file element.
+    // Examples of "Relative Path"s: "jars/test.jar", "classes/xyz.class",
+    // "abc.xyz", "a/b/X.jar". The server is expected to maintain the hierarchy
+    // of files as defined by their name. (i.e The relative path of the file on
+    // the server's filesystem will be the same as the name of the provided
+    // artifact)
+    string name = 1;
+    // A single data chunk.
+    ArtifactChunk data = 2;
+  }
+
+  // A number of `SingleChunkArtifact` batched into a single RPC.
+  message Batch {
+    repeated SingleChunkArtifact artifacts = 1;
+  }
+
+  // Signals the beginning/start of a chunked artifact.
+  // A large artifact is transferred through a payload of `BeginChunkedArtifact`
+  // followed by a sequence of `ArtifactChunk`s.
+  message BeginChunkedArtifact {
+    // Name of the artifact undergoing chunking. Follows the same conventions as
+    // the `name` in the `Artifact` message.
+    string name = 1;
+    // Total size of the artifact in bytes.
+    int64 total_bytes = 2;
+    // Number of chunks the artifact is split into.
+    // This includes the `initial_chunk`.
+    int64 num_chunks = 3;
+    // The first/initial chunk.
+    ArtifactChunk initial_chunk = 4;
+  }
+
+  // The payload is either a batch of artifacts or a partial chunk of a large
+  // artifact.
+  oneof payload {
+    Batch batch = 3;
+    // The metadata and the initial chunk of a large artifact chunked into
+    // multiple requests. The server side is notified about the total size of
+    // the large artifact as well as the number of chunks to expect.
+    BeginChunkedArtifact begin_chunk = 4;
+    // A chunk of an artifact excluding metadata. This can be any chunk of a
+    // large artifact excluding the first chunk (which is included in
+    // `BeginChunkedArtifact`).
+    ArtifactChunk chunk = 5;
+  }
+}
+
+// Response to adding an artifact. Contains relevant metadata to verify
+// successful transfer of artifact(s).
+message AddArtifactsResponse {
+  // Metadata of an artifact.
+  message ArtifactSummary {
+    string name = 1;
+    // Whether the CRC (Cyclic Redundancy Check) is successful on server
+    // verification. The server discards any artifact that fails the CRC. If
+    // false, the client may choose to resend the artifact specified by `name`.
+    bool is_crc_successful = 2;
+  }
+
+  // The list of artifact(s) seen by the server.
+  repeated ArtifactSummary artifacts = 1;
+}
+
+// Request to get current statuses of artifacts at the server side.
+message ArtifactStatusesRequest {
+  // (Required)
+  //
+  // The session_id specifies a spark session for a user id (which is specified
+  // by user_context.user_id). The session_id is set by the client to be able to
+  // collate streaming responses from different queries within the dedicated
+  // session. The id should be an UUID string of the format
+  // `00112233-4455-6677-8899-aabbccddeeff`
+  string session_id = 1;
+
+  // User context
+  UserContext user_context = 2;
+
+  // Provides optional information about the client sending the request. This
+  // field can be used for language or version specific information and is only
+  // intended for logging purposes and will not be interpreted by the server.
+  optional string client_type = 3;
+
+  // The name of the artifact is expected in the form of a "Relative Path" that
+  // is made up of a sequence of directories and the final file element.
+  // Examples of "Relative Path"s: "jars/test.jar", "classes/xyz.class",
+  // "abc.xyz", "a/b/X.jar". The server is expected to maintain the hierarchy of
+  // files as defined by their name. (i.e The relative path of the file on the
+  // server's filesystem will be the same as the name of the provided artifact)
+  repeated string names = 4;
+}
+
+// Response to checking artifact statuses.
+message ArtifactStatusesResponse {
+  message ArtifactStatus {
+    // Exists or not particular artifact at the server.
+    bool exists = 1;
+  }
+
+  // A map of artifact names to their statuses.
+  map<string, ArtifactStatus> statuses = 1;
+}
+
+message InterruptRequest {
+  // (Required)
+  //
+  // The session_id specifies a spark session for a user id (which is specified
+  // by user_context.user_id). The session_id is set by the client to be able to
+  // collate streaming responses from different queries within the dedicated
+  // session. The id should be an UUID string of the format
+  // `00112233-4455-6677-8899-aabbccddeeff`
+  string session_id = 1;
+
+  // (Required) User context
+  UserContext user_context = 2;
+
+  // Provides optional information about the client sending the request. This
+  // field can be used for language or version specific information and is only
+  // intended for logging purposes and will not be interpreted by the server.
+  optional string client_type = 3;
+
+  // (Required) The type of interrupt to execute.
+  InterruptType interrupt_type = 4;
+
+  enum InterruptType {
+    INTERRUPT_TYPE_UNSPECIFIED = 0;
+
+    // Interrupt all running executions within the session with the provided
+    // session_id.
+    INTERRUPT_TYPE_ALL = 1;
+
+    // Interrupt all running executions within the session with the provided
+    // operation_tag.
+    INTERRUPT_TYPE_TAG = 2;
+
+    // Interrupt the running execution within the session with the provided
+    // operation_id.
+    INTERRUPT_TYPE_OPERATION_ID = 3;
+  }
+
+  oneof interrupt {
+    // if interrupt_tag == INTERRUPT_TYPE_TAG, interrupt operation with this
+    // tag.
+    string operation_tag = 5;
+
+    // if interrupt_tag == INTERRUPT_TYPE_OPERATION_ID, interrupt operation with
+    // this operation_id.
+    string operation_id = 6;
+  }
+}
+
+message InterruptResponse {
+  // Session id in which the interrupt was running.
+  string session_id = 1;
+
+  // Operation ids of the executions which were interrupted.
+  repeated string interrupted_ids = 2;
+}
+
+message ReattachOptions {
+  // If true, the request can be reattached to using ReattachExecute.
+  // ReattachExecute can be used either if the stream broke with a GRPC network
+  // error, or if the server closed the stream without sending a response with
+  // StreamStatus.complete=true. The server will keep a buffer of responses in
+  // case a response is lost, and ReattachExecute needs to back-track.
+  //
+  // If false, the execution response stream will will not be reattachable, and
+  // all responses are immediately released by the server after being sent.
+  bool reattachable = 1;
+}
+
+message ReattachExecuteRequest {
+  // (Required)
+  //
+  // The session_id of the request to reattach to.
+  // This must be an id of existing session.
+  string session_id = 1;
+
+  // (Required) User context
+  //
+  // user_context.user_id and session+id both identify a unique remote spark
+  // session on the server side.
+  UserContext user_context = 2;
+
+  // (Required)
+  // Provide an id of the request to reattach to.
+  // This must be an id of existing operation.
+  string operation_id = 3;
+
+  // Provides optional information about the client sending the request. This
+  // field can be used for language or version specific information and is only
+  // intended for logging purposes and will not be interpreted by the server.
+  optional string client_type = 4;
+
+  // (Optional)
+  // Last already processed response id from the response stream.
+  // After reattach, server will resume the response stream after that response.
+  // If not specified, server will restart the stream from the start.
+  //
+  // Note: server controls the amount of responses that it buffers and it may
+  // drop responses, that are far behind the latest returned response, so this
+  // can't be used to arbitrarily scroll back the cursor. If the response is no
+  // longer available, this will result in an error.
+  optional string last_response_id = 5;
+}
+
+message ReleaseExecuteRequest {
+  // (Required)
+  //
+  // The session_id of the request to reattach to.
+  // This must be an id of existing session.
+  string session_id = 1;
+
+  // (Required) User context
+  //
+  // user_context.user_id and session+id both identify a unique remote spark
+  // session on the server side.
+  UserContext user_context = 2;
+
+  // (Required)
+  // Provide an id of the request to reattach to.
+  // This must be an id of existing operation.
+  string operation_id = 3;
+
+  // Provides optional information about the client sending the request. This
+  // field can be used for language or version specific information and is only
+  // intended for logging purposes and will not be interpreted by the server.
+  optional string client_type = 4;
+
+  // Release and close operation completely.
+  // This will also interrupt the query if it is running execution, and wait for
+  // it to be torn down.
+  message ReleaseAll {}
+
+  // Release all responses from the operation response stream up to and
+  // including the response with the given by response_id. While server
+  // determines by itself how much of a buffer of responses to keep, client
+  // providing explicit release calls will help reduce resource consumption.
+  // Noop if response_id not found in cached responses.
+  message ReleaseUntil {
+    string response_id = 1;
+  }
+
+  oneof release {
+    ReleaseAll release_all = 5;
+    ReleaseUntil release_until = 6;
+  }
+}
+
+message ReleaseExecuteResponse {
+  // Session id in which the release was running.
+  string session_id = 1;
+
+  // Operation id of the operation on which the release executed.
+  // If the operation couldn't be found (because e.g. it was concurrently
+  // released), will be unset. Otherwise, it will be equal to the operation_id
+  // from request.
+  optional string operation_id = 2;
+}
+
+// Main interface for the SparkConnect service.
+service SparkConnectService {
+  // Executes a request that contains the query and returns a stream of
+  // [[Response]].
+  //
+  // It is guaranteed that there is at least one ARROW batch returned even if
+  // the result set is empty.
+  rpc ExecutePlan(ExecutePlanRequest) returns (stream ExecutePlanResponse) {}
+
+  // Analyzes a query and returns a [[AnalyzeResponse]] containing metadata
+  // about the query.
+  rpc AnalyzePlan(AnalyzePlanRequest) returns (AnalyzePlanResponse) {}
+
+  // Update or fetch the configurations and returns a [[ConfigResponse]]
+  // containing the result.
+  rpc Config(ConfigRequest) returns (ConfigResponse) {}
+
+  // Add artifacts to the session and returns a [[AddArtifactsResponse]]
+  // containing metadata about the added artifacts.
+  rpc AddArtifacts(stream AddArtifactsRequest) returns (AddArtifactsResponse) {}
+
+  // Check statuses of artifacts in the session and returns them in a
+  // [[ArtifactStatusesResponse]]
+  rpc ArtifactStatus(ArtifactStatusesRequest)
+      returns (ArtifactStatusesResponse) {}
+
+  // Interrupts running executions
+  rpc Interrupt(InterruptRequest) returns (InterruptResponse) {}
+
+  // Reattach to an existing reattachable execution.
+  // The ExecutePlan must have been started with
+  // ReattachOptions.reattachable=true. If the ExecutePlanResponse stream ends
+  // without a ResultComplete message, there is more to continue. If there is a
+  // ResultComplete, the client should use ReleaseExecute with
+  rpc ReattachExecute(ReattachExecuteRequest)
+      returns (stream ExecutePlanResponse) {}
+
+  // Release an reattachable execution, or parts thereof.
+  // The ExecutePlan must have been started with
+  // ReattachOptions.reattachable=true. Non reattachable executions are released
+  // automatically and immediately after the ExecutePlan RPC and ReleaseExecute
+  // may not be used.
+  rpc ReleaseExecute(ReleaseExecuteRequest) returns (ReleaseExecuteResponse) {}
+}
diff --git a/velox/functions/sparksql/fuzzer/spark/connect/catalog.proto b/velox/functions/sparksql/fuzzer/spark/connect/catalog.proto
new file mode 100644
index 000000000000..d9992073fd07
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/spark/connect/catalog.proto
@@ -0,0 +1,243 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE 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.
+ */
+
+syntax = 'proto3';
+
+package spark.connect;
+
+import "velox/functions/sparksql/fuzzer/spark/connect/common.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/types.proto";
+
+option java_multiple_files = true;
+option java_package = "org.apache.spark.connect.proto";
+option go_package = "internal/generated";
+
+// Catalog messages are marked as unstable.
+message Catalog {
+  oneof cat_type {
+    CurrentDatabase current_database = 1;
+    SetCurrentDatabase set_current_database = 2;
+    ListDatabases list_databases = 3;
+    ListTables list_tables = 4;
+    ListFunctions list_functions = 5;
+    ListColumns list_columns = 6;
+    GetDatabase get_database = 7;
+    GetTable get_table = 8;
+    GetFunction get_function = 9;
+    DatabaseExists database_exists = 10;
+    TableExists table_exists = 11;
+    FunctionExists function_exists = 12;
+    CreateExternalTable create_external_table = 13;
+    CreateTable create_table = 14;
+    DropTempView drop_temp_view = 15;
+    DropGlobalTempView drop_global_temp_view = 16;
+    RecoverPartitions recover_partitions = 17;
+    IsCached is_cached = 18;
+    CacheTable cache_table = 19;
+    UncacheTable uncache_table = 20;
+    ClearCache clear_cache = 21;
+    RefreshTable refresh_table = 22;
+    RefreshByPath refresh_by_path = 23;
+    CurrentCatalog current_catalog = 24;
+    SetCurrentCatalog set_current_catalog = 25;
+    ListCatalogs list_catalogs = 26;
+  }
+}
+
+// See `spark.catalog.currentDatabase`
+message CurrentDatabase {}
+
+// See `spark.catalog.setCurrentDatabase`
+message SetCurrentDatabase {
+  // (Required)
+  string db_name = 1;
+}
+
+// See `spark.catalog.listDatabases`
+message ListDatabases {
+  // (Optional) The pattern that the database name needs to match
+  optional string pattern = 1;
+}
+
+// See `spark.catalog.listTables`
+message ListTables {
+  // (Optional)
+  optional string db_name = 1;
+  // (Optional) The pattern that the table name needs to match
+  optional string pattern = 2;
+}
+
+// See `spark.catalog.listFunctions`
+message ListFunctions {
+  // (Optional)
+  optional string db_name = 1;
+  // (Optional) The pattern that the function name needs to match
+  optional string pattern = 2;
+}
+
+// See `spark.catalog.listColumns`
+message ListColumns {
+  // (Required)
+  string table_name = 1;
+  // (Optional)
+  optional string db_name = 2;
+}
+
+// See `spark.catalog.getDatabase`
+message GetDatabase {
+  // (Required)
+  string db_name = 1;
+}
+
+// See `spark.catalog.getTable`
+message GetTable {
+  // (Required)
+  string table_name = 1;
+  // (Optional)
+  optional string db_name = 2;
+}
+
+// See `spark.catalog.getFunction`
+message GetFunction {
+  // (Required)
+  string function_name = 1;
+  // (Optional)
+  optional string db_name = 2;
+}
+
+// See `spark.catalog.databaseExists`
+message DatabaseExists {
+  // (Required)
+  string db_name = 1;
+}
+
+// See `spark.catalog.tableExists`
+message TableExists {
+  // (Required)
+  string table_name = 1;
+  // (Optional)
+  optional string db_name = 2;
+}
+
+// See `spark.catalog.functionExists`
+message FunctionExists {
+  // (Required)
+  string function_name = 1;
+  // (Optional)
+  optional string db_name = 2;
+}
+
+// See `spark.catalog.createExternalTable`
+message CreateExternalTable {
+  // (Required)
+  string table_name = 1;
+  // (Optional)
+  optional string path = 2;
+  // (Optional)
+  optional string source = 3;
+  // (Optional)
+  optional DataType schema = 4;
+  // Options could be empty for valid data source format.
+  // The map key is case insensitive.
+  map<string, string> options = 5;
+}
+
+// See `spark.catalog.createTable`
+message CreateTable {
+  // (Required)
+  string table_name = 1;
+  // (Optional)
+  optional string path = 2;
+  // (Optional)
+  optional string source = 3;
+  // (Optional)
+  optional string description = 4;
+  // (Optional)
+  optional DataType schema = 5;
+  // Options could be empty for valid data source format.
+  // The map key is case insensitive.
+  map<string, string> options = 6;
+}
+
+// See `spark.catalog.dropTempView`
+message DropTempView {
+  // (Required)
+  string view_name = 1;
+}
+
+// See `spark.catalog.dropGlobalTempView`
+message DropGlobalTempView {
+  // (Required)
+  string view_name = 1;
+}
+
+// See `spark.catalog.recoverPartitions`
+message RecoverPartitions {
+  // (Required)
+  string table_name = 1;
+}
+
+// See `spark.catalog.isCached`
+message IsCached {
+  // (Required)
+  string table_name = 1;
+}
+
+// See `spark.catalog.cacheTable`
+message CacheTable {
+  // (Required)
+  string table_name = 1;
+
+  // (Optional)
+  optional StorageLevel storage_level = 2;
+}
+
+// See `spark.catalog.uncacheTable`
+message UncacheTable {
+  // (Required)
+  string table_name = 1;
+}
+
+// See `spark.catalog.clearCache`
+message ClearCache {}
+
+// See `spark.catalog.refreshTable`
+message RefreshTable {
+  // (Required)
+  string table_name = 1;
+}
+
+// See `spark.catalog.refreshByPath`
+message RefreshByPath {
+  // (Required)
+  string path = 1;
+}
+
+// See `spark.catalog.currentCatalog`
+message CurrentCatalog {}
+
+// See `spark.catalog.setCurrentCatalog`
+message SetCurrentCatalog {
+  // (Required)
+  string catalog_name = 1;
+}
+
+// See `spark.catalog.listCatalogs`
+message ListCatalogs {
+  // (Optional) The pattern that the catalog name needs to match
+  optional string pattern = 1;
+}
diff --git a/velox/functions/sparksql/fuzzer/spark/connect/commands.proto b/velox/functions/sparksql/fuzzer/spark/connect/commands.proto
new file mode 100644
index 000000000000..ee418874a1a3
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/spark/connect/commands.proto
@@ -0,0 +1,425 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE 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.
+ */
+
+syntax = 'proto3';
+
+import "google/protobuf/any.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/common.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/expressions.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/relations.proto";
+
+package spark.connect;
+
+option java_multiple_files = true;
+option java_package = "org.apache.spark.connect.proto";
+option go_package = "internal/generated";
+
+// A [[Command]] is an operation that is executed by the server that does not
+// directly consume or produce a relational result.
+message Command {
+  oneof command_type {
+    CommonInlineUserDefinedFunction register_function = 1;
+    WriteOperation write_operation = 2;
+    CreateDataFrameViewCommand create_dataframe_view = 3;
+    WriteOperationV2 write_operation_v2 = 4;
+    SqlCommand sql_command = 5;
+    WriteStreamOperationStart write_stream_operation_start = 6;
+    StreamingQueryCommand streaming_query_command = 7;
+    GetResourcesCommand get_resources_command = 8;
+    StreamingQueryManagerCommand streaming_query_manager_command = 9;
+    CommonInlineUserDefinedTableFunction register_table_function = 10;
+
+    // This field is used to mark extensions to the protocol. When plugins
+    // generate arbitrary Commands they can add them here. During the planning
+    // the correct resolution is done.
+    google.protobuf.Any extension = 999;
+  }
+}
+
+// A SQL Command is used to trigger the eager evaluation of SQL commands in
+// Spark.
+//
+// When the SQL provide as part of the message is a command it will be
+// immediately evaluated and the result will be collected and returned as part
+// of a LocalRelation. If the result is not a command, the operation will simply
+// return a SQL Relation. This allows the client to be almost oblivious to the
+// server-side behavior.
+message SqlCommand {
+  // (Required) SQL Query.
+  string sql = 1;
+
+  // (Optional) A map of parameter names to literal expressions.
+  map<string, Expression.Literal> args = 2;
+
+  // (Optional) A sequence of literal expressions for positional parameters in
+  // the SQL query text.
+  repeated Expression.Literal pos_args = 3;
+}
+
+// A command that can create DataFrame global temp view or local temp view.
+message CreateDataFrameViewCommand {
+  // (Required) The relation that this view will be built on.
+  Relation input = 1;
+
+  // (Required) View name.
+  string name = 2;
+
+  // (Required) Whether this is global temp view or local temp view.
+  bool is_global = 3;
+
+  // (Required)
+  //
+  // If true, and if the view already exists, updates it; if false, and if the
+  // view already exists, throws exception.
+  bool replace = 4;
+}
+
+// As writes are not directly handled during analysis and planning, they are
+// modeled as commands.
+message WriteOperation {
+  // (Required) The output of the `input` relation will be persisted according
+  // to the options.
+  Relation input = 1;
+
+  // (Optional) Format value according to the Spark documentation. Examples are:
+  // text, parquet, delta.
+  optional string source = 2;
+
+  // (Optional)
+  //
+  // The destination of the write operation can be either a path or a table.
+  // If the destination is neither a path nor a table, such as jdbc and noop,
+  // the `save_type` should not be set.
+  oneof save_type {
+    string path = 3;
+    SaveTable table = 4;
+  }
+
+  // (Required) the save mode.
+  SaveMode mode = 5;
+
+  // (Optional) List of columns to sort the output by.
+  repeated string sort_column_names = 6;
+
+  // (Optional) List of columns for partitioning.
+  repeated string partitioning_columns = 7;
+
+  // (Optional) Bucketing specification. Bucketing must set the number of
+  // buckets and the columns to bucket by.
+  BucketBy bucket_by = 8;
+
+  // (Optional) A list of configuration options.
+  map<string, string> options = 9;
+
+  message SaveTable {
+    // (Required) The table name.
+    string table_name = 1;
+    // (Required) The method to be called to write to the table.
+    TableSaveMethod save_method = 2;
+
+    enum TableSaveMethod {
+      TABLE_SAVE_METHOD_UNSPECIFIED = 0;
+      TABLE_SAVE_METHOD_SAVE_AS_TABLE = 1;
+      TABLE_SAVE_METHOD_INSERT_INTO = 2;
+    }
+  }
+
+  message BucketBy {
+    repeated string bucket_column_names = 1;
+    int32 num_buckets = 2;
+  }
+
+  enum SaveMode {
+    SAVE_MODE_UNSPECIFIED = 0;
+    SAVE_MODE_APPEND = 1;
+    SAVE_MODE_OVERWRITE = 2;
+    SAVE_MODE_ERROR_IF_EXISTS = 3;
+    SAVE_MODE_IGNORE = 4;
+  }
+}
+
+// As writes are not directly handled during analysis and planning, they are
+// modeled as commands.
+message WriteOperationV2 {
+  // (Required) The output of the `input` relation will be persisted according
+  // to the options.
+  Relation input = 1;
+
+  // (Required) The destination of the write operation must be either a path or
+  // a table.
+  string table_name = 2;
+
+  // (Optional) A provider for the underlying output data source. Spark's
+  // default catalog supports "parquet", "json", etc.
+  optional string provider = 3;
+
+  // (Optional) List of columns for partitioning for output table created by
+  // `create`, `createOrReplace`, or `replace`
+  repeated Expression partitioning_columns = 4;
+
+  // (Optional) A list of configuration options.
+  map<string, string> options = 5;
+
+  // (Optional) A list of table properties.
+  map<string, string> table_properties = 6;
+
+  // (Required) Write mode.
+  Mode mode = 7;
+
+  enum Mode {
+    MODE_UNSPECIFIED = 0;
+    MODE_CREATE = 1;
+    MODE_OVERWRITE = 2;
+    MODE_OVERWRITE_PARTITIONS = 3;
+    MODE_APPEND = 4;
+    MODE_REPLACE = 5;
+    MODE_CREATE_OR_REPLACE = 6;
+  }
+
+  // (Optional) A condition for overwrite saving mode
+  Expression overwrite_condition = 8;
+}
+
+// Starts write stream operation as streaming query. Query ID and Run ID of the
+// streaming query are returned.
+message WriteStreamOperationStart {
+  // (Required) The output of the `input` streaming relation will be written.
+  Relation input = 1;
+
+  // The following fields directly map to API for DataStreamWriter().
+  // Consult API documentation unless explicitly documented here.
+
+  string format = 2;
+  map<string, string> options = 3;
+  repeated string partitioning_column_names = 4;
+
+  oneof trigger {
+    string processing_time_interval = 5;
+    bool available_now = 6;
+    bool once = 7;
+    string continuous_checkpoint_interval = 8;
+  }
+
+  string output_mode = 9;
+  string query_name = 10;
+
+  // The destination is optional. When set, it can be a path or a table name.
+  oneof sink_destination {
+    string path = 11;
+    string table_name = 12;
+  }
+
+  StreamingForeachFunction foreach_writer = 13;
+  StreamingForeachFunction foreach_batch = 14;
+}
+
+message StreamingForeachFunction {
+  oneof function {
+    PythonUDF python_function = 1;
+    ScalarScalaUDF scala_function = 2;
+  }
+}
+
+message WriteStreamOperationStartResult {
+  // (Required) Query instance. See `StreamingQueryInstanceId`.
+  StreamingQueryInstanceId query_id = 1;
+
+  // An optional query name.
+  string name = 2;
+
+  // TODO: How do we indicate errors?
+  // TODO: Consider adding status, last progress etc here.
+}
+
+// A tuple that uniquely identifies an instance of streaming query run. It
+// consists of `id` that persists across the streaming runs and `run_id` that
+// changes between each run of the streaming query that resumes from the
+// checkpoint.
+message StreamingQueryInstanceId {
+  // (Required) The unique id of this query that persists across restarts from
+  // checkpoint data. That is, this id is generated when a query is started for
+  // the first time, and will be the same every time it is restarted from
+  // checkpoint data.
+  string id = 1;
+
+  // (Required) The unique id of this run of the query. That is, every
+  // start/restart of a query will generate a unique run_id. Therefore, every
+  // time a query is restarted from checkpoint, it will have the same `id` but
+  // different `run_id`s.
+  string run_id = 2;
+}
+
+// Commands for a streaming query.
+message StreamingQueryCommand {
+  // (Required) Query instance. See `StreamingQueryInstanceId`.
+  StreamingQueryInstanceId query_id = 1;
+
+  // See documentation for the corresponding API method in StreamingQuery.
+  oneof command {
+    // status() API.
+    bool status = 2;
+    // lastProgress() API.
+    bool last_progress = 3;
+    // recentProgress() API.
+    bool recent_progress = 4;
+    // stop() API. Stops the query.
+    bool stop = 5;
+    // processAllAvailable() API. Waits till all the available data is processed
+    bool process_all_available = 6;
+    // explain() API. Returns logical and physical plans.
+    ExplainCommand explain = 7;
+    // exception() API. Returns the exception in the query if any.
+    bool exception = 8;
+    // awaitTermination() API. Waits for the termination of the query.
+    AwaitTerminationCommand await_termination = 9;
+  }
+
+  message ExplainCommand {
+    // TODO: Consider reusing Explain from AnalyzePlanRequest message.
+    //       We can not do this right now since it base.proto imports this file.
+    bool extended = 1;
+  }
+
+  message AwaitTerminationCommand {
+    optional int64 timeout_ms = 2;
+  }
+}
+
+// Response for commands on a streaming query.
+message StreamingQueryCommandResult {
+  // (Required) Query instance id. See `StreamingQueryInstanceId`.
+  StreamingQueryInstanceId query_id = 1;
+
+  oneof result_type {
+    StatusResult status = 2;
+    RecentProgressResult recent_progress = 3;
+    ExplainResult explain = 4;
+    ExceptionResult exception = 5;
+    AwaitTerminationResult await_termination = 6;
+  }
+
+  message StatusResult {
+    // See documentation for these Scala 'StreamingQueryStatus' struct
+    string status_message = 1;
+    bool is_data_available = 2;
+    bool is_trigger_active = 3;
+    bool is_active = 4;
+  }
+
+  message RecentProgressResult {
+    // Progress reports as an array of json strings.
+    repeated string recent_progress_json = 5;
+  }
+
+  message ExplainResult {
+    // Logical and physical plans as string
+    string result = 1;
+  }
+
+  message ExceptionResult {
+    // (Optional) Exception message as string, maps to the return value of
+    // original StreamingQueryException's toString method
+    optional string exception_message = 1;
+    // (Optional) Exception error class as string
+    optional string error_class = 2;
+    // (Optional) Exception stack trace as string
+    optional string stack_trace = 3;
+  }
+
+  message AwaitTerminationResult {
+    bool terminated = 1;
+  }
+}
+
+// Commands for the streaming query manager.
+message StreamingQueryManagerCommand {
+  // See documentation for the corresponding API method in
+  // StreamingQueryManager.
+  oneof command {
+    // active() API, returns a list of active queries.
+    bool active = 1;
+    // get() API, returns the StreamingQuery identified by id.
+    string get_query = 2;
+    // awaitAnyTermination() API, wait until any query terminates or timeout.
+    AwaitAnyTerminationCommand await_any_termination = 3;
+    // resetTerminated() API.
+    bool reset_terminated = 4;
+    // addListener API.
+    StreamingQueryListenerCommand add_listener = 5;
+    // removeListener API.
+    StreamingQueryListenerCommand remove_listener = 6;
+    // listListeners() API, returns a list of streaming query listeners.
+    bool list_listeners = 7;
+  }
+
+  message AwaitAnyTerminationCommand {
+    // (Optional) The waiting time in milliseconds to wait for any query to
+    // terminate.
+    optional int64 timeout_ms = 1;
+  }
+
+  message StreamingQueryListenerCommand {
+    bytes listener_payload = 1;
+    optional PythonUDF python_listener_payload = 2;
+    string id = 3;
+  }
+}
+
+// Response for commands on the streaming query manager.
+message StreamingQueryManagerCommandResult {
+  oneof result_type {
+    ActiveResult active = 1;
+    StreamingQueryInstance query = 2;
+    AwaitAnyTerminationResult await_any_termination = 3;
+    bool reset_terminated = 4;
+    bool add_listener = 5;
+    bool remove_listener = 6;
+    ListStreamingQueryListenerResult list_listeners = 7;
+  }
+
+  message ActiveResult {
+    repeated StreamingQueryInstance active_queries = 1;
+  }
+
+  message StreamingQueryInstance {
+    // (Required) The id and runId of this query.
+    StreamingQueryInstanceId id = 1;
+    // (Optional) The name of this query.
+    optional string name = 2;
+  }
+
+  message AwaitAnyTerminationResult {
+    bool terminated = 1;
+  }
+
+  message StreamingQueryListenerInstance {
+    bytes listener_payload = 1;
+  }
+
+  message ListStreamingQueryListenerResult {
+    // (Required) Reference IDs of listener instances.
+    repeated string listener_ids = 1;
+  }
+}
+
+// Command to get the output of 'SparkContext.resources'
+message GetResourcesCommand {}
+
+// Response for command 'GetResourcesCommand'.
+message GetResourcesCommandResult {
+  map<string, ResourceInformation> resources = 1;
+}
diff --git a/velox/functions/sparksql/fuzzer/spark/connect/common.proto b/velox/functions/sparksql/fuzzer/spark/connect/common.proto
new file mode 100644
index 000000000000..31381f3374cd
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/spark/connect/common.proto
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE 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.
+ */
+
+syntax = 'proto3';
+
+package spark.connect;
+
+option java_multiple_files = true;
+option java_package = "org.apache.spark.connect.proto";
+option go_package = "internal/generated";
+
+// StorageLevel for persisting Datasets/Tables.
+message StorageLevel {
+  // (Required) Whether the cache should use disk or not.
+  bool use_disk = 1;
+  // (Required) Whether the cache should use memory or not.
+  bool use_memory = 2;
+  // (Required) Whether the cache should use off-heap or not.
+  bool use_off_heap = 3;
+  // (Required) Whether the cached data is deserialized or not.
+  bool deserialized = 4;
+  // (Required) The number of replicas.
+  int32 replication = 5;
+}
+
+// ResourceInformation to hold information about a type of Resource.
+// The corresponding class is 'org.apache.spark.resource.ResourceInformation'
+message ResourceInformation {
+  // (Required) The name of the resource
+  string name = 1;
+  // (Required) An array of strings describing the addresses of the resource.
+  repeated string addresses = 2;
+}
diff --git a/velox/functions/sparksql/fuzzer/spark/connect/example_plugins.proto b/velox/functions/sparksql/fuzzer/spark/connect/example_plugins.proto
new file mode 100644
index 000000000000..682c271f5b78
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/spark/connect/example_plugins.proto
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE 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.
+ */
+
+syntax = 'proto3';
+
+import "velox/functions/sparksql/fuzzer/spark/connect/relations.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/expressions.proto";
+option go_package = "internal/generated";
+
+package spark.connect;
+
+option java_multiple_files = true;
+option java_package = "org.apache.spark.connect.proto";
+
+message ExamplePluginRelation {
+  Relation input = 1;
+  string custom_field = 2;
+}
+
+message ExamplePluginExpression {
+  Expression child = 1;
+  string custom_field = 2;
+}
+
+message ExamplePluginCommand {
+  string custom_field = 1;
+}
diff --git a/velox/functions/sparksql/fuzzer/spark/connect/expressions.proto b/velox/functions/sparksql/fuzzer/spark/connect/expressions.proto
new file mode 100644
index 000000000000..607a0a8ca9ad
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/spark/connect/expressions.proto
@@ -0,0 +1,388 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE 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.
+ */
+
+syntax = 'proto3';
+
+import "google/protobuf/any.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/types.proto";
+
+package spark.connect;
+
+option java_multiple_files = true;
+option java_package = "org.apache.spark.connect.proto";
+option go_package = "internal/generated";
+
+// Expression used to refer to fields, functions and similar. This can be used
+// everywhere expressions in SQL appear.
+message Expression {
+  oneof expr_type {
+    Literal literal = 1;
+    UnresolvedAttribute unresolved_attribute = 2;
+    UnresolvedFunction unresolved_function = 3;
+    ExpressionString expression_string = 4;
+    UnresolvedStar unresolved_star = 5;
+    Alias alias = 6;
+    Cast cast = 7;
+    UnresolvedRegex unresolved_regex = 8;
+    SortOrder sort_order = 9;
+    LambdaFunction lambda_function = 10;
+    Window window = 11;
+    UnresolvedExtractValue unresolved_extract_value = 12;
+    UpdateFields update_fields = 13;
+    UnresolvedNamedLambdaVariable unresolved_named_lambda_variable = 14;
+    CommonInlineUserDefinedFunction common_inline_user_defined_function = 15;
+    CallFunction call_function = 16;
+
+    // This field is used to mark extensions to the protocol. When plugins
+    // generate arbitrary relations they can add them here. During the planning
+    // the correct resolution is done.
+    google.protobuf.Any extension = 999;
+  }
+
+  // Expression for the OVER clause or WINDOW clause.
+  message Window {
+    // (Required) The window function.
+    Expression window_function = 1;
+
+    // (Optional) The way that input rows are partitioned.
+    repeated Expression partition_spec = 2;
+
+    // (Optional) Ordering of rows in a partition.
+    repeated SortOrder order_spec = 3;
+
+    // (Optional) Window frame in a partition.
+    //
+    // If not set, it will be treated as 'UnspecifiedFrame'.
+    WindowFrame frame_spec = 4;
+
+    // The window frame
+    message WindowFrame {
+      // (Required) The type of the frame.
+      FrameType frame_type = 1;
+
+      // (Required) The lower bound of the frame.
+      FrameBoundary lower = 2;
+
+      // (Required) The upper bound of the frame.
+      FrameBoundary upper = 3;
+
+      enum FrameType {
+        FRAME_TYPE_UNDEFINED = 0;
+
+        // RowFrame treats rows in a partition individually.
+        FRAME_TYPE_ROW = 1;
+
+        // RangeFrame treats rows in a partition as groups of peers.
+        // All rows having the same 'ORDER BY' ordering are considered as peers.
+        FRAME_TYPE_RANGE = 2;
+      }
+
+      message FrameBoundary {
+        oneof boundary {
+          // CURRENT ROW boundary
+          bool current_row = 1;
+
+          // UNBOUNDED boundary.
+          // For lower bound, it will be converted to 'UnboundedPreceding'.
+          // for upper bound, it will be converted to 'UnboundedFollowing'.
+          bool unbounded = 2;
+
+          // This is an expression for future proofing. We are expecting
+          // literals on the server side.
+          Expression value = 3;
+        }
+      }
+    }
+  }
+
+  // SortOrder is used to specify the  data ordering, it is normally used in
+  // Sort and Window. It is an unevaluable expression and cannot be evaluated,
+  // so can not be used in Projection.
+  message SortOrder {
+    // (Required) The expression to be sorted.
+    Expression child = 1;
+
+    // (Required) The sort direction, should be ASCENDING or DESCENDING.
+    SortDirection direction = 2;
+
+    // (Required) How to deal with NULLs, should be NULLS_FIRST or NULLS_LAST.
+    NullOrdering null_ordering = 3;
+
+    enum SortDirection {
+      SORT_DIRECTION_UNSPECIFIED = 0;
+      SORT_DIRECTION_ASCENDING = 1;
+      SORT_DIRECTION_DESCENDING = 2;
+    }
+
+    enum NullOrdering {
+      SORT_NULLS_UNSPECIFIED = 0;
+      SORT_NULLS_FIRST = 1;
+      SORT_NULLS_LAST = 2;
+    }
+  }
+
+  message Cast {
+    // (Required) the expression to be casted.
+    Expression expr = 1;
+
+    // (Required) the data type that the expr to be casted to.
+    oneof cast_to_type {
+      DataType type = 2;
+      // If this is set, Server will use Catalyst parser to parse this string to
+      // DataType.
+      string type_str = 3;
+    }
+  }
+
+  message Literal {
+    oneof literal_type {
+      DataType null = 1;
+      bytes binary = 2;
+      bool boolean = 3;
+
+      int32 byte = 4;
+      int32 short = 5;
+      int32 integer = 6;
+      int64 long = 7;
+      float float = 10;
+      double double = 11;
+      Decimal decimal = 12;
+
+      string string = 13;
+
+      // Date in units of days since the UNIX epoch.
+      int32 date = 16;
+      // Timestamp in units of microseconds since the UNIX epoch.
+      int64 timestamp = 17;
+      // Timestamp in units of microseconds since the UNIX epoch (without
+      // timezone information).
+      int64 timestamp_ntz = 18;
+
+      CalendarInterval calendar_interval = 19;
+      int32 year_month_interval = 20;
+      int64 day_time_interval = 21;
+      Array array = 22;
+      Map map = 23;
+      Struct struct = 24;
+    }
+
+    message Decimal {
+      // the string representation.
+      string value = 1;
+      // The maximum number of digits allowed in the value.
+      // the maximum precision is 38.
+      optional int32 precision = 2;
+      // declared scale of decimal literal
+      optional int32 scale = 3;
+    }
+
+    message CalendarInterval {
+      int32 months = 1;
+      int32 days = 2;
+      int64 microseconds = 3;
+    }
+
+    message Array {
+      DataType element_type = 1;
+      repeated Literal elements = 2;
+    }
+
+    message Map {
+      DataType key_type = 1;
+      DataType value_type = 2;
+      repeated Literal keys = 3;
+      repeated Literal values = 4;
+    }
+
+    message Struct {
+      DataType struct_type = 1;
+      repeated Literal elements = 2;
+    }
+  }
+
+  // An unresolved attribute that is not explicitly bound to a specific column,
+  // but the column is resolved during analysis by name.
+  message UnresolvedAttribute {
+    // (Required) An identifier that will be parsed by Catalyst parser. This
+    // should follow the Spark SQL identifier syntax.
+    string unparsed_identifier = 1;
+
+    // (Optional) The id of corresponding connect plan.
+    optional int64 plan_id = 2;
+  }
+
+  // An unresolved function is not explicitly bound to one explicit function,
+  // but the function is resolved during analysis following Sparks name
+  // resolution rules.
+  message UnresolvedFunction {
+    // (Required) name (or unparsed name for user defined function) for the
+    // unresolved function.
+    string function_name = 1;
+
+    // (Optional) Function arguments. Empty arguments are allowed.
+    repeated Expression arguments = 2;
+
+    // (Required) Indicate if this function should be applied on distinct
+    // values.
+    bool is_distinct = 3;
+
+    // (Required) Indicate if this is a user defined function.
+    //
+    // When it is not a user defined function, Connect will use the function
+    // name directly. When it is a user defined function, Connect will parse the
+    // function name first.
+    bool is_user_defined_function = 4;
+  }
+
+  // Expression as string.
+  message ExpressionString {
+    // (Required) A SQL expression that will be parsed by Catalyst parser.
+    string expression = 1;
+  }
+
+  // UnresolvedStar is used to expand all the fields of a relation or struct.
+  message UnresolvedStar {
+    // (Optional) The target of the expansion.
+    //
+    // If set, it should end with '.*' and will be parsed by
+    // 'parseAttributeName' in the server side.
+    optional string unparsed_target = 1;
+  }
+
+  // Represents all of the input attributes to a given relational operator, for
+  // example in "SELECT `(id)?+.+` FROM ...".
+  message UnresolvedRegex {
+    // (Required) The column name used to extract column with regex.
+    string col_name = 1;
+
+    // (Optional) The id of corresponding connect plan.
+    optional int64 plan_id = 2;
+  }
+
+  // Extracts a value or values from an Expression
+  message UnresolvedExtractValue {
+    // (Required) The expression to extract value from, can be
+    // Map, Array, Struct or array of Structs.
+    Expression child = 1;
+
+    // (Required) The expression to describe the extraction, can be
+    // key of Map, index of Array, field name of Struct.
+    Expression extraction = 2;
+  }
+
+  // Add, replace or drop a field of `StructType` expression by name.
+  message UpdateFields {
+    // (Required) The struct expression.
+    Expression struct_expression = 1;
+
+    // (Required) The field name.
+    string field_name = 2;
+
+    // (Optional) The expression to add or replace.
+    //
+    // When not set, it means this field will be dropped.
+    Expression value_expression = 3;
+  }
+
+  message Alias {
+    // (Required) The expression that alias will be added on.
+    Expression expr = 1;
+
+    // (Required) a list of name parts for the alias.
+    //
+    // Scalar columns only has one name that presents.
+    repeated string name = 2;
+
+    // (Optional) Alias metadata expressed as a JSON map.
+    optional string metadata = 3;
+  }
+
+  message LambdaFunction {
+    // (Required) The lambda function.
+    //
+    // The function body should use 'UnresolvedAttribute' as arguments, the
+    // sever side will replace 'UnresolvedAttribute' with
+    // 'UnresolvedNamedLambdaVariable'.
+    Expression function = 1;
+
+    // (Required) Function variables. Must contains 1 ~ 3 variables.
+    repeated Expression.UnresolvedNamedLambdaVariable arguments = 2;
+  }
+
+  message UnresolvedNamedLambdaVariable {
+    // (Required) a list of name parts for the variable. Must not be empty.
+    repeated string name_parts = 1;
+  }
+}
+
+message CommonInlineUserDefinedFunction {
+  // (Required) Name of the user-defined function.
+  string function_name = 1;
+  // (Optional) Indicate if the user-defined function is deterministic.
+  bool deterministic = 2;
+  // (Optional) Function arguments. Empty arguments are allowed.
+  repeated Expression arguments = 3;
+  // (Required) Indicate the function type of the user-defined function.
+  oneof function {
+    PythonUDF python_udf = 4;
+    ScalarScalaUDF scalar_scala_udf = 5;
+    JavaUDF java_udf = 6;
+  }
+}
+
+message PythonUDF {
+  // (Required) Output type of the Python UDF
+  DataType output_type = 1;
+  // (Required) EvalType of the Python UDF
+  int32 eval_type = 2;
+  // (Required) The encoded commands of the Python UDF
+  bytes command = 3;
+  // (Required) Python version being used in the client.
+  string python_ver = 4;
+}
+
+message ScalarScalaUDF {
+  // (Required) Serialized JVM object containing UDF definition, input encoders
+  // and output encoder
+  bytes payload = 1;
+  // (Optional) Input type(s) of the UDF
+  repeated DataType inputTypes = 2;
+  // (Required) Output type of the UDF
+  DataType outputType = 3;
+  // (Required) True if the UDF can return null value
+  bool nullable = 4;
+}
+
+message JavaUDF {
+  // (Required) Fully qualified name of Java class
+  string class_name = 1;
+
+  // (Optional) Output type of the Java UDF
+  optional DataType output_type = 2;
+
+  // (Required) Indicate if the Java user-defined function is an aggregate
+  // function
+  bool aggregate = 3;
+}
+
+message CallFunction {
+  // (Required) Unparsed name of the SQL function.
+  string function_name = 1;
+
+  // (Optional) Function arguments. Empty arguments are allowed.
+  repeated Expression arguments = 2;
+}
diff --git a/velox/functions/sparksql/fuzzer/spark/connect/relations.proto b/velox/functions/sparksql/fuzzer/spark/connect/relations.proto
new file mode 100644
index 000000000000..e4da00599ffe
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/spark/connect/relations.proto
@@ -0,0 +1,1033 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE 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.
+ */
+
+syntax = 'proto3';
+
+package spark.connect;
+
+import "google/protobuf/any.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/expressions.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/types.proto";
+import "velox/functions/sparksql/fuzzer/spark/connect/catalog.proto";
+
+option java_multiple_files = true;
+option java_package = "org.apache.spark.connect.proto";
+option go_package = "internal/generated";
+
+// The main [[Relation]] type. Fundamentally, a relation is a typed container
+// that has exactly one explicit relation type set.
+//
+// When adding new relation types, they have to be registered here.
+message Relation {
+  RelationCommon common = 1;
+  oneof rel_type {
+    Read read = 2;
+    Project project = 3;
+    Filter filter = 4;
+    Join join = 5;
+    SetOperation set_op = 6;
+    Sort sort = 7;
+    Limit limit = 8;
+    Aggregate aggregate = 9;
+    SQL sql = 10;
+    LocalRelation local_relation = 11;
+    Sample sample = 12;
+    Offset offset = 13;
+    Deduplicate deduplicate = 14;
+    Range range = 15;
+    SubqueryAlias subquery_alias = 16;
+    Repartition repartition = 17;
+    ToDF to_df = 18;
+    WithColumnsRenamed with_columns_renamed = 19;
+    ShowString show_string = 20;
+    Drop drop = 21;
+    Tail tail = 22;
+    WithColumns with_columns = 23;
+    Hint hint = 24;
+    Unpivot unpivot = 25;
+    ToSchema to_schema = 26;
+    RepartitionByExpression repartition_by_expression = 27;
+    MapPartitions map_partitions = 28;
+    CollectMetrics collect_metrics = 29;
+    Parse parse = 30;
+    GroupMap group_map = 31;
+    CoGroupMap co_group_map = 32;
+    WithWatermark with_watermark = 33;
+    ApplyInPandasWithState apply_in_pandas_with_state = 34;
+    HtmlString html_string = 35;
+    CachedLocalRelation cached_local_relation = 36;
+    CachedRemoteRelation cached_remote_relation = 37;
+    CommonInlineUserDefinedTableFunction
+        common_inline_user_defined_table_function = 38;
+
+    // NA functions
+    NAFill fill_na = 90;
+    NADrop drop_na = 91;
+    NAReplace replace = 92;
+
+    // stat functions
+    StatSummary summary = 100;
+    StatCrosstab crosstab = 101;
+    StatDescribe describe = 102;
+    StatCov cov = 103;
+    StatCorr corr = 104;
+    StatApproxQuantile approx_quantile = 105;
+    StatFreqItems freq_items = 106;
+    StatSampleBy sample_by = 107;
+
+    // Catalog API (experimental / unstable)
+    Catalog catalog = 200;
+
+    // This field is used to mark extensions to the protocol. When plugins
+    // generate arbitrary relations they can add them here. During the planning
+    // the correct resolution is done.
+    google.protobuf.Any extension = 998;
+    Unknown unknown = 999;
+  }
+}
+
+// Used for testing purposes only.
+message Unknown {}
+
+// Common metadata of all relations.
+message RelationCommon {
+  // (Required) Shared relation metadata.
+  string source_info = 1;
+
+  // (Optional) A per-client globally unique id for a given connect plan.
+  optional int64 plan_id = 2;
+}
+
+// Relation that uses a SQL query to generate the output.
+message SQL {
+  // (Required) The SQL query.
+  string query = 1;
+
+  // (Optional) A map of parameter names to literal expressions.
+  map<string, Expression.Literal> args = 2;
+
+  // (Optional) A sequence of literal expressions for positional parameters in
+  // the SQL query text.
+  repeated Expression.Literal pos_args = 3;
+}
+
+// Relation that reads from a file / table or other data source. Does not have
+// additional inputs.
+message Read {
+  oneof read_type {
+    NamedTable named_table = 1;
+    DataSource data_source = 2;
+  }
+
+  // (Optional) Indicates if this is a streaming read.
+  bool is_streaming = 3;
+
+  message NamedTable {
+    // (Required) Unparsed identifier for the table.
+    string unparsed_identifier = 1;
+
+    // Options for the named table. The map key is case insensitive.
+    map<string, string> options = 2;
+  }
+
+  message DataSource {
+    // (Optional) Supported formats include: parquet, orc, text, json, parquet,
+    // csv, avro.
+    //
+    // If not set, the value from SQL conf 'spark.sql.sources.default' will be
+    // used.
+    optional string format = 1;
+
+    // (Optional) If not set, Spark will infer the schema.
+    //
+    // This schema string should be either DDL-formatted or JSON-formatted.
+    optional string schema = 2;
+
+    // Options for the data source. The context of this map varies based on the
+    // data source format. This options could be empty for valid data source
+    // format. The map key is case insensitive.
+    map<string, string> options = 3;
+
+    // (Optional) A list of path for file-system backed data sources.
+    repeated string paths = 4;
+
+    // (Optional) Condition in the where clause for each partition.
+    //
+    // This is only supported by the JDBC data source.
+    repeated string predicates = 5;
+  }
+}
+
+// Projection of a bag of expressions for a given input relation.
+//
+// The input relation must be specified.
+// The projected expression can be an arbitrary expression.
+message Project {
+  // (Optional) Input relation is optional for Project.
+  //
+  // For example, `SELECT ABS(-1)` is valid plan without an input plan.
+  Relation input = 1;
+
+  // (Required) A Project requires at least one expression.
+  repeated Expression expressions = 3;
+}
+
+// Relation that applies a boolean expression `condition` on each row of `input`
+// to produce the output result.
+message Filter {
+  // (Required) Input relation for a Filter.
+  Relation input = 1;
+
+  // (Required) A Filter must have a condition expression.
+  Expression condition = 2;
+}
+
+// Relation of type [[Join]].
+//
+// `left` and `right` must be present.
+message Join {
+  // (Required) Left input relation for a Join.
+  Relation left = 1;
+
+  // (Required) Right input relation for a Join.
+  Relation right = 2;
+
+  // (Optional) The join condition. Could be unset when `using_columns` is
+  // utilized.
+  //
+  // This field does not co-exist with using_columns.
+  Expression join_condition = 3;
+
+  // (Required) The join type.
+  JoinType join_type = 4;
+
+  // Optional. using_columns provides a list of columns that should present on
+  // both sides of the join inputs that this Join will join on. For example A
+  // JOIN B USING col_name is equivalent to A JOIN B on A.col_name = B.col_name.
+  //
+  // This field does not co-exist with join_condition.
+  repeated string using_columns = 5;
+
+  enum JoinType {
+    JOIN_TYPE_UNSPECIFIED = 0;
+    JOIN_TYPE_INNER = 1;
+    JOIN_TYPE_FULL_OUTER = 2;
+    JOIN_TYPE_LEFT_OUTER = 3;
+    JOIN_TYPE_RIGHT_OUTER = 4;
+    JOIN_TYPE_LEFT_ANTI = 5;
+    JOIN_TYPE_LEFT_SEMI = 6;
+    JOIN_TYPE_CROSS = 7;
+  }
+
+  // (Optional) Only used by joinWith. Set the left and right join data types.
+  optional JoinDataType join_data_type = 6;
+
+  message JoinDataType {
+    // If the left data type is a struct.
+    bool is_left_struct = 1;
+    // If the right data type is a struct.
+    bool is_right_struct = 2;
+  }
+}
+
+// Relation of type [[SetOperation]]
+message SetOperation {
+  // (Required) Left input relation for a Set operation.
+  Relation left_input = 1;
+
+  // (Required) Right input relation for a Set operation.
+  Relation right_input = 2;
+
+  // (Required) The Set operation type.
+  SetOpType set_op_type = 3;
+
+  // (Optional) If to remove duplicate rows.
+  //
+  // True to preserve all results.
+  // False to remove duplicate rows.
+  optional bool is_all = 4;
+
+  // (Optional) If to perform the Set operation based on name resolution.
+  //
+  // Only UNION supports this option.
+  optional bool by_name = 5;
+
+  // (Optional) If to perform the Set operation and allow missing columns.
+  //
+  // Only UNION supports this option.
+  optional bool allow_missing_columns = 6;
+
+  enum SetOpType {
+    SET_OP_TYPE_UNSPECIFIED = 0;
+    SET_OP_TYPE_INTERSECT = 1;
+    SET_OP_TYPE_UNION = 2;
+    SET_OP_TYPE_EXCEPT = 3;
+  }
+}
+
+// Relation of type [[Limit]] that is used to `limit` rows from the input
+// relation.
+message Limit {
+  // (Required) Input relation for a Limit.
+  Relation input = 1;
+
+  // (Required) the limit.
+  int32 limit = 2;
+}
+
+// Relation of type [[Offset]] that is used to read rows staring from the
+// `offset` on the input relation.
+message Offset {
+  // (Required) Input relation for an Offset.
+  Relation input = 1;
+
+  // (Required) the limit.
+  int32 offset = 2;
+}
+
+// Relation of type [[Tail]] that is used to fetch `limit` rows from the last of
+// the input relation.
+message Tail {
+  // (Required) Input relation for an Tail.
+  Relation input = 1;
+
+  // (Required) the limit.
+  int32 limit = 2;
+}
+
+// Relation of type [[Aggregate]].
+message Aggregate {
+  // (Required) Input relation for a RelationalGroupedDataset.
+  Relation input = 1;
+
+  // (Required) How the RelationalGroupedDataset was built.
+  GroupType group_type = 2;
+
+  // (Required) Expressions for grouping keys
+  repeated Expression grouping_expressions = 3;
+
+  // (Required) List of values that will be translated to columns in the output
+  // DataFrame.
+  repeated Expression aggregate_expressions = 4;
+
+  // (Optional) Pivots a column of the current `DataFrame` and performs the
+  // specified aggregation.
+  Pivot pivot = 5;
+
+  enum GroupType {
+    GROUP_TYPE_UNSPECIFIED = 0;
+    GROUP_TYPE_GROUPBY = 1;
+    GROUP_TYPE_ROLLUP = 2;
+    GROUP_TYPE_CUBE = 3;
+    GROUP_TYPE_PIVOT = 4;
+  }
+
+  message Pivot {
+    // (Required) The column to pivot
+    Expression col = 1;
+
+    // (Optional) List of values that will be translated to columns in the
+    // output DataFrame.
+    //
+    // Note that if it is empty, the server side will immediately trigger a job
+    // to collect the distinct values of the column.
+    repeated Expression.Literal values = 2;
+  }
+}
+
+// Relation of type [[Sort]].
+message Sort {
+  // (Required) Input relation for a Sort.
+  Relation input = 1;
+
+  // (Required) The ordering expressions
+  repeated Expression.SortOrder order = 2;
+
+  // (Optional) if this is a global sort.
+  optional bool is_global = 3;
+}
+
+// Drop specified columns.
+message Drop {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Optional) columns to drop.
+  repeated Expression columns = 2;
+
+  // (Optional) names of columns to drop.
+  repeated string column_names = 3;
+}
+
+// Relation of type [[Deduplicate]] which have duplicate rows removed, could
+// consider either only the subset of columns or all the columns.
+message Deduplicate {
+  // (Required) Input relation for a Deduplicate.
+  Relation input = 1;
+
+  // (Optional) Deduplicate based on a list of column names.
+  //
+  // This field does not co-use with `all_columns_as_keys`.
+  repeated string column_names = 2;
+
+  // (Optional) Deduplicate based on all the columns of the input relation.
+  //
+  // This field does not co-use with `column_names`.
+  optional bool all_columns_as_keys = 3;
+
+  // (Optional) Deduplicate within the time range of watermark.
+  optional bool within_watermark = 4;
+}
+
+// A relation that does not need to be qualified by name.
+message LocalRelation {
+  // (Optional) Local collection data serialized into Arrow IPC streaming format
+  // which contains the schema of the data.
+  optional bytes data = 1;
+
+  // (Optional) The schema of local data.
+  // It should be either a DDL-formatted type string or a JSON string.
+  //
+  // The server side will update the column names and data types according to
+  // this schema. If the 'data' is not provided, then this schema will be
+  // required.
+  optional string schema = 2;
+}
+
+// A local relation that has been cached already.
+message CachedLocalRelation {
+  // `userId` and `sessionId` fields are deleted since the server must always
+  // use the active session/user rather than arbitrary values provided by the
+  // client. It is never valid to access a local relation from a different
+  // session/user.
+  reserved 1, 2;
+  reserved "userId", "sessionId";
+
+  // (Required) A sha-256 hash of the serialized local relation in proto, see
+  // LocalRelation.
+  string hash = 3;
+}
+
+// Represents a remote relation that has been cached on server.
+message CachedRemoteRelation {
+  // (Required) ID of the remote related (assigned by the service).
+  string relation_id = 1;
+}
+
+// Relation of type [[Sample]] that samples a fraction of the dataset.
+message Sample {
+  // (Required) Input relation for a Sample.
+  Relation input = 1;
+
+  // (Required) lower bound.
+  double lower_bound = 2;
+
+  // (Required) upper bound.
+  double upper_bound = 3;
+
+  // (Optional) Whether to sample with replacement.
+  optional bool with_replacement = 4;
+
+  // (Optional) The random seed.
+  optional int64 seed = 5;
+
+  // (Required) Explicitly sort the underlying plan to make the ordering
+  // deterministic or cache it. This flag is true when invoking
+  // `dataframe.randomSplit` to randomly splits DataFrame with the provided
+  // weights. Otherwise, it is false.
+  bool deterministic_order = 6;
+}
+
+// Relation of type [[Range]] that generates a sequence of integers.
+message Range {
+  // (Optional) Default value = 0
+  optional int64 start = 1;
+
+  // (Required)
+  int64 end = 2;
+
+  // (Required)
+  int64 step = 3;
+
+  // Optional. Default value is assigned by 1) SQL conf
+  // "spark.sql.leafNodeDefaultParallelism" if it is set, or 2) spark default
+  // parallelism.
+  optional int32 num_partitions = 4;
+}
+
+// Relation alias.
+message SubqueryAlias {
+  // (Required) The input relation of SubqueryAlias.
+  Relation input = 1;
+
+  // (Required) The alias.
+  string alias = 2;
+
+  // (Optional) Qualifier of the alias.
+  repeated string qualifier = 3;
+}
+
+// Relation repartition.
+message Repartition {
+  // (Required) The input relation of Repartition.
+  Relation input = 1;
+
+  // (Required) Must be positive.
+  int32 num_partitions = 2;
+
+  // (Optional) Default value is false.
+  optional bool shuffle = 3;
+}
+
+// Compose the string representing rows for output.
+// It will invoke 'Dataset.showString' to compute the results.
+message ShowString {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) Number of rows to show.
+  int32 num_rows = 2;
+
+  // (Required) If set to more than 0, truncates strings to
+  // `truncate` characters and all cells will be aligned right.
+  int32 truncate = 3;
+
+  // (Required) If set to true, prints output rows vertically (one line per
+  // column value).
+  bool vertical = 4;
+}
+
+// Compose the string representing rows for output.
+// It will invoke 'Dataset.htmlString' to compute the results.
+message HtmlString {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) Number of rows to show.
+  int32 num_rows = 2;
+
+  // (Required) If set to more than 0, truncates strings to
+  // `truncate` characters and all cells will be aligned right.
+  int32 truncate = 3;
+}
+
+// Computes specified statistics for numeric and string columns.
+// It will invoke 'Dataset.summary' (same as 'StatFunctions.summary')
+// to compute the results.
+message StatSummary {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Optional) Statistics from to be computed.
+  //
+  // Available statistics are:
+  //  count
+  //  mean
+  //  stddev
+  //  min
+  //  max
+  //  arbitrary approximate percentiles specified as a percentage (e.g. 75%)
+  //  count_distinct
+  //  approx_count_distinct
+  //
+  // If no statistics are given, this function computes 'count', 'mean',
+  // 'stddev', 'min', 'approximate quartiles' (percentiles at 25%, 50%, and
+  // 75%), and 'max'.
+  repeated string statistics = 2;
+}
+
+// Computes basic statistics for numeric and string columns, including count,
+// mean, stddev, min, and max. If no columns are given, this function computes
+// statistics for all numerical or string columns.
+message StatDescribe {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Optional) Columns to compute statistics on.
+  repeated string cols = 2;
+}
+
+// Computes a pair-wise frequency table of the given columns. Also known as a
+// contingency table. It will invoke 'Dataset.stat.crosstab' (same as
+// 'StatFunctions.crossTabulate') to compute the results.
+message StatCrosstab {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) The name of the first column.
+  //
+  // Distinct items will make the first item of each row.
+  string col1 = 2;
+
+  // (Required) The name of the second column.
+  //
+  // Distinct items will make the column names of the DataFrame.
+  string col2 = 3;
+}
+
+// Calculate the sample covariance of two numerical columns of a DataFrame.
+// It will invoke 'Dataset.stat.cov' (same as 'StatFunctions.calculateCov') to
+// compute the results.
+message StatCov {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) The name of the first column.
+  string col1 = 2;
+
+  // (Required) The name of the second column.
+  string col2 = 3;
+}
+
+// Calculates the correlation of two columns of a DataFrame. Currently only
+// supports the Pearson Correlation Coefficient. It will invoke
+// 'Dataset.stat.corr' (same as 'StatFunctions.pearsonCorrelation') to compute
+// the results.
+message StatCorr {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) The name of the first column.
+  string col1 = 2;
+
+  // (Required) The name of the second column.
+  string col2 = 3;
+
+  // (Optional) Default value is 'pearson'.
+  //
+  // Currently only supports the Pearson Correlation Coefficient.
+  optional string method = 4;
+}
+
+// Calculates the approximate quantiles of numerical columns of a DataFrame.
+// It will invoke 'Dataset.stat.approxQuantile' (same as
+// 'StatFunctions.approxQuantile') to compute the results.
+message StatApproxQuantile {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) The names of the numerical columns.
+  repeated string cols = 2;
+
+  // (Required) A list of quantile probabilities.
+  //
+  // Each number must belong to [0, 1].
+  // For example 0 is the minimum, 0.5 is the median, 1 is the maximum.
+  repeated double probabilities = 3;
+
+  // (Required) The relative target precision to achieve (greater than or equal
+  // to 0).
+  //
+  // If set to zero, the exact quantiles are computed, which could be very
+  // expensive. Note that values greater than 1 are accepted but give the same
+  // result as 1.
+  double relative_error = 4;
+}
+
+// Finding frequent items for columns, possibly with false positives.
+// It will invoke 'Dataset.stat.freqItems' (same as 'StatFunctions.freqItems')
+// to compute the results.
+message StatFreqItems {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) The names of the columns to search frequent items in.
+  repeated string cols = 2;
+
+  // (Optional) The minimum frequency for an item to be considered `frequent`.
+  // Should be greater than 1e-4.
+  optional double support = 3;
+}
+
+// Returns a stratified sample without replacement based on the fraction
+// given on each stratum.
+// It will invoke 'Dataset.stat.freqItems' (same as 'StatFunctions.freqItems')
+// to compute the results.
+message StatSampleBy {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) The column that defines strata.
+  Expression col = 2;
+
+  // (Required) Sampling fraction for each stratum.
+  //
+  // If a stratum is not specified, we treat its fraction as zero.
+  repeated Fraction fractions = 3;
+
+  // (Optional) The random seed.
+  optional int64 seed = 5;
+
+  message Fraction {
+    // (Required) The stratum.
+    Expression.Literal stratum = 1;
+
+    // (Required) The fraction value. Must be in [0, 1].
+    double fraction = 2;
+  }
+}
+
+// Replaces null values.
+// It will invoke 'Dataset.na.fill' (same as 'DataFrameNaFunctions.fill') to
+// compute the results. Following 3 parameter combinations are supported:
+//  1, 'values' only contains 1 item, 'cols' is empty:
+//    replaces null values in all type-compatible columns.
+//  2, 'values' only contains 1 item, 'cols' is not empty:
+//    replaces null values in specified columns.
+//  3, 'values' contains more than 1 items, then 'cols' is required to have the
+//  same length:
+//    replaces each specified column with corresponding value.
+message NAFill {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Optional) Optional list of column names to consider.
+  repeated string cols = 2;
+
+  // (Required) Values to replace null values with.
+  //
+  // Should contain at least 1 item.
+  // Only 4 data types are supported now: bool, long, double, string
+  repeated Expression.Literal values = 3;
+}
+
+// Drop rows containing null values.
+// It will invoke 'Dataset.na.drop' (same as 'DataFrameNaFunctions.drop') to
+// compute the results.
+message NADrop {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Optional) Optional list of column names to consider.
+  //
+  // When it is empty, all the columns in the input relation will be considered.
+  repeated string cols = 2;
+
+  // (Optional) The minimum number of non-null and non-NaN values required to
+  // keep.
+  //
+  // When not set, it is equivalent to the number of considered columns, which
+  // means a row will be kept only if all columns are non-null.
+  //
+  // 'how' options ('all', 'any') can be easily converted to this field:
+  //   - 'all' -> set 'min_non_nulls' 1;
+  //   - 'any' -> keep 'min_non_nulls' unset;
+  optional int32 min_non_nulls = 3;
+}
+
+// Replaces old values with the corresponding values.
+// It will invoke 'Dataset.na.replace' (same as 'DataFrameNaFunctions.replace')
+// to compute the results.
+message NAReplace {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Optional) List of column names to consider.
+  //
+  // When it is empty, all the type-compatible columns in the input relation
+  // will be considered.
+  repeated string cols = 2;
+
+  // (Optional) The value replacement mapping.
+  repeated Replacement replacements = 3;
+
+  message Replacement {
+    // (Required) The old value.
+    //
+    // Only 4 data types are supported now: null, bool, double, string.
+    Expression.Literal old_value = 1;
+
+    // (Required) The new value.
+    //
+    // Should be of the same data type with the old value.
+    Expression.Literal new_value = 2;
+  }
+}
+
+// Rename columns on the input relation by the same length of names.
+message ToDF {
+  // (Required) The input relation of RenameColumnsBySameLengthNames.
+  Relation input = 1;
+
+  // (Required)
+  //
+  // The number of columns of the input relation must be equal to the length
+  // of this field. If this is not true, an exception will be returned.
+  repeated string column_names = 2;
+}
+
+// Rename columns on the input relation by a map with name to name mapping.
+message WithColumnsRenamed {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required)
+  //
+  // Renaming column names of input relation from A to B where A is the map key
+  // and B is the map value. This is a no-op if schema doesn't contain any A. It
+  // does not require that all input relation column names to present as keys.
+  // duplicated B are not allowed.
+  map<string, string> rename_columns_map = 2;
+}
+
+// Adding columns or replacing the existing columns that have the same names.
+message WithColumns {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required)
+  //
+  // Given a column name, apply the corresponding expression on the column. If
+  // column name exists in the input relation, then replace the column. If the
+  // column name does not exist in the input relation, then adds it as a new
+  // column.
+  //
+  // Only one name part is expected from each Expression.Alias.
+  //
+  // An exception is thrown when duplicated names are present in the mapping.
+  repeated Expression.Alias aliases = 2;
+}
+
+message WithWatermark {
+  // (Required) The input relation
+  Relation input = 1;
+
+  // (Required) Name of the column containing event time.
+  string event_time = 2;
+
+  // (Required)
+  string delay_threshold = 3;
+}
+
+// Specify a hint over a relation. Hint should have a name and optional
+// parameters.
+message Hint {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) Hint name.
+  //
+  // Supported Join hints include BROADCAST, MERGE, SHUFFLE_HASH,
+  // SHUFFLE_REPLICATE_NL.
+  //
+  // Supported partitioning hints include COALESCE, REPARTITION,
+  // REPARTITION_BY_RANGE.
+  string name = 2;
+
+  // (Optional) Hint parameters.
+  repeated Expression parameters = 3;
+}
+
+// Unpivot a DataFrame from wide format to long format, optionally leaving
+// identifier columns set.
+message Unpivot {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) Id columns.
+  repeated Expression ids = 2;
+
+  // (Optional) Value columns to unpivot.
+  optional Values values = 3;
+
+  // (Required) Name of the variable column.
+  string variable_column_name = 4;
+
+  // (Required) Name of the value column.
+  string value_column_name = 5;
+
+  message Values {
+    repeated Expression values = 1;
+  }
+}
+
+message ToSchema {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) The user provided schema.
+  //
+  // The Sever side will update the dataframe with this schema.
+  DataType schema = 2;
+}
+
+message RepartitionByExpression {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) The partitioning expressions.
+  repeated Expression partition_exprs = 2;
+
+  // (Optional) number of partitions, must be positive.
+  optional int32 num_partitions = 3;
+}
+
+message MapPartitions {
+  // (Required) Input relation for a mapPartitions-equivalent API: mapInPandas,
+  // mapInArrow.
+  Relation input = 1;
+
+  // (Required) Input user-defined function.
+  CommonInlineUserDefinedFunction func = 2;
+
+  // (Optional) Whether to use barrier mode execution or not.
+  optional bool is_barrier = 3;
+}
+
+message GroupMap {
+  // (Required) Input relation for Group Map API: apply, applyInPandas.
+  Relation input = 1;
+
+  // (Required) Expressions for grouping keys.
+  repeated Expression grouping_expressions = 2;
+
+  // (Required) Input user-defined function.
+  CommonInlineUserDefinedFunction func = 3;
+
+  // (Optional) Expressions for sorting. Only used by Scala Sorted Group Map
+  // API.
+  repeated Expression sorting_expressions = 4;
+
+  // Below fields are only used by (Flat)MapGroupsWithState
+  // (Optional) Input relation for initial State.
+  Relation initial_input = 5;
+
+  // (Optional) Expressions for grouping keys of the initial state input
+  // relation.
+  repeated Expression initial_grouping_expressions = 6;
+
+  // (Optional) True if MapGroupsWithState, false if FlatMapGroupsWithState.
+  optional bool is_map_groups_with_state = 7;
+
+  // (Optional) The output mode of the function.
+  optional string output_mode = 8;
+
+  // (Optional) Timeout configuration for groups that do not receive data for a
+  // while.
+  optional string timeout_conf = 9;
+}
+
+message CoGroupMap {
+  // (Required) One input relation for CoGroup Map API - applyInPandas.
+  Relation input = 1;
+
+  // Expressions for grouping keys of the first input relation.
+  repeated Expression input_grouping_expressions = 2;
+
+  // (Required) The other input relation.
+  Relation other = 3;
+
+  // Expressions for grouping keys of the other input relation.
+  repeated Expression other_grouping_expressions = 4;
+
+  // (Required) Input user-defined function.
+  CommonInlineUserDefinedFunction func = 5;
+
+  // (Optional) Expressions for sorting. Only used by Scala Sorted CoGroup Map
+  // API.
+  repeated Expression input_sorting_expressions = 6;
+
+  // (Optional) Expressions for sorting. Only used by Scala Sorted CoGroup Map
+  // API.
+  repeated Expression other_sorting_expressions = 7;
+}
+
+message ApplyInPandasWithState {
+  // (Required) Input relation for applyInPandasWithState.
+  Relation input = 1;
+
+  // (Required) Expressions for grouping keys.
+  repeated Expression grouping_expressions = 2;
+
+  // (Required) Input user-defined function.
+  CommonInlineUserDefinedFunction func = 3;
+
+  // (Required) Schema for the output DataFrame.
+  string output_schema = 4;
+
+  // (Required) Schema for the state.
+  string state_schema = 5;
+
+  // (Required) The output mode of the function.
+  string output_mode = 6;
+
+  // (Required) Timeout configuration for groups that do not receive data for a
+  // while.
+  string timeout_conf = 7;
+}
+
+message CommonInlineUserDefinedTableFunction {
+  // (Required) Name of the user-defined table function.
+  string function_name = 1;
+
+  // (Optional) Whether the user-defined table function is deterministic.
+  bool deterministic = 2;
+
+  // (Optional) Function input arguments. Empty arguments are allowed.
+  repeated Expression arguments = 3;
+
+  // (Required) Type of the user-defined table function.
+  oneof function {
+    PythonUDTF python_udtf = 4;
+  }
+}
+
+message PythonUDTF {
+  // (Optional) Return type of the Python UDTF.
+  optional DataType return_type = 1;
+
+  // (Required) EvalType of the Python UDTF.
+  int32 eval_type = 2;
+
+  // (Required) The encoded commands of the Python UDTF.
+  bytes command = 3;
+
+  // (Required) Python version being used in the client.
+  string python_ver = 4;
+}
+
+// Collect arbitrary (named) metrics from a dataset.
+message CollectMetrics {
+  // (Required) The input relation.
+  Relation input = 1;
+
+  // (Required) Name of the metrics.
+  string name = 2;
+
+  // (Required) The metric sequence.
+  repeated Expression metrics = 3;
+}
+
+message Parse {
+  // (Required) Input relation to Parse. The input is expected to have single
+  // text column.
+  Relation input = 1;
+  // (Required) The expected format of the text.
+  ParseFormat format = 2;
+
+  // (Optional) DataType representing the schema. If not set, Spark will infer
+  // the schema.
+  optional DataType schema = 3;
+
+  // Options for the csv/json parser. The map key is case insensitive.
+  map<string, string> options = 4;
+  enum ParseFormat {
+    PARSE_FORMAT_UNSPECIFIED = 0;
+    PARSE_FORMAT_CSV = 1;
+    PARSE_FORMAT_JSON = 2;
+  }
+}
diff --git a/velox/functions/sparksql/fuzzer/spark/connect/types.proto b/velox/functions/sparksql/fuzzer/spark/connect/types.proto
new file mode 100644
index 000000000000..351706322e2a
--- /dev/null
+++ b/velox/functions/sparksql/fuzzer/spark/connect/types.proto
@@ -0,0 +1,195 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE 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.
+ */
+
+syntax = 'proto3';
+
+package spark.connect;
+
+option java_multiple_files = true;
+option java_package = "org.apache.spark.connect.proto";
+option go_package = "internal/generated";
+
+// This message describes the logical [[DataType]] of something. It does not
+// carry the value itself but only describes it.
+message DataType {
+  oneof kind {
+    NULL null = 1;
+
+    Binary binary = 2;
+
+    Boolean boolean = 3;
+
+    // Numeric types
+    Byte byte = 4;
+    Short short = 5;
+    Integer integer = 6;
+    Long long = 7;
+
+    Float float = 8;
+    Double double = 9;
+    Decimal decimal = 10;
+
+    // String types
+    String string = 11;
+    Char char = 12;
+    VarChar var_char = 13;
+
+    // Datatime types
+    Date date = 14;
+    Timestamp timestamp = 15;
+    TimestampNTZ timestamp_ntz = 16;
+
+    // Interval types
+    CalendarInterval calendar_interval = 17;
+    YearMonthInterval year_month_interval = 18;
+    DayTimeInterval day_time_interval = 19;
+
+    // Complex types
+    Array array = 20;
+    Struct struct = 21;
+    Map map = 22;
+
+    // UserDefinedType
+    UDT udt = 23;
+
+    // UnparsedDataType
+    Unparsed unparsed = 24;
+  }
+
+  message Boolean {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Byte {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Short {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Integer {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Long {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Float {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Double {
+    uint32 type_variation_reference = 1;
+  }
+
+  message String {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Binary {
+    uint32 type_variation_reference = 1;
+  }
+
+  message NULL {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Timestamp {
+    uint32 type_variation_reference = 1;
+  }
+
+  message Date {
+    uint32 type_variation_reference = 1;
+  }
+
+  message TimestampNTZ {
+    uint32 type_variation_reference = 1;
+  }
+
+  message CalendarInterval {
+    uint32 type_variation_reference = 1;
+  }
+
+  message YearMonthInterval {
+    optional int32 start_field = 1;
+    optional int32 end_field = 2;
+    uint32 type_variation_reference = 3;
+  }
+
+  message DayTimeInterval {
+    optional int32 start_field = 1;
+    optional int32 end_field = 2;
+    uint32 type_variation_reference = 3;
+  }
+
+  // Start compound types.
+  message Char {
+    int32 length = 1;
+    uint32 type_variation_reference = 2;
+  }
+
+  message VarChar {
+    int32 length = 1;
+    uint32 type_variation_reference = 2;
+  }
+
+  message Decimal {
+    optional int32 scale = 1;
+    optional int32 precision = 2;
+    uint32 type_variation_reference = 3;
+  }
+
+  message StructField {
+    string name = 1;
+    DataType data_type = 2;
+    bool nullable = 3;
+    optional string metadata = 4;
+  }
+
+  message Struct {
+    repeated StructField fields = 1;
+    uint32 type_variation_reference = 2;
+  }
+
+  message Array {
+    DataType element_type = 1;
+    bool contains_null = 2;
+    uint32 type_variation_reference = 3;
+  }
+
+  message Map {
+    DataType key_type = 1;
+    DataType value_type = 2;
+    bool value_contains_null = 3;
+    uint32 type_variation_reference = 4;
+  }
+
+  message UDT {
+    string type = 1;
+    optional string jvm_class = 2;
+    optional string python_class = 3;
+    optional string serialized_python_class = 4;
+    DataType sql_type = 5;
+  }
+
+  message Unparsed {
+    // (Required) The unparsed data type string
+    string data_type_string = 1;
+  }
+}
diff --git a/velox/functions/sparksql/fuzzer/tests/CMakeLists.txt b/velox/functions/sparksql/fuzzer/tests/CMakeLists.txt
index 5d186ed5c09f..c25e62feac7a 100644
--- a/velox/functions/sparksql/fuzzer/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/fuzzer/tests/CMakeLists.txt
@@ -17,7 +17,8 @@ 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})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_spark_query_runner_test
@@ -31,4 +32,5 @@ target_link_libraries(
     velox_vector_test_lib
     GTest::gtest
     GTest::gtest_main
-    Folly::folly)
+    Folly::folly
+)
diff --git a/velox/functions/sparksql/fuzzer/tests/SparkQueryRunnerTest.cpp b/velox/functions/sparksql/fuzzer/tests/SparkQueryRunnerTest.cpp
index bcf8000e9764..a409b46e43e3 100644
--- a/velox/functions/sparksql/fuzzer/tests/SparkQueryRunnerTest.cpp
+++ b/velox/functions/sparksql/fuzzer/tests/SparkQueryRunnerTest.cpp
@@ -21,6 +21,7 @@
 #include "velox/dwio/parquet/RegisterParquetWriter.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/sparksql/aggregates/Register.h"
 #include "velox/functions/sparksql/fuzzer/SparkQueryRunner.h"
 #include "velox/functions/sparksql/registration/Register.h"
@@ -44,6 +45,7 @@ class SparkQueryRunnerTest : public ::testing::Test,
 
   void SetUp() override {
     velox::functions::sparksql::registerFunctions("");
+    velox::aggregate::prestosql::registerAllAggregateFunctions();
     velox::functions::aggregate::sparksql::registerAggregateFunctions("");
     velox::parse::registerTypeResolver();
   }
@@ -59,13 +61,16 @@ TEST_F(SparkQueryRunnerTest, DISABLED_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 plan = exec::test::PlanBuilder()
+                  .values({input})
+                  .singleAggregation({}, {"count(c0)"})
+                  .planNode();
+  auto sparkResults = queryRunner->executeAndReturnVector(plan);
   auto expected = makeRowVector({
       makeConstant<int64_t>(25, 1),
   });
-  exec::test::assertEqualResults(sparkResults, outputType, {expected});
+  ASSERT_EQ(sparkResults.second, exec::test::ReferenceQueryErrorCode::kSuccess);
+  exec::test::assertEqualResults(sparkResults.first.value(), {expected});
 
   input = makeRowVector({
       makeFlatVector<int64_t>({0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2,
@@ -73,14 +78,17 @@ TEST_F(SparkQueryRunnerTest, DISABLED_basic) {
       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);
+  plan = exec::test::PlanBuilder()
+             .values({input})
+             .singleAggregation({"c0"}, {"count(c1)"})
+             .planNode();
+  sparkResults = queryRunner->executeAndReturnVector(plan);
   expected = makeRowVector({
       makeFlatVector<int64_t>({0, 1, 2, 3, 4}),
       makeFlatVector<int64_t>({5, 5, 5, 5, 5}),
   });
-  exec::test::assertEqualResults(sparkResults, outputType, {expected});
+  ASSERT_EQ(sparkResults.second, exec::test::ReferenceQueryErrorCode::kSuccess);
+  exec::test::assertEqualResults(sparkResults.first.value(), {expected});
 }
 
 // This test requires a Spark coordinator running at localhost, so disable it
@@ -92,10 +100,11 @@ TEST_F(SparkQueryRunnerTest, DISABLED_decimal) {
   auto input = makeRowVector({
       makeConstant<int128_t>(123456789, 25, DECIMAL(34, 2)),
   });
-  auto outputType = ROW({"a"}, {DECIMAL(34, 2)});
-  auto sparkResults =
-      queryRunner->execute("SELECT abs(c0) FROM tmp", {input}, outputType);
-  exec::test::assertEqualResults(sparkResults, outputType, {input});
+  auto plan =
+      exec::test::PlanBuilder().values({input}).project({"abs(c0)"}).planNode();
+  auto sparkResults = queryRunner->executeAndReturnVector(plan);
+  ASSERT_EQ(sparkResults.second, exec::test::ReferenceQueryErrorCode::kSuccess);
+  exec::test::assertEqualResults(sparkResults.first.value(), {input});
 }
 
 // This test requires a Spark coordinator running at localhost, so disable it
@@ -118,12 +127,9 @@ TEST_F(SparkQueryRunnerTest, DISABLED_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 sparkResults = queryRunner->executeAndReturnVector(plan);
   auto veloxResults = exec::test::AssertQueryBuilder(plan).copyResults(pool());
-  exec::test::assertEqualResults(
-      sparkResults, plan->outputType(), {veloxResults});
+  exec::test::assertEqualResults(sparkResults.first.value(), {veloxResults});
 }
 
 TEST_F(SparkQueryRunnerTest, toSql) {
@@ -138,7 +144,7 @@ TEST_F(SparkQueryRunnerTest, toSql) {
                   .planNode();
   EXPECT_EQ(
       queryRunner->toSql(plan),
-      "SELECT c1, avg(c0) as a0 FROM tmp GROUP BY c1");
+      "SELECT c1, avg(c0) as a0 FROM (tmp) GROUP BY c1");
 
   plan = exec::test::PlanBuilder()
              .tableScan("tmp", dataType)
@@ -147,7 +153,7 @@ TEST_F(SparkQueryRunnerTest, toSql) {
              .planNode();
   EXPECT_EQ(
       queryRunner->toSql(plan),
-      "SELECT (a0 / c1) as p0 FROM (SELECT c1, sum(c0) as a0 FROM tmp GROUP BY c1)");
+      "SELECT (a0 / c1) as p0 FROM (SELECT c1, sum(c0) as a0 FROM (tmp) GROUP BY c1)");
 
   plan = exec::test::PlanBuilder()
              .tableScan("tmp", dataType)
@@ -155,7 +161,7 @@ TEST_F(SparkQueryRunnerTest, toSql) {
              .planNode();
   EXPECT_EQ(
       queryRunner->toSql(plan),
-      "SELECT avg(c0) filter (where c2) as a0, avg(c1) as a1 FROM tmp");
+      "SELECT avg(c0) filter (where c2) as a0, avg(c1) as a1 FROM (tmp)");
 
   auto data =
       makeRowVector({makeFlatVector<int64_t>({}), makeFlatVector<int64_t>({})});
@@ -163,7 +169,8 @@ TEST_F(SparkQueryRunnerTest, toSql) {
              .values({data})
              .singleAggregation({}, {"sum(distinct c0)"})
              .planNode();
-  EXPECT_EQ(queryRunner->toSql(plan), "SELECT sum(distinct c0) as a0 FROM tmp");
+  EXPECT_EQ(
+      queryRunner->toSql(plan), "SELECT sum(distinct c0) as a0 FROM (t_0)");
 }
 
 } // namespace
diff --git a/velox/functions/sparksql/registration/CMakeLists.txt b/velox/functions/sparksql/registration/CMakeLists.txt
index c7ca8ed7c18f..93d15ce84a9c 100644
--- a/velox/functions/sparksql/registration/CMakeLists.txt
+++ b/velox/functions/sparksql/registration/CMakeLists.txt
@@ -27,20 +27,23 @@ velox_add_library(
   RegisterRegexp.cpp
   RegisterSpecialForm.cpp
   RegisterString.cpp
-  RegisterUrl.cpp)
+  RegisterUrl.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" AND NOT VELOX_MONO_LIBRARY)
-  target_compile_options(velox_functions_spark
-                         PRIVATE -Wno-deprecated-declarations)
+  target_compile_options(velox_functions_spark PRIVATE -Wno-deprecated-declarations)
 endif()
 
-velox_link_libraries(velox_functions_spark velox_functions_spark_impl
-                     velox_is_null_functions simdjson::simdjson)
+velox_link_libraries(
+  velox_functions_spark
+  velox_functions_spark_impl
+  velox_is_null_functions
+  simdjson::simdjson
+)
 
 if(NOT VELOX_MONO_LIBRARY)
-  set_property(TARGET velox_functions_spark PROPERTY JOB_POOL_COMPILE
-                                                     high_memory_pool)
+  set_property(TARGET velox_functions_spark PROPERTY JOB_POOL_COMPILE high_memory_pool)
 endif()
diff --git a/velox/functions/sparksql/registration/RegisterArray.cpp b/velox/functions/sparksql/registration/RegisterArray.cpp
index ed4863e01263..9706ffc39f85 100644
--- a/velox/functions/sparksql/registration/RegisterArray.cpp
+++ b/velox/functions/sparksql/registration/RegisterArray.cpp
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "velox/expression/ExprRewriteRegistry.h"
 #include "velox/functions/lib/ArrayRemoveNullFunction.h"
 #include "velox/functions/lib/ArrayShuffle.h"
 #include "velox/functions/lib/RegistrationHelpers.h"
@@ -26,6 +27,7 @@
 #include "velox/functions/sparksql/ArrayMinMaxFunction.h"
 #include "velox/functions/sparksql/ArrayPrepend.h"
 #include "velox/functions/sparksql/ArraySort.h"
+#include "velox/functions/sparksql/SimpleComparisonMatcher.h"
 
 namespace facebook::velox::functions {
 
@@ -216,9 +218,17 @@ void registerArrayFunctions(const std::string& prefix) {
   registerSparkArrayFunctions(prefix);
   // Register array sort functions.
   exec::registerStatefulVectorFunction(
-      prefix + "array_sort", arraySortSignatures(), makeArraySort);
+      prefix + "array_sort", arraySortSignatures(true), makeArraySortAsc);
+  exec::registerStatefulVectorFunction(
+      prefix + "array_sort_desc", arraySortDescSignatures(), makeArraySortDesc);
   exec::registerStatefulVectorFunction(
       prefix + "sort_array", sortArraySignatures(), makeSortArray);
+
+  auto checker = std::make_shared<SparkSimpleComparisonChecker>();
+  expression::ExprRewriteRegistry::instance().registerRewrite(
+      [prefix, checker](const auto& expr) {
+        return rewriteArraySortCall(prefix, expr, checker);
+      });
   exec::registerStatefulVectorFunction(
       prefix + "array_repeat",
       repeatSignatures(),
diff --git a/velox/functions/sparksql/registration/RegisterDatetime.cpp b/velox/functions/sparksql/registration/RegisterDatetime.cpp
index 0625ae202544..fdbbc2d073ca 100644
--- a/velox/functions/sparksql/registration/RegisterDatetime.cpp
+++ b/velox/functions/sparksql/registration/RegisterDatetime.cpp
@@ -56,7 +56,7 @@ void registerDatetimeFunctions(const std::string& prefix) {
   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<FormatDateTimeFunction, Varchar, Timestamp, Varchar>(
+  registerFunction<DateFormatFunction, Varchar, Timestamp, Varchar>(
       {prefix + "date_format"});
   registerFunction<DateFromUnixDateFunction, Date, int32_t>(
       {prefix + "date_from_unix_date"});
@@ -65,8 +65,7 @@ void registerDatetimeFunctions(const std::string& prefix) {
   registerFunction<DateSubFunction, Date, Date, int32_t>({prefix + "date_sub"});
   registerFunction<DayFunction, int32_t, Date>(
       {prefix + "day", prefix + "dayofmonth"});
-  registerFunction<DayOfYearFunction, int32_t, Date>(
-      {prefix + "doy", prefix + "dayofyear"});
+  registerFunction<DayOfYearFunction, int32_t, Date>({prefix + "dayofyear"});
   registerFunction<DayOfWeekFunction, int32_t, Date>({prefix + "dayofweek"});
   registerFunction<WeekdayFunction, int32_t, Date>({prefix + "weekday"});
   registerFunction<QuarterFunction, int32_t, Date>({prefix + "quarter"});
@@ -92,8 +91,33 @@ void registerDatetimeFunctions(const std::string& prefix) {
       {prefix + "unix_millis"});
   registerUnaryIntegralWithTReturn<MillisToTimestampFunction, Timestamp>(
       {prefix + "timestamp_millis"});
+  registerUnaryIntegralWithTReturn<SecondsToTimestampFunction, Timestamp>(
+      {prefix + "timestamp_seconds"});
+  registerUnaryFloatingPointWithTReturn<SecondsToTimestampFunction, Timestamp>(
+      {prefix + "timestamp_seconds"});
   registerFunction<DateTruncFunction, Timestamp, Varchar, Timestamp>(
       {prefix + "date_trunc"});
+  registerFunction<TruncFunction, Date, Date, Varchar>({prefix + "trunc"});
+  registerFunction<
+      TimestampDiffFunction,
+      int64_t,
+      Varchar,
+      Timestamp,
+      Timestamp>({prefix + "timestampdiff"});
+  registerFunction<
+      TimestampAddFunction,
+      Timestamp,
+      Varchar,
+      int32_t,
+      Timestamp>({prefix + "timestampadd"});
+  registerFunction<
+      TimestampAddFunction,
+      Timestamp,
+      Varchar,
+      int64_t,
+      Timestamp>({prefix + "timestampadd"});
+  registerFunction<MonthsBetweenFunction, double, Timestamp, Timestamp, bool>(
+      {prefix + "months_between"});
 }
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/registration/RegisterJson.cpp b/velox/functions/sparksql/registration/RegisterJson.cpp
index 93df64818d3d..8e7305952921 100644
--- a/velox/functions/sparksql/registration/RegisterJson.cpp
+++ b/velox/functions/sparksql/registration/RegisterJson.cpp
@@ -18,6 +18,7 @@
 #include "velox/functions/prestosql/JsonFunctions.h"
 #include "velox/functions/sparksql/GetJsonObject.h"
 #include "velox/functions/sparksql/JsonObjectKeys.h"
+#include "velox/functions/sparksql/ToJson.h"
 
 namespace facebook::velox::functions::sparksql {
 
@@ -28,6 +29,9 @@ void registerJsonFunctions(const std::string& prefix) {
       {prefix + "json_object_keys"});
   registerFunction<JsonArrayLengthFunction, int32_t, Varchar>(
       {prefix + "json_array_length"});
+  registerFunction<ToJsonFunction, Varchar, Generic<T1>>({prefix + "to_json"});
+  registerFunction<ToJsonFunction, Varchar, Generic<T1>, Varchar>(
+      {prefix + "to_json"});
 }
 
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/registration/RegisterMath.cpp b/velox/functions/sparksql/registration/RegisterMath.cpp
index 376e67b8f3ed..0575a7aaa265 100644
--- a/velox/functions/sparksql/registration/RegisterMath.cpp
+++ b/velox/functions/sparksql/registration/RegisterMath.cpp
@@ -25,7 +25,7 @@
 namespace facebook::velox::functions::sparksql {
 
 void registerMathFunctions(const std::string& prefix) {
-  registerUnaryNumeric<AbsFunction>({prefix + "abs"});
+  registerUnaryNumeric<sparksql::AbsFunction>({prefix + "abs"});
   registerFunction<
       DecimalAbsFunction,
       LongDecimal<P1, S1>,
@@ -86,6 +86,7 @@ void registerMathFunctions(const std::string& prefix) {
   registerFunction<sparksql::LogarithmFunction, double, double, double>(
       {prefix + "log"});
   registerFunction<SqrtFunction, double, double>({prefix + "sqrt"});
+  registerFunction<CbrtFunction, double, double>({prefix + "cbrt"});
   registerFunction<
       WidthBucketFunction,
       int64_t,
@@ -106,6 +107,8 @@ void registerMathFunctions(const std::string& prefix) {
   registerBinaryNumeric<MultiplyFunction>({prefix + "multiply"});
   registerFunction<DivideFunction, double, double, double>({prefix + "divide"});
   registerBinaryNumeric<RemainderFunction>({prefix + "remainder"});
+  registerBinaryIntegralWithTReturn<IntegralDivideFunction, int64_t>(
+      {prefix + "div"});
   registerUnaryNumeric<UnaryMinusFunction>({prefix + "unaryminus"});
   registerFunction<
       UnaryMinusFunction,
@@ -120,6 +123,7 @@ void registerMathFunctions(const std::string& prefix) {
   registerDecimalSubtract(prefix);
   registerDecimalMultiply(prefix);
   registerDecimalDivide(prefix);
+  registerDecimalIntegralDivide(prefix);
   registerFunction<sparksql::IsNanFunction, bool, float>({prefix + "isnan"});
   registerFunction<sparksql::IsNanFunction, bool, double>({prefix + "isnan"});
 
@@ -127,6 +131,8 @@ void registerMathFunctions(const std::string& prefix) {
   registerBinaryNumeric<CheckedSubtractFunction>({prefix + "checked_subtract"});
   registerBinaryNumeric<CheckedMultiplyFunction>({prefix + "checked_multiply"});
   registerBinaryNumeric<CheckedDivideFunction>({prefix + "checked_divide"});
+  registerBinaryIntegralWithTReturn<CheckedIntegralDivideFunction, int64_t>(
+      {prefix + "checked_div"});
   registerFunction<sparksql::FactorialFunction, int64_t, int32_t>(
       {prefix + "factorial"});
 }
diff --git a/velox/functions/sparksql/registration/RegisterSpecialForm.cpp b/velox/functions/sparksql/registration/RegisterSpecialForm.cpp
index d82b3fbc134a..5fd3b4963fca 100644
--- a/velox/functions/sparksql/registration/RegisterSpecialForm.cpp
+++ b/velox/functions/sparksql/registration/RegisterSpecialForm.cpp
@@ -14,19 +14,20 @@
  * limitations under the License.
  */
 #include "velox/expression/RegisterSpecialForm.h"
+#include "velox/expression/ExprConstants.h"
 #include "velox/expression/RowConstructor.h"
 #include "velox/expression/SpecialFormRegistry.h"
 #include "velox/functions/sparksql/specialforms/AtLeastNNonNulls.h"
 #include "velox/functions/sparksql/specialforms/DecimalRound.h"
 #include "velox/functions/sparksql/specialforms/FromJson.h"
+#include "velox/functions/sparksql/specialforms/GetArrayStructFields.h"
 #include "velox/functions/sparksql/specialforms/GetStructField.h"
 #include "velox/functions/sparksql/specialforms/MakeDecimal.h"
 #include "velox/functions/sparksql/specialforms/SparkCastExpr.h"
 
 namespace facebook::velox::functions {
 void registerSparkSpecialFormFunctions() {
-  VELOX_REGISTER_VECTOR_FUNCTION(
-      udf_concat_row, exec::RowConstructorCallToSpecialForm::kRowConstructor);
+  VELOX_REGISTER_VECTOR_FUNCTION(udf_concat_row, expression::kRowConstructor);
 }
 
 namespace sparksql {
@@ -43,14 +44,17 @@ void registerSpecialFormGeneralFunctions(const std::string& prefix) {
       std::make_unique<AtLeastNNonNullsCallToSpecialForm>());
   registerSparkSpecialFormFunctions();
   registerFunctionCallToSpecialForm(
-      "cast", std::make_unique<SparkCastCallToSpecialForm>());
+      expression::kCast, std::make_unique<SparkCastCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
-      "try_cast", std::make_unique<SparkTryCastCallToSpecialForm>());
+      expression::kTryCast, std::make_unique<SparkTryCastCallToSpecialForm>());
   exec::registerFunctionCallToSpecialForm(
       FromJsonCallToSpecialForm::kFromJson,
       std::make_unique<FromJsonCallToSpecialForm>());
   registerFunctionCallToSpecialForm(
       "get_struct_field", std::make_unique<GetStructFieldCallToSpecialForm>());
+  registerFunctionCallToSpecialForm(
+      GetArrayStructFieldsCallToSpecialForm::kGetArrayStructFields,
+      std::make_unique<GetArrayStructFieldsCallToSpecialForm>());
 }
 } // namespace sparksql
 } // namespace facebook::velox::functions
diff --git a/velox/functions/sparksql/registration/RegisterString.cpp b/velox/functions/sparksql/registration/RegisterString.cpp
index 1ddc231c3375..0fad619931bc 100644
--- a/velox/functions/sparksql/registration/RegisterString.cpp
+++ b/velox/functions/sparksql/registration/RegisterString.cpp
@@ -15,20 +15,25 @@
  */
 #include "velox/expression/SpecialFormRegistry.h"
 #include "velox/functions/lib/Re2Functions.h"
+#include "velox/functions/lib/UpperLower.h"
 #include "velox/functions/prestosql/StringFunctions.h"
 #include "velox/functions/prestosql/URLFunctions.h"
+#include "velox/functions/sparksql/Base64Function.h"
+#include "velox/functions/sparksql/CharTypeWriteSideCheck.h"
 #include "velox/functions/sparksql/ConcatWs.h"
+#include "velox/functions/sparksql/InitcapFunction.h"
 #include "velox/functions/sparksql/LuhnCheckFunction.h"
 #include "velox/functions/sparksql/MaskFunction.h"
+#include "velox/functions/sparksql/ReadSidePaddingFunction.h"
 #include "velox/functions/sparksql/Split.h"
 #include "velox/functions/sparksql/String.h"
 #include "velox/functions/sparksql/StringToMap.h"
+#include "velox/functions/sparksql/UnBase64Function.h"
+#include "velox/functions/sparksql/VarcharTypeWriteSideCheck.h"
 
 namespace facebook::velox::functions {
 void registerSparkStringFunctions(const std::string& prefix) {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_concat, prefix + "concat");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_lower, prefix + "lower");
-  VELOX_REGISTER_VECTOR_FUNCTION(udf_upper, prefix + "upper");
   VELOX_REGISTER_VECTOR_FUNCTION(udf_reverse, prefix + "reverse");
 }
 
@@ -61,10 +66,6 @@ void registerStringFunctions(const std::string& prefix) {
       {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"});
   registerFunction<sparksql::ChrFunction, Varchar, int64_t>({prefix + "chr"});
   registerFunction<AsciiFunction, int32_t, Varchar>({prefix + "ascii"});
   registerFunction<sparksql::LPadFunction, Varchar, Varchar, int32_t, Varchar>(
@@ -149,6 +150,38 @@ void registerStringFunctions(const std::string& prefix) {
       ConcatWsCallToSpecialForm::kConcatWs,
       std::make_unique<ConcatWsCallToSpecialForm>());
   registerFunction<LuhnCheckFunction, bool, Varchar>({prefix + "luhn_check"});
+
+  using SparkUpperFunction = UpperLowerTemplateFunction<
+      /*isLower=*/false,
+      /*turkishCasing=*/true,
+      /*greekFinalSigma=*/true>;
+  using SparkLowerFunction = UpperLowerTemplateFunction<
+      /*isLower=*/true,
+      /*turkishCasing=*/true,
+      /*greekFinalSigma=*/true>;
+  exec::registerVectorFunction(
+      prefix + "upper",
+      SparkUpperFunction::signatures(),
+      std::make_unique<SparkUpperFunction>());
+  exec::registerVectorFunction(
+      prefix + "lower",
+      SparkLowerFunction::signatures(),
+      std::make_unique<SparkLowerFunction>());
+  registerFunction<ReadSidePaddingFunction, Varchar, Varchar, int32_t>(
+      {prefix + "read_side_padding"});
+  registerFunction<
+      VarcharTypeWriteSideCheckFunction,
+      Varchar,
+      Varchar,
+      int32_t>({prefix + "varchar_type_write_side_check"});
+
+  registerFunction<CharTypeWriteSideCheckFunction, Varchar, Varchar, int32_t>(
+      {prefix + "char_type_write_side_check"});
+
+  registerFunction<Base64Function, Varchar, Varbinary>({prefix + "base64"});
+  registerFunction<UnBase64Function, Varbinary, Varchar>({prefix + "unbase64"});
+
+  registerFunction<InitCapFunction, Varchar, Varchar>({prefix + "initcap"});
 }
 } // namespace sparksql
 } // namespace facebook::velox::functions
diff --git a/velox/functions/sparksql/specialforms/AtLeastNNonNulls.cpp b/velox/functions/sparksql/specialforms/AtLeastNNonNulls.cpp
index 23d6c1180fae..1e5f9598883f 100644
--- a/velox/functions/sparksql/specialforms/AtLeastNNonNulls.cpp
+++ b/velox/functions/sparksql/specialforms/AtLeastNNonNulls.cpp
@@ -30,6 +30,7 @@ class AtLeastNNonNullsExpr : public SpecialForm {
       std::vector<ExprPtr>&& inputs,
       int n)
       : SpecialForm(
+            SpecialFormKind::kCustom,
             std::move(type),
             std::move(inputs),
             AtLeastNNonNullsCallToSpecialForm::kAtLeastNNonNulls,
@@ -47,7 +48,7 @@ class AtLeastNNonNullsExpr : public SpecialForm {
     LocalSelectivityVector activeRowsHolder(context, rows);
     auto activeRows = activeRowsHolder.get();
     VELOX_DCHECK_NOT_NULL(activeRows);
-    auto values = flatResult->mutableValues(rows.end())->asMutable<uint64_t>();
+    auto values = flatResult->mutableValues()->asMutable<uint64_t>();
     // If 'n_' <= 0, set result to all true.
     if (n_ <= 0) {
       bits::orBits(values, rows.asRange().bits(), rows.begin(), rows.end());
diff --git a/velox/functions/sparksql/specialforms/CMakeLists.txt b/velox/functions/sparksql/specialforms/CMakeLists.txt
index aca5c7f64869..5c110bc4240c 100644
--- a/velox/functions/sparksql/specialforms/CMakeLists.txt
+++ b/velox/functions/sparksql/specialforms/CMakeLists.txt
@@ -17,14 +17,17 @@ velox_add_library(
   AtLeastNNonNulls.cpp
   DecimalRound.cpp
   FromJson.cpp
+  GetArrayStructFields.cpp
   GetStructField.cpp
   MakeDecimal.cpp
   SparkCastExpr.cpp
-  SparkCastHooks.cpp)
+  SparkCastHooks.cpp
+)
 
 velox_link_libraries(
   velox_functions_spark_specialforms
   fmt::fmt
   velox_functions_lib
   velox_functions_json
-  velox_expression)
+  velox_expression
+)
diff --git a/velox/functions/sparksql/specialforms/FromJson.cpp b/velox/functions/sparksql/specialforms/FromJson.cpp
index 853a370d18c3..b729d400ad0c 100644
--- a/velox/functions/sparksql/specialforms/FromJson.cpp
+++ b/velox/functions/sparksql/specialforms/FromJson.cpp
@@ -16,8 +16,10 @@
 
 #include "velox/functions/sparksql/specialforms/FromJson.h"
 
+#include <algorithm>
 #include <limits>
 #include <stdexcept>
+#include <utility>
 
 #include "velox/expression/EvalCtx.h"
 #include "velox/expression/SpecialForm.h"
@@ -25,19 +27,62 @@
 #include "velox/functions/lib/string/StringCore.h"
 #include "velox/functions/lib/string/StringImpl.h"
 #include "velox/functions/prestosql/json/SIMDJsonUtil.h"
+#include "velox/type/DecimalUtil.h"
 
 using namespace facebook::velox::exec;
 
 namespace facebook::velox::functions::sparksql {
 namespace {
 
+// Struct to store schema information for a JSON row, used for efficient field
+// lookup and null handling.
+struct JsonRowSchemaInfo {
+  // Unique key for this schema info, computed from the nesting level and field
+  // index.
+  uint64_t key;
+
+  // Indicates if all field names in this row are ASCII (for optimized
+  // case-insensitive comparison).
+  // True if all field names in this row are ASCII, enabling optimized lowercase
+  // conversion.
+  bool allFieldsAreAscii;
+
+  // Shared pointer to a vector indicating which fields are missing in the
+  // current JSON object.
+  std::shared_ptr<std::vector<bool>> isFieldMissing;
+
+  // Maps lowercased field names to their column indices for fast lookup.
+  folly::F14FastMap<std::string, column_index_t> fieldIndices;
+
+  // Maps lowercased field names to their node index in the schema tree for fast
+  // lookup.
+  folly::F14FastMap<std::string, column_index_t> nodeIndices;
+
+  JsonRowSchemaInfo(
+      uint64_t key,
+      bool allFieldsAreAscii,
+      std::shared_ptr<std::vector<bool>>&& isFieldMissing,
+      folly::F14FastMap<std::string, column_index_t>&& fieldIndices,
+      folly::F14FastMap<std::string, column_index_t>&& nodeIndices)
+      : key(key),
+        allFieldsAreAscii(allFieldsAreAscii),
+        isFieldMissing(std::move(isFieldMissing)),
+        fieldIndices(std::move(fieldIndices)),
+        nodeIndices(std::move(nodeIndices)) {}
+};
+
 // Struct for extracting JSON data and writing it with type-specific handling.
 template <typename Input>
 struct ExtractJsonTypeImpl {
   template <TypeKind kind>
-  static simdjson::error_code
-  apply(Input input, exec::GenericWriter& writer, bool isRoot) {
-    return KindDispatcher<kind>::apply(input, writer, isRoot);
+  static simdjson::error_code apply(
+      Input input,
+      exec::GenericWriter& writer,
+      bool isRoot,
+      const folly::F14FastMap<int64_t, JsonRowSchemaInfo>& jsonRowSchemaInfo,
+      column_index_t nodeIndex) {
+    return KindDispatcher<kind>::apply(
+        input, writer, isRoot, jsonRowSchemaInfo, nodeIndex);
   }
 
  private:
@@ -45,7 +90,13 @@ struct ExtractJsonTypeImpl {
   // class.
   template <TypeKind kind, typename Dummy = void>
   struct KindDispatcher {
-    static simdjson::error_code apply(Input, exec::GenericWriter&, bool) {
+    static simdjson::error_code apply(
+        Input,
+        exec::GenericWriter&,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
       VELOX_NYI("Parse json to {} is not supported.", TypeTraits<kind>::name);
       return simdjson::error_code::UNEXPECTED_ERROR;
     }
@@ -53,8 +104,13 @@ struct ExtractJsonTypeImpl {
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::VARCHAR, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
       SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
       std::string_view s;
       if (type == simdjson::ondemand::json_type::string) {
@@ -69,8 +125,13 @@ struct ExtractJsonTypeImpl {
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::BOOLEAN, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
       SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
       if (type == simdjson::ondemand::json_type::boolean) {
         auto& w = writer.castTo<bool>();
@@ -83,24 +144,39 @@ struct ExtractJsonTypeImpl {
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::TINYINT, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
       return castJsonToInt<int8_t>(value, writer);
     }
   };
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::SMALLINT, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
       return castJsonToInt<int16_t>(value, writer);
     }
   };
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::INTEGER, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
       if (writer.type() == DATE()) {
         return castJsonToDate(value, writer);
       }
@@ -110,32 +186,68 @@ struct ExtractJsonTypeImpl {
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::BIGINT, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
+      if (writer.type()->isShortDecimal()) {
+        return castJsonToDecimal<int64_t>(value, writer);
+      }
       return castJsonToInt<int64_t>(value, writer);
     }
   };
 
+  template <typename Dummy>
+  struct KindDispatcher<TypeKind::HUGEINT, Dummy> {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
+      VELOX_CHECK(writer.type()->isLongDecimal());
+      return castJsonToDecimal<int128_t>(value, writer);
+    }
+  };
+
   template <typename Dummy>
   struct KindDispatcher<TypeKind::REAL, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
       return castJsonToFloatingPoint<float>(value, writer);
     }
   };
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::DOUBLE, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::
+            F14FastMap<int64_t, JsonRowSchemaInfo>& /*jsonRowSchemaInfo*/,
+        column_index_t /*nodeIndex*/) {
       return castJsonToFloatingPoint<double>(value, writer);
     }
   };
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::ARRAY, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool isRoot) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool isRoot,
+        const folly::F14FastMap<int64_t, JsonRowSchemaInfo>& jsonRowSchemaInfo,
+        column_index_t nodeIndex) {
       auto& writerTyped = writer.castTo<Array<Any>>();
       const auto& elementType = writer.type()->childAt(0);
       SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
@@ -153,7 +265,9 @@ struct ExtractJsonTypeImpl {
                 elementType->kind(),
                 element,
                 writerTyped.add_item(),
-                false));
+                false,
+                jsonRowSchemaInfo,
+                nodeIndex + 1));
           }
         }
       } else if (elementType->kind() == TypeKind::ROW && isRoot) {
@@ -162,7 +276,9 @@ struct ExtractJsonTypeImpl {
             elementType->kind(),
             value,
             writerTyped.add_item(),
-            false));
+            false,
+            jsonRowSchemaInfo,
+            nodeIndex + 1));
       } else {
         return simdjson::INCORRECT_TYPE;
       }
@@ -172,8 +288,12 @@ struct ExtractJsonTypeImpl {
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::MAP, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool /*isRoot*/) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool /*isRoot*/,
+        const folly::F14FastMap<int64_t, JsonRowSchemaInfo>& jsonRowSchemaInfo,
+        column_index_t nodeIndex) {
       auto& writerTyped = writer.castTo<Map<Any, Any>>();
       const auto& valueType = writer.type()->childAt(1);
       SIMDJSON_ASSIGN_OR_RAISE(auto object, value.get_object());
@@ -192,7 +312,9 @@ struct ExtractJsonTypeImpl {
               valueType->kind(),
               field.value(),
               std::get<1>(writers),
-              false));
+              false,
+              jsonRowSchemaInfo,
+              nodeIndex + 1));
         }
       }
       return simdjson::SUCCESS;
@@ -201,8 +323,12 @@ struct ExtractJsonTypeImpl {
 
   template <typename Dummy>
   struct KindDispatcher<TypeKind::ROW, Dummy> {
-    static simdjson::error_code
-    apply(Input value, exec::GenericWriter& writer, bool isRoot) {
+    static simdjson::error_code apply(
+        Input value,
+        exec::GenericWriter& writer,
+        bool isRoot,
+        const folly::F14FastMap<int64_t, JsonRowSchemaInfo>& jsonRowSchemaInfo,
+        column_index_t nodeIndex) {
       const auto& rowType = writer.type()->asRow();
       auto& writerTyped = writer.castTo<DynamicRow>();
       if (value.type().error() != ::simdjson::SUCCESS) {
@@ -212,15 +338,11 @@ struct ExtractJsonTypeImpl {
       const auto type = value.type().value_unsafe();
       if (type == simdjson::ondemand::json_type::object) {
         SIMDJSON_ASSIGN_OR_RAISE(auto object, value.get_object());
-
-        const auto& names = rowType.names();
-        bool allFieldsAreAscii =
-            std::all_of(names.begin(), names.end(), [](const auto& name) {
-              return functions::stringCore::isAscii(name.data(), name.size());
-            });
-
-        auto fieldIndices = makeFieldIndicesMap(rowType, allFieldsAreAscii);
-
+        const auto& schemaInfo = jsonRowSchemaInfo.at(nodeIndex);
+        const auto& isFieldMissing = schemaInfo.isFieldMissing;
+        const auto& fieldIndices = schemaInfo.fieldIndices;
+        const auto& nodeIndices = schemaInfo.nodeIndices;
+        std::fill(isFieldMissing->begin(), isFieldMissing->end(), true);
         std::string key;
         for (const auto& fieldResult : object) {
           if (fieldResult.error() != ::simdjson::SUCCESS) {
@@ -230,22 +352,23 @@ struct ExtractJsonTypeImpl {
           if (!field.value().is_null()) {
             SIMDJSON_ASSIGN_OR_RAISE(key, field.unescaped_key(true));
 
-            if (allFieldsAreAscii) {
+            if (schemaInfo.allFieldsAreAscii) {
               folly::toLowerAscii(key);
             } else {
               boost::algorithm::to_lower(key);
             }
             auto it = fieldIndices.find(key);
-            if (it != fieldIndices.end() && it->second >= 0) {
+            if (it != fieldIndices.end() && isFieldMissing->at(it->second)) {
               const auto index = it->second;
-              it->second = -1;
-
+              isFieldMissing->at(index) = false;
               const auto res = VELOX_DYNAMIC_TYPE_DISPATCH(
                   ExtractJsonTypeImpl<simdjson::ondemand::value>::apply,
                   rowType.childAt(index)->kind(),
                   field.value(),
                   writerTyped.get_writer_at(index),
-                  false);
+                  false,
+                  jsonRowSchemaInfo,
+                  nodeIndices.at(key));
               if (res != simdjson::SUCCESS) {
                 writerTyped.set_null_at(index);
               }
@@ -253,9 +376,9 @@ struct ExtractJsonTypeImpl {
           }
         }
 
-        for (const auto& [_, index] : fieldIndices) {
-          if (index >= 0) {
-            writerTyped.set_null_at(index);
+        for (column_index_t i = 0; i < rowType.size(); ++i) {
+          if (isFieldMissing->at(i)) {
+            writerTyped.set_null_at(i);
           }
         }
       } else {
@@ -340,37 +463,75 @@ struct ExtractJsonTypeImpl {
     return simdjson::SUCCESS;
   }
 
+  template <typename T>
+  static simdjson::error_code parseSpecialFloatingStrings(
+      const std::string_view& s,
+      exec::GenericWriter& writer) {
+    constexpr T kNaN = std::numeric_limits<T>::quiet_NaN();
+    constexpr T kInf = std::numeric_limits<T>::infinity();
+    // Strip surrounding quotes if any.
+    std::string_view stripped = s;
+    if (s.size() >= 2 && s.front() == '"' && s.back() == '"') {
+      stripped = s.substr(1, s.size() - 2);
+    }
+    if (stripped == "NaN") {
+      writer.castTo<T>() = kNaN;
+    } else if (
+        stripped == "+INF" || stripped == "+Infinity" ||
+        stripped == "Infinity") {
+      writer.castTo<T>() = kInf;
+    } else if (stripped == "-INF" || stripped == "-Infinity") {
+      writer.castTo<T>() = -kInf;
+    } else {
+      return simdjson::INCORRECT_TYPE;
+    }
+    return simdjson::SUCCESS;
+  }
+
   // Casts a JSON value to a float point, handling both numeric special cases
   // for NaN and Infinity.
   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::string: {
-        SIMDJSON_ASSIGN_OR_RAISE(auto s, value.get_string());
-        constexpr T kNaN = std::numeric_limits<T>::quiet_NaN();
-        constexpr T kInf = std::numeric_limits<T>::infinity();
-        if (s == "NaN") {
-          writer.castTo<T>() = kNaN;
-        } else if (s == "+INF" || s == "+Infinity" || s == "Infinity") {
-          writer.castTo<T>() = kInf;
-        } else if (s == "-INF" || s == "-Infinity") {
-          writer.castTo<T>() = -kInf;
-        } else {
-          return simdjson::INCORRECT_TYPE;
-        }
-        break;
-      }
-      default:
-        return simdjson::INCORRECT_TYPE;
+    auto result = value.get_double();
+    if (result.error() == simdjson::SUCCESS) {
+      auto num = result.value_unsafe();
+      writer.castTo<T>() = num;
+      return simdjson::SUCCESS;
     }
-    return simdjson::SUCCESS;
+
+    std::string_view s = value.raw_json_token();
+    // Spark support such special floating point with/without quotes:
+    // NaN, +INF, +Infinity, Infinity, -INF, -Infinity.
+    if (parseSpecialFloatingStrings<T>(s, writer) == simdjson::SUCCESS) {
+      return simdjson::SUCCESS;
+    }
+
+    // simdjson parses floating point numbers in the range
+    // [std::numeric_limits<double>::lowest(),
+    // std::numeric_limits<double>::max()], i.e., from approximately
+    // -1.7976e308 to 1.7975e308. Values outside this range
+    // (<= -1e308 or >= 1e308) are rejected and simdjson returns
+    // NUMBER_ERROR. However, our expected behavior is to convert such
+    // extreme values to -INF or +INF, so we add extra logic here to
+    // handle NUMBER_ERROR and perform the conversion.
+    if (s.length() > 0 && s.back() == '.') {
+      // If the number ends with a dot, it is not a valid JSON number,
+      // so we return NUMBER_ERROR.
+      return simdjson::NUMBER_ERROR;
+    }
+    if (s.length() > 1 && s.front() == '0') {
+      // If the number starts with '0' and has more than one character,
+      // it is not a valid JSON number, so we return NUMBER_ERROR.
+      return simdjson::NUMBER_ERROR;
+    }
+    auto castResult = util::Converter<TypeKind::DOUBLE>::tryCast(s);
+    if (!castResult.hasError()) {
+      writer.castTo<T>() = castResult.value();
+      return simdjson::SUCCESS;
+    }
+    return simdjson::NUMBER_ERROR;
   }
 
   template <typename To, typename From>
@@ -389,24 +550,36 @@ struct ExtractJsonTypeImpl {
     return simdjson::SUCCESS;
   }
 
-  // Creates a map of lower case field names to their indices in the row type.
-  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 {
-        boost::algorithm::to_lower(key);
+  template <typename T>
+  static simdjson::error_code castJsonToDecimal(
+      Input value,
+      exec::GenericWriter& writer) {
+    SIMDJSON_ASSIGN_OR_RAISE(auto type, value.type());
+    std::string_view s;
+    switch (type) {
+      case simdjson::ondemand::json_type::string: {
+        SIMDJSON_ASSIGN_OR_RAISE(s, value.get_string());
+        break;
       }
-
-      fieldIndices[key] = i;
+      case simdjson::ondemand::json_type::number: {
+        s = value.raw_json_token();
+        break;
+      }
+      default:
+        return simdjson::INCORRECT_TYPE;
     }
-
-    return fieldIndices;
+    const auto toPrecisionScale = getDecimalPrecisionScale(*writer.type());
+    T decimalValue;
+    const auto status = velox::DecimalUtil::castFromString<T>(
+        StringView(s),
+        toPrecisionScale.first,
+        toPrecisionScale.second,
+        decimalValue);
+    if (!status.ok()) {
+      return simdjson::INCORRECT_TYPE;
+    }
+    writer.castTo<T>() = decimalValue;
+    return simdjson::SUCCESS;
   }
 
   constexpr static std::string_view kGMT{"GMT"};
@@ -428,6 +601,11 @@ struct ExtractJsonTypeImpl {
 template <TypeKind kind>
 class FromJsonFunction final : public exec::VectorFunction {
  public:
+  explicit FromJsonFunction(const TypePtr& type) {
+    column_index_t index = 0;
+    constructRowSchemaInfoMap(type, index);
+  }
+
   void apply(
       const SelectivityVector& rows,
       std::vector<VectorPtr>& args, // Not using const ref so we can reuse args
@@ -475,7 +653,8 @@ class FromJsonFunction final : public exec::VectorFunction {
       context.applyToSelectedNoThrow(rows, [&](auto row) {
         writer.setOffset(row);
         if (error != simdjson::SUCCESS ||
-            extractJsonToWriter(jsonDoc, writer) != simdjson::SUCCESS) {
+            extractJsonToWriter(jsonDoc, writer, rowSchemaInfoMap_) !=
+                simdjson::SUCCESS) {
           writer.commitNull();
         }
       });
@@ -515,23 +694,79 @@ class FromJsonFunction final : public exec::VectorFunction {
       simdjson::ondemand::document doc;
       auto error = simdjsonParse(paddedInput).get(doc);
       if (error != simdjson::SUCCESS ||
-          extractJsonToWriter(doc, writer) != simdjson::SUCCESS) {
+          extractJsonToWriter(doc, writer, rowSchemaInfoMap_) !=
+              simdjson::SUCCESS) {
         writer.commitNull();
       }
     });
     writer.finish();
   }
 
+  // Constructs a map from the schema tree node index to JsonRowSchemaInfo.
+  column_index_t constructRowSchemaInfoMap(
+      const TypePtr& type,
+      column_index_t& index) {
+    auto nodeKey = index++;
+    switch (type->kind()) {
+      case TypeKind::ARRAY: {
+        constructRowSchemaInfoMap(type->childAt(0), index);
+        break;
+      }
+      case TypeKind::MAP: {
+        constructRowSchemaInfoMap(type->childAt(1), index);
+        break;
+      }
+      case TypeKind::ROW: {
+        const auto& rowType = asRowType(type);
+        const auto& names = rowType->names();
+        bool allFieldsAreAscii =
+            std::all_of(names.begin(), names.end(), [](const auto& name) {
+              return functions::stringCore::isAscii(name.data(), name.size());
+            });
+        auto isFieldMissing = std::make_shared<std::vector<bool>>();
+        isFieldMissing->resize(rowType->size(), true);
+        folly::F14FastMap<std::string, column_index_t> fieldIndices;
+        folly::F14FastMap<std::string, column_index_t> nodeIndices;
+        const auto size = rowType->size();
+        for (auto i = 0; i < size; ++i) {
+          std::string key = rowType->nameOf(i);
+          if (allFieldsAreAscii) {
+            folly::toLowerAscii(key);
+          } else {
+            boost::algorithm::to_lower(key);
+          }
+          fieldIndices[key] = i;
+          nodeIndices[key] = constructRowSchemaInfoMap(type->childAt(i), index);
+        }
+        rowSchemaInfoMap_.insert_or_assign(
+            nodeKey,
+            JsonRowSchemaInfo(
+                nodeKey,
+                allFieldsAreAscii,
+                std::move(isFieldMissing),
+                std::move(fieldIndices),
+                std::move(nodeIndices)));
+        break;
+      }
+      default:
+        break;
+    }
+    return nodeKey;
+  }
+
   // Extracts data from json doc and writes it to writer.
+  // @param rowSchemaInfoMap A map from schema tree node index to
+  // JsonRowSchemaInfo.
   static simdjson::error_code extractJsonToWriter(
       simdjson::ondemand::document& doc,
-      exec::VectorWriter<Any>& writer) {
+      exec::VectorWriter<Any>& writer,
+      const folly::F14FastMap<int64_t, JsonRowSchemaInfo>& rowSchemaInfoMap) {
     if (doc.is_null()) {
       writer.commitNull();
     } else {
       SIMDJSON_TRY(
           ExtractJsonTypeImpl<simdjson::ondemand::document&>::apply<kind>(
-              doc, writer.current(), true));
+              doc, writer.current(), true, rowSchemaInfoMap, 0));
       writer.commit(true);
     }
     return simdjson::SUCCESS;
@@ -539,6 +774,8 @@ class FromJsonFunction final : public exec::VectorFunction {
 
   // The buffer with extra bytes for parser::parse(),
   mutable std::string paddedInput_;
+  // Map from row schema tree node index to schema information for JSON rows.
+  folly::F14FastMap<int64_t, JsonRowSchemaInfo> rowSchemaInfoMap_;
 };
 
 /// Determines whether a given type is supported.
@@ -563,12 +800,8 @@ bool isSupportedType(const TypePtr& type, bool isRootType) {
           type->childAt(0)->kind() == TypeKind::VARCHAR &&
           isSupportedType(type->childAt(1), false));
     }
-    case TypeKind::BIGINT: {
-      if (type->isDecimal()) {
-        return false;
-      }
-      return !isRootType;
-    }
+    case TypeKind::HUGEINT:
+    case TypeKind::BIGINT:
     case TypeKind::INTEGER:
     case TypeKind::BOOLEAN:
     case TypeKind::SMALLINT:
@@ -600,17 +833,16 @@ exec::ExprPtr FromJsonCallToSpecialForm::constructSpecialForm(
       args[0]->type()->kind(),
       TypeKind::VARCHAR,
       "The first argument of from_json should be of varchar type.");
-
   VELOX_USER_CHECK(
       isSupportedType(type, true), "Unsupported type {}.", type->toString());
 
   std::shared_ptr<exec::VectorFunction> func;
   if (type->kind() == TypeKind::ARRAY) {
-    func = std::make_shared<FromJsonFunction<TypeKind::ARRAY>>();
+    func = std::make_shared<FromJsonFunction<TypeKind::ARRAY>>(type);
   } else if (type->kind() == TypeKind::MAP) {
-    func = std::make_shared<FromJsonFunction<TypeKind::MAP>>();
+    func = std::make_shared<FromJsonFunction<TypeKind::MAP>>(type);
   } else {
-    func = std::make_shared<FromJsonFunction<TypeKind::ROW>>();
+    func = std::make_shared<FromJsonFunction<TypeKind::ROW>>(type);
   }
 
   return std::make_shared<exec::Expr>(
diff --git a/velox/functions/sparksql/specialforms/GetArrayStructFields.cpp b/velox/functions/sparksql/specialforms/GetArrayStructFields.cpp
new file mode 100644
index 000000000000..7d4e57bf77d8
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/GetArrayStructFields.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 "velox/functions/sparksql/specialforms/GetArrayStructFields.h"
+#include "velox/expression/ConstantExpr.h"
+#include "velox/vector/ComplexVector.h"
+
+namespace facebook::velox::functions::sparksql {
+namespace {
+
+class GetArrayStructFieldsFunction : public exec::VectorFunction {
+ public:
+  explicit GetArrayStructFieldsFunction(int32_t ordinal) : ordinal_(ordinal) {}
+
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& /*resultType*/,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    // Decode input array vector.
+    exec::LocalDecodedVector decoded(context, *args[0], rows);
+    auto arrayVec = decoded->base()->as<ArrayVector>();
+
+    DecodedVector decodedElement(*arrayVec->elements());
+    auto elements = decodedElement.base()->as<RowVector>();
+    auto fieldVector = elements->childAt(ordinal_);
+
+    VectorPtr fieldResult = fieldVector;
+    if (elements->mayHaveNulls()) {
+      auto size = elements->size();
+      auto indices =
+          AlignedBuffer::allocate<vector_size_t>(size, context.pool());
+      std::iota(
+          indices->asMutable<vector_size_t>(),
+          indices->asMutable<vector_size_t>() + size,
+          0);
+
+      // Wrap field with nulls from elements.
+      fieldResult = BaseVector::wrapInDictionary(
+          elements->nulls(), indices, size, fieldResult);
+    }
+
+    // Apply element decoding if needed.
+    if (!decodedElement.isIdentityMapping()) {
+      fieldResult = decodedElement.wrap(
+          fieldResult, *arrayVec->elements(), decodedElement.size());
+    }
+
+    auto arrayResult = std::make_shared<ArrayVector>(
+        context.pool(),
+        ARRAY(fieldVector->type()),
+        arrayVec->nulls(),
+        arrayVec->size(),
+        arrayVec->offsets(),
+        arrayVec->sizes(),
+        fieldResult);
+
+    if (decoded->isIdentityMapping()) {
+      result = arrayResult;
+    } else {
+      result = decoded->wrap(arrayResult, *args[0], decoded->size());
+    }
+  }
+
+ private:
+  // The position to select subfield from the struct.
+  const int32_t ordinal_;
+};
+
+} // namespace
+
+TypePtr GetArrayStructFieldsCallToSpecialForm::resolveType(
+    const std::vector<TypePtr>& /*argTypes*/) {
+  VELOX_FAIL("GetArrayStructFields function does not support type resolution.");
+}
+
+exec::ExprPtr GetArrayStructFieldsCallToSpecialForm::constructSpecialForm(
+    const TypePtr& type,
+    std::vector<exec::ExprPtr>&& args,
+    bool trackCpuUsage,
+    const core::QueryConfig& /*config*/) {
+  VELOX_USER_CHECK_EQ(
+      args.size(), 2, "get_array_struct_fields expects two arguments.");
+
+  VELOX_USER_CHECK(
+      args[0]->type()->kind() == TypeKind::ARRAY &&
+          args[0]->type()->asArray().elementType()->kind() == TypeKind::ROW,
+      "The first argument of get_array_struct_fields should be of array(row) type.");
+
+  VELOX_USER_CHECK_EQ(
+      args[1]->type()->kind(),
+      TypeKind::INTEGER,
+      "The second argument of get_array_struct_fields 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 get_array_struct_fields should be constant expression.");
+  VELOX_USER_CHECK(
+      constantExpr->value()->isConstantEncoding(),
+      "The second argument of get_array_struct_fields should be wrapped in constant vector.");
+  auto constantVector =
+      constantExpr->value()->asUnchecked<ConstantVector<int32_t>>();
+  VELOX_USER_CHECK(
+      !constantVector->isNullAt(0),
+      "The second argument of get_array_struct_fields should be non-nullable.");
+
+  auto ordinal = constantVector->valueAt(0);
+
+  VELOX_USER_CHECK_GE(
+      ordinal, 0, "Invalid ordinal. Should be greater than or equal to 0.");
+  auto numFields = args[0]->type()->asArray().elementType()->asRow().size();
+  VELOX_USER_CHECK_LT(
+      ordinal,
+      numFields,
+      "Invalid ordinal {} for struct with {} fields.",
+      ordinal,
+      numFields);
+  auto getArrayStructFieldsFunction =
+      std::make_shared<GetArrayStructFieldsFunction>(ordinal);
+
+  return std::make_shared<exec::Expr>(
+      type,
+      std::move(args),
+      std::move(getArrayStructFieldsFunction),
+      exec::VectorFunctionMetadata{},
+      kGetArrayStructFields,
+      trackCpuUsage);
+}
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/GetArrayStructFields.h b/velox/functions/sparksql/specialforms/GetArrayStructFields.h
new file mode 100644
index 000000000000..9f9cd1724b6b
--- /dev/null
+++ b/velox/functions/sparksql/specialforms/GetArrayStructFields.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/expression/FunctionCallToSpecialForm.h"
+
+namespace facebook::velox::functions::sparksql {
+
+class GetArrayStructFieldsCallToSpecialForm
+    : public exec::FunctionCallToSpecialForm {
+ public:
+  TypePtr resolveType(const std::vector<TypePtr>& argTypes) override;
+
+  /// Returns an expression for get_array_struct_fields special form. The
+  /// expression is a regular expression based on a custom VectorFunction
+  /// implementation.
+  exec::ExprPtr constructSpecialForm(
+      const TypePtr& type,
+      std::vector<exec::ExprPtr>&& args,
+      bool trackCpuUsage,
+      const core::QueryConfig& config) override;
+
+  static constexpr const char* kGetArrayStructFields =
+      "get_array_struct_fields";
+};
+
+} // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/MakeDecimal.cpp b/velox/functions/sparksql/specialforms/MakeDecimal.cpp
index 029bb5cb1aff..30b58700fe6a 100644
--- a/velox/functions/sparksql/specialforms/MakeDecimal.cpp
+++ b/velox/functions/sparksql/specialforms/MakeDecimal.cpp
@@ -114,10 +114,12 @@ class MakeDecimalFunction final : public exec::VectorFunction {
   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)));
+    return std::make_exception_ptr(
+        std::overflow_error(
+            fmt::format(
+                "Unscaled value {} too large for precision {}.",
+                unscaled,
+                resultPrecision)));
   }
 
   const uint8_t resultPrecision_;
diff --git a/velox/functions/sparksql/specialforms/SparkCastExpr.cpp b/velox/functions/sparksql/specialforms/SparkCastExpr.cpp
index f9c991f74d82..c9c32f76c034 100644
--- a/velox/functions/sparksql/specialforms/SparkCastExpr.cpp
+++ b/velox/functions/sparksql/specialforms/SparkCastExpr.cpp
@@ -28,12 +28,17 @@ exec::ExprPtr SparkCastCallToSpecialForm::constructSpecialForm(
       1,
       "CAST statements expect exactly 1 argument, received {}.",
       compiledChildren.size());
+  // In Spark SQL (with ANSI mode off), both CAST and TRY_CAST behave like
+  // Velox's try_cast, so we set 'isTryCast' to true by default in CastExpr.
+  // The distinction between CAST (ANSI off) and TRY_CAST is limited to
+  // overflow handling, which is managed by the 'allowOverflow' flag in
+  // SparkCastHooks.
   return std::make_shared<SparkCastExpr>(
       type,
       std::move(compiledChildren[0]),
       trackCpuUsage,
-      false,
-      std::make_shared<SparkCastHooks>(config));
+      true,
+      std::make_shared<SparkCastHooks>(config, true));
 }
 
 exec::ExprPtr SparkTryCastCallToSpecialForm::constructSpecialForm(
@@ -51,6 +56,6 @@ exec::ExprPtr SparkTryCastCallToSpecialForm::constructSpecialForm(
       std::move(compiledChildren[0]),
       trackCpuUsage,
       true,
-      std::make_shared<SparkCastHooks>(config));
+      std::make_shared<SparkCastHooks>(config, false));
 }
 } // namespace facebook::velox::functions::sparksql
diff --git a/velox/functions/sparksql/specialforms/SparkCastExpr.h b/velox/functions/sparksql/specialforms/SparkCastExpr.h
index 9349876ba707..6b9e7e5d1c17 100644
--- a/velox/functions/sparksql/specialforms/SparkCastExpr.h
+++ b/velox/functions/sparksql/specialforms/SparkCastExpr.h
@@ -30,14 +30,10 @@ class SparkCastExpr : public exec::CastExpr {
       TypePtr type,
       exec::ExprPtr&& expr,
       bool trackCpuUsage,
-      bool nullOnFailure,
+      bool isTryCast,
       std::shared_ptr<SparkCastHooks> hooks)
-      : exec::CastExpr(
-            type,
-            std::move(expr),
-            trackCpuUsage,
-            nullOnFailure,
-            hooks) {}
+      : exec::CastExpr(type, std::move(expr), trackCpuUsage, isTryCast, hooks) {
+  }
 };
 
 class SparkCastCallToSpecialForm : public exec::CastCallToSpecialForm {
diff --git a/velox/functions/sparksql/specialforms/SparkCastHooks.cpp b/velox/functions/sparksql/specialforms/SparkCastHooks.cpp
index 7bc2844b9339..be5d683679ba 100644
--- a/velox/functions/sparksql/specialforms/SparkCastHooks.cpp
+++ b/velox/functions/sparksql/specialforms/SparkCastHooks.cpp
@@ -21,8 +21,10 @@
 
 namespace facebook::velox::functions::sparksql {
 
-SparkCastHooks::SparkCastHooks(const velox::core::QueryConfig& config)
-    : config_(config) {
+SparkCastHooks::SparkCastHooks(
+    const velox::core::QueryConfig& config,
+    bool allowOverflow)
+    : config_(config), allowOverflow_(allowOverflow) {
   const auto sessionTzName = config.sessionTimezone();
   if (!sessionTzName.empty()) {
     timestampToStringOptions_.timeZone = tz::locateZone(sessionTzName);
@@ -125,6 +127,9 @@ StringView SparkCastHooks::removeWhiteSpaces(const StringView& view) const {
 }
 
 exec::PolicyType SparkCastHooks::getPolicy() const {
+  if (!allowOverflow_) {
+    return exec::PolicyType::SparkTryCastPolicy;
+  }
   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
index 8ae511b5dc25..22f6a299995a 100644
--- a/velox/functions/sparksql/specialforms/SparkCastHooks.h
+++ b/velox/functions/sparksql/specialforms/SparkCastHooks.h
@@ -24,7 +24,9 @@ namespace facebook::velox::functions::sparksql {
 // This class provides cast hooks following Spark semantics.
 class SparkCastHooks : public exec::CastHooks {
  public:
-  explicit SparkCastHooks(const velox::core::QueryConfig& config);
+  explicit SparkCastHooks(
+      const velox::core::QueryConfig& config,
+      bool allowOverflow);
 
   // TODO: Spark hook allows more string patterns than Presto.
   Expected<Timestamp> castStringToTimestamp(
@@ -67,6 +69,10 @@ class SparkCastHooks : public exec::CastHooks {
   }
 
   bool truncate() const override {
+    return allowOverflow_;
+  }
+
+  bool applyTryCastRecursively() const override {
     return true;
   }
 
@@ -81,6 +87,9 @@ class SparkCastHooks : public exec::CastHooks {
 
   const core::QueryConfig& config_;
 
+  // If true, the cast will truncate the overflow value to fit the target type.
+  const bool allowOverflow_;
+
   /// 1) Does not follow 'isLegacyCast'. 2) The conversion precision is
   /// microsecond. 3) Does not append trailing zeros. 4) Adds a positive
   /// sign at first if the year exceeds 9999. 5) Respects the configured
diff --git a/velox/functions/sparksql/tests/ArithmeticTest.cpp b/velox/functions/sparksql/tests/ArithmeticTest.cpp
index 221b2783bba4..7efb55ef0838 100644
--- a/velox/functions/sparksql/tests/ArithmeticTest.cpp
+++ b/velox/functions/sparksql/tests/ArithmeticTest.cpp
@@ -16,6 +16,7 @@
 #include <cstdint>
 #include <limits>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 
 namespace facebook::velox::functions::sparksql::test {
@@ -189,6 +190,13 @@ class ArithmeticTest : public SparkFunctionBaseTest {
     return evaluateOnce<double>("divide(c0, c1)", numerator, denominator);
   }
 
+  template <typename T>
+  std::optional<int64_t> div(
+      std::optional<T> numerator,
+      std::optional<T> denominator) {
+    return evaluateOnce<int64_t>("div(c0, c1)", numerator, denominator);
+  }
+
   template <typename T>
   std::optional<T> checkedAdd(
       const std::optional<T> a,
@@ -217,6 +225,18 @@ class ArithmeticTest : public SparkFunctionBaseTest {
     return evaluateOnce<T>("checked_subtract(c0, c1)", a, b);
   }
 
+  template <typename T>
+  std::optional<int64_t> checkedDiv(
+      std::optional<T> numerator,
+      std::optional<T> denominator) {
+    return evaluateOnce<int64_t>("checked_div(c0, c1)", numerator, denominator);
+  }
+
+  template <typename T>
+  std::optional<T> abs(const std::optional<T> input) {
+    return evaluateOnce<T>("abs(c0)", input);
+  }
+
   template <typename T>
   void assertErrorForCheckedArithmetic(
       const std::string& func,
@@ -259,13 +279,21 @@ class ArithmeticTest : public SparkFunctionBaseTest {
   }
 
   template <typename T>
-  void assertErrorForcheckedSubtract(
+  void assertErrorForCheckedSubtract(
       const std::optional<T> a,
       const std::optional<T> b,
       const std::string& errorMessage) {
     assertErrorForCheckedArithmetic("checked_subtract", a, b, errorMessage);
   }
 
+  template <typename T>
+  void assertErrorForCheckedDiv(
+      const std::optional<T> a,
+      const std::optional<T> b,
+      const std::string& errorMessage) {
+    assertErrorForCheckedArithmetic("checked_div", 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();
@@ -319,6 +347,23 @@ TEST_F(ArithmeticTest, Divide) {
   EXPECT_TRUE(std::isnan(divide(kInf, -kInf).value_or(0)));
 }
 
+TEST_F(ArithmeticTest, div) {
+  // Division by zero is always null.
+  EXPECT_EQ(div<int64_t>(1, 0), std::nullopt);
+  EXPECT_EQ(div<int64_t>(0, 0), std::nullopt);
+  EXPECT_EQ(div<int64_t>(INT64_MIN, 0), std::nullopt);
+
+  EXPECT_EQ(div<int64_t>(INT64_MIN, -1), INT64_MIN);
+
+  EXPECT_EQ(div<int8_t>(INT8_MAX, INT8_MIN), 0);
+  EXPECT_EQ(div<int16_t>(INT16_MIN, INT16_MAX), -1);
+  EXPECT_EQ(div<int32_t>(INT32_MAX, INT32_MIN), 0);
+  EXPECT_EQ(div<int64_t>(INT64_MIN, INT64_MAX), -1);
+
+  EXPECT_EQ(div<int64_t>(2, 3), 0);
+  EXPECT_EQ(div<int64_t>(3, 2), 1);
+}
+
 TEST_F(ArithmeticTest, acosh) {
   const auto acosh = [&](std::optional<double> a) {
     return evaluateOnce<double>("acosh(c0)", a);
@@ -690,13 +735,13 @@ TEST_F(ArithmeticTest, checkedAdd) {
 }
 
 TEST_F(ArithmeticTest, checkedSubtract) {
-  assertErrorForcheckedSubtract<int8_t>(
+  assertErrorForCheckedSubtract<int8_t>(
       INT8_MIN, 1, "Arithmetic overflow: -128 - 1");
-  assertErrorForcheckedSubtract<int16_t>(
+  assertErrorForCheckedSubtract<int16_t>(
       INT16_MIN, 1, "Arithmetic overflow: -32768 - 1");
-  assertErrorForcheckedSubtract<int32_t>(
+  assertErrorForCheckedSubtract<int32_t>(
       INT32_MIN, 1, "Arithmetic overflow: -2147483648 - 1");
-  assertErrorForcheckedSubtract<int64_t>(
+  assertErrorForCheckedSubtract<int64_t>(
       INT64_MIN, 1, "Arithmetic overflow: -9223372036854775808 - 1");
   EXPECT_EQ(checkedSubtract<float>(kInf, 1), kInf);
   EXPECT_EQ(checkedSubtract<double>(kInfDouble, 1), kInfDouble);
@@ -729,6 +774,74 @@ TEST_F(ArithmeticTest, checkedDivide) {
   EXPECT_EQ(checkedDivide<double>(kInfDouble, 1), kInfDouble);
 }
 
+TEST_F(ArithmeticTest, checkedDiv) {
+  EXPECT_EQ(checkedDiv<int8_t>(INT8_MAX, INT8_MIN), 0);
+  EXPECT_EQ(checkedDiv<int16_t>(INT16_MIN, INT16_MAX), -1);
+  EXPECT_EQ(checkedDiv<int32_t>(INT32_MAX, INT32_MIN), 0);
+  EXPECT_EQ(checkedDiv<int64_t>(INT64_MIN, INT64_MAX), -1);
+
+  EXPECT_EQ(checkedDiv<int64_t>(2, 3), 0);
+  EXPECT_EQ(checkedDiv<int64_t>(3, 2), 1);
+  // Division by zero is always null.
+  assertErrorForCheckedDiv<int64_t>(1, 0, "Division by zero");
+  // Division overflow.
+  assertErrorForCheckedDiv<int64_t>(
+      INT64_MIN, -1, "Overflow in integral divide");
+}
+
+TEST_F(ArithmeticTest, abs) {
+  for (const auto& ansiEnabled : {"false", "true"}) {
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kSparkAnsiEnabled, ansiEnabled}});
+
+    EXPECT_EQ(abs<int8_t>(-127), 127);
+    EXPECT_EQ(abs<int16_t>(-32767), 32767);
+    EXPECT_EQ(abs<int32_t>(-2147483647), 2147483647);
+    EXPECT_EQ(abs<int64_t>(-9223372036854775807), 9223372036854775807);
+
+    EXPECT_EQ(abs<float>(-99999.9999f), 99999.9999f);
+    EXPECT_EQ(
+        abs<float>(std::numeric_limits<float>::lowest()),
+        std::numeric_limits<float>::max());
+    EXPECT_EQ(abs<double>(-99999.9999), 99999.9999);
+    EXPECT_EQ(
+        abs<double>(std::numeric_limits<double>::lowest()),
+        std::numeric_limits<double>::max());
+  }
+}
+
+TEST_F(ArithmeticTest, absMinValueOverflow) {
+  // Test abs with ANSI off.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kSparkAnsiEnabled, "false"}});
+
+  EXPECT_EQ(
+      abs<int8_t>(std::numeric_limits<int8_t>::min()),
+      std::numeric_limits<int8_t>::min());
+  EXPECT_EQ(
+      abs<int16_t>(std::numeric_limits<int16_t>::min()),
+      std::numeric_limits<int16_t>::min());
+  EXPECT_EQ(
+      abs<int32_t>(std::numeric_limits<int32_t>::min()),
+      std::numeric_limits<int32_t>::min());
+  EXPECT_EQ(
+      abs<int64_t>(std::numeric_limits<int64_t>::min()),
+      std::numeric_limits<int64_t>::min());
+
+  // Test abs with ANSI on.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kSparkAnsiEnabled, "true"}});
+
+  VELOX_ASSERT_THROW(
+      abs<int8_t>(std::numeric_limits<int8_t>::min()), "Arithmetic overflow");
+  VELOX_ASSERT_THROW(
+      abs<int16_t>(std::numeric_limits<int16_t>::min()), "Arithmetic overflow");
+  VELOX_ASSERT_THROW(
+      abs<int32_t>(std::numeric_limits<int32_t>::min()), "Arithmetic overflow");
+  VELOX_ASSERT_THROW(
+      abs<int64_t>(std::numeric_limits<int64_t>::min()), "Arithmetic overflow");
+}
+
 class LogNTest : public SparkFunctionBaseTest {
  protected:
   static constexpr double kInf = std::numeric_limits<double>::infinity();
@@ -796,5 +909,25 @@ TEST_F(SqrtTest, sqrt) {
   EXPECT_TRUE(std::isnan(sqrt(-1).value()));
 }
 
+class CbrtTest : public SparkFunctionBaseTest {
+ protected:
+  std::optional<double> cbrt(std::optional<double> a) {
+    return evaluateOnce<double>("cbrt(c0)", a);
+  }
+};
+
+TEST_F(CbrtTest, cbrt) {
+  const double kInf = std::numeric_limits<double>::infinity();
+  const double kNan = std::numeric_limits<double>::quiet_NaN();
+
+  EXPECT_EQ(cbrt(std::nullopt), std::nullopt);
+  EXPECT_EQ(cbrt(8), 2.0);
+  EXPECT_EQ(cbrt(-8), -2.0);
+  EXPECT_EQ(cbrt(0), 0.0);
+  EXPECT_EQ(cbrt(kInf), kInf);
+  EXPECT_EQ(cbrt(-kInf), -kInf);
+  EXPECT_TRUE(std::isnan(cbrt(kNan).value()));
+}
+
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArrayMaxTest.cpp b/velox/functions/sparksql/tests/ArrayMaxTest.cpp
index 530417852dae..cb0244c50bc8 100644
--- a/velox/functions/sparksql/tests/ArrayMaxTest.cpp
+++ b/velox/functions/sparksql/tests/ArrayMaxTest.cpp
@@ -195,9 +195,10 @@ TYPED_TEST(ArrayMaxFloatingPointTest, basic) {
   EXPECT_FLOAT_EQ(
       this->template arrayMax<T>({-0.00001, -0.0002, 0.0001}).value(), 0.0001);
 
-  EXPECT_TRUE(std::isnan(
-      this->template arrayMax<T>({kMin, -0.0001, -0.0002, -0.0003, kMax, kNaN})
-          .value()));
+  EXPECT_TRUE(
+      std::isnan(this->template arrayMax<T>(
+                         {kMin, -0.0001, -0.0002, -0.0003, kMax, kNaN})
+                     .value()));
 }
 
 } // namespace
diff --git a/velox/functions/sparksql/tests/ArraySortTest.cpp b/velox/functions/sparksql/tests/ArraySortTest.cpp
index 1247e020239a..47ee68b2a859 100644
--- a/velox/functions/sparksql/tests/ArraySortTest.cpp
+++ b/velox/functions/sparksql/tests/ArraySortTest.cpp
@@ -16,6 +16,7 @@
 
 #include <optional>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/sparksql/tests/ArraySortTestData.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
@@ -35,6 +36,24 @@ class ArraySortTest : public SparkFunctionBaseTest {
     assertEqualVectors(expected, result);
   }
 
+  void testArraySort(
+      const std::string& lamdaExpr,
+      bool asc,
+      const VectorPtr& input,
+      const VectorPtr& expected) {
+    std::string name = asc ? "array_sort" : "array_sort_desc";
+    auto result = evaluate(
+        fmt::format("{}(c0, {})", name, lamdaExpr), makeRowVector({input}));
+    assertEqualVectors(expected, result);
+
+    SelectivityVector firstRow(1);
+    result = evaluate(
+        fmt::format("{}(c0, {})", name, lamdaExpr),
+        makeRowVector({input}),
+        firstRow);
+    assertEqualVectors(expected->slice(0, 1), result);
+  }
+
   template <typename T>
   void testInt() {
     auto input = makeNullableArrayVector(intInput<T>());
@@ -104,10 +123,14 @@ TEST_F(ArraySortTest, array) {
   testArraySort(input, expected);
 }
 
-TEST_F(ArraySortTest, map) {
+// Map is not orderable, so sorting is not supported.
+TEST_F(ArraySortTest, failOnMapTypeSort) {
   auto input = makeArrayOfMapVector(mapInput());
-  auto expected = makeArrayOfMapVector(mapAscNullLargest());
-  testArraySort(input, expected);
+  const std::string kErrorMessage =
+      "Scalar function signature is not supported";
+
+  VELOX_ASSERT_THROW(
+      evaluate("array_sort(c0)", makeRowVector({input})), kErrorMessage);
 }
 
 TEST_F(ArraySortTest, row) {
@@ -140,5 +163,67 @@ TEST_F(ArraySortTest, constant) {
   expected = makeConstantArray<int64_t>(size, {6, 6, 6, 6});
   assertEqualVectors(expected, result);
 }
+
+TEST_F(ArraySortTest, lambda) {
+  auto data = makeNullableArrayVector<std::string>({
+      {"abc123", "abc", std::nullopt, "abcd"},
+      {std::nullopt, "x", "xyz123", "xyz"},
+  });
+
+  auto sortedAsc = makeNullableArrayVector<std::string>({
+      {"abc", "abcd", "abc123", std::nullopt},
+      {"x", "xyz", "xyz123", std::nullopt},
+  });
+
+  auto sortedDesc = makeNullableArrayVector<std::string>({
+      {"abc123", "abcd", "abc", std::nullopt},
+      {"xyz123", "xyz", "x", std::nullopt},
+  });
+
+  // Different ways to sort by length ascending.
+  testArraySort("x -> length(x)", true, data, sortedAsc);
+  testArraySort("x -> length(x) * -1", false, data, sortedAsc);
+  testArraySort(
+      "(x, y) -> if(lessthan(length(x), length(y)), -1, if(greaterthan(length(x), length(y)), 1, 0))",
+      true,
+      data,
+      sortedAsc);
+  testArraySort(
+      "(x, y) -> if(lessthan(length(x), length(y)), -1, if(equalto(length(x), length(y)), 0, 1))",
+      true,
+      data,
+      sortedAsc);
+
+  // Different ways to sort by length descending.
+  testArraySort("x -> length(x)", false, data, sortedDesc);
+  testArraySort("x -> length(x) * -1", true, data, sortedDesc);
+  testArraySort(
+      "(x, y) -> if(lessthan(length(x), length(y)), 1, if(greaterthan(length(x), length(y)), -1, 0))",
+      true,
+      data,
+      sortedDesc);
+  testArraySort(
+      "(x, y) -> if(lessthan(length(x), length(y)), 1, if(equalto(length(x), length(y)), 0, -1))",
+      true,
+      data,
+      sortedDesc);
+
+  // Lambda function return NULL.
+  VELOX_ASSERT_THROW(
+      evaluate(
+          "array_sort(c0, (x, y) -> IF(lessthan(x, y), 1, IF(equalto(x, y), 0, null)))",
+          makeRowVector({data})),
+      "Else clause of a SWITCH statement must have the same type as 'then' clauses. Expected BIGINT, but got UNKNOWN.");
+}
+
+TEST_F(ArraySortTest, unsupporteLambda) {
+  auto data = makeRowVector({
+      makeNullableArrayVector(intInput<int32_t>()),
+  });
+
+  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");
+}
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ArraySortTestData.h b/velox/functions/sparksql/tests/ArraySortTestData.h
index 38de4684e346..4a96e9b8ecd1 100644
--- a/velox/functions/sparksql/tests/ArraySortTestData.h
+++ b/velox/functions/sparksql/tests/ArraySortTestData.h
@@ -248,7 +248,11 @@ arrayInput() {
       // Top level null elements.
       {{A({1, 3}), std::nullopt, A({2, 1})}},
       // Array with null values.
-      {{A({std::nullopt, 6}), A({3, std::nullopt}), A({std::nullopt, 8})}},
+      {{A({std::nullopt, 6}),
+        A({3, std::nullopt}),
+        A({std::nullopt, 8}),
+        std::nullopt,
+        A({})}},
   };
 }
 
@@ -261,7 +265,11 @@ arrayAscNullSmallest() {
       {{std::nullopt, std::nullopt}},
       {{A({1, 3}), A({1, 3, 5}), A({2, 1})}},
       {{std::nullopt, A({1, 3}), A({2, 1})}},
-      {{A({std::nullopt, 6}), A({std::nullopt, 8}), A({3, std::nullopt})}},
+      {{std::nullopt,
+        A({}),
+        A({std::nullopt, 6}),
+        A({std::nullopt, 8}),
+        A({3, std::nullopt})}},
   };
 }
 
@@ -274,7 +282,11 @@ arrayAscNullLargest() {
       {{std::nullopt, std::nullopt}},
       {{A({1, 3}), A({1, 3, 5}), A({2, 1})}},
       {{A({1, 3}), A({2, 1}), std::nullopt}},
-      {{A({3, std::nullopt}), A({std::nullopt, 6}), A({std::nullopt, 8})}},
+      {{A({}),
+        A({3, std::nullopt}),
+        A({std::nullopt, 6}),
+        A({std::nullopt, 8}),
+        std::nullopt}},
   };
 }
 
diff --git a/velox/functions/sparksql/tests/Base64Test.cpp b/velox/functions/sparksql/tests/Base64Test.cpp
new file mode 100644
index 000000000000..35e10622bfb6
--- /dev/null
+++ b/velox/functions/sparksql/tests/Base64Test.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/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class Base64Test : public SparkFunctionBaseTest {
+ protected:
+  std::optional<std::string> base64(const std::optional<std::string>& a) {
+    return evaluateOnce<std::string>("base64(c0)", VARBINARY(), a);
+  }
+};
+
+TEST_F(Base64Test, basic) {
+  EXPECT_EQ(base64(std::nullopt), std::nullopt);
+  EXPECT_EQ(base64("Man"), "TWFu");
+  EXPECT_EQ(base64("\x01"), "AQ==");
+  EXPECT_EQ(base64("\xff\xee"), "/+4=");
+  EXPECT_EQ(base64("hello world"), "aGVsbG8gd29ybGQ=");
+  EXPECT_EQ(base64("Spark SQL"), "U3BhcmsgU1FM");
+  EXPECT_EQ(
+      base64(std::string(57, 'A')),
+      "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB");
+  EXPECT_EQ(
+      base64(std::string(58, 'A')),
+      "QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\r\nQQ==");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/CMakeLists.txt b/velox/functions/sparksql/tests/CMakeLists.txt
index 26dd66af053f..ad1b5833d4e7 100644
--- a/velox/functions/sparksql/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/tests/CMakeLists.txt
@@ -28,7 +28,9 @@ add_executable(
   ArrayUnionTest.cpp
   ArgTypesGeneratorTest.cpp
   AtLeastNNonNullsTest.cpp
+  Base64Test.cpp
   BitwiseTest.cpp
+  CharTypeWriteSideCheckTest.cpp
   ComparisonsTest.cpp
   ConcatWsTest.cpp
   DateTimeFunctionsTest.cpp
@@ -39,9 +41,12 @@ add_executable(
   ElementAtTest.cpp
   FactorialTest.cpp
   FromJsonTest.cpp
+  FromToJsonRoundTripTest.cpp
+  GetArrayStructFieldsTest.cpp
   GetJsonObjectTest.cpp
   GetStructFieldTest.cpp
   HashTest.cpp
+  InitcapTest.cpp
   InTest.cpp
   JsonArrayLengthTest.cpp
   JsonObjectKeysTest.cpp
@@ -56,6 +61,7 @@ add_executable(
   MonotonicallyIncreasingIdTest.cpp
   RaiseErrorTest.cpp
   RandTest.cpp
+  ReadSidePaddingFunctionTest.cpp
   RegexFunctionsTest.cpp
   SliceTest.cpp
   SizeTest.cpp
@@ -65,9 +71,14 @@ add_executable(
   SplitTest.cpp
   StringTest.cpp
   StringToMapTest.cpp
+  ToJsonTest.cpp
+  UnBase64Test.cpp
   UnscaledValueFunctionTest.cpp
+  UpperLowerTest.cpp
   UuidTest.cpp
-  XxHash64Test.cpp)
+  VarcharTypeWriteSideCheckTest.cpp
+  XxHash64Test.cpp
+)
 
 add_test(velox_functions_spark_test velox_functions_spark_test)
 
@@ -81,7 +92,8 @@ target_link_libraries(
   fmt::fmt
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
 
 add_executable(velox_spark_function_registry_test RegisterTest.cpp)
 
@@ -92,4 +104,5 @@ target_link_libraries(
   velox_expression
   velox_functions_spark
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/functions/sparksql/tests/CharTypeWriteSideCheckTest.cpp b/velox/functions/sparksql/tests/CharTypeWriteSideCheckTest.cpp
new file mode 100644
index 000000000000..eb73809d6090
--- /dev/null
+++ b/velox/functions/sparksql/tests/CharTypeWriteSideCheckTest.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"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class CharTypeWriteSideCheckTest : public SparkFunctionBaseTest {
+ protected:
+  auto charTypeWriteSideCheck(
+      const std::optional<std::string>& input,
+      const std::optional<int32_t>& limit) {
+    return evaluateOnce<std::string>(
+        "char_type_write_side_check(c0, c1)", input, limit);
+  }
+};
+
+TEST_F(CharTypeWriteSideCheckTest, ascii) {
+  // Case 1: String length equals limit (return as-is).
+  EXPECT_EQ(charTypeWriteSideCheck("abc", 3), "abc");
+
+  // Case 2: String length < limit (pad with spaces to reach limit).
+  EXPECT_EQ(charTypeWriteSideCheck("a", 3), "a  ");
+  EXPECT_EQ(charTypeWriteSideCheck("ab", 3), "ab ");
+  EXPECT_EQ(charTypeWriteSideCheck("", 3), "   ");
+
+  // Case 3: String length > limit (try trimming trailing spaces).
+  // Case 3a: Successful trimming (exactly fits after trimming).
+  EXPECT_EQ(charTypeWriteSideCheck("abc  ", 3), "abc");
+
+  // Case 3b: Successful trimming but contain spare spaces to fit the limit.
+  EXPECT_EQ(charTypeWriteSideCheck("a   ", 2), "a ");
+}
+
+TEST_F(CharTypeWriteSideCheckTest, unicode) {
+  // Case 1: String length equals limit (return as-is).
+  EXPECT_EQ(charTypeWriteSideCheck("世界", 2), "世界");
+  EXPECT_EQ(charTypeWriteSideCheck("a世", 2), "a世");
+  EXPECT_EQ(charTypeWriteSideCheck("Привет", 6), "Привет"); // Cyrillic
+  EXPECT_EQ(charTypeWriteSideCheck("Γειά", 4), "Γειά"); // Greek
+
+  // Case 2: String length < limit (pad with spaces to reach limit).
+  EXPECT_EQ(charTypeWriteSideCheck("世", 3), "世  ");
+  EXPECT_EQ(charTypeWriteSideCheck("世界", 3), "世界 ");
+  EXPECT_EQ(charTypeWriteSideCheck("При", 6), "При   ");
+  EXPECT_EQ(charTypeWriteSideCheck("Γει", 4), "Γει ");
+
+  // Case 3: String length > limit (try trimming trailing spaces).
+  EXPECT_EQ(charTypeWriteSideCheck("世界   ", 2), "世界");
+  EXPECT_EQ(charTypeWriteSideCheck("a世  ", 2), "a世");
+  EXPECT_EQ(charTypeWriteSideCheck("世   ", 2), "世 ");
+  EXPECT_EQ(charTypeWriteSideCheck("Привет   ", 6), "Привет");
+  EXPECT_EQ(charTypeWriteSideCheck("Γειά ", 4), "Γειά");
+}
+
+TEST_F(CharTypeWriteSideCheckTest, error) {
+  // Error cases - string length > limit even after trimming trailing spaces.
+  VELOX_ASSERT_USER_THROW(
+      charTypeWriteSideCheck("abcd", 3),
+      "Exceeds allowed length limitation: 3");
+  VELOX_ASSERT_USER_THROW(
+      charTypeWriteSideCheck("世界人", 2),
+      "Exceeds allowed length limitation: 2");
+  VELOX_ASSERT_USER_THROW(
+      charTypeWriteSideCheck("a世界b", 3),
+      "Exceeds allowed length limitation: 3");
+  VELOX_ASSERT_USER_THROW(
+      charTypeWriteSideCheck("Приветик", 6),
+      "Exceeds allowed length limitation: 6");
+  VELOX_ASSERT_USER_THROW(
+      charTypeWriteSideCheck("Γειάσου", 4),
+      "Exceeds allowed length limitation: 4");
+
+  // Edge cases - length limit must be positive.
+  VELOX_ASSERT_USER_THROW(
+      charTypeWriteSideCheck("a", 0),
+      "The length limit must be greater than 0.");
+  VELOX_ASSERT_USER_THROW(
+      charTypeWriteSideCheck("abc", -1),
+      "The length limit must be greater than 0.");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp b/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
index 80584844bb10..ce7bd74337ef 100644
--- a/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
+++ b/velox/functions/sparksql/tests/DateTimeFunctionsTest.cpp
@@ -70,6 +70,11 @@ class DateTimeFunctionsTest : public SparkFunctionBaseTest {
              makeNullableFlatVector(
                  std::vector<std::optional<TValue>>{value})}));
   }
+
+  template <typename T>
+  auto secondsToTimestamp(T seconds) {
+    return evaluateOnce<Timestamp, T>("timestamp_seconds(c0)", seconds);
+  }
 };
 
 TEST_F(DateTimeFunctionsTest, toUtcTimestamp) {
@@ -96,6 +101,9 @@ TEST_F(DateTimeFunctionsTest, toUtcTimestamp) {
   EXPECT_EQ(
       "2015-01-23T16:00:00.000000000",
       toUtcTimestamp("2015-01-24 00:00:00", "+08:00"));
+  EXPECT_EQ(
+      "2024-03-10T08:01:58.000000000",
+      toUtcTimestamp("2024-03-10 02:01:58", "America/Chicago"));
   VELOX_ASSERT_THROW(
       toUtcTimestamp("2015-01-24 00:00:00", "Asia/Ooty"),
       "Unknown time zone: 'Asia/Ooty'");
@@ -310,6 +318,11 @@ TEST_F(DateTimeFunctionsTest, unixTimestampCustomFormat) {
   EXPECT_EQ(
       std::nullopt,
       unixTimestamp("2022-12-12 asd 07:45:31", "yyyy-MM-dd 'asd HH:mm:ss"));
+
+  setQueryTimeZone("America/Chicago");
+  // Verify the gap time 2024-03-10 02:01:58 is correctly handled.
+  EXPECT_EQ(
+      1710057718, unixTimestamp("2024-03-10 02:01:58", "yyyy-MM-dd HH:mm:ss"));
 }
 
 TEST_F(DateTimeFunctionsTest, unixTimestampTimestampInput) {
@@ -814,6 +827,12 @@ TEST_F(DateTimeFunctionsTest, getTimestamp) {
       getTimestampString("2023/12/08 08:20:19", "yyyy/MM/dd HH:mm:ss"),
       "2023-12-08T08:20:19.000000000");
 
+  // Verify the gap time is correctly handled.
+  setQueryTimeZone("America/Chicago");
+  EXPECT_EQ(
+      getTimestampString("2024-03-10 02:01:58", "yyyy-MM-dd HH:mm:ss"),
+      "2024-03-10T08:01:58.000000000");
+
   // 8 hours ahead UTC.
   setQueryTimeZone("Asia/Shanghai");
   EXPECT_EQ(
@@ -1132,6 +1151,119 @@ TEST_F(DateTimeFunctionsTest, millisToTimestamp) {
       parseTimestamp("-292275055-05-16 16:47:04.192"));
 }
 
+TEST_F(DateTimeFunctionsTest, secondsToTimestamp) {
+  // Tests using integer seconds as input.
+  EXPECT_EQ(
+      secondsToTimestamp<int8_t>(1), parseTimestamp("1970-01-01 00:00:01"));
+  EXPECT_EQ(
+      secondsToTimestamp<int8_t>(-1), parseTimestamp("1969-12-31 23:59:59"));
+  EXPECT_EQ(
+      secondsToTimestamp<int16_t>(1), parseTimestamp("1970-01-01 00:00:01"));
+  EXPECT_EQ(
+      secondsToTimestamp<int16_t>(-1), parseTimestamp("1969-12-31 23:59:59"));
+  EXPECT_EQ(
+      secondsToTimestamp<int32_t>(1), parseTimestamp("1970-01-01 00:00:01"));
+  EXPECT_EQ(
+      secondsToTimestamp<int32_t>(-1), parseTimestamp("1969-12-31 23:59:59"));
+  EXPECT_EQ(
+      secondsToTimestamp<int64_t>(1), parseTimestamp("1970-01-01 00:00:01"));
+  EXPECT_EQ(
+      secondsToTimestamp<int64_t>(-1), parseTimestamp("1969-12-31 23:59:59"));
+  EXPECT_EQ(
+      secondsToTimestamp<int64_t>(1230219000),
+      parseTimestamp("2008-12-25 15:30:00"));
+  EXPECT_EQ(
+      secondsToTimestamp<int64_t>(253402300799),
+      parseTimestamp("9999-12-31 23:59:59"));
+  EXPECT_EQ(
+      secondsToTimestamp<int64_t>(-62167219200),
+      parseTimestamp("0000-01-01 0:0:0"));
+  EXPECT_EQ(
+      secondsToTimestamp<int8_t>(kMaxTinyint),
+      parseTimestamp("1970-01-01 00:02:07"));
+  EXPECT_EQ(
+      secondsToTimestamp<int8_t>(kMinTinyint),
+      parseTimestamp("1969-12-31 23:57:52"));
+  EXPECT_EQ(
+      secondsToTimestamp<int16_t>(kMaxSmallint),
+      parseTimestamp("1970-01-01 09:06:07"));
+  EXPECT_EQ(
+      secondsToTimestamp<int16_t>(kMinSmallint),
+      parseTimestamp("1969-12-31 14:53:52"));
+  EXPECT_EQ(
+      secondsToTimestamp<int32_t>(kMax), parseTimestamp("2038-01-19 03:14:07"));
+  EXPECT_EQ(
+      secondsToTimestamp<int32_t>(kMin), parseTimestamp("1901-12-13 20:45:52"));
+
+  // Tests using floating-point seconds as input.
+  EXPECT_EQ(
+      secondsToTimestamp<float>(1.0), parseTimestamp("1970-01-01 00:00:01"));
+  EXPECT_EQ(
+      secondsToTimestamp<float>(-1.0), parseTimestamp("1969-12-31 23:59:59"));
+  EXPECT_EQ(
+      secondsToTimestamp<float>(1.1234567),
+      parseTimestamp("1970-01-01 00:00:01.123456"));
+  EXPECT_EQ(
+      secondsToTimestamp<float>(std::numeric_limits<float>::max()),
+      parseTimestamp("+294247-01-10 04:00:54.775807"));
+  EXPECT_EQ(
+      secondsToTimestamp<float>(std::numeric_limits<float>::lowest()),
+      parseTimestamp("-290308-12-21 19:59:05.224192"));
+  EXPECT_EQ(
+      secondsToTimestamp<float>(std::numeric_limits<float>::quiet_NaN()),
+      std::nullopt);
+  EXPECT_EQ(
+      secondsToTimestamp<float>(std::numeric_limits<float>::infinity()),
+      std::nullopt);
+
+  // Tests using double seconds as input.
+  EXPECT_EQ(
+      secondsToTimestamp<double>(1.0), parseTimestamp("1970-01-01 00:00:01"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(-1.0), parseTimestamp("1969-12-31 23:59:59"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(1230219000.123),
+      parseTimestamp("2008-12-25 15:30:00.123"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(0.127),
+      parseTimestamp("1970-01-01 00:00:00.127"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(-0.128),
+      parseTimestamp("1969-12-31 23:59:59.872"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(32.767),
+      parseTimestamp("1970-01-01 00:00:32.767"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(-32.768),
+      parseTimestamp("1969-12-31 23:59:27.232"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(20.523),
+      parseTimestamp("1970-01-01 00:00:20.523"));
+  EXPECT_EQ(
+      secondsToTimestamp(-20.524), parseTimestamp("1969-12-31 23:59:39.476"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(2147483647.123),
+      parseTimestamp("2038-01-19 03:14:07.123"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(-2147483648.567),
+      parseTimestamp("1901-12-13 20:45:51.433"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(1.1234567),
+      parseTimestamp("1970-01-01 00:00:01.123456"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(std::numeric_limits<double>::lowest()),
+      parseTimestamp("-290308-12-21 19:59:05.224192"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(std::numeric_limits<double>::max()),
+      parseTimestamp("+294247-01-10 04:00:54.775807"));
+  EXPECT_EQ(
+      secondsToTimestamp<double>(std::numeric_limits<double>::quiet_NaN()),
+      std::nullopt);
+  EXPECT_EQ(
+      secondsToTimestamp<double>(std::numeric_limits<double>::infinity()),
+      std::nullopt);
+}
+
 TEST_F(DateTimeFunctionsTest, timestampToMicros) {
   const auto timestampToMicros = [&](const StringView time) {
     return evaluateOnce<int64_t, Timestamp>(
@@ -1261,5 +1393,513 @@ TEST_F(DateTimeFunctionsTest, dateTrunc) {
       Timestamp(978336000, 0),
       dateTrunc("year", Timestamp(998'474'645, 321'001'234)));
 }
+
+TEST_F(DateTimeFunctionsTest, trunc) {
+  const auto trunc = [&](std::optional<int32_t> date,
+                         const std::string& format) {
+    return evaluateOnce<int32_t>(
+        fmt::format("trunc(c0, '{}')", format), DATE(), date);
+  };
+
+  // Date(0) is 1970-01-01.
+  EXPECT_EQ(std::nullopt, trunc(0, ""));
+  EXPECT_EQ(std::nullopt, trunc(0, "day"));
+  EXPECT_EQ(std::nullopt, trunc(0, "hour"));
+  EXPECT_EQ(std::nullopt, trunc(0, "minute"));
+  EXPECT_EQ(std::nullopt, trunc(0, "second"));
+  EXPECT_EQ(std::nullopt, trunc(0, "millisecond"));
+  EXPECT_EQ(std::nullopt, trunc(0, "microsecond"));
+
+  // Date(19576) is 2023-08-07, which is Monday, should return Monday.
+  EXPECT_EQ(19576, trunc(19576, "week"));
+  // Date(19579) is 2023-08-10, Thur, should return Monday.
+  EXPECT_EQ(19576, trunc(19579, "week"));
+  // Date(18297) is 2020-02-05.
+  EXPECT_EQ(18293, trunc(18297, "month"));
+  EXPECT_EQ(18262, trunc(18297, "quarter"));
+  EXPECT_EQ(18262, trunc(18297, "year"));
+}
+
+TEST_F(DateTimeFunctionsTest, timestampdiff) {
+  const auto timestampDiff = [&](const std::string& unit,
+                                 std::optional<Timestamp> timestamp1,
+                                 std::optional<Timestamp> timestamp2) {
+    return evaluateOnce<int64_t>(
+        fmt::format("timestampdiff('{}', c0, c1)", unit),
+        timestamp1,
+        timestamp2);
+  };
+  EXPECT_EQ(
+      9,
+      timestampDiff(
+          "year",
+          parseTimestamp("2020-02-28 10:00:00.500"),
+          parseTimestamp("2030-02-27 10:00:00.500")));
+  // Check null behaviors.
+  EXPECT_EQ(
+      std::nullopt, timestampDiff("second", Timestamp(1, 0), std::nullopt));
+  EXPECT_EQ(
+      std::nullopt, timestampDiff("month", std::nullopt, Timestamp(0, 0)));
+
+  // Check invalid units.
+  VELOX_ASSERT_THROW(
+      timestampDiff("invalid_unit", Timestamp(1, 0), Timestamp(0, 0)),
+      "Unsupported datetime unit: invalid_unit");
+
+  // Simple tests.
+  EXPECT_EQ(
+      60 * 1000000 + 500999,
+      timestampDiff(
+          "microsecond",
+          parseTimestamp("2019-02-28 10:00:00.000000"),
+          parseTimestamp("2019-02-28 10:01:00.500999")));
+
+  EXPECT_EQ(
+      60 * 1000 + 500,
+      timestampDiff(
+          "millisecond",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-02-28 10:01:01.000")));
+  EXPECT_EQ(
+      60 * 60 * 24,
+      timestampDiff(
+          "second",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
+  EXPECT_EQ(
+      60 * 24,
+      timestampDiff(
+          "minute",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
+  EXPECT_EQ(
+      24,
+      timestampDiff(
+          "hour",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "day",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
+  EXPECT_EQ(
+      0,
+      timestampDiff(
+          "week",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-01 10:00:00.500")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "week",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2019-03-10 10:00:00.500")));
+  EXPECT_EQ(
+      12 + 1,
+      timestampDiff(
+          "month",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2020-03-28 10:00:00.500")));
+  EXPECT_EQ(
+      4,
+      timestampDiff(
+          "quarter",
+          parseTimestamp("2019-02-28 10:00:00.500"),
+          parseTimestamp("2020-02-28 10:00:00.500")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "year",
+          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.
+  // When adjust_timestamp_to_timezone is off, Daylight saving occurs in UTC.
+  EXPECT_EQ(
+      1000 * 60 * 60 * 24,
+      timestampDiff(
+          "millisecond",
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
+  EXPECT_EQ(
+      60 * 60 * 24,
+      timestampDiff(
+          "second",
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
+  EXPECT_EQ(
+      60 * 24,
+      timestampDiff(
+          "minute",
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
+  EXPECT_EQ(
+      24,
+      timestampDiff(
+          "hour",
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "day",
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-03-15 01:00:00.000")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "month",
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-04-14 01:00:00.000")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "quarter",
+          parseTimestamp("2021-03-14 01:00:00.000"),
+          parseTimestamp("2021-06-14 01:00:00.000")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "year",
+          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.
+  setQueryTimeZone("America/Los_Angeles");
+
+  EXPECT_EQ(
+      1000 * 60 * 60 * 24,
+      timestampDiff(
+          "millisecond",
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
+  EXPECT_EQ(
+      60 * 60 * 24,
+      timestampDiff(
+          "second",
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
+  EXPECT_EQ(
+      60 * 24,
+      timestampDiff(
+          "minute",
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
+  EXPECT_EQ(
+      24,
+      timestampDiff(
+          "hour",
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "day",
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-03-15 09:00:00.000")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "month",
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-04-14 09:00:00.000")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "quarter",
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2021-06-14 09:00:00.000")));
+  EXPECT_EQ(
+      1,
+      timestampDiff(
+          "year",
+          parseTimestamp("2021-03-14 09:00:00.000"),
+          parseTimestamp("2022-03-14 09:00:00.000")));
+
+  // Test for not respecting the last day of a year-month.
+  EXPECT_EQ(
+      12,
+      timestampDiff(
+          "month",
+          parseTimestamp("2019-01-30 10:00:00.500"),
+          parseTimestamp("2020-02-29 10:00:00.500")));
+  EXPECT_EQ(
+      0,
+      timestampDiff(
+          "quarter",
+          parseTimestamp("2019-11-30 10:00:00.500"),
+          parseTimestamp("2020-02-29 10:00:00.500")));
+  EXPECT_EQ(
+      9,
+      timestampDiff(
+          "year",
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2030-02-28 10:00:00.500")));
+
+  // Test for negative difference.
+  EXPECT_EQ(
+      -60 * 1000000 - 500999,
+      timestampDiff(
+          "microsecond",
+          parseTimestamp("2019-02-28 10:01:00.500999"),
+          parseTimestamp("2019-02-28 10:00:00.000000")));
+  EXPECT_EQ(
+      -60 * 60 * 24 * 1000 - 500,
+      timestampDiff(
+          "millisecond",
+          parseTimestamp("2020-03-01 00:00:00.500"),
+          parseTimestamp("2020-02-29 00:00:00.000")));
+  EXPECT_EQ(
+      -60 * 60 * 24,
+      timestampDiff(
+          "second",
+          parseTimestamp("2020-03-01 00:00:00.500"),
+          parseTimestamp("2020-02-29 00:00:00.500")));
+  EXPECT_EQ(
+      -60 * 24,
+      timestampDiff(
+          "minute",
+          parseTimestamp("2020-03-01 00:00:00.500"),
+          parseTimestamp("2020-02-29 00:00:00.500")));
+  EXPECT_EQ(
+      -24,
+      timestampDiff(
+          "hour",
+          parseTimestamp("2020-03-01 00:00:00.500"),
+          parseTimestamp("2020-02-29 00:00:00.500")));
+  EXPECT_EQ(
+      -366,
+      timestampDiff(
+          "day",
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2019-02-28 10:00:00.500")));
+  EXPECT_EQ(
+      -12,
+      timestampDiff(
+          "month",
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2019-02-28 10:00:00.500")));
+  EXPECT_EQ(
+      -4,
+      timestampDiff(
+          "quarter",
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2019-02-28 10:00:00.500")));
+  EXPECT_EQ(
+      -2,
+      timestampDiff(
+          "year",
+          parseTimestamp("2020-02-29 10:00:00.500"),
+          parseTimestamp("2018-02-28 10:00:00.500")));
+}
+
+TEST_F(DateTimeFunctionsTest, timestampadd) {
+  const auto timestampadd = [&](const std::string& unit,
+                                std::optional<int32_t> value,
+                                std::optional<Timestamp> timestamp) {
+    return evaluateOnce<Timestamp>(
+        fmt::format("timestampadd('{}', c0, c1)", unit), value, timestamp);
+  };
+
+  const auto timestampaddBigint = [&](const std::string& unit,
+                                      std::optional<int64_t> value,
+                                      std::optional<Timestamp> timestamp) {
+    return evaluateOnce<Timestamp>(
+        fmt::format("timestampadd('{}', c0, c1)", unit), value, timestamp);
+  };
+
+  // Check null behaviors.
+  EXPECT_EQ(std::nullopt, timestampadd("second", 1, std::nullopt));
+  EXPECT_EQ(std::nullopt, timestampadd("month", std::nullopt, Timestamp(0, 0)));
+  EXPECT_EQ(
+      std::nullopt, timestampaddBigint("month", std::nullopt, Timestamp(0, 0)));
+
+  // Check invalid units.
+  VELOX_ASSERT_THROW(
+      timestampadd("invalid_unit", 1, Timestamp(0, 0)),
+      "Unsupported datetime unit: invalid_unit");
+  VELOX_ASSERT_THROW(
+      timestampaddBigint("invalid_unit", 1, Timestamp(0, 0)),
+      "Unsupported datetime unit: invalid_unit");
+
+  EXPECT_EQ(
+      Timestamp(1551348061, 999) /*2019-02-28 10:01:01.000000*/,
+      timestampadd(
+          "microsecond",
+          60 * 1000000 + 500,
+          Timestamp(1551348000, 999'500'999) /*2019-02-28 10:00:00.999500*/));
+  EXPECT_EQ(
+      Timestamp(1551348061, 999) /*2019-02-28 10:01:01.000000*/,
+      timestampaddBigint(
+          "microsecond",
+          60 * 1000000 + 500,
+          Timestamp(1551348000, 999'500'999) /*2019-02-28 10:00:00.999500*/));
+  EXPECT_EQ(
+      Timestamp(1551348061, 999'999) /*2019-02-28 10:01:01.000*/,
+      timestampadd(
+          "millisecond",
+          60 * 1000 + 500,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1551434400, 500'999'999) /*2019-03-01 10:00:00.500*/,
+      timestampadd(
+          "second",
+          60 * 60 * 24,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1551434400, 500'999'999) /*2019-03-01 10:00:00.500*/,
+      timestampadd(
+          "minute",
+          60 * 24,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1551434400, 500'999'999) /*2019-03-01 10:00:00.500*/,
+      timestampadd(
+          "hour",
+          24,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1551434400, 500'999'999) /*2019-03-01 10:00:00.500*/,
+      timestampadd(
+          "day",
+          1,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1551434400, 500'999'999) /*2019-03-01 10:00:00.500*/,
+      timestampadd(
+          "dayofyear",
+          1,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      parseTimestamp("2019-03-07 10:00:00.500"),
+      timestampadd("week", 1, parseTimestamp("2019-02-28 10:00:00.500")));
+  EXPECT_EQ(
+      Timestamp(1585389600, 500'999'999) /*2020-03-28 10:00:00.500*/,
+      timestampadd(
+          "month",
+          12 + 1,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1582884000, 500'999'999) /*2020-02-28 10:00:00.500*/,
+      timestampadd(
+          "quarter",
+          4,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1582884000, 500'999'999) /*2020-02-28 10:00:00.500*/,
+      timestampadd(
+          "year",
+          1,
+          Timestamp(1551348000, 500'999'999) /*2019-02-28 10:00:00.500*/));
+
+  // Test for coercing to the last day of a year-month.
+  EXPECT_EQ(
+      Timestamp(1582970400, 500'999'999) /*2020-02-29 10:00:00.500*/,
+      timestampadd(
+          "day",
+          365 + 30,
+          Timestamp(1548842400, 500'999'999) /*2019-01-30 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1582970400, 500'999'999) /*2020-02-29 10:00:00.500*/,
+      timestampadd(
+          "month",
+          12 + 1,
+          Timestamp(1548842400, 500'999'999) /*2019-01-30 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1582970400, 500'999'999) /*2020-02-29 10:00:00.500*/,
+      timestampadd(
+          "quarter",
+          1,
+          Timestamp(1575108000, 500'999'999) /*2019-11-30 10:00:00.500*/));
+  EXPECT_EQ(
+      Timestamp(1898503200, 500'999'999) /*2030-02-28 10:00:00.500*/,
+      timestampadd(
+          "year",
+          10,
+          Timestamp(1582970400, 500'999'999) /*2020-02-29 10:00:00.500*/));
+}
+
+TEST_F(DateTimeFunctionsTest, monthsBetween) {
+  const auto monthsBetween = [&](std::optional<Timestamp> timestamp1,
+                                 std::optional<Timestamp> timestamp2,
+                                 std::optional<bool> roundOff) {
+    return evaluateOnce<double>(
+        "months_between(c0, c1, c2)", timestamp1, timestamp2, roundOff);
+  };
+
+  EXPECT_EQ(
+      3.94959677,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-10-30"),
+          true));
+  EXPECT_EQ(
+      3.9495967741935485,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-10-30"),
+          false));
+  EXPECT_EQ(
+      3.9495949074074073,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-10-30 00:00:05"),
+          false));
+  EXPECT_EQ(
+      -3.9495949074074073,
+      monthsBetween(
+          parseTimestamp("1996-10-30 00:00:05"),
+          parseTimestamp("1997-02-28 10:30:00"),
+          false));
+  // `timestamp1` and `timestamp2` both are the last day of month.
+  EXPECT_EQ(
+      11,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-03-31 11:00:00"),
+          true));
+  // `timestamp1` and `timestamp2` are on the same day of month.
+  EXPECT_EQ(
+      11,
+      monthsBetween(
+          parseTimestamp("1997-02-28 10:30:00"),
+          parseTimestamp("1996-03-28 11:00:00"),
+          true));
+  EXPECT_EQ(
+      11,
+      monthsBetween(
+          parseTimestamp("1997-02-21 10:30:00"),
+          parseTimestamp("1996-03-21 11:00:00"),
+          true));
+}
+TEST_F(DateTimeFunctionsTest, dateFormat) {
+  const auto dateFormat = [&](std::optional<Timestamp> timestamp,
+                              std::optional<std::string> format) {
+    return evaluateOnce<std::string>("date_format(c0, c1)", timestamp, format);
+  };
+
+  // Check invalid format.
+  EXPECT_THROW(dateFormat(parseTimestamp("1970-01-01"), "u"), VeloxUserError);
+  EXPECT_THROW(
+      dateFormat(parseTimestamp("1970-01-01"), "'abcd"), VeloxUserError);
+
+  // Check Simple tests.
+  EXPECT_EQ("AD", dateFormat(parseTimestamp("1970-01-01"), "G"));
+  EXPECT_EQ("19", dateFormat(parseTimestamp("1900-01-01"), "C"));
+  EXPECT_EQ("2020", dateFormat(parseTimestamp("2020-01-01"), "Y"));
+  EXPECT_EQ("1", dateFormat(parseTimestamp("2022-01-01"), "D"));
+  EXPECT_EQ("1", dateFormat(parseTimestamp("2022-01-01"), "d"));
+  EXPECT_EQ("AM", dateFormat(parseTimestamp("2022-01-01 00:00:00"), "a"));
+  EXPECT_EQ(
+      "2022-01-01 00:00:00",
+      dateFormat(parseTimestamp("2022-01-01"), "yyyy-MM-dd HH:mm:ss"));
+
+  enableLegacyFormatter();
+  EXPECT_EQ("4", dateFormat(parseTimestamp("1970-01-01"), "u"));
+}
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp b/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp
index 63467f4f019b..c2fab631ebb3 100644
--- a/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp
+++ b/velox/functions/sparksql/tests/DecimalArithmeticTest.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/functions/sparksql/DecimalArithmetic.h"
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 
@@ -43,8 +44,9 @@ class DecimalArithmeticTest : public SparkFunctionBaseTest {
         "At least one input vector is needed for arithmetic function test.");
     std::vector<core::TypedExprPtr> inputExprs;
     for (int i = 0; i < inputs.size(); ++i) {
-      inputExprs.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-          inputs[i]->type(), fmt::format("c{}", i)));
+      inputExprs.emplace_back(
+          std::make_shared<core::FieldAccessTypedExpr>(
+              inputs[i]->type(), fmt::format("c{}", i)));
     }
     auto expr = std::make_shared<const core::CallTypedExpr>(
         expected->type(), std::move(inputExprs), functionName);
@@ -68,6 +70,24 @@ class DecimalArithmeticTest : public SparkFunctionBaseTest {
     }
     return makeNullableFlatVector<int128_t>(numbers, type);
   }
+
+  template <typename T, typename U>
+  std::optional<int64_t> div(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u) {
+    return evaluateOnce<int64_t>("div(c0, c1)", {tType, uType}, t, u);
+  }
+
+  template <typename T, typename U>
+  std::optional<int64_t> checked_div(
+      const TypePtr& tType,
+      const TypePtr& uType,
+      std::optional<T> t,
+      std::optional<U> u) {
+    return evaluateOnce<int64_t>("checked_div(c0, c1)", {tType, uType}, t, u);
+  }
 };
 
 TEST_F(DecimalArithmeticTest, add) {
@@ -410,6 +430,21 @@ TEST_F(DecimalArithmeticTest, multiply) {
            1,
            DECIMAL(38, 0)),
        makeConstant<int64_t>(100, 1, DECIMAL(2, 1))});
+
+  testArithmeticFunction(
+      "multiply",
+      makeConstant<int128_t>(
+          HugeInt::parse("9999542798541987451780195064133346831"),
+          1,
+          DECIMAL(38, 23)),
+      {makeConstant<int128_t>(
+           HugeInt::parse("99997713966580193276534859500386083931"),
+           1,
+           DECIMAL(38, 31)),
+       makeConstant<int128_t>(
+           HugeInt::parse("99997713966580193276534859500386083931"),
+           1,
+           DECIMAL(38, 31))});
 }
 
 TEST_F(DecimalArithmeticTest, divide) {
@@ -518,6 +553,17 @@ TEST_F(DecimalArithmeticTest, 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))});
+
+  testArithmeticFunction(
+      "divide",
+      makeConstant<int128_t>(
+          HugeInt::parse("106277793246728545582603"), 1, DECIMAL(38, 6)),
+      {makeConstant<int128_t>(
+           HugeInt::parse("104352831492914033"), 1, DECIMAL(19, 0)),
+       makeConstant<int128_t>(
+           HugeInt::parse("98188745084925098440983457564770612914"),
+           1,
+           DECIMAL(38, 38))});
 }
 
 TEST_F(DecimalArithmeticTest, denyPrecisionLoss) {
@@ -687,5 +733,105 @@ TEST_F(DecimalArithmeticTest, ceil) {
            0},
           DECIMAL(19, 19))});
 }
+
+TEST_F(DecimalArithmeticTest, div) {
+  EXPECT_EQ((div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 10, 200)), 0L);
+  EXPECT_EQ((div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 24, 110)), 2L);
+  EXPECT_EQ((div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 12, 110)), 1L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 20, 0)),
+      std::nullopt);
+  EXPECT_EQ((div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 91, 200)), 4L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 100, 200)), 5L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), -92, 200)), -4L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 100, -190)), -5L);
+  EXPECT_EQ(
+      (div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), -100, -190)), 5L);
+
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 10, 200)), 0L);
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 24, 110)), 2L);
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 12, 110)), 1L);
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 20, 0L)),
+      std::nullopt);
+  EXPECT_EQ(
+      (div<int64_t, int128_t>(
+          DECIMAL(7, 1),
+          DECIMAL(38, 2),
+          0,
+          HugeInt::parse("99999999999999999999999999999999999999"))),
+      0L);
+
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(DECIMAL(38, 1), DECIMAL(7, 4), 10, 20000)), 0L);
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(DECIMAL(38, 1), DECIMAL(7, 4), 25, 11000)), 2L);
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(DECIMAL(38, 1), DECIMAL(7, 4), 26, 11000)), 2L);
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(DECIMAL(38, 1), DECIMAL(7, 4), 20, 0L)),
+      std::nullopt);
+  EXPECT_EQ(
+      (div<int128_t, int64_t>(
+          DECIMAL(38, 1),
+          DECIMAL(7, 4),
+          HugeInt::parse("99999999999999999999999999999999999"),
+          1L)),
+      687399551400672280L);
+
+  EXPECT_EQ(
+      (div<int128_t, int128_t>(DECIMAL(38, 0), DECIMAL(38, 6), 10, 2100000)),
+      4L);
+  EXPECT_EQ(
+      (div<int128_t, int128_t>(DECIMAL(38, 0), DECIMAL(38, 6), 10, 2900000)),
+      3L);
+  EXPECT_EQ(
+      (div<int128_t, int128_t>(DECIMAL(38, 0), DECIMAL(38, 6), 20, 0)),
+      std::nullopt);
+  EXPECT_EQ(
+      (div<int128_t, int128_t>(
+          DECIMAL(38, 0),
+          DECIMAL(38, 6),
+          HugeInt::parse("99999999999999999999999999999999999999"),
+          1)),
+      std::nullopt);
+}
+
+TEST_F(DecimalArithmeticTest, checkedDiv) {
+  EXPECT_EQ(
+      (checked_div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 10, 200)),
+      0L);
+  EXPECT_EQ(
+      (checked_div<int64_t, int128_t>(DECIMAL(7, 1), DECIMAL(38, 2), 12, 110)),
+      1L);
+  EXPECT_EQ(
+      (checked_div<int128_t, int64_t>(
+          DECIMAL(38, 1), DECIMAL(7, 4), 25, 11000)),
+      2L);
+  EXPECT_EQ(
+      (checked_div<int128_t, int128_t>(
+          DECIMAL(38, 0), DECIMAL(38, 6), 10, 2900000)),
+      3L);
+
+  VELOX_ASSERT_USER_THROW(
+      (checked_div<int64_t, int64_t>(DECIMAL(7, 1), DECIMAL(8, 2), 91, 0)),
+      "Division by zero");
+  VELOX_ASSERT_USER_THROW(
+      (checked_div<int128_t, int128_t>(DECIMAL(37, 1), DECIMAL(38, 2), 91, 0)),
+      "Division by zero");
+  VELOX_ASSERT_USER_THROW(
+      (checked_div<int128_t, int128_t>(
+          DECIMAL(38, 0),
+          DECIMAL(38, 6),
+          HugeInt::parse("99999999999999999999999999999999999999"),
+          1)),
+      "Overflow in integral divide");
+}
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/DecimalRoundTest.cpp b/velox/functions/sparksql/tests/DecimalRoundTest.cpp
index 4ac674a467db..c1f6dc4d5784 100644
--- a/velox/functions/sparksql/tests/DecimalRoundTest.cpp
+++ b/velox/functions/sparksql/tests/DecimalRoundTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/functions/sparksql/specialforms/DecimalRound.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 
 namespace facebook::velox::functions::sparksql::test {
@@ -34,14 +35,16 @@ class DecimalRoundTest : public SparkFunctionBaseTest {
       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*/));
+        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)));
+        inputs.emplace_back(
+            std::make_shared<core::ConstantTypedExpr>(
+                INTEGER(), variant(scale)));
       }
     }
 
diff --git a/velox/functions/sparksql/tests/DecimalUtilTest.cpp b/velox/functions/sparksql/tests/DecimalUtilTest.cpp
index 1b63019ed12a..8eef6858de74 100644
--- a/velox/functions/sparksql/tests/DecimalUtilTest.cpp
+++ b/velox/functions/sparksql/tests/DecimalUtilTest.cpp
@@ -35,6 +35,19 @@ class DecimalUtilTest : public testing::Test {
     ASSERT_EQ(overflow, expectedOverflow);
     ASSERT_EQ(r, expectedResult);
   }
+
+  template <bool allowPrecisionLoss>
+  void testComputeDivideResultPrecisionScale(
+      const uint8_t aPrecision,
+      const uint8_t aScale,
+      const uint8_t bPrecision,
+      const uint8_t bScale,
+      std::pair<uint8_t, uint8_t> expected) {
+    ASSERT_EQ(
+        DecimalUtil::computeDivideResultPrecisionScale<allowPrecisionLoss>(
+            aPrecision, aScale, bPrecision, bScale),
+        expected);
+  }
 };
 } // namespace
 
@@ -72,4 +85,19 @@ TEST_F(DecimalUtilTest, bounded) {
   testBounded(40, 3, {38, 3});
   testBounded(44, 42, {38, 38});
 }
+
+TEST_F(DecimalUtilTest, computeDivideResultPrecisionScale) {
+  // Test with allowPrecisionLoss = true.
+  testComputeDivideResultPrecisionScale<true>(10, 2, 5, 1, {17, 8});
+  testComputeDivideResultPrecisionScale<true>(38, 10, 10, 5, {38, 6});
+  testComputeDivideResultPrecisionScale<true>(1, 0, 1, 0, {7, 6});
+  testComputeDivideResultPrecisionScale<true>(20, 2, 20, 2, {38, 18});
+
+  // Test with allowPrecisionLoss = false.
+  testComputeDivideResultPrecisionScale<false>(10, 2, 5, 1, {17, 8});
+  testComputeDivideResultPrecisionScale<false>(38, 10, 5, 3, {38, 11});
+  testComputeDivideResultPrecisionScale<false>(1, 0, 1, 0, {7, 6});
+  testComputeDivideResultPrecisionScale<false>(30, 5, 10, 5, {38, 11});
+}
+
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/FromJsonTest.cpp b/velox/functions/sparksql/tests/FromJsonTest.cpp
index 117ca6ebd244..0e27100a092f 100644
--- a/velox/functions/sparksql/tests/FromJsonTest.cpp
+++ b/velox/functions/sparksql/tests/FromJsonTest.cpp
@@ -13,29 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <limits>
 #include "velox/common/base/tests/GTestUtils.h"
-#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+#include "velox/functions/sparksql/tests/JsonTestUtil.h"
 
 using namespace facebook::velox::test;
 
 namespace facebook::velox::functions::sparksql::test {
 namespace {
-constexpr float kNaNFloat = std::numeric_limits<float>::quiet_NaN();
-constexpr float kInfFloat = std::numeric_limits<float>::infinity();
-constexpr double kNaNDouble = std::numeric_limits<double>::quiet_NaN();
-constexpr double kInfDouble = std::numeric_limits<double>::infinity();
-
 class FromJsonTest : public SparkFunctionBaseTest {
  protected:
-  core::CallTypedExprPtr createFromJson(const TypePtr& outputType) {
-    std::vector<core::TypedExprPtr> inputs = {
-        std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0")};
-
-    return std::make_shared<const core::CallTypedExpr>(
-        outputType, std::move(inputs), "from_json");
-  }
-
   void testFromJson(const VectorPtr& input, const VectorPtr& expected) {
     auto expr = createFromJson(expected->type());
     testEncodings(expr, {input}, expected);
@@ -121,25 +107,41 @@ TEST_F(FromJsonTest, basicBigInt) {
 
 TEST_F(FromJsonTest, basicFloat) {
   auto expected = makeNullableFlatVector<float>(
-      {1.0,
-       2.0,
-       std::nullopt,
-       kNaNFloat,
-       -kInfFloat,
-       -kInfFloat,
-       kInfFloat,
-       kInfFloat,
-       kInfFloat});
+      {1.0,          2.0,          -3.4028235E38, 3.4028235E38, -kInfFloat,
+       kInfFloat,    0.0,          0.0,           std::nullopt, std::nullopt,
+       std::nullopt, std::nullopt, std::nullopt,  std::nullopt, std::nullopt,
+       std::nullopt, kNaNFloat,    kNaNFloat,     -kInfFloat,   -kInfFloat,
+       -kInfFloat,   -kInfFloat,   kInfFloat,     kInfFloat,    kInfFloat,
+       kInfFloat,    kInfFloat,    kInfFloat});
   auto input = makeFlatVector<std::string>(
       {R"({"a": 1})",
        R"({"a": 2.0})",
+       R"({"a": -3.4028235E38})", // Min float value
+       R"({"a": 3.4028235E38})", // Max float value
+       R"({"a": -3.4028235E39})",
+       R"({"a": 3.4028235E39})",
+       R"({"a": 0})",
+       R"({"a": 1.0e-200})",
        R"({"a": "3"})",
+       R"({"a": 1.1.0})", // Multiple decimal points.
+       R"({"a": 1.})", // Missing fraction digits after a decimal point.
+       R"({"a": 01})", // Leading zero.
+       R"({"a": 1e})", // Missing exponent digits after ‘e’ or ‘E’.
+       R"({"a": 1e+})", // Missing exponent digits after ‘e’ or ‘E’.
+       R"({"a": .e10})", // Missing digits.
+       R"({"a": -.})", // Missing digits entirely.
        R"({"a": "NaN"})",
+       R"({"a": NaN})",
        R"({"a": "-Infinity"})",
+       R"({"a": -Infinity})",
        R"({"a": "-INF"})",
+       R"({"a": -INF})",
        R"({"a": "+Infinity"})",
+       R"({"a": +Infinity})",
        R"({"a": "Infinity"})",
-       R"({"a": "+INF"})"});
+       R"({"a": Infinity})",
+       R"({"a": "+INF"})",
+       R"({"a": +INF})"});
   testFromJson(input, makeRowVector({"a"}, {expected}));
 }
 
@@ -147,23 +149,61 @@ TEST_F(FromJsonTest, basicDouble) {
   auto expected = makeNullableFlatVector<double>(
       {1.0,
        2.0,
+       -1.7976931348623158e+308,
+       1.7976931348623158e+308,
+       -kInfDouble,
+       kInfDouble,
+       0.0,
+       0.0,
+       std::nullopt,
        std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       std::nullopt,
+       kNaNDouble,
        kNaNDouble,
        -kInfDouble,
        -kInfDouble,
+       -kInfDouble,
+       -kInfDouble,
+       kInfDouble,
+       kInfDouble,
+       kInfDouble,
        kInfDouble,
        kInfDouble,
        kInfDouble});
   auto input = makeFlatVector<std::string>(
       {R"({"a": 1})",
        R"({"a": 2.0})",
+       R"({"a": -1.7976931348623158e+308})", // Min double value
+       R"({"a": 1.7976931348623158e+308})", // Max double value
+       R"({"a": -1.7976931348623158e+309})",
+       R"({"a": 1.7976931348623158e+309})",
+       R"({"a": 0})",
+       R"({"a": 1.0e-2000})",
        R"({"a": "3"})",
+       R"({"a": 1.1.0})", // Multiple decimal points.
+       R"({"a": 1.})", // Missing fraction digits after a decimal point.
+       R"({"a": 01})", // Leading zero.
+       R"({"a": 1e})", // Missing exponent digits after ‘e’ or ‘E’.
+       R"({"a": 1e+})", // Missing exponent digits after ‘e’ or ‘E’.
+       R"({"a": .e10})", // Missing digits.
+       R"({"a": -.})", // Missing digits entirely.
        R"({"a": "NaN"})",
+       R"({"a": NaN})",
        R"({"a": "-Infinity"})",
+       R"({"a": -Infinity})",
        R"({"a": "-INF"})",
+       R"({"a": -INF})",
        R"({"a": "+Infinity"})",
+       R"({"a": +Infinity})",
        R"({"a": "Infinity"})",
-       R"({"a": "+INF"})"});
+       R"({"a": Infinity})",
+       R"({"a": "+INF"})",
+       R"({"a": +INF})"});
   testFromJson(input, makeRowVector({"a"}, {expected}));
 }
 
@@ -198,6 +238,32 @@ TEST_F(FromJsonTest, basicDate) {
   testFromJson(input, makeRowVector({"a"}, {expected}));
 }
 
+TEST_F(FromJsonTest, basicShortDecimal) {
+  auto expected = makeNullableFlatVector<int64_t>(
+      {53210, -100, std::nullopt, std::nullopt}, DECIMAL(7, 2));
+  auto input = makeFlatVector<std::string>(
+      {R"({"a": "5.321E2"})",
+       R"({"a": -1})",
+       R"({"a": 55555555555555555555.5555})",
+       R"({"a": "+1BD"})"});
+  testFromJson(input, makeRowVector({"a"}, {expected}));
+}
+
+TEST_F(FromJsonTest, basicLongDecimal) {
+  auto expected = makeNullableFlatVector<int128_t>(
+      {53210000,
+       -100000,
+       HugeInt::build(0xffff, 0xffffffffffffffff),
+       std::nullopt},
+      DECIMAL(38, 5));
+  auto input = makeFlatVector<std::string>(
+      {R"({"a": "5.321E2"})",
+       R"({"a": -1})",
+       R"({"a": 12089258196146291747.06175})",
+       R"({"a": "+1BD"})"});
+  testFromJson(input, makeRowVector({"a"}, {expected}));
+}
+
 TEST_F(FromJsonTest, basicString) {
   auto expected = makeNullableFlatVector<StringView>(
       {"1", "2.0", "true", "{\"b\": \"test\"}", "[1, 2]"});
@@ -211,15 +277,115 @@ TEST_F(FromJsonTest, basicString) {
 }
 
 TEST_F(FromJsonTest, nestedComplexType) {
-  auto rowVector = makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 2})});
+  // ARRAY(ROW(BIGINT))
   std::vector<vector_size_t> offsets;
   offsets.push_back(0);
   offsets.push_back(1);
   offsets.push_back(2);
-  auto arrayVector = makeArrayVector(offsets, rowVector);
+  auto arrayVector = makeArrayVector(
+      offsets, makeRowVector({"a"}, {makeFlatVector<int64_t>({1, 2, 2})}));
   auto input = makeFlatVector<std::string>(
       {R"({"a": 1})", R"([{"a": 2}])", R"([{"a": 2}])"});
   testFromJson(input, arrayVector);
+
+  // MAP(ARRAY(ROW(BIGINT, INTEGER)))
+  auto keyVector = makeFlatVector<StringView>({"a", "b", "c"});
+  auto valueVector = makeArrayVector(
+      offsets,
+      makeRowVector(
+          {"d", "e"},
+          {makeFlatVector<int64_t>({1, 2, 3}),
+           makeNullableFlatVector<int32_t>({3, 4, std::nullopt})}));
+  auto mapVector = makeMapVector(offsets, keyVector, valueVector);
+  auto mapInput = makeFlatVector<std::string>(
+      {R"({"a": [{"d": 1, "e": 3}]})",
+       R"({"b": [{"d": 2, "e": 4}]})",
+       R"({"c": [{"d": 3}]})"});
+  testFromJson(mapInput, mapVector);
+
+  // ROW(ROW(ROW(BIGINT, INTEGER)))
+  auto rowVector = makeRowVector(
+      {"a"},
+      {makeRowVector(
+          {"b"},
+          {makeRowVector(
+              {"d1", "e1"},
+              {makeFlatVector<int64_t>({1, 2, 3}),
+               makeNullableFlatVector<int32_t>({3, 4, std::nullopt})})})});
+  auto rowInput = makeFlatVector<std::string>(
+      {R"({"a": {"b": {"d1": 1, "e1": 3, "e1": 4}}})", // Duplicate keys.
+       R"({"a": {"b": {"D1": 2, "e1": 4}}})", // Key case insensitive.
+       R"({"a": {"b": {"d1": 3, "f3": 3}}})"}); // Key not in schema.
+  testFromJson(rowInput, rowVector);
+
+  // ROW(ARRAY[BIGINT], BIGINT)
+  std::vector<vector_size_t> offsets1;
+  offsets1.push_back(0);
+  offsets1.push_back(1);
+  offsets1.push_back(3);
+  auto arrayVector1 =
+      makeArrayVector(offsets1, makeFlatVector<int64_t>({1, 2, 2, 3, 3, 3}));
+  auto rowVector1 = makeRowVector(
+      {"a", "b"}, {arrayVector1, makeFlatVector<int64_t>({1, 2, 3})});
+  auto rowInput1 = makeFlatVector<std::string>(
+      {R"({"a": [1], "b": 1})",
+       R"({"a": [2, 2], "b": 2})",
+       R"({"a": [3, 3, 3], "b": 3})"});
+  testFromJson(rowInput1, rowVector1);
+
+  // ROW(ROW(BIGINT, ARRAY[BIGINT]), ARRAY[BIGINT])
+  auto rowVector2 = makeRowVector(
+      {"a", "b"},
+      {makeRowVector(
+           {"c", "d"}, {makeFlatVector<int64_t>({1, 3, 4}), arrayVector1}),
+       arrayVector1});
+  auto rowInput2 = makeFlatVector<std::string>(
+      {R"({"a": {"c": 1, "d": [1]}, "b": [1]})",
+       R"({"a": {"c": 3, "d": [2, 2]}, "b": [2, 2]})",
+       R"({"a": {"c": 4, "d": [3, 3, 3]}, "b": [3, 3, 3]})"});
+  testFromJson(rowInput2, rowVector2);
+
+  // ROW(ROW(ROW(BIGINT)), ROW(ROW(BIGINT, BIGINT)))
+  auto rowVector3 = makeRowVector(
+      {"a", "d"},
+      {makeRowVector(
+           {"b"}, {makeRowVector({"c"}, {makeFlatVector<int64_t>({1, 2, 3})})}),
+       makeRowVector(
+           {"e"},
+           {makeRowVector(
+               {"f", "g"},
+               {makeFlatVector<int64_t>({1, 2, 3}),
+                makeFlatVector<int64_t>({4, 5, 6})})})});
+  auto rowInput3 = makeFlatVector<std::string>(
+      {R"({"a": {"b": {"c": 1}}, "d": {"e": {"f": 1, "g": 4}}})",
+       R"({"a": {"b": {"c": 2}}, "d": {"e": {"f": 2, "g": 5}}})",
+       R"({"a": {"b": {"c": 3}}, "d": {"e": {"f": 3, "g": 6}}})"});
+  testFromJson(rowInput3, rowVector3);
+
+  // ROW(ARRAY[ROW(BIGINT)], ARRAY[ROW(BIGINT, BIGINT)])
+  std::vector<vector_size_t> offsets2;
+  offsets2.push_back(0);
+  offsets2.push_back(1);
+  offsets2.push_back(2);
+  auto arrayVector3 = makeArrayVector(
+      offsets2,
+      makeRowVector({"c"}, {makeFlatVector<int64_t>({1, 2, 3, 4, 5})}));
+  std::vector<vector_size_t> offsets3;
+  offsets3.push_back(0);
+  offsets3.push_back(1);
+  offsets3.push_back(3);
+  auto arrayVector4 = makeArrayVector(
+      offsets3,
+      makeRowVector(
+          {"d", "e"},
+          {makeFlatVector<int64_t>({3, 2, 2, 1}),
+           makeFlatVector<int64_t>({7, 4, 8, 9})}));
+  auto rowVector4 = makeRowVector({"a", "b"}, {arrayVector3, arrayVector4});
+  auto rowInput4 = makeFlatVector<std::string>(
+      {R"({"a": [{"c": 1}], "b": [{"d": 3, "e": 7}]})",
+       R"({"a": [{"c": 2}], "b": [{"d": 2, "e": 4}, {"d": 2, "e": 8}]})",
+       R"({"a": [{"c": 3}, {"c": 4}, {"c": 5}], "b": [{"d": 1, "e": 9}]})"});
+  testFromJson(rowInput4, rowVector4);
 }
 
 TEST_F(FromJsonTest, structEmptyArray) {
@@ -252,15 +418,11 @@ TEST_F(FromJsonTest, structWrongData) {
 
 TEST_F(FromJsonTest, invalidType) {
   auto primitiveTypeOutput = makeFlatVector<int64_t>({2, 2, 3});
-  auto decimalOutput = makeFlatVector<int64_t>({2, 2, 3}, DECIMAL(16, 7));
   auto mapOutput =
       makeMapVector<int64_t, int64_t>({{{1, 1}}, {{2, 2}}, {{3, 3}}});
   auto input = makeFlatVector<std::string>({R"(2)", R"({2)", R"({3)"});
   VELOX_ASSERT_USER_THROW(
       testFromJson(input, primitiveTypeOutput), "Unsupported type BIGINT.");
-  VELOX_ASSERT_USER_THROW(
-      testFromJson(input, makeRowVector({"a"}, {decimalOutput})),
-      "Unsupported type ROW<a:DECIMAL(16, 7)>");
   VELOX_ASSERT_USER_THROW(
       testFromJson(input, mapOutput), "Unsupported type MAP<BIGINT,BIGINT>.");
 }
diff --git a/velox/functions/sparksql/tests/FromToJsonRoundTripTest.cpp b/velox/functions/sparksql/tests/FromToJsonRoundTripTest.cpp
new file mode 100644
index 000000000000..a43953f76ae9
--- /dev/null
+++ b/velox/functions/sparksql/tests/FromToJsonRoundTripTest.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/functions/sparksql/tests/JsonTestUtil.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class FromToJsonRoundTripTest : public SparkFunctionBaseTest {
+ protected:
+  // Performs a round-trip test: original -> from_json -> to_json -> final, and
+  // compare original and final.
+  void testFromToJsonRoundTrip(
+      const VectorPtr& input,
+      const std::shared_ptr<const Type>& rowType,
+      const std::optional<std::string>& timezone = std::nullopt) {
+    // from_json
+    auto fromJsonExpr = createFromJson(rowType);
+    auto fromJsonResult =
+        evaluate(fromJsonExpr, makeRowVector({"c0"}, {input}));
+
+    // to_json
+    auto toJsonExpr = createToJson(rowType, timezone);
+    auto finalResult =
+        evaluate(toJsonExpr, makeRowVector({"c0"}, {fromJsonResult}));
+    // Compare original and final results
+    assertEqualVectors(input, finalResult);
+  }
+};
+
+TEST_F(FromToJsonRoundTripTest, basicStruct) {
+  auto input = makeFlatVector<std::string>(
+      {R"({"a":1,"b":1.1})", R"({"b":2.2})", R"({"a":3})", R"({})"});
+  auto rowType = ROW({"a", "b"}, {BIGINT(), DOUBLE()});
+  testFromToJsonRoundTrip(input, rowType);
+}
+
+TEST_F(FromToJsonRoundTripTest, basicArray) {
+  auto input = makeNullableFlatVector<std::string>(
+      {R"([1])", R"([2,null,3])", R"([])", R"([null])"});
+  auto rowType = ARRAY(BIGINT());
+  testFromToJsonRoundTrip(input, rowType);
+}
+
+TEST_F(FromToJsonRoundTripTest, basicMap) {
+  auto input = makeFlatVector<std::string>(
+      {R"({"a":1})", R"({"b":2})", R"({"c":3})", R"({"3":3})"});
+  auto rowType = MAP(VARCHAR(), BIGINT());
+  testFromToJsonRoundTrip(input, rowType);
+}
+
+TEST_F(FromToJsonRoundTripTest, nestedComplexType) {
+  // ROW(VARCHAR, ARRAY(INTEGER), MAP(VARCHAR, INTEGER),
+  //     ROW(VARCHAR, ARRAY(INTEGER)))
+  auto input = makeFlatVector<std::string>(
+      {R"({"a":"str1","b":[1,2,3],"c":{"key1":1,"key2":2,"key3":3},"d":{"d1":"d1_str1","d2":[1,2,3]}})",
+       R"({"a":"str2","b":[],"d":{"d1":"d1_str2","d2":[4,5]}})",
+       R"({"a":"str3","b":[null],"c":{"key4":1,"key5":null},"d":{"d2":[null]}})"});
+  auto rowType =
+      ROW({"a", "b", "c", "d"},
+          {VARCHAR(),
+           ARRAY(INTEGER()),
+           MAP(VARCHAR(), INTEGER()),
+           ROW({"d1", "d2"}, {VARCHAR(), ARRAY(INTEGER())})});
+  testFromToJsonRoundTrip(input, rowType);
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/GetArrayStructFieldsTest.cpp b/velox/functions/sparksql/tests/GetArrayStructFieldsTest.cpp
new file mode 100644
index 000000000000..ffb4a707c5f6
--- /dev/null
+++ b/velox/functions/sparksql/tests/GetArrayStructFieldsTest.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/specialforms/GetArrayStructFields.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class GetArrayStructFieldsTest : public SparkFunctionBaseTest {
+ protected:
+  void testGetArrayStructFields(
+      const VectorPtr& input,
+      int ordinal,
+      const VectorPtr& expected) {
+    auto expr = std::make_shared<const core::CallTypedExpr>(
+        expected->type(),
+        GetArrayStructFieldsCallToSpecialForm::kGetArrayStructFields,
+        std::make_shared<const core::FieldAccessTypedExpr>(input->type(), "c0"),
+        std::make_shared<core::ConstantTypedExpr>(INTEGER(), variant(ordinal)));
+
+    // Input is flat.
+    auto result = evaluate(expr, makeRowVector({input}));
+    assertEqualVectors(expected, result);
+
+    // Input is dictionary or constant encoding.
+    if (input->size() >= 3) {
+      testEncodings(expr, {input}, expected);
+    }
+  }
+};
+
+TEST_F(GetArrayStructFieldsTest, simpleType) {
+  std::vector<vector_size_t> offsets{0, 1, 1};
+  auto colInt = makeFlatVector<int32_t>({1, 2, 3, 4});
+  auto colString = makeNullableFlatVector<std::string>(
+      {"hello", "world", std::nullopt, "test"});
+  auto colIntWithNull =
+      makeNullableFlatVector<int32_t>({11, std::nullopt, 13, 14});
+  auto elementVector = makeRowVector({colInt, colString, colIntWithNull});
+  auto data = makeArrayVector(offsets, elementVector);
+
+  testGetArrayStructFields(data, 0, makeArrayVector(offsets, colInt));
+  testGetArrayStructFields(data, 1, makeArrayVector(offsets, colString));
+  testGetArrayStructFields(data, 2, makeArrayVector(offsets, colIntWithNull));
+}
+
+TEST_F(GetArrayStructFieldsTest, complexType) {
+  std::vector<vector_size_t> offsets{0, 1, 2};
+  std::vector<vector_size_t> nulls{1};
+  auto colArray = makeNullableArrayVector<int32_t>(
+      {{1, 2, std::nullopt},
+       {3, std::nullopt, 4},
+       {5, std::nullopt, std::nullopt},
+       {6, 7, 8}});
+  auto colMap = makeMapVector<std::string, int32_t>(
+      {{{"a", 0}, {"b", 1}},
+       {{"c", 3}, {"d", 4}},
+       {{"e", 5}, {"f", 6}},
+       {{"g", 7}, {"h", 8}}});
+  auto colRow = makeRowVector(
+      {makeNullableArrayVector<int32_t>(
+           {{100, 101, std::nullopt},
+            {std::nullopt},
+            {200, std::nullopt, 202},
+            {300, 301, 302}}),
+       makeNullableFlatVector<std::string>({"a", "b", std::nullopt, "c"})});
+  auto elementVector = makeRowVector({colArray, colMap, colRow});
+  auto data = makeArrayVector(offsets, elementVector, nulls);
+
+  // Get array field array.
+  testGetArrayStructFields(data, 0, makeArrayVector(offsets, colArray, nulls));
+
+  // Get map field array.
+  testGetArrayStructFields(data, 1, makeArrayVector(offsets, colMap, nulls));
+
+  // Get row field array.
+  testGetArrayStructFields(data, 2, makeArrayVector(offsets, colRow, nulls));
+}
+
+TEST_F(GetArrayStructFieldsTest, nullElement) {
+  std::vector<vector_size_t> offsets{0, 1, 3};
+  auto colInt = makeFlatVector<int32_t>({1, 2, 3, 4});
+  auto colIntWithNull =
+      makeNullableFlatVector<int32_t>({11, std::nullopt, 13, 14});
+  auto elementVector = makeRowVector({colInt, colIntWithNull}, nullEvery(2));
+  auto data = makeArrayVector(offsets, elementVector);
+  testGetArrayStructFields(
+      data,
+      0,
+      makeArrayVector(
+          offsets,
+          makeNullableFlatVector<int32_t>({std::nullopt, 2, std::nullopt, 4})));
+  testGetArrayStructFields(
+      data,
+      1,
+      makeArrayVector(
+          offsets,
+          makeNullableFlatVector<int32_t>(
+              {std::nullopt, std::nullopt, std::nullopt, 14})));
+}
+
+TEST_F(GetArrayStructFieldsTest, decodeElement) {
+  std::vector<vector_size_t> offsets{0, 1, 3};
+  auto colInt = makeFlatVector<int32_t>({1, 2, 3, 4});
+  auto elementVector =
+      makeRowVector({wrapInDictionary(makeIndices({1, 0, 2, 3}), colInt)});
+  auto data = makeArrayVector(
+      offsets, wrapInDictionary(makeIndicesInReverse(4), elementVector));
+  testGetArrayStructFields(
+      data, 0, makeArrayVector(offsets, makeFlatVector<int32_t>({4, 3, 1, 2})));
+}
+
+TEST_F(GetArrayStructFieldsTest, emptyInput) {
+  std::vector<std::vector<std::optional<std::tuple<int32_t, std::string>>>>
+      data = {};
+
+  auto rowType = ROW({INTEGER(), VARCHAR()});
+  auto arrayVector = makeArrayOfRowVector(data, rowType);
+  testGetArrayStructFields(arrayVector, 0, makeArrayVector<int32_t>({}));
+}
+
+TEST_F(GetArrayStructFieldsTest, invalidOrdinal) {
+  std::vector<vector_size_t> offsets{0};
+  auto colInt = makeFlatVector<int32_t>({1, 2, 3, 4});
+  auto elementVector = makeRowVector({colInt});
+  auto data = makeArrayVector(offsets, elementVector);
+
+  VELOX_ASSERT_USER_THROW(
+      testGetArrayStructFields(
+          elementVector, -1, makeArrayVector(offsets, colInt)),
+      "The first argument of get_array_struct_fields should be of array(row) type.");
+
+  VELOX_ASSERT_USER_THROW(
+      testGetArrayStructFields(data, -1, makeArrayVector(offsets, colInt)),
+      "Invalid ordinal. Should be greater than or equal to 0.");
+
+  VELOX_ASSERT_USER_THROW(
+      testGetArrayStructFields(data, 2, makeArrayVector(offsets, colInt)),
+      fmt::format("(2 vs. 1) Invalid ordinal 2 for struct with 1 fields."));
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/GetJsonObjectTest.cpp b/velox/functions/sparksql/tests/GetJsonObjectTest.cpp
index ec437df7b823..c0721c7ac7c1 100644
--- a/velox/functions/sparksql/tests/GetJsonObjectTest.cpp
+++ b/velox/functions/sparksql/tests/GetJsonObjectTest.cpp
@@ -15,7 +15,6 @@
  */
 #include <stdint.h>
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
-#include "velox/type/Type.h"
 
 namespace facebook::velox::functions::sparksql::test {
 namespace {
@@ -47,6 +46,9 @@ TEST_F(GetJsonObjectTest, basic) {
   EXPECT_EQ(
       getJsonObject(R"({"name": "Alice", "age": 5, "id": "001"})", "$"),
       R"({"name": "Alice", "age": 5, "id": "001"})");
+  EXPECT_EQ(
+      getJsonObject(R"({"name": "Alice", "age": 5, "id": "001"})", "$  "),
+      R"({"name": "Alice", "age": 5, "id": "001"})");
   EXPECT_EQ(
       getJsonObject(R"({"name": "Alice", "age": 5, "id": "001"})", "$.age"),
       "5");
@@ -64,6 +66,23 @@ TEST_F(GetJsonObjectTest, basic) {
           "$[0].my.info.age"),
       "5");
 
+  // Json object with space in key.
+  EXPECT_EQ(getJsonObject(R"({"a b": "1"})", "$.a b"), "1");
+  EXPECT_EQ(getJsonObject(R"({"a": "1"})", "$. a"), "1");
+  EXPECT_EQ(getJsonObject(R"({"a b": "1"})", "$. a b"), "1");
+  EXPECT_EQ(getJsonObject(R"({"two spaces": "1"})", "$.  two spaces"), "1");
+  EXPECT_EQ(getJsonObject(R"({"a": "1"})", "$.a "), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"a ": "1"})", "$.a "), "1");
+  EXPECT_EQ(getJsonObject(R"({"a b": "1"})", "$.a b "), std::nullopt);
+  EXPECT_EQ(
+      getJsonObject(R"({"two spaces": "1"})", "$.  two spaces "), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"a": "1"})", "$ .a"), std::nullopt);
+  EXPECT_EQ(
+      getJsonObject(R"({"my": {"hello": true}})", "$.  my.  hello"), "true");
+  EXPECT_EQ(
+      getJsonObject(R"({"my": {"hello": true}})", "$.my.  hello"), "true");
+  EXPECT_EQ(getJsonObject(R"({"a$ ": {"b": 10}})", "$.a$ .b"), "10");
+  EXPECT_EQ(getJsonObject(R"({"a$. b": {"c": 10}})", "$.a$. b"), std::nullopt);
   // Json object as result.
   EXPECT_EQ(
       getJsonObject(
@@ -131,6 +150,9 @@ TEST_F(GetJsonObjectTest, incompleteJson) {
   EXPECT_EQ(
       getJsonObject(R"({"hello": "3.5","taskSort":"2",,,,,,})", "$.hello"),
       "3.5");
+  EXPECT_EQ(
+      getJsonObject(R"({"hello": 3.5,"taskSort":"2",,,,,,})", "$.hello"),
+      "3.5");
   EXPECT_EQ(
       getJsonObject(R"({"hello": "boy","taskSort":"2"},,,,,)", "$.hello"),
       "boy");
@@ -148,5 +170,39 @@ TEST_F(GetJsonObjectTest, incompleteJson) {
       R"({"name": "Alice", "age": "5", "id": "001"})");
 }
 
+TEST_F(GetJsonObjectTest, number) {
+  EXPECT_EQ(getJsonObject(R"({"f": +INF})", "$.f"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"f": -INF})", "$.f"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"f": NaN})", "$.f"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"f": Infinity})", "$.f"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"f": +21.00})", "$.f"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"f": +0.00})", "$.f"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"f": -0.00})", "$.f"), "-0.0");
+  EXPECT_EQ(getJsonObject(R"({"f": 0.00})", "$.f"), "0.0");
+  EXPECT_EQ(getJsonObject(R"({"f": -21.00})", "$.f"), "-21.0");
+  EXPECT_EQ(getJsonObject(R"({"f": -21.010})", "$.f"), "-21.01");
+  EXPECT_EQ(getJsonObject(R"({"f": 21e3})", "$.f"), "21000.0");
+  EXPECT_EQ(getJsonObject(R"({"f": -21E-3})", "$.f"), "-0.021");
+  EXPECT_EQ(getJsonObject(R"({"i": +0})", "$.i"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"i": -00})", "$.i"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"i": 00})", "$.i"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"i": 001})", "$.i"), std::nullopt);
+  EXPECT_EQ(getJsonObject(R"({"i": -0})", "$.i"), "0");
+  EXPECT_EQ(getJsonObject(R"({"i": 0})", "$.i"), "0");
+  EXPECT_EQ(
+      getJsonObject(
+          R"({"big": 98765432109876543210987654321098765432 })", "$.big"),
+      "98765432109876543210987654321098765432");
+  EXPECT_EQ(
+      getJsonObject(
+          R"({"big":  -98765432109876543210987654321098765432})", "$.big"),
+      "-98765432109876543210987654321098765432");
+  EXPECT_EQ(
+      getJsonObject(
+          R"({"nested": {"num": -1234567890123456789012345678901234567890 }})",
+          "$.nested.num"),
+      "-1234567890123456789012345678901234567890");
+}
+
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/GetStructFieldTest.cpp b/velox/functions/sparksql/tests/GetStructFieldTest.cpp
index b2f68e945bdc..38c9bd3c184a 100644
--- a/velox/functions/sparksql/tests/GetStructFieldTest.cpp
+++ b/velox/functions/sparksql/tests/GetStructFieldTest.cpp
@@ -17,6 +17,7 @@
 #include <optional>
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -31,11 +32,11 @@ class GetStructFieldTest : public SparkFunctionBaseTest {
       const VectorPtr& input,
       int ordinal,
       const VectorPtr& expected) {
-    std::vector<core::TypedExprPtr> inputs = {
-        std::make_shared<const core::FieldAccessTypedExpr>(input->type(), "c0"),
-        std::make_shared<core::ConstantTypedExpr>(INTEGER(), variant(ordinal))};
     auto expr = std::make_shared<const core::CallTypedExpr>(
-        expected->type(), std::move(inputs), "get_struct_field");
+        expected->type(),
+        "get_struct_field",
+        std::make_shared<const core::FieldAccessTypedExpr>(input->type(), "c0"),
+        std::make_shared<core::ConstantTypedExpr>(INTEGER(), variant(ordinal)));
 
     // Input is flat.
     auto result = evaluate(expr, makeRowVector({input}));
diff --git a/velox/functions/sparksql/tests/HashTest.cpp b/velox/functions/sparksql/tests/HashTest.cpp
index ff506f2ddd69..effeac777a9c 100644
--- a/velox/functions/sparksql/tests/HashTest.cpp
+++ b/velox/functions/sparksql/tests/HashTest.cpp
@@ -174,8 +174,9 @@ TEST_F(HashTest, array) {
 
   assertEqualVectors(
       makeFlatVector<int32_t>({-559580957, 1765031574, 42}),
-      hash(makeNullableArrayVector<int32_t>(
-          {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
+      hash(
+          makeNullableArrayVector<int32_t>(
+              {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
 
   // Nested array.
   {
@@ -269,10 +270,11 @@ TEST_F(HashTest, unknown) {
 
   assertEqualVectors(
       makeFlatVector<int32_t>({42, 42}),
-      hash(makeNullableArrayVector<UnknownValue>({
-          {std::nullopt, std::nullopt},
-          {std::nullopt, std::nullopt, std::nullopt},
-      })));
+      hash(
+          makeNullableArrayVector<UnknownValue>({
+              {std::nullopt, std::nullopt},
+              {std::nullopt, std::nullopt, std::nullopt},
+          })));
 
   auto mapVector = makeNullableMapVector<UnknownValue, UnknownValue>({
       std::nullopt,
diff --git a/velox/functions/sparksql/tests/InTest.cpp b/velox/functions/sparksql/tests/InTest.cpp
index ba1ea5ffcdb8..a740aa362bd1 100644
--- a/velox/functions/sparksql/tests/InTest.cpp
+++ b/velox/functions/sparksql/tests/InTest.cpp
@@ -83,8 +83,9 @@ class InTest : public SparkFunctionBaseTest {
         rhsArrayVector = wrapInDictionary(indices, rhs.size(), rhsArrayVector);
       }
 
-      args.push_back(std::make_shared<core::ConstantTypedExpr>(
-          BaseVector::wrapInConstant(1, 0, rhsArrayVector)));
+      args.push_back(
+          std::make_shared<core::ConstantTypedExpr>(
+              BaseVector::wrapInConstant(1, 0, rhsArrayVector)));
       return exec::ExprSet(
           {std::make_shared<core::CallTypedExpr>(BOOLEAN(), args, "in")},
           &execCtx_);
diff --git a/velox/functions/sparksql/tests/InitcapTest.cpp b/velox/functions/sparksql/tests/InitcapTest.cpp
new file mode 100644
index 000000000000..ae1ebe4f2931
--- /dev/null
+++ b/velox/functions/sparksql/tests/InitcapTest.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/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+class InitcapTest : public SparkFunctionBaseTest {
+ public:
+  static std::vector<std::tuple<std::string, std::string>>
+  getInitcapUnicodeTestData() {
+    return {
+        {"àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ", "Àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ"},
+        {"αβγδεζηθικλμνξοπρςστυφχψ", "Αβγδεζηθικλμνξοπρςστυφχψ"},
+        {"абвгдежзийклмнопрстуфхцчшщъыьэюя",
+         "Абвгдежзийклмнопрстуфхцчшщъыьэюя"},
+        {"hello world", "Hello World"},
+        {"HELLO WORLD", "Hello World"},
+        {"1234", "1234"},
+        {"", ""},
+        {"élève très-intelligent", "Élève Très-intelligent"},
+        {"mañana-por_la_tarde!", "Mañana-por_la_tarde!"},
+        {"добро-пожаловать.тест", "Добро-пожаловать.тест"},
+        {"çalışkan öğrenci@üniversite.tr", "Çalışkan Öğrenci@üniversite.tr"},
+        {"emoji😊test🚀case", "Emoji😊test🚀case"},
+        {"тест@пример.рф", "Тест@пример.рф"}};
+  }
+
+  static std::vector<std::tuple<std::string, std::string>>
+  getInitcapAsciiTestData() {
+    return {
+        {"abcdefg", "Abcdefg"},
+        {"ABCDEFG", "Abcdefg"},
+        {"a B c D e F g", "A B C D E F G"},
+        {"hello world", "Hello World"},
+        {"HELLO WORLD", "Hello World"},
+        {"1234", "1234"},
+        {"1 2 3 4", "1 2 3 4"},
+        {"1 2 3 4a", "1 2 3 4a"},
+        {"", ""},
+        {"urna.Ut@egetdictumplacerat.edu", "Urna.ut@egetdictumplacerat.edu"},
+        {"nibh.enim@egestas.ca", "Nibh.enim@egestas.ca"},
+        {"in@Donecat.ca", "In@donecat.ca"},
+        {"sodales@blanditviverraDonec.ca", "Sodales@blanditviverradonec.ca"},
+        {"sociis.natoque.penatibus@vitae.org",
+         "Sociis.natoque.penatibus@vitae.org"},
+        {"john_doe-123@example-site.com", "John_doe-123@example-site.com"},
+        {"MIXED.case-EMAIL_42@domain.NET", "Mixed.case-email_42@domain.net"},
+        {"...weird..case@@", "...weird..case@@"},
+        {"user-name+filter@sub.mail.org", "User-name+filter@sub.mail.org"},
+        {"CAPS_LOCK@DOMAIN.COM", "Caps_lock@domain.com"},
+        {"__init__.py@example.dev", "__init__.py@example.dev"}};
+  }
+
+ protected:
+  std::optional<std::string> initcap(const std::optional<std::string>& str) {
+    return evaluateOnce<std::string>("initcap(c0)", str);
+  }
+};
+
+TEST_F(InitcapTest, initcapUnicode) {
+  for (const auto& [inputStr, expected] : getInitcapUnicodeTestData()) {
+    EXPECT_EQ(initcap(inputStr).value(), expected);
+  }
+}
+
+TEST_F(InitcapTest, initcapAscii) {
+  for (const auto& [inputStr, expected] : getInitcapAsciiTestData()) {
+    EXPECT_EQ(initcap(inputStr).value(), expected);
+  }
+}
+
+TEST_F(InitcapTest, initcap) {
+  const auto initcap = [&](const std::optional<std::string>& value) {
+    return evaluateOnce<std::string>("initcap(c0)", value);
+  };
+  // Unicode only.
+  EXPECT_EQ(
+      initcap("àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ"),
+      "Àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ");
+  EXPECT_EQ(initcap("αβγδεζηθικλμνξοπρςστυφχψ"), "Αβγδεζηθικλμνξοπρςστυφχψ");
+  // Mix of ascii and unicode.
+  EXPECT_EQ(initcap("αβγδεζ world"), "Αβγδεζ World");
+  EXPECT_EQ(initcap("αfoo wβ"), "Αfoo Wβ");
+  // Ascii only.
+  EXPECT_EQ(initcap("hello world"), "Hello World");
+  EXPECT_EQ(initcap("HELLO WORLD"), "Hello World");
+  EXPECT_EQ(initcap("1234"), "1234");
+  EXPECT_EQ(initcap("a b c d"), "A B C D");
+  EXPECT_EQ(initcap("abcd"), "Abcd");
+  // Numbers.
+  EXPECT_EQ(initcap("123"), "123");
+  EXPECT_EQ(initcap("1abc"), "1abc");
+  // Edge cases.
+  EXPECT_EQ(initcap(""), "");
+  EXPECT_EQ(initcap(std::nullopt), std::nullopt);
+
+  // Test with spaces other than whitespace
+  EXPECT_EQ(initcap("YQ\tY"), "Yq\ty");
+  EXPECT_EQ(initcap("YQ\nY"), "Yq\ny");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/JsonTestUtil.h b/velox/functions/sparksql/tests/JsonTestUtil.h
new file mode 100644
index 000000000000..a2c9c08c2c5e
--- /dev/null
+++ b/velox/functions/sparksql/tests/JsonTestUtil.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 "velox/core/Expressions.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+
+constexpr float kNaNFloat = std::numeric_limits<float>::quiet_NaN();
+constexpr float kInfFloat = std::numeric_limits<float>::infinity();
+constexpr double kNaNDouble = std::numeric_limits<double>::quiet_NaN();
+constexpr double kInfDouble = std::numeric_limits<double>::infinity();
+
+inline core::CallTypedExprPtr createFromJson(const TypePtr& outputType) {
+  std::vector<core::TypedExprPtr> inputs = {
+      std::make_shared<core::FieldAccessTypedExpr>(VARCHAR(), "c0")};
+
+  return std::make_shared<const core::CallTypedExpr>(
+      outputType, std::move(inputs), "from_json");
+}
+
+inline core::CallTypedExprPtr createToJson(
+    const TypePtr& inputType,
+    const std::optional<std::string>& timezone = std::nullopt) {
+  auto input = std::make_shared<core::FieldAccessTypedExpr>(inputType, "c0");
+  std::vector<core::TypedExprPtr> inputs = {input};
+  if (timezone) {
+    auto tz = std::make_shared<core::ConstantTypedExpr>(VARCHAR(), *timezone);
+    inputs.emplace_back(tz);
+  }
+  return std::make_shared<const core::CallTypedExpr>(
+      VARCHAR(), std::move(inputs), "to_json");
+}
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/MakeDecimalTest.cpp b/velox/functions/sparksql/tests/MakeDecimalTest.cpp
index 5d11bd9c0dfa..ab63020938ce 100644
--- a/velox/functions/sparksql/tests/MakeDecimalTest.cpp
+++ b/velox/functions/sparksql/tests/MakeDecimalTest.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 
 namespace facebook::velox::functions::sparksql::test {
@@ -28,14 +29,15 @@ class MakeDecimalTest : public SparkFunctionBaseTest {
     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())));
+      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");
+          outputType, "try", makeDecimal);
     } else {
       return makeDecimal;
     }
diff --git a/velox/functions/sparksql/tests/MakeTimestampTest.cpp b/velox/functions/sparksql/tests/MakeTimestampTest.cpp
index 624058c9bdec..5e83dacc309c 100644
--- a/velox/functions/sparksql/tests/MakeTimestampTest.cpp
+++ b/velox/functions/sparksql/tests/MakeTimestampTest.cpp
@@ -86,22 +86,23 @@ TEST_F(MakeTimestampTest, basic) {
   // 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 year = makeFlatVector<int32_t>({2021, 2021, 1, 2024});
+    const auto month = makeFlatVector<int32_t>({07, 07, 1, 3});
+    const auto day = makeFlatVector<int32_t>({11, 11, 1, 10});
+    const auto hour = makeFlatVector<int32_t>({6, 6, 1, 2});
+    const auto minute = makeFlatVector<int32_t>({30, 30, 1, 1});
     const auto micros =
-        makeNullableFlatVector<int64_t>({45678000, 45678000, 1e6}, microsType);
-    const auto timeZone =
-        makeNullableFlatVector<StringView>({"GMT", "CET", std::nullopt});
+        makeFlatVector<int64_t>({45678000, 45678000, 0, 45678000}, microsType);
+    const auto timeZone = makeNullableFlatVector<StringView>(
+        {"GMT", "CET", std::nullopt, "America/Chicago"});
     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});
+         std::nullopt,
+         parseTimestamp("2024-03-10 08:01:45.678")});
     testMakeTimestamp(data, expected, true);
   }
 }
diff --git a/velox/functions/sparksql/tests/MapTest.cpp b/velox/functions/sparksql/tests/MapTest.cpp
index 655bdb652b96..f26fa8fb6853 100644
--- a/velox/functions/sparksql/tests/MapTest.cpp
+++ b/velox/functions/sparksql/tests/MapTest.cpp
@@ -77,6 +77,65 @@ TEST_F(MapTest, boolType) {
   testMap("map(c0, c1)", {inputVector1, inputVector2}, mapVector);
 }
 
+TEST_F(MapTest, duplicateMapKey) {
+  // Input vectors with duplicate keys.
+  auto inputVector1 = makeNullableFlatVector<int64_t>({1, 20, 3});
+  auto inputVector2 = makeNullableFlatVector<double>({4.0, 5.0, 6.0});
+  auto inputVector3 = makeNullableFlatVector<int64_t>({10, 20, 30});
+  auto inputVector4 = makeNullableFlatVector<double>({4.1, 5.1, 6.1});
+  auto inputVector5 = makeNullableFlatVector<int64_t>({100, 200, 30});
+  auto inputVector6 = makeNullableFlatVector<double>({4.2, 5.2, 6.2});
+
+  // Deduplicate map keys based on LAST_WIN policy.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kThrowExceptionOnDuplicateMapKeys, "false"}});
+
+  const auto expectedMapVector1 =
+      makeMapVector<int64_t, double>({{{1, 4.0}}, {{20, 5.0}}, {{3, 6.0}}});
+  const auto expectedMapVector2 = makeMapVector<int64_t, double>(
+      {{{10, 4.1}, {100, 4.2}}, {{20, 5.1}, {200, 5.2}}, {{30, 6.2}}});
+  const auto expectedMapVector3 = makeMapVector<int64_t, double>(
+      {{{1, 4.0}, {10, 4.1}, {100, 4.2}},
+       {{20, 5.1}, {200, 5.2}},
+       {{3, 6.0}, {30, 6.2}}});
+
+  testMap("map(c0, c1)", {inputVector1, inputVector2}, expectedMapVector1);
+
+  testMap(
+      "map(c0, c1, c2, c3)",
+      {inputVector3, inputVector4, inputVector5, inputVector6},
+      expectedMapVector2);
+
+  testMap(
+      "map(c0, c1, c2, c3, c4, c5)",
+      {inputVector1,
+       inputVector2,
+       inputVector3,
+       inputVector4,
+       inputVector5,
+       inputVector6},
+      expectedMapVector3);
+
+  // Throw exception when duplicate keys are found.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kThrowExceptionOnDuplicateMapKeys, "true"}});
+
+  testMapFails(
+      "map(c0, c1, c2, c3)",
+      {inputVector3, inputVector4, inputVector5, inputVector6},
+      "Duplicate map key (30) was found.");
+
+  testMapFails(
+      "map(c0, c1, c2, c3, c4, c5)",
+      {inputVector1,
+       inputVector2,
+       inputVector3,
+       inputVector4,
+       inputVector5,
+       inputVector6},
+      "Duplicate map key (20) was found.");
+}
+
 TEST_F(MapTest, wide) {
   auto inputVector1 = makeNullableFlatVector<int64_t>({1, 2, 3});
   auto inputVector2 = makeNullableFlatVector<double>({4.0, 5.0, 6.0});
@@ -90,12 +149,75 @@ TEST_F(MapTest, wide) {
       mapVector);
 }
 
+TEST_F(MapTest, tenKeyValuePairs) {
+  // Test map function with 10 key-value pairs (20 arguments).
+  auto key1 = makeFlatVector<int64_t>({1, 11, 21});
+  auto val1 = makeFlatVector<std::string>({"a", "aa", "aaa"});
+  auto key2 = makeFlatVector<int64_t>({2, 12, 22});
+  auto val2 = makeFlatVector<std::string>({"b", "bb", "bbb"});
+  auto key3 = makeFlatVector<int64_t>({3, 13, 23});
+  auto val3 = makeFlatVector<std::string>({"c", "cc", "ccc"});
+  auto key4 = makeFlatVector<int64_t>({4, 14, 24});
+  auto val4 = makeFlatVector<std::string>({"d", "dd", "ddd"});
+  auto key5 = makeFlatVector<int64_t>({5, 15, 25});
+  auto val5 = makeFlatVector<std::string>({"e", "ee", "eee"});
+  auto key6 = makeFlatVector<int64_t>({6, 16, 26});
+  auto val6 = makeFlatVector<std::string>({"f", "ff", "fff"});
+  auto key7 = makeFlatVector<int64_t>({7, 17, 27});
+  auto val7 = makeFlatVector<std::string>({"g", "gg", "ggg"});
+  auto key8 = makeFlatVector<int64_t>({8, 18, 28});
+  auto val8 = makeFlatVector<std::string>({"h", "hh", "hhh"});
+  auto key9 = makeFlatVector<int64_t>({9, 19, 29});
+  auto val9 = makeFlatVector<std::string>({"i", "ii", "iii"});
+  auto key10 = makeFlatVector<int64_t>({10, 20, 30});
+  auto val10 = makeFlatVector<std::string>({"j", "jj", "jjj"});
+
+  auto expectedMap = makeMapVector<int64_t, std::string>(
+      {{{1, "a"},
+        {2, "b"},
+        {3, "c"},
+        {4, "d"},
+        {5, "e"},
+        {6, "f"},
+        {7, "g"},
+        {8, "h"},
+        {9, "i"},
+        {10, "j"}},
+       {{11, "aa"},
+        {12, "bb"},
+        {13, "cc"},
+        {14, "dd"},
+        {15, "ee"},
+        {16, "ff"},
+        {17, "gg"},
+        {18, "hh"},
+        {19, "ii"},
+        {20, "jj"}},
+       {{21, "aaa"},
+        {22, "bbb"},
+        {23, "ccc"},
+        {24, "ddd"},
+        {25, "eee"},
+        {26, "fff"},
+        {27, "ggg"},
+        {28, "hhh"},
+        {29, "iii"},
+        {30, "jjj"}}});
+
+  testMap(
+      "map(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, "
+      "c15, c16, c17, c18, c19)",
+      {key1, val1, key2, val2, key3, val3, key4, val4, key5,  val5,
+       key6, val6, key7, val7, key8, val8, key9, val9, key10, val10},
+      expectedMap);
+}
+
 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
+  // Number of args.
   testMapFails(
       "map(c0)",
       {inputVectorInt64},
@@ -105,19 +227,21 @@ TEST_F(MapTest, errorCases) {
       {inputVectorInt64, inputVectorDouble, inputVectorInt64},
       "Scalar function signature is not supported: map(BIGINT, DOUBLE, BIGINT)");
 
+  // Test with 22 arguments (11 pairs) - exceeds the maximum of 10 key-value
+  // pairs supported by the map function.
   testMapFails(
-      "map(c0, c1, c2, c3, c4, c5, c6, c7)",
-      {inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
-       inputVectorDouble,
+      "map(c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21)",
+      {inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
+       inputVectorDouble, inputVectorDouble, inputVectorDouble,
        inputVectorDouble},
-      "Scalar function signature is not supported: map(DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE)");
+      "Scalar function signature is not supported: map(DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE, DOUBLE)");
 
-  // Types of args
+  // Types of args.
   testMapFails(
       "map(c0, c1, c2, c3)",
       {inputVectorInt64,
@@ -212,6 +336,152 @@ TEST_F(MapTest, complexTypes) {
       arrayMapResult1);
 }
 
+TEST_F(MapTest, complexTypesDuplicateMapKey) {
+  auto makeSingleMapVector = [&](const VectorPtr& keyVector,
+                                 const VectorPtr& valueVector) {
+    return makeMapVector(
+        {
+            0,
+        },
+        keyVector,
+        valueVector);
+  };
+  auto arrayKey = makeArrayVectorFromJson<int64_t>({"[1, 2, 3]"});
+  auto arrayValue = makeArrayVectorFromJson<int64_t>({"[1, 3, 5]"});
+  auto nullArrayValue = makeArrayVectorFromJson<int64_t>({"null"});
+
+  // Deduplicate map keys based on LAST_WIN policy.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kThrowExceptionOnDuplicateMapKeys, "false"}});
+  testMap(
+      "map(c0, c1, c2, c3)",
+      {arrayKey, arrayValue, arrayKey, arrayValue},
+      makeSingleMapVector(arrayKey, arrayValue));
+
+  testMap(
+      "map(c0, c1, c2, c3)",
+      {arrayKey, nullArrayValue, arrayKey, nullArrayValue},
+      makeSingleMapVector(arrayKey, nullArrayValue));
+
+  // Throw exception on duplicate map key.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kThrowExceptionOnDuplicateMapKeys, "true"}});
+  testMapFails(
+      "map(c0, c1, c2, c3)",
+      {arrayKey, arrayValue, arrayKey, arrayValue},
+      "Duplicate map key ({1, 2, 3}) was found.");
+}
+
+TEST_F(MapTest, complexTypesWithNestedNullsDuplicateMapKey) {
+  // Create array keys with nulls.
+  auto arrayKeysWithNull1 = makeNullableArrayVector<int64_t>(
+      {{1, std::nullopt, 3}, {4, 5, std::nullopt}, {7, 8, 9}});
+  auto valuesForKey1 = makeArrayVector<std::string>(
+      {{"a", "b", "c"}, {"d", "e", "f"}, {"g", "h", "i"}});
+
+  // Create duplicate keys with the same null pattern.
+  auto arrayKeysWithNull2 = makeNullableArrayVector<int64_t>(
+      {{1, std::nullopt, 3}, {10, 11, 12}, {13, 14, 15}});
+  auto valuesForKey2 = makeArrayVector<std::string>(
+      {{"x", "y", "z"}, {"p", "q", "r"}, {"s", "t", "u"}});
+
+  // Create complex type with map containing null values.
+  auto mapKey1 = makeMapVector<int64_t, int64_t>(
+      {{{1, 10}, {2, std::nullopt}},
+       {{3, 30}, {4, std::nullopt}},
+       {{5, 50}, {6, 60}}});
+  auto valueForMapKey1 = makeFlatVector<int64_t>({100, 200, 300});
+
+  // Create duplicate complex map key with the same null pattern.
+  auto mapKey2 = makeMapVector<int64_t, int64_t>(
+      {{{1, 10}, {2, std::nullopt}},
+       {{30, 300}, {40, 400}},
+       {{50, 500}, {60, 600}}});
+  auto valueForMapKey2 = makeFlatVector<int64_t>({1000, 2000, 3000});
+
+  // Deduplicate map keys based on LAST_WIN policy.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kThrowExceptionOnDuplicateMapKeys, "false"}});
+
+  // Test case 1: Array keys with nulls.
+  // Expected: [1, null, 3] appears twice, last value ["x", "y", "z"] wins.
+  auto expectedArrayMap = makeMapVector(
+      {0, 1, 3},
+      makeNullableArrayVector<int64_t>(
+          {{1, std::nullopt, 3},
+           {4, 5, std::nullopt},
+           {10, 11, 12},
+           {7, 8, 9},
+           {13, 14, 15}}),
+      makeArrayVector<std::string>(
+          {{"x", "y", "z"},
+           {"d", "e", "f"},
+           {"p", "q", "r"},
+           {"g", "h", "i"},
+           {"s", "t", "u"}}));
+
+  testMap(
+      "map(c0, c1, c2, c3)",
+      {arrayKeysWithNull1, valuesForKey1, arrayKeysWithNull2, valuesForKey2},
+      expectedArrayMap);
+
+  // Test case 2: Map keys with nulls.
+  // Expected: {{1, 10}, {2, null}} appears twice, last value 1000 wins.
+  auto expectedMapOfMap = makeMapVector(
+      {0, 1, 3},
+      makeMapVector<int64_t, int64_t>(
+          {{{1, 10}, {2, std::nullopt}},
+           {{3, 30}, {4, std::nullopt}},
+           {{30, 300}, {40, 400}},
+           {{5, 50}, {6, 60}},
+           {{50, 500}, {60, 600}}}),
+      makeFlatVector<int64_t>({1000, 200, 2000, 300, 3000}));
+
+  testMap(
+      "map(c0, c1, c2, c3)",
+      {mapKey1, valueForMapKey1, mapKey2, valueForMapKey2},
+      expectedMapOfMap);
+
+  // Test case 3: Test with deeply nested structures containing nulls.
+  auto rowKey1 = makeRowVector(
+      {makeNullableArrayVector<int64_t>({{1, std::nullopt, 3}}),
+       makeMapVector<int64_t, int64_t>({{{1, 10}, {2, std::nullopt}}})});
+  auto valueForRow1 = makeFlatVector<std::string>({"first"});
+
+  // Duplicate row key with same null pattern.
+  auto rowKey2 = makeRowVector(
+      {makeNullableArrayVector<int64_t>({{1, std::nullopt, 3}}),
+       makeMapVector<int64_t, int64_t>({{{1, 10}, {2, std::nullopt}}})});
+  auto valueForRow2 = makeFlatVector<std::string>({"last"});
+
+  // Expected: Complex row with nulls appears twice, last value "last" wins.
+  auto expectedRowMap = makeMapVector(
+      {0},
+      makeRowVector(
+          {makeNullableArrayVector<int64_t>({{1, std::nullopt, 3}}),
+           makeMapVector<int64_t, int64_t>({{{1, 10}, {2, std::nullopt}}})}),
+      makeFlatVector<std::string>({"last"}));
+
+  testMap(
+      "map(c0, c1, c2, c3)",
+      {rowKey1, valueForRow1, rowKey2, valueForRow2},
+      expectedRowMap);
+
+  // Test case 4: Test with exception throwing enabled.
+  queryCtx_->testingOverrideConfigUnsafe(
+      {{core::QueryConfig::kThrowExceptionOnDuplicateMapKeys, "true"}});
+
+  testMapFails(
+      "map(c0, c1, c2, c3)",
+      {arrayKeysWithNull1, valuesForKey1, arrayKeysWithNull2, valuesForKey2},
+      "Duplicate map key ({1, null, 3}) was found.");
+
+  testMapFails(
+      "map(c0, c1, c2, c3)",
+      {mapKey1, valueForMapKey1, mapKey2, valueForMapKey2},
+      "Duplicate map key ({1 => 10, 2 => null}) was found.");
+}
+
 TEST_F(MapTest, resultSize) {
   auto condition = makeFlatVector<int64_t>({1, 2, 3});
   auto keys = makeFlatVector<int64_t>({3, 2, 1});
diff --git a/velox/functions/sparksql/tests/MightContainTest.cpp b/velox/functions/sparksql/tests/MightContainTest.cpp
index c53bdbc4459c..e9f98076d01d 100644
--- a/velox/functions/sparksql/tests/MightContainTest.cpp
+++ b/velox/functions/sparksql/tests/MightContainTest.cpp
@@ -16,6 +16,7 @@
 
 #include "velox/functions/sparksql/MightContain.h"
 #include "velox/common/base/BloomFilter.h"
+#include "velox/core/Expressions.h"
 #include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
 
 namespace facebook::velox::functions::sparksql::test {
@@ -32,11 +33,13 @@ class MightContainTest : public SparkFunctionBaseTest {
     auto selected = SelectivityVector(value->size());
     std::vector<core::TypedExprPtr> args;
     if (serialized.has_value()) {
-      args.push_back(std::make_shared<core::ConstantTypedExpr>(
-          VARBINARY(), variant::binary(serialized.value())));
+      args.push_back(
+          std::make_shared<core::ConstantTypedExpr>(
+              VARBINARY(), variant::binary(serialized.value())));
     } else {
-      args.push_back(std::make_shared<core::ConstantTypedExpr>(
-          VARBINARY(), variant::null(TypeKind::VARBINARY)));
+      args.push_back(
+          std::make_shared<core::ConstantTypedExpr>(
+              VARBINARY(), variant::null(TypeKind::VARBINARY)));
     }
     args.push_back(
         std::make_shared<core::FieldAccessTypedExpr>(BIGINT(), "c0"));
diff --git a/velox/functions/sparksql/tests/ReadSidePaddingFunctionTest.cpp b/velox/functions/sparksql/tests/ReadSidePaddingFunctionTest.cpp
new file mode 100644
index 000000000000..67d61e0b2e49
--- /dev/null
+++ b/velox/functions/sparksql/tests/ReadSidePaddingFunctionTest.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/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class ReadSidePaddingFunctionTest : public SparkFunctionBaseTest {
+ protected:
+  auto readSidePadding(
+      const std::optional<std::string>& input,
+      const std::optional<int32_t>& limit) {
+    return evaluateOnce<std::string>("read_side_padding(c0, c1)", input, limit);
+  }
+};
+
+TEST_F(ReadSidePaddingFunctionTest, ascii) {
+  // String length < limit: pad with spaces.
+  EXPECT_EQ(readSidePadding("a", 3), "a  ");
+
+  // String length >= limit: return as-is.
+  EXPECT_EQ(readSidePadding("abc", 3), "abc");
+  EXPECT_EQ(readSidePadding("abcd", 3), "abcd");
+}
+
+TEST_F(ReadSidePaddingFunctionTest, unicode) {
+  // String length < limit: pad with spaces.
+  EXPECT_EQ(readSidePadding("世", 3), "世  ");
+  EXPECT_EQ(readSidePadding("a世", 3), "a世 ");
+  EXPECT_EQ(readSidePadding("Привет", 8), "Привет  "); // Cyrillic
+  EXPECT_EQ(readSidePadding("Γειά", 5), "Γειά "); // Greek
+
+  // String length >= limit: return as-is.
+  EXPECT_EQ(readSidePadding("世界", 2), "世界");
+  EXPECT_EQ(readSidePadding("Γειά", 4), "Γειά");
+  EXPECT_EQ(readSidePadding("a世界b", 3), "a世界b");
+  EXPECT_EQ(readSidePadding("Приветик", 6), "Приветик");
+}
+
+TEST_F(ReadSidePaddingFunctionTest, error) {
+  // Edge cases - length limit must be positive.
+  VELOX_ASSERT_USER_THROW(
+      readSidePadding("a", 0), "The length limit must be greater than 0.");
+  VELOX_ASSERT_USER_THROW(
+      readSidePadding("abc", -1), "The length limit must be greater than 0.");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/SortArrayTest.cpp b/velox/functions/sparksql/tests/SortArrayTest.cpp
index fa0449a37f9e..c205a56e65a1 100644
--- a/velox/functions/sparksql/tests/SortArrayTest.cpp
+++ b/velox/functions/sparksql/tests/SortArrayTest.cpp
@@ -18,6 +18,7 @@
 #include <limits>
 #include <optional>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/functions/prestosql/tests/utils/FunctionBaseTest.h"
 #include "velox/functions/sparksql/registration/Register.h"
 #include "velox/functions/sparksql/tests/ArraySortTestData.h"
@@ -153,13 +154,16 @@ TEST_F(SortArrayTest, array) {
       makeNullableNestedArrayVector(reverseNested(expected)));
 }
 
-TEST_F(SortArrayTest, map) {
+// Map is not orderable, so sorting is not supported.
+TEST_F(SortArrayTest, failOnMapTypeSort) {
   auto input = makeArrayOfMapVector(mapInput());
-  auto expected = mapAscNullSmallest();
-  testSortArray(
-      input,
-      makeArrayOfMapVector(expected),
-      makeArrayOfMapVector(reverseNested(expected)));
+  const std::string kErrorMessage =
+      "Scalar function signature is not supported";
+
+  VELOX_ASSERT_THROW(
+      evaluate("sort_array(c0)", makeRowVector({input})), kErrorMessage);
+  VELOX_ASSERT_THROW(
+      evaluate("sort_array(c0, true)", makeRowVector({input})), kErrorMessage);
 }
 
 TEST_F(SortArrayTest, row) {
diff --git a/velox/functions/sparksql/tests/SparkCastExprTest.cpp b/velox/functions/sparksql/tests/SparkCastExprTest.cpp
index eb3226fa0f3d..d92d4fdd2737 100644
--- a/velox/functions/sparksql/tests/SparkCastExprTest.cpp
+++ b/velox/functions/sparksql/tests/SparkCastExprTest.cpp
@@ -211,53 +211,26 @@ TEST_F(SparkCastExprTest, invalidDate) {
       "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", {"-1-1-1"}, "Unable to parse date value: \"-1-1-1\"", VARCHAR());
-  testInvalidCast<std::string>(
-      "date",
-      {"-11-1-1"},
-      "Unable to parse date value: \"-11-1-1\"",
-      VARCHAR());
-  testInvalidCast<std::string>(
-      "date",
-      {"-111-1-1"},
-      "Unable to parse date value: \"-111-1-1\"",
-      VARCHAR());
-  testInvalidCast<std::string>(
-      "date",
-      {"- 1111-1-1"},
-      "Unable to parse date value: \"- 1111-1-1\"",
-      VARCHAR());
+  testCast<std::string, int32_t>(
+      "date", {"2012-Oct-23"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"2015-03-18X"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"2015/03/18"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"2015.03.18"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"20150318"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"2015-031-8"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"-1-1-1"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"-11-1-1"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"-111-1-1"}, {std::nullopt}, VARCHAR(), DATE());
+  testCast<std::string, int32_t>(
+      "date", {"- 1111-1-1"}, {std::nullopt}, VARCHAR(), DATE());
 }
 
 TEST_F(SparkCastExprTest, stringToTimestamp) {
@@ -341,25 +314,25 @@ TEST_F(SparkCastExprTest, intToTimestamp) {
 TEST_F(SparkCastExprTest, timestampToInt) {
   // Cast timestamp as bigint.
   testCast(
-      makeFlatVector<Timestamp>({
-          Timestamp(0, 0),
-          Timestamp(1, 0),
-          Timestamp(10, 0),
-          Timestamp(-1, 0),
-          Timestamp(-10, 0),
-          Timestamp(-1, 500000),
-          Timestamp(-2, 999999),
-          Timestamp(-10, 999999),
-          Timestamp(1, 999999),
-          Timestamp(-1, 1),
-          Timestamp(1234567, 500000),
-          Timestamp(-9876543, 1234),
-          Timestamp(1727181032, 0),
-          Timestamp(-1727181032, 0),
-          Timestamp(9223372036854, 775'807'000),
-          Timestamp(-9223372036855, 224'192'000),
-      }),
-      makeFlatVector<int64_t>({
+      makeFlatVector<Timestamp>(
+          {Timestamp(0, 0),
+           Timestamp(1, 0),
+           Timestamp(10, 0),
+           Timestamp(-1, 0),
+           Timestamp(-10, 0),
+           Timestamp(-1, 500000),
+           Timestamp(-2, 999999),
+           Timestamp(-10, 999999),
+           Timestamp(1, 999999),
+           Timestamp(-1, 1),
+           Timestamp(1234567, 500000),
+           Timestamp(-9876543, 1234),
+           Timestamp(1727181032, 0),
+           Timestamp(-1727181032, 0),
+           Timestamp(9223372036854, 775'807'000),
+           Timestamp(-9223372036855, 224'192'000),
+           Timestamp(9223372036856, 0)}),
+      makeNullableFlatVector<int64_t>({
           0,
           1,
           10,
@@ -376,11 +349,8 @@ TEST_F(SparkCastExprTest, timestampToInt) {
           -1727181032,
           9223372036854,
           -9223372036855,
+          std::nullopt,
       }));
-  testInvalidCast<Timestamp>(
-      "bigint",
-      {Timestamp(9223372036856, 0)},
-      "Could not convert Timestamp(9223372036856, 0) to microseconds");
 
   // Cast timestamp as tinyint/smallint/integer.
   testTimestampToIntegralCast<int8_t>();
@@ -468,56 +438,32 @@ 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");
+    testCast<std::string, int8_t>("tinyint", {"1234567"}, {std::nullopt});
+    testCast<std::string, int8_t>("tinyint", {"1a"}, {std::nullopt});
+    testCast<std::string, int8_t>("tinyint", {""}, {std::nullopt});
+    testCast<std::string, int32_t>("integer", {"1'234'567"}, {std::nullopt});
+    testCast<std::string, int32_t>("integer", {"1,234,567"}, {std::nullopt});
+    testCast<std::string, int64_t>("bigint", {"infinity"}, {std::nullopt});
+    testCast<std::string, int64_t>("bigint", {"nan"}, {std::nullopt});
   }
 
   // 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");
+    testCast<std::string, float>("real", {"1.2a"}, {std::nullopt});
+    testCast<std::string, float>("real", {"1.2.3"}, {std::nullopt});
   }
 
   // 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");
+    testCast<std::string, bool>("boolean", {"1.7E308"}, {std::nullopt});
+    testCast<std::string, bool>("boolean", {"nan"}, {std::nullopt});
+    testCast<std::string, bool>("boolean", {"12"}, {std::nullopt});
+    testCast<std::string, bool>("boolean", {"-1"}, {std::nullopt});
+    testCast<std::string, bool>("boolean", {"tr"}, {std::nullopt});
+    testCast<std::string, bool>("boolean", {"tru"}, {std::nullopt});
+    testCast<std::string, bool>("boolean", {"on"}, {std::nullopt});
+    testCast<std::string, bool>("boolean", {"off"}, {std::nullopt});
   }
 }
 
@@ -608,7 +554,7 @@ TEST_F(SparkCastExprTest, truncate) {
       "tinyint", {1111111, 2, 3, 1000, -100101}, {71, 2, 3, -24, -5});
 }
 
-TEST_F(SparkCastExprTest, errorHandling) {
+TEST_F(SparkCastExprTest, tryCast) {
   testTryCast<std::string, int8_t>(
       "tinyint",
       {"-",
@@ -627,7 +573,8 @@ TEST_F(SparkCastExprTest, errorHandling) {
        "-..",
        "125.5",
        "127",
-       "-128"},
+       "-128",
+       "1.2"},
       {std::nullopt,
        0,
        std::nullopt,
@@ -642,14 +589,26 @@ TEST_F(SparkCastExprTest, errorHandling) {
        std::nullopt,
        std::nullopt,
        std::nullopt,
-       125,
+       std::nullopt,
        127,
-       -128});
+       -128,
+       std::nullopt});
 
-  testTryCast<double, int>(
+  testTryCast<double, int32_t>(
       "integer",
       {1e12, 2.5, 3.6, 100.44, -100.101},
-      {std::numeric_limits<int32_t>::max(), 2, 3, 100, -100});
+      {std::nullopt, 2, 3, 100, -100});
+  testTryCast<int64_t, int8_t>("tinyint", {456}, {std::nullopt});
+  testTryCast<int64_t, int16_t>("smallint", {1234567}, {std::nullopt});
+  testTryCast<int64_t, int32_t>("integer", {2147483649}, {std::nullopt});
+
+  testTryCast<std::string, int16_t>("smallint", {"52769"}, {std::nullopt});
+  testTryCast<std::string, int32_t>("integer", {"17515055537"}, {std::nullopt});
+  testTryCast<std::string, int32_t>(
+      "integer", {"-17515055537"}, {std::nullopt});
+  testTryCast<std::string, int64_t>(
+      "bigint", {"9663372036854775809"}, {std::nullopt});
+  testTryCast<int64_t, int8_t>("tinyint", {456}, {std::nullopt}, DECIMAL(6, 0));
 }
 
 TEST_F(SparkCastExprTest, overflow) {
@@ -681,37 +640,27 @@ TEST_F(SparkCastExprTest, overflow) {
   testCast(
       shortFlat,
       makeNullableFlatVector<int8_t>(
-          {-44, -4, 26, 56, -100, 0, 124, 117, 63, -78, -48, std::nullopt}));
+          {-44, -4, 26, 56, -100, 0, 124, 117, 63, -78, -48, std::nullopt}),
+      false);
   testCast(
       makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
-      makeNullableFlatVector<int8_t>({0}));
+      makeNullableFlatVector<int8_t>({0}),
+      false);
   testCast(
       makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
-      makeNullableFlatVector<int32_t>({-2147483648}));
+      makeNullableFlatVector<int32_t>({-2147483648}),
+      false);
   testCast(
       makeNullableFlatVector<int64_t>({214748364890}, DECIMAL(12, 2)),
-      makeNullableFlatVector<int64_t>({2147483648}));
+      makeNullableFlatVector<int64_t>({2147483648}),
+      false);
 
-  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");
+  testCast<std::string, int8_t>("tinyint", {"166"}, {std::nullopt});
+  testCast<std::string, int16_t>("smallint", {"52769"}, {std::nullopt});
+  testCast<std::string, int32_t>("integer", {"17515055537"}, {std::nullopt});
+  testCast<std::string, int32_t>("integer", {"-17515055537"}, {std::nullopt});
+  testCast<std::string, int64_t>(
+      "bigint", {"9663372036854775809"}, {std::nullopt});
 }
 
 TEST_F(SparkCastExprTest, timestampToString) {
@@ -932,5 +881,56 @@ TEST_F(SparkCastExprTest, boolToTimestamp) {
       }));
 }
 
+TEST_F(SparkCastExprTest, recursiveTryCast) {
+  // Test array elements.
+  testCast(
+      makeArrayVector<StringView>({
+          {"1", "2", "3"},
+          {"4", "a", "6"},
+          {"b", "c", "d"},
+      }),
+      makeNullableArrayVector<int64_t>({
+          {1, 2, 3},
+          {4, std::nullopt, 6},
+          {std::nullopt, std::nullopt, std::nullopt},
+      }));
+
+  // Test map values (Spark doesn't allow casting if the map keys can become
+  // null).
+  testCast(
+      makeMapVectorFromJson<int64_t, std::string>({
+          R"( {1:"1", 2:"2", 3:"3"} )",
+          R"( {1:"4", 2:"a", 3:"6"} )",
+          R"( {1:"b", 2:"c", 3:"d"} )",
+      }),
+      makeMapVectorFromJson<int64_t, int64_t>({
+          "{1:1, 2:2, 3:3}",
+          "{1:4, 2:null, 3:6}",
+          "{1:null, 2:null, 3:null}",
+      }));
+
+  // Test row fields.
+  testCast(
+      makeRowVector(
+          {makeFlatVector<StringView>({"1", "4", "b"}),
+           makeFlatVector<StringView>({"2", "a", "c"}),
+           makeFlatVector<StringView>({"3", "6", "d"})}),
+      makeRowVector(
+          {makeNullableFlatVector<int64_t>({1, 4, std::nullopt}),
+           makeNullableFlatVector<int64_t>({2, std::nullopt, std::nullopt}),
+           makeNullableFlatVector<int64_t>({3, 6, std::nullopt})}));
+
+  // Test nested arrays.
+  testCast(
+      makeNestedArrayVectorFromJson<std::string>({
+          R"( [["1", "2", "3"], ["4", "a", "6"]] )",
+          R"( [["b", "c", "d"], ["x", "7", "z"]] )",
+      }),
+      makeNestedArrayVectorFromJson<int64_t>({
+          "[[1, 2, 3], [4, null, 6]]",
+          "[[null, null, null], [null, 7, null]]",
+      }));
+}
+
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/functions/sparksql/tests/SplitTest.cpp b/velox/functions/sparksql/tests/SplitTest.cpp
index 33a8e133f9b2..58c1202a907b 100644
--- a/velox/functions/sparksql/tests/SplitTest.cpp
+++ b/velox/functions/sparksql/tests/SplitTest.cpp
@@ -42,7 +42,27 @@ class SplitTest : public SparkFunctionBaseTest {
       result = evaluate("split(c0, c1)", input);
     }
     assertEqualVectors(expectedResult, result);
-  };
+  }
+
+  void testSplitConstantDelim(
+      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 expectedResult = makeArrayVector(expected);
+    VectorPtr result;
+    if (limit.has_value()) {
+      auto limits = makeConstant<int32_t>(limit.value(), numRows);
+      auto input = makeRowVector({strings, limits});
+      result = evaluate("split(c0, '" + delim + "', c1)", input);
+    } else {
+      auto input = makeRowVector({strings});
+      result = evaluate("split(c0, '" + delim + "')", input);
+    }
+    assertEqualVectors(expectedResult, result);
+  }
 };
 
 TEST_F(SplitTest, basic) {
@@ -253,5 +273,50 @@ TEST_F(SplitTest, regexDelimiter) {
   };
   testSplit(input, "🙂", -1, numRows, expected);
 }
+
+TEST_F(SplitTest, fastPath) {
+  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"},
+      {""},
+  });
+
+  // Escaped delimiter.
+  testSplit(input, "\\$", std::nullopt, 1, expected);
+  testSplitConstantDelim(input, "\\$", std::nullopt, 1, expected);
+
+  // Octal string delimiter.
+  testSplit(input, "\\044", std::nullopt, 1, expected);
+  testSplitConstantDelim(input, "\\044", std::nullopt, 1, expected);
+
+  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
+  };
+
+  // Single character delimiter.
+  testSplit(input, "<", std::nullopt, 1, expected);
+  testSplitConstantDelim(input, "<", std::nullopt, 1, expected);
+
+  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
+  };
+
+  // Octal string delimiter that is outside the range of ASCII characters.
+  testSplit(input, "\\251", std::nullopt, 1, expected);
+  testSplitConstantDelim(input, "\\251", std::nullopt, 1, 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 419488eb5e5e..7f8e0707fd41 100644
--- a/velox/functions/sparksql/tests/StringTest.cpp
+++ b/velox/functions/sparksql/tests/StringTest.cpp
@@ -1055,5 +1055,6 @@ TEST_F(StringTest, empty2Null) {
   EXPECT_EQ(empty2Null(""), std::nullopt);
   EXPECT_EQ(empty2Null("abc"), "abc");
 }
+
 } // namespace
 } // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/ToJsonTest.cpp b/velox/functions/sparksql/tests/ToJsonTest.cpp
new file mode 100644
index 000000000000..dbcb54c256bc
--- /dev/null
+++ b/velox/functions/sparksql/tests/ToJsonTest.cpp
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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/common/testutil/OptionalEmpty.h"
+#include "velox/functions/sparksql/tests/JsonTestUtil.h"
+
+using namespace facebook::velox::test;
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class ToJsonTest : public SparkFunctionBaseTest {
+ protected:
+  void testToJson(const VectorPtr& input, const VectorPtr& expected) {
+    testToJson(input, std::nullopt, expected);
+  }
+
+  void testToJson(
+      const VectorPtr& input,
+      const std::optional<std::string>& timezone,
+      const VectorPtr& expected) {
+    auto expr = createToJson(input->type(), timezone);
+    testEncodings(expr, {input}, expected);
+  }
+
+  void disableJsonIgnoreNullFields() {
+    queryCtx_->testingOverrideConfigUnsafe(
+        {{core::QueryConfig::kSparkJsonIgnoreNullFields, "false"}});
+  }
+};
+
+TEST_F(ToJsonTest, basicStruct) {
+  auto input = makeRowVector(
+      {"a", "b"},
+      {makeNullableFlatVector<int64_t>({1, std::nullopt, 3, std::nullopt}),
+       makeNullableFlatVector<double>({1.1, 2.2, std::nullopt, std::nullopt})});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":1,"b":1.1})", R"({"b":2.2})", R"({"a":3})", R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicArray) {
+  auto input = makeNullableArrayVector<int64_t>(
+      {std::vector<std::optional<int64_t>>{1},
+       std::vector<std::optional<int64_t>>{2, std::nullopt, 3},
+       common::testutil::optionalEmpty,
+       std::nullopt});
+  auto expected = makeNullableFlatVector<std::string>(
+      {R"([1])", R"([2,null,3])", R"([])", std::nullopt});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicMap) {
+  // MAP(VARCHAR, BIGINT)
+  auto input = makeNullableMapVector<std::string, int64_t>(
+      {std::vector<std::pair<std::string, std::optional<int64_t>>>{
+           {"a", 1}, {"b", 2}, {"c", 3}},
+       std::nullopt,
+       common::testutil::optionalEmpty,
+       std::vector<std::pair<std::string, std::optional<int64_t>>>{
+           {"a", 1}, {"b", std::nullopt}}});
+  auto expected = makeNullableFlatVector<std::string>(
+      {R"({"a":1,"b":2,"c":3})", std::nullopt, R"({})", R"({"a":1,"b":null})"});
+  testToJson(input, expected);
+
+  // MAP(BIGINT, VARCHAR)
+  input = makeNullableMapVector<int64_t, std::string>(
+      {std::vector<std::pair<int64_t, std::optional<std::string>>>{
+           {1, "a"}, {2, "b"}, {3, "c"}},
+       std::nullopt,
+       common::testutil::optionalEmpty,
+       std::vector<std::pair<int64_t, std::optional<std::string>>>{
+           {1, "a"}, {2, std::nullopt}}});
+  expected = makeNullableFlatVector<std::string>(
+      {R"({"1":"a","2":"b","3":"c"})",
+       std::nullopt,
+       R"({})",
+       R"({"1":"a","2":null})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicBool) {
+  disableJsonIgnoreNullFields();
+  auto data = makeNullableFlatVector<bool>({true, false, std::nullopt});
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":true})", R"({"a":false})", R"({"a":null})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicString) {
+  disableJsonIgnoreNullFields();
+  auto data = makeNullableFlatVector<std::string>(
+      {"str1", "str2\\u", std::nullopt, "str\"3\"", std::nullopt, "a\"é你😄"});
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":"str1"})",
+       R"({"a":"str2\\u"})",
+       R"({"a":null})",
+       R"({"a":"str\"3\""})",
+       R"({"a":null})",
+       R"({"a":"a\"é你😄"})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicTinyInt) {
+  auto data =
+      makeNullableFlatVector<int8_t>({0, 127, 128, -128, -129, std::nullopt});
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":0})",
+       R"({"a":127})",
+       R"({"a":-128})",
+       R"({"a":-128})",
+       R"({"a":127})",
+       R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicSmallInt) {
+  auto data = makeNullableFlatVector<int16_t>({0, 32768, -32769, std::nullopt});
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":0})", R"({"a":-32768})", R"({"a":32767})", R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicInt) {
+  auto data = makeNullableFlatVector<int32_t>(
+      {0, 2147483648, -2147483649, std::nullopt});
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":0})", R"({"a":-2147483648})", R"({"a":2147483647})", R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicBigInt) {
+  auto data = makeNullableFlatVector<int64_t>(
+      {std::nullopt, 0, 1, INT64_MAX, INT64_MIN});
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({})",
+       R"({"a":0})",
+       R"({"a":1})",
+       R"({"a":9223372036854775807})",
+       R"({"a":-9223372036854775808})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicFloat) {
+  auto data = makeNullableFlatVector<float>(
+      {1.0, kNaNFloat, kInfFloat, -kInfFloat, std::nullopt});
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":1.0})",
+       R"({"a":"NaN"})",
+       R"({"a":"Infinity"})",
+       R"({"a":"-Infinity"})",
+       R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicDouble) {
+  auto data = makeNullableFlatVector<double>(
+      {1.0, kNaNDouble, kInfDouble, -kInfDouble, std::nullopt});
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":1.0})",
+       R"({"a":"NaN"})",
+       R"({"a":"Infinity"})",
+       R"({"a":"-Infinity"})",
+       R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicDecimal) {
+  auto data = makeNullableFlatVector<int64_t>(
+      {12345, 0, -67890, std::nullopt}, DECIMAL(10, 2));
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":123.45})", R"({"a":0.00})", R"({"a":-678.90})", R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, longDecimal) {
+  using facebook::velox::HugeInt;
+  auto data = makeNullableFlatVector<int128_t>(
+      {HugeInt::build(0, 0x112210F47DE98115), // 123456789.0123456789
+       HugeInt::build(0, 0), // 0.0000000000
+       -HugeInt::build(
+           0x35,
+           0x8A750438F380F524), // -98765432109.8765432100
+       HugeInt::build(
+           0x4B3B4CA85A86C47A,
+           0x098A223FFFFFFFFF), // max decimal(38, 10)
+       -HugeInt::build(
+           0x4B3B4CA85A86C47A,
+           0x098A223FFFFFFFFF), // min decimal(38, 10)
+       std::nullopt},
+      DECIMAL(38, 10));
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":123456789.0123456789})",
+       R"({"a":0.0000000000})",
+       R"({"a":-98765432109.8765432100})",
+       R"({"a":9999999999999999999999999999.9999999999})",
+       R"({"a":-9999999999999999999999999999.9999999999})",
+       R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicTimestamp) {
+  auto data = makeNullableFlatVector<Timestamp>(
+      {Timestamp(0, 0),
+       Timestamp(1582934400, 0),
+       Timestamp(-2208988800, 0),
+       std::nullopt});
+  auto input = makeRowVector({"a"}, {data});
+  // UTC time zone.
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":"1970-01-01T00:00:00.000Z"})",
+       R"({"a":"2020-02-29T00:00:00.000Z"})",
+       R"({"a":"1900-01-01T00:00:00.000Z"})",
+       R"({})"});
+  testToJson(input, "UTC", expected);
+  // Los_Angeles time zone.
+  setTimezone("America/Los_Angeles");
+  expected = makeFlatVector<std::string>(
+      {R"({"a":"1969-12-31T16:00:00.000-08:00"})",
+       R"({"a":"2020-02-28T16:00:00.000-08:00"})",
+       R"({"a":"1899-12-31T16:00:00.000-08:00"})",
+       R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, basicDate) {
+  auto data = makeNullableFlatVector<int32_t>(
+      {0, 18321, -25567, 2932896, std::nullopt}, DateType::get());
+  auto input = makeRowVector({"a"}, {data});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":"1970-01-01"})",
+       R"({"a":"2020-02-29"})",
+       R"({"a":"1900-01-01"})",
+       R"({"a":"9999-12-31"})",
+       R"({})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, nestedComplexType) {
+  // ROW(VARCHAR, ARRAY(INTEGER), MAP(VARCHAR, INTEGER),
+  //     ROW(VARCHAR, ARRAY(INTEGER)))
+  auto data1 = makeNullableFlatVector<std::string>({"str1", "str2", "str3"});
+  auto data2 =
+      makeNullableArrayVector<int64_t>({{1, 2, 3}, {}, {std::nullopt}});
+  auto data3 = makeNullableMapVector<std::string, int64_t>(
+      {{{{"key1", 1}, {"key2", 2}, {"key3", 3}}},
+       std::nullopt,
+       {{{"key4", 1}, {"key5", std::nullopt}}}});
+  auto data4 = makeRowVector(
+      {"d1", "d2"},
+      {makeNullableFlatVector<std::string>(
+           {"d1_str1", "d1_str2", std::nullopt}),
+       makeNullableArrayVector<int64_t>({{1, 2, 3}, {4, 5}, {std::nullopt}})});
+  auto input =
+      makeRowVector({"a", "b", "c", "d"}, {data1, data2, data3, data4});
+  auto expected = makeFlatVector<std::string>(
+      {R"({"a":"str1","b":[1,2,3],"c":{"key1":1,"key2":2,"key3":3},"d":{"d1":"d1_str1","d2":[1,2,3]}})",
+       R"({"a":"str2","b":[],"d":{"d1":"d1_str2","d2":[4,5]}})",
+       R"({"a":"str3","b":[null],"c":{"key4":1,"key5":null},"d":{"d2":[null]}})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, nestedMap) {
+  // MAP(ROW(DATE, ARRAY(VARCHAR), DOUBLE, TIMESTAMP), INTEGER)
+  auto values = makeFlatVector<int32_t>({10, 20, 30, 40, 50});
+  auto data1 = makeNullableFlatVector<int32_t>(
+      {0, 18321, -25567, 2932896, std::nullopt}, DateType::get());
+  auto data2 = makeNullableArrayVector<std::string>(
+      {std::vector<std::optional<std::string>>{"a", "b", std::nullopt},
+       common::testutil::optionalEmpty,
+       std::vector<std::optional<std::string>>{"d", "e"},
+       std::vector<std::optional<std::string>>{"f", std::nullopt, "h"},
+       std::nullopt});
+  auto data3 = makeNullableFlatVector<double>(
+      {1.0, kNaNDouble, kInfDouble, -kInfDouble, std::nullopt});
+  auto data4 = makeNullableFlatVector<Timestamp>(
+      {Timestamp(0, 0),
+       std::nullopt,
+       Timestamp(1582934400, 0),
+       Timestamp(-2208988800, 0),
+       Timestamp(1735713000, 0)});
+  auto rows = makeRowVector({"a", "b", "c", "d"}, {data1, data2, data3, data4});
+  auto input = makeMapVector({0, 1, 2, 3, 4}, rows, values);
+  auto expected = makeFlatVector<std::string>(
+      {R"({"[0,[a,b,null],1.0,0]":10})",
+       R"({"[18321,[],NaN,null]":20})",
+       R"({"[-25567,[d,e],Infinity,1582934400000000]":30})",
+       R"({"[2932896,[f,null,h],-Infinity,-2208988800000000]":40})",
+       R"({"[null,null,null,1735713000000000]":50})"});
+  testToJson(input, expected);
+}
+
+TEST_F(ToJsonTest, unsupportedType) {
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 1000;
+  opts.nullRatio = 0.1;
+
+  VectorFuzzer fuzzer(opts, pool_.get());
+
+#ifndef NDEBUG
+  // ROW(HUGEINT)
+  auto hugeIntInput =
+      fuzzer.fuzzDictionary(fuzzer.fuzzFlat(ROW({"a"}, {HUGEINT()})));
+  VELOX_ASSERT_THROW(
+      testToJson(hugeIntInput, nullptr), "HUGEINT must be a decimal type.");
+#endif
+
+  // MAP(MAP)
+  auto input = fuzzer.fuzzDictionary(
+      fuzzer.fuzzFlat(MAP(MAP(BIGINT(), BIGINT()), INTEGER())));
+  VELOX_ASSERT_THROW(
+      testToJson(input, nullptr),
+      "to_json function does not support type MAP<MAP<BIGINT,BIGINT>,INTEGER>.");
+
+  // MAP(ARRAY(MAP))
+  input = fuzzer.fuzzDictionary(
+      fuzzer.fuzzFlat(MAP(ARRAY(MAP(VARCHAR(), INTEGER())), INTEGER())));
+  VELOX_ASSERT_THROW(
+      testToJson(input, nullptr),
+      "to_json function does not support type MAP<ARRAY<MAP<VARCHAR,INTEGER>>,INTEGER>.");
+
+  // ROW(MAP(ARRAY(MAP)))
+  input = makeRowVector(
+      {"a"},
+      {fuzzer.fuzzDictionary(
+          fuzzer.fuzzFlat(MAP(ARRAY(MAP(BIGINT(), BIGINT())), INTEGER())))});
+  VELOX_ASSERT_THROW(
+      testToJson(input, nullptr),
+      "to_json function does not support type ROW<a:MAP<ARRAY<MAP<BIGINT,BIGINT>>,INTEGER>>.");
+}
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/UnBase64Test.cpp b/velox/functions/sparksql/tests/UnBase64Test.cpp
new file mode 100644
index 000000000000..96550f5e95f1
--- /dev/null
+++ b/velox/functions/sparksql/tests/UnBase64Test.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/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class UnBase64Test : public SparkFunctionBaseTest {
+ protected:
+  std::optional<std::string> unbase64(const std::optional<std::string>& a) {
+    return evaluateOnce<std::string>("unbase64(c0)", a);
+  }
+};
+
+TEST_F(UnBase64Test, basic) {
+  EXPECT_EQ(unbase64(std::nullopt), std::nullopt);
+  EXPECT_EQ(unbase64("TWFu"), "Man");
+  EXPECT_EQ(unbase64("TWFu\r\nTWFu"), "ManMan");
+  EXPECT_EQ(unbase64("aGVsbG8gd29ybGQ="), "hello world");
+  EXPECT_EQ(unbase64("U3BhcmsgU1FM"), "Spark SQL");
+  EXPECT_EQ(unbase64("#"), "");
+  EXPECT_EQ(unbase64("YQ==="), "a");
+  EXPECT_EQ(unbase64("aA"), "h");
+  EXPECT_EQ(unbase64("c3d"), "sw");
+  EXPECT_EQ(unbase64("cd@"), "q");
+  EXPECT_EQ(
+      unbase64("SGVsbG8gV29ybGQgZnJvbSBWZW@@Xvece"),
+      "Hello World from Vee\xEFy\xC7");
+  EXPECT_EQ(unbase64("@@dmVsb3g="), "velox");
+}
+
+TEST_F(UnBase64Test, error) {
+  VELOX_ASSERT_USER_THROW(
+      unbase64("aGVsx"), "Last unit does not have enough valid bits");
+  VELOX_ASSERT_USER_THROW(
+      unbase64("xx=y"), "Input byte array has wrong 4-byte ending unit");
+  VELOX_ASSERT_USER_THROW(
+      unbase64("xx="), "Input byte array has wrong 4-byte ending unit");
+  VELOX_ASSERT_USER_THROW(
+      unbase64("aGVs="), "Input byte array has wrong 4-byte ending unit");
+  VELOX_ASSERT_USER_THROW(
+      unbase64("AQ==y"), "Input byte array has incorrect ending");
+  VELOX_ASSERT_USER_THROW(
+      unbase64("a"), "Input should at least have 2 bytes for base64 bytes");
+
+  VELOX_ASSERT_USER_THROW(
+      unbase64("c@"), "Last unit does not have enough valid bits");
+  VELOX_ASSERT_USER_THROW(
+      unbase64("=="), "Input byte array has wrong 4-byte ending unit");
+  VELOX_ASSERT_USER_THROW(
+      unbase64("SGVsbG8gV29ybGQgZnJvbSBWZW===xveCE="),
+      "Input byte array has incorrect ending");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/UpperLowerTest.cpp b/velox/functions/sparksql/tests/UpperLowerTest.cpp
new file mode 100644
index 000000000000..6484348e8310
--- /dev/null
+++ b/velox/functions/sparksql/tests/UpperLowerTest.cpp
@@ -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.
+ */
+
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class UpperLowerTest : public SparkFunctionBaseTest {
+ protected:
+  std::optional<std::string> lower(std::optional<std::string> str) {
+    return evaluateOnce<std::string>("lower(c0)", str);
+  }
+
+  std::optional<std::string> upper(std::optional<std::string> str) {
+    return evaluateOnce<std::string>("upper(c0)", str);
+  }
+};
+
+TEST_F(UpperLowerTest, lowerAscii) {
+  EXPECT_EQ("abcdefg", lower("ABCDEFG"));
+  EXPECT_EQ("abcdefg", lower("abcdefg"));
+  EXPECT_EQ("a b c d e f g", lower("a B c D e F g"));
+}
+
+TEST_F(UpperLowerTest, lowerUnicode) {
+  EXPECT_EQ(
+      "àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ",
+      lower("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ"));
+  EXPECT_EQ("αβγδεζηθικλμνξοπρσστυφχψ", lower("ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΣΤΥΦΧΨ"));
+  EXPECT_EQ(
+      "абвгдежзийклмнопрстуфхцчшщъыьэюя",
+      lower("АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"));
+  EXPECT_EQ("i\xCC\x87", lower("\u0130"));
+  EXPECT_EQ("i\xCC\x87", lower("I\xCC\x87"));
+  EXPECT_EQ("\u010B", lower("\u010A"));
+  EXPECT_EQ("\u0117", lower("\u0116"));
+  EXPECT_EQ("\u0121", lower("\u0120"));
+  EXPECT_EQ("\u017C", lower("\u017B"));
+  EXPECT_EQ("\u0227", lower("\u0226"));
+  EXPECT_EQ("\u022F", lower("\u022E"));
+  EXPECT_EQ("\u1E03", lower("\u1E02"));
+  EXPECT_EQ("\u1E0B", lower("\u1E0A"));
+  EXPECT_EQ("\u1E1F", lower("\u1E1E"));
+  EXPECT_EQ("\u1E23", lower("\u1E22"));
+  EXPECT_EQ("\u1E41", lower("\u1E40"));
+  EXPECT_EQ("\u1E45", lower("\u1E44"));
+  EXPECT_EQ("\u1E57", lower("\u1E56"));
+  EXPECT_EQ("\u1E59", lower("\u1E58"));
+  EXPECT_EQ("\u1E61", lower("\u1E60"));
+  EXPECT_EQ("\u1E65", lower("\u1E64"));
+  EXPECT_EQ("\u1E67", lower("\u1E66"));
+  EXPECT_EQ("\u1E69", lower("\u1E68"));
+  EXPECT_EQ("\u1E6B", lower("\u1E6A"));
+  EXPECT_EQ("\u1E87", lower("\u1E86"));
+  EXPECT_EQ("\u1E8B", lower("\u1E8A"));
+  EXPECT_EQ("\u1E8F", lower("\u1E8E"));
+}
+
+TEST_F(UpperLowerTest, lowerGreek) {
+  EXPECT_EQ("πας", lower("ΠΑΣ"));
+  EXPECT_EQ("πας ", lower("ΠΑΣ "));
+  EXPECT_EQ("πασα", lower("ΠΑΣΑ"));
+  EXPECT_EQ("πας.", lower("ΠΑΣ."));
+  EXPECT_EQ("πας   a", lower("ΠΑΣ   A"));
+  EXPECT_EQ("πας`", lower("ΠΑΣ`"));
+  EXPECT_EQ("παςא", lower("ΠΑΣא"));
+  EXPECT_EQ("παςあ", lower("ΠΑΣあ"));
+  EXPECT_EQ("πασʰ", lower("ΠΑΣʰ"));
+  EXPECT_EQ("πασdž", lower("ΠΑΣDž"));
+  EXPECT_EQ("πασσ", lower("ΠΑΣσ"));
+  EXPECT_EQ("πασд", lower("ΠΑΣД"));
+}
+
+TEST_F(UpperLowerTest, upperAscii) {
+  EXPECT_EQ("ABCDEFG", upper("abcdefg"));
+  EXPECT_EQ("ABCDEFG", upper("ABCDEFG"));
+  EXPECT_EQ("A B C D E F G", upper("a B c D e F g"));
+}
+
+TEST_F(UpperLowerTest, upperUnicode) {
+  EXPECT_EQ(
+      "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ",
+      upper("àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ"));
+  EXPECT_EQ("ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΣΤΥΦΧΨ", upper("αβγδεζηθικλμνξοπρςστυφχψ"));
+  EXPECT_EQ(
+      "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ",
+      upper("абвгдежзийклмнопрстуфхцчшщъыьэюя"));
+  EXPECT_EQ("\u0049", upper("\u0069"));
+  EXPECT_EQ("I\xCC\x87", upper("i\xCC\x87"));
+  EXPECT_EQ("\u010A", upper("\u010B"));
+  EXPECT_EQ("\u0116", upper("\u0117"));
+  EXPECT_EQ("\u0120", upper("\u0121"));
+  EXPECT_EQ("\u017B", upper("\u017C"));
+  EXPECT_EQ("\u0226", upper("\u0227"));
+  EXPECT_EQ("\u022E", upper("\u022F"));
+  EXPECT_EQ("\u1E02", upper("\u1E03"));
+  EXPECT_EQ("\u1E0A", upper("\u1E0B"));
+  EXPECT_EQ("\u1E1E", upper("\u1E1F"));
+  EXPECT_EQ("\u1E22", upper("\u1E23"));
+  EXPECT_EQ("\u1E40", upper("\u1E41"));
+  EXPECT_EQ("\u1E44", upper("\u1E45"));
+  EXPECT_EQ("\u1E56", upper("\u1E57"));
+  EXPECT_EQ("\u1E58", upper("\u1E59"));
+  EXPECT_EQ("\u1E60", upper("\u1E61"));
+  EXPECT_EQ("\u1E64", upper("\u1E65"));
+  EXPECT_EQ("\u1E66", upper("\u1E67"));
+  EXPECT_EQ("\u1E68", upper("\u1E69"));
+  EXPECT_EQ("\u1E6A", upper("\u1E6B"));
+  EXPECT_EQ("\u1E86", upper("\u1E87"));
+  EXPECT_EQ("\u1E8A", upper("\u1E8B"));
+  EXPECT_EQ("\u1E8E", upper("\u1E8F"));
+}
+
+TEST_F(UpperLowerTest, upperGreek) {
+  EXPECT_EQ("ΠΑΣ", upper("πασ"));
+  EXPECT_EQ("ΠΑΣ ", upper("πασ "));
+  EXPECT_EQ("ΠΑΣA", upper("πασa"));
+  EXPECT_EQ("ΠΑΣ", upper("πας"));
+  EXPECT_EQ("ΠΑΣ ", upper("πας "));
+  EXPECT_EQ("ΠΑΣA", upper("παςa"));
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/VarcharTypeWriteSideCheckTest.cpp b/velox/functions/sparksql/tests/VarcharTypeWriteSideCheckTest.cpp
new file mode 100644
index 000000000000..4d38cd1a374c
--- /dev/null
+++ b/velox/functions/sparksql/tests/VarcharTypeWriteSideCheckTest.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/common/base/tests/GTestUtils.h"
+#include "velox/functions/sparksql/tests/SparkFunctionBaseTest.h"
+
+namespace facebook::velox::functions::sparksql::test {
+namespace {
+
+class VarcharTypeWriteSideCheckTest : public SparkFunctionBaseTest {};
+
+TEST_F(VarcharTypeWriteSideCheckTest, varcharTypeWriteSideCheck) {
+  const auto varcharTypeWriteSideCheck =
+      [&](const std::optional<std::string>& input,
+          const std::optional<int32_t>& limit) {
+        return evaluateOnce<std::string>(
+            "varchar_type_write_side_check(c0, c1)", input, limit);
+      };
+
+  // Basic cases - string length <= limit.
+  EXPECT_EQ(varcharTypeWriteSideCheck("abc", 3), "abc");
+  EXPECT_EQ(varcharTypeWriteSideCheck("ab", 3), "ab");
+  EXPECT_EQ(varcharTypeWriteSideCheck("", 5), "");
+
+  // Cases with trailing spaces.
+  // Edge cases - input string is longer than limit but trims to exactly limit.
+  EXPECT_EQ(varcharTypeWriteSideCheck("abc  ", 3), "abc");
+  EXPECT_EQ(varcharTypeWriteSideCheck("abc  ", 4), "abc ");
+  EXPECT_EQ(varcharTypeWriteSideCheck("abc  ", 5), "abc  ");
+
+  // Unicode string cases with trailing spaces.
+  EXPECT_EQ(varcharTypeWriteSideCheck("世界   ", 2), "世界");
+  EXPECT_EQ(varcharTypeWriteSideCheck("世界", 2), "世界");
+
+  // Error cases - string length > limit even after trimming trailing spaces.
+  VELOX_ASSERT_USER_THROW(
+      varcharTypeWriteSideCheck("abcd", 3),
+      "Exceeds allowed length limitation: 3");
+  VELOX_ASSERT_USER_THROW(
+      varcharTypeWriteSideCheck("世界人", 2),
+      "Exceeds allowed length limitation: 2");
+  VELOX_ASSERT_USER_THROW(
+      varcharTypeWriteSideCheck("abc def", 5),
+      "Exceeds allowed length limitation: 5");
+
+  // Null input cases.
+  EXPECT_EQ(varcharTypeWriteSideCheck(std::nullopt, 5), std::nullopt);
+
+  // Edge cases - length limit must be positive
+  VELOX_ASSERT_USER_THROW(
+      varcharTypeWriteSideCheck("abc", 0),
+      "The length limit must be greater than 0.");
+  VELOX_ASSERT_USER_THROW(
+      varcharTypeWriteSideCheck("abc", -1),
+      "The length limit must be greater than 0.");
+
+  // Edge cases - input string is all spaces.
+  EXPECT_EQ(varcharTypeWriteSideCheck("   ", 2), "  ");
+  EXPECT_EQ(varcharTypeWriteSideCheck("   ", 3), "   ");
+  EXPECT_EQ(varcharTypeWriteSideCheck("   ", 1), " ");
+}
+
+} // namespace
+} // namespace facebook::velox::functions::sparksql::test
diff --git a/velox/functions/sparksql/tests/XxHash64Test.cpp b/velox/functions/sparksql/tests/XxHash64Test.cpp
index c375a7a1d302..75aa3de08709 100644
--- a/velox/functions/sparksql/tests/XxHash64Test.cpp
+++ b/velox/functions/sparksql/tests/XxHash64Test.cpp
@@ -184,8 +184,9 @@ TEST_F(XxHash64Test, array) {
 
   assertEqualVectors(
       makeFlatVector<int64_t>({-6698625589789238999, 8420071140774656230, 42}),
-      xxhash64(makeNullableArrayVector<int32_t>(
-          {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
+      xxhash64(
+          makeNullableArrayVector<int32_t>(
+              {{1, std::nullopt}, {std::nullopt, 2}, {std::nullopt}})));
 
   // Nested array.
   {
@@ -286,10 +287,11 @@ TEST_F(XxHash64Test, unknown) {
 
   assertEqualVectors(
       makeFlatVector<int64_t>({42, 42}),
-      xxhash64(makeNullableArrayVector<UnknownValue>({
-          {std::nullopt, std::nullopt},
-          {std::nullopt, std::nullopt, std::nullopt},
-      })));
+      xxhash64(
+          makeNullableArrayVector<UnknownValue>({
+              {std::nullopt, std::nullopt},
+              {std::nullopt, std::nullopt, std::nullopt},
+          })));
 
   auto mapVector = makeNullableMapVector<UnknownValue, UnknownValue>({
       std::nullopt,
diff --git a/velox/functions/sparksql/window/CMakeLists.txt b/velox/functions/sparksql/window/CMakeLists.txt
index 0aac94596717..124363f8ece2 100644
--- a/velox/functions/sparksql/window/CMakeLists.txt
+++ b/velox/functions/sparksql/window/CMakeLists.txt
@@ -18,7 +18,8 @@ velox_link_libraries(
   velox_buffer
   velox_exec
   velox_functions_window
-  Folly::folly)
+  Folly::folly
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/functions/sparksql/window/tests/CMakeLists.txt b/velox/functions/sparksql/window/tests/CMakeLists.txt
index a8f7a92d84ea..84526d933e14 100644
--- a/velox/functions/sparksql/window/tests/CMakeLists.txt
+++ b/velox/functions/sparksql/window/tests/CMakeLists.txt
@@ -12,26 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-set(CMAKE_WINDOW_TEST_LINK_LIBRARIES
-    velox_core
-    velox_exec
-    velox_exec_test_lib
-    velox_functions_spark_window
-    velox_functions_window_test_lib
-    velox_vector_fuzzer
-    velox_vector_test_lib
-    GTest::gtest
-    GTest::gtest_main)
+set(
+  CMAKE_WINDOW_TEST_LINK_LIBRARIES
+  velox_core
+  velox_exec
+  velox_exec_test_lib
+  velox_functions_spark_window
+  velox_functions_window_test_lib
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  GTest::gtest
+  GTest::gtest_main
+)
 
 set(CMAKE_WINDOW_TEST_MAIN_FILES Main.cpp)
 
-add_executable(velox_spark_windows_test SparkWindowTest.cpp
-                                        ${CMAKE_WINDOW_TEST_MAIN_FILES})
+add_executable(velox_spark_windows_test SparkWindowTest.cpp ${CMAKE_WINDOW_TEST_MAIN_FILES})
 
-add_test(
-  NAME velox_spark_windows_test
-  COMMAND velox_spark_windows_test
-  WORKING_DIRECTORY .)
+add_test(NAME velox_spark_windows_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/tests/CMakeLists.txt b/velox/functions/tests/CMakeLists.txt
index 6b5401bacff8..f81597f3f301 100644
--- a/velox/functions/tests/CMakeLists.txt
+++ b/velox/functions/tests/CMakeLists.txt
@@ -21,4 +21,5 @@ target_link_libraries(
   velox_functions_test_lib
   GTest::gmock
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/functions/tests/DynamicTypeFuncDemo.cpp b/velox/functions/tests/DynamicTypeFuncDemo.cpp
new file mode 100644
index 000000000000..1e656e51de05
--- /dev/null
+++ b/velox/functions/tests/DynamicTypeFuncDemo.cpp
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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/Conv.h"
+#include "velox/common/memory/Memory.h"
+#include "velox/exec/tests/utils/QueryAssertions.h"
+#include "velox/expression/Expr.h"
+#include "velox/expression/VectorFunction.h"
+#include "velox/expression/VectorReaders.h"
+#include "velox/expression/VectorWriters.h"
+#include "velox/parse/ExpressionsParser.h"
+#include "velox/parse/TypeResolver.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/FlatVector.h"
+#include "velox/vector/tests/utils/VectorMaker.h"
+
+namespace facebook::velox::functions {
+
+using namespace facebook::velox::exec;
+
+// Demo function showing how to use typeVariable("T") for dynamic type binding
+// Signature: T -> T, where T can be any type determined at runtime
+//
+// This demonstrates Velox's powerful type system that allows functions to:
+// 1. Accept arguments of any type (using type variable T)
+// 2. Automatically bind the type variable to the actual input type at runtime
+// 3. Ensure type consistency between input and output
+class DynamicTypeFunction : public exec::VectorFunction {
+ public:
+  void apply(
+      const SelectivityVector& rows,
+      std::vector<VectorPtr>& args,
+      const TypePtr& outputType,
+      exec::EvalCtx& context,
+      VectorPtr& result) const override {
+    // Prepare the output vector with the same type as input (T -> T)
+    BaseVector::ensureWritable(rows, outputType, context.pool(), result);
+
+    // This demo expects exactly one argument
+    VELOX_CHECK_EQ(args.size(), 1);
+
+    // For demonstration purposes, we expect the input to be a row type
+    // In a real implementation, this function could handle any type T
+    auto* input = args[0]->as<RowVector>();
+    VELOX_CHECK_NOT_NULL(input);
+
+    // Demo validation: check that all row fields are integers
+    // This shows how you can inspect the structure of dynamic types at runtime
+    for (auto i = 0; i < input->childrenSize(); ++i) {
+      VELOX_CHECK(input->childAt(i)->type()->isInteger());
+    }
+
+    // In a real function, you would:
+    // 1. Process the input data according to your function's logic
+    // 2. Populate the result vector with the computed values
+    // 3. Handle null values appropriately
+    //
+    // For this demo, we just validate the input structure
+  }
+
+  static std::vector<std::shared_ptr<exec::FunctionSignature>> signatures() {
+    // This signature demonstrates the power of Velox's type variable system:
+    //
+    // .typeVariable("T") - Declares a generic type variable named "T"
+    //   - T can be bound to ANY Velox type at runtime (INTEGER, VARCHAR, ROW,
+    //   ARRAY, etc.)
+    //   - The same T must be used consistently throughout the signature
+    //
+    // .returnType("T") - Output type matches the input type
+    // .argumentType("T") - Input type can be any type, bound to T
+    //
+    // At runtime, Velox will:
+    // 1. Examine the actual argument types passed to the function
+    // 2. Bind T to the concrete type (e.g., if input is ROW(INTEGER, VARCHAR),
+    // then T = ROW(INTEGER, VARCHAR))
+    // 3. Validate that the function can handle this type binding
+    // 4. Ensure type safety throughout execution
+    return {exec::FunctionSignatureBuilder()
+                .typeVariable("T") // Declare type variable T
+                .returnType("T") // Return type = T (same as input)
+                .argumentType("T") // First argument type = T
+                .build()};
+  }
+};
+
+namespace {
+void registerDynamicTypeFunction() {
+  exec::registerVectorFunction(
+      "dynamic_row_udf",
+      DynamicTypeFunction::signatures(),
+      std::make_unique<DynamicTypeFunction>());
+}
+} // namespace
+
+void runDynamicTypeTest(
+    const VectorPtr& elementVector,
+    size_t elementSize,
+    size_t numElements,
+    memory::MemoryPool* pool) {
+  std::vector<VectorPtr> elementVectors;
+  elementVectors.reserve(numElements);
+  for (auto i = 0; i < numElements; ++i) {
+    elementVectors.push_back(elementVector);
+  }
+  std::vector<std::string> names;
+  names.reserve(numElements);
+  std::vector<TypePtr> types;
+  types.reserve(numElements);
+  for (int i = 0; i < numElements; ++i) {
+    names.push_back("c" + std::to_string(i));
+    types.push_back(elementVector->type());
+  }
+  const auto expectedOutputType = ROW(std::move(names), std::move(types));
+
+  auto rowVector = std::make_shared<RowVector>(
+      pool, expectedOutputType, nullptr, elementSize, elementVectors);
+  auto inputVector = std::make_shared<RowVector>(
+      pool,
+      ROW({"c0"}, {rowVector->type()}),
+      nullptr,
+      elementSize,
+      std::vector<VectorPtr>{rowVector});
+
+  // Prepare for function call
+  std::shared_ptr<core::QueryCtx> queryCtx{core::QueryCtx::create()};
+  core::ExecCtx execCtx{pool, queryCtx.get()};
+  SelectivityVector rows(elementSize);
+  auto untypedExpr = parse::parseExpr("dynamic_row_udf(c0)", {});
+  auto parsedExpr =
+      core::Expressions::inferTypes(untypedExpr, inputVector->type(), pool);
+  exec::ExprSet exprSet({parsedExpr}, &execCtx);
+  exec::EvalCtx evalCtx(&execCtx, &exprSet, inputVector.get());
+  std::vector<VectorPtr> result{1};
+  exprSet.eval(rows, evalCtx, result);
+  VELOX_CHECK_EQ(result[0]->size(), elementSize);
+  VELOX_CHECK_EQ(result[0]->type(), expectedOutputType);
+}
+
+// Initialize Velox environment
+std::shared_ptr<memory::MemoryPool> initializeVelox() {
+  memory::MemoryManager::initialize(memory::MemoryManager::Options{});
+  registerDynamicTypeFunction();
+  parse::registerTypeResolver();
+  return memory::MemoryManager::getInstance()->addLeafPool();
+}
+
+// Create original row vector with array columns
+VectorPtr createOriginalRowVector(
+    memory::MemoryPool* pool,
+    int numRows,
+    int numCols,
+    int arraySize) {
+  velox::test::VectorMaker vectorMaker{pool};
+  std::vector<VectorPtr> arrayVectors;
+
+  for (int col = 0; col < numCols; ++col) {
+    auto arrayVector = vectorMaker.arrayVector<int64_t>(
+        numRows,
+        [arraySize](auto row) { return arraySize; },
+        [col](auto row, auto index) {
+          return row * 100 + col * 10 + index + 1;
+        });
+    arrayVectors.push_back(arrayVector);
+
+    // Log each arrayVector's toString
+    LOG(INFO) << "Created Column " << col << " (ArrayVector):";
+    LOG(INFO) << arrayVector->toString(0, numRows);
+  }
+
+  auto rowVector =
+      vectorMaker.rowVector({"col0", "col1", "col2"}, arrayVectors);
+
+  return rowVector;
+}
+
+// Demonstrate VectorReader<DynamicRow> usage
+VectorPtr readRowVector(
+    const VectorPtr& originalRowVector,
+    memory::MemoryPool* pool) {
+  DecodedVector decoded;
+  decoded.decode(*originalRowVector);
+  exec::VectorReader<DynamicRow> reader(&decoded);
+
+  velox::test::VectorMaker vectorMaker{pool};
+  std::vector<VectorPtr> newArrayVectors;
+
+  auto numRows = originalRowVector->size();
+  auto numCols = originalRowVector->as<RowVector>()->childrenSize();
+
+  for (int col = 0; col < numCols; ++col) {
+    std::vector<std::vector<int64_t>> columnData;
+
+    for (int row = 0; row < numRows; ++row) {
+      auto dynamicRowView = reader[row];
+      auto columnView = dynamicRowView.at(col);
+
+      if (auto arrayView = columnView->tryCastTo<Array<int64_t>>()) {
+        std::vector<int64_t> rowData;
+        for (size_t j = 0; j < arrayView->size(); ++j) {
+          auto value = (*arrayView)[j];
+          rowData.push_back(value.value());
+        }
+        columnData.push_back(rowData);
+
+        std::string arrayContent = "[";
+        for (size_t j = 0; j < rowData.size(); ++j) {
+          if (j > 0) {
+            arrayContent += ", ";
+          }
+          arrayContent += folly::to<std::string>(rowData[j]);
+        }
+        arrayContent += "]";
+        LOG(INFO) << "Read from Column " << col << " Row " << row << ": "
+                  << arrayContent;
+      }
+    }
+
+    auto newArrayVector = vectorMaker.arrayVector<int64_t>(columnData);
+    newArrayVectors.push_back(newArrayVector);
+  }
+
+  auto newRowVector =
+      vectorMaker.rowVector({"col0", "col1", "col2"}, newArrayVectors);
+
+  LOG(INFO) << "Created new rowVector from VectorReader<DynamicRow> data:";
+  LOG(INFO) << "New RowVector toString: " << newRowVector->toString(0, numRows);
+
+  return newRowVector;
+}
+
+// Demonstrate VectorWriter<DynamicRow> usage - creates new output vector
+VectorPtr writeRowVector(
+    const VectorPtr& referenceRowVector,
+    memory::MemoryPool* pool) {
+  LOG(INFO)
+      << "=== Using VectorWriter<DynamicRow> to create new output vector ===";
+
+  auto numRows = referenceRowVector->size();
+  auto numCols = referenceRowVector->as<RowVector>()->childrenSize();
+
+  // Get array size from the first array in the reference vector
+  auto firstArrayCol =
+      referenceRowVector->as<RowVector>()->childAt(0)->as<ArrayVector>();
+  auto arraySize = firstArrayCol->sizeAt(0);
+
+  // Create a new output vector with the same structure as reference
+  auto outputRowType = referenceRowVector->type();
+
+  // Create new output vector
+  VectorPtr outputVector;
+  SelectivityVector rows(numRows);
+  BaseVector::ensureWritable(rows, outputRowType, pool, outputVector);
+
+  // Set up VectorWriter to write to the new output vector
+  exec::VectorWriter<DynamicRow> dynamicWriter;
+  dynamicWriter.init(*outputVector->as<RowVector>());
+
+  // Write data using VectorWriter<DynamicRow>
+  for (int row = 0; row < numRows; ++row) {
+    dynamicWriter.setOffset(row);
+    auto& dynamicRowWriter = dynamicWriter.current();
+
+    // Write each column (array) for this row
+    for (int col = 0; col < numCols; ++col) {
+      auto& arrayWriter = dynamicRowWriter.get_writer_at(col);
+
+      if (auto typedArrayWriter = arrayWriter.tryCastTo<Array<int64_t>>()) {
+        typedArrayWriter->resize(arraySize);
+        for (int i = 0; i < arraySize; ++i) {
+          (*typedArrayWriter)[i] = row * 100 + col * 10 + i + 1;
+        }
+      }
+    }
+
+    dynamicWriter.commit();
+  }
+  dynamicWriter.finish();
+
+  LOG(INFO) << "Created new rowVector using VectorWriter<DynamicRow>:";
+  LOG(INFO) << "Output RowVector toString: "
+            << outputVector->toString(0, numRows);
+
+  return outputVector;
+}
+
+void runDynamicTypeDemo() {
+  // Step 1: Initialize Velox environment
+  auto pool = initializeVelox();
+
+  // Step 2: Create original row vector with array columns
+  const int numRows = 3;
+  const int numCols = 3;
+  const int arraySize = 4;
+  auto originalRowVector =
+      createOriginalRowVector(pool.get(), numRows, numCols, arraySize);
+
+  // Step 3: Demonstrate VectorReader<DynamicRow> usage
+  auto readerRowVector = readRowVector(originalRowVector, pool.get());
+
+  // Step 4: Demonstrate VectorWriter<DynamicRow> usage
+  auto writerRowVector = writeRowVector(originalRowVector, pool.get());
+
+  // Step 5: Verify that VectorReader output and VectorWriter output matches
+  // original
+  std::vector<RowVectorPtr> readerVecs = {
+      std::dynamic_pointer_cast<RowVector>(readerRowVector)};
+  std::vector<RowVectorPtr> writerVecs = {
+      std::dynamic_pointer_cast<RowVector>(writerRowVector)};
+  std::vector<RowVectorPtr> originalVecs = {
+      std::dynamic_pointer_cast<RowVector>(originalRowVector)};
+
+  exec::test::assertEqualResults(readerVecs, writerVecs);
+  exec::test::assertEqualResults(originalVecs, writerVecs);
+}
+
+} // namespace facebook::velox::functions
+
+int main(int argc, char** argv) {
+  facebook::velox::functions::runDynamicTypeDemo();
+  return 0;
+}
diff --git a/velox/functions/tests/FunctionRegistryTest.cpp b/velox/functions/tests/FunctionRegistryTest.cpp
index e94d849bbb1a..7cab3996579d 100644
--- a/velox/functions/tests/FunctionRegistryTest.cpp
+++ b/velox/functions/tests/FunctionRegistryTest.cpp
@@ -17,6 +17,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/expression/FunctionSignature.h"
 #include "velox/expression/RegisterSpecialForm.h"
 #include "velox/expression/VectorFunction.h"
@@ -32,7 +33,6 @@
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
-
 namespace {
 
 VELOX_DECLARE_VECTOR_FUNCTION(
@@ -85,7 +85,6 @@ inline void registerTestFunctions() {
 inline void registerTestVectorFunctionOne(const std::string& functionName) {
   VELOX_REGISTER_VECTOR_FUNCTION(udf_vector_func_one, functionName);
 }
-} // namespace
 
 class FunctionRegistryTest : public testing::Test {
  public:
@@ -98,16 +97,190 @@ class FunctionRegistryTest : public testing::Test {
       const std::string& functionName,
       const std::vector<TypePtr>& types,
       const TypePtr& expected) {
-    checkEqual(velox::resolveFunction(functionName, types), expected);
-    checkEqual(velox::resolveVectorFunction(functionName, types), expected);
+    auto type = velox::resolveFunction(functionName, types);
+    VELOX_EXPECT_EQ_TYPES(type, expected);
+
+    type = velox::resolveVectorFunction(functionName, types);
+    VELOX_EXPECT_EQ_TYPES(type, expected);
+
+    std::vector<TypePtr> coercions;
+    type = resolveFunctionWithCoercions(functionName, types, coercions);
+    VELOX_EXPECT_EQ_TYPES(type, expected);
+
+    if (expected != nullptr) {
+      EXPECT_EQ(types.size(), coercions.size());
+      for (const auto& coercion : coercions) {
+        EXPECT_EQ(coercion, nullptr);
+      }
+    }
+  }
+
+  struct ResolveFuncs {
+    std::function<TypePtr(const std::string&, const std::vector<TypePtr>&)>
+        resolveFunc;
+
+    std::function<TypePtr(
+        const std::string&,
+        const std::vector<TypePtr>&,
+        std::vector<TypePtr>&)>
+        resolveWithCoercionsFunc;
+
+    static ResolveFuncs function() {
+      return {
+          .resolveFunc = resolveFunction,
+          .resolveWithCoercionsFunc = resolveFunctionWithCoercions,
+      };
+    }
+
+    static ResolveFuncs specialForm() {
+      return {
+          .resolveFunc = [](const auto& name, const auto& argTypes) -> TypePtr {
+            try {
+              return resolveCallableSpecialForm(name, argTypes);
+            } catch (const VeloxException&) {
+              return nullptr;
+            }
+          },
+          .resolveWithCoercionsFunc = [](const auto& name,
+                                         const auto& argTypes,
+                                         auto& coercions) -> TypePtr {
+            try {
+              return resolveCallableSpecialFormWithCoercions(
+                  name, argTypes, coercions);
+            } catch (const VeloxException&) {
+              return nullptr;
+            }
+          },
+      };
+    }
+  };
+
+  void testCoercionsInt(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const ResolveFuncs& resolveFuncs,
+      const TypePtr& expectedReturnType,
+      const std::vector<TypePtr>& expectedCoercions) {
+    auto type = resolveFuncs.resolveFunc(name, argTypes);
+    ASSERT_TRUE(type == nullptr);
+
+    std::vector<TypePtr> coercions;
+    type = resolveFuncs.resolveWithCoercionsFunc(name, argTypes, coercions);
+
+    VELOX_EXPECT_EQ_TYPES(type, expectedReturnType);
+
+    EXPECT_EQ(coercions.size(), argTypes.size());
+    EXPECT_EQ(coercions.size(), expectedCoercions.size());
+
+    for (auto i = 0; i < coercions.size(); ++i) {
+      if (expectedCoercions[i] == nullptr) {
+        EXPECT_EQ(coercions[i], nullptr) << "Expected no coercion at " << i
+                                         << ": " << coercions[i]->toString();
+      } else {
+        ASSERT_NE(coercions[i], nullptr) << "at " << i;
+        EXPECT_EQ(*coercions[i], *expectedCoercions[i])
+            << "Expected: " << expectedCoercions[i]->toString()
+            << ", but got: " << coercions[i]->toString();
+      }
+    }
+  }
+
+  void testNoCoercionsInt(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const ResolveFuncs& resolveFuncs,
+      const TypePtr& expectedReturnType) {
+    auto type = resolveFuncs.resolveFunc(name, argTypes);
+    VELOX_EXPECT_EQ_TYPES(type, expectedReturnType);
+
+    std::vector<TypePtr> coercions;
+    type = resolveFuncs.resolveWithCoercionsFunc(name, argTypes, coercions);
+
+    VELOX_EXPECT_EQ_TYPES(type, expectedReturnType);
+
+    EXPECT_EQ(coercions.size(), argTypes.size());
+    for (const auto& coercion : coercions) {
+      EXPECT_EQ(coercion, nullptr);
+    }
   }
 
-  void checkEqual(const TypePtr& actual, const TypePtr& expected) {
-    if (expected) {
-      EXPECT_EQ(*actual, *expected);
-    } else {
-      EXPECT_EQ(actual, nullptr);
+  void testCannotResolveInt(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const ResolveFuncs& resolveFuncs) {
+    auto type = resolveFuncs.resolveFunc(name, argTypes);
+    ASSERT_TRUE(type == nullptr);
+
+    std::vector<TypePtr> coercions;
+    type = resolveFuncs.resolveWithCoercionsFunc(name, argTypes, coercions);
+    ASSERT_TRUE(type == nullptr);
+  }
+
+  void testCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType,
+      const std::vector<TypePtr>& expectedCoercions) {
+    testCoercionsInt(
+        name,
+        argTypes,
+        ResolveFuncs::function(),
+        expectedReturnType,
+        expectedCoercions);
+  }
+
+  void testNoCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType) {
+    testNoCoercionsInt(
+        name, argTypes, ResolveFuncs::function(), expectedReturnType);
+  }
+
+  void testCannotResolve(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes) {
+    testCannotResolveInt(name, argTypes, ResolveFuncs::function());
+  }
+
+  void testSpecialFormCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType,
+      const std::vector<TypePtr>& expectedCoercions) {
+    testCoercionsInt(
+        name,
+        argTypes,
+        ResolveFuncs::specialForm(),
+        expectedReturnType,
+        expectedCoercions);
+  }
+
+  void testSpecialFormNoCoercions(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes,
+      const TypePtr& expectedReturnType) {
+    testNoCoercionsInt(
+        name, argTypes, ResolveFuncs::specialForm(), expectedReturnType);
+  }
+
+  void testSpecialFormCannotResolve(
+      const std::string& name,
+      const std::vector<TypePtr>& argTypes) {
+    testCannotResolveInt(name, argTypes, ResolveFuncs::specialForm());
+  }
+
+  exec::FunctionSignaturePtr makeSignature(
+      const std::string& returnType,
+      const std::vector<std::string>& argTypes) {
+    exec::FunctionSignatureBuilder builder;
+    builder.returnType(returnType);
+
+    for (const auto& argType : argTypes) {
+      builder.argumentType(argType);
     }
+
+    return builder.build();
   }
 };
 
@@ -438,10 +611,11 @@ TEST_F(FunctionRegistryTest, companionFunction) {
       "array_agg_extract", "arbitrary_extract", "bitwise_and_agg_extract"};
 
   for (const auto& function : functions) {
-    ASSERT_FALSE(exec::simpleFunctions()
-                     .getFunctionSignaturesAndMetadata(function)
-                     .front()
-                     .first.companionFunction);
+    ASSERT_FALSE(
+        exec::simpleFunctions()
+            .getFunctionSignaturesAndMetadata(function)
+            .front()
+            .first.companionFunction);
   }
   for (const auto& function : companionFunctions) {
     ASSERT_TRUE(exec::getVectorFunctionMetadata(function)->companionFunction);
@@ -503,6 +677,167 @@ TEST_F(FunctionRegistryTest, resolveFunctionsBasedOnPriority) {
   ASSERT_EQ(*result5, *REAL());
 }
 
+class DummyVectorFunction : public velox::exec::VectorFunction {
+ public:
+  void apply(
+      const velox::SelectivityVector& /* rows */,
+      std::vector<velox::VectorPtr>& /* args */,
+      const TypePtr& /* outputType */,
+      velox::exec::EvalCtx& /* context */,
+      velox::VectorPtr& /* result */) const override {}
+};
+
+template <typename TExec>
+struct DummySimpleFunction {
+  VELOX_DEFINE_FUNCTION_TYPES(TExec);
+
+  template <typename T>
+  void call(T&, const T&, const T&) {}
+};
+
+TEST_F(FunctionRegistryTest, resolveFunctionWithCoercions) {
+  removeFunction("foo");
+
+  {
+    SCOPE_EXIT {
+      removeFunction("foo");
+    };
+
+    registerFunction<DummySimpleFunction, int32_t, int32_t, int32_t>({"foo"});
+    registerFunction<DummySimpleFunction, int64_t, int64_t, int64_t>({"foo"});
+    registerFunction<DummySimpleFunction, float, float, float>({"foo"});
+    registerFunction<DummySimpleFunction, double, double, double>({"foo"});
+
+    testCoercions(
+        "foo", {TINYINT(), TINYINT()}, INTEGER(), {INTEGER(), INTEGER()});
+
+    testCoercions(
+        "foo", {TINYINT(), SMALLINT()}, INTEGER(), {INTEGER(), INTEGER()});
+    testCoercions(
+        "foo", {SMALLINT(), TINYINT()}, INTEGER(), {INTEGER(), INTEGER()});
+
+    testCoercions("foo", {TINYINT(), REAL()}, REAL(), {REAL(), nullptr});
+    testCoercions("foo", {REAL(), TINYINT()}, REAL(), {nullptr, REAL()});
+
+    testNoCoercions("foo", {INTEGER(), INTEGER()}, INTEGER());
+    testNoCoercions("foo", {REAL(), REAL()}, REAL());
+    testNoCoercions("foo", {DOUBLE(), DOUBLE()}, DOUBLE());
+
+    testCannotResolve("foo", {TINYINT(), VARCHAR()});
+  }
+
+  {
+    SCOPE_EXIT {
+      removeFunction("foo");
+    };
+
+    exec::registerVectorFunction(
+        "foo",
+        {
+            makeSignature("integer", {"integer", "integer"}),
+            makeSignature("bigint", {"bigint", "bigint"}),
+            makeSignature("real", {"real", "real"}),
+        },
+        std::make_unique<DummyVectorFunction>());
+
+    testCoercions(
+        "foo", {TINYINT(), TINYINT()}, INTEGER(), {INTEGER(), INTEGER()});
+
+    testCoercions(
+        "foo", {TINYINT(), SMALLINT()}, INTEGER(), {INTEGER(), INTEGER()});
+    testCoercions(
+        "foo", {SMALLINT(), TINYINT()}, INTEGER(), {INTEGER(), INTEGER()});
+
+    testCoercions("foo", {TINYINT(), REAL()}, REAL(), {REAL(), nullptr});
+    testCoercions("foo", {REAL(), TINYINT()}, REAL(), {nullptr, REAL()});
+
+    testNoCoercions("foo", {INTEGER(), INTEGER()}, INTEGER());
+    testNoCoercions("foo", {REAL(), REAL()}, REAL());
+
+    testCannotResolve("foo", {TINYINT(), VARCHAR()});
+  }
+
+  // Coercions with complex types.
+  {
+    SCOPE_EXIT {
+      removeFunction("foo");
+    };
+
+    exec::registerVectorFunction(
+        "foo",
+        {
+            makeSignature("integer", {"array(integer)", "integer"}),
+            makeSignature("bigint", {"array(bigint)", "bigint"}),
+            makeSignature("real", {"array(real)", "real"}),
+        },
+        std::make_unique<DummyVectorFunction>());
+
+    testCoercions(
+        "foo",
+        {ARRAY(TINYINT()), SMALLINT()},
+        INTEGER(),
+        {ARRAY(INTEGER()), INTEGER()});
+
+    testNoCoercions("foo", {ARRAY(INTEGER()), INTEGER()}, INTEGER());
+
+    testCannotResolve("foo", {ARRAY(VARCHAR()), SMALLINT()});
+  }
+
+  // Coercions with variable number of arguments.
+  {
+    SCOPE_EXIT {
+      removeFunction("foo");
+    };
+
+    exec::registerVectorFunction(
+        "foo",
+        {velox::exec::FunctionSignatureBuilder()
+             .returnType("bigint")
+             .argumentType("bigint")
+             .variableArity("bigint")
+             .build(),
+         velox::exec::FunctionSignatureBuilder()
+             .returnType("double")
+             .argumentType("double")
+             .variableArity("double")
+             .build()},
+        std::make_unique<DummyVectorFunction>());
+
+    testCoercions(
+        "foo",
+        {TINYINT(), SMALLINT(), INTEGER()},
+        BIGINT(),
+        {BIGINT(), BIGINT(), BIGINT()});
+
+    testNoCoercions("foo", {BIGINT(), BIGINT(), BIGINT()}, BIGINT());
+
+    testCannotResolve("foo", {TINYINT(), SMALLINT(), VARCHAR()});
+  }
+
+  // Coercions with generic types.
+  {
+    SCOPE_EXIT {
+      removeFunction("foo");
+    };
+
+    exec::registerVectorFunction(
+        "foo",
+        {velox::exec::FunctionSignatureBuilder()
+             .typeVariable("T")
+             .returnType("T")
+             .argumentType("T")
+             .argumentType("T")
+             .build()},
+        std::make_unique<DummyVectorFunction>());
+
+    testCoercions("foo", {TINYINT(), REAL()}, REAL(), {REAL(), nullptr});
+
+    testNoCoercions("foo", {INTEGER(), INTEGER()}, INTEGER());
+
+    testCannotResolve("foo", {TINYINT(), VARCHAR()});
+  }
+}
+
 TEST_F(FunctionRegistryTest, resolveSpecialForms) {
   auto andResult =
       resolveFunctionOrCallableSpecialForm("and", {BOOLEAN(), BOOLEAN()});
@@ -528,6 +863,89 @@ TEST_F(FunctionRegistryTest, resolveSpecialForms) {
   ASSERT_EQ(*tryResult, *REAL());
 }
 
+TEST_F(FunctionRegistryTest, resolveIfWithCoercions) {
+  testSpecialFormCoercions(
+      "if",
+      {BOOLEAN(), UNKNOWN(), BIGINT()},
+      BIGINT(),
+      {nullptr, BIGINT(), nullptr});
+
+  testSpecialFormCoercions(
+      "if",
+      {BOOLEAN(), BIGINT(), UNKNOWN()},
+      BIGINT(),
+      {nullptr, nullptr, BIGINT()});
+
+  testSpecialFormCoercions(
+      "if",
+      {BOOLEAN(), SMALLINT(), INTEGER()},
+      INTEGER(),
+      {nullptr, INTEGER(), nullptr});
+
+  testSpecialFormCoercions(
+      "if",
+      {BOOLEAN(), INTEGER(), SMALLINT()},
+      INTEGER(),
+      {nullptr, nullptr, INTEGER()});
+
+  testSpecialFormNoCoercions(
+      "if", {BOOLEAN(), INTEGER(), INTEGER()}, INTEGER());
+
+  testSpecialFormCannotResolve("if", {BOOLEAN(), INTEGER(), VARCHAR()});
+}
+
+TEST_F(FunctionRegistryTest, resolveSwitchWithCoercions) {
+  testSpecialFormCoercions(
+      "switch",
+      {BOOLEAN(),
+       UNKNOWN(),
+       BOOLEAN(),
+       INTEGER(),
+       BOOLEAN(),
+       BIGINT(),
+       SMALLINT()},
+      BIGINT(),
+      {nullptr, BIGINT(), nullptr, BIGINT(), nullptr, nullptr, BIGINT()});
+
+  testSpecialFormCoercions(
+      "switch",
+      {BOOLEAN(),
+       BIGINT(),
+       BOOLEAN(),
+       INTEGER(),
+       BOOLEAN(),
+       UNKNOWN(),
+       SMALLINT()},
+      BIGINT(),
+      {nullptr, nullptr, nullptr, BIGINT(), nullptr, BIGINT(), BIGINT()});
+
+  testSpecialFormCoercions(
+      "switch",
+      {BOOLEAN(),
+       TINYINT(),
+       BOOLEAN(),
+       INTEGER(),
+       BOOLEAN(),
+       UNKNOWN(),
+       BIGINT()},
+      BIGINT(),
+      {nullptr, BIGINT(), nullptr, BIGINT(), nullptr, BIGINT(), nullptr});
+}
+
+TEST_F(FunctionRegistryTest, resolveCoalesceWithCoercions) {
+  testSpecialFormCoercions(
+      "coalesce", {UNKNOWN(), BIGINT()}, BIGINT(), {BIGINT(), nullptr});
+
+  testSpecialFormCoercions(
+      "coalesce", {BIGINT(), UNKNOWN()}, BIGINT(), {nullptr, BIGINT()});
+
+  testSpecialFormCoercions(
+      "coalesce",
+      {SMALLINT(), INTEGER(), BIGINT(), TINYINT()},
+      BIGINT(),
+      {BIGINT(), BIGINT(), nullptr, BIGINT()});
+}
+
 TEST_F(FunctionRegistryTest, resolveRowConstructor) {
   auto result = resolveFunctionOrCallableSpecialForm(
       "row_constructor", {INTEGER(), BOOLEAN(), DOUBLE()});
@@ -609,4 +1027,5 @@ TEST_F(FunctionRegistryTest, ipPrefixRegistration) {
   EXPECT_FALSE(result->second.supportsFlattening);
 }
 
+} // namespace
 } // namespace facebook::velox
diff --git a/velox/parse/CMakeLists.txt b/velox/parse/CMakeLists.txt
index 75a5e835933c..b092eca3b036 100644
--- a/velox/parse/CMakeLists.txt
+++ b/velox/parse/CMakeLists.txt
@@ -12,24 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 velox_add_library(velox_parse_expression Expressions.cpp)
-velox_link_libraries(
-  velox_parse_expression
-  velox_type
-  velox_parse_utils
-  velox_expression
-  velox_exec)
+velox_link_libraries(velox_parse_expression velox_type velox_parse_utils velox_expression)
 
 velox_add_library(velox_parse_parser ExpressionsParser.cpp QueryPlanner.cpp)
-velox_link_libraries(velox_parse_parser velox_parse_expression velox_type
-                     velox_duckdb_parser)
+velox_link_libraries(velox_parse_parser velox_parse_expression velox_type velox_duckdb_parser)
 
 velox_add_library(velox_parse_utils TypeResolver.cpp)
 velox_link_libraries(
   velox_parse_utils
   velox_buffer
+  velox_exec
   velox_type
   velox_vector
-  velox_function_registry)
+  velox_function_registry
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/parse/DuckLogicalOperator.h b/velox/parse/DuckLogicalOperator.h
index 581f796f9acf..9102574eefa6 100644
--- a/velox/parse/DuckLogicalOperator.h
+++ b/velox/parse/DuckLogicalOperator.h
@@ -161,6 +161,29 @@ class LogicalAggregate : public LogicalOperator {
   void ResolveTypes() override;
 };
 
+//! LogicalDistinct filters duplicate entries from its child operator
+class LogicalDistinct : public LogicalOperator {
+ public:
+  static constexpr const LogicalOperatorType TYPE =
+      LogicalOperatorType::LOGICAL_DISTINCT;
+
+ public:
+  explicit LogicalDistinct(DistinctType distinct_type);
+  explicit LogicalDistinct(
+      vector<unique_ptr<Expression>> targets,
+      DistinctType distinct_type);
+
+  //! Whether or not this is a DISTINCT or DISTINCT ON
+  DistinctType distinct_type;
+  //! The set of distinct targets
+  vector<unique_ptr<Expression>> distinct_targets;
+  //! The order by modifier (optional, only for distinct on)
+  unique_ptr<BoundOrderModifier> order_by;
+
+ protected:
+  void ResolveTypes() override;
+};
+
 //! LogicalCrossProduct represents a cross product between two relations
 class LogicalCrossProduct : public LogicalOperator {
  public:
@@ -374,4 +397,25 @@ class LogicalDelimJoin : public LogicalComparisonJoin {
   vector<unique_ptr<Expression>> duplicate_eliminated_columns;
 };
 
+//! LogicalAnyJoin represents a join with an arbitrary expression as
+//! JoinCondition
+class LogicalAnyJoin : public LogicalJoin {
+ public:
+  static constexpr const LogicalOperatorType TYPE =
+      LogicalOperatorType::LOGICAL_ANY_JOIN;
+
+ public:
+  explicit LogicalAnyJoin(JoinType type);
+
+  //! The JoinCondition on which this join is performed
+  unique_ptr<Expression> condition;
+
+ public:
+  string ParamsToString() const override;
+  void Serialize(FieldWriter& writer) const override;
+  static unique_ptr<LogicalOperator> Deserialize(
+      LogicalDeserializationState& state,
+      FieldReader& reader);
+};
+
 } // namespace duckdb
diff --git a/velox/parse/Expressions.cpp b/velox/parse/Expressions.cpp
index 4f6a3b3598fe..a2c45c99fc09 100644
--- a/velox/parse/Expressions.cpp
+++ b/velox/parse/Expressions.cpp
@@ -14,465 +14,132 @@
  * limitations under the License.
  */
 #include "velox/parse/Expressions.h"
-#include "velox/common/base/Exceptions.h"
-#include "velox/core/Expressions.h"
-#include "velox/exec/Aggregate.h"
-#include "velox/expression/SimpleFunctionRegistry.h"
-#include "velox/functions/FunctionRegistry.h"
-#include "velox/type/Type.h"
-#include "velox/vector/ConstantVector.h"
-#include "velox/vector/VariantToVector.h"
 
 namespace facebook::velox::core {
 
-// static
-Expressions::TypeResolverHook Expressions::resolverHook_;
-// static
-Expressions::FieldAccessHook Expressions::fieldAccessHook_;
-
-namespace {
+bool FieldAccessExpr::operator==(const IExpr& other) const {
+  if (!other.is(Kind::kFieldAccess)) {
+    return false;
+  }
 
-// Determine output type based on input types.
-TypePtr resolveTypeImpl(
-    std::vector<TypedExprPtr> inputs,
-    const std::shared_ptr<const CallExpr>& expr,
-    bool nullOnFailure) {
-  VELOX_CHECK_NOT_NULL(Expressions::getResolverHook());
-  return Expressions::getResolverHook()(inputs, expr, nullOnFailure);
+  auto* otherField = other.as<FieldAccessExpr>();
+  return name_ == otherField->name_ && compareAliasAndInputs(other);
 }
 
-namespace {
-std::shared_ptr<const core::CastTypedExpr> makeTypedCast(
-    const TypePtr& type,
-    const TypedExprPtr& input) {
-  return std::make_shared<const core::CastTypedExpr>(type, input, false);
+size_t FieldAccessExpr::localHash() const {
+  return std::hash<std::string>{}(name_);
 }
 
-std::vector<TypePtr> implicitCastTargets(const TypePtr& type) {
-  std::vector<TypePtr> targetTypes;
-  switch (type->kind()) {
-    // We decide not to implicitly upcast booleans because it maybe funky.
-    case TypeKind::BOOLEAN:
-      break;
-    case TypeKind::TINYINT:
-      targetTypes.emplace_back(SMALLINT());
-      [[fallthrough]];
-    case TypeKind::SMALLINT:
-      targetTypes.emplace_back(INTEGER());
-      targetTypes.emplace_back(REAL());
-      [[fallthrough]];
-    case TypeKind::INTEGER:
-      targetTypes.emplace_back(BIGINT());
-      targetTypes.emplace_back(DOUBLE());
-      [[fallthrough]];
-    case TypeKind::BIGINT:
-      break;
-    case TypeKind::REAL:
-      targetTypes.emplace_back(DOUBLE());
-      [[fallthrough]];
-    case TypeKind::DOUBLE:
-      break;
-    case TypeKind::ARRAY: {
-      auto childTargetTypes = implicitCastTargets(type->childAt(0));
-      for (auto childTarget : childTargetTypes) {
-        targetTypes.emplace_back(ARRAY(childTarget));
-      }
-      break;
-    }
-    default: // make compilers happy
-      break;
-  }
-  return targetTypes;
+namespace {
+std::string escapeName(const std::string& name) {
+  return folly::cEscape<std::string>(name);
 }
 } // namespace
 
-// All acceptable implicit casts on this expression.
-// TODO: If we get this to be recursive somehow, we can save on cast function
-// signatures that need to be compiled and registered.
-std::vector<TypedExprPtr> genImplicitCasts(const TypedExprPtr& typedExpr) {
-  auto targetTypes = implicitCastTargets(typedExpr->type());
-
-  std::vector<TypedExprPtr> implicitCasts;
-  implicitCasts.reserve(targetTypes.size());
-  for (auto targetType : targetTypes) {
-    implicitCasts.emplace_back(makeTypedCast(targetType, typedExpr));
+std::string FieldAccessExpr::toString() const {
+  if (isRootColumn()) {
+    return appendAliasIfExists(fmt::format("\"{}\"", escapeName(name_)));
   }
-  return implicitCasts;
-}
 
-// TODO: Arguably all of this could be done with just Types.
-TypedExprPtr adjustLastNArguments(
-    std::vector<TypedExprPtr> inputs,
-    const std::shared_ptr<const CallExpr>& expr,
-    size_t n) {
-  auto type = resolveTypeImpl(inputs, expr, true /*nullOnFailure*/);
-  if (type != nullptr) {
-    return std::make_unique<CallTypedExpr>(
-        type, inputs, std::string{expr->getFunctionName()});
-  }
-
-  if (n == 0) {
-    return nullptr;
-  }
-
-  size_t firstOfLastN = inputs.size() - n;
-  // use it
-  std::vector<TypedExprPtr> viableExprs{inputs[firstOfLastN]};
-  // or lose it
-  auto&& implicitCasts = genImplicitCasts(inputs[firstOfLastN]);
-  std::move(
-      implicitCasts.begin(),
-      implicitCasts.end(),
-      std::back_inserter(viableExprs));
-
-  for (auto& viableExpr : viableExprs) {
-    inputs[firstOfLastN] = viableExpr;
-    auto adjustedExpr = adjustLastNArguments(inputs, expr, n - 1);
-    if (adjustedExpr != nullptr) {
-      return adjustedExpr;
-    }
-  }
-
-  return nullptr;
+  return appendAliasIfExists(
+      fmt::format("dot({},\"{}\")", input()->toString(), escapeName(name_)));
 }
 
-TypedExprPtr createWithImplicitCast(
-    const std::shared_ptr<const core::CallExpr>& expr,
-    const std::vector<TypedExprPtr>& inputs) {
-  auto adjusted = adjustLastNArguments(inputs, expr, inputs.size());
-  if (adjusted) {
-    return adjusted;
+bool CallExpr::operator==(const IExpr& other) const {
+  if (!other.is(Kind::kCall)) {
+    return false;
   }
-  auto type = resolveTypeImpl(inputs, expr, false /*nullOnFailure*/);
-  return std::make_shared<CallTypedExpr>(
-      type, std::move(inputs), std::string{expr->getFunctionName()});
-}
 
-bool isLambdaArgument(const exec::TypeSignature& typeSignature) {
-  return typeSignature.baseName() == "function";
+  auto* otherCall = other.as<CallExpr>();
+  return name_ == otherCall->name_ && compareAliasAndInputs(other);
 }
 
-bool isLambdaArgument(const exec::TypeSignature& typeSignature, int numInputs) {
-  return isLambdaArgument(typeSignature) &&
-      (typeSignature.parameters().size() == numInputs + 1);
+size_t CallExpr::localHash() const {
+  return std::hash<std::string>{}(name_);
 }
 
-bool hasLambdaArgument(const exec::FunctionSignature& signature) {
-  for (const auto& type : signature.argumentTypes()) {
-    if (isLambdaArgument(type)) {
-      return true;
+std::string CallExpr::toString() const {
+  std::string buf{name_ + "("};
+  bool first = true;
+  for (auto& f : inputs()) {
+    if (!first) {
+      buf += ",";
     }
+    buf += f->toString();
+    first = false;
   }
-
-  return false;
+  buf += ")";
+  return appendAliasIfExists(buf);
 }
-} // namespace
-
-// static
-TypedExprPtr Expressions::inferTypes(
-    const std::shared_ptr<const core::IExpr>& expr,
-    const TypePtr& inputRow,
-    memory::MemoryPool* pool,
-    const VectorPtr& complexConstants) {
-  return inferTypes(expr, inputRow, {}, pool, complexConstants);
-}
-
-// static
-TypedExprPtr Expressions::inferTypes(
-    const std::shared_ptr<const core::IExpr>& expr,
-    const TypePtr& inputRow,
-    const std::vector<TypePtr>& lambdaInputTypes,
-    memory::MemoryPool* pool,
-    const VectorPtr& complexConstants) {
-  VELOX_CHECK_NOT_NULL(expr);
-
-  if (auto lambdaExpr = std::dynamic_pointer_cast<const LambdaExpr>(expr)) {
-    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, complexConstants)) {
-        return returnType;
-      }
-    }
-  }
-
-  // try rebuilding complex constant type from vector
-  if (auto fun = std::dynamic_pointer_cast<const CallExpr>(expr)) {
-    if (fun->getFunctionName() == "__complex_constant") {
-      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();
-      auto rowType = asRowType(ccInputRow->type());
-      return std::make_shared<const ConstantTypedExpr>(
-          ccInputRow->childAt(rowType->getChildIdx(name)));
-    }
-  }
-
-  std::vector<TypedExprPtr> children;
-  for (auto& child : expr->getInputs()) {
-    children.push_back(
-        inferTypes(child, inputRow, lambdaInputTypes, pool, complexConstants));
-  }
-
-  if (auto fae = std::dynamic_pointer_cast<const FieldAccessExpr>(expr)) {
-    if (fieldAccessHook_) {
-      auto result = fieldAccessHook_(fae, children);
-      if (result) {
-        return result;
-      }
-    }
-    VELOX_CHECK(
-        !fae->getFieldName().empty(), "Anonymous columns are not supported");
-    VELOX_CHECK_EQ(
-        children.size(), 1, "Unexpected number of children in FieldAccessExpr");
-    auto input = children.at(0)->type();
-    auto& row = input->asRow();
-    auto childIndex = row.getChildIdx(fae->getFieldName());
-    if (fae->isRootColumn()) {
-      return std::make_shared<FieldAccessTypedExpr>(
-          input->childAt(childIndex),
-          children.at(0),
-          std::string{fae->getFieldName()});
-    } else {
-      return std::make_shared<DereferenceTypedExpr>(
-          input->childAt(childIndex), children.at(0), childIndex);
-    }
-  }
-  if (auto fun = std::dynamic_pointer_cast<const CallExpr>(expr)) {
-    return createWithImplicitCast(fun, std::move(children));
-  }
-  if (auto input = std::dynamic_pointer_cast<const InputExpr>(expr)) {
-    return std::make_shared<const InputTypedExpr>(inputRow);
-  }
-  if (auto constant = std::dynamic_pointer_cast<const ConstantExpr>(expr)) {
-    if (constant->type()->kind() == TypeKind::ARRAY) {
-      // Transform variant vector into an ArrayVector, then wrap it into a
-      // ConstantVector<ComplexType>.
-      VELOX_CHECK_NOT_NULL(
-          pool, "parsing array literals requires a memory pool");
-      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>(
-        constant->type(), constant->value());
-  }
-  if (auto cast = std::dynamic_pointer_cast<const CastExpr>(expr)) {
-    return std::make_shared<const CastTypedExpr>(
-        cast->type(), std::move(children), cast->nullOnFailure());
-  }
-  if (auto alreadyTyped = std::dynamic_pointer_cast<const ITypedExpr>(expr)) {
-    return alreadyTyped;
+bool CastExpr::operator==(const IExpr& other) const {
+  if (!other.is(Kind::kCast)) {
+    return false;
   }
 
-  VELOX_FAIL("Unknown expression type: {}", expr->toString());
+  auto* otherCast = other.as<CastExpr>();
+  return *type_ == (*otherCast->type_) && isTryCast_ == otherCast->isTryCast_ &&
+      compareAliasAndInputs(other);
 }
 
-// static
-TypedExprPtr Expressions::resolveLambdaExpr(
-    const std::shared_ptr<const core::LambdaExpr>& lambdaExpr,
-    const TypePtr& inputRow,
-    const std::vector<TypePtr>& lambdaInputTypes,
-    memory::MemoryPool* pool,
-    const VectorPtr& complexConstants) {
-  auto names = lambdaExpr->inputNames();
-  auto body = lambdaExpr->body();
-
-  VELOX_CHECK_LE(names.size(), lambdaInputTypes.size());
-  std::vector<TypePtr> types;
-  for (auto i = 0; i < names.size(); ++i) {
-    types.push_back(lambdaInputTypes[i]);
-  }
-
-  auto signature =
-      ROW(std::vector<std::string>(names), std::vector<TypePtr>(types));
-
-  auto& inputRowType = inputRow->asRow();
-  for (auto i = 0; i < inputRowType.size(); ++i) {
-    if (!signature->containsChild(inputRowType.names()[i])) {
-      names.push_back(inputRowType.names()[i]);
-      types.push_back(inputRowType.childAt(i));
-    }
-  }
-
-  auto lambdaRow = ROW(std::move(names), std::move(types));
-
-  return std::make_shared<LambdaTypedExpr>(
-      signature, inferTypes(body, lambdaRow, pool, complexConstants));
+size_t CastExpr::localHash() const {
+  return bits::hashMix(type_->hashKind(), std::hash<bool>{}(isTryCast_));
 }
 
-namespace {
-bool isLambdaSignature(
-    const exec::FunctionSignature* signature,
-    const std::shared_ptr<const CallExpr>& callExpr) {
-  if (!hasLambdaArgument(*signature)) {
-    return false;
-  }
-
-  const auto numArguments = callExpr->getInputs().size();
+std::string CastExpr::toString() const {
+  return appendAliasIfExists(
+      fmt::format(
+          "{}({} as {})",
+          isTryCast_ ? "try_cast" : "cast",
+          input()->toString(),
+          type_->toString()));
+}
 
-  if (numArguments != signature->argumentTypes().size()) {
+bool ConstantExpr::operator==(const IExpr& other) const {
+  if (!other.is(Kind::kConstant)) {
     return false;
   }
 
-  bool match = true;
-  for (auto i = 0; i < numArguments; ++i) {
-    if (auto lambda = dynamic_cast<const core::LambdaExpr*>(
-            callExpr->getInputs()[i].get())) {
-      const auto numLambdaInputs = lambda->inputNames().size();
-      const auto& argumentType = signature->argumentTypes()[i];
-      if (!isLambdaArgument(argumentType, numLambdaInputs)) {
-        match = false;
-        break;
-      }
-    }
-  }
-
-  return match;
+  auto* otherConstant = other.as<ConstantExpr>();
+  return *type_ == (*otherConstant->type_) && value_ == otherConstant->value_ &&
+      compareAliasAndInputs(other);
 }
 
-const exec::FunctionSignature* findLambdaSignature(
-    const std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>&
-        signatures,
-    const std::shared_ptr<const CallExpr>& callExpr) {
-  const exec::FunctionSignature* matchingSignature = nullptr;
-  for (const auto& signature : signatures) {
-    if (isLambdaSignature(signature.get(), callExpr)) {
-      VELOX_CHECK_NULL(
-          matchingSignature,
-          "Cannot resolve ambiguous lambda function signatures for {}.",
-          callExpr->getFunctionName());
-      matchingSignature = signature.get();
-    }
-  }
-
-  return matchingSignature;
+size_t ConstantExpr::localHash() const {
+  return bits::hashMix(type_->hashKind(), value_.hash());
 }
 
-const exec::FunctionSignature* findLambdaSignature(
-    const std::vector<const exec::FunctionSignature*>& signatures,
-    const std::shared_ptr<const CallExpr>& callExpr) {
-  const exec::FunctionSignature* matchingSignature = nullptr;
-  for (const auto& signature : signatures) {
-    if (isLambdaSignature(signature, callExpr)) {
-      VELOX_CHECK_NULL(
-          matchingSignature,
-          "Cannot resolve ambiguous lambda function signatures for {}.",
-          callExpr->getFunctionName());
-      matchingSignature = signature;
-    }
-  }
-
-  return matchingSignature;
+std::string ConstantExpr::toString() const {
+  return appendAliasIfExists(value_.toStringAsVector(type_));
 }
 
-// Assumes no overlap in function names between scalar and aggregate functions,
-// i.e. 'foo' is either a scalar or aggregate function.
-const exec::FunctionSignature* findLambdaSignature(
-    const std::shared_ptr<const CallExpr>& callExpr) {
-  // Look for a scalar lambda function.
-  auto scalarSignatures = getFunctionSignatures(callExpr->getFunctionName());
-  if (!scalarSignatures.empty()) {
-    return findLambdaSignature(scalarSignatures, callExpr);
-  }
-
-  // Look for an aggregate lambda function.
-  if (auto signatures =
-          exec::getAggregateFunctionSignatures(callExpr->getFunctionName())) {
-    return findLambdaSignature(signatures.value(), callExpr);
+bool LambdaExpr::operator==(const IExpr& other) const {
+  if (!other.is(Kind::kLambda)) {
+    return false;
   }
 
-  return nullptr;
+  auto* otherLambda = other.as<LambdaExpr>();
+  return arguments_ == otherLambda->arguments_ && *body_ == *otherLambda->body_;
 }
 
-} // namespace
-
-// static
-TypedExprPtr Expressions::tryResolveCallWithLambdas(
-    const std::shared_ptr<const CallExpr>& callExpr,
-    const TypePtr& inputRow,
-    memory::MemoryPool* pool,
-    const VectorPtr& complexConstants) {
-  auto signature = findLambdaSignature(callExpr);
-
-  if (signature == nullptr) {
-    return nullptr;
-  }
-
-  // Resolve non-lambda arguments first.
-  auto numArgs = callExpr->getInputs().size();
-  std::vector<TypedExprPtr> children(numArgs);
-  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, complexConstants);
-      childTypes[i] = children[i]->type();
-    }
+size_t LambdaExpr::localHash() const {
+  size_t hash = 0;
+  for (const auto& arg : arguments_) {
+    hash = bits::hashMix(hash, std::hash<std::string>{}(arg));
   }
+  return bits::hashMix(hash, body_->hash());
+}
 
-  // Resolve lambda arguments.
-  exec::SignatureBinder binder(*signature, childTypes);
-  binder.tryBind();
-  for (auto i = 0; i < numArgs; ++i) {
-    auto argSignature = signature->argumentTypes()[i];
-    if (isLambdaArgument(argSignature)) {
-      std::vector<TypePtr> lambdaTypes;
-      for (auto j = 0; j < argSignature.parameters().size() - 1; ++j) {
-        auto type = binder.tryResolveType(argSignature.parameters()[j]);
-        if (type == nullptr) {
-          return nullptr;
-        }
-        lambdaTypes.push_back(type);
-      }
+std::string LambdaExpr::toString() const {
+  std::ostringstream out;
 
-      children[i] = inferTypes(
-          callExpr->getInputs()[i],
-          inputRow,
-          lambdaTypes,
-          pool,
-          complexConstants);
-    }
+  if (arguments_.size() > 1) {
+    out << "(" << folly::join(", ", arguments_) << ")";
+  } else {
+    out << arguments_[0];
   }
-
-  return createWithImplicitCast(callExpr, std::move(children));
+  out << " -> " << body_->toString();
+  return out.str();
 }
 
-// This method returns null if the expression doesn't depend on any input row.
-TypePtr Expressions::getInputRowType(const TypedExprPtr& expr) {
-  if (auto inputExpr = std::dynamic_pointer_cast<const InputTypedExpr>(expr)) {
-    return inputExpr->type();
-  }
-  TypePtr inputRowType;
-  for (auto& input : expr->inputs()) {
-    auto childRowType = getInputRowType(input);
-    if (childRowType) {
-      VELOX_USER_CHECK(!inputRowType || *inputRowType == *childRowType);
-      inputRowType = childRowType;
-    }
-  }
-
-  return inputRowType;
-}
 } // namespace facebook::velox::core
diff --git a/velox/parse/Expressions.h b/velox/parse/Expressions.h
index b76ca9f28685..9da4e83a4931 100644
--- a/velox/parse/Expressions.h
+++ b/velox/parse/Expressions.h
@@ -16,202 +16,137 @@
 #pragma once
 
 #include "velox/common/base/Exceptions.h"
-#include "velox/core/Expressions.h"
 #include "velox/parse/IExpr.h"
 #include "velox/type/Variant.h"
 
 namespace facebook::velox::core {
 
-class CallExpr;
-class LambdaExpr;
-class FieldAccessExpr;
-
-class Expressions {
+class InputExpr : public IExpr {
  public:
-  using TypeResolverHook = std::function<TypePtr(
-      const std::vector<core::TypedExprPtr>& inputs,
-      const std::shared_ptr<const core::CallExpr>& expr,
-      bool nullOnFailure)>;
-
-  using FieldAccessHook = std::function<core::TypedExprPtr(
-      std::shared_ptr<const FieldAccessExpr> fae,
-      std::vector<core::TypedExprPtr>& children)>;
-
-  static TypedExprPtr inferTypes(
-      const std::shared_ptr<const IExpr>& expr,
-      const TypePtr& input,
-      memory::MemoryPool* pool,
-      const VectorPtr& complexConstants = nullptr);
+  InputExpr() : IExpr(IExpr::Kind::kInput, {}) {}
 
-  static TypePtr getInputRowType(const TypedExprPtr& expr);
-
-  static void setTypeResolverHook(TypeResolverHook hook) {
-    resolverHook_ = hook;
+  std::string toString() const override {
+    return "ROW";
   }
 
-  static TypeResolverHook getResolverHook() {
-    return resolverHook_;
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    return std::make_shared<InputExpr>();
   }
 
-  static void setFieldAccessHook(FieldAccessHook hook) {
-    fieldAccessHook_ = hook;
+  ExprPtr dropAlias() const override {
+    return std::make_shared<InputExpr>();
   }
 
-  static FieldAccessHook getFieldAccessHook() {
-    return fieldAccessHook_;
+  bool operator==(const IExpr& other) const override {
+    return other.is(Kind::kInput);
   }
 
-  static TypedExprPtr inferTypes(
-      const std::shared_ptr<const IExpr>& expr,
-      const TypePtr& input,
-      const std::vector<TypePtr>& lambdaInputTypes,
-      memory::MemoryPool* pool,
-      const VectorPtr& complexConstants = nullptr);
-
- private:
-  static TypedExprPtr resolveLambdaExpr(
-      const std::shared_ptr<const core::LambdaExpr>& lambdaExpr,
-      const TypePtr& inputRow,
-      const std::vector<TypePtr>& lambdaInputTypes,
-      memory::MemoryPool* pool,
-      const VectorPtr& complexConstants = nullptr);
-
-  static TypedExprPtr tryResolveCallWithLambdas(
-      const std::shared_ptr<const CallExpr>& expr,
-      const TypePtr& input,
-      memory::MemoryPool* pool,
-      const VectorPtr& complexConstants = nullptr);
-
-  static TypeResolverHook resolverHook_;
-  static FieldAccessHook fieldAccessHook_;
-};
-
-class InputExpr : public core::IExpr {
- public:
-  InputExpr() {}
-
-  std::string toString() const override {
-    return "ROW";
-  }
-
-  const std::vector<std::shared_ptr<const IExpr>>& getInputs() const override {
-    return EMPTY();
+  size_t localHash() const override {
+    return 0;
   }
 
   VELOX_DEFINE_CLASS_NAME(InputExpr)
 };
 
-class FieldAccessExpr : public core::IExpr {
+class FieldAccessExpr : public IExpr {
  public:
-  explicit FieldAccessExpr(
-      const std::string& name,
+  FieldAccessExpr(
+      std::string name,
       std::optional<std::string> alias,
-      std::vector<std::shared_ptr<const IExpr>>&& inputs =
-          std::vector<std::shared_ptr<const IExpr>>{
-              std::make_shared<const InputExpr>()})
-      : IExpr{std::move(alias)}, name_{name}, inputs_{std::move(inputs)} {
-    CHECK_EQ(inputs_.size(), 1);
+      std::vector<ExprPtr> inputs)
+      : IExpr{IExpr::Kind::kFieldAccess, std::move(inputs), std::move(alias)},
+        name_{std::move(name)} {
+    VELOX_USER_CHECK_EQ(IExpr::inputs().size(), 1);
   }
 
-  const std::string& getFieldName() const {
+  FieldAccessExpr(std::string name, std::optional<std::string> alias)
+      : IExpr{IExpr::Kind::kFieldAccess, {std::make_shared<const InputExpr>()}, std::move(alias)},
+        name_{std::move(name)} {}
+
+  const std::string& name() const {
     return name_;
   }
 
   bool isRootColumn() const {
-    if (UNLIKELY(inputs_.empty())) {
-      return false;
-    }
-    return dynamic_cast<const core::InputExpr*>(inputs_.front().get()) !=
-        nullptr;
+    return input()->is(Kind::kInput);
   }
 
-  std::string toString() const override {
-    if (UNLIKELY(inputs_.empty())) {
-      return appendAliasIfExists(toStringForRootColumn());
-    }
-    return appendAliasIfExists(
-        isRootColumn() ? toStringForRootColumn() : toStringForMemberAccess());
-  }
+  std::string toString() const override;
 
-  const std::vector<std::shared_ptr<const IExpr>>& getInputs() const override {
-    return inputs_;
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    VELOX_USER_CHECK_EQ(newInputs.size(), 1);
+    return std::make_shared<FieldAccessExpr>(
+        name_, alias(), std::move(newInputs));
   }
 
- private:
-  std::string toStringForRootColumn() const {
-    return "\"" + getEscapedName() + "\"";
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<FieldAccessExpr>(name_, alias, inputs());
   }
 
-  std::string toStringForMemberAccess() const {
-    return "dot(" + inputs_.front()->toString() + ",\"" + getEscapedName() +
-        "\")";
+  ExprPtr dropAlias() const override {
+    return std::make_shared<FieldAccessExpr>(name_, std::nullopt, inputs());
   }
 
-  std::string getEscapedName() const {
-    return folly::cEscape<std::string>(name_);
-  }
+  bool operator==(const IExpr& other) const override;
 
-  const std::string name_;
-  const std::vector<std::shared_ptr<const IExpr>> inputs_;
+  size_t localHash() const override;
 
   VELOX_DEFINE_CLASS_NAME(FieldAccessExpr)
+
+ private:
+  const std::string name_;
 };
 
-class CallExpr : public core::IExpr {
+class CallExpr : public IExpr {
  public:
   CallExpr(
-      std::string&& funcName,
-      std::vector<std::shared_ptr<const IExpr>>&& inputs,
+      std::string name,
+      std::vector<ExprPtr> inputs,
       std::optional<std::string> alias)
-      : core::IExpr{std::move(alias)},
-        name_{std::move(funcName)},
-        inputs_{std::move(inputs)} {
-    VELOX_CHECK(!name_.empty());
+      : IExpr{IExpr::Kind::kCall, std::move(inputs), std::move(alias)},
+        name_{std::move(name)} {
+    VELOX_USER_CHECK(!name_.empty());
   }
 
-  const std::string& getFunctionName() const {
+  const std::string& name() const {
     return name_;
   }
 
-  std::string toString() const override {
-    std::string buf{name_ + "("};
-    bool first = true;
-    for (auto& f : getInputs()) {
-      if (!first) {
-        buf += ",";
-      }
-      buf += f->toString();
-      first = false;
-    }
-    buf += ")";
-    return appendAliasIfExists(buf);
+  std::string toString() const override;
+
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    VELOX_CHECK_EQ(newInputs.size(), inputs().size());
+    return std::make_shared<CallExpr>(
+        folly::copy(name()), std::move(newInputs), alias());
   }
 
-  const std::vector<std::shared_ptr<const IExpr>>& getInputs() const override {
-    return inputs_;
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<CallExpr>(name(), inputs(), alias);
   }
 
- private:
-  const std::string name_;
-  const std::vector<std::shared_ptr<const IExpr>> inputs_;
+  ExprPtr dropAlias() const override {
+    return std::make_shared<CallExpr>(name(), inputs(), std::nullopt);
+  }
+
+  bool operator==(const IExpr& other) const override;
+
+  size_t localHash() const override;
 
   VELOX_DEFINE_CLASS_NAME(CallExpr)
+
+ private:
+  const std::string name_;
 };
 
 class ConstantExpr : public IExpr,
                      public std::enable_shared_from_this<ConstantExpr> {
  public:
-  explicit ConstantExpr(
-      TypePtr type,
-      variant value,
-      std::optional<std::string> alias)
-      : IExpr{std::move(alias)},
+  ConstantExpr(TypePtr type, variant value, std::optional<std::string> alias)
+      : IExpr{IExpr::Kind::kConstant, {}, std::move(alias)},
         type_{std::move(type)},
         value_{std::move(value)} {}
 
-  std::string toString() const override {
-    return appendAliasIfExists(variant{value_}.toJson(type_));
-  }
+  std::string toString() const override;
 
   const variant& value() const {
     return value_;
@@ -221,10 +156,23 @@ class ConstantExpr : public IExpr,
     return type_;
   }
 
-  const std::vector<std::shared_ptr<const IExpr>>& getInputs() const override {
-    return EMPTY();
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    VELOX_CHECK_EQ(newInputs.size(), 0);
+    return std::make_shared<ConstantExpr>(type(), value(), alias());
+  }
+
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<ConstantExpr>(type(), value(), alias);
+  }
+
+  ExprPtr dropAlias() const override {
+    return std::make_shared<ConstantExpr>(type(), value(), std::nullopt);
   }
 
+  bool operator==(const IExpr& other) const override;
+
+  size_t localHash() const override;
+
   VELOX_DEFINE_CLASS_NAME(ConstantExpr)
 
  private:
@@ -233,46 +181,50 @@ class ConstantExpr : public IExpr,
 };
 
 class CastExpr : public IExpr, public std::enable_shared_from_this<CastExpr> {
- private:
-  const TypePtr type_;
-  const std::shared_ptr<const IExpr> expr_;
-  const std::vector<std::shared_ptr<const IExpr>> inputs_;
-  bool nullOnFailure_;
-
  public:
-  explicit CastExpr(
+  CastExpr(
       const TypePtr& type,
-      const std::shared_ptr<const IExpr>& expr,
-      bool nullOnFailure,
+      const ExprPtr& expr,
+      bool isTryCast,
       std::optional<std::string> alias)
-      : IExpr{std::move(alias)},
+      : IExpr{IExpr::Kind::kCast, {expr}, std::move(alias)},
         type_(type),
-        expr_(expr),
-        inputs_({expr}),
-        nullOnFailure_(nullOnFailure) {}
+        isTryCast_(isTryCast) {}
 
-  std::string toString() const override {
-    return appendAliasIfExists(
-        "cast(" + expr_->toString() + ", " + type_->toString() + ")");
+  std::string toString() const override;
+
+  const TypePtr& type() const {
+    return type_;
   }
 
-  const std::vector<std::shared_ptr<const IExpr>>& getInputs() const override {
-    return inputs_;
+  bool isTryCast() const {
+    return isTryCast_;
   }
 
-  const TypePtr& type() const {
-    return type_;
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    VELOX_CHECK_EQ(newInputs.size(), 1);
+    return std::make_shared<CastExpr>(
+        type(), newInputs[0], isTryCast_, alias());
   }
 
-  const std::shared_ptr<const IExpr>& expr() const {
-    return expr_;
+  ExprPtr withAlias(const std::string& alias) const override {
+    return std::make_shared<CastExpr>(type(), input(), isTryCast_, alias);
   }
 
-  bool nullOnFailure() const {
-    return nullOnFailure_;
+  ExprPtr dropAlias() const override {
+    return std::make_shared<CastExpr>(
+        type(), input(), isTryCast_, std::nullopt);
   }
 
+  bool operator==(const IExpr& other) const override;
+
+  size_t localHash() const override;
+
   VELOX_DEFINE_CLASS_NAME(CastExpr)
+
+ private:
+  const TypePtr type_;
+  const bool isTryCast_;
 };
 
 /// Represents lambda expression as a list of inputs and the body expression.
@@ -282,45 +234,41 @@ class CastExpr : public IExpr, public std::enable_shared_from_this<CastExpr> {
 class LambdaExpr : public IExpr,
                    public std::enable_shared_from_this<LambdaExpr> {
  public:
-  LambdaExpr(
-      std::vector<std::string> inputNames,
-      std::shared_ptr<const IExpr> body)
-      : inputNames_{std::move(inputNames)}, body_{{std::move(body)}} {
-    VELOX_CHECK(!inputNames_.empty());
+  LambdaExpr(std::vector<std::string> arguments, ExprPtr body)
+      : IExpr(IExpr::Kind::kLambda, {}),
+        arguments_{std::move(arguments)},
+        body_{std::move(body)} {
+    VELOX_USER_CHECK(!arguments_.empty());
   }
 
-  const std::vector<std::string>& inputNames() const {
-    return inputNames_;
+  const std::vector<std::string>& arguments() const {
+    return arguments_;
   }
 
-  const std::shared_ptr<const IExpr>& body() const {
-    return body_[0];
+  const ExprPtr& body() const {
+    return body_;
   }
 
-  std::string toString() const override {
-    std::ostringstream out;
-    if (inputNames_.size() > 1) {
-      out << "(";
-      for (auto i = 0; i < inputNames_.size(); ++i) {
-        if (i > 0) {
-          out << ", ";
-        }
-        out << inputNames_[i];
-      }
-      out << ")";
-    } else {
-      out << inputNames_[0];
-    }
-    out << " -> " << body_[0]->toString();
-    return out.str();
+  ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const override {
+    VELOX_CHECK_EQ(newInputs.size(), 0);
+    return std::make_shared<LambdaExpr>(arguments(), body());
   }
 
-  const std::vector<std::shared_ptr<const IExpr>>& getInputs() const override {
-    return body_;
+  ExprPtr dropAlias() const override {
+    return std::make_shared<LambdaExpr>(arguments(), body());
   }
 
+  std::string toString() const override;
+
+  bool operator==(const IExpr& other) const override;
+
+  size_t localHash() const override;
+
+  VELOX_DEFINE_CLASS_NAME(LambdaExpr)
+
  private:
-  std::vector<std::string> inputNames_;
-  std::vector<std::shared_ptr<const IExpr>> body_;
+  const std::vector<std::string> arguments_;
+  const ExprPtr body_;
 };
+
 } // namespace facebook::velox::core
diff --git a/velox/parse/ExpressionsParser.cpp b/velox/parse/ExpressionsParser.cpp
index c2a3469f5bc3..a04a29a6860e 100644
--- a/velox/parse/ExpressionsParser.cpp
+++ b/velox/parse/ExpressionsParser.cpp
@@ -18,17 +18,16 @@
 
 namespace facebook::velox::parse {
 
-std::shared_ptr<const core::IExpr> parseExpr(
-    const std::string& expr,
-    const ParseOptions& options) {
+core::ExprPtr parseExpr(const std::string& expr, const ParseOptions& options) {
   facebook::velox::duckdb::ParseOptions duckConversionOptions;
   duckConversionOptions.parseDecimalAsDouble = options.parseDecimalAsDouble;
   duckConversionOptions.parseIntegerAsBigint = options.parseIntegerAsBigint;
+  duckConversionOptions.parseInListAsArray = options.parseInListAsArray;
   duckConversionOptions.functionPrefix = options.functionPrefix;
   return facebook::velox::duckdb::parseExpr(expr, duckConversionOptions);
 }
 
-std::vector<std::shared_ptr<const core::IExpr>> parseMultipleExpressions(
+std::vector<core::ExprPtr> parseMultipleExpressions(
     const std::string& expr,
     const ParseOptions& options) {
   facebook::velox::duckdb::ParseOptions duckConversionOptions;
@@ -39,9 +38,13 @@ std::vector<std::shared_ptr<const core::IExpr>> parseMultipleExpressions(
       expr, duckConversionOptions);
 }
 
-std::pair<std::shared_ptr<const core::IExpr>, core::SortOrder> parseOrderByExpr(
-    const std::string& expr) {
-  return facebook::velox::duckdb::parseOrderByExpr(expr);
+OrderByClause parseOrderByExpr(const std::string& expr) {
+  auto orderBy = facebook::velox::duckdb::parseOrderByExpr(expr);
+
+  return {
+      .expr = std::move(orderBy.expr),
+      .ascending = orderBy.ascending,
+      .nullsFirst = orderBy.nullsFirst};
 }
 
 } // namespace facebook::velox::parse
diff --git a/velox/parse/ExpressionsParser.h b/velox/parse/ExpressionsParser.h
index dfdf78c9adfb..e4ee66b27f05 100644
--- a/velox/parse/ExpressionsParser.h
+++ b/velox/parse/ExpressionsParser.h
@@ -15,9 +15,6 @@
  */
 #pragma once
 
-#include <set>
-#include "velox/core/PlanNode.h"
-#include "velox/core/QueryCtx.h"
 #include "velox/parse/IExpr.h"
 
 namespace facebook::velox::parse {
@@ -27,6 +24,9 @@ struct ParseOptions {
   // Retain legacy behavior by default.
   bool parseDecimalAsDouble = true;
   bool parseIntegerAsBigint = true;
+  // Controls whether to parse the values in an IN list as separate arguments or
+  // as a single array argument.
+  bool parseInListAsArray = true;
 
   /// SQL functions could be registered with different prefixes by the user.
   /// This parameter is the registered prefix of presto or spark functions,
@@ -34,14 +34,17 @@ struct ParseOptions {
   std::string functionPrefix;
 };
 
-std::shared_ptr<const core::IExpr> parseExpr(
-    const std::string& expr,
-    const ParseOptions& options);
+core::ExprPtr parseExpr(const std::string& expr, const ParseOptions& options);
+
+struct OrderByClause {
+  core::ExprPtr expr;
+  bool ascending;
+  bool nullsFirst;
+};
 
-std::pair<std::shared_ptr<const core::IExpr>, core::SortOrder> parseOrderByExpr(
-    const std::string& expr);
+OrderByClause parseOrderByExpr(const std::string& expr);
 
-std::vector<std::shared_ptr<const core::IExpr>> parseMultipleExpressions(
+std::vector<core::ExprPtr> parseMultipleExpressions(
     const std::string& expr,
     const ParseOptions& options);
 
diff --git a/velox/parse/IExpr.h b/velox/parse/IExpr.h
index ce32f50a488b..b07d7cad1337 100644
--- a/velox/parse/IExpr.h
+++ b/velox/parse/IExpr.h
@@ -15,9 +15,13 @@
  */
 #pragma once
 
-#include "velox/common/base/ClassName.h"
+#include <fmt/format.h>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+#include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
-#include "velox/type/Type.h"
 
 namespace facebook::velox::core {
 
@@ -27,39 +31,157 @@ using ExprPtr = std::shared_ptr<const IExpr>;
 /// An implicitly-typed expression, such as function call, literal, etc.
 class IExpr {
  public:
-  explicit IExpr(std::optional<std::string> alias = std::nullopt)
-      : alias_{std::move(alias)} {}
+  enum class Kind : int8_t {
+    kInput = 0,
+    kFieldAccess = 1,
+    kCall = 2,
+    kCast = 3,
+    kConstant = 4,
+    kLambda = 5,
+    kSubquery = 6,
+  };
 
-  virtual const std::vector<std::shared_ptr<const IExpr>>& getInputs()
-      const = 0;
+  explicit IExpr(
+      Kind kind,
+      std::vector<ExprPtr> inputs,
+      std::optional<std::string> alias = std::nullopt)
+      : kind_{kind}, inputs_{std::move(inputs)}, alias_{std::move(alias)} {}
 
-  std::shared_ptr<const IExpr> getInput() const {
-    return getInputs().size() == 1 ? getInputs().at(0) : nullptr;
+  virtual ~IExpr() = default;
+
+  Kind kind() const {
+    return kind_;
   }
 
-  virtual ~IExpr() = default;
+  bool is(Kind kind) const {
+    return kind_ == kind;
+  }
 
-  virtual std::string toString() const = 0;
+  template <typename T>
+  const T* as() const {
+    return dynamic_cast<const T*>(this);
+  }
+
+  const std::vector<ExprPtr>& inputs() const {
+    return inputs_;
+  }
+
+  const ExprPtr& input() const {
+    VELOX_CHECK_EQ(1, inputs_.size());
+    return inputs_.at(0);
+  }
+
+  const ExprPtr& inputAt(size_t index) const {
+    VELOX_CHECK_LT(index, inputs_.size());
+    return inputs_.at(index);
+  }
 
   const std::optional<std::string>& alias() const {
     return alias_;
   }
 
- protected:
-  static const std::vector<std::shared_ptr<const IExpr>>& EMPTY() {
-    static const std::vector<std::shared_ptr<const IExpr>> empty{};
-    return empty;
+  virtual std::string toString() const = 0;
+
+  /// Returns a copy of this expression with the given inputs.
+  virtual ExprPtr replaceInputs(std::vector<ExprPtr> newInputs) const = 0;
+
+  /// Returns a copy of this expression with the the new alias added.
+  ///
+  /// The last alias added will win if called multiple times. Throws in case the
+  /// subclass does not implement it.
+  virtual ExprPtr withAlias(const std::string& alias) const {
+    VELOX_FAIL("Unable to add alias to expression '{}'", *this);
+  }
+
+  /// Returns a copy of this expression with the alias removed.
+  virtual ExprPtr dropAlias() const = 0;
+
+  size_t hash() const {
+    size_t hash = localHash();
+    for (size_t i = 0; i < inputs_.size(); ++i) {
+      hash = bits::hashMix(hash, inputs_[i]->hash());
+    }
+
+    if (alias_.has_value()) {
+      hash = bits::hashMix(hash, std::hash<std::string>{}(alias_.value()));
+    }
+
+    hash = bits::hashMix(hash, std::hash<int8_t>{}(static_cast<int8_t>(kind_)));
+
+    return hash;
+  }
+
+  virtual bool operator==(const IExpr& other) const = 0;
+
+  friend std::ostream& operator<<(std::ostream& os, const IExpr& expr) {
+    return os << expr.toString();
   }
 
-  std::string appendAliasIfExists(std::string s) const {
+ protected:
+  // Returns a hash that include values specific to the expression. Doesn't
+  // include inputs, kind or alias.
+  virtual size_t localHash() const = 0;
+
+  std::string appendAliasIfExists(std::string name) const {
     if (!alias_.has_value()) {
-      return s;
+      return name;
     }
 
-    return fmt::format("{} AS {}", std::move(s), alias_.value());
+    return fmt::format("{} AS {}", std::move(name), alias_.value());
   }
 
-  std::optional<std::string> alias_;
+  bool compareAliasAndInputs(const IExpr& other) const {
+    if (alias() != other.alias() || inputs().size() != other.inputs().size()) {
+      return false;
+    }
+
+    for (size_t i = 0; i < inputs().size(); ++i) {
+      if (!(*inputs()[i] == *other.inputs()[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  const Kind kind_;
+  const std::vector<ExprPtr> inputs_;
+  const std::optional<std::string> alias_;
+};
+
+/// Hash functor for IExpr to use with folly::F14HashMap and other hash
+/// containers. This functor can be used with ExprPtr keys.
+struct IExprHash {
+  size_t operator()(const ExprPtr& expr) const {
+    return expr->hash();
+  }
+};
+
+/// Equal functor for IExpr to use with folly::F14HashMap and other hash
+/// containers. This functor can be used with ExprPtr keys.
+struct IExprEqual {
+  bool operator()(const ExprPtr& lhs, const ExprPtr& rhs) const {
+    return *lhs == *rhs;
+  }
 };
 
 } // namespace facebook::velox::core
+
+template <>
+struct fmt::formatter<facebook::velox::core::IExpr>
+    : fmt::formatter<std::string> {
+  auto format(const facebook::velox::core::IExpr& expr, format_context& ctx)
+      const {
+    return fmt::formatter<std::string>::format(expr.toString(), ctx);
+  }
+};
+
+// For ExprPtr (shared_ptr)
+template <>
+struct fmt::formatter<facebook::velox::core::ExprPtr>
+    : fmt::formatter<std::string> {
+  auto format(const facebook::velox::core::ExprPtr& expr, format_context& ctx)
+      const {
+    return fmt::formatter<std::string>::format(
+        expr ? expr->toString() : "null", ctx);
+  }
+};
diff --git a/velox/parse/PlanNodeIdGenerator.h b/velox/parse/PlanNodeIdGenerator.h
index 3483cac66883..4ec2722e99a1 100644
--- a/velox/parse/PlanNodeIdGenerator.h
+++ b/velox/parse/PlanNodeIdGenerator.h
@@ -15,7 +15,8 @@
  */
 #pragma once
 
-#include "velox/core/PlanNode.h"
+#include <fmt/format.h>
+#include <string>
 
 namespace facebook::velox::core {
 
@@ -25,7 +26,7 @@ class PlanNodeIdGenerator {
  public:
   explicit PlanNodeIdGenerator(int startId = 0) : nextId_{startId} {}
 
-  PlanNodeId next() {
+  std::string next() {
     return fmt::format("{}", nextId_++);
   }
 
diff --git a/velox/parse/QueryPlanner.cpp b/velox/parse/QueryPlanner.cpp
index 313f70b7b440..3b2a7b1ede07 100644
--- a/velox/parse/QueryPlanner.cpp
+++ b/velox/parse/QueryPlanner.cpp
@@ -16,7 +16,6 @@
 
 #include "velox/parse/QueryPlanner.h"
 #include "velox/duckdb/conversion/DuckConversion.h"
-#include "velox/expression/ScopedVarSetter.h"
 #include "velox/parse/DuckLogicalOperator.h"
 
 #include <duckdb.hpp> // @manual
@@ -59,8 +58,9 @@ struct QueryContext {
   MakeTableScan makeTableScan;
   bool isInDelimJoin{false};
 
-  QueryContext(const std::unordered_map<std::string, std::vector<RowVectorPtr>>&
-                   _inMemoryTables)
+  QueryContext(
+      const std::unordered_map<std::string, std::vector<RowVectorPtr>>&
+          _inMemoryTables)
       : inMemoryTables{_inMemoryTables} {}
 
   std::string nextNodeId() {
@@ -141,7 +141,8 @@ PlanNodePtr toVeloxPlan(
                 sources[0]->outputType()->childAt(0),
                 sources[0]->outputType()->asRow().nameOf(0))},
         std::vector<std::string>{"a"},
-        std::nullopt, // ordinalityName
+        /*ordinalityName=*/std::nullopt,
+        /*emptyUnnestValueName=*/std::nullopt,
         std::move(sources[0]));
   }
 
@@ -182,8 +183,9 @@ PlanNodePtr toVeloxPlan(
         children.push_back(rowVector->childAt(columnIds[i]));
       }
     }
-    data.push_back(std::make_shared<RowVector>(
-        pool, rowType, nullptr, rowVector->size(), children));
+    data.push_back(
+        std::make_shared<RowVector>(
+            pool, rowType, nullptr, rowVector->size(), children));
   }
 
   return std::make_shared<ValuesNode>(queryContext.nextNodeId(), data);
@@ -314,8 +316,7 @@ TypedExprPtr toVeloxExpression(
           std::move(children),
           name);
       if (negate) {
-        return std::make_shared<CallTypedExpr>(
-            BOOLEAN(), std::vector<TypedExprPtr>{call}, "not");
+        return std::make_shared<CallTypedExpr>(BOOLEAN(), "not", call);
       }
       return call;
     }
@@ -360,7 +361,7 @@ PlanNodePtr toVeloxPlan(
       veloxFilter = conjunct;
     } else {
       veloxFilter = std::make_shared<CallTypedExpr>(
-          BOOLEAN(), std::vector<TypedExprPtr>{veloxFilter, conjunct}, "and");
+          BOOLEAN(), "and", veloxFilter, conjunct);
     }
   }
   return std::make_shared<FilterNode>(
@@ -382,6 +383,7 @@ PlanNodePtr toVeloxPlan(
   auto columnBindings = logicalProjection.GetColumnBindings();
 
   std::vector<std::string> names;
+  names.reserve(projections.size());
   for (auto i = 0; i < projections.size(); ++i) {
     names.push_back(queryContext.nextColumnName("_p"));
   }
@@ -436,8 +438,9 @@ PlanNodePtr toVeloxPlan(
       } else {
         identityProjection = false;
         projectNames.push_back(queryContext.nextColumnName("_p"));
-        fieldInputs.push_back(std::make_shared<FieldAccessTypedExpr>(
-            input->type(), projectNames.back()));
+        fieldInputs.push_back(
+            std::make_shared<FieldAccessTypedExpr>(
+                input->type(), projectNames.back()));
       }
     }
 
@@ -463,8 +466,9 @@ PlanNodePtr toVeloxPlan(
     } else {
       identityProjection = false;
       projectNames.push_back(queryContext.nextColumnName("_p"));
-      groupingKeys.push_back(std::make_shared<FieldAccessTypedExpr>(
-          groupingExpr->type(), projectNames.back()));
+      groupingKeys.push_back(
+          std::make_shared<FieldAccessTypedExpr>(
+              groupingExpr->type(), projectNames.back()));
     }
   }
 
@@ -479,6 +483,7 @@ PlanNodePtr toVeloxPlan(
   }
 
   std::vector<std::string> names;
+  names.reserve(aggregates.size());
   for (auto i = 0; i < aggregates.size(); ++i) {
     names.push_back(queryContext.nextColumnName("_a"));
   }
@@ -490,7 +495,8 @@ PlanNodePtr toVeloxPlan(
       std::vector<FieldAccessTypedExprPtr>{}, // preGroupedKeys
       names,
       std::move(aggregates),
-      false, // ignoreNullKeys
+      /*ignoreNullKeys=*/false,
+      /*noGroupsSpanBatches=*/false,
       source);
 }
 
@@ -502,7 +508,7 @@ PlanNodePtr toVeloxPlan(
   VeloxColumnProjections projections(queryContext);
   std::vector<FieldAccessTypedExprPtr> keys;
   std::vector<SortOrder> sortOrder;
-  auto source = sources[0];
+  const auto& source = sources[0];
   for (auto& order : logicalOrder.orders) {
     keys.push_back(
         projections.toFieldAccess(*order.expression, source->outputType()));
@@ -707,8 +713,6 @@ PlanNodePtr toVeloxPlan(
     QueryContext& queryContext) {
   std::vector<PlanNodePtr> sources;
 
-  ScopedVarSetter isDelim(
-      &queryContext.isInDelimJoin, queryContext.isInDelimJoin);
   if (plan.type == ::duckdb::LogicalOperatorType::LOGICAL_DELIM_JOIN) {
     queryContext.isInDelimJoin = true;
   }
@@ -837,8 +841,9 @@ PlanNodePtr processDelimGetJoin(
     names.push_back(queryContext.nextColumnName("_delim"));
     auto rightIndex = delimAlias[i];
     auto type = rightType->childAt(rightIndex);
-    exprs.push_back(std::make_shared<FieldAccessTypedExpr>(
-        type, rightType->nameOf(rightIndex)));
+    exprs.push_back(
+        std::make_shared<FieldAccessTypedExpr>(
+            type, rightType->nameOf(rightIndex)));
   }
   for (auto i = 0; i < rightType->size(); ++i) {
     names.push_back(rightType->nameOf(i));
@@ -857,7 +862,7 @@ PlanNodePtr processDelimGetJoin(
       veloxFilter = conjunct;
     } else {
       veloxFilter = std::make_shared<CallTypedExpr>(
-          BOOLEAN(), std::vector<TypedExprPtr>{veloxFilter, conjunct}, "and");
+          BOOLEAN(), "and", veloxFilter, conjunct);
     }
   }
   return std::make_shared<FilterNode>(
@@ -888,8 +893,9 @@ PlanNodePtr processDelimGetJoin(
     names.push_back(queryContext.nextColumnName("_delim"));
     auto rightIndex = delimAlias[i];
     auto type = rightType->childAt(rightIndex);
-    exprs.push_back(std::make_shared<FieldAccessTypedExpr>(
-        type, rightType->nameOf(rightIndex)));
+    exprs.push_back(
+        std::make_shared<FieldAccessTypedExpr>(
+            type, rightType->nameOf(rightIndex)));
   }
   for (auto i = 0; i < rightType->size(); ++i) {
     names.push_back(rightType->nameOf(i));
diff --git a/velox/parse/TypeResolver.cpp b/velox/parse/TypeResolver.cpp
index 6eea2bb19b98..925bce6c35eb 100644
--- a/velox/parse/TypeResolver.cpp
+++ b/velox/parse/TypeResolver.cpp
@@ -16,11 +16,13 @@
 
 #include "velox/parse/TypeResolver.h"
 #include "velox/core/ITypedExpr.h"
+#include "velox/exec/Aggregate.h"
 #include "velox/expression/FunctionCallToSpecialForm.h"
 #include "velox/expression/SignatureBinder.h"
 #include "velox/functions/FunctionRegistry.h"
 #include "velox/parse/Expressions.h"
 #include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
 
 namespace facebook::velox::parse {
 namespace {
@@ -62,13 +64,12 @@ TypePtr resolveType(
     inputTypes.emplace_back(input->type());
   }
 
-  if (auto resolvedType = exec::resolveTypeForSpecialForm(
-          expr->getFunctionName(), inputTypes)) {
+  if (auto resolvedType =
+          exec::resolveTypeForSpecialForm(expr->name(), inputTypes)) {
     return resolvedType;
   }
 
-  return resolveScalarFunctionType(
-      expr->getFunctionName(), inputTypes, nullOnFailure);
+  return resolveScalarFunctionType(expr->name(), inputTypes, nullOnFailure);
 }
 
 } // namespace
@@ -102,4 +103,407 @@ TypePtr resolveScalarFunctionType(
         toString(functionSignatures));
   }
 }
+
 } // namespace facebook::velox::parse
+
+namespace facebook::velox::core {
+
+// static
+Expressions::TypeResolverHook Expressions::resolverHook_;
+// static
+Expressions::FieldAccessHook Expressions::fieldAccessHook_;
+
+namespace {
+
+// Determine output type based on input types.
+TypePtr resolveTypeImpl(
+    const std::vector<TypedExprPtr>& inputs,
+    const std::shared_ptr<const CallExpr>& expr,
+    bool nullOnFailure) {
+  VELOX_CHECK_NOT_NULL(Expressions::getResolverHook());
+  return Expressions::getResolverHook()(inputs, expr, nullOnFailure);
+}
+
+CastTypedExprPtr makeTypedCast(const TypePtr& type, const TypedExprPtr& input) {
+  return std::make_shared<CastTypedExpr>(type, input, false);
+}
+
+std::vector<TypePtr> implicitCastTargets(const TypePtr& type) {
+  std::vector<TypePtr> targetTypes;
+  switch (type->kind()) {
+    // We decide not to implicitly upcast booleans because it maybe funky.
+    case TypeKind::BOOLEAN:
+      break;
+    case TypeKind::TINYINT:
+      targetTypes.emplace_back(SMALLINT());
+      [[fallthrough]];
+    case TypeKind::SMALLINT:
+      targetTypes.emplace_back(INTEGER());
+      targetTypes.emplace_back(REAL());
+      [[fallthrough]];
+    case TypeKind::INTEGER:
+      targetTypes.emplace_back(BIGINT());
+      targetTypes.emplace_back(DOUBLE());
+      [[fallthrough]];
+    case TypeKind::BIGINT:
+      break;
+    case TypeKind::REAL:
+      targetTypes.emplace_back(DOUBLE());
+      [[fallthrough]];
+    case TypeKind::DOUBLE:
+      break;
+    case TypeKind::ARRAY: {
+      auto childTargetTypes = implicitCastTargets(type->childAt(0));
+      for (const auto& childTarget : childTargetTypes) {
+        targetTypes.emplace_back(ARRAY(childTarget));
+      }
+      break;
+    }
+    default: // make compilers happy
+      break;
+  }
+  return targetTypes;
+}
+
+// All acceptable implicit casts on this expression.
+// TODO: If we get this to be recursive somehow, we can save on cast function
+// signatures that need to be compiled and registered.
+std::vector<TypedExprPtr> genImplicitCasts(const TypedExprPtr& typedExpr) {
+  auto targetTypes = implicitCastTargets(typedExpr->type());
+
+  std::vector<TypedExprPtr> implicitCasts;
+  implicitCasts.reserve(targetTypes.size());
+  for (const auto& targetType : targetTypes) {
+    implicitCasts.emplace_back(makeTypedCast(targetType, typedExpr));
+  }
+  return implicitCasts;
+}
+
+// TODO: Arguably all of this could be done with just Types.
+TypedExprPtr adjustLastNArguments(
+    std::vector<TypedExprPtr> inputs,
+    const std::shared_ptr<const CallExpr>& expr,
+    size_t n) {
+  auto type = resolveTypeImpl(inputs, expr, true /*nullOnFailure*/);
+  if (type != nullptr) {
+    return std::make_shared<CallTypedExpr>(
+        type, inputs, std::string{expr->name()});
+  }
+
+  if (n == 0) {
+    return nullptr;
+  }
+
+  size_t firstOfLastN = inputs.size() - n;
+  // use it
+  std::vector<TypedExprPtr> viableExprs{inputs[firstOfLastN]};
+  // or lose it
+  auto&& implicitCasts = genImplicitCasts(inputs[firstOfLastN]);
+  std::move(
+      implicitCasts.begin(),
+      implicitCasts.end(),
+      std::back_inserter(viableExprs));
+
+  for (auto& viableExpr : viableExprs) {
+    inputs[firstOfLastN] = viableExpr;
+    auto adjustedExpr = adjustLastNArguments(inputs, expr, n - 1);
+    if (adjustedExpr != nullptr) {
+      return adjustedExpr;
+    }
+  }
+
+  return nullptr;
+}
+
+TypedExprPtr createWithImplicitCast(
+    const std::shared_ptr<const CallExpr>& expr,
+    const std::vector<TypedExprPtr>& inputs) {
+  if (auto adjusted = adjustLastNArguments(inputs, expr, inputs.size())) {
+    return adjusted;
+  }
+  auto type = resolveTypeImpl(inputs, expr, /*nullOnFailure=*/false);
+  return std::make_shared<CallTypedExpr>(type, inputs, expr->name());
+}
+
+bool isLambdaArgument(
+    const velox::exec::FunctionSignature& signature,
+    size_t index,
+    size_t numInputs) {
+  return signature.isLambdaArgumentAt(index) &&
+      (signature.argumentTypeAt(index).parameters().size() == numInputs + 1);
+}
+
+} // namespace
+
+// static
+TypedExprPtr Expressions::inferTypes(
+    const std::shared_ptr<const IExpr>& expr,
+    const TypePtr& inputRow,
+    memory::MemoryPool* pool,
+    const VectorPtr& complexConstants) {
+  return inferTypes(expr, inputRow, {}, pool, complexConstants);
+}
+
+// static
+TypedExprPtr Expressions::inferTypes(
+    const std::shared_ptr<const IExpr>& expr,
+    const TypePtr& inputRow,
+    const std::vector<TypePtr>& lambdaInputTypes,
+    memory::MemoryPool* pool,
+    const VectorPtr& complexConstants) {
+  VELOX_CHECK_NOT_NULL(expr);
+
+  if (auto lambdaExpr = std::dynamic_pointer_cast<const LambdaExpr>(expr)) {
+    return resolveLambdaExpr(
+        lambdaExpr, inputRow, lambdaInputTypes, pool, complexConstants);
+  }
+
+  if (auto call = std::dynamic_pointer_cast<const CallExpr>(expr)) {
+    if (!expr->inputs().empty()) {
+      if (auto returnType = tryResolveCallWithLambdas(
+              call, inputRow, pool, complexConstants)) {
+        return returnType;
+      }
+    }
+  }
+
+  // try rebuilding complex constant type from vector
+  if (auto fun = std::dynamic_pointer_cast<const CallExpr>(expr)) {
+    if (fun->name() == "__complex_constant") {
+      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->inputAt(0))
+              ->name();
+      auto rowType = asRowType(ccInputRow->type());
+      return std::make_shared<ConstantTypedExpr>(
+          ccInputRow->childAt(rowType->getChildIdx(name)));
+    }
+  }
+
+  std::vector<TypedExprPtr> children;
+  for (auto& child : expr->inputs()) {
+    children.push_back(
+        inferTypes(child, inputRow, lambdaInputTypes, pool, complexConstants));
+  }
+
+  if (auto fae = std::dynamic_pointer_cast<const FieldAccessExpr>(expr)) {
+    if (fieldAccessHook_) {
+      if (auto result = fieldAccessHook_(fae, children)) {
+        return result;
+      }
+    }
+    VELOX_CHECK(!fae->name().empty(), "Anonymous columns are not supported");
+    VELOX_CHECK_EQ(
+        children.size(), 1, "Unexpected number of children in FieldAccessExpr");
+    auto input = children.at(0)->type();
+    auto& row = input->asRow();
+    auto childIndex = row.getChildIdx(fae->name());
+    if (fae->isRootColumn()) {
+      return std::make_shared<FieldAccessTypedExpr>(
+          input->childAt(childIndex), children.at(0), std::string{fae->name()});
+    } else {
+      return std::make_shared<DereferenceTypedExpr>(
+          input->childAt(childIndex), children.at(0), childIndex);
+    }
+  }
+
+  if (auto fun = std::dynamic_pointer_cast<const CallExpr>(expr)) {
+    return createWithImplicitCast(fun, children);
+  }
+
+  if (auto input = std::dynamic_pointer_cast<const InputExpr>(expr)) {
+    return std::make_shared<InputTypedExpr>(inputRow);
+  }
+
+  if (auto constant = std::dynamic_pointer_cast<const ConstantExpr>(expr)) {
+    if (constant->type()->isPrimitiveType() || constant->value().isNull()) {
+      return std::make_shared<ConstantTypedExpr>(
+          constant->type(), constant->value());
+    }
+
+    VELOX_CHECK_NOT_NULL(
+        pool, "parsing complex literals requires a memory pool");
+    auto constantVector = BaseVector::createConstant(
+        constant->type(), constant->value(), 1, pool);
+    return std::make_shared<ConstantTypedExpr>(constantVector);
+  }
+
+  if (auto cast = std::dynamic_pointer_cast<const CastExpr>(expr)) {
+    return std::make_shared<CastTypedExpr>(
+        cast->type(), std::move(children), cast->isTryCast());
+  }
+
+  if (auto alreadyTyped = std::dynamic_pointer_cast<const ITypedExpr>(expr)) {
+    return alreadyTyped;
+  }
+
+  VELOX_FAIL("Unknown expression type: {}", expr->toString());
+}
+
+// static
+TypedExprPtr Expressions::resolveLambdaExpr(
+    const std::shared_ptr<const LambdaExpr>& lambdaExpr,
+    const TypePtr& inputRow,
+    const std::vector<TypePtr>& lambdaInputTypes,
+    memory::MemoryPool* pool,
+    const VectorPtr& complexConstants) {
+  auto names = lambdaExpr->arguments();
+  auto body = lambdaExpr->body();
+
+  VELOX_CHECK_LE(names.size(), lambdaInputTypes.size());
+  std::vector<TypePtr> types;
+  types.reserve(names.size());
+  for (auto i = 0; i < names.size(); ++i) {
+    types.push_back(lambdaInputTypes[i]);
+  }
+
+  auto signature =
+      ROW(std::vector<std::string>(names), std::vector<TypePtr>(types));
+
+  auto& inputRowType = inputRow->asRow();
+  for (auto i = 0; i < inputRowType.size(); ++i) {
+    if (!signature->containsChild(inputRowType.names()[i])) {
+      names.push_back(inputRowType.names()[i]);
+      types.push_back(inputRowType.childAt(i));
+    }
+  }
+
+  auto lambdaRow = ROW(std::move(names), std::move(types));
+
+  return std::make_shared<LambdaTypedExpr>(
+      signature, inferTypes(body, lambdaRow, pool, complexConstants));
+}
+
+namespace {
+bool isLambdaSignature(
+    const exec::FunctionSignature& signature,
+    const std::shared_ptr<const CallExpr>& callExpr) {
+  if (!signature.hasLambdaArgument()) {
+    return false;
+  }
+
+  const auto numArguments = callExpr->inputs().size();
+
+  if (numArguments != signature.argumentTypes().size()) {
+    return false;
+  }
+
+  bool match = true;
+  for (auto i = 0; i < numArguments; ++i) {
+    if (auto lambda =
+            dynamic_cast<const LambdaExpr*>(callExpr->inputAt(i).get())) {
+      const auto numLambdaInputs = lambda->arguments().size();
+      if (!isLambdaArgument(signature, i, numLambdaInputs)) {
+        match = false;
+        break;
+      }
+    }
+  }
+
+  return match;
+}
+
+const exec::FunctionSignature* FOLLY_NULLABLE findLambdaSignature(
+    const std::vector<std::shared_ptr<exec::AggregateFunctionSignature>>&
+        signatures,
+    const std::shared_ptr<const CallExpr>& callExpr) {
+  const exec::FunctionSignature* matchingSignature = nullptr;
+  for (const auto& signature : signatures) {
+    if (isLambdaSignature(*signature, callExpr)) {
+      VELOX_CHECK_NULL(
+          matchingSignature,
+          "Cannot resolve ambiguous lambda function signatures for {}.",
+          callExpr->name());
+      matchingSignature = signature.get();
+    }
+  }
+
+  return matchingSignature;
+}
+
+const exec::FunctionSignature* FOLLY_NULLABLE findLambdaSignature(
+    const std::vector<const exec::FunctionSignature*>& signatures,
+    const std::shared_ptr<const CallExpr>& callExpr) {
+  const exec::FunctionSignature* matchingSignature = nullptr;
+  for (const auto& signature : signatures) {
+    if (isLambdaSignature(*signature, callExpr)) {
+      VELOX_CHECK_NULL(
+          matchingSignature,
+          "Cannot resolve ambiguous lambda function signatures for {}.",
+          callExpr->name());
+      matchingSignature = signature;
+    }
+  }
+
+  return matchingSignature;
+}
+} // namespace
+
+const exec::FunctionSignature* findLambdaSignature(
+    const std::shared_ptr<const CallExpr>& callExpr) {
+  // Look for a scalar lambda function.
+  auto scalarSignatures = getFunctionSignatures(callExpr->name());
+  if (!scalarSignatures.empty()) {
+    return findLambdaSignature(scalarSignatures, callExpr);
+  }
+
+  // Look for an aggregate lambda function.
+  if (auto signatures =
+          exec::getAggregateFunctionSignatures(callExpr->name())) {
+    return findLambdaSignature(signatures.value(), callExpr);
+  }
+
+  return nullptr;
+}
+
+// static
+TypedExprPtr Expressions::tryResolveCallWithLambdas(
+    const std::shared_ptr<const CallExpr>& callExpr,
+    const TypePtr& inputRow,
+    memory::MemoryPool* pool,
+    const VectorPtr& complexConstants) {
+  auto signature = findLambdaSignature(callExpr);
+
+  if (signature == nullptr) {
+    return nullptr;
+  }
+
+  // Resolve non-lambda arguments first.
+  auto numArgs = callExpr->inputs().size();
+  std::vector<TypedExprPtr> children(numArgs);
+  std::vector<TypePtr> childTypes(numArgs);
+  for (auto i = 0; i < numArgs; ++i) {
+    if (!signature->isLambdaArgumentAt(i)) {
+      children[i] =
+          inferTypes(callExpr->inputAt(i), inputRow, pool, complexConstants);
+      childTypes[i] = children[i]->type();
+    }
+  }
+
+  // Resolve lambda arguments.
+  exec::SignatureBinder binder(*signature, childTypes);
+  binder.tryBind();
+  for (auto i = 0; i < numArgs; ++i) {
+    if (signature->isLambdaArgumentAt(i)) {
+      const auto& lambdaSignature = signature->argumentTypeAt(i);
+      const auto& params = lambdaSignature.parameters();
+      const auto lambdaTypes = binder.tryResolveTypes(
+          folly::Range(params.data(), params.size() - 1));
+
+      children[i] = inferTypes(
+          callExpr->inputAt(i), inputRow, lambdaTypes, pool, complexConstants);
+    }
+  }
+
+  return createWithImplicitCast(callExpr, children);
+}
+
+} // namespace facebook::velox::core
diff --git a/velox/parse/TypeResolver.h b/velox/parse/TypeResolver.h
index 8477a270e99d..9e1c64d04584 100644
--- a/velox/parse/TypeResolver.h
+++ b/velox/parse/TypeResolver.h
@@ -15,7 +15,12 @@
  */
 
 #pragma once
+
+#include "velox/core/ITypedExpr.h"
+#include "velox/expression/SignatureBinder.h"
+#include "velox/parse/Expressions.h"
 #include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
 
 namespace facebook::velox::parse {
 
@@ -30,5 +35,74 @@ TypePtr resolveScalarFunctionType(
     const std::string& name,
     const std::vector<TypePtr>& args,
     bool nullOnFailure = false);
-
 } // namespace facebook::velox::parse
+
+namespace facebook::velox::core {
+
+class Expressions {
+ public:
+  using TypeResolverHook = std::function<TypePtr(
+      const std::vector<TypedExprPtr>& inputs,
+      const std::shared_ptr<const CallExpr>& expr,
+      bool nullOnFailure)>;
+
+  using FieldAccessHook = std::function<TypedExprPtr(
+      std::shared_ptr<const FieldAccessExpr> fae,
+      std::vector<TypedExprPtr>& children)>;
+
+  static TypedExprPtr inferTypes(
+      const ExprPtr& expr,
+      const TypePtr& input,
+      memory::MemoryPool* pool,
+      const VectorPtr& complexConstants = nullptr);
+
+  static void setTypeResolverHook(TypeResolverHook hook) {
+    resolverHook_ = std::move(hook);
+  }
+
+  static TypeResolverHook getResolverHook() {
+    return resolverHook_;
+  }
+
+  static void setFieldAccessHook(FieldAccessHook hook) {
+    fieldAccessHook_ = std::move(hook);
+  }
+
+  static FieldAccessHook getFieldAccessHook() {
+    return fieldAccessHook_;
+  }
+
+  static TypedExprPtr inferTypes(
+      const ExprPtr& expr,
+      const TypePtr& input,
+      const std::vector<TypePtr>& lambdaInputTypes,
+      memory::MemoryPool* pool,
+      const VectorPtr& complexConstants = nullptr);
+
+ private:
+  static TypedExprPtr resolveLambdaExpr(
+      const std::shared_ptr<const LambdaExpr>& lambdaExpr,
+      const TypePtr& inputRow,
+      const std::vector<TypePtr>& lambdaInputTypes,
+      memory::MemoryPool* pool,
+      const VectorPtr& complexConstants = nullptr);
+
+  static TypedExprPtr tryResolveCallWithLambdas(
+      const std::shared_ptr<const CallExpr>& expr,
+      const TypePtr& input,
+      memory::MemoryPool* pool,
+      const VectorPtr& complexConstants = nullptr);
+
+  static TypeResolverHook resolverHook_;
+  static FieldAccessHook fieldAccessHook_;
+};
+
+/// Returns a signature for 'call' if a signature involving lambda arguments is
+/// found, nullptr otherwise.
+/// Assumes no overlap in function names between scalar and aggregate
+// functions,
+/// i.e. 'foo' is either a scalar or aggregate function.
+const exec::FunctionSignature* findLambdaSignature(
+    const std::shared_ptr<const CallExpr>& callExpr);
+
+} // namespace facebook::velox::core
diff --git a/velox/parse/tests/CMakeLists.txt b/velox/parse/tests/CMakeLists.txt
index 33b6fcab99f3..9a2fb6e52995 100644
--- a/velox/parse/tests/CMakeLists.txt
+++ b/velox/parse/tests/CMakeLists.txt
@@ -16,5 +16,4 @@ 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 GTest::gtest_main)
+target_link_libraries(velox_parse_test velox_parse_parser GTest::gtest GTest::gtest_main)
diff --git a/velox/parse/tests/ExprTest.cpp b/velox/parse/tests/ExprTest.cpp
new file mode 100644
index 000000000000..b0b09070b066
--- /dev/null
+++ b/velox/parse/tests/ExprTest.cpp
@@ -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.
+ */
+#include <folly/container/F14Map.h>
+#include <gtest/gtest.h>
+#include "velox/duckdb/conversion/DuckParser.h"
+#include "velox/parse/IExpr.h"
+
+namespace facebook::velox::core {
+namespace {
+
+class ExprTest : public testing::Test {};
+
+ExprPtr parse(const std::string& sql) {
+  return duckdb::parseExpr(sql, {});
+}
+
+TEST_F(ExprTest, hashMap) {
+  folly::F14FastMap<ExprPtr, int, IExprHash, IExprEqual> exprs;
+
+  {
+    auto expr1 = parse("a + 1");
+    auto expr2 = parse("a + b");
+    auto expr3 = parse("12");
+    auto expr4 = parse("a + b");
+
+    exprs.emplace(expr1, 1);
+    exprs.emplace(expr2, 2);
+    exprs.emplace(expr3, 3);
+    exprs.emplace(expr4, 4);
+
+    ASSERT_EQ(3, exprs.size());
+
+    EXPECT_EQ(exprs.at(expr1), 1);
+    EXPECT_EQ(exprs.at(expr2), 2);
+    EXPECT_EQ(exprs.at(expr3), 3);
+    EXPECT_EQ(exprs.at(expr4), 2);
+  }
+
+  {
+    auto expr1 = parse("cast(a as bigint) + 1");
+    auto expr2 = parse("cast(a as int) + 1");
+    auto expr3 = parse("cast(a as bigint) + 1");
+
+    exprs.emplace(expr1, 5);
+    exprs.emplace(expr2, 6);
+    exprs.emplace(expr3, 7);
+
+    ASSERT_EQ(5, exprs.size());
+
+    EXPECT_EQ(exprs.at(expr1), 5);
+    EXPECT_EQ(exprs.at(expr2), 6);
+    EXPECT_EQ(exprs.at(expr3), 5);
+  }
+}
+
+TEST_F(ExprTest, dropAlias) {
+  EXPECT_EQ(parse("a + b")->dropAlias()->toString(), R"(plus("a","b"))");
+  EXPECT_EQ(parse("a + b as c")->dropAlias()->toString(), R"(plus("a","b"))");
+
+  EXPECT_EQ(
+      parse("cast(a as date)")->dropAlias()->toString(),
+      R"(cast("a" as DATE))");
+  EXPECT_EQ(
+      parse("cast(a as date) as b")->dropAlias()->toString(),
+      R"(cast("a" as DATE))");
+
+  EXPECT_EQ(parse("a + 10")->dropAlias()->toString(), R"(plus("a",10))");
+  EXPECT_EQ(parse("a + 10 as b")->dropAlias()->toString(), R"(plus("a",10))");
+}
+
+} // namespace
+} // namespace facebook::velox::core
diff --git a/velox/parse/tests/QueryPlannerTest.cpp b/velox/parse/tests/QueryPlannerTest.cpp
index 42a2aec50004..ab0d35b91b48 100644
--- a/velox/parse/tests/QueryPlannerTest.cpp
+++ b/velox/parse/tests/QueryPlannerTest.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 #include "velox/parse/QueryPlanner.h"
-#include "velox/common/base/tests/GTestUtils.h"
+#include <gtest/gtest.h>
 
 namespace facebook::velox::core::test {
 
diff --git a/velox/python/CMakeLists.txt b/velox/python/CMakeLists.txt
index a11cc8005627..0e52234931f3 100644
--- a/velox/python/CMakeLists.txt
+++ b/velox/python/CMakeLists.txt
@@ -19,7 +19,8 @@ pyvelox_add_module(
   legacy/conversion.cpp
   legacy/pyvelox.cpp
   legacy/serde.cpp
-  legacy/signatures.cpp)
+  legacy/signatures.cpp
+)
 
 target_link_libraries(
   legacy
@@ -32,7 +33,8 @@ target_link_libraries(
     velox_functions_prestosql
     velox_functions_spark
     velox_aggregates
-    velox_functions_spark_aggregates)
+    velox_functions_spark_aggregates
+)
 
 if(VELOX_PYTHON_LEGACY_ONLY)
   # Only build the legacy module for CI
@@ -41,47 +43,37 @@ endif()
 
 add_library(velox_py_init init/PyInit.cpp)
 
-target_link_libraries(
-  velox_py_init
-  PRIVATE velox_memory)
+target_link_libraries(velox_py_init PRIVATE velox_memory)
 # This should not be necessary but the xxhash header is not part of any target
-target_include_directories(velox_py_init
-                           PUBLIC ${PROJECT_SOURCE_DIR}/velox/external/xxhash)
+target_include_directories(velox_py_init PUBLIC ${PROJECT_SOURCE_DIR}/velox/external/xxhash)
 
 # pyvelox.type library:
 add_library(velox_py_type_lib type/PyType.cpp)
-target_link_libraries(
-  velox_py_type_lib velox_type pybind11::module)
+target_link_libraries(velox_py_type_lib velox_type pybind11::module)
 
 pyvelox_add_module(type MODULE type/type.cpp)
-target_link_libraries(
-  type
-  PRIVATE velox_py_type_lib)
+target_link_libraries(type PRIVATE velox_py_type_lib)
 
 # pyvelox.file library:
 add_library(velox_py_file_lib file/PyFile.cpp)
-target_link_libraries(
-  velox_py_file_lib velox_dwio_common velox_py_init pybind11::module)
+target_link_libraries(velox_py_file_lib velox_dwio_common velox_py_init pybind11::module)
 
 pyvelox_add_module(file MODULE file/file.cpp)
-target_link_libraries(
-  file
-  PRIVATE velox_py_file_lib)
+target_link_libraries(file PRIVATE velox_py_file_lib)
 
 # pyvelox.vector library:
 add_library(velox_py_vector_lib vector/PyVector.cpp)
-target_link_libraries(
-  velox_py_vector_lib velox_vector pybind11::module)
+target_link_libraries(velox_py_vector_lib velox_vector pybind11::module)
 
 pyvelox_add_module(vector MODULE vector/vector.cpp)
-target_link_libraries(
-  vector
-  PRIVATE velox_py_vector_lib)
+target_link_libraries(vector PRIVATE velox_py_vector_lib)
 
 # pyvelox.plan_builder library:
 add_library(velox_py_plan_builder_lib plan_builder/PyPlanBuilder.cpp)
-target_include_directories(velox_py_plan_builder_lib
-                           PUBLIC ${PROJECT_SOURCE_DIR}/velox/external/xxhash)
+target_include_directories(
+  velox_py_plan_builder_lib
+  PUBLIC ${PROJECT_SOURCE_DIR}/velox/external/xxhash
+)
 target_link_libraries(
   velox_py_plan_builder_lib
   velox_py_type_lib
@@ -100,18 +92,18 @@ target_link_libraries(
   velox_dwio_dwrf_common
   velox_dwio_dwrf_writer
   Folly::folly
-  pybind11::module)
+  pybind11::module
+)
 
 pyvelox_add_module(plan_builder MODULE plan_builder/plan_builder.cpp)
-target_link_libraries(
-  plan_builder
-  PRIVATE velox_py_plan_builder_lib)
+target_link_libraries(plan_builder PRIVATE velox_py_plan_builder_lib)
 
 # pyvelox.runner library:
-add_library(velox_py_local_runner_lib runner/PyLocalRunner.cpp
-                                      runner/PyConnectors.cpp)
-target_include_directories(velox_py_local_runner_lib
-                           PUBLIC ${PROJECT_SOURCE_DIR}/velox/external/xxhash)
+add_library(velox_py_local_runner_lib runner/PyLocalRunner.cpp runner/PyConnectors.cpp)
+target_include_directories(
+  velox_py_local_runner_lib
+  PUBLIC ${PROJECT_SOURCE_DIR}/velox/external/xxhash
+)
 target_link_libraries(
   velox_py_local_runner_lib
   velox_py_type_lib
@@ -125,35 +117,25 @@ target_link_libraries(
   velox_dwio_dwrf_reader
   velox_dwio_dwrf_common
   velox_dwio_dwrf_writer
-  pybind11::module)
+  pybind11::module
+)
 
 pyvelox_add_module(runner MODULE runner/runner.cpp)
-target_link_libraries(
-  runner
-  PRIVATE velox_py_local_runner_lib)
+target_link_libraries(runner PRIVATE velox_py_local_runner_lib)
 
 # pyarrow has to be installed
 find_package(pyarrow REQUIRED)
 
 # 'arrow' target already exists
 pyvelox_add_module(arrow_module MODULE arrow/arrow.cpp)
-set_target_properties(
-  arrow_module
-  PROPERTIES OUTPUT_NAME "arrow")
+set_target_properties(arrow_module PROPERTIES OUTPUT_NAME "arrow")
 
 # This ensures the dynamic linker can find libarrow* dependencies at runtime
 # from the installed pyarrow package without requiring LD_LIBRARY_PATH to be set
-get_rpath_origin(_origin)
-set_property(
-  TARGET arrow_module
-  PROPERTY INSTALL_RPATH "${_origin}/../pyarrow"
-  APPEND)
+velox_get_rpath_origin(_origin)
+set_property(TARGET arrow_module PROPERTY INSTALL_RPATH "${_origin}/../pyarrow" APPEND)
 
 target_link_libraries(
   arrow_module
-  PRIVATE
-    velox_py_init
-    velox_py_vector_lib
-    velox_arrow_bridge
-    pyarrow::dev
-    pybind11::module)
+  PRIVATE velox_py_init velox_py_vector_lib velox_arrow_bridge pyarrow::dev pybind11::module
+)
diff --git a/velox/python/init/PyInit.cpp b/velox/python/init/PyInit.cpp
index 099fcf5d8008..0399ff46bc79 100644
--- a/velox/python/init/PyInit.cpp
+++ b/velox/python/init/PyInit.cpp
@@ -19,14 +19,11 @@
 #include <folly/debugging/symbolizer/SignalHandler.h>
 
 #include "velox/common/memory/Memory.h"
-#include "velox/connectors/hive/HiveConnectorSplit.h"
-#include "velox/connectors/hive/HiveDataSink.h"
-#include "velox/connectors/hive/TableHandle.h"
-#include "velox/connectors/tpch/TpchConnectorSplit.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/core/PlanNode.h"
+#include "velox/dwio/common/FileSink.h"
 #include "velox/dwio/dwrf/RegisterDwrfReader.h"
 #include "velox/dwio/dwrf/RegisterDwrfWriter.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
 #include "velox/functions/prestosql/registration/RegistrationFunctions.h"
 #include "velox/parse/TypeResolver.h"
@@ -49,12 +46,7 @@ void registerAllResourcesOnce() {
   velox::core::PlanNode::registerSerDe();
   velox::Type::registerSerDe();
   velox::common::Filter::registerSerDe();
-  velox::connector::hive::LocationHandle::registerSerDe();
-  velox::connector::hive::HiveSortingColumn::registerSerDe();
-  velox::connector::hive::HiveBucketProperty::registerSerDe();
-  velox::connector::hive::HiveTableHandle::registerSerDe();
-  velox::connector::hive::HiveColumnHandle::registerSerDe();
-  velox::connector::hive::HiveInsertTableHandle::registerSerDe();
+  velox::connector::hive::HiveConnector::registerSerDe();
   velox::core::ITypedExpr::registerSerDe();
 
   // Register functions.
diff --git a/velox/python/legacy/pyvelox.cpp b/velox/python/legacy/pyvelox.cpp
index a1e202706a49..4b5c813b0001 100644
--- a/velox/python/legacy/pyvelox.cpp
+++ b/velox/python/legacy/pyvelox.cpp
@@ -88,8 +88,7 @@ static VectorPtr variantsToFlatVector(
     const std::vector<velox::variant>& variants,
     facebook::velox::memory::MemoryPool* pool) {
   using NativeType = typename TypeTraits<T>::NativeType;
-  constexpr bool kNeedsHolder =
-      (T == TypeKind::VARCHAR || T == TypeKind::VARBINARY);
+  constexpr bool kNeedsHolder = is_string_kind(T);
 
   TypePtr type = createScalarType(T);
   auto result =
@@ -257,7 +256,7 @@ static void addExpressionBindings(
           "getInputs",
           [](IExprWrapper& e) {
             const std::vector<std::shared_ptr<const core::IExpr>>& inputs =
-                e.expr->getInputs();
+                e.expr->inputs();
             std::vector<IExprWrapper> wrapped_inputs;
             wrapped_inputs.resize(inputs.size());
             for (const std::shared_ptr<const core::IExpr>& input : inputs) {
diff --git a/velox/python/legacy/pyvelox.h b/velox/python/legacy/pyvelox.h
index a95956a407b8..a47d8e691ab1 100644
--- a/velox/python/legacy/pyvelox.h
+++ b/velox/python/legacy/pyvelox.h
@@ -304,9 +304,10 @@ inline void addDataTypeBindings(
   mapType.def("key_type", &MapType::keyType, "Return the key type");
   mapType.def("value_type", &MapType::valueType, "Return the value type");
 
-  rowType.def(py::init<
-              std::vector<std::string>,
-              std::vector<std::shared_ptr<const Type>>>());
+  rowType.def(
+      py::init<
+          std::vector<std::string>,
+          std::vector<std::shared_ptr<const Type>>>());
   rowType.def("size", &RowType::size, "Return the number of columns");
   rowType.def(
       "child_at",
diff --git a/velox/python/plan_builder/PyPlanBuilder.cpp b/velox/python/plan_builder/PyPlanBuilder.cpp
index c2509776f6d1..18e15f8fb0e6 100644
--- a/velox/python/plan_builder/PyPlanBuilder.cpp
+++ b/velox/python/plan_builder/PyPlanBuilder.cpp
@@ -22,14 +22,7 @@
 #include "velox/connectors/hive/TableHandle.h"
 #include "velox/connectors/tpch/TpchConnectorSplit.h"
 #include "velox/core/PlanNode.h"
-#include "velox/dwio/dwrf/RegisterDwrfReader.h"
-#include "velox/dwio/dwrf/RegisterDwrfWriter.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
-#include "velox/exec/Cursor.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/functions/prestosql/aggregates/RegisterAggregateFunctions.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-#include "velox/parse/TypeResolver.h"
 #include "velox/python/vector/PyVector.h"
 #include "velox/tpch/gen/TpchGen.h"
 
@@ -46,14 +39,13 @@ PyPlanNode::PyPlanNode(
   }
 }
 
-PyPlanBuilder::PyPlanBuilder(const std::shared_ptr<PyPlanContext>& planContext)
-    : planContext_(
-          planContext ? planContext : std::make_shared<PyPlanContext>()) {
-  rootPool_ = memory::memoryManager()->addRootPool();
-  leafPool_ = rootPool_->addLeafChild("py_plan_builder_pool");
-  planBuilder_ = exec::test::PlanBuilder(
-      planContext_->planNodeIdGenerator, leafPool_.get());
-}
+PyPlanBuilder::PyPlanBuilder(
+    const std::shared_ptr<memory::MemoryPool>& pool,
+    const std::shared_ptr<PyPlanContext>& planContext)
+    : pool_(pool),
+      planContext_(
+          planContext ? planContext : std::make_shared<PyPlanContext>()),
+      planBuilder_{planContext_->planNodeIdGenerator, pool_.get()} {}
 
 std::optional<PyPlanNode> PyPlanBuilder::planNode() const {
   if (planBuilder_.planNode() != nullptr) {
@@ -138,8 +130,7 @@ PyPlanBuilder& PyPlanBuilder::tableScan(
   // If there are subfields, create the appropriate structures and add to the
   // scan.
   if (!subfields.empty() || !rowIndexColumnName.empty()) {
-    std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-        assignments;
+    connector::ColumnHandleMap assignments;
 
     for (size_t i = 0; i < outputRowSchema->size(); ++i) {
       auto name = outputRowSchema->nameOf(i);
@@ -198,8 +189,9 @@ PyPlanBuilder& PyPlanBuilder::tableScan(
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   if (inputFiles.has_value()) {
     for (const auto& inputFile : *inputFiles) {
-      splits.push_back(std::make_shared<connector::hive::HiveConnectorSplit>(
-          connectorId, inputFile.filePath(), inputFile.fileFormat()));
+      splits.push_back(
+          std::make_shared<connector::hive::HiveConnectorSplit>(
+              connectorId, inputFile.filePath(), inputFile.fileFormat()));
     }
   }
 
@@ -242,6 +234,18 @@ PyPlanBuilder& PyPlanBuilder::aggregate(
   return *this;
 }
 
+PyPlanBuilder& PyPlanBuilder::streamingAggregate(
+    const std::vector<std::string>& groupingKeys,
+    const std::vector<std::string>& aggregations) {
+  planBuilder_.streamingAggregation(
+      groupingKeys,
+      aggregations,
+      {},
+      core::AggregationNode::Step::kSingle,
+      false);
+  return *this;
+}
+
 PyPlanBuilder& PyPlanBuilder::orderBy(
     const std::vector<std::string>& keys,
     bool isPartial) {
@@ -299,7 +303,14 @@ PyPlanBuilder& PyPlanBuilder::indexLookupJoin(
           std::dynamic_pointer_cast<const core::TableScanNode>(
               indexPlanSubtree.planNode())) {
     planBuilder_.indexLookupJoin(
-        leftKeys, rightKeys, tableScanNode, {}, output, joinType);
+        leftKeys,
+        rightKeys,
+        tableScanNode,
+        {},
+        /*filter=*/"",
+        /*hasMarker=*/false,
+        output,
+        joinType);
   } else {
     throw std::runtime_error(
         "Index Loop Join subtree must be a single TableScanNode.");
@@ -307,6 +318,16 @@ PyPlanBuilder& PyPlanBuilder::indexLookupJoin(
   return *this;
 }
 
+PyPlanBuilder& PyPlanBuilder::unnest(
+    const std::vector<std::string>& unnestColumns,
+    const std::vector<std::string>& replicateColumns,
+    const std::optional<std::string>& ordinalColumn,
+    const std::optional<std::string>& emptyUnnestValueName) {
+  planBuilder_.unnest(
+      replicateColumns, unnestColumns, ordinalColumn, emptyUnnestValueName);
+  return *this;
+}
+
 PyPlanBuilder& PyPlanBuilder::sortedMerge(
     const std::vector<std::string>& keys,
     const std::vector<std::optional<PyPlanNode>>& pySources) {
@@ -340,8 +361,9 @@ PyPlanBuilder& PyPlanBuilder::tpchGen(
   // Generate one split per part.
   std::vector<std::shared_ptr<connector::ConnectorSplit>> splits;
   for (size_t i = 0; i < numParts; ++i) {
-    splits.push_back(std::make_shared<connector::tpch::TpchConnectorSplit>(
-        connectorId, numParts, i));
+    splits.push_back(
+        std::make_shared<connector::tpch::TpchConnectorSplit>(
+            connectorId, numParts, i));
   }
 
   planContext_->scanFiles[planBuilder_.planNode()->id()] = std::move(splits);
diff --git a/velox/python/plan_builder/PyPlanBuilder.h b/velox/python/plan_builder/PyPlanBuilder.h
index 219f79fca4a3..b9b1bbbb773d 100644
--- a/velox/python/plan_builder/PyPlanBuilder.h
+++ b/velox/python/plan_builder/PyPlanBuilder.h
@@ -108,7 +108,9 @@ class PyPlanBuilder {
  public:
   /// Constructs a new PyPlanBuilder. If provided, the planContext is used;
   /// otherwise a new one is created.
-  PyPlanBuilder(const std::shared_ptr<PyPlanContext>& planContext = nullptr);
+  PyPlanBuilder(
+      const std::shared_ptr<memory::MemoryPool>& pool,
+      const std::shared_ptr<PyPlanContext>& planContext = nullptr);
 
   /// Returns the plan node at the head of the internal plan builder. If there
   /// is no plan node (plan builder is empty), then std::nullopt will signal
@@ -120,7 +122,7 @@ class PyPlanBuilder {
   /// plan.
   PyPlanBuilder newBuilder() {
     DCHECK(planContext_ != nullptr);
-    return PyPlanBuilder{planContext_};
+    return PyPlanBuilder{pool_, planContext_};
   }
 
   /// Add table scan node with basic functionality. This API is Hive-connector
@@ -212,12 +214,24 @@ class PyPlanBuilder {
   PyPlanBuilder& filter(const std::string& filter);
 
   /// Add a single-stage aggregation given a set of group keys, and
-  /// aggregations. Aggregations are specified as SQL expressions and currently
-  /// use DuckDB's parser semantics.
+  /// aggregations.
+  ///
+  /// Aggregations are specified as SQL expressions and currently use DuckDB's
+  /// parser semantics.
   PyPlanBuilder& aggregate(
       const std::vector<std::string>& groupingKeys,
       const std::vector<std::string>& aggregations);
 
+  /// Add a single-stage streaming aggregation given a set of group keys, and
+  /// aggregations. This assumes that the input will be sorted based on the
+  /// grouping keys.
+  ///
+  /// Aggregations are specified as SQL expressions and currently use DuckDB's
+  /// parser semantics.
+  PyPlanBuilder& streamingAggregate(
+      const std::vector<std::string>& groupingKeys,
+      const std::vector<std::string>& aggregations);
+
   /// Sorts the input based on the values of sorting keys.
   ///
   /// @param keys List of columns to order by. The strings can be column
@@ -291,6 +305,36 @@ class PyPlanBuilder {
       const std::vector<std::string>& output,
       core::JoinType joinType);
 
+  /// Add an UnnestNode to unnest (explode) one or more columns of type array or
+  /// map.
+  ///
+  /// The output will contain 'replicatedColumns' followed by unnested columns,
+  /// followed by an optional ordinality column.
+  ///
+  /// Array columns are unnested into a single column whose name is generated by
+  /// appending '_e' suffix to the array column name.
+  ///
+  /// Map columns are unnested into two columns whoes names are generated by
+  /// appending '_k' and '_v' suffixes to the map column name.
+  ///
+  /// @param unnestColumns A subset of input columns to unnest. These columns
+  /// must be of type array or map.
+  /// @param replicateColumns A subset of input columns to include in the output
+  /// unmodified.
+  /// @param ordinalColumn An optional name for the 'ordinal' column to produce.
+  /// This column contains the index of the element of the unnested array or
+  /// map. If not specified, the output will not contain this column.
+  /// @param emptyUnnestValueName An optional name for the
+  /// 'emptyUnnestValue' column to produce. This column contains a boolean
+  /// indicating if the output row has empty unnest value or not. If not
+  /// specified, the output will not contain this column and the unnest operator
+  /// also skips producing output rows with empty unnest value.
+  PyPlanBuilder& unnest(
+      const std::vector<std::string>& unnestColumns,
+      const std::vector<std::string>& replicateColumns,
+      const std::optional<std::string>& ordinalColumn = std::nullopt,
+      const std::optional<std::string>& emptyUnnestValueName = std::nullopt);
+
   /// Takes N sorted `source` subtrees and merges them into a sorted output.
   /// Assumes that all sources are sorted on `keys`.
   ///
@@ -324,11 +368,10 @@ class PyPlanBuilder {
   // TODO: Add other nodes.
 
  private:
-  std::shared_ptr<memory::MemoryPool> rootPool_;
-  std::shared_ptr<memory::MemoryPool> leafPool_;
+  std::shared_ptr<memory::MemoryPool> pool_;
 
-  exec::test::PlanBuilder planBuilder_;
   std::shared_ptr<PyPlanContext> planContext_;
+  exec::test::PlanBuilder planBuilder_;
 };
 
 } // namespace facebook::velox::py
diff --git a/velox/python/plan_builder/plan_builder.cpp b/velox/python/plan_builder/plan_builder.cpp
index 5348eb3e636d..9b0b1fc219ab 100644
--- a/velox/python/plan_builder/plan_builder.cpp
+++ b/velox/python/plan_builder/plan_builder.cpp
@@ -30,6 +30,9 @@ PYBIND11_MODULE(plan_builder, m) {
   velox::py::initializeVeloxMemory();
   velox::py::registerAllResources();
 
+  static auto rootPool = velox::memory::memoryManager()->addRootPool();
+  static auto leafPool = rootPool->addLeafChild("py_velox_plan_builder_pool");
+
   // Need types to specify table scan schema output.
   py::module::import("pyvelox.type");
 
@@ -79,7 +82,7 @@ PYBIND11_MODULE(plan_builder, m) {
       .value("FULL", velox::core::JoinType::kFull);
 
   py::class_<velox::py::PyPlanBuilder>(m, "PlanBuilder", py::module_local())
-      .def(py::init<>())
+      .def(py::init([]() { return velox::py::PyPlanBuilder{leafPool}; }))
       .def("get_plan_node", &velox::py::PyPlanBuilder::planNode, py::doc(R"(
         Returns the current plan node.
       )"))
@@ -183,6 +186,19 @@ PYBIND11_MODULE(plan_builder, m) {
           grouping_keys: List of columns to group by.
           aggregations: List of aggregate expressions.
       )"))
+      .def(
+          "streaming_aggregate",
+          &velox::py::PyPlanBuilder::streamingAggregate,
+          py::arg("grouping_keys") = std::vector<std::string>{},
+          py::arg("aggregations") = std::vector<std::string>{},
+          py::doc(R"(
+        Adds a single stage streaming aggregation. Assumes data is sorted based
+        on the grouping keys.
+
+        Args:
+          grouping_keys: List of columns to group by.
+          aggregations: List of aggregate expressions.
+      )"))
       .def(
           "order_by",
           &velox::py::PyPlanBuilder::orderBy,
@@ -276,6 +292,35 @@ PYBIND11_MODULE(plan_builder, m) {
           output: List of columns to be projected out of the join.
           join_type: Join type (inner, left, right, full, etc).
       )"))
+      .def(
+          "unnest",
+          &velox::py::PyPlanBuilder::unnest,
+          py::arg("unnest_columns"),
+          py::arg("replicate_columns") = std::vector<std::string>{},
+          py::arg("ordinal_column") = std::nullopt,
+          py::arg("empty_unnest_value_name") = std::nullopt,
+          py::doc(R"(
+        Add an UnnestNode to unnest (explode) one or more columns of type array
+        or map. The output will contain 'replicatedColumns' followed by
+        unnested columns, followed by an optional ordinality column.
+
+        Args:
+          unnest_columns: A subset of input columns to unnest. These columns
+                         must be of type array or map.
+          replicate_columns: A subset of input columns to include in the output
+                            unmodified.
+          ordinal_column: An optional name for the 'ordinal' column to produce.
+                         This column contains the index of the element of the
+                         unnested array or map. If not specified, the output
+                         will not contain this column.
+          empty_unnest_value_name: An optional name for the 'emptyUnnestValue'
+                                column to produce. This column contains a
+                                boolean indicating if the output row has empty
+                                unnest value or not. If not specified, the
+                                output will not contain this column and the
+                                unnest operator also skips producing output
+                                rows with empty unnest value.
+      )"))
       .def(
           "sorted_merge",
           &velox::py::PyPlanBuilder::sortedMerge,
diff --git a/velox/python/plan_builder/plan_builder.pyi b/velox/python/plan_builder/plan_builder.pyi
index 83cd5d1d523e..26d0d9c9c546 100644
--- a/velox/python/plan_builder/plan_builder.pyi
+++ b/velox/python/plan_builder/plan_builder.pyi
@@ -52,6 +52,25 @@ class PlanBuilder:
         num_parts: int = 1,
         connector_id: str = "tpch",
     ) -> PlanBuilder: ...
+    def hash_join(
+        self,
+        left_keys: list[str],
+        right_keys: list[str],
+        build_plan_node: PlanNode,
+        output: list[str] = [],
+        filter: str = "",
+        join_type: JoinType = JoinType.INNER,
+    ) -> PlanBuilder: ...
+    def aggregate(
+        self,
+        grouping_keys: list[str],
+        aggregations: list[str],
+    ) -> PlanBuilder: ...
+    def streaming_aggregate(
+        self,
+        grouping_keys: list[str],
+        aggregations: list[str],
+    ) -> PlanBuilder: ...
     def table_write(
         self,
         output_file: Optional[File] = None,
@@ -59,6 +78,13 @@ class PlanBuilder:
         connector_id: str = "hive",
         output_schema: Optional[Type] = None,
     ) -> PlanBuilder: ...
-    def get_plan_node(self) -> PlanBuilder: ...
+    def unnest(
+        self,
+        unnest_columns: list[str],
+        replicate_columns: list[str] = [],
+        ordinal_column: Optional[str] = None,
+        empty_unnest_value_name: Optional[str] = None,
+    ) -> PlanBuilder: ...
+    def get_plan_node(self) -> PlanNode: ...
     def new_builder(self) -> PlanBuilder: ...
     def id(self) -> str: ...
diff --git a/velox/python/runner/PyConnectors.cpp b/velox/python/runner/PyConnectors.cpp
index ad5e5b416eed..5357985b8c14 100644
--- a/velox/python/runner/PyConnectors.cpp
+++ b/velox/python/runner/PyConnectors.cpp
@@ -30,15 +30,11 @@ template <typename TConnectorFactory>
 void registerConnector(
     const std::string& connectorId,
     std::unordered_map<std::string, std::string> configs) {
-  connector::registerConnectorFactory(
-      std::make_shared<TConnectorFactory>(connectorId.data()));
-
   const auto configBase =
       std::make_shared<velox::config::ConfigBase>(std::move(configs));
-  auto connector =
-      connector::getConnectorFactory(connectorId)
-          ->newConnector(
-              connectorId, configBase, folly::getGlobalCPUExecutor().get());
+  TConnectorFactory factory;
+  auto connector = factory.newConnector(
+      connectorId, configBase, folly::getGlobalCPUExecutor().get());
   connector::registerConnector(connector);
   connectorRegistry().insert(connectorId);
 }
@@ -61,8 +57,7 @@ void registerTpch(
 
 // Is it ok to unregister connectors that were not registered.
 void unregister(const std::string& connectorId) {
-  if (!facebook::velox::connector::unregisterConnector(connectorId) ||
-      !facebook::velox::connector::unregisterConnectorFactory(connectorId)) {
+  if (!facebook::velox::connector::unregisterConnector(connectorId)) {
     throw std::runtime_error(
         fmt::format("Unable to unregister connector '{}'", connectorId));
   }
diff --git a/velox/python/runner/PyLocalRunner.cpp b/velox/python/runner/PyLocalRunner.cpp
index 3f9eefe4a8d2..9b8df9bfda0c 100644
--- a/velox/python/runner/PyLocalRunner.cpp
+++ b/velox/python/runner/PyLocalRunner.cpp
@@ -38,6 +38,18 @@ std::mutex& taskRegistryLock() {
   return lock;
 }
 
+exec::Split preparedSplit(
+    std::shared_ptr<connector::ConnectorSplit> connectorSplit) {
+  // Adds special $row_group_id column to the split.
+  if (auto* hiveConnectorSplit =
+          dynamic_cast<connector::hive::HiveConnectorSplit*>(
+              connectorSplit.get())) {
+    hiveConnectorSplit->infoColumns["$row_group_id"] =
+        hiveConnectorSplit->getFileName();
+  }
+  return exec::Split{std::move(connectorSplit)};
+}
+
 } // namespace
 
 namespace py = pybind11;
@@ -93,7 +105,7 @@ py::iterator PyLocalRunner::execute(int32_t maxDrivers) {
       cache::AsyncDataCache::getInstance(),
       rootPool_);
 
-  // Intialize task cursor and task.
+  // Initialize task cursor and task.
   cursor_ = exec::TaskCursor::create({
       .planNode = planNode_,
       .maxDrivers = maxDrivers,
@@ -104,7 +116,7 @@ py::iterator PyLocalRunner::execute(int32_t maxDrivers) {
   // Add any files passed by the client during plan building.
   for (auto& [scanId, splits] : scanFiles_) {
     for (auto& split : splits) {
-      cursor_->task()->addSplit(scanId, exec::Split(std::move(split)));
+      cursor_->task()->addSplit(scanId, preparedSplit(std::move(split)));
     }
     cursor_->task()->noMoreSplits(scanId);
   }
diff --git a/velox/python/runner/PyLocalRunner.h b/velox/python/runner/PyLocalRunner.h
index ee3d0ef421dd..5153579351db 100644
--- a/velox/python/runner/PyLocalRunner.h
+++ b/velox/python/runner/PyLocalRunner.h
@@ -125,10 +125,6 @@ class PyTaskIterator {
       return *this;
     }
 
-    bool operator!=(const Iterator& other) const {
-      return vector_ != other.vector_;
-    }
-
     bool operator==(const Iterator& other) const {
       return vector_ == other.vector_;
     }
diff --git a/velox/python/runner/runner.cpp b/velox/python/runner/runner.cpp
index 89e829a8040a..66c315bb1dde 100644
--- a/velox/python/runner/runner.cpp
+++ b/velox/python/runner/runner.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <folly/system/HardwareConcurrency.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include "velox/python/init/PyInit.h"
@@ -32,7 +33,7 @@ PYBIND11_MODULE(runner, m) {
   // is about to exit.
   static auto rootPool = velox::memory::memoryManager()->addRootPool();
   static auto executor = std::make_shared<folly::CPUThreadPoolExecutor>(
-      std::thread::hardware_concurrency());
+      folly::hardware_concurrency());
 
   // execute() returns an iterator to Vectors.
   py::module::import("pyvelox.vector");
@@ -133,7 +134,7 @@ PYBIND11_MODULE(runner, m) {
 
   // When the module gets unloaded, first ensure all tasks created by this
   // module have finished, then unregister all connectors that have been
-  // registered by this module. We need to explicity unregister them to prevent
+  // registered by this module. We need to explicitly unregister them to prevent
   // the connectors and their nested structures from being destructed after
   // other global and static resources are destructed.
   m.add_object("_cleanup", py::capsule([]() {
diff --git a/velox/python/type/PyType.h b/velox/python/type/PyType.h
index 7fc2dfdc6c55..bdf940a6bd16 100644
--- a/velox/python/type/PyType.h
+++ b/velox/python/type/PyType.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include <pybind11/embed.h>
+#include "velox/functions/prestosql/types/JsonType.h"
 #include "velox/type/Type.h"
 
 namespace facebook::velox::py {
@@ -43,9 +44,11 @@ class PyType {
   // Factory functions:
 
   static PyType createRowType(
-      const std::vector<std::string>& names,
+      std::vector<std::string> names,
       const std::vector<PyType>& pyTypes) {
     std::vector<TypePtr> types;
+    types.reserve(pyTypes.size());
+
     for (const auto& pyType : pyTypes) {
       types.emplace_back(pyType.type());
     }
@@ -53,7 +56,7 @@ class PyType {
     if (names.empty()) {
       return PyType{ROW(std::move(types))};
     }
-    return PyType{ROW(folly::copy(names), std::move(types))};
+    return PyType{ROW(std::move(names), std::move(types))};
   }
 
   static PyType createMapType(const PyType& keyType, const PyType& valueType) {
@@ -104,6 +107,10 @@ class PyType {
     return PyType{VARBINARY()};
   }
 
+  static PyType createJson() {
+    return PyType{JSON()};
+  }
+
  private:
   TypePtr type_;
 };
diff --git a/velox/python/type/type.cpp b/velox/python/type/type.cpp
index fa32615eb924..28f56db1b606 100644
--- a/velox/python/type/type.cpp
+++ b/velox/python/type/type.cpp
@@ -42,6 +42,8 @@ PYBIND11_MODULE(type, m) {
   m.def("VARCHAR", &velox::py::PyType::createVarchar);
   m.def("VARBINARY", &velox::py::PyType::createVarbinary);
 
+  m.def("JSON", &velox::py::PyType::createJson);
+
   m.def("DATE", &velox::py::PyType::createDate);
 
   m.def("ARRAY", &velox::py::PyType::createArrayType, py::arg("elements_type"));
diff --git a/velox/python/type/type.pyi b/velox/python/type/type.pyi
index 6d7f95fccd38..c918928f3b18 100644
--- a/velox/python/type/type.pyi
+++ b/velox/python/type/type.pyi
@@ -28,6 +28,7 @@ def DATE() -> Type: ...
 def DOUBLE() -> Type: ...
 def VARCHAR() -> Type: ...
 def VARBINARY() -> Type: ...
+def JSON() -> Type: ...
 def ARRAY(elements_type: Type) -> Type: ...
 def MAP(key_type: Type, value_type: Type) -> Type: ...
 def ROW(names: List[str] = [], types: List[Type] = []) -> Type: ...
diff --git a/velox/python/vector/PyVector.cpp b/velox/python/vector/PyVector.cpp
index 0df59ad16f05..529355c9028b 100644
--- a/velox/python/vector/PyVector.cpp
+++ b/velox/python/vector/PyVector.cpp
@@ -45,8 +45,9 @@ PyVector PyVector::childAt(vector_size_t idx) const {
   if (auto rowVector = std::dynamic_pointer_cast<RowVector>(vector_)) {
     return PyVector{rowVector->childAt(idx), pool_};
   }
-  throw std::runtime_error(fmt::format(
-      "Can only call child_at() on RowVector, but got '{}'", toString()));
+  throw std::runtime_error(
+      fmt::format(
+          "Can only call child_at() on RowVector, but got '{}'", toString()));
 }
 
 } // namespace facebook::velox::py
diff --git a/velox/row/CompactRow.cpp b/velox/row/CompactRow.cpp
index 2dec96942711..91ab0edd1914 100644
--- a/velox/row/CompactRow.cpp
+++ b/velox/row/CompactRow.cpp
@@ -455,7 +455,7 @@ int32_t CompactRow::variableWidthRowSize(vector_size_t index) const {
       return rowRowSize(index);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type kind: {}", mapTypeKindToName(typeKind_));
+          "Unexpected type kind: {}", TypeKindName::toName(typeKind_));
   };
 }
 
@@ -718,7 +718,7 @@ int32_t CompactRow::serializeVariableWidth(vector_size_t index, char* buffer)
       return serializeRow(index, buffer);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type kind: {}", mapTypeKindToName(typeKind_));
+          "Unexpected type kind: {}", TypeKindName::toName(typeKind_));
   };
 }
 
@@ -1145,16 +1145,12 @@ VectorPtr deserialize(
     case TypeKind::VARCHAR:
     case TypeKind::VARBINARY:
       return deserializeStrings(type, data, nulls, offsets, pool);
-      break;
     case TypeKind::ARRAY:
       return deserializeArrays(type, data, nulls, offsets, pool);
-      break;
     case TypeKind::MAP:
       return deserializeMaps(type, data, nulls, offsets, pool);
-      break;
     case TypeKind::ROW:
       return deserializeRows(type, data, nulls, offsets, pool);
-      break;
     default:
       VELOX_UNREACHABLE("{}", type->toString());
   }
diff --git a/velox/row/UnsafeRowFast.cpp b/velox/row/UnsafeRowFast.cpp
index 9e27a229d201..f29941cd10d6 100644
--- a/velox/row/UnsafeRowFast.cpp
+++ b/velox/row/UnsafeRowFast.cpp
@@ -161,7 +161,7 @@ int32_t UnsafeRowFast::variableWidthRowSize(vector_size_t index) const {
       return rowRowSize(index);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type kind: {}", mapTypeKindToName(typeKind_));
+          "Unexpected type kind: {}", TypeKindName::toName(typeKind_));
   };
 }
 
@@ -228,7 +228,7 @@ int32_t UnsafeRowFast::serializeVariableWidth(vector_size_t index, char* buffer)
       return serializeRow(index, buffer);
     default:
       VELOX_UNREACHABLE(
-          "Unexpected type kind: {}", mapTypeKindToName(typeKind_));
+          "Unexpected type kind: {}", TypeKindName::toName(typeKind_));
   };
 }
 
@@ -1023,16 +1023,12 @@ VectorPtr deserialize(
     case TypeKind::VARCHAR:
     case TypeKind::VARBINARY:
       return deserializeStrings(type, data, nulls, offsets, pool);
-      break;
     case TypeKind::ARRAY:
       return deserializeArrays(type, data, nulls, pool);
-      break;
     case TypeKind::MAP:
       return deserializeMaps(type, data, nulls, pool);
-      break;
     case TypeKind::ROW:
       return deserializeRows(type, data, nulls, offsets, pool);
-      break;
     default:
       VELOX_UNREACHABLE("{}", type->toString());
   }
diff --git a/velox/row/benchmarks/CMakeLists.txt b/velox/row/benchmarks/CMakeLists.txt
index 51888106aa3c..ca6ebe4d6216 100644
--- a/velox/row/benchmarks/CMakeLists.txt
+++ b/velox/row/benchmarks/CMakeLists.txt
@@ -12,13 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-add_executable(velox_unsafe_row_serialize_benchmark
-               UnsafeRowSerializeBenchmark.cpp)
+add_executable(velox_unsafe_row_serialize_benchmark UnsafeRowSerializeBenchmark.cpp)
 target_link_libraries(
   velox_unsafe_row_serialize_benchmark
-  PRIVATE
-    velox_exec
-    velox_row_fast
-    velox_vector_fuzzer
-    Folly::folly
-    Folly::follybenchmark)
+  PRIVATE velox_exec velox_row_fast velox_vector_fuzzer Folly::folly Folly::follybenchmark
+)
diff --git a/velox/row/tests/CMakeLists.txt b/velox/row/tests/CMakeLists.txt
index fbd1a0fc1722..3a504450ec8b 100644
--- a/velox/row/tests/CMakeLists.txt
+++ b/velox/row/tests/CMakeLists.txt
@@ -20,10 +20,9 @@ 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
-    GTest::gtest_main)
+    GTest::gtest_main
+)
diff --git a/velox/row/tests/UnsafeRowTest.cpp b/velox/row/tests/UnsafeRowTest.cpp
index b0eea1ae61db..9a30611d2423 100644
--- a/velox/row/tests/UnsafeRowTest.cpp
+++ b/velox/row/tests/UnsafeRowTest.cpp
@@ -216,5 +216,11 @@ TEST_F(UnsafeRowTest, nestedMaps) {
   testRoundTrip(data);
 }
 
+TEST_F(UnsafeRowTest, constantVector) {
+  auto data =
+      makeRowVector({BaseVector::createNullConstant(ROW({}), 1, pool_.get())});
+  testRoundTrip(data);
+}
+
 } // namespace
 } // namespace facebook::velox::row
diff --git a/velox/runner/LocalRunner.cpp b/velox/runner/LocalRunner.cpp
deleted file mode 100644
index d90f8c4dcf97..000000000000
--- a/velox/runner/LocalRunner.cpp
+++ /dev/null
@@ -1,300 +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/runner/LocalRunner.h"
-#include "velox/common/time/Timer.h"
-
-#include "velox/connectors/hive/HiveConnectorSplit.h"
-
-namespace facebook::velox::runner {
-namespace {
-std::shared_ptr<exec::RemoteConnectorSplit> remoteSplit(
-    const std::string& taskId) {
-  return std::make_shared<exec::RemoteConnectorSplit>(taskId);
-}
-} // namespace
-
-RowVectorPtr LocalRunner::next() {
-  if (!cursor_) {
-    start();
-  }
-  bool hasNext = cursor_->moveNext();
-  if (!hasNext) {
-    state_ = State::kFinished;
-    return nullptr;
-  }
-  return cursor_->current();
-}
-
-namespace {
-std::vector<exec::Split> listAllSplits(std::shared_ptr<SplitSource> source) {
-  std::vector<exec::Split> result;
-  for (;;) {
-    auto splits = source->getSplits(std::numeric_limits<uint64_t>::max());
-    VELOX_CHECK(!splits.empty());
-    for (auto& split : splits) {
-      if (split.split == nullptr) {
-        return result;
-        break;
-      }
-      result.push_back(exec::Split(std::move(split.split)));
-    }
-  }
-  VELOX_UNREACHABLE();
-}
-} // namespace
-
-void LocalRunner::start() {
-  VELOX_CHECK_EQ(state_, State::kInitialized);
-  auto lastStage = makeStages();
-  params_.planNode = plan_->fragments().back().fragment.planNode;
-  auto cursor = exec::TaskCursor::create(params_);
-  stages_.push_back({cursor->task()});
-  // Add table scan splits to the final gathere stage.
-  for (auto& scan : fragments_.back().scans) {
-    auto splits = listAllSplits(splitSourceForScan(*scan));
-    for (auto& split : splits) {
-      cursor->task()->addSplit(scan->id(), std::move(split));
-    }
-    cursor->task()->noMoreSplits(scan->id());
-  }
-  // If the plan only has the final gather stage, there are no shuffles between
-  // the last
-  // and previous stages to set up.
-  if (!lastStage.empty()) {
-    const auto finalStageConsumer =
-        fragments_.back().inputStages[0].consumerNodeId;
-    for (auto& remote : lastStage) {
-      cursor->task()->addSplit(finalStageConsumer, exec::Split(remote));
-    }
-    cursor->task()->noMoreSplits(finalStageConsumer);
-  }
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    if (!error_) {
-      cursor_ = std::move(cursor);
-      state_ = State::kRunning;
-    }
-  }
-  if (!cursor_) {
-    // The cursor was not set because previous fragments had an error.
-    abort();
-    std::rethrow_exception(error_);
-  }
-}
-
-std::shared_ptr<SplitSource> LocalRunner::splitSourceForScan(
-    const core::TableScanNode& scan) {
-  return splitSourceFactory_->splitSourceForScan(scan);
-}
-
-void LocalRunner::abort() {
-  // If called without previous error, we set the error to be cancellation.
-  if (!error_) {
-    try {
-      state_ = State::kCancelled;
-      VELOX_FAIL("Query cancelled");
-    } catch (const std::exception&) {
-      error_ = std::current_exception();
-    }
-  }
-  VELOX_CHECK(state_ != State::kInitialized);
-  // Setting errors is thred safe. The stages do not change after
-  // initialization.
-  for (auto& stage : stages_) {
-    for (auto& task : stage) {
-      task->setError(error_);
-    }
-  }
-  if (cursor_) {
-    cursor_->setError(error_);
-  }
-}
-
-void LocalRunner::waitForCompletion(int32_t maxWaitUs) {
-  VELOX_CHECK_NE(state_, State::kInitialized);
-  std::vector<ContinueFuture> futures;
-  {
-    std::lock_guard<std::mutex> l(mutex_);
-    for (auto& stage : stages_) {
-      for (auto& task : stage) {
-        futures.push_back(task->taskDeletionFuture());
-      }
-      stage.clear();
-    }
-  }
-  auto startTime = getCurrentTimeMicro();
-  for (auto& future : futures) {
-    auto& executor = folly::QueuedImmediateExecutor::instance();
-    if (getCurrentTimeMicro() - startTime > maxWaitUs) {
-      VELOX_FAIL("LocalRunner did not finish within {} us", maxWaitUs);
-    }
-    std::move(future)
-        .within(std::chrono::microseconds(maxWaitUs))
-        .via(&executor)
-        .wait();
-  }
-}
-
-std::vector<std::shared_ptr<exec::RemoteConnectorSplit>>
-LocalRunner::makeStages() {
-  std::unordered_map<std::string, int32_t> stageMap;
-  auto sharedRunner = shared_from_this();
-  auto onError = [self = sharedRunner, this](std::exception_ptr error) {
-    {
-      std::lock_guard<std::mutex> l(mutex_);
-      if (error_) {
-        return;
-      }
-      state_ = State::kError;
-      error_ = error;
-    }
-    if (cursor_) {
-      abort();
-    }
-  };
-
-  for (auto fragmentIndex = 0; fragmentIndex < fragments_.size() - 1;
-       ++fragmentIndex) {
-    auto& fragment = fragments_[fragmentIndex];
-    stageMap[fragment.taskPrefix] = stages_.size();
-    stages_.emplace_back();
-    for (auto i = 0; i < fragment.width; ++i) {
-      exec::Consumer consumer = nullptr;
-      auto task = exec::Task::create(
-          fmt::format(
-              "local://{}/{}.{}",
-              params_.queryCtx->queryId(),
-              fragment.taskPrefix,
-              i),
-          fragment.fragment,
-          i,
-          params_.queryCtx,
-          exec::Task::ExecutionMode::kParallel,
-          consumer,
-          0,
-          onError);
-      stages_.back().push_back(task);
-      // Output buffers are created during Task::start(), so we must start the
-      // task before calling updateOutputBuffers().
-      task->start(options_.numDrivers);
-      if (fragment.numBroadcastDestinations) {
-        // TODO: Add support for Arbitrary partition type.
-        task->updateOutputBuffers(fragment.numBroadcastDestinations, true);
-      }
-    }
-  }
-
-  for (auto fragmentIndex = 0; fragmentIndex < fragments_.size() - 1;
-       ++fragmentIndex) {
-    auto& fragment = fragments_[fragmentIndex];
-    for (auto& scan : fragment.scans) {
-      auto source = splitSourceForScan(*scan);
-      std::vector<SplitSource::SplitAndGroup> splits;
-      int32_t splitIdx = 0;
-      auto getNextSplit = [&]() {
-        if (splitIdx < splits.size()) {
-          return exec::Split(std::move(splits[splitIdx++].split));
-        }
-        splits = source->getSplits(std::numeric_limits<int64_t>::max());
-        splitIdx = 1;
-        return exec::Split(std::move(splits[0].split));
-      };
-
-      bool allDone = false;
-      do {
-        for (auto i = 0; i < stages_[fragmentIndex].size(); ++i) {
-          auto split = getNextSplit();
-          if (!split.hasConnectorSplit()) {
-            allDone = true;
-            break;
-          }
-          stages_[fragmentIndex][i]->addSplit(scan->id(), std::move(split));
-        }
-      } while (!allDone);
-    }
-    for (auto& scan : fragment.scans) {
-      for (auto i = 0; i < stages_[fragmentIndex].size(); ++i) {
-        stages_[fragmentIndex][i]->noMoreSplits(scan->id());
-      }
-    }
-
-    for (auto& input : fragment.inputStages) {
-      const auto sourceStage = stageMap[input.producerTaskPrefix];
-      std::vector<std::shared_ptr<exec::RemoteConnectorSplit>> sourceSplits;
-      for (auto i = 0; i < stages_[sourceStage].size(); ++i) {
-        sourceSplits.push_back(remoteSplit(stages_[sourceStage][i]->taskId()));
-      }
-      for (auto& task : stages_[fragmentIndex]) {
-        for (auto& remote : sourceSplits) {
-          task->addSplit(input.consumerNodeId, exec::Split(remote));
-        }
-        task->noMoreSplits(input.consumerNodeId);
-      }
-    }
-  }
-  if (stages_.empty()) {
-    return {};
-  }
-  std::vector<std::shared_ptr<exec::RemoteConnectorSplit>> lastStage;
-  for (auto& task : stages_.back()) {
-    lastStage.push_back(remoteSplit(task->taskId()));
-  }
-  return lastStage;
-}
-
-std::vector<exec::TaskStats> LocalRunner::stats() const {
-  std::vector<exec::TaskStats> result;
-  std::lock_guard<std::mutex> l(mutex_);
-  for (auto i = 0; i < stages_.size(); ++i) {
-    auto& tasks = stages_[i];
-    VELOX_CHECK(!tasks.empty());
-    auto stats = tasks[0]->taskStats();
-    for (auto j = 1; j < tasks.size(); ++j) {
-      auto moreStats = tasks[j]->taskStats();
-      for (auto pipeline = 0; pipeline < stats.pipelineStats.size();
-           ++pipeline) {
-        for (auto op = 0;
-             op < stats.pipelineStats[pipeline].operatorStats.size();
-             ++op) {
-          stats.pipelineStats[pipeline].operatorStats[op].add(
-              moreStats.pipelineStats[pipeline].operatorStats[op]);
-        }
-      }
-    }
-    result.push_back(std::move(stats));
-  }
-  return result;
-}
-
-std::vector<SplitSource::SplitAndGroup> SimpleSplitSource::getSplits(
-    uint64_t /*targetBytes*/) {
-  if (splitIdx_ >= splits_.size()) {
-    return {{nullptr, 0}};
-  }
-  return {SplitAndGroup{std::move(splits_[splitIdx_++]), 0}};
-}
-
-std::shared_ptr<SplitSource> SimpleSplitSourceFactory::splitSourceForScan(
-    const core::TableScanNode& scan) {
-  auto it = nodeSplitMap_.find(scan.id());
-  if (it == nodeSplitMap_.end()) {
-    VELOX_FAIL("Splits aare not provided for scan {}", scan.id());
-  }
-  return std::make_shared<SimpleSplitSource>(it->second);
-}
-
-} // namespace facebook::velox::runner
diff --git a/velox/runner/LocalRunner.h b/velox/runner/LocalRunner.h
deleted file mode 100644
index 22efbe5de6dd..000000000000
--- a/velox/runner/LocalRunner.h
+++ /dev/null
@@ -1,113 +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/connectors/Connector.h"
-#include "velox/exec/Cursor.h"
-#include "velox/exec/Exchange.h"
-#include "velox/runner/MultiFragmentPlan.h"
-#include "velox/runner/Runner.h"
-
-namespace facebook::velox::runner {
-
-/// Testing proxy for a split source managed by a system with full metadata
-/// access.
-class SimpleSplitSource : public SplitSource {
- public:
-  explicit SimpleSplitSource(
-      std::vector<std::shared_ptr<connector::ConnectorSplit>> splits)
-      : splits_(std::move(splits)) {}
-
-  virtual std::vector<SplitAndGroup> getSplits(uint64_t targetBytes) override;
-
- private:
-  std::vector<std::shared_ptr<connector::ConnectorSplit>> splits_;
-  int32_t splitIdx_{0};
-};
-
-/// Testing proxy for a split source factory that uses connector metadata to
-/// enumerate splits. This takes a precomputed split list for each scan.
-class SimpleSplitSourceFactory : public SplitSourceFactory {
- public:
-  explicit SimpleSplitSourceFactory(
-      std::unordered_map<
-          core::PlanNodeId,
-          std::vector<std::shared_ptr<connector::ConnectorSplit>>> nodeSplitMap)
-      : nodeSplitMap_(std::move(nodeSplitMap)) {}
-
-  std::shared_ptr<SplitSource> splitSourceForScan(
-      const core::TableScanNode& scan) override;
-
- private:
-  std::unordered_map<
-      core::PlanNodeId,
-      std::vector<std::shared_ptr<connector::ConnectorSplit>>>
-      nodeSplitMap_;
-};
-
-/// Runner for in-process execution of a distributed plan.
-class LocalRunner : public Runner,
-                    public std::enable_shared_from_this<LocalRunner> {
- public:
-  LocalRunner(
-      MultiFragmentPlanPtr plan,
-      std::shared_ptr<core::QueryCtx> queryCtx,
-      std::shared_ptr<SplitSourceFactory> splitSourceFactory)
-      : plan_(std::move(plan)),
-        fragments_(plan_->fragments()),
-        options_(plan_->options()),
-        splitSourceFactory_(std::move(splitSourceFactory)) {
-    params_.queryCtx = std::move(queryCtx);
-  }
-
-  RowVectorPtr next() override;
-
-  std::vector<exec::TaskStats> stats() const override;
-
-  void abort() override;
-
-  void waitForCompletion(int32_t maxWaitMicros) override;
-
-  State state() const override {
-    return state_;
-  }
-
- private:
-  void start();
-
-  // Creates all stages except for the single worker final consumer stage.
-  std::vector<std::shared_ptr<exec::RemoteConnectorSplit>> makeStages();
-  std::shared_ptr<SplitSource> splitSourceForScan(
-      const core::TableScanNode& scan);
-
-  // Serializes 'cursor_' and 'error_'.
-  mutable std::mutex mutex_;
-
-  const MultiFragmentPlanPtr plan_;
-  const std::vector<ExecutableFragment> fragments_;
-  const MultiFragmentPlan::Options& options_;
-
-  exec::CursorParameters params_;
-
-  tsan_atomic<State> state_{State::kInitialized};
-
-  std::unique_ptr<exec::TaskCursor> cursor_;
-  std::vector<std::vector<std::shared_ptr<exec::Task>>> stages_;
-  std::exception_ptr error_;
-  std::shared_ptr<SplitSourceFactory> splitSourceFactory_;
-};
-
-} // namespace facebook::velox::runner
diff --git a/velox/runner/MultiFragmentPlan.cpp b/velox/runner/MultiFragmentPlan.cpp
deleted file mode 100644
index 5396db41db5d..000000000000
--- a/velox/runner/MultiFragmentPlan.cpp
+++ /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.
- */
-
-#include "velox/runner/MultiFragmentPlan.h"
-
-namespace facebook::velox::runner {
-
-namespace {
-
-std::string toFragmentsString(
-    const std::vector<ExecutableFragment>& fragments,
-    const std::function<std::string(const core::PlanNode&)>& planNodeToString) {
-  std::stringstream out;
-  for (auto i = 0; i < fragments.size(); ++i) {
-    const auto& fragment = fragments[i];
-    out << fmt::format(
-               "Fragment {}: {} numWorkers={}:",
-               i,
-               fragment.taskPrefix,
-               fragment.width)
-        << std::endl;
-    out << planNodeToString(*fragment.fragment.planNode) << std::endl;
-    if (!fragment.inputStages.empty()) {
-      out << "Inputs: ";
-      for (auto& input : fragment.inputStages) {
-        out << fmt::format(
-            " {} <- {} ", input.consumerNodeId, input.producerTaskPrefix);
-      }
-      out << std::endl;
-    }
-  }
-  return out.str();
-}
-
-} // namespace
-
-std::string MultiFragmentPlan::toString(bool detailed) const {
-  return toFragmentsString(fragments_, [&](const auto& planNode) {
-    return planNode.toString(detailed, true);
-  });
-}
-
-std::string MultiFragmentPlan::toSummaryString(
-    core::PlanSummaryOptions options) const {
-  return toFragmentsString(fragments_, [&](const auto& planNode) {
-    return planNode.toSummaryString(options);
-  });
-}
-
-} // namespace facebook::velox::runner
diff --git a/velox/runner/MultiFragmentPlan.h b/velox/runner/MultiFragmentPlan.h
deleted file mode 100644
index 1887cd8138ed..000000000000
--- a/velox/runner/MultiFragmentPlan.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 "velox/core/PlanFragment.h"
-
-namespace facebook::velox::runner {
-
-/// Describes an exchange source for an ExchangeNode a non-leaf stage.
-struct InputStage {
-  // Id of ExchangeNode in the consumer fragment.
-  core::PlanNodeId consumerNodeId;
-
-  /// Task prefix of producer stage.
-  std::string producerTaskPrefix;
-};
-
-/// Describes a fragment of a distributed plan. This allows a run
-/// time to distribute fragments across workers and to set up
-/// exchanges. A complete plan is a vector of these with the last
-/// being the fragment that gathers results from the complete
-/// plan. Different runtimes, e.g. local, streaming or
-/// materialized shuffle can use this to describe exchange
-/// parallel execution. Decisions on number of workers, location
-/// of workers and mode of exchange are up to the runtime.
-struct ExecutableFragment {
-  ExecutableFragment() = default;
-
-  explicit ExecutableFragment(const std::string& taskPrefix)
-      : taskPrefix(taskPrefix) {}
-  std::string taskPrefix;
-  int32_t width{0};
-  velox::core::PlanFragment fragment;
-
-  /// Source fragments and Exchange node ids for remote shuffles producing input
-  /// for 'this'.
-  std::vector<InputStage> inputStages;
-
-  /// Table scan nodes in 'this'.
-  std::vector<std::shared_ptr<const core::TableScanNode>> scans;
-  int32_t numBroadcastDestinations{0};
-};
-
-/// Describes a distributed plan handed to a Runner for parallel/distributed
-/// execution. The last element of 'fragments' is by convention the stage that
-/// gathers the query result. Otherwise the order of 'fragments' is not
-/// important since the producer-consumer relations are given by 'inputStages'
-/// in each fragment.
-class MultiFragmentPlan {
- public:
-  /// Describes options for running a MultiFragmentPlan.
-  struct Options {
-    /// Query id used as a prefix for tasks ids.
-    std::string queryId;
-
-    /// Maximum Number of independent Tasks for one stage of execution. If 1,
-    /// there are no exchanges.
-    int32_t numWorkers;
-
-    /// Number of threads in a fragment in a worker. If 1, there are no local
-    /// exchanges.
-    int32_t numDrivers;
-  };
-
-  MultiFragmentPlan(std::vector<ExecutableFragment> fragments, Options options)
-      : fragments_(std::move(fragments)), options_(std::move(options)) {}
-
-  const std::vector<ExecutableFragment>& fragments() const {
-    return fragments_;
-  }
-
-  const Options& options() const {
-    return options_;
-  }
-
-  /// @param detailed If true, includes details of each plan node. Otherwise,
-  /// only node types are included.
-  std::string toString(bool detailed = true) const;
-
-  /// Prints the summary of the plan using PlanNode::toSummaryString() API.
-  std::string toSummaryString(core::PlanSummaryOptions options = {}) const;
-
- private:
-  const std::vector<ExecutableFragment> fragments_;
-  const Options options_;
-};
-
-using MultiFragmentPlanPtr = std::shared_ptr<const MultiFragmentPlan>;
-
-} // namespace facebook::velox::runner
diff --git a/velox/runner/Runner.h b/velox/runner/Runner.h
deleted file mode 100644
index 21a1a00ce068..000000000000
--- a/velox/runner/Runner.h
+++ /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.
- */
-#pragma once
-
-#include "velox/connectors/Connector.h"
-#include "velox/exec/Cursor.h"
-#include "velox/exec/Exchange.h"
-#include "velox/runner/MultiFragmentPlan.h"
-
-/// Base classes for multifragment Velox query execution.
-namespace facebook::velox::runner {
-
-/// Iterator for obtaining splits for a scan. One is created for each table
-/// scan.
-class SplitSource {
- public:
-  static constexpr uint32_t kUngroupedGroupId =
-      std::numeric_limits<uint32_t>::max();
-
-  /// Result of getSplits. Each split belongs to a group. A nullptr split for
-  /// group means that there are on more splits for the group. In ungrouped
-  /// execution, the group is kUngroupedGroupId.
-  struct SplitAndGroup {
-    std::shared_ptr<connector::ConnectorSplit> split;
-    uint32_t group{kUngroupedGroupId};
-  };
-
-  virtual ~SplitSource() = default;
-
-  /// Returns a set of splits that cover up to 'targetBytes' of data.
-  virtual std::vector<SplitAndGroup> getSplits(uint64_t targetBytes) = 0;
-};
-
-/// A factory for getting a SplitSource for each TableScan. The splits produced
-/// may depend on partition keys, buckets etc mentioned by each tableScan.
-class SplitSourceFactory {
- public:
-  virtual ~SplitSourceFactory() = default;
-
-  /// Returns a splitSource for one TableScan across all Tasks of
-  /// the fragment. The source will be invoked to produce splits for
-  /// each individual worker running the scan.
-  virtual std::shared_ptr<SplitSource> splitSourceForScan(
-      const core::TableScanNode& scan) = 0;
-};
-
-/// Base class for executing multifragment Velox queries. One instance
-/// of a Runner coordinates the execution of one multifragment
-/// query. Different derived classes can support different shuffles
-/// and different scheduling either in process or in a cluster. Unless
-/// otherwise stated, the member functions are thread safe as long as
-/// the caller holds an owning reference to the runner.
-class Runner {
- public:
-  enum class State { kInitialized, kRunning, kFinished, kError, kCancelled };
-
-  static std::string stateString(Runner::State state);
-
-  virtual ~Runner() = default;
-
-  /// Returns the next batch of results. Returns nullptr when no more results.
-  /// Throws any execution time errors. The result is allocated in the pool of
-  /// QueryCtx given to the Runner implementation. The caller is responsible for
-  /// serializing calls from different threads.
-  virtual RowVectorPtr next() = 0;
-
-  /// Returns Task stats for each fragment of the plan. The stats correspond 1:1
-  /// to the stages in the MultiFragmentPlan. This may be called at any time.
-  /// before waitForCompletion() or abort().
-  virtual std::vector<exec::TaskStats> stats() const = 0;
-
-  /// Returns the state of execution.
-  virtual State state() const = 0;
-
-  /// Cancels the possibly pending execution. Returns immediately, thus before
-  /// the execution is actually finished. Use waitForCompletion() to wait for
-  /// all execution resources to be freed. May be called from any thread without
-  /// serialization.
-  virtual void abort() = 0;
-
-  /// Waits up to 'maxWaitMicros' for all activity of the execution to cease.
-  /// This is used in tests to ensure that all pools are empty and unreferenced
-  /// before teradown.
-
-  virtual void waitForCompletion(int32_t maxWaitMicros) = 0;
-};
-
-} // namespace facebook::velox::runner
-
-template <>
-struct fmt::formatter<facebook::velox::runner::Runner::State>
-    : formatter<std::string> {
-  auto format(facebook::velox::runner::Runner::State state, format_context& ctx)
-      const {
-    return formatter<std::string>::format(
-        facebook::velox::runner::Runner::stateString(state), ctx);
-  }
-};
diff --git a/velox/runner/tests/LocalRunnerTest.cpp b/velox/runner/tests/LocalRunnerTest.cpp
deleted file mode 100644
index d219b2456879..000000000000
--- a/velox/runner/tests/LocalRunnerTest.cpp
+++ /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.
- */
-
-#include "velox/exec/tests/utils/DistributedPlanBuilder.h"
-#include "velox/exec/tests/utils/LocalRunnerTestBase.h"
-#include "velox/exec/tests/utils/QueryAssertions.h"
-
-namespace facebook::velox::runner {
-namespace {
-
-using namespace facebook::velox::exec;
-using namespace facebook::velox::exec::test;
-
-constexpr int kWaitTimeoutUs = 500'000;
-
-class LocalRunnerTest : public LocalRunnerTestBase {
- protected:
-  static constexpr int32_t kNumFiles = 5;
-  static constexpr int32_t kNumVectors = 5;
-  static constexpr int32_t kRowsPerVector = 10000;
-  static constexpr int32_t kNumRows = kNumFiles * kNumVectors * kRowsPerVector;
-
-  static void SetUpTestCase() {
-    // The lambdas will be run after this scope returns, so make captures
-    // static.
-    static int32_t counter1;
-    // Clear 'counter1' so that --gtest_repeat runs get the same data.
-    counter1 = 0;
-    auto customize1 = [&](const RowVectorPtr& rows) {
-      makeAscending(rows, counter1);
-    };
-
-    static int32_t counter2;
-    counter2 = kNumRows - 1;
-    auto customize2 = [&](const RowVectorPtr& rows) {
-      makeDescending(rows, counter2);
-    };
-
-    rowType_ = ROW({"c0"}, {BIGINT()});
-    testTables_ = {
-        TableSpec{
-            .name = "T",
-            .columns = rowType_,
-            .rowsPerVector = kRowsPerVector,
-            .numVectorsPerFile = kNumVectors,
-            .numFiles = kNumFiles,
-            .customizeData = customize1},
-        TableSpec{
-            .name = "U",
-            .columns = rowType_,
-            .rowsPerVector = kRowsPerVector,
-            .numVectorsPerFile = kNumVectors,
-            .numFiles = kNumFiles,
-            .customizeData = customize2}};
-
-    // Creates the data and schema from 'testTables_'. These are created on the
-    // first test fixture initialization.
-    LocalRunnerTestBase::SetUpTestCase();
-  }
-
-  std::shared_ptr<memory::MemoryPool> makeRootPool(const std::string& queryId) {
-    static std::atomic_uint64_t poolId{0};
-    return memory::memoryManager()->addRootPool(
-        fmt::format("{}_{}", queryId, poolId++));
-  }
-
-  // Returns a plan with a table scan. This is a single stage if 'numWorkers' is
-  // 1, otherwise this is a scan stage plus shuffle to a stage that gathers the
-  // scan results.
-  MultiFragmentPlanPtr makeScanPlan(const std::string& id, int32_t numWorkers) {
-    MultiFragmentPlan::Options options = {
-        .queryId = id, .numWorkers = numWorkers, .numDrivers = 2};
-
-    DistributedPlanBuilder rootBuilder(options, idGenerator_, pool_.get());
-    rootBuilder.tableScan("T", rowType_);
-    if (numWorkers > 1) {
-      rootBuilder.shufflePartitioned({}, 1, false);
-    }
-    return std::make_shared<MultiFragmentPlan>(
-        rootBuilder.fragments(), std::move(options));
-  }
-
-  MultiFragmentPlanPtr makeJoinPlan(
-      std::string project = "c0",
-      bool broadcastBuild = false) {
-    MultiFragmentPlan::Options options = {
-        .queryId = "test.", .numWorkers = 4, .numDrivers = 2};
-    const int32_t width = 3;
-
-    DistributedPlanBuilder rootBuilder(options, idGenerator_, pool_.get());
-    rootBuilder.tableScan("T", rowType_)
-        .project({project})
-        .shufflePartitioned({"c0"}, 3, false)
-        .hashJoin(
-            {"c0"},
-            {"b0"},
-            broadcastBuild
-                ? DistributedPlanBuilder(rootBuilder)
-                      .tableScan("U", rowType_)
-                      .project({"c0 as b0"})
-                      .shuffleBroadcastResult()
-                : DistributedPlanBuilder(rootBuilder)
-                      .tableScan("U", rowType_)
-                      .project({"c0 as b0"})
-                      .shufflePartitionedResult({"b0"}, width, false),
-            "",
-            {"c0", "b0"})
-        .shufflePartitioned({}, 1, false)
-        .finalAggregation({}, {"count(1)"}, {{BIGINT()}});
-    return std::make_shared<MultiFragmentPlan>(
-        rootBuilder.fragments(), std::move(options));
-  }
-
-  static void makeAscending(const RowVectorPtr& rows, int32_t& counter) {
-    auto ints = rows->childAt(0)->as<FlatVector<int64_t>>();
-    for (auto i = 0; i < ints->size(); ++i) {
-      ints->set(i, counter + i);
-    }
-    counter += ints->size();
-  }
-
-  static void makeDescending(const RowVectorPtr& rows, int32_t& counter) {
-    auto ints = rows->childAt(0)->as<FlatVector<int64_t>>();
-    for (auto i = 0; i < ints->size(); ++i) {
-      ints->set(i, counter - i);
-    }
-    counter -= ints->size();
-  }
-
-  void checkScanCount(const std::string& id, int32_t numWorkers) {
-    auto scan = makeScanPlan(id, numWorkers);
-    auto rootPool = makeRootPool(id);
-    auto splitSourceFactory = makeSimpleSplitSourceFactory(scan);
-    auto localRunner = std::make_shared<LocalRunner>(
-        std::move(scan), makeQueryCtx(id, rootPool.get()), splitSourceFactory);
-    auto results = readCursor(localRunner);
-
-    int32_t count = 0;
-    for (auto& rows : results) {
-      count += rows->size();
-    }
-    localRunner->waitForCompletion(kWaitTimeoutUs);
-    EXPECT_EQ(250'000, count);
-  }
-
-  std::shared_ptr<core::PlanNodeIdGenerator> idGenerator_{
-      std::make_shared<core::PlanNodeIdGenerator>()};
-  // The below are declared static to be scoped to TestCase so as to reuse the
-  // dataset between tests.
-
-  inline static RowTypePtr rowType_;
-};
-
-TEST_F(LocalRunnerTest, count) {
-  auto join = makeJoinPlan();
-  const std::string id = "q1";
-  auto rootPool = makeRootPool(id);
-  auto splitSourceFactory = makeSimpleSplitSourceFactory(join);
-  auto localRunner = std::make_shared<LocalRunner>(
-      std::move(join), makeQueryCtx(id, rootPool.get()), splitSourceFactory);
-  auto results = readCursor(localRunner);
-  auto stats = localRunner->stats();
-  EXPECT_EQ(1, results.size());
-  EXPECT_EQ(1, results[0]->size());
-  EXPECT_EQ(
-      kNumRows, results[0]->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0));
-  results.clear();
-  EXPECT_EQ(Runner::State::kFinished, localRunner->state());
-  localRunner->waitForCompletion(kWaitTimeoutUs);
-}
-
-TEST_F(LocalRunnerTest, error) {
-  auto join = makeJoinPlan("if (c0 = 111, c0 / 0, c0 + 1) as c0");
-  const std::string id = "q1";
-  auto rootPool = makeRootPool(id);
-  auto splitSourceFactory = makeSimpleSplitSourceFactory(join);
-  auto localRunner = std::make_shared<LocalRunner>(
-      std::move(join), makeQueryCtx(id, rootPool.get()), splitSourceFactory);
-  EXPECT_THROW(readCursor(localRunner), VeloxUserError);
-  EXPECT_EQ(Runner::State::kError, localRunner->state());
-  localRunner->waitForCompletion(kWaitTimeoutUs);
-}
-
-TEST_F(LocalRunnerTest, scan) {
-  checkScanCount("s1", 1);
-  checkScanCount("s2", 3);
-}
-
-TEST_F(LocalRunnerTest, broadcast) {
-  auto plan = makeJoinPlan("c0", true);
-  const std::string id = "q1";
-  auto rootPool = makeRootPool(id);
-  auto splitSourceFactory = makeSimpleSplitSourceFactory(plan);
-  auto localRunner = std::make_shared<LocalRunner>(
-      std::move(plan), makeQueryCtx(id, rootPool.get()), splitSourceFactory);
-  auto results = readCursor(localRunner);
-  auto stats = localRunner->stats();
-  EXPECT_EQ(1, results.size());
-  EXPECT_EQ(1, results[0]->size());
-  EXPECT_EQ(
-      kNumRows, results[0]->childAt(0)->as<FlatVector<int64_t>>()->valueAt(0));
-  results.clear();
-  EXPECT_EQ(Runner::State::kFinished, localRunner->state());
-  localRunner->waitForCompletion(kWaitTimeoutUs);
-}
-
-} // namespace
-} // namespace facebook::velox::runner
diff --git a/velox/serializers/CMakeLists.txt b/velox/serializers/CMakeLists.txt
index e5a8c6d6308a..9c6390cc730c 100644
--- a/velox/serializers/CMakeLists.txt
+++ b/velox/serializers/CMakeLists.txt
@@ -11,6 +11,17 @@
 # WITHOUT 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_key_encoder KeyEncoder.cpp)
+
+velox_link_libraries(
+  velox_key_encoder
+  velox_common_base
+  velox_core
+  velox_memory
+  velox_type
+  velox_vector
+)
+
 velox_add_library(
   velox_presto_serializer
   CompactRowSerializer.cpp
@@ -24,7 +35,9 @@ velox_add_library(
   PrestoSerializerSerializationUtils.cpp
   PrestoVectorLexer.cpp
   RowSerializer.cpp
-  VectorStream.cpp)
+  SerializedPageFile.cpp
+  VectorStream.cpp
+)
 
 velox_link_libraries(velox_presto_serializer velox_vector velox_row_fast)
 
diff --git a/velox/serializers/CompactRowSerializer.cpp b/velox/serializers/CompactRowSerializer.cpp
index 80a72f9118a8..776c5909d7c4 100644
--- a/velox/serializers/CompactRowSerializer.cpp
+++ b/velox/serializers/CompactRowSerializer.cpp
@@ -49,7 +49,7 @@ class CompactRowVectorSerializer : public RowSerializer<row::CompactRow> {
         offset += size + sizeof(TRowSize);
         ++index;
       } else {
-        raw_vector<size_t> offsets(range.size);
+        raw_vector<size_t> offsets(range.size, pool_);
         for (auto i = 0; i < range.size; ++i, ++index) {
           // Write raw size. Needs to be in big endian order.
           *(TRowSize*)(rawBuffer + offset) = folly::Endian::big(rowSize[index]);
@@ -85,19 +85,34 @@ CompactRowVectorSerde::createIterativeSerializer(
 namespace {
 std::unique_ptr<RowIterator> compactRowIteratorFactory(
     ByteInputStream* source,
-    std::unique_ptr<BufferInputStream> uncompressedStream,
-    std::unique_ptr<folly::IOBuf> uncompressedBuf,
-    size_t endOffset) {
-  if (source != nullptr) {
-    VELOX_CHECK_NULL(uncompressedStream);
-    VELOX_CHECK_NULL(uncompressedBuf);
-    return std::make_unique<RowIteratorImpl>(source, endOffset);
-  } else {
-    VELOX_CHECK_NOT_NULL(uncompressedStream);
-    VELOX_CHECK_NOT_NULL(uncompressedBuf);
+    const VectorSerde::Options* options) {
+  const auto header = detail::RowGroupHeader::read(source);
+  if (!header.compressed) {
     return std::make_unique<RowIteratorImpl>(
-        std::move(uncompressedStream), std::move(uncompressedBuf), endOffset);
+        source, header.uncompressedSize + source->tellp());
   }
+
+  const auto compressionKind = options == nullptr
+      ? VectorSerde::Options().compressionKind
+      : options->compressionKind;
+  VELOX_DCHECK_NE(
+      compressionKind, common::CompressionKind::CompressionKind_NONE);
+  auto compressBuf = folly::IOBuf::create(header.compressedSize);
+  source->readBytes(compressBuf->writableData(), header.compressedSize);
+  compressBuf->append(header.compressedSize);
+
+  // Process chained uncompressed results IOBufs.
+  const auto codec = common::compressionKindToCodec(compressionKind);
+  auto uncompressedBuf =
+      codec->uncompress(compressBuf.get(), header.uncompressedSize);
+
+  auto uncompressedStream = std::make_unique<BufferInputStream>(
+      byteRangesFromIOBuf(uncompressedBuf.get()));
+  const std::streampos initialSize = uncompressedStream->tellp();
+  return std::make_unique<RowIteratorImpl>(
+      std::move(uncompressedStream),
+      std::move(uncompressedBuf),
+      header.uncompressedSize + initialSize);
 }
 } // namespace
 
diff --git a/velox/serializers/KeyEncoder.cpp b/velox/serializers/KeyEncoder.cpp
new file mode 100644
index 000000000000..40fe3d6bf273
--- /dev/null
+++ b/velox/serializers/KeyEncoder.cpp
@@ -0,0 +1,1268 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/serializers/KeyEncoder.h"
+
+#include "velox/common/base/SimdUtil.h"
+#include "velox/type/Timestamp.h"
+#include "velox/vector/FlatVector.h"
+
+namespace facebook::velox::serializer {
+
+bool IndexBounds::validate() const {
+  if (!lowerBound.has_value() && !upperBound.has_value()) {
+    return false;
+  }
+
+  const auto validateBound = [this](const RowVectorPtr& bound) {
+    if (bound->size() != 1) {
+      return false;
+    }
+
+    const auto& rowType = asRowType(bound->type());
+    if (rowType->size() != indexColumns.size()) {
+      return false;
+    }
+    for (const auto& columnName : indexColumns) {
+      if (!rowType->containsChild(columnName)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  if (lowerBound.has_value() && !validateBound(lowerBound->bound)) {
+    return false;
+  }
+
+  if (upperBound.has_value() && !validateBound(upperBound->bound)) {
+    return false;
+  }
+
+  if (lowerBound.has_value() && upperBound.has_value() &&
+      !lowerBound->bound->type()->equivalent(*upperBound->bound->type())) {
+    return false;
+  }
+
+  return true;
+}
+
+TypePtr IndexBounds::type() const {
+  const RowVectorPtr& boundVector =
+      lowerBound.has_value() ? lowerBound->bound : upperBound->bound;
+  return boundVector->type();
+}
+
+std::string IndexBounds::toString() const {
+  std::stringstream ss;
+  ss << "IndexBounds{indexColumns=[";
+  for (size_t i = 0; i < indexColumns.size(); ++i) {
+    if (i > 0) {
+      ss << ", ";
+    }
+    ss << indexColumns[i];
+  }
+  ss << "]";
+
+  const auto formatBound = [&ss](const char* name, const IndexBound& bound) {
+    ss << ", " << name << "=" << (bound.inclusive ? "[" : "(");
+    ss << bound.bound->toString(0, bound.bound->size());
+    ss << (bound.inclusive ? "]" : ")");
+  };
+
+  if (lowerBound.has_value()) {
+    formatBound("lowerBound", lowerBound.value());
+  }
+
+  if (upperBound.has_value()) {
+    formatBound("upperBound", upperBound.value());
+  }
+
+  ss << "}";
+  return ss.str();
+}
+
+namespace {
+// Validates if a type is a valid index column type.
+// Only primitive scalar types are supported except UNKNOWN and HUGEINT.
+bool isValidIndexColumnType(const TypePtr& type) {
+  return type->isPrimitiveType() && type->kind() != TypeKind::UNKNOWN &&
+      type->kind() != TypeKind::HUGEINT;
+}
+
+static constexpr int64_t DOUBLE_EXP_BIT_MASK = 0x7FF0000000000000L;
+static constexpr int64_t DOUBLE_SIGNIF_BIT_MASK = 0x000FFFFFFFFFFFFFL;
+
+static constexpr int32_t FLOAT_EXP_BIT_MASK = 0x7F800000;
+static constexpr int32_t FLOAT_SIGNIF_BIT_MASK = 0x007FFFFF;
+
+static constexpr size_t kNullByteSize = 1;
+
+// Converts a double to its int64_t bit representation, normalizing all NaN
+// values to a canonical quiet NaN (0x7ff8000000000000L). This ensures
+// consistent key encoding since different NaN bit patterns should compare
+// equal.
+FOLLY_ALWAYS_INLINE int64_t doubleToLong(double value) {
+  const int64_t* result = reinterpret_cast<const int64_t*>(&value);
+
+  if (((*result & DOUBLE_EXP_BIT_MASK) == DOUBLE_EXP_BIT_MASK) &&
+      (*result & DOUBLE_SIGNIF_BIT_MASK) != 0L) {
+    return 0x7ff8000000000000L;
+  }
+  return *result;
+}
+
+// Converts a float to its int32_t bit representation, normalizing all NaN
+// values to a canonical quiet NaN (0x7fc00000). This ensures consistent key
+// encoding since different NaN bit patterns should compare equal.
+FOLLY_ALWAYS_INLINE int32_t floatToInt(float value) {
+  const int32_t* result = reinterpret_cast<const int32_t*>(&value);
+
+  if (((*result & FLOAT_EXP_BIT_MASK) == FLOAT_EXP_BIT_MASK) &&
+      (*result & FLOAT_SIGNIF_BIT_MASK) != 0L) {
+    return 0x7fc00000;
+  }
+  return *result;
+}
+
+FOLLY_ALWAYS_INLINE void encodeByte(int8_t value, bool descending, char*& out) {
+  if (descending) {
+    *out = 0xff ^ value;
+  } else {
+    *out = value;
+  }
+  ++out;
+}
+
+// Template for encoding integers (signed and unsigned).
+// For signed types: flips the sign bit for lexicographic ordering.
+// Converts to big-endian and applies descending transformation if needed.
+template <typename T>
+FOLLY_ALWAYS_INLINE void encodeInt(T value, bool descending, char*& out) {
+  using UnsignedT = std::make_unsigned_t<T>;
+
+  // Flip sign bit for signed types for lexicographic ordering
+  if constexpr (std::is_signed_v<T>) {
+    constexpr int kSignBitShift = sizeof(T) * 8 - 1;
+    value ^= 1ULL << kSignBitShift;
+  }
+
+  // Convert to big-endian
+  value = folly::Endian::big(value);
+
+  // Apply descending transformation if needed (branchless)
+  // If descending is true, XOR with all 1s; if false, XOR with 0
+  const UnsignedT mask = -static_cast<UnsignedT>(descending);
+  value ^= mask;
+
+  std::memcpy(out, &value, sizeof(value));
+  out += sizeof(value);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeString(const char* data, size_t size, bool descending, char*& out) {
+  size_t offset = 0;
+  constexpr size_t kBatchSize = xsimd::batch<uint8_t>::size;
+
+  // Precompute XOR mask for descending transformation
+  const uint8_t xorMask = descending ? 0xFF : 0x00;
+
+  // Process in SIMD batches to find bytes needing escaping
+  if (size >= kBatchSize) {
+    const auto zero = xsimd::batch<uint8_t>::broadcast(0);
+    const auto one = xsimd::batch<uint8_t>::broadcast(1);
+    const auto xorBatch = xsimd::batch<uint8_t>::broadcast(xorMask);
+
+    while (offset + kBatchSize <= size) {
+      auto batch = xsimd::batch<uint8_t>::load_unaligned(
+          reinterpret_cast<const uint8_t*>(data + offset));
+
+      // Check which bytes need escaping (are 0 or 1)
+      const auto needsEscape = (batch == zero) | (batch == one);
+      const auto escapeMask = simd::toBitMask(needsEscape);
+
+      if (escapeMask == 0) {
+        // Fast path: no bytes need escaping, bulk copy the entire batch
+        // Apply descending transformation branchlessly (no-op if xorBatch is
+        // all zeros)
+        batch = batch ^ xorBatch;
+        batch.store_unaligned(reinterpret_cast<uint8_t*>(out));
+        out += kBatchSize;
+        offset += kBatchSize;
+      } else {
+        // Some bytes need escaping, process byte-by-byte for this batch
+        for (size_t i = 0; i < kBatchSize; ++i) {
+          const uint8_t byte = data[offset + i];
+          if (byte == 0 || byte == 1) {
+            encodeByte(1, descending, out);
+            encodeByte(byte, descending, out);
+          } else {
+            encodeByte(byte, descending, out);
+          }
+        }
+        offset += kBatchSize;
+      }
+    }
+  }
+
+  // Process remaining bytes
+  for (; offset < size; ++offset) {
+    const uint8_t byte = data[offset];
+    if (byte == 0 || byte == 1) {
+      encodeByte(1, descending, out);
+      encodeByte(byte, descending, out);
+    } else {
+      encodeByte(byte, descending, out);
+    }
+  }
+
+  // Write terminator
+  encodeByte(0, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE size_t stringEncodedSize(const char* data, size_t size) {
+  size_t countZeros{0};
+  size_t countOnes{0};
+  size_t offset{0};
+
+  // Process bytes in SIMD batches
+  constexpr size_t kBatchSize = xsimd::batch<uint8_t>::size;
+  if (size >= kBatchSize) {
+    const auto zero = xsimd::batch<uint8_t>::broadcast(0);
+    const auto one = xsimd::batch<uint8_t>::broadcast(1);
+
+    for (; offset + kBatchSize <= size; offset += kBatchSize) {
+      auto batch = xsimd::batch<uint8_t>::load_unaligned(
+          reinterpret_cast<const uint8_t*>(data + offset));
+
+      // Count bytes that equal 0
+      const auto isZero = (batch == zero);
+      const auto zeroMask = simd::toBitMask(isZero);
+      countZeros += __builtin_popcount(zeroMask);
+
+      // Count bytes that equal 1
+      const auto isOne = (batch == one);
+      const auto oneMask = simd::toBitMask(isOne);
+      countOnes += __builtin_popcount(oneMask);
+    }
+  }
+
+  // Process remaining bytes using standard algorithms
+  const auto* remaining = reinterpret_cast<const uint8_t*>(data + offset);
+  const auto remainingSize = size - offset;
+
+  countZeros += std::count(remaining, remaining + remainingSize, 0);
+  countOnes += std::count(remaining, remaining + remainingSize, 1);
+
+  // Each 0 or 1 byte needs 2 bytes (escape byte + actual byte)
+  // Other bytes need 1 byte
+  // Plus 1 terminator byte
+  return size + countZeros + countOnes + 1;
+}
+
+FOLLY_ALWAYS_INLINE void encodeBool(bool value, char*& out) {
+  encodeByte(value, /*descending=*/false, out);
+}
+
+// Forward declarations for functions used in estimateEncodedColumnSize
+void addDateEncodedSize(
+    const folly::Range<const vector_size_t*>& nonNullRows,
+    vector_size_t** nonNullSizePtrs);
+
+template <TypeKind KIND>
+void addColumnEncodedSizeTyped(
+    const DecodedVector& decodedSource,
+    const folly::Range<const vector_size_t*>& nonNullRows,
+    vector_size_t** nonNullSizePtrs);
+
+void estimateEncodedColumnSize(
+    const DecodedVector& decodedSource,
+    const folly::Range<const vector_size_t*>& rows,
+    std::vector<vector_size_t>& sizes,
+    Scratch& scratch) {
+  const auto numRows = rows.size();
+  folly::Range<const vector_size_t*> nonNullRows = rows;
+  vector_size_t** nonNullSizePtrs = nullptr;
+
+  ScratchPtr<uint64_t, 64> nullsHolder(scratch);
+  ScratchPtr<vector_size_t, 64> nonNullsHolder(scratch);
+  ScratchPtr<vector_size_t*, 64> nonNullSizePtrsHolder(scratch);
+
+  if (decodedSource.mayHaveNulls()) {
+    auto* nulls = nullsHolder.get(bits::nwords(numRows));
+    for (auto row = 0; row < numRows; ++row) {
+      bits::clearNull(nulls, row);
+      if (decodedSource.isNullAt(rows[row])) {
+        bits::setNull(nulls, row);
+        sizes[row] += kNullByteSize;
+      }
+    }
+
+    auto* nonNulls = nonNullsHolder.get(numRows);
+    const auto numNonNull = simd::indicesOfSetBits(nulls, 0, numRows, nonNulls);
+    if (numNonNull == 0) {
+      return;
+    }
+
+    auto* const nonNullSizes = sizes.data();
+    nonNullSizePtrs = nonNullSizePtrsHolder.get(numNonNull);
+    for (int32_t i = 0; i < numNonNull; ++i) {
+      nonNullSizePtrs[i] = &nonNullSizes[nonNulls[i]];
+    }
+
+    simd::transpose(
+        rows.data(),
+        folly::Range<const vector_size_t*>(nonNulls, numNonNull),
+        nonNulls);
+    nonNullRows = folly::Range<const vector_size_t*>(nonNulls, numNonNull);
+  } else {
+    // No nulls, all rows are non-null - create size pointers for all rows
+    nonNullSizePtrs = nonNullSizePtrsHolder.get(numRows);
+    for (int32_t i = 0; i < numRows; ++i) {
+      nonNullSizePtrs[i] = &sizes[i];
+    }
+  }
+
+  // Process data for non-null rows only (or all rows if no nulls)
+  if (decodedSource.base()->type()->isDate()) {
+    for (auto i = 0; i < nonNullRows.size(); ++i) {
+      *nonNullSizePtrs[i] += (kNullByteSize + sizeof(int32_t));
+    }
+  } else {
+    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        addColumnEncodedSizeTyped,
+        decodedSource.base()->typeKind(),
+        decodedSource,
+        nonNullRows,
+        nonNullSizePtrs);
+  }
+}
+
+template <TypeKind KIND>
+void addColumnEncodedSizeTyped(
+    const DecodedVector& decodedSource,
+    const folly::Range<const vector_size_t*>& nonNullRows,
+    vector_size_t** nonNullSizePtrs) {
+  // Handle variable-width types
+  if constexpr (KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY) {
+    for (auto i = 0; i < nonNullRows.size(); ++i) {
+      const auto view = decodedSource.valueAt<StringView>(nonNullRows[i]);
+      *nonNullSizePtrs[i] +=
+          kNullByteSize + stringEncodedSize(view.data(), view.size());
+    }
+  } else {
+    // Fixed-width scalar types
+    const auto elementSize = decodedSource.base()->type()->cppSizeInBytes();
+    for (auto i = 0; i < nonNullRows.size(); ++i) {
+      *nonNullSizePtrs[i] += (kNullByteSize + elementSize);
+    }
+  }
+}
+
+std::vector<vector_size_t> getKeyChannels(
+    const RowTypePtr& inputType,
+    const std::vector<std::string>& keyColumns) {
+  std::vector<vector_size_t> keyChannels;
+  keyChannels.reserve(keyColumns.size());
+  for (const auto& keyColumn : keyColumns) {
+    keyChannels.emplace_back(inputType->getChildIdx(keyColumn));
+  }
+  return keyChannels;
+}
+
+// Wrapper functions for backward compatibility and readability
+FOLLY_ALWAYS_INLINE void
+encodeLong(int64_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeUnsignedLong(uint64_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeShort(int16_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeInteger(int32_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+FOLLY_ALWAYS_INLINE void
+encodeUnsignedInteger(uint32_t value, bool descending, char*& out) {
+  encodeInt(value, descending, out);
+}
+
+void encodeBigInt(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int64_t>(row);
+        encodeLong(value, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int64_t>(row);
+      encodeLong(value, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeBoolean(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<bool>(row);
+        encodeByte(
+            static_cast<int8_t>(value ? 2 : 1), descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<bool>(row);
+      encodeByte(
+          static_cast<int8_t>(value ? 2 : 1), descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeDouble(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<double>(row);
+        int64_t longValue = doubleToLong(value);
+        // Normalize -0.0 to +0.0 by clearing sign bit when value is zero
+        if ((longValue & ~(1L << 63)) == 0) {
+          longValue = 0;
+        }
+        if ((longValue & (1L << 63)) != 0) {
+          longValue = ~longValue;
+        } else {
+          longValue = longValue ^ (1L << 63);
+        }
+        encodeUnsignedLong(longValue, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<double>(row);
+      int64_t longValue = doubleToLong(value);
+      // Normalize -0.0 to +0.0 by clearing sign bit when value is zero
+      if ((longValue & ~(1L << 63)) == 0) {
+        longValue = 0;
+      }
+      if ((longValue & (1L << 63)) != 0) {
+        longValue = ~longValue;
+      } else {
+        longValue = longValue ^ (1L << 63);
+      }
+      encodeUnsignedLong(longValue, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeReal(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<float>(row);
+        int32_t intValue = floatToInt(value);
+        // Normalize -0.0 to +0.0 by clearing sign bit when value is zero
+        if ((intValue & ~(1 << 31)) == 0) {
+          intValue = 0;
+        }
+        if ((intValue & (1L << 31)) != 0) {
+          intValue = ~intValue;
+        } else {
+          intValue = intValue ^ (1L << 31);
+        }
+        encodeUnsignedInteger(intValue, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<float>(row);
+      int32_t intValue = floatToInt(value);
+      // Normalize -0.0 to +0.0 by clearing sign bit when value is zero
+      if ((intValue & ~(1 << 31)) == 0) {
+        intValue = 0;
+      }
+      if ((intValue & (1L << 31)) != 0) {
+        intValue = ~intValue;
+      } else {
+        intValue = intValue ^ (1L << 31);
+      }
+      encodeUnsignedInteger(intValue, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeTinyInt(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int8_t>(row);
+        encodeByte(
+            static_cast<int8_t>(value ^ 0x80), descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int8_t>(row);
+      encodeByte(
+          static_cast<int8_t>(value ^ 0x80), descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeSmallInt(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int16_t>(row);
+        encodeShort(value, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int16_t>(row);
+      encodeShort(value, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeIntegerType(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int32_t>(row);
+        encodeInteger(value, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int32_t>(row);
+      encodeInteger(value, descending, rowOffsets[row]);
+    }
+  }
+}
+
+void encodeStringType(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<StringView>(row);
+        encodeString(value.data(), value.size(), descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<StringView>(row);
+      encodeString(value.data(), value.size(), descending, rowOffsets[row]);
+    }
+  }
+}
+
+// Encodes Timestamp type column for all rows in columnar fashion.
+// When comparing Timestamp, first compare seconds and then compare nanos, so
+// when encoding, just encode seconds and nanos in sequence (similar to
+// PrefixSortEncoder).
+void encodeTimestamp(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<Timestamp>(row);
+        // Encode seconds (int64_t) followed by nanos (uint64_t)
+        encodeLong(value.getSeconds(), descending, rowOffsets[row]);
+        encodeUnsignedLong(value.getNanos(), descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<Timestamp>(row);
+      // Encode seconds (int64_t) followed by nanos (uint64_t)
+      encodeLong(value.getSeconds(), descending, rowOffsets[row]);
+      encodeUnsignedLong(value.getNanos(), descending, rowOffsets[row]);
+    }
+  }
+}
+
+// Encodes Date type column for all rows in columnar fashion.
+void encodeDate(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const bool mayHaveNulls = decodedVector.mayHaveNulls();
+  if (mayHaveNulls) {
+    for (auto row = 0; row < numRows; ++row) {
+      if (decodedVector.isNullAt(row)) {
+        // Encode null indicator only
+        encodeBool(nullLast, rowOffsets[row]);
+      } else {
+        // Encode non-null indicator followed by data
+        encodeBool(!nullLast, rowOffsets[row]);
+        const auto value = decodedVector.valueAt<int32_t>(row);
+        encodeInteger(value, descending, rowOffsets[row]);
+      }
+    }
+  } else {
+    for (auto row = 0; row < numRows; ++row) {
+      // Encode non-null indicator followed by data
+      encodeBool(!nullLast, rowOffsets[row]);
+      const auto value = decodedVector.valueAt<int32_t>(row);
+      encodeInteger(value, descending, rowOffsets[row]);
+    }
+  }
+}
+
+// Template function to encode column data for a specific type kind
+template <TypeKind Kind>
+void encodeColumnTyped(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  if constexpr (Kind == TypeKind::BIGINT) {
+    encodeBigInt(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::BOOLEAN) {
+    encodeBoolean(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::DOUBLE) {
+    encodeDouble(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::REAL) {
+    encodeReal(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::TINYINT) {
+    encodeTinyInt(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::SMALLINT) {
+    encodeSmallInt(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::INTEGER) {
+    encodeIntegerType(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (Kind == TypeKind::TIMESTAMP) {
+    encodeTimestamp(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else if constexpr (
+      Kind == TypeKind::VARCHAR || Kind == TypeKind::VARBINARY) {
+    encodeStringType(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else {
+    VELOX_UNSUPPORTED("Unsupported type: {}", Kind);
+  }
+}
+
+bool incrementStringValue(std::string* value, bool descending) {
+  if (!descending) {
+    // Ascending order: append the smallest possible byte (null byte) to get the
+    // immediate next string. For any string s, s < s + '\0' < s + '\x01' < ...
+    value->push_back('\0');
+    return true;
+  } else {
+    // Descending order: decrement is only possible if the string ends with
+    // '\0'. This is the inverse of the increment operation - truncate the
+    // trailing null byte. This approach aligns with Apache Kudu's
+    // DecrementStringCell.
+    //
+    // For strings not ending with '\0', there is no finite immediate
+    // predecessor (e.g., predecessor of "abc" would be "ab\xFF\xFF\xFF..." with
+    // infinite 0xFF bytes). Return false to signal caller should use exclusive
+    // bounds.
+    if (value->empty() || value->back() != '\0') {
+      return false;
+    }
+    value->pop_back();
+    return true;
+  }
+}
+
+template <TypeKind KIND>
+bool setMinValueTyped(VectorPtr& result, vector_size_t row) {
+  using T = typename TypeTraits<KIND>::NativeType;
+
+  if constexpr (KIND == TypeKind::BOOLEAN) {
+    auto* flatVector = result->asChecked<FlatVector<bool>>();
+    flatVector->set(row, false);
+    return true;
+  }
+
+  if constexpr (
+      KIND == TypeKind::TINYINT || KIND == TypeKind::SMALLINT ||
+      KIND == TypeKind::INTEGER || KIND == TypeKind::BIGINT) {
+    auto* flatVector = result->asChecked<FlatVector<T>>();
+    flatVector->set(row, std::numeric_limits<T>::min());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::REAL || KIND == TypeKind::DOUBLE) {
+    auto* flatVector = result->asChecked<FlatVector<T>>();
+    flatVector->set(row, -std::numeric_limits<T>::infinity());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY) {
+    auto* flatVector = result->asChecked<FlatVector<StringView>>();
+    flatVector->set(row, StringView(""));
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::TIMESTAMP) {
+    auto* flatVector = result->asChecked<FlatVector<Timestamp>>();
+    flatVector->set(row, std::numeric_limits<Timestamp>::min());
+    return true;
+  }
+
+  VELOX_UNSUPPORTED("Cannot set min value for column type: {}", KIND);
+}
+
+template <TypeKind KIND>
+bool setMaxValueTyped(VectorPtr& result, vector_size_t row) {
+  using T = typename TypeTraits<KIND>::NativeType;
+
+  if constexpr (KIND == TypeKind::BOOLEAN) {
+    auto* flatVector = result->asChecked<FlatVector<bool>>();
+    flatVector->set(row, true);
+    return true;
+  }
+
+  if constexpr (
+      KIND == TypeKind::TINYINT || KIND == TypeKind::SMALLINT ||
+      KIND == TypeKind::INTEGER || KIND == TypeKind::BIGINT) {
+    auto* flatVector = result->asChecked<FlatVector<T>>();
+    flatVector->set(row, std::numeric_limits<T>::max());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::REAL || KIND == TypeKind::DOUBLE) {
+    auto* flatVector = result->asChecked<FlatVector<T>>();
+    flatVector->set(row, std::numeric_limits<T>::infinity());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::TIMESTAMP) {
+    auto* flatVector = result->asChecked<FlatVector<Timestamp>>();
+    flatVector->set(row, std::numeric_limits<Timestamp>::max());
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY) {
+    // For max string value, we can't represent it directly, but we can use
+    // a very large string. However, this is problematic. For now, return false.
+    return false;
+  }
+
+  VELOX_UNSUPPORTED("Cannot set max value for column type: {}", KIND);
+}
+
+template <TypeKind KIND>
+bool incrementColumnValueTyped(
+    const VectorPtr& column,
+    vector_size_t row,
+    VectorPtr& result,
+    bool descending) {
+  using T = typename TypeTraits<KIND>::NativeType;
+
+  if constexpr (KIND == TypeKind::BOOLEAN) {
+    const auto* inputVector = column->asChecked<FlatVector<bool>>();
+    auto* resultVector = result->asChecked<FlatVector<bool>>();
+    const auto value = inputVector->valueAt(row);
+    if (!descending) {
+      // Ascending: false -> true, true cannot increment
+      if (value) {
+        // Overflow: wrap around to min value (false) for proper bound encoding.
+        resultVector->set(row, false);
+        return false;
+      }
+      resultVector->set(row, true);
+    } else {
+      // Descending: true -> false, false cannot decrement
+      if (!value) {
+        // Underflow: wrap around to max value (true) for proper bound encoding.
+        resultVector->set(row, true);
+        return false;
+      }
+      resultVector->set(row, false);
+    }
+    return true;
+  }
+
+  if constexpr (
+      KIND == TypeKind::TINYINT || KIND == TypeKind::SMALLINT ||
+      KIND == TypeKind::INTEGER || KIND == TypeKind::BIGINT) {
+    const auto* inputVector = column->asChecked<FlatVector<T>>();
+    auto* resultVector = result->asChecked<FlatVector<T>>();
+    const auto value = inputVector->valueAt(row);
+    if (!descending) {
+      // Ascending: increment
+      if (value == std::numeric_limits<T>::max()) {
+        // Overflow: wrap around to min value for proper bound encoding.
+        resultVector->set(row, std::numeric_limits<T>::min());
+        return false;
+      }
+      resultVector->set(row, value + 1);
+    } else {
+      // Descending: decrement
+      if (value == std::numeric_limits<T>::min()) {
+        // Underflow: wrap around to max value for proper bound encoding.
+        resultVector->set(row, std::numeric_limits<T>::max());
+        return false;
+      }
+      resultVector->set(row, value - 1);
+    }
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::REAL || KIND == TypeKind::DOUBLE) {
+    const auto* inputVector = column->asChecked<FlatVector<T>>();
+    auto* resultVector = result->asChecked<FlatVector<T>>();
+    const auto value = inputVector->valueAt(row);
+    if (!descending) {
+      // Ascending: increment to next representable value
+      if (std::isinf(value) && value > 0) {
+        // Overflow: wrap around to min value (-inf) for proper bound encoding.
+        resultVector->set(row, -std::numeric_limits<T>::infinity());
+        return false;
+      }
+      resultVector->set(
+          row, std::nextafter(value, std::numeric_limits<T>::infinity()));
+    } else {
+      // Descending: decrement to previous representable value
+      if (std::isinf(value) && value < 0) {
+        // Underflow: wrap around to max value (+inf) for proper bound encoding.
+        resultVector->set(row, std::numeric_limits<T>::infinity());
+        return false;
+      }
+      resultVector->set(
+          row, std::nextafter(value, -std::numeric_limits<T>::infinity()));
+    }
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY) {
+    // For strings, increment/decrement the string representation.
+    const auto* inputVector = column->asChecked<FlatVector<StringView>>();
+    auto* resultVector = result->asChecked<FlatVector<StringView>>();
+    const auto value = inputVector->valueAt(row);
+    std::string incrementedStr(value.data(), value.size());
+    if (!incrementStringValue(&incrementedStr, descending)) {
+      if (!descending) {
+        // Ascending overflow: set to min value (empty string)
+        resultVector->set(row, StringView(""));
+      }
+      // For descending underflow: cannot represent max string value,
+      // leave value unchanged as there's no finite predecessor.
+      return false;
+    }
+    resultVector->set(row, StringView(incrementedStr));
+    return true;
+  }
+
+  if constexpr (KIND == TypeKind::TIMESTAMP) {
+    const auto* inputVector = column->asChecked<FlatVector<Timestamp>>();
+    auto* resultVector = result->asChecked<FlatVector<Timestamp>>();
+    const auto value = inputVector->valueAt(row);
+    if (!descending) {
+      // Ascending: increment nanos first, then seconds if nanos overflow
+      const auto nanos = value.getNanos();
+      VELOX_DCHECK_LE(nanos, Timestamp::kMaxNanos);
+      const auto seconds = value.getSeconds();
+      VELOX_DCHECK_LE(seconds, Timestamp::kMaxSeconds);
+      if (nanos < Timestamp::kMaxNanos) {
+        resultVector->set(row, Timestamp(seconds, nanos + 1));
+      } else if (seconds < Timestamp::kMaxSeconds) {
+        resultVector->set(row, Timestamp(seconds + 1, 0));
+      } else {
+        // Overflow: wrap around to min timestamp for proper bound encoding.
+        resultVector->set(row, Timestamp(Timestamp::kMinSeconds, 0));
+        return false;
+      }
+    } else {
+      // Descending: decrement nanos first, then seconds if nanos underflow
+      const auto nanos = value.getNanos();
+      const auto seconds = value.getSeconds();
+      if (nanos > 0) {
+        resultVector->set(row, Timestamp(seconds, nanos - 1));
+      } else if (seconds > Timestamp::kMinSeconds) {
+        resultVector->set(row, Timestamp(seconds - 1, Timestamp::kMaxNanos));
+      } else {
+        // Underflow: wrap around to max timestamp for proper bound encoding.
+        resultVector->set(
+            row, Timestamp(Timestamp::kMaxSeconds, Timestamp::kMaxNanos));
+        return false;
+      }
+    }
+    return true;
+  }
+
+  VELOX_UNSUPPORTED("Cannot increment column type: {}", KIND);
+}
+
+// Handles incrementing or decrementing null column values based on sort order.
+// Returns true if operation succeeds, false otherwise.
+bool incrementNullColumnValue(
+    const VectorPtr& column,
+    vector_size_t row,
+    bool descending,
+    bool nullLast,
+    VectorPtr& result) {
+  if (!nullLast) {
+    if (descending) {
+      // Nulls first: null is at the beginning
+      result->setNull(row, false);
+      const auto ret = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          setMaxValueTyped, column->typeKind(), result, row);
+      if (!ret) {
+        result->setNull(row, true);
+      }
+      return ret;
+    } else {
+      result->setNull(row, false);
+      const auto ret = VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          setMinValueTyped, column->typeKind(), result, row);
+      if (!ret) {
+        result->setNull(row, true);
+      }
+      return ret;
+    }
+  } else {
+    // Nulls last: null is at the end, can't increment
+    return false;
+  }
+}
+
+// Increments or decrements a column value at the given row index based on sort
+// order. Returns true if increment/decrement succeeds, false if value
+// overflows/underflows.
+bool incrementColumnValue(
+    const VectorPtr& column,
+    vector_size_t row,
+    bool descending,
+    bool nullLast,
+    VectorPtr& result) {
+  if (column->isNullAt(row)) {
+    return incrementNullColumnValue(column, row, descending, nullLast, result);
+  }
+
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      incrementColumnValueTyped,
+      column->typeKind(),
+      column,
+      row,
+      result,
+      descending);
+}
+} // namespace
+
+// static.
+std::unique_ptr<KeyEncoder> KeyEncoder::create(
+    std::vector<std::string> keyColumns,
+    RowTypePtr inputType,
+    std::vector<core::SortOrder> sortOrders,
+    memory::MemoryPool* pool) {
+  return std::unique_ptr<KeyEncoder>(
+      new KeyEncoder(keyColumns, inputType, sortOrders, pool));
+}
+
+KeyEncoder::KeyEncoder(
+    std::vector<std::string> keyColumns,
+    RowTypePtr inputType,
+    std::vector<core::SortOrder> sortOrders,
+    memory::MemoryPool* pool)
+    : inputType_{std::move(inputType)},
+      sortOrders_{std::move(sortOrders)},
+      keyChannels_{getKeyChannels(inputType_, keyColumns)},
+      pool_{pool},
+      childDecodedVectors_{keyColumns.size()} {
+  VELOX_CHECK(!childDecodedVectors_.empty());
+  VELOX_CHECK_EQ(
+      keyChannels_.size(),
+      sortOrders_.size(),
+      "Size mismatch between key columns and sort orders");
+
+  // Validate that all index columns are valid types
+  for (size_t i = 0; i < keyChannels_.size(); ++i) {
+    const auto& columnType = inputType_->childAt(keyChannels_[i]);
+    VELOX_CHECK(
+        isValidIndexColumnType(columnType),
+        "Unsupported type for index column '{}': {}",
+        keyColumns[i],
+        columnType->toString());
+  }
+}
+
+void KeyEncoder::encodeColumn(
+    const DecodedVector& decodedVector,
+    vector_size_t numRows,
+    bool descending,
+    bool nullLast,
+    std::vector<char*>& rowOffsets) {
+  const auto typeKind = decodedVector.base()->typeKind();
+  if (decodedVector.base()->type()->isDate()) {
+    encodeDate(decodedVector, numRows, descending, nullLast, rowOffsets);
+  } else {
+    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        encodeColumnTyped,
+        typeKind,
+        decodedVector,
+        numRows,
+        descending,
+        nullLast,
+        rowOffsets);
+  }
+}
+
+std::optional<RowVectorPtr> KeyEncoder::createIncrementedBound(
+    const RowVectorPtr& bound) const {
+  const auto& children = bound->children();
+  VELOX_CHECK_EQ(bound->size(), 1);
+  const auto numKeyColumns = keyChannels_.size();
+  VELOX_CHECK_EQ(children.size(), keyChannels_.size());
+
+  std::vector<VectorPtr> newChildren;
+  newChildren.reserve(numKeyColumns);
+  for (const auto& child : children) {
+    newChildren.push_back(BaseVector::create(child->type(), 1, pool_));
+  }
+
+  // Copy all values from the source row
+  for (size_t i = 0; i < numKeyColumns; ++i) {
+    newChildren[i]->copy(children[i].get(), 0, 0, 1);
+  }
+
+  // Increment from rightmost key column (least significant) to leftmost and
+  // quit once we find a column that can be incremented.
+  for (int i = numKeyColumns - 1; i >= 0; --i) {
+    const bool descending = !sortOrders_[i].isAscending();
+    const bool nullLast = !sortOrders_[i].isNullsFirst();
+    if (incrementColumnValue(
+            children[i], 0, descending, nullLast, newChildren[i])) {
+      return std::make_shared<RowVector>(
+          pool_, bound->type(), nullptr, 1, std::move(newChildren));
+    }
+  }
+
+  // All key columns overflowed - cannot increment
+  return std::nullopt;
+}
+
+uint64_t KeyEncoder::estimateEncodedSize() {
+  const auto numRows = decodedVector_.size();
+  encodedSizes_.resize(numRows, 0);
+
+  // Process each key channel in columnar order.
+  for (auto i = 0; i < keyChannels_.size(); ++i) {
+    ScratchPtr<vector_size_t, 128> decodedRowsHolder(scratch_);
+    auto* decodedRows = decodedRowsHolder.get(numRows);
+    for (auto row = 0; row < numRows; ++row) {
+      decodedRows[row] = decodedVector_.index(row);
+    }
+
+    estimateEncodedColumnSize(
+        childDecodedVectors_[i],
+        folly::Range<const vector_size_t*>(decodedRows, numRows),
+        encodedSizes_,
+        scratch_);
+  }
+  return std::accumulate(encodedSizes_.begin(), encodedSizes_.end(), 0);
+}
+
+std::vector<std::string> KeyEncoder::encode(const RowVectorPtr& input) {
+  std::vector<char> buffer;
+  std::vector<std::string_view> encodedKeys;
+  // Call the templated encode method with a buffer allocator lambda
+  encode(input, encodedKeys, [&buffer](size_t size) -> void* {
+    buffer.resize(size);
+    return buffer.data();
+  });
+
+  // Copy encoded keys to result.
+  std::vector<std::string> result;
+  result.reserve(encodedKeys.size());
+  for (const auto& key : encodedKeys) {
+    result.emplace_back(key.data(), key.size());
+  }
+  return result;
+}
+
+std::optional<EncodedKeyBounds> KeyEncoder::encodeIndexBounds(
+    const IndexBounds& indexBounds) {
+  VELOX_CHECK(indexBounds.validate());
+
+  EncodedKeyBounds result;
+
+  // Encode lower bound if present
+  if (indexBounds.lowerBound.has_value()) {
+    const auto& lowerBound = indexBounds.lowerBound.value();
+    RowVectorPtr lowerBoundToEncode = lowerBound.bound;
+    // For exclusive lower bound, increment the row before encoding
+    if (!lowerBound.inclusive) {
+      const auto incrementedBoundOpt =
+          createIncrementedBound(lowerBoundToEncode);
+      if (!incrementedBoundOpt.has_value()) {
+        return std::nullopt;
+      }
+      lowerBoundToEncode = incrementedBoundOpt.value();
+    }
+    auto encodedKeys = encode(lowerBoundToEncode);
+    VELOX_CHECK_EQ(encodedKeys.size(), 1);
+    result.lowerKey = std::move(encodedKeys[0]);
+  }
+
+  // Encode upper bound if present
+  if (indexBounds.upperBound.has_value()) {
+    const auto& upperBound = indexBounds.upperBound.value();
+    RowVectorPtr upperBoundToEncode = upperBound.bound;
+
+    // For inclusive upper bound, increment the row before encoding
+    if (upperBound.inclusive) {
+      const auto incrementedBoundOpt = createIncrementedBound(upperBound.bound);
+      // If increment fails (bound is at maximum value), treat as unbounded by
+      // setting to nullptr. This prevents setting an upper bound when the
+      // inclusive upper bound is already at the maximum possible value.
+      if (!incrementedBoundOpt.has_value()) {
+        upperBoundToEncode = nullptr;
+      } else {
+        upperBoundToEncode = incrementedBoundOpt.value();
+      }
+    }
+    if (upperBoundToEncode != nullptr) {
+      auto encodedKeys = encode(upperBoundToEncode);
+      result.upperKey = std::move(encodedKeys[0]);
+    }
+  }
+
+  return result;
+}
+
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/KeyEncoder.h b/velox/serializers/KeyEncoder.h
new file mode 100644
index 000000000000..fb6f6de1d59f
--- /dev/null
+++ b/velox/serializers/KeyEncoder.h
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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 "velox/common/base/Exceptions.h"
+#include "velox/common/memory/Scratch.h"
+#include "velox/core/PlanNode.h"
+#include "velox/type/Type.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+
+namespace facebook::velox::serializer {
+
+/// A single index bound (lower or upper) with a single row and inclusive flag.
+/// Used to represent either a lower or upper bound for index filtering.
+struct IndexBound {
+  /// Single row containing the bound values. Must have exactly 1 row.
+  RowVectorPtr bound;
+  /// Whether this bound is inclusive. If true, the bound value is included
+  /// in the range; if false, it's excluded.
+  bool inclusive{true};
+};
+
+/// Represents bounds for index-based filtering with optional lower and upper
+/// bounds. Used to define a range of values for index columns that can be
+/// encoded into byte-comparable keys for efficient filtering.
+struct IndexBounds {
+  /// The top-level column names that form the index. These columns must exist
+  /// in the input data and define the order of columns in the encoded key.
+  std::vector<std::string> indexColumns;
+  /// Optional lower bound for the index range.
+  std::optional<IndexBound> lowerBound;
+  /// Optional upper bound for the index range.
+  std::optional<IndexBound> upperBound;
+
+  /// Validates that the bounds are well-formed:
+  /// - At least one bound (lower or upper) must be present
+  /// - Each bound must have exactly 1 row
+  /// Returns true if valid, false otherwise.
+  bool validate() const;
+
+  /// Returns the type from the bound vectors.
+  /// Extracts the type from lowerBound if available, otherwise from upperBound.
+  /// At least one bound must be present.
+  TypePtr type() const;
+
+  /// Returns a human-readable string representation of the bounds.
+  std::string toString() const;
+};
+
+/// Encoded representation of index bounds as byte-comparable strings.
+/// These keys can be compared lexicographically to perform range filtering.
+struct EncodedKeyBounds {
+  /// Encoded lower bound key. If present, represents the minimum key value
+  /// (inclusive or exclusive based on IndexBound.inclusive).
+  std::optional<std::string> lowerKey;
+  /// Encoded upper bound key. If present, represents the maximum key value
+  /// (inclusive or exclusive based on IndexBound.inclusive).
+  std::optional<std::string> upperKey;
+};
+
+/// KeyEncoder encodes multi-column keys into byte-comparable strings that
+/// preserve the sort order defined by the column types and sort orders.
+/// This enables efficient range-based filtering and comparison of composite
+/// keys.
+///
+/// The encoding is designed such that:
+/// - Lexicographic comparison of encoded keys matches the logical comparison
+///   of the original values
+/// - Null values are sorted according to the specified sort order (nulls
+///   first/last)
+/// - Ascending/descending sort orders are respected
+/// - Only scalar types are supported (e.g., integers, floats, strings,
+///   booleans, dates). Complex types (arrays, maps, rows) are not supported.
+///
+/// Example usage:
+///   auto keyEncoder = KeyEncoder::create(
+///       {"col1", "col2"}, rowType, sortOrders, pool);
+///   std::vector<std::string_view> encodedKeys;
+///   HashStringAllocator allocator(pool);
+///   keyEncoder->encode(inputVector, encodedKeys,
+///       [&allocator](size_t size) { return allocator.allocate(size); });
+class KeyEncoder {
+ public:
+  /// Factory method to create a KeyEncoder instance.
+  ///
+  /// @param keyColumns Names of columns to include in the encoded key, in order
+  /// @param inputType Row type of the input data containing these columns
+  /// @param sortOrders Sort order for each key column (ascending/descending,
+  ///                   nulls first/last)
+  /// @param pool Memory pool for allocations
+  /// @return Unique pointer to a new KeyEncoder instance
+  static std::unique_ptr<KeyEncoder> create(
+      std::vector<std::string> keyColumns,
+      RowTypePtr inputType,
+      std::vector<core::SortOrder> sortOrders,
+      memory::MemoryPool* pool);
+
+  /// Type alias for buffer allocator function.
+  /// Takes estimated size in bytes and returns a pointer to the allocated
+  /// buffer.
+  using BufferAllocator = std::function<void*(size_t)>;
+
+  /// Encodes the key columns from the input vector into byte-comparable keys.
+  ///
+  /// Each row in the input produces one encoded key string. The keys can be
+  /// compared lexicographically, and the comparison result will match the
+  /// logical comparison based on the specified sort orders.
+  ///
+  /// @tparam Container A container type for std::string_view that supports
+  ///                   reserve(), size(), and emplace_back() operations.
+  /// @param input Input vector containing rows to encode
+  /// @param encodedKeys Output container to store the encoded key strings
+  ///                    (views into allocated buffer)
+  /// @param bufferAllocator Allocator function that takes estimated size and
+  ///                        returns pointer to allocated buffer
+  template <typename Container>
+  void encode(
+      const VectorPtr& input,
+      Container& encodedKeys,
+      const BufferAllocator& bufferAllocator);
+
+  /// Encodes index bounds into byte-comparable boundary keys.
+  ///
+  /// The implementation normalizes all bounds to half-open interval format
+  /// [lower_bound, upper_bound) to ease range scan processing:
+  /// - Lower bounds: Always converted to inclusive
+  ///   - Exclusive lower bound (x > 5) → incremented to inclusive (x >= 6)
+  ///   - Inclusive lower bound (x >= 5) → stays as is
+  /// - Upper bounds: Always converted to exclusive
+  ///   - Inclusive upper bound (x <= 10) → incremented to exclusive (x < 11)
+  ///   - Exclusive upper bound (x < 10) → stays as is
+  ///
+  /// Increment failure handling (asymmetric behavior):
+  /// - Lower bound increment fails → returns std::nullopt (cannot establish
+  ///   valid range start)
+  /// - Upper bound increment fails → upperKey set to std::nullopt (treated as
+  ///   unbounded upper range)
+  ///
+  /// Increment fails when values are at their maximum (e.g., INT_MAX, strings
+  /// with all \xFF characters, or nulls in NULLS_LAST ordering).
+  ///
+  /// @param indexBounds Index bounds containing lower/upper bounds with
+  ///                    inclusive flags
+  /// @return std::nullopt if lower bound increment fails; otherwise
+  ///         EncodedKeyBounds with encoded keys in [lower, upper) format
+  std::optional<EncodedKeyBounds> encodeIndexBounds(
+      const IndexBounds& indexBounds);
+
+ private:
+  KeyEncoder(
+      std::vector<std::string> keyColumns,
+      RowTypePtr inputType,
+      std::vector<core::SortOrder> sortOrders,
+      memory::MemoryPool* pool);
+
+  uint64_t estimateEncodedSize();
+
+  // Encodes a RowVector and returns encoded keys as strings.
+  // Each row in the input vector produces one encoded key string.
+  std::vector<std::string> encode(const RowVectorPtr& input);
+
+  // Creates a new row vector with the key columns incremented by 1.
+  // Similar to Apache Kudu's IncrementKey, this increments from the
+  // rightmost (least significant) column. Returns std::nullopt if all columns
+  // overflow (key is at maximum value).
+  std::optional<RowVectorPtr> createIncrementedBound(
+      const RowVectorPtr& bound) const;
+
+  // Encodes a single column for all rows.
+  void encodeColumn(
+      const DecodedVector& decodedVector,
+      vector_size_t numRows,
+      bool descending,
+      bool nullLast,
+      std::vector<char*>& rowOffsets);
+
+  const RowTypePtr inputType_;
+  const std::vector<core::SortOrder> sortOrders_;
+  const std::vector<vector_size_t> keyChannels_;
+  const RowTypePtr keyType_;
+  memory::MemoryPool* const pool_;
+
+  // Reusable buffers.
+  DecodedVector decodedVector_;
+  std::vector<DecodedVector> childDecodedVectors_;
+  std::vector<vector_size_t> encodedSizes_;
+  Scratch scratch_;
+};
+
+// Template implementation
+template <typename Container>
+void KeyEncoder::encode(
+    const VectorPtr& input,
+    Container& encodedKeys,
+    const BufferAllocator& bufferAllocator) {
+  VELOX_CHECK_GT(input->size(), 0);
+  SCOPE_EXIT {
+    encodedSizes_.clear();
+  };
+  decodedVector_.decode(*input, /*loadLazy=*/true);
+  const auto* rowBase = decodedVector_.base()->asChecked<RowVector>();
+  const auto& children = rowBase->children();
+  for (auto i = 0; i < keyChannels_.size(); ++i) {
+    childDecodedVectors_[i].decode(*children[keyChannels_[i]]);
+  }
+  const auto totalBytes = estimateEncodedSize();
+  auto* const allocated = static_cast<char*>(bufferAllocator(totalBytes));
+
+  const auto numRows = input->size();
+  const auto numKeys = keyChannels_.size();
+
+  // Compute buffer start offsets for each row
+  std::vector<char*> rowOffsets(numRows);
+  rowOffsets[0] = allocated;
+  for (auto row = 1; row < numRows; ++row) {
+    rowOffsets[row] = rowOffsets[row - 1] + encodedSizes_[row - 1];
+  }
+
+  // Encode column-by-column for better cache locality
+  for (auto i = 0; i < numKeys; ++i) {
+    const bool nullLast = !sortOrders_[i].isNullsFirst();
+    const bool descending = !sortOrders_[i].isAscending();
+    const auto& decodedVector = childDecodedVectors_[i];
+
+    // Encode column data for all rows (null indicator is encoded within each
+    // type's encoding function)
+    encodeColumn(decodedVector, numRows, descending, nullLast, rowOffsets);
+  }
+
+  // Build encoded keys string views
+  encodedKeys.reserve(encodedKeys.size() + numRows);
+  size_t offset{0};
+  for (auto row = 0; row < numRows; ++row) {
+    encodedKeys.emplace_back(allocated + offset, encodedSizes_[row]);
+    offset += encodedSizes_[row];
+    VELOX_CHECK_EQ(rowOffsets[row], allocated + offset);
+  }
+}
+
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/PrestoHeader.cpp b/velox/serializers/PrestoHeader.cpp
index 5e2b36b38c1d..bfa44989eb75 100644
--- a/velox/serializers/PrestoHeader.cpp
+++ b/velox/serializers/PrestoHeader.cpp
@@ -21,8 +21,9 @@ namespace facebook::velox::serializer::presto::detail {
 /* static */ Expected<PrestoHeader> PrestoHeader::read(
     ByteInputStream* source) {
   if (source->remainingSize() < kHeaderSize) {
-    return folly::makeUnexpected(Status::Invalid(
-        fmt::format("{} bytes for header", source->remainingSize())));
+    return folly::makeUnexpected(
+        Status::Invalid(
+            fmt::format("{} bytes for header", source->remainingSize())));
   }
   PrestoHeader header;
   header.numRows = source->read<int32_t>();
@@ -36,12 +37,15 @@ namespace facebook::velox::serializer::presto::detail {
         Status::Invalid(fmt::format("negative numRows: {}", header.numRows)));
   }
   if (header.uncompressedSize < 0) {
-    return folly::makeUnexpected(Status::Invalid(
-        fmt::format("negative uncompressedSize: {}", header.uncompressedSize)));
+    return folly::makeUnexpected(
+        Status::Invalid(
+            fmt::format(
+                "negative uncompressedSize: {}", header.uncompressedSize)));
   }
   if (header.compressedSize < 0) {
-    return folly::makeUnexpected(Status::Invalid(
-        fmt::format("negative compressedSize: {}", header.compressedSize)));
+    return folly::makeUnexpected(
+        Status::Invalid(
+            fmt::format("negative compressedSize: {}", header.compressedSize)));
   }
 
   return header;
diff --git a/velox/serializers/PrestoSerializer.cpp b/velox/serializers/PrestoSerializer.cpp
index 2217c2eed226..dad701728f2f 100644
--- a/velox/serializers/PrestoSerializer.cpp
+++ b/velox/serializers/PrestoSerializer.cpp
@@ -88,6 +88,10 @@ PrestoVectorSerde::PrestoOptions toPrestoOptions(
       dynamic_cast<const PrestoVectorSerde::PrestoOptions*>(options);
   VELOX_CHECK_NOT_NULL(
       prestoOptions, "Serde options are not Presto-compatible");
+  VELOX_CHECK(
+      !(prestoOptions->useLosslessTimestamp &&
+        prestoOptions->useMicrosecondPrecision),
+      "useLosslessTimestamp and useMicrosecondPrecision are mutually exclusive");
   return *prestoOptions;
 }
 } // namespace
diff --git a/velox/serializers/PrestoSerializer.h b/velox/serializers/PrestoSerializer.h
index a079e232b8a5..6ea12dcd2884 100644
--- a/velox/serializers/PrestoSerializer.h
+++ b/velox/serializers/PrestoSerializer.h
@@ -69,6 +69,12 @@ class PrestoVectorSerde : public VectorSerde {
     /// currently used for spilling. Is false by default.
     bool useLosslessTimestamp{false};
 
+    /// When true, interprets serialized timestamp values as microseconds
+    /// instead of milliseconds. Used when the source data contains timestamps
+    /// in microsecond precision (e.g., TIMESTAMP_MICROSECONDS Presto type).
+    /// Mutually exclusive with useLosslessTimestamp.
+    bool useMicrosecondPrecision{false};
+
     /// Serializes nulls of structs before the columns. Used to allow
     /// single pass reading of in spilling.
     ///
diff --git a/velox/serializers/PrestoSerializerDeserializationUtils.cpp b/velox/serializers/PrestoSerializerDeserializationUtils.cpp
index 30c0ae17a8ac..e5af09d37120 100644
--- a/velox/serializers/PrestoSerializerDeserializationUtils.cpp
+++ b/velox/serializers/PrestoSerializerDeserializationUtils.cpp
@@ -596,6 +596,38 @@ void readLosslessTimestampValues(
   }
 }
 
+Timestamp readMicrosecondTimestamp(ByteInputStream* source) {
+  int64_t micros = source->read<int64_t>();
+  return Timestamp::fromMicros(micros);
+}
+
+void readMicrosecondTimestampValues(
+    ByteInputStream* source,
+    vector_size_t size,
+    vector_size_t offset,
+    const BufferPtr& nulls,
+    vector_size_t nullCount,
+    const BufferPtr& values) {
+  auto rawValues = values->asMutable<Timestamp>();
+  checkValuesSize<Timestamp>(values, nulls, size, offset);
+  if (nullCount > 0) {
+    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] = readMicrosecondTimestamp(source);
+          toClear = row + 1;
+        });
+  } else {
+    for (int32_t row = offset; row < offset + size; ++row) {
+      rawValues[row] = readMicrosecondTimestamp(source);
+    }
+  }
+}
+
 template <typename T>
 void readValues(
     ByteInputStream* source,
@@ -706,7 +738,7 @@ void read(
   auto nullCount = readNulls(
       source, size, resultOffset, incomingNulls, numIncomingNulls, *flatResult);
 
-  BufferPtr values = flatResult->mutableValues(resultOffset + numNewValues);
+  BufferPtr values = flatResult->mutableValues();
   if constexpr (std::is_same_v<T, Timestamp>) {
     if (opts.useLosslessTimestamp) {
       readLosslessTimestampValues(
@@ -718,6 +750,16 @@ void read(
           values);
       return;
     }
+    if (opts.useMicrosecondPrecision) {
+      readMicrosecondTimestampValues(
+          source,
+          numNewValues,
+          resultOffset,
+          flatResult->nulls(),
+          nullCount,
+          values);
+      return;
+    }
   }
   if constexpr (std::is_same_v<T, int128_t>) {
     if (type->isLongDecimal()) {
@@ -780,7 +822,7 @@ void read<StringView>(
   result->resize(resultOffset + numNewValues);
 
   auto flatResult = result->as<FlatVector<StringView>>();
-  BufferPtr values = flatResult->mutableValues(resultOffset + size);
+  BufferPtr values = flatResult->mutableValues();
   auto rawValues = values->asMutable<StringView>();
   int32_t lastOffset = 0;
   for (int32_t i = 0; i < numNewValues; ++i) {
@@ -837,7 +879,7 @@ void read<OpaqueType>(
   auto deserialization = opaqueType->getDeserializeFunc();
 
   auto flatResult = result->as<FlatVector<std::shared_ptr<void>>>();
-  BufferPtr values = flatResult->mutableValues(resultOffset + size);
+  BufferPtr values = flatResult->mutableValues();
 
   auto rawValues = values->asMutable<std::shared_ptr<void>>();
   std::vector<int32_t> offsets;
@@ -866,7 +908,7 @@ void read<OpaqueType>(
   for (int32_t i = 0; i < numNewValues; ++i) {
     int32_t offset = offsets[i];
     auto sv = StringView(rawString + previousOffset, offset - previousOffset);
-    auto opaqueValue = deserialization(sv);
+    auto opaqueValue = deserialization(std::string(sv));
     rawValues[resultOffset + i] = opaqueValue;
     previousOffset = offset;
   }
diff --git a/velox/serializers/PrestoSerializerSerializationUtils.cpp b/velox/serializers/PrestoSerializerSerializationUtils.cpp
index f4321c5c8e41..a36832e8fc61 100644
--- a/velox/serializers/PrestoSerializerSerializationUtils.cpp
+++ b/velox/serializers/PrestoSerializerSerializationUtils.cpp
@@ -139,6 +139,7 @@ void serializeWrappedRanges(
     VectorStream* stream,
     Scratch& scratch) {
   std::vector<IndexRange> newRanges;
+  newRanges.reserve(rangesTotalSize(ranges));
   const bool mayHaveNulls = vector->mayHaveNulls();
   const VectorPtr& wrapped = BaseVector::wrappedVectorShared(vector);
   for (int32_t i = 0; i < ranges.size(); ++i) {
@@ -529,8 +530,9 @@ void serializeIPPrefix(
       // the ipaddress porition as big endian whereas Velox stores it as little
       auto javaIPPrefix =
           toJavaIPPrefixType(ip->valueAt(rows[i]), prefix->valueAt(rows[i]));
-      stream->values().appendStringView(std::string_view(
-          (const char*)javaIPPrefix.data(), javaIPPrefix.size()));
+      stream->values().appendStringView(
+          std::string_view(
+              (const char*)javaIPPrefix.data(), javaIPPrefix.size()));
     }
     return;
   }
diff --git a/velox/serializers/PrestoSerializerSerializationUtils.h b/velox/serializers/PrestoSerializerSerializationUtils.h
index ea184107392a..eb40fac56d46 100644
--- a/velox/serializers/PrestoSerializerSerializationUtils.h
+++ b/velox/serializers/PrestoSerializerSerializationUtils.h
@@ -60,8 +60,8 @@ void initBitsToMapOnce();
 FOLLY_ALWAYS_INLINE std::array<int8_t, ipaddress::kIPPrefixBytes>
 toJavaIPPrefixType(int128_t currentIpBytes, int8_t prefix) {
   std::array<int8_t, ipaddress::kIPPrefixBytes> byteArray{{0}};
-  memcpy(&byteArray, &currentIpBytes, sizeof(currentIpBytes));
-  memcpy((byteArray.begin() + sizeof(currentIpBytes)), &prefix, sizeof(prefix));
+  memcpy(&byteArray[0], &currentIpBytes, sizeof(currentIpBytes));
+  memcpy(&byteArray[sizeof(currentIpBytes)], &prefix, sizeof(prefix));
   if constexpr (folly::kIsLittleEndian) {
     std::reverse(byteArray.begin(), byteArray.begin() + sizeof(currentIpBytes));
     return byteArray;
diff --git a/velox/serializers/PrestoVectorLexer.cpp b/velox/serializers/PrestoVectorLexer.cpp
index 89bf2e4d2d48..a57dfb6ac39b 100644
--- a/velox/serializers/PrestoVectorLexer.cpp
+++ b/velox/serializers/PrestoVectorLexer.cpp
@@ -248,7 +248,7 @@ PrestoVectorLexer::lexBytes(int32_t numBytes, TokenType tokenType, char* dst) {
 }
 
 void PrestoVectorLexer::commit(TokenType tokenType) {
-  const auto newPtr = source_.begin();
+  const auto* newPtr = source_.data();
   assert(committedPtr_ <= newPtr);
   assert(
       int64_t(newPtr - committedPtr_) <=
diff --git a/velox/serializers/PrestoVectorLexer.h b/velox/serializers/PrestoVectorLexer.h
index f00a4ebc8573..c39b74d50174 100644
--- a/velox/serializers/PrestoVectorLexer.h
+++ b/velox/serializers/PrestoVectorLexer.h
@@ -50,7 +50,7 @@ namespace detail {
 class PrestoVectorLexer {
  public:
   explicit PrestoVectorLexer(std::string_view source)
-      : source_(source), committedPtr_(source.begin()) {}
+      : source_{source}, committedPtr_{source.data()} {}
 
   Status lex(std::vector<Token>& out) &&;
 
diff --git a/velox/serializers/RowSerializer.cpp b/velox/serializers/RowSerializer.cpp
index dc434ad56237..79b112b46217 100644
--- a/velox/serializers/RowSerializer.cpp
+++ b/velox/serializers/RowSerializer.cpp
@@ -85,7 +85,7 @@ bool RowIteratorImpl::hasNext() const {
   return source_->tellp() < endOffset_;
 }
 
-std::unique_ptr<std::string> RowIteratorImpl::next() {
+std::unique_ptr<std::string> RowIteratorImpl::nextRow() {
   const auto rowSize = readRowSize();
   auto serializedBuffer = std::make_unique<std::string>();
   serializedBuffer->reserve(rowSize);
diff --git a/velox/serializers/RowSerializer.h b/velox/serializers/RowSerializer.h
index 4ab11847cfb8..5ad5a9e7ea97 100644
--- a/velox/serializers/RowSerializer.h
+++ b/velox/serializers/RowSerializer.h
@@ -265,7 +265,7 @@ class RowSerializer : public IterativeVectorSerializer {
 /// Usage:
 /// RowIteratorImpl iterator(source, endOffset);
 /// while (iterator.hasNext()) {
-///   auto next = iterator.next();
+///   auto next = iterator.nextRow();
 ///   ...Process the data in next...
 /// }
 class RowIteratorImpl : public velox::RowIterator {
@@ -281,7 +281,11 @@ class RowIteratorImpl : public velox::RowIterator {
 
   bool hasNext() const override;
 
-  std::unique_ptr<std::string> next() override;
+  std::unique_ptr<std::string> nextRow() override;
+
+  std::vector<std::string_view> nextBatch(size_t maxRows) override {
+    VELOX_UNSUPPORTED("nextBatch is not supported");
+  }
 
  private:
   TRowSize readRowSize();
@@ -301,9 +305,7 @@ class RowIteratorImpl : public velox::RowIterator {
 
 using RowIteratorFactory = std::function<std::unique_ptr<RowIterator>(
     ByteInputStream*,
-    std::unique_ptr<BufferInputStream>,
-    std::unique_ptr<folly::IOBuf>,
-    size_t)>;
+    const VectorSerde::Options*)>;
 
 template <typename SerializeView>
 class RowDeserializer {
@@ -312,17 +314,18 @@ class RowDeserializer {
       ByteInputStream* source,
       std::vector<SerializeView>& serializedRows,
       std::vector<std::unique_ptr<std::string>>& serializedBuffers,
-      RowIteratorFactory rowIteratorFactory,
+      const RowIteratorFactory& rowIteratorFactory,
       const VectorSerde::Options* options) {
     while (!source->atEnd()) {
       std::unique_ptr<velox::RowIterator> rowIterator =
-          createNextRowIter(source, options, rowIteratorFactory);
+          rowIteratorFactory(source, options);
       while (rowIterator->hasNext()) {
-        serializedBuffers.emplace_back(rowIterator->next());
+        serializedBuffers.emplace_back(rowIterator->nextRow());
         if constexpr (std::is_same_v<SerializeView, std::string_view>) {
-          serializedRows.push_back(std::string_view(
-              serializedBuffers.back()->data(),
-              serializedBuffers.back()->size()));
+          serializedRows.push_back(
+              std::string_view(
+                  serializedBuffers.back()->data(),
+                  serializedBuffers.back()->size()));
         } else {
           serializedRows.push_back(serializedBuffers.back()->data());
         }
@@ -344,21 +347,21 @@ class RowDeserializer {
       std::unique_ptr<velox::RowIterator>& sourceRowIterator,
       std::vector<SerializeView>& serializedRows,
       std::vector<std::unique_ptr<std::string>>& serializedBuffers,
-      RowIteratorFactory rowIteratorFactory,
+      const RowIteratorFactory& rowIteratorFactory,
       const VectorSerde::Options* options) {
     auto remainingRows = maxRows;
     if (sourceRowIterator == nullptr) {
       VELOX_CHECK(!source->atEnd());
-      sourceRowIterator =
-          createNextRowIter(source, options, rowIteratorFactory);
+      sourceRowIterator = rowIteratorFactory(source, options);
     }
     while (remainingRows > 0) {
       while (sourceRowIterator->hasNext()) {
-        serializedBuffers.emplace_back(sourceRowIterator->next());
+        serializedBuffers.emplace_back(sourceRowIterator->nextRow());
         if constexpr (std::is_same_v<SerializeView, std::string_view>) {
-          serializedRows.push_back(std::string_view(
-              serializedBuffers.back()->data(),
-              serializedBuffers.back()->size()));
+          serializedRows.push_back(
+              std::string_view(
+                  serializedBuffers.back()->data(),
+                  serializedBuffers.back()->size()));
         } else {
           serializedRows.push_back(serializedBuffers.back()->data());
         }
@@ -372,46 +375,10 @@ class RowDeserializer {
           sourceRowIterator.reset();
           break;
         }
-        sourceRowIterator =
-            createNextRowIter(source, options, rowIteratorFactory);
+        sourceRowIterator = rowIteratorFactory(source, options);
       }
     }
     return maxRows - remainingRows;
   }
-
- private:
-  static std::unique_ptr<velox::RowIterator> createNextRowIter(
-      ByteInputStream* source,
-      const VectorSerde::Options* options,
-      RowIteratorFactory& rowIteratorFactory) {
-    const auto header = detail::RowGroupHeader::read(source);
-    if (!header.compressed) {
-      return rowIteratorFactory(
-          source, nullptr, nullptr, header.uncompressedSize + source->tellp());
-    }
-
-    const auto compressionKind = options == nullptr
-        ? VectorSerde::Options().compressionKind
-        : options->compressionKind;
-    VELOX_DCHECK_NE(
-        compressionKind, common::CompressionKind::CompressionKind_NONE);
-    auto compressBuf = folly::IOBuf::create(header.compressedSize);
-    source->readBytes(compressBuf->writableData(), header.compressedSize);
-    compressBuf->append(header.compressedSize);
-
-    // Process chained uncompressed results IOBufs.
-    const auto codec = common::compressionKindToCodec(compressionKind);
-    auto uncompressedBuf =
-        codec->uncompress(compressBuf.get(), header.uncompressedSize);
-
-    auto uncompressedStream = std::make_unique<BufferInputStream>(
-        byteRangesFromIOBuf(uncompressedBuf.get()));
-    const std::streampos initialSize = uncompressedStream->tellp();
-    return rowIteratorFactory(
-        nullptr,
-        std::move(uncompressedStream),
-        std::move(uncompressedBuf),
-        header.uncompressedSize + initialSize);
-  }
 };
 } // namespace facebook::velox::serializer
diff --git a/velox/serializers/SerializedPageFile.cpp b/velox/serializers/SerializedPageFile.cpp
new file mode 100644
index 000000000000..7c4f998fb659
--- /dev/null
+++ b/velox/serializers/SerializedPageFile.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/serializers/SerializedPageFile.h"
+#include <cstdint>
+#include <memory>
+#include "velox/common/file/FileSystems.h"
+
+namespace facebook::velox::serializer {
+std::unique_ptr<SerializedPageFile> SerializedPageFile::create(
+    uint32_t id,
+    const std::string& pathPrefix,
+    const std::string& fileCreateConfig) {
+  return std::unique_ptr<SerializedPageFile>(
+      new SerializedPageFile(id, pathPrefix, fileCreateConfig));
+}
+
+SerializedPageFile::SerializedPageFile(
+    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 SerializedPageFile::finish() {
+  VELOX_CHECK_NOT_NULL(file_);
+  size_ = file_->size();
+  file_->close();
+  file_ = nullptr;
+}
+
+uint64_t SerializedPageFile::size() {
+  if (file_ != nullptr) {
+    return file_->size();
+  }
+  return size_;
+}
+
+uint64_t SerializedPageFile::write(std::unique_ptr<folly::IOBuf> iobuf) {
+  auto writtenBytes = iobuf->computeChainDataLength();
+  file_->append(std::move(iobuf));
+  return writtenBytes;
+}
+
+SerializedPageFileWriter::SerializedPageFileWriter(
+    const std::string& pathPrefix,
+    uint64_t targetFileSize,
+    uint64_t writeBufferSize,
+    const std::string& fileCreateConfig,
+    std::unique_ptr<VectorSerde::Options> serdeOptions,
+    VectorSerde* serde,
+    memory::MemoryPool* pool)
+    : pathPrefix_(pathPrefix),
+      targetFileSize_(targetFileSize),
+      writeBufferSize_(writeBufferSize),
+      fileCreateConfig_(fileCreateConfig),
+      serdeOptions_(std::move(serdeOptions)),
+      pool_(pool),
+      serde_(serde) {}
+
+SerializedPageFile* SerializedPageFileWriter::ensureFile() {
+  if ((currentFile_ != nullptr) && (currentFile_->size() > targetFileSize_)) {
+    closeFile();
+  }
+  if (currentFile_ == nullptr) {
+    currentFile_ = SerializedPageFile::create(
+        nextFileId_++,
+        fmt::format("{}-{}", pathPrefix_, finishedFiles_.size()),
+        fileCreateConfig_);
+  }
+  return currentFile_.get();
+}
+
+void SerializedPageFileWriter::closeFile() {
+  if (currentFile_ == nullptr) {
+    return;
+  }
+  currentFile_->finish();
+  const auto& fileInfo = currentFile_->fileInfo();
+  updateFileStats(fileInfo);
+  finishedFiles_.push_back(fileInfo);
+  currentFile_.reset();
+}
+
+size_t SerializedPageFileWriter::numFinishedFiles() const {
+  return finishedFiles_.size();
+}
+
+uint64_t SerializedPageFileWriter::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);
+  return writtenBytes;
+}
+
+uint64_t SerializedPageFileWriter::write(
+    const RowVectorPtr& rows,
+    const folly::Range<IndexRange*>& indices) {
+  if (rows == nullptr || rows->size() == 0 || indices.size() == 0) {
+    return 0;
+  }
+
+  checkNotFinished();
+
+  uint64_t timeNs{0};
+  {
+    NanosecondTimer timer(&timeNs);
+    if (batch_ == nullptr) {
+      batch_ = std::make_unique<VectorStreamGroup>(pool_, serde_);
+      batch_->createStreamTree(
+          std::static_pointer_cast<const RowType>(rows->type()),
+          1'000,
+          serdeOptions_.get());
+    }
+    batch_->append(rows, indices);
+  }
+  updateAppendStats(rows->size(), timeNs);
+  if (batch_->size() < writeBufferSize_) {
+    return 0;
+  }
+  return flush();
+}
+
+void SerializedPageFileWriter::finishFile() {
+  checkNotFinished();
+  flush();
+  closeFile();
+  VELOX_CHECK_NULL(currentFile_);
+}
+
+std::vector<SerializedPageFile::FileInfo> SerializedPageFileWriter::finish() {
+  checkNotFinished();
+  auto finishGuard = folly::makeGuard([this]() { finished_ = true; });
+
+  finishFile();
+  return std::move(finishedFiles_);
+}
+
+SerializedPageFileReader::SerializedPageFileReader(
+    const std::string& path,
+    uint64_t bufferSize,
+    const RowTypePtr& type,
+    VectorSerde* serde,
+    std::unique_ptr<VectorSerde::Options> readOptions,
+    memory::MemoryPool* pool)
+    : readOptions_(std::move(readOptions)),
+      pool_(pool),
+      serde_(serde),
+      type_(type) {
+  auto fs = filesystems::getFileSystem(path, nullptr);
+  auto file = fs->openFileForRead(path);
+  input_ = std::make_unique<common::FileInputStream>(
+      std::move(file), bufferSize, pool_);
+}
+
+bool SerializedPageFileReader::nextBatch(RowVectorPtr& rowVector) {
+  if (input_->atEnd()) {
+    updateFinalStats();
+    return false;
+  }
+
+  uint64_t timeNs{0};
+  {
+    NanosecondTimer timer{&timeNs};
+    VectorStreamGroup::read(
+        input_.get(), pool_, type_, serde_, &rowVector, readOptions_.get());
+  }
+  updateSerializationTimeStats(timeNs);
+  return true;
+}
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/SerializedPageFile.h b/velox/serializers/SerializedPageFile.h
new file mode 100644
index 000000000000..da2bc1ae7e9a
--- /dev/null
+++ b/velox/serializers/SerializedPageFile.h
@@ -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.
+ */
+
+#pragma once
+
+#include <folly/io/IOBuf.h>
+#include <cstdint>
+#include <memory>
+#include "velox/common/file/File.h"
+#include "velox/common/file/FileInputStream.h"
+#include "velox/serializers/VectorStream.h"
+
+namespace facebook::velox::serializer {
+
+/// Represents a file for writing the serialized pages into a disk file.
+class SerializedPageFile {
+ public:
+  /// FileInfo struct containing the essential file information.
+  struct FileInfo {
+    uint32_t id;
+    std::string path;
+    uint64_t size;
+  };
+
+  static std::unique_ptr<SerializedPageFile> create(
+      uint32_t id,
+      const std::string& pathPrefix,
+      const std::string& fileCreateConfig);
+
+  uint32_t id() const {
+    return id_;
+  }
+
+  uint64_t size();
+
+  std::string path() const {
+    return path_;
+  }
+
+  FileInfo fileInfo() const {
+    return {id_, path_, (file_ != nullptr ? file_->size() : size_)};
+  }
+
+  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};
+
+  SerializedPageFile(
+      uint32_t id,
+      const std::string& pathPrefix,
+      const std::string& fileCreateConfig);
+
+  const uint32_t id_;
+
+  const std::string path_;
+
+  uint64_t size_{0};
+
+  std::unique_ptr<WriteFile> file_;
+};
+
+/// Used to write 'RowVector' as serialized page data to a sequence of files.
+class SerializedPageFileWriter {
+ public:
+  /// 'compressionKind' specifies the compression to use. 'pathPrefix' 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. 'fileCreateConfig' specifies the file layout on
+  /// remote storage which is storage system specific. 'serdeOptions' specifies
+  /// the serialization options to use. 'serde' specifies the VectorSerde
+  /// instance to use. 'pool' is used for buffering.
+  SerializedPageFileWriter(
+      const std::string& pathPrefix,
+      uint64_t targetFileSize,
+      uint64_t writeBufferSize,
+      const std::string& fileCreateConfig,
+      std::unique_ptr<VectorSerde::Options> serdeOptions,
+      VectorSerde* serde,
+      memory::MemoryPool* pool);
+
+  virtual ~SerializedPageFileWriter() = default;
+
+  /// Adds 'rows' for the positions in 'indices' into 'this'.
+  /// 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 file info.
+  /// NOTE: we don't allow write to a file writer after finish.
+  std::vector<SerializedPageFile::FileInfo> finish();
+
+ protected:
+  // Invoked upon each vector append.
+  virtual void updateAppendStats(
+      uint64_t /* numRows */,
+      uint64_t /* serializationTimeNs */) {}
+
+  // Invoked upon each serialized page write to disk.
+  virtual void updateWriteStats(
+      uint64_t /* writtenBytes */,
+      uint64_t /* flushTimeNs */,
+      uint64_t /* fileWriteTimeNs */) {}
+
+  // Invoked upon each file close.
+  virtual void updateFileStats(const SerializedPageFile::FileInfo& /* file */) {
+  }
+
+  // Closes the current open file pointed by 'currentFile_'.
+  virtual void closeFile();
+
+  // Writes data from 'batch_' to the current output file. Returns the actual
+  // written size.
+  virtual uint64_t flush();
+
+  FOLLY_ALWAYS_INLINE void checkNotFinished() const {
+    VELOX_CHECK(!finished_, "SerializedPageFileWriter has finished");
+  }
+
+  // Returns an open file for write. If there is no open file, then
+  // the function creates a new one. If the current open 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 file.
+  SerializedPageFile* ensureFile();
+
+  const std::string pathPrefix_;
+  const uint64_t targetFileSize_;
+  const uint64_t writeBufferSize_;
+  const std::string fileCreateConfig_;
+
+  const std::unique_ptr<VectorSerde::Options> serdeOptions_;
+  memory::MemoryPool* const pool_;
+  VectorSerde* const serde_;
+
+  bool finished_{false};
+  uint32_t nextFileId_{0};
+  std::unique_ptr<VectorStreamGroup> batch_;
+  std::unique_ptr<SerializedPageFile> currentFile_;
+  std::vector<SerializedPageFile::FileInfo> finishedFiles_;
+};
+
+/// Used to read the serialized page data from a single file generated by
+/// 'SerializedPageFileWriter'.
+class SerializedPageFileReader {
+ public:
+  SerializedPageFileReader(
+      const std::string& path,
+      uint64_t bufferSize,
+      const RowTypePtr& type,
+      VectorSerde* serde,
+      std::unique_ptr<VectorSerde::Options> readOptions,
+      memory::MemoryPool* pool);
+
+  virtual ~SerializedPageFileReader() = default;
+
+  bool nextBatch(RowVectorPtr& rowVector);
+
+ protected:
+  virtual void updateFinalStats() {}
+
+  virtual void updateSerializationTimeStats(uint64_t /* timeNs */) {}
+
+  const std::unique_ptr<VectorSerde::Options> readOptions_;
+
+  memory::MemoryPool* const pool_;
+
+  VectorSerde* const serde_;
+
+  const RowTypePtr type_;
+
+  std::unique_ptr<common::FileInputStream> input_;
+};
+
+} // namespace facebook::velox::serializer
diff --git a/velox/serializers/UnsafeRowSerializer.cpp b/velox/serializers/UnsafeRowSerializer.cpp
index 36f952e8f1ba..49afa5d5460c 100644
--- a/velox/serializers/UnsafeRowSerializer.cpp
+++ b/velox/serializers/UnsafeRowSerializer.cpp
@@ -19,6 +19,39 @@
 #include "velox/serializers/RowSerializer.h"
 
 namespace facebook::velox::serializer::spark {
+namespace {
+std::unique_ptr<RowIterator> unsafeRowIteratorFactory(
+    ByteInputStream* source,
+    const VectorSerde::Options* options) {
+  const auto header = detail::RowGroupHeader::read(source);
+  if (!header.compressed) {
+    return std::make_unique<RowIteratorImpl>(
+        source, header.uncompressedSize + source->tellp());
+  }
+
+  const auto compressionKind = options == nullptr
+      ? VectorSerde::Options().compressionKind
+      : options->compressionKind;
+  VELOX_DCHECK_NE(
+      compressionKind, common::CompressionKind::CompressionKind_NONE);
+  auto compressBuf = folly::IOBuf::create(header.compressedSize);
+  source->readBytes(compressBuf->writableData(), header.compressedSize);
+  compressBuf->append(header.compressedSize);
+
+  // Process chained uncompressed results IOBufs.
+  const auto codec = common::compressionKindToCodec(compressionKind);
+  auto uncompressedBuf =
+      codec->uncompress(compressBuf.get(), header.uncompressedSize);
+
+  auto uncompressedStream = std::make_unique<BufferInputStream>(
+      byteRangesFromIOBuf(uncompressedBuf.get()));
+  const std::streampos initialSize = uncompressedStream->tellp();
+  return std::make_unique<RowIteratorImpl>(
+      std::move(uncompressedStream),
+      std::move(uncompressedBuf),
+      header.uncompressedSize + initialSize);
+}
+} // namespace
 
 void UnsafeRowVectorSerde::estimateSerializedSize(
     const row::UnsafeRowFast* unsafeRow,
@@ -49,23 +82,35 @@ void UnsafeRowVectorSerde::deserialize(
       source,
       serializedRows,
       serializedBuffers,
-      [](auto* source,
-         auto uncompressedStream,
-         auto uncompressedBuf,
-         auto endOffset) {
-        if (source != nullptr) {
-          VELOX_CHECK_NULL(uncompressedStream);
-          VELOX_CHECK_NULL(uncompressedBuf);
-          return std::make_unique<RowIteratorImpl>(source, endOffset);
-        } else {
-          VELOX_CHECK_NOT_NULL(uncompressedStream);
-          VELOX_CHECK_NOT_NULL(uncompressedBuf);
-          return std::make_unique<RowIteratorImpl>(
-              std::move(uncompressedStream),
-              std::move(uncompressedBuf),
-              endOffset);
-        }
-      },
+      unsafeRowIteratorFactory,
+      options);
+
+  if (serializedRows.empty()) {
+    *result = BaseVector::create<RowVector>(type, 0, pool);
+    return;
+  }
+
+  *result = std::dynamic_pointer_cast<RowVector>(
+      row::UnsafeRowFast::deserialize(serializedRows, type, pool));
+}
+
+void UnsafeRowVectorSerde::deserialize(
+    ByteInputStream* source,
+    std::unique_ptr<RowIterator>& sourceRowIterator,
+    uint64_t maxRows,
+    RowTypePtr type,
+    RowVectorPtr* result,
+    velox::memory::MemoryPool* pool,
+    const Options* options) {
+  std::vector<char*> serializedRows;
+  std::vector<std::unique_ptr<std::string>> serializedBuffers;
+  RowDeserializer<char*>::deserialize(
+      source,
+      maxRows,
+      sourceRowIterator,
+      serializedRows,
+      serializedBuffers,
+      unsafeRowIteratorFactory,
       options);
 
   if (serializedRows.empty()) {
diff --git a/velox/serializers/UnsafeRowSerializer.h b/velox/serializers/UnsafeRowSerializer.h
index e859d8f2cc0f..2e7e95acd77b 100644
--- a/velox/serializers/UnsafeRowSerializer.h
+++ b/velox/serializers/UnsafeRowSerializer.h
@@ -44,6 +44,15 @@ class UnsafeRowVectorSerde : public VectorSerde {
       RowVectorPtr* result,
       const Options* options) override;
 
+  void deserialize(
+      ByteInputStream* source,
+      std::unique_ptr<RowIterator>& sourceRowIterator,
+      uint64_t maxRows,
+      RowTypePtr type,
+      RowVectorPtr* result,
+      velox::memory::MemoryPool* pool,
+      const Options* options = nullptr) override;
+
   static void registerVectorSerde();
   static void registerNamedVectorSerde();
 };
diff --git a/velox/serializers/VectorStream.cpp b/velox/serializers/VectorStream.cpp
index 5ac9015c4d70..00bd6d718ed9 100644
--- a/velox/serializers/VectorStream.cpp
+++ b/velox/serializers/VectorStream.cpp
@@ -342,6 +342,10 @@ void VectorStream::append(folly::Range<const Timestamp*> values) {
       appendOne(value.getSeconds());
       appendOne(value.getNanos());
     }
+  } else if (opts_.useMicrosecondPrecision) {
+    for (auto& value : values) {
+      appendOne(value.toMicros());
+    }
   } else {
     for (auto& value : values) {
       appendOne(value.toMillis());
diff --git a/velox/serializers/benchmarks/CMakeLists.txt b/velox/serializers/benchmarks/CMakeLists.txt
index 6087a2b738ae..7d1044e43676 100644
--- a/velox/serializers/benchmarks/CMakeLists.txt
+++ b/velox/serializers/benchmarks/CMakeLists.txt
@@ -19,4 +19,5 @@ target_link_libraries(
   velox_vector_fuzzer
   velox_memory
   Folly::folly
-  Folly::follybenchmark)
+  Folly::follybenchmark
+)
diff --git a/velox/serializers/tests/CMakeLists.txt b/velox/serializers/tests/CMakeLists.txt
index 937d40cb6831..d54e9ff9574e 100644
--- a/velox/serializers/tests/CMakeLists.txt
+++ b/velox/serializers/tests/CMakeLists.txt
@@ -11,22 +11,49 @@
 # WITHOUT 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_key_encoder_test KeyEncoderTest.cpp)
+
+add_test(
+  NAME velox_key_encoder_test
+  COMMAND velox_key_encoder_test
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+target_link_libraries(
+  velox_key_encoder_test
+  velox_exec
+  velox_exec_test_lib
+  velox_key_encoder
+  velox_functions_prestosql
+  velox_vector_fuzzer
+  velox_vector_test_lib
+  GTest::gtest
+  GTest::gtest_main
+  GTest::gmock
+)
+
 add_executable(
   velox_serializer_test
-  CompactRowSerializerTest.cpp PrestoOutputStreamListenerTest.cpp
-  PrestoSerializerTest.cpp UnsafeRowSerializerTest.cpp)
+  CompactRowSerializerTest.cpp
+  PrestoOutputStreamListenerTest.cpp
+  PrestoSerializerTest.cpp
+  SerializedPageFileTest.cpp
+  UnsafeRowSerializerTest.cpp
+)
 
 add_test(velox_serializer_test velox_serializer_test)
 
 target_link_libraries(
   velox_serializer_test
+  velox_expression_test_utility
   velox_presto_serializer
   velox_vector_test_lib
   velox_vector_fuzzer
   velox_row_fast
   GTest::gtest
   GTest::gtest_main
-  glog::glog)
+  glog::glog
+)
 
 if(VELOX_ENABLE_BENCHMARKS)
   add_executable(velox_serializer_benchmark SerializerBenchmark.cpp)
@@ -38,5 +65,6 @@ if(VELOX_ENABLE_BENCHMARKS)
     velox_vector_fuzzer
     GTest::gtest
     GTest::gtest_main
-    glog::glog)
+    glog::glog
+  )
 endif()
diff --git a/velox/serializers/tests/CompactRowSerializerTest.cpp b/velox/serializers/tests/CompactRowSerializerTest.cpp
index 5bcfae91c3d4..dba91d2c5d06 100644
--- a/velox/serializers/tests/CompactRowSerializerTest.cpp
+++ b/velox/serializers/tests/CompactRowSerializerTest.cpp
@@ -325,6 +325,14 @@ TEST_P(CompactRowSerializerTest, fuzz) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     CompactRowSerializerTest,
     CompactRowSerializerTest,
-    testing::ValuesIn(CompactRowSerializerTest::getTestParams()));
+    testing::ValuesIn(CompactRowSerializerTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}_{}_{}",
+          compressionKindToString(info.param.compressionKind),
+          info.param.appendRow ? "append" : "batch",
+          info.param.microBatchDeserialize ? "rowDeserialize"
+                                           : "batchDeserialize");
+    });
 } // namespace
 } // namespace facebook::velox::serializer
diff --git a/velox/serializers/tests/KeyEncoderTest.cpp b/velox/serializers/tests/KeyEncoderTest.cpp
new file mode 100644
index 000000000000..ef7ee03700f1
--- /dev/null
+++ b/velox/serializers/tests/KeyEncoderTest.cpp
@@ -0,0 +1,10613 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/serializers/KeyEncoder.h"
+
+#include <fmt/ranges.h>
+#include <folly/init/Init.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <algorithm>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/core/PlanNode.h"
+#include "velox/exec/tests/utils/AssertQueryBuilder.h"
+#include "velox/exec/tests/utils/OperatorTestBase.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+#include "velox/type/Type.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::serializer::test {
+namespace {
+
+class KeyEncoderTest : public velox::exec::test::OperatorTestBase {
+ protected:
+  void SetUp() override {
+    OperatorTestBase::SetUp();
+  }
+
+  static int lexicographicalCompare(
+      const std::string& key1,
+      const std::string& key2) {
+    const auto begin1 = reinterpret_cast<const unsigned char*>(key1.data());
+    const auto end1 = begin1 + key1.size();
+    const auto begin2 = reinterpret_cast<const unsigned char*>(key2.data());
+    const auto end2 = begin2 + key2.size();
+    bool lessThan = std::lexicographical_compare(begin1, end1, begin2, end2);
+
+    bool equal = std::equal(begin1, end1, begin2, end2);
+
+    return lessThan ? -1 : (equal ? 0 : 1);
+  }
+
+  // Helper method to test a specific sort order
+  void encodeTestWithSortOrder(
+      const std::vector<velox::RowVectorPtr>& inputs,
+      const std::vector<std::string>& sortingKeys,
+      const velox::core::SortOrder& sortOrder) {
+    ASSERT_FALSE(inputs.empty());
+    const auto inputType = asRowType(inputs[0]->type());
+
+    // Build key column types string
+    std::vector<std::string> keyColumnTypes;
+    keyColumnTypes.reserve(sortingKeys.size());
+    for (const auto& key : sortingKeys) {
+      auto child = inputType->findChild(key);
+      if (child) {
+        keyColumnTypes.push_back(child->toString());
+      }
+    }
+
+    SCOPED_TRACE(
+        fmt::format(
+            "Sort order: {}, nullsFirst: {}, Key columns: [{}]",
+            sortOrder.isAscending() ? "ASC" : "DESC",
+            sortOrder.isNullsFirst(),
+            folly::join(", ", keyColumnTypes)));
+
+    // Create KeyEncoder - always create a new one for each test
+    auto keyEncoder = KeyEncoder::create(
+        sortingKeys,
+        inputType,
+        std::vector<velox::core::SortOrder>{sortingKeys.size(), sortOrder},
+        pool_.get());
+
+    for (const auto& input : inputs) {
+      // Encode the keys
+      std::vector<char> buffer;
+      std::vector<std::string_view> encodedKeys;
+      keyEncoder->encode(input, encodedKeys, [&buffer](size_t size) -> void* {
+        buffer.resize(size);
+        return buffer.data();
+      });
+
+      // Sort indices based on encoded keys (lexicographic comparison)
+      std::vector<velox::vector_size_t> encodedIndices(input->size());
+      std::iota(encodedIndices.begin(), encodedIndices.end(), 0);
+      std::sort(
+          encodedIndices.begin(),
+          encodedIndices.end(),
+          [&encodedKeys](velox::vector_size_t a, velox::vector_size_t b) {
+            return lexicographicalCompare(
+                       std::string(encodedKeys[a]),
+                       std::string(encodedKeys[b])) < 0;
+          });
+
+      // Build orderBy specification strings for all sorting keys
+      std::vector<std::string> orderBySpecs;
+      orderBySpecs.reserve(sortingKeys.size());
+      for (const auto& key : sortingKeys) {
+        std::string spec = key;
+        if (!sortOrder.isAscending()) {
+          spec += " DESC";
+        }
+        if (sortOrder.isNullsFirst()) {
+          spec += " NULLS FIRST";
+        } else {
+          spec += " NULLS LAST";
+        }
+        orderBySpecs.push_back(spec);
+      }
+
+      // Use AssertQueryBuilder to create Velox OrderBy plan
+      velox::exec::test::AssertQueryBuilder queryBuilder{
+          velox::exec::test::PlanBuilder()
+              .values({input})
+              .orderBy(orderBySpecs, /*isPartial=*/false)
+              .planNode(),
+          duckDbQueryRunner_};
+
+      // Execute the plan and get results
+      auto veloxResult = queryBuilder.copyResults(pool_.get());
+
+      // Compare results - reorder input based on encoded key sort order
+      auto encodedResult = velox::BaseVector::create(
+          inputType, encodedIndices.size(), pool_.get());
+      for (size_t i = 0; i < encodedIndices.size(); ++i) {
+        encodedResult->copy(input.get(), i, encodedIndices[i], 1);
+      }
+
+      // Verify both results match
+      velox::test::assertEqualVectors(encodedResult, veloxResult);
+    }
+  }
+
+  // Test method to validate KeyEncoder encoding against Velox OrderBy operator
+  // Tests all four sort orders: AscNullsFirst, AscNullsLast, DescNullsFirst,
+  // DescNullsLast
+  void encodeTest(
+      const std::vector<velox::RowVectorPtr>& inputs,
+      const std::vector<std::string>& sortingKeys) {
+    encodeTestWithSortOrder(inputs, sortingKeys, velox::core::kAscNullsFirst);
+    encodeTestWithSortOrder(inputs, sortingKeys, velox::core::kAscNullsLast);
+    encodeTestWithSortOrder(inputs, sortingKeys, velox::core::kDescNullsFirst);
+    encodeTestWithSortOrder(inputs, sortingKeys, velox::core::kDescNullsFirst);
+  }
+
+  struct EncodeIndexBoundsTestCase {
+    std::vector<std::string> indexColumns;
+    std::optional<IndexBound> lowerBound;
+    std::optional<IndexBound> upperBound;
+    std::optional<velox::RowVectorPtr> expectedLowerBound;
+    std::optional<velox::RowVectorPtr> expectedUpperBound;
+    velox::core::SortOrder sortOrder = velox::core::kAscNullsFirst;
+    bool expectedFailure = false;
+
+    std::string debugString() const {
+      auto vectorToString = [](const velox::VectorPtr& vec) -> std::string {
+        if (vec->isNullAt(0)) {
+          return "null";
+        }
+
+        const auto typeKind = vec->typeKind();
+        switch (typeKind) {
+          case velox::TypeKind::BIGINT: {
+            const auto* flatVec = vec->as<velox::FlatVector<int64_t>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::INTEGER: {
+            const auto* flatVec = vec->as<velox::FlatVector<int32_t>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::SMALLINT: {
+            const auto* flatVec = vec->as<velox::FlatVector<int16_t>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::TINYINT: {
+            const auto* flatVec = vec->as<velox::FlatVector<int8_t>>();
+            return std::to_string(static_cast<int>(flatVec->valueAt(0)));
+          }
+          case velox::TypeKind::DOUBLE: {
+            const auto* flatVec = vec->as<velox::FlatVector<double>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::REAL: {
+            const auto* flatVec = vec->as<velox::FlatVector<float>>();
+            return std::to_string(flatVec->valueAt(0));
+          }
+          case velox::TypeKind::BOOLEAN: {
+            const auto* flatVec = vec->as<velox::FlatVector<bool>>();
+            return flatVec->valueAt(0) ? "true" : "false";
+          }
+          case velox::TypeKind::VARCHAR:
+          case velox::TypeKind::VARBINARY: {
+            const auto* flatVec =
+                vec->as<velox::FlatVector<velox::StringView>>();
+            return flatVec->valueAt(0).str();
+          }
+          case velox::TypeKind::TIMESTAMP: {
+            const auto* flatVec =
+                vec->as<velox::FlatVector<velox::Timestamp>>();
+            return flatVec->valueAt(0).toString();
+          }
+          default:
+            return fmt::format(
+                "<unknown type: {}>", static_cast<int>(typeKind));
+        }
+      };
+
+      std::vector<std::string> parts;
+
+      parts.push_back(
+          fmt::format("columns=[{}]", folly::join(", ", indexColumns)));
+
+      // Add sort order information
+      std::string soStr = sortOrder.isAscending() ? "ASC" : "DESC";
+      soStr += sortOrder.isNullsFirst() ? "_NULLS_FIRST" : "_NULLS_LAST";
+      parts.push_back(fmt::format("sortOrder={}", soStr));
+
+      if (lowerBound.has_value()) {
+        const auto& bound = lowerBound.value();
+        std::vector<std::string> values;
+        values.reserve(bound.bound->childrenSize());
+        for (size_t i = 0; i < bound.bound->childrenSize(); ++i) {
+          values.emplace_back(vectorToString(bound.bound->childAt(i)));
+        }
+        parts.push_back(
+            fmt::format(
+                "lower={}[{}]",
+                bound.inclusive ? ">=" : ">",
+                folly::join(", ", values)));
+      } else {
+        parts.push_back("lower=null");
+      }
+
+      if (upperBound.has_value()) {
+        const auto& bound = upperBound.value();
+        std::vector<std::string> values;
+        for (size_t i = 0; i < bound.bound->childrenSize(); ++i) {
+          values.push_back(vectorToString(bound.bound->childAt(i)));
+        }
+        parts.push_back(
+            fmt::format(
+                "upper={}[{}]",
+                bound.inclusive ? "<=" : "<",
+                folly::join(", ", values)));
+      } else {
+        parts.push_back("upper=null");
+      }
+
+      if (expectedLowerBound.has_value()) {
+        const auto& bound = expectedLowerBound.value();
+        std::vector<std::string> values;
+        for (size_t i = 0; i < bound->childrenSize(); ++i) {
+          values.push_back(vectorToString(bound->childAt(i)));
+        }
+        parts.push_back(
+            fmt::format("expected_lower=[{}]", folly::join(", ", values)));
+      } else {
+        parts.push_back("expected_lower=null");
+      }
+
+      if (expectedUpperBound.has_value()) {
+        const auto& bound = expectedUpperBound.value();
+        std::vector<std::string> values;
+        for (size_t i = 0; i < bound->childrenSize(); ++i) {
+          values.push_back(vectorToString(bound->childAt(i)));
+        }
+        parts.push_back(
+            fmt::format("expected_upper=[{}]", folly::join(", ", values)));
+      } else {
+        parts.push_back("expected_upper=null");
+      }
+
+      return folly::join(", ", parts);
+    }
+  };
+
+  // Test method to validate KeyEncoder encodeIndexBounds against expected
+  // encoded bounds
+  void testIndexBounds(const EncodeIndexBoundsTestCase& testCase) {
+    IndexBounds indexBounds;
+    indexBounds.indexColumns = testCase.indexColumns;
+    indexBounds.lowerBound = testCase.lowerBound;
+    indexBounds.upperBound = testCase.upperBound;
+
+    ASSERT_TRUE(indexBounds.validate());
+
+    const auto inputType = asRowType(indexBounds.type());
+    const std::vector<velox::core::SortOrder> sortOrders(
+        testCase.indexColumns.size(), testCase.sortOrder);
+    auto keyEncoder = KeyEncoder::create(
+        indexBounds.indexColumns, inputType, sortOrders, pool_.get());
+
+    const auto encodedBounds = keyEncoder->encodeIndexBounds(indexBounds);
+
+    if (testCase.expectedFailure) {
+      // For lower bound bump failures, expect std::nullopt to be returned
+      EXPECT_FALSE(encodedBounds.has_value())
+          << "Expected encodeIndexBounds to return std::nullopt for bound bump failure";
+      return;
+    }
+
+    // Verify we got a valid result
+    ASSERT_TRUE(encodedBounds.has_value());
+
+    // Verify presence of keys matches expectations
+    EXPECT_EQ(
+        encodedBounds->lowerKey.has_value(),
+        testCase.expectedLowerBound.has_value());
+    EXPECT_EQ(
+        encodedBounds->upperKey.has_value(),
+        testCase.expectedUpperBound.has_value());
+
+    // Encode expected bounds and verify they match
+    if (testCase.expectedLowerBound.has_value()) {
+      ASSERT_TRUE(encodedBounds->lowerKey.has_value());
+      std::vector<char> expectedBuffer;
+      std::vector<std::string_view> expectedKeys;
+      keyEncoder->encode(
+          testCase.expectedLowerBound.value(),
+          expectedKeys,
+          [&expectedBuffer](size_t size) -> void* {
+            expectedBuffer.resize(size);
+            return expectedBuffer.data();
+          });
+      EXPECT_EQ(expectedKeys.size(), 1);
+      EXPECT_EQ(encodedBounds->lowerKey.value(), std::string(expectedKeys[0]));
+    }
+
+    if (testCase.expectedUpperBound.has_value()) {
+      ASSERT_TRUE(encodedBounds->upperKey.has_value());
+      std::vector<char> expectedBuffer;
+      std::vector<std::string_view> expectedKeys;
+      keyEncoder->encode(
+          testCase.expectedUpperBound.value(),
+          expectedKeys,
+          [&expectedBuffer](size_t size) -> void* {
+            expectedBuffer.resize(size);
+            return expectedBuffer.data();
+          });
+      EXPECT_EQ(expectedKeys.size(), 1);
+      EXPECT_EQ(encodedBounds->upperKey.value(), std::string(expectedKeys[0]));
+    }
+  }
+
+  // Helper method to create test cases for all sort orders with sort
+  // order-specific expected values
+  std::vector<EncodeIndexBoundsTestCase> createIndexBoundEncodeTestCases(
+      std::vector<std::string> indexColumns,
+      std::optional<IndexBound> lowerBound,
+      std::optional<IndexBound> upperBound,
+      std::optional<velox::RowVectorPtr> ascNullsFirstExpectedLowerBound,
+      std::optional<velox::RowVectorPtr> ascNullsFirstExpectedUpperBound,
+      std::optional<velox::RowVectorPtr> ascNullsLastExpectedLowerBound,
+      std::optional<velox::RowVectorPtr> ascNullsLastExpectedUpperBound,
+      std::optional<velox::RowVectorPtr> descNullsFirstExpectedLowerBound,
+      std::optional<velox::RowVectorPtr> descNullsFirstExpectedUpperBound,
+      std::optional<velox::RowVectorPtr> descNullsLastExpectedLowerBound,
+      std::optional<velox::RowVectorPtr> descNullsLastExpectedUpperBound) {
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst,
+        velox::core::kAscNullsLast,
+        velox::core::kDescNullsFirst,
+        velox::core::kDescNullsLast,
+    };
+
+    std::vector<EncodeIndexBoundsTestCase> testCases;
+    testCases.reserve(sortOrders.size());
+
+    for (const auto& sortOrder : sortOrders) {
+      std::optional<velox::RowVectorPtr> expectedLowerBound;
+      std::optional<velox::RowVectorPtr> expectedUpperBound;
+
+      if (sortOrder.isAscending() && sortOrder.isNullsFirst()) {
+        expectedLowerBound = ascNullsFirstExpectedLowerBound;
+        expectedUpperBound = ascNullsFirstExpectedUpperBound;
+      } else if (sortOrder.isAscending() && !sortOrder.isNullsFirst()) {
+        expectedLowerBound = ascNullsLastExpectedLowerBound;
+        expectedUpperBound = ascNullsLastExpectedUpperBound;
+      } else if (!sortOrder.isAscending() && sortOrder.isNullsFirst()) {
+        expectedLowerBound = descNullsFirstExpectedLowerBound;
+        expectedUpperBound = descNullsFirstExpectedUpperBound;
+      } else { // DESC NULLS_LAST
+        expectedLowerBound = descNullsLastExpectedLowerBound;
+        expectedUpperBound = descNullsLastExpectedUpperBound;
+      }
+
+      testCases.push_back({
+          .indexColumns = indexColumns,
+          .lowerBound = lowerBound,
+          .upperBound = upperBound,
+          .expectedLowerBound = expectedLowerBound,
+          .expectedUpperBound = expectedUpperBound,
+          .sortOrder = sortOrder,
+      });
+    }
+
+    return testCases;
+  }
+};
+} // namespace
+
+TEST_F(KeyEncoderTest, indexBounds) {
+  const auto boundRow = makeRowVector({makeNullableFlatVector<int32_t>({2})});
+  // Test valid bounds with lower bound
+  IndexBounds boundsWithLower;
+  boundsWithLower.indexColumns = {"c0"};
+  boundsWithLower.lowerBound = IndexBound{boundRow, true};
+  EXPECT_TRUE(boundsWithLower.validate());
+  EXPECT_EQ(
+      boundsWithLower.toString(),
+      "IndexBounds{indexColumns=[c0], lowerBound=[0: {2}]}");
+  EXPECT_EQ(boundsWithLower.type()->toString(), boundRow->type()->toString());
+
+  // Test valid bounds with upper bound
+  IndexBounds boundsWithUpper;
+  boundsWithUpper.indexColumns = {"c0"};
+  boundsWithUpper.upperBound = IndexBound{boundRow, false};
+  EXPECT_TRUE(boundsWithUpper.validate());
+  EXPECT_EQ(
+      boundsWithUpper.toString(),
+      "IndexBounds{indexColumns=[c0], upperBound=(0: {2})}");
+
+  // Test valid bounds with both
+  IndexBounds boundsWithBoth;
+  boundsWithBoth.indexColumns = {"c0"};
+  boundsWithBoth.lowerBound = IndexBound{boundRow, true};
+  boundsWithBoth.upperBound = IndexBound{boundRow, false};
+  EXPECT_TRUE(boundsWithBoth.validate());
+  EXPECT_EQ(
+      boundsWithBoth.toString(),
+      "IndexBounds{indexColumns=[c0], lowerBound=[0: {2}], upperBound=(0: {2})}");
+
+  // Test invalid bounds with no bounds
+  IndexBounds noBounds;
+  noBounds.indexColumns = {"c0"};
+  EXPECT_FALSE(noBounds.validate());
+
+  auto badRowBound =
+      makeRowVector({makeNullableFlatVector<int32_t>({2, std::nullopt})});
+  IndexBounds badSizeBounds;
+  badSizeBounds.indexColumns = {"c0"};
+  badSizeBounds.lowerBound = IndexBound{badRowBound, true};
+  EXPECT_FALSE(badSizeBounds.validate());
+
+  // Test invalid bounds with extra index columns.
+  IndexBounds extraColBounds;
+  extraColBounds.indexColumns = {"c0", "c1", "c2"};
+  extraColBounds.lowerBound = IndexBound{boundRow, true};
+  EXPECT_FALSE(extraColBounds.validate());
+
+  extraColBounds.lowerBound = std::nullopt;
+  extraColBounds.upperBound = IndexBound{boundRow, true};
+  EXPECT_FALSE(extraColBounds.validate());
+
+  const auto multiColumnBoundRow = makeRowVector(
+      {makeNullableFlatVector<int32_t>({2}),
+       makeNullableFlatVector<int32_t>({1})});
+  IndexBounds multiColumnBounds;
+  multiColumnBounds.indexColumns = {"c0", "c1"};
+  multiColumnBounds.lowerBound = IndexBound{multiColumnBoundRow, true};
+  multiColumnBounds.upperBound = IndexBound{multiColumnBoundRow, false};
+  EXPECT_TRUE(multiColumnBounds.validate());
+  EXPECT_EQ(
+      multiColumnBounds.toString(),
+      "IndexBounds{indexColumns=[c0, c1], lowerBound=[0: {2, 1}], upperBound=(0: {2, 1})}");
+
+  IndexBounds missingColBounds;
+  missingColBounds.indexColumns = {"c0"};
+  missingColBounds.upperBound = IndexBound{multiColumnBoundRow, false};
+  EXPECT_FALSE(missingColBounds.validate());
+}
+
+TEST_F(KeyEncoderTest, indexBoundsType) {
+  struct TestCase {
+    std::string name;
+    std::vector<std::string> indexColumns;
+    std::optional<RowVectorPtr> lowerBoundRow;
+    std::optional<RowVectorPtr> upperBoundRow;
+    bool lowerInclusive;
+    bool upperInclusive;
+    // Expected type is always the type from lowerBoundRow if present,
+    // otherwise from upperBoundRow
+  };
+
+  std::vector<TestCase> testCases = {
+      // Lower bound only - single column
+      {
+          .name = "lower_bound_only_single_column",
+          .indexColumns = {"key"},
+          .lowerBoundRow =
+              makeRowVector({"key"}, {makeNullableFlatVector<int32_t>({42})}),
+          .upperBoundRow = std::nullopt,
+          .lowerInclusive = true,
+          .upperInclusive = false,
+      },
+      // Upper bound only - single column
+      {
+          .name = "upper_bound_only_single_column",
+          .indexColumns = {"key"},
+          .lowerBoundRow = std::nullopt,
+          .upperBoundRow =
+              makeRowVector({"key"}, {makeNullableFlatVector<int64_t>({100})}),
+          .lowerInclusive = false,
+          .upperInclusive = true,
+      },
+      // Both bounds - single column
+      {
+          .name = "both_bounds_single_column",
+          .indexColumns = {"col"},
+          .lowerBoundRow =
+              makeRowVector({"col"}, {makeNullableFlatVector<double>({1.5})}),
+          .upperBoundRow =
+              makeRowVector({"col"}, {makeNullableFlatVector<double>({10.5})}),
+          .lowerInclusive = true,
+          .upperInclusive = false,
+      },
+      // Lower bound only - multi column
+      {
+          .name = "lower_bound_only_multi_column",
+          .indexColumns = {"col1", "col2"},
+          .lowerBoundRow = makeRowVector(
+              {"col1", "col2"},
+              {makeNullableFlatVector<int64_t>({100}),
+               makeNullableFlatVector<std::string>({"test"})}),
+          .upperBoundRow = std::nullopt,
+          .lowerInclusive = true,
+          .upperInclusive = false,
+      },
+      // Upper bound only - multi column
+      {
+          .name = "upper_bound_only_multi_column",
+          .indexColumns = {"a", "b", "c"},
+          .lowerBoundRow = std::nullopt,
+          .upperBoundRow = makeRowVector(
+              {"a", "b", "c"},
+              {makeNullableFlatVector<int32_t>({1}),
+               makeNullableFlatVector<int32_t>({2}),
+               makeNullableFlatVector<int32_t>({3})}),
+          .lowerInclusive = false,
+          .upperInclusive = true,
+      },
+      // Both bounds - multi column
+      {
+          .name = "both_bounds_multi_column",
+          .indexColumns = {"x", "y"},
+          .lowerBoundRow = makeRowVector(
+              {"x", "y"},
+              {makeNullableFlatVector<bool>({true}),
+               makeNullableFlatVector<float>({1.0f})}),
+          .upperBoundRow = makeRowVector(
+              {"x", "y"},
+              {makeNullableFlatVector<bool>({false}),
+               makeNullableFlatVector<float>({9.0f})}),
+          .lowerInclusive = false,
+          .upperInclusive = false,
+      },
+      // Timestamp type
+      {
+          .name = "timestamp_type",
+          .indexColumns = {"ts"},
+          .lowerBoundRow = makeRowVector(
+              {"ts"},
+              {makeNullableFlatVector<Timestamp>({Timestamp(1000, 500)})}),
+          .upperBoundRow = std::nullopt,
+          .lowerInclusive = true,
+          .upperInclusive = false,
+      },
+      // VARCHAR type
+      {
+          .name = "varchar_type",
+          .indexColumns = {"name"},
+          .lowerBoundRow = std::nullopt,
+          .upperBoundRow = makeRowVector(
+              {"name"}, {makeNullableFlatVector<std::string>({"hello"})}),
+          .lowerInclusive = false,
+          .upperInclusive = true,
+      },
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.name);
+
+    IndexBounds bounds;
+    bounds.indexColumns = testCase.indexColumns;
+    if (testCase.lowerBoundRow.has_value()) {
+      bounds.lowerBound =
+          IndexBound{testCase.lowerBoundRow.value(), testCase.lowerInclusive};
+    }
+    if (testCase.upperBoundRow.has_value()) {
+      bounds.upperBound =
+          IndexBound{testCase.upperBoundRow.value(), testCase.upperInclusive};
+    }
+
+    ASSERT_TRUE(bounds.validate());
+
+    const auto type = bounds.type();
+    ASSERT_NE(type, nullptr);
+    EXPECT_EQ(type->kind(), TypeKind::ROW);
+
+    // type() should return lowerBound's type when present, otherwise
+    // upperBound's type
+    const auto& expectedRow = testCase.lowerBoundRow.has_value()
+        ? testCase.lowerBoundRow.value()
+        : testCase.upperBoundRow.value();
+    EXPECT_TRUE(type->equivalent(*expectedRow->type()));
+
+    const auto rowType = asRowType(type);
+    EXPECT_EQ(rowType->size(), testCase.indexColumns.size());
+    for (size_t i = 0; i < testCase.indexColumns.size(); ++i) {
+      EXPECT_EQ(rowType->nameOf(i), testCase.indexColumns[i]);
+      EXPECT_EQ(
+          rowType->childAt(i)->kind(), expectedRow->childAt(i)->type()->kind());
+    }
+  }
+}
+
+TEST_F(KeyEncoderTest, longTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<int64_t>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<int64_t> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row]);
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1}, {2}, {3}}},
+      // All same values
+      {{{5, 5, 5}, {10, 10, 10}, {15, 15, 15}}},
+      // Ascending order in first column
+      {{{1, 2, 3, 4}, {100, 100, 100, 100}, {50, 50, 50, 50}}},
+      // Descending order in first column
+      {{{10, 9, 8, 7}, {0, 0, 0, 0}, {5, 5, 5, 5}}},
+      // Mixed positive and negative values
+      {{{-5, 0, 5}, {-10, -5, 0}, {10, 5, 0}}},
+      // Edge values: min and max int64_t
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max(),
+         0},
+        {-1, 0, 1},
+        {100, 200, 300}}},
+      // All zeros
+      {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
+      // Duplicate values across rows
+      {{{1, 2, 1, 2}, {3, 3, 4, 4}, {5, 5, 5, 5}}},
+      // Large spread of values
+      {{{-1000000, -1, 0, 1, 1000000},
+        {999999, 500000, 0, -500000, -999999},
+        {42, 42, 42, 42, 42}}},
+      // Values that differ only in last column
+      {{{1, 1, 1}, {2, 2, 2}, {3, 4, 5}}},
+      // Values that differ only in first column
+      {{{1, 2, 3}, {100, 100, 100}, {200, 200, 200}}},
+      // Alternating pattern
+      {{{1, -1, 1, -1, 1, -1}, {2, -2, 2, -2, 2, -2}, {3, -3, 3, -3, 3, -3}}},
+      // Sequential values
+      {{{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}}},
+      // Powers of 2
+      {{{1, 2, 4, 8, 16, 32, 64},
+        {128, 256, 512, 1024, 2048, 4096, 8192},
+        {16384, 32768, 65536, 131072, 262144, 524288, 1048576}}},
+      // Negative progression
+      {{{-1, -2, -4, -8}, {-16, -32, -64, -128}, {0, 0, 0, 0}}},
+      // Mix of edge cases and regular values
+      {{{std::numeric_limits<int64_t>::min(), -1000, -1, 0},
+        {1,
+         1000,
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max()},
+        {42, 43, 44, 45}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<int64_t>(testCase.columnValues[0]),
+         makeFlatVector<int64_t>(testCase.columnValues[1]),
+         makeFlatVector<int64_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, longTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<int64_t>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1}, {2}}},
+      // Single row without null (nullable type)
+      {{{1}, {2}, {3}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning of first column
+      {{{std::nullopt, 1, 2}, {10, 20, 30}, {100, 200, 300}}},
+      // Null at end of first column
+      {{{1, 2, std::nullopt}, {10, 20, 30}, {100, 200, 300}}},
+      // Null in middle of first column
+      {{{1, std::nullopt, 2}, {10, 20, 30}, {100, 200, 300}}},
+      // Nulls in all positions across different columns
+      {{{std::nullopt, 1, 2, 3},
+        {1, std::nullopt, 2, 3},
+        {1, 2, std::nullopt, 3}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1, 2}, {std::nullopt, 1, 2}, {std::nullopt, 1, 2}}},
+      // Alternating null and non-null in first column
+      {{{std::nullopt, 1, std::nullopt, 2, std::nullopt, 3},
+        {10, 10, 10, 10, 10, 10},
+        {20, 20, 20, 20, 20, 20}}},
+      // Same values, different null positions
+      {{{1, 1, std::nullopt}, {2, std::nullopt, 2}, {3, 3, 3}}},
+      // Nulls with edge values
+      {{{std::nullopt,
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max()},
+        {0, std::nullopt, 0},
+        {100, 200, std::nullopt}}},
+      // Nulls with zeros
+      {{{std::nullopt, 0, std::nullopt}, {0, std::nullopt, 0}, {0, 0, 0}}},
+      // Nulls with positive and negative values
+      {{{std::nullopt, -5, 5},
+        {-10, std::nullopt, 10},
+        {std::nullopt, -15, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1, 1, std::nullopt, std::nullopt},
+        {2, 2, 2, std::nullopt},
+        {3, std::nullopt, 3, 3}}},
+      // Ascending order with nulls scattered
+      {{{std::nullopt, 1, 2, 3, std::nullopt},
+        {10, std::nullopt, 20, std::nullopt, 30},
+        {std::nullopt, std::nullopt, 100, 200, 300}}},
+      // Descending order with nulls scattered
+      {{{std::nullopt, 3, 2, 1, std::nullopt},
+        {30, std::nullopt, 20, std::nullopt, 10},
+        {std::nullopt, std::nullopt, 300, 200, 100}}},
+      // Only first column has nulls
+      {{{std::nullopt, std::nullopt, 1, 2}, {10, 20, 30, 40}, {5, 6, 7, 8}}},
+      // Only middle column has nulls
+      {{{1, 2, 3, 4},
+        {std::nullopt, std::nullopt, 10, 20},
+        {100, 200, 300, 400}}},
+      // Only last column has nulls
+      {{{1, 2, 3, 4},
+        {10, 20, 30, 40},
+        {std::nullopt, std::nullopt, 100, 200}}},
+      // All columns have at least one null
+      {{{std::nullopt, 1, 2, 3, 4},
+        {1, std::nullopt, 2, 3, 4},
+        {1, 2, std::nullopt, 3, 4}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1}, {100, 100}, {200, 200}}},
+      // Large spread with nulls
+      {{{std::nullopt, -1000000, 0, 1000000, std::nullopt},
+        {999999, std::nullopt, 0, std::nullopt, -999999},
+        {std::nullopt, 42, std::nullopt, 42, std::nullopt}}},
+      // Sequential with nulls at boundaries
+      {{{std::nullopt, 0, 1, 2, 3, std::nullopt},
+        {std::nullopt, 10, 11, 12, 13, std::nullopt},
+        {std::nullopt, 20, 21, 22, 23, std::nullopt}}},
+      // Powers of 2 with nulls
+      {{{std::nullopt, 1, 2, 4, 8, std::nullopt},
+        {16, std::nullopt, 32, 64, std::nullopt, 128},
+        {std::nullopt, 256, std::nullopt, 512, std::nullopt, 1024}}},
+      // Mix of nulls and regular values testing sort order edge cases
+      {{{std::nullopt, std::nullopt, 0, 0},
+        {std::nullopt, 1, std::nullopt, 1},
+        {2, std::nullopt, 2, std::nullopt}}},
+      // All max values
+      {{{std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max()},
+        {std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max()},
+        {std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max()}}},
+      // All min values
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min()}}},
+      // Max values with nulls
+      {{{std::nullopt, std::numeric_limits<int64_t>::max(), std::nullopt},
+        {std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::max()},
+        {std::nullopt, std::nullopt, std::numeric_limits<int64_t>::max()}}},
+      // Min values with nulls
+      {{{std::nullopt, std::numeric_limits<int64_t>::min(), std::nullopt},
+        {std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::min()},
+        {std::nullopt, std::nullopt, std::numeric_limits<int64_t>::min()}}},
+      // Mix of max and min values
+      {{{std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max()},
+        {std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max()}}},
+      // Mix of max, min, and nulls
+      {{{std::nullopt,
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::min()},
+        {std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt}}},
+      // Max in first column only
+      {{{std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         1,
+         2},
+        {100, 200, 300, 400},
+        {5, 6, 7, 8}}},
+      // Min in first column only
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         1,
+         2},
+        {100, 200, 300, 400},
+        {5, 6, 7, 8}}},
+      // Max and min in different columns
+      {{{std::numeric_limits<int64_t>::max(), 1, 2},
+        {1, std::numeric_limits<int64_t>::min(), 2},
+        {1, 2, std::numeric_limits<int64_t>::max()}}},
+      // Adjacent to max (max-1, max)
+      {{{std::numeric_limits<int64_t>::max() - 1,
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::max() - 1,
+         std::numeric_limits<int64_t>::max()},
+        {std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::max() - 1}}},
+      // Adjacent to min (min, min+1)
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min() + 1,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min() + 1},
+        {std::numeric_limits<int64_t>::min() + 1,
+         std::nullopt,
+         std::numeric_limits<int64_t>::min()}}},
+      // Boundary transitions with nulls (min, null, 0, null, max)
+      {{{std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         0,
+         std::nullopt,
+         std::numeric_limits<int64_t>::max()},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt},
+        {0, 0, 0, 0, 0}}},
+      // Duplicate max values with nulls
+      {{{std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::max(),
+         std::numeric_limits<int64_t>::max(),
+         std::nullopt},
+        {std::numeric_limits<int64_t>::max(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int64_t>::max()}}},
+      // Duplicate min values with nulls
+      {{{std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int64_t>::min(),
+         std::numeric_limits<int64_t>::min(),
+         std::nullopt},
+        {std::numeric_limits<int64_t>::min(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int64_t>::min()}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<int64_t>(testCase.columnValues[0]),
+         makeNullableFlatVector<int64_t>(testCase.columnValues[1]),
+         makeNullableFlatVector<int64_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders (ASC/DESC x NULLS FIRST/NULLS LAST)
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, integerTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<int32_t>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<int32_t> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row]);
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1}, {2}, {3}}},
+      // All same values
+      {{{5, 5, 5}, {10, 10, 10}, {15, 15, 15}}},
+      // Ascending order
+      {{{1, 2, 3, 4}, {100, 100, 100, 100}, {50, 50, 50, 50}}},
+      // Descending order
+      {{{10, 9, 8, 7}, {0, 0, 0, 0}, {5, 5, 5, 5}}},
+      // Mixed positive and negative values
+      {{{-5, 0, 5}, {-10, -5, 0}, {10, 5, 0}}},
+      // Edge values: min and max int32_t
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max(),
+         0},
+        {-1, 0, 1},
+        {100, 200, 300}}},
+      // All zeros
+      {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
+      // Duplicate values
+      {{{1, 2, 1, 2}, {3, 3, 4, 4}, {5, 5, 5, 5}}},
+      // Large spread
+      {{{-1000000, -1, 0, 1, 1000000},
+        {999999, 500000, 0, -500000, -999999},
+        {42, 42, 42, 42, 42}}},
+      // Values differing only in last column
+      {{{1, 1, 1}, {2, 2, 2}, {3, 4, 5}}},
+      // Values differing only in first column
+      {{{1, 2, 3}, {100, 100, 100}, {200, 200, 200}}},
+      // Alternating pattern
+      {{{1, -1, 1, -1}, {2, -2, 2, -2}, {3, -3, 3, -3}}},
+      // All max values
+      {{{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()}}},
+      // All min values
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min()}}},
+      // Mix of max and min
+      {{{std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max()},
+        {0, 0}}},
+      // Adjacent to max (max-1, max)
+      {{{std::numeric_limits<int32_t>::max() - 1,
+         std::numeric_limits<int32_t>::max()},
+        {std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max() - 1},
+        {0, 1}}},
+      // Adjacent to min (min, min+1)
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min() + 1},
+        {std::numeric_limits<int32_t>::min() + 1,
+         std::numeric_limits<int32_t>::min()},
+        {0, 1}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<int32_t>(testCase.columnValues[0]),
+         makeFlatVector<int32_t>(testCase.columnValues[1]),
+         makeFlatVector<int32_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, integerTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<int32_t>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1}, {2}}},
+      // Single row without null (nullable type)
+      {{{1}, {2}, {3}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with max value
+      {{{std::nullopt, 1, std::numeric_limits<int32_t>::max()},
+        {10, 20, 30},
+        {100, 200, 300}}},
+      // Null at end with min value
+      {{{1, std::numeric_limits<int32_t>::min(), std::nullopt},
+        {10, 20, 30},
+        {100, 200, 300}}},
+      // Null in middle
+      {{{1, std::nullopt, 2}, {10, 20, 30}, {100, 200, 300}}},
+      // Nulls in all positions across different columns with edge values
+      {{{std::nullopt, 1, std::numeric_limits<int32_t>::max(), 3},
+        {1, std::nullopt, 2, std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(), 2, std::nullopt, 3}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1, 2}, {std::nullopt, 1, 2}, {std::nullopt, 1, 2}}},
+      // Alternating null and non-null with boundaries
+      {{{std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt,
+         2,
+         std::nullopt,
+         std::numeric_limits<int32_t>::min()},
+        {10, 10, 10, 10, 10, 10},
+        {20, 20, 20, 20, 20, 20}}},
+      // Same values, different null positions
+      {{{1, 1, std::nullopt}, {2, std::nullopt, 2}, {3, 3, 3}}},
+      // Mixed edge values with nulls
+      {{{std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max()},
+        {0, std::nullopt, 0},
+        {100, 200, std::nullopt}}},
+      // Nulls with zeros and boundaries
+      {{{std::nullopt, 0, std::numeric_limits<int32_t>::max()},
+        {0, std::nullopt, std::numeric_limits<int32_t>::min()},
+        {0, 0, 0}}},
+      // Nulls with positive and negative including extremes
+      {{{std::nullopt, -5, std::numeric_limits<int32_t>::max()},
+        {std::numeric_limits<int32_t>::min(), std::nullopt, 10},
+        {std::nullopt, -15, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1, 1, std::nullopt, std::nullopt},
+        {2, 2, 2, std::nullopt},
+        {3, std::nullopt, 3, 3}}},
+      // Ascending order with nulls and max values
+      {{{std::nullopt, 1, 2, std::numeric_limits<int32_t>::max(), std::nullopt},
+        {10, std::nullopt, 20, std::nullopt, 30},
+        {std::nullopt, std::nullopt, 100, 200, 300}}},
+      // Descending order with nulls and min values
+      {{{std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         2,
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt},
+        {30, std::nullopt, 20, std::nullopt, 10},
+        {std::nullopt, std::nullopt, 300, 200, 100}}},
+      // Only first column has nulls with boundaries
+      {{{std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max()},
+        {10, 20, 30, 40},
+        {5, 6, 7, 8}}},
+      // Only middle column has nulls
+      {{{1, 2, 3, 4},
+        {std::nullopt, std::nullopt, 10, 20},
+        {100, 200, 300, 400}}},
+      // Only last column has nulls with max
+      {{{1, 2, 3, std::numeric_limits<int32_t>::max()},
+        {10, 20, 30, 40},
+        {std::nullopt,
+         std::nullopt,
+         100,
+         std::numeric_limits<int32_t>::min()}}},
+      // All columns have at least one null mixed with extremes
+      {{{std::nullopt, std::numeric_limits<int32_t>::max(), 2, 3, 4},
+        {1, std::nullopt, std::numeric_limits<int32_t>::min(), 3, 4},
+        {1, 2, std::nullopt, std::numeric_limits<int32_t>::max(), 4}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1}, {100, 100}, {200, 200}}},
+      // Large spread with nulls and boundaries
+      {{{std::nullopt,
+         -1000000,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {999999, std::nullopt, 0, std::nullopt, -999999},
+        {std::nullopt, 42, std::nullopt, 42, std::nullopt}}},
+      // Sequential with nulls at boundaries
+      {{{std::nullopt,
+         0,
+         1,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {std::nullopt, 10, 11, 12, 13, std::nullopt},
+        {std::nullopt, 20, 21, 22, 23, std::nullopt}}},
+      // Mix of nulls and regular values testing sort order
+      {{{std::nullopt, std::nullopt, 0, 0},
+        {std::nullopt, 1, std::nullopt, 1},
+        {2, std::nullopt, 2, std::nullopt}}},
+      // Max and min together in different positions
+      {{{std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::min()},
+        {std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int32_t>::max()}}},
+      // Adjacent to max with nulls (max-1, max)
+      {{{std::numeric_limits<int32_t>::max() - 1,
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::max() - 1,
+         std::numeric_limits<int32_t>::max()},
+        {std::numeric_limits<int32_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int32_t>::max() - 1}}},
+      // Adjacent to min with nulls (min, min+1)
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min() + 1,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min() + 1},
+        {std::numeric_limits<int32_t>::min() + 1,
+         std::nullopt,
+         std::numeric_limits<int32_t>::min()}}},
+      // Boundary transitions with nulls (min, null, 0, null, max)
+      {{{std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         0,
+         std::nullopt,
+         std::numeric_limits<int32_t>::max()},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {0, 0, 0, 0, 0}}},
+      // Duplicate max values with nulls
+      {{{std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::max(),
+         std::numeric_limits<int32_t>::max(),
+         std::nullopt},
+        {std::numeric_limits<int32_t>::max(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int32_t>::max()}}},
+      // Duplicate min values with nulls
+      {{{std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int32_t>::min(),
+         std::numeric_limits<int32_t>::min(),
+         std::nullopt},
+        {std::numeric_limits<int32_t>::min(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int32_t>::min()}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<int32_t>(testCase.columnValues[0]),
+         makeNullableFlatVector<int32_t>(testCase.columnValues[1]),
+         makeNullableFlatVector<int32_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, shortTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<int16_t>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<int16_t> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row]);
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1}, {2}, {3}}},
+      // All same values
+      {{{5, 5, 5}, {10, 10, 10}, {15, 15, 15}}},
+      // Ascending order
+      {{{1, 2, 3, 4}, {100, 100, 100, 100}, {50, 50, 50, 50}}},
+      // Descending order
+      {{{10, 9, 8, 7}, {0, 0, 0, 0}, {5, 5, 5, 5}}},
+      // Mixed positive and negative values
+      {{{-5, 0, 5}, {-10, -5, 0}, {10, 5, 0}}},
+      // Edge values: min and max int16_t
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max(),
+         0},
+        {-1, 0, 1},
+        {100, 200, 300}}},
+      // All zeros
+      {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
+      // Duplicate values
+      {{{1, 2, 1, 2}, {3, 3, 4, 4}, {5, 5, 5, 5}}},
+      // Large spread (within int16 range)
+      {{{-30000, -1, 0, 1, 30000},
+        {20000, 10000, 0, -10000, -20000},
+        {42, 42, 42, 42, 42}}},
+      // Values differing only in last column
+      {{{1, 1, 1}, {2, 2, 2}, {3, 4, 5}}},
+      // Values differing only in first column
+      {{{1, 2, 3}, {100, 100, 100}, {200, 200, 200}}},
+      // Alternating pattern
+      {{{1, -1, 1, -1}, {2, -2, 2, -2}, {3, -3, 3, -3}}},
+      // All max values
+      {{{std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max()}}},
+      // All min values
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min()}}},
+      // Mix of max and min
+      {{{std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max()},
+        {0, 0}}},
+      // Adjacent to max (max-1, max)
+      {{{std::numeric_limits<int16_t>::max() - 1,
+         std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max() - 1},
+        {0, 1}}},
+      // Adjacent to min (min, min+1)
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min() + 1},
+        {std::numeric_limits<int16_t>::min() + 1,
+         std::numeric_limits<int16_t>::min()},
+        {0, 1}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<int16_t>(testCase.columnValues[0]),
+         makeFlatVector<int16_t>(testCase.columnValues[1]),
+         makeFlatVector<int16_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, shortTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<int16_t>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1}, {2}}},
+      // Single row without null (nullable type)
+      {{{1}, {2}, {3}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with max value
+      {{{std::nullopt, 1, std::numeric_limits<int16_t>::max()},
+        {10, 20, 30},
+        {100, 200, 300}}},
+      // Null at end with min value
+      {{{1, std::numeric_limits<int16_t>::min(), std::nullopt},
+        {10, 20, 30},
+        {100, 200, 300}}},
+      // Null in middle
+      {{{1, std::nullopt, 2}, {10, 20, 30}, {100, 200, 300}}},
+      // Nulls in all positions across different columns with edge values
+      {{{std::nullopt, 1, std::numeric_limits<int16_t>::max(), 3},
+        {1, std::nullopt, 2, std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(), 2, std::nullopt, 3}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1, 2}, {std::nullopt, 1, 2}, {std::nullopt, 1, 2}}},
+      // Alternating null and non-null with boundaries
+      {{{std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt,
+         2,
+         std::nullopt,
+         std::numeric_limits<int16_t>::min()},
+        {10, 10, 10, 10, 10, 10},
+        {20, 20, 20, 20, 20, 20}}},
+      // Same values, different null positions
+      {{{1, 1, std::nullopt}, {2, std::nullopt, 2}, {3, 3, 3}}},
+      // Mixed edge values with nulls
+      {{{std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max()},
+        {0, std::nullopt, 0},
+        {100, 200, std::nullopt}}},
+      // Nulls with zeros and boundaries
+      {{{std::nullopt, 0, std::numeric_limits<int16_t>::max()},
+        {0, std::nullopt, std::numeric_limits<int16_t>::min()},
+        {0, 0, 0}}},
+      // Nulls with positive and negative including extremes
+      {{{std::nullopt, -5, std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::min(), std::nullopt, 10},
+        {std::nullopt, -15, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1, 1, std::nullopt, std::nullopt},
+        {2, 2, 2, std::nullopt},
+        {3, std::nullopt, 3, 3}}},
+      // Ascending order with nulls and max values
+      {{{std::nullopt, 1, 2, std::numeric_limits<int16_t>::max(), std::nullopt},
+        {10, std::nullopt, 20, std::nullopt, 30},
+        {std::nullopt, std::nullopt, 100, 200, 300}}},
+      // Descending order with nulls and min values
+      {{{std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         2,
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt},
+        {30, std::nullopt, 20, std::nullopt, 10},
+        {std::nullopt, std::nullopt, 300, 200, 100}}},
+      // Only first column has nulls with boundaries
+      {{{std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max()},
+        {10, 20, 30, 40},
+        {5, 6, 7, 8}}},
+      // Only middle column has nulls
+      {{{1, 2, 3, 4},
+        {std::nullopt, std::nullopt, 10, 20},
+        {100, 200, 300, 400}}},
+      // Only last column has nulls with max
+      {{{1, 2, 3, std::numeric_limits<int16_t>::max()},
+        {10, 20, 30, 40},
+        {std::nullopt,
+         std::nullopt,
+         100,
+         std::numeric_limits<int16_t>::min()}}},
+      // All columns have at least one null mixed with extremes
+      {{{std::nullopt, std::numeric_limits<int16_t>::max(), 2, 3, 4},
+        {1, std::nullopt, std::numeric_limits<int16_t>::min(), 3, 4},
+        {1, 2, std::nullopt, std::numeric_limits<int16_t>::max(), 4}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1}, {100, 100}, {200, 200}}},
+      // Large spread with nulls and boundaries (within int16 range)
+      {{{std::nullopt,
+         -30000,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt},
+        {20000, std::nullopt, 0, std::nullopt, -20000},
+        {std::nullopt, 42, std::nullopt, 42, std::nullopt}}},
+      // Mix of nulls and regular values testing sort order
+      {{{std::nullopt, std::nullopt, 0, 0},
+        {std::nullopt, 1, std::nullopt, 1},
+        {2, std::nullopt, 2, std::nullopt}}},
+      // Max and min together in different positions
+      {{{std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::min()},
+        {std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int16_t>::max()}}},
+      // Adjacent to max with nulls (max-1, max)
+      {{{std::numeric_limits<int16_t>::max() - 1,
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::max() - 1,
+         std::numeric_limits<int16_t>::max()},
+        {std::numeric_limits<int16_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int16_t>::max() - 1}}},
+      // Adjacent to min with nulls (min, min+1)
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min() + 1,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min() + 1},
+        {std::numeric_limits<int16_t>::min() + 1,
+         std::nullopt,
+         std::numeric_limits<int16_t>::min()}}},
+      // Boundary transitions with nulls (min, null, 0, null, max)
+      {{{std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         0,
+         std::nullopt,
+         std::numeric_limits<int16_t>::max()},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt},
+        {0, 0, 0, 0, 0}}},
+      // Duplicate max values with nulls
+      {{{std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::max(),
+         std::numeric_limits<int16_t>::max(),
+         std::nullopt},
+        {std::numeric_limits<int16_t>::max(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int16_t>::max()}}},
+      // Duplicate min values with nulls
+      {{{std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int16_t>::min(),
+         std::numeric_limits<int16_t>::min(),
+         std::nullopt},
+        {std::numeric_limits<int16_t>::min(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int16_t>::min()}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<int16_t>(testCase.columnValues[0]),
+         makeNullableFlatVector<int16_t>(testCase.columnValues[1]),
+         makeNullableFlatVector<int16_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, byteTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<int8_t>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<int> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(static_cast<int>(column[row]));
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1}, {2}, {3}}},
+      // All same values
+      {{{5, 5, 5}, {10, 10, 10}, {15, 15, 15}}},
+      // Ascending order
+      {{{1, 2, 3, 4}, {100, 100, 100, 100}, {50, 50, 50, 50}}},
+      // Descending order
+      {{{10, 9, 8, 7}, {0, 0, 0, 0}, {5, 5, 5, 5}}},
+      // Mixed positive and negative values
+      {{{-5, 0, 5}, {-10, -5, 0}, {10, 5, 0}}},
+      // Edge values: min and max int8_t
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max(),
+         0},
+        {-1, 0, 1},
+        {100, 50, 25}}},
+      // All zeros
+      {{{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}},
+      // Duplicate values
+      {{{1, 2, 1, 2}, {3, 3, 4, 4}, {5, 5, 5, 5}}},
+      // Large spread (within int8 range)
+      {{{-120, -1, 0, 1, 120}, {100, 50, 0, -50, -100}, {42, 42, 42, 42, 42}}},
+      // Values differing only in last column
+      {{{1, 1, 1}, {2, 2, 2}, {3, 4, 5}}},
+      // Values differing only in first column
+      {{{1, 2, 3}, {100, 100, 100}, {50, 50, 50}}},
+      // Alternating pattern
+      {{{1, -1, 1, -1}, {2, -2, 2, -2}, {3, -3, 3, -3}}},
+      // All max values (127)
+      {{{std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max()}}},
+      // All min values (-128)
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min()}}},
+      // Mix of max and min
+      {{{std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max()},
+        {0, 0}}},
+      // Adjacent to max (max-1, max)
+      {{{std::numeric_limits<int8_t>::max() - 1,
+         std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max() - 1},
+        {0, 1}}},
+      // Adjacent to min (min, min+1)
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min() + 1},
+        {std::numeric_limits<int8_t>::min() + 1,
+         std::numeric_limits<int8_t>::min()},
+        {0, 1}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<int8_t>(testCase.columnValues[0]),
+         makeFlatVector<int8_t>(testCase.columnValues[1]),
+         makeFlatVector<int8_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, byteTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<int8_t>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(
+                std::to_string(static_cast<int>(column[row].value())));
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1}, {2}}},
+      // Single row without null (nullable type)
+      {{{1}, {2}, {3}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with max value
+      {{{std::nullopt, 1, std::numeric_limits<int8_t>::max()},
+        {10, 20, 30},
+        {100, 50, 25}}},
+      // Null at end with min value
+      {{{1, std::numeric_limits<int8_t>::min(), std::nullopt},
+        {10, 20, 30},
+        {100, 50, 25}}},
+      // Null in middle
+      {{{1, std::nullopt, 2}, {10, 20, 30}, {100, 50, 25}}},
+      // Nulls in all positions across different columns with edge values
+      {{{std::nullopt, 1, std::numeric_limits<int8_t>::max(), 3},
+        {1, std::nullopt, 2, std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(), 2, std::nullopt, 3}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1, 2}, {std::nullopt, 1, 2}, {std::nullopt, 1, 2}}},
+      // Alternating null and non-null with boundaries
+      {{{std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt,
+         2,
+         std::nullopt,
+         std::numeric_limits<int8_t>::min()},
+        {10, 10, 10, 10, 10, 10},
+        {20, 20, 20, 20, 20, 20}}},
+      // Same values, different null positions
+      {{{1, 1, std::nullopt}, {2, std::nullopt, 2}, {3, 3, 3}}},
+      // Mixed edge values with nulls
+      {{{std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max()},
+        {0, std::nullopt, 0},
+        {100, 50, std::nullopt}}},
+      // Nulls with zeros and boundaries
+      {{{std::nullopt, 0, std::numeric_limits<int8_t>::max()},
+        {0, std::nullopt, std::numeric_limits<int8_t>::min()},
+        {0, 0, 0}}},
+      // Nulls with positive and negative including extremes
+      {{{std::nullopt, -5, std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::min(), std::nullopt, 10},
+        {std::nullopt, -15, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1, 1, std::nullopt, std::nullopt},
+        {2, 2, 2, std::nullopt},
+        {3, std::nullopt, 3, 3}}},
+      // Ascending order with nulls and max values
+      {{{std::nullopt, 1, 2, std::numeric_limits<int8_t>::max(), std::nullopt},
+        {10, std::nullopt, 20, std::nullopt, 30},
+        {std::nullopt, std::nullopt, 100, 50, 25}}},
+      // Descending order with nulls and min values
+      {{{std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         2,
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt},
+        {30, std::nullopt, 20, std::nullopt, 10},
+        {std::nullopt, std::nullopt, 100, 50, 25}}},
+      // Only first column has nulls with boundaries
+      {{{std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max()},
+        {10, 20, 30, 40},
+        {5, 6, 7, 8}}},
+      // Only middle column has nulls
+      {{{1, 2, 3, 4}, {std::nullopt, std::nullopt, 10, 20}, {100, 50, 25, 10}}},
+      // Only last column has nulls with max
+      {{{1, 2, 3, std::numeric_limits<int8_t>::max()},
+        {10, 20, 30, 40},
+        {std::nullopt, std::nullopt, 100, std::numeric_limits<int8_t>::min()}}},
+      // All columns have at least one null mixed with extremes
+      {{{std::nullopt, std::numeric_limits<int8_t>::max(), 2, 3, 4},
+        {1, std::nullopt, std::numeric_limits<int8_t>::min(), 3, 4},
+        {1, 2, std::nullopt, std::numeric_limits<int8_t>::max(), 4}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1}, {100, 100}, {50, 50}}},
+      // Large spread with nulls and boundaries (within int8 range)
+      {{{std::nullopt,
+         -120,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt},
+        {100, std::nullopt, 0, std::nullopt, -100},
+        {std::nullopt, 42, std::nullopt, 42, std::nullopt}}},
+      // Mix of nulls and regular values testing sort order
+      {{{std::nullopt, std::nullopt, 0, 0},
+        {std::nullopt, 1, std::nullopt, 1},
+        {2, std::nullopt, 2, std::nullopt}}},
+      // Max and min together in different positions
+      {{{std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::min()},
+        {std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int8_t>::max()}}},
+      // Adjacent to max with nulls (max-1, max)
+      {{{std::numeric_limits<int8_t>::max() - 1,
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::max() - 1,
+         std::numeric_limits<int8_t>::max()},
+        {std::numeric_limits<int8_t>::max(),
+         std::nullopt,
+         std::numeric_limits<int8_t>::max() - 1}}},
+      // Adjacent to min with nulls (min, min+1)
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min() + 1,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min() + 1},
+        {std::numeric_limits<int8_t>::min() + 1,
+         std::nullopt,
+         std::numeric_limits<int8_t>::min()}}},
+      // Boundary transitions with nulls (min, null, 0, null, max)
+      {{{std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         0,
+         std::nullopt,
+         std::numeric_limits<int8_t>::max()},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt},
+        {0, 0, 0, 0, 0}}},
+      // Duplicate max values with nulls
+      {{{std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::max(),
+         std::numeric_limits<int8_t>::max(),
+         std::nullopt},
+        {std::numeric_limits<int8_t>::max(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int8_t>::max()}}},
+      // Duplicate min values with nulls
+      {{{std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<int8_t>::min(),
+         std::numeric_limits<int8_t>::min(),
+         std::nullopt},
+        {std::numeric_limits<int8_t>::min(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<int8_t>::min()}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<int8_t>(testCase.columnValues[0]),
+         makeNullableFlatVector<int8_t>(testCase.columnValues[1]),
+         makeNullableFlatVector<int8_t>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, doubleTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<double>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(std::to_string(column[row]));
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1.0}, {2.0}, {3.0}}},
+      // All same values
+      {{{5.5, 5.5, 5.5}, {10.5, 10.5, 10.5}, {15.5, 15.5, 15.5}}},
+      // Ascending order
+      {{{1.1, 2.2, 3.3, 4.4},
+        {100.5, 100.5, 100.5, 100.5},
+        {50.5, 50.5, 50.5, 50.5}}},
+      // Descending order
+      {{{10.9, 9.8, 8.7, 7.6}, {0.0, 0.0, 0.0, 0.0}, {5.5, 5.5, 5.5, 5.5}}},
+      // Mixed positive and negative values
+      {{{-5.5, 0.0, 5.5}, {-10.5, -5.5, 0.0}, {10.5, 5.5, 0.0}}},
+      // All zeros
+      {{{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}}},
+      // Positive and negative zero
+      {{{0.0, -0.0, 0.0}, {-0.0, 0.0, -0.0}, {0.0, 0.0, 0.0}}},
+      // Positive infinity
+      {{{std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {1.0, 2.0},
+        {3.0, 4.0}}},
+      // Negative infinity
+      {{{-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()},
+        {1.0, 2.0},
+        {3.0, 4.0}}},
+      // Mix of infinity and regular values
+      {{{-std::numeric_limits<double>::infinity(),
+         0.0,
+         std::numeric_limits<double>::infinity()},
+        {-1.0, 0.0, 1.0},
+        {100.0, 200.0, 300.0}}},
+      // Both infinities together
+      {{{-std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()},
+        {0.0, 0.0}}},
+      // Edge values with infinity
+      {{{-std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::min(),
+         0.0,
+         std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::infinity()},
+        {1.0, 2.0, 3.0, 4.0, 5.0, 6.0},
+        {10.0, 20.0, 30.0, 40.0, 50.0, 60.0}}},
+      // All positive infinity
+      {{{std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()}}},
+      // All negative infinity
+      {{{-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()},
+        {-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()},
+        {-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity()}}},
+      // Max values
+      {{{std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::max()},
+        {std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::max()},
+        {std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::max()}}},
+      // Min positive values
+      {{{std::numeric_limits<double>::min(),
+         std::numeric_limits<double>::min()},
+        {std::numeric_limits<double>::min(),
+         std::numeric_limits<double>::min()},
+        {std::numeric_limits<double>::min(),
+         std::numeric_limits<double>::min()}}},
+      // Lowest values (most negative)
+      {{{std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()},
+        {std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()},
+        {std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::lowest()}}},
+      // Mix of max, min, and infinity
+      {{{-std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::lowest(),
+         std::numeric_limits<double>::max(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::min(), 0.0, 1.0, 2.0},
+        {-1.0, -2.0, -3.0, -4.0}}},
+      // Very small and very large values
+      {{{-1e308, -1e100, -1e-308, 0.0, 1e-308, 1e100, 1e308},
+        {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0},
+        {2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0}}},
+      // Fractional values
+      {{{0.1, 0.01, 0.001, 0.0001},
+        {-0.1, -0.01, -0.001, -0.0001},
+        {1.5, 2.5, 3.5, 4.5}}},
+      // Values differing only in last column
+      {{{1.5, 1.5, 1.5}, {2.5, 2.5, 2.5}, {3.5, 4.5, 5.5}}},
+      // Values differing only in first column
+      {{{1.5, 2.5, 3.5}, {100.5, 100.5, 100.5}, {200.5, 200.5, 200.5}}},
+      {{{1.0f, 0.0f, -0.0f}, {0.0f, 1.0f, 0.0f}, {-0.0f, 0.0f, 1.0f}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<double>(testCase.columnValues[0]),
+         makeFlatVector<double>(testCase.columnValues[1]),
+         makeFlatVector<double>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, doubleTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<double>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1.0}, {2.0}}},
+      // Single row without null (nullable type)
+      {{{1.0}, {2.0}, {3.0}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with infinity
+      {{{std::nullopt, 1.0, std::numeric_limits<double>::infinity()},
+        {10.0, 20.0, 30.0},
+        {100.0, 200.0, 300.0}}},
+      // Null at end with negative infinity
+      {{{1.0, -std::numeric_limits<double>::infinity(), std::nullopt},
+        {10.0, 20.0, 30.0},
+        {100.0, 200.0, 300.0}}},
+      // Null in middle
+      {{{1.0, std::nullopt, 2.0}, {10.0, 20.0, 30.0}, {100.0, 200.0, 300.0}}},
+      // Nulls with both infinities
+      {{{std::nullopt,
+         -std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()},
+        {0.0, 1.0, std::nullopt}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1.0, 2.0},
+        {std::nullopt, 1.0, 2.0},
+        {std::nullopt, 1.0, 2.0}}},
+      // Alternating null and non-null with infinities
+      {{{std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         2.0,
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()},
+        {10.0, 10.0, 10.0, 10.0, 10.0, 10.0},
+        {20.0, 20.0, 20.0, 20.0, 20.0, 20.0}}},
+      // Same values, different null positions
+      {{{1.5, 1.5, std::nullopt}, {2.5, std::nullopt, 2.5}, {3.5, 3.5, 3.5}}},
+      // Nulls with zeros
+      {{{std::nullopt, 0.0, std::nullopt},
+        {0.0, std::nullopt, 0.0},
+        {0.0, 0.0, 0.0}}},
+      // Nulls with positive and negative values
+      {{{std::nullopt, -5.5, 5.5},
+        {-10.5, std::nullopt, 10.5},
+        {std::nullopt, -15.5, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1.5, 1.5, std::nullopt, std::nullopt},
+        {2.5, 2.5, 2.5, std::nullopt},
+        {3.5, std::nullopt, 3.5, 3.5}}},
+      // Ascending order with nulls and infinity
+      {{{std::nullopt,
+         1.0,
+         2.0,
+         std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {10.0, std::nullopt, 20.0, std::nullopt, 30.0},
+        {std::nullopt, std::nullopt, 100.0, 200.0, 300.0}}},
+      // Descending order with nulls and negative infinity
+      {{{std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         2.0,
+         -std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {30.0, std::nullopt, 20.0, std::nullopt, 10.0},
+        {std::nullopt, std::nullopt, 300.0, 200.0, 100.0}}},
+      // Only first column has nulls with infinities
+      {{{std::nullopt,
+         std::nullopt,
+         -std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity()},
+        {10.0, 20.0, 30.0, 40.0},
+        {5.0, 6.0, 7.0, 8.0}}},
+      // Only middle column has nulls
+      {{{1.0, 2.0, 3.0, 4.0},
+        {std::nullopt, std::nullopt, 10.0, 20.0},
+        {100.0, 200.0, 300.0, 400.0}}},
+      // Only last column has nulls with infinity
+      {{{1.0, 2.0, 3.0, std::numeric_limits<double>::infinity()},
+        {10.0, 20.0, 30.0, 40.0},
+        {std::nullopt,
+         std::nullopt,
+         100.0,
+         -std::numeric_limits<double>::infinity()}}},
+      // All columns have at least one null mixed with infinities
+      {{{std::nullopt, std::numeric_limits<double>::infinity(), 2.0, 3.0, 4.0},
+        {1.0, std::nullopt, -std::numeric_limits<double>::infinity(), 3.0, 4.0},
+        {1.0,
+         2.0,
+         std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         4.0}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1.0}, {100.0, 100.0}, {200.0, 200.0}}},
+      // Mix of null, infinity, and regular values
+      {{{std::nullopt,
+         -std::numeric_limits<double>::infinity(),
+         0.0,
+         std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         0.0,
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()},
+        {std::nullopt, 1.0, std::nullopt, 2.0, std::nullopt}}},
+      // All positive infinity with nulls
+      {{{std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<double>::infinity()}}},
+      // All negative infinity with nulls
+      {{{-std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         -std::numeric_limits<double>::infinity(),
+         -std::numeric_limits<double>::infinity(),
+         std::nullopt},
+        {-std::numeric_limits<double>::infinity(),
+         std::nullopt,
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()}}},
+      // Max values with nulls
+      {{{std::nullopt, std::numeric_limits<double>::max(), std::nullopt},
+        {std::numeric_limits<double>::max(),
+         std::nullopt,
+         std::numeric_limits<double>::max()},
+        {std::nullopt, std::nullopt, std::numeric_limits<double>::max()}}},
+      // Lowest values with nulls
+      {{{std::nullopt, std::numeric_limits<double>::lowest(), std::nullopt},
+        {std::numeric_limits<double>::lowest(),
+         std::nullopt,
+         std::numeric_limits<double>::lowest()},
+        {std::nullopt, std::nullopt, std::numeric_limits<double>::lowest()}}},
+      // Mix of max, lowest, infinity and nulls
+      {{{std::nullopt,
+         std::numeric_limits<double>::infinity(),
+         std::numeric_limits<double>::max()},
+        {std::numeric_limits<double>::lowest(),
+         std::nullopt,
+         -std::numeric_limits<double>::infinity()},
+        {0.0, 1.0, std::nullopt}}},
+      // Very small and very large values with nulls
+      {{{std::nullopt, 1e-308, 1e308, std::nullopt},
+        {1e308, std::nullopt, -1e308, -1e-308},
+        {std::nullopt, 0.0f, std::nullopt, 0.0f}}},
+      // Positive and negative zero with nulls
+      {{{std::nullopt, 0.0, -0.0f},
+        {0.0f, std::nullopt, 0.0f},
+        {-0.0f, 0.0f, std::nullopt}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<double>(testCase.columnValues[0]),
+         makeNullableFlatVector<double>(testCase.columnValues[1]),
+         makeNullableFlatVector<double>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, floatTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<float>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(std::to_string(column[row]));
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{1.0f}, {2.0f}, {3.0f}}},
+      // All same values
+      {{{5.5f, 5.5f, 5.5f}, {10.5f, 10.5f, 10.5f}, {15.5f, 15.5f, 15.5f}}},
+      // Ascending order
+      {{{1.1f, 2.2f, 3.3f, 4.4f},
+        {100.5f, 100.5f, 100.5f, 100.5f},
+        {50.5f, 50.5f, 50.5f, 50.5f}}},
+      // Descending order
+      {{{10.9f, 9.8f, 8.7f, 7.6f},
+        {0.0f, 0.0f, 0.0f, 0.0f},
+        {5.5f, 5.5f, 5.5f, 5.5f}}},
+      // Mixed positive and negative values
+      {{{-5.5f, 0.0f, 5.5f}, {-10.5f, -5.5f, 0.0f}, {10.5f, 5.5f, 0.0f}}},
+      // All zeros
+      {{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}}},
+      // Positive and negative zero
+      {{{0.0f, -0.0f, 0.0f}, {-0.0f, 0.0f, -0.0f}, {0.0f, 0.0f, 0.0f}}},
+      // Positive infinity
+      {{{std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {1.0f, 2.0f},
+        {3.0f, 4.0f}}},
+      // Negative infinity
+      {{{-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()},
+        {1.0f, 2.0f},
+        {3.0f, 4.0f}}},
+      // Mix of infinity and regular values
+      {{{-std::numeric_limits<float>::infinity(),
+         0.0f,
+         std::numeric_limits<float>::infinity()},
+        {-1.0f, 0.0f, 1.0f},
+        {100.0f, 200.0f, 300.0f}}},
+      // Both infinities together
+      {{{-std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()},
+        {0.0f, 0.0f}}},
+      // Edge values with infinity
+      {{{-std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::min(),
+         0.0f,
+         std::numeric_limits<float>::max(),
+         std::numeric_limits<float>::infinity()},
+        {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f},
+        {10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f}}},
+      // All positive infinity
+      {{{std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()}}},
+      // All negative infinity
+      {{{-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()},
+        {-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()},
+        {-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity()}}},
+      // Max values
+      {{{std::numeric_limits<float>::max(), std::numeric_limits<float>::max()},
+        {std::numeric_limits<float>::max(), std::numeric_limits<float>::max()},
+        {std::numeric_limits<float>::max(),
+         std::numeric_limits<float>::max()}}},
+      // Min positive values
+      {{{std::numeric_limits<float>::min(), std::numeric_limits<float>::min()},
+        {std::numeric_limits<float>::min(), std::numeric_limits<float>::min()},
+        {std::numeric_limits<float>::min(),
+         std::numeric_limits<float>::min()}}},
+      // Lowest values (most negative)
+      {{{std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()},
+        {std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()},
+        {std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::lowest()}}},
+      // Mix of max, min, and infinity
+      {{{-std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::lowest(),
+         std::numeric_limits<float>::max(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::min(), 0.0f, 1.0f, 2.0f},
+        {-1.0f, -2.0f, -3.0f, -4.0f}}},
+      // Very small and very large values
+      {{{-1e38f, -1e10f, -1e-38f, 0.0f, 1e-38f, 1e10f, 1e38f},
+        {1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f},
+        {2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f}}},
+      // Fractional values
+      {{{0.1f, 0.01f, 0.001f, 0.0001f},
+        {-0.1f, -0.01f, -0.001f, -0.0001f},
+        {1.5f, 2.5f, 3.5f, 4.5f}}},
+      // Values differing only in last column
+      {{{1.5f, 1.5f, 1.5f}, {2.5f, 2.5f, 2.5f}, {3.5f, 4.5f, 5.5f}}},
+      // Values differing only in first column
+      {{{1.5f, 2.5f, 3.5f},
+        {100.5f, 100.5f, 100.5f},
+        {200.5f, 200.5f, 200.5f}}},
+      {{{1.0f, 0.0f, -0.0f}, {0.0f, 1.0f, 0.0f}, {-0.0f, 0.0f, 1.0f}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<float>(testCase.columnValues[0]),
+         makeFlatVector<float>(testCase.columnValues[1]),
+         makeFlatVector<float>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, floatTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<float>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(std::to_string(column[row].value()));
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {1.0f}, {2.0f}}},
+      // Single row without null (nullable type)
+      {{{1.0f}, {2.0f}, {3.0f}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning with infinity
+      {{{std::nullopt, 1.0f, std::numeric_limits<float>::infinity()},
+        {10.0f, 20.0f, 30.0f},
+        {100.0f, 200.0f, 300.0f}}},
+      // Null at end with negative infinity
+      {{{1.0f, -std::numeric_limits<float>::infinity(), std::nullopt},
+        {10.0f, 20.0f, 30.0f},
+        {100.0f, 200.0f, 300.0f}}},
+      // Null in middle
+      {{{1.0f, std::nullopt, 2.0f},
+        {10.0f, 20.0f, 30.0f},
+        {100.0f, 200.0f, 300.0f}}},
+      // Nulls with both infinities
+      {{{std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()},
+        {0.0f, 1.0f, std::nullopt}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, 1.0f, 2.0f},
+        {std::nullopt, 1.0f, 2.0f},
+        {std::nullopt, 1.0f, 2.0f}}},
+      // Alternating null and non-null with infinities
+      {{{std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         2.0f,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()},
+        {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f},
+        {20.0f, 20.0f, 20.0f, 20.0f, 20.0f, 20.0f}}},
+      // Same values, different null positions
+      {{{1.5f, 1.5f, std::nullopt},
+        {2.5f, std::nullopt, 2.5f},
+        {3.5f, 3.5f, 3.5f}}},
+      // Nulls with zeros
+      {{{std::nullopt, 0.0f, std::nullopt},
+        {0.0f, std::nullopt, 0.0f},
+        {0.0f, 0.0f, 0.0f}}},
+      // Nulls with positive and negative values
+      {{{std::nullopt, -5.5f, 5.5f},
+        {-10.5f, std::nullopt, 10.5f},
+        {std::nullopt, -15.5f, std::nullopt}}},
+      // Duplicate non-null values with nulls
+      {{{1.5f, 1.5f, std::nullopt, std::nullopt},
+        {2.5f, 2.5f, 2.5f, std::nullopt},
+        {3.5f, std::nullopt, 3.5f, 3.5f}}},
+      // Ascending order with nulls and infinity
+      {{{std::nullopt,
+         1.0f,
+         2.0f,
+         std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {10.0f, std::nullopt, 20.0f, std::nullopt, 30.0f},
+        {std::nullopt, std::nullopt, 100.0f, 200.0f, 300.0f}}},
+      // Descending order with nulls and negative infinity
+      {{{std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         2.0f,
+         -std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {30.0f, std::nullopt, 20.0f, std::nullopt, 10.0f},
+        {std::nullopt, std::nullopt, 300.0f, 200.0f, 100.0f}}},
+      // Only first column has nulls with infinities
+      {{{std::nullopt,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity()},
+        {10.0f, 20.0f, 30.0f, 40.0f},
+        {5.0f, 6.0f, 7.0f, 8.0f}}},
+      // Only middle column has nulls
+      {{{1.0f, 2.0f, 3.0f, 4.0f},
+        {std::nullopt, std::nullopt, 10.0f, 20.0f},
+        {100.0f, 200.0f, 300.0f, 400.0f}}},
+      // Only last column has nulls with infinity
+      {{{1.0f, 2.0f, 3.0f, std::numeric_limits<float>::infinity()},
+        {10.0f, 20.0f, 30.0f, 40.0f},
+        {std::nullopt,
+         std::nullopt,
+         100.0f,
+         -std::numeric_limits<float>::infinity()}}},
+      // All columns have at least one null mixed with infinities
+      {{{std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         2.0f,
+         3.0f,
+         4.0f},
+        {1.0f,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         3.0f,
+         4.0f},
+        {1.0f,
+         2.0f,
+         std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         4.0f}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, 1.0f}, {100.0f, 100.0f}, {200.0f, 200.0f}}},
+      // Mix of null, infinity, and regular values
+      {{{std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         0.0f,
+         std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         0.0f,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()},
+        {std::nullopt, 1.0f, std::nullopt, 2.0f, std::nullopt}}},
+      // All positive infinity with nulls
+      {{{std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         std::nullopt,
+         std::numeric_limits<float>::infinity()}}},
+      // All negative infinity with nulls
+      {{{-std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         std::nullopt},
+        {std::nullopt,
+         -std::numeric_limits<float>::infinity(),
+         -std::numeric_limits<float>::infinity(),
+         std::nullopt},
+        {-std::numeric_limits<float>::infinity(),
+         std::nullopt,
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()}}},
+      // Max values with nulls
+      {{{std::nullopt, std::numeric_limits<float>::max(), std::nullopt},
+        {std::numeric_limits<float>::max(),
+         std::nullopt,
+         std::numeric_limits<float>::max()},
+        {std::nullopt, std::nullopt, std::numeric_limits<float>::max()}}},
+      // Lowest values with nulls
+      {{{std::nullopt, std::numeric_limits<float>::lowest(), std::nullopt},
+        {std::numeric_limits<float>::lowest(),
+         std::nullopt,
+         std::numeric_limits<float>::lowest()},
+        {std::nullopt, std::nullopt, std::numeric_limits<float>::lowest()}}},
+      // Mix of max, lowest, infinity and nulls
+      {{{std::nullopt,
+         std::numeric_limits<float>::infinity(),
+         std::numeric_limits<float>::max()},
+        {std::numeric_limits<float>::lowest(),
+         std::nullopt,
+         -std::numeric_limits<float>::infinity()},
+        {0.0f, 1.0f, std::nullopt}}},
+      // Very small and very large values with nulls
+      {{{std::nullopt, 1e-38f, 1e38f, std::nullopt},
+        {1e38f, std::nullopt, -1e38f, -1e-38f},
+        {std::nullopt, 0.0f, std::nullopt, 0.0f}}},
+      // Positive and negative zero with nulls
+      {{{std::nullopt, 0.0f, -0.0f},
+        {0.0f, std::nullopt, 0.0f},
+        {-0.0f, 0.0f, std::nullopt}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<float>(testCase.columnValues[0]),
+         makeNullableFlatVector<float>(testCase.columnValues[1]),
+         makeNullableFlatVector<float>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, booleanTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<bool>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row] ? "true" : "false");
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row (true)
+      {{{true}, {false}, {true}}},
+      // Single row (false)
+      {{{false}, {true}, {false}}},
+      // All true values
+      {{{true, true, true}, {true, true, true}, {true, true, true}}},
+      // All false values
+      {{{false, false, false}, {false, false, false}, {false, false, false}}},
+      // Mixed true/false values
+      {{{true, false, true, false},
+        {false, true, false, true},
+        {true, true, false, false}}},
+      // Alternating true/false
+      {{{true, false, true, false},
+        {false, true, false, true},
+        {true, false, true, false}}},
+      // Values differing only in last column
+      {{{true, true, true}, {false, false, false}, {true, false, true}}},
+      // Values differing only in first column
+      {{{true, false, true}, {false, false, false}, {true, true, true}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<bool>(testCase.columnValues[0]),
+         makeFlatVector<bool>(testCase.columnValues[1]),
+         makeFlatVector<bool>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, booleanTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<bool>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(column[row].value() ? "true" : "false");
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single null
+      {{{std::nullopt}, {true}, {false}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt}}},
+      // Null with true
+      {{{std::nullopt, true}, {true, false}, {false, true}}},
+      // Null with false
+      {{{std::nullopt, false}, {false, true}, {true, false}}},
+      // Nulls at different positions
+      {{{std::nullopt, true, false},
+        {true, std::nullopt, false},
+        {true, false, std::nullopt}}},
+      // Alternating null/true/false
+      {{{std::nullopt, true, false, std::nullopt},
+        {true, std::nullopt, true, false},
+        {false, true, std::nullopt, true}}},
+      // Only first column has nulls
+      {{{std::nullopt, std::nullopt, true},
+        {true, false, true},
+        {false, true, false}}},
+      // Only middle column has nulls
+      {{{true, false, true},
+        {std::nullopt, std::nullopt, true},
+        {false, true, false}}},
+      // Only last column has nulls
+      {{{true, false, true},
+        {false, true, false},
+        {std::nullopt, std::nullopt, true}}},
+      // All columns have at least one null
+      {{{std::nullopt, true, false},
+        {true, std::nullopt, false},
+        {true, false, std::nullopt}}},
+      // Mix of null/true/false values
+      {{{std::nullopt, true, false, std::nullopt},
+        {true, std::nullopt, false, true},
+        {false, true, std::nullopt, false}}},
+      // Null vs non-null with same other column values
+      {{{std::nullopt, true}, {false, false}, {true, true}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<bool>(testCase.columnValues[0]),
+         makeNullableFlatVector<bool>(testCase.columnValues[1]),
+         makeNullableFlatVector<bool>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, stringTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<std::string>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(fmt::format("'{}'", column[row]));
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{"apple"}, {"dog"}, {"x"}}},
+      // All same values
+      {{{"same", "same", "same"},
+        {"same", "same", "same"},
+        {"same", "same", "same"}}},
+      // Ascending order (lexicographically)
+      {{{"a", "b", "c", "d"},
+        {"alpha", "alpha", "alpha", "alpha"},
+        {"x", "x", "x", "x"}}},
+      // Descending order (lexicographically)
+      {{{"zebra", "yak", "xray", "wolf"},
+        {"delta", "delta", "delta", "delta"},
+        {"z", "z", "z", "z"}}},
+      // Empty string as minimum
+      {{{"", "a", "aa", "aaa"},
+        {"empty", "empty", "empty", "empty"},
+        {"test", "test", "test", "test"}}},
+      // Empty strings
+      {{{"", "", ""}, {"", "", ""}, {"", "", ""}}},
+      // Single character strings
+      {{{"a", "b", "c"}, {"x", "y", "z"}, {"1", "2", "3"}}},
+      // Multi-character strings
+      {{{"apple", "banana", "cherry"},
+        {"dog", "elephant", "fox"},
+        {"red", "green", "blue"}}},
+      // Strings with spaces
+      {{{"hello world", "foo bar", "test case"},
+        {"space test", "another test", "final test"},
+        {"a b c", "x y z", "1 2 3"}}},
+      // Strings with special characters
+      {{{"hello!", "world?", "test@"},
+        {"special#", "chars$", "here%"},
+        {"more^", "symbols&", "data*"}}},
+      // Strings differing only in case
+      {{{"apple", "Apple", "APPLE"},
+        {"test", "test", "test"},
+        {"value", "value", "value"}}},
+      // Strings differing only in length
+      {{{"a", "aa", "aaa"}, {"b", "bb", "bbb"}, {"c", "cc", "ccc"}}},
+      // Strings differing only in last character
+      {{{"testa", "testb", "testc"},
+        {"valuex", "valuey", "valuez"},
+        {"item1", "item2", "item3"}}},
+      // Very long strings
+      {{{"this_is_a_very_long_string_that_contains_many_characters_to_test_encoding",
+         "another_extremely_long_string_with_different_content_for_testing_purposes",
+         "yet_another_long_string_to_ensure_proper_handling_of_large_data"},
+        {"long_value_1", "long_value_2", "long_value_3"},
+        {"x", "y", "z"}}},
+      // Strings with numbers
+      {{{"test123", "value456", "item789"},
+        {"abc123", "def456", "ghi789"},
+        {"1a2b3c", "4d5e6f", "7g8h9i"}}},
+      // Strings with unicode characters (if supported)
+      {{{"café", "naïve", "résumé"},
+        {"hello", "world", "test"},
+        {"α", "β", "γ"}}},
+      // Duplicate strings
+      {{{"apple", "apple", "banana", "banana"},
+        {"test", "test", "value", "value"},
+        {"x", "y", "x", "y"}}},
+      // Prefixes of each other
+      {{{"a", "ab", "abc", "abcd"},
+        {"test", "test", "test", "test"},
+        {"x", "x", "x", "x"}}},
+      // Mixed empty and non-empty
+      {{{"", "a", "", "b"},
+        {"empty", "", "mixed", ""},
+        {"test", "test", "", ""}}},
+      // Strings with tabs and newlines
+      {{{"hello\tworld", "test\ncase", "value\r\ndata"},
+        {"tab\there", "new\nline", "return\rchar"},
+        {"a", "b", "c"}}},
+      // Numeric strings (lexicographic vs numeric order)
+      {{{"1", "10", "2", "20"},
+        {"100", "200", "300", "400"},
+        {"a", "b", "c", "d"}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<std::string_view>(std::vector<std::string_view>(
+             testCase.columnValues[0].begin(), testCase.columnValues[0].end())),
+         makeFlatVector<std::string_view>(std::vector<std::string_view>(
+             testCase.columnValues[1].begin(), testCase.columnValues[1].end())),
+         makeFlatVector<std::string_view>(std::vector<std::string_view>(
+             testCase.columnValues[2].begin(),
+             testCase.columnValues[2].end()))});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, stringTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<std::string>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(fmt::format("'{}'", column[row].value()));
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single null
+      {{{std::nullopt}, {"test"}, {"value"}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null with empty string
+      {{{std::nullopt, ""}, {"test", "test"}, {"value", "value"}}},
+      // Null with non-empty strings
+      {{{std::nullopt, "apple", "banana"},
+        {"test", "test", "test"},
+        {"x", "y", "z"}}},
+      // Nulls at different positions (beginning, middle, end)
+      {{{std::nullopt, "a", "b", "c"},
+        {"a", std::nullopt, "b", "c"},
+        {"a", "b", std::nullopt, "c"}}},
+      // Empty string vs null
+      {{{std::nullopt, "", "a"}, {"", std::nullopt, "a"}, {"a", "a", "a"}}},
+      // Nulls with various string lengths
+      {{{std::nullopt, "a", "ab", "abc"},
+        {"test", std::nullopt, "testing", "t"},
+        {"x", "y", std::nullopt, "z"}}},
+      // Duplicate strings with nulls
+      {{{std::nullopt, "apple", "apple", std::nullopt},
+        {"test", std::nullopt, "test", std::nullopt},
+        {"x", "x", std::nullopt, "x"}}},
+      // Ascending with nulls
+      {{{std::nullopt, "a", "b", "c"},
+        {"alpha", std::nullopt, "beta", "gamma"},
+        {std::nullopt, "x", "y", "z"}}},
+      // Descending with nulls
+      {{{std::nullopt, "zebra", "yak", "wolf"},
+        {"delta", std::nullopt, "charlie", "bravo"},
+        {std::nullopt, "z", "y", "x"}}},
+      // Only first column has nulls
+      {{{std::nullopt, std::nullopt, "a", "b"},
+        {"test1", "test2", "test3", "test4"},
+        {"x", "y", "z", "w"}}},
+      // Only middle column has nulls
+      {{{"apple", "banana", "cherry"},
+        {std::nullopt, std::nullopt, "test"},
+        {"x", "y", "z"}}},
+      // Only last column has nulls
+      {{{"apple", "banana", "cherry"},
+        {"dog", "elephant", "fox"},
+        {std::nullopt, std::nullopt, "red"}}},
+      // All columns have at least one null
+      {{{std::nullopt, "a", "b", "c"},
+        {"test", std::nullopt, "value", "data"},
+        {"x", "y", std::nullopt, "z"}}},
+      // All columns have nulls in same rows
+      {{{std::nullopt, "a", std::nullopt, "c"},
+        {std::nullopt, "test", std::nullopt, "value"},
+        {std::nullopt, "x", std::nullopt, "z"}}},
+      // Null vs non-null with same other values
+      {{{std::nullopt, "apple"}, {"test", "test"}, {"value", "value"}}},
+      // Mix of empty string, null, and regular strings
+      {{{std::nullopt, "", "a", "apple"},
+        {"", std::nullopt, "b", "banana"},
+        {"test", "test", std::nullopt, ""}}},
+      // Nulls with strings containing spaces
+      {{{std::nullopt, "hello world", "foo bar"},
+        {"test case", std::nullopt, "another test"},
+        {std::nullopt, "a b c", std::nullopt}}},
+      // Nulls with strings containing special characters
+      {{{std::nullopt, "hello!", "world?"},
+        {"special#", std::nullopt, "chars$"},
+        {"more^", std::nullopt, "data*"}}},
+      // Nulls with strings differing only in case
+      {{{std::nullopt, "apple", "Apple", "APPLE"},
+        {"test", std::nullopt, "test", "test"},
+        {"value", "value", std::nullopt, "value"}}},
+      // Nulls with strings differing only in length
+      {{{std::nullopt, "a", "aa", "aaa"},
+        {"b", std::nullopt, "bb", "bbb"},
+        {"c", "cc", std::nullopt, "ccc"}}},
+      // Nulls with very long strings
+      {{{std::nullopt,
+         "this_is_a_very_long_string_that_contains_many_characters",
+         "another_long_string"},
+        {"test", std::nullopt, "value"},
+        {"x", "y", std::nullopt}}},
+      // Nulls with strings containing numbers
+      {{{std::nullopt, "test123", "value456"},
+        {"abc123", std::nullopt, "def456"},
+        {"1a2b3c", "4d5e6f", std::nullopt}}},
+      // Nulls with unicode characters
+      {{{std::nullopt, "café", "naïve"},
+        {"hello", std::nullopt, "world"},
+        {"α", "β", std::nullopt}}},
+      // Nulls with prefixes
+      {{{std::nullopt, "a", "ab", "abc"},
+        {"test", std::nullopt, "test", "test"},
+        {"x", "x", std::nullopt, "x"}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, "a", std::nullopt},
+        {std::nullopt, "b", std::nullopt},
+        {std::nullopt, "c", std::nullopt}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+
+    // Convert std::optional<std::string> to std::optional<std::string_view>
+    std::vector<std::optional<std::string_view>> col0, col1, col2;
+    for (const auto& val : testCase.columnValues[0]) {
+      col0.push_back(
+          val.has_value() ? std::optional<std::string_view>(val.value())
+                          : std::nullopt);
+    }
+    for (const auto& val : testCase.columnValues[1]) {
+      col1.push_back(
+          val.has_value() ? std::optional<std::string_view>(val.value())
+                          : std::nullopt);
+    }
+    for (const auto& val : testCase.columnValues[2]) {
+      col2.push_back(
+          val.has_value() ? std::optional<std::string_view>(val.value())
+                          : std::nullopt);
+    }
+
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<std::string_view>(col0),
+         makeNullableFlatVector<std::string_view>(col1),
+         makeNullableFlatVector<std::string_view>(col2)});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, timestampTypeWithoutNulls) {
+  struct {
+    std::vector<std::vector<velox::Timestamp>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          rowValues.push_back(column[row].toString());
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row
+      {{{velox::Timestamp(1, 0)},
+        {velox::Timestamp(2, 0)},
+        {velox::Timestamp(3, 0)}}},
+      // All same values
+      {{{velox::Timestamp(5, 100), velox::Timestamp(5, 100)},
+        {velox::Timestamp(10, 200), velox::Timestamp(10, 200)},
+        {velox::Timestamp(15, 300), velox::Timestamp(15, 300)}}},
+      // Ascending order in first column (by seconds)
+      {{{velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         velox::Timestamp(3, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(100, 0),
+         velox::Timestamp(100, 0)},
+        {velox::Timestamp(50, 0),
+         velox::Timestamp(50, 0),
+         velox::Timestamp(50, 0)}}},
+      // Descending order in first column (by seconds)
+      {{{velox::Timestamp(10, 0),
+         velox::Timestamp(9, 0),
+         velox::Timestamp(8, 0)},
+        {velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(5, 0),
+         velox::Timestamp(5, 0),
+         velox::Timestamp(5, 0)}}},
+      // Mixed positive and negative seconds
+      {{{velox::Timestamp(-5, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(5, 0)},
+        {velox::Timestamp(-10, 0),
+         velox::Timestamp(-5, 0),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(5, 0),
+         velox::Timestamp(0, 0)}}},
+      // Same seconds, different nanos
+      {{{velox::Timestamp(100, 1),
+         velox::Timestamp(100, 2),
+         velox::Timestamp(100, 3)},
+        {velox::Timestamp(200, 100),
+         velox::Timestamp(200, 200),
+         velox::Timestamp(200, 300)},
+        {velox::Timestamp(300, 999),
+         velox::Timestamp(300, 998),
+         velox::Timestamp(300, 997)}}},
+      // Edge values: valid min and max seconds for Timestamp
+      // kMinSeconds = INT64_MIN / 1000 - 1, kMaxSeconds = INT64_MAX / 1000
+      {{{velox::Timestamp::min(),
+         velox::Timestamp::max(),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(-1, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(1, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(300, 0)}}},
+      // All zeros
+      {{{velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0)},
+        {velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(0, 0)}}},
+      // Duplicate values across rows
+      {{{velox::Timestamp(1, 100),
+         velox::Timestamp(2, 200),
+         velox::Timestamp(1, 100),
+         velox::Timestamp(2, 200)},
+        {velox::Timestamp(3, 300),
+         velox::Timestamp(3, 300),
+         velox::Timestamp(4, 400),
+         velox::Timestamp(4, 400)},
+        {velox::Timestamp(5, 500),
+         velox::Timestamp(5, 500),
+         velox::Timestamp(5, 500),
+         velox::Timestamp(5, 500)}}},
+      // Large spread of values
+      {{{velox::Timestamp(-1000000, 0),
+         velox::Timestamp(-1, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(1, 0),
+         velox::Timestamp(1000000, 0)},
+        {velox::Timestamp(999999, 0),
+         velox::Timestamp(500000, 0),
+         velox::Timestamp(0, 0),
+         velox::Timestamp(-500000, 0),
+         velox::Timestamp(-999999, 0)},
+        {velox::Timestamp(42, 0),
+         velox::Timestamp(42, 0),
+         velox::Timestamp(42, 0),
+         velox::Timestamp(42, 0),
+         velox::Timestamp(42, 0)}}},
+      // Values that differ only in last column
+      {{{velox::Timestamp(1, 0),
+         velox::Timestamp(1, 0),
+         velox::Timestamp(1, 0)},
+        {velox::Timestamp(2, 0),
+         velox::Timestamp(2, 0),
+         velox::Timestamp(2, 0)},
+        {velox::Timestamp(3, 0),
+         velox::Timestamp(4, 0),
+         velox::Timestamp(5, 0)}}},
+      // Values that differ only in first column
+      {{{velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         velox::Timestamp(3, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(100, 0),
+         velox::Timestamp(100, 0)},
+        {velox::Timestamp(200, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(200, 0)}}},
+      // Nanos ordering within same second
+      {{{velox::Timestamp(1, 0),
+         velox::Timestamp(1, 500000000),
+         velox::Timestamp(1, 999999999)},
+        {velox::Timestamp(2, 999999999),
+         velox::Timestamp(2, 500000000),
+         velox::Timestamp(2, 0)},
+        {velox::Timestamp(3, 123456789),
+         velox::Timestamp(3, 123456789),
+         velox::Timestamp(3, 123456789)}}},
+      // All min values
+      {{{velox::Timestamp::min(),
+         velox::Timestamp::min(),
+         velox::Timestamp::min()},
+        {velox::Timestamp::min(),
+         velox::Timestamp::min(),
+         velox::Timestamp::min()},
+        {velox::Timestamp::min(),
+         velox::Timestamp::min(),
+         velox::Timestamp::min()}}},
+      // All max values
+      {{{velox::Timestamp::max(),
+         velox::Timestamp::max(),
+         velox::Timestamp::max()},
+        {velox::Timestamp::max(),
+         velox::Timestamp::max(),
+         velox::Timestamp::max()},
+        {velox::Timestamp::max(),
+         velox::Timestamp::max(),
+         velox::Timestamp::max()}}},
+      // Min to max range in single column
+      {{{velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()},
+        {velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()},
+        {velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()}}},
+      // Min and max with max nanos
+      {{{velox::Timestamp(velox::Timestamp::min().getSeconds(), 999999999),
+         velox::Timestamp(velox::Timestamp::max().getSeconds(), 999999999)},
+        {velox::Timestamp(velox::Timestamp::min().getSeconds(), 0),
+         velox::Timestamp(velox::Timestamp::max().getSeconds(), 0)},
+        {velox::Timestamp(0, 999999999), velox::Timestamp(0, 0)}}},
+      // Alternating min and max
+      {{{velox::Timestamp::min(),
+         velox::Timestamp::max(),
+         velox::Timestamp::min(),
+         velox::Timestamp::max()},
+        {velox::Timestamp::max(),
+         velox::Timestamp::min(),
+         velox::Timestamp::max(),
+         velox::Timestamp::min()},
+        {velox::Timestamp::min(),
+         velox::Timestamp::min(),
+         velox::Timestamp::max(),
+         velox::Timestamp::max()}}}};
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeFlatVector<velox::Timestamp>(testCase.columnValues[0]),
+         makeFlatVector<velox::Timestamp>(testCase.columnValues[1]),
+         makeFlatVector<velox::Timestamp>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, timestampTypeWithNulls) {
+  struct {
+    std::vector<std::vector<std::optional<velox::Timestamp>>> columnValues;
+
+    std::string debugString() const {
+      const size_t numRows = columnValues[0].size();
+      std::vector<std::string> rows;
+      rows.reserve(numRows);
+
+      for (size_t row = 0; row < numRows; ++row) {
+        std::vector<std::string> rowValues;
+        rowValues.reserve(columnValues.size());
+        for (const auto& column : columnValues) {
+          if (column[row].has_value()) {
+            rowValues.push_back(column[row].value().toString());
+          } else {
+            rowValues.push_back("null");
+          }
+        }
+        rows.push_back(fmt::format("{{{}}}", fmt::join(rowValues, ", ")));
+      }
+
+      return fmt::format("[{}]", fmt::join(rows, ", "));
+    }
+  } testCases[] = {
+      // Single row with null
+      {{{std::nullopt}, {velox::Timestamp(1, 0)}, {velox::Timestamp(2, 0)}}},
+      // Single row without null (nullable type)
+      {{{velox::Timestamp(1, 0)},
+        {velox::Timestamp(2, 0)},
+        {velox::Timestamp(3, 0)}}},
+      // All nulls
+      {{{std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt},
+        {std::nullopt, std::nullopt, std::nullopt}}},
+      // Null at beginning of first column
+      {{{std::nullopt, velox::Timestamp(1, 0), velox::Timestamp(2, 0)},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(20, 0),
+         velox::Timestamp(30, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(300, 0)}}},
+      // Null at end of first column
+      {{{velox::Timestamp(1, 0), velox::Timestamp(2, 0), std::nullopt},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(20, 0),
+         velox::Timestamp(30, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(300, 0)}}},
+      // Null in middle of first column
+      {{{velox::Timestamp(1, 0), std::nullopt, velox::Timestamp(2, 0)},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(20, 0),
+         velox::Timestamp(30, 0)},
+        {velox::Timestamp(100, 0),
+         velox::Timestamp(200, 0),
+         velox::Timestamp(300, 0)}}},
+      // Nulls in all positions across different columns
+      {{{std::nullopt,
+         velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         velox::Timestamp(3, 0)},
+        {velox::Timestamp(1, 0),
+         std::nullopt,
+         velox::Timestamp(2, 0),
+         velox::Timestamp(3, 0)},
+        {velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         std::nullopt,
+         velox::Timestamp(3, 0)}}},
+      // Multiple nulls in same row
+      {{{std::nullopt, velox::Timestamp(1, 0), velox::Timestamp(2, 0)},
+        {std::nullopt, velox::Timestamp(10, 0), velox::Timestamp(20, 0)},
+        {std::nullopt, velox::Timestamp(100, 0), velox::Timestamp(200, 0)}}},
+      // Alternating nulls and values
+      {{{std::nullopt,
+         velox::Timestamp(1, 0),
+         std::nullopt,
+         velox::Timestamp(2, 0)},
+        {velox::Timestamp(10, 0),
+         std::nullopt,
+         velox::Timestamp(20, 0),
+         std::nullopt},
+        {std::nullopt,
+         velox::Timestamp(100, 0),
+         std::nullopt,
+         velox::Timestamp(200, 0)}}},
+      // Nulls with valid edge values for Timestamp
+      // kMinSeconds = INT64_MIN / 1000 - 1, kMaxSeconds = INT64_MAX / 1000
+      {{{std::nullopt, velox::Timestamp::min(), velox::Timestamp::max()},
+        {velox::Timestamp(0, 0), std::nullopt, velox::Timestamp(1, 0)},
+        {velox::Timestamp(-1, 0), velox::Timestamp(0, 0), std::nullopt}}},
+      // Null with varying nanos
+      {{{std::nullopt,
+         velox::Timestamp(1, 100),
+         velox::Timestamp(1, 200),
+         velox::Timestamp(1, 300)},
+        {velox::Timestamp(2, 100),
+         std::nullopt,
+         velox::Timestamp(2, 200),
+         velox::Timestamp(2, 300)},
+        {velox::Timestamp(3, 100),
+         velox::Timestamp(3, 200),
+         std::nullopt,
+         velox::Timestamp(3, 300)}}},
+      // Dense nulls at boundaries
+      {{{std::nullopt,
+         std::nullopt,
+         velox::Timestamp(1, 0),
+         velox::Timestamp(2, 0),
+         std::nullopt,
+         std::nullopt},
+        {velox::Timestamp(10, 0),
+         velox::Timestamp(20, 0),
+         std::nullopt,
+         std::nullopt,
+         velox::Timestamp(30, 0),
+         velox::Timestamp(40, 0)},
+        {std::nullopt,
+         velox::Timestamp(100, 0),
+         std::nullopt,
+         velox::Timestamp(200, 0),
+         std::nullopt,
+         velox::Timestamp(300, 0)}}},
+      // All min values with some nulls
+      {{{velox::Timestamp::min(), std::nullopt, velox::Timestamp::min()},
+        {std::nullopt, velox::Timestamp::min(), velox::Timestamp::min()},
+        {velox::Timestamp::min(), velox::Timestamp::min(), std::nullopt}}},
+      // All max values with some nulls
+      {{{velox::Timestamp::max(), std::nullopt, velox::Timestamp::max()},
+        {std::nullopt, velox::Timestamp::max(), velox::Timestamp::max()},
+        {velox::Timestamp::max(), velox::Timestamp::max(), std::nullopt}}},
+      // Min to max range with nulls
+      {{{std::nullopt,
+         velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()},
+        {velox::Timestamp::min(),
+         std::nullopt,
+         velox::Timestamp(0, 0),
+         velox::Timestamp::max()},
+        {velox::Timestamp::min(),
+         velox::Timestamp(0, 0),
+         std::nullopt,
+         velox::Timestamp::max()}}},
+      // Min and max with max nanos and nulls
+      {{{std::nullopt,
+         velox::Timestamp(velox::Timestamp::min().getSeconds(), 999999999),
+         velox::Timestamp(velox::Timestamp::max().getSeconds(), 999999999)},
+        {velox::Timestamp(velox::Timestamp::min().getSeconds(), 0),
+         std::nullopt,
+         velox::Timestamp(velox::Timestamp::max().getSeconds(), 0)},
+        {velox::Timestamp(0, 999999999),
+         velox::Timestamp(0, 0),
+         std::nullopt}}},
+      // Alternating min, max and nulls
+      {{{velox::Timestamp::min(),
+         std::nullopt,
+         velox::Timestamp::max(),
+         std::nullopt},
+        {std::nullopt,
+         velox::Timestamp::max(),
+         std::nullopt,
+         velox::Timestamp::min()},
+        {velox::Timestamp::max(),
+         velox::Timestamp::min(),
+         std::nullopt,
+         std::nullopt}}},
+  };
+
+  for (const auto& testCase : testCases) {
+    SCOPED_TRACE(testCase.debugString());
+    ASSERT_EQ(testCase.columnValues.size(), 3);
+    const auto input = makeRowVector(
+        {makeNullableFlatVector<velox::Timestamp>(testCase.columnValues[0]),
+         makeNullableFlatVector<velox::Timestamp>(testCase.columnValues[1]),
+         makeNullableFlatVector<velox::Timestamp>(testCase.columnValues[2])});
+    const std::vector<std::string> keyColumns = {"c0", "c1", "c2"};
+
+    // Test all four sort orders (ASC/DESC x NULLS FIRST/NULLS LAST)
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, keyColumnsOutOfOrder) {
+  // Create a dataset with multiple columns of different types
+  // Columns: BIGINT, VARCHAR, DOUBLE, BOOLEAN, INTEGER, SMALLINT
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3, 4, 5}), // c0: BIGINT
+      makeFlatVector<std::string>(
+          {"apple", "banana", "cherry", "date", "elderberry"}), // c1: VARCHAR
+      makeFlatVector<double>({1.5, 2.5, 3.5, 4.5, 5.5}), // c2: DOUBLE
+      makeFlatVector<bool>({true, false, true, false, true}), // c3: BOOLEAN
+      makeFlatVector<int32_t>({10, 20, 30, 40, 50}), // c4: INTEGER
+      makeFlatVector<int16_t>({100, 200, 300, 400, 500}), // c5: SMALLINT
+  });
+
+  // Test various key column orderings to ensure KeyEncoder works correctly
+  // regardless of column order
+
+  // Original order - all columns
+  {
+    SCOPED_TRACE("Original order - all columns");
+    const std::vector<std::string> keyColumns = {
+        "c0", "c1", "c2", "c3", "c4", "c5"};
+    encodeTest({input}, keyColumns);
+  }
+
+  // Reverse order - all columns
+  {
+    SCOPED_TRACE("Reverse order - all columns");
+    const std::vector<std::string> keyColumns = {
+        "c5", "c4", "c3", "c2", "c1", "c0"};
+    encodeTest({input}, keyColumns);
+  }
+
+  // Random order - subset of columns
+  {
+    SCOPED_TRACE("Random order - subset of columns");
+    const std::vector<std::string> keyColumns = {"c2", "c5", "c0", "c3"};
+    encodeTest({input}, keyColumns);
+  }
+
+  // Another random order - different subset
+  {
+    SCOPED_TRACE("Another random order - different subset");
+    const std::vector<std::string> keyColumns = {"c4", "c1", "c3"};
+    encodeTest({input}, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, errorNonExistentColumn) {
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({4, 5, 6}),
+  });
+
+  const std::vector<std::string> keyColumns = {"c0", "nonexistent"};
+  const std::vector<velox::core::SortOrder> sortOrders = {
+      velox::core::kAscNullsFirst, velox::core::kAscNullsFirst};
+
+  VELOX_ASSERT_THROW(
+      KeyEncoder::create(
+          keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+      "Field not found");
+}
+
+TEST_F(KeyEncoderTest, errorMismatchedSortOrders) {
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({4, 5, 6}),
+  });
+
+  const std::vector<std::string> keyColumns = {"c0", "c1"};
+  const std::vector<velox::core::SortOrder> sortOrders = {
+      velox::core::kAscNullsFirst}; // Only one sort order for two columns
+
+  VELOX_ASSERT_THROW(
+      KeyEncoder::create(
+          keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+      "Size mismatch");
+}
+
+TEST_F(KeyEncoderTest, errorEmptyKeyColumns) {
+  const auto input = makeRowVector({
+      makeFlatVector<int64_t>({1, 2, 3}),
+      makeFlatVector<int32_t>({4, 5, 6}),
+  });
+
+  const std::vector<std::string> keyColumns = {}; // Empty key columns
+  const std::vector<velox::core::SortOrder> sortOrders = {};
+
+  VELOX_ASSERT_THROW(
+      KeyEncoder::create(
+          keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+      "");
+}
+
+TEST_F(KeyEncoderTest, unsupportedIndexColumnType) {
+  // Test ARRAY type
+  {
+    const auto input = makeRowVector({
+        makeArrayVector<int64_t>({{1, 2}, {3, 4}, {5, 6}}),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': ARRAY<BIGINT>");
+  }
+
+  // Test MAP type
+  {
+    auto input = makeRowVector({
+        makeMapVector<int64_t, int64_t>({{{1, 2}, {3, 4}}, {{5, 6}}}),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': MAP<BIGINT,BIGINT>");
+  }
+
+  // Test ROW (struct) type
+  {
+    auto input = makeRowVector({
+        makeRowVector({
+            makeFlatVector<int64_t>({1, 2, 3}),
+            makeFlatVector<int32_t>({4, 5, 6}),
+        }),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': ROW<c0:BIGINT,c1:INTEGER>");
+  }
+
+  // Test UNKNOWN type
+  {
+    auto input = makeRowVector({
+        velox::BaseVector::createNullConstant(velox::UNKNOWN(), 3, pool_.get()),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': UNKNOWN");
+  }
+
+  // Test OPAQUE type
+  {
+    // Define a simple test class for opaque type
+    class TestOpaqueClass {};
+
+    // Create an opaque type vector
+    auto opaqueType = velox::OpaqueType::create<TestOpaqueClass>();
+    auto opaqueValue = std::make_shared<TestOpaqueClass>();
+    auto opaqueVector = velox::BaseVector::createConstant(
+        opaqueType, velox::variant::opaque(opaqueValue), 3, pool_.get());
+
+    auto input = makeRowVector({opaqueVector});
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': OPAQUE");
+  }
+
+  // Test HUGEINT type
+  {
+    using HugeintType = velox::TypeTraits<velox::TypeKind::HUGEINT>::NativeType;
+    auto input = makeRowVector({
+        makeFlatVector<HugeintType>({0, 1}),
+    });
+
+    const std::vector<std::string> keyColumns = {"c0"};
+    const std::vector<velox::core::SortOrder> sortOrders = {
+        velox::core::kAscNullsFirst};
+
+    VELOX_ASSERT_THROW(
+        KeyEncoder::create(
+            keyColumns, asRowType(input->type()), sortOrders, pool_.get()),
+        "Unsupported type for index column 'c0': HUGEINT");
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeFuzz) {
+  // Seed for deterministic testing
+  const size_t seed = 123456;
+
+  // Supported scalar types for KeyEncoder (excluding complex types like
+  // arrays/maps)
+  const std::vector<velox::TypePtr> supportedTypes = {
+      velox::BIGINT(),
+      velox::INTEGER(),
+      velox::SMALLINT(),
+      velox::TINYINT(),
+      velox::DOUBLE(),
+      velox::REAL(),
+      velox::BOOLEAN(),
+      velox::VARCHAR(),
+      velox::DATE(),
+      velox::TIMESTAMP()};
+
+  // VectorFuzzer options
+  velox::VectorFuzzer::Options options;
+  options.vectorSize = 100;
+  options.nullRatio = 0.2; // 20% nulls
+  options.stringLength = 50;
+  options.stringVariableLength = true;
+  options.containerLength = 10;
+  options.containerVariableLength = true;
+  options.allowLazyVector = true;
+  options.allowSlice = true;
+  options.allowConstantVector = true;
+  options.allowDictionaryVector = true;
+
+  // Run fuzzer iterations
+  const int numIterations = 50;
+  for (int iter = 0; iter < numIterations; ++iter) {
+    // Create fuzzer with iteration-specific seed for variation
+    velox::VectorFuzzer fuzzer(options, pool_.get(), seed + iter);
+
+    // Generate random number of columns (1 to 5)
+    const size_t numColumns = fuzzer.randInRange(1, 5);
+
+    // Generate random row type with supported scalar types
+    std::vector<std::string> columnNames;
+    std::vector<velox::TypePtr> columnTypes;
+    for (size_t i = 0; i < numColumns; ++i) {
+      columnNames.push_back(fmt::format("c{}", i));
+      // Pick a random supported type
+      const size_t typeIndex = fuzzer.randInRange(0, supportedTypes.size() - 1);
+      columnTypes.push_back(supportedTypes[typeIndex]);
+    }
+
+    // Create row type
+    auto rowType = velox::ROW(std::move(columnNames), std::move(columnTypes));
+
+    // Generate multiple input vectors with different encodings (3 to 10
+    // vectors per iteration)
+    const size_t numInputVectors = fuzzer.randInRange(3, 10);
+    std::vector<velox::RowVectorPtr> inputs;
+    inputs.reserve(numInputVectors);
+
+    for (size_t i = 0; i < numInputVectors; ++i) {
+      // Use fuzzInputRow which generates RowVectors without top-level
+      // nulls (i.e., no null rows, only nullable child vectors)
+      inputs.push_back(fuzzer.fuzzInputRow(rowType));
+    }
+
+    SCOPED_TRACE(
+        fmt::format(
+            "Iteration {}: {} input vectors, {} columns, types: [{}]",
+            iter,
+            numInputVectors,
+            numColumns,
+            folly::join(", ", rowType->names())));
+
+    // Create key column names
+    // 80% of the time: randomize the order
+    // 20% of the time: follow the same order as input vector columns
+    std::vector<std::string> keyColumns;
+    keyColumns.reserve(numColumns);
+    for (size_t i = 0; i < numColumns; ++i) {
+      keyColumns.push_back(fmt::format("c{}", i));
+    }
+
+    // Randomize key column order 80% of the time
+    if (fuzzer.coinToss(0.8)) {
+      // Shuffle the key columns to test if KeyEncoder can handle
+      // different orders
+      std::mt19937 rng(seed + iter + 1000);
+      std::shuffle(keyColumns.begin(), keyColumns.end(), rng);
+      SCOPED_TRACE(
+          fmt::format(
+              "Randomized key column order: [{}]",
+              folly::join(", ", keyColumns)));
+    } else {
+      SCOPED_TRACE("Using original key column order (same as input vector)");
+    }
+
+    // Test all input vectors with the same KeyEncoder configuration
+    encodeTest(inputs, keyColumns);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithBigIntType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int64_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({10})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({100})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int64_t>({11})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({11})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int64_t>({9})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({9})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({100})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int64_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({10})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int64_t>({10})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}), makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7-1: Upper bound at max value (overflow case)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>(
+                {std::numeric_limits<int64_t>::max()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int64_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int64_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int64_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max() -
+             1})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max() -
+             1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7-2: Upper bound at max value (overflow case)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>(
+                {std::numeric_limits<int64_t>::min()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int64_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::min() +
+             1})}), // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int64_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::min() +
+             1})}), // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int64_t>({0})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({0})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 8: Only lower bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({10})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int64_t>({11})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({11})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int64_t>({9})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({9})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 9: Only upper bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 10: Multi-column, both exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}), makeFlatVector<int64_t>({20})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({21})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({21})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({19})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({19})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 11: Multi-column, lower inclusive upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}), makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 12: Multi-column, only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}), makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 13: Multi-column, only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-1: Multi-column at max values (overflow)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({0}), makeFlatVector<int64_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({1}),
+                 makeFlatVector<int64_t>(
+                     {std::numeric_limits<int64_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({2}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({2}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({1}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({1}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-2: Multi-column at max values
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({0}), makeFlatVector<int64_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({1}),
+                 makeFlatVector<int64_t>(
+                     {std::numeric_limits<int64_t>::min()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({1}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min() +
+                  1})}), // ASC_NULLS_FIRST
+                         // upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({1}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min() + 1})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-3: Multi-column at max values (overflow)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({0}), makeFlatVector<int64_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()}),
+                 makeFlatVector<int64_t>(
+                     {std::numeric_limits<int64_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({0}),
+             makeFlatVector<int64_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()}),
+             makeFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 15: Multi-column, only lower bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}), makeFlatVector<int64_t>({20})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({21})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({21})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({19})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({19})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 16: Multi-column, only upper bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 17: Single column with null in lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 18: Single column with null in upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int64_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int64_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int64_t>(
+            {std::numeric_limits<int64_t>::max()})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int64_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 19: Multi-column with null in first column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt}),
+                 makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 20: Multi-column with null in second column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}),
+                 makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 21: Multi-column with null in first column of upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}), makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt}),
+                 makeFlatVector<int64_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 22: Multi-column with null in second column of upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({10}), makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeNullableFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({101}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeNullableFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int64_t>({10}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 23: Both bounds with nulls in different columns
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int64_t>({std::nullopt}),
+                 makeFlatVector<int64_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int64_t>({100}),
+                 makeNullableFlatVector<int64_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeNullableFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({101}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({100}),
+             makeNullableFlatVector<int64_t>(
+                 {std::numeric_limits<int64_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeFlatVector<int64_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int64_t>({99}),
+             makeNullableFlatVector<int64_t>(
+                 {std::nullopt})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test lower bound bump failures
+  // Test Case 24-1: Single column lower bound bump failure - exclusive bound
+  // at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 24-2: Single column lower bound bump failure - exclusive bound
+  // at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 25-1: Multiple columns lower bound bump failure - all columns
+  // at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()}),
+             makeFlatVector<int64_t>({std::numeric_limits<int64_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 25-2: Multiple columns lower bound bump failure - all columns
+  // at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<int64_t>({std::nullopt}),
+             makeNullableFlatVector<int64_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithIntegerType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int32_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({10})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({100})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int32_t>({11})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({11})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int32_t>({9})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({9})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({100})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int32_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({10})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int32_t>({10})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}), makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7-1: Upper bound at max value (overflow case)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>(
+                {std::numeric_limits<int32_t>::max()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int32_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int32_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int32_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::max() -
+             1})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::max() -
+             1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7-2: Upper bound at min value (overflow case)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>(
+                {std::numeric_limits<int32_t>::min()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int32_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::min() +
+             1})}), // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int32_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::min() +
+             1})}), // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int32_t>({0})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({0})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 8: Only lower bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({10})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int32_t>({11})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({11})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int32_t>({9})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({9})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 9: Only upper bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 10: Multi-column, both exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}), makeFlatVector<int32_t>({20})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({21})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({21})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({19})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({19})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 11: Multi-column, lower inclusive upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}), makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 12: Multi-column, only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}), makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 13: Multi-column, only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-1: Multi-column at max values (overflow)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({0}), makeFlatVector<int32_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({1}),
+                 makeFlatVector<int32_t>(
+                     {std::numeric_limits<int32_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({2}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({2}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({1}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({1}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-2: Multi-column at min values
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({0}), makeFlatVector<int32_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({1}),
+                 makeFlatVector<int32_t>(
+                     {std::numeric_limits<int32_t>::min()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({1}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min() +
+                  1})}), // ASC_NULLS_FIRST
+                         // upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({1}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min() + 1})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-3: Multi-column at max values (overflow)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({0}), makeFlatVector<int32_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()}),
+                 makeFlatVector<int32_t>(
+                     {std::numeric_limits<int32_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({0}),
+             makeFlatVector<int32_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()}),
+             makeFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 15: Multi-column, only lower bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}), makeFlatVector<int32_t>({20})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({21})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({21})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({19})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({19})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 16: Multi-column, only upper bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 17: Single column with null in lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 18: Single column with null in upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int32_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int32_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int32_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int32_t>(
+            {std::numeric_limits<int32_t>::max()})}), // DESC_NULLS_FIRST
+                                                      // upper
+        makeRowVector({makeFlatVector<int32_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 19: Multi-column with null in first column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt}),
+                 makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 20: Multi-column with null in second column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}),
+                 makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 21: Multi-column with null in first column of upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}), makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt}),
+                 makeFlatVector<int32_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 22: Multi-column with null in second column of upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({10}), makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeNullableFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({101}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeNullableFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int32_t>({10}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 23: Both bounds with nulls in different columns
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int32_t>({std::nullopt}),
+                 makeFlatVector<int32_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int32_t>({100}),
+                 makeNullableFlatVector<int32_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeNullableFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({101}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({100}),
+             makeNullableFlatVector<int32_t>(
+                 {std::numeric_limits<int32_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeFlatVector<int32_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int32_t>({99}),
+             makeNullableFlatVector<int32_t>(
+                 {std::nullopt})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test lower bound bump failures
+  // Test Case 24-1: Single column lower bound bump failure - exclusive bound
+  // at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 24-2: Single column lower bound bump failure - exclusive bound
+  // at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int32_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 25-1: Multiple columns lower bound bump failure - all columns
+  // at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()}),
+             makeFlatVector<int32_t>({std::numeric_limits<int32_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 25-2: Multiple columns lower bound bump failure - all columns
+  // at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<int32_t>({std::nullopt}),
+             makeNullableFlatVector<int32_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithSmallIntType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int16_t>({11})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({11})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int16_t>({9})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({9})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7-1: Upper bound at max value (overflow case)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>(
+                {std::numeric_limits<int16_t>::max()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::max() -
+             1})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::max() -
+             1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7-2: Upper bound at min value (overflow case)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>(
+                {std::numeric_limits<int16_t>::min()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::min() +
+             1})}), // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::min() +
+             1})}), // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 8: Only lower bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int16_t>({11})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({11})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int16_t>({9})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({9})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 9: Only upper bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 10: Multi-column, both exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({21})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({21})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({19})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({19})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 11: Multi-column, lower inclusive upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 12: Multi-column, only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 13: Multi-column, only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-1: Multi-column at max values (overflow)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({0}), makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({1}),
+                 makeFlatVector<int16_t>(
+                     {std::numeric_limits<int16_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({2}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({2}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_LAST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({1}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({1}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-2: Multi-column at min values
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({0}), makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({1}),
+                 makeFlatVector<int16_t>(
+                     {std::numeric_limits<int16_t>::min()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({1}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min() +
+                  1})}), // ASC_NULLS_FIRST
+                         // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({1}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min() + 1})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})})); // DESC_NULLS_LAST
+                                                            // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-3: Multi-column at max values (overflow)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({0}), makeFlatVector<int16_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()}),
+                 makeFlatVector<int16_t>(
+                     {std::numeric_limits<int16_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({0}),
+             makeFlatVector<int16_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()}),
+             makeFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 15: Multi-column, only lower bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({21})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({21})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({19})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({19})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 16: Multi-column, only upper bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 17: Single column with null in lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 18: Single column with null in upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int16_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int16_t>(
+            {std::numeric_limits<int16_t>::max()})}), // DESC_NULLS_FIRST
+                                                      // upper
+        makeRowVector({makeFlatVector<int16_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 19: Multi-column with null in first column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt}),
+                 makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 20: Multi-column with null in second column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}),
+                 makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 21: Multi-column with null in first column of upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt}),
+                 makeFlatVector<int16_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 22: Multi-column with null in second column of upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({10}), makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeNullableFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeNullableFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<int16_t>({10}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 23: Both bounds with nulls in different columns
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int16_t>({std::nullopt}),
+                 makeFlatVector<int16_t>({20})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int16_t>({100}),
+                 makeNullableFlatVector<int16_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeNullableFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::min()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({101}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({100}),
+             makeNullableFlatVector<int16_t>(
+                 {std::numeric_limits<int16_t>::max()})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeFlatVector<int16_t>({20})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int16_t>({99}),
+             makeNullableFlatVector<int16_t>(
+                 {std::nullopt})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test lower bound bump failures
+  // Test Case 24-1: Single column lower bound bump failure - exclusive
+  // bound at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 24-2: Single column lower bound bump failure - exclusive
+  // bound at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int16_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 25-1: Multiple columns lower bound bump failure - all
+  // columns at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()}),
+             makeFlatVector<int16_t>({std::numeric_limits<int16_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 25-2: Multiple columns lower bound bump failure - all
+  // columns at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<int16_t>({std::nullopt}),
+             makeNullableFlatVector<int16_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithTinyIntType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({49})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({49})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int8_t>({6})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({6})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({4})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({4})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({49})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({49})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7-1: Upper bound at max value (overflow case)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::max() -
+             1})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::max() -
+             1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7-2: Upper bound at min value (overflow case)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::min()})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::min() +
+             1})}), // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::min() +
+             1})}), // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 8: Only lower bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector({makeFlatVector<int8_t>({6})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({6})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({4})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<int8_t>({4})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 9: Only upper bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({50})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({50})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 10: Multi-column, both exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({11})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({11})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({9})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({9})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 11: Multi-column, lower inclusive upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 12: Multi-column, only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 13: Multi-column, only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-1: Multi-column at max values (overflow)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({0}), makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({1}),
+                 makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({2}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({2}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_LAST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({1}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({1}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-2: Multi-column at min values
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({0}), makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({1}),
+                 makeFlatVector<int8_t>({std::numeric_limits<int8_t>::min()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({1}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min() + 1})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({1}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min() + 1})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})})); // DESC_NULLS_LAST
+                                                           // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14-3: Multi-column at max values (overflow)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({0}), makeFlatVector<int8_t>({0})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()}),
+                 makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max() -
+                  1})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({0}),
+             makeFlatVector<int8_t>({0})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()}),
+             makeFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max() -
+                  1})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 15: Multi-column, only lower bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = false},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({11})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({11})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({9})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({9})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 16: Multi-column, only upper bound, exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = false},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({100})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 17: Single column with null in lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({50})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({51})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<int8_t>({49})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<int8_t>({49})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 18: Single column with null in upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<int8_t>({5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_FIRST
+                                                     // upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<int8_t>(
+            {std::numeric_limits<int8_t>::max()})}), // DESC_NULLS_FIRST
+                                                     // upper
+        makeRowVector({makeFlatVector<int8_t>({5})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 19: Multi-column with null in first column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int8_t>({std::nullopt}),
+                 makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 20: Multi-column with null in second column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}),
+                 makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}), makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 21: Multi-column with null in first column of upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int8_t>({std::nullopt}),
+                 makeFlatVector<int8_t>({100})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({101})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({99})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({99})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 22: Multi-column with null in second column of upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({5}), makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}),
+                 makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeNullableFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({51}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeNullableFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<int8_t>({5}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({49}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 23: Both bounds with nulls in different columns
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<int8_t>({std::nullopt}),
+                 makeFlatVector<int8_t>({10})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<int8_t>({50}),
+                 makeNullableFlatVector<int8_t>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeNullableFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::min()})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({51}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({50}),
+             makeNullableFlatVector<int8_t>(
+                 {std::numeric_limits<int8_t>::max()})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeFlatVector<int8_t>({10})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<int8_t>({49}),
+             makeNullableFlatVector<int8_t>(
+                 {std::nullopt})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test lower bound bump failures
+  // Test Case 24-1: Single column lower bound bump failure - exclusive
+  // bound at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 24-2: Single column lower bound bump failure - exclusive
+  // bound at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<int8_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 25-1: Multiple columns lower bound bump failure - all
+  // columns at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()}),
+             makeFlatVector<int8_t>({std::numeric_limits<int8_t>::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+  // Test Case 25-2: Multiple columns lower bound bump failure - all
+  // columns at max value with null.
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<int8_t>({std::nullopt}),
+             makeNullableFlatVector<int8_t>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithBoolType) {
+  // Test Case 1: Both bounds inclusive (false to true)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow - can't increment
+                      // true)
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 2: Upper bound exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({true})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<bool>({true})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<bool>({true})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<bool>({true})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<bool>({true})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Only lower bound (false)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 4: Only upper bound (true)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        std::nullopt, // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 5: Single column with null in lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<bool>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<bool>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector({makeNullableFlatVector<bool>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector({makeNullableFlatVector<bool>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<bool>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 6: Single column with null in upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<bool>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<bool>({false})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeNullableFlatVector<bool>({true})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7: Multi-column, both inclusive (bool + bool)
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({false}), makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({true}), makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 8: Multi-column with null in first column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<bool>({std::nullopt}),
+                 makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({true}), makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper (overflow)
+        makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper (overflow)
+        makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 9: Lower bound bump failure - exclusive bound at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<bool>({true})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 10: Lower bound bump failure - exclusive bound with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeNullableFlatVector<bool>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 11: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<bool>({true}), makeFlatVector<bool>({true})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<bool>({std::nullopt}),
+             makeNullableFlatVector<bool>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 13: Multi-column point lookup where the lower (second) column
+  // hits max value (true) in ASC order. This tests carry-over behavior when
+  // incrementing - when c1 is true, the increment should carry over to c0,
+  // resulting in (true, false).
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({false}), makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({false}), makeFlatVector<bool>({true})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST upper
+                                              // (carry-over)
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_LAST upper
+                                              // (carry-over)
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({false})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 14: Multi-column point lookup where the lower (second) column
+  // hits min value (false) in DESC order. This tests carry-over behavior when
+  // decrementing - when c1 is false, the decrement should carry over to c0,
+  // resulting in (false, true).
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({true}), makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<bool>({true}), makeFlatVector<bool>({false})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({true})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({true})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})}), // DESC_NULLS_FIRST upper
+                                             // (carry-over)
+        makeRowVector(
+            {makeFlatVector<bool>({true}),
+             makeFlatVector<bool>({false})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<bool>({false}),
+             makeFlatVector<bool>({true})})); // DESC_NULLS_LAST upper
+                                              // (carry-over)
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithRealType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                         // upper
+        makeRowVector({makeFlatVector<float>({10.5f})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                         // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})})); // DESC_NULLS_LAST
+                                                           // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            10.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            10.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            10.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_FIRST
+                                                          // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            10.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_LAST
+                                                          // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<float>({10.5f})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<float>({10.5f})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                         // upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                         // upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_FIRST
+                                                          // upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})})); // DESC_NULLS_LAST
+                                                           // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({10.5f}),
+                 makeFlatVector<float>({20.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeFlatVector<float>({20.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeFlatVector<float>({20.5f})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeFlatVector<float>({20.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})}), // DESC_NULLS_FIRST
+                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeFlatVector<float>({20.5f})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})})); // DESC_NULLS_LAST
+                                               // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7: Single column with null in lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<float>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                         // upper
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                         // upper
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<float>({std::nextafter(
+            100.5f,
+            -std::numeric_limits<float>::infinity())})})); // DESC_NULLS_LAST
+                                                           // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 8: Single column with null in upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<float>({10.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<float>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<float>(
+            {-std::numeric_limits<float>::infinity()})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector({makeFlatVector<float>({10.5f})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<float>(
+            {std::numeric_limits<float>::infinity()})}), // DESC_NULLS_FIRST
+                                                         // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 9: Multi-column with null in first column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<float>({std::nullopt}),
+                 makeFlatVector<float>({20.5f})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeFlatVector<float>({20.5f})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeFlatVector<float>({20.5f})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeFlatVector<float>({20.5f})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})}), // DESC_NULLS_FIRST
+                                              // upper
+        makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeFlatVector<float>({20.5f})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})})); // DESC_NULLS_LAST
+                                               // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 10: Multi-column with null in second column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({10.5f}),
+                 makeNullableFlatVector<float>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>({100.5f})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeNullableFlatVector<float>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeNullableFlatVector<float>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeNullableFlatVector<float>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})}), // DESC_NULLS_FIRST
+                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({10.5f}),
+             makeNullableFlatVector<float>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 100.5f,
+                 -std::numeric_limits<
+                     float>::infinity())})})); // DESC_NULLS_LAST
+                                               // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 11: Lower bound bump failure - exclusive bound at positive
+  // infinity
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<float>({std::numeric_limits<float>::infinity()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Lower bound bump failure - exclusive bound with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeNullableFlatVector<float>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 13: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<float>({std::numeric_limits<float>::infinity()}),
+             makeFlatVector<float>({std::numeric_limits<float>::infinity()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 14: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<float>({std::nullopt}),
+             makeNullableFlatVector<float>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 15: Multi-column point lookup where the lower (second) column
+  // hits positive infinity in ASC order. This tests carry-over behavior when
+  // incrementing - when c1 is at +infinity, the increment should carry over
+  // to c0, resulting in (nextafter(c0, +inf), -inf).
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>(
+                     {std::numeric_limits<float>::infinity()})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>(
+                     {std::numeric_limits<float>::infinity()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>(
+                 {std::numeric_limits<float>::infinity()})}), // ASC_NULLS_FIRST
+                                                              // lower
+        makeRowVector(
+            {makeFlatVector<float>({std::nextafter(
+                 100.5f, std::numeric_limits<float>::infinity())}),
+             makeFlatVector<float>({-std::numeric_limits<
+                 float>::infinity()})}), // ASC_NULLS_FIRST
+                                         // upper
+                                         // (carry-over)
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>(
+                 {std::numeric_limits<float>::infinity()})}), // ASC_NULLS_LAST
+                                                              // lower
+        makeRowVector(
+            {makeFlatVector<float>({std::nextafter(
+                 100.5f, std::numeric_limits<float>::infinity())}),
+             makeFlatVector<float>(
+                 {-std::numeric_limits<float>::infinity()})}), // ASC_NULLS_LAST
+                                                               // upper
+                                                               // (carry-over)
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::numeric_limits<
+                 float>::infinity()})}), // DESC_NULLS_FIRST
+                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 std::numeric_limits<float>::infinity(),
+                 -std::numeric_limits<
+                     float>::infinity())})}), // DESC_NULLS_FIRST
+                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>(
+                 {std::numeric_limits<float>::infinity()})}), // DESC_NULLS_LAST
+                                                              // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 std::numeric_limits<float>::infinity(),
+                 -std::numeric_limits<
+                     float>::infinity())})})); // DESC_NULLS_LAST
+                                               // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 16: Multi-column point lookup where the lower (second) column
+  // hits negative infinity in DESC order. This tests carry-over behavior when
+  // decrementing - when c1 is at -infinity, the decrement should carry over
+  // to c0, resulting in (nextafter(c0, -inf), +inf).
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>(
+                     {-std::numeric_limits<float>::infinity()})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<float>({100.5f}),
+                 makeFlatVector<float>(
+                     {-std::numeric_limits<float>::infinity()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({-std::numeric_limits<
+                 float>::infinity()})}), // ASC_NULLS_FIRST
+                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 -std::numeric_limits<float>::infinity(),
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_FIRST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>(
+                 {-std::numeric_limits<float>::infinity()})}), // ASC_NULLS_LAST
+                                                               // lower
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({std::nextafter(
+                 -std::numeric_limits<float>::infinity(),
+                 std::numeric_limits<float>::infinity())})}), // ASC_NULLS_LAST
+                                                              // upper
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({-std::numeric_limits<
+                 float>::infinity()})}), // DESC_NULLS_FIRST
+                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({std::nextafter(
+                 100.5f, -std::numeric_limits<float>::infinity())}),
+             makeFlatVector<float>({std::numeric_limits<
+                 float>::infinity()})}), // DESC_NULLS_FIRST
+                                         // upper
+                                         // (carry-over)
+        makeRowVector(
+            {makeFlatVector<float>({100.5f}),
+             makeFlatVector<float>({-std::numeric_limits<
+                 float>::infinity()})}), // DESC_NULLS_LAST
+                                         // lower
+        makeRowVector(
+            {makeFlatVector<float>({std::nextafter(
+                 100.5f, -std::numeric_limits<float>::infinity())}),
+             makeFlatVector<float>({std::numeric_limits<
+                 float>::infinity()})})); // DESC_NULLS_LAST
+                                          // upper
+                                          // (carry-over)
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithDoubleType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector({makeFlatVector<double>({10.5})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})})); // DESC_NULLS_LAST
+                                                            // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            10.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_FIRST
+                                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            10.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            10.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_FIRST
+                                                           // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            10.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_LAST
+                                                           // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = false},
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<double>({10.5})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<double>({10.5})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_FIRST
+                                                          // upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                          // upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_FIRST
+                                                           // upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})})); // DESC_NULLS_LAST
+                                                            // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({10.5}),
+                 makeFlatVector<double>({20.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeFlatVector<double>({20.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<
+                     double>::infinity())})}), // ASC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeFlatVector<double>({20.5})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeFlatVector<double>({20.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})}), // DESC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeFlatVector<double>({20.5})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})})); // DESC_NULLS_LAST
+                                                // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7: Single column with null in lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<double>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_FIRST
+                                                          // upper
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                          // upper
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})}), // DESC_NULLS_FIRST
+                                                           // upper
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<double>({std::nextafter(
+            100.5,
+            -std::numeric_limits<double>::infinity())})})); // DESC_NULLS_LAST
+                                                            // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 8: Single column with null in upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<double>({10.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound =
+                makeRowVector({makeNullableFlatVector<double>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<double>(
+            {-std::numeric_limits<double>::infinity()})}), // ASC_NULLS_FIRST
+                                                           // upper
+        makeRowVector({makeFlatVector<double>({10.5})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<double>(
+            {std::numeric_limits<double>::infinity()})}), // DESC_NULLS_FIRST
+                                                          // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST
+                       // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 9: Multi-column with null in first column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<double>({std::nullopt}),
+                 makeFlatVector<double>({20.5})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeFlatVector<double>({20.5})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<
+                     double>::infinity())})}), // ASC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeFlatVector<double>({20.5})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeFlatVector<double>({20.5})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})}), // DESC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeFlatVector<double>({20.5})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})})); // DESC_NULLS_LAST
+                                                // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 10: Multi-column with null in second column of lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({10.5}),
+                 makeNullableFlatVector<double>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>({100.5})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeNullableFlatVector<double>(
+                 {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<
+                     double>::infinity())})}), // ASC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeNullableFlatVector<double>(
+                 {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeNullableFlatVector<double>(
+                 {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})}), // DESC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({10.5}),
+             makeNullableFlatVector<double>(
+                 {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 100.5,
+                 -std::numeric_limits<
+                     double>::infinity())})})); // DESC_NULLS_LAST
+                                                // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 11: Lower bound bump failure - exclusive bound at positive
+  // infinity
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<double>(
+            {std::numeric_limits<double>::infinity()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Lower bound bump failure - exclusive bound with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound =
+            makeRowVector({makeNullableFlatVector<double>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 13: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<double>({std::numeric_limits<double>::infinity()}),
+             makeFlatVector<double>(
+                 {std::numeric_limits<double>::infinity()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 14: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<double>({std::nullopt}),
+             makeNullableFlatVector<double>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 15: Multi-column point lookup where the lower (second) column
+  // hits positive infinity in ASC order. This tests carry-over behavior when
+  // incrementing - when c1 is at +infinity, the increment should carry over
+  // to c0, resulting in (nextafter(c0, +inf), -inf).
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>(
+                     {std::numeric_limits<double>::infinity()})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>(
+                     {std::numeric_limits<double>::infinity()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_FIRST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({std::nextafter(
+                 100.5, std::numeric_limits<double>::infinity())}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_FIRST
+                                          // upper
+                                          // (carry-over)
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>(
+                 {std::numeric_limits<double>::infinity()})}), // ASC_NULLS_LAST
+                                                               // lower
+        makeRowVector(
+            {makeFlatVector<double>({std::nextafter(
+                 100.5, std::numeric_limits<double>::infinity())}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_LAST
+                                          // upper
+                                          // (carry-over)
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_FIRST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 std::numeric_limits<double>::infinity(),
+                 -std::numeric_limits<
+                     double>::infinity())})}), // DESC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_LAST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 std::numeric_limits<double>::infinity(),
+                 -std::numeric_limits<
+                     double>::infinity())})})); // DESC_NULLS_LAST
+                                                // upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 16: Multi-column point lookup where the lower (second) column
+  // hits negative infinity in DESC order. This tests carry-over behavior when
+  // decrementing - when c1 is at -infinity, the decrement should carry over
+  // to c0, resulting in (nextafter(c0, -inf), +inf).
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>(
+                     {-std::numeric_limits<double>::infinity()})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<double>({100.5}),
+                 makeFlatVector<double>(
+                     {-std::numeric_limits<double>::infinity()})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_FIRST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 -std::numeric_limits<double>::infinity(),
+                 std::numeric_limits<
+                     double>::infinity())})}), // ASC_NULLS_FIRST
+                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // ASC_NULLS_LAST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({std::nextafter(
+                 -std::numeric_limits<double>::infinity(),
+                 std::numeric_limits<double>::infinity())})}), // ASC_NULLS_LAST
+                                                               // upper
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_FIRST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({std::nextafter(
+                 100.5, -std::numeric_limits<double>::infinity())}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_FIRST
+                                          // upper
+                                          // (carry-over)
+        makeRowVector(
+            {makeFlatVector<double>({100.5}),
+             makeFlatVector<double>({-std::numeric_limits<
+                 double>::infinity()})}), // DESC_NULLS_LAST
+                                          // lower
+        makeRowVector(
+            {makeFlatVector<double>({std::nextafter(
+                 100.5, -std::numeric_limits<double>::infinity())}),
+             makeFlatVector<double>({std::numeric_limits<
+                 double>::infinity()})})); // DESC_NULLS_LAST
+                                           // upper
+                                           // (carry-over)
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithTimestampType) {
+  // Test Case 1: Both bounds inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(10, 100)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = true},
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 2: Both bounds exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(10, 100)})}),
+            .inclusive = false},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 101)})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 101)})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 99)})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 99)})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Lower inclusive, upper exclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(10, 100)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = false},
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 200)})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 4: Only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(10, 100)})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(10, 100)})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 5: Only upper bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        std::nullopt,
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = true},
+        std::nullopt, // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_FIRST upper
+        std::nullopt, // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_LAST upper
+        std::nullopt, // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})}), // DESC_NULLS_FIRST upper
+        std::nullopt, // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 6: Single column with null in lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<velox::Timestamp>({std::nullopt})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<velox::Timestamp>(
+                {velox::Timestamp(100, 200)})}),
+            .inclusive = true},
+        makeRowVector({makeNullableFlatVector<velox::Timestamp>(
+            {std::nullopt})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<velox::Timestamp>(
+            {std::nullopt})}), // ASC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 201)})}), // ASC_NULLS_LAST upper
+        makeRowVector({makeNullableFlatVector<velox::Timestamp>(
+            {std::nullopt})}), // DESC_NULLS_FIRST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})}), // DESC_NULLS_FIRST upper
+        makeRowVector({makeNullableFlatVector<velox::Timestamp>(
+            {std::nullopt})}), // DESC_NULLS_LAST lower
+        makeRowVector({makeFlatVector<velox::Timestamp>(
+            {velox::Timestamp(100, 199)})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 7: Multi-column, both inclusive
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+                 makeFlatVector<velox::Timestamp>(
+                     {velox::Timestamp(20, 200)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>(
+                     {velox::Timestamp(200, 400)})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(20, 200)})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(200, 401)})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(20, 200)})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(200, 401)})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(20, 200)})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(200, 399)})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(10, 100)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(20, 200)})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>(
+                 {velox::Timestamp(200, 399)})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 8: Lower bound bump failure - exclusive bound at max value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 9: Lower bound bump failure - exclusive bound with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<velox::Timestamp>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 10: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp::max()}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp::max()})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 11: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<velox::Timestamp>({std::nullopt}),
+             makeNullableFlatVector<velox::Timestamp>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Multi-column point lookup where the lower (second) column
+  // hits max value in ASC order. This tests carry-over behavior when
+  // incrementing - when c1 is at Timestamp::max(), the increment should carry
+  // over to c0, resulting in (c0+1nanos, Timestamp::min()).
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                     velox::Timestamp::kMaxSeconds,
+                     velox::Timestamp::kMaxNanos)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                     velox::Timestamp::kMaxSeconds,
+                     velox::Timestamp::kMaxNanos)})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 301)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // ASC_NULLS_FIRST upper
+                                                        // (carry-over)
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 301)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // ASC_NULLS_LAST upper
+                                                        // (carry-over)
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos - 1)})}), // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos - 1)})})); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 13: Multi-column point lookup where the lower (second) column
+  // hits min value in DESC order. This tests carry-over behavior when
+  // decrementing - when c1 is at Timestamp::min(), the decrement should carry
+  // over to c0, resulting in (c0-1nanos, Timestamp::max()).
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0", "c1"},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>(
+                     {velox::Timestamp(velox::Timestamp::kMinSeconds, 0)})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+                 makeFlatVector<velox::Timestamp>(
+                     {velox::Timestamp(velox::Timestamp::kMinSeconds, 0)})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // ASC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 1)})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // ASC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 1)})}), // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds,
+                 0)})}), // DESC_NULLS_FIRST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 299)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})}), // DESC_NULLS_FIRST upper
+                                                   // (carry-over)
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 300)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMinSeconds, 0)})}), // DESC_NULLS_LAST lower
+        makeRowVector(
+            {makeFlatVector<velox::Timestamp>({velox::Timestamp(100, 299)}),
+             makeFlatVector<velox::Timestamp>({velox::Timestamp(
+                 velox::Timestamp::kMaxSeconds,
+                 velox::Timestamp::kMaxNanos)})})); // DESC_NULLS_LAST upper
+                                                    // (carry-over)
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+}
+
+TEST_F(KeyEncoderTest, encodeIndexBoundsWithStringType) {
+  // Helper to create string with embedded null byte (for increment result)
+  auto makeStringWithNull = [](const std::string& s) {
+    return s + std::string(1, '\0');
+  };
+
+  // Test Case 1: Both bounds inclusive
+  // For ascending order: increment appends '\0' (e.g., "orange" ->
+  // "orange\0") For descending order: decrement only works if string ends
+  // with '\0', otherwise increment fails and we get unbounded upper
+  // (std::nullopt)
+  {
+    // For DESC order with inclusive upper bound on "orange" (doesn't end with
+    // '\0'), decrement fails, so upper bound becomes unbounded (std::nullopt)
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({"apple"})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({"apple"})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // For DESC order, decrement fails on "orange" (doesn't end with '\0'),
+    // so upper bound becomes unbounded
+    EncodeIndexBoundsTestCase descNullsFirstTestCase;
+    descNullsFirstTestCase.indexColumns = {"c0"};
+    descNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({"apple"})});
+    descNullsFirstTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsFirstTestCase.debugString());
+    testIndexBounds(descNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase descNullsLastTestCase;
+    descNullsLastTestCase.indexColumns = {"c0"};
+    descNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+        .inclusive = true};
+    descNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+    descNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({"apple"})});
+    descNullsLastTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsLastTestCase.debugString());
+    testIndexBounds(descNullsLastTestCase);
+  }
+
+  // Test Case 2: Only lower bound
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+            .inclusive = true},
+        std::nullopt,
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // ASC_NULLS_FIRST lower
+        std::nullopt, // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 3: Only upper bound (inclusive)
+  // For ASC: increment appends '\0'
+  // For DESC: decrement fails on "orange", upper becomes unbounded
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = std::nullopt;
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = std::nullopt;
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0"};
+    ascNullsLastTestCase.lowerBound = std::nullopt;
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound = std::nullopt;
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    EncodeIndexBoundsTestCase descNullsFirstTestCase;
+    descNullsFirstTestCase.indexColumns = {"c0"};
+    descNullsFirstTestCase.lowerBound = std::nullopt;
+    descNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descNullsFirstTestCase.expectedLowerBound = std::nullopt;
+    descNullsFirstTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsFirstTestCase.debugString());
+    testIndexBounds(descNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase descNullsLastTestCase;
+    descNullsLastTestCase.indexColumns = {"c0"};
+    descNullsLastTestCase.lowerBound = std::nullopt;
+    descNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+    descNullsLastTestCase.expectedLowerBound = std::nullopt;
+    descNullsLastTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsLastTestCase.debugString());
+    testIndexBounds(descNullsLastTestCase);
+  }
+
+  // Test Case 4: String ending with '\0' - decrement should work
+  // This tests the Kudu-aligned behavior where decrement truncates trailing
+  // '\0'
+  {
+    std::string stringWithNull = makeStringWithNull("abc");
+
+    EncodeIndexBoundsTestCase descTestCase;
+    descTestCase.indexColumns = {"c0"};
+    descTestCase.lowerBound = std::nullopt;
+    descTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({stringWithNull})}),
+        .inclusive = true};
+    descTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descTestCase.expectedLowerBound = std::nullopt;
+    // Decrement of "abc\0" should give "abc"
+    descTestCase.expectedUpperBound =
+        makeRowVector({makeFlatVector<std::string>({"abc"})});
+    SCOPED_TRACE(descTestCase.debugString());
+    testIndexBounds(descTestCase);
+  }
+
+  // Test Case 5: Empty string lower bound
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"abc"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({""})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("abc")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"abc"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({""})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("abc")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // For DESC order, decrement fails on "abc", upper becomes unbounded
+    EncodeIndexBoundsTestCase descNullsFirstTestCase;
+    descNullsFirstTestCase.indexColumns = {"c0"};
+    descNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+        .inclusive = true};
+    descNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"abc"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({""})});
+    descNullsFirstTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsFirstTestCase.debugString());
+    testIndexBounds(descNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase descNullsLastTestCase;
+    descNullsLastTestCase.indexColumns = {"c0"};
+    descNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+        .inclusive = true};
+    descNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"abc"})}),
+        .inclusive = true};
+    descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+    descNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeFlatVector<std::string>({""})});
+    descNullsLastTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsLastTestCase.debugString());
+    testIndexBounds(descNullsLastTestCase);
+  }
+
+  // Test Case 6: Multi-column, both inclusive
+  // For multi-column, increment works on rightmost column first
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0", "c1"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // For DESC order, decrement fails on rightmost column "peach",
+    // then tries leftmost "orange" which also fails -> unbounded
+    EncodeIndexBoundsTestCase descNullsFirstTestCase;
+    descNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    descNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    descNullsFirstTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsFirstTestCase.debugString());
+    testIndexBounds(descNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase descNullsLastTestCase;
+    descNullsLastTestCase.indexColumns = {"c0", "c1"};
+    descNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    descNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+    descNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    descNullsLastTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsLastTestCase.debugString());
+    testIndexBounds(descNullsLastTestCase);
+  }
+
+  // Test Case 7: Single column with null in lower bound
+  // For null in lower bound with inclusive, the lower bound stays as null
+  // For upper bound, ASC order appends '\0', DESC order fails decrement
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeNullableFlatVector<std::string>({std::nullopt})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeNullableFlatVector<std::string>({std::nullopt})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    EncodeIndexBoundsTestCase descNullsFirstTestCase;
+    descNullsFirstTestCase.indexColumns = {"c0"};
+    descNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    descNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descNullsFirstTestCase.expectedLowerBound =
+        makeRowVector({makeNullableFlatVector<std::string>({std::nullopt})});
+    // Decrement fails on "orange", upper becomes unbounded
+    descNullsFirstTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsFirstTestCase.debugString());
+    testIndexBounds(descNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase descNullsLastTestCase;
+    descNullsLastTestCase.indexColumns = {"c0"};
+    descNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    descNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({"orange"})}),
+        .inclusive = true};
+    descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+    descNullsLastTestCase.expectedLowerBound =
+        makeRowVector({makeNullableFlatVector<std::string>({std::nullopt})});
+    // Decrement fails on "orange", upper becomes unbounded
+    descNullsLastTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsLastTestCase.debugString());
+    testIndexBounds(descNullsLastTestCase);
+  }
+
+  // Test Case 8: Single column with null in upper bound
+  // Incrementing null in ASC_NULLS_FIRST gives empty string ""
+  // For other orders, null is at the end or decrement fails
+  {
+    auto testCases = createIndexBoundEncodeTestCases(
+        {"c0"},
+        IndexBound{
+            .bound = makeRowVector({makeFlatVector<std::string>({"apple"})}),
+            .inclusive = true},
+        IndexBound{
+            .bound = makeRowVector(
+                {makeNullableFlatVector<std::string>({std::nullopt})}),
+            .inclusive = true},
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // ASC_NULLS_FIRST lower
+        makeRowVector({makeNullableFlatVector<std::string>(
+            {""})}), // ASC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // ASC_NULLS_LAST lower
+        std::nullopt, // ASC_NULLS_LAST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // DESC_NULLS_FIRST lower
+        std::nullopt, // DESC_NULLS_FIRST upper
+        makeRowVector(
+            {makeFlatVector<std::string>({"apple"})}), // DESC_NULLS_LAST lower
+        std::nullopt); // DESC_NULLS_LAST upper
+    for (const auto& testCase : testCases) {
+      SCOPED_TRACE(testCase.debugString());
+      testIndexBounds(testCase);
+    }
+  }
+
+  // Test Case 9: Multi-column with null in first column lower bound
+  // For ASC order, upper bound appends '\0' to rightmost column
+  // For DESC order, decrement fails on rightmost column "peach"
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeNullableFlatVector<std::string>({std::nullopt}),
+         makeFlatVector<std::string>({"banana"})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0", "c1"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeNullableFlatVector<std::string>({std::nullopt}),
+         makeFlatVector<std::string>({"banana"})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // DESC order: decrement fails on both columns -> unbounded
+    EncodeIndexBoundsTestCase descNullsFirstTestCase;
+    descNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    descNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeNullableFlatVector<std::string>({std::nullopt}),
+         makeFlatVector<std::string>({"banana"})});
+    descNullsFirstTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsFirstTestCase.debugString());
+    testIndexBounds(descNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase descNullsLastTestCase;
+    descNullsLastTestCase.indexColumns = {"c0", "c1"};
+    descNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    descNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+    descNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeNullableFlatVector<std::string>({std::nullopt}),
+         makeFlatVector<std::string>({"banana"})});
+    descNullsLastTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsLastTestCase.debugString());
+    testIndexBounds(descNullsLastTestCase);
+  }
+
+  // Test Case 10: Multi-column with null in second column lower bound
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeNullableFlatVector<std::string>({std::nullopt})});
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0", "c1"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    // For NULLS_LAST, null is at the end, no increment needed for lower bound
+    ascNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeNullableFlatVector<std::string>({std::nullopt})});
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({makeStringWithNull("peach")})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // DESC order: decrement fails -> unbounded
+    EncodeIndexBoundsTestCase descNullsFirstTestCase;
+    descNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    descNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    descNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeNullableFlatVector<std::string>({std::nullopt})});
+    descNullsFirstTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsFirstTestCase.debugString());
+    testIndexBounds(descNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase descNullsLastTestCase;
+    descNullsLastTestCase.indexColumns = {"c0", "c1"};
+    descNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    descNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeFlatVector<std::string>({"peach"})}),
+        .inclusive = true};
+    descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+    descNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeNullableFlatVector<std::string>({std::nullopt})});
+    descNullsLastTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsLastTestCase.debugString());
+    testIndexBounds(descNullsLastTestCase);
+  }
+
+  // Test Case 11: Multi-column with null in upper bound
+  // For ASC_NULLS_FIRST, null sorts first so incrementing null gives ""
+  // For ASC_NULLS_LAST, null sorts last, increment first column
+  // For DESC orders, decrement fails on first column string
+  {
+    EncodeIndexBoundsTestCase ascNullsFirstTestCase;
+    ascNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    ascNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsFirstTestCase.sortOrder = velox::core::kAscNullsFirst;
+    ascNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    // Incrementing null in NULLS_FIRST gives ""
+    ascNullsFirstTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({"orange"}),
+         makeFlatVector<std::string>({""})});
+    SCOPED_TRACE(ascNullsFirstTestCase.debugString());
+    testIndexBounds(ascNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase ascNullsLastTestCase;
+    ascNullsLastTestCase.indexColumns = {"c0", "c1"};
+    ascNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    ascNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    ascNullsLastTestCase.sortOrder = velox::core::kAscNullsLast;
+    ascNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    // Null at NULLS_LAST can't be incremented, so increment first column
+    ascNullsLastTestCase.expectedUpperBound = makeRowVector(
+        {makeFlatVector<std::string>({makeStringWithNull("orange")}),
+         makeNullableFlatVector<std::string>({std::nullopt})});
+    SCOPED_TRACE(ascNullsLastTestCase.debugString());
+    testIndexBounds(ascNullsLastTestCase);
+
+    // DESC order: decrement fails on null in second column,
+    // then fails on first column "orange" -> unbounded
+    EncodeIndexBoundsTestCase descNullsFirstTestCase;
+    descNullsFirstTestCase.indexColumns = {"c0", "c1"};
+    descNullsFirstTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    descNullsFirstTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    descNullsFirstTestCase.sortOrder = velox::core::kDescNullsFirst;
+    descNullsFirstTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    descNullsFirstTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsFirstTestCase.debugString());
+    testIndexBounds(descNullsFirstTestCase);
+
+    EncodeIndexBoundsTestCase descNullsLastTestCase;
+    descNullsLastTestCase.indexColumns = {"c0", "c1"};
+    descNullsLastTestCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"apple"}),
+             makeFlatVector<std::string>({"banana"})}),
+        .inclusive = true};
+    descNullsLastTestCase.upperBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({"orange"}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = true};
+    descNullsLastTestCase.sortOrder = velox::core::kDescNullsLast;
+    descNullsLastTestCase.expectedLowerBound = makeRowVector(
+        {makeFlatVector<std::string>({"apple"}),
+         makeFlatVector<std::string>({"banana"})});
+    descNullsLastTestCase.expectedUpperBound = std::nullopt;
+    SCOPED_TRACE(descNullsLastTestCase.debugString());
+    testIndexBounds(descNullsLastTestCase);
+  }
+
+  // Test lower bound bump failures
+  // Test Case 11: Single column lower bound bump failure - exclusive bound
+  // with string of max characters
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector({makeFlatVector<std::string>({""})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kDescNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 12: Single column lower bound bump failure - exclusive bound
+  // with null at end
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 13: Multi-column lower bound bump failure - all columns at max
+  // value
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeFlatVector<std::string>({""}),
+             makeFlatVector<std::string>({""})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kDescNullsFirst;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+
+  // Test Case 14: Multi-column lower bound bump failure - all columns at max
+  // value with null
+  {
+    EncodeIndexBoundsTestCase testCase;
+    testCase.indexColumns = {"c0", "c1"};
+    testCase.lowerBound = IndexBound{
+        .bound = makeRowVector(
+            {makeNullableFlatVector<std::string>({std::nullopt}),
+             makeNullableFlatVector<std::string>({std::nullopt})}),
+        .inclusive = false};
+    testCase.upperBound = std::nullopt;
+    testCase.sortOrder = velox::core::kAscNullsLast;
+    testCase.expectedFailure = true;
+    SCOPED_TRACE(testCase.debugString());
+    testIndexBounds(testCase);
+  }
+}
+
+// Test column separator with string + integer columns
+TEST_F(KeyEncoderTest, columnSeparatorTest) {
+  const std::vector<std::string> keyColumns = {"c0", "c1"};
+
+  // Test with multiple input datasets
+  const std::vector<velox::RowVectorPtr> inputs = {
+      makeRowVector({
+          makeFlatVector<std::string>({"0000", "00000"}),
+          makeFlatVector<int32_t>({0, 0}),
+      }),
+      makeRowVector(
+          {makeFlatVector<std::string>({"0000", "00000"}),
+           makeFlatVector<int32_t>({1, 1})})};
+
+  // Test all 4 sort order combinations
+  const std::vector<velox::core::SortOrder> sortOrders = {
+      velox::core::kAscNullsFirst,
+      velox::core::kAscNullsLast,
+      velox::core::kDescNullsFirst,
+      velox::core::kDescNullsLast,
+  };
+
+  for (const auto& input : inputs) {
+    SCOPED_TRACE(fmt::format("input:{}", input->toString(0, input->size())));
+    for (const auto& sortOrder : sortOrders) {
+      SCOPED_TRACE(
+          fmt::format(
+              "sortOrder: {} {}",
+              sortOrder.isAscending() ? "ASC" : "DESC",
+              sortOrder.isNullsFirst() ? "NULLS_FIRST" : "NULLS_LAST"));
+
+      auto encoder = KeyEncoder::create(
+          keyColumns,
+          asRowType(input->type()),
+          {sortOrder, sortOrder},
+          pool_.get());
+
+      // Use the public encode() method
+      std::vector<char> buffer;
+      std::vector<std::string_view> encodedKeys;
+      encoder->encode(input, encodedKeys, [&buffer](size_t size) -> void* {
+        buffer.resize(size);
+        return buffer.data();
+      });
+
+      // Verify we got 2 distinct keys
+      EXPECT_EQ(encodedKeys.size(), 2);
+      EXPECT_NE(encodedKeys[0], encodedKeys[1]);
+
+      if (sortOrder.isAscending()) {
+        EXPECT_LT(encodedKeys[0], encodedKeys[1]);
+      } else {
+        EXPECT_GT(encodedKeys[0], encodedKeys[1]);
+      }
+    }
+  }
+}
+} // namespace facebook::velox::serializer::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/serializers/tests/PrestoSerializerTest.cpp b/velox/serializers/tests/PrestoSerializerTest.cpp
index c4f41f7d69f9..c09e92191578 100644
--- a/velox/serializers/tests/PrestoSerializerTest.cpp
+++ b/velox/serializers/tests/PrestoSerializerTest.cpp
@@ -123,8 +123,11 @@ class PrestoSerializerTest
         serdeOptions == nullptr ? false : serdeOptions->nullsFirst;
     const bool preserveEncodings =
         serdeOptions == nullptr ? false : serdeOptions->preserveEncodings;
+    const bool useMicrosecondPrecision =
+        serdeOptions == nullptr ? false : serdeOptions->useMicrosecondPrecision;
     serializer::presto::PrestoVectorSerde::PrestoOptions paramOptions{
         useLosslessTimestamp, kind, 0.8, nullsFirst, preserveEncodings};
+    paramOptions.useMicrosecondPrecision = useMicrosecondPrecision;
 
     return paramOptions;
   }
@@ -1157,6 +1160,40 @@ TEST_P(PrestoSerializerTest, timestampWithNanosecondPrecision) {
   assertEqualVectors(deserialized, expectedOutputWithLostPrecision);
 }
 
+TEST_P(PrestoSerializerTest, timestampMicrosecondPrecision) {
+  auto timestamps = makeFlatVector<Timestamp>({
+      Timestamp::fromMicros(1704067200000000),
+      Timestamp::fromMicros(1704153600000000),
+      Timestamp::fromMicros(-1000000),
+      Timestamp::fromMicros(0),
+  });
+
+  serializer::presto::PrestoVectorSerde::PrestoOptions opts;
+  opts.useMicrosecondPrecision = true;
+  testRoundTrip(timestamps, &opts);
+}
+
+TEST_P(PrestoSerializerTest, timestampMicrosecondPrecisionSomeNulls) {
+  auto timestamps = makeNullableFlatVector<Timestamp>(
+      {Timestamp::fromMicros(1704067200000000),
+       std::nullopt,
+       Timestamp::fromMicros(0),
+       std::nullopt});
+
+  serializer::presto::PrestoVectorSerde::PrestoOptions opts;
+  opts.useMicrosecondPrecision = true;
+  testRoundTrip(timestamps, &opts);
+}
+
+TEST_P(PrestoSerializerTest, timestampMicrosecondPrecisionAllNulls) {
+  auto timestamps = makeNullableFlatVector<Timestamp>(
+      {std::nullopt, std::nullopt, std::nullopt, std::nullopt});
+
+  serializer::presto::PrestoVectorSerde::PrestoOptions opts;
+  opts.useMicrosecondPrecision = true;
+  testRoundTrip(timestamps, &opts);
+}
+
 TEST_P(PrestoSerializerTest, longDecimal) {
   std::vector<int128_t> decimalValues(102);
   decimalValues[0] = DecimalUtil::kLongDecimalMin;
diff --git a/velox/serializers/tests/SerializedPageFileTest.cpp b/velox/serializers/tests/SerializedPageFileTest.cpp
new file mode 100644
index 000000000000..52a0feb3a487
--- /dev/null
+++ b/velox/serializers/tests/SerializedPageFileTest.cpp
@@ -0,0 +1,555 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "velox/serializers/SerializedPageFile.h"
+#include <boost/random/uniform_int_distribution.hpp>
+#include <folly/Random.h>
+#include <gtest/gtest.h>
+#include <vector>
+#include "folly/experimental/EventCount.h"
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/file/FileSystems.h"
+#include "velox/exec/tests/utils/TempDirectoryPath.h"
+#include "velox/expression/fuzzer/FuzzerToolkit.h"
+#include "velox/serializers/CompactRowSerializer.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/serializers/UnsafeRowSerializer.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::test;
+using namespace facebook::velox::serializer;
+
+enum class SerdeType { kPresto, kCompactRow, kUnsafeRow };
+
+struct TestParams {
+  SerdeType serdeType;
+  common::CompressionKind compressionKind;
+};
+
+class SerializedPageFileTest : public ::testing::TestWithParam<TestParams>,
+                               public VectorTestBase {
+ protected:
+  static void SetUpTestSuite() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    const auto& params = GetParam();
+
+    deregisterVectorSerde();
+    deregisterNamedVectorSerde(VectorSerde::Kind::kPresto);
+    deregisterNamedVectorSerde(VectorSerde::Kind::kCompactRow);
+    deregisterNamedVectorSerde(VectorSerde::Kind::kUnsafeRow);
+
+    setupSerde(params.serdeType);
+    filesystems::registerLocalFileSystem();
+    tempDirPath_ = exec::test::TempDirectoryPath::create();
+    compressionKind_ = params.compressionKind;
+  }
+
+  void TearDown() override {
+    deregisterVectorSerde();
+    deregisterNamedVectorSerde(VectorSerde::Kind::kPresto);
+    deregisterNamedVectorSerde(VectorSerde::Kind::kCompactRow);
+    deregisterNamedVectorSerde(VectorSerde::Kind::kUnsafeRow);
+  }
+
+  void setupSerde(SerdeType serdeType) {
+    switch (serdeType) {
+      case SerdeType::kPresto:
+        serializer::presto::PrestoVectorSerde::registerVectorSerde();
+        serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
+        serde_ = getNamedVectorSerde(VectorSerde::Kind::kPresto);
+        break;
+      case SerdeType::kCompactRow:
+        serializer::CompactRowVectorSerde::registerVectorSerde();
+        serializer::CompactRowVectorSerde::registerNamedVectorSerde();
+        serde_ = getNamedVectorSerde(VectorSerde::Kind::kCompactRow);
+        break;
+      case SerdeType::kUnsafeRow:
+        serializer::spark::UnsafeRowVectorSerde::registerVectorSerde();
+        serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
+        serde_ = getNamedVectorSerde(VectorSerde::Kind::kUnsafeRow);
+        break;
+    }
+  }
+
+  std::unique_ptr<VectorSerde::Options> createSerdeOptions() {
+    const auto& params = GetParam();
+    switch (params.serdeType) {
+      case SerdeType::kPresto:
+        return std::make_unique<
+            serializer::presto::PrestoVectorSerde::PrestoOptions>(
+            false, // useLosslessTimestamp
+            compressionKind_, // compressionKind
+            0.8, // minCompressionRatio
+            false, // nullsFirst
+            false); // preserveEncodings
+      case SerdeType::kCompactRow:
+      case SerdeType::kUnsafeRow:
+        return std::make_unique<VectorSerde::Options>(compressionKind_, 0.8);
+    }
+    return nullptr;
+  }
+
+  RowVectorPtr createTestVector(int32_t numRows) {
+    VectorFuzzer fuzzer({.vectorSize = static_cast<size_t>(numRows)}, pool());
+    auto rowType = ROW({"a", "b", "c"}, {BIGINT(), VARCHAR(), DOUBLE()});
+    return fuzzer.fuzzRow(rowType);
+  }
+
+  std::string getTestFilePath(const std::string& name = "test") {
+    return fmt::format("{}/{}", tempDirPath_->getPath(), name);
+  }
+
+  std::unique_ptr<folly::IOBuf> createTestIOBuf(
+      const std::string& data = "test_data") {
+    return folly::IOBuf::copyBuffer(data);
+  }
+
+  VectorSerde* serde_{nullptr};
+  std::shared_ptr<exec::test::TempDirectoryPath> tempDirPath_;
+  common::CompressionKind compressionKind_;
+};
+
+TEST_P(SerializedPageFileTest, serializedPageFileBasic) {
+  const std::string pathPrefix = getTestFilePath();
+  const uint32_t kFileId = 123;
+
+  auto pageFile = SerializedPageFile::create(kFileId, pathPrefix, "");
+
+  EXPECT_EQ(pageFile->id(), kFileId);
+  EXPECT_TRUE(pageFile->path().find(pathPrefix) == 0);
+  EXPECT_EQ(pageFile->size(), 0);
+  EXPECT_NE(pageFile->file(), nullptr);
+
+  auto iobuf = createTestIOBuf("test data for file");
+  const uint64_t dataSize = iobuf->computeChainDataLength();
+  const uint64_t written = pageFile->write(std::move(iobuf));
+
+  EXPECT_EQ(written, dataSize);
+  EXPECT_EQ(pageFile->size(), dataSize);
+
+  auto fileInfo = pageFile->fileInfo();
+  EXPECT_EQ(fileInfo.id, kFileId);
+  EXPECT_EQ(fileInfo.path, pageFile->path());
+  EXPECT_EQ(fileInfo.size, dataSize);
+
+  pageFile->finish();
+  EXPECT_EQ(pageFile->size(), dataSize);
+  EXPECT_EQ(pageFile->file(), nullptr);
+}
+
+TEST_P(SerializedPageFileTest, serializedPageFileMultipleWrites) {
+  const uint32_t kFileId = 1;
+  const uint32_t kNumWrites = 10;
+
+  const std::string pathPrefix = getTestFilePath();
+  auto pageFile = SerializedPageFile::create(kFileId, pathPrefix, "");
+
+  uint64_t totalSize = 0;
+  for (int i = 0; i < kNumWrites; ++i) {
+    auto data = fmt::format("chunk_{}", i);
+    auto iobuf = createTestIOBuf(data);
+    const uint64_t chunkSize = iobuf->computeChainDataLength();
+    const uint64_t written = pageFile->write(std::move(iobuf));
+    totalSize += chunkSize;
+
+    EXPECT_EQ(written, chunkSize);
+    EXPECT_EQ(pageFile->size(), totalSize);
+  }
+
+  pageFile->finish();
+  EXPECT_EQ(pageFile->size(), totalSize);
+}
+
+TEST_P(SerializedPageFileTest, serializedPageFileWriterBasicOperations) {
+  const std::string pathPrefix = getTestFilePath();
+  const uint64_t kTargetFileSize = 1024;
+  const uint64_t kWriteBufferSize = 512;
+  const uint32_t kRowCount = 100;
+
+  auto serdeOptions = createSerdeOptions();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      std::move(serdeOptions),
+      serde_,
+      pool());
+
+  EXPECT_EQ(writer.numFinishedFiles(), 0);
+
+  auto rowVector = createTestVector(kRowCount);
+  IndexRange range{0, kRowCount};
+  folly::Range<IndexRange*> ranges(&range, 1);
+
+  writer.write(rowVector, ranges);
+
+  writer.finishFile();
+  const auto numFinishedFiles = writer.numFinishedFiles();
+  const auto fileInfos = writer.finish();
+
+  EXPECT_EQ(numFinishedFiles, 1);
+  EXPECT_EQ(fileInfos.size(), numFinishedFiles);
+
+  for (const auto& fileInfo : fileInfos) {
+    EXPECT_FALSE(fileInfo.path.empty());
+    EXPECT_GT(fileInfo.size, 0);
+  }
+}
+
+TEST_P(SerializedPageFileTest, serializedPageFileWriterMultipleBatches) {
+  const uint64_t kTargetFileSize = 1024; // Increased target size
+  const uint64_t kWriteBufferSize = 512; // Smaller buffer to force more flushes
+  const uint32_t kNumWrites = 30; // Fewer writes but larger data
+  const uint32_t kRowsPerBatch = 100; // More rows to generate more data
+
+  const std::string pathPrefix = getTestFilePath();
+  auto serdeOptions = createSerdeOptions();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      std::move(serdeOptions),
+      serde_,
+      pool());
+
+  for (uint32_t i = 0; i < kNumWrites; ++i) {
+    auto rowVector = createTestVector(kRowsPerBatch);
+    IndexRange range{0, kRowsPerBatch};
+    folly::Range<IndexRange*> ranges(&range, 1);
+    writer.write(rowVector, ranges);
+  }
+
+  auto fileInfos = writer.finish();
+  EXPECT_GT(fileInfos.size(), 1);
+
+  uint64_t totalFileSize = 0;
+  for (const auto& fileInfo : fileInfos) {
+    totalFileSize += fileInfo.size;
+  }
+  EXPECT_GT(totalFileSize, 0);
+}
+
+TEST_P(SerializedPageFileTest, serializedPageFileWriterFinishMultipleTimes) {
+  const std::string pathPrefix = getTestFilePath();
+  const uint64_t kTargetFileSize = 1024;
+  const uint64_t kWriteBufferSize = 512;
+  const uint32_t kRowCount = 10;
+
+  auto serdeOptions = createSerdeOptions();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      std::move(serdeOptions),
+      serde_,
+      pool());
+
+  auto rowVector = createTestVector(kRowCount);
+  IndexRange range{0, kRowCount};
+  folly::Range<IndexRange*> ranges(&range, 1);
+  writer.write(rowVector, ranges);
+
+  auto fileInfos = writer.finish();
+  EXPECT_EQ(fileInfos.size(), 1);
+
+  VELOX_ASSERT_THROW(
+      writer.write(rowVector, ranges), "SerializedPageFileWriter has finished");
+}
+
+TEST_P(SerializedPageFileTest, serializedPageRoundTripBasic) {
+  constexpr uint64_t kTargetFileSize = 2048;
+  constexpr uint64_t kWriteBufferSize = 512;
+  constexpr uint64_t kReadBufferSize = 1024;
+
+  const std::string pathPrefix = getTestFilePath();
+  auto writeOptions = createSerdeOptions();
+  auto readOptions = createSerdeOptions();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      std::move(writeOptions),
+      serde_,
+      pool());
+
+  auto originalVector = createTestVector(100);
+  IndexRange range{0, 100};
+  folly::Range<IndexRange*> ranges(&range, 1);
+  writer.write(originalVector, ranges);
+
+  auto fileInfos = writer.finish();
+
+  // Since we only write once with a small vector (100 rows) and large target
+  // file size (2048 bytes), there should be exactly one file created
+  ASSERT_EQ(fileInfos.size(), 1);
+
+  const auto& filePath = fileInfos[0].path;
+  SerializedPageFileReader reader(
+      filePath,
+      kReadBufferSize,
+      asRowType(originalVector->type()),
+      serde_,
+      createSerdeOptions(),
+      pool());
+
+  RowVectorPtr readVector;
+  bool hasData = reader.nextBatch(readVector);
+  EXPECT_TRUE(hasData);
+
+  // Verify that the data content is identical
+  test::assertEqualVectors(originalVector, readVector);
+
+  // Verify there's no more data after the first batch
+  hasData = reader.nextBatch(readVector);
+  EXPECT_FALSE(hasData);
+}
+
+TEST_P(SerializedPageFileTest, serializedPageRoundTripMultipleBatches) {
+  const uint64_t kTargetFileSize = 256;
+  const uint64_t kWriteBufferSize = 100;
+  const uint64_t kReadBufferSize = 256;
+  const uint32_t kNumWrites = 30;
+  const uint32_t kRowsPerBatch = 50;
+  const auto pathPrefix = getTestFilePath();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      createSerdeOptions(),
+      serde_,
+      pool());
+
+  std::vector<RowVectorPtr> originalVectors;
+  IndexRange range{0, kRowsPerBatch};
+  folly::Range<IndexRange*> ranges(&range, 1);
+  for (int i = 0; i < kNumWrites; ++i) {
+    auto vector = createTestVector(kRowsPerBatch);
+    originalVectors.push_back(vector);
+    writer.write(vector, ranges);
+  }
+
+  auto fileInfos = writer.finish();
+  ASSERT_GT(fileInfos.size(), 1);
+
+  // Read from ALL files that were created and collect all the data
+  std::vector<RowVectorPtr> readVectors;
+
+  for (const auto& fileInfo : fileInfos) {
+    SerializedPageFileReader reader(
+        fileInfo.path,
+        kReadBufferSize,
+        asRowType(originalVectors[0]->type()),
+        serde_,
+        createSerdeOptions(),
+        pool());
+
+    RowVectorPtr readVector;
+    while (reader.nextBatch(readVector)) {
+      EXPECT_NE(readVector, nullptr);
+      EXPECT_EQ(
+          readVector->type()->toString(),
+          originalVectors[0]->type()->toString());
+      readVectors.push_back(readVector);
+    }
+  }
+
+  test::assertEqualVectors(
+      fuzzer::mergeRowVectors(originalVectors, pool()),
+      fuzzer::mergeRowVectors(readVectors, pool()));
+}
+
+TEST_P(SerializedPageFileTest, roundTripWithComplexTypes) {
+  // Skip UnsafeRow for complex types as it has limitations with nested
+  // structures
+  if (GetParam().serdeType == SerdeType::kUnsafeRow) {
+    GTEST_SKIP() << "UnsafeRow does not support complex nested types";
+  }
+
+  const uint64_t kTargetFileSize = 1024; // Small to encourage multiple files
+  const uint64_t kWriteBufferSize = 256;
+  const uint64_t kReadBufferSize = 512;
+  const uint64_t kNumWrites = 20;
+  const uint64_t kBatchSize = 30;
+  const std::string pathPrefix = getTestFilePath();
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      createSerdeOptions(),
+      serde_,
+      pool());
+
+  VectorFuzzer fuzzer({.vectorSize = kBatchSize}, pool());
+  auto complexType =
+      ROW({"int_field", "string_field", "array_field", "map_field"},
+          {BIGINT(), VARCHAR(), ARRAY(INTEGER()), MAP(VARCHAR(), DOUBLE())});
+
+  // Write multiple batches with complex data
+  std::vector<RowVectorPtr> originalVectors;
+  for (int i = 0; i < kNumWrites; ++i) {
+    auto vector = fuzzer.fuzzRow(complexType);
+    originalVectors.push_back(vector);
+    IndexRange range{0, kBatchSize};
+    folly::Range<IndexRange*> ranges(&range, 1);
+    writer.write(vector, ranges);
+  }
+
+  auto fileInfos = writer.finish();
+  ASSERT_GT(fileInfos.size(), 1);
+
+  // Read from ALL files that were created and collect all the data
+  std::vector<RowVectorPtr> readVectors;
+
+  for (const auto& fileInfo : fileInfos) {
+    SerializedPageFileReader reader(
+        fileInfo.path,
+        kReadBufferSize,
+        asRowType(originalVectors[0]->type()),
+        serde_,
+        createSerdeOptions(),
+        pool());
+
+    RowVectorPtr readVector;
+    while (reader.nextBatch(readVector)) {
+      EXPECT_NE(readVector, nullptr);
+      EXPECT_EQ(
+          readVector->type()->toString(),
+          originalVectors[0]->type()->toString());
+      readVectors.push_back(readVector);
+    }
+  }
+
+  // Compare the concatenated vectors for exact data equality
+  test::assertEqualVectors(
+      fuzzer::mergeRowVectors(originalVectors, pool()),
+      fuzzer::mergeRowVectors(readVectors, pool()));
+}
+TEST_P(SerializedPageFileTest, emptyBatches) {
+  const std::string pathPrefix = getTestFilePath();
+  const uint64_t kTargetFileSize = 1024;
+  const uint64_t kWriteBufferSize = 512;
+
+  SerializedPageFileWriter writer(
+      pathPrefix,
+      kTargetFileSize,
+      kWriteBufferSize,
+      "",
+      createSerdeOptions(),
+      serde_,
+      pool());
+
+  auto rowType = ROW({"a", "b", "c"}, {BIGINT(), VARCHAR(), DOUBLE()});
+  auto emptyVector = BaseVector::create<RowVector>(rowType, 0, pool());
+
+  IndexRange range{0, 0};
+  folly::Range<IndexRange*> ranges(&range, 1);
+  writer.write(emptyVector, ranges);
+
+  auto fileInfos = writer.finish();
+  EXPECT_EQ(fileInfos.size(), 0);
+}
+
+// Generate test parameters for different serde types and compression kinds
+std::vector<TestParams> generateTestParams() {
+  std::vector<TestParams> params;
+
+  std::vector<SerdeType> serdeTypes = {
+      SerdeType::kPresto,
+  };
+
+  std::vector<common::CompressionKind> compressionKinds = {
+      common::CompressionKind::CompressionKind_NONE,
+      common::CompressionKind::CompressionKind_ZLIB,
+      common::CompressionKind::CompressionKind_SNAPPY,
+      common::CompressionKind::CompressionKind_ZSTD,
+      common::CompressionKind::CompressionKind_LZ4,
+      common::CompressionKind::CompressionKind_GZIP};
+
+  for (const auto& serdeType : serdeTypes) {
+    for (const auto& compressionKind : compressionKinds) {
+      params.push_back({serdeType, compressionKind});
+    }
+  }
+
+  return params;
+}
+
+// Custom test name generator
+std::string testNameGenerator(
+    const ::testing::TestParamInfo<TestParams>& info) {
+  std::string serdeName;
+  switch (info.param.serdeType) {
+    case SerdeType::kPresto:
+      serdeName = "Presto";
+      break;
+    case SerdeType::kCompactRow:
+      serdeName = "CompactRow";
+      break;
+    case SerdeType::kUnsafeRow:
+      serdeName = "UnsafeRow";
+      break;
+    default:
+      VELOX_UNSUPPORTED();
+  }
+
+  std::string compressionName;
+  switch (info.param.compressionKind) {
+    case common::CompressionKind::CompressionKind_NONE:
+      compressionName = "NoCompression";
+      break;
+    case common::CompressionKind::CompressionKind_ZLIB:
+      compressionName = "ZLIB";
+      break;
+    case common::CompressionKind::CompressionKind_SNAPPY:
+      compressionName = "Snappy";
+      break;
+    case common::CompressionKind::CompressionKind_ZSTD:
+      compressionName = "ZSTD";
+      break;
+    case common::CompressionKind::CompressionKind_LZ4:
+      compressionName = "LZ4";
+      break;
+    case common::CompressionKind::CompressionKind_GZIP:
+      compressionName = "GZIP";
+      break;
+    default:
+      VELOX_UNSUPPORTED();
+  }
+
+  return serdeName + "_" + compressionName;
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    SerializedPageFileTest,
+    SerializedPageFileTest,
+    ::testing::ValuesIn(generateTestParams()),
+    testNameGenerator);
diff --git a/velox/serializers/tests/UnsafeRowSerializerTest.cpp b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
index 36642caf993e..0a3f04fb8eb5 100644
--- a/velox/serializers/tests/UnsafeRowSerializerTest.cpp
+++ b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
@@ -26,9 +26,15 @@ using namespace facebook::velox;
 struct TestParam {
   common::CompressionKind compressionKind;
   bool appendRow;
-
-  TestParam(common::CompressionKind _compressionKind, bool _appendRow)
-      : compressionKind(_compressionKind), appendRow(_appendRow) {}
+  bool microBatchDeserialize;
+
+  TestParam(
+      common::CompressionKind _compressionKind,
+      bool _appendRow,
+      bool _microBatchDeserialize)
+      : compressionKind(_compressionKind),
+        appendRow(_appendRow),
+        microBatchDeserialize(_microBatchDeserialize) {}
 };
 
 class UnsafeRowSerializerTest : public ::testing::Test,
@@ -37,12 +43,18 @@ class UnsafeRowSerializerTest : public ::testing::Test,
  public:
   static std::vector<TestParam> getTestParams() {
     static std::vector<TestParam> testParams = {
-        {common::CompressionKind::CompressionKind_NONE, false},
-        {common::CompressionKind::CompressionKind_ZLIB, true},
-        {common::CompressionKind::CompressionKind_SNAPPY, false},
-        {common::CompressionKind::CompressionKind_ZSTD, true},
-        {common::CompressionKind::CompressionKind_LZ4, false},
-        {common::CompressionKind::CompressionKind_GZIP, true}};
+        {common::CompressionKind::CompressionKind_NONE, false, false},
+        {common::CompressionKind::CompressionKind_NONE, false, true},
+        {common::CompressionKind::CompressionKind_ZLIB, true, false},
+        {common::CompressionKind::CompressionKind_ZLIB, true, true},
+        {common::CompressionKind::CompressionKind_SNAPPY, false, false},
+        {common::CompressionKind::CompressionKind_SNAPPY, false, true},
+        {common::CompressionKind::CompressionKind_ZSTD, true, false},
+        {common::CompressionKind::CompressionKind_ZSTD, true, true},
+        {common::CompressionKind::CompressionKind_LZ4, false, false},
+        {common::CompressionKind::CompressionKind_LZ4, false, true},
+        {common::CompressionKind::CompressionKind_GZIP, true, false},
+        {common::CompressionKind::CompressionKind_GZIP, true, true}};
     return testParams;
   }
 
@@ -63,6 +75,7 @@ class UnsafeRowSerializerTest : public ::testing::Test,
         VectorSerde::Kind::kUnsafeRow);
     appendRow_ = GetParam().appendRow;
     compressionKind_ = GetParam().compressionKind;
+    microBatchDeserialize_ = GetParam().microBatchDeserialize;
     options_ = std::make_unique<VectorSerde::Options>(compressionKind_, 0.8);
   }
 
@@ -131,14 +144,121 @@ class UnsafeRowSerializerTest : public ::testing::Test,
     return std::make_unique<BufferInputStream>(std::move(ranges));
   }
 
+  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 concatenateRowVectors(
+      const std::vector<RowVectorPtr>& rowVectors,
+      velox::memory::MemoryPool* pool) {
+    if (rowVectors.empty()) {
+      return nullptr;
+    }
+
+    // Ensure all RowVectors have the same schema.
+    auto rowType = rowVectors.front()->type();
+    for (const auto& rowVector : rowVectors) {
+      VELOX_CHECK(
+          rowVector->type()->equivalent(*rowType),
+          "RowVectors must have the same schema");
+    }
+
+    // Calculate total size.
+    vector_size_t totalSize = 0;
+    for (const auto& rowVector : rowVectors) {
+      totalSize += rowVector->size();
+    }
+
+    // Create nulls buffer if any input has nulls
+    BufferPtr nulls = nullptr;
+    for (const auto& rowVector : rowVectors) {
+      if (rowVector->nulls()) {
+        nulls = AlignedBuffer::allocate<bool>(totalSize, pool, bits::kNotNull);
+        break;
+      }
+    }
+
+    // Concatenate child vectors.
+    std::vector<VectorPtr> concatenatedChildren;
+    for (size_t i = 0; i < rowType->size(); ++i) {
+      std::vector<VectorPtr> childVectors;
+      for (const auto& rowVector : rowVectors) {
+        childVectors.push_back(rowVector->childAt(i));
+      }
+      concatenatedChildren.push_back(
+          BaseVector::create(rowType->childAt(i), totalSize, pool));
+      vector_size_t offset = 0;
+      for (const auto& childVector : childVectors) {
+        concatenatedChildren.back()->copy(
+            childVector.get(), offset, 0, childVector->size());
+        offset += childVector->size();
+      }
+    }
+
+    // Copy nulls if needed
+    if (nulls != nullptr) {
+      auto rawNulls = nulls->asMutable<uint64_t>();
+      vector_size_t offset = 0;
+      for (const auto& rowVector : rowVectors) {
+        if (rowVector->nulls()) {
+          bits::copyBits(
+              rowVector->nulls()->as<uint64_t>(),
+              0,
+              rawNulls,
+              offset,
+              rowVector->size());
+        }
+        offset += rowVector->size();
+      }
+    }
+
+    return std::make_shared<RowVector>(
+        pool, rowType, nulls, totalSize, std::move(concatenatedChildren));
+  }
+
   RowVectorPtr deserialize(
       std::shared_ptr<const RowType> rowType,
       const std::vector<std::string_view>& input) {
     auto byteStream = toByteStream(input);
-
     RowVectorPtr result;
-    getVectorSerde()->deserialize(
-        byteStream.get(), pool_.get(), rowType, &result, options_.get());
+    if (microBatchDeserialize_) {
+      static constexpr int32_t kBatchSize = 3;
+      std::unique_ptr<RowIterator> rowIterator;
+      std::vector<RowVectorPtr> results;
+      while (!byteStream->atEnd() ||
+             (rowIterator != nullptr && rowIterator->hasNext())) {
+        results.emplace_back();
+        dynamic_cast<serializer::spark::UnsafeRowVectorSerde*>(getVectorSerde())
+            ->deserialize(
+                byteStream.get(),
+                rowIterator,
+                kBatchSize,
+                rowType,
+                &results.back(),
+                pool_.get(),
+                options_.get());
+      }
+      result = concatenateRowVectors(results, pool_.get());
+    } else {
+      getVectorSerde()->deserialize(
+          byteStream.get(), pool_.get(), rowType, &result, options_.get());
+    }
     return result;
   }
 
@@ -206,6 +326,7 @@ class UnsafeRowSerializerTest : public ::testing::Test,
   common::CompressionKind compressionKind_;
   std::unique_ptr<VectorSerde::Options> options_;
   bool appendRow_;
+  bool microBatchDeserialize_;
 };
 
 // These expected binary buffers were samples taken using Spark's java code.
@@ -512,4 +633,12 @@ TEST_P(UnsafeRowSerializerTest, multiPage) {
 VELOX_INSTANTIATE_TEST_SUITE_P(
     UnsafeRowSerializerTest,
     UnsafeRowSerializerTest,
-    testing::ValuesIn(UnsafeRowSerializerTest::getTestParams()));
+    testing::ValuesIn(UnsafeRowSerializerTest::getTestParams()),
+    [](const testing::TestParamInfo<TestParam>& info) {
+      return fmt::format(
+          "{}_{}_{}",
+          compressionKindToString(info.param.compressionKind),
+          info.param.appendRow ? "append" : "batch",
+          info.param.microBatchDeserialize ? "rowDeserialize"
+                                           : "batchDeserialize");
+    });
diff --git a/velox/substrait/CMakeLists.txt b/velox/substrait/CMakeLists.txt
deleted file mode 100644
index 13ce0e01a981..000000000000
--- a/velox/substrait/CMakeLists.txt
+++ /dev/null
@@ -1,70 +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 up Proto
-set(proto_directory ${CMAKE_CURRENT_SOURCE_DIR}/proto)
-set(substrait_proto_directory ${CMAKE_CURRENT_SOURCE_DIR}/proto/substrait)
-set(PROTO_OUTPUT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/proto/")
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/proto/substrait)
-file(GLOB PROTO_FILES ${substrait_proto_directory}/*.proto
-     ${substrait_proto_directory}/extensions/*.proto)
-foreach(PROTO ${PROTO_FILES})
-  file(RELATIVE_PATH REL_PROTO ${substrait_proto_directory} ${PROTO})
-  string(REGEX REPLACE "\\.proto" "" PROTO_NAME ${REL_PROTO})
-  list(APPEND PROTO_SRCS "${PROTO_OUTPUT_DIR}/substrait/${PROTO_NAME}.pb.cc")
-  list(APPEND PROTO_HDRS "${PROTO_OUTPUT_DIR}/substrait/${PROTO_NAME}.pb.h")
-endforeach()
-set(PROTO_OUTPUT_FILES ${PROTO_HDRS} ${PROTO_SRCS})
-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 ${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})
-add_dependencies(substrait_proto protobuf::libprotobuf)
-
-set(SRCS
-    ${PROTO_SRCS}
-    SubstraitExtensionCollector.cpp
-    SubstraitParser.cpp
-    SubstraitToVeloxExpr.cpp
-    SubstraitToVeloxPlan.cpp
-    TypeUtils.cpp
-    VeloxSubstraitSignature.cpp
-    VeloxToSubstraitExpr.cpp
-    VeloxToSubstraitPlan.cpp
-    VeloxToSubstraitType.cpp
-    VariantToVectorConverter.cpp)
-
-velox_add_library(velox_substrait_plan_converter ${SRCS})
-target_include_directories(velox_substrait_plan_converter
-                           PUBLIC ${PROTO_OUTPUT_DIR})
-velox_link_libraries(velox_substrait_plan_converter velox_connector
-                     velox_dwio_dwrf_common)
-
-if(${VELOX_BUILD_TESTING})
-  add_subdirectory(tests)
-endif()
diff --git a/velox/substrait/SubstraitExtensionCollector.cpp b/velox/substrait/SubstraitExtensionCollector.cpp
deleted file mode 100644
index 1b78832d92a5..000000000000
--- a/velox/substrait/SubstraitExtensionCollector.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 "velox/substrait/SubstraitExtensionCollector.h"
-
-namespace facebook::velox::substrait {
-
-int SubstraitExtensionCollector::getReferenceNumber(
-    const std::string& functionName,
-    const std::vector<TypePtr>& arguments) {
-  const auto& substraitFunctionSignature =
-      VeloxSubstraitSignature::toSubstraitSignature(functionName, arguments);
-  // TODO: Currently we treat all velox registry based function signatures as
-  // custom substrait extension, so no uri link and leave it as empty.
-  return getReferenceNumber({"", substraitFunctionSignature});
-}
-
-int SubstraitExtensionCollector::getReferenceNumber(
-    const std::string& functionName,
-    const std::vector<TypePtr>& arguments,
-    const core::AggregationNode::Step /* aggregationStep */) {
-  // TODO: Ignore aggregationStep for now, will refactor when introduce velox
-  // registry for function signature binding
-  return getReferenceNumber(functionName, arguments);
-}
-
-template <typename T>
-bool SubstraitExtensionCollector::BiDirectionHashMap<T>::putIfAbsent(
-    const int& key,
-    const T& value) {
-  if (forwardMap_.find(key) == forwardMap_.end() &&
-      reverseMap_.find(value) == reverseMap_.end()) {
-    forwardMap_[key] = value;
-    reverseMap_[value] = key;
-    return true;
-  }
-  return false;
-}
-
-void SubstraitExtensionCollector::addExtensionsToPlan(
-    ::substrait::Plan* plan) const {
-  using SimpleExtensionURI = ::substrait::extensions::SimpleExtensionURI;
-  // Currently we don't introduce any substrait extension YAML files, so always
-  // only have one URI.
-  SimpleExtensionURI* extensionUri = plan->add_extension_uris();
-  extensionUri->set_extension_uri_anchor(1);
-
-  for (const auto& [referenceNum, functionId] :
-       extensionFunctions_->forwardMap()) {
-    auto extensionFunction =
-        plan->add_extensions()->mutable_extension_function();
-    extensionFunction->set_extension_uri_reference(
-        extensionUri->extension_uri_anchor());
-    extensionFunction->set_function_anchor(referenceNum);
-    extensionFunction->set_name(functionId.signature);
-  }
-}
-
-SubstraitExtensionCollector::SubstraitExtensionCollector() {
-  extensionFunctions_ =
-      std::make_shared<BiDirectionHashMap<ExtensionFunctionId>>();
-}
-
-int SubstraitExtensionCollector::getReferenceNumber(
-    const ExtensionFunctionId& extensionFunctionId) {
-  const auto& extensionFunctionAnchorIt =
-      extensionFunctions_->reverseMap().find(extensionFunctionId);
-  if (extensionFunctionAnchorIt != extensionFunctions_->reverseMap().end()) {
-    return extensionFunctionAnchorIt->second;
-  }
-  ++functionReferenceNumber;
-  extensionFunctions_->putIfAbsent(
-      functionReferenceNumber, extensionFunctionId);
-  return functionReferenceNumber;
-}
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/SubstraitExtensionCollector.h b/velox/substrait/SubstraitExtensionCollector.h
deleted file mode 100644
index 56a4d00795aa..000000000000
--- a/velox/substrait/SubstraitExtensionCollector.h
+++ /dev/null
@@ -1,117 +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>
-#include "velox/core/Expressions.h"
-#include "velox/core/PlanNode.h"
-#include "velox/substrait/VeloxSubstraitSignature.h"
-#include "velox/substrait/proto/substrait/algebra.pb.h"
-#include "velox/substrait/proto/substrait/plan.pb.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::substrait {
-
-struct ExtensionFunctionId {
-  /// Substrait extension YAML file uri.
-  std::string uri;
-
-  /// Substrait signature used in the function extension declaration is a
-  /// combination of the name of the function along with a list of input
-  /// argument types.The format is as follows : <function
-  /// name>:<short_arg_type0>_<short_arg_type1>_..._<short_arg_typeN> for more
-  /// detail information about the argument type please refer to link
-  /// https://substrait.io/extensions/#function-signature-compound-names.
-  std::string signature;
-
-  bool operator==(const ExtensionFunctionId& other) const {
-    return (uri == other.uri && signature == other.signature);
-  }
-};
-
-/// Assigns unique IDs to function signatures using ExtensionFunctionId.
-class SubstraitExtensionCollector {
- public:
-  SubstraitExtensionCollector();
-
-  /// Given a scalar function name and argument types, return the functionId
-  /// using ExtensionFunctionId.
-  int getReferenceNumber(
-      const std::string& functionName,
-      const std::vector<TypePtr>& arguments);
-
-  /// Given an aggregate function name and argument types and aggregation Step,
-  /// return the functionId using ExtensionFunctionId.
-  int getReferenceNumber(
-      const std::string& functionName,
-      const std::vector<TypePtr>& arguments,
-      core::AggregationNode::Step aggregationStep);
-
-  /// Add extension functions to Substrait plan.
-  void addExtensionsToPlan(::substrait::Plan* plan) const;
-
- private:
-  /// A bi-direction hash map to keep the relation between reference number and
-  /// either function or type signature.
-  template <class T>
-  class BiDirectionHashMap {
-   public:
-    /// Add (key, value) pair if doesn't exist already, i.e. forwardMap doesn't
-    /// contain the key and reverseMap doesn't contain the value.
-    ///
-    /// @return True if the values were added successfully. False, otherwise.
-    bool putIfAbsent(const int& key, const T& value);
-
-    const std::unordered_map<int, ExtensionFunctionId> forwardMap() const {
-      return forwardMap_;
-    }
-
-    const std::unordered_map<T, int>& reverseMap() const {
-      return reverseMap_;
-    }
-
-   private:
-    std::unordered_map<int, T> forwardMap_;
-    std::unordered_map<T, int> reverseMap_;
-  };
-
-  /// Assigns unique IDs to function signatures using ExtensionFunctionId.
-  int getReferenceNumber(const ExtensionFunctionId& extensionFunctionId);
-
-  int functionReferenceNumber = -1;
-  std::shared_ptr<BiDirectionHashMap<ExtensionFunctionId>> extensionFunctions_;
-};
-
-using SubstraitExtensionCollectorPtr =
-    std::shared_ptr<SubstraitExtensionCollector>;
-
-} // namespace facebook::velox::substrait
-
-namespace std {
-
-/// Hash function of facebook::velox::substrait::ExtensionFunctionId.
-template <>
-struct hash<facebook::velox::substrait::ExtensionFunctionId> {
-  size_t operator()(
-      const facebook::velox::substrait::ExtensionFunctionId& k) const {
-    size_t val = hash<std::string>()(k.uri);
-    val = val * 31 + hash<std::string>()(k.signature);
-    return val;
-  }
-};
-
-} // namespace std
diff --git a/velox/substrait/SubstraitParser.cpp b/velox/substrait/SubstraitParser.cpp
deleted file mode 100644
index c2a22c68180f..000000000000
--- a/velox/substrait/SubstraitParser.cpp
+++ /dev/null
@@ -1,217 +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/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 {
-
-TypePtr SubstraitParser::parseType(const ::substrait::Type& substraitType) {
-  switch (substraitType.kind_case()) {
-    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: {
-      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));
-      }
-      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& 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();
-      return MAP(parseType(keyType), parseType(valueType));
-    }
-    case ::substrait::Type::KindCase::kUserDefined:
-      // We only support UNKNOWN type to handle the null literal whose type is
-      // not known.
-      return UNKNOWN();
-    case ::substrait::Type::KindCase::kDate:
-      return DATE();
-    default:
-      VELOX_NYI(
-          "Parsing for Substrait type not supported: {}",
-          substraitType.DebugString());
-  }
-}
-
-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<TypePtr> typeList;
-  typeList.reserve(substraitTypes.size());
-  for (const auto& type : substraitTypes) {
-    typeList.emplace_back(parseType(type));
-  }
-  return typeList;
-}
-
-int32_t SubstraitParser::parseReferenceSegment(
-    const ::substrait::Expression::ReferenceSegment& refSegment) {
-  auto typeCase = refSegment.reference_type_case();
-  switch (typeCase) {
-    case ::substrait::Expression::ReferenceSegment::ReferenceTypeCase::
-        kStructField: {
-      return refSegment.struct_field().field();
-    }
-    default:
-      VELOX_NYI(
-          "Substrait conversion not supported for ReferenceSegment '{}'",
-          std::to_string(typeCase));
-  }
-}
-
-std::vector<std::string> SubstraitParser::makeNames(
-    const std::string& prefix,
-    int size) {
-  std::vector<std::string> names;
-  names.reserve(size);
-  for (int i = 0; i < size; i++) {
-    names.emplace_back(fmt::format("{}_{}", prefix, i));
-  }
-  return names;
-}
-
-std::string SubstraitParser::makeNodeName(int node_id, int col_idx) {
-  return fmt::format("n{}_{}", node_id, col_idx);
-}
-
-int SubstraitParser::getIdxFromNodeName(const std::string& nodeName) {
-  // Get the position of "_" in the function name.
-  std::size_t pos = nodeName.find("_");
-  if (pos == std::string::npos) {
-    VELOX_FAIL("Invalid node name.");
-  }
-  if (pos == nodeName.size() - 1) {
-    VELOX_FAIL("Invalid node name.");
-  }
-  // Get the column index.
-  std::string colIdx = nodeName.substr(pos + 1);
-  try {
-    return stoi(colIdx);
-  } catch (const std::exception& err) {
-    VELOX_FAIL(err.what());
-  }
-}
-
-const std::string& SubstraitParser::findFunctionSpec(
-    const std::unordered_map<uint64_t, std::string>& functionMap,
-    uint64_t id) const {
-  if (functionMap.find(id) == functionMap.end()) {
-    VELOX_FAIL("Could not find function id {} in function map.", id);
-  }
-  std::unordered_map<uint64_t, std::string>& map =
-      const_cast<std::unordered_map<uint64_t, std::string>&>(functionMap);
-  return map[id];
-}
-
-std::string SubstraitParser::findVeloxFunction(
-    const std::unordered_map<uint64_t, std::string>& functionMap,
-    uint64_t id) const {
-  std::string funcSpec = findFunctionSpec(functionMap, id);
-  std::string_view funcName = getNameBeforeDelimiter(funcSpec, ":");
-  return mapToVeloxFunction({funcName.begin(), funcName.end()});
-}
-
-std::string SubstraitParser::mapToVeloxFunction(
-    const std::string& substraitFunction) const {
-  auto it = substraitVeloxFunctionMap_.find(substraitFunction);
-  if (it != substraitVeloxFunctionMap_.end()) {
-    return it->second;
-  }
-
-  // If not finding the mapping from Substrait function name to Velox function
-  // name, the original Substrait function name will be used.
-  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
deleted file mode 100644
index 806619952996..000000000000
--- a/velox/substrait/SubstraitParser.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 "velox/substrait/proto/substrait/algebra.pb.h"
-#include "velox/substrait/proto/substrait/capabilities.pb.h"
-#include "velox/substrait/proto/substrait/extensions/extensions.pb.h"
-#include "velox/substrait/proto/substrait/function.pb.h"
-#include "velox/substrait/proto/substrait/parameterized_types.pb.h"
-#include "velox/substrait/proto/substrait/plan.pb.h"
-#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:
-  /// Parse Substrait NamedStruct.
-  std::vector<TypePtr> parseNamedStruct(
-      const ::substrait::NamedStruct& namedStruct);
-
-  /// Parse Substrait Type.
-  TypePtr parseType(const ::substrait::Type& substraitType);
-
-  /// Parse Substrait ReferenceSegment.
-  int32_t parseReferenceSegment(
-      const ::substrait::Expression::ReferenceSegment& refSegment);
-
-  /// Make names in the format of {prefix}_{index}.
-  std::vector<std::string> makeNames(const std::string& prefix, int size);
-
-  /// Make node name in the format of n{nodeId}_{colIdx}.
-  std::string makeNodeName(int nodeId, int colIdx);
-
-  /// Get the column index from a node name in the format of
-  /// n{nodeId}_{colIdx}.
-  int getIdxFromNodeName(const std::string& nodeName);
-
-  /// Find the Substrait function name according to the function id
-  /// from a pre-constructed function map. The function specification can be
-  /// a simple name or a compound name. The compound name format is:
-  /// <function name>:<short_arg_type0>_<short_arg_type1>_..._<short_arg_typeN>.
-  /// Currently, the input types in the function specification are not used. But
-  /// in the future, they should be used for the validation according the
-  /// specifications in Substrait yaml files.
-  const std::string& findFunctionSpec(
-      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(
-      const std::unordered_map<uint64_t, std::string>& functionMap,
-      uint64_t id) const;
-
-  /// 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
-  /// keyword. For those functions with different names in Substrait and Velox,
-  /// a mapping relation should be added here.
-  std::unordered_map<std::string, std::string> substraitVeloxFunctionMap_ = {
-      {"add", "plus"},
-      {"subtract", "minus"},
-      {"modulus", "mod"},
-      {"not_equal", "neq"},
-      {"equal", "eq"}};
-};
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/SubstraitToVeloxExpr.cpp b/velox/substrait/SubstraitToVeloxExpr.cpp
deleted file mode 100644
index 93cf168dfccc..000000000000
--- a/velox/substrait/SubstraitToVeloxExpr.cpp
+++ /dev/null
@@ -1,393 +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/substrait/SubstraitToVeloxExpr.h"
-#include "velox/substrait/TypeUtils.h"
-#include "velox/vector/FlatVector.h"
-
-using namespace facebook::velox;
-namespace {
-// Get values for the different supported types.
-template <typename T>
-T getLiteralValue(const ::substrait::Expression::Literal& /* literal */) {
-  VELOX_NYI();
-}
-
-template <>
-int8_t getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return static_cast<int8_t>(literal.i8());
-}
-
-template <>
-int16_t getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return static_cast<int16_t>(literal.i16());
-}
-
-template <>
-int32_t getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return literal.i32();
-}
-
-template <>
-int64_t getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return literal.i64();
-}
-
-template <>
-double getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return literal.fp64();
-}
-
-template <>
-float getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return literal.fp32();
-}
-
-template <>
-bool getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return literal.boolean();
-}
-
-template <>
-uint32_t getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return literal.i32();
-}
-
-template <>
-Timestamp getLiteralValue(const ::substrait::Expression::Literal& literal) {
-  return Timestamp::fromMicros(literal.timestamp());
-}
-
-ArrayVectorPtr makeArrayVector(const VectorPtr& elements) {
-  BufferPtr offsets = allocateOffsets(1, elements->pool());
-  BufferPtr sizes = allocateOffsets(1, elements->pool());
-  sizes->asMutable<vector_size_t>()[0] = elements->size();
-
-  return std::make_shared<ArrayVector>(
-      elements->pool(),
-      ARRAY(elements->type()),
-      nullptr,
-      1,
-      offsets,
-      sizes,
-      elements);
-}
-
-ArrayVectorPtr makeEmptyArrayVector(memory::MemoryPool* pool) {
-  BufferPtr offsets = allocateOffsets(1, pool);
-  BufferPtr sizes = allocateOffsets(1, pool);
-  return std::make_shared<ArrayVector>(
-      pool, ARRAY(UNKNOWN()), nullptr, 1, offsets, sizes, nullptr);
-}
-
-template <typename T>
-void setLiteralValue(
-    const ::substrait::Expression::Literal& literal,
-    FlatVector<T>* vector,
-    vector_size_t index) {
-  if (literal.has_null()) {
-    vector->setNull(index, true);
-  } else if constexpr (std::is_same_v<T, StringView>) {
-    if (literal.has_string()) {
-      vector->set(index, StringView(literal.string()));
-    } else if (literal.has_var_char()) {
-      vector->set(index, StringView(literal.var_char().value()));
-    } else {
-      VELOX_FAIL("Unexpected string literal");
-    }
-  } else if (vector->type()->isDate()) {
-    auto dateVector = vector->template asFlatVector<int32_t>();
-    dateVector->set(index, static_cast<int32_t>(literal.date()));
-  } else {
-    vector->set(index, getLiteralValue<T>(literal));
-  }
-}
-
-template <TypeKind kind>
-VectorPtr constructFlatVector(
-    const ::substrait::Expression::Literal& listLiteral,
-    const vector_size_t size,
-    const TypePtr& type,
-    memory::MemoryPool* pool) {
-  VELOX_CHECK(type->isPrimitiveType());
-  auto vector = BaseVector::create(type, size, pool);
-  using T = typename TypeTraits<kind>::NativeType;
-  auto flatVector = vector->as<FlatVector<T>>();
-
-  vector_size_t index = 0;
-  for (auto child : listLiteral.list().values()) {
-    setLiteralValue(child, flatVector, index++);
-  }
-  return vector;
-}
-
-/// Whether null will be returned on cast failure.
-bool isNullOnFailure(
-    ::substrait::Expression::Cast::FailureBehavior failureBehavior) {
-  switch (failureBehavior) {
-    case ::substrait::
-        Expression_Cast_FailureBehavior_FAILURE_BEHAVIOR_UNSPECIFIED:
-    case ::substrait::
-        Expression_Cast_FailureBehavior_FAILURE_BEHAVIOR_THROW_EXCEPTION:
-      return false;
-    case ::substrait::
-        Expression_Cast_FailureBehavior_FAILURE_BEHAVIOR_RETURN_NULL:
-      return true;
-    default:
-      VELOX_NYI(
-          "The given failure behavior is NOT supported: '{}'", failureBehavior);
-  }
-}
-
-} // namespace
-
-namespace facebook::velox::substrait {
-
-std::shared_ptr<const core::FieldAccessTypedExpr>
-SubstraitVeloxExprConverter::toVeloxExpr(
-    const ::substrait::Expression::FieldReference& substraitField,
-    const RowTypePtr& inputType) {
-  auto typeCase = substraitField.reference_type_case();
-  switch (typeCase) {
-    case ::substrait::Expression::FieldReference::ReferenceTypeCase::
-        kDirectReference: {
-      const auto& directRef = substraitField.direct_reference();
-      int32_t colIdx = substraitParser_.parseReferenceSegment(directRef);
-      const auto& inputNames = inputType->names();
-      const int64_t inputSize = inputNames.size();
-      if (colIdx <= inputSize) {
-        const auto& inputTypes = inputType->children();
-        // Convert type to row.
-        return std::make_shared<core::FieldAccessTypedExpr>(
-            inputTypes[colIdx],
-            std::make_shared<core::InputTypedExpr>(inputTypes[colIdx]),
-            inputNames[colIdx]);
-      } else {
-        VELOX_FAIL("Missing the column with id '{}' .", colIdx);
-      }
-    }
-    default:
-      VELOX_NYI(
-          "Substrait conversion not supported for Reference '{}'", typeCase);
-  }
-}
-
-core::TypedExprPtr SubstraitVeloxExprConverter::toVeloxExpr(
-    const ::substrait::Expression::ScalarFunction& substraitFunc,
-    const RowTypePtr& inputType) {
-  std::vector<core::TypedExprPtr> params;
-  params.reserve(substraitFunc.arguments().size());
-  for (const auto& sArg : substraitFunc.arguments()) {
-    params.emplace_back(toVeloxExpr(sArg.value(), inputType));
-  }
-  const auto& veloxFunction = substraitParser_.findVeloxFunction(
-      functionMap_, substraitFunc.function_reference());
-  return std::make_shared<const core::CallTypedExpr>(
-      substraitParser_.parseType(substraitFunc.output_type()),
-      std::move(params),
-      veloxFunction);
-}
-
-std::shared_ptr<const core::ConstantTypedExpr>
-SubstraitVeloxExprConverter::toVeloxExpr(
-    const ::substrait::Expression::Literal& substraitLit) {
-  auto typeCase = substraitLit.literal_type_case();
-  switch (typeCase) {
-    case ::substrait::Expression_Literal::LiteralTypeCase::kBoolean:
-      return std::make_shared<core::ConstantTypedExpr>(
-          BOOLEAN(), variant(substraitLit.boolean()));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kI8:
-      // SubstraitLit.i8() will return int32, so we need this type conversion.
-      return std::make_shared<core::ConstantTypedExpr>(
-          TINYINT(), variant(static_cast<int8_t>(substraitLit.i8())));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kI16:
-      // SubstraitLit.i16() will return int32, so we need this type conversion.
-      return std::make_shared<core::ConstantTypedExpr>(
-          SMALLINT(), variant(static_cast<int16_t>(substraitLit.i16())));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kI32:
-      return std::make_shared<core::ConstantTypedExpr>(
-          INTEGER(), variant(substraitLit.i32()));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kFp32:
-      return std::make_shared<core::ConstantTypedExpr>(
-          REAL(), variant(substraitLit.fp32()));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kI64:
-      return std::make_shared<core::ConstantTypedExpr>(
-          BIGINT(), variant(substraitLit.i64()));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kFp64:
-      return std::make_shared<core::ConstantTypedExpr>(
-          DOUBLE(), variant(substraitLit.fp64()));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kString:
-      return std::make_shared<core::ConstantTypedExpr>(
-          VARCHAR(), variant(substraitLit.string()));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kNull: {
-      auto veloxType = substraitParser_.parseType(substraitLit.null());
-      return std::make_shared<core::ConstantTypedExpr>(
-          veloxType, variant::null(veloxType->kind()));
-    }
-    case ::substrait::Expression_Literal::LiteralTypeCase::kVarChar:
-      return std::make_shared<core::ConstantTypedExpr>(
-          VARCHAR(), variant(substraitLit.var_char().value()));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kList: {
-      auto constantVector =
-          BaseVector::wrapInConstant(1, 0, literalsToArrayVector(substraitLit));
-      return std::make_shared<const core::ConstantTypedExpr>(constantVector);
-    }
-    case ::substrait::Expression_Literal::LiteralTypeCase::kDate:
-      return std::make_shared<core::ConstantTypedExpr>(
-          DATE(), variant(static_cast<int32_t>(substraitLit.date())));
-    default:
-      VELOX_NYI(
-          "Substrait conversion not supported for type case '{}'", typeCase);
-  }
-}
-
-ArrayVectorPtr SubstraitVeloxExprConverter::literalsToArrayVector(
-    const ::substrait::Expression::Literal& listLiteral) {
-  auto childSize = listLiteral.list().values().size();
-  if (childSize == 0) {
-    return makeEmptyArrayVector(pool_);
-  }
-  auto typeCase = listLiteral.list().values(0).literal_type_case();
-  switch (typeCase) {
-    case ::substrait::Expression_Literal::LiteralTypeCase::kBoolean:
-      return makeArrayVector(constructFlatVector<TypeKind::BOOLEAN>(
-          listLiteral, childSize, BOOLEAN(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kI8:
-      return makeArrayVector(constructFlatVector<TypeKind::TINYINT>(
-          listLiteral, childSize, TINYINT(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kI16:
-      return makeArrayVector(constructFlatVector<TypeKind::SMALLINT>(
-          listLiteral, childSize, SMALLINT(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kI32:
-      return makeArrayVector(constructFlatVector<TypeKind::INTEGER>(
-          listLiteral, childSize, INTEGER(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kFp32:
-      return makeArrayVector(constructFlatVector<TypeKind::REAL>(
-          listLiteral, childSize, REAL(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kI64:
-      return makeArrayVector(constructFlatVector<TypeKind::BIGINT>(
-          listLiteral, childSize, BIGINT(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kFp64:
-      return makeArrayVector(constructFlatVector<TypeKind::DOUBLE>(
-          listLiteral, childSize, DOUBLE(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kString:
-    case ::substrait::Expression_Literal::LiteralTypeCase::kVarChar:
-      return makeArrayVector(constructFlatVector<TypeKind::VARCHAR>(
-          listLiteral, childSize, VARCHAR(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kNull: {
-      auto veloxType = substraitParser_.parseType(listLiteral.null());
-      auto kind = veloxType->kind();
-      return makeArrayVector(VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-          constructFlatVector, kind, listLiteral, childSize, veloxType, pool_));
-    }
-    case ::substrait::Expression_Literal::LiteralTypeCase::kDate:
-      return makeArrayVector(constructFlatVector<TypeKind::INTEGER>(
-          listLiteral, childSize, DATE(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kTimestamp:
-      return makeArrayVector(constructFlatVector<TypeKind::TIMESTAMP>(
-          listLiteral, childSize, TIMESTAMP(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kIntervalDayToSecond:
-      return makeArrayVector(constructFlatVector<TypeKind::BIGINT>(
-          listLiteral, childSize, INTERVAL_DAY_TIME(), pool_));
-    case ::substrait::Expression_Literal::LiteralTypeCase::kList: {
-      VectorPtr elements;
-      for (auto it : listLiteral.list().values()) {
-        auto v = literalsToArrayVector(it);
-        if (!elements) {
-          elements = v;
-        } else {
-          elements->append(v.get());
-        }
-      }
-      return makeArrayVector(elements);
-    }
-    default:
-      VELOX_NYI(
-          "literalsToArrayVector not supported for type case '{}'", typeCase);
-  }
-}
-
-core::TypedExprPtr SubstraitVeloxExprConverter::toVeloxExpr(
-    const ::substrait::Expression::Cast& castExpr,
-    const RowTypePtr& inputType) {
-  auto type = substraitParser_.parseType(castExpr.type());
-  bool nullOnFailure = isNullOnFailure(castExpr.failure_behavior());
-
-  std::vector<core::TypedExprPtr> inputs{
-      toVeloxExpr(castExpr.input(), inputType)};
-
-  return std::make_shared<core::CastTypedExpr>(type, inputs, nullOnFailure);
-}
-
-core::TypedExprPtr SubstraitVeloxExprConverter::toVeloxExpr(
-    const ::substrait::Expression& substraitExpr,
-    const RowTypePtr& inputType) {
-  core::TypedExprPtr veloxExpr;
-  auto typeCase = substraitExpr.rex_type_case();
-  switch (typeCase) {
-    case ::substrait::Expression::RexTypeCase::kLiteral:
-      return toVeloxExpr(substraitExpr.literal());
-    case ::substrait::Expression::RexTypeCase::kScalarFunction:
-      return toVeloxExpr(substraitExpr.scalar_function(), inputType);
-    case ::substrait::Expression::RexTypeCase::kSelection:
-      return toVeloxExpr(substraitExpr.selection(), inputType);
-    case ::substrait::Expression::RexTypeCase::kCast:
-      return toVeloxExpr(substraitExpr.cast(), inputType);
-    case ::substrait::Expression::RexTypeCase::kIfThen:
-      return toVeloxExpr(substraitExpr.if_then(), inputType);
-    default:
-      VELOX_NYI(
-          "Substrait conversion not supported for Expression '{}'", typeCase);
-  }
-}
-
-core::TypedExprPtr SubstraitVeloxExprConverter::toVeloxExpr(
-    const ::substrait::Expression_IfThen& substraitIfThen,
-    const RowTypePtr& inputType) {
-  std::vector<core::TypedExprPtr> inputs;
-  if (substraitIfThen.has_else_()) {
-    inputs.reserve(substraitIfThen.ifs_size() * 2 + 1);
-  } else {
-    inputs.reserve(substraitIfThen.ifs_size() * 2);
-  }
-
-  TypePtr resultType;
-  for (auto& ifExpr : substraitIfThen.ifs()) {
-    auto ifClauseExpr = toVeloxExpr(ifExpr.if_(), inputType);
-    inputs.emplace_back(ifClauseExpr);
-    auto thenClauseExpr = toVeloxExpr(ifExpr.then(), inputType);
-    inputs.emplace_back(thenClauseExpr);
-
-    if (!thenClauseExpr->type()->containsUnknown()) {
-      resultType = thenClauseExpr->type();
-    }
-  }
-
-  if (substraitIfThen.has_else_()) {
-    auto elseClauseExpr = toVeloxExpr(substraitIfThen.else_(), inputType);
-    inputs.emplace_back(elseClauseExpr);
-    if (!resultType && !elseClauseExpr->type()->containsUnknown()) {
-      resultType = elseClauseExpr->type();
-    }
-  }
-
-  VELOX_CHECK_NOT_NULL(resultType, "Result type not found");
-
-  return std::make_shared<const core::CallTypedExpr>(
-      resultType, std::move(inputs), "if");
-}
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/SubstraitToVeloxExpr.h b/velox/substrait/SubstraitToVeloxExpr.h
deleted file mode 100644
index 0c53d82d4553..000000000000
--- a/velox/substrait/SubstraitToVeloxExpr.h
+++ /dev/null
@@ -1,121 +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 "velox/core/Expressions.h"
-#include "velox/substrait/SubstraitParser.h"
-#include "velox/vector/ComplexVector.h"
-
-namespace facebook::velox::substrait {
-
-/// This class is used to convert Substrait representations to Velox
-/// expressions.
-class SubstraitVeloxExprConverter {
- public:
-  /// subParser: A Substrait parser used to convert Substrait representations
-  /// into recognizable representations. functionMap: A pre-constructed map
-  /// storing the relations between the function id and the function name.
-  explicit SubstraitVeloxExprConverter(
-      memory::MemoryPool* pool,
-      const std::unordered_map<uint64_t, std::string>& functionMap)
-      : pool_(pool), functionMap_(functionMap) {}
-
-  /// Convert Substrait Field into Velox Field Expression.
-  std::shared_ptr<const core::FieldAccessTypedExpr> toVeloxExpr(
-      const ::substrait::Expression::FieldReference& substraitField,
-      const RowTypePtr& inputType);
-
-  /// Convert Substrait ScalarFunction into Velox Expression.
-  core::TypedExprPtr toVeloxExpr(
-      const ::substrait::Expression::ScalarFunction& substraitFunc,
-      const RowTypePtr& inputType);
-
-  /// Convert Substrait CastExpression to Velox Expression.
-  core::TypedExprPtr toVeloxExpr(
-      const ::substrait::Expression::Cast& castExpr,
-      const RowTypePtr& inputType);
-
-  /// Convert Substrait Literal into Velox Expression.
-  std::shared_ptr<const core::ConstantTypedExpr> toVeloxExpr(
-      const ::substrait::Expression::Literal& substraitLit);
-
-  /// Convert Substrait Expression into Velox Expression.
-  core::TypedExprPtr toVeloxExpr(
-      const ::substrait::Expression& substraitExpr,
-      const RowTypePtr& inputType);
-
-  /// Convert Substrait IfThen into Velox Expression.
-  core::TypedExprPtr toVeloxExpr(
-      const ::substrait::Expression::IfThen& substraitIfThen,
-      const RowTypePtr& inputType);
-
- private:
-  /// Convert list literal to ArrayVector.
-  ArrayVectorPtr literalsToArrayVector(
-      const ::substrait::Expression::Literal& listLiteral);
-
-  /// Memory pool.
-  memory::MemoryPool* pool_;
-
-  /// The Substrait parser used to convert Substrait representations into
-  /// recognizable representations.
-  SubstraitParser substraitParser_;
-
-  /// The map storing the relations between the function id and the function
-  /// name.
-  std::unordered_map<uint64_t, std::string> functionMap_;
-};
-
-} // 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
deleted file mode 100644
index 0a8ae48a5932..000000000000
--- a/velox/substrait/SubstraitToVeloxPlan.cpp
+++ /dev/null
@@ -1,789 +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/substrait/SubstraitToVeloxPlan.h"
-#include "velox/substrait/TypeUtils.h"
-#include "velox/substrait/VariantToVectorConverter.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::substrait {
-namespace {
-core::AggregationNode::Step toAggregationStep(
-    const ::substrait::AggregateRel& sAgg) {
-  if (sAgg.measures().size() == 0) {
-    // When only groupings exist, set the phase to be Single.
-    return core::AggregationNode::Step::kSingle;
-  }
-
-  // Use the first measure to set aggregation phase.
-  const auto& firstMeasure = sAgg.measures()[0];
-  const auto& aggFunction = firstMeasure.measure();
-  switch (aggFunction.phase()) {
-    case ::substrait::AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE:
-      return core::AggregationNode::Step::kPartial;
-    case ::substrait::AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE:
-      return core::AggregationNode::Step::kIntermediate;
-    case ::substrait::AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT:
-      return core::AggregationNode::Step::kFinal;
-    case ::substrait::AGGREGATION_PHASE_INITIAL_TO_RESULT:
-      return core::AggregationNode::Step::kSingle;
-    default:
-      VELOX_FAIL("Aggregate phase is not supported.");
-  }
-}
-
-core::SortOrder toSortOrder(const ::substrait::SortField& sortField) {
-  switch (sortField.direction()) {
-    case ::substrait::SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_FIRST:
-      return core::kAscNullsFirst;
-    case ::substrait::SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_LAST:
-      return core::kAscNullsLast;
-    case ::substrait::SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST:
-      return core::kDescNullsFirst;
-    case ::substrait::SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST:
-      return core::kDescNullsLast;
-    default:
-      VELOX_FAIL("Sort direction is not supported.");
-  }
-}
-
-/// Holds the information required to create
-/// a project node to simulate the emit
-/// behavior in Substrait.
-struct EmitInfo {
-  std::vector<core::TypedExprPtr> expressions;
-  std::vector<std::string> projectNames;
-};
-
-/// Helper function to extract the attributes required to create a ProjectNode
-/// used for interpretting Substrait Emit.
-EmitInfo getEmitInfo(
-    const ::substrait::RelCommon& relCommon,
-    const core::PlanNodePtr& node) {
-  const auto& emit = relCommon.emit();
-  int emitSize = emit.output_mapping_size();
-  EmitInfo emitInfo;
-  emitInfo.projectNames.reserve(emitSize);
-  emitInfo.expressions.reserve(emitSize);
-  const auto& outputType = node->outputType();
-  for (int i = 0; i < emitSize; i++) {
-    int32_t mapId = emit.output_mapping(i);
-    emitInfo.projectNames[i] = outputType->nameOf(mapId);
-    emitInfo.expressions[i] = std::make_shared<core::FieldAccessTypedExpr>(
-        outputType->childAt(mapId), outputType->nameOf(mapId));
-  }
-  return emitInfo;
-}
-
-} // namespace
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::processEmit(
-    const ::substrait::RelCommon& relCommon,
-    const core::PlanNodePtr& noEmitNode) {
-  switch (relCommon.emit_kind_case()) {
-    case ::substrait::RelCommon::EmitKindCase::kDirect:
-      return noEmitNode;
-    case ::substrait::RelCommon::EmitKindCase::kEmit: {
-      auto emitInfo = getEmitInfo(relCommon, noEmitNode);
-      return std::make_shared<core::ProjectNode>(
-          nextPlanNodeId(),
-          std::move(emitInfo.projectNames),
-          std::move(emitInfo.expressions),
-          noEmitNode);
-    }
-    default:
-      VELOX_FAIL("unrecognized emit kind");
-  }
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::AggregateRel& aggRel) {
-  auto childNode = convertSingleInput<::substrait::AggregateRel>(aggRel);
-  core::AggregationNode::Step aggStep = toAggregationStep(aggRel);
-  const auto& inputType = childNode->outputType();
-  std::vector<core::FieldAccessTypedExprPtr> veloxGroupingExprs;
-
-  // Get the grouping expressions.
-  for (const auto& grouping : aggRel.groupings()) {
-    for (const auto& groupingExpr : grouping.grouping_expressions()) {
-      // Velox's groupings are limited to be Field.
-      veloxGroupingExprs.emplace_back(
-          exprConverter_->toVeloxExpr(groupingExpr.selection(), inputType));
-    }
-  }
-
-  // Parse measures and get the aggregate expressions.
-  // Each measure represents one aggregate expression.
-  std::vector<core::AggregationNode::Aggregate> aggregates;
-  aggregates.reserve(aggRel.measures().size());
-
-  for (const auto& measure : aggRel.measures()) {
-    core::FieldAccessTypedExprPtr mask;
-    ::substrait::Expression substraitAggMask = measure.filter();
-    // Get Aggregation Masks.
-    if (measure.has_filter()) {
-      if (substraitAggMask.ByteSizeLong() > 0) {
-        mask = std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-            exprConverter_->toVeloxExpr(substraitAggMask, inputType));
-      }
-    }
-
-    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 = 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, rawInputTypes, mask, {}, {}});
-  }
-
-  bool ignoreNullKeys = false;
-  std::vector<core::FieldAccessTypedExprPtr> preGroupingExprs;
-
-  // Get the output names of Aggregation.
-  std::vector<std::string> aggOutNames;
-  aggOutNames.reserve(aggRel.measures().size());
-  for (int idx = veloxGroupingExprs.size();
-       idx < veloxGroupingExprs.size() + aggRel.measures().size();
-       idx++) {
-    aggOutNames.emplace_back(substraitParser_->makeNodeName(planNodeId_, idx));
-  }
-
-  auto aggregationNode = std::make_shared<core::AggregationNode>(
-      nextPlanNodeId(),
-      aggStep,
-      veloxGroupingExprs,
-      preGroupingExprs,
-      aggOutNames,
-      aggregates,
-      ignoreNullKeys,
-      childNode);
-
-  if (aggRel.has_common()) {
-    return processEmit(aggRel.common(), std::move(aggregationNode));
-  } else {
-    return aggregationNode;
-  }
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::ProjectRel& projectRel) {
-  auto childNode = convertSingleInput<::substrait::ProjectRel>(projectRel);
-
-  // Construct Velox Expressions.
-  auto projectExprs = projectRel.expressions();
-  std::vector<std::string> projectNames;
-  std::vector<core::TypedExprPtr> expressions;
-  projectNames.reserve(projectExprs.size());
-  expressions.reserve(projectExprs.size());
-
-  const auto& inputType = childNode->outputType();
-  int colIdx = 0;
-  // Note that Substrait projection adds the project expressions on top of the
-  // input to the projection node. Thus we need to add the input columns first
-  // and then add the projection expressions.
-
-  // First, adding the project names and expressions from the input to
-  // the project node.
-  for (uint32_t idx = 0; idx < inputType->size(); idx++) {
-    const auto& fieldName = inputType->nameOf(idx);
-    projectNames.emplace_back(fieldName);
-    expressions.emplace_back(std::make_shared<core::FieldAccessTypedExpr>(
-        inputType->childAt(idx), fieldName));
-    colIdx += 1;
-  }
-
-  // Then, adding project expression related project names and expressions.
-  for (const auto& expr : projectExprs) {
-    expressions.emplace_back(exprConverter_->toVeloxExpr(expr, inputType));
-    projectNames.emplace_back(
-        substraitParser_->makeNodeName(planNodeId_, colIdx));
-    colIdx += 1;
-  }
-
-  if (projectRel.has_common()) {
-    auto relCommon = projectRel.common();
-    const auto& emit = relCommon.emit();
-    int emitSize = emit.output_mapping_size();
-    std::vector<std::string> emitProjectNames(emitSize);
-    std::vector<core::TypedExprPtr> emitExpressions(emitSize);
-    for (int i = 0; i < emitSize; i++) {
-      int32_t mapId = emit.output_mapping(i);
-      emitProjectNames[i] = projectNames[mapId];
-      emitExpressions[i] = expressions[mapId];
-    }
-    return std::make_shared<core::ProjectNode>(
-        nextPlanNodeId(),
-        std::move(emitProjectNames),
-        std::move(emitExpressions),
-        std::move(childNode));
-  } else {
-    return std::make_shared<core::ProjectNode>(
-        nextPlanNodeId(),
-        std::move(projectNames),
-        std::move(expressions),
-        std::move(childNode));
-  }
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::SortRel& sortRel) {
-  auto childNode = convertSingleInput<::substrait::SortRel>(sortRel);
-
-  auto [sortingKeys, sortingOrders] =
-      processSortField(sortRel.sorts(), childNode->outputType());
-
-  return std::make_shared<core::OrderByNode>(
-      nextPlanNodeId(),
-      sortingKeys,
-      sortingOrders,
-      false /*isPartial*/,
-      childNode);
-}
-
-std::pair<
-    std::vector<core::FieldAccessTypedExprPtr>,
-    std::vector<core::SortOrder>>
-SubstraitVeloxPlanConverter::processSortField(
-    const ::google::protobuf::RepeatedPtrField<::substrait::SortField>&
-        sortFields,
-    const RowTypePtr& inputType) {
-  std::vector<core::FieldAccessTypedExprPtr> sortingKeys;
-  std::vector<core::SortOrder> sortingOrders;
-  sortingKeys.reserve(sortFields.size());
-  sortingOrders.reserve(sortFields.size());
-
-  for (const auto& sort : sortFields) {
-    sortingOrders.emplace_back(toSortOrder(sort));
-
-    if (sort.has_expr()) {
-      auto expression = exprConverter_->toVeloxExpr(sort.expr(), inputType);
-      auto fieldExpr =
-          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(
-              expression);
-      VELOX_CHECK_NOT_NULL(
-          fieldExpr, " the sorting key in Sort Operator only support field");
-      sortingKeys.emplace_back(fieldExpr);
-    }
-  }
-  return {sortingKeys, sortingOrders};
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::FilterRel& filterRel) {
-  auto childNode = convertSingleInput<::substrait::FilterRel>(filterRel);
-
-  auto filterNode = std::make_shared<core::FilterNode>(
-      nextPlanNodeId(),
-      exprConverter_->toVeloxExpr(
-          filterRel.condition(), childNode->outputType()),
-      childNode);
-
-  if (filterRel.has_common()) {
-    return processEmit(filterRel.common(), std::move(filterNode));
-  } else {
-    return filterNode;
-  }
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::FetchRel& fetchRel) {
-  core::PlanNodePtr childNode;
-  // Check the input of fetchRel, if it's sortRel, convert them into
-  // topNNode. otherwise, to limitNode.
-  ::substrait::SortRel sortRel;
-  bool topNFlag;
-  if (fetchRel.has_input()) {
-    topNFlag = fetchRel.input().has_sort();
-    if (topNFlag) {
-      sortRel = fetchRel.input().sort();
-      childNode = toVeloxPlan(sortRel.input());
-    } else {
-      childNode = toVeloxPlan(fetchRel.input());
-    }
-  } else {
-    VELOX_FAIL("Child Rel is expected in FetchRel.");
-  }
-
-  if (topNFlag) {
-    auto [sortingKeys, sortingOrders] =
-        processSortField(sortRel.sorts(), childNode->outputType());
-
-    VELOX_CHECK_EQ(fetchRel.offset(), 0);
-
-    return std::make_shared<core::TopNNode>(
-        nextPlanNodeId(),
-        sortingKeys,
-        sortingOrders,
-        (int32_t)fetchRel.count(),
-        false /*isPartial*/,
-        childNode);
-
-  } else {
-    return std::make_shared<core::LimitNode>(
-        nextPlanNodeId(),
-        static_cast<int32_t>(fetchRel.offset()),
-        static_cast<int32_t>(fetchRel.count()),
-        false /*isPartial*/,
-        childNode);
-  }
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::ReadRel& readRel,
-    std::shared_ptr<SplitInfo>& splitInfo) {
-  // emit is not allowed in TableScanNode and ValuesNode related
-  // outputs
-  if (readRel.has_common()) {
-    VELOX_USER_CHECK(
-        !readRel.common().has_emit(),
-        "Emit not supported for ValuesNode and TableScanNode related Substrait plans.");
-  }
-  // Get output names and types.
-  std::vector<std::string> colNameList;
-  std::vector<TypePtr> veloxTypeList;
-  if (readRel.has_base_schema()) {
-    const auto& baseSchema = readRel.base_schema();
-    colNameList.reserve(baseSchema.names().size());
-    for (const auto& name : baseSchema.names()) {
-      colNameList.emplace_back(name);
-    }
-    veloxTypeList = substraitParser_->parseNamedStruct(baseSchema);
-  }
-
-  // Parse local files
-  if (readRel.has_local_files()) {
-    using SubstraitFileFormatCase =
-        ::substrait::ReadRel_LocalFiles_FileOrFiles::FileFormatCase;
-    const auto& fileList = readRel.local_files().items();
-    splitInfo->paths.reserve(fileList.size());
-    splitInfo->starts.reserve(fileList.size());
-    splitInfo->lengths.reserve(fileList.size());
-    for (const auto& file : fileList) {
-      // Expect all files to share the same index.
-      splitInfo->partitionIndex = file.partition_index();
-      splitInfo->paths.emplace_back(file.uri_file());
-      splitInfo->starts.emplace_back(file.start());
-      splitInfo->lengths.emplace_back(file.length());
-      switch (file.file_format_case()) {
-        case SubstraitFileFormatCase::kOrc:
-          splitInfo->format = dwio::common::FileFormat::DWRF;
-          break;
-        case SubstraitFileFormatCase::kParquet:
-          splitInfo->format = dwio::common::FileFormat::PARQUET;
-          break;
-        default:
-          splitInfo->format = dwio::common::FileFormat::UNKNOWN;
-      }
-    }
-  }
-
-  // Do not hard-code connector ID and allow for connectors other than Hive.
-  static const std::string kHiveConnectorId = "test-hive";
-
-  // Velox requires Filter Pushdown must being enabled.
-  bool filterPushdownEnabled = true;
-  std::shared_ptr<connector::hive::HiveTableHandle> tableHandle;
-  if (!readRel.has_filter()) {
-    tableHandle = std::make_shared<connector::hive::HiveTableHandle>(
-        kHiveConnectorId,
-        "hive_table",
-        filterPushdownEnabled,
-        common::SubfieldFilters{},
-        nullptr,
-        nullptr);
-  } else {
-    common::SubfieldFilters filters =
-        toVeloxFilter(colNameList, veloxTypeList, readRel.filter());
-    tableHandle = std::make_shared<connector::hive::HiveTableHandle>(
-        kHiveConnectorId,
-        "hive_table",
-        filterPushdownEnabled,
-        std::move(filters),
-        nullptr,
-        nullptr);
-  }
-
-  // Get assignments and out names.
-  std::vector<std::string> outNames;
-  outNames.reserve(colNameList.size());
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
-  for (int idx = 0; idx < colNameList.size(); idx++) {
-    auto outName = substraitParser_->makeNodeName(planNodeId_, idx);
-    assignments[outName] = std::make_shared<connector::hive::HiveColumnHandle>(
-        colNameList[idx],
-        connector::hive::HiveColumnHandle::ColumnType::kRegular,
-        veloxTypeList[idx],
-        veloxTypeList[idx]);
-    outNames.emplace_back(outName);
-  }
-  auto outputType = ROW(std::move(outNames), std::move(veloxTypeList));
-
-  if (readRel.has_virtual_table()) {
-    return toVeloxPlan(readRel, outputType);
-  } else {
-    return std::make_shared<core::TableScanNode>(
-        nextPlanNodeId(),
-        std::move(outputType),
-        std::move(tableHandle),
-        std::move(assignments));
-  }
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::ReadRel& readRel,
-    const RowTypePtr& type) {
-  ::substrait::ReadRel_VirtualTable readVirtualTable = readRel.virtual_table();
-  int64_t numVectors = readVirtualTable.values_size();
-  int64_t numColumns = type->size();
-  int64_t valueFieldNums =
-      readVirtualTable.values(numVectors - 1).fields_size();
-  std::vector<RowVectorPtr> vectors;
-  vectors.reserve(numVectors);
-
-  int64_t batchSize;
-  // For the empty vectors, eg,vectors = makeRowVector(ROW({}, {}), 1).
-  if (numColumns == 0) {
-    batchSize = 1;
-  } else {
-    batchSize = valueFieldNums / numColumns;
-  }
-
-  for (int64_t index = 0; index < numVectors; ++index) {
-    std::vector<VectorPtr> children;
-    ::substrait::Expression_Literal_Struct rowValue =
-        readRel.virtual_table().values(index);
-    auto fieldSize = rowValue.fields_size();
-    VELOX_CHECK_EQ(fieldSize, batchSize * numColumns);
-
-    for (int64_t col = 0; col < numColumns; ++col) {
-      const TypePtr& outputChildType = type->childAt(col);
-      std::vector<variant> batchChild;
-      batchChild.reserve(batchSize);
-      for (int64_t batchId = 0; batchId < batchSize; batchId++) {
-        // each value in the batch
-        auto fieldIdx = col * batchSize + batchId;
-        ::substrait::Expression_Literal field = rowValue.fields(fieldIdx);
-
-        auto expr = exprConverter_->toVeloxExpr(field);
-        if (auto constantExpr =
-                std::dynamic_pointer_cast<const core::ConstantTypedExpr>(
-                    expr)) {
-          if (!constantExpr->hasValueVector()) {
-            batchChild.emplace_back(constantExpr->value());
-          } else {
-            VELOX_UNSUPPORTED(
-                "Values node with complex type values is not supported yet");
-          }
-        } else {
-          VELOX_FAIL("Expected constant expression");
-        }
-      }
-      children.emplace_back(
-          setVectorFromVariants(outputChildType, batchChild, pool_));
-    }
-
-    vectors.emplace_back(
-        std::make_shared<RowVector>(pool_, type, nullptr, batchSize, children));
-  }
-
-  return std::make_shared<core::ValuesNode>(
-      nextPlanNodeId(), std::move(vectors));
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::Rel& rel) {
-  if (rel.has_aggregate()) {
-    return toVeloxPlan(rel.aggregate());
-  }
-  if (rel.has_project()) {
-    return toVeloxPlan(rel.project());
-  }
-  if (rel.has_filter()) {
-    return toVeloxPlan(rel.filter());
-  }
-  if (rel.has_read()) {
-    auto splitInfo = std::make_shared<SplitInfo>();
-
-    auto planNode = toVeloxPlan(rel.read(), splitInfo);
-    splitInfoMap_[planNode->id()] = splitInfo;
-    return planNode;
-  }
-  if (rel.has_fetch()) {
-    return toVeloxPlan(rel.fetch());
-  }
-  if (rel.has_sort()) {
-    return toVeloxPlan(rel.sort());
-  }
-  VELOX_NYI("Substrait conversion not supported for Rel.");
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::RelRoot& root) {
-  // TODO: Use the names as the output names for the whole computing.
-  if (root.has_input()) {
-    const auto& rel = root.input();
-    return toVeloxPlan(rel);
-  }
-  VELOX_FAIL("Input is expected in RelRoot.");
-}
-
-core::PlanNodePtr SubstraitVeloxPlanConverter::toVeloxPlan(
-    const ::substrait::Plan& substraitPlan) {
-  VELOX_CHECK(
-      checkTypeExtension(substraitPlan),
-      "The type extension only have unknown type.");
-  // Construct the function map based on the Substrait representation.
-  constructFunctionMap(substraitPlan);
-
-  // Construct the expression converter.
-  exprConverter_ =
-      std::make_shared<SubstraitVeloxExprConverter>(pool_, functionMap_);
-
-  // In fact, only one RelRoot or Rel is expected here.
-  VELOX_CHECK_EQ(substraitPlan.relations_size(), 1);
-  const auto& rel = substraitPlan.relations(0);
-  if (rel.has_root()) {
-    return toVeloxPlan(rel.root());
-  }
-  if (rel.has_rel()) {
-    return toVeloxPlan(rel.rel());
-  }
-
-  VELOX_FAIL("RelRoot or Rel is expected in Plan.");
-}
-
-std::string SubstraitVeloxPlanConverter::nextPlanNodeId() {
-  auto id = fmt::format("{}", planNodeId_);
-  planNodeId_++;
-  return id;
-}
-
-// This class contains the needed infos for Filter Pushdown.
-// TODO: Support different types here.
-class FilterInfo {
- public:
-  // Used to set the left bound.
-  void setLeft(double left, bool isExclusive) {
-    left_ = left;
-    leftExclusive_ = isExclusive;
-    if (!isInitialized_) {
-      isInitialized_ = true;
-    }
-  }
-
-  // Used to set the right bound.
-  void setRight(double right, bool isExclusive) {
-    right_ = right;
-    rightExclusive_ = isExclusive;
-    if (!isInitialized_) {
-      isInitialized_ = true;
-    }
-  }
-
-  // Will fordis Null value if called once.
-  void forbidsNull() {
-    nullAllowed_ = false;
-    if (!isInitialized_) {
-      isInitialized_ = true;
-    }
-  }
-
-  // Return the initialization status.
-  bool isInitialized() {
-    return isInitialized_ ? true : false;
-  }
-
-  // The left bound.
-  std::optional<double> left_ = std::nullopt;
-  // The right bound.
-  std::optional<double> right_ = std::nullopt;
-  // The Null allowing.
-  bool nullAllowed_ = true;
-  // If true, left bound will be exclusive.
-  bool leftExclusive_ = false;
-  // If true, right bound will be exclusive.
-  bool rightExclusive_ = false;
-
- private:
-  bool isInitialized_ = false;
-};
-
-common::SubfieldFilters SubstraitVeloxPlanConverter::toVeloxFilter(
-    const std::vector<std::string>& inputNameList,
-    const std::vector<TypePtr>& inputTypeList,
-    const ::substrait::Expression& substraitFilter) {
-  common::SubfieldFilters filters;
-  // A map betweesn the column index and the FilterInfo for that column.
-  std::unordered_map<int, std::shared_ptr<FilterInfo>> colInfoMap;
-  for (int idx = 0; idx < inputNameList.size(); idx++) {
-    colInfoMap[idx] = std::make_shared<FilterInfo>();
-  }
-
-  std::vector<::substrait::Expression_ScalarFunction> scalarFunctions;
-  flattenConditions(substraitFilter, scalarFunctions);
-  // Construct the FilterInfo for the related column.
-  for (const auto& scalarFunction : scalarFunctions) {
-    auto filterNameSpec = substraitParser_->findFunctionSpec(
-        functionMap_, scalarFunction.function_reference());
-    auto filterName = getNameBeforeDelimiter(filterNameSpec, ":");
-    int32_t colIdx;
-    // TODO: Add different types' support here.
-    double val;
-    for (auto& arg : scalarFunction.arguments()) {
-      auto argExpr = arg.value();
-      auto typeCase = argExpr.rex_type_case();
-      switch (typeCase) {
-        case ::substrait::Expression::RexTypeCase::kSelection: {
-          auto sel = argExpr.selection();
-          // TODO: Only direct reference is considered here.
-          auto dRef = sel.direct_reference();
-          colIdx = substraitParser_->parseReferenceSegment(dRef);
-          break;
-        }
-        case ::substrait::Expression::RexTypeCase::kLiteral: {
-          auto sLit = argExpr.literal();
-          // TODO: Only double is considered here.
-          val = sLit.fp64();
-          break;
-        }
-        default:
-          VELOX_NYI(
-              "Substrait conversion not supported for arg type '{}'", typeCase);
-      }
-    }
-    if (filterName == "is_not_null") {
-      colInfoMap[colIdx]->forbidsNull();
-    } else if (filterName == "gte") {
-      colInfoMap[colIdx]->setLeft(val, false);
-    } else if (filterName == "gt") {
-      colInfoMap[colIdx]->setLeft(val, true);
-    } else if (filterName == "lte") {
-      colInfoMap[colIdx]->setRight(val, false);
-    } else if (filterName == "lt") {
-      colInfoMap[colIdx]->setRight(val, true);
-    } else {
-      VELOX_NYI(
-          "Substrait conversion not supported for filter name '{}'",
-          filterName);
-    }
-  }
-
-  // Construct the Filters.
-  for (int idx = 0; idx < inputNameList.size(); idx++) {
-    auto filterInfo = colInfoMap[idx];
-    double leftBound;
-    double rightBound;
-    bool leftUnbounded = true;
-    bool rightUnbounded = true;
-    bool leftExclusive = false;
-    bool rightExclusive = false;
-    if (filterInfo->isInitialized()) {
-      if (filterInfo->left_) {
-        leftUnbounded = false;
-        leftBound = filterInfo->left_.value();
-        leftExclusive = filterInfo->leftExclusive_;
-      }
-      if (filterInfo->right_) {
-        rightUnbounded = false;
-        rightBound = filterInfo->right_.value();
-        rightExclusive = filterInfo->rightExclusive_;
-      }
-      bool nullAllowed = filterInfo->nullAllowed_;
-      filters[common::Subfield(inputNameList[idx])] =
-          std::make_unique<common::DoubleRange>(
-              leftBound,
-              leftUnbounded,
-              leftExclusive,
-              rightBound,
-              rightUnbounded,
-              rightExclusive,
-              nullAllowed);
-    }
-  }
-  return filters;
-}
-
-void SubstraitVeloxPlanConverter::flattenConditions(
-    const ::substrait::Expression& substraitFilter,
-    std::vector<::substrait::Expression_ScalarFunction>& scalarFunctions) {
-  auto typeCase = substraitFilter.rex_type_case();
-  switch (typeCase) {
-    case ::substrait::Expression::RexTypeCase::kScalarFunction: {
-      auto sFunc = substraitFilter.scalar_function();
-      auto filterNameSpec = substraitParser_->findFunctionSpec(
-          functionMap_, sFunc.function_reference());
-      // TODO: Only and relation is supported here.
-      if (getNameBeforeDelimiter(filterNameSpec, ":") == "and") {
-        for (const auto& sCondition : sFunc.arguments()) {
-          flattenConditions(sCondition.value(), scalarFunctions);
-        }
-      } else {
-        scalarFunctions.emplace_back(sFunc);
-      }
-      break;
-    }
-    default:
-      VELOX_NYI("GetFlatConditions not supported for type '{}'", typeCase);
-  }
-}
-
-void SubstraitVeloxPlanConverter::constructFunctionMap(
-    const ::substrait::Plan& substraitPlan) {
-  // Construct the function map based on the Substrait representation.
-  for (const auto& sExtension : substraitPlan.extensions()) {
-    if (!sExtension.has_extension_function()) {
-      continue;
-    }
-    const auto& sFmap = sExtension.extension_function();
-    auto id = sFmap.function_anchor();
-    auto name = sFmap.name();
-    functionMap_[id] = name;
-  }
-}
-
-bool SubstraitVeloxPlanConverter::checkTypeExtension(
-    const ::substrait::Plan& substraitPlan) {
-  for (const auto& sExtension : substraitPlan.extensions()) {
-    if (!sExtension.has_extension_type()) {
-      continue;
-    }
-
-    // Only support UNKNOWN type in UserDefined type extension.
-    if (sExtension.extension_type().name() != "UNKNOWN") {
-      return false;
-    }
-  }
-  return true;
-}
-
-const std::string& SubstraitVeloxPlanConverter::findFunction(
-    uint64_t id) const {
-  return substraitParser_->findFunctionSpec(functionMap_, id);
-}
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/SubstraitToVeloxPlan.h b/velox/substrait/SubstraitToVeloxPlan.h
deleted file mode 100644
index efdd16b012a9..000000000000
--- a/velox/substrait/SubstraitToVeloxPlan.h
+++ /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.
- */
-
-#pragma once
-
-#include "velox/connectors/hive/HiveConnector.h"
-#include "velox/connectors/hive/TableHandle.h"
-#include "velox/core/PlanNode.h"
-#include "velox/dwio/common/Options.h"
-#include "velox/substrait/SubstraitToVeloxExpr.h"
-
-namespace facebook::velox::substrait {
-
-/// This class is used to convert the Substrait plan into Velox plan.
-class SubstraitVeloxPlanConverter {
- public:
-  explicit SubstraitVeloxPlanConverter(memory::MemoryPool* pool)
-      : pool_(pool) {}
-  struct SplitInfo {
-    /// The Partition index.
-    u_int32_t partitionIndex;
-
-    /// The file paths to be scanned.
-    std::vector<std::string> paths;
-
-    /// The file starts in the scan.
-    std::vector<u_int64_t> starts;
-
-    /// The lengths to be scanned.
-    std::vector<u_int64_t> lengths;
-
-    /// The file format of the files to be scanned.
-    dwio::common::FileFormat format;
-  };
-
-  /// Convert Substrait AggregateRel into Velox PlanNode.
-  core::PlanNodePtr toVeloxPlan(const ::substrait::AggregateRel& aggRel);
-
-  /// Convert Substrait ProjectRel into Velox PlanNode.
-  core::PlanNodePtr toVeloxPlan(const ::substrait::ProjectRel& projectRel);
-
-  /// Convert Substrait FilterRel into Velox PlanNode.
-  core::PlanNodePtr toVeloxPlan(const ::substrait::FilterRel& filterRel);
-
-  /// Convert Substrait ReadRel into Velox PlanNode.
-  /// Index: the index of the partition this item belongs to.
-  /// Starts: the start positions in byte to read from the items.
-  /// Lengths: the lengths in byte to read from the items.
-  core::PlanNodePtr toVeloxPlan(
-      const ::substrait::ReadRel& readRel,
-      std::shared_ptr<SplitInfo>& splitInfo);
-
-  /// Convert Substrait FetchRel into Velox LimitNode or TopNNode according the
-  /// different input of fetchRel.
-  core::PlanNodePtr toVeloxPlan(const ::substrait::FetchRel& fetchRel);
-
-  /// Convert Substrait ReadRel into Velox Values Node.
-  core::PlanNodePtr toVeloxPlan(
-      const ::substrait::ReadRel& readRel,
-      const RowTypePtr& type);
-
-  /// Convert Substrait Rel into Velox PlanNode.
-  core::PlanNodePtr toVeloxPlan(const ::substrait::Rel& rel);
-
-  /// Convert Substrait RelRoot into Velox PlanNode.
-  core::PlanNodePtr toVeloxPlan(const ::substrait::RelRoot& root);
-
-  /// Convert Substrait SortRel into Velox OrderByNode.
-  core::PlanNodePtr toVeloxPlan(const ::substrait::SortRel& sortRel);
-
-  /// Convert Substrait Plan into Velox PlanNode.
-  core::PlanNodePtr toVeloxPlan(const ::substrait::Plan& substraitPlan);
-
-  /// Check the Substrait type extension only has one unknown extension.
-  bool checkTypeExtension(const ::substrait::Plan& substraitPlan);
-
-  /// Construct the function map between the index and the Substrait function
-  /// name.
-  void constructFunctionMap(const ::substrait::Plan& substraitPlan);
-
-  /// Return the function map used by this plan converter.
-  const std::unordered_map<uint64_t, std::string>& getFunctionMap() const {
-    return functionMap_;
-  }
-
-  /// Return the splitInfo map used by this plan converter.
-  const std::unordered_map<core::PlanNodeId, std::shared_ptr<SplitInfo>>&
-  splitInfos() const {
-    return splitInfoMap_;
-  }
-
-  /// Looks up a function by ID and returns function name if found. Throws if
-  /// function with specified ID doesn't exist. Returns a compound
-  /// function specification consisting of the function name and the input
-  /// types. The format is as follows: <function
-  /// name>:<arg_type0>_<arg_type1>_..._<arg_typeN>
-  const std::string& findFunction(uint64_t id) const;
-
-  /// Integrate Substrait emit feature. Here a given 'substrait::RelCommon'
-  /// is passed and check if emit is defined for this relation. Basically a
-  /// ProjectNode is added on top of 'noEmitNode' to represent output order
-  /// specified in 'relCommon::emit'. Return 'noEmitNode' as is
-  /// if output order is 'kDriect'.
-  core::PlanNodePtr processEmit(
-      const ::substrait::RelCommon& relCommon,
-      const core::PlanNodePtr& noEmitNode);
-
- private:
-  /// Returns unique ID to use for plan node. Produces sequential numbers
-  /// starting from zero.
-  std::string nextPlanNodeId();
-
-  /// Used to convert Substrait Filter into Velox SubfieldFilters which will
-  /// be used in TableScan.
-  common::SubfieldFilters toVeloxFilter(
-      const std::vector<std::string>& inputNameList,
-      const std::vector<TypePtr>& inputTypeList,
-      const ::substrait::Expression& substraitFilter);
-
-  /// Multiple conditions are connected to a binary tree structure with
-  /// the relation key words, including AND, OR, and etc. Currently, only
-  /// AND is supported. This function is used to extract all the Substrait
-  /// conditions in the binary tree structure into a vector.
-  void flattenConditions(
-      const ::substrait::Expression& substraitFilter,
-      std::vector<::substrait::Expression_ScalarFunction>& scalarFunctions);
-
-  /// The Substrait parser used to convert Substrait representations into
-  /// recognizable representations.
-  std::shared_ptr<SubstraitParser> substraitParser_{
-      std::make_shared<SubstraitParser>()};
-
-  /// Helper Function to convert Substrait sortField to Velox sortingKeys and
-  /// sortingOrders.
-  std::pair<
-      std::vector<core::FieldAccessTypedExprPtr>,
-      std::vector<core::SortOrder>>
-  processSortField(
-      const ::google::protobuf::RepeatedPtrField<::substrait::SortField>&
-          sortField,
-      const RowTypePtr& inputType);
-
-  /// The Expression converter used to convert Substrait representations into
-  /// Velox expressions.
-  std::shared_ptr<SubstraitVeloxExprConverter> exprConverter_;
-
-  /// The unique identification for each PlanNode.
-  int planNodeId_ = 0;
-
-  /// The map storing the relations between the function id and the function
-  /// name. Will be constructed based on the Substrait representation.
-  std::unordered_map<uint64_t, std::string> functionMap_;
-
-  /// Mapping from leaf plan node ID to splits.
-  std::unordered_map<core::PlanNodeId, std::shared_ptr<SplitInfo>>
-      splitInfoMap_;
-
-  /// Memory pool.
-  memory::MemoryPool* pool_;
-
-  /// Helper function to convert the input of Substrait Rel to Velox Node.
-  template <typename T>
-  core::PlanNodePtr convertSingleInput(T rel) {
-    VELOX_CHECK(rel.has_input(), "Child Rel is expected here.");
-    return toVeloxPlan(rel.input());
-  }
-};
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/TypeUtils.cpp b/velox/substrait/TypeUtils.cpp
deleted file mode 100644
index a179eebc49e1..000000000000
--- a/velox/substrait/TypeUtils.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 "velox/substrait/TypeUtils.h"
-#include "velox/type/Type.h"
-
-namespace facebook::velox::substrait {
-std::vector<std::string_view> getTypesFromCompoundName(
-    std::string_view compoundName) {
-  // CompoundName is like ARRAY<BIGINT> or MAP<BIGINT,DOUBLE>
-  // or ROW<BIGINT,ROW<DOUBLE,BIGINT>,ROW<DOUBLE,BIGINT>>
-  // the position of then delimiter is where the number of leftAngleBracket
-  // equals rightAngleBracket need to split.
-  std::vector<std::string_view> types;
-  std::vector<int> angleBracketNumEqualPos;
-  auto leftAngleBracketPos = compoundName.find("<");
-  auto rightAngleBracketPos = compoundName.rfind(">");
-  auto typesName = compoundName.substr(
-      leftAngleBracketPos + 1, rightAngleBracketPos - leftAngleBracketPos - 1);
-  int leftAngleBracketNum = 0;
-  int rightAngleBracketNum = 0;
-  for (auto index = 0; index < typesName.length(); index++) {
-    if (typesName[index] == '<') {
-      leftAngleBracketNum++;
-    }
-    if (typesName[index] == '>') {
-      rightAngleBracketNum++;
-    }
-    if (typesName[index] == ',' &&
-        rightAngleBracketNum == leftAngleBracketNum) {
-      angleBracketNumEqualPos.push_back(index);
-    }
-  }
-  int startPos = 0;
-  for (auto delimeterPos : angleBracketNumEqualPos) {
-    types.emplace_back(typesName.substr(startPos, delimeterPos - startPos));
-    startPos = delimeterPos + 1;
-  }
-  types.emplace_back(std::string_view(
-      typesName.data() + startPos, typesName.length() - startPos));
-  return types;
-}
-
-// TODO Refactor using Bison.
-std::string_view getNameBeforeDelimiter(
-    const std::string& compoundName,
-    const std::string& delimiter) {
-  std::size_t pos = compoundName.find(delimiter);
-  if (pos == std::string::npos) {
-    return compoundName;
-  }
-  return std::string_view(compoundName.data(), pos);
-}
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VariantToVectorConverter.cpp b/velox/substrait/VariantToVectorConverter.cpp
deleted file mode 100644
index 33194f6ac166..000000000000
--- a/velox/substrait/VariantToVectorConverter.cpp
+++ /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.
- */
-
-#include "velox/substrait/VariantToVectorConverter.h"
-#include "velox/vector/FlatVector.h"
-
-namespace facebook::velox::substrait {
-
-namespace {
-template <TypeKind KIND>
-VectorPtr setVectorFromVariantsByKind(
-    const std::vector<velox::variant>& values,
-    const TypePtr& type,
-    memory::MemoryPool* pool) {
-  using T = typename TypeTraits<KIND>::NativeType;
-
-  auto flatVector =
-      BaseVector::create<FlatVector<T>>(type, values.size(), pool);
-
-  for (vector_size_t i = 0; i < values.size(); i++) {
-    if (values[i].isNull()) {
-      flatVector->setNull(i, true);
-    } else {
-      flatVector->set(i, values[i].value<T>());
-    }
-  }
-  return flatVector;
-}
-
-template <>
-VectorPtr setVectorFromVariantsByKind<TypeKind::VARBINARY>(
-    const std::vector<velox::variant>& /* values */,
-    const TypePtr& /*type*/,
-    memory::MemoryPool* /* pool */) {
-  VELOX_UNSUPPORTED("Return of VARBINARY data is not supported");
-}
-
-template <>
-VectorPtr setVectorFromVariantsByKind<TypeKind::VARCHAR>(
-    const std::vector<velox::variant>& values,
-    const TypePtr& type,
-    memory::MemoryPool* pool) {
-  auto flatVector =
-      BaseVector::create<FlatVector<StringView>>(type, values.size(), pool);
-
-  for (vector_size_t i = 0; i < values.size(); i++) {
-    if (values[i].isNull()) {
-      flatVector->setNull(i, true);
-    } else {
-      flatVector->set(i, StringView(values[i].value<TypeKind::VARCHAR>()));
-    }
-  }
-  return flatVector;
-}
-} // namespace
-
-VectorPtr setVectorFromVariants(
-    const TypePtr& type,
-    const std::vector<velox::variant>& values,
-    memory::MemoryPool* pool) {
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-      setVectorFromVariantsByKind, type->kind(), values, type, pool);
-}
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VeloxSubstraitSignature.cpp b/velox/substrait/VeloxSubstraitSignature.cpp
deleted file mode 100644
index 0a709c87ac07..000000000000
--- a/velox/substrait/VeloxSubstraitSignature.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/substrait/VeloxSubstraitSignature.h"
-#include "velox/functions/FunctionRegistry.h"
-
-namespace facebook::velox::substrait {
-
-std::string VeloxSubstraitSignature::toSubstraitSignature(const TypePtr& type) {
-  switch (type->kind()) {
-    case TypeKind::BOOLEAN:
-      return "bool";
-    case TypeKind::TINYINT:
-      return "i8";
-    case TypeKind::SMALLINT:
-      return "i16";
-    case TypeKind::INTEGER:
-      if (type->isDate()) {
-        return "date";
-      }
-      return "i32";
-    case TypeKind::BIGINT:
-      return "i64";
-    case TypeKind::REAL:
-      return "fp32";
-    case TypeKind::DOUBLE:
-      return "fp64";
-    case TypeKind::VARCHAR:
-      return "str";
-    case TypeKind::VARBINARY:
-      return "vbin";
-    case TypeKind::TIMESTAMP:
-      return "ts";
-    case TypeKind::ARRAY:
-      return "list";
-    case TypeKind::MAP:
-      return "map";
-    case TypeKind::ROW:
-      return "struct";
-    case TypeKind::UNKNOWN:
-      return "u!name";
-    default:
-      VELOX_UNSUPPORTED(
-          "Substrait type signature conversion not supported for type {}.",
-          mapTypeKindToName(type->kind()));
-  }
-}
-
-// 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) {
-  if (arguments.empty()) {
-    return functionName;
-  }
-  std::vector<std::string> substraitTypeSignatures;
-  substraitTypeSignatures.reserve(arguments.size());
-  for (const auto& type : arguments) {
-    substraitTypeSignatures.emplace_back(toSubstraitSignature(type));
-  }
-  return functionName + ":" + folly::join("_", substraitTypeSignatures);
-}
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VeloxSubstraitSignature.h b/velox/substrait/VeloxSubstraitSignature.h
deleted file mode 100644
index 0a4baed478eb..000000000000
--- a/velox/substrait/VeloxSubstraitSignature.h
+++ /dev/null
@@ -1,44 +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/type/Type.h"
-
-namespace facebook::velox::substrait {
-
-class VeloxSubstraitSignature {
- public:
-  /// Given a velox type kind, return the Substrait type signature, throw if no
-  /// match found, Substrait signature used in the function extension
-  /// declaration is a combination of the name of the function along with a list
-  /// of input argument types.The format is as follows : <function
-  /// name>:<short_arg_type0>_<short_arg_type1>_..._<short_arg_typeN> for more
-  /// detail information about the argument type please refer to link
-  /// 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(
-      const std::string& functionName,
-      const std::vector<TypePtr>& arguments);
-};
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VeloxToSubstraitExpr.cpp b/velox/substrait/VeloxToSubstraitExpr.cpp
deleted file mode 100644
index 506c4023c765..000000000000
--- a/velox/substrait/VeloxToSubstraitExpr.cpp
+++ /dev/null
@@ -1,620 +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/substrait/VeloxToSubstraitExpr.h"
-#include "velox/vector/FlatVector.h"
-
-namespace facebook::velox::substrait {
-
-namespace {
-const ::substrait::Expression_Literal& toSubstraitNullLiteral(
-    google::protobuf::Arena& arena,
-    const velox::TypeKind& typeKind) {
-  ::substrait::Expression_Literal* substraitField =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  switch (typeKind) {
-    case velox::TypeKind::BOOLEAN: {
-      ::substrait::Type_Boolean* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_Boolean>(
-              &arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_bool_(nullValue);
-      break;
-    }
-    case velox::TypeKind::TINYINT: {
-      ::substrait::Type_I8* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_I8>(&arena);
-
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_i8(nullValue);
-      break;
-    }
-    case velox::TypeKind::SMALLINT: {
-      ::substrait::Type_I16* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_I16>(&arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_i16(nullValue);
-      break;
-    }
-    case velox::TypeKind::INTEGER: {
-      ::substrait::Type_I32* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_I32>(&arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_i32(nullValue);
-      break;
-    }
-    case velox::TypeKind::BIGINT: {
-      ::substrait::Type_I64* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_I64>(&arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_i64(nullValue);
-      break;
-    }
-    case velox::TypeKind::VARCHAR: {
-      ::substrait::Type_String* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_String>(
-              &arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_string(nullValue);
-      break;
-    }
-    case velox::TypeKind::REAL: {
-      ::substrait::Type_FP32* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_FP32>(
-              &arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_fp32(nullValue);
-      break;
-    }
-    case velox::TypeKind::DOUBLE: {
-      ::substrait::Type_FP64* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_FP64>(
-              &arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_fp64(nullValue);
-      break;
-    }
-    case velox::TypeKind::ARRAY: {
-      ::substrait::Type_List* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_List>(
-              &arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitField->mutable_null()->set_allocated_list(nullValue);
-      break;
-    }
-    case velox::TypeKind::UNKNOWN: {
-      ::substrait::Type_UserDefined* nullValue =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_UserDefined>(
-              &arena);
-      nullValue->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      nullValue->set_type_reference(0);
-      substraitField->mutable_null()->set_allocated_user_defined(nullValue);
-
-      break;
-    }
-    default: {
-      VELOX_UNSUPPORTED("Unsupported type '{}'", mapTypeKindToName(typeKind));
-    }
-  }
-  substraitField->set_nullable(true);
-  return *substraitField;
-}
-
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral(
-    google::protobuf::Arena& arena,
-    const velox::variant& variantValue) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  switch (variantValue.kind()) {
-    case velox::TypeKind::BOOLEAN: {
-      literalExpr->set_boolean(variantValue.value<TypeKind::BOOLEAN>());
-      break;
-    }
-    case velox::TypeKind::TINYINT: {
-      literalExpr->set_i8(variantValue.value<TypeKind::TINYINT>());
-      break;
-    }
-    case velox::TypeKind::SMALLINT: {
-      literalExpr->set_i16(variantValue.value<TypeKind::SMALLINT>());
-      break;
-    }
-    case velox::TypeKind::INTEGER: {
-      literalExpr->set_i32(variantValue.value<TypeKind::INTEGER>());
-      break;
-    }
-    case velox::TypeKind::BIGINT: {
-      literalExpr->set_i64(variantValue.value<TypeKind::BIGINT>());
-      break;
-    }
-    case velox::TypeKind::REAL: {
-      literalExpr->set_fp32(variantValue.value<TypeKind::REAL>());
-      break;
-    }
-    case velox::TypeKind::DOUBLE: {
-      literalExpr->set_fp64(variantValue.value<TypeKind::DOUBLE>());
-      break;
-    }
-    case velox::TypeKind::TIMESTAMP: {
-      auto vTimeStamp = variantValue.value<TypeKind::TIMESTAMP>();
-      auto micros =
-          vTimeStamp.getSeconds() * 1000000 + vTimeStamp.getNanos() / 1000;
-      literalExpr->set_timestamp(micros);
-      break;
-    }
-    case velox::TypeKind::VARCHAR: {
-      auto vCharValue = variantValue.value<StringView>();
-      ::substrait::Expression_Literal::VarChar* sVarChar =
-          new ::substrait::Expression_Literal::VarChar();
-      sVarChar->set_value(vCharValue.data());
-      sVarChar->set_length(vCharValue.size());
-      literalExpr->set_allocated_var_char(sVarChar);
-      break;
-    }
-    default:
-      VELOX_NYI(
-          "Unsupported constant Type '{}' ",
-          mapTypeKindToName(variantValue.kind()));
-  }
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <TypeKind kind>
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral(
-    google::protobuf::Arena& arena,
-    const typename TypeTraits<kind>::NativeType& /* value */) {
-  VELOX_UNSUPPORTED(
-      "toSubstraitNotNullLiteral function doesn't support {} type",
-      TypeTraits<kind>::name);
-
-  // Make compiler happy.
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral<
-    TypeKind::BOOLEAN>(google::protobuf::Arena& arena, const bool& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  literalExpr->set_boolean(value);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral<
-    TypeKind::TINYINT>(google::protobuf::Arena& arena, const int8_t& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  literalExpr->set_i8(value);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral<
-    TypeKind::SMALLINT>(google::protobuf::Arena& arena, const int16_t& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  literalExpr->set_i16(value);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral<
-    TypeKind::INTEGER>(google::protobuf::Arena& arena, const int32_t& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  literalExpr->set_i32(value);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral<
-    TypeKind::BIGINT>(google::protobuf::Arena& arena, const int64_t& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  literalExpr->set_i64(value);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral<
-    TypeKind::REAL>(google::protobuf::Arena& arena, const float& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  literalExpr->set_fp32(value);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal& toSubstraitNotNullLiteral<
-    TypeKind::DOUBLE>(google::protobuf::Arena& arena, const double& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  literalExpr->set_fp64(value);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal&
-toSubstraitNotNullLiteral<TypeKind::TIMESTAMP>(
-    google::protobuf::Arena& arena,
-    const Timestamp& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  auto micros = value.getSeconds() * 1000000 + value.getNanos() / 1000;
-  literalExpr->set_timestamp(micros);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <>
-const ::substrait::Expression_Literal&
-toSubstraitNotNullLiteral<TypeKind::VARCHAR>(
-    google::protobuf::Arena& arena,
-    const velox::StringView& value) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  ::substrait::Expression_Literal::VarChar* sVarChar =
-      new ::substrait::Expression_Literal::VarChar();
-  sVarChar->set_value(value.data());
-  sVarChar->set_length(value.size());
-  literalExpr->set_allocated_var_char(sVarChar);
-  literalExpr->set_nullable(false);
-  return *literalExpr;
-}
-
-template <TypeKind Kind>
-void arrayVectorToLiteral(
-    google::protobuf::Arena& arena,
-    const ArrayVector* arrayVector,
-    ::substrait::Expression_Literal_List* listLiteral,
-    vector_size_t offset,
-    vector_size_t size) {
-  using T = typename TypeTraits<Kind>::NativeType;
-  auto elements = arrayVector->elements()->as<SimpleVector<T>>();
-  for (auto i = offset; i < offset + size; ++i) {
-    ::substrait::Expression_Literal* childLiteral = listLiteral->add_values();
-    if (elements->isNullAt(i)) {
-      childLiteral->MergeFrom(toSubstraitNullLiteral(arena, Kind));
-    } else {
-      childLiteral->MergeFrom(
-          toSubstraitNotNullLiteral<Kind>(arena, elements->valueAt(i)));
-    }
-  }
-}
-
-template <TypeKind kind>
-void convertVectorValue(
-    google::protobuf::Arena& arena,
-    const velox::VectorPtr& vectorValue,
-    ::substrait::Expression_Literal_Struct* litValue,
-    ::substrait::Expression_Literal* substraitField) {
-  const TypePtr& childType = vectorValue->type();
-
-  using T = typename TypeTraits<kind>::NativeType;
-
-  auto childToFlatVec = vectorValue->as<SimpleVector<T>>();
-
-  //  Get the batchSize and convert each value in it.
-  vector_size_t flatVecSize = childToFlatVec->size();
-  for (int64_t i = 0; i < flatVecSize; i++) {
-    substraitField = litValue->add_fields();
-    if (childToFlatVec->isNullAt(i)) {
-      // Process the null value.
-      substraitField->MergeFrom(
-          toSubstraitNullLiteral(arena, childType->kind()));
-    } else {
-      substraitField->MergeFrom(
-          toSubstraitNotNullLiteral<kind>(arena, childToFlatVec->valueAt(i)));
-    }
-  }
-}
-} // namespace
-
-const ::substrait::Expression& VeloxToSubstraitExprConvertor::toSubstraitExpr(
-    google::protobuf::Arena& arena,
-    const core::TypedExprPtr& expr,
-    const RowTypePtr& inputType) {
-  ::substrait::Expression* substraitExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression>(&arena);
-  if (auto constExpr =
-          std::dynamic_pointer_cast<const core::ConstantTypedExpr>(expr)) {
-    substraitExpr->mutable_literal()->MergeFrom(
-        toSubstraitExpr(arena, constExpr));
-    return *substraitExpr;
-  }
-  if (auto callTypeExpr =
-          std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
-    substraitExpr->MergeFrom(toSubstraitExpr(arena, callTypeExpr, inputType));
-    return *substraitExpr;
-  }
-  if (auto fieldExpr =
-          std::dynamic_pointer_cast<const core::FieldAccessTypedExpr>(expr)) {
-    substraitExpr->mutable_selection()->MergeFrom(
-        toSubstraitExpr(arena, fieldExpr, inputType));
-
-    return *substraitExpr;
-  }
-  if (auto castExpr =
-          std::dynamic_pointer_cast<const core::CastTypedExpr>(expr)) {
-    substraitExpr->mutable_cast()->MergeFrom(
-        toSubstraitExpr(arena, castExpr, inputType));
-
-    return *substraitExpr;
-  }
-
-  VELOX_UNSUPPORTED("Unsupport Expr '{}' in Substrait", expr->toString());
-}
-
-const ::substrait::Expression_Cast&
-VeloxToSubstraitExprConvertor::toSubstraitExpr(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::CastTypedExpr>& castExpr,
-    const RowTypePtr& inputType) {
-  ::substrait::Expression_Cast* substraitCastExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Cast>(
-          &arena);
-  std::vector<core::TypedExprPtr> castExprInputs = castExpr->inputs();
-
-  substraitCastExpr->mutable_type()->MergeFrom(
-      typeConvertor_->toSubstraitType(arena, castExpr->type()));
-
-  for (auto& arg : castExprInputs) {
-    substraitCastExpr->mutable_input()->MergeFrom(
-        toSubstraitExpr(arena, arg, inputType));
-  }
-  if (castExpr->nullOnFailure()) {
-    substraitCastExpr->set_failure_behavior(
-        ::substrait::
-            Expression_Cast_FailureBehavior_FAILURE_BEHAVIOR_RETURN_NULL);
-  } else {
-    substraitCastExpr->set_failure_behavior(
-        ::substrait::
-            Expression_Cast_FailureBehavior_FAILURE_BEHAVIOR_THROW_EXCEPTION);
-  }
-  return *substraitCastExpr;
-}
-
-const ::substrait::Expression_FieldReference&
-VeloxToSubstraitExprConvertor::toSubstraitExpr(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::FieldAccessTypedExpr>& fieldExpr,
-    const RowTypePtr& inputType) {
-  ::substrait::Expression_FieldReference* substraitFieldExpr =
-      google::protobuf::Arena::CreateMessage<
-          ::substrait::Expression_FieldReference>(&arena);
-
-  std::string exprName = fieldExpr->name();
-
-  ::substrait::Expression_ReferenceSegment_StructField* directStruct =
-      substraitFieldExpr->mutable_direct_reference()->mutable_struct_field();
-
-  directStruct->set_field(inputType->getChildIdx(exprName));
-  return *substraitFieldExpr;
-}
-
-const ::substrait::Expression& VeloxToSubstraitExprConvertor::toSubstraitExpr(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::CallTypedExpr>& callTypeExpr,
-    const RowTypePtr& inputType) {
-  ::substrait::Expression* substraitExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression>(&arena);
-
-  auto inputs = callTypeExpr->inputs();
-  auto& functionName = callTypeExpr->name();
-
-  if (functionName != "if" && functionName != "switch") {
-    ::substrait::Expression_ScalarFunction* scalarExpr =
-        substraitExpr->mutable_scalar_function();
-
-    std::vector<TypePtr> types;
-    types.reserve(callTypeExpr->inputs().size());
-    for (auto& typedExpr : callTypeExpr->inputs()) {
-      types.emplace_back(typedExpr->type());
-    }
-
-    scalarExpr->set_function_reference(
-        extensionCollector_->getReferenceNumber(functionName, types));
-
-    for (auto& arg : inputs) {
-      scalarExpr->add_arguments()->mutable_value()->MergeFrom(
-          toSubstraitExpr(arena, arg, inputType));
-    }
-
-    scalarExpr->mutable_output_type()->MergeFrom(
-        typeConvertor_->toSubstraitType(arena, callTypeExpr->type()));
-
-  } else {
-    // For today's version of Substrait, you'd have to use IfThen if you need
-    // the switch cases to be call typed expression.
-
-    size_t inputsSize = callTypeExpr->inputs().size();
-    bool hasElseInput = inputsSize % 2 == 1;
-
-    auto ifThenExpr = substraitExpr->mutable_if_then();
-    for (int i = 0; i < inputsSize / 2; i++) {
-      auto ifClauseExpr = ifThenExpr->add_ifs();
-      ifClauseExpr->mutable_if_()->MergeFrom(
-          toSubstraitExpr(arena, callTypeExpr->inputs().at(i * 2), inputType));
-      ifClauseExpr->mutable_then()->MergeFrom(toSubstraitExpr(
-          arena, callTypeExpr->inputs().at(i * 2 + 1), inputType));
-    }
-    if (hasElseInput) {
-      ifThenExpr->mutable_else_()->MergeFrom(toSubstraitExpr(
-          arena, callTypeExpr->inputs().at(inputsSize - 1), inputType));
-    }
-  }
-
-  return *substraitExpr;
-}
-
-const ::substrait::Expression_Literal&
-VeloxToSubstraitExprConvertor::toSubstraitExpr(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::ConstantTypedExpr>& constExpr,
-    ::substrait::Expression_Literal_Struct* litValue) {
-  if (constExpr->hasValueVector()) {
-    return toSubstraitLiteral(arena, constExpr->valueVector(), litValue);
-  } else {
-    return toSubstraitLiteral(arena, constExpr->value());
-  }
-}
-
-const ::substrait::Expression_Literal&
-VeloxToSubstraitExprConvertor::toSubstraitLiteral(
-    google::protobuf::Arena& arena,
-    const velox::variant& variantValue) {
-  ::substrait::Expression_Literal* literalExpr =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-
-  if (variantValue.isNull()) {
-    literalExpr->MergeFrom(toSubstraitNullLiteral(arena, variantValue.kind()));
-  } else {
-    literalExpr->MergeFrom(toSubstraitNotNullLiteral(arena, variantValue));
-  }
-  return *literalExpr;
-}
-
-const ::substrait::Expression_Literal_List&
-VeloxToSubstraitExprConvertor::toSubstraitLiteralList(
-    google::protobuf::Arena& arena,
-    const ArrayVector* arrayVector,
-    vector_size_t row) {
-  ::substrait::Expression_Literal_List* listLiteral =
-      google::protobuf::Arena::CreateMessage<
-          ::substrait::Expression_Literal_List>(&arena);
-  auto size = arrayVector->sizeAt(row);
-  if (size == 0) {
-    return *listLiteral;
-  }
-  auto offset = arrayVector->offsetAt(row);
-  if (arrayVector->elements()->isScalar()) {
-    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-        arrayVectorToLiteral,
-        arrayVector->elements()->type()->kind(),
-        arena,
-        arrayVector,
-        listLiteral,
-        offset,
-        size);
-    return *listLiteral;
-  }
-
-  if (arrayVector->elements()->typeKind() == TypeKind::ARRAY) {
-    auto encoding = arrayVector->elements()->encoding();
-    if (encoding == VectorEncoding::Simple::ARRAY) {
-      auto nestedArrayVector = arrayVector->elements()->as<ArrayVector>();
-      VELOX_CHECK_NOT_NULL(nestedArrayVector);
-      for (auto i = offset; i < offset + size; ++i) {
-        ::substrait::Expression_Literal* literal = listLiteral->add_values();
-        literal->set_allocated_list(
-            const_cast<::substrait::Expression_Literal_List*>(
-                &toSubstraitLiteralList(arena, nestedArrayVector, i)));
-      }
-      return *listLiteral;
-    }
-  }
-  VELOX_NYI(
-      "Complex type literals are not supported: {}",
-      arrayVector->elements()->type()->toString());
-}
-
-const ::substrait::Expression_Literal&
-VeloxToSubstraitExprConvertor::toSubstraitLiteralComplex(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<ConstantVector<ComplexType>>& constantVector) {
-  ::substrait::Expression_Literal* substraitField =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  if (constantVector->typeKind() == TypeKind::ARRAY) {
-    if (constantVector->isNullAt(0)) {
-      // Process the null value.
-      substraitField->MergeFrom(
-          toSubstraitNullLiteral(arena, constantVector->typeKind()));
-      return *substraitField;
-    }
-    auto encoding = constantVector->valueVector()->encoding();
-    if (encoding == VectorEncoding::Simple::ARRAY) {
-      auto arrayVector = constantVector->valueVector()->as<ArrayVector>();
-      substraitField->mutable_list()->MergeFrom(
-          toSubstraitLiteralList(arena, arrayVector, constantVector->index()));
-      return *substraitField;
-    }
-  }
-  VELOX_NYI(
-      "Complex type literals are not supported: {}",
-      constantVector->type()->toString());
-}
-
-const ::substrait::Expression_Literal&
-VeloxToSubstraitExprConvertor::toSubstraitLiteral(
-    google::protobuf::Arena& arena,
-    const velox::VectorPtr& vectorValue,
-    ::substrait::Expression_Literal_Struct* litValue) {
-  ::substrait::Expression_Literal* substraitField =
-      google::protobuf::Arena::CreateMessage<::substrait::Expression_Literal>(
-          &arena);
-  if (vectorValue->isScalar()) {
-    VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-        convertVectorValue,
-        vectorValue->type()->kind(),
-        arena,
-        vectorValue,
-        litValue,
-        substraitField);
-    return *substraitField;
-  }
-
-  if (auto constantVector =
-          std::dynamic_pointer_cast<ConstantVector<ComplexType>>(vectorValue)) {
-    return toSubstraitLiteralComplex(arena, constantVector);
-  }
-  return *substraitField;
-}
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VeloxToSubstraitExpr.h b/velox/substrait/VeloxToSubstraitExpr.h
deleted file mode 100644
index 29d973b7da57..000000000000
--- a/velox/substrait/VeloxToSubstraitExpr.h
+++ /dev/null
@@ -1,107 +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/substrait/SubstraitExtensionCollector.h"
-#include "velox/substrait/VeloxToSubstraitType.h"
-#include "velox/substrait/proto/substrait/algebra.pb.h"
-#include "velox/vector/ConstantVector.h"
-
-namespace facebook::velox::substrait {
-
-class VeloxToSubstraitExprConvertor {
- public:
-  explicit VeloxToSubstraitExprConvertor(
-      const SubstraitExtensionCollectorPtr& extensionCollector)
-      : extensionCollector_(extensionCollector) {}
-
-  /// Convert Velox Expression to Substrait Expression.
-  /// @param arena Arena to use for allocating Substrait plan objects.
-  /// @param expr Velox expression needed to be converted.
-  /// @param inputType The input row Type of the current processed node,
-  /// which also equals the output row type of the previous node of the current.
-  /// @return A pointer to Substrait expression object allocated on the arena
-  /// and representing the input Velox expression.
-  const ::substrait::Expression& toSubstraitExpr(
-      google::protobuf::Arena& arena,
-      const core::TypedExprPtr& expr,
-      const RowTypePtr& inputType);
-
-  /// Convert Velox Constant Expression to Substrait
-  /// Literal Expression.
-  /// @param arena Arena to use for allocating Substrait plan objects.
-  /// @param constExpr Velox Constant expression needed to be converted.
-  /// @param litValue The Struct that returned literal expression belong to.
-  /// @return A pointer to Substrait Literal expression object allocated on
-  /// the arena and representing the input Velox Constant expression.
-  const ::substrait::Expression_Literal& toSubstraitExpr(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::ConstantTypedExpr>& constExpr,
-      ::substrait::Expression_Literal_Struct* litValue = nullptr);
-
-  /// Convert Velox FieldAccessTypedExpr to Substrait FieldReference Expression.
-  const ::substrait::Expression_FieldReference& toSubstraitExpr(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::FieldAccessTypedExpr>& fieldExpr,
-      const RowTypePtr& inputType);
-
-  /// Convert Velox vector to Substrait literal.
-  const ::substrait::Expression_Literal& toSubstraitLiteral(
-      google::protobuf::Arena& arena,
-      const velox::VectorPtr& vectorValue,
-      ::substrait::Expression_Literal_Struct* litValue);
-
- private:
-  /// Convert Velox Cast Expression to Substrait Cast Expression.
-  const ::substrait::Expression_Cast& toSubstraitExpr(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::CastTypedExpr>& castExpr,
-      const RowTypePtr& inputType);
-
-  /// Convert Velox CallTypedExpr Expression to Substrait Expression.
-  const ::substrait::Expression& toSubstraitExpr(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::CallTypedExpr>& callTypeExpr,
-      const RowTypePtr& inputType);
-
-  /// Convert Velox variant to Substrait Literal Expression.
-  const ::substrait::Expression_Literal& toSubstraitLiteral(
-      google::protobuf::Arena& arena,
-      const velox::variant& variantValue);
-
-  /// Convert values in Velox array vector to Substrait Literal List.
-  const ::substrait::Expression_Literal_List& toSubstraitLiteralList(
-      google::protobuf::Arena& arena,
-      const ArrayVector* arrayVector,
-      vector_size_t row);
-
-  /// Convert values in Velox complex vector to Substrait Literal.
-  const ::substrait::Expression_Literal& toSubstraitLiteralComplex(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<ConstantVector<ComplexType>>& constantVector);
-
-  VeloxToSubstraitTypeConvertorPtr typeConvertor_;
-
-  SubstraitExtensionCollectorPtr extensionCollector_;
-};
-
-using VeloxToSubstraitExprConvertorPtr =
-    std::shared_ptr<VeloxToSubstraitExprConvertor>;
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VeloxToSubstraitPlan.cpp b/velox/substrait/VeloxToSubstraitPlan.cpp
deleted file mode 100644
index 4022f77d0eb9..000000000000
--- a/velox/substrait/VeloxToSubstraitPlan.cpp
+++ /dev/null
@@ -1,401 +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/substrait/VeloxToSubstraitPlan.h"
-
-namespace facebook::velox::substrait {
-
-namespace {
-::substrait::AggregationPhase toAggregationPhase(
-    core::AggregationNode::Step step) {
-  switch (step) {
-    case core::AggregationNode::Step::kPartial: {
-      return ::substrait::AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE;
-    }
-    case core::AggregationNode::Step::kIntermediate: {
-      return ::substrait::AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE;
-    }
-    case core::AggregationNode::Step::kSingle: {
-      return ::substrait::AGGREGATION_PHASE_INITIAL_TO_RESULT;
-    }
-    case core::AggregationNode::Step::kFinal: {
-      return ::substrait::AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT;
-    }
-    default:
-      VELOX_UNSUPPORTED(
-          "Unsupported Aggregate Step '{}' in Substrait ",
-          mapAggregationStepToName(step));
-  }
-}
-
-::substrait::SortField_SortDirection toSortDirection(
-    core::SortOrder sortOrder) {
-  if (sortOrder.isNullsFirst()) {
-    if (sortOrder.isAscending()) {
-      return ::substrait::
-          SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_FIRST;
-    } else {
-      return ::substrait::
-          SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST;
-    }
-  } else {
-    if (sortOrder.isAscending()) {
-      return ::substrait::SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_LAST;
-    } else {
-      return ::substrait::
-          SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST;
-    }
-  }
-}
-
-} // namespace
-
-::substrait::Plan& VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const core::PlanNodePtr& plan) {
-  // Construct the extension colllector.
-  extensionCollector_ = std::make_shared<SubstraitExtensionCollector>();
-  // Construct the expression converter.
-  exprConvertor_ =
-      std::make_shared<VeloxToSubstraitExprConvertor>(extensionCollector_);
-
-  auto substraitPlan =
-      google::protobuf::Arena::CreateMessage<::substrait::Plan>(&arena);
-
-  // Add unknown type in extension.
-  auto unknownType = substraitPlan->add_extensions()->mutable_extension_type();
-
-  unknownType->set_extension_uri_reference(0);
-  unknownType->set_type_anchor(0);
-  unknownType->set_name("UNKNOWN");
-
-  // Do conversion.
-  ::substrait::RelRoot* rootRel =
-      substraitPlan->add_relations()->mutable_root();
-
-  toSubstrait(arena, plan, rootRel->mutable_input());
-
-  // Add extensions for all functions and types seen in the plan.
-  extensionCollector_->addExtensionsToPlan(substraitPlan);
-
-  // Set RootRel names.
-  for (const auto& name : plan->outputType()->names()) {
-    rootRel->add_names(name);
-  }
-
-  return *substraitPlan;
-}
-
-void VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const core::PlanNodePtr& planNode,
-    ::substrait::Rel* rel) {
-  if (auto filterNode =
-          std::dynamic_pointer_cast<const core::FilterNode>(planNode)) {
-    auto filterRel = rel->mutable_filter();
-    toSubstrait(arena, filterNode, filterRel);
-    return;
-  }
-  if (auto valuesNode =
-          std::dynamic_pointer_cast<const core::ValuesNode>(planNode)) {
-    ::substrait::ReadRel* readRel = rel->mutable_read();
-    toSubstrait(arena, valuesNode, readRel);
-    return;
-  }
-  if (auto projectNode =
-          std::dynamic_pointer_cast<const core::ProjectNode>(planNode)) {
-    ::substrait::ProjectRel* projectRel = rel->mutable_project();
-    toSubstrait(arena, projectNode, projectRel);
-    return;
-  }
-  if (auto aggregationNode =
-          std::dynamic_pointer_cast<const core::AggregationNode>(planNode)) {
-    ::substrait::AggregateRel* aggregateRel = rel->mutable_aggregate();
-    toSubstrait(arena, aggregationNode, aggregateRel);
-    return;
-  }
-  if (auto orderbyNode =
-          std::dynamic_pointer_cast<const core::OrderByNode>(planNode)) {
-    toSubstrait(arena, orderbyNode, rel->mutable_sort());
-    return;
-  }
-  if (auto topNNode =
-          std::dynamic_pointer_cast<const core::TopNNode>(planNode)) {
-    toSubstrait(arena, topNNode, rel->mutable_fetch());
-    return;
-  }
-  if (auto limitNode =
-          std::dynamic_pointer_cast<const core::LimitNode>(planNode)) {
-    toSubstrait(arena, limitNode, rel->mutable_fetch());
-    return;
-  }
-  VELOX_UNSUPPORTED("Unsupported plan node '{}' .", planNode->name());
-}
-
-void VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::FilterNode>& filterNode,
-    ::substrait::FilterRel* filterRel) {
-  const auto& source = getSingleSource(filterNode);
-
-  toSubstrait(arena, source, filterRel->mutable_input());
-
-  // Construct substrait expr(Filter condition).
-  auto filterCondition = filterNode->filter();
-  auto inputType = source->outputType();
-  filterRel->mutable_condition()->MergeFrom(
-      exprConvertor_->toSubstraitExpr(arena, filterCondition, inputType));
-
-  filterRel->mutable_common()->mutable_direct();
-}
-
-void VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::ValuesNode>& valuesNode,
-    ::substrait::ReadRel* readRel) {
-  const auto& outputType = valuesNode->outputType();
-
-  ::substrait::ReadRel_VirtualTable* virtualTable =
-      readRel->mutable_virtual_table();
-
-  for (const auto& vector : valuesNode->values()) {
-    ::substrait::Expression_Literal_Struct* litValue =
-        virtualTable->add_values();
-
-    for (const auto& column : vector->children()) {
-      ::substrait::Expression_Literal* substraitField =
-          google::protobuf::Arena::CreateMessage<
-              ::substrait::Expression_Literal>(&arena);
-
-      substraitField->MergeFrom(
-          exprConvertor_->toSubstraitLiteral(arena, column, litValue));
-    }
-  }
-
-  readRel->mutable_base_schema()->MergeFrom(
-      typeConvertor_->toSubstraitNamedStruct(arena, outputType));
-
-  readRel->mutable_common()->mutable_direct();
-}
-
-void VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::ProjectNode>& projectNode,
-    ::substrait::ProjectRel* projectRel) {
-  const auto& projections = projectNode->projections();
-
-  const auto& source = getSingleSource(projectNode);
-
-  // Process the source Node.
-  toSubstrait(arena, source, projectRel->mutable_input());
-
-  // Remap the output.
-  ::substrait::RelCommon_Emit* projRelEmit =
-      projectRel->mutable_common()->mutable_emit();
-
-  int64_t projectionSize = projections.size();
-
-  auto inputType = source->outputType();
-  int64_t inputTypeSize = inputType->size();
-
-  for (int64_t i = 0; i < projectionSize; i++) {
-    const auto& veloxExpr = projections.at(i);
-
-    projectRel->add_expressions()->MergeFrom(
-        exprConvertor_->toSubstraitExpr(arena, veloxExpr, inputType));
-
-    // Add outputMapping for each expression.
-    projRelEmit->add_output_mapping(inputTypeSize + i);
-  }
-
-  return;
-}
-
-void VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::AggregationNode>& aggregateNode,
-    ::substrait::AggregateRel* aggregateRel) {
-  // Process the source Node.
-  const auto& source = getSingleSource(aggregateNode);
-  toSubstrait(arena, source, aggregateRel->mutable_input());
-
-  // Convert aggregate grouping keys, such as: group by key1, key2.
-  auto inputType = source->outputType();
-  auto groupingKeys = aggregateNode->groupingKeys();
-  int64_t groupingKeySize = groupingKeys.size();
-  ::substrait::AggregateRel_Grouping* aggGroupings =
-      aggregateRel->add_groupings();
-
-  for (int64_t i = 0; i < groupingKeySize; i++) {
-    aggGroupings->add_grouping_expressions()->mutable_selection()->MergeFrom(
-        exprConvertor_->toSubstraitExpr(arena, groupingKeys.at(i), inputType));
-  }
-
-  // AggregatesSize should be equal to or greater than the aggregateMasks Size.
-  // Two cases: 1. aggregateMasksSize = 0, aggregatesSize > aggregateMasksSize.
-  // 2. aggregateMasksSize != 0, aggregatesSize = aggregateMasksSize.
-  auto aggregates = aggregateNode->aggregates();
-  int64_t aggregatesSize = aggregates.size();
-
-  for (int64_t i = 0; i < aggregatesSize; i++) {
-    const auto& aggregate = aggregates.at(i);
-
-    ::substrait::AggregateRel_Measure* aggMeasures =
-        aggregateRel->add_measures();
-
-    // Set substrait filter.
-    ::substrait::Expression* aggFilter = aggMeasures->mutable_filter();
-    if (const auto& mask = aggregate.mask) {
-      aggFilter->mutable_selection()->MergeFrom(
-          exprConvertor_->toSubstraitExpr(arena, mask, inputType));
-    } else {
-      // Set null.
-      aggFilter = nullptr;
-    }
-
-    // Process measure, eg:sum(a).
-    ::substrait::AggregateFunction* aggFunction =
-        aggMeasures->mutable_measure();
-
-    // Aggregation function name.
-    const auto& funName = aggregate.call->name();
-    // set aggFunction args.
-
-    std::vector<TypePtr> arguments;
-    arguments.reserve(aggregate.call->inputs().size());
-    for (const auto& expr : aggregate.call->inputs()) {
-      // If the expr is CallTypedExpr, people need to do project firstly.
-      if (auto aggregatesExprInput =
-              std::dynamic_pointer_cast<const core::CallTypedExpr>(expr)) {
-        VELOX_NYI("In Velox Plan, the aggregates type cannot be CallTypedExpr");
-      } else {
-        aggFunction->add_arguments()->mutable_value()->MergeFrom(
-            exprConvertor_->toSubstraitExpr(arena, expr, inputType));
-
-        arguments.emplace_back(expr->type());
-      }
-    }
-
-    auto referenceNumber = extensionCollector_->getReferenceNumber(
-        funName, aggregate.rawInputTypes, aggregateNode->step());
-
-    aggFunction->set_function_reference(referenceNumber);
-
-    aggFunction->mutable_output_type()->MergeFrom(
-        typeConvertor_->toSubstraitType(arena, aggregate.call->type()));
-
-    // Set substrait aggregate Function phase.
-    aggFunction->set_phase(toAggregationPhase(aggregateNode->step()));
-  }
-
-  // Direct output.
-  aggregateRel->mutable_common()->mutable_direct();
-}
-
-void VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::OrderByNode>& orderByNode,
-    ::substrait::SortRel* sortRel) {
-  const auto& source = getSingleSource(orderByNode);
-  toSubstrait(arena, source, sortRel->mutable_input());
-
-  sortRel->MergeFrom(processSortFields(
-      arena,
-      orderByNode->sortingKeys(),
-      orderByNode->sortingOrders(),
-      source->outputType()));
-
-  VELOX_CHECK(
-      !orderByNode->isPartial(),
-      "Substrait doesn't support partial order by yet");
-  sortRel->mutable_common()->mutable_direct();
-}
-
-void VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::TopNNode>& topNNode,
-    ::substrait::FetchRel* fetchRel) {
-  const auto& source = getSingleSource(topNNode);
-
-  // Construct the sortRel as the FetchRel input.
-  ::substrait::SortRel* sortRel = fetchRel->mutable_input()->mutable_sort();
-  toSubstrait(arena, source, sortRel->mutable_input());
-
-  sortRel->MergeFrom(processSortFields(
-      arena,
-      topNNode->sortingKeys(),
-      topNNode->sortingOrders(),
-      source->outputType()));
-
-  sortRel->mutable_common()->mutable_direct();
-
-  VELOX_CHECK(
-      !topNNode->isPartial(), "Substrait doesn't support partial topN yet");
-
-  fetchRel->set_offset(0);
-  fetchRel->set_count(topNNode->count());
-  fetchRel->mutable_common()->mutable_direct();
-}
-
-const ::substrait::SortRel& VeloxToSubstraitPlanConvertor::processSortFields(
-    google::protobuf::Arena& arena,
-    const std::vector<core::FieldAccessTypedExprPtr>& sortingKeys,
-    const std::vector<core::SortOrder>& sortingOrders,
-    const facebook::velox::RowTypePtr& inputType) {
-  ::substrait::SortRel* sortRel =
-      google::protobuf::Arena::CreateMessage<::substrait::SortRel>(&arena);
-
-  VELOX_CHECK_EQ(
-      sortingKeys.size(),
-      sortingOrders.size(),
-      "Number of sorting keys and sorting orders must be the same");
-
-  for (int64_t i = 0; i < sortingKeys.size(); i++) {
-    ::substrait::SortField* sortField = sortRel->add_sorts();
-    sortField->mutable_expr()->mutable_selection()->MergeFrom(
-        exprConvertor_->toSubstraitExpr(arena, sortingKeys[i], inputType));
-
-    sortField->set_direction(toSortDirection(sortingOrders[i]));
-  }
-  return *sortRel;
-}
-
-void VeloxToSubstraitPlanConvertor::toSubstrait(
-    google::protobuf::Arena& arena,
-    const std::shared_ptr<const core::LimitNode>& limitNode,
-    ::substrait::FetchRel* fetchRel) {
-  const auto& source = getSingleSource(limitNode);
-  toSubstrait(arena, source, fetchRel->mutable_input());
-
-  fetchRel->set_offset(limitNode->offset());
-  fetchRel->set_count(limitNode->count());
-
-  VELOX_CHECK(
-      !limitNode->isPartial(), "Substrait doesn't support partial limit yet");
-
-  fetchRel->mutable_common()->mutable_direct();
-}
-
-const core::PlanNodePtr& VeloxToSubstraitPlanConvertor::getSingleSource(
-    const core::PlanNodePtr& node) {
-  const auto& sources = node->sources();
-
-  VELOX_USER_CHECK_EQ(
-      1, sources.size(), "Plan node must have exactly one source.");
-  return sources[0];
-}
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VeloxToSubstraitPlan.h b/velox/substrait/VeloxToSubstraitPlan.h
deleted file mode 100644
index af8f15efb7f9..000000000000
--- a/velox/substrait/VeloxToSubstraitPlan.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 <google/protobuf/arena.h>
-#include <string>
-#include <typeinfo>
-
-#include "velox/core/PlanNode.h"
-#include "velox/type/Type.h"
-
-#include "velox/substrait/SubstraitExtensionCollector.h"
-#include "velox/substrait/VeloxToSubstraitExpr.h"
-#include "velox/substrait/proto/substrait/algebra.pb.h"
-#include "velox/substrait/proto/substrait/plan.pb.h"
-
-namespace facebook::velox::substrait {
-
-/// Convert the Velox plan into Substrait plan.
-class VeloxToSubstraitPlanConvertor {
- public:
-  /// Convert Velox PlanNode into Substrait Plan.
-  /// @param vPlan Velox query plan to convert.
-  /// @param arena Arena to use for allocating Substrait plan objects.
-  /// @return A pointer to Substrait plan object allocated on the arena and
-  /// representing the input Velox plan.
-  ::substrait::Plan& toSubstrait(
-      google::protobuf::Arena& arena,
-      const core::PlanNodePtr& planNode);
-
- private:
-  /// Convert Velox PlanNode into Substrait Rel.
-  void toSubstrait(
-      google::protobuf::Arena& arena,
-      const core::PlanNodePtr& planNode,
-      ::substrait::Rel* rel);
-
-  /// Convert Velox FilterNode into Substrait FilterRel.
-  void toSubstrait(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::FilterNode>& filterNode,
-      ::substrait::FilterRel* filterRel);
-
-  /// Convert Velox ValuesNode into Substrait ReadRel.
-  void toSubstrait(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::ValuesNode>& valuesNode,
-      ::substrait::ReadRel* readRel);
-
-  /// Convert Velox ProjectNode into Substrait ProjectRel.
-  void toSubstrait(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::ProjectNode>& projectNode,
-      ::substrait::ProjectRel* projectRel);
-
-  /// Convert Velox Aggregation Node into Substrait AggregateRel.
-  void toSubstrait(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::AggregationNode>& aggregateNode,
-      ::substrait::AggregateRel* aggregateRel);
-
-  /// Convert Velox OrderBy Node into Substrait SortRel.
-  void toSubstrait(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::OrderByNode>& orderByNode,
-      ::substrait::SortRel* sortRel);
-
-  /// Convert Velox TopN Node into Substrait SortRel->FetchRel.
-  void toSubstrait(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::TopNNode>& topNNode,
-      ::substrait::FetchRel* fetchRel);
-
-  /// Helper function to process sortingKeys and sortingOrders in Velox to
-  /// convert them to the sortField of SortRel in Substrait.
-  const ::substrait::SortRel& processSortFields(
-      google::protobuf::Arena& arena,
-      const std::vector<core::FieldAccessTypedExprPtr>& sortingKeys,
-      const std::vector<core::SortOrder>& sortingOrders,
-      const RowTypePtr& inputType);
-
-  /// Convert Velox Limit Node into Substrait FetchRel.
-  void toSubstrait(
-      google::protobuf::Arena& arena,
-      const std::shared_ptr<const core::LimitNode>& limitNode,
-      ::substrait::FetchRel* fetchRel);
-
-  /// Check there only have one source for the velox node and return it.
-  const core::PlanNodePtr& getSingleSource(const core::PlanNodePtr& node);
-
-  /// The Expression converter used to convert Velox representations into
-  /// Substrait expressions.
-  VeloxToSubstraitExprConvertorPtr exprConvertor_;
-
-  /// The Type converter used to conver velox representation into Substrait
-  /// type.
-  std::shared_ptr<VeloxToSubstraitTypeConvertor> typeConvertor_;
-
-  /// The Extension collector storing the relations between the function
-  /// signature and the function reference number.
-  SubstraitExtensionCollectorPtr extensionCollector_;
-};
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VeloxToSubstraitType.cpp b/velox/substrait/VeloxToSubstraitType.cpp
deleted file mode 100644
index 28008986fa10..000000000000
--- a/velox/substrait/VeloxToSubstraitType.cpp
+++ /dev/null
@@ -1,220 +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/substrait/VeloxToSubstraitType.h"
-
-#include "velox/expression/Expr.h"
-
-namespace facebook::velox::substrait {
-
-const ::substrait::Type& VeloxToSubstraitTypeConvertor::toSubstraitType(
-    google::protobuf::Arena& arena,
-    const velox::TypePtr& type) {
-  ::substrait::Type* substraitType =
-      google::protobuf::Arena::CreateMessage<::substrait::Type>(&arena);
-
-  switch (type->kind()) {
-    case velox::TypeKind::BOOLEAN: {
-      auto substraitBool =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_Boolean>(
-              &arena);
-      substraitBool->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_bool_(substraitBool);
-
-      break;
-    }
-    case velox::TypeKind::TINYINT: {
-      auto substraitI8 =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_I8>(&arena);
-      substraitI8->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_i8(substraitI8);
-      break;
-    }
-    case velox::TypeKind::SMALLINT: {
-      auto substraitI16 =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_I16>(&arena);
-      substraitI16->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_i16(substraitI16);
-      break;
-    }
-    case velox::TypeKind::INTEGER: {
-      if (type->isDate()) {
-        auto substraitDate =
-            google::protobuf::Arena::CreateMessage<::substrait::Type_Date>(
-                &arena);
-        substraitDate->set_nullability(
-            ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-        substraitType->set_allocated_date(substraitDate);
-        return *substraitType;
-      }
-
-      auto substraitI32 =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_I32>(&arena);
-      substraitI32->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_i32(substraitI32);
-      break;
-    }
-    case velox::TypeKind::BIGINT: {
-      auto substraitI64 =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_I64>(&arena);
-      substraitI64->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_i64(substraitI64);
-      break;
-    }
-    case velox::TypeKind::REAL: {
-      auto substraitFp32 =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_FP32>(
-              &arena);
-      substraitFp32->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_fp32(substraitFp32);
-      break;
-    }
-    case velox::TypeKind::DOUBLE: {
-      auto substraitFp64 =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_FP64>(
-              &arena);
-      substraitFp64->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_fp64(substraitFp64);
-      break;
-    }
-    case velox::TypeKind::VARCHAR: {
-      auto substraitString =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_String>(
-              &arena);
-      substraitString->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_string(substraitString);
-      break;
-    }
-    case velox::TypeKind::VARBINARY: {
-      auto substraitVarBinary =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_Binary>(
-              &arena);
-      substraitVarBinary->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_binary(substraitVarBinary);
-      break;
-    }
-    case velox::TypeKind::TIMESTAMP: {
-      auto substraitTimestamp =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_Timestamp>(
-              &arena);
-      substraitTimestamp->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_timestamp(substraitTimestamp);
-      break;
-    }
-    case velox::TypeKind::ARRAY: {
-      ::substrait::Type_List* substraitList =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_List>(
-              &arena);
-
-      substraitList->mutable_type()->MergeFrom(
-          toSubstraitType(arena, type->asArray().elementType()));
-
-      substraitList->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-
-      substraitType->set_allocated_list(substraitList);
-
-      break;
-    }
-    case velox::TypeKind::MAP: {
-      ::substrait::Type_Map* substraitMap =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_Map>(&arena);
-
-      substraitMap->mutable_key()->MergeFrom(
-          toSubstraitType(arena, type->asMap().keyType()));
-      substraitMap->mutable_value()->MergeFrom(
-          toSubstraitType(arena, type->asMap().valueType()));
-
-      substraitMap->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-
-      substraitType->set_allocated_map(substraitMap);
-
-      break;
-    }
-    case velox::TypeKind::ROW: {
-      ::substrait::Type_Struct* substraitStruct =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_Struct>(
-              &arena);
-      for (const auto& child : type->asRow().children()) {
-        substraitStruct->set_nullability(
-            ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-        substraitStruct->add_types()->MergeFrom(toSubstraitType(arena, child));
-      }
-      substraitStruct->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_struct_(substraitStruct);
-      break;
-    }
-    case velox::TypeKind::UNKNOWN: {
-      auto substraitUserDefined =
-          google::protobuf::Arena::CreateMessage<::substrait::Type_UserDefined>(
-              &arena);
-      substraitUserDefined->set_type_reference(0);
-      substraitUserDefined->set_nullability(
-          ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-      substraitType->set_allocated_user_defined(substraitUserDefined);
-      break;
-    }
-    case velox::TypeKind::FUNCTION:
-    case velox::TypeKind::OPAQUE:
-    case velox::TypeKind::INVALID:
-    default:
-      VELOX_UNSUPPORTED("Unsupported velox type '{}'", type->toString());
-  }
-  return *substraitType;
-}
-
-const ::substrait::NamedStruct&
-VeloxToSubstraitTypeConvertor::toSubstraitNamedStruct(
-    google::protobuf::Arena& arena,
-    const velox::RowTypePtr& rowType) {
-  ::substrait::NamedStruct* substraitNamedStruct =
-      google::protobuf::Arena::CreateMessage<::substrait::NamedStruct>(&arena);
-
-  const auto size = rowType->size();
-  if (size != 0) {
-    const auto& names = rowType->names();
-    const auto& veloxTypes = rowType->children();
-
-    auto substraitType = substraitNamedStruct->mutable_struct_();
-
-    substraitType->set_nullability(
-        ::substrait::Type_Nullability_NULLABILITY_NULLABLE);
-
-    for (int64_t i = 0; i < size; ++i) {
-      const auto& name = names.at(i);
-      const auto& veloxType = veloxTypes.at(i);
-      substraitNamedStruct->add_names(name);
-
-      substraitType->add_types()->MergeFrom(toSubstraitType(arena, veloxType));
-    }
-  }
-
-  return *substraitNamedStruct;
-}
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/VeloxToSubstraitType.h b/velox/substrait/VeloxToSubstraitType.h
deleted file mode 100644
index 5a1f297a7d40..000000000000
--- a/velox/substrait/VeloxToSubstraitType.h
+++ /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.
- */
-
-#pragma once
-
-#include "velox/core/PlanNode.h"
-
-#include "velox/substrait/proto/substrait/algebra.pb.h"
-#include "velox/substrait/proto/substrait/type.pb.h"
-
-namespace facebook::velox::substrait {
-
-class VeloxToSubstraitTypeConvertor {
- public:
-  /// Convert Velox RowType to Substrait NamedStruct.
-  const ::substrait::NamedStruct& toSubstraitNamedStruct(
-      google::protobuf::Arena& arena,
-      const velox::RowTypePtr& rowType);
-
-  /// Convert Velox Type to Substrait Type.
-  const ::substrait::Type& toSubstraitType(
-      google::protobuf::Arena& arena,
-      const velox::TypePtr& type);
-};
-
-using VeloxToSubstraitTypeConvertorPtr =
-    std::shared_ptr<VeloxToSubstraitTypeConvertor>;
-
-} // namespace facebook::velox::substrait
diff --git a/velox/substrait/proto/substrait/.clang-format b/velox/substrait/proto/substrait/.clang-format
deleted file mode 100644
index 88fd00791f8f..000000000000
--- a/velox/substrait/proto/substrait/.clang-format
+++ /dev/null
@@ -1,4 +0,0 @@
----
-Language: Proto
-DisableFormat: true
-...
diff --git a/velox/substrait/proto/substrait/algebra.proto b/velox/substrait/proto/substrait/algebra.proto
deleted file mode 100644
index 3913871aca09..000000000000
--- a/velox/substrait/proto/substrait/algebra.proto
+++ /dev/null
@@ -1,1295 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait;
-
-import "google/protobuf/any.proto";
-import "velox/substrait/proto/substrait/extensions/extensions.proto";
-import "velox/substrait/proto/substrait/type.proto";
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-// Common fields for all relational operators
-message RelCommon {
-  oneof emit_kind {
-    // The underlying relation is output as is (no reordering or projection of columns)
-    Direct direct = 1;
-    // Allows to control for order and inclusion of fields
-    Emit emit = 2;
-  }
-
-  Hint hint = 3;
-  substrait.extensions.AdvancedExtension advanced_extension = 4;
-
-  // Direct indicates no change on presence and ordering of fields in the output
-  message Direct {}
-
-  // Remap which fields are output and in which order
-  message Emit {
-    repeated int32 output_mapping = 1;
-  }
-
-  // Changes to the operation that can influence efficiency/performance but
-  // should not impact correctness.
-  message Hint {
-    Stats stats = 1;
-    RuntimeConstraint constraint = 2;
-    substrait.extensions.AdvancedExtension advanced_extension = 10;
-
-    // The statistics related to a hint (physical properties of records)
-    message Stats {
-      double row_count = 1;
-      double record_size = 2;
-      substrait.extensions.AdvancedExtension advanced_extension = 10;
-    }
-
-    message RuntimeConstraint {
-      // TODO: nodes, cpu threads/%, memory, iops, etc.
-
-      substrait.extensions.AdvancedExtension advanced_extension = 10;
-    }
-  }
-}
-
-// The scan operator of base data (physical or virtual), including filtering and projection.
-message ReadRel {
-  RelCommon common = 1;
-  NamedStruct base_schema = 2;
-  Expression filter = 3;
-  Expression best_effort_filter = 11;
-  Expression.MaskExpression projection = 4;
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-
-  // Definition of which type of scan operation is to be performed
-  oneof read_type {
-    VirtualTable virtual_table = 5;
-    LocalFiles local_files = 6;
-    NamedTable named_table = 7;
-    ExtensionTable extension_table = 8;
-  }
-
-  // A base table. The list of string is used to represent namespacing (e.g., mydb.mytable).
-  // This assumes shared catalog between systems exchanging a message.
-  message NamedTable {
-    repeated string names = 1;
-    substrait.extensions.AdvancedExtension advanced_extension = 10;
-  }
-
-  // A table composed of literals.
-  message VirtualTable {
-    repeated Expression.Literal.Struct values = 1;
-  }
-
-  // A stub type that can be used to extend/introduce new table types outside
-  // the specification.
-  message ExtensionTable {
-    google.protobuf.Any detail = 1;
-  }
-
-  // Represents a list of files in input of a scan operation
-  message LocalFiles {
-    repeated FileOrFiles items = 1;
-    substrait.extensions.AdvancedExtension advanced_extension = 10;
-
-    // Many files consist of indivisible chunks (e.g. parquet row groups
-    // or CSV rows).  If a slice partially selects an indivisible chunk
-    // then the consumer should employ some rule to decide which slice to
-    // include the chunk in (e.g. include it in the slice that contains
-    // the midpoint of the chunk)
-    message FileOrFiles {
-      oneof path_type {
-        // A URI that can refer to either a single folder or a single file
-        string uri_path = 1;
-        // A URI where the path portion is a glob expression that can
-        // identify zero or more paths.
-        // Consumers should support the POSIX syntax.  The recursive
-        // globstar (**) may not be supported.
-        string uri_path_glob = 2;
-        // A URI that refers to a single file
-        string uri_file = 3;
-        // A URI that refers to a single folder
-        string uri_folder = 4;
-      }
-
-      // Original file format enum, superseded by the file_format oneof.
-      reserved 5;
-      reserved "format";
-
-      // The index of the partition this item belongs to
-      uint64 partition_index = 6;
-
-      // The start position in byte to read from this item
-      uint64 start = 7;
-
-      // The length in byte to read from this item
-      uint64 length = 8;
-
-      message ParquetReadOptions {}
-      message ArrowReadOptions {}
-      message OrcReadOptions {}
-      message DwrfReadOptions {}
-
-      // The format of the files.
-      oneof file_format {
-        ParquetReadOptions parquet = 9;
-        ArrowReadOptions arrow = 10;
-        OrcReadOptions orc = 11;
-        google.protobuf.Any extension = 12;
-        DwrfReadOptions dwrf = 13;
-      }
-    }
-  }
-}
-
-// This operator allows to represent calculated expressions of fields (e.g., a+b). Direct/Emit are used to represent classical relational projections
-message ProjectRel {
-  RelCommon common = 1;
-  Rel input = 2;
-  repeated Expression expressions = 3;
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// The binary JOIN relational operator left-join-right, including various join types, a join condition and post_join_filter expression
-message JoinRel {
-  RelCommon common = 1;
-  Rel left = 2;
-  Rel right = 3;
-  Expression expression = 4;
-  Expression post_join_filter = 5;
-
-  JoinType type = 6;
-
-  enum JoinType {
-    JOIN_TYPE_UNSPECIFIED = 0;
-    JOIN_TYPE_INNER = 1;
-    JOIN_TYPE_OUTER = 2;
-    JOIN_TYPE_LEFT = 3;
-    JOIN_TYPE_RIGHT = 4;
-    JOIN_TYPE_SEMI = 5;
-    JOIN_TYPE_ANTI = 6;
-    // This join is useful for nested sub-queries where we need exactly one tuple in output (or throw exception)
-    // See Section 3.2 of https://15721.courses.cs.cmu.edu/spring2018/papers/16-optimizer2/hyperjoins-btw2017.pdf
-    JOIN_TYPE_SINGLE = 7;
-  }
-
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// Cartesian product relational operator of two tables (left and right)
-message CrossRel {
-  RelCommon common = 1;
-  Rel left = 2;
-  Rel right = 3;
-
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// The relational operator representing LIMIT/OFFSET or TOP type semantics.
-message FetchRel {
-  RelCommon common = 1;
-  Rel input = 2;
-  // the offset expressed in number of records
-  int64 offset = 3;
-  // the amount of records to return
-  int64 count = 4;
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// The relational operator representing a GROUP BY Aggregate
-message AggregateRel {
-  RelCommon common = 1;
-
-  // Input of the aggregation
-  Rel input = 2;
-
-  // A list of expression grouping that the aggregation measured should be calculated for.
-  repeated Grouping groupings = 3;
-
-  // A list of one or more aggregate expressions along with an optional filter.
-  repeated Measure measures = 4;
-
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-
-  message Grouping {
-    repeated Expression grouping_expressions = 1;
-  }
-
-  message Measure {
-    AggregateFunction measure = 1;
-
-    // An optional boolean expression that acts to filter which records are
-    // included in the measure. True means include this record for calculation
-    // within the measure.
-    // Helps to support SUM(<c>) FILTER(WHERE...) syntax without masking opportunities for optimization
-    Expression filter = 2;
-  }
-}
-
-// The ORDERY BY (or sorting) relational operator. Beside describing a base relation, it includes a list of fields to sort on
-message SortRel {
-  RelCommon common = 1;
-  Rel input = 2;
-  repeated SortField sorts = 3;
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// The relational operator capturing simple FILTERs (as in the WHERE clause of SQL)
-message FilterRel {
-  RelCommon common = 1;
-  Rel input = 2;
-  Expression condition = 3;
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// The relational set operators (intersection/union/etc..)
-message SetRel {
-  RelCommon common = 1;
-  // The first input is the primary input, the remaining are secondary
-  // inputs.  There must be at least two inputs.
-  repeated Rel inputs = 2;
-  SetOp op = 3;
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-
-  enum SetOp {
-    SET_OP_UNSPECIFIED = 0;
-    SET_OP_MINUS_PRIMARY = 1;
-    SET_OP_MINUS_MULTISET = 2;
-    SET_OP_INTERSECTION_PRIMARY = 3;
-    SET_OP_INTERSECTION_MULTISET = 4;
-    SET_OP_UNION_DISTINCT = 5;
-    SET_OP_UNION_ALL = 6;
-  }
-}
-
-// Stub to support extension with a single input
-message ExtensionSingleRel {
-  RelCommon common = 1;
-  Rel input = 2;
-  google.protobuf.Any detail = 3;
-}
-
-// Stub to support extension with a zero inputs
-message ExtensionLeafRel {
-  RelCommon common = 1;
-  google.protobuf.Any detail = 2;
-}
-
-// Stub to support extension with multiple inputs
-message ExtensionMultiRel {
-  RelCommon common = 1;
-  repeated Rel inputs = 2;
-  google.protobuf.Any detail = 3;
-}
-
-// A redistribution operation
-message ExchangeRel {
-  RelCommon common = 1;
-  Rel input = 2;
-  int32 partition_count = 3;
-  repeated ExchangeTarget targets = 4;
-
-  // the type of exchange used
-  oneof exchange_kind {
-    ScatterFields scatter_by_fields = 5;
-    SingleBucketExpression single_target = 6;
-    MultiBucketExpression multi_target = 7;
-    RoundRobin round_robin = 8;
-    Broadcast broadcast = 9;
-  }
-
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-
-  message ScatterFields {
-    repeated Expression.FieldReference fields = 1;
-  }
-
-  // Returns a single bucket number per record.
-  message SingleBucketExpression {
-    Expression expression = 1;
-  }
-
-  // Returns zero or more bucket numbers per record
-  message MultiBucketExpression {
-    Expression expression = 1;
-    bool constrained_to_count = 2;
-  }
-
-  // Send all data to every target.
-  message Broadcast {}
-
-  // Route approximately
-  message RoundRobin {
-    // whether the round robin behavior is required to exact (per record) or
-    // approximate. Defaults to approximate.
-    bool exact = 1;
-  }
-
-  // The message to describe partition targets of an exchange
-  message ExchangeTarget {
-    // Describes the partition id(s) to send. If this is empty, all data is sent
-    // to this target.
-    repeated int32 partition_id = 1;
-
-    oneof target_type {
-      string uri = 2;
-      google.protobuf.Any extended = 3;
-    }
-  }
-}
-
-// A relation with output field names.
-//
-// This is for use at the root of a `Rel` tree.
-message RelRoot {
-  // A relation
-  Rel input = 1;
-  // Field names in depth-first order
-  repeated string names = 2;
-}
-
-// A relation (used internally in a plan)
-message Rel {
-  oneof rel_type {
-    ReadRel read = 1;
-    FilterRel filter = 2;
-    FetchRel fetch = 3;
-    AggregateRel aggregate = 4;
-    SortRel sort = 5;
-    JoinRel join = 6;
-    ProjectRel project = 7;
-    SetRel set = 8;
-    ExtensionSingleRel extension_single = 9;
-    ExtensionMultiRel extension_multi = 10;
-    ExtensionLeafRel extension_leaf = 11;
-    CrossRel cross = 12;
-
-    //Physical relations
-    HashJoinRel hash_join = 13;
-    MergeJoinRel merge_join = 14;
-  }
-}
-
-// A base object for writing (e.g., a table or a view).
-message NamedObjectWrite {
-  // The list of string is used to represent namespacing (e.g., mydb.mytable).
-  // This assumes shared catalog between systems exchanging a message.
-  repeated string names = 1;
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// A stub type that can be used to extend/introduce new table types outside
-// the specification.
-message ExtensionObject {
-  google.protobuf.Any detail = 1;
-}
-
-message DdlRel {
-  // Definition of which type of object we are operating on
-  oneof write_type {
-    NamedObjectWrite named_object = 1;
-    ExtensionObject extension_object = 2;
-  }
-
-  // The columns that will be modified (representing after-image of a schema change)
-  NamedStruct table_schema = 3;
-  // The default values for the columns (representing after-image of a schema change)
-  // E.g., in case of an ALTER TABLE that changes some of the column default values, we expect
-  // the table_defaults Struct to report a full list of default values reflecting the result of applying
-  // the ALTER TABLE operator successfully
-  Expression.Literal.Struct table_defaults = 4;
-
-  // Which type of object we operate on
-  DdlObject object = 5;
-
-  // The type of operation to perform
-  DdlOp op = 6;
-
-  // The body of the CREATE VIEW
-  Rel view_definition = 7;
-
-  enum DdlObject {
-    DDL_OBJECT_UNSPECIFIED = 0;
-    // A Table object in the system
-    DDL_OBJECT_TABLE = 1;
-    // A View object in the system
-    DDL_OBJECT_VIEW = 2;
-  }
-
-  enum DdlOp {
-    DDL_OP_UNSPECIFIED = 0;
-    // A create operation (for any object)
-    DDL_OP_CREATE = 1;
-    // A create operation if the object does not exist, or replaces it (equivalent to a DROP + CREATE) if the object already exists
-    DDL_OP_CREATE_OR_REPLACE = 2;
-    // An operation that modifies the schema (e.g., column names, types, default values) for the target object
-    DDL_OP_ALTER = 3;
-    // An operation that removes an object from the system
-    DDL_OP_DROP = 4;
-    // An operation that removes an object from the system (without throwing an exception if the object did not exist)
-    DDL_OP_DROP_IF_EXIST = 5;
-  }
-  //TODO add PK/constraints/indexes/etc..?
-}
-
-// The operator that modifies the content of a database (operates on 1 table at a time, but tuple-selection/source can be
-// based on joining of multiple tables).
-message WriteRel {
-  // Definition of which TABLE we are operating on
-  oneof write_type {
-    NamedObjectWrite named_table = 1;
-    ExtensionObject extension_table = 2;
-  }
-
-  // The schema of the table (must align with Rel input (e.g., number of leaf fields must match))
-  NamedStruct table_schema = 3;
-
-  // The type of operation to perform
-  WriteOp op = 4;
-
-  // The relation that determines the tuples to add/remove/modify
-  // the schema must match with table_schema. Default values must be explicitly stated
-  // in a ProjectRel at the top of the input. The match must also
-  // occur in case of DELETE to ensure multi-engine plans are unequivocal.
-  Rel input = 5;
-
-  // Output mode determines what is the output of executing this rel
-  OutputMode output = 6;
-
-  enum WriteOp {
-    WRITE_OP_UNSPECIFIED = 0;
-    // The insert of new tuples in a table
-    WRITE_OP_INSERT = 1;
-    // The removal of tuples from a table
-    WRITE_OP_DELETE = 2;
-    // The modification of existing tuples within a table
-    WRITE_OP_UPDATE = 3;
-    // The Creation of a new table, and the insert of new tuples in the table
-    WRITE_OP_CTAS = 4;
-  }
-
-  enum OutputMode {
-    OUTPUT_MODE_UNSPECIFIED = 0;
-    // return no tuples at all
-    OUTPUT_MODE_NO_OUTPUT = 1;
-    // this mode makes the operator return all the tuple INSERTED/DELETED/UPDATED by the operator.
-    // The operator returns the AFTER-image of any change. This can be further manipulated by operators upstreams
-    // (e.g., retunring the typical "count of modified tuples").
-    // For scenarios in which the BEFORE image is required, the user must implement a spool (via references to
-    // subplans in the body of the Rel input) and return those with anounter PlanRel.relations.
-    OUTPUT_MODE_MODIFIED_TUPLES = 2;
-  }
-}
-
-// The hash equijoin join operator will build a hash table out of the right input based on a set of join keys.
-// It will then probe that hash table for incoming inputs, finding matches.
-message HashJoinRel {
-  RelCommon common = 1;
-  Rel left = 2;
-  Rel right = 3;
-  repeated Expression.FieldReference left_keys = 4;
-  repeated Expression.FieldReference right_keys = 5;
-  Expression post_join_filter = 6;
-
-  JoinType type = 7;
-
-  enum JoinType {
-    JOIN_TYPE_UNSPECIFIED = 0;
-    JOIN_TYPE_INNER = 1;
-    JOIN_TYPE_OUTER = 2;
-    JOIN_TYPE_LEFT = 3;
-    JOIN_TYPE_RIGHT = 4;
-    JOIN_TYPE_LEFT_SEMI = 5;
-    JOIN_TYPE_RIGHT_SEMI = 6;
-    JOIN_TYPE_LEFT_ANTI = 7;
-    JOIN_TYPE_RIGHT_ANTI = 8;
-  }
-
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// The merge equijoin does a join by taking advantage of two sets that are sorted on the join keys.
-// This allows the join operation to be done in a streaming fashion.
-message MergeJoinRel {
-  RelCommon common = 1;
-  Rel left = 2;
-  Rel right = 3;
-  repeated Expression.FieldReference left_keys = 4;
-  repeated Expression.FieldReference right_keys = 5;
-  Expression post_join_filter = 6;
-
-  JoinType type = 7;
-
-  enum JoinType {
-    JOIN_TYPE_UNSPECIFIED = 0;
-    JOIN_TYPE_INNER = 1;
-    JOIN_TYPE_OUTER = 2;
-    JOIN_TYPE_LEFT = 3;
-    JOIN_TYPE_RIGHT = 4;
-    JOIN_TYPE_LEFT_SEMI = 5;
-    JOIN_TYPE_RIGHT_SEMI = 6;
-    JOIN_TYPE_LEFT_ANTI = 7;
-    JOIN_TYPE_RIGHT_ANTI = 8;
-  }
-
-  substrait.extensions.AdvancedExtension advanced_extension = 10;
-}
-
-// The argument of a function
-message FunctionArgument {
-  oneof arg_type {
-    string enum = 1;
-    Type type = 2;
-    Expression value = 3;
-  }
-}
-
-// An optional function argument.  Typically used for specifying behavior in
-// invalid or corner cases.
-message FunctionOption {
-  // Name of the option to set. If the consumer does not recognize the
-  // option, it must reject the plan. The name is matched case-insensitively
-  // with option names defined for the function.
-  string name = 1;
-
-  // List of behavior options allowed by the producer. At least one must be
-  // specified; to leave an option unspecified, simply don't add an entry to
-  // `options`. The consumer must use the first option from the list that it
-  // supports. If the consumer supports none of the specified options, it
-  // must reject the plan. The name is matched case-insensitively and must
-  // match one of the option values defined for the option.
-  repeated string preference = 2;
-}
-
-message Expression {
-  oneof rex_type {
-    Literal literal = 1;
-    FieldReference selection = 2;
-    ScalarFunction scalar_function = 3;
-    WindowFunction window_function = 5;
-    IfThen if_then = 6;
-    SwitchExpression switch_expression = 7;
-    SingularOrList singular_or_list = 8;
-    MultiOrList multi_or_list = 9;
-    Cast cast = 11;
-    Subquery subquery = 12;
-    Nested nested = 13;
-
-    // deprecated: enum literals are only sensible in the context of
-    // function arguments, for which FunctionArgument should now be
-    // used
-    Enum enum = 10 [deprecated = true];
-  }
-
-  message Enum {
-    option deprecated = true;
-
-    oneof enum_kind {
-      string specified = 1;
-      Empty unspecified = 2;
-    }
-
-    message Empty {
-      option deprecated = true;
-    }
-  }
-
-  message Literal {
-    oneof literal_type {
-      bool boolean = 1;
-      int32 i8 = 2;
-      int32 i16 = 3;
-      int32 i32 = 5;
-      int64 i64 = 7;
-      float fp32 = 10;
-      double fp64 = 11;
-      string string = 12;
-      bytes binary = 13;
-      // Timestamp in units of microseconds since the UNIX epoch.
-      int64 timestamp = 14;
-      // Date in units of days since the UNIX epoch.
-      int32 date = 16;
-      // Time in units of microseconds past midnight
-      int64 time = 17;
-      IntervalYearToMonth interval_year_to_month = 19;
-      IntervalDayToSecond interval_day_to_second = 20;
-      string fixed_char = 21;
-      VarChar var_char = 22;
-      bytes fixed_binary = 23;
-      Decimal decimal = 24;
-      Struct struct = 25;
-      Map map = 26;
-      // Timestamp in units of microseconds since the UNIX epoch.
-      int64 timestamp_tz = 27;
-      bytes uuid = 28;
-      Type null = 29; // a typed null literal
-      List list = 30;
-      Type.List empty_list = 31;
-      Type.Map empty_map = 32;
-      UserDefined user_defined = 33;
-    }
-
-    // whether the literal type should be treated as a nullable type. Applies to
-    // all members of union other than the Typed null (which should directly
-    // declare nullability).
-    bool nullable = 50;
-
-    // optionally points to a type_variation_anchor defined in this plan.
-    // Applies to all members of union other than the Typed null (which should
-    // directly declare the type variation).
-    uint32 type_variation_reference = 51;
-
-    message VarChar {
-      string value = 1;
-      uint32 length = 2;
-    }
-
-    message Decimal {
-      // little-endian twos-complement integer representation of complete value
-      // (ignoring precision) Always 16 bytes in length
-      bytes value = 1;
-      // The maximum number of digits allowed in the value.
-      // the maximum precision is 38.
-      int32 precision = 2;
-      // declared scale of decimal literal
-      int32 scale = 3;
-    }
-
-    message Map {
-      message KeyValue {
-        Literal key = 1;
-        Literal value = 2;
-      }
-
-      repeated KeyValue key_values = 1;
-    }
-
-    message IntervalYearToMonth {
-      int32 years = 1;
-      int32 months = 2;
-    }
-
-    message IntervalDayToSecond {
-      int32 days = 1;
-      int32 seconds = 2;
-      int32 microseconds = 3;
-    }
-
-    message Struct {
-      // A possibly heterogeneously typed list of literals
-      repeated Literal fields = 1;
-    }
-
-    message List {
-      // A homogeneously typed list of literals
-      repeated Literal values = 1;
-    }
-
-    message UserDefined {
-      // points to a type_anchor defined in this plan
-      uint32 type_reference = 1;
-
-      // The parameters to be bound to the type class, if the type class is
-      // parameterizable.
-      repeated Type.Parameter type_parameters = 3;
-
-      // the value of the literal, serialized using some type-specific
-      // protobuf message
-      google.protobuf.Any value = 2;
-    }
-  }
-
-  // Expression to dynamically construct nested types.
-  message Nested {
-    // Whether the returned nested type is nullable.
-    bool nullable = 1;
-
-    // Optionally points to a type_variation_anchor defined in this plan for
-    // the returned nested type.
-    uint32 type_variation_reference = 2;
-
-    oneof nested_type {
-      Struct struct = 3;
-      List list = 4;
-      Map map = 5;
-    }
-
-    message Map {
-      message KeyValue {
-        // Mandatory key/value expressions.
-        Expression key = 1;
-        Expression value = 2;
-      }
-
-      // One or more key-value pairs. To specify an empty map, use
-      // Literal.empty_map (otherwise type information would be missing).
-      repeated KeyValue key_values = 1;
-    }
-
-    message Struct {
-      // Zero or more possibly heterogeneously-typed list of expressions that
-      // form the struct fields.
-      repeated Expression fields = 1;
-    }
-
-    message List {
-      // A homogeneously-typed list of one or more expressions that form the
-      // list entries. To specify an empty list, use Literal.empty_list
-      // (otherwise type information would be missing).
-      repeated Expression values = 1;
-    }
-  }
-
-  // A scalar function call.
-  message ScalarFunction {
-    // Points to a function_anchor defined in this plan, which must refer
-    // to a scalar function in the associated YAML file. Required; avoid
-    // using anchor/reference zero.
-    uint32 function_reference = 1;
-
-    // The arguments to be bound to the function. This must have exactly the
-    // number of arguments specified in the function definition, and the
-    // argument types must also match exactly:
-    //
-    //  - Value arguments must be bound using FunctionArgument.value, and
-    //    the expression in that must yield a value of a type that a function
-    //    overload is defined for.
-    //  - Type arguments must be bound using FunctionArgument.type.
-    //  - Enum arguments must be bound using FunctionArgument.enum
-    //    followed by Enum.specified, with a string that case-insensitively
-    //    matches one of the allowed options.
-    repeated FunctionArgument arguments = 4;
-
-    // Options to specify behavior for corner cases, or leave behavior
-    // unspecified if the consumer does not need specific behavior in these
-    // cases.
-    repeated FunctionOption options = 5;
-
-    // Must be set to the return type of the function, exactly as derived
-    // using the declaration in the extension.
-    Type output_type = 3;
-
-    // Deprecated; use arguments instead.
-    repeated Expression args = 2 [deprecated = true];
-  }
-
-  // A window function call.
-  message WindowFunction {
-    // Points to a function_anchor defined in this plan, which must refer
-    // to a window function in the associated YAML file. Required; 0 is
-    // considered to be a valid anchor/reference.
-    uint32 function_reference = 1;
-
-    // The arguments to be bound to the function. This must have exactly the
-    // number of arguments specified in the function definition, and the
-    // argument types must also match exactly:
-    //
-    //  - Value arguments must be bound using FunctionArgument.value, and
-    //    the expression in that must yield a value of a type that a function
-    //    overload is defined for.
-    //  - Type arguments must be bound using FunctionArgument.type, and a
-    //    function overload must be defined for that type.
-    //  - Enum arguments must be bound using FunctionArgument.enum
-    //    followed by Enum.specified, with a string that case-insensitively
-    //    matches one of the allowed options.
-    repeated FunctionArgument arguments = 9;
-
-    // Options to specify behavior for corner cases, or leave behavior
-    // unspecified if the consumer does not need specific behavior in these
-    // cases.
-    repeated FunctionOption options = 11;
-
-    // Must be set to the return type of the function, exactly as derived
-    // using the declaration in the extension.
-    Type output_type = 7;
-
-    // Describes which part of the window function to perform within the
-    // context of distributed algorithms. Required. Must be set to
-    // INITIAL_TO_RESULT for window functions that are not decomposable.
-    AggregationPhase phase = 6;
-
-    // If specified, the records that are part of the window defined by
-    // upper_bound and lower_bound are ordered according to this list
-    // before they are aggregated. The first sort field has the highest
-    // priority; only if a sort field determines two records to be equivalent
-    // is the next field queried. This field is optional, and is only allowed
-    // if the window function is defined to support sorting.
-    repeated SortField sorts = 3;
-
-    // Specifies whether equivalent records are merged before being aggregated.
-    // Optional, defaults to AGGREGATION_INVOCATION_ALL.
-    AggregateFunction.AggregationInvocation invocation = 10;
-
-    // When one or more partition expressions are specified, two records are
-    // considered to be in the same partition if and only if these expressions
-    // yield an equal tuple of values for both. When computing the window
-    // function, only the subset of records within the bounds that are also in
-    // the same partition as the current record are aggregated.
-    repeated Expression partitions = 2;
-
-    // Defines the record relative to the current record from which the window
-    // extends. The bound is inclusive. If the lower bound indexes a record
-    // greater than the upper bound, TODO (null range/no records passed?
-    // wrapping around as if lower/upper were swapped? error? null?).
-    // Optional; defaults to the start of the partition.
-    Bound lower_bound = 5;
-
-    // Defines the record relative to the current record up to which the window
-    // extends. The bound is inclusive. If the upper bound indexes a record
-    // less than the lower bound, TODO (null range/no records passed?
-    // wrapping around as if lower/upper were swapped? error? null?).
-    // Optional; defaults to the end of the partition.
-    Bound upper_bound = 4;
-
-    // Deprecated; use arguments instead.
-    repeated Expression args = 8 [deprecated = true];
-
-    // Defines one of the two boundaries for the window of a window function.
-    message Bound {
-      // Defines that the bound extends this far back from the current record.
-      message Preceding {
-        // A strictly positive integer specifying the number of records that
-        // the window extends back from the current record. Required. Use
-        // CurrentRow for offset zero and Following for negative offsets.
-        int64 offset = 1;
-      }
-
-      // Defines that the bound extends this far ahead of the current record.
-      message Following {
-        // A strictly positive integer specifying the number of records that
-        // the window extends ahead of the current record. Required. Use
-        // CurrentRow for offset zero and Preceding for negative offsets.
-        int64 offset = 1;
-      }
-
-      // Defines that the bound extends to or from the current record.
-      message CurrentRow {}
-
-      // Defines an "unbounded bound": for lower bounds this means the start
-      // of the partition, and for upper bounds this means the end of the
-      // partition.
-      message Unbounded {}
-
-      oneof kind {
-        // The bound extends some number of records behind the current record.
-        Preceding preceding = 1;
-
-        // The bound extends some number of records ahead of the current
-        // record.
-        Following following = 2;
-
-        // The bound extends to the current record.
-        CurrentRow current_row = 3;
-
-        // The bound extends to the start of the partition or the end of the
-        // partition, depending on whether this represents the upper or lower
-        // bound.
-        Unbounded unbounded = 4;
-      }
-    }
-  }
-
-  message IfThen {
-    repeated IfClause ifs = 1;
-    Expression else = 2;
-
-    message IfClause {
-      Expression if = 1;
-      Expression then = 2;
-    }
-  }
-
-  message Cast {
-    Type type = 1;
-    Expression input = 2;
-    FailureBehavior failure_behavior = 3;
-
-    enum FailureBehavior {
-      FAILURE_BEHAVIOR_UNSPECIFIED = 0;
-      FAILURE_BEHAVIOR_RETURN_NULL = 1;
-      FAILURE_BEHAVIOR_THROW_EXCEPTION = 2;
-    }
-  }
-
-  message SwitchExpression {
-    Expression match = 3;
-    repeated IfValue ifs = 1;
-    Expression else = 2;
-
-    message IfValue {
-      Literal if = 1;
-      Expression then = 2;
-    }
-  }
-
-  message SingularOrList {
-    Expression value = 1;
-    repeated Expression options = 2;
-  }
-
-  message MultiOrList {
-    repeated Expression value = 1;
-    repeated Record options = 2;
-
-    message Record {
-      repeated Expression fields = 1;
-    }
-  }
-
-  message EmbeddedFunction {
-    repeated Expression arguments = 1;
-    Type output_type = 2;
-    oneof kind {
-      PythonPickleFunction python_pickle_function = 3;
-      WebAssemblyFunction web_assembly_function = 4;
-    }
-
-    message PythonPickleFunction {
-      bytes function = 1;
-      repeated string prerequisite = 2;
-    }
-
-    message WebAssemblyFunction {
-      bytes script = 1;
-      repeated string prerequisite = 2;
-    }
-  }
-
-  // A way to reference the inner property of a complex record. Can reference
-  // either a map key by literal, a struct field by the ordinal position of
-  // the desired field or a particular element in an array. Supports
-  // expressions that would roughly translate to something similar to:
-  // a.b[2].c['my_map_key'].x where a,b,c and x are struct field references
-  // (ordinalized in the internal representation here), [2] is a list offset
-  // and ['my_map_key'] is a reference into a map field.
-  message ReferenceSegment {
-    oneof reference_type {
-      MapKey map_key = 1;
-      StructField struct_field = 2;
-      ListElement list_element = 3;
-    }
-
-    message MapKey {
-      // literal based reference to specific possible value in map.
-      Literal map_key = 1;
-
-      // Optional child segment
-      ReferenceSegment child = 2;
-    }
-
-    message StructField {
-      // zero-indexed ordinal position of field in struct
-      int32 field = 1;
-
-      // Optional child segment
-      ReferenceSegment child = 2;
-    }
-
-    message ListElement {
-      // zero-indexed ordinal position of element in list
-      int32 offset = 1;
-
-      // Optional child segment
-      ReferenceSegment child = 2;
-    }
-  }
-
-  // A reference that takes an existing subtype and selectively removes fields
-  // from it. For example, one might initially have an inner struct with 100
-  // fields but a a particular operation only needs to interact with only 2 of
-  // those 100 fields. In this situation, one would use a mask expression to
-  // eliminate the 98 fields that are not relevant to the rest of the operation
-  // pipeline.
-  //
-  // Note that this does not fundamentally alter the structure of data beyond
-  // the elimination of unecessary elements.
-  message MaskExpression {
-    StructSelect select = 1;
-    bool maintain_singular_struct = 2;
-
-    message Select {
-      oneof type {
-        StructSelect struct = 1;
-        ListSelect list = 2;
-        MapSelect map = 3;
-      }
-    }
-
-    message StructSelect {
-      repeated StructItem struct_items = 1;
-    }
-
-    message StructItem {
-      int32 field = 1;
-      Select child = 2;
-    }
-
-    message ListSelect {
-      repeated ListSelectItem selection = 1;
-      Select child = 2;
-
-      message ListSelectItem {
-        oneof type {
-          ListElement item = 1;
-          ListSlice slice = 2;
-        }
-
-        message ListElement {
-          int32 field = 1;
-        }
-
-        message ListSlice {
-          int32 start = 1;
-          int32 end = 2;
-        }
-      }
-    }
-
-    message MapSelect {
-      oneof select {
-        MapKey key = 1;
-        MapKeyExpression expression = 2;
-      }
-
-      Select child = 3;
-
-      message MapKey {
-        string map_key = 1;
-      }
-
-      message MapKeyExpression {
-        string map_key_expression = 1;
-      }
-    }
-  }
-
-  // A reference to an inner part of a complex object. Can reference reference a
-  // single element or a masked version of elements
-  message FieldReference {
-    // Whether this is composed of a single element reference or a masked
-    // element subtree
-    oneof reference_type {
-      ReferenceSegment direct_reference = 1;
-      MaskExpression masked_reference = 2;
-    }
-
-    // Whether this reference has an origin of a root struct or is based on the
-    // ouput of an expression. When this is a RootReference and direct_reference
-    // above is used, the direct_reference must be of a type StructField.
-    oneof root_type {
-      Expression expression = 3;
-      RootReference root_reference = 4;
-      OuterReference outer_reference = 5;
-    }
-
-    // Singleton that expresses this FieldReference is rooted off the root
-    // incoming record type
-    message RootReference {}
-
-    // A root reference for the outer relation's subquery
-    message OuterReference {
-      // number of subquery boundaries to traverse up for this field's reference
-      //
-      // This value must be >= 1
-      uint32 steps_out = 1;
-    }
-  }
-
-  // Subquery relation expression
-  message Subquery {
-    oneof subquery_type {
-      // Scalar subquery
-      Scalar scalar = 1;
-      // x IN y predicate
-      InPredicate in_predicate = 2;
-      // EXISTS/UNIQUE predicate
-      SetPredicate set_predicate = 3;
-      // ANY/ALL predicate
-      SetComparison set_comparison = 4;
-    }
-
-    // A subquery with one row and one column. This is often an aggregate
-    // though not required to be.
-    message Scalar {
-      Rel input = 1;
-    }
-
-    // Predicate checking that the left expression is contained in the right
-    // subquery
-    //
-    // Examples:
-    //
-    // x IN (SELECT * FROM t)
-    // (x, y) IN (SELECT a, b FROM t)
-    message InPredicate {
-      repeated Expression needles = 1;
-      Rel haystack = 2;
-    }
-
-    // A predicate over a set of rows in the form of a subquery
-    // EXISTS and UNIQUE are common SQL forms of this operation.
-    message SetPredicate {
-      enum PredicateOp {
-        PREDICATE_OP_UNSPECIFIED = 0;
-        PREDICATE_OP_EXISTS = 1;
-        PREDICATE_OP_UNIQUE = 2;
-      }
-      // TODO: should allow expressions
-      PredicateOp predicate_op = 1;
-      Rel tuples = 2;
-    }
-
-    // A subquery comparison using ANY or ALL.
-    // Examples:
-    //
-    // SELECT *
-    // FROM t1
-    // WHERE x < ANY(SELECT y from t2)
-    message SetComparison {
-      enum ComparisonOp {
-        COMPARISON_OP_UNSPECIFIED = 0;
-        COMPARISON_OP_EQ = 1;
-        COMPARISON_OP_NE = 2;
-        COMPARISON_OP_LT = 3;
-        COMPARISON_OP_GT = 4;
-        COMPARISON_OP_LE = 5;
-        COMPARISON_OP_GE = 6;
-      }
-
-      enum ReductionOp {
-        REDUCTION_OP_UNSPECIFIED = 0;
-        REDUCTION_OP_ANY = 1;
-        REDUCTION_OP_ALL = 2;
-      }
-
-      // ANY or ALL
-      ReductionOp reduction_op = 1;
-      // A comparison operator
-      ComparisonOp comparison_op = 2;
-      // left side of the expression
-      Expression left = 3;
-      // right side of the expression
-      Rel right = 4;
-    }
-  }
-}
-
-// The description of a field to sort on (including the direction of sorting and null semantics)
-message SortField {
-  Expression expr = 1;
-
-  oneof sort_kind {
-    SortDirection direction = 2;
-    uint32 comparison_function_reference = 3;
-  }
-  enum SortDirection {
-    SORT_DIRECTION_UNSPECIFIED = 0;
-    SORT_DIRECTION_ASC_NULLS_FIRST = 1;
-    SORT_DIRECTION_ASC_NULLS_LAST = 2;
-    SORT_DIRECTION_DESC_NULLS_FIRST = 3;
-    SORT_DIRECTION_DESC_NULLS_LAST = 4;
-    SORT_DIRECTION_CLUSTERED = 5;
-  }
-}
-
-// Describes which part of an aggregation or window function to perform within
-// the context of distributed algorithms.
-enum AggregationPhase {
-  // Implies `INTERMEDIATE_TO_RESULT`.
-  AGGREGATION_PHASE_UNSPECIFIED = 0;
-
-  // Specifies that the function should be run only up to the point of
-  // generating an intermediate value, to be further aggregated later using
-  // INTERMEDIATE_TO_INTERMEDIATE or INTERMEDIATE_TO_RESULT.
-  AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE = 1;
-
-  // Specifies that the inputs of the aggregate or window function are the
-  // intermediate values of the function, and that the output should also be
-  // an intermediate value, to be further aggregated later using
-  // INTERMEDIATE_TO_INTERMEDIATE or INTERMEDIATE_TO_RESULT.
-  AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE = 2;
-
-  // A complete invocation: the function should aggregate the given set of
-  // inputs to yield a single return value. This style must be used for
-  // aggregate or window functions that are not decomposable.
-  AGGREGATION_PHASE_INITIAL_TO_RESULT = 3;
-
-  // Specifies that the inputs of the aggregate or window function are the
-  // intermediate values of the function, generated previously using
-  // INITIAL_TO_INTERMEDIATE and possibly INTERMEDIATE_TO_INTERMEDIATE calls.
-  // This call should combine the intermediate values to yield the final
-  // return value.
-  AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT = 4;
-}
-
-// An aggregate function.
-message AggregateFunction {
-  // Points to a function_anchor defined in this plan, which must refer
-  // to an aggregate function in the associated YAML file. Required; 0 is
-  // considered to be a valid anchor/reference.
-  uint32 function_reference = 1;
-
-  // The arguments to be bound to the function. This must have exactly the
-  // number of arguments specified in the function definition, and the
-  // argument types must also match exactly:
-  //
-  //  - Value arguments must be bound using FunctionArgument.value, and
-  //    the expression in that must yield a value of a type that a function
-  //    overload is defined for.
-  //  - Type arguments must be bound using FunctionArgument.type, and a
-  //    function overload must be defined for that type.
-  //  - Enum arguments must be bound using FunctionArgument.enum
-  //    followed by Enum.specified, with a string that case-insensitively
-  //    matches one of the allowed options.
-  //  - Optional enum arguments must be bound using FunctionArgument.enum
-  //    followed by either Enum.specified or Enum.unspecified. If specified,
-  //    the string must case-insensitively match one of the allowed options.
-  repeated FunctionArgument arguments = 7;
-
-  // Options to specify behavior for corner cases, or leave behavior
-  // unspecified if the consumer does not need specific behavior in these
-  // cases.
-  repeated FunctionOption options = 8;
-
-  // Must be set to the return type of the function, exactly as derived
-  // using the declaration in the extension.
-  Type output_type = 5;
-
-  // Describes which part of the aggregation to perform within the context of
-  // distributed algorithms. Required. Must be set to INITIAL_TO_RESULT for
-  // aggregate functions that are not decomposable.
-  AggregationPhase phase = 4;
-
-  // If specified, the aggregated records are ordered according to this list
-  // before they are aggregated. The first sort field has the highest
-  // priority; only if a sort field determines two records to be equivalent is
-  // the next field queried. This field is optional.
-  repeated SortField sorts = 3;
-
-  // Specifies whether equivalent records are merged before being aggregated.
-  // Optional, defaults to AGGREGATION_INVOCATION_ALL.
-  AggregationInvocation invocation = 6;
-
-  // deprecated; use arguments instead
-  repeated Expression args = 2 [deprecated = true];
-
-  // Method in which equivalent records are merged before being aggregated.
-  enum AggregationInvocation {
-    // This default value implies AGGREGATION_INVOCATION_ALL.
-    AGGREGATION_INVOCATION_UNSPECIFIED = 0;
-
-    // Use all values in the aggregation calculation.
-    AGGREGATION_INVOCATION_ALL = 1;
-
-    // Use only distinct values in the aggregation calculation.
-    AGGREGATION_INVOCATION_DISTINCT = 2;
-  }
-
-  // This rel is used  to create references,
-  // in case we refer to a RelRoot field names will be ignored
-  message ReferenceRel {
-    int32 subtree_ordinal = 1;
-  }
-}
diff --git a/velox/substrait/proto/substrait/capabilities.proto b/velox/substrait/proto/substrait/capabilities.proto
deleted file mode 100644
index 351427189a7d..000000000000
--- a/velox/substrait/proto/substrait/capabilities.proto
+++ /dev/null
@@ -1,29 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait;
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-// Defines a set of Capabilities that a system (producer or consumer) supports.
-message Capabilities {
-  // List of Substrait versions this system supports
-  repeated string substrait_versions = 1;
-
-  // list of com.google.Any message types this system supports for advanced
-  // extensions.
-  repeated string advanced_extension_type_urls = 2;
-
-  // list of simple extensions this system supports.
-  repeated SimpleExtension simple_extensions = 3;
-
-  message SimpleExtension {
-    string uri = 1;
-    repeated string function_keys = 2;
-    repeated string type_keys = 3;
-    repeated string type_variation_keys = 4;
-  }
-}
diff --git a/velox/substrait/proto/substrait/extended_expression.proto b/velox/substrait/proto/substrait/extended_expression.proto
deleted file mode 100644
index 1c88b384edca..000000000000
--- a/velox/substrait/proto/substrait/extended_expression.proto
+++ /dev/null
@@ -1,51 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait;
-
-import "velox/substrait/proto/substrait/algebra.proto";
-import "velox/substrait/proto/substrait/extensions/extensions.proto";
-import "velox/substrait/proto/substrait/plan.proto";
-import "velox/substrait/proto/substrait/type.proto";
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-message ExpressionReference {
-  oneof expr_type {
-    Expression expression = 1;
-    AggregateFunction measure = 2;
-  }
-  // Field names in depth-first order
-  repeated string output_names = 3;
-}
-
-// Describe a set of operations to complete.
-// For compactness sake, identifiers are normalized at the plan level.
-message ExtendedExpression {
-  // Substrait version of the expression. Optional up to 0.17.0, required for later
-  // versions.
-  Version version = 7;
-
-  // a list of yaml specifications this expression may depend on
-  repeated substrait.extensions.SimpleExtensionURI extension_uris = 1;
-
-  // a list of extensions this expression may depend on
-  repeated substrait.extensions.SimpleExtensionDeclaration extensions = 2;
-
-  // one or more expression trees with same order in plan rel
-  repeated ExpressionReference referred_expr = 3;
-
-  NamedStruct base_schema = 4;
-  // additional extensions associated with this expression.
-  substrait.extensions.AdvancedExtension advanced_extensions = 5;
-
-  // A list of com.google.Any entities that this plan may use. Can be used to
-  // warn if some embedded message types are unknown. Note that this list may
-  // include message types that are ignorable (optimizations) or that are
-  // unused. In many cases, a consumer may be able to work with a plan even if
-  // one or more message types defined here are unknown.
-  repeated string expected_type_urls = 6;
-}
diff --git a/velox/substrait/proto/substrait/extensions/extensions.proto b/velox/substrait/proto/substrait/extensions/extensions.proto
deleted file mode 100644
index d3af5f3d9ed1..000000000000
--- a/velox/substrait/proto/substrait/extensions/extensions.proto
+++ /dev/null
@@ -1,81 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait.extensions;
-
-import "google/protobuf/any.proto";
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto/extensions";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-message SimpleExtensionURI {
-  // A surrogate key used in the context of a single plan used to reference the
-  // URI associated with an extension.
-  uint32 extension_uri_anchor = 1;
-
-  // The URI where this extension YAML can be retrieved. This is the "namespace"
-  // of this extension.
-  string uri = 2;
-}
-
-// Describes a mapping between a specific extension entity and the uri where
-// that extension can be found.
-message SimpleExtensionDeclaration {
-  oneof mapping_type {
-    ExtensionType extension_type = 1;
-    ExtensionTypeVariation extension_type_variation = 2;
-    ExtensionFunction extension_function = 3;
-  }
-
-  // Describes a Type
-  message ExtensionType {
-    // references the extension_uri_anchor defined for a specific extension URI.
-    uint32 extension_uri_reference = 1;
-
-    // A surrogate key used in the context of a single plan to reference a
-    // specific extension type
-    uint32 type_anchor = 2;
-
-    // the name of the type in the defined extension YAML.
-    string name = 3;
-  }
-
-  message ExtensionTypeVariation {
-    // references the extension_uri_anchor defined for a specific extension URI.
-    uint32 extension_uri_reference = 1;
-
-    // A surrogate key used in the context of a single plan to reference a
-    // specific type variation
-    uint32 type_variation_anchor = 2;
-
-    // the name of the type in the defined extension YAML.
-    string name = 3;
-  }
-
-  message ExtensionFunction {
-    // references the extension_uri_anchor defined for a specific extension URI.
-    uint32 extension_uri_reference = 1;
-
-    // A surrogate key used in the context of a single plan to reference a
-    // specific function
-    uint32 function_anchor = 2;
-
-    // A simple name if there is only one impl for the function within the YAML.
-    // A compound name, referencing that includes type short names if there is
-    // more than one impl per name in the YAML.
-    string name = 3;
-  }
-}
-
-// A generic object that can be used to embed additional extension information
-// into the serialized substrait plan.
-message AdvancedExtension {
-  // An optimization is helpful information that don't influence semantics. May
-  // be ignored by a consumer.
-  google.protobuf.Any optimization = 1;
-
-  // An enhancement alter semantics. Cannot be ignored by a consumer.
-  google.protobuf.Any enhancement = 2;
-}
diff --git a/velox/substrait/proto/substrait/function.proto b/velox/substrait/proto/substrait/function.proto
deleted file mode 100644
index 1fc0376f6625..000000000000
--- a/velox/substrait/proto/substrait/function.proto
+++ /dev/null
@@ -1,148 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait;
-
-import "velox/substrait/proto/substrait/parameterized_types.proto";
-import "velox/substrait/proto/substrait/type.proto";
-import "velox/substrait/proto/substrait/type_expressions.proto";
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-// List of function signatures available.
-message FunctionSignature {
-  message FinalArgVariadic {
-    // the minimum number of arguments allowed for the list of final arguments
-    // (inclusive).
-    int64 min_args = 1;
-
-    // the maximum number of arguments allowed for the list of final arguments
-    // (exclusive)
-    int64 max_args = 2;
-
-    // the type of parameterized type consistency
-    ParameterConsistency consistency = 3;
-
-    enum ParameterConsistency {
-      PARAMETER_CONSISTENCY_UNSPECIFIED = 0;
-
-      // All argument must be the same concrete type.
-      PARAMETER_CONSISTENCY_CONSISTENT = 1;
-
-      // Each argument can be any possible concrete type afforded by the bounds
-      // of any parameter defined in the arguments specification.
-      PARAMETER_CONSISTENCY_INCONSISTENT = 2;
-    }
-  }
-
-  message FinalArgNormal {}
-
-  message Scalar {
-    repeated Argument arguments = 2;
-    repeated string name = 3;
-    Description description = 4;
-
-    bool deterministic = 7;
-    bool session_dependent = 8;
-
-    DerivationExpression output_type = 9;
-
-    oneof final_variable_behavior {
-      FinalArgVariadic variadic = 10;
-      FinalArgNormal normal = 11;
-    }
-
-    repeated Implementation implementations = 12;
-  }
-
-  message Aggregate {
-    repeated Argument arguments = 2;
-    string name = 3;
-    Description description = 4;
-
-    bool deterministic = 7;
-    bool session_dependent = 8;
-
-    DerivationExpression output_type = 9;
-
-    oneof final_variable_behavior {
-      FinalArgVariadic variadic = 10;
-      FinalArgNormal normal = 11;
-    }
-
-    bool ordered = 14;
-    uint64 max_set = 12;
-    Type intermediate_type = 13;
-
-    repeated Implementation implementations = 15;
-  }
-
-  message Window {
-    repeated Argument arguments = 2;
-    repeated string name = 3;
-    Description description = 4;
-
-    bool deterministic = 7;
-    bool session_dependent = 8;
-
-    DerivationExpression intermediate_type = 9;
-    DerivationExpression output_type = 10;
-    oneof final_variable_behavior {
-      FinalArgVariadic variadic = 16;
-      FinalArgNormal normal = 17;
-    }
-    bool ordered = 11;
-    uint64 max_set = 12;
-    WindowType window_type = 14;
-    repeated Implementation implementations = 15;
-
-    enum WindowType {
-      WINDOW_TYPE_UNSPECIFIED = 0;
-      WINDOW_TYPE_STREAMING = 1;
-      WINDOW_TYPE_PARTITION = 2;
-    }
-  }
-
-  message Description {
-    string language = 1;
-    string body = 2;
-  }
-
-  message Implementation {
-    Type type = 1;
-    string uri = 2;
-
-    enum Type {
-      TYPE_UNSPECIFIED = 0;
-      TYPE_WEB_ASSEMBLY = 1;
-      TYPE_TRINO_JAR = 2;
-    }
-  }
-
-  message Argument {
-    string name = 1;
-
-    oneof argument_kind {
-      ValueArgument value = 2;
-      TypeArgument type = 3;
-      EnumArgument enum = 4;
-    }
-
-    message ValueArgument {
-      ParameterizedType type = 1;
-      bool constant = 2;
-    }
-
-    message TypeArgument {
-      ParameterizedType type = 1;
-    }
-
-    message EnumArgument {
-      repeated string options = 1;
-      bool optional = 2;
-    }
-  }
-}
diff --git a/velox/substrait/proto/substrait/parameterized_types.proto b/velox/substrait/proto/substrait/parameterized_types.proto
deleted file mode 100644
index 9408101c548e..000000000000
--- a/velox/substrait/proto/substrait/parameterized_types.proto
+++ /dev/null
@@ -1,128 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait;
-
-import "velox/substrait/proto/substrait/type.proto";
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-message ParameterizedType {
-  oneof kind {
-    Type.Boolean bool = 1;
-    Type.I8 i8 = 2;
-    Type.I16 i16 = 3;
-    Type.I32 i32 = 5;
-    Type.I64 i64 = 7;
-    Type.FP32 fp32 = 10;
-    Type.FP64 fp64 = 11;
-    Type.String string = 12;
-    Type.Binary binary = 13;
-    Type.Timestamp timestamp = 14;
-    Type.Date date = 16;
-    Type.Time time = 17;
-    Type.IntervalYear interval_year = 19;
-    Type.IntervalDay interval_day = 20;
-    Type.TimestampTZ timestamp_tz = 29;
-    Type.UUID uuid = 32;
-
-    ParameterizedFixedChar fixed_char = 21;
-    ParameterizedVarChar varchar = 22;
-    ParameterizedFixedBinary fixed_binary = 23;
-    ParameterizedDecimal decimal = 24;
-
-    ParameterizedStruct struct = 25;
-    ParameterizedList list = 27;
-    ParameterizedMap map = 28;
-
-    ParameterizedUserDefined user_defined = 30;
-
-    // Deprecated in favor of user_defined, which allows nullability and
-    // variations to be specified. If user_defined_pointer is encountered,
-    // treat it as being non-nullable and having the default variation.
-    uint32 user_defined_pointer = 31 [deprecated = true];
-
-    TypeParameter type_parameter = 33;
-  }
-
-  message TypeParameter {
-    string name = 1;
-    repeated ParameterizedType bounds = 2;
-  }
-
-  message IntegerParameter {
-    string name = 1;
-    NullableInteger range_start_inclusive = 2;
-    NullableInteger range_end_exclusive = 3;
-  }
-
-  message NullableInteger {
-    int64 value = 1;
-  }
-
-  message ParameterizedFixedChar {
-    IntegerOption length = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ParameterizedVarChar {
-    IntegerOption length = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ParameterizedFixedBinary {
-    IntegerOption length = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ParameterizedDecimal {
-    IntegerOption scale = 1;
-    IntegerOption precision = 2;
-    uint32 variation_pointer = 3;
-    Type.Nullability nullability = 4;
-  }
-
-  message ParameterizedStruct {
-    repeated ParameterizedType types = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ParameterizedNamedStruct {
-    // list of names in dfs order
-    repeated string names = 1;
-    ParameterizedStruct struct = 2;
-  }
-
-  message ParameterizedList {
-    ParameterizedType type = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ParameterizedMap {
-    ParameterizedType key = 1;
-    ParameterizedType value = 2;
-    uint32 variation_pointer = 3;
-    Type.Nullability nullability = 4;
-  }
-
-  message ParameterizedUserDefined {
-    uint32 type_pointer = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message IntegerOption {
-    oneof integer_type {
-      int32 literal = 1;
-      IntegerParameter parameter = 2;
-    }
-  }
-}
diff --git a/velox/substrait/proto/substrait/plan.proto b/velox/substrait/proto/substrait/plan.proto
deleted file mode 100644
index 71590a63b531..000000000000
--- a/velox/substrait/proto/substrait/plan.proto
+++ /dev/null
@@ -1,82 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait;
-
-import "velox/substrait/proto/substrait/algebra.proto";
-import "velox/substrait/proto/substrait/extensions/extensions.proto";
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-// Either a relation or root relation
-message PlanRel {
-  oneof rel_type {
-    // Any relation (used for references and CTEs)
-    Rel rel = 1;
-    // The root of a relation tree
-    RelRoot root = 2;
-  }
-}
-
-// Describe a set of operations to complete.
-// For compactness sake, identifiers are normalized at the plan level.
-message Plan {
-  // Substrait version of the plan. Optional up to 0.17.0, required for later
-  // versions.
-  Version version = 6;
-
-  // a list of yaml specifications this plan may depend on
-  repeated substrait.extensions.SimpleExtensionURI extension_uris = 1;
-
-  // a list of extensions this plan may depend on
-  repeated substrait.extensions.SimpleExtensionDeclaration extensions = 2;
-
-  // one or more relation trees that are associated with this plan.
-  repeated PlanRel relations = 3;
-
-  // additional extensions associated with this plan.
-  substrait.extensions.AdvancedExtension advanced_extensions = 4;
-
-  // A list of com.google.Any entities that this plan may use. Can be used to
-  // warn if some embedded message types are unknown. Note that this list may
-  // include message types that are ignorable (optimizations) or that are
-  // unused. In many cases, a consumer may be able to work with a plan even if
-  // one or more message types defined here are unknown.
-  repeated string expected_type_urls = 5;
-}
-
-// This message type can be used to deserialize only the version of a Substrait
-// Plan message. This prevents deserialization errors when there were breaking
-// changes between the Substrait version of the tool that produced the plan and
-// the Substrait version used to deserialize it, such that a consumer can emit
-// a more helpful error message in this case.
-message PlanVersion {
-  Version version = 6;
-}
-
-message Version {
-  // Substrait version number.
-  uint32 major_number = 1;
-  uint32 minor_number = 2;
-  uint32 patch_number = 3;
-
-  // If a particular version of Substrait is used that does not correspond to
-  // a version number exactly (for example when using an unofficial fork or
-  // using a version that is not yet released or is between versions), set this
-  // to the full git hash of the utilized commit of
-  // https://github.com/substrait-io/substrait (or fork thereof), represented
-  // using a lowercase hex ASCII string 40 characters in length. The version
-  // number above should be set to the most recent version tag in the history
-  // of that commit.
-  string git_hash = 4;
-
-  // Identifying information for the producer that created this plan. Under
-  // ideal circumstances, consumers should not need this information. However,
-  // it is foreseen that consumers may need to work around bugs in particular
-  // producers in practice, and therefore may need to know which producer
-  // created the plan.
-  string producer = 5;
-}
diff --git a/velox/substrait/proto/substrait/type.proto b/velox/substrait/proto/substrait/type.proto
deleted file mode 100644
index a7f1c665db30..000000000000
--- a/velox/substrait/proto/substrait/type.proto
+++ /dev/null
@@ -1,229 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait;
-
-import "google/protobuf/empty.proto";
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-message Type {
-  oneof kind {
-    Boolean bool = 1;
-    I8 i8 = 2;
-    I16 i16 = 3;
-    I32 i32 = 5;
-    I64 i64 = 7;
-    FP32 fp32 = 10;
-    FP64 fp64 = 11;
-    String string = 12;
-    Binary binary = 13;
-    Timestamp timestamp = 14;
-    Date date = 16;
-    Time time = 17;
-    IntervalYear interval_year = 19;
-    IntervalDay interval_day = 20;
-    TimestampTZ timestamp_tz = 29;
-    UUID uuid = 32;
-
-    FixedChar fixed_char = 21;
-    VarChar varchar = 22;
-    FixedBinary fixed_binary = 23;
-    Decimal decimal = 24;
-
-    Struct struct = 25;
-    List list = 27;
-    Map map = 28;
-
-    UserDefined user_defined = 30;
-
-    // Deprecated in favor of user_defined, which allows nullability and
-    // variations to be specified. If user_defined_type_reference is
-    // encountered, treat it as being non-nullable and having the default
-    // variation.
-    uint32 user_defined_type_reference = 31 [deprecated = true];
-  }
-
-  enum Nullability {
-    NULLABILITY_UNSPECIFIED = 0;
-    NULLABILITY_NULLABLE = 1;
-    NULLABILITY_REQUIRED = 2;
-  }
-
-  message Boolean {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message I8 {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message I16 {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message I32 {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message I64 {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message FP32 {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message FP64 {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message String {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message Binary {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message Timestamp {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message Date {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message Time {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message TimestampTZ {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message IntervalYear {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message IntervalDay {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  message UUID {
-    uint32 type_variation_reference = 1;
-    Nullability nullability = 2;
-  }
-
-  // Start compound types.
-  message FixedChar {
-    int32 length = 1;
-    uint32 type_variation_reference = 2;
-    Nullability nullability = 3;
-  }
-
-  message VarChar {
-    int32 length = 1;
-    uint32 type_variation_reference = 2;
-    Nullability nullability = 3;
-  }
-
-  message FixedBinary {
-    int32 length = 1;
-    uint32 type_variation_reference = 2;
-    Nullability nullability = 3;
-  }
-
-  message Decimal {
-    int32 scale = 1;
-    int32 precision = 2;
-    uint32 type_variation_reference = 3;
-    Nullability nullability = 4;
-  }
-
-  message Struct {
-    repeated Type types = 1;
-    uint32 type_variation_reference = 2;
-    Nullability nullability = 3;
-  }
-
-  message List {
-    Type type = 1;
-    uint32 type_variation_reference = 2;
-    Nullability nullability = 3;
-  }
-
-  message Map {
-    Type key = 1;
-    Type value = 2;
-    uint32 type_variation_reference = 3;
-    Nullability nullability = 4;
-  }
-
-  message UserDefined {
-    uint32 type_reference = 1;
-    uint32 type_variation_reference = 2;
-    Nullability nullability = 3;
-    repeated Parameter type_parameters = 4;
-  }
-
-  message Parameter {
-    oneof parameter {
-      // Explicitly null/unspecified parameter, to select the default value (if
-      // any).
-      google.protobuf.Empty null = 1;
-
-      // Data type parameters, like the i32 in LIST<i32>.
-      Type data_type = 2;
-
-      // Value parameters, like the 10 in VARCHAR<10>.
-      bool boolean = 3;
-      int64 integer = 4;
-      string enum = 5;
-      string string = 6;
-    }
-  }
-}
-
-// A message for modeling name/type pairs.
-//
-// Useful for representing relation schemas.
-//
-// Notes:
-//
-// * The names field is in depth-first order.
-//
-// For example a schema such as:
-//
-// a: int64
-// b: struct<c: float32, d: string>
-//
-// would have a `names` field that looks like:
-//
-// ["a", "b", "c", "d"]
-//
-// * Only struct fields are contained in this field's elements,
-// * Map keys should be traversed first, then values when producing/consuming
-message NamedStruct {
-  // list of names in dfs order
-  repeated string names = 1;
-  Type.Struct struct = 2;
-}
diff --git a/velox/substrait/proto/substrait/type_expressions.proto b/velox/substrait/proto/substrait/type_expressions.proto
deleted file mode 100644
index 59782d5230ff..000000000000
--- a/velox/substrait/proto/substrait/type_expressions.proto
+++ /dev/null
@@ -1,160 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-syntax = "proto3";
-
-package substrait;
-
-import "velox/substrait/proto/substrait/type.proto";
-
-option csharp_namespace = "Substrait.Protobuf";
-option go_package = "github.com/substrait-io/substrait-go/proto";
-option java_multiple_files = true;
-option java_package = "io.substrait.proto";
-
-message DerivationExpression {
-  oneof kind {
-    Type.Boolean bool = 1;
-    Type.I8 i8 = 2;
-    Type.I16 i16 = 3;
-    Type.I32 i32 = 5;
-    Type.I64 i64 = 7;
-    Type.FP32 fp32 = 10;
-    Type.FP64 fp64 = 11;
-    Type.String string = 12;
-    Type.Binary binary = 13;
-    Type.Timestamp timestamp = 14;
-    Type.Date date = 16;
-    Type.Time time = 17;
-    Type.IntervalYear interval_year = 19;
-    Type.IntervalDay interval_day = 20;
-    Type.TimestampTZ timestamp_tz = 29;
-    Type.UUID uuid = 32;
-
-    ExpressionFixedChar fixed_char = 21;
-    ExpressionVarChar varchar = 22;
-    ExpressionFixedBinary fixed_binary = 23;
-    ExpressionDecimal decimal = 24;
-
-    ExpressionStruct struct = 25;
-    ExpressionList list = 27;
-    ExpressionMap map = 28;
-
-    ExpressionUserDefined user_defined = 30;
-
-    // Deprecated in favor of user_defined, which allows nullability and
-    // variations to be specified. If user_defined_pointer is encountered,
-    // treat it as being non-nullable and having the default variation.
-    uint32 user_defined_pointer = 31 [deprecated = true];
-
-    string type_parameter_name = 33;
-    string integer_parameter_name = 34;
-
-    int32 integer_literal = 35;
-    UnaryOp unary_op = 36;
-    BinaryOp binary_op = 37;
-    IfElse if_else = 38;
-    ReturnProgram return_program = 39;
-  }
-
-  message ExpressionFixedChar {
-    DerivationExpression length = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ExpressionVarChar {
-    DerivationExpression length = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ExpressionFixedBinary {
-    DerivationExpression length = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ExpressionDecimal {
-    DerivationExpression scale = 1;
-    DerivationExpression precision = 2;
-    uint32 variation_pointer = 3;
-    Type.Nullability nullability = 4;
-  }
-
-  message ExpressionStruct {
-    repeated DerivationExpression types = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ExpressionNamedStruct {
-    repeated string names = 1;
-    ExpressionStruct struct = 2;
-  }
-
-  message ExpressionList {
-    DerivationExpression type = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message ExpressionMap {
-    DerivationExpression key = 1;
-    DerivationExpression value = 2;
-    uint32 variation_pointer = 3;
-    Type.Nullability nullability = 4;
-  }
-
-  message ExpressionUserDefined {
-    uint32 type_pointer = 1;
-    uint32 variation_pointer = 2;
-    Type.Nullability nullability = 3;
-  }
-
-  message IfElse {
-    DerivationExpression if_condition = 1;
-    DerivationExpression if_return = 2;
-    DerivationExpression else_return = 3;
-  }
-
-  message UnaryOp {
-    UnaryOpType op_type = 1;
-    DerivationExpression arg = 2;
-
-    enum UnaryOpType {
-      UNARY_OP_TYPE_UNSPECIFIED = 0;
-      UNARY_OP_TYPE_BOOLEAN_NOT = 1;
-    }
-  }
-
-  message BinaryOp {
-    BinaryOpType op_type = 1;
-    DerivationExpression arg1 = 2;
-    DerivationExpression arg2 = 3;
-
-    enum BinaryOpType {
-      BINARY_OP_TYPE_UNSPECIFIED = 0;
-      BINARY_OP_TYPE_PLUS = 1;
-      BINARY_OP_TYPE_MINUS = 2;
-      BINARY_OP_TYPE_MULTIPLY = 3;
-      BINARY_OP_TYPE_DIVIDE = 4;
-      BINARY_OP_TYPE_MIN = 5;
-      BINARY_OP_TYPE_MAX = 6;
-      BINARY_OP_TYPE_GREATER_THAN = 7;
-      BINARY_OP_TYPE_LESS_THAN = 8;
-      BINARY_OP_TYPE_AND = 9;
-      BINARY_OP_TYPE_OR = 10;
-      BINARY_OP_TYPE_EQUALS = 11;
-      BINARY_OP_TYPE_COVERS = 12;
-    }
-  }
-
-  message ReturnProgram {
-    message Assignment {
-      string name = 1;
-      DerivationExpression expression = 2;
-    }
-
-    repeated Assignment assignments = 1;
-    DerivationExpression final_expression = 2;
-  }
-}
diff --git a/velox/substrait/tests/CMakeLists.txt b/velox/substrait/tests/CMakeLists.txt
deleted file mode 100644
index b1ee68ebea7d..000000000000
--- a/velox/substrait/tests/CMakeLists.txt
+++ /dev/null
@@ -1,64 +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_plan_conversion_test
-  FunctionTest.cpp
-  JsonToProtoConverter.cpp
-  Substrait2VeloxPlanConversionTest.cpp
-  Substrait2VeloxValuesNodeConversionTest.cpp
-  SubstraitExtensionCollectorTest.cpp
-  VeloxSubstraitRoundTripTest.cpp
-  VeloxToSubstraitTypeTest.cpp
-  VeloxSubstraitSignatureTest.cpp)
-
-add_dependencies(velox_plan_conversion_test velox_substrait_plan_converter)
-
-add_test(
-  NAME velox_plan_conversion_test
-  COMMAND velox_plan_conversion_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-
-target_link_libraries(
-  velox_plan_conversion_test
-  velox_substrait_plan_converter
-  velox_functions_test_lib
-  velox_exec
-  velox_dwio_common
-  velox_aggregates
-  velox_functions_aggregates_test_lib
-  velox_functions_lib
-  velox_functions_prestosql
-  velox_hive_connector
-  velox_type
-  velox_serialization
-  velox_exec_test_lib
-  velox_functions_json
-  velox_vector
-  velox_memory
-  velox_dwio_common_exception
-  Boost::atomic
-  Boost::context
-  Boost::date_time
-  Boost::filesystem
-  Boost::program_options
-  Boost::regex
-  Boost::thread
-  Boost::system
-  GTest::gtest
-  GTest::gtest_main
-  Folly::folly
-  gflags::gflags
-  glog::glog
-  fmt::fmt)
diff --git a/velox/substrait/tests/FunctionTest.cpp b/velox/substrait/tests/FunctionTest.cpp
deleted file mode 100644
index 1f131f3dd478..000000000000
--- a/velox/substrait/tests/FunctionTest.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 "velox/substrait/tests/JsonToProtoConverter.h"
-
-#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"
-
-using namespace facebook::velox;
-using namespace facebook::velox::test;
-using namespace facebook::velox::substrait;
-namespace vestrait = facebook::velox::substrait;
-
-class FunctionTest : public ::testing::Test {
- protected:
-  static void SetUpTestCase() {
-    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
-  }
-
-  std::shared_ptr<core::QueryCtx> queryCtx_ = core::QueryCtx::create();
-
-  std::shared_ptr<memory::MemoryPool> pool_ =
-      memory::memoryManager()->addLeafPool();
-
-  std::shared_ptr<vestrait::SubstraitParser> substraitParser_ =
-      std::make_shared<vestrait::SubstraitParser>();
-
-  std::shared_ptr<vestrait::SubstraitVeloxPlanConverter> planConverter_ =
-      std::make_shared<vestrait::SubstraitVeloxPlanConverter>(pool_.get());
-};
-
-TEST_F(FunctionTest, makeNames) {
-  std::string prefix = "n";
-  int size = 0;
-  std::vector<std::string> names = substraitParser_->makeNames(prefix, size);
-  ASSERT_EQ(names.size(), size);
-
-  size = 5;
-  names = substraitParser_->makeNames(prefix, size);
-  ASSERT_EQ(names.size(), size);
-  for (int i = 0; i < size; i++) {
-    std::string expected = "n_" + std::to_string(i);
-    ASSERT_EQ(names[i], expected);
-  }
-}
-
-TEST_F(FunctionTest, makeNodeName) {
-  std::string nodeName = substraitParser_->makeNodeName(1, 0);
-  ASSERT_EQ(nodeName, "n1_0");
-}
-
-TEST_F(FunctionTest, getIdxFromNodeName) {
-  std::string nodeName = "n1_0";
-  int index = substraitParser_->getIdxFromNodeName(nodeName);
-  ASSERT_EQ(index, 0);
-}
-
-TEST_F(FunctionTest, getNameBeforeDelimiter) {
-  std::string functionSpec = "lte:fp64_fp64";
-  std::string_view funcName = getNameBeforeDelimiter(functionSpec, ":");
-  ASSERT_EQ(funcName, "lte");
-
-  functionSpec = "lte:";
-  funcName = getNameBeforeDelimiter(functionSpec, ":");
-  ASSERT_EQ(funcName, "lte");
-
-  functionSpec = "lte";
-  funcName = getNameBeforeDelimiter(functionSpec, ":");
-  ASSERT_EQ(funcName, "lte");
-}
-
-TEST_F(FunctionTest, constructFunctionMap) {
-  std::string planPath =
-      getDataFilePath("velox/substrait/tests", "data/q1_first_stage.json");
-  ::substrait::Plan substraitPlan;
-  JsonToProtoConverter::readFromFile(planPath, substraitPlan);
-  planConverter_->constructFunctionMap(substraitPlan);
-
-  auto functionMap = planConverter_->getFunctionMap();
-  ASSERT_EQ(functionMap.size(), 9);
-
-  std::string function = planConverter_->findFunction(1);
-  ASSERT_EQ(function, "lte:fp64_fp64");
-
-  function = planConverter_->findFunction(2);
-  ASSERT_EQ(function, "and:bool_bool");
-
-  function = planConverter_->findFunction(3);
-  ASSERT_EQ(function, "subtract:opt_fp64_fp64");
-
-  function = planConverter_->findFunction(4);
-  ASSERT_EQ(function, "multiply:opt_fp64_fp64");
-
-  function = planConverter_->findFunction(5);
-  ASSERT_EQ(function, "add:opt_fp64_fp64");
-
-  function = planConverter_->findFunction(6);
-  ASSERT_EQ(function, "sum:opt_fp64");
-
-  function = planConverter_->findFunction(7);
-  ASSERT_EQ(function, "count:opt_fp64");
-
-  function = planConverter_->findFunction(8);
-  ASSERT_EQ(function, "count:opt_i32");
-
-  function = planConverter_->findFunction(9);
-  ASSERT_EQ(function, "is_not_null:fp64");
-}
-
-TEST_F(FunctionTest, setVectorFromVariants) {
-  auto resultVec = setVectorFromVariants(
-      BOOLEAN(), {variant(false), variant(true)}, pool_.get());
-  ASSERT_EQ(false, resultVec->asFlatVector<bool>()->valueAt(0));
-  ASSERT_EQ(true, resultVec->asFlatVector<bool>()->valueAt(1));
-
-  auto min8 = std::numeric_limits<int8_t>::min();
-  auto max8 = std::numeric_limits<int8_t>::max();
-  resultVec = setVectorFromVariants(
-      TINYINT(), {variant(min8), variant(max8)}, pool_.get());
-  EXPECT_EQ(min8, resultVec->asFlatVector<int8_t>()->valueAt(0));
-  EXPECT_EQ(max8, resultVec->asFlatVector<int8_t>()->valueAt(1));
-
-  auto min16 = std::numeric_limits<int16_t>::min();
-  auto max16 = std::numeric_limits<int16_t>::max();
-  resultVec = setVectorFromVariants(
-      SMALLINT(), {variant(min16), variant(max16)}, pool_.get());
-  EXPECT_EQ(min16, resultVec->asFlatVector<int16_t>()->valueAt(0));
-  EXPECT_EQ(max16, resultVec->asFlatVector<int16_t>()->valueAt(1));
-
-  auto min32 = std::numeric_limits<int32_t>::min();
-  auto max32 = std::numeric_limits<int32_t>::max();
-  resultVec = setVectorFromVariants(
-      INTEGER(), {variant(min32), variant(max32)}, pool_.get());
-  EXPECT_EQ(min32, resultVec->asFlatVector<int32_t>()->valueAt(0));
-  EXPECT_EQ(max32, resultVec->asFlatVector<int32_t>()->valueAt(1));
-
-  auto min64 = std::numeric_limits<int64_t>::min();
-  auto max64 = std::numeric_limits<int64_t>::max();
-  resultVec = setVectorFromVariants(
-      BIGINT(), {variant(min64), variant(max64)}, pool_.get());
-  EXPECT_EQ(min64, resultVec->asFlatVector<int64_t>()->valueAt(0));
-  EXPECT_EQ(max64, resultVec->asFlatVector<int64_t>()->valueAt(1));
-
-  // Floats are harder to compare because of low-precision. Just making sure
-  // they don't throw.
-  EXPECT_NO_THROW(setVectorFromVariants(
-      REAL(), {variant(float(0.99L)), variant(float(-1.99L))}, pool_.get()));
-
-  resultVec = setVectorFromVariants(
-      DOUBLE(), {variant(double(0.99L)), variant(double(-1.99L))}, pool_.get());
-  ASSERT_EQ(double(0.99L), resultVec->asFlatVector<double>()->valueAt(0));
-  ASSERT_EQ(double(-1.99L), resultVec->asFlatVector<double>()->valueAt(1));
-
-  resultVec = setVectorFromVariants(
-      VARCHAR(), {variant(""), variant("asdf")}, pool_.get());
-  ASSERT_EQ("", resultVec->asFlatVector<StringView>()->valueAt(0).str());
-  ASSERT_EQ("asdf", resultVec->asFlatVector<StringView>()->valueAt(1).str());
-
-  ASSERT_ANY_THROW(setVectorFromVariants(
-      VARBINARY(), {variant(""), variant("asdf")}, pool_.get()));
-
-  resultVec = setVectorFromVariants(
-      TIMESTAMP(),
-      {variant(Timestamp(9020, 0)), variant(Timestamp(8875, 0))},
-      pool_.get());
-  ASSERT_EQ(
-      "1970-01-01T02:30:20.000000000",
-      resultVec->asFlatVector<Timestamp>()->valueAt(0).toString());
-  ASSERT_EQ(
-      "1970-01-01T02:27:55.000000000",
-      resultVec->asFlatVector<Timestamp>()->valueAt(1).toString());
-
-  resultVec = setVectorFromVariants(
-      DATE(), {variant(9020), variant(8875)}, pool_.get());
-  ASSERT_EQ(
-      "1994-09-12",
-      DATE()->toString(resultVec->asFlatVector<int32_t>()->valueAt(0)));
-  ASSERT_EQ(
-      "1994-04-20",
-      DATE()->toString(resultVec->asFlatVector<int32_t>()->valueAt(1)));
-
-  resultVec = setVectorFromVariants(
-      INTERVAL_DAY_TIME(), {variant(9020LL), variant(8875LL)}, pool_.get());
-  ASSERT_TRUE(resultVec->type()->isIntervalDayTime());
-  ASSERT_EQ(9020, resultVec->asFlatVector<int64_t>()->valueAt(0));
-  ASSERT_EQ(8875, resultVec->asFlatVector<int64_t>()->valueAt(1));
-
-  resultVec = setVectorFromVariants(
-      INTERVAL_YEAR_MONTH(), {variant(20), variant(30)}, pool_.get());
-  ASSERT_TRUE(resultVec->type()->isIntervalYearMonth());
-  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
deleted file mode 100644
index 26db710abce9..000000000000
--- a/velox/substrait/tests/JsonToProtoConverter.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 "velox/substrait/tests/JsonToProtoConverter.h"
-#include <fstream>
-#include <sstream>
-#include "velox/common/base/Exceptions.h"
-
-void JsonToProtoConverter::readFromFile(
-    const std::string& msgPath,
-    google::protobuf::Message& msg) {
-  // Read json file and resume the Substrait plan.
-  std::ifstream msgJson(msgPath);
-  VELOX_CHECK(
-      !msgJson.fail(), "Failed to open file: {}. {}", msgPath, strerror(errno));
-  std::stringstream buffer;
-  buffer << msgJson.rdbuf();
-  std::string msgData = buffer.str();
-  auto status = google::protobuf::util::JsonStringToMessage(msgData, &msg);
-  VELOX_CHECK(
-      status.ok(),
-      "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
deleted file mode 100644
index bc330463d465..000000000000
--- a/velox/substrait/tests/Substrait2VeloxPlanConversionTest.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 "velox/substrait/tests/JsonToProtoConverter.h"
-
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/dwio/common/tests/utils/DataFiles.h"
-#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 "velox/substrait/SubstraitToVeloxPlan.h"
-#include "velox/type/Type.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::test;
-using namespace facebook::velox::connector::hive;
-using namespace facebook::velox::exec;
-
-class Substrait2VeloxPlanConversionTest
-    : public exec::test::HiveConnectorTestBase {
- protected:
-  static void SetUpTestCase() {
-    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
-  }
-
-  std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
-  makeSplits(
-      const facebook::velox::substrait::SubstraitVeloxPlanConverter& converter,
-      std::shared_ptr<const core::PlanNode> planNode) {
-    const auto& splitInfos = converter.splitInfos();
-    auto leafPlanNodeIds = planNode->leafPlanNodeIds();
-    // Only one leaf node is expected here.
-    EXPECT_EQ(1, leafPlanNodeIds.size());
-    const auto& splitInfo = splitInfos.at(*leafPlanNodeIds.begin());
-
-    const auto& paths = splitInfo->paths;
-    const auto& starts = splitInfo->starts;
-    const auto& lengths = splitInfo->lengths;
-    const auto fileFormat = splitInfo->format;
-
-    std::vector<std::shared_ptr<facebook::velox::connector::ConnectorSplit>>
-        splits;
-    splits.reserve(paths.size());
-
-    for (int i = 0; i < paths.size(); 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)
-                       .fileFormat(fileFormat)
-                       .start(start)
-                       .length(length)
-                       .build();
-      splits.emplace_back(split);
-    }
-    return splits;
-  }
-
-  std::shared_ptr<exec::test::TempDirectoryPath> tmpDir_{
-      exec::test::TempDirectoryPath::create()};
-};
-
-// This test will firstly generate mock TPC-H lineitem ORC file. Then, Velox's
-// computing will be tested based on the generated ORC file.
-// Input: Json file of the Substrait plan for the below modified TPC-H Q6 query:
-//
-//  SELECT sum(l_extendedprice * l_discount) AS revenue
-//  FROM lineitem
-//  WHERE
-//    l_shipdate_new >= 8766 AND l_shipdate_new < 9131 AND
-//    l_discount BETWEEN .06 - 0.01 AND .06 + 0.01 AND
-//    l_quantity < 24
-//
-//  Tested Velox operators: TableScan (Filter Pushdown), Project, Aggregate.
-TEST_F(Substrait2VeloxPlanConversionTest, DISABLED_q6) {
-  // Generate the used ORC file.
-  auto type =
-      ROW({"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"},
-          {BIGINT(),
-           BIGINT(),
-           BIGINT(),
-           INTEGER(),
-           DOUBLE(),
-           DOUBLE(),
-           DOUBLE(),
-           DOUBLE(),
-           VARCHAR(),
-           VARCHAR(),
-           DOUBLE(),
-           DOUBLE(),
-           DOUBLE(),
-           VARCHAR(),
-           VARCHAR(),
-           VARCHAR()});
-  std::shared_ptr<memory::MemoryPool> pool{
-      memory::memoryManager()->addLeafPool()};
-  std::vector<VectorPtr> vectors;
-  // TPC-H lineitem table has 16 columns.
-  int colNum = 16;
-  vectors.reserve(colNum);
-  std::vector<int64_t> lOrderkeyData = {
-      4636438147,
-      2012485446,
-      1635327427,
-      8374290148,
-      2972204230,
-      8001568994,
-      989963396,
-      2142695974,
-      6354246853,
-      4141748419};
-  vectors.emplace_back(makeFlatVector<int64_t>(lOrderkeyData));
-  std::vector<int64_t> lPartkeyData = {
-      263222018,
-      255918298,
-      143549509,
-      96877642,
-      201976875,
-      196938305,
-      100260625,
-      273511608,
-      112999357,
-      299103530};
-  vectors.emplace_back(makeFlatVector<int64_t>(lPartkeyData));
-  std::vector<int64_t> lSuppkeyData = {
-      2102019,
-      13998315,
-      12989528,
-      4717643,
-      9976902,
-      12618306,
-      11940632,
-      871626,
-      1639379,
-      3423588};
-  vectors.emplace_back(makeFlatVector<int64_t>(lSuppkeyData));
-  std::vector<int32_t> lLinenumberData = {4, 6, 1, 5, 1, 2, 1, 5, 2, 6};
-  vectors.emplace_back(makeFlatVector<int32_t>(lLinenumberData));
-  std::vector<double> lQuantityData = {
-      6.0, 1.0, 19.0, 4.0, 6.0, 12.0, 23.0, 11.0, 16.0, 19.0};
-  vectors.emplace_back(makeFlatVector<double>(lQuantityData));
-  std::vector<double> lExtendedpriceData = {
-      30586.05,
-      7821.0,
-      1551.33,
-      30681.2,
-      1941.78,
-      66673.0,
-      6322.44,
-      41754.18,
-      8704.26,
-      63780.36};
-  vectors.emplace_back(makeFlatVector<double>(lExtendedpriceData));
-  std::vector<double> lDiscountData = {
-      0.05, 0.06, 0.01, 0.07, 0.05, 0.06, 0.07, 0.05, 0.06, 0.07};
-  vectors.emplace_back(makeFlatVector<double>(lDiscountData));
-  std::vector<double> lTaxData = {
-      0.02, 0.03, 0.01, 0.0, 0.01, 0.01, 0.03, 0.07, 0.01, 0.04};
-  vectors.emplace_back(makeFlatVector<double>(lTaxData));
-  std::vector<std::string> lReturnflagData = {
-      "N", "A", "A", "R", "A", "N", "A", "A", "N", "R"};
-  vectors.emplace_back(makeFlatVector<std::string>(lReturnflagData));
-  std::vector<std::string> lLinestatusData = {
-      "O", "F", "F", "F", "F", "O", "F", "F", "O", "F"};
-  vectors.emplace_back(makeFlatVector<std::string>(lLinestatusData));
-  std::vector<double> lShipdateNewData = {
-      8953.666666666666,
-      8773.666666666666,
-      9034.666666666666,
-      8558.666666666666,
-      9072.666666666666,
-      8864.666666666666,
-      9004.666666666666,
-      8778.666666666666,
-      9013.666666666666,
-      8832.666666666666};
-  vectors.emplace_back(makeFlatVector<double>(lShipdateNewData));
-  std::vector<double> lCommitdateNewData = {
-      10447.666666666666,
-      8953.666666666666,
-      8325.666666666666,
-      8527.666666666666,
-      8438.666666666666,
-      10049.666666666666,
-      9036.666666666666,
-      8666.666666666666,
-      9519.666666666666,
-      9138.666666666666};
-  vectors.emplace_back(makeFlatVector<double>(lCommitdateNewData));
-  std::vector<double> lReceiptdateNewData = {
-      10456.666666666666,
-      8979.666666666666,
-      8299.666666666666,
-      8474.666666666666,
-      8525.666666666666,
-      9996.666666666666,
-      9103.666666666666,
-      8726.666666666666,
-      9593.666666666666,
-      9178.666666666666};
-  vectors.emplace_back(makeFlatVector<double>(lReceiptdateNewData));
-  std::vector<std::string> lShipinstructData = {
-      "COLLECT COD",
-      "NONE",
-      "TAKE BACK RETURN",
-      "NONE",
-      "TAKE BACK RETURN",
-      "NONE",
-      "DELIVER IN PERSON",
-      "DELIVER IN PERSON",
-      "TAKE BACK RETURN",
-      "NONE"};
-  vectors.emplace_back(makeFlatVector<std::string>(lShipinstructData));
-  std::vector<std::string> lShipmodeData = {
-      "FOB",
-      "REG AIR",
-      "MAIL",
-      "FOB",
-      "RAIL",
-      "SHIP",
-      "REG AIR",
-      "REG AIR",
-      "TRUCK",
-      "AIR"};
-  vectors.emplace_back(makeFlatVector<std::string>(lShipmodeData));
-  std::vector<std::string> lCommentData = {
-      " the furiously final foxes. quickly final p",
-      "thely ironic",
-      "ate furiously. even, pending pinto bean",
-      "ackages af",
-      "odolites. slyl",
-      "ng the regular requests sleep above",
-      "lets above the slyly ironic theodolites sl",
-      "lyly regular excuses affi",
-      "lly unusual theodolites grow slyly above",
-      " the quickly ironic pains lose car"};
-  vectors.emplace_back(makeFlatVector<std::string>(lCommentData));
-
-  // Write data into an ORC file.
-  writeToFile(
-      tmpDir_->getPath() + "/mock_lineitem.orc",
-      {makeRowVector(type->names(), vectors)});
-
-  // Find and deserialize Substrait plan json file.
-  std::string planPath =
-      getDataFilePath("velox/substrait/tests", "data/q6_first_stage.json");
-
-  // Read q6_first_stage.json and resume the Substrait plan.
-  ::substrait::Plan substraitPlan;
-  JsonToProtoConverter::readFromFile(planPath, substraitPlan);
-
-  // Convert to Velox PlanNode.
-  facebook::velox::substrait::SubstraitVeloxPlanConverter planConverter(
-      pool_.get());
-  auto planNode = planConverter.toVeloxPlan(substraitPlan);
-
-  auto expectedResult = makeRowVector({
-      makeFlatVector<double>(1, [](auto /*row*/) { return 13613.1921; }),
-  });
-
-  exec::test::AssertQueryBuilder(planNode)
-      .splits(makeSplits(planConverter, planNode))
-      .assertResults(expectedResult);
-}
diff --git a/velox/substrait/tests/Substrait2VeloxValuesNodeConversionTest.cpp b/velox/substrait/tests/Substrait2VeloxValuesNodeConversionTest.cpp
deleted file mode 100644
index 45927a2e7a00..000000000000
--- a/velox/substrait/tests/Substrait2VeloxValuesNodeConversionTest.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 "velox/substrait/tests/JsonToProtoConverter.h"
-
-#include "velox/common/base/Fs.h"
-#include "velox/dwio/common/tests/utils/DataFiles.h"
-#include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/vector/tests/utils/VectorTestBase.h"
-
-#include "velox/substrait/SubstraitToVeloxPlan.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::test;
-using namespace facebook::velox::exec;
-using namespace facebook::velox::exec::test;
-using namespace facebook::velox::substrait;
-
-class Substrait2VeloxValuesNodeConversionTest : public OperatorTestBase {
- protected:
-  std::shared_ptr<SubstraitVeloxPlanConverter> planConverter_ =
-      std::make_shared<SubstraitVeloxPlanConverter>(pool_.get());
-};
-
-// SELECT * FROM tmp
-TEST_F(Substrait2VeloxValuesNodeConversionTest, valuesNode) {
-  auto planPath = getDataFilePath(
-      "velox/substrait/tests", "data/substrait_virtualTable.json");
-
-  ::substrait::Plan substraitPlan;
-  JsonToProtoConverter::readFromFile(planPath, substraitPlan);
-
-  auto veloxPlan = planConverter_->toVeloxPlan(substraitPlan);
-
-  RowVectorPtr expectedData = makeRowVector(
-      {makeFlatVector<int64_t>(
-           {2499109626526694126, 2342493223442167775, 4077358421272316858}),
-       makeFlatVector<int32_t>({581869302, -708632711, -133711905}),
-       makeFlatVector<double>(
-           {0.90579193414549275, 0.96886777112423139, 0.63235925003444637}),
-       makeFlatVector<bool>({true, false, false}),
-       makeFlatVector<int32_t>(3, nullptr, nullEvery(1))
-
-      });
-
-  createDuckDbTable({expectedData});
-  assertQuery(veloxPlan, "SELECT * FROM tmp");
-}
diff --git a/velox/substrait/tests/SubstraitExtensionCollectorTest.cpp b/velox/substrait/tests/SubstraitExtensionCollectorTest.cpp
deleted file mode 100644
index c339582e94ad..000000000000
--- a/velox/substrait/tests/SubstraitExtensionCollectorTest.cpp
+++ /dev/null
@@ -1,155 +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/substrait/SubstraitExtensionCollector.h"
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/core/PlanNode.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::substrait;
-
-namespace facebook::velox::substrait::test {
-
-class SubstraitExtensionCollectorTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    Test::SetUp();
-    functions::prestosql::registerAllScalarFunctions();
-  }
-
-  int getReferenceNumber(
-      const std::string& functionName,
-      std::vector<TypePtr>&& arguments) {
-    int referenceNumber1 =
-        extensionCollector_->getReferenceNumber(functionName, arguments);
-    // Repeat the call to make sure properly de-duplicated.
-    int referenceNumber2 =
-        extensionCollector_->getReferenceNumber(functionName, arguments);
-    EXPECT_EQ(referenceNumber1, referenceNumber2);
-    return referenceNumber1;
-  }
-
-  int getReferenceNumber(
-      const std::string& functionName,
-      std::vector<TypePtr>&& arguments,
-      core::AggregationNode::Step step) {
-    int referenceNumber1 =
-        extensionCollector_->getReferenceNumber(functionName, arguments, step);
-    // Repeat the call to make sure properly de-duplicated.
-    int referenceNumber2 =
-        extensionCollector_->getReferenceNumber(functionName, arguments, step);
-    EXPECT_EQ(referenceNumber1, referenceNumber2);
-    return referenceNumber2;
-  }
-
-  /// Given a substrait plan, return the sorted extension functions by the
-  /// function anchor.
-  ::google::protobuf::RepeatedPtrField<
-      ::substrait::extensions::SimpleExtensionDeclaration>
-  getSortedSubstraitExtension(const ::substrait::Plan* substraitPlan) {
-    auto substraitExtensions = substraitPlan->extensions();
-    std::sort(
-        substraitExtensions.begin(),
-        substraitExtensions.end(),
-        [](const auto& a, const auto& b) {
-          return a.extension_function().function_anchor() <
-              b.extension_function().function_anchor();
-        });
-
-    return substraitExtensions;
-  }
-
-  SubstraitExtensionCollectorPtr extensionCollector_ =
-      std::make_shared<SubstraitExtensionCollector>();
-};
-
-TEST_F(SubstraitExtensionCollectorTest, getReferenceNumberForScalarFunction) {
-  ASSERT_EQ(getReferenceNumber("plus", {INTEGER(), INTEGER()}), 0);
-  ASSERT_EQ(getReferenceNumber("divide", {INTEGER(), INTEGER()}), 1);
-  ASSERT_EQ(getReferenceNumber("cardinality", {ARRAY(INTEGER())}), 2);
-  ASSERT_EQ(getReferenceNumber("array_sum", {ARRAY(INTEGER())}), 3);
-
-  auto functionType = std::make_shared<const FunctionType>(
-      std::vector<TypePtr>{INTEGER(), VARCHAR()}, BIGINT());
-  std::vector<TypePtr> types = {MAP(INTEGER(), VARCHAR()), functionType};
-  ASSERT_ANY_THROW(getReferenceNumber("transform_keys", std::move(types)));
-}
-
-TEST_F(
-    SubstraitExtensionCollectorTest,
-    getReferenceNumberForAggregateFunction) {
-  // Sum aggregate function have same argument type for each aggregation step.
-  ASSERT_EQ(
-      getReferenceNumber(
-          "sum", {INTEGER()}, core::AggregationNode::Step::kSingle),
-      0);
-
-  // Partial avg aggregate function should use primitive integral type.
-  ASSERT_EQ(
-      getReferenceNumber(
-          "avg", {INTEGER()}, core::AggregationNode::Step::kPartial),
-      1);
-
-  // Final avg aggregate function should use struct type, like
-  // 'ROW<DOUBLE,BIGINT>'
-  ASSERT_EQ(
-      getReferenceNumber(
-          "avg",
-          {ROW({DOUBLE(), BIGINT()})},
-          core::AggregationNode::Step::kFinal),
-      2);
-
-  // Count aggregate function have same argument type for each aggregation step.
-  ASSERT_EQ(
-      getReferenceNumber(
-          "count", {INTEGER()}, core::AggregationNode::Step::kFinal),
-      3);
-}
-
-TEST_F(SubstraitExtensionCollectorTest, addExtensionsToPlan) {
-  getReferenceNumber("plus", {INTEGER(), INTEGER()});
-  getReferenceNumber("divide", {INTEGER(), INTEGER()});
-  getReferenceNumber("cardinality", {ARRAY(INTEGER())});
-  getReferenceNumber("array_sum", {ARRAY(INTEGER())});
-  getReferenceNumber("sum", {INTEGER()});
-  getReferenceNumber("avg", {INTEGER()});
-  getReferenceNumber("avg", {ROW({DOUBLE(), BIGINT()})});
-  getReferenceNumber("count", {INTEGER()});
-
-  google::protobuf::Arena arena;
-  auto* substraitPlan =
-      google::protobuf::Arena::CreateMessage<::substrait::Plan>(&arena);
-
-  extensionCollector_->addExtensionsToPlan(substraitPlan);
-
-  const auto& substraitExtensions = getSortedSubstraitExtension(substraitPlan);
-  auto getFunctionName = [&](auto id) {
-    return substraitExtensions[id].extension_function().name();
-  };
-
-  ASSERT_EQ(substraitPlan->extensions().size(), 8);
-  ASSERT_EQ(getFunctionName(0), "plus:i32_i32");
-  ASSERT_EQ(getFunctionName(1), "divide:i32_i32");
-  ASSERT_EQ(getFunctionName(2), "cardinality:list");
-  ASSERT_EQ(getFunctionName(3), "array_sum:list");
-  ASSERT_EQ(getFunctionName(4), "sum:i32");
-  ASSERT_EQ(getFunctionName(5), "avg:i32");
-  ASSERT_EQ(getFunctionName(6), "avg:struct");
-  ASSERT_EQ(getFunctionName(7), "count:i32");
-}
-
-} // namespace facebook::velox::substrait::test
diff --git a/velox/substrait/tests/VeloxSubstraitRoundTripTest.cpp b/velox/substrait/tests/VeloxSubstraitRoundTripTest.cpp
deleted file mode 100644
index c7330b177b67..000000000000
--- a/velox/substrait/tests/VeloxSubstraitRoundTripTest.cpp
+++ /dev/null
@@ -1,513 +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 <folly/init/Init.h>
-
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/exec/tests/utils/OperatorTestBase.h"
-#include "velox/exec/tests/utils/PlanBuilder.h"
-#include "velox/vector/tests/utils/VectorMaker.h"
-
-#include "velox/substrait/SubstraitToVeloxPlan.h"
-#include "velox/substrait/VeloxToSubstraitPlan.h"
-
-#include "velox/substrait/VariantToVectorConverter.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::test;
-using namespace facebook::velox::exec;
-using namespace facebook::velox::exec::test;
-using namespace facebook::velox::substrait;
-
-class VeloxSubstraitRoundTripTest : public OperatorTestBase {
- protected:
-  /// Makes a vector of INTEGER type with 'size' RowVectorPtr.
-  /// @param size The number of RowVectorPtr.
-  /// @param childSize The number of columns for each row.
-  /// @param batchSize The batch Size of the data.
-  std::vector<RowVectorPtr>
-  makeVectors(int64_t size, int64_t childSize, int64_t batchSize) {
-    std::vector<RowVectorPtr> vectors;
-    std::mt19937 gen(std::mt19937::default_seed);
-    for (int i = 0; i < size; i++) {
-      std::vector<VectorPtr> children;
-      for (int j = 0; j < childSize; j++) {
-        children.emplace_back(makeFlatVector<int32_t>(
-            batchSize,
-            [&](auto /*row*/) {
-              return folly::Random::rand32(INT32_MAX / 4, INT32_MAX / 2, gen);
-            },
-            nullEvery(2)));
-      }
-
-      vectors.push_back(makeRowVector({children}));
-    }
-    return vectors;
-  }
-
-  void assertPlanConversion(
-      const std::shared_ptr<const core::PlanNode>& plan,
-      const std::string& duckDbSql) {
-    assertQuery(plan, duckDbSql);
-
-    // Convert Velox Plan to Substrait Plan.
-    google::protobuf::Arena arena;
-    auto substraitPlan = veloxConvertor_->toSubstrait(arena, plan);
-
-    // Convert Substrait Plan to the same Velox Plan.
-    auto samePlan = substraitConverter_->toVeloxPlan(substraitPlan);
-
-    // Assert velox again.
-    assertQuery(samePlan, duckDbSql);
-  }
-
-  void assertFailingPlanConversion(
-      const std::shared_ptr<const core::PlanNode>& plan,
-      const std::string& expectedErrorMessage) {
-    CursorParameters params;
-    params.planNode = plan;
-    VELOX_ASSERT_THROW(readCursor(params), expectedErrorMessage);
-
-    // Convert Velox Plan to Substrait Plan.
-    google::protobuf::Arena arena;
-    auto substraitPlan = veloxConvertor_->toSubstrait(arena, plan);
-
-    // Convert Substrait Plan to the same Velox Plan.
-    auto samePlan = substraitConverter_->toVeloxPlan(substraitPlan);
-
-    // Assert velox again.
-    params.planNode = samePlan;
-    VELOX_ASSERT_THROW(readCursor(params), expectedErrorMessage);
-  }
-
-  std::shared_ptr<VeloxToSubstraitPlanConvertor> veloxConvertor_ =
-      std::make_shared<VeloxToSubstraitPlanConvertor>();
-  std::shared_ptr<SubstraitVeloxPlanConverter> substraitConverter_ =
-      std::make_shared<SubstraitVeloxPlanConverter>(pool_.get());
-};
-
-TEST_F(VeloxSubstraitRoundTripTest, project) {
-  auto vectors = makeVectors(3, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan =
-      PlanBuilder().values(vectors).project({"c0 + c1", "c1 / c2"}).planNode();
-  assertPlanConversion(plan, "SELECT c0 + c1, c1 // c2 FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, cast) {
-  auto vectors = makeVectors(3, 4, 2);
-  createDuckDbTable(vectors);
-  // Cast int32 to int64.
-  auto plan =
-      PlanBuilder().values(vectors).project({"cast(c0 as bigint)"}).planNode();
-  assertPlanConversion(plan, "SELECT cast(c0 as bigint) FROM tmp");
-
-  // Cast literal "abc" to int64 and allow cast failure, expecting no exception.
-  plan = PlanBuilder()
-             .values(vectors)
-             .project({"try_cast('abc' as bigint)"})
-             .planNode();
-  assertPlanConversion(plan, "SELECT try_cast('abc' as bigint) FROM tmp");
-
-  // Cast literal "abc" to int64, expecting an exception to be thrown.
-  plan = PlanBuilder()
-             .values(vectors)
-             .project({"cast('abc' as bigint)"})
-             .planNode();
-  assertFailingPlanConversion(plan, "Cannot cast VARCHAR 'abc' to BIGINT");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, filter) {
-  auto vectors = makeVectors(3, 4, 2);
-  createDuckDbTable(vectors);
-
-  auto plan = PlanBuilder().values(vectors).filter("c2 < 1000").planNode();
-  assertPlanConversion(plan, "SELECT * FROM tmp WHERE c2 < 1000");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, null) {
-  auto vectors = makeRowVector(ROW({}, {}), 1);
-  auto plan = PlanBuilder().values({vectors}).project({"NULL"}).planNode();
-  assertPlanConversion(plan, "SELECT NULL ");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, values) {
-  RowVectorPtr vectors = makeRowVector(
-      {makeFlatVector<int64_t>(
-           {2499109626526694126, 2342493223442167775, 4077358421272316858}),
-       makeFlatVector<int32_t>({581869302, -708632711, -133711905}),
-       makeFlatVector<double>(
-           {0.90579193414549275, 0.96886777112423139, 0.63235925003444637}),
-       makeFlatVector<bool>({true, false, false}),
-       makeFlatVector<int32_t>(3, nullptr, nullEvery(1))
-
-      });
-  createDuckDbTable({vectors});
-
-  auto plan = PlanBuilder().values({vectors}).planNode();
-
-  assertPlanConversion(plan, "SELECT * FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, count) {
-  auto vectors = makeVectors(2, 7, 3);
-  createDuckDbTable(vectors);
-
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .filter("c6 < 24")
-                  .singleAggregation({"c0", "c1"}, {"count(c4) as num_price"})
-                  .project({"num_price"})
-                  .planNode();
-
-  assertPlanConversion(
-      plan,
-      "SELECT count(c4) as num_price FROM tmp WHERE c6 < 24 GROUP BY c0, c1");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, countAll) {
-  auto vectors = makeVectors(2, 7, 3);
-  createDuckDbTable(vectors);
-
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .filter("c6 < 24")
-                  .singleAggregation({"c0", "c1"}, {"count(1) as num_price"})
-                  .project({"num_price"})
-                  .planNode();
-
-  assertPlanConversion(
-      plan,
-      "SELECT count(*) as num_price FROM tmp WHERE c6 < 24 GROUP BY c0, c1");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, sum) {
-  auto vectors = makeVectors(2, 7, 3);
-  createDuckDbTable(vectors);
-
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .partialAggregation({}, {"sum(1)", "count(c4)"})
-                  .planNode();
-
-  assertPlanConversion(plan, "SELECT sum(1), count(c4) FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, sumAndCount) {
-  auto vectors = makeVectors(2, 7, 3);
-  createDuckDbTable(vectors);
-
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .partialAggregation({}, {"sum(c1)", "count(c4)"})
-                  .finalAggregation()
-                  .planNode();
-
-  assertPlanConversion(plan, "SELECT sum(c1), count(c4) FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, sumGlobal) {
-  auto vectors = makeVectors(2, 7, 3);
-  createDuckDbTable(vectors);
-
-  // Global final aggregation.
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .partialAggregation({"c0"}, {"sum(c0)", "sum(c1)"})
-                  .intermediateAggregation()
-                  .finalAggregation()
-                  .planNode();
-  assertPlanConversion(
-      plan, "SELECT c0, sum(c0), sum(c1) FROM tmp GROUP BY c0");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, sumMask) {
-  auto vectors = makeVectors(2, 7, 3);
-  createDuckDbTable(vectors);
-
-  auto plan =
-      PlanBuilder()
-          .values(vectors)
-          .project({"c0", "c1", "c2 % 2 < 10 AS m0", "c3 % 3 = 0 AS m1"})
-          .partialAggregation(
-              {}, {"sum(c0)", "sum(c0)", "sum(c1)"}, {"m0", "m1", "m1"})
-          .finalAggregation()
-          .planNode();
-
-  assertPlanConversion(
-      plan,
-      "SELECT sum(c0) FILTER (WHERE c2 % 2 < 10), "
-      "sum(c0) FILTER (WHERE c3 % 3 = 0), sum(c1) FILTER (WHERE c3 % 3 = 0) "
-      "FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, rowConstructor) {
-  RowVectorPtr vectors = makeRowVector(
-      {makeFlatVector<double_t>({0.905791934145, 0.968867771124}),
-       makeFlatVector<int64_t>({2499109626526694126, 2342493223442167775}),
-       makeFlatVector<int32_t>({581869302, -133711905})});
-  createDuckDbTable({vectors});
-
-  auto plan = PlanBuilder()
-                  .values({vectors})
-                  .project({"row_constructor(c1, c2)"})
-                  .planNode();
-  assertPlanConversion(plan, "SELECT row(c1, c2) FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, projectAs) {
-  RowVectorPtr vectors = makeRowVector(
-      {makeFlatVector<double_t>({0.905791934145, 0.968867771124}),
-       makeFlatVector<int64_t>({2499109626526694126, 2342493223442167775}),
-       makeFlatVector<int32_t>({581869302, -133711905})});
-  createDuckDbTable({vectors});
-
-  auto plan = PlanBuilder()
-                  .values({vectors})
-                  .filter("c0 < 0.5")
-                  .project({"c1 * c2 as revenue"})
-                  .partialAggregation({}, {"sum(revenue)"})
-                  .planNode();
-  assertPlanConversion(
-      plan, "SELECT sum(c1 * c2) as revenue FROM tmp WHERE c0 < 0.5");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, avg) {
-  auto vectors = makeVectors(2, 7, 3);
-  createDuckDbTable(vectors);
-
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .partialAggregation({}, {"avg(c4)"})
-                  .finalAggregation()
-                  .planNode();
-
-  assertPlanConversion(plan, "SELECT avg(c4) FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, caseWhen) {
-  auto vectors = makeVectors(3, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan =
-      PlanBuilder()
-          .values(vectors)
-          .project(
-              {"case when c0=1 then c1 when c0=2 then c2 else c3  end as x"})
-          .planNode();
-
-  assertPlanConversion(
-      plan,
-      "SELECT case when c0=1 then c1 when c0=2 then c2 else c3 end as x FROM tmp");
-
-  // Switch expression without else.
-  plan = PlanBuilder()
-             .values(vectors)
-             .project({"case when c0=1 then c1 when c0=2 then c2 end as x"})
-             .planNode();
-  assertPlanConversion(
-      plan,
-      "SELECT case when c0=1 then c1 when c0=2 then c2  end as x FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, ifThen) {
-  auto vectors = makeVectors(3, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .project({"if (c0=1, c0 + 1, c1 + 2) as x"})
-                  .planNode();
-  assertPlanConversion(plan, "SELECT if (c0=1, c0 + 1, c1 + 2) as x FROM tmp");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, orderBySingleKey) {
-  auto vectors = makeVectors(10, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .orderBy({"c0 DESC NULLS LAST"}, false)
-                  .planNode();
-  assertPlanConversion(plan, "SELECT * FROM tmp ORDER BY c0 DESC NULLS LAST");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, orderBy) {
-  auto vectors = makeVectors(10, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .orderBy({"c0 ASC NULLS FIRST", "c1 ASC NULLS LAST"}, false)
-                  .planNode();
-  assertPlanConversion(
-      plan, "SELECT * FROM tmp ORDER BY c0 NULLS FIRST, c1 NULLS LAST");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, limit) {
-  auto vectors = makeVectors(10, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan = PlanBuilder().values(vectors).limit(0, 10, false).planNode();
-  assertPlanConversion(plan, "SELECT * FROM tmp LIMIT 10");
-
-  // With offset.
-  plan = PlanBuilder().values(vectors).limit(5, 10, false).planNode();
-  assertPlanConversion(plan, "SELECT * FROM tmp OFFSET 5 LIMIT 10");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, topN) {
-  auto vectors = makeVectors(10, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .topN({"c0 NULLS FIRST"}, 10, false)
-                  .planNode();
-  assertPlanConversion(
-      plan, "SELECT * FROM tmp ORDER BY c0 NULLS FIRST LIMIT 10");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, topNFilter) {
-  auto vectors = makeVectors(10, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .filter("c0 > 15")
-                  .topN({"c0 DESC NULLS FIRST"}, 10, false)
-                  .planNode();
-  assertPlanConversion(
-      plan,
-      "SELECT * FROM tmp WHERE c0 > 15 ORDER BY c0 DESC NULLS FIRST LIMIT 10");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, topNTwoKeys) {
-  auto vectors = makeVectors(10, 4, 2);
-  createDuckDbTable(vectors);
-  auto plan = PlanBuilder()
-                  .values(vectors)
-                  .filter("c0 > 15")
-                  .topN({"c0 NULLS FIRST", "c1 DESC NULLS LAST"}, 10, false)
-                  .planNode();
-  assertPlanConversion(
-      plan,
-      "SELECT * FROM tmp WHERE c0 > 15 ORDER BY c0 NULLS FIRST, c1 DESC NULLS LAST LIMIT 10");
-}
-
-namespace {
-core::TypedExprPtr makeConstantExpr(const TypePtr& type, const variant& value) {
-  return std::make_shared<const core::ConstantTypedExpr>(type, value);
-}
-
-core::TypedExprPtr makeConstantExpr(const VectorPtr& vector) {
-  return std::make_shared<const core::ConstantTypedExpr>(
-      BaseVector::wrapInConstant(1, 0, vector));
-}
-} // namespace
-
-TEST_F(VeloxSubstraitRoundTripTest, notNullLiteral) {
-  auto vectors = makeRowVector(ROW({}, {}), 1);
-  auto plan = PlanBuilder(pool_.get())
-                  .values({vectors})
-                  .addNode([&](std::string id, core::PlanNodePtr input) {
-                    std::vector<std::string> projectNames = {
-                        "a", "b", "c", "d", "e", "f", "g", "h"};
-                    std::vector<core::TypedExprPtr> projectExpressions = {
-                        makeConstantExpr(BOOLEAN(), (bool)1),
-                        makeConstantExpr(TINYINT(), (int8_t)23),
-                        makeConstantExpr(SMALLINT(), (int16_t)45),
-                        makeConstantExpr(INTEGER(), (int32_t)678),
-                        makeConstantExpr(BIGINT(), (int64_t)910),
-                        makeConstantExpr(REAL(), (float)1.23),
-                        makeConstantExpr(DOUBLE(), (double)4.56),
-                        makeConstantExpr(VARCHAR(), "789")};
-                    return std::make_shared<core::ProjectNode>(
-                        id,
-                        std::move(projectNames),
-                        std::move(projectExpressions),
-                        input);
-                  })
-                  .planNode();
-  assertPlanConversion(
-      plan, "SELECT true, 23, 45, 678, 910, 1.23, 4.56, '789'");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, arrayLiteral) {
-  auto vectors = makeRowVector(ROW({}), 1);
-  auto plan =
-      PlanBuilder(pool_.get())
-          .values({vectors})
-          .addNode([&](std::string id, core::PlanNodePtr input) {
-            std::vector<core::TypedExprPtr> expressions = {
-                makeConstantExpr(
-                    makeNullableArrayVector<bool>({{true, std::nullopt}})),
-                makeConstantExpr(
-                    makeNullableArrayVector<int8_t>({{0, std::nullopt}})),
-                makeConstantExpr(
-                    makeNullableArrayVector<int16_t>({{1, std::nullopt}})),
-                makeConstantExpr(
-                    makeNullableArrayVector<int32_t>({{2, std::nullopt}})),
-                makeConstantExpr(
-                    makeNullableArrayVector<int64_t>({{3, std::nullopt}})),
-                makeConstantExpr(
-                    makeNullableArrayVector<float>({{4.4, std::nullopt}})),
-                makeConstantExpr(
-                    makeNullableArrayVector<double>({{5.5, std::nullopt}})),
-                makeConstantExpr(
-                    makeArrayVector<StringView>({{StringView("6")}})),
-                makeConstantExpr(makeArrayVector<Timestamp>(
-                    {{Timestamp(123'456, 123'000)}})),
-                makeConstantExpr(makeArrayVector<int32_t>({{8035}}, DATE())),
-                makeConstantExpr(makeArrayVector<int64_t>(
-                    {{54 * 1000}}, INTERVAL_DAY_TIME())),
-                makeConstantExpr(makeArrayVector<int64_t>({{}})),
-                // Nested array: [[1, 2, 3], [4, 5]]
-                makeConstantExpr(makeArrayVector(
-                    {0}, makeArrayVector<int64_t>({{1, 2, 3}, {4, 5}}))),
-            };
-            std::vector<std::string> names(expressions.size());
-            for (auto i = 0; i < names.size(); ++i) {
-              names[i] = fmt::format("e{}", i);
-            }
-            return std::make_shared<core::ProjectNode>(
-                id, std::move(names), std::move(expressions), input);
-          })
-          .planNode();
-  assertPlanConversion(
-      plan,
-      "SELECT array[true, null], array[0, null], array[1, null], "
-      "array[2, null], array[3, null], array[4.4, null], array[5.5, null], "
-      "array['6'],"
-      "array['1970-01-02T10:17:36.000123000'::TIMESTAMP],"
-      "array['1992-01-01'::DATE],"
-      "array[INTERVAL 54 MILLISECONDS], "
-      "array[], array[array[1,2,3], array[4,5]]");
-}
-
-TEST_F(VeloxSubstraitRoundTripTest, dateType) {
-  auto a = makeFlatVector<int32_t>({0, 1});
-  auto b = makeFlatVector<double_t>({0.3, 0.4});
-  auto c = makeFlatVector<int32_t>({8036, 8035}, DATE());
-
-  auto vectors = makeRowVector({"a", "b", "c"}, {a, b, c});
-  createDuckDbTable({vectors});
-
-  auto plan = PlanBuilder()
-                  .values({vectors})
-                  .filter({"c > DATE '1992-01-01'"})
-                  .planNode();
-  assertPlanConversion(plan, "SELECT * FROM tmp WHERE c > DATE '1992-01-01'");
-}
-
-int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
-  folly::Init init{&argc, &argv, false};
-  return RUN_ALL_TESTS();
-}
diff --git a/velox/substrait/tests/VeloxSubstraitSignatureTest.cpp b/velox/substrait/tests/VeloxSubstraitSignatureTest.cpp
deleted file mode 100644
index e8db267e2565..000000000000
--- a/velox/substrait/tests/VeloxSubstraitSignatureTest.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/substrait/VeloxSubstraitSignature.h"
-#include "velox/common/base/tests/GTestUtils.h"
-#include "velox/functions/prestosql/registration/RegistrationFunctions.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::substrait;
-
-namespace facebook::velox::substrait::test {
-
-class VeloxSubstraitSignatureTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    Test::SetUp();
-    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);
-  }
-
-  static std::string toSubstraitSignature(
-      const std::string& functionName,
-      const std::vector<TypePtr>& arguments) {
-    return VeloxSubstraitSignature::toSubstraitSignature(
-        functionName, arguments);
-  }
-};
-
-TEST_F(VeloxSubstraitSignatureTest, toSubstraitSignatureWithType) {
-  ASSERT_EQ(toSubstraitSignature(BOOLEAN()), "bool");
-
-  ASSERT_EQ(toSubstraitSignature(TINYINT()), "i8");
-  ASSERT_EQ(toSubstraitSignature(SMALLINT()), "i16");
-  ASSERT_EQ(toSubstraitSignature(INTEGER()), "i32");
-  ASSERT_EQ(toSubstraitSignature(BIGINT()), "i64");
-  ASSERT_EQ(toSubstraitSignature(REAL()), "fp32");
-  ASSERT_EQ(toSubstraitSignature(DOUBLE()), "fp64");
-  ASSERT_EQ(toSubstraitSignature(VARCHAR()), "str");
-  ASSERT_EQ(toSubstraitSignature(VARBINARY()), "vbin");
-  ASSERT_EQ(toSubstraitSignature(TIMESTAMP()), "ts");
-  ASSERT_EQ(toSubstraitSignature(DATE()), "date");
-  ASSERT_EQ(toSubstraitSignature(ARRAY(BOOLEAN())), "list");
-  ASSERT_EQ(toSubstraitSignature(ARRAY(INTEGER())), "list");
-  ASSERT_EQ(toSubstraitSignature(MAP(INTEGER(), BIGINT())), "map");
-  ASSERT_EQ(toSubstraitSignature(ROW({INTEGER(), BIGINT()})), "struct");
-  ASSERT_EQ(toSubstraitSignature(ROW({ARRAY(INTEGER())})), "struct");
-  ASSERT_EQ(toSubstraitSignature(ROW({MAP(INTEGER(), INTEGER())})), "struct");
-  ASSERT_EQ(toSubstraitSignature(ROW({ROW({INTEGER()})})), "struct");
-  ASSERT_EQ(toSubstraitSignature(UNKNOWN()), "u!name");
-}
-
-TEST_F(
-    VeloxSubstraitSignatureTest,
-    toSubstraitSignatureWithFunctionNameAndArguments) {
-  ASSERT_EQ(toSubstraitSignature("eq", {INTEGER(), INTEGER()}), "eq:i32_i32");
-  ASSERT_EQ(toSubstraitSignature("gt", {INTEGER(), INTEGER()}), "gt:i32_i32");
-  ASSERT_EQ(toSubstraitSignature("lt", {INTEGER(), INTEGER()}), "lt:i32_i32");
-  ASSERT_EQ(toSubstraitSignature("gte", {INTEGER(), INTEGER()}), "gte:i32_i32");
-  ASSERT_EQ(toSubstraitSignature("lte", {INTEGER(), INTEGER()}), "lte:i32_i32");
-
-  ASSERT_EQ(
-      toSubstraitSignature("and", {BOOLEAN(), BOOLEAN()}), "and:bool_bool");
-  ASSERT_EQ(toSubstraitSignature("or", {BOOLEAN(), BOOLEAN()}), "or:bool_bool");
-  ASSERT_EQ(toSubstraitSignature("not", {BOOLEAN()}), "not:bool");
-  ASSERT_EQ(
-      toSubstraitSignature("xor", {BOOLEAN(), BOOLEAN()}), "xor:bool_bool");
-
-  ASSERT_EQ(
-      toSubstraitSignature("between", {INTEGER(), INTEGER(), INTEGER()}),
-      "between:i32_i32_i32");
-
-  ASSERT_EQ(
-      toSubstraitSignature("plus", {INTEGER(), INTEGER()}), "plus:i32_i32");
-  ASSERT_EQ(
-      toSubstraitSignature("divide", {INTEGER(), INTEGER()}), "divide:i32_i32");
-
-  ASSERT_EQ(
-      toSubstraitSignature("cardinality", {ARRAY(INTEGER())}),
-      "cardinality:list");
-  ASSERT_EQ(
-      toSubstraitSignature("array_sum", {ARRAY(INTEGER())}), "array_sum:list");
-
-  ASSERT_EQ(toSubstraitSignature("sum", {INTEGER()}), "sum:i32");
-  ASSERT_EQ(toSubstraitSignature("avg", {INTEGER()}), "avg:i32");
-  ASSERT_EQ(toSubstraitSignature("count", {INTEGER()}), "count:i32");
-
-  auto functionType = std::make_shared<const FunctionType>(
-      std::vector<TypePtr>{INTEGER(), VARCHAR()}, BIGINT());
-  std::vector<TypePtr> types = {MAP(INTEGER(), VARCHAR()), functionType};
-  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
deleted file mode 100644
index 2e0e36fe4b10..000000000000
--- a/velox/substrait/tests/VeloxToSubstraitTypeTest.cpp
+++ /dev/null
@@ -1,70 +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/substrait/SubstraitParser.h"
-#include "velox/substrait/TypeUtils.h"
-#include "velox/substrait/VeloxToSubstraitType.h"
-
-using namespace facebook::velox;
-using namespace facebook::velox::substrait;
-
-namespace facebook::velox::substrait::test {
-
-class VeloxToSubstraitTypeTest : public ::testing::Test {
- protected:
-  void testTypeConversion(const TypePtr& type) {
-    SCOPED_TRACE(type->toString());
-
-    google::protobuf::Arena arena;
-    auto substraitType = typeConvertor_->toSubstraitType(arena, type);
-    auto sameType = substraitParser_->parseType(substraitType);
-    ASSERT_TRUE(sameType->kindEquals(type))
-        << "Expected: " << type->toString()
-        << ", but got: " << sameType->toString();
-  }
-
-  std::shared_ptr<VeloxToSubstraitTypeConvertor> typeConvertor_;
-
-  std::shared_ptr<SubstraitParser> substraitParser_ =
-      std::make_shared<SubstraitParser>();
-};
-
-TEST_F(VeloxToSubstraitTypeTest, basic) {
-  testTypeConversion(BOOLEAN());
-
-  testTypeConversion(TINYINT());
-  testTypeConversion(SMALLINT());
-  testTypeConversion(INTEGER());
-  testTypeConversion(BIGINT());
-
-  testTypeConversion(REAL());
-  testTypeConversion(DOUBLE());
-
-  testTypeConversion(VARCHAR());
-  testTypeConversion(VARBINARY());
-
-  testTypeConversion(ARRAY(BIGINT()));
-  testTypeConversion(MAP(BIGINT(), DOUBLE()));
-
-  testTypeConversion(ROW({"a", "b", "c"}, {BIGINT(), BOOLEAN(), VARCHAR()}));
-  testTypeConversion(
-      ROW({"a", "b", "c"},
-          {BIGINT(), ROW({"x", "y"}, {BOOLEAN(), VARCHAR()}), REAL()}));
-  testTypeConversion(ROW({}, {}));
-}
-} // namespace facebook::velox::substrait::test
diff --git a/velox/substrait/tests/data/q1_first_stage.json b/velox/substrait/tests/data/q1_first_stage.json
deleted file mode 100644
index 6b4c1cf7a499..000000000000
--- a/velox/substrait/tests/data/q1_first_stage.json
+++ /dev/null
@@ -1,877 +0,0 @@
-{
-    "extension_uris": [
-        {
-            "extension_uri_anchor": 1,
-            "uri": "/functions_datetime.yaml"
-        }
-    ],
-    "extensions": [
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 1,
-                "name": "lte:fp64_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 6,
-                "name": "sum:opt_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 3,
-                "name": "subtract:opt_fp64_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 9,
-                "name": "is_not_null:fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 2,
-                "name": "and:bool_bool"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 5,
-                "name": "add:opt_fp64_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 7,
-                "name": "count:opt_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 4,
-                "name": "multiply:opt_fp64_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 8,
-                "name": "count:opt_i32"
-            }
-        }
-    ],
-    "relations": [
-        {
-            "root": {
-                "input": {
-                    "aggregate": {
-                        "common": {
-                            "direct": {}
-                        },
-                        "input": {
-                            "project": {
-                                "common": {
-                                    "direct": {}
-                                },
-                                "input": {
-                                    "project": {
-                                        "common": {
-                                            "direct": {}
-                                        },
-                                        "input": {
-                                            "read": {
-                                                "common": {
-                                                    "direct": {}
-                                                },
-                                                "base_schema": {
-                                                    "names": [
-                                                        "l_quantity",
-                                                        "l_extendedprice",
-                                                        "l_discount",
-                                                        "l_tax",
-                                                        "l_returnflag",
-                                                        "l_linestatus",
-                                                        "l_shipdate"
-                                                    ],
-                                                    "struct": {
-                                                        "types": [
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "string": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "string": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            }
-                                                        ],
-                                                        "type_variation_reference": 0,
-                                                        "nullability": "NULLABILITY_REQUIRED"
-                                                    }
-                                                },
-                                                "filter": {
-                                                    "scalar_function": {
-                                                        "function_reference": 2,
-                                                        "arguments": [
-                                                            {
-                                                                "value": {
-                                                                    "scalar_function": {
-                                                                        "function_reference": 9,
-                                                                        "arguments": [
-                                                                            {
-                                                                                "value": {
-                                                                                    "selection": {
-                                                                                        "direct_reference": {
-                                                                                            "struct_field": {
-                                                                                                "field": 6
-                                                                                            }
-                                                                                        },
-                                                                                        "root_reference": {}
-                                                                                    }
-                                                                                }
-                                                                            }
-                                                                        ],
-                                                                        "output_type": {
-                                                                            "bool": {
-                                                                                "type_variation_reference": 0,
-                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                }
-                                                            },
-                                                            {
-                                                                "value": {
-                                                                    "scalar_function": {
-                                                                        "function_reference": 1,
-                                                                        "arguments": [
-                                                                            {
-                                                                                "value": {
-                                                                                    "selection": {
-                                                                                        "direct_reference": {
-                                                                                            "struct_field": {
-                                                                                                "field": 6
-                                                                                            }
-                                                                                        },
-                                                                                        "root_reference": {}
-                                                                                    }
-                                                                                }
-                                                                            },
-                                                                            {
-                                                                                "value": {
-                                                                                    "literal": {
-                                                                                        "nullable": false,
-                                                                                        "fp64": 10471
-                                                                                    }
-                                                                                }
-                                                                            }
-                                                                        ],
-                                                                        "output_type": {
-                                                                            "bool": {
-                                                                                "type_variation_reference": 0,
-                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                }
-                                                            }
-                                                        ],
-                                                        "output_type": {
-                                                            "bool": {
-                                                                "type_variation_reference": 0,
-                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                            }
-                                                        }
-                                                    }
-                                                },
-                                                "local_files": {
-                                                    "items": [
-                                                        {
-                                                            "orc": {},
-                                                            "partition_index": "0",
-                                                            "start": "0",
-                                                            "length": "3719",
-                                                            "uri_file": "/mock_lineitem.orc"
-                                                        }
-                                                    ]
-                                                }
-                                            }
-                                        },
-                                        "expressions": [
-                                            {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 0
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            },
-                                            {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 1
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            },
-                                            {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 2
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            },
-                                            {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 3
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            },
-                                            {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 4
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            },
-                                            {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 5
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        ]
-                                    }
-                                },
-                                "expressions": [
-                                    {
-                                        "selection": {
-                                            "direct_reference": {
-                                                "struct_field": {
-                                                    "field": 4
-                                                }
-                                            },
-                                            "root_reference": {}
-                                        }
-                                    },
-                                    {
-                                        "selection": {
-                                            "direct_reference": {
-                                                "struct_field": {
-                                                    "field": 5
-                                                }
-                                            },
-                                            "root_reference": {}
-                                        }
-                                    },
-                                    {
-                                        "selection": {
-                                            "direct_reference": {
-                                                "struct_field": {
-                                                    "field": 0
-                                                }
-                                            },
-                                            "root_reference": {}
-                                        }
-                                    },
-                                    {
-                                        "selection": {
-                                            "direct_reference": {
-                                                "struct_field": {
-                                                    "field": 1
-                                                }
-                                            },
-                                            "root_reference": {}
-                                        }
-                                    },
-                                    {
-                                        "scalar_function": {
-                                            "function_reference": 4,
-                                            "arguments": [
-                                                {
-                                                    "value": {
-                                                        "selection": {
-                                                            "direct_reference": {
-                                                                "struct_field": {
-                                                                    "field": 1
-                                                                }
-                                                            },
-                                                            "root_reference": {}
-                                                        }
-                                                    }
-                                                },
-                                                {
-                                                    "value": {
-                                                        "scalar_function": {
-                                                            "function_reference": 3,
-                                                            "arguments": [
-                                                                {
-                                                                    "value": {
-                                                                        "literal": {
-                                                                            "nullable": false,
-                                                                            "fp64": 1
-                                                                        }
-                                                                    }
-                                                                },
-                                                                {
-                                                                    "value": {
-                                                                        "selection": {
-                                                                            "direct_reference": {
-                                                                                "struct_field": {
-                                                                                    "field": 2
-                                                                                }
-                                                                            },
-                                                                            "root_reference": {}
-                                                                        }
-                                                                    }
-                                                                }
-                                                            ],
-                                                            "output_type": {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            ],
-                                            "output_type": {
-                                                "fp64": {
-                                                    "type_variation_reference": 0,
-                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                }
-                                            }
-                                        }
-                                    },
-                                    {
-                                        "scalar_function": {
-                                            "function_reference": 4,
-                                            "arguments": [
-                                                {
-                                                    "value": {
-                                                        "scalar_function": {
-                                                            "function_reference": 4,
-                                                            "arguments": [
-                                                                {
-                                                                    "value": {
-                                                                        "selection": {
-                                                                            "direct_reference": {
-                                                                                "struct_field": {
-                                                                                    "field": 1
-                                                                                }
-                                                                            },
-                                                                            "root_reference": {}
-                                                                        }
-                                                                    }
-                                                                },
-                                                                {
-                                                                    "value": {
-                                                                        "scalar_function": {
-                                                                            "function_reference": 3,
-                                                                            "arguments": [
-                                                                                {
-                                                                                    "value": {
-                                                                                        "literal": {
-                                                                                            "nullable": false,
-                                                                                            "fp64": 1
-                                                                                        }
-                                                                                    }
-                                                                                },
-                                                                                {
-                                                                                    "value": {
-                                                                                        "selection": {
-                                                                                            "direct_reference": {
-                                                                                                "struct_field": {
-                                                                                                    "field": 2
-                                                                                                }
-                                                                                            },
-                                                                                            "root_reference": {}
-                                                                                        }
-                                                                                    }
-                                                                                }
-                                                                            ],
-                                                                            "output_type": {
-                                                                                "fp64": {
-                                                                                    "type_variation_reference": 0,
-                                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                                }
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                }
-                                                            ],
-                                                            "output_type": {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                },
-                                                {
-                                                    "value": {
-                                                        "scalar_function": {
-                                                            "function_reference": 5,
-                                                            "arguments": [
-                                                                {
-                                                                    "value": {
-                                                                        "literal": {
-                                                                            "nullable": false,
-                                                                            "fp64": 1
-                                                                        }
-                                                                    }
-                                                                },
-                                                                {
-                                                                    "value": {
-                                                                        "selection": {
-                                                                            "direct_reference": {
-                                                                                "struct_field": {
-                                                                                    "field": 3
-                                                                                }
-                                                                            },
-                                                                            "root_reference": {}
-                                                                        }
-                                                                    }
-                                                                }
-                                                            ],
-                                                            "output_type": {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            ],
-                                            "output_type": {
-                                                "fp64": {
-                                                    "type_variation_reference": 0,
-                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                }
-                                            }
-                                        }
-                                    },
-                                    {
-                                        "selection": {
-                                            "direct_reference": {
-                                                "struct_field": {
-                                                    "field": 2
-                                                }
-                                            },
-                                            "root_reference": {}
-                                        }
-                                    },
-                                    {
-                                        "literal": {
-                                            "nullable": false,
-                                            "i32": 1
-                                        }
-                                    }
-                                ]
-                            }
-                        },
-                        "groupings": [
-                            {
-                                "grouping_expressions": [
-                                    {
-                                        "selection": {
-                                            "direct_reference": {
-                                                "struct_field": {
-                                                    "field": 0
-                                                }
-                                            },
-                                            "root_reference": {}
-                                        }
-                                    },
-                                    {
-                                        "selection": {
-                                            "direct_reference": {
-                                                "struct_field": {
-                                                    "field": 1
-                                                }
-                                            },
-                                            "root_reference": {}
-                                        }
-                                    }
-                                ]
-                            }
-                        ],
-                        "measures": [
-                            {
-                                "measure": {
-                                    "function_reference": 6,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 2
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "sorts": [],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "type_variation_reference": 0,
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 6,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 3
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "sorts": [],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "type_variation_reference": 0,
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 6,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 4
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "sorts": [],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "type_variation_reference": 0,
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 6,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 5
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 6,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "directReference": {
-                                                        "structField": {
-                                                            "field": 2
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "sorts": [],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "type_variation_reference": 0,
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 7,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 2
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "i64": {
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 6,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 3
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "sorts": [],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "type_variation_reference": 0,
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 7,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 3
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "i64": {
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 6,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 6
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "sorts": [],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "type_variation_reference": 0,
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 7,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 6
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "sorts": [],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "type_variation_reference": 0,
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                "measure": {
-                                    "function_reference": 8,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 7
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "sorts": [],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "i64": {
-                                            "type_variation_reference": 0,
-                                            "nullability": "NULLABILITY_REQUIRED"
-                                        }
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                },
-                "names": [
-                    "l_returnflag#8",
-                    "l_linestatus#9",
-                    "sum#108",
-                    "sum#109",
-                    "sum#110",
-                    "sum#111",
-                    "sum#112",
-                    "count#113",
-                    "sum#114",
-                    "count#115",
-                    "sum#116",
-                    "count#117",
-                    "count#118"
-                ]
-            }
-        }
-    ],
-    "expected_type_urls": []
-}
diff --git a/velox/substrait/tests/data/q6_first_stage.json b/velox/substrait/tests/data/q6_first_stage.json
deleted file mode 100644
index 36597a362516..000000000000
--- a/velox/substrait/tests/data/q6_first_stage.json
+++ /dev/null
@@ -1,603 +0,0 @@
-{
-    "extension_uris": [
-        {
-            "extension_uri_anchor": 1,
-            "uri": "/functions_boolean.yaml"
-        }
-    ],
-    "extensions": [
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 4,
-                "name": "lte:fp64_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 6,
-                "name": "sum:opt_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 3,
-                "name": "lt:fp64_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 7,
-                "name": "is_not_null:fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 1,
-                "name": "and:bool_bool"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 2,
-                "name": "gte:fp64_fp64"
-            }
-        },
-        {
-            "extension_function": {
-                "extension_uri_reference": 1,
-                "function_anchor": 5,
-                "name": "multiply:opt_fp64_fp64"
-            }
-        }
-    ],
-    "relations": [
-        {
-            "root": {
-                "input": {
-                    "aggregate": {
-                        "common": {
-                            "direct": {}
-                        },
-                        "input": {
-                            "project": {
-                                "common": {
-                                    "emit":{
-                                        "outputMapping":[
-                                           2
-                                        ]
-                                    }
-                                },
-                                "input": {
-                                    "project": {
-                                        "common": {
-                                            "emit":{
-                                                "outputMapping":[
-                                                   4,
-                                                   5
-                                                ]
-                                            }
-                                        },
-                                        "input": {
-                                            "read": {
-                                                "common": {
-                                                    "direct": {}
-                                                },
-                                                "base_schema": {
-                                                    "names": [
-                                                        "l_quantity",
-                                                        "l_extendedprice",
-                                                        "l_discount",
-                                                        "l_shipdate"
-                                                    ],
-                                                    "struct": {
-                                                        "types": [
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            },
-                                                            {
-                                                                "fp64": {
-                                                                    "type_variation_reference": 0,
-                                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                                }
-                                                            }
-                                                        ],
-                                                        "type_variation_reference": 0,
-                                                        "nullability": "NULLABILITY_REQUIRED"
-                                                    }
-                                                },
-                                                "filter": {
-                                                    "scalar_function": {
-                                                        "function_reference": 1,
-                                                        "arguments": [
-                                                            {
-                                                                "value": {
-                                                                    "scalar_function": {
-                                                                        "function_reference": 1,
-                                                                        "arguments": [
-                                                                            {
-                                                                                "value": {
-                                                                                    "scalar_function": {
-                                                                                        "function_reference": 1,
-                                                                                        "arguments": [
-                                                                                            {
-                                                                                                "value": {
-                                                                                                    "scalar_function": {
-                                                                                                        "function_reference": 1,
-                                                                                                        "arguments": [
-                                                                                                            {
-                                                                                                                "value": {
-                                                                                                                    "scalar_function": {
-                                                                                                                        "function_reference": 1,
-                                                                                                                        "arguments": [
-                                                                                                                            {
-                                                                                                                                "value": {
-                                                                                                                                    "scalar_function": {
-                                                                                                                                        "function_reference": 1,
-                                                                                                                                        "arguments": [
-                                                                                                                                            {
-                                                                                                                                                "value": {
-                                                                                                                                                    "scalar_function": {
-                                                                                                                                                        "function_reference": 1,
-                                                                                                                                                        "arguments": [
-                                                                                                                                                            {
-                                                                                                                                                                "value": {
-                                                                                                                                                                    "scalar_function": {
-                                                                                                                                                                        "function_reference": 7,
-                                                                                                                                                                        "arguments": [
-                                                                                                                                                                            {
-                                                                                                                                                                                "value": {
-                                                                                                                                                                                    "selection": {
-                                                                                                                                                                                        "direct_reference": {
-                                                                                                                                                                                            "struct_field": {
-                                                                                                                                                                                                "field": 3
-                                                                                                                                                                                            }
-                                                                                                                                                                                        },
-                                                                                                                                                                                        "root_reference": {}
-                                                                                                                                                                                    }
-                                                                                                                                                                                }
-                                                                                                                                                                            }
-                                                                                                                                                                        ],
-                                                                                                                                                                        "output_type": {
-                                                                                                                                                                            "bool": {
-                                                                                                                                                                                "type_variation_reference": 0,
-                                                                                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                                                                                            }
-                                                                                                                                                                        }
-                                                                                                                                                                    }
-                                                                                                                                                                }
-                                                                                                                                                            },
-                                                                                                                                                            {
-                                                                                                                                                                "value": {
-                                                                                                                                                                    "scalar_function": {
-                                                                                                                                                                        "function_reference": 7,
-                                                                                                                                                                        "arguments": [
-                                                                                                                                                                            {
-                                                                                                                                                                                "value": {
-                                                                                                                                                                                    "selection": {
-                                                                                                                                                                                        "direct_reference": {
-                                                                                                                                                                                            "struct_field": {
-                                                                                                                                                                                                "field": 2
-                                                                                                                                                                                            }
-                                                                                                                                                                                        },
-                                                                                                                                                                                        "root_reference": {}
-                                                                                                                                                                                    }
-                                                                                                                                                                                }
-                                                                                                                                                                            }
-                                                                                                                                                                        ],
-                                                                                                                                                                        "output_type": {
-                                                                                                                                                                            "bool": {
-                                                                                                                                                                                "type_variation_reference": 0,
-                                                                                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                                                                                            }
-                                                                                                                                                                        }
-                                                                                                                                                                    }
-                                                                                                                                                                }
-                                                                                                                                                            }
-                                                                                                                                                        ],
-                                                                                                                                                        "output_type": {
-                                                                                                                                                            "bool": {
-                                                                                                                                                                "type_variation_reference": 0,
-                                                                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                                                                            }
-                                                                                                                                                        }
-                                                                                                                                                    }
-                                                                                                                                                }
-                                                                                                                                            },
-                                                                                                                                            {
-                                                                                                                                                "value": {
-                                                                                                                                                    "scalar_function": {
-                                                                                                                                                        "function_reference": 7,
-                                                                                                                                                        "arguments": [
-                                                                                                                                                            {
-                                                                                                                                                                "value": {
-                                                                                                                                                                    "selection": {
-                                                                                                                                                                        "direct_reference": {
-                                                                                                                                                                            "struct_field": {
-                                                                                                                                                                                "field": 0
-                                                                                                                                                                            }
-                                                                                                                                                                        },
-                                                                                                                                                                        "root_reference": {}
-                                                                                                                                                                    }
-                                                                                                                                                                }
-                                                                                                                                                            }
-                                                                                                                                                        ],
-                                                                                                                                                        "output_type": {
-                                                                                                                                                            "bool": {
-                                                                                                                                                                "type_variation_reference": 0,
-                                                                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                                                                            }
-                                                                                                                                                        }
-                                                                                                                                                    }
-                                                                                                                                                }
-                                                                                                                                            }
-                                                                                                                                        ],
-                                                                                                                                        "output_type": {
-                                                                                                                                            "bool": {
-                                                                                                                                                "type_variation_reference": 0,
-                                                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                                                            }
-                                                                                                                                        }
-                                                                                                                                    }
-                                                                                                                                }
-                                                                                                                            },
-                                                                                                                            {
-                                                                                                                                "value": {
-                                                                                                                                    "scalar_function": {
-                                                                                                                                        "function_reference": 2,
-                                                                                                                                        "arguments": [
-                                                                                                                                            {
-                                                                                                                                                "value": {
-                                                                                                                                                    "selection": {
-                                                                                                                                                        "direct_reference": {
-                                                                                                                                                            "struct_field": {
-                                                                                                                                                                "field": 3
-                                                                                                                                                            }
-                                                                                                                                                        },
-                                                                                                                                                        "root_reference": {}
-                                                                                                                                                    }
-                                                                                                                                                }
-                                                                                                                                            },
-                                                                                                                                            {
-                                                                                                                                                "value": {
-                                                                                                                                                    "literal": {
-                                                                                                                                                        "nullable": false,
-                                                                                                                                                        "fp64": 8766
-                                                                                                                                                    }
-                                                                                                                                                }
-                                                                                                                                            }
-                                                                                                                                        ],
-                                                                                                                                        "output_type": {
-                                                                                                                                            "bool": {
-                                                                                                                                                "type_variation_reference": 0,
-                                                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                                                            }
-                                                                                                                                        }
-                                                                                                                                    }
-                                                                                                                                }
-                                                                                                                            }
-                                                                                                                        ],
-                                                                                                                        "output_type": {
-                                                                                                                            "bool": {
-                                                                                                                                "type_variation_reference": 0,
-                                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                                            }
-                                                                                                                        }
-                                                                                                                    }
-                                                                                                                }
-                                                                                                            },
-                                                                                                            {
-                                                                                                                "value": {
-                                                                                                                    "scalar_function": {
-                                                                                                                        "function_reference": 3,
-                                                                                                                        "arguments": [
-                                                                                                                            {
-                                                                                                                                "value": {
-                                                                                                                                    "selection": {
-                                                                                                                                        "direct_reference": {
-                                                                                                                                            "struct_field": {
-                                                                                                                                                "field": 3
-                                                                                                                                            }
-                                                                                                                                        },
-                                                                                                                                        "root_reference": {}
-                                                                                                                                    }
-                                                                                                                                }
-                                                                                                                            },
-                                                                                                                            {
-                                                                                                                                "value": {
-                                                                                                                                    "literal": {
-                                                                                                                                        "nullable": false,
-                                                                                                                                        "fp64": 9131
-                                                                                                                                    }
-                                                                                                                                }
-                                                                                                                            }
-                                                                                                                        ],
-                                                                                                                        "output_type": {
-                                                                                                                            "bool": {
-                                                                                                                                "type_variation_reference": 0,
-                                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                                            }
-                                                                                                                        }
-                                                                                                                    }
-                                                                                                                }
-                                                                                                            }
-                                                                                                        ],
-                                                                                                        "output_type": {
-                                                                                                            "bool": {
-                                                                                                                "type_variation_reference": 0,
-                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                            }
-                                                                                                        }
-                                                                                                    }
-                                                                                                }
-                                                                                            },
-                                                                                            {
-                                                                                                "value": {
-                                                                                                    "scalar_function": {
-                                                                                                        "function_reference": 2,
-                                                                                                        "arguments": [
-                                                                                                            {
-                                                                                                                "value": {
-                                                                                                                    "selection": {
-                                                                                                                        "direct_reference": {
-                                                                                                                            "struct_field": {
-                                                                                                                                "field": 2
-                                                                                                                            }
-                                                                                                                        },
-                                                                                                                        "root_reference": {}
-                                                                                                                    }
-                                                                                                                }
-                                                                                                            },
-                                                                                                            {
-                                                                                                                "value": {
-                                                                                                                    "literal": {
-                                                                                                                        "nullable": false,
-                                                                                                                        "fp64": 0.05
-                                                                                                                    }
-                                                                                                                }
-                                                                                                            }
-                                                                                                        ],
-                                                                                                        "output_type": {
-                                                                                                            "bool": {
-                                                                                                                "type_variation_reference": 0,
-                                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                                            }
-                                                                                                        }
-                                                                                                    }
-                                                                                                }
-                                                                                            }
-                                                                                        ],
-                                                                                        "output_type": {
-                                                                                            "bool": {
-                                                                                                "type_variation_reference": 0,
-                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                            }
-                                                                                        }
-                                                                                    }
-                                                                                }
-                                                                            },
-                                                                            {
-                                                                                "value": {
-                                                                                    "scalar_function": {
-                                                                                        "function_reference": 4,
-                                                                                        "arguments": [
-                                                                                            {
-                                                                                                "value": {
-                                                                                                    "selection": {
-                                                                                                        "direct_reference": {
-                                                                                                            "struct_field": {
-                                                                                                                "field": 2
-                                                                                                            }
-                                                                                                        },
-                                                                                                        "root_reference": {}
-                                                                                                    }
-                                                                                                }
-                                                                                            },
-                                                                                            {
-                                                                                                "value": {
-                                                                                                    "literal": {
-                                                                                                        "nullable": false,
-                                                                                                        "fp64": 0.07
-                                                                                                    }
-                                                                                                }
-                                                                                            }
-                                                                                        ],
-                                                                                        "output_type": {
-                                                                                            "bool": {
-                                                                                                "type_variation_reference": 0,
-                                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                                            }
-                                                                                        }
-                                                                                    }
-                                                                                }
-                                                                            }
-                                                                        ],
-                                                                        "output_type": {
-                                                                            "bool": {
-                                                                                "type_variation_reference": 0,
-                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                }
-                                                            },
-                                                            {
-                                                                "value": {
-                                                                    "scalar_function": {
-                                                                        "function_reference": 3,
-                                                                        "arguments": [
-                                                                            {
-                                                                                "value": {
-                                                                                    "selection": {
-                                                                                        "direct_reference": {
-                                                                                            "struct_field": {
-                                                                                                "field": 0
-                                                                                            }
-                                                                                        },
-                                                                                        "root_reference": {}
-                                                                                    }
-                                                                                }
-                                                                            },
-                                                                            {
-                                                                                "value": {
-                                                                                    "literal": {
-                                                                                        "nullable": false,
-                                                                                        "fp64": 24
-                                                                                    }
-                                                                                }
-                                                                            }
-                                                                        ],
-                                                                        "output_type": {
-                                                                            "bool": {
-                                                                                "type_variation_reference": 0,
-                                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                                            }
-                                                                        }
-                                                                    }
-                                                                }
-                                                            }
-                                                        ],
-                                                        "output_type": {
-                                                            "bool": {
-                                                                "type_variation_reference": 0,
-                                                                "nullability": "NULLABILITY_NULLABLE"
-                                                            }
-                                                        }
-                                                    }
-                                                },
-                                                "local_files": {
-                                                    "items": [
-                                                        {
-                                                            "partition_index": "0",
-                                                            "start": "0",
-                                                            "length": "3719",
-                                                            "uri_file": "/mock_lineitem.orc",
-                                                            "orc": {}
-                                                        }
-                                                    ]
-                                                }
-                                            }
-                                        },
-                                        "expressions": [
-                                            {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 1
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            },
-                                            {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 2
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        ]
-                                    }
-                                },
-                                "expressions": [
-                                    {
-                                        "scalar_function": {
-                                            "function_reference": 5,
-                                            "arguments": [
-                                                {
-                                                    "value": {
-                                                        "selection": {
-                                                            "direct_reference": {
-                                                                "struct_field": {
-                                                                    "field": 0
-                                                                }
-                                                            },
-                                                            "root_reference": {}
-                                                        }
-                                                    }
-                                                },
-                                                {
-                                                    "value": {
-                                                        "selection": {
-                                                            "direct_reference": {
-                                                                "struct_field": {
-                                                                    "field": 1
-                                                                }
-                                                            },
-                                                            "root_reference": {}
-                                                        }
-                                                    }
-                                                }
-                                            ],
-                                            "output_type": {
-                                                "fp64": {
-                                                    "nullability": "NULLABILITY_NULLABLE"
-                                                }
-                                            }
-                                        }
-                                    }
-                                ]
-                            }
-                        },
-                        "groupings": [
-                            {}
-                        ],
-                        "measures": [
-                            {
-                                "measure": {
-                                    "functionReference": 6,
-                                    "arguments": [
-                                        {
-                                            "value": {
-                                                "selection": {
-                                                    "direct_reference": {
-                                                        "struct_field": {
-                                                            "field": 0
-                                                        }
-                                                    },
-                                                    "root_reference": {}
-                                                }
-                                            }
-                                        }
-                                    ],
-                                    "phase": "AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE",
-                                    "output_type": {
-                                        "fp64": {
-                                            "nullability": "NULLABILITY_NULLABLE"
-                                        }
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                },
-                "names": [
-                    "sum#43"
-                ]
-            }
-        }
-    ]
-}
diff --git a/velox/substrait/tests/data/substrait_virtualTable.json b/velox/substrait/tests/data/substrait_virtualTable.json
deleted file mode 100644
index 06536fadd7e8..000000000000
--- a/velox/substrait/tests/data/substrait_virtualTable.json
+++ /dev/null
@@ -1,153 +0,0 @@
-{
- "extension_uris": [],
- "extensions": [],
- "relations": [
-  {
-   "root": {
-    "input": {
-     "read": {
-      "common": {
-       "direct": {}
-      },
-      "base_schema": {
-       "names": [
-        "c0",
-        "c1",
-        "c2",
-        "c3",
-        "c4"
-       ],
-       "struct": {
-        "types": [
-         {
-          "i64": {
-           "type_variation_reference": 0,
-           "nullability": "NULLABILITY_REQUIRED"
-          }
-         },
-         {
-          "i32": {
-           "type_variation_reference": 0,
-           "nullability": "NULLABILITY_REQUIRED"
-          }
-         },
-         {
-          "fp64": {
-           "type_variation_reference": 0,
-           "nullability": "NULLABILITY_REQUIRED"
-          }
-         },
-         {
-          "bool": {
-           "type_variation_reference": 0,
-           "nullability": "NULLABILITY_REQUIRED"
-          }
-         },
-         {
-          "i32": {
-           "type_variation_reference": 0,
-           "nullability": "NULLABILITY_NULLABLE"
-          }
-         }
-        ],
-        "type_variation_reference": 0,
-        "nullability": "NULLABILITY_NULLABLE"
-       }
-      },
-      "virtual_table": {
-       "values": [
-        {
-         "fields": [
-          {
-           "nullable": false,
-           "i64": "2499109626526694126"
-          },
-          {
-           "nullable": false,
-           "i64": "2342493223442167775"
-          },
-          {
-           "nullable": false,
-           "i64": "4077358421272316858"
-          },
-          {
-           "nullable": false,
-           "i32": 581869302
-          },
-          {
-           "nullable": false,
-           "i32": -708632711
-          },
-          {
-           "nullable": false,
-           "i32": -133711905
-          },
-          {
-           "nullable": false,
-           "fp64": 0.90579193414549275
-          },
-          {
-           "nullable": false,
-           "fp64": 0.96886777112423139
-          },
-          {
-           "nullable": false,
-           "fp64": 0.63235925003444637
-          },
-          {
-           "nullable": false,
-           "boolean": true
-          },
-          {
-           "nullable": false,
-           "boolean": false
-          },
-          {
-           "nullable": false,
-           "boolean": false
-          },
-          {
-           "null": {
-            "i32": {
-             "type_variation_reference": 0,
-             "nullability": "NULLABILITY_NULLABLE"
-            }
-           },
-           "nullable": true
-          },
-          {
-           "null": {
-            "i32": {
-             "type_variation_reference": 0,
-             "nullability": "NULLABILITY_NULLABLE"
-            }
-           },
-           "nullable": true
-          },
-          {
-           "null": {
-            "i32": {
-             "type_variation_reference": 0,
-             "nullability": "NULLABILITY_NULLABLE"
-            }
-           },
-           "nullable": true
-          }
-         ]
-        }
-       ]
-      }
-     }
-    },
-    "names": [
-     "c0",
-     "c1",
-     "c2",
-     "c3",
-     "c4"
-    ]
-   }
-  }
- ],
- "expected_type_urls": []
-}
diff --git a/velox/tool/trace/AggregationReplayer.h b/velox/tool/trace/AggregationReplayer.h
index 3613cff33249..0b8c2fcb812a 100644
--- a/velox/tool/trace/AggregationReplayer.h
+++ b/velox/tool/trace/AggregationReplayer.h
@@ -29,6 +29,7 @@ class AggregationReplayer : public OperatorReplayerBase {
       const std::string& taskId,
       const std::string& nodeId,
       const std::string& operatorType,
+      const std::string& spillBaseDir,
       const std::string& driverIds,
       uint64_t queryCapacity,
       folly::Executor* executor)
@@ -38,6 +39,7 @@ class AggregationReplayer : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            spillBaseDir,
             driverIds,
             queryCapacity,
             executor) {}
diff --git a/velox/tool/trace/CMakeLists.txt b/velox/tool/trace/CMakeLists.txt
index 5648fa9b4eb5..2de99a888946 100644
--- a/velox/tool/trace/CMakeLists.txt
+++ b/velox/tool/trace/CMakeLists.txt
@@ -17,12 +17,18 @@ add_library(
   AggregationReplayer.cpp
   FilterProjectReplayer.cpp
   HashJoinReplayer.cpp
+  IndexLookupJoinReplayer.cpp
+  MergeJoinReplayer.cpp
   OperatorReplayerBase.cpp
+  OrderByReplayer.cpp
   PartitionedOutputReplayer.cpp
   TableScanReplayer.cpp
   TableWriterReplayer.cpp
+  TopNRowNumberReplayer.cpp
   TraceReplayRunner.cpp
-  TraceReplayTaskRunner.cpp)
+  TraceReplayTaskRunner.cpp
+  UnnestReplayer.cpp
+)
 
 target_link_libraries(
   velox_query_trace_replayer_base
@@ -43,7 +49,8 @@ target_link_libraries(
   velox_s3fs
   Folly::folly
   glog::glog
-  gflags::gflags)
+  gflags::gflags
+)
 
 add_executable(velox_query_replayer TraceReplayerMain.cpp)
 
@@ -52,7 +59,8 @@ target_link_libraries(
   velox_query_trace_replayer_base
   velox_exec
   velox_exec_test_lib
-  velox_tpch_connector)
+  velox_tpch_connector
+)
 
 add_library(velox_trace_file_tool_base TraceFileToolRunner.cpp)
 
@@ -65,11 +73,11 @@ target_link_libraries(
   velox_hive_connector
   Folly::folly
   glog::glog
-  gflags::gflags)
+  gflags::gflags
+)
 
 add_executable(velox_trace_file_tool TraceFileToolMain.cpp)
 
-target_link_libraries(
-  velox_trace_file_tool velox_trace_file_tool_base)
+target_link_libraries(velox_trace_file_tool velox_trace_file_tool_base)
 
 add_subdirectory(tests)
diff --git a/velox/tool/trace/FilterProjectReplayer.cpp b/velox/tool/trace/FilterProjectReplayer.cpp
index 0a7a4b523a0a..fff124aed0cd 100644
--- a/velox/tool/trace/FilterProjectReplayer.cpp
+++ b/velox/tool/trace/FilterProjectReplayer.cpp
@@ -65,10 +65,8 @@ core::PlanNodePtr FilterProjectReplayer::createPlanNode(
 bool FilterProjectReplayer::isFilterProject(
     const core::PlanNode* filterNode) const {
   const auto* projectNode =
-      dynamic_cast<const core::ProjectNode*>(core::PlanNode::findFirstNode(
-          planFragment_.get(), [this](const core::PlanNode* node) {
-            return node->id() == std::to_string(std::stoull(nodeId_) + 1);
-          }));
+      dynamic_cast<const core::ProjectNode*>(core::PlanNode::findNodeById(
+          planFragment_.get(), std::to_string(std::stoull(nodeId_) + 1)));
   return projectNode != nullptr && projectNode->name() == "Project" &&
       projectNode->sources().size() == 1 &&
       projectNode->sources().front()->id() == nodeId_;
diff --git a/velox/tool/trace/FilterProjectReplayer.h b/velox/tool/trace/FilterProjectReplayer.h
index 2df1f679ac27..a5a6bfc6c77d 100644
--- a/velox/tool/trace/FilterProjectReplayer.h
+++ b/velox/tool/trace/FilterProjectReplayer.h
@@ -43,6 +43,7 @@ class FilterProjectReplayer : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            "",
             driverIds,
             queryCapacity,
             executor) {}
diff --git a/velox/tool/trace/HashJoinReplayer.h b/velox/tool/trace/HashJoinReplayer.h
index f0277753582b..d8d09ae3a1d3 100644
--- a/velox/tool/trace/HashJoinReplayer.h
+++ b/velox/tool/trace/HashJoinReplayer.h
@@ -29,6 +29,7 @@ class HashJoinReplayer final : public OperatorReplayerBase {
       const std::string& taskId,
       const std::string& nodeId,
       const std::string& operatorType,
+      const std::string& spillBaseDir,
       const std::string& driverIds,
       uint64_t queryCapacity,
       folly::Executor* executor)
@@ -38,6 +39,7 @@ class HashJoinReplayer final : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            spillBaseDir,
             driverIds,
             queryCapacity,
             executor) {}
diff --git a/velox/tool/trace/IndexLookupJoinReplayer.cpp b/velox/tool/trace/IndexLookupJoinReplayer.cpp
new file mode 100644
index 000000000000..f5ae9eb6bd63
--- /dev/null
+++ b/velox/tool/trace/IndexLookupJoinReplayer.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/tool/trace/IndexLookupJoinReplayer.h"
+#include "velox/exec/TraceUtil.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::tool::trace {
+core::PlanNodePtr IndexLookupJoinReplayer::createPlanNode(
+    const core::PlanNode* node,
+    const core::PlanNodeId& nodeId,
+    const core::PlanNodePtr& source) const {
+  const auto* indexLookupJoinNode =
+      dynamic_cast<const core::IndexLookupJoinNode*>(node);
+  VELOX_CHECK_NOT_NULL(indexLookupJoinNode);
+  return std::make_shared<core::IndexLookupJoinNode>(
+      nodeId,
+      indexLookupJoinNode->joinType(),
+      indexLookupJoinNode->leftKeys(),
+      indexLookupJoinNode->rightKeys(),
+      indexLookupJoinNode->joinConditions(),
+      indexLookupJoinNode->filter(),
+      indexLookupJoinNode->hasMarker(),
+      source, // Probe side
+      indexLookupJoinNode->lookupSource(), // Index side
+      indexLookupJoinNode->outputType());
+}
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/IndexLookupJoinReplayer.h b/velox/tool/trace/IndexLookupJoinReplayer.h
new file mode 100644
index 000000000000..c7d5f655dbc3
--- /dev/null
+++ b/velox/tool/trace/IndexLookupJoinReplayer.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/tool/trace/OperatorReplayerBase.h"
+
+namespace facebook::velox::tool::trace {
+/// The replayer to replay the traced 'IndexLookupJoin' operator.
+class IndexLookupJoinReplayer : public OperatorReplayerBase {
+ public:
+  IndexLookupJoinReplayer(
+      const std::string& traceDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& operatorType,
+      const std::string& driverIds,
+      uint64_t queryCapacity,
+      folly::Executor* executor)
+      : OperatorReplayerBase(
+            traceDir,
+            queryId,
+            taskId,
+            nodeId,
+            operatorType,
+            "",
+            driverIds,
+            queryCapacity,
+            executor) {}
+
+ private:
+  core::PlanNodePtr createPlanNode(
+      const core::PlanNode* node,
+      const core::PlanNodeId& nodeId,
+      const core::PlanNodePtr& source) const override;
+};
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/MergeJoinReplayer.cpp b/velox/tool/trace/MergeJoinReplayer.cpp
new file mode 100644
index 000000000000..6ba68cb2ebcf
--- /dev/null
+++ b/velox/tool/trace/MergeJoinReplayer.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/tool/trace/MergeJoinReplayer.h"
+#include "velox/exec/TraceUtil.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::tool::trace {
+core::PlanNodePtr MergeJoinReplayer::createPlanNode(
+    const core::PlanNode* node,
+    const core::PlanNodeId& nodeId,
+    const core::PlanNodePtr& source) const {
+  const auto* mergeJoinNode = dynamic_cast<const core::MergeJoinNode*>(node);
+  return std::make_shared<core::MergeJoinNode>(
+      nodeId,
+      mergeJoinNode->joinType(),
+      mergeJoinNode->leftKeys(),
+      mergeJoinNode->rightKeys(),
+      mergeJoinNode->filter(),
+      source,
+      PlanBuilder(planNodeIdGenerator_)
+          .traceScan(
+              nodeTraceDir_,
+              pipelineIds_.at(1), // Right side
+              driverIds_,
+              exec::trace::getDataType(planFragment_, nodeId_, 1))
+          .planNode(),
+      mergeJoinNode->outputType());
+}
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/MergeJoinReplayer.h b/velox/tool/trace/MergeJoinReplayer.h
new file mode 100644
index 000000000000..fb3cb027041b
--- /dev/null
+++ b/velox/tool/trace/MergeJoinReplayer.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/PlanNode.h"
+#include "velox/tool/trace/OperatorReplayerBase.h"
+
+namespace facebook::velox::tool::trace {
+/// The replayer to replay the traced 'MergeJoin' operator.
+class MergeJoinReplayer final : public OperatorReplayerBase {
+ public:
+  MergeJoinReplayer(
+      const std::string& rootDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& operatorType,
+      const std::string& spillBaseDir,
+      const std::string& driverIds,
+      uint64_t queryCapacity,
+      folly::Executor* executor)
+      : OperatorReplayerBase(
+            rootDir,
+            queryId,
+            taskId,
+            nodeId,
+            operatorType,
+            spillBaseDir,
+            driverIds,
+            queryCapacity,
+            executor) {}
+
+ private:
+  core::PlanNodePtr createPlanNode(
+      const core::PlanNode* node,
+      const core::PlanNodeId& nodeId,
+      const core::PlanNodePtr& source) const override;
+};
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/OperatorReplayerBase.cpp b/velox/tool/trace/OperatorReplayerBase.cpp
index 00cbd912d45a..dd831b104736 100644
--- a/velox/tool/trace/OperatorReplayerBase.cpp
+++ b/velox/tool/trace/OperatorReplayerBase.cpp
@@ -33,21 +33,23 @@ using namespace facebook::velox;
 
 namespace facebook::velox::tool::trace {
 OperatorReplayerBase::OperatorReplayerBase(
-    std::string traceDir,
-    std::string queryId,
-    std::string taskId,
-    std::string nodeId,
-    std::string operatorType,
+    const std::string& traceDir,
+    const std::string& queryId,
+    const std::string& taskId,
+    const std::string& nodeId,
+    const std::string& nodeName,
+    const std::string& spillBaseDir,
     const std::string& driverIds,
     uint64_t queryCapacity,
     folly::Executor* executor)
     : queryId_(std::string(std::move(queryId))),
       taskId_(std::move(taskId)),
       nodeId_(std::move(nodeId)),
-      operatorType_(std::move(operatorType)),
+      nodeName_(std::move(nodeName)),
       taskTraceDir_(
           exec::trace::getTaskTraceDirectory(traceDir, queryId_, taskId_)),
       nodeTraceDir_(exec::trace::getNodeTraceDirectory(taskTraceDir_, nodeId_)),
+      spillBaseDir_(spillBaseDir),
       fs_(filesystems::getFileSystem(taskTraceDir_, nullptr)),
       pipelineIds_(exec::trace::listPipelineIds(nodeTraceDir_, fs_)),
       driverIds_(
@@ -61,8 +63,8 @@ OperatorReplayerBase::OperatorReplayerBase(
   VELOX_USER_CHECK(!taskTraceDir_.empty());
   VELOX_USER_CHECK(!taskId_.empty());
   VELOX_USER_CHECK(!nodeId_.empty());
-  VELOX_USER_CHECK(!operatorType_.empty());
-  if (operatorType_ == "HashJoin") {
+  VELOX_USER_CHECK(!nodeName_.empty());
+  if (nodeName_ == "HashJoin" || nodeName_ == "MergeJoin") {
     VELOX_USER_CHECK_EQ(pipelineIds_.size(), 2);
   } else {
     VELOX_USER_CHECK_EQ(pipelineIds_.size(), 1);
@@ -72,6 +74,10 @@ OperatorReplayerBase::OperatorReplayerBase(
   const auto taskMetaReader = exec::trace::TaskTraceMetadataReader(
       taskTraceDir_, memory::MemoryManager::getInstance()->tracePool());
   queryConfigs_ = taskMetaReader.queryConfigs();
+  LOG(INFO) << "Query configs:\n";
+  for (const auto& [key, value] : queryConfigs_) {
+    LOG(INFO) << fmt::format("\t{}: {}", key, value);
+  }
   connectorConfigs_ = taskMetaReader.connectorProperties();
   planFragment_ = taskMetaReader.queryPlan();
   queryConfigs_[core::QueryConfig::kQueryTraceEnabled] = "false";
@@ -79,26 +85,27 @@ OperatorReplayerBase::OperatorReplayerBase(
 
 RowVectorPtr OperatorReplayerBase::run(bool copyResults) {
   auto queryCtx = createQueryCtx();
-  std::shared_ptr<exec::test::TempDirectoryPath> spillDirectory;
-  if (queryCtx->queryConfig().spillEnabled()) {
-    spillDirectory = exec::test::TempDirectoryPath::create();
+  std::shared_ptr<exec::test::TempDirectoryPath> localSpillDirectory;
+  if (queryCtx->queryConfig().spillEnabled() && spillBaseDir_.empty()) {
+    localSpillDirectory = exec::test::TempDirectoryPath::create();
   }
 
   TraceReplayTaskRunner traceTaskRunner(createPlan(), std::move(queryCtx));
   auto [task, result] =
       traceTaskRunner.maxDrivers(driverIds_.size())
-          .spillDirectory(spillDirectory ? spillDirectory->getPath() : "")
+          .spillDirectory(
+              localSpillDirectory != nullptr ? localSpillDirectory->getPath()
+                                             : spillBaseDir_)
           .run(copyResults);
   printStats(task);
   return result;
 }
 
 core::PlanNodePtr OperatorReplayerBase::createPlan() {
-  const auto* replayNode = core::PlanNode::findFirstNode(
-      planFragment_.get(),
-      [this](const core::PlanNode* node) { return node->id() == nodeId_; });
+  const auto* replayNode =
+      core::PlanNode::findNodeById(planFragment_.get(), nodeId_);
 
-  if (replayNode->name() == "TableScan") {
+  if (replayNode->sources().empty()) {
     return exec::test::PlanBuilder()
         .addNode(replayNodeFactory(replayNode))
         .capturePlanNodeId(replayPlanNodeId_)
@@ -119,7 +126,7 @@ core::PlanNodePtr OperatorReplayerBase::createPlan() {
 std::shared_ptr<core::QueryCtx> OperatorReplayerBase::createQueryCtx() {
   static std::atomic_uint64_t replayQueryId{0};
   auto queryPool = memory::memoryManager()->addRootPool(
-      fmt::format("{}_replayer_{}", operatorType_, replayQueryId++),
+      fmt::format("{}_replayer_{}", nodeName_, replayQueryId++),
       queryCapacity_);
   std::unordered_map<std::string, std::shared_ptr<config::ConfigBase>>
       connectorConfigs;
@@ -138,7 +145,8 @@ std::shared_ptr<core::QueryCtx> OperatorReplayerBase::createQueryCtx() {
 
 std::function<core::PlanNodePtr(std::string, core::PlanNodePtr)>
 OperatorReplayerBase::replayNodeFactory(const core::PlanNode* node) const {
-  return [=](const core::PlanNodeId& nodeId,
+  return [=, this](
+             const core::PlanNodeId& nodeId,
              const core::PlanNodePtr& source) -> core::PlanNodePtr {
     return createPlanNode(node, nodeId, source);
   };
@@ -146,12 +154,12 @@ OperatorReplayerBase::replayNodeFactory(const core::PlanNode* node) const {
 
 void OperatorReplayerBase::printStats(
     const std::shared_ptr<exec::Task>& task) const {
-  const auto planStats = exec::toPlanStats(task->taskStats());
-  const auto& stats = planStats.at(replayPlanNodeId_);
-  for (const auto& [name, operatorStats] : stats.operatorStats) {
-    LOG(INFO) << "Stats of replaying operator " << name << " : "
-              << operatorStats->toString();
-  }
+  const auto taskStats = exec::toPlanStats(task->taskStats());
+  const auto& nodeStats = taskStats.at(replayPlanNodeId_);
+  LOG(INFO) << "Stats of replaying execution:";
+  LOG(INFO) << nodeStats.toString(
+      /*includeInputStats=*/true,
+      /*includeRuntimeStats=*/true);
   LOG(INFO) << "Memory usage: " << task->pool()->treeMemoryUsage(false);
 }
 } // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/OperatorReplayerBase.h b/velox/tool/trace/OperatorReplayerBase.h
index e804e08d768b..e6118e9ec32e 100644
--- a/velox/tool/trace/OperatorReplayerBase.h
+++ b/velox/tool/trace/OperatorReplayerBase.h
@@ -29,11 +29,12 @@ namespace facebook::velox::tool::trace {
 class OperatorReplayerBase {
  public:
   OperatorReplayerBase(
-      std::string traceDir,
-      std::string queryId,
-      std::string taskId,
-      std::string nodeId,
-      std::string operatorType,
+      const std::string& traceDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& nodeName,
+      const std::string& spillBaseDir,
       const std::string& driverIds,
       uint64_t queryCapacity,
       folly::Executor* executor);
@@ -60,9 +61,10 @@ class OperatorReplayerBase {
   const std::string queryId_;
   const std::string taskId_;
   const std::string nodeId_;
-  const std::string operatorType_;
+  const std::string nodeName_;
   const std::string taskTraceDir_;
   const std::string nodeTraceDir_;
+  const std::string spillBaseDir_;
   const std::shared_ptr<filesystems::FileSystem> fs_;
   const std::vector<uint32_t> pipelineIds_;
   const std::vector<uint32_t> driverIds_;
diff --git a/velox/tool/trace/OrderByReplayer.cpp b/velox/tool/trace/OrderByReplayer.cpp
new file mode 100644
index 000000000000..e6e44718cd64
--- /dev/null
+++ b/velox/tool/trace/OrderByReplayer.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/tool/trace/OrderByReplayer.h"
+#include "velox/exec/OperatorTraceReader.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::tool::trace {
+core::PlanNodePtr OrderByReplayer::createPlanNode(
+    const core::PlanNode* node,
+    const core::PlanNodeId& nodeId,
+    const core::PlanNodePtr& source) const {
+  const auto* orderByNode = dynamic_cast<const core::OrderByNode*>(node);
+  return std::make_shared<core::OrderByNode>(
+      nodeId,
+      orderByNode->sortingKeys(),
+      orderByNode->sortingOrders(),
+      orderByNode->isPartial(),
+      source);
+}
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/OrderByReplayer.h b/velox/tool/trace/OrderByReplayer.h
new file mode 100644
index 000000000000..825d6c8a5f1c
--- /dev/null
+++ b/velox/tool/trace/OrderByReplayer.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/PlanNode.h"
+#include "velox/tool/trace/OperatorReplayerBase.h"
+
+namespace facebook::velox::tool::trace {
+/// The replayer to replay the traced 'OrderBy' operator.
+class OrderByReplayer : public OperatorReplayerBase {
+ public:
+  OrderByReplayer(
+      const std::string& traceDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& operatorType,
+      const std::string& spillBaseDir,
+      const std::string& driverIds,
+      uint64_t queryCapacity,
+      folly::Executor* executor)
+      : OperatorReplayerBase(
+            traceDir,
+            queryId,
+            taskId,
+            nodeId,
+            operatorType,
+            spillBaseDir,
+            driverIds,
+            queryCapacity,
+            executor) {}
+
+ private:
+  core::PlanNodePtr createPlanNode(
+      const core::PlanNode* node,
+      const core::PlanNodeId& nodeId,
+      const core::PlanNodePtr& source) const override;
+};
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/PartitionedOutputReplayer.cpp b/velox/tool/trace/PartitionedOutputReplayer.cpp
index 48c7a6b1459d..37d07b1a0c9c 100644
--- a/velox/tool/trace/PartitionedOutputReplayer.cpp
+++ b/velox/tool/trace/PartitionedOutputReplayer.cpp
@@ -121,15 +121,13 @@ PartitionedOutputReplayer::PartitionedOutputReplayer(
           taskId,
           nodeId,
           operatorType,
+          "",
           driverIds,
           queryCapacity,
           executor),
-      originalNode_(dynamic_cast<const core::PartitionedOutputNode*>(
-          core::PlanNode::findFirstNode(
-              planFragment_.get(),
-              [this](const core::PlanNode* node) {
-                return node->id() == nodeId_;
-              }))),
+      originalNode_(
+          dynamic_cast<const core::PartitionedOutputNode*>(
+              core::PlanNode::findNodeById(planFragment_.get(), nodeId_))),
       serdeKind_(serdeKind),
       consumerCb_(consumerCb) {
   VELOX_CHECK_NOT_NULL(originalNode_);
@@ -144,7 +142,8 @@ RowVectorPtr PartitionedOutputReplayer::run(bool /*unused*/) {
       core::PlanFragment{createPlan()},
       0,
       createQueryContext(queryConfigs_, executor_.get()),
-      Task::ExecutionMode::kParallel);
+      Task::ExecutionMode::kParallel,
+      exec::Consumer{});
   task->start(driverIds_.size());
 
   consumeAllData(
diff --git a/velox/tool/trace/PartitionedOutputReplayer.h b/velox/tool/trace/PartitionedOutputReplayer.h
index 99a450bc3a90..f75d5c9beab0 100644
--- a/velox/tool/trace/PartitionedOutputReplayer.h
+++ b/velox/tool/trace/PartitionedOutputReplayer.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <folly/system/HardwareConcurrency.h>
 #include <utility>
 
 #include "velox/core/PlanNode.h"
@@ -66,7 +67,7 @@ class PartitionedOutputReplayer final : public OperatorReplayerBase {
       exec::OutputBufferManager::getInstanceRef()};
   const std::unique_ptr<folly::Executor> executor_{
       std::make_unique<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency(),
+          folly::hardware_concurrency(),
           std::make_shared<folly::NamedThreadFactory>("Driver"))};
   const ConsumerCallBack consumerCb_;
   std::unique_ptr<folly::CPUThreadPoolExecutor> consumerExecutor_;
diff --git a/velox/tool/trace/TableScanReplayer.cpp b/velox/tool/trace/TableScanReplayer.cpp
index 78dcc6612a81..89c421322c62 100644
--- a/velox/tool/trace/TableScanReplayer.cpp
+++ b/velox/tool/trace/TableScanReplayer.cpp
@@ -54,8 +54,9 @@ core::PlanNodePtr TableScanReplayer::createPlanNode(
 std::vector<exec::Split> TableScanReplayer::getSplits() const {
   std::vector<std::string> splitInfoDirs;
   for (const auto driverId : driverIds_) {
-    splitInfoDirs.push_back(exec::trace::getOpTraceDirectory(
-        nodeTraceDir_, pipelineIds_.front(), driverId));
+    splitInfoDirs.push_back(
+        exec::trace::getOpTraceDirectory(
+            nodeTraceDir_, pipelineIds_.front(), driverId));
   }
   const auto splitStrs =
       exec::trace::OperatorTraceSplitReader(
diff --git a/velox/tool/trace/TableScanReplayer.h b/velox/tool/trace/TableScanReplayer.h
index 58121851368b..4c31acdcac95 100644
--- a/velox/tool/trace/TableScanReplayer.h
+++ b/velox/tool/trace/TableScanReplayer.h
@@ -42,6 +42,7 @@ class TableScanReplayer final : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            "",
             driverIds,
             queryCapacity,
             executor) {}
diff --git a/velox/tool/trace/TableWriterReplayer.cpp b/velox/tool/trace/TableWriterReplayer.cpp
index 8644765b4e51..d17511f73bbe 100644
--- a/velox/tool/trace/TableWriterReplayer.cpp
+++ b/velox/tool/trace/TableWriterReplayer.cpp
@@ -33,7 +33,7 @@ makeHiveInsertTableHandle(
     const core::TableWriteNode* node,
     std::string targetDir) {
   const auto tracedHandle =
-      std::dynamic_pointer_cast<connector::hive::HiveInsertTableHandle>(
+      std::dynamic_pointer_cast<const connector::hive::HiveInsertTableHandle>(
           node->insertTableHandle()->connectorInsertTableHandle());
   const auto inputColumns = tracedHandle->inputColumns();
   const auto compressionKind =
@@ -78,10 +78,10 @@ core::PlanNodePtr TableWriterReplayer::createPlanNode(
       nodeId,
       tableWriterNode->columns(),
       tableWriterNode->columnNames(),
-      tableWriterNode->aggregationNode(),
+      tableWriterNode->columnStatsSpec(),
       insertTableHandle,
       tableWriterNode->hasPartitioningScheme(),
-      TableWriteTraits::outputType(tableWriterNode->aggregationNode()),
+      TableWriteTraits::outputType(tableWriterNode->columnStatsSpec()),
       tableWriterNode->commitStrategy(),
       source);
 }
diff --git a/velox/tool/trace/TableWriterReplayer.h b/velox/tool/trace/TableWriterReplayer.h
index 52563d5cc932..03ff2843a9f3 100644
--- a/velox/tool/trace/TableWriterReplayer.h
+++ b/velox/tool/trace/TableWriterReplayer.h
@@ -42,6 +42,7 @@ class TableWriterReplayer final : public OperatorReplayerBase {
             taskId,
             nodeId,
             operatorType,
+            "",
             driverIds,
             queryCapacity,
             executor),
diff --git a/velox/tool/trace/TopNRowNumberReplayer.cpp b/velox/tool/trace/TopNRowNumberReplayer.cpp
new file mode 100644
index 000000000000..13f4fc291c2b
--- /dev/null
+++ b/velox/tool/trace/TopNRowNumberReplayer.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 "velox/tool/trace/TopNRowNumberReplayer.h"
+#include "velox/common/Casts.h"
+#include "velox/exec/OperatorTraceReader.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::tool::trace {
+core::PlanNodePtr TopNRowNumberReplayer::createPlanNode(
+    const core::PlanNode* node,
+    const core::PlanNodeId& nodeId,
+    const core::PlanNodePtr& source) const {
+  const auto* topNRowNumberNode =
+      checkedPointerCast<const core::TopNRowNumberNode>(node);
+  const auto generateRowNumber = topNRowNumberNode->generateRowNumber();
+  return std::make_shared<core::TopNRowNumberNode>(
+      nodeId,
+      topNRowNumberNode->rankFunction(),
+      topNRowNumberNode->partitionKeys(),
+      topNRowNumberNode->sortingKeys(),
+      topNRowNumberNode->sortingOrders(),
+      generateRowNumber
+          ? std::make_optional(topNRowNumberNode->outputType()->names().back())
+          : std::nullopt,
+      topNRowNumberNode->limit(),
+      source);
+}
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/TopNRowNumberReplayer.h b/velox/tool/trace/TopNRowNumberReplayer.h
new file mode 100644
index 000000000000..93e4e8fed4e3
--- /dev/null
+++ b/velox/tool/trace/TopNRowNumberReplayer.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/PlanNode.h"
+#include "velox/tool/trace/OperatorReplayerBase.h"
+
+namespace facebook::velox::tool::trace {
+/// The replayer to replay the traced 'TopNRowNumber' operator.
+class TopNRowNumberReplayer : public OperatorReplayerBase {
+ public:
+  TopNRowNumberReplayer(
+      const std::string& traceDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& operatorType,
+      const std::string& spillBaseDir,
+      const std::string& driverIds,
+      uint64_t queryCapacity,
+      folly::Executor* executor)
+      : OperatorReplayerBase(
+            traceDir,
+            queryId,
+            taskId,
+            nodeId,
+            operatorType,
+            spillBaseDir,
+            driverIds,
+            queryCapacity,
+            executor) {}
+
+ private:
+  core::PlanNodePtr createPlanNode(
+      const core::PlanNode* node,
+      const core::PlanNodeId& nodeId,
+      const core::PlanNodePtr& source) const override;
+};
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/TraceReplayRunner.cpp b/velox/tool/trace/TraceReplayRunner.cpp
index e1f2b9580bbc..c1dcd913ad25 100644
--- a/velox/tool/trace/TraceReplayRunner.cpp
+++ b/velox/tool/trace/TraceReplayRunner.cpp
@@ -15,6 +15,7 @@
  */
 
 #include "velox/tool/trace/TraceReplayRunner.h"
+#include <folly/system/HardwareConcurrency.h>
 
 #include <gflags/gflags.h>
 
@@ -24,7 +25,6 @@
 #include "velox/connectors/hive/HiveConnector.h"
 #include "velox/connectors/hive/HiveConnectorSplit.h"
 #include "velox/connectors/hive/HiveDataSink.h"
-#include "velox/connectors/hive/TableHandle.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"
@@ -44,10 +44,15 @@
 #include "velox/tool/trace/AggregationReplayer.h"
 #include "velox/tool/trace/FilterProjectReplayer.h"
 #include "velox/tool/trace/HashJoinReplayer.h"
+#include "velox/tool/trace/IndexLookupJoinReplayer.h"
+#include "velox/tool/trace/MergeJoinReplayer.h"
 #include "velox/tool/trace/OperatorReplayerBase.h"
+#include "velox/tool/trace/OrderByReplayer.h"
 #include "velox/tool/trace/PartitionedOutputReplayer.h"
 #include "velox/tool/trace/TableScanReplayer.h"
 #include "velox/tool/trace/TableWriterReplayer.h"
+#include "velox/tool/trace/TopNRowNumberReplayer.h"
+#include "velox/tool/trace/UnnestReplayer.h"
 #include "velox/type/Type.h"
 
 #ifdef VELOX_ENABLE_PARQUET
@@ -104,6 +109,10 @@ DEFINE_string(
     function_prefix,
     "",
     "Prefix for the scalar and aggregate functions.");
+DEFINE_string(
+    spill_directory,
+    "",
+    "Base directory for spilling. If not specified, a local temporary directory will be used.");
 
 namespace facebook::velox::tool::trace {
 namespace {
@@ -231,20 +240,21 @@ void printSummary(
 } // namespace
 
 TraceReplayRunner::TraceReplayRunner()
-    : cpuExecutor_(std::make_unique<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency() *
-              FLAGS_driver_cpu_executor_hw_multiplier,
-          std::make_shared<folly::NamedThreadFactory>(
-              "TraceReplayCpuConnector"))),
-      ioExecutor_(std::make_unique<folly::IOThreadPoolExecutor>(
-          std::thread::hardware_concurrency() *
-              FLAGS_hive_connector_executor_hw_multiplier,
-          std::make_shared<folly::NamedThreadFactory>(
-              "TraceReplayIoConnector"))) {}
+    : cpuExecutor_(
+          std::make_unique<folly::CPUThreadPoolExecutor>(
+              folly::hardware_concurrency() *
+                  FLAGS_driver_cpu_executor_hw_multiplier,
+              std::make_shared<folly::NamedThreadFactory>(
+                  "TraceReplayCpuConnector"))),
+      ioExecutor_(
+          std::make_unique<folly::IOThreadPoolExecutor>(
+              folly::hardware_concurrency() *
+                  FLAGS_hive_connector_executor_hw_multiplier,
+              std::make_shared<folly::NamedThreadFactory>(
+                  "TraceReplayIoConnector"))) {}
 
 void TraceReplayRunner::init() {
   VELOX_USER_CHECK(!FLAGS_root_dir.empty(), "--root_dir must be provided");
-  VELOX_USER_CHECK(!FLAGS_query_id.empty(), "--query_id must be provided");
   VELOX_USER_CHECK(!FLAGS_node_id.empty(), "--node_id must be provided");
 
   if (!memory::MemoryManager::testInstance()) {
@@ -270,6 +280,7 @@ void TraceReplayRunner::init() {
 #endif
 
   core::PlanNode::registerSerDe();
+  velox::exec::trace::registerDummySourceSerDe();
   core::ITypedExpr::registerSerDe();
   common::Filter::registerSerDe();
   Type::registerSerDe();
@@ -286,24 +297,13 @@ void TraceReplayRunner::init() {
   if (!isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
     serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
   }
-  connector::hive::HiveTableHandle::registerSerDe();
-  connector::hive::LocationHandle::registerSerDe();
-  connector::hive::HiveColumnHandle::registerSerDe();
-  connector::hive::HiveInsertTableHandle::registerSerDe();
-  connector::hive::HiveInsertFileNameGenerator::registerSerDe();
-  connector::hive::HiveConnectorSplit::registerSerDe();
-  connector::hive::registerHivePartitionFunctionSerDe();
-  connector::hive::HiveBucketProperty::registerSerDe();
+
+  connector::hive::HiveConnector::registerSerDe();
 
   functions::prestosql::registerAllScalarFunctions(FLAGS_function_prefix);
   aggregate::prestosql::registerAllAggregateFunctions(FLAGS_function_prefix);
   parse::registerTypeResolver();
 
-  if (!facebook::velox::connector::hasConnectorFactory("hive")) {
-    connector::registerConnectorFactory(
-        std::make_shared<connector::hive::HiveConnectorFactory>());
-  }
-
   fs_ = filesystems::getFileSystem(FLAGS_root_dir, nullptr);
   const auto taskTraceDir = exec::trace::getTaskTraceDirectory(
       FLAGS_root_dir, FLAGS_query_id, FLAGS_task_id);
@@ -340,6 +340,7 @@ TraceReplayRunner::createReplayer() const {
         FLAGS_task_id,
         FLAGS_node_id,
         traceNodeName,
+        FLAGS_spill_directory,
         FLAGS_driver_ids,
         queryCapacityBytes,
         cpuExecutor_.get());
@@ -357,14 +358,15 @@ TraceReplayRunner::createReplayer() const {
   } else if (traceNodeName == "TableScan") {
     const auto connectorId =
         taskTraceMetadataReader_->connectorId(FLAGS_node_id);
-    if (const auto& collectors = connector::getAllConnectors();
-        collectors.find(connectorId) == collectors.end()) {
-      const auto hiveConnector =
-          connector::getConnectorFactory("hive")->newConnector(
-              connectorId,
-              std::make_shared<config::ConfigBase>(
-                  std::unordered_map<std::string, std::string>()),
-              ioExecutor_.get());
+    VELOX_CHECK(connectorId.has_value());
+
+    if (!connector::hasConnector(connectorId.value())) {
+      connector::hive::HiveConnectorFactory factory;
+      const auto hiveConnector = factory.newConnector(
+          connectorId.value(),
+          std::make_shared<config::ConfigBase>(
+              std::unordered_map<std::string, std::string>()),
+          ioExecutor_.get());
       connector::registerConnector(hiveConnector);
     }
     replayer = std::make_unique<tool::trace::TableScanReplayer>(
@@ -393,6 +395,60 @@ TraceReplayRunner::createReplayer() const {
         FLAGS_task_id,
         FLAGS_node_id,
         traceNodeName,
+        FLAGS_spill_directory,
+        FLAGS_driver_ids,
+        queryCapacityBytes,
+        cpuExecutor_.get());
+  } else if (traceNodeName == "IndexLookupJoin") {
+    replayer = std::make_unique<tool::trace::IndexLookupJoinReplayer>(
+        FLAGS_root_dir,
+        FLAGS_query_id,
+        FLAGS_task_id,
+        FLAGS_node_id,
+        traceNodeName,
+        FLAGS_driver_ids,
+        queryCapacityBytes,
+        cpuExecutor_.get());
+  } else if (traceNodeName == "MergeJoin") {
+    replayer = std::make_unique<tool::trace::MergeJoinReplayer>(
+        FLAGS_root_dir,
+        FLAGS_query_id,
+        FLAGS_task_id,
+        FLAGS_node_id,
+        traceNodeName,
+        FLAGS_spill_directory,
+        FLAGS_driver_ids,
+        queryCapacityBytes,
+        cpuExecutor_.get());
+  } else if (traceNodeName == "Unnest") {
+    replayer = std::make_unique<tool::trace::UnnestReplayer>(
+        FLAGS_root_dir,
+        FLAGS_query_id,
+        FLAGS_task_id,
+        FLAGS_node_id,
+        traceNodeName,
+        FLAGS_driver_ids,
+        queryCapacityBytes,
+        cpuExecutor_.get());
+  } else if (traceNodeName == "OrderBy") {
+    replayer = std::make_unique<tool::trace::OrderByReplayer>(
+        FLAGS_root_dir,
+        FLAGS_query_id,
+        FLAGS_task_id,
+        FLAGS_node_id,
+        traceNodeName,
+        FLAGS_spill_directory,
+        FLAGS_driver_ids,
+        queryCapacityBytes,
+        cpuExecutor_.get());
+  } else if (traceNodeName == "TopNRowNumber") {
+    replayer = std::make_unique<tool::trace::TopNRowNumberReplayer>(
+        FLAGS_root_dir,
+        FLAGS_query_id,
+        FLAGS_task_id,
+        FLAGS_node_id,
+        traceNodeName,
+        FLAGS_spill_directory,
         FLAGS_driver_ids,
         queryCapacityBytes,
         cpuExecutor_.get());
diff --git a/velox/tool/trace/TraceReplayRunner.h b/velox/tool/trace/TraceReplayRunner.h
index 833a5ff410c9..c38cfa1415e0 100644
--- a/velox/tool/trace/TraceReplayRunner.h
+++ b/velox/tool/trace/TraceReplayRunner.h
@@ -57,7 +57,8 @@ class TraceReplayRunner {
   virtual void run();
 
  protected:
-  std::unique_ptr<tool::trace::OperatorReplayerBase> createReplayer() const;
+  virtual std::unique_ptr<tool::trace::OperatorReplayerBase> createReplayer()
+      const;
 
   const std::unique_ptr<folly::CPUThreadPoolExecutor> cpuExecutor_;
   const std::unique_ptr<folly::IOThreadPoolExecutor> ioExecutor_;
diff --git a/velox/tool/trace/TraceReplayerMain.cpp b/velox/tool/trace/TraceReplayerMain.cpp
index cfca543a04fa..eda0e5745fbe 100644
--- a/velox/tool/trace/TraceReplayerMain.cpp
+++ b/velox/tool/trace/TraceReplayerMain.cpp
@@ -16,10 +16,11 @@
 
 #include "velox/tool/trace/TraceReplayRunner.h"
 
+#include <folly/init/Init.h>
 #include <gflags/gflags.h>
 
 int main(int argc, char** argv) {
-  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  folly::Init init(&argc, &argv);
 
   facebook::velox::tool::trace::TraceReplayRunner runner;
   runner.init();
diff --git a/velox/tool/trace/UnnestReplayer.cpp b/velox/tool/trace/UnnestReplayer.cpp
new file mode 100644
index 000000000000..b9d98a87a885
--- /dev/null
+++ b/velox/tool/trace/UnnestReplayer.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/tool/trace/UnnestReplayer.h"
+
+#include "velox/exec/TraceUtil.h"
+#include "velox/exec/tests/utils/PlanBuilder.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::exec;
+using namespace facebook::velox::exec::test;
+
+namespace facebook::velox::tool::trace {
+core::PlanNodePtr UnnestReplayer::createPlanNode(
+    const core::PlanNode* node,
+    const core::PlanNodeId& nodeId,
+    const core::PlanNodePtr& source) const {
+  const auto* unnestNode = dynamic_cast<const core::UnnestNode*>(node);
+  VELOX_CHECK_NOT_NULL(unnestNode);
+  return std::make_shared<core::UnnestNode>(
+      nodeId,
+      unnestNode->replicateVariables(),
+      unnestNode->unnestVariables(),
+      unnestNode->unnestNames(),
+      unnestNode->ordinalityName(),
+      unnestNode->markerName(),
+      source);
+}
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/UnnestReplayer.h b/velox/tool/trace/UnnestReplayer.h
new file mode 100644
index 000000000000..9dfacb820ee8
--- /dev/null
+++ b/velox/tool/trace/UnnestReplayer.h
@@ -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.
+ */
+
+#pragma once
+
+#include "velox/core/PlanNode.h"
+#include "velox/tool/trace/OperatorReplayerBase.h"
+
+namespace facebook::velox::tool::trace {
+/// The replayer to replay the traced 'IndexLookupJoin' operator.
+class UnnestReplayer : public OperatorReplayerBase {
+ public:
+  UnnestReplayer(
+      const std::string& traceDir,
+      const std::string& queryId,
+      const std::string& taskId,
+      const std::string& nodeId,
+      const std::string& operatorType,
+      const std::string& driverIds,
+      uint64_t queryCapacity,
+      folly::Executor* executor)
+      : OperatorReplayerBase(
+            traceDir,
+            queryId,
+            taskId,
+            nodeId,
+            operatorType,
+            "",
+            driverIds,
+            queryCapacity,
+            executor) {}
+
+ private:
+  core::PlanNodePtr createPlanNode(
+      const core::PlanNode* node,
+      const core::PlanNodeId& nodeId,
+      const core::PlanNodePtr& source) const override;
+};
+} // namespace facebook::velox::tool::trace
diff --git a/velox/tool/trace/tests/AggregationReplayerTest.cpp b/velox/tool/trace/tests/AggregationReplayerTest.cpp
index d31fc3258e2d..0f750921bc67 100644
--- a/velox/tool/trace/tests/AggregationReplayerTest.cpp
+++ b/velox/tool/trace/tests/AggregationReplayerTest.cpp
@@ -25,6 +25,7 @@
 #include "velox/common/file/FileSystems.h"
 #include "velox/common/hyperloglog/SparseHll.h"
 #include "velox/common/testutil/TestValue.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/dwio/dwrf/writer/Writer.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/TableWriter.h"
@@ -66,12 +67,9 @@ class AggregationReplayerTest : public HiveConnectorTestBase {
     }
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveInsertFileNameGenerator::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
   }
@@ -262,7 +260,7 @@ TEST_F(AggregationReplayerTest, hashAggregationTest) {
               .config(core::QueryConfig::kQueryTraceDir, traceRoot)
               .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
               .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-              .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+              .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
               .split(makeHiveConnectorSplit(sourceFilePath->getPath()))
               .copyResults(pool(), task);
 
@@ -273,6 +271,7 @@ TEST_F(AggregationReplayerTest, hashAggregationTest) {
                                        traceNodeId_,
                                        "Aggregation",
                                        "",
+                                       "",
                                        0,
                                        executor_.get())
                                        .run();
@@ -328,7 +327,7 @@ TEST_F(AggregationReplayerTest, streamingAggregateTest) {
               .config(core::QueryConfig::kQueryTraceDir, traceRoot)
               .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
               .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-              .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+              .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
               .split(makeHiveConnectorSplit(sourceFilePath->getPath()))
               .copyResults(pool(), task);
 
@@ -339,6 +338,7 @@ TEST_F(AggregationReplayerTest, streamingAggregateTest) {
                                        traceNodeId_,
                                        "Aggregation",
                                        "",
+                                       "",
                                        0,
                                        executor_.get())
                                        .run();
diff --git a/velox/tool/trace/tests/CMakeLists.txt b/velox/tool/trace/tests/CMakeLists.txt
index 6715825eb8c6..f2a38b80142b 100644
--- a/velox/tool/trace/tests/CMakeLists.txt
+++ b/velox/tool/trace/tests/CMakeLists.txt
@@ -17,15 +17,22 @@ add_executable(
   AggregationReplayerTest.cpp
   FilterProjectReplayerTest.cpp
   HashJoinReplayerTest.cpp
+  IndexLookupJoinReplayerTest.cpp
+  MergeJoinReplayerTest.cpp
+  OrderByReplayerTest.cpp
   PartitionedOutputReplayerTest.cpp
-  TraceFileToolTest.cpp
   TableScanReplayerTest.cpp
-  TableWriterReplayerTest.cpp)
+  TableWriterReplayerTest.cpp
+  TopNRowNumberReplayerTest.cpp
+  TraceFileToolTest.cpp
+  UnnestReplayerTest.cpp
+)
 
 add_test(
   NAME velox_tool_trace_test
   COMMAND velox_tool_trace_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 set_tests_properties(velox_tool_trace_test PROPERTIES TIMEOUT 3000)
 
@@ -42,4 +49,5 @@ target_link_libraries(
   Folly::folly
   gflags::gflags
   glog::glog
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/tool/trace/tests/FilterProjectReplayerTest.cpp b/velox/tool/trace/tests/FilterProjectReplayerTest.cpp
index d314c538f9a0..9c4ff740fabb 100644
--- a/velox/tool/trace/tests/FilterProjectReplayerTest.cpp
+++ b/velox/tool/trace/tests/FilterProjectReplayerTest.cpp
@@ -23,13 +23,9 @@
 #include <folly/experimental/EventCount.h>
 
 #include "velox/common/file/FileSystems.h"
-#include "velox/common/hyperloglog/SparseHll.h"
-#include "velox/common/testutil/TestValue.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/PartitionFunction.h"
-#include "velox/exec/TableWriter.h"
 #include "velox/exec/TraceUtil.h"
-#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -37,11 +33,6 @@
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/FilterProjectReplayer.h"
 
-#include "velox/common/file/Utils.h"
-#include "velox/exec/PlanNodeStats.h"
-
-#include "velox/vector/tests/utils/VectorTestBase.h"
-
 using namespace facebook::velox;
 using namespace facebook::velox::core;
 using namespace facebook::velox::common;
@@ -54,6 +45,7 @@ using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::common::hll;
 
 namespace facebook::velox::tool::trace::test {
+namespace {
 class FilterProjectReplayerTest : public HiveConnectorTestBase {
  protected:
   static void SetUpTestCase() {
@@ -65,13 +57,9 @@ class FilterProjectReplayerTest : public HiveConnectorTestBase {
     }
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveInsertFileNameGenerator::registerSerDe();
-    connector::hive::HiveConnectorSplit::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
   }
@@ -179,9 +167,7 @@ TEST_F(FilterProjectReplayerTest, filterProject) {
         .config(core::QueryConfig::kQueryTraceDir, traceRoot)
         .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
         .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-        .config(
-            core::QueryConfig::kQueryTraceNodeIds,
-            fmt::format("{},{}", filterNodeId_, projectNodeId_));
+        .config(core::QueryConfig::kQueryTraceNodeId, projectNodeId_);
     auto traceResult = traceBuilder.splits(tracePlanWithSplits.splits)
                            .copyResults(pool(), task);
 
@@ -216,9 +202,7 @@ TEST_F(FilterProjectReplayerTest, filterOnly) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(
-          core::QueryConfig::kQueryTraceNodeIds,
-          fmt::format("{},{}", filterNodeId_, projectNodeId_));
+      .config(core::QueryConfig::kQueryTraceNodeId, filterNodeId_);
   auto traceResult =
       traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
 
@@ -252,9 +236,7 @@ TEST_F(FilterProjectReplayerTest, projectOnly) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(
-          core::QueryConfig::kQueryTraceNodeIds,
-          fmt::format("{},{}", filterNodeId_, projectNodeId_));
+      .config(core::QueryConfig::kQueryTraceNodeId, projectNodeId_);
   auto traceResult =
       traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
 
@@ -321,4 +303,40 @@ TEST_F(FilterProjectReplayerTest, projectOnly) {
                          .run();
   ASSERT_EQ(emptyResult->size(), 0);
 }
+
+TEST_F(FilterProjectReplayerTest, dryRun) {
+  const auto planWithSplits = createPlan(PlanMode::FilterOnly);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  std::shared_ptr<Task> task;
+  auto result = builder.splits(planWithSplits.splits).copyResults(pool(), task);
+  ASSERT_EQ(result->size(), 1780);
+
+  const auto traceRoot = fmt::format("{}/{}", testDir_->getPath(), "filter");
+  const auto tracePlanWithSplits = createPlan(PlanMode::FilterOnly);
+  std::shared_ptr<Task> taskWithTrace;
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(4)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, filterNodeId_)
+      .config(core::QueryConfig::kQueryTraceDryRun, true);
+  auto traceResult = traceBuilder.splits(tracePlanWithSplits.splits)
+                         .copyResults(pool(), taskWithTrace);
+  ASSERT_EQ(traceResult->size(), 0);
+
+  auto replayingResult = FilterProjectReplayer(
+                             traceRoot,
+                             taskWithTrace->queryCtx()->queryId(),
+                             taskWithTrace->taskId(),
+                             filterNodeId_,
+                             "FilterProject",
+                             "",
+                             0,
+                             executor_.get())
+                             .run();
+  assertEqualResults({result}, {replayingResult});
+}
+} // namespace
 } // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/HashJoinReplayerTest.cpp b/velox/tool/trace/tests/HashJoinReplayerTest.cpp
index f3328963b612..814fa67633ee 100644
--- a/velox/tool/trace/tests/HashJoinReplayerTest.cpp
+++ b/velox/tool/trace/tests/HashJoinReplayerTest.cpp
@@ -21,18 +21,15 @@
 
 #include <folly/experimental/EventCount.h>
 
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/common/file/Utils.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
-#include "velox/common/hyperloglog/SparseHll.h"
 #include "velox/common/testutil/TestValue.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/PlanNodeStats.h"
-#include "velox/exec/TableWriter.h"
 #include "velox/exec/TraceUtil.h"
-#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -40,7 +37,6 @@
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/HashJoinReplayer.h"
 #include "velox/tool/trace/TraceReplayRunner.h"
-#include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::core;
@@ -66,13 +62,9 @@ class HashJoinReplayerTest : public HiveConnectorTestBase {
     }
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveInsertFileNameGenerator::registerSerDe();
-    connector::hive::HiveConnectorSplit::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
   }
@@ -222,7 +214,7 @@ TEST_F(HashJoinReplayerTest, basic) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_);
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_);
   for (const auto& [planNodeId, nodeSplits] : tracePlanWithSplits.splits) {
     traceBuilder.splits(planNodeId, nodeSplits);
   }
@@ -237,8 +229,9 @@ TEST_F(HashJoinReplayerTest, basic) {
                                    task->taskId(),
                                    traceNodeId_,
                                    "HashJoin",
-                                   "",
-                                   0,
+                                   /*spillBaseDir=*/"",
+                                   /*driverIds=*/"",
+                                   /*queryCapacity=*/0,
                                    executor_.get())
                                    .run();
   assertEqualResults({result}, {replayingResult});
@@ -278,7 +271,7 @@ TEST_F(HashJoinReplayerTest, partialDriverIds) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_);
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_);
   for (const auto& [planNodeId, nodeSplits] : tracePlanWithSplits.splits) {
     traceBuilder.splits(planNodeId, nodeSplits);
   }
@@ -309,6 +302,7 @@ TEST_F(HashJoinReplayerTest, partialDriverIds) {
             task->taskId(),
             traceNodeId_,
             "HashJoin",
+            "",
             "0",
             0,
             executor_.get())
@@ -321,6 +315,7 @@ TEST_F(HashJoinReplayerTest, partialDriverIds) {
       task->taskId(),
       traceNodeId_,
       "HashJoin",
+      "",
       "1,3",
       0,
       executor_.get())
@@ -344,7 +339,7 @@ TEST_F(HashJoinReplayerTest, runner) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_);
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_);
   for (const auto& [planNodeId, nodeSplits] : tracePlanWithSplits.splits) {
     traceBuilder.splits(planNodeId, nodeSplits);
   }
@@ -447,7 +442,7 @@ DEBUG_ONLY_TEST_F(HashJoinReplayerTest, hashBuildSpill) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
       .config(core::QueryConfig::kSpillEnabled, true)
       .config(core::QueryConfig::kJoinSpillEnabled, true)
       .spillDirectory(spillDir);
@@ -476,6 +471,7 @@ DEBUG_ONLY_TEST_F(HashJoinReplayerTest, hashBuildSpill) {
                                    traceNodeId_,
                                    "HashJoin",
                                    "",
+                                   "",
                                    0,
                                    executor_.get())
                                    .run();
@@ -528,7 +524,7 @@ DEBUG_ONLY_TEST_F(HashJoinReplayerTest, hashProbeSpill) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
       .config(core::QueryConfig::kSpillEnabled, true)
       .config(core::QueryConfig::kJoinSpillEnabled, true)
       .spillDirectory(spillDir);
@@ -558,6 +554,7 @@ DEBUG_ONLY_TEST_F(HashJoinReplayerTest, hashProbeSpill) {
                                    traceNodeId_,
                                    "HashJoin",
                                    "",
+                                   "",
                                    0,
                                    executor_.get())
                                    .run();
diff --git a/velox/tool/trace/tests/IndexLookupJoinReplayerTest.cpp b/velox/tool/trace/tests/IndexLookupJoinReplayerTest.cpp
new file mode 100644
index 000000000000..cf0492ed7616
--- /dev/null
+++ b/velox/tool/trace/tests/IndexLookupJoinReplayerTest.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 <boost/random/uniform_int_distribution.hpp>
+#include <gtest/gtest.h>
+
+#include <string>
+
+#include <folly/experimental/EventCount.h>
+
+#include "velox/common/file/tests/FaultyFileSystem.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/TraceUtil.h"
+#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 "velox/exec/tests/utils/TestIndexStorageConnector.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/tool/trace/IndexLookupJoinReplayer.h"
+
+using namespace facebook::velox;
+using namespace facebook::velox::core;
+using namespace facebook::velox::common;
+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::common::testutil;
+using namespace facebook::velox::common::hll;
+using namespace facebook::velox::tests::utils;
+
+namespace facebook::velox::tool::trace::test {
+class IndexLookupJoinReplayerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    HiveConnectorTestBase::SetUpTestCase();
+    registerFaultyFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
+    core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+    auto connectorCpuExecutor =
+        std::make_unique<folly::CPUThreadPoolExecutor>(128);
+    TestIndexConnectorFactory::registerConnector(connectorCpuExecutor.get());
+    TestIndexTableHandle::registerSerDe();
+    TestIndexColumnHandle::registerSerDe();
+  }
+
+  void TearDown() override {
+    probeInput_.clear();
+    indexInput_.clear();
+    HiveConnectorTestBase::TearDown();
+    connector::unregisterConnector(kTestIndexConnectorName);
+  }
+
+  // Create index table with the given key and value inputs.
+  std::shared_ptr<TestIndexTable> createIndexTable(
+      int numEqualJoinKeys,
+      const RowVectorPtr& keyData,
+      const RowVectorPtr& valueData) {
+    const auto keyType =
+        std::dynamic_pointer_cast<const RowType>(keyData->type());
+    VELOX_CHECK_GE(keyType->size(), 1);
+    VELOX_CHECK_GE(keyType->size(), numEqualJoinKeys);
+    auto valueType =
+        std::dynamic_pointer_cast<const RowType>(valueData->type());
+    VELOX_CHECK_GE(valueType->size(), 1);
+    const auto numRows = keyData->size();
+    VELOX_CHECK_EQ(numRows, valueData->size());
+
+    std::vector<std::unique_ptr<VectorHasher>> hashers;
+    hashers.reserve(numEqualJoinKeys);
+    std::vector<VectorPtr> keyVectors;
+    keyVectors.reserve(numEqualJoinKeys);
+    for (auto i = 0; i < numEqualJoinKeys; ++i) {
+      hashers.push_back(std::make_unique<VectorHasher>(keyType->childAt(i), i));
+      keyVectors.push_back(keyData->childAt(i));
+    }
+
+    std::vector<TypePtr> dependentTypes;
+    std::vector<VectorPtr> dependentVectors;
+    for (int i = numEqualJoinKeys; i < keyType->size(); ++i) {
+      dependentTypes.push_back(keyType->childAt(i));
+      dependentVectors.push_back(keyData->childAt(i));
+    }
+    for (int i = 0; i < valueType->size(); ++i) {
+      dependentTypes.push_back(valueType->childAt(i));
+      dependentVectors.push_back(valueData->childAt(i));
+    }
+
+    // Create the table.
+    auto table = HashTable<false>::createForJoin(
+        std::move(hashers),
+        /*dependentTypes=*/dependentTypes,
+        /*allowDuplicates=*/true,
+        /*hasProbedFlag=*/false,
+        /*minTableSizeForParallelJoinBuild=*/1,
+        pool_.get());
+
+    // Insert data into the row container.
+    auto* rowContainer = table->rows();
+    std::vector<DecodedVector> decodedVectors;
+    for (auto& vector : keyData->children()) {
+      decodedVectors.emplace_back(*vector);
+    }
+    for (auto& vector : valueData->children()) {
+      decodedVectors.emplace_back(*vector);
+    }
+
+    for (auto row = 0; row < numRows; ++row) {
+      auto* newRow = rowContainer->newRow();
+
+      for (auto col = 0; col < decodedVectors.size(); ++col) {
+        rowContainer->store(decodedVectors[col], row, newRow, col);
+      }
+    }
+
+    // Build the table index.
+    table->prepareJoinTable(
+        {}, BaseHashTable::kNoSpillInputStartPartitionBit, 1'000'000);
+    return std::make_shared<TestIndexTable>(
+        keyType, std::move(valueType), std::move(table));
+  }
+
+  // Makes index table handle with the specified index table and async lookup
+  // flag.
+  static std::shared_ptr<TestIndexTableHandle> makeIndexTableHandle(
+      const std::shared_ptr<TestIndexTable>& indexTable) {
+    return std::make_shared<TestIndexTableHandle>(
+        kTestIndexConnectorName, indexTable, /*asyncLookup*/ false);
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId indexScanId;
+    std::unordered_map<core::PlanNodeId, std::vector<exec::Split>> splits;
+
+    explicit PlanWithSplits(
+        const core::PlanNodePtr& _plan,
+        const core::PlanNodeId& _probeScanId = "",
+        const core::PlanNodeId& _indexScanId = "",
+        const std::unordered_map<
+            core::PlanNodeId,
+            std::vector<velox::exec::Split>>& _splits = {})
+        : plan(_plan),
+          probeScanId(_probeScanId),
+          indexScanId(_indexScanId),
+          splits(_splits) {}
+  };
+
+  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));
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(int32_t count, int32_t rowsPerVector, const RowTypePtr& rowType) {
+    return HiveConnectorTestBase::makeVectors(rowType, count, rowsPerVector);
+  }
+
+  std::vector<Split> makeSplits(
+      const std::vector<RowVectorPtr>& inputs,
+      const std::string& path,
+      memory::MemoryPool* writerPool) {
+    std::vector<Split> splits;
+    for (auto i = 0; i < 4; ++i) {
+      const std::string filePath = fmt::format("{}/{}", path, i);
+      writeToFile(filePath, inputs);
+      splits.emplace_back(makeHiveConnectorSplit(filePath));
+    }
+
+    return splits;
+  }
+
+  core::PlanNodeId traceNodeId_;
+  RowTypePtr probeType_{
+      ROW({"t0", "t1", "t2", "t3"}, {BIGINT(), VARCHAR(), SMALLINT(), REAL()})};
+
+  RowTypePtr indexType_{
+      ROW({"u0", "u1", "u2", "u3"},
+          {BIGINT(), INTEGER(), SMALLINT(), VARCHAR()})};
+  std::vector<RowVectorPtr> probeInput_ = makeVectors(5, 100, probeType_);
+  std::vector<RowVectorPtr> indexInput_ = makeVectors(3, 100, indexType_);
+
+  const std::vector<std::string> leftKeys{"t0"};
+  const std::vector<std::string> rightKeys{"u0"};
+  const std::shared_ptr<TempDirectoryPath> testDir_ =
+      TempDirectoryPath::create();
+  const std::string tableDir_ =
+      fmt::format("{}/{}", testDir_->getPath(), "table");
+  const std::unique_ptr<folly::CPUThreadPoolExecutor> connectorCpuExecutor_{
+      std::make_unique<folly::CPUThreadPoolExecutor>(128)};
+};
+
+TEST_F(IndexLookupJoinReplayerTest, test) {
+  // Create a plan with a table scan and an index lookup join
+  auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+  core::PlanNodeId probeScanId;
+
+  // Create a TestIndexTable for the index side
+  const auto indexTable = createIndexTable(
+      /*numEqualJoinKeys=*/1,
+      makeRowVector(
+          indexType_->names(),
+          {makeFlatVector<int64_t>({1, 2, 3}),
+           makeFlatVector<int32_t>({10, 20, 30}),
+           makeFlatVector<int16_t>({100, 200, 300}),
+           makeFlatVector<StringView>({"a", "b", "c"})}),
+      makeRowVector(
+          {"u4", "u5"},
+          {makeFlatVector<int64_t>({1000, 2000, 3000}),
+           makeFlatVector<StringView>({"x", "y", "z"})}));
+
+  // Create a TestIndexTableHandle with the TestIndexTable
+  auto indexTableHandle = makeIndexTableHandle(indexTable);
+
+  // Create a table scan node with the TestIndexTableHandle
+  connector::ColumnHandleMap columnHandles;
+  for (const auto& name : indexType_->names()) {
+    columnHandles[name] = std::make_shared<TestIndexColumnHandle>(name);
+  }
+
+  auto indexScan = std::make_shared<core::TableScanNode>(
+      planNodeIdGenerator->next(), indexType_, indexTableHandle, columnHandles);
+
+  auto plan =
+      PlanBuilder(planNodeIdGenerator)
+          .tableScan(probeType_)
+          .capturePlanNodeId(probeScanId)
+          .indexLookupJoin(
+              leftKeys,
+              rightKeys,
+              std::dynamic_pointer_cast<const core::TableScanNode>(indexScan),
+              /*joinConditions=*/{},
+              /*filter=*/"",
+              /*hasMarker=*/false,
+              concat(probeType_, indexType_)->names(),
+              core::JoinType::kInner)
+          .capturePlanNodeId(traceNodeId_)
+          .planNode();
+
+  // Create a trace directory
+  const auto testDir = TempDirectoryPath::create();
+  const auto traceRoot = fmt::format("{}/{}", testDir->getPath(), "traceRoot");
+  std::shared_ptr<Task> task;
+
+  // Create a file for the probe data
+  const auto sourceFilePath = TempFilePath::create();
+  writeToFile(sourceFilePath->getPath(), probeInput_);
+
+  // Run the query with tracing enabled
+  auto results =
+      AssertQueryBuilder(plan)
+          .config(core::QueryConfig::kQueryTraceEnabled, true)
+          .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+          .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+          .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+          .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
+          .splits(
+              probeScanId,
+              {Split(makeHiveConnectorSplit(sourceFilePath->getPath()))})
+          .copyResults(pool(), task);
+
+  // Run the replayer
+  const auto replayingResult = IndexLookupJoinReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   traceNodeId_,
+                                   "IndexLookupJoin",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({results}, {replayingResult});
+}
+
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/MergeJoinReplayerTest.cpp b/velox/tool/trace/tests/MergeJoinReplayerTest.cpp
new file mode 100644
index 000000000000..0b695a860268
--- /dev/null
+++ b/velox/tool/trace/tests/MergeJoinReplayerTest.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 <gtest/gtest.h>
+
+#include <string>
+
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/dwio/common/tests/utils/BatchMaker.h"
+#include "velox/exec/OperatorTraceReader.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/TraceUtil.h"
+#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 "velox/serializers/PrestoSerializer.h"
+#include "velox/tool/trace/MergeJoinReplayer.h"
+#include "velox/tool/trace/TraceReplayRunner.h"
+
+// using namespace facebook::velox;
+// using namespace facebook::velox::core;
+// using namespace facebook::velox::common;
+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::common::testutil;
+// using namespace facebook::velox::common::hll;
+
+namespace facebook::velox::tool::trace::test {
+class MergeJoinReplayerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    HiveConnectorTestBase::SetUpTestCase();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
+    core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  void TearDown() override {
+    probeInput_.clear();
+    buildInput_.clear();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    std::unordered_map<core::PlanNodeId, std::vector<exec::Split>> splits;
+
+    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 = {})
+        : plan(_plan),
+          probeScanId(_probeScanId),
+          buildScanId(_buildScanId),
+          splits(_splits) {}
+  };
+
+  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));
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(int32_t count, int32_t rowsPerVector, const RowTypePtr& rowType) {
+    std::vector<RowVectorPtr> vectors;
+    vectors.reserve(count);
+
+    for (int32_t i = 0; i < count; ++i) {
+      const int32_t startRow = i * rowsPerVector;
+      std::vector<VectorPtr> children;
+
+      for (int32_t col = 0; col < rowType->size(); ++col) {
+        const auto& type = rowType->childAt(col);
+
+        // First column is the join key and must be sorted
+        if (col == 0) {
+          if (type->kind() == TypeKind::BIGINT) {
+            children.push_back(
+                makeFlatVector<int64_t>(rowsPerVector, [startRow](auto row) {
+                  return startRow + row;
+                }));
+          } else {
+            VELOX_FAIL("Unsupported join key type: {}", type->toString());
+          }
+        } else {
+          // Other columns can have random data using BatchMaker
+          children.push_back(VELOX_DYNAMIC_TYPE_DISPATCH(
+              velox::test::BatchMaker::createVector,
+              type->kind(),
+              type,
+              rowsPerVector,
+              *pool()));
+        }
+      }
+
+      vectors.push_back(makeRowVector(rowType->names(), children));
+    }
+
+    return vectors;
+  }
+
+  std::vector<Split> makeSplits(
+      const std::vector<RowVectorPtr>& inputs,
+      const std::string& path,
+      memory::MemoryPool* writerPool) {
+    std::vector<Split> splits;
+    for (auto i = 0; i < 4; ++i) {
+      const std::string filePath = fmt::format("{}/{}", path, i);
+      writeToFile(filePath, inputs);
+      splits.emplace_back(makeHiveConnectorSplit(filePath));
+    }
+
+    return splits;
+  }
+
+  PlanWithSplits createPlan(
+      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) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    const std::vector<Split> probeSplits =
+        makeSplits(probeInput, fmt::format("{}/probe", tableDir), pool());
+    const std::vector<Split> buildSplits =
+        makeSplits(buildInput, fmt::format("{}/build", tableDir), pool());
+    core::PlanNodeId probeScanId;
+    core::PlanNodeId buildScanId;
+    const auto outputColumns = concat(
+                                   asRowType(buildInput_[0]->type()),
+                                   asRowType(probeInput_[0]->type()))
+                                   ->names();
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(probeType_)
+                    .capturePlanNodeId(probeScanId)
+                    .mergeJoin(
+                        probeKeys,
+                        buildKeys,
+                        PlanBuilder(planNodeIdGenerator)
+                            .tableScan(buildType_)
+                            .capturePlanNodeId(buildScanId)
+                            .planNode(),
+                        /*filter=*/"",
+                        outputColumns,
+                        joinType)
+                    .capturePlanNodeId(traceNodeId_)
+                    .planNode();
+    return PlanWithSplits{
+        plan,
+        probeScanId,
+        buildScanId,
+        {{probeScanId, probeSplits}, {buildScanId, buildSplits}}};
+  }
+
+  core::PlanNodeId traceNodeId_;
+  RowTypePtr probeType_{
+      ROW({"t0", "t1", "t2", "t3"}, {BIGINT(), VARCHAR(), SMALLINT(), REAL()})};
+
+  RowTypePtr buildType_{
+      ROW({"u0", "u1", "u2", "u3"},
+          {BIGINT(), INTEGER(), SMALLINT(), VARCHAR()})};
+  std::vector<RowVectorPtr> probeInput_ = makeVectors(5, 100, probeType_);
+  std::vector<RowVectorPtr> buildInput_ = makeVectors(3, 100, buildType_);
+
+  const std::vector<std::string> probeKeys_{"t0"};
+  const std::vector<std::string> buildKeys_{"u0"};
+  const std::shared_ptr<TempDirectoryPath> testDir_ =
+      TempDirectoryPath::create();
+  const std::string tableDir_ =
+      fmt::format("{}/{}", testDir_->getPath(), "table");
+};
+
+TEST_F(MergeJoinReplayerTest, basic) {
+  const auto planWithSplits = createPlan(
+      tableDir_,
+      core::JoinType::kInner,
+      probeKeys_,
+      buildKeys_,
+      probeInput_,
+      buildInput_);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  for (const auto& [planNodeId, nodeSplits] : planWithSplits.splits) {
+    builder.splits(planNodeId, nodeSplits);
+  }
+  const auto result = builder.copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "basic");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(
+      tableDir_,
+      core::JoinType::kInner,
+      probeKeys_,
+      buildKeys_,
+      probeInput_,
+      buildInput_);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_);
+  for (const auto& [planNodeId, nodeSplits] : tracePlanWithSplits.splits) {
+    traceBuilder.splits(planNodeId, nodeSplits);
+  }
+  auto traceResult = traceBuilder.copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto taskId = task->taskId();
+  const auto replayingResult = MergeJoinReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   traceNodeId_,
+                                   "MergeJoin",
+                                   /*spillBaseDir=*/"",
+                                   /*driverIds=*/"",
+                                   /*queryCapacity=*/0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(MergeJoinReplayerTest, runner) {
+  const auto testDir = TempDirectoryPath::create();
+  const auto traceRoot = fmt::format("{}/{}", testDir->getPath(), "traceRoot");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(
+      tableDir_,
+      core::JoinType::kInner,
+      probeKeys_,
+      buildKeys_,
+      probeInput_,
+      buildInput_);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.config(core::QueryConfig::kEnableOperatorBatchSizeStats, true)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_);
+  for (const auto& [planNodeId, nodeSplits] : tracePlanWithSplits.splits) {
+    traceBuilder.splits(planNodeId, nodeSplits);
+  }
+  auto traceResult = traceBuilder.copyResults(pool(), task);
+
+  const auto taskTraceDir =
+      exec::trace::getTaskTraceDirectory(traceRoot, *task);
+  const auto leftOperatorTraceDir = exec::trace::getOpTraceDirectory(
+      taskTraceDir,
+      traceNodeId_,
+      /*pipelineId=*/0,
+      /*driverId=*/0);
+  const auto leftSummary =
+      exec::trace::OperatorTraceSummaryReader(leftOperatorTraceDir, pool())
+          .read();
+  ASSERT_EQ(leftSummary.opType, "MergeJoin");
+  ASSERT_GT(leftSummary.peakMemory, 0);
+  ASSERT_GT(leftSummary.inputRows, 0);
+  // NOTE: the input bytes is 0 because of the lazy materialization.
+  ASSERT_EQ(leftSummary.inputBytes, 0);
+  ASSERT_EQ(leftSummary.rawInputRows, 0);
+  ASSERT_EQ(leftSummary.rawInputBytes, 0);
+
+  const auto rightOperatorTraceDir = exec::trace::getOpTraceDirectory(
+      taskTraceDir,
+      traceNodeId_,
+      /*pipelineId=*/1,
+      /*driverId=*/0);
+  const auto rightSummary =
+      exec::trace::OperatorTraceSummaryReader(rightOperatorTraceDir, pool())
+          .read();
+  ASSERT_EQ(rightSummary.opType, "CallbackSink");
+  // NOTE: CallbackSink does not have its own memory pool.
+  ASSERT_EQ(rightSummary.peakMemory, 0);
+  ASSERT_GT(rightSummary.inputRows, 0);
+  // NOTE: the input bytes is 0 because of the lazy materialization.
+  ASSERT_EQ(rightSummary.inputBytes, 0);
+  ASSERT_EQ(rightSummary.rawInputRows, 0);
+  ASSERT_EQ(rightSummary.rawInputBytes, 0);
+
+  FLAGS_root_dir = traceRoot;
+  FLAGS_query_id = task->queryCtx()->queryId();
+  FLAGS_task_id = task->taskId();
+  FLAGS_node_id = traceNodeId_;
+  FLAGS_summary = true;
+  {
+    TraceReplayRunner runner;
+    runner.init();
+    runner.run();
+  }
+
+  FLAGS_task_id = task->taskId();
+  FLAGS_driver_ids = "";
+  FLAGS_summary = false;
+  {
+    TraceReplayRunner runner;
+    runner.init();
+    runner.run();
+  }
+}
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/OrderByReplayerTest.cpp b/velox/tool/trace/tests/OrderByReplayerTest.cpp
new file mode 100644
index 000000000000..4e3ce6e68f36
--- /dev/null
+++ b/velox/tool/trace/tests/OrderByReplayerTest.cpp
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <string>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/TraceUtil.h"
+#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 "velox/serializers/PrestoSerializer.h"
+#include "velox/tool/trace/OrderByReplayer.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;
+
+namespace facebook::velox::tool::trace::test {
+class OrderByReplayerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    HiveConnectorTestBase::SetUpTestCase();
+    filesystems::registerLocalFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
+    core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  void TearDown() override {
+    input_.clear();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(int32_t count, int32_t rowsPerVector, const RowTypePtr& rowType) {
+    return HiveConnectorTestBase::makeVectors(rowType, count, rowsPerVector);
+  }
+
+  std::vector<Split> makeSplits(
+      const std::vector<RowVectorPtr>& inputs,
+      const std::string& path) {
+    std::vector<Split> splits;
+    for (auto i = 0; i < 4; ++i) {
+      const std::string filePath = fmt::format("{}/{}", path, i);
+      writeToFile(filePath, inputs);
+      splits.emplace_back(makeHiveConnectorSplit(filePath));
+    }
+
+    return splits;
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId scanId;
+    std::vector<exec::Split> splits;
+
+    explicit PlanWithSplits(
+        const core::PlanNodePtr& _plan,
+        const core::PlanNodeId& _scanId = "",
+        const std::vector<velox::exec::Split>& _splits = {})
+        : plan(_plan), scanId(_scanId), splits(_splits) {}
+  };
+
+  PlanWithSplits createPlan(bool isPartial = false) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+
+    auto builder = PlanBuilder(planNodeIdGenerator)
+                       .tableScan(inputType_)
+                       .capturePlanNodeId(scanId)
+                       .orderBy({"c0"}, isPartial);
+
+    auto plan = builder.capturePlanNodeId(orderById_).planNode();
+
+    const std::vector<Split> splits =
+        makeSplits(input_, fmt::format("{}/splits", testDir_->getPath()));
+    return PlanWithSplits{plan, scanId, splits};
+  }
+
+  core::PlanNodeId orderById_;
+  RowTypePtr inputType_{ROW({"c0", "c1"}, {BIGINT(), VARCHAR()})};
+
+  std::vector<RowVectorPtr> input_ = makeVectors(5, 100, inputType_);
+
+  const std::shared_ptr<TempDirectoryPath> testDir_ =
+      TempDirectoryPath::create();
+};
+
+TEST_F(OrderByReplayerTest, basic) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return 99 - row; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", row); })})};
+
+  const auto planWithSplits = createPlan();
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result = builder.splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "basic");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan();
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(4)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, orderById_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = OrderByReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   orderById_,
+                                   "OrderBy",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(OrderByReplayerTest, partial) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("data_{}", row); })})};
+
+  const auto planWithSplits = createPlan(true);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result = builder.splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "partial");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(true);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(4)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, orderById_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = OrderByReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   orderById_,
+                                   "OrderBy",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/PartitionedOutputReplayerTest.cpp b/velox/tool/trace/tests/PartitionedOutputReplayerTest.cpp
index 584cbbe99f92..e83aac6dfe63 100644
--- a/velox/tool/trace/tests/PartitionedOutputReplayerTest.cpp
+++ b/velox/tool/trace/tests/PartitionedOutputReplayerTest.cpp
@@ -21,6 +21,7 @@
 #include "folly/dynamic.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/TraceUtil.h"
@@ -58,12 +59,9 @@ class PartitionedOutputReplayerTest
     }
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveInsertFileNameGenerator::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
   }
@@ -111,12 +109,13 @@ class PartitionedOutputReplayerTest
              {core::QueryConfig::kQueryTraceMaxBytes,
               std::to_string(100UL << 30)},
              {core::QueryConfig::kQueryTraceTaskRegExp, ".*"},
-             {core::QueryConfig::kQueryTraceNodeIds, capturedPlanNodeId},
+             {core::QueryConfig::kQueryTraceNodeId, capturedPlanNodeId},
              {core::QueryConfig::kMaxPartitionedOutputBufferSize,
               std::to_string(8UL << 20)},
              {core::QueryConfig::kMaxOutputBufferSize,
               std::to_string(8UL << 20)}}),
-        Task::ExecutionMode::kParallel);
+        Task::ExecutionMode::kParallel,
+        exec::Consumer{});
     return task;
   }
 
diff --git a/velox/tool/trace/tests/TableScanReplayerTest.cpp b/velox/tool/trace/tests/TableScanReplayerTest.cpp
index be504a2c3803..91cf139cbd78 100644
--- a/velox/tool/trace/tests/TableScanReplayerTest.cpp
+++ b/velox/tool/trace/tests/TableScanReplayerTest.cpp
@@ -17,14 +17,12 @@
 #include <folly/init/Init.h>
 #include <gtest/gtest.h>
 
-#include <algorithm>
 #include <memory>
 #include <string>
 
 #include "folly/dynamic.h"
-#include "velox/common/base/Fs.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/TraceUtil.h"
@@ -35,7 +33,6 @@
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/TableScanReplayer.h"
 #include "velox/tool/trace/TraceReplayRunner.h"
-#include "velox/vector/tests/utils/VectorTestBase.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::core;
@@ -49,6 +46,7 @@ using namespace facebook::velox::common::testutil;
 using namespace facebook::velox::common::hll;
 
 namespace facebook::velox::tool::trace::test {
+
 class TableScanReplayerTest : public HiveConnectorTestBase {
  protected:
   static void SetUpTestCase() {
@@ -60,13 +58,9 @@ class TableScanReplayerTest : public HiveConnectorTestBase {
     }
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveInsertFileNameGenerator::registerSerDe();
-    connector::hive::HiveConnectorSplit::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
   }
@@ -124,7 +118,7 @@ TEST_F(TableScanReplayerTest, runner) {
           .config(core::QueryConfig::kQueryTraceDir, traceRoot)
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-          .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+          .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
           .splits(makeHiveConnectorSplits(splitFiles))
           .copyResults(pool(), task);
 
@@ -196,7 +190,7 @@ TEST_F(TableScanReplayerTest, basic) {
           .config(core::QueryConfig::kQueryTraceDir, traceRoot)
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-          .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+          .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
           .splits(makeHiveConnectorSplits(splitFiles))
           .copyResults(pool(), task);
 
@@ -265,7 +259,7 @@ TEST_F(TableScanReplayerTest, columnPrunning) {
           .config(core::QueryConfig::kQueryTraceDir, traceRoot)
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-          .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+          .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
           .splits(makeHiveConnectorSplits(splitFiles))
           .copyResults(pool(), task);
 
@@ -300,8 +294,7 @@ TEST_F(TableScanReplayerTest, subfieldPrunning) {
   writeToFile(filePath->getPath(), vectors);
   std::vector<common::Subfield> requiredSubfields;
   requiredSubfields.emplace_back("e.c");
-  std::unordered_map<std::string, std::shared_ptr<connector::ColumnHandle>>
-      assignments;
+  connector::ColumnHandleMap assignments;
   assignments["e"] = std::make_shared<HiveColumnHandle>(
       "e",
       HiveColumnHandle::ColumnType::kRegular,
@@ -328,7 +321,7 @@ TEST_F(TableScanReplayerTest, subfieldPrunning) {
           .config(core::QueryConfig::kQueryTraceDir, traceRoot)
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-          .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+          .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
           .split(split)
           .copyResults(pool(), task);
 
@@ -369,7 +362,7 @@ TEST_F(TableScanReplayerTest, concurrent) {
           .config(core::QueryConfig::kQueryTraceDir, traceRoot)
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-          .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_)
+          .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_)
           .splits(makeHiveConnectorSplits(splitFiles))
           .copyResults(pool(), task);
 
diff --git a/velox/tool/trace/tests/TableWriterReplayerTest.cpp b/velox/tool/trace/tests/TableWriterReplayerTest.cpp
index 1e378e85c157..1aa7080dcfec 100644
--- a/velox/tool/trace/tests/TableWriterReplayerTest.cpp
+++ b/velox/tool/trace/tests/TableWriterReplayerTest.cpp
@@ -23,7 +23,7 @@
 #include "folly/dynamic.h"
 #include "velox/common/base/Fs.h"
 #include "velox/common/file/FileSystems.h"
-#include "velox/common/hyperloglog/SparseHll.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/OperatorTraceReader.h"
 #include "velox/exec/PartitionFunction.h"
 #include "velox/exec/TableWriter.h"
@@ -60,12 +60,9 @@ class TableWriterReplayerTest : public HiveConnectorTestBase {
     }
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveInsertFileNameGenerator::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
   }
@@ -126,12 +123,12 @@ class TableWriterReplayerTest : public HiveConnectorTestBase {
           connector::hive::LocationHandle::TableType::kNew,
       const CommitStrategy& outputCommitStrategy = CommitStrategy::kNoCommit,
       bool aggregateResult = true,
-      std::shared_ptr<core::AggregationNode> aggregationNode = nullptr) {
+      const std::optional<ColumnStatsSpec> statsSpec = std::nullopt) {
     auto insertPlan = inputPlan
                           .addNode(addTableWriter(
                               inputRowType,
                               tableRowType->names(),
-                              aggregationNode,
+                              statsSpec,
                               createInsertTableHandle(
                                   tableRowType,
                                   outputTableType,
@@ -154,29 +151,21 @@ class TableWriterReplayerTest : public HiveConnectorTestBase {
   std::function<PlanNodePtr(std::string, PlanNodePtr)> addTableWriter(
       const RowTypePtr& inputColumns,
       const std::vector<std::string>& tableColumnNames,
-      const std::shared_ptr<core::AggregationNode>& aggregationNode,
+      const std::optional<ColumnStatsSpec>& statsSpec,
       const std::shared_ptr<core::InsertTableHandle>& insertHandle,
       bool hasPartitioningScheme,
       connector::CommitStrategy commitStrategy =
           connector::CommitStrategy::kNoCommit) {
     return [=](core::PlanNodeId nodeId,
                core::PlanNodePtr source) -> core::PlanNodePtr {
-      std::shared_ptr<core::AggregationNode> aggNode = nullptr;
-      if (aggregationNode == nullptr) {
-        aggNode = generateAggregationNode(
-            "c0", nodeId, {}, core::AggregationNode::Step::kPartial, source);
-      } else {
-        aggNode = aggregationNode;
-      }
-
       return std::make_shared<core::TableWriteNode>(
           nodeId,
           inputColumns,
           tableColumnNames,
-          aggNode,
+          statsSpec,
           insertHandle,
           hasPartitioningScheme,
-          TableWriteTraits::outputType(aggNode),
+          TableWriteTraits::outputType(statsSpec),
           commitStrategy,
           source);
     };
@@ -205,8 +194,9 @@ class TableWriterReplayerTest : public HiveConnectorTestBase {
 
     for (auto& path : fs::recursive_directory_iterator(directoryPath)) {
       if (path.is_regular_file()) {
-        splits.push_back(HiveConnectorTestBase::makeHiveConnectorSplits(
-            path.path().string(), 1, fileFormat_)[0]);
+        splits.push_back(
+            HiveConnectorTestBase::makeHiveConnectorSplits(
+                path.path().string(), 1, fileFormat_)[0]);
       }
     }
 
@@ -237,7 +227,7 @@ class TableWriterReplayerTest : public HiveConnectorTestBase {
     }
   }
 
-  static std::shared_ptr<core::AggregationNode> generateAggregationNode(
+  static std::shared_ptr<core::AggregationNode> generateColumnStatsSpec(
       const std::string& name,
       const core::PlanNodeId nodeId,
       const std::vector<core::FieldAccessTypedExprPtr>& groupingKeys,
@@ -246,7 +236,7 @@ class TableWriterReplayerTest : public HiveConnectorTestBase {
     core::TypedExprPtr inputField =
         std::make_shared<const core::FieldAccessTypedExpr>(BIGINT(), name);
     auto callExpr = std::make_shared<const core::CallTypedExpr>(
-        BIGINT(), std::vector<core::TypedExprPtr>{inputField}, "min");
+        BIGINT(), "min", inputField);
     std::vector<std::string> aggregateNames = {"min"};
     std::vector<core::AggregationNode::Aggregate> aggregates = {
         core::AggregationNode::Aggregate{
@@ -293,7 +283,7 @@ TEST_F(TableWriterReplayerTest, runner) {
           .config(core::QueryConfig::kQueryTraceDir, traceRoot)
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-          .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId)
+          .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId)
           .split(makeHiveConnectorSplit(sourceFilePath->getPath()))
           .copyResults(pool(), task);
 
@@ -364,7 +354,7 @@ TEST_F(TableWriterReplayerTest, basic) {
           .config(core::QueryConfig::kQueryTraceDir, traceRoot)
           .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
           .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-          .config(core::QueryConfig::kQueryTraceNodeIds, planNodeId)
+          .config(core::QueryConfig::kQueryTraceNodeId, planNodeId)
           .split(makeHiveConnectorSplit(sourceFilePath->getPath()))
           .copyResults(pool(), task);
   const auto traceOutputDir = TempDirectoryPath::create();
@@ -383,7 +373,8 @@ TEST_F(TableWriterReplayerTest, basic) {
   // Second column contains details about written files.
   const auto details = results->childAt(TableWriteTraits::kFragmentChannel)
                            ->as<FlatVector<StringView>>();
-  const folly::dynamic obj = folly::parseJson(details->valueAt(1));
+  const folly::dynamic obj =
+      folly::parseJson(std::string_view(details->valueAt(1)));
   const auto fileWriteInfos = obj["fileWriteInfos"];
   ASSERT_EQ(1, fileWriteInfos.size());
 
@@ -393,8 +384,9 @@ TEST_F(TableWriterReplayerTest, basic) {
 
   const auto copy =
       AssertQueryBuilder(plan)
-          .split(makeHiveConnectorSplit(fmt::format(
-              "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
+          .split(makeHiveConnectorSplit(
+              fmt::format(
+                  "{}/{}", targetDirectoryPath->getPath(), writeFileName)))
           .copyResults(pool());
   assertEqualResults({data}, {copy});
 }
@@ -482,7 +474,7 @@ TEST_F(TableWriterReplayerTest, partitionWrite) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, tableWriteNodeId)
+      .config(core::QueryConfig::kQueryTraceNodeId, tableWriteNodeId)
       .splits(makeHiveConnectorSplits(inputFilePaths))
       .copyResults(pool(), task);
   actualPartitionDirectories =
diff --git a/velox/tool/trace/tests/TopNRowNumberReplayerTest.cpp b/velox/tool/trace/tests/TopNRowNumberReplayerTest.cpp
new file mode 100644
index 000000000000..cec5bb999441
--- /dev/null
+++ b/velox/tool/trace/tests/TopNRowNumberReplayerTest.cpp
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <string>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/TraceUtil.h"
+#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 "velox/serializers/PrestoSerializer.h"
+#include "velox/tool/trace/TopNRowNumberReplayer.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;
+
+namespace facebook::velox::tool::trace::test {
+class TopNRowNumberReplayerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    HiveConnectorTestBase::SetUpTestCase();
+    filesystems::registerLocalFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
+    core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  void TearDown() override {
+    input_.clear();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(int32_t count, int32_t rowsPerVector, const RowTypePtr& rowType) {
+    return HiveConnectorTestBase::makeVectors(rowType, count, rowsPerVector);
+  }
+
+  std::vector<Split> makeSplits(
+      const std::vector<RowVectorPtr>& inputs,
+      const std::string& path) {
+    std::vector<Split> splits;
+    for (auto i = 0; i < 4; ++i) {
+      const std::string filePath = fmt::format("{}/{}", path, i);
+      writeToFile(filePath, inputs);
+      splits.emplace_back(makeHiveConnectorSplit(filePath));
+    }
+
+    return splits;
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId scanId;
+    std::vector<exec::Split> splits;
+
+    explicit PlanWithSplits(
+        const core::PlanNodePtr& _plan,
+        const core::PlanNodeId& _scanId = "",
+        const std::vector<velox::exec::Split>& _splits = {})
+        : plan(_plan), scanId(_scanId), splits(_splits) {}
+  };
+
+  PlanWithSplits createPlan(
+      int32_t limit,
+      bool generateRowNumber = true,
+      const std::vector<std::string>& partitionKeys = {"c0"},
+      const std::vector<std::string>& sortingKeys = {"c1"}) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+
+    auto builder =
+        PlanBuilder(planNodeIdGenerator)
+            .tableScan(inputType_)
+            .capturePlanNodeId(scanId)
+            .topNRowNumber(
+                partitionKeys, sortingKeys, limit, generateRowNumber);
+
+    auto plan = builder.capturePlanNodeId(topNRowNumberId_).planNode();
+
+    const std::vector<Split> splits =
+        makeSplits(input_, fmt::format("{}/splits", testDir_->getPath()));
+    return PlanWithSplits{plan, scanId, splits};
+  }
+
+  PlanWithSplits createRankPlan(
+      std::string_view function,
+      int32_t limit,
+      bool generateRowNumber = true,
+      const std::vector<std::string>& partitionKeys = {"c0"},
+      const std::vector<std::string>& sortingKeys = {"c1"}) {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+
+    auto builder =
+        PlanBuilder(planNodeIdGenerator)
+            .tableScan(inputType_)
+            .capturePlanNodeId(scanId)
+            .topNRank(
+                function, partitionKeys, sortingKeys, limit, generateRowNumber);
+
+    auto plan = builder.capturePlanNodeId(topNRowNumberId_).planNode();
+
+    const std::vector<Split> splits =
+        makeSplits(input_, fmt::format("{}/splits", testDir_->getPath()));
+    return PlanWithSplits{plan, scanId, splits};
+  }
+
+  core::PlanNodeId topNRowNumberId_;
+  RowTypePtr inputType_{ROW({"c0", "c1"}, {BIGINT(), VARCHAR()})};
+
+  std::vector<RowVectorPtr> input_ = makeVectors(5, 100, inputType_);
+
+  const std::shared_ptr<TempDirectoryPath> testDir_ =
+      TempDirectoryPath::create();
+};
+
+TEST_F(TopNRowNumberReplayerTest, basic) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(5, true);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "basic");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(5, true);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, withoutRowNumber) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("data_{}", row); })})};
+
+  const auto planWithSplits = createPlan(10, false);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "withoutRowNumber");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(10, false);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, multiplePartitions) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 5; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("value_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(3, true);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot = fmt::format(
+      "{}/{}/traceRoot/", testDir_->getPath(), "multiplePartitions");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(3, true);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, noPartitionKeys) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(5, true, {}, {"c1"});
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "noPartitionKeys");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(5, true, {}, {"c1"});
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, multipleSortingKeys) {
+  inputType_ = ROW({"c0", "c1", "c2"}, {BIGINT(), BIGINT(), VARCHAR()});
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 5; }),
+       makeFlatVector<int64_t>(100, [](auto row) { return row / 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(3, true, {"c0"}, {"c1 DESC", "c2"});
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot = fmt::format(
+      "{}/{}/traceRoot/", testDir_->getPath(), "multipleSortingKeys");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(3, true, {"c0"}, {"c1 DESC", "c2"});
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+TEST_F(TopNRowNumberReplayerTest, limitOne) {
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row % 10; }),
+       makeFlatVector<std::string>(
+           100, [](auto row) { return fmt::format("str_{}", 99 - row); })})};
+
+  const auto planWithSplits = createPlan(1, true);
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result =
+      builder.maxDrivers(1).splits(planWithSplits.splits).copyResults(pool());
+
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "limitOne");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan(1, true);
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(1)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, topNRowNumberId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  assertEqualResults({result}, {traceResult});
+
+  const auto replayingResult = TopNRowNumberReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   topNRowNumberId_,
+                                   "TopNRowNumber",
+                                   "",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/tool/trace/tests/TraceFileToolTest.cpp b/velox/tool/trace/tests/TraceFileToolTest.cpp
index 2a497d9a34bd..b680754f63c8 100644
--- a/velox/tool/trace/tests/TraceFileToolTest.cpp
+++ b/velox/tool/trace/tests/TraceFileToolTest.cpp
@@ -19,18 +19,11 @@
 
 #include <string>
 
-#include "velox/common/file/FileSystems.h"
-
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/file/tests/FaultyFileSystem.h"
-#include "velox/common/hyperloglog/SparseHll.h"
-#include "velox/common/testutil/TestValue.h"
-#include "velox/dwio/dwrf/writer/Writer.h"
-#include "velox/exec/OperatorTraceReader.h"
+#include "velox/connectors/hive/HiveConnector.h"
 #include "velox/exec/PartitionFunction.h"
-#include "velox/exec/PlanNodeStats.h"
-#include "velox/exec/TableWriter.h"
 #include "velox/exec/TraceUtil.h"
-#include "velox/exec/tests/utils/ArbitratorTestUtil.h"
 #include "velox/exec/tests/utils/AssertQueryBuilder.h"
 #include "velox/exec/tests/utils/HiveConnectorTestBase.h"
 #include "velox/exec/tests/utils/PlanBuilder.h"
@@ -38,7 +31,6 @@
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/tool/trace/HashJoinReplayer.h"
 #include "velox/tool/trace/TraceFileToolRunner.h"
-#include "velox/tool/trace/TraceReplayRunner.h"
 
 using namespace facebook::velox;
 using namespace facebook::velox::core;
@@ -64,12 +56,9 @@ class TraceFileToolTest : public HiveConnectorTestBase {
     }
     Type::registerSerDe();
     common::Filter::registerSerDe();
-    connector::hive::HiveTableHandle::registerSerDe();
-    connector::hive::LocationHandle::registerSerDe();
-    connector::hive::HiveColumnHandle::registerSerDe();
-    connector::hive::HiveInsertTableHandle::registerSerDe();
-    connector::hive::HiveConnectorSplit::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
     core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
     core::ITypedExpr::registerSerDe();
     registerPartitionFunctionSerDe();
   }
@@ -213,7 +202,7 @@ TEST_F(TraceFileToolTest, basic) {
       .config(core::QueryConfig::kQueryTraceDir, traceRoot)
       .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
       .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
-      .config(core::QueryConfig::kQueryTraceNodeIds, traceNodeId_);
+      .config(core::QueryConfig::kQueryTraceNodeId, traceNodeId_);
 
   for (const auto& [planNodeId, nodeSplits] : tracePlanWithSplits.splits) {
     traceBuilder.splits(planNodeId, nodeSplits);
@@ -262,6 +251,7 @@ TEST_F(TraceFileToolTest, basic) {
                                      traceNodeId_,
                                      "HashJoin",
                                      "",
+                                     "",
                                      0,
                                      executor_.get())
                                      .run();
diff --git a/velox/tool/trace/tests/UnnestReplayerTest.cpp b/velox/tool/trace/tests/UnnestReplayerTest.cpp
new file mode 100644
index 000000000000..0686693a1cc4
--- /dev/null
+++ b/velox/tool/trace/tests/UnnestReplayerTest.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 <gtest/gtest.h>
+
+#include <string>
+
+#include "velox/common/file/FileSystems.h"
+#include "velox/connectors/hive/HiveConnector.h"
+#include "velox/exec/PartitionFunction.h"
+#include "velox/exec/TraceUtil.h"
+#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 "velox/serializers/PrestoSerializer.h"
+#include "velox/tool/trace/UnnestReplayer.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;
+
+namespace facebook::velox::tool::trace::test {
+class UnnestReplayerTest : public HiveConnectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    HiveConnectorTestBase::SetUpTestCase();
+    filesystems::registerLocalFileSystem();
+    if (!isRegisteredVectorSerde()) {
+      serializer::presto::PrestoVectorSerde::registerVectorSerde();
+    }
+    Type::registerSerDe();
+    common::Filter::registerSerDe();
+    connector::hive::HiveConnector::registerSerDe();
+    core::PlanNode::registerSerDe();
+    velox::exec::trace::registerDummySourceSerDe();
+    core::ITypedExpr::registerSerDe();
+    registerPartitionFunctionSerDe();
+  }
+
+  void TearDown() override {
+    input_.clear();
+    HiveConnectorTestBase::TearDown();
+  }
+
+  std::vector<RowVectorPtr>
+  makeVectors(int32_t count, int32_t rowsPerVector, const RowTypePtr& rowType) {
+    return HiveConnectorTestBase::makeVectors(rowType, count, rowsPerVector);
+  }
+
+  std::vector<Split> makeSplits(
+      const std::vector<RowVectorPtr>& inputs,
+      const std::string& path) {
+    std::vector<Split> splits;
+    for (auto i = 0; i < 4; ++i) {
+      const std::string filePath = fmt::format("{}/{}", path, i);
+      writeToFile(filePath, inputs);
+      splits.emplace_back(makeHiveConnectorSplit(filePath));
+    }
+
+    return splits;
+  }
+
+  struct PlanWithSplits {
+    core::PlanNodePtr plan;
+    core::PlanNodeId scanId;
+    std::vector<exec::Split> splits;
+
+    explicit PlanWithSplits(
+        const core::PlanNodePtr& _plan,
+        const core::PlanNodeId& _scanId = "",
+        const std::vector<velox::exec::Split>& _splits = {})
+        : plan(_plan), scanId(_scanId), splits(_splits) {}
+  };
+
+  PlanWithSplits createPlan() {
+    auto planNodeIdGenerator = std::make_shared<core::PlanNodeIdGenerator>();
+    core::PlanNodeId scanId;
+    core::PlanNodeId unnestId;
+
+    auto plan = PlanBuilder(planNodeIdGenerator)
+                    .tableScan(inputType_)
+                    .capturePlanNodeId(scanId)
+                    .unnest({"c0"}, {"c1"})
+                    .capturePlanNodeId(unnestId_)
+                    .planNode();
+
+    const std::vector<Split> splits =
+        makeSplits(input_, fmt::format("{}/splits", testDir_->getPath()));
+    return PlanWithSplits{plan, scanId, splits};
+  }
+
+  core::PlanNodeId unnestId_;
+  RowTypePtr inputType_{ROW({"c0", "c1"}, {BIGINT(), ARRAY(INTEGER())})};
+
+  std::vector<RowVectorPtr> input_ = makeVectors(5, 100, inputType_);
+
+  const std::shared_ptr<TempDirectoryPath> testDir_ =
+      TempDirectoryPath::create();
+};
+
+TEST_F(UnnestReplayerTest, test) {
+  // Create input data with arrays
+  auto arrayVector = makeArrayVector<int32_t>(
+      100,
+      [](auto row) { return row % 5 + 1; },
+      [](auto row, auto index) { return index * (row % 3); });
+
+  input_ = {makeRowVector(
+      {makeFlatVector<int64_t>(100, [](auto row) { return row; }),
+       arrayVector})};
+
+  // Run the original query and get results
+  const auto planWithSplits = createPlan();
+  AssertQueryBuilder builder(planWithSplits.plan);
+  const auto result = builder.splits(planWithSplits.splits).copyResults(pool());
+
+  // Run the query with tracing enabled
+  const auto traceRoot =
+      fmt::format("{}/{}/traceRoot/", testDir_->getPath(), "basic");
+  std::shared_ptr<Task> task;
+  auto tracePlanWithSplits = createPlan();
+  AssertQueryBuilder traceBuilder(tracePlanWithSplits.plan);
+  traceBuilder.maxDrivers(4)
+      .config(core::QueryConfig::kQueryTraceEnabled, true)
+      .config(core::QueryConfig::kQueryTraceDir, traceRoot)
+      .config(core::QueryConfig::kQueryTraceMaxBytes, 100UL << 30)
+      .config(core::QueryConfig::kQueryTraceTaskRegExp, ".*")
+      .config(core::QueryConfig::kQueryTraceNodeId, unnestId_);
+  auto traceResult =
+      traceBuilder.splits(tracePlanWithSplits.splits).copyResults(pool(), task);
+
+  // Verify that the traced results match the original results
+  assertEqualResults({result}, {traceResult});
+
+  // Replay the traced execution and verify results
+  const auto replayingResult = UnnestReplayer(
+                                   traceRoot,
+                                   task->queryCtx()->queryId(),
+                                   task->taskId(),
+                                   unnestId_,
+                                   "Unnest",
+                                   "",
+                                   0,
+                                   executor_.get())
+                                   .run();
+  assertEqualResults({result}, {replayingResult});
+}
+
+} // namespace facebook::velox::tool::trace::test
diff --git a/velox/runner/CMakeLists.txt b/velox/tpcds/gen/CMakeLists.txt
similarity index 62%
rename from velox/runner/CMakeLists.txt
rename to velox/tpcds/gen/CMakeLists.txt
index d453befcf291..e08e9ca0ca40 100644
--- a/velox/runner/CMakeLists.txt
+++ b/velox/tpcds/gen/CMakeLists.txt
@@ -11,23 +11,22 @@
 # WITHOUT 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_multifragment_plan MultiFragmentPlan.cpp)
-velox_link_libraries(velox_multifragment_plan velox_common_base velox_memory
-                     velox_core)
 
-velox_add_library(velox_local_runner LocalRunner.cpp Runner.cpp)
+# Add subdirectories
+add_subdirectory(utils)
+add_subdirectory(dsdgen)
 
+velox_add_library(velox_tpcds_gen TpcdsGen.cpp DSDGenIterator.cpp)
+velox_include_directories(
+  velox_tpcds_gen
+  PUBLIC "$<BUILD_LOCAL_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/dsdgen/include>"
+)
 velox_link_libraries(
-  velox_local_runner
-  velox_multifragment_plan
-  velox_common_base
-  velox_memory
-  velox_hive_connector
-  velox_dwio_common
-  velox_dwio_dwrf_writer
-  velox_exec
-  velox_cursor)
+  velox_tpcds_gen
+  PUBLIC velox_memory velox_tpcds_append_info
+  PRIVATE velox_vector velox_tpcds_dsdgen fmt::fmt
+)
+
+if(${VELOX_BUILD_TESTING})
+  add_subdirectory(tests)
+endif()
diff --git a/velox/tpcds/gen/DSDGenIterator.cpp b/velox/tpcds/gen/DSDGenIterator.cpp
new file mode 100644
index 000000000000..169aad4b3b33
--- /dev/null
+++ b/velox/tpcds/gen/DSDGenIterator.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/tpcds/gen/DSDGenIterator.h"
+#include "velox/common/base/Exceptions.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+using namespace facebook::velox;
+
+namespace facebook::velox::tpcds {
+
+void initializeDSDgen(
+    double scale,
+    int32_t parallel,
+    int32_t child,
+    DSDGenContext& dsdGenContext) {
+  dsdGenContext.Reset();
+  resetCountCount();
+
+  std::string scaleStr = std::to_string(scale);
+  set_str("SCALE", scaleStr.c_str(), dsdGenContext);
+  std::string parallelStr = std::to_string(parallel);
+  set_str("PARALLEL", parallelStr.c_str(), dsdGenContext);
+  std::string childStr = std::to_string(child);
+  set_str("CHILD", childStr.c_str(), dsdGenContext);
+
+  init_rand(dsdGenContext); // no random numbers without this
+}
+
+DSDGenIterator::DSDGenIterator(
+    double scaleFactor,
+    int32_t parallel,
+    int32_t child) {
+  tableDefs_.resize(DBGEN_VERSION); // there are 24 TPC-DS tables
+  VELOX_CHECK_GT(scaleFactor, 0.0, "Tpcds scale factor must be non-negative");
+  initializeDSDgen(scaleFactor, parallel, child, dsdgenCtx_);
+}
+
+void DSDGenIterator::initializeTable(
+    const std::vector<VectorPtr>& children,
+    int table_id) {
+  auto tdef = getSimpleTdefsByNumber(table_id, dsdgenCtx_);
+  facebook::velox::tpcds::TpcdsTableDef table_def;
+  table_def.name = tdef->name;
+  table_def.fl_child = tdef->flags & FL_CHILD ? 1 : 0;
+  table_def.fl_small = tdef->flags & FL_SMALL ? 1 : 0;
+  table_def.first_column = tdef->nFirstColumn;
+  table_def.children = children;
+  table_def.dsdGenContext = &dsdgenCtx_;
+  tableDefs_[table_id] = std::make_unique<TpcdsTableDef>(table_def);
+}
+
+std::vector<std::unique_ptr<TpcdsTableDef>>& DSDGenIterator::getTableDefs() {
+  return tableDefs_;
+};
+
+tpcds_builder_func DSDGenIterator::getTDefFunctionByNumber(int table_id) {
+  auto table_funcs = getTdefFunctionsByNumber(table_id);
+  return table_funcs->builder;
+}
+
+void DSDGenIterator::initTableOffset(int32_t table_id, size_t offset) {
+  row_skip(table_id, offset, dsdgenCtx_);
+}
+
+void DSDGenIterator::genRow(int32_t table_id, size_t index) {
+  auto builder_func = getTDefFunctionByNumber(table_id);
+  builder_func((void*)&tableDefs_, index, dsdgenCtx_);
+  row_stop(table_id, dsdgenCtx_);
+}
+
+int64_t DSDGenIterator::getRowCount(int32_t table) {
+  return get_rowcount(table, dsdgenCtx_);
+}
+
+} // namespace facebook::velox::tpcds
diff --git a/velox/tpcds/gen/DSDGenIterator.h b/velox/tpcds/gen/DSDGenIterator.h
new file mode 100644
index 000000000000..7e067287a348
--- /dev/null
+++ b/velox/tpcds/gen/DSDGenIterator.h
@@ -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.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include "velox/tpcds/gen/utils/append_info-c.h"
+
+namespace facebook::velox::tpcds {
+
+typedef int64_t ds_key_t;
+
+typedef int (*tpcds_builder_func)(void*, ds_key_t, DSDGenContext& dsdgenCtx);
+
+void initializeDSDgen(
+    double scale,
+    int32_t parallel,
+    int32_t child,
+    DSDGenContext& dsdGenContext);
+
+/// This class exposes a thread-safe and reproducible iterator over TPC-DS
+/// synthetically generated data, backed by DSDGEN.
+class DSDGenIterator {
+ public:
+  explicit DSDGenIterator(double scaleFactor, int32_t parallel, int32_t child);
+
+  /// Initializes the table definition and the table schema.
+  void initializeTable(const std::vector<VectorPtr>& children, int table);
+
+  /// Returns a vector of all the table definitions.
+  std::vector<std::unique_ptr<TpcdsTableDef>>& getTableDefs();
+
+  // Before generating records using the gen*() functions below, call the
+  // initTableOffset(int32_t table_id, size_t offset) function to correctly
+  // initialize the seed given the offset to be generated.
+  // table_id corresponds to the table that needs to be generated.
+  // offset represents the row from which data for tables will be generated
+  // using the gen*() functions. offset lets generate data for a segment of the
+  // table and should be less than the table's row count.
+  void initTableOffset(int32_t table_id, size_t offset);
+
+  /// Generate different types of records.
+  // table_id corresponds to the table that is to be generated and row is the
+  // row to be generated.
+  void genRow(int32_t table_id, size_t row);
+
+  /// Gets the row count for a table.
+  ds_key_t getRowCount(int32_t table_id);
+
+  // Gets the metadata for a table, which hold information about the mk_*()
+  // functions responsible for generating the data.
+  tpcds_builder_func getTDefFunctionByNumber(int table_id);
+
+ protected:
+  DSDGenContext dsdgenCtx_;
+  std::vector<std::unique_ptr<TpcdsTableDef>> tableDefs_;
+};
+
+} // namespace facebook::velox::tpcds
diff --git a/velox/tpcds/gen/TpcdsGen.cpp b/velox/tpcds/gen/TpcdsGen.cpp
new file mode 100644
index 000000000000..feca666d22ed
--- /dev/null
+++ b/velox/tpcds/gen/TpcdsGen.cpp
@@ -0,0 +1,922 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "velox/tpcds/gen/TpcdsGen.h"
+#include "velox/tpcds/gen/DSDGenIterator.h"
+#include "velox/vector/ComplexVector.h"
+
+using namespace facebook::velox;
+namespace facebook::velox::tpcds {
+
+namespace {
+// The maximum number of rows that can be returned by dsdgen's data generation
+// functions, invoked with function DSDGenIterator::genRow(), for any of the
+// parent tables (TBL_CATALOG_SALES, TBL_STORE_SALES, or TBL_WEB_SALES) is 16.
+static constexpr vector_size_t kMaxParentTableRows = 16;
+
+std::unordered_map<std::string_view, Table> tpcdsTableMap() {
+  static const std::unordered_map<std::string_view, Table> map{
+      {"call_center", Table::TBL_CALL_CENTER},
+      {"catalog_page", Table::TBL_CATALOG_PAGE},
+      {"catalog_returns", Table::TBL_CATALOG_RETURNS},
+      {"catalog_sales", Table::TBL_CATALOG_SALES},
+      {"customer", Table::TBL_CUSTOMER},
+      {"customer_address", Table::TBL_CUSTOMER_ADDRESS},
+      {"customer_demographics", Table::TBL_CUSTOMER_DEMOGRAPHICS},
+      {"date_dim", Table::TBL_DATE_DIM},
+      {"household_demographics", Table::TBL_HOUSEHOLD_DEMOGRAPHICS},
+      {"income_band", Table::TBL_INCOME_BAND},
+      {"inventory", Table::TBL_INVENTORY},
+      {"item", Table::TBL_ITEM},
+      {"promotion", Table::TBL_PROMOTION},
+      {"reason", Table::TBL_REASON},
+      {"ship_mode", Table::TBL_SHIP_MODE},
+      {"store", Table::TBL_STORE},
+      {"store_returns", Table::TBL_STORE_RETURNS},
+      {"store_sales", Table::TBL_STORE_SALES},
+      {"time_dim", Table::TBL_TIME_DIM},
+      {"warehouse", Table::TBL_WAREHOUSE},
+      {"web_page", Table::TBL_WEB_PAGE},
+      {"web_returns", Table::TBL_WEB_RETURNS},
+      {"web_sales", Table::TBL_WEB_SALES},
+      {"web_site", Table::TBL_WEB_SITE},
+  };
+  return map;
+}
+
+std::unordered_map<Table, std::string_view> invertTpcdsTableMap() {
+  std::unordered_map<Table, std::string_view> inverted;
+  for (const auto& [key, value] : tpcdsTableMap()) {
+    inverted.emplace(value, key);
+  }
+  return inverted;
+}
+
+size_t getVectorSize(size_t rowCount, size_t maxRows, size_t offset) {
+  if (offset >= rowCount) {
+    return 0;
+  }
+  return std::min(rowCount - offset, maxRows);
+}
+
+std::vector<VectorPtr> allocateChildVectors(
+    const RowTypePtr& type,
+    size_t vectorSize,
+    memory::MemoryPool* pool) {
+  std::vector<VectorPtr> vector;
+  vector.reserve(type->size());
+
+  for (const auto& childType : type->children()) {
+    vector.emplace_back(BaseVector::create(childType, vectorSize, pool));
+  }
+  return vector;
+}
+
+RowVectorPtr genTpcdsRowVector(
+    int32_t tableId,
+    memory::MemoryPool* pool,
+    RowTypePtr rowType,
+    std::vector<std::unique_ptr<TpcdsTableDef>>& tableDef) {
+  auto rowCount = tableDef[tableId]->rowIndex;
+  for (auto& child : tableDef[tableId]->children) {
+    child->resize(rowCount);
+  }
+
+  return std::make_shared<RowVector>(
+      pool,
+      rowType,
+      BufferPtr(nullptr),
+      rowCount,
+      std::move(tableDef[tableId]->children));
+}
+
+RowVectorPtr genTpcdsTableData(
+    Table table,
+    memory::MemoryPool* pool,
+    size_t maxRows,
+    size_t offset,
+    double scaleFactor,
+    int32_t parallel,
+    int32_t child) {
+  //  Create schema and allocate vectors.
+  auto rowType = getTableSchema(table);
+  auto table_id = static_cast<int>(table);
+  DSDGenIterator dsdGenIterator(scaleFactor, parallel, child);
+  size_t vectorSize =
+      getVectorSize(dsdGenIterator.getRowCount(table_id), maxRows, offset);
+  auto children = allocateChildVectors(rowType, vectorSize, pool);
+  dsdGenIterator.initTableOffset(table_id, offset);
+  dsdGenIterator.initializeTable(children, table_id);
+  auto& tableDef = dsdGenIterator.getTableDefs();
+  for (size_t i = 0; i < vectorSize; ++i) {
+    dsdGenIterator.genRow(table_id, i + offset + 1);
+  }
+  return std::make_shared<RowVector>(
+      pool,
+      rowType,
+      BufferPtr(nullptr),
+      vectorSize,
+      std::move(tableDef[table_id]->children));
+}
+
+RowVectorPtr genTpcdsParentAndChildTable(
+    memory::MemoryPool* pool,
+    size_t maxRows,
+    size_t offset,
+    double scaleFactor,
+    int32_t parallel,
+    int32_t child,
+    Table parentTable,
+    Table childTable,
+    bool childTableCall) {
+  // Whenever a call to generate a table which is either marked as a
+  // parent or a child is requested, both the child and parent tables
+  // need to be populated.
+
+  auto parentTableType = getTableSchema(parentTable);
+  DSDGenIterator dsdGenIterator(scaleFactor, parallel, child);
+  size_t parentTableVectorSize = getVectorSize(
+      dsdGenIterator.getRowCount(static_cast<int>(parentTable)),
+      maxRows,
+      offset);
+
+  size_t parentTableUpperBound = parentTableVectorSize * kMaxParentTableRows;
+  auto children =
+      allocateChildVectors(parentTableType, parentTableUpperBound, pool);
+
+  auto childTableType = getTableSchema(childTable);
+  auto childChildren =
+      allocateChildVectors(childTableType, parentTableUpperBound, pool);
+
+  auto parentTableId = static_cast<int>(parentTable);
+  auto childTableId = static_cast<int>(childTable);
+
+  dsdGenIterator.initTableOffset(parentTableId, offset);
+  dsdGenIterator.initializeTable(children, parentTableId);
+  dsdGenIterator.initializeTable(childChildren, childTableId);
+  auto& tableDef = dsdGenIterator.getTableDefs();
+  for (size_t i = 0; i < parentTableVectorSize; ++i) {
+    dsdGenIterator.genRow(parentTableId, i + offset + 1);
+  }
+  if (childTableCall) {
+    return genTpcdsRowVector(childTableId, pool, childTableType, tableDef);
+  } else {
+    return genTpcdsRowVector(parentTableId, pool, parentTableType, tableDef);
+  }
+}
+} // namespace
+
+static const RowTypePtr callCenterType = ROW(
+    {"cc_call_center_sk", "cc_call_center_id",
+     "cc_rec_start_date", "cc_rec_end_date",
+     "cc_closed_date_sk", "cc_open_date_sk",
+     "cc_name",           "cc_class",
+     "cc_employees",      "cc_sq_ft",
+     "cc_hours",          "cc_manager",
+     "cc_mkt_id",         "cc_mkt_class",
+     "cc_mkt_desc",       "cc_market_manager",
+     "cc_division",       "cc_division_name",
+     "cc_company",        "cc_company_name",
+     "cc_street_number",  "cc_street_name",
+     "cc_street_type",    "cc_suite_number",
+     "cc_city",           "cc_county",
+     "cc_state",          "cc_zip",
+     "cc_country",        "cc_gmt_offset",
+     "cc_tax_percentage"},
+    {BIGINT(),     VARCHAR(), DATE(),    DATE(),    INTEGER(), INTEGER(),
+     VARCHAR(),    VARCHAR(), INTEGER(), INTEGER(), VARCHAR(), VARCHAR(),
+     INTEGER(),    VARCHAR(), VARCHAR(), VARCHAR(), INTEGER(), VARCHAR(),
+     INTEGER(),    VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(),
+     VARCHAR(),    VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(), DECIMAL(5, 2),
+     DECIMAL(5, 2)});
+
+static const RowTypePtr catalogPageType =
+    ROW({"cp_catalog_page_sk",
+         "cp_catalog_page_id",
+         "cp_start_date_sk",
+         "cp_end_date_sk",
+         "cp_department",
+         "cp_catalog_number",
+         "cp_catalog_page_number",
+         "cp_description",
+         "cp_type"},
+        {BIGINT(),
+         VARCHAR(),
+         INTEGER(),
+         INTEGER(),
+         VARCHAR(),
+         INTEGER(),
+         INTEGER(),
+         VARCHAR(),
+         VARCHAR()});
+
+static const RowTypePtr catalogReturnsType = ROW(
+    {"cr_returned_date_sk",
+     "cr_returned_time_sk",
+     "cr_item_sk",
+     "cr_refunded_customer_sk",
+     "cr_refunded_cdemo_sk",
+     "cr_refunded_hdemo_sk",
+     "cr_refunded_addr_sk",
+     "cr_returning_customer_sk",
+     "cr_returning_cdemo_sk",
+     "cr_returning_hdemo_sk",
+     "cr_returning_addr_sk",
+     "cr_call_center_sk",
+     "cr_catalog_page_sk",
+     "cr_ship_mode_sk",
+     "cr_warehouse_sk",
+     "cr_reason_sk",
+     "cr_order_number",
+     "cr_return_quantity",
+     "cr_return_amount",
+     "cr_return_tax",
+     "cr_return_amt_inc_tax",
+     "cr_fee",
+     "cr_return_ship_cost",
+     "cr_refunded_cash",
+     "cr_reversed_charge",
+     "cr_store_credit",
+     "cr_net_loss"},
+    {BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      INTEGER(),     DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2)});
+
+static const RowTypePtr catalogSalesType = ROW(
+    {"cs_sold_date_sk",
+     "cs_sold_time_sk",
+     "cs_ship_date_sk",
+     "cs_bill_customer_sk",
+     "cs_bill_cdemo_sk",
+     "cs_bill_hdemo_sk",
+     "cs_bill_addr_sk",
+     "cs_ship_customer_sk",
+     "cs_ship_cdemo_sk",
+     "cs_ship_hdemo_sk",
+     "cs_ship_addr_sk",
+     "cs_call_center_sk",
+     "cs_catalog_page_sk",
+     "cs_ship_mode_sk",
+     "cs_warehouse_sk",
+     "cs_item_sk",
+     "cs_promo_sk",
+     "cs_order_number",
+     "cs_quantity",
+     "cs_wholesale_cost",
+     "cs_list_price",
+     "cs_sales_price",
+     "cs_ext_discount_amt",
+     "cs_ext_sales_price",
+     "cs_ext_wholesale_cost",
+     "cs_ext_list_price",
+     "cs_ext_tax",
+     "cs_coupon_amt",
+     "cs_ext_ship_cost",
+     "cs_net_paid",
+     "cs_net_paid_inc_tax",
+     "cs_net_paid_inc_ship",
+     "cs_net_paid_inc_ship_tax",
+     "cs_net_profit"},
+    {BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      INTEGER(),     DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2)});
+
+static const RowTypePtr customerType = ROW(
+    {
+        "c_customer_sk",
+        "c_customer_id",
+        "c_current_cdemo_sk",
+        "c_current_hdemo_sk",
+        "c_current_addr_sk",
+        "c_first_shipto_date_sk",
+        "c_first_sales_date_sk",
+        "c_salutation",
+        "c_first_name",
+        "c_last_name",
+        "c_preferred_cust_flag",
+        "c_birth_day",
+        "c_birth_month",
+        "c_birth_year",
+        "c_birth_country",
+        "c_login",
+        "c_email_address",
+        "c_last_review_date_sk",
+    },
+    {
+        BIGINT(),
+        VARCHAR(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        BIGINT(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        INTEGER(),
+        INTEGER(),
+        INTEGER(),
+        VARCHAR(),
+        VARCHAR(),
+        VARCHAR(),
+        BIGINT(),
+    });
+
+static const RowTypePtr customerAddressType =
+    ROW({"ca_address_sk",
+         "ca_address_id",
+         "ca_street_number",
+         "ca_street_name",
+         "ca_street_type",
+         "ca_suite_number",
+         "ca_city",
+         "ca_county",
+         "ca_state",
+         "ca_zip",
+         "ca_country",
+         "ca_gmt_offset",
+         "ca_location_type"},
+        {BIGINT(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         DECIMAL(5, 2),
+         VARCHAR()});
+
+static const RowTypePtr customerDemographicsType =
+    ROW({"cd_demo_sk",
+         "cd_gender",
+         "cd_marital_status",
+         "cd_education_status",
+         "cd_purchase_estimate",
+         "cd_credit_rating",
+         "cd_dep_count",
+         "cd_dep_employed_count",
+         "cd_dep_college_count"},
+        {BIGINT(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         INTEGER(),
+         VARCHAR(),
+         INTEGER(),
+         INTEGER(),
+         INTEGER()});
+
+static const RowTypePtr dateDimType = ROW(
+    {
+        "d_date_sk",
+        "d_date_id",
+        "d_date",
+        "d_month_seq",
+        "d_week_seq",
+        "d_quarter_seq",
+        "d_year",
+        "d_dow",
+        "d_moy",
+        "d_dom",
+        "d_qoy",
+        "d_fy_year",
+        "d_fy_quarter_seq",
+        "d_fy_week_seq",
+        "d_day_name",
+        "d_quarter_name",
+        "d_holiday",
+        "d_weekend",
+        "d_following_holiday",
+        "d_first_dom",
+        "d_last_dom",
+        "d_same_day_ly",
+        "d_same_day_lq",
+        "d_current_day",
+        "d_current_week",
+        "d_current_month",
+        "d_current_quarter",
+        "d_current_year",
+    },
+    {
+        BIGINT(),  VARCHAR(), DATE(),    INTEGER(), INTEGER(), INTEGER(),
+        INTEGER(), INTEGER(), INTEGER(), INTEGER(), INTEGER(), INTEGER(),
+        INTEGER(), INTEGER(), VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(),
+        VARCHAR(), INTEGER(), INTEGER(), INTEGER(), INTEGER(), VARCHAR(),
+        VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(),
+    });
+
+static const RowTypePtr householdDemographicsType =
+    ROW({"hd_demo_sk",
+         "hd_income_band_sk",
+         "hd_buy_potential",
+         "hd_dep_count",
+         "hd_vehicle_count"},
+        {BIGINT(), BIGINT(), VARCHAR(), INTEGER(), INTEGER()});
+
+static const RowTypePtr incomeBandType =
+    ROW({"ib_income_band_sk", "ib_lower_bound", "ib_upper_bound"},
+        {BIGINT(), INTEGER(), INTEGER()});
+
+static const RowTypePtr inventoryType = ROW(
+    {"inv_date_sk", "inv_item_sk", "inv_warehouse_sk", "inv_quantity_on_hand"},
+    {BIGINT(), BIGINT(), BIGINT(), INTEGER()});
+
+static const RowTypePtr itemType = ROW(
+    {"i_item_sk",     "i_item_id",       "i_rec_start_date", "i_rec_end_date",
+     "i_item_desc",   "i_current_price", "i_wholesale_cost", "i_brand_id",
+     "i_brand",       "i_class_id",      "i_class",          "i_category_id",
+     "i_category",    "i_manufact_id",   "i_manufact",       "i_size",
+     "i_formulation", "i_color",         "i_units",          "i_container",
+     "i_manager_id",  "i_product_name"},
+    {BIGINT(),      VARCHAR(), DATE(),    DATE(),    VARCHAR(), DECIMAL(7, 2),
+     DECIMAL(7, 2), INTEGER(), VARCHAR(), INTEGER(), VARCHAR(), INTEGER(),
+     VARCHAR(),     INTEGER(), VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(),
+     VARCHAR(),     VARCHAR(), INTEGER(), VARCHAR()});
+
+static const RowTypePtr promotionType =
+    ROW({"p_promo_sk",
+         "p_promo_id",
+         "p_start_date_sk",
+         "p_end_date_sk",
+         "p_item_sk",
+         "p_cost",
+         "p_response_targe",
+         "p_promo_name",
+         "p_channel_dmail",
+         "p_channel_email",
+         "p_channel_catalog",
+         "p_channel_tv",
+         "p_channel_radio",
+         "p_channel_press",
+         "p_channel_event",
+         "p_channel_demo",
+         "p_channel_details",
+         "p_purpose",
+         "p_discount_active"},
+        {BIGINT(),
+         VARCHAR(),
+         BIGINT(),
+         BIGINT(),
+         BIGINT(),
+         DECIMAL(15, 2),
+         INTEGER(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR()});
+
+static const RowTypePtr reasonType =
+    ROW({"r_reason_sk", "r_reason_id", "r_reason_desc"},
+        {BIGINT(), VARCHAR(), VARCHAR()});
+
+static const RowTypePtr shipModeType =
+    ROW({"sm_ship_mode_sk",
+         "sm_ship_mode_id",
+         "sm_type",
+         "sm_code",
+         "sm_carrier",
+         "sm_contract"},
+        {BIGINT(), VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR()});
+
+static const RowTypePtr storeType = ROW(
+    {
+        "s_store_sk",
+        "s_store_id",
+        "s_rec_start_date",
+        "s_rec_end_date",
+        "s_closed_date_sk",
+        "s_store_name",
+        "s_number_employees",
+        "s_floor_space",
+        "s_hours",
+        "s_manager",
+        "s_market_id",
+        "s_geography_class",
+        "s_market_desc",
+        "s_market_manager",
+        "s_division_id",
+        "s_division_name",
+        "s_company_id",
+        "s_company_name",
+        "s_street_number",
+        "s_street_name",
+        "s_street_type",
+        "s_suite_number",
+        "s_city",
+        "s_county",
+        "s_state",
+        "s_zip",
+        "s_country",
+        "s_gmt_offset",
+        "s_tax_precentage",
+    },
+    {
+        BIGINT(),  VARCHAR(), DATE(),        DATE(),        BIGINT(),
+        VARCHAR(), INTEGER(), INTEGER(),     VARCHAR(),     VARCHAR(),
+        INTEGER(), VARCHAR(), VARCHAR(),     VARCHAR(),     INTEGER(),
+        VARCHAR(), INTEGER(), VARCHAR(),     VARCHAR(),     VARCHAR(),
+        VARCHAR(), VARCHAR(), VARCHAR(),     VARCHAR(),     VARCHAR(),
+        VARCHAR(), VARCHAR(), DECIMAL(5, 2), DECIMAL(5, 2),
+    });
+
+static const RowTypePtr storeReturnsType =
+    ROW({"sr_returned_date_sk",
+         "sr_return_time_sk",
+         "sr_item_sk",
+         "sr_customer_sk",
+         "sr_cdemo_sk",
+         "sr_hdemo_sk",
+         "sr_addr_sk",
+         "sr_store_sk",
+         "sr_reason_sk",
+         "sr_ticket_number",
+         "sr_return_quantity",
+         "sr_return_amt",
+         "sr_return_tax",
+         "sr_return_amt_inc_tax",
+         "sr_fee",
+         "sr_return_ship_cost",
+         "sr_refunded_cash",
+         "sr_reversed_charge",
+         "sr_store_credit",
+         "sr_net_loss"},
+        {BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+         BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+         BIGINT(),      BIGINT(),      INTEGER(),     DECIMAL(7, 2),
+         DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+         DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2)});
+
+static const RowTypePtr storeSalesType = ROW(
+    {"ss_sold_date_sk",     "ss_sold_time_sk",       "ss_item_sk",
+     "ss_customer_sk",      "ss_cdemo_sk",           "ss_hdemo_sk",
+     "ss_addr_sk",          "ss_store_sk",           "ss_promo_sk",
+     "ss_ticket_number",    "ss_quantity",           "ss_wholesale_cost",
+     "ss_list_price",       "ss_sales_price",        "ss_ext_discount_amt",
+     "ss_ext_sales_price",  "ss_ext_wholesale_cost", "ss_ext_list_price",
+     "ss_ext_tax",          "ss_coupon_amt",         "ss_net_paid",
+     "ss_net_paid_inc_tax", "ss_net_profit"},
+    {BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     INTEGER(),     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2)});
+
+static const RowTypePtr timeDimType =
+    ROW({"t_time_sk",
+         "t_time_id",
+         "t_time",
+         "t_hour",
+         "t_minute",
+         "t_second",
+         "t_am_pm",
+         "t_shift",
+         "t_sub_shift",
+         "t_meal_time"},
+        {BIGINT(),
+         VARCHAR(),
+         INTEGER(),
+         INTEGER(),
+         INTEGER(),
+         INTEGER(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR()});
+
+static const RowTypePtr warehouseType =
+    ROW({"w_warehouse_sk",
+         "w_warehouse_id",
+         "w_warehouse_name",
+         "w_warehouse_sq_ft",
+         "w_street_number",
+         "w_street_name",
+         "w_street_type",
+         "w_suite_number",
+         "w_city",
+         "w_county",
+         "w_state",
+         "w_zip",
+         "w_country",
+         "w_gmt_offset"},
+        {BIGINT(),
+         VARCHAR(),
+         VARCHAR(),
+         INTEGER(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         VARCHAR(),
+         DECIMAL(5, 2)});
+
+static const RowTypePtr webPageType =
+    ROW({"wp_web_page_sk",
+         "wp_web_page_id",
+         "wp_rec_start_date",
+         "wp_rec_end_date",
+         "wp_creation_date_sk",
+         "wp_access_date_sk",
+         "wp_autogen_flag",
+         "wp_customer_sk",
+         "wp_url",
+         "wp_type",
+         "wp_char_count",
+         "wp_link_count",
+         "wp_image_count",
+         "wp_max_ad_count"},
+        {BIGINT(),
+         VARCHAR(),
+         DATE(),
+         DATE(),
+         BIGINT(),
+         BIGINT(),
+         VARCHAR(),
+         BIGINT(),
+         VARCHAR(),
+         VARCHAR(),
+         INTEGER(),
+         INTEGER(),
+         INTEGER(),
+         INTEGER()});
+
+static const RowTypePtr webReturnsType = ROW(
+    {"wr_returned_date_sk",
+     "wr_returned_time_sk",
+     "wr_item_sk",
+     "wr_refunded_customer_sk",
+     "wr_refunded_cdemo_sk",
+     "wr_refunded_hdemo_sk",
+     "wr_refunded_addr_sk",
+     "wr_returning_customer_sk",
+     "wr_returning_cdemo_sk",
+     "wr_returning_hdemo_sk",
+     "wr_returning_addr_sk",
+     "wr_web_page_sk",
+     "wr_reason_sk",
+     "wr_order_number",
+     "wr_return_quantity",
+     "wr_return_amt",
+     "wr_return_tax",
+     "wr_return_amt_inc_tax",
+     "wr_fee",
+     "wr_return_ship_cost",
+     "wr_refunded_cash",
+     "wr_reversed_charge",
+     "wr_account_credit",
+     "wr_net_loss"},
+    {BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      INTEGER(),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2)});
+
+static const RowTypePtr webSalesType = ROW(
+    {"ws_sold_date_sk",
+     "ws_sold_time_sk",
+     "ws_ship_date_sk",
+     "ws_item_sk",
+     "ws_bill_customer_sk",
+     "ws_bill_cdemo_sk",
+     "ws_bill_hdemo_sk",
+     "ws_bill_addr_sk",
+     "ws_ship_customer_sk",
+     "ws_ship_cdemo_sk",
+     "ws_ship_hdemo_sk",
+     "ws_ship_addr_sk",
+     "ws_web_page_sk",
+     "ws_web_site_sk",
+     "ws_ship_mode_sk",
+     "ws_warehouse_sk",
+     "ws_promo_sk",
+     "ws_order_number",
+     "ws_quantity",
+     "ws_wholesale_cost",
+     "ws_list_price",
+     "ws_sales_price",
+     "ws_ext_discount_amt",
+     "ws_ext_sales_price",
+     "ws_ext_wholesale_cost",
+     "ws_ext_list_price",
+     "ws_ext_tax",
+     "ws_coupon_amt",
+     "ws_ext_ship_cost",
+     "ws_net_paid",
+     "ws_net_paid_inc_tax",
+     "ws_net_paid_inc_ship",
+     "ws_net_paid_inc_ship_tax",
+     "ws_net_profit"},
+    {BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),      BIGINT(),
+     BIGINT(),      BIGINT(),      BIGINT(),      INTEGER(),     DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2),
+     DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2), DECIMAL(7, 2)});
+
+static const RowTypePtr websiteType = ROW(
+    {"web_site_sk",        "web_site_id",       "web_rec_start_date",
+     "web_rec_end_date",   "web_name",          "web_open_date_sk",
+     "web_close_date_sk",  "web_class",         "web_manager",
+     "web_mkt_id",         "web_mkt_class",     "web_mkt_desc",
+     "web_market_manager", "web_company_id",    "web_company_name",
+     "web_street_number",  "web_street_name",   "web_street_type",
+     "web_suite_number",   "web_city",          "web_county",
+     "web_state",          "web_zip",           "web_country",
+     "web_gmt_offset",     "web_tax_percentage"},
+    {BIGINT(),      VARCHAR(),    DATE(),    DATE(),    VARCHAR(), BIGINT(),
+     BIGINT(),      VARCHAR(),    VARCHAR(), INTEGER(), VARCHAR(), VARCHAR(),
+     VARCHAR(),     INTEGER(),    VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(),
+     VARCHAR(),     VARCHAR(),    VARCHAR(), VARCHAR(), VARCHAR(), VARCHAR(),
+     DECIMAL(5, 2), DECIMAL(5, 2)});
+
+const RowTypePtr getTableSchema(Table table) {
+  switch (table) {
+    case Table::TBL_CALL_CENTER:
+      return callCenterType;
+    case Table::TBL_CATALOG_PAGE:
+      return catalogPageType;
+    case Table::TBL_CATALOG_RETURNS:
+      return catalogReturnsType;
+    case Table::TBL_CATALOG_SALES:
+      return catalogSalesType;
+    case Table::TBL_CUSTOMER:
+      return customerType;
+    case Table::TBL_CUSTOMER_ADDRESS:
+      return customerAddressType;
+    case Table::TBL_CUSTOMER_DEMOGRAPHICS:
+      return customerDemographicsType;
+    case Table::TBL_DATE_DIM:
+      return dateDimType;
+    case Table::TBL_HOUSEHOLD_DEMOGRAPHICS:
+      return householdDemographicsType;
+    case Table::TBL_INCOME_BAND:
+      return incomeBandType;
+    case Table::TBL_INVENTORY:
+      return inventoryType;
+    case Table::TBL_ITEM:
+      return itemType;
+    case Table::TBL_PROMOTION:
+      return promotionType;
+    case Table::TBL_REASON:
+      return reasonType;
+    case Table::TBL_SHIP_MODE:
+      return shipModeType;
+    case Table::TBL_STORE:
+      return storeType;
+    case Table::TBL_STORE_RETURNS:
+      return storeReturnsType;
+    case Table::TBL_STORE_SALES:
+      return storeSalesType;
+    case Table::TBL_TIME_DIM:
+      return timeDimType;
+    case Table::TBL_WAREHOUSE:
+      return warehouseType;
+    case Table::TBL_WEB_PAGE:
+      return webPageType;
+    case Table::TBL_WEB_RETURNS:
+      return webReturnsType;
+    case Table::TBL_WEB_SALES:
+      return webSalesType;
+    case Table::TBL_WEB_SITE:
+      return websiteType;
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
+std::string_view toTableName(Table table) {
+  auto inverted = invertTpcdsTableMap();
+  auto it = inverted.find(table);
+  if (it != inverted.end()) {
+    return inverted.at(table);
+  }
+  VELOX_UNREACHABLE("Invalid TPC-DS table: {}", static_cast<uint8_t>(table));
+}
+
+Table fromTableName(std::string_view tableName) {
+  auto map = tpcdsTableMap();
+  auto it = map.find(tableName);
+  if (it != map.end()) {
+    return it->second;
+  }
+  VELOX_UNREACHABLE("Invalid TPC-DS table name: {}", tableName);
+}
+
+TypePtr resolveTpcdsColumn(Table table, const std::string& columnName) {
+  return getTableSchema(table)->findChild(columnName);
+}
+
+RowVectorPtr genTpcdsData(
+    Table table,
+    size_t maxRows,
+    size_t offset,
+    memory::MemoryPool* pool,
+    double scaleFactor,
+    int32_t parallel,
+    int32_t child) {
+  switch (table) {
+    Table parentTable, childTable;
+    case Table::TBL_CATALOG_RETURNS:
+    case Table::TBL_CATALOG_SALES:
+      parentTable = Table::TBL_CATALOG_SALES;
+      childTable = Table::TBL_CATALOG_RETURNS;
+      return genTpcdsParentAndChildTable(
+          pool,
+          maxRows,
+          offset,
+          scaleFactor,
+          parallel,
+          child,
+          parentTable,
+          childTable,
+          table == childTable);
+    case Table::TBL_WEB_RETURNS:
+    case Table::TBL_WEB_SALES:
+      parentTable = Table::TBL_WEB_SALES;
+      childTable = Table::TBL_WEB_RETURNS;
+      return genTpcdsParentAndChildTable(
+          pool,
+          maxRows,
+          offset,
+          scaleFactor,
+          parallel,
+          child,
+          parentTable,
+          childTable,
+          table == childTable);
+    case Table::TBL_STORE_RETURNS:
+    case Table::TBL_STORE_SALES:
+      parentTable = Table::TBL_STORE_SALES;
+      childTable = Table::TBL_STORE_RETURNS;
+      return genTpcdsParentAndChildTable(
+          pool,
+          maxRows,
+          offset,
+          scaleFactor,
+          parallel,
+          child,
+          parentTable,
+          childTable,
+          table == childTable);
+    case Table::TBL_CALL_CENTER:
+    case Table::TBL_CATALOG_PAGE:
+    case Table::TBL_CUSTOMER:
+    case Table::TBL_CUSTOMER_ADDRESS:
+    case Table::TBL_CUSTOMER_DEMOGRAPHICS:
+    case Table::TBL_DATE_DIM:
+    case Table::TBL_HOUSEHOLD_DEMOGRAPHICS:
+    case Table::TBL_INCOME_BAND:
+    case Table::TBL_INVENTORY:
+    case Table::TBL_ITEM:
+    case Table::TBL_PROMOTION:
+    case Table::TBL_REASON:
+    case Table::TBL_SHIP_MODE:
+    case Table::TBL_STORE:
+    case Table::TBL_TIME_DIM:
+    case Table::TBL_WAREHOUSE:
+    case Table::TBL_WEB_PAGE:
+    case Table::TBL_WEB_SITE:
+      return genTpcdsTableData(
+          table, pool, maxRows, offset, scaleFactor, parallel, child);
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+} // namespace facebook::velox::tpcds
diff --git a/velox/tpcds/gen/TpcdsGen.h b/velox/tpcds/gen/TpcdsGen.h
new file mode 100644
index 000000000000..028100623ed0
--- /dev/null
+++ b/velox/tpcds/gen/TpcdsGen.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/Memory.h"
+
+namespace facebook::velox {
+class RowVector;
+using RowVectorPtr = std::shared_ptr<RowVector>;
+class RowType;
+using RowTypePtr = std::shared_ptr<const RowType>;
+class Type;
+using TypePtr = std::shared_ptr<const Type>;
+} // namespace facebook::velox
+
+namespace facebook::velox::tpcds {
+
+/// This file uses TPC-DS DSDGEN to generate data encoded using Velox Vectors.
+
+enum class Table : uint8_t {
+  TBL_CALL_CENTER,
+  TBL_CATALOG_PAGE,
+  TBL_CATALOG_RETURNS,
+  TBL_CATALOG_SALES,
+  TBL_CUSTOMER,
+  TBL_CUSTOMER_ADDRESS,
+  TBL_CUSTOMER_DEMOGRAPHICS,
+  TBL_DATE_DIM,
+  TBL_HOUSEHOLD_DEMOGRAPHICS,
+  TBL_INCOME_BAND,
+  TBL_INVENTORY,
+  TBL_ITEM,
+  TBL_PROMOTION,
+  TBL_REASON,
+  TBL_SHIP_MODE,
+  TBL_STORE,
+  TBL_STORE_RETURNS,
+  TBL_STORE_SALES,
+  TBL_TIME_DIM,
+  TBL_WAREHOUSE,
+  TBL_WEB_PAGE,
+  TBL_WEB_RETURNS,
+  TBL_WEB_SALES,
+  TBL_WEB_SITE
+};
+
+static const auto tables = {
+    tpcds::Table::TBL_CALL_CENTER,
+    tpcds::Table::TBL_CATALOG_PAGE,
+    tpcds::Table::TBL_CATALOG_RETURNS,
+    tpcds::Table::TBL_CATALOG_SALES,
+    tpcds::Table::TBL_CUSTOMER,
+    tpcds::Table::TBL_CUSTOMER_ADDRESS,
+    tpcds::Table::TBL_CUSTOMER_DEMOGRAPHICS,
+    tpcds::Table::TBL_DATE_DIM,
+    tpcds::Table::TBL_HOUSEHOLD_DEMOGRAPHICS,
+    tpcds::Table::TBL_INCOME_BAND,
+    tpcds::Table::TBL_INVENTORY,
+    tpcds::Table::TBL_ITEM,
+    tpcds::Table::TBL_PROMOTION,
+    tpcds::Table::TBL_REASON,
+    tpcds::Table::TBL_SHIP_MODE,
+    tpcds::Table::TBL_STORE,
+    tpcds::Table::TBL_STORE_RETURNS,
+    tpcds::Table::TBL_STORE_SALES,
+    tpcds::Table::TBL_TIME_DIM,
+    tpcds::Table::TBL_WAREHOUSE,
+    tpcds::Table::TBL_WEB_PAGE,
+    tpcds::Table::TBL_WEB_RETURNS,
+    tpcds::Table::TBL_WEB_SALES,
+    tpcds::Table::TBL_WEB_SITE};
+
+/// Returns table name as a string.
+std::string_view toTableName(Table table);
+
+/// Returns the schema (RowType) for a particular TPC-DS table.
+const velox::RowTypePtr getTableSchema(Table table);
+
+/// Returns TPC-DS table enum corresponding to name.
+Table fromTableName(std::string_view tableName);
+
+/// Returns a row vector containing at most `maxRows` rows of the `table`,
+/// starting at `offset`, with the given `scaleFactor`. DSDGen allows data
+/// generation in N chunks in parallel. `parallel` represents the total number
+/// of chunks the data will be generated in and `child` represents the chunk of
+/// data generated by this function.
+velox::RowVectorPtr genTpcdsData(
+    Table table,
+    size_t maxRows,
+    size_t offset,
+    velox::memory::MemoryPool* pool,
+    double scaleFactor,
+    int32_t parallel,
+    int32_t child);
+
+TypePtr resolveTpcdsColumn(Table table, const std::string& columnName);
+} // namespace facebook::velox::tpcds
diff --git a/velox/tpcds/gen/dsdgen/CMakeLists.txt b/velox/tpcds/gen/dsdgen/CMakeLists.txt
new file mode 100644
index 000000000000..52d850589269
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/CMakeLists.txt
@@ -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.
+#
+#  Copyright owned by the Transaction Processing Performance Council.
+#
+#  A copy of the license is included under tpcds/gen/dsdgen/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.
+#
+cmake_minimum_required(VERSION 3.10)
+cmake_policy(SET CMP0063 NEW)
+
+project(velox_tpcds_dsdgen CXX C)
+
+velox_add_library(
+  velox_tpcds_dsdgen
+  skip_days.cpp
+  address.cpp
+  build_support.cpp
+  date.cpp
+  dbgen_version.cpp
+  decimal.cpp
+  dist.cpp
+  error_msg.cpp
+  genrand.cpp
+  join.cpp
+  list.cpp
+  load.cpp
+  misc.cpp
+  nulls.cpp
+  parallel.cpp
+  permute.cpp
+  pricing.cpp
+  r_params.cpp
+  scaling.cpp
+  scd.cpp
+  sparse.cpp
+  StringBuffer.cpp
+  tdef_functions.cpp
+  tdefs.cpp
+  text.cpp
+  w_call_center.cpp
+  w_catalog_page.cpp
+  w_catalog_returns.cpp
+  w_catalog_sales.cpp
+  w_customer.cpp
+  w_customer_address.cpp
+  w_customer_demographics.cpp
+  w_datetbl.cpp
+  w_household_demographics.cpp
+  w_income_band.cpp
+  w_inventory.cpp
+  w_item.cpp
+  w_promotion.cpp
+  w_reason.cpp
+  w_ship_mode.cpp
+  w_store.cpp
+  w_store_returns.cpp
+  w_store_sales.cpp
+  w_timetbl.cpp
+  w_warehouse.cpp
+  w_web_page.cpp
+  w_web_returns.cpp
+  w_web_sales.cpp
+  w_web_site.cpp
+)
+
+velox_include_directories(velox_tpcds_dsdgen PRIVATE include)
+velox_link_libraries(velox_tpcds_dsdgen velox_tpcds_append_info Folly::folly)
diff --git a/velox/tpcds/gen/dsdgen/LICENSE b/velox/tpcds/gen/dsdgen/LICENSE
new file mode 100644
index 000000000000..feed8c4973b4
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/LICENSE
@@ -0,0 +1,320 @@
+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.
diff --git a/velox/tpcds/gen/dsdgen/StringBuffer.cpp b/velox/tpcds/gen/dsdgen/StringBuffer.cpp
new file mode 100644
index 000000000000..14a37d26e887
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/StringBuffer.cpp
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 <assert.h>
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#ifndef USE_STDLIB_H
+#include <malloc.h>
+#endif
+#include "velox/tpcds/gen/dsdgen/include/StringBuffer.h"
+
+/*
+ * Routine: AddBuffer
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int AddBuffer(StringBuffer_t* pBuf, char* pStr) {
+  int nRemaining = pBuf->nBytesAllocated - pBuf->nBytesUsed,
+      nRequested = strlen(pStr);
+
+  if (!nRequested)
+    return (0);
+
+  while (nRequested >= nRemaining) {
+    pBuf->pText = static_cast<char*>(realloc(
+        static_cast<void*>(pBuf->pText),
+        pBuf->nBytesAllocated + pBuf->nIncrement));
+    if (!pBuf->pText)
+      return (-1);
+    pBuf->nBytesAllocated += pBuf->nIncrement;
+    nRemaining += pBuf->nIncrement;
+  }
+
+  strncat(pBuf->pText, pStr, pBuf->nBytesAllocated);
+  if (pBuf->nBytesUsed == 0) /* first string adds a terminator */
+    pBuf->nBytesUsed = 1;
+  pBuf->nBytesUsed += nRequested;
+
+  return (0);
+}
+
+/*
+ * Routine: ResetStringBuffer
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int ResetBuffer(StringBuffer_t* pBuf) {
+  pBuf->nBytesUsed = 0;
+  if (pBuf->nBytesAllocated)
+    pBuf->pText[0] = '\0';
+
+  return (0);
+}
+
+/*
+ * Routine: GetBuffer
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+char* GetBuffer(StringBuffer_t* pBuf) {
+  return (pBuf->pText);
+}
+
+/*
+ * Routine: FreeBuffer
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void FreeBuffer(StringBuffer_t* pBuf) {
+  if (!pBuf)
+    return;
+  if (pBuf->pText)
+    free(static_cast<void*>(pBuf->pText));
+  free(static_cast<void*>(pBuf));
+
+  return;
+}
diff --git a/velox/tpcds/gen/dsdgen/address.cpp b/velox/tpcds/gen/dsdgen/address.cpp
new file mode 100644
index 000000000000..adfff67b62d3
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/address.cpp
@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/address.h"
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+static int s_nCountyCount = 0;
+static int s_nCityCount = 0;
+
+void resetCountCount(void) {
+  s_nCountyCount = 0;
+  s_nCityCount = 0;
+
+  return;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int mk_address(ds_addr_t* pAddr, int nColumn, DSDGenContext& dsdGenContext) {
+  int i = 0, nRegion = 0;
+  char *szZipPrefix = nullptr, szAddr[100];
+  int nMaxCities, nMaxCounties;
+  tdef* pTdef;
+
+  nMaxCities = static_cast<int>(get_rowcount(ACTIVE_CITIES, dsdGenContext));
+  nMaxCounties = static_cast<int>(get_rowcount(ACTIVE_COUNTIES, dsdGenContext));
+
+  /* street_number is [1..1000] */
+  genrand_integer(
+      &pAddr->street_num, DIST_UNIFORM, 1, 1000, 0, nColumn, dsdGenContext);
+
+  /* street names are picked from a distribution */
+  pick_distribution(
+      &pAddr->street_name1, "street_names", 1, 1, nColumn, dsdGenContext);
+  pick_distribution(
+      &pAddr->street_name2, "street_names", 1, 2, nColumn, dsdGenContext);
+
+  /* street type is picked from a distribution */
+  pick_distribution(
+      &pAddr->street_type, "street_type", 1, 1, nColumn, dsdGenContext);
+
+  /* suite number is alphabetic 50% of the time */
+  genrand_integer(&i, DIST_UNIFORM, 1, 100, 0, nColumn, dsdGenContext);
+  if (i & 0x01) {
+    auto result = snprintf(
+        pAddr->suite_num, sizeof(pAddr->suite_num), "Suite %d", (i >> 1) * 10);
+    if (result < 0)
+      perror("sprintf failed");
+  } else {
+    auto result = snprintf(
+        pAddr->suite_num,
+        sizeof(pAddr->suite_num),
+        "Suite %c",
+        ((i >> 1) % 25) + 'A');
+    if (result < 0)
+      perror("sprintf failed");
+  }
+
+  pTdef = getTdefsByNumber(
+      getTableFromColumn(nColumn, dsdGenContext), dsdGenContext);
+
+  /* city is picked from a distribution which maps to large/medium/small */
+  if (pTdef->flags & FL_SMALL) {
+    i = static_cast<int>(get_rowcount(
+        getTableFromColumn(nColumn, dsdGenContext), dsdGenContext));
+    genrand_integer(
+        &i,
+        DIST_UNIFORM,
+        1,
+        (nMaxCities > i) ? i : nMaxCities,
+        0,
+        nColumn,
+        dsdGenContext);
+    dist_member(&pAddr->city, "cities", i, 1, dsdGenContext);
+  } else
+    pick_distribution(&pAddr->city, "cities", 1, 6, nColumn, dsdGenContext);
+
+  /* county is picked from a distribution, based on population and keys the
+   * rest */
+  if (pTdef->flags & FL_SMALL) {
+    i = (int)get_rowcount(
+        getTableFromColumn(nColumn, dsdGenContext), dsdGenContext);
+    genrand_integer(
+        &nRegion,
+        DIST_UNIFORM,
+        1,
+        (nMaxCounties > i) ? i : nMaxCounties,
+        0,
+        nColumn,
+        dsdGenContext);
+    dist_member(&pAddr->county, "fips_county", nRegion, 2, dsdGenContext);
+  } else
+    nRegion = pick_distribution(
+        &pAddr->county, "fips_county", 2, 1, nColumn, dsdGenContext);
+
+  /* match state with the selected region/county */
+  dist_member(&pAddr->state, "fips_county", nRegion, 3, dsdGenContext);
+
+  /* match the zip prefix with the selected region/county */
+  pAddr->zip = city_hash(0, pAddr->city);
+  /* 00000 - 00600 are unused. Avoid them */
+  dist_member(
+      static_cast<void*>(&szZipPrefix),
+      "fips_county",
+      nRegion,
+      5,
+      dsdGenContext);
+  if (!(szZipPrefix[0] - '0') && (pAddr->zip < 9400))
+    pAddr->zip += 600;
+  pAddr->zip += (szZipPrefix[0] - '0') * 10000;
+
+  auto result = snprintf(
+      szAddr,
+      sizeof(szAddr),
+      "%d %s %s %s",
+      pAddr->street_num,
+      pAddr->street_name1,
+      pAddr->street_name2,
+      pAddr->street_type);
+  if (result < 0)
+    perror("sprintf failed");
+  pAddr->plus4 = city_hash(0, szAddr);
+  dist_member(&pAddr->gmt_offset, "fips_county", nRegion, 6, dsdGenContext);
+  strcpy(pAddr->country, "United States");
+
+  return (0);
+}
+
+/*
+ * Routine: mk_streetnumber
+ * Purpose:
+ *	one of a set of routines that creates addresses
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ *	nTable: target table (and, by extension, address) to allow differing
+ *distributions dest: destination for the random number Returns: Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20030422 jms should be replaced if there is no table variation
+ */
+int mk_streetnumber(int nTable, int* dest, DSDGenContext& dsdGenContext) {
+  genrand_integer(dest, DIST_UNIFORM, 1, 1000, 0, nTable, dsdGenContext);
+
+  return (0);
+}
+
+/*
+ * Routine: mk_suitenumber()
+ * Purpose:
+ *	one of a set of routines that creates addresses
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ *	nTable: target table (and, by extension, address) to allow differing
+ *distributions dest: destination for the random number Returns: Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20010615 JMS return code is meaningless
+ */
+int mk_suitenumber(int nTable, char* dest, DSDGenContext& dsdGenContext) {
+  int i;
+
+  genrand_integer(&i, DIST_UNIFORM, 1, 100, 0, nTable, dsdGenContext);
+  if (i <= 50) {
+    genrand_integer(&i, DIST_UNIFORM, 1, 1000, 0, nTable, dsdGenContext);
+    auto result = snprintf(dest, 11, "Suite %d", i);
+    if (result < 0)
+      perror("sprintf failed");
+  } else {
+    genrand_integer(&i, DIST_UNIFORM, 0, 25, 0, nTable, dsdGenContext);
+    auto result = snprintf(dest, 10, "Suite %c", i + 'A');
+    if (result < 0)
+      perror("sprintf failed");
+  }
+
+  return (0);
+}
+
+/*
+ * Routine: mk_streetname()
+ * Purpose:
+ *	one of a set of routines that creates addresses
+ * Algorithm:
+ *	use a staggered distibution and the 150 most common street names in the
+ *US Data Structures:
+ *
+ * Params:
+ *	nTable: target table (and, by extension, address) to allow differing
+ *distributions dest: destination for the street name Returns: Called By: Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20010615 JMS return code is meaningless
+ */
+int mk_streetname(int nTable, char* dest, DSDGenContext& dsdGenContext) {
+  char *pTemp1 = nullptr, *pTemp2 = nullptr;
+
+  pick_distribution(
+      static_cast<void*>(&pTemp1),
+      "street_names",
+      (int)1,
+      (int)1,
+      nTable,
+      dsdGenContext);
+  pick_distribution(
+      static_cast<void*>(&pTemp2),
+      "street_names",
+      (int)1,
+      (int)2,
+      nTable,
+      dsdGenContext);
+
+  if (pTemp1 && pTemp2) {
+    if (strlen(pTemp2)) {
+      auto result = snprintf(
+          dest, strlen(pTemp1) + strlen(pTemp2) + 2, "%s %s", pTemp1, pTemp2);
+      if (result < 0)
+        perror("sprintf failed");
+    } else
+      strcpy(dest, pTemp1);
+  }
+
+  return (0);
+}
+
+/*
+ * Routine: mk_city
+ * Purpose:
+ *	one of a set of routines that creates addresses
+ * Algorithm:
+ *	use a staggered distibution of 1000 most common place names in the US
+ * Data Structures:
+ *
+ * Params:
+ *	nTable: target table (and, by extension, address) to allow differing
+ *distributions dest: destination for the city name Returns: Called By: Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20030423 jms should be replaced if there is no per-table variation
+ */
+int mk_city(int nTable, char** dest, DSDGenContext& dsdGenContext) {
+  pick_distribution(
+      static_cast<void*>(dest),
+      "cities",
+      static_cast<int>(1),
+      static_cast<int>(get_int("_SCALE_INDEX", dsdGenContext)),
+      11,
+      dsdGenContext);
+
+  return (0);
+}
+
+/*
+ * Routine: city_hash()
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int city_hash(int nTable, char* name) {
+  char* cp;
+  uint64_t hash_value = 0, res = 0;
+
+  for (cp = name; *cp; cp++) {
+    hash_value *= 26;
+    hash_value -= 'A';
+    hash_value += *cp;
+    if (hash_value > 1000000) {
+      hash_value %= 10000;
+      res += hash_value;
+      hash_value = 0;
+    }
+  }
+  hash_value %= 1000;
+  res += hash_value;
+  res %= 10000; /* looking for a 4 digit result */
+
+  return (res);
+}
+
+/*
+ * Routine:
+ *	one of a set of routines that creates addresses
+ * Algorithm:
+ *	use a compound distribution of the 3500 counties in the US
+ * Data Structures:
+ *
+ * Params:
+ *	nTable: target table (and, by extension, address) to allow differing
+ *distributions dest: destination for the city name nRegion: the county selected
+ *	city: the city name selected
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20010615 JMS return code is meaningless
+ */
+int mk_zipcode(
+    int nTable,
+    char* dest,
+    int nRegion,
+    char* city,
+    DSDGenContext& dsdGenContext) {
+  char* szZipPrefix = nullptr;
+  int nCityCode;
+  int nPlusFour;
+
+  if (szZipPrefix) {
+    dist_member(
+        static_cast<void*>(&szZipPrefix),
+        "fips_county",
+        nRegion,
+        5,
+        dsdGenContext);
+    nCityCode = city_hash(nTable, city);
+    genrand_integer(
+        &nPlusFour, DIST_UNIFORM, 1, 9999, 0, nTable, dsdGenContext);
+    auto result = snprintf(
+        dest,
+        strlen(szZipPrefix) + 10,
+        "%s%04d-%04d",
+        szZipPrefix,
+        nCityCode,
+        nPlusFour);
+    if (result < 0)
+      perror("sprintf failed");
+  }
+
+  return (0);
+}
diff --git a/velox/tpcds/gen/dsdgen/build_support.cpp b/velox/tpcds/gen/dsdgen/build_support.cpp
new file mode 100644
index 000000000000..62cf1210e576
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/build_support.cpp
@@ -0,0 +1,458 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#ifndef WIN32
+#include <netinet/in.h>
+#endif
+#include <math.h>
+#include "velox/tpcds/gen/dsdgen/include/StringBuffer.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+/*
+ * Routine: hierarchy_item
+ * Purpose:
+ *	select the hierarchy entry for this level
+ * Algorithm: Assumes a top-down ordering
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+void hierarchy_item(
+    int h_level,
+    ds_key_t* id,
+    char** name,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext) {
+  static int nLastCategory = -1, nLastClass = -1, nBrandBase;
+  int nBrandCount = 0;
+  static char* szClassDistName = nullptr;
+
+  switch (h_level) {
+    case I_CATEGORY:
+      nLastCategory =
+          pick_distribution(name, "categories", 1, 1, h_level, dsdGenContext);
+      *id = nLastCategory;
+      nBrandBase = nLastCategory;
+      nLastClass = -1;
+      break;
+    case I_CLASS:
+      if (nLastCategory == -1)
+        ReportErrorNoLine(
+            DBGEN_ERROR_HIERACHY_ORDER, "I_CLASS before I_CATEGORY", 1);
+      dist_member(
+          &szClassDistName, "categories", nLastCategory, 2, dsdGenContext);
+      nLastClass = pick_distribution(
+          name, szClassDistName, 1, 1, h_level, dsdGenContext);
+      nLastCategory = -1;
+      *id = nLastClass;
+      break;
+    case I_BRAND: {
+      if (nLastClass == -1)
+        ReportErrorNoLine(
+            DBGEN_ERROR_HIERACHY_ORDER, "I_BRAND before I_CLASS", 1);
+      dist_member(&nBrandCount, szClassDistName, nLastClass, 2, dsdGenContext);
+      *id = kIndex % nBrandCount + 1;
+      mk_word(
+          *name,
+          "brand_syllables",
+          nBrandBase * 10 + nLastClass,
+          45,
+          I_BRAND,
+          dsdGenContext);
+      int idValue = static_cast<int>(*id);
+      std::vector<char> sTemp(6 + std::to_string(idValue).size());
+      auto result = snprintf(sTemp.data(), sTemp.size(), " #%d", idValue);
+      if (result < 0)
+        perror("sprintf failed");
+      strcat(*name, sTemp.data());
+      *id += (nBrandBase * 1000 + nLastClass) * 1000;
+      break;
+    }
+    default:
+      auto result = printf(
+          "ERROR: Invalid call to hierarchy_item with argument '%d'\n",
+          h_level);
+      if (result < 0)
+        perror("sprintf failed");
+      exit(1);
+  }
+
+  return;
+}
+
+/*
+ * Routine: mk_companyname()
+ * Purpose:
+ *	yet another member of a set of routines used for address creation
+ * Algorithm:
+ *	create a hash, based on an index value, so that the same result can be
+ *derived reliably and then build a word from a syllable set Data Structures:
+ *
+ * Params:
+ *	char * dest: target for resulting name
+ *	int nTable: to allow differing distributions
+ *	int nCompany: index value
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ *	20010615 JMS return code is meaningless
+ *	20030422 JMS should be replaced if there is no per-table variation
+ */
+int mk_companyname(
+    char* dest,
+    int nTable,
+    int nCompany,
+    DSDGenContext& dsdGenContext) {
+  mk_word(dest, "syllables", nCompany, 10, CC_COMPANY_NAME, dsdGenContext);
+
+  return (0);
+}
+
+/*
+ * Routine: set_locale()
+ * Purpose:
+ *	generate a reasonable lattitude and longitude based on a region and the
+ *USGS data on 3500 counties in the US Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20011230 JMS set_locale() is just a placeholder; do we need geographic
+ *coords?
+ */
+int set_locale(int nRegion, decimal_t* longitude, decimal_t* latitude) {
+  static int init = 0;
+  static decimal_t dZero;
+
+  if (!init) {
+    strtodec(&dZero, "0.00");
+    init = 1;
+  }
+
+  memcpy(longitude, &dZero, sizeof(decimal_t));
+  memcpy(latitude, &dZero, sizeof(decimal_t));
+
+  return (0);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void bitmap_to_dist(
+    void* pDest,
+    const char* distname,
+    ds_key_t* modulus,
+    int vset,
+    int stream,
+    DSDGenContext& dsdGenContext) {
+  int32_t m, s;
+  unsigned int len = strlen(distname);
+  std::vector<char> msg(len + 31);
+
+  if ((s = distsize(distname, dsdGenContext)) == -1) {
+    auto result = snprintf(
+        msg.data(), msg.size(), "Invalid distribution name '%s'", distname);
+    if (result < 0)
+      perror("sprintf failed");
+    INTERNAL(msg.data());
+  }
+  m = static_cast<int32_t>((*modulus % s) + 1);
+  *modulus /= s;
+
+  dist_member(pDest, distname, m, vset, dsdGenContext);
+
+  return;
+}
+
+/*
+ * Routine: void dist_to_bitmap(int *pDest, char *szDistName, int nValueSet, int
+ * nWeightSet, int nStream) Purpose: Reverse engineer a composite key based on
+ * distributions Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void dist_to_bitmap(
+    int* pDest,
+    const char* szDistName,
+    int nValue,
+    int nWeight,
+    int nStream,
+    DSDGenContext& dsdGenContext) {
+  *pDest *= distsize(szDistName, dsdGenContext);
+  *pDest += pick_distribution(
+      NULL, szDistName, nValue, nWeight, nStream, dsdGenContext);
+
+  return;
+}
+
+/*
+ * Routine: void random_to_bitmap(int *pDest, int nDist, int nMin, int nMax, int
+ * nMean, int nStream) Purpose: Reverse engineer a composite key based on an
+ * integer range Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void random_to_bitmap(
+    int* pDest,
+    int nDist,
+    int nMin,
+    int nMax,
+    int nMean,
+    int nStream,
+    DSDGenContext& dsdGenContext) {
+  *pDest *= nMax;
+  *pDest +=
+      genrand_integer(NULL, nDist, nMin, nMax, nMean, nStream, dsdGenContext);
+
+  return;
+}
+
+/*
+ * Routine: mk_word()
+ * Purpose:
+ *	generate a gibberish word from a given syllable set
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+void mk_word(
+    char* dest,
+    const char* syl_set,
+    ds_key_t src,
+    int char_cnt,
+    int col,
+    DSDGenContext& dsdGenContext) {
+  ds_key_t i = src, nSyllableCount;
+  char* cp = nullptr;
+
+  *dest = '\0';
+  while (i > 0) {
+    nSyllableCount = distsize(syl_set, dsdGenContext);
+    dist_member(
+        &cp,
+        syl_set,
+        static_cast<int>(i % nSyllableCount) + 1,
+        1,
+        dsdGenContext);
+    i /= nSyllableCount;
+    if (static_cast<int>(strlen(dest) + strlen(cp)) <= char_cnt)
+      strcat(dest, cp);
+    else
+      break;
+  }
+
+  return;
+}
+
+/*
+ * Routine: mk_surrogate()
+ * Purpose: create a character based surrogate key from a 64-bit value
+ * Algorithm: since the RNG routines produce a 32bit value, and surrogate keys
+ *can reach beyond that, use the RNG output to generate the lower end of a
+ *random string, and build the upper end from a ds_key_t Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls: ltoc()
+ * Assumptions: output is a 16 character string. Space is not checked
+ * Side Effects:
+ * TODO:
+ * 20020830 jms may need to define a 64-bit form of htonl() for portable shift
+ *operations
+ */
+void ltoc(char* szDest, unsigned long nVal) {
+  char szXlate[16] = {
+      'A',
+      'B',
+      'C',
+      'D',
+      'E',
+      'F',
+      'G',
+      'H',
+      'I',
+      'J',
+      'K',
+      'L',
+      'M',
+      'N',
+      'O',
+      'P'};
+
+  char c;
+  for (int i = 0; i < 8; i++) {
+    c = szXlate[(static_cast<uint32_t>(nVal) & 0xF)];
+    *szDest++ = c;
+    nVal >>= 4;
+  }
+  *szDest = '\0';
+}
+
+void mk_bkey(char* szDest, ds_key_t kPrimary, int nStream) {
+  unsigned long nTemp;
+
+  nTemp = static_cast<unsigned long>(kPrimary >> 32);
+  ltoc(szDest, nTemp);
+
+  nTemp =
+      static_cast<unsigned long>(static_cast<uint32_t>(kPrimary) & 0xFFFFFFFF);
+  ltoc(szDest + 8, nTemp);
+
+  return;
+}
+
+/*
+ * Routine: embed_string(char *szDest, char *szDist, int nValue, int nWeight,
+ * int nStream, DSDGenContext& dsdGenContext) Purpose: Algorithm: Data
+ * Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int embed_string(
+    char* szDest,
+    const char* szDist,
+    int nValue,
+    int nWeight,
+    int nStream,
+    DSDGenContext& dsdGenContext) {
+  int nPosition = 0;
+  char* szWord = nullptr;
+
+  pick_distribution(&szWord, szDist, nValue, nWeight, nStream, dsdGenContext);
+  nPosition = genrand_integer(
+      NULL,
+      DIST_UNIFORM,
+      0,
+      strlen(szDest) - strlen(szWord) - 1,
+      0,
+      nStream,
+      dsdGenContext);
+  memcpy(&szDest[nPosition], szWord, sizeof(char) * strlen(szWord));
+
+  return (0);
+}
+
+/*
+ * Routine: adjust the valid date window for source schema tables, based on
+ *	based on the update count, update window size, etc.
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void setUpdateDateRange(
+    int nTable,
+    date_t* pMinDate,
+    date_t* pMaxDate,
+    DSDGenContext& dsdGenContext) {
+  static int nUpdateNumber;
+
+  if (!dsdGenContext.setUpdateDateRange_init) {
+    nUpdateNumber = get_int("UPDATE", dsdGenContext);
+    dsdGenContext.setUpdateDateRange_init = 1;
+  }
+
+  switch (nTable) /* no per-table changes at the moment; but could be */
+  {
+    default:
+      strtodt(pMinDate, WAREHOUSE_LOAD_DATE);
+      pMinDate->julian += UPDATE_INTERVAL * (nUpdateNumber - 1);
+      jtodt(pMinDate, pMinDate->julian);
+      jtodt(pMaxDate, pMinDate->julian + UPDATE_INTERVAL);
+      break;
+  }
+
+  return;
+}
diff --git a/velox/tpcds/gen/dsdgen/date.cpp b/velox/tpcds/gen/dsdgen/date.cpp
new file mode 100644
index 000000000000..301812499fe3
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/date.cpp
@@ -0,0 +1,433 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 <stdlib.h>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#ifndef USE_STDLIB_H
+#include <malloc.h>
+#endif
+#include <math.h>
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/mathops.h"
+
+#define D_CHARS "ymdYMD24" /* valid characters in a DBGDATE setting */
+#define MIN_DATE_INT 18000101
+
+static int m_days[2][13] = {
+    {0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
+    {0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}};
+static const std::vector<const char*> qtr_start =
+    {"", "01-01", "04-01", "07-01", "10-01"};
+const std::vector<const char*> weekday_names = {
+    "",
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"};
+
+/*
+ * Routine: strtodate(char *str)
+ * Purpose: initialize a date_t
+ * Algorithm:
+ * Data Structures:
+ * Params:
+ * Returns: date_t
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+date_t strtodate(const char* str) {
+  date_t res;
+
+  if (sscanf(str, "%d-%d-%d", &res.year, &res.month, &res.day) != 3)
+    INTERNAL("Badly formed string in call to strtodate()");
+  res.flags = 0;
+  res.julian = dttoj(&res);
+
+  return (res);
+}
+
+/*
+ * Routine: jtodt(int src, date_t *dest)
+ * Purpose: convert a number of julian days to a date_t
+ * Algorithm: Fleigel and Van Flandern (CACM, vol 11, #10, Oct. 1968, p. 657)
+ * Data Structures:
+ *
+ * Params: source integer: days since big bang
+ * Returns: date_t *; NULL on failure
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+int jtodt(date_t* dest, int src) {
+  long i = 0, j = 0, l = 0, n = 0;
+
+  if (src < 0)
+    return (-1);
+
+  dest->julian = src;
+  l = src + 68569;
+  n = (int)floor((4 * l) / 146097);
+  l = l - (int)floor((146097 * n + 3) / 4);
+  i = (int)floor((4000 * (l + 1) / 1461001));
+  l = l - (int)floor((1461 * i) / 4) + 31;
+  j = (int)floor((80 * l) / 2447);
+  dest->day = l - (int)floor((2447 * j) / 80);
+  l = (int)floor(j / 11);
+  dest->month = j + 2 - 12 * l;
+  dest->year = 100 * (n - 49) + i + l;
+
+  return (0);
+}
+
+/*
+ * Routine: dttoj(date_t *)
+ * Purpose: convert a date_t to a number of julian days
+ * Algorithm: http://quasar.as.utexas.edu/BillInfo/JulianDatesG.html
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int dttoj(date_t* dt) {
+  int y, m, res = 0;
+
+  y = dt->year;
+  m = dt->month;
+  if (m <= 2) {
+    m += 12;
+    y -= 1;
+  }
+
+  /*
+   * added 1 to get dttoj and jtodt to match
+   */
+  res = dt->day + (153 * m - 457) / 5 + 365 * y + (int)floor(y / 4) -
+      (int)floor(y / 100) + (int)floor(y / 400) + 1721118 + 1;
+
+  return (res);
+}
+
+/*
+ * Routine: strtodt()
+ * Purpose: Convert an ascii string to a date_t structure
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params: char *s, date_t *dest
+ * Returns: int; 0 on success
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: Need to allow for date formats other than Y4MD-
+ */
+int strtodt(date_t* dest, const char* s) {
+  int nRetCode = 0;
+
+  if (s == NULL) {
+    dest = NULL;
+    return (-1);
+  }
+
+  if (sscanf(s, "%4d-%d-%d", &dest->year, &dest->month, &dest->day) != 3) {
+    fprintf(stderr, "ERROR: Invalid string to date conversion in strtodt\n");
+    nRetCode = -1;
+  }
+
+  dest->julian = dttoj(dest);
+
+  return (nRetCode);
+}
+
+/*
+ * Routine: date_init
+ * Purpose: set the date handling parameters
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params: None
+ * Returns: int; 0 on success
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int date_init(void) {
+  printf("date_init is not yet complete\n");
+  exit(1);
+  return (0);
+}
+
+/*
+ * Routine: date_t_op(int op, date_t *operand1, date_t *operand2)
+ * Purpose: execute arbitrary binary operations on date_t's
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ *	20010806 jms	Return code is meaningless
+ */
+int date_t_op(date_t* dest, int op, date_t* d1, date_t* d2) {
+  int tJulian;
+  std::vector<char> tString(20);
+  date_t tDate;
+
+  switch (op) {
+    case OP_FIRST_DOM: /* set to first day of month */
+      tJulian = d1->julian - d1->day + 1;
+      jtodt(dest, tJulian);
+      break;
+    case OP_LAST_DOM: /* set to last day of month */
+      tJulian = d1->julian - d1->day + m_days[is_leap(d1->year)][d1->month];
+      jtodt(dest, tJulian);
+      break;
+    case OP_SAME_LY:
+      if (is_leap(d1->year) && (d1->month == 2) && (d1->day == 29))
+        snprintf(tString.data(), tString.size(), "%d-02-28", d1->year - 1);
+      else
+        snprintf(
+            tString.data(),
+            tString.size(),
+            "%4d-%02d-%02d",
+            d1->year - 1,
+            d1->month,
+            d1->day);
+      strtodt(dest, tString.data());
+      break;
+    case OP_SAME_LQ:
+      switch (d1->month) {
+        case 1:
+        case 2:
+        case 3:
+          snprintf(
+              tString.data(), tString.size(), "%4d-%s", d1->year, qtr_start[1]);
+          strtodt(&tDate, tString.data());
+          tJulian = d1->julian - tDate.julian;
+          snprintf(
+              tString.data(),
+              tString.size(),
+              "%4d-%s",
+              d1->year - 1,
+              qtr_start[4]);
+          strtodt(&tDate, tString.data());
+          tJulian += tDate.julian;
+          jtodt(dest, tJulian);
+          break;
+        case 4:
+        case 5:
+        case 6:
+          snprintf(
+              tString.data(), tString.size(), "%4d-%s", d1->year, qtr_start[2]);
+          strtodt(&tDate, tString.data());
+          tJulian = d1->julian - tDate.julian;
+          snprintf(
+              tString.data(), tString.size(), "%4d-%s", d1->year, qtr_start[1]);
+          strtodt(&tDate, tString.data());
+          tJulian += tDate.julian;
+          jtodt(dest, tJulian);
+          break;
+        case 7:
+        case 8:
+        case 9:
+          snprintf(
+              tString.data(), tString.size(), "%4d-%s", d1->year, qtr_start[3]);
+          strtodt(&tDate, tString.data());
+          tJulian = d1->julian - tDate.julian;
+          snprintf(
+              tString.data(), tString.size(), "%4d-%s", d1->year, qtr_start[2]);
+          strtodt(&tDate, tString.data());
+          tJulian += tDate.julian;
+          jtodt(dest, tJulian);
+          break;
+        case 10:
+        case 11:
+        case 12:
+          snprintf(
+              tString.data(), tString.size(), "%4d-%s", d1->year, qtr_start[4]);
+          strtodt(&tDate, tString.data());
+          tJulian = d1->julian - tDate.julian;
+          snprintf(
+              tString.data(), tString.size(), "%4d-%s", d1->year, qtr_start[3]);
+          strtodt(&tDate, tString.data());
+          tJulian += tDate.julian;
+          jtodt(dest, tJulian);
+          break;
+      }
+      break;
+  }
+
+  return (0);
+}
+
+/*
+ * Routine: set_dow(date *d)
+ * Purpose: perpetual calendar stuff
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+int set_dow(date_t* d) {
+  int doomsday[4] = {3, 2, 0, 5};
+  int known[13] = {0, 3, 0, 0, 4, 9, 6, 11, 8, 5, 10, 7, 12};
+  int last_year = -1, dday;
+  int res = 0, q = 0, r = 0, s = 0;
+
+  if (d->year != last_year) {
+    if (is_leap(d->year)) {
+      /* adjust the known dates for january and february */
+      known[1] = 4;
+      known[2] = 1;
+    } else {
+      known[1] = 3;
+      known[2] = 0;
+    }
+
+    /* calculate the doomsday for the century */
+    dday = d->year / 100;
+    dday -= 15;
+    dday %= 4;
+    dday = doomsday[dday];
+
+    /* and then calculate the doomsday for the year */
+    q = d->year % 100;
+    r = q % 12;
+    q /= 12;
+    s = r / 4;
+    dday += q + r + s;
+    dday %= 7;
+    last_year = d->year;
+  }
+
+  res = d->day;
+  res -= known[d->month];
+  while (res < 0)
+    res += 7;
+  while (res > 6)
+    res -= 7;
+
+  res += dday;
+  res %= 7;
+
+  return (res);
+}
+
+/*
+ * Routine: is_leap(year)
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int is_leap(int year) {
+  return (
+      ((year % 100) == 0)     ? ((((year % 400) % 2) == 0) ? 1 : 0)
+          : ((year % 4) == 0) ? 1
+                              : 0);
+}
+
+/*
+ * Routine: day_number(date_t *)
+ * Purpose:
+ * Algorithm: NOTE: this is NOT the ordinal day in the year, but the ordinal
+ *reference into the calendar distribution for the day; in particular, this
+ *needs to skip over the leap day Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int day_number(date_t* d) {
+  return (m_days[is_leap(d->year)][d->month] + d->day);
+}
+
+/*
+ * Routine: date_part(date_t *, int part)
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int date_part(date_t* d, int part) {
+  switch (part) {
+    case 1:
+      return (d->year);
+    case 2:
+      return (d->month);
+    case 3:
+      return (d->day);
+    default:
+      INTERNAL("Invalid call to date_part()");
+      return (-1);
+  }
+}
diff --git a/velox/tpcds/gen/dsdgen/dbgen_version.cpp b/velox/tpcds/gen/dsdgen/dbgen_version.cpp
new file mode 100644
index 000000000000..549693cda301
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/dbgen_version.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/dbgen_version.h"
+#include <stdio.h>
+#include <time.h>
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int mk_dbgen_version(
+    void* pDest,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext) {
+  time_t ltime = time_t();
+  struct tm* pTimeStamp = nullptr;
+  struct DBGEN_VERSION_TBL* r;
+
+  if (pDest == NULL)
+    r = &dsdGenContext.g_dbgen_version;
+  else
+    r = static_cast<DBGEN_VERSION_TBL*>(pDest);
+
+  if (!dsdGenContext.mk_dbgen_version_init) {
+    memset(&dsdGenContext.g_dbgen_version, 0, sizeof(struct DBGEN_VERSION_TBL));
+    dsdGenContext.mk_dbgen_version_init = 1;
+  }
+
+  time(&ltime); /* Get time in seconds */
+  pTimeStamp = localtime(&ltime); /* Convert time to struct */
+
+  auto result = snprintf(
+      r->szDate,
+      sizeof(r->szDate),
+      "%4d-%02d-%02d",
+      pTimeStamp->tm_year + 1900,
+      pTimeStamp->tm_mon + 1,
+      pTimeStamp->tm_mday);
+  if (result < 0)
+    perror("sprintf failed");
+  result = snprintf(
+      r->szTime,
+      sizeof(r->szTime),
+      "%02d:%02d:%02d",
+      pTimeStamp->tm_hour,
+      pTimeStamp->tm_min,
+      pTimeStamp->tm_sec);
+  if (result < 0)
+    perror("sprintf failed");
+  result = snprintf(
+      r->szVersion,
+      sizeof(r->szVersion),
+      "%d.%d.%d%s",
+      VERSION,
+      RELEASE,
+      MODIFICATION,
+      PATCH);
+  if (result < 0)
+    perror("sprintf failed");
+  strcpy(r->szCmdLineArgs, "--this_table_is_rather_pointless");
+
+  return (0);
+}
+//
+///*
+// * Routine:
+// * Purpose:
+// * Algorithm:
+// * Data Structures:
+// *
+// * Params:
+// * Returns:
+// * Called By:
+// * Calls:
+// * Assumptions:
+// * Side Effects:
+// * TODO: None
+// */
+// int pr_dbgen_version(void *pSrc) {
+//	struct DBGEN_VERSION_TBL *r;
+//
+//	if (pSrc == NULL)
+//		r = &g_dbgen_version;
+//	else
+//		r = pSrc;
+//
+//	print_start(DBGEN_VERSION);
+//	print_varchar(DV_VERSION, r->szVersion, 1);
+//	print_varchar(DV_CREATE_DATE, r->szDate, 1);
+//	print_varchar(DV_CREATE_TIME, r->szTime, 1);
+//	print_varchar(DV_CMDLINE_ARGS, r->szCmdLineArgs, 0);
+//	print_end(DBGEN_VERSION);
+//
+//	return (0);
+//}
diff --git a/velox/tpcds/gen/dsdgen/decimal.cpp b/velox/tpcds/gen/dsdgen/decimal.cpp
new file mode 100644
index 000000000000..b0d2987197b4
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/decimal.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#ifndef USE_STDLIB_H
+#include <malloc.h>
+#endif
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/mathops.h"
+
+/*
+ * Routine: itodec(int src, decimal_t *dest)
+ * Purpose: convert an integer to a decimal_t
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params: source integer
+ * Returns: decimal_t *
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20000104 need to set errno on error
+ */
+int itodec(decimal_t* dest, int src) {
+  int scale = 1, bound = 1;
+
+  while ((bound * 10) <= src) {
+    scale += 1;
+    bound *= 10;
+  }
+
+  dest->precision = 0;
+  dest->scale = scale;
+  dest->number = src;
+
+  return (0);
+}
+
+/*
+ * Routine: strtodec()
+ * Purpose: Convert an ascii string to a decimal_t structure
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params: char *s
+ * Returns: decimal_t *
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int strtodec(decimal_t* dest, const char* s) {
+  int i;
+  char* d_pt;
+  std::vector<char> valbuf(20);
+
+  if (strlen(s) < 20) {
+    strcpy(valbuf.data(), s);
+  }
+  dest->flags = 0;
+  if ((d_pt = strchr(valbuf.data(), '.')) == NULL) {
+    dest->scale = valbuf.size();
+    dest->number = atoi(valbuf.data());
+    dest->precision = 0;
+  } else {
+    *d_pt = '\0';
+    d_pt += 1;
+    dest->scale = valbuf.size();
+    dest->number = atoi(valbuf.data());
+    dest->precision = strlen(d_pt);
+    for (i = 0; i < dest->precision; i++)
+      dest->number *= 10;
+    dest->number += atoi(d_pt);
+  }
+
+  if (*s == '-' && dest->number > 0)
+    dest->number *= -1;
+
+  return (0);
+}
+
+/*
+ * Routine: decimal_t_op(int op, decimal_t *operand1, decimal_t *operand2)
+ * Purpose: execute arbitrary binary operations on decimal_t's
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int decimal_t_op(decimal_t* dest, int op, decimal_t* d1, decimal_t* d2) {
+  int res, np;
+  float f1, f2;
+
+  if ((d1 == NULL) || (d2 == NULL))
+    return (-1);
+
+  dest->scale = (d1->scale > d2->scale) ? d1->scale : d2->scale;
+  if (d1->precision > d2->precision) {
+    dest->precision = d1->precision;
+  } else {
+    dest->precision = d2->precision;
+  }
+
+  switch (op) {
+    case OP_PLUS:
+      dest->number = d1->number + d2->number;
+      break;
+    case OP_MINUS:
+      dest->number = d1->number - d2->number;
+      break;
+    case OP_MULT:
+      res = d1->precision + d2->precision;
+      dest->number = d1->number * d2->number;
+      while (res-- > dest->precision)
+        dest->number /= 10;
+      break;
+    case OP_DIV:
+      f1 = static_cast<float>(d1->number);
+      np = d1->precision;
+      while (np < dest->precision) {
+        f1 *= 10.0;
+        np += 1;
+      }
+      np = 0;
+      while (np < dest->precision) {
+        f1 *= 10.0;
+        np += 1;
+      }
+      f2 = static_cast<float>(d2->number);
+      np = d2->precision;
+      while (np < dest->precision) {
+        f2 *= 10.0;
+        np += 1;
+      }
+
+      dest->number = static_cast<int>(f1 / f2);
+      break;
+    default: {
+      auto result = printf("decimal_t_op does not support op %d\n", op);
+      if (result < 0)
+        perror("sprintf failed");
+      exit(1);
+      break;
+    }
+  }
+
+  return (0);
+}
diff --git a/velox/tpcds/gen/dsdgen/dist.cpp b/velox/tpcds/gen/dsdgen/dist.cpp
new file mode 100644
index 000000000000..442ae340e5dc
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/dist.cpp
@@ -0,0 +1,925 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#define MAX_LINE_LEN 120
+#ifdef WIN32
+#define OPTION_START '/'
+#else
+#define OPTION_START '-'
+#endif
+#ifdef _WIN32
+#include <io.h> // @manual
+#include <search.h>
+#include <stdlib.h>
+#include <winsock.h> // @manual
+#else
+#include <netinet/in.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+#ifdef NCR
+#include <sys/types.h>
+#endif
+#ifndef USE_STDLIB_H
+#include <malloc.h>
+#endif
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/dcomp.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/tpcds_idx.hpp"
+#ifdef TEST
+option_t options[] = {
+    {"DISTRIBUTIONS",
+     OPT_STR,
+     2,
+     "read distributions from file <s>",
+     NULL,
+     "tester_dist.idx"},
+    NULL};
+
+char params[2];
+struct {
+  char* name;
+} tdefs[] = {NULL};
+#endif
+
+/* NOTE: these need to be in sync with a_dist.h */
+#define D_NAME_LEN 20
+#define FL_LOADED 0x01
+static int load_dist(d_idx_t* d);
+
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+
+/*
+ * Routine: release(char *param_name, char *msg)
+ * Purpose: display version information
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int printReleaseInfo(
+    const char* param_name,
+    const char* msg,
+    DSDGenContext& dsdGenContext) {
+  auto result = fprintf(
+      stderr,
+      "%s Population Generator (Version %d.%d.%d%s)\n",
+      get_str("PROG", dsdGenContext),
+      VERSION,
+      RELEASE,
+      MODIFICATION,
+      PATCH);
+  if (result < 0)
+    perror("sprintf failed");
+  result = fprintf(stderr, "Copyright %s %s\n", COPYRIGHT, C_DATES);
+  if (result < 0)
+    perror("sprintf failed");
+
+  exit(0);
+}
+
+/*
+ * Routine: usage(char *param_name, char *msg)
+ * Purpose: display a usage message, with an optional error message
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int usage(
+    const char* param_name,
+    const char* msg,
+    DSDGenContext& dsdGenContext) {
+  init_params(dsdGenContext);
+
+  auto result = fprintf(
+      stderr,
+      "%s Population Generator (Version %d.%d.%d%s)\n",
+      get_str("PROG", dsdGenContext),
+      VERSION,
+      RELEASE,
+      MODIFICATION,
+      PATCH);
+  if (result < 0)
+    perror("sprintf failed");
+  result = fprintf(stderr, "Copyright %s %s\n", COPYRIGHT, C_DATES);
+  if (result < 0)
+    perror("sprintf failed");
+
+  if (msg != NULL)
+    printf("\nERROR: %s\n\n", msg);
+
+  printf("\n\nUSAGE: %s [options]\n", get_str("PROG", dsdGenContext));
+  printf(
+      "\nNote: When defined in a parameter file (using -p), parmeters "
+      "should\n");
+  printf("use the form below. Each option can also be set from the command\n");
+  printf("line, using a form of '%cparam [optional argument]'\n", OPTION_START);
+  printf("Unique anchored substrings of options are also recognized, and \n");
+  printf(
+      "case is ignored, so '%csc' is equivalent to '%cSCALE'\n\n",
+      OPTION_START,
+      OPTION_START);
+  printf("General Options\n===============\n");
+  print_options(dsdGenContext.options, 0, dsdGenContext);
+  printf("\n");
+  printf("Advanced Options\n===============\n");
+  print_options(dsdGenContext.options, 1, dsdGenContext);
+  printf("\n");
+  exit((msg == NULL) ? 0 : 1);
+}
+
+/*
+ * Routine: read_file(char *param_name, char *fname)
+ * Purpose: process a parameter file
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int read_file(
+    const char* param_name,
+    const char* optarg,
+    DSDGenContext& dsdGenContext) {
+  FILE* fp = nullptr;
+  char* cp = nullptr;
+  char line[MAX_LINE_LEN];
+  char name[100];
+  int index = 0;
+
+  init_params(dsdGenContext);
+
+  if ((fp = fopen(optarg, "r")) == NULL)
+    return (-1);
+  while (fgets(line, MAX_LINE_LEN, fp) != NULL) {
+    if ((cp = strchr(line, '\n')) != NULL)
+      *cp = '\0';
+    if ((cp = strchr(line, '-')) != NULL)
+      if (*(cp + 1) == '-')
+        *cp = '\0';
+    if ((cp = strtok(line, " \t=\n")) != NULL) {
+      strcpy(name, cp);
+      index = fnd_param(name, dsdGenContext);
+      if (index == -1)
+        continue; /* JMS: errors are silently ignored */
+      cp += strlen(cp) + 1;
+      while (*cp && strchr(" \t =", *cp))
+        cp++;
+
+      /* command line options over-ride those in a file */
+      if (static_cast<unsigned int>(dsdGenContext.options[index].flags) &
+          OPT_SET)
+        continue;
+
+      if (*cp) {
+        switch (static_cast<unsigned int>(dsdGenContext.options[index].flags) &
+                TYPE_MASK) {
+          case OPT_INT:
+            if ((cp = strtok(cp, " \t\n")) != NULL)
+              set_option(name, cp);
+            break;
+          case OPT_STR:
+          case OPT_FLG:
+            set_option(name, cp);
+            break;
+        }
+      }
+    }
+  }
+
+  fclose(fp);
+
+  return (0);
+}
+
+/*
+ * Routine: set_scale()
+ * Purpose: link SCALE and SCALE_INDEX
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int SetScaleIndex(
+    const char* szName,
+    const char* szValue,
+    DSDGenContext& dsdGenContext) {
+  char szScale[2];
+  int nScale;
+
+  if ((nScale = atoi(szValue)) == 0)
+    nScale = 1;
+
+  nScale = 1 + static_cast<int>(log10(nScale));
+  szScale[0] = '0' + nScale;
+  szScale[1] = '\0';
+
+  set_int("_SCALE_INDEX", szScale, dsdGenContext);
+
+  return (atoi(szValue));
+}
+
+/*
+ * Routine: print_options(struct OPTION_T *o, int file, int depth)
+ * Purpose: print a summary of options
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+static void print_options(
+    struct OPTION_T* o,
+    int bShowOptional,
+    DSDGenContext& dsdGenContext) {
+  int w_adjust = 0, bShow = 0, nCount = 0;
+
+  for (int i = 0; dsdGenContext.options[i].name != NULL; i++) {
+    /*
+     * options come in two groups, general and "hidden". Decide which group
+     * to show in this pass, and ignore others
+     */
+    bShow = 0;
+    if (bShowOptional && (static_cast<unsigned int>(o[i].flags) & OPT_ADV))
+      bShow = 1;
+    if (!bShowOptional && !(static_cast<unsigned int>(o[i].flags) & OPT_ADV))
+      bShow = 1;
+
+    if (!bShow || (static_cast<unsigned int>(o[i].flags) & OPT_HIDE))
+      continue;
+
+    nCount += 1;
+    printf("%s = ", o[i].name);
+    w_adjust = 15 - strlen(o[i].name);
+    if (static_cast<unsigned int>(o[i].flags) & OPT_INT)
+      printf(" <n>   ");
+    else if (static_cast<unsigned int>(o[i].flags) & OPT_STR)
+      printf(" <s>   ");
+    else if (static_cast<unsigned int>(o[i].flags) & OPT_SUB)
+      printf(" <opt> ");
+    else if (static_cast<unsigned int>(o[i].flags) & OPT_FLG)
+      printf(" [Y|N] ");
+    else
+      printf("       ");
+    printf("%*s-- %s", w_adjust, " ", o[i].usage);
+    if (static_cast<unsigned int>(o[i].flags) & OPT_NOP)
+      printf(" NOT IMPLEMENTED");
+    printf("\n");
+  }
+
+  if (nCount == 0)
+    printf("None defined.\n");
+
+  return;
+}
+
+/*
+ * Routine: di_compare()
+ * Purpose: comparison routine for two d_idx_t entries; used by qsort
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int di_compare(const void* op1, const void* op2) {
+  d_idx_t *ie1 = (d_idx_t*)op1, *ie2 = (d_idx_t*)op2;
+
+  return (strcasecmp(ie1->name, ie2->name));
+}
+
+int load_dists() {
+  /* open the dist file */
+  auto read_ptr = tpcds_idx;
+  int32_t temp;
+  memcpy(&temp, read_ptr, sizeof(int32_t));
+  read_ptr += sizeof(int32_t);
+  int entry_count = ntohl(temp);
+  read_ptr = tpcds_idx + tpcds_idx_len - (entry_count * IDX_SIZE);
+  for (int i = 0; i < entry_count; i++) {
+    d_idx_t entry;
+    memset(reinterpret_cast<uint8_t*>(&entry), 0, sizeof(const d_idx_t));
+    memcpy(entry.name, read_ptr, D_NAME_LEN);
+    read_ptr += D_NAME_LEN;
+    entry.name[D_NAME_LEN] = '\0';
+    memcpy(&temp, read_ptr, sizeof(int32_t));
+    read_ptr += sizeof(int32_t);
+    entry.index = ntohl(temp);
+    memcpy(&temp, read_ptr, sizeof(int32_t));
+    read_ptr += sizeof(int32_t);
+    entry.offset = ntohl(temp);
+    memcpy(&temp, read_ptr, sizeof(int32_t));
+    read_ptr += sizeof(int32_t);
+    entry.str_space = ntohl(temp);
+    memcpy(&temp, read_ptr, sizeof(int32_t));
+    read_ptr += sizeof(int32_t);
+    entry.length = ntohl(temp);
+    memcpy(&temp, read_ptr, sizeof(int32_t));
+    read_ptr += sizeof(int32_t);
+    entry.w_width = ntohl(temp);
+    memcpy(&temp, read_ptr, sizeof(int32_t));
+    read_ptr += sizeof(int32_t);
+    entry.v_width = ntohl(temp);
+    memcpy(&temp, read_ptr, sizeof(int32_t));
+    read_ptr += sizeof(int32_t);
+    entry.name_space = ntohl(temp);
+    load_dist(&entry);
+    auto lockedMap = idx_.wlock();
+    lockedMap->emplace(std::string(entry.name), entry);
+  }
+  return (1);
+}
+/*
+ * Routine: find_dist(char *name, DSDGenContext& dsdGenContext)
+ * Purpose: translate from dist_t name to d_idx_t *
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+const d_idx_t* find_dist(const char* name) {
+  std::call_once(initFlag_, []() { load_dists(); });
+
+  std::string key(name);
+  auto lockedMap = idx_.rlock();
+  if (lockedMap->find(key) != lockedMap->end()) {
+    return &(lockedMap->at(key));
+  }
+  return nullptr;
+}
+
+/*
+ * Routine: load_dist(int fd, dist_t *d, DSDGenContext& dsdGenContext)
+ * Purpose: load a particular distribution
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+static int load_dist(d_idx_t* di) {
+  int res = 0, i = 0, j = 0;
+  dist_t* d;
+  int32_t temp;
+  FILE* ifp;
+
+  if (di->flags != FL_LOADED) /* make sure no one beat us to it */
+  {
+    auto read_ptr = tpcds_idx;
+    read_ptr += di->offset;
+    d = &di->dist;
+
+    /* load the type information */
+    d->type_vector.resize(di->v_width);
+    for (i = 0; i < di->v_width; i++) {
+      if (read_ptr)
+        memcpy(&temp, read_ptr, sizeof(int32_t));
+      read_ptr += sizeof(int32_t);
+      d->type_vector[i] = ntohl(temp);
+    }
+
+    /* load the weights */
+    d->weight_sets.resize(di->w_width);
+    d->maximums.resize(di->w_width);
+    for (i = 0; i < di->w_width; i++) {
+      d->weight_sets[i].resize(di->length);
+      d->maximums[i] = 0;
+      for (j = 0; j < di->length; j++) {
+        if (read_ptr)
+          memcpy(&temp, read_ptr, sizeof(int32_t));
+        read_ptr += sizeof(int32_t);
+        d->weight_sets[i][j] = ntohl(temp);
+        /* calculate the maximum weight and convert sets to cummulative
+         */
+        d->maximums[i] += d->weight_sets[i][j];
+        d->weight_sets[i][j] = d->maximums[i];
+      }
+    }
+
+    /* load the value offsets */
+    d->value_sets.resize(di->v_width);
+    for (i = 0; i < di->v_width; i++) {
+      d->value_sets[i].resize(di->length);
+      for (j = 0; j < di->length; j++) {
+        if (read_ptr)
+          memcpy(&temp, read_ptr, sizeof(int32_t));
+        read_ptr += sizeof(int32_t);
+        d->value_sets[i][j] = ntohl(temp);
+      }
+    }
+
+    /* load the column aliases, if they were defined */
+    if (di->name_space) {
+      d->names.resize(di->name_space);
+      if (read_ptr)
+        memcpy(d->names.data(), read_ptr, di->name_space);
+      read_ptr += di->name_space * sizeof(char);
+    }
+
+    /* and finally the values themselves */
+    d->strings.resize(di->str_space);
+    if (read_ptr)
+      memcpy(d->strings.data(), read_ptr, di->str_space);
+    read_ptr += di->str_space * sizeof(char);
+    di->flags = FL_LOADED;
+  }
+
+  return (res);
+}
+
+/*
+ * Routine: void *dist_op()
+ * Purpose: select a value/weight from a distribution
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:	char *d_name
+ *			int vset: which set of values
+ *			int wset: which set of weights
+ * Returns: appropriate data type cast as a void *
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20000317 Need to be sure this is portable to NT and others
+ */
+int dist_op(
+    void* dest,
+    int op,
+    const char* d_name,
+    int vset,
+    int wset,
+    int stream,
+    DSDGenContext& dsdGenContext) {
+  int level = 0, index = 0, dt = 0;
+  int i_res = 1;
+  const d_idx_t* d;
+
+  if ((d = find_dist(d_name)) == nullptr) {
+    std::vector<char> msg(40 + strlen(d_name));
+    auto result = snprintf(
+        msg.data(), msg.size(), "Invalid distribution name '%s'", d_name);
+    if (result < 0)
+      perror("sprintf failed");
+    INTERNAL(msg.data());
+    assert(d != nullptr);
+  }
+
+  const dist_t* dist = &d->dist;
+
+  if (op == 0) {
+    genrand_integer(
+        &level,
+        DIST_UNIFORM,
+        1,
+        dist->maximums[wset - 1],
+        0,
+        stream,
+        dsdGenContext);
+    while (level > dist->weight_sets[wset - 1][index] && index < d->length)
+      index += 1;
+    dt = vset - 1;
+    if ((index >= d->length) || (dt > d->v_width))
+      INTERNAL("Distribution overrun");
+  } else {
+    index = vset - 1;
+    dt = wset - 1;
+    if (index >= d->length || index < 0) {
+      auto result =
+          fprintf(stderr, "Runtime ERROR: Distribution over-run/under-run\n");
+      if (result < 0)
+        perror("sprintf failed");
+      result = fprintf(
+          stderr,
+          "Check distribution definitions and usage for %s.\n",
+          d->name);
+      if (result < 0)
+        perror("sprintf failed");
+      result = fprintf(stderr, "index = %d, length=%d.\n", index, d->length);
+      if (result < 0)
+        perror("sprintf failed");
+      exit(1);
+    }
+  }
+  const char* char_val = dist->strings.data() + dist->value_sets[dt][index];
+
+  switch (dist->type_vector[dt]) {
+    case TKN_VARCHAR:
+      if (dest)
+        *static_cast<const char**>(dest) = static_cast<const char*>(char_val);
+      break;
+    case TKN_INT:
+      i_res = atoi(char_val);
+      if (dest)
+        *static_cast<int*>(dest) = i_res;
+      break;
+    case TKN_DATE:
+      strtodt(*static_cast<date_t**>(dest), char_val);
+      break;
+    case TKN_DECIMAL:
+      strtodec(*static_cast<decimal_t**>(dest), char_val);
+      break;
+  }
+
+  return (
+      (dest == nullptr)
+          ? i_res
+          : index + 1); /* shift back to the 1-based indexing scheme */
+}
+
+/*
+ * Routine: int dist_weight
+ * Purpose: return the weight of a particular member of a distribution
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:	distribution *d
+ *			int index: which "row"
+ *			int wset: which set of weights
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ *	20000405 need to add error checking
+ */
+int dist_weight(
+    int* dest,
+    const char* d,
+    int index,
+    int wset,
+    DSDGenContext& /*dsdGenContext*/) {
+  int res = 0;
+  const d_idx_t* d_idx;
+
+  if ((d_idx = find_dist(d)) == nullptr) {
+    std::vector<char> msg(40 + strlen(d));
+    snprintf(msg.data(), msg.size(), "Invalid distribution name '%s'", d);
+    INTERNAL(msg.data());
+  }
+
+  const dist_t* dist = &d_idx->dist;
+  assert(index > 0);
+  assert(wset > 0);
+  res = dist->weight_sets[wset - 1][index - 1];
+  /* reverse the accumulation of weights */
+  if (index > 1)
+    res -= dist->weight_sets[wset - 1][index - 2];
+
+  if (dest == nullptr)
+    return (res);
+
+  *dest = res;
+
+  return (0);
+}
+
+/*
+ * Routine: int distsize(char *name)
+ * Purpose: return the size of a distribution
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ *	20000405 need to add error checking
+ */
+int distsize(const char* name, DSDGenContext& /*dsdGenContext*/) {
+  const d_idx_t* dist;
+
+  dist = find_dist(name);
+
+  if (dist == NULL)
+    return (-1);
+
+  return (dist->length);
+}
+
+/*
+ * Routine: int dist_type(char *name, int nValueSet)
+ * Purpose: return the type of the n-th value set in a distribution
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+int dist_type(const char* name, int nValueSet, DSDGenContext& dsdGenContext) {
+  const d_idx_t* dist;
+
+  dist = find_dist(name);
+
+  if (dist == nullptr)
+    return (-1);
+
+  if (nValueSet < 1 || nValueSet > dist->v_width)
+    return (-1);
+
+  return (dist->dist.type_vector[nValueSet - 1]);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void dump_dist(const char* name, DSDGenContext& dsdGenContext) {
+  const d_idx_t* pIndex = nullptr;
+  int i, j;
+  char* pCharVal = nullptr;
+  int nVal = 0;
+
+  pIndex = find_dist(name);
+  if (pIndex == nullptr)
+    ReportErrorNoLine(QERR_BAD_NAME, name, 1);
+  printf("create %s;\n", pIndex->name);
+  printf("set types = (");
+  for (i = 0; i < pIndex->v_width; i++) {
+    if (i > 0)
+      printf(", ");
+    printf(
+        "%s", dist_type(name, i + 1, dsdGenContext) == 7 ? "int" : "varchar");
+  }
+  printf(");\n");
+  printf("set weights = %d;\n", pIndex->w_width);
+  for (i = 0; i < pIndex->length; i++) {
+    printf("add(");
+    for (j = 0; j < pIndex->v_width; j++) {
+      if (j)
+        printf(", ");
+      if (dist_type(name, j + 1, dsdGenContext) != 7) {
+        dist_member(&pCharVal, name, i + 1, j + 1, dsdGenContext);
+        printf("\"%s\"", pCharVal);
+      } else {
+        dist_member(&nVal, name, i + 1, j + 1, dsdGenContext);
+        printf("%d", nVal);
+      }
+    }
+    printf("; ");
+    for (j = 0; j < pIndex->w_width; j++) {
+      if (j)
+        printf(", ");
+      printf("%d", dist_weight(nullptr, name, i + 1, j + 1, dsdGenContext));
+    }
+    printf(");\n");
+  }
+
+  return;
+}
+
+/*
+ * Routine: dist_active(char *szName, int nWeightSet)
+ * Purpose: return number of entries with non-zero weght values
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int dist_active(
+    const char* szName,
+    int nWeightSet,
+    DSDGenContext& dsdGenContext) {
+  int nSize, nResult = 0, i = 0;
+
+  nSize = distsize(szName, dsdGenContext);
+  for (i = 1; i <= nSize; i++) {
+    if (dist_weight(nullptr, szName, i, nWeightSet, dsdGenContext) != 0)
+      nResult += 1;
+  }
+
+  return (nResult);
+}
+
+/*
+ * Routine: findDistValue(char *szValue, char *szDistName, int nValueSet)
+ * Purpose: Return the row number where the entry is found
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20031024 jms this routine needs to handle all data types, not just varchar
+ */
+int findDistValue(
+    const char* szValue,
+    const char* szDistName,
+    int ValueSet,
+    DSDGenContext& dsdGenContext) {
+  std::vector<char> szDistValue(128);
+  int nRetValue = 1, nDistMax;
+
+  nDistMax = distsize(szDistName, dsdGenContext);
+
+  for (nRetValue = 1; nRetValue < nDistMax; nRetValue++) {
+    dist_member(&szDistValue, szDistName, nRetValue, ValueSet, dsdGenContext);
+    if (strcmp(szValue, szDistValue.data()) == 0)
+      break;
+  }
+
+  if (nRetValue <= nDistMax)
+    return (nRetValue);
+  return (-1);
+}
+
+void DSDGenContext::Reset() {
+  init_rand_init = 0;
+  mk_address_init = 0;
+  setUpdateDateRange_init = 0;
+  mk_dbgen_version_init = 0;
+  getCatalogNumberFromPage_init = 0;
+  checkSeeds_init = 0;
+  dateScaling_init = 0;
+  mk_w_call_center_init = 0;
+  mk_w_catalog_page_init = 0;
+  mk_master_catalog_sales_init = 0;
+  dectostr_init = 0;
+  date_join_init = 0;
+  setSCDKeys_init = 0;
+  scd_join_init = 0;
+  matchSCDSK_init = 0;
+  skipDays_init = 0;
+  mk_w_catalog_returns_init = 0;
+  mk_detail_catalog_sales_init = 0;
+  mk_w_customer_init = 0;
+  mk_w_date_init = 0;
+  mk_w_inventory_init = 0;
+  mk_w_item_init = 0;
+  mk_w_promotion_init = 0;
+  mk_w_reason_init = 0;
+  mk_w_ship_mode_init = 0;
+  mk_w_store_returns_init = 0;
+  mk_master_store_sales_init = 0;
+  mk_w_store_init = 0;
+  mk_w_web_page_init = 0;
+  mk_w_web_returns_init = 0;
+  mk_master_init = 0;
+  mk_detail_init = 0;
+  mk_w_web_site_init = 0;
+  mk_cust_init = 0;
+  mk_order_init = 0;
+  mk_part_init = 0;
+  mk_supp_init = 0;
+  dbg_text_init = 0;
+  find_dist_init = 0;
+  cp_join_init = 0;
+  web_join_init = 0;
+  set_pricing_init = 0;
+  init_params_init = 0;
+  get_rowcount_init = 0;
+  mk_detail_web_sales_init = 0;
+  mk_master_web_sales_init = 0;
+}
+
+#ifdef TEST
+main() {
+  int i_res;
+  char* c_res;
+  decimal_t dec_res;
+
+  init_params();
+
+  dist_member(&i_res, "test_dist", 1, 1);
+  if (i_res != 10) {
+    printf("dist_member(\"test_dist\", 1, 1): %d != 10\n", i_res);
+    exit(1);
+  }
+  dist_member(&i_res, "test_dist", 1, 2);
+  if (i_res != 60) {
+    printf("dist_member(\"test_dist\", 1, 2): %d != 60\n", i_res);
+    exit(1);
+  }
+  dist_member((void*)&c_res, "test_dist", 1, 3);
+  if (strcmp(c_res, "El Camino")) {
+    printf("dist_member(\"test_dist\", 1, 3): %s != El Camino\n", c_res);
+    exit(1);
+  }
+  dist_member((void*)&dec_res, "test_dist", 1, 4);
+  if (strcmp(dec_res.number, "1") || strcmp(dec_res.fraction, "23")) {
+    printf(
+        "dist_member(\"test_dist\", 1, 4): %s.%s != 1.23\n",
+        dec_res.number,
+        dec_res.fraction);
+    exit(1);
+  }
+  dist_weight(&i_res, "test_dist", 2, 2);
+  if (3 != i_res) {
+    printf("dist_weight(\"test_dist\", 2, 2): %d != 3\n", i_res);
+    exit(1);
+  }
+}
+#endif /* TEST */
diff --git a/velox/tpcds/gen/dsdgen/error_msg.cpp b/velox/tpcds/gen/dsdgen/error_msg.cpp
new file mode 100644
index 000000000000..6202bf70d30d
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/error_msg.cpp
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include <stdio.h>
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/grammar_support.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+static int* LN;
+static char* FN;
+
+err_msg_t Errors[MAX_ERROR + 2] = {
+    {
+        EFLG_NO_ARG,
+        "",
+    },
+    {EFLG_STR_ARG, "File '%s' not found"},
+    {EFLG_NO_ARG, "Line exceeds maximum leng.h"},
+    {EFLG_STR_ARG, "Memory allocation failed %s"},
+    {EFLG_STR_ARG, "Syntax Error: \n'%s'"},
+    {EFLG_NO_ARG, "Invalid/Out-of-range Argument"},
+    {EFLG_STR_ARG, "'%s' is not a unique name"},
+    {EFLG_STR_ARG, "'%s' is not a valid name"},
+    {EFLG_NO_ARG, "Command parse failed"},
+    {EFLG_NO_ARG, "Invalid tag found"},
+    {EFLG_STR_ARG, "Read failed on '%s'"},
+    {EFLG_NO_ARG, "Too Many Templates!"},
+    {EFLG_NO_ARG, "Each workload definition must be in its own file"},
+    {EFLG_NO_ARG,
+     "Query Class name must be unique within a workload definition"},
+    {EFLG_NO_ARG, "Query Template must be unique within a query class"},
+    {EFLG_STR_ARG | EFLG_SYSTEM, "Open failed on '%s'"},
+    {EFLG_STR_ARG, "%s  not yet implemented"}, /* QERR_NOT_IMPLEMENTED */
+    {EFLG_STR_ARG, "string trucated to '%s'"},
+    {EFLG_NO_ARG, "Non-terminated string"},
+    {EFLG_STR_ARG, "failed to write to '%s'"},
+    {EFLG_NO_ARG, "No type vector defined for distribution"},
+    {EFLG_NO_ARG, "No weight count defined for distribution"},
+    {EFLG_NO_ARG, "No limits defined for pricing calculations"},
+    {EFLG_STR_ARG, "Percentage is out of bounds in substitution '%s'"},
+    {EFLG_STR_ARG, "Name is not a distribution or table name: '%s'"},
+    {EFLG_NO_ARG, "Cannot evaluate expression"},
+    {EFLG_STR_ARG,
+     "Substitution'%s' is used before being initialized"}, /* QERR_NO_INIT
+                                                            */
+    {EFLG_NO_ARG,
+     "RANGE()/LIST()/ULIST() not supported for NORMAL "
+     "distributions"},
+    {EFLG_STR_ARG, "Bad Nesting; '%s' not found"},
+    {EFLG_STR_ARG, "Include stack overflow when opening '%s'"},
+    {EFLG_STR_ARG, "Bad function call: '%s'"},
+    {EFLG_STR_ARG, "Bad Hierarchy Call: '%s'"},
+    {EFLG_NO_ARG, "Must set types and weights before defining names"},
+    {EFLG_NO_ARG, "More than 20 arguments in definition"},
+    {EFLG_NO_ARG, "Argument type mismat.h"},
+    {EFLG_NO_ARG,
+     "RANGE()/LIST()/ULIST() cannot be used in the "
+     "same expression"}, /* QERR_RANGE_LIST
+                          */
+    {EFLG_NO_ARG, "Selected scale factor is NOT valid for result publication"},
+    {EFLG_STR_ARG, "Parameter setting failed for '%s'"},
+    {EFLG_STR_ARG, "Table %s is being joined without an explicit rule"},
+    {EFLG_STR_ARG, "Table %s is not yet fully defined"},
+    {EFLG_STR_ARG,
+     "Table %s is a child; it is populated during the build of "
+     "its parent (e.g., catalog_sales builds catalog returns)"},
+    {EFLG_NO_ARG,
+     "Command line arguments for dbgen_version exceed 200 "
+     "characters; truncated"},
+    {EFLG_NO_ARG,
+     "A query template list must be supplied using the "
+     "INPUT option"}, /* QERR_NO_QUERYLIST
+                       */
+    {EFLG_NO_ARG,
+     "Invalid query number found in permutation!"}, /* QERR_QUERY_RANGE
+                                                     */
+    {EFLG_NO_ARG,
+     "RANGE/LIST/ULIST expressions not valid as "
+     "function parameters"}, /* QERR_MODIFIED_PARAM
+                              */
+    {EFLG_NO_ARG,
+     "RANGE/LIST/ULIST truncated to available "
+     "values"}, /* QERR_MODIFIED_PARAM
+                 */
+    {EFLG_NO_ARG,
+     "This scale factor is valid for QUALIFICATION "
+     "ONLY"}, /* QERR_QUALIFICATION_SCALE
+               */
+    {EFLG_STR_ARG,
+     "Generating %s requires the '-update' option"}, /* QERR_TABLE_UPDATE
+                                                      */
+    {0, NULL}};
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void ProcessErrorCode(
+    int nErrorCode,
+    char* szRoutineName,
+    char* szParam,
+    int nParam) {
+  switch (nErrorCode) {
+    case QERR_NO_FILE:
+      ReportError(QERR_NO_FILE, szParam, 1);
+      break;
+    case QERR_SYNTAX:
+    case QERR_RANGE_ERROR:
+    case QERR_NON_UNIQUE:
+    case QERR_BAD_NAME:
+    case QERR_DEFINE_OVERFLOW:
+    case QERR_INVALID_TAG:
+    case QERR_READ_FAILED:
+    case QERR_NO_MEMORY:
+    case QERR_LINE_TOO_LONG:
+      ReportError(nErrorCode, szRoutineName, 1);
+      break;
+  }
+  return;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int ReportError(int nError, const char* msg, int bExit) {
+  auto result = fprintf(stderr, "ERROR?!\n");
+  if (result < 0)
+    perror("sprintf failed");
+  return (nError);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int ReportErrorNoLine(int nError, const char* msg, int bExit) {
+  if (nError < MAX_ERROR) {
+    switch (static_cast<uint32_t>(Errors[-nError].flags) & EFLG_ARG_MASK) {
+      case EFLG_NO_ARG: {
+        auto result = fprintf(
+            stderr,
+            "%s: %s\n",
+            (bExit) ? "ERROR" : "Warning",
+            Errors[-nError].prompt);
+        if (result < 0)
+          perror("sprintf failed");
+        break;
+      }
+      case EFLG_STR_ARG: {
+        auto prompt = Errors[std::min(
+                                 static_cast<uint32_t>(-nError),
+                                 static_cast<uint32_t>(MAX_ERROR + 1))]
+                          .prompt;
+        std::vector<char> e_msg(1024 + strlen(prompt) + strlen(msg));
+        auto result = snprintf(e_msg.data(), e_msg.size(), prompt, msg);
+        if (result < 0)
+          perror("sprintf failed");
+        result = fprintf(
+            stderr, "%s: %s\n", (bExit) ? "ERROR" : "Warning", e_msg.data());
+        if (result < 0)
+          perror("sprintf failed");
+        break;
+      }
+    }
+
+    if (static_cast<uint32_t>(Errors[static_cast<uint32_t>(-nError)].flags) &
+        EFLG_SYSTEM)
+      perror(msg);
+  }
+
+  if (bExit)
+    exit(nError);
+  else
+    return (nError);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void SetErrorGlobals(char* szFileName, int* nLineNumber) {
+  FN = szFileName;
+  LN = nLineNumber;
+
+  return;
+}
diff --git a/velox/tpcds/gen/dsdgen/genrand.cpp b/velox/tpcds/gen/dsdgen/genrand.cpp
new file mode 100644
index 000000000000..ae36aece1e22
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/genrand.cpp
@@ -0,0 +1,724 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 <stdlib.h>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#ifdef WIN32
+#include <limits.h>
+#include <search.h>
+#endif
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/params.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+
+static long Mult = 16807; /* the multiplier */
+static long nQ = 127773; /* the quotient MAXINT / Mult */
+static long nR = 2836; /* the remainder MAXINT % Mult */
+void DSNthElement(HUGE_TYPE N, int nStream, DSDGenContext& dsdGenContext);
+
+/*
+ * Routine: next_random(int stream, DSDGenContext& dsdGenContext)
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+long next_random(int stream, DSDGenContext& dsdGenContext) {
+  long s = dsdGenContext.Streams[stream].nSeed, div_res, mod_res;
+
+  div_res = s / nQ;
+  mod_res = s - nQ * div_res; /* i.e., mod_res = s % nQ */
+  s = Mult * mod_res - div_res * nR;
+  if (s < 0)
+    s += MAXINT;
+  dsdGenContext.Streams[stream].nSeed = s;
+  dsdGenContext.Streams[stream].nUsed += 1;
+#ifdef JMS
+  dsdGenContext.Streams[stream].nTotal += 1;
+#endif
+  return (s);
+}
+
+/*
+ * Routine: next_random_float(int stream)
+ * Purpose:  return random in [0..1]
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+double next_random_float(int stream, DSDGenContext& dsdGenContext) {
+  long res;
+
+  res = next_random(stream, dsdGenContext);
+
+  return (static_cast<double>(res) / static_cast<double>(MAXINT));
+}
+
+/*
+ * Routine: skip_random(int stream, int skip_count, DSDGenContext&
+ * dsdGenContext) Purpose: Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void skip_random(int nStream, ds_key_t N, DSDGenContext& dsdGenContext) {
+  ds_key_t Z;
+  ds_key_t M;
+
+#ifdef UNDEF
+  fprintf(stderr, "skipping stream %d to %d\n", nStream, N);
+  Streams[nStream].nTotal = N;
+#endif
+  M = Mult;
+  Z = static_cast<ds_key_t>(dsdGenContext.Streams[nStream].nInitialSeed);
+  while (N > 0) {
+    if (N % 2 != 0) /* testing for oddness, this seems portable */
+      Z = (M * Z) % MAXINT;
+    N = N / 2; /* integer division, truncates */
+    M = (M * M) % MAXINT;
+  }
+  dsdGenContext.Streams[nStream].nSeed = static_cast<long>(Z);
+
+  return;
+}
+
+/*
+ * Routine: genrand_integer(int dist, int min, int max, int mean, dsdGenContext)
+ * Purpose: generate a random integer given the distribution and limits
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns: int
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ */
+int genrand_integer(
+    int* dest,
+    int dist,
+    int min,
+    int max,
+    int mean,
+    int stream,
+    DSDGenContext& dsdGenContext) {
+  int res = 0, i;
+  double fres = 0;
+
+  switch (dist) {
+    case DIST_UNIFORM:
+      res = next_random(stream, dsdGenContext);
+      res %= max - min + 1;
+      res += min;
+      break;
+    case DIST_EXPONENTIAL:
+      for (i = 0; i < 12; i++)
+        fres +=
+            static_cast<double>(next_random(stream, dsdGenContext) / MAXINT) -
+            0.5;
+      res = min + static_cast<int>((max - min + 1) * fres);
+      break;
+    default:
+      INTERNAL("Undefined distribution");
+      break;
+  }
+
+  if (dest == nullptr)
+    return (res);
+
+  *dest = res;
+
+  return (0);
+}
+
+/*
+ * Routine: genrand_key(ket_t *dest, int dist, ds_key_t min, ds_key_t max,
+ * ds_key_t mean, int stream, DSDGenContext& dsdGenContext) Purpose: generate a
+ * random integer given the distribution and limits Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns: ds_key_t
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: Need to rework to rely on RNG routines that will work for 64 bit return
+ * values
+ */
+ds_key_t genrand_key(
+    ds_key_t* dest,
+    int dist,
+    ds_key_t min,
+    ds_key_t max,
+    ds_key_t mean,
+    int stream,
+    DSDGenContext& dsdGenContext) {
+  int res = 0, i;
+  double fres = 0;
+
+  switch (dist) {
+    case DIST_UNIFORM:
+      res = next_random(stream, dsdGenContext);
+      res %= static_cast<int>(max - min + 1);
+      res += static_cast<int>(min);
+      break;
+    case DIST_EXPONENTIAL:
+      for (i = 0; i < 12; i++)
+        fres +=
+            static_cast<double>(next_random(stream, dsdGenContext) / MAXINT) -
+            0.5;
+      res = static_cast<int>(min) + static_cast<int>((max - min + 1) * fres);
+      break;
+    default:
+      INTERNAL("Undefined distribution");
+      break;
+  }
+
+  if (dest == nullptr)
+    return (static_cast<ds_key_t>(res));
+
+  *dest = static_cast<ds_key_t>(res);
+
+  return (static_cast<ds_key_t>(0));
+}
+
+/*
+ * Routine:
+ *	genrand_decimal(int dist, decimal_t *min, decimal_t *max, decimal_t
+ **mean), dsdGenContext Purpose: create a random decimal_t Algorithm: Data
+ *Structures:
+ *
+ * Params: min/max are char * to allow easy passing of precision
+ * Returns: decimal_t *; NULL on failure
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int genrand_decimal(
+    decimal_t* dest,
+    int dist,
+    decimal_t* min,
+    decimal_t* max,
+    decimal_t* mean,
+    int stream,
+    DSDGenContext& dsdGenContext) {
+  int i;
+  decimal_t res;
+  double fres = 0.0;
+
+  if (min->precision < max->precision)
+    dest->precision = min->precision;
+  else
+    dest->precision = max->precision;
+
+  switch (dist) {
+    case DIST_UNIFORM:
+      res.number = next_random(stream, dsdGenContext);
+      res.number %= max->number - min->number + 1;
+      res.number += min->number;
+      break;
+    case DIST_EXPONENTIAL:
+      for (i = 0; i < 12; i++) {
+        fres /= 2.0;
+        fres += static_cast<double>(
+                    static_cast<double>(next_random(stream, dsdGenContext)) /
+                    static_cast<double>(MAXINT)) -
+            0.5;
+      }
+      res.number = mean->number +
+          static_cast<int>((max->number - min->number + 1) * fres);
+      break;
+    default:
+      INTERNAL("Undefined distribution");
+      break;
+  }
+
+  dest->number = res.number;
+  i = 0;
+  while (res.number > 10) {
+    res.number /= 10;
+    i += 1;
+  }
+  dest->scale = i;
+
+  return (0);
+}
+
+/* Routine: RNGReset(int tbl)
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int RNGReset(int tbl, DSDGenContext& dsdGenContext) {
+  int i;
+
+  for (i = 0; dsdGenContext.Streams[i].nColumn != -1; i++)
+    if (dsdGenContext.Streams[i].nTable == tbl)
+      dsdGenContext.Streams[i].nSeed = dsdGenContext.Streams[i].nInitialSeed;
+
+  return (0);
+}
+
+/* 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 HUGE_TYPE Multiplier = 16807; /* or whatever nonstandard */
+static HUGE_TYPE 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 DSNthElementNthElement(
+    HUGE_TYPE N,
+    int nStream,
+    DSDGenContext& dsdGenContext) {
+  HUGE_TYPE Z;
+  HUGE_TYPE Mult;
+
+  Mult = Multiplier;
+  Z = static_cast<HUGE_TYPE>(dsdGenContext.Streams[nStream].nInitialSeed);
+  while (N > 0) {
+    if (N % 2 != 0) /* testing for oddness, this seems portable */
+    {
+#ifdef JMS
+      dsdGenContext.Streams[nStream].nTotal += 1;
+#endif
+      Z = (Mult * Z) % Modulus;
+    }
+    N = N / 2; /* integer division, truncates */
+    Mult = (Mult * Mult) % Modulus;
+#ifdef JMS
+    dsdGenContext.Streams[nStream].nTotal += 2;
+#endif
+  }
+  dsdGenContext.Streams[nStream].nSeed = static_cast<long>(Z);
+
+  return;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int dump_seeds_ds(int tbl, DSDGenContext& dsdGenContext) {
+  int i;
+
+  for (i = 0; dsdGenContext.Streams[i].nColumn != -1; i++)
+    if (dsdGenContext.Streams[i].nTable == tbl) {
+      auto result = printf(
+          "%04d\t%09d\t%09ld\n",
+          i,
+          dsdGenContext.Streams[i].nUsed,
+          dsdGenContext.Streams[i].nSeed);
+      if (result < 0)
+        perror("sprintf failed");
+    }
+  return (0);
+}
+
+/*
+ * Routine: gen_charset(char *set, int min, int max)
+ * Purpose: generate random characters from set for a random length [min..max]
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int gen_charset(
+    char* dest,
+    const char* set,
+    int min,
+    int max,
+    int stream,
+    DSDGenContext& dsdGenContext) {
+  int len, i, temp;
+
+  if (set == NULL) {
+    dest = NULL;
+    return (-1);
+  }
+
+  genrand_integer(&len, DIST_UNIFORM, min, max, 0, stream, dsdGenContext);
+
+  for (i = 0; i < max; i++) {
+    genrand_integer(
+        &temp, DIST_UNIFORM, 0, strlen(set) - 1, 0, stream, dsdGenContext);
+    if (i < len)
+      dest[i] = *(set + temp);
+  }
+  dest[len] = '\0';
+
+  return (0);
+}
+
+/*
+ * Routine: genrand_date(int dist, date_t *min, date_t *max, DSDGenContext&
+ * dsdGenContext) Purpose: generate random date within [min..max] Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int genrand_date(
+    date_t* dest,
+    int dist,
+    date_t* min,
+    date_t* max,
+    date_t* mean,
+    int stream,
+    DSDGenContext& dsdGenContext) {
+  int range, imean = 0, temp, idt, nYear, nTotalWeight = 0, nDayCount;
+
+  idt = dttoj(min);
+  range = dttoj(max);
+  range -= idt;
+  nDayCount = min->day;
+  nYear = min->year;
+
+  switch (dist) {
+    case DIST_SALES:
+    case DIST_RETURNS:
+      /* walk from min to max to "integrate" the distribution */
+      while (range -= 1) {
+        nTotalWeight += dist_weight(
+            NULL, "calendar", nDayCount, dist + is_leap(nYear), dsdGenContext);
+        if (nDayCount == 365 + is_leap(nYear)) {
+          nYear += 1;
+          nDayCount = 1;
+        } else
+          nDayCount += 1;
+      }
+      /* pick a value in the resulting range */
+      temp = genrand_integer(
+          NULL, DIST_UNIFORM, 1, nTotalWeight, 0, stream, dsdGenContext);
+      /* and walk it again to translate that back to a date */
+      nDayCount = min->day;
+      idt = min->julian;
+      nYear = min->year;
+      while (temp >= 0) {
+        temp -= dist_weight(
+            NULL, "calendar", nDayCount, dist + is_leap(nYear), dsdGenContext);
+        nDayCount += 1;
+        idt += 1;
+        if (nDayCount > 365 + is_leap(nYear)) {
+          nYear += 1;
+          nDayCount = 1;
+        }
+      }
+      break;
+    case DIST_EXPONENTIAL:
+      imean = dttoj(mean);
+      imean -= idt;
+    case DIST_UNIFORM:
+      genrand_integer(&temp, dist, 0, range, imean, stream, dsdGenContext);
+      idt += temp;
+      break;
+    default:
+      break;
+  }
+
+  jtodt(dest, idt);
+
+  return (0);
+}
+
+/**************
+ **************
+ **
+ ** static routines
+ **
+ **************
+ **************/
+
+/*
+ * Routine: init_rand(DSDGenContext& dsdGenContext)
+ * Purpose: Initialize the RNG used throughout the code
+ * Algorithm: To allow two columns to use the same stream of numbers (for
+ *joins), pre-sort the streams list by Duplicate and then assign values. Order
+ *by column after initialization Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+// FIXME: allow re-init
+void init_rand(DSDGenContext& dsdGenContext) {
+  long long i, skip, nSeed; // changed to long long from int
+
+  if (!dsdGenContext.init_rand_init) {
+    if (is_set("RNGSEED", dsdGenContext))
+      nSeed = get_int("RNGSEED", dsdGenContext);
+    else
+      nSeed = RNG_SEED;
+    skip = MAXINT / MAX_COLUMN;
+    for (i = 0; i < MAX_COLUMN; i++) {
+      // simulate the overflow as if it were an int
+      if (i != 0 && (INT_MAX - nSeed) / i < skip) {
+        long long val = nSeed + skip * i;
+        val %= MAXINT;
+        val -= MAXINT;
+        val -= 2;
+        dsdGenContext.Streams[i].nInitialSeed = val;
+        dsdGenContext.Streams[i].nSeed = val;
+      } else {
+        dsdGenContext.Streams[i].nInitialSeed = nSeed + skip * i;
+        dsdGenContext.Streams[i].nSeed = nSeed + skip * i;
+      }
+      dsdGenContext.Streams[i].nUsed = 0;
+    }
+    dsdGenContext.init_rand_init = 1;
+  }
+  return;
+}
+
+void resetSeeds(int nTable, DSDGenContext& dsdGenContext) {
+  int i;
+
+  for (i = 0; i < MAX_COLUMN; i++)
+    if (dsdGenContext.Streams[i].nTable == nTable)
+      dsdGenContext.Streams[i].nSeed = dsdGenContext.Streams[i].nInitialSeed;
+  return;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void genrand_email(
+    char* pEmail,
+    char* pFirst,
+    char* pLast,
+    int nColumn,
+    DSDGenContext& dsdGenContext) {
+  char* pDomain = nullptr;
+  std::vector<char> szCompany(50);
+  int nCompanyLength;
+
+  pick_distribution(&pDomain, "top_domains", 1, 1, nColumn, dsdGenContext);
+  genrand_integer(
+      &nCompanyLength, DIST_UNIFORM, 10, 20, 0, nColumn, dsdGenContext);
+  gen_charset(&szCompany[0], ALPHANUM, 1, 20, nColumn, dsdGenContext);
+  szCompany[nCompanyLength] = '\0';
+
+  if ((strlen(pFirst) + strlen(pLast) + szCompany.size() + strlen(pDomain) +
+       3) < (RS_C_EMAIL + 1)) {
+    auto result = snprintf(
+        pEmail,
+        RS_C_EMAIL + 1,
+        "%s.%s@%s.%s",
+        pFirst,
+        pLast,
+        szCompany.data(),
+        pDomain);
+    if (result < 0)
+      perror("sprintf failed");
+  }
+
+  return;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void genrand_ipaddr(char* pDest, int nColumn, DSDGenContext& dsdGenContext) {
+  int arQuads[4], i;
+
+  for (i = 0; i < 4; i++)
+    genrand_integer(
+        &arQuads[i], DIST_UNIFORM, 1, 255, 0, nColumn, dsdGenContext);
+  auto result = snprintf(
+      pDest,
+      16,
+      "%03d.%03d.%03d.%03d",
+      arQuads[0],
+      arQuads[1],
+      arQuads[2],
+      arQuads[3]);
+  if (result < 0)
+    perror("sprintf failed");
+
+  return;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int genrand_url(char* pDest, int nColumn) {
+  strcpy(pDest, "http://www.foo.com");
+
+  return (0);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int setSeed(int nStream, int nValue, DSDGenContext& dsdGenContext) {
+  int nRetValue;
+
+  nRetValue = dsdGenContext.Streams[nStream].nSeed;
+  dsdGenContext.Streams[nStream].nSeed = nValue;
+
+  return (nRetValue);
+}
+
+#ifdef TEST
+main() {
+  printf("r_genrand:No test routine has been defined for this module\n");
+
+  exit(0);
+}
+#endif /* TEST */
diff --git a/velox/tpcds/gen/dsdgen/include/StringBuffer.h b/velox/tpcds/gen/dsdgen/include/StringBuffer.h
new file mode 100644
index 000000000000..a0383093db4f
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/StringBuffer.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef STRING_BUFFER_H
+#define STRING_BUFFER_H
+
+#define SB_INIT 0x01
+
+typedef struct STRING_BUFFER_T {
+  int nFlags;
+  int nBytesAllocated;
+  int nBytesUsed;
+  int nIncrement;
+  char* pText;
+} StringBuffer_t;
+
+StringBuffer_t* InitBuffer(int nSize, int nIncrement);
+int AddBuffer(StringBuffer_t* pBuf, char* pStr);
+int ResetBuffer(StringBuffer_t* pBuf);
+char* GetBuffer(StringBuffer_t* pBuf);
+void FreeBuffer(StringBuffer_t* pBuf);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/address.h b/velox/tpcds/gen/dsdgen/include/address.h
new file mode 100644
index 000000000000..40a0c02719fe
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/address.h
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef DS_ADDRESS_H
+#define DS_ADDRESS_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/dist.h" // @manual
+
+#define DS_ADDR_SUITE_NUM 0
+#define DS_ADDR_STREET_NUM 1
+#define DS_ADDR_STREET_NAME1 2
+#define DS_ADDR_STREET_NAME2 3
+#define DS_ADDR_STREET_TYPE 4
+#define DS_ADDR_CITY 5
+#define DS_ADDR_COUNTY 6
+#define DS_ADDR_STATE 7
+#define DS_ADDR_COUNTRY 8
+#define DS_ADDR_ZIP 9
+#define DS_ADDR_PLUS4 10
+#define DS_ADDR_GMT_OFFSET 11
+
+int mk_address(ds_addr_t* pDest, int nColumn, DSDGenContext& dsdGenContext);
+int mk_streetnumber(int nTable, int* dest, DSDGenContext& dsdGenContext);
+int mk_suitenumber(int nTable, char* dest, DSDGenContext& dsdGenContext);
+int mk_streetname(int nTable, char* dest);
+int mk_city(int nTable, char** dest, DSDGenContext& dsdGenContext);
+int city_hash(int nTable, char* name);
+int mk_zipcode(
+    int nTable,
+    char* dest,
+    int nRegion,
+    char* city,
+    DSDGenContext& dsdGenContext);
+// void printAddressPart(FILE *fp, ds_addr_t *pAddr, int nAddressPart);
+void resetCountCount(void);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/append_info.h b/velox/tpcds/gen/dsdgen/include/append_info.h
new file mode 100644
index 000000000000..863889deb670
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/append_info.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef R_APPEND_H
+#define R_APPEND_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+
+typedef void* append_info;
+
+append_info* append_info_get(void* info_list, int table_id);
+
+void append_row_start(append_info info);
+void append_row_end(append_info info);
+
+void append_varchar(
+    int32_t column,
+    append_info info,
+    const char* value,
+    bool fillEmptyStringAsNull = true);
+void append_varchar(
+    int32_t column,
+    append_info info,
+    std::string value,
+    bool fillEmptyStringAsNull = true);
+void append_key(int32_t column, append_info info, int64_t value);
+void append_date(int32_t column, append_info info, int64_t value);
+void append_integer(int32_t column, append_info info, int32_t value);
+void append_decimal(int32_t column, append_info info, decimal_t* val);
+void append_boolean(int32_t column, append_info info, int32_t val);
+void append_integer_decimal(int32_t column, append_info info, int32_t val);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/build_support.h b/velox/tpcds/gen/dsdgen/include/build_support.h
new file mode 100644
index 000000000000..80bf2af481e3
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/build_support.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef BUILD_SUPPORT_H
+#define BUILD_SUPPORT_H
+
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+
+void bitmap_to_dist(
+    void* pDest,
+    const char* distname,
+    ds_key_t* modulus,
+    int vset,
+    int stream,
+    DSDGenContext& dsdGenContext);
+void dist_to_bitmap(
+    int* pDest,
+    const char* szDistName,
+    int nValue,
+    int nWeight,
+    int nStream);
+void random_to_bitmap(
+    int* pDest,
+    int nDist,
+    int nMin,
+    int nMax,
+    int nMean,
+    int nStream);
+int city_hash(int nTable, char* city);
+void hierarchy_item(
+    int h_level,
+    ds_key_t* id,
+    char** name,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+ds_key_t mk_join(
+    int from_tbl,
+    int to_tbl,
+    ds_key_t ref_key,
+    DSDGenContext& dsdGenContext);
+ds_key_t getCatalogNumberFromPage(ds_key_t kPageNumber);
+void mk_word(
+    char* dest,
+    const char* syl_set,
+    ds_key_t src,
+    int char_cnt,
+    int col,
+    DSDGenContext& dsdGenContext);
+int set_locale(int nRegion, decimal_t* longitude, decimal_t* latitude);
+int adj_time(
+    ds_key_t* res_date,
+    ds_key_t* res_time,
+    ds_key_t base_date,
+    ds_key_t base_time,
+    ds_key_t offset_key,
+    int tabid);
+void mk_bkey(char* szDest, ds_key_t kPrimary, int nStream);
+int embed_string(
+    char* szDest,
+    const char* szDist,
+    int nValue,
+    int nWeight,
+    int nStream,
+    DSDGenContext& dsdGenContext);
+int mk_companyname(
+    char* dest,
+    int nTable,
+    int nCompany,
+    DSDGenContext& dsdGenContext);
+void setUpdateDateRange(
+    int nTable,
+    date_t* pMinDate,
+    date_t* pMaxDate,
+    DSDGenContext& dsdGenContext);
+
+#endif /* BUILD_SUPPORT_H */
diff --git a/velox/tpcds/gen/dsdgen/include/columns.h b/velox/tpcds/gen/dsdgen/include/columns.h
new file mode 100644
index 000000000000..67a9ed0cadbf
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/columns.h
@@ -0,0 +1,957 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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.
+ */
+
+/*
+ * THIS IS A GENERATED FILE
+ * SEE COLUMNS.LIST
+ */
+#ifndef COLUMNS_H
+#define COLUMNS_H
+#define CALL_CENTER_START 1
+#define CC_CALL_CENTER_SK 1
+#define CC_CALL_CENTER_ID 2
+#define CC_REC_START_DATE_ID 3
+#define CC_REC_END_DATE_ID 4
+#define CC_CLOSED_DATE_ID 5
+#define CC_OPEN_DATE_ID 6
+#define CC_NAME 7
+#define CC_CLASS 8
+#define CC_EMPLOYEES 9
+#define CC_SQ_FT 10
+#define CC_HOURS 11
+#define CC_MANAGER 12
+#define CC_MARKET_ID 13
+#define CC_MARKET_CLASS 14
+#define CC_MARKET_DESC 15
+#define CC_MARKET_MANAGER 16
+#define CC_DIVISION 17
+#define CC_DIVISION_NAME 18
+#define CC_COMPANY 19
+#define CC_COMPANY_NAME 20
+#define CC_STREET_NUMBER 21
+#define CC_STREET_NAME 22
+#define CC_STREET_TYPE 23
+#define CC_SUITE_NUMBER 24
+#define CC_CITY 25
+#define CC_COUNTY 26
+#define CC_STATE 27
+#define CC_ZIP 28
+#define CC_COUNTRY 29
+#define CC_GMT_OFFSET 30
+#define CC_ADDRESS 31
+#define CC_TAX_PERCENTAGE 32
+#define CC_SCD 33
+#define CC_NULLS 34
+#define CALL_CENTER_END 34
+#define CATALOG_PAGE_START 35
+#define CP_CATALOG_PAGE_SK 35
+#define CP_CATALOG_PAGE_ID 36
+#define CP_START_DATE_ID 37
+#define CP_END_DATE_ID 38
+#define CP_PROMO_ID 39
+#define CP_DEPARTMENT 40
+#define CP_CATALOG_NUMBER 41
+#define CP_CATALOG_PAGE_NUMBER 42
+#define CP_DESCRIPTION 43
+#define CP_TYPE 44
+#define CP_NULLS 45
+#define CATALOG_PAGE_END 45
+#define CATALOG_RETURNS_START 46
+#define CR_RETURNED_DATE_SK 46
+#define CR_RETURNED_TIME_SK 47
+#define CR_ITEM_SK 48
+#define CR_REFUNDED_CUSTOMER_SK 49
+#define CR_REFUNDED_CDEMO_SK 50
+#define CR_REFUNDED_HDEMO_SK 51
+#define CR_REFUNDED_ADDR_SK 52
+#define CR_RETURNING_CUSTOMER_SK 53
+#define CR_RETURNING_CDEMO_SK 54
+#define CR_RETURNING_HDEMO_SK 55
+#define CR_RETURNING_ADDR_SK 56
+#define CR_CALL_CENTER_SK 57
+#define CR_CATALOG_PAGE_SK 58
+#define CR_SHIP_MODE_SK 59
+#define CR_WAREHOUSE_SK 60
+#define CR_REASON_SK 61
+#define CR_ORDER_NUMBER 62
+#define CR_PRICING_QUANTITY 63
+#define CR_PRICING_NET_PAID 64
+#define CR_PRICING_EXT_TAX 65
+#define CR_PRICING_NET_PAID_INC_TAX 66
+#define CR_PRICING_FEE 67
+#define CR_PRICING_EXT_SHIP_COST 68
+#define CR_PRICING_REFUNDED_CASH 69
+#define CR_PRICING_REVERSED_CHARGE 70
+#define CR_PRICING_STORE_CREDIT 71
+#define CR_PRICING_NET_LOSS 72
+#define CR_NULLS 73
+#define CR_PRICING 74
+#define CATALOG_RETURNS_END 74
+#define CATALOG_SALES_START 75
+#define CS_SOLD_DATE_SK 75
+#define CS_SOLD_TIME_SK 76
+#define CS_SHIP_DATE_SK 77
+#define CS_BILL_CUSTOMER_SK 78
+#define CS_BILL_CDEMO_SK 79
+#define CS_BILL_HDEMO_SK 80
+#define CS_BILL_ADDR_SK 81
+#define CS_SHIP_CUSTOMER_SK 82
+#define CS_SHIP_CDEMO_SK 83
+#define CS_SHIP_HDEMO_SK 84
+#define CS_SHIP_ADDR_SK 85
+#define CS_CALL_CENTER_SK 86
+#define CS_CATALOG_PAGE_SK 87
+#define CS_SHIP_MODE_SK 88
+#define CS_WAREHOUSE_SK 89
+#define CS_SOLD_ITEM_SK 90
+#define CS_PROMO_SK 91
+#define CS_ORDER_NUMBER 92
+#define CS_PRICING_QUANTITY 93
+#define CS_PRICING_WHOLESALE_COST 94
+#define CS_PRICING_LIST_PRICE 95
+#define CS_PRICING_SALES_PRICE 96
+#define CS_PRICING_COUPON_AMT 97
+#define CS_PRICING_EXT_SALES_PRICE 98
+#define CS_PRICING_EXT_DISCOUNT_AMOUNT 99
+#define CS_PRICING_EXT_WHOLESALE_COST 100
+#define CS_PRICING_EXT_LIST_PRICE 101
+#define CS_PRICING_EXT_TAX 102
+#define CS_PRICING_EXT_SHIP_COST 103
+#define CS_PRICING_NET_PAID 104
+#define CS_PRICING_NET_PAID_INC_TAX 105
+#define CS_PRICING_NET_PAID_INC_SHIP 106
+#define CS_PRICING_NET_PAID_INC_SHIP_TAX 107
+#define CS_PRICING_NET_PROFIT 108
+#define CS_PRICING 109
+#define CS_PERMUTE 110
+#define CS_NULLS 111
+#define CR_IS_RETURNED 112
+#define CS_PERMUTATION 113
+#define CATALOG_SALES_END 113
+#define CUSTOMER_START 114
+#define C_CUSTOMER_SK 114
+#define C_CUSTOMER_ID 115
+#define C_CURRENT_CDEMO_SK 116
+#define C_CURRENT_HDEMO_SK 117
+#define C_CURRENT_ADDR_SK 118
+#define C_FIRST_SHIPTO_DATE_ID 119
+#define C_FIRST_SALES_DATE_ID 120
+#define C_SALUTATION 121
+#define C_FIRST_NAME 122
+#define C_LAST_NAME 123
+#define C_PREFERRED_CUST_FLAG 124
+#define C_BIRTH_DAY 125
+#define C_BIRTH_MONTH 126
+#define C_BIRTH_YEAR 127
+#define C_BIRTH_COUNTRY 128
+#define C_LOGIN 129
+#define C_EMAIL_ADDRESS 130
+#define C_LAST_REVIEW_DATE 131
+#define C_NULLS 132
+#define CUSTOMER_END 132
+#define CUSTOMER_ADDRESS_START 133
+#define CA_ADDRESS_SK 133
+#define CA_ADDRESS_ID 134
+#define CA_ADDRESS_STREET_NUM 135
+#define CA_ADDRESS_STREET_NAME1 136
+#define CA_ADDRESS_STREET_TYPE 137
+#define CA_ADDRESS_SUITE_NUM 138
+#define CA_ADDRESS_CITY 139
+#define CA_ADDRESS_COUNTY 140
+#define CA_ADDRESS_STATE 141
+#define CA_ADDRESS_ZIP 142
+#define CA_ADDRESS_COUNTRY 143
+#define CA_ADDRESS_GMT_OFFSET 144
+#define CA_LOCATION_TYPE 145
+#define CA_NULLS 146
+#define CA_ADDRESS 147
+#define CA_ADDRESS_STREET_NAME2 148
+#define CUSTOMER_ADDRESS_END 148
+#define CUSTOMER_DEMOGRAPHICS_START 149
+#define CD_DEMO_SK 149
+#define CD_GENDER 150
+#define CD_MARITAL_STATUS 151
+#define CD_EDUCATION_STATUS 152
+#define CD_PURCHASE_ESTIMATE 153
+#define CD_CREDIT_RATING 154
+#define CD_DEP_COUNT 155
+#define CD_DEP_EMPLOYED_COUNT 156
+#define CD_DEP_COLLEGE_COUNT 157
+#define CD_NULLS 158
+#define CUSTOMER_DEMOGRAPHICS_END 158
+#define DATE_START 159
+#define D_DATE_SK 159
+#define D_DATE_ID 160
+#define D_DATE 161
+#define D_MONTH_SEQ 162
+#define D_WEEK_SEQ 163
+#define D_QUARTER_SEQ 164
+#define D_YEAR 165
+#define D_DOW 166
+#define D_MOY 167
+#define D_DOM 168
+#define D_QOY 169
+#define D_FY_YEAR 170
+#define D_FY_QUARTER_SEQ 171
+#define D_FY_WEEK_SEQ 172
+#define D_DAY_NAME 173
+#define D_QUARTER_NAME 174
+#define D_HOLIDAY 175
+#define D_WEEKEND 176
+#define D_FOLLOWING_HOLIDAY 177
+#define D_FIRST_DOM 178
+#define D_LAST_DOM 179
+#define D_SAME_DAY_LY 180
+#define D_SAME_DAY_LQ 181
+#define D_CURRENT_DAY 182
+#define D_CURRENT_WEEK 183
+#define D_CURRENT_MONTH 184
+#define D_CURRENT_QUARTER 185
+#define D_CURRENT_YEAR 186
+#define D_NULLS 187
+#define DATE_END 187
+#define HOUSEHOLD_DEMOGRAPHICS_START 188
+#define HD_DEMO_SK 188
+#define HD_INCOME_BAND_ID 189
+#define HD_BUY_POTENTIAL 190
+#define HD_DEP_COUNT 191
+#define HD_VEHICLE_COUNT 192
+#define HD_NULLS 193
+#define HOUSEHOLD_DEMOGRAPHICS_END 193
+#define INCOME_BAND_START 194
+#define IB_INCOME_BAND_ID 194
+#define IB_LOWER_BOUND 195
+#define IB_UPPER_BOUND 196
+#define IB_NULLS 197
+#define INCOME_BAND_END 197
+#define INVENTORY_START 198
+#define INV_DATE_SK 198
+#define INV_ITEM_SK 199
+#define INV_WAREHOUSE_SK 200
+#define INV_QUANTITY_ON_HAND 201
+#define INV_NULLS 202
+#define INVENTORY_END 202
+#define ITEM_START 203
+#define I_ITEM_SK 203
+#define I_ITEM_ID 204
+#define I_REC_START_DATE_ID 205
+#define I_REC_END_DATE_ID 206
+#define I_ITEM_DESC 207
+#define I_CURRENT_PRICE 208
+#define I_WHOLESALE_COST 209
+#define I_BRAND_ID 210
+#define I_BRAND 211
+#define I_CLASS_ID 212
+#define I_CLASS 213
+#define I_CATEGORY_ID 214
+#define I_CATEGORY 215
+#define I_MANUFACT_ID 216
+#define I_MANUFACT 217
+#define I_SIZE 218
+#define I_FORMULATION 219
+#define I_COLOR 220
+#define I_UNITS 221
+#define I_CONTAINER 222
+#define I_MANAGER_ID 223
+#define I_PRODUCT_NAME 224
+#define I_NULLS 225
+#define I_SCD 226
+#define I_PROMO_SK 227
+#define ITEM_END 227
+#define PROMOTION_START 228
+#define P_PROMO_SK 228
+#define P_PROMO_ID 229
+#define P_START_DATE_ID 230
+#define P_END_DATE_ID 231
+#define P_ITEM_SK 232
+#define P_COST 233
+#define P_RESPONSE_TARGET 234
+#define P_PROMO_NAME 235
+#define P_CHANNEL_DMAIL 236
+#define P_CHANNEL_EMAIL 237
+#define P_CHANNEL_CATALOG 238
+#define P_CHANNEL_TV 239
+#define P_CHANNEL_RADIO 240
+#define P_CHANNEL_PRESS 241
+#define P_CHANNEL_EVENT 242
+#define P_CHANNEL_DEMO 243
+#define P_CHANNEL_DETAILS 244
+#define P_PURPOSE 245
+#define P_DISCOUNT_ACTIVE 246
+#define P_NULLS 247
+#define PROMOTION_END 247
+#define REASON_START 248
+#define R_REASON_SK 248
+#define R_REASON_ID 249
+#define R_REASON_DESCRIPTION 250
+#define R_NULLS 251
+#define REASON_END 251
+#define SHIP_MODE_START 252
+#define SM_SHIP_MODE_SK 252
+#define SM_SHIP_MODE_ID 253
+#define SM_TYPE 254
+#define SM_CODE 255
+#define SM_CONTRACT 256
+#define SM_CARRIER 257
+#define SM_NULLS 258
+#define SHIP_MODE_END 258
+#define STORE_START 259
+#define W_STORE_SK 259
+#define W_STORE_ID 260
+#define W_STORE_REC_START_DATE_ID 261
+#define W_STORE_REC_END_DATE_ID 262
+#define W_STORE_CLOSED_DATE_ID 263
+#define W_STORE_NAME 264
+#define W_STORE_EMPLOYEES 265
+#define W_STORE_FLOOR_SPACE 266
+#define W_STORE_HOURS 267
+#define W_STORE_MANAGER 268
+#define W_STORE_MARKET_ID 269
+#define W_STORE_TAX_PERCENTAGE 270
+#define W_STORE_GEOGRAPHY_CLASS 271
+#define W_STORE_MARKET_DESC 272
+#define W_STORE_MARKET_MANAGER 273
+#define W_STORE_DIVISION_ID 274
+#define W_STORE_DIVISION_NAME 275
+#define W_STORE_COMPANY_ID 276
+#define W_STORE_COMPANY_NAME 277
+#define W_STORE_ADDRESS_STREET_NUM 278
+#define W_STORE_ADDRESS_STREET_NAME1 279
+#define W_STORE_ADDRESS_STREET_TYPE 280
+#define W_STORE_ADDRESS_SUITE_NUM 281
+#define W_STORE_ADDRESS_CITY 282
+#define W_STORE_ADDRESS_COUNTY 283
+#define W_STORE_ADDRESS_STATE 284
+#define W_STORE_ADDRESS_ZIP 285
+#define W_STORE_ADDRESS_COUNTRY 286
+#define W_STORE_ADDRESS_GMT_OFFSET 287
+#define W_STORE_NULLS 288
+#define W_STORE_TYPE 289
+#define W_STORE_SCD 290
+#define W_STORE_ADDRESS 291
+#define STORE_END 291
+#define STORE_RETURNS_START 292
+#define SR_RETURNED_DATE_SK 292
+#define SR_RETURNED_TIME_SK 293
+#define SR_ITEM_SK 294
+#define SR_CUSTOMER_SK 295
+#define SR_CDEMO_SK 296
+#define SR_HDEMO_SK 297
+#define SR_ADDR_SK 298
+#define SR_STORE_SK 299
+#define SR_REASON_SK 300
+#define SR_TICKET_NUMBER 301
+#define SR_PRICING_QUANTITY 302
+#define SR_PRICING_NET_PAID 303
+#define SR_PRICING_EXT_TAX 304
+#define SR_PRICING_NET_PAID_INC_TAX 305
+#define SR_PRICING_FEE 306
+#define SR_PRICING_EXT_SHIP_COST 307
+#define SR_PRICING_REFUNDED_CASH 308
+#define SR_PRICING_REVERSED_CHARGE 309
+#define SR_PRICING_STORE_CREDIT 310
+#define SR_PRICING_NET_LOSS 311
+#define SR_PRICING 312
+#define SR_NULLS 313
+#define STORE_RETURNS_END 313
+#define STORE_SALES_START 314
+#define SS_SOLD_DATE_SK 314
+#define SS_SOLD_TIME_SK 315
+#define SS_SOLD_ITEM_SK 316
+#define SS_SOLD_CUSTOMER_SK 317
+#define SS_SOLD_CDEMO_SK 318
+#define SS_SOLD_HDEMO_SK 319
+#define SS_SOLD_ADDR_SK 320
+#define SS_SOLD_STORE_SK 321
+#define SS_SOLD_PROMO_SK 322
+#define SS_TICKET_NUMBER 323
+#define SS_PRICING_QUANTITY 324
+#define SS_PRICING_WHOLESALE_COST 325
+#define SS_PRICING_LIST_PRICE 326
+#define SS_PRICING_SALES_PRICE 327
+#define SS_PRICING_COUPON_AMT 328
+#define SS_PRICING_EXT_SALES_PRICE 329
+#define SS_PRICING_EXT_WHOLESALE_COST 330
+#define SS_PRICING_EXT_LIST_PRICE 331
+#define SS_PRICING_EXT_TAX 332
+#define SS_PRICING_NET_PAID 333
+#define SS_PRICING_NET_PAID_INC_TAX 334
+#define SS_PRICING_NET_PROFIT 335
+#define SR_IS_RETURNED 336
+#define SS_PRICING 337
+#define SS_NULLS 338
+#define SS_PERMUTATION 339
+#define STORE_SALES_END 339
+#define TIME_START 340
+#define T_TIME_SK 340
+#define T_TIME_ID 341
+#define T_TIME 342
+#define T_HOUR 343
+#define T_MINUTE 344
+#define T_SECOND 345
+#define T_AM_PM 346
+#define T_SHIFT 347
+#define T_SUB_SHIFT 348
+#define T_MEAL_TIME 349
+#define T_NULLS 350
+#define TIME_END 350
+#define WAREHOUSE_START 351
+#define W_WAREHOUSE_SK 351
+#define W_WAREHOUSE_ID 352
+#define W_WAREHOUSE_NAME 353
+#define W_WAREHOUSE_SQ_FT 354
+#define W_ADDRESS_STREET_NUM 355
+#define W_ADDRESS_STREET_NAME1 356
+#define W_ADDRESS_STREET_TYPE 357
+#define W_ADDRESS_SUITE_NUM 358
+#define W_ADDRESS_CITY 359
+#define W_ADDRESS_COUNTY 360
+#define W_ADDRESS_STATE 361
+#define W_ADDRESS_ZIP 362
+#define W_ADDRESS_COUNTRY 363
+#define W_ADDRESS_GMT_OFFSET 364
+#define W_NULLS 365
+#define W_WAREHOUSE_ADDRESS 366
+#define WAREHOUSE_END 366
+#define WEB_PAGE_START 367
+#define WP_PAGE_SK 367
+#define WP_PAGE_ID 368
+#define WP_REC_START_DATE_ID 369
+#define WP_REC_END_DATE_ID 370
+#define WP_CREATION_DATE_SK 371
+#define WP_ACCESS_DATE_SK 372
+#define WP_AUTOGEN_FLAG 373
+#define WP_CUSTOMER_SK 374
+#define WP_URL 375
+#define WP_TYPE 376
+#define WP_CHAR_COUNT 377
+#define WP_LINK_COUNT 378
+#define WP_IMAGE_COUNT 379
+#define WP_MAX_AD_COUNT 380
+#define WP_NULLS 381
+#define WP_SCD 382
+#define WEB_PAGE_END 382
+#define WEB_RETURNS_START 383
+#define WR_RETURNED_DATE_SK 383
+#define WR_RETURNED_TIME_SK 384
+#define WR_ITEM_SK 385
+#define WR_REFUNDED_CUSTOMER_SK 386
+#define WR_REFUNDED_CDEMO_SK 387
+#define WR_REFUNDED_HDEMO_SK 388
+#define WR_REFUNDED_ADDR_SK 389
+#define WR_RETURNING_CUSTOMER_SK 390
+#define WR_RETURNING_CDEMO_SK 391
+#define WR_RETURNING_HDEMO_SK 392
+#define WR_RETURNING_ADDR_SK 393
+#define WR_WEB_PAGE_SK 394
+#define WR_REASON_SK 395
+#define WR_ORDER_NUMBER 396
+#define WR_PRICING_QUANTITY 397
+#define WR_PRICING_NET_PAID 398
+#define WR_PRICING_EXT_TAX 399
+#define WR_PRICING_NET_PAID_INC_TAX 400
+#define WR_PRICING_FEE 401
+#define WR_PRICING_EXT_SHIP_COST 402
+#define WR_PRICING_REFUNDED_CASH 403
+#define WR_PRICING_REVERSED_CHARGE 404
+#define WR_PRICING_STORE_CREDIT 405
+#define WR_PRICING_NET_LOSS 406
+#define WR_PRICING 407
+#define WR_NULLS 408
+#define WEB_RETURNS_END 408
+#define WEB_SALES_START 409
+#define WS_SOLD_DATE_SK 409
+#define WS_SOLD_TIME_SK 410
+#define WS_SHIP_DATE_SK 411
+#define WS_ITEM_SK 412
+#define WS_BILL_CUSTOMER_SK 413
+#define WS_BILL_CDEMO_SK 414
+#define WS_BILL_HDEMO_SK 415
+#define WS_BILL_ADDR_SK 416
+#define WS_SHIP_CUSTOMER_SK 417
+#define WS_SHIP_CDEMO_SK 418
+#define WS_SHIP_HDEMO_SK 419
+#define WS_SHIP_ADDR_SK 420
+#define WS_WEB_PAGE_SK 421
+#define WS_WEB_SITE_SK 422
+#define WS_SHIP_MODE_SK 423
+#define WS_WAREHOUSE_SK 424
+#define WS_PROMO_SK 425
+#define WS_ORDER_NUMBER 426
+#define WS_PRICING_QUANTITY 427
+#define WS_PRICING_WHOLESALE_COST 428
+#define WS_PRICING_LIST_PRICE 429
+#define WS_PRICING_SALES_PRICE 430
+#define WS_PRICING_EXT_DISCOUNT_AMT 431
+#define WS_PRICING_EXT_SALES_PRICE 432
+#define WS_PRICING_EXT_WHOLESALE_COST 433
+#define WS_PRICING_EXT_LIST_PRICE 434
+#define WS_PRICING_EXT_TAX 435
+#define WS_PRICING_COUPON_AMT 436
+#define WS_PRICING_EXT_SHIP_COST 437
+#define WS_PRICING_NET_PAID 438
+#define WS_PRICING_NET_PAID_INC_TAX 439
+#define WS_PRICING_NET_PAID_INC_SHIP 440
+#define WS_PRICING_NET_PAID_INC_SHIP_TAX 441
+#define WS_PRICING_NET_PROFIT 442
+#define WS_PRICING 443
+#define WS_NULLS 444
+#define WR_IS_RETURNED 445
+#define WS_PERMUTATION 446
+#define WEB_SALES_END 446
+#define WEB_SITE_START 447
+#define WEB_SITE_SK 447
+#define WEB_SITE_ID 448
+#define WEB_REC_START_DATE_ID 449
+#define WEB_REC_END_DATE_ID 450
+#define WEB_NAME 451
+#define WEB_OPEN_DATE 452
+#define WEB_CLOSE_DATE 453
+#define WEB_CLASS 454
+#define WEB_MANAGER 455
+#define WEB_MARKET_ID 456
+#define WEB_MARKET_CLASS 457
+#define WEB_MARKET_DESC 458
+#define WEB_MARKET_MANAGER 459
+#define WEB_COMPANY_ID 460
+#define WEB_COMPANY_NAME 461
+#define WEB_ADDRESS_STREET_NUM 462
+#define WEB_ADDRESS_STREET_NAME1 463
+#define WEB_ADDRESS_STREET_TYPE 464
+#define WEB_ADDRESS_SUITE_NUM 465
+#define WEB_ADDRESS_CITY 466
+#define WEB_ADDRESS_COUNTY 467
+#define WEB_ADDRESS_STATE 468
+#define WEB_ADDRESS_ZIP 469
+#define WEB_ADDRESS_COUNTRY 470
+#define WEB_ADDRESS_GMT_OFFSET 471
+#define WEB_TAX_PERCENTAGE 472
+#define WEB_NULLS 473
+#define WEB_ADDRESS 474
+#define WEB_SCD 475
+#define WEB_SITE_END 475
+#define DBGEN_VERSION_START 476
+#define DV_VERSION 476
+#define DV_CREATE_DATE 477
+#define DV_CREATE_TIME 478
+#define DV_CMDLINE_ARGS 479
+#define VALIDATE_STREAM 480
+#define DBGEN_VERSION_END 480
+#define S_BRAND_START 481
+#define S_BRAND_ID 481
+#define S_BRAND_SUBCLASS_ID 482
+#define S_BRAND_MANAGER_ID 483
+#define S_BRAND_MANUFACTURER_ID 484
+#define S_BRAND_NAME 485
+#define S_BRAND_END 485
+#define S_CUSTOMER_ADDRESS_START 486
+#define S_CADR_ID 486
+#define S_CADR_ADDRESS_STREET_NUMBER 487
+#define S_CADR_ADDRESS_STREET_NAME1 488
+#define S_CADR_ADDRESS_STREET_NAME2 489
+#define S_CADR_ADDRESS_STREET_TYPE 490
+#define S_CADR_ADDRESS_SUITE_NUM 491
+#define S_CADR_ADDRESS_CITY 492
+#define S_CADR_ADDRESS_COUNTY 493
+#define S_CADR_ADDRESS_STATE 494
+#define S_CADR_ADDRESS_ZIP 495
+#define S_CADR_ADDRESS_COUNTRY 496
+#define S_BADDR_ADDRESS 497
+#define S_CUSTOMER_ADDRESS_END 497
+#define S_CALL_CENTER_START 498
+#define S_CALL_CENTER_ID 498
+#define S_CALL_CENTER_DIVISION_ID 499
+#define S_CALL_CENTER_OPEN_DATE 500
+#define S_CALL_CENTER_CLOSED_DATE 501
+#define S_CALL_CENTER_NAME 502
+#define S_CALL_CENTER_CLASS 503
+#define S_CALL_CENTER_EMPLOYEES 504
+#define S_CALL_CENTER_SQFT 505
+#define S_CALL_CENTER_HOURS 506
+#define S_CALL_CENTER_MANAGER_ID 507
+#define S_CALL_CENTER_MARKET_ID 508
+#define S_CALL_CENTER_ADDRESS_ID 509
+#define S_CALL_CENTER_TAX_PERCENTAGE 510
+#define S_CALL_CENTER_SCD 511
+#define S_CALL_CENTER_END 511
+#define S_CATALOG_START 512
+#define S_CATALOG_NUMBER 512
+#define S_CATALOG_START_DATE 513
+#define S_CATALOG_END_DATE 514
+#define S_CATALOG_DESC 515
+#define S_CATALOG_TYPE 516
+#define S_CATALOG_END 516
+#define S_CATALOG_ORDER_START 517
+#define S_CORD_ID 517
+#define S_CORD_BILL_CUSTOMER_ID 518
+#define S_CORD_SHIP_CUSTOMER_ID 519
+#define S_CORD_ORDER_DATE 520
+#define S_CORD_ORDER_TIME 521
+#define S_CORD_SHIP_MODE_ID 522
+#define S_CORD_CALL_CENTER_ID 523
+#define S_CLIN_ITEM_ID 524
+#define S_CORD_COMMENT 525
+#define S_CATALOG_ORDER_END 525
+#define S_CATALOG_ORDER_LINEITEM_START 526
+#define S_CLIN_ORDER_ID 526
+#define S_CLIN_LINE_NUMBER 527
+#define S_CLIN_PROMOTION_ID 528
+#define S_CLIN_QUANTITY 529
+#define S_CLIN_COUPON_AMT 530
+#define S_CLIN_WAREHOUSE_ID 531
+#define S_CLIN_SHIP_DATE 532
+#define S_CLIN_CATALOG_ID 533
+#define S_CLIN_CATALOG_PAGE_ID 534
+#define S_CLIN_PRICING 535
+#define S_CLIN_SHIP_COST 536
+#define S_CLIN_IS_RETURNED 537
+#define S_CLIN_PERMUTE 538
+#define S_CATALOG_ORDER_LINEITEM_END 538
+#define S_CATALOG_PAGE_START 539
+#define S_CATALOG_PAGE_CATALOG_NUMBER 539
+#define S_CATALOG_PAGE_NUMBER 540
+#define S_CATALOG_PAGE_DEPARTMENT 541
+#define S_CP_ID 542
+#define S_CP_START_DATE 543
+#define S_CP_END_DATE 544
+#define S_CP_DESCRIPTION 545
+#define S_CP_TYPE 546
+#define S_CATALOG_PAGE_END 546
+#define S_CATALOG_PROMOTIONAL_ITEM_START 547
+#define S_CATALOG_PROMOTIONAL_ITEM_CATALOG_NUMBER 547
+#define S_CATALOG_PROMOTIONAL_ITEM_CATALOG_PAGE_NUMBER 548
+#define S_CATALOG_PROMOTIONAL_ITEM_ITEM_ID 549
+#define S_CATALOG_PROMOTIONAL_ITEM_PROMOTION_ID 550
+#define S_CATALOG_PROMOTIONAL_ITEM_END 550
+#define S_CATALOG_RETURNS_START 551
+#define S_CRET_CALL_CENTER_ID 551
+#define S_CRET_ORDER_ID 552
+#define S_CRET_LINE_NUMBER 553
+#define S_CRET_ITEM_ID 554
+#define S_CRET_RETURN_CUSTOMER_ID 555
+#define S_CRET_REFUND_CUSTOMER_ID 556
+#define S_CRET_DATE 557
+#define S_CRET_TIME 558
+#define S_CRET_QUANTITY 559
+#define S_CRET_AMOUNT 560
+#define S_CRET_TAX 561
+#define S_CRET_FEE 562
+#define S_CRET_SHIP_COST 563
+#define S_CRET_REFUNDED_CASH 564
+#define S_CRET_REVERSED_CHARGE 565
+#define S_CRET_MERCHANT_CREDIT 566
+#define S_CRET_REASON_ID 567
+#define S_CRET_PRICING 568
+#define S_CRET_SHIPMODE_ID 569
+#define S_CRET_WAREHOUSE_ID 570
+#define S_CRET_CATALOG_PAGE_ID 571
+#define S_CATALOG_RETURNS_END 571
+#define S_CATEGORY_START 572
+#define S_CATEGORY_ID 572
+#define S_CATEGORY_NAME 573
+#define S_CATEGORY_DESC 574
+#define S_CATEGORY_END 574
+#define S_CLASS_START 575
+#define S_CLASS_ID 575
+#define S_CLASS_SUBCAT_ID 576
+#define S_CLASS_DESC 577
+#define S_CLASS_END 577
+#define S_COMPANY_START 578
+#define S_COMPANY_ID 578
+#define S_COMPANY_NAME 579
+#define S_COMPANY_END 579
+#define S_CUSTOMER_START 580
+#define S_CUST_ID 580
+#define S_CUST_SALUTATION 581
+#define S_CUST_LAST_NAME 582
+#define S_CUST_FIRST_NAME 583
+#define S_CUST_PREFERRED_FLAG 584
+#define S_CUST_BIRTH_DATE 585
+#define S_CUST_FIRST_PURCHASE_DATE 586
+#define S_CUST_FIRST_SHIPTO_DATE 587
+#define S_CUST_BIRTH_COUNTRY 588
+#define S_CUST_LOGIN 589
+#define S_CUST_EMAIL 590
+#define S_CUST_LAST_LOGIN 591
+#define S_CUST_LAST_REVIEW 592
+#define S_CUST_PRIMARY_MACHINE 593
+#define S_CUST_SECONDARY_MACHINE 594
+#define S_CUST_ADDRESS 595
+#define S_CUST_ADDRESS_STREET_NUM 596
+#define S_CUST_ADDRESS_STREET_NAME1 597
+#define S_CUST_ADDRESS_STREET_NAME2 598
+#define S_CUST_ADDRESS_STREET_TYPE 599
+#define S_CUST_ADDRESS_SUITE_NUM 600
+#define S_CUST_ADDRESS_CITY 601
+#define S_CUST_ADDRESS_ZIP 602
+#define S_CUST_ADDRESS_COUNTY 603
+#define S_CUST_ADDRESS_STATE 604
+#define S_CUST_ADDRESS_COUNTRY 605
+#define S_CUST_LOCATION_TYPE 606
+#define S_CUST_GENDER 607
+#define S_CUST_MARITAL_STATUS 608
+#define S_CUST_EDUCATION 609
+#define S_CUST_CREDIT_RATING 610
+#define S_CUST_PURCHASE_ESTIMATE 611
+#define S_CUST_BUY_POTENTIAL 612
+#define S_CUST_DEPENDENT_CNT 613
+#define S_CUST_EMPLOYED_CNT 614
+#define S_CUST_COLLEGE_CNT 615
+#define S_CUST_VEHICLE_CNT 616
+#define S_CUST_INCOME 617
+#define S_CUSTOMER_END 617
+#define S_DIVISION_START 618
+#define S_DIVISION_ID 618
+#define S_DIVISION_COMPANY 619
+#define S_DIVISION_NAME 620
+#define S_DIVISION_END 620
+#define S_INVENTORY_START 621
+#define S_INVN_WAREHOUSE 621
+#define S_INVN_ITEM 622
+#define S_INVN_DATE 623
+#define S_INVN_QUANTITY 624
+#define S_INVENTORY_END 624
+#define S_ITEM_START 625
+#define S_ITEM_ID 625
+#define S_ITEM_PERMUTE 626
+#define S_ITEM_PRODUCT_ID 627
+#define S_ITEM_DESC 628
+#define S_ITEM_LIST_PRICE 629
+#define S_ITEM_WHOLESALE_COST 630
+#define S_ITEM_MANAGER_ID 631
+#define S_ITEM_SIZE 632
+#define S_ITEM_FORMULATION 633
+#define S_ITEM_FLAVOR 634
+#define S_ITEM_UNITS 635
+#define S_ITEM_CONTAINER 636
+#define S_ITEM_SCD 637
+#define S_ITEM_END 637
+#define S_MANAGER_START 638
+#define S_MANAGER_ID 638
+#define S_MANAGER_NAME 639
+#define S_MANAGER_END 639
+#define S_MANUFACTURER_START 640
+#define S_MANUFACTURER_ID 640
+#define S_MANUFACTURER_NAME 641
+#define S_MANUFACTURER_END 641
+#define S_MARKET_START 642
+#define S_MARKET_ID 642
+#define S_MARKET_CLASS_NAME 643
+#define S_MARKET_DESC 644
+#define S_MARKET_MANAGER_ID 645
+#define S_MARKET_END 645
+#define S_PRODUCT_START 646
+#define S_PRODUCT_ID 646
+#define S_PRODUCT_BRAND_ID 647
+#define S_PRODUCT_NAME 648
+#define S_PRODUCT_TYPE 649
+#define S_PRODUCT_END 649
+#define S_PROMOTION_START 650
+#define S_PROMOTION_ID 650
+#define S_PROMOTION_ITEM_ID 651
+#define S_PROMOTION_START_DATE 652
+#define S_PROMOTION_END_DATE 653
+#define S_PROMOTION_COST 654
+#define S_PROMOTION_RESPONSE_TARGET 655
+#define S_PROMOTION_DMAIL 656
+#define S_PROMOTION_EMAIL 657
+#define S_PROMOTION_CATALOG 658
+#define S_PROMOTION_TV 659
+#define S_PROMOTION_RADIO 660
+#define S_PROMOTION_PRESS 661
+#define S_PROMOTION_EVENT 662
+#define S_PROMOTION_DEMO 663
+#define S_PROMOTION_DETAILS 664
+#define S_PROMOTION_PURPOSE 665
+#define S_PROMOTION_DISCOUNT_ACTIVE 666
+#define S_PROMOTION_DISCOUNT_PCT 667
+#define S_PROMOTION_NAME 668
+#define S_PROMOTION_BITFIELD 669
+#define S_PROMOTION_END 669
+#define S_PURCHASE_START 670
+#define S_PURCHASE_ID 670
+#define S_PURCHASE_STORE_ID 671
+#define S_PURCHASE_CUSTOMER_ID 672
+#define S_PURCHASE_DATE 673
+#define S_PURCHASE_TIME 674
+#define S_PURCHASE_REGISTER 675
+#define S_PURCHASE_CLERK 676
+#define S_PURCHASE_COMMENT 677
+#define S_PURCHASE_PRICING 678
+#define S_PLINE_ITEM_ID 679
+#define S_PURCHASE_END 679
+#define S_PURCHASE_LINEITEM_START 680
+#define S_PLINE_PURCHASE_ID 680
+#define S_PLINE_NUMBER 681
+#define S_PLINE_PROMOTION_ID 682
+#define S_PLINE_SALE_PRICE 683
+#define S_PLINE_QUANTITY 684
+#define S_PLINE_COUPON_AMT 685
+#define S_PLINE_COMMENT 686
+#define S_PLINE_PRICING 687
+#define S_PLINE_IS_RETURNED 688
+#define S_PLINE_PERMUTE 689
+#define S_PURCHASE_LINEITEM_END 689
+#define S_REASON_START 690
+#define S_REASON_ID 690
+#define S_REASON_DESC 691
+#define S_REASON_END 691
+#define S_STORE_START 692
+#define S_STORE_ID 692
+#define S_STORE_ADDRESS_ID 693
+#define S_STORE_DIVISION_ID 694
+#define S_STORE_OPEN_DATE 695
+#define S_STORE_CLOSE_DATE 696
+#define S_STORE_NAME 697
+#define S_STORE_CLASS 698
+#define S_STORE_EMPLOYEES 699
+#define S_STORE_FLOOR_SPACE 700
+#define S_STORE_HOURS 701
+#define S_STORE_MARKET_MANAGER_ID 702
+#define S_STORE_MANAGER_ID 703
+#define S_STORE_MARKET_ID 704
+#define S_STORE_GEOGRAPHY_CLASS 705
+#define S_STORE_TAX_PERCENTAGE 706
+#define S_STORE_END 706
+#define S_STORE_PROMOTIONAL_ITEM_START 707
+#define S_SITM_PROMOTION_ID 707
+#define S_SITM_ITEM_ID 708
+#define S_SITM_STORE_ID 709
+#define S_STORE_PROMOTIONAL_ITEM_END 709
+#define S_STORE_RETURNS_START 710
+#define S_SRET_STORE_ID 710
+#define S_SRET_PURCHASE_ID 711
+#define S_SRET_LINENUMBER 712
+#define S_SRET_ITEM_ID 713
+#define S_SRET_CUSTOMER_ID 714
+#define S_SRET_RETURN_DATE 715
+#define S_SRET_RETURN_TIME 716
+#define S_SRET_TICKET_NUMBER 717
+#define S_SRET_RETURN_QUANTITY 718
+#define S_SRET_RETURN_AMT 719
+#define S_SRET_RETURN_TAX 720
+#define S_SRET_RETURN_FEE 721
+#define S_SRET_RETURN_SHIP_COST 722
+#define S_SRET_REFUNDED_CASH 723
+#define S_SRET_REVERSED_CHARGE 724
+#define S_SRET_MERCHANT_CREDIT 725
+#define S_SRET_REASON_ID 726
+#define S_SRET_PRICING 727
+#define S_STORE_RETURNS_END 727
+#define S_SUBCATEGORY_START 728
+#define S_SBCT_ID 728
+#define S_SBCT_CATEGORY_ID 729
+#define S_SBCT_NAME 730
+#define S_SBCT_DESC 731
+#define S_SUBCATEGORY_END 731
+#define S_SUBCLASS_START 732
+#define S_SUBC_ID 732
+#define S_SUBC_CLASS_ID 733
+#define S_SUBC_NAME 734
+#define S_SUBC_DESC 735
+#define S_SUBCLASS_END 735
+#define S_WAREHOUSE_START 736
+#define S_WRHS_ID 736
+#define S_WRHS_DESC 737
+#define S_WRHS_SQFT 738
+#define S_WRHS_ADDRESS_ID 739
+#define S_WAREHOUSE_END 739
+#define S_WEB_ORDER_START 740
+#define S_WORD_ID 740
+#define S_WORD_BILL_CUSTOMER_ID 741
+#define S_WORD_SHIP_CUSTOMER_ID 742
+#define S_WORD_ORDER_DATE 743
+#define S_WORD_ORDER_TIME 744
+#define S_WORD_SHIP_MODE_ID 745
+#define S_WORD_WEB_SITE_ID 746
+#define S_WORD_COMMENT 747
+#define S_WLIN_ITEM_ID 748
+#define S_WEB_ORDER_END 748
+#define S_WEB_ORDER_LINEITEM_START 749
+#define S_WLIN_ID 749
+#define S_WLIN_LINE_NUMBER 750
+#define S_WLIN_PROMOTION_ID 751
+#define S_WLIN_QUANTITY 752
+#define S_WLIN_COUPON_AMT 753
+#define S_WLIN_WAREHOUSE_ID 754
+#define S_WLIN_SHIP_DATE 755
+#define S_WLIN_WEB_PAGE_ID 756
+#define S_WLIN_PRICING 757
+#define S_WLIN_SHIP_COST 758
+#define S_WLIN_IS_RETURNED 759
+#define S_WLIN_PERMUTE 760
+#define S_WEB_ORDER_LINEITEM_END 760
+#define S_WEB_PAGE_START 761
+#define S_WPAG_SITE_ID 761
+#define S_WPAG_ID 762
+#define S_WPAG_CREATE_DATE 763
+#define S_WPAG_ACCESS_DATE 764
+#define S_WPAG_AUTOGEN_FLAG 765
+#define S_WPAG_DEPARTMENT 766
+#define S_WPAG_URL 767
+#define S_WPAG_TYPE 768
+#define S_WPAG_CHAR_CNT 769
+#define S_WPAG_LINK_CNT 770
+#define S_WPAG_IMAGE_CNT 771
+#define S_WPAG_MAX_AD_CNT 772
+#define S_WPAG_PERMUTE 773
+#define S_WEB_PAGE_END 773
+#define S_WEB_PROMOTIONAL_ITEM_START 774
+#define S_WITM_SITE_ID 774
+#define S_WITM_PAGE_ID 775
+#define S_WITM_ITEM_ID 776
+#define S_WITM_PROMOTION_ID 777
+#define S_WEB_PROMOTIONAL_ITEM_END 777
+#define S_WEB_RETURNS_START 778
+#define S_WRET_SITE_ID 778
+#define S_WRET_ORDER_ID 779
+#define S_WRET_LINE_NUMBER 780
+#define S_WRET_ITEM_ID 781
+#define S_WRET_RETURN_CUST_ID 782
+#define S_WRET_REFUND_CUST_ID 783
+#define S_WRET_RETURN_DATE 784
+#define S_WRET_RETURN_TIME 785
+#define S_WRET_REASON_ID 786
+#define S_WRET_PRICING 787
+#define S_WEB_RETURNS_END 787
+#define S_WEB_SITE_START 788
+#define S_WSIT_ID 788
+#define S_WSIT_OPEN_DATE 789
+#define S_WSIT_CLOSE_DATE 790
+#define S_WSIT_NAME 791
+#define S_WSIT_ADDRESS_ID 792
+#define S_WSIT_DIVISION_ID 793
+#define S_WSIT_CLASS 794
+#define S_WSIT_MANAGER_ID 795
+#define S_WSIT_MARKET_ID 796
+#define S_WSIT_TAX_PERCENTAGE 797
+#define S_WEB_SITE_END 797
+#define S_ZIPG_START 798
+#define S_ZIPG_ZIP 798
+#define S_ZIPG_GMT 799
+#define S_ZIPG_END 799
+#define MAX_COLUMN 799
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/config.h b/velox/tpcds/gen/dsdgen/include/config.h
new file mode 100644
index 000000000000..ccef0db77ad8
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/config.h
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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.
+ */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+// #ifdef MACOS
+#define SUPPORT_64BITS
+#define HUGE_TYPE int64_t
+#define HUGE_FORMAT "%lld"
+#define HUGE_COUNT 1
+#define USE_STRING_H
+#define USE_STDLIB_H
+#define USE_LIMITS_H
+#include <limits.h>
+#define MAXINT INT_MAX
+
+// #define FLEX
+// #endif /* MACOS */
+
+#ifdef NCR
+#define STDLIB_HAS_GETOPT
+#define USE_STRING_H
+#define USE_VALUES_H
+#ifdef SQLSERVER
+#define WIN32
+#else
+/* the 64 bit defines are for the Metaware compiler */
+#define SUPPORT_64BITS
+#define HUGE_TYPE long long
+#define HUGE_COUNT 1
+#define HUGE_FORMAT "%LLd"
+#define int32_t int
+#endif /* SQLSERVER or MP/RAS */
+#endif /* NCR */
+
+#ifdef AIX
+#define _ALL_SOURCE
+#define USE_STRING_H
+#define USE_LIMITS_H
+/*
+ * if the C compiler is 3.1 or later, then uncomment the
+ * lines for 64 bit seed generation
+ */
+#define SUPPORT_64BITS
+#define HUGE_TYPE long long
+#define HUGE_COUNT 1
+#define HUGE_FORMAT "%lld"
+#define STDLIB_HAS_GETOPT
+#define USE_STDLIB_H
+#define FLEX
+#endif /* AIX */
+
+#ifdef CYGWIN
+#define USE_STRING_H
+#define PATH_SEP '\\'
+#define SUPPORT_64BITS
+#define HUGE_TYPE __int64
+#define HUGE_COUNT 1
+#define HUGE_FORMAT "%I64d"
+#endif /* WIN32 */
+
+#ifdef HPUX
+#define SUPPORT_64BITS
+#define HUGE_TYPE long long int
+#define HUGE_FORMAT "%lld"
+#define HUGE_COUNT 1
+#define USE_STRING_H
+#define USE_VALUES_H
+#define USE_STDLIB_H
+#define FLEX
+#endif /* HPUX */
+
+#ifdef INTERIX
+#define USE_LIMITS_H
+#define SUPPORT_64BITS
+#define HUGE_TYPE long long int
+#define HUGE_FORMAT "%lld"
+#define HUGE_COUNT 1
+#endif /* INTERIX */
+
+#ifdef LINUX
+#define SUPPORT_64BITS
+#define HUGE_TYPE int64_t
+#define HUGE_FORMAT "%lld"
+#define HUGE_COUNT 1
+#define USE_STRING_H
+#define USE_VALUES_H
+#define USE_STDLIB_H
+#define FLEX
+#endif /* LINUX */
+
+#ifdef SOLARIS
+#define SUPPORT_64BITS
+#define HUGE_TYPE long long
+#define HUGE_FORMAT "%lld"
+#define HUGE_COUNT 1
+#define USE_STRING_H
+#define USE_VALUES_H
+#define USE_STDLIB_H
+#endif /* SOLARIS */
+
+#ifdef SOL86
+#define SUPPORT_64BITS
+#define HUGE_TYPE long long
+#define HUGE_FORMAT "%lld"
+#define HUGE_COUNT 1
+#define USE_STRING_H
+#define USE_VALUES_H
+#define USE_STDLIB_H
+#endif /* SOLARIS */
+
+#ifdef WIN32
+#define USE_STRING_H
+#define USE_LIMITS_H
+#define PATH_SEP '\\'
+#define SUPPORT_64BITS
+#define HUGE_TYPE __int64
+#define HUGE_COUNT 1
+#define HUGE_FORMAT "%I64d"
+#endif /* WIN32 */
+
+/* preliminary defines for 64-bit windows compile */
+#ifdef WIN64
+#define USE_STRING_H
+#define PATH_SEP '\\'
+#define SUPPORT_64BITS
+#define HUGE_TYPE __int64
+#define HUGE_COUNT 1
+#define HUGE_FORMAT "%I64d"
+#endif /* WIN32 */
+
+#ifndef PATH_SEP
+#define PATH_SEP '/'
+#endif /* PATH_SEP */
+
+#ifndef HUGE_TYPE
+#error The code now requires 64b support
+#endif
+
+/***
+ ** DATABASE DEFINES
+ ***/
+#ifdef _MYSQL
+#define STR_QUOTES
+#endif
+
+#endif /* CONFIG_H */
diff --git a/velox/tpcds/gen/dsdgen/include/constants.h b/velox/tpcds/gen/dsdgen/include/constants.h
new file mode 100644
index 000000000000..dfd2d0d5caa6
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/constants.h
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef CONSTANTS_H
+#define CONSTANTS_H
+/***
+*** Multi-table/Global Defines
+***/
+#define DATA_START_DATE "1998-01-01" /* earliest date in the data set */
+#define DATA_END_DATE "2003-12-31" /* latest date in the data set */
+#define LINES_PER_ORDER \
+  16 /* max number of lineitems per order for all channels */
+
+/***
+*** C_xxx Cutomer Defines
+***/
+#define C_PREFERRED_PCT 50
+
+/***
+ *** CC_xxx Call Center Defines
+ ***/
+#define CC_EMPLOYEE_MAX 7 /* rises ~ scale ^ 2 */
+
+/***
+ *** CP_xxx Catalog Page Defines
+ ***/
+#define CP_CATALOGS_PER_YEAR 18
+#define CP_SK(c, s, p) (c * s + p)
+
+/***
+*** CR_xxx Catalog Returns Defines
+***/
+#define CR_RETURN_PCT 10 /* percentage of catalog sales that are returned */
+
+/***
+*** CS_xxx Customer Sales Defines
+***/
+#define CS_QUANTITY_MAX "100"
+#define CS_MARKUP_MAX "2.00"
+#define CS_DISCOUNT_MAX "1.00"
+#define CS_WHOLESALE_MAX "100.00"
+#define CS_COUPON_MAX "0.50"
+#define CS_MIN_SHIP_DELAY 2 /* minimum days from order to ship */
+#define CS_MAX_SHIP_DELAY 90 /* maximum days from order to ship */
+#define CS_ITEMS_PER_ORDER 10 /* number of items in each order */
+#define CS_GIFT_PCT 10 /* ship-to != bill-to */
+
+/*
+ * DATE SETTINGS
+ *
+ * The benchmarks sense of "today". Should this be a sliding scale/parameter?
+ */
+#define CURRENT_YEAR 2003
+#define CURRENT_MONTH 1
+#define CURRENT_DAY 8
+#define CURRENT_QUARTER 1
+#define CURRENT_WEEK 2
+#define DATE_MINIMUM "1998-01-01"
+#define DATE_MAXIMUM "2002-12-31"
+#define YEAR_MINIMUM 1998
+#define YEAR_MAXIMUM 2002
+#define WAREHOUSE_LOAD_DATE "2001-07-18"
+#define UPDATE_INTERVAL 30 /* refresh interval in days */
+#define TODAYS_DATE "2003-01-08"
+
+/***
+ *** INV_xxx Inventory Defines
+ ***/
+#define INV_QUANTITY_MIN 0
+#define INV_QUANTITY_MAX 1000
+
+/***
+ *** ITEM_xxx Item Defines
+ ***/
+#define ITEM_DESC_LEN 5
+#define ITEM_NAME_LEN 10
+#define ITEM_MANFACTURER_COUNT \
+  1000 /* number of brands handled by a particular manufacturer */
+
+/***
+ *** PROMO_xxx Promotions Defines
+ ***/
+#define PROMO_NAME_LEN 5
+#define PROMO_START_MIN -720
+#define PROMO_START_MAX 100
+#define PROMO_START_MEAN 0
+#define PROMO_LEN_MIN 1
+#define PROMO_LEN_MAX 60
+#define PROMO_LEN_MEAN 0
+#define PROMO_DETAIL_LEN_MIN 20
+#define PROMO_DETAIL_LEN_MAX 60
+
+/***
+*** SR_xxx Store Returns Defines
+***/
+#define SR_RETURN_PCT 10 /* percentage of store sales that are returned */
+
+/***
+*** SS_xxx Store Sales Defines
+***/
+#define SS_MIN_SHIP_DELAY 2 /* minimum days from order to ship */
+#define SS_MAX_SHIP_DELAY 90 /* maximum days from order to ship */
+#define SS_QUANTITY_MAX "100"
+#define SS_MARKUP_MAX "1.00"
+#define SS_DISCOUNT_MAX "1.00"
+#define SS_WHOLESALE_MAX "100.00"
+#define SS_COUPON_MAX "0.50"
+
+/***
+*** WP_xxx Web Page Defines
+***/
+#define WP_AUTOGEN_PCT 30
+#define WP_LINK_MIN 2
+#define WP_LINK_MAX 25
+#define WP_IMAGE_MIN 1
+#define WP_IMAGE_MAX 7
+#define WP_AD_MIN 0
+#define WP_AD_MAX 4
+#define WP_MAX_REC_DURATION                        \
+  1000 /* maximum time from start to end of record \
+        */
+#define WP_IDLE_TIME_MAX 100 /* maximum time since last page access */
+
+/***
+*** W_xxx Warehouse Defines
+***/
+#define W_DESC_MIN 5
+#define W_SQFT_MIN 50000
+#define W_SQFT_MAX 1000000
+#define W_NAME_MIN 10
+
+/***
+*** WR_xxx Web Returns Defines
+***/
+#define WR_RETURN_PCT 10 /* percentage of web sales that are returned */
+#define WR_SHIP_LAG_MIN 2 /* lag time between receiving and returning */
+#define WR_SHIP_LAG_MAX 12
+
+/***
+*** WEB_xxx Web Site Defines
+***/
+#define WEB_START_DATE                                                     \
+  DATE_MINIMUM /* range of open/close dates; actual dates can exceed these \
+                  values */
+#define WEB_END_DATE DATE_MAXIMUM /* due to staggered start of each site */
+#define WEB_DATE_STAGGER \
+  17 /* time between site creation on leading/trailing edge */
+#define WEB_PAGES_PER_SITE 123 /* number of pages on a web site */
+/* some of the web sites are completely replaced in the date range. */
+#define WEB_MORTALITY \
+  50 /* percentage of sites that "die" between start and end */
+#define WEB_IS_REPLACED(j) \
+  ((j % (100 / WEB_MORTALITY)) == 0) /* does this site get replaced? */
+#define WEB_IS_REPLACEMENT(j) \
+  ((j / (100 / WEB_MORTALITY)) % 2) /* is this the replacement? */
+
+/***
+ *** SOURCE SCHEMA CONSTANTS
+ ***/
+#define DAYS_PER_UPDATE 3
+
+/***
+*** RS_xxx: Row and column sizes
+***/
+/* sizes used in various tables */
+#define RS_BKEY 16
+/* table-specific sizes */
+
+#define RS_BRND_NAME 50
+#define RS_C_SALUTATION 5
+#define RS_C_FIRST_NAME 20
+#define RS_C_LAST_NAME 30
+#define RS_C_BIRTH_COUNTRY 20
+#define RS_C_LOGIN 13
+#define RS_C_PASSWORD 13
+#define RS_C_EMAIL 50
+#define RS_C_PRIMARY_MACHINE_ID 15
+#define RS_C_SECONDARY_MACHINE_ID 15
+#define RS_CA_SUITE_NUMBER 10
+#define RS_CA_STREET_NAME 60
+#define RS_CA_STREET_TYPE 15
+#define RS_CA_CITY 60
+#define RS_CA_COUNTY 30
+#define RS_CA_STATE 2
+#define RS_CA_COUNTRY 20
+#define RS_CA_ZIP 10
+#define RS_CA_LOCATION_TYPE 20
+#define RS_CATG_DESC 20
+#define RS_CC_NAME 50
+#define RS_CC_CLASS 50
+#define RS_CC_HOURS 20
+#define RS_CC_MANAGER 40
+#define RS_CC_MARKET_MANAGER 40
+#define RS_CC_MARKET_CLASS 50
+#define RS_CC_MARKET_DESC 100
+#define RS_CC_DIVISION_NAME 50
+#define RS_CC_COMPANY_NAME 60
+#define RS_CC_SUITE_NUM 10
+#define RS_CC_STREET_NAME 60
+#define RS_CC_STREET_TYPE 15
+#define RS_CC_CITY 60
+#define RS_CC_COUNTY 30
+#define RS_CC_STATE 2
+#define RS_CC_COUNTRY 20
+#define RS_CC_ZIP 10
+#define RS_CD_GENDER 1
+#define RS_CD_MARITAL_STATUS 1
+#define RS_CD_EDUCATION_STATUS 20
+#define RS_CD_CREDIT_RATING 10
+#define RS_CP_DEPARTMENT 20
+#define RS_CLAS_DESC 100
+#define RS_CMPY_NAME 50
+#define RS_CP_DESCRIPTION 100
+#define RS_CP_TYPE 100
+#define RS_CTGR_NAME 25
+#define RS_CTGR_DESC 100
+#define RS_CUST_CREDIT 100
+#define RS_D_DAY_NAME 4
+#define RS_D_QUARTER_NAME 4
+#define RS_DVSN_NAME 50
+#define RS_HD_BUY_POTENTIAL 7
+#define RS_I_ITEM_DESC 200
+#define RS_I_BRAND 50
+#define RS_I_SUBCLASS 50
+#define RS_I_CLASS 50
+#define RS_I_SUBCATEGORY 50
+#define RS_I_CATEGORY 50
+#define RS_I_MANUFACT 50
+#define RS_I_SIZE 20
+#define RS_I_FORMULATION 20
+#define RS_I_FLAVOR 20
+#define RS_I_UNITS 10
+#define RS_I_CONTAINER 10
+#define RS_I_PRODUCT_NAME 50
+#define RS_MANF_NAME 50
+#define RS_MNGR_NAME 50
+#define RS_P_PROMO_NAME 50
+#define RS_P_CHANNEL_DETAILS 100
+#define RS_P_PURPOSE 15
+#define RS_PB_DESCRIPTION 100
+#define RS_PLIN_COMMENT 100
+#define RS_PROD_NAME 100
+#define RS_PROD_TYPE 100
+#define RS_R_REASON_DESCRIPTION 100
+#define RS_STORE_NAME 50
+#define RS_STORE_HOURS 20
+#define RS_S_STORE_MANAGER 40
+#define RS_S_GEOGRAPHY_CLASS 100
+#define RS_S_MARKET_DESC 100
+#define RS_S_MARKET_MANAGER 40
+#define RS_S_DIVISION_NAME 50
+#define RS_S_COMPANY_NAME 50
+#define RS_S_SUITE_NUM 10
+#define RS_S_STREET_NAME 60
+#define RS_S_STREET_TYPE 15
+#define RS_S_CITY 60
+#define RS_S_STATE 2
+#define RS_S_COUNTY 30
+#define RS_S_COUNTRY 30
+#define RS_S_ZIP 10
+#define RS_SM_TYPE 30
+#define RS_SM_CODE 10
+#define RS_SM_CONTRACT 20
+#define RS_SM_CARRIER 20
+#define RS_SBCT_NAME 100
+#define RS_SBCT_DESC 100
+#define RS_SUBC_NAME 100
+#define RS_SUBC_DESC 100
+#define RS_T_AM_PM 2
+#define RS_T_SHIFT 20
+#define RS_T_SUB_SHIFT 20
+#define RS_T_MEAL_TIME 20
+#define RS_W_WAREHOUSE_NAME 20
+#define RS_W_STREET_NAME 60
+#define RS_W_SUITE_NUM 10
+#define RS_W_STREET_TYPE 15
+#define RS_W_CITY 60
+#define RS_W_COUNTY 30
+#define RS_W_STATE 2
+#define RS_W_COUNTRY 20
+#define RS_W_ZIP 10
+#define RS_WEB_MANAGER 50
+#define RS_WEB_NAME 50
+#define RS_WEB_CLASS 50
+#define RS_WEB_MARKET_CLASS 50
+#define RS_WEB_MARKET_DESC 100
+#define RS_WEB_MARKET_MANAGER 40
+#define RS_WEB_COMPANY_NAME 100
+#define RS_WEB_SUITE_NUMBER 10
+#define RS_WEB_STREET_NAME 60
+#define RS_WEB_STREET_TYPE 15
+#define RS_WEB_CITY 60
+#define RS_WEB_COUNTY 30
+#define RS_WEB_STATE 2
+#define RS_WEB_COUNTRY 20
+#define RS_WEB_ZIP 10
+#define RS_WP_URL 100
+#define RS_WEB_TYPE 50
+#define RS_WRHS_DESC 100
+#define RS_WORD_COMMENT 100
+#define RS_ZIPG_ZIP 5
+#endif /* CONSTANTS_H */
diff --git a/velox/tpcds/gen/dsdgen/include/date.h b/velox/tpcds/gen/dsdgen/include/date.h
new file mode 100644
index 000000000000..fee42cb6cbc4
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/date.h
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef R_DATE_H
+#define R_DATE_H
+
+#include <string>
+#include <vector>
+#include "velox/tpcds/gen/dsdgen/include/mathops.h"
+
+typedef struct DATE_T {
+  int flags;
+  int year;
+  int month;
+  int day;
+  int julian;
+} date_t;
+
+int jtodt(date_t* dest, int i);
+int strtodt(date_t* dest, const char* s);
+date_t strtodate(const char* str);
+
+int dttoj(date_t* d);
+
+int date_t_op(date_t* dest, int o, date_t* d1, date_t* d2);
+int set_dow(date_t* d);
+int is_leap(int year);
+int day_number(date_t* d);
+int date_part(date_t* d, int p);
+#define CENTURY_SHIFT 20 /* years before this are assumed to be 2000's */
+/*
+ * DATE OPERATORS
+ */
+#define OP_FIRST_DOM 0x01 /* get date of first day of current month */
+#define OP_LAST_DOM \
+  0x02 /* get date of last day of current month; LY == 2/28) */
+#define OP_SAME_LY 0x03 /* get date for same day/month, last year */
+#define OP_SAME_LQ 0x04 /* get date for same offset in the prior quarter */
+
+extern const std::vector<const char*> weekday_names;
+
+#endif /* R_DATE_H */
diff --git a/velox/runner/Runner.cpp b/velox/tpcds/gen/dsdgen/include/dbgen_version.h
similarity index 52%
rename from velox/runner/Runner.cpp
rename to velox/tpcds/gen/dsdgen/include/dbgen_version.h
index 828f7b1cbc05..16f8d8a373f8 100644
--- a/velox/runner/Runner.cpp
+++ b/velox/tpcds/gen/dsdgen/include/dbgen_version.h
@@ -13,26 +13,26 @@
  * 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 tpcds/gen/dsdgen/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 "velox/runner/Runner.h"
-
-namespace facebook::velox::runner {
+#ifndef DBGEN_VERSION_H
+#define DBGEN_VERSION_H
 
-// static
-std::string Runner::stateString(Runner::State state) {
-  switch (state) {
-    case Runner::State::kInitialized:
-      return "initialized";
-    case Runner::State::kRunning:
-      return "running";
-    case Runner::State::kCancelled:
-      return "cancelled";
-    case Runner::State::kError:
-      return "error";
-    case Runner::State::kFinished:
-      return "finished";
-  }
-  return fmt::format("invalid state {}", static_cast<int32_t>(state));
-}
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
 
-} // namespace facebook::velox::runner
+int mk_dbgen_version(
+    void* pDest,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+int pr_dbgen_version(void* pSrc);
+int ld_dbgen_version(void* pSrc);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/dcomp.h b/velox/tpcds/gen/dsdgen/include/dcomp.h
new file mode 100644
index 000000000000..d73786f597b8
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/dcomp.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef DCOMP_H
+#define DCOMP_H
+
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/grammar.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+/*
+ * query template grammar definition
+ */
+#define TKN_UNKNOWN 0
+#define TKN_CREATE 1
+#define TKN_WEIGHTS 2
+#define TKN_TYPES 3
+#define TKN_INCLUDE 4
+#define TKN_SET 5
+#define TKN_VARCHAR 6
+#define TKN_INT 7
+#define TKN_ADD 8
+#define TKN_DATE 9
+#define TKN_DECIMAL 10
+#define TKN_NAMES 11
+#define MAX_TOKEN 11
+
+int ProcessDistribution(char* s, token_t* t);
+int ProcessTypes(char* s, token_t* t);
+int ProcessInclude(char* s, token_t* t);
+int ProcessSet(char* s, token_t* t);
+int ProcessAdd(char* s, token_t* t);
+
+#ifdef DECLARER
+token_t dcomp_tokens[MAX_TOKEN + 2] = {
+    {TKN_UNKNOWN, "", NULL},
+    {TKN_CREATE, "create", ProcessDistribution},
+    {TKN_WEIGHTS, "weights", NULL},
+    {TKN_TYPES, "types", NULL},
+    {TKN_INCLUDE, "#include", ProcessInclude},
+    {TKN_SET, "set", ProcessSet},
+    {TKN_VARCHAR, "varchar", NULL},
+    {TKN_INT, "int", NULL},
+    {TKN_ADD, "add", ProcessAdd},
+    {TKN_DATE, "date", NULL},
+    {TKN_DECIMAL, "decimal", NULL},
+    {TKN_NAMES, "names", NULL},
+    {-1, "", NULL}};
+#else
+extern token_t tokens[];
+#endif
+
+#endif /* DCOMP_H */
diff --git a/velox/tpcds/gen/dsdgen/include/decimal.h b/velox/tpcds/gen/dsdgen/include/decimal.h
new file mode 100644
index 000000000000..9958ce07d7b9
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/decimal.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef R_DECIMAL_H
+#define R_DECIMAL_H
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/mathops.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+#define FL_INIT 0x0004
+
+int itodec(decimal_t* dest, int i);
+int strtodec(decimal_t* d, const char* src);
+
+#define dectoi(d) atoi(d->number)
+
+int decimal_t_op(decimal_t* dest, int o, decimal_t* d1, decimal_t* d2);
+void set_precision(decimal_t* d, int sie, int precision);
+#define NegateDecimal(d) (d)->number *= -1
+#endif /* R_DECIMAL_H */
diff --git a/velox/tpcds/gen/dsdgen/include/dist.h b/velox/tpcds/gen/dsdgen/include/dist.h
new file mode 100644
index 000000000000..738f1927629e
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/dist.h
@@ -0,0 +1,4002 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 <folly/Singleton.h>
+#include <folly/Synchronized.h>
+#include <algorithm>
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+
+#ifndef STREAMS_H
+#define STREAMS_H
+#endif
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+
+#ifndef R_DIST_H
+#define R_DIST_H
+#endif
+
+/***
+ *** RELEASE INFORMATION
+ ***/
+#define VERSION 2
+#define RELEASE 10
+#define MODIFICATION 0
+#define PATCH ""
+#define COPYRIGHT "Transaction Processing Performance Council (TPC)"
+#define C_DATES "2001 - 2018"
+
+#define D_NAME_LEN 20
+#define MAX_STREAM 805
+
+#define RS_W_STORE_NAME 50
+#define RS_W_STORE_MGR 40
+#define RS_W_MARKET_MGR 40
+#define RS_W_MARKET_DESC 100
+#define STORE_MIN_TAX_PERCENTAGE "0.00"
+#define STORE_MAX_TAX_PERCENTAGE "0.11"
+
+/***
+ *** STORE_xxx Store Defines
+ ***/
+#define STORE_MIN_DAYS_OPEN 5
+#define STORE_MAX_DAYS_OPEN 500
+#define STORE_CLOSED_PCT 30
+#define STORE_MIN_REV_GROWTH "-0.05"
+#define STORE_MAX_REV_GROWTH "0.50"
+#define STORE_DESC_MIN 15
+
+#define RS_VERSION_LENGTH 100
+#define RS_CMDLINARGS_LENGTH 200
+
+#define OPT_NONE 0x00
+#define OPT_FLG 0x01 /* option is a flag; no parameter */
+#define OPT_INT 0x02 /* argument is an integer */
+#define OPT_STR 0x04 /* argument is a string */
+#define OPT_NOP 0x08 /* flags non-operational options */
+#define OPT_SUB 0x10 /* sub-option defined */
+#define OPT_ADV 0x20 /* advanced option */
+#define OPT_SET \
+  0x40 /* not changeable -- used for default/file/command precedence */
+#define OPT_DFLT 0x80 /* param set to non-zero default */
+#define OPT_MULTI 0x100 /* param may be set repeatedly */
+#define OPT_HIDE 0x200 /* hidden option -- not listed in usage */
+#define TYPE_MASK 0x07
+
+/*
+ * Flag field definitions used in tdefs[]
+ */
+#define FL_NONE 0x0000 /* this table is not defined */
+#define FL_NOP 0x0001 /* this table is not defined */
+#define FL_DATE_BASED 0x0002 /* this table is produced in date order */
+#define FL_CHILD 0x0004 /* this table is the child in a parent/child link */
+#define FL_OPEN 0x0008 /* this table has a valid output destination */
+#define FL_DUP_NAME 0x0010 /* to keep find_table() from complaining twice */
+#define FL_TYPE_2                                                          \
+  0x0020 /* this dimension keeps history -- rowcount shows unique entities \
+            (not including revisions) */
+#define FL_SMALL 0x0040 /* this table has low rowcount; used by address.c */
+#define FL_SPARSE 0x0080
+/* unused 0x0100 */
+#define FL_NO_UPDATE \
+  0x0200 /* this table is not altered by the update process */
+#define FL_SOURCE_DDL 0x0400 /* table in the souce schema */
+#define FL_JOIN_ERROR 0x0800 /* join called without an explicit rule */
+#define FL_PARENT 0x1000 /* this table has a child in nParam */
+#define FL_FACT_TABLE 0x2000
+#define FL_PASSTHRU 0x4000 /* verify routine uses warehouse without change */
+#define FL_VPRINT 0x8000 /* verify routine includes print function */
+
+#define JMS 1
+
+typedef HUGE_TYPE ds_key_t;
+
+struct DSDGenContext;
+
+typedef struct DIST_T {
+  std::vector<int32_t> type_vector;
+  std::vector<std::vector<int32_t>> weight_sets;
+  std::vector<int32_t> maximums;
+  std::vector<std::vector<int32_t>> value_sets;
+  std::vector<char> strings;
+  std::vector<char> names;
+  int size;
+} dist_t;
+
+struct DBGEN_VERSION_TBL {
+  char szVersion[RS_VERSION_LENGTH + 1];
+  char szDate[26];
+  char szTime[26];
+  char szCmdLineArgs[RS_CMDLINARGS_LENGTH + 1];
+};
+
+typedef struct D_IDX_T {
+  char name[D_NAME_LEN + 1];
+  int index;
+  int nAllocatedLength;
+  int nRemainingStrSpace;
+  int offset;
+  int str_space;
+  int name_space;
+  int length;
+  int w_width;
+  int v_width;
+  int flags;
+  dist_t dist;
+} d_idx_t;
+
+typedef struct DISTINDEX_T {
+  int nDistCount;
+  int nAllocatedCount;
+  d_idx_t* pEntries;
+} distindex_t;
+
+/*
+ * a precise decimal data type, using scaled integer
+ * arithmetic.
+ */
+typedef struct DECIMAL_T {
+  int flags;
+  int precision;
+  int scale;
+  ds_key_t number;
+} decimal_t;
+
+typedef struct OPTION_T {
+  const char* name;
+  int flags;
+  int index;
+  const char* usage;
+  int (*action)(
+      const char* szPName,
+      const char* optarg,
+      DSDGenContext& dsdGenContext);
+  std::string dflt;
+} option_t;
+
+typedef struct DS_PRICING_T {
+  decimal_t wholesale_cost;
+  decimal_t list_price;
+  decimal_t sales_price;
+  int quantity;
+  decimal_t ext_discount_amt;
+  decimal_t ext_sales_price;
+  decimal_t ext_wholesale_cost;
+  decimal_t ext_list_price;
+  decimal_t tax_pct;
+  decimal_t ext_tax;
+  decimal_t coupon_amt;
+  decimal_t ship_cost;
+  decimal_t ext_ship_cost;
+  decimal_t net_paid;
+  decimal_t net_paid_inc_tax;
+  decimal_t net_paid_inc_ship;
+  decimal_t net_paid_inc_ship_tax;
+  decimal_t net_profit;
+  decimal_t refunded_cash;
+  decimal_t reversed_charge;
+  decimal_t store_credit;
+  decimal_t fee;
+  decimal_t net_loss;
+} ds_pricing_t;
+
+typedef struct DS_ADDR_T {
+  char suite_num[RS_CC_SUITE_NUM + 1];
+  int street_num;
+  char* street_name1;
+  char* street_name2;
+  char* street_type;
+  char* city;
+  char* county;
+  char* state;
+  char country[RS_CC_COUNTRY + 1];
+  int zip;
+  int plus4;
+  int gmt_offset;
+} ds_addr_t;
+
+/*
+ * STORE_SALES table structure
+ */
+struct W_STORE_SALES_TBL {
+  ds_key_t ss_sold_date_sk;
+  ds_key_t ss_sold_time_sk;
+  ds_key_t ss_sold_item_sk;
+  ds_key_t ss_sold_customer_sk;
+  ds_key_t ss_sold_cdemo_sk;
+  ds_key_t ss_sold_hdemo_sk;
+  ds_key_t ss_sold_addr_sk;
+  ds_key_t ss_sold_store_sk;
+  ds_key_t ss_sold_promo_sk;
+  ds_key_t ss_ticket_number;
+  ds_pricing_t ss_pricing;
+};
+
+/*
+ * STORE_RETURNS table structure
+ */
+struct W_STORE_RETURNS_TBL {
+  ds_key_t sr_returned_date_sk;
+  ds_key_t sr_returned_time_sk;
+  ds_key_t sr_item_sk;
+  ds_key_t sr_customer_sk;
+  ds_key_t sr_cdemo_sk;
+  ds_key_t sr_hdemo_sk;
+  ds_key_t sr_addr_sk;
+  ds_key_t sr_store_sk;
+  ds_key_t sr_reason_sk;
+  ds_key_t sr_ticket_number;
+  ds_pricing_t sr_pricing;
+};
+
+typedef struct RNG_T {
+  int nUsed;
+  int nUsedPerRow;
+  long nSeed;
+  long nInitialSeed; /* used to allow skip_row() to back up */
+  int nColumn; /* column where this stream is used */
+  int nTable; /* table where this stream is used */
+  int nDuplicateOf; /* duplicate streams allow independent tables to share
+                       data streams */
+#ifdef JMS
+  ds_key_t nTotal;
+#endif
+} rng_t;
+
+struct W_DATE_TBL {
+  ds_key_t d_date_sk;
+  char d_date_id[RS_BKEY + 1];
+  /* this is generated at output from d_date_sk */
+  /* date_t		d_date; */
+  int d_month_seq;
+  int d_week_seq;
+  int d_quarter_seq;
+  int d_year;
+  int d_dow;
+  int d_moy;
+  int d_dom;
+  int d_qoy;
+  int d_fy_year;
+  int d_fy_quarter_seq;
+  int d_fy_week_seq;
+  const char* d_day_name;
+  /* char		d_quarter_name[RS_D_QUARTER_NAME + 1]; derived at print
+   * time */
+  int d_holiday;
+  int d_weekend;
+  int d_following_holiday;
+  int d_first_dom;
+  int d_last_dom;
+  int d_same_day_ly;
+  int d_same_day_lq;
+  int d_current_day;
+  int d_current_week;
+  int d_current_month;
+  int d_current_quarter;
+  int d_current_year;
+};
+
+/*
+ * STORE table structure
+ */
+struct W_STORE_TBL {
+  ds_key_t store_sk;
+  char store_id[RS_BKEY + 1];
+  ds_key_t rec_start_date_id;
+  ds_key_t rec_end_date_id;
+  ds_key_t closed_date_id;
+  char store_name[RS_W_STORE_NAME + 1];
+  int employees;
+  int floor_space;
+  char* hours;
+  char store_manager[RS_W_STORE_MGR + 1];
+  int market_id;
+  decimal_t dTaxPercentage;
+  char* geography_class;
+  char market_desc[RS_W_MARKET_DESC + 1];
+  char market_manager[RS_W_MARKET_MGR + 1];
+  ds_key_t division_id;
+  char* division_name;
+  ds_key_t company_id;
+  char* company_name;
+  ds_addr_t address;
+};
+
+/*
+ * CALL_CENTER table structure
+ */
+struct CALL_CENTER_TBL {
+  ds_key_t cc_call_center_sk;
+  char cc_call_center_id[RS_BKEY + 1];
+  ds_key_t cc_rec_start_date_id;
+  ds_key_t cc_rec_end_date_id;
+  ds_key_t cc_closed_date_id;
+  ds_key_t cc_open_date_id;
+  char cc_name[RS_CC_NAME + 1];
+  char* cc_class;
+  int cc_employees;
+  int cc_sq_ft;
+  char* cc_hours;
+  char cc_manager[RS_CC_MANAGER + 1];
+  int cc_market_id;
+  char cc_market_class[RS_CC_MARKET_CLASS + 1];
+  char cc_market_desc[RS_CC_MARKET_DESC + 1];
+  char cc_market_manager[RS_CC_MARKET_MANAGER + 1];
+  int cc_division_id;
+  char cc_division_name[RS_CC_DIVISION_NAME + 1];
+  int cc_company;
+  char cc_company_name[RS_CC_COMPANY_NAME + 1];
+  ds_addr_t cc_address;
+  decimal_t cc_tax_percentage;
+};
+
+struct SCALING_T {
+  ds_key_t kBaseRowcount;
+  ds_key_t kNextInsertValue;
+  int nUpdatePercentage;
+  ds_key_t kDayRowcount[6];
+};
+
+/*
+ * CATALOG_PAGE table structure
+ */
+struct CATALOG_PAGE_TBL {
+  ds_key_t cp_catalog_page_sk;
+  char cp_catalog_page_id[RS_BKEY + 1];
+  ds_key_t cp_start_date_id;
+  ds_key_t cp_end_date_id;
+  char cp_department[RS_CP_DEPARTMENT + 1];
+  int cp_catalog_number;
+  int cp_catalog_page_number;
+  char cp_description[RS_CP_DESCRIPTION + 1];
+  char* cp_type;
+};
+
+/*
+ * CATALOG_RETURNS table structure
+ */
+struct W_CATALOG_RETURNS_TBL {
+  ds_key_t cr_returned_date_sk;
+  ds_key_t cr_returned_time_sk;
+  ds_key_t cr_item_sk;
+  ds_key_t cr_refunded_customer_sk;
+  ds_key_t cr_refunded_cdemo_sk;
+  ds_key_t cr_refunded_hdemo_sk;
+  ds_key_t cr_refunded_addr_sk;
+  ds_key_t cr_returning_customer_sk;
+  ds_key_t cr_returning_cdemo_sk;
+  ds_key_t cr_returning_hdemo_sk;
+  ds_key_t cr_returning_addr_sk;
+  ds_key_t cr_call_center_sk;
+  ds_key_t cr_catalog_page_sk;
+  ds_key_t cr_ship_mode_sk;
+  ds_key_t cr_warehouse_sk;
+  ds_key_t cr_reason_sk;
+  ds_key_t cr_order_number;
+  ds_pricing_t cr_pricing;
+  decimal_t cr_fee;
+  decimal_t cr_refunded_cash;
+  decimal_t cr_reversed_charge;
+  decimal_t cr_store_credit;
+  decimal_t cr_net_loss;
+};
+
+/*
+ * CATALOG_SALES table structure
+ */
+struct W_CATALOG_SALES_TBL {
+  ds_key_t cs_sold_date_sk;
+  ds_key_t cs_sold_time_sk;
+  ds_key_t cs_ship_date_sk;
+  ds_key_t cs_bill_customer_sk;
+  ds_key_t cs_bill_cdemo_sk;
+  ds_key_t cs_bill_hdemo_sk;
+  ds_key_t cs_bill_addr_sk;
+  ds_key_t cs_ship_customer_sk;
+  ds_key_t cs_ship_cdemo_sk;
+  ds_key_t cs_ship_hdemo_sk;
+  ds_key_t cs_ship_addr_sk;
+  ds_key_t cs_call_center_sk;
+  ds_key_t cs_catalog_page_sk;
+  ds_key_t cs_ship_mode_sk;
+  ds_key_t cs_warehouse_sk;
+  ds_key_t cs_sold_item_sk;
+  ds_key_t cs_promo_sk;
+  ds_key_t cs_order_number;
+  ds_pricing_t cs_pricing;
+};
+
+/*
+ * CUSTOMER table structure
+ */
+struct W_CUSTOMER_TBL {
+  ds_key_t c_customer_sk;
+  char c_customer_id[RS_BKEY + 1];
+  ds_key_t c_current_cdemo_sk;
+  ds_key_t c_current_hdemo_sk;
+  ds_key_t c_current_addr_sk;
+  int c_first_shipto_date_id;
+  int c_first_sales_date_id;
+  char* c_salutation;
+  char* c_first_name;
+  char* c_last_name;
+  int c_preferred_cust_flag;
+  int c_birth_day;
+  int c_birth_month;
+  int c_birth_year;
+  char* c_birth_country;
+  char c_login[RS_C_LOGIN + 1] = {};
+  char c_email_address[RS_C_EMAIL + 1];
+  int c_last_review_date;
+};
+
+/*
+ * CUSTOMER_ADDRESS table structure
+ */
+struct W_CUSTOMER_ADDRESS_TBL {
+  ds_key_t ca_addr_sk;
+  char ca_addr_id[RS_BKEY + 1];
+  ds_addr_t ca_address;
+  char* ca_location_type;
+};
+
+/*
+ * CUSTOMER_DEMOGRAPHICS table structure
+ */
+struct W_CUSTOMER_DEMOGRAPHICS_TBL {
+  ds_key_t cd_demo_sk;
+  char* cd_gender;
+  char* cd_marital_status;
+  char* cd_education_status;
+  int cd_purchase_estimate;
+  char* cd_credit_rating;
+  int cd_dep_count;
+  int cd_dep_employed_count;
+  int cd_dep_college_count;
+};
+
+/*
+ * INVENTORY table structure
+ */
+struct W_INVENTORY_TBL {
+  ds_key_t inv_date_sk;
+  ds_key_t inv_item_sk;
+  ds_key_t inv_warehouse_sk;
+  int inv_quantity_on_hand;
+};
+
+/*
+ * TIME_DIM table structure
+ */
+struct W_TIME_TBL {
+  ds_key_t t_time_sk;
+  char t_time_id[RS_BKEY + 1];
+  int t_time;
+  int t_hour;
+  int t_minute;
+  int t_second;
+  char* t_am_pm;
+  char* t_shift;
+  char* t_sub_shift;
+  char* t_meal_time;
+};
+
+/*
+ * INCOME_BAND table structure
+ */
+struct W_INCOME_BAND_TBL {
+  int ib_income_band_id;
+  int ib_lower_bound;
+  int ib_upper_bound;
+};
+
+/*
+ * HOUSEHOLD_DEMOGRAPHICS table structure
+ */
+struct W_HOUSEHOLD_DEMOGRAPHICS_TBL {
+  ds_key_t hd_demo_sk;
+  ds_key_t hd_income_band_id;
+  char* hd_buy_potential;
+  int hd_dep_count;
+  int hd_vehicle_count;
+};
+
+/*
+ * SHIP_MODE table structure
+ */
+struct W_SHIP_MODE_TBL {
+  ds_key_t sm_ship_mode_sk;
+  char sm_ship_mode_id[RS_BKEY + 1];
+  char* sm_type;
+  char* sm_code;
+  char* sm_carrier;
+  char sm_contract[RS_SM_CONTRACT + 1];
+};
+
+/*
+ * PROMOTION table structure
+ */
+struct W_PROMOTION_TBL {
+  ds_key_t p_promo_sk;
+  char p_promo_id[RS_BKEY + 1];
+  ds_key_t p_start_date_id;
+  ds_key_t p_end_date_id;
+  ds_key_t p_item_sk;
+  decimal_t p_cost;
+  int p_response_target;
+  char p_promo_name[RS_P_PROMO_NAME + 1];
+  int p_channel_dmail;
+  int p_channel_email;
+  int p_channel_catalog;
+  int p_channel_tv;
+  int p_channel_radio;
+  int p_channel_press;
+  int p_channel_event;
+  int p_channel_demo;
+  char p_channel_details[RS_P_CHANNEL_DETAILS + 1];
+  char* p_purpose;
+  int p_discount_active;
+};
+
+/*
+ * REASON table structure
+ */
+struct W_REASON_TBL {
+  ds_key_t r_reason_sk;
+  char r_reason_id[RS_BKEY + 1];
+  char* r_reason_description;
+};
+
+/*
+ * WAREHOUSE table structure
+ */
+struct W_WAREHOUSE_TBL {
+  ds_key_t w_warehouse_sk;
+  char w_warehouse_id[RS_BKEY + 1];
+  char w_warehouse_name[RS_W_WAREHOUSE_NAME + 1];
+  int w_warehouse_sq_ft;
+  ds_addr_t w_address;
+};
+
+/*
+ * WEB_SALES table structure
+ */
+struct W_WEB_SALES_TBL {
+  ds_key_t ws_sold_date_sk;
+  ds_key_t ws_sold_time_sk;
+  ds_key_t ws_ship_date_sk;
+  ds_key_t ws_item_sk;
+  ds_key_t ws_bill_customer_sk;
+  ds_key_t ws_bill_cdemo_sk;
+  ds_key_t ws_bill_hdemo_sk;
+  ds_key_t ws_bill_addr_sk;
+  ds_key_t ws_ship_customer_sk;
+  ds_key_t ws_ship_cdemo_sk;
+  ds_key_t ws_ship_hdemo_sk;
+  ds_key_t ws_ship_addr_sk;
+  ds_key_t ws_web_page_sk;
+  ds_key_t ws_web_site_sk;
+  ds_key_t ws_ship_mode_sk;
+  ds_key_t ws_warehouse_sk;
+  ds_key_t ws_promo_sk;
+  ds_key_t ws_order_number;
+  ds_pricing_t ws_pricing;
+};
+
+/*
+ * WEB_RETURNS table structure
+ */
+struct W_WEB_RETURNS_TBL {
+  ds_key_t wr_returned_date_sk;
+  ds_key_t wr_returned_time_sk;
+  ds_key_t wr_item_sk;
+  ds_key_t wr_refunded_customer_sk;
+  ds_key_t wr_refunded_cdemo_sk;
+  ds_key_t wr_refunded_hdemo_sk;
+  ds_key_t wr_refunded_addr_sk;
+  ds_key_t wr_returning_customer_sk;
+  ds_key_t wr_returning_cdemo_sk;
+  ds_key_t wr_returning_hdemo_sk;
+  ds_key_t wr_returning_addr_sk;
+  ds_key_t wr_web_page_sk;
+  ds_key_t wr_reason_sk;
+  ds_key_t wr_order_number;
+  ds_pricing_t wr_pricing;
+};
+
+/*
+ * WEB_PAGE table structure
+ */
+struct W_WEB_PAGE_TBL {
+  ds_key_t wp_page_sk;
+  char wp_page_id[RS_BKEY + 1];
+  char wp_site_id[RS_BKEY + 1];
+  ds_key_t wp_rec_start_date_id;
+  ds_key_t wp_rec_end_date_id;
+  ds_key_t wp_creation_date_sk;
+  ds_key_t wp_access_date_sk;
+  int wp_autogen_flag;
+  ds_key_t wp_customer_sk;
+  char wp_url[RS_WP_URL + 1];
+  char* wp_type;
+  int wp_char_count;
+  int wp_link_count;
+  int wp_image_count;
+  int wp_max_ad_count;
+};
+
+/*
+ * ITEM table structure
+ */
+struct W_ITEM_TBL {
+  ds_key_t i_item_sk;
+  char i_item_id[RS_BKEY + 1];
+  ds_key_t i_rec_start_date_id;
+  ds_key_t i_rec_end_date_id;
+  char i_item_desc[RS_I_ITEM_DESC + 1];
+  decimal_t i_current_price; /* list price */
+  decimal_t i_wholesale_cost;
+  ds_key_t i_brand_id;
+  char i_brand[RS_I_BRAND + 1];
+  ds_key_t i_class_id;
+  char* i_class;
+  ds_key_t i_category_id;
+  char* i_category;
+  ds_key_t i_manufact_id;
+  char i_manufact[RS_I_MANUFACT + 1];
+  char* i_size;
+  char i_formulation[RS_I_FORMULATION + 1];
+  char* i_color;
+  char* i_units;
+  char* i_container;
+  ds_key_t i_manager_id;
+  char i_product_name[RS_I_PRODUCT_NAME + 1];
+  ds_key_t i_promo_sk;
+};
+
+/*
+ * WEB_SITE table structure
+ */
+struct W_WEB_SITE_TBL {
+  ds_key_t web_site_sk;
+  char web_site_id[RS_BKEY + 1];
+  ds_key_t web_rec_start_date_id;
+  ds_key_t web_rec_end_date_id;
+  char web_name[RS_WEB_NAME + 1];
+  ds_key_t web_open_date;
+  ds_key_t web_close_date;
+  char web_class[RS_WEB_CLASS + 1];
+  char web_manager[RS_WEB_MANAGER + 1];
+  int web_market_id;
+  char web_market_class[RS_WEB_MARKET_CLASS + 1];
+  char web_market_desc[RS_WEB_MARKET_DESC + 1];
+  char web_market_manager[RS_WEB_MARKET_MANAGER + 1];
+  int web_company_id;
+  char web_company_name[RS_WEB_COMPANY_NAME + 1];
+  ds_addr_t web_address;
+  decimal_t web_tax_percentage;
+};
+
+/*
+ * general table descriptions.
+ * NOTE: This table contains the constant elements in the table descriptions; it
+ * must be kept in sync with the declararions of assocaited functions, found in
+ * tdef_functions.h
+ */
+
+typedef struct TDEF_T {
+  const char* name = nullptr; /* -- name of the table; */
+  const char* abreviation = nullptr; /* -- shorthand name of the table */
+  unsigned int flags = 0; /* -- control table options */
+  int nFirstColumn = 0; /* -- first column/RNG for this table */
+  int nLastColumn = 0; /* -- last column/RNG for this table */
+  int nTableIndex = 0; /* used for rowcount calculations */
+  int nParam = 0; /* -- additional table param (revision count, child number,
+                 etc.) */
+  FILE* outfile = nullptr; /* -- output destination */
+  int nUpdateSize = 0; /* -- percentage of base rowcount in each update set
+                      (basis points) */
+  int nNewRowPct = 0;
+  int nNullPct = 0; /* percentage of rows with nulls (basis points) */
+  ds_key_t kNullBitMap = 0; /* colums that should be NULL in the current row */
+  ds_key_t kNotNullBitMap = 0; /* columns that are defined NOT NULL */
+  std::vector<ds_key_t> arSparseKeys =
+      {}; /* sparse key set for table; used if FL_SPARSE is set */
+} tdef;
+
+int read_file(
+    const char* param_name,
+    const char* arg,
+    DSDGenContext& dsdGenContext);
+int usage(
+    const char* param_name,
+    const char* msg,
+    DSDGenContext& dsdGenContext);
+int SetScaleIndex(
+    const char* szName,
+    const char* szValue,
+    DSDGenContext& dsdGenContext);
+int printReleaseInfo(
+    const char* param,
+    const char* val,
+    DSDGenContext& dsdGenContext);
+static void print_options(
+    struct OPTION_T* o,
+    int bShowOptional,
+    DSDGenContext& dsdGenContext);
+
+static folly::Synchronized<std::unordered_map<std::string, d_idx_t>> idx_;
+static std::once_flag initFlag_;
+
+// DSDGenContext to access global variables.
+struct DSDGenContext {
+  DSDGenContext() : params(23 + 2) {}
+
+  struct DBGEN_VERSION_TBL g_dbgen_version;
+
+  struct W_STORE_SALES_TBL g_w_store_sales;
+  int *pStoreSalesItemPermutation, *pCatalogSalesItemPermutation,
+      *pWebSalesItemPermutation;
+  int nStoreSalesItemCount, nCatalogSalesItemCount, nWebSalesItemCount;
+  int nStoreSalesItemIndex, nCatalogSalesItemIndex, nWebSalesItemIndex;
+  ds_key_t jDate, kNewDateIndex;
+  int nTicketItemBase = 1;
+
+  struct W_STORE_RETURNS_TBL g_w_store_returns;
+  struct DIST_T dist;
+  option_t options[26] = {
+      {"ABREVIATION", OPT_STR, 0, "build table with abreviation <s>", NULL, ""},
+      {"DELIMITER",
+       OPT_STR | OPT_ADV,
+       1,
+       "use <s> as output field separator",
+       NULL,
+       "|"},
+      {"DIR", OPT_STR, 2, "generate tables in directory <s>", NULL, "."},
+      {"DISTRIBUTIONS",
+       OPT_STR | OPT_ADV,
+       3,
+       "read distributions from file <s>",
+       NULL,
+       "NONE"},
+      {"FORCE",
+       OPT_FLG | OPT_ADV,
+       4,
+       "over-write data files without prompting",
+       NULL,
+       "N"},
+      {"HELP", OPT_INT, 5, "display this message", usage, "0"},
+      {"PARAMS", OPT_STR, 6, "read parameters from file <s>", read_file, ""},
+      {"PROG",
+       OPT_STR | OPT_HIDE | OPT_SET,
+       7,
+       "DO NOT MODIFY",
+       NULL,
+       "dsdgen"},
+      {"QUIET", OPT_FLG, 8, "disable all output to stdout/stderr", NULL, "N"},
+      {"SCALE",
+       OPT_STR,
+       9,
+       "volume of data to generate in GB",
+       SetScaleIndex,
+       "1"},
+      {"SUFFIX",
+       OPT_STR | OPT_ADV,
+       10,
+       "use <s> as output file suffix",
+       NULL,
+       ".dat"},
+      {"TABLE", OPT_STR, 11, "build only table <s>", NULL, "ALL"},
+      {"TERMINATE",
+       OPT_FLG | OPT_ADV,
+       12,
+       "end each record with a field delimiter",
+       NULL,
+       "Y"},
+      {"UPDATE", OPT_INT, 13, "generate update data set <n>", NULL, ""},
+      {"VERBOSE", OPT_FLG, 14, "enable verbose output", NULL, "N"},
+      {"_SCALE_INDEX",
+       OPT_INT | OPT_HIDE,
+       15,
+       "Scale band; used for dist lookups",
+       NULL,
+       "1"},
+      {"PARALLEL", OPT_INT, 16, "build data in <n> separate chunks", NULL, ""},
+      {"CHILD",
+       OPT_INT,
+       17,
+       "generate <n>th chunk of the parallelized data",
+       NULL,
+       "1"},
+      {"CHKSEEDS",
+       OPT_FLG | OPT_HIDE,
+       18,
+       "validate RNG usage for parallelism",
+       NULL,
+       "N"},
+      {"RELEASE",
+       OPT_FLG,
+       19,
+       "display the release information",
+       printReleaseInfo,
+       "N"},
+      {"_FILTER", OPT_FLG, 20, "output data to stdout", NULL, "N"},
+      {"VALIDATE", OPT_FLG, 21, "produce rows for data validation", NULL, "N"},
+      {"VCOUNT",
+       OPT_INT | OPT_ADV,
+       22,
+       "set number of validation rows to be produced",
+       NULL,
+       "50"},
+      {"VSUFFIX",
+       OPT_STR | OPT_ADV,
+       23,
+       "set file suffix for data validation",
+       NULL,
+       ".vld"},
+      {"RNGSEED", OPT_INT | OPT_ADV, 24, "set RNG seed", NULL, "19620718"}};
+
+  std::vector<std::vector<char>> params;
+
+  struct W_DATE_TBL g_w_date;
+
+  struct W_STORE_TBL g_w_store;
+
+  struct CALL_CENTER_TBL g_w_call_center;
+
+  struct W_WEB_PAGE_TBL g_w_web_page;
+
+  struct W_ITEM_TBL g_w_item;
+
+  struct W_WEB_SITE_TBL g_w_web_site;
+
+  struct CATALOG_PAGE_TBL g_w_catalog_page;
+
+  struct W_CATALOG_RETURNS_TBL g_w_catalog_returns;
+
+  struct W_CATALOG_SALES_TBL g_w_catalog_sales;
+
+  struct W_CUSTOMER_TBL g_w_customer;
+
+  struct W_CUSTOMER_ADDRESS_TBL g_w_customer_address;
+
+  struct W_CUSTOMER_DEMOGRAPHICS_TBL g_w_customer_demographics;
+
+  struct W_INVENTORY_TBL g_w_inventory;
+
+  struct W_TIME_TBL g_w_time;
+
+  struct W_INCOME_BAND_TBL g_w_income_band;
+
+  struct W_HOUSEHOLD_DEMOGRAPHICS_TBL g_w_household_demographics;
+
+  struct W_SHIP_MODE_TBL g_w_ship_mode;
+
+  struct W_PROMOTION_TBL g_w_promotion;
+
+  struct W_REASON_TBL g_w_reason;
+
+  struct W_WAREHOUSE_TBL g_w_warehouse;
+
+  struct W_WEB_SALES_TBL g_w_web_sales;
+
+  struct W_WEB_RETURNS_TBL g_w_web_returns;
+
+  SCALING_T arRowcount[MAX_TABLE + 1];
+
+  int arUpdateDates[6];
+  int arInventoryUpdateDates[6];
+
+  int arScaleVolume[9] = {1, 10, 100, 300, 1000, 3000, 10000, 30000, 100000};
+
+  int init_rand_init;
+  int mk_address_init;
+  int setUpdateDateRange_init;
+  int mk_dbgen_version_init;
+  int getCatalogNumberFromPage_init;
+  int checkSeeds_init;
+  int dateScaling_init;
+  int mk_w_call_center_init;
+  int mk_w_catalog_page_init;
+  int mk_master_catalog_sales_init;
+  int dectostr_init;
+  int date_join_init;
+  int setSCDKeys_init;
+  int scd_join_init;
+  int matchSCDSK_init;
+  int skipDays_init;
+  int mk_w_catalog_returns_init;
+  int mk_detail_catalog_sales_init;
+  int mk_w_customer_init;
+  int mk_w_date_init;
+  int mk_w_inventory_init;
+  int mk_w_item_init;
+  int mk_w_promotion_init;
+  int mk_w_reason_init;
+  int mk_w_ship_mode_init;
+  int mk_w_store_returns_init;
+  int mk_master_store_sales_init;
+  int mk_master_web_sales_init;
+  int mk_detail_web_sales_init;
+  int mk_w_store_init;
+  int mk_w_web_page_init;
+  int mk_w_web_returns_init;
+  int mk_master_init;
+  int mk_detail_init;
+  int mk_w_web_site_init;
+  int mk_cust_init;
+  int mk_order_init;
+  int mk_part_init;
+  int mk_supp_init;
+  int dbg_text_init;
+  int find_dist_init;
+  int cp_join_init;
+  int web_join_init;
+  int set_pricing_init;
+  int init_params_init;
+  int get_rowcount_init;
+
+  tdef s_tdefs[38] = {
+      {"s_brand",
+       "s_br",
+       FL_NOP | FL_SOURCE_DDL,
+       S_BRAND_START,
+       S_BRAND_END,
+       S_BRAND,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_customer_address",
+       "s_ca",
+       FL_SOURCE_DDL | FL_PASSTHRU,
+       S_CUSTOMER_ADDRESS_START,
+       S_CUSTOMER_ADDRESS_END,
+       S_CUSTOMER_ADDRESS,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_call_center",
+       "s_cc",
+       FL_SOURCE_DDL,
+       S_CALL_CENTER_START,
+       S_CALL_CENTER_END,
+       S_CALL_CENTER,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x02,
+       {}},
+      {"s_catalog",
+       "s_ct",
+       FL_SOURCE_DDL | FL_NOP,
+       S_CATALOG_START,
+       S_CATALOG_END,
+       S_CATALOG,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_catalog_order",
+       "s_cord",
+       FL_SOURCE_DDL | FL_PARENT | FL_DATE_BASED,
+       S_CATALOG_ORDER_START,
+       S_CATALOG_ORDER_END,
+       S_CATALOG_ORDER,
+       S_CATALOG_ORDER_LINEITEM,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_catalog_order_lineitem",
+       "s_cl",
+       FL_SOURCE_DDL | FL_CHILD | FL_PARENT,
+       S_CATALOG_ORDER_LINEITEM_START,
+       S_CATALOG_ORDER_LINEITEM_END,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CATALOG_RETURNS,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x07,
+       {}},
+      {"s_catalog_page",
+       "s_cp",
+       FL_SOURCE_DDL | FL_PASSTHRU,
+       S_CATALOG_PAGE_START,
+       S_CATALOG_PAGE_END,
+       S_CATALOG_PAGE,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x033,
+       {}},
+      {"s_catalog_promotional_item",
+       "s_ci",
+       FL_NOP | FL_SOURCE_DDL,
+       S_CATALOG_PROMOTIONAL_ITEM_START,
+       S_CATALOG_PROMOTIONAL_ITEM_END,
+       S_CATALOG_PROMOTIONAL_ITEM,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_catalog_returns",
+       "s_cr",
+       FL_SOURCE_DDL | FL_CHILD,
+       S_CATALOG_RETURNS_START,
+       S_CATALOG_RETURNS_END,
+       S_CATALOG_RETURNS,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0E,
+       {}},
+      {"s_category",
+       "s_cg",
+       FL_NOP | FL_SOURCE_DDL,
+       S_CATEGORY_START,
+       S_CATEGORY_END,
+       S_CATEGORY,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_class",
+       "s_cl",
+       FL_NOP | FL_SOURCE_DDL,
+       S_CLASS_START,
+       S_CLASS_END,
+       S_CLASS,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_company",
+       "s_co",
+       FL_NOP | FL_SOURCE_DDL,
+       S_COMPANY_START,
+       S_COMPANY_END,
+       S_COMPANY,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_customer",
+       "s_cu",
+       FL_SOURCE_DDL,
+       S_CUSTOMER_START,
+       S_CUSTOMER_END,
+       S_CUSTOMER,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_division",
+       "s_di",
+       FL_NOP | FL_SOURCE_DDL,
+       S_DIVISION_START,
+       S_DIVISION_END,
+       S_DIVISION,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_inventory",
+       "s_in",
+       FL_SOURCE_DDL | FL_DATE_BASED,
+       S_INVENTORY_START,
+       S_INVENTORY_END,
+       S_INVENTORY,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x07,
+       {}},
+      {"s_item",
+       "s_it",
+       FL_SOURCE_DDL,
+       S_ITEM_START,
+       S_ITEM_END,
+       S_ITEM,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_manager",
+       "s_mg",
+       FL_NOP | FL_SOURCE_DDL,
+       S_MANAGER_START,
+       S_MANAGER_END,
+       S_MANAGER,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_manufacturer",
+       "s_mn",
+       FL_NOP | FL_SOURCE_DDL,
+       S_MANUFACTURER_START,
+       S_MANUFACTURER_END,
+       S_MANUFACTURER,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_market",
+       "s_mk",
+       FL_NOP | FL_SOURCE_DDL,
+       S_MARKET_START,
+       S_MARKET_END,
+       S_MARKET,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_product",
+       "s_pr",
+       FL_NOP | FL_SOURCE_DDL,
+       S_PRODUCT_START,
+       S_PRODUCT_END,
+       S_PRODUCT,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_promotion",
+       "s_pm",
+       FL_SOURCE_DDL | FL_PASSTHRU,
+       S_PROMOTION_START,
+       S_PROMOTION_END,
+       S_PROMOTION,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_purchase",
+       "s_pu",
+       FL_SOURCE_DDL | FL_PARENT | FL_DATE_BASED,
+       S_PURCHASE_START,
+       S_PURCHASE_END,
+       S_PURCHASE,
+       S_PURCHASE_LINEITEM,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_purchase_lineitem",
+       "s_pl",
+       FL_SOURCE_DDL | FL_CHILD | FL_PARENT,
+       S_PURCHASE_LINEITEM_START,
+       S_PURCHASE_LINEITEM_END,
+       S_PURCHASE_LINEITEM,
+       S_STORE_RETURNS,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x07,
+       {}},
+      {"s_reason",
+       "s_re",
+       FL_NOP | FL_SOURCE_DDL,
+       S_REASON_START,
+       S_REASON_END,
+       S_REASON,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_store",
+       "s_st",
+       FL_SOURCE_DDL,
+       S_STORE_START,
+       S_STORE_END,
+       S_STORE,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_store_promotional_item",
+       "s_sp",
+       FL_NOP | FL_SOURCE_DDL,
+       S_STORE_PROMOTIONAL_ITEM_START,
+       S_STORE_PROMOTIONAL_ITEM_END,
+       S_STORE_PROMOTIONAL_ITEM,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_store_returns",
+       "s_sr",
+       FL_SOURCE_DDL | FL_CHILD,
+       S_STORE_RETURNS_START,
+       S_STORE_RETURNS_END,
+       S_STORE_RETURNS,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0E,
+       {}},
+      {"s_subcategory",
+       "s_ct",
+       FL_NOP | FL_SOURCE_DDL,
+       S_SUBCATEGORY_START,
+       S_SUBCATEGORY_END,
+       S_SUBCATEGORY,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_subclass",
+       "s_sc",
+       FL_NOP | FL_SOURCE_DDL,
+       S_SUBCLASS_START,
+       S_SUBCLASS_END,
+       S_SUBCLASS,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_warehouse",
+       "s_.h",
+       FL_SOURCE_DDL,
+       S_WAREHOUSE_START,
+       S_WAREHOUSE_END,
+       S_WAREHOUSE,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_web_order",
+       "s_wo",
+       FL_SOURCE_DDL | FL_PARENT | FL_DATE_BASED,
+       S_WEB_ORDER_START,
+       S_WEB_ORDER_END,
+       S_WEB_ORDER,
+       S_WEB_ORDER_LINEITEM,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_web_order_lineitem",
+       "s_wl",
+       FL_SOURCE_DDL | FL_CHILD | FL_PARENT,
+       S_WEB_ORDER_LINEITEM_START,
+       S_WEB_ORDER_LINEITEM_END,
+       S_WEB_ORDER_LINEITEM,
+       S_WEB_RETURNS,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x07,
+       {}},
+      {"s_web_page",
+       "s_wp",
+       FL_SOURCE_DDL | FL_PASSTHRU,
+       S_WEB_PAGE_START,
+       S_WEB_PAGE_END,
+       S_WEB_PAGE,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_web_promotional_item",
+       "s_wi",
+       FL_NOP | FL_SOURCE_DDL,
+       S_WEB_PROMOTIONAL_ITEM_START,
+       S_WEB_PROMOTIONAL_ITEM_END,
+       S_WEB_PROMOTIONAL_ITEM,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0,
+       {}},
+      {"s_web_returns",
+       "s_wr",
+       FL_SOURCE_DDL | FL_CHILD,
+       S_WEB_RETURNS_START,
+       S_WEB_RETURNS_END,
+       S_WEB_RETURNS,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x0E,
+       {}},
+      {"s_web_site",
+       "s_ws",
+       FL_SOURCE_DDL,
+       S_WEB_SITE_START,
+       S_WEB_SITE_END,
+       S_WEB_SITE,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x01,
+       {}},
+      {"s_zip_to_gmt",
+       "s_zi",
+       FL_SOURCE_DDL | FL_VPRINT,
+       S_ZIPG_START,
+       S_ZIPG_END,
+       S_ZIPG,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0x0,
+       0x03,
+       {}},
+      {NULL}};
+
+  tdef w_tdefs[26] = {
+      {"call_center",
+       "cc",
+       FL_TYPE_2 | FL_SMALL,
+       CALL_CENTER_START,
+       CALL_CENTER_END,
+       CALL_CENTER,
+       -1,
+       NULL,
+       0,
+       0,
+       100,
+       0,
+       0x0B,
+       {}},
+      {"catalog_page",
+       "cp",
+       0,
+       CATALOG_PAGE_START,
+       CATALOG_PAGE_END,
+       CATALOG_PAGE,
+       -1,
+       NULL,
+       0,
+       0,
+       200,
+       0,
+       0x03,
+       {}},
+      {"catalog_returns",
+       "cr",
+       FL_CHILD,
+       CATALOG_RETURNS_START,
+       CATALOG_RETURNS_END,
+       CATALOG_RETURNS,
+       -1,
+       NULL,
+       0,
+       0,
+       400,
+       0,
+       0x10007,
+       {}},
+      {"catalog_sales",
+       "cs",
+       FL_PARENT | FL_DATE_BASED | FL_VPRINT,
+       CATALOG_SALES_START,
+       CATALOG_SALES_END,
+       CATALOG_SALES,
+       CATALOG_RETURNS,
+       NULL,
+       0,
+       0,
+       100,
+       0,
+       0x28000,
+       {}},
+      {"customer",
+       "cu",
+       0,
+       CUSTOMER_START,
+       CUSTOMER_END,
+       CUSTOMER,
+       -1,
+       NULL,
+       0,
+       0,
+       700,
+       0,
+       0x13,
+       {}},
+      {"customer_address",
+       "ca",
+       0,
+       CUSTOMER_ADDRESS_START,
+       CUSTOMER_ADDRESS_END,
+       CUSTOMER_ADDRESS,
+       -1,
+       NULL,
+       0,
+       0,
+       600,
+       0,
+       0x03,
+       {}},
+      {"customer_demographics",
+       "cd",
+       0,
+       CUSTOMER_DEMOGRAPHICS_START,
+       CUSTOMER_DEMOGRAPHICS_END,
+       CUSTOMER_DEMOGRAPHICS,
+       823200,
+       NULL,
+       0,
+       0,
+       0,
+       0,
+       0x1,
+       {}},
+      {"date_dim",
+       "da",
+       0,
+       DATE_START,
+       DATE_END,
+       DATET,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0,
+       0x03,
+       {}},
+      {"household_demographics",
+       "hd",
+       0,
+       HOUSEHOLD_DEMOGRAPHICS_START,
+       HOUSEHOLD_DEMOGRAPHICS_END,
+       HOUSEHOLD_DEMOGRAPHICS,
+       7200,
+       NULL,
+       0,
+       0,
+       0,
+       0,
+       0x01,
+       {}},
+      {"income_band",
+       "ib",
+       0,
+       INCOME_BAND_START,
+       INCOME_BAND_END,
+       INCOME_BAND,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0,
+       0x1,
+       {}},
+      {"inventory",
+       "inv",
+       FL_DATE_BASED,
+       INVENTORY_START,
+       INVENTORY_END,
+       INVENTORY,
+       -1,
+       NULL,
+       0,
+       0,
+       1000,
+       0,
+       0x07,
+       {}},
+      {"item",
+       "it",
+       FL_TYPE_2,
+       ITEM_START,
+       ITEM_END,
+       ITEM,
+       -1,
+       NULL,
+       0,
+       0,
+       50,
+       0,
+       0x0B,
+       {}},
+      {"promotion",
+       "pr",
+       0,
+       PROMOTION_START,
+       PROMOTION_END,
+       PROMOTION,
+       -1,
+       NULL,
+       0,
+       0,
+       200,
+       0,
+       0x03,
+       {}},
+      {"reason",
+       "re",
+       0,
+       REASON_START,
+       REASON_END,
+       REASON,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0,
+       0x03,
+       {}},
+      {"ship_mode",
+       "sm",
+       0,
+       SHIP_MODE_START,
+       SHIP_MODE_END,
+       SHIP_MODE,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0,
+       0x03,
+       {}},
+      {"store",
+       "st",
+       FL_TYPE_2 | FL_SMALL,
+       STORE_START,
+       STORE_END,
+       STORE,
+       -1,
+       NULL,
+       0,
+       0,
+       100,
+       0,
+       0xB,
+       {}},
+      {"store_returns",
+       "sr",
+       FL_CHILD,
+       STORE_RETURNS_START,
+       STORE_RETURNS_END,
+       STORE_RETURNS,
+       -1,
+       NULL,
+       0,
+       0,
+       700,
+       0,
+       0x204,
+       {}},
+      {"store_sales",
+       "ss",
+       FL_PARENT | FL_DATE_BASED | FL_VPRINT,
+       STORE_SALES_START,
+       STORE_SALES_END,
+       STORE_SALES,
+       STORE_RETURNS,
+       NULL,
+       0,
+       0,
+       900,
+       0,
+       0x204,
+       {}},
+      {"time_dim",
+       "ti",
+       0,
+       TIME_START,
+       TIME_END,
+       TIMET,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0,
+       0x03,
+       {}},
+      {"warehouse",
+       "wa",
+       FL_SMALL,
+       WAREHOUSE_START,
+       WAREHOUSE_END,
+       WAREHOUSE,
+       -1,
+       NULL,
+       0,
+       0,
+       200,
+       0,
+       0x03,
+       {}},
+      {"web_page",
+       "wp",
+       FL_TYPE_2,
+       WEB_PAGE_START,
+       WEB_PAGE_END,
+       WEB_PAGE,
+       -1,
+       NULL,
+       0,
+       0,
+       250,
+       0,
+       0x0B,
+       {}},
+      {"web_returns",
+       "wr",
+       FL_CHILD,
+       WEB_RETURNS_START,
+       WEB_RETURNS_END,
+       WEB_RETURNS,
+       -1,
+       NULL,
+       0,
+       0,
+       900,
+       0,
+       0x2004,
+       {}},
+      {"web_sales",
+       "ws",
+       FL_VPRINT | FL_PARENT | FL_DATE_BASED,
+       WEB_SALES_START,
+       WEB_SALES_END,
+       WEB_SALES,
+       WEB_RETURNS,
+       NULL,
+       0,
+       0,
+       5,
+       1100,
+       0x20008,
+       {}},
+      {"web_site",
+       "web",
+       FL_TYPE_2 | FL_SMALL,
+       WEB_SITE_START,
+       WEB_SITE_END,
+       WEB_SITE,
+       -1,
+       NULL,
+       0,
+       0,
+       100,
+       0,
+       0x0B,
+       {}},
+      {"dbgen_version",
+       "dv",
+       0,
+       DBGEN_VERSION_START,
+       DBGEN_VERSION_END,
+       DBGEN_VERSION,
+       -1,
+       NULL,
+       0,
+       0,
+       0,
+       0,
+       0,
+       {}},
+      {NULL}};
+
+  rng_t Streams[MAX_STREAM + 1] = {
+      {0, 0, 0, 0, 0, 0, 0, 0},
+      {0, 0, 0, 0, CC_CALL_CENTER_SK, CALL_CENTER, CC_CALL_CENTER_SK, 0},
+      {0, 15, 0, 0, CC_CALL_CENTER_ID, CALL_CENTER, CC_CALL_CENTER_ID, 0},
+      {0, 10, 0, 0, CC_REC_START_DATE_ID, CALL_CENTER, CC_REC_START_DATE_ID, 0},
+      {0, 1, 0, 0, CC_REC_END_DATE_ID, CALL_CENTER, CC_REC_END_DATE_ID, 0},
+      {0, 4, 0, 0, CC_CLOSED_DATE_ID, CALL_CENTER, CC_CLOSED_DATE_ID, 0},
+      {0, 10, 0, 0, CC_OPEN_DATE_ID, CALL_CENTER, CC_OPEN_DATE_ID, 0},
+      {0, 0, 0, 0, CC_NAME, CALL_CENTER, CC_NAME, 0},
+      {0, 2, 0, 0, CC_CLASS, CALL_CENTER, CC_CLASS, 0},
+      {0, 1, 0, 0, CC_EMPLOYEES, CALL_CENTER, CC_EMPLOYEES, 0},
+      {0, 1, 0, 0, CC_SQ_FT, CALL_CENTER, CC_SQ_FT, 0},
+      {0, 1, 0, 0, CC_HOURS, CALL_CENTER, CC_HOURS, 0},
+      {0, 2, 0, 0, CC_MANAGER, CALL_CENTER, CC_MANAGER, 0},
+      {0, 1, 0, 0, CC_MARKET_ID, CALL_CENTER, CC_MARKET_ID, 0},
+      {0, 50, 0, 0, CC_MARKET_CLASS, CALL_CENTER, CC_MARKET_CLASS, 0},
+      {0, 50, 0, 0, CC_MARKET_DESC, CALL_CENTER, CC_MARKET_DESC, 0},
+      {0, 2, 0, 0, CC_MARKET_MANAGER, CALL_CENTER, CC_MARKET_MANAGER, 0},
+      {0, 2, 0, 0, CC_DIVISION, CALL_CENTER, CC_DIVISION, 0},
+      {0, 2, 0, 0, CC_DIVISION_NAME, CALL_CENTER, CC_DIVISION_NAME, 0},
+      {0, 2, 0, 0, CC_COMPANY, CALL_CENTER, CC_COMPANY, 0},
+      {0, 2, 0, 0, CC_COMPANY_NAME, CALL_CENTER, CC_COMPANY_NAME, 0},
+      {0, 0, 0, 0, CC_STREET_NUMBER, CALL_CENTER, CC_STREET_NUMBER, 0},
+      {0, 0, 0, 0, CC_STREET_NAME, CALL_CENTER, CC_STREET_NAME, 0},
+      {0, 0, 0, 0, CC_STREET_TYPE, CALL_CENTER, CC_STREET_TYPE, 0},
+      {0, 0, 0, 0, CC_SUITE_NUMBER, CALL_CENTER, CC_SUITE_NUMBER, 0},
+      {0, 0, 0, 0, CC_CITY, CALL_CENTER, CC_CITY, 0},
+      {0, 0, 0, 0, CC_COUNTY, CALL_CENTER, CC_COUNTY, 0},
+      {0, 0, 0, 0, CC_STATE, CALL_CENTER, CC_STATE, 0},
+      {0, 0, 0, 0, CC_ZIP, CALL_CENTER, CC_ZIP, 0},
+      {0, 0, 0, 0, CC_COUNTRY, CALL_CENTER, CC_COUNTRY, 0},
+      {0, 0, 0, 0, CC_GMT_OFFSET, CALL_CENTER, CC_GMT_OFFSET, 0},
+      {0, 15, 0, 0, CC_ADDRESS, CALL_CENTER, CC_ADDRESS, 0},
+      {0, 1, 0, 0, CC_TAX_PERCENTAGE, CALL_CENTER, CC_TAX_PERCENTAGE, 0},
+      {0, 1, 0, 0, CC_SCD, CALL_CENTER, CC_SCD, 0},
+      {0, 2, 0, 0, CC_NULLS, CALL_CENTER, CC_NULLS, 0},
+      {0, 1, 0, 0, CP_CATALOG_PAGE_SK, CATALOG_PAGE, CP_CATALOG_PAGE_SK, 0},
+      {0, 1, 0, 0, CP_CATALOG_PAGE_ID, CATALOG_PAGE, CP_CATALOG_PAGE_ID, 0},
+      {0, 1, 0, 0, CP_START_DATE_ID, CATALOG_PAGE, CP_START_DATE_ID, 0},
+      {0, 1, 0, 0, CP_END_DATE_ID, CATALOG_PAGE, CP_END_DATE_ID, 0},
+      {0, 1, 0, 0, CP_PROMO_ID, CATALOG_PAGE, CP_PROMO_ID, 0},
+      {0, 1, 0, 0, CP_DEPARTMENT, CATALOG_PAGE, CP_DEPARTMENT, 0},
+      {0, 1, 0, 0, CP_CATALOG_NUMBER, CATALOG_PAGE, CP_CATALOG_NUMBER, 0},
+      {0,
+       1,
+       0,
+       0,
+       CP_CATALOG_PAGE_NUMBER,
+       CATALOG_PAGE,
+       CP_CATALOG_PAGE_NUMBER,
+       0},
+      {0, 100, 0, 0, CP_DESCRIPTION, CATALOG_PAGE, S_CP_DESCRIPTION, 0},
+      {0, 1, 0, 0, CP_TYPE, CATALOG_PAGE, CP_TYPE, 0},
+      {0, 2, 0, 0, CP_NULLS, CATALOG_PAGE, CP_NULLS, 0},
+      {0,
+       28,
+       0,
+       0,
+       CR_RETURNED_DATE_SK,
+       CATALOG_RETURNS,
+       CR_RETURNED_DATE_SK,
+       0},
+      {0,
+       28,
+       0,
+       0,
+       CR_RETURNED_TIME_SK,
+       CATALOG_RETURNS,
+       CR_RETURNED_TIME_SK,
+       0},
+      {0, 14, 0, 0, CR_ITEM_SK, CATALOG_RETURNS, CR_ITEM_SK, 0},
+      {0,
+       14,
+       0,
+       0,
+       CR_REFUNDED_CUSTOMER_SK,
+       CATALOG_RETURNS,
+       CR_REFUNDED_CUSTOMER_SK,
+       0},
+      {0,
+       14,
+       0,
+       0,
+       CR_REFUNDED_CDEMO_SK,
+       CATALOG_RETURNS,
+       CR_REFUNDED_CDEMO_SK,
+       0},
+      {0,
+       14,
+       0,
+       0,
+       CR_REFUNDED_HDEMO_SK,
+       CATALOG_RETURNS,
+       CR_REFUNDED_HDEMO_SK,
+       0},
+      {0,
+       14,
+       0,
+       0,
+       CR_REFUNDED_ADDR_SK,
+       CATALOG_RETURNS,
+       CR_REFUNDED_ADDR_SK,
+       0},
+      {0,
+       28,
+       0,
+       0,
+       CR_RETURNING_CUSTOMER_SK,
+       CATALOG_RETURNS,
+       CR_RETURNING_CUSTOMER_SK,
+       0},
+      {0,
+       14,
+       0,
+       0,
+       CR_RETURNING_CDEMO_SK,
+       CATALOG_RETURNS,
+       CR_RETURNING_CDEMO_SK,
+       0},
+      {0,
+       14,
+       0,
+       0,
+       CR_RETURNING_HDEMO_SK,
+       CATALOG_RETURNS,
+       CR_RETURNING_HDEMO_SK,
+       0},
+      {0,
+       14,
+       0,
+       0,
+       CR_RETURNING_ADDR_SK,
+       CATALOG_RETURNS,
+       CR_RETURNING_ADDR_SK,
+       0},
+      {0, 0, 0, 0, CR_CALL_CENTER_SK, CATALOG_RETURNS, CR_CALL_CENTER_SK, 0},
+      {0, 14, 0, 0, CR_CATALOG_PAGE_SK, CATALOG_RETURNS, CR_CATALOG_PAGE_SK, 0},
+      {0, 14, 0, 0, CR_SHIP_MODE_SK, CATALOG_RETURNS, CR_SHIP_MODE_SK, 0},
+      {0, 14, 0, 0, CR_WAREHOUSE_SK, CATALOG_RETURNS, CR_WAREHOUSE_SK, 0},
+      {0, 14, 0, 0, CR_REASON_SK, CATALOG_RETURNS, CR_REASON_SK, 0},
+      {0, 0, 0, 0, CR_ORDER_NUMBER, CATALOG_RETURNS, CR_ORDER_NUMBER, 0},
+      {0,
+       0,
+       0,
+       0,
+       CR_PRICING_QUANTITY,
+       CATALOG_RETURNS,
+       CR_PRICING_QUANTITY,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CR_PRICING_NET_PAID,
+       CATALOG_RETURNS,
+       CR_PRICING_NET_PAID,
+       0},
+      {0, 0, 0, 0, CR_PRICING_EXT_TAX, CATALOG_RETURNS, CR_PRICING_EXT_TAX, 0},
+      {0,
+       0,
+       0,
+       0,
+       CR_PRICING_NET_PAID_INC_TAX,
+       CATALOG_RETURNS,
+       CR_PRICING_NET_PAID_INC_TAX,
+       0},
+      {0, 0, 0, 0, CR_PRICING_FEE, CATALOG_RETURNS, CR_PRICING_FEE, 0},
+      {0,
+       0,
+       0,
+       0,
+       CR_PRICING_EXT_SHIP_COST,
+       CATALOG_RETURNS,
+       CR_PRICING_EXT_SHIP_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CR_PRICING_REFUNDED_CASH,
+       CATALOG_RETURNS,
+       CR_PRICING_REFUNDED_CASH,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CR_PRICING_REVERSED_CHARGE,
+       CATALOG_RETURNS,
+       CR_PRICING_REVERSED_CHARGE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CR_PRICING_STORE_CREDIT,
+       CATALOG_RETURNS,
+       CR_PRICING_STORE_CREDIT,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CR_PRICING_NET_LOSS,
+       CATALOG_RETURNS,
+       CR_PRICING_NET_LOSS,
+       0},
+      {0, 28, 0, 0, CR_NULLS, CATALOG_RETURNS, CR_NULLS, 0},
+      {0, 70, 0, 0, CR_PRICING, CATALOG_RETURNS, CR_PRICING, 0},
+      {0, 1, 0, 0, CS_SOLD_DATE_SK, CATALOG_SALES, CS_SOLD_DATE_SK, 0},
+      {0, 2, 0, 0, CS_SOLD_TIME_SK, CATALOG_SALES, CS_SOLD_TIME_SK, 0},
+      {0, 14, 0, 0, CS_SHIP_DATE_SK, CATALOG_SALES, CS_SHIP_DATE_SK, 0},
+      {0, 1, 0, 0, CS_BILL_CUSTOMER_SK, CATALOG_SALES, CS_BILL_CUSTOMER_SK, 0},
+      {0, 1, 0, 0, CS_BILL_CDEMO_SK, CATALOG_SALES, CS_BILL_CDEMO_SK, 0},
+      {0, 1, 0, 0, CS_BILL_HDEMO_SK, CATALOG_SALES, CS_BILL_HDEMO_SK, 0},
+      {0, 1, 0, 0, CS_BILL_ADDR_SK, CATALOG_SALES, CS_BILL_ADDR_SK, 0},
+      {0, 2, 0, 0, CS_SHIP_CUSTOMER_SK, CATALOG_SALES, CS_SHIP_CUSTOMER_SK, 0},
+      {0, 1, 0, 0, CS_SHIP_CDEMO_SK, CATALOG_SALES, CS_SHIP_CDEMO_SK, 0},
+      {0, 1, 0, 0, CS_SHIP_HDEMO_SK, CATALOG_SALES, CS_SHIP_HDEMO_SK, 0},
+      {0, 1, 0, 0, CS_SHIP_ADDR_SK, CATALOG_SALES, CS_SHIP_ADDR_SK, 0},
+      {0, 1, 0, 0, CS_CALL_CENTER_SK, CATALOG_SALES, CS_CALL_CENTER_SK, 0},
+      {0, 42, 0, 0, CS_CATALOG_PAGE_SK, CATALOG_SALES, CS_CATALOG_PAGE_SK, 0},
+      {0, 14, 0, 0, CS_SHIP_MODE_SK, CATALOG_SALES, CS_SHIP_MODE_SK, 0},
+      {0, 14, 0, 0, CS_WAREHOUSE_SK, CATALOG_SALES, CS_WAREHOUSE_SK, 0},
+      {0, 1, 0, 0, CS_SOLD_ITEM_SK, CATALOG_SALES, CS_SOLD_ITEM_SK, 0},
+      {0, 14, 0, 0, CS_PROMO_SK, CATALOG_SALES, CS_PROMO_SK, 0},
+      {0, 1, 0, 0, CS_ORDER_NUMBER, CATALOG_SALES, CS_ORDER_NUMBER, 0},
+      {0, 0, 0, 0, CS_PRICING_QUANTITY, CATALOG_SALES, CS_PRICING_QUANTITY, 0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_WHOLESALE_COST,
+       CATALOG_SALES,
+       CS_PRICING_WHOLESALE_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_LIST_PRICE,
+       CATALOG_SALES,
+       CS_PRICING_LIST_PRICE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_SALES_PRICE,
+       CATALOG_SALES,
+       CS_PRICING_SALES_PRICE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_COUPON_AMT,
+       CATALOG_SALES,
+       CS_PRICING_COUPON_AMT,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_EXT_SALES_PRICE,
+       CATALOG_SALES,
+       CS_PRICING_EXT_SALES_PRICE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_EXT_DISCOUNT_AMOUNT,
+       CATALOG_SALES,
+       CS_PRICING_EXT_DISCOUNT_AMOUNT,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_EXT_WHOLESALE_COST,
+       CATALOG_SALES,
+       CS_PRICING_EXT_WHOLESALE_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_EXT_LIST_PRICE,
+       CATALOG_SALES,
+       CS_PRICING_EXT_LIST_PRICE,
+       0},
+      {0, 0, 0, 0, CS_PRICING_EXT_TAX, CATALOG_SALES, CS_PRICING_EXT_TAX, 0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_EXT_SHIP_COST,
+       CATALOG_SALES,
+       CS_PRICING_EXT_SHIP_COST,
+       0},
+      {0, 0, 0, 0, CS_PRICING_NET_PAID, CATALOG_SALES, CS_PRICING_NET_PAID, 0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_NET_PAID_INC_TAX,
+       CATALOG_SALES,
+       CS_PRICING_NET_PAID_INC_TAX,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_NET_PAID_INC_SHIP,
+       CATALOG_SALES,
+       CS_PRICING_NET_PAID_INC_SHIP,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_NET_PAID_INC_SHIP_TAX,
+       CATALOG_SALES,
+       CS_PRICING_NET_PAID_INC_SHIP_TAX,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       CS_PRICING_NET_PROFIT,
+       CATALOG_SALES,
+       CS_PRICING_NET_PROFIT,
+       0},
+      {0, 112, 0, 0, CS_PRICING, CATALOG_SALES, CS_PRICING, 0},
+      {0, 0, 0, 0, CS_PERMUTE, CATALOG_SALES, CS_PERMUTE, 0},
+      {0, 28, 0, 0, CS_NULLS, CATALOG_SALES, CS_NULLS, 0},
+      {0, 14, 0, 0, CR_IS_RETURNED, CATALOG_SALES, CR_IS_RETURNED, 0},
+      {0, 0, 0, 0, CS_PERMUTATION, CATALOG_SALES, CS_PERMUTATION, 0},
+      {0, 1, 0, 0, C_CUSTOMER_SK, CUSTOMER, C_CUSTOMER_SK, 0},
+      {0, 1, 0, 0, C_CUSTOMER_ID, CUSTOMER, C_CUSTOMER_ID, 0},
+      {0, 1, 0, 0, C_CURRENT_CDEMO_SK, CUSTOMER, C_CURRENT_CDEMO_SK, 0},
+      {0, 1, 0, 0, C_CURRENT_HDEMO_SK, CUSTOMER, C_CURRENT_HDEMO_SK, 0},
+      {0, 1, 0, 0, C_CURRENT_ADDR_SK, CUSTOMER, C_CURRENT_ADDR_SK, 0},
+      {0, 0, 0, 0, C_FIRST_SHIPTO_DATE_ID, CUSTOMER, C_FIRST_SHIPTO_DATE_ID, 0},
+      {0, 1, 0, 0, C_FIRST_SALES_DATE_ID, CUSTOMER, C_FIRST_SALES_DATE_ID, 0},
+      {0, 1, 0, 0, C_SALUTATION, CUSTOMER, C_SALUTATION, 0},
+      {0, 1, 0, 0, C_FIRST_NAME, CUSTOMER, C_FIRST_NAME, 0},
+      {0, 1, 0, 0, C_LAST_NAME, CUSTOMER, C_LAST_NAME, 0},
+      {0, 2, 0, 0, C_PREFERRED_CUST_FLAG, CUSTOMER, C_PREFERRED_CUST_FLAG, 0},
+      {0, 1, 0, 0, C_BIRTH_DAY, CUSTOMER, C_BIRTH_DAY, 0},
+      {0, 0, 0, 0, C_BIRTH_MONTH, CUSTOMER, C_BIRTH_MONTH, 0},
+      {0, 0, 0, 0, C_BIRTH_YEAR, CUSTOMER, C_BIRTH_YEAR, 0},
+      {0, 1, 0, 0, C_BIRTH_COUNTRY, CUSTOMER, C_BIRTH_COUNTRY, 0},
+      {0, 1, 0, 0, C_LOGIN, CUSTOMER, C_LOGIN, 0},
+      {0, 23, 0, 0, C_EMAIL_ADDRESS, CUSTOMER, C_EMAIL_ADDRESS, 0},
+      {0, 1, 0, 0, C_LAST_REVIEW_DATE, CUSTOMER, C_LAST_REVIEW_DATE, 0},
+      {0, 2, 0, 0, C_NULLS, CUSTOMER, C_NULLS, 0},
+      {0, 1, 0, 0, CA_ADDRESS_SK, CUSTOMER_ADDRESS, CA_ADDRESS_SK, 0},
+      {0, 1, 0, 0, CA_ADDRESS_ID, CUSTOMER_ADDRESS, CA_ADDRESS_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       CA_ADDRESS_STREET_NUM,
+       CUSTOMER_ADDRESS,
+       CA_ADDRESS_STREET_NUM,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       CA_ADDRESS_STREET_NAME1,
+       CUSTOMER_ADDRESS,
+       CA_ADDRESS_STREET_NAME1,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       CA_ADDRESS_STREET_TYPE,
+       CUSTOMER_ADDRESS,
+       CA_ADDRESS_STREET_TYPE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       CA_ADDRESS_SUITE_NUM,
+       CUSTOMER_ADDRESS,
+       CA_ADDRESS_SUITE_NUM,
+       0},
+      {0, 1, 0, 0, CA_ADDRESS_CITY, CUSTOMER_ADDRESS, CA_ADDRESS_CITY, 0},
+      {0, 1, 0, 0, CA_ADDRESS_COUNTY, CUSTOMER_ADDRESS, CA_ADDRESS_COUNTY, 0},
+      {0, 1, 0, 0, CA_ADDRESS_STATE, CUSTOMER_ADDRESS, CA_ADDRESS_STATE, 0},
+      {0, 1, 0, 0, CA_ADDRESS_ZIP, CUSTOMER_ADDRESS, CA_ADDRESS_ZIP, 0},
+      {0, 1, 0, 0, CA_ADDRESS_COUNTRY, CUSTOMER_ADDRESS, CA_ADDRESS_COUNTRY, 0},
+      {0,
+       1,
+       0,
+       0,
+       CA_ADDRESS_GMT_OFFSET,
+       CUSTOMER_ADDRESS,
+       CA_ADDRESS_GMT_OFFSET,
+       0},
+      {0, 1, 0, 0, CA_LOCATION_TYPE, CUSTOMER_ADDRESS, CA_LOCATION_TYPE, 0},
+      {0, 2, 0, 0, CA_NULLS, CUSTOMER_ADDRESS, CA_NULLS, 0},
+      {0, 7, 0, 0, CA_ADDRESS, CUSTOMER_ADDRESS, CA_ADDRESS, 0},
+      {0,
+       1,
+       0,
+       0,
+       CA_ADDRESS_STREET_NAME2,
+       CUSTOMER_ADDRESS,
+       CA_ADDRESS_STREET_NAME2,
+       0},
+      {0, 1, 0, 0, CD_DEMO_SK, CUSTOMER_DEMOGRAPHICS, CD_DEMO_SK, 0},
+      {0, 1, 0, 0, CD_GENDER, CUSTOMER_DEMOGRAPHICS, CD_GENDER, 0},
+      {0,
+       1,
+       0,
+       0,
+       CD_MARITAL_STATUS,
+       CUSTOMER_DEMOGRAPHICS,
+       CD_MARITAL_STATUS,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       CD_EDUCATION_STATUS,
+       CUSTOMER_DEMOGRAPHICS,
+       CD_EDUCATION_STATUS,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       CD_PURCHASE_ESTIMATE,
+       CUSTOMER_DEMOGRAPHICS,
+       CD_PURCHASE_ESTIMATE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       CD_CREDIT_RATING,
+       CUSTOMER_DEMOGRAPHICS,
+       CD_CREDIT_RATING,
+       0},
+      {0, 1, 0, 0, CD_DEP_COUNT, CUSTOMER_DEMOGRAPHICS, CD_DEP_COUNT, 0},
+      {0,
+       1,
+       0,
+       0,
+       CD_DEP_EMPLOYED_COUNT,
+       CUSTOMER_DEMOGRAPHICS,
+       CD_DEP_EMPLOYED_COUNT,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       CD_DEP_COLLEGE_COUNT,
+       CUSTOMER_DEMOGRAPHICS,
+       CD_DEP_COLLEGE_COUNT,
+       0},
+      {0, 2, 0, 0, CD_NULLS, CUSTOMER_DEMOGRAPHICS, CD_NULLS, 0},
+      {0, 0, 0, 0, D_DATE_SK, DATET, D_DATE_SK, 0},
+      {0, 0, 0, 0, D_DATE_ID, DATET, D_DATE_ID, 0},
+      {0, 0, 0, 0, D_DATE, DATET, D_DATE, 0},
+      {0, 0, 0, 0, D_MONTH_SEQ, DATET, D_MONTH_SEQ, 0},
+      {0, 0, 0, 0, D_WEEK_SEQ, DATET, D_WEEK_SEQ, 0},
+      {0, 0, 0, 0, D_QUARTER_SEQ, DATET, D_QUARTER_SEQ, 0},
+      {0, 0, 0, 0, D_YEAR, DATET, D_YEAR, 0},
+      {0, 0, 0, 0, D_DOW, DATET, D_DOW, 0},
+      {0, 0, 0, 0, D_MOY, DATET, D_MOY, 0},
+      {0, 0, 0, 0, D_DOM, DATET, D_DOM, 0},
+      {0, 0, 0, 0, D_QOY, DATET, D_QOY, 0},
+      {0, 0, 0, 0, D_FY_YEAR, DATET, D_FY_YEAR, 0},
+      {0, 0, 0, 0, D_FY_QUARTER_SEQ, DATET, D_FY_QUARTER_SEQ, 0},
+      {0, 0, 0, 0, D_FY_WEEK_SEQ, DATET, D_FY_WEEK_SEQ, 0},
+      {0, 0, 0, 0, D_DAY_NAME, DATET, D_DAY_NAME, 0},
+      {0, 0, 0, 0, D_QUARTER_NAME, DATET, D_QUARTER_NAME, 0},
+      {0, 0, 0, 0, D_HOLIDAY, DATET, D_HOLIDAY, 0},
+      {0, 0, 0, 0, D_WEEKEND, DATET, D_WEEKEND, 0},
+      {0, 0, 0, 0, D_FOLLOWING_HOLIDAY, DATET, D_FOLLOWING_HOLIDAY, 0},
+      {0, 0, 0, 0, D_FIRST_DOM, DATET, D_FIRST_DOM, 0},
+      {0, 0, 0, 0, D_LAST_DOM, DATET, D_LAST_DOM, 0},
+      {0, 0, 0, 0, D_SAME_DAY_LY, DATET, D_SAME_DAY_LY, 0},
+      {0, 0, 0, 0, D_SAME_DAY_LQ, DATET, D_SAME_DAY_LQ, 0},
+      {0, 0, 0, 0, D_CURRENT_DAY, DATET, D_CURRENT_DAY, 0},
+      {0, 0, 0, 0, D_CURRENT_WEEK, DATET, D_CURRENT_WEEK, 0},
+      {0, 0, 0, 0, D_CURRENT_MONTH, DATET, D_CURRENT_MONTH, 0},
+      {0, 0, 0, 0, D_CURRENT_QUARTER, DATET, D_CURRENT_QUARTER, 0},
+      {0, 0, 0, 0, D_CURRENT_YEAR, DATET, D_CURRENT_YEAR, 0},
+      {0, 2, 0, 0, D_NULLS, DATET, D_NULLS, 0},
+      {0, 1, 0, 0, HD_DEMO_SK, HOUSEHOLD_DEMOGRAPHICS, HD_DEMO_SK, 0},
+      {0,
+       1,
+       0,
+       0,
+       HD_INCOME_BAND_ID,
+       HOUSEHOLD_DEMOGRAPHICS,
+       HD_INCOME_BAND_ID,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       HD_BUY_POTENTIAL,
+       HOUSEHOLD_DEMOGRAPHICS,
+       HD_BUY_POTENTIAL,
+       0},
+      {0, 1, 0, 0, HD_DEP_COUNT, HOUSEHOLD_DEMOGRAPHICS, HD_DEP_COUNT, 0},
+      {0,
+       1,
+       0,
+       0,
+       HD_VEHICLE_COUNT,
+       HOUSEHOLD_DEMOGRAPHICS,
+       HD_VEHICLE_COUNT,
+       0},
+      {0, 2, 0, 0, HD_NULLS, HOUSEHOLD_DEMOGRAPHICS, HD_NULLS, 0},
+      {0, 1, 0, 0, IB_INCOME_BAND_ID, INCOME_BAND, IB_INCOME_BAND_ID, 0},
+      {0, 1, 0, 0, IB_LOWER_BOUND, INCOME_BAND, IB_LOWER_BOUND, 0},
+      {0, 1, 0, 0, IB_UPPER_BOUND, INCOME_BAND, IB_UPPER_BOUND, 0},
+      {0, 2, 0, 0, IB_NULLS, INCOME_BAND, IB_NULLS, 0},
+      {0, 1, 0, 0, INV_DATE_SK, INVENTORY, INV_DATE_SK, 0},
+      {0, 1, 0, 0, INV_ITEM_SK, INVENTORY, INV_ITEM_SK, 0},
+      {0, 1, 0, 0, INV_WAREHOUSE_SK, INVENTORY, INV_WAREHOUSE_SK, 0},
+      {0, 1, 0, 0, INV_QUANTITY_ON_HAND, INVENTORY, INV_QUANTITY_ON_HAND, 0},
+      {0, 2, 0, 0, INV_NULLS, INVENTORY, INV_NULLS, 0},
+      {0, 1, 0, 0, I_ITEM_SK, ITEM, I_ITEM_SK, 0},
+      {0, 1, 0, 0, I_ITEM_ID, ITEM, I_ITEM_ID, 0},
+      {0, 1, 0, 0, I_REC_START_DATE_ID, ITEM, I_REC_START_DATE_ID, 0},
+      {0, 2, 0, 0, I_REC_END_DATE_ID, ITEM, I_REC_END_DATE_ID, 0},
+      {0, 200, 0, 0, I_ITEM_DESC, ITEM, S_ITEM_DESC, 0},
+      {0, 2, 0, 0, I_CURRENT_PRICE, ITEM, I_CURRENT_PRICE, 0},
+      {0, 1, 0, 0, I_WHOLESALE_COST, ITEM, I_WHOLESALE_COST, 0},
+      {0, 1, 0, 0, I_BRAND_ID, ITEM, I_BRAND_ID, 0},
+      {0, 1, 0, 0, I_BRAND, ITEM, I_BRAND, 0},
+      {0, 1, 0, 0, I_CLASS_ID, ITEM, I_CLASS_ID, 0},
+      {0, 1, 0, 0, I_CLASS, ITEM, I_CLASS, 0},
+      {0, 1, 0, 0, I_CATEGORY_ID, ITEM, I_CATEGORY_ID, 0},
+      {0, 1, 0, 0, I_CATEGORY, ITEM, I_CATEGORY, 0},
+      {0, 2, 0, 0, I_MANUFACT_ID, ITEM, I_MANUFACT_ID, 0},
+      {0, 1, 0, 0, I_MANUFACT, ITEM, I_MANUFACT, 0},
+      {0, 1, 0, 0, I_SIZE, ITEM, I_SIZE, 0},
+      {0, 50, 0, 0, I_FORMULATION, ITEM, I_FORMULATION, 0},
+      {0, 1, 0, 0, I_COLOR, ITEM, I_COLOR, 0},
+      {0, 1, 0, 0, I_UNITS, ITEM, I_UNITS, 0},
+      {0, 1, 0, 0, I_CONTAINER, ITEM, I_CONTAINER, 0},
+      {0, 2, 0, 0, I_MANAGER_ID, ITEM, I_MANAGER_ID, 0},
+      {0, 1, 0, 0, I_PRODUCT_NAME, ITEM, I_PRODUCT_NAME, 0},
+      {0, 2, 0, 0, I_NULLS, ITEM, I_NULLS, 0},
+      {0, 1, 0, 0, I_SCD, ITEM, I_SCD, 0},
+      {0, 2, 0, 0, I_PROMO_SK, ITEM, I_PROMO_SK, 0},
+      {0, 1, 0, 0, P_PROMO_SK, PROMOTION, P_PROMO_SK, 0},
+      {0, 1, 0, 0, P_PROMO_ID, PROMOTION, P_PROMO_ID, 0},
+      {0, 1, 0, 0, P_START_DATE_ID, PROMOTION, P_START_DATE_ID, 0},
+      {0, 1, 0, 0, P_END_DATE_ID, PROMOTION, P_END_DATE_ID, 0},
+      {0, 1, 0, 0, P_ITEM_SK, PROMOTION, P_ITEM_SK, 0},
+      {0, 1, 0, 0, P_COST, PROMOTION, P_COST, 0},
+      {0, 1, 0, 0, P_RESPONSE_TARGET, PROMOTION, P_RESPONSE_TARGET, 0},
+      {0, 1, 0, 0, P_PROMO_NAME, PROMOTION, P_PROMO_NAME, 0},
+      {0, 1, 0, 0, P_CHANNEL_DMAIL, PROMOTION, P_CHANNEL_DMAIL, 0},
+      {0, 1, 0, 0, P_CHANNEL_EMAIL, PROMOTION, P_CHANNEL_EMAIL, 0},
+      {0, 1, 0, 0, P_CHANNEL_CATALOG, PROMOTION, P_CHANNEL_CATALOG, 0},
+      {0, 1, 0, 0, P_CHANNEL_TV, PROMOTION, P_CHANNEL_TV, 0},
+      {0, 1, 0, 0, P_CHANNEL_RADIO, PROMOTION, P_CHANNEL_RADIO, 0},
+      {0, 1, 0, 0, P_CHANNEL_PRESS, PROMOTION, P_CHANNEL_PRESS, 0},
+      {0, 1, 0, 0, P_CHANNEL_EVENT, PROMOTION, P_CHANNEL_EVENT, 0},
+      {0, 1, 0, 0, P_CHANNEL_DEMO, PROMOTION, P_CHANNEL_DEMO, 0},
+      {0, 100, 0, 0, P_CHANNEL_DETAILS, PROMOTION, P_CHANNEL_DETAILS, 0},
+      {0, 1, 0, 0, P_PURPOSE, PROMOTION, P_PURPOSE, 0},
+      {0, 1, 0, 0, P_DISCOUNT_ACTIVE, PROMOTION, P_DISCOUNT_ACTIVE, 0},
+      {0, 2, 0, 0, P_NULLS, PROMOTION, P_NULLS, 0},
+      {0, 1, 0, 0, R_REASON_SK, REASON, R_REASON_SK, 0},
+      {0, 1, 0, 0, R_REASON_ID, REASON, R_REASON_ID, 0},
+      {0, 1, 0, 0, R_REASON_DESCRIPTION, REASON, R_REASON_DESCRIPTION, 0},
+      {0, 2, 0, 0, R_NULLS, REASON, R_NULLS, 0},
+      {0, 1, 0, 0, SM_SHIP_MODE_SK, SHIP_MODE, SM_SHIP_MODE_SK, 0},
+      {0, 1, 0, 0, SM_SHIP_MODE_ID, SHIP_MODE, SM_SHIP_MODE_ID, 0},
+      {0, 1, 0, 0, SM_TYPE, SHIP_MODE, SM_TYPE, 0},
+      {0, 1, 0, 0, SM_CODE, SHIP_MODE, SM_CODE, 0},
+      {0, 21, 0, 0, SM_CONTRACT, SHIP_MODE, SM_CONTRACT, 0},
+      {0, 1, 0, 0, SM_CARRIER, SHIP_MODE, SM_CARRIER, 0},
+      {0, 2, 0, 0, SM_NULLS, SHIP_MODE, SM_NULLS, 0},
+      {0, 1, 0, 0, W_STORE_SK, STORE, W_STORE_SK, 0},
+      {0, 1, 0, 0, W_STORE_ID, STORE, W_STORE_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       W_STORE_REC_START_DATE_ID,
+       STORE,
+       W_STORE_REC_START_DATE_ID,
+       0},
+      {0, 2, 0, 0, W_STORE_REC_END_DATE_ID, STORE, W_STORE_REC_END_DATE_ID, 0},
+      {0, 2, 0, 0, W_STORE_CLOSED_DATE_ID, STORE, W_STORE_CLOSED_DATE_ID, 0},
+      {0, 0, 0, 0, W_STORE_NAME, STORE, W_STORE_NAME, 0},
+      {0, 1, 0, 0, W_STORE_EMPLOYEES, STORE, W_STORE_EMPLOYEES, 0},
+      {0, 1, 0, 0, W_STORE_FLOOR_SPACE, STORE, W_STORE_FLOOR_SPACE, 0},
+      {0, 1, 0, 0, W_STORE_HOURS, STORE, W_STORE_HOURS, 0},
+      {0, 2, 0, 0, W_STORE_MANAGER, STORE, W_STORE_MANAGER, 0},
+      {0, 1, 0, 0, W_STORE_MARKET_ID, STORE, W_STORE_MARKET_ID, 0},
+      {0, 1, 0, 0, W_STORE_TAX_PERCENTAGE, STORE, W_STORE_TAX_PERCENTAGE, 0},
+      {0, 1, 0, 0, W_STORE_GEOGRAPHY_CLASS, STORE, W_STORE_GEOGRAPHY_CLASS, 0},
+      {0, 100, 0, 0, W_STORE_MARKET_DESC, STORE, W_STORE_MARKET_DESC, 0},
+      {0, 2, 0, 0, W_STORE_MARKET_MANAGER, STORE, W_STORE_MARKET_MANAGER, 0},
+      {0, 1, 0, 0, W_STORE_DIVISION_ID, STORE, W_STORE_DIVISION_ID, 0},
+      {0, 1, 0, 0, W_STORE_DIVISION_NAME, STORE, W_STORE_DIVISION_NAME, 0},
+      {0, 1, 0, 0, W_STORE_COMPANY_ID, STORE, W_STORE_COMPANY_ID, 0},
+      {0, 1, 0, 0, W_STORE_COMPANY_NAME, STORE, W_STORE_COMPANY_NAME, 0},
+      {0,
+       1,
+       0,
+       0,
+       W_STORE_ADDRESS_STREET_NUM,
+       STORE,
+       W_STORE_ADDRESS_STREET_NUM,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       W_STORE_ADDRESS_STREET_NAME1,
+       STORE,
+       W_STORE_ADDRESS_STREET_NAME1,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       W_STORE_ADDRESS_STREET_TYPE,
+       STORE,
+       W_STORE_ADDRESS_STREET_TYPE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       W_STORE_ADDRESS_SUITE_NUM,
+       STORE,
+       W_STORE_ADDRESS_SUITE_NUM,
+       0},
+      {0, 1, 0, 0, W_STORE_ADDRESS_CITY, STORE, W_STORE_ADDRESS_CITY, 0},
+      {0, 1, 0, 0, W_STORE_ADDRESS_COUNTY, STORE, W_STORE_ADDRESS_COUNTY, 0},
+      {0, 1, 0, 0, W_STORE_ADDRESS_STATE, STORE, W_STORE_ADDRESS_STATE, 0},
+      {0, 1, 0, 0, W_STORE_ADDRESS_ZIP, STORE, W_STORE_ADDRESS_ZIP, 0},
+      {0, 1, 0, 0, W_STORE_ADDRESS_COUNTRY, STORE, W_STORE_ADDRESS_COUNTRY, 0},
+      {0,
+       1,
+       0,
+       0,
+       W_STORE_ADDRESS_GMT_OFFSET,
+       STORE,
+       W_STORE_ADDRESS_GMT_OFFSET,
+       0},
+      {0, 2, 0, 0, W_STORE_NULLS, STORE, W_STORE_NULLS, 0},
+      {0, 1, 0, 0, W_STORE_TYPE, STORE, W_STORE_TYPE, 0},
+      {0, 1, 0, 0, W_STORE_SCD, STORE, W_STORE_SCD, 0},
+      {0, 7, 0, 0, W_STORE_ADDRESS, STORE, W_STORE_ADDRESS, 0},
+      {0, 32, 0, 0, SR_RETURNED_DATE_SK, STORE_RETURNS, SR_RETURNED_DATE_SK, 0},
+      {0, 32, 0, 0, SR_RETURNED_TIME_SK, STORE_RETURNS, SR_RETURNED_TIME_SK, 0},
+      {0, 16, 0, 0, SR_ITEM_SK, STORE_RETURNS, SR_ITEM_SK, 0},
+      {0, 16, 0, 0, SR_CUSTOMER_SK, STORE_RETURNS, SR_CUSTOMER_SK, 0},
+      {0, 16, 0, 0, SR_CDEMO_SK, STORE_RETURNS, SR_CDEMO_SK, 0},
+      {0, 16, 0, 0, SR_HDEMO_SK, STORE_RETURNS, SR_HDEMO_SK, 0},
+      {0, 16, 0, 0, SR_ADDR_SK, STORE_RETURNS, SR_ADDR_SK, 0},
+      {0, 16, 0, 0, SR_STORE_SK, STORE_RETURNS, SR_STORE_SK, 0},
+      {0, 16, 0, 0, SR_REASON_SK, STORE_RETURNS, SR_REASON_SK, 0},
+      {0, 16, 0, 0, SR_TICKET_NUMBER, STORE_RETURNS, SR_TICKET_NUMBER, 0},
+      {0, 0, 0, 0, SR_PRICING_QUANTITY, STORE_RETURNS, SR_PRICING_QUANTITY, 0},
+      {0, 0, 0, 0, SR_PRICING_NET_PAID, STORE_RETURNS, SR_PRICING_NET_PAID, 0},
+      {0, 0, 0, 0, SR_PRICING_EXT_TAX, STORE_RETURNS, SR_PRICING_EXT_TAX, 0},
+      {0,
+       0,
+       0,
+       0,
+       SR_PRICING_NET_PAID_INC_TAX,
+       STORE_RETURNS,
+       SR_PRICING_NET_PAID_INC_TAX,
+       0},
+      {0, 0, 0, 0, SR_PRICING_FEE, STORE_RETURNS, SR_PRICING_FEE, 0},
+      {0,
+       0,
+       0,
+       0,
+       SR_PRICING_EXT_SHIP_COST,
+       STORE_RETURNS,
+       SR_PRICING_EXT_SHIP_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SR_PRICING_REFUNDED_CASH,
+       STORE_RETURNS,
+       SR_PRICING_REFUNDED_CASH,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SR_PRICING_REVERSED_CHARGE,
+       STORE_RETURNS,
+       SR_PRICING_REVERSED_CHARGE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SR_PRICING_STORE_CREDIT,
+       STORE_RETURNS,
+       SR_PRICING_STORE_CREDIT,
+       0},
+      {0, 0, 0, 0, SR_PRICING_NET_LOSS, STORE_RETURNS, SR_PRICING_NET_LOSS, 0},
+      {0, 80, 0, 0, SR_PRICING, STORE_RETURNS, SR_PRICING, 0},
+      {0, 32, 0, 0, SR_NULLS, STORE_RETURNS, SR_NULLS, 0},
+      {0, 2, 0, 0, SS_SOLD_DATE_SK, STORE_SALES, SS_SOLD_DATE_SK, 0},
+      {0, 2, 0, 0, SS_SOLD_TIME_SK, STORE_SALES, SS_SOLD_TIME_SK, 0},
+      {0, 1, 0, 0, SS_SOLD_ITEM_SK, STORE_SALES, SS_SOLD_ITEM_SK, 0},
+      {0, 1, 0, 0, SS_SOLD_CUSTOMER_SK, STORE_SALES, SS_SOLD_CUSTOMER_SK, 0},
+      {0, 1, 0, 0, SS_SOLD_CDEMO_SK, STORE_SALES, SS_SOLD_CDEMO_SK, 0},
+      {0, 1, 0, 0, SS_SOLD_HDEMO_SK, STORE_SALES, SS_SOLD_HDEMO_SK, 0},
+      {0, 1, 0, 0, SS_SOLD_ADDR_SK, STORE_SALES, SS_SOLD_ADDR_SK, 0},
+      {0, 1, 0, 0, SS_SOLD_STORE_SK, STORE_SALES, SS_SOLD_STORE_SK, 0},
+      {0, 16, 0, 0, SS_SOLD_PROMO_SK, STORE_SALES, SS_SOLD_PROMO_SK, 0},
+      {0, 1, 0, 0, SS_TICKET_NUMBER, STORE_SALES, SS_TICKET_NUMBER, 0},
+      {0, 1, 0, 0, SS_PRICING_QUANTITY, STORE_SALES, SS_PRICING_QUANTITY, 0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_WHOLESALE_COST,
+       STORE_SALES,
+       SS_PRICING_WHOLESALE_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_LIST_PRICE,
+       STORE_SALES,
+       SS_PRICING_LIST_PRICE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_SALES_PRICE,
+       STORE_SALES,
+       SS_PRICING_SALES_PRICE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_COUPON_AMT,
+       STORE_SALES,
+       SS_PRICING_COUPON_AMT,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_EXT_SALES_PRICE,
+       STORE_SALES,
+       SS_PRICING_EXT_SALES_PRICE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_EXT_WHOLESALE_COST,
+       STORE_SALES,
+       SS_PRICING_EXT_WHOLESALE_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_EXT_LIST_PRICE,
+       STORE_SALES,
+       SS_PRICING_EXT_LIST_PRICE,
+       0},
+      {0, 0, 0, 0, SS_PRICING_EXT_TAX, STORE_SALES, SS_PRICING_EXT_TAX, 0},
+      {0, 0, 0, 0, SS_PRICING_NET_PAID, STORE_SALES, SS_PRICING_NET_PAID, 0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_NET_PAID_INC_TAX,
+       STORE_SALES,
+       SS_PRICING_NET_PAID_INC_TAX,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       SS_PRICING_NET_PROFIT,
+       STORE_SALES,
+       SS_PRICING_NET_PROFIT,
+       0},
+      {0, 16, 0, 0, SR_IS_RETURNED, STORE_SALES, SR_IS_RETURNED, 0},
+      {0, 128, 0, 0, SS_PRICING, STORE_SALES, SS_PRICING, 0},
+      {0, 32, 0, 0, SS_NULLS, STORE_SALES, SS_NULLS, 0},
+      {0, 0, 0, 0, SS_PERMUTATION, STORE_SALES, SS_PERMUTATION, 0},
+      {0, 1, 0, 0, T_TIME_SK, TIMET, T_TIME_SK, 0},
+      {0, 1, 0, 0, T_TIME_ID, TIMET, T_TIME_ID, 0},
+      {0, 1, 0, 0, T_TIME, TIMET, T_TIME, 0},
+      {0, 1, 0, 0, T_HOUR, TIMET, T_HOUR, 0},
+      {0, 1, 0, 0, T_MINUTE, TIMET, T_MINUTE, 0},
+      {0, 1, 0, 0, T_SECOND, TIMET, T_SECOND, 0},
+      {0, 1, 0, 0, T_AM_PM, TIMET, T_AM_PM, 0},
+      {0, 1, 0, 0, T_SHIFT, TIMET, T_SHIFT, 0},
+      {0, 1, 0, 0, T_SUB_SHIFT, TIMET, T_SUB_SHIFT, 0},
+      {0, 1, 0, 0, T_MEAL_TIME, TIMET, T_MEAL_TIME, 0},
+      {0, 2, 0, 0, T_NULLS, TIMET, T_NULLS, 0},
+      {0, 1, 0, 0, W_WAREHOUSE_SK, WAREHOUSE, W_WAREHOUSE_SK, 0},
+      {0, 1, 0, 0, W_WAREHOUSE_ID, WAREHOUSE, W_WAREHOUSE_ID, 0},
+      {0, 80, 0, 0, W_WAREHOUSE_NAME, WAREHOUSE, W_WAREHOUSE_NAME, 0},
+      {0, 1, 0, 0, W_WAREHOUSE_SQ_FT, WAREHOUSE, W_WAREHOUSE_SQ_FT, 0},
+      {0, 1, 0, 0, W_ADDRESS_STREET_NUM, WAREHOUSE, W_ADDRESS_STREET_NUM, 0},
+      {0,
+       1,
+       0,
+       0,
+       W_ADDRESS_STREET_NAME1,
+       WAREHOUSE,
+       W_ADDRESS_STREET_NAME1,
+       0},
+      {0, 1, 0, 0, W_ADDRESS_STREET_TYPE, WAREHOUSE, W_ADDRESS_STREET_TYPE, 0},
+      {0, 1, 0, 0, W_ADDRESS_SUITE_NUM, WAREHOUSE, W_ADDRESS_SUITE_NUM, 0},
+      {0, 1, 0, 0, W_ADDRESS_CITY, WAREHOUSE, W_ADDRESS_CITY, 0},
+      {0, 1, 0, 0, W_ADDRESS_COUNTY, WAREHOUSE, W_ADDRESS_COUNTY, 0},
+      {0, 1, 0, 0, W_ADDRESS_STATE, WAREHOUSE, W_ADDRESS_STATE, 0},
+      {0, 1, 0, 0, W_ADDRESS_ZIP, WAREHOUSE, W_ADDRESS_ZIP, 0},
+      {0, 1, 0, 0, W_ADDRESS_COUNTRY, WAREHOUSE, W_ADDRESS_COUNTRY, 0},
+      {0, 1, 0, 0, W_ADDRESS_GMT_OFFSET, WAREHOUSE, W_ADDRESS_GMT_OFFSET, 0},
+      {0, 2, 0, 0, W_NULLS, WAREHOUSE, W_NULLS, 0},
+      {0, 7, 0, 0, W_WAREHOUSE_ADDRESS, WAREHOUSE, W_WAREHOUSE_ADDRESS, 0},
+      {0, 1, 0, 0, WP_PAGE_SK, WEB_PAGE, WP_PAGE_SK, 0},
+      {0, 1, 0, 0, WP_PAGE_ID, WEB_PAGE, WP_PAGE_ID, 0},
+      {0, 1, 0, 0, WP_REC_START_DATE_ID, WEB_PAGE, WP_REC_START_DATE_ID, 0},
+      {0, 1, 0, 0, WP_REC_END_DATE_ID, WEB_PAGE, WP_REC_END_DATE_ID, 0},
+      {0, 2, 0, 0, WP_CREATION_DATE_SK, WEB_PAGE, WP_CREATION_DATE_SK, 0},
+      {0, 1, 0, 0, WP_ACCESS_DATE_SK, WEB_PAGE, WP_ACCESS_DATE_SK, 0},
+      {0, 1, 0, 0, WP_AUTOGEN_FLAG, WEB_PAGE, WP_AUTOGEN_FLAG, 0},
+      {0, 1, 0, 0, WP_CUSTOMER_SK, WEB_PAGE, WP_CUSTOMER_SK, 0},
+      {0, 1, 0, 0, WP_URL, WEB_PAGE, WP_URL, 0},
+      {0, 1, 0, 0, WP_TYPE, WEB_PAGE, WP_TYPE, 0},
+      {0, 1, 0, 0, WP_CHAR_COUNT, WEB_PAGE, WP_CHAR_COUNT, 0},
+      {0, 1, 0, 0, WP_LINK_COUNT, WEB_PAGE, WP_LINK_COUNT, 0},
+      {0, 1, 0, 0, WP_IMAGE_COUNT, WEB_PAGE, WP_IMAGE_COUNT, 0},
+      {0, 1, 0, 0, WP_MAX_AD_COUNT, WEB_PAGE, WP_MAX_AD_COUNT, 0},
+      {0, 2, 0, 0, WP_NULLS, WEB_PAGE, WP_NULLS, 0},
+      {0, 1, 0, 0, WP_SCD, WEB_PAGE, WP_SCD, 0},
+      {0, 32, 0, 0, WR_RETURNED_DATE_SK, WEB_RETURNS, WR_RETURNED_DATE_SK, 0},
+      {0, 32, 0, 0, WR_RETURNED_TIME_SK, WEB_RETURNS, WR_RETURNED_TIME_SK, 0},
+      {0, 16, 0, 0, WR_ITEM_SK, WEB_RETURNS, WR_ITEM_SK, 0},
+      {0,
+       16,
+       0,
+       0,
+       WR_REFUNDED_CUSTOMER_SK,
+       WEB_RETURNS,
+       WR_REFUNDED_CUSTOMER_SK,
+       0},
+      {0, 16, 0, 0, WR_REFUNDED_CDEMO_SK, WEB_RETURNS, WR_REFUNDED_CDEMO_SK, 0},
+      {0, 16, 0, 0, WR_REFUNDED_HDEMO_SK, WEB_RETURNS, WR_REFUNDED_HDEMO_SK, 0},
+      {0, 16, 0, 0, WR_REFUNDED_ADDR_SK, WEB_RETURNS, WR_REFUNDED_ADDR_SK, 0},
+      {0,
+       16,
+       0,
+       0,
+       WR_RETURNING_CUSTOMER_SK,
+       WEB_RETURNS,
+       WR_RETURNING_CUSTOMER_SK,
+       0},
+      {0,
+       16,
+       0,
+       0,
+       WR_RETURNING_CDEMO_SK,
+       WEB_RETURNS,
+       WR_RETURNING_CDEMO_SK,
+       0},
+      {0,
+       16,
+       0,
+       0,
+       WR_RETURNING_HDEMO_SK,
+       WEB_RETURNS,
+       WR_RETURNING_HDEMO_SK,
+       0},
+      {0, 16, 0, 0, WR_RETURNING_ADDR_SK, WEB_RETURNS, WR_RETURNING_ADDR_SK, 0},
+      {0, 16, 0, 0, WR_WEB_PAGE_SK, WEB_RETURNS, WR_WEB_PAGE_SK, 0},
+      {0, 16, 0, 0, WR_REASON_SK, WEB_RETURNS, WR_REASON_SK, 0},
+      {0, 0, 0, 0, WR_ORDER_NUMBER, WEB_RETURNS, WR_ORDER_NUMBER, 0},
+      {0, 0, 0, 0, WR_PRICING_QUANTITY, WEB_RETURNS, WR_PRICING_QUANTITY, 0},
+      {0, 0, 0, 0, WR_PRICING_NET_PAID, WEB_RETURNS, WR_PRICING_NET_PAID, 0},
+      {0, 0, 0, 0, WR_PRICING_EXT_TAX, WEB_RETURNS, WR_PRICING_EXT_TAX, 0},
+      {0,
+       0,
+       0,
+       0,
+       WR_PRICING_NET_PAID_INC_TAX,
+       WEB_RETURNS,
+       WR_PRICING_NET_PAID_INC_TAX,
+       0},
+      {0, 0, 0, 0, WR_PRICING_FEE, WEB_RETURNS, WR_PRICING_FEE, 0},
+      {0,
+       0,
+       0,
+       0,
+       WR_PRICING_EXT_SHIP_COST,
+       WEB_RETURNS,
+       WR_PRICING_EXT_SHIP_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WR_PRICING_REFUNDED_CASH,
+       WEB_RETURNS,
+       WR_PRICING_REFUNDED_CASH,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WR_PRICING_REVERSED_CHARGE,
+       WEB_RETURNS,
+       WR_PRICING_REVERSED_CHARGE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WR_PRICING_STORE_CREDIT,
+       WEB_RETURNS,
+       WR_PRICING_STORE_CREDIT,
+       0},
+      {0, 0, 0, 0, WR_PRICING_NET_LOSS, WEB_RETURNS, WR_PRICING_NET_LOSS, 0},
+      {0, 80, 0, 0, WR_PRICING, WEB_RETURNS, WR_PRICING, 0},
+      {0, 32, 0, 0, WR_NULLS, WEB_RETURNS, WR_NULLS, 0},
+      {0, 2, 0, 0, WS_SOLD_DATE_SK, WEB_SALES, WS_SOLD_DATE_SK, 0},
+      {0, 2, 0, 0, WS_SOLD_TIME_SK, WEB_SALES, WS_SOLD_TIME_SK, 0},
+      {0, 16, 0, 0, WS_SHIP_DATE_SK, WEB_SALES, WS_SHIP_DATE_SK, 0},
+      {0, 1, 0, 0, WS_ITEM_SK, WEB_SALES, WS_ITEM_SK, 0},
+      {0, 1, 0, 0, WS_BILL_CUSTOMER_SK, WEB_SALES, WS_BILL_CUSTOMER_SK, 0},
+      {0, 1, 0, 0, WS_BILL_CDEMO_SK, WEB_SALES, WS_BILL_CDEMO_SK, 0},
+      {0, 1, 0, 0, WS_BILL_HDEMO_SK, WEB_SALES, WS_BILL_HDEMO_SK, 0},
+      {0, 1, 0, 0, WS_BILL_ADDR_SK, WEB_SALES, WS_BILL_ADDR_SK, 0},
+      {0, 2, 0, 0, WS_SHIP_CUSTOMER_SK, WEB_SALES, WS_SHIP_CUSTOMER_SK, 0},
+      {0, 2, 0, 0, WS_SHIP_CDEMO_SK, WEB_SALES, WS_SHIP_CDEMO_SK, 0},
+      {0, 1, 0, 0, WS_SHIP_HDEMO_SK, WEB_SALES, WS_SHIP_HDEMO_SK, 0},
+      {0, 1, 0, 0, WS_SHIP_ADDR_SK, WEB_SALES, WS_SHIP_ADDR_SK, 0},
+      {0, 16, 0, 0, WS_WEB_PAGE_SK, WEB_SALES, WS_WEB_PAGE_SK, 0},
+      {0, 16, 0, 0, WS_WEB_SITE_SK, WEB_SALES, WS_WEB_SITE_SK, 0},
+      {0, 16, 0, 0, WS_SHIP_MODE_SK, WEB_SALES, WS_SHIP_MODE_SK, 0},
+      {0, 16, 0, 0, WS_WAREHOUSE_SK, WEB_SALES, WS_WAREHOUSE_SK, 0},
+      {0, 16, 0, 0, WS_PROMO_SK, WEB_SALES, WS_PROMO_SK, 0},
+      {0, 1, 0, 0, WS_ORDER_NUMBER, WEB_SALES, WS_ORDER_NUMBER, 0},
+      {0, 1, 0, 0, WS_PRICING_QUANTITY, WEB_SALES, WS_PRICING_QUANTITY, 0},
+      {0,
+       1,
+       0,
+       0,
+       WS_PRICING_WHOLESALE_COST,
+       WEB_SALES,
+       WS_PRICING_WHOLESALE_COST,
+       0},
+      {0, 0, 0, 0, WS_PRICING_LIST_PRICE, WEB_SALES, WS_PRICING_LIST_PRICE, 0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_SALES_PRICE,
+       WEB_SALES,
+       WS_PRICING_SALES_PRICE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_EXT_DISCOUNT_AMT,
+       WEB_SALES,
+       WS_PRICING_EXT_DISCOUNT_AMT,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_EXT_SALES_PRICE,
+       WEB_SALES,
+       WS_PRICING_EXT_SALES_PRICE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_EXT_WHOLESALE_COST,
+       WEB_SALES,
+       WS_PRICING_EXT_WHOLESALE_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_EXT_LIST_PRICE,
+       WEB_SALES,
+       WS_PRICING_EXT_LIST_PRICE,
+       0},
+      {0, 0, 0, 0, WS_PRICING_EXT_TAX, WEB_SALES, WS_PRICING_EXT_TAX, 0},
+      {0, 0, 0, 0, WS_PRICING_COUPON_AMT, WEB_SALES, WS_PRICING_COUPON_AMT, 0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_EXT_SHIP_COST,
+       WEB_SALES,
+       WS_PRICING_EXT_SHIP_COST,
+       0},
+      {0, 0, 0, 0, WS_PRICING_NET_PAID, WEB_SALES, WS_PRICING_NET_PAID, 0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_NET_PAID_INC_TAX,
+       WEB_SALES,
+       WS_PRICING_NET_PAID_INC_TAX,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_NET_PAID_INC_SHIP,
+       WEB_SALES,
+       WS_PRICING_NET_PAID_INC_SHIP,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       WS_PRICING_NET_PAID_INC_SHIP_TAX,
+       WEB_SALES,
+       WS_PRICING_NET_PAID_INC_SHIP_TAX,
+       0},
+      {0, 0, 0, 0, WS_PRICING_NET_PROFIT, WEB_SALES, WS_PRICING_NET_PROFIT, 0},
+      {0, 128, 0, 0, WS_PRICING, WEB_SALES, WS_PRICING, 0},
+      {0, 32, 0, 0, WS_NULLS, WEB_SALES, WS_NULLS, 0},
+      {0, 16, 0, 0, WR_IS_RETURNED, WEB_SALES, WR_IS_RETURNED, 0},
+      {0, 0, 0, 0, WS_PERMUTATION, WEB_SALES, WS_PERMUTATION, 0},
+      {0, 1, 0, 0, WEB_SITE_SK, WEB_SITE, WEB_SITE_SK, 0},
+      {0, 1, 0, 0, WEB_SITE_ID, WEB_SITE, WEB_SITE_ID, 0},
+      {0, 1, 0, 0, WEB_REC_START_DATE_ID, WEB_SITE, WEB_REC_START_DATE_ID, 0},
+      {0, 1, 0, 0, WEB_REC_END_DATE_ID, WEB_SITE, WEB_REC_END_DATE_ID, 0},
+      {0, 1, 0, 0, WEB_NAME, WEB_SITE, WEB_NAME, 0},
+      {0, 1, 0, 0, WEB_OPEN_DATE, WEB_SITE, WEB_OPEN_DATE, 0},
+      {0, 1, 0, 0, WEB_CLOSE_DATE, WEB_SITE, WEB_CLOSE_DATE, 0},
+      {0, 1, 0, 0, WEB_CLASS, WEB_SITE, WEB_CLASS, 0},
+      {0, 2, 0, 0, WEB_MANAGER, WEB_SITE, WEB_MANAGER, 0},
+      {0, 1, 0, 0, WEB_MARKET_ID, WEB_SITE, WEB_MARKET_ID, 0},
+      {0, 20, 0, 0, WEB_MARKET_CLASS, WEB_SITE, WEB_MARKET_CLASS, 0},
+      {0, 100, 0, 0, WEB_MARKET_DESC, WEB_SITE, WEB_MARKET_DESC, 0},
+      {0, 2, 0, 0, WEB_MARKET_MANAGER, WEB_SITE, WEB_MARKET_MANAGER, 0},
+      {0, 1, 0, 0, WEB_COMPANY_ID, WEB_SITE, WEB_COMPANY_ID, 0},
+      {0, 1, 0, 0, WEB_COMPANY_NAME, WEB_SITE, WEB_COMPANY_NAME, 0},
+      {0, 1, 0, 0, WEB_ADDRESS_STREET_NUM, WEB_SITE, WEB_ADDRESS_STREET_NUM, 0},
+      {0,
+       1,
+       0,
+       0,
+       WEB_ADDRESS_STREET_NAME1,
+       WEB_SITE,
+       WEB_ADDRESS_STREET_NAME1,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       WEB_ADDRESS_STREET_TYPE,
+       WEB_SITE,
+       WEB_ADDRESS_STREET_TYPE,
+       0},
+      {0, 1, 0, 0, WEB_ADDRESS_SUITE_NUM, WEB_SITE, WEB_ADDRESS_SUITE_NUM, 0},
+      {0, 1, 0, 0, WEB_ADDRESS_CITY, WEB_SITE, WEB_ADDRESS_CITY, 0},
+      {0, 1, 0, 0, WEB_ADDRESS_COUNTY, WEB_SITE, WEB_ADDRESS_COUNTY, 0},
+      {0, 1, 0, 0, WEB_ADDRESS_STATE, WEB_SITE, WEB_ADDRESS_STATE, 0},
+      {0, 1, 0, 0, WEB_ADDRESS_ZIP, WEB_SITE, WEB_ADDRESS_ZIP, 0},
+      {0, 1, 0, 0, WEB_ADDRESS_COUNTRY, WEB_SITE, WEB_ADDRESS_COUNTRY, 0},
+      {0, 1, 0, 0, WEB_ADDRESS_GMT_OFFSET, WEB_SITE, WEB_ADDRESS_GMT_OFFSET, 0},
+      {0, 1, 0, 0, WEB_TAX_PERCENTAGE, WEB_SITE, WEB_TAX_PERCENTAGE, 0},
+      {0, 2, 0, 0, WEB_NULLS, WEB_SITE, WEB_NULLS, 0},
+      {0, 7, 0, 0, WEB_ADDRESS, WEB_SITE, WEB_ADDRESS, 0},
+      {0, 70, 0, 0, WEB_SCD, WEB_SITE, WEB_SCD, 0},
+      {0, 0, 0, 0, DV_VERSION, DBGEN_VERSION, DV_VERSION, 0},
+      {0, 0, 0, 0, DV_CREATE_DATE, DBGEN_VERSION, DV_CREATE_DATE, 0},
+      {0, 0, 0, 0, DV_CREATE_TIME, DBGEN_VERSION, DV_CREATE_TIME, 0},
+      {0, 0, 0, 0, DV_CMDLINE_ARGS, DBGEN_VERSION, DV_CMDLINE_ARGS, 0},
+      {0, 0, 0, 0, VALIDATE_STREAM, DBGEN_VERSION, VALIDATE_STREAM, 0},
+      {0, 0, 0, 0, S_BRAND_ID, S_BRAND, S_BRAND_ID, 0},
+      {0, 0, 0, 0, S_BRAND_SUBCLASS_ID, S_BRAND, S_BRAND_SUBCLASS_ID, 0},
+      {0, 1, 0, 0, S_BRAND_MANAGER_ID, S_BRAND, S_BRAND_MANAGER_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_BRAND_MANUFACTURER_ID,
+       S_BRAND,
+       S_BRAND_MANUFACTURER_ID,
+       0},
+      {0, 6, 0, 0, S_BRAND_NAME, S_BRAND, S_BRAND_NAME, 0},
+      {0, 0, 0, 0, S_CADR_ID, S_CUSTOMER_ADDRESS, S_CADR_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_STREET_NUMBER,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_STREET_NUMBER,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_STREET_NAME1,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_STREET_NAME1,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_STREET_NAME2,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_STREET_NAME2,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_STREET_TYPE,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_STREET_TYPE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_SUITE_NUM,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_SUITE_NUM,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_CITY,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_CITY,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_COUNTY,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_COUNTY,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_STATE,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_STATE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_ZIP,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_ZIP,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CADR_ADDRESS_COUNTRY,
+       S_CUSTOMER_ADDRESS,
+       S_CADR_ADDRESS_COUNTRY,
+       0},
+      {0, 7, 0, 0, S_BADDR_ADDRESS, S_CUSTOMER_ADDRESS, CA_ADDRESS, 0},
+      {0, 1, 0, 0, S_CALL_CENTER_ID, S_CALL_CENTER, S_CALL_CENTER_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CALL_CENTER_DIVISION_ID,
+       S_CALL_CENTER,
+       S_CALL_CENTER_DIVISION_ID,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CALL_CENTER_OPEN_DATE,
+       S_CALL_CENTER,
+       S_CALL_CENTER_OPEN_DATE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_CALL_CENTER_CLOSED_DATE,
+       S_CALL_CENTER,
+       S_CALL_CENTER_CLOSED_DATE,
+       0},
+      {0, 0, 0, 0, S_CALL_CENTER_NAME, S_CALL_CENTER, S_CALL_CENTER_NAME, 0},
+      {0, 0, 0, 0, S_CALL_CENTER_CLASS, S_CALL_CENTER, S_CALL_CENTER_CLASS, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CALL_CENTER_EMPLOYEES,
+       S_CALL_CENTER,
+       S_CALL_CENTER_EMPLOYEES,
+       0},
+      {0, 1, 0, 0, S_CALL_CENTER_SQFT, S_CALL_CENTER, S_CALL_CENTER_SQFT, 0},
+      {0, 1, 0, 0, S_CALL_CENTER_HOURS, S_CALL_CENTER, S_CALL_CENTER_HOURS, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CALL_CENTER_MANAGER_ID,
+       S_CALL_CENTER,
+       S_CALL_CENTER_MANAGER_ID,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CALL_CENTER_MARKET_ID,
+       S_CALL_CENTER,
+       S_CALL_CENTER_MARKET_ID,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CALL_CENTER_ADDRESS_ID,
+       S_CALL_CENTER,
+       S_CALL_CENTER_ADDRESS_ID,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CALL_CENTER_TAX_PERCENTAGE,
+       S_CALL_CENTER,
+       S_CALL_CENTER_TAX_PERCENTAGE,
+       0},
+      {0, 1, 0, 0, S_CALL_CENTER_SCD, S_CALL_CENTER, S_CALL_CENTER_SCD, 0},
+      {0, 0, 0, 0, S_CATALOG_NUMBER, S_CATALOG, S_CATALOG_NUMBER, 0},
+      {0, 1, 0, 0, S_CATALOG_START_DATE, S_CATALOG, S_CATALOG_START_DATE, 0},
+      {0, 1, 0, 0, S_CATALOG_END_DATE, S_CATALOG, S_CATALOG_END_DATE, 0},
+      {0, 10, 0, 0, S_CATALOG_DESC, S_CATALOG, S_CATALOG_DESC, 0},
+      {0, 1, 0, 0, S_CATALOG_TYPE, S_CATALOG, S_CATALOG_TYPE, 0},
+      {0, 0, 0, 0, S_CORD_ID, S_CATALOG_ORDER, S_CORD_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CORD_BILL_CUSTOMER_ID,
+       S_CATALOG_ORDER,
+       S_CORD_BILL_CUSTOMER_ID,
+       0},
+      {0,
+       2,
+       0,
+       0,
+       S_CORD_SHIP_CUSTOMER_ID,
+       S_CATALOG_ORDER,
+       S_CORD_SHIP_CUSTOMER_ID,
+       0},
+      {0, 1, 0, 0, S_CORD_ORDER_DATE, S_CATALOG_ORDER, S_CORD_ORDER_DATE, 0},
+      {0, 1, 0, 0, S_CORD_ORDER_TIME, S_CATALOG_ORDER, S_CORD_ORDER_TIME, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CORD_SHIP_MODE_ID,
+       S_CATALOG_ORDER,
+       S_CORD_SHIP_MODE_ID,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CORD_CALL_CENTER_ID,
+       S_CATALOG_ORDER,
+       S_CORD_CALL_CENTER_ID,
+       0},
+      {0, 1, 0, 0, S_CLIN_ITEM_ID, S_CATALOG_ORDER, S_CLIN_ITEM_ID, 0},
+      {0, 100, 0, 0, S_CORD_COMMENT, S_CATALOG_ORDER, S_CORD_COMMENT, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CLIN_ORDER_ID,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_ORDER_ID,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_CLIN_LINE_NUMBER,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_LINE_NUMBER,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CLIN_PROMOTION_ID,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_PROMOTION_ID,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CLIN_QUANTITY,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_QUANTITY,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CLIN_COUPON_AMT,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_COUPON_AMT,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CLIN_WAREHOUSE_ID,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_WAREHOUSE_ID,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CLIN_SHIP_DATE,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_SHIP_DATE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CLIN_CATALOG_ID,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_CATALOG_ID,
+       0},
+      {0,
+       2,
+       0,
+       0,
+       S_CLIN_CATALOG_PAGE_ID,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_CATALOG_PAGE_ID,
+       0},
+      {0, 8, 0, 0, S_CLIN_PRICING, S_CATALOG_ORDER_LINEITEM, S_CLIN_PRICING, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_CLIN_SHIP_COST,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_SHIP_COST,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CLIN_IS_RETURNED,
+       S_CATALOG_ORDER_LINEITEM,
+       S_CLIN_IS_RETURNED,
+       0},
+      {0, 0, 0, 0, S_CLIN_PERMUTE, S_CATALOG_ORDER_LINEITEM, S_CLIN_PERMUTE, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_CATALOG_PAGE_CATALOG_NUMBER,
+       S_CATALOG_PAGE,
+       S_CATALOG_PAGE_CATALOG_NUMBER,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_CATALOG_PAGE_NUMBER,
+       S_CATALOG_PAGE,
+       S_CATALOG_PAGE_NUMBER,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CATALOG_PAGE_DEPARTMENT,
+       S_CATALOG_PAGE,
+       S_CATALOG_PAGE_DEPARTMENT,
+       0},
+      {0, 1, 0, 0, S_CP_ID, S_CATALOG_PAGE, S_CP_ID, 0},
+      {0, 1, 0, 0, S_CP_START_DATE, S_CATALOG_PAGE, S_CP_START_DATE, 0},
+      {0, 1, 0, 0, S_CP_END_DATE, S_CATALOG_PAGE, S_CP_END_DATE, 0},
+      {0, 100, 0, 0, S_CP_DESCRIPTION, S_CATALOG_PAGE, CP_DESCRIPTION, 0},
+      {0, 1, 0, 0, S_CP_TYPE, S_CATALOG_PAGE, S_CP_TYPE, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CATALOG_PROMOTIONAL_ITEM_CATALOG_NUMBER,
+       S_CATALOG_PROMOTIONAL_ITEM,
+       S_CATALOG_PROMOTIONAL_ITEM_CATALOG_NUMBER,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CATALOG_PROMOTIONAL_ITEM_CATALOG_PAGE_NUMBER,
+       S_CATALOG_PROMOTIONAL_ITEM,
+       S_CATALOG_PROMOTIONAL_ITEM_CATALOG_PAGE_NUMBER,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CATALOG_PROMOTIONAL_ITEM_ITEM_ID,
+       S_CATALOG_PROMOTIONAL_ITEM,
+       S_CATALOG_PROMOTIONAL_ITEM_ITEM_ID,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_CATALOG_PROMOTIONAL_ITEM_PROMOTION_ID,
+       S_CATALOG_PROMOTIONAL_ITEM,
+       S_CATALOG_PROMOTIONAL_ITEM_PROMOTION_ID,
+       0},
+      {0,
+       9,
+       0,
+       0,
+       S_CRET_CALL_CENTER_ID,
+       S_CATALOG_RETURNS,
+       S_CRET_CALL_CENTER_ID,
+       0},
+      {0, 0, 0, 0, S_CRET_ORDER_ID, S_CATALOG_RETURNS, S_CRET_ORDER_ID, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_CRET_LINE_NUMBER,
+       S_CATALOG_RETURNS,
+       S_CRET_LINE_NUMBER,
+       0},
+      {0, 0, 0, 0, S_CRET_ITEM_ID, S_CATALOG_RETURNS, S_CRET_ITEM_ID, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_CRET_RETURN_CUSTOMER_ID,
+       S_CATALOG_RETURNS,
+       S_CRET_RETURN_CUSTOMER_ID,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_CRET_REFUND_CUSTOMER_ID,
+       S_CATALOG_RETURNS,
+       S_CRET_REFUND_CUSTOMER_ID,
+       0},
+      {0, 9, 0, 0, S_CRET_DATE, S_CATALOG_RETURNS, S_CRET_DATE, 0},
+      {0, 18, 0, 0, S_CRET_TIME, S_CATALOG_RETURNS, S_CRET_TIME, 0},
+      {0, 0, 0, 0, S_CRET_QUANTITY, S_CATALOG_RETURNS, S_CRET_QUANTITY, 0},
+      {0, 0, 0, 0, S_CRET_AMOUNT, S_CATALOG_RETURNS, S_CRET_AMOUNT, 0},
+      {0, 0, 0, 0, S_CRET_TAX, S_CATALOG_RETURNS, S_CRET_TAX, 0},
+      {0, 0, 0, 0, S_CRET_FEE, S_CATALOG_RETURNS, S_CRET_FEE, 0},
+      {0, 0, 0, 0, S_CRET_SHIP_COST, S_CATALOG_RETURNS, S_CRET_SHIP_COST, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_CRET_REFUNDED_CASH,
+       S_CATALOG_RETURNS,
+       S_CRET_REFUNDED_CASH,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_CRET_REVERSED_CHARGE,
+       S_CATALOG_RETURNS,
+       S_CRET_REVERSED_CHARGE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_CRET_MERCHANT_CREDIT,
+       S_CATALOG_RETURNS,
+       S_CRET_MERCHANT_CREDIT,
+       0},
+      {0, 9, 0, 0, S_CRET_REASON_ID, S_CATALOG_RETURNS, S_CRET_REASON_ID, 0},
+      {0, 72, 0, 0, S_CRET_PRICING, S_CATALOG_RETURNS, S_CRET_PRICING, 0},
+      {0,
+       9,
+       0,
+       0,
+       S_CRET_SHIPMODE_ID,
+       S_CATALOG_RETURNS,
+       S_CRET_SHIPMODE_ID,
+       0},
+      {0,
+       9,
+       0,
+       0,
+       S_CRET_WAREHOUSE_ID,
+       S_CATALOG_RETURNS,
+       S_CRET_WAREHOUSE_ID,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_CRET_CATALOG_PAGE_ID,
+       S_CATALOG_RETURNS,
+       S_CRET_CATALOG_PAGE_ID,
+       0},
+      {0, 0, 0, 0, S_CATEGORY_ID, S_CATEGORY, S_CATEGORY_ID, 0},
+      {0, 0, 0, 0, S_CATEGORY_NAME, S_CATEGORY, S_CATEGORY_NAME, 0},
+      {0, 10, 0, 0, S_CATEGORY_DESC, S_CATEGORY, S_CATEGORY_DESC, 0},
+      {0, 0, 0, 0, S_CLASS_ID, S_CLASS, S_CLASS_ID, 0},
+      {0, 1, 0, 0, S_CLASS_SUBCAT_ID, S_CLASS, S_CLASS_SUBCAT_ID, 0},
+      {0, 10, 0, 0, S_CLASS_DESC, S_CLASS, S_CLASS_DESC, 0},
+      {0, 0, 0, 0, S_COMPANY_ID, S_COMPANY, S_COMPANY_ID, 0},
+      {0, 0, 0, 0, S_COMPANY_NAME, S_COMPANY, S_COMPANY_NAME, 0},
+      {0, 0, 0, 0, S_CUST_ID, S_CUSTOMER, S_CUST_ID, 0},
+      {0, 1, 0, 0, S_CUST_SALUTATION, S_CUSTOMER, S_CUST_SALUTATION, 0},
+      {0, 1, 0, 0, S_CUST_LAST_NAME, S_CUSTOMER, S_CUST_LAST_NAME, 0},
+      {0, 1, 0, 0, S_CUST_FIRST_NAME, S_CUSTOMER, S_CUST_FIRST_NAME, 0},
+      {0, 1, 0, 0, S_CUST_PREFERRED_FLAG, S_CUSTOMER, S_CUST_PREFERRED_FLAG, 0},
+      {0, 1, 0, 0, S_CUST_BIRTH_DATE, S_CUSTOMER, S_CUST_BIRTH_DATE, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_FIRST_PURCHASE_DATE,
+       S_CUSTOMER,
+       S_CUST_FIRST_PURCHASE_DATE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_FIRST_SHIPTO_DATE,
+       S_CUSTOMER,
+       S_CUST_FIRST_SHIPTO_DATE,
+       0},
+      {0, 1, 0, 0, S_CUST_BIRTH_COUNTRY, S_CUSTOMER, S_CUST_BIRTH_COUNTRY, 0},
+      {0, 25, 0, 0, S_CUST_LOGIN, S_CUSTOMER, S_CUST_LOGIN, 0},
+      {0, 23, 0, 0, S_CUST_EMAIL, S_CUSTOMER, S_CUST_EMAIL, 0},
+      {0, 1, 0, 0, S_CUST_LAST_LOGIN, S_CUSTOMER, S_CUST_LAST_LOGIN, 0},
+      {0, 1, 0, 0, S_CUST_LAST_REVIEW, S_CUSTOMER, S_CUST_LAST_REVIEW, 0},
+      {0,
+       4,
+       0,
+       0,
+       S_CUST_PRIMARY_MACHINE,
+       S_CUSTOMER,
+       S_CUST_PRIMARY_MACHINE,
+       0},
+      {0,
+       4,
+       0,
+       0,
+       S_CUST_SECONDARY_MACHINE,
+       S_CUSTOMER,
+       S_CUST_SECONDARY_MACHINE,
+       0},
+      {0, 7, 0, 0, S_CUST_ADDRESS, S_CUSTOMER, S_CUST_ADDRESS, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_ADDRESS_STREET_NUM,
+       S_CUSTOMER,
+       S_CUST_ADDRESS_STREET_NUM,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_ADDRESS_STREET_NAME1,
+       S_CUSTOMER,
+       S_CUST_ADDRESS_STREET_NAME1,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_ADDRESS_STREET_NAME2,
+       S_CUSTOMER,
+       S_CUST_ADDRESS_STREET_NAME2,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_ADDRESS_STREET_TYPE,
+       S_CUSTOMER,
+       S_CUST_ADDRESS_STREET_TYPE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_ADDRESS_SUITE_NUM,
+       S_CUSTOMER,
+       S_CUST_ADDRESS_SUITE_NUM,
+       0},
+      {0, 1, 0, 0, S_CUST_ADDRESS_CITY, S_CUSTOMER, S_CUST_ADDRESS_CITY, 0},
+      {0, 1, 0, 0, S_CUST_ADDRESS_ZIP, S_CUSTOMER, S_CUST_ADDRESS_ZIP, 0},
+      {0, 1, 0, 0, S_CUST_ADDRESS_COUNTY, S_CUSTOMER, S_CUST_ADDRESS_COUNTY, 0},
+      {0, 1, 0, 0, S_CUST_ADDRESS_STATE, S_CUSTOMER, S_CUST_ADDRESS_STATE, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_ADDRESS_COUNTRY,
+       S_CUSTOMER,
+       S_CUST_ADDRESS_COUNTRY,
+       0},
+      {0, 1, 0, 0, S_CUST_LOCATION_TYPE, S_CUSTOMER, S_CUST_LOCATION_TYPE, 0},
+      {0, 1, 0, 0, S_CUST_GENDER, S_CUSTOMER, S_CUST_GENDER, 0},
+      {0, 1, 0, 0, S_CUST_MARITAL_STATUS, S_CUSTOMER, S_CUST_MARITAL_STATUS, 0},
+      {0, 1, 0, 0, S_CUST_EDUCATION, S_CUSTOMER, S_CUST_EDUCATION, 0},
+      {0, 1, 0, 0, S_CUST_CREDIT_RATING, S_CUSTOMER, S_CUST_CREDIT_RATING, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_CUST_PURCHASE_ESTIMATE,
+       S_CUSTOMER,
+       S_CUST_PURCHASE_ESTIMATE,
+       0},
+      {0, 1, 0, 0, S_CUST_BUY_POTENTIAL, S_CUSTOMER, S_CUST_BUY_POTENTIAL, 0},
+      {0, 1, 0, 0, S_CUST_DEPENDENT_CNT, S_CUSTOMER, S_CUST_DEPENDENT_CNT, 0},
+      {0, 1, 0, 0, S_CUST_EMPLOYED_CNT, S_CUSTOMER, S_CUST_EMPLOYED_CNT, 0},
+      {0, 1, 0, 0, S_CUST_COLLEGE_CNT, S_CUSTOMER, S_CUST_COLLEGE_CNT, 0},
+      {0, 1, 0, 0, S_CUST_VEHICLE_CNT, S_CUSTOMER, S_CUST_VEHICLE_CNT, 0},
+      {0, 1, 0, 0, S_CUST_INCOME, S_CUSTOMER, S_CUST_INCOME, 0},
+      {0, 0, 0, 0, S_DIVISION_ID, S_DIVISION, S_DIVISION_ID, 0},
+      {0, 0, 0, 0, S_DIVISION_COMPANY, S_DIVISION, S_DIVISION_COMPANY, 0},
+      {0, 0, 0, 0, S_DIVISION_NAME, S_DIVISION, S_DIVISION_NAME, 0},
+      {0, 1, 0, 0, S_INVN_WAREHOUSE, S_INVENTORY, S_INVN_WAREHOUSE, 0},
+      {0, 1, 0, 0, S_INVN_ITEM, S_INVENTORY, S_INVN_ITEM, 0},
+      {0, 2, 0, 0, S_INVN_DATE, S_INVENTORY, S_INVN_DATE, 0},
+      {0, 1, 0, 0, S_INVN_QUANTITY, S_INVENTORY, S_INVN_QUANTITY, 0},
+      {0, 1, 0, 0, S_ITEM_ID, S_ITEM, S_ITEM_ID, 0},
+      {0, 0, 0, 0, S_ITEM_PERMUTE, S_ITEM, S_ITEM_PERMUTE, 0},
+      {0, 1, 0, 0, S_ITEM_PRODUCT_ID, S_ITEM, S_ITEM_PRODUCT_ID, 0},
+      {0, 200, 0, 0, S_ITEM_DESC, S_ITEM, I_ITEM_DESC, 0},
+      {0, 2, 0, 0, S_ITEM_LIST_PRICE, S_ITEM, I_CURRENT_PRICE, 0},
+      {0, 1, 0, 0, S_ITEM_WHOLESALE_COST, S_ITEM, I_WHOLESALE_COST, 0},
+      {0, 1, 0, 0, S_ITEM_MANAGER_ID, S_ITEM, I_MANAGER_ID, 0},
+      {0, 1, 0, 0, S_ITEM_SIZE, S_ITEM, I_SIZE, 0},
+      {0, 50, 0, 0, S_ITEM_FORMULATION, S_ITEM, I_FORMULATION, 0},
+      {0, 1, 0, 0, S_ITEM_FLAVOR, S_ITEM, I_COLOR, 0},
+      {0, 1, 0, 0, S_ITEM_UNITS, S_ITEM, I_UNITS, 0},
+      {0, 1, 0, 0, S_ITEM_CONTAINER, S_ITEM, I_CONTAINER, 0},
+      {0, 1, 0, 0, S_ITEM_SCD, S_ITEM, I_SCD, 0},
+      {0, 0, 0, 0, S_MANAGER_ID, S_MANAGER, S_MANAGER_ID, 0},
+      {0, 2, 0, 0, S_MANAGER_NAME, S_MANAGER, S_MANAGER_NAME, 0},
+      {0, 0, 0, 0, S_MANUFACTURER_ID, S_MANUFACTURER, S_MANUFACTURER_ID, 0},
+      {0, 0, 0, 0, S_MANUFACTURER_NAME, S_MANUFACTURER, S_MANUFACTURER_NAME, 0},
+      {0, 0, 0, 0, S_MARKET_ID, S_MARKET, S_MARKET_ID, 0},
+      {0, 0, 0, 0, S_MARKET_CLASS_NAME, S_MARKET, S_MARKET_CLASS_NAME, 0},
+      {0, 10, 0, 0, S_MARKET_DESC, S_MARKET, S_MARKET_DESC, 0},
+      {0, 1, 0, 0, S_MARKET_MANAGER_ID, S_MARKET, S_MARKET_MANAGER_ID, 0},
+      {0, 0, 0, 0, S_PRODUCT_ID, S_PRODUCT, S_PRODUCT_ID, 0},
+      {0, 1, 0, 0, S_PRODUCT_BRAND_ID, S_PRODUCT, S_PRODUCT_BRAND_ID, 0},
+      {0, 0, 0, 0, S_PRODUCT_NAME, S_PRODUCT, S_PRODUCT_NAME, 0},
+      {0, 1, 0, 0, S_PRODUCT_TYPE, S_PRODUCT, S_PRODUCT_TYPE, 0},
+      {0, 1, 0, 0, S_PROMOTION_ID, S_PROMOTION, S_PROMOTION_ID, 0},
+      {0, 1, 0, 0, S_PROMOTION_ITEM_ID, S_PROMOTION, S_PROMOTION_ITEM_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_PROMOTION_START_DATE,
+       S_PROMOTION,
+       S_PROMOTION_START_DATE,
+       0},
+      {0, 1, 0, 0, S_PROMOTION_END_DATE, S_PROMOTION, S_PROMOTION_END_DATE, 0},
+      {0, 1, 0, 0, S_PROMOTION_COST, S_PROMOTION, S_PROMOTION_COST, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_PROMOTION_RESPONSE_TARGET,
+       S_PROMOTION,
+       S_PROMOTION_RESPONSE_TARGET,
+       0},
+      {0, 0, 0, 0, S_PROMOTION_DMAIL, S_PROMOTION, S_PROMOTION_DMAIL, 0},
+      {0, 0, 0, 0, S_PROMOTION_EMAIL, S_PROMOTION, S_PROMOTION_EMAIL, 0},
+      {0, 0, 0, 0, S_PROMOTION_CATALOG, S_PROMOTION, S_PROMOTION_CATALOG, 0},
+      {0, 0, 0, 0, S_PROMOTION_TV, S_PROMOTION, S_PROMOTION_TV, 0},
+      {0, 0, 0, 0, S_PROMOTION_RADIO, S_PROMOTION, S_PROMOTION_RADIO, 0},
+      {0, 0, 0, 0, S_PROMOTION_PRESS, S_PROMOTION, S_PROMOTION_PRESS, 0},
+      {0, 0, 0, 0, S_PROMOTION_EVENT, S_PROMOTION, S_PROMOTION_EVENT, 0},
+      {0, 0, 0, 0, S_PROMOTION_DEMO, S_PROMOTION, S_PROMOTION_DEMO, 0},
+      {0, 100, 0, 0, S_PROMOTION_DETAILS, S_PROMOTION, P_CHANNEL_DETAILS, 0},
+      {0, 1, 0, 0, S_PROMOTION_PURPOSE, S_PROMOTION, S_PROMOTION_PURPOSE, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_PROMOTION_DISCOUNT_ACTIVE,
+       S_PROMOTION,
+       S_PROMOTION_DISCOUNT_ACTIVE,
+       0},
+      {0,
+       1,
+       0,
+       0,
+       S_PROMOTION_DISCOUNT_PCT,
+       S_PROMOTION,
+       S_PROMOTION_DISCOUNT_PCT,
+       0},
+      {0, 0, 0, 0, S_PROMOTION_NAME, S_PROMOTION, S_PROMOTION_NAME, 0},
+      {0, 1, 0, 0, S_PROMOTION_BITFIELD, S_PROMOTION, S_PROMOTION_BITFIELD, 0},
+      {0, 0, 0, 0, S_PURCHASE_ID, S_PURCHASE, S_PURCHASE_ID, 0},
+      {0, 1, 0, 0, S_PURCHASE_STORE_ID, S_PURCHASE, S_PURCHASE_STORE_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_PURCHASE_CUSTOMER_ID,
+       S_PURCHASE,
+       S_PURCHASE_CUSTOMER_ID,
+       0},
+      {0, 1, 0, 0, S_PURCHASE_DATE, S_PURCHASE, S_PURCHASE_DATE, 0},
+      {0, 1, 0, 0, S_PURCHASE_TIME, S_PURCHASE, S_PURCHASE_TIME, 0},
+      {0, 1, 0, 0, S_PURCHASE_REGISTER, S_PURCHASE, S_PURCHASE_REGISTER, 0},
+      {0, 1, 0, 0, S_PURCHASE_CLERK, S_PURCHASE, S_PURCHASE_CLERK, 0},
+      {0, 100, 0, 0, S_PURCHASE_COMMENT, S_PURCHASE, S_PURCHASE_COMMENT, 0},
+      {0, 7, 0, 0, S_PURCHASE_PRICING, S_PURCHASE, S_PURCHASE_PRICING, 0},
+      {0, 1, 0, 0, S_PLINE_ITEM_ID, S_PURCHASE, S_PLINE_ITEM_ID, 0},
+      {0,
+       12,
+       0,
+       0,
+       S_PLINE_PURCHASE_ID,
+       S_PURCHASE_LINEITEM,
+       S_PLINE_PURCHASE_ID,
+       0},
+      {0, 12, 0, 0, S_PLINE_NUMBER, S_PURCHASE_LINEITEM, S_PLINE_NUMBER, 0},
+      {0,
+       12,
+       0,
+       0,
+       S_PLINE_PROMOTION_ID,
+       S_PURCHASE_LINEITEM,
+       S_PLINE_PROMOTION_ID,
+       0},
+      {0,
+       12,
+       0,
+       0,
+       S_PLINE_SALE_PRICE,
+       S_PURCHASE_LINEITEM,
+       S_PLINE_SALE_PRICE,
+       0},
+      {0, 12, 0, 0, S_PLINE_QUANTITY, S_PURCHASE_LINEITEM, S_PLINE_QUANTITY, 0},
+      {0,
+       12,
+       0,
+       0,
+       S_PLINE_COUPON_AMT,
+       S_PURCHASE_LINEITEM,
+       S_PLINE_COUPON_AMT,
+       0},
+      {0, 1200, 0, 0, S_PLINE_COMMENT, S_PURCHASE_LINEITEM, S_PLINE_COMMENT, 0},
+      {0, 96, 0, 0, S_PLINE_PRICING, S_PURCHASE_LINEITEM, S_PLINE_PRICING, 0},
+      {0,
+       12,
+       0,
+       0,
+       S_PLINE_IS_RETURNED,
+       S_PURCHASE_LINEITEM,
+       S_PLINE_IS_RETURNED,
+       0},
+      {0, 0, 0, 0, S_PLINE_PERMUTE, S_PURCHASE_LINEITEM, S_PLINE_PERMUTE, 0},
+      {0, 0, 0, 0, S_REASON_ID, S_REASON, S_REASON_ID, 0},
+      {0, 10, 0, 0, S_REASON_DESC, S_REASON, S_REASON_DESC, 0},
+      {0, 1, 0, 0, S_STORE_ID, S_STORE, S_STORE_ID, 0},
+      {0, 1, 0, 0, S_STORE_ADDRESS_ID, S_STORE, S_STORE_ADDRESS_ID, 0},
+      {0, 1, 0, 0, S_STORE_DIVISION_ID, S_STORE, S_STORE_DIVISION_ID, 0},
+      {0, 1, 0, 0, S_STORE_OPEN_DATE, S_STORE, S_STORE_OPEN_DATE, 0},
+      {0, 1, 0, 0, S_STORE_CLOSE_DATE, S_STORE, S_STORE_CLOSE_DATE, 0},
+      {0, 0, 0, 0, S_STORE_NAME, S_STORE, S_STORE_NAME, 0},
+      {0, 0, 0, 0, S_STORE_CLASS, S_STORE, S_STORE_CLASS, 0},
+      {0, 1, 0, 0, S_STORE_EMPLOYEES, S_STORE, S_STORE_EMPLOYEES, 0},
+      {0, 1, 0, 0, S_STORE_FLOOR_SPACE, S_STORE, S_STORE_FLOOR_SPACE, 0},
+      {0, 1, 0, 0, S_STORE_HOURS, S_STORE, S_STORE_HOURS, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_STORE_MARKET_MANAGER_ID,
+       S_STORE,
+       S_STORE_MARKET_MANAGER_ID,
+       0},
+      {0, 1, 0, 0, S_STORE_MANAGER_ID, S_STORE, S_STORE_MANAGER_ID, 0},
+      {0, 1, 0, 0, S_STORE_MARKET_ID, S_STORE, S_STORE_MARKET_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_STORE_GEOGRAPHY_CLASS,
+       S_STORE,
+       S_STORE_GEOGRAPHY_CLASS,
+       0},
+      {0, 1, 0, 0, S_STORE_TAX_PERCENTAGE, S_STORE, S_STORE_TAX_PERCENTAGE, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_SITM_PROMOTION_ID,
+       S_STORE_PROMOTIONAL_ITEM,
+       S_SITM_PROMOTION_ID,
+       0},
+      {0, 1, 0, 0, S_SITM_ITEM_ID, S_STORE_PROMOTIONAL_ITEM, S_SITM_ITEM_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_SITM_STORE_ID,
+       S_STORE_PROMOTIONAL_ITEM,
+       S_SITM_STORE_ID,
+       0},
+      {0, 0, 0, 0, S_SRET_STORE_ID, S_STORE_RETURNS, S_SRET_STORE_ID, 0},
+      {0, 0, 0, 0, S_SRET_PURCHASE_ID, S_STORE_RETURNS, S_SRET_PURCHASE_ID, 0},
+      {0, 0, 0, 0, S_SRET_LINENUMBER, S_STORE_RETURNS, S_SRET_LINENUMBER, 0},
+      {0, 0, 0, 0, S_SRET_ITEM_ID, S_STORE_RETURNS, S_SRET_ITEM_ID, 0},
+      {0, 0, 0, 0, S_SRET_CUSTOMER_ID, S_STORE_RETURNS, S_SRET_CUSTOMER_ID, 0},
+      {0, 24, 0, 0, S_SRET_RETURN_DATE, S_STORE_RETURNS, S_SRET_RETURN_DATE, 0},
+      {0, 12, 0, 0, S_SRET_RETURN_TIME, S_STORE_RETURNS, S_SRET_RETURN_TIME, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_SRET_TICKET_NUMBER,
+       S_STORE_RETURNS,
+       S_SRET_TICKET_NUMBER,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_SRET_RETURN_QUANTITY,
+       S_STORE_RETURNS,
+       S_SRET_RETURN_QUANTITY,
+       0},
+      {0, 0, 0, 0, S_SRET_RETURN_AMT, S_STORE_RETURNS, S_SRET_RETURN_AMT, 0},
+      {0, 0, 0, 0, S_SRET_RETURN_TAX, S_STORE_RETURNS, S_SRET_RETURN_TAX, 0},
+      {0, 0, 0, 0, S_SRET_RETURN_FEE, S_STORE_RETURNS, S_SRET_RETURN_FEE, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_SRET_RETURN_SHIP_COST,
+       S_STORE_RETURNS,
+       S_SRET_RETURN_SHIP_COST,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_SRET_REFUNDED_CASH,
+       S_STORE_RETURNS,
+       S_SRET_REFUNDED_CASH,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_SRET_REVERSED_CHARGE,
+       S_STORE_RETURNS,
+       S_SRET_REVERSED_CHARGE,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_SRET_MERCHANT_CREDIT,
+       S_STORE_RETURNS,
+       S_SRET_MERCHANT_CREDIT,
+       0},
+      {0, 12, 0, 0, S_SRET_REASON_ID, S_STORE_RETURNS, S_SRET_REASON_ID, 0},
+      {0, 84, 0, 0, S_SRET_PRICING, S_STORE_RETURNS, S_SRET_PRICING, 0},
+      {0, 0, 0, 0, S_SBCT_ID, S_SUBCATEGORY, S_SBCT_ID, 0},
+      {0, 1, 0, 0, S_SBCT_CATEGORY_ID, S_SUBCATEGORY, S_SBCT_CATEGORY_ID, 0},
+      {0, 0, 0, 0, S_SBCT_NAME, S_SUBCATEGORY, S_SBCT_NAME, 0},
+      {0, 10, 0, 0, S_SBCT_DESC, S_SUBCATEGORY, S_SBCT_DESC, 0},
+      {0, 0, 0, 0, S_SUBC_ID, S_SUBCLASS, S_SUBC_ID, 0},
+      {0, 1, 0, 0, S_SUBC_CLASS_ID, S_SUBCLASS, S_SUBC_CLASS_ID, 0},
+      {0, 0, 0, 0, S_SUBC_NAME, S_SUBCLASS, S_SUBC_NAME, 0},
+      {0, 10, 0, 0, S_SUBC_DESC, S_SUBCLASS, S_SUBC_DESC, 0},
+      {0, 1, 0, 0, S_WRHS_ID, S_WAREHOUSE, S_WRHS_ID, 0},
+      {0, 10, 0, 0, S_WRHS_DESC, S_WAREHOUSE, S_WRHS_DESC, 0},
+      {0, 1, 0, 0, S_WRHS_SQFT, S_WAREHOUSE, S_WRHS_SQFT, 0},
+      {0, 1, 0, 0, S_WRHS_ADDRESS_ID, S_WAREHOUSE, S_WRHS_ADDRESS_ID, 0},
+      {0, 1, 0, 0, S_WORD_ID, S_WEB_ORDER, S_WORD_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_WORD_BILL_CUSTOMER_ID,
+       S_WEB_ORDER,
+       S_WORD_BILL_CUSTOMER_ID,
+       0},
+      {0,
+       2,
+       0,
+       0,
+       S_WORD_SHIP_CUSTOMER_ID,
+       S_WEB_ORDER,
+       S_WORD_SHIP_CUSTOMER_ID,
+       0},
+      {0, 1, 0, 0, S_WORD_ORDER_DATE, S_WEB_ORDER, S_WORD_ORDER_DATE, 0},
+      {0, 1, 0, 0, S_WORD_ORDER_TIME, S_WEB_ORDER, S_WORD_ORDER_TIME, 0},
+      {0, 1, 0, 0, S_WORD_SHIP_MODE_ID, S_WEB_ORDER, S_WORD_SHIP_MODE_ID, 0},
+      {0, 1, 0, 0, S_WORD_WEB_SITE_ID, S_WEB_ORDER, S_WORD_WEB_SITE_ID, 0},
+      {0, 100, 0, 0, S_WORD_COMMENT, S_WEB_ORDER, S_WORD_COMMENT, 0},
+      {0, 1, 0, 0, S_WLIN_ITEM_ID, S_WEB_ORDER, S_WLIN_ITEM_ID, 0},
+      {0, 12, 0, 0, S_WLIN_ID, S_WEB_ORDER_LINEITEM, S_WLIN_ID, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_WLIN_LINE_NUMBER,
+       S_WEB_ORDER_LINEITEM,
+       S_WLIN_LINE_NUMBER,
+       0},
+      {0,
+       12,
+       0,
+       0,
+       S_WLIN_PROMOTION_ID,
+       S_WEB_ORDER_LINEITEM,
+       S_WLIN_PROMOTION_ID,
+       0},
+      {0, 12, 0, 0, S_WLIN_QUANTITY, S_WEB_ORDER_LINEITEM, S_WLIN_QUANTITY, 0},
+      {0,
+       12,
+       0,
+       0,
+       S_WLIN_COUPON_AMT,
+       S_WEB_ORDER_LINEITEM,
+       S_WLIN_COUPON_AMT,
+       0},
+      {0,
+       12,
+       0,
+       0,
+       S_WLIN_WAREHOUSE_ID,
+       S_WEB_ORDER_LINEITEM,
+       S_WLIN_WAREHOUSE_ID,
+       0},
+      {0,
+       12,
+       0,
+       0,
+       S_WLIN_SHIP_DATE,
+       S_WEB_ORDER_LINEITEM,
+       S_WLIN_SHIP_DATE,
+       0},
+      {0,
+       12,
+       0,
+       0,
+       S_WLIN_WEB_PAGE_ID,
+       S_WEB_ORDER_LINEITEM,
+       S_WLIN_WEB_PAGE_ID,
+       0},
+      {0, 96, 0, 0, S_WLIN_PRICING, S_WEB_ORDER_LINEITEM, S_WLIN_PRICING, 0},
+      {0, 0, 0, 0, S_WLIN_SHIP_COST, S_WEB_ORDER_LINEITEM, S_WLIN_SHIP_COST, 0},
+      {0,
+       12,
+       0,
+       0,
+       S_WLIN_IS_RETURNED,
+       S_WEB_ORDER_LINEITEM,
+       S_WLIN_IS_RETURNED,
+       0},
+      {0, 0, 0, 0, S_WLIN_PERMUTE, S_WEB_ORDER_LINEITEM, S_WLIN_PERMUTE, 0},
+      {0, 1, 0, 0, S_WPAG_SITE_ID, S_WEB_PAGE, S_WPAG_SITE_ID, 0},
+      {0, 1, 0, 0, S_WPAG_ID, S_WEB_PAGE, S_WPAG_ID, 0},
+      {0, 1, 0, 0, S_WPAG_CREATE_DATE, S_WEB_PAGE, S_WPAG_CREATE_DATE, 0},
+      {0, 1, 0, 0, S_WPAG_ACCESS_DATE, S_WEB_PAGE, S_WPAG_ACCESS_DATE, 0},
+      {0, 1, 0, 0, S_WPAG_AUTOGEN_FLAG, S_WEB_PAGE, S_WPAG_AUTOGEN_FLAG, 0},
+      {0, 1, 0, 0, S_WPAG_DEPARTMENT, S_WEB_PAGE, S_WPAG_DEPARTMENT, 0},
+      {0, 1, 0, 0, S_WPAG_URL, S_WEB_PAGE, S_WPAG_URL, 0},
+      {0, 1, 0, 0, S_WPAG_TYPE, S_WEB_PAGE, S_WPAG_TYPE, 0},
+      {0, 1, 0, 0, S_WPAG_CHAR_CNT, S_WEB_PAGE, S_WPAG_CHAR_CNT, 0},
+      {0, 1, 0, 0, S_WPAG_LINK_CNT, S_WEB_PAGE, S_WPAG_LINK_CNT, 0},
+      {0, 1, 0, 0, S_WPAG_IMAGE_CNT, S_WEB_PAGE, S_WPAG_IMAGE_CNT, 0},
+      {0, 1, 0, 0, S_WPAG_MAX_AD_CNT, S_WEB_PAGE, S_WPAG_MAX_AD_CNT, 0},
+      {0, 0, 0, 0, S_WPAG_PERMUTE, S_WEB_PAGE, S_WPAG_PERMUTE, 0},
+      {0, 1, 0, 0, S_WITM_SITE_ID, S_WEB_PROMOTIONAL_ITEM, S_WITM_SITE_ID, 0},
+      {0, 1, 0, 0, S_WITM_PAGE_ID, S_WEB_PROMOTIONAL_ITEM, S_WITM_PAGE_ID, 0},
+      {0, 1, 0, 0, S_WITM_ITEM_ID, S_WEB_PROMOTIONAL_ITEM, S_WITM_ITEM_ID, 0},
+      {0,
+       1,
+       0,
+       0,
+       S_WITM_PROMOTION_ID,
+       S_WEB_PROMOTIONAL_ITEM,
+       S_WITM_PROMOTION_ID,
+       0},
+      {0, 0, 0, 0, S_WRET_SITE_ID, S_WEB_RETURNS, S_WRET_SITE_ID, 0},
+      {0, 0, 0, 0, S_WRET_ORDER_ID, S_WEB_RETURNS, S_WRET_ORDER_ID, 0},
+      {0, 0, 0, 0, S_WRET_LINE_NUMBER, S_WEB_RETURNS, S_WRET_LINE_NUMBER, 0},
+      {0, 0, 0, 0, S_WRET_ITEM_ID, S_WEB_RETURNS, S_WRET_ITEM_ID, 0},
+      {0,
+       0,
+       0,
+       0,
+       S_WRET_RETURN_CUST_ID,
+       S_WEB_RETURNS,
+       S_WRET_RETURN_CUST_ID,
+       0},
+      {0,
+       0,
+       0,
+       0,
+       S_WRET_REFUND_CUST_ID,
+       S_WEB_RETURNS,
+       S_WRET_REFUND_CUST_ID,
+       0},
+      {0, 24, 0, 0, S_WRET_RETURN_DATE, S_WEB_RETURNS, S_WRET_RETURN_DATE, 0},
+      {0, 12, 0, 0, S_WRET_RETURN_TIME, S_WEB_RETURNS, S_WRET_RETURN_TIME, 0},
+      {0, 12, 0, 0, S_WRET_REASON_ID, S_WEB_RETURNS, S_WRET_REASON_ID, 0},
+      {0, 84, 0, 0, S_WRET_PRICING, S_WEB_RETURNS, S_WRET_PRICING, 0},
+      {0, 1, 0, 0, S_WSIT_ID, S_WEB_SITE, S_WSIT_ID, 0},
+      {0, 1, 0, 0, S_WSIT_OPEN_DATE, S_WEB_SITE, S_WSIT_OPEN_DATE, 0},
+      {0, 1, 0, 0, S_WSIT_CLOSE_DATE, S_WEB_SITE, S_WSIT_CLOSE_DATE, 0},
+      {0, 0, 0, 0, S_WSIT_NAME, S_WEB_SITE, S_WSIT_NAME, 0},
+      {0, 1, 0, 0, S_WSIT_ADDRESS_ID, S_WEB_SITE, S_WSIT_ADDRESS_ID, 0},
+      {0, 1, 0, 0, S_WSIT_DIVISION_ID, S_WEB_SITE, S_WSIT_DIVISION_ID, 0},
+      {0, 1, 0, 0, S_WSIT_CLASS, S_WEB_SITE, S_WSIT_CLASS, 0},
+      {0, 1, 0, 0, S_WSIT_MANAGER_ID, S_WEB_SITE, S_WSIT_MANAGER_ID, 0},
+      {0, 1, 0, 0, S_WSIT_MARKET_ID, S_WEB_SITE, S_WSIT_MARKET_ID, 0},
+      {0, 1, 0, 0, S_WSIT_TAX_PERCENTAGE, S_WEB_SITE, S_WSIT_TAX_PERCENTAGE, 0},
+      {0, 0, 0, 0, S_ZIPG_ZIP, S_ZIPG, S_ZIPG_ZIP, 0},
+      {0, 0, 0, 0, S_ZIPG_GMT, S_ZIPG, S_ZIPG_GMT, 0},
+      {-1, -1, -1, -1, -1, -1, -1, 0}};
+
+  void Reset();
+};
+
+/* must match WriteDist() in dcomp.c */
+#define IDX_SIZE (D_NAME_LEN + 7 * sizeof(int))
+
+int dist_op(
+    void* dest,
+    int op,
+    const char* d_name,
+    int vset,
+    int wset,
+    int stream,
+    DSDGenContext& dsdGenContext);
+#define pick_distribution(dest, dist, v, w, s, dsdGenContext) \
+  dist_op(dest, 0, dist, v, w, s, dsdGenContext)
+#define dist_member(dest, dist, v, w, dsdGenContext) \
+  dist_op(dest, 1, dist, v, w, 0, dsdGenContext)
+#define dist_max(dist, w, dsdGenContext) dist->maximums[w - 1]
+int dist_weight(
+    int* dest,
+    const char* d,
+    int index,
+    int wset,
+    DSDGenContext& dsdGenContext);
+int distsize(const char* szDistname, DSDGenContext& dsdGenContext);
+int dist_type(const char* szDistName, int vset, DSDGenContext& dsdGenContext);
+const d_idx_t* find_dist(const char* name);
+int IntegrateDist(
+    const char* szDistName,
+    int nPct,
+    int nStartIndex,
+    int nWeightSet,
+    DSDGenContext& dsdGenContext);
+void dump_dist(const char* szName, DSDGenContext& dsdGenContext);
+int dist_active(
+    const char* szName,
+    int nWeightSet,
+    DSDGenContext& dsdGenContext);
+int DistNameIndex(
+    const char* szDist,
+    int nNameType,
+    const char* szName,
+    DSDGenContext& dsdGenContext);
+int DistSizeToShiftWidth(
+    const char* szDist,
+    int nWeightSet,
+    DSDGenContext& dsdGenContext);
+int MatchDistWeight(
+    void* dest,
+    const char* szDist,
+    int nWeight,
+    int nWeightSet,
+    int ValueSet,
+    DSDGenContext& dsdGenContext);
+int findDistValue(
+    const char* szValue,
+    const char* szDistName,
+    int ValueSet,
+    DSDGenContext& dsdGenContext);
+int di_compare(const void* op1, const void* op2);
+int load_dists();
+
+#define DIST_UNIFORM 0x0001
+#define DIST_EXPONENTIAL 0x0002
+/* sales and returns are special; they must match calendar.dst */
+#define DIST_SALES 3
+#define DIST_RETURNS 5
+#define DIST_CHAR 0x0004
+#define DIST_INT 0x0008
+#define DIST_NAMES_SET 0xff00
+
+/* DistNameIndex needs to know what sort of name we are trying to match */
+#define VALUE_NAME 0x0000
+#define WEIGHT_NAME 0x0001
diff --git a/velox/tpcds/gen/dsdgen/include/error_msg.h b/velox/tpcds/gen/dsdgen/include/error_msg.h
new file mode 100644
index 000000000000..820cc6fdc853
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/error_msg.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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.
+ */
+
+#define QERR_OK 0
+#define QERR_NO_FILE -1
+#define QERR_LINE_TOO_LONG -2
+#define QERR_NO_MEMORY -3
+#define QERR_SYNTAX -4
+#define QERR_RANGE_ERROR -5
+#define QERR_NON_UNIQUE -6
+#define QERR_BAD_NAME -7
+#define QERR_DEFINE_OVERFLOW -8
+#define QERR_INVALID_TAG -9
+#define QERR_READ_FAILED -10
+#define QERR_TEMPLATE_OVERFLOW -11
+#define QERR_ONE_WORKLOAD -12
+#define QERR_CLASS_REDEFINE -13
+#define QERR_DUP_QUERY -14
+#define QERR_OPEN_FAILED -15
+#define QERR_NOT_IMPLEMENTED -16
+#define QERR_STR_TRUNCATED -17
+#define QERR_BAD_STRING -18
+#define QERR_WRITE_FAILED -19
+#define QERR_NO_TYPE -20
+#define QERR_NO_WEIGHT -21
+#define QERR_NO_LIMIT -22
+#define QERR_BAD_PERCENT -23
+#define QERR_ROWCOUNT_NAME -24
+#define QERR_NO_EXPR -25
+#define QERR_NO_INIT -26
+#define QERR_NO_NORMAL_RANGE -27
+#define QERR_UNBALANCED -28
+#define QERR_INCLUDE_OVERFLOW -29
+#define QERR_BAD_PARAMS -30
+#define DBGEN_ERROR_HIERACHY_ORDER -31
+#define QERR_NAMES_EARLY -32
+#define QERR_ARG_OVERFLOW -33
+#define QERR_INVALID_ARG -34
+#define QERR_RANGE_LIST -35
+#define QERR_BAD_SCALE -36
+#define QERR_BAD_PARAM -37
+#define QERR_BAD_JOIN -38
+#define QERR_TABLE_NOP -39
+#define QERR_TABLE_CHILD -40
+#define QERR_CMDLINE_TOO_LONG -41
+#define QERR_NO_QUERYLIST -42
+#define QERR_QUERY_RANGE -43
+#define QERR_MODIFIED_PARAM -44
+#define QERR_RANGE_OVERRUN -45
+#define QERR_QUALIFICATION_SCALE -46
+#define QERR_TABLE_UPDATE -47
+#define MAX_ERROR 47
+
+typedef struct ERR_MSG_T {
+  int flags;
+  const char* prompt;
+} err_msg_t;
+
+/*  Flag determine formating */
+#define EFLG_NO_ARG 0x0000
+#define EFLG_STR_ARG 0x0001
+#define EFLG_ARG_MASK 0x0001
+
+#define EFLG_SYSTEM 0x0002
+
+int ReportError(int nError, const char* arg, int bExit);
+int ReportErrorNoLine(int nError, const char* arg, int bExit);
+void SetErrorGlobals(char* szFileName, int* pnLineNumber);
diff --git a/velox/tpcds/gen/dsdgen/include/genrand.h b/velox/tpcds/gen/dsdgen/include/genrand.h
new file mode 100644
index 000000000000..71ef82b7e1a0
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/genrand.h
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef GENRAND_H
+#define GENRAND_H
+
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+
+extern rng_t Streams[];
+
+#define FL_SEED_OVERRUN 0x0001
+
+#define ALPHANUM "abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ0123456789"
+#define DIGITS "0123456789"
+
+#define RNG_SEED 19620718
+
+int genrand_integer(
+    int* dest,
+    int dist,
+    int min,
+    int max,
+    int mean,
+    int stream,
+    DSDGenContext& dsdGenContext);
+int genrand_decimal(
+    decimal_t* dest,
+    int dist,
+    decimal_t* min,
+    decimal_t* max,
+    decimal_t* mean,
+    int stream,
+    DSDGenContext& dsdGenContext);
+int genrand_date(
+    date_t* dest,
+    int dist,
+    date_t* min,
+    date_t* max,
+    date_t* mean,
+    int stream,
+    DSDGenContext& dsdGenContext);
+ds_key_t genrand_key(
+    ds_key_t* dest,
+    int dist,
+    ds_key_t min,
+    ds_key_t max,
+    ds_key_t mean,
+    int stream,
+    DSDGenContext& dsdGenContext);
+int gen_charset(
+    char* dest,
+    const char* set,
+    int min,
+    int max,
+    int stream,
+    DSDGenContext& dsdGenContext);
+int dump_seeds_ds(int tbl);
+void init_rand(DSDGenContext& dsdGenContext);
+void skip_random(int s, ds_key_t count, DSDGenContext& dsdGenContext);
+int RNGReset(int nTable);
+long next_random(int nStream, DSDGenContext& dsdGenContext);
+void genrand_email(
+    char* pEmail,
+    char* pFirst,
+    char* pLast,
+    int nColumn,
+    DSDGenContext& dsdGenContext);
+void genrand_ipaddr(char* pDest, int nColumn, DSDGenContext& dsdGenContext);
+int genrand_url(char* pDest, int nColumn);
+int setSeed(int nStream, int nValue, DSDGenContext& dsdGenContext);
+void resetSeeds(int nTable, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/grammar.h b/velox/tpcds/gen/dsdgen/include/grammar.h
new file mode 100644
index 000000000000..00feb9ba3013
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/grammar.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef GRAMMAR_H
+#define GRAMMAR_H
+
+typedef struct TOKEN_T {
+  int index;
+  char word[40];
+  int (*handler)(char* s, struct TOKEN_T* t);
+} token_t;
+
+#define COMMENT_CHAR '-'
+#define STMT_END ';'
+int ParseFile(char* szPath);
+int FindToken(char* name);
+void SetTokens(token_t* t);
+char* ProcessStr(char* stmt, token_t* pTokens);
+char* SafeStrtok(char* string, char* delims);
+extern token_t* pTokens;
+
+#endif /* GRAMMAR_H */
diff --git a/velox/tpcds/gen/dsdgen/include/grammar_support.h b/velox/tpcds/gen/dsdgen/include/grammar_support.h
new file mode 100644
index 000000000000..70c5b400af7d
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/grammar_support.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef GRAMMAR_SUPPORT_H
+#define GRAMMAR_SUPPORT_H
+/*
+ * entry in the file stack used to manage multiple input file and include files
+ */
+typedef struct FILE_REF_T {
+  FILE* file;
+  char* name;
+  int line_number;
+  void* pContext;
+  struct FILE_REF_T* pNext;
+#if defined(MKS) || defined(FLEX)
+  void* pLexState;
+#endif
+} file_ref_t;
+
+extern file_ref_t* pCurrentFile;
+
+int yywarn(char* str);
+void yyerror(char* msg, ...);
+int setup(void);
+int include_file(char* fn, void* pContext);
+void GetErrorCounts(int* nError, int* nWarning);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/list.h b/velox/tpcds/gen/dsdgen/include/list.h
new file mode 100644
index 000000000000..25b6b8eee6b4
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/list.h
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef LIST_H
+#define LIST_H
+typedef struct LIST_NODE_T {
+  struct LIST_NODE_T* pNext;
+  struct LIST_NODE_T* pPrev;
+  void* pData;
+} node_t;
+
+typedef struct LIST_T {
+  struct LIST_NODE_T* head;
+  struct LIST_NODE_T* tail;
+  struct LIST_NODE_T* pCurrent;
+  int (*pSortFunc)(const void* pD1, const void* pD2);
+  int nMembers;
+  int nFlags;
+} list_t;
+
+/* list_t flags */
+#define L_FL_HEAD 0x01 /* add at head */
+#define L_FL_TAIL 0x02 /* add at tail */
+#define L_FL_SORT 0x04 /* create sorted list */
+
+#define length(list) list->nMembers
+
+list_t* makeList(
+    int nFlags,
+    int (*pSortFunc)(const void* pD1, const void* pD2));
+list_t* addList(list_t* pList, void* pData);
+void* findList(list_t* pList, void* pData);
+void* removeItem(list_t* pList, int bFromHead);
+void* getHead(list_t* pList);
+void* getTail(list_t* pList);
+void* getNext(list_t* pList);
+void* getItem(list_t* pList, int nIndex);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/load.h b/velox/tpcds/gen/dsdgen/include/load.h
new file mode 100644
index 000000000000..0ea190c713a5
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/load.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef LOAD_H
+#define LOAD_H
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+void load_init(void);
+void load_close(void);
+int create_table(int nTable);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/mathops.h b/velox/tpcds/gen/dsdgen/include/mathops.h
new file mode 100644
index 000000000000..58284f9e15f3
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/mathops.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#define OP_PLUS 0x00001
+#define OP_MINUS 0x00002
+#define OP_MULT 0x00004
+#define OP_DIV 0x00008
+#define OP_MOD 0x00010
+#define OP_XOR 0x00020
+#define OP_PAREN 0x00040
+#define OP_BRACKET 0x00080
+#define OP_NEST 0x00100 /* a --> (a) */
+#define OP_NEG 0x00200
+#define OP_ADDR 0x00400 /* get an address */
+#define OP_PTR 0x00800 /* reference through a pointer */
+#define OP_FUNC 0x01000 /* user function/macro */
+#define OP_UNIQUE 0x02000 /* built in functions start here */
+#define OP_TEXT 0x04000
+#define OP_RANDOM 0x08000
+#define OP_RANGE 0x10000
+#define OP_USER 0x20000 /* user defined function */
diff --git a/velox/tpcds/gen/dsdgen/include/misc.h b/velox/tpcds/gen/dsdgen/include/misc.h
new file mode 100644
index 000000000000..b73704bf49df
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/misc.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef MISC_H
+#define MISC_H
+int prep_direct(int dialect);
+int close_direct(int dialect);
+int pick_tbl(char* dname);
+int itostr(char* dest, int i);
+int char_op(char* dest, int op, char* s1, char* s2);
+void gen_text(
+    char* dest,
+    int min,
+    int max,
+    int stream,
+    DSDGenContext& dsdGenContext);
+int int_op(int* dest, int op, int arg1, int arg2);
+
+char* env_config(char* var, char* dflt);
+int a_rnd(int min, int max, int column, char* dest);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/nulls.h b/velox/tpcds/gen/dsdgen/include/nulls.h
new file mode 100644
index 000000000000..4164d854e2b4
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/nulls.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef R_NULLCHECK_H
+#define R_NULLCHECK_H
+
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+
+int nullCheck(int nColumn, DSDGenContext& dsdGenContext);
+void nullSet(ds_key_t* pDest, int nStream, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/parallel.h b/velox/tpcds/gen/dsdgen/include/parallel.h
new file mode 100644
index 000000000000..d77ab2b32767
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/parallel.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef PARALLEL_H
+#define PARALLEL_H
+
+int split_work(
+    int nTable,
+    ds_key_t* pkFirstRow,
+    ds_key_t* pkRowCount,
+    DSDGenContext& dsdGenContext);
+int row_stop(int tbl, DSDGenContext& dsdGenContext);
+int row_skip(int tbl, ds_key_t count, DSDGenContext& dsdGenContext);
+
+#endif /* PARALLEL_H */
diff --git a/velox/tpcds/gen/dsdgen/include/params.h b/velox/tpcds/gen/dsdgen/include/params.h
new file mode 100644
index 000000000000..7646eeffe708
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/params.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef QGEN_PARAMS_H
+#define QGEN_PARAMS_H
+
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+
+#ifdef DECLARER
+#else
+extern option_t options[];
+extern char* params[];
+extern char* szTableNames[];
+#endif
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/permute.h b/velox/tpcds/gen/dsdgen/include/permute.h
new file mode 100644
index 000000000000..f167aabd33c3
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/permute.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+int* makePermutation(int nSize, int nStream, DSDGenContext& dsdGenContext);
+ds_key_t* makeKeyPermutation(
+    ds_key_t* pNumberSet,
+    ds_key_t nSize,
+    int nStream,
+    DSDGenContext& dsdGenContext);
+#define getPermutationEntry(pPermutation, nIndex) (pPermutation[nIndex - 1] + 1)
diff --git a/velox/tpcds/gen/dsdgen/include/porting.h b/velox/tpcds/gen/dsdgen/include/porting.h
new file mode 100644
index 000000000000..af15abf176d7
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/porting.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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.
+ */
+
+#ifndef PORTING_H
+#define PORTING_H
+
+#include <string.h>
+// #ifdef USE_STRING_H
+// #include <string.h>
+// #else
+// #include <strings.h>
+// #endif
+
+#ifdef USE_VALUES_H
+#include <values.h>
+#endif
+
+#ifdef USE_LIMITS_H
+#include <limits.h>
+#endif
+
+#ifdef USE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifndef WIN32
+#include <sys/types.h>
+#else
+#define int32_t __int32
+#define int64_t __int64
+#endif
+
+#ifdef WIN32
+#include <sys/timeb.h>
+#define timeb _timeb
+#define ftime _ftime
+#else
+#include <sys/time.h>
+#endif
+
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+
+typedef HUGE_TYPE ds_key_t;
+
+/*
+ * add some functions that are not strictly ANSI standard
+ */
+#ifndef strdup
+char* strdup(const char*);
+#endif
+
+#ifdef WIN32
+#include <io.h> // @manual
+#include <winbase.h> // @manual
+#include <windows.h> // @manual
+#include <winsock2.h> // @manual
+#define random rand
+#define strncasecmp _strnicmp
+#define strcasecmp _stricmp
+#define strdup _strdup
+#define access _access
+#define isatty _isatty
+#define fileno _fileno
+#define F_OK 0
+#define MAXINT INT_MAX
+#define THREAD __declspec(thread)
+#define MIN_MULTI_NODE_ROWS 100000
+#define MIN_MULTI_THREAD_ROWS 5000
+#define THREAD __declspec(thread)
+/* Lines added by Chuck McDevitt for WIN32 support */
+#ifndef _POSIX_
+#ifndef S_ISREG
+#define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
+#define S_ISFIFO(m) (((m) & _S_IFMT) == _S_IFIFO)
+#endif
+#endif
+#endif /* WIN32 */
+
+#ifdef _MSC_VER
+#pragma comment(lib, "ws2_32.lib")
+#endif
+
+#ifdef INTERIX
+#include <limits.h>
+#define MAXINT INT_MAX
+#endif /* INTERIX */
+
+#ifdef AIX
+#define MAXINT INT_MAX
+#endif
+
+#ifdef MACOS
+#include <limits.h>
+#define MAXINT INT_MAX
+#endif /* MACOS */
+
+#define INTERNAL(m)                                                            \
+  {                                                                            \
+    auto result = fprintf(                                                     \
+        stderr, "ERROR: %s\n\tFile: %s\n\tLine: %d\n", m, __FILE__, __LINE__); \
+    if (result < 0)                                                            \
+      perror("sprintf failed");                                                \
+  }
+
+#define OPEN_CHECK(var, path)                                               \
+  if ((var) == NULL) {                                                      \
+    fprintf(                                                                \
+        stderr, "Open failed for %s at %s:%d\n", path, __FILE__, __LINE__); \
+    exit(1);                                                                \
+  }
+
+#ifdef MEM_TEST
+#define MALLOC_CHECK(v)                                                 \
+  if (v == NULL) {                                                      \
+    fprintf(stderr, "Malloc Failed at %d in %s\n", __LINE__, __FILE__); \
+    exit(1);                                                            \
+  } else {                                                              \
+    fprintf(                                                            \
+        stderr,                                                         \
+        "Add (%x) %d at %d in %s\n",                                    \
+        sizeof(*v),                                                     \
+        v,                                                              \
+        __LINE__,                                                       \
+        __FILE__);                                                      \
+  }
+#else
+#define MALLOC_CHECK(v)                                                     \
+  if (v == nullptr) {                                                       \
+    int result =                                                            \
+        fprintf(stderr, "Malloc Failed at %d in %s\n", __LINE__, __FILE__); \
+    if (result < 0)                                                         \
+      perror("fprintf failed");                                             \
+    exit(1);                                                                \
+  }
+#endif /* MEM_TEST */
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/pricing.h b/velox/tpcds/gen/dsdgen/include/pricing.h
new file mode 100644
index 000000000000..0b9820aa1f68
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/pricing.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef PRICING_H
+#define PRICING_H
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+
+typedef struct DS_LIMITS_T {
+  int nId;
+  const char* szQuantity;
+  const char* szMarkUp;
+  const char* szDiscount;
+  const char* szWholesale;
+  const char* szCoupon;
+} ds_limits_t;
+
+void set_pricing(
+    int nTabId,
+    ds_pricing_t* pPricing,
+    DSDGenContext& dsdGenContext);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/r_params.h b/velox/tpcds/gen/dsdgen/include/r_params.h
new file mode 100644
index 000000000000..3bdfa40f2d58
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/r_params.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/dist.h" // @manual
+
+#ifndef R_PARAMS_H
+#define R_PARAMS_H
+#define OPT_NONE 0x00
+#define OPT_FLG 0x01 /* option is a flag; no parameter */
+#define OPT_INT 0x02 /* argument is an integer */
+#define OPT_STR 0x04 /* argument is a string */
+#define OPT_NOP 0x08 /* flags non-operational options */
+#define OPT_SUB 0x10 /* sub-option defined */
+#define OPT_ADV 0x20 /* advanced option */
+#define OPT_SET \
+  0x40 /* not changeable -- used for default/file/command precedence */
+#define OPT_DFLT 0x80 /* param set to non-zero default */
+#define OPT_MULTI 0x100 /* param may be set repeatedly */
+#define OPT_HIDE 0x200 /* hidden option -- not listed in usage */
+#define TYPE_MASK 0x07
+#endif
+/*
+ * function declarations
+ */
+int process_options(int count, const char** args);
+const char* get_str(const char* var, DSDGenContext& dsdGenContext);
+void set_str(
+    const char* param,
+    const char* value,
+    DSDGenContext& dsdGenContext);
+int get_int(const char* var, DSDGenContext& dsdGenContext);
+void set_int(const char* var, const char* val, DSDGenContext& dsdGenContext);
+double get_dbl(const char* var, DSDGenContext& dsdGenContext);
+int is_set(const char* flag, DSDGenContext& dsdGenContext);
+void clr_flg(const char* flag, DSDGenContext& dsdGenContext);
+int find_table(const char* szParamName, const char* tname);
+char* GetParamName(int nParam, DSDGenContext& dsdGenContext);
+const char* GetParamValue(int nParam, DSDGenContext& dsdGenContext);
+int load_param(int nParam, const char* value, DSDGenContext& dsdGenContext);
+int fnd_param(const char* name, DSDGenContext& dsdGenContext);
+int init_params(DSDGenContext& dsdGenContext);
+int set_option(const char* pname, const char* value);
+void load_params(void);
+int IsIntParam(const char* szName, DSDGenContext& dsdGenContext);
+int IsStrParam(const char* szName, DSDGenContext& dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/include/scaling.h b/velox/tpcds/gen/dsdgen/include/scaling.h
new file mode 100644
index 000000000000..f48568b32a5d
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/scaling.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/dist.h"
+
+#ifndef SCALING_H
+#define SCALING_H
+
+ds_key_t get_rowcount(int table, DSDGenContext& dsdGenContext);
+ds_key_t getIDCount(int nTable, DSDGenContext& dsdGenContext);
+int getUpdateID(ds_key_t* pDest, int nTable, int nColumn);
+int getScaleSlot(int nTargetGB, DSDGenContext& dsdGenContext);
+int getSkewedJulianDate(int nWeight, int nColumn, DSDGenContext& dsdGenContext);
+ds_key_t dateScaling(int nColumn, ds_key_t jDate, DSDGenContext& dsdGenContext);
+int getUpdateDate(int nTable, ds_key_t kRowcount, DSDGenContext& dsdGenContext);
+void setUpdateDates(DSDGenContext& dsdGenContext);
+void setUpdateScaling(int nTable, DSDGenContext& dsdGenContext);
+ds_key_t getUpdateBase(int nTable, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/scd.h b/velox/tpcds/gen/dsdgen/include/scd.h
new file mode 100644
index 000000000000..b65f3621a497
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/scd.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef SCD_H
+#define SCD_H
+
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+
+extern char arBKeys[MAX_TABLE][17];
+int setSCDKeys(
+    int nTableID,
+    ds_key_t hgIndex,
+    char* szBKey,
+    ds_key_t* hgBeginDateKey,
+    ds_key_t* hgEndDateKey,
+    DSDGenContext& dsdGenContext);
+ds_key_t
+scd_join(int tbl, int col, ds_key_t jDate, DSDGenContext& dsdGenContext);
+ds_key_t matchSCDSK(
+    ds_key_t kUnique,
+    ds_key_t jDate,
+    int nTable,
+    DSDGenContext& dsdGenContext);
+ds_key_t getSKFromID(ds_key_t kID, int nColumn, DSDGenContext& dsdGenContext);
+ds_key_t getFirstSK(ds_key_t kID);
+/*
+ * handle the partial change of a history keeping record
+ * TODO: remove the macros in favor of straight fucntion calls
+ */
+#define SCD_INT 0
+#define SCD_CHAR 1
+#define SCD_DEC 2
+#define SCD_KEY 3
+#define SCD_PTR 4
+void changeSCD(
+    int nDataType,
+    void* pNewData,
+    void* pOldData,
+    int* nFlags,
+    int bFirst);
+int validateSCD(int nTable, ds_key_t kRow, int* Permutation);
+void printValidation(int nTable, ds_key_t kRow);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/skip_days.h b/velox/tpcds/gen/dsdgen/include/skip_days.h
new file mode 100644
index 000000000000..0b516c76d82c
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/skip_days.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef R_SKIP_DAYS_H
+#define R_SKIP_DAYS_H
+
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+ds_key_t
+skipDays(int nTable, ds_key_t* pRemainder, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/sparse.h b/velox/tpcds/gen/dsdgen/include/sparse.h
new file mode 100644
index 000000000000..7ff2aa2b7ae9
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/sparse.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/dist.h"
+
+int initSparseKeys(
+    int nTable,
+    DSDGenContext& dsdGenContext); /* populate the set of valid keys */
+ds_key_t randomSparseKey(
+    int nTable,
+    int nColumn,
+    DSDGenContext& dsdGenContext); /* select a random sparse key */
diff --git a/velox/tpcds/gen/dsdgen/include/tables.h b/velox/tpcds/gen/dsdgen/include/tables.h
new file mode 100644
index 000000000000..610087469d8e
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/tables.h
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+/*
+ * THIS IS A GENERATED FILE
+ * SEE COLUMNS.LIST
+ */
+#ifndef TABLES_H
+#define TABLES_H
+#define CALL_CENTER 0
+#define CATALOG_PAGE 1
+#define CATALOG_RETURNS 2
+#define CATALOG_SALES 3
+#define CUSTOMER 4
+#define CUSTOMER_ADDRESS 5
+#define CUSTOMER_DEMOGRAPHICS 6
+#define DATET 7
+#define HOUSEHOLD_DEMOGRAPHICS 8
+#define INCOME_BAND 9
+#define INVENTORY 10
+#define ITEM 11
+#define PROMOTION 12
+#define REASON 13
+#define SHIP_MODE 14
+#define STORE 15
+#define STORE_RETURNS 16
+#define STORE_SALES 17
+#define TIMET 18
+#define WAREHOUSE 19
+#define WEB_PAGE 20
+#define WEB_RETURNS 21
+#define WEB_SALES 22
+#define WEB_SITE 23
+#define DBGEN_VERSION 24
+#define S_BRAND 25
+#define S_CUSTOMER_ADDRESS 26
+#define S_CALL_CENTER 27
+#define S_CATALOG 28
+#define S_CATALOG_ORDER 29
+#define S_CATALOG_ORDER_LINEITEM 30
+#define S_CATALOG_PAGE 31
+#define S_CATALOG_PROMOTIONAL_ITEM 32
+#define S_CATALOG_RETURNS 33
+#define S_CATEGORY 34
+#define S_CLASS 35
+#define S_COMPANY 36
+#define S_CUSTOMER 37
+#define S_DIVISION 38
+#define S_INVENTORY 39
+#define S_ITEM 40
+#define S_MANAGER 41
+#define S_MANUFACTURER 42
+#define S_MARKET 43
+#define S_PRODUCT 44
+#define S_PROMOTION 45
+#define S_PURCHASE 46
+#define S_PURCHASE_LINEITEM 47
+#define S_REASON 48
+#define S_STORE 49
+#define S_STORE_PROMOTIONAL_ITEM 50
+#define S_STORE_RETURNS 51
+#define S_SUBCATEGORY 52
+#define S_SUBCLASS 53
+#define S_WAREHOUSE 54
+#define S_WEB_ORDER 55
+#define S_WEB_ORDER_LINEITEM 56
+#define S_WEB_PAGE 57
+#define S_WEB_PROMOTIONAL_ITEM 58
+#define S_WEB_RETURNS 59
+#define S_WEB_SITE 60
+#define S_ZIPG 61
+#define PSEUDO_TABLE_START 62
+/* PSEUDO TABLES from here on; used in hierarchies */
+#define ITEM_BRAND 62
+#define ITEM_CLASS 63
+#define ITEM_CATEGORY 64
+#define DIVISIONS 65
+#define COMPANY 66
+#define CONCURRENT_WEB_SITES 67
+#define ACTIVE_CITIES 68
+#define ACTIVE_COUNTIES 69
+#define ACTIVE_STATES 70
+#define MAX_TABLE 70
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/tdef_functions.h b/velox/tpcds/gen/dsdgen/include/tdef_functions.h
new file mode 100644
index 000000000000..6fc7d393b60d
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/tdef_functions.h
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef TDEF_FUNCTIONS_H
+#define TDEF_FUNCTIONS_H
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+
+/*
+* table functions.
+* NOTE: This table contains the function declarations in the table descriptions;
+it must be kept in sync with the
+*    declararions of assocaited constants, found in tdefs.h
+
+*/
+typedef struct TABLE_FUNC_T {
+  const char* name; /* -- name of the table; */
+  int (*builder)(
+      void*,
+      ds_key_t,
+      DSDGenContext& dsdGenContext); /* -- function to prep output */
+  int (*loader[2])(void*); /* -- functions to present output */
+  /* -- data validation function */
+  int (*validate)(int nTable, ds_key_t kRow, int* Permutation);
+} table_func_t;
+
+extern table_func_t w_tdef_funcs[MAX_TABLE];
+extern table_func_t s_tdef_funcs[MAX_TABLE];
+extern table_func_t* tdef_funcs;
+
+int validateGeneric(int nTable, ds_key_t kRow, int* Permutation);
+int validateSCD(int nTable, ds_key_t kRow, int* Permutation);
+
+#endif /* TDEF_FUNCTIONS_H */
+extern table_func_t s_tdef_funcs[];
+extern table_func_t w_tdef_funcs[];
+
+table_func_t* getTdefFunctionsByNumber(int nTable);
diff --git a/velox/tpcds/gen/dsdgen/include/tdefs.h b/velox/tpcds/gen/dsdgen/include/tdefs.h
new file mode 100644
index 000000000000..dd105b79a025
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/tdefs.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef TDEFS_H
+#define TDEFS_H
+
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
+
+#define tdefIsFlagSet(t, f) (tdefs[t].flags & f)
+ds_key_t GetRowcountByName(char* szName, DSDGenContext& dsdGenContext);
+int GetTableNumber(char* szName, DSDGenContext& dsdGenContext);
+const char* getTableNameByID(int id, DSDGenContext& dsdGenContext);
+int getTableFromColumn(int id, DSDGenContext& dsdGenContext);
+int initSpareKeys(int id, DSDGenContext& dsdGenContext);
+tdef* getSimpleTdefsByNumber(int nTable, DSDGenContext& dsdGenContext);
+tdef* getTdefsByNumber(int nTable, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/template.h b/velox/tpcds/gen/dsdgen/include/template.h
new file mode 100644
index 000000000000..4ad5dec4b08a
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/template.h
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef TEMPLATE_H
+#define TEMPLATE_H
+#include "velox/tpcds/gen/dsdgen/include/StringBuffer.h"
+#include "velox/tpcds/gen/dsdgen/include/expr.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/list.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/substitution.h" // @manual
+
+/*  Replacement flags */
+#define REPL_FL_NONE 0x0001 /*  no effect on result set size */
+#define REPL_FL_MORE 0x0002 /*  likely to increase result set size */
+#define REPL_FL_LESS 0x0004 /*  likely to decrease result set size */
+
+typedef struct TEMPLATE_T {
+  char* name;
+  int index;
+  int flags;
+  list_t* SubstitutionList;
+  list_t* SegmentList;
+  list_t* DistList;
+} template_t;
+#define QT_INIT 0x0001
+
+extern template_t* pCurrentQuery;
+
+void PrintQuery(FILE* fp, template_t* t);
+int AddQuerySegment(template_t* pQuery, char* szSQL);
+int AddQuerySubstitution(
+    template_t* Query,
+    char* szSubName,
+    int nUse,
+    int nSubPart);
+int AddSubstitution(template_t* t, char* s, expr_t* pExpr);
+int SetSegmentFlag(template_t* Query, int nSegmentNumber, int nFlag);
+substitution_t* FindSubstitution(template_t* t, char* stmt, int* nUse);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/tpcds.idx.h b/velox/tpcds/gen/dsdgen/include/tpcds.idx.h
new file mode 100644
index 000000000000..d845f39a2db6
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/tpcds.idx.h
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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.
+ */
+
+/*
+THIS IS AN AUTOMATICALLY GENERATED FILE
+DO NOT EDIT
+
+See distcomp.c for details
+*/
+
+/* aliases for values/weights in the first_names distribution */
+#define first_names_name 1
+#define first_names_male 1
+#define first_names_female 2
+#define first_names_unified 3
+
+/* aliases for values/weights in the last_names distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the calendar distribution */
+#define calendar_day_seq 1
+#define calendar_month_name 2
+#define calendar_date 3
+#define calendar_season 4
+#define calendar_month_num 5
+#define calendar_quarter 6
+#define calendar_fom 7
+#define calendar_holiday 8
+#define calendar_uniform 1
+#define calendar_uniform_leap 2
+#define calendar_sales 3
+#define calendar_sales_leap 4
+#define calendar_returns 5
+#define calendar_returns_leap 6
+#define calendar_skewed 7
+#define calendar_low 8
+#define calendar_medium 9
+#define calendar_high 10
+
+/* aliases for values/weights in the week_info distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the fips_county distribution */
+#define fips_county_fips 1
+#define fips_county_county 2
+#define fips_county_st 3
+#define fips_county_state 4
+#define fips_county_zone 5
+#define fips_county_gmt 6
+#define fips_county_uniform 1
+#define fips_county_population 2
+#define fips_county_tz 3
+#define fips_county_tz90 4
+#define fips_county_tz9 5
+#define fips_county_tz1 6
+
+/* aliases for values/weights in the street_names distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the street_type distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the adjectives distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the adverbs distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the articles distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the nouns distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the prepositions distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the verbs distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the auxiliaries distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the terminators distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the sentences distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the syllables distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the cities distribution */
+#define cities_name 1
+#define cities_usgs 1
+#define cities_uniform 2
+#define cities_large 3
+#define cities_medium 4
+#define cities_small 5
+#define cities_unified 6
+
+/* aliases for values/weights in the categories distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the women_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the men_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the children_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the shoe_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the music_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the jewelry_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the home_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the sport_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the book_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the electronic_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the sizes distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the units distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the container distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the colors distribution */
+#define colors_name 1
+#define colors_uniform 1
+#define colors_skewed 2
+#define colors_low 3
+#define colors_medium 4
+#define colors_high 5
+
+/* aliases for values/weights in the brand_syllables distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the i_current_price distribution */
+#define i_current_price_index 1
+#define i_current_price_low_bound 2
+#define i_current_price_high_bound 3
+#define i_current_price_skew 1
+#define i_current_price_high 2
+#define i_current_price_medium 3
+#define i_current_price_low 4
+
+/* aliases for values/weights in the i_manufact_id distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the i_manager_id distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the rowcounts distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the gender distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the marital_status distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the education distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the purchase_band distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the buy_potential distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the credit_rating distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the income_band distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the dependent_count distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the vehicle_count distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the promo_purpose distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the return_reasons distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the store_type distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the geography_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the divisions distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the stores distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the hours distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the call_centers distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the call_center_hours distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the call_center_class distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the salutations distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the ship_mode_code distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the ship_mode_type distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the ship_mode_carrier distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the web_page_use distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the web_page_type distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the catalog_page_type distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the location_type distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the top_domains distribution */
+/* NONE DEFINED */
+
+/* aliases for values/weights in the countries distribution */
+/* NONE DEFINED */
diff --git a/velox/tpcds/gen/dsdgen/include/tpcds_idx.hpp b/velox/tpcds/gen/dsdgen/include/tpcds_idx.hpp
new file mode 100644
index 000000000000..c8045b557f2b
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/tpcds_idx.hpp
@@ -0,0 +1,53406 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** Generated with `xxd -i tpcds.idx tpcds_idx.hpp`
+ * DO NOT EDIT
+ **/
+
+#pragma once
+
+unsigned const char tpcds_idx[] = {
+    0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xf0,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xa2,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x02, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd1,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x01, 0x4f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x01, 0x0e, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xf8,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x02, 0xe0,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xbe,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xe5, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0xa5,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xf3, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x44,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x32,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xce, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0xb4,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xce, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x43,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x35,
+    0x00, 0x00, 0x09, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x9f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xa3, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x01, 0x6f,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4d,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x3a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xc1,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f,
+    0x00, 0x00, 0x03, 0x0b, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x94,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd7,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x45, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x02, 0x8a,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x9f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x35, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x01, 0xb9,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x3c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x73, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x6d,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x3b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa5,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x0c, 0xf6, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x94, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x76,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x02, 0x4f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0xf2,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x01, 0xb0,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0xbf,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x01, 0x41, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xc7,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0xc3,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x01, 0x39, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x02, 0x65, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x7c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x01, 0xb3, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x37, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x3a,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x02, 0x9f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x56, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x01, 0x1a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7d,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xb5,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xaa,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x02, 0x91,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa2,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x45,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb1,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x7a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x01, 0x85, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x03, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x01, 0x7d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0xc5,
+    0x00, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x01, 0x1a, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0xe8,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x06, 0xa7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x47, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x01, 0x42, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd5, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0xe0,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x32, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x02, 0x22, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x34,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x1c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x03, 0x0c, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x37,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x64,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x8a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x38,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x8f, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xf9,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x68,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x93, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x2e, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x63,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x62,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x01, 0x65, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x01, 0x94,
+    0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x01, 0xc3,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xec,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x01, 0xd4,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x6c, 0x00, 0x00, 0x01, 0xb8, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x23,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x01, 0x2f, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x7f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0xd4,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x82,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x8f,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x6e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x02, 0x9a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x01, 0x0b,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x37,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x01, 0xc7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x75,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2e,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x47,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x81,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xab,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x75, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa9,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x26,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x3b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x01, 0x13, 0x00, 0x00, 0x01, 0x7e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc0,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xcf, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xd5,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x9d,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x01, 0xee,
+    0x00, 0x00, 0x01, 0x98, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x01, 0x67,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x45,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x47,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x54,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x4f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x02, 0xd7, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb3, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc5,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0xa9, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x65,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xad,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x42,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x5b,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xcd, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x4f,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbd,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x97, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4f,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x7b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x1d, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x03, 0xa4,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x44,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xea, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x88,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x6c,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x29,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x14, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x5c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x02, 0x9b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x39, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x01, 0xa8, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x10,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x33,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0xf8,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x41,
+    0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xd3,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xc0, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf8,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xe5,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x67,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x34,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x5a,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x56,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x7b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf1, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x58,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x9c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x32,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x5e,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x01, 0xce, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x02, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x39, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x42,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x33,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x4e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x02, 0x9d, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x19, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x49,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xda, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2e,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x01, 0xa0, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4c,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xf2,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x01, 0xae,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0xcc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x28, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x23,
+    0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x32, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x75, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe5,
+    0x00, 0x00, 0x01, 0xfc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x0a, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0xaf, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3e,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3e,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xb2, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x90,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x1a, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x5c,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59,
+    0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x69,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xaf,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xc3,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x95,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x6f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x8e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x52,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb4,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x01, 0xae, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x76,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xe2,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf2,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x62,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0xcc, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x01, 0x3b, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x35,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x75,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x29,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xa2,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x01, 0x65, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x01, 0x94,
+    0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x01, 0xc3,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0xf2,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x02, 0x1b, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x01, 0xd4,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x6c, 0x00, 0x00, 0x01, 0xb8, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x02, 0xd4,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xc0,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x01, 0x51,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x01, 0x3d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x7f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x03, 0xd4,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x82,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x4e,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x01, 0x0e, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x8f,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x6e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x02, 0x9a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x01, 0x0b,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xf8,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x37,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x37,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x46,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x01, 0xc7, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x02, 0xe0,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x75,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xbe,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x73,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x25,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2e,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x5a, 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xe5, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x47,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x81,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xab,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x75, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0xa5,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x05, 0xf3, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5a,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa9,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x26,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x3b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x41,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x01, 0x13, 0x00, 0x00, 0x01, 0x7e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x04, 0x0b,
+    0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc0,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x44,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x32,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x5f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xce, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xcf, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0xb4,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xd5,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0xce, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x43,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x35,
+    0x00, 0x00, 0x09, 0x3b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x68,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x9d,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x01, 0xee,
+    0x00, 0x00, 0x01, 0x98, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x01, 0x9f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x01, 0x67,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x45,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x91,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x03, 0xa3, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x02, 0x47,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x54,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x4f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x02, 0xd7, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x01, 0x6f,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4d,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x3a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xc1,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x90,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xb3, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xc5,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2f,
+    0x00, 0x00, 0x03, 0x0b, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x94,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0xa9, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x65,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xad,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x2e,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x00, 0x82,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xd7,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x25,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xae,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xe6,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x36,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x42,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x39,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3a,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x7c,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x02, 0x45, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x2b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x49,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x02, 0x8a,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x9f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x5b,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x35, 0x00, 0x00, 0x00, 0x8d,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x28,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xcd, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x4f,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0xbd,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x01, 0xb9,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x3c,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x73, 0x00, 0x00, 0x00, 0x38,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x38,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x01, 0x51, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x97, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x6d,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x61,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x28,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x76,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4f,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x33,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x3b,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xa5,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x0c, 0xf6, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x7b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x1d, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x47,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x02, 0x94, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x76,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x02, 0x4f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x03, 0xa4,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x44,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0xf2,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x01, 0xb0,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0xea, 0x00, 0x00, 0x00, 0x41,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x9b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0xbf,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x88,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x01, 0x41, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0c, 0xc7,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0xc3,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x73,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x01, 0x39, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x02, 0x65, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x05, 0x7c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x01, 0xb3, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x6c,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x3c,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x29,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x01, 0x14, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0x34,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x5c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2a,
+    0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x37, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x29,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x02, 0x9b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x45,
+    0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x39, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x01, 0xa8, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x10,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x33,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x01, 0x34, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x3f,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x26,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x3a,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x02, 0x9f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0xf8,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x41,
+    0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x3e,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xa0,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x56, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x01, 0x1a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x4d,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x45,
+    0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x7d,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xd3,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x04, 0x0b, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x02, 0xc0, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x70,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf8,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xe5,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x67,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2b,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x34,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xb5,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x57,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x5a,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x56,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x7b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xf1, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x03, 0xaa,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x58,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x9c, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x32,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x02, 0x91,
+    0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x5c,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x4f,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x5e,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x01, 0xce, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0xa2,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x45,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x02, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x39, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x42,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x33,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x4e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x02, 0x9d, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x47,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x42,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x3d,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x01, 0x13, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x19, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x49,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xda, 0x00, 0x00, 0x00, 0xb1,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x7a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2e,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x01, 0xa0, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x01, 0x85, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x4c,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2b,
+    0x00, 0x00, 0x03, 0xb4, 0x00, 0x00, 0x00, 0xd9, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x01, 0x7d,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0xc5,
+    0x00, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x26,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xf2,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x01, 0x1a, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0xe8,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x01, 0xae,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x85,
+    0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x06, 0xa7, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0xcc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0c, 0x47, 0x00, 0x00, 0x00, 0x75,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x01, 0x42, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x02, 0xd5, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x01, 0x28, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x23,
+    0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x52,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0xe0,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x32, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x01, 0x48, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x7c,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x32, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x75, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0xe5,
+    0x00, 0x00, 0x01, 0xfc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x02, 0x22, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x5d,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x28,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x0a, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x27,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc8,
+    0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0xaf, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x17,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3e,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1c,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3e,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xb2, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x34,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x1d,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x20,
+    0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x90,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x02, 0x1c, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x03, 0x0c, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2c,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x1a, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x5c,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x1a,
+    0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x59,
+    0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x14,
+    0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x69,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x37,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xaf,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x7b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x05, 0x64,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xc3,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0x00, 0xdc,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x75,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xbe,
+    0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0xa6,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x18,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x8a,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x59,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x95,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x6f,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x30,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x8e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x52,
+    0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xde, 0x00, 0x00, 0x00, 0xb4,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x01, 0xae, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x76,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x38,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x8f, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xe2,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x6e,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xf9,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x68,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x24,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x09, 0x93, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x2e, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0d,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x63,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x12,
+    0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x36,
+    0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x45,
+    0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x5c,
+    0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x6d,
+    0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x85,
+    0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x9c,
+    0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0xb0,
+    0x00, 0x00, 0x00, 0xb6, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0xc3,
+    0x00, 0x00, 0x00, 0xca, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0xd7,
+    0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0xe7, 0x00, 0x00, 0x00, 0xf0,
+    0x00, 0x00, 0x00, 0xf9, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08,
+    0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x01, 0x17, 0x00, 0x00, 0x01, 0x1e,
+    0x00, 0x00, 0x01, 0x24, 0x00, 0x00, 0x01, 0x2a, 0x00, 0x00, 0x01, 0x33,
+    0x00, 0x00, 0x01, 0x3a, 0x00, 0x00, 0x01, 0x42, 0x00, 0x00, 0x01, 0x4b,
+    0x00, 0x00, 0x01, 0x51, 0x00, 0x00, 0x01, 0x57, 0x00, 0x00, 0x01, 0x5a,
+    0x00, 0x00, 0x01, 0x5f, 0x00, 0x00, 0x01, 0x64, 0x00, 0x00, 0x01, 0x69,
+    0x00, 0x00, 0x01, 0x70, 0x00, 0x00, 0x01, 0x77, 0x00, 0x00, 0x01, 0x7d,
+    0x00, 0x00, 0x01, 0x83, 0x00, 0x00, 0x01, 0x87, 0x00, 0x00, 0x01, 0x8d,
+    0x00, 0x00, 0x01, 0x94, 0x00, 0x00, 0x01, 0x97, 0x00, 0x00, 0x01, 0x9e,
+    0x00, 0x00, 0x01, 0xa5, 0x00, 0x00, 0x01, 0xaa, 0x00, 0x00, 0x01, 0xb0,
+    0x00, 0x00, 0x01, 0xb6, 0x00, 0x00, 0x01, 0xbd, 0x00, 0x00, 0x01, 0xc4,
+    0x00, 0x00, 0x01, 0xc9, 0x00, 0x00, 0x01, 0xd0, 0x00, 0x00, 0x01, 0xd8,
+    0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0xeb, 0x00, 0x00, 0x01, 0xf5,
+    0x00, 0x00, 0x01, 0xfd, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x02, 0x09,
+    0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x02, 0x14, 0x00, 0x00, 0x02, 0x1b,
+    0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x02, 0x27, 0x00, 0x00, 0x02, 0x2d,
+    0x00, 0x00, 0x02, 0x34, 0x00, 0x00, 0x02, 0x3c, 0x00, 0x00, 0x02, 0x46,
+    0x00, 0x00, 0x02, 0x52, 0x00, 0x00, 0x02, 0x5c, 0x00, 0x00, 0x02, 0x62,
+    0x00, 0x00, 0x02, 0x68, 0x00, 0x00, 0x02, 0x6f, 0x00, 0x00, 0x02, 0x77,
+    0x00, 0x00, 0x02, 0x7e, 0x00, 0x00, 0x02, 0x89, 0x00, 0x00, 0x02, 0x8f,
+    0x00, 0x00, 0x02, 0x96, 0x00, 0x00, 0x02, 0x9e, 0x00, 0x00, 0x02, 0xa6,
+    0x00, 0x00, 0x02, 0xab, 0x00, 0x00, 0x02, 0xb1, 0x00, 0x00, 0x02, 0xbb,
+    0x00, 0x00, 0x02, 0xc5, 0x00, 0x00, 0x02, 0xd0, 0x00, 0x00, 0x02, 0xd7,
+    0x00, 0x00, 0x02, 0xde, 0x00, 0x00, 0x02, 0xe6, 0x00, 0x00, 0x02, 0xee,
+    0x00, 0x00, 0x02, 0xf5, 0x00, 0x00, 0x02, 0xfd, 0x00, 0x00, 0x03, 0x06,
+    0x00, 0x00, 0x03, 0x0e, 0x00, 0x00, 0x03, 0x12, 0x00, 0x00, 0x03, 0x17,
+    0x00, 0x00, 0x03, 0x1d, 0x00, 0x00, 0x03, 0x23, 0x00, 0x00, 0x03, 0x2a,
+    0x00, 0x00, 0x03, 0x30, 0x00, 0x00, 0x03, 0x36, 0x00, 0x00, 0x03, 0x3c,
+    0x00, 0x00, 0x03, 0x42, 0x00, 0x00, 0x03, 0x48, 0x00, 0x00, 0x03, 0x4f,
+    0x00, 0x00, 0x03, 0x57, 0x00, 0x00, 0x03, 0x5e, 0x00, 0x00, 0x03, 0x65,
+    0x00, 0x00, 0x03, 0x6c, 0x00, 0x00, 0x03, 0x72, 0x00, 0x00, 0x03, 0x77,
+    0x00, 0x00, 0x03, 0x7d, 0x00, 0x00, 0x03, 0x82, 0x00, 0x00, 0x03, 0x88,
+    0x00, 0x00, 0x03, 0x8f, 0x00, 0x00, 0x03, 0x97, 0x00, 0x00, 0x03, 0x9d,
+    0x00, 0x00, 0x03, 0xa4, 0x00, 0x00, 0x03, 0xab, 0x00, 0x00, 0x03, 0xb1,
+    0x00, 0x00, 0x03, 0xb8, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x00, 0x03, 0xc6,
+    0x00, 0x00, 0x03, 0xce, 0x00, 0x00, 0x03, 0xd3, 0x00, 0x00, 0x03, 0xda,
+    0x00, 0x00, 0x03, 0xe1, 0x00, 0x00, 0x03, 0xe7, 0x00, 0x00, 0x03, 0xee,
+    0x00, 0x00, 0x03, 0xf5, 0x00, 0x00, 0x03, 0xfb, 0x00, 0x00, 0x04, 0x04,
+    0x00, 0x00, 0x04, 0x0d, 0x00, 0x00, 0x04, 0x12, 0x00, 0x00, 0x04, 0x1d,
+    0x00, 0x00, 0x04, 0x23, 0x00, 0x00, 0x04, 0x2a, 0x00, 0x00, 0x04, 0x30,
+    0x00, 0x00, 0x04, 0x35, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x04, 0x43,
+    0x00, 0x00, 0x04, 0x4b, 0x00, 0x00, 0x04, 0x51, 0x00, 0x00, 0x04, 0x58,
+    0x00, 0x00, 0x04, 0x5e, 0x00, 0x00, 0x04, 0x65, 0x00, 0x00, 0x04, 0x6b,
+    0x00, 0x00, 0x04, 0x71, 0x00, 0x00, 0x04, 0x78, 0x00, 0x00, 0x04, 0x7f,
+    0x00, 0x00, 0x04, 0x86, 0x00, 0x00, 0x04, 0x8d, 0x00, 0x00, 0x04, 0x93,
+    0x00, 0x00, 0x04, 0x99, 0x00, 0x00, 0x04, 0x9e, 0x00, 0x00, 0x04, 0xa5,
+    0x00, 0x00, 0x04, 0xac, 0x00, 0x00, 0x04, 0xb2, 0x00, 0x00, 0x04, 0xba,
+    0x00, 0x00, 0x04, 0xc2, 0x00, 0x00, 0x04, 0xc7, 0x00, 0x00, 0x04, 0xce,
+    0x00, 0x00, 0x04, 0xd6, 0x00, 0x00, 0x04, 0xda, 0x00, 0x00, 0x04, 0xdf,
+    0x00, 0x00, 0x04, 0xe5, 0x00, 0x00, 0x04, 0xeb, 0x00, 0x00, 0x04, 0xf1,
+    0x00, 0x00, 0x04, 0xf7, 0x00, 0x00, 0x04, 0xfc, 0x00, 0x00, 0x05, 0x03,
+    0x00, 0x00, 0x05, 0x07, 0x00, 0x00, 0x05, 0x0a, 0x00, 0x00, 0x05, 0x0e,
+    0x00, 0x00, 0x05, 0x15, 0x00, 0x00, 0x05, 0x1d, 0x00, 0x00, 0x05, 0x26,
+    0x00, 0x00, 0x05, 0x30, 0x00, 0x00, 0x05, 0x3a, 0x00, 0x00, 0x05, 0x41,
+    0x00, 0x00, 0x05, 0x4a, 0x00, 0x00, 0x05, 0x50, 0x00, 0x00, 0x05, 0x56,
+    0x00, 0x00, 0x05, 0x5d, 0x00, 0x00, 0x05, 0x65, 0x00, 0x00, 0x05, 0x6c,
+    0x00, 0x00, 0x05, 0x73, 0x00, 0x00, 0x05, 0x7a, 0x00, 0x00, 0x05, 0x81,
+    0x00, 0x00, 0x05, 0x86, 0x00, 0x00, 0x05, 0x8d, 0x00, 0x00, 0x05, 0x93,
+    0x00, 0x00, 0x05, 0x9a, 0x00, 0x00, 0x05, 0xa1, 0x00, 0x00, 0x05, 0xaa,
+    0x00, 0x00, 0x05, 0xb2, 0x00, 0x00, 0x05, 0xba, 0x00, 0x00, 0x05, 0xc2,
+    0x00, 0x00, 0x05, 0xcb, 0x00, 0x00, 0x05, 0xd4, 0x00, 0x00, 0x05, 0xdd,
+    0x00, 0x00, 0x05, 0xe6, 0x00, 0x00, 0x05, 0xf0, 0x00, 0x00, 0x05, 0xf9,
+    0x00, 0x00, 0x06, 0x01, 0x00, 0x00, 0x06, 0x08, 0x00, 0x00, 0x06, 0x10,
+    0x00, 0x00, 0x06, 0x16, 0x00, 0x00, 0x06, 0x1d, 0x00, 0x00, 0x06, 0x23,
+    0x00, 0x00, 0x06, 0x29, 0x00, 0x00, 0x06, 0x30, 0x00, 0x00, 0x06, 0x34,
+    0x00, 0x00, 0x06, 0x3b, 0x00, 0x00, 0x06, 0x41, 0x00, 0x00, 0x06, 0x47,
+    0x00, 0x00, 0x06, 0x4e, 0x00, 0x00, 0x06, 0x55, 0x00, 0x00, 0x06, 0x5b,
+    0x00, 0x00, 0x06, 0x62, 0x00, 0x00, 0x06, 0x67, 0x00, 0x00, 0x06, 0x71,
+    0x00, 0x00, 0x06, 0x7a, 0x00, 0x00, 0x06, 0x7e, 0x00, 0x00, 0x06, 0x83,
+    0x00, 0x00, 0x06, 0x8b, 0x00, 0x00, 0x06, 0x94, 0x00, 0x00, 0x06, 0x9e,
+    0x00, 0x00, 0x06, 0xa6, 0x00, 0x00, 0x06, 0xaf, 0x00, 0x00, 0x06, 0xb7,
+    0x00, 0x00, 0x06, 0xc1, 0x00, 0x00, 0x06, 0xcb, 0x00, 0x00, 0x06, 0xd0,
+    0x00, 0x00, 0x06, 0xda, 0x00, 0x00, 0x06, 0xe2, 0x00, 0x00, 0x06, 0xec,
+    0x00, 0x00, 0x06, 0xf3, 0x00, 0x00, 0x06, 0xfb, 0x00, 0x00, 0x07, 0x03,
+    0x00, 0x00, 0x07, 0x0a, 0x00, 0x00, 0x07, 0x10, 0x00, 0x00, 0x07, 0x17,
+    0x00, 0x00, 0x07, 0x1d, 0x00, 0x00, 0x07, 0x24, 0x00, 0x00, 0x07, 0x2d,
+    0x00, 0x00, 0x07, 0x35, 0x00, 0x00, 0x07, 0x3d, 0x00, 0x00, 0x07, 0x48,
+    0x00, 0x00, 0x07, 0x50, 0x00, 0x00, 0x07, 0x5b, 0x00, 0x00, 0x07, 0x61,
+    0x00, 0x00, 0x07, 0x68, 0x00, 0x00, 0x07, 0x72, 0x00, 0x00, 0x07, 0x7c,
+    0x00, 0x00, 0x07, 0x84, 0x00, 0x00, 0x07, 0x8f, 0x00, 0x00, 0x07, 0x98,
+    0x00, 0x00, 0x07, 0xa0, 0x00, 0x00, 0x07, 0xa7, 0x00, 0x00, 0x07, 0xae,
+    0x00, 0x00, 0x07, 0xb3, 0x00, 0x00, 0x07, 0xbc, 0x00, 0x00, 0x07, 0xc2,
+    0x00, 0x00, 0x07, 0xc8, 0x00, 0x00, 0x07, 0xcc, 0x00, 0x00, 0x07, 0xd4,
+    0x00, 0x00, 0x07, 0xdd, 0x00, 0x00, 0x07, 0xe5, 0x00, 0x00, 0x07, 0xed,
+    0x00, 0x00, 0x07, 0xf4, 0x00, 0x00, 0x07, 0xfb, 0x00, 0x00, 0x08, 0x03,
+    0x00, 0x00, 0x08, 0x0a, 0x00, 0x00, 0x08, 0x12, 0x00, 0x00, 0x08, 0x1a,
+    0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x08, 0x26, 0x00, 0x00, 0x08, 0x2d,
+    0x00, 0x00, 0x08, 0x34, 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x46,
+    0x00, 0x00, 0x08, 0x4d, 0x00, 0x00, 0x08, 0x54, 0x00, 0x00, 0x08, 0x5c,
+    0x00, 0x00, 0x08, 0x64, 0x00, 0x00, 0x08, 0x6a, 0x00, 0x00, 0x08, 0x6f,
+    0x00, 0x00, 0x08, 0x75, 0x00, 0x00, 0x08, 0x7d, 0x00, 0x00, 0x08, 0x82,
+    0x00, 0x00, 0x08, 0x89, 0x00, 0x00, 0x08, 0x90, 0x00, 0x00, 0x08, 0x96,
+    0x00, 0x00, 0x08, 0x9d, 0x00, 0x00, 0x08, 0xa4, 0x00, 0x00, 0x08, 0xac,
+    0x00, 0x00, 0x08, 0xb4, 0x00, 0x00, 0x08, 0xbc, 0x00, 0x00, 0x08, 0xc2,
+    0x00, 0x00, 0x08, 0xca, 0x00, 0x00, 0x08, 0xd1, 0x00, 0x00, 0x08, 0xd8,
+    0x00, 0x00, 0x08, 0xdf, 0x00, 0x00, 0x08, 0xe7, 0x00, 0x00, 0x08, 0xf1,
+    0x00, 0x00, 0x08, 0xf9, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x08,
+    0x00, 0x00, 0x09, 0x10, 0x00, 0x00, 0x09, 0x18, 0x00, 0x00, 0x09, 0x1f,
+    0x00, 0x00, 0x09, 0x26, 0x00, 0x00, 0x09, 0x2e, 0x00, 0x00, 0x09, 0x36,
+    0x00, 0x00, 0x09, 0x3b, 0x00, 0x00, 0x09, 0x41, 0x00, 0x00, 0x09, 0x45,
+    0x00, 0x00, 0x09, 0x4c, 0x00, 0x00, 0x09, 0x52, 0x00, 0x00, 0x09, 0x59,
+    0x00, 0x00, 0x09, 0x61, 0x00, 0x00, 0x09, 0x65, 0x00, 0x00, 0x09, 0x6a,
+    0x00, 0x00, 0x09, 0x72, 0x00, 0x00, 0x09, 0x79, 0x00, 0x00, 0x09, 0x80,
+    0x00, 0x00, 0x09, 0x87, 0x00, 0x00, 0x09, 0x90, 0x00, 0x00, 0x09, 0x97,
+    0x00, 0x00, 0x09, 0x9d, 0x00, 0x00, 0x09, 0xa4, 0x00, 0x00, 0x09, 0xaa,
+    0x00, 0x00, 0x09, 0xb1, 0x00, 0x00, 0x09, 0xb8, 0x00, 0x00, 0x09, 0xbd,
+    0x00, 0x00, 0x09, 0xc3, 0x00, 0x00, 0x09, 0xcb, 0x00, 0x00, 0x09, 0xd2,
+    0x00, 0x00, 0x09, 0xdb, 0x00, 0x00, 0x09, 0xe2, 0x00, 0x00, 0x09, 0xe9,
+    0x00, 0x00, 0x09, 0xef, 0x00, 0x00, 0x09, 0xf5, 0x00, 0x00, 0x09, 0xfc,
+    0x00, 0x00, 0x0a, 0x03, 0x00, 0x00, 0x0a, 0x0a, 0x00, 0x00, 0x0a, 0x11,
+    0x00, 0x00, 0x0a, 0x17, 0x00, 0x00, 0x0a, 0x1e, 0x00, 0x00, 0x0a, 0x26,
+    0x00, 0x00, 0x0a, 0x30, 0x00, 0x00, 0x0a, 0x3a, 0x00, 0x00, 0x0a, 0x43,
+    0x00, 0x00, 0x0a, 0x4b, 0x00, 0x00, 0x0a, 0x50, 0x00, 0x00, 0x0a, 0x56,
+    0x00, 0x00, 0x0a, 0x5e, 0x00, 0x00, 0x0a, 0x66, 0x00, 0x00, 0x0a, 0x6d,
+    0x00, 0x00, 0x0a, 0x74, 0x00, 0x00, 0x0a, 0x7b, 0x00, 0x00, 0x0a, 0x82,
+    0x00, 0x00, 0x0a, 0x86, 0x00, 0x00, 0x0a, 0x8e, 0x00, 0x00, 0x0a, 0x94,
+    0x00, 0x00, 0x0a, 0x99, 0x00, 0x00, 0x0a, 0x9f, 0x00, 0x00, 0x0a, 0xa6,
+    0x00, 0x00, 0x0a, 0xac, 0x00, 0x00, 0x0a, 0xb2, 0x00, 0x00, 0x0a, 0xb9,
+    0x00, 0x00, 0x0a, 0xc0, 0x00, 0x00, 0x0a, 0xc7, 0x00, 0x00, 0x0a, 0xcf,
+    0x00, 0x00, 0x0a, 0xd5, 0x00, 0x00, 0x0a, 0xdc, 0x00, 0x00, 0x0a, 0xe4,
+    0x00, 0x00, 0x0a, 0xeb, 0x00, 0x00, 0x0a, 0xf1, 0x00, 0x00, 0x0a, 0xf5,
+    0x00, 0x00, 0x0a, 0xfe, 0x00, 0x00, 0x0b, 0x03, 0x00, 0x00, 0x0b, 0x0a,
+    0x00, 0x00, 0x0b, 0x12, 0x00, 0x00, 0x0b, 0x1a, 0x00, 0x00, 0x0b, 0x21,
+    0x00, 0x00, 0x0b, 0x28, 0x00, 0x00, 0x0b, 0x2d, 0x00, 0x00, 0x0b, 0x34,
+    0x00, 0x00, 0x0b, 0x3c, 0x00, 0x00, 0x0b, 0x43, 0x00, 0x00, 0x0b, 0x49,
+    0x00, 0x00, 0x0b, 0x4e, 0x00, 0x00, 0x0b, 0x55, 0x00, 0x00, 0x0b, 0x5b,
+    0x00, 0x00, 0x0b, 0x63, 0x00, 0x00, 0x0b, 0x67, 0x00, 0x00, 0x0b, 0x6d,
+    0x00, 0x00, 0x0b, 0x76, 0x00, 0x00, 0x0b, 0x7e, 0x00, 0x00, 0x0b, 0x86,
+    0x00, 0x00, 0x0b, 0x8b, 0x00, 0x00, 0x0b, 0x93, 0x00, 0x00, 0x0b, 0x98,
+    0x00, 0x00, 0x0b, 0x9e, 0x00, 0x00, 0x0b, 0xa5, 0x00, 0x00, 0x0b, 0xab,
+    0x00, 0x00, 0x0b, 0xaf, 0x00, 0x00, 0x0b, 0xb5, 0x00, 0x00, 0x0b, 0xbb,
+    0x00, 0x00, 0x0b, 0xc3, 0x00, 0x00, 0x0b, 0xca, 0x00, 0x00, 0x0b, 0xcf,
+    0x00, 0x00, 0x0b, 0xd5, 0x00, 0x00, 0x0b, 0xdb, 0x00, 0x00, 0x0b, 0xe1,
+    0x00, 0x00, 0x0b, 0xe5, 0x00, 0x00, 0x0b, 0xee, 0x00, 0x00, 0x0b, 0xf5,
+    0x00, 0x00, 0x0b, 0xfc, 0x00, 0x00, 0x0c, 0x05, 0x00, 0x00, 0x0c, 0x0d,
+    0x00, 0x00, 0x0c, 0x14, 0x00, 0x00, 0x0c, 0x1a, 0x00, 0x00, 0x0c, 0x21,
+    0x00, 0x00, 0x0c, 0x2a, 0x00, 0x00, 0x0c, 0x30, 0x00, 0x00, 0x0c, 0x3b,
+    0x00, 0x00, 0x0c, 0x45, 0x00, 0x00, 0x0c, 0x4d, 0x00, 0x00, 0x0c, 0x56,
+    0x00, 0x00, 0x0c, 0x61, 0x00, 0x00, 0x0c, 0x6c, 0x00, 0x00, 0x0c, 0x75,
+    0x00, 0x00, 0x0c, 0x7e, 0x00, 0x00, 0x0c, 0x87, 0x00, 0x00, 0x0c, 0x8f,
+    0x00, 0x00, 0x0c, 0x96, 0x00, 0x00, 0x0c, 0x9f, 0x00, 0x00, 0x0c, 0xa7,
+    0x00, 0x00, 0x0c, 0xad, 0x00, 0x00, 0x0c, 0xb2, 0x00, 0x00, 0x0c, 0xb8,
+    0x00, 0x00, 0x0c, 0xbf, 0x00, 0x00, 0x0c, 0xc6, 0x00, 0x00, 0x0c, 0xce,
+    0x00, 0x00, 0x0c, 0xd4, 0x00, 0x00, 0x0c, 0xd9, 0x00, 0x00, 0x0c, 0xe0,
+    0x00, 0x00, 0x0c, 0xe5, 0x00, 0x00, 0x0c, 0xee, 0x00, 0x00, 0x0c, 0xf6,
+    0x00, 0x00, 0x0c, 0xfe, 0x00, 0x00, 0x0d, 0x05, 0x00, 0x00, 0x0d, 0x0c,
+    0x00, 0x00, 0x0d, 0x12, 0x00, 0x00, 0x0d, 0x18, 0x00, 0x00, 0x0d, 0x1f,
+    0x00, 0x00, 0x0d, 0x27, 0x00, 0x00, 0x0d, 0x2d, 0x00, 0x00, 0x0d, 0x36,
+    0x00, 0x00, 0x0d, 0x3d, 0x00, 0x00, 0x0d, 0x43, 0x00, 0x00, 0x0d, 0x4a,
+    0x00, 0x00, 0x0d, 0x4e, 0x00, 0x00, 0x0d, 0x57, 0x00, 0x00, 0x0d, 0x60,
+    0x00, 0x00, 0x0d, 0x68, 0x00, 0x00, 0x0d, 0x6f, 0x00, 0x00, 0x0d, 0x74,
+    0x00, 0x00, 0x0d, 0x79, 0x00, 0x00, 0x0d, 0x7f, 0x00, 0x00, 0x0d, 0x86,
+    0x00, 0x00, 0x0d, 0x8c, 0x00, 0x00, 0x0d, 0x93, 0x00, 0x00, 0x0d, 0x9a,
+    0x00, 0x00, 0x0d, 0xa1, 0x00, 0x00, 0x0d, 0xa8, 0x00, 0x00, 0x0d, 0xae,
+    0x00, 0x00, 0x0d, 0xb4, 0x00, 0x00, 0x0d, 0xbb, 0x00, 0x00, 0x0d, 0xc2,
+    0x00, 0x00, 0x0d, 0xca, 0x00, 0x00, 0x0d, 0xd3, 0x00, 0x00, 0x0d, 0xdb,
+    0x00, 0x00, 0x0d, 0xe2, 0x00, 0x00, 0x0d, 0xe5, 0x00, 0x00, 0x0d, 0xe9,
+    0x00, 0x00, 0x0d, 0xef, 0x00, 0x00, 0x0d, 0xf6, 0x00, 0x00, 0x0d, 0xfc,
+    0x00, 0x00, 0x0e, 0x03, 0x00, 0x00, 0x0e, 0x0b, 0x00, 0x00, 0x0e, 0x0f,
+    0x00, 0x00, 0x0e, 0x14, 0x00, 0x00, 0x0e, 0x1b, 0x00, 0x00, 0x0e, 0x22,
+    0x00, 0x00, 0x0e, 0x28, 0x00, 0x00, 0x0e, 0x2f, 0x00, 0x00, 0x0e, 0x35,
+    0x00, 0x00, 0x0e, 0x3b, 0x00, 0x00, 0x0e, 0x40, 0x00, 0x00, 0x0e, 0x45,
+    0x00, 0x00, 0x0e, 0x4e, 0x00, 0x00, 0x0e, 0x56, 0x00, 0x00, 0x0e, 0x5d,
+    0x00, 0x00, 0x0e, 0x63, 0x00, 0x00, 0x0e, 0x69, 0x00, 0x00, 0x0e, 0x70,
+    0x00, 0x00, 0x0e, 0x77, 0x00, 0x00, 0x0e, 0x7f, 0x00, 0x00, 0x0e, 0x87,
+    0x00, 0x00, 0x0e, 0x8e, 0x00, 0x00, 0x0e, 0x96, 0x00, 0x00, 0x0e, 0x9e,
+    0x00, 0x00, 0x0e, 0xa5, 0x00, 0x00, 0x0e, 0xab, 0x00, 0x00, 0x0e, 0xb2,
+    0x00, 0x00, 0x0e, 0xb9, 0x00, 0x00, 0x0e, 0xc1, 0x00, 0x00, 0x0e, 0xc9,
+    0x00, 0x00, 0x0e, 0xce, 0x00, 0x00, 0x0e, 0xd5, 0x00, 0x00, 0x0e, 0xdd,
+    0x00, 0x00, 0x0e, 0xe5, 0x00, 0x00, 0x0e, 0xec, 0x00, 0x00, 0x0e, 0xf2,
+    0x00, 0x00, 0x0e, 0xfa, 0x00, 0x00, 0x0e, 0xff, 0x00, 0x00, 0x0f, 0x05,
+    0x00, 0x00, 0x0f, 0x0b, 0x00, 0x00, 0x0f, 0x12, 0x00, 0x00, 0x0f, 0x1a,
+    0x00, 0x00, 0x0f, 0x22, 0x00, 0x00, 0x0f, 0x28, 0x00, 0x00, 0x0f, 0x30,
+    0x00, 0x00, 0x0f, 0x39, 0x00, 0x00, 0x0f, 0x43, 0x00, 0x00, 0x0f, 0x4c,
+    0x00, 0x00, 0x0f, 0x53, 0x00, 0x00, 0x0f, 0x5b, 0x00, 0x00, 0x0f, 0x64,
+    0x00, 0x00, 0x0f, 0x6b, 0x00, 0x00, 0x0f, 0x73, 0x00, 0x00, 0x0f, 0x7b,
+    0x00, 0x00, 0x0f, 0x82, 0x00, 0x00, 0x0f, 0x88, 0x00, 0x00, 0x0f, 0x8f,
+    0x00, 0x00, 0x0f, 0x99, 0x00, 0x00, 0x0f, 0xa2, 0x00, 0x00, 0x0f, 0xac,
+    0x00, 0x00, 0x0f, 0xb5, 0x00, 0x00, 0x0f, 0xbe, 0x00, 0x00, 0x0f, 0xc7,
+    0x00, 0x00, 0x0f, 0xcf, 0x00, 0x00, 0x0f, 0xd7, 0x00, 0x00, 0x0f, 0xdd,
+    0x00, 0x00, 0x0f, 0xe7, 0x00, 0x00, 0x0f, 0xef, 0x00, 0x00, 0x0f, 0xf5,
+    0x00, 0x00, 0x0f, 0xfc, 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x10, 0x09,
+    0x00, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x10, 0x18, 0x00, 0x00, 0x10, 0x1e,
+    0x00, 0x00, 0x10, 0x24, 0x00, 0x00, 0x10, 0x2c, 0x00, 0x00, 0x10, 0x33,
+    0x00, 0x00, 0x10, 0x39, 0x00, 0x00, 0x10, 0x3f, 0x00, 0x00, 0x10, 0x45,
+    0x00, 0x00, 0x10, 0x4a, 0x00, 0x00, 0x10, 0x4e, 0x00, 0x00, 0x10, 0x54,
+    0x00, 0x00, 0x10, 0x5a, 0x00, 0x00, 0x10, 0x60, 0x00, 0x00, 0x10, 0x67,
+    0x00, 0x00, 0x10, 0x6c, 0x00, 0x00, 0x10, 0x72, 0x00, 0x00, 0x10, 0x78,
+    0x00, 0x00, 0x10, 0x7d, 0x00, 0x00, 0x10, 0x83, 0x00, 0x00, 0x10, 0x88,
+    0x00, 0x00, 0x10, 0x8f, 0x00, 0x00, 0x10, 0x96, 0x00, 0x00, 0x10, 0x9c,
+    0x00, 0x00, 0x10, 0xa4, 0x00, 0x00, 0x10, 0xac, 0x00, 0x00, 0x10, 0xb5,
+    0x00, 0x00, 0x10, 0xbb, 0x00, 0x00, 0x10, 0xc3, 0x00, 0x00, 0x10, 0xca,
+    0x00, 0x00, 0x10, 0xd1, 0x00, 0x00, 0x10, 0xd9, 0x00, 0x00, 0x10, 0xe2,
+    0x00, 0x00, 0x10, 0xea, 0x00, 0x00, 0x10, 0xef, 0x00, 0x00, 0x10, 0xf5,
+    0x00, 0x00, 0x10, 0xfc, 0x00, 0x00, 0x11, 0x04, 0x00, 0x00, 0x11, 0x0c,
+    0x00, 0x00, 0x11, 0x13, 0x00, 0x00, 0x11, 0x19, 0x00, 0x00, 0x11, 0x21,
+    0x00, 0x00, 0x11, 0x2a, 0x00, 0x00, 0x11, 0x35, 0x00, 0x00, 0x11, 0x3b,
+    0x00, 0x00, 0x11, 0x43, 0x00, 0x00, 0x11, 0x4b, 0x00, 0x00, 0x11, 0x52,
+    0x00, 0x00, 0x11, 0x59, 0x00, 0x00, 0x11, 0x60, 0x00, 0x00, 0x11, 0x66,
+    0x00, 0x00, 0x11, 0x6e, 0x00, 0x00, 0x11, 0x76, 0x00, 0x00, 0x11, 0x7b,
+    0x00, 0x00, 0x11, 0x81, 0x00, 0x00, 0x11, 0x87, 0x00, 0x00, 0x11, 0x8c,
+    0x00, 0x00, 0x11, 0x94, 0x00, 0x00, 0x11, 0x9a, 0x00, 0x00, 0x11, 0xa0,
+    0x00, 0x00, 0x11, 0xa7, 0x00, 0x00, 0x11, 0xae, 0x00, 0x00, 0x11, 0xb6,
+    0x00, 0x00, 0x11, 0xbd, 0x00, 0x00, 0x11, 0xc2, 0x00, 0x00, 0x11, 0xc8,
+    0x00, 0x00, 0x11, 0xcf, 0x00, 0x00, 0x11, 0xd7, 0x00, 0x00, 0x11, 0xdf,
+    0x00, 0x00, 0x11, 0xe7, 0x00, 0x00, 0x11, 0xf0, 0x00, 0x00, 0x11, 0xf7,
+    0x00, 0x00, 0x11, 0xfd, 0x00, 0x00, 0x12, 0x04, 0x00, 0x00, 0x12, 0x0c,
+    0x00, 0x00, 0x12, 0x14, 0x00, 0x00, 0x12, 0x1a, 0x00, 0x00, 0x12, 0x21,
+    0x00, 0x00, 0x12, 0x29, 0x00, 0x00, 0x12, 0x32, 0x00, 0x00, 0x12, 0x3a,
+    0x00, 0x00, 0x12, 0x40, 0x00, 0x00, 0x12, 0x47, 0x00, 0x00, 0x12, 0x4d,
+    0x00, 0x00, 0x12, 0x54, 0x00, 0x00, 0x12, 0x5b, 0x00, 0x00, 0x12, 0x63,
+    0x00, 0x00, 0x12, 0x6c, 0x00, 0x00, 0x12, 0x76, 0x00, 0x00, 0x12, 0x80,
+    0x00, 0x00, 0x12, 0x89, 0x00, 0x00, 0x12, 0x91, 0x00, 0x00, 0x12, 0x98,
+    0x00, 0x00, 0x12, 0xa0, 0x00, 0x00, 0x12, 0xa8, 0x00, 0x00, 0x12, 0xaf,
+    0x00, 0x00, 0x12, 0xb5, 0x00, 0x00, 0x12, 0xbc, 0x00, 0x00, 0x12, 0xc5,
+    0x00, 0x00, 0x12, 0xcc, 0x00, 0x00, 0x12, 0xd4, 0x00, 0x00, 0x12, 0xdc,
+    0x00, 0x00, 0x12, 0xe5, 0x00, 0x00, 0x12, 0xee, 0x00, 0x00, 0x12, 0xf5,
+    0x00, 0x00, 0x12, 0xfd, 0x00, 0x00, 0x13, 0x06, 0x00, 0x00, 0x13, 0x0f,
+    0x00, 0x00, 0x13, 0x15, 0x00, 0x00, 0x13, 0x1d, 0x00, 0x00, 0x13, 0x23,
+    0x00, 0x00, 0x13, 0x2a, 0x00, 0x00, 0x13, 0x31, 0x00, 0x00, 0x13, 0x39,
+    0x00, 0x00, 0x13, 0x3f, 0x00, 0x00, 0x13, 0x46, 0x00, 0x00, 0x13, 0x4d,
+    0x00, 0x00, 0x13, 0x52, 0x00, 0x00, 0x13, 0x58, 0x00, 0x00, 0x13, 0x60,
+    0x00, 0x00, 0x13, 0x66, 0x00, 0x00, 0x13, 0x6f, 0x00, 0x00, 0x13, 0x75,
+    0x00, 0x00, 0x13, 0x7b, 0x00, 0x00, 0x13, 0x84, 0x00, 0x00, 0x13, 0x8e,
+    0x00, 0x00, 0x13, 0x99, 0x00, 0x00, 0x13, 0xa0, 0x00, 0x00, 0x13, 0xa6,
+    0x00, 0x00, 0x13, 0xae, 0x00, 0x00, 0x13, 0xb5, 0x00, 0x00, 0x13, 0xbf,
+    0x00, 0x00, 0x13, 0xc5, 0x00, 0x00, 0x13, 0xce, 0x00, 0x00, 0x13, 0xd7,
+    0x00, 0x00, 0x13, 0xe0, 0x00, 0x00, 0x13, 0xea, 0x00, 0x00, 0x13, 0xf3,
+    0x00, 0x00, 0x13, 0xfd, 0x00, 0x00, 0x14, 0x07, 0x00, 0x00, 0x14, 0x0f,
+    0x00, 0x00, 0x14, 0x18, 0x00, 0x00, 0x14, 0x1f, 0x00, 0x00, 0x14, 0x25,
+    0x00, 0x00, 0x14, 0x2c, 0x00, 0x00, 0x14, 0x35, 0x00, 0x00, 0x14, 0x3e,
+    0x00, 0x00, 0x14, 0x46, 0x00, 0x00, 0x14, 0x4c, 0x00, 0x00, 0x14, 0x53,
+    0x00, 0x00, 0x14, 0x5b, 0x00, 0x00, 0x14, 0x63, 0x00, 0x00, 0x14, 0x69,
+    0x00, 0x00, 0x14, 0x71, 0x00, 0x00, 0x14, 0x77, 0x00, 0x00, 0x14, 0x7e,
+    0x00, 0x00, 0x14, 0x85, 0x00, 0x00, 0x14, 0x8d, 0x00, 0x00, 0x14, 0x95,
+    0x00, 0x00, 0x14, 0x9c, 0x00, 0x00, 0x14, 0xa3, 0x00, 0x00, 0x14, 0xab,
+    0x00, 0x00, 0x14, 0xb2, 0x00, 0x00, 0x14, 0xba, 0x00, 0x00, 0x14, 0xc2,
+    0x00, 0x00, 0x14, 0xcc, 0x00, 0x00, 0x14, 0xd6, 0x00, 0x00, 0x14, 0xdc,
+    0x00, 0x00, 0x14, 0xe3, 0x00, 0x00, 0x14, 0xeb, 0x00, 0x00, 0x14, 0xf2,
+    0x00, 0x00, 0x14, 0xf8, 0x00, 0x00, 0x14, 0xfe, 0x00, 0x00, 0x15, 0x04,
+    0x00, 0x00, 0x15, 0x09, 0x00, 0x00, 0x15, 0x12, 0x00, 0x00, 0x15, 0x17,
+    0x00, 0x00, 0x15, 0x1c, 0x00, 0x00, 0x15, 0x22, 0x00, 0x00, 0x15, 0x29,
+    0x00, 0x00, 0x15, 0x30, 0x00, 0x00, 0x15, 0x38, 0x00, 0x00, 0x15, 0x3f,
+    0x00, 0x00, 0x15, 0x47, 0x00, 0x00, 0x15, 0x50, 0x00, 0x00, 0x15, 0x56,
+    0x00, 0x00, 0x15, 0x5e, 0x00, 0x00, 0x15, 0x66, 0x00, 0x00, 0x15, 0x6d,
+    0x00, 0x00, 0x15, 0x75, 0x00, 0x00, 0x15, 0x7e, 0x00, 0x00, 0x15, 0x88,
+    0x00, 0x00, 0x15, 0x8e, 0x00, 0x00, 0x15, 0x95, 0x00, 0x00, 0x15, 0x9d,
+    0x00, 0x00, 0x15, 0xa6, 0x00, 0x00, 0x15, 0xaf, 0x00, 0x00, 0x15, 0xb7,
+    0x00, 0x00, 0x15, 0xbf, 0x00, 0x00, 0x15, 0xc6, 0x00, 0x00, 0x15, 0xcf,
+    0x00, 0x00, 0x15, 0xd8, 0x00, 0x00, 0x15, 0xe1, 0x00, 0x00, 0x15, 0xe9,
+    0x00, 0x00, 0x15, 0xf5, 0x00, 0x00, 0x15, 0xff, 0x00, 0x00, 0x16, 0x07,
+    0x00, 0x00, 0x16, 0x0f, 0x00, 0x00, 0x16, 0x18, 0x00, 0x00, 0x16, 0x21,
+    0x00, 0x00, 0x16, 0x2b, 0x00, 0x00, 0x16, 0x34, 0x00, 0x00, 0x16, 0x3c,
+    0x00, 0x00, 0x16, 0x45, 0x00, 0x00, 0x16, 0x4f, 0x00, 0x00, 0x16, 0x5a,
+    0x00, 0x00, 0x16, 0x5f, 0x00, 0x00, 0x16, 0x65, 0x00, 0x00, 0x16, 0x6d,
+    0x00, 0x00, 0x16, 0x75, 0x00, 0x00, 0x16, 0x7e, 0x00, 0x00, 0x16, 0x87,
+    0x00, 0x00, 0x16, 0x8c, 0x00, 0x00, 0x16, 0x95, 0x00, 0x00, 0x16, 0x9b,
+    0x00, 0x00, 0x16, 0xa3, 0x00, 0x00, 0x16, 0xab, 0x00, 0x00, 0x16, 0xb3,
+    0x00, 0x00, 0x16, 0xb8, 0x00, 0x00, 0x16, 0xbe, 0x00, 0x00, 0x16, 0xc5,
+    0x00, 0x00, 0x16, 0xce, 0x00, 0x00, 0x16, 0xd4, 0x00, 0x00, 0x16, 0xdb,
+    0x00, 0x00, 0x16, 0xe4, 0x00, 0x00, 0x16, 0xec, 0x00, 0x00, 0x16, 0xf4,
+    0x00, 0x00, 0x16, 0xfb, 0x00, 0x00, 0x17, 0x03, 0x00, 0x00, 0x17, 0x0a,
+    0x00, 0x00, 0x17, 0x12, 0x00, 0x00, 0x17, 0x19, 0x00, 0x00, 0x17, 0x21,
+    0x00, 0x00, 0x17, 0x27, 0x00, 0x00, 0x17, 0x2e, 0x00, 0x00, 0x17, 0x36,
+    0x00, 0x00, 0x17, 0x3e, 0x00, 0x00, 0x17, 0x46, 0x00, 0x00, 0x17, 0x4b,
+    0x00, 0x00, 0x17, 0x54, 0x00, 0x00, 0x17, 0x58, 0x00, 0x00, 0x17, 0x5d,
+    0x00, 0x00, 0x17, 0x64, 0x00, 0x00, 0x17, 0x69, 0x00, 0x00, 0x17, 0x6f,
+    0x00, 0x00, 0x17, 0x75, 0x00, 0x00, 0x17, 0x7e, 0x00, 0x00, 0x17, 0x84,
+    0x00, 0x00, 0x17, 0x8a, 0x00, 0x00, 0x17, 0x90, 0x00, 0x00, 0x17, 0x98,
+    0x00, 0x00, 0x17, 0xa0, 0x00, 0x00, 0x17, 0xa9, 0x00, 0x00, 0x17, 0xb3,
+    0x00, 0x00, 0x17, 0xbc, 0x00, 0x00, 0x17, 0xc5, 0x00, 0x00, 0x17, 0xcf,
+    0x00, 0x00, 0x17, 0xd9, 0x00, 0x00, 0x17, 0xe1, 0x00, 0x00, 0x17, 0xea,
+    0x00, 0x00, 0x17, 0xf4, 0x00, 0x00, 0x17, 0xff, 0x00, 0x00, 0x18, 0x0a,
+    0x00, 0x00, 0x18, 0x13, 0x00, 0x00, 0x18, 0x1c, 0x00, 0x00, 0x18, 0x26,
+    0x00, 0x00, 0x18, 0x30, 0x00, 0x00, 0x18, 0x3b, 0x00, 0x00, 0x18, 0x46,
+    0x00, 0x00, 0x18, 0x52, 0x00, 0x00, 0x18, 0x5a, 0x00, 0x00, 0x18, 0x63,
+    0x00, 0x00, 0x18, 0x67, 0x00, 0x00, 0x18, 0x6d, 0x00, 0x00, 0x18, 0x72,
+    0x00, 0x00, 0x18, 0x78, 0x00, 0x00, 0x18, 0x7e, 0x00, 0x00, 0x18, 0x85,
+    0x00, 0x00, 0x18, 0x8b, 0x00, 0x00, 0x18, 0x92, 0x00, 0x00, 0x18, 0x98,
+    0x00, 0x00, 0x18, 0xa3, 0x00, 0x00, 0x18, 0xa9, 0x00, 0x00, 0x18, 0xb0,
+    0x00, 0x00, 0x18, 0xb6, 0x00, 0x00, 0x18, 0xbe, 0x00, 0x00, 0x18, 0xc3,
+    0x00, 0x00, 0x18, 0xc9, 0x00, 0x00, 0x18, 0xd0, 0x00, 0x00, 0x18, 0xd6,
+    0x00, 0x00, 0x18, 0xdc, 0x00, 0x00, 0x18, 0xe5, 0x00, 0x00, 0x18, 0xee,
+    0x00, 0x00, 0x18, 0xf7, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x08,
+    0x00, 0x00, 0x19, 0x11, 0x00, 0x00, 0x19, 0x19, 0x00, 0x00, 0x19, 0x20,
+    0x00, 0x00, 0x19, 0x28, 0x00, 0x00, 0x19, 0x31, 0x00, 0x00, 0x19, 0x39,
+    0x00, 0x00, 0x19, 0x3f, 0x00, 0x00, 0x19, 0x47, 0x00, 0x00, 0x19, 0x4d,
+    0x00, 0x00, 0x19, 0x54, 0x00, 0x00, 0x19, 0x5e, 0x00, 0x00, 0x19, 0x66,
+    0x00, 0x00, 0x19, 0x6e, 0x00, 0x00, 0x19, 0x77, 0x00, 0x00, 0x19, 0x7f,
+    0x00, 0x00, 0x19, 0x84, 0x00, 0x00, 0x19, 0x8c, 0x00, 0x00, 0x19, 0x93,
+    0x00, 0x00, 0x19, 0x9d, 0x00, 0x00, 0x19, 0xa5, 0x00, 0x00, 0x19, 0xae,
+    0x00, 0x00, 0x19, 0xb9, 0x00, 0x00, 0x19, 0xc4, 0x00, 0x00, 0x19, 0xcc,
+    0x00, 0x00, 0x19, 0xd1, 0x00, 0x00, 0x19, 0xdb, 0x00, 0x00, 0x19, 0xe2,
+    0x00, 0x00, 0x19, 0xec, 0x00, 0x00, 0x19, 0xf2, 0x00, 0x00, 0x19, 0xf9,
+    0x00, 0x00, 0x1a, 0x03, 0x00, 0x00, 0x1a, 0x09, 0x00, 0x00, 0x1a, 0x12,
+    0x00, 0x00, 0x1a, 0x1a, 0x00, 0x00, 0x1a, 0x20, 0x00, 0x00, 0x1a, 0x28,
+    0x00, 0x00, 0x1a, 0x2e, 0x00, 0x00, 0x1a, 0x37, 0x00, 0x00, 0x1a, 0x40,
+    0x00, 0x00, 0x1a, 0x46, 0x00, 0x00, 0x1a, 0x4b, 0x00, 0x00, 0x1a, 0x50,
+    0x00, 0x00, 0x1a, 0x56, 0x00, 0x00, 0x1a, 0x5b, 0x00, 0x00, 0x1a, 0x62,
+    0x00, 0x00, 0x1a, 0x6a, 0x00, 0x00, 0x1a, 0x71, 0x00, 0x00, 0x1a, 0x79,
+    0x00, 0x00, 0x1a, 0x81, 0x00, 0x00, 0x1a, 0x87, 0x00, 0x00, 0x1a, 0x8f,
+    0x00, 0x00, 0x1a, 0x96, 0x00, 0x00, 0x1a, 0x9e, 0x00, 0x00, 0x1a, 0xa7,
+    0x00, 0x00, 0x1a, 0xae, 0x00, 0x00, 0x1a, 0xb5, 0x00, 0x00, 0x1a, 0xbe,
+    0x00, 0x00, 0x1a, 0xc9, 0x00, 0x00, 0x1a, 0xd4, 0x00, 0x00, 0x1a, 0xdd,
+    0x00, 0x00, 0x1a, 0xe4, 0x00, 0x00, 0x1a, 0xed, 0x00, 0x00, 0x1a, 0xf4,
+    0x00, 0x00, 0x1a, 0xfb, 0x00, 0x00, 0x1b, 0x05, 0x00, 0x00, 0x1b, 0x0e,
+    0x00, 0x00, 0x1b, 0x17, 0x00, 0x00, 0x1b, 0x20, 0x00, 0x00, 0x1b, 0x25,
+    0x00, 0x00, 0x1b, 0x2b, 0x00, 0x00, 0x1b, 0x33, 0x00, 0x00, 0x1b, 0x3b,
+    0x00, 0x00, 0x1b, 0x43, 0x00, 0x00, 0x1b, 0x4c, 0x00, 0x00, 0x1b, 0x54,
+    0x00, 0x00, 0x1b, 0x5b, 0x00, 0x00, 0x1b, 0x62, 0x00, 0x00, 0x1b, 0x69,
+    0x00, 0x00, 0x1b, 0x70, 0x00, 0x00, 0x1b, 0x78, 0x00, 0x00, 0x1b, 0x7e,
+    0x00, 0x00, 0x1b, 0x83, 0x00, 0x00, 0x1b, 0x89, 0x00, 0x00, 0x1b, 0x90,
+    0x00, 0x00, 0x1b, 0x97, 0x00, 0x00, 0x1b, 0x9f, 0x00, 0x00, 0x1b, 0xa7,
+    0x00, 0x00, 0x1b, 0xaf, 0x00, 0x00, 0x1b, 0xb8, 0x00, 0x00, 0x1b, 0xc2,
+    0x00, 0x00, 0x1b, 0xca, 0x00, 0x00, 0x1b, 0xd1, 0x00, 0x00, 0x1b, 0xd8,
+    0x00, 0x00, 0x1b, 0xe0, 0x00, 0x00, 0x1b, 0xe8, 0x00, 0x00, 0x1b, 0xf1,
+    0x00, 0x00, 0x1b, 0xf8, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x05,
+    0x00, 0x00, 0x1c, 0x0e, 0x00, 0x00, 0x1c, 0x12, 0x00, 0x00, 0x1c, 0x18,
+    0x00, 0x00, 0x1c, 0x1f, 0x00, 0x00, 0x1c, 0x24, 0x00, 0x00, 0x1c, 0x2d,
+    0x00, 0x00, 0x1c, 0x34, 0x00, 0x00, 0x1c, 0x3b, 0x00, 0x00, 0x1c, 0x43,
+    0x00, 0x00, 0x1c, 0x4b, 0x00, 0x00, 0x1c, 0x52, 0x00, 0x00, 0x1c, 0x5a,
+    0x00, 0x00, 0x1c, 0x62, 0x00, 0x00, 0x1c, 0x6b, 0x00, 0x00, 0x1c, 0x74,
+    0x00, 0x00, 0x1c, 0x7e, 0x00, 0x00, 0x1c, 0x89, 0x00, 0x00, 0x1c, 0x90,
+    0x00, 0x00, 0x1c, 0x95, 0x00, 0x00, 0x1c, 0x9c, 0x00, 0x00, 0x1c, 0xa4,
+    0x00, 0x00, 0x1c, 0xac, 0x00, 0x00, 0x1c, 0xb0, 0x00, 0x00, 0x1c, 0xb5,
+    0x00, 0x00, 0x1c, 0xbc, 0x00, 0x00, 0x1c, 0xc2, 0x00, 0x00, 0x1c, 0xc8,
+    0x00, 0x00, 0x1c, 0xd0, 0x00, 0x00, 0x1c, 0xd6, 0x00, 0x00, 0x1c, 0xde,
+    0x00, 0x00, 0x1c, 0xe4, 0x00, 0x00, 0x1c, 0xeb, 0x00, 0x00, 0x1c, 0xf1,
+    0x00, 0x00, 0x1c, 0xf8, 0x00, 0x00, 0x1c, 0xfe, 0x00, 0x00, 0x1d, 0x05,
+    0x00, 0x00, 0x1d, 0x0b, 0x00, 0x00, 0x1d, 0x11, 0x00, 0x00, 0x1d, 0x18,
+    0x00, 0x00, 0x1d, 0x1e, 0x00, 0x00, 0x1d, 0x25, 0x00, 0x00, 0x1d, 0x2a,
+    0x00, 0x00, 0x1d, 0x31, 0x00, 0x00, 0x1d, 0x37, 0x00, 0x00, 0x1d, 0x3e,
+    0x00, 0x00, 0x1d, 0x45, 0x00, 0x00, 0x1d, 0x4c, 0x00, 0x00, 0x1d, 0x54,
+    0x00, 0x00, 0x1d, 0x5b, 0x00, 0x00, 0x1d, 0x62, 0x00, 0x00, 0x1d, 0x69,
+    0x00, 0x00, 0x1d, 0x6f, 0x00, 0x00, 0x1d, 0x73, 0x00, 0x00, 0x1d, 0x78,
+    0x00, 0x00, 0x1d, 0x7e, 0x00, 0x00, 0x1d, 0x83, 0x00, 0x00, 0x1d, 0x8b,
+    0x00, 0x00, 0x1d, 0x93, 0x00, 0x00, 0x1d, 0x98, 0x00, 0x00, 0x1d, 0x9e,
+    0x00, 0x00, 0x1d, 0xa5, 0x00, 0x00, 0x1d, 0xac, 0x00, 0x00, 0x1d, 0xb3,
+    0x00, 0x00, 0x1d, 0xbb, 0x00, 0x00, 0x1d, 0xc3, 0x00, 0x00, 0x1d, 0xcb,
+    0x00, 0x00, 0x1d, 0xd4, 0x00, 0x00, 0x1d, 0xdd, 0x00, 0x00, 0x1d, 0xe4,
+    0x00, 0x00, 0x1d, 0xec, 0x00, 0x00, 0x1d, 0xf3, 0x00, 0x00, 0x1d, 0xfa,
+    0x00, 0x00, 0x1d, 0xff, 0x00, 0x00, 0x1e, 0x05, 0x00, 0x00, 0x1e, 0x0e,
+    0x00, 0x00, 0x1e, 0x15, 0x00, 0x00, 0x1e, 0x1f, 0x00, 0x00, 0x1e, 0x25,
+    0x00, 0x00, 0x1e, 0x2b, 0x00, 0x00, 0x1e, 0x32, 0x00, 0x00, 0x1e, 0x39,
+    0x00, 0x00, 0x1e, 0x41, 0x00, 0x00, 0x1e, 0x4a, 0x00, 0x00, 0x1e, 0x52,
+    0x00, 0x00, 0x1e, 0x59, 0x00, 0x00, 0x1e, 0x5e, 0x00, 0x00, 0x1e, 0x64,
+    0x00, 0x00, 0x1e, 0x6b, 0x00, 0x00, 0x1e, 0x72, 0x00, 0x00, 0x1e, 0x78,
+    0x00, 0x00, 0x1e, 0x7f, 0x00, 0x00, 0x1e, 0x85, 0x00, 0x00, 0x1e, 0x8c,
+    0x00, 0x00, 0x1e, 0x92, 0x00, 0x00, 0x1e, 0x98, 0x00, 0x00, 0x1e, 0x9e,
+    0x00, 0x00, 0x1e, 0xa4, 0x00, 0x00, 0x1e, 0xab, 0x00, 0x00, 0x1e, 0xb1,
+    0x00, 0x00, 0x1e, 0xb9, 0x00, 0x00, 0x1e, 0xc1, 0x00, 0x00, 0x1e, 0xc9,
+    0x00, 0x00, 0x1e, 0xd1, 0x00, 0x00, 0x1e, 0xd9, 0x00, 0x00, 0x1e, 0xdf,
+    0x00, 0x00, 0x1e, 0xe6, 0x00, 0x00, 0x1e, 0xee, 0x00, 0x00, 0x1e, 0xf5,
+    0x00, 0x00, 0x1e, 0xfd, 0x00, 0x00, 0x1f, 0x04, 0x00, 0x00, 0x1f, 0x0b,
+    0x00, 0x00, 0x1f, 0x12, 0x00, 0x00, 0x1f, 0x19, 0x00, 0x00, 0x1f, 0x1f,
+    0x00, 0x00, 0x1f, 0x24, 0x00, 0x00, 0x1f, 0x2a, 0x00, 0x00, 0x1f, 0x31,
+    0x00, 0x00, 0x1f, 0x38, 0x00, 0x00, 0x1f, 0x3e, 0x00, 0x00, 0x1f, 0x43,
+    0x00, 0x00, 0x1f, 0x49, 0x00, 0x00, 0x1f, 0x4f, 0x00, 0x00, 0x1f, 0x55,
+    0x00, 0x00, 0x1f, 0x5b, 0x00, 0x00, 0x1f, 0x61, 0x00, 0x00, 0x1f, 0x68,
+    0x00, 0x00, 0x1f, 0x6d, 0x00, 0x00, 0x1f, 0x73, 0x00, 0x00, 0x1f, 0x7b,
+    0x00, 0x00, 0x1f, 0x83, 0x00, 0x00, 0x1f, 0x8c, 0x00, 0x00, 0x1f, 0x92,
+    0x00, 0x00, 0x1f, 0x9b, 0x00, 0x00, 0x1f, 0xa1, 0x00, 0x00, 0x1f, 0xa8,
+    0x00, 0x00, 0x1f, 0xaf, 0x00, 0x00, 0x1f, 0xb3, 0x00, 0x00, 0x1f, 0xb9,
+    0x00, 0x00, 0x1f, 0xc0, 0x00, 0x00, 0x1f, 0xc7, 0x00, 0x00, 0x1f, 0xcd,
+    0x00, 0x00, 0x1f, 0xd4, 0x00, 0x00, 0x1f, 0xd9, 0x00, 0x00, 0x1f, 0xe0,
+    0x00, 0x00, 0x1f, 0xe8, 0x00, 0x00, 0x1f, 0xee, 0x00, 0x00, 0x1f, 0xf5,
+    0x00, 0x00, 0x1f, 0xfd, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x20, 0x08,
+    0x00, 0x00, 0x20, 0x0c, 0x00, 0x00, 0x20, 0x13, 0x00, 0x00, 0x20, 0x1b,
+    0x00, 0x00, 0x20, 0x22, 0x00, 0x00, 0x20, 0x29, 0x00, 0x00, 0x20, 0x2f,
+    0x00, 0x00, 0x20, 0x36, 0x00, 0x00, 0x20, 0x3d, 0x00, 0x00, 0x20, 0x44,
+    0x00, 0x00, 0x20, 0x4c, 0x00, 0x00, 0x20, 0x51, 0x00, 0x00, 0x20, 0x55,
+    0x00, 0x00, 0x20, 0x5d, 0x00, 0x00, 0x20, 0x64, 0x00, 0x00, 0x20, 0x6c,
+    0x00, 0x00, 0x20, 0x73, 0x00, 0x00, 0x20, 0x7a, 0x00, 0x00, 0x20, 0x82,
+    0x00, 0x00, 0x20, 0x88, 0x00, 0x00, 0x20, 0x90, 0x00, 0x00, 0x20, 0x97,
+    0x00, 0x00, 0x20, 0x9f, 0x00, 0x00, 0x20, 0xa7, 0x00, 0x00, 0x20, 0xae,
+    0x00, 0x00, 0x20, 0xb3, 0x00, 0x00, 0x20, 0xb9, 0x00, 0x00, 0x20, 0xbf,
+    0x00, 0x00, 0x20, 0xc6, 0x00, 0x00, 0x20, 0xcd, 0x00, 0x00, 0x20, 0xd3,
+    0x00, 0x00, 0x20, 0xda, 0x00, 0x00, 0x20, 0xe2, 0x00, 0x00, 0x20, 0xe9,
+    0x00, 0x00, 0x20, 0xf1, 0x00, 0x00, 0x20, 0xf9, 0x00, 0x00, 0x21, 0x01,
+    0x00, 0x00, 0x21, 0x09, 0x00, 0x00, 0x21, 0x10, 0x00, 0x00, 0x21, 0x18,
+    0x00, 0x00, 0x21, 0x21, 0x00, 0x00, 0x21, 0x28, 0x00, 0x00, 0x21, 0x2e,
+    0x00, 0x00, 0x21, 0x37, 0x00, 0x00, 0x21, 0x3f, 0x00, 0x00, 0x21, 0x48,
+    0x00, 0x00, 0x21, 0x52, 0x00, 0x00, 0x21, 0x5c, 0x00, 0x00, 0x21, 0x61,
+    0x00, 0x00, 0x21, 0x67, 0x00, 0x00, 0x21, 0x6e, 0x00, 0x00, 0x21, 0x75,
+    0x00, 0x00, 0x21, 0x7c, 0x00, 0x00, 0x21, 0x82, 0x00, 0x00, 0x21, 0x89,
+    0x00, 0x00, 0x21, 0x91, 0x00, 0x00, 0x21, 0x99, 0x00, 0x00, 0x21, 0xa0,
+    0x00, 0x00, 0x21, 0xa6, 0x00, 0x00, 0x21, 0xad, 0x00, 0x00, 0x21, 0xb5,
+    0x00, 0x00, 0x21, 0xbb, 0x00, 0x00, 0x21, 0xc2, 0x00, 0x00, 0x21, 0xc9,
+    0x00, 0x00, 0x21, 0xce, 0x00, 0x00, 0x21, 0xd5, 0x00, 0x00, 0x21, 0xdb,
+    0x00, 0x00, 0x21, 0xe2, 0x00, 0x00, 0x21, 0xea, 0x00, 0x00, 0x21, 0xf2,
+    0x00, 0x00, 0x21, 0xfa, 0x00, 0x00, 0x22, 0x01, 0x00, 0x00, 0x22, 0x09,
+    0x00, 0x00, 0x22, 0x11, 0x00, 0x00, 0x22, 0x19, 0x00, 0x00, 0x22, 0x20,
+    0x00, 0x00, 0x22, 0x28, 0x00, 0x00, 0x22, 0x2e, 0x00, 0x00, 0x22, 0x34,
+    0x00, 0x00, 0x22, 0x3a, 0x00, 0x00, 0x22, 0x41, 0x00, 0x00, 0x22, 0x48,
+    0x00, 0x00, 0x22, 0x50, 0x00, 0x00, 0x22, 0x58, 0x00, 0x00, 0x22, 0x5e,
+    0x00, 0x00, 0x22, 0x65, 0x00, 0x00, 0x22, 0x6c, 0x00, 0x00, 0x22, 0x70,
+    0x00, 0x00, 0x22, 0x78, 0x00, 0x00, 0x22, 0x7d, 0x00, 0x00, 0x22, 0x83,
+    0x00, 0x00, 0x22, 0x89, 0x00, 0x00, 0x22, 0x8f, 0x00, 0x00, 0x22, 0x96,
+    0x00, 0x00, 0x22, 0x9d, 0x00, 0x00, 0x22, 0xa2, 0x00, 0x00, 0x22, 0xa9,
+    0x00, 0x00, 0x22, 0xb0, 0x00, 0x00, 0x22, 0xb6, 0x00, 0x00, 0x22, 0xbe,
+    0x00, 0x00, 0x22, 0xc4, 0x00, 0x00, 0x22, 0xcb, 0x00, 0x00, 0x22, 0xd2,
+    0x00, 0x00, 0x22, 0xd7, 0x00, 0x00, 0x22, 0xdd, 0x00, 0x00, 0x22, 0xe2,
+    0x00, 0x00, 0x22, 0xea, 0x00, 0x00, 0x22, 0xef, 0x00, 0x00, 0x22, 0xf5,
+    0x00, 0x00, 0x22, 0xfc, 0x00, 0x00, 0x23, 0x03, 0x00, 0x00, 0x23, 0x08,
+    0x00, 0x00, 0x23, 0x0f, 0x00, 0x00, 0x23, 0x15, 0x00, 0x00, 0x23, 0x1b,
+    0x00, 0x00, 0x23, 0x22, 0x00, 0x00, 0x23, 0x28, 0x00, 0x00, 0x23, 0x30,
+    0x00, 0x00, 0x23, 0x38, 0x00, 0x00, 0x23, 0x40, 0x00, 0x00, 0x23, 0x49,
+    0x00, 0x00, 0x23, 0x51, 0x00, 0x00, 0x23, 0x59, 0x00, 0x00, 0x23, 0x61,
+    0x00, 0x00, 0x23, 0x6a, 0x00, 0x00, 0x23, 0x73, 0x00, 0x00, 0x23, 0x7d,
+    0x00, 0x00, 0x23, 0x86, 0x00, 0x00, 0x23, 0x8f, 0x00, 0x00, 0x23, 0x99,
+    0x00, 0x00, 0x23, 0x9d, 0x00, 0x00, 0x23, 0xa2, 0x00, 0x00, 0x23, 0xa9,
+    0x00, 0x00, 0x23, 0xb1, 0x00, 0x00, 0x23, 0xb9, 0x00, 0x00, 0x23, 0xc1,
+    0x00, 0x00, 0x23, 0xc6, 0x00, 0x00, 0x23, 0xcd, 0x00, 0x00, 0x23, 0xd2,
+    0x00, 0x00, 0x23, 0xd8, 0x00, 0x00, 0x23, 0xe0, 0x00, 0x00, 0x23, 0xe9,
+    0x00, 0x00, 0x23, 0xf2, 0x00, 0x00, 0x23, 0xf9, 0x00, 0x00, 0x23, 0xff,
+    0x00, 0x00, 0x24, 0x07, 0x00, 0x00, 0x24, 0x0d, 0x00, 0x00, 0x24, 0x13,
+    0x00, 0x00, 0x24, 0x18, 0x00, 0x00, 0x24, 0x20, 0x00, 0x00, 0x24, 0x27,
+    0x00, 0x00, 0x24, 0x30, 0x00, 0x00, 0x24, 0x37, 0x00, 0x00, 0x24, 0x3e,
+    0x00, 0x00, 0x24, 0x46, 0x00, 0x00, 0x24, 0x4f, 0x00, 0x00, 0x24, 0x57,
+    0x00, 0x00, 0x24, 0x5c, 0x00, 0x00, 0x24, 0x62, 0x00, 0x00, 0x24, 0x69,
+    0x00, 0x00, 0x24, 0x6f, 0x00, 0x00, 0x24, 0x77, 0x00, 0x00, 0x24, 0x7e,
+    0x00, 0x00, 0x24, 0x84, 0x00, 0x00, 0x24, 0x8a, 0x00, 0x00, 0x24, 0x92,
+    0x00, 0x00, 0x24, 0x9b, 0x00, 0x00, 0x24, 0xa3, 0x00, 0x00, 0x24, 0xaa,
+    0x00, 0x00, 0x24, 0xb1, 0x00, 0x00, 0x24, 0xb8, 0x00, 0x00, 0x24, 0xc0,
+    0x00, 0x00, 0x24, 0xc8, 0x00, 0x00, 0x24, 0xcf, 0x00, 0x00, 0x24, 0xd3,
+    0x00, 0x00, 0x24, 0xda, 0x00, 0x00, 0x24, 0xe0, 0x00, 0x00, 0x24, 0xe5,
+    0x00, 0x00, 0x24, 0xed, 0x00, 0x00, 0x24, 0xf6, 0x00, 0x00, 0x24, 0xfc,
+    0x00, 0x00, 0x25, 0x02, 0x00, 0x00, 0x25, 0x09, 0x00, 0x00, 0x25, 0x0f,
+    0x00, 0x00, 0x25, 0x14, 0x00, 0x00, 0x25, 0x1d, 0x00, 0x00, 0x25, 0x26,
+    0x00, 0x00, 0x25, 0x2c, 0x00, 0x00, 0x25, 0x33, 0x00, 0x00, 0x25, 0x39,
+    0x00, 0x00, 0x25, 0x40, 0x00, 0x00, 0x25, 0x47, 0x00, 0x00, 0x25, 0x4c,
+    0x00, 0x00, 0x25, 0x52, 0x00, 0x00, 0x25, 0x59, 0x00, 0x00, 0x25, 0x5f,
+    0x00, 0x00, 0x25, 0x65, 0x00, 0x00, 0x25, 0x6b, 0x00, 0x00, 0x25, 0x72,
+    0x00, 0x00, 0x25, 0x79, 0x00, 0x00, 0x25, 0x7e, 0x00, 0x00, 0x25, 0x84,
+    0x00, 0x00, 0x25, 0x89, 0x00, 0x00, 0x25, 0x8f, 0x00, 0x00, 0x25, 0x97,
+    0x00, 0x00, 0x25, 0x9f, 0x00, 0x00, 0x25, 0xa7, 0x00, 0x00, 0x25, 0xae,
+    0x00, 0x00, 0x25, 0xb6, 0x00, 0x00, 0x25, 0xbe, 0x00, 0x00, 0x25, 0xc9,
+    0x00, 0x00, 0x25, 0xd0, 0x00, 0x00, 0x25, 0xd7, 0x00, 0x00, 0x25, 0xdd,
+    0x00, 0x00, 0x25, 0xe4, 0x00, 0x00, 0x25, 0xea, 0x00, 0x00, 0x25, 0xef,
+    0x00, 0x00, 0x25, 0xf2, 0x00, 0x00, 0x25, 0xf6, 0x00, 0x00, 0x25, 0xfb,
+    0x00, 0x00, 0x26, 0x01, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x26, 0x0f,
+    0x00, 0x00, 0x26, 0x14, 0x00, 0x00, 0x26, 0x1a, 0x00, 0x00, 0x26, 0x22,
+    0x00, 0x00, 0x26, 0x27, 0x00, 0x00, 0x26, 0x2e, 0x00, 0x00, 0x26, 0x34,
+    0x00, 0x00, 0x26, 0x3b, 0x00, 0x00, 0x26, 0x42, 0x00, 0x00, 0x26, 0x4a,
+    0x00, 0x00, 0x26, 0x4f, 0x00, 0x00, 0x26, 0x54, 0x00, 0x00, 0x26, 0x5a,
+    0x00, 0x00, 0x26, 0x62, 0x00, 0x00, 0x26, 0x69, 0x00, 0x00, 0x26, 0x71,
+    0x00, 0x00, 0x26, 0x77, 0x00, 0x00, 0x26, 0x7e, 0x00, 0x00, 0x26, 0x84,
+    0x00, 0x00, 0x26, 0x8b, 0x00, 0x00, 0x26, 0x91, 0x00, 0x00, 0x26, 0x98,
+    0x00, 0x00, 0x26, 0x9e, 0x00, 0x00, 0x26, 0xa4, 0x00, 0x00, 0x26, 0xab,
+    0x00, 0x00, 0x26, 0xb2, 0x00, 0x00, 0x26, 0xb6, 0x00, 0x00, 0x26, 0xbd,
+    0x00, 0x00, 0x26, 0xc4, 0x00, 0x00, 0x26, 0xcb, 0x00, 0x00, 0x26, 0xd1,
+    0x00, 0x00, 0x26, 0xd7, 0x00, 0x00, 0x26, 0xde, 0x00, 0x00, 0x26, 0xe5,
+    0x00, 0x00, 0x26, 0xea, 0x00, 0x00, 0x26, 0xf1, 0x00, 0x00, 0x26, 0xf6,
+    0x00, 0x00, 0x26, 0xfc, 0x00, 0x00, 0x27, 0x02, 0x00, 0x00, 0x27, 0x09,
+    0x00, 0x00, 0x27, 0x12, 0x00, 0x00, 0x27, 0x1a, 0x00, 0x00, 0x27, 0x23,
+    0x00, 0x00, 0x27, 0x2c, 0x00, 0x00, 0x27, 0x33, 0x00, 0x00, 0x27, 0x39,
+    0x00, 0x00, 0x27, 0x3f, 0x00, 0x00, 0x27, 0x45, 0x00, 0x00, 0x27, 0x4c,
+    0x00, 0x00, 0x27, 0x54, 0x00, 0x00, 0x27, 0x5c, 0x00, 0x00, 0x27, 0x64,
+    0x00, 0x00, 0x27, 0x6d, 0x00, 0x00, 0x27, 0x76, 0x00, 0x00, 0x27, 0x7e,
+    0x00, 0x00, 0x27, 0x87, 0x00, 0x00, 0x27, 0x90, 0x00, 0x00, 0x27, 0x94,
+    0x00, 0x00, 0x27, 0x99, 0x00, 0x00, 0x27, 0xa0, 0x00, 0x00, 0x27, 0xa6,
+    0x00, 0x00, 0x27, 0xad, 0x00, 0x00, 0x27, 0xb3, 0x00, 0x00, 0x27, 0xba,
+    0x00, 0x00, 0x27, 0xc1, 0x00, 0x00, 0x27, 0xc6, 0x00, 0x00, 0x27, 0xcc,
+    0x00, 0x00, 0x27, 0xd3, 0x00, 0x00, 0x27, 0xdb, 0x00, 0x00, 0x27, 0xe1,
+    0x00, 0x00, 0x27, 0xeb, 0x00, 0x00, 0x27, 0xf1, 0x00, 0x00, 0x27, 0xf8,
+    0x00, 0x00, 0x27, 0xff, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x28, 0x0b,
+    0x00, 0x00, 0x28, 0x11, 0x00, 0x00, 0x28, 0x1a, 0x00, 0x00, 0x28, 0x24,
+    0x00, 0x00, 0x28, 0x2d, 0x00, 0x00, 0x28, 0x37, 0x00, 0x00, 0x28, 0x3c,
+    0x00, 0x00, 0x28, 0x41, 0x00, 0x00, 0x28, 0x49, 0x00, 0x00, 0x28, 0x4f,
+    0x00, 0x00, 0x28, 0x55, 0x00, 0x00, 0x28, 0x5c, 0x00, 0x00, 0x28, 0x61,
+    0x00, 0x00, 0x28, 0x67, 0x00, 0x00, 0x28, 0x6e, 0x00, 0x00, 0x28, 0x76,
+    0x00, 0x00, 0x28, 0x7c, 0x00, 0x00, 0x28, 0x86, 0x00, 0x00, 0x28, 0x8b,
+    0x00, 0x00, 0x28, 0x91, 0x00, 0x00, 0x28, 0x96, 0x00, 0x00, 0x28, 0x9c,
+    0x00, 0x00, 0x28, 0xa3, 0x00, 0x00, 0x28, 0xa8, 0x00, 0x00, 0x28, 0xad,
+    0x00, 0x00, 0x28, 0xb4, 0x00, 0x00, 0x28, 0xbb, 0x00, 0x00, 0x28, 0xc1,
+    0x00, 0x00, 0x28, 0xc8, 0x00, 0x00, 0x28, 0xcf, 0x00, 0x00, 0x28, 0xd7,
+    0x00, 0x00, 0x28, 0xdc, 0x00, 0x00, 0x28, 0xe2, 0x00, 0x00, 0x28, 0xe7,
+    0x00, 0x00, 0x28, 0xec, 0x00, 0x00, 0x28, 0xf2, 0x00, 0x00, 0x28, 0xf7,
+    0x00, 0x00, 0x28, 0xfd, 0x00, 0x00, 0x29, 0x02, 0x00, 0x00, 0x29, 0x09,
+    0x00, 0x00, 0x29, 0x0f, 0x00, 0x00, 0x29, 0x15, 0x00, 0x00, 0x29, 0x1b,
+    0x00, 0x00, 0x29, 0x22, 0x00, 0x00, 0x29, 0x29, 0x00, 0x00, 0x29, 0x2f,
+    0x00, 0x00, 0x29, 0x37, 0x00, 0x00, 0x29, 0x3e, 0x00, 0x00, 0x29, 0x44,
+    0x00, 0x00, 0x29, 0x49, 0x00, 0x00, 0x29, 0x4d, 0x00, 0x00, 0x29, 0x55,
+    0x00, 0x00, 0x29, 0x5c, 0x00, 0x00, 0x29, 0x63, 0x00, 0x00, 0x29, 0x6b,
+    0x00, 0x00, 0x29, 0x73, 0x00, 0x00, 0x29, 0x79, 0x00, 0x00, 0x29, 0x81,
+    0x00, 0x00, 0x29, 0x89, 0x00, 0x00, 0x29, 0x91, 0x00, 0x00, 0x29, 0x97,
+    0x00, 0x00, 0x29, 0x9d, 0x00, 0x00, 0x29, 0xa2, 0x00, 0x00, 0x29, 0xa8,
+    0x00, 0x00, 0x29, 0xaf, 0x00, 0x00, 0x29, 0xb6, 0x00, 0x00, 0x29, 0xbd,
+    0x00, 0x00, 0x29, 0xc4, 0x00, 0x00, 0x29, 0xca, 0x00, 0x00, 0x29, 0xcf,
+    0x00, 0x00, 0x29, 0xd8, 0x00, 0x00, 0x29, 0xe1, 0x00, 0x00, 0x29, 0xe8,
+    0x00, 0x00, 0x29, 0xee, 0x00, 0x00, 0x29, 0xf5, 0x00, 0x00, 0x29, 0xfa,
+    0x00, 0x00, 0x2a, 0x02, 0x00, 0x00, 0x2a, 0x08, 0x00, 0x00, 0x2a, 0x0c,
+    0x00, 0x00, 0x2a, 0x11, 0x00, 0x00, 0x2a, 0x19, 0x00, 0x00, 0x2a, 0x20,
+    0x00, 0x00, 0x2a, 0x25, 0x00, 0x00, 0x2a, 0x2b, 0x00, 0x00, 0x2a, 0x31,
+    0x00, 0x00, 0x2a, 0x39, 0x00, 0x00, 0x2a, 0x43, 0x00, 0x00, 0x2a, 0x4c,
+    0x00, 0x00, 0x2a, 0x50, 0x00, 0x00, 0x2a, 0x57, 0x00, 0x00, 0x2a, 0x5c,
+    0x00, 0x00, 0x2a, 0x62, 0x00, 0x00, 0x2a, 0x68, 0x00, 0x00, 0x2a, 0x6e,
+    0x00, 0x00, 0x2a, 0x75, 0x00, 0x00, 0x2a, 0x7a, 0x00, 0x00, 0x2a, 0x80,
+    0x00, 0x00, 0x2a, 0x85, 0x00, 0x00, 0x2a, 0x8b, 0x00, 0x00, 0x2a, 0x92,
+    0x00, 0x00, 0x2a, 0x9a, 0x00, 0x00, 0x2a, 0xa1, 0x00, 0x00, 0x2a, 0xa6,
+    0x00, 0x00, 0x2a, 0xb0, 0x00, 0x00, 0x2a, 0xb8, 0x00, 0x00, 0x2a, 0xbd,
+    0x00, 0x00, 0x2a, 0xc4, 0x00, 0x00, 0x2a, 0xce, 0x00, 0x00, 0x2a, 0xd8,
+    0x00, 0x00, 0x2a, 0xe0, 0x00, 0x00, 0x2a, 0xe6, 0x00, 0x00, 0x2a, 0xec,
+    0x00, 0x00, 0x2a, 0xf2, 0x00, 0x00, 0x2a, 0xf8, 0x00, 0x00, 0x2a, 0xfd,
+    0x00, 0x00, 0x2b, 0x07, 0x00, 0x00, 0x2b, 0x11, 0x00, 0x00, 0x2b, 0x17,
+    0x00, 0x00, 0x2b, 0x1c, 0x00, 0x00, 0x2b, 0x24, 0x00, 0x00, 0x2b, 0x2d,
+    0x00, 0x00, 0x2b, 0x34, 0x00, 0x00, 0x2b, 0x3b, 0x00, 0x00, 0x2b, 0x43,
+    0x00, 0x00, 0x2b, 0x4b, 0x00, 0x00, 0x2b, 0x51, 0x00, 0x00, 0x2b, 0x58,
+    0x00, 0x00, 0x2b, 0x61, 0x00, 0x00, 0x2b, 0x66, 0x00, 0x00, 0x2b, 0x6c,
+    0x00, 0x00, 0x2b, 0x72, 0x00, 0x00, 0x2b, 0x7b, 0x00, 0x00, 0x2b, 0x83,
+    0x00, 0x00, 0x2b, 0x89, 0x00, 0x00, 0x2b, 0x90, 0x00, 0x00, 0x2b, 0x95,
+    0x00, 0x00, 0x2b, 0x9b, 0x00, 0x00, 0x2b, 0xa3, 0x00, 0x00, 0x2b, 0xaa,
+    0x00, 0x00, 0x2b, 0xb1, 0x00, 0x00, 0x2b, 0xb9, 0x00, 0x00, 0x2b, 0xc1,
+    0x00, 0x00, 0x2b, 0xc9, 0x00, 0x00, 0x2b, 0xce, 0x00, 0x00, 0x2b, 0xd4,
+    0x00, 0x00, 0x2b, 0xdc, 0x00, 0x00, 0x2b, 0xe0, 0x00, 0x00, 0x2b, 0xe5,
+    0x00, 0x00, 0x2b, 0xec, 0x00, 0x00, 0x2b, 0xf1, 0x00, 0x00, 0x2b, 0xf9,
+    0x00, 0x00, 0x2c, 0x01, 0x00, 0x00, 0x2c, 0x0a, 0x00, 0x00, 0x2c, 0x0e,
+    0x00, 0x00, 0x2c, 0x15, 0x00, 0x00, 0x2c, 0x1a, 0x00, 0x00, 0x2c, 0x25,
+    0x00, 0x00, 0x2c, 0x30, 0x00, 0x00, 0x2c, 0x34, 0x00, 0x00, 0x2c, 0x3b,
+    0x00, 0x00, 0x2c, 0x42, 0x00, 0x00, 0x2c, 0x4a, 0x00, 0x00, 0x2c, 0x52,
+    0x00, 0x00, 0x2c, 0x59, 0x00, 0x00, 0x2c, 0x61, 0x00, 0x00, 0x2c, 0x69,
+    0x00, 0x00, 0x2c, 0x71, 0x00, 0x00, 0x2c, 0x7a, 0x00, 0x00, 0x2c, 0x81,
+    0x00, 0x00, 0x2c, 0x86, 0x00, 0x00, 0x2c, 0x8b, 0x00, 0x00, 0x2c, 0x91,
+    0x00, 0x00, 0x2c, 0x96, 0x00, 0x00, 0x2c, 0x9d, 0x00, 0x00, 0x2c, 0xa1,
+    0x00, 0x00, 0x2c, 0xa6, 0x00, 0x00, 0x2c, 0xae, 0x00, 0x00, 0x2c, 0xb7,
+    0x00, 0x00, 0x2c, 0xbc, 0x00, 0x00, 0x2c, 0xc3, 0x00, 0x00, 0x2c, 0xcb,
+    0x00, 0x00, 0x2c, 0xcf, 0x00, 0x00, 0x2c, 0xd5, 0x00, 0x00, 0x2c, 0xdb,
+    0x00, 0x00, 0x2c, 0xe2, 0x00, 0x00, 0x2c, 0xe9, 0x00, 0x00, 0x2c, 0xef,
+    0x00, 0x00, 0x2c, 0xf5, 0x00, 0x00, 0x2c, 0xfc, 0x00, 0x00, 0x2d, 0x03,
+    0x00, 0x00, 0x2d, 0x0b, 0x00, 0x00, 0x2d, 0x14, 0x00, 0x00, 0x2d, 0x1d,
+    0x00, 0x00, 0x2d, 0x24, 0x00, 0x00, 0x2d, 0x2c, 0x00, 0x00, 0x2d, 0x31,
+    0x00, 0x00, 0x2d, 0x35, 0x00, 0x00, 0x2d, 0x3a, 0x00, 0x00, 0x2d, 0x3d,
+    0x00, 0x00, 0x2d, 0x46, 0x00, 0x00, 0x2d, 0x4e, 0x00, 0x00, 0x2d, 0x55,
+    0x00, 0x00, 0x2d, 0x5c, 0x00, 0x00, 0x2d, 0x64, 0x00, 0x00, 0x2d, 0x6e,
+    0x00, 0x00, 0x2d, 0x77, 0x00, 0x00, 0x2d, 0x81, 0x00, 0x00, 0x2d, 0x88,
+    0x00, 0x00, 0x2d, 0x8f, 0x00, 0x00, 0x2d, 0x96, 0x00, 0x00, 0x2d, 0x9e,
+    0x00, 0x00, 0x2d, 0xa4, 0x00, 0x00, 0x2d, 0xab, 0x00, 0x00, 0x2d, 0xb5,
+    0x00, 0x00, 0x2d, 0xbc, 0x00, 0x00, 0x2d, 0xc4, 0x00, 0x00, 0x2d, 0xc9,
+    0x00, 0x00, 0x2d, 0xd2, 0x00, 0x00, 0x2d, 0xdb, 0x00, 0x00, 0x2d, 0xe4,
+    0x00, 0x00, 0x2d, 0xea, 0x00, 0x00, 0x2d, 0xf0, 0x00, 0x00, 0x2d, 0xf7,
+    0x00, 0x00, 0x2d, 0xff, 0x00, 0x00, 0x2e, 0x09, 0x00, 0x00, 0x2e, 0x12,
+    0x00, 0x00, 0x2e, 0x18, 0x00, 0x00, 0x2e, 0x1f, 0x00, 0x00, 0x2e, 0x25,
+    0x00, 0x00, 0x2e, 0x2e, 0x00, 0x00, 0x2e, 0x32, 0x00, 0x00, 0x2e, 0x37,
+    0x00, 0x00, 0x2e, 0x3d, 0x00, 0x00, 0x2e, 0x46, 0x00, 0x00, 0x2e, 0x4f,
+    0x00, 0x00, 0x2e, 0x59, 0x00, 0x00, 0x2e, 0x63, 0x00, 0x00, 0x2e, 0x6b,
+    0x00, 0x00, 0x2e, 0x76, 0x00, 0x00, 0x2e, 0x81, 0x00, 0x00, 0x2e, 0x8a,
+    0x00, 0x00, 0x2e, 0x91, 0x00, 0x00, 0x2e, 0x99, 0x00, 0x00, 0x2e, 0xa2,
+    0x00, 0x00, 0x2e, 0xaa, 0x00, 0x00, 0x2e, 0xb2, 0x00, 0x00, 0x2e, 0xba,
+    0x00, 0x00, 0x2e, 0xbf, 0x00, 0x00, 0x2e, 0xc5, 0x00, 0x00, 0x2e, 0xcb,
+    0x00, 0x00, 0x2e, 0xd2, 0x00, 0x00, 0x2e, 0xda, 0x00, 0x00, 0x2e, 0xe1,
+    0x00, 0x00, 0x2e, 0xe6, 0x00, 0x00, 0x2e, 0xed, 0x00, 0x00, 0x2e, 0xf6,
+    0x00, 0x00, 0x2e, 0xfe, 0x00, 0x00, 0x2f, 0x08, 0x00, 0x00, 0x2f, 0x12,
+    0x00, 0x00, 0x2f, 0x1d, 0x00, 0x00, 0x2f, 0x25, 0x00, 0x00, 0x2f, 0x2e,
+    0x00, 0x00, 0x2f, 0x37, 0x00, 0x00, 0x2f, 0x3f, 0x00, 0x00, 0x2f, 0x49,
+    0x00, 0x00, 0x2f, 0x53, 0x00, 0x00, 0x2f, 0x5d, 0x00, 0x00, 0x2f, 0x63,
+    0x00, 0x00, 0x2f, 0x6b, 0x00, 0x00, 0x2f, 0x74, 0x00, 0x00, 0x2f, 0x7d,
+    0x00, 0x00, 0x2f, 0x87, 0x00, 0x00, 0x2f, 0x8c, 0x00, 0x00, 0x2f, 0x92,
+    0x00, 0x00, 0x2f, 0x99, 0x00, 0x00, 0x2f, 0xa1, 0x00, 0x00, 0x2f, 0xa8,
+    0x00, 0x00, 0x2f, 0xb1, 0x00, 0x00, 0x2f, 0xbb, 0x00, 0x00, 0x2f, 0xc5,
+    0x00, 0x00, 0x2f, 0xd0, 0x00, 0x00, 0x2f, 0xd7, 0x00, 0x00, 0x2f, 0xdf,
+    0x00, 0x00, 0x2f, 0xe8, 0x00, 0x00, 0x2f, 0xf2, 0x00, 0x00, 0x2f, 0xf9,
+    0x00, 0x00, 0x30, 0x01, 0x00, 0x00, 0x30, 0x08, 0x00, 0x00, 0x30, 0x0e,
+    0x00, 0x00, 0x30, 0x15, 0x00, 0x00, 0x30, 0x1b, 0x00, 0x00, 0x30, 0x22,
+    0x00, 0x00, 0x30, 0x2a, 0x00, 0x00, 0x30, 0x33, 0x00, 0x00, 0x30, 0x3c,
+    0x00, 0x00, 0x30, 0x46, 0x00, 0x00, 0x30, 0x50, 0x00, 0x00, 0x30, 0x55,
+    0x00, 0x00, 0x30, 0x5a, 0x00, 0x00, 0x30, 0x5f, 0x00, 0x00, 0x30, 0x65,
+    0x00, 0x00, 0x30, 0x6c, 0x00, 0x00, 0x30, 0x75, 0x00, 0x00, 0x30, 0x7d,
+    0x00, 0x00, 0x30, 0x84, 0x00, 0x00, 0x30, 0x8c, 0x00, 0x00, 0x30, 0x93,
+    0x00, 0x00, 0x30, 0x9b, 0x00, 0x00, 0x30, 0xa1, 0x00, 0x00, 0x30, 0xa7,
+    0x00, 0x00, 0x30, 0xac, 0x00, 0x00, 0x30, 0xb3, 0x00, 0x00, 0x30, 0xb9,
+    0x00, 0x00, 0x30, 0xbd, 0x00, 0x00, 0x30, 0xc2, 0x00, 0x00, 0x30, 0xc8,
+    0x00, 0x00, 0x30, 0xce, 0x00, 0x00, 0x30, 0xd6, 0x00, 0x00, 0x30, 0xde,
+    0x00, 0x00, 0x30, 0xe6, 0x00, 0x00, 0x30, 0xef, 0x00, 0x00, 0x30, 0xf9,
+    0x00, 0x00, 0x30, 0xfe, 0x00, 0x00, 0x31, 0x04, 0x00, 0x00, 0x31, 0x09,
+    0x00, 0x00, 0x31, 0x10, 0x00, 0x00, 0x31, 0x15, 0x00, 0x00, 0x31, 0x1d,
+    0x00, 0x00, 0x31, 0x24, 0x00, 0x00, 0x31, 0x2c, 0x00, 0x00, 0x31, 0x36,
+    0x00, 0x00, 0x31, 0x3f, 0x00, 0x00, 0x31, 0x45, 0x00, 0x00, 0x31, 0x4b,
+    0x00, 0x00, 0x31, 0x51, 0x00, 0x00, 0x31, 0x58, 0x00, 0x00, 0x31, 0x5e,
+    0x00, 0x00, 0x31, 0x67, 0x00, 0x00, 0x31, 0x70, 0x00, 0x00, 0x31, 0x79,
+    0x00, 0x00, 0x31, 0x80, 0x00, 0x00, 0x31, 0x8a, 0x00, 0x00, 0x31, 0x95,
+    0x00, 0x00, 0x31, 0x9e, 0x00, 0x00, 0x31, 0xa8, 0x00, 0x00, 0x31, 0xb2,
+    0x00, 0x00, 0x31, 0xba, 0x00, 0x00, 0x31, 0xc4, 0x00, 0x00, 0x31, 0xce,
+    0x00, 0x00, 0x31, 0xd9, 0x00, 0x00, 0x31, 0xe4, 0x00, 0x00, 0x31, 0xec,
+    0x00, 0x00, 0x31, 0xf5, 0x00, 0x00, 0x31, 0xfe, 0x00, 0x00, 0x32, 0x05,
+    0x00, 0x00, 0x32, 0x0f, 0x00, 0x00, 0x32, 0x17, 0x00, 0x00, 0x32, 0x1f,
+    0x00, 0x00, 0x32, 0x26, 0x00, 0x00, 0x32, 0x2e, 0x00, 0x00, 0x32, 0x34,
+    0x00, 0x00, 0x32, 0x39, 0x00, 0x00, 0x32, 0x42, 0x00, 0x00, 0x32, 0x49,
+    0x00, 0x00, 0x32, 0x4f, 0x00, 0x00, 0x32, 0x55, 0x00, 0x00, 0x32, 0x5c,
+    0x00, 0x00, 0x32, 0x63, 0x00, 0x00, 0x32, 0x6b, 0x00, 0x00, 0x32, 0x74,
+    0x00, 0x00, 0x32, 0x7e, 0x00, 0x00, 0x32, 0x86, 0x00, 0x00, 0x32, 0x90,
+    0x00, 0x00, 0x32, 0x94, 0x00, 0x00, 0x32, 0x9b, 0x00, 0x00, 0x32, 0xa2,
+    0x00, 0x00, 0x32, 0xa7, 0x00, 0x00, 0x32, 0xab, 0x00, 0x00, 0x32, 0xb3,
+    0x00, 0x00, 0x32, 0xbc, 0x00, 0x00, 0x32, 0xc5, 0x00, 0x00, 0x32, 0xcb,
+    0x00, 0x00, 0x32, 0xd3, 0x00, 0x00, 0x32, 0xd9, 0x00, 0x00, 0x32, 0xde,
+    0x00, 0x00, 0x32, 0xe6, 0x00, 0x00, 0x32, 0xed, 0x00, 0x00, 0x32, 0xf3,
+    0x00, 0x00, 0x32, 0xf8, 0x00, 0x00, 0x33, 0x01, 0x00, 0x00, 0x33, 0x0a,
+    0x00, 0x00, 0x33, 0x11, 0x00, 0x00, 0x33, 0x18, 0x00, 0x00, 0x33, 0x20,
+    0x00, 0x00, 0x33, 0x25, 0x00, 0x00, 0x33, 0x2e, 0x00, 0x00, 0x33, 0x39,
+    0x00, 0x00, 0x33, 0x40, 0x00, 0x00, 0x33, 0x46, 0x00, 0x00, 0x33, 0x4d,
+    0x00, 0x00, 0x33, 0x54, 0x00, 0x00, 0x33, 0x59, 0x00, 0x00, 0x33, 0x60,
+    0x00, 0x00, 0x33, 0x69, 0x00, 0x00, 0x33, 0x6f, 0x00, 0x00, 0x33, 0x76,
+    0x00, 0x00, 0x33, 0x7e, 0x00, 0x00, 0x33, 0x86, 0x00, 0x00, 0x33, 0x8d,
+    0x00, 0x00, 0x33, 0x94, 0x00, 0x00, 0x33, 0x9a, 0x00, 0x00, 0x33, 0xa1,
+    0x00, 0x00, 0x33, 0xa8, 0x00, 0x00, 0x33, 0xae, 0x00, 0x00, 0x33, 0xb5,
+    0x00, 0x00, 0x33, 0xbc, 0x00, 0x00, 0x33, 0xc4, 0x00, 0x00, 0x33, 0xcb,
+    0x00, 0x00, 0x33, 0xd1, 0x00, 0x00, 0x33, 0xd8, 0x00, 0x00, 0x33, 0xdf,
+    0x00, 0x00, 0x33, 0xe8, 0x00, 0x00, 0x33, 0xee, 0x00, 0x00, 0x33, 0xf5,
+    0x00, 0x00, 0x33, 0xfb, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x34, 0x0b,
+    0x00, 0x00, 0x34, 0x12, 0x00, 0x00, 0x34, 0x1a, 0x00, 0x00, 0x34, 0x1f,
+    0x00, 0x00, 0x34, 0x25, 0x00, 0x00, 0x34, 0x2e, 0x00, 0x00, 0x34, 0x37,
+    0x00, 0x00, 0x34, 0x3f, 0x00, 0x00, 0x34, 0x45, 0x00, 0x00, 0x34, 0x4e,
+    0x00, 0x00, 0x34, 0x55, 0x00, 0x00, 0x34, 0x5e, 0x00, 0x00, 0x34, 0x65,
+    0x00, 0x00, 0x34, 0x6e, 0x00, 0x00, 0x34, 0x75, 0x00, 0x00, 0x34, 0x7f,
+    0x00, 0x00, 0x34, 0x86, 0x00, 0x00, 0x34, 0x92, 0x00, 0x00, 0x34, 0x9c,
+    0x00, 0x00, 0x34, 0xa0, 0x00, 0x00, 0x34, 0xa7, 0x00, 0x00, 0x34, 0xaf,
+    0x00, 0x00, 0x34, 0xb3, 0x00, 0x00, 0x34, 0xb8, 0x00, 0x00, 0x34, 0xbf,
+    0x00, 0x00, 0x34, 0xc9, 0x00, 0x00, 0x34, 0xcf, 0x00, 0x00, 0x34, 0xd4,
+    0x00, 0x00, 0x34, 0xdc, 0x00, 0x00, 0x34, 0xdf, 0x00, 0x00, 0x34, 0xe3,
+    0x00, 0x00, 0x34, 0xe7, 0x00, 0x00, 0x34, 0xee, 0x00, 0x00, 0x34, 0xf2,
+    0x00, 0x00, 0x34, 0xf8, 0x00, 0x00, 0x34, 0xff, 0x00, 0x00, 0x35, 0x06,
+    0x00, 0x00, 0x35, 0x0d, 0x00, 0x00, 0x35, 0x11, 0x00, 0x00, 0x35, 0x16,
+    0x00, 0x00, 0x35, 0x1b, 0x00, 0x00, 0x35, 0x20, 0x00, 0x00, 0x35, 0x25,
+    0x00, 0x00, 0x35, 0x2b, 0x00, 0x00, 0x35, 0x32, 0x00, 0x00, 0x35, 0x3c,
+    0x00, 0x00, 0x35, 0x41, 0x00, 0x00, 0x35, 0x48, 0x00, 0x00, 0x35, 0x50,
+    0x00, 0x00, 0x35, 0x57, 0x00, 0x00, 0x35, 0x5f, 0x00, 0x00, 0x35, 0x66,
+    0x00, 0x00, 0x35, 0x6e, 0x00, 0x00, 0x35, 0x77, 0x00, 0x00, 0x35, 0x81,
+    0x00, 0x00, 0x35, 0x88, 0x00, 0x00, 0x35, 0x91, 0x00, 0x00, 0x35, 0x97,
+    0x00, 0x00, 0x35, 0x9e, 0x00, 0x00, 0x35, 0xa5, 0x00, 0x00, 0x35, 0xac,
+    0x00, 0x00, 0x35, 0xb3, 0x00, 0x00, 0x35, 0xba, 0x00, 0x00, 0x35, 0xc1,
+    0x00, 0x00, 0x35, 0xc8, 0x00, 0x00, 0x35, 0xd0, 0x00, 0x00, 0x35, 0xd6,
+    0x00, 0x00, 0x35, 0xdc, 0x00, 0x00, 0x35, 0xe4, 0x00, 0x00, 0x35, 0xeb,
+    0x00, 0x00, 0x35, 0xf2, 0x00, 0x00, 0x35, 0xf7, 0x00, 0x00, 0x35, 0xfb,
+    0x00, 0x00, 0x36, 0x01, 0x00, 0x00, 0x36, 0x07, 0x00, 0x00, 0x36, 0x0d,
+    0x00, 0x00, 0x36, 0x13, 0x00, 0x00, 0x36, 0x1b, 0x00, 0x00, 0x36, 0x21,
+    0x00, 0x00, 0x36, 0x28, 0x00, 0x00, 0x36, 0x2f, 0x00, 0x00, 0x36, 0x35,
+    0x00, 0x00, 0x36, 0x3c, 0x00, 0x00, 0x36, 0x46, 0x00, 0x00, 0x36, 0x50,
+    0x00, 0x00, 0x36, 0x56, 0x00, 0x00, 0x36, 0x5b, 0x00, 0x00, 0x36, 0x63,
+    0x00, 0x00, 0x36, 0x6d, 0x00, 0x00, 0x36, 0x76, 0x00, 0x00, 0x36, 0x7c,
+    0x00, 0x00, 0x36, 0x83, 0x00, 0x00, 0x36, 0x8e, 0x00, 0x00, 0x36, 0x96,
+    0x00, 0x00, 0x36, 0x9e, 0x00, 0x00, 0x36, 0xa6, 0x00, 0x00, 0x36, 0xaf,
+    0x00, 0x00, 0x36, 0xb8, 0x00, 0x00, 0x36, 0xc0, 0x00, 0x00, 0x36, 0xc6,
+    0x00, 0x00, 0x36, 0xcd, 0x00, 0x00, 0x36, 0xd4, 0x00, 0x00, 0x36, 0xdb,
+    0x00, 0x00, 0x36, 0xe1, 0x00, 0x00, 0x36, 0xe6, 0x00, 0x00, 0x36, 0xee,
+    0x00, 0x00, 0x36, 0xf6, 0x00, 0x00, 0x36, 0xfd, 0x00, 0x00, 0x37, 0x03,
+    0x00, 0x00, 0x37, 0x09, 0x00, 0x00, 0x37, 0x13, 0x00, 0x00, 0x37, 0x1e,
+    0x00, 0x00, 0x37, 0x26, 0x00, 0x00, 0x37, 0x2e, 0x00, 0x00, 0x37, 0x34,
+    0x00, 0x00, 0x37, 0x3b, 0x00, 0x00, 0x37, 0x44, 0x00, 0x00, 0x37, 0x4a,
+    0x00, 0x00, 0x37, 0x51, 0x00, 0x00, 0x37, 0x58, 0x00, 0x00, 0x37, 0x5c,
+    0x00, 0x00, 0x37, 0x63, 0x00, 0x00, 0x37, 0x6a, 0x00, 0x00, 0x37, 0x70,
+    0x00, 0x00, 0x37, 0x77, 0x00, 0x00, 0x37, 0x7e, 0x00, 0x00, 0x37, 0x84,
+    0x00, 0x00, 0x37, 0x8a, 0x00, 0x00, 0x37, 0x90, 0x00, 0x00, 0x37, 0x95,
+    0x00, 0x00, 0x37, 0x9a, 0x00, 0x00, 0x37, 0xa1, 0x00, 0x00, 0x37, 0xa9,
+    0x00, 0x00, 0x37, 0xb3, 0x00, 0x00, 0x37, 0xbc, 0x00, 0x00, 0x37, 0xc6,
+    0x00, 0x00, 0x37, 0xcc, 0x00, 0x00, 0x37, 0xd4, 0x00, 0x00, 0x37, 0xdb,
+    0x00, 0x00, 0x37, 0xe0, 0x00, 0x00, 0x37, 0xe5, 0x00, 0x00, 0x37, 0xec,
+    0x00, 0x00, 0x37, 0xf0, 0x00, 0x00, 0x37, 0xf5, 0x00, 0x00, 0x37, 0xfa,
+    0x00, 0x00, 0x37, 0xff, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, 0x38, 0x09,
+    0x00, 0x00, 0x38, 0x12, 0x00, 0x00, 0x38, 0x17, 0x00, 0x00, 0x38, 0x1e,
+    0x00, 0x00, 0x38, 0x24, 0x00, 0x00, 0x38, 0x28, 0x00, 0x00, 0x38, 0x31,
+    0x00, 0x00, 0x38, 0x35, 0x00, 0x00, 0x38, 0x3b, 0x00, 0x00, 0x38, 0x3f,
+    0x00, 0x00, 0x38, 0x44, 0x00, 0x00, 0x38, 0x49, 0x00, 0x00, 0x38, 0x4d,
+    0x00, 0x00, 0x38, 0x51, 0x00, 0x00, 0x38, 0x58, 0x00, 0x00, 0x38, 0x5e,
+    0x00, 0x00, 0x38, 0x65, 0x00, 0x00, 0x38, 0x6b, 0x00, 0x00, 0x38, 0x73,
+    0x00, 0x00, 0x38, 0x7b, 0x00, 0x00, 0x38, 0x7f, 0x00, 0x00, 0x38, 0x83,
+    0x00, 0x00, 0x38, 0x89, 0x00, 0x00, 0x38, 0x8e, 0x00, 0x00, 0x38, 0x95,
+    0x00, 0x00, 0x38, 0x9b, 0x00, 0x00, 0x38, 0xa1, 0x00, 0x00, 0x38, 0xa8,
+    0x00, 0x00, 0x38, 0xad, 0x00, 0x00, 0x38, 0xb3, 0x00, 0x00, 0x38, 0xb8,
+    0x00, 0x00, 0x38, 0xc2, 0x00, 0x00, 0x38, 0xc6, 0x00, 0x00, 0x38, 0xcd,
+    0x00, 0x00, 0x38, 0xd5, 0x00, 0x00, 0x38, 0xd8, 0x00, 0x00, 0x38, 0xdc,
+    0x00, 0x00, 0x38, 0xe2, 0x00, 0x00, 0x38, 0xe9, 0x00, 0x00, 0x38, 0xef,
+    0x00, 0x00, 0x38, 0xf4, 0x00, 0x00, 0x38, 0xf9, 0x00, 0x00, 0x38, 0xfe,
+    0x00, 0x00, 0x39, 0x03, 0x00, 0x00, 0x39, 0x0c, 0x00, 0x00, 0x39, 0x12,
+    0x00, 0x00, 0x39, 0x19, 0x00, 0x00, 0x39, 0x23, 0x00, 0x00, 0x39, 0x28,
+    0x00, 0x00, 0x39, 0x2d, 0x00, 0x00, 0x39, 0x32, 0x00, 0x00, 0x39, 0x36,
+    0x00, 0x00, 0x39, 0x3d, 0x00, 0x00, 0x39, 0x43, 0x00, 0x00, 0x39, 0x49,
+    0x00, 0x00, 0x39, 0x4f, 0x00, 0x00, 0x39, 0x54, 0x00, 0x00, 0x39, 0x5a,
+    0x00, 0x00, 0x39, 0x5f, 0x00, 0x00, 0x39, 0x67, 0x00, 0x00, 0x39, 0x6d,
+    0x00, 0x00, 0x39, 0x74, 0x00, 0x00, 0x39, 0x7a, 0x00, 0x00, 0x39, 0x7e,
+    0x00, 0x00, 0x39, 0x84, 0x00, 0x00, 0x39, 0x8b, 0x00, 0x00, 0x39, 0x93,
+    0x00, 0x00, 0x39, 0x9c, 0x00, 0x00, 0x39, 0xa5, 0x00, 0x00, 0x39, 0xad,
+    0x00, 0x00, 0x39, 0xb4, 0x00, 0x00, 0x39, 0xbb, 0x00, 0x00, 0x39, 0xc2,
+    0x00, 0x00, 0x39, 0xc8, 0x00, 0x00, 0x39, 0xce, 0x00, 0x00, 0x39, 0xd5,
+    0x00, 0x00, 0x39, 0xdc, 0x00, 0x00, 0x39, 0xe1, 0x00, 0x00, 0x39, 0xe8,
+    0x00, 0x00, 0x39, 0xef, 0x00, 0x00, 0x39, 0xf6, 0x00, 0x00, 0x39, 0xfd,
+    0x00, 0x00, 0x3a, 0x03, 0x00, 0x00, 0x3a, 0x07, 0x00, 0x00, 0x3a, 0x0c,
+    0x00, 0x00, 0x3a, 0x12, 0x00, 0x00, 0x3a, 0x1b, 0x00, 0x00, 0x3a, 0x22,
+    0x00, 0x00, 0x3a, 0x27, 0x00, 0x00, 0x3a, 0x2e, 0x00, 0x00, 0x3a, 0x34,
+    0x00, 0x00, 0x3a, 0x38, 0x00, 0x00, 0x3a, 0x3f, 0x00, 0x00, 0x3a, 0x45,
+    0x00, 0x00, 0x3a, 0x48, 0x00, 0x00, 0x3a, 0x50, 0x00, 0x00, 0x3a, 0x58,
+    0x00, 0x00, 0x3a, 0x60, 0x00, 0x00, 0x3a, 0x68, 0x00, 0x00, 0x3a, 0x70,
+    0x00, 0x00, 0x3a, 0x75, 0x00, 0x00, 0x3a, 0x7f, 0x00, 0x00, 0x3a, 0x88,
+    0x00, 0x00, 0x3a, 0x8e, 0x00, 0x00, 0x3a, 0x95, 0x00, 0x00, 0x3a, 0x9d,
+    0x00, 0x00, 0x3a, 0xa9, 0x00, 0x00, 0x3a, 0xb1, 0x00, 0x00, 0x3a, 0xb8,
+    0x00, 0x00, 0x3a, 0xbe, 0x00, 0x00, 0x3a, 0xc9, 0x00, 0x00, 0x3a, 0xd0,
+    0x00, 0x00, 0x3a, 0xda, 0x00, 0x00, 0x3a, 0xe5, 0x00, 0x00, 0x3a, 0xef,
+    0x00, 0x00, 0x3a, 0xfa, 0x00, 0x00, 0x3b, 0x05, 0x00, 0x00, 0x3b, 0x0d,
+    0x00, 0x00, 0x3b, 0x17, 0x00, 0x00, 0x3b, 0x1e, 0x00, 0x00, 0x3b, 0x26,
+    0x00, 0x00, 0x3b, 0x31, 0x00, 0x00, 0x3b, 0x3b, 0x00, 0x00, 0x3b, 0x44,
+    0x00, 0x00, 0x3b, 0x49, 0x00, 0x00, 0x3b, 0x4e, 0x00, 0x00, 0x3b, 0x56,
+    0x00, 0x00, 0x3b, 0x5a, 0x00, 0x00, 0x3b, 0x60, 0x00, 0x00, 0x3b, 0x67,
+    0x00, 0x00, 0x3b, 0x6e, 0x00, 0x00, 0x3b, 0x73, 0x00, 0x00, 0x3b, 0x7b,
+    0x00, 0x00, 0x3b, 0x82, 0x00, 0x00, 0x3b, 0x87, 0x00, 0x00, 0x3b, 0x8e,
+    0x00, 0x00, 0x3b, 0x94, 0x00, 0x00, 0x3b, 0x9a, 0x00, 0x00, 0x3b, 0x9f,
+    0x00, 0x00, 0x3b, 0xa5, 0x00, 0x00, 0x3b, 0xab, 0x00, 0x00, 0x3b, 0xb1,
+    0x00, 0x00, 0x3b, 0xb7, 0x00, 0x00, 0x3b, 0xbc, 0x00, 0x00, 0x3b, 0xc2,
+    0x00, 0x00, 0x3b, 0xc9, 0x00, 0x00, 0x3b, 0xd0, 0x00, 0x00, 0x3b, 0xd8,
+    0x00, 0x00, 0x3b, 0xdf, 0x00, 0x00, 0x3b, 0xe3, 0x00, 0x00, 0x3b, 0xe8,
+    0x00, 0x00, 0x3b, 0xee, 0x00, 0x00, 0x3b, 0xf4, 0x00, 0x00, 0x3b, 0xf9,
+    0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x06, 0x00, 0x00, 0x3c, 0x0d,
+    0x00, 0x00, 0x3c, 0x13, 0x00, 0x00, 0x3c, 0x1a, 0x00, 0x00, 0x3c, 0x22,
+    0x00, 0x00, 0x3c, 0x2a, 0x00, 0x00, 0x3c, 0x31, 0x00, 0x00, 0x3c, 0x39,
+    0x00, 0x00, 0x3c, 0x3f, 0x00, 0x00, 0x3c, 0x46, 0x00, 0x00, 0x3c, 0x4d,
+    0x00, 0x00, 0x3c, 0x55, 0x00, 0x00, 0x3c, 0x5d, 0x00, 0x00, 0x3c, 0x63,
+    0x00, 0x00, 0x3c, 0x68, 0x00, 0x00, 0x3c, 0x6f, 0x00, 0x00, 0x3c, 0x75,
+    0x00, 0x00, 0x3c, 0x7d, 0x00, 0x00, 0x3c, 0x84, 0x00, 0x00, 0x3c, 0x8b,
+    0x00, 0x00, 0x3c, 0x91, 0x00, 0x00, 0x3c, 0x98, 0x00, 0x00, 0x3c, 0x9f,
+    0x00, 0x00, 0x3c, 0xa4, 0x00, 0x00, 0x3c, 0xaa, 0x00, 0x00, 0x3c, 0xb1,
+    0x00, 0x00, 0x3c, 0xba, 0x00, 0x00, 0x3c, 0xc1, 0x00, 0x00, 0x3c, 0xc9,
+    0x00, 0x00, 0x3c, 0xd0, 0x00, 0x00, 0x3c, 0xda, 0x00, 0x00, 0x3c, 0xe3,
+    0x00, 0x00, 0x3c, 0xe9, 0x00, 0x00, 0x3c, 0xef, 0x00, 0x00, 0x3c, 0xf6,
+    0x00, 0x00, 0x3c, 0xfe, 0x00, 0x00, 0x3d, 0x05, 0x00, 0x00, 0x3d, 0x0c,
+    0x00, 0x00, 0x3d, 0x13, 0x00, 0x00, 0x3d, 0x1b, 0x00, 0x00, 0x3d, 0x21,
+    0x00, 0x00, 0x3d, 0x28, 0x00, 0x00, 0x3d, 0x30, 0x00, 0x00, 0x3d, 0x37,
+    0x00, 0x00, 0x3d, 0x3b, 0x00, 0x00, 0x3d, 0x40, 0x00, 0x00, 0x3d, 0x46,
+    0x00, 0x00, 0x3d, 0x4d, 0x00, 0x00, 0x3d, 0x53, 0x00, 0x00, 0x3d, 0x59,
+    0x00, 0x00, 0x3d, 0x60, 0x00, 0x00, 0x3d, 0x67, 0x00, 0x00, 0x3d, 0x6f,
+    0x00, 0x00, 0x3d, 0x72, 0x00, 0x00, 0x3d, 0x77, 0x00, 0x00, 0x3d, 0x7d,
+    0x00, 0x00, 0x3d, 0x83, 0x00, 0x00, 0x3d, 0x8c, 0x00, 0x00, 0x3d, 0x94,
+    0x00, 0x00, 0x3d, 0x9c, 0x00, 0x00, 0x3d, 0xa5, 0x00, 0x00, 0x3d, 0xae,
+    0x00, 0x00, 0x3d, 0xb6, 0x00, 0x00, 0x3d, 0xbd, 0x00, 0x00, 0x3d, 0xc5,
+    0x00, 0x00, 0x3d, 0xcf, 0x00, 0x00, 0x3d, 0xd6, 0x00, 0x00, 0x3d, 0xdd,
+    0x00, 0x00, 0x3d, 0xe7, 0x00, 0x00, 0x3d, 0xf1, 0x00, 0x00, 0x3d, 0xf9,
+    0x00, 0x00, 0x3e, 0x02, 0x00, 0x00, 0x3e, 0x06, 0x00, 0x00, 0x3e, 0x0b,
+    0x00, 0x00, 0x3e, 0x14, 0x00, 0x00, 0x3e, 0x1e, 0x00, 0x00, 0x3e, 0x26,
+    0x00, 0x00, 0x3e, 0x2d, 0x00, 0x00, 0x3e, 0x35, 0x00, 0x00, 0x3e, 0x3c,
+    0x00, 0x00, 0x3e, 0x40, 0x00, 0x00, 0x3e, 0x45, 0x00, 0x00, 0x3e, 0x4b,
+    0x00, 0x00, 0x3e, 0x50, 0x00, 0x00, 0x3e, 0x56, 0x00, 0x00, 0x3e, 0x5d,
+    0x00, 0x00, 0x3e, 0x65, 0x00, 0x00, 0x3e, 0x6d, 0x00, 0x00, 0x3e, 0x74,
+    0x00, 0x00, 0x3e, 0x79, 0x00, 0x00, 0x3e, 0x80, 0x00, 0x00, 0x3e, 0x88,
+    0x00, 0x00, 0x3e, 0x91, 0x00, 0x00, 0x3e, 0x98, 0x00, 0x00, 0x3e, 0x9f,
+    0x00, 0x00, 0x3e, 0xa5, 0x00, 0x00, 0x3e, 0xae, 0x00, 0x00, 0x3e, 0xb6,
+    0x00, 0x00, 0x3e, 0xbf, 0x00, 0x00, 0x3e, 0xc5, 0x00, 0x00, 0x3e, 0xcc,
+    0x00, 0x00, 0x3e, 0xd5, 0x00, 0x00, 0x3e, 0xdf, 0x00, 0x00, 0x3e, 0xe7,
+    0x00, 0x00, 0x3e, 0xed, 0x00, 0x00, 0x3e, 0xf4, 0x00, 0x00, 0x3e, 0xfe,
+    0x00, 0x00, 0x3f, 0x05, 0x00, 0x00, 0x3f, 0x0a, 0x00, 0x00, 0x3f, 0x13,
+    0x00, 0x00, 0x3f, 0x1a, 0x00, 0x00, 0x3f, 0x1f, 0x00, 0x00, 0x3f, 0x26,
+    0x00, 0x00, 0x3f, 0x2e, 0x00, 0x00, 0x3f, 0x36, 0x00, 0x00, 0x3f, 0x3f,
+    0x00, 0x00, 0x3f, 0x46, 0x00, 0x00, 0x3f, 0x4d, 0x00, 0x00, 0x3f, 0x54,
+    0x00, 0x00, 0x3f, 0x5c, 0x00, 0x00, 0x3f, 0x62, 0x00, 0x00, 0x3f, 0x6a,
+    0x00, 0x00, 0x3f, 0x71, 0x00, 0x00, 0x3f, 0x78, 0x00, 0x00, 0x3f, 0x80,
+    0x00, 0x00, 0x3f, 0x86, 0x00, 0x00, 0x3f, 0x8e, 0x00, 0x00, 0x3f, 0x95,
+    0x00, 0x00, 0x3f, 0x9a, 0x00, 0x00, 0x3f, 0xa0, 0x00, 0x00, 0x3f, 0xa9,
+    0x00, 0x00, 0x3f, 0xaf, 0x00, 0x00, 0x3f, 0xb6, 0x00, 0x00, 0x3f, 0xbe,
+    0x00, 0x00, 0x3f, 0xc5, 0x00, 0x00, 0x3f, 0xcd, 0x00, 0x00, 0x3f, 0xd5,
+    0x00, 0x00, 0x3f, 0xdb, 0x00, 0x00, 0x3f, 0xe2, 0x00, 0x00, 0x3f, 0xeb,
+    0x00, 0x00, 0x3f, 0xf1, 0x00, 0x00, 0x3f, 0xf8, 0x00, 0x00, 0x3f, 0xfe,
+    0x00, 0x00, 0x40, 0x05, 0x00, 0x00, 0x40, 0x08, 0x00, 0x00, 0x40, 0x0d,
+    0x00, 0x00, 0x40, 0x15, 0x00, 0x00, 0x40, 0x19, 0x00, 0x00, 0x40, 0x20,
+    0x00, 0x00, 0x40, 0x26, 0x00, 0x00, 0x40, 0x2a, 0x00, 0x00, 0x40, 0x2f,
+    0x00, 0x00, 0x40, 0x35, 0x00, 0x00, 0x40, 0x38, 0x00, 0x00, 0x40, 0x3d,
+    0x00, 0x00, 0x40, 0x43, 0x00, 0x00, 0x40, 0x49, 0x00, 0x00, 0x40, 0x50,
+    0x00, 0x00, 0x40, 0x56, 0x00, 0x00, 0x40, 0x5d, 0x00, 0x00, 0x40, 0x64,
+    0x00, 0x00, 0x40, 0x6c, 0x00, 0x00, 0x40, 0x74, 0x00, 0x00, 0x40, 0x7d,
+    0x00, 0x00, 0x40, 0x85, 0x00, 0x00, 0x40, 0x8b, 0x00, 0x00, 0x40, 0x90,
+    0x00, 0x00, 0x40, 0x96, 0x00, 0x00, 0x40, 0x9b, 0x00, 0x00, 0x40, 0x9f,
+    0x00, 0x00, 0x40, 0xa6, 0x00, 0x00, 0x40, 0xab, 0x00, 0x00, 0x40, 0xb2,
+    0x00, 0x00, 0x40, 0xb9, 0x00, 0x00, 0x40, 0xc1, 0x00, 0x00, 0x40, 0xc8,
+    0x00, 0x00, 0x40, 0xcf, 0x00, 0x00, 0x40, 0xd6, 0x00, 0x00, 0x40, 0xdb,
+    0x00, 0x00, 0x40, 0xe2, 0x00, 0x00, 0x40, 0xea, 0x00, 0x00, 0x40, 0xf2,
+    0x00, 0x00, 0x40, 0xf7, 0x00, 0x00, 0x40, 0xfd, 0x00, 0x00, 0x41, 0x07,
+    0x00, 0x00, 0x41, 0x11, 0x00, 0x00, 0x41, 0x1a, 0x00, 0x00, 0x41, 0x23,
+    0x00, 0x00, 0x41, 0x2a, 0x00, 0x00, 0x41, 0x31, 0x00, 0x00, 0x41, 0x39,
+    0x00, 0x00, 0x41, 0x40, 0x00, 0x00, 0x41, 0x48, 0x00, 0x00, 0x41, 0x50,
+    0x00, 0x00, 0x41, 0x54, 0x00, 0x00, 0x41, 0x59, 0x00, 0x00, 0x41, 0x61,
+    0x00, 0x00, 0x41, 0x68, 0x00, 0x00, 0x41, 0x6f, 0x00, 0x00, 0x41, 0x75,
+    0x00, 0x00, 0x41, 0x7c, 0x00, 0x00, 0x41, 0x82, 0x00, 0x00, 0x41, 0x89,
+    0x00, 0x00, 0x41, 0x8d, 0x00, 0x00, 0x41, 0x92, 0x00, 0x00, 0x41, 0x98,
+    0x00, 0x00, 0x41, 0x9e, 0x00, 0x00, 0x41, 0xa7, 0x00, 0x00, 0x41, 0xb0,
+    0x00, 0x00, 0x41, 0xb5, 0x00, 0x00, 0x41, 0xbc, 0x00, 0x00, 0x41, 0xc4,
+    0x00, 0x00, 0x41, 0xc9, 0x00, 0x00, 0x41, 0xce, 0x00, 0x00, 0x41, 0xd4,
+    0x00, 0x00, 0x41, 0xda, 0x00, 0x00, 0x41, 0xe1, 0x00, 0x00, 0x41, 0xe8,
+    0x00, 0x00, 0x41, 0xef, 0x00, 0x00, 0x41, 0xf5, 0x00, 0x00, 0x41, 0xfa,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x07, 0x00, 0x00, 0x42, 0x10,
+    0x00, 0x00, 0x42, 0x19, 0x00, 0x00, 0x42, 0x21, 0x00, 0x00, 0x42, 0x28,
+    0x00, 0x00, 0x42, 0x32, 0x00, 0x00, 0x42, 0x3c, 0x00, 0x00, 0x42, 0x44,
+    0x00, 0x00, 0x42, 0x49, 0x00, 0x00, 0x42, 0x50, 0x00, 0x00, 0x42, 0x57,
+    0x00, 0x00, 0x42, 0x5d, 0x00, 0x00, 0x42, 0x64, 0x00, 0x00, 0x42, 0x6b,
+    0x00, 0x00, 0x42, 0x74, 0x00, 0x00, 0x42, 0x7a, 0x00, 0x00, 0x42, 0x80,
+    0x00, 0x00, 0x42, 0x87, 0x00, 0x00, 0x42, 0x8b, 0x00, 0x00, 0x42, 0x90,
+    0x00, 0x00, 0x42, 0x96, 0x00, 0x00, 0x42, 0x9f, 0x00, 0x00, 0x42, 0xa4,
+    0x00, 0x00, 0x42, 0xa9, 0x00, 0x00, 0x42, 0xaf, 0x00, 0x00, 0x42, 0xb7,
+    0x00, 0x00, 0x42, 0xbc, 0x00, 0x00, 0x42, 0xc1, 0x00, 0x00, 0x42, 0xc7,
+    0x00, 0x00, 0x42, 0xce, 0x00, 0x00, 0x42, 0xd5, 0x00, 0x00, 0x42, 0xda,
+    0x00, 0x00, 0x42, 0xdf, 0x00, 0x00, 0x42, 0xe5, 0x00, 0x00, 0x42, 0xec,
+    0x00, 0x00, 0x42, 0xf2, 0x00, 0x00, 0x42, 0xf7, 0x00, 0x00, 0x42, 0xfd,
+    0x00, 0x00, 0x43, 0x04, 0x00, 0x00, 0x43, 0x0c, 0x00, 0x00, 0x43, 0x14,
+    0x00, 0x00, 0x43, 0x1c, 0x00, 0x00, 0x43, 0x25, 0x00, 0x00, 0x43, 0x2e,
+    0x00, 0x00, 0x43, 0x34, 0x00, 0x00, 0x43, 0x3d, 0x00, 0x00, 0x43, 0x46,
+    0x00, 0x00, 0x43, 0x4d, 0x00, 0x00, 0x43, 0x55, 0x00, 0x00, 0x43, 0x5e,
+    0x00, 0x00, 0x43, 0x67, 0x00, 0x00, 0x43, 0x6d, 0x00, 0x00, 0x43, 0x75,
+    0x00, 0x00, 0x43, 0x7c, 0x00, 0x00, 0x43, 0x81, 0x00, 0x00, 0x43, 0x86,
+    0x00, 0x00, 0x43, 0x8c, 0x00, 0x00, 0x43, 0x93, 0x00, 0x00, 0x43, 0x9a,
+    0x00, 0x00, 0x43, 0xa0, 0x00, 0x00, 0x43, 0xa6, 0x00, 0x00, 0x43, 0xad,
+    0x00, 0x00, 0x43, 0xb5, 0x00, 0x00, 0x43, 0xbd, 0x00, 0x00, 0x43, 0xc3,
+    0x00, 0x00, 0x43, 0xc6, 0x00, 0x00, 0x43, 0xcc, 0x00, 0x00, 0x43, 0xd1,
+    0x00, 0x00, 0x43, 0xd7, 0x00, 0x00, 0x43, 0xdc, 0x00, 0x00, 0x43, 0xe0,
+    0x00, 0x00, 0x43, 0xe6, 0x00, 0x00, 0x43, 0xee, 0x00, 0x00, 0x43, 0xf6,
+    0x00, 0x00, 0x43, 0xfb, 0x00, 0x00, 0x44, 0x03, 0x00, 0x00, 0x44, 0x09,
+    0x00, 0x00, 0x44, 0x0e, 0x00, 0x00, 0x44, 0x15, 0x00, 0x00, 0x44, 0x1b,
+    0x00, 0x00, 0x44, 0x1f, 0x00, 0x00, 0x44, 0x26, 0x00, 0x00, 0x44, 0x2b,
+    0x00, 0x00, 0x44, 0x33, 0x00, 0x00, 0x44, 0x3b, 0x00, 0x00, 0x44, 0x41,
+    0x00, 0x00, 0x44, 0x49, 0x00, 0x00, 0x44, 0x50, 0x00, 0x00, 0x44, 0x57,
+    0x00, 0x00, 0x44, 0x5d, 0x00, 0x00, 0x44, 0x65, 0x00, 0x00, 0x44, 0x6d,
+    0x00, 0x00, 0x44, 0x72, 0x00, 0x00, 0x44, 0x78, 0x00, 0x00, 0x44, 0x7f,
+    0x00, 0x00, 0x44, 0x86, 0x00, 0x00, 0x44, 0x8c, 0x00, 0x00, 0x44, 0x93,
+    0x00, 0x00, 0x44, 0x99, 0x00, 0x00, 0x44, 0x9e, 0x00, 0x00, 0x44, 0xa4,
+    0x00, 0x00, 0x44, 0xab, 0x00, 0x00, 0x44, 0xb1, 0x00, 0x00, 0x44, 0xb8,
+    0x00, 0x00, 0x44, 0xbf, 0x00, 0x00, 0x44, 0xc6, 0x00, 0x00, 0x44, 0xce,
+    0x00, 0x00, 0x44, 0xd3, 0x00, 0x00, 0x44, 0xd9, 0x00, 0x00, 0x44, 0xe1,
+    0x00, 0x00, 0x44, 0xe9, 0x00, 0x00, 0x44, 0xef, 0x00, 0x00, 0x44, 0xf6,
+    0x00, 0x00, 0x44, 0xfc, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x45, 0x09,
+    0x00, 0x00, 0x45, 0x10, 0x00, 0x00, 0x45, 0x19, 0x00, 0x00, 0x45, 0x21,
+    0x00, 0x00, 0x45, 0x27, 0x00, 0x00, 0x45, 0x2e, 0x00, 0x00, 0x45, 0x34,
+    0x00, 0x00, 0x45, 0x3b, 0x00, 0x00, 0x45, 0x41, 0x00, 0x00, 0x45, 0x46,
+    0x00, 0x00, 0x45, 0x4c, 0x00, 0x00, 0x45, 0x52, 0x00, 0x00, 0x45, 0x5b,
+    0x00, 0x00, 0x45, 0x61, 0x00, 0x00, 0x45, 0x67, 0x00, 0x00, 0x45, 0x6c,
+    0x00, 0x00, 0x45, 0x72, 0x00, 0x00, 0x45, 0x7c, 0x00, 0x00, 0x45, 0x83,
+    0x00, 0x00, 0x45, 0x88, 0x00, 0x00, 0x45, 0x90, 0x00, 0x00, 0x45, 0x98,
+    0x00, 0x00, 0x45, 0xa1, 0x00, 0x00, 0x45, 0xaa, 0x00, 0x00, 0x45, 0xb4,
+    0x00, 0x00, 0x45, 0xbe, 0x00, 0x00, 0x45, 0xc8, 0x00, 0x00, 0x45, 0xd1,
+    0x00, 0x00, 0x45, 0xd7, 0x00, 0x00, 0x45, 0xe1, 0x00, 0x00, 0x45, 0xea,
+    0x00, 0x00, 0x45, 0xf4, 0x00, 0x00, 0x45, 0xfe, 0x00, 0x00, 0x46, 0x06,
+    0x00, 0x00, 0x46, 0x0f, 0x00, 0x00, 0x46, 0x16, 0x00, 0x00, 0x46, 0x1c,
+    0x00, 0x00, 0x46, 0x23, 0x00, 0x00, 0x46, 0x2c, 0x00, 0x00, 0x46, 0x35,
+    0x00, 0x00, 0x46, 0x3e, 0x00, 0x00, 0x46, 0x46, 0x00, 0x00, 0x46, 0x4e,
+    0x00, 0x00, 0x46, 0x57, 0x00, 0x00, 0x46, 0x5f, 0x00, 0x00, 0x46, 0x68,
+    0x00, 0x00, 0x46, 0x6e, 0x00, 0x00, 0x46, 0x76, 0x00, 0x00, 0x46, 0x7b,
+    0x00, 0x00, 0x46, 0x81, 0x00, 0x00, 0x46, 0x87, 0x00, 0x00, 0x46, 0x8e,
+    0x00, 0x00, 0x46, 0x95, 0x00, 0x00, 0x46, 0x9d, 0x00, 0x00, 0x46, 0xa5,
+    0x00, 0x00, 0x46, 0xac, 0x00, 0x00, 0x46, 0xb1, 0x00, 0x00, 0x46, 0xb5,
+    0x00, 0x00, 0x46, 0xbb, 0x00, 0x00, 0x46, 0xc2, 0x00, 0x00, 0x46, 0xc7,
+    0x00, 0x00, 0x46, 0xcd, 0x00, 0x00, 0x46, 0xd4, 0x00, 0x00, 0x46, 0xdc,
+    0x00, 0x00, 0x46, 0xe5, 0x00, 0x00, 0x46, 0xed, 0x00, 0x00, 0x46, 0xf4,
+    0x00, 0x00, 0x46, 0xfa, 0x00, 0x00, 0x47, 0x01, 0x00, 0x00, 0x47, 0x07,
+    0x00, 0x00, 0x47, 0x0d, 0x00, 0x00, 0x47, 0x14, 0x00, 0x00, 0x47, 0x1b,
+    0x00, 0x00, 0x47, 0x21, 0x00, 0x00, 0x47, 0x27, 0x00, 0x00, 0x47, 0x2d,
+    0x00, 0x00, 0x47, 0x34, 0x00, 0x00, 0x47, 0x3a, 0x00, 0x00, 0x47, 0x41,
+    0x00, 0x00, 0x47, 0x46, 0x00, 0x00, 0x47, 0x4c, 0x00, 0x00, 0x47, 0x53,
+    0x00, 0x00, 0x47, 0x5a, 0x00, 0x00, 0x47, 0x60, 0x00, 0x00, 0x47, 0x67,
+    0x00, 0x00, 0x47, 0x6d, 0x00, 0x00, 0x47, 0x74, 0x00, 0x00, 0x47, 0x7b,
+    0x00, 0x00, 0x47, 0x81, 0x00, 0x00, 0x47, 0x88, 0x00, 0x00, 0x47, 0x8f,
+    0x00, 0x00, 0x47, 0x98, 0x00, 0x00, 0x47, 0x9c, 0x00, 0x00, 0x47, 0xa1,
+    0x00, 0x00, 0x47, 0xa7, 0x00, 0x00, 0x47, 0xae, 0x00, 0x00, 0x47, 0xb6,
+    0x00, 0x00, 0x47, 0xbd, 0x00, 0x00, 0x47, 0xc6, 0x00, 0x00, 0x47, 0xcd,
+    0x00, 0x00, 0x47, 0xd3, 0x00, 0x00, 0x47, 0xdb, 0x00, 0x00, 0x47, 0xe1,
+    0x00, 0x00, 0x47, 0xe9, 0x00, 0x00, 0x47, 0xf1, 0x00, 0x00, 0x47, 0xf7,
+    0x00, 0x00, 0x47, 0xfc, 0x00, 0x00, 0x48, 0x03, 0x00, 0x00, 0x48, 0x09,
+    0x00, 0x00, 0x48, 0x12, 0x00, 0x00, 0x48, 0x1b, 0x00, 0x00, 0x48, 0x20,
+    0x00, 0x00, 0x48, 0x26, 0x00, 0x00, 0x48, 0x2b, 0x00, 0x00, 0x48, 0x32,
+    0x00, 0x00, 0x48, 0x38, 0x00, 0x00, 0x48, 0x3f, 0x00, 0x00, 0x48, 0x45,
+    0x00, 0x00, 0x48, 0x4d, 0x00, 0x00, 0x48, 0x53, 0x00, 0x00, 0x48, 0x5a,
+    0x00, 0x00, 0x48, 0x62, 0x00, 0x00, 0x48, 0x67, 0x00, 0x00, 0x48, 0x6d,
+    0x00, 0x00, 0x48, 0x73, 0x00, 0x00, 0x48, 0x7c, 0x00, 0x00, 0x48, 0x85,
+    0x00, 0x00, 0x48, 0x89, 0x00, 0x00, 0x48, 0x8f, 0x00, 0x00, 0x48, 0x95,
+    0x00, 0x00, 0x48, 0x9b, 0x00, 0x00, 0x48, 0xa4, 0x00, 0x00, 0x48, 0xab,
+    0x00, 0x00, 0x48, 0xb1, 0x00, 0x00, 0x48, 0xb7, 0x00, 0x00, 0x48, 0xbb,
+    0x00, 0x00, 0x48, 0xc2, 0x00, 0x00, 0x48, 0xcc, 0x00, 0x00, 0x48, 0xd6,
+    0x00, 0x00, 0x48, 0xe0, 0x00, 0x00, 0x48, 0xe9, 0x00, 0x00, 0x48, 0xf3,
+    0x00, 0x00, 0x48, 0xfc, 0x00, 0x00, 0x49, 0x04, 0x00, 0x00, 0x49, 0x0b,
+    0x00, 0x00, 0x49, 0x10, 0x00, 0x00, 0x49, 0x17, 0x00, 0x00, 0x49, 0x1c,
+    0x00, 0x00, 0x49, 0x23, 0x00, 0x00, 0x49, 0x28, 0x00, 0x00, 0x49, 0x2c,
+    0x00, 0x00, 0x49, 0x31, 0x00, 0x00, 0x49, 0x37, 0x00, 0x00, 0x49, 0x3c,
+    0x00, 0x00, 0x49, 0x44, 0x00, 0x00, 0x49, 0x4c, 0x00, 0x00, 0x49, 0x54,
+    0x00, 0x00, 0x49, 0x5a, 0x00, 0x00, 0x49, 0x5e, 0x00, 0x00, 0x49, 0x65,
+    0x00, 0x00, 0x49, 0x6b, 0x00, 0x00, 0x49, 0x72, 0x00, 0x00, 0x49, 0x79,
+    0x00, 0x00, 0x49, 0x7f, 0x00, 0x00, 0x49, 0x85, 0x00, 0x00, 0x49, 0x8b,
+    0x00, 0x00, 0x49, 0x90, 0x00, 0x00, 0x49, 0x98, 0x00, 0x00, 0x49, 0x9d,
+    0x00, 0x00, 0x49, 0xa6, 0x00, 0x00, 0x49, 0xac, 0x00, 0x00, 0x49, 0xb1,
+    0x00, 0x00, 0x49, 0xb9, 0x00, 0x00, 0x49, 0xc0, 0x00, 0x00, 0x49, 0xc7,
+    0x00, 0x00, 0x49, 0xcf, 0x00, 0x00, 0x49, 0xd7, 0x00, 0x00, 0x49, 0xe0,
+    0x00, 0x00, 0x49, 0xe8, 0x00, 0x00, 0x49, 0xf0, 0x00, 0x00, 0x49, 0xf7,
+    0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x4a, 0x08, 0x00, 0x00, 0x4a, 0x10,
+    0x00, 0x00, 0x4a, 0x19, 0x00, 0x00, 0x4a, 0x22, 0x00, 0x00, 0x4a, 0x2a,
+    0x00, 0x00, 0x4a, 0x34, 0x00, 0x00, 0x4a, 0x3f, 0x00, 0x00, 0x4a, 0x46,
+    0x00, 0x00, 0x4a, 0x4e, 0x00, 0x00, 0x4a, 0x55, 0x00, 0x00, 0x4a, 0x5d,
+    0x00, 0x00, 0x4a, 0x65, 0x00, 0x00, 0x4a, 0x6d, 0x00, 0x00, 0x4a, 0x76,
+    0x00, 0x00, 0x4a, 0x7e, 0x00, 0x00, 0x4a, 0x87, 0x00, 0x00, 0x4a, 0x8b,
+    0x00, 0x00, 0x4a, 0x90, 0x00, 0x00, 0x4a, 0x97, 0x00, 0x00, 0x4a, 0x9c,
+    0x00, 0x00, 0x4a, 0xa1, 0x00, 0x00, 0x4a, 0xa7, 0x00, 0x00, 0x4a, 0xad,
+    0x00, 0x00, 0x4a, 0xb1, 0x00, 0x00, 0x4a, 0xba, 0x00, 0x00, 0x4a, 0xc0,
+    0x00, 0x00, 0x4a, 0xc6, 0x00, 0x00, 0x4a, 0xcb, 0x00, 0x00, 0x4a, 0xd1,
+    0x00, 0x00, 0x4a, 0xd7, 0x00, 0x00, 0x4a, 0xe0, 0x00, 0x00, 0x4a, 0xe5,
+    0x00, 0x00, 0x4a, 0xeb, 0x00, 0x00, 0x4a, 0xf4, 0x00, 0x00, 0x4a, 0xf9,
+    0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x4b, 0x08, 0x00, 0x00, 0x4b, 0x0d,
+    0x00, 0x00, 0x4b, 0x12, 0x00, 0x00, 0x4b, 0x19, 0x00, 0x00, 0x4b, 0x1d,
+    0x00, 0x00, 0x4b, 0x23, 0x00, 0x00, 0x4b, 0x29, 0x00, 0x00, 0x4b, 0x31,
+    0x00, 0x00, 0x4b, 0x3a, 0x00, 0x00, 0x4b, 0x43, 0x00, 0x00, 0x4b, 0x4c,
+    0x00, 0x00, 0x4b, 0x54, 0x00, 0x00, 0x4b, 0x5c, 0x00, 0x00, 0x4b, 0x65,
+    0x00, 0x00, 0x4b, 0x6b, 0x00, 0x00, 0x4b, 0x74, 0x00, 0x00, 0x4b, 0x7c,
+    0x00, 0x00, 0x4b, 0x83, 0x00, 0x00, 0x4b, 0x88, 0x00, 0x00, 0x4b, 0x8e,
+    0x00, 0x00, 0x4b, 0x97, 0x00, 0x00, 0x4b, 0x9e, 0x00, 0x00, 0x4b, 0xa2,
+    0x00, 0x00, 0x4b, 0xa7, 0x00, 0x00, 0x4b, 0xad, 0x00, 0x00, 0x4b, 0xb4,
+    0x00, 0x00, 0x4b, 0xb9, 0x00, 0x00, 0x4b, 0xc0, 0x00, 0x00, 0x4b, 0xc8,
+    0x00, 0x00, 0x4b, 0xd0, 0x00, 0x00, 0x4b, 0xd5, 0x00, 0x00, 0x4b, 0xda,
+    0x00, 0x00, 0x4b, 0xe0, 0x00, 0x00, 0x4b, 0xe7, 0x00, 0x00, 0x4b, 0xee,
+    0x00, 0x00, 0x4b, 0xf4, 0x00, 0x00, 0x4b, 0xfb, 0x00, 0x00, 0x4c, 0x04,
+    0x00, 0x00, 0x4c, 0x0c, 0x00, 0x00, 0x4c, 0x11, 0x00, 0x00, 0x4c, 0x17,
+    0x00, 0x00, 0x4c, 0x1f, 0x00, 0x00, 0x4c, 0x25, 0x00, 0x00, 0x4c, 0x2e,
+    0x00, 0x00, 0x4c, 0x35, 0x00, 0x00, 0x4c, 0x3d, 0x00, 0x00, 0x4c, 0x44,
+    0x00, 0x00, 0x4c, 0x4c, 0x00, 0x00, 0x4c, 0x55, 0x00, 0x00, 0x4c, 0x5b,
+    0x00, 0x00, 0x4c, 0x61, 0x00, 0x00, 0x4c, 0x6a, 0x00, 0x00, 0x4c, 0x73,
+    0x00, 0x00, 0x4c, 0x7d, 0x00, 0x00, 0x4c, 0x85, 0x00, 0x00, 0x4c, 0x8f,
+    0x00, 0x00, 0x4c, 0x97, 0x00, 0x00, 0x4c, 0xa0, 0x00, 0x00, 0x4c, 0xaa,
+    0x00, 0x00, 0x4c, 0xb1, 0x00, 0x00, 0x4c, 0xb9, 0x00, 0x00, 0x4c, 0xc0,
+    0x00, 0x00, 0x4c, 0xc9, 0x00, 0x00, 0x4c, 0xd2, 0x00, 0x00, 0x4c, 0xda,
+    0x00, 0x00, 0x4c, 0xe2, 0x00, 0x00, 0x4c, 0xeb, 0x00, 0x00, 0x4c, 0xf3,
+    0x00, 0x00, 0x4c, 0xfc, 0x00, 0x00, 0x4d, 0x04, 0x00, 0x00, 0x4d, 0x0a,
+    0x00, 0x00, 0x4d, 0x12, 0x00, 0x00, 0x4d, 0x19, 0x00, 0x00, 0x4d, 0x21,
+    0x00, 0x00, 0x4d, 0x29, 0x00, 0x00, 0x4d, 0x31, 0x00, 0x00, 0x4d, 0x39,
+    0x00, 0x00, 0x4d, 0x41, 0x00, 0x00, 0x4d, 0x48, 0x00, 0x00, 0x4d, 0x50,
+    0x00, 0x00, 0x4d, 0x58, 0x00, 0x00, 0x4d, 0x61, 0x00, 0x00, 0x4d, 0x69,
+    0x00, 0x00, 0x4d, 0x72, 0x00, 0x00, 0x4d, 0x78, 0x00, 0x00, 0x4d, 0x7e,
+    0x00, 0x00, 0x4d, 0x87, 0x00, 0x00, 0x4d, 0x8e, 0x00, 0x00, 0x4d, 0x94,
+    0x00, 0x00, 0x4d, 0x9c, 0x00, 0x00, 0x4d, 0xa3, 0x00, 0x00, 0x4d, 0xaa,
+    0x00, 0x00, 0x4d, 0xb2, 0x00, 0x00, 0x4d, 0xbb, 0x00, 0x00, 0x4d, 0xc3,
+    0x00, 0x00, 0x4d, 0xcc, 0x00, 0x00, 0x4d, 0xd5, 0x00, 0x00, 0x4d, 0xdb,
+    0x00, 0x00, 0x4d, 0xe3, 0x00, 0x00, 0x4d, 0xea, 0x00, 0x00, 0x4d, 0xf3,
+    0x00, 0x00, 0x4d, 0xfb, 0x00, 0x00, 0x4e, 0x02, 0x00, 0x00, 0x4e, 0x09,
+    0x00, 0x00, 0x4e, 0x11, 0x00, 0x00, 0x4e, 0x19, 0x00, 0x00, 0x4e, 0x20,
+    0x00, 0x00, 0x4e, 0x27, 0x00, 0x00, 0x4e, 0x2f, 0x00, 0x00, 0x4e, 0x37,
+    0x00, 0x00, 0x4e, 0x3e, 0x00, 0x00, 0x4e, 0x46, 0x00, 0x00, 0x4e, 0x4d,
+    0x00, 0x00, 0x4e, 0x55, 0x00, 0x00, 0x4e, 0x5b, 0x00, 0x00, 0x4e, 0x62,
+    0x00, 0x00, 0x4e, 0x6a, 0x00, 0x00, 0x4e, 0x71, 0x00, 0x00, 0x4e, 0x79,
+    0x00, 0x00, 0x4e, 0x81, 0x00, 0x00, 0x4e, 0x89, 0x00, 0x00, 0x4e, 0x90,
+    0x00, 0x00, 0x4e, 0x98, 0x00, 0x00, 0x4e, 0xa0, 0x00, 0x00, 0x4e, 0xaa,
+    0x00, 0x00, 0x4e, 0xb3, 0x00, 0x00, 0x4e, 0xb9, 0x00, 0x00, 0x4e, 0xbf,
+    0x00, 0x00, 0x4e, 0xc6, 0x00, 0x00, 0x4e, 0xc9, 0x00, 0x00, 0x4e, 0xcd,
+    0x00, 0x00, 0x4e, 0xd2, 0x00, 0x00, 0x4e, 0xd7, 0x00, 0x00, 0x4e, 0xdd,
+    0x00, 0x00, 0x4e, 0xe5, 0x00, 0x00, 0x4e, 0xed, 0x00, 0x00, 0x4e, 0xf3,
+    0x00, 0x00, 0x4e, 0xfa, 0x00, 0x00, 0x4f, 0x01, 0x00, 0x00, 0x4f, 0x09,
+    0x00, 0x00, 0x4f, 0x10, 0x00, 0x00, 0x4f, 0x19, 0x00, 0x00, 0x4f, 0x1f,
+    0x00, 0x00, 0x4f, 0x24, 0x00, 0x00, 0x4f, 0x28, 0x00, 0x00, 0x4f, 0x2f,
+    0x00, 0x00, 0x4f, 0x37, 0x00, 0x00, 0x4f, 0x3f, 0x00, 0x00, 0x4f, 0x45,
+    0x00, 0x00, 0x4f, 0x4b, 0x00, 0x00, 0x4f, 0x50, 0x00, 0x00, 0x4f, 0x56,
+    0x00, 0x00, 0x4f, 0x5b, 0x00, 0x00, 0x4f, 0x61, 0x00, 0x00, 0x4f, 0x68,
+    0x00, 0x00, 0x4f, 0x71, 0x00, 0x00, 0x4f, 0x77, 0x00, 0x00, 0x4f, 0x7f,
+    0x00, 0x00, 0x4f, 0x85, 0x00, 0x00, 0x4f, 0x8c, 0x00, 0x00, 0x4f, 0x94,
+    0x00, 0x00, 0x4f, 0x99, 0x00, 0x00, 0x4f, 0x9f, 0x00, 0x00, 0x4f, 0xa6,
+    0x00, 0x00, 0x4f, 0xac, 0x00, 0x00, 0x4f, 0xb3, 0x00, 0x00, 0x4f, 0xb7,
+    0x00, 0x00, 0x4f, 0xbc, 0x00, 0x00, 0x4f, 0xc3, 0x00, 0x00, 0x4f, 0xca,
+    0x00, 0x00, 0x4f, 0xd0, 0x00, 0x00, 0x4f, 0xd7, 0x00, 0x00, 0x4f, 0xdd,
+    0x00, 0x00, 0x4f, 0xe4, 0x00, 0x00, 0x4f, 0xeb, 0x00, 0x00, 0x4f, 0xef,
+    0x00, 0x00, 0x4f, 0xf5, 0x00, 0x00, 0x4f, 0xfb, 0x00, 0x00, 0x50, 0x00,
+    0x00, 0x00, 0x50, 0x06, 0x00, 0x00, 0x50, 0x0e, 0x00, 0x00, 0x50, 0x17,
+    0x00, 0x00, 0x50, 0x20, 0x00, 0x00, 0x50, 0x26, 0x00, 0x00, 0x50, 0x2d,
+    0x00, 0x00, 0x50, 0x34, 0x00, 0x00, 0x50, 0x3c, 0x00, 0x00, 0x50, 0x43,
+    0x00, 0x00, 0x50, 0x4b, 0x00, 0x00, 0x50, 0x52, 0x00, 0x00, 0x50, 0x5a,
+    0x00, 0x00, 0x50, 0x62, 0x00, 0x00, 0x50, 0x6b, 0x00, 0x00, 0x50, 0x74,
+    0x00, 0x00, 0x50, 0x7a, 0x00, 0x00, 0x50, 0x80, 0x00, 0x00, 0x50, 0x85,
+    0x00, 0x00, 0x50, 0x8b, 0x00, 0x00, 0x50, 0x8f, 0x00, 0x00, 0x50, 0x94,
+    0x00, 0x00, 0x50, 0x9a, 0x00, 0x00, 0x50, 0xa0, 0x00, 0x00, 0x50, 0xa7,
+    0x00, 0x00, 0x50, 0xae, 0x00, 0x00, 0x50, 0xb4, 0x00, 0x00, 0x50, 0xbb,
+    0x00, 0x00, 0x50, 0xc2, 0x00, 0x00, 0x50, 0xc9, 0x00, 0x00, 0x50, 0xce,
+    0x00, 0x00, 0x50, 0xd4, 0x00, 0x00, 0x50, 0xdc, 0x00, 0x00, 0x50, 0xe4,
+    0x00, 0x00, 0x50, 0xec, 0x00, 0x00, 0x50, 0xf3, 0x00, 0x00, 0x50, 0xf9,
+    0x00, 0x00, 0x50, 0xfe, 0x00, 0x00, 0x51, 0x04, 0x00, 0x00, 0x51, 0x0a,
+    0x00, 0x00, 0x51, 0x11, 0x00, 0x00, 0x51, 0x14, 0x00, 0x00, 0x51, 0x18,
+    0x00, 0x00, 0x51, 0x1e, 0x00, 0x00, 0x51, 0x24, 0x00, 0x00, 0x51, 0x2b,
+    0x00, 0x00, 0x51, 0x32, 0x00, 0x00, 0x51, 0x38, 0x00, 0x00, 0x51, 0x40,
+    0x00, 0x00, 0x51, 0x48, 0x00, 0x00, 0x51, 0x4d, 0x00, 0x00, 0x51, 0x53,
+    0x00, 0x00, 0x51, 0x58, 0x00, 0x00, 0x51, 0x63, 0x00, 0x00, 0x51, 0x69,
+    0x00, 0x00, 0x51, 0x6e, 0x00, 0x00, 0x51, 0x73, 0x00, 0x00, 0x51, 0x79,
+    0x00, 0x00, 0x51, 0x80, 0x00, 0x00, 0x51, 0x88, 0x00, 0x00, 0x51, 0x8e,
+    0x00, 0x00, 0x51, 0x94, 0x00, 0x00, 0x51, 0x9b, 0x00, 0x00, 0x51, 0xa3,
+    0x00, 0x00, 0x51, 0xab, 0x00, 0x00, 0x51, 0xb4, 0x00, 0x00, 0x51, 0xbb,
+    0x00, 0x00, 0x51, 0xc1, 0x00, 0x00, 0x51, 0xc6, 0x00, 0x00, 0x51, 0xca,
+    0x00, 0x00, 0x51, 0xcf, 0x00, 0x00, 0x51, 0xd7, 0x00, 0x00, 0x51, 0xdd,
+    0x00, 0x00, 0x51, 0xe5, 0x00, 0x00, 0x51, 0xed, 0x00, 0x00, 0x51, 0xf4,
+    0x00, 0x00, 0x51, 0xfa, 0x00, 0x00, 0x52, 0x02, 0x00, 0x00, 0x52, 0x07,
+    0x00, 0x00, 0x52, 0x0c, 0x00, 0x00, 0x52, 0x11, 0x00, 0x00, 0x52, 0x18,
+    0x00, 0x00, 0x52, 0x1f, 0x00, 0x00, 0x52, 0x24, 0x00, 0x00, 0x52, 0x2b,
+    0x00, 0x00, 0x52, 0x33, 0x00, 0x00, 0x52, 0x3a, 0x00, 0x00, 0x52, 0x3f,
+    0x00, 0x00, 0x52, 0x48, 0x00, 0x00, 0x52, 0x51, 0x00, 0x00, 0x52, 0x59,
+    0x00, 0x00, 0x52, 0x5e, 0x00, 0x00, 0x52, 0x66, 0x00, 0x00, 0x52, 0x6c,
+    0x00, 0x00, 0x52, 0x72, 0x00, 0x00, 0x52, 0x7b, 0x00, 0x00, 0x52, 0x80,
+    0x00, 0x00, 0x52, 0x86, 0x00, 0x00, 0x52, 0x8a, 0x00, 0x00, 0x52, 0x8f,
+    0x00, 0x00, 0x52, 0x98, 0x00, 0x00, 0x52, 0xa0, 0x00, 0x00, 0x52, 0xa7,
+    0x00, 0x00, 0x52, 0xaf, 0x00, 0x00, 0x52, 0xb8, 0x00, 0x00, 0x52, 0xbf,
+    0x00, 0x00, 0x52, 0xc5, 0x00, 0x00, 0x52, 0xca, 0x00, 0x00, 0x52, 0xd0,
+    0x00, 0x00, 0x52, 0xd6, 0x00, 0x00, 0x52, 0xdb, 0x00, 0x00, 0x52, 0xe1,
+    0x00, 0x00, 0x52, 0xe6, 0x00, 0x00, 0x52, 0xed, 0x00, 0x00, 0x52, 0xf2,
+    0x00, 0x00, 0x52, 0xf6, 0x00, 0x00, 0x52, 0xfb, 0x00, 0x00, 0x53, 0x01,
+    0x00, 0x00, 0x53, 0x06, 0x00, 0x00, 0x53, 0x0b, 0x00, 0x00, 0x53, 0x11,
+    0x00, 0x00, 0x53, 0x18, 0x00, 0x00, 0x53, 0x1e, 0x00, 0x00, 0x53, 0x23,
+    0x00, 0x00, 0x53, 0x2b, 0x00, 0x00, 0x53, 0x33, 0x00, 0x00, 0x53, 0x38,
+    0x00, 0x00, 0x53, 0x3f, 0x00, 0x00, 0x53, 0x45, 0x00, 0x00, 0x53, 0x4c,
+    0x00, 0x00, 0x53, 0x54, 0x00, 0x00, 0x53, 0x5a, 0x00, 0x00, 0x53, 0x61,
+    0x00, 0x00, 0x53, 0x68, 0x00, 0x00, 0x53, 0x70, 0x00, 0x00, 0x53, 0x78,
+    0x00, 0x00, 0x53, 0x7f, 0x00, 0x00, 0x53, 0x87, 0x00, 0x00, 0x53, 0x8f,
+    0x00, 0x00, 0x53, 0x94, 0x00, 0x00, 0x53, 0x9a, 0x00, 0x00, 0x53, 0xa2,
+    0x00, 0x00, 0x53, 0xa8, 0x00, 0x00, 0x53, 0xb0, 0x00, 0x00, 0x53, 0xb7,
+    0x00, 0x00, 0x53, 0xbf, 0x00, 0x00, 0x53, 0xc6, 0x00, 0x00, 0x53, 0xcc,
+    0x00, 0x00, 0x53, 0xd3, 0x00, 0x00, 0x53, 0xd9, 0x00, 0x00, 0x53, 0xe2,
+    0x00, 0x00, 0x53, 0xeb, 0x00, 0x00, 0x53, 0xf1, 0x00, 0x00, 0x53, 0xfa,
+    0x00, 0x00, 0x54, 0x01, 0x00, 0x00, 0x54, 0x09, 0x00, 0x00, 0x54, 0x0e,
+    0x00, 0x00, 0x54, 0x15, 0x00, 0x00, 0x54, 0x19, 0x00, 0x00, 0x54, 0x20,
+    0x00, 0x00, 0x54, 0x28, 0x00, 0x00, 0x54, 0x30, 0x00, 0x00, 0x54, 0x38,
+    0x00, 0x00, 0x54, 0x3e, 0x00, 0x00, 0x54, 0x44, 0x00, 0x00, 0x54, 0x4b,
+    0x00, 0x00, 0x54, 0x52, 0x00, 0x00, 0x54, 0x58, 0x00, 0x00, 0x54, 0x60,
+    0x00, 0x00, 0x54, 0x67, 0x00, 0x00, 0x54, 0x70, 0x00, 0x00, 0x54, 0x75,
+    0x00, 0x00, 0x54, 0x7d, 0x00, 0x00, 0x54, 0x85, 0x00, 0x00, 0x54, 0x8b,
+    0x00, 0x00, 0x54, 0x92, 0x00, 0x00, 0x54, 0x98, 0x00, 0x00, 0x54, 0x9d,
+    0x00, 0x00, 0x54, 0xa0, 0x00, 0x00, 0x54, 0xa6, 0x00, 0x00, 0x54, 0xac,
+    0x00, 0x00, 0x54, 0xb3, 0x00, 0x00, 0x54, 0xba, 0x00, 0x00, 0x54, 0xbf,
+    0x00, 0x00, 0x54, 0xc5, 0x00, 0x00, 0x54, 0xca, 0x00, 0x00, 0x54, 0xd0,
+    0x00, 0x00, 0x54, 0xd8, 0x00, 0x00, 0x54, 0xe0, 0x00, 0x00, 0x54, 0xe6,
+    0x00, 0x00, 0x54, 0xed, 0x00, 0x00, 0x54, 0xf6, 0x00, 0x00, 0x54, 0xfd,
+    0x00, 0x00, 0x55, 0x04, 0x00, 0x00, 0x55, 0x0c, 0x00, 0x00, 0x55, 0x14,
+    0x00, 0x00, 0x55, 0x1b, 0x00, 0x00, 0x55, 0x23, 0x00, 0x00, 0x55, 0x29,
+    0x00, 0x00, 0x55, 0x30, 0x00, 0x00, 0x55, 0x39, 0x00, 0x00, 0x55, 0x42,
+    0x00, 0x00, 0x55, 0x47, 0x00, 0x00, 0x55, 0x4d, 0x00, 0x00, 0x55, 0x56,
+    0x00, 0x00, 0x55, 0x5a, 0x00, 0x00, 0x55, 0x61, 0x00, 0x00, 0x55, 0x68,
+    0x00, 0x00, 0x55, 0x6e, 0x00, 0x00, 0x55, 0x73, 0x00, 0x00, 0x55, 0x79,
+    0x00, 0x00, 0x55, 0x7f, 0x00, 0x00, 0x55, 0x84, 0x00, 0x00, 0x55, 0x89,
+    0x00, 0x00, 0x55, 0x8e, 0x00, 0x00, 0x55, 0x93, 0x00, 0x00, 0x55, 0x98,
+    0x00, 0x00, 0x55, 0x9f, 0x00, 0x00, 0x55, 0xa4, 0x00, 0x00, 0x55, 0xac,
+    0x00, 0x00, 0x55, 0xb4, 0x00, 0x00, 0x55, 0xbb, 0x00, 0x00, 0x55, 0xc3,
+    0x00, 0x00, 0x55, 0xc7, 0x00, 0x00, 0x55, 0xcc, 0x00, 0x00, 0x55, 0xd2,
+    0x00, 0x00, 0x55, 0xd7, 0x00, 0x00, 0x55, 0xdc, 0x00, 0x00, 0x55, 0xe2,
+    0x00, 0x00, 0x55, 0xe6, 0x00, 0x00, 0x55, 0xec, 0x00, 0x00, 0x55, 0xf3,
+    0x00, 0x00, 0x55, 0xfa, 0x00, 0x00, 0x56, 0x02, 0x00, 0x00, 0x56, 0x0a,
+    0x00, 0x00, 0x56, 0x11, 0x00, 0x00, 0x56, 0x19, 0x00, 0x00, 0x56, 0x21,
+    0x00, 0x00, 0x56, 0x29, 0x00, 0x00, 0x56, 0x2e, 0x00, 0x00, 0x56, 0x34,
+    0x00, 0x00, 0x56, 0x3a, 0x00, 0x00, 0x56, 0x43, 0x00, 0x00, 0x56, 0x4a,
+    0x00, 0x00, 0x56, 0x52, 0x00, 0x00, 0x56, 0x55, 0x00, 0x00, 0x56, 0x5b,
+    0x00, 0x00, 0x56, 0x63, 0x00, 0x00, 0x56, 0x69, 0x00, 0x00, 0x56, 0x6d,
+    0x00, 0x00, 0x56, 0x76, 0x00, 0x00, 0x56, 0x7c, 0x00, 0x00, 0x56, 0x81,
+    0x00, 0x00, 0x56, 0x8b, 0x00, 0x00, 0x56, 0x90, 0x00, 0x00, 0x56, 0x99,
+    0x00, 0x00, 0x56, 0xa2, 0x00, 0x00, 0x56, 0xaa, 0x00, 0x00, 0x56, 0xb1,
+    0x00, 0x00, 0x56, 0xbb, 0x00, 0x00, 0x56, 0xc5, 0x00, 0x00, 0x56, 0xce,
+    0x00, 0x00, 0x56, 0xd7, 0x00, 0x00, 0x56, 0xdf, 0x00, 0x00, 0x56, 0xe5,
+    0x00, 0x00, 0x56, 0xeb, 0x00, 0x00, 0x56, 0xf3, 0x00, 0x00, 0x56, 0xfa,
+    0x00, 0x00, 0x57, 0x02, 0x00, 0x00, 0x57, 0x06, 0x00, 0x00, 0x57, 0x0d,
+    0x00, 0x00, 0x57, 0x15, 0x00, 0x00, 0x57, 0x1c, 0x00, 0x00, 0x57, 0x23,
+    0x00, 0x00, 0x57, 0x29, 0x00, 0x00, 0x57, 0x31, 0x00, 0x00, 0x57, 0x37,
+    0x00, 0x00, 0x57, 0x40, 0x00, 0x00, 0x57, 0x4a, 0x00, 0x00, 0x57, 0x54,
+    0x00, 0x00, 0x57, 0x5a, 0x00, 0x00, 0x57, 0x61, 0x00, 0x00, 0x57, 0x6a,
+    0x00, 0x00, 0x57, 0x72, 0x00, 0x00, 0x57, 0x76, 0x00, 0x00, 0x57, 0x7b,
+    0x00, 0x00, 0x57, 0x81, 0x00, 0x00, 0x57, 0x87, 0x00, 0x00, 0x57, 0x8d,
+    0x00, 0x00, 0x57, 0x93, 0x00, 0x00, 0x57, 0x9a, 0x00, 0x00, 0x57, 0xa1,
+    0x00, 0x00, 0x57, 0xa7, 0x00, 0x00, 0x57, 0xaf, 0x00, 0x00, 0x57, 0xb6,
+    0x00, 0x00, 0x57, 0xbe, 0x00, 0x00, 0x57, 0xc5, 0x00, 0x00, 0x57, 0xcc,
+    0x00, 0x00, 0x57, 0xd2, 0x00, 0x00, 0x57, 0xd8, 0x00, 0x00, 0x57, 0xdf,
+    0x00, 0x00, 0x57, 0xe7, 0x00, 0x00, 0x57, 0xee, 0x00, 0x00, 0x57, 0xf6,
+    0x00, 0x00, 0x57, 0xfc, 0x00, 0x00, 0x58, 0x03, 0x00, 0x00, 0x58, 0x0b,
+    0x00, 0x00, 0x58, 0x13, 0x00, 0x00, 0x58, 0x1b, 0x00, 0x00, 0x58, 0x21,
+    0x00, 0x00, 0x58, 0x28, 0x00, 0x00, 0x58, 0x2c, 0x00, 0x00, 0x58, 0x31,
+    0x00, 0x00, 0x58, 0x37, 0x00, 0x00, 0x58, 0x3d, 0x00, 0x00, 0x58, 0x44,
+    0x00, 0x00, 0x58, 0x4a, 0x00, 0x00, 0x58, 0x50, 0x00, 0x00, 0x58, 0x57,
+    0x00, 0x00, 0x58, 0x5e, 0x00, 0x00, 0x58, 0x66, 0x00, 0x00, 0x58, 0x6b,
+    0x00, 0x00, 0x58, 0x6f, 0x00, 0x00, 0x58, 0x75, 0x00, 0x00, 0x58, 0x7a,
+    0x00, 0x00, 0x58, 0x84, 0x00, 0x00, 0x58, 0x8d, 0x00, 0x00, 0x58, 0x95,
+    0x00, 0x00, 0x58, 0x9a, 0x00, 0x00, 0x58, 0xa1, 0x00, 0x00, 0x58, 0xa9,
+    0x00, 0x00, 0x58, 0xb3, 0x00, 0x00, 0x58, 0xbd, 0x00, 0x00, 0x58, 0xc7,
+    0x00, 0x00, 0x58, 0xd1, 0x00, 0x00, 0x58, 0xd9, 0x00, 0x00, 0x58, 0xe2,
+    0x00, 0x00, 0x58, 0xeb, 0x00, 0x00, 0x58, 0xf5, 0x00, 0x00, 0x58, 0xfd,
+    0x00, 0x00, 0x59, 0x05, 0x00, 0x00, 0x59, 0x0f, 0x00, 0x00, 0x59, 0x15,
+    0x00, 0x00, 0x59, 0x1c, 0x00, 0x00, 0x59, 0x23, 0x00, 0x00, 0x59, 0x29,
+    0x00, 0x00, 0x59, 0x30, 0x00, 0x00, 0x59, 0x37, 0x00, 0x00, 0x59, 0x3d,
+    0x00, 0x00, 0x59, 0x45, 0x00, 0x00, 0x59, 0x4b, 0x00, 0x00, 0x59, 0x50,
+    0x00, 0x00, 0x59, 0x59, 0x00, 0x00, 0x59, 0x63, 0x00, 0x00, 0x59, 0x6d,
+    0x00, 0x00, 0x59, 0x77, 0x00, 0x00, 0x59, 0x82, 0x00, 0x00, 0x59, 0x8d,
+    0x00, 0x00, 0x59, 0x97, 0x00, 0x00, 0x59, 0xa1, 0x00, 0x00, 0x59, 0xab,
+    0x00, 0x00, 0x59, 0xb3, 0x00, 0x00, 0x59, 0xb9, 0x00, 0x00, 0x59, 0xc1,
+    0x00, 0x00, 0x59, 0xca, 0x00, 0x00, 0x59, 0xd2, 0x00, 0x00, 0x59, 0xda,
+    0x00, 0x00, 0x59, 0xe1, 0x00, 0x00, 0x59, 0xec, 0x00, 0x00, 0x59, 0xf3,
+    0x00, 0x00, 0x59, 0xfa, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x5a, 0x09,
+    0x00, 0x00, 0x5a, 0x10, 0x00, 0x00, 0x5a, 0x18, 0x00, 0x00, 0x5a, 0x21,
+    0x00, 0x00, 0x5a, 0x2c, 0x00, 0x00, 0x5a, 0x37, 0x00, 0x00, 0x5a, 0x41,
+    0x00, 0x00, 0x5a, 0x47, 0x00, 0x00, 0x5a, 0x4e, 0x00, 0x00, 0x5a, 0x53,
+    0x00, 0x00, 0x5a, 0x59, 0x00, 0x00, 0x5a, 0x60, 0x00, 0x00, 0x5a, 0x67,
+    0x00, 0x00, 0x5a, 0x6e, 0x00, 0x00, 0x5a, 0x76, 0x00, 0x00, 0x5a, 0x80,
+    0x00, 0x00, 0x5a, 0x88, 0x00, 0x00, 0x5a, 0x91, 0x00, 0x00, 0x5a, 0x9a,
+    0x00, 0x00, 0x5a, 0xa2, 0x00, 0x00, 0x5a, 0xaa, 0x00, 0x00, 0x5a, 0xb3,
+    0x00, 0x00, 0x5a, 0xba, 0x00, 0x00, 0x5a, 0xc3, 0x00, 0x00, 0x5a, 0xcc,
+    0x00, 0x00, 0x5a, 0xd2, 0x00, 0x00, 0x5a, 0xd9, 0x00, 0x00, 0x5a, 0xe1,
+    0x00, 0x00, 0x5a, 0xea, 0x00, 0x00, 0x5a, 0xf3, 0x00, 0x00, 0x5a, 0xfc,
+    0x00, 0x00, 0x5b, 0x05, 0x00, 0x00, 0x5b, 0x0c, 0x00, 0x00, 0x5b, 0x14,
+    0x00, 0x00, 0x5b, 0x1c, 0x00, 0x00, 0x5b, 0x23, 0x00, 0x00, 0x5b, 0x2b,
+    0x00, 0x00, 0x5b, 0x34, 0x00, 0x00, 0x5b, 0x3a, 0x00, 0x00, 0x5b, 0x41,
+    0x00, 0x00, 0x5b, 0x49, 0x00, 0x00, 0x5b, 0x50, 0x00, 0x00, 0x5b, 0x56,
+    0x00, 0x00, 0x5b, 0x5d, 0x00, 0x00, 0x5b, 0x63, 0x00, 0x00, 0x5b, 0x6a,
+    0x00, 0x00, 0x5b, 0x73, 0x00, 0x00, 0x5b, 0x7b, 0x00, 0x00, 0x5b, 0x83,
+    0x00, 0x00, 0x5b, 0x8b, 0x00, 0x00, 0x5b, 0x92, 0x00, 0x00, 0x5b, 0x9a,
+    0x00, 0x00, 0x5b, 0xa2, 0x00, 0x00, 0x5b, 0xab, 0x00, 0x00, 0x5b, 0xb3,
+    0x00, 0x00, 0x5b, 0xb8, 0x00, 0x00, 0x5b, 0xc1, 0x00, 0x00, 0x5b, 0xc9,
+    0x00, 0x00, 0x5b, 0xd0, 0x00, 0x00, 0x5b, 0xd6, 0x00, 0x00, 0x5b, 0xde,
+    0x00, 0x00, 0x5b, 0xe6, 0x00, 0x00, 0x5b, 0xed, 0x00, 0x00, 0x5b, 0xf5,
+    0x00, 0x00, 0x5b, 0xfd, 0x00, 0x00, 0x5c, 0x04, 0x00, 0x00, 0x5c, 0x0c,
+    0x00, 0x00, 0x5c, 0x12, 0x00, 0x00, 0x5c, 0x19, 0x00, 0x00, 0x5c, 0x20,
+    0x00, 0x00, 0x5c, 0x27, 0x00, 0x00, 0x5c, 0x2d, 0x00, 0x00, 0x5c, 0x33,
+    0x00, 0x00, 0x5c, 0x3a, 0x00, 0x00, 0x5c, 0x45, 0x00, 0x00, 0x5c, 0x4f,
+    0x00, 0x00, 0x5c, 0x57, 0x00, 0x00, 0x5c, 0x60, 0x00, 0x00, 0x5c, 0x6a,
+    0x00, 0x00, 0x5c, 0x70, 0x00, 0x00, 0x5c, 0x77, 0x00, 0x00, 0x5c, 0x80,
+    0x00, 0x00, 0x5c, 0x86, 0x00, 0x00, 0x5c, 0x8c, 0x00, 0x00, 0x5c, 0x93,
+    0x00, 0x00, 0x5c, 0x99, 0x00, 0x00, 0x5c, 0xa0, 0x00, 0x00, 0x5c, 0xa8,
+    0x00, 0x00, 0x5c, 0xb0, 0x00, 0x00, 0x5c, 0xb6, 0x00, 0x00, 0x5c, 0xbc,
+    0x00, 0x00, 0x5c, 0xc3, 0x00, 0x00, 0x5c, 0xcc, 0x00, 0x00, 0x5c, 0xd3,
+    0x00, 0x00, 0x5c, 0xda, 0x00, 0x00, 0x5c, 0xdf, 0x00, 0x00, 0x5c, 0xe4,
+    0x00, 0x00, 0x5c, 0xea, 0x00, 0x00, 0x5c, 0xf4, 0x00, 0x00, 0x5c, 0xfb,
+    0x00, 0x00, 0x5d, 0x03, 0x00, 0x00, 0x5d, 0x0c, 0x00, 0x00, 0x5d, 0x15,
+    0x00, 0x00, 0x5d, 0x1f, 0x00, 0x00, 0x5d, 0x28, 0x00, 0x00, 0x5d, 0x32,
+    0x00, 0x00, 0x5d, 0x3b, 0x00, 0x00, 0x5d, 0x44, 0x00, 0x00, 0x5d, 0x4b,
+    0x00, 0x00, 0x5d, 0x54, 0x00, 0x00, 0x5d, 0x5c, 0x00, 0x00, 0x5d, 0x64,
+    0x00, 0x00, 0x5d, 0x6b, 0x00, 0x00, 0x5d, 0x73, 0x00, 0x00, 0x5d, 0x7e,
+    0x00, 0x00, 0x5d, 0x86, 0x00, 0x00, 0x5d, 0x8f, 0x00, 0x00, 0x5d, 0x98,
+    0x00, 0x00, 0x5d, 0x9f, 0x00, 0x00, 0x5d, 0xa5, 0x00, 0x00, 0x5d, 0xab,
+    0x00, 0x00, 0x5d, 0xb2, 0x00, 0x00, 0x5d, 0xbb, 0x00, 0x00, 0x5d, 0xc4,
+    0x00, 0x00, 0x5d, 0xcc, 0x00, 0x00, 0x5d, 0xd4, 0x00, 0x00, 0x5d, 0xd9,
+    0x00, 0x00, 0x5d, 0xe1, 0x00, 0x00, 0x5d, 0xe8, 0x00, 0x00, 0x5d, 0xed,
+    0x00, 0x00, 0x5d, 0xf3, 0x00, 0x00, 0x5d, 0xfa, 0x00, 0x00, 0x5e, 0x00,
+    0x00, 0x00, 0x5e, 0x08, 0x00, 0x00, 0x5e, 0x10, 0x00, 0x00, 0x5e, 0x19,
+    0x00, 0x00, 0x5e, 0x21, 0x00, 0x00, 0x5e, 0x29, 0x00, 0x00, 0x5e, 0x2f,
+    0x00, 0x00, 0x5e, 0x35, 0x00, 0x00, 0x5e, 0x39, 0x00, 0x00, 0x5e, 0x3f,
+    0x00, 0x00, 0x5e, 0x46, 0x00, 0x00, 0x5e, 0x4f, 0x00, 0x00, 0x5e, 0x56,
+    0x00, 0x00, 0x5e, 0x5d, 0x00, 0x00, 0x5e, 0x65, 0x00, 0x00, 0x5e, 0x69,
+    0x00, 0x00, 0x5e, 0x6e, 0x00, 0x00, 0x5e, 0x76, 0x00, 0x00, 0x5e, 0x7f,
+    0x00, 0x00, 0x5e, 0x84, 0x00, 0x00, 0x5e, 0x8a, 0x00, 0x00, 0x5e, 0x92,
+    0x00, 0x00, 0x5e, 0x99, 0x00, 0x00, 0x5e, 0x9f, 0x00, 0x00, 0x5e, 0xa5,
+    0x00, 0x00, 0x5e, 0xae, 0x00, 0x00, 0x5e, 0xb7, 0x00, 0x00, 0x5e, 0xbe,
+    0x00, 0x00, 0x5e, 0xc6, 0x00, 0x00, 0x5e, 0xcf, 0x00, 0x00, 0x5e, 0xd4,
+    0x00, 0x00, 0x5e, 0xd8, 0x00, 0x00, 0x5e, 0xdc, 0x00, 0x00, 0x5e, 0xe2,
+    0x00, 0x00, 0x5e, 0xe9, 0x00, 0x00, 0x5e, 0xf0, 0x00, 0x00, 0x5e, 0xf8,
+    0x00, 0x00, 0x5e, 0xfc, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x5f, 0x08,
+    0x00, 0x00, 0x5f, 0x0f, 0x00, 0x00, 0x5f, 0x17, 0x00, 0x00, 0x5f, 0x1f,
+    0x00, 0x00, 0x5f, 0x26, 0x00, 0x00, 0x5f, 0x2c, 0x00, 0x00, 0x5f, 0x32,
+    0x00, 0x00, 0x5f, 0x38, 0x00, 0x00, 0x5f, 0x3f, 0x00, 0x00, 0x5f, 0x46,
+    0x00, 0x00, 0x5f, 0x4e, 0x00, 0x00, 0x5f, 0x55, 0x00, 0x00, 0x5f, 0x5d,
+    0x00, 0x00, 0x5f, 0x66, 0x00, 0x00, 0x5f, 0x6d, 0x00, 0x00, 0x5f, 0x74,
+    0x00, 0x00, 0x5f, 0x7c, 0x00, 0x00, 0x5f, 0x85, 0x00, 0x00, 0x5f, 0x8d,
+    0x00, 0x00, 0x5f, 0x94, 0x00, 0x00, 0x5f, 0x9c, 0x00, 0x00, 0x5f, 0xa3,
+    0x00, 0x00, 0x5f, 0xab, 0x00, 0x00, 0x5f, 0xb2, 0x00, 0x00, 0x5f, 0xb8,
+    0x00, 0x00, 0x5f, 0xbf, 0x00, 0x00, 0x5f, 0xc7, 0x00, 0x00, 0x5f, 0xcf,
+    0x00, 0x00, 0x5f, 0xd5, 0x00, 0x00, 0x5f, 0xde, 0x00, 0x00, 0x5f, 0xe7,
+    0x00, 0x00, 0x5f, 0xed, 0x00, 0x00, 0x5f, 0xf6, 0x00, 0x00, 0x5f, 0xfb,
+    0x00, 0x00, 0x60, 0x04, 0x00, 0x00, 0x60, 0x0d, 0x00, 0x00, 0x60, 0x15,
+    0x00, 0x00, 0x60, 0x1d, 0x00, 0x00, 0x60, 0x23, 0x00, 0x00, 0x60, 0x2b,
+    0x00, 0x00, 0x60, 0x32, 0x00, 0x00, 0x60, 0x39, 0x00, 0x00, 0x60, 0x3f,
+    0x00, 0x00, 0x60, 0x45, 0x00, 0x00, 0x60, 0x4c, 0x00, 0x00, 0x60, 0x55,
+    0x00, 0x00, 0x60, 0x5d, 0x00, 0x00, 0x60, 0x63, 0x00, 0x00, 0x60, 0x6a,
+    0x00, 0x00, 0x60, 0x71, 0x00, 0x00, 0x60, 0x77, 0x00, 0x00, 0x60, 0x7c,
+    0x00, 0x00, 0x60, 0x7f, 0x00, 0x00, 0x60, 0x83, 0x00, 0x00, 0x60, 0x88,
+    0x00, 0x00, 0x60, 0x90, 0x00, 0x00, 0x60, 0x96, 0x00, 0x00, 0x60, 0x9c,
+    0x00, 0x00, 0x60, 0xa4, 0x00, 0x00, 0x60, 0xad, 0x00, 0x00, 0x60, 0xb6,
+    0x00, 0x00, 0x60, 0xbd, 0x00, 0x00, 0x60, 0xc5, 0x00, 0x00, 0x60, 0xcd,
+    0x00, 0x00, 0x60, 0xd4, 0x00, 0x00, 0x60, 0xdc, 0x00, 0x00, 0x60, 0xe6,
+    0x00, 0x00, 0x60, 0xf0, 0x00, 0x00, 0x60, 0xf8, 0x00, 0x00, 0x61, 0x01,
+    0x00, 0x00, 0x61, 0x09, 0x00, 0x00, 0x61, 0x10, 0x00, 0x00, 0x61, 0x16,
+    0x00, 0x00, 0x61, 0x1d, 0x00, 0x00, 0x61, 0x24, 0x00, 0x00, 0x61, 0x2d,
+    0x00, 0x00, 0x61, 0x34, 0x00, 0x00, 0x61, 0x3b, 0x00, 0x00, 0x61, 0x45,
+    0x00, 0x00, 0x61, 0x4a, 0x00, 0x00, 0x61, 0x52, 0x00, 0x00, 0x61, 0x57,
+    0x00, 0x00, 0x61, 0x5d, 0x00, 0x00, 0x61, 0x62, 0x00, 0x00, 0x61, 0x68,
+    0x00, 0x00, 0x61, 0x6d, 0x00, 0x00, 0x61, 0x75, 0x00, 0x00, 0x61, 0x7e,
+    0x00, 0x00, 0x61, 0x84, 0x00, 0x00, 0x61, 0x8a, 0x00, 0x00, 0x61, 0x92,
+    0x00, 0x00, 0x61, 0x98, 0x00, 0x00, 0x61, 0xa0, 0x00, 0x00, 0x61, 0xa8,
+    0x00, 0x00, 0x61, 0xb0, 0x00, 0x00, 0x61, 0xba, 0x00, 0x00, 0x61, 0xc1,
+    0x00, 0x00, 0x61, 0xc7, 0x00, 0x00, 0x61, 0xcc, 0x00, 0x00, 0x61, 0xd3,
+    0x00, 0x00, 0x61, 0xd8, 0x00, 0x00, 0x61, 0xdc, 0x00, 0x00, 0x61, 0xe1,
+    0x00, 0x00, 0x61, 0xe7, 0x00, 0x00, 0x61, 0xed, 0x00, 0x00, 0x61, 0xf3,
+    0x00, 0x00, 0x61, 0xfb, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x62, 0x05,
+    0x00, 0x00, 0x62, 0x0b, 0x00, 0x00, 0x62, 0x12, 0x00, 0x00, 0x62, 0x18,
+    0x00, 0x00, 0x62, 0x1f, 0x00, 0x00, 0x62, 0x24, 0x00, 0x00, 0x62, 0x2c,
+    0x00, 0x00, 0x62, 0x35, 0x00, 0x00, 0x62, 0x3d, 0x00, 0x00, 0x62, 0x44,
+    0x00, 0x00, 0x62, 0x4b, 0x00, 0x00, 0x62, 0x52, 0x00, 0x00, 0x62, 0x58,
+    0x00, 0x00, 0x62, 0x5e, 0x00, 0x00, 0x62, 0x65, 0x00, 0x00, 0x62, 0x6b,
+    0x00, 0x00, 0x62, 0x70, 0x00, 0x00, 0x62, 0x76, 0x00, 0x00, 0x62, 0x7c,
+    0x00, 0x00, 0x62, 0x83, 0x00, 0x00, 0x62, 0x89, 0x00, 0x00, 0x62, 0x8f,
+    0x00, 0x00, 0x62, 0x97, 0x00, 0x00, 0x62, 0xa0, 0x00, 0x00, 0x62, 0xa7,
+    0x00, 0x00, 0x62, 0xaf, 0x00, 0x00, 0x62, 0xb6, 0x00, 0x00, 0x62, 0xbc,
+    0x00, 0x00, 0x62, 0xc3, 0x00, 0x00, 0x62, 0xca, 0x00, 0x00, 0x62, 0xd2,
+    0x00, 0x00, 0x62, 0xda, 0x00, 0x00, 0x62, 0xe2, 0x00, 0x00, 0x62, 0xeb,
+    0x00, 0x00, 0x62, 0xf4, 0x00, 0x00, 0x62, 0xfa, 0x00, 0x00, 0x63, 0x01,
+    0x00, 0x00, 0x63, 0x08, 0x00, 0x00, 0x63, 0x0e, 0x00, 0x00, 0x63, 0x13,
+    0x00, 0x00, 0x63, 0x19, 0x00, 0x00, 0x63, 0x20, 0x00, 0x00, 0x63, 0x27,
+    0x00, 0x00, 0x63, 0x2f, 0x00, 0x00, 0x63, 0x36, 0x00, 0x00, 0x63, 0x3d,
+    0x00, 0x00, 0x63, 0x48, 0x00, 0x00, 0x63, 0x4e, 0x00, 0x00, 0x63, 0x54,
+    0x00, 0x00, 0x63, 0x59, 0x00, 0x00, 0x63, 0x5e, 0x00, 0x00, 0x63, 0x65,
+    0x00, 0x00, 0x63, 0x6c, 0x00, 0x00, 0x63, 0x73, 0x00, 0x00, 0x63, 0x7a,
+    0x00, 0x00, 0x63, 0x7f, 0x00, 0x00, 0x63, 0x85, 0x00, 0x00, 0x63, 0x8b,
+    0x00, 0x00, 0x63, 0x92, 0x00, 0x00, 0x63, 0x9a, 0x00, 0x00, 0x63, 0xa2,
+    0x00, 0x00, 0x63, 0xa6, 0x00, 0x00, 0x63, 0xab, 0x00, 0x00, 0x63, 0xb2,
+    0x00, 0x00, 0x63, 0xb9, 0x00, 0x00, 0x63, 0xbc, 0x00, 0x00, 0x63, 0xc3,
+    0x00, 0x00, 0x63, 0xc9, 0x00, 0x00, 0x63, 0xcf, 0x00, 0x00, 0x63, 0xd4,
+    0x00, 0x00, 0x63, 0xdb, 0x00, 0x00, 0x63, 0xe0, 0x00, 0x00, 0x63, 0xe6,
+    0x00, 0x00, 0x63, 0xec, 0x00, 0x00, 0x63, 0xf2, 0x00, 0x00, 0x63, 0xf8,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x07, 0x00, 0x00, 0x64, 0x0e,
+    0x00, 0x00, 0x64, 0x15, 0x00, 0x00, 0x64, 0x1b, 0x00, 0x00, 0x64, 0x1e,
+    0x00, 0x00, 0x64, 0x23, 0x00, 0x00, 0x64, 0x2a, 0x00, 0x00, 0x64, 0x30,
+    0x00, 0x00, 0x64, 0x37, 0x00, 0x00, 0x64, 0x3d, 0x00, 0x00, 0x64, 0x45,
+    0x00, 0x00, 0x64, 0x4b, 0x00, 0x00, 0x64, 0x53, 0x00, 0x00, 0x64, 0x5a,
+    0x00, 0x00, 0x64, 0x5e, 0x00, 0x00, 0x64, 0x62, 0x00, 0x00, 0x64, 0x67,
+    0x00, 0x00, 0x64, 0x6e, 0x00, 0x00, 0x64, 0x75, 0x00, 0x00, 0x64, 0x7b,
+    0x00, 0x00, 0x64, 0x82, 0x00, 0x00, 0x64, 0x88, 0x00, 0x00, 0x64, 0x90,
+    0x00, 0x00, 0x64, 0x99, 0x00, 0x00, 0x64, 0xa0, 0x00, 0x00, 0x64, 0xa6,
+    0x00, 0x00, 0x64, 0xac, 0x00, 0x00, 0x64, 0xb5, 0x00, 0x00, 0x64, 0xbd,
+    0x00, 0x00, 0x64, 0xc5, 0x00, 0x00, 0x64, 0xcd, 0x00, 0x00, 0x64, 0xd5,
+    0x00, 0x00, 0x64, 0xdd, 0x00, 0x00, 0x64, 0xe5, 0x00, 0x00, 0x64, 0xee,
+    0x00, 0x00, 0x64, 0xf7, 0x00, 0x00, 0x64, 0xfe, 0x00, 0x00, 0x65, 0x08,
+    0x00, 0x00, 0x65, 0x12, 0x00, 0x00, 0x65, 0x1c, 0x00, 0x00, 0x65, 0x24,
+    0x00, 0x00, 0x65, 0x2e, 0x00, 0x00, 0x65, 0x36, 0x00, 0x00, 0x65, 0x3b,
+    0x00, 0x00, 0x65, 0x42, 0x00, 0x00, 0x65, 0x46, 0x00, 0x00, 0x65, 0x4b,
+    0x00, 0x00, 0x65, 0x51, 0x00, 0x00, 0x65, 0x57, 0x00, 0x00, 0x65, 0x5d,
+    0x00, 0x00, 0x65, 0x62, 0x00, 0x00, 0x65, 0x68, 0x00, 0x00, 0x65, 0x6e,
+    0x00, 0x00, 0x65, 0x75, 0x00, 0x00, 0x65, 0x7a, 0x00, 0x00, 0x65, 0x80,
+    0x00, 0x00, 0x65, 0x86, 0x00, 0x00, 0x65, 0x8d, 0x00, 0x00, 0x65, 0x93,
+    0x00, 0x00, 0x65, 0x9a, 0x00, 0x00, 0x65, 0x9f, 0x00, 0x00, 0x65, 0xa6,
+    0x00, 0x00, 0x65, 0xac, 0x00, 0x00, 0x65, 0xb2, 0x00, 0x00, 0x65, 0xba,
+    0x00, 0x00, 0x65, 0xc2, 0x00, 0x00, 0x65, 0xc7, 0x00, 0x00, 0x65, 0xce,
+    0x00, 0x00, 0x65, 0xd3, 0x00, 0x00, 0x65, 0xda, 0x00, 0x00, 0x65, 0xdf,
+    0x00, 0x00, 0x65, 0xe6, 0x00, 0x00, 0x65, 0xee, 0x00, 0x00, 0x65, 0xf5,
+    0x00, 0x00, 0x65, 0xf9, 0x00, 0x00, 0x65, 0xfe, 0x00, 0x00, 0x66, 0x03,
+    0x00, 0x00, 0x66, 0x0a, 0x00, 0x00, 0x66, 0x0e, 0x00, 0x00, 0x66, 0x17,
+    0x00, 0x00, 0x66, 0x1e, 0x00, 0x00, 0x66, 0x27, 0x00, 0x00, 0x66, 0x2f,
+    0x00, 0x00, 0x66, 0x38, 0x00, 0x00, 0x66, 0x3d, 0x00, 0x00, 0x66, 0x43,
+    0x00, 0x00, 0x66, 0x4a, 0x00, 0x00, 0x66, 0x53, 0x00, 0x00, 0x66, 0x5b,
+    0x00, 0x00, 0x66, 0x61, 0x00, 0x00, 0x66, 0x67, 0x00, 0x00, 0x66, 0x6e,
+    0x00, 0x00, 0x66, 0x76, 0x00, 0x00, 0x66, 0x7f, 0x00, 0x00, 0x66, 0x86,
+    0x00, 0x00, 0x66, 0x90, 0x00, 0x00, 0x66, 0x98, 0x00, 0x00, 0x66, 0x9d,
+    0x00, 0x00, 0x66, 0xa3, 0x00, 0x00, 0x66, 0xaa, 0x00, 0x00, 0x66, 0xb1,
+    0x00, 0x00, 0x66, 0xb7, 0x00, 0x00, 0x66, 0xbc, 0x00, 0x00, 0x66, 0xc2,
+    0x00, 0x00, 0x66, 0xc9, 0x00, 0x00, 0x66, 0xcf, 0x00, 0x00, 0x66, 0xd6,
+    0x00, 0x00, 0x66, 0xdb, 0x00, 0x00, 0x66, 0xe1, 0x00, 0x00, 0x66, 0xe7,
+    0x00, 0x00, 0x66, 0xec, 0x00, 0x00, 0x66, 0xf2, 0x00, 0x00, 0x66, 0xf8,
+    0x00, 0x00, 0x66, 0xfd, 0x00, 0x00, 0x67, 0x02, 0x00, 0x00, 0x67, 0x08,
+    0x00, 0x00, 0x67, 0x0f, 0x00, 0x00, 0x67, 0x13, 0x00, 0x00, 0x67, 0x18,
+    0x00, 0x00, 0x67, 0x1f, 0x00, 0x00, 0x67, 0x26, 0x00, 0x00, 0x67, 0x2d,
+    0x00, 0x00, 0x67, 0x33, 0x00, 0x00, 0x67, 0x3a, 0x00, 0x00, 0x67, 0x3f,
+    0x00, 0x00, 0x67, 0x45, 0x00, 0x00, 0x67, 0x4a, 0x00, 0x00, 0x67, 0x4f,
+    0x00, 0x00, 0x67, 0x54, 0x00, 0x00, 0x67, 0x5a, 0x00, 0x00, 0x67, 0x62,
+    0x00, 0x00, 0x67, 0x6b, 0x00, 0x00, 0x67, 0x72, 0x00, 0x00, 0x67, 0x79,
+    0x00, 0x00, 0x67, 0x80, 0x00, 0x00, 0x67, 0x87, 0x00, 0x00, 0x67, 0x8d,
+    0x00, 0x00, 0x67, 0x94, 0x00, 0x00, 0x67, 0x9c, 0x00, 0x00, 0x67, 0xa3,
+    0x00, 0x00, 0x67, 0xa8, 0x00, 0x00, 0x67, 0xb0, 0x00, 0x00, 0x67, 0xb3,
+    0x00, 0x00, 0x67, 0xb9, 0x00, 0x00, 0x67, 0xc1, 0x00, 0x00, 0x67, 0xc7,
+    0x00, 0x00, 0x67, 0xcc, 0x00, 0x00, 0x67, 0xd4, 0x00, 0x00, 0x67, 0xd9,
+    0x00, 0x00, 0x67, 0xe1, 0x00, 0x00, 0x67, 0xe9, 0x00, 0x00, 0x67, 0xed,
+    0x00, 0x00, 0x67, 0xf4, 0x00, 0x00, 0x67, 0xfa, 0x00, 0x00, 0x68, 0x01,
+    0x00, 0x00, 0x68, 0x08, 0x00, 0x00, 0x68, 0x0f, 0x00, 0x00, 0x68, 0x14,
+    0x00, 0x00, 0x68, 0x1b, 0x00, 0x00, 0x68, 0x1e, 0x00, 0x00, 0x68, 0x22,
+    0x00, 0x00, 0x68, 0x27, 0x00, 0x00, 0x68, 0x2d, 0x00, 0x00, 0x68, 0x33,
+    0x00, 0x00, 0x68, 0x3a, 0x00, 0x00, 0x68, 0x3f, 0x00, 0x00, 0x68, 0x47,
+    0x00, 0x00, 0x68, 0x4c, 0x00, 0x00, 0x68, 0x53, 0x00, 0x00, 0x68, 0x59,
+    0x00, 0x00, 0x68, 0x5f, 0x00, 0x00, 0x68, 0x66, 0x00, 0x00, 0x68, 0x6d,
+    0x00, 0x00, 0x68, 0x73, 0x00, 0x00, 0x68, 0x7b, 0x00, 0x00, 0x68, 0x7f,
+    0x00, 0x00, 0x68, 0x84, 0x00, 0x00, 0x68, 0x8a, 0x00, 0x00, 0x68, 0x8f,
+    0x00, 0x00, 0x68, 0x93, 0x00, 0x00, 0x68, 0x9a, 0x00, 0x00, 0x68, 0x9f,
+    0x00, 0x00, 0x68, 0xa5, 0x00, 0x00, 0x68, 0xaa, 0x00, 0x00, 0x68, 0xb2,
+    0x00, 0x00, 0x68, 0xb6, 0x00, 0x00, 0x68, 0xbd, 0x00, 0x00, 0x68, 0xc4,
+    0x00, 0x00, 0x68, 0xc9, 0x00, 0x00, 0x68, 0xd0, 0x00, 0x00, 0x68, 0xd8,
+    0x00, 0x00, 0x68, 0xde, 0x00, 0x00, 0x68, 0xe4, 0x00, 0x00, 0x68, 0xec,
+    0x00, 0x00, 0x68, 0xf2, 0x00, 0x00, 0x68, 0xf8, 0x00, 0x00, 0x69, 0x00,
+    0x00, 0x00, 0x69, 0x08, 0x00, 0x00, 0x69, 0x0f, 0x00, 0x00, 0x69, 0x14,
+    0x00, 0x00, 0x69, 0x1b, 0x00, 0x00, 0x69, 0x20, 0x00, 0x00, 0x69, 0x25,
+    0x00, 0x00, 0x69, 0x2b, 0x00, 0x00, 0x69, 0x30, 0x00, 0x00, 0x69, 0x36,
+    0x00, 0x00, 0x69, 0x3d, 0x00, 0x00, 0x69, 0x42, 0x00, 0x00, 0x69, 0x45,
+    0x00, 0x00, 0x69, 0x4b, 0x00, 0x00, 0x69, 0x50, 0x00, 0x00, 0x69, 0x56,
+    0x00, 0x00, 0x69, 0x5c, 0x00, 0x00, 0x69, 0x63, 0x00, 0x00, 0x69, 0x6b,
+    0x00, 0x00, 0x69, 0x6f, 0x00, 0x00, 0x69, 0x76, 0x00, 0x00, 0x69, 0x7d,
+    0x00, 0x00, 0x69, 0x85, 0x00, 0x00, 0x69, 0x8d, 0x00, 0x00, 0x69, 0x94,
+    0x00, 0x00, 0x69, 0x9b, 0x00, 0x00, 0x69, 0xa3, 0x00, 0x00, 0x69, 0xa9,
+    0x00, 0x00, 0x69, 0xaf, 0x00, 0x00, 0x69, 0xb5, 0x00, 0x00, 0x69, 0xbc,
+    0x00, 0x00, 0x69, 0xc6, 0x00, 0x00, 0x69, 0xcf, 0x00, 0x00, 0x69, 0xd8,
+    0x00, 0x00, 0x69, 0xde, 0x00, 0x00, 0x69, 0xe2, 0x00, 0x00, 0x69, 0xeb,
+    0x00, 0x00, 0x69, 0xf2, 0x00, 0x00, 0x69, 0xfa, 0x00, 0x00, 0x6a, 0x02,
+    0x00, 0x00, 0x6a, 0x0b, 0x00, 0x00, 0x6a, 0x13, 0x00, 0x00, 0x6a, 0x1b,
+    0x00, 0x00, 0x6a, 0x21, 0x00, 0x00, 0x6a, 0x27, 0x00, 0x00, 0x6a, 0x2e,
+    0x00, 0x00, 0x6a, 0x34, 0x00, 0x00, 0x6a, 0x39, 0x00, 0x00, 0x6a, 0x3f,
+    0x00, 0x00, 0x6a, 0x47, 0x00, 0x00, 0x6a, 0x50, 0x00, 0x00, 0x6a, 0x59,
+    0x00, 0x00, 0x6a, 0x61, 0x00, 0x00, 0x6a, 0x69, 0x00, 0x00, 0x6a, 0x71,
+    0x00, 0x00, 0x6a, 0x75, 0x00, 0x00, 0x6a, 0x7b, 0x00, 0x00, 0x6a, 0x82,
+    0x00, 0x00, 0x6a, 0x8b, 0x00, 0x00, 0x6a, 0x93, 0x00, 0x00, 0x6a, 0x9c,
+    0x00, 0x00, 0x6a, 0xa3, 0x00, 0x00, 0x6a, 0xa9, 0x00, 0x00, 0x6a, 0xad,
+    0x00, 0x00, 0x6a, 0xb4, 0x00, 0x00, 0x6a, 0xba, 0x00, 0x00, 0x6a, 0xbe,
+    0x00, 0x00, 0x6a, 0xc7, 0x00, 0x00, 0x6a, 0xce, 0x00, 0x00, 0x6a, 0xd4,
+    0x00, 0x00, 0x6a, 0xdb, 0x00, 0x00, 0x6a, 0xe1, 0x00, 0x00, 0x6a, 0xe7,
+    0x00, 0x00, 0x6a, 0xed, 0x00, 0x00, 0x6a, 0xf3, 0x00, 0x00, 0x6a, 0xf8,
+    0x00, 0x00, 0x6a, 0xfe, 0x00, 0x00, 0x6b, 0x04, 0x00, 0x00, 0x6b, 0x0c,
+    0x00, 0x00, 0x6b, 0x16, 0x00, 0x00, 0x6b, 0x1c, 0x00, 0x00, 0x6b, 0x21,
+    0x00, 0x00, 0x6b, 0x28, 0x00, 0x00, 0x6b, 0x30, 0x00, 0x00, 0x6b, 0x38,
+    0x00, 0x00, 0x6b, 0x42, 0x00, 0x00, 0x6b, 0x49, 0x00, 0x00, 0x6b, 0x4f,
+    0x00, 0x00, 0x6b, 0x56, 0x00, 0x00, 0x6b, 0x5f, 0x00, 0x00, 0x6b, 0x66,
+    0x00, 0x00, 0x6b, 0x6e, 0x00, 0x00, 0x6b, 0x76, 0x00, 0x00, 0x6b, 0x7a,
+    0x00, 0x00, 0x6b, 0x81, 0x00, 0x00, 0x6b, 0x88, 0x00, 0x00, 0x6b, 0x8e,
+    0x00, 0x00, 0x6b, 0x93, 0x00, 0x00, 0x6b, 0x9a, 0x00, 0x00, 0x6b, 0xa0,
+    0x00, 0x00, 0x6b, 0xa4, 0x00, 0x00, 0x6b, 0xaa, 0x00, 0x00, 0x6b, 0xb3,
+    0x00, 0x00, 0x6b, 0xbb, 0x00, 0x00, 0x6b, 0xc2, 0x00, 0x00, 0x6b, 0xc9,
+    0x00, 0x00, 0x6b, 0xd0, 0x00, 0x00, 0x6b, 0xd9, 0x00, 0x00, 0x6b, 0xe1,
+    0x00, 0x00, 0x6b, 0xea, 0x00, 0x00, 0x6b, 0xf1, 0x00, 0x00, 0x6b, 0xfa,
+    0x00, 0x00, 0x6c, 0x03, 0x00, 0x00, 0x6c, 0x0d, 0x00, 0x00, 0x6c, 0x19,
+    0x00, 0x00, 0x6c, 0x22, 0x00, 0x00, 0x6c, 0x27, 0x00, 0x00, 0x6c, 0x2d,
+    0x00, 0x00, 0x6c, 0x33, 0x00, 0x00, 0x6c, 0x3b, 0x00, 0x00, 0x6c, 0x43,
+    0x00, 0x00, 0x6c, 0x4a, 0x00, 0x00, 0x6c, 0x51, 0x00, 0x00, 0x6c, 0x57,
+    0x00, 0x00, 0x6c, 0x5f, 0x00, 0x00, 0x6c, 0x67, 0x00, 0x00, 0x6c, 0x6d,
+    0x00, 0x00, 0x6c, 0x75, 0x00, 0x00, 0x6c, 0x7c, 0x00, 0x00, 0x6c, 0x84,
+    0x00, 0x00, 0x6c, 0x8b, 0x00, 0x00, 0x6c, 0x93, 0x00, 0x00, 0x6c, 0x9b,
+    0x00, 0x00, 0x6c, 0xa4, 0x00, 0x00, 0x6c, 0xac, 0x00, 0x00, 0x6c, 0xb0,
+    0x00, 0x00, 0x6c, 0xb7, 0x00, 0x00, 0x6c, 0xbf, 0x00, 0x00, 0x6c, 0xc6,
+    0x00, 0x00, 0x6c, 0xce, 0x00, 0x00, 0x6c, 0xd5, 0x00, 0x00, 0x6c, 0xdb,
+    0x00, 0x00, 0x6c, 0xe1, 0x00, 0x00, 0x6c, 0xe9, 0x00, 0x00, 0x6c, 0xef,
+    0x00, 0x00, 0x6c, 0xf6, 0x00, 0x00, 0x6c, 0xfc, 0x00, 0x00, 0x6d, 0x03,
+    0x00, 0x00, 0x6d, 0x0c, 0x00, 0x00, 0x6d, 0x11, 0x00, 0x00, 0x6d, 0x17,
+    0x00, 0x00, 0x6d, 0x1d, 0x00, 0x00, 0x6d, 0x24, 0x00, 0x00, 0x6d, 0x2c,
+    0x00, 0x00, 0x6d, 0x33, 0x00, 0x00, 0x6d, 0x3b, 0x00, 0x00, 0x6d, 0x41,
+    0x00, 0x00, 0x6d, 0x4a, 0x00, 0x00, 0x6d, 0x50, 0x00, 0x00, 0x6d, 0x56,
+    0x00, 0x00, 0x6d, 0x5e, 0x00, 0x00, 0x6d, 0x65, 0x00, 0x00, 0x6d, 0x6c,
+    0x00, 0x00, 0x6d, 0x75, 0x00, 0x00, 0x6d, 0x7d, 0x00, 0x00, 0x6d, 0x82,
+    0x00, 0x00, 0x6d, 0x88, 0x00, 0x00, 0x6d, 0x8c, 0x00, 0x00, 0x6d, 0x91,
+    0x00, 0x00, 0x6d, 0x99, 0x00, 0x00, 0x6d, 0xa1, 0x00, 0x00, 0x6d, 0xa8,
+    0x00, 0x00, 0x6d, 0xb0, 0x00, 0x00, 0x6d, 0xb9, 0x00, 0x00, 0x6d, 0xc2,
+    0x00, 0x00, 0x6d, 0xc8, 0x00, 0x00, 0x6d, 0xcc, 0x00, 0x00, 0x6d, 0xd3,
+    0x00, 0x00, 0x6d, 0xda, 0x00, 0x00, 0x6d, 0xe1, 0x00, 0x00, 0x6d, 0xe6,
+    0x00, 0x00, 0x6d, 0xee, 0x00, 0x00, 0x6d, 0xf7, 0x00, 0x00, 0x6d, 0xfe,
+    0x00, 0x00, 0x6e, 0x06, 0x00, 0x00, 0x6e, 0x0e, 0x00, 0x00, 0x6e, 0x16,
+    0x00, 0x00, 0x6e, 0x1b, 0x00, 0x00, 0x6e, 0x20, 0x00, 0x00, 0x6e, 0x26,
+    0x00, 0x00, 0x6e, 0x2e, 0x00, 0x00, 0x6e, 0x36, 0x00, 0x00, 0x6e, 0x3c,
+    0x00, 0x00, 0x6e, 0x43, 0x00, 0x00, 0x6e, 0x4b, 0x00, 0x00, 0x6e, 0x52,
+    0x00, 0x00, 0x6e, 0x59, 0x00, 0x00, 0x6e, 0x62, 0x00, 0x00, 0x6e, 0x69,
+    0x00, 0x00, 0x6e, 0x71, 0x00, 0x00, 0x6e, 0x76, 0x00, 0x00, 0x6e, 0x7c,
+    0x00, 0x00, 0x6e, 0x82, 0x00, 0x00, 0x6e, 0x8b, 0x00, 0x00, 0x6e, 0x91,
+    0x00, 0x00, 0x6e, 0x96, 0x00, 0x00, 0x6e, 0x9f, 0x00, 0x00, 0x6e, 0xa6,
+    0x00, 0x00, 0x6e, 0xab, 0x00, 0x00, 0x6e, 0xb1, 0x00, 0x00, 0x6e, 0xb9,
+    0x00, 0x00, 0x6e, 0xc0, 0x00, 0x00, 0x6e, 0xc7, 0x00, 0x00, 0x6e, 0xce,
+    0x00, 0x00, 0x6e, 0xd4, 0x00, 0x00, 0x6e, 0xda, 0x00, 0x00, 0x6e, 0xdf,
+    0x00, 0x00, 0x6e, 0xe5, 0x00, 0x00, 0x6e, 0xeb, 0x00, 0x00, 0x6e, 0xf3,
+    0x00, 0x00, 0x6e, 0xfa, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x6f, 0x07,
+    0x00, 0x00, 0x6f, 0x0c, 0x00, 0x00, 0x6f, 0x12, 0x00, 0x00, 0x6f, 0x18,
+    0x00, 0x00, 0x6f, 0x1f, 0x00, 0x00, 0x6f, 0x24, 0x00, 0x00, 0x6f, 0x28,
+    0x00, 0x00, 0x6f, 0x2c, 0x00, 0x00, 0x6f, 0x32, 0x00, 0x00, 0x6f, 0x38,
+    0x00, 0x00, 0x6f, 0x41, 0x00, 0x00, 0x6f, 0x4a, 0x00, 0x00, 0x6f, 0x4f,
+    0x00, 0x00, 0x6f, 0x55, 0x00, 0x00, 0x6f, 0x5b, 0x00, 0x00, 0x6f, 0x64,
+    0x00, 0x00, 0x6f, 0x6a, 0x00, 0x00, 0x6f, 0x70, 0x00, 0x00, 0x6f, 0x77,
+    0x00, 0x00, 0x6f, 0x7b, 0x00, 0x00, 0x6f, 0x83, 0x00, 0x00, 0x6f, 0x8b,
+    0x00, 0x00, 0x6f, 0x90, 0x00, 0x00, 0x6f, 0x98, 0x00, 0x00, 0x6f, 0xa1,
+    0x00, 0x00, 0x6f, 0xa8, 0x00, 0x00, 0x6f, 0xad, 0x00, 0x00, 0x6f, 0xb4,
+    0x00, 0x00, 0x6f, 0xba, 0x00, 0x00, 0x6f, 0xc1, 0x00, 0x00, 0x6f, 0xc7,
+    0x00, 0x00, 0x6f, 0xcc, 0x00, 0x00, 0x6f, 0xd6, 0x00, 0x00, 0x6f, 0xdc,
+    0x00, 0x00, 0x6f, 0xe2, 0x00, 0x00, 0x6f, 0xe7, 0x00, 0x00, 0x6f, 0xec,
+    0x00, 0x00, 0x6f, 0xf1, 0x00, 0x00, 0x6f, 0xf6, 0x00, 0x00, 0x6f, 0xfb,
+    0x00, 0x00, 0x70, 0x01, 0x00, 0x00, 0x70, 0x05, 0x00, 0x00, 0x70, 0x0b,
+    0x00, 0x00, 0x70, 0x12, 0x00, 0x00, 0x70, 0x19, 0x00, 0x00, 0x70, 0x1f,
+    0x00, 0x00, 0x70, 0x26, 0x00, 0x00, 0x70, 0x2d, 0x00, 0x00, 0x70, 0x34,
+    0x00, 0x00, 0x70, 0x3c, 0x00, 0x00, 0x70, 0x44, 0x00, 0x00, 0x70, 0x4a,
+    0x00, 0x00, 0x70, 0x4f, 0x00, 0x00, 0x70, 0x55, 0x00, 0x00, 0x70, 0x5b,
+    0x00, 0x00, 0x70, 0x62, 0x00, 0x00, 0x70, 0x6a, 0x00, 0x00, 0x70, 0x73,
+    0x00, 0x00, 0x70, 0x79, 0x00, 0x00, 0x70, 0x7f, 0x00, 0x00, 0x70, 0x83,
+    0x00, 0x00, 0x70, 0x8c, 0x00, 0x00, 0x70, 0x93, 0x00, 0x00, 0x70, 0x9a,
+    0x00, 0x00, 0x70, 0xa2, 0x00, 0x00, 0x70, 0xaa, 0x00, 0x00, 0x70, 0xb2,
+    0x00, 0x00, 0x70, 0xba, 0x00, 0x00, 0x70, 0xc0, 0x00, 0x00, 0x70, 0xc7,
+    0x00, 0x00, 0x70, 0xcf, 0x00, 0x00, 0x70, 0xd7, 0x00, 0x00, 0x70, 0xdf,
+    0x00, 0x00, 0x70, 0xe4, 0x00, 0x00, 0x70, 0xec, 0x00, 0x00, 0x70, 0xf1,
+    0x00, 0x00, 0x70, 0xf9, 0x00, 0x00, 0x70, 0xff, 0x00, 0x00, 0x71, 0x06,
+    0x00, 0x00, 0x71, 0x0e, 0x00, 0x00, 0x71, 0x14, 0x00, 0x00, 0x71, 0x1b,
+    0x00, 0x00, 0x71, 0x1f, 0x00, 0x00, 0x71, 0x24, 0x00, 0x00, 0x71, 0x2b,
+    0x00, 0x00, 0x71, 0x31, 0x00, 0x00, 0x71, 0x36, 0x00, 0x00, 0x71, 0x3c,
+    0x00, 0x00, 0x71, 0x42, 0x00, 0x00, 0x71, 0x49, 0x00, 0x00, 0x71, 0x4f,
+    0x00, 0x00, 0x71, 0x59, 0x00, 0x00, 0x71, 0x5e, 0x00, 0x00, 0x71, 0x63,
+    0x00, 0x00, 0x71, 0x6b, 0x00, 0x00, 0x71, 0x73, 0x00, 0x00, 0x71, 0x7b,
+    0x00, 0x00, 0x71, 0x83, 0x00, 0x00, 0x71, 0x8c, 0x00, 0x00, 0x71, 0x95,
+    0x00, 0x00, 0x71, 0x9f, 0x00, 0x00, 0x71, 0xa8, 0x00, 0x00, 0x71, 0xb0,
+    0x00, 0x00, 0x71, 0xb8, 0x00, 0x00, 0x71, 0xc2, 0x00, 0x00, 0x71, 0xcb,
+    0x00, 0x00, 0x71, 0xd2, 0x00, 0x00, 0x71, 0xd9, 0x00, 0x00, 0x71, 0xe1,
+    0x00, 0x00, 0x71, 0xe9, 0x00, 0x00, 0x71, 0xf1, 0x00, 0x00, 0x71, 0xf9,
+    0x00, 0x00, 0x72, 0x01, 0x00, 0x00, 0x72, 0x08, 0x00, 0x00, 0x72, 0x0d,
+    0x00, 0x00, 0x72, 0x15, 0x00, 0x00, 0x72, 0x1e, 0x00, 0x00, 0x72, 0x27,
+    0x00, 0x00, 0x72, 0x2f, 0x00, 0x00, 0x72, 0x37, 0x00, 0x00, 0x72, 0x40,
+    0x00, 0x00, 0x72, 0x48, 0x00, 0x00, 0x72, 0x50, 0x00, 0x00, 0x72, 0x58,
+    0x00, 0x00, 0x72, 0x62, 0x00, 0x00, 0x72, 0x6b, 0x00, 0x00, 0x72, 0x72,
+    0x00, 0x00, 0x72, 0x7a, 0x00, 0x00, 0x72, 0x82, 0x00, 0x00, 0x72, 0x8a,
+    0x00, 0x00, 0x72, 0x92, 0x00, 0x00, 0x72, 0x98, 0x00, 0x00, 0x72, 0x9e,
+    0x00, 0x00, 0x72, 0xa5, 0x00, 0x00, 0x72, 0xab, 0x00, 0x00, 0x72, 0xb2,
+    0x00, 0x00, 0x72, 0xb9, 0x00, 0x00, 0x72, 0xbe, 0x00, 0x00, 0x72, 0xc6,
+    0x00, 0x00, 0x72, 0xcd, 0x00, 0x00, 0x72, 0xd2, 0x00, 0x00, 0x72, 0xd9,
+    0x00, 0x00, 0x72, 0xe0, 0x00, 0x00, 0x72, 0xe7, 0x00, 0x00, 0x72, 0xee,
+    0x00, 0x00, 0x72, 0xf6, 0x00, 0x00, 0x72, 0xfe, 0x00, 0x00, 0x73, 0x04,
+    0x00, 0x00, 0x73, 0x09, 0x00, 0x00, 0x73, 0x0d, 0x00, 0x00, 0x73, 0x13,
+    0x00, 0x00, 0x73, 0x19, 0x00, 0x00, 0x73, 0x21, 0x00, 0x00, 0x73, 0x29,
+    0x00, 0x00, 0x73, 0x2f, 0x00, 0x00, 0x73, 0x34, 0x00, 0x00, 0x73, 0x3a,
+    0x00, 0x00, 0x73, 0x40, 0x00, 0x00, 0x73, 0x45, 0x00, 0x00, 0x73, 0x4b,
+    0x00, 0x00, 0x73, 0x52, 0x00, 0x00, 0x73, 0x5a, 0x00, 0x00, 0x73, 0x5f,
+    0x00, 0x00, 0x73, 0x66, 0x00, 0x00, 0x73, 0x6d, 0x00, 0x00, 0x73, 0x73,
+    0x00, 0x00, 0x73, 0x7a, 0x00, 0x00, 0x73, 0x7f, 0x00, 0x00, 0x73, 0x86,
+    0x00, 0x00, 0x73, 0x8e, 0x00, 0x00, 0x73, 0x94, 0x00, 0x00, 0x73, 0x99,
+    0x00, 0x00, 0x73, 0x9f, 0x00, 0x00, 0x73, 0xa7, 0x00, 0x00, 0x73, 0xb0,
+    0x00, 0x00, 0x73, 0xb6, 0x00, 0x00, 0x73, 0xbd, 0x00, 0x00, 0x73, 0xc2,
+    0x00, 0x00, 0x73, 0xc8, 0x00, 0x00, 0x73, 0xcf, 0x00, 0x00, 0x73, 0xd6,
+    0x00, 0x00, 0x73, 0xdc, 0x00, 0x00, 0x73, 0xe4, 0x00, 0x00, 0x73, 0xea,
+    0x00, 0x00, 0x73, 0xf2, 0x00, 0x00, 0x73, 0xf7, 0x00, 0x00, 0x73, 0xfd,
+    0x00, 0x00, 0x74, 0x03, 0x00, 0x00, 0x74, 0x08, 0x00, 0x00, 0x74, 0x0c,
+    0x00, 0x00, 0x74, 0x13, 0x00, 0x00, 0x74, 0x1a, 0x00, 0x00, 0x74, 0x21,
+    0x00, 0x00, 0x74, 0x28, 0x00, 0x00, 0x74, 0x2e, 0x00, 0x00, 0x74, 0x35,
+    0x00, 0x00, 0x74, 0x3e, 0x00, 0x00, 0x74, 0x48, 0x00, 0x00, 0x74, 0x4c,
+    0x00, 0x00, 0x74, 0x55, 0x00, 0x00, 0x74, 0x5c, 0x00, 0x00, 0x74, 0x64,
+    0x00, 0x00, 0x74, 0x6c, 0x00, 0x00, 0x74, 0x73, 0x00, 0x00, 0x74, 0x7a,
+    0x00, 0x00, 0x74, 0x80, 0x00, 0x00, 0x74, 0x87, 0x00, 0x00, 0x74, 0x8e,
+    0x00, 0x00, 0x74, 0x93, 0x00, 0x00, 0x74, 0x99, 0x00, 0x00, 0x74, 0xa0,
+    0x00, 0x00, 0x74, 0xa6, 0x00, 0x00, 0x74, 0xad, 0x00, 0x00, 0x74, 0xb4,
+    0x00, 0x00, 0x74, 0xba, 0x00, 0x00, 0x74, 0xc2, 0x00, 0x00, 0x74, 0xc7,
+    0x00, 0x00, 0x74, 0xd0, 0x00, 0x00, 0x74, 0xdb, 0x00, 0x00, 0x74, 0xe2,
+    0x00, 0x00, 0x74, 0xe8, 0x00, 0x00, 0x74, 0xf0, 0x00, 0x00, 0x74, 0xf9,
+    0x00, 0x00, 0x75, 0x01, 0x00, 0x00, 0x75, 0x07, 0x00, 0x00, 0x75, 0x0e,
+    0x00, 0x00, 0x75, 0x13, 0x00, 0x00, 0x75, 0x19, 0x00, 0x00, 0x75, 0x1f,
+    0x00, 0x00, 0x75, 0x25, 0x00, 0x00, 0x75, 0x2a, 0x00, 0x00, 0x75, 0x31,
+    0x00, 0x00, 0x75, 0x38, 0x00, 0x00, 0x75, 0x3e, 0x00, 0x00, 0x75, 0x48,
+    0x00, 0x00, 0x75, 0x4c, 0x00, 0x00, 0x75, 0x51, 0x00, 0x00, 0x75, 0x59,
+    0x00, 0x00, 0x75, 0x61, 0x00, 0x00, 0x75, 0x6a, 0x00, 0x00, 0x75, 0x72,
+    0x00, 0x00, 0x75, 0x7b, 0x00, 0x00, 0x75, 0x80, 0x00, 0x00, 0x75, 0x86,
+    0x00, 0x00, 0x75, 0x8e, 0x00, 0x00, 0x75, 0x95, 0x00, 0x00, 0x75, 0x9a,
+    0x00, 0x00, 0x75, 0xa1, 0x00, 0x00, 0x75, 0xab, 0x00, 0x00, 0x75, 0xb3,
+    0x00, 0x00, 0x75, 0xb7, 0x00, 0x00, 0x75, 0xbd, 0x00, 0x00, 0x75, 0xc4,
+    0x00, 0x00, 0x75, 0xcb, 0x00, 0x00, 0x75, 0xd2, 0x00, 0x00, 0x75, 0xd8,
+    0x00, 0x00, 0x75, 0xdd, 0x00, 0x00, 0x75, 0xe5, 0x00, 0x00, 0x75, 0xef,
+    0x00, 0x00, 0x75, 0xf8, 0x00, 0x00, 0x75, 0xff, 0x00, 0x00, 0x76, 0x06,
+    0x00, 0x00, 0x76, 0x0d, 0x00, 0x00, 0x76, 0x14, 0x00, 0x00, 0x76, 0x19,
+    0x00, 0x00, 0x76, 0x21, 0x00, 0x00, 0x76, 0x29, 0x00, 0x00, 0x76, 0x2d,
+    0x00, 0x00, 0x76, 0x32, 0x00, 0x00, 0x76, 0x37, 0x00, 0x00, 0x76, 0x3e,
+    0x00, 0x00, 0x76, 0x45, 0x00, 0x00, 0x76, 0x4d, 0x00, 0x00, 0x76, 0x55,
+    0x00, 0x00, 0x76, 0x5b, 0x00, 0x00, 0x76, 0x64, 0x00, 0x00, 0x76, 0x6b,
+    0x00, 0x00, 0x76, 0x74, 0x00, 0x00, 0x76, 0x7c, 0x00, 0x00, 0x76, 0x84,
+    0x00, 0x00, 0x76, 0x89, 0x00, 0x00, 0x76, 0x8f, 0x00, 0x00, 0x76, 0x96,
+    0x00, 0x00, 0x76, 0x9d, 0x00, 0x00, 0x76, 0xa4, 0x00, 0x00, 0x76, 0xac,
+    0x00, 0x00, 0x76, 0xb2, 0x00, 0x00, 0x76, 0xba, 0x00, 0x00, 0x76, 0xc1,
+    0x00, 0x00, 0x76, 0xc9, 0x00, 0x00, 0x76, 0xd2, 0x00, 0x00, 0x76, 0xd8,
+    0x00, 0x00, 0x76, 0xe0, 0x00, 0x00, 0x76, 0xe8, 0x00, 0x00, 0x76, 0xf1,
+    0x00, 0x00, 0x76, 0xf9, 0x00, 0x00, 0x77, 0x00, 0x00, 0x00, 0x77, 0x08,
+    0x00, 0x00, 0x77, 0x10, 0x00, 0x00, 0x77, 0x17, 0x00, 0x00, 0x77, 0x1e,
+    0x00, 0x00, 0x77, 0x26, 0x00, 0x00, 0x77, 0x2e, 0x00, 0x00, 0x77, 0x35,
+    0x00, 0x00, 0x77, 0x3d, 0x00, 0x00, 0x77, 0x46, 0x00, 0x00, 0x77, 0x50,
+    0x00, 0x00, 0x77, 0x57, 0x00, 0x00, 0x77, 0x60, 0x00, 0x00, 0x77, 0x69,
+    0x00, 0x00, 0x77, 0x6f, 0x00, 0x00, 0x77, 0x76, 0x00, 0x00, 0x77, 0x7d,
+    0x00, 0x00, 0x77, 0x84, 0x00, 0x00, 0x77, 0x8c, 0x00, 0x00, 0x77, 0x93,
+    0x00, 0x00, 0x77, 0x99, 0x00, 0x00, 0x77, 0xa1, 0x00, 0x00, 0x77, 0xa8,
+    0x00, 0x00, 0x77, 0xb0, 0x00, 0x00, 0x77, 0xb9, 0x00, 0x00, 0x77, 0xc1,
+    0x00, 0x00, 0x77, 0xc8, 0x00, 0x00, 0x77, 0xd1, 0x00, 0x00, 0x77, 0xda,
+    0x00, 0x00, 0x77, 0xe4, 0x00, 0x00, 0x77, 0xed, 0x00, 0x00, 0x77, 0xf4,
+    0x00, 0x00, 0x77, 0xfd, 0x00, 0x00, 0x78, 0x04, 0x00, 0x00, 0x78, 0x0c,
+    0x00, 0x00, 0x78, 0x13, 0x00, 0x00, 0x78, 0x1a, 0x00, 0x00, 0x78, 0x21,
+    0x00, 0x00, 0x78, 0x27, 0x00, 0x00, 0x78, 0x2e, 0x00, 0x00, 0x78, 0x36,
+    0x00, 0x00, 0x78, 0x3e, 0x00, 0x00, 0x78, 0x46, 0x00, 0x00, 0x78, 0x4e,
+    0x00, 0x00, 0x78, 0x55, 0x00, 0x00, 0x78, 0x5e, 0x00, 0x00, 0x78, 0x67,
+    0x00, 0x00, 0x78, 0x6f, 0x00, 0x00, 0x78, 0x78, 0x00, 0x00, 0x78, 0x81,
+    0x00, 0x00, 0x78, 0x87, 0x00, 0x00, 0x78, 0x8e, 0x00, 0x00, 0x78, 0x96,
+    0x00, 0x00, 0x78, 0x9e, 0x00, 0x00, 0x78, 0xa6, 0x00, 0x00, 0x78, 0xae,
+    0x00, 0x00, 0x78, 0xb3, 0x00, 0x00, 0x78, 0xba, 0x00, 0x00, 0x78, 0xc1,
+    0x00, 0x00, 0x78, 0xc8, 0x00, 0x00, 0x78, 0xcd, 0x00, 0x00, 0x78, 0xd3,
+    0x00, 0x00, 0x78, 0xda, 0x00, 0x00, 0x78, 0xe1, 0x00, 0x00, 0x78, 0xe9,
+    0x00, 0x00, 0x78, 0xef, 0x00, 0x00, 0x78, 0xf6, 0x00, 0x00, 0x78, 0xfd,
+    0x00, 0x00, 0x79, 0x05, 0x00, 0x00, 0x79, 0x0c, 0x00, 0x00, 0x79, 0x13,
+    0x00, 0x00, 0x79, 0x1b, 0x00, 0x00, 0x79, 0x22, 0x00, 0x00, 0x79, 0x2a,
+    0x00, 0x00, 0x79, 0x31, 0x00, 0x00, 0x79, 0x39, 0x00, 0x00, 0x79, 0x41,
+    0x00, 0x00, 0x79, 0x49, 0x00, 0x00, 0x79, 0x4f, 0x00, 0x00, 0x79, 0x57,
+    0x00, 0x00, 0x79, 0x5f, 0x00, 0x00, 0x79, 0x66, 0x00, 0x00, 0x79, 0x6c,
+    0x00, 0x00, 0x79, 0x73, 0x00, 0x00, 0x79, 0x7b, 0x00, 0x00, 0x79, 0x81,
+    0x00, 0x00, 0x79, 0x89, 0x00, 0x00, 0x79, 0x92, 0x00, 0x00, 0x79, 0x99,
+    0x00, 0x00, 0x79, 0xa1, 0x00, 0x00, 0x79, 0xa9, 0x00, 0x00, 0x79, 0xb2,
+    0x00, 0x00, 0x79, 0xba, 0x00, 0x00, 0x79, 0xc2, 0x00, 0x00, 0x79, 0xcb,
+    0x00, 0x00, 0x79, 0xd3, 0x00, 0x00, 0x79, 0xda, 0x00, 0x00, 0x79, 0xe2,
+    0x00, 0x00, 0x79, 0xea, 0x00, 0x00, 0x79, 0xf1, 0x00, 0x00, 0x79, 0xfa,
+    0x00, 0x00, 0x7a, 0x01, 0x00, 0x00, 0x7a, 0x09, 0x00, 0x00, 0x7a, 0x11,
+    0x00, 0x00, 0x7a, 0x1a, 0x00, 0x00, 0x7a, 0x22, 0x00, 0x00, 0x7a, 0x29,
+    0x00, 0x00, 0x7a, 0x31, 0x00, 0x00, 0x7a, 0x3a, 0x00, 0x00, 0x7a, 0x40,
+    0x00, 0x00, 0x7a, 0x47, 0x00, 0x00, 0x7a, 0x4f, 0x00, 0x00, 0x7a, 0x56,
+    0x00, 0x00, 0x7a, 0x5c, 0x00, 0x00, 0x7a, 0x63, 0x00, 0x00, 0x7a, 0x68,
+    0x00, 0x00, 0x7a, 0x6e, 0x00, 0x00, 0x7a, 0x76, 0x00, 0x00, 0x7a, 0x7c,
+    0x00, 0x00, 0x7a, 0x84, 0x00, 0x00, 0x7a, 0x8d, 0x00, 0x00, 0x7a, 0x96,
+    0x00, 0x00, 0x7a, 0x9e, 0x00, 0x00, 0x7a, 0xa5, 0x00, 0x00, 0x7a, 0xac,
+    0x00, 0x00, 0x7a, 0xb4, 0x00, 0x00, 0x7a, 0xb9, 0x00, 0x00, 0x7a, 0xbf,
+    0x00, 0x00, 0x7a, 0xc6, 0x00, 0x00, 0x7a, 0xce, 0x00, 0x00, 0x7a, 0xd5,
+    0x00, 0x00, 0x7a, 0xdc, 0x00, 0x00, 0x7a, 0xe5, 0x00, 0x00, 0x7a, 0xe9,
+    0x00, 0x00, 0x7a, 0xef, 0x00, 0x00, 0x7a, 0xf5, 0x00, 0x00, 0x7a, 0xf9,
+    0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x7b, 0x07, 0x00, 0x00, 0x7b, 0x0d,
+    0x00, 0x00, 0x7b, 0x14, 0x00, 0x00, 0x7b, 0x1a, 0x00, 0x00, 0x7b, 0x20,
+    0x00, 0x00, 0x7b, 0x28, 0x00, 0x00, 0x7b, 0x2f, 0x00, 0x00, 0x7b, 0x34,
+    0x00, 0x00, 0x7b, 0x3a, 0x00, 0x00, 0x7b, 0x41, 0x00, 0x00, 0x7b, 0x48,
+    0x00, 0x00, 0x7b, 0x50, 0x00, 0x00, 0x7b, 0x55, 0x00, 0x00, 0x7b, 0x5b,
+    0x00, 0x00, 0x7b, 0x63, 0x00, 0x00, 0x7b, 0x6a, 0x00, 0x00, 0x7b, 0x6e,
+    0x00, 0x00, 0x7b, 0x74, 0x00, 0x00, 0x7b, 0x79, 0x00, 0x00, 0x7b, 0x80,
+    0x00, 0x00, 0x7b, 0x83, 0x00, 0x00, 0x7b, 0x8b, 0x00, 0x00, 0x7b, 0x91,
+    0x00, 0x00, 0x7b, 0x97, 0x00, 0x00, 0x7b, 0x9b, 0x00, 0x00, 0x7b, 0xa3,
+    0x00, 0x00, 0x7b, 0xab, 0x00, 0x00, 0x7b, 0xb3, 0x00, 0x00, 0x7b, 0xb9,
+    0x00, 0x00, 0x7b, 0xc0, 0x00, 0x00, 0x7b, 0xc4, 0x00, 0x00, 0x7b, 0xc9,
+    0x00, 0x00, 0x7b, 0xd0, 0x00, 0x00, 0x7b, 0xd5, 0x00, 0x00, 0x7b, 0xdb,
+    0x00, 0x00, 0x7b, 0xe1, 0x00, 0x00, 0x7b, 0xe7, 0x00, 0x00, 0x7b, 0xed,
+    0x00, 0x00, 0x7b, 0xf1, 0x00, 0x00, 0x7b, 0xf6, 0x00, 0x00, 0x7b, 0xfb,
+    0x00, 0x00, 0x7c, 0x02, 0x00, 0x00, 0x7c, 0x09, 0x00, 0x00, 0x7c, 0x10,
+    0x00, 0x00, 0x7c, 0x18, 0x00, 0x00, 0x7c, 0x20, 0x00, 0x00, 0x7c, 0x27,
+    0x00, 0x00, 0x7c, 0x2e, 0x00, 0x00, 0x7c, 0x35, 0x00, 0x00, 0x7c, 0x3b,
+    0x00, 0x00, 0x7c, 0x42, 0x00, 0x00, 0x7c, 0x49, 0x00, 0x00, 0x7c, 0x4f,
+    0x00, 0x00, 0x7c, 0x54, 0x00, 0x00, 0x7c, 0x5d, 0x00, 0x00, 0x7c, 0x65,
+    0x00, 0x00, 0x7c, 0x6d, 0x00, 0x00, 0x7c, 0x72, 0x00, 0x00, 0x7c, 0x79,
+    0x00, 0x00, 0x7c, 0x7f, 0x00, 0x00, 0x7c, 0x86, 0x00, 0x00, 0x7c, 0x8d,
+    0x00, 0x00, 0x7c, 0x95, 0x00, 0x00, 0x7c, 0x9e, 0x00, 0x00, 0x7c, 0xa7,
+    0x00, 0x00, 0x7c, 0xaf, 0x00, 0x00, 0x7c, 0xb9, 0x00, 0x00, 0x7c, 0xc0,
+    0x00, 0x00, 0x7c, 0xc9, 0x00, 0x00, 0x7c, 0xd3, 0x00, 0x00, 0x7c, 0xdb,
+    0x00, 0x00, 0x7c, 0xe4, 0x00, 0x00, 0x7c, 0xed, 0x00, 0x00, 0x7c, 0xf7,
+    0x00, 0x00, 0x7d, 0x01, 0x00, 0x00, 0x7d, 0x0a, 0x00, 0x00, 0x7d, 0x12,
+    0x00, 0x00, 0x7d, 0x1c, 0x00, 0x00, 0x7d, 0x25, 0x00, 0x00, 0x7d, 0x2e,
+    0x00, 0x00, 0x7d, 0x37, 0x00, 0x00, 0x7d, 0x3d, 0x00, 0x00, 0x7d, 0x44,
+    0x00, 0x00, 0x7d, 0x4b, 0x00, 0x00, 0x7d, 0x53, 0x00, 0x00, 0x7d, 0x5a,
+    0x00, 0x00, 0x7d, 0x61, 0x00, 0x00, 0x7d, 0x64, 0x00, 0x00, 0x7d, 0x6b,
+    0x00, 0x00, 0x7d, 0x71, 0x00, 0x00, 0x7d, 0x75, 0x00, 0x00, 0x7d, 0x7c,
+    0x00, 0x00, 0x7d, 0x84, 0x00, 0x00, 0x7d, 0x88, 0x00, 0x00, 0x7d, 0x8f,
+    0x00, 0x00, 0x7d, 0x96, 0x00, 0x00, 0x7d, 0x9d, 0x00, 0x00, 0x7d, 0xa1,
+    0x00, 0x00, 0x7d, 0xa8, 0x00, 0x00, 0x7d, 0xad, 0x00, 0x00, 0x7d, 0xb3,
+    0x00, 0x00, 0x7d, 0xb9, 0x00, 0x00, 0x7d, 0xc2, 0x00, 0x00, 0x7d, 0xc8,
+    0x00, 0x00, 0x7d, 0xcf, 0x00, 0x00, 0x7d, 0xd6, 0x00, 0x00, 0x7d, 0xde,
+    0x00, 0x00, 0x7d, 0xe7, 0x00, 0x00, 0x7d, 0xef, 0x00, 0x00, 0x7d, 0xf5,
+    0x00, 0x00, 0x7d, 0xfa, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x7e, 0x07,
+    0x00, 0x00, 0x7e, 0x0f, 0x00, 0x00, 0x7e, 0x17, 0x00, 0x00, 0x7e, 0x1f,
+    0x00, 0x00, 0x7e, 0x24, 0x00, 0x00, 0x7e, 0x2a, 0x00, 0x00, 0x7e, 0x2f,
+    0x00, 0x00, 0x7e, 0x38, 0x00, 0x00, 0x7e, 0x3e, 0x00, 0x00, 0x7e, 0x44,
+    0x00, 0x00, 0x7e, 0x4b, 0x00, 0x00, 0x7e, 0x55, 0x00, 0x00, 0x7e, 0x5c,
+    0x00, 0x00, 0x7e, 0x63, 0x00, 0x00, 0x7e, 0x6b, 0x00, 0x00, 0x7e, 0x73,
+    0x00, 0x00, 0x7e, 0x76, 0x00, 0x00, 0x7e, 0x7e, 0x00, 0x00, 0x7e, 0x86,
+    0x00, 0x00, 0x7e, 0x8e, 0x00, 0x00, 0x7e, 0x92, 0x00, 0x00, 0x7e, 0x96,
+    0x00, 0x00, 0x7e, 0x9c, 0x00, 0x00, 0x7e, 0xa3, 0x00, 0x00, 0x7e, 0xab,
+    0x00, 0x00, 0x7e, 0xb2, 0x00, 0x00, 0x7e, 0xba, 0x00, 0x00, 0x7e, 0xc0,
+    0x00, 0x00, 0x7e, 0xc8, 0x00, 0x00, 0x7e, 0xd0, 0x00, 0x00, 0x7e, 0xd4,
+    0x00, 0x00, 0x7e, 0xd9, 0x00, 0x00, 0x7e, 0xe0, 0x00, 0x00, 0x7e, 0xe6,
+    0x00, 0x00, 0x7e, 0xed, 0x00, 0x00, 0x7e, 0xf5, 0x00, 0x00, 0x7e, 0xfc,
+    0x00, 0x00, 0x7f, 0x04, 0x00, 0x00, 0x7f, 0x0b, 0x00, 0x00, 0x7f, 0x13,
+    0x00, 0x00, 0x7f, 0x1a, 0x00, 0x00, 0x7f, 0x21, 0x00, 0x00, 0x7f, 0x29,
+    0x00, 0x00, 0x7f, 0x2e, 0x00, 0x00, 0x7f, 0x35, 0x00, 0x00, 0x7f, 0x3b,
+    0x00, 0x00, 0x7f, 0x42, 0x00, 0x00, 0x7f, 0x49, 0x00, 0x00, 0x7f, 0x51,
+    0x00, 0x00, 0x7f, 0x59, 0x00, 0x00, 0x7f, 0x61, 0x00, 0x00, 0x7f, 0x67,
+    0x00, 0x00, 0x7f, 0x6e, 0x00, 0x00, 0x7f, 0x74, 0x00, 0x00, 0x7f, 0x7a,
+    0x00, 0x00, 0x7f, 0x7f, 0x00, 0x00, 0x7f, 0x86, 0x00, 0x00, 0x7f, 0x8c,
+    0x00, 0x00, 0x7f, 0x93, 0x00, 0x00, 0x7f, 0x9b, 0x00, 0x00, 0x7f, 0xa3,
+    0x00, 0x00, 0x7f, 0xa9, 0x00, 0x00, 0x7f, 0xb0, 0x00, 0x00, 0x7f, 0xb8,
+    0x00, 0x00, 0x7f, 0xbe, 0x00, 0x00, 0x7f, 0xc4, 0x00, 0x00, 0x7f, 0xcb,
+    0x00, 0x00, 0x7f, 0xd1, 0x00, 0x00, 0x7f, 0xd6, 0x00, 0x00, 0x7f, 0xdc,
+    0x00, 0x00, 0x7f, 0xe2, 0x00, 0x00, 0x7f, 0xe7, 0x00, 0x00, 0x7f, 0xed,
+    0x00, 0x00, 0x7f, 0xf4, 0x00, 0x00, 0x7f, 0xfa, 0x00, 0x00, 0x80, 0x00,
+    0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x80, 0x0f, 0x00, 0x00, 0x80, 0x15,
+    0x00, 0x00, 0x80, 0x1d, 0x00, 0x00, 0x80, 0x23, 0x00, 0x00, 0x80, 0x2b,
+    0x00, 0x00, 0x80, 0x32, 0x00, 0x00, 0x80, 0x39, 0x00, 0x00, 0x80, 0x41,
+    0x00, 0x00, 0x80, 0x49, 0x00, 0x00, 0x80, 0x4f, 0x00, 0x00, 0x80, 0x55,
+    0x00, 0x00, 0x80, 0x5c, 0x00, 0x00, 0x80, 0x63, 0x00, 0x00, 0x80, 0x69,
+    0x00, 0x00, 0x80, 0x6d, 0x00, 0x00, 0x80, 0x73, 0x00, 0x00, 0x80, 0x79,
+    0x00, 0x00, 0x80, 0x7f, 0x00, 0x00, 0x80, 0x86, 0x00, 0x00, 0x80, 0x8c,
+    0x00, 0x00, 0x80, 0x93, 0x00, 0x00, 0x80, 0x9a, 0x00, 0x00, 0x80, 0xa1,
+    0x00, 0x00, 0x80, 0xa8, 0x00, 0x00, 0x80, 0xad, 0x00, 0x00, 0x80, 0xb5,
+    0x00, 0x00, 0x80, 0xbd, 0x00, 0x00, 0x80, 0xc4, 0x00, 0x00, 0x80, 0xcd,
+    0x00, 0x00, 0x80, 0xd5, 0x00, 0x00, 0x80, 0xdd, 0x00, 0x00, 0x80, 0xe5,
+    0x00, 0x00, 0x80, 0xed, 0x00, 0x00, 0x80, 0xf2, 0x00, 0x00, 0x80, 0xfa,
+    0x00, 0x00, 0x81, 0x02, 0x00, 0x00, 0x81, 0x09, 0x00, 0x00, 0x81, 0x10,
+    0x00, 0x00, 0x81, 0x18, 0x00, 0x00, 0x81, 0x21, 0x00, 0x00, 0x81, 0x29,
+    0x00, 0x00, 0x81, 0x2e, 0x00, 0x00, 0x81, 0x35, 0x00, 0x00, 0x81, 0x3c,
+    0x00, 0x00, 0x81, 0x43, 0x00, 0x00, 0x81, 0x49, 0x00, 0x00, 0x81, 0x52,
+    0x00, 0x00, 0x81, 0x5a, 0x00, 0x00, 0x81, 0x63, 0x00, 0x00, 0x81, 0x6b,
+    0x00, 0x00, 0x81, 0x71, 0x00, 0x00, 0x81, 0x78, 0x00, 0x00, 0x81, 0x81,
+    0x00, 0x00, 0x81, 0x87, 0x00, 0x00, 0x81, 0x8d, 0x00, 0x00, 0x81, 0x92,
+    0x00, 0x00, 0x81, 0x98, 0x00, 0x00, 0x81, 0x9f, 0x00, 0x00, 0x81, 0xa4,
+    0x00, 0x00, 0x81, 0xad, 0x00, 0x00, 0x81, 0xb4, 0x00, 0x00, 0x81, 0xba,
+    0x00, 0x00, 0x81, 0xbf, 0x00, 0x00, 0x81, 0xc4, 0x00, 0x00, 0x81, 0xca,
+    0x00, 0x00, 0x81, 0xd1, 0x00, 0x00, 0x81, 0xd6, 0x00, 0x00, 0x81, 0xdf,
+    0x00, 0x00, 0x81, 0xe8, 0x00, 0x00, 0x81, 0xef, 0x00, 0x00, 0x81, 0xf7,
+    0x00, 0x00, 0x81, 0xff, 0x00, 0x00, 0x82, 0x08, 0x00, 0x00, 0x82, 0x11,
+    0x00, 0x00, 0x82, 0x18, 0x00, 0x00, 0x82, 0x1f, 0x00, 0x00, 0x82, 0x23,
+    0x00, 0x00, 0x82, 0x2a, 0x00, 0x00, 0x82, 0x34, 0x00, 0x00, 0x82, 0x3e,
+    0x00, 0x00, 0x82, 0x48, 0x00, 0x00, 0x82, 0x4e, 0x00, 0x00, 0x82, 0x55,
+    0x00, 0x00, 0x82, 0x59, 0x00, 0x00, 0x82, 0x61, 0x00, 0x00, 0x82, 0x66,
+    0x00, 0x00, 0x82, 0x6a, 0x00, 0x00, 0x82, 0x70, 0x00, 0x00, 0x82, 0x77,
+    0x00, 0x00, 0x82, 0x7d, 0x00, 0x00, 0x82, 0x82, 0x00, 0x00, 0x82, 0x88,
+    0x00, 0x00, 0x82, 0x8f, 0x00, 0x00, 0x82, 0x96, 0x00, 0x00, 0x82, 0x9d,
+    0x00, 0x00, 0x82, 0xa6, 0x00, 0x00, 0x82, 0xae, 0x00, 0x00, 0x82, 0xb7,
+    0x00, 0x00, 0x82, 0xbf, 0x00, 0x00, 0x82, 0xc7, 0x00, 0x00, 0x82, 0xcf,
+    0x00, 0x00, 0x82, 0xd5, 0x00, 0x00, 0x82, 0xdc, 0x00, 0x00, 0x82, 0xe0,
+    0x00, 0x00, 0x82, 0xe7, 0x00, 0x00, 0x82, 0xed, 0x00, 0x00, 0x82, 0xf5,
+    0x00, 0x00, 0x82, 0xfa, 0x00, 0x00, 0x83, 0x02, 0x00, 0x00, 0x83, 0x07,
+    0x00, 0x00, 0x83, 0x0c, 0x00, 0x00, 0x83, 0x11, 0x00, 0x00, 0x83, 0x17,
+    0x00, 0x00, 0x83, 0x1d, 0x00, 0x00, 0x83, 0x22, 0x00, 0x00, 0x83, 0x29,
+    0x00, 0x00, 0x83, 0x2f, 0x00, 0x00, 0x83, 0x34, 0x00, 0x00, 0x83, 0x3c,
+    0x00, 0x00, 0x83, 0x40, 0x00, 0x00, 0x83, 0x45, 0x00, 0x00, 0x83, 0x49,
+    0x00, 0x00, 0x83, 0x4d, 0x00, 0x00, 0x83, 0x53, 0x00, 0x00, 0x83, 0x5a,
+    0x00, 0x00, 0x83, 0x61, 0x00, 0x00, 0x83, 0x66, 0x00, 0x00, 0x83, 0x6d,
+    0x00, 0x00, 0x83, 0x74, 0x00, 0x00, 0x83, 0x7b, 0x00, 0x00, 0x83, 0x81,
+    0x00, 0x00, 0x83, 0x88, 0x00, 0x00, 0x83, 0x8f, 0x00, 0x00, 0x83, 0x94,
+    0x00, 0x00, 0x83, 0x9a, 0x00, 0x00, 0x83, 0xa2, 0x00, 0x00, 0x83, 0xa8,
+    0x00, 0x00, 0x83, 0xad, 0x00, 0x00, 0x83, 0xb3, 0x00, 0x00, 0x83, 0xb9,
+    0x00, 0x00, 0x83, 0xc1, 0x00, 0x00, 0x83, 0xc8, 0x00, 0x00, 0x83, 0xce,
+    0x00, 0x00, 0x83, 0xd3, 0x00, 0x00, 0x83, 0xd9, 0x00, 0x00, 0x83, 0xde,
+    0x00, 0x00, 0x83, 0xe3, 0x00, 0x00, 0x83, 0xe9, 0x00, 0x00, 0x83, 0xef,
+    0x00, 0x00, 0x83, 0xf6, 0x00, 0x00, 0x83, 0xfb, 0x00, 0x00, 0x84, 0x01,
+    0x00, 0x00, 0x84, 0x08, 0x00, 0x00, 0x84, 0x10, 0x00, 0x00, 0x84, 0x15,
+    0x00, 0x00, 0x84, 0x1d, 0x00, 0x00, 0x84, 0x22, 0x00, 0x00, 0x84, 0x29,
+    0x00, 0x00, 0x84, 0x30, 0x00, 0x00, 0x84, 0x36, 0x00, 0x00, 0x84, 0x3d,
+    0x00, 0x00, 0x84, 0x43, 0x00, 0x00, 0x84, 0x48, 0x00, 0x00, 0x84, 0x4e,
+    0x00, 0x00, 0x84, 0x55, 0x00, 0x00, 0x84, 0x5c, 0x00, 0x00, 0x84, 0x63,
+    0x00, 0x00, 0x84, 0x69, 0x00, 0x00, 0x84, 0x6f, 0x00, 0x00, 0x84, 0x77,
+    0x00, 0x00, 0x84, 0x7d, 0x00, 0x00, 0x84, 0x84, 0x00, 0x00, 0x84, 0x8c,
+    0x00, 0x00, 0x84, 0x92, 0x00, 0x00, 0x84, 0x99, 0x00, 0x00, 0x84, 0x9e,
+    0x00, 0x00, 0x84, 0xa5, 0x00, 0x00, 0x84, 0xab, 0x00, 0x00, 0x84, 0xb1,
+    0x00, 0x00, 0x84, 0xba, 0x00, 0x00, 0x84, 0xc2, 0x00, 0x00, 0x84, 0xc8,
+    0x00, 0x00, 0x84, 0xcf, 0x00, 0x00, 0x84, 0xd6, 0x00, 0x00, 0x84, 0xde,
+    0x00, 0x00, 0x84, 0xe3, 0x00, 0x00, 0x84, 0xe9, 0x00, 0x00, 0x84, 0xf0,
+    0x00, 0x00, 0x84, 0xf6, 0x00, 0x00, 0x84, 0xfc, 0x00, 0x00, 0x85, 0x03,
+    0x00, 0x00, 0x85, 0x06, 0x00, 0x00, 0x85, 0x0b, 0x00, 0x00, 0x85, 0x10,
+    0x00, 0x00, 0x85, 0x16, 0x00, 0x00, 0x85, 0x1c, 0x00, 0x00, 0x85, 0x23,
+    0x00, 0x00, 0x85, 0x2a, 0x00, 0x00, 0x85, 0x30, 0x00, 0x00, 0x85, 0x36,
+    0x00, 0x00, 0x85, 0x39, 0x00, 0x00, 0x85, 0x40, 0x00, 0x00, 0x85, 0x47,
+    0x00, 0x00, 0x85, 0x4d, 0x00, 0x00, 0x85, 0x55, 0x00, 0x00, 0x85, 0x5a,
+    0x00, 0x00, 0x85, 0x60, 0x00, 0x00, 0x85, 0x67, 0x00, 0x00, 0x85, 0x6d,
+    0x00, 0x00, 0x85, 0x74, 0x00, 0x00, 0x85, 0x7a, 0x00, 0x00, 0x85, 0x7e,
+    0x00, 0x00, 0x85, 0x85, 0x00, 0x00, 0x85, 0x8d, 0x00, 0x00, 0x85, 0x90,
+    0x00, 0x00, 0x85, 0x94, 0x00, 0x00, 0x85, 0x9b, 0x00, 0x00, 0x85, 0xa0,
+    0x00, 0x00, 0x85, 0xa4, 0x00, 0x00, 0x85, 0xa9, 0x00, 0x00, 0x85, 0xad,
+    0x00, 0x00, 0x85, 0xb5, 0x00, 0x00, 0x85, 0xbb, 0x00, 0x00, 0x85, 0xc4,
+    0x00, 0x00, 0x85, 0xcb, 0x00, 0x00, 0x85, 0xd4, 0x00, 0x00, 0x85, 0xde,
+    0x00, 0x00, 0x85, 0xe8, 0x00, 0x00, 0x85, 0xef, 0x00, 0x00, 0x85, 0xf7,
+    0x00, 0x00, 0x85, 0xff, 0x00, 0x00, 0x86, 0x06, 0x00, 0x00, 0x86, 0x0d,
+    0x00, 0x00, 0x86, 0x15, 0x00, 0x00, 0x86, 0x1c, 0x00, 0x00, 0x86, 0x20,
+    0x00, 0x00, 0x86, 0x26, 0x00, 0x00, 0x86, 0x2c, 0x00, 0x00, 0x86, 0x33,
+    0x00, 0x00, 0x86, 0x3b, 0x00, 0x00, 0x86, 0x43, 0x00, 0x00, 0x86, 0x49,
+    0x00, 0x00, 0x86, 0x50, 0x00, 0x00, 0x86, 0x56, 0x00, 0x00, 0x86, 0x5e,
+    0x00, 0x00, 0x86, 0x67, 0x00, 0x00, 0x86, 0x6e, 0x00, 0x00, 0x86, 0x77,
+    0x00, 0x00, 0x86, 0x7e, 0x00, 0x00, 0x86, 0x83, 0x00, 0x00, 0x86, 0x89,
+    0x00, 0x00, 0x86, 0x8f, 0x00, 0x00, 0x86, 0x95, 0x00, 0x00, 0x86, 0x9b,
+    0x00, 0x00, 0x86, 0xa1, 0x00, 0x00, 0x86, 0xa8, 0x00, 0x00, 0x86, 0xad,
+    0x00, 0x00, 0x86, 0xb5, 0x00, 0x00, 0x86, 0xbd, 0x00, 0x00, 0x86, 0xc4,
+    0x00, 0x00, 0x86, 0xcb, 0x00, 0x00, 0x86, 0xd2, 0x00, 0x00, 0x86, 0xd8,
+    0x00, 0x00, 0x86, 0xde, 0x00, 0x00, 0x86, 0xe3, 0x00, 0x00, 0x86, 0xe9,
+    0x00, 0x00, 0x86, 0xf1, 0x00, 0x00, 0x86, 0xf8, 0x00, 0x00, 0x86, 0xff,
+    0x00, 0x00, 0x87, 0x06, 0x00, 0x00, 0x87, 0x0c, 0x00, 0x00, 0x87, 0x14,
+    0x00, 0x00, 0x87, 0x1b, 0x00, 0x00, 0x87, 0x23, 0x00, 0x00, 0x87, 0x28,
+    0x00, 0x00, 0x87, 0x2e, 0x00, 0x00, 0x87, 0x36, 0x00, 0x00, 0x87, 0x3f,
+    0x00, 0x00, 0x87, 0x46, 0x00, 0x00, 0x87, 0x4e, 0x00, 0x00, 0x87, 0x55,
+    0x00, 0x00, 0x87, 0x5d, 0x00, 0x00, 0x87, 0x64, 0x00, 0x00, 0x87, 0x6b,
+    0x00, 0x00, 0x87, 0x74, 0x00, 0x00, 0x87, 0x7d, 0x00, 0x00, 0x87, 0x87,
+    0x00, 0x00, 0x87, 0x8e, 0x00, 0x00, 0x87, 0x95, 0x00, 0x00, 0x87, 0x9b,
+    0x00, 0x00, 0x87, 0xa0, 0x00, 0x00, 0x87, 0xa3, 0x00, 0x00, 0x87, 0xab,
+    0x00, 0x00, 0x87, 0xb3, 0x00, 0x00, 0x87, 0xba, 0x00, 0x00, 0x87, 0xc0,
+    0x00, 0x00, 0x87, 0xc7, 0x00, 0x00, 0x87, 0xcd, 0x00, 0x00, 0x87, 0xd4,
+    0x00, 0x00, 0x87, 0xdd, 0x00, 0x00, 0x87, 0xe7, 0x00, 0x00, 0x87, 0xec,
+    0x00, 0x00, 0x87, 0xf1, 0x00, 0x00, 0x87, 0xf7, 0x00, 0x00, 0x87, 0xfd,
+    0x00, 0x00, 0x88, 0x02, 0x00, 0x00, 0x88, 0x08, 0x00, 0x00, 0x88, 0x10,
+    0x00, 0x00, 0x88, 0x19, 0x00, 0x00, 0x88, 0x22, 0x00, 0x00, 0x88, 0x29,
+    0x00, 0x00, 0x88, 0x30, 0x00, 0x00, 0x88, 0x36, 0x00, 0x00, 0x88, 0x3d,
+    0x00, 0x00, 0x88, 0x45, 0x00, 0x00, 0x88, 0x4e, 0x00, 0x00, 0x88, 0x55,
+    0x00, 0x00, 0x88, 0x5c, 0x00, 0x00, 0x88, 0x63, 0x00, 0x00, 0x88, 0x6c,
+    0x00, 0x00, 0x88, 0x74, 0x00, 0x00, 0x88, 0x7d, 0x00, 0x00, 0x88, 0x82,
+    0x00, 0x00, 0x88, 0x87, 0x00, 0x00, 0x88, 0x8c, 0x00, 0x00, 0x88, 0x92,
+    0x00, 0x00, 0x88, 0x99, 0x00, 0x00, 0x88, 0xa1, 0x00, 0x00, 0x88, 0xa8,
+    0x00, 0x00, 0x88, 0xb1, 0x00, 0x00, 0x88, 0xb5, 0x00, 0x00, 0x88, 0xbd,
+    0x00, 0x00, 0x88, 0xc3, 0x00, 0x00, 0x88, 0xca, 0x00, 0x00, 0x88, 0xcf,
+    0x00, 0x00, 0x88, 0xd3, 0x00, 0x00, 0x88, 0xd9, 0x00, 0x00, 0x88, 0xe0,
+    0x00, 0x00, 0x88, 0xe8, 0x00, 0x00, 0x88, 0xee, 0x00, 0x00, 0x88, 0xf5,
+    0x00, 0x00, 0x88, 0xfc, 0x00, 0x00, 0x89, 0x05, 0x00, 0x00, 0x89, 0x09,
+    0x00, 0x00, 0x89, 0x0f, 0x00, 0x00, 0x89, 0x16, 0x00, 0x00, 0x89, 0x1e,
+    0x00, 0x00, 0x89, 0x25, 0x00, 0x00, 0x89, 0x2a, 0x00, 0x00, 0x89, 0x31,
+    0x00, 0x00, 0x89, 0x38, 0x00, 0x00, 0x89, 0x3d, 0x00, 0x00, 0x89, 0x44,
+    0x00, 0x00, 0x89, 0x4a, 0x00, 0x00, 0x89, 0x4e, 0x00, 0x00, 0x89, 0x55,
+    0x00, 0x00, 0x89, 0x59, 0x00, 0x00, 0x89, 0x61, 0x00, 0x00, 0x89, 0x67,
+    0x00, 0x00, 0x89, 0x6e, 0x00, 0x00, 0x89, 0x77, 0x00, 0x00, 0x89, 0x7d,
+    0x00, 0x00, 0x89, 0x84, 0x00, 0x00, 0x89, 0x8b, 0x00, 0x00, 0x89, 0x8f,
+    0x00, 0x00, 0x89, 0x96, 0x00, 0x00, 0x89, 0x9d, 0x00, 0x00, 0x89, 0xa5,
+    0x00, 0x00, 0x89, 0xad, 0x00, 0x00, 0x89, 0xb4, 0x00, 0x00, 0x89, 0xbc,
+    0x00, 0x00, 0x89, 0xc3, 0x00, 0x00, 0x89, 0xcb, 0x00, 0x00, 0x89, 0xd1,
+    0x00, 0x00, 0x89, 0xd7, 0x00, 0x00, 0x89, 0xdf, 0x00, 0x00, 0x89, 0xe7,
+    0x00, 0x00, 0x89, 0xf0, 0x00, 0x00, 0x89, 0xfb, 0x00, 0x00, 0x8a, 0x05,
+    0x00, 0x00, 0x8a, 0x0a, 0x00, 0x00, 0x8a, 0x10, 0x00, 0x00, 0x8a, 0x18,
+    0x00, 0x00, 0x8a, 0x20, 0x00, 0x00, 0x8a, 0x28, 0x00, 0x00, 0x8a, 0x31,
+    0x00, 0x00, 0x8a, 0x3a, 0x00, 0x00, 0x8a, 0x41, 0x00, 0x00, 0x8a, 0x49,
+    0x00, 0x00, 0x8a, 0x52, 0x00, 0x00, 0x8a, 0x5a, 0x00, 0x00, 0x8a, 0x61,
+    0x00, 0x00, 0x8a, 0x6b, 0x00, 0x00, 0x8a, 0x72, 0x00, 0x00, 0x8a, 0x7c,
+    0x00, 0x00, 0x8a, 0x83, 0x00, 0x00, 0x8a, 0x89, 0x00, 0x00, 0x8a, 0x8f,
+    0x00, 0x00, 0x8a, 0x96, 0x00, 0x00, 0x8a, 0x9d, 0x00, 0x00, 0x8a, 0xa4,
+    0x00, 0x00, 0x8a, 0xaa, 0x00, 0x00, 0x8a, 0xb2, 0x00, 0x00, 0x8a, 0xba,
+    0x00, 0x00, 0x8a, 0xc3, 0x00, 0x00, 0x8a, 0xca, 0x00, 0x00, 0x8a, 0xd4,
+    0x00, 0x00, 0x8a, 0xdb, 0x00, 0x00, 0x8a, 0xe3, 0x00, 0x00, 0x8a, 0xea,
+    0x00, 0x00, 0x8a, 0xed, 0x00, 0x00, 0x8a, 0xf3, 0x00, 0x00, 0x8a, 0xfb,
+    0x00, 0x00, 0x8b, 0x01, 0x00, 0x00, 0x8b, 0x08, 0x00, 0x00, 0x8b, 0x0f,
+    0x00, 0x00, 0x8b, 0x16, 0x00, 0x00, 0x8b, 0x1c, 0x00, 0x00, 0x8b, 0x21,
+    0x00, 0x00, 0x8b, 0x29, 0x00, 0x00, 0x8b, 0x31, 0x00, 0x00, 0x8b, 0x36,
+    0x00, 0x00, 0x8b, 0x3d, 0x00, 0x00, 0x8b, 0x43, 0x00, 0x00, 0x8b, 0x48,
+    0x00, 0x00, 0x8b, 0x50, 0x00, 0x00, 0x8b, 0x58, 0x00, 0x00, 0x8b, 0x5c,
+    0x00, 0x00, 0x8b, 0x61, 0x00, 0x00, 0x8b, 0x68, 0x00, 0x00, 0x8b, 0x6f,
+    0x00, 0x00, 0x8b, 0x77, 0x00, 0x00, 0x8b, 0x7e, 0x00, 0x00, 0x8b, 0x82,
+    0x00, 0x00, 0x8b, 0x89, 0x00, 0x00, 0x8b, 0x8d, 0x00, 0x00, 0x8b, 0x91,
+    0x00, 0x00, 0x8b, 0x99, 0x00, 0x00, 0x8b, 0xa2, 0x00, 0x00, 0x8b, 0xa8,
+    0x00, 0x00, 0x8b, 0xb0, 0x00, 0x00, 0x8b, 0xb3, 0x00, 0x00, 0x8b, 0xb8,
+    0x00, 0x00, 0x8b, 0xbd, 0x00, 0x00, 0x8b, 0xc5, 0x00, 0x00, 0x8b, 0xcd,
+    0x00, 0x00, 0x8b, 0xd5, 0x00, 0x00, 0x8b, 0xdd, 0x00, 0x00, 0x8b, 0xe1,
+    0x00, 0x00, 0x8b, 0xe6, 0x00, 0x00, 0x8b, 0xed, 0x00, 0x00, 0x8b, 0xf5,
+    0x00, 0x00, 0x8b, 0xfe, 0x00, 0x00, 0x8c, 0x04, 0x00, 0x00, 0x8c, 0x07,
+    0x00, 0x00, 0x8c, 0x0e, 0x00, 0x00, 0x8c, 0x12, 0x00, 0x00, 0x8c, 0x17,
+    0x00, 0x00, 0x8c, 0x1e, 0x00, 0x00, 0x8c, 0x23, 0x00, 0x00, 0x8c, 0x2b,
+    0x00, 0x00, 0x8c, 0x2f, 0x00, 0x00, 0x8c, 0x34, 0x00, 0x00, 0x8c, 0x3b,
+    0x00, 0x00, 0x8c, 0x40, 0x00, 0x00, 0x8c, 0x47, 0x00, 0x00, 0x8c, 0x4e,
+    0x00, 0x00, 0x8c, 0x54, 0x00, 0x00, 0x8c, 0x5b, 0x00, 0x00, 0x8c, 0x65,
+    0x00, 0x00, 0x8c, 0x6d, 0x00, 0x00, 0x8c, 0x75, 0x00, 0x00, 0x8c, 0x7a,
+    0x00, 0x00, 0x8c, 0x82, 0x00, 0x00, 0x8c, 0x87, 0x00, 0x00, 0x8c, 0x8d,
+    0x00, 0x00, 0x8c, 0x92, 0x00, 0x00, 0x8c, 0x99, 0x00, 0x00, 0x8c, 0x9e,
+    0x00, 0x00, 0x8c, 0xa4, 0x00, 0x00, 0x8c, 0xaa, 0x00, 0x00, 0x8c, 0xb0,
+    0x00, 0x00, 0x8c, 0xb5, 0x00, 0x00, 0x8c, 0xbd, 0x00, 0x00, 0x8c, 0xc3,
+    0x00, 0x00, 0x8c, 0xcb, 0x00, 0x00, 0x8c, 0xd1, 0x00, 0x00, 0x8c, 0xd6,
+    0x00, 0x00, 0x8c, 0xdb, 0x00, 0x00, 0x8c, 0xdf, 0x00, 0x00, 0x8c, 0xe5,
+    0x00, 0x00, 0x8c, 0xeb, 0x00, 0x00, 0x8c, 0xf0, 0x00, 0x00, 0x8c, 0xf5,
+    0x00, 0x00, 0x8c, 0xfb, 0x00, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x8d, 0x08,
+    0x00, 0x00, 0x8d, 0x0d, 0x00, 0x00, 0x8d, 0x14, 0x6e, 0x61, 0x6d, 0x65,
+    0x00, 0x6d, 0x61, 0x6c, 0x65, 0x00, 0x66, 0x65, 0x6d, 0x61, 0x6c, 0x65,
+    0x00, 0x75, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x00, 0x41, 0x61, 0x72,
+    0x6f, 0x6e, 0x00, 0x41, 0x62, 0x62, 0x65, 0x79, 0x00, 0x41, 0x62, 0x62,
+    0x69, 0x65, 0x00, 0x41, 0x62, 0x62, 0x79, 0x00, 0x41, 0x62, 0x64, 0x75,
+    0x6c, 0x00, 0x41, 0x62, 0x65, 0x00, 0x41, 0x62, 0x65, 0x6c, 0x00, 0x41,
+    0x62, 0x69, 0x67, 0x61, 0x69, 0x6c, 0x00, 0x41, 0x62, 0x72, 0x61, 0x68,
+    0x61, 0x6d, 0x00, 0x41, 0x62, 0x72, 0x61, 0x6d, 0x00, 0x41, 0x64, 0x61,
+    0x00, 0x41, 0x64, 0x61, 0x68, 0x00, 0x41, 0x64, 0x61, 0x6c, 0x62, 0x65,
+    0x72, 0x74, 0x6f, 0x00, 0x41, 0x64, 0x61, 0x6c, 0x69, 0x6e, 0x65, 0x00,
+    0x41, 0x64, 0x61, 0x6d, 0x00, 0x41, 0x64, 0x61, 0x6e, 0x00, 0x41, 0x64,
+    0x64, 0x69, 0x65, 0x00, 0x41, 0x64, 0x65, 0x6c, 0x61, 0x00, 0x41, 0x64,
+    0x65, 0x6c, 0x61, 0x69, 0x64, 0x61, 0x00, 0x41, 0x64, 0x65, 0x6c, 0x61,
+    0x69, 0x64, 0x65, 0x00, 0x41, 0x64, 0x65, 0x6c, 0x65, 0x00, 0x41, 0x64,
+    0x65, 0x6c, 0x69, 0x61, 0x00, 0x41, 0x64, 0x65, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x41, 0x64, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x41, 0x64, 0x65,
+    0x6c, 0x6c, 0x00, 0x41, 0x64, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x41, 0x64,
+    0x65, 0x6c, 0x6c, 0x65, 0x00, 0x41, 0x64, 0x65, 0x6e, 0x61, 0x00, 0x41,
+    0x64, 0x69, 0x6e, 0x61, 0x00, 0x41, 0x64, 0x6f, 0x6c, 0x66, 0x6f, 0x00,
+    0x41, 0x64, 0x6f, 0x6c, 0x70, 0x68, 0x00, 0x41, 0x64, 0x72, 0x69, 0x61,
+    0x00, 0x41, 0x64, 0x72, 0x69, 0x61, 0x6e, 0x00, 0x41, 0x64, 0x72, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x41, 0x64, 0x72, 0x69, 0x61, 0x6e, 0x65, 0x00,
+    0x41, 0x64, 0x72, 0x69, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x41, 0x64, 0x72,
+    0x69, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x41, 0x64, 0x72, 0x69, 0x65, 0x6e,
+    0x00, 0x41, 0x64, 0x72, 0x69, 0x65, 0x6e, 0x65, 0x00, 0x41, 0x64, 0x72,
+    0x69, 0x65, 0x6e, 0x6e, 0x65, 0x00, 0x41, 0x66, 0x74, 0x6f, 0x6e, 0x00,
+    0x41, 0x67, 0x61, 0x74, 0x68, 0x61, 0x00, 0x41, 0x67, 0x6e, 0x65, 0x73,
+    0x00, 0x41, 0x67, 0x6e, 0x75, 0x73, 0x00, 0x41, 0x67, 0x72, 0x69, 0x70,
+    0x69, 0x6e, 0x61, 0x00, 0x41, 0x67, 0x75, 0x65, 0x64, 0x61, 0x00, 0x41,
+    0x67, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x00, 0x41, 0x67, 0x75, 0x73, 0x74,
+    0x69, 0x6e, 0x61, 0x00, 0x41, 0x68, 0x6d, 0x61, 0x64, 0x00, 0x41, 0x68,
+    0x6d, 0x65, 0x64, 0x00, 0x41, 0x69, 0x00, 0x41, 0x69, 0x64, 0x61, 0x00,
+    0x41, 0x69, 0x64, 0x65, 0x00, 0x41, 0x69, 0x6b, 0x6f, 0x00, 0x41, 0x69,
+    0x6c, 0x65, 0x65, 0x6e, 0x00, 0x41, 0x69, 0x6c, 0x65, 0x6e, 0x65, 0x00,
+    0x41, 0x69, 0x6d, 0x65, 0x65, 0x00, 0x41, 0x69, 0x73, 0x68, 0x61, 0x00,
+    0x41, 0x6a, 0x61, 0x00, 0x41, 0x6b, 0x69, 0x6b, 0x6f, 0x00, 0x41, 0x6b,
+    0x69, 0x6c, 0x61, 0x68, 0x00, 0x41, 0x6c, 0x00, 0x41, 0x6c, 0x61, 0x69,
+    0x6e, 0x61, 0x00, 0x41, 0x6c, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x41, 0x6c,
+    0x61, 0x6e, 0x00, 0x41, 0x6c, 0x61, 0x6e, 0x61, 0x00, 0x41, 0x6c, 0x61,
+    0x6e, 0x65, 0x00, 0x41, 0x6c, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x41, 0x6c,
+    0x61, 0x79, 0x6e, 0x61, 0x00, 0x41, 0x6c, 0x62, 0x61, 0x00, 0x41, 0x6c,
+    0x62, 0x65, 0x72, 0x74, 0x00, 0x41, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x61,
+    0x00, 0x41, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x68, 0x61, 0x00, 0x41, 0x6c,
+    0x62, 0x65, 0x72, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x41, 0x6c, 0x62, 0x65,
+    0x72, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x41, 0x6c, 0x62, 0x65, 0x72, 0x74,
+    0x6f, 0x00, 0x41, 0x6c, 0x62, 0x69, 0x6e, 0x61, 0x00, 0x41, 0x6c, 0x64,
+    0x61, 0x00, 0x41, 0x6c, 0x64, 0x65, 0x6e, 0x00, 0x41, 0x6c, 0x64, 0x6f,
+    0x00, 0x41, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x00, 0x41, 0x6c, 0x65, 0x63,
+    0x00, 0x41, 0x6c, 0x65, 0x63, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x65,
+    0x6e, 0x00, 0x41, 0x6c, 0x65, 0x69, 0x64, 0x61, 0x00, 0x41, 0x6c, 0x65,
+    0x69, 0x73, 0x68, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x6a, 0x61, 0x6e, 0x64,
+    0x72, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x6a, 0x61, 0x6e, 0x64, 0x72, 0x69,
+    0x6e, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x6a, 0x61, 0x6e, 0x64, 0x72, 0x6f,
+    0x00, 0x41, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x6e, 0x65,
+    0x00, 0x41, 0x6c, 0x65, 0x73, 0x68, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x73,
+    0x68, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x73, 0x69, 0x61, 0x00, 0x41,
+    0x6c, 0x65, 0x73, 0x73, 0x61, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x41, 0x6c,
+    0x65, 0x74, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x74, 0x68, 0x61, 0x00, 0x41,
+    0x6c, 0x65, 0x74, 0x68, 0x65, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x74, 0x68,
+    0x69, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x78, 0x00, 0x41, 0x6c, 0x65, 0x78,
+    0x61, 0x00, 0x41, 0x6c, 0x65, 0x78, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x00,
+    0x41, 0x6c, 0x65, 0x78, 0x61, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x41, 0x6c,
+    0x65, 0x78, 0x61, 0x6e, 0x64, 0x72, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x65,
+    0x78, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x65, 0x78, 0x69, 0x73, 0x00, 0x41,
+    0x6c, 0x66, 0x6f, 0x6e, 0x73, 0x6f, 0x00, 0x41, 0x6c, 0x66, 0x6f, 0x6e,
+    0x7a, 0x6f, 0x00, 0x41, 0x6c, 0x66, 0x72, 0x65, 0x64, 0x00, 0x41, 0x6c,
+    0x66, 0x72, 0x65, 0x64, 0x61, 0x00, 0x41, 0x6c, 0x66, 0x72, 0x65, 0x64,
+    0x69, 0x61, 0x00, 0x41, 0x6c, 0x66, 0x72, 0x65, 0x64, 0x6f, 0x00, 0x41,
+    0x6c, 0x69, 0x00, 0x41, 0x6c, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x69, 0x63,
+    0x61, 0x00, 0x41, 0x6c, 0x69, 0x63, 0x65, 0x00, 0x41, 0x6c, 0x69, 0x63,
+    0x69, 0x61, 0x00, 0x41, 0x6c, 0x69, 0x64, 0x61, 0x00, 0x41, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x41, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x41, 0x6c, 0x69,
+    0x73, 0x61, 0x00, 0x41, 0x6c, 0x69, 0x73, 0x65, 0x00, 0x41, 0x6c, 0x69,
+    0x73, 0x68, 0x61, 0x00, 0x41, 0x6c, 0x69, 0x73, 0x68, 0x69, 0x61, 0x00,
+    0x41, 0x6c, 0x69, 0x73, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x69, 0x73, 0x6f,
+    0x6e, 0x00, 0x41, 0x6c, 0x69, 0x73, 0x73, 0x61, 0x00, 0x41, 0x6c, 0x69,
+    0x74, 0x61, 0x00, 0x41, 0x6c, 0x69, 0x78, 0x00, 0x41, 0x6c, 0x69, 0x7a,
+    0x61, 0x00, 0x41, 0x6c, 0x6c, 0x61, 0x00, 0x41, 0x6c, 0x6c, 0x61, 0x6e,
+    0x00, 0x41, 0x6c, 0x6c, 0x65, 0x65, 0x6e, 0x00, 0x41, 0x6c, 0x6c, 0x65,
+    0x67, 0x72, 0x61, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x41, 0x6c,
+    0x6c, 0x65, 0x6e, 0x61, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x6e, 0x65, 0x00,
+    0x41, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x41, 0x6c, 0x6c, 0x69, 0x6e, 0x65,
+    0x00, 0x41, 0x6c, 0x6c, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x41, 0x6c, 0x6c,
+    0x79, 0x6e, 0x00, 0x41, 0x6c, 0x6c, 0x79, 0x73, 0x6f, 0x6e, 0x00, 0x41,
+    0x6c, 0x6d, 0x61, 0x00, 0x41, 0x6c, 0x6d, 0x65, 0x64, 0x61, 0x00, 0x41,
+    0x6c, 0x6d, 0x65, 0x74, 0x61, 0x00, 0x41, 0x6c, 0x6f, 0x6e, 0x61, 0x00,
+    0x41, 0x6c, 0x6f, 0x6e, 0x73, 0x6f, 0x00, 0x41, 0x6c, 0x6f, 0x6e, 0x7a,
+    0x6f, 0x00, 0x41, 0x6c, 0x70, 0x68, 0x61, 0x00, 0x41, 0x6c, 0x70, 0x68,
+    0x6f, 0x6e, 0x73, 0x65, 0x00, 0x41, 0x6c, 0x70, 0x68, 0x6f, 0x6e, 0x73,
+    0x6f, 0x00, 0x41, 0x6c, 0x74, 0x61, 0x00, 0x41, 0x6c, 0x74, 0x61, 0x67,
+    0x72, 0x61, 0x63, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x74, 0x68, 0x61, 0x00,
+    0x41, 0x6c, 0x74, 0x68, 0x65, 0x61, 0x00, 0x41, 0x6c, 0x74, 0x6f, 0x6e,
+    0x00, 0x41, 0x6c, 0x76, 0x61, 0x00, 0x41, 0x6c, 0x76, 0x61, 0x72, 0x6f,
+    0x00, 0x41, 0x6c, 0x76, 0x65, 0x72, 0x61, 0x00, 0x41, 0x6c, 0x76, 0x65,
+    0x72, 0x74, 0x61, 0x00, 0x41, 0x6c, 0x76, 0x69, 0x6e, 0x00, 0x41, 0x6c,
+    0x76, 0x69, 0x6e, 0x61, 0x00, 0x41, 0x6c, 0x79, 0x63, 0x65, 0x00, 0x41,
+    0x6c, 0x79, 0x63, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x79, 0x73, 0x61, 0x00,
+    0x41, 0x6c, 0x79, 0x73, 0x65, 0x00, 0x41, 0x6c, 0x79, 0x73, 0x68, 0x61,
+    0x00, 0x41, 0x6c, 0x79, 0x73, 0x69, 0x61, 0x00, 0x41, 0x6c, 0x79, 0x73,
+    0x6f, 0x6e, 0x00, 0x41, 0x6c, 0x79, 0x73, 0x73, 0x61, 0x00, 0x41, 0x6d,
+    0x61, 0x64, 0x61, 0x00, 0x41, 0x6d, 0x61, 0x64, 0x6f, 0x00, 0x41, 0x6d,
+    0x61, 0x6c, 0x00, 0x41, 0x6d, 0x61, 0x6c, 0x69, 0x61, 0x00, 0x41, 0x6d,
+    0x61, 0x6e, 0x64, 0x61, 0x00, 0x41, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x41,
+    0x6d, 0x62, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x41, 0x6d, 0x62, 0x72, 0x6f,
+    0x73, 0x65, 0x00, 0x41, 0x6d, 0x65, 0x65, 0x00, 0x41, 0x6d, 0x65, 0x6c,
+    0x69, 0x61, 0x00, 0x41, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x00, 0x41,
+    0x6d, 0x69, 0x00, 0x41, 0x6d, 0x69, 0x65, 0x00, 0x41, 0x6d, 0x69, 0x65,
+    0x65, 0x00, 0x41, 0x6d, 0x69, 0x6e, 0x61, 0x00, 0x41, 0x6d, 0x69, 0x72,
+    0x61, 0x00, 0x41, 0x6d, 0x6d, 0x69, 0x65, 0x00, 0x41, 0x6d, 0x6f, 0x73,
+    0x00, 0x41, 0x6d, 0x70, 0x61, 0x72, 0x6f, 0x00, 0x41, 0x6d, 0x79, 0x00,
+    0x41, 0x6e, 0x00, 0x41, 0x6e, 0x61, 0x00, 0x41, 0x6e, 0x61, 0x62, 0x65,
+    0x6c, 0x00, 0x41, 0x6e, 0x61, 0x6c, 0x69, 0x73, 0x61, 0x00, 0x41, 0x6e,
+    0x61, 0x6d, 0x61, 0x72, 0x69, 0x61, 0x00, 0x41, 0x6e, 0x61, 0x73, 0x74,
+    0x61, 0x63, 0x69, 0x61, 0x00, 0x41, 0x6e, 0x61, 0x73, 0x74, 0x61, 0x73,
+    0x69, 0x61, 0x00, 0x41, 0x6e, 0x64, 0x65, 0x72, 0x61, 0x00, 0x41, 0x6e,
+    0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x61,
+    0x00, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x65,
+    0x61, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x61, 0x73, 0x00, 0x41, 0x6e,
+    0x64, 0x72, 0x65, 0x65, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x73, 0x00,
+    0x41, 0x6e, 0x64, 0x72, 0x65, 0x77, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x69,
+    0x61, 0x00, 0x41, 0x6e, 0x64, 0x79, 0x00, 0x41, 0x6e, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x00, 0x41, 0x6e, 0x67, 0x65,
+    0x6c, 0x61, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x65, 0x00, 0x41, 0x6e,
+    0x67, 0x65, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c,
+    0x65, 0x73, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x41,
+    0x6e, 0x67, 0x65, 0x6c, 0x69, 0x63, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c,
+    0x69, 0x63, 0x61, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x6b, 0x61,
+    0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x41, 0x6e,
+    0x67, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c,
+    0x69, 0x71, 0x75, 0x65, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x74,
+    0x61, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x41, 0x6e,
+    0x67, 0x65, 0x6c, 0x6f, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x79, 0x6e,
+    0x00, 0x41, 0x6e, 0x67, 0x69, 0x65, 0x00, 0x41, 0x6e, 0x67, 0x69, 0x6c,
+    0x61, 0x00, 0x41, 0x6e, 0x67, 0x6c, 0x61, 0x00, 0x41, 0x6e, 0x67, 0x6c,
+    0x65, 0x00, 0x41, 0x6e, 0x67, 0x6c, 0x65, 0x61, 0x00, 0x41, 0x6e, 0x68,
+    0x00, 0x41, 0x6e, 0x69, 0x62, 0x61, 0x6c, 0x00, 0x41, 0x6e, 0x69, 0x6b,
+    0x61, 0x00, 0x41, 0x6e, 0x69, 0x73, 0x61, 0x00, 0x41, 0x6e, 0x69, 0x73,
+    0x68, 0x61, 0x00, 0x41, 0x6e, 0x69, 0x73, 0x73, 0x61, 0x00, 0x41, 0x6e,
+    0x69, 0x74, 0x61, 0x00, 0x41, 0x6e, 0x69, 0x74, 0x72, 0x61, 0x00, 0x41,
+    0x6e, 0x6a, 0x61, 0x00, 0x41, 0x6e, 0x6a, 0x61, 0x6e, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x41, 0x6e, 0x6a, 0x65, 0x6c, 0x69, 0x63, 0x61, 0x00, 0x41,
+    0x6e, 0x6e, 0x00, 0x41, 0x6e, 0x6e, 0x61, 0x00, 0x41, 0x6e, 0x6e, 0x61,
+    0x62, 0x65, 0x6c, 0x00, 0x41, 0x6e, 0x6e, 0x61, 0x62, 0x65, 0x6c, 0x6c,
+    0x00, 0x41, 0x6e, 0x6e, 0x61, 0x62, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x41,
+    0x6e, 0x6e, 0x61, 0x6c, 0x65, 0x65, 0x00, 0x41, 0x6e, 0x6e, 0x61, 0x6c,
+    0x69, 0x73, 0x61, 0x00, 0x41, 0x6e, 0x6e, 0x61, 0x6d, 0x61, 0x65, 0x00,
+    0x41, 0x6e, 0x6e, 0x61, 0x6d, 0x61, 0x72, 0x69, 0x61, 0x00, 0x41, 0x6e,
+    0x6e, 0x61, 0x6d, 0x61, 0x72, 0x69, 0x65, 0x00, 0x41, 0x6e, 0x6e, 0x65,
+    0x00, 0x41, 0x6e, 0x6e, 0x65, 0x6c, 0x69, 0x65, 0x73, 0x65, 0x00, 0x41,
+    0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x41, 0x6e, 0x6e, 0x65, 0x6d,
+    0x61, 0x72, 0x69, 0x65, 0x00, 0x41, 0x6e, 0x6e, 0x65, 0x74, 0x74, 0x00,
+    0x41, 0x6e, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x41, 0x6e, 0x6e, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x41, 0x6e, 0x6e, 0x69, 0x63, 0x65, 0x00, 0x41,
+    0x6e, 0x6e, 0x69, 0x65, 0x00, 0x41, 0x6e, 0x6e, 0x69, 0x6b, 0x61, 0x00,
+    0x41, 0x6e, 0x6e, 0x69, 0x73, 0x00, 0x41, 0x6e, 0x6e, 0x69, 0x74, 0x61,
+    0x00, 0x41, 0x6e, 0x6e, 0x6d, 0x61, 0x72, 0x69, 0x65, 0x00, 0x41, 0x6e,
+    0x74, 0x68, 0x6f, 0x6e, 0x79, 0x00, 0x41, 0x6e, 0x74, 0x69, 0x6f, 0x6e,
+    0x65, 0x00, 0x41, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x41, 0x6e, 0x74, 0x6f, 0x69, 0x6e, 0x65, 0x00, 0x41, 0x6e, 0x74,
+    0x6f, 0x69, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x41, 0x6e, 0x74, 0x6f,
+    0x6e, 0x00, 0x41, 0x6e, 0x74, 0x6f, 0x6e, 0x65, 0x00, 0x41, 0x6e, 0x74,
+    0x6f, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x41, 0x6e, 0x74, 0x6f, 0x6e,
+    0x65, 0x74, 0x74, 0x65, 0x00, 0x41, 0x6e, 0x74, 0x6f, 0x6e, 0x69, 0x61,
+    0x00, 0x41, 0x6e, 0x74, 0x6f, 0x6e, 0x69, 0x65, 0x74, 0x74, 0x61, 0x00,
+    0x41, 0x6e, 0x74, 0x6f, 0x6e, 0x69, 0x6e, 0x61, 0x00, 0x41, 0x6e, 0x74,
+    0x6f, 0x6e, 0x69, 0x6f, 0x00, 0x41, 0x6e, 0x74, 0x6f, 0x6e, 0x79, 0x00,
+    0x41, 0x6e, 0x74, 0x77, 0x61, 0x6e, 0x00, 0x41, 0x6e, 0x79, 0x61, 0x00,
+    0x41, 0x70, 0x6f, 0x6c, 0x6f, 0x6e, 0x69, 0x61, 0x00, 0x41, 0x70, 0x72,
+    0x69, 0x6c, 0x00, 0x41, 0x70, 0x72, 0x79, 0x6c, 0x00, 0x41, 0x72, 0x61,
+    0x00, 0x41, 0x72, 0x61, 0x63, 0x65, 0x6c, 0x69, 0x00, 0x41, 0x72, 0x61,
+    0x63, 0x65, 0x6c, 0x69, 0x73, 0x00, 0x41, 0x72, 0x61, 0x63, 0x65, 0x6c,
+    0x79, 0x00, 0x41, 0x72, 0x63, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x41, 0x72,
+    0x63, 0x68, 0x69, 0x65, 0x00, 0x41, 0x72, 0x64, 0x61, 0x74, 0x68, 0x00,
+    0x41, 0x72, 0x64, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x41, 0x72, 0x64, 0x65,
+    0x6c, 0x6c, 0x00, 0x41, 0x72, 0x64, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x41,
+    0x72, 0x64, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x41, 0x72, 0x64, 0x65, 0x6e,
+    0x00, 0x41, 0x72, 0x64, 0x69, 0x73, 0x00, 0x41, 0x72, 0x64, 0x69, 0x74,
+    0x68, 0x00, 0x41, 0x72, 0x65, 0x74, 0x68, 0x61, 0x00, 0x41, 0x72, 0x67,
+    0x65, 0x6c, 0x69, 0x61, 0x00, 0x41, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x69,
+    0x6e, 0x61, 0x00, 0x41, 0x72, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x41, 0x72,
+    0x69, 0x61, 0x6e, 0x65, 0x00, 0x41, 0x72, 0x69, 0x61, 0x6e, 0x6e, 0x61,
+    0x00, 0x41, 0x72, 0x69, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x41, 0x72, 0x69,
+    0x63, 0x61, 0x00, 0x41, 0x72, 0x69, 0x65, 0x00, 0x41, 0x72, 0x69, 0x65,
+    0x6c, 0x00, 0x41, 0x72, 0x69, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x41, 0x72,
+    0x6c, 0x61, 0x00, 0x41, 0x72, 0x6c, 0x65, 0x61, 0x6e, 0x00, 0x41, 0x72,
+    0x6c, 0x65, 0x65, 0x6e, 0x00, 0x41, 0x72, 0x6c, 0x65, 0x6e, 0x00, 0x41,
+    0x72, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x41, 0x72, 0x6c, 0x65, 0x6e, 0x65,
+    0x00, 0x41, 0x72, 0x6c, 0x65, 0x74, 0x68, 0x61, 0x00, 0x41, 0x72, 0x6c,
+    0x65, 0x74, 0x74, 0x61, 0x00, 0x41, 0x72, 0x6c, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x41, 0x72, 0x6c, 0x69, 0x65, 0x00, 0x41, 0x72, 0x6c, 0x69, 0x6e,
+    0x64, 0x61, 0x00, 0x41, 0x72, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x41, 0x72,
+    0x6c, 0x79, 0x6e, 0x65, 0x00, 0x41, 0x72, 0x6d, 0x61, 0x6e, 0x64, 0x00,
+    0x41, 0x72, 0x6d, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x41, 0x72, 0x6d, 0x61,
+    0x6e, 0x64, 0x69, 0x6e, 0x61, 0x00, 0x41, 0x72, 0x6d, 0x61, 0x6e, 0x64,
+    0x6f, 0x00, 0x41, 0x72, 0x6d, 0x69, 0x64, 0x61, 0x00, 0x41, 0x72, 0x6d,
+    0x69, 0x6e, 0x64, 0x61, 0x00, 0x41, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x61,
+    0x00, 0x41, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x41, 0x72, 0x6e,
+    0x69, 0x74, 0x61, 0x00, 0x41, 0x72, 0x6e, 0x6f, 0x6c, 0x64, 0x00, 0x41,
+    0x72, 0x6e, 0x6f, 0x6c, 0x64, 0x6f, 0x00, 0x41, 0x72, 0x6e, 0x75, 0x6c,
+    0x66, 0x6f, 0x00, 0x41, 0x72, 0x6f, 0x6e, 0x00, 0x41, 0x72, 0x72, 0x6f,
+    0x6e, 0x00, 0x41, 0x72, 0x74, 0x00, 0x41, 0x72, 0x74, 0x68, 0x75, 0x72,
+    0x00, 0x41, 0x72, 0x74, 0x69, 0x65, 0x00, 0x41, 0x72, 0x74, 0x75, 0x72,
+    0x6f, 0x00, 0x41, 0x72, 0x76, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x41, 0x73,
+    0x61, 0x00, 0x41, 0x73, 0x68, 0x61, 0x00, 0x41, 0x73, 0x68, 0x61, 0x6e,
+    0x74, 0x69, 0x00, 0x41, 0x73, 0x68, 0x65, 0x6c, 0x79, 0x00, 0x41, 0x73,
+    0x68, 0x6c, 0x65, 0x61, 0x00, 0x41, 0x73, 0x68, 0x6c, 0x65, 0x65, 0x00,
+    0x41, 0x73, 0x68, 0x6c, 0x65, 0x69, 0x67, 0x68, 0x00, 0x41, 0x73, 0x68,
+    0x6c, 0x65, 0x79, 0x00, 0x41, 0x73, 0x68, 0x6c, 0x69, 0x00, 0x41, 0x73,
+    0x68, 0x6c, 0x69, 0x65, 0x00, 0x41, 0x73, 0x68, 0x6c, 0x79, 0x00, 0x41,
+    0x73, 0x68, 0x6c, 0x79, 0x6e, 0x00, 0x41, 0x73, 0x68, 0x74, 0x6f, 0x6e,
+    0x00, 0x41, 0x73, 0x69, 0x61, 0x00, 0x41, 0x73, 0x6c, 0x65, 0x79, 0x00,
+    0x41, 0x73, 0x73, 0x75, 0x6e, 0x74, 0x61, 0x00, 0x41, 0x73, 0x74, 0x72,
+    0x69, 0x64, 0x00, 0x41, 0x73, 0x75, 0x6e, 0x63, 0x69, 0x6f, 0x6e, 0x00,
+    0x41, 0x74, 0x68, 0x65, 0x6e, 0x61, 0x00, 0x41, 0x75, 0x62, 0x72, 0x65,
+    0x79, 0x00, 0x41, 0x75, 0x64, 0x69, 0x65, 0x00, 0x41, 0x75, 0x64, 0x72,
+    0x61, 0x00, 0x41, 0x75, 0x64, 0x72, 0x65, 0x61, 0x00, 0x41, 0x75, 0x64,
+    0x72, 0x65, 0x79, 0x00, 0x41, 0x75, 0x64, 0x72, 0x69, 0x61, 0x00, 0x41,
+    0x75, 0x64, 0x72, 0x69, 0x65, 0x00, 0x41, 0x75, 0x64, 0x72, 0x79, 0x00,
+    0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73,
+    0x74, 0x61, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x61,
+    0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x41,
+    0x75, 0x67, 0x75, 0x73, 0x74, 0x75, 0x73, 0x00, 0x41, 0x75, 0x6e, 0x64,
+    0x72, 0x65, 0x61, 0x00, 0x41, 0x75, 0x72, 0x61, 0x00, 0x41, 0x75, 0x72,
+    0x65, 0x61, 0x00, 0x41, 0x75, 0x72, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x41,
+    0x75, 0x72, 0x65, 0x6c, 0x69, 0x6f, 0x00, 0x41, 0x75, 0x72, 0x6f, 0x72,
+    0x61, 0x00, 0x41, 0x75, 0x72, 0x6f, 0x72, 0x65, 0x00, 0x41, 0x75, 0x73,
+    0x74, 0x69, 0x6e, 0x00, 0x41, 0x75, 0x74, 0x75, 0x6d, 0x6e, 0x00, 0x41,
+    0x76, 0x61, 0x00, 0x41, 0x76, 0x65, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x41,
+    0x76, 0x65, 0x72, 0x79, 0x00, 0x41, 0x76, 0x69, 0x73, 0x00, 0x41, 0x76,
+    0x72, 0x69, 0x6c, 0x00, 0x41, 0x77, 0x69, 0x6c, 0x64, 0x61, 0x00, 0x41,
+    0x79, 0x61, 0x6b, 0x6f, 0x00, 0x41, 0x79, 0x61, 0x6e, 0x61, 0x00, 0x41,
+    0x79, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x41, 0x79, 0x65, 0x73, 0x68, 0x61,
+    0x00, 0x41, 0x7a, 0x61, 0x6c, 0x65, 0x65, 0x00, 0x41, 0x7a, 0x75, 0x63,
+    0x65, 0x6e, 0x61, 0x00, 0x41, 0x7a, 0x7a, 0x69, 0x65, 0x00, 0x42, 0x61,
+    0x62, 0x61, 0x72, 0x61, 0x00, 0x42, 0x61, 0x62, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x42, 0x61, 0x69, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x61, 0x6d, 0x62,
+    0x69, 0x00, 0x42, 0x61, 0x6f, 0x00, 0x42, 0x61, 0x72, 0x61, 0x62, 0x61,
+    0x72, 0x61, 0x00, 0x42, 0x61, 0x72, 0x62, 0x00, 0x42, 0x61, 0x72, 0x62,
+    0x61, 0x72, 0x00, 0x42, 0x61, 0x72, 0x62, 0x61, 0x72, 0x61, 0x00, 0x42,
+    0x61, 0x72, 0x62, 0x65, 0x72, 0x61, 0x00, 0x42, 0x61, 0x72, 0x62, 0x69,
+    0x65, 0x00, 0x42, 0x61, 0x72, 0x62, 0x72, 0x61, 0x00, 0x42, 0x61, 0x72,
+    0x69, 0x00, 0x42, 0x61, 0x72, 0x6e, 0x65, 0x79, 0x00, 0x42, 0x61, 0x72,
+    0x72, 0x65, 0x74, 0x74, 0x00, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x00,
+    0x42, 0x61, 0x72, 0x72, 0x79, 0x00, 0x42, 0x61, 0x72, 0x74, 0x00, 0x42,
+    0x61, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x61, 0x73, 0x69, 0x6c, 0x00,
+    0x42, 0x61, 0x73, 0x69, 0x6c, 0x69, 0x61, 0x00, 0x42, 0x65, 0x61, 0x00,
+    0x42, 0x65, 0x61, 0x74, 0x61, 0x00, 0x42, 0x65, 0x61, 0x74, 0x72, 0x69,
+    0x63, 0x65, 0x00, 0x42, 0x65, 0x61, 0x74, 0x72, 0x69, 0x73, 0x00, 0x42,
+    0x65, 0x61, 0x74, 0x72, 0x69, 0x7a, 0x00, 0x42, 0x65, 0x61, 0x75, 0x00,
+    0x42, 0x65, 0x61, 0x75, 0x6c, 0x61, 0x68, 0x00, 0x42, 0x65, 0x62, 0x65,
+    0x00, 0x42, 0x65, 0x63, 0x6b, 0x69, 0x00, 0x42, 0x65, 0x63, 0x6b, 0x69,
+    0x65, 0x00, 0x42, 0x65, 0x63, 0x6b, 0x79, 0x00, 0x42, 0x65, 0x65, 0x00,
+    0x42, 0x65, 0x6c, 0x65, 0x6e, 0x00, 0x42, 0x65, 0x6c, 0x69, 0x61, 0x00,
+    0x42, 0x65, 0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x42, 0x65, 0x6c, 0x6b,
+    0x69, 0x73, 0x00, 0x42, 0x65, 0x6c, 0x6c, 0x00, 0x42, 0x65, 0x6c, 0x6c,
+    0x61, 0x00, 0x42, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x42, 0x65, 0x6c, 0x76,
+    0x61, 0x00, 0x42, 0x65, 0x6e, 0x00, 0x42, 0x65, 0x6e, 0x65, 0x64, 0x69,
+    0x63, 0x74, 0x00, 0x42, 0x65, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x42, 0x65,
+    0x6e, 0x69, 0x74, 0x6f, 0x00, 0x42, 0x65, 0x6e, 0x6a, 0x61, 0x6d, 0x69,
+    0x6e, 0x00, 0x42, 0x65, 0x6e, 0x6e, 0x65, 0x74, 0x74, 0x00, 0x42, 0x65,
+    0x6e, 0x6e, 0x69, 0x65, 0x00, 0x42, 0x65, 0x6e, 0x6e, 0x79, 0x00, 0x42,
+    0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x65, 0x72, 0x65, 0x6e, 0x69,
+    0x63, 0x65, 0x00, 0x42, 0x65, 0x72, 0x6e, 0x61, 0x00, 0x42, 0x65, 0x72,
+    0x6e, 0x61, 0x64, 0x65, 0x74, 0x74, 0x65, 0x00, 0x42, 0x65, 0x72, 0x6e,
+    0x61, 0x64, 0x69, 0x6e, 0x65, 0x00, 0x42, 0x65, 0x72, 0x6e, 0x61, 0x72,
+    0x64, 0x00, 0x42, 0x65, 0x72, 0x6e, 0x61, 0x72, 0x64, 0x61, 0x00, 0x42,
+    0x65, 0x72, 0x6e, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x00, 0x42, 0x65,
+    0x72, 0x6e, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x65, 0x00, 0x42, 0x65, 0x72,
+    0x6e, 0x61, 0x72, 0x64, 0x6f, 0x00, 0x42, 0x65, 0x72, 0x6e, 0x65, 0x69,
+    0x63, 0x65, 0x00, 0x42, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00,
+    0x42, 0x65, 0x72, 0x6e, 0x69, 0x63, 0x65, 0x00, 0x42, 0x65, 0x72, 0x6e,
+    0x69, 0x65, 0x00, 0x42, 0x65, 0x72, 0x6e, 0x69, 0x65, 0x63, 0x65, 0x00,
+    0x42, 0x65, 0x72, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x42, 0x65, 0x72, 0x72,
+    0x79, 0x00, 0x42, 0x65, 0x72, 0x74, 0x00, 0x42, 0x65, 0x72, 0x74, 0x61,
+    0x00, 0x42, 0x65, 0x72, 0x74, 0x68, 0x61, 0x00, 0x42, 0x65, 0x72, 0x74,
+    0x69, 0x65, 0x00, 0x42, 0x65, 0x72, 0x74, 0x72, 0x61, 0x6d, 0x00, 0x42,
+    0x65, 0x72, 0x79, 0x6c, 0x00, 0x42, 0x65, 0x73, 0x73, 0x00, 0x42, 0x65,
+    0x73, 0x73, 0x69, 0x65, 0x00, 0x42, 0x65, 0x74, 0x68, 0x00, 0x42, 0x65,
+    0x74, 0x68, 0x61, 0x6e, 0x69, 0x65, 0x00, 0x42, 0x65, 0x74, 0x68, 0x61,
+    0x6e, 0x6e, 0x00, 0x42, 0x65, 0x74, 0x68, 0x61, 0x6e, 0x79, 0x00, 0x42,
+    0x65, 0x74, 0x68, 0x65, 0x6c, 0x00, 0x42, 0x65, 0x74, 0x73, 0x65, 0x79,
+    0x00, 0x42, 0x65, 0x74, 0x73, 0x79, 0x00, 0x42, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x42, 0x65, 0x74, 0x74, 0x69, 0x65, 0x00, 0x42, 0x65, 0x74, 0x74,
+    0x69, 0x6e, 0x61, 0x00, 0x42, 0x65, 0x74, 0x74, 0x79, 0x00, 0x42, 0x65,
+    0x74, 0x74, 0x79, 0x61, 0x6e, 0x6e, 0x00, 0x42, 0x65, 0x74, 0x74, 0x79,
+    0x65, 0x00, 0x42, 0x65, 0x75, 0x6c, 0x61, 0x00, 0x42, 0x65, 0x75, 0x6c,
+    0x61, 0x68, 0x00, 0x42, 0x65, 0x76, 0x00, 0x42, 0x65, 0x76, 0x65, 0x72,
+    0x6c, 0x65, 0x65, 0x00, 0x42, 0x65, 0x76, 0x65, 0x72, 0x6c, 0x65, 0x79,
+    0x00, 0x42, 0x65, 0x76, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x42, 0x69, 0x61,
+    0x6e, 0x63, 0x61, 0x00, 0x42, 0x69, 0x62, 0x69, 0x00, 0x42, 0x69, 0x6c,
+    0x6c, 0x00, 0x42, 0x69, 0x6c, 0x6c, 0x69, 0x00, 0x42, 0x69, 0x6c, 0x6c,
+    0x69, 0x65, 0x00, 0x42, 0x69, 0x6c, 0x6c, 0x79, 0x00, 0x42, 0x69, 0x6c,
+    0x6c, 0x79, 0x65, 0x00, 0x42, 0x69, 0x72, 0x64, 0x69, 0x65, 0x00, 0x42,
+    0x69, 0x72, 0x67, 0x69, 0x74, 0x00, 0x42, 0x6c, 0x61, 0x69, 0x6e, 0x65,
+    0x00, 0x42, 0x6c, 0x61, 0x69, 0x72, 0x00, 0x42, 0x6c, 0x61, 0x6b, 0x65,
+    0x00, 0x42, 0x6c, 0x61, 0x6e, 0x63, 0x61, 0x00, 0x42, 0x6c, 0x61, 0x6e,
+    0x63, 0x68, 0x00, 0x42, 0x6c, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x00, 0x42,
+    0x6c, 0x6f, 0x6e, 0x64, 0x65, 0x6c, 0x6c, 0x00, 0x42, 0x6c, 0x6f, 0x73,
+    0x73, 0x6f, 0x6d, 0x00, 0x42, 0x6c, 0x79, 0x74, 0x68, 0x65, 0x00, 0x42,
+    0x6f, 0x00, 0x42, 0x6f, 0x62, 0x00, 0x42, 0x6f, 0x62, 0x62, 0x69, 0x00,
+    0x42, 0x6f, 0x62, 0x62, 0x69, 0x65, 0x00, 0x42, 0x6f, 0x62, 0x62, 0x79,
+    0x00, 0x42, 0x6f, 0x62, 0x62, 0x79, 0x65, 0x00, 0x42, 0x6f, 0x62, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x42, 0x6f, 0x6b, 0x00, 0x42, 0x6f, 0x6e, 0x67,
+    0x00, 0x42, 0x6f, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x42, 0x6f, 0x6e, 0x6e,
+    0x69, 0x65, 0x00, 0x42, 0x6f, 0x6e, 0x6e, 0x79, 0x00, 0x42, 0x6f, 0x6f,
+    0x6b, 0x65, 0x72, 0x00, 0x42, 0x6f, 0x72, 0x69, 0x73, 0x00, 0x42, 0x6f,
+    0x79, 0x63, 0x65, 0x00, 0x42, 0x6f, 0x79, 0x64, 0x00, 0x42, 0x72, 0x61,
+    0x64, 0x00, 0x42, 0x72, 0x61, 0x64, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x42,
+    0x72, 0x61, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x72, 0x61, 0x64, 0x6c,
+    0x79, 0x00, 0x42, 0x72, 0x61, 0x64, 0x79, 0x00, 0x42, 0x72, 0x61, 0x69,
+    0x6e, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x42, 0x72, 0x61,
+    0x6e, 0x64, 0x65, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x64, 0x65, 0x65, 0x00,
+    0x42, 0x72, 0x61, 0x6e, 0x64, 0x65, 0x6e, 0x00, 0x42, 0x72, 0x61, 0x6e,
+    0x64, 0x69, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x64, 0x69, 0x65, 0x00, 0x42,
+    0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x64,
+    0x79, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x74, 0x00, 0x42, 0x72, 0x65, 0x61,
+    0x6e, 0x61, 0x00, 0x42, 0x72, 0x65, 0x61, 0x6e, 0x6e, 0x00, 0x42, 0x72,
+    0x65, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x42, 0x72, 0x65, 0x61, 0x6e, 0x6e,
+    0x65, 0x00, 0x42, 0x72, 0x65, 0x65, 0x00, 0x42, 0x72, 0x65, 0x6e, 0x64,
+    0x61, 0x00, 0x42, 0x72, 0x65, 0x6e, 0x64, 0x61, 0x6e, 0x00, 0x42, 0x72,
+    0x65, 0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x65, 0x6e, 0x6e, 0x61,
+    0x00, 0x42, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x42, 0x72, 0x65, 0x6e, 0x74,
+    0x6f, 0x6e, 0x00, 0x42, 0x72, 0x65, 0x74, 0x00, 0x42, 0x72, 0x65, 0x74,
+    0x74, 0x00, 0x42, 0x72, 0x69, 0x61, 0x6e, 0x00, 0x42, 0x72, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x42, 0x72, 0x69, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x42,
+    0x72, 0x69, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x42, 0x72, 0x69, 0x63, 0x65,
+    0x00, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x74, 0x00, 0x42, 0x72, 0x69,
+    0x64, 0x67, 0x65, 0x74, 0x74, 0x00, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x42, 0x72, 0x69, 0x67, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x42, 0x72, 0x69, 0x67, 0x69, 0x64, 0x00, 0x42, 0x72, 0x69, 0x67,
+    0x69, 0x64, 0x61, 0x00, 0x42, 0x72, 0x69, 0x67, 0x69, 0x74, 0x74, 0x65,
+    0x00, 0x42, 0x72, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x42, 0x72, 0x69, 0x74,
+    0x61, 0x6e, 0x79, 0x00, 0x42, 0x72, 0x69, 0x74, 0x6e, 0x65, 0x79, 0x00,
+    0x42, 0x72, 0x69, 0x74, 0x6e, 0x69, 0x00, 0x42, 0x72, 0x69, 0x74, 0x74,
+    0x00, 0x42, 0x72, 0x69, 0x74, 0x74, 0x61, 0x00, 0x42, 0x72, 0x69, 0x74,
+    0x74, 0x61, 0x6e, 0x65, 0x79, 0x00, 0x42, 0x72, 0x69, 0x74, 0x74, 0x61,
+    0x6e, 0x69, 0x00, 0x42, 0x72, 0x69, 0x74, 0x74, 0x61, 0x6e, 0x69, 0x65,
+    0x00, 0x42, 0x72, 0x69, 0x74, 0x74, 0x61, 0x6e, 0x79, 0x00, 0x42, 0x72,
+    0x69, 0x74, 0x74, 0x65, 0x6e, 0x79, 0x00, 0x42, 0x72, 0x69, 0x74, 0x74,
+    0x6e, 0x65, 0x79, 0x00, 0x42, 0x72, 0x69, 0x74, 0x74, 0x6e, 0x69, 0x00,
+    0x42, 0x72, 0x69, 0x74, 0x74, 0x6e, 0x79, 0x00, 0x42, 0x72, 0x6f, 0x63,
+    0x6b, 0x00, 0x42, 0x72, 0x6f, 0x64, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x00,
+    0x42, 0x72, 0x6f, 0x6e, 0x77, 0x79, 0x6e, 0x00, 0x42, 0x72, 0x6f, 0x6f,
+    0x6b, 0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x65, 0x00, 0x42, 0x72, 0x6f,
+    0x6f, 0x6b, 0x73, 0x00, 0x42, 0x72, 0x75, 0x63, 0x65, 0x00, 0x42, 0x72,
+    0x75, 0x6e, 0x61, 0x00, 0x42, 0x72, 0x75, 0x6e, 0x69, 0x6c, 0x64, 0x61,
+    0x00, 0x42, 0x72, 0x75, 0x6e, 0x6f, 0x00, 0x42, 0x72, 0x79, 0x61, 0x6e,
+    0x00, 0x42, 0x72, 0x79, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x42, 0x72, 0x79,
+    0x61, 0x6e, 0x74, 0x00, 0x42, 0x72, 0x79, 0x63, 0x65, 0x00, 0x42, 0x72,
+    0x79, 0x6e, 0x6e, 0x00, 0x42, 0x72, 0x79, 0x6f, 0x6e, 0x00, 0x42, 0x75,
+    0x63, 0x6b, 0x00, 0x42, 0x75, 0x64, 0x00, 0x42, 0x75, 0x64, 0x64, 0x79,
+    0x00, 0x42, 0x75, 0x65, 0x6e, 0x61, 0x00, 0x42, 0x75, 0x66, 0x66, 0x79,
+    0x00, 0x42, 0x75, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x42, 0x75, 0x6c, 0x61,
+    0x00, 0x42, 0x75, 0x6c, 0x61, 0x68, 0x00, 0x42, 0x75, 0x6e, 0x6e, 0x79,
+    0x00, 0x42, 0x75, 0x72, 0x6c, 0x00, 0x42, 0x75, 0x72, 0x6d, 0x61, 0x00,
+    0x42, 0x75, 0x72, 0x74, 0x00, 0x42, 0x75, 0x72, 0x74, 0x6f, 0x6e, 0x00,
+    0x42, 0x75, 0x73, 0x74, 0x65, 0x72, 0x00, 0x42, 0x79, 0x72, 0x6f, 0x6e,
+    0x00, 0x43, 0x61, 0x69, 0x74, 0x6c, 0x69, 0x6e, 0x00, 0x43, 0x61, 0x69,
+    0x74, 0x6c, 0x79, 0x6e, 0x00, 0x43, 0x61, 0x6c, 0x61, 0x6e, 0x64, 0x72,
+    0x61, 0x00, 0x43, 0x61, 0x6c, 0x65, 0x62, 0x00, 0x43, 0x61, 0x6c, 0x69,
+    0x73, 0x74, 0x61, 0x00, 0x43, 0x61, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x43,
+    0x61, 0x6c, 0x76, 0x69, 0x6e, 0x00, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x69,
+    0x61, 0x00, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x6c, 0x69, 0x61, 0x00, 0x43,
+    0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x6d, 0x69, 0x00,
+    0x43, 0x61, 0x6d, 0x69, 0x65, 0x00, 0x43, 0x61, 0x6d, 0x69, 0x6c, 0x61,
+    0x00, 0x43, 0x61, 0x6d, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x43, 0x61, 0x6d,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x43, 0x61, 0x6d, 0x6d, 0x69, 0x65, 0x00,
+    0x43, 0x61, 0x6d, 0x6d, 0x79, 0x00, 0x43, 0x61, 0x6e, 0x64, 0x61, 0x63,
+    0x65, 0x00, 0x43, 0x61, 0x6e, 0x64, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x43,
+    0x61, 0x6e, 0x64, 0x65, 0x6c, 0x61, 0x72, 0x69, 0x61, 0x00, 0x43, 0x61,
+    0x6e, 0x64, 0x69, 0x00, 0x43, 0x61, 0x6e, 0x64, 0x69, 0x63, 0x65, 0x00,
+    0x43, 0x61, 0x6e, 0x64, 0x69, 0x64, 0x61, 0x00, 0x43, 0x61, 0x6e, 0x64,
+    0x69, 0x65, 0x00, 0x43, 0x61, 0x6e, 0x64, 0x69, 0x73, 0x00, 0x43, 0x61,
+    0x6e, 0x64, 0x72, 0x61, 0x00, 0x43, 0x61, 0x6e, 0x64, 0x79, 0x00, 0x43,
+    0x61, 0x6e, 0x64, 0x79, 0x63, 0x65, 0x00, 0x43, 0x61, 0x70, 0x72, 0x69,
+    0x63, 0x65, 0x00, 0x43, 0x61, 0x72, 0x61, 0x00, 0x43, 0x61, 0x72, 0x65,
+    0x6e, 0x00, 0x43, 0x61, 0x72, 0x65, 0x79, 0x00, 0x43, 0x61, 0x72, 0x69,
+    0x00, 0x43, 0x61, 0x72, 0x69, 0x64, 0x61, 0x64, 0x00, 0x43, 0x61, 0x72,
+    0x69, 0x65, 0x00, 0x43, 0x61, 0x72, 0x69, 0x6e, 0x00, 0x43, 0x61, 0x72,
+    0x69, 0x6e, 0x61, 0x00, 0x43, 0x61, 0x72, 0x69, 0x73, 0x61, 0x00, 0x43,
+    0x61, 0x72, 0x69, 0x73, 0x73, 0x61, 0x00, 0x43, 0x61, 0x72, 0x69, 0x74,
+    0x61, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x61,
+    0x00, 0x43, 0x61, 0x72, 0x6c, 0x65, 0x65, 0x00, 0x43, 0x61, 0x72, 0x6c,
+    0x65, 0x65, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x65, 0x6e, 0x61, 0x00,
+    0x43, 0x61, 0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x43, 0x61, 0x72, 0x6c,
+    0x65, 0x74, 0x74, 0x61, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x65, 0x79, 0x00,
+    0x43, 0x61, 0x72, 0x6c, 0x69, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x69, 0x65,
+    0x00, 0x43, 0x61, 0x72, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x61, 0x72,
+    0x6c, 0x69, 0x74, 0x61, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x6f, 0x00, 0x43,
+    0x61, 0x72, 0x6c, 0x6f, 0x73, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x6f, 0x74,
+    0x61, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x6f, 0x74, 0x74, 0x61, 0x00, 0x43,
+    0x61, 0x72, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x79,
+    0x00, 0x43, 0x61, 0x72, 0x6c, 0x79, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x6d,
+    0x61, 0x00, 0x43, 0x61, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x43, 0x61, 0x72,
+    0x6d, 0x65, 0x6c, 0x00, 0x43, 0x61, 0x72, 0x6d, 0x65, 0x6c, 0x61, 0x00,
+    0x43, 0x61, 0x72, 0x6d, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x43, 0x61, 0x72,
+    0x6d, 0x65, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x61, 0x72, 0x6d, 0x65,
+    0x6c, 0x69, 0x74, 0x61, 0x00, 0x43, 0x61, 0x72, 0x6d, 0x65, 0x6c, 0x6c,
+    0x61, 0x00, 0x43, 0x61, 0x72, 0x6d, 0x65, 0x6c, 0x6f, 0x00, 0x43, 0x61,
+    0x72, 0x6d, 0x65, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x61,
+    0x00, 0x43, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x61, 0x72,
+    0x6d, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x00, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x61, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x61, 0x6e,
+    0x6e, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x65, 0x00, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x65, 0x65, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x6c, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x79, 0x6e, 0x00, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x79, 0x6e, 0x65, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x79, 0x6e, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6e, 0x00, 0x43, 0x61,
+    0x72, 0x6f, 0x79, 0x6c, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x72, 0x69, 0x00,
+    0x43, 0x61, 0x72, 0x72, 0x69, 0x65, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f,
+    0x6c, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x00, 0x43, 0x61,
+    0x72, 0x72, 0x79, 0x00, 0x43, 0x61, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x43,
+    0x61, 0x72, 0x74, 0x65, 0x72, 0x00, 0x43, 0x61, 0x72, 0x79, 0x00, 0x43,
+    0x61, 0x72, 0x79, 0x6c, 0x00, 0x43, 0x61, 0x72, 0x79, 0x6c, 0x6f, 0x6e,
+    0x00, 0x43, 0x61, 0x72, 0x79, 0x6e, 0x00, 0x43, 0x61, 0x73, 0x61, 0x6e,
+    0x64, 0x72, 0x61, 0x00, 0x43, 0x61, 0x73, 0x65, 0x79, 0x00, 0x43, 0x61,
+    0x73, 0x69, 0x65, 0x00, 0x43, 0x61, 0x73, 0x69, 0x6d, 0x69, 0x72, 0x61,
+    0x00, 0x43, 0x61, 0x73, 0x73, 0x61, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x43,
+    0x61, 0x73, 0x73, 0x61, 0x75, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x43, 0x61,
+    0x73, 0x73, 0x65, 0x79, 0x00, 0x43, 0x61, 0x73, 0x73, 0x69, 0x00, 0x43,
+    0x61, 0x73, 0x73, 0x69, 0x64, 0x79, 0x00, 0x43, 0x61, 0x73, 0x73, 0x69,
+    0x65, 0x00, 0x43, 0x61, 0x73, 0x73, 0x6f, 0x6e, 0x64, 0x72, 0x61, 0x00,
+    0x43, 0x61, 0x73, 0x73, 0x79, 0x00, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x43, 0x61, 0x74, 0x61, 0x72, 0x69, 0x6e, 0x61, 0x00,
+    0x43, 0x61, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x61, 0x74,
+    0x68, 0x61, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x61, 0x74, 0x68, 0x65,
+    0x72, 0x69, 0x6e, 0x00, 0x43, 0x61, 0x74, 0x68, 0x65, 0x72, 0x69, 0x6e,
+    0x61, 0x00, 0x43, 0x61, 0x74, 0x68, 0x65, 0x72, 0x69, 0x6e, 0x65, 0x00,
+    0x43, 0x61, 0x74, 0x68, 0x65, 0x72, 0x6e, 0x00, 0x43, 0x61, 0x74, 0x68,
+    0x65, 0x72, 0x79, 0x6e, 0x00, 0x43, 0x61, 0x74, 0x68, 0x65, 0x79, 0x00,
+    0x43, 0x61, 0x74, 0x68, 0x69, 0x00, 0x43, 0x61, 0x74, 0x68, 0x69, 0x65,
+    0x00, 0x43, 0x61, 0x74, 0x68, 0x6c, 0x65, 0x65, 0x6e, 0x00, 0x43, 0x61,
+    0x74, 0x68, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x61, 0x74, 0x68, 0x72,
+    0x79, 0x6e, 0x00, 0x43, 0x61, 0x74, 0x68, 0x79, 0x00, 0x43, 0x61, 0x74,
+    0x69, 0x6e, 0x61, 0x00, 0x43, 0x61, 0x74, 0x72, 0x69, 0x63, 0x65, 0x00,
+    0x43, 0x61, 0x74, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x61, 0x79, 0x6c,
+    0x61, 0x00, 0x43, 0x65, 0x63, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x43, 0x65,
+    0x63, 0x69, 0x6c, 0x00, 0x43, 0x65, 0x63, 0x69, 0x6c, 0x61, 0x00, 0x43,
+    0x65, 0x63, 0x69, 0x6c, 0x65, 0x00, 0x43, 0x65, 0x63, 0x69, 0x6c, 0x69,
+    0x61, 0x00, 0x43, 0x65, 0x63, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x43, 0x65,
+    0x63, 0x69, 0x6c, 0x79, 0x00, 0x43, 0x65, 0x64, 0x72, 0x69, 0x63, 0x00,
+    0x43, 0x65, 0x64, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x43, 0x65, 0x6c, 0x65,
+    0x6e, 0x61, 0x00, 0x43, 0x65, 0x6c, 0x65, 0x73, 0x74, 0x61, 0x00, 0x43,
+    0x65, 0x6c, 0x65, 0x73, 0x74, 0x65, 0x00, 0x43, 0x65, 0x6c, 0x65, 0x73,
+    0x74, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x65, 0x6c, 0x65, 0x73, 0x74, 0x69,
+    0x6e, 0x65, 0x00, 0x43, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x43, 0x65, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x43, 0x65, 0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00,
+    0x43, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x65, 0x6c, 0x73, 0x61,
+    0x00, 0x43, 0x65, 0x6f, 0x6c, 0x61, 0x00, 0x43, 0x65, 0x73, 0x61, 0x72,
+    0x00, 0x43, 0x68, 0x61, 0x64, 0x00, 0x43, 0x68, 0x61, 0x64, 0x77, 0x69,
+    0x63, 0x6b, 0x00, 0x43, 0x68, 0x61, 0x65, 0x00, 0x43, 0x68, 0x61, 0x6e,
+    0x00, 0x43, 0x68, 0x61, 0x6e, 0x61, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x63,
+    0x65, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x43, 0x68, 0x61,
+    0x6e, 0x64, 0x72, 0x61, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x65, 0x6c, 0x00,
+    0x43, 0x68, 0x61, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x43, 0x68, 0x61, 0x6e,
+    0x65, 0x6c, 0x6c, 0x65, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x00, 0x43,
+    0x68, 0x61, 0x6e, 0x74, 0x61, 0x6c, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x74,
+    0x61, 0x79, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x74, 0x65, 0x00, 0x43, 0x68,
+    0x61, 0x6e, 0x74, 0x65, 0x6c, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x74, 0x65,
+    0x6c, 0x6c, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x74, 0x65, 0x6c, 0x6c, 0x65,
+    0x00, 0x43, 0x68, 0x61, 0x72, 0x61, 0x00, 0x43, 0x68, 0x61, 0x72, 0x69,
+    0x73, 0x00, 0x43, 0x68, 0x61, 0x72, 0x69, 0x73, 0x65, 0x00, 0x43, 0x68,
+    0x61, 0x72, 0x69, 0x73, 0x73, 0x61, 0x00, 0x43, 0x68, 0x61, 0x72, 0x69,
+    0x73, 0x73, 0x65, 0x00, 0x43, 0x68, 0x61, 0x72, 0x69, 0x74, 0x61, 0x00,
+    0x43, 0x68, 0x61, 0x72, 0x69, 0x74, 0x79, 0x00, 0x43, 0x68, 0x61, 0x72,
+    0x6c, 0x61, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x65, 0x6e, 0x00,
+    0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x43, 0x68, 0x61,
+    0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65,
+    0x73, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x73, 0x65, 0x74, 0x74,
+    0x61, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x00,
+    0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x43, 0x68, 0x61, 0x72,
+    0x6c, 0x69, 0x65, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x69, 0x6e, 0x65,
+    0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x6f, 0x74, 0x74, 0x00, 0x43, 0x68,
+    0x61, 0x72, 0x6c, 0x6f, 0x74, 0x74, 0x65, 0x00, 0x43, 0x68, 0x61, 0x72,
+    0x6c, 0x73, 0x69, 0x65, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x79, 0x6e,
+    0x00, 0x43, 0x68, 0x61, 0x72, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x43, 0x68,
+    0x61, 0x72, 0x6d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x68, 0x61, 0x72,
+    0x6f, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x00, 0x43, 0x68, 0x61, 0x73, 0x00,
+    0x43, 0x68, 0x61, 0x73, 0x65, 0x00, 0x43, 0x68, 0x61, 0x73, 0x69, 0x64,
+    0x79, 0x00, 0x43, 0x68, 0x61, 0x73, 0x69, 0x74, 0x79, 0x00, 0x43, 0x68,
+    0x61, 0x73, 0x73, 0x69, 0x64, 0x79, 0x00, 0x43, 0x68, 0x61, 0x73, 0x74,
+    0x69, 0x74, 0x79, 0x00, 0x43, 0x68, 0x61, 0x75, 0x00, 0x43, 0x68, 0x61,
+    0x75, 0x6e, 0x63, 0x65, 0x79, 0x00, 0x43, 0x68, 0x61, 0x79, 0x61, 0x00,
+    0x43, 0x68, 0x65, 0x6c, 0x73, 0x65, 0x61, 0x00, 0x43, 0x68, 0x65, 0x6c,
+    0x73, 0x65, 0x79, 0x00, 0x43, 0x68, 0x65, 0x6c, 0x73, 0x69, 0x65, 0x00,
+    0x43, 0x68, 0x65, 0x72, 0x00, 0x43, 0x68, 0x65, 0x72, 0x65, 0x00, 0x43,
+    0x68, 0x65, 0x72, 0x65, 0x65, 0x00, 0x43, 0x68, 0x65, 0x72, 0x65, 0x6c,
+    0x6c, 0x65, 0x00, 0x43, 0x68, 0x65, 0x72, 0x69, 0x00, 0x43, 0x68, 0x65,
+    0x72, 0x69, 0x65, 0x00, 0x43, 0x68, 0x65, 0x72, 0x69, 0x6c, 0x79, 0x6e,
+    0x00, 0x43, 0x68, 0x65, 0x72, 0x69, 0x73, 0x65, 0x00, 0x43, 0x68, 0x65,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x43, 0x68, 0x65, 0x72, 0x6c, 0x79, 0x00,
+    0x43, 0x68, 0x65, 0x72, 0x6c, 0x79, 0x6e, 0x00, 0x43, 0x68, 0x65, 0x72,
+    0x72, 0x69, 0x00, 0x43, 0x68, 0x65, 0x72, 0x72, 0x69, 0x65, 0x00, 0x43,
+    0x68, 0x65, 0x72, 0x72, 0x79, 0x00, 0x43, 0x68, 0x65, 0x72, 0x72, 0x79,
+    0x6c, 0x00, 0x43, 0x68, 0x65, 0x72, 0x79, 0x00, 0x43, 0x68, 0x65, 0x72,
+    0x79, 0x6c, 0x00, 0x43, 0x68, 0x65, 0x72, 0x79, 0x6c, 0x65, 0x00, 0x43,
+    0x68, 0x65, 0x72, 0x79, 0x6c, 0x6c, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74,
+    0x65, 0x72, 0x00, 0x43, 0x68, 0x65, 0x74, 0x00, 0x43, 0x68, 0x65, 0x79,
+    0x65, 0x6e, 0x6e, 0x65, 0x00, 0x43, 0x68, 0x69, 0x00, 0x43, 0x68, 0x69,
+    0x61, 0x00, 0x43, 0x68, 0x69, 0x65, 0x6b, 0x6f, 0x00, 0x43, 0x68, 0x69,
+    0x6e, 0x00, 0x43, 0x68, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x68, 0x69, 0x6e,
+    0x67, 0x00, 0x43, 0x68, 0x69, 0x71, 0x75, 0x69, 0x74, 0x61, 0x00, 0x43,
+    0x68, 0x6c, 0x6f, 0x65, 0x00, 0x43, 0x68, 0x6f, 0x6e, 0x67, 0x00, 0x43,
+    0x68, 0x72, 0x69, 0x73, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x73, 0x79,
+    0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x61, 0x00, 0x43, 0x68, 0x72,
+    0x69, 0x73, 0x74, 0x61, 0x6c, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74,
+    0x65, 0x65, 0x6e, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x65, 0x6c,
+    0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x00, 0x43, 0x68,
+    0x72, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x61, 0x00, 0x43, 0x68, 0x72, 0x69,
+    0x73, 0x74, 0x65, 0x6e, 0x65, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74,
+    0x69, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x61, 0x00, 0x43,
+    0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x00, 0x43, 0x68, 0x72,
+    0x69, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x43, 0x68, 0x72, 0x69,
+    0x73, 0x74, 0x69, 0x61, 0x6e, 0x65, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73,
+    0x74, 0x69, 0x65, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x6e,
+    0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x43,
+    0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x68, 0x72,
+    0x69, 0x73, 0x74, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x43, 0x68, 0x72, 0x69,
+    0x73, 0x74, 0x6f, 0x70, 0x65, 0x72, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73,
+    0x74, 0x6f, 0x70, 0x68, 0x65, 0x72, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73,
+    0x74, 0x79, 0x00, 0x43, 0x68, 0x72, 0x79, 0x73, 0x74, 0x61, 0x6c, 0x00,
+    0x43, 0x68, 0x75, 0x00, 0x43, 0x68, 0x75, 0x63, 0x6b, 0x00, 0x43, 0x68,
+    0x75, 0x6e, 0x00, 0x43, 0x68, 0x75, 0x6e, 0x67, 0x00, 0x43, 0x69, 0x61,
+    0x72, 0x61, 0x00, 0x43, 0x69, 0x63, 0x65, 0x6c, 0x79, 0x00, 0x43, 0x69,
+    0x65, 0x72, 0x61, 0x00, 0x43, 0x69, 0x65, 0x72, 0x72, 0x61, 0x00, 0x43,
+    0x69, 0x6e, 0x64, 0x61, 0x00, 0x43, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x65,
+    0x6c, 0x6c, 0x61, 0x00, 0x43, 0x69, 0x6e, 0x64, 0x69, 0x00, 0x43, 0x69,
+    0x6e, 0x64, 0x69, 0x65, 0x00, 0x43, 0x69, 0x6e, 0x64, 0x79, 0x00, 0x43,
+    0x69, 0x6e, 0x74, 0x68, 0x69, 0x61, 0x00, 0x43, 0x69, 0x72, 0x61, 0x00,
+    0x43, 0x6c, 0x61, 0x69, 0x72, 0x00, 0x43, 0x6c, 0x61, 0x69, 0x72, 0x65,
+    0x00, 0x43, 0x6c, 0x61, 0x72, 0x61, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x65,
+    0x00, 0x43, 0x6c, 0x61, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x43, 0x6c,
+    0x61, 0x72, 0x65, 0x74, 0x68, 0x61, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x65,
+    0x74, 0x74, 0x61, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x69, 0x62, 0x65, 0x6c,
+    0x00, 0x43, 0x6c, 0x61, 0x72, 0x69, 0x63, 0x65, 0x00, 0x43, 0x6c, 0x61,
+    0x72, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x69, 0x6e,
+    0x65, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x69, 0x73, 0x00, 0x43, 0x6c, 0x61,
+    0x72, 0x69, 0x73, 0x61, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x69, 0x73, 0x73,
+    0x61, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x69, 0x74, 0x61, 0x00, 0x43, 0x6c,
+    0x61, 0x72, 0x6b, 0x00, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x65, 0x00,
+    0x43, 0x6c, 0x61, 0x75, 0x64, 0x00, 0x43, 0x6c, 0x61, 0x75, 0x64, 0x65,
+    0x00, 0x43, 0x6c, 0x61, 0x75, 0x64, 0x65, 0x74, 0x74, 0x65, 0x00, 0x43,
+    0x6c, 0x61, 0x75, 0x64, 0x69, 0x61, 0x00, 0x43, 0x6c, 0x61, 0x75, 0x64,
+    0x69, 0x65, 0x00, 0x43, 0x6c, 0x61, 0x75, 0x64, 0x69, 0x6e, 0x65, 0x00,
+    0x43, 0x6c, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x00, 0x43, 0x6c, 0x61, 0x79,
+    0x00, 0x43, 0x6c, 0x61, 0x79, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6c, 0x65,
+    0x6c, 0x69, 0x61, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x63, 0x69,
+    0x61, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x43, 0x6c,
+    0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x65,
+    0x6e, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x65, 0x6e,
+    0x74, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x6d, 0x69, 0x65,
+    0x00, 0x43, 0x6c, 0x65, 0x6f, 0x00, 0x43, 0x6c, 0x65, 0x6f, 0x70, 0x61,
+    0x74, 0x72, 0x61, 0x00, 0x43, 0x6c, 0x65, 0x6f, 0x72, 0x61, 0x00, 0x43,
+    0x6c, 0x65, 0x6f, 0x74, 0x69, 0x6c, 0x64, 0x65, 0x00, 0x43, 0x6c, 0x65,
+    0x74, 0x61, 0x00, 0x43, 0x6c, 0x65, 0x74, 0x75, 0x73, 0x00, 0x43, 0x6c,
+    0x65, 0x76, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x43, 0x6c, 0x69, 0x66,
+    0x66, 0x00, 0x43, 0x6c, 0x69, 0x66, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x43,
+    0x6c, 0x69, 0x66, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6c, 0x69, 0x6e, 0x74,
+    0x00, 0x43, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6c, 0x6f,
+    0x72, 0x61, 0x00, 0x43, 0x6c, 0x6f, 0x72, 0x69, 0x6e, 0x64, 0x61, 0x00,
+    0x43, 0x6c, 0x6f, 0x74, 0x69, 0x6c, 0x64, 0x65, 0x00, 0x43, 0x6c, 0x79,
+    0x64, 0x65, 0x00, 0x43, 0x6f, 0x64, 0x69, 0x00, 0x43, 0x6f, 0x64, 0x79,
+    0x00, 0x43, 0x6f, 0x6c, 0x62, 0x79, 0x00, 0x43, 0x6f, 0x6c, 0x65, 0x00,
+    0x43, 0x6f, 0x6c, 0x65, 0x65, 0x6e, 0x00, 0x43, 0x6f, 0x6c, 0x65, 0x6d,
+    0x61, 0x6e, 0x00, 0x43, 0x6f, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x43, 0x6f,
+    0x6c, 0x65, 0x74, 0x74, 0x61, 0x00, 0x43, 0x6f, 0x6c, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x43, 0x6f, 0x6c, 0x69, 0x6e, 0x00, 0x43, 0x6f, 0x6c, 0x6c,
+    0x65, 0x65, 0x6e, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x43,
+    0x6f, 0x6c, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x00, 0x43,
+    0x6f, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62,
+    0x75, 0x73, 0x00, 0x43, 0x6f, 0x6e, 0x63, 0x65, 0x70, 0x63, 0x69, 0x6f,
+    0x6e, 0x00, 0x43, 0x6f, 0x6e, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+    0x00, 0x43, 0x6f, 0x6e, 0x63, 0x65, 0x74, 0x74, 0x61, 0x00, 0x43, 0x6f,
+    0x6e, 0x63, 0x68, 0x61, 0x00, 0x43, 0x6f, 0x6e, 0x63, 0x68, 0x69, 0x74,
+    0x61, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x43, 0x6f, 0x6e,
+    0x72, 0x61, 0x64, 0x00, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
+    0x65, 0x00, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x65, 0x6c, 0x61, 0x00, 0x43,
+    0x6f, 0x6e, 0x73, 0x75, 0x65, 0x6c, 0x6f, 0x00, 0x43, 0x6f, 0x6e, 0x74,
+    0x65, 0x73, 0x73, 0x61, 0x00, 0x43, 0x6f, 0x72, 0x61, 0x00, 0x43, 0x6f,
+    0x72, 0x61, 0x6c, 0x00, 0x43, 0x6f, 0x72, 0x61, 0x6c, 0x65, 0x65, 0x00,
+    0x43, 0x6f, 0x72, 0x61, 0x6c, 0x69, 0x65, 0x00, 0x43, 0x6f, 0x72, 0x61,
+    0x7a, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x72, 0x64, 0x65, 0x6c, 0x69, 0x61,
+    0x00, 0x43, 0x6f, 0x72, 0x64, 0x65, 0x6c, 0x6c, 0x00, 0x43, 0x6f, 0x72,
+    0x64, 0x69, 0x61, 0x00, 0x43, 0x6f, 0x72, 0x64, 0x69, 0x65, 0x00, 0x43,
+    0x6f, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x43, 0x6f, 0x72, 0x65, 0x6e, 0x65,
+    0x00, 0x43, 0x6f, 0x72, 0x65, 0x74, 0x74, 0x61, 0x00, 0x43, 0x6f, 0x72,
+    0x65, 0x79, 0x00, 0x43, 0x6f, 0x72, 0x69, 0x00, 0x43, 0x6f, 0x72, 0x69,
+    0x65, 0x00, 0x43, 0x6f, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x6f, 0x72,
+    0x69, 0x6e, 0x65, 0x00, 0x43, 0x6f, 0x72, 0x69, 0x6e, 0x6e, 0x61, 0x00,
+    0x43, 0x6f, 0x72, 0x69, 0x6e, 0x6e, 0x65, 0x00, 0x43, 0x6f, 0x72, 0x6c,
+    0x69, 0x73, 0x73, 0x00, 0x43, 0x6f, 0x72, 0x6e, 0x65, 0x6c, 0x69, 0x61,
+    0x00, 0x43, 0x6f, 0x72, 0x6e, 0x65, 0x6c, 0x69, 0x75, 0x73, 0x00, 0x43,
+    0x6f, 0x72, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x43, 0x6f, 0x72, 0x72, 0x69,
+    0x65, 0x00, 0x43, 0x6f, 0x72, 0x72, 0x69, 0x6e, 0x00, 0x43, 0x6f, 0x72,
+    0x72, 0x69, 0x6e, 0x61, 0x00, 0x43, 0x6f, 0x72, 0x72, 0x69, 0x6e, 0x65,
+    0x00, 0x43, 0x6f, 0x72, 0x72, 0x69, 0x6e, 0x6e, 0x65, 0x00, 0x43, 0x6f,
+    0x72, 0x74, 0x65, 0x7a, 0x00, 0x43, 0x6f, 0x72, 0x74, 0x6e, 0x65, 0x79,
+    0x00, 0x43, 0x6f, 0x72, 0x79, 0x00, 0x43, 0x6f, 0x75, 0x72, 0x74, 0x6e,
+    0x65, 0x79, 0x00, 0x43, 0x6f, 0x79, 0x00, 0x43, 0x72, 0x61, 0x69, 0x67,
+    0x00, 0x43, 0x72, 0x65, 0x6f, 0x6c, 0x61, 0x00, 0x43, 0x72, 0x69, 0x73,
+    0x00, 0x43, 0x72, 0x69, 0x73, 0x65, 0x6c, 0x64, 0x61, 0x00, 0x43, 0x72,
+    0x69, 0x73, 0x73, 0x79, 0x00, 0x43, 0x72, 0x69, 0x73, 0x74, 0x61, 0x00,
+    0x43, 0x72, 0x69, 0x73, 0x74, 0x61, 0x6c, 0x00, 0x43, 0x72, 0x69, 0x73,
+    0x74, 0x65, 0x6e, 0x00, 0x43, 0x72, 0x69, 0x73, 0x74, 0x69, 0x00, 0x43,
+    0x72, 0x69, 0x73, 0x74, 0x69, 0x65, 0x00, 0x43, 0x72, 0x69, 0x73, 0x74,
+    0x69, 0x6e, 0x00, 0x43, 0x72, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x00,
+    0x43, 0x72, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x72, 0x69,
+    0x73, 0x74, 0x6f, 0x62, 0x61, 0x6c, 0x00, 0x43, 0x72, 0x69, 0x73, 0x74,
+    0x6f, 0x70, 0x68, 0x65, 0x72, 0x00, 0x43, 0x72, 0x69, 0x73, 0x74, 0x79,
+    0x00, 0x43, 0x72, 0x75, 0x7a, 0x00, 0x43, 0x72, 0x79, 0x73, 0x74, 0x61,
+    0x00, 0x43, 0x72, 0x79, 0x73, 0x74, 0x61, 0x6c, 0x00, 0x43, 0x72, 0x79,
+    0x73, 0x74, 0x6c, 0x65, 0x00, 0x43, 0x75, 0x63, 0x00, 0x43, 0x75, 0x72,
+    0x74, 0x00, 0x43, 0x75, 0x72, 0x74, 0x69, 0x73, 0x00, 0x43, 0x79, 0x6e,
+    0x64, 0x69, 0x00, 0x43, 0x79, 0x6e, 0x64, 0x79, 0x00, 0x43, 0x79, 0x6e,
+    0x74, 0x68, 0x69, 0x61, 0x00, 0x43, 0x79, 0x72, 0x69, 0x6c, 0x00, 0x43,
+    0x79, 0x72, 0x73, 0x74, 0x61, 0x6c, 0x00, 0x43, 0x79, 0x72, 0x75, 0x73,
+    0x00, 0x43, 0x79, 0x74, 0x68, 0x69, 0x61, 0x00, 0x44, 0x61, 0x63, 0x69,
+    0x61, 0x00, 0x44, 0x61, 0x67, 0x6d, 0x61, 0x72, 0x00, 0x44, 0x61, 0x67,
+    0x6e, 0x79, 0x00, 0x44, 0x61, 0x68, 0x6c, 0x69, 0x61, 0x00, 0x44, 0x61,
+    0x69, 0x6e, 0x61, 0x00, 0x44, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x44, 0x61,
+    0x69, 0x73, 0x65, 0x79, 0x00, 0x44, 0x61, 0x69, 0x73, 0x79, 0x00, 0x44,
+    0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x44, 0x61, 0x6c, 0x65, 0x00, 0x44,
+    0x61, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x44, 0x61, 0x6c, 0x69, 0x61, 0x00,
+    0x44, 0x61, 0x6c, 0x69, 0x6c, 0x61, 0x00, 0x44, 0x61, 0x6c, 0x6c, 0x61,
+    0x73, 0x00, 0x44, 0x61, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x44, 0x61, 0x6d,
+    0x61, 0x72, 0x69, 0x73, 0x00, 0x44, 0x61, 0x6d, 0x69, 0x61, 0x6e, 0x00,
+    0x44, 0x61, 0x6d, 0x69, 0x65, 0x6e, 0x00, 0x44, 0x61, 0x6d, 0x69, 0x6f,
+    0x6e, 0x00, 0x44, 0x61, 0x6d, 0x6f, 0x6e, 0x00, 0x44, 0x61, 0x6e, 0x00,
+    0x44, 0x61, 0x6e, 0x61, 0x00, 0x44, 0x61, 0x6e, 0x61, 0x65, 0x00, 0x44,
+    0x61, 0x6e, 0x65, 0x00, 0x44, 0x61, 0x6e, 0x65, 0x6c, 0x6c, 0x65, 0x00,
+    0x44, 0x61, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x44, 0x61, 0x6e, 0x69,
+    0x00, 0x44, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x44, 0x61, 0x6e, 0x69, 0x61,
+    0x6c, 0x00, 0x44, 0x61, 0x6e, 0x69, 0x63, 0x61, 0x00, 0x44, 0x61, 0x6e,
+    0x69, 0x65, 0x6c, 0x00, 0x44, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x61, 0x00,
+    0x44, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x65, 0x00, 0x44, 0x61, 0x6e, 0x69,
+    0x65, 0x6c, 0x6c, 0x00, 0x44, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x6c, 0x61,
+    0x00, 0x44, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x44, 0x61,
+    0x6e, 0x69, 0x6b, 0x61, 0x00, 0x44, 0x61, 0x6e, 0x69, 0x6c, 0x6c, 0x65,
+    0x00, 0x44, 0x61, 0x6e, 0x69, 0x6c, 0x6f, 0x00, 0x44, 0x61, 0x6e, 0x69,
+    0x74, 0x61, 0x00, 0x44, 0x61, 0x6e, 0x6e, 0x00, 0x44, 0x61, 0x6e, 0x6e,
+    0x61, 0x00, 0x44, 0x61, 0x6e, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x44,
+    0x61, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x44, 0x61, 0x6e, 0x6e, 0x69, 0x65,
+    0x6c, 0x6c, 0x65, 0x00, 0x44, 0x61, 0x6e, 0x6e, 0x79, 0x00, 0x44, 0x61,
+    0x6e, 0x74, 0x65, 0x00, 0x44, 0x61, 0x6e, 0x75, 0x74, 0x61, 0x00, 0x44,
+    0x61, 0x6e, 0x79, 0x65, 0x6c, 0x00, 0x44, 0x61, 0x6e, 0x79, 0x65, 0x6c,
+    0x6c, 0x00, 0x44, 0x61, 0x6e, 0x79, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x44,
+    0x61, 0x70, 0x68, 0x69, 0x6e, 0x65, 0x00, 0x44, 0x61, 0x70, 0x68, 0x6e,
+    0x65, 0x00, 0x44, 0x61, 0x72, 0x61, 0x00, 0x44, 0x61, 0x72, 0x62, 0x79,
+    0x00, 0x44, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x00, 0x44, 0x61, 0x72, 0x63,
+    0x65, 0x79, 0x00, 0x44, 0x61, 0x72, 0x63, 0x69, 0x00, 0x44, 0x61, 0x72,
+    0x63, 0x69, 0x65, 0x00, 0x44, 0x61, 0x72, 0x63, 0x79, 0x00, 0x44, 0x61,
+    0x72, 0x65, 0x6c, 0x6c, 0x00, 0x44, 0x61, 0x72, 0x65, 0x6e, 0x00, 0x44,
+    0x61, 0x72, 0x69, 0x61, 0x00, 0x44, 0x61, 0x72, 0x69, 0x6e, 0x00, 0x44,
+    0x61, 0x72, 0x69, 0x6f, 0x00, 0x44, 0x61, 0x72, 0x69, 0x75, 0x73, 0x00,
+    0x44, 0x61, 0x72, 0x6c, 0x61, 0x00, 0x44, 0x61, 0x72, 0x6c, 0x65, 0x65,
+    0x6e, 0x00, 0x44, 0x61, 0x72, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x44, 0x61,
+    0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x44, 0x61, 0x72, 0x6c, 0x69, 0x6e,
+    0x65, 0x00, 0x44, 0x61, 0x72, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x44, 0x61,
+    0x72, 0x6f, 0x6e, 0x00, 0x44, 0x61, 0x72, 0x72, 0x65, 0x6c, 0x00, 0x44,
+    0x61, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x44, 0x61, 0x72, 0x72, 0x65,
+    0x6e, 0x00, 0x44, 0x61, 0x72, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x44, 0x61,
+    0x72, 0x72, 0x69, 0x6e, 0x00, 0x44, 0x61, 0x72, 0x72, 0x6f, 0x6e, 0x00,
+    0x44, 0x61, 0x72, 0x72, 0x79, 0x6c, 0x00, 0x44, 0x61, 0x72, 0x77, 0x69,
+    0x6e, 0x00, 0x44, 0x61, 0x72, 0x79, 0x6c, 0x00, 0x44, 0x61, 0x76, 0x65,
+    0x00, 0x44, 0x61, 0x76, 0x69, 0x64, 0x00, 0x44, 0x61, 0x76, 0x69, 0x64,
+    0x61, 0x00, 0x44, 0x61, 0x76, 0x69, 0x6e, 0x61, 0x00, 0x44, 0x61, 0x76,
+    0x69, 0x73, 0x00, 0x44, 0x61, 0x77, 0x6e, 0x00, 0x44, 0x61, 0x77, 0x6e,
+    0x61, 0x00, 0x44, 0x61, 0x77, 0x6e, 0x65, 0x00, 0x44, 0x61, 0x79, 0x6c,
+    0x65, 0x00, 0x44, 0x61, 0x79, 0x6e, 0x61, 0x00, 0x44, 0x61, 0x79, 0x73,
+    0x69, 0x00, 0x44, 0x65, 0x61, 0x64, 0x72, 0x61, 0x00, 0x44, 0x65, 0x61,
+    0x6e, 0x00, 0x44, 0x65, 0x61, 0x6e, 0x61, 0x00, 0x44, 0x65, 0x61, 0x6e,
+    0x64, 0x72, 0x61, 0x00, 0x44, 0x65, 0x61, 0x6e, 0x64, 0x72, 0x65, 0x00,
+    0x44, 0x65, 0x61, 0x6e, 0x64, 0x72, 0x65, 0x61, 0x00, 0x44, 0x65, 0x61,
+    0x6e, 0x65, 0x00, 0x44, 0x65, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x6f, 0x00,
+    0x44, 0x65, 0x61, 0x6e, 0x6e, 0x00, 0x44, 0x65, 0x61, 0x6e, 0x6e, 0x61,
+    0x00, 0x44, 0x65, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x44, 0x65, 0x62, 0x00,
+    0x44, 0x65, 0x62, 0x62, 0x69, 0x00, 0x44, 0x65, 0x62, 0x62, 0x69, 0x65,
+    0x00, 0x44, 0x65, 0x62, 0x62, 0x72, 0x61, 0x00, 0x44, 0x65, 0x62, 0x62,
+    0x79, 0x00, 0x44, 0x65, 0x62, 0x65, 0x72, 0x61, 0x00, 0x44, 0x65, 0x62,
+    0x69, 0x00, 0x44, 0x65, 0x62, 0x6f, 0x72, 0x61, 0x00, 0x44, 0x65, 0x62,
+    0x6f, 0x72, 0x61, 0x68, 0x00, 0x44, 0x65, 0x62, 0x72, 0x61, 0x00, 0x44,
+    0x65, 0x62, 0x72, 0x61, 0x68, 0x00, 0x44, 0x65, 0x62, 0x72, 0x6f, 0x61,
+    0x68, 0x00, 0x44, 0x65, 0x64, 0x65, 0x00, 0x44, 0x65, 0x64, 0x72, 0x61,
+    0x00, 0x44, 0x65, 0x65, 0x00, 0x44, 0x65, 0x65, 0x61, 0x6e, 0x6e, 0x00,
+    0x44, 0x65, 0x65, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x44, 0x65, 0x65, 0x64,
+    0x65, 0x65, 0x00, 0x44, 0x65, 0x65, 0x64, 0x72, 0x61, 0x00, 0x44, 0x65,
+    0x65, 0x6e, 0x61, 0x00, 0x44, 0x65, 0x65, 0x74, 0x74, 0x61, 0x00, 0x44,
+    0x65, 0x69, 0x64, 0x72, 0x61, 0x00, 0x44, 0x65, 0x69, 0x64, 0x72, 0x65,
+    0x00, 0x44, 0x65, 0x69, 0x72, 0x64, 0x72, 0x65, 0x00, 0x44, 0x65, 0x6a,
+    0x61, 0x00, 0x44, 0x65, 0x6c, 0x00, 0x44, 0x65, 0x6c, 0x61, 0x69, 0x6e,
+    0x65, 0x00, 0x44, 0x65, 0x6c, 0x61, 0x6e, 0x61, 0x00, 0x44, 0x65, 0x6c,
+    0x62, 0x65, 0x72, 0x74, 0x00, 0x44, 0x65, 0x6c, 0x63, 0x69, 0x65, 0x00,
+    0x44, 0x65, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x44, 0x65, 0x6c, 0x66, 0x69,
+    0x6e, 0x61, 0x00, 0x44, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x44, 0x65, 0x6c,
+    0x69, 0x63, 0x69, 0x61, 0x00, 0x44, 0x65, 0x6c, 0x69, 0x6c, 0x61, 0x00,
+    0x44, 0x65, 0x6c, 0x69, 0x6c, 0x61, 0x68, 0x00, 0x44, 0x65, 0x6c, 0x69,
+    0x6e, 0x64, 0x61, 0x00, 0x44, 0x65, 0x6c, 0x69, 0x73, 0x61, 0x00, 0x44,
+    0x65, 0x6c, 0x6c, 0x00, 0x44, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x44, 0x65,
+    0x6c, 0x6d, 0x61, 0x00, 0x44, 0x65, 0x6c, 0x6d, 0x61, 0x72, 0x00, 0x44,
+    0x65, 0x6c, 0x6d, 0x65, 0x72, 0x00, 0x44, 0x65, 0x6c, 0x6d, 0x79, 0x00,
+    0x44, 0x65, 0x6c, 0x6f, 0x69, 0x73, 0x00, 0x44, 0x65, 0x6c, 0x6f, 0x69,
+    0x73, 0x65, 0x00, 0x44, 0x65, 0x6c, 0x6f, 0x72, 0x61, 0x00, 0x44, 0x65,
+    0x6c, 0x6f, 0x72, 0x61, 0x73, 0x00, 0x44, 0x65, 0x6c, 0x6f, 0x72, 0x65,
+    0x73, 0x00, 0x44, 0x65, 0x6c, 0x6f, 0x72, 0x69, 0x73, 0x00, 0x44, 0x65,
+    0x6c, 0x6f, 0x72, 0x73, 0x65, 0x00, 0x44, 0x65, 0x6c, 0x70, 0x68, 0x61,
+    0x00, 0x44, 0x65, 0x6c, 0x70, 0x68, 0x69, 0x61, 0x00, 0x44, 0x65, 0x6c,
+    0x70, 0x68, 0x69, 0x6e, 0x65, 0x00, 0x44, 0x65, 0x6c, 0x73, 0x69, 0x65,
+    0x00, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x00, 0x44, 0x65, 0x6d, 0x61, 0x72,
+    0x63, 0x75, 0x73, 0x00, 0x44, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x61, 0x00,
+    0x44, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x61, 0x00, 0x44, 0x65, 0x6d,
+    0x65, 0x74, 0x72, 0x69, 0x63, 0x65, 0x00, 0x44, 0x65, 0x6d, 0x65, 0x74,
+    0x72, 0x69, 0x75, 0x73, 0x00, 0x44, 0x65, 0x6e, 0x61, 0x00, 0x44, 0x65,
+    0x6e, 0x61, 0x65, 0x00, 0x44, 0x65, 0x6e, 0x65, 0x65, 0x6e, 0x00, 0x44,
+    0x65, 0x6e, 0x65, 0x73, 0x65, 0x00, 0x44, 0x65, 0x6e, 0x69, 0x63, 0x65,
+    0x00, 0x44, 0x65, 0x6e, 0x69, 0x73, 0x00, 0x44, 0x65, 0x6e, 0x69, 0x73,
+    0x65, 0x00, 0x44, 0x65, 0x6e, 0x69, 0x73, 0x68, 0x61, 0x00, 0x44, 0x65,
+    0x6e, 0x69, 0x73, 0x73, 0x65, 0x00, 0x44, 0x65, 0x6e, 0x69, 0x74, 0x61,
+    0x00, 0x44, 0x65, 0x6e, 0x6e, 0x61, 0x00, 0x44, 0x65, 0x6e, 0x6e, 0x69,
+    0x73, 0x00, 0x44, 0x65, 0x6e, 0x6e, 0x69, 0x73, 0x65, 0x00, 0x44, 0x65,
+    0x6e, 0x6e, 0x79, 0x00, 0x44, 0x65, 0x6e, 0x76, 0x65, 0x72, 0x00, 0x44,
+    0x65, 0x6e, 0x79, 0x73, 0x65, 0x00, 0x44, 0x65, 0x6f, 0x6e, 0x00, 0x44,
+    0x65, 0x6f, 0x6e, 0x6e, 0x61, 0x00, 0x44, 0x65, 0x72, 0x65, 0x6b, 0x00,
+    0x44, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x44, 0x65, 0x72, 0x72, 0x69,
+    0x63, 0x6b, 0x00, 0x44, 0x65, 0x73, 0x68, 0x61, 0x77, 0x6e, 0x00, 0x44,
+    0x65, 0x73, 0x69, 0x72, 0x61, 0x65, 0x00, 0x44, 0x65, 0x73, 0x69, 0x72,
+    0x65, 0x00, 0x44, 0x65, 0x73, 0x69, 0x72, 0x65, 0x65, 0x00, 0x44, 0x65,
+    0x73, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x44, 0x65, 0x73, 0x70, 0x69, 0x6e,
+    0x61, 0x00, 0x44, 0x65, 0x73, 0x73, 0x69, 0x65, 0x00, 0x44, 0x65, 0x73,
+    0x74, 0x69, 0x6e, 0x79, 0x00, 0x44, 0x65, 0x74, 0x72, 0x61, 0x00, 0x44,
+    0x65, 0x76, 0x69, 0x6e, 0x00, 0x44, 0x65, 0x76, 0x6f, 0x6e, 0x00, 0x44,
+    0x65, 0x76, 0x6f, 0x6e, 0x61, 0x00, 0x44, 0x65, 0x76, 0x6f, 0x72, 0x61,
+    0x00, 0x44, 0x65, 0x76, 0x6f, 0x72, 0x61, 0x68, 0x00, 0x44, 0x65, 0x77,
+    0x61, 0x79, 0x6e, 0x65, 0x00, 0x44, 0x65, 0x77, 0x65, 0x79, 0x00, 0x44,
+    0x65, 0x77, 0x69, 0x74, 0x74, 0x00, 0x44, 0x65, 0x78, 0x74, 0x65, 0x72,
+    0x00, 0x44, 0x69, 0x61, 0x00, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64,
+    0x00, 0x44, 0x69, 0x61, 0x6e, 0x00, 0x44, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x44, 0x69, 0x61, 0x6e, 0x65, 0x00, 0x44, 0x69, 0x61, 0x6e, 0x6e, 0x00,
+    0x44, 0x69, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x44, 0x69, 0x61, 0x6e, 0x6e,
+    0x65, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x00, 0x44, 0x69, 0x65, 0x64, 0x72,
+    0x61, 0x00, 0x44, 0x69, 0x65, 0x64, 0x72, 0x65, 0x00, 0x44, 0x69, 0x65,
+    0x67, 0x6f, 0x00, 0x44, 0x69, 0x65, 0x72, 0x64, 0x72, 0x65, 0x00, 0x44,
+    0x69, 0x67, 0x6e, 0x61, 0x00, 0x44, 0x69, 0x6c, 0x6c, 0x6f, 0x6e, 0x00,
+    0x44, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x00, 0x44, 0x69, 0x6e, 0x61, 0x00,
+    0x44, 0x69, 0x6e, 0x61, 0x68, 0x00, 0x44, 0x69, 0x6e, 0x6f, 0x00, 0x44,
+    0x69, 0x6e, 0x6f, 0x72, 0x61, 0x68, 0x00, 0x44, 0x69, 0x6f, 0x6e, 0x00,
+    0x44, 0x69, 0x6f, 0x6e, 0x65, 0x00, 0x44, 0x69, 0x6f, 0x6e, 0x6e, 0x61,
+    0x00, 0x44, 0x69, 0x6f, 0x6e, 0x6e, 0x65, 0x00, 0x44, 0x69, 0x72, 0x6b,
+    0x00, 0x44, 0x69, 0x76, 0x69, 0x6e, 0x61, 0x00, 0x44, 0x69, 0x78, 0x69,
+    0x65, 0x00, 0x44, 0x6f, 0x64, 0x69, 0x65, 0x00, 0x44, 0x6f, 0x6c, 0x6c,
+    0x69, 0x65, 0x00, 0x44, 0x6f, 0x6c, 0x6c, 0x79, 0x00, 0x44, 0x6f, 0x6c,
+    0x6f, 0x72, 0x65, 0x73, 0x00, 0x44, 0x6f, 0x6c, 0x6f, 0x72, 0x69, 0x73,
+    0x00, 0x44, 0x6f, 0x6d, 0x65, 0x6e, 0x69, 0x63, 0x00, 0x44, 0x6f, 0x6d,
+    0x65, 0x6e, 0x69, 0x63, 0x61, 0x00, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x67,
+    0x61, 0x00, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x6f, 0x00, 0x44, 0x6f,
+    0x6d, 0x69, 0x6e, 0x69, 0x63, 0x00, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x69,
+    0x63, 0x61, 0x00, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x69, 0x63, 0x6b, 0x00,
+    0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x00, 0x44, 0x6f,
+    0x6d, 0x69, 0x6e, 0x71, 0x75, 0x65, 0x00, 0x44, 0x6f, 0x6d, 0x69, 0x74,
+    0x69, 0x6c, 0x61, 0x00, 0x44, 0x6f, 0x6d, 0x6f, 0x6e, 0x69, 0x71, 0x75,
+    0x65, 0x00, 0x44, 0x6f, 0x6e, 0x00, 0x44, 0x6f, 0x6e, 0x61, 0x00, 0x44,
+    0x6f, 0x6e, 0x61, 0x6c, 0x64, 0x00, 0x44, 0x6f, 0x6e, 0x65, 0x6c, 0x6c,
+    0x61, 0x00, 0x44, 0x6f, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x44, 0x6f,
+    0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x44, 0x6f, 0x6e, 0x67, 0x00, 0x44,
+    0x6f, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x44, 0x6f, 0x6e, 0x6e, 0x00, 0x44,
+    0x6f, 0x6e, 0x6e, 0x61, 0x00, 0x44, 0x6f, 0x6e, 0x6e, 0x65, 0x6c, 0x6c,
+    0x00, 0x44, 0x6f, 0x6e, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x44, 0x6f,
+    0x6e, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x44, 0x6f, 0x6e, 0x6e, 0x69,
+    0x65, 0x00, 0x44, 0x6f, 0x6e, 0x6e, 0x79, 0x00, 0x44, 0x6f, 0x6e, 0x6f,
+    0x76, 0x61, 0x6e, 0x00, 0x44, 0x6f, 0x6e, 0x74, 0x65, 0x00, 0x44, 0x6f,
+    0x6e, 0x79, 0x61, 0x00, 0x44, 0x6f, 0x72, 0x61, 0x00, 0x44, 0x6f, 0x72,
+    0x61, 0x74, 0x68, 0x79, 0x00, 0x44, 0x6f, 0x72, 0x63, 0x61, 0x73, 0x00,
+    0x44, 0x6f, 0x72, 0x65, 0x61, 0x74, 0x68, 0x61, 0x00, 0x44, 0x6f, 0x72,
+    0x65, 0x65, 0x6e, 0x00, 0x44, 0x6f, 0x72, 0x65, 0x6e, 0x65, 0x00, 0x44,
+    0x6f, 0x72, 0x65, 0x74, 0x68, 0x61, 0x00, 0x44, 0x6f, 0x72, 0x65, 0x74,
+    0x68, 0x65, 0x61, 0x00, 0x44, 0x6f, 0x72, 0x65, 0x74, 0x74, 0x61, 0x00,
+    0x44, 0x6f, 0x72, 0x69, 0x00, 0x44, 0x6f, 0x72, 0x69, 0x61, 0x00, 0x44,
+    0x6f, 0x72, 0x69, 0x61, 0x6e, 0x00, 0x44, 0x6f, 0x72, 0x69, 0x65, 0x00,
+    0x44, 0x6f, 0x72, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x44, 0x6f, 0x72, 0x69,
+    0x6e, 0x65, 0x00, 0x44, 0x6f, 0x72, 0x69, 0x73, 0x00, 0x44, 0x6f, 0x72,
+    0x6c, 0x61, 0x00, 0x44, 0x6f, 0x72, 0x6f, 0x74, 0x68, 0x61, 0x00, 0x44,
+    0x6f, 0x72, 0x6f, 0x74, 0x68, 0x65, 0x61, 0x00, 0x44, 0x6f, 0x72, 0x6f,
+    0x74, 0x68, 0x79, 0x00, 0x44, 0x6f, 0x72, 0x72, 0x69, 0x73, 0x00, 0x44,
+    0x6f, 0x72, 0x73, 0x65, 0x79, 0x00, 0x44, 0x6f, 0x72, 0x74, 0x68, 0x61,
+    0x00, 0x44, 0x6f, 0x72, 0x74, 0x68, 0x65, 0x61, 0x00, 0x44, 0x6f, 0x72,
+    0x74, 0x68, 0x65, 0x79, 0x00, 0x44, 0x6f, 0x72, 0x74, 0x68, 0x79, 0x00,
+    0x44, 0x6f, 0x74, 0x00, 0x44, 0x6f, 0x74, 0x74, 0x69, 0x65, 0x00, 0x44,
+    0x6f, 0x74, 0x74, 0x79, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x00, 0x44, 0x6f,
+    0x75, 0x67, 0x6c, 0x61, 0x73, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61,
+    0x73, 0x73, 0x00, 0x44, 0x6f, 0x76, 0x69, 0x65, 0x00, 0x44, 0x6f, 0x79,
+    0x6c, 0x65, 0x00, 0x44, 0x72, 0x65, 0x61, 0x6d, 0x61, 0x00, 0x44, 0x72,
+    0x65, 0x6d, 0x61, 0x00, 0x44, 0x72, 0x65, 0x77, 0x00, 0x44, 0x72, 0x75,
+    0x63, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x44, 0x72, 0x75, 0x73, 0x69, 0x6c,
+    0x6c, 0x61, 0x00, 0x44, 0x75, 0x61, 0x6e, 0x65, 0x00, 0x44, 0x75, 0x64,
+    0x6c, 0x65, 0x79, 0x00, 0x44, 0x75, 0x6c, 0x63, 0x65, 0x00, 0x44, 0x75,
+    0x6c, 0x63, 0x69, 0x65, 0x00, 0x44, 0x75, 0x6e, 0x63, 0x61, 0x6e, 0x00,
+    0x44, 0x75, 0x6e, 0x67, 0x00, 0x44, 0x75, 0x73, 0x74, 0x69, 0x00, 0x44,
+    0x75, 0x73, 0x74, 0x69, 0x6e, 0x00, 0x44, 0x75, 0x73, 0x74, 0x79, 0x00,
+    0x44, 0x77, 0x61, 0x69, 0x6e, 0x00, 0x44, 0x77, 0x61, 0x6e, 0x61, 0x00,
+    0x44, 0x77, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x44, 0x77, 0x69, 0x67, 0x68,
+    0x74, 0x00, 0x44, 0x79, 0x61, 0x6e, 0x00, 0x44, 0x79, 0x6c, 0x61, 0x6e,
+    0x00, 0x45, 0x61, 0x72, 0x6c, 0x00, 0x45, 0x61, 0x72, 0x6c, 0x65, 0x00,
+    0x45, 0x61, 0x72, 0x6c, 0x65, 0x61, 0x6e, 0x00, 0x45, 0x61, 0x72, 0x6c,
+    0x65, 0x65, 0x6e, 0x00, 0x45, 0x61, 0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00,
+    0x45, 0x61, 0x72, 0x6c, 0x69, 0x65, 0x00, 0x45, 0x61, 0x72, 0x6c, 0x69,
+    0x6e, 0x65, 0x00, 0x45, 0x61, 0x72, 0x6e, 0x65, 0x73, 0x74, 0x00, 0x45,
+    0x61, 0x72, 0x6e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x45, 0x61,
+    0x72, 0x74, 0x68, 0x61, 0x00, 0x45, 0x61, 0x73, 0x74, 0x65, 0x72, 0x00,
+    0x45, 0x62, 0x6f, 0x6e, 0x69, 0x00, 0x45, 0x62, 0x6f, 0x6e, 0x69, 0x65,
+    0x00, 0x45, 0x62, 0x6f, 0x6e, 0x79, 0x00, 0x45, 0x63, 0x68, 0x6f, 0x00,
+    0x45, 0x64, 0x00, 0x45, 0x64, 0x61, 0x00, 0x45, 0x64, 0x64, 0x61, 0x00,
+    0x45, 0x64, 0x64, 0x69, 0x65, 0x00, 0x45, 0x64, 0x64, 0x79, 0x00, 0x45,
+    0x64, 0x65, 0x6c, 0x6d, 0x69, 0x72, 0x61, 0x00, 0x45, 0x64, 0x65, 0x6e,
+    0x00, 0x45, 0x64, 0x67, 0x61, 0x72, 0x00, 0x45, 0x64, 0x67, 0x61, 0x72,
+    0x64, 0x6f, 0x00, 0x45, 0x64, 0x69, 0x65, 0x00, 0x45, 0x64, 0x69, 0x73,
+    0x6f, 0x6e, 0x00, 0x45, 0x64, 0x69, 0x74, 0x68, 0x00, 0x45, 0x64, 0x6d,
+    0x6f, 0x6e, 0x64, 0x00, 0x45, 0x64, 0x6d, 0x75, 0x6e, 0x64, 0x00, 0x45,
+    0x64, 0x6d, 0x75, 0x6e, 0x64, 0x6f, 0x00, 0x45, 0x64, 0x6e, 0x61, 0x00,
+    0x45, 0x64, 0x72, 0x61, 0x00, 0x45, 0x64, 0x72, 0x69, 0x73, 0x00, 0x45,
+    0x64, 0x75, 0x61, 0x72, 0x64, 0x6f, 0x00, 0x45, 0x64, 0x77, 0x61, 0x72,
+    0x64, 0x00, 0x45, 0x64, 0x77, 0x61, 0x72, 0x64, 0x6f, 0x00, 0x45, 0x64,
+    0x77, 0x69, 0x6e, 0x00, 0x45, 0x64, 0x77, 0x69, 0x6e, 0x61, 0x00, 0x45,
+    0x64, 0x79, 0x74, 0x68, 0x00, 0x45, 0x64, 0x79, 0x74, 0x68, 0x65, 0x00,
+    0x45, 0x66, 0x66, 0x69, 0x65, 0x00, 0x45, 0x66, 0x72, 0x61, 0x69, 0x6e,
+    0x00, 0x45, 0x66, 0x72, 0x65, 0x6e, 0x00, 0x45, 0x68, 0x74, 0x65, 0x6c,
+    0x00, 0x45, 0x69, 0x6c, 0x65, 0x65, 0x6e, 0x00, 0x45, 0x69, 0x6c, 0x65,
+    0x6e, 0x65, 0x00, 0x45, 0x6c, 0x61, 0x00, 0x45, 0x6c, 0x61, 0x64, 0x69,
+    0x61, 0x00, 0x45, 0x6c, 0x61, 0x69, 0x6e, 0x61, 0x00, 0x45, 0x6c, 0x61,
+    0x69, 0x6e, 0x65, 0x00, 0x45, 0x6c, 0x61, 0x6e, 0x61, 0x00, 0x45, 0x6c,
+    0x61, 0x6e, 0x65, 0x00, 0x45, 0x6c, 0x61, 0x6e, 0x6f, 0x72, 0x00, 0x45,
+    0x6c, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x45, 0x6c, 0x62, 0x61, 0x00, 0x45,
+    0x6c, 0x62, 0x65, 0x72, 0x74, 0x00, 0x45, 0x6c, 0x64, 0x61, 0x00, 0x45,
+    0x6c, 0x64, 0x65, 0x6e, 0x00, 0x45, 0x6c, 0x64, 0x6f, 0x6e, 0x00, 0x45,
+    0x6c, 0x64, 0x6f, 0x72, 0x61, 0x00, 0x45, 0x6c, 0x64, 0x72, 0x69, 0x64,
+    0x67, 0x65, 0x00, 0x45, 0x6c, 0x65, 0x61, 0x6e, 0x6f, 0x72, 0x00, 0x45,
+    0x6c, 0x65, 0x61, 0x6e, 0x6f, 0x72, 0x61, 0x00, 0x45, 0x6c, 0x65, 0x61,
+    0x6e, 0x6f, 0x72, 0x65, 0x00, 0x45, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x00,
+    0x45, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x45, 0x6c, 0x65, 0x6e, 0x65, 0x00,
+    0x45, 0x6c, 0x65, 0x6e, 0x69, 0x00, 0x45, 0x6c, 0x65, 0x6e, 0x6f, 0x72,
+    0x00, 0x45, 0x6c, 0x65, 0x6e, 0x6f, 0x72, 0x61, 0x00, 0x45, 0x6c, 0x65,
+    0x6e, 0x6f, 0x72, 0x65, 0x00, 0x45, 0x6c, 0x65, 0x6f, 0x6e, 0x6f, 0x72,
+    0x00, 0x45, 0x6c, 0x65, 0x6f, 0x6e, 0x6f, 0x72, 0x61, 0x00, 0x45, 0x6c,
+    0x65, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x00, 0x45, 0x6c, 0x66, 0x72, 0x65,
+    0x64, 0x61, 0x00, 0x45, 0x6c, 0x66, 0x72, 0x69, 0x65, 0x64, 0x61, 0x00,
+    0x45, 0x6c, 0x66, 0x72, 0x69, 0x65, 0x64, 0x65, 0x00, 0x45, 0x6c, 0x69,
+    0x00, 0x45, 0x6c, 0x69, 0x61, 0x00, 0x45, 0x6c, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x45, 0x6c, 0x69, 0x61, 0x73, 0x00, 0x45, 0x6c, 0x69, 0x63, 0x69,
+    0x61, 0x00, 0x45, 0x6c, 0x69, 0x64, 0x61, 0x00, 0x45, 0x6c, 0x69, 0x64,
+    0x69, 0x61, 0x00, 0x45, 0x6c, 0x69, 0x6a, 0x61, 0x68, 0x00, 0x45, 0x6c,
+    0x69, 0x6e, 0x00, 0x45, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x45, 0x6c, 0x69,
+    0x6e, 0x6f, 0x72, 0x00, 0x45, 0x6c, 0x69, 0x6e, 0x6f, 0x72, 0x65, 0x00,
+    0x45, 0x6c, 0x69, 0x73, 0x61, 0x00, 0x45, 0x6c, 0x69, 0x73, 0x61, 0x62,
+    0x65, 0x74, 0x68, 0x00, 0x45, 0x6c, 0x69, 0x73, 0x65, 0x00, 0x45, 0x6c,
+    0x69, 0x73, 0x65, 0x6f, 0x00, 0x45, 0x6c, 0x69, 0x73, 0x68, 0x61, 0x00,
+    0x45, 0x6c, 0x69, 0x73, 0x73, 0x61, 0x00, 0x45, 0x6c, 0x69, 0x7a, 0x00,
+    0x45, 0x6c, 0x69, 0x7a, 0x61, 0x00, 0x45, 0x6c, 0x69, 0x7a, 0x61, 0x62,
+    0x65, 0x74, 0x00, 0x45, 0x6c, 0x69, 0x7a, 0x61, 0x62, 0x65, 0x74, 0x68,
+    0x00, 0x45, 0x6c, 0x69, 0x7a, 0x62, 0x65, 0x74, 0x68, 0x00, 0x45, 0x6c,
+    0x69, 0x7a, 0x65, 0x62, 0x65, 0x74, 0x68, 0x00, 0x45, 0x6c, 0x6b, 0x65,
+    0x00, 0x45, 0x6c, 0x6c, 0x61, 0x00, 0x45, 0x6c, 0x6c, 0x61, 0x6d, 0x61,
+    0x65, 0x00, 0x45, 0x6c, 0x6c, 0x61, 0x6e, 0x00, 0x45, 0x6c, 0x6c, 0x65,
+    0x6e, 0x00, 0x45, 0x6c, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x45, 0x6c, 0x6c,
+    0x69, 0x00, 0x45, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x45, 0x6c, 0x6c, 0x69,
+    0x6f, 0x74, 0x00, 0x45, 0x6c, 0x6c, 0x69, 0x6f, 0x74, 0x74, 0x00, 0x45,
+    0x6c, 0x6c, 0x69, 0x73, 0x00, 0x45, 0x6c, 0x6c, 0x73, 0x77, 0x6f, 0x72,
+    0x74, 0x68, 0x00, 0x45, 0x6c, 0x6c, 0x79, 0x00, 0x45, 0x6c, 0x6c, 0x79,
+    0x6e, 0x00, 0x45, 0x6c, 0x6d, 0x61, 0x00, 0x45, 0x6c, 0x6d, 0x65, 0x72,
+    0x00, 0x45, 0x6c, 0x6d, 0x69, 0x72, 0x61, 0x00, 0x45, 0x6c, 0x6d, 0x6f,
+    0x00, 0x45, 0x6c, 0x6e, 0x61, 0x00, 0x45, 0x6c, 0x6e, 0x6f, 0x72, 0x61,
+    0x00, 0x45, 0x6c, 0x6f, 0x64, 0x69, 0x61, 0x00, 0x45, 0x6c, 0x6f, 0x69,
+    0x73, 0x00, 0x45, 0x6c, 0x6f, 0x69, 0x73, 0x61, 0x00, 0x45, 0x6c, 0x6f,
+    0x69, 0x73, 0x65, 0x00, 0x45, 0x6c, 0x6f, 0x75, 0x69, 0x73, 0x65, 0x00,
+    0x45, 0x6c, 0x6f, 0x79, 0x00, 0x45, 0x6c, 0x72, 0x6f, 0x79, 0x00, 0x45,
+    0x6c, 0x73, 0x61, 0x00, 0x45, 0x6c, 0x73, 0x65, 0x00, 0x45, 0x6c, 0x73,
+    0x69, 0x65, 0x00, 0x45, 0x6c, 0x73, 0x79, 0x00, 0x45, 0x6c, 0x74, 0x6f,
+    0x6e, 0x00, 0x45, 0x6c, 0x76, 0x61, 0x00, 0x45, 0x6c, 0x76, 0x65, 0x72,
+    0x61, 0x00, 0x45, 0x6c, 0x76, 0x69, 0x61, 0x00, 0x45, 0x6c, 0x76, 0x69,
+    0x65, 0x00, 0x45, 0x6c, 0x76, 0x69, 0x6e, 0x00, 0x45, 0x6c, 0x76, 0x69,
+    0x6e, 0x61, 0x00, 0x45, 0x6c, 0x76, 0x69, 0x72, 0x61, 0x00, 0x45, 0x6c,
+    0x76, 0x69, 0x73, 0x00, 0x45, 0x6c, 0x77, 0x61, 0x6e, 0x64, 0x61, 0x00,
+    0x45, 0x6c, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x45, 0x6c, 0x79, 0x73, 0x65,
+    0x00, 0x45, 0x6c, 0x7a, 0x61, 0x00, 0x45, 0x6d, 0x61, 0x00, 0x45, 0x6d,
+    0x61, 0x6e, 0x75, 0x65, 0x6c, 0x00, 0x45, 0x6d, 0x65, 0x6c, 0x64, 0x61,
+    0x00, 0x45, 0x6d, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x45, 0x6d, 0x65, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x45, 0x6d, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00,
+    0x45, 0x6d, 0x65, 0x6c, 0x79, 0x00, 0x45, 0x6d, 0x65, 0x72, 0x61, 0x6c,
+    0x64, 0x00, 0x45, 0x6d, 0x65, 0x72, 0x69, 0x74, 0x61, 0x00, 0x45, 0x6d,
+    0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x45, 0x6d, 0x65, 0x72, 0x79, 0x00,
+    0x45, 0x6d, 0x69, 0x6b, 0x6f, 0x00, 0x45, 0x6d, 0x69, 0x6c, 0x00, 0x45,
+    0x6d, 0x69, 0x6c, 0x65, 0x00, 0x45, 0x6d, 0x69, 0x6c, 0x65, 0x65, 0x00,
+    0x45, 0x6d, 0x69, 0x6c, 0x69, 0x61, 0x00, 0x45, 0x6d, 0x69, 0x6c, 0x69,
+    0x65, 0x00, 0x45, 0x6d, 0x69, 0x6c, 0x69, 0x6f, 0x00, 0x45, 0x6d, 0x69,
+    0x6c, 0x79, 0x00, 0x45, 0x6d, 0x6d, 0x61, 0x00, 0x45, 0x6d, 0x6d, 0x61,
+    0x6c, 0x69, 0x6e, 0x65, 0x00, 0x45, 0x6d, 0x6d, 0x61, 0x6e, 0x75, 0x65,
+    0x6c, 0x00, 0x45, 0x6d, 0x6d, 0x65, 0x74, 0x74, 0x00, 0x45, 0x6d, 0x6d,
+    0x69, 0x65, 0x00, 0x45, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x00, 0x45, 0x6d,
+    0x6d, 0x79, 0x00, 0x45, 0x6d, 0x6f, 0x67, 0x65, 0x6e, 0x65, 0x00, 0x45,
+    0x6d, 0x6f, 0x72, 0x79, 0x00, 0x45, 0x6e, 0x61, 0x00, 0x45, 0x6e, 0x64,
+    0x61, 0x00, 0x45, 0x6e, 0x65, 0x64, 0x69, 0x6e, 0x61, 0x00, 0x45, 0x6e,
+    0x65, 0x69, 0x64, 0x61, 0x00, 0x45, 0x6e, 0x69, 0x64, 0x00, 0x45, 0x6e,
+    0x6f, 0x63, 0x68, 0x00, 0x45, 0x6e, 0x6f, 0x6c, 0x61, 0x00, 0x45, 0x6e,
+    0x72, 0x69, 0x71, 0x75, 0x65, 0x00, 0x45, 0x6e, 0x72, 0x69, 0x71, 0x75,
+    0x65, 0x74, 0x61, 0x00, 0x45, 0x70, 0x69, 0x66, 0x61, 0x6e, 0x69, 0x61,
+    0x00, 0x45, 0x72, 0x61, 0x00, 0x45, 0x72, 0x61, 0x73, 0x6d, 0x6f, 0x00,
+    0x45, 0x72, 0x69, 0x63, 0x00, 0x45, 0x72, 0x69, 0x63, 0x61, 0x00, 0x45,
+    0x72, 0x69, 0x63, 0x68, 0x00, 0x45, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x45,
+    0x72, 0x69, 0x63, 0x6b, 0x61, 0x00, 0x45, 0x72, 0x69, 0x6b, 0x00, 0x45,
+    0x72, 0x69, 0x6b, 0x61, 0x00, 0x45, 0x72, 0x69, 0x6e, 0x00, 0x45, 0x72,
+    0x69, 0x6e, 0x6e, 0x00, 0x45, 0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x45,
+    0x72, 0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x45, 0x72, 0x6c, 0x69, 0x6e,
+    0x65, 0x00, 0x45, 0x72, 0x6d, 0x61, 0x00, 0x45, 0x72, 0x6d, 0x65, 0x6c,
+    0x69, 0x6e, 0x64, 0x61, 0x00, 0x45, 0x72, 0x6d, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x45, 0x72, 0x6e, 0x61, 0x00, 0x45, 0x72, 0x6e, 0x65, 0x73, 0x74,
+    0x00, 0x45, 0x72, 0x6e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x45,
+    0x72, 0x6e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x45, 0x72, 0x6e,
+    0x65, 0x73, 0x74, 0x6f, 0x00, 0x45, 0x72, 0x6e, 0x69, 0x65, 0x00, 0x45,
+    0x72, 0x72, 0x6f, 0x6c, 0x00, 0x45, 0x72, 0x76, 0x69, 0x6e, 0x00, 0x45,
+    0x72, 0x77, 0x69, 0x6e, 0x00, 0x45, 0x72, 0x79, 0x6e, 0x00, 0x45, 0x73,
+    0x6d, 0x65, 0x72, 0x61, 0x6c, 0x64, 0x61, 0x00, 0x45, 0x73, 0x70, 0x65,
+    0x72, 0x61, 0x6e, 0x7a, 0x61, 0x00, 0x45, 0x73, 0x73, 0x69, 0x65, 0x00,
+    0x45, 0x73, 0x74, 0x61, 0x00, 0x45, 0x73, 0x74, 0x65, 0x62, 0x61, 0x6e,
+    0x00, 0x45, 0x73, 0x74, 0x65, 0x66, 0x61, 0x6e, 0x61, 0x00, 0x45, 0x73,
+    0x74, 0x65, 0x6c, 0x61, 0x00, 0x45, 0x73, 0x74, 0x65, 0x6c, 0x6c, 0x00,
+    0x45, 0x73, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x45, 0x73, 0x74, 0x65,
+    0x6c, 0x6c, 0x65, 0x00, 0x45, 0x73, 0x74, 0x65, 0x72, 0x00, 0x45, 0x73,
+    0x74, 0x68, 0x65, 0x72, 0x00, 0x45, 0x73, 0x74, 0x72, 0x65, 0x6c, 0x6c,
+    0x61, 0x00, 0x45, 0x74, 0x68, 0x61, 0x00, 0x45, 0x74, 0x68, 0x61, 0x6e,
+    0x00, 0x45, 0x74, 0x68, 0x65, 0x6c, 0x00, 0x45, 0x74, 0x68, 0x65, 0x6c,
+    0x65, 0x6e, 0x65, 0x00, 0x45, 0x74, 0x68, 0x65, 0x6c, 0x79, 0x6e, 0x00,
+    0x45, 0x74, 0x68, 0x79, 0x6c, 0x00, 0x45, 0x74, 0x73, 0x75, 0x6b, 0x6f,
+    0x00, 0x45, 0x74, 0x74, 0x61, 0x00, 0x45, 0x74, 0x74, 0x69, 0x65, 0x00,
+    0x45, 0x75, 0x66, 0x65, 0x6d, 0x69, 0x61, 0x00, 0x45, 0x75, 0x67, 0x65,
+    0x6e, 0x61, 0x00, 0x45, 0x75, 0x67, 0x65, 0x6e, 0x65, 0x00, 0x45, 0x75,
+    0x67, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x45, 0x75, 0x67, 0x65, 0x6e, 0x69,
+    0x65, 0x00, 0x45, 0x75, 0x67, 0x65, 0x6e, 0x69, 0x6f, 0x00, 0x45, 0x75,
+    0x6c, 0x61, 0x00, 0x45, 0x75, 0x6c, 0x61, 0x68, 0x00, 0x45, 0x75, 0x6c,
+    0x61, 0x6c, 0x69, 0x61, 0x00, 0x45, 0x75, 0x6e, 0x00, 0x45, 0x75, 0x6e,
+    0x61, 0x00, 0x45, 0x75, 0x6e, 0x69, 0x63, 0x65, 0x00, 0x45, 0x75, 0x72,
+    0x61, 0x00, 0x45, 0x75, 0x73, 0x65, 0x62, 0x69, 0x61, 0x00, 0x45, 0x75,
+    0x73, 0x65, 0x62, 0x69, 0x6f, 0x00, 0x45, 0x75, 0x73, 0x74, 0x6f, 0x6c,
+    0x69, 0x61, 0x00, 0x45, 0x76, 0x61, 0x00, 0x45, 0x76, 0x61, 0x6c, 0x79,
+    0x6e, 0x00, 0x45, 0x76, 0x61, 0x6e, 0x00, 0x45, 0x76, 0x61, 0x6e, 0x67,
+    0x65, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x45, 0x76, 0x61, 0x6e, 0x67, 0x65,
+    0x6c, 0x69, 0x6e, 0x65, 0x00, 0x45, 0x76, 0x65, 0x00, 0x45, 0x76, 0x65,
+    0x6c, 0x69, 0x61, 0x00, 0x45, 0x76, 0x65, 0x6c, 0x69, 0x6e, 0x00, 0x45,
+    0x76, 0x65, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x45, 0x76, 0x65, 0x6c, 0x69,
+    0x6e, 0x65, 0x00, 0x45, 0x76, 0x65, 0x6c, 0x79, 0x6e, 0x00, 0x45, 0x76,
+    0x65, 0x6c, 0x79, 0x6e, 0x65, 0x00, 0x45, 0x76, 0x65, 0x6c, 0x79, 0x6e,
+    0x6e, 0x00, 0x45, 0x76, 0x65, 0x72, 0x65, 0x74, 0x74, 0x00, 0x45, 0x76,
+    0x65, 0x72, 0x65, 0x74, 0x74, 0x65, 0x00, 0x45, 0x76, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x45, 0x76, 0x69, 0x61, 0x00, 0x45, 0x76, 0x69, 0x65, 0x00,
+    0x45, 0x76, 0x69, 0x74, 0x61, 0x00, 0x45, 0x76, 0x6f, 0x6e, 0x00, 0x45,
+    0x76, 0x6f, 0x6e, 0x6e, 0x65, 0x00, 0x45, 0x77, 0x61, 0x00, 0x45, 0x78,
+    0x69, 0x65, 0x00, 0x45, 0x7a, 0x65, 0x6b, 0x69, 0x65, 0x6c, 0x00, 0x45,
+    0x7a, 0x65, 0x71, 0x75, 0x69, 0x65, 0x6c, 0x00, 0x45, 0x7a, 0x72, 0x61,
+    0x00, 0x46, 0x61, 0x62, 0x69, 0x61, 0x6e, 0x00, 0x46, 0x61, 0x62, 0x69,
+    0x6f, 0x6c, 0x61, 0x00, 0x46, 0x61, 0x65, 0x00, 0x46, 0x61, 0x69, 0x72,
+    0x79, 0x00, 0x46, 0x61, 0x69, 0x74, 0x68, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x6f, 0x6e, 0x00, 0x46, 0x61, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x46, 0x61,
+    0x6e, 0x6e, 0x79, 0x00, 0x46, 0x61, 0x72, 0x61, 0x68, 0x00, 0x46, 0x61,
+    0x72, 0x72, 0x61, 0x68, 0x00, 0x46, 0x61, 0x74, 0x69, 0x6d, 0x61, 0x00,
+    0x46, 0x61, 0x74, 0x69, 0x6d, 0x61, 0x68, 0x00, 0x46, 0x61, 0x75, 0x73,
+    0x74, 0x69, 0x6e, 0x61, 0x00, 0x46, 0x61, 0x75, 0x73, 0x74, 0x69, 0x6e,
+    0x6f, 0x00, 0x46, 0x61, 0x75, 0x73, 0x74, 0x6f, 0x00, 0x46, 0x61, 0x76,
+    0x69, 0x6f, 0x6c, 0x61, 0x00, 0x46, 0x61, 0x77, 0x6e, 0x00, 0x46, 0x61,
+    0x79, 0x00, 0x46, 0x61, 0x79, 0x65, 0x00, 0x46, 0x65, 0x00, 0x46, 0x65,
+    0x64, 0x65, 0x72, 0x69, 0x63, 0x6f, 0x00, 0x46, 0x65, 0x6c, 0x65, 0x63,
+    0x69, 0x61, 0x00, 0x46, 0x65, 0x6c, 0x69, 0x63, 0x61, 0x00, 0x46, 0x65,
+    0x6c, 0x69, 0x63, 0x65, 0x00, 0x46, 0x65, 0x6c, 0x69, 0x63, 0x69, 0x61,
+    0x00, 0x46, 0x65, 0x6c, 0x69, 0x63, 0x69, 0x64, 0x61, 0x64, 0x00, 0x46,
+    0x65, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x61, 0x00, 0x46, 0x65, 0x6c, 0x69,
+    0x63, 0x69, 0x74, 0x61, 0x73, 0x00, 0x46, 0x65, 0x6c, 0x69, 0x70, 0x61,
+    0x00, 0x46, 0x65, 0x6c, 0x69, 0x70, 0x65, 0x00, 0x46, 0x65, 0x6c, 0x69,
+    0x73, 0x61, 0x00, 0x46, 0x65, 0x6c, 0x69, 0x73, 0x68, 0x61, 0x00, 0x46,
+    0x65, 0x6c, 0x69, 0x78, 0x00, 0x46, 0x65, 0x6c, 0x74, 0x6f, 0x6e, 0x00,
+    0x46, 0x65, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6e, 0x64, 0x00, 0x46, 0x65,
+    0x72, 0x6d, 0x69, 0x6e, 0x00, 0x46, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61,
+    0x00, 0x46, 0x65, 0x72, 0x6e, 0x00, 0x46, 0x65, 0x72, 0x6e, 0x61, 0x6e,
+    0x64, 0x61, 0x00, 0x46, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x64, 0x65, 0x00,
+    0x46, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x64, 0x6f, 0x00, 0x46, 0x65, 0x72,
+    0x6e, 0x65, 0x00, 0x46, 0x69, 0x64, 0x65, 0x6c, 0x00, 0x46, 0x69, 0x64,
+    0x65, 0x6c, 0x61, 0x00, 0x46, 0x69, 0x64, 0x65, 0x6c, 0x69, 0x61, 0x00,
+    0x46, 0x69, 0x6c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x00, 0x46, 0x69,
+    0x6c, 0x6f, 0x6d, 0x65, 0x6e, 0x61, 0x00, 0x46, 0x69, 0x6f, 0x6e, 0x61,
+    0x00, 0x46, 0x6c, 0x61, 0x76, 0x69, 0x61, 0x00, 0x46, 0x6c, 0x65, 0x74,
+    0x61, 0x00, 0x46, 0x6c, 0x65, 0x74, 0x63, 0x68, 0x65, 0x72, 0x00, 0x46,
+    0x6c, 0x6f, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x61, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x46,
+    0x6c, 0x6f, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x65, 0x6e, 0x63, 0x69, 0x61, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x65, 0x6e,
+    0x63, 0x69, 0x6f, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x65, 0x6e, 0x65, 0x00,
+    0x46, 0x6c, 0x6f, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x46,
+    0x6c, 0x6f, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x6f, 0x00, 0x46, 0x6c,
+    0x6f, 0x72, 0x65, 0x74, 0x74, 0x61, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69,
+    0x61, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x46, 0x6c,
+    0x6f, 0x72, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69,
+    0x6e, 0x65, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x72, 0x69, 0x65, 0x00, 0x46,
+    0x6c, 0x6f, 0x73, 0x73, 0x69, 0x65, 0x00, 0x46, 0x6c, 0x6f, 0x79, 0x00,
+    0x46, 0x6c, 0x6f, 0x79, 0x64, 0x00, 0x46, 0x6f, 0x6e, 0x64, 0x61, 0x00,
+    0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x00, 0x46, 0x6f, 0x72, 0x72, 0x65,
+    0x73, 0x74, 0x00, 0x46, 0x6f, 0x73, 0x74, 0x65, 0x72, 0x00, 0x46, 0x72,
+    0x61, 0x6e, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x46, 0x72,
+    0x61, 0x6e, 0x63, 0x65, 0x6e, 0x65, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63,
+    0x65, 0x73, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x63, 0x61,
+    0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x63, 0x6f, 0x00, 0x46,
+    0x72, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x63, 0x61, 0x00, 0x46, 0x72,
+    0x61, 0x6e, 0x63, 0x69, 0x65, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69,
+    0x6e, 0x61, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x6e, 0x65, 0x00,
+    0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73, 0x00, 0x46, 0x72, 0x61, 0x6e,
+    0x63, 0x69, 0x73, 0x63, 0x61, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69,
+    0x73, 0x63, 0x6f, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x6f, 0x69, 0x73,
+    0x65, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x00, 0x46, 0x72, 0x61, 0x6e,
+    0x6b, 0x69, 0x65, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e,
+    0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x79, 0x6e, 0x00, 0x46, 0x72,
+    0x61, 0x6e, 0x73, 0x69, 0x73, 0x63, 0x61, 0x00, 0x46, 0x72, 0x65, 0x64,
+    0x00, 0x46, 0x72, 0x65, 0x64, 0x61, 0x00, 0x46, 0x72, 0x65, 0x64, 0x64,
+    0x61, 0x00, 0x46, 0x72, 0x65, 0x64, 0x64, 0x69, 0x65, 0x00, 0x46, 0x72,
+    0x65, 0x64, 0x64, 0x79, 0x00, 0x46, 0x72, 0x65, 0x64, 0x65, 0x72, 0x69,
+    0x63, 0x00, 0x46, 0x72, 0x65, 0x64, 0x65, 0x72, 0x69, 0x63, 0x61, 0x00,
+    0x46, 0x72, 0x65, 0x64, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x46, 0x72,
+    0x65, 0x64, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x61, 0x00, 0x46, 0x72, 0x65,
+    0x64, 0x69, 0x61, 0x00, 0x46, 0x72, 0x65, 0x64, 0x72, 0x69, 0x63, 0x00,
+    0x46, 0x72, 0x65, 0x64, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x46, 0x72, 0x65,
+    0x64, 0x72, 0x69, 0x63, 0x6b, 0x61, 0x00, 0x46, 0x72, 0x65, 0x65, 0x64,
+    0x61, 0x00, 0x46, 0x72, 0x65, 0x65, 0x6d, 0x61, 0x6e, 0x00, 0x46, 0x72,
+    0x65, 0x69, 0x64, 0x61, 0x00, 0x46, 0x72, 0x69, 0x64, 0x61, 0x00, 0x46,
+    0x72, 0x69, 0x65, 0x64, 0x61, 0x00, 0x46, 0x72, 0x69, 0x74, 0x7a, 0x00,
+    0x46, 0x75, 0x6d, 0x69, 0x6b, 0x6f, 0x00, 0x47, 0x61, 0x62, 0x72, 0x69,
+    0x65, 0x6c, 0x00, 0x47, 0x61, 0x62, 0x72, 0x69, 0x65, 0x6c, 0x61, 0x00,
+    0x47, 0x61, 0x62, 0x72, 0x69, 0x65, 0x6c, 0x65, 0x00, 0x47, 0x61, 0x62,
+    0x72, 0x69, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x47, 0x61, 0x62, 0x72, 0x69,
+    0x65, 0x6c, 0x6c, 0x65, 0x00, 0x47, 0x61, 0x69, 0x6c, 0x00, 0x47, 0x61,
+    0x6c, 0x61, 0x00, 0x47, 0x61, 0x6c, 0x65, 0x00, 0x47, 0x61, 0x6c, 0x65,
+    0x6e, 0x00, 0x47, 0x61, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x47, 0x61, 0x72,
+    0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x47, 0x61, 0x72, 0x6c, 0x61, 0x6e,
+    0x64, 0x00, 0x47, 0x61, 0x72, 0x6e, 0x65, 0x74, 0x00, 0x47, 0x61, 0x72,
+    0x6e, 0x65, 0x74, 0x74, 0x00, 0x47, 0x61, 0x72, 0x72, 0x65, 0x74, 0x00,
+    0x47, 0x61, 0x72, 0x72, 0x65, 0x74, 0x74, 0x00, 0x47, 0x61, 0x72, 0x72,
+    0x79, 0x00, 0x47, 0x61, 0x72, 0x74, 0x68, 0x00, 0x47, 0x61, 0x72, 0x79,
+    0x00, 0x47, 0x61, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x47, 0x61, 0x76, 0x69,
+    0x6e, 0x00, 0x47, 0x61, 0x79, 0x00, 0x47, 0x61, 0x79, 0x65, 0x00, 0x47,
+    0x61, 0x79, 0x6c, 0x61, 0x00, 0x47, 0x61, 0x79, 0x6c, 0x65, 0x00, 0x47,
+    0x61, 0x79, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x47, 0x61, 0x79, 0x6c, 0x6f,
+    0x72, 0x64, 0x00, 0x47, 0x61, 0x79, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x47,
+    0x61, 0x79, 0x6e, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x47, 0x65, 0x61, 0x72,
+    0x6c, 0x64, 0x69, 0x6e, 0x65, 0x00, 0x47, 0x65, 0x6d, 0x61, 0x00, 0x47,
+    0x65, 0x6d, 0x6d, 0x61, 0x00, 0x47, 0x65, 0x6e, 0x61, 0x00, 0x47, 0x65,
+    0x6e, 0x61, 0x72, 0x6f, 0x00, 0x47, 0x65, 0x6e, 0x65, 0x00, 0x47, 0x65,
+    0x6e, 0x65, 0x73, 0x69, 0x73, 0x00, 0x47, 0x65, 0x6e, 0x65, 0x76, 0x61,
+    0x00, 0x47, 0x65, 0x6e, 0x65, 0x76, 0x69, 0x65, 0x00, 0x47, 0x65, 0x6e,
+    0x65, 0x76, 0x69, 0x65, 0x76, 0x65, 0x00, 0x47, 0x65, 0x6e, 0x65, 0x76,
+    0x69, 0x76, 0x65, 0x00, 0x47, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x47, 0x65,
+    0x6e, 0x69, 0x65, 0x00, 0x47, 0x65, 0x6e, 0x6e, 0x61, 0x00, 0x47, 0x65,
+    0x6e, 0x6e, 0x69, 0x65, 0x00, 0x47, 0x65, 0x6e, 0x6e, 0x79, 0x00, 0x47,
+    0x65, 0x6e, 0x6f, 0x76, 0x65, 0x76, 0x61, 0x00, 0x47, 0x65, 0x6f, 0x66,
+    0x66, 0x72, 0x65, 0x79, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x61, 0x6e,
+    0x6e, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x65, 0x61, 0x6e, 0x6e, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x65, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65,
+    0x6e, 0x65, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x74, 0x74, 0x61,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x74, 0x74, 0x65, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x6e, 0x6e, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x6e, 0x6e,
+    0x61, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x6e, 0x6e, 0x65,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x65, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x6e, 0x61, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x6e, 0x65, 0x00, 0x47, 0x65, 0x72, 0x61, 0x6c, 0x64, 0x00, 0x47, 0x65,
+    0x72, 0x61, 0x6c, 0x64, 0x69, 0x6e, 0x65, 0x00, 0x47, 0x65, 0x72, 0x61,
+    0x6c, 0x64, 0x6f, 0x00, 0x47, 0x65, 0x72, 0x61, 0x6c, 0x79, 0x6e, 0x00,
+    0x47, 0x65, 0x72, 0x61, 0x72, 0x64, 0x00, 0x47, 0x65, 0x72, 0x61, 0x72,
+    0x64, 0x6f, 0x00, 0x47, 0x65, 0x72, 0x64, 0x61, 0x00, 0x47, 0x65, 0x72,
+    0x69, 0x00, 0x47, 0x65, 0x72, 0x6d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x47,
+    0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x47, 0x65, 0x72, 0x72, 0x69, 0x00,
+    0x47, 0x65, 0x72, 0x72, 0x79, 0x00, 0x47, 0x65, 0x72, 0x74, 0x68, 0x61,
+    0x00, 0x47, 0x65, 0x72, 0x74, 0x69, 0x65, 0x00, 0x47, 0x65, 0x72, 0x74,
+    0x72, 0x75, 0x64, 0x00, 0x47, 0x65, 0x72, 0x74, 0x72, 0x75, 0x64, 0x65,
+    0x00, 0x47, 0x65, 0x72, 0x74, 0x72, 0x75, 0x64, 0x69, 0x73, 0x00, 0x47,
+    0x65, 0x72, 0x74, 0x75, 0x64, 0x65, 0x00, 0x47, 0x68, 0x69, 0x73, 0x6c,
+    0x61, 0x69, 0x6e, 0x65, 0x00, 0x47, 0x69, 0x61, 0x00, 0x47, 0x69, 0x61,
+    0x6e, 0x6e, 0x61, 0x00, 0x47, 0x69, 0x64, 0x67, 0x65, 0x74, 0x00, 0x47,
+    0x69, 0x67, 0x69, 0x00, 0x47, 0x69, 0x6c, 0x00, 0x47, 0x69, 0x6c, 0x62,
+    0x65, 0x72, 0x74, 0x00, 0x47, 0x69, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x65,
+    0x00, 0x47, 0x69, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x00, 0x47, 0x69,
+    0x6c, 0x64, 0x61, 0x00, 0x47, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x00,
+    0x47, 0x69, 0x6c, 0x6d, 0x61, 0x00, 0x47, 0x69, 0x6e, 0x61, 0x00, 0x47,
+    0x69, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x47, 0x69, 0x6e, 0x67, 0x65,
+    0x72, 0x00, 0x47, 0x69, 0x6e, 0x6e, 0x79, 0x00, 0x47, 0x69, 0x6e, 0x6f,
+    0x00, 0x47, 0x69, 0x6f, 0x76, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x47, 0x69,
+    0x6f, 0x76, 0x61, 0x6e, 0x6e, 0x69, 0x00, 0x47, 0x69, 0x73, 0x65, 0x6c,
+    0x61, 0x00, 0x47, 0x69, 0x73, 0x65, 0x6c, 0x65, 0x00, 0x47, 0x69, 0x73,
+    0x65, 0x6c, 0x6c, 0x65, 0x00, 0x47, 0x69, 0x74, 0x61, 0x00, 0x47, 0x69,
+    0x75, 0x73, 0x65, 0x70, 0x70, 0x65, 0x00, 0x47, 0x69, 0x75, 0x73, 0x65,
+    0x70, 0x70, 0x69, 0x6e, 0x61, 0x00, 0x47, 0x6c, 0x61, 0x64, 0x69, 0x73,
+    0x00, 0x47, 0x6c, 0x61, 0x64, 0x79, 0x00, 0x47, 0x6c, 0x61, 0x64, 0x79,
+    0x73, 0x00, 0x47, 0x6c, 0x61, 0x79, 0x64, 0x73, 0x00, 0x47, 0x6c, 0x65,
+    0x6e, 0x00, 0x47, 0x6c, 0x65, 0x6e, 0x64, 0x61, 0x00, 0x47, 0x6c, 0x65,
+    0x6e, 0x64, 0x6f, 0x72, 0x61, 0x00, 0x47, 0x6c, 0x65, 0x6e, 0x6e, 0x00,
+    0x47, 0x6c, 0x65, 0x6e, 0x6e, 0x61, 0x00, 0x47, 0x6c, 0x65, 0x6e, 0x6e,
+    0x69, 0x65, 0x00, 0x47, 0x6c, 0x65, 0x6e, 0x6e, 0x69, 0x73, 0x00, 0x47,
+    0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x47, 0x6c, 0x6f, 0x72, 0x69, 0x61,
+    0x00, 0x47, 0x6c, 0x6f, 0x72, 0x79, 0x00, 0x47, 0x6c, 0x79, 0x6e, 0x64,
+    0x61, 0x00, 0x47, 0x6c, 0x79, 0x6e, 0x69, 0x73, 0x00, 0x47, 0x6f, 0x6c,
+    0x64, 0x61, 0x00, 0x47, 0x6f, 0x6c, 0x64, 0x65, 0x6e, 0x00, 0x47, 0x6f,
+    0x6c, 0x64, 0x69, 0x65, 0x00, 0x47, 0x6f, 0x6e, 0x7a, 0x61, 0x6c, 0x6f,
+    0x00, 0x47, 0x6f, 0x72, 0x64, 0x6f, 0x6e, 0x00, 0x47, 0x72, 0x61, 0x63,
+    0x65, 0x00, 0x47, 0x72, 0x61, 0x63, 0x69, 0x61, 0x00, 0x47, 0x72, 0x61,
+    0x63, 0x69, 0x65, 0x00, 0x47, 0x72, 0x61, 0x63, 0x69, 0x65, 0x6c, 0x61,
+    0x00, 0x47, 0x72, 0x61, 0x64, 0x79, 0x00, 0x47, 0x72, 0x61, 0x68, 0x61,
+    0x6d, 0x00, 0x47, 0x72, 0x61, 0x69, 0x67, 0x00, 0x47, 0x72, 0x61, 0x6e,
+    0x74, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00,
+    0x47, 0x72, 0x61, 0x79, 0x63, 0x65, 0x00, 0x47, 0x72, 0x61, 0x7a, 0x79,
+    0x6e, 0x61, 0x00, 0x47, 0x72, 0x65, 0x67, 0x00, 0x47, 0x72, 0x65, 0x67,
+    0x67, 0x00, 0x47, 0x72, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x61, 0x00, 0x47,
+    0x72, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x6f, 0x00, 0x47, 0x72, 0x65, 0x67,
+    0x6f, 0x72, 0x79, 0x00, 0x47, 0x72, 0x65, 0x74, 0x61, 0x00, 0x47, 0x72,
+    0x65, 0x74, 0x63, 0x68, 0x65, 0x6e, 0x00, 0x47, 0x72, 0x65, 0x74, 0x74,
+    0x61, 0x00, 0x47, 0x72, 0x69, 0x63, 0x65, 0x6c, 0x64, 0x61, 0x00, 0x47,
+    0x72, 0x69, 0x73, 0x65, 0x6c, 0x00, 0x47, 0x72, 0x69, 0x73, 0x65, 0x6c,
+    0x64, 0x61, 0x00, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x47, 0x75,
+    0x61, 0x64, 0x61, 0x6c, 0x75, 0x70, 0x65, 0x00, 0x47, 0x75, 0x64, 0x72,
+    0x75, 0x6e, 0x00, 0x47, 0x75, 0x69, 0x6c, 0x6c, 0x65, 0x72, 0x6d, 0x69,
+    0x6e, 0x61, 0x00, 0x47, 0x75, 0x69, 0x6c, 0x6c, 0x65, 0x72, 0x6d, 0x6f,
+    0x00, 0x47, 0x75, 0x73, 0x00, 0x47, 0x75, 0x73, 0x73, 0x69, 0x65, 0x00,
+    0x47, 0x75, 0x73, 0x74, 0x61, 0x76, 0x6f, 0x00, 0x47, 0x75, 0x79, 0x00,
+    0x47, 0x77, 0x65, 0x6e, 0x00, 0x47, 0x77, 0x65, 0x6e, 0x64, 0x61, 0x00,
+    0x47, 0x77, 0x65, 0x6e, 0x64, 0x6f, 0x6c, 0x79, 0x6e, 0x00, 0x47, 0x77,
+    0x65, 0x6e, 0x6e, 0x00, 0x47, 0x77, 0x79, 0x6e, 0x00, 0x47, 0x77, 0x79,
+    0x6e, 0x65, 0x74, 0x68, 0x00, 0x48, 0x61, 0x00, 0x48, 0x61, 0x65, 0x00,
+    0x48, 0x61, 0x69, 0x00, 0x48, 0x61, 0x69, 0x6c, 0x65, 0x79, 0x00, 0x48,
+    0x61, 0x6c, 0x00, 0x48, 0x61, 0x6c, 0x65, 0x79, 0x00, 0x48, 0x61, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x48, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x48,
+    0x61, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x48, 0x61, 0x6e, 0x00, 0x48, 0x61,
+    0x6e, 0x61, 0x00, 0x48, 0x61, 0x6e, 0x67, 0x00, 0x48, 0x61, 0x6e, 0x68,
+    0x00, 0x48, 0x61, 0x6e, 0x6b, 0x00, 0x48, 0x61, 0x6e, 0x6e, 0x61, 0x00,
+    0x48, 0x61, 0x6e, 0x6e, 0x61, 0x68, 0x00, 0x48, 0x61, 0x6e, 0x6e, 0x65,
+    0x6c, 0x6f, 0x72, 0x65, 0x00, 0x48, 0x61, 0x6e, 0x73, 0x00, 0x48, 0x61,
+    0x72, 0x6c, 0x61, 0x6e, 0x00, 0x48, 0x61, 0x72, 0x6c, 0x61, 0x6e, 0x64,
+    0x00, 0x48, 0x61, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x48, 0x61, 0x72, 0x6d,
+    0x6f, 0x6e, 0x79, 0x00, 0x48, 0x61, 0x72, 0x6f, 0x6c, 0x64, 0x00, 0x48,
+    0x61, 0x72, 0x72, 0x69, 0x65, 0x74, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69,
+    0x65, 0x74, 0x74, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73, 0x00, 0x48, 0x61, 0x72,
+    0x72, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x61, 0x72, 0x72, 0x79, 0x00,
+    0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x00, 0x48, 0x61, 0x73, 0x73, 0x61,
+    0x6e, 0x00, 0x48, 0x61, 0x73, 0x73, 0x69, 0x65, 0x00, 0x48, 0x61, 0x74,
+    0x74, 0x69, 0x65, 0x00, 0x48, 0x61, 0x79, 0x64, 0x65, 0x65, 0x00, 0x48,
+    0x61, 0x79, 0x64, 0x65, 0x6e, 0x00, 0x48, 0x61, 0x79, 0x6c, 0x65, 0x79,
+    0x00, 0x48, 0x61, 0x79, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x48, 0x61, 0x7a,
+    0x65, 0x6c, 0x00, 0x48, 0x65, 0x61, 0x74, 0x68, 0x00, 0x48, 0x65, 0x61,
+    0x74, 0x68, 0x65, 0x72, 0x00, 0x48, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x00,
+    0x48, 0x65, 0x64, 0x77, 0x69, 0x67, 0x00, 0x48, 0x65, 0x64, 0x79, 0x00,
+    0x48, 0x65, 0x65, 0x00, 0x48, 0x65, 0x69, 0x64, 0x65, 0x00, 0x48, 0x65,
+    0x69, 0x64, 0x69, 0x00, 0x48, 0x65, 0x69, 0x64, 0x79, 0x00, 0x48, 0x65,
+    0x69, 0x6b, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x61, 0x69, 0x6e, 0x65, 0x00,
+    0x48, 0x65, 0x6c, 0x65, 0x6e, 0x00, 0x48, 0x65, 0x6c, 0x65, 0x6e, 0x61,
+    0x00, 0x48, 0x65, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x67,
+    0x61, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x48, 0x65, 0x6e,
+    0x72, 0x69, 0x65, 0x74, 0x74, 0x61, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x69,
+    0x65, 0x74, 0x74, 0x65, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x00, 0x48,
+    0x65, 0x72, 0x62, 0x00, 0x48, 0x65, 0x72, 0x62, 0x65, 0x72, 0x74, 0x00,
+    0x48, 0x65, 0x72, 0x69, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x00, 0x48, 0x65,
+    0x72, 0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x48, 0x65, 0x72, 0x6d, 0x61,
+    0x00, 0x48, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x48, 0x65, 0x72, 0x6d,
+    0x65, 0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x48, 0x65, 0x72, 0x6d, 0x69,
+    0x6c, 0x61, 0x00, 0x48, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x00, 0x48,
+    0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x00, 0x48, 0x65, 0x72, 0x6d, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x48, 0x65, 0x72, 0x73, 0x63, 0x68, 0x65, 0x6c,
+    0x00, 0x48, 0x65, 0x72, 0x73, 0x68, 0x65, 0x6c, 0x00, 0x48, 0x65, 0x72,
+    0x74, 0x61, 0x00, 0x48, 0x65, 0x72, 0x74, 0x68, 0x61, 0x00, 0x48, 0x65,
+    0x73, 0x74, 0x65, 0x72, 0x00, 0x48, 0x65, 0x74, 0x74, 0x69, 0x65, 0x00,
+    0x48, 0x69, 0x65, 0x64, 0x69, 0x00, 0x48, 0x69, 0x65, 0x6e, 0x00, 0x48,
+    0x69, 0x6c, 0x61, 0x72, 0x69, 0x61, 0x00, 0x48, 0x69, 0x6c, 0x61, 0x72,
+    0x69, 0x6f, 0x00, 0x48, 0x69, 0x6c, 0x61, 0x72, 0x79, 0x00, 0x48, 0x69,
+    0x6c, 0x64, 0x61, 0x00, 0x48, 0x69, 0x6c, 0x64, 0x65, 0x00, 0x48, 0x69,
+    0x6c, 0x64, 0x65, 0x67, 0x61, 0x72, 0x64, 0x00, 0x48, 0x69, 0x6c, 0x64,
+    0x65, 0x67, 0x61, 0x72, 0x64, 0x65, 0x00, 0x48, 0x69, 0x6c, 0x64, 0x72,
+    0x65, 0x64, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x79, 0x00, 0x48,
+    0x69, 0x6c, 0x6d, 0x61, 0x00, 0x48, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x00,
+    0x48, 0x69, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x6f, 0x00, 0x48, 0x69, 0x72,
+    0x61, 0x6d, 0x00, 0x48, 0x69, 0x72, 0x6f, 0x6b, 0x6f, 0x00, 0x48, 0x69,
+    0x73, 0x61, 0x6b, 0x6f, 0x00, 0x48, 0x6f, 0x61, 0x00, 0x48, 0x6f, 0x62,
+    0x65, 0x72, 0x74, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x48,
+    0x6f, 0x6c, 0x6c, 0x69, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x69, 0x65, 0x00,
+    0x48, 0x6f, 0x6c, 0x6c, 0x69, 0x73, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x79,
+    0x00, 0x48, 0x6f, 0x6d, 0x65, 0x72, 0x00, 0x48, 0x6f, 0x6e, 0x65, 0x79,
+    0x00, 0x48, 0x6f, 0x6e, 0x67, 0x00, 0x48, 0x6f, 0x70, 0x65, 0x00, 0x48,
+    0x6f, 0x72, 0x61, 0x63, 0x65, 0x00, 0x48, 0x6f, 0x72, 0x61, 0x63, 0x69,
+    0x6f, 0x00, 0x48, 0x6f, 0x72, 0x74, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x00,
+    0x48, 0x6f, 0x72, 0x74, 0x65, 0x6e, 0x73, 0x65, 0x00, 0x48, 0x6f, 0x72,
+    0x74, 0x65, 0x6e, 0x73, 0x69, 0x61, 0x00, 0x48, 0x6f, 0x73, 0x65, 0x61,
+    0x00, 0x48, 0x6f, 0x75, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x48, 0x6f, 0x77,
+    0x61, 0x72, 0x64, 0x00, 0x48, 0x6f, 0x79, 0x74, 0x00, 0x48, 0x73, 0x69,
+    0x75, 0x00, 0x48, 0x75, 0x62, 0x65, 0x72, 0x74, 0x00, 0x48, 0x75, 0x65,
+    0x00, 0x48, 0x75, 0x65, 0x79, 0x00, 0x48, 0x75, 0x67, 0x68, 0x00, 0x48,
+    0x75, 0x67, 0x6f, 0x00, 0x48, 0x75, 0x69, 0x00, 0x48, 0x75, 0x6c, 0x64,
+    0x61, 0x00, 0x48, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x00, 0x48,
+    0x75, 0x6e, 0x67, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x48,
+    0x75, 0x6f, 0x6e, 0x67, 0x00, 0x48, 0x77, 0x61, 0x00, 0x48, 0x79, 0x61,
+    0x63, 0x69, 0x6e, 0x74, 0x68, 0x00, 0x48, 0x79, 0x65, 0x00, 0x48, 0x79,
+    0x6d, 0x61, 0x6e, 0x00, 0x48, 0x79, 0x6f, 0x00, 0x48, 0x79, 0x6f, 0x6e,
+    0x00, 0x48, 0x79, 0x75, 0x6e, 0x00, 0x49, 0x61, 0x6e, 0x00, 0x49, 0x64,
+    0x61, 0x00, 0x49, 0x64, 0x61, 0x6c, 0x69, 0x61, 0x00, 0x49, 0x64, 0x65,
+    0x6c, 0x6c, 0x00, 0x49, 0x64, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x49, 0x65,
+    0x73, 0x68, 0x61, 0x00, 0x49, 0x67, 0x6e, 0x61, 0x63, 0x69, 0x61, 0x00,
+    0x49, 0x67, 0x6e, 0x61, 0x63, 0x69, 0x6f, 0x00, 0x49, 0x6b, 0x65, 0x00,
+    0x49, 0x6c, 0x61, 0x00, 0x49, 0x6c, 0x61, 0x6e, 0x61, 0x00, 0x49, 0x6c,
+    0x64, 0x61, 0x00, 0x49, 0x6c, 0x65, 0x61, 0x6e, 0x61, 0x00, 0x49, 0x6c,
+    0x65, 0x65, 0x6e, 0x00, 0x49, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x49, 0x6c,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x49, 0x6c, 0x6c, 0x61, 0x00, 0x49, 0x6c,
+    0x6f, 0x6e, 0x61, 0x00, 0x49, 0x6c, 0x73, 0x65, 0x00, 0x49, 0x6c, 0x75,
+    0x6d, 0x69, 0x6e, 0x61, 0x64, 0x61, 0x00, 0x49, 0x6d, 0x61, 0x00, 0x49,
+    0x6d, 0x65, 0x6c, 0x64, 0x61, 0x00, 0x49, 0x6d, 0x6f, 0x67, 0x65, 0x6e,
+    0x65, 0x00, 0x49, 0x6e, 0x00, 0x49, 0x6e, 0x61, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x72, 0x61, 0x00, 0x49, 0x6e,
+    0x65, 0x6c, 0x6c, 0x00, 0x49, 0x6e, 0x65, 0x73, 0x00, 0x49, 0x6e, 0x65,
+    0x7a, 0x00, 0x49, 0x6e, 0x67, 0x61, 0x00, 0x49, 0x6e, 0x67, 0x65, 0x00,
+    0x49, 0x6e, 0x67, 0x65, 0x62, 0x6f, 0x72, 0x67, 0x00, 0x49, 0x6e, 0x67,
+    0x65, 0x72, 0x00, 0x49, 0x6e, 0x67, 0x72, 0x69, 0x64, 0x00, 0x49, 0x6e,
+    0x6f, 0x63, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x00, 0x49, 0x6f, 0x6c, 0x61,
+    0x00, 0x49, 0x6f, 0x6e, 0x61, 0x00, 0x49, 0x6f, 0x6e, 0x65, 0x00, 0x49,
+    0x72, 0x61, 0x00, 0x49, 0x72, 0x61, 0x69, 0x64, 0x61, 0x00, 0x49, 0x72,
+    0x65, 0x6e, 0x61, 0x00, 0x49, 0x72, 0x65, 0x6e, 0x65, 0x00, 0x49, 0x72,
+    0x69, 0x6e, 0x61, 0x00, 0x49, 0x72, 0x69, 0x73, 0x00, 0x49, 0x72, 0x69,
+    0x73, 0x68, 0x00, 0x49, 0x72, 0x6d, 0x61, 0x00, 0x49, 0x72, 0x6d, 0x67,
+    0x61, 0x72, 0x64, 0x00, 0x49, 0x72, 0x76, 0x69, 0x6e, 0x00, 0x49, 0x72,
+    0x76, 0x69, 0x6e, 0x67, 0x00, 0x49, 0x72, 0x77, 0x69, 0x6e, 0x00, 0x49,
+    0x73, 0x61, 0x00, 0x49, 0x73, 0x61, 0x61, 0x63, 0x00, 0x49, 0x73, 0x61,
+    0x62, 0x65, 0x6c, 0x00, 0x49, 0x73, 0x61, 0x62, 0x65, 0x6c, 0x6c, 0x00,
+    0x49, 0x73, 0x61, 0x62, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x49, 0x73, 0x61,
+    0x62, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x49, 0x73, 0x61, 0x64, 0x6f, 0x72,
+    0x61, 0x00, 0x49, 0x73, 0x61, 0x69, 0x61, 0x68, 0x00, 0x49, 0x73, 0x61,
+    0x69, 0x61, 0x73, 0x00, 0x49, 0x73, 0x61, 0x75, 0x72, 0x61, 0x00, 0x49,
+    0x73, 0x65, 0x6c, 0x61, 0x00, 0x49, 0x73, 0x69, 0x61, 0x68, 0x00, 0x49,
+    0x73, 0x69, 0x64, 0x72, 0x61, 0x00, 0x49, 0x73, 0x69, 0x64, 0x72, 0x6f,
+    0x00, 0x49, 0x73, 0x69, 0x73, 0x00, 0x49, 0x73, 0x6d, 0x61, 0x65, 0x6c,
+    0x00, 0x49, 0x73, 0x6f, 0x62, 0x65, 0x6c, 0x00, 0x49, 0x73, 0x72, 0x61,
+    0x65, 0x6c, 0x00, 0x49, 0x73, 0x72, 0x65, 0x61, 0x6c, 0x00, 0x49, 0x73,
+    0x73, 0x61, 0x63, 0x00, 0x49, 0x76, 0x61, 0x00, 0x49, 0x76, 0x61, 0x6e,
+    0x00, 0x49, 0x76, 0x61, 0x6e, 0x61, 0x00, 0x49, 0x76, 0x65, 0x6c, 0x69,
+    0x73, 0x73, 0x65, 0x00, 0x49, 0x76, 0x65, 0x74, 0x74, 0x65, 0x00, 0x49,
+    0x76, 0x65, 0x79, 0x00, 0x49, 0x76, 0x6f, 0x6e, 0x6e, 0x65, 0x00, 0x49,
+    0x76, 0x6f, 0x72, 0x79, 0x00, 0x49, 0x76, 0x79, 0x00, 0x49, 0x7a, 0x65,
+    0x74, 0x74, 0x61, 0x00, 0x49, 0x7a, 0x6f, 0x6c, 0x61, 0x00, 0x4a, 0x61,
+    0x00, 0x4a, 0x61, 0x63, 0x61, 0x6c, 0x79, 0x6e, 0x00, 0x4a, 0x61, 0x63,
+    0x65, 0x6c, 0x79, 0x6e, 0x00, 0x4a, 0x61, 0x63, 0x69, 0x6e, 0x64, 0x61,
+    0x00, 0x4a, 0x61, 0x63, 0x69, 0x6e, 0x74, 0x61, 0x00, 0x4a, 0x61, 0x63,
+    0x69, 0x6e, 0x74, 0x6f, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x00, 0x4a, 0x61,
+    0x63, 0x6b, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x61, 0x63, 0x6b,
+    0x65, 0x6c, 0x79, 0x6e, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x69, 0x00, 0x4a,
+    0x61, 0x63, 0x6b, 0x69, 0x65, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x6c, 0x79,
+    0x6e, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x71, 0x75, 0x65, 0x6c, 0x69, 0x6e,
+    0x65, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x61,
+    0x63, 0x6c, 0x79, 0x6e, 0x00, 0x4a, 0x61, 0x63, 0x6f, 0x62, 0x00, 0x4a,
+    0x61, 0x63, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x61,
+    0x63, 0x71, 0x75, 0x65, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75, 0x65, 0x6c,
+    0x69, 0x6e, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75, 0x65, 0x6c, 0x69, 0x6e,
+    0x65, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75, 0x65, 0x6c, 0x79, 0x6e, 0x00,
+    0x4a, 0x61, 0x63, 0x71, 0x75, 0x65, 0x6c, 0x79, 0x6e, 0x65, 0x00, 0x4a,
+    0x61, 0x63, 0x71, 0x75, 0x65, 0x6c, 0x79, 0x6e, 0x6e, 0x00, 0x4a, 0x61,
+    0x63, 0x71, 0x75, 0x65, 0x73, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75, 0x65,
+    0x74, 0x74, 0x61, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75, 0x69, 0x00, 0x4a,
+    0x61, 0x63, 0x71, 0x75, 0x69, 0x65, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75,
+    0x69, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75, 0x6c,
+    0x69, 0x6e, 0x65, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75, 0x6c, 0x79, 0x6e,
+    0x00, 0x4a, 0x61, 0x64, 0x61, 0x00, 0x4a, 0x61, 0x64, 0x65, 0x00, 0x4a,
+    0x61, 0x64, 0x77, 0x69, 0x67, 0x61, 0x00, 0x4a, 0x61, 0x65, 0x00, 0x4a,
+    0x61, 0x69, 0x6d, 0x65, 0x00, 0x4a, 0x61, 0x69, 0x6d, 0x65, 0x65, 0x00,
+    0x4a, 0x61, 0x69, 0x6d, 0x69, 0x65, 0x00, 0x4a, 0x61, 0x6b, 0x65, 0x00,
+    0x4a, 0x61, 0x6c, 0x65, 0x65, 0x73, 0x61, 0x00, 0x4a, 0x61, 0x6c, 0x69,
+    0x73, 0x61, 0x00, 0x4a, 0x61, 0x6d, 0x61, 0x00, 0x4a, 0x61, 0x6d, 0x61,
+    0x61, 0x6c, 0x00, 0x4a, 0x61, 0x6d, 0x61, 0x6c, 0x00, 0x4a, 0x61, 0x6d,
+    0x61, 0x72, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x00, 0x4a, 0x61, 0x6d, 0x65,
+    0x65, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x6c, 0x00, 0x4a, 0x61, 0x6d, 0x65,
+    0x73, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x79, 0x00, 0x4a, 0x61, 0x6d, 0x69,
+    0x00, 0x4a, 0x61, 0x6d, 0x69, 0x65, 0x00, 0x4a, 0x61, 0x6d, 0x69, 0x6b,
+    0x61, 0x00, 0x4a, 0x61, 0x6d, 0x69, 0x6c, 0x61, 0x00, 0x4a, 0x61, 0x6d,
+    0x69, 0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x61, 0x6d, 0x6d, 0x69, 0x65, 0x00,
+    0x4a, 0x61, 0x6e, 0x00, 0x4a, 0x61, 0x6e, 0x61, 0x00, 0x4a, 0x61, 0x6e,
+    0x61, 0x65, 0x00, 0x4a, 0x61, 0x6e, 0x61, 0x79, 0x00, 0x4a, 0x61, 0x6e,
+    0x65, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x61, 0x6e, 0x00, 0x4a, 0x61, 0x6e,
+    0x65, 0x65, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x65, 0x6e, 0x00, 0x4a, 0x61,
+    0x6e, 0x65, 0x6c, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4a,
+    0x61, 0x6e, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x6c,
+    0x6c, 0x65, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x6e, 0x65, 0x00, 0x4a, 0x61,
+    0x6e, 0x65, 0x73, 0x73, 0x61, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x74, 0x00,
+    0x4a, 0x61, 0x6e, 0x65, 0x74, 0x68, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x74,
+    0x74, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4a, 0x61,
+    0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4a, 0x61, 0x6e, 0x65, 0x79, 0x00,
+    0x4a, 0x61, 0x6e, 0x69, 0x00, 0x4a, 0x61, 0x6e, 0x69, 0x63, 0x65, 0x00,
+    0x4a, 0x61, 0x6e, 0x69, 0x65, 0x00, 0x4a, 0x61, 0x6e, 0x69, 0x65, 0x63,
+    0x65, 0x00, 0x4a, 0x61, 0x6e, 0x69, 0x6e, 0x61, 0x00, 0x4a, 0x61, 0x6e,
+    0x69, 0x6e, 0x65, 0x00, 0x4a, 0x61, 0x6e, 0x69, 0x73, 0x00, 0x4a, 0x61,
+    0x6e, 0x69, 0x73, 0x65, 0x00, 0x4a, 0x61, 0x6e, 0x69, 0x74, 0x61, 0x00,
+    0x4a, 0x61, 0x6e, 0x6e, 0x00, 0x4a, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4a,
+    0x61, 0x6e, 0x6e, 0x65, 0x74, 0x00, 0x4a, 0x61, 0x6e, 0x6e, 0x65, 0x74,
+    0x74, 0x65, 0x00, 0x4a, 0x61, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x4a, 0x61,
+    0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x4a, 0x61, 0x6e, 0x79, 0x63, 0x65,
+    0x00, 0x4a, 0x61, 0x71, 0x75, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4a,
+    0x61, 0x71, 0x75, 0x65, 0x6c, 0x79, 0x6e, 0x00, 0x4a, 0x61, 0x72, 0x65,
+    0x64, 0x00, 0x4a, 0x61, 0x72, 0x6f, 0x64, 0x00, 0x4a, 0x61, 0x72, 0x72,
+    0x65, 0x64, 0x00, 0x4a, 0x61, 0x72, 0x72, 0x65, 0x74, 0x74, 0x00, 0x4a,
+    0x61, 0x72, 0x72, 0x6f, 0x64, 0x00, 0x4a, 0x61, 0x72, 0x76, 0x69, 0x73,
+    0x00, 0x4a, 0x61, 0x73, 0x6d, 0x69, 0x6e, 0x00, 0x4a, 0x61, 0x73, 0x6d,
+    0x69, 0x6e, 0x65, 0x00, 0x4a, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x61,
+    0x73, 0x70, 0x65, 0x72, 0x00, 0x4a, 0x61, 0x75, 0x6e, 0x69, 0x74, 0x61,
+    0x00, 0x4a, 0x61, 0x76, 0x69, 0x65, 0x72, 0x00, 0x4a, 0x61, 0x79, 0x00,
+    0x4a, 0x61, 0x79, 0x65, 0x00, 0x4a, 0x61, 0x79, 0x6d, 0x65, 0x00, 0x4a,
+    0x61, 0x79, 0x6d, 0x69, 0x65, 0x00, 0x4a, 0x61, 0x79, 0x6e, 0x61, 0x00,
+    0x4a, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x4a, 0x61, 0x79, 0x73, 0x6f, 0x6e,
+    0x00, 0x4a, 0x61, 0x7a, 0x6d, 0x69, 0x6e, 0x00, 0x4a, 0x61, 0x7a, 0x6d,
+    0x69, 0x6e, 0x65, 0x00, 0x4a, 0x63, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x00,
+    0x4a, 0x65, 0x61, 0x6e, 0x61, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x65, 0x00,
+    0x4a, 0x65, 0x61, 0x6e, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4a, 0x65, 0x61,
+    0x6e, 0x65, 0x6e, 0x65, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x65, 0x74, 0x74,
+    0x00, 0x4a, 0x65, 0x61, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4a, 0x65,
+    0x61, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x69,
+    0x63, 0x65, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x69, 0x65, 0x00, 0x4a, 0x65,
+    0x61, 0x6e, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x6d, 0x61,
+    0x72, 0x69, 0x65, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4a,
+    0x65, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x6e, 0x65,
+    0x74, 0x74, 0x61, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x6e, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x4a, 0x65, 0x61, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x4a, 0x65,
+    0x61, 0x6e, 0x6e, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x65, 0x64, 0x00, 0x4a,
+    0x65, 0x66, 0x66, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x65, 0x79,
+    0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x4a,
+    0x65, 0x66, 0x66, 0x65, 0x72, 0x79, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x69,
+    0x65, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x72, 0x65, 0x79, 0x00, 0x4a, 0x65,
+    0x66, 0x66, 0x72, 0x79, 0x00, 0x4a, 0x65, 0x6e, 0x00, 0x4a, 0x65, 0x6e,
+    0x61, 0x00, 0x4a, 0x65, 0x6e, 0x61, 0x65, 0x00, 0x4a, 0x65, 0x6e, 0x65,
+    0x00, 0x4a, 0x65, 0x6e, 0x65, 0x65, 0x00, 0x4a, 0x65, 0x6e, 0x65, 0x6c,
+    0x6c, 0x00, 0x4a, 0x65, 0x6e, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4a, 0x65,
+    0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4a, 0x65, 0x6e, 0x65, 0x76, 0x61,
+    0x00, 0x4a, 0x65, 0x6e, 0x69, 0x00, 0x4a, 0x65, 0x6e, 0x69, 0x63, 0x65,
+    0x00, 0x4a, 0x65, 0x6e, 0x69, 0x66, 0x65, 0x72, 0x00, 0x4a, 0x65, 0x6e,
+    0x69, 0x66, 0x66, 0x65, 0x72, 0x00, 0x4a, 0x65, 0x6e, 0x69, 0x6e, 0x65,
+    0x00, 0x4a, 0x65, 0x6e, 0x69, 0x73, 0x65, 0x00, 0x4a, 0x65, 0x6e, 0x6e,
+    0x61, 0x00, 0x4a, 0x65, 0x6e, 0x6e, 0x65, 0x66, 0x65, 0x72, 0x00, 0x4a,
+    0x65, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4a, 0x65, 0x6e, 0x6e, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x4a, 0x65, 0x6e, 0x6e, 0x69, 0x00, 0x4a, 0x65,
+    0x6e, 0x6e, 0x69, 0x65, 0x00, 0x4a, 0x65, 0x6e, 0x6e, 0x69, 0x66, 0x65,
+    0x72, 0x00, 0x4a, 0x65, 0x6e, 0x6e, 0x69, 0x66, 0x66, 0x65, 0x72, 0x00,
+    0x4a, 0x65, 0x6e, 0x6e, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x65, 0x6e, 0x6e,
+    0x79, 0x00, 0x4a, 0x65, 0x72, 0x61, 0x6c, 0x64, 0x00, 0x4a, 0x65, 0x72,
+    0x61, 0x6c, 0x64, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x65, 0x72, 0x61, 0x6d,
+    0x79, 0x00, 0x4a, 0x65, 0x72, 0x65, 0x00, 0x4a, 0x65, 0x72, 0x65, 0x6d,
+    0x69, 0x61, 0x68, 0x00, 0x4a, 0x65, 0x72, 0x65, 0x6d, 0x79, 0x00, 0x4a,
+    0x65, 0x72, 0x69, 0x00, 0x4a, 0x65, 0x72, 0x69, 0x63, 0x61, 0x00, 0x4a,
+    0x65, 0x72, 0x69, 0x6c, 0x79, 0x6e, 0x00, 0x4a, 0x65, 0x72, 0x6c, 0x65,
+    0x6e, 0x65, 0x00, 0x4a, 0x65, 0x72, 0x6d, 0x61, 0x69, 0x6e, 0x65, 0x00,
+    0x4a, 0x65, 0x72, 0x6f, 0x6c, 0x64, 0x00, 0x4a, 0x65, 0x72, 0x6f, 0x6d,
+    0x65, 0x00, 0x4a, 0x65, 0x72, 0x6f, 0x6d, 0x79, 0x00, 0x4a, 0x65, 0x72,
+    0x72, 0x65, 0x6c, 0x6c, 0x00, 0x4a, 0x65, 0x72, 0x72, 0x69, 0x00, 0x4a,
+    0x65, 0x72, 0x72, 0x69, 0x63, 0x61, 0x00, 0x4a, 0x65, 0x72, 0x72, 0x69,
+    0x65, 0x00, 0x4a, 0x65, 0x72, 0x72, 0x6f, 0x64, 0x00, 0x4a, 0x65, 0x72,
+    0x72, 0x6f, 0x6c, 0x64, 0x00, 0x4a, 0x65, 0x72, 0x72, 0x79, 0x00, 0x4a,
+    0x65, 0x73, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x4a, 0x65, 0x73, 0x69, 0x63,
+    0x61, 0x00, 0x4a, 0x65, 0x73, 0x73, 0x00, 0x4a, 0x65, 0x73, 0x73, 0x65,
+    0x00, 0x4a, 0x65, 0x73, 0x73, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x4a, 0x65,
+    0x73, 0x73, 0x69, 0x00, 0x4a, 0x65, 0x73, 0x73, 0x69, 0x61, 0x00, 0x4a,
+    0x65, 0x73, 0x73, 0x69, 0x63, 0x61, 0x00, 0x4a, 0x65, 0x73, 0x73, 0x69,
+    0x65, 0x00, 0x4a, 0x65, 0x73, 0x73, 0x69, 0x6b, 0x61, 0x00, 0x4a, 0x65,
+    0x73, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x65, 0x73, 0x75, 0x73, 0x00,
+    0x4a, 0x65, 0x73, 0x75, 0x73, 0x61, 0x00, 0x4a, 0x65, 0x73, 0x75, 0x73,
+    0x69, 0x74, 0x61, 0x00, 0x4a, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4a, 0x65,
+    0x74, 0x74, 0x69, 0x65, 0x00, 0x4a, 0x65, 0x77, 0x65, 0x6c, 0x00, 0x4a,
+    0x65, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4a, 0x69, 0x00, 0x4a, 0x69, 0x6c,
+    0x6c, 0x00, 0x4a, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x00, 0x4a, 0x69,
+    0x6d, 0x00, 0x4a, 0x69, 0x6d, 0x6d, 0x69, 0x65, 0x00, 0x4a, 0x69, 0x6d,
+    0x6d, 0x79, 0x00, 0x4a, 0x69, 0x6e, 0x00, 0x4a, 0x69, 0x6e, 0x61, 0x00,
+    0x4a, 0x69, 0x6e, 0x6e, 0x79, 0x00, 0x4a, 0x6f, 0x00, 0x4a, 0x6f, 0x61,
+    0x6e, 0x00, 0x4a, 0x6f, 0x61, 0x6e, 0x61, 0x00, 0x4a, 0x6f, 0x61, 0x6e,
+    0x65, 0x00, 0x4a, 0x6f, 0x61, 0x6e, 0x69, 0x65, 0x00, 0x4a, 0x6f, 0x61,
+    0x6e, 0x6e, 0x00, 0x4a, 0x6f, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4a, 0x6f,
+    0x61, 0x6e, 0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x61, 0x6e, 0x6e, 0x69, 0x65,
+    0x00, 0x4a, 0x6f, 0x61, 0x71, 0x75, 0x69, 0x6e, 0x00, 0x4a, 0x6f, 0x61,
+    0x71, 0x75, 0x69, 0x6e, 0x61, 0x00, 0x4a, 0x6f, 0x63, 0x65, 0x6c, 0x79,
+    0x6e, 0x00, 0x4a, 0x6f, 0x64, 0x65, 0x65, 0x00, 0x4a, 0x6f, 0x64, 0x69,
+    0x00, 0x4a, 0x6f, 0x64, 0x69, 0x65, 0x00, 0x4a, 0x6f, 0x64, 0x79, 0x00,
+    0x4a, 0x6f, 0x65, 0x00, 0x4a, 0x6f, 0x65, 0x61, 0x6e, 0x6e, 0x00, 0x4a,
+    0x6f, 0x65, 0x6c, 0x00, 0x4a, 0x6f, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4a,
+    0x6f, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4a, 0x6f, 0x65, 0x6c, 0x6c, 0x65,
+    0x6e, 0x00, 0x4a, 0x6f, 0x65, 0x73, 0x70, 0x68, 0x00, 0x4a, 0x6f, 0x65,
+    0x74, 0x74, 0x61, 0x00, 0x4a, 0x6f, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4a,
+    0x6f, 0x65, 0x79, 0x00, 0x4a, 0x6f, 0x68, 0x61, 0x6e, 0x61, 0x00, 0x4a,
+    0x6f, 0x68, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4a, 0x6f, 0x68, 0x61, 0x6e,
+    0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x00, 0x4a, 0x6f, 0x68, 0x6e,
+    0x61, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x61, 0x74, 0x68, 0x61, 0x6e, 0x00,
+    0x4a, 0x6f, 0x68, 0x6e, 0x61, 0x74, 0x68, 0x6f, 0x6e, 0x00, 0x4a, 0x6f,
+    0x68, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x69, 0x65, 0x00, 0x4a,
+    0x6f, 0x68, 0x6e, 0x6e, 0x61, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x6e, 0x69,
+    0x65, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x6e, 0x79, 0x00, 0x4a, 0x6f, 0x68,
+    0x6e, 0x73, 0x69, 0x65, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f, 0x6e,
+    0x00, 0x4a, 0x6f, 0x69, 0x00, 0x4a, 0x6f, 0x69, 0x65, 0x00, 0x4a, 0x6f,
+    0x6c, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x4a, 0x6f, 0x6c, 0x65, 0x65, 0x6e,
+    0x00, 0x4a, 0x6f, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x6c, 0x69,
+    0x65, 0x00, 0x4a, 0x6f, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x6c,
+    0x79, 0x6e, 0x00, 0x4a, 0x6f, 0x6c, 0x79, 0x6e, 0x6e, 0x00, 0x4a, 0x6f,
+    0x6e, 0x00, 0x4a, 0x6f, 0x6e, 0x61, 0x00, 0x4a, 0x6f, 0x6e, 0x61, 0x68,
+    0x00, 0x4a, 0x6f, 0x6e, 0x61, 0x73, 0x00, 0x4a, 0x6f, 0x6e, 0x61, 0x74,
+    0x68, 0x61, 0x6e, 0x00, 0x4a, 0x6f, 0x6e, 0x61, 0x74, 0x68, 0x6f, 0x6e,
+    0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x6c, 0x6c,
+    0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4a, 0x6f, 0x6e,
+    0x67, 0x00, 0x4a, 0x6f, 0x6e, 0x69, 0x00, 0x4a, 0x6f, 0x6e, 0x69, 0x65,
+    0x00, 0x4a, 0x6f, 0x6e, 0x6e, 0x61, 0x00, 0x4a, 0x6f, 0x6e, 0x6e, 0x69,
+    0x65, 0x00, 0x4a, 0x6f, 0x72, 0x64, 0x61, 0x6e, 0x00, 0x4a, 0x6f, 0x72,
+    0x64, 0x6f, 0x6e, 0x00, 0x4a, 0x6f, 0x72, 0x67, 0x65, 0x00, 0x4a, 0x6f,
+    0x73, 0x65, 0x00, 0x4a, 0x6f, 0x73, 0x65, 0x66, 0x00, 0x4a, 0x6f, 0x73,
+    0x65, 0x66, 0x61, 0x00, 0x4a, 0x6f, 0x73, 0x65, 0x66, 0x69, 0x6e, 0x61,
+    0x00, 0x4a, 0x6f, 0x73, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x6f,
+    0x73, 0x65, 0x6c, 0x79, 0x6e, 0x00, 0x4a, 0x6f, 0x73, 0x65, 0x70, 0x68,
+    0x00, 0x4a, 0x6f, 0x73, 0x65, 0x70, 0x68, 0x69, 0x6e, 0x61, 0x00, 0x4a,
+    0x6f, 0x73, 0x65, 0x70, 0x68, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x73,
+    0x65, 0x74, 0x74, 0x65, 0x00, 0x4a, 0x6f, 0x73, 0x68, 0x00, 0x4a, 0x6f,
+    0x73, 0x68, 0x75, 0x61, 0x00, 0x4a, 0x6f, 0x73, 0x69, 0x61, 0x68, 0x00,
+    0x4a, 0x6f, 0x73, 0x69, 0x65, 0x00, 0x4a, 0x6f, 0x73, 0x6c, 0x79, 0x6e,
+    0x00, 0x4a, 0x6f, 0x73, 0x70, 0x65, 0x68, 0x00, 0x4a, 0x6f, 0x73, 0x70,
+    0x68, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x73, 0x75, 0x65, 0x00, 0x4a,
+    0x6f, 0x76, 0x61, 0x6e, 0x00, 0x4a, 0x6f, 0x76, 0x69, 0x74, 0x61, 0x00,
+    0x4a, 0x6f, 0x79, 0x00, 0x4a, 0x6f, 0x79, 0x61, 0x00, 0x4a, 0x6f, 0x79,
+    0x63, 0x65, 0x00, 0x4a, 0x6f, 0x79, 0x63, 0x65, 0x6c, 0x79, 0x6e, 0x00,
+    0x4a, 0x6f, 0x79, 0x65, 0x00, 0x4a, 0x75, 0x61, 0x6e, 0x00, 0x4a, 0x75,
+    0x61, 0x6e, 0x61, 0x00, 0x4a, 0x75, 0x61, 0x6e, 0x69, 0x74, 0x61, 0x00,
+    0x4a, 0x75, 0x64, 0x65, 0x00, 0x4a, 0x75, 0x64, 0x69, 0x00, 0x4a, 0x75,
+    0x64, 0x69, 0x65, 0x00, 0x4a, 0x75, 0x64, 0x69, 0x74, 0x68, 0x00, 0x4a,
+    0x75, 0x64, 0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x75, 0x64, 0x79, 0x00, 0x4a,
+    0x75, 0x6c, 0x65, 0x00, 0x4a, 0x75, 0x6c, 0x65, 0x65, 0x00, 0x4a, 0x75,
+    0x6c, 0x65, 0x6e, 0x65, 0x00, 0x4a, 0x75, 0x6c, 0x65, 0x73, 0x00, 0x4a,
+    0x75, 0x6c, 0x69, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x61, 0x00, 0x4a, 0x75,
+    0x6c, 0x69, 0x61, 0x6e, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x4a, 0x75, 0x6c, 0x69, 0x61, 0x6e, 0x65, 0x00, 0x4a, 0x75, 0x6c,
+    0x69, 0x61, 0x6e, 0x6e, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x61, 0x6e, 0x6e,
+    0x61, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x4a,
+    0x75, 0x6c, 0x69, 0x65, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x65, 0x61, 0x6e,
+    0x6e, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x65, 0x6e, 0x6e, 0x65, 0x00, 0x4a,
+    0x75, 0x6c, 0x69, 0x65, 0x74, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x65, 0x74,
+    0x61, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4a,
+    0x75, 0x6c, 0x69, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4a, 0x75, 0x6c, 0x69,
+    0x6f, 0x00, 0x4a, 0x75, 0x6c, 0x69, 0x73, 0x73, 0x61, 0x00, 0x4a, 0x75,
+    0x6c, 0x69, 0x75, 0x73, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x4a, 0x75,
+    0x6e, 0x67, 0x00, 0x4a, 0x75, 0x6e, 0x69, 0x65, 0x00, 0x4a, 0x75, 0x6e,
+    0x69, 0x6f, 0x72, 0x00, 0x4a, 0x75, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x4a,
+    0x75, 0x6e, 0x6b, 0x6f, 0x00, 0x4a, 0x75, 0x73, 0x74, 0x61, 0x00, 0x4a,
+    0x75, 0x73, 0x74, 0x69, 0x6e, 0x00, 0x4a, 0x75, 0x73, 0x74, 0x69, 0x6e,
+    0x61, 0x00, 0x4a, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x4a, 0x75,
+    0x74, 0x74, 0x61, 0x00, 0x4b, 0x61, 0x00, 0x4b, 0x61, 0x63, 0x65, 0x79,
+    0x00, 0x4b, 0x61, 0x63, 0x69, 0x00, 0x4b, 0x61, 0x63, 0x69, 0x65, 0x00,
+    0x4b, 0x61, 0x63, 0x79, 0x00, 0x4b, 0x61, 0x69, 0x00, 0x4b, 0x61, 0x69,
+    0x6c, 0x61, 0x00, 0x4b, 0x61, 0x69, 0x74, 0x6c, 0x69, 0x6e, 0x00, 0x4b,
+    0x61, 0x69, 0x74, 0x6c, 0x79, 0x6e, 0x00, 0x4b, 0x61, 0x6c, 0x61, 0x00,
+    0x4b, 0x61, 0x6c, 0x65, 0x69, 0x67, 0x68, 0x00, 0x4b, 0x61, 0x6c, 0x65,
+    0x79, 0x00, 0x4b, 0x61, 0x6c, 0x69, 0x00, 0x4b, 0x61, 0x6c, 0x6c, 0x69,
+    0x65, 0x00, 0x4b, 0x61, 0x6c, 0x79, 0x6e, 0x00, 0x4b, 0x61, 0x6d, 0x00,
+    0x4b, 0x61, 0x6d, 0x61, 0x6c, 0x61, 0x00, 0x4b, 0x61, 0x6d, 0x69, 0x00,
+    0x4b, 0x61, 0x6d, 0x69, 0x6c, 0x61, 0x68, 0x00, 0x4b, 0x61, 0x6e, 0x64,
+    0x61, 0x63, 0x65, 0x00, 0x4b, 0x61, 0x6e, 0x64, 0x69, 0x00, 0x4b, 0x61,
+    0x6e, 0x64, 0x69, 0x63, 0x65, 0x00, 0x4b, 0x61, 0x6e, 0x64, 0x69, 0x73,
+    0x00, 0x4b, 0x61, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x4b, 0x61, 0x6e, 0x64,
+    0x79, 0x00, 0x4b, 0x61, 0x6e, 0x65, 0x73, 0x68, 0x61, 0x00, 0x4b, 0x61,
+    0x6e, 0x69, 0x73, 0x68, 0x61, 0x00, 0x4b, 0x61, 0x72, 0x61, 0x00, 0x4b,
+    0x61, 0x72, 0x61, 0x6e, 0x00, 0x4b, 0x61, 0x72, 0x65, 0x65, 0x6d, 0x00,
+    0x4b, 0x61, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x4b, 0x61, 0x72, 0x65, 0x6e,
+    0x00, 0x4b, 0x61, 0x72, 0x65, 0x6e, 0x61, 0x00, 0x4b, 0x61, 0x72, 0x65,
+    0x79, 0x00, 0x4b, 0x61, 0x72, 0x69, 0x00, 0x4b, 0x61, 0x72, 0x69, 0x65,
+    0x00, 0x4b, 0x61, 0x72, 0x69, 0x6d, 0x61, 0x00, 0x4b, 0x61, 0x72, 0x69,
+    0x6e, 0x00, 0x4b, 0x61, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x4b, 0x61, 0x72,
+    0x69, 0x6e, 0x65, 0x00, 0x4b, 0x61, 0x72, 0x69, 0x73, 0x61, 0x00, 0x4b,
+    0x61, 0x72, 0x69, 0x73, 0x73, 0x61, 0x00, 0x4b, 0x61, 0x72, 0x6c, 0x00,
+    0x4b, 0x61, 0x72, 0x6c, 0x61, 0x00, 0x4b, 0x61, 0x72, 0x6c, 0x65, 0x65,
+    0x6e, 0x00, 0x4b, 0x61, 0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x4b, 0x61,
+    0x72, 0x6c, 0x79, 0x00, 0x4b, 0x61, 0x72, 0x6c, 0x79, 0x6e, 0x00, 0x4b,
+    0x61, 0x72, 0x6d, 0x61, 0x00, 0x4b, 0x61, 0x72, 0x6d, 0x65, 0x6e, 0x00,
+    0x4b, 0x61, 0x72, 0x6f, 0x6c, 0x00, 0x4b, 0x61, 0x72, 0x6f, 0x6c, 0x65,
+    0x00, 0x4b, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4b, 0x61,
+    0x72, 0x6f, 0x6c, 0x79, 0x6e, 0x00, 0x4b, 0x61, 0x72, 0x6f, 0x6e, 0x00,
+    0x4b, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x00, 0x4b, 0x61, 0x72, 0x72, 0x69,
+    0x00, 0x4b, 0x61, 0x72, 0x72, 0x69, 0x65, 0x00, 0x4b, 0x61, 0x72, 0x72,
+    0x79, 0x00, 0x4b, 0x61, 0x72, 0x79, 0x00, 0x4b, 0x61, 0x72, 0x79, 0x6c,
+    0x00, 0x4b, 0x61, 0x72, 0x79, 0x6e, 0x00, 0x4b, 0x61, 0x73, 0x61, 0x6e,
+    0x64, 0x72, 0x61, 0x00, 0x4b, 0x61, 0x73, 0x65, 0x79, 0x00, 0x4b, 0x61,
+    0x73, 0x68, 0x61, 0x00, 0x4b, 0x61, 0x73, 0x69, 0x00, 0x4b, 0x61, 0x73,
+    0x69, 0x65, 0x00, 0x4b, 0x61, 0x73, 0x73, 0x61, 0x6e, 0x64, 0x72, 0x61,
+    0x00, 0x4b, 0x61, 0x73, 0x73, 0x69, 0x65, 0x00, 0x4b, 0x61, 0x74, 0x65,
+    0x00, 0x4b, 0x61, 0x74, 0x65, 0x6c, 0x69, 0x6e, 0x00, 0x4b, 0x61, 0x74,
+    0x65, 0x6c, 0x79, 0x6e, 0x00, 0x4b, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x6e,
+    0x6e, 0x00, 0x4b, 0x61, 0x74, 0x65, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x4b,
+    0x61, 0x74, 0x68, 0x61, 0x6c, 0x65, 0x65, 0x6e, 0x00, 0x4b, 0x61, 0x74,
+    0x68, 0x61, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x61,
+    0x72, 0x69, 0x6e, 0x65, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x61, 0x72, 0x79,
+    0x6e, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x65, 0x00, 0x4b, 0x61, 0x74, 0x68,
+    0x65, 0x6c, 0x65, 0x65, 0x6e, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x65, 0x72,
+    0x69, 0x6e, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x65, 0x72, 0x69, 0x6e, 0x61,
+    0x00, 0x4b, 0x61, 0x74, 0x68, 0x65, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x4b,
+    0x61, 0x74, 0x68, 0x65, 0x72, 0x6e, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x65,
+    0x72, 0x79, 0x6e, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x65, 0x79, 0x00, 0x4b,
+    0x61, 0x74, 0x68, 0x69, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x69, 0x65, 0x00,
+    0x4b, 0x61, 0x74, 0x68, 0x6c, 0x65, 0x65, 0x6e, 0x00, 0x4b, 0x61, 0x74,
+    0x68, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x6c, 0x69,
+    0x6e, 0x65, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x6c, 0x79, 0x6e, 0x00, 0x4b,
+    0x61, 0x74, 0x68, 0x72, 0x69, 0x6e, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x72,
+    0x69, 0x6e, 0x65, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x72, 0x79, 0x6e, 0x00,
+    0x4b, 0x61, 0x74, 0x68, 0x72, 0x79, 0x6e, 0x65, 0x00, 0x4b, 0x61, 0x74,
+    0x68, 0x79, 0x00, 0x4b, 0x61, 0x74, 0x68, 0x79, 0x72, 0x6e, 0x00, 0x4b,
+    0x61, 0x74, 0x69, 0x00, 0x4b, 0x61, 0x74, 0x69, 0x61, 0x00, 0x4b, 0x61,
+    0x74, 0x69, 0x65, 0x00, 0x4b, 0x61, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x4b,
+    0x61, 0x74, 0x6c, 0x79, 0x6e, 0x00, 0x4b, 0x61, 0x74, 0x72, 0x69, 0x63,
+    0x65, 0x00, 0x4b, 0x61, 0x74, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x4b, 0x61,
+    0x74, 0x74, 0x69, 0x65, 0x00, 0x4b, 0x61, 0x74, 0x79, 0x00, 0x4b, 0x61,
+    0x79, 0x00, 0x4b, 0x61, 0x79, 0x63, 0x65, 0x00, 0x4b, 0x61, 0x79, 0x63,
+    0x65, 0x65, 0x00, 0x4b, 0x61, 0x79, 0x65, 0x00, 0x4b, 0x61, 0x79, 0x6c,
+    0x61, 0x00, 0x4b, 0x61, 0x79, 0x6c, 0x65, 0x65, 0x00, 0x4b, 0x61, 0x79,
+    0x6c, 0x65, 0x65, 0x6e, 0x00, 0x4b, 0x61, 0x79, 0x6c, 0x65, 0x69, 0x67,
+    0x68, 0x00, 0x4b, 0x61, 0x79, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x4b, 0x61,
+    0x7a, 0x75, 0x6b, 0x6f, 0x00, 0x4b, 0x65, 0x63, 0x69, 0x61, 0x00, 0x4b,
+    0x65, 0x65, 0x6c, 0x65, 0x79, 0x00, 0x4b, 0x65, 0x65, 0x6c, 0x79, 0x00,
+    0x4b, 0x65, 0x65, 0x6e, 0x61, 0x00, 0x4b, 0x65, 0x65, 0x6e, 0x61, 0x6e,
+    0x00, 0x4b, 0x65, 0x65, 0x73, 0x68, 0x61, 0x00, 0x4b, 0x65, 0x69, 0x6b,
+    0x6f, 0x00, 0x4b, 0x65, 0x69, 0x6c, 0x61, 0x00, 0x4b, 0x65, 0x69, 0x72,
+    0x61, 0x00, 0x4b, 0x65, 0x69, 0x73, 0x68, 0x61, 0x00, 0x4b, 0x65, 0x69,
+    0x74, 0x68, 0x00, 0x4b, 0x65, 0x69, 0x74, 0x68, 0x61, 0x00, 0x4b, 0x65,
+    0x6c, 0x69, 0x00, 0x4b, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4b, 0x65, 0x6c,
+    0x6c, 0x65, 0x65, 0x00, 0x4b, 0x65, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x4b,
+    0x65, 0x6c, 0x6c, 0x69, 0x00, 0x4b, 0x65, 0x6c, 0x6c, 0x69, 0x65, 0x00,
+    0x4b, 0x65, 0x6c, 0x6c, 0x79, 0x00, 0x4b, 0x65, 0x6c, 0x6c, 0x79, 0x65,
+    0x00, 0x4b, 0x65, 0x6c, 0x73, 0x65, 0x79, 0x00, 0x4b, 0x65, 0x6c, 0x73,
+    0x69, 0x00, 0x4b, 0x65, 0x6c, 0x73, 0x69, 0x65, 0x00, 0x4b, 0x65, 0x6c,
+    0x76, 0x69, 0x6e, 0x00, 0x4b, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x79,
+    0x00, 0x4b, 0x65, 0x6e, 0x00, 0x4b, 0x65, 0x6e, 0x61, 0x00, 0x4b, 0x65,
+    0x6e, 0x64, 0x61, 0x00, 0x4b, 0x65, 0x6e, 0x64, 0x61, 0x6c, 0x00, 0x4b,
+    0x65, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x00, 0x4b, 0x65, 0x6e, 0x64, 0x72,
+    0x61, 0x00, 0x4b, 0x65, 0x6e, 0x64, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x4b,
+    0x65, 0x6e, 0x65, 0x74, 0x68, 0x00, 0x4b, 0x65, 0x6e, 0x69, 0x61, 0x00,
+    0x4b, 0x65, 0x6e, 0x69, 0x73, 0x68, 0x61, 0x00, 0x4b, 0x65, 0x6e, 0x6e,
+    0x61, 0x00, 0x4b, 0x65, 0x6e, 0x6e, 0x65, 0x74, 0x68, 0x00, 0x4b, 0x65,
+    0x6e, 0x6e, 0x69, 0x74, 0x68, 0x00, 0x4b, 0x65, 0x6e, 0x6e, 0x79, 0x00,
+    0x4b, 0x65, 0x6e, 0x74, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00,
+    0x4b, 0x65, 0x6e, 0x79, 0x61, 0x00, 0x4b, 0x65, 0x6e, 0x79, 0x61, 0x74,
+    0x74, 0x61, 0x00, 0x4b, 0x65, 0x6e, 0x79, 0x65, 0x74, 0x74, 0x61, 0x00,
+    0x4b, 0x65, 0x72, 0x61, 0x00, 0x4b, 0x65, 0x72, 0x65, 0x6e, 0x00, 0x4b,
+    0x65, 0x72, 0x69, 0x00, 0x4b, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x00, 0x4b,
+    0x65, 0x72, 0x72, 0x69, 0x00, 0x4b, 0x65, 0x72, 0x72, 0x69, 0x65, 0x00,
+    0x4b, 0x65, 0x72, 0x72, 0x79, 0x00, 0x4b, 0x65, 0x72, 0x73, 0x74, 0x69,
+    0x6e, 0x00, 0x4b, 0x65, 0x73, 0x68, 0x61, 0x00, 0x4b, 0x65, 0x73, 0x68,
+    0x69, 0x61, 0x00, 0x4b, 0x65, 0x74, 0x75, 0x72, 0x61, 0x68, 0x00, 0x4b,
+    0x65, 0x76, 0x61, 0x00, 0x4b, 0x65, 0x76, 0x65, 0x6e, 0x00, 0x4b, 0x65,
+    0x76, 0x69, 0x6e, 0x00, 0x4b, 0x68, 0x61, 0x64, 0x69, 0x6a, 0x61, 0x68,
+    0x00, 0x4b, 0x68, 0x61, 0x6c, 0x69, 0x6c, 0x61, 0x68, 0x00, 0x4b, 0x69,
+    0x61, 0x00, 0x4b, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x4b, 0x69, 0x61, 0x72,
+    0x61, 0x00, 0x4b, 0x69, 0x65, 0x72, 0x61, 0x00, 0x4b, 0x69, 0x65, 0x72,
+    0x73, 0x74, 0x65, 0x6e, 0x00, 0x4b, 0x69, 0x65, 0x73, 0x68, 0x61, 0x00,
+    0x4b, 0x69, 0x65, 0x74, 0x68, 0x00, 0x4b, 0x69, 0x6c, 0x65, 0x79, 0x00,
+    0x4b, 0x69, 0x6d, 0x00, 0x4b, 0x69, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x4b,
+    0x69, 0x6d, 0x62, 0x65, 0x72, 0x65, 0x6c, 0x79, 0x00, 0x4b, 0x69, 0x6d,
+    0x62, 0x65, 0x72, 0x6c, 0x65, 0x65, 0x00, 0x4b, 0x69, 0x6d, 0x62, 0x65,
+    0x72, 0x6c, 0x65, 0x79, 0x00, 0x4b, 0x69, 0x6d, 0x62, 0x65, 0x72, 0x6c,
+    0x69, 0x00, 0x4b, 0x69, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x69, 0x65, 0x00,
+    0x4b, 0x69, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x4b, 0x69, 0x6d,
+    0x62, 0x65, 0x72, 0x79, 0x00, 0x4b, 0x69, 0x6d, 0x62, 0x72, 0x61, 0x00,
+    0x4b, 0x69, 0x6d, 0x69, 0x00, 0x4b, 0x69, 0x6d, 0x69, 0x6b, 0x6f, 0x00,
+    0x4b, 0x69, 0x6e, 0x61, 0x00, 0x4b, 0x69, 0x6e, 0x64, 0x72, 0x61, 0x00,
+    0x4b, 0x69, 0x6e, 0x67, 0x00, 0x4b, 0x69, 0x70, 0x00, 0x4b, 0x69, 0x72,
+    0x61, 0x00, 0x4b, 0x69, 0x72, 0x62, 0x79, 0x00, 0x4b, 0x69, 0x72, 0x6b,
+    0x00, 0x4b, 0x69, 0x72, 0x73, 0x74, 0x65, 0x6e, 0x00, 0x4b, 0x69, 0x72,
+    0x73, 0x74, 0x69, 0x65, 0x00, 0x4b, 0x69, 0x72, 0x73, 0x74, 0x69, 0x6e,
+    0x00, 0x4b, 0x69, 0x73, 0x68, 0x61, 0x00, 0x4b, 0x69, 0x74, 0x00, 0x4b,
+    0x69, 0x74, 0x74, 0x69, 0x65, 0x00, 0x4b, 0x69, 0x74, 0x74, 0x79, 0x00,
+    0x4b, 0x69, 0x79, 0x6f, 0x6b, 0x6f, 0x00, 0x4b, 0x69, 0x7a, 0x7a, 0x69,
+    0x65, 0x00, 0x4b, 0x69, 0x7a, 0x7a, 0x79, 0x00, 0x4b, 0x6c, 0x61, 0x72,
+    0x61, 0x00, 0x4b, 0x6f, 0x72, 0x65, 0x79, 0x00, 0x4b, 0x6f, 0x72, 0x69,
+    0x00, 0x4b, 0x6f, 0x72, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x4b, 0x6f, 0x72,
+    0x79, 0x00, 0x4b, 0x6f, 0x75, 0x72, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x4b,
+    0x72, 0x61, 0x69, 0x67, 0x00, 0x4b, 0x72, 0x69, 0x73, 0x00, 0x4b, 0x72,
+    0x69, 0x73, 0x68, 0x6e, 0x61, 0x00, 0x4b, 0x72, 0x69, 0x73, 0x73, 0x79,
+    0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x61, 0x00, 0x4b, 0x72, 0x69, 0x73,
+    0x74, 0x61, 0x6c, 0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x00,
+    0x4b, 0x72, 0x69, 0x73, 0x74, 0x65, 0x65, 0x6e, 0x00, 0x4b, 0x72, 0x69,
+    0x73, 0x74, 0x65, 0x6c, 0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x65, 0x6e,
+    0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x69, 0x00, 0x4b, 0x72, 0x69, 0x73,
+    0x74, 0x69, 0x61, 0x6e, 0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x69, 0x65,
+    0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x00, 0x4b, 0x72, 0x69,
+    0x73, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x69,
+    0x6e, 0x65, 0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x6c, 0x65, 0x00, 0x4b,
+    0x72, 0x69, 0x73, 0x74, 0x6f, 0x66, 0x65, 0x72, 0x00, 0x4b, 0x72, 0x69,
+    0x73, 0x74, 0x6f, 0x70, 0x68, 0x65, 0x72, 0x00, 0x4b, 0x72, 0x69, 0x73,
+    0x74, 0x79, 0x00, 0x4b, 0x72, 0x69, 0x73, 0x74, 0x79, 0x6e, 0x00, 0x4b,
+    0x72, 0x79, 0x73, 0x74, 0x61, 0x00, 0x4b, 0x72, 0x79, 0x73, 0x74, 0x61,
+    0x6c, 0x00, 0x4b, 0x72, 0x79, 0x73, 0x74, 0x65, 0x6e, 0x00, 0x4b, 0x72,
+    0x79, 0x73, 0x74, 0x69, 0x6e, 0x00, 0x4b, 0x72, 0x79, 0x73, 0x74, 0x69,
+    0x6e, 0x61, 0x00, 0x4b, 0x72, 0x79, 0x73, 0x74, 0x6c, 0x65, 0x00, 0x4b,
+    0x72, 0x79, 0x73, 0x74, 0x79, 0x6e, 0x61, 0x00, 0x4b, 0x75, 0x6d, 0x00,
+    0x4b, 0x75, 0x72, 0x74, 0x00, 0x4b, 0x75, 0x72, 0x74, 0x69, 0x73, 0x00,
+    0x4b, 0x79, 0x6c, 0x61, 0x00, 0x4b, 0x79, 0x6c, 0x65, 0x00, 0x4b, 0x79,
+    0x6c, 0x65, 0x65, 0x00, 0x4b, 0x79, 0x6c, 0x69, 0x65, 0x00, 0x4b, 0x79,
+    0x6d, 0x00, 0x4b, 0x79, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x4b,
+    0x79, 0x6f, 0x6b, 0x6f, 0x00, 0x4b, 0x79, 0x6f, 0x6e, 0x67, 0x00, 0x4b,
+    0x79, 0x72, 0x61, 0x00, 0x4b, 0x79, 0x75, 0x6e, 0x67, 0x00, 0x4c, 0x61,
+    0x63, 0x65, 0x79, 0x00, 0x4c, 0x61, 0x63, 0x68, 0x65, 0x6c, 0x6c, 0x65,
+    0x00, 0x4c, 0x61, 0x63, 0x69, 0x00, 0x4c, 0x61, 0x63, 0x69, 0x65, 0x00,
+    0x4c, 0x61, 0x63, 0x72, 0x65, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x61, 0x63,
+    0x79, 0x00, 0x4c, 0x61, 0x64, 0x61, 0x77, 0x6e, 0x00, 0x4c, 0x61, 0x64,
+    0x6f, 0x6e, 0x6e, 0x61, 0x00, 0x4c, 0x61, 0x64, 0x79, 0x00, 0x4c, 0x61,
+    0x65, 0x6c, 0x00, 0x4c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x4c, 0x61,
+    0x69, 0x00, 0x4c, 0x61, 0x69, 0x6c, 0x61, 0x00, 0x4c, 0x61, 0x69, 0x6e,
+    0x65, 0x00, 0x4c, 0x61, 0x6a, 0x75, 0x61, 0x6e, 0x61, 0x00, 0x4c, 0x61,
+    0x6b, 0x65, 0x65, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x69,
+    0x73, 0x68, 0x61, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x6e, 0x64, 0x72, 0x61,
+    0x00, 0x4c, 0x61, 0x6b, 0x65, 0x6e, 0x79, 0x61, 0x00, 0x4c, 0x61, 0x6b,
+    0x65, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x73, 0x68, 0x69,
+    0x61, 0x00, 0x4c, 0x61, 0x6b, 0x69, 0x61, 0x00, 0x4c, 0x61, 0x6b, 0x69,
+    0x65, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x61, 0x6b, 0x69, 0x73, 0x68, 0x61,
+    0x00, 0x4c, 0x61, 0x6b, 0x69, 0x74, 0x61, 0x00, 0x4c, 0x61, 0x6c, 0x61,
+    0x00, 0x4c, 0x61, 0x6d, 0x61, 0x72, 0x00, 0x4c, 0x61, 0x6d, 0x6f, 0x6e,
+    0x69, 0x63, 0x61, 0x00, 0x4c, 0x61, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x4c,
+    0x61, 0x6e, 0x00, 0x4c, 0x61, 0x6e, 0x61, 0x00, 0x4c, 0x61, 0x6e, 0x63,
+    0x65, 0x00, 0x4c, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x6e,
+    0x65, 0x00, 0x4c, 0x61, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x61, 0x6e,
+    0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4c, 0x61, 0x6e, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x4c, 0x61, 0x6e, 0x69, 0x00, 0x4c,
+    0x61, 0x6e, 0x69, 0x65, 0x00, 0x4c, 0x61, 0x6e, 0x69, 0x74, 0x61, 0x00,
+    0x4c, 0x61, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x4c, 0x61, 0x6e, 0x6e, 0x79,
+    0x00, 0x4c, 0x61, 0x6e, 0x6f, 0x72, 0x61, 0x00, 0x4c, 0x61, 0x71, 0x75,
+    0x61, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x61, 0x71, 0x75, 0x69, 0x74, 0x61,
+    0x00, 0x4c, 0x61, 0x72, 0x61, 0x00, 0x4c, 0x61, 0x72, 0x61, 0x65, 0x00,
+    0x4c, 0x61, 0x72, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x4c, 0x61, 0x72, 0x65,
+    0x65, 0x00, 0x4c, 0x61, 0x72, 0x68, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x4c,
+    0x61, 0x72, 0x69, 0x73, 0x61, 0x00, 0x4c, 0x61, 0x72, 0x69, 0x73, 0x73,
+    0x61, 0x00, 0x4c, 0x61, 0x72, 0x69, 0x74, 0x61, 0x00, 0x4c, 0x61, 0x72,
+    0x6f, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x61, 0x72, 0x72, 0x61, 0x69, 0x6e,
+    0x65, 0x00, 0x4c, 0x61, 0x72, 0x72, 0x79, 0x00, 0x4c, 0x61, 0x72, 0x75,
+    0x65, 0x00, 0x4c, 0x61, 0x73, 0x61, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x4c,
+    0x61, 0x73, 0x68, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x61, 0x73, 0x68,
+    0x61, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x4c, 0x61, 0x73, 0x68, 0x61, 0x75,
+    0x6e, 0x00, 0x4c, 0x61, 0x73, 0x68, 0x61, 0x75, 0x6e, 0x64, 0x61, 0x00,
+    0x4c, 0x61, 0x73, 0x68, 0x61, 0x77, 0x6e, 0x00, 0x4c, 0x61, 0x73, 0x68,
+    0x61, 0x77, 0x6e, 0x61, 0x00, 0x4c, 0x61, 0x73, 0x68, 0x61, 0x77, 0x6e,
+    0x64, 0x61, 0x00, 0x4c, 0x61, 0x73, 0x68, 0x61, 0x79, 0x00, 0x4c, 0x61,
+    0x73, 0x68, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x61, 0x73, 0x68, 0x6f, 0x6e,
+    0x00, 0x4c, 0x61, 0x73, 0x68, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x61,
+    0x73, 0x68, 0x75, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x61, 0x73, 0x6f, 0x6e,
+    0x79, 0x61, 0x00, 0x4c, 0x61, 0x74, 0x61, 0x6e, 0x79, 0x61, 0x00, 0x4c,
+    0x61, 0x74, 0x61, 0x72, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x61, 0x74, 0x61,
+    0x73, 0x68, 0x61, 0x00, 0x4c, 0x61, 0x74, 0x61, 0x73, 0x68, 0x69, 0x61,
+    0x00, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x61, 0x74,
+    0x69, 0x61, 0x00, 0x4c, 0x61, 0x74, 0x69, 0x63, 0x69, 0x61, 0x00, 0x4c,
+    0x61, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x4c, 0x61, 0x74, 0x69, 0x73, 0x68,
+    0x61, 0x00, 0x4c, 0x61, 0x74, 0x6f, 0x6e, 0x69, 0x61, 0x00, 0x4c, 0x61,
+    0x74, 0x6f, 0x6e, 0x79, 0x61, 0x00, 0x4c, 0x61, 0x74, 0x6f, 0x72, 0x69,
+    0x61, 0x00, 0x4c, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x61,
+    0x74, 0x6f, 0x79, 0x61, 0x00, 0x4c, 0x61, 0x74, 0x6f, 0x79, 0x69, 0x61,
+    0x00, 0x4c, 0x61, 0x74, 0x72, 0x69, 0x63, 0x65, 0x00, 0x4c, 0x61, 0x74,
+    0x72, 0x69, 0x63, 0x69, 0x61, 0x00, 0x4c, 0x61, 0x74, 0x72, 0x69, 0x6e,
+    0x61, 0x00, 0x4c, 0x61, 0x74, 0x72, 0x69, 0x73, 0x68, 0x61, 0x00, 0x4c,
+    0x61, 0x75, 0x6e, 0x61, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x61, 0x00, 0x4c,
+    0x61, 0x75, 0x72, 0x61, 0x6c, 0x65, 0x65, 0x00, 0x4c, 0x61, 0x75, 0x72,
+    0x61, 0x6e, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x65, 0x00, 0x4c, 0x61, 0x75,
+    0x72, 0x65, 0x65, 0x6e, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x65, 0x6c, 0x00,
+    0x4c, 0x61, 0x75, 0x72, 0x65, 0x6e, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x65,
+    0x6e, 0x61, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00,
+    0x4c, 0x61, 0x75, 0x72, 0x65, 0x6e, 0x65, 0x00, 0x4c, 0x61, 0x75, 0x72,
+    0x65, 0x74, 0x74, 0x61, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x69, 0x00, 0x4c, 0x61, 0x75, 0x72,
+    0x69, 0x63, 0x65, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x69, 0x65, 0x00, 0x4c,
+    0x61, 0x75, 0x72, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x61, 0x75, 0x72,
+    0x69, 0x6e, 0x65, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x79, 0x6e, 0x00, 0x4c,
+    0x61, 0x76, 0x61, 0x64, 0x61, 0x00, 0x4c, 0x61, 0x76, 0x65, 0x6c, 0x6c,
+    0x65, 0x00, 0x4c, 0x61, 0x76, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x4c, 0x61,
+    0x76, 0x65, 0x72, 0x61, 0x00, 0x4c, 0x61, 0x76, 0x65, 0x72, 0x6e, 0x00,
+    0x4c, 0x61, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x00, 0x4c, 0x61, 0x76, 0x65,
+    0x72, 0x6e, 0x65, 0x00, 0x4c, 0x61, 0x76, 0x65, 0x74, 0x61, 0x00, 0x4c,
+    0x61, 0x76, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4c, 0x61, 0x76, 0x69, 0x6e,
+    0x61, 0x00, 0x4c, 0x61, 0x76, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x4c, 0x61,
+    0x76, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x76, 0x6f, 0x6e, 0x61, 0x00, 0x4c,
+    0x61, 0x76, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x61, 0x76, 0x6f, 0x6e,
+    0x65, 0x00, 0x4c, 0x61, 0x76, 0x6f, 0x6e, 0x69, 0x61, 0x00, 0x4c, 0x61,
+    0x76, 0x6f, 0x6e, 0x6e, 0x61, 0x00, 0x4c, 0x61, 0x76, 0x6f, 0x6e, 0x6e,
+    0x65, 0x00, 0x4c, 0x61, 0x77, 0x61, 0x6e, 0x61, 0x00, 0x4c, 0x61, 0x77,
+    0x61, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x61, 0x77, 0x61, 0x6e, 0x6e, 0x61,
+    0x00, 0x4c, 0x61, 0x77, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x4c,
+    0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x4c, 0x61, 0x79, 0x6c,
+    0x61, 0x00, 0x4c, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x4c, 0x61, 0x7a, 0x61,
+    0x72, 0x6f, 0x00, 0x4c, 0x65, 0x00, 0x4c, 0x65, 0x61, 0x00, 0x4c, 0x65,
+    0x61, 0x68, 0x00, 0x4c, 0x65, 0x61, 0x6e, 0x00, 0x4c, 0x65, 0x61, 0x6e,
+    0x61, 0x00, 0x4c, 0x65, 0x61, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x4c, 0x65,
+    0x61, 0x6e, 0x64, 0x72, 0x6f, 0x00, 0x4c, 0x65, 0x61, 0x6e, 0x6e, 0x00,
+    0x4c, 0x65, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4c, 0x65, 0x61, 0x6e, 0x6e,
+    0x65, 0x00, 0x4c, 0x65, 0x61, 0x6e, 0x6f, 0x72, 0x61, 0x00, 0x4c, 0x65,
+    0x61, 0x74, 0x68, 0x61, 0x00, 0x4c, 0x65, 0x61, 0x74, 0x72, 0x69, 0x63,
+    0x65, 0x00, 0x4c, 0x65, 0x63, 0x69, 0x61, 0x00, 0x4c, 0x65, 0x64, 0x61,
+    0x00, 0x4c, 0x65, 0x65, 0x00, 0x4c, 0x65, 0x65, 0x61, 0x6e, 0x6e, 0x00,
+    0x4c, 0x65, 0x65, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4c, 0x65, 0x65, 0x61,
+    0x6e, 0x6e, 0x65, 0x00, 0x4c, 0x65, 0x65, 0x6e, 0x61, 0x00, 0x4c, 0x65,
+    0x65, 0x73, 0x61, 0x00, 0x4c, 0x65, 0x69, 0x61, 0x00, 0x4c, 0x65, 0x69,
+    0x64, 0x61, 0x00, 0x4c, 0x65, 0x69, 0x66, 0x00, 0x4c, 0x65, 0x69, 0x67,
+    0x68, 0x00, 0x4c, 0x65, 0x69, 0x67, 0x68, 0x61, 0x00, 0x4c, 0x65, 0x69,
+    0x67, 0x68, 0x61, 0x6e, 0x6e, 0x00, 0x4c, 0x65, 0x69, 0x6c, 0x61, 0x00,
+    0x4c, 0x65, 0x69, 0x6c, 0x61, 0x6e, 0x69, 0x00, 0x4c, 0x65, 0x69, 0x73,
+    0x61, 0x00, 0x4c, 0x65, 0x69, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x65, 0x6b,
+    0x69, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x65, 0x6c, 0x61, 0x00, 0x4c, 0x65,
+    0x6c, 0x61, 0x68, 0x00, 0x4c, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x4c,
+    0x65, 0x6c, 0x69, 0x61, 0x00, 0x4c, 0x65, 0x6d, 0x75, 0x65, 0x6c, 0x00,
+    0x4c, 0x65, 0x6e, 0x00, 0x4c, 0x65, 0x6e, 0x61, 0x00, 0x4c, 0x65, 0x6e,
+    0x61, 0x72, 0x64, 0x00, 0x4c, 0x65, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x4c,
+    0x65, 0x6e, 0x6e, 0x61, 0x00, 0x4c, 0x65, 0x6e, 0x6e, 0x69, 0x65, 0x00,
+    0x4c, 0x65, 0x6e, 0x6e, 0x79, 0x00, 0x4c, 0x65, 0x6e, 0x6f, 0x72, 0x61,
+    0x00, 0x4c, 0x65, 0x6e, 0x6f, 0x72, 0x65, 0x00, 0x4c, 0x65, 0x6f, 0x00,
+    0x4c, 0x65, 0x6f, 0x6c, 0x61, 0x00, 0x4c, 0x65, 0x6f, 0x6d, 0x61, 0x00,
+    0x4c, 0x65, 0x6f, 0x6e, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x61, 0x00, 0x4c,
+    0x65, 0x6f, 0x6e, 0x61, 0x72, 0x64, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x61,
+    0x72, 0x64, 0x61, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x61, 0x72, 0x64, 0x6f,
+    0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x65, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x65,
+    0x6c, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x69, 0x61, 0x00, 0x4c, 0x65, 0x6f,
+    0x6e, 0x69, 0x64, 0x61, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x69, 0x65, 0x00,
+    0x4c, 0x65, 0x6f, 0x6e, 0x69, 0x6c, 0x61, 0x00, 0x4c, 0x65, 0x6f, 0x6e,
+    0x6f, 0x72, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x6f, 0x72, 0x61, 0x00, 0x4c,
+    0x65, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x74,
+    0x69, 0x6e, 0x65, 0x00, 0x4c, 0x65, 0x6f, 0x70, 0x6f, 0x6c, 0x64, 0x6f,
+    0x00, 0x4c, 0x65, 0x6f, 0x72, 0x61, 0x00, 0x4c, 0x65, 0x6f, 0x74, 0x61,
+    0x00, 0x4c, 0x65, 0x72, 0x61, 0x00, 0x4c, 0x65, 0x72, 0x6f, 0x79, 0x00,
+    0x4c, 0x65, 0x73, 0x00, 0x4c, 0x65, 0x73, 0x61, 0x00, 0x4c, 0x65, 0x73,
+    0x68, 0x61, 0x00, 0x4c, 0x65, 0x73, 0x69, 0x61, 0x00, 0x4c, 0x65, 0x73,
+    0x6c, 0x65, 0x65, 0x00, 0x4c, 0x65, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x4c,
+    0x65, 0x73, 0x6c, 0x69, 0x00, 0x4c, 0x65, 0x73, 0x6c, 0x69, 0x65, 0x00,
+    0x4c, 0x65, 0x73, 0x73, 0x69, 0x65, 0x00, 0x4c, 0x65, 0x73, 0x74, 0x65,
+    0x72, 0x00, 0x4c, 0x65, 0x74, 0x61, 0x00, 0x4c, 0x65, 0x74, 0x68, 0x61,
+    0x00, 0x4c, 0x65, 0x74, 0x69, 0x63, 0x69, 0x61, 0x00, 0x4c, 0x65, 0x74,
+    0x69, 0x73, 0x68, 0x61, 0x00, 0x4c, 0x65, 0x74, 0x69, 0x74, 0x69, 0x61,
+    0x00, 0x4c, 0x65, 0x74, 0x74, 0x69, 0x65, 0x00, 0x4c, 0x65, 0x74, 0x74,
+    0x79, 0x00, 0x4c, 0x65, 0x76, 0x69, 0x00, 0x4c, 0x65, 0x77, 0x69, 0x73,
+    0x00, 0x4c, 0x65, 0x78, 0x69, 0x65, 0x00, 0x4c, 0x65, 0x7a, 0x6c, 0x69,
+    0x65, 0x00, 0x4c, 0x69, 0x00, 0x4c, 0x69, 0x61, 0x00, 0x4c, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x4c, 0x69, 0x61, 0x6e, 0x65, 0x00, 0x4c, 0x69, 0x61,
+    0x6e, 0x6e, 0x65, 0x00, 0x4c, 0x69, 0x62, 0x62, 0x69, 0x65, 0x00, 0x4c,
+    0x69, 0x62, 0x62, 0x79, 0x00, 0x4c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x79,
+    0x00, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x64, 0x61, 0x00, 0x4c, 0x69, 0x64,
+    0x61, 0x00, 0x4c, 0x69, 0x64, 0x69, 0x61, 0x00, 0x4c, 0x69, 0x65, 0x6e,
+    0x00, 0x4c, 0x69, 0x65, 0x73, 0x65, 0x6c, 0x6f, 0x74, 0x74, 0x65, 0x00,
+    0x4c, 0x69, 0x67, 0x69, 0x61, 0x00, 0x4c, 0x69, 0x6c, 0x61, 0x00, 0x4c,
+    0x69, 0x6c, 0x69, 0x00, 0x4c, 0x69, 0x6c, 0x69, 0x61, 0x00, 0x4c, 0x69,
+    0x6c, 0x69, 0x61, 0x6e, 0x00, 0x4c, 0x69, 0x6c, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x4c, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x4c, 0x69, 0x6c, 0x6c, 0x69,
+    0x00, 0x4c, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x00, 0x4c, 0x69, 0x6c, 0x6c,
+    0x69, 0x61, 0x6d, 0x00, 0x4c, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x00,
+    0x4c, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x4c, 0x69, 0x6c,
+    0x6c, 0x69, 0x65, 0x00, 0x4c, 0x69, 0x6c, 0x6c, 0x79, 0x00, 0x4c, 0x69,
+    0x6c, 0x79, 0x00, 0x4c, 0x69, 0x6e, 0x00, 0x4c, 0x69, 0x6e, 0x61, 0x00,
+    0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x00, 0x4c, 0x69, 0x6e, 0x64,
+    0x61, 0x00, 0x4c, 0x69, 0x6e, 0x64, 0x73, 0x61, 0x79, 0x00, 0x4c, 0x69,
+    0x6e, 0x64, 0x73, 0x65, 0x79, 0x00, 0x4c, 0x69, 0x6e, 0x64, 0x73, 0x79,
+    0x00, 0x4c, 0x69, 0x6e, 0x64, 0x79, 0x00, 0x4c, 0x69, 0x6e, 0x65, 0x74,
+    0x74, 0x65, 0x00, 0x4c, 0x69, 0x6e, 0x67, 0x00, 0x4c, 0x69, 0x6e, 0x68,
+    0x00, 0x4c, 0x69, 0x6e, 0x6e, 0x00, 0x4c, 0x69, 0x6e, 0x6e, 0x65, 0x61,
+    0x00, 0x4c, 0x69, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x4c, 0x69, 0x6e, 0x6f,
+    0x00, 0x4c, 0x69, 0x6e, 0x73, 0x65, 0x79, 0x00, 0x4c, 0x69, 0x6e, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x4c, 0x69, 0x6f, 0x6e, 0x65, 0x6c, 0x00, 0x4c,
+    0x69, 0x73, 0x61, 0x00, 0x4c, 0x69, 0x73, 0x61, 0x62, 0x65, 0x74, 0x68,
+    0x00, 0x4c, 0x69, 0x73, 0x61, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x4c, 0x69,
+    0x73, 0x62, 0x65, 0x74, 0x68, 0x00, 0x4c, 0x69, 0x73, 0x65, 0x00, 0x4c,
+    0x69, 0x73, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4c, 0x69, 0x73, 0x68, 0x61,
+    0x00, 0x4c, 0x69, 0x73, 0x73, 0x61, 0x00, 0x4c, 0x69, 0x73, 0x73, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x4c, 0x69, 0x74, 0x61, 0x00, 0x4c, 0x69, 0x76,
+    0x69, 0x61, 0x00, 0x4c, 0x69, 0x7a, 0x00, 0x4c, 0x69, 0x7a, 0x61, 0x00,
+    0x4c, 0x69, 0x7a, 0x61, 0x62, 0x65, 0x74, 0x68, 0x00, 0x4c, 0x69, 0x7a,
+    0x62, 0x65, 0x74, 0x68, 0x00, 0x4c, 0x69, 0x7a, 0x65, 0x74, 0x68, 0x00,
+    0x4c, 0x69, 0x7a, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4c, 0x69, 0x7a, 0x7a,
+    0x65, 0x74, 0x74, 0x65, 0x00, 0x4c, 0x69, 0x7a, 0x7a, 0x69, 0x65, 0x00,
+    0x4c, 0x6c, 0x6f, 0x79, 0x64, 0x00, 0x4c, 0x6f, 0x61, 0x6e, 0x00, 0x4c,
+    0x6f, 0x67, 0x61, 0x6e, 0x00, 0x4c, 0x6f, 0x69, 0x64, 0x61, 0x00, 0x4c,
+    0x6f, 0x69, 0x73, 0x00, 0x4c, 0x6f, 0x69, 0x73, 0x65, 0x00, 0x4c, 0x6f,
+    0x6c, 0x61, 0x00, 0x4c, 0x6f, 0x6c, 0x69, 0x74, 0x61, 0x00, 0x4c, 0x6f,
+    0x6d, 0x61, 0x00, 0x4c, 0x6f, 0x6e, 0x00, 0x4c, 0x6f, 0x6e, 0x61, 0x00,
+    0x4c, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x6f, 0x6e, 0x67, 0x00, 0x4c,
+    0x6f, 0x6e, 0x69, 0x00, 0x4c, 0x6f, 0x6e, 0x6e, 0x61, 0x00, 0x4c, 0x6f,
+    0x6e, 0x6e, 0x69, 0x65, 0x00, 0x4c, 0x6f, 0x6e, 0x6e, 0x79, 0x00, 0x4c,
+    0x6f, 0x72, 0x61, 0x00, 0x4c, 0x6f, 0x72, 0x61, 0x69, 0x6e, 0x65, 0x00,
+    0x4c, 0x6f, 0x72, 0x61, 0x6c, 0x65, 0x65, 0x00, 0x4c, 0x6f, 0x72, 0x65,
+    0x00, 0x4c, 0x6f, 0x72, 0x65, 0x61, 0x6e, 0x00, 0x4c, 0x6f, 0x72, 0x65,
+    0x65, 0x00, 0x4c, 0x6f, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x4c, 0x6f, 0x72,
+    0x65, 0x6c, 0x65, 0x69, 0x00, 0x4c, 0x6f, 0x72, 0x65, 0x6e, 0x00, 0x4c,
+    0x6f, 0x72, 0x65, 0x6e, 0x61, 0x00, 0x4c, 0x6f, 0x72, 0x65, 0x6e, 0x65,
+    0x00, 0x4c, 0x6f, 0x72, 0x65, 0x6e, 0x7a, 0x61, 0x00, 0x4c, 0x6f, 0x72,
+    0x65, 0x6e, 0x7a, 0x6f, 0x00, 0x4c, 0x6f, 0x72, 0x65, 0x74, 0x61, 0x00,
+    0x4c, 0x6f, 0x72, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4c, 0x6f, 0x72, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x4c, 0x6f, 0x72, 0x69, 0x00, 0x4c, 0x6f, 0x72,
+    0x69, 0x61, 0x00, 0x4c, 0x6f, 0x72, 0x69, 0x61, 0x6e, 0x6e, 0x00, 0x4c,
+    0x6f, 0x72, 0x69, 0x65, 0x00, 0x4c, 0x6f, 0x72, 0x69, 0x6c, 0x65, 0x65,
+    0x00, 0x4c, 0x6f, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x4c, 0x6f, 0x72, 0x69,
+    0x6e, 0x64, 0x61, 0x00, 0x4c, 0x6f, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x4c,
+    0x6f, 0x72, 0x69, 0x73, 0x00, 0x4c, 0x6f, 0x72, 0x69, 0x74, 0x61, 0x00,
+    0x4c, 0x6f, 0x72, 0x6e, 0x61, 0x00, 0x4c, 0x6f, 0x72, 0x72, 0x61, 0x69,
+    0x6e, 0x65, 0x00, 0x4c, 0x6f, 0x72, 0x72, 0x65, 0x74, 0x74, 0x61, 0x00,
+    0x4c, 0x6f, 0x72, 0x72, 0x69, 0x00, 0x4c, 0x6f, 0x72, 0x72, 0x69, 0x61,
+    0x6e, 0x65, 0x00, 0x4c, 0x6f, 0x72, 0x72, 0x69, 0x65, 0x00, 0x4c, 0x6f,
+    0x72, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x4c, 0x6f, 0x72, 0x79, 0x00, 0x4c,
+    0x6f, 0x74, 0x74, 0x69, 0x65, 0x00, 0x4c, 0x6f, 0x75, 0x00, 0x4c, 0x6f,
+    0x75, 0x61, 0x6e, 0x6e, 0x00, 0x4c, 0x6f, 0x75, 0x61, 0x6e, 0x6e, 0x65,
+    0x00, 0x4c, 0x6f, 0x75, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4c, 0x6f, 0x75,
+    0x65, 0x74, 0x74, 0x61, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x65, 0x00, 0x4c,
+    0x6f, 0x75, 0x69, 0x73, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x61, 0x00,
+    0x4c, 0x6f, 0x75, 0x69, 0x73, 0x65, 0x00, 0x4c, 0x6f, 0x75, 0x72, 0x61,
+    0x00, 0x4c, 0x6f, 0x75, 0x72, 0x64, 0x65, 0x73, 0x00, 0x4c, 0x6f, 0x75,
+    0x72, 0x69, 0x65, 0x00, 0x4c, 0x6f, 0x75, 0x76, 0x65, 0x6e, 0x69, 0x61,
+    0x00, 0x4c, 0x6f, 0x76, 0x65, 0x00, 0x4c, 0x6f, 0x76, 0x65, 0x6c, 0x6c,
+    0x61, 0x00, 0x4c, 0x6f, 0x76, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4c, 0x6f,
+    0x76, 0x69, 0x65, 0x00, 0x4c, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4c,
+    0x6f, 0x79, 0x63, 0x65, 0x00, 0x4c, 0x6f, 0x79, 0x64, 0x00, 0x4c, 0x75,
+    0x00, 0x4c, 0x75, 0x61, 0x6e, 0x61, 0x00, 0x4c, 0x75, 0x61, 0x6e, 0x6e,
+    0x00, 0x4c, 0x75, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4c, 0x75, 0x61, 0x6e,
+    0x6e, 0x65, 0x00, 0x4c, 0x75, 0x62, 0x61, 0x00, 0x4c, 0x75, 0x63, 0x61,
+    0x73, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x61,
+    0x00, 0x4c, 0x75, 0x63, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x4c, 0x75, 0x63,
+    0x69, 0x61, 0x6e, 0x6f, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x65, 0x00, 0x4c,
+    0x75, 0x63, 0x69, 0x65, 0x6e, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x65, 0x6e,
+    0x6e, 0x65, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x6c, 0x61, 0x00, 0x4c, 0x75,
+    0x63, 0x69, 0x6c, 0x65, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x6c, 0x6c, 0x61,
+    0x00, 0x4c, 0x75, 0x63, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4c, 0x75, 0x63,
+    0x69, 0x6e, 0x61, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x6e, 0x64, 0x61, 0x00,
+    0x4c, 0x75, 0x63, 0x69, 0x6f, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x75, 0x73,
+    0x00, 0x4c, 0x75, 0x63, 0x72, 0x65, 0x63, 0x69, 0x61, 0x00, 0x4c, 0x75,
+    0x63, 0x72, 0x65, 0x74, 0x69, 0x61, 0x00, 0x4c, 0x75, 0x63, 0x79, 0x00,
+    0x4c, 0x75, 0x64, 0x69, 0x65, 0x00, 0x4c, 0x75, 0x64, 0x69, 0x76, 0x69,
+    0x6e, 0x61, 0x00, 0x4c, 0x75, 0x65, 0x00, 0x4c, 0x75, 0x65, 0x6c, 0x6c,
+    0x61, 0x00, 0x4c, 0x75, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4c, 0x75, 0x69,
+    0x67, 0x69, 0x00, 0x4c, 0x75, 0x69, 0x73, 0x00, 0x4c, 0x75, 0x69, 0x73,
+    0x61, 0x00, 0x4c, 0x75, 0x69, 0x73, 0x65, 0x00, 0x4c, 0x75, 0x6b, 0x65,
+    0x00, 0x4c, 0x75, 0x6c, 0x61, 0x00, 0x4c, 0x75, 0x6c, 0x75, 0x00, 0x4c,
+    0x75, 0x6e, 0x61, 0x00, 0x4c, 0x75, 0x70, 0x65, 0x00, 0x4c, 0x75, 0x70,
+    0x69, 0x74, 0x61, 0x00, 0x4c, 0x75, 0x72, 0x61, 0x00, 0x4c, 0x75, 0x72,
+    0x6c, 0x65, 0x6e, 0x65, 0x00, 0x4c, 0x75, 0x72, 0x6c, 0x69, 0x6e, 0x65,
+    0x00, 0x4c, 0x75, 0x74, 0x68, 0x65, 0x72, 0x00, 0x4c, 0x75, 0x76, 0x65,
+    0x6e, 0x69, 0x61, 0x00, 0x4c, 0x75, 0x7a, 0x00, 0x4c, 0x79, 0x64, 0x61,
+    0x00, 0x4c, 0x79, 0x64, 0x69, 0x61, 0x00, 0x4c, 0x79, 0x6c, 0x61, 0x00,
+    0x4c, 0x79, 0x6c, 0x65, 0x00, 0x4c, 0x79, 0x6d, 0x61, 0x6e, 0x00, 0x4c,
+    0x79, 0x6e, 0x00, 0x4c, 0x79, 0x6e, 0x64, 0x61, 0x00, 0x4c, 0x79, 0x6e,
+    0x64, 0x69, 0x61, 0x00, 0x4c, 0x79, 0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x4c,
+    0x79, 0x6e, 0x64, 0x73, 0x61, 0x79, 0x00, 0x4c, 0x79, 0x6e, 0x64, 0x73,
+    0x65, 0x79, 0x00, 0x4c, 0x79, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x79,
+    0x6e, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4c, 0x79, 0x6e, 0x65, 0x74, 0x74,
+    0x61, 0x00, 0x4c, 0x79, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4c, 0x79,
+    0x6e, 0x6e, 0x00, 0x4c, 0x79, 0x6e, 0x6e, 0x61, 0x00, 0x4c, 0x79, 0x6e,
+    0x6e, 0x65, 0x00, 0x4c, 0x79, 0x6e, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00,
+    0x4c, 0x79, 0x6e, 0x73, 0x65, 0x79, 0x00, 0x4c, 0x79, 0x6e, 0x77, 0x6f,
+    0x6f, 0x64, 0x00, 0x4d, 0x61, 0x00, 0x4d, 0x61, 0x62, 0x65, 0x6c, 0x00,
+    0x4d, 0x61, 0x62, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x61, 0x62, 0x6c,
+    0x65, 0x00, 0x4d, 0x61, 0x63, 0x00, 0x4d, 0x61, 0x63, 0x68, 0x65, 0x6c,
+    0x6c, 0x65, 0x00, 0x4d, 0x61, 0x63, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x63,
+    0x6b, 0x00, 0x4d, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x7a, 0x69, 0x65, 0x00,
+    0x4d, 0x61, 0x63, 0x79, 0x00, 0x4d, 0x61, 0x64, 0x61, 0x6c, 0x65, 0x6e,
+    0x65, 0x00, 0x4d, 0x61, 0x64, 0x61, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4d,
+    0x61, 0x64, 0x61, 0x6c, 0x79, 0x6e, 0x00, 0x4d, 0x61, 0x64, 0x64, 0x69,
+    0x65, 0x00, 0x4d, 0x61, 0x64, 0x65, 0x6c, 0x61, 0x69, 0x6e, 0x65, 0x00,
+    0x4d, 0x61, 0x64, 0x65, 0x6c, 0x65, 0x69, 0x6e, 0x65, 0x00, 0x4d, 0x61,
+    0x64, 0x65, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x64, 0x65, 0x6c,
+    0x69, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x64, 0x65, 0x6c, 0x79, 0x6e, 0x00,
+    0x4d, 0x61, 0x64, 0x67, 0x65, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x65, 0x00,
+    0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x64, 0x6c,
+    0x79, 0x6e, 0x00, 0x4d, 0x61, 0x64, 0x6f, 0x6e, 0x6e, 0x61, 0x00, 0x4d,
+    0x61, 0x65, 0x00, 0x4d, 0x61, 0x65, 0x67, 0x61, 0x6e, 0x00, 0x4d, 0x61,
+    0x66, 0x61, 0x6c, 0x64, 0x61, 0x00, 0x4d, 0x61, 0x67, 0x61, 0x6c, 0x69,
+    0x00, 0x4d, 0x61, 0x67, 0x61, 0x6c, 0x79, 0x00, 0x4d, 0x61, 0x67, 0x61,
+    0x6e, 0x00, 0x4d, 0x61, 0x67, 0x61, 0x72, 0x65, 0x74, 0x00, 0x4d, 0x61,
+    0x67, 0x64, 0x61, 0x00, 0x4d, 0x61, 0x67, 0x64, 0x61, 0x6c, 0x65, 0x6e,
+    0x00, 0x4d, 0x61, 0x67, 0x64, 0x61, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x4d,
+    0x61, 0x67, 0x64, 0x61, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x67,
+    0x65, 0x6e, 0x00, 0x4d, 0x61, 0x67, 0x67, 0x69, 0x65, 0x00, 0x4d, 0x61,
+    0x67, 0x6e, 0x6f, 0x6c, 0x69, 0x61, 0x00, 0x4d, 0x61, 0x68, 0x61, 0x6c,
+    0x69, 0x61, 0x00, 0x4d, 0x61, 0x69, 0x00, 0x4d, 0x61, 0x69, 0x61, 0x00,
+    0x4d, 0x61, 0x69, 0x64, 0x61, 0x00, 0x4d, 0x61, 0x69, 0x6c, 0x65, 0x00,
+    0x4d, 0x61, 0x69, 0x72, 0x61, 0x00, 0x4d, 0x61, 0x69, 0x72, 0x65, 0x00,
+    0x4d, 0x61, 0x69, 0x73, 0x68, 0x61, 0x00, 0x4d, 0x61, 0x69, 0x73, 0x69,
+    0x65, 0x00, 0x4d, 0x61, 0x6a, 0x6f, 0x72, 0x00, 0x4d, 0x61, 0x6a, 0x6f,
+    0x72, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x6b, 0x65, 0x64, 0x61, 0x00, 0x4d,
+    0x61, 0x6c, 0x63, 0x6f, 0x6c, 0x6d, 0x00, 0x4d, 0x61, 0x6c, 0x63, 0x6f,
+    0x6d, 0x00, 0x4d, 0x61, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x6c,
+    0x69, 0x61, 0x00, 0x4d, 0x61, 0x6c, 0x69, 0x6b, 0x00, 0x4d, 0x61, 0x6c,
+    0x69, 0x6b, 0x61, 0x00, 0x4d, 0x61, 0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00,
+    0x4d, 0x61, 0x6c, 0x69, 0x73, 0x61, 0x00, 0x4d, 0x61, 0x6c, 0x69, 0x73,
+    0x73, 0x61, 0x00, 0x4d, 0x61, 0x6c, 0x6b, 0x61, 0x00, 0x4d, 0x61, 0x6c,
+    0x6c, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x6c, 0x6c, 0x6f, 0x72, 0x79, 0x00,
+    0x4d, 0x61, 0x6c, 0x6f, 0x72, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x6c, 0x76,
+    0x69, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x6d, 0x69, 0x65, 0x00, 0x4d, 0x61,
+    0x6d, 0x6d, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x6e, 0x00, 0x4d, 0x61, 0x6e,
+    0x61, 0x00, 0x4d, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x4d, 0x61, 0x6e, 0x64,
+    0x69, 0x00, 0x4d, 0x61, 0x6e, 0x64, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x6e,
+    0x64, 0x79, 0x00, 0x4d, 0x61, 0x6e, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x6e,
+    0x75, 0x61, 0x6c, 0x00, 0x4d, 0x61, 0x6e, 0x75, 0x65, 0x6c, 0x00, 0x4d,
+    0x61, 0x6e, 0x75, 0x65, 0x6c, 0x61, 0x00, 0x4d, 0x61, 0x6e, 0x79, 0x00,
+    0x4d, 0x61, 0x6f, 0x00, 0x4d, 0x61, 0x70, 0x6c, 0x65, 0x00, 0x4d, 0x61,
+    0x72, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x61, 0x67, 0x61, 0x72, 0x65, 0x74,
+    0x00, 0x4d, 0x61, 0x72, 0x61, 0x67, 0x72, 0x65, 0x74, 0x00, 0x4d, 0x61,
+    0x72, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x65, 0x6c, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x65, 0x6c,
+    0x61, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x65, 0x6e, 0x65, 0x00,
+    0x4d, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x4d, 0x61,
+    0x72, 0x63, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x63,
+    0x65, 0x6c, 0x69, 0x6e, 0x6f, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x65, 0x6c,
+    0x6c, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x63,
+    0x65, 0x6c, 0x6c, 0x75, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x65, 0x6c,
+    0x6f, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x65, 0x6e, 0x65, 0x00, 0x4d, 0x61,
+    0x72, 0x63, 0x68, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x63,
+    0x69, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x69, 0x61, 0x00, 0x4d, 0x61, 0x72,
+    0x63, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x6f, 0x00, 0x4d, 0x61,
+    0x72, 0x63, 0x6f, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x75, 0x73, 0x00,
+    0x4d, 0x61, 0x72, 0x63, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x64, 0x65, 0x6c,
+    0x6c, 0x00, 0x4d, 0x61, 0x72, 0x65, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x67,
+    0x00, 0x4d, 0x61, 0x72, 0x67, 0x61, 0x72, 0x65, 0x74, 0x00, 0x4d, 0x61,
+    0x72, 0x67, 0x61, 0x72, 0x65, 0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x67,
+    0x61, 0x72, 0x65, 0x74, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x61, 0x72,
+    0x65, 0x74, 0x74, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x61, 0x72, 0x65, 0x74,
+    0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x61, 0x72, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x61, 0x72, 0x69, 0x74, 0x61, 0x00,
+    0x4d, 0x61, 0x72, 0x67, 0x61, 0x72, 0x69, 0x74, 0x65, 0x00, 0x4d, 0x61,
+    0x72, 0x67, 0x61, 0x72, 0x69, 0x74, 0x6f, 0x00, 0x4d, 0x61, 0x72, 0x67,
+    0x61, 0x72, 0x74, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x65, 0x00, 0x4d, 0x61,
+    0x72, 0x67, 0x65, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x65, 0x72,
+    0x65, 0x74, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x65, 0x72, 0x74, 0x00, 0x4d,
+    0x61, 0x72, 0x67, 0x65, 0x72, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x65,
+    0x74, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x68, 0x65, 0x72, 0x69, 0x74, 0x61,
+    0x00, 0x4d, 0x61, 0x72, 0x67, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x67,
+    0x69, 0x74, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x6f, 0x00, 0x4d, 0x61, 0x72,
+    0x67, 0x6f, 0x72, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x6f, 0x74,
+    0x00, 0x4d, 0x61, 0x72, 0x67, 0x72, 0x65, 0x74, 0x00, 0x4d, 0x61, 0x72,
+    0x67, 0x72, 0x65, 0x74, 0x74, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x75, 0x65,
+    0x72, 0x69, 0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x75, 0x65, 0x72,
+    0x69, 0x74, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x75, 0x72, 0x69, 0x74,
+    0x65, 0x00, 0x4d, 0x61, 0x72, 0x67, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x68,
+    0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x00, 0x4d, 0x61, 0x72, 0x69,
+    0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x61, 0x68, 0x00, 0x4d, 0x61, 0x72,
+    0x69, 0x61, 0x6d, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x00, 0x4d,
+    0x61, 0x72, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x61,
+    0x6e, 0x65, 0x6c, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x6e,
+    0x00, 0x4d, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4d, 0x61,
+    0x72, 0x69, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x61,
+    0x6e, 0x6f, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x62, 0x65, 0x6c, 0x00, 0x4d,
+    0x61, 0x72, 0x69, 0x62, 0x65, 0x74, 0x68, 0x00, 0x4d, 0x61, 0x72, 0x69,
+    0x63, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x63, 0x65, 0x6c, 0x61, 0x00,
+    0x4d, 0x61, 0x72, 0x69, 0x63, 0x72, 0x75, 0x7a, 0x00, 0x4d, 0x61, 0x72,
+    0x69, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x65, 0x6c, 0x00, 0x4d, 0x61,
+    0x72, 0x69, 0x65, 0x6c, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x65, 0x6c,
+    0x6c, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x65, 0x6c, 0x6c, 0x65, 0x00,
+    0x4d, 0x61, 0x72, 0x69, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4d, 0x61, 0x72,
+    0x69, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6b, 0x6f,
+    0x00, 0x4d, 0x61, 0x72, 0x69, 0x6c, 0x65, 0x65, 0x00, 0x4d, 0x61, 0x72,
+    0x69, 0x6c, 0x6f, 0x75, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6c, 0x75, 0x00,
+    0x4d, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x69,
+    0x6c, 0x79, 0x6e, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6e, 0x00, 0x4d,
+    0x61, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6e, 0x64,
+    0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x72,
+    0x69, 0x6f, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x00, 0x4d, 0x61,
+    0x72, 0x69, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x73, 0x61, 0x00, 0x4d,
+    0x61, 0x72, 0x69, 0x73, 0x65, 0x6c, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69,
+    0x73, 0x68, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6c, 0x00,
+    0x4d, 0x61, 0x72, 0x69, 0x73, 0x73, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69,
+    0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x74, 0x7a, 0x61, 0x00, 0x4d,
+    0x61, 0x72, 0x69, 0x76, 0x65, 0x6c, 0x00, 0x4d, 0x61, 0x72, 0x6a, 0x6f,
+    0x72, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x6a, 0x6f, 0x72, 0x79, 0x00,
+    0x4d, 0x61, 0x72, 0x6b, 0x00, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x74,
+    0x61, 0x00, 0x4d, 0x61, 0x72, 0x6b, 0x69, 0x74, 0x61, 0x00, 0x4d, 0x61,
+    0x72, 0x6b, 0x75, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x61, 0x00, 0x4d,
+    0x61, 0x72, 0x6c, 0x61, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x65,
+    0x65, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x65, 0x6e, 0x00, 0x4d, 0x61,
+    0x72, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x65, 0x6e,
+    0x65, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x69, 0x6e, 0x00, 0x4d, 0x61, 0x72,
+    0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x6f, 0x00, 0x4d,
+    0x61, 0x72, 0x6c, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x79, 0x6e,
+    0x00, 0x4d, 0x61, 0x72, 0x6c, 0x79, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x6e,
+    0x61, 0x00, 0x4d, 0x61, 0x72, 0x6e, 0x69, 0x00, 0x4d, 0x61, 0x72, 0x6e,
+    0x69, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x71, 0x75, 0x65, 0x72, 0x69, 0x74,
+    0x65, 0x00, 0x4d, 0x61, 0x72, 0x71, 0x75, 0x65, 0x74, 0x74, 0x61, 0x00,
+    0x4d, 0x61, 0x72, 0x71, 0x75, 0x69, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x71,
+    0x75, 0x69, 0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x71, 0x75, 0x69, 0x74,
+    0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x72, 0x79, 0x00, 0x4d, 0x61, 0x72,
+    0x73, 0x68, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c,
+    0x00, 0x4d, 0x61, 0x72, 0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x68,
+    0x00, 0x4d, 0x61, 0x72, 0x74, 0x68, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x74,
+    0x69, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x00, 0x4d, 0x61, 0x72,
+    0x74, 0x69, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x65,
+    0x00, 0x4d, 0x61, 0x72, 0x74, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x76, 0x61,
+    0x00, 0x4d, 0x61, 0x72, 0x76, 0x65, 0x6c, 0x00, 0x4d, 0x61, 0x72, 0x76,
+    0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x76, 0x69, 0x6e, 0x00,
+    0x4d, 0x61, 0x72, 0x76, 0x69, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x78, 0x00,
+    0x4d, 0x61, 0x72, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x61, 0x00, 0x4d,
+    0x61, 0x72, 0x79, 0x61, 0x6c, 0x69, 0x63, 0x65, 0x00, 0x4d, 0x61, 0x72,
+    0x79, 0x61, 0x6d, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x61, 0x6e, 0x6e, 0x00,
+    0x4d, 0x61, 0x72, 0x79, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x72,
+    0x79, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x62, 0x65,
+    0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x62, 0x65, 0x74, 0x68,
+    0x00, 0x4d, 0x61, 0x72, 0x79, 0x65, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x4d,
+    0x61, 0x72, 0x79, 0x65, 0x74, 0x74, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x79,
+    0x6a, 0x61, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6a, 0x6f, 0x00,
+    0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x4d, 0x61, 0x72,
+    0x79, 0x6c, 0x65, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x69, 0x6e,
+    0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x79,
+    0x6c, 0x6f, 0x75, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x6f, 0x75, 0x69,
+    0x73, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x79, 0x6e, 0x00, 0x4d,
+    0x61, 0x72, 0x79, 0x6c, 0x79, 0x6e, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x79,
+    0x72, 0x6f, 0x73, 0x65, 0x00, 0x4d, 0x61, 0x73, 0x61, 0x6b, 0x6f, 0x00,
+    0x4d, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x74, 0x68, 0x61, 0x00,
+    0x4d, 0x61, 0x74, 0x68, 0x65, 0x77, 0x00, 0x4d, 0x61, 0x74, 0x68, 0x69,
+    0x6c, 0x64, 0x61, 0x00, 0x4d, 0x61, 0x74, 0x68, 0x69, 0x6c, 0x64, 0x65,
+    0x00, 0x4d, 0x61, 0x74, 0x69, 0x6c, 0x64, 0x61, 0x00, 0x4d, 0x61, 0x74,
+    0x69, 0x6c, 0x64, 0x65, 0x00, 0x4d, 0x61, 0x74, 0x74, 0x00, 0x4d, 0x61,
+    0x74, 0x74, 0x68, 0x65, 0x77, 0x00, 0x4d, 0x61, 0x74, 0x74, 0x69, 0x65,
+    0x00, 0x4d, 0x61, 0x75, 0x64, 0x00, 0x4d, 0x61, 0x75, 0x64, 0x65, 0x00,
+    0x4d, 0x61, 0x75, 0x64, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x75, 0x72, 0x61,
+    0x00, 0x4d, 0x61, 0x75, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x4d, 0x61, 0x75,
+    0x72, 0x69, 0x63, 0x65, 0x00, 0x4d, 0x61, 0x75, 0x72, 0x69, 0x63, 0x69,
+    0x6f, 0x00, 0x4d, 0x61, 0x75, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x4d, 0x61,
+    0x75, 0x72, 0x69, 0x74, 0x61, 0x00, 0x4d, 0x61, 0x75, 0x72, 0x6f, 0x00,
+    0x4d, 0x61, 0x76, 0x69, 0x73, 0x00, 0x4d, 0x61, 0x78, 0x00, 0x4d, 0x61,
+    0x78, 0x69, 0x65, 0x00, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x61, 0x00, 0x4d,
+    0x61, 0x78, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x78, 0x69,
+    0x6d, 0x6f, 0x00, 0x4d, 0x61, 0x78, 0x69, 0x6e, 0x65, 0x00, 0x4d, 0x61,
+    0x78, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x4d, 0x61,
+    0x79, 0x61, 0x00, 0x4d, 0x61, 0x79, 0x62, 0x65, 0x6c, 0x6c, 0x00, 0x4d,
+    0x61, 0x79, 0x62, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x61, 0x79, 0x65,
+    0x00, 0x4d, 0x61, 0x79, 0x6d, 0x65, 0x00, 0x4d, 0x61, 0x79, 0x6e, 0x61,
+    0x72, 0x64, 0x00, 0x4d, 0x61, 0x79, 0x6f, 0x6c, 0x61, 0x00, 0x4d, 0x61,
+    0x79, 0x72, 0x61, 0x00, 0x4d, 0x61, 0x7a, 0x69, 0x65, 0x00, 0x4d, 0x63,
+    0x6b, 0x65, 0x6e, 0x7a, 0x69, 0x65, 0x00, 0x4d, 0x63, 0x6b, 0x69, 0x6e,
+    0x6c, 0x65, 0x79, 0x00, 0x4d, 0x65, 0x61, 0x67, 0x61, 0x6e, 0x00, 0x4d,
+    0x65, 0x61, 0x67, 0x68, 0x61, 0x6e, 0x00, 0x4d, 0x65, 0x63, 0x68, 0x65,
+    0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x65, 0x64, 0x61, 0x00, 0x4d, 0x65, 0x65,
+    0x00, 0x4d, 0x65, 0x67, 0x00, 0x4d, 0x65, 0x67, 0x61, 0x6e, 0x00, 0x4d,
+    0x65, 0x67, 0x67, 0x61, 0x6e, 0x00, 0x4d, 0x65, 0x67, 0x68, 0x61, 0x6e,
+    0x00, 0x4d, 0x65, 0x67, 0x68, 0x61, 0x6e, 0x6e, 0x00, 0x4d, 0x65, 0x69,
+    0x00, 0x4d, 0x65, 0x6c, 0x00, 0x4d, 0x65, 0x6c, 0x61, 0x69, 0x6e, 0x65,
+    0x00, 0x4d, 0x65, 0x6c, 0x61, 0x6e, 0x69, 0x00, 0x4d, 0x65, 0x6c, 0x61,
+    0x6e, 0x69, 0x61, 0x00, 0x4d, 0x65, 0x6c, 0x61, 0x6e, 0x69, 0x65, 0x00,
+    0x4d, 0x65, 0x6c, 0x61, 0x6e, 0x79, 0x00, 0x4d, 0x65, 0x6c, 0x62, 0x61,
+    0x00, 0x4d, 0x65, 0x6c, 0x64, 0x61, 0x00, 0x4d, 0x65, 0x6c, 0x69, 0x61,
+    0x00, 0x4d, 0x65, 0x6c, 0x69, 0x64, 0x61, 0x00, 0x4d, 0x65, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x4d, 0x65, 0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x4d,
+    0x65, 0x6c, 0x69, 0x73, 0x61, 0x00, 0x4d, 0x65, 0x6c, 0x69, 0x73, 0x73,
+    0x61, 0x00, 0x4d, 0x65, 0x6c, 0x69, 0x73, 0x73, 0x69, 0x61, 0x00, 0x4d,
+    0x65, 0x6c, 0x69, 0x74, 0x61, 0x00, 0x4d, 0x65, 0x6c, 0x6c, 0x69, 0x65,
+    0x00, 0x4d, 0x65, 0x6c, 0x6c, 0x69, 0x73, 0x61, 0x00, 0x4d, 0x65, 0x6c,
+    0x6c, 0x69, 0x73, 0x73, 0x61, 0x00, 0x4d, 0x65, 0x6c, 0x6f, 0x64, 0x65,
+    0x65, 0x00, 0x4d, 0x65, 0x6c, 0x6f, 0x64, 0x69, 0x00, 0x4d, 0x65, 0x6c,
+    0x6f, 0x64, 0x69, 0x65, 0x00, 0x4d, 0x65, 0x6c, 0x6f, 0x64, 0x79, 0x00,
+    0x4d, 0x65, 0x6c, 0x6f, 0x6e, 0x69, 0x65, 0x00, 0x4d, 0x65, 0x6c, 0x6f,
+    0x6e, 0x79, 0x00, 0x4d, 0x65, 0x6c, 0x76, 0x61, 0x00, 0x4d, 0x65, 0x6c,
+    0x76, 0x69, 0x6e, 0x00, 0x4d, 0x65, 0x6c, 0x76, 0x69, 0x6e, 0x61, 0x00,
+    0x4d, 0x65, 0x6c, 0x79, 0x6e, 0x64, 0x61, 0x00, 0x4d, 0x65, 0x6e, 0x64,
+    0x79, 0x00, 0x4d, 0x65, 0x72, 0x63, 0x65, 0x64, 0x65, 0x73, 0x00, 0x4d,
+    0x65, 0x72, 0x63, 0x65, 0x64, 0x65, 0x7a, 0x00, 0x4d, 0x65, 0x72, 0x63,
+    0x79, 0x00, 0x4d, 0x65, 0x72, 0x65, 0x64, 0x69, 0x74, 0x68, 0x00, 0x4d,
+    0x65, 0x72, 0x69, 0x00, 0x4d, 0x65, 0x72, 0x69, 0x64, 0x65, 0x74, 0x68,
+    0x00, 0x4d, 0x65, 0x72, 0x69, 0x64, 0x69, 0x74, 0x68, 0x00, 0x4d, 0x65,
+    0x72, 0x69, 0x6c, 0x79, 0x6e, 0x00, 0x4d, 0x65, 0x72, 0x69, 0x73, 0x73,
+    0x61, 0x00, 0x4d, 0x65, 0x72, 0x6c, 0x65, 0x00, 0x4d, 0x65, 0x72, 0x6c,
+    0x65, 0x6e, 0x65, 0x00, 0x4d, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x00, 0x4d,
+    0x65, 0x72, 0x6c, 0x79, 0x6e, 0x00, 0x4d, 0x65, 0x72, 0x6e, 0x61, 0x00,
+    0x4d, 0x65, 0x72, 0x72, 0x69, 0x00, 0x4d, 0x65, 0x72, 0x72, 0x69, 0x65,
+    0x00, 0x4d, 0x65, 0x72, 0x72, 0x69, 0x6c, 0x65, 0x65, 0x00, 0x4d, 0x65,
+    0x72, 0x72, 0x69, 0x6c, 0x6c, 0x00, 0x4d, 0x65, 0x72, 0x72, 0x79, 0x00,
+    0x4d, 0x65, 0x72, 0x74, 0x69, 0x65, 0x00, 0x4d, 0x65, 0x72, 0x76, 0x69,
+    0x6e, 0x00, 0x4d, 0x65, 0x72, 0x79, 0x6c, 0x00, 0x4d, 0x65, 0x74, 0x61,
+    0x00, 0x4d, 0x69, 0x00, 0x4d, 0x69, 0x61, 0x00, 0x4d, 0x69, 0x63, 0x61,
+    0x00, 0x4d, 0x69, 0x63, 0x61, 0x65, 0x6c, 0x61, 0x00, 0x4d, 0x69, 0x63,
+    0x61, 0x68, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x61, 0x00, 0x4d, 0x69, 0x63,
+    0x68, 0x61, 0x65, 0x6c, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c,
+    0x61, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c, 0x65, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x61, 0x6c, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x61, 0x6c,
+    0x65, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x65, 0x61, 0x6c, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x65, 0x6c, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x65, 0x6c, 0x65,
+    0x00, 0x4d, 0x69, 0x63, 0x68, 0x65, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4d, 0x69, 0x63,
+    0x68, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x65, 0x6c, 0x6c,
+    0x65, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x6b, 0x6f, 0x00, 0x4d, 0x69,
+    0x63, 0x6b, 0x65, 0x79, 0x00, 0x4d, 0x69, 0x63, 0x6b, 0x69, 0x00, 0x4d,
+    0x69, 0x63, 0x6b, 0x69, 0x65, 0x00, 0x4d, 0x69, 0x65, 0x73, 0x68, 0x61,
+    0x00, 0x4d, 0x69, 0x67, 0x64, 0x61, 0x6c, 0x69, 0x61, 0x00, 0x4d, 0x69,
+    0x67, 0x6e, 0x6f, 0x6e, 0x00, 0x4d, 0x69, 0x67, 0x75, 0x65, 0x6c, 0x00,
+    0x4d, 0x69, 0x67, 0x75, 0x65, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x4d, 0x69,
+    0x6b, 0x61, 0x00, 0x4d, 0x69, 0x6b, 0x61, 0x65, 0x6c, 0x61, 0x00, 0x4d,
+    0x69, 0x6b, 0x65, 0x00, 0x4d, 0x69, 0x6b, 0x65, 0x6c, 0x00, 0x4d, 0x69,
+    0x6b, 0x69, 0x00, 0x4d, 0x69, 0x6b, 0x6b, 0x69, 0x00, 0x4d, 0x69, 0x6c,
+    0x61, 0x00, 0x4d, 0x69, 0x6c, 0x61, 0x67, 0x72, 0x6f, 0x00, 0x4d, 0x69,
+    0x6c, 0x61, 0x67, 0x72, 0x6f, 0x73, 0x00, 0x4d, 0x69, 0x6c, 0x61, 0x6e,
+    0x00, 0x4d, 0x69, 0x6c, 0x64, 0x61, 0x00, 0x4d, 0x69, 0x6c, 0x64, 0x72,
+    0x65, 0x64, 0x00, 0x4d, 0x69, 0x6c, 0x65, 0x73, 0x00, 0x4d, 0x69, 0x6c,
+    0x66, 0x6f, 0x72, 0x64, 0x00, 0x4d, 0x69, 0x6c, 0x69, 0x73, 0x73, 0x61,
+    0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x00, 0x4d, 0x69, 0x6c,
+    0x6c, 0x69, 0x63, 0x65, 0x6e, 0x74, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x69,
+    0x65, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x79, 0x00, 0x4d, 0x69, 0x6c, 0x6f,
+    0x00, 0x4d, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x69, 0x6d, 0x69,
+    0x00, 0x4d, 0x69, 0x6e, 0x00, 0x4d, 0x69, 0x6e, 0x61, 0x00, 0x4d, 0x69,
+    0x6e, 0x64, 0x61, 0x00, 0x4d, 0x69, 0x6e, 0x64, 0x69, 0x00, 0x4d, 0x69,
+    0x6e, 0x64, 0x79, 0x00, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x76, 0x61, 0x00,
+    0x4d, 0x69, 0x6e, 0x67, 0x00, 0x4d, 0x69, 0x6e, 0x68, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x61, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x4d,
+    0x69, 0x6e, 0x74, 0x61, 0x00, 0x4d, 0x69, 0x71, 0x75, 0x65, 0x6c, 0x00,
+    0x4d, 0x69, 0x72, 0x61, 0x00, 0x4d, 0x69, 0x72, 0x61, 0x6e, 0x64, 0x61,
+    0x00, 0x4d, 0x69, 0x72, 0x65, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x69,
+    0x72, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4d, 0x69, 0x72, 0x65, 0x79, 0x61,
+    0x00, 0x4d, 0x69, 0x72, 0x69, 0x61, 0x6d, 0x00, 0x4d, 0x69, 0x72, 0x69,
+    0x61, 0x6e, 0x00, 0x4d, 0x69, 0x72, 0x6e, 0x61, 0x00, 0x4d, 0x69, 0x72,
+    0x74, 0x61, 0x00, 0x4d, 0x69, 0x72, 0x74, 0x68, 0x61, 0x00, 0x4d, 0x69,
+    0x73, 0x68, 0x61, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x79, 0x00, 0x4d, 0x69, 0x73, 0x74, 0x69, 0x00, 0x4d, 0x69, 0x73,
+    0x74, 0x69, 0x65, 0x00, 0x4d, 0x69, 0x73, 0x74, 0x79, 0x00, 0x4d, 0x69,
+    0x74, 0x63, 0x68, 0x00, 0x4d, 0x69, 0x74, 0x63, 0x68, 0x65, 0x6c, 0x00,
+    0x4d, 0x69, 0x74, 0x63, 0x68, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x69, 0x74,
+    0x73, 0x75, 0x65, 0x00, 0x4d, 0x69, 0x74, 0x73, 0x75, 0x6b, 0x6f, 0x00,
+    0x4d, 0x69, 0x74, 0x74, 0x69, 0x65, 0x00, 0x4d, 0x69, 0x74, 0x7a, 0x69,
+    0x00, 0x4d, 0x69, 0x74, 0x7a, 0x69, 0x65, 0x00, 0x4d, 0x69, 0x79, 0x6f,
+    0x6b, 0x6f, 0x00, 0x4d, 0x6f, 0x64, 0x65, 0x73, 0x74, 0x61, 0x00, 0x4d,
+    0x6f, 0x64, 0x65, 0x73, 0x74, 0x6f, 0x00, 0x4d, 0x6f, 0x68, 0x61, 0x6d,
+    0x65, 0x64, 0x00, 0x4d, 0x6f, 0x68, 0x61, 0x6d, 0x6d, 0x61, 0x64, 0x00,
+    0x4d, 0x6f, 0x68, 0x61, 0x6d, 0x6d, 0x65, 0x64, 0x00, 0x4d, 0x6f, 0x69,
+    0x72, 0x61, 0x00, 0x4d, 0x6f, 0x69, 0x73, 0x65, 0x73, 0x00, 0x4d, 0x6f,
+    0x6c, 0x6c, 0x69, 0x65, 0x00, 0x4d, 0x6f, 0x6c, 0x6c, 0x79, 0x00, 0x4d,
+    0x6f, 0x6e, 0x61, 0x00, 0x4d, 0x6f, 0x6e, 0x65, 0x74, 0x00, 0x4d, 0x6f,
+    0x6e, 0x69, 0x63, 0x61, 0x00, 0x4d, 0x6f, 0x6e, 0x69, 0x6b, 0x61, 0x00,
+    0x4d, 0x6f, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x00, 0x4d, 0x6f, 0x6e, 0x6e,
+    0x69, 0x65, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x00, 0x4d, 0x6f,
+    0x6e, 0x73, 0x65, 0x72, 0x72, 0x61, 0x74, 0x65, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x65, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x6f, 0x6f,
+    0x6e, 0x00, 0x4d, 0x6f, 0x72, 0x61, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61,
+    0x6e, 0x00, 0x4d, 0x6f, 0x72, 0x69, 0x61, 0x68, 0x00, 0x4d, 0x6f, 0x72,
+    0x72, 0x69, 0x73, 0x00, 0x4d, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x4d,
+    0x6f, 0x73, 0x65, 0x00, 0x4d, 0x6f, 0x73, 0x65, 0x73, 0x00, 0x4d, 0x6f,
+    0x73, 0x68, 0x65, 0x00, 0x4d, 0x6f, 0x7a, 0x65, 0x6c, 0x6c, 0x00, 0x4d,
+    0x6f, 0x7a, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4d, 0x6f, 0x7a, 0x65, 0x6c,
+    0x6c, 0x65, 0x00, 0x4d, 0x75, 0x69, 0x00, 0x4d, 0x75, 0x6f, 0x69, 0x00,
+    0x4d, 0x75, 0x72, 0x69, 0x65, 0x6c, 0x00, 0x4d, 0x75, 0x72, 0x72, 0x61,
+    0x79, 0x00, 0x4d, 0x79, 0x00, 0x4d, 0x79, 0x65, 0x73, 0x68, 0x61, 0x00,
+    0x4d, 0x79, 0x6c, 0x65, 0x73, 0x00, 0x4d, 0x79, 0x6f, 0x6e, 0x67, 0x00,
+    0x4d, 0x79, 0x72, 0x61, 0x00, 0x4d, 0x79, 0x72, 0x69, 0x61, 0x6d, 0x00,
+    0x4d, 0x79, 0x72, 0x6c, 0x00, 0x4d, 0x79, 0x72, 0x6c, 0x65, 0x00, 0x4d,
+    0x79, 0x72, 0x6e, 0x61, 0x00, 0x4d, 0x79, 0x72, 0x6f, 0x6e, 0x00, 0x4d,
+    0x79, 0x72, 0x74, 0x61, 0x00, 0x4d, 0x79, 0x72, 0x74, 0x69, 0x63, 0x65,
+    0x00, 0x4d, 0x79, 0x72, 0x74, 0x69, 0x65, 0x00, 0x4d, 0x79, 0x72, 0x74,
+    0x69, 0x73, 0x00, 0x4d, 0x79, 0x72, 0x74, 0x6c, 0x65, 0x00, 0x4d, 0x79,
+    0x75, 0x6e, 0x67, 0x00, 0x4e, 0x61, 0x00, 0x4e, 0x61, 0x64, 0x61, 0x00,
+    0x4e, 0x61, 0x64, 0x65, 0x6e, 0x65, 0x00, 0x4e, 0x61, 0x64, 0x69, 0x61,
+    0x00, 0x4e, 0x61, 0x64, 0x69, 0x6e, 0x65, 0x00, 0x4e, 0x61, 0x69, 0x64,
+    0x61, 0x00, 0x4e, 0x61, 0x6b, 0x65, 0x73, 0x68, 0x61, 0x00, 0x4e, 0x61,
+    0x6b, 0x69, 0x61, 0x00, 0x4e, 0x61, 0x6b, 0x69, 0x73, 0x68, 0x61, 0x00,
+    0x4e, 0x61, 0x6b, 0x69, 0x74, 0x61, 0x00, 0x4e, 0x61, 0x6d, 0x00, 0x4e,
+    0x61, 0x6e, 0x00, 0x4e, 0x61, 0x6e, 0x61, 0x00, 0x4e, 0x61, 0x6e, 0x63,
+    0x65, 0x65, 0x00, 0x4e, 0x61, 0x6e, 0x63, 0x65, 0x79, 0x00, 0x4e, 0x61,
+    0x6e, 0x63, 0x69, 0x00, 0x4e, 0x61, 0x6e, 0x63, 0x69, 0x65, 0x00, 0x4e,
+    0x61, 0x6e, 0x63, 0x79, 0x00, 0x4e, 0x61, 0x6e, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x4e, 0x61, 0x6e, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4e, 0x61,
+    0x6e, 0x6e, 0x69, 0x65, 0x00, 0x4e, 0x61, 0x6f, 0x6d, 0x61, 0x00, 0x4e,
+    0x61, 0x6f, 0x6d, 0x69, 0x00, 0x4e, 0x61, 0x70, 0x6f, 0x6c, 0x65, 0x6f,
+    0x6e, 0x00, 0x4e, 0x61, 0x72, 0x63, 0x69, 0x73, 0x61, 0x00, 0x4e, 0x61,
+    0x74, 0x61, 0x63, 0x68, 0x61, 0x00, 0x4e, 0x61, 0x74, 0x61, 0x6c, 0x69,
+    0x61, 0x00, 0x4e, 0x61, 0x74, 0x61, 0x6c, 0x69, 0x65, 0x00, 0x4e, 0x61,
+    0x74, 0x61, 0x6c, 0x79, 0x61, 0x00, 0x4e, 0x61, 0x74, 0x61, 0x73, 0x68,
+    0x61, 0x00, 0x4e, 0x61, 0x74, 0x61, 0x73, 0x68, 0x69, 0x61, 0x00, 0x4e,
+    0x61, 0x74, 0x68, 0x61, 0x6c, 0x69, 0x65, 0x00, 0x4e, 0x61, 0x74, 0x68,
+    0x61, 0x6e, 0x00, 0x4e, 0x61, 0x74, 0x68, 0x61, 0x6e, 0x61, 0x65, 0x6c,
+    0x00, 0x4e, 0x61, 0x74, 0x68, 0x61, 0x6e, 0x69, 0x61, 0x6c, 0x00, 0x4e,
+    0x61, 0x74, 0x68, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x00, 0x4e, 0x61, 0x74,
+    0x69, 0x73, 0x68, 0x61, 0x00, 0x4e, 0x61, 0x74, 0x69, 0x76, 0x69, 0x64,
+    0x61, 0x64, 0x00, 0x4e, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x61, 0x00, 0x4e,
+    0x65, 0x61, 0x6c, 0x00, 0x4e, 0x65, 0x63, 0x6f, 0x6c, 0x65, 0x00, 0x4e,
+    0x65, 0x64, 0x00, 0x4e, 0x65, 0x64, 0x61, 0x00, 0x4e, 0x65, 0x64, 0x72,
+    0x61, 0x00, 0x4e, 0x65, 0x65, 0x6c, 0x79, 0x00, 0x4e, 0x65, 0x69, 0x64,
+    0x61, 0x00, 0x4e, 0x65, 0x69, 0x6c, 0x00, 0x4e, 0x65, 0x6c, 0x64, 0x61,
+    0x00, 0x4e, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x4e, 0x65, 0x6c, 0x69, 0x64,
+    0x61, 0x00, 0x4e, 0x65, 0x6c, 0x6c, 0x00, 0x4e, 0x65, 0x6c, 0x6c, 0x61,
+    0x00, 0x4e, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4e, 0x65, 0x6c, 0x6c, 0x69,
+    0x65, 0x00, 0x4e, 0x65, 0x6c, 0x6c, 0x79, 0x00, 0x4e, 0x65, 0x6c, 0x73,
+    0x6f, 0x6e, 0x00, 0x4e, 0x65, 0x6e, 0x61, 0x00, 0x4e, 0x65, 0x6e, 0x69,
+    0x74, 0x61, 0x00, 0x4e, 0x65, 0x6f, 0x6d, 0x61, 0x00, 0x4e, 0x65, 0x6f,
+    0x6d, 0x69, 0x00, 0x4e, 0x65, 0x72, 0x65, 0x69, 0x64, 0x61, 0x00, 0x4e,
+    0x65, 0x72, 0x69, 0x73, 0x73, 0x61, 0x00, 0x4e, 0x65, 0x72, 0x79, 0x00,
+    0x4e, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x00, 0x4e, 0x65, 0x74, 0x61, 0x00,
+    0x4e, 0x65, 0x74, 0x74, 0x69, 0x65, 0x00, 0x4e, 0x65, 0x76, 0x61, 0x00,
+    0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x4e, 0x65, 0x76, 0x69, 0x6c,
+    0x6c, 0x65, 0x00, 0x4e, 0x65, 0x77, 0x74, 0x6f, 0x6e, 0x00, 0x4e, 0x67,
+    0x61, 0x00, 0x4e, 0x67, 0x61, 0x6e, 0x00, 0x4e, 0x67, 0x6f, 0x63, 0x00,
+    0x4e, 0x67, 0x75, 0x79, 0x65, 0x74, 0x00, 0x4e, 0x69, 0x61, 0x00, 0x4e,
+    0x69, 0x63, 0x68, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4e, 0x69, 0x63, 0x68,
+    0x6f, 0x6c, 0x00, 0x4e, 0x69, 0x63, 0x68, 0x6f, 0x6c, 0x61, 0x73, 0x00,
+    0x4e, 0x69, 0x63, 0x68, 0x6f, 0x6c, 0x65, 0x00, 0x4e, 0x69, 0x63, 0x68,
+    0x6f, 0x6c, 0x6c, 0x65, 0x00, 0x4e, 0x69, 0x63, 0x6b, 0x00, 0x4e, 0x69,
+    0x63, 0x6b, 0x69, 0x00, 0x4e, 0x69, 0x63, 0x6b, 0x69, 0x65, 0x00, 0x4e,
+    0x69, 0x63, 0x6b, 0x6f, 0x6c, 0x61, 0x73, 0x00, 0x4e, 0x69, 0x63, 0x6b,
+    0x6f, 0x6c, 0x65, 0x00, 0x4e, 0x69, 0x63, 0x6b, 0x79, 0x00, 0x4e, 0x69,
+    0x63, 0x6f, 0x6c, 0x00, 0x4e, 0x69, 0x63, 0x6f, 0x6c, 0x61, 0x00, 0x4e,
+    0x69, 0x63, 0x6f, 0x6c, 0x61, 0x73, 0x00, 0x4e, 0x69, 0x63, 0x6f, 0x6c,
+    0x61, 0x73, 0x61, 0x00, 0x4e, 0x69, 0x63, 0x6f, 0x6c, 0x65, 0x00, 0x4e,
+    0x69, 0x63, 0x6f, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4e, 0x69, 0x63,
+    0x6f, 0x6c, 0x6c, 0x65, 0x00, 0x4e, 0x69, 0x64, 0x61, 0x00, 0x4e, 0x69,
+    0x64, 0x69, 0x61, 0x00, 0x4e, 0x69, 0x65, 0x73, 0x68, 0x61, 0x00, 0x4e,
+    0x69, 0x65, 0x76, 0x65, 0x73, 0x00, 0x4e, 0x69, 0x67, 0x65, 0x6c, 0x00,
+    0x4e, 0x69, 0x6b, 0x69, 0x00, 0x4e, 0x69, 0x6b, 0x69, 0x61, 0x00, 0x4e,
+    0x69, 0x6b, 0x69, 0x74, 0x61, 0x00, 0x4e, 0x69, 0x6b, 0x6b, 0x69, 0x00,
+    0x4e, 0x69, 0x6b, 0x6f, 0x6c, 0x65, 0x00, 0x4e, 0x69, 0x6c, 0x61, 0x00,
+    0x4e, 0x69, 0x6c, 0x64, 0x61, 0x00, 0x4e, 0x69, 0x6c, 0x73, 0x61, 0x00,
+    0x4e, 0x69, 0x6e, 0x61, 0x00, 0x4e, 0x69, 0x6e, 0x66, 0x61, 0x00, 0x4e,
+    0x69, 0x73, 0x68, 0x61, 0x00, 0x4e, 0x69, 0x74, 0x61, 0x00, 0x4e, 0x6f,
+    0x61, 0x68, 0x00, 0x4e, 0x6f, 0x62, 0x6c, 0x65, 0x00, 0x4e, 0x6f, 0x62,
+    0x75, 0x6b, 0x6f, 0x00, 0x4e, 0x6f, 0x65, 0x00, 0x4e, 0x6f, 0x65, 0x6c,
+    0x00, 0x4e, 0x6f, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x4e, 0x6f, 0x65, 0x6c,
+    0x6c, 0x61, 0x00, 0x4e, 0x6f, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x4e, 0x6f,
+    0x65, 0x6d, 0x69, 0x00, 0x4e, 0x6f, 0x68, 0x65, 0x6d, 0x69, 0x00, 0x4e,
+    0x6f, 0x6c, 0x61, 0x00, 0x4e, 0x6f, 0x6c, 0x61, 0x6e, 0x00, 0x4e, 0x6f,
+    0x6d, 0x61, 0x00, 0x4e, 0x6f, 0x6e, 0x61, 0x00, 0x4e, 0x6f, 0x72, 0x61,
+    0x00, 0x4e, 0x6f, 0x72, 0x61, 0x68, 0x00, 0x4e, 0x6f, 0x72, 0x62, 0x65,
+    0x72, 0x74, 0x00, 0x4e, 0x6f, 0x72, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x00,
+    0x4e, 0x6f, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x4e, 0x6f, 0x72, 0x65, 0x6e,
+    0x65, 0x00, 0x4e, 0x6f, 0x72, 0x69, 0x6b, 0x6f, 0x00, 0x4e, 0x6f, 0x72,
+    0x69, 0x6e, 0x65, 0x00, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x00, 0x4e, 0x6f,
+    0x72, 0x6d, 0x61, 0x6e, 0x00, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x64,
+    0x00, 0x4e, 0x6f, 0x72, 0x72, 0x69, 0x73, 0x00, 0x4e, 0x6f, 0x76, 0x61,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4e, 0x75, 0x00,
+    0x4e, 0x75, 0x62, 0x69, 0x61, 0x00, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
+    0x73, 0x00, 0x4e, 0x79, 0x64, 0x69, 0x61, 0x00, 0x4e, 0x79, 0x6c, 0x61,
+    0x00, 0x4f, 0x62, 0x64, 0x75, 0x6c, 0x69, 0x61, 0x00, 0x4f, 0x63, 0x69,
+    0x65, 0x00, 0x4f, 0x63, 0x74, 0x61, 0x76, 0x69, 0x61, 0x00, 0x4f, 0x63,
+    0x74, 0x61, 0x76, 0x69, 0x6f, 0x00, 0x4f, 0x64, 0x61, 0x00, 0x4f, 0x64,
+    0x65, 0x6c, 0x69, 0x61, 0x00, 0x4f, 0x64, 0x65, 0x6c, 0x6c, 0x00, 0x4f,
+    0x64, 0x65, 0x73, 0x73, 0x61, 0x00, 0x4f, 0x64, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x4f, 0x64, 0x69, 0x6c, 0x69, 0x61, 0x00, 0x4f, 0x64, 0x69, 0x73,
+    0x00, 0x4f, 0x66, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x4f, 0x6b, 0x00, 0x4f,
+    0x6c, 0x61, 0x00, 0x4f, 0x6c, 0x65, 0x6e, 0x00, 0x4f, 0x6c, 0x65, 0x6e,
+    0x65, 0x00, 0x4f, 0x6c, 0x65, 0x74, 0x61, 0x00, 0x4f, 0x6c, 0x65, 0x76,
+    0x69, 0x61, 0x00, 0x4f, 0x6c, 0x67, 0x61, 0x00, 0x4f, 0x6c, 0x69, 0x6d,
+    0x70, 0x69, 0x61, 0x00, 0x4f, 0x6c, 0x69, 0x6e, 0x00, 0x4f, 0x6c, 0x69,
+    0x6e, 0x64, 0x61, 0x00, 0x4f, 0x6c, 0x69, 0x76, 0x61, 0x00, 0x4f, 0x6c,
+    0x69, 0x76, 0x65, 0x00, 0x4f, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x00, 0x4f,
+    0x6c, 0x69, 0x76, 0x69, 0x61, 0x00, 0x4f, 0x6c, 0x6c, 0x69, 0x65, 0x00,
+    0x4f, 0x6c, 0x79, 0x6d, 0x70, 0x69, 0x61, 0x00, 0x4f, 0x6d, 0x61, 0x00,
+    0x4f, 0x6d, 0x61, 0x72, 0x00, 0x4f, 0x6d, 0x65, 0x67, 0x61, 0x00, 0x4f,
+    0x6d, 0x65, 0x72, 0x00, 0x4f, 0x6e, 0x61, 0x00, 0x4f, 0x6e, 0x65, 0x69,
+    0x64, 0x61, 0x00, 0x4f, 0x6e, 0x69, 0x65, 0x00, 0x4f, 0x6e, 0x69, 0x74,
+    0x61, 0x00, 0x4f, 0x70, 0x61, 0x6c, 0x00, 0x4f, 0x70, 0x68, 0x65, 0x6c,
+    0x69, 0x61, 0x00, 0x4f, 0x72, 0x61, 0x00, 0x4f, 0x72, 0x61, 0x6c, 0x65,
+    0x65, 0x00, 0x4f, 0x72, 0x61, 0x6c, 0x69, 0x61, 0x00, 0x4f, 0x72, 0x65,
+    0x6e, 0x00, 0x4f, 0x72, 0x65, 0x74, 0x68, 0x61, 0x00, 0x4f, 0x72, 0x6c,
+    0x61, 0x6e, 0x64, 0x6f, 0x00, 0x4f, 0x72, 0x70, 0x68, 0x61, 0x00, 0x4f,
+    0x72, 0x76, 0x61, 0x6c, 0x00, 0x4f, 0x72, 0x76, 0x69, 0x6c, 0x6c, 0x65,
+    0x00, 0x4f, 0x73, 0x63, 0x61, 0x72, 0x00, 0x4f, 0x73, 0x73, 0x69, 0x65,
+    0x00, 0x4f, 0x73, 0x76, 0x61, 0x6c, 0x64, 0x6f, 0x00, 0x4f, 0x73, 0x77,
+    0x61, 0x6c, 0x64, 0x6f, 0x00, 0x4f, 0x74, 0x65, 0x6c, 0x69, 0x61, 0x00,
+    0x4f, 0x74, 0x68, 0x61, 0x00, 0x4f, 0x74, 0x69, 0x6c, 0x69, 0x61, 0x00,
+    0x4f, 0x74, 0x69, 0x73, 0x00, 0x4f, 0x74, 0x74, 0x6f, 0x00, 0x4f, 0x75,
+    0x69, 0x64, 0x61, 0x00, 0x4f, 0x77, 0x65, 0x6e, 0x00, 0x4f, 0x7a, 0x65,
+    0x6c, 0x6c, 0x00, 0x4f, 0x7a, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x4f, 0x7a,
+    0x69, 0x65, 0x00, 0x50, 0x61, 0x00, 0x50, 0x61, 0x62, 0x6c, 0x6f, 0x00,
+    0x50, 0x61, 0x67, 0x65, 0x00, 0x50, 0x61, 0x69, 0x67, 0x65, 0x00, 0x50,
+    0x61, 0x6c, 0x6d, 0x61, 0x00, 0x50, 0x61, 0x6c, 0x6d, 0x65, 0x72, 0x00,
+    0x50, 0x61, 0x6c, 0x6d, 0x69, 0x72, 0x61, 0x00, 0x50, 0x61, 0x6d, 0x00,
+    0x50, 0x61, 0x6d, 0x61, 0x6c, 0x61, 0x00, 0x50, 0x61, 0x6d, 0x65, 0x6c,
+    0x61, 0x00, 0x50, 0x61, 0x6d, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x50, 0x61,
+    0x6d, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x50, 0x61, 0x6d, 0x69, 0x6c, 0x61,
+    0x00, 0x50, 0x61, 0x6d, 0x75, 0x6c, 0x61, 0x00, 0x50, 0x61, 0x6e, 0x64,
+    0x6f, 0x72, 0x61, 0x00, 0x50, 0x61, 0x6e, 0x73, 0x79, 0x00, 0x50, 0x61,
+    0x6f, 0x6c, 0x61, 0x00, 0x50, 0x61, 0x72, 0x69, 0x73, 0x00, 0x50, 0x61,
+    0x72, 0x6b, 0x65, 0x72, 0x00, 0x50, 0x61, 0x72, 0x74, 0x68, 0x65, 0x6e,
+    0x69, 0x61, 0x00, 0x50, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x61, 0x00,
+    0x50, 0x61, 0x73, 0x71, 0x75, 0x61, 0x6c, 0x65, 0x00, 0x50, 0x61, 0x73,
+    0x74, 0x79, 0x00, 0x50, 0x61, 0x74, 0x00, 0x50, 0x61, 0x74, 0x69, 0x65,
+    0x6e, 0x63, 0x65, 0x00, 0x50, 0x61, 0x74, 0x72, 0x69, 0x61, 0x00, 0x50,
+    0x61, 0x74, 0x72, 0x69, 0x63, 0x61, 0x00, 0x50, 0x61, 0x74, 0x72, 0x69,
+    0x63, 0x65, 0x00, 0x50, 0x61, 0x74, 0x72, 0x69, 0x63, 0x69, 0x61, 0x00,
+    0x50, 0x61, 0x74, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x50, 0x61, 0x74, 0x72,
+    0x69, 0x6e, 0x61, 0x00, 0x50, 0x61, 0x74, 0x73, 0x79, 0x00, 0x50, 0x61,
+    0x74, 0x74, 0x69, 0x00, 0x50, 0x61, 0x74, 0x74, 0x69, 0x65, 0x00, 0x50,
+    0x61, 0x74, 0x74, 0x79, 0x00, 0x50, 0x61, 0x75, 0x6c, 0x00, 0x50, 0x61,
+    0x75, 0x6c, 0x61, 0x00, 0x50, 0x61, 0x75, 0x6c, 0x65, 0x6e, 0x65, 0x00,
+    0x50, 0x61, 0x75, 0x6c, 0x65, 0x74, 0x74, 0x61, 0x00, 0x50, 0x61, 0x75,
+    0x6c, 0x65, 0x74, 0x74, 0x65, 0x00, 0x50, 0x61, 0x75, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x50, 0x61, 0x75, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x50, 0x61,
+    0x75, 0x6c, 0x69, 0x74, 0x61, 0x00, 0x50, 0x61, 0x7a, 0x00, 0x50, 0x65,
+    0x61, 0x72, 0x6c, 0x00, 0x50, 0x65, 0x61, 0x72, 0x6c, 0x65, 0x00, 0x50,
+    0x65, 0x61, 0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x50, 0x65, 0x61, 0x72,
+    0x6c, 0x69, 0x65, 0x00, 0x50, 0x65, 0x61, 0x72, 0x6c, 0x69, 0x6e, 0x65,
+    0x00, 0x50, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x00, 0x50, 0x65, 0x64, 0x72,
+    0x6f, 0x00, 0x50, 0x65, 0x67, 0x00, 0x50, 0x65, 0x67, 0x67, 0x69, 0x65,
+    0x00, 0x50, 0x65, 0x67, 0x67, 0x79, 0x00, 0x50, 0x65, 0x69, 0x00, 0x50,
+    0x65, 0x6e, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x00, 0x50, 0x65, 0x6e, 0x6e,
+    0x65, 0x79, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x69, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x69, 0x65, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x79, 0x00, 0x50, 0x65,
+    0x72, 0x63, 0x79, 0x00, 0x50, 0x65, 0x72, 0x6c, 0x61, 0x00, 0x50, 0x65,
+    0x72, 0x72, 0x79, 0x00, 0x50, 0x65, 0x74, 0x65, 0x00, 0x50, 0x65, 0x74,
+    0x65, 0x72, 0x00, 0x50, 0x65, 0x74, 0x72, 0x61, 0x00, 0x50, 0x65, 0x74,
+    0x72, 0x69, 0x6e, 0x61, 0x00, 0x50, 0x65, 0x74, 0x72, 0x6f, 0x6e, 0x69,
+    0x6c, 0x61, 0x00, 0x50, 0x68, 0x65, 0x62, 0x65, 0x00, 0x50, 0x68, 0x69,
+    0x6c, 0x00, 0x50, 0x68, 0x69, 0x6c, 0x69, 0x70, 0x00, 0x50, 0x68, 0x69,
+    0x6c, 0x6c, 0x69, 0x70, 0x00, 0x50, 0x68, 0x69, 0x6c, 0x6c, 0x69, 0x73,
+    0x00, 0x50, 0x68, 0x69, 0x6c, 0x6f, 0x6d, 0x65, 0x6e, 0x61, 0x00, 0x50,
+    0x68, 0x6f, 0x65, 0x62, 0x65, 0x00, 0x50, 0x68, 0x75, 0x6e, 0x67, 0x00,
+    0x50, 0x68, 0x75, 0x6f, 0x6e, 0x67, 0x00, 0x50, 0x68, 0x79, 0x6c, 0x69,
+    0x63, 0x69, 0x61, 0x00, 0x50, 0x68, 0x79, 0x6c, 0x69, 0x73, 0x00, 0x50,
+    0x68, 0x79, 0x6c, 0x69, 0x73, 0x73, 0x00, 0x50, 0x68, 0x79, 0x6c, 0x6c,
+    0x69, 0x73, 0x00, 0x50, 0x69, 0x61, 0x00, 0x50, 0x69, 0x65, 0x64, 0x61,
+    0x64, 0x00, 0x50, 0x69, 0x65, 0x72, 0x72, 0x65, 0x00, 0x50, 0x69, 0x6c,
+    0x61, 0x72, 0x00, 0x50, 0x69, 0x6e, 0x67, 0x00, 0x50, 0x69, 0x6e, 0x6b,
+    0x69, 0x65, 0x00, 0x50, 0x69, 0x70, 0x65, 0x72, 0x00, 0x50, 0x6f, 0x6b,
+    0x00, 0x50, 0x6f, 0x6c, 0x6c, 0x79, 0x00, 0x50, 0x6f, 0x72, 0x66, 0x69,
+    0x72, 0x69, 0x6f, 0x00, 0x50, 0x6f, 0x72, 0x73, 0x63, 0x68, 0x65, 0x00,
+    0x50, 0x6f, 0x72, 0x73, 0x68, 0x61, 0x00, 0x50, 0x6f, 0x72, 0x74, 0x65,
+    0x72, 0x00, 0x50, 0x6f, 0x72, 0x74, 0x69, 0x61, 0x00, 0x50, 0x72, 0x65,
+    0x63, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x50, 0x72, 0x65, 0x73, 0x74, 0x6f,
+    0x6e, 0x00, 0x50, 0x72, 0x69, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x50,
+    0x72, 0x69, 0x6e, 0x63, 0x65, 0x00, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65,
+    0x73, 0x73, 0x00, 0x50, 0x72, 0x69, 0x73, 0x63, 0x69, 0x6c, 0x61, 0x00,
+    0x50, 0x72, 0x69, 0x73, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x50, 0x72,
+    0x6f, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x69, 0x61, 0x00, 0x50, 0x72,
+    0x75, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x50, 0x75, 0x72, 0x61, 0x00,
+    0x51, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x51, 0x75, 0x65, 0x65, 0x6e, 0x00,
+    0x51, 0x75, 0x65, 0x65, 0x6e, 0x69, 0x65, 0x00, 0x51, 0x75, 0x65, 0x6e,
+    0x74, 0x69, 0x6e, 0x00, 0x51, 0x75, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x51,
+    0x75, 0x69, 0x6e, 0x63, 0x79, 0x00, 0x51, 0x75, 0x69, 0x6e, 0x6e, 0x00,
+    0x51, 0x75, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x00, 0x51, 0x75, 0x69, 0x6e,
+    0x74, 0x6f, 0x6e, 0x00, 0x51, 0x75, 0x79, 0x65, 0x6e, 0x00, 0x52, 0x61,
+    0x63, 0x68, 0x61, 0x65, 0x6c, 0x00, 0x52, 0x61, 0x63, 0x68, 0x61, 0x6c,
+    0x00, 0x52, 0x61, 0x63, 0x68, 0x65, 0x61, 0x6c, 0x00, 0x52, 0x61, 0x63,
+    0x68, 0x65, 0x6c, 0x00, 0x52, 0x61, 0x63, 0x68, 0x65, 0x6c, 0x65, 0x00,
+    0x52, 0x61, 0x63, 0x68, 0x65, 0x6c, 0x6c, 0x00, 0x52, 0x61, 0x63, 0x68,
+    0x65, 0x6c, 0x6c, 0x65, 0x00, 0x52, 0x61, 0x63, 0x71, 0x75, 0x65, 0x6c,
+    0x00, 0x52, 0x61, 0x65, 0x00, 0x52, 0x61, 0x65, 0x61, 0x6e, 0x6e, 0x00,
+    0x52, 0x61, 0x65, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x52, 0x61, 0x66, 0x61,
+    0x65, 0x6c, 0x00, 0x52, 0x61, 0x66, 0x61, 0x65, 0x6c, 0x61, 0x00, 0x52,
+    0x61, 0x67, 0x75, 0x65, 0x6c, 0x00, 0x52, 0x61, 0x69, 0x6e, 0x61, 0x00,
+    0x52, 0x61, 0x69, 0x73, 0x61, 0x00, 0x52, 0x61, 0x6c, 0x65, 0x69, 0x67,
+    0x68, 0x00, 0x52, 0x61, 0x6c, 0x70, 0x68, 0x00, 0x52, 0x61, 0x6d, 0x69,
+    0x72, 0x6f, 0x00, 0x52, 0x61, 0x6d, 0x6f, 0x6e, 0x00, 0x52, 0x61, 0x6d,
+    0x6f, 0x6e, 0x61, 0x00, 0x52, 0x61, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x61,
+    0x00, 0x52, 0x61, 0x6e, 0x61, 0x00, 0x52, 0x61, 0x6e, 0x61, 0x65, 0x00,
+    0x52, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6c,
+    0x00, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x00, 0x52, 0x61, 0x6e,
+    0x64, 0x65, 0x65, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x65, 0x6c, 0x6c, 0x00,
+    0x52, 0x61, 0x6e, 0x64, 0x69, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6c,
+    0x70, 0x68, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x79, 0x00, 0x52, 0x61, 0x6e,
+    0x65, 0x65, 0x00, 0x52, 0x61, 0x70, 0x68, 0x61, 0x65, 0x6c, 0x00, 0x52,
+    0x61, 0x71, 0x75, 0x65, 0x6c, 0x00, 0x52, 0x61, 0x73, 0x68, 0x61, 0x64,
+    0x00, 0x52, 0x61, 0x73, 0x68, 0x65, 0x65, 0x64, 0x61, 0x00, 0x52, 0x61,
+    0x73, 0x68, 0x69, 0x64, 0x61, 0x00, 0x52, 0x61, 0x75, 0x6c, 0x00, 0x52,
+    0x61, 0x76, 0x65, 0x6e, 0x00, 0x52, 0x61, 0x79, 0x00, 0x52, 0x61, 0x79,
+    0x65, 0x00, 0x52, 0x61, 0x79, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x52, 0x61,
+    0x79, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x52, 0x61, 0x79, 0x6d, 0x6f, 0x6e,
+    0x00, 0x52, 0x61, 0x79, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x52, 0x61, 0x79,
+    0x6d, 0x6f, 0x6e, 0x64, 0x65, 0x00, 0x52, 0x61, 0x79, 0x6d, 0x75, 0x6e,
+    0x64, 0x6f, 0x00, 0x52, 0x61, 0x79, 0x6e, 0x61, 0x00, 0x52, 0x65, 0x61,
+    0x00, 0x52, 0x65, 0x61, 0x67, 0x61, 0x6e, 0x00, 0x52, 0x65, 0x61, 0x6e,
+    0x6e, 0x61, 0x00, 0x52, 0x65, 0x61, 0x74, 0x68, 0x61, 0x00, 0x52, 0x65,
+    0x62, 0x61, 0x00, 0x52, 0x65, 0x62, 0x62, 0x65, 0x63, 0x61, 0x00, 0x52,
+    0x65, 0x62, 0x62, 0x65, 0x63, 0x63, 0x61, 0x00, 0x52, 0x65, 0x62, 0x65,
+    0x63, 0x61, 0x00, 0x52, 0x65, 0x62, 0x65, 0x63, 0x63, 0x61, 0x00, 0x52,
+    0x65, 0x62, 0x65, 0x63, 0x6b, 0x61, 0x00, 0x52, 0x65, 0x62, 0x65, 0x6b,
+    0x61, 0x68, 0x00, 0x52, 0x65, 0x64, 0x61, 0x00, 0x52, 0x65, 0x65, 0x64,
+    0x00, 0x52, 0x65, 0x65, 0x6e, 0x61, 0x00, 0x52, 0x65, 0x66, 0x75, 0x67,
+    0x69, 0x61, 0x00, 0x52, 0x65, 0x66, 0x75, 0x67, 0x69, 0x6f, 0x00, 0x52,
+    0x65, 0x67, 0x61, 0x6e, 0x00, 0x52, 0x65, 0x67, 0x65, 0x6e, 0x61, 0x00,
+    0x52, 0x65, 0x67, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x52, 0x65, 0x67, 0x67,
+    0x69, 0x65, 0x00, 0x52, 0x65, 0x67, 0x69, 0x6e, 0x61, 0x00, 0x52, 0x65,
+    0x67, 0x69, 0x6e, 0x61, 0x6c, 0x64, 0x00, 0x52, 0x65, 0x67, 0x69, 0x6e,
+    0x65, 0x00, 0x52, 0x65, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x52, 0x65,
+    0x69, 0x64, 0x00, 0x52, 0x65, 0x69, 0x6b, 0x6f, 0x00, 0x52, 0x65, 0x69,
+    0x6e, 0x61, 0x00, 0x52, 0x65, 0x69, 0x6e, 0x61, 0x6c, 0x64, 0x6f, 0x00,
+    0x52, 0x65, 0x69, 0x74, 0x61, 0x00, 0x52, 0x65, 0x6d, 0x61, 0x00, 0x52,
+    0x65, 0x6d, 0x65, 0x64, 0x69, 0x6f, 0x73, 0x00, 0x52, 0x65, 0x6d, 0x6f,
+    0x6e, 0x61, 0x00, 0x52, 0x65, 0x6e, 0x61, 0x00, 0x52, 0x65, 0x6e, 0x61,
+    0x65, 0x00, 0x52, 0x65, 0x6e, 0x61, 0x6c, 0x64, 0x6f, 0x00, 0x52, 0x65,
+    0x6e, 0x61, 0x74, 0x61, 0x00, 0x52, 0x65, 0x6e, 0x61, 0x74, 0x65, 0x00,
+    0x52, 0x65, 0x6e, 0x61, 0x74, 0x6f, 0x00, 0x52, 0x65, 0x6e, 0x61, 0x79,
+    0x00, 0x52, 0x65, 0x6e, 0x64, 0x61, 0x00, 0x52, 0x65, 0x6e, 0x65, 0x00,
+    0x52, 0x65, 0x6e, 0x65, 0x61, 0x00, 0x52, 0x65, 0x6e, 0x65, 0x65, 0x00,
+    0x52, 0x65, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x52, 0x65, 0x6e, 0x69,
+    0x74, 0x61, 0x00, 0x52, 0x65, 0x6e, 0x6e, 0x61, 0x00, 0x52, 0x65, 0x73,
+    0x73, 0x69, 0x65, 0x00, 0x52, 0x65, 0x74, 0x61, 0x00, 0x52, 0x65, 0x74,
+    0x68, 0x61, 0x00, 0x52, 0x65, 0x74, 0x74, 0x61, 0x00, 0x52, 0x65, 0x75,
+    0x62, 0x65, 0x6e, 0x00, 0x52, 0x65, 0x76, 0x61, 0x00, 0x52, 0x65, 0x78,
+    0x00, 0x52, 0x65, 0x79, 0x00, 0x52, 0x65, 0x79, 0x65, 0x73, 0x00, 0x52,
+    0x65, 0x79, 0x6e, 0x61, 0x00, 0x52, 0x65, 0x79, 0x6e, 0x61, 0x6c, 0x64,
+    0x61, 0x00, 0x52, 0x65, 0x79, 0x6e, 0x61, 0x6c, 0x64, 0x6f, 0x00, 0x52,
+    0x68, 0x65, 0x61, 0x00, 0x52, 0x68, 0x65, 0x62, 0x61, 0x00, 0x52, 0x68,
+    0x65, 0x74, 0x74, 0x00, 0x52, 0x68, 0x69, 0x61, 0x6e, 0x6e, 0x6f, 0x6e,
+    0x00, 0x52, 0x68, 0x6f, 0x64, 0x61, 0x00, 0x52, 0x68, 0x6f, 0x6e, 0x61,
+    0x00, 0x52, 0x68, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x52, 0x69, 0x61, 0x00,
+    0x52, 0x69, 0x63, 0x61, 0x72, 0x64, 0x61, 0x00, 0x52, 0x69, 0x63, 0x61,
+    0x72, 0x64, 0x6f, 0x00, 0x52, 0x69, 0x63, 0x68, 0x00, 0x52, 0x69, 0x63,
+    0x68, 0x61, 0x72, 0x64, 0x00, 0x52, 0x69, 0x63, 0x68, 0x65, 0x6c, 0x6c,
+    0x65, 0x00, 0x52, 0x69, 0x63, 0x68, 0x69, 0x65, 0x00, 0x52, 0x69, 0x63,
+    0x6b, 0x00, 0x52, 0x69, 0x63, 0x6b, 0x65, 0x79, 0x00, 0x52, 0x69, 0x63,
+    0x6b, 0x69, 0x00, 0x52, 0x69, 0x63, 0x6b, 0x69, 0x65, 0x00, 0x52, 0x69,
+    0x63, 0x6b, 0x79, 0x00, 0x52, 0x69, 0x63, 0x6f, 0x00, 0x52, 0x69, 0x67,
+    0x6f, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x00, 0x52, 0x69, 0x6b, 0x6b, 0x69,
+    0x00, 0x52, 0x69, 0x6c, 0x65, 0x79, 0x00, 0x52, 0x69, 0x6d, 0x61, 0x00,
+    0x52, 0x69, 0x6e, 0x61, 0x00, 0x52, 0x69, 0x73, 0x61, 0x00, 0x52, 0x69,
+    0x74, 0x61, 0x00, 0x52, 0x69, 0x76, 0x61, 0x00, 0x52, 0x69, 0x76, 0x6b,
+    0x61, 0x00, 0x52, 0x6f, 0x62, 0x00, 0x52, 0x6f, 0x62, 0x62, 0x69, 0x00,
+    0x52, 0x6f, 0x62, 0x62, 0x69, 0x65, 0x00, 0x52, 0x6f, 0x62, 0x62, 0x69,
+    0x6e, 0x00, 0x52, 0x6f, 0x62, 0x62, 0x79, 0x00, 0x52, 0x6f, 0x62, 0x62,
+    0x79, 0x6e, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x6e, 0x61, 0x00, 0x52, 0x6f,
+    0x62, 0x65, 0x72, 0x74, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x61,
+    0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x00, 0x52, 0x6f, 0x62,
+    0x69, 0x6e, 0x00, 0x52, 0x6f, 0x62, 0x74, 0x00, 0x52, 0x6f, 0x62, 0x79,
+    0x6e, 0x00, 0x52, 0x6f, 0x63, 0x63, 0x6f, 0x00, 0x52, 0x6f, 0x63, 0x68,
+    0x65, 0x6c, 0x00, 0x52, 0x6f, 0x63, 0x68, 0x65, 0x6c, 0x6c, 0x00, 0x52,
+    0x6f, 0x63, 0x68, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x52, 0x6f, 0x63, 0x69,
+    0x6f, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x79, 0x00, 0x52, 0x6f, 0x64, 0x00,
+    0x52, 0x6f, 0x64, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x52, 0x6f, 0x64,
+    0x67, 0x65, 0x72, 0x00, 0x52, 0x6f, 0x64, 0x6e, 0x65, 0x79, 0x00, 0x52,
+    0x6f, 0x64, 0x6f, 0x6c, 0x66, 0x6f, 0x00, 0x52, 0x6f, 0x64, 0x72, 0x69,
+    0x63, 0x6b, 0x00, 0x52, 0x6f, 0x64, 0x72, 0x69, 0x67, 0x6f, 0x00, 0x52,
+    0x6f, 0x67, 0x65, 0x6c, 0x69, 0x6f, 0x00, 0x52, 0x6f, 0x67, 0x65, 0x72,
+    0x00, 0x52, 0x6f, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x52, 0x6f, 0x6c, 0x61,
+    0x6e, 0x64, 0x61, 0x00, 0x52, 0x6f, 0x6c, 0x61, 0x6e, 0x64, 0x65, 0x00,
+    0x52, 0x6f, 0x6c, 0x61, 0x6e, 0x64, 0x6f, 0x00, 0x52, 0x6f, 0x6c, 0x66,
+    0x00, 0x52, 0x6f, 0x6c, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x52, 0x6f, 0x6d,
+    0x61, 0x00, 0x52, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x52, 0x6f,
+    0x6d, 0x61, 0x6e, 0x00, 0x52, 0x6f, 0x6d, 0x61, 0x6e, 0x61, 0x00, 0x52,
+    0x6f, 0x6d, 0x65, 0x6c, 0x69, 0x61, 0x00, 0x52, 0x6f, 0x6d, 0x65, 0x6f,
+    0x00, 0x52, 0x6f, 0x6d, 0x6f, 0x6e, 0x61, 0x00, 0x52, 0x6f, 0x6e, 0x00,
+    0x52, 0x6f, 0x6e, 0x61, 0x00, 0x52, 0x6f, 0x6e, 0x61, 0x6c, 0x64, 0x00,
+    0x52, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x52, 0x6f, 0x6e, 0x69, 0x00, 0x52,
+    0x6f, 0x6e, 0x6e, 0x61, 0x00, 0x52, 0x6f, 0x6e, 0x6e, 0x69, 0x00, 0x52,
+    0x6f, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x52, 0x6f, 0x6e, 0x6e, 0x79, 0x00,
+    0x52, 0x6f, 0x6f, 0x73, 0x65, 0x76, 0x65, 0x6c, 0x74, 0x00, 0x52, 0x6f,
+    0x72, 0x79, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x61,
+    0x6c, 0x62, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x6c, 0x65, 0x65, 0x00,
+    0x52, 0x6f, 0x73, 0x61, 0x6c, 0x69, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x61,
+    0x6c, 0x69, 0x65, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x52, 0x6f, 0x73, 0x61, 0x6c, 0x69, 0x6e, 0x64, 0x00, 0x52, 0x6f,
+    0x73, 0x61, 0x6c, 0x69, 0x6e, 0x64, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x61,
+    0x6c, 0x69, 0x6e, 0x65, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x6c, 0x76, 0x61,
+    0x00, 0x52, 0x6f, 0x73, 0x61, 0x6c, 0x79, 0x6e, 0x00, 0x52, 0x6f, 0x73,
+    0x61, 0x6d, 0x61, 0x72, 0x69, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x6d,
+    0x6f, 0x6e, 0x64, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x6e, 0x61, 0x00, 0x52,
+    0x6f, 0x73, 0x61, 0x6e, 0x6e, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x6e, 0x6e,
+    0x61, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x52, 0x6f,
+    0x73, 0x61, 0x72, 0x69, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x72, 0x69,
+    0x6f, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x75, 0x72, 0x61, 0x00, 0x52, 0x6f,
+    0x73, 0x63, 0x6f, 0x65, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x00, 0x52, 0x6f,
+    0x73, 0x65, 0x61, 0x6e, 0x6e, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x61, 0x6e,
+    0x6e, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x61, 0x6e, 0x6e, 0x65, 0x00,
+    0x52, 0x6f, 0x73, 0x65, 0x6c, 0x65, 0x65, 0x00, 0x52, 0x6f, 0x73, 0x65,
+    0x6c, 0x69, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x6c, 0x69, 0x6e, 0x65,
+    0x00, 0x52, 0x6f, 0x73, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x52, 0x6f, 0x73,
+    0x65, 0x6c, 0x6c, 0x65, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x6c, 0x79, 0x6e,
+    0x00, 0x52, 0x6f, 0x73, 0x65, 0x6d, 0x61, 0x72, 0x69, 0x65, 0x00, 0x52,
+    0x6f, 0x73, 0x65, 0x6d, 0x61, 0x72, 0x79, 0x00, 0x52, 0x6f, 0x73, 0x65,
+    0x6e, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x6e, 0x64, 0x61, 0x00, 0x52,
+    0x6f, 0x73, 0x65, 0x6e, 0x64, 0x6f, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x74,
+    0x74, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x74, 0x74, 0x65, 0x00, 0x52,
+    0x6f, 0x73, 0x69, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x69, 0x65, 0x00, 0x52,
+    0x6f, 0x73, 0x69, 0x6e, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x69, 0x6f, 0x00,
+    0x52, 0x6f, 0x73, 0x69, 0x74, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x6c, 0x79,
+    0x6e, 0x00, 0x52, 0x6f, 0x73, 0x73, 0x00, 0x52, 0x6f, 0x73, 0x73, 0x61,
+    0x6e, 0x61, 0x00, 0x52, 0x6f, 0x73, 0x73, 0x69, 0x65, 0x00, 0x52, 0x6f,
+    0x73, 0x79, 0x00, 0x52, 0x6f, 0x77, 0x65, 0x6e, 0x61, 0x00, 0x52, 0x6f,
+    0x78, 0x61, 0x6e, 0x61, 0x00, 0x52, 0x6f, 0x78, 0x61, 0x6e, 0x65, 0x00,
+    0x52, 0x6f, 0x78, 0x61, 0x6e, 0x6e, 0x00, 0x52, 0x6f, 0x78, 0x61, 0x6e,
+    0x6e, 0x61, 0x00, 0x52, 0x6f, 0x78, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x52,
+    0x6f, 0x78, 0x69, 0x65, 0x00, 0x52, 0x6f, 0x78, 0x79, 0x00, 0x52, 0x6f,
+    0x79, 0x00, 0x52, 0x6f, 0x79, 0x61, 0x6c, 0x00, 0x52, 0x6f, 0x79, 0x63,
+    0x65, 0x00, 0x52, 0x6f, 0x7a, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x52, 0x6f,
+    0x7a, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x52, 0x75, 0x62, 0x65, 0x6e, 0x00,
+    0x52, 0x75, 0x62, 0x69, 0x00, 0x52, 0x75, 0x62, 0x69, 0x65, 0x00, 0x52,
+    0x75, 0x62, 0x69, 0x6e, 0x00, 0x52, 0x75, 0x62, 0x79, 0x00, 0x52, 0x75,
+    0x62, 0x79, 0x65, 0x00, 0x52, 0x75, 0x64, 0x6f, 0x6c, 0x66, 0x00, 0x52,
+    0x75, 0x64, 0x6f, 0x6c, 0x70, 0x68, 0x00, 0x52, 0x75, 0x64, 0x79, 0x00,
+    0x52, 0x75, 0x65, 0x62, 0x65, 0x6e, 0x00, 0x52, 0x75, 0x66, 0x69, 0x6e,
+    0x61, 0x00, 0x52, 0x75, 0x66, 0x75, 0x73, 0x00, 0x52, 0x75, 0x70, 0x65,
+    0x72, 0x74, 0x00, 0x52, 0x75, 0x73, 0x73, 0x00, 0x52, 0x75, 0x73, 0x73,
+    0x65, 0x6c, 0x00, 0x52, 0x75, 0x73, 0x73, 0x65, 0x6c, 0x6c, 0x00, 0x52,
+    0x75, 0x73, 0x74, 0x79, 0x00, 0x52, 0x75, 0x74, 0x68, 0x00, 0x52, 0x75,
+    0x74, 0x68, 0x61, 0x00, 0x52, 0x75, 0x74, 0x68, 0x61, 0x6e, 0x6e, 0x00,
+    0x52, 0x75, 0x74, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x52, 0x75, 0x74,
+    0x68, 0x65, 0x00, 0x52, 0x75, 0x74, 0x68, 0x69, 0x65, 0x00, 0x52, 0x79,
+    0x61, 0x6e, 0x00, 0x52, 0x79, 0x61, 0x6e, 0x6e, 0x00, 0x53, 0x61, 0x62,
+    0x69, 0x6e, 0x61, 0x00, 0x53, 0x61, 0x62, 0x69, 0x6e, 0x65, 0x00, 0x53,
+    0x61, 0x62, 0x72, 0x61, 0x00, 0x53, 0x61, 0x62, 0x72, 0x69, 0x6e, 0x61,
+    0x00, 0x53, 0x61, 0x63, 0x68, 0x61, 0x00, 0x53, 0x61, 0x63, 0x68, 0x69,
+    0x6b, 0x6f, 0x00, 0x53, 0x61, 0x64, 0x65, 0x00, 0x53, 0x61, 0x64, 0x69,
+    0x65, 0x00, 0x53, 0x61, 0x64, 0x79, 0x65, 0x00, 0x53, 0x61, 0x67, 0x65,
+    0x00, 0x53, 0x61, 0x6c, 0x00, 0x53, 0x61, 0x6c, 0x65, 0x6e, 0x61, 0x00,
+    0x53, 0x61, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x53, 0x61, 0x6c, 0x6c, 0x65,
+    0x79, 0x00, 0x53, 0x61, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x53, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x53, 0x61, 0x6c, 0x6f, 0x6d, 0x65, 0x00, 0x53, 0x61,
+    0x6c, 0x76, 0x61, 0x64, 0x6f, 0x72, 0x00, 0x53, 0x61, 0x6c, 0x76, 0x61,
+    0x74, 0x6f, 0x72, 0x65, 0x00, 0x53, 0x61, 0x6d, 0x00, 0x53, 0x61, 0x6d,
+    0x61, 0x6e, 0x74, 0x68, 0x61, 0x00, 0x53, 0x61, 0x6d, 0x61, 0x72, 0x61,
+    0x00, 0x53, 0x61, 0x6d, 0x61, 0x74, 0x68, 0x61, 0x00, 0x53, 0x61, 0x6d,
+    0x65, 0x6c, 0x6c, 0x61, 0x00, 0x53, 0x61, 0x6d, 0x69, 0x72, 0x61, 0x00,
+    0x53, 0x61, 0x6d, 0x6d, 0x69, 0x65, 0x00, 0x53, 0x61, 0x6d, 0x6d, 0x79,
+    0x00, 0x53, 0x61, 0x6d, 0x75, 0x61, 0x6c, 0x00, 0x53, 0x61, 0x6d, 0x75,
+    0x65, 0x6c, 0x00, 0x53, 0x61, 0x6e, 0x61, 0x00, 0x53, 0x61, 0x6e, 0x64,
+    0x61, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x65, 0x65, 0x00, 0x53, 0x61, 0x6e,
+    0x64, 0x69, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x69, 0x65, 0x00, 0x53, 0x61,
+    0x6e, 0x64, 0x72, 0x61, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x79, 0x00, 0x53,
+    0x61, 0x6e, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x53, 0x61, 0x6e, 0x67, 0x00,
+    0x53, 0x61, 0x6e, 0x6a, 0x75, 0x61, 0x6e, 0x61, 0x00, 0x53, 0x61, 0x6e,
+    0x6a, 0x75, 0x61, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x53, 0x61, 0x6e, 0x6f,
+    0x72, 0x61, 0x00, 0x53, 0x61, 0x6e, 0x74, 0x61, 0x00, 0x53, 0x61, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x53, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x67,
+    0x6f, 0x00, 0x53, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x53, 0x61,
+    0x6e, 0x74, 0x6f, 0x00, 0x53, 0x61, 0x6e, 0x74, 0x6f, 0x73, 0x00, 0x53,
+    0x61, 0x72, 0x61, 0x00, 0x53, 0x61, 0x72, 0x61, 0x68, 0x00, 0x53, 0x61,
+    0x72, 0x61, 0x69, 0x00, 0x53, 0x61, 0x72, 0x61, 0x6e, 0x00, 0x53, 0x61,
+    0x72, 0x69, 0x00, 0x53, 0x61, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x53, 0x61,
+    0x72, 0x69, 0x74, 0x61, 0x00, 0x53, 0x61, 0x73, 0x68, 0x61, 0x00, 0x53,
+    0x61, 0x74, 0x75, 0x72, 0x6e, 0x69, 0x6e, 0x61, 0x00, 0x53, 0x61, 0x75,
+    0x00, 0x53, 0x61, 0x75, 0x6c, 0x00, 0x53, 0x61, 0x75, 0x6e, 0x64, 0x72,
+    0x61, 0x00, 0x53, 0x61, 0x76, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x53, 0x61,
+    0x76, 0x61, 0x6e, 0x6e, 0x61, 0x68, 0x00, 0x53, 0x63, 0x61, 0x72, 0x6c,
+    0x65, 0x74, 0x00, 0x53, 0x63, 0x61, 0x72, 0x6c, 0x65, 0x74, 0x74, 0x00,
+    0x53, 0x63, 0x6f, 0x74, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x00, 0x53,
+    0x63, 0x6f, 0x74, 0x74, 0x69, 0x65, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74,
+    0x79, 0x00, 0x53, 0x65, 0x61, 0x6e, 0x00, 0x53, 0x65, 0x61, 0x73, 0x6f,
+    0x6e, 0x00, 0x53, 0x65, 0x62, 0x61, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x00,
+    0x53, 0x65, 0x62, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x53, 0x65, 0x65, 0x00,
+    0x53, 0x65, 0x65, 0x6d, 0x61, 0x00, 0x53, 0x65, 0x6c, 0x65, 0x6e, 0x61,
+    0x00, 0x53, 0x65, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x53, 0x65, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x53, 0x65, 0x6c, 0x6d, 0x61, 0x00, 0x53, 0x65, 0x6e,
+    0x61, 0x00, 0x53, 0x65, 0x6e, 0x61, 0x69, 0x64, 0x61, 0x00, 0x53, 0x65,
+    0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x53, 0x65, 0x72, 0x61,
+    0x66, 0x69, 0x6e, 0x61, 0x00, 0x53, 0x65, 0x72, 0x65, 0x6e, 0x61, 0x00,
+    0x53, 0x65, 0x72, 0x67, 0x69, 0x6f, 0x00, 0x53, 0x65, 0x72, 0x69, 0x6e,
+    0x61, 0x00, 0x53, 0x65, 0x72, 0x69, 0x74, 0x61, 0x00, 0x53, 0x65, 0x74,
+    0x68, 0x00, 0x53, 0x65, 0x74, 0x73, 0x75, 0x6b, 0x6f, 0x00, 0x53, 0x65,
+    0x79, 0x6d, 0x6f, 0x75, 0x72, 0x00, 0x53, 0x68, 0x61, 0x00, 0x53, 0x68,
+    0x61, 0x64, 0x00, 0x53, 0x68, 0x61, 0x65, 0x00, 0x53, 0x68, 0x61, 0x69,
+    0x6e, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6b, 0x69, 0x61, 0x00, 0x53, 0x68,
+    0x61, 0x6b, 0x69, 0x72, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6b, 0x69, 0x74,
+    0x61, 0x00, 0x53, 0x68, 0x61, 0x6c, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6c,
+    0x61, 0x6e, 0x64, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6c, 0x6f, 0x6e, 0x00,
+    0x53, 0x68, 0x61, 0x6c, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x53, 0x68, 0x61,
+    0x6d, 0x65, 0x6b, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6d, 0x69, 0x6b, 0x61,
+    0x00, 0x53, 0x68, 0x61, 0x6e, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x61, 0x00,
+    0x53, 0x68, 0x61, 0x6e, 0x61, 0x65, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x64,
+    0x61, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x64, 0x69, 0x00, 0x53, 0x68, 0x61,
+    0x6e, 0x64, 0x72, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x65, 0x00, 0x53,
+    0x68, 0x61, 0x6e, 0x65, 0x6b, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x65,
+    0x6c, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x53, 0x68,
+    0x61, 0x6e, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x69,
+    0x00, 0x53, 0x68, 0x61, 0x6e, 0x69, 0x63, 0x65, 0x00, 0x53, 0x68, 0x61,
+    0x6e, 0x69, 0x6b, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x69, 0x71, 0x75,
+    0x61, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x53, 0x68,
+    0x61, 0x6e, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x6e, 0x61, 0x6e,
+    0x00, 0x53, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x61,
+    0x6e, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x74, 0x61, 0x00, 0x53,
+    0x68, 0x61, 0x6e, 0x74, 0x61, 0x65, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x74,
+    0x61, 0x79, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x74, 0x65, 0x00, 0x53, 0x68,
+    0x61, 0x6e, 0x74, 0x65, 0x6c, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x74, 0x65,
+    0x6c, 0x6c, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x74, 0x65, 0x6c, 0x6c, 0x65,
+    0x00, 0x53, 0x68, 0x61, 0x6e, 0x74, 0x69, 0x00, 0x53, 0x68, 0x61, 0x71,
+    0x75, 0x61, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x61, 0x71, 0x75, 0x69, 0x74,
+    0x61, 0x00, 0x53, 0x68, 0x61, 0x72, 0x61, 0x00, 0x53, 0x68, 0x61, 0x72,
+    0x61, 0x6e, 0x00, 0x53, 0x68, 0x61, 0x72, 0x64, 0x61, 0x00, 0x53, 0x68,
+    0x61, 0x72, 0x65, 0x65, 0x00, 0x53, 0x68, 0x61, 0x72, 0x65, 0x6c, 0x6c,
+    0x00, 0x53, 0x68, 0x61, 0x72, 0x65, 0x6e, 0x00, 0x53, 0x68, 0x61, 0x72,
+    0x69, 0x00, 0x53, 0x68, 0x61, 0x72, 0x69, 0x63, 0x65, 0x00, 0x53, 0x68,
+    0x61, 0x72, 0x69, 0x65, 0x00, 0x53, 0x68, 0x61, 0x72, 0x69, 0x6b, 0x61,
+    0x00, 0x53, 0x68, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x6e, 0x00, 0x53, 0x68,
+    0x61, 0x72, 0x69, 0x74, 0x61, 0x00, 0x53, 0x68, 0x61, 0x72, 0x6c, 0x61,
+    0x00, 0x53, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x65, 0x6e, 0x00, 0x53, 0x68,
+    0x61, 0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x53, 0x68, 0x61, 0x72, 0x6d,
+    0x61, 0x69, 0x6e, 0x65, 0x00, 0x53, 0x68, 0x61, 0x72, 0x6f, 0x6c, 0x79,
+    0x6e, 0x00, 0x53, 0x68, 0x61, 0x72, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x61,
+    0x72, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x53, 0x68, 0x61, 0x72, 0x72, 0x69,
+    0x00, 0x53, 0x68, 0x61, 0x72, 0x72, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x61,
+    0x72, 0x79, 0x6c, 0x00, 0x53, 0x68, 0x61, 0x72, 0x79, 0x6e, 0x00, 0x53,
+    0x68, 0x61, 0x73, 0x74, 0x61, 0x00, 0x53, 0x68, 0x61, 0x75, 0x6e, 0x00,
+    0x53, 0x68, 0x61, 0x75, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x61, 0x75, 0x6e,
+    0x64, 0x61, 0x00, 0x53, 0x68, 0x61, 0x75, 0x6e, 0x6e, 0x61, 0x00, 0x53,
+    0x68, 0x61, 0x75, 0x6e, 0x74, 0x61, 0x00, 0x53, 0x68, 0x61, 0x75, 0x6e,
+    0x74, 0x65, 0x00, 0x53, 0x68, 0x61, 0x76, 0x6f, 0x6e, 0x00, 0x53, 0x68,
+    0x61, 0x76, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x53, 0x68, 0x61, 0x76, 0x6f,
+    0x6e, 0x6e, 0x65, 0x00, 0x53, 0x68, 0x61, 0x77, 0x61, 0x6e, 0x61, 0x00,
+    0x53, 0x68, 0x61, 0x77, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x53, 0x68, 0x61,
+    0x77, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x61, 0x77, 0x6e, 0x00,
+    0x53, 0x68, 0x61, 0x77, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x61, 0x77, 0x6e,
+    0x64, 0x61, 0x00, 0x53, 0x68, 0x61, 0x77, 0x6e, 0x65, 0x65, 0x00, 0x53,
+    0x68, 0x61, 0x77, 0x6e, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x61, 0x77, 0x6e,
+    0x74, 0x61, 0x00, 0x53, 0x68, 0x61, 0x79, 0x00, 0x53, 0x68, 0x61, 0x79,
+    0x6c, 0x61, 0x00, 0x53, 0x68, 0x61, 0x79, 0x6e, 0x61, 0x00, 0x53, 0x68,
+    0x61, 0x79, 0x6e, 0x65, 0x00, 0x53, 0x68, 0x65, 0x61, 0x00, 0x53, 0x68,
+    0x65, 0x62, 0x61, 0x00, 0x53, 0x68, 0x65, 0x65, 0x6e, 0x61, 0x00, 0x53,
+    0x68, 0x65, 0x69, 0x6c, 0x61, 0x00, 0x53, 0x68, 0x65, 0x69, 0x6c, 0x61,
+    0x68, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x61, 0x00, 0x53, 0x68, 0x65, 0x6c,
+    0x62, 0x61, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x62, 0x79, 0x00, 0x53, 0x68,
+    0x65, 0x6c, 0x64, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x69, 0x61,
+    0x00, 0x53, 0x68, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x53, 0x68, 0x65, 0x6c,
+    0x6c, 0x65, 0x79, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x6c, 0x69, 0x00, 0x53,
+    0x68, 0x65, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x6c,
+    0x79, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x68,
+    0x65, 0x6d, 0x65, 0x6b, 0x61, 0x00, 0x53, 0x68, 0x65, 0x6d, 0x69, 0x6b,
+    0x61, 0x00, 0x53, 0x68, 0x65, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x65, 0x6e,
+    0x69, 0x6b, 0x61, 0x00, 0x53, 0x68, 0x65, 0x6e, 0x69, 0x74, 0x61, 0x00,
+    0x53, 0x68, 0x65, 0x6e, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x65, 0x72, 0x61,
+    0x00, 0x53, 0x68, 0x65, 0x72, 0x65, 0x65, 0x00, 0x53, 0x68, 0x65, 0x72,
+    0x65, 0x6c, 0x6c, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x69, 0x63, 0x65, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x64,
+    0x61, 0x6e, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x65, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x69, 0x6b, 0x61, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x6c,
+    0x6c, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x6c, 0x79, 0x6e, 0x00, 0x53,
+    0x68, 0x65, 0x72, 0x69, 0x73, 0x65, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69,
+    0x74, 0x61, 0x00, 0x53, 0x68, 0x65, 0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00,
+    0x53, 0x68, 0x65, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x68, 0x65, 0x72,
+    0x6c, 0x79, 0x00, 0x53, 0x68, 0x65, 0x72, 0x6c, 0x79, 0x6e, 0x00, 0x53,
+    0x68, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x68, 0x65, 0x72, 0x6f,
+    0x6e, 0x00, 0x53, 0x68, 0x65, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x53,
+    0x68, 0x65, 0x72, 0x72, 0x69, 0x00, 0x53, 0x68, 0x65, 0x72, 0x72, 0x69,
+    0x65, 0x00, 0x53, 0x68, 0x65, 0x72, 0x72, 0x69, 0x6c, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x72, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x68, 0x65, 0x72, 0x72,
+    0x6f, 0x6e, 0x00, 0x53, 0x68, 0x65, 0x72, 0x72, 0x79, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x72, 0x79, 0x6c, 0x00, 0x53, 0x68, 0x65, 0x72, 0x77, 0x6f,
+    0x6f, 0x64, 0x00, 0x53, 0x68, 0x65, 0x72, 0x79, 0x00, 0x53, 0x68, 0x65,
+    0x72, 0x79, 0x6c, 0x00, 0x53, 0x68, 0x65, 0x72, 0x79, 0x6c, 0x6c, 0x00,
+    0x53, 0x68, 0x69, 0x65, 0x6c, 0x61, 0x00, 0x53, 0x68, 0x69, 0x6c, 0x61,
+    0x00, 0x53, 0x68, 0x69, 0x6c, 0x6f, 0x68, 0x00, 0x53, 0x68, 0x69, 0x6e,
+    0x00, 0x53, 0x68, 0x69, 0x72, 0x61, 0x00, 0x53, 0x68, 0x69, 0x72, 0x65,
+    0x6c, 0x79, 0x00, 0x53, 0x68, 0x69, 0x72, 0x6c, 0x00, 0x53, 0x68, 0x69,
+    0x72, 0x6c, 0x65, 0x65, 0x00, 0x53, 0x68, 0x69, 0x72, 0x6c, 0x65, 0x65,
+    0x6e, 0x00, 0x53, 0x68, 0x69, 0x72, 0x6c, 0x65, 0x6e, 0x65, 0x00, 0x53,
+    0x68, 0x69, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x68, 0x69, 0x72, 0x6c,
+    0x79, 0x00, 0x53, 0x68, 0x69, 0x7a, 0x75, 0x65, 0x00, 0x53, 0x68, 0x69,
+    0x7a, 0x75, 0x6b, 0x6f, 0x00, 0x53, 0x68, 0x6f, 0x6e, 0x00, 0x53, 0x68,
+    0x6f, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x53,
+    0x68, 0x6f, 0x6e, 0x64, 0x72, 0x61, 0x00, 0x53, 0x68, 0x6f, 0x6e, 0x6e,
+    0x61, 0x00, 0x53, 0x68, 0x6f, 0x6e, 0x74, 0x61, 0x00, 0x53, 0x68, 0x6f,
+    0x73, 0x68, 0x61, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x75, 0x00, 0x53, 0x68,
+    0x79, 0x6c, 0x61, 0x00, 0x53, 0x69, 0x62, 0x79, 0x6c, 0x00, 0x53, 0x69,
+    0x64, 0x00, 0x53, 0x69, 0x64, 0x6e, 0x65, 0x79, 0x00, 0x53, 0x69, 0x65,
+    0x72, 0x72, 0x61, 0x00, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x00, 0x53, 0x69,
+    0x67, 0x72, 0x69, 0x64, 0x00, 0x53, 0x69, 0x6c, 0x61, 0x73, 0x00, 0x53,
+    0x69, 0x6c, 0x76, 0x61, 0x00, 0x53, 0x69, 0x6c, 0x76, 0x61, 0x6e, 0x61,
+    0x00, 0x53, 0x69, 0x6c, 0x76, 0x69, 0x61, 0x00, 0x53, 0x69, 0x6d, 0x61,
+    0x00, 0x53, 0x69, 0x6d, 0x6f, 0x6e, 0x00, 0x53, 0x69, 0x6d, 0x6f, 0x6e,
+    0x61, 0x00, 0x53, 0x69, 0x6d, 0x6f, 0x6e, 0x65, 0x00, 0x53, 0x69, 0x6d,
+    0x6f, 0x6e, 0x6e, 0x65, 0x00, 0x53, 0x69, 0x6e, 0x61, 0x00, 0x53, 0x69,
+    0x6e, 0x64, 0x79, 0x00, 0x53, 0x69, 0x6f, 0x62, 0x68, 0x61, 0x6e, 0x00,
+    0x53, 0x69, 0x72, 0x65, 0x6e, 0x61, 0x00, 0x53, 0x69, 0x75, 0x00, 0x53,
+    0x69, 0x78, 0x74, 0x61, 0x00, 0x53, 0x6b, 0x79, 0x65, 0x00, 0x53, 0x6c,
+    0x79, 0x76, 0x69, 0x61, 0x00, 0x53, 0x6f, 0x00, 0x53, 0x6f, 0x63, 0x6f,
+    0x72, 0x72, 0x6f, 0x00, 0x53, 0x6f, 0x66, 0x69, 0x61, 0x00, 0x53, 0x6f,
+    0x69, 0x6c, 0x61, 0x00, 0x53, 0x6f, 0x6c, 0x00, 0x53, 0x6f, 0x6c, 0x61,
+    0x6e, 0x67, 0x65, 0x00, 0x53, 0x6f, 0x6c, 0x65, 0x64, 0x61, 0x64, 0x00,
+    0x53, 0x6f, 0x6c, 0x6f, 0x6d, 0x6f, 0x6e, 0x00, 0x53, 0x6f, 0x6d, 0x65,
+    0x72, 0x00, 0x53, 0x6f, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x53, 0x6f, 0x6e,
+    0x00, 0x53, 0x6f, 0x6e, 0x61, 0x00, 0x53, 0x6f, 0x6e, 0x64, 0x72, 0x61,
+    0x00, 0x53, 0x6f, 0x6e, 0x67, 0x00, 0x53, 0x6f, 0x6e, 0x69, 0x61, 0x00,
+    0x53, 0x6f, 0x6e, 0x6a, 0x61, 0x00, 0x53, 0x6f, 0x6e, 0x6e, 0x79, 0x00,
+    0x53, 0x6f, 0x6e, 0x79, 0x61, 0x00, 0x53, 0x6f, 0x6f, 0x00, 0x53, 0x6f,
+    0x6f, 0x6b, 0x00, 0x53, 0x6f, 0x6f, 0x6e, 0x00, 0x53, 0x6f, 0x70, 0x68,
+    0x69, 0x61, 0x00, 0x53, 0x6f, 0x70, 0x68, 0x69, 0x65, 0x00, 0x53, 0x6f,
+    0x72, 0x61, 0x79, 0x61, 0x00, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x6c, 0x65,
+    0x00, 0x53, 0x70, 0x65, 0x6e, 0x63, 0x65, 0x72, 0x00, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x00, 0x53, 0x74, 0x61, 0x63, 0x65, 0x65, 0x00, 0x53,
+    0x74, 0x61, 0x63, 0x65, 0x79, 0x00, 0x53, 0x74, 0x61, 0x63, 0x69, 0x00,
+    0x53, 0x74, 0x61, 0x63, 0x69, 0x61, 0x00, 0x53, 0x74, 0x61, 0x63, 0x69,
+    0x65, 0x00, 0x53, 0x74, 0x61, 0x63, 0x79, 0x00, 0x53, 0x74, 0x61, 0x6e,
+    0x00, 0x53, 0x74, 0x61, 0x6e, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x53, 0x74,
+    0x61, 0x6e, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x74, 0x61, 0x6e, 0x74, 0x6f,
+    0x6e, 0x00, 0x53, 0x74, 0x61, 0x72, 0x00, 0x53, 0x74, 0x61, 0x72, 0x6c,
+    0x61, 0x00, 0x53, 0x74, 0x61, 0x72, 0x72, 0x00, 0x53, 0x74, 0x61, 0x73,
+    0x69, 0x61, 0x00, 0x53, 0x74, 0x65, 0x66, 0x61, 0x6e, 0x00, 0x53, 0x74,
+    0x65, 0x66, 0x61, 0x6e, 0x69, 0x00, 0x53, 0x74, 0x65, 0x66, 0x61, 0x6e,
+    0x69, 0x61, 0x00, 0x53, 0x74, 0x65, 0x66, 0x61, 0x6e, 0x69, 0x65, 0x00,
+    0x53, 0x74, 0x65, 0x66, 0x61, 0x6e, 0x79, 0x00, 0x53, 0x74, 0x65, 0x66,
+    0x66, 0x61, 0x6e, 0x69, 0x65, 0x00, 0x53, 0x74, 0x65, 0x6c, 0x6c, 0x61,
+    0x00, 0x53, 0x74, 0x65, 0x70, 0x61, 0x6e, 0x69, 0x65, 0x00, 0x53, 0x74,
+    0x65, 0x70, 0x68, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x53, 0x74, 0x65, 0x70,
+    0x68, 0x61, 0x6e, 0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x61, 0x6e, 0x65,
+    0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x61, 0x6e, 0x69, 0x00, 0x53, 0x74,
+    0x65, 0x70, 0x68, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x53, 0x74, 0x65, 0x70,
+    0x68, 0x61, 0x6e, 0x69, 0x65, 0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x61,
+    0x6e, 0x79, 0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x65, 0x6e, 0x00, 0x53,
+    0x74, 0x65, 0x70, 0x68, 0x65, 0x6e, 0x69, 0x65, 0x00, 0x53, 0x74, 0x65,
+    0x70, 0x68, 0x69, 0x6e, 0x65, 0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x6e,
+    0x69, 0x65, 0x00, 0x53, 0x74, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x67, 0x00,
+    0x53, 0x74, 0x65, 0x76, 0x65, 0x00, 0x53, 0x74, 0x65, 0x76, 0x65, 0x6e,
+    0x00, 0x53, 0x74, 0x65, 0x76, 0x69, 0x65, 0x00, 0x53, 0x74, 0x65, 0x77,
+    0x61, 0x72, 0x74, 0x00, 0x53, 0x74, 0x6f, 0x72, 0x6d, 0x79, 0x00, 0x53,
+    0x74, 0x75, 0x61, 0x72, 0x74, 0x00, 0x53, 0x75, 0x00, 0x53, 0x75, 0x61,
+    0x6e, 0x6e, 0x65, 0x00, 0x53, 0x75, 0x64, 0x69, 0x65, 0x00, 0x53, 0x75,
+    0x65, 0x00, 0x53, 0x75, 0x65, 0x61, 0x6e, 0x6e, 0x00, 0x53, 0x75, 0x65,
+    0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x53, 0x75, 0x6b, 0x00, 0x53, 0x75, 0x6c,
+    0x65, 0x6d, 0x61, 0x00, 0x53, 0x75, 0x6d, 0x69, 0x6b, 0x6f, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x53, 0x75, 0x6e, 0x00, 0x53, 0x75,
+    0x6e, 0x64, 0x61, 0x79, 0x00, 0x53, 0x75, 0x6e, 0x67, 0x00, 0x53, 0x75,
+    0x6e, 0x6e, 0x69, 0x00, 0x53, 0x75, 0x6e, 0x6e, 0x79, 0x00, 0x53, 0x75,
+    0x6e, 0x73, 0x68, 0x69, 0x6e, 0x65, 0x00, 0x53, 0x75, 0x73, 0x61, 0x6e,
+    0x00, 0x53, 0x75, 0x73, 0x61, 0x6e, 0x61, 0x00, 0x53, 0x75, 0x73, 0x61,
+    0x6e, 0x6e, 0x00, 0x53, 0x75, 0x73, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x53,
+    0x75, 0x73, 0x61, 0x6e, 0x6e, 0x61, 0x68, 0x00, 0x53, 0x75, 0x73, 0x61,
+    0x6e, 0x6e, 0x65, 0x00, 0x53, 0x75, 0x73, 0x69, 0x65, 0x00, 0x53, 0x75,
+    0x73, 0x79, 0x00, 0x53, 0x75, 0x7a, 0x61, 0x6e, 0x00, 0x53, 0x75, 0x7a,
+    0x61, 0x6e, 0x6e, 0x00, 0x53, 0x75, 0x7a, 0x61, 0x6e, 0x6e, 0x61, 0x00,
+    0x53, 0x75, 0x7a, 0x61, 0x6e, 0x6e, 0x65, 0x00, 0x53, 0x75, 0x7a, 0x65,
+    0x74, 0x74, 0x65, 0x00, 0x53, 0x75, 0x7a, 0x69, 0x00, 0x53, 0x75, 0x7a,
+    0x69, 0x65, 0x00, 0x53, 0x75, 0x7a, 0x79, 0x00, 0x53, 0x76, 0x65, 0x74,
+    0x6c, 0x61, 0x6e, 0x61, 0x00, 0x53, 0x79, 0x62, 0x69, 0x6c, 0x00, 0x53,
+    0x79, 0x62, 0x6c, 0x65, 0x00, 0x53, 0x79, 0x64, 0x6e, 0x65, 0x79, 0x00,
+    0x53, 0x79, 0x6c, 0x76, 0x65, 0x73, 0x74, 0x65, 0x72, 0x00, 0x53, 0x79,
+    0x6c, 0x76, 0x69, 0x61, 0x00, 0x53, 0x79, 0x6c, 0x76, 0x69, 0x65, 0x00,
+    0x53, 0x79, 0x6e, 0x74, 0x68, 0x69, 0x61, 0x00, 0x53, 0x79, 0x72, 0x65,
+    0x65, 0x74, 0x61, 0x00, 0x54, 0x61, 0x00, 0x54, 0x61, 0x62, 0x61, 0x74,
+    0x68, 0x61, 0x00, 0x54, 0x61, 0x62, 0x65, 0x74, 0x68, 0x61, 0x00, 0x54,
+    0x61, 0x62, 0x69, 0x74, 0x68, 0x61, 0x00, 0x54, 0x61, 0x64, 0x00, 0x54,
+    0x61, 0x69, 0x00, 0x54, 0x61, 0x69, 0x6e, 0x61, 0x00, 0x54, 0x61, 0x69,
+    0x73, 0x68, 0x61, 0x00, 0x54, 0x61, 0x6a, 0x75, 0x61, 0x6e, 0x61, 0x00,
+    0x54, 0x61, 0x6b, 0x61, 0x6b, 0x6f, 0x00, 0x54, 0x61, 0x6b, 0x69, 0x73,
+    0x68, 0x61, 0x00, 0x54, 0x61, 0x6c, 0x69, 0x61, 0x00, 0x54, 0x61, 0x6c,
+    0x69, 0x73, 0x68, 0x61, 0x00, 0x54, 0x61, 0x6c, 0x69, 0x74, 0x68, 0x61,
+    0x00, 0x54, 0x61, 0x6d, 0x00, 0x54, 0x61, 0x6d, 0x61, 0x00, 0x54, 0x61,
+    0x6d, 0x61, 0x6c, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x61, 0x72, 0x00, 0x54,
+    0x61, 0x6d, 0x61, 0x72, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x61, 0x74, 0x68,
+    0x61, 0x00, 0x54, 0x61, 0x6d, 0x62, 0x72, 0x61, 0x00, 0x54, 0x61, 0x6d,
+    0x65, 0x69, 0x6b, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x65, 0x6b, 0x61, 0x00,
+    0x54, 0x61, 0x6d, 0x65, 0x6b, 0x69, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x65,
+    0x6c, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x00, 0x54, 0x61,
+    0x6d, 0x65, 0x73, 0x68, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x69, 0x00, 0x54,
+    0x61, 0x6d, 0x69, 0x63, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x69, 0x65, 0x00,
+    0x54, 0x61, 0x6d, 0x69, 0x6b, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x69, 0x6b,
+    0x6f, 0x00, 0x54, 0x61, 0x6d, 0x69, 0x73, 0x68, 0x61, 0x00, 0x54, 0x61,
+    0x6d, 0x6d, 0x61, 0x72, 0x61, 0x00, 0x54, 0x61, 0x6d, 0x6d, 0x65, 0x72,
+    0x61, 0x00, 0x54, 0x61, 0x6d, 0x6d, 0x69, 0x00, 0x54, 0x61, 0x6d, 0x6d,
+    0x69, 0x65, 0x00, 0x54, 0x61, 0x6d, 0x6d, 0x79, 0x00, 0x54, 0x61, 0x6d,
+    0x72, 0x61, 0x00, 0x54, 0x61, 0x6e, 0x61, 0x00, 0x54, 0x61, 0x6e, 0x64,
+    0x72, 0x61, 0x00, 0x54, 0x61, 0x6e, 0x64, 0x79, 0x00, 0x54, 0x61, 0x6e,
+    0x65, 0x6b, 0x61, 0x00, 0x54, 0x61, 0x6e, 0x65, 0x73, 0x68, 0x61, 0x00,
+    0x54, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x61, 0x00, 0x54, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x54, 0x61, 0x6e, 0x69, 0x6b, 0x61, 0x00, 0x54, 0x61, 0x6e,
+    0x69, 0x73, 0x68, 0x61, 0x00, 0x54, 0x61, 0x6e, 0x6a, 0x61, 0x00, 0x54,
+    0x61, 0x6e, 0x6e, 0x61, 0x00, 0x54, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x00,
+    0x54, 0x61, 0x6e, 0x79, 0x61, 0x00, 0x54, 0x61, 0x72, 0x61, 0x00, 0x54,
+    0x61, 0x72, 0x61, 0x68, 0x00, 0x54, 0x61, 0x72, 0x65, 0x6e, 0x00, 0x54,
+    0x61, 0x72, 0x69, 0x00, 0x54, 0x61, 0x72, 0x72, 0x61, 0x00, 0x54, 0x61,
+    0x72, 0x73, 0x68, 0x61, 0x00, 0x54, 0x61, 0x72, 0x79, 0x6e, 0x00, 0x54,
+    0x61, 0x73, 0x68, 0x61, 0x00, 0x54, 0x61, 0x73, 0x68, 0x69, 0x61, 0x00,
+    0x54, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x61, 0x00, 0x54, 0x61, 0x73, 0x69,
+    0x61, 0x00, 0x54, 0x61, 0x74, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x54, 0x61,
+    0x74, 0x75, 0x6d, 0x00, 0x54, 0x61, 0x74, 0x79, 0x61, 0x6e, 0x61, 0x00,
+    0x54, 0x61, 0x75, 0x6e, 0x79, 0x61, 0x00, 0x54, 0x61, 0x77, 0x61, 0x6e,
+    0x61, 0x00, 0x54, 0x61, 0x77, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x54, 0x61,
+    0x77, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x54, 0x61, 0x77, 0x6e, 0x61, 0x00,
+    0x54, 0x61, 0x77, 0x6e, 0x79, 0x00, 0x54, 0x61, 0x77, 0x6e, 0x79, 0x61,
+    0x00, 0x54, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x00, 0x54, 0x61, 0x79, 0x6e,
+    0x61, 0x00, 0x54, 0x65, 0x64, 0x00, 0x54, 0x65, 0x64, 0x64, 0x79, 0x00,
+    0x54, 0x65, 0x65, 0x6e, 0x61, 0x00, 0x54, 0x65, 0x67, 0x61, 0x6e, 0x00,
+    0x54, 0x65, 0x69, 0x73, 0x68, 0x61, 0x00, 0x54, 0x65, 0x6c, 0x6d, 0x61,
+    0x00, 0x54, 0x65, 0x6d, 0x65, 0x6b, 0x61, 0x00, 0x54, 0x65, 0x6d, 0x69,
+    0x6b, 0x61, 0x00, 0x54, 0x65, 0x6d, 0x70, 0x69, 0x65, 0x00, 0x54, 0x65,
+    0x6d, 0x70, 0x6c, 0x65, 0x00, 0x54, 0x65, 0x6e, 0x61, 0x00, 0x54, 0x65,
+    0x6e, 0x65, 0x73, 0x68, 0x61, 0x00, 0x54, 0x65, 0x6e, 0x69, 0x73, 0x68,
+    0x61, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x54, 0x65, 0x6f, 0x64, 0x6f, 0x72,
+    0x61, 0x00, 0x54, 0x65, 0x6f, 0x64, 0x6f, 0x72, 0x6f, 0x00, 0x54, 0x65,
+    0x6f, 0x66, 0x69, 0x6c, 0x61, 0x00, 0x54, 0x65, 0x71, 0x75, 0x69, 0x6c,
+    0x61, 0x00, 0x54, 0x65, 0x72, 0x61, 0x00, 0x54, 0x65, 0x72, 0x65, 0x61,
+    0x73, 0x61, 0x00, 0x54, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x54,
+    0x65, 0x72, 0x65, 0x73, 0x61, 0x00, 0x54, 0x65, 0x72, 0x65, 0x73, 0x65,
+    0x00, 0x54, 0x65, 0x72, 0x65, 0x73, 0x69, 0x61, 0x00, 0x54, 0x65, 0x72,
+    0x65, 0x73, 0x69, 0x74, 0x61, 0x00, 0x54, 0x65, 0x72, 0x65, 0x73, 0x73,
+    0x61, 0x00, 0x54, 0x65, 0x72, 0x69, 0x00, 0x54, 0x65, 0x72, 0x69, 0x63,
+    0x61, 0x00, 0x54, 0x65, 0x72, 0x69, 0x6e, 0x61, 0x00, 0x54, 0x65, 0x72,
+    0x69, 0x73, 0x61, 0x00, 0x54, 0x65, 0x72, 0x72, 0x61, 0x00, 0x54, 0x65,
+    0x72, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x54, 0x65, 0x72, 0x72, 0x65,
+    0x6c, 0x6c, 0x00, 0x54, 0x65, 0x72, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00,
+    0x54, 0x65, 0x72, 0x72, 0x65, 0x73, 0x61, 0x00, 0x54, 0x65, 0x72, 0x72,
+    0x69, 0x00, 0x54, 0x65, 0x72, 0x72, 0x69, 0x65, 0x00, 0x54, 0x65, 0x72,
+    0x72, 0x69, 0x6c, 0x79, 0x6e, 0x00, 0x54, 0x65, 0x72, 0x72, 0x79, 0x00,
+    0x54, 0x65, 0x73, 0x68, 0x61, 0x00, 0x54, 0x65, 0x73, 0x73, 0x00, 0x54,
+    0x65, 0x73, 0x73, 0x61, 0x00, 0x54, 0x65, 0x73, 0x73, 0x69, 0x65, 0x00,
+    0x54, 0x68, 0x61, 0x64, 0x00, 0x54, 0x68, 0x61, 0x64, 0x64, 0x65, 0x75,
+    0x73, 0x00, 0x54, 0x68, 0x61, 0x6c, 0x69, 0x61, 0x00, 0x54, 0x68, 0x61,
+    0x6e, 0x68, 0x00, 0x54, 0x68, 0x61, 0x6f, 0x00, 0x54, 0x68, 0x65, 0x61,
+    0x00, 0x54, 0x68, 0x65, 0x64, 0x61, 0x00, 0x54, 0x68, 0x65, 0x6c, 0x6d,
+    0x61, 0x00, 0x54, 0x68, 0x65, 0x6f, 0x00, 0x54, 0x68, 0x65, 0x6f, 0x64,
+    0x6f, 0x72, 0x61, 0x00, 0x54, 0x68, 0x65, 0x6f, 0x64, 0x6f, 0x72, 0x65,
+    0x00, 0x54, 0x68, 0x65, 0x6f, 0x6c, 0x61, 0x00, 0x54, 0x68, 0x65, 0x72,
+    0x65, 0x73, 0x61, 0x00, 0x54, 0x68, 0x65, 0x72, 0x65, 0x73, 0x65, 0x00,
+    0x54, 0x68, 0x65, 0x72, 0x65, 0x73, 0x69, 0x61, 0x00, 0x54, 0x68, 0x65,
+    0x72, 0x65, 0x73, 0x73, 0x61, 0x00, 0x54, 0x68, 0x65, 0x72, 0x6f, 0x6e,
+    0x00, 0x54, 0x68, 0x65, 0x72, 0x73, 0x61, 0x00, 0x54, 0x68, 0x69, 0x00,
+    0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73, 0x00, 0x54, 0x68, 0x6f, 0x6d, 0x61,
+    0x73, 0x65, 0x6e, 0x61, 0x00, 0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73, 0x69,
+    0x6e, 0x61, 0x00, 0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73, 0x69, 0x6e, 0x65,
+    0x00, 0x54, 0x68, 0x6f, 0x72, 0x61, 0x00, 0x54, 0x68, 0x72, 0x65, 0x73,
+    0x61, 0x00, 0x54, 0x68, 0x75, 0x00, 0x54, 0x68, 0x75, 0x72, 0x6d, 0x61,
+    0x6e, 0x00, 0x54, 0x68, 0x75, 0x79, 0x00, 0x54, 0x69, 0x61, 0x00, 0x54,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x54, 0x69, 0x61, 0x6e, 0x6e, 0x61, 0x00,
+    0x54, 0x69, 0x61, 0x72, 0x61, 0x00, 0x54, 0x69, 0x65, 0x6e, 0x00, 0x54,
+    0x69, 0x65, 0x72, 0x61, 0x00, 0x54, 0x69, 0x65, 0x72, 0x72, 0x61, 0x00,
+    0x54, 0x69, 0x65, 0x73, 0x68, 0x61, 0x00, 0x54, 0x69, 0x66, 0x61, 0x6e,
+    0x79, 0x00, 0x54, 0x69, 0x66, 0x66, 0x61, 0x6e, 0x65, 0x79, 0x00, 0x54,
+    0x69, 0x66, 0x66, 0x61, 0x6e, 0x69, 0x00, 0x54, 0x69, 0x66, 0x66, 0x61,
+    0x6e, 0x69, 0x65, 0x00, 0x54, 0x69, 0x66, 0x66, 0x61, 0x6e, 0x79, 0x00,
+    0x54, 0x69, 0x66, 0x66, 0x69, 0x6e, 0x79, 0x00, 0x54, 0x69, 0x6a, 0x75,
+    0x61, 0x6e, 0x61, 0x00, 0x54, 0x69, 0x6c, 0x64, 0x61, 0x00, 0x54, 0x69,
+    0x6c, 0x6c, 0x69, 0x65, 0x00, 0x54, 0x69, 0x6d, 0x00, 0x54, 0x69, 0x6d,
+    0x69, 0x6b, 0x61, 0x00, 0x54, 0x69, 0x6d, 0x6d, 0x79, 0x00, 0x54, 0x69,
+    0x6d, 0x6f, 0x74, 0x68, 0x79, 0x00, 0x54, 0x69, 0x6e, 0x61, 0x00, 0x54,
+    0x69, 0x6e, 0x69, 0x73, 0x68, 0x61, 0x00, 0x54, 0x69, 0x6e, 0x79, 0x00,
+    0x54, 0x69, 0x73, 0x61, 0x00, 0x54, 0x69, 0x73, 0x68, 0x00, 0x54, 0x69,
+    0x73, 0x68, 0x61, 0x00, 0x54, 0x69, 0x74, 0x75, 0x73, 0x00, 0x54, 0x6f,
+    0x62, 0x69, 0x00, 0x54, 0x6f, 0x62, 0x69, 0x61, 0x73, 0x00, 0x54, 0x6f,
+    0x62, 0x69, 0x65, 0x00, 0x54, 0x6f, 0x62, 0x79, 0x00, 0x54, 0x6f, 0x63,
+    0x63, 0x61, 0x72, 0x61, 0x00, 0x54, 0x6f, 0x64, 0x00, 0x54, 0x6f, 0x64,
+    0x64, 0x00, 0x54, 0x6f, 0x69, 0x00, 0x54, 0x6f, 0x6d, 0x00, 0x54, 0x6f,
+    0x6d, 0x61, 0x73, 0x00, 0x54, 0x6f, 0x6d, 0x61, 0x73, 0x61, 0x00, 0x54,
+    0x6f, 0x6d, 0x65, 0x6b, 0x61, 0x00, 0x54, 0x6f, 0x6d, 0x69, 0x00, 0x54,
+    0x6f, 0x6d, 0x69, 0x6b, 0x61, 0x00, 0x54, 0x6f, 0x6d, 0x69, 0x6b, 0x6f,
+    0x00, 0x54, 0x6f, 0x6d, 0x6d, 0x69, 0x65, 0x00, 0x54, 0x6f, 0x6d, 0x6d,
+    0x79, 0x00, 0x54, 0x6f, 0x6d, 0x6d, 0x79, 0x65, 0x00, 0x54, 0x6f, 0x6d,
+    0x6f, 0x6b, 0x6f, 0x00, 0x54, 0x6f, 0x6e, 0x61, 0x00, 0x54, 0x6f, 0x6e,
+    0x64, 0x61, 0x00, 0x54, 0x6f, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x54,
+    0x6f, 0x6e, 0x65, 0x79, 0x00, 0x54, 0x6f, 0x6e, 0x69, 0x00, 0x54, 0x6f,
+    0x6e, 0x69, 0x61, 0x00, 0x54, 0x6f, 0x6e, 0x69, 0x65, 0x00, 0x54, 0x6f,
+    0x6e, 0x69, 0x73, 0x68, 0x61, 0x00, 0x54, 0x6f, 0x6e, 0x69, 0x74, 0x61,
+    0x00, 0x54, 0x6f, 0x6e, 0x6a, 0x61, 0x00, 0x54, 0x6f, 0x6e, 0x79, 0x00,
+    0x54, 0x6f, 0x6e, 0x79, 0x61, 0x00, 0x54, 0x6f, 0x72, 0x61, 0x00, 0x54,
+    0x6f, 0x72, 0x69, 0x00, 0x54, 0x6f, 0x72, 0x69, 0x65, 0x00, 0x54, 0x6f,
+    0x72, 0x72, 0x69, 0x00, 0x54, 0x6f, 0x72, 0x72, 0x69, 0x65, 0x00, 0x54,
+    0x6f, 0x72, 0x79, 0x00, 0x54, 0x6f, 0x73, 0x68, 0x61, 0x00, 0x54, 0x6f,
+    0x73, 0x68, 0x69, 0x61, 0x00, 0x54, 0x6f, 0x73, 0x68, 0x69, 0x6b, 0x6f,
+    0x00, 0x54, 0x6f, 0x76, 0x61, 0x00, 0x54, 0x6f, 0x77, 0x61, 0x6e, 0x64,
+    0x61, 0x00, 0x54, 0x6f, 0x79, 0x61, 0x00, 0x54, 0x72, 0x61, 0x63, 0x65,
+    0x65, 0x00, 0x54, 0x72, 0x61, 0x63, 0x65, 0x79, 0x00, 0x54, 0x72, 0x61,
+    0x63, 0x69, 0x00, 0x54, 0x72, 0x61, 0x63, 0x69, 0x65, 0x00, 0x54, 0x72,
+    0x61, 0x63, 0x79, 0x00, 0x54, 0x72, 0x61, 0x6e, 0x00, 0x54, 0x72, 0x61,
+    0x6e, 0x67, 0x00, 0x54, 0x72, 0x61, 0x76, 0x69, 0x73, 0x00, 0x54, 0x72,
+    0x65, 0x61, 0x73, 0x61, 0x00, 0x54, 0x72, 0x65, 0x65, 0x6e, 0x61, 0x00,
+    0x54, 0x72, 0x65, 0x6e, 0x61, 0x00, 0x54, 0x72, 0x65, 0x6e, 0x74, 0x00,
+    0x54, 0x72, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x72, 0x65, 0x73,
+    0x61, 0x00, 0x54, 0x72, 0x65, 0x73, 0x73, 0x61, 0x00, 0x54, 0x72, 0x65,
+    0x73, 0x73, 0x69, 0x65, 0x00, 0x54, 0x72, 0x65, 0x76, 0x61, 0x00, 0x54,
+    0x72, 0x65, 0x76, 0x6f, 0x72, 0x00, 0x54, 0x72, 0x65, 0x79, 0x00, 0x54,
+    0x72, 0x69, 0x63, 0x69, 0x61, 0x00, 0x54, 0x72, 0x69, 0x6e, 0x61, 0x00,
+    0x54, 0x72, 0x69, 0x6e, 0x68, 0x00, 0x54, 0x72, 0x69, 0x6e, 0x69, 0x64,
+    0x61, 0x64, 0x00, 0x54, 0x72, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x00, 0x54,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x54, 0x72, 0x69, 0x73, 0x68, 0x61, 0x00,
+    0x54, 0x72, 0x69, 0x73, 0x74, 0x61, 0x00, 0x54, 0x72, 0x69, 0x73, 0x74,
+    0x61, 0x6e, 0x00, 0x54, 0x72, 0x6f, 0x79, 0x00, 0x54, 0x72, 0x75, 0x64,
+    0x69, 0x00, 0x54, 0x72, 0x75, 0x64, 0x69, 0x65, 0x00, 0x54, 0x72, 0x75,
+    0x64, 0x79, 0x00, 0x54, 0x72, 0x75, 0x6c, 0x61, 0x00, 0x54, 0x72, 0x75,
+    0x6d, 0x61, 0x6e, 0x00, 0x54, 0x75, 0x00, 0x54, 0x75, 0x61, 0x6e, 0x00,
+    0x54, 0x75, 0x6c, 0x61, 0x00, 0x54, 0x75, 0x79, 0x65, 0x74, 0x00, 0x54,
+    0x77, 0x61, 0x6e, 0x61, 0x00, 0x54, 0x77, 0x61, 0x6e, 0x64, 0x61, 0x00,
+    0x54, 0x77, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x54, 0x77, 0x69, 0x6c, 0x61,
+    0x00, 0x54, 0x77, 0x79, 0x6c, 0x61, 0x00, 0x54, 0x79, 0x00, 0x54, 0x79,
+    0x65, 0x73, 0x68, 0x61, 0x00, 0x54, 0x79, 0x69, 0x73, 0x68, 0x61, 0x00,
+    0x54, 0x79, 0x6c, 0x65, 0x72, 0x00, 0x54, 0x79, 0x6e, 0x69, 0x73, 0x68,
+    0x61, 0x00, 0x54, 0x79, 0x72, 0x61, 0x00, 0x54, 0x79, 0x72, 0x65, 0x65,
+    0x00, 0x54, 0x79, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x54, 0x79, 0x72, 0x6f,
+    0x6e, 0x00, 0x54, 0x79, 0x72, 0x6f, 0x6e, 0x65, 0x00, 0x54, 0x79, 0x73,
+    0x6f, 0x6e, 0x00, 0x55, 0x6c, 0x61, 0x00, 0x55, 0x6c, 0x72, 0x69, 0x6b,
+    0x65, 0x00, 0x55, 0x6c, 0x79, 0x73, 0x73, 0x65, 0x73, 0x00, 0x55, 0x6e,
+    0x00, 0x55, 0x6e, 0x61, 0x00, 0x55, 0x72, 0x73, 0x75, 0x6c, 0x61, 0x00,
+    0x55, 0x73, 0x68, 0x61, 0x00, 0x55, 0x74, 0x65, 0x00, 0x56, 0x61, 0x64,
+    0x61, 0x00, 0x56, 0x61, 0x6c, 0x00, 0x56, 0x61, 0x6c, 0x61, 0x72, 0x69,
+    0x65, 0x00, 0x56, 0x61, 0x6c, 0x64, 0x61, 0x00, 0x56, 0x61, 0x6c, 0x65,
+    0x6e, 0x63, 0x69, 0x61, 0x00, 0x56, 0x61, 0x6c, 0x65, 0x6e, 0x65, 0x00,
+    0x56, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x00, 0x56, 0x61, 0x6c,
+    0x65, 0x6e, 0x74, 0x69, 0x6e, 0x61, 0x00, 0x56, 0x61, 0x6c, 0x65, 0x6e,
+    0x74, 0x69, 0x6e, 0x65, 0x00, 0x56, 0x61, 0x6c, 0x65, 0x72, 0x69, 0x00,
+    0x56, 0x61, 0x6c, 0x65, 0x72, 0x69, 0x61, 0x00, 0x56, 0x61, 0x6c, 0x65,
+    0x72, 0x69, 0x65, 0x00, 0x56, 0x61, 0x6c, 0x65, 0x72, 0x79, 0x00, 0x56,
+    0x61, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x56, 0x61, 0x6c, 0x6f, 0x72, 0x69,
+    0x65, 0x00, 0x56, 0x61, 0x6c, 0x72, 0x69, 0x65, 0x00, 0x56, 0x61, 0x6e,
+    0x00, 0x56, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x56, 0x61, 0x6e, 0x64, 0x61,
+    0x00, 0x56, 0x61, 0x6e, 0x65, 0x73, 0x61, 0x00, 0x56, 0x61, 0x6e, 0x65,
+    0x73, 0x73, 0x61, 0x00, 0x56, 0x61, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00,
+    0x56, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x56, 0x61, 0x6e, 0x69, 0x74, 0x61,
+    0x00, 0x56, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x56, 0x61, 0x6e, 0x6e, 0x65,
+    0x73, 0x61, 0x00, 0x56, 0x61, 0x6e, 0x6e, 0x65, 0x73, 0x73, 0x61, 0x00,
+    0x56, 0x61, 0x73, 0x68, 0x74, 0x69, 0x00, 0x56, 0x61, 0x73, 0x69, 0x6c,
+    0x69, 0x6b, 0x69, 0x00, 0x56, 0x61, 0x75, 0x67, 0x68, 0x6e, 0x00, 0x56,
+    0x65, 0x64, 0x61, 0x00, 0x56, 0x65, 0x6c, 0x64, 0x61, 0x00, 0x56, 0x65,
+    0x6c, 0x69, 0x61, 0x00, 0x56, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x56, 0x65,
+    0x6c, 0x6d, 0x61, 0x00, 0x56, 0x65, 0x6c, 0x76, 0x61, 0x00, 0x56, 0x65,
+    0x6c, 0x76, 0x65, 0x74, 0x00, 0x56, 0x65, 0x6e, 0x61, 0x00, 0x56, 0x65,
+    0x6e, 0x65, 0x73, 0x73, 0x61, 0x00, 0x56, 0x65, 0x6e, 0x65, 0x74, 0x74,
+    0x61, 0x00, 0x56, 0x65, 0x6e, 0x69, 0x63, 0x65, 0x00, 0x56, 0x65, 0x6e,
+    0x69, 0x74, 0x61, 0x00, 0x56, 0x65, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x56,
+    0x65, 0x6e, 0x75, 0x73, 0x00, 0x56, 0x65, 0x6f, 0x6c, 0x61, 0x00, 0x56,
+    0x65, 0x72, 0x61, 0x00, 0x56, 0x65, 0x72, 0x64, 0x61, 0x00, 0x56, 0x65,
+    0x72, 0x64, 0x65, 0x6c, 0x6c, 0x00, 0x56, 0x65, 0x72, 0x64, 0x69, 0x65,
+    0x00, 0x56, 0x65, 0x72, 0x65, 0x6e, 0x61, 0x00, 0x56, 0x65, 0x72, 0x67,
+    0x69, 0x65, 0x00, 0x56, 0x65, 0x72, 0x6c, 0x61, 0x00, 0x56, 0x65, 0x72,
+    0x6c, 0x65, 0x6e, 0x65, 0x00, 0x56, 0x65, 0x72, 0x6c, 0x69, 0x65, 0x00,
+    0x56, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x56, 0x65, 0x72, 0x6e,
+    0x00, 0x56, 0x65, 0x72, 0x6e, 0x61, 0x00, 0x56, 0x65, 0x72, 0x6e, 0x65,
+    0x6c, 0x6c, 0x00, 0x56, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00,
+    0x56, 0x65, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x56, 0x65, 0x72, 0x6e, 0x69,
+    0x63, 0x65, 0x00, 0x56, 0x65, 0x72, 0x6e, 0x69, 0x65, 0x00, 0x56, 0x65,
+    0x72, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x56, 0x65, 0x72, 0x6e, 0x6f, 0x6e,
+    0x00, 0x56, 0x65, 0x72, 0x6f, 0x6e, 0x61, 0x00, 0x56, 0x65, 0x72, 0x6f,
+    0x6e, 0x69, 0x63, 0x61, 0x00, 0x56, 0x65, 0x72, 0x6f, 0x6e, 0x69, 0x6b,
+    0x61, 0x00, 0x56, 0x65, 0x72, 0x6f, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x00,
+    0x56, 0x65, 0x72, 0x73, 0x69, 0x65, 0x00, 0x56, 0x65, 0x72, 0x74, 0x69,
+    0x65, 0x00, 0x56, 0x65, 0x73, 0x74, 0x61, 0x00, 0x56, 0x65, 0x74, 0x61,
+    0x00, 0x56, 0x69, 0x00, 0x56, 0x69, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x00,
+    0x56, 0x69, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x00, 0x56, 0x69, 0x63, 0x6b,
+    0x65, 0x79, 0x00, 0x56, 0x69, 0x63, 0x6b, 0x69, 0x00, 0x56, 0x69, 0x63,
+    0x6b, 0x69, 0x65, 0x00, 0x56, 0x69, 0x63, 0x6b, 0x79, 0x00, 0x56, 0x69,
+    0x63, 0x74, 0x6f, 0x72, 0x00, 0x56, 0x69, 0x63, 0x74, 0x6f, 0x72, 0x69,
+    0x61, 0x00, 0x56, 0x69, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x6e, 0x61, 0x00,
+    0x56, 0x69, 0x64, 0x61, 0x00, 0x56, 0x69, 0x6b, 0x69, 0x00, 0x56, 0x69,
+    0x6b, 0x6b, 0x69, 0x00, 0x56, 0x69, 0x6c, 0x6d, 0x61, 0x00, 0x56, 0x69,
+    0x6e, 0x61, 0x00, 0x56, 0x69, 0x6e, 0x63, 0x65, 0x00, 0x56, 0x69, 0x6e,
+    0x63, 0x65, 0x6e, 0x74, 0x00, 0x56, 0x69, 0x6e, 0x63, 0x65, 0x6e, 0x7a,
+    0x61, 0x00, 0x56, 0x69, 0x6e, 0x63, 0x65, 0x6e, 0x7a, 0x6f, 0x00, 0x56,
+    0x69, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x56, 0x69, 0x6e, 0x6e, 0x69, 0x65,
+    0x00, 0x56, 0x69, 0x6f, 0x6c, 0x61, 0x00, 0x56, 0x69, 0x6f, 0x6c, 0x65,
+    0x74, 0x00, 0x56, 0x69, 0x6f, 0x6c, 0x65, 0x74, 0x61, 0x00, 0x56, 0x69,
+    0x6f, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x00, 0x56, 0x69, 0x72, 0x67, 0x65,
+    0x6e, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x65, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6c, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6c, 0x69, 0x6f,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x61, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x56, 0x69, 0x74, 0x61, 0x00, 0x56,
+    0x69, 0x74, 0x6f, 0x00, 0x56, 0x69, 0x76, 0x61, 0x00, 0x56, 0x69, 0x76,
+    0x61, 0x6e, 0x00, 0x56, 0x69, 0x76, 0x69, 0x61, 0x6e, 0x00, 0x56, 0x69,
+    0x76, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x56, 0x69, 0x76, 0x69, 0x65, 0x6e,
+    0x00, 0x56, 0x69, 0x76, 0x69, 0x65, 0x6e, 0x6e, 0x65, 0x00, 0x56, 0x6f,
+    0x6e, 0x00, 0x56, 0x6f, 0x6e, 0x63, 0x69, 0x6c, 0x65, 0x00, 0x56, 0x6f,
+    0x6e, 0x64, 0x61, 0x00, 0x56, 0x6f, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x57,
+    0x61, 0x64, 0x65, 0x00, 0x57, 0x61, 0x69, 0x00, 0x57, 0x61, 0x6c, 0x64,
+    0x6f, 0x00, 0x57, 0x61, 0x6c, 0x6b, 0x65, 0x72, 0x00, 0x57, 0x61, 0x6c,
+    0x6c, 0x61, 0x63, 0x65, 0x00, 0x57, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x57,
+    0x61, 0x6c, 0x74, 0x65, 0x72, 0x00, 0x57, 0x61, 0x6c, 0x74, 0x6f, 0x6e,
+    0x00, 0x57, 0x61, 0x6c, 0x74, 0x72, 0x61, 0x75, 0x64, 0x00, 0x57, 0x61,
+    0x6e, 0x00, 0x57, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x57, 0x61, 0x6e, 0x65,
+    0x74, 0x61, 0x00, 0x57, 0x61, 0x6e, 0x65, 0x74, 0x74, 0x61, 0x00, 0x57,
+    0x61, 0x6e, 0x69, 0x74, 0x61, 0x00, 0x57, 0x61, 0x72, 0x64, 0x00, 0x57,
+    0x61, 0x72, 0x6e, 0x65, 0x72, 0x00, 0x57, 0x61, 0x72, 0x72, 0x65, 0x6e,
+    0x00, 0x57, 0x61, 0x76, 0x61, 0x00, 0x57, 0x61, 0x79, 0x6c, 0x6f, 0x6e,
+    0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x57, 0x65, 0x69, 0x00, 0x57,
+    0x65, 0x6c, 0x64, 0x6f, 0x6e, 0x00, 0x57, 0x65, 0x6e, 0x00, 0x57, 0x65,
+    0x6e, 0x64, 0x65, 0x6c, 0x6c, 0x00, 0x57, 0x65, 0x6e, 0x64, 0x69, 0x00,
+    0x57, 0x65, 0x6e, 0x64, 0x69, 0x65, 0x00, 0x57, 0x65, 0x6e, 0x64, 0x6f,
+    0x6c, 0x79, 0x6e, 0x00, 0x57, 0x65, 0x6e, 0x64, 0x79, 0x00, 0x57, 0x65,
+    0x6e, 0x6f, 0x6e, 0x61, 0x00, 0x57, 0x65, 0x72, 0x6e, 0x65, 0x72, 0x00,
+    0x57, 0x65, 0x73, 0x00, 0x57, 0x65, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x68, 0x69, 0x74, 0x6c, 0x65,
+    0x79, 0x00, 0x57, 0x68, 0x69, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x57, 0x69,
+    0x6c, 0x62, 0x65, 0x72, 0x00, 0x57, 0x69, 0x6c, 0x62, 0x65, 0x72, 0x74,
+    0x00, 0x57, 0x69, 0x6c, 0x62, 0x75, 0x72, 0x00, 0x57, 0x69, 0x6c, 0x62,
+    0x75, 0x72, 0x6e, 0x00, 0x57, 0x69, 0x6c, 0x64, 0x61, 0x00, 0x57, 0x69,
+    0x6c, 0x65, 0x79, 0x00, 0x57, 0x69, 0x6c, 0x66, 0x6f, 0x72, 0x64, 0x00,
+    0x57, 0x69, 0x6c, 0x66, 0x72, 0x65, 0x64, 0x00, 0x57, 0x69, 0x6c, 0x66,
+    0x72, 0x65, 0x64, 0x6f, 0x00, 0x57, 0x69, 0x6c, 0x68, 0x65, 0x6c, 0x6d,
+    0x69, 0x6e, 0x61, 0x00, 0x57, 0x69, 0x6c, 0x68, 0x65, 0x6d, 0x69, 0x6e,
+    0x61, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x61,
+    0x00, 0x57, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x00, 0x57, 0x69, 0x6c,
+    0x6c, 0x65, 0x6e, 0x61, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x65, 0x6e, 0x65,
+    0x00, 0x57, 0x69, 0x6c, 0x6c, 0x65, 0x74, 0x74, 0x61, 0x00, 0x57, 0x69,
+    0x6c, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69,
+    0x61, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x00, 0x57, 0x69,
+    0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69,
+    0x61, 0x6e, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x57, 0x69,
+    0x6c, 0x6c, 0x69, 0x65, 0x6d, 0x61, 0x65, 0x00, 0x57, 0x69, 0x6c, 0x6c,
+    0x69, 0x73, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x6f, 0x64, 0x65, 0x61, 0x6e,
+    0x00, 0x57, 0x69, 0x6c, 0x6c, 0x6f, 0x77, 0x00, 0x57, 0x69, 0x6c, 0x6c,
+    0x79, 0x00, 0x57, 0x69, 0x6c, 0x6d, 0x61, 0x00, 0x57, 0x69, 0x6c, 0x6d,
+    0x65, 0x72, 0x00, 0x57, 0x69, 0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x57, 0x69,
+    0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6e, 0x64, 0x79, 0x00, 0x57,
+    0x69, 0x6e, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x57, 0x69, 0x6e, 0x66, 0x72,
+    0x65, 0x64, 0x00, 0x57, 0x69, 0x6e, 0x69, 0x66, 0x72, 0x65, 0x64, 0x00,
+    0x57, 0x69, 0x6e, 0x6e, 0x69, 0x65, 0x00, 0x57, 0x69, 0x6e, 0x6e, 0x69,
+    0x66, 0x72, 0x65, 0x64, 0x00, 0x57, 0x69, 0x6e, 0x6f, 0x6e, 0x61, 0x00,
+    0x57, 0x69, 0x6e, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x57, 0x6d, 0x00, 0x57, 0x6f, 0x6e, 0x64, 0x61, 0x00,
+    0x57, 0x6f, 0x6f, 0x64, 0x72, 0x6f, 0x77, 0x00, 0x57, 0x79, 0x61, 0x74,
+    0x74, 0x00, 0x57, 0x79, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x57, 0x79, 0x6e,
+    0x6f, 0x6e, 0x61, 0x00, 0x58, 0x61, 0x76, 0x69, 0x65, 0x72, 0x00, 0x58,
+    0x65, 0x6e, 0x69, 0x61, 0x00, 0x58, 0x69, 0x61, 0x6f, 0x00, 0x58, 0x69,
+    0x6f, 0x6d, 0x61, 0x72, 0x61, 0x00, 0x58, 0x6f, 0x63, 0x68, 0x69, 0x74,
+    0x6c, 0x00, 0x58, 0x75, 0x61, 0x6e, 0x00, 0x59, 0x61, 0x64, 0x69, 0x72,
+    0x61, 0x00, 0x59, 0x61, 0x65, 0x6b, 0x6f, 0x00, 0x59, 0x61, 0x65, 0x6c,
+    0x00, 0x59, 0x61, 0x68, 0x61, 0x69, 0x72, 0x61, 0x00, 0x59, 0x61, 0x6a,
+    0x61, 0x69, 0x72, 0x61, 0x00, 0x59, 0x61, 0x6e, 0x00, 0x59, 0x61, 0x6e,
+    0x67, 0x00, 0x59, 0x61, 0x6e, 0x69, 0x72, 0x61, 0x00, 0x59, 0x61, 0x73,
+    0x6d, 0x69, 0x6e, 0x00, 0x59, 0x61, 0x73, 0x6d, 0x69, 0x6e, 0x65, 0x00,
+    0x59, 0x61, 0x73, 0x75, 0x6b, 0x6f, 0x00, 0x59, 0x65, 0x65, 0x00, 0x59,
+    0x65, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x59, 0x65, 0x6e, 0x00, 0x59, 0x65,
+    0x72, 0x00, 0x59, 0x65, 0x73, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x59, 0x65,
+    0x73, 0x73, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x59, 0x65, 0x74, 0x74, 0x61,
+    0x00, 0x59, 0x65, 0x76, 0x65, 0x74, 0x74, 0x65, 0x00, 0x59, 0x69, 0x00,
+    0x59, 0x69, 0x6e, 0x67, 0x00, 0x59, 0x6f, 0x6b, 0x6f, 0x00, 0x59, 0x6f,
+    0x6c, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x59, 0x6f, 0x6c, 0x61, 0x6e, 0x64,
+    0x65, 0x00, 0x59, 0x6f, 0x6c, 0x61, 0x6e, 0x64, 0x6f, 0x00, 0x59, 0x6f,
+    0x6c, 0x6f, 0x6e, 0x64, 0x61, 0x00, 0x59, 0x6f, 0x6e, 0x00, 0x59, 0x6f,
+    0x6e, 0x67, 0x00, 0x59, 0x6f, 0x73, 0x68, 0x69, 0x65, 0x00, 0x59, 0x6f,
+    0x73, 0x68, 0x69, 0x6b, 0x6f, 0x00, 0x59, 0x6f, 0x75, 0x6c, 0x61, 0x6e,
+    0x64, 0x61, 0x00, 0x59, 0x6f, 0x75, 0x6e, 0x67, 0x00, 0x59, 0x75, 0x00,
+    0x59, 0x75, 0x65, 0x74, 0x74, 0x65, 0x00, 0x59, 0x75, 0x6b, 0x00, 0x59,
+    0x75, 0x6b, 0x69, 0x00, 0x59, 0x75, 0x6b, 0x69, 0x6b, 0x6f, 0x00, 0x59,
+    0x75, 0x6b, 0x6f, 0x00, 0x59, 0x75, 0x6c, 0x61, 0x6e, 0x64, 0x61, 0x00,
+    0x59, 0x75, 0x6e, 0x00, 0x59, 0x75, 0x6e, 0x67, 0x00, 0x59, 0x75, 0x6f,
+    0x6e, 0x6e, 0x65, 0x00, 0x59, 0x75, 0x72, 0x69, 0x00, 0x59, 0x75, 0x72,
+    0x69, 0x6b, 0x6f, 0x00, 0x59, 0x76, 0x65, 0x74, 0x74, 0x65, 0x00, 0x59,
+    0x76, 0x6f, 0x6e, 0x65, 0x00, 0x59, 0x76, 0x6f, 0x6e, 0x6e, 0x65, 0x00,
+    0x5a, 0x61, 0x63, 0x68, 0x61, 0x72, 0x69, 0x61, 0x68, 0x00, 0x5a, 0x61,
+    0x63, 0x68, 0x61, 0x72, 0x79, 0x00, 0x5a, 0x61, 0x63, 0x68, 0x65, 0x72,
+    0x79, 0x00, 0x5a, 0x61, 0x63, 0x6b, 0x00, 0x5a, 0x61, 0x63, 0x6b, 0x61,
+    0x72, 0x79, 0x00, 0x5a, 0x61, 0x64, 0x61, 0x00, 0x5a, 0x61, 0x69, 0x64,
+    0x61, 0x00, 0x5a, 0x61, 0x6e, 0x61, 0x00, 0x5a, 0x61, 0x6e, 0x64, 0x72,
+    0x61, 0x00, 0x5a, 0x61, 0x6e, 0x65, 0x00, 0x5a, 0x65, 0x6c, 0x64, 0x61,
+    0x00, 0x5a, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x5a, 0x65, 0x6c, 0x6d, 0x61,
+    0x00, 0x5a, 0x65, 0x6e, 0x61, 0x00, 0x5a, 0x65, 0x6e, 0x61, 0x69, 0x64,
+    0x61, 0x00, 0x5a, 0x65, 0x6e, 0x69, 0x61, 0x00, 0x5a, 0x65, 0x6e, 0x6f,
+    0x62, 0x69, 0x61, 0x00, 0x5a, 0x65, 0x74, 0x74, 0x61, 0x00, 0x5a, 0x69,
+    0x6e, 0x61, 0x00, 0x5a, 0x69, 0x74, 0x61, 0x00, 0x5a, 0x6f, 0x65, 0x00,
+    0x5a, 0x6f, 0x66, 0x69, 0x61, 0x00, 0x5a, 0x6f, 0x69, 0x6c, 0x61, 0x00,
+    0x5a, 0x6f, 0x6c, 0x61, 0x00, 0x5a, 0x6f, 0x6e, 0x61, 0x00, 0x5a, 0x6f,
+    0x6e, 0x69, 0x61, 0x00, 0x5a, 0x6f, 0x72, 0x61, 0x00, 0x5a, 0x6f, 0x72,
+    0x61, 0x69, 0x64, 0x61, 0x00, 0x5a, 0x75, 0x6c, 0x61, 0x00, 0x5a, 0x75,
+    0x6c, 0x65, 0x6d, 0x61, 0x00, 0x5a, 0x75, 0x6c, 0x6d, 0x61, 0x00, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x03, 0xee, 0x00, 0x00, 0x03, 0x2a, 0x00,
+    0x00, 0x02, 0xbb, 0x00, 0x00, 0x02, 0x6d, 0x00, 0x00, 0x02, 0x6d, 0x00,
+    0x00, 0x01, 0xe0, 0x00, 0x00, 0x01, 0xa8, 0x00, 0x00, 0x01, 0x53, 0x00,
+    0x00, 0x01, 0x38, 0x00, 0x00, 0x01, 0x37, 0x00, 0x00, 0x01, 0x37, 0x00,
+    0x00, 0x01, 0x37, 0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x01, 0x17, 0x00,
+    0x00, 0x01, 0x13, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x01, 0x0d, 0x00,
+    0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0xe9, 0x00,
+    0x00, 0x00, 0xe7, 0x00, 0x00, 0x00, 0xe5, 0x00, 0x00, 0x00, 0xe2, 0x00,
+    0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0xc8, 0x00,
+    0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0xc1, 0x00, 0x00, 0x00, 0xc0, 0x00,
+    0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0xbb, 0x00,
+    0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0xb7, 0x00,
+    0x00, 0x00, 0xae, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0xa6, 0x00,
+    0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xa0, 0x00,
+    0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x98, 0x00,
+    0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x92, 0x00,
+    0x00, 0x00, 0x8d, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x86, 0x00,
+    0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x7d, 0x00,
+    0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x78, 0x00,
+    0x00, 0x00, 0x76, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x75, 0x00,
+    0x00, 0x00, 0x73, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x71, 0x00,
+    0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x6e, 0x00,
+    0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x6b, 0x00,
+    0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x69, 0x00,
+    0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x66, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x63, 0x00,
+    0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x60, 0x00,
+    0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x5f, 0x00,
+    0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x5c, 0x00,
+    0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x5c, 0x00,
+    0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x5b, 0x00,
+    0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x57, 0x00,
+    0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x54, 0x00,
+    0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x53, 0x00,
+    0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x52, 0x00,
+    0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x50, 0x00,
+    0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x4e, 0x00,
+    0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x4d, 0x00,
+    0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x4b, 0x00,
+    0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x4b, 0x00,
+    0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x4a, 0x00,
+    0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x48, 0x00,
+    0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x46, 0x00,
+    0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x45, 0x00,
+    0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x44, 0x00,
+    0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x43, 0x00,
+    0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x41, 0x00,
+    0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x40, 0x00,
+    0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x00,
+    0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3d, 0x00,
+    0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x00,
+    0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x3b, 0x00,
+    0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x3a, 0x00,
+    0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x39, 0x00,
+    0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x38, 0x00,
+    0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x38, 0x00,
+    0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x37, 0x00,
+    0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x37, 0x00,
+    0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x36, 0x00,
+    0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x36, 0x00,
+    0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x36, 0x00,
+    0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x35, 0x00,
+    0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x35, 0x00,
+    0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x34, 0x00,
+    0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x34, 0x00,
+    0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x33, 0x00,
+    0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x33, 0x00,
+    0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x33, 0x00,
+    0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x32, 0x00,
+    0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x31, 0x00,
+    0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x30, 0x00,
+    0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00,
+    0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00,
+    0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x2f, 0x00,
+    0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2e, 0x00,
+    0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2e, 0x00,
+    0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2d, 0x00,
+    0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00,
+    0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00,
+    0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x2c, 0x00,
+    0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x2b, 0x00,
+    0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x2b, 0x00,
+    0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00,
+    0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00,
+    0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x29, 0x00,
+    0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00,
+    0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00,
+    0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00,
+    0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00,
+    0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00,
+    0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00,
+    0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00,
+    0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00,
+    0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x26, 0x00,
+    0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x26, 0x00,
+    0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00,
+    0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00,
+    0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00,
+    0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00,
+    0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00,
+    0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00,
+    0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00,
+    0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00,
+    0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00,
+    0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x22, 0x00,
+    0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00,
+    0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00,
+    0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00,
+    0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00,
+    0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00,
+    0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00,
+    0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00,
+    0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00,
+    0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1c, 0x00,
+    0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00,
+    0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00,
+    0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00,
+    0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x23, 0x00,
+    0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x37, 0x00,
+    0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x4d, 0x00,
+    0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x62, 0x00,
+    0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x79, 0x00,
+    0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x92, 0x00,
+    0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xa8, 0x00,
+    0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 0xb3, 0x00, 0x00, 0x00, 0xb8, 0x00,
+    0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00, 0xce, 0x00,
+    0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0xda, 0x00, 0x00, 0x00, 0xe0, 0x00,
+    0x00, 0x00, 0xe5, 0x00, 0x00, 0x00, 0xeb, 0x00, 0x00, 0x00, 0xf1, 0x00,
+    0x00, 0x00, 0xf7, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x01, 0x06, 0x00,
+    0x00, 0x01, 0x0d, 0x00, 0x00, 0x01, 0x14, 0x00, 0x00, 0x01, 0x1d, 0x00,
+    0x00, 0x01, 0x23, 0x00, 0x00, 0x01, 0x2b, 0x00, 0x00, 0x01, 0x32, 0x00,
+    0x00, 0x01, 0x3b, 0x00, 0x00, 0x01, 0x44, 0x00, 0x00, 0x01, 0x4b, 0x00,
+    0x00, 0x01, 0x51, 0x00, 0x00, 0x01, 0x59, 0x00, 0x00, 0x01, 0x61, 0x00,
+    0x00, 0x01, 0x69, 0x00, 0x00, 0x01, 0x71, 0x00, 0x00, 0x01, 0x78, 0x00,
+    0x00, 0x01, 0x7f, 0x00, 0x00, 0x01, 0x84, 0x00, 0x00, 0x01, 0x89, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x95, 0x00, 0x00, 0x01, 0x9c, 0x00,
+    0x00, 0x01, 0xa3, 0x00, 0x00, 0x01, 0xaa, 0x00, 0x00, 0x01, 0xb1, 0x00,
+    0x00, 0x01, 0xbc, 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x01, 0xc7, 0x00,
+    0x00, 0x01, 0xcc, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x01, 0xdc, 0x00,
+    0x00, 0x01, 0xe1, 0x00, 0x00, 0x01, 0xe9, 0x00, 0x00, 0x01, 0xef, 0x00,
+    0x00, 0x01, 0xf6, 0x00, 0x00, 0x01, 0xfd, 0x00, 0x00, 0x02, 0x03, 0x00,
+    0x00, 0x02, 0x0b, 0x00, 0x00, 0x02, 0x11, 0x00, 0x00, 0x02, 0x19, 0x00,
+    0x00, 0x02, 0x1e, 0x00, 0x00, 0x02, 0x25, 0x00, 0x00, 0x02, 0x2a, 0x00,
+    0x00, 0x02, 0x34, 0x00, 0x00, 0x02, 0x3c, 0x00, 0x00, 0x02, 0x44, 0x00,
+    0x00, 0x02, 0x4a, 0x00, 0x00, 0x02, 0x51, 0x00, 0x00, 0x02, 0x56, 0x00,
+    0x00, 0x02, 0x60, 0x00, 0x00, 0x02, 0x67, 0x00, 0x00, 0x02, 0x6e, 0x00,
+    0x00, 0x02, 0x79, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0x02, 0x88, 0x00,
+    0x00, 0x02, 0x8f, 0x00, 0x00, 0x02, 0x98, 0x00, 0x00, 0x02, 0x9f, 0x00,
+    0x00, 0x02, 0xa9, 0x00, 0x00, 0x02, 0xb1, 0x00, 0x00, 0x02, 0xb9, 0x00,
+    0x00, 0x02, 0xbe, 0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x02, 0xca, 0x00,
+    0x00, 0x02, 0xcf, 0x00, 0x00, 0x02, 0xd8, 0x00, 0x00, 0x02, 0xdf, 0x00,
+    0x00, 0x02, 0xe8, 0x00, 0x00, 0x02, 0xf0, 0x00, 0x00, 0x02, 0xf6, 0x00,
+    0x00, 0x02, 0xfb, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x07, 0x00,
+    0x00, 0x03, 0x0d, 0x00, 0x00, 0x03, 0x16, 0x00, 0x00, 0x03, 0x1d, 0x00,
+    0x00, 0x03, 0x23, 0x00, 0x00, 0x03, 0x2c, 0x00, 0x00, 0x03, 0x33, 0x00,
+    0x00, 0x03, 0x3c, 0x00, 0x00, 0x03, 0x41, 0x00, 0x00, 0x03, 0x4a, 0x00,
+    0x00, 0x03, 0x50, 0x00, 0x00, 0x03, 0x56, 0x00, 0x00, 0x03, 0x5d, 0x00,
+    0x00, 0x03, 0x65, 0x00, 0x00, 0x03, 0x6b, 0x00, 0x00, 0x03, 0x70, 0x00,
+    0x00, 0x03, 0x78, 0x00, 0x00, 0x03, 0x80, 0x00, 0x00, 0x03, 0x87, 0x00,
+    0x00, 0x03, 0x8e, 0x00, 0x00, 0x03, 0x95, 0x00, 0x00, 0x03, 0x9b, 0x00,
+    0x00, 0x03, 0xa4, 0x00, 0x00, 0x03, 0xaa, 0x00, 0x00, 0x03, 0xaf, 0x00,
+    0x00, 0x03, 0xb5, 0x00, 0x00, 0x03, 0xbd, 0x00, 0x00, 0x03, 0xc5, 0x00,
+    0x00, 0x03, 0xcc, 0x00, 0x00, 0x03, 0xd2, 0x00, 0x00, 0x03, 0xd8, 0x00,
+    0x00, 0x03, 0xde, 0x00, 0x00, 0x03, 0xe4, 0x00, 0x00, 0x03, 0xeb, 0x00,
+    0x00, 0x03, 0xf0, 0x00, 0x00, 0x03, 0xf7, 0x00, 0x00, 0x03, 0xfc, 0x00,
+    0x00, 0x04, 0x06, 0x00, 0x00, 0x04, 0x0b, 0x00, 0x00, 0x04, 0x11, 0x00,
+    0x00, 0x04, 0x19, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04, 0x26, 0x00,
+    0x00, 0x04, 0x2e, 0x00, 0x00, 0x04, 0x34, 0x00, 0x00, 0x04, 0x3b, 0x00,
+    0x00, 0x04, 0x44, 0x00, 0x00, 0x04, 0x49, 0x00, 0x00, 0x04, 0x4f, 0x00,
+    0x00, 0x04, 0x57, 0x00, 0x00, 0x04, 0x5c, 0x00, 0x00, 0x04, 0x64, 0x00,
+    0x00, 0x04, 0x6b, 0x00, 0x00, 0x04, 0x73, 0x00, 0x00, 0x04, 0x7b, 0x00,
+    0x00, 0x04, 0x84, 0x00, 0x00, 0x04, 0x8a, 0x00, 0x00, 0x04, 0x91, 0x00,
+    0x00, 0x04, 0x97, 0x00, 0x00, 0x04, 0xa0, 0x00, 0x00, 0x04, 0xa7, 0x00,
+    0x00, 0x04, 0xae, 0x00, 0x00, 0x04, 0xb5, 0x00, 0x00, 0x04, 0xb9, 0x00,
+    0x00, 0x04, 0xc1, 0x00, 0x00, 0x04, 0xc7, 0x00, 0x00, 0x04, 0xcf, 0x00,
+    0x00, 0x04, 0xd6, 0x00, 0x00, 0x04, 0xdd, 0x00, 0x00, 0x04, 0xe2, 0x00,
+    0x00, 0x04, 0xed, 0x00, 0x00, 0x04, 0xf5, 0x00, 0x00, 0x04, 0xfa, 0x00,
+    0x00, 0x05, 0x02, 0x00, 0x00, 0x05, 0x07, 0x00, 0x00, 0x05, 0x0e, 0x00,
+    0x00, 0x05, 0x12, 0x00, 0x00, 0x05, 0x18, 0x00, 0x00, 0x05, 0x22, 0x00,
+    0x00, 0x05, 0x2c, 0x00, 0x00, 0x05, 0x33, 0x00, 0x00, 0x05, 0x3a, 0x00,
+    0x00, 0x05, 0x43, 0x00, 0x00, 0x05, 0x4b, 0x00, 0x00, 0x05, 0x52, 0x00,
+    0x00, 0x05, 0x57, 0x00, 0x00, 0x05, 0x5e, 0x00, 0x00, 0x05, 0x65, 0x00,
+    0x00, 0x05, 0x6c, 0x00, 0x00, 0x05, 0x75, 0x00, 0x00, 0x05, 0x7c, 0x00,
+    0x00, 0x05, 0x83, 0x00, 0x00, 0x05, 0x8d, 0x00, 0x00, 0x05, 0x92, 0x00,
+    0x00, 0x05, 0x9a, 0x00, 0x00, 0x05, 0x9f, 0x00, 0x00, 0x05, 0xa7, 0x00,
+    0x00, 0x05, 0xb0, 0x00, 0x00, 0x05, 0xb8, 0x00, 0x00, 0x05, 0xc0, 0x00,
+    0x00, 0x05, 0xc7, 0x00, 0x00, 0x05, 0xd2, 0x00, 0x00, 0x05, 0xdb, 0x00,
+    0x00, 0x05, 0xe6, 0x00, 0x00, 0x05, 0xef, 0x00, 0x00, 0x05, 0xf5, 0x00,
+    0x00, 0x05, 0xfb, 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x06, 0x08, 0x00,
+    0x00, 0x06, 0x0f, 0x00, 0x00, 0x06, 0x17, 0x00, 0x00, 0x06, 0x20, 0x00,
+    0x00, 0x06, 0x27, 0x00, 0x00, 0x06, 0x31, 0x00, 0x00, 0x06, 0x37, 0x00,
+    0x00, 0x06, 0x3e, 0x00, 0x00, 0x06, 0x45, 0x00, 0x00, 0x06, 0x4c, 0x00,
+    0x00, 0x06, 0x54, 0x00, 0x00, 0x06, 0x5b, 0x00, 0x00, 0x06, 0x62, 0x00,
+    0x00, 0x06, 0x69, 0x00, 0x00, 0x06, 0x6e, 0x00, 0x00, 0x06, 0x72, 0x00,
+    0x00, 0x06, 0x79, 0x00, 0x00, 0x06, 0x7f, 0x00, 0x00, 0x06, 0x84, 0x00,
+    0x00, 0x06, 0x8c, 0x00, 0x00, 0x06, 0x94, 0x00, 0x00, 0x06, 0x9b, 0x00,
+    0x00, 0x06, 0xa1, 0x00, 0x00, 0x06, 0xa8, 0x00, 0x00, 0x06, 0xb0, 0x00,
+    0x00, 0x06, 0xb6, 0x00, 0x00, 0x06, 0xbd, 0x00, 0x00, 0x06, 0xc1, 0x00,
+    0x00, 0x06, 0xc9, 0x00, 0x00, 0x06, 0xd0, 0x00, 0x00, 0x06, 0xd7, 0x00,
+    0x00, 0x06, 0xde, 0x00, 0x00, 0x06, 0xe5, 0x00, 0x00, 0x06, 0xec, 0x00,
+    0x00, 0x06, 0xf4, 0x00, 0x00, 0x06, 0xfc, 0x00, 0x00, 0x07, 0x02, 0x00,
+    0x00, 0x07, 0x0a, 0x00, 0x00, 0x07, 0x12, 0x00, 0x00, 0x07, 0x1a, 0x00,
+    0x00, 0x07, 0x22, 0x00, 0x00, 0x07, 0x29, 0x00, 0x00, 0x07, 0x30, 0x00,
+    0x00, 0x07, 0x35, 0x00, 0x00, 0x07, 0x3e, 0x00, 0x00, 0x07, 0x46, 0x00,
+    0x00, 0x07, 0x4a, 0x00, 0x00, 0x07, 0x50, 0x00, 0x00, 0x07, 0x58, 0x00,
+    0x00, 0x07, 0x5d, 0x00, 0x00, 0x07, 0x62, 0x00, 0x00, 0x07, 0x6a, 0x00,
+    0x00, 0x07, 0x71, 0x00, 0x00, 0x07, 0x76, 0x00, 0x00, 0x07, 0x7f, 0x00,
+    0x00, 0x07, 0x84, 0x00, 0x00, 0x07, 0x8d, 0x00, 0x00, 0x07, 0x95, 0x00,
+    0x00, 0x07, 0x9c, 0x00, 0x00, 0x07, 0xa4, 0x00, 0x00, 0x07, 0xab, 0x00,
+    0x00, 0x07, 0xb3, 0x00, 0x00, 0x07, 0xbb, 0x00, 0x00, 0x07, 0xc2, 0x00,
+    0x00, 0x07, 0xc9, 0x00, 0x00, 0x07, 0xd0, 0x00, 0x00, 0x07, 0xd8, 0x00,
+    0x00, 0x07, 0xe1, 0x00, 0x00, 0x07, 0xe7, 0x00, 0x00, 0x07, 0xed, 0x00,
+    0x00, 0x07, 0xf3, 0x00, 0x00, 0x07, 0xfd, 0x00, 0x00, 0x08, 0x06, 0x00,
+    0x00, 0x08, 0x0b, 0x00, 0x00, 0x08, 0x13, 0x00, 0x00, 0x08, 0x1c, 0x00,
+    0x00, 0x08, 0x22, 0x00, 0x00, 0x08, 0x28, 0x00, 0x00, 0x08, 0x2d, 0x00,
+    0x00, 0x08, 0x34, 0x00, 0x00, 0x08, 0x39, 0x00, 0x00, 0x08, 0x3e, 0x00,
+    0x00, 0x08, 0x45, 0x00, 0x00, 0x08, 0x4c, 0x00, 0x00, 0x08, 0x55, 0x00,
+    0x00, 0x08, 0x5c, 0x00, 0x00, 0x08, 0x61, 0x00, 0x00, 0x08, 0x68, 0x00,
+    0x00, 0x08, 0x6e, 0x00, 0x00, 0x08, 0x75, 0x00, 0x00, 0x08, 0x7e, 0x00,
+    0x00, 0x08, 0x85, 0x00, 0x00, 0x08, 0x8b, 0x00, 0x00, 0x08, 0x90, 0x00,
+    0x00, 0x08, 0x97, 0x00, 0x00, 0x08, 0x9d, 0x00, 0x00, 0x08, 0xa4, 0x00,
+    0x00, 0x08, 0xac, 0x00, 0x00, 0x08, 0xb3, 0x00, 0x00, 0x08, 0xba, 0x00,
+    0x00, 0x08, 0xbf, 0x00, 0x00, 0x08, 0xc5, 0x00, 0x00, 0x08, 0xca, 0x00,
+    0x00, 0x08, 0xd1, 0x00, 0x00, 0x08, 0xda, 0x00, 0x00, 0x08, 0xe0, 0x00,
+    0x00, 0x08, 0xe8, 0x00, 0x00, 0x08, 0xee, 0x00, 0x00, 0x08, 0xf4, 0x00,
+    0x00, 0x08, 0xfb, 0x00, 0x00, 0x09, 0x01, 0x00, 0x00, 0x09, 0x0b, 0x00,
+    0x00, 0x09, 0x13, 0x00, 0x00, 0x09, 0x1a, 0x00, 0x00, 0x09, 0x20, 0x00,
+    0x00, 0x09, 0x26, 0x00, 0x00, 0x09, 0x2d, 0x00, 0x00, 0x09, 0x34, 0x00,
+    0x00, 0x09, 0x3d, 0x00, 0x00, 0x09, 0x43, 0x00, 0x00, 0x09, 0x4b, 0x00,
+    0x00, 0x09, 0x54, 0x00, 0x00, 0x09, 0x5b, 0x00, 0x00, 0x09, 0x63, 0x00,
+    0x00, 0x09, 0x6b, 0x00, 0x00, 0x09, 0x72, 0x00, 0x00, 0x09, 0x79, 0x00,
+    0x00, 0x09, 0x83, 0x00, 0x00, 0x09, 0x8b, 0x00, 0x00, 0x09, 0x92, 0x00,
+    0x00, 0x09, 0x97, 0x00, 0x00, 0x09, 0x9d, 0x00, 0x00, 0x09, 0xa4, 0x00,
+    0x00, 0x09, 0xa9, 0x00, 0x00, 0x09, 0xae, 0x00, 0x00, 0x09, 0xb3, 0x00,
+    0x00, 0x09, 0xbc, 0x00, 0x00, 0x09, 0xc3, 0x00, 0x00, 0x09, 0xc9, 0x00,
+    0x00, 0x09, 0xd0, 0x00, 0x00, 0x09, 0xd8, 0x00, 0x00, 0x09, 0xe0, 0x00,
+    0x00, 0x09, 0xe5, 0x00, 0x00, 0x09, 0xec, 0x00, 0x00, 0x09, 0xf4, 0x00,
+    0x00, 0x09, 0xfa, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x00, 0x0a, 0x09, 0x00,
+    0x00, 0x0a, 0x11, 0x00, 0x00, 0x0a, 0x18, 0x00, 0x00, 0x0a, 0x1d, 0x00,
+    0x00, 0x0a, 0x23, 0x00, 0x00, 0x0a, 0x2b, 0x00, 0x00, 0x0a, 0x32, 0x00,
+    0x00, 0x0a, 0x38, 0x00, 0x00, 0x0a, 0x3f, 0x00, 0x00, 0x0a, 0x4a, 0x00,
+    0x00, 0x0a, 0x53, 0x00, 0x00, 0x0a, 0x5a, 0x00, 0x00, 0x0a, 0x62, 0x00,
+    0x00, 0x0a, 0x69, 0x00, 0x00, 0x0a, 0x6e, 0x00, 0x00, 0x0a, 0x76, 0x00,
+    0x00, 0x0a, 0x7d, 0x00, 0x00, 0x0a, 0x84, 0x00, 0x00, 0x0a, 0x8c, 0x00,
+    0x00, 0x0a, 0x93, 0x00, 0x00, 0x0a, 0x9b, 0x00, 0x00, 0x0a, 0xa3, 0x00,
+    0x00, 0x0a, 0xad, 0x00, 0x00, 0x0a, 0xb3, 0x00, 0x00, 0x0a, 0xba, 0x00,
+    0x00, 0x0a, 0xc3, 0x00, 0x00, 0x0a, 0xca, 0x00, 0x00, 0x0a, 0xcf, 0x00,
+    0x00, 0x0a, 0xd6, 0x00, 0x00, 0x0a, 0xdd, 0x00, 0x00, 0x0a, 0xe5, 0x00,
+    0x00, 0x0a, 0xec, 0x00, 0x00, 0x0a, 0xf3, 0x00, 0x00, 0x0a, 0xfb, 0x00,
+    0x00, 0x0b, 0x03, 0x00, 0x00, 0x0b, 0x08, 0x00, 0x00, 0x0b, 0x0e, 0x00,
+    0x00, 0x0b, 0x14, 0x00, 0x00, 0x0b, 0x1a, 0x00, 0x00, 0x0b, 0x22, 0x00,
+    0x00, 0x0b, 0x27, 0x00, 0x00, 0x0b, 0x2d, 0x00, 0x00, 0x0b, 0x35, 0x00,
+    0x00, 0x0b, 0x3a, 0x00, 0x00, 0x0b, 0x43, 0x00, 0x00, 0x0b, 0x4c, 0x00,
+    0x00, 0x0b, 0x54, 0x00, 0x00, 0x0b, 0x5c, 0x00, 0x00, 0x0b, 0x65, 0x00,
+    0x00, 0x0b, 0x6b, 0x00, 0x00, 0x0b, 0x71, 0x00, 0x00, 0x0b, 0x77, 0x00,
+    0x00, 0x0b, 0x82, 0x00, 0x00, 0x0b, 0x89, 0x00, 0x00, 0x0b, 0x8f, 0x00,
+    0x00, 0x0b, 0x97, 0x00, 0x00, 0x0b, 0xa0, 0x00, 0x00, 0x0b, 0xa5, 0x00,
+    0x00, 0x0b, 0xab, 0x00, 0x00, 0x0b, 0xb0, 0x00, 0x00, 0x0b, 0xb9, 0x00,
+    0x00, 0x0b, 0xbf, 0x00, 0x00, 0x0b, 0xc7, 0x00, 0x00, 0x0b, 0xcd, 0x00,
+    0x00, 0x0b, 0xd4, 0x00, 0x00, 0x0b, 0xda, 0x00, 0x00, 0x0b, 0xe2, 0x00,
+    0x00, 0x0b, 0xeb, 0x00, 0x00, 0x0b, 0xf3, 0x00, 0x00, 0x0b, 0xfb, 0x00,
+    0x00, 0x0c, 0x07, 0x00, 0x00, 0x0c, 0x0d, 0x00, 0x00, 0x0c, 0x13, 0x00,
+    0x00, 0x0c, 0x1a, 0x00, 0x00, 0x0c, 0x22, 0x00, 0x00, 0x0c, 0x2d, 0x00,
+    0x00, 0x0c, 0x37, 0x00, 0x00, 0x0c, 0x3e, 0x00, 0x00, 0x0c, 0x47, 0x00,
+    0x00, 0x0c, 0x4d, 0x00, 0x00, 0x0c, 0x56, 0x00, 0x00, 0x0c, 0x5a, 0x00,
+    0x00, 0x0c, 0x62, 0x00, 0x00, 0x0c, 0x68, 0x00, 0x00, 0x0c, 0x72, 0x00,
+    0x00, 0x0c, 0x7b, 0x00, 0x00, 0x0c, 0x81, 0x00, 0x00, 0x0c, 0x87, 0x00,
+    0x00, 0x0c, 0x8d, 0x00, 0x00, 0x0c, 0x93, 0x00, 0x00, 0x0c, 0x98, 0x00,
+    0x00, 0x0c, 0x9d, 0x00, 0x00, 0x0c, 0xa3, 0x00, 0x00, 0x0c, 0xa9, 0x00,
+    0x00, 0x0c, 0xae, 0x00, 0x00, 0x0c, 0xb8, 0x00, 0x00, 0x0c, 0xbd, 0x00,
+    0x00, 0x0c, 0xc4, 0x00, 0x00, 0x0c, 0xcb, 0x00, 0x00, 0x0c, 0xd2, 0x00,
+    0x00, 0x0c, 0xda, 0x00, 0x00, 0x0c, 0xe1, 0x00, 0x00, 0x0c, 0xe6, 0x00,
+    0x00, 0x0c, 0xee, 0x00, 0x00, 0x0c, 0xf5, 0x00, 0x00, 0x0c, 0xfb, 0x00,
+    0x00, 0x0d, 0x04, 0x00, 0x00, 0x0d, 0x0b, 0x00, 0x00, 0x0d, 0x12, 0x00,
+    0x00, 0x0d, 0x1b, 0x00, 0x00, 0x0d, 0x22, 0x00, 0x00, 0x0d, 0x27, 0x00,
+    0x00, 0x0d, 0x2c, 0x00, 0x00, 0x0d, 0x37, 0x00, 0x00, 0x0d, 0x3d, 0x00,
+    0x00, 0x0d, 0x43, 0x00, 0x00, 0x0d, 0x4a, 0x00, 0x00, 0x0d, 0x51, 0x00,
+    0x00, 0x0d, 0x58, 0x00, 0x00, 0x0d, 0x62, 0x00, 0x00, 0x0d, 0x6a, 0x00,
+    0x00, 0x0d, 0x6f, 0x00, 0x00, 0x0d, 0x75, 0x00, 0x00, 0x0d, 0x7f, 0x00,
+    0x00, 0x0d, 0x85, 0x00, 0x00, 0x0d, 0x8e, 0x00, 0x00, 0x0d, 0x96, 0x00,
+    0x00, 0x0d, 0x9b, 0x00, 0x00, 0x0d, 0xa2, 0x00, 0x00, 0x0d, 0xaa, 0x00,
+    0x00, 0x0d, 0xb2, 0x00, 0x00, 0x0d, 0xba, 0x00, 0x00, 0x0d, 0xc4, 0x00,
+    0x00, 0x0d, 0xc9, 0x00, 0x00, 0x0d, 0xd1, 0x00, 0x00, 0x0d, 0xd8, 0x00,
+    0x00, 0x0d, 0xdf, 0x00, 0x00, 0x0d, 0xe5, 0x00, 0x00, 0x0d, 0xec, 0x00,
+    0x00, 0x0d, 0xf4, 0x00, 0x00, 0x0d, 0xfc, 0x00, 0x00, 0x0e, 0x04, 0x00,
+    0x00, 0x0e, 0x0c, 0x00, 0x00, 0x0e, 0x12, 0x00, 0x00, 0x0e, 0x1c, 0x00,
+    0x00, 0x0e, 0x21, 0x00, 0x00, 0x0e, 0x27, 0x00, 0x00, 0x0e, 0x2c, 0x00,
+    0x00, 0x0e, 0x32, 0x00, 0x00, 0x0e, 0x39, 0x00, 0x00, 0x0e, 0x3f, 0x00,
+    0x00, 0x0e, 0x47, 0x00, 0x00, 0x0e, 0x51, 0x00, 0x00, 0x0e, 0x57, 0x00,
+    0x00, 0x0e, 0x5e, 0x00, 0x00, 0x0e, 0x64, 0x00, 0x00, 0x0e, 0x6d, 0x00,
+    0x00, 0x0e, 0x77, 0x00, 0x00, 0x0e, 0x7e, 0x00, 0x00, 0x0e, 0x83, 0x00,
+    0x00, 0x0e, 0x8a, 0x00, 0x00, 0x0e, 0x8f, 0x00, 0x00, 0x0e, 0x97, 0x00,
+    0x00, 0x0e, 0x9f, 0x00, 0x00, 0x0e, 0xa8, 0x00, 0x00, 0x0e, 0xb0, 0x00,
+    0x00, 0x0e, 0xb8, 0x00, 0x00, 0x0e, 0xbd, 0x00, 0x00, 0x0e, 0xc4, 0x00,
+    0x00, 0x0e, 0xca, 0x00, 0x00, 0x0e, 0xd2, 0x00, 0x00, 0x0e, 0xdb, 0x00,
+    0x00, 0x0e, 0xe3, 0x00, 0x00, 0x0e, 0xeb, 0x00, 0x00, 0x0e, 0xf5, 0x00,
+    0x00, 0x0e, 0xfb, 0x00, 0x00, 0x0f, 0x01, 0x00, 0x00, 0x0f, 0x06, 0x00,
+    0x00, 0x0f, 0x0c, 0x00, 0x00, 0x0f, 0x13, 0x00, 0x00, 0x0f, 0x19, 0x00,
+    0x00, 0x0f, 0x21, 0x00, 0x00, 0x0f, 0x2b, 0x00, 0x00, 0x0f, 0x32, 0x00,
+    0x00, 0x0f, 0x3a, 0x00, 0x00, 0x0f, 0x40, 0x00, 0x00, 0x0f, 0x48, 0x00,
+    0x00, 0x0f, 0x50, 0x00, 0x00, 0x0f, 0x58, 0x00, 0x00, 0x0f, 0x60, 0x00,
+    0x00, 0x0f, 0x65, 0x00, 0x00, 0x0f, 0x6b, 0x00, 0x00, 0x0f, 0x72, 0x00,
+    0x00, 0x0f, 0x7a, 0x00, 0x00, 0x0f, 0x7f, 0x00, 0x00, 0x0f, 0x84, 0x00,
+    0x00, 0x0f, 0x8c, 0x00, 0x00, 0x0f, 0x93, 0x00, 0x00, 0x0f, 0x9d, 0x00,
+    0x00, 0x0f, 0xa7, 0x00, 0x00, 0x0f, 0xad, 0x00, 0x00, 0x0f, 0xb4, 0x00,
+    0x00, 0x0f, 0xb9, 0x00, 0x00, 0x0f, 0xc0, 0x00, 0x00, 0x0f, 0xc9, 0x00,
+    0x00, 0x0f, 0xd0, 0x00, 0x00, 0x0f, 0xd7, 0x00, 0x00, 0x0f, 0xdf, 0x00,
+    0x00, 0x0f, 0xe5, 0x00, 0x00, 0x0f, 0xee, 0x00, 0x00, 0x0f, 0xf8, 0x00,
+    0x00, 0x0f, 0xff, 0x00, 0x00, 0x10, 0x05, 0x00, 0x00, 0x10, 0x0e, 0x00,
+    0x00, 0x10, 0x16, 0x00, 0x00, 0x10, 0x1e, 0x00, 0x00, 0x10, 0x23, 0x00,
+    0x00, 0x10, 0x2a, 0x00, 0x00, 0x10, 0x30, 0x00, 0x00, 0x10, 0x3a, 0x00,
+    0x00, 0x10, 0x42, 0x00, 0x00, 0x10, 0x4a, 0x00, 0x00, 0x10, 0x52, 0x00,
+    0x00, 0x10, 0x57, 0x00, 0x00, 0x10, 0x5e, 0x00, 0x00, 0x10, 0x64, 0x00,
+    0x00, 0x10, 0x6a, 0x00, 0x00, 0x10, 0x72, 0x00, 0x00, 0x10, 0x78, 0x00,
+    0x00, 0x10, 0x7e, 0x00, 0x00, 0x10, 0x84, 0x00, 0x00, 0x10, 0x8c, 0x00,
+    0x00, 0x10, 0x94, 0x00, 0x00, 0x10, 0x9b, 0x00, 0x00, 0x10, 0xa4, 0x00,
+    0x00, 0x10, 0xac, 0x00, 0x00, 0x10, 0xb2, 0x00, 0x00, 0x10, 0xbd, 0x00,
+    0x00, 0x10, 0xc2, 0x00, 0x00, 0x10, 0xc9, 0x00, 0x00, 0x10, 0xd1, 0x00,
+    0x00, 0x10, 0xd8, 0x00, 0x00, 0x10, 0xde, 0x00, 0x00, 0x10, 0xe5, 0x00,
+    0x00, 0x10, 0xeb, 0x00, 0x00, 0x10, 0xf1, 0x00, 0x00, 0x10, 0xf6, 0x00,
+    0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x05, 0x00, 0x00, 0x11, 0x0b, 0x00,
+    0x00, 0x11, 0x17, 0x00, 0x00, 0x11, 0x1f, 0x00, 0x00, 0x11, 0x27, 0x00,
+    0x00, 0x11, 0x2e, 0x00, 0x00, 0x11, 0x35, 0x00, 0x00, 0x11, 0x3b, 0x00,
+    0x00, 0x11, 0x44, 0x00, 0x00, 0x11, 0x4b, 0x00, 0x00, 0x11, 0x53, 0x00,
+    0x00, 0x11, 0x5a, 0x00, 0x00, 0x11, 0x61, 0x00, 0x00, 0x11, 0x6a, 0x00,
+    0x00, 0x11, 0x70, 0x00, 0x00, 0x11, 0x79, 0x00, 0x00, 0x11, 0x82, 0x00,
+    0x00, 0x11, 0x89, 0x00, 0x00, 0x11, 0x93, 0x00, 0x00, 0x11, 0x9a, 0x00,
+    0x00, 0x11, 0xa2, 0x00, 0x00, 0x11, 0xaa, 0x00, 0x00, 0x11, 0xb3, 0x00,
+    0x00, 0x11, 0xb7, 0x00, 0x00, 0x11, 0xbe, 0x00, 0x00, 0x11, 0xc4, 0x00,
+    0x00, 0x11, 0xcc, 0x00, 0x00, 0x11, 0xd3, 0x00, 0x00, 0x11, 0xd8, 0x00,
+    0x00, 0x11, 0xe0, 0x00, 0x00, 0x11, 0xeb, 0x00, 0x00, 0x11, 0xf1, 0x00,
+    0x00, 0x11, 0xf7, 0x00, 0x00, 0x11, 0xff, 0x00, 0x00, 0x12, 0x05, 0x00,
+    0x00, 0x12, 0x0d, 0x00, 0x00, 0x12, 0x15, 0x00, 0x00, 0x12, 0x1d, 0x00,
+    0x00, 0x12, 0x24, 0x00, 0x00, 0x12, 0x2b, 0x00, 0x00, 0x12, 0x33, 0x00,
+    0x00, 0x12, 0x3a, 0x00, 0x00, 0x12, 0x41, 0x00, 0x00, 0x12, 0x46, 0x00,
+    0x00, 0x12, 0x4e, 0x00, 0x00, 0x12, 0x56, 0x00, 0x00, 0x12, 0x5d, 0x00,
+    0x00, 0x12, 0x63, 0x00, 0x00, 0x12, 0x69, 0x00, 0x00, 0x12, 0x6f, 0x00,
+    0x00, 0x12, 0x78, 0x00, 0x00, 0x12, 0x80, 0x00, 0x00, 0x12, 0x86, 0x00,
+    0x00, 0x12, 0x8d, 0x00, 0x00, 0x12, 0x95, 0x00, 0x00, 0x12, 0x9c, 0x00,
+    0x00, 0x12, 0xa5, 0x00, 0x00, 0x12, 0xaa, 0x00, 0x00, 0x12, 0xb0, 0x00,
+    0x00, 0x12, 0xbb, 0x00, 0x00, 0x12, 0xc2, 0x00, 0x00, 0x12, 0xc9, 0x00,
+    0x00, 0x12, 0xd2, 0x00, 0x00, 0x12, 0xd7, 0x00, 0x00, 0x12, 0xdd, 0x00,
+    0x00, 0x12, 0xe2, 0x00, 0x00, 0x12, 0xea, 0x00, 0x00, 0x12, 0xf1, 0x00,
+    0x00, 0x12, 0xf6, 0x00, 0x00, 0x12, 0xfb, 0x00, 0x00, 0x13, 0x03, 0x00,
+    0x00, 0x13, 0x0c, 0x00, 0x00, 0x13, 0x16, 0x00, 0x00, 0x13, 0x1c, 0x00,
+    0x00, 0x13, 0x22, 0x00, 0x00, 0x13, 0x28, 0x00, 0x00, 0x13, 0x30, 0x00,
+    0x00, 0x13, 0x38, 0x00, 0x00, 0x13, 0x3e, 0x00, 0x00, 0x13, 0x44, 0x00,
+    0x00, 0x13, 0x4d, 0x00, 0x00, 0x13, 0x55, 0x00, 0x00, 0x13, 0x5c, 0x00,
+    0x00, 0x13, 0x63, 0x00, 0x00, 0x13, 0x69, 0x00, 0x00, 0x13, 0x6e, 0x00,
+    0x00, 0x13, 0x74, 0x00, 0x00, 0x13, 0x7a, 0x00, 0x00, 0x13, 0x81, 0x00,
+    0x00, 0x13, 0x89, 0x00, 0x00, 0x13, 0x92, 0x00, 0x00, 0x13, 0x97, 0x00,
+    0x00, 0x13, 0x9d, 0x00, 0x00, 0x13, 0xa2, 0x00, 0x00, 0x13, 0xa8, 0x00,
+    0x00, 0x13, 0xaf, 0x00, 0x00, 0x13, 0xb5, 0x00, 0x00, 0x13, 0xbe, 0x00,
+    0x00, 0x13, 0xc4, 0x00, 0x00, 0x13, 0xcc, 0x00, 0x00, 0x13, 0xd1, 0x00,
+    0x00, 0x13, 0xd8, 0x00, 0x00, 0x13, 0xe3, 0x00, 0x00, 0x13, 0xed, 0x00,
+    0x00, 0x13, 0xf4, 0x00, 0x00, 0x13, 0xfb, 0x00, 0x00, 0x14, 0x03, 0x00,
+    0x00, 0x14, 0x08, 0x00, 0x00, 0x14, 0x0d, 0x00, 0x00, 0x14, 0x17, 0x00,
+    0x00, 0x14, 0x20, 0x00, 0x00, 0x14, 0x28, 0x00, 0x00, 0x14, 0x2f, 0x00,
+    0x00, 0x14, 0x35, 0x00, 0x00, 0x14, 0x3c, 0x00, 0x00, 0x14, 0x42, 0x00,
+    0x00, 0x14, 0x48, 0x00, 0x00, 0x14, 0x52, 0x00, 0x00, 0x14, 0x5a, 0x00,
+    0x00, 0x14, 0x65, 0x00, 0x00, 0x14, 0x6e, 0x00, 0x00, 0x14, 0x75, 0x00,
+    0x00, 0x14, 0x7e, 0x00, 0x00, 0x14, 0x83, 0x00, 0x00, 0x14, 0x88, 0x00,
+    0x00, 0x14, 0x90, 0x00, 0x00, 0x14, 0x9b, 0x00, 0x00, 0x14, 0xa2, 0x00,
+    0x00, 0x14, 0xa8, 0x00, 0x00, 0x14, 0xb2, 0x00, 0x00, 0x14, 0xb8, 0x00,
+    0x00, 0x14, 0xc0, 0x00, 0x00, 0x14, 0xc6, 0x00, 0x00, 0x14, 0xcb, 0x00,
+    0x00, 0x14, 0xd2, 0x00, 0x00, 0x14, 0xd8, 0x00, 0x00, 0x14, 0xe0, 0x00,
+    0x00, 0x14, 0xe6, 0x00, 0x00, 0x14, 0xf0, 0x00, 0x00, 0x14, 0xf7, 0x00,
+    0x00, 0x14, 0xfd, 0x00, 0x00, 0x15, 0x06, 0x00, 0x00, 0x15, 0x0b, 0x00,
+    0x00, 0x15, 0x10, 0x00, 0x00, 0x15, 0x19, 0x00, 0x00, 0x15, 0x20, 0x00,
+    0x00, 0x15, 0x25, 0x00, 0x00, 0x15, 0x2c, 0x00, 0x00, 0x15, 0x31, 0x00,
+    0x00, 0x15, 0x37, 0x00, 0x00, 0x15, 0x3e, 0x00, 0x00, 0x15, 0x43, 0x00,
+    0x00, 0x15, 0x4c, 0x00, 0x00, 0x15, 0x54, 0x00, 0x00, 0x15, 0x5d, 0x00,
+    0x00, 0x15, 0x64, 0x00, 0x00, 0x15, 0x6a, 0x00, 0x00, 0x15, 0x70, 0x00,
+    0x00, 0x15, 0x76, 0x00, 0x00, 0x15, 0x7c, 0x00, 0x00, 0x15, 0x85, 0x00,
+    0x00, 0x15, 0x89, 0x00, 0x00, 0x15, 0x8f, 0x00, 0x00, 0x15, 0x99, 0x00,
+    0x00, 0x15, 0x9f, 0x00, 0x00, 0x15, 0xa7, 0x00, 0x00, 0x15, 0xae, 0x00,
+    0x00, 0x15, 0xb5, 0x00, 0x00, 0x15, 0xbe, 0x00, 0x00, 0x15, 0xc7, 0x00,
+    0x00, 0x15, 0xcf, 0x00, 0x00, 0x15, 0xd6, 0x00, 0x00, 0x15, 0xdd, 0x00,
+    0x00, 0x15, 0xe7, 0x00, 0x00, 0x15, 0xed, 0x00, 0x00, 0x15, 0xf5, 0x00,
+    0x00, 0x15, 0xfb, 0x00, 0x00, 0x16, 0x05, 0x00, 0x00, 0x16, 0x0d, 0x00,
+    0x00, 0x16, 0x15, 0x00, 0x00, 0x16, 0x1d, 0x00, 0x00, 0x16, 0x25, 0x00,
+    0x00, 0x16, 0x2a, 0x00, 0x00, 0x16, 0x2e, 0x00, 0x00, 0x16, 0x34, 0x00,
+    0x00, 0x16, 0x3c, 0x00, 0x00, 0x16, 0x43, 0x00, 0x00, 0x16, 0x4b, 0x00,
+    0x00, 0x16, 0x52, 0x00, 0x00, 0x16, 0x5a, 0x00, 0x00, 0x16, 0x62, 0x00,
+    0x00, 0x16, 0x6c, 0x00, 0x00, 0x16, 0x71, 0x00, 0x00, 0x16, 0x78, 0x00,
+    0x00, 0x16, 0x7f, 0x00, 0x00, 0x16, 0x86, 0x00, 0x00, 0x16, 0x8d, 0x00,
+    0x00, 0x16, 0x92, 0x00, 0x00, 0x16, 0x99, 0x00, 0x00, 0x16, 0xa0, 0x00,
+    0x00, 0x16, 0xa5, 0x00, 0x00, 0x16, 0xab, 0x00, 0x00, 0x16, 0xb1, 0x00,
+    0x00, 0x16, 0xbb, 0x00, 0x00, 0x16, 0xc3, 0x00, 0x00, 0x16, 0xca, 0x00,
+    0x00, 0x16, 0xcf, 0x00, 0x00, 0x16, 0xd7, 0x00, 0x00, 0x16, 0xe1, 0x00,
+    0x00, 0x16, 0xe7, 0x00, 0x00, 0x16, 0xee, 0x00, 0x00, 0x16, 0xf7, 0x00,
+    0x00, 0x16, 0xfe, 0x00, 0x00, 0x17, 0x05, 0x00, 0x00, 0x17, 0x0c, 0x00,
+    0x00, 0x17, 0x15, 0x00, 0x00, 0x17, 0x1b, 0x00, 0x00, 0x17, 0x23, 0x00,
+    0x00, 0x17, 0x2a, 0x00, 0x00, 0x17, 0x30, 0x00, 0x00, 0x17, 0x38, 0x00,
+    0x00, 0x17, 0x3f, 0x00, 0x00, 0x17, 0x46, 0x00, 0x00, 0x17, 0x4d, 0x00,
+    0x00, 0x17, 0x54, 0x00, 0x00, 0x17, 0x5c, 0x00, 0x00, 0x17, 0x62, 0x00,
+    0x00, 0x17, 0x6b, 0x00, 0x00, 0x17, 0x72, 0x00, 0x00, 0x17, 0x7a, 0x00,
+    0x00, 0x17, 0x80, 0x00, 0x00, 0x17, 0x86, 0x00, 0x00, 0x17, 0x8b, 0x00,
+    0x00, 0x17, 0x92, 0x00, 0x00, 0x17, 0x99, 0x00, 0x00, 0x17, 0xa0, 0x00,
+    0x00, 0x17, 0xa6, 0x00, 0x00, 0x17, 0xad, 0x00, 0x00, 0x17, 0xb5, 0x00,
+    0x00, 0x17, 0xbb, 0x00, 0x00, 0x17, 0xc2, 0x00, 0x00, 0x17, 0xca, 0x00,
+    0x00, 0x17, 0xd1, 0x00, 0x00, 0x17, 0xd8, 0x00, 0x00, 0x17, 0xdf, 0x00,
+    0x00, 0x17, 0xe5, 0x00, 0x00, 0x17, 0xed, 0x00, 0x00, 0x17, 0xf6, 0x00,
+    0x00, 0x17, 0xfd, 0x00, 0x00, 0x18, 0x02, 0x00, 0x00, 0x18, 0x07, 0x00,
+    0x00, 0x18, 0x10, 0x00, 0x00, 0x18, 0x15, 0x00, 0x00, 0x18, 0x1d, 0x00,
+    0x00, 0x18, 0x24, 0x00, 0x00, 0x18, 0x2a, 0x00, 0x00, 0x18, 0x31, 0x00,
+    0x00, 0x18, 0x35, 0x00, 0x00, 0x18, 0x3c, 0x00, 0x00, 0x18, 0x41, 0x00,
+    0x00, 0x18, 0x47, 0x00, 0x00, 0x18, 0x4c, 0x00, 0x00, 0x18, 0x55, 0x00,
+    0x00, 0x18, 0x59, 0x00, 0x00, 0x18, 0x61, 0x00, 0x00, 0x18, 0x67, 0x00,
+    0x00, 0x18, 0x71, 0x00, 0x00, 0x18, 0x7b, 0x00, 0x00, 0x18, 0x82, 0x00,
+    0x00, 0x18, 0x8a, 0x00, 0x00, 0x18, 0x91, 0x00, 0x00, 0x18, 0x98, 0x00,
+    0x00, 0x18, 0x9d, 0x00, 0x00, 0x18, 0xa3, 0x00, 0x00, 0x18, 0xaa, 0x00,
+    0x00, 0x18, 0xaf, 0x00, 0x00, 0x18, 0xb5, 0x00, 0x00, 0x18, 0xc1, 0x00,
+    0x00, 0x18, 0xcc, 0x00, 0x00, 0x18, 0xd4, 0x00, 0x00, 0x18, 0xda, 0x00,
+    0x00, 0x18, 0xe1, 0x00, 0x00, 0x18, 0xeb, 0x00, 0x00, 0x18, 0xf3, 0x00,
+    0x00, 0x18, 0xfb, 0x00, 0x00, 0x19, 0x03, 0x00, 0x00, 0x19, 0x0a, 0x00,
+    0x00, 0x19, 0x0f, 0x00, 0x00, 0x19, 0x16, 0x00, 0x00, 0x19, 0x1e, 0x00,
+    0x00, 0x19, 0x26, 0x00, 0x00, 0x19, 0x2d, 0x00, 0x00, 0x19, 0x35, 0x00,
+    0x00, 0x19, 0x3b, 0x00, 0x00, 0x19, 0x45, 0x00, 0x00, 0x19, 0x4d, 0x00,
+    0x00, 0x19, 0x52, 0x00, 0x00, 0x19, 0x5a, 0x00, 0x00, 0x19, 0x60, 0x00,
+    0x00, 0x19, 0x68, 0x00, 0x00, 0x19, 0x6f, 0x00, 0x00, 0x19, 0x77, 0x00,
+    0x00, 0x19, 0x7e, 0x00, 0x00, 0x19, 0x83, 0x00, 0x00, 0x19, 0x8a, 0x00,
+    0x00, 0x19, 0x8f, 0x00, 0x00, 0x19, 0x96, 0x00, 0x00, 0x19, 0x9f, 0x00,
+    0x00, 0x19, 0xa6, 0x00, 0x00, 0x19, 0xaf, 0x00, 0x00, 0x19, 0xb9, 0x00,
+    0x00, 0x19, 0xc0, 0x00, 0x00, 0x19, 0xc5, 0x00, 0x00, 0x19, 0xcd, 0x00,
+    0x00, 0x19, 0xd4, 0x00, 0x00, 0x19, 0xda, 0x00, 0x00, 0x19, 0xe2, 0x00,
+    0x00, 0x19, 0xe7, 0x00, 0x00, 0x19, 0xf1, 0x00, 0x00, 0x19, 0xf7, 0x00,
+    0x00, 0x19, 0xff, 0x00, 0x00, 0x1a, 0x05, 0x00, 0x00, 0x1a, 0x0c, 0x00,
+    0x00, 0x1a, 0x16, 0x00, 0x00, 0x1a, 0x1d, 0x00, 0x00, 0x1a, 0x24, 0x00,
+    0x00, 0x1a, 0x2a, 0x00, 0x00, 0x1a, 0x31, 0x00, 0x00, 0x1a, 0x39, 0x00,
+    0x00, 0x1a, 0x40, 0x00, 0x00, 0x1a, 0x47, 0x00, 0x00, 0x1a, 0x4f, 0x00,
+    0x00, 0x1a, 0x55, 0x00, 0x00, 0x1a, 0x5a, 0x00, 0x00, 0x1a, 0x5f, 0x00,
+    0x00, 0x1a, 0x66, 0x00, 0x00, 0x1a, 0x6f, 0x00, 0x00, 0x1a, 0x76, 0x00,
+    0x00, 0x1a, 0x7b, 0x00, 0x00, 0x1a, 0x81, 0x00, 0x00, 0x1a, 0x8a, 0x00,
+    0x00, 0x1a, 0x8f, 0x00, 0x00, 0x1a, 0x97, 0x00, 0x00, 0x1a, 0x9e, 0x00,
+    0x00, 0x1a, 0xa3, 0x00, 0x00, 0x1a, 0xaa, 0x00, 0x00, 0x1a, 0xb2, 0x00,
+    0x00, 0x1a, 0xba, 0x00, 0x00, 0x1a, 0xc0, 0x00, 0x00, 0x1a, 0xc5, 0x00,
+    0x00, 0x1a, 0xca, 0x00, 0x00, 0x1a, 0xd2, 0x00, 0x00, 0x1a, 0xd7, 0x00,
+    0x00, 0x1a, 0xdd, 0x00, 0x00, 0x1a, 0xe4, 0x00, 0x00, 0x1a, 0xec, 0x00,
+    0x00, 0x1a, 0xf3, 0x00, 0x00, 0x1a, 0xf9, 0x00, 0x00, 0x1b, 0x03, 0x00,
+    0x00, 0x1b, 0x08, 0x00, 0x00, 0x1b, 0x0f, 0x00, 0x00, 0x1b, 0x17, 0x00,
+    0x00, 0x1b, 0x1a, 0x00, 0x00, 0x1b, 0x22, 0x00, 0x00, 0x1b, 0x2b, 0x00,
+    0x00, 0x1b, 0x31, 0x00, 0x00, 0x1b, 0x3a, 0x00, 0x00, 0x1b, 0x41, 0x00,
+    0x00, 0x1b, 0x49, 0x00, 0x00, 0x1b, 0x4e, 0x00, 0x00, 0x1b, 0x55, 0x00,
+    0x00, 0x1b, 0x5d, 0x00, 0x00, 0x1b, 0x65, 0x00, 0x00, 0x1b, 0x6c, 0x00,
+    0x00, 0x1b, 0x72, 0x00, 0x00, 0x1b, 0x79, 0x00, 0x00, 0x1b, 0x7f, 0x00,
+    0x00, 0x1b, 0x87, 0x00, 0x00, 0x1b, 0x8f, 0x00, 0x00, 0x1b, 0x95, 0x00,
+    0x00, 0x1b, 0x9d, 0x00, 0x00, 0x1b, 0xa5, 0x00, 0x00, 0x1b, 0xad, 0x00,
+    0x00, 0x1b, 0xb3, 0x00, 0x00, 0x1b, 0xbd, 0x00, 0x00, 0x1b, 0xc5, 0x00,
+    0x00, 0x1b, 0xca, 0x00, 0x00, 0x1b, 0xcf, 0x00, 0x00, 0x1b, 0xd4, 0x00,
+    0x00, 0x1b, 0xda, 0x00, 0x00, 0x1b, 0xe2, 0x00, 0x00, 0x1b, 0xeb, 0x00,
+    0x00, 0x1b, 0xf1, 0x00, 0x00, 0x1b, 0xf8, 0x00, 0x00, 0x1b, 0xfe, 0x00,
+    0x00, 0x1c, 0x04, 0x00, 0x00, 0x1c, 0x0b, 0x00, 0x00, 0x1c, 0x12, 0x00,
+    0x00, 0x1c, 0x1c, 0x00, 0x00, 0x1c, 0x21, 0x00, 0x00, 0x1c, 0x2a, 0x00,
+    0x00, 0x1c, 0x30, 0x00, 0x00, 0x1c, 0x39, 0x00, 0x00, 0x1c, 0x41, 0x00,
+    0x00, 0x1c, 0x49, 0x00, 0x00, 0x1c, 0x51, 0x00, 0x00, 0x1c, 0x58, 0x00,
+    0x00, 0x1c, 0x5e, 0x00, 0x00, 0x1c, 0x64, 0x00, 0x00, 0x1c, 0x6e, 0x00,
+    0x00, 0x1c, 0x77, 0x00, 0x00, 0x1c, 0x7e, 0x00, 0x00, 0x1c, 0x84, 0x00,
+    0x00, 0x1c, 0x89, 0x00, 0x00, 0x1c, 0x92, 0x00, 0x00, 0x1c, 0x98, 0x00,
+    0x00, 0x1c, 0x9e, 0x00, 0x00, 0x1c, 0xa5, 0x00, 0x00, 0x1c, 0xab, 0x00,
+    0x00, 0x1c, 0xb2, 0x00, 0x00, 0x1c, 0xb9, 0x00, 0x00, 0x1c, 0xc3, 0x00,
+    0x00, 0x1c, 0xca, 0x00, 0x00, 0x1c, 0xd2, 0x00, 0x00, 0x1c, 0xd8, 0x00,
+    0x00, 0x1c, 0xdf, 0x00, 0x00, 0x1c, 0xe4, 0x00, 0x00, 0x1c, 0xeb, 0x00,
+    0x00, 0x1c, 0xf1, 0x00, 0x00, 0x1c, 0xfc, 0x00, 0x00, 0x1d, 0x05, 0x00,
+    0x00, 0x1d, 0x0c, 0x00, 0x00, 0x1d, 0x12, 0x00, 0x00, 0x1d, 0x18, 0x00,
+    0x00, 0x1d, 0x1d, 0x00, 0x00, 0x1d, 0x25, 0x00, 0x00, 0x1d, 0x2b, 0x00,
+    0x00, 0x1d, 0x30, 0x00, 0x00, 0x1d, 0x37, 0x00, 0x00, 0x1d, 0x40, 0x00,
+    0x00, 0x1d, 0x4a, 0x00, 0x00, 0x1d, 0x50, 0x00, 0x00, 0x1d, 0x56, 0x00,
+    0x00, 0x1d, 0x5d, 0x00, 0x00, 0x1d, 0x65, 0x00, 0x00, 0x1d, 0x6d, 0x00,
+    0x00, 0x1d, 0x74, 0x00, 0x00, 0x1d, 0x7a, 0x00, 0x00, 0x1d, 0x81, 0x00,
+    0x00, 0x1d, 0x86, 0x00, 0x00, 0x1d, 0x8e, 0x00, 0x00, 0x1d, 0x93, 0x00,
+    0x00, 0x1d, 0x9d, 0x00, 0x00, 0x1d, 0xa6, 0x00, 0x00, 0x1d, 0xab, 0x00,
+    0x00, 0x1d, 0xb1, 0x00, 0x00, 0x1d, 0xb5, 0x00, 0x00, 0x1d, 0xbe, 0x00,
+    0x00, 0x1d, 0xc6, 0x00, 0x00, 0x1d, 0xcd, 0x00, 0x00, 0x1d, 0xd5, 0x00,
+    0x00, 0x1d, 0xde, 0x00, 0x00, 0x1d, 0xe5, 0x00, 0x00, 0x1d, 0xeb, 0x00,
+    0x00, 0x1d, 0xf2, 0x00, 0x00, 0x1d, 0xf9, 0x00, 0x00, 0x1e, 0x00, 0x00,
+    0x00, 0x1e, 0x07, 0x00, 0x00, 0x1e, 0x0d, 0x00, 0x00, 0x1e, 0x13, 0x00,
+    0x00, 0x1e, 0x19, 0x00, 0x00, 0x1e, 0x20, 0x00, 0x00, 0x1e, 0x26, 0x00,
+    0x00, 0x1e, 0x2b, 0x00, 0x00, 0x1e, 0x31, 0x00, 0x00, 0x1e, 0x35, 0x00,
+    0x00, 0x1e, 0x3c, 0x00, 0x00, 0x1e, 0x47, 0x00, 0x00, 0x1e, 0x4c, 0x00,
+    0x00, 0x1e, 0x53, 0x00, 0x00, 0x1e, 0x5d, 0x00, 0x00, 0x1e, 0x65, 0x00,
+    0x00, 0x1e, 0x70, 0x00, 0x00, 0x1e, 0x78, 0x00, 0x00, 0x1e, 0x7e, 0x00,
+    0x00, 0x1e, 0x8a, 0x00, 0x00, 0x1e, 0x92, 0x00, 0x00, 0x1e, 0x98, 0x00,
+    0x00, 0x1e, 0xa0, 0x00, 0x00, 0x1e, 0xa9, 0x00, 0x00, 0x1e, 0xae, 0x00,
+    0x00, 0x1e, 0xb6, 0x00, 0x00, 0x1e, 0xbe, 0x00, 0x00, 0x1e, 0xc6, 0x00,
+    0x00, 0x1e, 0xcf, 0x00, 0x00, 0x1e, 0xd7, 0x00, 0x00, 0x1e, 0xdf, 0x00,
+    0x00, 0x1e, 0xe8, 0x00, 0x00, 0x1e, 0xed, 0x00, 0x00, 0x1e, 0xf4, 0x00,
+    0x00, 0x1e, 0xfb, 0x00, 0x00, 0x1f, 0x03, 0x00, 0x00, 0x1f, 0x0b, 0x00,
+    0x00, 0x1f, 0x11, 0x00, 0x00, 0x1f, 0x16, 0x00, 0x00, 0x1f, 0x1c, 0x00,
+    0x00, 0x1f, 0x25, 0x00, 0x00, 0x1f, 0x2d, 0x00, 0x00, 0x1f, 0x34, 0x00,
+    0x00, 0x1f, 0x3b, 0x00, 0x00, 0x1f, 0x42, 0x00, 0x00, 0x1f, 0x4b, 0x00,
+    0x00, 0x1f, 0x57, 0x00, 0x00, 0x1f, 0x5e, 0x00, 0x00, 0x1f, 0x66, 0x00,
+    0x00, 0x1f, 0x70, 0x00, 0x00, 0x1f, 0x76, 0x00, 0x00, 0x1f, 0x7e, 0x00,
+    0x00, 0x1f, 0x85, 0x00, 0x00, 0x1f, 0x8c, 0x00, 0x00, 0x1f, 0x93, 0x00,
+    0x00, 0x1f, 0x9b, 0x00, 0x00, 0x1f, 0xa2, 0x00, 0x00, 0x1f, 0xa9, 0x00,
+    0x00, 0x1f, 0xaf, 0x00, 0x00, 0x1f, 0xb4, 0x00, 0x00, 0x1f, 0xba, 0x00,
+    0x00, 0x1f, 0xc0, 0x00, 0x00, 0x1f, 0xc7, 0x00, 0x00, 0x1f, 0xce, 0x00,
+    0x00, 0x1f, 0xd6, 0x00, 0x00, 0x1f, 0xdc, 0x00, 0x00, 0x1f, 0xe3, 0x00,
+    0x00, 0x1f, 0xeb, 0x00, 0x00, 0x1f, 0xf1, 0x00, 0x00, 0x1f, 0xfa, 0x00,
+    0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x05, 0x00, 0x00, 0x20, 0x0d, 0x00,
+    0x00, 0x20, 0x15, 0x00, 0x00, 0x20, 0x1b, 0x00, 0x00, 0x20, 0x22, 0x00,
+    0x00, 0x20, 0x29, 0x00, 0x00, 0x20, 0x31, 0x00, 0x00, 0x20, 0x38, 0x00,
+    0x00, 0x20, 0x3f, 0x00, 0x00, 0x20, 0x44, 0x00, 0x00, 0x20, 0x4b, 0x00,
+    0x00, 0x20, 0x52, 0x00, 0x00, 0x20, 0x57, 0x00, 0x00, 0x20, 0x5f, 0x00,
+    0x00, 0x20, 0x68, 0x00, 0x00, 0x20, 0x6e, 0x00, 0x00, 0x20, 0x74, 0x00,
+    0x00, 0x20, 0x7a, 0x00, 0x00, 0x20, 0x84, 0x00, 0x00, 0x20, 0x8b, 0x00,
+    0x00, 0x20, 0x91, 0x00, 0x00, 0x20, 0x97, 0x00, 0x00, 0x20, 0x9c, 0x00,
+    0x00, 0x20, 0xa3, 0x00, 0x00, 0x20, 0xaa, 0x00, 0x00, 0x20, 0xb1, 0x00,
+    0x00, 0x20, 0xb6, 0x00, 0x00, 0x20, 0xc0, 0x00, 0x00, 0x20, 0xca, 0x00,
+    0x00, 0x20, 0xd0, 0x00, 0x00, 0x20, 0xd9, 0x00, 0x00, 0x20, 0xde, 0x00,
+    0x00, 0x20, 0xea, 0x00, 0x00, 0x20, 0xf2, 0x00, 0x00, 0x20, 0xfa, 0x00,
+    0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x07, 0x00, 0x00, 0x21, 0x0f, 0x00,
+    0x00, 0x21, 0x16, 0x00, 0x00, 0x21, 0x1d, 0x00, 0x00, 0x21, 0x24, 0x00,
+    0x00, 0x21, 0x2c, 0x00, 0x00, 0x21, 0x34, 0x00, 0x00, 0x21, 0x3d, 0x00,
+    0x00, 0x21, 0x41, 0x00, 0x00, 0x21, 0x47, 0x00, 0x00, 0x21, 0x4f, 0x00,
+    0x00, 0x21, 0x54, 0x00, 0x00, 0x21, 0x5b, 0x00, 0x00, 0x21, 0x62, 0x00,
+    0x00, 0x21, 0x69, 0x00, 0x00, 0x21, 0x71, 0x00, 0x00, 0x21, 0x77, 0x00,
+    0x00, 0x21, 0x7f, 0x00, 0x00, 0x21, 0x86, 0x00, 0x00, 0x21, 0x8c, 0x00,
+    0x00, 0x21, 0x92, 0x00, 0x00, 0x21, 0x9b, 0x00, 0x00, 0x21, 0xa1, 0x00,
+    0x00, 0x21, 0xa8, 0x00, 0x00, 0x21, 0xaf, 0x00, 0x00, 0x21, 0xb8, 0x00,
+    0x00, 0x21, 0xc2, 0x00, 0x00, 0x21, 0xce, 0x00, 0x00, 0x21, 0xd6, 0x00,
+    0x00, 0x21, 0xdd, 0x00, 0x00, 0x21, 0xe6, 0x00, 0x00, 0x21, 0xea, 0x00,
+    0x00, 0x21, 0xef, 0x00, 0x00, 0x21, 0xf5, 0x00, 0x00, 0x21, 0xfc, 0x00,
+    0x00, 0x22, 0x04, 0x00, 0x00, 0x22, 0x0a, 0x00, 0x00, 0x22, 0x12, 0x00,
+    0x00, 0x22, 0x18, 0x00, 0x00, 0x22, 0x1f, 0x00, 0x00, 0x22, 0x27, 0x00,
+    0x00, 0x22, 0x2e, 0x00, 0x00, 0x22, 0x34, 0x00, 0x00, 0x22, 0x3d, 0x00,
+    0x00, 0x22, 0x41, 0x00, 0x00, 0x22, 0x48, 0x00, 0x00, 0x22, 0x50, 0x00,
+    0x00, 0x22, 0x59, 0x00, 0x00, 0x22, 0x5e, 0x00, 0x00, 0x22, 0x65, 0x00,
+    0x00, 0x22, 0x6c, 0x00, 0x00, 0x22, 0x73, 0x00, 0x00, 0x22, 0x79, 0x00,
+    0x00, 0x22, 0x80, 0x00, 0x00, 0x22, 0x88, 0x00, 0x00, 0x22, 0x91, 0x00,
+    0x00, 0x22, 0x98, 0x00, 0x00, 0x22, 0xa0, 0x00, 0x00, 0x22, 0xa7, 0x00,
+    0x00, 0x22, 0xb2, 0x00, 0x00, 0x22, 0xb9, 0x00, 0x00, 0x22, 0xc0, 0x00,
+    0x00, 0x22, 0xc7, 0x00, 0x00, 0x22, 0xcd, 0x00, 0x00, 0x22, 0xd3, 0x00,
+    0x00, 0x22, 0xd8, 0x00, 0x00, 0x22, 0xe0, 0x00, 0x00, 0x22, 0xe8, 0x00,
+    0x00, 0x22, 0xf1, 0x00, 0x00, 0x22, 0xf8, 0x00, 0x00, 0x22, 0xff, 0x00,
+    0x00, 0x23, 0x07, 0x00, 0x00, 0x23, 0x0d, 0x00, 0x00, 0x23, 0x13, 0x00,
+    0x00, 0x23, 0x1c, 0x00, 0x00, 0x23, 0x23, 0x00, 0x00, 0x23, 0x2b, 0x00,
+    0x00, 0x23, 0x30, 0x00, 0x00, 0x23, 0x37, 0x00, 0x00, 0x23, 0x3d, 0x00,
+    0x00, 0x23, 0x42, 0x00, 0x00, 0x23, 0x49, 0x00, 0x00, 0x23, 0x4e, 0x00,
+    0x00, 0x23, 0x53, 0x00, 0x00, 0x23, 0x5c, 0x00, 0x00, 0x23, 0x64, 0x00,
+    0x00, 0x23, 0x6b, 0x00, 0x00, 0x23, 0x74, 0x00, 0x00, 0x23, 0x79, 0x00,
+    0x00, 0x23, 0x7c, 0x00, 0x00, 0x23, 0x86, 0x00, 0x00, 0x23, 0x8d, 0x00,
+    0x00, 0x23, 0x93, 0x00, 0x00, 0x23, 0x9a, 0x00, 0x00, 0x23, 0x9e, 0x00,
+    0x00, 0x23, 0xa4, 0x00, 0x00, 0x23, 0xab, 0x00, 0x00, 0x23, 0xb2, 0x00,
+    0x00, 0x23, 0xb7, 0x00, 0x00, 0x23, 0xbe, 0x00, 0x00, 0x23, 0xc3, 0x00,
+    0x00, 0x23, 0xc9, 0x00, 0x00, 0x23, 0xd0, 0x00, 0x00, 0x23, 0xd8, 0x00,
+    0x00, 0x23, 0xe1, 0x00, 0x00, 0x23, 0xea, 0x00, 0x00, 0x23, 0xf2, 0x00,
+    0x00, 0x23, 0xf9, 0x00, 0x00, 0x24, 0x01, 0x00, 0x00, 0x24, 0x07, 0x00,
+    0x00, 0x24, 0x11, 0x00, 0x00, 0x24, 0x1a, 0x00, 0x00, 0x24, 0x20, 0x00,
+    0x00, 0x24, 0x2a, 0x00, 0x00, 0x24, 0x31, 0x00, 0x00, 0x24, 0x36, 0x00,
+    0x00, 0x24, 0x3e, 0x00, 0x00, 0x24, 0x44, 0x00, 0x00, 0x24, 0x4a, 0x00,
+    0x00, 0x24, 0x51, 0x00, 0x00, 0x24, 0x57, 0x00, 0x00, 0x24, 0x60, 0x00,
+    0x00, 0x24, 0x6e, 0x00, 0x00, 0x24, 0x77, 0x00, 0x00, 0x24, 0x7c, 0x00,
+    0x00, 0x24, 0x81, 0x00, 0x00, 0x24, 0x8a, 0x00, 0x00, 0x24, 0x92, 0x00,
+    0x00, 0x24, 0x98, 0x00, 0x00, 0x24, 0xa2, 0x00, 0x00, 0x24, 0xaa, 0x00,
+    0x00, 0x24, 0xb3, 0x00, 0x00, 0x24, 0xbb, 0x00, 0x00, 0x24, 0xc2, 0x00,
+    0x00, 0x24, 0xcd, 0x00, 0x00, 0x24, 0xd5, 0x00, 0x00, 0x24, 0xdd, 0x00,
+    0x00, 0x24, 0xe4, 0x00, 0x00, 0x24, 0xed, 0x00, 0x00, 0x24, 0xf6, 0x00,
+    0x00, 0x24, 0xfd, 0x00, 0x00, 0x25, 0x05, 0x00, 0x00, 0x25, 0x0b, 0x00,
+    0x00, 0x25, 0x13, 0x00, 0x00, 0x25, 0x1a, 0x00, 0x00, 0x25, 0x20, 0x00,
+    0x00, 0x25, 0x27, 0x00, 0x00, 0x25, 0x2c, 0x00, 0x00, 0x25, 0x32, 0x00,
+    0x00, 0x25, 0x39, 0x00, 0x00, 0x25, 0x40, 0x00, 0x00, 0x25, 0x48, 0x00,
+    0x00, 0x25, 0x50, 0x00, 0x00, 0x25, 0x59, 0x00, 0x00, 0x25, 0x61, 0x00,
+    0x00, 0x25, 0x6a, 0x00, 0x00, 0x25, 0x73, 0x00, 0x00, 0x25, 0x7b, 0x00,
+    0x00, 0x25, 0x83, 0x00, 0x00, 0x25, 0x8a, 0x00, 0x00, 0x25, 0x93, 0x00,
+    0x00, 0x25, 0x9b, 0x00, 0x00, 0x25, 0xa2, 0x00, 0x00, 0x25, 0xa7, 0x00,
+    0x00, 0x25, 0xb0, 0x00, 0x00, 0x25, 0xb7, 0x00, 0x00, 0x25, 0xbd, 0x00,
+    0x00, 0x25, 0xc6, 0x00, 0x00, 0x25, 0xcb, 0x00, 0x00, 0x25, 0xd3, 0x00,
+    0x00, 0x25, 0xdc, 0x00, 0x00, 0x25, 0xe3, 0x00, 0x00, 0x25, 0xe8, 0x00,
+    0x00, 0x25, 0xf0, 0x00, 0x00, 0x25, 0xf8, 0x00, 0x00, 0x26, 0x02, 0x00,
+    0x00, 0x26, 0x0a, 0x00, 0x00, 0x26, 0x14, 0x00, 0x00, 0x26, 0x1b, 0x00,
+    0x00, 0x26, 0x22, 0x00, 0x00, 0x26, 0x2b, 0x00, 0x00, 0x26, 0x33, 0x00,
+    0x00, 0x26, 0x39, 0x00, 0x00, 0x26, 0x40, 0x00, 0x00, 0x26, 0x47, 0x00,
+    0x00, 0x26, 0x4d, 0x00, 0x00, 0x26, 0x54, 0x00, 0x00, 0x26, 0x5a, 0x00,
+    0x00, 0x26, 0x61, 0x00, 0x00, 0x26, 0x68, 0x00, 0x00, 0x26, 0x6f, 0x00,
+    0x00, 0x26, 0x74, 0x00, 0x00, 0x26, 0x7c, 0x00, 0x00, 0x26, 0x83, 0x00,
+    0x00, 0x26, 0x88, 0x00, 0x00, 0x26, 0x90, 0x00, 0x00, 0x26, 0x98, 0x00,
+    0x00, 0x26, 0x9e, 0x00, 0x00, 0x26, 0xa7, 0x00, 0x00, 0x26, 0xad, 0x00,
+    0x00, 0x26, 0xb6, 0x00, 0x00, 0x26, 0xbe, 0x00, 0x00, 0x26, 0xc3, 0x00,
+    0x00, 0x26, 0xcd, 0x00, 0x00, 0x26, 0xd2, 0x00, 0x00, 0x26, 0xd9, 0x00,
+    0x00, 0x26, 0xe0, 0x00, 0x00, 0x26, 0xe7, 0x00, 0x00, 0x26, 0xee, 0x00,
+    0x00, 0x26, 0xf4, 0x00, 0x00, 0x26, 0xfd, 0x00, 0x00, 0x27, 0x03, 0x00,
+    0x00, 0x27, 0x09, 0x00, 0x00, 0x27, 0x12, 0x00, 0x00, 0x27, 0x1b, 0x00,
+    0x00, 0x27, 0x24, 0x00, 0x00, 0x27, 0x2b, 0x00, 0x00, 0x27, 0x31, 0x00,
+    0x00, 0x27, 0x3a, 0x00, 0x00, 0x27, 0x41, 0x00, 0x00, 0x27, 0x4a, 0x00,
+    0x00, 0x27, 0x54, 0x00, 0x00, 0x27, 0x5a, 0x00, 0x00, 0x27, 0x63, 0x00,
+    0x00, 0x27, 0x6a, 0x00, 0x00, 0x27, 0x6f, 0x00, 0x00, 0x27, 0x75, 0x00,
+    0x00, 0x27, 0x7c, 0x00, 0x00, 0x27, 0x87, 0x00, 0x00, 0x27, 0x8d, 0x00,
+    0x00, 0x27, 0x94, 0x00, 0x00, 0x27, 0x99, 0x00, 0x00, 0x27, 0x9e, 0x00,
+    0x00, 0x27, 0xa5, 0x00, 0x00, 0x27, 0xae, 0x00, 0x00, 0x27, 0xb5, 0x00,
+    0x00, 0x27, 0xbc, 0x00, 0x00, 0x27, 0xc3, 0x00, 0x00, 0x27, 0xca, 0x00,
+    0x00, 0x27, 0xd0, 0x00, 0x00, 0x27, 0xd8, 0x00, 0x00, 0x27, 0xe2, 0x00,
+    0x00, 0x27, 0xe9, 0x00, 0x00, 0x27, 0xee, 0x00, 0x00, 0x27, 0xf5, 0x00,
+    0x00, 0x27, 0xfe, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x28, 0x10, 0x00,
+    0x00, 0x28, 0x15, 0x00, 0x00, 0x28, 0x1c, 0x00, 0x00, 0x28, 0x20, 0x00,
+    0x00, 0x28, 0x28, 0x00, 0x00, 0x28, 0x2e, 0x00, 0x00, 0x28, 0x34, 0x00,
+    0x00, 0x28, 0x3c, 0x00, 0x00, 0x28, 0x42, 0x00, 0x00, 0x28, 0x48, 0x00,
+    0x00, 0x28, 0x50, 0x00, 0x00, 0x28, 0x57, 0x00, 0x00, 0x28, 0x5e, 0x00,
+    0x00, 0x28, 0x65, 0x00, 0x00, 0x28, 0x69, 0x00, 0x00, 0x28, 0x6e, 0x00,
+    0x00, 0x28, 0x76, 0x00, 0x00, 0x28, 0x7f, 0x00, 0x00, 0x28, 0x87, 0x00,
+    0x00, 0x28, 0x8c, 0x00, 0x00, 0x28, 0x95, 0x00, 0x00, 0x28, 0x9c, 0x00,
+    0x00, 0x28, 0xa1, 0x00, 0x00, 0x28, 0xaa, 0x00, 0x00, 0x28, 0xb0, 0x00,
+    0x00, 0x28, 0xb8, 0x00, 0x00, 0x28, 0xc2, 0x00, 0x00, 0x28, 0xca, 0x00,
+    0x00, 0x28, 0xd2, 0x00, 0x00, 0x28, 0xd9, 0x00, 0x00, 0x28, 0xde, 0x00,
+    0x00, 0x28, 0xe8, 0x00, 0x00, 0x28, 0xef, 0x00, 0x00, 0x28, 0xf6, 0x00,
+    0x00, 0x28, 0xfe, 0x00, 0x00, 0x29, 0x03, 0x00, 0x00, 0x29, 0x0a, 0x00,
+    0x00, 0x29, 0x10, 0x00, 0x00, 0x29, 0x15, 0x00, 0x00, 0x29, 0x1c, 0x00,
+    0x00, 0x29, 0x22, 0x00, 0x00, 0x29, 0x29, 0x00, 0x00, 0x29, 0x32, 0x00,
+    0x00, 0x29, 0x39, 0x00, 0x00, 0x29, 0x41, 0x00, 0x00, 0x29, 0x49, 0x00,
+    0x00, 0x29, 0x4e, 0x00, 0x00, 0x29, 0x56, 0x00, 0x00, 0x29, 0x5b, 0x00,
+    0x00, 0x29, 0x63, 0x00, 0x00, 0x29, 0x6b, 0x00, 0x00, 0x29, 0x6f, 0x00,
+    0x00, 0x29, 0x77, 0x00, 0x00, 0x29, 0x7f, 0x00, 0x00, 0x29, 0x84, 0x00,
+    0x00, 0x29, 0x8c, 0x00, 0x00, 0x29, 0x96, 0x00, 0x00, 0x29, 0x9b, 0x00,
+    0x00, 0x29, 0xa1, 0x00, 0x00, 0x29, 0xa9, 0x00, 0x00, 0x29, 0xb2, 0x00,
+    0x00, 0x29, 0xb8, 0x00, 0x00, 0x29, 0xbe, 0x00, 0x00, 0x29, 0xc6, 0x00,
+    0x00, 0x29, 0xcc, 0x00, 0x00, 0x29, 0xd6, 0x00, 0x00, 0x29, 0xdd, 0x00,
+    0x00, 0x29, 0xe4, 0x00, 0x00, 0x29, 0xeb, 0x00, 0x00, 0x29, 0xf1, 0x00,
+    0x00, 0x29, 0xf6, 0x00, 0x00, 0x29, 0xfc, 0x00, 0x00, 0x2a, 0x04, 0x00,
+    0x00, 0x2a, 0x0d, 0x00, 0x00, 0x2a, 0x16, 0x00, 0x00, 0x2a, 0x1a, 0x00,
+    0x00, 0x2a, 0x22, 0x00, 0x00, 0x2a, 0x28, 0x00, 0x00, 0x2a, 0x2e, 0x00,
+    0x00, 0x2a, 0x34, 0x00, 0x00, 0x2a, 0x3b, 0x00, 0x00, 0x2a, 0x41, 0x00,
+    0x00, 0x2a, 0x49, 0x00, 0x00, 0x2a, 0x4f, 0x00, 0x00, 0x2a, 0x55, 0x00,
+    0x00, 0x2a, 0x5d, 0x00, 0x00, 0x2a, 0x65, 0x00, 0x00, 0x2a, 0x6c, 0x00,
+    0x00, 0x2a, 0x73, 0x00, 0x00, 0x2a, 0x7a, 0x00, 0x00, 0x2a, 0x7f, 0x00,
+    0x00, 0x2a, 0x85, 0x00, 0x00, 0x2a, 0x8e, 0x00, 0x00, 0x2a, 0x94, 0x00,
+    0x00, 0x2a, 0x99, 0x00, 0x00, 0x2a, 0x9f, 0x00, 0x00, 0x2a, 0xa9, 0x00,
+    0x00, 0x2a, 0xad, 0x00, 0x00, 0x2a, 0xb7, 0x00, 0x00, 0x2a, 0xbf, 0x00,
+    0x00, 0x2a, 0xc7, 0x00, 0x00, 0x2a, 0xcc, 0x00, 0x00, 0x2a, 0xd3, 0x00,
+    0x00, 0x2a, 0xd9, 0x00, 0x00, 0x2a, 0xe3, 0x00, 0x00, 0x2a, 0xeb, 0x00,
+    0x00, 0x2a, 0xf0, 0x00, 0x00, 0x2a, 0xf7, 0x00, 0x00, 0x2a, 0xfe, 0x00,
+    0x00, 0x2b, 0x06, 0x00, 0x00, 0x2b, 0x0e, 0x00, 0x00, 0x2b, 0x16, 0x00,
+    0x00, 0x2b, 0x1e, 0x00, 0x00, 0x2b, 0x26, 0x00, 0x00, 0x2b, 0x2d, 0x00,
+    0x00, 0x2b, 0x34, 0x00, 0x00, 0x2b, 0x3b, 0x00, 0x00, 0x2b, 0x43, 0x00,
+    0x00, 0x2b, 0x4a, 0x00, 0x00, 0x2b, 0x52, 0x00, 0x00, 0x2b, 0x5a, 0x00,
+    0x00, 0x2b, 0x62, 0x00, 0x00, 0x2b, 0x66, 0x00, 0x00, 0x2b, 0x6c, 0x00,
+    0x00, 0x2b, 0x74, 0x00, 0x00, 0x2b, 0x79, 0x00, 0x00, 0x2b, 0x81, 0x00,
+    0x00, 0x2b, 0x8b, 0x00, 0x00, 0x2b, 0x92, 0x00, 0x00, 0x2b, 0x99, 0x00,
+    0x00, 0x2b, 0xa0, 0x00, 0x00, 0x2b, 0xa8, 0x00, 0x00, 0x2b, 0xaf, 0x00,
+    0x00, 0x2b, 0xb5, 0x00, 0x00, 0x2b, 0xbe, 0x00, 0x00, 0x2b, 0xc6, 0x00,
+    0x00, 0x2b, 0xcf, 0x00, 0x00, 0x2b, 0xd4, 0x00, 0x00, 0x2b, 0xdb, 0x00,
+    0x00, 0x2b, 0xe4, 0x00, 0x00, 0x2b, 0xec, 0x00, 0x00, 0x2b, 0xf3, 0x00,
+    0x00, 0x2b, 0xfe, 0x00, 0x00, 0x2c, 0x04, 0x00, 0x00, 0x2c, 0x0c, 0x00,
+    0x00, 0x2c, 0x13, 0x00, 0x00, 0x2c, 0x1a, 0x00, 0x00, 0x2c, 0x21, 0x00,
+    0x00, 0x2c, 0x28, 0x00, 0x00, 0x2c, 0x30, 0x00, 0x00, 0x2c, 0x36, 0x00,
+    0x00, 0x2c, 0x3c, 0x00, 0x00, 0x2c, 0x42, 0x00, 0x00, 0x2c, 0x4a, 0x00,
+    0x00, 0x2c, 0x52, 0x00, 0x00, 0x2c, 0x5c, 0x00, 0x00, 0x2c, 0x65, 0x00,
+    0x00, 0x2c, 0x6c, 0x00, 0x00, 0x2c, 0x75, 0x00, 0x00, 0x2c, 0x7c, 0x00,
+    0x00, 0x2c, 0x81, 0x00, 0x00, 0x2c, 0x87, 0x00, 0x00, 0x2c, 0x8e, 0x00,
+    0x00, 0x2c, 0x93, 0x00, 0x00, 0x2c, 0x98, 0x00, 0x00, 0x2c, 0x9e, 0x00,
+    0x00, 0x2c, 0xa7, 0x00, 0x00, 0x2c, 0xaf, 0x00, 0x00, 0x2c, 0xb6, 0x00,
+    0x00, 0x2c, 0xbf, 0x00, 0x00, 0x2c, 0xc7, 0x00, 0x00, 0x2c, 0xd1, 0x00,
+    0x00, 0x2c, 0xd6, 0x00, 0x00, 0x2c, 0xdc, 0x00, 0x00, 0x2c, 0xe3, 0x00,
+    0x00, 0x2c, 0xe9, 0x00, 0x00, 0x2c, 0xf1, 0x00, 0x00, 0x2c, 0xf9, 0x00,
+    0x00, 0x2d, 0x02, 0x00, 0x00, 0x2d, 0x0b, 0x00, 0x00, 0x2d, 0x15, 0x00,
+    0x00, 0x2d, 0x1c, 0x00, 0x00, 0x2d, 0x21, 0x00, 0x00, 0x2d, 0x29, 0x00,
+    0x00, 0x2d, 0x2d, 0x00, 0x00, 0x2d, 0x35, 0x00, 0x00, 0x2d, 0x3b, 0x00,
+    0x00, 0x2d, 0x43, 0x00, 0x00, 0x2d, 0x48, 0x00, 0x00, 0x2d, 0x50, 0x00,
+    0x00, 0x2d, 0x56, 0x00, 0x00, 0x2d, 0x5b, 0x00, 0x00, 0x2d, 0x62, 0x00,
+    0x00, 0x2d, 0x67, 0x00, 0x00, 0x2d, 0x6e, 0x00, 0x00, 0x2d, 0x75, 0x00,
+    0x00, 0x2d, 0x7b, 0x00, 0x00, 0x2d, 0x84, 0x00, 0x00, 0x2d, 0x8b, 0x00,
+    0x00, 0x2d, 0x93, 0x00, 0x00, 0x2d, 0x9b, 0x00, 0x00, 0x2d, 0xa1, 0x00,
+    0x00, 0x2d, 0xa7, 0x00, 0x00, 0x2d, 0xad, 0x00, 0x00, 0x2d, 0xb5, 0x00,
+    0x00, 0x2d, 0xbe, 0x00, 0x00, 0x2d, 0xc3, 0x00, 0x00, 0x2d, 0xcc, 0x00,
+    0x00, 0x2d, 0xd1, 0x00, 0x00, 0x2d, 0xd7, 0x00, 0x00, 0x2d, 0xdd, 0x00,
+    0x00, 0x2d, 0xe7, 0x00, 0x00, 0x2d, 0xed, 0x00, 0x00, 0x2d, 0xf3, 0x00,
+    0x00, 0x2d, 0xfb, 0x00, 0x00, 0x2e, 0x03, 0x00, 0x00, 0x2e, 0x0b, 0x00,
+    0x00, 0x2e, 0x12, 0x00, 0x00, 0x2e, 0x18, 0x00, 0x00, 0x2e, 0x20, 0x00,
+    0x00, 0x2e, 0x27, 0x00, 0x00, 0x2e, 0x2f, 0x00, 0x00, 0x2e, 0x36, 0x00,
+    0x00, 0x2e, 0x3d, 0x00, 0x00, 0x2e, 0x42, 0x00, 0x00, 0x2e, 0x4a, 0x00,
+    0x00, 0x2e, 0x53, 0x00, 0x00, 0x2e, 0x5a, 0x00, 0x00, 0x2e, 0x62, 0x00,
+    0x00, 0x2e, 0x67, 0x00, 0x00, 0x2e, 0x6d, 0x00, 0x00, 0x2e, 0x73, 0x00,
+    0x00, 0x2e, 0x7d, 0x00, 0x00, 0x2e, 0x85, 0x00, 0x00, 0x2e, 0x8d, 0x00,
+    0x00, 0x2e, 0x94, 0x00, 0x00, 0x2e, 0x9d, 0x00, 0x00, 0x2e, 0xa4, 0x00,
+    0x00, 0x2e, 0xac, 0x00, 0x00, 0x2e, 0xb4, 0x00, 0x00, 0x2e, 0xbb, 0x00,
+    0x00, 0x2e, 0xc6, 0x00, 0x00, 0x2e, 0xcd, 0x00, 0x00, 0x2e, 0xd7, 0x00,
+    0x00, 0x2e, 0xde, 0x00, 0x00, 0x2e, 0xe5, 0x00, 0x00, 0x2e, 0xec, 0x00,
+    0x00, 0x2e, 0xf3, 0x00, 0x00, 0x2e, 0xf8, 0x00, 0x00, 0x2e, 0xfe, 0x00,
+    0x00, 0x2f, 0x07, 0x00, 0x00, 0x2f, 0x0f, 0x00, 0x00, 0x2f, 0x19, 0x00,
+    0x00, 0x2f, 0x21, 0x00, 0x00, 0x2f, 0x28, 0x00, 0x00, 0x2f, 0x30, 0x00,
+    0x00, 0x2f, 0x38, 0x00, 0x00, 0x2f, 0x40, 0x00, 0x00, 0x2f, 0x47, 0x00,
+    0x00, 0x2f, 0x4f, 0x00, 0x00, 0x2f, 0x54, 0x00, 0x00, 0x2f, 0x5b, 0x00,
+    0x00, 0x2f, 0x61, 0x00, 0x00, 0x2f, 0x68, 0x00, 0x00, 0x2f, 0x6e, 0x00,
+    0x00, 0x2f, 0x73, 0x00, 0x00, 0x2f, 0x79, 0x00, 0x00, 0x2f, 0x81, 0x00,
+    0x00, 0x2f, 0x8b, 0x00, 0x00, 0x2f, 0x93, 0x00, 0x00, 0x2f, 0x9b, 0x00,
+    0x00, 0x2f, 0xa2, 0x00, 0x00, 0x2f, 0xa8, 0x00, 0x00, 0x2f, 0xb0, 0x00,
+    0x00, 0x2f, 0xb9, 0x00, 0x00, 0x2f, 0xc1, 0x00, 0x00, 0x2f, 0xc8, 0x00,
+    0x00, 0x2f, 0xcd, 0x00, 0x00, 0x2f, 0xd4, 0x00, 0x00, 0x2f, 0xdd, 0x00,
+    0x00, 0x2f, 0xe2, 0x00, 0x00, 0x2f, 0xe8, 0x00, 0x00, 0x2f, 0xef, 0x00,
+    0x00, 0x2f, 0xf5, 0x00, 0x00, 0x2f, 0xfe, 0x00, 0x00, 0x30, 0x03, 0x00,
+    0x00, 0x30, 0x0c, 0x00, 0x00, 0x30, 0x12, 0x00, 0x00, 0x30, 0x19, 0x00,
+    0x00, 0x30, 0x1f, 0x00, 0x00, 0x30, 0x28, 0x00, 0x00, 0x30, 0x2f, 0x00,
+    0x00, 0x30, 0x37, 0x00, 0x00, 0x30, 0x3e, 0x00, 0x00, 0x30, 0x43, 0x00,
+    0x00, 0x30, 0x48, 0x00, 0x00, 0x30, 0x4f, 0x00, 0x00, 0x30, 0x55, 0x00,
+    0x00, 0x30, 0x5b, 0x00, 0x00, 0x30, 0x64, 0x00, 0x00, 0x30, 0x68, 0x00,
+    0x00, 0x30, 0x6b, 0x00, 0x00, 0x30, 0x71, 0x00, 0x00, 0x30, 0x77, 0x00,
+    0x00, 0x30, 0x7e, 0x00, 0x00, 0x30, 0x85, 0x00, 0x00, 0x30, 0x8b, 0x00,
+    0x00, 0x30, 0x93, 0x00, 0x00, 0x30, 0x9a, 0x00, 0x00, 0x30, 0xa1, 0x00,
+    0x00, 0x30, 0xa8, 0x00, 0x00, 0x30, 0xae, 0x00, 0x00, 0x30, 0xb2, 0x00,
+    0x00, 0x30, 0xb7, 0x00, 0x00, 0x30, 0xbf, 0x00, 0x00, 0x30, 0xc6, 0x00,
+    0x00, 0x30, 0xcb, 0x00, 0x00, 0x30, 0xd3, 0x00, 0x00, 0x30, 0xda, 0x00,
+    0x00, 0x30, 0xe1, 0x00, 0x00, 0x30, 0xea, 0x00, 0x00, 0x30, 0xf4, 0x00,
+    0x00, 0x30, 0xfd, 0x00, 0x00, 0x31, 0x03, 0x00, 0x00, 0x31, 0x0a, 0x00,
+    0x00, 0x31, 0x11, 0x00, 0x00, 0x31, 0x16, 0x00, 0x00, 0x31, 0x20, 0x00,
+    0x00, 0x31, 0x26, 0x00, 0x00, 0x31, 0x30, 0x00, 0x00, 0x31, 0x39, 0x00,
+    0x00, 0x31, 0x3f, 0x00, 0x00, 0x31, 0x48, 0x00, 0x00, 0x31, 0x4f, 0x00,
+    0x00, 0x31, 0x55, 0x00, 0x00, 0x31, 0x5e, 0x00, 0x00, 0x31, 0x63, 0x00,
+    0x00, 0x31, 0x6b, 0x00, 0x00, 0x31, 0x71, 0x00, 0x00, 0x31, 0x7b, 0x00,
+    0x00, 0x31, 0x81, 0x00, 0x00, 0x31, 0x86, 0x00, 0x00, 0x31, 0x91, 0x00,
+    0x00, 0x31, 0x98, 0x00, 0x00, 0x31, 0xa1, 0x00, 0x00, 0x31, 0xa7, 0x00,
+    0x00, 0x31, 0xac, 0x00, 0x00, 0x31, 0xb3, 0x00, 0x00, 0x31, 0xbf, 0x00,
+    0x00, 0x31, 0xc7, 0x00, 0x00, 0x31, 0xce, 0x00, 0x00, 0x31, 0xd6, 0x00,
+    0x00, 0x31, 0xdc, 0x00, 0x00, 0x31, 0xe3, 0x00, 0x00, 0x31, 0xea, 0x00,
+    0x00, 0x31, 0xef, 0x00, 0x00, 0x31, 0xf2, 0x00, 0x00, 0x31, 0xf8, 0x00,
+    0x00, 0x31, 0xff, 0x00, 0x00, 0x32, 0x06, 0x00, 0x00, 0x32, 0x0d, 0x00,
+    0x00, 0x32, 0x16, 0x00, 0x00, 0x32, 0x1e, 0x00, 0x00, 0x32, 0x23, 0x00,
+    0x00, 0x32, 0x29, 0x00, 0x00, 0x32, 0x2f, 0x00, 0x00, 0x32, 0x35, 0x00,
+    0x00, 0x32, 0x3a, 0x00, 0x00, 0x32, 0x40, 0x00, 0x00, 0x32, 0x47, 0x00,
+    0x00, 0x32, 0x4c, 0x00, 0x00, 0x32, 0x52, 0x00, 0x00, 0x32, 0x5b, 0x00,
+    0x00, 0x32, 0x65, 0x00, 0x00, 0x32, 0x6b, 0x00, 0x00, 0x32, 0x71, 0x00,
+    0x00, 0x32, 0x77, 0x00, 0x00, 0x32, 0x7f, 0x00, 0x00, 0x32, 0x89, 0x00,
+    0x00, 0x32, 0x91, 0x00, 0x00, 0x32, 0x99, 0x00, 0x00, 0x32, 0x9f, 0x00,
+    0x00, 0x32, 0xa6, 0x00, 0x00, 0x32, 0xac, 0x00, 0x00, 0x32, 0xb3, 0x00,
+    0x00, 0x32, 0xba, 0x00, 0x00, 0x32, 0xc0, 0x00, 0x00, 0x32, 0xc7, 0x00,
+    0x00, 0x32, 0xce, 0x00, 0x00, 0x32, 0xd6, 0x00, 0x00, 0x32, 0xdd, 0x00,
+    0x00, 0x32, 0xe2, 0x00, 0x00, 0x32, 0xea, 0x00, 0x00, 0x32, 0xf1, 0x00,
+    0x00, 0x32, 0xf9, 0x00, 0x00, 0x32, 0xff, 0x00, 0x00, 0x33, 0x06, 0x00,
+    0x00, 0x33, 0x11, 0x00, 0x00, 0x33, 0x18, 0x00, 0x00, 0x33, 0x1e, 0x00,
+    0x00, 0x33, 0x25, 0x00, 0x00, 0x33, 0x2a, 0x00, 0x00, 0x33, 0x34, 0x00,
+    0x00, 0x33, 0x3b, 0x00, 0x00, 0x33, 0x45, 0x00, 0x00, 0x33, 0x4c, 0x00,
+    0x00, 0x33, 0x51, 0x00, 0x00, 0x33, 0x5a, 0x00, 0x00, 0x33, 0x61, 0x00,
+    0x00, 0x33, 0x66, 0x00, 0x00, 0x33, 0x6c, 0x00, 0x00, 0x33, 0x74, 0x00,
+    0x00, 0x33, 0x7c, 0x00, 0x00, 0x33, 0x82, 0x00, 0x00, 0x33, 0x88, 0x00,
+    0x00, 0x33, 0x8e, 0x00, 0x00, 0x33, 0x96, 0x00, 0x00, 0x33, 0x9d, 0x00,
+    0x00, 0x33, 0xa5, 0x00, 0x00, 0x33, 0xaa, 0x00, 0x00, 0x33, 0xaf, 0x00,
+    0x00, 0x33, 0xb7, 0x00, 0x00, 0x33, 0xbe, 0x00, 0x00, 0x33, 0xc5, 0x00,
+    0x00, 0x33, 0xcc, 0x00, 0x00, 0x33, 0xd4, 0x00, 0x00, 0x33, 0xdb, 0x00,
+    0x00, 0x33, 0xe8, 0x00, 0x00, 0x33, 0xf2, 0x00, 0x00, 0x33, 0xfb, 0x00,
+    0x00, 0x34, 0x02, 0x00, 0x00, 0x34, 0x07, 0x00, 0x00, 0x34, 0x10, 0x00,
+    0x00, 0x34, 0x18, 0x00, 0x00, 0x34, 0x1e, 0x00, 0x00, 0x34, 0x24, 0x00,
+    0x00, 0x34, 0x29, 0x00, 0x00, 0x34, 0x31, 0x00, 0x00, 0x34, 0x3b, 0x00,
+    0x00, 0x34, 0x43, 0x00, 0x00, 0x34, 0x4a, 0x00, 0x00, 0x34, 0x50, 0x00,
+    0x00, 0x34, 0x56, 0x00, 0x00, 0x34, 0x5f, 0x00, 0x00, 0x34, 0x65, 0x00,
+    0x00, 0x34, 0x6e, 0x00, 0x00, 0x34, 0x75, 0x00, 0x00, 0x34, 0x7d, 0x00,
+    0x00, 0x34, 0x87, 0x00, 0x00, 0x34, 0x8d, 0x00, 0x00, 0x34, 0x93, 0x00,
+    0x00, 0x34, 0x9e, 0x00, 0x00, 0x34, 0xa3, 0x00, 0x00, 0x34, 0xa9, 0x00,
+    0x00, 0x34, 0xb2, 0x00, 0x00, 0x34, 0xb7, 0x00, 0x00, 0x34, 0xbe, 0x00,
+    0x00, 0x34, 0xc3, 0x00, 0x00, 0x34, 0xcb, 0x00, 0x00, 0x34, 0xd1, 0x00,
+    0x00, 0x34, 0xd8, 0x00, 0x00, 0x34, 0xde, 0x00, 0x00, 0x34, 0xe5, 0x00,
+    0x00, 0x34, 0xec, 0x00, 0x00, 0x34, 0xf2, 0x00, 0x00, 0x34, 0xf8, 0x00,
+    0x00, 0x35, 0x01, 0x00, 0x00, 0x35, 0x0a, 0x00, 0x00, 0x35, 0x0f, 0x00,
+    0x00, 0x35, 0x18, 0x00, 0x00, 0x35, 0x1c, 0x00, 0x00, 0x35, 0x24, 0x00,
+    0x00, 0x35, 0x2b, 0x00, 0x00, 0x35, 0x32, 0x00, 0x00, 0x35, 0x3a, 0x00,
+    0x00, 0x35, 0x41, 0x00, 0x00, 0x35, 0x46, 0x00, 0x00, 0x35, 0x4d, 0x00,
+    0x00, 0x35, 0x54, 0x00, 0x00, 0x35, 0x59, 0x00, 0x00, 0x35, 0x5f, 0x00,
+    0x00, 0x35, 0x65, 0x00, 0x00, 0x35, 0x6a, 0x00, 0x00, 0x35, 0x73, 0x00,
+    0x00, 0x35, 0x7d, 0x00, 0x00, 0x35, 0x83, 0x00, 0x00, 0x35, 0x8a, 0x00,
+    0x00, 0x35, 0x92, 0x00, 0x00, 0x35, 0x99, 0x00, 0x00, 0x35, 0xa1, 0x00,
+    0x00, 0x35, 0xa7, 0x00, 0x00, 0x35, 0xad, 0x00, 0x00, 0x35, 0xb4, 0x00,
+    0x00, 0x35, 0xb9, 0x00, 0x00, 0x35, 0xc1, 0x00, 0x00, 0x35, 0xc6, 0x00,
+    0x00, 0x35, 0xcc, 0x00, 0x00, 0x35, 0xd3, 0x00, 0x00, 0x35, 0xdb, 0x00,
+    0x00, 0x35, 0xe1, 0x00, 0x00, 0x35, 0xea, 0x00, 0x00, 0x35, 0xf1, 0x00,
+    0x00, 0x35, 0xf8, 0x00, 0x00, 0x35, 0xfe, 0x00, 0x00, 0x36, 0x03, 0x00,
+    0x00, 0x36, 0x09, 0x00, 0x00, 0x36, 0x12, 0x00, 0x00, 0x36, 0x1a, 0x00,
+    0x00, 0x36, 0x20, 0x00, 0x00, 0x36, 0x26, 0x00, 0x00, 0x36, 0x2d, 0x00,
+    0x00, 0x36, 0x33, 0x00, 0x00, 0x36, 0x39, 0x00, 0x00, 0x36, 0x40, 0x00,
+    0x00, 0x36, 0x48, 0x00, 0x00, 0x36, 0x4f, 0x00, 0x00, 0x36, 0x57, 0x00,
+    0x00, 0x36, 0x5c, 0x00, 0x00, 0x36, 0x63, 0x00, 0x00, 0x36, 0x6b, 0x00,
+    0x00, 0x36, 0x73, 0x00, 0x00, 0x36, 0x79, 0x00, 0x00, 0x36, 0x80, 0x00,
+    0x00, 0x36, 0x89, 0x00, 0x00, 0x36, 0x8e, 0x00, 0x00, 0x36, 0x92, 0x00,
+    0x00, 0x36, 0x9a, 0x00, 0x00, 0x36, 0xa1, 0x00, 0x00, 0x36, 0xa7, 0x00,
+    0x00, 0x36, 0xab, 0x00, 0x00, 0x36, 0xb0, 0x00, 0x00, 0x36, 0xb5, 0x00,
+    0x00, 0x36, 0xbe, 0x00, 0x00, 0x36, 0xc5, 0x00, 0x00, 0x36, 0xcc, 0x00,
+    0x00, 0x36, 0xd5, 0x00, 0x00, 0x36, 0xdd, 0x00, 0x00, 0x36, 0xe4, 0x00,
+    0x00, 0x36, 0xea, 0x00, 0x00, 0x36, 0xf3, 0x00, 0x00, 0x36, 0xf9, 0x00,
+    0x00, 0x36, 0xfe, 0x00, 0x00, 0x37, 0x03, 0x00, 0x00, 0x37, 0x0d, 0x00,
+    0x00, 0x37, 0x14, 0x00, 0x00, 0x37, 0x1d, 0x00, 0x00, 0x37, 0x23, 0x00,
+    0x00, 0x37, 0x2b, 0x00, 0x00, 0x37, 0x33, 0x00, 0x00, 0x37, 0x3b, 0x00,
+    0x00, 0x37, 0x41, 0x00, 0x00, 0x37, 0x46, 0x00, 0x00, 0x37, 0x4d, 0x00,
+    0x00, 0x37, 0x56, 0x00, 0x00, 0x37, 0x5e, 0x00, 0x00, 0x37, 0x68, 0x00,
+    0x00, 0x37, 0x72, 0x00, 0x00, 0x37, 0x77, 0x00, 0x00, 0x37, 0x7d, 0x00,
+    0x00, 0x37, 0x85, 0x00, 0x00, 0x37, 0x8b, 0x00, 0x00, 0x37, 0x91, 0x00,
+    0x00, 0x37, 0x9a, 0x00, 0x00, 0x37, 0xa4, 0x00, 0x00, 0x37, 0xaa, 0x00,
+    0x00, 0x37, 0xb2, 0x00, 0x00, 0x37, 0xb7, 0x00, 0x00, 0x37, 0xbe, 0x00,
+    0x00, 0x37, 0xc6, 0x00, 0x00, 0x37, 0xcc, 0x00, 0x00, 0x37, 0xd5, 0x00,
+    0x00, 0x37, 0xdc, 0x00, 0x00, 0x37, 0xe3, 0x00, 0x00, 0x37, 0xec, 0x00,
+    0x00, 0x37, 0xf3, 0x00, 0x00, 0x37, 0xfc, 0x00, 0x00, 0x38, 0x04, 0x00,
+    0x00, 0x38, 0x0d, 0x00, 0x00, 0x38, 0x13, 0x00, 0x00, 0x38, 0x19, 0x00,
+    0x00, 0x38, 0x1f, 0x00, 0x00, 0x38, 0x29, 0x00, 0x00, 0x38, 0x2d, 0x00,
+    0x00, 0x38, 0x34, 0x00, 0x00, 0x38, 0x39, 0x00, 0x00, 0x38, 0x3f, 0x00,
+    0x00, 0x38, 0x48, 0x00, 0x00, 0x38, 0x4e, 0x00, 0x00, 0x38, 0x55, 0x00,
+    0x00, 0x38, 0x5d, 0x00, 0x00, 0x38, 0x63, 0x00, 0x00, 0x38, 0x6b, 0x00,
+    0x00, 0x38, 0x71, 0x00, 0x00, 0x38, 0x78, 0x00, 0x00, 0x38, 0x81, 0x00,
+    0x00, 0x38, 0x88, 0x00, 0x00, 0x38, 0x8e, 0x00, 0x00, 0x38, 0x95, 0x00,
+    0x00, 0x38, 0x9d, 0x00, 0x00, 0x38, 0xa5, 0x00, 0x00, 0x38, 0xac, 0x00,
+    0x00, 0x38, 0xb6, 0x00, 0x00, 0x38, 0xbf, 0x00, 0x00, 0x38, 0xc4, 0x00,
+    0x00, 0x38, 0xcc, 0x00, 0x00, 0x38, 0xd4, 0x00, 0x00, 0x38, 0xdd, 0x00,
+    0x00, 0x38, 0xe4, 0x00, 0x00, 0x38, 0xeb, 0x00, 0x00, 0x38, 0xf0, 0x00,
+    0x00, 0x38, 0xf6, 0x00, 0x00, 0x38, 0xfc, 0x00, 0x00, 0x39, 0x03, 0x00,
+    0x00, 0x39, 0x0c, 0x00, 0x00, 0x39, 0x13, 0x00, 0x00, 0x39, 0x1b, 0x00,
+    0x00, 0x39, 0x22, 0x00, 0x00, 0x39, 0x2e, 0x00, 0x00, 0x39, 0x37, 0x00,
+    0x00, 0x39, 0x3f, 0x00, 0x00, 0x39, 0x45, 0x00, 0x00, 0x39, 0x4d, 0x00,
+    0x00, 0x39, 0x52, 0x00, 0x00, 0x39, 0x59, 0x00, 0x00, 0x39, 0x60, 0x00,
+    0x00, 0x39, 0x66, 0x00, 0x00, 0x39, 0x6b, 0x00, 0x00, 0x39, 0x72, 0x00,
+    0x00, 0x39, 0x76, 0x00, 0x00, 0x39, 0x7f, 0x00, 0x00, 0x39, 0x89, 0x00,
+    0x00, 0x39, 0x8f, 0x00, 0x00, 0x39, 0x96, 0x00, 0x00, 0x39, 0x9c, 0x00,
+    0x00, 0x39, 0xa2, 0x00, 0x00, 0x39, 0xa8, 0x00, 0x00, 0x39, 0xae, 0x00,
+    0x00, 0x39, 0xb3, 0x00, 0x00, 0x39, 0xba, 0x00, 0x00, 0x39, 0xc0, 0x00,
+    0x00, 0x39, 0xc9, 0x00, 0x00, 0x39, 0xcf, 0x00, 0x00, 0x39, 0xda, 0x00,
+    0x00, 0x39, 0xe5, 0x00, 0x00, 0x39, 0xed, 0x00, 0x00, 0x39, 0xf4, 0x00,
+    0x00, 0x39, 0xfa, 0x00, 0x00, 0x3a, 0x01, 0x00, 0x00, 0x3a, 0x0d, 0x00,
+    0x00, 0x3a, 0x15, 0x00, 0x00, 0x3a, 0x1a, 0x00, 0x00, 0x3a, 0x1d, 0x00,
+    0x00, 0x3a, 0x22, 0x00, 0x00, 0x3a, 0x29, 0x00, 0x00, 0x3a, 0x31, 0x00,
+    0x00, 0x3a, 0x38, 0x00, 0x00, 0x3a, 0x3f, 0x00, 0x00, 0x3a, 0x47, 0x00,
+    0x00, 0x3a, 0x4f, 0x00, 0x00, 0x3a, 0x56, 0x00, 0x00, 0x3a, 0x5b, 0x00,
+    0x00, 0x3a, 0x63, 0x00, 0x00, 0x3a, 0x6b, 0x00, 0x00, 0x3a, 0x74, 0x00,
+    0x00, 0x3a, 0x78, 0x00, 0x00, 0x3a, 0x82, 0x00, 0x00, 0x3a, 0x8a, 0x00,
+    0x00, 0x3a, 0x8f, 0x00, 0x00, 0x3a, 0x97, 0x00, 0x00, 0x3a, 0x9a, 0x00,
+    0x00, 0x3a, 0xa1, 0x00, 0x00, 0x3a, 0xa7, 0x00, 0x00, 0x3a, 0xac, 0x00,
+    0x00, 0x3a, 0xb2, 0x00, 0x00, 0x3a, 0xbb, 0x00, 0x00, 0x3a, 0xc4, 0x00,
+    0x00, 0x3a, 0xcd, 0x00, 0x00, 0x3a, 0xd4, 0x00, 0x00, 0x3a, 0xdc, 0x00,
+    0x00, 0x3a, 0xe1, 0x00, 0x00, 0x3a, 0xe9, 0x00, 0x00, 0x3a, 0xed, 0x00,
+    0x00, 0x3a, 0xf6, 0x00, 0x00, 0x3a, 0xfc, 0x00, 0x00, 0x3b, 0x00, 0x00,
+    0x00, 0x3b, 0x09, 0x00, 0x00, 0x3b, 0x11, 0x00, 0x00, 0x3b, 0x18, 0x00,
+    0x00, 0x3b, 0x20, 0x00, 0x00, 0x3b, 0x26, 0x00, 0x00, 0x3b, 0x2e, 0x00,
+    0x00, 0x3b, 0x36, 0x00, 0x00, 0x3b, 0x3e, 0x00, 0x00, 0x3b, 0x43, 0x00,
+    0x00, 0x3b, 0x4a, 0x00, 0x00, 0x3b, 0x51, 0x00, 0x00, 0x3b, 0x59, 0x00,
+    0x00, 0x3b, 0x62, 0x00, 0x00, 0x3b, 0x68, 0x00, 0x00, 0x3b, 0x70, 0x00,
+    0x00, 0x3b, 0x77, 0x00, 0x00, 0x3b, 0x7e, 0x00, 0x00, 0x3b, 0x84, 0x00,
+    0x00, 0x3b, 0x8d, 0x00, 0x00, 0x3b, 0x92, 0x00, 0x00, 0x3b, 0x9a, 0x00,
+    0x00, 0x3b, 0xa1, 0x00, 0x00, 0x3b, 0xa9, 0x00, 0x00, 0x3b, 0xaf, 0x00,
+    0x00, 0x3b, 0xba, 0x00, 0x00, 0x3b, 0xbf, 0x00, 0x00, 0x3b, 0xc5, 0x00,
+    0x00, 0x3b, 0xca, 0x00, 0x00, 0x3b, 0xd2, 0x00, 0x00, 0x3b, 0xdb, 0x00,
+    0x00, 0x3b, 0xe1, 0x00, 0x00, 0x3b, 0xe8, 0x00, 0x00, 0x3b, 0xf1, 0x00,
+    0x00, 0x3b, 0xf9, 0x00, 0x00, 0x3c, 0x01, 0x00, 0x00, 0x3c, 0x08, 0x00,
+    0x00, 0x3c, 0x0f, 0x00, 0x00, 0x3c, 0x14, 0x00, 0x00, 0x3c, 0x1a, 0x00,
+    0x00, 0x3c, 0x24, 0x00, 0x00, 0x3c, 0x2b, 0x00, 0x00, 0x3c, 0x31, 0x00,
+    0x00, 0x3c, 0x37, 0x00, 0x00, 0x3c, 0x40, 0x00, 0x00, 0x3c, 0x4b, 0x00,
+    0x00, 0x3c, 0x50, 0x00, 0x00, 0x3c, 0x58, 0x00, 0x00, 0x3c, 0x5e, 0x00,
+    0x00, 0x3c, 0x64, 0x00, 0x00, 0x3c, 0x6c, 0x00, 0x00, 0x3c, 0x74, 0x00,
+    0x00, 0x3c, 0x7b, 0x00, 0x00, 0x3c, 0x84, 0x00, 0x00, 0x3c, 0x8a, 0x00,
+    0x00, 0x3c, 0x91, 0x00, 0x00, 0x3c, 0x97, 0x00, 0x00, 0x3c, 0x9d, 0x00,
+    0x00, 0x3c, 0xa4, 0x00, 0x00, 0x3c, 0xab, 0x00, 0x00, 0x3c, 0xb2, 0x00,
+    0x00, 0x3c, 0xbb, 0x00, 0x00, 0x3c, 0xc1, 0x00, 0x00, 0x3c, 0xc8, 0x00,
+    0x00, 0x3c, 0xd0, 0x00, 0x00, 0x3c, 0xd6, 0x00, 0x00, 0x3c, 0xdd, 0x00,
+    0x00, 0x3c, 0xe6, 0x00, 0x00, 0x3c, 0xed, 0x00, 0x00, 0x3c, 0xf7, 0x00,
+    0x00, 0x3c, 0xfe, 0x00, 0x00, 0x3d, 0x06, 0x00, 0x00, 0x3d, 0x0f, 0x00,
+    0x00, 0x3d, 0x16, 0x00, 0x00, 0x3d, 0x1d, 0x00, 0x00, 0x3d, 0x22, 0x00,
+    0x00, 0x3d, 0x2b, 0x00, 0x00, 0x3d, 0x30, 0x00, 0x00, 0x3d, 0x3a, 0x00,
+    0x00, 0x3d, 0x42, 0x00, 0x00, 0x3d, 0x49, 0x00, 0x00, 0x3d, 0x4e, 0x00,
+    0x00, 0x3d, 0x55, 0x00, 0x00, 0x3d, 0x5a, 0x00, 0x00, 0x3d, 0x60, 0x00,
+    0x00, 0x3d, 0x68, 0x00, 0x00, 0x3d, 0x70, 0x00, 0x00, 0x3d, 0x78, 0x00,
+    0x00, 0x3d, 0x7f, 0x00, 0x00, 0x3d, 0x86, 0x00, 0x00, 0x3d, 0x8c, 0x00,
+    0x00, 0x3d, 0x94, 0x00, 0x00, 0x3d, 0x9b, 0x00, 0x00, 0x3d, 0xa1, 0x00,
+    0x00, 0x3d, 0xaa, 0x00, 0x00, 0x3d, 0xb1, 0x00, 0x00, 0x3d, 0xb8, 0x00,
+    0x00, 0x3d, 0xbe, 0x00, 0x00, 0x3d, 0xc5, 0x00, 0x00, 0x3d, 0xce, 0x00,
+    0x00, 0x3d, 0xd5, 0x00, 0x00, 0x3d, 0xdd, 0x00, 0x00, 0x3d, 0xe3, 0x00,
+    0x00, 0x3d, 0xeb, 0x00, 0x00, 0x3d, 0xf3, 0x00, 0x00, 0x3d, 0xfa, 0x00,
+    0x00, 0x3e, 0x01, 0x00, 0x00, 0x3e, 0x08, 0x00, 0x00, 0x3e, 0x12, 0x00,
+    0x00, 0x3e, 0x1a, 0x00, 0x00, 0x3e, 0x20, 0x00, 0x00, 0x3e, 0x25, 0x00,
+    0x00, 0x3e, 0x2d, 0x00, 0x00, 0x3e, 0x33, 0x00, 0x00, 0x3e, 0x38, 0x00,
+    0x00, 0x3e, 0x40, 0x00, 0x00, 0x3e, 0x47, 0x00, 0x00, 0x3e, 0x4d, 0x00,
+    0x00, 0x3e, 0x58, 0x00, 0x00, 0x3e, 0x5d, 0x00, 0x00, 0x3e, 0x65, 0x00,
+    0x00, 0x3e, 0x6d, 0x00, 0x00, 0x3e, 0x73, 0x00, 0x00, 0x3e, 0x7a, 0x00,
+    0x00, 0x3e, 0x85, 0x00, 0x00, 0x3e, 0x8e, 0x00, 0x00, 0x3e, 0x95, 0x00,
+    0x00, 0x3e, 0x9c, 0x00, 0x00, 0x3e, 0xa2, 0x00, 0x00, 0x3e, 0xaa, 0x00,
+    0x00, 0x3e, 0xb1, 0x00, 0x00, 0x3e, 0xb8, 0x00, 0x00, 0x3e, 0xc1, 0x00,
+    0x00, 0x3e, 0xc6, 0x00, 0x00, 0x3e, 0xcc, 0x00, 0x00, 0x3e, 0xd3, 0x00,
+    0x00, 0x3e, 0xda, 0x00, 0x00, 0x3e, 0xe1, 0x00, 0x00, 0x3e, 0xe9, 0x00,
+    0x00, 0x3e, 0xf0, 0x00, 0x00, 0x3e, 0xf5, 0x00, 0x00, 0x3e, 0xfb, 0x00,
+    0x00, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x08, 0x00, 0x00, 0x3f, 0x10, 0x00,
+    0x00, 0x3f, 0x18, 0x00, 0x00, 0x3f, 0x22, 0x00, 0x00, 0x3f, 0x29, 0x00,
+    0x00, 0x3f, 0x30, 0x00, 0x00, 0x3f, 0x37, 0x00, 0x00, 0x3f, 0x3e, 0x00,
+    0x00, 0x3f, 0x46, 0x00, 0x00, 0x3f, 0x4c, 0x00, 0x00, 0x3f, 0x53, 0x00,
+    0x00, 0x3f, 0x5c, 0x00, 0x00, 0x3f, 0x67, 0x00, 0x00, 0x3f, 0x6f, 0x00,
+    0x00, 0x3f, 0x76, 0x00, 0x00, 0x3f, 0x7c, 0x00, 0x00, 0x3f, 0x84, 0x00,
+    0x00, 0x3f, 0x88, 0x00, 0x00, 0x3f, 0x8f, 0x00, 0x00, 0x3f, 0x97, 0x00,
+    0x00, 0x3f, 0x9c, 0x00, 0x00, 0x3f, 0xa2, 0x00, 0x00, 0x3f, 0xae, 0x00,
+    0x00, 0x3f, 0xb3, 0x00, 0x00, 0x3f, 0xbd, 0x00, 0x00, 0x3f, 0xc2, 0x00,
+    0x00, 0x3f, 0xc7, 0x00, 0x00, 0x3f, 0xd1, 0x00, 0x00, 0x3f, 0xd9, 0x00,
+    0x00, 0x3f, 0xe2, 0x00, 0x00, 0x3f, 0xe9, 0x00, 0x00, 0x3f, 0xef, 0x00,
+    0x00, 0x3f, 0xf5, 0x00, 0x00, 0x3f, 0xfd, 0x00, 0x00, 0x40, 0x04, 0x00,
+    0x00, 0x40, 0x09, 0x00, 0x00, 0x40, 0x12, 0x00, 0x00, 0x40, 0x19, 0x00,
+    0x00, 0x40, 0x21, 0x00, 0x00, 0x40, 0x29, 0x00, 0x00, 0x40, 0x2d, 0x00,
+    0x00, 0x40, 0x35, 0x00, 0x00, 0x40, 0x3c, 0x00, 0x00, 0x40, 0x46, 0x00,
+    0x00, 0x40, 0x50, 0x00, 0x00, 0x40, 0x58, 0x00, 0x00, 0x40, 0x5e, 0x00,
+    0x00, 0x40, 0x66, 0x00, 0x00, 0x40, 0x6c, 0x00, 0x00, 0x40, 0x75, 0x00,
+    0x00, 0x40, 0x7b, 0x00, 0x00, 0x40, 0x83, 0x00, 0x00, 0x40, 0x8b, 0x00,
+    0x00, 0x40, 0x92, 0x00, 0x00, 0x40, 0x9b, 0x00, 0x00, 0x40, 0xa4, 0x00,
+    0x00, 0x40, 0xae, 0x00, 0x00, 0x40, 0xb8, 0x00, 0x00, 0x40, 0xc0, 0x00,
+    0x00, 0x40, 0xc6, 0x00, 0x00, 0x40, 0xce, 0x00, 0x00, 0x40, 0xd4, 0x00,
+    0x00, 0x40, 0xdb, 0x00, 0x00, 0x40, 0xe0, 0x00, 0x00, 0x40, 0xe9, 0x00,
+    0x00, 0x40, 0xf2, 0x00, 0x00, 0x40, 0xf7, 0x00, 0x00, 0x40, 0xfe, 0x00,
+    0x00, 0x41, 0x07, 0x00, 0x00, 0x41, 0x11, 0x00, 0x00, 0x41, 0x1a, 0x00,
+    0x00, 0x41, 0x21, 0x00, 0x00, 0x41, 0x24, 0x00, 0x00, 0x41, 0x2b, 0x00,
+    0x00, 0x41, 0x30, 0x00, 0x00, 0x41, 0x36, 0x00, 0x00, 0x41, 0x3c, 0x00,
+    0x00, 0x41, 0x46, 0x00, 0x00, 0x41, 0x4f, 0x00, 0x00, 0x41, 0x57, 0x00,
+    0x00, 0x41, 0x5c, 0x00, 0x00, 0x41, 0x66, 0x00, 0x00, 0x41, 0x6b, 0x00,
+    0x00, 0x41, 0x71, 0x00, 0x00, 0x41, 0x76, 0x00, 0x00, 0x41, 0x7d, 0x00,
+    0x00, 0x41, 0x84, 0x00, 0x00, 0x41, 0x8b, 0x00, 0x00, 0x41, 0x93, 0x00,
+    0x00, 0x41, 0x9a, 0x00, 0x00, 0x41, 0xa3, 0x00, 0x00, 0x41, 0xa7, 0x00,
+    0x00, 0x41, 0xaf, 0x00, 0x00, 0x41, 0xb7, 0x00, 0x00, 0x41, 0xc1, 0x00,
+    0x00, 0x41, 0xc5, 0x00, 0x00, 0x41, 0xcc, 0x00, 0x00, 0x41, 0xd3, 0x00,
+    0x00, 0x41, 0xd9, 0x00, 0x00, 0x41, 0xe2, 0x00, 0x00, 0x41, 0xe9, 0x00,
+    0x00, 0x41, 0xf2, 0x00, 0x00, 0x41, 0xf7, 0x00, 0x00, 0x41, 0xff, 0x00,
+    0x00, 0x42, 0x05, 0x00, 0x00, 0x42, 0x0b, 0x00, 0x00, 0x42, 0x11, 0x00,
+    0x00, 0x42, 0x17, 0x00, 0x00, 0x42, 0x1e, 0x00, 0x00, 0x42, 0x24, 0x00,
+    0x00, 0x42, 0x2a, 0x00, 0x00, 0x42, 0x30, 0x00, 0x00, 0x42, 0x38, 0x00,
+    0x00, 0x42, 0x41, 0x00, 0x00, 0x42, 0x48, 0x00, 0x00, 0x42, 0x4e, 0x00,
+    0x00, 0x42, 0x54, 0x00, 0x00, 0x42, 0x5b, 0x00, 0x00, 0x42, 0x60, 0x00,
+    0x00, 0x42, 0x6a, 0x00, 0x00, 0x42, 0x70, 0x00, 0x00, 0x42, 0x77, 0x00,
+    0x00, 0x42, 0x7f, 0x00, 0x00, 0x42, 0x85, 0x00, 0x00, 0x42, 0x8d, 0x00,
+    0x00, 0x42, 0x95, 0x00, 0x00, 0x42, 0x9c, 0x00, 0x00, 0x42, 0xa5, 0x00,
+    0x00, 0x42, 0xad, 0x00, 0x00, 0x42, 0xb9, 0x00, 0x00, 0x42, 0xbe, 0x00,
+    0x00, 0x42, 0xc6, 0x00, 0x00, 0x42, 0xcd, 0x00, 0x00, 0x42, 0xd5, 0x00,
+    0x00, 0x42, 0xda, 0x00, 0x00, 0x42, 0xe3, 0x00, 0x00, 0x42, 0xee, 0x00,
+    0x00, 0x42, 0xf5, 0x00, 0x00, 0x42, 0xfc, 0x00, 0x00, 0x43, 0x02, 0x00,
+    0x00, 0x43, 0x09, 0x00, 0x00, 0x43, 0x0e, 0x00, 0x00, 0x43, 0x15, 0x00,
+    0x00, 0x43, 0x1a, 0x00, 0x00, 0x43, 0x22, 0x00, 0x00, 0x43, 0x2e, 0x00,
+    0x00, 0x43, 0x38, 0x00, 0x00, 0x43, 0x40, 0x00, 0x00, 0x43, 0x47, 0x00,
+    0x00, 0x43, 0x4e, 0x00, 0x00, 0x43, 0x54, 0x00, 0x00, 0x43, 0x5c, 0x00,
+    0x00, 0x43, 0x66, 0x00, 0x00, 0x43, 0x6c, 0x00, 0x00, 0x43, 0x73, 0x00,
+    0x00, 0x43, 0x7c, 0x00, 0x00, 0x43, 0x82, 0x00, 0x00, 0x43, 0x8a, 0x00,
+    0x00, 0x43, 0x92, 0x00, 0x00, 0x43, 0x9b, 0x00, 0x00, 0x43, 0xa3, 0x00,
+    0x00, 0x43, 0xa8, 0x00, 0x00, 0x43, 0xaf, 0x00, 0x00, 0x43, 0xb9, 0x00,
+    0x00, 0x43, 0xc2, 0x00, 0x00, 0x43, 0xc9, 0x00, 0x00, 0x43, 0xd1, 0x00,
+    0x00, 0x43, 0xd7, 0x00, 0x00, 0x43, 0xe1, 0x00, 0x00, 0x43, 0xe7, 0x00,
+    0x00, 0x43, 0xed, 0x00, 0x00, 0x43, 0xf5, 0x00, 0x00, 0x43, 0xfc, 0x00,
+    0x00, 0x44, 0x02, 0x00, 0x00, 0x44, 0x0a, 0x00, 0x00, 0x44, 0x15, 0x00,
+    0x00, 0x44, 0x1c, 0x00, 0x00, 0x44, 0x25, 0x00, 0x00, 0x44, 0x2c, 0x00,
+    0x00, 0x44, 0x36, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x00, 0x44, 0x46, 0x00,
+    0x00, 0x44, 0x4e, 0x00, 0x00, 0x44, 0x58, 0x00, 0x00, 0x44, 0x61, 0x00,
+    0x00, 0x44, 0x68, 0x00, 0x00, 0x44, 0x71, 0x00, 0x00, 0x44, 0x7b, 0x00,
+    0x00, 0x44, 0x82, 0x00, 0x00, 0x44, 0x88, 0x00, 0x00, 0x44, 0x8f, 0x00,
+    0x00, 0x44, 0x99, 0x00, 0x00, 0x44, 0xa0, 0x00, 0x00, 0x44, 0xa6, 0x00,
+    0x00, 0x44, 0xac, 0x00, 0x00, 0x44, 0xb2, 0x00, 0x00, 0x44, 0xb9, 0x00,
+    0x00, 0x44, 0xbf, 0x00, 0x00, 0x44, 0xc7, 0x00, 0x00, 0x44, 0xcd, 0x00,
+    0x00, 0x44, 0xd3, 0x00, 0x00, 0x44, 0xdd, 0x00, 0x00, 0x44, 0xe3, 0x00,
+    0x00, 0x44, 0xea, 0x00, 0x00, 0x44, 0xf1, 0x00, 0x00, 0x44, 0xfa, 0x00,
+    0x00, 0x45, 0x02, 0x00, 0x00, 0x45, 0x09, 0x00, 0x00, 0x45, 0x10, 0x00,
+    0x00, 0x45, 0x16, 0x00, 0x00, 0x45, 0x1f, 0x00, 0x00, 0x45, 0x26, 0x00,
+    0x00, 0x45, 0x2d, 0x00, 0x00, 0x45, 0x33, 0x00, 0x00, 0x45, 0x3c, 0x00,
+    0x00, 0x45, 0x41, 0x00, 0x00, 0x45, 0x47, 0x00, 0x00, 0x45, 0x4e, 0x00,
+    0x00, 0x45, 0x55, 0x00, 0x00, 0x45, 0x5b, 0x00, 0x00, 0x45, 0x61, 0x00,
+    0x00, 0x45, 0x69, 0x00, 0x00, 0x45, 0x70, 0x00, 0x00, 0x45, 0x77, 0x00,
+    0x00, 0x45, 0x84, 0x00, 0x00, 0x45, 0x88, 0x00, 0x00, 0x45, 0x91, 0x00,
+    0x00, 0x45, 0x99, 0x00, 0x00, 0x45, 0xa1, 0x00, 0x00, 0x45, 0xa6, 0x00,
+    0x00, 0x45, 0xad, 0x00, 0x00, 0x45, 0xb5, 0x00, 0x00, 0x45, 0xbc, 0x00,
+    0x00, 0x45, 0xc4, 0x00, 0x00, 0x45, 0xcd, 0x00, 0x00, 0x45, 0xd4, 0x00,
+    0x00, 0x45, 0xdc, 0x00, 0x00, 0x45, 0xe6, 0x00, 0x00, 0x45, 0xed, 0x00,
+    0x00, 0x45, 0xf4, 0x00, 0x00, 0x45, 0xfb, 0x00, 0x00, 0x46, 0x02, 0x00,
+    0x00, 0x46, 0x0d, 0x00, 0x00, 0x46, 0x16, 0x00, 0x00, 0x46, 0x20, 0x00,
+    0x00, 0x46, 0x2c, 0x00, 0x00, 0x46, 0x32, 0x00, 0x00, 0x46, 0x3a, 0x00,
+    0x00, 0x46, 0x43, 0x00, 0x00, 0x46, 0x47, 0x00, 0x00, 0x46, 0x4f, 0x00,
+    0x00, 0x46, 0x55, 0x00, 0x00, 0x46, 0x5c, 0x00, 0x00, 0x46, 0x62, 0x00,
+    0x00, 0x46, 0x6b, 0x00, 0x00, 0x46, 0x71, 0x00, 0x00, 0x46, 0x78, 0x00,
+    0x00, 0x46, 0x7f, 0x00, 0x00, 0x46, 0x86, 0x00, 0x00, 0x46, 0x8c, 0x00,
+    0x00, 0x46, 0x92, 0x00, 0x00, 0x46, 0x99, 0x00, 0x00, 0x46, 0xa0, 0x00,
+    0x00, 0x46, 0xa8, 0x00, 0x00, 0x46, 0xb2, 0x00, 0x00, 0x46, 0xb8, 0x00,
+    0x00, 0x46, 0xbc, 0x00, 0x00, 0x46, 0xc1, 0x00, 0x00, 0x46, 0xc8, 0x00,
+    0x00, 0x46, 0xd1, 0x00, 0x00, 0x46, 0xd7, 0x00, 0x00, 0x46, 0xe0, 0x00,
+    0x00, 0x46, 0xe8, 0x00, 0x00, 0x46, 0xef, 0x00, 0x00, 0x46, 0xf6, 0x00,
+    0x00, 0x46, 0xfc, 0x00, 0x00, 0x47, 0x06, 0x00, 0x00, 0x47, 0x0e, 0x00,
+    0x00, 0x47, 0x13, 0x00, 0x00, 0x47, 0x1a, 0x00, 0x00, 0x47, 0x21, 0x00,
+    0x00, 0x47, 0x2a, 0x00, 0x00, 0x47, 0x31, 0x00, 0x00, 0x47, 0x38, 0x00,
+    0x00, 0x47, 0x40, 0x00, 0x00, 0x47, 0x45, 0x00, 0x00, 0x47, 0x51, 0x00,
+    0x00, 0x47, 0x57, 0x00, 0x00, 0x47, 0x60, 0x00, 0x00, 0x47, 0x6a, 0x00,
+    0x00, 0x47, 0x76, 0x00, 0x00, 0x47, 0x80, 0x00, 0x00, 0x47, 0x87, 0x00,
+    0x00, 0x47, 0x8d, 0x00, 0x00, 0x47, 0x94, 0x00, 0x00, 0x47, 0xa0, 0x00,
+    0x00, 0x47, 0xa4, 0x00, 0x00, 0x47, 0xac, 0x00, 0x00, 0x47, 0xb2, 0x00,
+    0x00, 0x47, 0xb7, 0x00, 0x00, 0x47, 0xbe, 0x00, 0x00, 0x47, 0xc6, 0x00,
+    0x00, 0x47, 0xcf, 0x00, 0x00, 0x47, 0xd6, 0x00, 0x00, 0x47, 0xdf, 0x00,
+    0x00, 0x47, 0xe7, 0x00, 0x00, 0x47, 0xee, 0x00, 0x00, 0x47, 0xf6, 0x00,
+    0x00, 0x47, 0xfb, 0x00, 0x00, 0x48, 0x01, 0x00, 0x00, 0x48, 0x06, 0x00,
+    0x00, 0x48, 0x0c, 0x00, 0x00, 0x48, 0x13, 0x00, 0x00, 0x48, 0x1a, 0x00,
+    0x00, 0x48, 0x24, 0x00, 0x00, 0x48, 0x2a, 0x00, 0x00, 0x48, 0x32, 0x00,
+    0x00, 0x48, 0x38, 0x00, 0x00, 0x48, 0x40, 0x00, 0x00, 0x48, 0x48, 0x00,
+    0x00, 0x48, 0x52, 0x00, 0x00, 0x48, 0x5b, 0x00, 0x00, 0x48, 0x63, 0x00,
+    0x00, 0x48, 0x6c, 0x00, 0x00, 0x48, 0x74, 0x00, 0x00, 0x48, 0x7a, 0x00,
+    0x00, 0x48, 0x80, 0x00, 0x00, 0x48, 0x85, 0x00, 0x00, 0x48, 0x89, 0x00,
+    0x00, 0x48, 0x93, 0x00, 0x00, 0x48, 0x9b, 0x00, 0x00, 0x48, 0xa0, 0x00,
+    0x00, 0x48, 0xa7, 0x00, 0x00, 0x48, 0xad, 0x00, 0x00, 0x48, 0xb6, 0x00,
+    0x00, 0x48, 0xbd, 0x00, 0x00, 0x48, 0xc6, 0x00, 0x00, 0x48, 0xcd, 0x00,
+    0x00, 0x48, 0xd4, 0x00, 0x00, 0x48, 0xdd, 0x00, 0x00, 0x48, 0xe2, 0x00,
+    0x00, 0x48, 0xe7, 0x00, 0x00, 0x48, 0xf0, 0x00, 0x00, 0x48, 0xf9, 0x00,
+    0x00, 0x48, 0xff, 0x00, 0x00, 0x49, 0x03, 0x00, 0x00, 0x49, 0x0d, 0x00,
+    0x00, 0x49, 0x17, 0x00, 0x00, 0x49, 0x1e, 0x00, 0x00, 0x49, 0x27, 0x00,
+    0x00, 0x49, 0x2f, 0x00, 0x00, 0x49, 0x37, 0x00, 0x00, 0x49, 0x3c, 0x00,
+    0x00, 0x49, 0x44, 0x00, 0x00, 0x49, 0x50, 0x00, 0x00, 0x49, 0x54, 0x00,
+    0x00, 0x49, 0x5c, 0x00, 0x00, 0x49, 0x63, 0x00, 0x00, 0x49, 0x6a, 0x00,
+    0x00, 0x49, 0x70, 0x00, 0x00, 0x49, 0x75, 0x00, 0x00, 0x49, 0x7d, 0x00,
+    0x00, 0x49, 0x83, 0x00, 0x00, 0x49, 0x89, 0x00, 0x00, 0x49, 0x93, 0x00,
+    0x00, 0x49, 0x9c, 0x00, 0x00, 0x49, 0xa5, 0x00, 0x00, 0x49, 0xab, 0x00,
+    0x00, 0x49, 0xb2, 0x00, 0x00, 0x49, 0xbc, 0x00, 0x00, 0x49, 0xc3, 0x00,
+    0x00, 0x49, 0xca, 0x00, 0x00, 0x49, 0xd0, 0x00, 0x00, 0x49, 0xda, 0x00,
+    0x00, 0x49, 0xdf, 0x00, 0x00, 0x49, 0xe4, 0x00, 0x00, 0x49, 0xeb, 0x00,
+    0x00, 0x49, 0xf2, 0x00, 0x00, 0x49, 0xfa, 0x00, 0x00, 0x4a, 0x02, 0x00,
+    0x00, 0x4a, 0x0b, 0x00, 0x00, 0x4a, 0x13, 0x00, 0x00, 0x4a, 0x19, 0x00,
+    0x00, 0x4a, 0x22, 0x00, 0x00, 0x4a, 0x2d, 0x00, 0x00, 0x4a, 0x36, 0x00,
+    0x00, 0x4a, 0x3e, 0x00, 0x00, 0x4a, 0x45, 0x00, 0x00, 0x4a, 0x4a, 0x00,
+    0x00, 0x4a, 0x51, 0x00, 0x00, 0x4a, 0x5c, 0x00, 0x00, 0x4a, 0x63, 0x00,
+    0x00, 0x4a, 0x68, 0x00, 0x00, 0x4a, 0x6c, 0x00, 0x00, 0x4a, 0x73, 0x00,
+    0x00, 0x4a, 0x7a, 0x00, 0x00, 0x4a, 0x82, 0x00, 0x00, 0x4a, 0x88, 0x00,
+    0x00, 0x4a, 0x91, 0x00, 0x00, 0x4a, 0x97, 0x00, 0x00, 0x4a, 0x9c, 0x00,
+    0x00, 0x4a, 0xa4, 0x00, 0x00, 0x4a, 0xab, 0x00, 0x00, 0x4a, 0xb3, 0x00,
+    0x00, 0x4a, 0xbb, 0x00, 0x00, 0x4a, 0xc1, 0x00, 0x00, 0x4a, 0xc8, 0x00,
+    0x00, 0x4a, 0xce, 0x00, 0x00, 0x4a, 0xd4, 0x00, 0x00, 0x4a, 0xdc, 0x00,
+    0x00, 0x4a, 0xe1, 0x00, 0x00, 0x4a, 0xe6, 0x00, 0x00, 0x4a, 0xed, 0x00,
+    0x00, 0x4a, 0xf3, 0x00, 0x00, 0x4a, 0xfa, 0x00, 0x00, 0x4b, 0x03, 0x00,
+    0x00, 0x4b, 0x0c, 0x00, 0x00, 0x4b, 0x15, 0x00, 0x00, 0x4b, 0x1d, 0x00,
+    0x00, 0x4b, 0x23, 0x00, 0x00, 0x4b, 0x29, 0x00, 0x00, 0x4b, 0x2e, 0x00,
+    0x00, 0x4b, 0x35, 0x00, 0x00, 0x4b, 0x3c, 0x00, 0x00, 0x4b, 0x44, 0x00,
+    0x00, 0x4b, 0x4a, 0x00, 0x00, 0x4b, 0x4d, 0x00, 0x00, 0x4b, 0x54, 0x00,
+    0x00, 0x4b, 0x5c, 0x00, 0x00, 0x4b, 0x67, 0x00, 0x00, 0x4b, 0x6f, 0x00,
+    0x00, 0x4b, 0x76, 0x00, 0x00, 0x4b, 0x7f, 0x00, 0x00, 0x4b, 0x86, 0x00,
+    0x00, 0x4b, 0x8c, 0x00, 0x00, 0x4b, 0x94, 0x00, 0x00, 0x4b, 0x9b, 0x00,
+    0x00, 0x4b, 0xa0, 0x00, 0x00, 0x4b, 0xa5, 0x00, 0x00, 0x4b, 0xac, 0x00,
+    0x00, 0x4b, 0xb4, 0x00, 0x00, 0x4b, 0xbb, 0x00, 0x00, 0x4b, 0xc2, 0x00,
+    0x00, 0x4b, 0xc8, 0x00, 0x00, 0x4b, 0xd1, 0x00, 0x00, 0x4b, 0xd9, 0x00,
+    0x00, 0x4b, 0xde, 0x00, 0x00, 0x4b, 0xe4, 0x00, 0x00, 0x4b, 0xeb, 0x00,
+    0x00, 0x4b, 0xf2, 0x00, 0x00, 0x4b, 0xfa, 0x00, 0x00, 0x4c, 0x02, 0x00,
+    0x00, 0x4c, 0x09, 0x00, 0x00, 0x4c, 0x10, 0x00, 0x00, 0x4c, 0x16, 0x00,
+    0x00, 0x4c, 0x1c, 0x00, 0x00, 0x4c, 0x25, 0x00, 0x00, 0x4c, 0x2a, 0x00,
+    0x00, 0x4c, 0x2e, 0x00, 0x00, 0x4c, 0x36, 0x00, 0x00, 0x4c, 0x3d, 0x00,
+    0x00, 0x4c, 0x44, 0x00, 0x00, 0x4c, 0x51, 0x00, 0x00, 0x4c, 0x57, 0x00,
+    0x00, 0x4c, 0x5e, 0x00, 0x00, 0x4c, 0x67, 0x00, 0x00, 0x4c, 0x6b, 0x00,
+    0x00, 0x4c, 0x71, 0x00, 0x00, 0x4c, 0x76, 0x00, 0x00, 0x4c, 0x7d, 0x00,
+    0x00, 0x4c, 0x84, 0x00, 0x00, 0x4c, 0x8c, 0x00, 0x00, 0x4c, 0x95, 0x00,
+    0x00, 0x4c, 0x9b, 0x00, 0x00, 0x4c, 0xa2, 0x00, 0x00, 0x4c, 0xa8, 0x00,
+    0x00, 0x4c, 0xad, 0x00, 0x00, 0x4c, 0xb3, 0x00, 0x00, 0x4c, 0xbd, 0x00,
+    0x00, 0x4c, 0xc4, 0x00, 0x00, 0x4c, 0xcb, 0x00, 0x00, 0x4c, 0xd1, 0x00,
+    0x00, 0x4c, 0xd7, 0x00, 0x00, 0x4c, 0xdf, 0x00, 0x00, 0x4c, 0xe6, 0x00,
+    0x00, 0x4c, 0xf0, 0x00, 0x00, 0x4c, 0xf6, 0x00, 0x00, 0x4c, 0xfd, 0x00,
+    0x00, 0x4d, 0x03, 0x00, 0x00, 0x4d, 0x0a, 0x00, 0x00, 0x4d, 0x12, 0x00,
+    0x00, 0x4d, 0x1e, 0x00, 0x00, 0x4d, 0x27, 0x00, 0x00, 0x4d, 0x2e, 0x00,
+    0x00, 0x4d, 0x36, 0x00, 0x00, 0x4d, 0x3b, 0x00, 0x00, 0x4d, 0x42, 0x00,
+    0x00, 0x4d, 0x4b, 0x00, 0x00, 0x4d, 0x52, 0x00, 0x00, 0x4d, 0x5a, 0x00,
+    0x00, 0x4d, 0x64, 0x00, 0x00, 0x4d, 0x6a, 0x00, 0x00, 0x4d, 0x74, 0x00,
+    0x00, 0x4d, 0x7a, 0x00, 0x00, 0x4d, 0x80, 0x00, 0x00, 0x4d, 0x88, 0x00,
+    0x00, 0x4d, 0x91, 0x00, 0x00, 0x4d, 0x99, 0x00, 0x00, 0x4d, 0x9e, 0x00,
+    0x00, 0x4d, 0xa6, 0x00, 0x00, 0x4d, 0xae, 0x00, 0x00, 0x4d, 0xb7, 0x00,
+    0x00, 0x4d, 0xc0, 0x00, 0x00, 0x4d, 0xc9, 0x00, 0x00, 0x4d, 0xd2, 0x00,
+    0x00, 0x4d, 0xd6, 0x00, 0x00, 0x4d, 0xdb, 0x00, 0x00, 0x4d, 0xe3, 0x00,
+    0x00, 0x4d, 0xec, 0x00, 0x00, 0x4d, 0xf4, 0x00, 0x00, 0x4d, 0xfc, 0x00,
+    0x00, 0x4e, 0x02, 0x00, 0x00, 0x4e, 0x07, 0x00, 0x00, 0x4e, 0x0f, 0x00,
+    0x00, 0x4e, 0x17, 0x00, 0x00, 0x4e, 0x1d, 0x00, 0x00, 0x4e, 0x22, 0x00,
+    0x00, 0x4e, 0x2b, 0x00, 0x00, 0x4e, 0x33, 0x00, 0x00, 0x4e, 0x3d, 0x00,
+    0x00, 0x4e, 0x44, 0x00, 0x00, 0x4e, 0x4d, 0x00, 0x00, 0x4e, 0x54, 0x00,
+    0x00, 0x4e, 0x5e, 0x00, 0x00, 0x4e, 0x64, 0x00, 0x00, 0x4e, 0x6e, 0x00,
+    0x00, 0x4e, 0x74, 0x00, 0x00, 0x4e, 0x7e, 0x00, 0x00, 0x4e, 0x87, 0x00,
+    0x00, 0x4e, 0x8e, 0x00, 0x00, 0x4e, 0x97, 0x00, 0x00, 0x4e, 0x9f, 0x00,
+    0x00, 0x4e, 0xa5, 0x00, 0x00, 0x4e, 0xaf, 0x00, 0x00, 0x4e, 0xb5, 0x00,
+    0x00, 0x4e, 0xbb, 0x00, 0x00, 0x4e, 0xc1, 0x00, 0x00, 0x4e, 0xca, 0x00,
+    0x00, 0x4e, 0xd1, 0x00, 0x00, 0x4e, 0xd8, 0x00, 0x00, 0x4e, 0xe1, 0x00,
+    0x00, 0x4e, 0xe8, 0x00, 0x00, 0x4e, 0xee, 0x00, 0x00, 0x4e, 0xf5, 0x00,
+    0x00, 0x4e, 0xfe, 0x00, 0x00, 0x4f, 0x07, 0x00, 0x00, 0x4f, 0x0e, 0x00,
+    0x00, 0x4f, 0x16, 0x00, 0x00, 0x4f, 0x1d, 0x00, 0x00, 0x4f, 0x24, 0x00,
+    0x00, 0x4f, 0x2b, 0x00, 0x00, 0x4f, 0x35, 0x00, 0x00, 0x4f, 0x3a, 0x00,
+    0x00, 0x4f, 0x42, 0x00, 0x00, 0x4f, 0x4a, 0x00, 0x00, 0x4f, 0x51, 0x00,
+    0x00, 0x4f, 0x58, 0x00, 0x00, 0x4f, 0x60, 0x00, 0x00, 0x4f, 0x67, 0x00,
+    0x00, 0x4f, 0x71, 0x00, 0x00, 0x4f, 0x78, 0x00, 0x00, 0x4f, 0x7f, 0x00,
+    0x00, 0x4f, 0x89, 0x00, 0x00, 0x4f, 0x8f, 0x00, 0x00, 0x4f, 0x96, 0x00,
+    0x00, 0x4f, 0x9c, 0x00, 0x00, 0x4f, 0xa4, 0x00, 0x00, 0x4f, 0xaa, 0x00,
+    0x00, 0x4f, 0xb2, 0x00, 0x00, 0x4f, 0xb9, 0x00, 0x00, 0x4f, 0xc1, 0x00,
+    0x00, 0x4f, 0xc7, 0x00, 0x00, 0x4f, 0xce, 0x00, 0x00, 0x4f, 0xd7, 0x00,
+    0x00, 0x4f, 0xdf, 0x00, 0x00, 0x4f, 0xe7, 0x00, 0x00, 0x4f, 0xee, 0x00,
+    0x00, 0x4f, 0xf6, 0x00, 0x00, 0x4f, 0xff, 0x00, 0x00, 0x50, 0x07, 0x00,
+    0x00, 0x50, 0x0e, 0x00, 0x00, 0x50, 0x15, 0x00, 0x00, 0x50, 0x1f, 0x00,
+    0x00, 0x50, 0x25, 0x00, 0x00, 0x50, 0x2d, 0x00, 0x00, 0x50, 0x35, 0x00,
+    0x00, 0x50, 0x3e, 0x00, 0x00, 0x50, 0x45, 0x00, 0x00, 0x50, 0x4b, 0x00,
+    0x00, 0x50, 0x53, 0x00, 0x00, 0x50, 0x59, 0x00, 0x00, 0x50, 0x5e, 0x00,
+    0x00, 0x50, 0x67, 0x00, 0x00, 0x50, 0x72, 0x00, 0x00, 0x50, 0x78, 0x00,
+    0x00, 0x50, 0x7f, 0x00, 0x00, 0x50, 0x86, 0x00, 0x00, 0x50, 0x8d, 0x00,
+    0x00, 0x50, 0x94, 0x00, 0x00, 0x50, 0x99, 0x00, 0x00, 0x50, 0xa1, 0x00,
+    0x00, 0x50, 0xaa, 0x00, 0x00, 0x50, 0xb4, 0x00, 0x00, 0x50, 0xbb, 0x00,
+    0x00, 0x50, 0xc0, 0x00, 0x00, 0x50, 0xc6, 0x00, 0x00, 0x50, 0xce, 0x00,
+    0x00, 0x50, 0xd6, 0x00, 0x00, 0x50, 0xdd, 0x00, 0x00, 0x50, 0xe3, 0x00,
+    0x00, 0x50, 0xea, 0x00, 0x00, 0x50, 0xf4, 0x00, 0x00, 0x50, 0xfa, 0x00,
+    0x00, 0x51, 0x02, 0x00, 0x00, 0x51, 0x07, 0x00, 0x00, 0x51, 0x0d, 0x00,
+    0x00, 0x51, 0x16, 0x00, 0x00, 0x51, 0x1e, 0x00, 0x00, 0x51, 0x25, 0x00,
+    0x00, 0x51, 0x2f, 0x00, 0x00, 0x51, 0x37, 0x00, 0x00, 0x51, 0x3e, 0x00,
+    0x00, 0x51, 0x47, 0x00, 0x00, 0x51, 0x4d, 0x00, 0x00, 0x51, 0x51, 0x00,
+    0x00, 0x51, 0x59, 0x00, 0x00, 0x51, 0x62, 0x00, 0x00, 0x51, 0x69, 0x00,
+    0x00, 0x51, 0x70, 0x00, 0x00, 0x51, 0x75, 0x00, 0x00, 0x51, 0x7b, 0x00,
+    0x00, 0x51, 0x85, 0x00, 0x00, 0x51, 0x8d, 0x00, 0x00, 0x51, 0x96, 0x00,
+    0x00, 0x51, 0x9f, 0x00, 0x00, 0x51, 0xa5, 0x00, 0x00, 0x51, 0xaa, 0x00,
+    0x00, 0x51, 0xb2, 0x00, 0x00, 0x51, 0xba, 0x00, 0x00, 0x51, 0xc0, 0x00,
+    0x00, 0x51, 0xc7, 0x00, 0x00, 0x51, 0xcf, 0x00, 0x00, 0x51, 0xd7, 0x00,
+    0x00, 0x51, 0xdc, 0x00, 0x00, 0x51, 0xe3, 0x00, 0x00, 0x51, 0xe8, 0x00,
+    0x00, 0x51, 0xed, 0x00, 0x00, 0x51, 0xf3, 0x00, 0x00, 0x51, 0xfb, 0x00,
+    0x00, 0x52, 0x01, 0x00, 0x00, 0x52, 0x08, 0x00, 0x00, 0x52, 0x0f, 0x00,
+    0x00, 0x52, 0x17, 0x00, 0x00, 0x52, 0x1e, 0x00, 0x00, 0x52, 0x25, 0x00,
+    0x00, 0x52, 0x2a, 0x00, 0x00, 0x52, 0x30, 0x00, 0x00, 0x52, 0x38, 0x00,
+    0x00, 0x52, 0x3f, 0x00, 0x00, 0x52, 0x48, 0x00, 0x00, 0x52, 0x53, 0x00,
+    0x00, 0x52, 0x59, 0x00, 0x00, 0x52, 0x60, 0x00, 0x00, 0x52, 0x65, 0x00,
+    0x00, 0x52, 0x68, 0x00, 0x00, 0x52, 0x6e, 0x00, 0x00, 0x52, 0x76, 0x00,
+    0x00, 0x52, 0x7c, 0x00, 0x00, 0x52, 0x82, 0x00, 0x00, 0x52, 0x8b, 0x00,
+    0x00, 0x52, 0x90, 0x00, 0x00, 0x52, 0x96, 0x00, 0x00, 0x52, 0x9e, 0x00,
+    0x00, 0x52, 0xa7, 0x00, 0x00, 0x52, 0xaf, 0x00, 0x00, 0x52, 0xb5, 0x00,
+    0x00, 0x52, 0xba, 0x00, 0x00, 0x52, 0xc2, 0x00, 0x00, 0x52, 0xce, 0x00,
+    0x00, 0x52, 0xd3, 0x00, 0x00, 0x52, 0xd8, 0x00, 0x00, 0x52, 0xdd, 0x00,
+    0x00, 0x52, 0xe3, 0x00, 0x00, 0x52, 0xeb, 0x00, 0x00, 0x52, 0xf5, 0x00,
+    0x00, 0x52, 0xfe, 0x00, 0x00, 0x53, 0x07, 0x00, 0x00, 0x53, 0x0e, 0x00,
+    0x00, 0x53, 0x16, 0x00, 0x00, 0x53, 0x1d, 0x00, 0x00, 0x53, 0x26, 0x00,
+    0x00, 0x53, 0x2d, 0x00, 0x00, 0x53, 0x34, 0x00, 0x00, 0x53, 0x3c, 0x00,
+    0x00, 0x53, 0x43, 0x00, 0x00, 0x53, 0x4b, 0x00, 0x00, 0x53, 0x53, 0x00,
+    0x00, 0x53, 0x5d, 0x00, 0x00, 0x53, 0x61, 0x00, 0x00, 0x53, 0x69, 0x00,
+    0x00, 0x53, 0x70, 0x00, 0x00, 0x53, 0x7b, 0x00, 0x00, 0x53, 0x81, 0x00,
+    0x00, 0x53, 0x8b, 0x00, 0x00, 0x53, 0x93, 0x00, 0x00, 0x53, 0x9c, 0x00,
+    0x00, 0x53, 0xa6, 0x00, 0x00, 0x53, 0xad, 0x00, 0x00, 0x53, 0xb3, 0x00,
+    0x00, 0x53, 0xbc, 0x00, 0x00, 0x53, 0xc4, 0x00, 0x00, 0x53, 0xcc, 0x00,
+    0x00, 0x53, 0xd4, 0x00, 0x00, 0x53, 0xdb, 0x00, 0x00, 0x53, 0xe3, 0x00,
+    0x00, 0x53, 0xea, 0x00, 0x00, 0x53, 0xf2, 0x00, 0x00, 0x53, 0xf9, 0x00,
+    0x00, 0x54, 0x01, 0x00, 0x00, 0x54, 0x0c, 0x00, 0x00, 0x54, 0x0f, 0x00,
+    0x00, 0x54, 0x16, 0x00, 0x00, 0x54, 0x1d, 0x00, 0x00, 0x54, 0x25, 0x00,
+    0x00, 0x54, 0x2b, 0x00, 0x00, 0x54, 0x31, 0x00, 0x00, 0x54, 0x39, 0x00,
+    0x00, 0x54, 0x42, 0x00, 0x00, 0x54, 0x4b, 0x00, 0x00, 0x54, 0x52, 0x00,
+    0x00, 0x54, 0x5a, 0x00, 0x00, 0x54, 0x60, 0x00, 0x00, 0x54, 0x69, 0x00,
+    0x00, 0x54, 0x76, 0x00, 0x00, 0x54, 0x7b, 0x00, 0x00, 0x54, 0x83, 0x00,
+    0x00, 0x54, 0x8b, 0x00, 0x00, 0x54, 0x90, 0x00, 0x00, 0x54, 0x96, 0x00,
+    0x00, 0x54, 0xa1, 0x00, 0x00, 0x54, 0xa6, 0x00, 0x00, 0x54, 0xac, 0x00,
+    0x00, 0x54, 0xb2, 0x00, 0x00, 0x54, 0xb8, 0x00, 0x00, 0x54, 0xbe, 0x00,
+    0x00, 0x54, 0xc8, 0x00, 0x00, 0x54, 0xd2, 0x00, 0x00, 0x54, 0xdb, 0x00,
+    0x00, 0x54, 0xe2, 0x00, 0x00, 0x54, 0xea, 0x00, 0x00, 0x54, 0xf1, 0x00,
+    0x00, 0x54, 0xf7, 0x00, 0x00, 0x54, 0xfe, 0x00, 0x00, 0x55, 0x05, 0x00,
+    0x00, 0x55, 0x0d, 0x00, 0x00, 0x55, 0x14, 0x00, 0x00, 0x55, 0x1b, 0x00,
+    0x00, 0x55, 0x21, 0x00, 0x00, 0x55, 0x29, 0x00, 0x00, 0x55, 0x30, 0x00,
+    0x00, 0x55, 0x35, 0x00, 0x00, 0x55, 0x3d, 0x00, 0x00, 0x55, 0x43, 0x00,
+    0x00, 0x55, 0x4b, 0x00, 0x00, 0x55, 0x53, 0x00, 0x00, 0x55, 0x5b, 0x00,
+    0x00, 0x55, 0x62, 0x00, 0x00, 0x55, 0x6a, 0x00, 0x00, 0x55, 0x71, 0x00,
+    0x00, 0x55, 0x78, 0x00, 0x00, 0x55, 0x80, 0x00, 0x00, 0x55, 0x8c, 0x00,
+    0x00, 0x55, 0x93, 0x00, 0x00, 0x55, 0x9a, 0x00, 0x00, 0x55, 0xa2, 0x00,
+    0x00, 0x55, 0xa8, 0x00, 0x00, 0x55, 0xb2, 0x00, 0x00, 0x55, 0xb6, 0x00,
+    0x00, 0x55, 0xbe, 0x00, 0x00, 0x55, 0xc1, 0x00, 0x00, 0x55, 0xcb, 0x00,
+    0x00, 0x55, 0xd0, 0x00, 0x00, 0x55, 0xd5, 0x00, 0x00, 0x55, 0xdc, 0x00,
+    0x00, 0x55, 0xe6, 0x00, 0x00, 0x55, 0xee, 0x00, 0x00, 0x55, 0xf4, 0x00,
+    0x00, 0x55, 0xfc, 0x00, 0x00, 0x56, 0x06, 0x00, 0x00, 0x56, 0x0e, 0x00,
+    0x00, 0x56, 0x16, 0x00, 0x00, 0x56, 0x1c, 0x00, 0x00, 0x56, 0x24, 0x00,
+    0x00, 0x56, 0x2b, 0x00, 0x00, 0x56, 0x34, 0x00, 0x00, 0x56, 0x3e, 0x00,
+    0x00, 0x56, 0x46, 0x00, 0x00, 0x56, 0x4e, 0x00, 0x00, 0x56, 0x56, 0x00,
+    0x00, 0x56, 0x5d, 0x00, 0x00, 0x56, 0x68, 0x00, 0x00, 0x56, 0x71, 0x00,
+    0x00, 0x56, 0x77, 0x00, 0x00, 0x56, 0x7e, 0x00, 0x00, 0x56, 0x84, 0x00,
+    0x00, 0x56, 0x89, 0x00, 0x00, 0x56, 0x8f, 0x00, 0x00, 0x56, 0x97, 0x00,
+    0x00, 0x56, 0x9f, 0x00, 0x00, 0x56, 0xa6, 0x00, 0x00, 0x56, 0xad, 0x00,
+    0x00, 0x56, 0xb3, 0x00, 0x00, 0x56, 0xba, 0x00, 0x00, 0x56, 0xc0, 0x00,
+    0x00, 0x56, 0xc6, 0x00, 0x00, 0x56, 0xcd, 0x00, 0x00, 0x56, 0xd5, 0x00,
+    0x00, 0x56, 0xdd, 0x00, 0x00, 0x56, 0xe2, 0x00, 0x00, 0x56, 0xe9, 0x00,
+    0x00, 0x56, 0xf1, 0x00, 0x00, 0x56, 0xfa, 0x00, 0x00, 0x57, 0x04, 0x00,
+    0x00, 0x57, 0x09, 0x00, 0x00, 0x57, 0x0f, 0x00, 0x00, 0x57, 0x18, 0x00,
+    0x00, 0x57, 0x22, 0x00, 0x00, 0x57, 0x28, 0x00, 0x00, 0x57, 0x2f, 0x00,
+    0x00, 0x57, 0x34, 0x00, 0x00, 0x57, 0x3a, 0x00, 0x00, 0x57, 0x3f, 0x00,
+    0x00, 0x57, 0x45, 0x00, 0x00, 0x57, 0x4e, 0x00, 0x00, 0x57, 0x55, 0x00,
+    0x00, 0x57, 0x5b, 0x00, 0x00, 0x57, 0x63, 0x00, 0x00, 0x57, 0x6a, 0x00,
+    0x00, 0x57, 0x71, 0x00, 0x00, 0x57, 0x78, 0x00, 0x00, 0x57, 0x80, 0x00,
+    0x00, 0x57, 0x87, 0x00, 0x00, 0x57, 0x91, 0x00, 0x00, 0x57, 0x9b, 0x00,
+    0x00, 0x57, 0xa2, 0x00, 0x00, 0x57, 0xab, 0x00, 0x00, 0x57, 0xb1, 0x00,
+    0x00, 0x57, 0xba, 0x00, 0x00, 0x57, 0xc0, 0x00, 0x00, 0x57, 0xca, 0x00,
+    0x00, 0x57, 0xd1, 0x00, 0x00, 0x57, 0xd8, 0x00, 0x00, 0x57, 0xe2, 0x00,
+    0x00, 0x57, 0xe9, 0x00, 0x00, 0x57, 0xf0, 0x00, 0x00, 0x57, 0xf8, 0x00,
+    0x00, 0x58, 0x00, 0x00, 0x00, 0x58, 0x05, 0x00, 0x00, 0x58, 0x0c, 0x00,
+    0x00, 0x58, 0x11, 0x00, 0x00, 0x58, 0x1a, 0x00, 0x00, 0x58, 0x22, 0x00,
+    0x00, 0x58, 0x29, 0x00, 0x00, 0x58, 0x2f, 0x00, 0x00, 0x58, 0x36, 0x00,
+    0x00, 0x58, 0x3d, 0x00, 0x00, 0x58, 0x43, 0x00, 0x00, 0x58, 0x49, 0x00,
+    0x00, 0x58, 0x4f, 0x00, 0x00, 0x58, 0x55, 0x00, 0x00, 0x58, 0x5d, 0x00,
+    0x00, 0x58, 0x65, 0x00, 0x00, 0x58, 0x6a, 0x00, 0x00, 0x58, 0x6f, 0x00,
+    0x00, 0x58, 0x78, 0x00, 0x00, 0x58, 0x7e, 0x00, 0x00, 0x58, 0x85, 0x00,
+    0x00, 0x58, 0x8c, 0x00, 0x00, 0x58, 0x99, 0x00, 0x00, 0x58, 0x9f, 0x00,
+    0x00, 0x58, 0xa9, 0x00, 0x00, 0x58, 0xb1, 0x00, 0x00, 0x58, 0xb7, 0x00,
+    0x00, 0x58, 0xbf, 0x00, 0x00, 0x58, 0xca, 0x00, 0x00, 0x58, 0xd0, 0x00,
+    0x00, 0x58, 0xd7, 0x00, 0x00, 0x58, 0xdd, 0x00, 0x00, 0x58, 0xe4, 0x00,
+    0x00, 0x58, 0xed, 0x00, 0x00, 0x58, 0xf6, 0x00, 0x00, 0x58, 0xfc, 0x00,
+    0x00, 0x59, 0x04, 0x00, 0x00, 0x59, 0x09, 0x00, 0x00, 0x59, 0x11, 0x00,
+    0x00, 0x59, 0x18, 0x00, 0x00, 0x59, 0x1d, 0x00, 0x00, 0x59, 0x23, 0x00,
+    0x00, 0x59, 0x2a, 0x00, 0x00, 0x59, 0x31, 0x00, 0x00, 0x59, 0x38, 0x00,
+    0x00, 0x59, 0x40, 0x00, 0x00, 0x59, 0x47, 0x00, 0x00, 0x59, 0x4e, 0x00,
+    0x00, 0x59, 0x53, 0x00, 0x00, 0x59, 0x5c, 0x00, 0x00, 0x59, 0x68, 0x00,
+    0x00, 0x59, 0x71, 0x00, 0x00, 0x59, 0x75, 0x00, 0x00, 0x59, 0x7d, 0x00,
+    0x00, 0x59, 0x83, 0x00, 0x00, 0x59, 0x8c, 0x00, 0x00, 0x59, 0x92, 0x00,
+    0x00, 0x59, 0x98, 0x00, 0x00, 0x59, 0xa0, 0x00, 0x00, 0x59, 0xa8, 0x00,
+    0x00, 0x59, 0xaf, 0x00, 0x00, 0x59, 0xb7, 0x00, 0x00, 0x59, 0xc0, 0x00,
+    0x00, 0x59, 0xc9, 0x00, 0x00, 0x59, 0xd1, 0x00, 0x00, 0x59, 0xd7, 0x00,
+    0x00, 0x59, 0xdc, 0x00, 0x00, 0x59, 0xe1, 0x00, 0x00, 0x59, 0xe9, 0x00,
+    0x00, 0x59, 0xef, 0x00, 0x00, 0x59, 0xf5, 0x00, 0x00, 0x59, 0xfc, 0x00,
+    0x00, 0x5a, 0x04, 0x00, 0x00, 0x5a, 0x0b, 0x00, 0x00, 0x5a, 0x11, 0x00,
+    0x00, 0x5a, 0x19, 0x00, 0x00, 0x5a, 0x1f, 0x00, 0x00, 0x5a, 0x2b, 0x00,
+    0x00, 0x5a, 0x32, 0x00, 0x00, 0x5a, 0x36, 0x00, 0x00, 0x5a, 0x3e, 0x00,
+    0x00, 0x5a, 0x41, 0x00, 0x00, 0x5a, 0x49, 0x00, 0x00, 0x5a, 0x52, 0x00,
+    0x00, 0x5a, 0x5a, 0x00, 0x00, 0x5a, 0x61, 0x00, 0x00, 0x5a, 0x67, 0x00,
+    0x00, 0x5a, 0x6f, 0x00, 0x00, 0x5a, 0x78, 0x00, 0x00, 0x5a, 0x7e, 0x00,
+    0x00, 0x5a, 0x83, 0x00, 0x00, 0x5a, 0x89, 0x00, 0x00, 0x5a, 0x8f, 0x00,
+    0x00, 0x5a, 0x97, 0x00, 0x00, 0x5a, 0x9e, 0x00, 0x00, 0x5a, 0xa4, 0x00,
+    0x00, 0x5a, 0xad, 0x00, 0x00, 0x5a, 0xb5, 0x00, 0x00, 0x5a, 0xbd, 0x00,
+    0x00, 0x5a, 0xc3, 0x00, 0x00, 0x5a, 0xcd, 0x00, 0x00, 0x5a, 0xd8, 0x00,
+    0x00, 0x5a, 0xe0, 0x00, 0x00, 0x5a, 0xe9, 0x00, 0x00, 0x5a, 0xf1, 0x00,
+    0x00, 0x5a, 0xfa, 0x00, 0x00, 0x5b, 0x04, 0x00, 0x00, 0x5b, 0x0a, 0x00,
+    0x00, 0x5b, 0x0d, 0x00, 0x00, 0x5b, 0x14, 0x00, 0x00, 0x5b, 0x1c, 0x00,
+    0x00, 0x5b, 0x22, 0x00, 0x00, 0x5b, 0x27, 0x00, 0x00, 0x5b, 0x2c, 0x00,
+    0x00, 0x5b, 0x35, 0x00, 0x00, 0x5b, 0x3a, 0x00, 0x00, 0x5b, 0x41, 0x00,
+    0x00, 0x5b, 0x4a, 0x00, 0x00, 0x5b, 0x4f, 0x00, 0x00, 0x5b, 0x59, 0x00,
+    0x00, 0x5b, 0x5e, 0x00, 0x00, 0x5b, 0x64, 0x00, 0x00, 0x5b, 0x6a, 0x00,
+    0x00, 0x5b, 0x72, 0x00, 0x00, 0x5b, 0x78, 0x00, 0x00, 0x5b, 0x7d, 0x00,
+    0x00, 0x5b, 0x84, 0x00, 0x00, 0x5b, 0x8d, 0x00, 0x00, 0x5b, 0x95, 0x00,
+    0x00, 0x5b, 0x9e, 0x00, 0x00, 0x5b, 0xa5, 0x00, 0x00, 0x5b, 0xad, 0x00,
+    0x00, 0x5b, 0xb4, 0x00, 0x00, 0x5b, 0xba, 0x00, 0x00, 0x5b, 0xc2, 0x00,
+    0x00, 0x5b, 0xc7, 0x00, 0x00, 0x5b, 0xcd, 0x00, 0x00, 0x5b, 0xd5, 0x00,
+    0x00, 0x5b, 0xdd, 0x00, 0x00, 0x5b, 0xe4, 0x00, 0x00, 0x5b, 0xed, 0x00,
+    0x00, 0x5b, 0xf6, 0x00, 0x00, 0x5b, 0xfc, 0x00, 0x00, 0x5c, 0x02, 0x00,
+    0x00, 0x5c, 0x0a, 0x00, 0x00, 0x5c, 0x10, 0x00, 0x00, 0x5c, 0x15, 0x00,
+    0x00, 0x5c, 0x1d, 0x00, 0x00, 0x5c, 0x28, 0x00, 0x00, 0x5c, 0x2f, 0x00,
+    0x00, 0x5c, 0x36, 0x00, 0x00, 0x5c, 0x3b, 0x00, 0x00, 0x5c, 0x43, 0x00,
+    0x00, 0x5c, 0x4a, 0x00, 0x00, 0x5c, 0x50, 0x00, 0x00, 0x5c, 0x58, 0x00,
+    0x00, 0x5c, 0x61, 0x00, 0x00, 0x5c, 0x68, 0x00, 0x00, 0x5c, 0x6f, 0x00,
+    0x00, 0x5c, 0x76, 0x00, 0x00, 0x5c, 0x7e, 0x00, 0x00, 0x5c, 0x83, 0x00,
+    0x00, 0x5c, 0x89, 0x00, 0x00, 0x5c, 0x8f, 0x00, 0x00, 0x5c, 0x96, 0x00,
+    0x00, 0x5c, 0x9d, 0x00, 0x00, 0x5c, 0xa5, 0x00, 0x00, 0x5c, 0xb1, 0x00,
+    0x00, 0x5c, 0xbb, 0x00, 0x00, 0x5c, 0xc1, 0x00, 0x00, 0x5c, 0xca, 0x00,
+    0x00, 0x5c, 0xcf, 0x00, 0x00, 0x5c, 0xdb, 0x00, 0x00, 0x5c, 0xe3, 0x00,
+    0x00, 0x5c, 0xee, 0x00, 0x00, 0x5c, 0xf7, 0x00, 0x00, 0x5d, 0x00, 0x00,
+    0x00, 0x5d, 0x08, 0x00, 0x00, 0x5d, 0x0d, 0x00, 0x00, 0x5d, 0x14, 0x00,
+    0x00, 0x5d, 0x1b, 0x00, 0x00, 0x5d, 0x23, 0x00, 0x00, 0x5d, 0x28, 0x00,
+    0x00, 0x5d, 0x2f, 0x00, 0x00, 0x5d, 0x37, 0x00, 0x00, 0x5d, 0x3e, 0x00,
+    0x00, 0x5d, 0x44, 0x00, 0x00, 0x5d, 0x4e, 0x00, 0x00, 0x5d, 0x56, 0x00,
+    0x00, 0x5d, 0x5b, 0x00, 0x00, 0x5d, 0x62, 0x00, 0x00, 0x5d, 0x67, 0x00,
+    0x00, 0x5d, 0x70, 0x00, 0x00, 0x5d, 0x77, 0x00, 0x00, 0x5d, 0x7e, 0x00,
+    0x00, 0x5d, 0x86, 0x00, 0x00, 0x5d, 0x8b, 0x00, 0x00, 0x5d, 0x94, 0x00,
+    0x00, 0x5d, 0x9a, 0x00, 0x00, 0x5d, 0x9f, 0x00, 0x00, 0x5d, 0xa6, 0x00,
+    0x00, 0x5d, 0xab, 0x00, 0x00, 0x5d, 0xb1, 0x00, 0x00, 0x5d, 0xb6, 0x00,
+    0x00, 0x5d, 0xbe, 0x00, 0x00, 0x5d, 0xc3, 0x00, 0x00, 0x5d, 0xca, 0x00,
+    0x00, 0x5d, 0xd0, 0x00, 0x00, 0x5d, 0xd6, 0x00, 0x00, 0x5d, 0xe1, 0x00,
+    0x00, 0x5d, 0xea, 0x00, 0x00, 0x5d, 0xf2, 0x00, 0x00, 0x5d, 0xf6, 0x00,
+    0x00, 0x5d, 0xfc, 0x00, 0x00, 0x5e, 0x01, 0x00, 0x00, 0x5e, 0x09, 0x00,
+    0x00, 0x5e, 0x11, 0x00, 0x00, 0x5e, 0x17, 0x00, 0x00, 0x5e, 0x1c, 0x00,
+    0x00, 0x5e, 0x22, 0x00, 0x00, 0x5e, 0x2c, 0x00, 0x00, 0x5e, 0x35, 0x00,
+    0x00, 0x5e, 0x3f, 0x00, 0x00, 0x5e, 0x49, 0x00, 0x00, 0x5e, 0x52, 0x00,
+    0x00, 0x5e, 0x5a, 0x00, 0x00, 0x5e, 0x5f, 0x00, 0x00, 0x5e, 0x67, 0x00,
+    0x00, 0x5e, 0x6c, 0x00, 0x00, 0x5e, 0x76, 0x00, 0x00, 0x5e, 0x7d, 0x00,
+    0x00, 0x5e, 0x87, 0x00, 0x00, 0x5e, 0x90, 0x00, 0x00, 0x5e, 0x99, 0x00,
+    0x00, 0x5e, 0xa0, 0x00, 0x00, 0x5e, 0xa7, 0x00, 0x00, 0x5e, 0xaf, 0x00,
+    0x00, 0x5e, 0xb7, 0x00, 0x00, 0x5e, 0xbd, 0x00, 0x00, 0x5e, 0xc8, 0x00,
+    0x00, 0x5e, 0xcf, 0x00, 0x00, 0x5e, 0xd6, 0x00, 0x00, 0x5e, 0xdd, 0x00,
+    0x00, 0x5e, 0xe3, 0x00, 0x00, 0x5e, 0xed, 0x00, 0x00, 0x5e, 0xf6, 0x00,
+    0x00, 0x5e, 0xfe, 0x00, 0x00, 0x5f, 0x05, 0x00, 0x00, 0x5f, 0x0c, 0x00,
+    0x00, 0x5f, 0x0f, 0x00, 0x00, 0x5f, 0x14, 0x00, 0x00, 0x5f, 0x1d, 0x00,
+    0x00, 0x5f, 0x25, 0x00, 0x00, 0x5f, 0x2b, 0x00, 0x00, 0x5f, 0x33, 0x00,
+    0x00, 0x5f, 0x3d, 0x00, 0x00, 0x5f, 0x47, 0x00, 0x00, 0x5f, 0x4d, 0x00,
+    0x00, 0x5f, 0x54, 0x00, 0x00, 0x5f, 0x5c, 0x00, 0x00, 0x5f, 0x63, 0x00,
+    0x00, 0x5f, 0x68, 0x00, 0x00, 0x5f, 0x70, 0x00, 0x00, 0x5f, 0x7b, 0x00,
+    0x00, 0x5f, 0x82, 0x00, 0x00, 0x5f, 0x88, 0x00, 0x00, 0x5f, 0x91, 0x00,
+    0x00, 0x5f, 0x9b, 0x00, 0x00, 0x5f, 0xa5, 0x00, 0x00, 0x5f, 0xab, 0x00,
+    0x00, 0x5f, 0xb4, 0x00, 0x00, 0x5f, 0xba, 0x00, 0x00, 0x5f, 0xc6, 0x00,
+    0x00, 0x5f, 0xcd, 0x00, 0x00, 0x5f, 0xd2, 0x00, 0x00, 0x5f, 0xd7, 0x00,
+    0x00, 0x5f, 0xde, 0x00, 0x00, 0x5f, 0xe5, 0x00, 0x00, 0x5f, 0xeb, 0x00,
+    0x00, 0x5f, 0xf2, 0x00, 0x00, 0x5f, 0xfa, 0x00, 0x00, 0x60, 0x01, 0x00,
+    0x00, 0x60, 0x0b, 0x00, 0x00, 0x60, 0x12, 0x00, 0x00, 0x60, 0x1a, 0x00,
+    0x00, 0x60, 0x22, 0x00, 0x00, 0x60, 0x29, 0x00, 0x00, 0x60, 0x30, 0x00,
+    0x00, 0x60, 0x38, 0x00, 0x00, 0x60, 0x41, 0x00, 0x00, 0x60, 0x49, 0x00,
+    0x00, 0x60, 0x52, 0x00, 0x00, 0x60, 0x58, 0x00, 0x00, 0x60, 0x60, 0x00,
+    0x00, 0x60, 0x67, 0x00, 0x00, 0x60, 0x6b, 0x00, 0x00, 0x60, 0x70, 0x00,
+    0x00, 0x60, 0x77, 0x00, 0x00, 0x60, 0x7d, 0x00, 0x00, 0x60, 0x84, 0x00,
+    0x00, 0x60, 0x8c, 0x00, 0x00, 0x60, 0x93, 0x00, 0x00, 0x60, 0x9b, 0x00,
+    0x00, 0x60, 0xa2, 0x00, 0x00, 0x60, 0xa7, 0x00, 0x00, 0x60, 0xad, 0x00,
+    0x00, 0x60, 0xb5, 0x00, 0x00, 0x60, 0xbb, 0x00, 0x00, 0x60, 0xc3, 0x00,
+    0x00, 0x60, 0xc9, 0x00, 0x00, 0x60, 0xd1, 0x00, 0x00, 0x60, 0xd7, 0x00,
+    0x00, 0x60, 0xdf, 0x00, 0x00, 0x60, 0xe6, 0x00, 0x00, 0x60, 0xf0, 0x00,
+    0x00, 0x60, 0xf7, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x61, 0x08, 0x00,
+    0x00, 0x61, 0x0e, 0x00, 0x00, 0x61, 0x15, 0x00, 0x00, 0x61, 0x20, 0x00,
+    0x00, 0x61, 0x29, 0x00, 0x00, 0x61, 0x32, 0x00, 0x00, 0x61, 0x37, 0x00,
+    0x00, 0x61, 0x3f, 0x00, 0x00, 0x61, 0x45, 0x00, 0x00, 0x61, 0x4c, 0x00,
+    0x00, 0x61, 0x56, 0x00, 0x00, 0x61, 0x5d, 0x00, 0x00, 0x61, 0x66, 0x00,
+    0x00, 0x61, 0x6c, 0x00, 0x00, 0x61, 0x73, 0x00, 0x00, 0x61, 0x7a, 0x00,
+    0x00, 0x61, 0x81, 0x00, 0x00, 0x61, 0x88, 0x00, 0x00, 0x61, 0x90, 0x00,
+    0x00, 0x61, 0x99, 0x00, 0x00, 0x61, 0x9e, 0x00, 0x00, 0x61, 0xa5, 0x00,
+    0x00, 0x61, 0xa9, 0x00, 0x00, 0x61, 0xb0, 0x00, 0x00, 0x61, 0xb7, 0x00,
+    0x00, 0x61, 0xbd, 0x00, 0x00, 0x61, 0xc2, 0x00, 0x00, 0x61, 0xcd, 0x00,
+    0x00, 0x61, 0xd4, 0x00, 0x00, 0x61, 0xde, 0x00, 0x00, 0x61, 0xe5, 0x00,
+    0x00, 0x61, 0xeb, 0x00, 0x00, 0x61, 0xf3, 0x00, 0x00, 0x61, 0xfb, 0x00,
+    0x00, 0x62, 0x01, 0x00, 0x00, 0x62, 0x06, 0x00, 0x00, 0x62, 0x0c, 0x00,
+    0x00, 0x62, 0x15, 0x00, 0x00, 0x62, 0x1d, 0x00, 0x00, 0x62, 0x22, 0x00,
+    0x00, 0x62, 0x28, 0x00, 0x00, 0x62, 0x2c, 0x00, 0x00, 0x62, 0x34, 0x00,
+    0x00, 0x62, 0x39, 0x00, 0x00, 0x62, 0x42, 0x00, 0x00, 0x62, 0x48, 0x00,
+    0x00, 0x62, 0x4d, 0x00, 0x00, 0x62, 0x54, 0x00, 0x00, 0x62, 0x5d, 0x00,
+    0x00, 0x62, 0x64, 0x00, 0x00, 0x62, 0x6a, 0x00, 0x00, 0x62, 0x72, 0x00,
+    0x00, 0x62, 0x79, 0x00, 0x00, 0x62, 0x7d, 0x00, 0x00, 0x62, 0x84, 0x00,
+    0x00, 0x62, 0x8f, 0x00, 0x00, 0x62, 0x96, 0x00, 0x00, 0x62, 0x9e, 0x00,
+    0x00, 0x62, 0xa5, 0x00, 0x00, 0x62, 0xad, 0x00, 0x00, 0x62, 0xb6, 0x00,
+    0x00, 0x62, 0xbd, 0x00, 0x00, 0x62, 0xc4, 0x00, 0x00, 0x62, 0xcf, 0x00,
+    0x00, 0x62, 0xd5, 0x00, 0x00, 0x62, 0xd8, 0x00, 0x00, 0x62, 0xde, 0x00,
+    0x00, 0x62, 0xe4, 0x00, 0x00, 0x62, 0xeb, 0x00, 0x00, 0x62, 0xf2, 0x00,
+    0x00, 0x62, 0xfa, 0x00, 0x00, 0x63, 0x01, 0x00, 0x00, 0x63, 0x08, 0x00,
+    0x00, 0x63, 0x14, 0x00, 0x00, 0x63, 0x1b, 0x00, 0x00, 0x63, 0x21, 0x00,
+    0x00, 0x63, 0x27, 0x00, 0x00, 0x63, 0x2e, 0x00, 0x00, 0x63, 0x33, 0x00,
+    0x00, 0x63, 0x39, 0x00, 0x00, 0x63, 0x41, 0x00, 0x00, 0x63, 0x4b, 0x00,
+    0x00, 0x63, 0x4f, 0x00, 0x00, 0x63, 0x55, 0x00, 0x00, 0x63, 0x5e, 0x00,
+    0x00, 0x63, 0x64, 0x00, 0x00, 0x63, 0x68, 0x00, 0x00, 0x63, 0x6f, 0x00,
+    0x00, 0x63, 0x75, 0x00, 0x00, 0x63, 0x7c, 0x00, 0x00, 0x63, 0x83, 0x00,
+    0x00, 0x63, 0x8b, 0x00, 0x00, 0x63, 0x93, 0x00, 0x00, 0x63, 0x9c, 0x00,
+    0x00, 0x63, 0xa5, 0x00, 0x00, 0x63, 0xae, 0x00, 0x00, 0x63, 0xb6, 0x00,
+    0x00, 0x63, 0xbd, 0x00, 0x00, 0x63, 0xc3, 0x00, 0x00, 0x63, 0xca, 0x00,
+    0x00, 0x63, 0xd3, 0x00, 0x00, 0x63, 0xd9, 0x00, 0x00, 0x63, 0xe1, 0x00,
+    0x00, 0x63, 0xe7, 0x00, 0x00, 0x63, 0xed, 0x00, 0x00, 0x63, 0xf7, 0x00,
+    0x00, 0x63, 0xfe, 0x00, 0x00, 0x64, 0x04, 0x00, 0x00, 0x64, 0x0c, 0x00,
+    0x00, 0x64, 0x13, 0x00, 0x00, 0x64, 0x1a, 0x00, 0x00, 0x64, 0x1e, 0x00,
+    0x00, 0x64, 0x24, 0x00, 0x00, 0x64, 0x2a, 0x00, 0x00, 0x64, 0x31, 0x00,
+    0x00, 0x64, 0x38, 0x00, 0x00, 0x64, 0x3f, 0x00, 0x00, 0x64, 0x46, 0x00,
+    0x00, 0x64, 0x4d, 0x00, 0x00, 0x64, 0x54, 0x00, 0x00, 0x64, 0x5e, 0x00,
+    0x00, 0x64, 0x65, 0x00, 0x00, 0x64, 0x6c, 0x00, 0x00, 0x64, 0x75, 0x00,
+    0x00, 0x64, 0x7a, 0x00, 0x00, 0x64, 0x82, 0x00, 0x00, 0x64, 0x88, 0x00,
+    0x00, 0x64, 0x90, 0x00, 0x00, 0x64, 0x99, 0x00, 0x00, 0x64, 0xa0, 0x00,
+    0x00, 0x64, 0xa6, 0x00, 0x00, 0x64, 0xac, 0x00, 0x00, 0x64, 0xb4, 0x00,
+    0x00, 0x64, 0xb9, 0x00, 0x00, 0x64, 0xbe, 0x00, 0x00, 0x64, 0xc3, 0x00,
+    0x00, 0x64, 0xcc, 0x00, 0x00, 0x64, 0xd2, 0x00, 0x00, 0x64, 0xd9, 0x00,
+    0x00, 0x64, 0xe1, 0x00, 0x00, 0x64, 0xe9, 0x00, 0x00, 0x64, 0xf1, 0x00,
+    0x00, 0x64, 0xf6, 0x00, 0x00, 0x64, 0xff, 0x00, 0x00, 0x65, 0x06, 0x00,
+    0x00, 0x65, 0x0f, 0x00, 0x00, 0x65, 0x15, 0x00, 0x00, 0x65, 0x1d, 0x00,
+    0x00, 0x65, 0x23, 0x00, 0x00, 0x65, 0x2b, 0x00, 0x00, 0x65, 0x31, 0x00,
+    0x00, 0x65, 0x37, 0x00, 0x00, 0x65, 0x3e, 0x00, 0x00, 0x65, 0x42, 0x00,
+    0x00, 0x65, 0x4b, 0x00, 0x00, 0x65, 0x51, 0x00, 0x00, 0x65, 0x5a, 0x00,
+    0x00, 0x65, 0x60, 0x00, 0x00, 0x65, 0x67, 0x00, 0x00, 0x65, 0x70, 0x00,
+    0x00, 0x65, 0x77, 0x00, 0x00, 0x65, 0x80, 0x00, 0x00, 0x65, 0x88, 0x00,
+    0x00, 0x65, 0x92, 0x00, 0x00, 0x65, 0x98, 0x00, 0x00, 0x65, 0xa0, 0x00,
+    0x00, 0x65, 0xa8, 0x00, 0x00, 0x65, 0xad, 0x00, 0x00, 0x65, 0xb6, 0x00,
+    0x00, 0x65, 0xbe, 0x00, 0x00, 0x65, 0xc5, 0x00, 0x00, 0x65, 0xcb, 0x00,
+    0x00, 0x65, 0xd0, 0x00, 0x00, 0x65, 0xd9, 0x00, 0x00, 0x65, 0xdf, 0x00,
+    0x00, 0x65, 0xe8, 0x00, 0x00, 0x65, 0xef, 0x00, 0x00, 0x65, 0xf4, 0x00,
+    0x00, 0x65, 0xfe, 0x00, 0x00, 0x66, 0x07, 0x00, 0x00, 0x66, 0x0f, 0x00,
+    0x00, 0x66, 0x16, 0x00, 0x00, 0x66, 0x1c, 0x00, 0x00, 0x66, 0x25, 0x00,
+    0x00, 0x66, 0x2e, 0x00, 0x00, 0x66, 0x35, 0x00, 0x00, 0x66, 0x3e, 0x00,
+    0x00, 0x66, 0x43, 0x00, 0x00, 0x66, 0x4a, 0x00, 0x00, 0x66, 0x52, 0x00,
+    0x00, 0x66, 0x5a, 0x00, 0x00, 0x66, 0x60, 0x00, 0x00, 0x66, 0x67, 0x00,
+    0x00, 0x66, 0x6d, 0x00, 0x00, 0x66, 0x75, 0x00, 0x00, 0x66, 0x7e, 0x00,
+    0x00, 0x66, 0x87, 0x00, 0x00, 0x66, 0x90, 0x00, 0x00, 0x66, 0x96, 0x00,
+    0x00, 0x66, 0x9e, 0x00, 0x00, 0x66, 0xa6, 0x00, 0x00, 0x66, 0xab, 0x00,
+    0x00, 0x66, 0xb2, 0x00, 0x00, 0x66, 0xb9, 0x00, 0x00, 0x66, 0xbf, 0x00,
+    0x00, 0x66, 0xc8, 0x00, 0x00, 0x66, 0xcf, 0x00, 0x00, 0x66, 0xd6, 0x00,
+    0x00, 0x66, 0xde, 0x00, 0x00, 0x66, 0xe5, 0x00, 0x00, 0x66, 0xee, 0x00,
+    0x00, 0x66, 0xf4, 0x00, 0x00, 0x66, 0xf9, 0x00, 0x00, 0x67, 0x00, 0x00,
+    0x00, 0x67, 0x06, 0x00, 0x00, 0x67, 0x0e, 0x00, 0x00, 0x67, 0x13, 0x00,
+    0x00, 0x67, 0x18, 0x00, 0x00, 0x67, 0x1f, 0x00, 0x00, 0x67, 0x26, 0x00,
+    0x00, 0x67, 0x2d, 0x00, 0x00, 0x67, 0x34, 0x00, 0x00, 0x67, 0x3d, 0x00,
+    0x00, 0x67, 0x44, 0x00, 0x00, 0x67, 0x4c, 0x00, 0x00, 0x67, 0x51, 0x00,
+    0x00, 0x67, 0x57, 0x00, 0x00, 0x67, 0x5e, 0x00, 0x00, 0x67, 0x66, 0x00,
+    0x00, 0x67, 0x6d, 0x00, 0x00, 0x67, 0x74, 0x00, 0x00, 0x67, 0x7a, 0x00,
+    0x00, 0x67, 0x82, 0x00, 0x00, 0x67, 0x8b, 0x00, 0x00, 0x67, 0x91, 0x00,
+    0x00, 0x67, 0x99, 0x00, 0x00, 0x67, 0xa2, 0x00, 0x00, 0x67, 0xad, 0x00,
+    0x00, 0x67, 0xb4, 0x00, 0x00, 0x67, 0xbc, 0x00, 0x00, 0x67, 0xc2, 0x00,
+    0x00, 0x67, 0xc8, 0x00, 0x00, 0x67, 0xcd, 0x00, 0x00, 0x67, 0xd1, 0x00,
+    0x00, 0x67, 0xd5, 0x00, 0x00, 0x67, 0xda, 0x00, 0x00, 0x67, 0xe1, 0x00,
+    0x00, 0x67, 0xec, 0x00, 0x00, 0x67, 0xf4, 0x00, 0x00, 0x67, 0xfe, 0x00,
+    0x00, 0x68, 0x07, 0x00, 0x00, 0x68, 0x0c, 0x00, 0x00, 0x68, 0x17, 0x00,
+    0x00, 0x68, 0x1e, 0x00, 0x00, 0x68, 0x2a, 0x00, 0x00, 0x68, 0x32, 0x00,
+    0x00, 0x68, 0x37, 0x00, 0x00, 0x68, 0x3d, 0x00, 0x00, 0x68, 0x43, 0x00,
+    0x00, 0x68, 0x4d, 0x00, 0x00, 0x68, 0x58, 0x00, 0x00, 0x68, 0x61, 0x00,
+    0x00, 0x68, 0x6a, 0x00, 0x00, 0x68, 0x72, 0x00, 0x00, 0x68, 0x7a, 0x00,
+    0x00, 0x68, 0x82, 0x00, 0x00, 0x68, 0x88, 0x00, 0x00, 0x68, 0x8e, 0x00,
+    0x00, 0x68, 0x95, 0x00, 0x00, 0x68, 0x9d, 0x00, 0x00, 0x68, 0xa5, 0x00,
+    0x00, 0x68, 0xaa, 0x00, 0x00, 0x68, 0xb2, 0x00, 0x00, 0x68, 0xb9, 0x00,
+    0x00, 0x68, 0xbe, 0x00, 0x00, 0x68, 0xc5, 0x00, 0x00, 0x68, 0xcd, 0x00,
+    0x00, 0x68, 0xd7, 0x00, 0x00, 0x68, 0xdf, 0x00, 0x00, 0x68, 0xe7, 0x00,
+    0x00, 0x68, 0xef, 0x00, 0x00, 0x68, 0xf4, 0x00, 0x00, 0x68, 0xfb, 0x00,
+    0x00, 0x69, 0x03, 0x00, 0x00, 0x69, 0x09, 0x00, 0x00, 0x69, 0x11, 0x00,
+    0x00, 0x69, 0x1a, 0x00, 0x00, 0x69, 0x22, 0x00, 0x00, 0x69, 0x28, 0x00,
+    0x00, 0x69, 0x31, 0x00, 0x00, 0x69, 0x3a, 0x00, 0x00, 0x69, 0x40, 0x00,
+    0x00, 0x69, 0x48, 0x00, 0x00, 0x69, 0x50, 0x00, 0x00, 0x69, 0x58, 0x00,
+    0x00, 0x69, 0x5d, 0x00, 0x00, 0x69, 0x68, 0x00, 0x00, 0x69, 0x6e, 0x00,
+    0x00, 0x69, 0x72, 0x00, 0x00, 0x69, 0x7a, 0x00, 0x00, 0x69, 0x82, 0x00,
+    0x00, 0x69, 0x8b, 0x00, 0x00, 0x69, 0x92, 0x00, 0x00, 0x69, 0x96, 0x00,
+    0x00, 0x69, 0x9c, 0x00, 0x00, 0x69, 0xa3, 0x00, 0x00, 0x69, 0xaa, 0x00,
+    0x00, 0x69, 0xb2, 0x00, 0x00, 0x69, 0xba, 0x00, 0x00, 0x69, 0xc1, 0x00,
+    0x00, 0x69, 0xc9, 0x00, 0x00, 0x69, 0xd2, 0x00, 0x00, 0x69, 0xd8, 0x00,
+    0x00, 0x69, 0xdf, 0x00, 0x00, 0x69, 0xe5, 0x00, 0x00, 0x69, 0xec, 0x00,
+    0x00, 0x69, 0xf3, 0x00, 0x00, 0x69, 0xfb, 0x00, 0x00, 0x6a, 0x02, 0x00,
+    0x00, 0x6a, 0x07, 0x00, 0x00, 0x6a, 0x10, 0x00, 0x00, 0x6a, 0x17, 0x00,
+    0x00, 0x6a, 0x21, 0x00, 0x00, 0x6a, 0x27, 0x00, 0x00, 0x6a, 0x2e, 0x00,
+    0x00, 0x6a, 0x32, 0x00, 0x00, 0x6a, 0x38, 0x00, 0x00, 0x6a, 0x40, 0x00,
+    0x00, 0x6a, 0x47, 0x00, 0x00, 0x6a, 0x4f, 0x00, 0x00, 0x6a, 0x56, 0x00,
+    0x00, 0x6a, 0x61, 0x00, 0x00, 0x6a, 0x6a, 0x00, 0x00, 0x6a, 0x70, 0x00,
+    0x00, 0x6a, 0x77, 0x00, 0x00, 0x6a, 0x7c, 0x00, 0x00, 0x6a, 0x82, 0x00,
+    0x00, 0x6a, 0x8b, 0x00, 0x00, 0x6a, 0x92, 0x00, 0x00, 0x6a, 0x99, 0x00,
+    0x00, 0x6a, 0xa1, 0x00, 0x00, 0x6a, 0xaa, 0x00, 0x00, 0x6a, 0xb1, 0x00,
+    0x00, 0x6a, 0xba, 0x00, 0x00, 0x6a, 0xc6, 0x00, 0x00, 0x6a, 0xcc, 0x00,
+    0x00, 0x6a, 0xd4, 0x00, 0x00, 0x6a, 0xdb, 0x00, 0x00, 0x6a, 0xe3, 0x00,
+    0x00, 0x6a, 0xeb, 0x00, 0x00, 0x6a, 0xf1, 0x00, 0x00, 0x6a, 0xf8, 0x00,
+    0x00, 0x6a, 0xff, 0x00, 0x00, 0x6b, 0x05, 0x00, 0x00, 0x6b, 0x0c, 0x00,
+    0x00, 0x6b, 0x12, 0x00, 0x00, 0x6b, 0x1b, 0x00, 0x00, 0x6b, 0x24, 0x00,
+    0x00, 0x6b, 0x2d, 0x00, 0x00, 0x6b, 0x36, 0x00, 0x00, 0x6b, 0x3f, 0x00,
+    0x00, 0x6b, 0x46, 0x00, 0x00, 0x6b, 0x4e, 0x00, 0x00, 0x6b, 0x57, 0x00,
+    0x00, 0x6b, 0x5e, 0x00, 0x00, 0x6b, 0x66, 0x00, 0x00, 0x6b, 0x6d, 0x00,
+    0x00, 0x6b, 0x73, 0x00, 0x00, 0x6b, 0x79, 0x00, 0x00, 0x6b, 0x83, 0x00,
+    0x00, 0x6b, 0x8c, 0x00, 0x00, 0x6b, 0x92, 0x00, 0x00, 0x6b, 0x97, 0x00,
+    0x00, 0x6b, 0x9f, 0x00, 0x00, 0x6b, 0xa8, 0x00, 0x00, 0x6b, 0xaf, 0x00,
+    0x00, 0x6b, 0xb7, 0x00, 0x00, 0x6b, 0xbe, 0x00, 0x00, 0x6b, 0xc4, 0x00,
+    0x00, 0x6b, 0xcc, 0x00, 0x00, 0x6b, 0xd3, 0x00, 0x00, 0x6b, 0xd9, 0x00,
+    0x00, 0x6b, 0xe1, 0x00, 0x00, 0x6b, 0xe8, 0x00, 0x00, 0x6b, 0xf0, 0x00,
+    0x00, 0x6b, 0xf8, 0x00, 0x00, 0x6b, 0xfd, 0x00, 0x00, 0x6c, 0x04, 0x00,
+    0x00, 0x6c, 0x0b, 0x00, 0x00, 0x6c, 0x12, 0x00, 0x00, 0x6c, 0x1a, 0x00,
+    0x00, 0x6c, 0x24, 0x00, 0x00, 0x6c, 0x2d, 0x00, 0x00, 0x6c, 0x34, 0x00,
+    0x00, 0x6c, 0x3b, 0x00, 0x00, 0x6c, 0x42, 0x00, 0x00, 0x6c, 0x48, 0x00,
+    0x00, 0x6c, 0x4f, 0x00, 0x00, 0x6c, 0x57, 0x00, 0x00, 0x6c, 0x60, 0x00,
+    0x00, 0x6c, 0x69, 0x00, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x6c, 0x77, 0x00,
+    0x00, 0x6c, 0x80, 0x00, 0x00, 0x6c, 0x89, 0x00, 0x00, 0x6c, 0x90, 0x00,
+    0x00, 0x6c, 0x98, 0x00, 0x00, 0x6c, 0xa0, 0x00, 0x00, 0x6c, 0xa5, 0x00,
+    0x00, 0x6c, 0xab, 0x00, 0x00, 0x6c, 0xb5, 0x00, 0x00, 0x6c, 0xba, 0x00,
+    0x00, 0x6c, 0xbf, 0x00, 0x00, 0x6c, 0xc5, 0x00, 0x00, 0x6c, 0xce, 0x00,
+    0x00, 0x6c, 0xd5, 0x00, 0x00, 0x6c, 0xdb, 0x00, 0x00, 0x6c, 0xe2, 0x00,
+    0x00, 0x6c, 0xea, 0x00, 0x00, 0x6c, 0xf1, 0x00, 0x00, 0x6c, 0xf9, 0x00,
+    0x00, 0x6c, 0xfe, 0x00, 0x00, 0x6d, 0x06, 0x00, 0x00, 0x6d, 0x0d, 0x00,
+    0x00, 0x6d, 0x14, 0x00, 0x00, 0x6d, 0x1a, 0x00, 0x00, 0x6d, 0x23, 0x00,
+    0x00, 0x6d, 0x2c, 0x00, 0x00, 0x6d, 0x33, 0x00, 0x00, 0x6d, 0x3c, 0x00,
+    0x00, 0x6d, 0x43, 0x00, 0x00, 0x6d, 0x4d, 0x00, 0x00, 0x6d, 0x53, 0x00,
+    0x00, 0x6d, 0x5a, 0x00, 0x00, 0x6d, 0x61, 0x00, 0x00, 0x6d, 0x69, 0x00,
+    0x00, 0x6d, 0x6f, 0x00, 0x00, 0x6d, 0x76, 0x00, 0x00, 0x6d, 0x7c, 0x00,
+    0x00, 0x6d, 0x81, 0x00, 0x00, 0x6d, 0x88, 0x00, 0x00, 0x6d, 0x8d, 0x00,
+    0x00, 0x6d, 0x94, 0x00, 0x00, 0x6d, 0x9e, 0x00, 0x00, 0x6d, 0xa6, 0x00,
+    0x00, 0x6d, 0xb0, 0x00, 0x00, 0x6d, 0xb6, 0x00, 0x00, 0x6d, 0xbf, 0x00,
+    0x00, 0x6d, 0xc8, 0x00, 0x00, 0x6d, 0xcd, 0x00, 0x00, 0x6d, 0xd5, 0x00,
+    0x00, 0x6d, 0xdc, 0x00, 0x00, 0x6d, 0xe5, 0x00, 0x00, 0x6d, 0xed, 0x00,
+    0x00, 0x6d, 0xf5, 0x00, 0x00, 0x6d, 0xfd, 0x00, 0x00, 0x6e, 0x05, 0x00,
+    0x00, 0x6e, 0x0b, 0x00, 0x00, 0x6e, 0x17, 0x00, 0x00, 0x6e, 0x1d, 0x00,
+    0x00, 0x6e, 0x26, 0x00, 0x00, 0x6e, 0x2c, 0x00, 0x00, 0x6e, 0x34, 0x00,
+    0x00, 0x6e, 0x3e, 0x00, 0x00, 0x6e, 0x49, 0x00, 0x00, 0x6e, 0x4e, 0x00,
+    0x00, 0x6e, 0x54, 0x00, 0x00, 0x6e, 0x5b, 0x00, 0x00, 0x6e, 0x64, 0x00,
+    0x00, 0x6e, 0x6b, 0x00, 0x00, 0x6e, 0x71, 0x00, 0x00, 0x6e, 0x77, 0x00,
+    0x00, 0x6e, 0x82, 0x00, 0x00, 0x6e, 0x8a, 0x00, 0x00, 0x6e, 0x8f, 0x00,
+    0x00, 0x6e, 0x94, 0x00, 0x00, 0x6e, 0x9c, 0x00, 0x00, 0x6e, 0xa3, 0x00,
+    0x00, 0x6e, 0xa8, 0x00, 0x00, 0x6e, 0xae, 0x00, 0x00, 0x6e, 0xb7, 0x00,
+    0x00, 0x6e, 0xbd, 0x00, 0x00, 0x6e, 0xc6, 0x00, 0x00, 0x6e, 0xce, 0x00,
+    0x00, 0x6e, 0xd6, 0x00, 0x00, 0x6e, 0xdf, 0x00, 0x00, 0x6e, 0xe8, 0x00,
+    0x00, 0x6e, 0xf0, 0x00, 0x00, 0x6e, 0xf6, 0x00, 0x00, 0x6e, 0xff, 0x00,
+    0x00, 0x6f, 0x04, 0x00, 0x00, 0x6f, 0x0c, 0x00, 0x00, 0x6f, 0x15, 0x00,
+    0x00, 0x6f, 0x1c, 0x00, 0x00, 0x6f, 0x24, 0x00, 0x00, 0x6f, 0x2a, 0x00,
+    0x00, 0x6f, 0x30, 0x00, 0x00, 0x6f, 0x38, 0x00, 0x00, 0x6f, 0x3e, 0x00,
+    0x00, 0x6f, 0x46, 0x00, 0x00, 0x6f, 0x4f, 0x00, 0x00, 0x6f, 0x57, 0x00,
+    0x00, 0x6f, 0x5e, 0x00, 0x00, 0x6f, 0x68, 0x00, 0x00, 0x6f, 0x6f, 0x00,
+    0x00, 0x6f, 0x77, 0x00, 0x00, 0x6f, 0x80, 0x00, 0x00, 0x6f, 0x85, 0x00,
+    0x00, 0x6f, 0x8e, 0x00, 0x00, 0x6f, 0x98, 0x00, 0x00, 0x6f, 0xa2, 0x00,
+    0x00, 0x6f, 0xaa, 0x00, 0x00, 0x6f, 0xb3, 0x00, 0x00, 0x6f, 0xba, 0x00,
+    0x00, 0x6f, 0xc1, 0x00, 0x00, 0x6f, 0xc8, 0x00, 0x00, 0x6f, 0xd2, 0x00,
+    0x00, 0x6f, 0xda, 0x00, 0x00, 0x6f, 0xe1, 0x00, 0x00, 0x6f, 0xe9, 0x00,
+    0x00, 0x6f, 0xef, 0x00, 0x00, 0x6f, 0xf6, 0x00, 0x00, 0x6f, 0xfe, 0x00,
+    0x00, 0x70, 0x05, 0x00, 0x00, 0x70, 0x09, 0x00, 0x00, 0x70, 0x12, 0x00,
+    0x00, 0x70, 0x17, 0x00, 0x00, 0x70, 0x1d, 0x00, 0x00, 0x70, 0x24, 0x00,
+    0x00, 0x70, 0x2b, 0x00, 0x00, 0x70, 0x35, 0x00, 0x00, 0x70, 0x3d, 0x00,
+    0x00, 0x70, 0x43, 0x00, 0x00, 0x70, 0x4e, 0x00, 0x00, 0x70, 0x56, 0x00,
+    0x00, 0x70, 0x5e, 0x00, 0x00, 0x70, 0x65, 0x00, 0x00, 0x70, 0x6c, 0x00,
+    0x00, 0x70, 0x76, 0x00, 0x00, 0x70, 0x7e, 0x00, 0x00, 0x70, 0x84, 0x00,
+    0x00, 0x70, 0x8c, 0x00, 0x00, 0x70, 0x94, 0x00, 0x00, 0x70, 0x98, 0x00,
+    0x00, 0x70, 0x9f, 0x00, 0x00, 0x70, 0xa6, 0x00, 0x00, 0x70, 0xac, 0x00,
+    0x00, 0x70, 0xb5, 0x00, 0x00, 0x70, 0xbd, 0x00, 0x00, 0x70, 0xc9, 0x00,
+    0x00, 0x70, 0xd1, 0x00, 0x00, 0x70, 0xd9, 0x00, 0x00, 0x70, 0xe0, 0x00,
+    0x00, 0x70, 0xe8, 0x00, 0x00, 0x70, 0xec, 0x00, 0x00, 0x70, 0xf3, 0x00,
+    0x00, 0x70, 0xfd, 0x00, 0x00, 0x71, 0x07, 0x00, 0x00, 0x71, 0x0e, 0x00,
+    0x00, 0x71, 0x14, 0x00, 0x00, 0x71, 0x1b, 0x00, 0x00, 0x71, 0x22, 0x00,
+    0x00, 0x71, 0x2c, 0x00, 0x00, 0x71, 0x34, 0x00, 0x00, 0x71, 0x3b, 0x00,
+    0x00, 0x71, 0x42, 0x00, 0x00, 0x71, 0x4b, 0x00, 0x00, 0x71, 0x51, 0x00,
+    0x00, 0x71, 0x5a, 0x00, 0x00, 0x71, 0x5f, 0x00, 0x00, 0x71, 0x68, 0x00,
+    0x00, 0x71, 0x72, 0x00, 0x00, 0x71, 0x78, 0x00, 0x00, 0x71, 0x81, 0x00,
+    0x00, 0x71, 0x85, 0x00, 0x00, 0x71, 0x8e, 0x00, 0x00, 0x71, 0x94, 0x00,
+    0x00, 0x71, 0x9b, 0x00, 0x00, 0x71, 0xa3, 0x00, 0x00, 0x71, 0xab, 0x00,
+    0x00, 0x71, 0xb4, 0x00, 0x00, 0x71, 0xba, 0x00, 0x00, 0x71, 0xc2, 0x00,
+    0x00, 0x71, 0xcc, 0x00, 0x00, 0x71, 0xd3, 0x00, 0x00, 0x71, 0xda, 0x00,
+    0x00, 0x71, 0xe1, 0x00, 0x00, 0x71, 0xe8, 0x00, 0x00, 0x71, 0xf2, 0x00,
+    0x00, 0x71, 0xf7, 0x00, 0x00, 0x71, 0xff, 0x00, 0x00, 0x72, 0x04, 0x00,
+    0x00, 0x72, 0x0b, 0x00, 0x00, 0x72, 0x11, 0x00, 0x00, 0x72, 0x18, 0x00,
+    0x00, 0x72, 0x1e, 0x00, 0x00, 0x72, 0x24, 0x00, 0x00, 0x72, 0x2c, 0x00,
+    0x00, 0x72, 0x34, 0x00, 0x00, 0x72, 0x3b, 0x00, 0x00, 0x72, 0x43, 0x00,
+    0x00, 0x72, 0x4b, 0x00, 0x00, 0x72, 0x51, 0x00, 0x00, 0x72, 0x5a, 0x00,
+    0x00, 0x72, 0x5f, 0x00, 0x00, 0x72, 0x65, 0x00, 0x00, 0x72, 0x6e, 0x00,
+    0x00, 0x72, 0x74, 0x00, 0x00, 0x72, 0x7d, 0x00, 0x00, 0x72, 0x86, 0x00,
+    0x00, 0x72, 0x8c, 0x00, 0x00, 0x72, 0x91, 0x00, 0x00, 0x72, 0x9a, 0x00,
+    0x00, 0x72, 0xa3, 0x00, 0x00, 0x72, 0xaa, 0x00, 0x00, 0x72, 0xb5, 0x00,
+    0x00, 0x72, 0xbe, 0x00, 0x00, 0x72, 0xc5, 0x00, 0x00, 0x72, 0xcb, 0x00,
+    0x00, 0x72, 0xd4, 0x00, 0x00, 0x72, 0xdd, 0x00, 0x00, 0x72, 0xe6, 0x00,
+    0x00, 0x72, 0xed, 0x00, 0x00, 0x72, 0xf5, 0x00, 0x00, 0x72, 0xfe, 0x00,
+    0x00, 0x73, 0x04, 0x00, 0x00, 0x73, 0x0a, 0x00, 0x00, 0x73, 0x0f, 0x00,
+    0x00, 0x73, 0x19, 0x00, 0x00, 0x73, 0x1f, 0x00, 0x00, 0x73, 0x25, 0x00,
+    0x00, 0x73, 0x2c, 0x00, 0x00, 0x73, 0x32, 0x00, 0x00, 0x73, 0x37, 0x00,
+    0x00, 0x73, 0x3c, 0x00, 0x00, 0x73, 0x45, 0x00, 0x00, 0x73, 0x4b, 0x00,
+    0x00, 0x73, 0x56, 0x00, 0x00, 0x73, 0x5b, 0x00, 0x00, 0x73, 0x65, 0x00,
+    0x00, 0x73, 0x6b, 0x00, 0x00, 0x73, 0x72, 0x00, 0x00, 0x73, 0x7a, 0x00,
+    0x00, 0x73, 0x7f, 0x00, 0x00, 0x73, 0x88, 0x00, 0x00, 0x73, 0x8d, 0x00,
+    0x00, 0x73, 0x92, 0x00, 0x00, 0x73, 0x98, 0x00, 0x00, 0x73, 0xa2, 0x00,
+    0x00, 0x73, 0xa9, 0x00, 0x00, 0x73, 0xb4, 0x00, 0x00, 0x73, 0xba, 0x00,
+    0x00, 0x73, 0xc0, 0x00, 0x00, 0x73, 0xc5, 0x00, 0x00, 0x73, 0xcd, 0x00,
+    0x00, 0x73, 0xd6, 0x00, 0x00, 0x73, 0xe1, 0x00, 0x00, 0x73, 0xe8, 0x00,
+    0x00, 0x73, 0xef, 0x00, 0x00, 0x73, 0xf8, 0x00, 0x00, 0x74, 0x00, 0x00,
+    0x00, 0x74, 0x07, 0x00, 0x00, 0x74, 0x0e, 0x00, 0x00, 0x74, 0x14, 0x00,
+    0x00, 0x74, 0x19, 0x00, 0x00, 0x74, 0x20, 0x00, 0x00, 0x74, 0x29, 0x00,
+    0x00, 0x74, 0x30, 0x00, 0x00, 0x74, 0x37, 0x00, 0x00, 0x74, 0x3e, 0x00,
+    0x00, 0x74, 0x45, 0x00, 0x00, 0x74, 0x4b, 0x00, 0x00, 0x74, 0x52, 0x00,
+    0x00, 0x74, 0x59, 0x00, 0x00, 0x74, 0x60, 0x00, 0x00, 0x74, 0x67, 0x00,
+    0x00, 0x74, 0x6e, 0x00, 0x00, 0x74, 0x76, 0x00, 0x00, 0x74, 0x7f, 0x00,
+    0x00, 0x74, 0x88, 0x00, 0x00, 0x74, 0x8f, 0x00, 0x00, 0x74, 0x95, 0x00,
+    0x00, 0x74, 0x9c, 0x00, 0x00, 0x74, 0xa4, 0x00, 0x00, 0x74, 0xac, 0x00,
+    0x00, 0x74, 0xb3, 0x00, 0x00, 0x74, 0xba, 0x00, 0x00, 0x74, 0xc0, 0x00,
+    0x00, 0x74, 0xcb, 0x00, 0x00, 0x74, 0xd2, 0x00, 0x00, 0x74, 0xda, 0x00,
+    0x00, 0x74, 0xe2, 0x00, 0x00, 0x74, 0xe9, 0x00, 0x00, 0x74, 0xf0, 0x00,
+    0x00, 0x74, 0xf9, 0x00, 0x00, 0x75, 0x02, 0x00, 0x00, 0x75, 0x09, 0x00,
+    0x00, 0x75, 0x11, 0x00, 0x00, 0x75, 0x1b, 0x00, 0x00, 0x75, 0x21, 0x00,
+    0x00, 0x75, 0x27, 0x00, 0x00, 0x75, 0x2e, 0x00, 0x00, 0x75, 0x36, 0x00,
+    0x00, 0x75, 0x3d, 0x00, 0x00, 0x75, 0x44, 0x00, 0x00, 0x75, 0x49, 0x00,
+    0x00, 0x75, 0x52, 0x00, 0x00, 0x75, 0x58, 0x00, 0x00, 0x75, 0x5d, 0x00,
+    0x00, 0x75, 0x63, 0x00, 0x00, 0x75, 0x68, 0x00, 0x00, 0x75, 0x6f, 0x00,
+    0x00, 0x75, 0x78, 0x00, 0x00, 0x75, 0x81, 0x00, 0x00, 0x75, 0x88, 0x00,
+    0x00, 0x75, 0x91, 0x00, 0x00, 0x75, 0x96, 0x00, 0x00, 0x75, 0x9c, 0x00,
+    0x00, 0x75, 0xa5, 0x00, 0x00, 0x75, 0xab, 0x00, 0x00, 0x75, 0xb1, 0x00,
+    0x00, 0x75, 0xb6, 0x00, 0x00, 0x75, 0xbe, 0x00, 0x00, 0x75, 0xc5, 0x00,
+    0x00, 0x75, 0xcb, 0x00, 0x00, 0x75, 0xd2, 0x00, 0x00, 0x75, 0xda, 0x00,
+    0x00, 0x75, 0xe2, 0x00, 0x00, 0x75, 0xec, 0x00, 0x00, 0x75, 0xf8, 0x00,
+    0x00, 0x76, 0x01, 0x00, 0x00, 0x76, 0x09, 0x00, 0x00, 0x76, 0x10, 0x00,
+    0x00, 0x76, 0x16, 0x00, 0x00, 0x76, 0x1e, 0x00, 0x00, 0x76, 0x26, 0x00,
+    0x00, 0x76, 0x2d, 0x00, 0x00, 0x76, 0x31, 0x00, 0x00, 0x76, 0x37, 0x00,
+    0x00, 0x76, 0x3e, 0x00, 0x00, 0x76, 0x4a, 0x00, 0x00, 0x76, 0x51, 0x00,
+    0x00, 0x76, 0x5c, 0x00, 0x00, 0x76, 0x61, 0x00, 0x00, 0x76, 0x65, 0x00,
+    0x00, 0x76, 0x6e, 0x00, 0x00, 0x76, 0x76, 0x00, 0x00, 0x76, 0x7c, 0x00,
+    0x00, 0x76, 0x83, 0x00, 0x00, 0x76, 0x8a, 0x00, 0x00, 0x76, 0x94, 0x00,
+    0x00, 0x76, 0x9d, 0x00, 0x00, 0x76, 0xa5, 0x00, 0x00, 0x76, 0xac, 0x00,
+    0x00, 0x76, 0xb5, 0x00, 0x00, 0x76, 0xbb, 0x00, 0x00, 0x76, 0xc2, 0x00,
+    0x00, 0x76, 0xcb, 0x00, 0x00, 0x76, 0xd3, 0x00, 0x00, 0x76, 0xdf, 0x00,
+    0x00, 0x76, 0xe7, 0x00, 0x00, 0x76, 0xeb, 0x00, 0x00, 0x76, 0xf4, 0x00,
+    0x00, 0x76, 0xfb, 0x00, 0x00, 0x77, 0x02, 0x00, 0x00, 0x77, 0x0a, 0x00,
+    0x00, 0x77, 0x12, 0x00, 0x00, 0x77, 0x19, 0x00, 0x00, 0x77, 0x1e, 0x00,
+    0x00, 0x77, 0x25, 0x00, 0x00, 0x77, 0x2a, 0x00, 0x00, 0x77, 0x31, 0x00,
+    0x00, 0x77, 0x37, 0x00, 0x00, 0x77, 0x3f, 0x00, 0x00, 0x77, 0x47, 0x00,
+    0x00, 0x77, 0x51, 0x00, 0x00, 0x77, 0x56, 0x00, 0x00, 0x77, 0x5f, 0x00,
+    0x00, 0x77, 0x68, 0x00, 0x00, 0x77, 0x6f, 0x00, 0x00, 0x77, 0x76, 0x00,
+    0x00, 0x77, 0x7c, 0x00, 0x00, 0x77, 0x84, 0x00, 0x00, 0x77, 0x8b, 0x00,
+    0x00, 0x77, 0x92, 0x00, 0x00, 0x77, 0x99, 0x00, 0x00, 0x77, 0xa1, 0x00,
+    0x00, 0x77, 0xaa, 0x00, 0x00, 0x77, 0xb1, 0x00, 0x00, 0x77, 0xb6, 0x00,
+    0x00, 0x77, 0xbd, 0x00, 0x00, 0x77, 0xc3, 0x00, 0x00, 0x77, 0xc9, 0x00,
+    0x00, 0x77, 0xd0, 0x00, 0x00, 0x77, 0xd7, 0x00, 0x00, 0x77, 0xde, 0x00,
+    0x00, 0x77, 0xe5, 0x00, 0x00, 0x77, 0xed, 0x00, 0x00, 0x77, 0xf4, 0x00,
+    0x00, 0x77, 0xfa, 0x00, 0x00, 0x77, 0xff, 0x00, 0x00, 0x78, 0x08, 0x00,
+    0x00, 0x78, 0x11, 0x00, 0x00, 0x78, 0x17, 0x00, 0x00, 0x78, 0x1f, 0x00,
+    0x00, 0x78, 0x28, 0x00, 0x00, 0x78, 0x2f, 0x00, 0x00, 0x78, 0x36, 0x00,
+    0x00, 0x78, 0x3c, 0x00, 0x00, 0x78, 0x44, 0x00, 0x00, 0x78, 0x4a, 0x00,
+    0x00, 0x78, 0x55, 0x00, 0x00, 0x78, 0x5c, 0x00, 0x00, 0x78, 0x66, 0x00,
+    0x00, 0x78, 0x6d, 0x00, 0x00, 0x78, 0x73, 0x00, 0x00, 0x78, 0x7b, 0x00,
+    0x00, 0x78, 0x82, 0x00, 0x00, 0x78, 0x89, 0x00, 0x00, 0x78, 0x8e, 0x00,
+    0x00, 0x78, 0x99, 0x00, 0x00, 0x78, 0xa1, 0x00, 0x00, 0x78, 0xa6, 0x00,
+    0x00, 0x78, 0xac, 0x00, 0x00, 0x78, 0xb3, 0x00, 0x00, 0x78, 0xb8, 0x00,
+    0x00, 0x78, 0xbf, 0x00, 0x00, 0x78, 0xc6, 0x00, 0x00, 0x78, 0xcc, 0x00,
+    0x00, 0x78, 0xd7, 0x00, 0x00, 0x78, 0xde, 0x00, 0x00, 0x78, 0xe7, 0x00,
+    0x00, 0x78, 0xef, 0x00, 0x00, 0x78, 0xf7, 0x00, 0x00, 0x78, 0xfe, 0x00,
+    0x00, 0x79, 0x07, 0x00, 0x00, 0x79, 0x0e, 0x00, 0x00, 0x79, 0x16, 0x00,
+    0x00, 0x79, 0x1d, 0x00, 0x00, 0x79, 0x24, 0x00, 0x00, 0x79, 0x2b, 0x00,
+    0x00, 0x79, 0x30, 0x00, 0x00, 0x79, 0x37, 0x00, 0x00, 0x79, 0x3e, 0x00,
+    0x00, 0x79, 0x45, 0x00, 0x00, 0x79, 0x4b, 0x00, 0x00, 0x79, 0x51, 0x00,
+    0x00, 0x79, 0x59, 0x00, 0x00, 0x79, 0x5d, 0x00, 0x00, 0x79, 0x65, 0x00,
+    0x00, 0x79, 0x6c, 0x00, 0x00, 0x79, 0x76, 0x00, 0x00, 0x79, 0x7d, 0x00,
+    0x00, 0x79, 0x83, 0x00, 0x00, 0x79, 0x8b, 0x00, 0x00, 0x79, 0x90, 0x00,
+    0x00, 0x79, 0x9a, 0x00, 0x00, 0x79, 0x9e, 0x00, 0x00, 0x79, 0xa4, 0x00,
+    0x00, 0x79, 0xad, 0x00, 0x00, 0x79, 0xb4, 0x00, 0x00, 0x79, 0xba, 0x00,
+    0x00, 0x79, 0xbf, 0x00, 0x00, 0x79, 0xca, 0x00, 0x00, 0x79, 0xd2, 0x00,
+    0x00, 0x79, 0xda, 0x00, 0x00, 0x79, 0xe1, 0x00, 0x00, 0x79, 0xe7, 0x00,
+    0x00, 0x79, 0xf0, 0x00, 0x00, 0x79, 0xf6, 0x00, 0x00, 0x79, 0xff, 0x00,
+    0x00, 0x7a, 0x04, 0x00, 0x00, 0x7a, 0x0d, 0x00, 0x00, 0x7a, 0x16, 0x00,
+    0x00, 0x7a, 0x1e, 0x00, 0x00, 0x7a, 0x27, 0x00, 0x00, 0x7a, 0x2e, 0x00,
+    0x00, 0x7a, 0x36, 0x00, 0x00, 0x7a, 0x3d, 0x00, 0x00, 0x7a, 0x44, 0x00,
+    0x00, 0x7a, 0x49, 0x00, 0x00, 0x7a, 0x51, 0x00, 0x00, 0x7a, 0x58, 0x00,
+    0x00, 0x7a, 0x5e, 0x00, 0x00, 0x7a, 0x63, 0x00, 0x00, 0x7a, 0x68, 0x00,
+    0x00, 0x7a, 0x71, 0x00, 0x00, 0x7a, 0x79, 0x00, 0x00, 0x7a, 0x81, 0x00,
+    0x00, 0x7a, 0x8a, 0x00, 0x00, 0x7a, 0x91, 0x00, 0x00, 0x7a, 0x99, 0x00,
+    0x00, 0x7a, 0xa2, 0x00, 0x00, 0x7a, 0xa8, 0x00, 0x00, 0x7a, 0xb0, 0x00,
+    0x00, 0x7a, 0xb5, 0x00, 0x00, 0x7a, 0xbb, 0x00, 0x00, 0x7a, 0xc3, 0x00,
+    0x00, 0x7a, 0xca, 0x00, 0x00, 0x7a, 0xcf, 0x00, 0x00, 0x7a, 0xd7, 0x00,
+    0x00, 0x7a, 0xde, 0x00, 0x00, 0x7a, 0xe5, 0x00, 0x00, 0x7a, 0xe9, 0x00,
+    0x00, 0x7a, 0xf0, 0x00, 0x00, 0x7a, 0xf5, 0x00, 0x00, 0x7a, 0xf9, 0x00,
+    0x00, 0x7b, 0x00, 0x00, 0x00, 0x7b, 0x07, 0x00, 0x00, 0x7b, 0x0e, 0x00,
+    0x00, 0x7b, 0x14, 0x00, 0x00, 0x7b, 0x1b, 0x00, 0x00, 0x7b, 0x22, 0x00,
+    0x00, 0x7b, 0x27, 0x00, 0x00, 0x7b, 0x2f, 0x00, 0x00, 0x7b, 0x35, 0x00,
+    0x00, 0x7b, 0x3c, 0x00, 0x00, 0x7b, 0x42, 0x00, 0x00, 0x7b, 0x4c, 0x00,
+    0x00, 0x7b, 0x54, 0x00, 0x00, 0x7b, 0x5d, 0x00, 0x00, 0x7b, 0x69, 0x00,
+    0x00, 0x7b, 0x74, 0x00, 0x00, 0x7b, 0x7b, 0x00, 0x00, 0x7b, 0x81, 0x00,
+    0x00, 0x7b, 0x8a, 0x00, 0x00, 0x7b, 0x92, 0x00, 0x00, 0x7b, 0x9d, 0x00,
+    0x00, 0x7b, 0xa4, 0x00, 0x00, 0x7b, 0xad, 0x00, 0x00, 0x7b, 0xb4, 0x00,
+    0x00, 0x7b, 0xbb, 0x00, 0x00, 0x7b, 0xc5, 0x00, 0x00, 0x7b, 0xcf, 0x00,
+    0x00, 0x7b, 0xd5, 0x00, 0x00, 0x7b, 0xdb, 0x00, 0x00, 0x7b, 0xe6, 0x00,
+    0x00, 0x7b, 0xed, 0x00, 0x00, 0x7b, 0xf4, 0x00, 0x00, 0x7b, 0xfa, 0x00,
+    0x00, 0x7b, 0xff, 0x00, 0x00, 0x7c, 0x04, 0x00, 0x00, 0x7c, 0x0c, 0x00,
+    0x00, 0x7c, 0x16, 0x00, 0x00, 0x7c, 0x1c, 0x00, 0x00, 0x7c, 0x24, 0x00,
+    0x00, 0x7c, 0x29, 0x00, 0x00, 0x7c, 0x30, 0x00, 0x00, 0x7c, 0x35, 0x00,
+    0x00, 0x7c, 0x3e, 0x00, 0x00, 0x7c, 0x45, 0x00, 0x00, 0x7c, 0x4b, 0x00,
+    0x00, 0x7c, 0x50, 0x00, 0x00, 0x7c, 0x58, 0x00, 0x00, 0x7c, 0x5e, 0x00,
+    0x00, 0x7c, 0x66, 0x00, 0x00, 0x7c, 0x6d, 0x00, 0x00, 0x7c, 0x75, 0x00,
+    0x00, 0x7c, 0x7c, 0x00, 0x00, 0x7c, 0x81, 0x00, 0x00, 0x7c, 0x8c, 0x00,
+    0x00, 0x7c, 0x94, 0x00, 0x00, 0x7c, 0x9b, 0x00, 0x00, 0x7c, 0xa3, 0x00,
+    0x00, 0x7c, 0xab, 0x00, 0x00, 0x7c, 0xb4, 0x00, 0x00, 0x7c, 0xbd, 0x00,
+    0x00, 0x7c, 0xc6, 0x00, 0x00, 0x7c, 0xcc, 0x00, 0x00, 0x7c, 0xd4, 0x00,
+    0x00, 0x7c, 0xdb, 0x00, 0x00, 0x7c, 0xe3, 0x00, 0x00, 0x7c, 0xec, 0x00,
+    0x00, 0x7c, 0xf6, 0x00, 0x00, 0x7c, 0xfd, 0x00, 0x00, 0x7d, 0x03, 0x00,
+    0x00, 0x7d, 0x0c, 0x00, 0x00, 0x7d, 0x13, 0x00, 0x00, 0x7d, 0x1d, 0x00,
+    0x00, 0x7d, 0x25, 0x00, 0x00, 0x7d, 0x2c, 0x00, 0x00, 0x7d, 0x35, 0x00,
+    0x00, 0x7d, 0x3c, 0x00, 0x00, 0x7d, 0x43, 0x00, 0x00, 0x7d, 0x49, 0x00,
+    0x00, 0x7d, 0x50, 0x00, 0x00, 0x7d, 0x57, 0x00, 0x00, 0x7d, 0x5d, 0x00,
+    0x00, 0x7d, 0x65, 0x00, 0x00, 0x7d, 0x6d, 0x00, 0x00, 0x7d, 0x75, 0x00,
+    0x00, 0x7d, 0x7c, 0x00, 0x00, 0x7d, 0x84, 0x00, 0x00, 0x7d, 0x8a, 0x00,
+    0x00, 0x7d, 0x92, 0x00, 0x00, 0x7d, 0x98, 0x00, 0x00, 0x7d, 0xa0, 0x00,
+    0x00, 0x7d, 0xa5, 0x00, 0x00, 0x7d, 0xae, 0x00, 0x00, 0x7d, 0xb7, 0x00,
+    0x00, 0x7d, 0xbe, 0x00, 0x00, 0x7d, 0xc8, 0x00, 0x00, 0x7d, 0xcf, 0x00,
+    0x00, 0x7d, 0xd5, 0x00, 0x00, 0x7d, 0xd8, 0x00, 0x00, 0x7d, 0xdf, 0x00,
+    0x00, 0x7d, 0xe5, 0x00, 0x00, 0x7d, 0xed, 0x00, 0x00, 0x7d, 0xf3, 0x00,
+    0x00, 0x7d, 0xf9, 0x00, 0x00, 0x7d, 0xff, 0x00, 0x00, 0x7e, 0x06, 0x00,
+    0x00, 0x7e, 0x0e, 0x00, 0x00, 0x7e, 0x16, 0x00, 0x00, 0x7e, 0x1d, 0x00,
+    0x00, 0x7e, 0x23, 0x00, 0x00, 0x7e, 0x28, 0x00, 0x00, 0x7e, 0x2e, 0x00,
+    0x00, 0x7e, 0x35, 0x00, 0x00, 0x7e, 0x3d, 0x00, 0x00, 0x7e, 0x46, 0x00,
+    0x00, 0x7e, 0x4c, 0x00, 0x00, 0x7e, 0x56, 0x00, 0x00, 0x7e, 0x5f, 0x00,
+    0x00, 0x7e, 0x65, 0x00, 0x00, 0x7e, 0x6d, 0x00, 0x00, 0x7e, 0x76, 0x00,
+    0x00, 0x7e, 0x7d, 0x00, 0x00, 0x7e, 0x83, 0x00, 0x00, 0x7e, 0x8c, 0x00,
+    0x00, 0x7e, 0x95, 0x00, 0x00, 0x7e, 0x9e, 0x00, 0x00, 0x7e, 0xa9, 0x00,
+    0x00, 0x7e, 0xae, 0x00, 0x00, 0x7e, 0xb6, 0x00, 0x00, 0x7e, 0xc0, 0x00,
+    0x00, 0x7e, 0xc6, 0x00, 0x00, 0x7e, 0xcf, 0x00, 0x00, 0x7e, 0xd4, 0x00,
+    0x00, 0x7e, 0xdb, 0x00, 0x00, 0x7e, 0xe2, 0x00, 0x00, 0x7e, 0xe8, 0x00,
+    0x00, 0x7e, 0xf1, 0x00, 0x00, 0x7e, 0xf8, 0x00, 0x00, 0x7f, 0x00, 0x00,
+    0x00, 0x7f, 0x07, 0x00, 0x00, 0x7f, 0x0e, 0x00, 0x00, 0x7f, 0x13, 0x00,
+    0x00, 0x7f, 0x1b, 0x00, 0x00, 0x7f, 0x24, 0x00, 0x00, 0x7f, 0x2b, 0x00,
+    0x00, 0x7f, 0x30, 0x00, 0x00, 0x7f, 0x37, 0x00, 0x00, 0x7f, 0x3f, 0x00,
+    0x00, 0x7f, 0x49, 0x00, 0x00, 0x7f, 0x50, 0x00, 0x00, 0x7f, 0x56, 0x00,
+    0x00, 0x7f, 0x5d, 0x00, 0x00, 0x7f, 0x65, 0x00, 0x00, 0x7f, 0x6d, 0x00,
+    0x00, 0x7f, 0x75, 0x00, 0x00, 0x7f, 0x7b, 0x00, 0x00, 0x7f, 0x80, 0x00,
+    0x00, 0x7f, 0x87, 0x00, 0x00, 0x7f, 0x8e, 0x00, 0x00, 0x7f, 0x93, 0x00,
+    0x00, 0x7f, 0x98, 0x00, 0x00, 0x7f, 0x9f, 0x00, 0x00, 0x7f, 0xa8, 0x00,
+    0x00, 0x7f, 0xaf, 0x00, 0x00, 0x7f, 0xb7, 0x00, 0x00, 0x7f, 0xbf, 0x00,
+    0x00, 0x7f, 0xc6, 0x00, 0x00, 0x7f, 0xcf, 0x00, 0x00, 0x7f, 0xd7, 0x00,
+    0x00, 0x7f, 0xde, 0x00, 0x00, 0x7f, 0xe5, 0x00, 0x00, 0x7f, 0xec, 0x00,
+    0x00, 0x7f, 0xf5, 0x00, 0x00, 0x7f, 0xfc, 0x00, 0x00, 0x80, 0x03, 0x00,
+    0x00, 0x80, 0x0e, 0x00, 0x00, 0x80, 0x14, 0x00, 0x00, 0x80, 0x19, 0x00,
+    0x00, 0x80, 0x21, 0x00, 0x00, 0x80, 0x2a, 0x00, 0x00, 0x80, 0x31, 0x00,
+    0x00, 0x80, 0x38, 0x00, 0x00, 0x80, 0x3e, 0x00, 0x00, 0x80, 0x44, 0x00,
+    0x00, 0x80, 0x4c, 0x00, 0x00, 0x80, 0x54, 0x00, 0x00, 0x80, 0x5a, 0x00,
+    0x00, 0x80, 0x62, 0x00, 0x00, 0x80, 0x68, 0x00, 0x00, 0x80, 0x6e, 0x00,
+    0x00, 0x80, 0x75, 0x00, 0x00, 0x80, 0x7b, 0x00, 0x00, 0x80, 0x85, 0x00,
+    0x00, 0x80, 0x8d, 0x00, 0x00, 0x80, 0x98, 0x00, 0x00, 0x80, 0x9e, 0x00,
+    0x00, 0x80, 0xa7, 0x00, 0x00, 0x80, 0xb0, 0x00, 0x00, 0x80, 0xb8, 0x00,
+    0x00, 0x80, 0xc0, 0x00, 0x00, 0x80, 0xc5, 0x00, 0x00, 0x80, 0xcc, 0x00,
+    0x00, 0x80, 0xd3, 0x00, 0x00, 0x80, 0xd9, 0x00, 0x00, 0x80, 0xe2, 0x00,
+    0x00, 0x80, 0xea, 0x00, 0x00, 0x80, 0xf0, 0x00, 0x00, 0x80, 0xfa, 0x00,
+    0x00, 0x81, 0x02, 0x00, 0x00, 0x81, 0x0a, 0x00, 0x00, 0x81, 0x11, 0x00,
+    0x00, 0x81, 0x1b, 0x00, 0x00, 0x81, 0x20, 0x00, 0x00, 0x81, 0x28, 0x00,
+    0x00, 0x81, 0x2e, 0x00, 0x00, 0x81, 0x36, 0x00, 0x00, 0x81, 0x3d, 0x00,
+    0x00, 0x81, 0x42, 0x00, 0x00, 0x81, 0x49, 0x00, 0x00, 0x81, 0x50, 0x00,
+    0x00, 0x81, 0x57, 0x00, 0x00, 0x81, 0x5c, 0x00, 0x00, 0x81, 0x66, 0x00,
+    0x00, 0x81, 0x6b, 0x00, 0x00, 0x81, 0x73, 0x00, 0x00, 0x81, 0x7b, 0x00,
+    0x00, 0x81, 0x81, 0x00, 0x00, 0x81, 0x86, 0x00, 0x00, 0x81, 0x8c, 0x00,
+    0x00, 0x81, 0x94, 0x00, 0x00, 0x81, 0x9c, 0x00, 0x00, 0x81, 0xa3, 0x00,
+    0x00, 0x81, 0xad, 0x00, 0x00, 0x81, 0xb4, 0x00, 0x00, 0x81, 0xbe, 0x00,
+    0x00, 0x81, 0xc6, 0x00, 0x00, 0x81, 0xce, 0x00, 0x00, 0x81, 0xd5, 0x00,
+    0x00, 0x81, 0xdc, 0x00, 0x00, 0x81, 0xe5, 0x00, 0x00, 0x81, 0xed, 0x00,
+    0x00, 0x81, 0xf4, 0x00, 0x00, 0x81, 0xfe, 0x00, 0x00, 0x82, 0x05, 0x00,
+    0x00, 0x82, 0x0d, 0x00, 0x00, 0x82, 0x15, 0x00, 0x00, 0x82, 0x19, 0x00,
+    0x00, 0x82, 0x21, 0x00, 0x00, 0x82, 0x26, 0x00, 0x00, 0x82, 0x2c, 0x00,
+    0x00, 0x82, 0x33, 0x00, 0x00, 0x82, 0x3e, 0x00, 0x00, 0x82, 0x45, 0x00,
+    0x00, 0x82, 0x4d, 0x00, 0x00, 0x82, 0x52, 0x00, 0x00, 0x82, 0x5a, 0x00,
+    0x00, 0x82, 0x61, 0x00, 0x00, 0x82, 0x68, 0x00, 0x00, 0x82, 0x6e, 0x00,
+    0x00, 0x82, 0x76, 0x00, 0x00, 0x82, 0x7f, 0x00, 0x00, 0x82, 0x85, 0x00,
+    0x00, 0x82, 0x8a, 0x00, 0x00, 0x82, 0x91, 0x00, 0x00, 0x82, 0x9a, 0x00,
+    0x00, 0x82, 0x9f, 0x00, 0x00, 0x82, 0xa5, 0x00, 0x00, 0x82, 0xad, 0x00,
+    0x00, 0x82, 0xb5, 0x00, 0x00, 0x82, 0xc0, 0x00, 0x00, 0x82, 0xc7, 0x00,
+    0x00, 0x82, 0xce, 0x00, 0x00, 0x82, 0xd7, 0x00, 0x00, 0x82, 0xdd, 0x00,
+    0x00, 0x82, 0xe5, 0x00, 0x00, 0x82, 0xec, 0x00, 0x00, 0x82, 0xf3, 0x00,
+    0x00, 0x82, 0xfb, 0x00, 0x00, 0x83, 0x04, 0x00, 0x00, 0x83, 0x0e, 0x00,
+    0x00, 0x83, 0x15, 0x00, 0x00, 0x83, 0x1b, 0x00, 0x00, 0x83, 0x24, 0x00,
+    0x00, 0x83, 0x2d, 0x00, 0x00, 0x83, 0x33, 0x00, 0x00, 0x83, 0x3f, 0x00,
+    0x00, 0x83, 0x46, 0x00, 0x00, 0x83, 0x4d, 0x00, 0x00, 0x83, 0x53, 0x00,
+    0x00, 0x83, 0x5a, 0x00, 0x00, 0x83, 0x64, 0x00, 0x00, 0x83, 0x6b, 0x00,
+    0x00, 0x83, 0x71, 0x00, 0x00, 0x83, 0x79, 0x00, 0x00, 0x83, 0x83, 0x00,
+    0x00, 0x83, 0x8c, 0x00, 0x00, 0x83, 0x94, 0x00, 0x00, 0x83, 0x9a, 0x00,
+    0x00, 0x83, 0xa2, 0x00, 0x00, 0x83, 0xaa, 0x00, 0x00, 0x83, 0xb4, 0x00,
+    0x00, 0x83, 0xbb, 0x00, 0x00, 0x83, 0xc2, 0x00, 0x00, 0x83, 0xca, 0x00,
+    0x00, 0x83, 0xd2, 0x00, 0x00, 0x83, 0xd8, 0x00, 0x00, 0x83, 0xde, 0x00,
+    0x00, 0x83, 0xe7, 0x00, 0x00, 0x83, 0xee, 0x00, 0x00, 0x83, 0xf4, 0x00,
+    0x00, 0x83, 0xfa, 0x00, 0x00, 0x84, 0x03, 0x00, 0x00, 0x84, 0x0c, 0x00,
+    0x00, 0x84, 0x14, 0x00, 0x00, 0x84, 0x1e, 0x00, 0x00, 0x84, 0x26, 0x00,
+    0x00, 0x84, 0x2d, 0x00, 0x00, 0x84, 0x32, 0x00, 0x00, 0x84, 0x3a, 0x00,
+    0x00, 0x84, 0x44, 0x00, 0x00, 0x84, 0x4b, 0x00, 0x00, 0x84, 0x54, 0x00,
+    0x00, 0x84, 0x5a, 0x00, 0x00, 0x84, 0x62, 0x00, 0x00, 0x84, 0x68, 0x00,
+    0x00, 0x84, 0x6d, 0x00, 0x00, 0x84, 0x76, 0x00, 0x00, 0x84, 0x7d, 0x00,
+    0x00, 0x84, 0x87, 0x00, 0x00, 0x84, 0x8f, 0x00, 0x00, 0x84, 0x97, 0x00,
+    0x00, 0x84, 0xa0, 0x00, 0x00, 0x84, 0xa9, 0x00, 0x00, 0x84, 0xb1, 0x00,
+    0x00, 0x84, 0xb6, 0x00, 0x00, 0x84, 0xbe, 0x00, 0x00, 0x84, 0xc7, 0x00,
+    0x00, 0x84, 0xd2, 0x00, 0x00, 0x84, 0xda, 0x00, 0x00, 0x84, 0xdf, 0x00,
+    0x00, 0x84, 0xe6, 0x00, 0x00, 0x84, 0xeb, 0x00, 0x00, 0x84, 0xf4, 0x00,
+    0x00, 0x84, 0xfb, 0x00, 0x00, 0x85, 0x06, 0x00, 0x00, 0x85, 0x0b, 0x00,
+    0x00, 0x85, 0x12, 0x00, 0x00, 0x85, 0x1a, 0x00, 0x00, 0x85, 0x22, 0x00,
+    0x00, 0x85, 0x2a, 0x00, 0x00, 0x85, 0x31, 0x00, 0x00, 0x85, 0x38, 0x00,
+    0x00, 0x85, 0x41, 0x00, 0x00, 0x85, 0x48, 0x00, 0x00, 0x85, 0x4f, 0x00,
+    0x00, 0x85, 0x58, 0x00, 0x00, 0x85, 0x61, 0x00, 0x00, 0x85, 0x68, 0x00,
+    0x00, 0x85, 0x6f, 0x00, 0x00, 0x85, 0x75, 0x00, 0x00, 0x85, 0x7d, 0x00,
+    0x00, 0x85, 0x85, 0x00, 0x00, 0x85, 0x8c, 0x00, 0x00, 0x85, 0x94, 0x00,
+    0x00, 0x85, 0x9a, 0x00, 0x00, 0x85, 0xa0, 0x00, 0x00, 0x85, 0xa7, 0x00,
+    0x00, 0x85, 0xae, 0x00, 0x00, 0x85, 0xb3, 0x00, 0x00, 0x85, 0xbb, 0x00,
+    0x00, 0x85, 0xc2, 0x00, 0x00, 0x85, 0xc8, 0x00, 0x00, 0x85, 0xcd, 0x00,
+    0x00, 0x85, 0xd4, 0x00, 0x00, 0x85, 0xdc, 0x00, 0x00, 0x85, 0xe5, 0x00,
+    0x00, 0x85, 0xee, 0x00, 0x00, 0x85, 0xf4, 0x00, 0x00, 0x85, 0xfb, 0x00,
+    0x00, 0x86, 0x03, 0x00, 0x00, 0x86, 0x0c, 0x00, 0x00, 0x86, 0x12, 0x00,
+    0x00, 0x86, 0x1a, 0x00, 0x00, 0x86, 0x24, 0x00, 0x00, 0x86, 0x2e, 0x00,
+    0x00, 0x86, 0x39, 0x00, 0x00, 0x86, 0x3e, 0x00, 0x00, 0x86, 0x46, 0x00,
+    0x00, 0x86, 0x4f, 0x00, 0x00, 0x86, 0x55, 0x00, 0x00, 0x86, 0x5e, 0x00,
+    0x00, 0x86, 0x66, 0x00, 0x00, 0x86, 0x71, 0x00, 0x00, 0x86, 0x77, 0x00,
+    0x00, 0x86, 0x7f, 0x00, 0x00, 0x86, 0x83, 0x00, 0x00, 0x86, 0x8b, 0x00,
+    0x00, 0x86, 0x92, 0x00, 0x00, 0x86, 0x9a, 0x00, 0x00, 0x86, 0xa0, 0x00,
+    0x00, 0x86, 0xa8, 0x00, 0x00, 0x86, 0xaf, 0x00, 0x00, 0x86, 0xb5, 0x00,
+    0x00, 0x86, 0xbc, 0x00, 0x00, 0x86, 0xc5, 0x00, 0x00, 0x86, 0xcd, 0x00,
+    0x00, 0x86, 0xd6, 0x00, 0x00, 0x86, 0xde, 0x00, 0x00, 0x86, 0xe8, 0x00,
+    0x00, 0x86, 0xef, 0x00, 0x00, 0x86, 0xf6, 0x00, 0x00, 0x86, 0xfe, 0x00,
+    0x00, 0x87, 0x05, 0x00, 0x00, 0x87, 0x0d, 0x00, 0x00, 0x87, 0x13, 0x00,
+    0x00, 0x87, 0x19, 0x00, 0x00, 0x87, 0x23, 0x00, 0x00, 0x87, 0x29, 0x00,
+    0x00, 0x87, 0x31, 0x00, 0x00, 0x87, 0x39, 0x00, 0x00, 0x87, 0x44, 0x00,
+    0x00, 0x87, 0x4b, 0x00, 0x00, 0x87, 0x52, 0x00, 0x00, 0x87, 0x57, 0x00,
+    0x00, 0x87, 0x61, 0x00, 0x00, 0x87, 0x68, 0x00, 0x00, 0x87, 0x71, 0x00,
+    0x00, 0x87, 0x79, 0x00, 0x00, 0x87, 0x82, 0x00, 0x00, 0x87, 0x89, 0x00,
+    0x00, 0x87, 0x92, 0x00, 0x00, 0x87, 0x9a, 0x00, 0x00, 0x87, 0xa1, 0x00,
+    0x00, 0x87, 0xa8, 0x00, 0x00, 0x87, 0xaf, 0x00, 0x00, 0x87, 0xb7, 0x00,
+    0x00, 0x87, 0xbf, 0x00, 0x00, 0x87, 0xc6, 0x00, 0x00, 0x87, 0xd1, 0x00,
+    0x00, 0x87, 0xd9, 0x00, 0x00, 0x87, 0xe1, 0x00, 0x00, 0x87, 0xe8, 0x00,
+    0x00, 0x87, 0xf0, 0x00, 0x00, 0x87, 0xf8, 0x00, 0x00, 0x87, 0xfe, 0x00,
+    0x00, 0x88, 0x05, 0x00, 0x00, 0x88, 0x0b, 0x00, 0x00, 0x88, 0x12, 0x00,
+    0x00, 0x88, 0x1a, 0x00, 0x00, 0x88, 0x22, 0x00, 0x00, 0x88, 0x27, 0x00,
+    0x00, 0x88, 0x2d, 0x00, 0x00, 0x88, 0x36, 0x00, 0x00, 0x88, 0x3e, 0x00,
+    0x00, 0x88, 0x43, 0x00, 0x00, 0x88, 0x4c, 0x00, 0x00, 0x88, 0x53, 0x00,
+    0x00, 0x88, 0x5b, 0x00, 0x00, 0x88, 0x60, 0x00, 0x00, 0x88, 0x68, 0x00,
+    0x00, 0x88, 0x70, 0x00, 0x00, 0x88, 0x7a, 0x00, 0x00, 0x88, 0x84, 0x00,
+    0x00, 0x88, 0x89, 0x00, 0x00, 0x88, 0x92, 0x00, 0x00, 0x88, 0x99, 0x00,
+    0x00, 0x88, 0x9f, 0x00, 0x00, 0x88, 0xa8, 0x00, 0x00, 0x88, 0xaf, 0x00,
+    0x00, 0x88, 0xb5, 0x00, 0x00, 0x88, 0xbd, 0x00, 0x00, 0x88, 0xc4, 0x00,
+    0x00, 0x88, 0xcc, 0x00, 0x00, 0x88, 0xd5, 0x00, 0x00, 0x88, 0xdf, 0x00,
+    0x00, 0x88, 0xe8, 0x00, 0x00, 0x88, 0xf0, 0x00, 0x00, 0x88, 0xf9, 0x00,
+    0x00, 0x89, 0x00, 0x00, 0x00, 0x89, 0x05, 0x00, 0x00, 0x89, 0x0b, 0x00,
+    0x00, 0x89, 0x13, 0x00, 0x00, 0x89, 0x1b, 0x00, 0x00, 0x89, 0x20, 0x00,
+    0x00, 0x89, 0x25, 0x00, 0x00, 0x89, 0x2d, 0x00, 0x00, 0x89, 0x37, 0x00,
+    0x00, 0x89, 0x3c, 0x00, 0x00, 0x89, 0x43, 0x00, 0x00, 0x89, 0x4b, 0x00,
+    0x00, 0x89, 0x51, 0x00, 0x00, 0x89, 0x57, 0x00, 0x00, 0x89, 0x5d, 0x00,
+    0x00, 0x89, 0x65, 0x00, 0x00, 0x89, 0x6c, 0x00, 0x00, 0x89, 0x72, 0x00,
+    0x00, 0x89, 0x79, 0x00, 0x00, 0x89, 0x7f, 0x00, 0x00, 0x89, 0x86, 0x00,
+    0x00, 0x89, 0x8c, 0x00, 0x00, 0x89, 0x96, 0x00, 0x00, 0x89, 0x9d, 0x00,
+    0x00, 0x89, 0xa3, 0x00, 0x00, 0x89, 0xaa, 0x00, 0x00, 0x89, 0xb0, 0x00,
+    0x00, 0x89, 0xb8, 0x00, 0x00, 0x89, 0xbd, 0x00, 0x00, 0x89, 0xc6, 0x00,
+    0x00, 0x89, 0xcf, 0x00, 0x00, 0x89, 0xd6, 0x00, 0x00, 0x89, 0xdd, 0x00,
+    0x00, 0x89, 0xe8, 0x00, 0x00, 0x89, 0xf2, 0x00, 0x00, 0x89, 0xf8, 0x00,
+    0x00, 0x89, 0xfd, 0x00, 0x00, 0x8a, 0x05, 0x00, 0x00, 0x8a, 0x0b, 0x00,
+    0x00, 0x8a, 0x13, 0x00, 0x00, 0x8a, 0x1a, 0x00, 0x00, 0x8a, 0x24, 0x00,
+    0x00, 0x8a, 0x2f, 0x00, 0x00, 0x8a, 0x37, 0x00, 0x00, 0x8a, 0x3f, 0x00,
+    0x00, 0x8a, 0x46, 0x00, 0x00, 0x8a, 0x4c, 0x00, 0x00, 0x8a, 0x54, 0x00,
+    0x00, 0x8a, 0x5e, 0x00, 0x00, 0x8a, 0x65, 0x00, 0x00, 0x8a, 0x6d, 0x00,
+    0x00, 0x8a, 0x75, 0x00, 0x00, 0x8a, 0x7b, 0x00, 0x00, 0x8a, 0x82, 0x00,
+    0x00, 0x8a, 0x87, 0x00, 0x00, 0x8a, 0x8c, 0x00, 0x00, 0x8a, 0x93, 0x00,
+    0x00, 0x8a, 0x99, 0x00, 0x00, 0x8a, 0xa3, 0x00, 0x00, 0x8a, 0xa9, 0x00,
+    0x00, 0x8a, 0xb4, 0x00, 0x00, 0x8a, 0xbc, 0x00, 0x00, 0x8a, 0xc2, 0x00,
+    0x00, 0x8a, 0xc7, 0x00, 0x00, 0x8a, 0xcd, 0x00, 0x00, 0x8a, 0xd6, 0x00,
+    0x00, 0x8a, 0xdc, 0x00, 0x00, 0x8a, 0xe1, 0x00, 0x00, 0x8a, 0xe7, 0x00,
+    0x00, 0x8a, 0xec, 0x00, 0x00, 0x8a, 0xf5, 0x00, 0x00, 0x8a, 0xff, 0x00,
+    0x00, 0x8b, 0x07, 0x00, 0x00, 0x8b, 0x0c, 0x00, 0x00, 0x8b, 0x13, 0x00,
+    0x00, 0x8b, 0x19, 0x00, 0x00, 0x8b, 0x21, 0x00, 0x00, 0x8b, 0x29, 0x00,
+    0x00, 0x8b, 0x30, 0x00, 0x00, 0x8b, 0x34, 0x00, 0x00, 0x8b, 0x3d, 0x00,
+    0x00, 0x8b, 0x45, 0x00, 0x00, 0x8b, 0x4b, 0x00, 0x00, 0x8b, 0x51, 0x00,
+    0x00, 0x8b, 0x59, 0x00, 0x00, 0x8b, 0x62, 0x00, 0x00, 0x8b, 0x66, 0x00,
+    0x00, 0x8b, 0x72, 0x00, 0x00, 0x8b, 0x7c, 0x00, 0x00, 0x8b, 0x82, 0x00,
+    0x00, 0x8b, 0x8d, 0x00, 0x00, 0x8b, 0x95, 0x00, 0x00, 0x8b, 0x9c, 0x00,
+    0x00, 0x8b, 0xa3, 0x00, 0x00, 0x8b, 0xa8, 0x00, 0x00, 0x8b, 0xb0, 0x00,
+    0x00, 0x8b, 0xb8, 0x00, 0x00, 0x8b, 0xbf, 0x00, 0x00, 0x8b, 0xca, 0x00,
+    0x00, 0x8b, 0xd0, 0x00, 0x00, 0x8b, 0xd8, 0x00, 0x00, 0x8b, 0xde, 0x00,
+    0x00, 0x8b, 0xe8, 0x00, 0x00, 0x8b, 0xed, 0x00, 0x00, 0x8b, 0xf8, 0x00,
+    0x00, 0x8b, 0xfe, 0x00, 0x00, 0x8c, 0x04, 0x00, 0x00, 0x8c, 0x0a, 0x00,
+    0x00, 0x8c, 0x12, 0x00, 0x00, 0x8c, 0x1a, 0x00, 0x00, 0x8c, 0x21, 0x00,
+    0x00, 0x8c, 0x26, 0x00, 0x00, 0x8c, 0x2c, 0x00, 0x00, 0x8c, 0x34, 0x00,
+    0x00, 0x8c, 0x39, 0x00, 0x00, 0x8c, 0x40, 0x00, 0x00, 0x8c, 0x4b, 0x00,
+    0x00, 0x8c, 0x51, 0x00, 0x00, 0x8c, 0x59, 0x00, 0x00, 0x8c, 0x61, 0x00,
+    0x00, 0x8c, 0x69, 0x00, 0x00, 0x8c, 0x70, 0x00, 0x00, 0x8c, 0x77, 0x00,
+    0x00, 0x8c, 0x7f, 0x00, 0x00, 0x8c, 0x8a, 0x00, 0x00, 0x8c, 0x91, 0x00,
+    0x00, 0x8c, 0x97, 0x00, 0x00, 0x8c, 0x9f, 0x00, 0x00, 0x8c, 0xa7, 0x00,
+    0x00, 0x8c, 0xad, 0x00, 0x00, 0x8c, 0xb6, 0x00, 0x00, 0x8c, 0xbc, 0x00,
+    0x00, 0x8c, 0xc4, 0x00, 0x00, 0x8c, 0xcc, 0x00, 0x00, 0x8c, 0xd4, 0x00,
+    0x00, 0x8c, 0xdc, 0x00, 0x00, 0x8c, 0xe7, 0x00, 0x00, 0x8c, 0xec, 0x00,
+    0x00, 0x8c, 0xf4, 0x00, 0x00, 0x8c, 0xfb, 0x00, 0x00, 0x8d, 0x03, 0x00,
+    0x00, 0x8d, 0x0b, 0x00, 0x00, 0x8d, 0x10, 0x00, 0x00, 0x8d, 0x17, 0x00,
+    0x00, 0x8d, 0x1d, 0x00, 0x00, 0x8d, 0x24, 0x00, 0x00, 0x8d, 0x2e, 0x00,
+    0x00, 0x8d, 0x37, 0x00, 0x00, 0x8d, 0x3e, 0x00, 0x00, 0x8d, 0x45, 0x00,
+    0x00, 0x8d, 0x4c, 0x00, 0x00, 0x8d, 0x53, 0x00, 0x00, 0x8d, 0x5b, 0x00,
+    0x00, 0x8d, 0x62, 0x00, 0x00, 0x8d, 0x68, 0x00, 0x00, 0x8d, 0x6f, 0x00,
+    0x00, 0x8d, 0x79, 0x00, 0x00, 0x8d, 0x81, 0x00, 0x00, 0x8d, 0x87, 0x00,
+    0x00, 0x8d, 0x8f, 0x00, 0x00, 0x8d, 0x96, 0x00, 0x00, 0x8d, 0x9d, 0x00,
+    0x00, 0x8d, 0xa5, 0x00, 0x00, 0x8d, 0xac, 0x00, 0x00, 0x8d, 0xb3, 0x00,
+    0x00, 0x8d, 0xba, 0x00, 0x00, 0x8d, 0xbf, 0x00, 0x00, 0x8d, 0xc4, 0x00,
+    0x00, 0x8d, 0xc9, 0x00, 0x00, 0x8d, 0xd3, 0x00, 0x00, 0x8d, 0xda, 0x00,
+    0x00, 0x8d, 0xdf, 0x00, 0x00, 0x8d, 0xe8, 0x53, 0x6d, 0x69, 0x74, 0x68,
+    0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6c,
+    0x6c, 0x69, 0x61, 0x6d, 0x73, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x00,
+    0x42, 0x72, 0x6f, 0x77, 0x6e, 0x00, 0x44, 0x61, 0x76, 0x69, 0x73, 0x00,
+    0x4d, 0x69, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x57, 0x69, 0x6c, 0x73, 0x6f,
+    0x6e, 0x00, 0x4d, 0x6f, 0x6f, 0x72, 0x65, 0x00, 0x54, 0x61, 0x79, 0x6c,
+    0x6f, 0x72, 0x00, 0x41, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00,
+    0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73,
+    0x6f, 0x6e, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65, 0x00, 0x48, 0x61, 0x72,
+    0x72, 0x69, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x00, 0x54,
+    0x68, 0x6f, 0x6d, 0x70, 0x73, 0x6f, 0x6e, 0x00, 0x47, 0x61, 0x72, 0x63,
+    0x69, 0x61, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x65, 0x7a, 0x00,
+    0x52, 0x6f, 0x62, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x6c, 0x61,
+    0x72, 0x6b, 0x00, 0x52, 0x6f, 0x64, 0x72, 0x69, 0x67, 0x75, 0x65, 0x7a,
+    0x00, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x00, 0x4c, 0x65, 0x65, 0x00, 0x57,
+    0x61, 0x6c, 0x6b, 0x65, 0x72, 0x00, 0x48, 0x61, 0x6c, 0x6c, 0x00, 0x41,
+    0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x59, 0x6f, 0x75, 0x6e, 0x67, 0x00, 0x48,
+    0x65, 0x72, 0x6e, 0x61, 0x6e, 0x64, 0x65, 0x7a, 0x00, 0x4b, 0x69, 0x6e,
+    0x67, 0x00, 0x57, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x4c, 0x6f, 0x70,
+    0x65, 0x7a, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x63, 0x6f, 0x74,
+    0x74, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x41, 0x64, 0x61, 0x6d,
+    0x73, 0x00, 0x42, 0x61, 0x6b, 0x65, 0x72, 0x00, 0x47, 0x6f, 0x6e, 0x7a,
+    0x61, 0x6c, 0x65, 0x7a, 0x00, 0x4e, 0x65, 0x6c, 0x73, 0x6f, 0x6e, 0x00,
+    0x43, 0x61, 0x72, 0x74, 0x65, 0x72, 0x00, 0x4d, 0x69, 0x74, 0x63, 0x68,
+    0x65, 0x6c, 0x6c, 0x00, 0x50, 0x65, 0x72, 0x65, 0x7a, 0x00, 0x52, 0x6f,
+    0x62, 0x65, 0x72, 0x74, 0x73, 0x00, 0x54, 0x75, 0x72, 0x6e, 0x65, 0x72,
+    0x00, 0x50, 0x68, 0x69, 0x6c, 0x6c, 0x69, 0x70, 0x73, 0x00, 0x43, 0x61,
+    0x6d, 0x70, 0x62, 0x65, 0x6c, 0x6c, 0x00, 0x50, 0x61, 0x72, 0x6b, 0x65,
+    0x72, 0x00, 0x45, 0x76, 0x61, 0x6e, 0x73, 0x00, 0x45, 0x64, 0x77, 0x61,
+    0x72, 0x64, 0x73, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x73, 0x00,
+    0x53, 0x74, 0x65, 0x77, 0x61, 0x72, 0x74, 0x00, 0x53, 0x61, 0x6e, 0x63,
+    0x68, 0x65, 0x7a, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x69, 0x73, 0x00, 0x52,
+    0x6f, 0x67, 0x65, 0x72, 0x73, 0x00, 0x52, 0x65, 0x65, 0x64, 0x00, 0x43,
+    0x6f, 0x6f, 0x6b, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x00, 0x42,
+    0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x75, 0x72, 0x70, 0x68, 0x79, 0x00, 0x42,
+    0x61, 0x69, 0x6c, 0x65, 0x79, 0x00, 0x52, 0x69, 0x76, 0x65, 0x72, 0x61,
+    0x00, 0x43, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x00, 0x52, 0x69, 0x63, 0x68,
+    0x61, 0x72, 0x64, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x78, 0x00, 0x48,
+    0x6f, 0x77, 0x61, 0x72, 0x64, 0x00, 0x57, 0x61, 0x72, 0x64, 0x00, 0x54,
+    0x6f, 0x72, 0x72, 0x65, 0x73, 0x00, 0x50, 0x65, 0x74, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x00, 0x47, 0x72, 0x61, 0x79, 0x00, 0x52, 0x61, 0x6d, 0x69,
+    0x72, 0x65, 0x7a, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x57, 0x61,
+    0x74, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x73, 0x00,
+    0x4b, 0x65, 0x6c, 0x6c, 0x79, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x65, 0x72,
+    0x73, 0x00, 0x50, 0x72, 0x69, 0x63, 0x65, 0x00, 0x42, 0x65, 0x6e, 0x6e,
+    0x65, 0x74, 0x74, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x00, 0x42, 0x61, 0x72,
+    0x6e, 0x65, 0x73, 0x00, 0x52, 0x6f, 0x73, 0x73, 0x00, 0x48, 0x65, 0x6e,
+    0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x6c, 0x65, 0x6d,
+    0x61, 0x6e, 0x00, 0x4a, 0x65, 0x6e, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x50,
+    0x65, 0x72, 0x72, 0x79, 0x00, 0x50, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00,
+    0x4c, 0x6f, 0x6e, 0x67, 0x00, 0x50, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x00, 0x48, 0x75, 0x67, 0x68, 0x65, 0x73, 0x00, 0x46, 0x6c,
+    0x6f, 0x72, 0x65, 0x73, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x00, 0x42, 0x75, 0x74, 0x6c, 0x65, 0x72, 0x00, 0x53,
+    0x69, 0x6d, 0x6d, 0x6f, 0x6e, 0x73, 0x00, 0x46, 0x6f, 0x73, 0x74, 0x65,
+    0x72, 0x00, 0x47, 0x6f, 0x6e, 0x7a, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x42,
+    0x72, 0x79, 0x61, 0x6e, 0x74, 0x00, 0x41, 0x6c, 0x65, 0x78, 0x61, 0x6e,
+    0x64, 0x65, 0x72, 0x00, 0x52, 0x75, 0x73, 0x73, 0x65, 0x6c, 0x6c, 0x00,
+    0x47, 0x72, 0x69, 0x66, 0x66, 0x69, 0x6e, 0x00, 0x44, 0x69, 0x61, 0x7a,
+    0x00, 0x48, 0x61, 0x79, 0x65, 0x73, 0x00, 0x4d, 0x79, 0x65, 0x72, 0x73,
+    0x00, 0x46, 0x6f, 0x72, 0x64, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74,
+    0x6f, 0x6e, 0x00, 0x47, 0x72, 0x61, 0x68, 0x61, 0x6d, 0x00, 0x53, 0x75,
+    0x6c, 0x6c, 0x69, 0x76, 0x61, 0x6e, 0x00, 0x57, 0x61, 0x6c, 0x6c, 0x61,
+    0x63, 0x65, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x73, 0x00, 0x43, 0x6f, 0x6c,
+    0x65, 0x00, 0x57, 0x65, 0x73, 0x74, 0x00, 0x4a, 0x6f, 0x72, 0x64, 0x61,
+    0x6e, 0x00, 0x4f, 0x77, 0x65, 0x6e, 0x73, 0x00, 0x52, 0x65, 0x79, 0x6e,
+    0x6f, 0x6c, 0x64, 0x73, 0x00, 0x46, 0x69, 0x73, 0x68, 0x65, 0x72, 0x00,
+    0x45, 0x6c, 0x6c, 0x69, 0x73, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73,
+    0x6f, 0x6e, 0x00, 0x47, 0x69, 0x62, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x63,
+    0x64, 0x6f, 0x6e, 0x61, 0x6c, 0x64, 0x00, 0x43, 0x72, 0x75, 0x7a, 0x00,
+    0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x00, 0x4f, 0x72, 0x74,
+    0x69, 0x7a, 0x00, 0x47, 0x6f, 0x6d, 0x65, 0x7a, 0x00, 0x4d, 0x75, 0x72,
+    0x72, 0x61, 0x79, 0x00, 0x46, 0x72, 0x65, 0x65, 0x6d, 0x61, 0x6e, 0x00,
+    0x57, 0x65, 0x6c, 0x6c, 0x73, 0x00, 0x57, 0x65, 0x62, 0x62, 0x00, 0x53,
+    0x69, 0x6d, 0x70, 0x73, 0x6f, 0x6e, 0x00, 0x53, 0x74, 0x65, 0x76, 0x65,
+    0x6e, 0x73, 0x00, 0x54, 0x75, 0x63, 0x6b, 0x65, 0x72, 0x00, 0x50, 0x6f,
+    0x72, 0x74, 0x65, 0x72, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x00,
+    0x48, 0x69, 0x63, 0x6b, 0x73, 0x00, 0x43, 0x72, 0x61, 0x77, 0x66, 0x6f,
+    0x72, 0x64, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x00, 0x42, 0x6f, 0x79,
+    0x64, 0x00, 0x4d, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x6f, 0x72, 0x61,
+    0x6c, 0x65, 0x73, 0x00, 0x4b, 0x65, 0x6e, 0x6e, 0x65, 0x64, 0x79, 0x00,
+    0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x00, 0x44, 0x69, 0x78, 0x6f, 0x6e,
+    0x00, 0x52, 0x61, 0x6d, 0x6f, 0x73, 0x00, 0x52, 0x65, 0x79, 0x65, 0x73,
+    0x00, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x00, 0x47, 0x6f, 0x72, 0x64, 0x6f,
+    0x6e, 0x00, 0x53, 0x68, 0x61, 0x77, 0x00, 0x48, 0x6f, 0x6c, 0x6d, 0x65,
+    0x73, 0x00, 0x52, 0x69, 0x63, 0x65, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x72,
+    0x74, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x00, 0x42, 0x6c,
+    0x61, 0x63, 0x6b, 0x00, 0x44, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x73, 0x00,
+    0x50, 0x61, 0x6c, 0x6d, 0x65, 0x72, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x73,
+    0x00, 0x4e, 0x69, 0x63, 0x68, 0x6f, 0x6c, 0x73, 0x00, 0x47, 0x72, 0x61,
+    0x6e, 0x74, 0x00, 0x4b, 0x6e, 0x69, 0x67, 0x68, 0x74, 0x00, 0x46, 0x65,
+    0x72, 0x67, 0x75, 0x73, 0x6f, 0x6e, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x00,
+    0x53, 0x74, 0x6f, 0x6e, 0x65, 0x00, 0x48, 0x61, 0x77, 0x6b, 0x69, 0x6e,
+    0x73, 0x00, 0x44, 0x75, 0x6e, 0x6e, 0x00, 0x50, 0x65, 0x72, 0x6b, 0x69,
+    0x6e, 0x73, 0x00, 0x48, 0x75, 0x64, 0x73, 0x6f, 0x6e, 0x00, 0x53, 0x70,
+    0x65, 0x6e, 0x63, 0x65, 0x72, 0x00, 0x47, 0x61, 0x72, 0x64, 0x6e, 0x65,
+    0x72, 0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x65, 0x6e, 0x73, 0x00, 0x50,
+    0x61, 0x79, 0x6e, 0x65, 0x00, 0x50, 0x69, 0x65, 0x72, 0x63, 0x65, 0x00,
+    0x42, 0x65, 0x72, 0x72, 0x79, 0x00, 0x4d, 0x61, 0x74, 0x74, 0x68, 0x65,
+    0x77, 0x73, 0x00, 0x41, 0x72, 0x6e, 0x6f, 0x6c, 0x64, 0x00, 0x57, 0x61,
+    0x67, 0x6e, 0x65, 0x72, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x73, 0x00,
+    0x52, 0x61, 0x79, 0x00, 0x57, 0x61, 0x74, 0x6b, 0x69, 0x6e, 0x73, 0x00,
+    0x4f, 0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c,
+    0x6c, 0x00, 0x44, 0x75, 0x6e, 0x63, 0x61, 0x6e, 0x00, 0x53, 0x6e, 0x79,
+    0x64, 0x65, 0x72, 0x00, 0x48, 0x61, 0x72, 0x74, 0x00, 0x43, 0x75, 0x6e,
+    0x6e, 0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x00, 0x42, 0x72, 0x61, 0x64,
+    0x6c, 0x65, 0x79, 0x00, 0x4c, 0x61, 0x6e, 0x65, 0x00, 0x41, 0x6e, 0x64,
+    0x72, 0x65, 0x77, 0x73, 0x00, 0x52, 0x75, 0x69, 0x7a, 0x00, 0x48, 0x61,
+    0x72, 0x70, 0x65, 0x72, 0x00, 0x46, 0x6f, 0x78, 0x00, 0x52, 0x69, 0x6c,
+    0x65, 0x79, 0x00, 0x41, 0x72, 0x6d, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67,
+    0x00, 0x43, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x57,
+    0x65, 0x61, 0x76, 0x65, 0x72, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x65,
+    0x00, 0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x45, 0x6c,
+    0x6c, 0x69, 0x6f, 0x74, 0x74, 0x00, 0x43, 0x68, 0x61, 0x76, 0x65, 0x7a,
+    0x00, 0x53, 0x69, 0x6d, 0x73, 0x00, 0x41, 0x75, 0x73, 0x74, 0x69, 0x6e,
+    0x00, 0x50, 0x65, 0x74, 0x65, 0x72, 0x73, 0x00, 0x4b, 0x65, 0x6c, 0x6c,
+    0x65, 0x79, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x00,
+    0x4c, 0x61, 0x77, 0x73, 0x6f, 0x6e, 0x00, 0x46, 0x69, 0x65, 0x6c, 0x64,
+    0x73, 0x00, 0x47, 0x75, 0x74, 0x69, 0x65, 0x72, 0x72, 0x65, 0x7a, 0x00,
+    0x52, 0x79, 0x61, 0x6e, 0x00, 0x53, 0x63, 0x68, 0x6d, 0x69, 0x64, 0x74,
+    0x00, 0x43, 0x61, 0x72, 0x72, 0x00, 0x56, 0x61, 0x73, 0x71, 0x75, 0x65,
+    0x7a, 0x00, 0x43, 0x61, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x6f, 0x00, 0x57,
+    0x68, 0x65, 0x65, 0x6c, 0x65, 0x72, 0x00, 0x43, 0x68, 0x61, 0x70, 0x6d,
+    0x61, 0x6e, 0x00, 0x4f, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x00, 0x52, 0x69, 0x63,
+    0x68, 0x61, 0x72, 0x64, 0x73, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61,
+    0x6d, 0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x74, 0x6f,
+    0x6e, 0x00, 0x42, 0x61, 0x6e, 0x6b, 0x73, 0x00, 0x4d, 0x65, 0x79, 0x65,
+    0x72, 0x00, 0x42, 0x69, 0x73, 0x68, 0x6f, 0x70, 0x00, 0x4d, 0x63, 0x63,
+    0x6f, 0x79, 0x00, 0x48, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x41, 0x6c,
+    0x76, 0x61, 0x72, 0x65, 0x7a, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x69, 0x73,
+    0x6f, 0x6e, 0x00, 0x48, 0x61, 0x6e, 0x73, 0x65, 0x6e, 0x00, 0x46, 0x65,
+    0x72, 0x6e, 0x61, 0x6e, 0x64, 0x65, 0x7a, 0x00, 0x47, 0x61, 0x72, 0x7a,
+    0x61, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65, 0x79, 0x00, 0x4c, 0x69, 0x74,
+    0x74, 0x6c, 0x65, 0x00, 0x42, 0x75, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x53,
+    0x74, 0x61, 0x6e, 0x6c, 0x65, 0x79, 0x00, 0x4e, 0x67, 0x75, 0x79, 0x65,
+    0x6e, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x00, 0x4a, 0x61, 0x63,
+    0x6f, 0x62, 0x73, 0x00, 0x52, 0x65, 0x69, 0x64, 0x00, 0x4b, 0x69, 0x6d,
+    0x00, 0x46, 0x75, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x4c, 0x79, 0x6e, 0x63,
+    0x68, 0x00, 0x44, 0x65, 0x61, 0x6e, 0x00, 0x47, 0x69, 0x6c, 0x62, 0x65,
+    0x72, 0x74, 0x00, 0x47, 0x61, 0x72, 0x72, 0x65, 0x74, 0x74, 0x00, 0x52,
+    0x6f, 0x6d, 0x65, 0x72, 0x6f, 0x00, 0x57, 0x65, 0x6c, 0x63, 0x68, 0x00,
+    0x4c, 0x61, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x46, 0x72, 0x61, 0x7a, 0x69,
+    0x65, 0x72, 0x00, 0x42, 0x75, 0x72, 0x6b, 0x65, 0x00, 0x48, 0x61, 0x6e,
+    0x73, 0x6f, 0x6e, 0x00, 0x44, 0x61, 0x79, 0x00, 0x4d, 0x65, 0x6e, 0x64,
+    0x6f, 0x7a, 0x61, 0x00, 0x4d, 0x6f, 0x72, 0x65, 0x6e, 0x6f, 0x00, 0x42,
+    0x6f, 0x77, 0x6d, 0x61, 0x6e, 0x00, 0x4d, 0x65, 0x64, 0x69, 0x6e, 0x61,
+    0x00, 0x46, 0x6f, 0x77, 0x6c, 0x65, 0x72, 0x00, 0x42, 0x72, 0x65, 0x77,
+    0x65, 0x72, 0x00, 0x48, 0x6f, 0x66, 0x66, 0x6d, 0x61, 0x6e, 0x00, 0x43,
+    0x61, 0x72, 0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x53, 0x69, 0x6c, 0x76, 0x61,
+    0x00, 0x50, 0x65, 0x61, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x6f, 0x6c,
+    0x6c, 0x61, 0x6e, 0x64, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73,
+    0x00, 0x46, 0x6c, 0x65, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x4a, 0x65, 0x6e,
+    0x73, 0x65, 0x6e, 0x00, 0x56, 0x61, 0x72, 0x67, 0x61, 0x73, 0x00, 0x42,
+    0x79, 0x72, 0x64, 0x00, 0x44, 0x61, 0x76, 0x69, 0x64, 0x73, 0x6f, 0x6e,
+    0x00, 0x48, 0x6f, 0x70, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x4d, 0x61, 0x79,
+    0x00, 0x54, 0x65, 0x72, 0x72, 0x79, 0x00, 0x48, 0x65, 0x72, 0x72, 0x65,
+    0x72, 0x61, 0x00, 0x57, 0x61, 0x64, 0x65, 0x00, 0x53, 0x6f, 0x74, 0x6f,
+    0x00, 0x57, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x73, 0x00, 0x43, 0x75, 0x72,
+    0x74, 0x69, 0x73, 0x00, 0x4e, 0x65, 0x61, 0x6c, 0x00, 0x43, 0x61, 0x6c,
+    0x64, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x6f, 0x77, 0x65, 0x00, 0x4a,
+    0x65, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x42, 0x61, 0x72, 0x6e,
+    0x65, 0x74, 0x74, 0x00, 0x47, 0x72, 0x61, 0x76, 0x65, 0x73, 0x00, 0x4a,
+    0x69, 0x6d, 0x65, 0x6e, 0x65, 0x7a, 0x00, 0x48, 0x6f, 0x72, 0x74, 0x6f,
+    0x6e, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x61,
+    0x72, 0x72, 0x65, 0x74, 0x74, 0x00, 0x4f, 0x62, 0x72, 0x69, 0x65, 0x6e,
+    0x00, 0x43, 0x61, 0x73, 0x74, 0x72, 0x6f, 0x00, 0x53, 0x75, 0x74, 0x74,
+    0x6f, 0x6e, 0x00, 0x47, 0x72, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x00, 0x4d,
+    0x63, 0x6b, 0x69, 0x6e, 0x6e, 0x65, 0x79, 0x00, 0x4c, 0x75, 0x63, 0x61,
+    0x73, 0x00, 0x4d, 0x69, 0x6c, 0x65, 0x73, 0x00, 0x43, 0x72, 0x61, 0x69,
+    0x67, 0x00, 0x52, 0x6f, 0x64, 0x72, 0x69, 0x71, 0x75, 0x65, 0x7a, 0x00,
+    0x43, 0x68, 0x61, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x00, 0x48, 0x6f, 0x6c,
+    0x74, 0x00, 0x4c, 0x61, 0x6d, 0x62, 0x65, 0x72, 0x74, 0x00, 0x46, 0x6c,
+    0x65, 0x74, 0x63, 0x68, 0x65, 0x72, 0x00, 0x57, 0x61, 0x74, 0x74, 0x73,
+    0x00, 0x42, 0x61, 0x74, 0x65, 0x73, 0x00, 0x48, 0x61, 0x6c, 0x65, 0x00,
+    0x52, 0x68, 0x6f, 0x64, 0x65, 0x73, 0x00, 0x50, 0x65, 0x6e, 0x61, 0x00,
+    0x42, 0x65, 0x63, 0x6b, 0x00, 0x4e, 0x65, 0x77, 0x6d, 0x61, 0x6e, 0x00,
+    0x48, 0x61, 0x79, 0x6e, 0x65, 0x73, 0x00, 0x4d, 0x63, 0x64, 0x61, 0x6e,
+    0x69, 0x65, 0x6c, 0x00, 0x4d, 0x65, 0x6e, 0x64, 0x65, 0x7a, 0x00, 0x42,
+    0x75, 0x73, 0x68, 0x00, 0x56, 0x61, 0x75, 0x67, 0x68, 0x6e, 0x00, 0x50,
+    0x61, 0x72, 0x6b, 0x73, 0x00, 0x44, 0x61, 0x77, 0x73, 0x6f, 0x6e, 0x00,
+    0x53, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x67, 0x6f, 0x00, 0x4e, 0x6f, 0x72,
+    0x72, 0x69, 0x73, 0x00, 0x48, 0x61, 0x72, 0x64, 0x79, 0x00, 0x4c, 0x6f,
+    0x76, 0x65, 0x00, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x65, 0x00, 0x43, 0x75,
+    0x72, 0x72, 0x79, 0x00, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x73, 0x00, 0x53,
+    0x63, 0x68, 0x75, 0x6c, 0x74, 0x7a, 0x00, 0x42, 0x61, 0x72, 0x6b, 0x65,
+    0x72, 0x00, 0x47, 0x75, 0x7a, 0x6d, 0x61, 0x6e, 0x00, 0x50, 0x61, 0x67,
+    0x65, 0x00, 0x4d, 0x75, 0x6e, 0x6f, 0x7a, 0x00, 0x42, 0x61, 0x6c, 0x6c,
+    0x00, 0x4b, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x43, 0x68, 0x61, 0x6e,
+    0x64, 0x6c, 0x65, 0x72, 0x00, 0x57, 0x65, 0x62, 0x65, 0x72, 0x00, 0x4c,
+    0x65, 0x6f, 0x6e, 0x61, 0x72, 0x64, 0x00, 0x57, 0x61, 0x6c, 0x73, 0x68,
+    0x00, 0x4c, 0x79, 0x6f, 0x6e, 0x73, 0x00, 0x52, 0x61, 0x6d, 0x73, 0x65,
+    0x79, 0x00, 0x57, 0x6f, 0x6c, 0x66, 0x65, 0x00, 0x53, 0x63, 0x68, 0x6e,
+    0x65, 0x69, 0x64, 0x65, 0x72, 0x00, 0x4d, 0x75, 0x6c, 0x6c, 0x69, 0x6e,
+    0x73, 0x00, 0x42, 0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x61,
+    0x72, 0x70, 0x00, 0x42, 0x6f, 0x77, 0x65, 0x6e, 0x00, 0x44, 0x61, 0x6e,
+    0x69, 0x65, 0x6c, 0x00, 0x42, 0x61, 0x72, 0x62, 0x65, 0x72, 0x00, 0x43,
+    0x75, 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x48, 0x69, 0x6e, 0x65,
+    0x73, 0x00, 0x42, 0x61, 0x6c, 0x64, 0x77, 0x69, 0x6e, 0x00, 0x47, 0x72,
+    0x69, 0x66, 0x66, 0x69, 0x74, 0x68, 0x00, 0x56, 0x61, 0x6c, 0x64, 0x65,
+    0x7a, 0x00, 0x48, 0x75, 0x62, 0x62, 0x61, 0x72, 0x64, 0x00, 0x53, 0x61,
+    0x6c, 0x61, 0x7a, 0x61, 0x72, 0x00, 0x52, 0x65, 0x65, 0x76, 0x65, 0x73,
+    0x00, 0x57, 0x61, 0x72, 0x6e, 0x65, 0x72, 0x00, 0x53, 0x74, 0x65, 0x76,
+    0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x75, 0x72, 0x67, 0x65, 0x73,
+    0x73, 0x00, 0x53, 0x61, 0x6e, 0x74, 0x6f, 0x73, 0x00, 0x54, 0x61, 0x74,
+    0x65, 0x00, 0x43, 0x72, 0x6f, 0x73, 0x73, 0x00, 0x47, 0x61, 0x72, 0x6e,
+    0x65, 0x72, 0x00, 0x4d, 0x61, 0x6e, 0x6e, 0x00, 0x4d, 0x61, 0x63, 0x6b,
+    0x00, 0x4d, 0x6f, 0x73, 0x73, 0x00, 0x54, 0x68, 0x6f, 0x72, 0x6e, 0x74,
+    0x6f, 0x6e, 0x00, 0x44, 0x65, 0x6e, 0x6e, 0x69, 0x73, 0x00, 0x4d, 0x63,
+    0x67, 0x65, 0x65, 0x00, 0x46, 0x61, 0x72, 0x6d, 0x65, 0x72, 0x00, 0x44,
+    0x65, 0x6c, 0x67, 0x61, 0x64, 0x6f, 0x00, 0x41, 0x67, 0x75, 0x69, 0x6c,
+    0x61, 0x72, 0x00, 0x56, 0x65, 0x67, 0x61, 0x00, 0x47, 0x6c, 0x6f, 0x76,
+    0x65, 0x72, 0x00, 0x4d, 0x61, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x43,
+    0x6f, 0x68, 0x65, 0x6e, 0x00, 0x48, 0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x00,
+    0x52, 0x6f, 0x64, 0x67, 0x65, 0x72, 0x73, 0x00, 0x52, 0x6f, 0x62, 0x62,
+    0x69, 0x6e, 0x73, 0x00, 0x4e, 0x65, 0x77, 0x74, 0x6f, 0x6e, 0x00, 0x54,
+    0x6f, 0x64, 0x64, 0x00, 0x42, 0x6c, 0x61, 0x69, 0x72, 0x00, 0x48, 0x69,
+    0x67, 0x67, 0x69, 0x6e, 0x73, 0x00, 0x49, 0x6e, 0x67, 0x72, 0x61, 0x6d,
+    0x00, 0x52, 0x65, 0x65, 0x73, 0x65, 0x00, 0x43, 0x61, 0x6e, 0x6e, 0x6f,
+    0x6e, 0x00, 0x53, 0x74, 0x72, 0x69, 0x63, 0x6b, 0x6c, 0x61, 0x6e, 0x64,
+    0x00, 0x54, 0x6f, 0x77, 0x6e, 0x73, 0x65, 0x6e, 0x64, 0x00, 0x50, 0x6f,
+    0x74, 0x74, 0x65, 0x72, 0x00, 0x47, 0x6f, 0x6f, 0x64, 0x77, 0x69, 0x6e,
+    0x00, 0x57, 0x61, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x6f, 0x77, 0x65,
+    0x00, 0x48, 0x61, 0x6d, 0x70, 0x74, 0x6f, 0x6e, 0x00, 0x4f, 0x72, 0x74,
+    0x65, 0x67, 0x61, 0x00, 0x50, 0x61, 0x74, 0x74, 0x6f, 0x6e, 0x00, 0x53,
+    0x77, 0x61, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x6f, 0x73, 0x65, 0x70,
+    0x68, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73, 0x00, 0x47, 0x6f,
+    0x6f, 0x64, 0x6d, 0x61, 0x6e, 0x00, 0x4d, 0x61, 0x6c, 0x64, 0x6f, 0x6e,
+    0x61, 0x64, 0x6f, 0x00, 0x59, 0x61, 0x74, 0x65, 0x73, 0x00, 0x42, 0x65,
+    0x63, 0x6b, 0x65, 0x72, 0x00, 0x45, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x6f,
+    0x6e, 0x00, 0x48, 0x6f, 0x64, 0x67, 0x65, 0x73, 0x00, 0x52, 0x69, 0x6f,
+    0x73, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x72, 0x00, 0x41, 0x64, 0x6b,
+    0x69, 0x6e, 0x73, 0x00, 0x57, 0x65, 0x62, 0x73, 0x74, 0x65, 0x72, 0x00,
+    0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x4d, 0x61, 0x6c, 0x6f, 0x6e,
+    0x65, 0x00, 0x48, 0x61, 0x6d, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x46, 0x6c,
+    0x6f, 0x77, 0x65, 0x72, 0x73, 0x00, 0x43, 0x6f, 0x62, 0x62, 0x00, 0x4d,
+    0x6f, 0x6f, 0x64, 0x79, 0x00, 0x51, 0x75, 0x69, 0x6e, 0x6e, 0x00, 0x42,
+    0x6c, 0x61, 0x6b, 0x65, 0x00, 0x4d, 0x61, 0x78, 0x77, 0x65, 0x6c, 0x6c,
+    0x00, 0x50, 0x6f, 0x70, 0x65, 0x00, 0x46, 0x6c, 0x6f, 0x79, 0x64, 0x00,
+    0x4f, 0x73, 0x62, 0x6f, 0x72, 0x6e, 0x65, 0x00, 0x50, 0x61, 0x75, 0x6c,
+    0x00, 0x4d, 0x63, 0x63, 0x61, 0x72, 0x74, 0x68, 0x79, 0x00, 0x47, 0x75,
+    0x65, 0x72, 0x72, 0x65, 0x72, 0x6f, 0x00, 0x4c, 0x69, 0x6e, 0x64, 0x73,
+    0x65, 0x79, 0x00, 0x45, 0x73, 0x74, 0x72, 0x61, 0x64, 0x61, 0x00, 0x53,
+    0x61, 0x6e, 0x64, 0x6f, 0x76, 0x61, 0x6c, 0x00, 0x47, 0x69, 0x62, 0x62,
+    0x73, 0x00, 0x54, 0x79, 0x6c, 0x65, 0x72, 0x00, 0x47, 0x72, 0x6f, 0x73,
+    0x73, 0x00, 0x46, 0x69, 0x74, 0x7a, 0x67, 0x65, 0x72, 0x61, 0x6c, 0x64,
+    0x00, 0x53, 0x74, 0x6f, 0x6b, 0x65, 0x73, 0x00, 0x44, 0x6f, 0x79, 0x6c,
+    0x65, 0x00, 0x53, 0x68, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x61,
+    0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x00, 0x57, 0x69, 0x73, 0x65, 0x00,
+    0x43, 0x6f, 0x6c, 0x6f, 0x6e, 0x00, 0x47, 0x69, 0x6c, 0x6c, 0x00, 0x41,
+    0x6c, 0x76, 0x61, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x47, 0x72, 0x65, 0x65,
+    0x72, 0x00, 0x50, 0x61, 0x64, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x53, 0x69,
+    0x6d, 0x6f, 0x6e, 0x00, 0x57, 0x61, 0x74, 0x65, 0x72, 0x73, 0x00, 0x4e,
+    0x75, 0x6e, 0x65, 0x7a, 0x00, 0x42, 0x61, 0x6c, 0x6c, 0x61, 0x72, 0x64,
+    0x00, 0x53, 0x63, 0x68, 0x77, 0x61, 0x72, 0x74, 0x7a, 0x00, 0x4d, 0x63,
+    0x62, 0x72, 0x69, 0x64, 0x65, 0x00, 0x48, 0x6f, 0x75, 0x73, 0x74, 0x6f,
+    0x6e, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x73, 0x65,
+    0x6e, 0x00, 0x4b, 0x6c, 0x65, 0x69, 0x6e, 0x00, 0x50, 0x72, 0x61, 0x74,
+    0x74, 0x00, 0x42, 0x72, 0x69, 0x67, 0x67, 0x73, 0x00, 0x50, 0x61, 0x72,
+    0x73, 0x6f, 0x6e, 0x73, 0x00, 0x4d, 0x63, 0x6c, 0x61, 0x75, 0x67, 0x68,
+    0x6c, 0x69, 0x6e, 0x00, 0x5a, 0x69, 0x6d, 0x6d, 0x65, 0x72, 0x6d, 0x61,
+    0x6e, 0x00, 0x46, 0x72, 0x65, 0x6e, 0x63, 0x68, 0x00, 0x42, 0x75, 0x63,
+    0x68, 0x61, 0x6e, 0x61, 0x6e, 0x00, 0x4d, 0x6f, 0x72, 0x61, 0x6e, 0x00,
+    0x43, 0x6f, 0x70, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x52, 0x6f, 0x79,
+    0x00, 0x50, 0x69, 0x74, 0x74, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x72, 0x61,
+    0x64, 0x79, 0x00, 0x4d, 0x63, 0x63, 0x6f, 0x72, 0x6d, 0x69, 0x63, 0x6b,
+    0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x61, 0x79, 0x00, 0x42, 0x72,
+    0x6f, 0x63, 0x6b, 0x00, 0x50, 0x6f, 0x6f, 0x6c, 0x65, 0x00, 0x46, 0x72,
+    0x61, 0x6e, 0x6b, 0x00, 0x4c, 0x6f, 0x67, 0x61, 0x6e, 0x00, 0x4f, 0x77,
+    0x65, 0x6e, 0x00, 0x42, 0x61, 0x73, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x73,
+    0x68, 0x00, 0x44, 0x72, 0x61, 0x6b, 0x65, 0x00, 0x57, 0x6f, 0x6e, 0x67,
+    0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x50,
+    0x61, 0x72, 0x6b, 0x00, 0x4d, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x41,
+    0x62, 0x62, 0x6f, 0x74, 0x74, 0x00, 0x53, 0x70, 0x61, 0x72, 0x6b, 0x73,
+    0x00, 0x50, 0x61, 0x74, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x6f, 0x6e, 0x00, 0x48, 0x75, 0x66, 0x66, 0x00, 0x43, 0x6c, 0x61,
+    0x79, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x65, 0x79, 0x00,
+    0x4c, 0x6c, 0x6f, 0x79, 0x64, 0x00, 0x46, 0x69, 0x67, 0x75, 0x65, 0x72,
+    0x6f, 0x61, 0x00, 0x43, 0x61, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x6f,
+    0x77, 0x65, 0x72, 0x73, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x00, 0x42, 0x61, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x72, 0x61,
+    0x6e, 0x00, 0x4c, 0x61, 0x6d, 0x62, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x73, 0x65, 0x79, 0x00,
+    0x42, 0x6f, 0x6f, 0x6e, 0x65, 0x00, 0x43, 0x6f, 0x72, 0x74, 0x65, 0x7a,
+    0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x65, 0x00, 0x4d, 0x61, 0x74, 0x68,
+    0x69, 0x73, 0x00, 0x53, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x74, 0x6f, 0x6e,
+    0x00, 0x57, 0x69, 0x6c, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x43, 0x61, 0x69,
+    0x6e, 0x00, 0x42, 0x72, 0x79, 0x61, 0x6e, 0x00, 0x55, 0x6e, 0x64, 0x65,
+    0x72, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x48, 0x6f, 0x67, 0x61, 0x6e, 0x00,
+    0x4d, 0x63, 0x6b, 0x65, 0x6e, 0x7a, 0x69, 0x65, 0x00, 0x43, 0x6f, 0x6c,
+    0x6c, 0x69, 0x65, 0x72, 0x00, 0x4c, 0x75, 0x6e, 0x61, 0x00, 0x50, 0x68,
+    0x65, 0x6c, 0x70, 0x73, 0x00, 0x4d, 0x63, 0x67, 0x75, 0x69, 0x72, 0x65,
+    0x00, 0x41, 0x6c, 0x6c, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x69,
+    0x64, 0x67, 0x65, 0x73, 0x00, 0x57, 0x69, 0x6c, 0x6b, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x00, 0x4e, 0x61, 0x73, 0x68, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x73, 0x00, 0x41, 0x74, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x57,
+    0x69, 0x6c, 0x63, 0x6f, 0x78, 0x00, 0x50, 0x69, 0x74, 0x74, 0x73, 0x00,
+    0x43, 0x6f, 0x6e, 0x6c, 0x65, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x71, 0x75,
+    0x65, 0x7a, 0x00, 0x42, 0x75, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x00, 0x52,
+    0x69, 0x63, 0x68, 0x61, 0x72, 0x64, 0x00, 0x43, 0x6f, 0x63, 0x68, 0x72,
+    0x61, 0x6e, 0x00, 0x43, 0x68, 0x61, 0x73, 0x65, 0x00, 0x44, 0x61, 0x76,
+    0x65, 0x6e, 0x70, 0x6f, 0x72, 0x74, 0x00, 0x48, 0x6f, 0x6f, 0x64, 0x00,
+    0x47, 0x61, 0x74, 0x65, 0x73, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x00, 0x41,
+    0x79, 0x61, 0x6c, 0x61, 0x00, 0x53, 0x61, 0x77, 0x79, 0x65, 0x72, 0x00,
+    0x52, 0x6f, 0x6d, 0x61, 0x6e, 0x00, 0x56, 0x61, 0x7a, 0x71, 0x75, 0x65,
+    0x7a, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00,
+    0x48, 0x6f, 0x64, 0x67, 0x65, 0x00, 0x41, 0x63, 0x6f, 0x73, 0x74, 0x61,
+    0x00, 0x46, 0x6c, 0x79, 0x6e, 0x6e, 0x00, 0x45, 0x73, 0x70, 0x69, 0x6e,
+    0x6f, 0x7a, 0x61, 0x00, 0x4e, 0x69, 0x63, 0x68, 0x6f, 0x6c, 0x73, 0x6f,
+    0x6e, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x00, 0x57, 0x6f, 0x6c,
+    0x66, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x00, 0x4b, 0x69, 0x72,
+    0x6b, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x00, 0x41, 0x6e,
+    0x74, 0x68, 0x6f, 0x6e, 0x79, 0x00, 0x57, 0x68, 0x69, 0x74, 0x61, 0x6b,
+    0x65, 0x72, 0x00, 0x4f, 0x63, 0x6f, 0x6e, 0x6e, 0x6f, 0x72, 0x00, 0x53,
+    0x6b, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x00, 0x57, 0x61, 0x72, 0x65, 0x00,
+    0x4d, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x4b, 0x69, 0x72, 0x62, 0x79,
+    0x00, 0x48, 0x75, 0x66, 0x66, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x72, 0x61,
+    0x64, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65,
+    0x73, 0x00, 0x47, 0x69, 0x6c, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x44, 0x6f,
+    0x6d, 0x69, 0x6e, 0x67, 0x75, 0x65, 0x7a, 0x00, 0x4f, 0x6e, 0x65, 0x61,
+    0x6c, 0x00, 0x42, 0x72, 0x75, 0x63, 0x65, 0x00, 0x4c, 0x61, 0x6e, 0x67,
+    0x00, 0x43, 0x6f, 0x6d, 0x62, 0x73, 0x00, 0x4b, 0x72, 0x61, 0x6d, 0x65,
+    0x72, 0x00, 0x48, 0x65, 0x61, 0x74, 0x68, 0x00, 0x48, 0x61, 0x6e, 0x63,
+    0x6f, 0x63, 0x6b, 0x00, 0x47, 0x61, 0x6c, 0x6c, 0x61, 0x67, 0x68, 0x65,
+    0x72, 0x00, 0x47, 0x61, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x53, 0x68, 0x61,
+    0x66, 0x66, 0x65, 0x72, 0x00, 0x53, 0x68, 0x6f, 0x72, 0x74, 0x00, 0x57,
+    0x69, 0x67, 0x67, 0x69, 0x6e, 0x73, 0x00, 0x4d, 0x61, 0x74, 0x68, 0x65,
+    0x77, 0x73, 0x00, 0x4d, 0x63, 0x63, 0x6c, 0x61, 0x69, 0x6e, 0x00, 0x46,
+    0x69, 0x73, 0x63, 0x68, 0x65, 0x72, 0x00, 0x57, 0x61, 0x6c, 0x6c, 0x00,
+    0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x00, 0x4d, 0x65, 0x6c, 0x74, 0x6f, 0x6e,
+    0x00, 0x48, 0x65, 0x6e, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x6f, 0x6e,
+    0x64, 0x00, 0x44, 0x79, 0x65, 0x72, 0x00, 0x43, 0x61, 0x6d, 0x65, 0x72,
+    0x6f, 0x6e, 0x00, 0x47, 0x72, 0x69, 0x6d, 0x65, 0x73, 0x00, 0x43, 0x6f,
+    0x6e, 0x74, 0x72, 0x65, 0x72, 0x61, 0x73, 0x00, 0x43, 0x68, 0x72, 0x69,
+    0x73, 0x74, 0x69, 0x61, 0x6e, 0x00, 0x57, 0x79, 0x61, 0x74, 0x74, 0x00,
+    0x42, 0x61, 0x78, 0x74, 0x65, 0x72, 0x00, 0x53, 0x6e, 0x6f, 0x77, 0x00,
+    0x4d, 0x6f, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x68, 0x65, 0x70, 0x68,
+    0x65, 0x72, 0x64, 0x00, 0x4c, 0x61, 0x72, 0x73, 0x65, 0x6e, 0x00, 0x48,
+    0x6f, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x42, 0x65, 0x61, 0x73, 0x6c, 0x65,
+    0x79, 0x00, 0x47, 0x6c, 0x65, 0x6e, 0x6e, 0x00, 0x50, 0x65, 0x74, 0x65,
+    0x72, 0x73, 0x65, 0x6e, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65, 0x68, 0x65,
+    0x61, 0x64, 0x00, 0x4d, 0x65, 0x79, 0x65, 0x72, 0x73, 0x00, 0x4b, 0x65,
+    0x69, 0x74, 0x68, 0x00, 0x47, 0x61, 0x72, 0x72, 0x69, 0x73, 0x6f, 0x6e,
+    0x00, 0x56, 0x69, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x00, 0x53, 0x68, 0x69,
+    0x65, 0x6c, 0x64, 0x73, 0x00, 0x48, 0x6f, 0x72, 0x6e, 0x00, 0x53, 0x61,
+    0x76, 0x61, 0x67, 0x65, 0x00, 0x4f, 0x6c, 0x73, 0x65, 0x6e, 0x00, 0x53,
+    0x63, 0x68, 0x72, 0x6f, 0x65, 0x64, 0x65, 0x72, 0x00, 0x48, 0x61, 0x72,
+    0x74, 0x6d, 0x61, 0x6e, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x61, 0x72, 0x64,
+    0x00, 0x4d, 0x75, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x4b, 0x65, 0x6d,
+    0x70, 0x00, 0x44, 0x65, 0x6c, 0x65, 0x6f, 0x6e, 0x00, 0x42, 0x6f, 0x6f,
+    0x74, 0x68, 0x00, 0x50, 0x61, 0x74, 0x65, 0x6c, 0x00, 0x43, 0x61, 0x6c,
+    0x68, 0x6f, 0x75, 0x6e, 0x00, 0x57, 0x69, 0x6c, 0x65, 0x79, 0x00, 0x45,
+    0x61, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x4e,
+    0x61, 0x76, 0x61, 0x72, 0x72, 0x6f, 0x00, 0x48, 0x61, 0x72, 0x72, 0x65,
+    0x6c, 0x6c, 0x00, 0x4c, 0x65, 0x73, 0x74, 0x65, 0x72, 0x00, 0x48, 0x75,
+    0x6d, 0x70, 0x68, 0x72, 0x65, 0x79, 0x00, 0x50, 0x61, 0x72, 0x72, 0x69,
+    0x73, 0x68, 0x00, 0x44, 0x75, 0x72, 0x61, 0x6e, 0x00, 0x48, 0x75, 0x74,
+    0x63, 0x68, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x65, 0x73, 0x73,
+    0x00, 0x44, 0x6f, 0x72, 0x73, 0x65, 0x79, 0x00, 0x42, 0x75, 0x6c, 0x6c,
+    0x6f, 0x63, 0x6b, 0x00, 0x52, 0x6f, 0x62, 0x6c, 0x65, 0x73, 0x00, 0x42,
+    0x65, 0x61, 0x72, 0x64, 0x00, 0x44, 0x61, 0x6c, 0x74, 0x6f, 0x6e, 0x00,
+    0x41, 0x76, 0x69, 0x6c, 0x61, 0x00, 0x56, 0x61, 0x6e, 0x63, 0x65, 0x00,
+    0x52, 0x69, 0x63, 0x68, 0x00, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x77, 0x65,
+    0x6c, 0x6c, 0x00, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x4a, 0x6f, 0x68, 0x6e,
+    0x73, 0x00, 0x42, 0x6c, 0x61, 0x6e, 0x6b, 0x65, 0x6e, 0x73, 0x68, 0x69,
+    0x70, 0x00, 0x54, 0x72, 0x65, 0x76, 0x69, 0x6e, 0x6f, 0x00, 0x53, 0x61,
+    0x6c, 0x69, 0x6e, 0x61, 0x73, 0x00, 0x43, 0x61, 0x6d, 0x70, 0x6f, 0x73,
+    0x00, 0x50, 0x72, 0x75, 0x69, 0x74, 0x74, 0x00, 0x4d, 0x6f, 0x73, 0x65,
+    0x73, 0x00, 0x43, 0x61, 0x6c, 0x6c, 0x61, 0x68, 0x61, 0x6e, 0x00, 0x47,
+    0x6f, 0x6c, 0x64, 0x65, 0x6e, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x6f, 0x79,
+    0x61, 0x00, 0x48, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x00, 0x47, 0x75, 0x65,
+    0x72, 0x72, 0x61, 0x00, 0x4d, 0x63, 0x64, 0x6f, 0x77, 0x65, 0x6c, 0x6c,
+    0x00, 0x43, 0x61, 0x72, 0x65, 0x79, 0x00, 0x53, 0x74, 0x61, 0x66, 0x66,
+    0x6f, 0x72, 0x64, 0x00, 0x47, 0x61, 0x6c, 0x6c, 0x65, 0x67, 0x6f, 0x73,
+    0x00, 0x48, 0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6c, 0x6b,
+    0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x6f, 0x6f, 0x6b, 0x65, 0x72,
+    0x00, 0x4d, 0x65, 0x72, 0x72, 0x69, 0x74, 0x74, 0x00, 0x4d, 0x69, 0x72,
+    0x61, 0x6e, 0x64, 0x61, 0x00, 0x41, 0x74, 0x6b, 0x69, 0x6e, 0x73, 0x6f,
+    0x6e, 0x00, 0x4f, 0x72, 0x72, 0x00, 0x44, 0x65, 0x63, 0x6b, 0x65, 0x72,
+    0x00, 0x48, 0x6f, 0x62, 0x62, 0x73, 0x00, 0x50, 0x72, 0x65, 0x73, 0x74,
+    0x6f, 0x6e, 0x00, 0x54, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x00, 0x4b, 0x6e,
+    0x6f, 0x78, 0x00, 0x50, 0x61, 0x63, 0x68, 0x65, 0x63, 0x6f, 0x00, 0x53,
+    0x74, 0x65, 0x70, 0x68, 0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x47, 0x6c,
+    0x61, 0x73, 0x73, 0x00, 0x52, 0x6f, 0x6a, 0x61, 0x73, 0x00, 0x53, 0x65,
+    0x72, 0x72, 0x61, 0x6e, 0x6f, 0x00, 0x4d, 0x61, 0x72, 0x6b, 0x73, 0x00,
+    0x48, 0x69, 0x63, 0x6b, 0x6d, 0x61, 0x6e, 0x00, 0x45, 0x6e, 0x67, 0x6c,
+    0x69, 0x73, 0x68, 0x00, 0x53, 0x77, 0x65, 0x65, 0x6e, 0x65, 0x79, 0x00,
+    0x53, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x00, 0x50, 0x72, 0x69, 0x6e, 0x63,
+    0x65, 0x00, 0x4d, 0x63, 0x63, 0x6c, 0x75, 0x72, 0x65, 0x00, 0x43, 0x6f,
+    0x6e, 0x77, 0x61, 0x79, 0x00, 0x57, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x00,
+    0x52, 0x6f, 0x74, 0x68, 0x00, 0x4d, 0x61, 0x79, 0x6e, 0x61, 0x72, 0x64,
+    0x00, 0x46, 0x61, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x6f, 0x77,
+    0x65, 0x72, 0x79, 0x00, 0x48, 0x75, 0x72, 0x73, 0x74, 0x00, 0x4e, 0x69,
+    0x78, 0x6f, 0x6e, 0x00, 0x57, 0x65, 0x69, 0x73, 0x73, 0x00, 0x54, 0x72,
+    0x75, 0x6a, 0x69, 0x6c, 0x6c, 0x6f, 0x00, 0x45, 0x6c, 0x6c, 0x69, 0x73,
+    0x6f, 0x6e, 0x00, 0x53, 0x6c, 0x6f, 0x61, 0x6e, 0x00, 0x4a, 0x75, 0x61,
+    0x72, 0x65, 0x7a, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x00,
+    0x4d, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x6f,
+    0x6c, 0x70, 0x68, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x00, 0x42, 0x6f, 0x79,
+    0x65, 0x72, 0x00, 0x56, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x72, 0x65, 0x61,
+    0x6c, 0x00, 0x4d, 0x63, 0x63, 0x61, 0x6c, 0x6c, 0x00, 0x47, 0x65, 0x6e,
+    0x74, 0x72, 0x79, 0x00, 0x43, 0x61, 0x72, 0x72, 0x69, 0x6c, 0x6c, 0x6f,
+    0x00, 0x4b, 0x65, 0x6e, 0x74, 0x00, 0x41, 0x79, 0x65, 0x72, 0x73, 0x00,
+    0x4c, 0x61, 0x72, 0x61, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e,
+    0x00, 0x53, 0x65, 0x78, 0x74, 0x6f, 0x6e, 0x00, 0x50, 0x61, 0x63, 0x65,
+    0x00, 0x48, 0x75, 0x6c, 0x6c, 0x00, 0x4c, 0x65, 0x62, 0x6c, 0x61, 0x6e,
+    0x63, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x56,
+    0x65, 0x6c, 0x61, 0x73, 0x71, 0x75, 0x65, 0x7a, 0x00, 0x4c, 0x65, 0x61,
+    0x63, 0x68, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x00, 0x48, 0x6f, 0x75,
+    0x73, 0x65, 0x00, 0x53, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x48,
+    0x65, 0x72, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x4e, 0x6f, 0x62, 0x6c, 0x65,
+    0x00, 0x46, 0x6f, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x61, 0x72, 0x74, 0x6c,
+    0x65, 0x74, 0x74, 0x00, 0x4d, 0x65, 0x72, 0x63, 0x61, 0x64, 0x6f, 0x00,
+    0x4c, 0x61, 0x6e, 0x64, 0x72, 0x79, 0x00, 0x44, 0x75, 0x72, 0x68, 0x61,
+    0x6d, 0x00, 0x57, 0x61, 0x6c, 0x6c, 0x73, 0x00, 0x42, 0x61, 0x72, 0x72,
+    0x00, 0x4d, 0x63, 0x6b, 0x65, 0x65, 0x00, 0x42, 0x61, 0x75, 0x65, 0x72,
+    0x00, 0x52, 0x69, 0x76, 0x65, 0x72, 0x73, 0x00, 0x45, 0x76, 0x65, 0x72,
+    0x65, 0x74, 0x74, 0x00, 0x42, 0x72, 0x61, 0x64, 0x73, 0x68, 0x61, 0x77,
+    0x00, 0x50, 0x75, 0x67, 0x68, 0x00, 0x56, 0x65, 0x6c, 0x65, 0x7a, 0x00,
+    0x52, 0x75, 0x73, 0x68, 0x00, 0x45, 0x73, 0x74, 0x65, 0x73, 0x00, 0x44,
+    0x6f, 0x64, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x6f, 0x72, 0x73, 0x65, 0x00,
+    0x53, 0x68, 0x65, 0x70, 0x70, 0x61, 0x72, 0x64, 0x00, 0x57, 0x65, 0x65,
+    0x6b, 0x73, 0x00, 0x43, 0x61, 0x6d, 0x61, 0x63, 0x68, 0x6f, 0x00, 0x42,
+    0x65, 0x61, 0x6e, 0x00, 0x42, 0x61, 0x72, 0x72, 0x6f, 0x6e, 0x00, 0x4c,
+    0x69, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x69,
+    0x64, 0x64, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x70, 0x65, 0x61,
+    0x72, 0x73, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x00, 0x42, 0x6c,
+    0x65, 0x76, 0x69, 0x6e, 0x73, 0x00, 0x43, 0x68, 0x65, 0x6e, 0x00, 0x4b,
+    0x65, 0x72, 0x72, 0x00, 0x4d, 0x63, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x6c,
+    0x6c, 0x00, 0x48, 0x61, 0x74, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x48,
+    0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x41, 0x73, 0x68, 0x6c, 0x65,
+    0x79, 0x00, 0x53, 0x6f, 0x6c, 0x69, 0x73, 0x00, 0x48, 0x65, 0x72, 0x6d,
+    0x61, 0x6e, 0x00, 0x46, 0x72, 0x6f, 0x73, 0x74, 0x00, 0x47, 0x69, 0x6c,
+    0x65, 0x73, 0x00, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x62, 0x75, 0x72, 0x6e,
+    0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x6f, 0x6f, 0x64,
+    0x77, 0x61, 0x72, 0x64, 0x00, 0x46, 0x69, 0x6e, 0x6c, 0x65, 0x79, 0x00,
+    0x4d, 0x63, 0x69, 0x6e, 0x74, 0x6f, 0x73, 0x68, 0x00, 0x4b, 0x6f, 0x63,
+    0x68, 0x00, 0x42, 0x65, 0x73, 0x74, 0x00, 0x53, 0x6f, 0x6c, 0x6f, 0x6d,
+    0x6f, 0x6e, 0x00, 0x4d, 0x63, 0x63, 0x75, 0x6c, 0x6c, 0x6f, 0x75, 0x67,
+    0x68, 0x00, 0x44, 0x75, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x4e, 0x6f, 0x6c,
+    0x61, 0x6e, 0x00, 0x42, 0x6c, 0x61, 0x6e, 0x63, 0x68, 0x61, 0x72, 0x64,
+    0x00, 0x52, 0x69, 0x76, 0x61, 0x73, 0x00, 0x42, 0x72, 0x65, 0x6e, 0x6e,
+    0x61, 0x6e, 0x00, 0x4d, 0x65, 0x6a, 0x69, 0x61, 0x00, 0x4b, 0x61, 0x6e,
+    0x65, 0x00, 0x42, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x4a, 0x6f, 0x79,
+    0x63, 0x65, 0x00, 0x42, 0x75, 0x63, 0x6b, 0x6c, 0x65, 0x79, 0x00, 0x48,
+    0x61, 0x6c, 0x65, 0x79, 0x00, 0x56, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x69,
+    0x6e, 0x65, 0x00, 0x4d, 0x61, 0x64, 0x64, 0x6f, 0x78, 0x00, 0x52, 0x75,
+    0x73, 0x73, 0x6f, 0x00, 0x4d, 0x63, 0x6b, 0x6e, 0x69, 0x67, 0x68, 0x74,
+    0x00, 0x42, 0x75, 0x63, 0x6b, 0x00, 0x4d, 0x6f, 0x6f, 0x6e, 0x00, 0x4d,
+    0x63, 0x6d, 0x69, 0x6c, 0x6c, 0x61, 0x6e, 0x00, 0x43, 0x72, 0x6f, 0x73,
+    0x62, 0x79, 0x00, 0x42, 0x65, 0x72, 0x67, 0x00, 0x44, 0x6f, 0x74, 0x73,
+    0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x79, 0x73, 0x00, 0x52, 0x6f, 0x61, 0x63,
+    0x68, 0x00, 0x43, 0x68, 0x75, 0x72, 0x63, 0x68, 0x00, 0x43, 0x68, 0x61,
+    0x6e, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x4d,
+    0x65, 0x61, 0x64, 0x6f, 0x77, 0x73, 0x00, 0x46, 0x61, 0x75, 0x6c, 0x6b,
+    0x6e, 0x65, 0x72, 0x00, 0x4f, 0x6e, 0x65, 0x69, 0x6c, 0x6c, 0x00, 0x4b,
+    0x6e, 0x61, 0x70, 0x70, 0x00, 0x4b, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x42,
+    0x61, 0x72, 0x72, 0x79, 0x00, 0x4f, 0x63, 0x68, 0x6f, 0x61, 0x00, 0x4a,
+    0x61, 0x63, 0x6f, 0x62, 0x73, 0x6f, 0x6e, 0x00, 0x47, 0x61, 0x79, 0x00,
+    0x41, 0x76, 0x65, 0x72, 0x79, 0x00, 0x48, 0x65, 0x6e, 0x64, 0x72, 0x69,
+    0x63, 0x6b, 0x73, 0x00, 0x48, 0x6f, 0x72, 0x6e, 0x65, 0x00, 0x53, 0x68,
+    0x65, 0x70, 0x61, 0x72, 0x64, 0x00, 0x48, 0x65, 0x62, 0x65, 0x72, 0x74,
+    0x00, 0x43, 0x68, 0x65, 0x72, 0x72, 0x79, 0x00, 0x43, 0x61, 0x72, 0x64,
+    0x65, 0x6e, 0x61, 0x73, 0x00, 0x4d, 0x63, 0x69, 0x6e, 0x74, 0x79, 0x72,
+    0x65, 0x00, 0x57, 0x68, 0x69, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x57, 0x61,
+    0x6c, 0x6c, 0x65, 0x72, 0x00, 0x48, 0x6f, 0x6c, 0x6d, 0x61, 0x6e, 0x00,
+    0x44, 0x6f, 0x6e, 0x61, 0x6c, 0x64, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x61,
+    0x6e, 0x74, 0x75, 0x00, 0x54, 0x65, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00,
+    0x4d, 0x6f, 0x72, 0x69, 0x6e, 0x00, 0x47, 0x69, 0x6c, 0x6c, 0x65, 0x73,
+    0x70, 0x69, 0x65, 0x00, 0x46, 0x75, 0x65, 0x6e, 0x74, 0x65, 0x73, 0x00,
+    0x54, 0x69, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x61, 0x6e, 0x66,
+    0x6f, 0x72, 0x64, 0x00, 0x42, 0x65, 0x6e, 0x74, 0x6c, 0x65, 0x79, 0x00,
+    0x50, 0x65, 0x63, 0x6b, 0x00, 0x4b, 0x65, 0x79, 0x00, 0x53, 0x61, 0x6c,
+    0x61, 0x73, 0x00, 0x52, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x73, 0x00, 0x47,
+    0x61, 0x6d, 0x62, 0x6c, 0x65, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x73, 0x6f,
+    0x6e, 0x00, 0x42, 0x61, 0x74, 0x74, 0x6c, 0x65, 0x00, 0x53, 0x61, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x43, 0x61, 0x62, 0x72, 0x65, 0x72, 0x61,
+    0x00, 0x43, 0x65, 0x72, 0x76, 0x61, 0x6e, 0x74, 0x65, 0x73, 0x00, 0x48,
+    0x6f, 0x77, 0x65, 0x00, 0x48, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x48,
+    0x75, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x70, 0x65, 0x6e, 0x63, 0x65,
+    0x00, 0x5a, 0x61, 0x6d, 0x6f, 0x72, 0x61, 0x00, 0x59, 0x61, 0x6e, 0x67,
+    0x00, 0x4d, 0x63, 0x6e, 0x65, 0x69, 0x6c, 0x00, 0x53, 0x75, 0x61, 0x72,
+    0x65, 0x7a, 0x00, 0x43, 0x61, 0x73, 0x65, 0x00, 0x50, 0x65, 0x74, 0x74,
+    0x79, 0x00, 0x47, 0x6f, 0x75, 0x6c, 0x64, 0x00, 0x4d, 0x63, 0x66, 0x61,
+    0x72, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x53, 0x61, 0x6d, 0x70, 0x73, 0x6f,
+    0x6e, 0x00, 0x43, 0x61, 0x72, 0x76, 0x65, 0x72, 0x00, 0x42, 0x72, 0x61,
+    0x79, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x72, 0x69, 0x6f, 0x00, 0x4d, 0x61,
+    0x63, 0x64, 0x6f, 0x6e, 0x61, 0x6c, 0x64, 0x00, 0x53, 0x74, 0x6f, 0x75,
+    0x74, 0x00, 0x48, 0x65, 0x73, 0x74, 0x65, 0x72, 0x00, 0x4d, 0x65, 0x6c,
+    0x65, 0x6e, 0x64, 0x65, 0x7a, 0x00, 0x44, 0x69, 0x6c, 0x6c, 0x6f, 0x6e,
+    0x00, 0x46, 0x61, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x48, 0x6f, 0x70, 0x70,
+    0x65, 0x72, 0x00, 0x47, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x61, 0x79, 0x00,
+    0x50, 0x6f, 0x74, 0x74, 0x73, 0x00, 0x42, 0x65, 0x72, 0x6e, 0x61, 0x72,
+    0x64, 0x00, 0x4a, 0x6f, 0x79, 0x6e, 0x65, 0x72, 0x00, 0x53, 0x74, 0x65,
+    0x69, 0x6e, 0x00, 0x41, 0x67, 0x75, 0x69, 0x72, 0x72, 0x65, 0x00, 0x4f,
+    0x73, 0x62, 0x6f, 0x72, 0x6e, 0x00, 0x4d, 0x65, 0x72, 0x63, 0x65, 0x72,
+    0x00, 0x42, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x46, 0x72, 0x61, 0x6e,
+    0x63, 0x6f, 0x00, 0x52, 0x6f, 0x77, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x53,
+    0x79, 0x6b, 0x65, 0x73, 0x00, 0x42, 0x65, 0x6e, 0x6a, 0x61, 0x6d, 0x69,
+    0x6e, 0x00, 0x54, 0x72, 0x61, 0x76, 0x69, 0x73, 0x00, 0x50, 0x69, 0x63,
+    0x6b, 0x65, 0x74, 0x74, 0x00, 0x43, 0x72, 0x61, 0x6e, 0x65, 0x00, 0x53,
+    0x65, 0x61, 0x72, 0x73, 0x00, 0x4d, 0x61, 0x79, 0x6f, 0x00, 0x44, 0x75,
+    0x6e, 0x6c, 0x61, 0x70, 0x00, 0x48, 0x61, 0x79, 0x64, 0x65, 0x6e, 0x00,
+    0x57, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x00, 0x4d, 0x63, 0x6b, 0x61, 0x79,
+    0x00, 0x43, 0x6f, 0x66, 0x66, 0x65, 0x79, 0x00, 0x4d, 0x63, 0x63, 0x61,
+    0x72, 0x74, 0x79, 0x00, 0x45, 0x77, 0x69, 0x6e, 0x67, 0x00, 0x43, 0x6f,
+    0x6f, 0x6c, 0x65, 0x79, 0x00, 0x56, 0x61, 0x75, 0x67, 0x68, 0x61, 0x6e,
+    0x00, 0x42, 0x6f, 0x6e, 0x6e, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x74, 0x74,
+    0x6f, 0x6e, 0x00, 0x48, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x00, 0x53, 0x74,
+    0x61, 0x72, 0x6b, 0x00, 0x46, 0x65, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00,
+    0x43, 0x61, 0x6e, 0x74, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x46, 0x75, 0x6c,
+    0x74, 0x6f, 0x6e, 0x00, 0x4c, 0x79, 0x6e, 0x6e, 0x00, 0x4c, 0x6f, 0x74,
+    0x74, 0x00, 0x43, 0x61, 0x6c, 0x64, 0x65, 0x72, 0x6f, 0x6e, 0x00, 0x52,
+    0x6f, 0x73, 0x61, 0x00, 0x50, 0x6f, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x00,
+    0x48, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x00, 0x42, 0x75, 0x72, 0x63, 0x68,
+    0x00, 0x4d, 0x75, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x46, 0x72, 0x79, 0x00,
+    0x52, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x00, 0x4c, 0x65, 0x76, 0x79, 0x00,
+    0x44, 0x61, 0x76, 0x69, 0x64, 0x00, 0x44, 0x75, 0x6b, 0x65, 0x00, 0x4f,
+    0x64, 0x6f, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x47, 0x75, 0x79, 0x00,
+    0x4d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c, 0x00, 0x42, 0x72, 0x69, 0x74,
+    0x74, 0x00, 0x46, 0x72, 0x65, 0x64, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x00,
+    0x44, 0x61, 0x75, 0x67, 0x68, 0x65, 0x72, 0x74, 0x79, 0x00, 0x42, 0x65,
+    0x72, 0x67, 0x65, 0x72, 0x00, 0x44, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x64,
+    0x00, 0x41, 0x6c, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x4a, 0x61, 0x72, 0x76,
+    0x69, 0x73, 0x00, 0x46, 0x72, 0x79, 0x65, 0x00, 0x52, 0x69, 0x67, 0x67,
+    0x73, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x65, 0x79, 0x00, 0x4f, 0x64, 0x6f,
+    0x6d, 0x00, 0x44, 0x75, 0x66, 0x66, 0x79, 0x00, 0x46, 0x69, 0x74, 0x7a,
+    0x70, 0x61, 0x74, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x56, 0x61, 0x6c, 0x65,
+    0x6e, 0x7a, 0x75, 0x65, 0x6c, 0x61, 0x00, 0x4d, 0x65, 0x72, 0x72, 0x69,
+    0x6c, 0x6c, 0x00, 0x4d, 0x61, 0x79, 0x65, 0x72, 0x00, 0x41, 0x6c, 0x66,
+    0x6f, 0x72, 0x64, 0x00, 0x4d, 0x63, 0x70, 0x68, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x00, 0x41, 0x63, 0x65, 0x76, 0x65, 0x64, 0x6f, 0x00, 0x44, 0x6f,
+    0x6e, 0x6f, 0x76, 0x61, 0x6e, 0x00, 0x42, 0x61, 0x72, 0x72, 0x65, 0x72,
+    0x61, 0x00, 0x41, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x00, 0x43, 0x6f, 0x74,
+    0x65, 0x00, 0x52, 0x65, 0x69, 0x6c, 0x6c, 0x79, 0x00, 0x43, 0x6f, 0x6d,
+    0x70, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x61, 0x79, 0x6d, 0x6f, 0x6e, 0x64,
+    0x00, 0x4d, 0x6f, 0x6f, 0x6e, 0x65, 0x79, 0x00, 0x4d, 0x63, 0x67, 0x6f,
+    0x77, 0x61, 0x6e, 0x00, 0x43, 0x72, 0x61, 0x66, 0x74, 0x00, 0x43, 0x6c,
+    0x65, 0x76, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x43, 0x6c, 0x65, 0x6d,
+    0x6f, 0x6e, 0x73, 0x00, 0x57, 0x79, 0x6e, 0x6e, 0x00, 0x4e, 0x69, 0x65,
+    0x6c, 0x73, 0x65, 0x6e, 0x00, 0x42, 0x61, 0x69, 0x72, 0x64, 0x00, 0x53,
+    0x74, 0x61, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x6e, 0x69, 0x64, 0x65,
+    0x72, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x42, 0x72,
+    0x69, 0x67, 0x68, 0x74, 0x00, 0x57, 0x69, 0x74, 0x74, 0x00, 0x53, 0x74,
+    0x75, 0x61, 0x72, 0x74, 0x00, 0x48, 0x61, 0x79, 0x73, 0x00, 0x48, 0x6f,
+    0x6c, 0x64, 0x65, 0x6e, 0x00, 0x52, 0x75, 0x74, 0x6c, 0x65, 0x64, 0x67,
+    0x65, 0x00, 0x4b, 0x69, 0x6e, 0x6e, 0x65, 0x79, 0x00, 0x43, 0x6c, 0x65,
+    0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x43, 0x61, 0x73, 0x74, 0x61, 0x6e,
+    0x65, 0x64, 0x61, 0x00, 0x53, 0x6c, 0x61, 0x74, 0x65, 0x72, 0x00, 0x48,
+    0x61, 0x68, 0x6e, 0x00, 0x45, 0x6d, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00,
+    0x43, 0x6f, 0x6e, 0x72, 0x61, 0x64, 0x00, 0x42, 0x75, 0x72, 0x6b, 0x73,
+    0x00, 0x44, 0x65, 0x6c, 0x61, 0x6e, 0x65, 0x79, 0x00, 0x50, 0x61, 0x74,
+    0x65, 0x00, 0x4c, 0x61, 0x6e, 0x63, 0x61, 0x73, 0x74, 0x65, 0x72, 0x00,
+    0x53, 0x77, 0x65, 0x65, 0x74, 0x00, 0x4a, 0x75, 0x73, 0x74, 0x69, 0x63,
+    0x65, 0x00, 0x54, 0x79, 0x73, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x61, 0x72,
+    0x70, 0x65, 0x00, 0x57, 0x68, 0x69, 0x74, 0x66, 0x69, 0x65, 0x6c, 0x64,
+    0x00, 0x54, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x4d, 0x61, 0x63, 0x69,
+    0x61, 0x73, 0x00, 0x49, 0x72, 0x77, 0x69, 0x6e, 0x00, 0x42, 0x75, 0x72,
+    0x72, 0x69, 0x73, 0x00, 0x52, 0x61, 0x74, 0x6c, 0x69, 0x66, 0x66, 0x00,
+    0x4d, 0x63, 0x63, 0x72, 0x61, 0x79, 0x00, 0x4d, 0x61, 0x64, 0x64, 0x65,
+    0x6e, 0x00, 0x4b, 0x61, 0x75, 0x66, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x65,
+    0x61, 0x63, 0x68, 0x00, 0x47, 0x6f, 0x66, 0x66, 0x00, 0x43, 0x61, 0x73,
+    0x68, 0x00, 0x42, 0x6f, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x63, 0x66,
+    0x61, 0x64, 0x64, 0x65, 0x6e, 0x00, 0x4c, 0x65, 0x76, 0x69, 0x6e, 0x65,
+    0x00, 0x47, 0x6f, 0x6f, 0x64, 0x00, 0x42, 0x79, 0x65, 0x72, 0x73, 0x00,
+    0x4b, 0x69, 0x72, 0x6b, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x4b, 0x69, 0x64,
+    0x64, 0x00, 0x57, 0x6f, 0x72, 0x6b, 0x6d, 0x61, 0x6e, 0x00, 0x43, 0x61,
+    0x72, 0x6e, 0x65, 0x79, 0x00, 0x44, 0x61, 0x6c, 0x65, 0x00, 0x4d, 0x63,
+    0x6c, 0x65, 0x6f, 0x64, 0x00, 0x48, 0x6f, 0x6c, 0x63, 0x6f, 0x6d, 0x62,
+    0x00, 0x45, 0x6e, 0x67, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x46, 0x69, 0x6e,
+    0x63, 0x68, 0x00, 0x48, 0x65, 0x61, 0x64, 0x00, 0x42, 0x75, 0x72, 0x74,
+    0x00, 0x48, 0x65, 0x6e, 0x64, 0x72, 0x69, 0x78, 0x00, 0x53, 0x6f, 0x73,
+    0x61, 0x00, 0x48, 0x61, 0x6e, 0x65, 0x79, 0x00, 0x46, 0x72, 0x61, 0x6e,
+    0x6b, 0x73, 0x00, 0x53, 0x61, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x00, 0x4e,
+    0x69, 0x65, 0x76, 0x65, 0x73, 0x00, 0x44, 0x6f, 0x77, 0x6e, 0x73, 0x00,
+    0x52, 0x61, 0x73, 0x6d, 0x75, 0x73, 0x73, 0x65, 0x6e, 0x00, 0x42, 0x69,
+    0x72, 0x64, 0x00, 0x48, 0x65, 0x77, 0x69, 0x74, 0x74, 0x00, 0x4c, 0x69,
+    0x6e, 0x64, 0x73, 0x61, 0x79, 0x00, 0x4c, 0x65, 0x00, 0x46, 0x6f, 0x72,
+    0x65, 0x6d, 0x61, 0x6e, 0x00, 0x56, 0x61, 0x6c, 0x65, 0x6e, 0x63, 0x69,
+    0x61, 0x00, 0x4f, 0x6e, 0x65, 0x69, 0x6c, 0x00, 0x44, 0x65, 0x6c, 0x61,
+    0x63, 0x72, 0x75, 0x7a, 0x00, 0x56, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x00,
+    0x44, 0x65, 0x6a, 0x65, 0x73, 0x75, 0x73, 0x00, 0x48, 0x79, 0x64, 0x65,
+    0x00, 0x46, 0x6f, 0x72, 0x62, 0x65, 0x73, 0x00, 0x47, 0x69, 0x6c, 0x6c,
+    0x69, 0x61, 0x6d, 0x00, 0x47, 0x75, 0x74, 0x68, 0x72, 0x69, 0x65, 0x00,
+    0x57, 0x6f, 0x6f, 0x74, 0x65, 0x6e, 0x00, 0x48, 0x75, 0x62, 0x65, 0x72,
+    0x00, 0x42, 0x61, 0x72, 0x6c, 0x6f, 0x77, 0x00, 0x42, 0x6f, 0x79, 0x6c,
+    0x65, 0x00, 0x4d, 0x63, 0x6d, 0x61, 0x68, 0x6f, 0x6e, 0x00, 0x42, 0x75,
+    0x63, 0x6b, 0x6e, 0x65, 0x72, 0x00, 0x52, 0x6f, 0x63, 0x68, 0x61, 0x00,
+    0x50, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x74, 0x00, 0x4c, 0x61, 0x6e, 0x67,
+    0x6c, 0x65, 0x79, 0x00, 0x4b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x73, 0x00,
+    0x43, 0x6f, 0x6f, 0x6b, 0x65, 0x00, 0x56, 0x65, 0x6c, 0x61, 0x7a, 0x71,
+    0x75, 0x65, 0x7a, 0x00, 0x57, 0x68, 0x69, 0x74, 0x6c, 0x65, 0x79, 0x00,
+    0x4e, 0x6f, 0x65, 0x6c, 0x00, 0x56, 0x61, 0x6e, 0x67, 0x00, 0x53, 0x68,
+    0x65, 0x61, 0x00, 0x52, 0x6f, 0x75, 0x73, 0x65, 0x00, 0x48, 0x61, 0x72,
+    0x74, 0x6c, 0x65, 0x79, 0x00, 0x4d, 0x61, 0x79, 0x66, 0x69, 0x65, 0x6c,
+    0x64, 0x00, 0x45, 0x6c, 0x64, 0x65, 0x72, 0x00, 0x52, 0x61, 0x6e, 0x6b,
+    0x69, 0x6e, 0x00, 0x48, 0x61, 0x6e, 0x6e, 0x61, 0x00, 0x43, 0x6f, 0x77,
+    0x61, 0x6e, 0x00, 0x4c, 0x75, 0x63, 0x65, 0x72, 0x6f, 0x00, 0x41, 0x72,
+    0x72, 0x6f, 0x79, 0x6f, 0x00, 0x53, 0x6c, 0x61, 0x75, 0x67, 0x68, 0x74,
+    0x65, 0x72, 0x00, 0x48, 0x61, 0x61, 0x73, 0x00, 0x4f, 0x63, 0x6f, 0x6e,
+    0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x69, 0x6e, 0x6f, 0x72, 0x00, 0x4b,
+    0x65, 0x6e, 0x64, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x53, 0x68, 0x69, 0x72,
+    0x6c, 0x65, 0x79, 0x00, 0x4b, 0x65, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x00,
+    0x42, 0x6f, 0x75, 0x63, 0x68, 0x65, 0x72, 0x00, 0x41, 0x72, 0x63, 0x68,
+    0x65, 0x72, 0x00, 0x42, 0x6f, 0x67, 0x67, 0x73, 0x00, 0x4f, 0x64, 0x65,
+    0x6c, 0x6c, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x68, 0x65, 0x72, 0x74, 0x79,
+    0x00, 0x41, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x65, 0x6e, 0x00, 0x4e, 0x65,
+    0x77, 0x65, 0x6c, 0x6c, 0x00, 0x43, 0x72, 0x6f, 0x77, 0x65, 0x00, 0x57,
+    0x61, 0x6e, 0x67, 0x00, 0x46, 0x72, 0x69, 0x65, 0x64, 0x6d, 0x61, 0x6e,
+    0x00, 0x42, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x53, 0x77, 0x61, 0x69, 0x6e,
+    0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x46, 0x65, 0x6c, 0x69,
+    0x78, 0x00, 0x50, 0x65, 0x61, 0x72, 0x63, 0x65, 0x00, 0x43, 0x68, 0x69,
+    0x6c, 0x64, 0x73, 0x00, 0x59, 0x61, 0x72, 0x62, 0x72, 0x6f, 0x75, 0x67,
+    0x68, 0x00, 0x47, 0x61, 0x6c, 0x76, 0x61, 0x6e, 0x00, 0x50, 0x72, 0x6f,
+    0x63, 0x74, 0x6f, 0x72, 0x00, 0x4d, 0x65, 0x65, 0x6b, 0x73, 0x00, 0x4c,
+    0x6f, 0x7a, 0x61, 0x6e, 0x6f, 0x00, 0x4d, 0x6f, 0x72, 0x61, 0x00, 0x52,
+    0x61, 0x6e, 0x67, 0x65, 0x6c, 0x00, 0x42, 0x61, 0x63, 0x6f, 0x6e, 0x00,
+    0x56, 0x69, 0x6c, 0x6c, 0x61, 0x6e, 0x75, 0x65, 0x76, 0x61, 0x00, 0x53,
+    0x63, 0x68, 0x61, 0x65, 0x66, 0x65, 0x72, 0x00, 0x52, 0x6f, 0x73, 0x61,
+    0x64, 0x6f, 0x00, 0x48, 0x65, 0x6c, 0x6d, 0x73, 0x00, 0x42, 0x6f, 0x79,
+    0x63, 0x65, 0x00, 0x47, 0x6f, 0x73, 0x73, 0x00, 0x53, 0x74, 0x69, 0x6e,
+    0x73, 0x6f, 0x6e, 0x00, 0x53, 0x6d, 0x61, 0x72, 0x74, 0x00, 0x4c, 0x61,
+    0x6b, 0x65, 0x00, 0x49, 0x62, 0x61, 0x72, 0x72, 0x61, 0x00, 0x48, 0x75,
+    0x74, 0x63, 0x68, 0x69, 0x6e, 0x73, 0x00, 0x43, 0x6f, 0x76, 0x69, 0x6e,
+    0x67, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x65, 0x79, 0x6e, 0x61, 0x00, 0x47,
+    0x72, 0x65, 0x67, 0x67, 0x00, 0x57, 0x65, 0x72, 0x6e, 0x65, 0x72, 0x00,
+    0x43, 0x72, 0x6f, 0x77, 0x6c, 0x65, 0x79, 0x00, 0x48, 0x61, 0x74, 0x63,
+    0x68, 0x65, 0x72, 0x00, 0x4d, 0x61, 0x63, 0x6b, 0x65, 0x79, 0x00, 0x42,
+    0x75, 0x6e, 0x63, 0x68, 0x00, 0x57, 0x6f, 0x6d, 0x61, 0x63, 0x6b, 0x00,
+    0x50, 0x6f, 0x6c, 0x6b, 0x00, 0x4a, 0x61, 0x6d, 0x69, 0x73, 0x6f, 0x6e,
+    0x00, 0x44, 0x6f, 0x64, 0x64, 0x00, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72,
+    0x65, 0x73, 0x73, 0x00, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x65, 0x72, 0x73,
+    0x00, 0x43, 0x61, 0x6d, 0x70, 0x00, 0x56, 0x69, 0x6c, 0x6c, 0x61, 0x00,
+    0x44, 0x79, 0x65, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x65, 0x72,
+    0x00, 0x4d, 0x61, 0x68, 0x6f, 0x6e, 0x65, 0x79, 0x00, 0x44, 0x61, 0x69,
+    0x6c, 0x65, 0x79, 0x00, 0x42, 0x65, 0x6c, 0x63, 0x68, 0x65, 0x72, 0x00,
+    0x4c, 0x6f, 0x63, 0x6b, 0x68, 0x61, 0x72, 0x74, 0x00, 0x47, 0x72, 0x69,
+    0x67, 0x67, 0x73, 0x00, 0x43, 0x6f, 0x73, 0x74, 0x61, 0x00, 0x43, 0x6f,
+    0x6e, 0x6e, 0x6f, 0x72, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x64, 0x74, 0x00,
+    0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x57, 0x61, 0x6c, 0x64, 0x65,
+    0x6e, 0x00, 0x4d, 0x6f, 0x73, 0x65, 0x72, 0x00, 0x54, 0x72, 0x61, 0x63,
+    0x79, 0x00, 0x54, 0x61, 0x74, 0x75, 0x6d, 0x00, 0x4d, 0x63, 0x63, 0x61,
+    0x6e, 0x6e, 0x00, 0x41, 0x6b, 0x65, 0x72, 0x73, 0x00, 0x4c, 0x75, 0x74,
+    0x7a, 0x00, 0x50, 0x72, 0x79, 0x6f, 0x72, 0x00, 0x4c, 0x61, 0x77, 0x00,
+    0x4f, 0x72, 0x6f, 0x7a, 0x63, 0x6f, 0x00, 0x4d, 0x63, 0x61, 0x6c, 0x6c,
+    0x69, 0x73, 0x74, 0x65, 0x72, 0x00, 0x4c, 0x75, 0x67, 0x6f, 0x00, 0x44,
+    0x61, 0x76, 0x69, 0x65, 0x73, 0x00, 0x53, 0x68, 0x6f, 0x65, 0x6d, 0x61,
+    0x6b, 0x65, 0x72, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x00,
+    0x52, 0x75, 0x74, 0x68, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x4e,
+    0x65, 0x77, 0x73, 0x6f, 0x6d, 0x65, 0x00, 0x4d, 0x61, 0x67, 0x65, 0x65,
+    0x00, 0x43, 0x68, 0x61, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x61, 0x69, 0x6e,
+    0x00, 0x42, 0x6c, 0x61, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x69, 0x6d,
+    0x6d, 0x73, 0x00, 0x47, 0x6f, 0x64, 0x66, 0x72, 0x65, 0x79, 0x00, 0x46,
+    0x6c, 0x61, 0x6e, 0x61, 0x67, 0x61, 0x6e, 0x00, 0x43, 0x72, 0x75, 0x6d,
+    0x00, 0x43, 0x6f, 0x72, 0x64, 0x6f, 0x76, 0x61, 0x00, 0x45, 0x73, 0x63,
+    0x6f, 0x62, 0x61, 0x72, 0x00, 0x44, 0x6f, 0x77, 0x6e, 0x69, 0x6e, 0x67,
+    0x00, 0x53, 0x69, 0x6e, 0x63, 0x6c, 0x61, 0x69, 0x72, 0x00, 0x44, 0x6f,
+    0x6e, 0x61, 0x68, 0x75, 0x65, 0x00, 0x4b, 0x72, 0x75, 0x65, 0x67, 0x65,
+    0x72, 0x00, 0x4d, 0x63, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x73, 0x00, 0x47,
+    0x6f, 0x72, 0x65, 0x00, 0x46, 0x61, 0x72, 0x72, 0x69, 0x73, 0x00, 0x57,
+    0x65, 0x62, 0x62, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x72, 0x62, 0x65, 0x74,
+    0x74, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x61, 0x64, 0x65, 0x00, 0x53, 0x74,
+    0x61, 0x72, 0x72, 0x00, 0x4c, 0x79, 0x6f, 0x6e, 0x00, 0x59, 0x6f, 0x64,
+    0x65, 0x72, 0x00, 0x48, 0x61, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x00,
+    0x4d, 0x63, 0x67, 0x72, 0x61, 0x74, 0x68, 0x00, 0x53, 0x70, 0x69, 0x76,
+    0x65, 0x79, 0x00, 0x4b, 0x72, 0x61, 0x75, 0x73, 0x65, 0x00, 0x48, 0x61,
+    0x72, 0x64, 0x65, 0x6e, 0x00, 0x43, 0x72, 0x61, 0x62, 0x74, 0x72, 0x65,
+    0x65, 0x00, 0x4b, 0x69, 0x72, 0x6b, 0x70, 0x61, 0x74, 0x72, 0x69, 0x63,
+    0x6b, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x69, 0x73, 0x00, 0x42, 0x72, 0x61,
+    0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x41, 0x72, 0x72, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x45, 0x72, 0x76, 0x69, 0x6e, 0x00, 0x43, 0x6c, 0x69,
+    0x66, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x69, 0x74, 0x74, 0x65, 0x72, 0x00,
+    0x4d, 0x63, 0x67, 0x68, 0x65, 0x65, 0x00, 0x42, 0x6f, 0x6c, 0x64, 0x65,
+    0x6e, 0x00, 0x4d, 0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x79, 0x00, 0x47, 0x61,
+    0x67, 0x6e, 0x6f, 0x6e, 0x00, 0x44, 0x75, 0x6e, 0x62, 0x61, 0x72, 0x00,
+    0x50, 0x6f, 0x6e, 0x63, 0x65, 0x00, 0x50, 0x69, 0x6b, 0x65, 0x00, 0x4d,
+    0x61, 0x79, 0x65, 0x73, 0x00, 0x48, 0x65, 0x61, 0x72, 0x64, 0x00, 0x42,
+    0x65, 0x61, 0x74, 0x74, 0x79, 0x00, 0x4d, 0x6f, 0x62, 0x6c, 0x65, 0x79,
+    0x00, 0x4b, 0x69, 0x6d, 0x62, 0x61, 0x6c, 0x6c, 0x00, 0x42, 0x75, 0x74,
+    0x74, 0x73, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x73, 0x00, 0x48, 0x65,
+    0x72, 0x62, 0x65, 0x72, 0x74, 0x00, 0x47, 0x72, 0x61, 0x64, 0x79, 0x00,
+    0x45, 0x6c, 0x64, 0x72, 0x69, 0x64, 0x67, 0x65, 0x00, 0x42, 0x72, 0x61,
+    0x75, 0x6e, 0x00, 0x48, 0x61, 0x6d, 0x6d, 0x00, 0x47, 0x69, 0x62, 0x62,
+    0x6f, 0x6e, 0x73, 0x00, 0x53, 0x65, 0x79, 0x6d, 0x6f, 0x75, 0x72, 0x00,
+    0x4d, 0x6f, 0x79, 0x65, 0x72, 0x00, 0x4d, 0x61, 0x6e, 0x6c, 0x65, 0x79,
+    0x00, 0x48, 0x65, 0x72, 0x72, 0x6f, 0x6e, 0x00, 0x50, 0x6c, 0x75, 0x6d,
+    0x6d, 0x65, 0x72, 0x00, 0x45, 0x6c, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x43,
+    0x72, 0x61, 0x6d, 0x65, 0x72, 0x00, 0x47, 0x61, 0x72, 0x79, 0x00, 0x52,
+    0x75, 0x63, 0x6b, 0x65, 0x72, 0x00, 0x48, 0x69, 0x6c, 0x74, 0x6f, 0x6e,
+    0x00, 0x42, 0x6c, 0x75, 0x65, 0x00, 0x50, 0x69, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x00, 0x46, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x6f, 0x74, 0x00, 0x46,
+    0x69, 0x65, 0x6c, 0x64, 0x00, 0x52, 0x75, 0x62, 0x69, 0x6f, 0x00, 0x47,
+    0x72, 0x61, 0x63, 0x65, 0x00, 0x47, 0x6f, 0x6c, 0x64, 0x73, 0x74, 0x65,
+    0x69, 0x6e, 0x00, 0x45, 0x6c, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x57, 0x69,
+    0x6c, 0x6c, 0x73, 0x00, 0x4e, 0x6f, 0x76, 0x61, 0x6b, 0x00, 0x4a, 0x6f,
+    0x68, 0x6e, 0x00, 0x48, 0x69, 0x63, 0x6b, 0x65, 0x79, 0x00, 0x57, 0x6f,
+    0x72, 0x6c, 0x65, 0x79, 0x00, 0x47, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x00,
+    0x4b, 0x61, 0x74, 0x7a, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x73,
+    0x6f, 0x6e, 0x00, 0x42, 0x72, 0x6f, 0x75, 0x73, 0x73, 0x61, 0x72, 0x64,
+    0x00, 0x46, 0x72, 0x69, 0x74, 0x7a, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x72,
+    0x75, 0x66, 0x66, 0x00, 0x43, 0x72, 0x6f, 0x77, 0x00, 0x43, 0x68, 0x72,
+    0x69, 0x73, 0x74, 0x6f, 0x70, 0x68, 0x65, 0x72, 0x00, 0x42, 0x72, 0x69,
+    0x74, 0x74, 0x6f, 0x6e, 0x00, 0x46, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x74,
+    0x00, 0x4e, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x4c, 0x65, 0x68, 0x6d, 0x61,
+    0x6e, 0x00, 0x42, 0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x00, 0x5a, 0x75,
+    0x6e, 0x69, 0x67, 0x61, 0x00, 0x57, 0x68, 0x61, 0x6c, 0x65, 0x79, 0x00,
+    0x53, 0x68, 0x61, 0x66, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x66, 0x66, 0x6d,
+    0x61, 0x6e, 0x00, 0x53, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x00, 0x44,
+    0x65, 0x6c, 0x61, 0x72, 0x6f, 0x73, 0x61, 0x00, 0x4e, 0x69, 0x78, 0x00,
+    0x4e, 0x65, 0x65, 0x6c, 0x79, 0x00, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72,
+    0x73, 0x00, 0x4d, 0x61, 0x74, 0x61, 0x00, 0x4d, 0x61, 0x6e, 0x75, 0x65,
+    0x6c, 0x00, 0x44, 0x61, 0x76, 0x69, 0x6c, 0x61, 0x00, 0x4d, 0x63, 0x63,
+    0x61, 0x62, 0x65, 0x00, 0x4b, 0x65, 0x73, 0x73, 0x6c, 0x65, 0x72, 0x00,
+    0x45, 0x6d, 0x65, 0x72, 0x79, 0x00, 0x42, 0x6f, 0x77, 0x6c, 0x69, 0x6e,
+    0x67, 0x00, 0x48, 0x69, 0x6e, 0x6b, 0x6c, 0x65, 0x00, 0x57, 0x65, 0x6c,
+    0x73, 0x68, 0x00, 0x50, 0x61, 0x67, 0x61, 0x6e, 0x00, 0x47, 0x6f, 0x6c,
+    0x64, 0x62, 0x65, 0x72, 0x67, 0x00, 0x47, 0x6f, 0x69, 0x6e, 0x73, 0x00,
+    0x43, 0x72, 0x6f, 0x75, 0x63, 0x68, 0x00, 0x43, 0x75, 0x65, 0x76, 0x61,
+    0x73, 0x00, 0x51, 0x75, 0x69, 0x6e, 0x6f, 0x6e, 0x65, 0x73, 0x00, 0x4d,
+    0x63, 0x64, 0x65, 0x72, 0x6d, 0x6f, 0x74, 0x74, 0x00, 0x48, 0x65, 0x6e,
+    0x64, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x00, 0x53, 0x61, 0x6d,
+    0x75, 0x65, 0x6c, 0x73, 0x00, 0x44, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00,
+    0x42, 0x65, 0x72, 0x67, 0x65, 0x72, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x6d,
+    0x00, 0x49, 0x76, 0x65, 0x79, 0x00, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x00,
+    0x48, 0x61, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x54, 0x68, 0x75, 0x72, 0x6d,
+    0x61, 0x6e, 0x00, 0x53, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x48, 0x6f, 0x73,
+    0x6b, 0x69, 0x6e, 0x73, 0x00, 0x42, 0x79, 0x72, 0x6e, 0x65, 0x00, 0x4d,
+    0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6e, 0x73, 0x74, 0x6f,
+    0x6e, 0x00, 0x41, 0x72, 0x74, 0x68, 0x75, 0x72, 0x00, 0x41, 0x72, 0x69,
+    0x61, 0x73, 0x00, 0x53, 0x74, 0x61, 0x6e, 0x66, 0x6f, 0x72, 0x64, 0x00,
+    0x52, 0x6f, 0x65, 0x00, 0x43, 0x6f, 0x72, 0x62, 0x69, 0x6e, 0x00, 0x42,
+    0x65, 0x6c, 0x74, 0x72, 0x61, 0x6e, 0x00, 0x43, 0x68, 0x61, 0x70, 0x70,
+    0x65, 0x6c, 0x6c, 0x00, 0x48, 0x75, 0x72, 0x74, 0x00, 0x44, 0x6f, 0x77,
+    0x6e, 0x65, 0x79, 0x00, 0x44, 0x6f, 0x6f, 0x6c, 0x65, 0x79, 0x00, 0x54,
+    0x75, 0x74, 0x74, 0x6c, 0x65, 0x00, 0x43, 0x6f, 0x75, 0x63, 0x68, 0x00,
+    0x50, 0x61, 0x79, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x63, 0x65, 0x6c, 0x72,
+    0x6f, 0x79, 0x00, 0x43, 0x72, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x74, 0x00,
+    0x47, 0x72, 0x6f, 0x76, 0x65, 0x73, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x65,
+    0x6e, 0x74, 0x00, 0x4c, 0x65, 0x73, 0x6c, 0x69, 0x65, 0x00, 0x43, 0x61,
+    0x72, 0x74, 0x77, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x44, 0x69, 0x63,
+    0x6b, 0x65, 0x79, 0x00, 0x4d, 0x63, 0x67, 0x69, 0x6c, 0x6c, 0x00, 0x44,
+    0x75, 0x62, 0x6f, 0x69, 0x73, 0x00, 0x4d, 0x75, 0x6e, 0x69, 0x7a, 0x00,
+    0x45, 0x72, 0x77, 0x69, 0x6e, 0x00, 0x53, 0x65, 0x6c, 0x66, 0x00, 0x54,
+    0x6f, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x00, 0x44, 0x65, 0x6d, 0x70, 0x73,
+    0x65, 0x79, 0x00, 0x43, 0x69, 0x73, 0x6e, 0x65, 0x72, 0x6f, 0x73, 0x00,
+    0x53, 0x65, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x61, 0x74, 0x68, 0x61,
+    0x6d, 0x00, 0x47, 0x61, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x56, 0x69,
+    0x67, 0x69, 0x6c, 0x00, 0x54, 0x61, 0x70, 0x69, 0x61, 0x00, 0x53, 0x74,
+    0x65, 0x72, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x52, 0x61, 0x69, 0x6e, 0x65,
+    0x79, 0x00, 0x4e, 0x6f, 0x72, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4c, 0x61,
+    0x63, 0x79, 0x00, 0x53, 0x74, 0x72, 0x6f, 0x75, 0x64, 0x00, 0x4d, 0x65,
+    0x61, 0x64, 0x65, 0x00, 0x41, 0x6d, 0x6f, 0x73, 0x00, 0x54, 0x69, 0x70,
+    0x74, 0x6f, 0x6e, 0x00, 0x4c, 0x6f, 0x72, 0x64, 0x00, 0x4b, 0x75, 0x68,
+    0x6e, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x72, 0x64, 0x00, 0x42,
+    0x6f, 0x6e, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x54, 0x65, 0x61, 0x67, 0x75,
+    0x65, 0x00, 0x43, 0x6f, 0x75, 0x72, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x47,
+    0x75, 0x6e, 0x6e, 0x00, 0x48, 0x6f, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e,
+    0x77, 0x6f, 0x6f, 0x64, 0x00, 0x43, 0x6f, 0x72, 0x72, 0x65, 0x61, 0x00,
+    0x52, 0x65, 0x65, 0x63, 0x65, 0x00, 0x57, 0x65, 0x73, 0x74, 0x6f, 0x6e,
+    0x00, 0x50, 0x6f, 0x65, 0x00, 0x54, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x50,
+    0x69, 0x6e, 0x65, 0x64, 0x61, 0x00, 0x50, 0x68, 0x69, 0x70, 0x70, 0x73,
+    0x00, 0x46, 0x72, 0x65, 0x79, 0x00, 0x4b, 0x61, 0x69, 0x73, 0x65, 0x72,
+    0x00, 0x41, 0x6d, 0x65, 0x73, 0x00, 0x50, 0x61, 0x69, 0x67, 0x65, 0x00,
+    0x47, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x53, 0x63, 0x68, 0x6d, 0x69,
+    0x74, 0x74, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x67, 0x61, 0x6e, 0x00,
+    0x45, 0x73, 0x70, 0x69, 0x6e, 0x6f, 0x73, 0x61, 0x00, 0x43, 0x61, 0x72,
+    0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x6f, 0x77, 0x64, 0x65, 0x6e, 0x00,
+    0x56, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x00, 0x4c, 0x6f, 0x77, 0x72,
+    0x79, 0x00, 0x50, 0x72, 0x69, 0x74, 0x63, 0x68, 0x61, 0x72, 0x64, 0x00,
+    0x43, 0x6f, 0x73, 0x74, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x50, 0x69, 0x70,
+    0x65, 0x72, 0x00, 0x4d, 0x63, 0x63, 0x6c, 0x65, 0x6c, 0x6c, 0x61, 0x6e,
+    0x00, 0x4c, 0x6f, 0x76, 0x65, 0x6c, 0x6c, 0x00, 0x44, 0x72, 0x65, 0x77,
+    0x00, 0x53, 0x68, 0x65, 0x65, 0x68, 0x61, 0x6e, 0x00, 0x51, 0x75, 0x69,
+    0x63, 0x6b, 0x00, 0x48, 0x61, 0x74, 0x63, 0x68, 0x00, 0x44, 0x6f, 0x62,
+    0x73, 0x6f, 0x6e, 0x00, 0x53, 0x69, 0x6e, 0x67, 0x68, 0x00, 0x4a, 0x65,
+    0x66, 0x66, 0x72, 0x69, 0x65, 0x73, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x69,
+    0x6e, 0x67, 0x73, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x00, 0x53, 0x6f, 0x72,
+    0x65, 0x6e, 0x73, 0x65, 0x6e, 0x00, 0x4d, 0x65, 0x7a, 0x61, 0x00, 0x46,
+    0x69, 0x6e, 0x6b, 0x00, 0x44, 0x6f, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x79,
+    0x00, 0x42, 0x75, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x42, 0x72, 0x75,
+    0x6e, 0x6f, 0x00, 0x54, 0x6f, 0x6d, 0x6c, 0x69, 0x6e, 0x73, 0x6f, 0x6e,
+    0x00, 0x43, 0x6f, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x00, 0x42, 0x69, 0x6c,
+    0x6c, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x52, 0x69, 0x74, 0x63, 0x68, 0x69,
+    0x65, 0x00, 0x48, 0x65, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x75, 0x74,
+    0x68, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x50, 0x65, 0x6f, 0x70,
+    0x6c, 0x65, 0x73, 0x00, 0x4d, 0x63, 0x71, 0x75, 0x65, 0x65, 0x6e, 0x00,
+    0x47, 0x61, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x68, 0x6f, 0x6d, 0x61,
+    0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x63, 0x6b, 0x69, 0x6e, 0x6c, 0x65, 0x79,
+    0x00, 0x47, 0x69, 0x76, 0x65, 0x6e, 0x73, 0x00, 0x43, 0x72, 0x6f, 0x63,
+    0x6b, 0x65, 0x72, 0x00, 0x56, 0x6f, 0x67, 0x65, 0x6c, 0x00, 0x52, 0x6f,
+    0x62, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x44, 0x75, 0x6e, 0x68, 0x61, 0x6d,
+    0x00, 0x43, 0x6f, 0x6b, 0x65, 0x72, 0x00, 0x53, 0x77, 0x61, 0x72, 0x74,
+    0x7a, 0x00, 0x4b, 0x65, 0x79, 0x73, 0x00, 0x4c, 0x69, 0x6c, 0x6c, 0x79,
+    0x00, 0x4c, 0x61, 0x64, 0x6e, 0x65, 0x72, 0x00, 0x48, 0x61, 0x6e, 0x6e,
+    0x61, 0x68, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x00, 0x52,
+    0x69, 0x63, 0x68, 0x74, 0x65, 0x72, 0x00, 0x48, 0x61, 0x72, 0x67, 0x72,
+    0x6f, 0x76, 0x65, 0x00, 0x45, 0x64, 0x6d, 0x6f, 0x6e, 0x64, 0x73, 0x00,
+    0x42, 0x72, 0x61, 0x6e, 0x74, 0x6c, 0x65, 0x79, 0x00, 0x41, 0x6c, 0x62,
+    0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x4d, 0x75, 0x72, 0x64, 0x6f, 0x63,
+    0x6b, 0x00, 0x42, 0x6f, 0x73, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x75,
+    0x6c, 0x6c, 0x65, 0x72, 0x00, 0x51, 0x75, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x6f, 0x00, 0x50, 0x61, 0x64, 0x67, 0x65, 0x74, 0x74, 0x00, 0x4b, 0x65,
+    0x6e, 0x6e, 0x65, 0x79, 0x00, 0x44, 0x61, 0x6c, 0x79, 0x00, 0x43, 0x6f,
+    0x6e, 0x6e, 0x6f, 0x6c, 0x6c, 0x79, 0x00, 0x50, 0x69, 0x65, 0x72, 0x72,
+    0x65, 0x00, 0x49, 0x6e, 0x6d, 0x61, 0x6e, 0x00, 0x51, 0x75, 0x69, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x4c, 0x75, 0x6e, 0x64, 0x00, 0x42, 0x61,
+    0x72, 0x6e, 0x61, 0x72, 0x64, 0x00, 0x56, 0x69, 0x6c, 0x6c, 0x65, 0x67,
+    0x61, 0x73, 0x00, 0x53, 0x69, 0x6d, 0x6f, 0x6e, 0x73, 0x00, 0x4c, 0x61,
+    0x6e, 0x64, 0x00, 0x48, 0x75, 0x67, 0x67, 0x69, 0x6e, 0x73, 0x00, 0x54,
+    0x69, 0x64, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x75, 0x6c, 0x6c, 0x61, 0x72, 0x64,
+    0x00, 0x4d, 0x63, 0x63, 0x6c, 0x65, 0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x44,
+    0x75, 0x61, 0x72, 0x74, 0x65, 0x00, 0x44, 0x72, 0x61, 0x70, 0x65, 0x72,
+    0x00, 0x4d, 0x65, 0x72, 0x65, 0x64, 0x69, 0x74, 0x68, 0x00, 0x4d, 0x61,
+    0x72, 0x72, 0x65, 0x72, 0x6f, 0x00, 0x44, 0x77, 0x79, 0x65, 0x72, 0x00,
+    0x41, 0x62, 0x72, 0x61, 0x6d, 0x73, 0x00, 0x53, 0x74, 0x6f, 0x76, 0x65,
+    0x72, 0x00, 0x47, 0x6f, 0x6f, 0x64, 0x65, 0x00, 0x46, 0x72, 0x61, 0x73,
+    0x65, 0x72, 0x00, 0x43, 0x72, 0x65, 0x77, 0x73, 0x00, 0x42, 0x65, 0x72,
+    0x6e, 0x61, 0x6c, 0x00, 0x53, 0x6d, 0x69, 0x6c, 0x65, 0x79, 0x00, 0x47,
+    0x6f, 0x64, 0x77, 0x69, 0x6e, 0x00, 0x46, 0x69, 0x73, 0x68, 0x00, 0x43,
+    0x6f, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x00, 0x4d, 0x63, 0x6e, 0x65, 0x61,
+    0x6c, 0x00, 0x42, 0x61, 0x63, 0x61, 0x00, 0x45, 0x73, 0x70, 0x61, 0x72,
+    0x7a, 0x61, 0x00, 0x43, 0x72, 0x6f, 0x77, 0x64, 0x65, 0x72, 0x00, 0x42,
+    0x6f, 0x77, 0x65, 0x72, 0x00, 0x4e, 0x69, 0x63, 0x68, 0x6f, 0x6c, 0x61,
+    0x73, 0x00, 0x43, 0x68, 0x75, 0x6e, 0x67, 0x00, 0x42, 0x72, 0x65, 0x77,
+    0x73, 0x74, 0x65, 0x72, 0x00, 0x4d, 0x63, 0x6e, 0x65, 0x69, 0x6c, 0x6c,
+    0x00, 0x44, 0x69, 0x63, 0x6b, 0x00, 0x52, 0x6f, 0x64, 0x72, 0x69, 0x67,
+    0x75, 0x65, 0x73, 0x00, 0x4c, 0x65, 0x61, 0x6c, 0x00, 0x43, 0x6f, 0x61,
+    0x74, 0x65, 0x73, 0x00, 0x52, 0x61, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x4d,
+    0x63, 0x63, 0x61, 0x69, 0x6e, 0x00, 0x4d, 0x63, 0x63, 0x6f, 0x72, 0x64,
+    0x00, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x00, 0x48, 0x6f, 0x6c, 0x62, 0x72,
+    0x6f, 0x6f, 0x6b, 0x00, 0x53, 0x77, 0x69, 0x66, 0x74, 0x00, 0x44, 0x75,
+    0x6b, 0x65, 0x73, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x69, 0x73, 0x6c, 0x65,
+    0x00, 0x41, 0x6c, 0x64, 0x72, 0x69, 0x64, 0x67, 0x65, 0x00, 0x41, 0x63,
+    0x6b, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x74, 0x61, 0x72, 0x6b,
+    0x73, 0x00, 0x52, 0x69, 0x63, 0x6b, 0x73, 0x00, 0x48, 0x6f, 0x6c, 0x6c,
+    0x69, 0x64, 0x61, 0x79, 0x00, 0x46, 0x65, 0x72, 0x72, 0x69, 0x73, 0x00,
+    0x48, 0x61, 0x69, 0x72, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x65,
+    0x66, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x4c, 0x61, 0x6e, 0x67, 0x65,
+    0x00, 0x46, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x00, 0x4d, 0x61,
+    0x72, 0x69, 0x6e, 0x6f, 0x00, 0x44, 0x6f, 0x73, 0x73, 0x00, 0x42, 0x65,
+    0x74, 0x74, 0x73, 0x00, 0x4b, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x00, 0x43,
+    0x61, 0x72, 0x6d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c, 0x00, 0x42, 0x6c,
+    0x6f, 0x6f, 0x6d, 0x00, 0x52, 0x75, 0x66, 0x66, 0x69, 0x6e, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x00, 0x4b, 0x65, 0x72, 0x6e, 0x00, 0x42, 0x6f, 0x77,
+    0x6c, 0x65, 0x73, 0x00, 0x53, 0x69, 0x7a, 0x65, 0x6d, 0x6f, 0x72, 0x65,
+    0x00, 0x4c, 0x61, 0x72, 0x6b, 0x69, 0x6e, 0x00, 0x44, 0x75, 0x70, 0x72,
+    0x65, 0x65, 0x00, 0x4a, 0x65, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x53, 0x69,
+    0x6c, 0x76, 0x65, 0x72, 0x00, 0x53, 0x65, 0x61, 0x6c, 0x73, 0x00, 0x4d,
+    0x65, 0x74, 0x63, 0x61, 0x6c, 0x66, 0x00, 0x48, 0x75, 0x74, 0x63, 0x68,
+    0x69, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x65, 0x6e, 0x6c, 0x65, 0x79, 0x00,
+    0x46, 0x61, 0x72, 0x72, 0x00, 0x43, 0x61, 0x73, 0x74, 0x6c, 0x65, 0x00,
+    0x4d, 0x63, 0x63, 0x61, 0x75, 0x6c, 0x65, 0x79, 0x00, 0x48, 0x61, 0x6e,
+    0x6b, 0x69, 0x6e, 0x73, 0x00, 0x47, 0x75, 0x73, 0x74, 0x61, 0x66, 0x73,
+    0x6f, 0x6e, 0x00, 0x44, 0x65, 0x61, 0x6c, 0x00, 0x43, 0x75, 0x72, 0x72,
+    0x61, 0x6e, 0x00, 0x41, 0x73, 0x68, 0x00, 0x57, 0x61, 0x64, 0x64, 0x65,
+    0x6c, 0x6c, 0x00, 0x52, 0x61, 0x6d, 0x65, 0x79, 0x00, 0x43, 0x61, 0x74,
+    0x65, 0x73, 0x00, 0x50, 0x6f, 0x6c, 0x6c, 0x6f, 0x63, 0x6b, 0x00, 0x4d,
+    0x61, 0x6a, 0x6f, 0x72, 0x00, 0x49, 0x72, 0x76, 0x69, 0x6e, 0x00, 0x43,
+    0x75, 0x6d, 0x6d, 0x69, 0x6e, 0x73, 0x00, 0x4d, 0x65, 0x73, 0x73, 0x65,
+    0x72, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x44, 0x65, 0x77,
+    0x69, 0x74, 0x74, 0x00, 0x4c, 0x69, 0x6e, 0x00, 0x46, 0x75, 0x6e, 0x6b,
+    0x00, 0x43, 0x6f, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x00, 0x50, 0x61, 0x6c,
+    0x61, 0x63, 0x69, 0x6f, 0x73, 0x00, 0x47, 0x61, 0x6c, 0x69, 0x6e, 0x64,
+    0x6f, 0x00, 0x43, 0x61, 0x6e, 0x6f, 0x00, 0x48, 0x61, 0x74, 0x68, 0x61,
+    0x77, 0x61, 0x79, 0x00, 0x53, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x50,
+    0x68, 0x61, 0x6d, 0x00, 0x45, 0x6e, 0x72, 0x69, 0x71, 0x75, 0x65, 0x7a,
+    0x00, 0x41, 0x61, 0x72, 0x6f, 0x6e, 0x00, 0x53, 0x61, 0x6c, 0x67, 0x61,
+    0x64, 0x6f, 0x00, 0x50, 0x65, 0x6c, 0x6c, 0x65, 0x74, 0x69, 0x65, 0x72,
+    0x00, 0x50, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x57, 0x69, 0x73,
+    0x65, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x6c, 0x6f, 0x75, 0x6e, 0x74, 0x00,
+    0x48, 0x61, 0x6e, 0x64, 0x00, 0x46, 0x65, 0x6c, 0x69, 0x63, 0x69, 0x61,
+    0x6e, 0x6f, 0x00, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x65, 0x00, 0x48, 0x6f,
+    0x75, 0x73, 0x65, 0x72, 0x00, 0x44, 0x6f, 0x68, 0x65, 0x72, 0x74, 0x79,
+    0x00, 0x4d, 0x65, 0x61, 0x64, 0x00, 0x4d, 0x63, 0x67, 0x72, 0x61, 0x77,
+    0x00, 0x54, 0x6f, 0x6e, 0x65, 0x79, 0x00, 0x53, 0x77, 0x61, 0x6e, 0x00,
+    0x4d, 0x65, 0x6c, 0x76, 0x69, 0x6e, 0x00, 0x43, 0x61, 0x70, 0x70, 0x73,
+    0x00, 0x42, 0x6c, 0x61, 0x6e, 0x63, 0x6f, 0x00, 0x42, 0x6c, 0x61, 0x63,
+    0x6b, 0x6d, 0x6f, 0x6e, 0x00, 0x57, 0x65, 0x73, 0x6c, 0x65, 0x79, 0x00,
+    0x54, 0x68, 0x6f, 0x6d, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x63, 0x6d, 0x61,
+    0x6e, 0x75, 0x73, 0x00, 0x46, 0x61, 0x69, 0x72, 0x00, 0x42, 0x75, 0x72,
+    0x6b, 0x65, 0x74, 0x74, 0x00, 0x50, 0x6f, 0x73, 0x74, 0x00, 0x47, 0x6c,
+    0x65, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x52, 0x75, 0x64, 0x6f, 0x6c, 0x70,
+    0x68, 0x00, 0x4f, 0x74, 0x74, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x65, 0x6e,
+    0x73, 0x00, 0x43, 0x6f, 0x72, 0x6d, 0x69, 0x65, 0x72, 0x00, 0x56, 0x6f,
+    0x73, 0x73, 0x00, 0x52, 0x75, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x00, 0x52,
+    0x6f, 0x73, 0x65, 0x6e, 0x62, 0x65, 0x72, 0x67, 0x00, 0x48, 0x75, 0x72,
+    0x64, 0x00, 0x44, 0x75, 0x6d, 0x61, 0x73, 0x00, 0x42, 0x65, 0x6e, 0x69,
+    0x74, 0x65, 0x7a, 0x00, 0x41, 0x72, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x6f,
+    0x00, 0x53, 0x74, 0x6f, 0x72, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6e,
+    0x00, 0x43, 0x61, 0x75, 0x64, 0x69, 0x6c, 0x6c, 0x00, 0x42, 0x72, 0x61,
+    0x67, 0x67, 0x00, 0x4a, 0x61, 0x72, 0x61, 0x6d, 0x69, 0x6c, 0x6c, 0x6f,
+    0x00, 0x48, 0x75, 0x65, 0x72, 0x74, 0x61, 0x00, 0x47, 0x69, 0x70, 0x73,
+    0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x6c, 0x76, 0x69, 0x6e, 0x00, 0x42, 0x69,
+    0x67, 0x67, 0x73, 0x00, 0x56, 0x65, 0x6c, 0x61, 0x00, 0x50, 0x6c, 0x61,
+    0x74, 0x74, 0x00, 0x43, 0x61, 0x73, 0x73, 0x69, 0x64, 0x79, 0x00, 0x54,
+    0x6f, 0x6d, 0x70, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x4d, 0x63, 0x63, 0x6f,
+    0x6c, 0x6c, 0x75, 0x6d, 0x00, 0x4b, 0x61, 0x79, 0x00, 0x47, 0x61, 0x62,
+    0x72, 0x69, 0x65, 0x6c, 0x00, 0x44, 0x6f, 0x6c, 0x61, 0x6e, 0x00, 0x44,
+    0x61, 0x6c, 0x65, 0x79, 0x00, 0x43, 0x72, 0x75, 0x6d, 0x70, 0x00, 0x53,
+    0x74, 0x72, 0x65, 0x65, 0x74, 0x00, 0x53, 0x6e, 0x65, 0x65, 0x64, 0x00,
+    0x4b, 0x69, 0x6c, 0x67, 0x6f, 0x72, 0x65, 0x00, 0x47, 0x72, 0x6f, 0x76,
+    0x65, 0x00, 0x47, 0x72, 0x69, 0x6d, 0x6d, 0x00, 0x44, 0x61, 0x76, 0x69,
+    0x73, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x75, 0x6e, 0x73, 0x6f, 0x6e, 0x00,
+    0x50, 0x72, 0x61, 0x74, 0x65, 0x72, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x75,
+    0x6d, 0x00, 0x44, 0x65, 0x76, 0x69, 0x6e, 0x65, 0x00, 0x4b, 0x79, 0x6c,
+    0x65, 0x00, 0x44, 0x6f, 0x64, 0x67, 0x65, 0x00, 0x53, 0x74, 0x72, 0x61,
+    0x74, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x6f, 0x73, 0x61, 0x73, 0x00, 0x43,
+    0x68, 0x6f, 0x69, 0x00, 0x54, 0x72, 0x69, 0x70, 0x70, 0x00, 0x4c, 0x65,
+    0x64, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72, 0x00, 0x4c, 0x61, 0x79, 0x00,
+    0x48, 0x69, 0x67, 0x68, 0x74, 0x6f, 0x77, 0x65, 0x72, 0x00, 0x48, 0x61,
+    0x79, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x46, 0x65, 0x6c, 0x64, 0x6d, 0x61,
+    0x6e, 0x00, 0x45, 0x70, 0x70, 0x73, 0x00, 0x59, 0x65, 0x61, 0x67, 0x65,
+    0x72, 0x00, 0x50, 0x6f, 0x73, 0x65, 0x79, 0x00, 0x53, 0x79, 0x6c, 0x76,
+    0x65, 0x73, 0x74, 0x65, 0x72, 0x00, 0x53, 0x63, 0x72, 0x75, 0x67, 0x67,
+    0x73, 0x00, 0x43, 0x6f, 0x70, 0x65, 0x00, 0x53, 0x74, 0x75, 0x62, 0x62,
+    0x73, 0x00, 0x52, 0x69, 0x63, 0x68, 0x65, 0x79, 0x00, 0x4f, 0x76, 0x65,
+    0x72, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x72, 0x6f, 0x74, 0x74, 0x65, 0x72,
+    0x00, 0x53, 0x70, 0x72, 0x61, 0x67, 0x75, 0x65, 0x00, 0x43, 0x6f, 0x72,
+    0x64, 0x65, 0x72, 0x6f, 0x00, 0x42, 0x75, 0x74, 0x63, 0x68, 0x65, 0x72,
+    0x00, 0x42, 0x75, 0x72, 0x67, 0x65, 0x72, 0x00, 0x53, 0x74, 0x69, 0x6c,
+    0x65, 0x73, 0x00, 0x42, 0x75, 0x72, 0x67, 0x6f, 0x73, 0x00, 0x57, 0x6f,
+    0x6f, 0x64, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x6f, 0x72, 0x6e, 0x65, 0x72,
+    0x00, 0x42, 0x61, 0x73, 0x73, 0x65, 0x74, 0x74, 0x00, 0x50, 0x75, 0x72,
+    0x63, 0x65, 0x6c, 0x6c, 0x00, 0x48, 0x61, 0x73, 0x6b, 0x69, 0x6e, 0x73,
+    0x00, 0x47, 0x65, 0x65, 0x00, 0x41, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x41,
+    0x62, 0x72, 0x61, 0x68, 0x61, 0x6d, 0x00, 0x48, 0x6f, 0x79, 0x74, 0x00,
+    0x5a, 0x69, 0x65, 0x67, 0x6c, 0x65, 0x72, 0x00, 0x53, 0x70, 0x61, 0x75,
+    0x6c, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x48, 0x61, 0x64, 0x6c, 0x65, 0x79,
+    0x00, 0x47, 0x72, 0x75, 0x62, 0x62, 0x73, 0x00, 0x53, 0x75, 0x6d, 0x6e,
+    0x65, 0x72, 0x00, 0x4d, 0x75, 0x72, 0x69, 0x6c, 0x6c, 0x6f, 0x00, 0x5a,
+    0x61, 0x76, 0x61, 0x6c, 0x61, 0x00, 0x53, 0x68, 0x6f, 0x6f, 0x6b, 0x00,
+    0x4c, 0x6f, 0x63, 0x6b, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4a, 0x61, 0x72,
+    0x72, 0x65, 0x74, 0x74, 0x00, 0x44, 0x72, 0x69, 0x73, 0x63, 0x6f, 0x6c,
+    0x6c, 0x00, 0x44, 0x61, 0x68, 0x6c, 0x00, 0x54, 0x68, 0x6f, 0x72, 0x70,
+    0x65, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x64, 0x61, 0x6e, 0x00, 0x52,
+    0x65, 0x64, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x50, 0x75, 0x74, 0x6e, 0x61,
+    0x6d, 0x00, 0x4d, 0x63, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73,
+    0x00, 0x4d, 0x63, 0x72, 0x61, 0x65, 0x00, 0x43, 0x6f, 0x72, 0x6e, 0x65,
+    0x6c, 0x6c, 0x00, 0x46, 0x65, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x6f,
+    0x6d, 0x61, 0x6e, 0x6f, 0x00, 0x4a, 0x6f, 0x69, 0x6e, 0x65, 0x72, 0x00,
+    0x53, 0x61, 0x64, 0x6c, 0x65, 0x72, 0x00, 0x48, 0x65, 0x64, 0x72, 0x69,
+    0x63, 0x6b, 0x00, 0x48, 0x61, 0x67, 0x65, 0x72, 0x00, 0x48, 0x61, 0x67,
+    0x65, 0x6e, 0x00, 0x46, 0x69, 0x74, 0x63, 0x68, 0x00, 0x43, 0x6f, 0x75,
+    0x6c, 0x74, 0x65, 0x72, 0x00, 0x54, 0x68, 0x61, 0x63, 0x6b, 0x65, 0x72,
+    0x00, 0x4d, 0x61, 0x6e, 0x73, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x4c,
+    0x61, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x47, 0x75, 0x69, 0x64,
+    0x72, 0x79, 0x00, 0x46, 0x65, 0x72, 0x72, 0x65, 0x69, 0x72, 0x61, 0x00,
+    0x43, 0x6f, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x00,
+    0x52, 0x6f, 0x73, 0x73, 0x69, 0x00, 0x4c, 0x61, 0x63, 0x6b, 0x65, 0x79,
+    0x00, 0x43, 0x6f, 0x64, 0x79, 0x00, 0x42, 0x61, 0x65, 0x7a, 0x00, 0x53,
+    0x61, 0x65, 0x6e, 0x7a, 0x00, 0x4d, 0x63, 0x6e, 0x61, 0x6d, 0x61, 0x72,
+    0x61, 0x00, 0x44, 0x61, 0x72, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x65, 0x6c, 0x00, 0x4d, 0x63, 0x6d, 0x75, 0x6c, 0x6c, 0x65,
+    0x6e, 0x00, 0x4d, 0x63, 0x6b, 0x65, 0x6e, 0x6e, 0x61, 0x00, 0x4d, 0x63,
+    0x64, 0x6f, 0x6e, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x4c, 0x69, 0x6e, 0x6b,
+    0x00, 0x45, 0x6e, 0x67, 0x65, 0x6c, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e,
+    0x65, 0x00, 0x52, 0x6f, 0x70, 0x65, 0x72, 0x00, 0x50, 0x65, 0x61, 0x63,
+    0x6f, 0x63, 0x6b, 0x00, 0x45, 0x75, 0x62, 0x61, 0x6e, 0x6b, 0x73, 0x00,
+    0x44, 0x72, 0x75, 0x6d, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x53, 0x74, 0x72,
+    0x69, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x50, 0x72, 0x69, 0x74, 0x63, 0x68,
+    0x65, 0x74, 0x74, 0x00, 0x50, 0x61, 0x72, 0x68, 0x61, 0x6d, 0x00, 0x4d,
+    0x69, 0x6d, 0x73, 0x00, 0x4c, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x00,
+    0x48, 0x61, 0x6d, 0x00, 0x47, 0x72, 0x61, 0x79, 0x73, 0x6f, 0x6e, 0x00,
+    0x53, 0x74, 0x61, 0x63, 0x79, 0x00, 0x53, 0x63, 0x68, 0x61, 0x66, 0x65,
+    0x72, 0x00, 0x45, 0x67, 0x61, 0x6e, 0x00, 0x54, 0x69, 0x6d, 0x6d, 0x6f,
+    0x6e, 0x73, 0x00, 0x4f, 0x68, 0x61, 0x72, 0x61, 0x00, 0x4b, 0x65, 0x65,
+    0x6e, 0x00, 0x48, 0x61, 0x6d, 0x6c, 0x69, 0x6e, 0x00, 0x46, 0x69, 0x6e,
+    0x6e, 0x00, 0x43, 0x6f, 0x72, 0x74, 0x65, 0x73, 0x00, 0x4d, 0x63, 0x6e,
+    0x61, 0x69, 0x72, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x00, 0x43, 0x6c,
+    0x69, 0x66, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x4e, 0x61, 0x64, 0x65, 0x61,
+    0x75, 0x00, 0x4d, 0x6f, 0x73, 0x65, 0x6c, 0x65, 0x79, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x61, 0x75, 0x64, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x6e, 0x00,
+    0x4f, 0x61, 0x6b, 0x65, 0x73, 0x00, 0x4b, 0x75, 0x72, 0x74, 0x7a, 0x00,
+    0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x00, 0x43, 0x61, 0x6c, 0x6c,
+    0x6f, 0x77, 0x61, 0x79, 0x00, 0x42, 0x65, 0x61, 0x6c, 0x00, 0x42, 0x61,
+    0x75, 0x74, 0x69, 0x73, 0x74, 0x61, 0x00, 0x57, 0x69, 0x6e, 0x6e, 0x00,
+    0x53, 0x75, 0x67, 0x67, 0x73, 0x00, 0x53, 0x74, 0x65, 0x72, 0x6e, 0x00,
+    0x53, 0x74, 0x61, 0x70, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x4c, 0x79,
+    0x6c, 0x65, 0x73, 0x00, 0x4c, 0x61, 0x69, 0x72, 0x64, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x61, 0x6e, 0x6f, 0x00, 0x44, 0x69, 0x61, 0x6d, 0x6f, 0x6e,
+    0x64, 0x00, 0x44, 0x61, 0x77, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x52, 0x6f,
+    0x6c, 0x61, 0x6e, 0x64, 0x00, 0x48, 0x61, 0x67, 0x61, 0x6e, 0x00, 0x47,
+    0x6f, 0x6c, 0x64, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x72, 0x79, 0x73, 0x6f,
+    0x6e, 0x00, 0x42, 0x61, 0x72, 0x61, 0x6a, 0x61, 0x73, 0x00, 0x4c, 0x6f,
+    0x76, 0x65, 0x74, 0x74, 0x00, 0x53, 0x65, 0x67, 0x75, 0x72, 0x61, 0x00,
+    0x4d, 0x65, 0x74, 0x7a, 0x00, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x74,
+    0x00, 0x4c, 0x61, 0x6e, 0x67, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x48, 0x69,
+    0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x45, 0x61, 0x73, 0x74, 0x6d, 0x61, 0x6e,
+    0x00, 0x52, 0x6f, 0x63, 0x6b, 0x00, 0x48, 0x6f, 0x6f, 0x6b, 0x73, 0x00,
+    0x57, 0x6f, 0x6f, 0x64, 0x79, 0x00, 0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x53, 0x68, 0x61, 0x70, 0x69, 0x72, 0x6f, 0x00,
+    0x43, 0x72, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x57, 0x68, 0x61, 0x6c,
+    0x65, 0x6e, 0x00, 0x54, 0x72, 0x69, 0x70, 0x6c, 0x65, 0x74, 0x74, 0x00,
+    0x48, 0x6f, 0x6f, 0x6b, 0x65, 0x72, 0x00, 0x43, 0x68, 0x61, 0x74, 0x6d,
+    0x61, 0x6e, 0x00, 0x41, 0x6c, 0x64, 0x72, 0x69, 0x63, 0x68, 0x00, 0x43,
+    0x61, 0x68, 0x69, 0x6c, 0x6c, 0x00, 0x59, 0x6f, 0x75, 0x6e, 0x67, 0x62,
+    0x6c, 0x6f, 0x6f, 0x64, 0x00, 0x59, 0x62, 0x61, 0x72, 0x72, 0x61, 0x00,
+    0x53, 0x74, 0x61, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x53, 0x68,
+    0x65, 0x65, 0x74, 0x73, 0x00, 0x53, 0x61, 0x6d, 0x75, 0x65, 0x6c, 0x00,
+    0x52, 0x65, 0x65, 0x64, 0x65, 0x72, 0x00, 0x50, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x00, 0x50, 0x61, 0x63, 0x6b, 0x00, 0x4c, 0x61, 0x63, 0x65, 0x79,
+    0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x79, 0x00, 0x42, 0x61,
+    0x74, 0x65, 0x6d, 0x61, 0x6e, 0x00, 0x41, 0x62, 0x65, 0x72, 0x6e, 0x61,
+    0x74, 0x68, 0x79, 0x00, 0x57, 0x69, 0x6e, 0x6b, 0x6c, 0x65, 0x72, 0x00,
+    0x57, 0x69, 0x6c, 0x6b, 0x65, 0x73, 0x00, 0x4d, 0x61, 0x73, 0x74, 0x65,
+    0x72, 0x73, 0x00, 0x48, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x74, 0x00, 0x47,
+    0x72, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x47, 0x69, 0x6c, 0x6c, 0x69,
+    0x73, 0x00, 0x53, 0x63, 0x68, 0x6d, 0x69, 0x74, 0x7a, 0x00, 0x53, 0x61,
+    0x70, 0x70, 0x00, 0x4e, 0x61, 0x70, 0x69, 0x65, 0x72, 0x00, 0x53, 0x6f,
+    0x75, 0x7a, 0x61, 0x00, 0x4c, 0x61, 0x6e, 0x69, 0x65, 0x72, 0x00, 0x47,
+    0x6f, 0x6d, 0x65, 0x73, 0x00, 0x57, 0x65, 0x69, 0x72, 0x00, 0x4f, 0x74,
+    0x65, 0x72, 0x6f, 0x00, 0x4c, 0x65, 0x64, 0x66, 0x6f, 0x72, 0x64, 0x00,
+    0x42, 0x75, 0x72, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x73, 0x00, 0x42, 0x61,
+    0x62, 0x63, 0x6f, 0x63, 0x6b, 0x00, 0x56, 0x65, 0x6e, 0x74, 0x75, 0x72,
+    0x61, 0x00, 0x53, 0x69, 0x65, 0x67, 0x65, 0x6c, 0x00, 0x44, 0x75, 0x67,
+    0x61, 0x6e, 0x00, 0x43, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x43,
+    0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x65, 0x00, 0x42, 0x6c, 0x65, 0x64,
+    0x73, 0x6f, 0x65, 0x00, 0x41, 0x74, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x57,
+    0x72, 0x61, 0x79, 0x00, 0x56, 0x61, 0x72, 0x6e, 0x65, 0x72, 0x00, 0x53,
+    0x70, 0x61, 0x6e, 0x67, 0x6c, 0x65, 0x72, 0x00, 0x4f, 0x74, 0x74, 0x6f,
+    0x00, 0x41, 0x6e, 0x61, 0x79, 0x61, 0x00, 0x53, 0x74, 0x61, 0x6c, 0x65,
+    0x79, 0x00, 0x4b, 0x72, 0x61, 0x66, 0x74, 0x00, 0x46, 0x6f, 0x75, 0x72,
+    0x6e, 0x69, 0x65, 0x72, 0x00, 0x45, 0x64, 0x64, 0x79, 0x00, 0x42, 0x65,
+    0x6c, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x57, 0x6f, 0x6c, 0x66, 0x66,
+    0x00, 0x54, 0x68, 0x6f, 0x72, 0x6e, 0x65, 0x00, 0x42, 0x79, 0x6e, 0x75,
+    0x6d, 0x00, 0x42, 0x75, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x42,
+    0x6f, 0x79, 0x6b, 0x69, 0x6e, 0x00, 0x53, 0x77, 0x65, 0x6e, 0x73, 0x6f,
+    0x6e, 0x00, 0x50, 0x75, 0x72, 0x76, 0x69, 0x73, 0x00, 0x50, 0x69, 0x6e,
+    0x61, 0x00, 0x4b, 0x68, 0x61, 0x6e, 0x00, 0x44, 0x75, 0x76, 0x61, 0x6c,
+    0x6c, 0x00, 0x44, 0x61, 0x72, 0x62, 0x79, 0x00, 0x58, 0x69, 0x6f, 0x6e,
+    0x67, 0x00, 0x4b, 0x61, 0x75, 0x66, 0x66, 0x6d, 0x61, 0x6e, 0x00, 0x41,
+    0x6c, 0x69, 0x00, 0x59, 0x75, 0x00, 0x48, 0x65, 0x61, 0x6c, 0x79, 0x00,
+    0x45, 0x6e, 0x67, 0x6c, 0x65, 0x00, 0x43, 0x6f, 0x72, 0x6f, 0x6e, 0x61,
+    0x00, 0x42, 0x65, 0x6e, 0x6f, 0x69, 0x74, 0x00, 0x56, 0x61, 0x6c, 0x6c,
+    0x65, 0x00, 0x53, 0x74, 0x65, 0x69, 0x6e, 0x65, 0x72, 0x00, 0x53, 0x70,
+    0x69, 0x63, 0x65, 0x72, 0x00, 0x53, 0x68, 0x61, 0x76, 0x65, 0x72, 0x00,
+    0x52, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x00, 0x4c, 0x75, 0x6e, 0x64, 0x79,
+    0x00, 0x44, 0x6f, 0x77, 0x00, 0x43, 0x68, 0x69, 0x6e, 0x00, 0x43, 0x61,
+    0x6c, 0x76, 0x65, 0x72, 0x74, 0x00, 0x53, 0x74, 0x61, 0x74, 0x6f, 0x6e,
+    0x00, 0x4e, 0x65, 0x66, 0x66, 0x00, 0x4b, 0x65, 0x61, 0x72, 0x6e, 0x65,
+    0x79, 0x00, 0x44, 0x61, 0x72, 0x64, 0x65, 0x6e, 0x00, 0x4f, 0x61, 0x6b,
+    0x6c, 0x65, 0x79, 0x00, 0x4d, 0x65, 0x64, 0x65, 0x69, 0x72, 0x6f, 0x73,
+    0x00, 0x4d, 0x63, 0x63, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x00, 0x43,
+    0x72, 0x65, 0x6e, 0x73, 0x68, 0x61, 0x77, 0x00, 0x42, 0x6c, 0x6f, 0x63,
+    0x6b, 0x00, 0x42, 0x65, 0x61, 0x76, 0x65, 0x72, 0x00, 0x50, 0x65, 0x72,
+    0x64, 0x75, 0x65, 0x00, 0x44, 0x69, 0x6c, 0x6c, 0x00, 0x57, 0x68, 0x69,
+    0x74, 0x74, 0x61, 0x6b, 0x65, 0x72, 0x00, 0x54, 0x6f, 0x62, 0x69, 0x6e,
+    0x00, 0x43, 0x6f, 0x72, 0x6e, 0x65, 0x6c, 0x69, 0x75, 0x73, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x62, 0x75, 0x72, 0x6e, 0x00, 0x48, 0x6f, 0x67, 0x75,
+    0x65, 0x00, 0x47, 0x6f, 0x6f, 0x64, 0x72, 0x69, 0x63, 0x68, 0x00, 0x45,
+    0x61, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x72, 0x61, 0x76, 0x6f, 0x00,
+    0x44, 0x65, 0x6e, 0x6e, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x56, 0x65, 0x72,
+    0x61, 0x00, 0x53, 0x68, 0x69, 0x70, 0x6c, 0x65, 0x79, 0x00, 0x4b, 0x65,
+    0x72, 0x6e, 0x73, 0x00, 0x4a, 0x6f, 0x72, 0x67, 0x65, 0x6e, 0x73, 0x65,
+    0x6e, 0x00, 0x43, 0x72, 0x61, 0x69, 0x6e, 0x00, 0x41, 0x62, 0x65, 0x6c,
+    0x00, 0x56, 0x69, 0x6c, 0x6c, 0x61, 0x6c, 0x6f, 0x62, 0x6f, 0x73, 0x00,
+    0x4d, 0x61, 0x75, 0x72, 0x65, 0x72, 0x00, 0x4c, 0x6f, 0x6e, 0x67, 0x6f,
+    0x72, 0x69, 0x61, 0x00, 0x4b, 0x65, 0x65, 0x6e, 0x65, 0x00, 0x43, 0x6f,
+    0x6f, 0x6e, 0x00, 0x53, 0x69, 0x65, 0x72, 0x72, 0x61, 0x00, 0x57, 0x69,
+    0x74, 0x68, 0x65, 0x72, 0x73, 0x70, 0x6f, 0x6f, 0x6e, 0x00, 0x53, 0x74,
+    0x61, 0x70, 0x6c, 0x65, 0x73, 0x00, 0x50, 0x65, 0x74, 0x74, 0x69, 0x74,
+    0x00, 0x4b, 0x69, 0x6e, 0x63, 0x61, 0x69, 0x64, 0x00, 0x45, 0x61, 0x73,
+    0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x64, 0x72, 0x69, 0x64, 0x00, 0x45, 0x63,
+    0x68, 0x6f, 0x6c, 0x73, 0x00, 0x4c, 0x75, 0x73, 0x6b, 0x00, 0x57, 0x75,
+    0x00, 0x53, 0x74, 0x61, 0x68, 0x6c, 0x00, 0x43, 0x75, 0x72, 0x72, 0x69,
+    0x65, 0x00, 0x54, 0x68, 0x61, 0x79, 0x65, 0x72, 0x00, 0x53, 0x68, 0x75,
+    0x6c, 0x74, 0x7a, 0x00, 0x53, 0x68, 0x65, 0x72, 0x77, 0x6f, 0x6f, 0x64,
+    0x00, 0x4d, 0x63, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x53, 0x65, 0x61,
+    0x79, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x00, 0x4d, 0x61, 0x68, 0x65,
+    0x72, 0x00, 0x4b, 0x65, 0x6e, 0x6e, 0x79, 0x00, 0x48, 0x6f, 0x70, 0x65,
+    0x00, 0x47, 0x61, 0x67, 0x6e, 0x65, 0x00, 0x42, 0x61, 0x72, 0x72, 0x6f,
+    0x77, 0x00, 0x4e, 0x61, 0x76, 0x61, 0x00, 0x4d, 0x79, 0x6c, 0x65, 0x73,
+    0x00, 0x4d, 0x6f, 0x72, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x48, 0x6f,
+    0x6e, 0x65, 0x79, 0x63, 0x75, 0x74, 0x74, 0x00, 0x48, 0x65, 0x61, 0x72,
+    0x6e, 0x00, 0x44, 0x69, 0x67, 0x67, 0x73, 0x00, 0x43, 0x61, 0x72, 0x6f,
+    0x6e, 0x00, 0x57, 0x68, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x00, 0x57, 0x65,
+    0x73, 0x74, 0x62, 0x72, 0x6f, 0x6f, 0x6b, 0x00, 0x53, 0x74, 0x6f, 0x76,
+    0x61, 0x6c, 0x6c, 0x00, 0x52, 0x61, 0x67, 0x6c, 0x61, 0x6e, 0x64, 0x00,
+    0x51, 0x75, 0x65, 0x65, 0x6e, 0x00, 0x4d, 0x75, 0x6e, 0x73, 0x6f, 0x6e,
+    0x00, 0x4d, 0x65, 0x69, 0x65, 0x72, 0x00, 0x4c, 0x6f, 0x6f, 0x6e, 0x65,
+    0x79, 0x00, 0x4b, 0x69, 0x6d, 0x62, 0x6c, 0x65, 0x00, 0x4a, 0x6f, 0x6c,
+    0x6c, 0x79, 0x00, 0x48, 0x6f, 0x62, 0x73, 0x6f, 0x6e, 0x00, 0x4c, 0x6f,
+    0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x47, 0x6f, 0x64, 0x64, 0x61, 0x72, 0x64,
+    0x00, 0x43, 0x75, 0x6c, 0x76, 0x65, 0x72, 0x00, 0x42, 0x75, 0x72, 0x72,
+    0x00, 0x50, 0x72, 0x65, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x4e, 0x65, 0x67,
+    0x72, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00,
+    0x54, 0x6f, 0x76, 0x61, 0x72, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x75, 0x73,
+    0x00, 0x48, 0x75, 0x64, 0x64, 0x6c, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x00,
+    0x48, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x41, 0x73, 0x68, 0x62, 0x79,
+    0x00, 0x53, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x00, 0x52, 0x6f, 0x6f, 0x74,
+    0x00, 0x50, 0x65, 0x6e, 0x64, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x4f,
+    0x6c, 0x65, 0x61, 0x72, 0x79, 0x00, 0x4e, 0x69, 0x63, 0x6b, 0x65, 0x72,
+    0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x79, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x4a,
+    0x75, 0x64, 0x64, 0x00, 0x4a, 0x61, 0x63, 0x6f, 0x62, 0x73, 0x65, 0x6e,
+    0x00, 0x45, 0x6c, 0x6c, 0x69, 0x6f, 0x74, 0x00, 0x42, 0x61, 0x69, 0x6e,
+    0x00, 0x41, 0x64, 0x61, 0x69, 0x72, 0x00, 0x53, 0x74, 0x61, 0x72, 0x6e,
+    0x65, 0x73, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x64, 0x6f, 0x6e, 0x00, 0x4d,
+    0x61, 0x74, 0x6f, 0x73, 0x00, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x00, 0x42,
+    0x75, 0x73, 0x62, 0x79, 0x00, 0x48, 0x65, 0x72, 0x6e, 0x64, 0x6f, 0x6e,
+    0x00, 0x48, 0x61, 0x6e, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x65, 0x6c, 0x6c,
+    0x61, 0x6d, 0x79, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x00, 0x44, 0x6f, 0x74,
+    0x79, 0x00, 0x42, 0x61, 0x72, 0x74, 0x6c, 0x65, 0x79, 0x00, 0x59, 0x61,
+    0x7a, 0x7a, 0x69, 0x65, 0x00, 0x52, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00,
+    0x50, 0x61, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x47, 0x69, 0x66, 0x66, 0x6f,
+    0x72, 0x64, 0x00, 0x43, 0x75, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x43, 0x68,
+    0x72, 0x69, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x73, 0x65, 0x6e, 0x00, 0x42,
+    0x65, 0x6e, 0x61, 0x76, 0x69, 0x64, 0x65, 0x73, 0x00, 0x42, 0x61, 0x72,
+    0x6e, 0x68, 0x61, 0x72, 0x74, 0x00, 0x54, 0x61, 0x6c, 0x62, 0x6f, 0x74,
+    0x00, 0x4d, 0x6f, 0x63, 0x6b, 0x00, 0x43, 0x72, 0x61, 0x6e, 0x64, 0x61,
+    0x6c, 0x6c, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x6f, 0x72, 0x73, 0x00, 0x42,
+    0x6f, 0x6e, 0x64, 0x73, 0x00, 0x57, 0x68, 0x69, 0x74, 0x74, 0x00, 0x47,
+    0x61, 0x67, 0x65, 0x00, 0x42, 0x65, 0x72, 0x67, 0x6d, 0x61, 0x6e, 0x00,
+    0x41, 0x72, 0x72, 0x65, 0x64, 0x6f, 0x6e, 0x64, 0x6f, 0x00, 0x41, 0x64,
+    0x64, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e,
+    0x00, 0x4c, 0x75, 0x6a, 0x61, 0x6e, 0x00, 0x44, 0x6f, 0x77, 0x64, 0x79,
+    0x00, 0x4a, 0x65, 0x72, 0x6e, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x48, 0x75,
+    0x79, 0x6e, 0x68, 0x00, 0x42, 0x6f, 0x75, 0x63, 0x68, 0x61, 0x72, 0x64,
+    0x00, 0x44, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x68, 0x6f, 0x61,
+    0x64, 0x65, 0x73, 0x00, 0x4f, 0x75, 0x65, 0x6c, 0x6c, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x4b, 0x69, 0x73, 0x65, 0x72, 0x00, 0x52, 0x75, 0x62, 0x69,
+    0x6e, 0x00, 0x48, 0x65, 0x72, 0x72, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x48, 0x61, 0x72, 0x65, 0x00, 0x44, 0x65, 0x6e, 0x6e, 0x79, 0x00,
+    0x42, 0x6c, 0x61, 0x63, 0x6b, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x61, 0x62,
+    0x62, 0x00, 0x41, 0x6c, 0x6c, 0x72, 0x65, 0x64, 0x00, 0x52, 0x75, 0x64,
+    0x64, 0x00, 0x50, 0x61, 0x75, 0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x4f, 0x67,
+    0x64, 0x65, 0x6e, 0x00, 0x4b, 0x6f, 0x65, 0x6e, 0x69, 0x67, 0x00, 0x4a,
+    0x61, 0x63, 0x6f, 0x62, 0x00, 0x49, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x00,
+    0x47, 0x65, 0x69, 0x67, 0x65, 0x72, 0x00, 0x42, 0x65, 0x67, 0x61, 0x79,
+    0x00, 0x50, 0x61, 0x72, 0x72, 0x61, 0x00, 0x43, 0x68, 0x61, 0x6d, 0x70,
+    0x69, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x73, 0x73, 0x69, 0x74, 0x65, 0x72,
+    0x00, 0x48, 0x61, 0x77, 0x6b, 0x00, 0x45, 0x73, 0x70, 0x6f, 0x73, 0x69,
+    0x74, 0x6f, 0x00, 0x43, 0x68, 0x6f, 0x00, 0x57, 0x61, 0x6c, 0x64, 0x72,
+    0x6f, 0x6e, 0x00, 0x56, 0x65, 0x72, 0x6e, 0x6f, 0x6e, 0x00, 0x52, 0x61,
+    0x6e, 0x73, 0x6f, 0x6d, 0x00, 0x50, 0x72, 0x61, 0x74, 0x68, 0x65, 0x72,
+    0x00, 0x4b, 0x65, 0x65, 0x6e, 0x61, 0x6e, 0x00, 0x4a, 0x65, 0x61, 0x6e,
+    0x00, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x43, 0x68, 0x61, 0x63,
+    0x6f, 0x6e, 0x00, 0x56, 0x69, 0x63, 0x6b, 0x00, 0x53, 0x61, 0x6e, 0x64,
+    0x73, 0x00, 0x52, 0x6f, 0x61, 0x72, 0x6b, 0x00, 0x50, 0x61, 0x72, 0x72,
+    0x00, 0x4d, 0x61, 0x79, 0x62, 0x65, 0x72, 0x72, 0x79, 0x00, 0x47, 0x72,
+    0x65, 0x65, 0x6e, 0x62, 0x65, 0x72, 0x67, 0x00, 0x43, 0x6f, 0x6c, 0x65,
+    0x79, 0x00, 0x42, 0x72, 0x75, 0x6e, 0x65, 0x72, 0x00, 0x57, 0x68, 0x69,
+    0x74, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x6b, 0x61, 0x67, 0x67, 0x73, 0x00,
+    0x53, 0x68, 0x69, 0x70, 0x6d, 0x61, 0x6e, 0x00, 0x4d, 0x65, 0x61, 0x6e,
+    0x73, 0x00, 0x4c, 0x65, 0x61, 0x72, 0x79, 0x00, 0x48, 0x75, 0x74, 0x74,
+    0x6f, 0x6e, 0x00, 0x52, 0x6f, 0x6d, 0x6f, 0x00, 0x4d, 0x65, 0x64, 0x72,
+    0x61, 0x6e, 0x6f, 0x00, 0x4c, 0x61, 0x64, 0x64, 0x00, 0x4b, 0x72, 0x75,
+    0x73, 0x65, 0x00, 0x46, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x00, 0x44, 0x61,
+    0x72, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x41, 0x73, 0x6b, 0x65, 0x77, 0x00,
+    0x56, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x00, 0x53, 0x63, 0x68,
+    0x75, 0x6c, 0x7a, 0x00, 0x41, 0x6c, 0x66, 0x61, 0x72, 0x6f, 0x00, 0x54,
+    0x61, 0x62, 0x6f, 0x72, 0x00, 0x4d, 0x6f, 0x68, 0x72, 0x00, 0x47, 0x61,
+    0x6c, 0x6c, 0x6f, 0x00, 0x42, 0x65, 0x72, 0x6d, 0x75, 0x64, 0x65, 0x7a,
+    0x00, 0x50, 0x65, 0x72, 0x65, 0x69, 0x72, 0x61, 0x00, 0x49, 0x73, 0x61,
+    0x61, 0x63, 0x00, 0x42, 0x6c, 0x69, 0x73, 0x73, 0x00, 0x52, 0x65, 0x61,
+    0x76, 0x65, 0x73, 0x00, 0x46, 0x6c, 0x69, 0x6e, 0x74, 0x00, 0x43, 0x6f,
+    0x6d, 0x65, 0x72, 0x00, 0x42, 0x6f, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x57,
+    0x6f, 0x6f, 0x64, 0x61, 0x6c, 0x6c, 0x00, 0x4e, 0x61, 0x71, 0x75, 0x69,
+    0x6e, 0x00, 0x47, 0x75, 0x65, 0x76, 0x61, 0x72, 0x61, 0x00, 0x45, 0x61,
+    0x72, 0x6c, 0x00, 0x44, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x43, 0x61,
+    0x72, 0x72, 0x69, 0x65, 0x72, 0x00, 0x50, 0x69, 0x63, 0x6b, 0x65, 0x6e,
+    0x73, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x64, 0x00, 0x54, 0x69, 0x6c, 0x6c,
+    0x65, 0x79, 0x00, 0x53, 0x63, 0x68, 0x61, 0x66, 0x66, 0x65, 0x72, 0x00,
+    0x52, 0x65, 0x61, 0x64, 0x00, 0x4c, 0x69, 0x6d, 0x00, 0x4b, 0x6e, 0x75,
+    0x74, 0x73, 0x6f, 0x6e, 0x00, 0x46, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00,
+    0x44, 0x6f, 0x72, 0x61, 0x6e, 0x00, 0x43, 0x68, 0x75, 0x00, 0x56, 0x6f,
+    0x67, 0x74, 0x00, 0x56, 0x61, 0x6e, 0x6e, 0x00, 0x50, 0x72, 0x65, 0x73,
+    0x63, 0x6f, 0x74, 0x74, 0x00, 0x4d, 0x63, 0x6c, 0x61, 0x69, 0x6e, 0x00,
+    0x4c, 0x61, 0x6e, 0x64, 0x69, 0x73, 0x00, 0x43, 0x6f, 0x72, 0x63, 0x6f,
+    0x72, 0x61, 0x6e, 0x00, 0x41, 0x6d, 0x62, 0x72, 0x6f, 0x73, 0x65, 0x00,
+    0x5a, 0x61, 0x70, 0x61, 0x74, 0x61, 0x00, 0x48, 0x79, 0x61, 0x74, 0x74,
+    0x00, 0x48, 0x65, 0x6d, 0x70, 0x68, 0x69, 0x6c, 0x6c, 0x00, 0x46, 0x61,
+    0x75, 0x6c, 0x6b, 0x00, 0x43, 0x61, 0x6c, 0x6c, 0x00, 0x44, 0x6f, 0x76,
+    0x65, 0x00, 0x42, 0x6f, 0x75, 0x64, 0x72, 0x65, 0x61, 0x75, 0x78, 0x00,
+    0x41, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x00, 0x57, 0x68, 0x69, 0x74, 0x6c,
+    0x6f, 0x63, 0x6b, 0x00, 0x54, 0x72, 0x65, 0x6a, 0x6f, 0x00, 0x54, 0x61,
+    0x63, 0x6b, 0x65, 0x74, 0x74, 0x00, 0x53, 0x68, 0x65, 0x61, 0x72, 0x65,
+    0x72, 0x00, 0x53, 0x61, 0x6c, 0x64, 0x61, 0x6e, 0x61, 0x00, 0x48, 0x61,
+    0x6e, 0x6b, 0x73, 0x00, 0x47, 0x6f, 0x6c, 0x64, 0x00, 0x44, 0x72, 0x69,
+    0x76, 0x65, 0x72, 0x00, 0x4d, 0x63, 0x6b, 0x69, 0x6e, 0x6e, 0x6f, 0x6e,
+    0x00, 0x4b, 0x6f, 0x65, 0x68, 0x6c, 0x65, 0x72, 0x00, 0x43, 0x68, 0x61,
+    0x6d, 0x70, 0x61, 0x67, 0x6e, 0x65, 0x00, 0x42, 0x6f, 0x75, 0x72, 0x67,
+    0x65, 0x6f, 0x69, 0x73, 0x00, 0x50, 0x6f, 0x6f, 0x6c, 0x00, 0x4b, 0x65,
+    0x79, 0x65, 0x73, 0x00, 0x47, 0x6f, 0x6f, 0x64, 0x73, 0x6f, 0x6e, 0x00,
+    0x46, 0x6f, 0x6f, 0x74, 0x65, 0x00, 0x45, 0x61, 0x72, 0x6c, 0x79, 0x00,
+    0x4c, 0x75, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x47, 0x6f, 0x6c,
+    0x64, 0x73, 0x6d, 0x69, 0x74, 0x68, 0x00, 0x46, 0x6c, 0x6f, 0x6f, 0x64,
+    0x00, 0x57, 0x69, 0x6e, 0x73, 0x6c, 0x6f, 0x77, 0x00, 0x53, 0x61, 0x6d,
+    0x73, 0x00, 0x52, 0x65, 0x61, 0x67, 0x61, 0x6e, 0x00, 0x4d, 0x63, 0x63,
+    0x6c, 0x6f, 0x75, 0x64, 0x00, 0x48, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x45,
+    0x73, 0x71, 0x75, 0x69, 0x76, 0x65, 0x6c, 0x00, 0x4e, 0x61, 0x79, 0x6c,
+    0x6f, 0x72, 0x00, 0x4c, 0x6f, 0x6f, 0x6d, 0x69, 0x73, 0x00, 0x43, 0x6f,
+    0x72, 0x6f, 0x6e, 0x61, 0x64, 0x6f, 0x00, 0x4c, 0x75, 0x64, 0x77, 0x69,
+    0x67, 0x00, 0x42, 0x72, 0x61, 0x73, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x42,
+    0x65, 0x61, 0x72, 0x64, 0x65, 0x6e, 0x00, 0x53, 0x68, 0x65, 0x72, 0x72,
+    0x69, 0x6c, 0x6c, 0x00, 0x48, 0x75, 0x61, 0x6e, 0x67, 0x00, 0x46, 0x61,
+    0x67, 0x61, 0x6e, 0x00, 0x45, 0x7a, 0x65, 0x6c, 0x6c, 0x00, 0x45, 0x64,
+    0x6d, 0x6f, 0x6e, 0x64, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x79, 0x72, 0x00,
+    0x43, 0x72, 0x6f, 0x6e, 0x69, 0x6e, 0x00, 0x4e, 0x75, 0x6e, 0x6e, 0x00,
+    0x4c, 0x65, 0x6d, 0x6f, 0x6e, 0x00, 0x47, 0x75, 0x69, 0x6c, 0x6c, 0x6f,
+    0x72, 0x79, 0x00, 0x47, 0x72, 0x69, 0x65, 0x72, 0x00, 0x44, 0x75, 0x62,
+    0x6f, 0x73, 0x65, 0x00, 0x54, 0x72, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x00,
+    0x52, 0x79, 0x64, 0x65, 0x72, 0x00, 0x44, 0x6f, 0x62, 0x62, 0x69, 0x6e,
+    0x73, 0x00, 0x43, 0x6f, 0x79, 0x6c, 0x65, 0x00, 0x41, 0x70, 0x6f, 0x6e,
+    0x74, 0x65, 0x00, 0x57, 0x68, 0x69, 0x74, 0x6d, 0x6f, 0x72, 0x65, 0x00,
+    0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x73, 0x00, 0x52, 0x6f, 0x77, 0x61, 0x6e,
+    0x00, 0x4d, 0x61, 0x6c, 0x6c, 0x6f, 0x79, 0x00, 0x43, 0x61, 0x72, 0x64,
+    0x6f, 0x6e, 0x61, 0x00, 0x42, 0x72, 0x61, 0x78, 0x74, 0x6f, 0x6e, 0x00,
+    0x42, 0x6f, 0x72, 0x64, 0x65, 0x6e, 0x00, 0x48, 0x75, 0x6d, 0x70, 0x68,
+    0x72, 0x69, 0x65, 0x73, 0x00, 0x43, 0x61, 0x72, 0x72, 0x61, 0x73, 0x63,
+    0x6f, 0x00, 0x52, 0x75, 0x66, 0x66, 0x00, 0x4d, 0x65, 0x74, 0x7a, 0x67,
+    0x65, 0x72, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x6c, 0x65, 0x79, 0x00, 0x48,
+    0x69, 0x6e, 0x6f, 0x6a, 0x6f, 0x73, 0x61, 0x00, 0x46, 0x69, 0x6e, 0x6e,
+    0x65, 0x79, 0x00, 0x4d, 0x61, 0x64, 0x73, 0x65, 0x6e, 0x00, 0x48, 0x6f,
+    0x6e, 0x67, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x00, 0x45, 0x72, 0x6e,
+    0x73, 0x74, 0x00, 0x44, 0x6f, 0x7a, 0x69, 0x65, 0x72, 0x00, 0x42, 0x75,
+    0x72, 0x6b, 0x68, 0x61, 0x72, 0x74, 0x00, 0x42, 0x6f, 0x77, 0x73, 0x65,
+    0x72, 0x00, 0x50, 0x65, 0x72, 0x61, 0x6c, 0x74, 0x61, 0x00, 0x44, 0x61,
+    0x69, 0x67, 0x6c, 0x65, 0x00, 0x57, 0x68, 0x69, 0x74, 0x74, 0x69, 0x6e,
+    0x67, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x6f, 0x72, 0x65, 0x6e, 0x73, 0x6f,
+    0x6e, 0x00, 0x53, 0x61, 0x75, 0x63, 0x65, 0x64, 0x6f, 0x00, 0x52, 0x6f,
+    0x63, 0x68, 0x65, 0x00, 0x52, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x00,
+    0x4c, 0x6f, 0x79, 0x64, 0x00, 0x46, 0x75, 0x67, 0x61, 0x74, 0x65, 0x00,
+    0x41, 0x76, 0x61, 0x6c, 0x6f, 0x73, 0x00, 0x57, 0x61, 0x69, 0x74, 0x65,
+    0x00, 0x4c, 0x69, 0x6e, 0x64, 0x00, 0x48, 0x75, 0x73, 0x74, 0x6f, 0x6e,
+    0x00, 0x48, 0x61, 0x79, 0x00, 0x42, 0x65, 0x6e, 0x65, 0x64, 0x69, 0x63,
+    0x74, 0x00, 0x48, 0x61, 0x77, 0x74, 0x68, 0x6f, 0x72, 0x6e, 0x65, 0x00,
+    0x48, 0x61, 0x6d, 0x62, 0x79, 0x00, 0x42, 0x6f, 0x79, 0x6c, 0x65, 0x73,
+    0x00, 0x42, 0x6f, 0x6c, 0x65, 0x73, 0x00, 0x52, 0x65, 0x67, 0x61, 0x6e,
+    0x00, 0x46, 0x61, 0x75, 0x73, 0x74, 0x00, 0x43, 0x72, 0x6f, 0x6f, 0x6b,
+    0x00, 0x42, 0x65, 0x61, 0x6d, 0x00, 0x42, 0x61, 0x72, 0x67, 0x65, 0x72,
+    0x00, 0x48, 0x69, 0x6e, 0x64, 0x73, 0x00, 0x47, 0x61, 0x6c, 0x6c, 0x61,
+    0x72, 0x64, 0x6f, 0x00, 0x45, 0x6c, 0x69, 0x61, 0x73, 0x00, 0x57, 0x69,
+    0x6c, 0x6c, 0x6f, 0x75, 0x67, 0x68, 0x62, 0x79, 0x00, 0x57, 0x69, 0x6c,
+    0x6c, 0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x00, 0x57, 0x69, 0x6c, 0x62,
+    0x75, 0x72, 0x6e, 0x00, 0x45, 0x63, 0x6b, 0x65, 0x72, 0x74, 0x00, 0x42,
+    0x75, 0x73, 0x63, 0x68, 0x00, 0x5a, 0x65, 0x70, 0x65, 0x64, 0x61, 0x00,
+    0x57, 0x6f, 0x72, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00,
+    0x54, 0x69, 0x6e, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x52, 0x75, 0x73, 0x73,
+    0x00, 0x4c, 0x69, 0x00, 0x48, 0x6f, 0x66, 0x66, 0x00, 0x48, 0x61, 0x77,
+    0x6c, 0x65, 0x79, 0x00, 0x43, 0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x61, 0x00,
+    0x56, 0x61, 0x72, 0x65, 0x6c, 0x61, 0x00, 0x52, 0x65, 0x63, 0x74, 0x6f,
+    0x72, 0x00, 0x4e, 0x65, 0x77, 0x63, 0x6f, 0x6d, 0x62, 0x00, 0x4d, 0x61,
+    0x6c, 0x6c, 0x6f, 0x72, 0x79, 0x00, 0x4b, 0x69, 0x6e, 0x73, 0x65, 0x79,
+    0x00, 0x44, 0x75, 0x62, 0x65, 0x00, 0x57, 0x68, 0x61, 0x74, 0x6c, 0x65,
+    0x79, 0x00, 0x53, 0x74, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x52, 0x61,
+    0x67, 0x73, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x49, 0x76, 0x79, 0x00, 0x42,
+    0x65, 0x72, 0x6e, 0x73, 0x74, 0x65, 0x69, 0x6e, 0x00, 0x42, 0x65, 0x63,
+    0x65, 0x72, 0x72, 0x61, 0x00, 0x59, 0x6f, 0x73, 0x74, 0x00, 0x4d, 0x61,
+    0x74, 0x74, 0x73, 0x6f, 0x6e, 0x00, 0x4c, 0x79, 0x00, 0x46, 0x65, 0x6c,
+    0x64, 0x65, 0x72, 0x00, 0x43, 0x68, 0x65, 0x65, 0x6b, 0x00, 0x4c, 0x75,
+    0x6b, 0x65, 0x00, 0x48, 0x61, 0x6e, 0x64, 0x79, 0x00, 0x47, 0x72, 0x6f,
+    0x73, 0x73, 0x6d, 0x61, 0x6e, 0x00, 0x47, 0x61, 0x75, 0x74, 0x68, 0x69,
+    0x65, 0x72, 0x00, 0x45, 0x73, 0x63, 0x6f, 0x62, 0x65, 0x64, 0x6f, 0x00,
+    0x42, 0x72, 0x61, 0x64, 0x65, 0x6e, 0x00, 0x42, 0x65, 0x63, 0x6b, 0x6d,
+    0x61, 0x6e, 0x00, 0x4d, 0x6f, 0x74, 0x74, 0x00, 0x48, 0x69, 0x6c, 0x6c,
+    0x6d, 0x61, 0x6e, 0x00, 0x47, 0x69, 0x6c, 0x00, 0x46, 0x6c, 0x61, 0x68,
+    0x65, 0x72, 0x74, 0x79, 0x00, 0x44, 0x79, 0x6b, 0x65, 0x73, 0x00, 0x44,
+    0x6f, 0x65, 0x00, 0x53, 0x74, 0x6f, 0x63, 0x6b, 0x74, 0x6f, 0x6e, 0x00,
+    0x53, 0x74, 0x65, 0x61, 0x72, 0x6e, 0x73, 0x00, 0x4c, 0x6f, 0x66, 0x74,
+    0x6f, 0x6e, 0x00, 0x4b, 0x69, 0x74, 0x63, 0x68, 0x65, 0x6e, 0x00, 0x43,
+    0x6f, 0x61, 0x74, 0x73, 0x00, 0x43, 0x61, 0x76, 0x61, 0x7a, 0x6f, 0x73,
+    0x00, 0x42, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x00, 0x42, 0x61, 0x72,
+    0x72, 0x69, 0x6f, 0x73, 0x00, 0x54, 0x61, 0x6e, 0x67, 0x00, 0x50, 0x61,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x4d, 0x6f, 0x73, 0x68, 0x65, 0x72, 0x00,
+    0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x64,
+    0x77, 0x65, 0x6c, 0x6c, 0x00, 0x43, 0x6f, 0x6c, 0x65, 0x73, 0x00, 0x42,
+    0x75, 0x72, 0x6e, 0x68, 0x61, 0x6d, 0x00, 0x57, 0x65, 0x6c, 0x6c, 0x65,
+    0x72, 0x00, 0x4c, 0x65, 0x6d, 0x6f, 0x6e, 0x73, 0x00, 0x42, 0x65, 0x65,
+    0x62, 0x65, 0x00, 0x41, 0x67, 0x75, 0x69, 0x6c, 0x65, 0x72, 0x61, 0x00,
+    0x52, 0x69, 0x6e, 0x67, 0x00, 0x50, 0x61, 0x72, 0x6e, 0x65, 0x6c, 0x6c,
+    0x00, 0x48, 0x61, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x43, 0x6f, 0x75, 0x74,
+    0x75, 0x72, 0x65, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x63,
+    0x68, 0x75, 0x6d, 0x61, 0x63, 0x68, 0x65, 0x72, 0x00, 0x52, 0x65, 0x64,
+    0x64, 0x00, 0x44, 0x6f, 0x62, 0x62, 0x73, 0x00, 0x42, 0x6c, 0x75, 0x6d,
+    0x00, 0x42, 0x6c, 0x61, 0x6c, 0x6f, 0x63, 0x6b, 0x00, 0x4d, 0x65, 0x72,
+    0x63, 0x68, 0x61, 0x6e, 0x74, 0x00, 0x45, 0x6e, 0x6e, 0x69, 0x73, 0x00,
+    0x44, 0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x74, 0x74, 0x72,
+    0x65, 0x6c, 0x6c, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74, 0x65, 0x72, 0x00,
+    0x42, 0x72, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x00, 0x42, 0x61, 0x67, 0x6c,
+    0x65, 0x79, 0x00, 0x41, 0x76, 0x69, 0x6c, 0x65, 0x73, 0x00, 0x57, 0x61,
+    0x74, 0x74, 0x00, 0x53, 0x6f, 0x75, 0x73, 0x61, 0x00, 0x52, 0x6f, 0x73,
+    0x65, 0x6e, 0x74, 0x68, 0x61, 0x6c, 0x00, 0x52, 0x6f, 0x6f, 0x6e, 0x65,
+    0x79, 0x00, 0x44, 0x69, 0x65, 0x74, 0x7a, 0x00, 0x42, 0x6c, 0x61, 0x6e,
+    0x6b, 0x00, 0x50, 0x61, 0x71, 0x75, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4d,
+    0x63, 0x63, 0x6c, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x44, 0x75,
+    0x66, 0x66, 0x00, 0x56, 0x65, 0x6c, 0x61, 0x73, 0x63, 0x6f, 0x00, 0x4c,
+    0x65, 0x6e, 0x74, 0x7a, 0x00, 0x47, 0x72, 0x75, 0x62, 0x62, 0x00, 0x42,
+    0x75, 0x72, 0x72, 0x6f, 0x77, 0x73, 0x00, 0x42, 0x61, 0x72, 0x62, 0x6f,
+    0x75, 0x72, 0x00, 0x55, 0x6c, 0x72, 0x69, 0x63, 0x68, 0x00, 0x53, 0x68,
+    0x6f, 0x63, 0x6b, 0x6c, 0x65, 0x79, 0x00, 0x52, 0x61, 0x64, 0x65, 0x72,
+    0x00, 0x47, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x65, 0x79, 0x65,
+    0x72, 0x00, 0x4d, 0x69, 0x78, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x79, 0x74,
+    0x6f, 0x6e, 0x00, 0x41, 0x6c, 0x74, 0x6d, 0x61, 0x6e, 0x00, 0x41, 0x6c,
+    0x6f, 0x6e, 0x7a, 0x6f, 0x00, 0x57, 0x65, 0x61, 0x74, 0x68, 0x65, 0x72,
+    0x73, 0x00, 0x54, 0x69, 0x74, 0x75, 0x73, 0x00, 0x53, 0x74, 0x6f, 0x6e,
+    0x65, 0x72, 0x00, 0x53, 0x71, 0x75, 0x69, 0x72, 0x65, 0x73, 0x00, 0x53,
+    0x68, 0x69, 0x70, 0x70, 0x00, 0x50, 0x72, 0x69, 0x65, 0x73, 0x74, 0x00,
+    0x4c, 0x69, 0x70, 0x73, 0x63, 0x6f, 0x6d, 0x62, 0x00, 0x43, 0x75, 0x74,
+    0x6c, 0x65, 0x72, 0x00, 0x43, 0x61, 0x62, 0x61, 0x6c, 0x6c, 0x65, 0x72,
+    0x6f, 0x00, 0x5a, 0x69, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x57, 0x69, 0x6c,
+    0x6c, 0x65, 0x74, 0x74, 0x00, 0x54, 0x68, 0x75, 0x72, 0x73, 0x74, 0x6f,
+    0x6e, 0x00, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x79, 0x00, 0x4d, 0x65, 0x64,
+    0x6c, 0x65, 0x79, 0x00, 0x4c, 0x79, 0x6c, 0x65, 0x00, 0x45, 0x70, 0x70,
+    0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x61, 0x68, 0x00, 0x4d,
+    0x63, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x00, 0x42, 0x61, 0x67,
+    0x67, 0x65, 0x74, 0x74, 0x00, 0x54, 0x6f, 0x72, 0x72, 0x65, 0x7a, 0x00,
+    0x4c, 0x61, 0x77, 0x73, 0x00, 0x48, 0x69, 0x72, 0x73, 0x63, 0x68, 0x00,
+    0x44, 0x65, 0x6e, 0x74, 0x00, 0x43, 0x6f, 0x72, 0x65, 0x79, 0x00, 0x50,
+    0x6f, 0x69, 0x72, 0x69, 0x65, 0x72, 0x00, 0x50, 0x65, 0x61, 0x63, 0x68,
+    0x65, 0x79, 0x00, 0x4a, 0x61, 0x63, 0x71, 0x75, 0x65, 0x73, 0x00, 0x46,
+    0x61, 0x72, 0x72, 0x61, 0x72, 0x00, 0x43, 0x72, 0x65, 0x65, 0x63, 0x68,
+    0x00, 0x42, 0x61, 0x72, 0x74, 0x68, 0x00, 0x54, 0x72, 0x69, 0x6d, 0x62,
+    0x6c, 0x65, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x44, 0x75,
+    0x70, 0x72, 0x65, 0x00, 0x41, 0x6c, 0x62, 0x72, 0x65, 0x63, 0x68, 0x74,
+    0x00, 0x53, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x00, 0x4c, 0x61, 0x77, 0x6c,
+    0x65, 0x72, 0x00, 0x43, 0x72, 0x69, 0x73, 0x70, 0x00, 0x43, 0x6f, 0x6e,
+    0x72, 0x6f, 0x79, 0x00, 0x43, 0x68, 0x61, 0x64, 0x77, 0x69, 0x63, 0x6b,
+    0x00, 0x57, 0x65, 0x74, 0x7a, 0x65, 0x6c, 0x00, 0x4e, 0x65, 0x73, 0x62,
+    0x69, 0x74, 0x74, 0x00, 0x4d, 0x75, 0x72, 0x72, 0x79, 0x00, 0x4a, 0x61,
+    0x6d, 0x65, 0x73, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6c, 0x68, 0x65, 0x6c,
+    0x6d, 0x00, 0x50, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x00, 0x4d, 0x69, 0x6e,
+    0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x74, 0x73, 0x6f, 0x6e, 0x00, 0x4b,
+    0x69, 0x6d, 0x62, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x49, 0x76, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x00, 0x47, 0x75, 0x69, 0x6e, 0x6e, 0x00, 0x47,
+    0x61, 0x6c, 0x65, 0x00, 0x46, 0x6f, 0x72, 0x74, 0x75, 0x6e, 0x65, 0x00,
+    0x43, 0x72, 0x6f, 0x66, 0x74, 0x00, 0x54, 0x6f, 0x74, 0x68, 0x00, 0x50,
+    0x75, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x00, 0x4e, 0x75, 0x67, 0x65, 0x6e,
+    0x74, 0x00, 0x4e, 0x65, 0x77, 0x62, 0x79, 0x00, 0x4c, 0x69, 0x74, 0x74,
+    0x6c, 0x65, 0x6a, 0x6f, 0x68, 0x6e, 0x00, 0x44, 0x69, 0x61, 0x73, 0x00,
+    0x43, 0x61, 0x6e, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x42, 0x65, 0x72, 0x6e,
+    0x69, 0x65, 0x72, 0x00, 0x42, 0x61, 0x72, 0x6f, 0x6e, 0x00, 0x42, 0x61,
+    0x72, 0x6e, 0x65, 0x79, 0x00, 0x53, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x74,
+    0x61, 0x72, 0x79, 0x00, 0x52, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x69, 0x61,
+    0x00, 0x50, 0x72, 0x75, 0x65, 0x74, 0x74, 0x00, 0x4d, 0x63, 0x68, 0x75,
+    0x67, 0x68, 0x00, 0x4d, 0x61, 0x62, 0x72, 0x79, 0x00, 0x4c, 0x61, 0x6e,
+    0x64, 0x72, 0x75, 0x6d, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x65, 0x72, 0x00,
+    0x57, 0x65, 0x6c, 0x64, 0x6f, 0x6e, 0x00, 0x53, 0x74, 0x6f, 0x64, 0x64,
+    0x61, 0x72, 0x64, 0x00, 0x52, 0x75, 0x74, 0x68, 0x00, 0x43, 0x61, 0x67,
+    0x6c, 0x65, 0x00, 0x53, 0x74, 0x6a, 0x6f, 0x68, 0x6e, 0x00, 0x53, 0x63,
+    0x61, 0x6c, 0x65, 0x73, 0x00, 0x4b, 0x6f, 0x68, 0x6c, 0x65, 0x72, 0x00,
+    0x4b, 0x65, 0x6c, 0x6c, 0x6f, 0x67, 0x67, 0x00, 0x48, 0x6f, 0x70, 0x73,
+    0x6f, 0x6e, 0x00, 0x47, 0x61, 0x6e, 0x74, 0x00, 0x54, 0x68, 0x61, 0x72,
+    0x70, 0x00, 0x47, 0x61, 0x6e, 0x6e, 0x00, 0x5a, 0x65, 0x69, 0x67, 0x6c,
+    0x65, 0x72, 0x00, 0x50, 0x72, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x00, 0x48,
+    0x61, 0x6d, 0x6d, 0x6f, 0x6e, 0x73, 0x00, 0x46, 0x61, 0x69, 0x72, 0x63,
+    0x68, 0x69, 0x6c, 0x64, 0x00, 0x44, 0x65, 0x61, 0x74, 0x6f, 0x6e, 0x00,
+    0x43, 0x68, 0x61, 0x76, 0x69, 0x73, 0x00, 0x43, 0x61, 0x72, 0x6e, 0x65,
+    0x73, 0x00, 0x52, 0x6f, 0x77, 0x6c, 0x65, 0x79, 0x00, 0x4d, 0x61, 0x74,
+    0x6c, 0x6f, 0x63, 0x6b, 0x00, 0x4c, 0x69, 0x62, 0x62, 0x79, 0x00, 0x4b,
+    0x65, 0x61, 0x72, 0x6e, 0x73, 0x00, 0x49, 0x72, 0x69, 0x7a, 0x61, 0x72,
+    0x72, 0x79, 0x00, 0x43, 0x61, 0x72, 0x72, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x00, 0x53, 0x74, 0x61, 0x72, 0x6b, 0x65, 0x79, 0x00, 0x50, 0x65,
+    0x70, 0x70, 0x65, 0x72, 0x00, 0x4c, 0x6f, 0x70, 0x65, 0x73, 0x00, 0x4a,
+    0x61, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x46, 0x61, 0x79, 0x00, 0x43,
+    0x72, 0x61, 0x76, 0x65, 0x6e, 0x00, 0x42, 0x65, 0x76, 0x65, 0x72, 0x6c,
+    0x79, 0x00, 0x42, 0x61, 0x75, 0x6d, 0x00, 0x53, 0x70, 0x61, 0x69, 0x6e,
+    0x00, 0x4c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x66, 0x69, 0x65, 0x6c, 0x64,
+    0x00, 0x4c, 0x69, 0x6e, 0x6e, 0x00, 0x48, 0x75, 0x6d, 0x70, 0x68, 0x72,
+    0x65, 0x79, 0x73, 0x00, 0x48, 0x6f, 0x6f, 0x6b, 0x00, 0x48, 0x69, 0x67,
+    0x68, 0x00, 0x45, 0x74, 0x68, 0x65, 0x72, 0x69, 0x64, 0x67, 0x65, 0x00,
+    0x43, 0x75, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x00, 0x43, 0x68, 0x61, 0x73,
+    0x74, 0x61, 0x69, 0x6e, 0x00, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x00,
+    0x42, 0x75, 0x6e, 0x64, 0x79, 0x00, 0x53, 0x70, 0x65, 0x65, 0x72, 0x00,
+    0x53, 0x6b, 0x65, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x51, 0x75, 0x69, 0x72,
+    0x6f, 0x7a, 0x00, 0x50, 0x79, 0x6c, 0x65, 0x00, 0x50, 0x6f, 0x72, 0x74,
+    0x69, 0x6c, 0x6c, 0x6f, 0x00, 0x50, 0x6f, 0x6e, 0x64, 0x65, 0x72, 0x00,
+    0x4d, 0x6f, 0x75, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x63, 0x68,
+    0x61, 0x64, 0x6f, 0x00, 0x4c, 0x69, 0x75, 0x00, 0x4b, 0x69, 0x6c, 0x6c,
+    0x69, 0x61, 0x6e, 0x00, 0x48, 0x75, 0x74, 0x73, 0x6f, 0x6e, 0x00, 0x48,
+    0x69, 0x74, 0x63, 0x68, 0x63, 0x6f, 0x63, 0x6b, 0x00, 0x45, 0x6c, 0x6c,
+    0x73, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x00, 0x44, 0x6f, 0x77, 0x6c, 0x69,
+    0x6e, 0x67, 0x00, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x00, 0x42, 0x75, 0x72,
+    0x64, 0x69, 0x63, 0x6b, 0x00, 0x53, 0x70, 0x61, 0x6e, 0x6e, 0x00, 0x50,
+    0x65, 0x64, 0x65, 0x72, 0x73, 0x65, 0x6e, 0x00, 0x4c, 0x65, 0x76, 0x69,
+    0x6e, 0x00, 0x4c, 0x65, 0x67, 0x67, 0x65, 0x74, 0x74, 0x00, 0x48, 0x61,
+    0x79, 0x77, 0x61, 0x72, 0x64, 0x00, 0x48, 0x61, 0x63, 0x6b, 0x65, 0x72,
+    0x00, 0x44, 0x69, 0x65, 0x74, 0x72, 0x69, 0x63, 0x68, 0x00, 0x42, 0x65,
+    0x61, 0x75, 0x6c, 0x69, 0x65, 0x75, 0x00, 0x42, 0x61, 0x72, 0x6b, 0x73,
+    0x64, 0x61, 0x6c, 0x65, 0x00, 0x57, 0x61, 0x6b, 0x65, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x00, 0x53, 0x6e, 0x6f, 0x77, 0x64, 0x65, 0x6e, 0x00, 0x50,
+    0x61, 0x72, 0x69, 0x73, 0x00, 0x42, 0x72, 0x69, 0x73, 0x63, 0x6f, 0x65,
+    0x00, 0x42, 0x6f, 0x77, 0x69, 0x65, 0x00, 0x42, 0x65, 0x72, 0x6d, 0x61,
+    0x6e, 0x00, 0x4f, 0x67, 0x6c, 0x65, 0x00, 0x4d, 0x63, 0x67, 0x72, 0x65,
+    0x67, 0x6f, 0x72, 0x00, 0x4c, 0x61, 0x75, 0x67, 0x68, 0x6c, 0x69, 0x6e,
+    0x00, 0x48, 0x65, 0x6c, 0x6d, 0x00, 0x42, 0x75, 0x72, 0x64, 0x65, 0x6e,
+    0x00, 0x57, 0x68, 0x65, 0x61, 0x74, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x63,
+    0x68, 0x72, 0x65, 0x69, 0x62, 0x65, 0x72, 0x00, 0x50, 0x72, 0x65, 0x73,
+    0x73, 0x6c, 0x65, 0x79, 0x00, 0x50, 0x61, 0x72, 0x72, 0x69, 0x73, 0x00,
+    0x4e, 0x67, 0x00, 0x41, 0x6c, 0x61, 0x6e, 0x69, 0x7a, 0x00, 0x41, 0x67,
+    0x65, 0x65, 0x00, 0x55, 0x72, 0x62, 0x61, 0x6e, 0x00, 0x53, 0x77, 0x61,
+    0x6e, 0x6e, 0x00, 0x53, 0x6e, 0x6f, 0x64, 0x67, 0x72, 0x61, 0x73, 0x73,
+    0x00, 0x53, 0x63, 0x68, 0x75, 0x73, 0x74, 0x65, 0x72, 0x00, 0x52, 0x61,
+    0x64, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x4d, 0x6f, 0x6e, 0x6b, 0x00, 0x4d,
+    0x61, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x4d, 0x61, 0x69,
+    0x6e, 0x00, 0x4c, 0x61, 0x6d, 0x61, 0x72, 0x00, 0x48, 0x61, 0x72, 0x70,
+    0x00, 0x47, 0x69, 0x72, 0x61, 0x72, 0x64, 0x00, 0x43, 0x68, 0x65, 0x6e,
+    0x65, 0x79, 0x00, 0x59, 0x61, 0x6e, 0x63, 0x65, 0x79, 0x00, 0x57, 0x61,
+    0x67, 0x6f, 0x6e, 0x65, 0x72, 0x00, 0x52, 0x69, 0x64, 0x6c, 0x65, 0x79,
+    0x00, 0x4c, 0x6f, 0x6d, 0x62, 0x61, 0x72, 0x64, 0x6f, 0x00, 0x4c, 0x61,
+    0x75, 0x00, 0x48, 0x75, 0x64, 0x67, 0x69, 0x6e, 0x73, 0x00, 0x47, 0x61,
+    0x73, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x44, 0x75, 0x63, 0x6b, 0x77, 0x6f,
+    0x72, 0x74, 0x68, 0x00, 0x43, 0x6f, 0x65, 0x00, 0x43, 0x6f, 0x62, 0x75,
+    0x72, 0x6e, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x50, 0x72,
+    0x61, 0x64, 0x6f, 0x00, 0x4e, 0x65, 0x77, 0x62, 0x65, 0x72, 0x72, 0x79,
+    0x00, 0x4d, 0x61, 0x67, 0x61, 0x6e, 0x61, 0x00, 0x48, 0x61, 0x6d, 0x6d,
+    0x6f, 0x6e, 0x64, 0x73, 0x00, 0x45, 0x6c, 0x61, 0x6d, 0x00, 0x57, 0x68,
+    0x69, 0x70, 0x70, 0x6c, 0x65, 0x00, 0x53, 0x6c, 0x61, 0x64, 0x65, 0x00,
+    0x53, 0x65, 0x72, 0x6e, 0x61, 0x00, 0x4f, 0x6a, 0x65, 0x64, 0x61, 0x00,
+    0x4c, 0x69, 0x6c, 0x65, 0x73, 0x00, 0x44, 0x6f, 0x72, 0x6d, 0x61, 0x6e,
+    0x00, 0x44, 0x69, 0x65, 0x68, 0x6c, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c,
+    0x00, 0x55, 0x70, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x65, 0x61, 0x72, 0x64,
+    0x6f, 0x6e, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c, 0x73, 0x00,
+    0x4b, 0x65, 0x6c, 0x73, 0x65, 0x79, 0x00, 0x47, 0x6f, 0x65, 0x74, 0x7a,
+    0x00, 0x45, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x42, 0x61, 0x75, 0x6d, 0x61,
+    0x6e, 0x00, 0x42, 0x61, 0x65, 0x72, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73,
+    0x74, 0x69, 0x6e, 0x65, 0x00, 0x4c, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x48,
+    0x75, 0x6d, 0x6d, 0x65, 0x6c, 0x00, 0x42, 0x72, 0x65, 0x6e, 0x6e, 0x65,
+    0x72, 0x00, 0x41, 0x6d, 0x61, 0x79, 0x61, 0x00, 0x41, 0x64, 0x61, 0x6d,
+    0x73, 0x6f, 0x6e, 0x00, 0x4f, 0x72, 0x6e, 0x65, 0x6c, 0x61, 0x73, 0x00,
+    0x44, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x43, 0x6c, 0x6f, 0x75, 0x74,
+    0x69, 0x65, 0x72, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x79, 0x00,
+    0x43, 0x61, 0x73, 0x74, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x6f, 0x73, 0x00,
+    0x57, 0x69, 0x6e, 0x67, 0x00, 0x57, 0x65, 0x6c, 0x6c, 0x6d, 0x61, 0x6e,
+    0x00, 0x53, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x00, 0x4f, 0x72, 0x6f, 0x75,
+    0x72, 0x6b, 0x65, 0x00, 0x4d, 0x6f, 0x79, 0x61, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x61, 0x6c, 0x76, 0x6f, 0x00, 0x4b, 0x69, 0x6c, 0x70, 0x61, 0x74,
+    0x72, 0x69, 0x63, 0x6b, 0x00, 0x48, 0x61, 0x72, 0x6c, 0x65, 0x79, 0x00,
+    0x44, 0x75, 0x72, 0x62, 0x69, 0x6e, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x6c,
+    0x00, 0x4f, 0x6c, 0x64, 0x68, 0x61, 0x6d, 0x00, 0x4b, 0x61, 0x6e, 0x67,
+    0x00, 0x47, 0x61, 0x72, 0x76, 0x69, 0x6e, 0x00, 0x46, 0x6f, 0x73, 0x73,
+    0x00, 0x42, 0x72, 0x61, 0x6e, 0x68, 0x61, 0x6d, 0x00, 0x42, 0x61, 0x72,
+    0x74, 0x68, 0x6f, 0x6c, 0x6f, 0x6d, 0x65, 0x77, 0x00, 0x54, 0x65, 0x6d,
+    0x70, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x67, 0x75, 0x69,
+    0x72, 0x65, 0x00, 0x48, 0x6f, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x41, 0x6c,
+    0x6f, 0x6e, 0x73, 0x6f, 0x00, 0x52, 0x69, 0x64, 0x65, 0x72, 0x00, 0x4d,
+    0x6f, 0x6e, 0x61, 0x68, 0x61, 0x6e, 0x00, 0x4d, 0x63, 0x63, 0x6f, 0x72,
+    0x6d, 0x61, 0x63, 0x6b, 0x00, 0x42, 0x65, 0x61, 0x74, 0x79, 0x00, 0x41,
+    0x6e, 0x64, 0x65, 0x72, 0x73, 0x00, 0x53, 0x74, 0x72, 0x65, 0x65, 0x74,
+    0x65, 0x72, 0x00, 0x4e, 0x69, 0x65, 0x74, 0x6f, 0x00, 0x4e, 0x69, 0x65,
+    0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x6f, 0x66, 0x66, 0x65, 0x74, 0x74,
+    0x00, 0x4c, 0x61, 0x6e, 0x6b, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x4b, 0x65,
+    0x61, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x48, 0x65, 0x63, 0x6b, 0x00, 0x47,
+    0x61, 0x74, 0x6c, 0x69, 0x6e, 0x00, 0x44, 0x65, 0x6c, 0x61, 0x74, 0x6f,
+    0x72, 0x72, 0x65, 0x00, 0x43, 0x61, 0x6c, 0x6c, 0x61, 0x77, 0x61, 0x79,
+    0x00, 0x41, 0x64, 0x63, 0x6f, 0x63, 0x6b, 0x00, 0x57, 0x6f, 0x72, 0x72,
+    0x65, 0x6c, 0x6c, 0x00, 0x55, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x52, 0x6f,
+    0x62, 0x69, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x4e, 0x6f, 0x77, 0x61,
+    0x6b, 0x00, 0x4a, 0x65, 0x74, 0x65, 0x72, 0x00, 0x42, 0x72, 0x75, 0x6e,
+    0x6e, 0x65, 0x72, 0x00, 0x41, 0x73, 0x68, 0x74, 0x6f, 0x6e, 0x00, 0x53,
+    0x74, 0x65, 0x65, 0x6e, 0x00, 0x50, 0x61, 0x72, 0x72, 0x6f, 0x74, 0x74,
+    0x00, 0x4f, 0x76, 0x65, 0x72, 0x73, 0x74, 0x72, 0x65, 0x65, 0x74, 0x00,
+    0x4e, 0x6f, 0x62, 0x6c, 0x65, 0x73, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61,
+    0x6e, 0x65, 0x7a, 0x00, 0x4c, 0x75, 0x74, 0x68, 0x65, 0x72, 0x00, 0x43,
+    0x6c, 0x65, 0x76, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x42, 0x72, 0x69,
+    0x6e, 0x6b, 0x6c, 0x65, 0x79, 0x00, 0x54, 0x72, 0x61, 0x68, 0x61, 0x6e,
+    0x00, 0x51, 0x75, 0x61, 0x72, 0x6c, 0x65, 0x73, 0x00, 0x50, 0x69, 0x63,
+    0x6b, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x50, 0x65, 0x64, 0x65, 0x72,
+    0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x61, 0x6e, 0x73, 0x65, 0x6e, 0x00, 0x47,
+    0x72, 0x61, 0x6e, 0x74, 0x68, 0x61, 0x6d, 0x00, 0x47, 0x69, 0x6c, 0x63,
+    0x68, 0x72, 0x69, 0x73, 0x74, 0x00, 0x43, 0x72, 0x65, 0x73, 0x70, 0x6f,
+    0x00, 0x41, 0x69, 0x6b, 0x65, 0x6e, 0x00, 0x53, 0x63, 0x68, 0x65, 0x6c,
+    0x6c, 0x00, 0x53, 0x63, 0x68, 0x61, 0x65, 0x66, 0x66, 0x65, 0x72, 0x00,
+    0x4c, 0x6f, 0x72, 0x65, 0x6e, 0x7a, 0x00, 0x4c, 0x65, 0x79, 0x76, 0x61,
+    0x00, 0x48, 0x61, 0x72, 0x6d, 0x73, 0x00, 0x44, 0x79, 0x73, 0x6f, 0x6e,
+    0x00, 0x57, 0x61, 0x6c, 0x6c, 0x69, 0x73, 0x00, 0x50, 0x65, 0x61, 0x73,
+    0x65, 0x00, 0x4c, 0x65, 0x61, 0x76, 0x69, 0x74, 0x74, 0x00, 0x48, 0x79,
+    0x6d, 0x61, 0x6e, 0x00, 0x43, 0x68, 0x65, 0x6e, 0x67, 0x00, 0x43, 0x61,
+    0x76, 0x61, 0x6e, 0x61, 0x75, 0x67, 0x68, 0x00, 0x42, 0x61, 0x74, 0x74,
+    0x73, 0x00, 0x57, 0x61, 0x72, 0x64, 0x65, 0x6e, 0x00, 0x53, 0x65, 0x61,
+    0x6d, 0x61, 0x6e, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x77, 0x65, 0x6c, 0x6c,
+    0x00, 0x51, 0x75, 0x65, 0x7a, 0x61, 0x64, 0x61, 0x00, 0x50, 0x61, 0x78,
+    0x74, 0x6f, 0x6e, 0x00, 0x4c, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x48,
+    0x6f, 0x75, 0x63, 0x6b, 0x00, 0x46, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e,
+    0x65, 0x00, 0x44, 0x75, 0x72, 0x61, 0x6e, 0x74, 0x00, 0x43, 0x61, 0x72,
+    0x75, 0x73, 0x6f, 0x00, 0x41, 0x64, 0x6c, 0x65, 0x72, 0x00, 0x50, 0x69,
+    0x6d, 0x65, 0x6e, 0x74, 0x65, 0x6c, 0x00, 0x4d, 0x69, 0x7a, 0x65, 0x00,
+    0x4c, 0x79, 0x74, 0x6c, 0x65, 0x00, 0x44, 0x6f, 0x6e, 0x61, 0x6c, 0x64,
+    0x00, 0x43, 0x6c, 0x65, 0x61, 0x72, 0x79, 0x00, 0x43, 0x61, 0x73, 0x6f,
+    0x6e, 0x00, 0x41, 0x63, 0x6b, 0x65, 0x72, 0x00, 0x53, 0x77, 0x69, 0x74,
+    0x7a, 0x65, 0x72, 0x00, 0x53, 0x61, 0x6c, 0x6d, 0x6f, 0x6e, 0x00, 0x49,
+    0x73, 0x61, 0x61, 0x63, 0x73, 0x00, 0x48, 0x69, 0x67, 0x67, 0x69, 0x6e,
+    0x62, 0x6f, 0x74, 0x68, 0x61, 0x6d, 0x00, 0x48, 0x61, 0x6e, 0x00, 0x57,
+    0x61, 0x74, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x56, 0x61, 0x6e, 0x64,
+    0x79, 0x6b, 0x65, 0x00, 0x53, 0x74, 0x61, 0x6d, 0x70, 0x65, 0x72, 0x00,
+    0x53, 0x69, 0x73, 0x6b, 0x00, 0x53, 0x68, 0x75, 0x6c, 0x65, 0x72, 0x00,
+    0x52, 0x69, 0x64, 0x64, 0x69, 0x63, 0x6b, 0x00, 0x52, 0x65, 0x64, 0x6d,
+    0x61, 0x6e, 0x00, 0x4d, 0x63, 0x6d, 0x61, 0x68, 0x61, 0x6e, 0x00, 0x4c,
+    0x65, 0x76, 0x65, 0x73, 0x71, 0x75, 0x65, 0x00, 0x48, 0x61, 0x74, 0x74,
+    0x6f, 0x6e, 0x00, 0x42, 0x72, 0x6f, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x42,
+    0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x41, 0x72, 0x6e,
+    0x65, 0x74, 0x74, 0x00, 0x4f, 0x6b, 0x65, 0x65, 0x66, 0x65, 0x00, 0x47,
+    0x65, 0x72, 0x62, 0x65, 0x72, 0x00, 0x47, 0x61, 0x6e, 0x6e, 0x6f, 0x6e,
+    0x00, 0x46, 0x61, 0x72, 0x6e, 0x73, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x00,
+    0x42, 0x61, 0x75, 0x67, 0x68, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x69, 0x6c,
+    0x76, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x61, 0x74, 0x74, 0x65,
+    0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x52, 0x6f, 0x79, 0x61, 0x6c,
+    0x00, 0x4d, 0x63, 0x63, 0x72, 0x61, 0x72, 0x79, 0x00, 0x4b, 0x6f, 0x77,
+    0x61, 0x6c, 0x73, 0x6b, 0x69, 0x00, 0x4a, 0x6f, 0x79, 0x00, 0x47, 0x72,
+    0x69, 0x67, 0x73, 0x62, 0x79, 0x00, 0x47, 0x72, 0x65, 0x63, 0x6f, 0x00,
+    0x43, 0x61, 0x62, 0x72, 0x61, 0x6c, 0x00, 0x54, 0x72, 0x6f, 0x75, 0x74,
+    0x00, 0x52, 0x69, 0x6e, 0x65, 0x68, 0x61, 0x72, 0x74, 0x00, 0x4d, 0x61,
+    0x68, 0x6f, 0x6e, 0x00, 0x4c, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x47,
+    0x6f, 0x6f, 0x64, 0x65, 0x6e, 0x00, 0x43, 0x75, 0x72, 0x6c, 0x65, 0x79,
+    0x00, 0x42, 0x61, 0x75, 0x67, 0x68, 0x00, 0x57, 0x79, 0x6d, 0x61, 0x6e,
+    0x00, 0x57, 0x65, 0x69, 0x6e, 0x65, 0x72, 0x00, 0x53, 0x63, 0x68, 0x77,
+    0x61, 0x62, 0x00, 0x53, 0x63, 0x68, 0x75, 0x6c, 0x65, 0x72, 0x00, 0x4d,
+    0x6f, 0x72, 0x72, 0x69, 0x73, 0x73, 0x65, 0x79, 0x00, 0x4d, 0x61, 0x68,
+    0x61, 0x6e, 0x00, 0x43, 0x6f, 0x79, 0x00, 0x42, 0x75, 0x6e, 0x6e, 0x00,
+    0x41, 0x6e, 0x64, 0x72, 0x65, 0x77, 0x00, 0x54, 0x68, 0x72, 0x61, 0x73,
+    0x68, 0x65, 0x72, 0x00, 0x53, 0x70, 0x65, 0x61, 0x72, 0x00, 0x57, 0x61,
+    0x67, 0x67, 0x6f, 0x6e, 0x65, 0x72, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x6c,
+    0x65, 0x79, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x00, 0x51, 0x75,
+    0x61, 0x6c, 0x6c, 0x73, 0x00, 0x50, 0x75, 0x72, 0x64, 0x79, 0x00, 0x4d,
+    0x63, 0x77, 0x68, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x00, 0x4d, 0x61, 0x75,
+    0x6c, 0x64, 0x69, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x6b, 0x00, 0x4a, 0x6f,
+    0x72, 0x64, 0x6f, 0x6e, 0x00, 0x47, 0x69, 0x6c, 0x6d, 0x61, 0x6e, 0x00,
+    0x50, 0x65, 0x72, 0x72, 0x79, 0x6d, 0x61, 0x6e, 0x00, 0x4e, 0x65, 0x77,
+    0x73, 0x6f, 0x6d, 0x00, 0x4d, 0x65, 0x6e, 0x61, 0x72, 0x64, 0x00, 0x4d,
+    0x61, 0x72, 0x74, 0x69, 0x6e, 0x6f, 0x00, 0x47, 0x72, 0x61, 0x66, 0x00,
+    0x42, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x73, 0x6c, 0x65, 0x79, 0x00,
+    0x41, 0x72, 0x74, 0x69, 0x73, 0x00, 0x53, 0x69, 0x6d, 0x70, 0x6b, 0x69,
+    0x6e, 0x73, 0x00, 0x53, 0x61, 0x6c, 0x69, 0x73, 0x62, 0x75, 0x72, 0x79,
+    0x00, 0x51, 0x75, 0x69, 0x6e, 0x74, 0x61, 0x6e, 0x69, 0x6c, 0x6c, 0x61,
+    0x00, 0x47, 0x69, 0x6c, 0x6c, 0x69, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x46,
+    0x72, 0x61, 0x6c, 0x65, 0x79, 0x00, 0x46, 0x6f, 0x75, 0x73, 0x74, 0x00,
+    0x43, 0x72, 0x6f, 0x75, 0x73, 0x65, 0x00, 0x53, 0x63, 0x61, 0x72, 0x62,
+    0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x4e, 0x67, 0x6f, 0x00, 0x47,
+    0x72, 0x69, 0x73, 0x73, 0x6f, 0x6d, 0x00, 0x46, 0x75, 0x6c, 0x74, 0x7a,
+    0x00, 0x52, 0x69, 0x63, 0x6f, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x6f, 0x77,
+    0x00, 0x4d, 0x61, 0x72, 0x6b, 0x68, 0x61, 0x6d, 0x00, 0x4d, 0x61, 0x64,
+    0x72, 0x69, 0x67, 0x61, 0x6c, 0x00, 0x4c, 0x61, 0x77, 0x74, 0x6f, 0x6e,
+    0x00, 0x42, 0x61, 0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x57, 0x68,
+    0x69, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x56, 0x61, 0x72, 0x6e, 0x65, 0x79,
+    0x00, 0x53, 0x63, 0x68, 0x77, 0x61, 0x72, 0x7a, 0x00, 0x48, 0x75, 0x65,
+    0x79, 0x00, 0x47, 0x6f, 0x6f, 0x63, 0x68, 0x00, 0x41, 0x72, 0x63, 0x65,
+    0x00, 0x57, 0x68, 0x65, 0x61, 0x74, 0x00, 0x54, 0x72, 0x75, 0x6f, 0x6e,
+    0x67, 0x00, 0x50, 0x6f, 0x75, 0x6c, 0x69, 0x6e, 0x00, 0x4d, 0x61, 0x63,
+    0x6b, 0x65, 0x6e, 0x7a, 0x69, 0x65, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x65,
+    0x00, 0x48, 0x75, 0x72, 0x74, 0x61, 0x64, 0x6f, 0x00, 0x53, 0x65, 0x6c,
+    0x62, 0x79, 0x00, 0x47, 0x61, 0x69, 0x74, 0x68, 0x65, 0x72, 0x00, 0x46,
+    0x6f, 0x72, 0x74, 0x6e, 0x65, 0x72, 0x00, 0x43, 0x75, 0x6c, 0x70, 0x65,
+    0x70, 0x70, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x75, 0x67, 0x68, 0x6c, 0x69,
+    0x6e, 0x00, 0x42, 0x72, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x6f,
+    0x75, 0x64, 0x72, 0x65, 0x61, 0x75, 0x00, 0x42, 0x61, 0x72, 0x6b, 0x6c,
+    0x65, 0x79, 0x00, 0x42, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x53, 0x74, 0x65,
+    0x70, 0x70, 0x00, 0x48, 0x6f, 0x6c, 0x6d, 0x00, 0x54, 0x61, 0x6e, 0x00,
+    0x53, 0x63, 0x68, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x4d, 0x6f,
+    0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x4b, 0x61, 0x68, 0x6e, 0x00, 0x48,
+    0x65, 0x61, 0x74, 0x6f, 0x6e, 0x00, 0x47, 0x61, 0x6d, 0x65, 0x7a, 0x00,
+    0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x43, 0x61, 0x75,
+    0x73, 0x65, 0x79, 0x00, 0x42, 0x72, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x73,
+    0x00, 0x54, 0x75, 0x72, 0x70, 0x69, 0x6e, 0x00, 0x53, 0x68, 0x61, 0x6e,
+    0x6b, 0x73, 0x00, 0x53, 0x63, 0x68, 0x72, 0x61, 0x64, 0x65, 0x72, 0x00,
+    0x4d, 0x65, 0x65, 0x6b, 0x00, 0x49, 0x73, 0x6f, 0x6d, 0x00, 0x48, 0x61,
+    0x72, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x72, 0x61,
+    0x6e, 0x7a, 0x61, 0x00, 0x59, 0x61, 0x6e, 0x65, 0x7a, 0x00, 0x57, 0x61,
+    0x79, 0x00, 0x53, 0x63, 0x72, 0x6f, 0x67, 0x67, 0x69, 0x6e, 0x73, 0x00,
+    0x53, 0x63, 0x68, 0x6f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x52, 0x75,
+    0x6e, 0x79, 0x6f, 0x6e, 0x00, 0x52, 0x61, 0x74, 0x63, 0x6c, 0x69, 0x66,
+    0x66, 0x00, 0x4d, 0x75, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x6f,
+    0x65, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x49, 0x72, 0x62, 0x79, 0x00, 0x43,
+    0x75, 0x72, 0x72, 0x69, 0x65, 0x72, 0x00, 0x42, 0x75, 0x74, 0x74, 0x65,
+    0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x59, 0x65, 0x65, 0x00, 0x52,
+    0x61, 0x6c, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x50, 0x75, 0x6c, 0x6c, 0x65,
+    0x6e, 0x00, 0x50, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x45, 0x73, 0x74,
+    0x65, 0x70, 0x00, 0x45, 0x61, 0x73, 0x74, 0x00, 0x43, 0x61, 0x72, 0x62,
+    0x6f, 0x6e, 0x65, 0x00, 0x4c, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x48, 0x61,
+    0x77, 0x6b, 0x73, 0x00, 0x45, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x00, 0x43, 0x61, 0x73, 0x69, 0x6c, 0x6c, 0x61, 0x73, 0x00, 0x53,
+    0x70, 0x75, 0x72, 0x6c, 0x6f, 0x63, 0x6b, 0x00, 0x53, 0x69, 0x6b, 0x65,
+    0x73, 0x00, 0x4d, 0x6f, 0x74, 0x6c, 0x65, 0x79, 0x00, 0x4d, 0x63, 0x63,
+    0x61, 0x72, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x4b, 0x72, 0x75, 0x67, 0x65,
+    0x72, 0x00, 0x49, 0x73, 0x62, 0x65, 0x6c, 0x6c, 0x00, 0x48, 0x6f, 0x75,
+    0x6c, 0x65, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x69, 0x73, 0x63, 0x6f,
+    0x00, 0x42, 0x75, 0x72, 0x6b, 0x00, 0x42, 0x6f, 0x6e, 0x65, 0x00, 0x54,
+    0x6f, 0x6d, 0x6c, 0x69, 0x6e, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x62, 0x79,
+    0x00, 0x51, 0x75, 0x69, 0x67, 0x6c, 0x65, 0x79, 0x00, 0x4e, 0x65, 0x75,
+    0x6d, 0x61, 0x6e, 0x6e, 0x00, 0x4c, 0x6f, 0x76, 0x65, 0x6c, 0x61, 0x63,
+    0x65, 0x00, 0x46, 0x65, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x43, 0x6f,
+    0x6c, 0x62, 0x79, 0x00, 0x43, 0x68, 0x65, 0x61, 0x74, 0x68, 0x61, 0x6d,
+    0x00, 0x42, 0x75, 0x73, 0x74, 0x61, 0x6d, 0x61, 0x6e, 0x74, 0x65, 0x00,
+    0x53, 0x6b, 0x69, 0x64, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x48, 0x69, 0x64,
+    0x61, 0x6c, 0x67, 0x6f, 0x00, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x00,
+    0x43, 0x75, 0x6c, 0x70, 0x00, 0x42, 0x6f, 0x77, 0x65, 0x6e, 0x73, 0x00,
+    0x42, 0x65, 0x74, 0x61, 0x6e, 0x63, 0x6f, 0x75, 0x72, 0x74, 0x00, 0x41,
+    0x71, 0x75, 0x69, 0x6e, 0x6f, 0x00, 0x52, 0x6f, 0x62, 0x62, 0x00, 0x52,
+    0x65, 0x61, 0x00, 0x4d, 0x69, 0x6c, 0x6e, 0x65, 0x72, 0x00, 0x4d, 0x61,
+    0x72, 0x74, 0x65, 0x6c, 0x00, 0x47, 0x72, 0x65, 0x73, 0x68, 0x61, 0x6d,
+    0x00, 0x57, 0x69, 0x6c, 0x65, 0x73, 0x00, 0x52, 0x69, 0x63, 0x6b, 0x65,
+    0x74, 0x74, 0x73, 0x00, 0x47, 0x61, 0x76, 0x69, 0x6e, 0x00, 0x44, 0x6f,
+    0x77, 0x64, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x7a, 0x6f, 0x00, 0x42,
+    0x6f, 0x73, 0x74, 0x69, 0x63, 0x00, 0x42, 0x6c, 0x61, 0x6b, 0x65, 0x6c,
+    0x79, 0x00, 0x53, 0x68, 0x65, 0x72, 0x72, 0x6f, 0x64, 0x00, 0x50, 0x6f,
+    0x77, 0x65, 0x72, 0x00, 0x4b, 0x65, 0x6e, 0x79, 0x6f, 0x6e, 0x00, 0x47,
+    0x61, 0x6e, 0x64, 0x79, 0x00, 0x45, 0x62, 0x65, 0x72, 0x74, 0x00, 0x44,
+    0x65, 0x6c, 0x6f, 0x61, 0x63, 0x68, 0x00, 0x43, 0x61, 0x72, 0x79, 0x00,
+    0x42, 0x75, 0x6c, 0x6c, 0x00, 0x41, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x00,
+    0x53, 0x61, 0x75, 0x65, 0x72, 0x00, 0x52, 0x6f, 0x62, 0x69, 0x6e, 0x73,
+    0x00, 0x4f, 0x6c, 0x69, 0x76, 0x61, 0x72, 0x65, 0x73, 0x00, 0x47, 0x69,
+    0x6c, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74,
+    0x6e, 0x75, 0x74, 0x00, 0x42, 0x6f, 0x75, 0x72, 0x71, 0x75, 0x65, 0x00,
+    0x50, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x4c, 0x79, 0x6d, 0x61, 0x6e, 0x00,
+    0x48, 0x69, 0x74, 0x65, 0x00, 0x48, 0x61, 0x75, 0x73, 0x65, 0x72, 0x00,
+    0x44, 0x65, 0x76, 0x6f, 0x72, 0x65, 0x00, 0x43, 0x72, 0x61, 0x77, 0x6c,
+    0x65, 0x79, 0x00, 0x43, 0x68, 0x61, 0x70, 0x61, 0x00, 0x56, 0x75, 0x00,
+    0x54, 0x6f, 0x62, 0x69, 0x61, 0x73, 0x00, 0x54, 0x61, 0x6c, 0x62, 0x65,
+    0x72, 0x74, 0x00, 0x50, 0x6f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x74, 0x65,
+    0x72, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x00, 0x4d, 0x65,
+    0x61, 0x64, 0x6f, 0x72, 0x00, 0x4d, 0x63, 0x64, 0x75, 0x66, 0x66, 0x69,
+    0x65, 0x00, 0x4d, 0x61, 0x74, 0x74, 0x6f, 0x78, 0x00, 0x4b, 0x72, 0x61,
+    0x75, 0x73, 0x00, 0x48, 0x61, 0x72, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x43,
+    0x68, 0x6f, 0x61, 0x74, 0x65, 0x00, 0x42, 0x65, 0x73, 0x73, 0x00, 0x57,
+    0x72, 0x65, 0x6e, 0x00, 0x53, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x00, 0x53,
+    0x61, 0x6e, 0x62, 0x6f, 0x72, 0x6e, 0x00, 0x4f, 0x75, 0x74, 0x6c, 0x61,
+    0x77, 0x00, 0x4b, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x47, 0x65, 0x61,
+    0x72, 0x79, 0x00, 0x43, 0x6f, 0x72, 0x6e, 0x77, 0x65, 0x6c, 0x6c, 0x00,
+    0x42, 0x61, 0x72, 0x63, 0x6c, 0x61, 0x79, 0x00, 0x41, 0x64, 0x61, 0x6d,
+    0x00, 0x41, 0x62, 0x6e, 0x65, 0x79, 0x00, 0x53, 0x65, 0x77, 0x61, 0x72,
+    0x64, 0x00, 0x52, 0x68, 0x6f, 0x61, 0x64, 0x73, 0x00, 0x48, 0x6f, 0x77,
+    0x6c, 0x61, 0x6e, 0x64, 0x00, 0x46, 0x6f, 0x72, 0x74, 0x69, 0x65, 0x72,
+    0x00, 0x45, 0x61, 0x73, 0x74, 0x65, 0x72, 0x00, 0x42, 0x65, 0x6e, 0x6e,
+    0x65, 0x72, 0x00, 0x56, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x54, 0x75, 0x62,
+    0x62, 0x73, 0x00, 0x54, 0x72, 0x6f, 0x75, 0x74, 0x6d, 0x61, 0x6e, 0x00,
+    0x52, 0x61, 0x70, 0x70, 0x00, 0x4e, 0x6f, 0x65, 0x00, 0x4d, 0x63, 0x63,
+    0x75, 0x72, 0x64, 0x79, 0x00, 0x48, 0x61, 0x72, 0x64, 0x65, 0x72, 0x00,
+    0x44, 0x65, 0x6c, 0x75, 0x63, 0x61, 0x00, 0x57, 0x65, 0x73, 0x74, 0x6d,
+    0x6f, 0x72, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x53, 0x6f, 0x75, 0x74,
+    0x68, 0x00, 0x48, 0x61, 0x76, 0x65, 0x6e, 0x73, 0x00, 0x47, 0x75, 0x61,
+    0x6a, 0x61, 0x72, 0x64, 0x6f, 0x00, 0x45, 0x6c, 0x79, 0x00, 0x43, 0x6c,
+    0x61, 0x72, 0x79, 0x00, 0x53, 0x65, 0x61, 0x6c, 0x00, 0x4d, 0x65, 0x65,
+    0x68, 0x61, 0x6e, 0x00, 0x48, 0x65, 0x72, 0x7a, 0x6f, 0x67, 0x00, 0x47,
+    0x75, 0x69, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x41, 0x73, 0x68, 0x63, 0x72,
+    0x61, 0x66, 0x74, 0x00, 0x57, 0x61, 0x75, 0x67, 0x68, 0x00, 0x52, 0x65,
+    0x6e, 0x6e, 0x65, 0x72, 0x00, 0x4d, 0x69, 0x6c, 0x61, 0x6d, 0x00, 0x4a,
+    0x75, 0x6e, 0x67, 0x00, 0x45, 0x6c, 0x72, 0x6f, 0x64, 0x00, 0x43, 0x68,
+    0x75, 0x72, 0x63, 0x68, 0x69, 0x6c, 0x6c, 0x00, 0x42, 0x75, 0x66, 0x6f,
+    0x72, 0x64, 0x00, 0x42, 0x72, 0x65, 0x61, 0x75, 0x78, 0x00, 0x42, 0x6f,
+    0x6c, 0x69, 0x6e, 0x00, 0x41, 0x73, 0x68, 0x65, 0x72, 0x00, 0x57, 0x69,
+    0x6e, 0x64, 0x68, 0x61, 0x6d, 0x00, 0x54, 0x69, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x50, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x4e,
+    0x6f, 0x6c, 0x65, 0x6e, 0x00, 0x4e, 0x6f, 0x6c, 0x61, 0x6e, 0x64, 0x00,
+    0x4b, 0x6e, 0x6f, 0x74, 0x74, 0x00, 0x45, 0x6d, 0x6d, 0x6f, 0x6e, 0x73,
+    0x00, 0x43, 0x6f, 0x72, 0x6e, 0x69, 0x73, 0x68, 0x00, 0x43, 0x68, 0x72,
+    0x69, 0x73, 0x74, 0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x6f,
+    0x77, 0x6e, 0x6c, 0x65, 0x65, 0x00, 0x42, 0x61, 0x72, 0x62, 0x65, 0x65,
+    0x00, 0x57, 0x61, 0x6c, 0x64, 0x72, 0x6f, 0x70, 0x00, 0x50, 0x69, 0x74,
+    0x74, 0x00, 0x4f, 0x6c, 0x76, 0x65, 0x72, 0x61, 0x00, 0x4c, 0x6f, 0x6d,
+    0x62, 0x61, 0x72, 0x64, 0x69, 0x00, 0x47, 0x72, 0x75, 0x62, 0x65, 0x72,
+    0x00, 0x47, 0x61, 0x66, 0x66, 0x6e, 0x65, 0x79, 0x00, 0x45, 0x67, 0x67,
+    0x6c, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x61, 0x6e, 0x64, 0x61,
+    0x00, 0x41, 0x72, 0x63, 0x68, 0x75, 0x6c, 0x65, 0x74, 0x61, 0x00, 0x53,
+    0x74, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x6c, 0x6f, 0x6e, 0x65, 0x00, 0x50,
+    0x72, 0x65, 0x77, 0x69, 0x74, 0x74, 0x00, 0x50, 0x66, 0x65, 0x69, 0x66,
+    0x66, 0x65, 0x72, 0x00, 0x4e, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x73, 0x00,
+    0x4d, 0x65, 0x6e, 0x61, 0x00, 0x4d, 0x63, 0x61, 0x64, 0x61, 0x6d, 0x73,
+    0x00, 0x48, 0x65, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x47, 0x61, 0x72,
+    0x64, 0x69, 0x6e, 0x65, 0x72, 0x00, 0x43, 0x72, 0x6f, 0x6d, 0x77, 0x65,
+    0x6c, 0x6c, 0x00, 0x43, 0x68, 0x69, 0x73, 0x68, 0x6f, 0x6c, 0x6d, 0x00,
+    0x42, 0x75, 0x72, 0x6c, 0x65, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x6f, 0x78,
+    0x00, 0x56, 0x65, 0x73, 0x74, 0x00, 0x4f, 0x67, 0x6c, 0x65, 0x73, 0x62,
+    0x79, 0x00, 0x4d, 0x63, 0x63, 0x61, 0x72, 0x74, 0x65, 0x72, 0x00, 0x4d,
+    0x61, 0x6c, 0x63, 0x6f, 0x6c, 0x6d, 0x00, 0x4c, 0x75, 0x6d, 0x70, 0x6b,
+    0x69, 0x6e, 0x00, 0x4c, 0x61, 0x72, 0x75, 0x65, 0x00, 0x47, 0x72, 0x65,
+    0x79, 0x00, 0x57, 0x6f, 0x66, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x56, 0x61,
+    0x6e, 0x68, 0x6f, 0x72, 0x6e, 0x00, 0x54, 0x68, 0x6f, 0x72, 0x6e, 0x00,
+    0x54, 0x65, 0x65, 0x6c, 0x00, 0x53, 0x77, 0x61, 0x66, 0x66, 0x6f, 0x72,
+    0x64, 0x00, 0x53, 0x74, 0x63, 0x6c, 0x61, 0x69, 0x72, 0x00, 0x53, 0x74,
+    0x61, 0x6e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x4f, 0x63, 0x61, 0x6d,
+    0x70, 0x6f, 0x00, 0x48, 0x65, 0x72, 0x72, 0x6d, 0x61, 0x6e, 0x6e, 0x00,
+    0x48, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x00, 0x41, 0x72, 0x73, 0x65, 0x6e,
+    0x61, 0x75, 0x6c, 0x74, 0x00, 0x52, 0x6f, 0x75, 0x73, 0x68, 0x00, 0x4d,
+    0x63, 0x61, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x72, 0x00, 0x48, 0x69, 0x61,
+    0x74, 0x74, 0x00, 0x47, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e,
+    0x00, 0x46, 0x6f, 0x72, 0x73, 0x79, 0x74, 0x68, 0x65, 0x00, 0x44, 0x75,
+    0x67, 0x67, 0x61, 0x6e, 0x00, 0x44, 0x65, 0x6c, 0x76, 0x61, 0x6c, 0x6c,
+    0x65, 0x00, 0x43, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x6e, 0x00, 0x57, 0x69,
+    0x6c, 0x6b, 0x73, 0x00, 0x57, 0x65, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x69,
+    0x6e, 0x00, 0x55, 0x72, 0x69, 0x62, 0x65, 0x00, 0x52, 0x69, 0x7a, 0x7a,
+    0x6f, 0x00, 0x4e, 0x6f, 0x79, 0x65, 0x73, 0x00, 0x4d, 0x63, 0x6c, 0x65,
+    0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x47, 0x75, 0x72, 0x6c, 0x65, 0x79, 0x00,
+    0x42, 0x65, 0x74, 0x68, 0x65, 0x61, 0x00, 0x57, 0x69, 0x6e, 0x73, 0x74,
+    0x65, 0x61, 0x64, 0x00, 0x4d, 0x61, 0x70, 0x6c, 0x65, 0x73, 0x00, 0x48,
+    0x61, 0x72, 0x72, 0x79, 0x00, 0x47, 0x75, 0x79, 0x74, 0x6f, 0x6e, 0x00,
+    0x47, 0x69, 0x6f, 0x72, 0x64, 0x61, 0x6e, 0x6f, 0x00, 0x41, 0x6c, 0x64,
+    0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x56, 0x61, 0x6c, 0x64, 0x65, 0x73,
+    0x00, 0x50, 0x6f, 0x6c, 0x61, 0x6e, 0x63, 0x6f, 0x00, 0x50, 0x61, 0x70,
+    0x70, 0x61, 0x73, 0x00, 0x4c, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x47,
+    0x72, 0x6f, 0x67, 0x61, 0x6e, 0x00, 0x47, 0x72, 0x69, 0x66, 0x66, 0x69,
+    0x74, 0x68, 0x73, 0x00, 0x42, 0x6f, 0x62, 0x6f, 0x00, 0x41, 0x72, 0x65,
+    0x76, 0x61, 0x6c, 0x6f, 0x00, 0x57, 0x68, 0x69, 0x74, 0x73, 0x6f, 0x6e,
+    0x00, 0x53, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x52, 0x65, 0x6e, 0x64,
+    0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x74, 0x74, 0x68, 0x65, 0x77, 0x00, 0x4a,
+    0x75, 0x6c, 0x69, 0x61, 0x6e, 0x00, 0x46, 0x65, 0x72, 0x6e, 0x61, 0x6e,
+    0x64, 0x65, 0x73, 0x00, 0x46, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x00, 0x45,
+    0x64, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x42, 0x65, 0x6e, 0x61, 0x76, 0x69,
+    0x64, 0x65, 0x7a, 0x00, 0x41, 0x79, 0x72, 0x65, 0x73, 0x00, 0x41, 0x6c,
+    0x69, 0x63, 0x65, 0x61, 0x00, 0x53, 0x74, 0x75, 0x6d, 0x70, 0x00, 0x53,
+    0x6d, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x65, 0x69, 0x74, 0x7a,
+    0x00, 0x53, 0x63, 0x68, 0x75, 0x6c, 0x74, 0x65, 0x00, 0x47, 0x69, 0x6c,
+    0x6c, 0x65, 0x79, 0x00, 0x47, 0x61, 0x6c, 0x6c, 0x61, 0x6e, 0x74, 0x00,
+    0x44, 0x65, 0x77, 0x65, 0x79, 0x00, 0x43, 0x61, 0x73, 0x70, 0x65, 0x72,
+    0x00, 0x43, 0x61, 0x6e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x57, 0x6f,
+    0x6c, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x4f, 0x6d, 0x61, 0x6c, 0x6c, 0x65,
+    0x79, 0x00, 0x4d, 0x63, 0x6e, 0x75, 0x74, 0x74, 0x00, 0x4d, 0x63, 0x6e,
+    0x75, 0x6c, 0x74, 0x79, 0x00, 0x4d, 0x63, 0x67, 0x6f, 0x76, 0x65, 0x72,
+    0x6e, 0x00, 0x48, 0x61, 0x72, 0x64, 0x6d, 0x61, 0x6e, 0x00, 0x48, 0x61,
+    0x72, 0x62, 0x69, 0x6e, 0x00, 0x43, 0x6f, 0x77, 0x61, 0x72, 0x74, 0x00,
+    0x43, 0x68, 0x61, 0x76, 0x61, 0x72, 0x72, 0x69, 0x61, 0x00, 0x42, 0x72,
+    0x69, 0x6e, 0x6b, 0x00, 0x42, 0x65, 0x63, 0x6b, 0x65, 0x74, 0x74, 0x00,
+    0x42, 0x61, 0x67, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x41, 0x72, 0x6d, 0x73,
+    0x74, 0x65, 0x61, 0x64, 0x00, 0x41, 0x6e, 0x67, 0x6c, 0x69, 0x6e, 0x00,
+    0x41, 0x62, 0x72, 0x65, 0x75, 0x00, 0x52, 0x65, 0x79, 0x6e, 0x6f, 0x73,
+    0x6f, 0x00, 0x4b, 0x72, 0x65, 0x62, 0x73, 0x00, 0x4a, 0x65, 0x74, 0x74,
+    0x00, 0x48, 0x6f, 0x66, 0x66, 0x6d, 0x61, 0x6e, 0x6e, 0x00, 0x47, 0x72,
+    0x65, 0x65, 0x6e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x46, 0x6f, 0x72,
+    0x74, 0x65, 0x00, 0x42, 0x75, 0x72, 0x6e, 0x65, 0x79, 0x00, 0x42, 0x72,
+    0x6f, 0x6f, 0x6d, 0x65, 0x00, 0x53, 0x69, 0x73, 0x73, 0x6f, 0x6e, 0x00,
+    0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x4a, 0x75, 0x64, 0x65, 0x00,
+    0x59, 0x6f, 0x75, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x54, 0x72, 0x61, 0x6d,
+    0x6d, 0x65, 0x6c, 0x6c, 0x00, 0x50, 0x61, 0x72, 0x74, 0x72, 0x69, 0x64,
+    0x67, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x76, 0x69, 0x6e, 0x00, 0x4d, 0x61,
+    0x63, 0x65, 0x00, 0x4c, 0x6f, 0x6d, 0x61, 0x78, 0x00, 0x4c, 0x65, 0x6d,
+    0x69, 0x65, 0x75, 0x78, 0x00, 0x47, 0x6f, 0x73, 0x73, 0x65, 0x74, 0x74,
+    0x00, 0x46, 0x72, 0x61, 0x6e, 0x74, 0x7a, 0x00, 0x46, 0x6f, 0x67, 0x6c,
+    0x65, 0x00, 0x43, 0x6f, 0x6f, 0x6e, 0x65, 0x79, 0x00, 0x42, 0x72, 0x6f,
+    0x75, 0x67, 0x68, 0x74, 0x6f, 0x6e, 0x00, 0x50, 0x65, 0x6e, 0x63, 0x65,
+    0x00, 0x50, 0x61, 0x75, 0x6c, 0x73, 0x65, 0x6e, 0x00, 0x4e, 0x65, 0x69,
+    0x6c, 0x00, 0x4d, 0x75, 0x6e, 0x63, 0x79, 0x00, 0x4d, 0x63, 0x61, 0x72,
+    0x74, 0x68, 0x75, 0x72, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x73,
+    0x00, 0x45, 0x64, 0x77, 0x61, 0x72, 0x64, 0x00, 0x42, 0x65, 0x61, 0x75,
+    0x63, 0x68, 0x61, 0x6d, 0x70, 0x00, 0x57, 0x69, 0x74, 0x68, 0x65, 0x72,
+    0x73, 0x00, 0x4f, 0x73, 0x6f, 0x72, 0x69, 0x6f, 0x00, 0x4d, 0x75, 0x6c,
+    0x6c, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x48, 0x6f, 0x79, 0x6c, 0x65, 0x00,
+    0x46, 0x6f, 0x79, 0x00, 0x44, 0x6f, 0x63, 0x6b, 0x65, 0x72, 0x79, 0x00,
+    0x43, 0x6f, 0x63, 0x6b, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x42, 0x65, 0x67,
+    0x6c, 0x65, 0x79, 0x00, 0x41, 0x6d, 0x61, 0x64, 0x6f, 0x72, 0x00, 0x52,
+    0x6f, 0x62, 0x79, 0x00, 0x52, 0x61, 0x69, 0x6e, 0x73, 0x00, 0x4c, 0x69,
+    0x6e, 0x64, 0x71, 0x75, 0x69, 0x73, 0x74, 0x00, 0x47, 0x65, 0x6e, 0x74,
+    0x69, 0x6c, 0x65, 0x00, 0x45, 0x76, 0x65, 0x72, 0x68, 0x61, 0x72, 0x74,
+    0x00, 0x42, 0x6f, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x00, 0x57, 0x79,
+    0x6c, 0x69, 0x65, 0x00, 0x54, 0x68, 0x61, 0x6f, 0x00, 0x53, 0x6f, 0x6d,
+    0x6d, 0x65, 0x72, 0x73, 0x00, 0x50, 0x75, 0x72, 0x6e, 0x65, 0x6c, 0x6c,
+    0x00, 0x50, 0x61, 0x6c, 0x6d, 0x61, 0x00, 0x46, 0x6f, 0x72, 0x74, 0x69,
+    0x6e, 0x00, 0x44, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x42, 0x72,
+    0x65, 0x65, 0x64, 0x65, 0x6e, 0x00, 0x56, 0x61, 0x69, 0x6c, 0x00, 0x50,
+    0x68, 0x65, 0x6c, 0x61, 0x6e, 0x00, 0x50, 0x68, 0x61, 0x6e, 0x00, 0x4d,
+    0x61, 0x72, 0x78, 0x00, 0x43, 0x6f, 0x73, 0x62, 0x79, 0x00, 0x43, 0x6f,
+    0x6c, 0x62, 0x75, 0x72, 0x6e, 0x00, 0x43, 0x68, 0x6f, 0x6e, 0x67, 0x00,
+    0x42, 0x6f, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x42, 0x69, 0x64, 0x64, 0x6c,
+    0x65, 0x00, 0x4c, 0x65, 0x64, 0x65, 0x73, 0x6d, 0x61, 0x00, 0x47, 0x61,
+    0x64, 0x64, 0x69, 0x73, 0x00, 0x44, 0x65, 0x6e, 0x6e, 0x65, 0x79, 0x00,
+    0x43, 0x68, 0x6f, 0x77, 0x00, 0x42, 0x75, 0x65, 0x6e, 0x6f, 0x00, 0x42,
+    0x65, 0x72, 0x72, 0x69, 0x6f, 0x73, 0x00, 0x57, 0x69, 0x63, 0x6b, 0x65,
+    0x72, 0x00, 0x54, 0x6f, 0x6c, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x00, 0x54,
+    0x68, 0x69, 0x62, 0x6f, 0x64, 0x65, 0x61, 0x75, 0x78, 0x00, 0x4e, 0x61,
+    0x67, 0x6c, 0x65, 0x00, 0x4c, 0x61, 0x76, 0x6f, 0x69, 0x65, 0x00, 0x46,
+    0x69, 0x73, 0x6b, 0x00, 0x44, 0x6f, 0x00, 0x43, 0x72, 0x69, 0x73, 0x74,
+    0x00, 0x42, 0x61, 0x72, 0x62, 0x6f, 0x73, 0x61, 0x00, 0x52, 0x65, 0x65,
+    0x64, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x4c, 0x6f, 0x63,
+    0x6b, 0x6c, 0x65, 0x61, 0x72, 0x00, 0x4b, 0x6f, 0x6c, 0x62, 0x00, 0x48,
+    0x69, 0x6d, 0x65, 0x73, 0x00, 0x42, 0x65, 0x68, 0x72, 0x65, 0x6e, 0x73,
+    0x00, 0x42, 0x65, 0x63, 0x6b, 0x77, 0x69, 0x74, 0x68, 0x00, 0x42, 0x65,
+    0x63, 0x6b, 0x68, 0x61, 0x6d, 0x00, 0x57, 0x65, 0x65, 0x6d, 0x73, 0x00,
+    0x57, 0x61, 0x68, 0x6c, 0x00, 0x53, 0x68, 0x6f, 0x72, 0x74, 0x65, 0x72,
+    0x00, 0x53, 0x68, 0x61, 0x63, 0x6b, 0x65, 0x6c, 0x66, 0x6f, 0x72, 0x64,
+    0x00, 0x52, 0x65, 0x65, 0x73, 0x00, 0x4d, 0x75, 0x73, 0x65, 0x00, 0x46,
+    0x72, 0x65, 0x65, 0x00, 0x43, 0x65, 0x72, 0x64, 0x61, 0x00, 0x56, 0x61,
+    0x6c, 0x61, 0x64, 0x65, 0x7a, 0x00, 0x54, 0x68, 0x69, 0x62, 0x6f, 0x64,
+    0x65, 0x61, 0x75, 0x00, 0x53, 0x61, 0x61, 0x76, 0x65, 0x64, 0x72, 0x61,
+    0x00, 0x52, 0x69, 0x64, 0x67, 0x65, 0x77, 0x61, 0x79, 0x00, 0x52, 0x65,
+    0x69, 0x74, 0x65, 0x72, 0x00, 0x4d, 0x63, 0x68, 0x65, 0x6e, 0x72, 0x79,
+    0x00, 0x4d, 0x61, 0x6a, 0x6f, 0x72, 0x73, 0x00, 0x4c, 0x61, 0x63, 0x68,
+    0x61, 0x6e, 0x63, 0x65, 0x00, 0x4b, 0x65, 0x61, 0x74, 0x6f, 0x6e, 0x00,
+    0x49, 0x73, 0x72, 0x61, 0x65, 0x6c, 0x00, 0x46, 0x65, 0x72, 0x72, 0x61,
+    0x72, 0x61, 0x00, 0x46, 0x61, 0x6c, 0x63, 0x6f, 0x6e, 0x00, 0x43, 0x6c,
+    0x65, 0x6d, 0x65, 0x6e, 0x73, 0x00, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x65,
+    0x72, 0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x00,
+    0x50, 0x61, 0x7a, 0x00, 0x4e, 0x65, 0x65, 0x64, 0x68, 0x61, 0x6d, 0x00,
+    0x4d, 0x6f, 0x6a, 0x69, 0x63, 0x61, 0x00, 0x4b, 0x75, 0x79, 0x6b, 0x65,
+    0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x00, 0x48, 0x61, 0x6d, 0x65, 0x6c, 0x00,
+    0x45, 0x73, 0x63, 0x61, 0x6d, 0x69, 0x6c, 0x6c, 0x61, 0x00, 0x44, 0x6f,
+    0x75, 0x67, 0x68, 0x74, 0x79, 0x00, 0x42, 0x75, 0x72, 0x63, 0x68, 0x65,
+    0x74, 0x74, 0x00, 0x41, 0x69, 0x6e, 0x73, 0x77, 0x6f, 0x72, 0x74, 0x68,
+    0x00, 0x57, 0x69, 0x6c, 0x62, 0x75, 0x72, 0x00, 0x56, 0x69, 0x64, 0x61,
+    0x6c, 0x00, 0x55, 0x70, 0x63, 0x68, 0x75, 0x72, 0x63, 0x68, 0x00, 0x54,
+    0x68, 0x69, 0x67, 0x70, 0x65, 0x6e, 0x00, 0x53, 0x74, 0x72, 0x61, 0x75,
+    0x73, 0x73, 0x00, 0x53, 0x70, 0x72, 0x75, 0x69, 0x6c, 0x6c, 0x00, 0x53,
+    0x6f, 0x77, 0x65, 0x72, 0x73, 0x00, 0x52, 0x69, 0x67, 0x67, 0x69, 0x6e,
+    0x73, 0x00, 0x52, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x00, 0x4d, 0x63, 0x63,
+    0x6f, 0x6d, 0x62, 0x73, 0x00, 0x48, 0x61, 0x72, 0x6c, 0x6f, 0x77, 0x00,
+    0x47, 0x61, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x00, 0x42, 0x75, 0x66, 0x66,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x59, 0x69, 0x00, 0x53, 0x6f,
+    0x74, 0x65, 0x6c, 0x6f, 0x00, 0x4f, 0x6c, 0x69, 0x76, 0x61, 0x73, 0x00,
+    0x4e, 0x65, 0x67, 0x72, 0x65, 0x74, 0x65, 0x00, 0x4d, 0x6f, 0x72, 0x65,
+    0x79, 0x00, 0x4d, 0x61, 0x63, 0x6f, 0x6e, 0x00, 0x4c, 0x6f, 0x67, 0x73,
+    0x64, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65,
+    0x00, 0x46, 0x6c, 0x6f, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x43, 0x61,
+    0x74, 0x68, 0x65, 0x79, 0x00, 0x42, 0x69, 0x67, 0x65, 0x6c, 0x6f, 0x77,
+    0x00, 0x42, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x57, 0x65, 0x73, 0x74, 0x66,
+    0x61, 0x6c, 0x6c, 0x00, 0x53, 0x74, 0x75, 0x62, 0x62, 0x6c, 0x65, 0x66,
+    0x69, 0x65, 0x6c, 0x64, 0x00, 0x50, 0x65, 0x61, 0x6b, 0x00, 0x4c, 0x69,
+    0x6e, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x72, 0x65,
+    0x79, 0x00, 0x48, 0x65, 0x69, 0x6e, 0x00, 0x48, 0x61, 0x77, 0x65, 0x73,
+    0x00, 0x46, 0x61, 0x72, 0x72, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00,
+    0x45, 0x64, 0x67, 0x65, 0x00, 0x42, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x42,
+    0x69, 0x72, 0x63, 0x68, 0x00, 0x57, 0x69, 0x6c, 0x64, 0x65, 0x00, 0x53,
+    0x74, 0x65, 0x65, 0x64, 0x00, 0x53, 0x65, 0x70, 0x75, 0x6c, 0x76, 0x65,
+    0x64, 0x61, 0x00, 0x52, 0x65, 0x69, 0x6e, 0x68, 0x61, 0x72, 0x64, 0x74,
+    0x00, 0x50, 0x72, 0x6f, 0x66, 0x66, 0x69, 0x74, 0x74, 0x00, 0x4d, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x4d, 0x65, 0x73, 0x73, 0x69, 0x6e, 0x61,
+    0x00, 0x4d, 0x63, 0x6e, 0x61, 0x62, 0x62, 0x00, 0x4d, 0x61, 0x69, 0x65,
+    0x72, 0x00, 0x4b, 0x65, 0x65, 0x6c, 0x65, 0x72, 0x00, 0x47, 0x61, 0x6d,
+    0x62, 0x6f, 0x61, 0x00, 0x44, 0x6f, 0x6e, 0x6f, 0x68, 0x75, 0x65, 0x00,
+    0x44, 0x65, 0x78, 0x74, 0x65, 0x72, 0x00, 0x42, 0x61, 0x73, 0x68, 0x61,
+    0x6d, 0x00, 0x53, 0x68, 0x69, 0x6e, 0x6e, 0x00, 0x4f, 0x72, 0x6c, 0x61,
+    0x6e, 0x64, 0x6f, 0x00, 0x43, 0x72, 0x6f, 0x6f, 0x6b, 0x73, 0x00, 0x43,
+    0x6f, 0x74, 0x61, 0x00, 0x42, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x00,
+    0x42, 0x69, 0x6c, 0x6c, 0x73, 0x00, 0x42, 0x61, 0x63, 0x68, 0x6d, 0x61,
+    0x6e, 0x00, 0x54, 0x69, 0x73, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x54, 0x61,
+    0x76, 0x61, 0x72, 0x65, 0x73, 0x00, 0x53, 0x63, 0x68, 0x6d, 0x69, 0x64,
+    0x00, 0x50, 0x69, 0x63, 0x6b, 0x61, 0x72, 0x64, 0x00, 0x4a, 0x61, 0x73,
+    0x70, 0x65, 0x72, 0x00, 0x47, 0x75, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x46,
+    0x6f, 0x6e, 0x73, 0x65, 0x63, 0x61, 0x00, 0x44, 0x65, 0x6c, 0x6f, 0x73,
+    0x73, 0x61, 0x6e, 0x74, 0x6f, 0x73, 0x00, 0x43, 0x6f, 0x6e, 0x64, 0x6f,
+    0x6e, 0x00, 0x43, 0x6c, 0x61, 0x6e, 0x63, 0x79, 0x00, 0x42, 0x61, 0x74,
+    0x69, 0x73, 0x74, 0x61, 0x00, 0x57, 0x69, 0x63, 0x6b, 0x73, 0x00, 0x57,
+    0x61, 0x64, 0x73, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x00, 0x4e, 0x65, 0x77,
+    0x00, 0x4d, 0x61, 0x72, 0x74, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x6f, 0x00,
+    0x4c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x49, 0x73,
+    0x6f, 0x6e, 0x00, 0x48, 0x61, 0x61, 0x67, 0x00, 0x46, 0x6f, 0x6c, 0x73,
+    0x6f, 0x6d, 0x00, 0x42, 0x72, 0x75, 0x6d, 0x66, 0x69, 0x65, 0x6c, 0x64,
+    0x00, 0x42, 0x72, 0x6f, 0x79, 0x6c, 0x65, 0x73, 0x00, 0x42, 0x72, 0x69,
+    0x74, 0x6f, 0x00, 0x4d, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x00, 0x4d,
+    0x63, 0x64, 0x6f, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x65, 0x63,
+    0x6c, 0x61, 0x69, 0x72, 0x00, 0x48, 0x61, 0x6d, 0x62, 0x6c, 0x69, 0x6e,
+    0x00, 0x47, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x46, 0x61, 0x6e, 0x6e, 0x69,
+    0x6e, 0x67, 0x00, 0x42, 0x69, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x57, 0x69,
+    0x6e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x57, 0x68, 0x69, 0x74, 0x77,
+    0x6f, 0x72, 0x74, 0x68, 0x00, 0x53, 0x6f, 0x72, 0x69, 0x61, 0x6e, 0x6f,
+    0x00, 0x50, 0x61, 0x6c, 0x75, 0x6d, 0x62, 0x6f, 0x00, 0x4e, 0x65, 0x77,
+    0x6b, 0x69, 0x72, 0x6b, 0x00, 0x4d, 0x61, 0x6e, 0x67, 0x75, 0x6d, 0x00,
+    0x48, 0x75, 0x74, 0x63, 0x68, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x43,
+    0x6f, 0x6d, 0x73, 0x74, 0x6f, 0x63, 0x6b, 0x00, 0x43, 0x65, 0x63, 0x69,
+    0x6c, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x69, 0x6e, 0x00, 0x42, 0x65, 0x61,
+    0x6c, 0x6c, 0x00, 0x42, 0x61, 0x69, 0x72, 0x00, 0x57, 0x65, 0x6e, 0x64,
+    0x74, 0x00, 0x57, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x00, 0x57, 0x61,
+    0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x50, 0x75, 0x74, 0x6d, 0x61, 0x6e,
+    0x00, 0x4f, 0x74, 0x6f, 0x6f, 0x6c, 0x65, 0x00, 0x4f, 0x6c, 0x69, 0x76,
+    0x61, 0x00, 0x4d, 0x6f, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x4d, 0x61, 0x72,
+    0x65, 0x73, 0x00, 0x4c, 0x65, 0x6d, 0x75, 0x73, 0x00, 0x4b, 0x65, 0x65,
+    0x6e, 0x65, 0x72, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x79, 0x00,
+    0x48, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x44, 0x69, 0x61, 0x6c,
+    0x00, 0x44, 0x61, 0x6d, 0x69, 0x63, 0x6f, 0x00, 0x42, 0x69, 0x6c, 0x6c,
+    0x75, 0x70, 0x73, 0x00, 0x53, 0x74, 0x72, 0x6f, 0x74, 0x68, 0x65, 0x72,
+    0x00, 0x4d, 0x63, 0x66, 0x61, 0x72, 0x6c, 0x61, 0x6e, 0x65, 0x00, 0x4c,
+    0x61, 0x6d, 0x6d, 0x00, 0x45, 0x61, 0x76, 0x65, 0x73, 0x00, 0x43, 0x72,
+    0x75, 0x74, 0x63, 0x68, 0x65, 0x72, 0x00, 0x43, 0x61, 0x72, 0x61, 0x62,
+    0x61, 0x6c, 0x6c, 0x6f, 0x00, 0x43, 0x61, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x74, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x54, 0x61, 0x66, 0x74, 0x00, 0x53,
+    0x69, 0x6c, 0x65, 0x72, 0x00, 0x52, 0x75, 0x73, 0x74, 0x00, 0x52, 0x61,
+    0x77, 0x6c, 0x73, 0x00, 0x52, 0x61, 0x77, 0x6c, 0x69, 0x6e, 0x67, 0x73,
+    0x00, 0x50, 0x72, 0x69, 0x65, 0x74, 0x6f, 0x00, 0x4e, 0x69, 0x6c, 0x65,
+    0x73, 0x00, 0x4d, 0x63, 0x6e, 0x65, 0x65, 0x6c, 0x79, 0x00, 0x4d, 0x63,
+    0x61, 0x66, 0x65, 0x65, 0x00, 0x48, 0x75, 0x6c, 0x73, 0x65, 0x79, 0x00,
+    0x48, 0x61, 0x72, 0x6c, 0x61, 0x6e, 0x00, 0x48, 0x61, 0x63, 0x6b, 0x6e,
+    0x65, 0x79, 0x00, 0x47, 0x61, 0x6c, 0x76, 0x65, 0x7a, 0x00, 0x45, 0x73,
+    0x63, 0x61, 0x6c, 0x61, 0x6e, 0x74, 0x65, 0x00, 0x44, 0x65, 0x6c, 0x61,
+    0x67, 0x61, 0x72, 0x7a, 0x61, 0x00, 0x43, 0x72, 0x69, 0x64, 0x65, 0x72,
+    0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x61,
+    0x6e, 0x64, 0x79, 0x00, 0x57, 0x69, 0x6c, 0x62, 0x61, 0x6e, 0x6b, 0x73,
+    0x00, 0x53, 0x74, 0x6f, 0x77, 0x65, 0x00, 0x53, 0x74, 0x65, 0x69, 0x6e,
+    0x62, 0x65, 0x72, 0x67, 0x00, 0x53, 0x61, 0x6d, 0x73, 0x6f, 0x6e, 0x00,
+    0x52, 0x65, 0x6e, 0x66, 0x72, 0x6f, 0x00, 0x4d, 0x61, 0x73, 0x74, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x69, 0x65, 0x00,
+    0x4c, 0x61, 0x6e, 0x68, 0x61, 0x6d, 0x00, 0x48, 0x61, 0x73, 0x6b, 0x65,
+    0x6c, 0x6c, 0x00, 0x48, 0x61, 0x6d, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x46,
+    0x6f, 0x72, 0x74, 0x00, 0x44, 0x65, 0x68, 0x61, 0x72, 0x74, 0x00, 0x43,
+    0x61, 0x72, 0x64, 0x00, 0x42, 0x75, 0x72, 0x64, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x42, 0x72, 0x61, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x6f, 0x75,
+    0x72, 0x6e, 0x65, 0x00, 0x42, 0x61, 0x62, 0x69, 0x6e, 0x00, 0x41, 0x6c,
+    0x65, 0x6d, 0x61, 0x6e, 0x00, 0x57, 0x6f, 0x72, 0x74, 0x68, 0x79, 0x00,
+    0x54, 0x69, 0x62, 0x62, 0x73, 0x00, 0x53, 0x77, 0x65, 0x61, 0x74, 0x00,
+    0x53, 0x6d, 0x6f, 0x6f, 0x74, 0x00, 0x53, 0x6c, 0x61, 0x63, 0x6b, 0x00,
+    0x50, 0x61, 0x72, 0x61, 0x64, 0x69, 0x73, 0x00, 0x50, 0x61, 0x63, 0x6b,
+    0x61, 0x72, 0x64, 0x00, 0x4d, 0x75, 0x6c, 0x6c, 0x00, 0x4c, 0x75, 0x63,
+    0x65, 0x00, 0x48, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x6f, 0x6e, 0x00, 0x47,
+    0x61, 0x6e, 0x74, 0x74, 0x00, 0x46, 0x75, 0x72, 0x6d, 0x61, 0x6e, 0x00,
+    0x44, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73,
+    0x74, 0x69, 0x61, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x42, 0x75, 0x72, 0x67,
+    0x65, 0x00, 0x42, 0x72, 0x6f, 0x64, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x00,
+    0x41, 0x73, 0x68, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x41, 0x72, 0x6e, 0x64,
+    0x74, 0x00, 0x41, 0x6c, 0x6d, 0x65, 0x69, 0x64, 0x61, 0x00, 0x53, 0x74,
+    0x61, 0x6c, 0x6c, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x00, 0x53, 0x68, 0x61,
+    0x64, 0x65, 0x00, 0x53, 0x65, 0x61, 0x72, 0x63, 0x79, 0x00, 0x53, 0x61,
+    0x67, 0x65, 0x72, 0x00, 0x4e, 0x6f, 0x6f, 0x6e, 0x61, 0x6e, 0x00, 0x4d,
+    0x63, 0x6c, 0x65, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x4d, 0x63, 0x69, 0x6e,
+    0x74, 0x69, 0x72, 0x65, 0x00, 0x4d, 0x61, 0x78, 0x65, 0x79, 0x00, 0x4c,
+    0x61, 0x76, 0x69, 0x67, 0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x62, 0x65, 0x00,
+    0x49, 0x72, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x46, 0x65, 0x72, 0x72,
+    0x65, 0x72, 0x00, 0x46, 0x61, 0x6c, 0x6b, 0x00, 0x45, 0x64, 0x67, 0x61,
+    0x72, 0x00, 0x43, 0x6f, 0x66, 0x66, 0x69, 0x6e, 0x00, 0x42, 0x79, 0x72,
+    0x6e, 0x65, 0x73, 0x00, 0x41, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x00, 0x41,
+    0x70, 0x6f, 0x64, 0x61, 0x63, 0x61, 0x00, 0x53, 0x74, 0x61, 0x6d, 0x70,
+    0x73, 0x00, 0x52, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x00, 0x50, 0x65, 0x65,
+    0x6b, 0x00, 0x4f, 0x6c, 0x6d, 0x73, 0x74, 0x65, 0x61, 0x64, 0x00, 0x4c,
+    0x65, 0x77, 0x61, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x6b, 0x69, 0x00, 0x4b,
+    0x61, 0x6d, 0x69, 0x6e, 0x73, 0x6b, 0x69, 0x00, 0x48, 0x65, 0x72, 0x00,
+    0x44, 0x75, 0x6e, 0x61, 0x77, 0x61, 0x79, 0x00, 0x42, 0x72, 0x75, 0x6e,
+    0x73, 0x00, 0x42, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x74, 0x00, 0x41,
+    0x6d, 0x61, 0x74, 0x6f, 0x00, 0x52, 0x65, 0x69, 0x63, 0x68, 0x00, 0x4d,
+    0x63, 0x63, 0x6c, 0x75, 0x6e, 0x67, 0x00, 0x4c, 0x61, 0x63, 0x72, 0x6f,
+    0x69, 0x78, 0x00, 0x4b, 0x6f, 0x6f, 0x6e, 0x74, 0x7a, 0x00, 0x48, 0x65,
+    0x72, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x48, 0x61, 0x72, 0x64, 0x65, 0x73,
+    0x74, 0x79, 0x00, 0x46, 0x6c, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x00,
+    0x43, 0x6f, 0x75, 0x73, 0x69, 0x6e, 0x73, 0x00, 0x43, 0x6c, 0x6f, 0x73,
+    0x65, 0x00, 0x43, 0x61, 0x74, 0x6f, 0x00, 0x43, 0x61, 0x64, 0x65, 0x00,
+    0x56, 0x69, 0x63, 0x6b, 0x65, 0x72, 0x79, 0x00, 0x53, 0x68, 0x61, 0x6e,
+    0x6b, 0x00, 0x4e, 0x61, 0x67, 0x65, 0x6c, 0x00, 0x44, 0x75, 0x70, 0x75,
+    0x69, 0x73, 0x00, 0x43, 0x72, 0x6f, 0x74, 0x65, 0x61, 0x75, 0x00, 0x43,
+    0x6f, 0x74, 0x74, 0x65, 0x72, 0x00, 0x43, 0x61, 0x62, 0x6c, 0x65, 0x00,
+    0x53, 0x74, 0x75, 0x63, 0x6b, 0x65, 0x79, 0x00, 0x53, 0x74, 0x69, 0x6e,
+    0x65, 0x00, 0x50, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x66, 0x69, 0x65, 0x6c,
+    0x64, 0x00, 0x50, 0x61, 0x75, 0x6c, 0x65, 0x79, 0x00, 0x4e, 0x79, 0x65,
+    0x00, 0x4d, 0x6f, 0x66, 0x66, 0x69, 0x74, 0x74, 0x00, 0x4c, 0x75, 0x00,
+    0x4b, 0x6e, 0x75, 0x64, 0x73, 0x65, 0x6e, 0x00, 0x48, 0x61, 0x72, 0x64,
+    0x77, 0x69, 0x63, 0x6b, 0x00, 0x47, 0x6f, 0x66, 0x6f, 0x72, 0x74, 0x68,
+    0x00, 0x44, 0x75, 0x70, 0x6f, 0x6e, 0x74, 0x00, 0x42, 0x6c, 0x75, 0x6e,
+    0x74, 0x00, 0x42, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x73, 0x00, 0x42, 0x61,
+    0x72, 0x6e, 0x68, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x68, 0x75, 0x6c, 0x6c,
+    0x00, 0x52, 0x61, 0x73, 0x68, 0x00, 0x52, 0x61, 0x6c, 0x70, 0x68, 0x00,
+    0x50, 0x65, 0x6e, 0x6e, 0x79, 0x00, 0x4c, 0x6f, 0x72, 0x65, 0x6e, 0x7a,
+    0x6f, 0x00, 0x4c, 0x6f, 0x66, 0x74, 0x69, 0x73, 0x00, 0x4c, 0x65, 0x6d,
+    0x61, 0x79, 0x00, 0x4b, 0x69, 0x74, 0x63, 0x68, 0x65, 0x6e, 0x73, 0x00,
+    0x48, 0x6f, 0x72, 0x76, 0x61, 0x74, 0x68, 0x00, 0x47, 0x72, 0x65, 0x6e,
+    0x69, 0x65, 0x72, 0x00, 0x46, 0x75, 0x63, 0x68, 0x73, 0x00, 0x46, 0x61,
+    0x69, 0x72, 0x62, 0x61, 0x6e, 0x6b, 0x73, 0x00, 0x43, 0x75, 0x6c, 0x62,
+    0x65, 0x72, 0x74, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x6c, 0x6b, 0x69,
+    0x6e, 0x73, 0x00, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x00,
+    0x42, 0x65, 0x61, 0x74, 0x74, 0x69, 0x65, 0x00, 0x41, 0x73, 0x68, 0x77,
+    0x6f, 0x72, 0x74, 0x68, 0x00, 0x41, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x73,
+    0x6f, 0x6e, 0x00, 0x57, 0x65, 0x72, 0x74, 0x7a, 0x00, 0x56, 0x6f, 0x00,
+    0x56, 0x61, 0x75, 0x67, 0x68, 0x74, 0x00, 0x56, 0x61, 0x6c, 0x6c, 0x65,
+    0x6a, 0x6f, 0x00, 0x54, 0x79, 0x72, 0x65, 0x65, 0x00, 0x54, 0x75, 0x72,
+    0x6b, 0x00, 0x54, 0x75, 0x63, 0x6b, 0x00, 0x54, 0x69, 0x6a, 0x65, 0x72,
+    0x69, 0x6e, 0x61, 0x00, 0x53, 0x61, 0x67, 0x65, 0x00, 0x50, 0x69, 0x63,
+    0x61, 0x72, 0x64, 0x00, 0x50, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x61, 0x6e,
+    0x00, 0x4f, 0x74, 0x69, 0x73, 0x00, 0x4d, 0x61, 0x72, 0x72, 0x6f, 0x71,
+    0x75, 0x69, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x72, 0x00, 0x4c, 0x61, 0x6e,
+    0x74, 0x7a, 0x00, 0x48, 0x6f, 0x61, 0x6e, 0x67, 0x00, 0x44, 0x65, 0x6d,
+    0x61, 0x72, 0x63, 0x6f, 0x00, 0x44, 0x61, 0x69, 0x6c, 0x79, 0x00, 0x43,
+    0x6f, 0x6e, 0x65, 0x00, 0x42, 0x65, 0x72, 0x75, 0x62, 0x65, 0x00, 0x42,
+    0x61, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x65, 0x00, 0x57, 0x68, 0x61, 0x72,
+    0x74, 0x6f, 0x6e, 0x00, 0x53, 0x74, 0x69, 0x6e, 0x6e, 0x65, 0x74, 0x74,
+    0x00, 0x53, 0x6c, 0x6f, 0x63, 0x75, 0x6d, 0x00, 0x53, 0x63, 0x61, 0x6e,
+    0x6c, 0x6f, 0x6e, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x50,
+    0x69, 0x6e, 0x74, 0x6f, 0x00, 0x4d, 0x61, 0x6e, 0x63, 0x75, 0x73, 0x6f,
+    0x00, 0x4c, 0x69, 0x6d, 0x61, 0x00, 0x4a, 0x75, 0x64, 0x67, 0x65, 0x00,
+    0x48, 0x65, 0x61, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x45, 0x70, 0x73, 0x74,
+    0x65, 0x69, 0x6e, 0x00, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x00, 0x43,
+    0x6c, 0x61, 0x72, 0x6b, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x72, 0x6e,
+    0x61, 0x68, 0x61, 0x6e, 0x00, 0x42, 0x72, 0x69, 0x63, 0x65, 0x00, 0x42,
+    0x6f, 0x72, 0x65, 0x6e, 0x00, 0x41, 0x72, 0x74, 0x65, 0x61, 0x67, 0x61,
+    0x00, 0x41, 0x64, 0x61, 0x6d, 0x65, 0x00, 0x5a, 0x6f, 0x6f, 0x6b, 0x00,
+    0x57, 0x68, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x00, 0x57, 0x68, 0x69, 0x74,
+    0x65, 0x68, 0x75, 0x72, 0x73, 0x74, 0x00, 0x57, 0x65, 0x6e, 0x7a, 0x65,
+    0x6c, 0x00, 0x53, 0x61, 0x78, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x68, 0x65,
+    0x61, 0x00, 0x52, 0x65, 0x64, 0x64, 0x69, 0x63, 0x6b, 0x00, 0x50, 0x75,
+    0x65, 0x6e, 0x74, 0x65, 0x00, 0x48, 0x61, 0x7a, 0x65, 0x6c, 0x00, 0x48,
+    0x61, 0x6e, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x48, 0x61, 0x67, 0x67, 0x65,
+    0x72, 0x74, 0x79, 0x00, 0x45, 0x61, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x44,
+    0x65, 0x76, 0x6c, 0x69, 0x6e, 0x00, 0x44, 0x61, 0x6c, 0x6c, 0x61, 0x73,
+    0x00, 0x43, 0x68, 0x61, 0x66, 0x66, 0x69, 0x6e, 0x00, 0x43, 0x61, 0x64,
+    0x79, 0x00, 0x41, 0x68, 0x6d, 0x65, 0x64, 0x00, 0x41, 0x63, 0x75, 0x6e,
+    0x61, 0x00, 0x53, 0x6f, 0x6c, 0x61, 0x6e, 0x6f, 0x00, 0x53, 0x69, 0x67,
+    0x6c, 0x65, 0x72, 0x00, 0x50, 0x6f, 0x6c, 0x6c, 0x61, 0x63, 0x6b, 0x00,
+    0x50, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x67, 0x72, 0x61, 0x73, 0x73, 0x00,
+    0x4f, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x4a, 0x61,
+    0x6e, 0x65, 0x73, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x63, 0x6f, 0x69, 0x73,
+    0x00, 0x46, 0x69, 0x6e, 0x65, 0x00, 0x43, 0x72, 0x75, 0x74, 0x63, 0x68,
+    0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x43, 0x6f, 0x72, 0x64, 0x65, 0x6c,
+    0x6c, 0x00, 0x43, 0x68, 0x61, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x69, 0x6e,
+    0x00, 0x42, 0x72, 0x75, 0x62, 0x61, 0x6b, 0x65, 0x72, 0x00, 0x42, 0x61,
+    0x70, 0x74, 0x69, 0x73, 0x74, 0x65, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x73,
+    0x6f, 0x6e, 0x00, 0x52, 0x65, 0x69, 0x73, 0x00, 0x4e, 0x65, 0x65, 0x6c,
+    0x65, 0x79, 0x00, 0x4d, 0x75, 0x6c, 0x6c, 0x69, 0x6e, 0x00, 0x4d, 0x65,
+    0x72, 0x63, 0x69, 0x65, 0x72, 0x00, 0x4c, 0x69, 0x72, 0x61, 0x00, 0x4c,
+    0x61, 0x79, 0x6d, 0x61, 0x6e, 0x00, 0x4b, 0x65, 0x65, 0x6c, 0x69, 0x6e,
+    0x67, 0x00, 0x48, 0x69, 0x67, 0x64, 0x6f, 0x6e, 0x00, 0x47, 0x75, 0x65,
+    0x73, 0x74, 0x00, 0x46, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x74, 0x65, 0x72,
+    0x00, 0x45, 0x73, 0x70, 0x69, 0x6e, 0x61, 0x6c, 0x00, 0x44, 0x69, 0x6f,
+    0x6e, 0x00, 0x43, 0x68, 0x61, 0x70, 0x69, 0x6e, 0x00, 0x43, 0x61, 0x72,
+    0x6c, 0x00, 0x57, 0x61, 0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x54,
+    0x6f, 0x6c, 0x65, 0x64, 0x6f, 0x00, 0x50, 0x75, 0x6c, 0x69, 0x64, 0x6f,
+    0x00, 0x50, 0x65, 0x65, 0x62, 0x6c, 0x65, 0x73, 0x00, 0x4e, 0x61, 0x67,
+    0x79, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x67, 0x75, 0x65, 0x00, 0x4d,
+    0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x4c, 0x65, 0x61, 0x72, 0x00, 0x4a, 0x61,
+    0x65, 0x67, 0x65, 0x72, 0x00, 0x48, 0x6f, 0x67, 0x67, 0x00, 0x47, 0x72,
+    0x61, 0x66, 0x66, 0x00, 0x46, 0x75, 0x72, 0x72, 0x00, 0x44, 0x65, 0x72,
+    0x72, 0x69, 0x63, 0x6b, 0x00, 0x43, 0x61, 0x76, 0x65, 0x00, 0x43, 0x61,
+    0x6e, 0x61, 0x64, 0x61, 0x00, 0x53, 0x6f, 0x6c, 0x69, 0x7a, 0x00, 0x50,
+    0x6f, 0x6f, 0x72, 0x65, 0x00, 0x4d, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x68,
+    0x61, 0x6c, 0x6c, 0x00, 0x4d, 0x63, 0x6c, 0x61, 0x75, 0x72, 0x69, 0x6e,
+    0x00, 0x4d, 0x61, 0x65, 0x73, 0x74, 0x61, 0x73, 0x00, 0x4c, 0x6f, 0x77,
+    0x00, 0x47, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x42, 0x65, 0x6c, 0x74, 0x00,
+    0x42, 0x61, 0x72, 0x72, 0x61, 0x7a, 0x61, 0x00, 0x54, 0x69, 0x6c, 0x6c,
+    0x65, 0x72, 0x79, 0x00, 0x53, 0x6e, 0x65, 0x61, 0x64, 0x00, 0x50, 0x6f,
+    0x6e, 0x64, 0x00, 0x4e, 0x65, 0x69, 0x6c, 0x6c, 0x00, 0x4d, 0x63, 0x63,
+    0x75, 0x6c, 0x6c, 0x6f, 0x63, 0x68, 0x00, 0x4d, 0x63, 0x63, 0x6f, 0x72,
+    0x6b, 0x6c, 0x65, 0x00, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x66, 0x6f, 0x6f,
+    0x74, 0x00, 0x48, 0x75, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x00,
+    0x48, 0x6f, 0x6c, 0x6c, 0x6f, 0x6d, 0x61, 0x6e, 0x00, 0x48, 0x61, 0x72,
+    0x6e, 0x65, 0x73, 0x73, 0x00, 0x44, 0x6f, 0x72, 0x6e, 0x00, 0x43, 0x6f,
+    0x75, 0x6e, 0x63, 0x69, 0x6c, 0x00, 0x42, 0x6f, 0x63, 0x6b, 0x00, 0x5a,
+    0x69, 0x65, 0x6c, 0x69, 0x6e, 0x73, 0x6b, 0x69, 0x00, 0x54, 0x75, 0x72,
+    0x6c, 0x65, 0x79, 0x00, 0x54, 0x72, 0x65, 0x61, 0x64, 0x77, 0x65, 0x6c,
+    0x6c, 0x00, 0x53, 0x74, 0x70, 0x69, 0x65, 0x72, 0x72, 0x65, 0x00, 0x53,
+    0x74, 0x61, 0x72, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x53, 0x6f, 0x6d, 0x65,
+    0x72, 0x73, 0x00, 0x4f, 0x73, 0x77, 0x61, 0x6c, 0x64, 0x00, 0x4d, 0x65,
+    0x72, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x4d, 0x61, 0x72, 0x71, 0x75, 0x69,
+    0x73, 0x00, 0x49, 0x76, 0x6f, 0x72, 0x79, 0x00, 0x45, 0x61, 0x73, 0x74,
+    0x65, 0x72, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x42, 0x69, 0x76, 0x65, 0x6e,
+    0x73, 0x00, 0x54, 0x72, 0x75, 0x69, 0x74, 0x74, 0x00, 0x50, 0x6f, 0x73,
+    0x74, 0x6f, 0x6e, 0x00, 0x50, 0x61, 0x72, 0x72, 0x79, 0x00, 0x4f, 0x6e,
+    0x74, 0x69, 0x76, 0x65, 0x72, 0x6f, 0x73, 0x00, 0x4f, 0x6c, 0x69, 0x76,
+    0x61, 0x72, 0x65, 0x7a, 0x00, 0x4e, 0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65,
+    0x00, 0x4d, 0x6f, 0x72, 0x65, 0x61, 0x75, 0x00, 0x4d, 0x65, 0x64, 0x6c,
+    0x69, 0x6e, 0x00, 0x4d, 0x61, 0x00, 0x4c, 0x65, 0x6e, 0x7a, 0x00, 0x4b,
+    0x6e, 0x6f, 0x77, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x46, 0x61, 0x69, 0x72,
+    0x6c, 0x65, 0x79, 0x00, 0x43, 0x6f, 0x62, 0x62, 0x73, 0x00, 0x43, 0x68,
+    0x69, 0x73, 0x6f, 0x6c, 0x6d, 0x00, 0x42, 0x61, 0x6e, 0x6e, 0x69, 0x73,
+    0x74, 0x65, 0x72, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x77, 0x6f, 0x72, 0x74,
+    0x68, 0x00, 0x54, 0x6f, 0x6c, 0x65, 0x72, 0x00, 0x4f, 0x63, 0x61, 0x73,
+    0x69, 0x6f, 0x00, 0x4e, 0x6f, 0x72, 0x69, 0x65, 0x67, 0x61, 0x00, 0x4e,
+    0x65, 0x75, 0x6d, 0x61, 0x6e, 0x00, 0x4d, 0x6f, 0x79, 0x65, 0x00, 0x4d,
+    0x69, 0x6c, 0x62, 0x75, 0x72, 0x6e, 0x00, 0x4d, 0x63, 0x63, 0x6c, 0x61,
+    0x6e, 0x61, 0x68, 0x61, 0x6e, 0x00, 0x4c, 0x69, 0x6c, 0x6c, 0x65, 0x79,
+    0x00, 0x48, 0x61, 0x6e, 0x65, 0x73, 0x00, 0x46, 0x6c, 0x61, 0x6e, 0x6e,
+    0x65, 0x72, 0x79, 0x00, 0x44, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x65,
+    0x72, 0x00, 0x44, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x73, 0x6f, 0x6e, 0x00,
+    0x43, 0x6f, 0x6e, 0x74, 0x69, 0x00, 0x42, 0x6c, 0x6f, 0x64, 0x67, 0x65,
+    0x74, 0x74, 0x00, 0x42, 0x65, 0x65, 0x72, 0x73, 0x00, 0x57, 0x65, 0x61,
+    0x74, 0x68, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x53, 0x74, 0x72,
+    0x61, 0x69, 0x6e, 0x00, 0x4b, 0x61, 0x72, 0x72, 0x00, 0x48, 0x69, 0x74,
+    0x74, 0x00, 0x44, 0x65, 0x6e, 0x68, 0x61, 0x6d, 0x00, 0x43, 0x75, 0x73,
+    0x74, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x62, 0x6c, 0x65, 0x00, 0x43, 0x6c,
+    0x6f, 0x75, 0x67, 0x68, 0x00, 0x43, 0x61, 0x73, 0x74, 0x65, 0x65, 0x6c,
+    0x00, 0x42, 0x6f, 0x6c, 0x64, 0x75, 0x63, 0x00, 0x42, 0x61, 0x74, 0x63,
+    0x68, 0x65, 0x6c, 0x6f, 0x72, 0x00, 0x41, 0x6d, 0x6d, 0x6f, 0x6e, 0x73,
+    0x00, 0x57, 0x68, 0x69, 0x74, 0x6c, 0x6f, 0x77, 0x00, 0x54, 0x69, 0x65,
+    0x72, 0x6e, 0x65, 0x79, 0x00, 0x53, 0x74, 0x61, 0x74, 0x65, 0x6e, 0x00,
+    0x53, 0x69, 0x62, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x65, 0x69, 0x66, 0x65,
+    0x72, 0x74, 0x00, 0x53, 0x63, 0x68, 0x75, 0x62, 0x65, 0x72, 0x74, 0x00,
+    0x53, 0x61, 0x6c, 0x63, 0x65, 0x64, 0x6f, 0x00, 0x4d, 0x61, 0x74, 0x74,
+    0x69, 0x73, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x6e, 0x65, 0x79, 0x00, 0x48,
+    0x61, 0x67, 0x67, 0x61, 0x72, 0x64, 0x00, 0x47, 0x72, 0x6f, 0x6f, 0x6d,
+    0x73, 0x00, 0x44, 0x69, 0x78, 0x00, 0x44, 0x65, 0x65, 0x73, 0x00, 0x43,
+    0x72, 0x6f, 0x6d, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x6f, 0x6b, 0x73, 0x00,
+    0x43, 0x6f, 0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x73, 0x77, 0x65,
+    0x6c, 0x6c, 0x00, 0x5a, 0x61, 0x72, 0x61, 0x74, 0x65, 0x00, 0x53, 0x77,
+    0x69, 0x73, 0x68, 0x65, 0x72, 0x00, 0x53, 0x74, 0x61, 0x63, 0x65, 0x79,
+    0x00, 0x53, 0x68, 0x69, 0x6e, 0x00, 0x52, 0x61, 0x67, 0x61, 0x6e, 0x00,
+    0x50, 0x72, 0x69, 0x64, 0x67, 0x65, 0x6e, 0x00, 0x4d, 0x63, 0x76, 0x65,
+    0x79, 0x00, 0x4d, 0x61, 0x74, 0x68, 0x65, 0x6e, 0x79, 0x00, 0x4c, 0x65,
+    0x69, 0x67, 0x68, 0x00, 0x4c, 0x61, 0x66, 0x6c, 0x65, 0x75, 0x72, 0x00,
+    0x46, 0x72, 0x61, 0x6e, 0x7a, 0x00, 0x46, 0x65, 0x72, 0x72, 0x61, 0x72,
+    0x6f, 0x00, 0x44, 0x75, 0x67, 0x67, 0x65, 0x72, 0x00, 0x57, 0x68, 0x69,
+    0x74, 0x65, 0x73, 0x69, 0x64, 0x65, 0x00, 0x52, 0x69, 0x67, 0x73, 0x62,
+    0x79, 0x00, 0x4d, 0x63, 0x6d, 0x75, 0x72, 0x72, 0x61, 0x79, 0x00, 0x4c,
+    0x65, 0x68, 0x6d, 0x61, 0x6e, 0x6e, 0x00, 0x4c, 0x61, 0x72, 0x67, 0x65,
+    0x00, 0x4a, 0x61, 0x63, 0x6f, 0x62, 0x79, 0x00, 0x48, 0x69, 0x6c, 0x64,
+    0x65, 0x62, 0x72, 0x61, 0x6e, 0x64, 0x00, 0x48, 0x65, 0x6e, 0x64, 0x72,
+    0x69, 0x63, 0x6b, 0x00, 0x48, 0x65, 0x61, 0x64, 0x72, 0x69, 0x63, 0x6b,
+    0x00, 0x47, 0x6f, 0x61, 0x64, 0x00, 0x46, 0x69, 0x6e, 0x63, 0x68, 0x65,
+    0x72, 0x00, 0x44, 0x72, 0x75, 0x72, 0x79, 0x00, 0x42, 0x6f, 0x72, 0x67,
+    0x65, 0x73, 0x00, 0x41, 0x72, 0x63, 0x68, 0x69, 0x62, 0x61, 0x6c, 0x64,
+    0x00, 0x41, 0x6c, 0x62, 0x65, 0x72, 0x73, 0x00, 0x57, 0x6f, 0x6f, 0x64,
+    0x63, 0x6f, 0x63, 0x6b, 0x00, 0x54, 0x72, 0x61, 0x70, 0x70, 0x00, 0x53,
+    0x6f, 0x61, 0x72, 0x65, 0x73, 0x00, 0x53, 0x65, 0x61, 0x74, 0x6f, 0x6e,
+    0x00, 0x52, 0x69, 0x63, 0x68, 0x69, 0x65, 0x00, 0x4d, 0x6f, 0x6e, 0x73,
+    0x6f, 0x6e, 0x00, 0x4c, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x74, 0x00, 0x4c,
+    0x69, 0x6e, 0x64, 0x62, 0x65, 0x72, 0x67, 0x00, 0x4b, 0x6f, 0x70, 0x70,
+    0x00, 0x4b, 0x65, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x48, 0x73, 0x75, 0x00,
+    0x48, 0x65, 0x61, 0x6c, 0x65, 0x79, 0x00, 0x47, 0x61, 0x72, 0x76, 0x65,
+    0x79, 0x00, 0x47, 0x61, 0x64, 0x64, 0x79, 0x00, 0x46, 0x61, 0x69, 0x6e,
+    0x00, 0x42, 0x75, 0x72, 0x63, 0x68, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00,
+    0x42, 0x61, 0x64, 0x67, 0x65, 0x72, 0x00, 0x57, 0x65, 0x6e, 0x74, 0x77,
+    0x6f, 0x72, 0x74, 0x68, 0x00, 0x53, 0x74, 0x72, 0x61, 0x6e, 0x64, 0x00,
+    0x53, 0x74, 0x61, 0x63, 0x6b, 0x00, 0x53, 0x70, 0x6f, 0x6f, 0x6e, 0x65,
+    0x72, 0x00, 0x53, 0x61, 0x75, 0x63, 0x69, 0x65, 0x72, 0x00, 0x53, 0x61,
+    0x6c, 0x65, 0x73, 0x00, 0x52, 0x75, 0x62, 0x79, 0x00, 0x52, 0x69, 0x63,
+    0x63, 0x69, 0x00, 0x50, 0x6c, 0x75, 0x6e, 0x6b, 0x65, 0x74, 0x74, 0x00,
+    0x50, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4e, 0x65, 0x73, 0x73,
+    0x00, 0x4c, 0x65, 0x67, 0x65, 0x72, 0x00, 0x48, 0x6f, 0x79, 0x00, 0x46,
+    0x72, 0x65, 0x69, 0x74, 0x61, 0x73, 0x00, 0x46, 0x6f, 0x6e, 0x67, 0x00,
+    0x45, 0x6c, 0x69, 0x7a, 0x6f, 0x6e, 0x64, 0x6f, 0x00, 0x44, 0x75, 0x76,
+    0x61, 0x6c, 0x00, 0x43, 0x68, 0x75, 0x6e, 0x00, 0x43, 0x61, 0x6c, 0x76,
+    0x69, 0x6e, 0x00, 0x42, 0x65, 0x61, 0x75, 0x64, 0x6f, 0x69, 0x6e, 0x00,
+    0x55, 0x72, 0x62, 0x69, 0x6e, 0x61, 0x00, 0x53, 0x74, 0x6f, 0x63, 0x6b,
+    0x00, 0x52, 0x69, 0x63, 0x6b, 0x61, 0x72, 0x64, 0x00, 0x50, 0x61, 0x72,
+    0x74, 0x69, 0x6e, 0x00, 0x4d, 0x6f, 0x65, 0x00, 0x4d, 0x63, 0x67, 0x72,
+    0x65, 0x77, 0x00, 0x4d, 0x63, 0x63, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x63,
+    0x6b, 0x00, 0x4c, 0x65, 0x64, 0x6f, 0x75, 0x78, 0x00, 0x46, 0x6f, 0x72,
+    0x73, 0x79, 0x74, 0x68, 0x00, 0x46, 0x61, 0x69, 0x73, 0x6f, 0x6e, 0x00,
+    0x44, 0x65, 0x76, 0x72, 0x69, 0x65, 0x73, 0x00, 0x42, 0x65, 0x72, 0x74,
+    0x72, 0x61, 0x6e, 0x64, 0x00, 0x57, 0x61, 0x73, 0x73, 0x6f, 0x6e, 0x00,
+    0x54, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x63, 0x61, 0x72, 0x62,
+    0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x50, 0x72, 0x69, 0x64, 0x65, 0x00,
+    0x4f, 0x68, 0x00, 0x4c, 0x65, 0x75, 0x6e, 0x67, 0x00, 0x4c, 0x61, 0x72,
+    0x72, 0x79, 0x00, 0x49, 0x72, 0x76, 0x69, 0x6e, 0x65, 0x00, 0x47, 0x61,
+    0x72, 0x62, 0x65, 0x72, 0x00, 0x44, 0x65, 0x6e, 0x6e, 0x69, 0x6e, 0x67,
+    0x00, 0x43, 0x6f, 0x72, 0x72, 0x61, 0x6c, 0x00, 0x43, 0x6f, 0x6c, 0x6c,
+    0x65, 0x79, 0x00, 0x43, 0x61, 0x73, 0x74, 0x6c, 0x65, 0x62, 0x65, 0x72,
+    0x72, 0x79, 0x00, 0x42, 0x6f, 0x77, 0x6c, 0x69, 0x6e, 0x00, 0x42, 0x6f,
+    0x67, 0x61, 0x6e, 0x00, 0x42, 0x65, 0x61, 0x6c, 0x65, 0x00, 0x42, 0x61,
+    0x69, 0x6e, 0x65, 0x73, 0x00, 0x54, 0x72, 0x75, 0x65, 0x00, 0x54, 0x72,
+    0x69, 0x63, 0x65, 0x00, 0x52, 0x61, 0x79, 0x62, 0x75, 0x72, 0x6e, 0x00,
+    0x50, 0x61, 0x72, 0x6b, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x50, 0x61,
+    0x6b, 0x00, 0x4e, 0x75, 0x6e, 0x65, 0x73, 0x00, 0x4d, 0x63, 0x6d, 0x69,
+    0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x4c, 0x65, 0x61, 0x68, 0x79, 0x00, 0x4c,
+    0x65, 0x61, 0x00, 0x4b, 0x69, 0x6d, 0x6d, 0x65, 0x6c, 0x00, 0x48, 0x69,
+    0x67, 0x67, 0x73, 0x00, 0x46, 0x75, 0x6c, 0x6d, 0x65, 0x72, 0x00, 0x43,
+    0x61, 0x72, 0x64, 0x65, 0x6e, 0x00, 0x42, 0x65, 0x64, 0x66, 0x6f, 0x72,
+    0x64, 0x00, 0x54, 0x61, 0x67, 0x67, 0x61, 0x72, 0x74, 0x00, 0x53, 0x70,
+    0x65, 0x61, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x52, 0x65, 0x67, 0x69, 0x73,
+    0x74, 0x65, 0x72, 0x00, 0x50, 0x72, 0x69, 0x63, 0x68, 0x61, 0x72, 0x64,
+    0x00, 0x4d, 0x6f, 0x72, 0x72, 0x69, 0x6c, 0x6c, 0x00, 0x4b, 0x6f, 0x6f,
+    0x6e, 0x63, 0x65, 0x00, 0x48, 0x65, 0x69, 0x6e, 0x7a, 0x00, 0x48, 0x65,
+    0x64, 0x67, 0x65, 0x73, 0x00, 0x47, 0x75, 0x65, 0x6e, 0x74, 0x68, 0x65,
+    0x72, 0x00, 0x47, 0x72, 0x69, 0x63, 0x65, 0x00, 0x46, 0x69, 0x6e, 0x64,
+    0x6c, 0x65, 0x79, 0x00, 0x45, 0x61, 0x72, 0x6c, 0x65, 0x00, 0x44, 0x6f,
+    0x76, 0x65, 0x72, 0x00, 0x43, 0x72, 0x65, 0x69, 0x67, 0x68, 0x74, 0x6f,
+    0x6e, 0x00, 0x42, 0x6f, 0x6f, 0x74, 0x68, 0x65, 0x00, 0x42, 0x61, 0x79,
+    0x65, 0x72, 0x00, 0x41, 0x72, 0x72, 0x65, 0x6f, 0x6c, 0x61, 0x00, 0x56,
+    0x69, 0x74, 0x61, 0x6c, 0x65, 0x00, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x73,
+    0x00, 0x53, 0x65, 0x65, 0x00, 0x52, 0x61, 0x6e, 0x65, 0x79, 0x00, 0x50,
+    0x65, 0x74, 0x65, 0x72, 0x00, 0x4f, 0x73, 0x67, 0x6f, 0x6f, 0x64, 0x00,
+    0x4c, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x48, 0x61, 0x6e, 0x6c, 0x6f,
+    0x6e, 0x00, 0x42, 0x75, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x6f, 0x75,
+    0x6e, 0x64, 0x73, 0x00, 0x57, 0x6f, 0x72, 0x64, 0x65, 0x6e, 0x00, 0x57,
+    0x65, 0x61, 0x74, 0x68, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x56, 0x65, 0x74,
+    0x74, 0x65, 0x72, 0x00, 0x54, 0x61, 0x6e, 0x61, 0x6b, 0x61, 0x00, 0x53,
+    0x74, 0x69, 0x6c, 0x74, 0x6e, 0x65, 0x72, 0x00, 0x53, 0x65, 0x6c, 0x6c,
+    0x00, 0x4e, 0x65, 0x76, 0x61, 0x72, 0x65, 0x7a, 0x00, 0x4d, 0x6f, 0x73,
+    0x62, 0x79, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x72, 0x6f, 0x00, 0x4d,
+    0x65, 0x6c, 0x61, 0x6e, 0x63, 0x6f, 0x6e, 0x00, 0x48, 0x61, 0x72, 0x74,
+    0x65, 0x72, 0x00, 0x48, 0x61, 0x6d, 0x65, 0x72, 0x00, 0x47, 0x6f, 0x62,
+    0x6c, 0x65, 0x00, 0x47, 0x6c, 0x61, 0x64, 0x64, 0x65, 0x6e, 0x00, 0x47,
+    0x69, 0x73, 0x74, 0x00, 0x47, 0x69, 0x6e, 0x6e, 0x00, 0x41, 0x6b, 0x69,
+    0x6e, 0x00, 0x5a, 0x61, 0x72, 0x61, 0x67, 0x6f, 0x7a, 0x61, 0x00, 0x54,
+    0x6f, 0x77, 0x6e, 0x73, 0x00, 0x54, 0x61, 0x72, 0x76, 0x65, 0x72, 0x00,
+    0x53, 0x61, 0x6d, 0x6d, 0x6f, 0x6e, 0x73, 0x00, 0x52, 0x6f, 0x79, 0x73,
+    0x74, 0x65, 0x72, 0x00, 0x4f, 0x72, 0x65, 0x69, 0x6c, 0x6c, 0x79, 0x00,
+    0x4d, 0x75, 0x69, 0x72, 0x00, 0x4d, 0x6f, 0x72, 0x65, 0x68, 0x65, 0x61,
+    0x64, 0x00, 0x4c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x00, 0x4b, 0x69, 0x6e,
+    0x67, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x4b, 0x65, 0x6c, 0x73, 0x6f, 0x00,
+    0x47, 0x72, 0x69, 0x73, 0x68, 0x61, 0x6d, 0x00, 0x47, 0x6c, 0x79, 0x6e,
+    0x6e, 0x00, 0x42, 0x61, 0x75, 0x6d, 0x61, 0x6e, 0x6e, 0x00, 0x41, 0x6c,
+    0x76, 0x65, 0x73, 0x00, 0x59, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x54, 0x61,
+    0x6d, 0x61, 0x79, 0x6f, 0x00, 0x54, 0x61, 0x6d, 0x00, 0x50, 0x61, 0x74,
+    0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x4f, 0x61, 0x74, 0x65, 0x73, 0x00,
+    0x4d, 0x65, 0x6e, 0x65, 0x6e, 0x64, 0x65, 0x7a, 0x00, 0x4c, 0x6f, 0x6e,
+    0x67, 0x6f, 0x00, 0x48, 0x61, 0x72, 0x67, 0x69, 0x73, 0x00, 0x47, 0x72,
+    0x65, 0x65, 0x6e, 0x6c, 0x65, 0x65, 0x00, 0x47, 0x69, 0x6c, 0x6c, 0x65,
+    0x6e, 0x00, 0x44, 0x65, 0x73, 0x61, 0x6e, 0x74, 0x69, 0x73, 0x00, 0x43,
+    0x6f, 0x6e, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x42, 0x72, 0x65, 0x65, 0x64,
+    0x6c, 0x6f, 0x76, 0x65, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x53,
+    0x75, 0x6d, 0x70, 0x74, 0x65, 0x72, 0x00, 0x53, 0x63, 0x68, 0x65, 0x72,
+    0x65, 0x72, 0x00, 0x52, 0x75, 0x70, 0x70, 0x00, 0x52, 0x65, 0x69, 0x63,
+    0x68, 0x65, 0x72, 0x74, 0x00, 0x48, 0x65, 0x72, 0x65, 0x64, 0x69, 0x61,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x6f, 0x6e, 0x00, 0x43, 0x72, 0x65, 0x65,
+    0x6c, 0x00, 0x43, 0x6f, 0x68, 0x6e, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x6d,
+    0x6f, 0x6e, 0x73, 0x00, 0x43, 0x61, 0x73, 0x61, 0x73, 0x00, 0x42, 0x69,
+    0x63, 0x6b, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x42, 0x65, 0x6c, 0x74, 0x6f,
+    0x6e, 0x00, 0x42, 0x61, 0x63, 0x68, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69,
+    0x66, 0x6f, 0x72, 0x64, 0x00, 0x57, 0x68, 0x69, 0x74, 0x63, 0x6f, 0x6d,
+    0x62, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x61, 0x6e, 0x74, 0x00, 0x53, 0x75,
+    0x74, 0x74, 0x65, 0x72, 0x00, 0x53, 0x74, 0x75, 0x6c, 0x6c, 0x00, 0x53,
+    0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x4d, 0x63, 0x63, 0x61,
+    0x6c, 0x6c, 0x75, 0x6d, 0x00, 0x4d, 0x61, 0x6e, 0x73, 0x6f, 0x6e, 0x00,
+    0x4c, 0x61, 0x6e, 0x67, 0x6c, 0x6f, 0x69, 0x73, 0x00, 0x4b, 0x65, 0x65,
+    0x6c, 0x00, 0x4b, 0x65, 0x65, 0x67, 0x61, 0x6e, 0x00, 0x45, 0x6d, 0x61,
+    0x6e, 0x75, 0x65, 0x6c, 0x00, 0x44, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x6f,
+    0x00, 0x44, 0x61, 0x6e, 0x63, 0x79, 0x00, 0x44, 0x61, 0x6d, 0x72, 0x6f,
+    0x6e, 0x00, 0x43, 0x6c, 0x61, 0x70, 0x70, 0x00, 0x43, 0x6c, 0x61, 0x6e,
+    0x74, 0x6f, 0x6e, 0x00, 0x42, 0x61, 0x6e, 0x6b, 0x73, 0x74, 0x6f, 0x6e,
+    0x00, 0x54, 0x72, 0x69, 0x6e, 0x69, 0x64, 0x61, 0x64, 0x00, 0x4f, 0x6c,
+    0x69, 0x76, 0x65, 0x69, 0x72, 0x61, 0x00, 0x4d, 0x69, 0x6e, 0x74, 0x7a,
+    0x00, 0x4d, 0x63, 0x69, 0x6e, 0x6e, 0x69, 0x73, 0x00, 0x4d, 0x61, 0x72,
+    0x74, 0x65, 0x6e, 0x73, 0x00, 0x4d, 0x61, 0x62, 0x65, 0x00, 0x4c, 0x61,
+    0x73, 0x74, 0x65, 0x72, 0x00, 0x4a, 0x6f, 0x6c, 0x6c, 0x65, 0x79, 0x00,
+    0x49, 0x72, 0x69, 0x73, 0x68, 0x00, 0x48, 0x69, 0x6c, 0x64, 0x72, 0x65,
+    0x74, 0x68, 0x00, 0x48, 0x65, 0x66, 0x6e, 0x65, 0x72, 0x00, 0x47, 0x6c,
+    0x61, 0x73, 0x65, 0x72, 0x00, 0x44, 0x75, 0x63, 0x6b, 0x65, 0x74, 0x74,
+    0x00, 0x44, 0x65, 0x6d, 0x65, 0x72, 0x73, 0x00, 0x42, 0x72, 0x6f, 0x63,
+    0x6b, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x6c, 0x61, 0x69, 0x73, 0x00, 0x42,
+    0x61, 0x63, 0x6b, 0x00, 0x41, 0x6c, 0x63, 0x6f, 0x72, 0x6e, 0x00, 0x41,
+    0x67, 0x6e, 0x65, 0x77, 0x00, 0x54, 0x6f, 0x6c, 0x69, 0x76, 0x65, 0x72,
+    0x00, 0x54, 0x69, 0x63, 0x65, 0x00, 0x53, 0x6f, 0x6e, 0x67, 0x00, 0x53,
+    0x65, 0x65, 0x6c, 0x65, 0x79, 0x00, 0x4e, 0x61, 0x6a, 0x65, 0x72, 0x61,
+    0x00, 0x4d, 0x75, 0x73, 0x73, 0x65, 0x72, 0x00, 0x4d, 0x63, 0x66, 0x61,
+    0x6c, 0x6c, 0x00, 0x4c, 0x61, 0x70, 0x6c, 0x61, 0x6e, 0x74, 0x65, 0x00,
+    0x47, 0x61, 0x6c, 0x76, 0x69, 0x6e, 0x00, 0x46, 0x61, 0x6a, 0x61, 0x72,
+    0x64, 0x6f, 0x00, 0x44, 0x6f, 0x61, 0x6e, 0x00, 0x43, 0x6f, 0x79, 0x6e,
+    0x65, 0x00, 0x43, 0x6f, 0x70, 0x6c, 0x65, 0x79, 0x00, 0x43, 0x6c, 0x61,
+    0x77, 0x73, 0x6f, 0x6e, 0x00, 0x43, 0x68, 0x65, 0x75, 0x6e, 0x67, 0x00,
+    0x42, 0x61, 0x72, 0x6f, 0x6e, 0x65, 0x00, 0x57, 0x79, 0x6e, 0x6e, 0x65,
+    0x00, 0x57, 0x6f, 0x6f, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x54, 0x72, 0x65,
+    0x6d, 0x62, 0x6c, 0x61, 0x79, 0x00, 0x53, 0x74, 0x6f, 0x6c, 0x6c, 0x00,
+    0x53, 0x70, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x00, 0x53, 0x70, 0x61, 0x72,
+    0x6b, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x63, 0x68, 0x77, 0x65, 0x69, 0x74,
+    0x7a, 0x65, 0x72, 0x00, 0x53, 0x61, 0x73, 0x73, 0x65, 0x72, 0x00, 0x53,
+    0x61, 0x6d, 0x70, 0x6c, 0x65, 0x73, 0x00, 0x52, 0x6f, 0x6e, 0x65, 0x79,
+    0x00, 0x52, 0x61, 0x6d, 0x6f, 0x6e, 0x00, 0x4c, 0x65, 0x67, 0x67, 0x00,
+    0x4c, 0x61, 0x69, 0x00, 0x4a, 0x6f, 0x65, 0x00, 0x48, 0x65, 0x69, 0x6d,
+    0x00, 0x46, 0x61, 0x72, 0x69, 0x61, 0x73, 0x00, 0x43, 0x6f, 0x6e, 0x63,
+    0x65, 0x70, 0x63, 0x69, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x6c, 0x77, 0x65,
+    0x6c, 0x6c, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x6d, 0x61, 0x6e,
+    0x00, 0x42, 0x72, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72, 0x00, 0x41, 0x6c,
+    0x62, 0x61, 0x00, 0x57, 0x69, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x74, 0x65,
+    0x72, 0x00, 0x55, 0x70, 0x73, 0x68, 0x61, 0x77, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x53, 0x6f, 0x72,
+    0x72, 0x65, 0x6c, 0x6c, 0x00, 0x53, 0x68, 0x61, 0x79, 0x00, 0x53, 0x65,
+    0x6c, 0x6c, 0x73, 0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x4d, 0x63,
+    0x63, 0x6c, 0x6f, 0x73, 0x6b, 0x65, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x74,
+    0x69, 0x6e, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x4c, 0x75, 0x74, 0x74, 0x72,
+    0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x6f, 0x76, 0x65, 0x6c, 0x65, 0x73, 0x73,
+    0x00, 0x4c, 0x6f, 0x76, 0x65, 0x6a, 0x6f, 0x79, 0x00, 0x4c, 0x69, 0x6e,
+    0x61, 0x72, 0x65, 0x73, 0x00, 0x4c, 0x61, 0x74, 0x69, 0x6d, 0x65, 0x72,
+    0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x79, 0x00, 0x45, 0x6d, 0x62, 0x72, 0x79,
+    0x00, 0x43, 0x6f, 0x6f, 0x6d, 0x62, 0x73, 0x00, 0x42, 0x72, 0x61, 0x74,
+    0x74, 0x6f, 0x6e, 0x00, 0x42, 0x6f, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x00,
+    0x42, 0x6f, 0x73, 0x73, 0x00, 0x56, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+    0x00, 0x54, 0x75, 0x67, 0x67, 0x6c, 0x65, 0x00, 0x54, 0x6f, 0x72, 0x6f,
+    0x00, 0x53, 0x74, 0x61, 0x67, 0x67, 0x73, 0x00, 0x53, 0x61, 0x6e, 0x64,
+    0x6c, 0x69, 0x6e, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x69, 0x65,
+    0x73, 0x00, 0x48, 0x65, 0x63, 0x6b, 0x6d, 0x61, 0x6e, 0x00, 0x47, 0x72,
+    0x69, 0x66, 0x66, 0x69, 0x73, 0x00, 0x43, 0x72, 0x61, 0x79, 0x74, 0x6f,
+    0x6e, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x00, 0x42, 0x75, 0x74, 0x74, 0x6f,
+    0x6e, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x64, 0x65, 0x72, 0x00, 0x41, 0x6c,
+    0x6c, 0x61, 0x6e, 0x00, 0x54, 0x68, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x00,
+    0x53, 0x74, 0x75, 0x72, 0x67, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x70, 0x72,
+    0x6f, 0x75, 0x73, 0x65, 0x00, 0x52, 0x6f, 0x79, 0x65, 0x72, 0x00, 0x52,
+    0x6f, 0x75, 0x73, 0x73, 0x65, 0x61, 0x75, 0x00, 0x52, 0x69, 0x64, 0x65,
+    0x6e, 0x6f, 0x75, 0x72, 0x00, 0x50, 0x6f, 0x67, 0x75, 0x65, 0x00, 0x50,
+    0x65, 0x72, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x50, 0x65, 0x65, 0x70, 0x6c,
+    0x65, 0x73, 0x00, 0x4d, 0x65, 0x74, 0x7a, 0x6c, 0x65, 0x72, 0x00, 0x4d,
+    0x65, 0x73, 0x61, 0x00, 0x4d, 0x63, 0x63, 0x75, 0x74, 0x63, 0x68, 0x65,
+    0x6f, 0x6e, 0x00, 0x4d, 0x63, 0x62, 0x65, 0x65, 0x00, 0x4a, 0x61, 0x79,
+    0x00, 0x48, 0x6f, 0x72, 0x6e, 0x73, 0x62, 0x79, 0x00, 0x48, 0x65, 0x66,
+    0x66, 0x6e, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x72, 0x72, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x41, 0x72, 0x6d, 0x69, 0x6a, 0x6f, 0x00, 0x56, 0x75, 0x65,
+    0x00, 0x52, 0x6f, 0x6d, 0x65, 0x6f, 0x00, 0x50, 0x6c, 0x61, 0x6e, 0x74,
+    0x65, 0x00, 0x50, 0x65, 0x79, 0x74, 0x6f, 0x6e, 0x00, 0x50, 0x61, 0x72,
+    0x65, 0x64, 0x65, 0x73, 0x00, 0x4d, 0x61, 0x63, 0x6b, 0x6c, 0x69, 0x6e,
+    0x00, 0x48, 0x75, 0x73, 0x73, 0x65, 0x79, 0x00, 0x48, 0x6f, 0x64, 0x67,
+    0x73, 0x6f, 0x6e, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x61, 0x64, 0x6f, 0x73,
+    0x00, 0x46, 0x72, 0x69, 0x61, 0x73, 0x00, 0x43, 0x61, 0x72, 0x6d, 0x61,
+    0x6e, 0x00, 0x42, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x42, 0x65, 0x63, 0x6e,
+    0x65, 0x6c, 0x00, 0x42, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x00, 0x41, 0x6c,
+    0x6d, 0x61, 0x6e, 0x7a, 0x61, 0x00, 0x54, 0x75, 0x72, 0x6e, 0x65, 0x79,
+    0x00, 0x54, 0x65, 0x61, 0x6c, 0x00, 0x53, 0x74, 0x75, 0x72, 0x67, 0x65,
+    0x6f, 0x6e, 0x00, 0x4d, 0x65, 0x65, 0x6b, 0x65, 0x72, 0x00, 0x4d, 0x63,
+    0x64, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x73, 0x00, 0x4c, 0x69, 0x6d, 0x6f,
+    0x6e, 0x00, 0x4b, 0x65, 0x65, 0x6e, 0x65, 0x79, 0x00, 0x4b, 0x65, 0x65,
+    0x00, 0x48, 0x75, 0x74, 0x74, 0x6f, 0x00, 0x48, 0x6f, 0x6c, 0x67, 0x75,
+    0x69, 0x6e, 0x00, 0x47, 0x6f, 0x72, 0x68, 0x61, 0x6d, 0x00, 0x46, 0x69,
+    0x73, 0x68, 0x6d, 0x61, 0x6e, 0x00, 0x46, 0x69, 0x65, 0x72, 0x72, 0x6f,
+    0x00, 0x42, 0x6c, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x74, 0x74, 0x65, 0x00,
+    0x52, 0x6f, 0x64, 0x72, 0x69, 0x67, 0x75, 0x65, 0x00, 0x52, 0x65, 0x64,
+    0x64, 0x79, 0x00, 0x4f, 0x73, 0x62, 0x75, 0x72, 0x6e, 0x00, 0x4f, 0x64,
+    0x65, 0x6e, 0x00, 0x4c, 0x65, 0x72, 0x6d, 0x61, 0x00, 0x4b, 0x69, 0x72,
+    0x6b, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4b, 0x65, 0x65, 0x66, 0x65, 0x72,
+    0x00, 0x48, 0x61, 0x75, 0x67, 0x65, 0x6e, 0x00, 0x48, 0x61, 0x6d, 0x6d,
+    0x65, 0x74, 0x74, 0x00, 0x43, 0x68, 0x61, 0x6c, 0x6d, 0x65, 0x72, 0x73,
+    0x00, 0x43, 0x61, 0x72, 0x6c, 0x6f, 0x73, 0x00, 0x42, 0x72, 0x69, 0x6e,
+    0x6b, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x61, 0x75, 0x6d, 0x67, 0x61, 0x72,
+    0x74, 0x6e, 0x65, 0x72, 0x00, 0x5a, 0x68, 0x61, 0x6e, 0x67, 0x00, 0x56,
+    0x61, 0x6c, 0x65, 0x72, 0x69, 0x6f, 0x00, 0x54, 0x65, 0x6c, 0x6c, 0x65,
+    0x7a, 0x00, 0x53, 0x74, 0x65, 0x66, 0x66, 0x65, 0x6e, 0x00, 0x53, 0x68,
+    0x75, 0x6d, 0x61, 0x74, 0x65, 0x00, 0x53, 0x61, 0x75, 0x6c, 0x73, 0x00,
+    0x52, 0x69, 0x70, 0x6c, 0x65, 0x79, 0x00, 0x4b, 0x65, 0x6d, 0x70, 0x65,
+    0x72, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x00, 0x47, 0x75, 0x66, 0x66,
+    0x65, 0x79, 0x00, 0x45, 0x76, 0x65, 0x72, 0x73, 0x00, 0x43, 0x72, 0x61,
+    0x64, 0x64, 0x6f, 0x63, 0x6b, 0x00, 0x43, 0x61, 0x72, 0x76, 0x61, 0x6c,
+    0x68, 0x6f, 0x00, 0x42, 0x6c, 0x61, 0x79, 0x6c, 0x6f, 0x63, 0x6b, 0x00,
+    0x42, 0x61, 0x6e, 0x75, 0x65, 0x6c, 0x6f, 0x73, 0x00, 0x42, 0x61, 0x6c,
+    0x64, 0x65, 0x72, 0x61, 0x73, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x65, 0x6e,
+    0x00, 0x57, 0x68, 0x65, 0x61, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x75, 0x72,
+    0x6e, 0x62, 0x75, 0x6c, 0x6c, 0x00, 0x53, 0x68, 0x75, 0x6d, 0x61, 0x6e,
+    0x00, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x4d, 0x6f, 0x73,
+    0x69, 0x65, 0x72, 0x00, 0x4d, 0x63, 0x63, 0x75, 0x65, 0x00, 0x4c, 0x69,
+    0x67, 0x6f, 0x6e, 0x00, 0x4b, 0x6f, 0x7a, 0x6c, 0x6f, 0x77, 0x73, 0x6b,
+    0x69, 0x00, 0x4a, 0x6f, 0x68, 0x61, 0x6e, 0x73, 0x65, 0x6e, 0x00, 0x49,
+    0x6e, 0x67, 0x6c, 0x65, 0x00, 0x48, 0x65, 0x72, 0x72, 0x00, 0x42, 0x72,
+    0x69, 0x6f, 0x6e, 0x65, 0x73, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x65,
+    0x72, 0x6e, 0x00, 0x53, 0x6e, 0x69, 0x70, 0x65, 0x73, 0x00, 0x52, 0x69,
+    0x63, 0x6b, 0x6d, 0x61, 0x6e, 0x00, 0x50, 0x69, 0x70, 0x6b, 0x69, 0x6e,
+    0x00, 0x50, 0x65, 0x61, 0x63, 0x65, 0x00, 0x50, 0x61, 0x6e, 0x74, 0x6f,
+    0x6a, 0x61, 0x00, 0x4f, 0x72, 0x6f, 0x73, 0x63, 0x6f, 0x00, 0x4d, 0x6f,
+    0x6e, 0x69, 0x7a, 0x00, 0x4c, 0x61, 0x77, 0x6c, 0x65, 0x73, 0x73, 0x00,
+    0x4b, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x00, 0x48, 0x69, 0x62, 0x62, 0x61,
+    0x72, 0x64, 0x00, 0x47, 0x61, 0x6c, 0x61, 0x72, 0x7a, 0x61, 0x00, 0x45,
+    0x6e, 0x6f, 0x73, 0x00, 0x42, 0x75, 0x73, 0x73, 0x65, 0x79, 0x00, 0x53,
+    0x65, 0x74, 0x74, 0x6c, 0x65, 0x00, 0x53, 0x63, 0x68, 0x6f, 0x74, 0x74,
+    0x00, 0x53, 0x61, 0x6c, 0x63, 0x69, 0x64, 0x6f, 0x00, 0x50, 0x65, 0x72,
+    0x72, 0x65, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x4d, 0x63, 0x64, 0x6f, 0x75,
+    0x67, 0x61, 0x6c, 0x00, 0x4d, 0x63, 0x63, 0x6f, 0x6f, 0x6c, 0x00, 0x48,
+    0x61, 0x69, 0x67, 0x68, 0x74, 0x00, 0x47, 0x61, 0x72, 0x72, 0x69, 0x73,
+    0x00, 0x46, 0x65, 0x72, 0x72, 0x79, 0x00, 0x45, 0x61, 0x73, 0x74, 0x6f,
+    0x6e, 0x00, 0x43, 0x6f, 0x6e, 0x79, 0x65, 0x72, 0x73, 0x00, 0x41, 0x74,
+    0x68, 0x65, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6d, 0x62, 0x65,
+    0x72, 0x6c, 0x79, 0x00, 0x55, 0x74, 0x6c, 0x65, 0x79, 0x00, 0x53, 0x74,
+    0x65, 0x70, 0x68, 0x65, 0x6e, 0x00, 0x53, 0x70, 0x65, 0x6c, 0x6c, 0x6d,
+    0x61, 0x6e, 0x00, 0x53, 0x6d, 0x69, 0x74, 0x68, 0x73, 0x6f, 0x6e, 0x00,
+    0x53, 0x6c, 0x61, 0x67, 0x6c, 0x65, 0x00, 0x53, 0x6b, 0x69, 0x70, 0x70,
+    0x65, 0x72, 0x00, 0x52, 0x69, 0x74, 0x63, 0x68, 0x65, 0x79, 0x00, 0x52,
+    0x61, 0x6e, 0x64, 0x00, 0x50, 0x65, 0x74, 0x69, 0x74, 0x00, 0x4f, 0x73,
+    0x75, 0x6c, 0x6c, 0x69, 0x76, 0x61, 0x6e, 0x00, 0x4f, 0x61, 0x6b, 0x73,
+    0x00, 0x4e, 0x75, 0x74, 0x74, 0x00, 0x4d, 0x63, 0x76, 0x61, 0x79, 0x00,
+    0x4d, 0x63, 0x63, 0x72, 0x65, 0x61, 0x72, 0x79, 0x00, 0x4d, 0x61, 0x79,
+    0x68, 0x65, 0x77, 0x00, 0x4b, 0x6e, 0x6f, 0x6c, 0x6c, 0x00, 0x4a, 0x65,
+    0x77, 0x65, 0x74, 0x74, 0x00, 0x48, 0x61, 0x72, 0x77, 0x6f, 0x6f, 0x64,
+    0x00, 0x48, 0x61, 0x69, 0x6c, 0x65, 0x79, 0x00, 0x43, 0x61, 0x72, 0x64,
+    0x6f, 0x7a, 0x61, 0x00, 0x41, 0x73, 0x68, 0x65, 0x00, 0x41, 0x72, 0x72,
+    0x69, 0x61, 0x67, 0x61, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x73, 0x00,
+    0x5a, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x57, 0x69, 0x72, 0x74, 0x68,
+    0x00, 0x57, 0x68, 0x69, 0x74, 0x6d, 0x69, 0x72, 0x65, 0x00, 0x53, 0x74,
+    0x61, 0x75, 0x66, 0x66, 0x65, 0x72, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x52, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x65, 0x65, 0x00, 0x52,
+    0x65, 0x64, 0x64, 0x65, 0x6e, 0x00, 0x4d, 0x63, 0x63, 0x61, 0x66, 0x66,
+    0x72, 0x65, 0x79, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x7a, 0x00, 0x4c, 0x6f,
+    0x76, 0x69, 0x6e, 0x67, 0x00, 0x4c, 0x61, 0x72, 0x6f, 0x73, 0x65, 0x00,
+    0x4c, 0x61, 0x6e, 0x67, 0x64, 0x6f, 0x6e, 0x00, 0x48, 0x75, 0x6d, 0x65,
+    0x73, 0x00, 0x47, 0x61, 0x73, 0x6b, 0x69, 0x6e, 0x00, 0x46, 0x61, 0x62,
+    0x65, 0x72, 0x00, 0x44, 0x6f, 0x6c, 0x6c, 0x00, 0x44, 0x65, 0x76, 0x69,
+    0x74, 0x6f, 0x00, 0x43, 0x61, 0x73, 0x73, 0x00, 0x41, 0x6c, 0x6d, 0x6f,
+    0x6e, 0x64, 0x00, 0x57, 0x69, 0x6e, 0x67, 0x66, 0x69, 0x65, 0x6c, 0x64,
+    0x00, 0x57, 0x69, 0x6e, 0x67, 0x61, 0x74, 0x65, 0x00, 0x56, 0x69, 0x6c,
+    0x6c, 0x61, 0x72, 0x65, 0x61, 0x6c, 0x00, 0x54, 0x79, 0x6e, 0x65, 0x72,
+    0x00, 0x53, 0x6d, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x73, 0x00, 0x53, 0x65,
+    0x76, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x52, 0x65, 0x6e, 0x6f, 0x00,
+    0x50, 0x65, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x61, 0x75, 0x70,
+    0x69, 0x6e, 0x00, 0x4c, 0x65, 0x69, 0x67, 0x68, 0x74, 0x6f, 0x6e, 0x00,
+    0x4a, 0x61, 0x6e, 0x73, 0x73, 0x65, 0x6e, 0x00, 0x48, 0x61, 0x73, 0x73,
+    0x65, 0x6c, 0x6c, 0x00, 0x48, 0x61, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x00,
+    0x48, 0x61, 0x6c, 0x63, 0x6f, 0x6d, 0x62, 0x00, 0x46, 0x6f, 0x6c, 0x73,
+    0x65, 0x00, 0x46, 0x69, 0x74, 0x7a, 0x73, 0x69, 0x6d, 0x6d, 0x6f, 0x6e,
+    0x73, 0x00, 0x46, 0x61, 0x68, 0x65, 0x79, 0x00, 0x43, 0x72, 0x61, 0x6e,
+    0x66, 0x6f, 0x72, 0x64, 0x00, 0x42, 0x6f, 0x6c, 0x65, 0x6e, 0x00, 0x42,
+    0x61, 0x74, 0x74, 0x6c, 0x65, 0x73, 0x00, 0x42, 0x61, 0x74, 0x74, 0x61,
+    0x67, 0x6c, 0x69, 0x61, 0x00, 0x57, 0x6f, 0x6f, 0x6c, 0x64, 0x72, 0x69,
+    0x64, 0x67, 0x65, 0x00, 0x57, 0x65, 0x65, 0x64, 0x00, 0x54, 0x72, 0x61,
+    0x73, 0x6b, 0x00, 0x52, 0x6f, 0x73, 0x73, 0x65, 0x72, 0x00, 0x52, 0x65,
+    0x67, 0x61, 0x6c, 0x61, 0x64, 0x6f, 0x00, 0x4d, 0x63, 0x65, 0x77, 0x65,
+    0x6e, 0x00, 0x4b, 0x65, 0x65, 0x66, 0x65, 0x00, 0x46, 0x75, 0x71, 0x75,
+    0x61, 0x00, 0x45, 0x63, 0x68, 0x65, 0x76, 0x61, 0x72, 0x72, 0x69, 0x61,
+    0x00, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x6f, 0x00, 0x44, 0x61, 0x6e,
+    0x67, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x00, 0x42, 0x6f, 0x79, 0x6e, 0x74,
+    0x6f, 0x6e, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x75, 0x73, 0x00, 0x57, 0x69,
+    0x6c, 0x64, 0x00, 0x56, 0x69, 0x65, 0x72, 0x61, 0x00, 0x56, 0x61, 0x6e,
+    0x6d, 0x65, 0x74, 0x65, 0x72, 0x00, 0x54, 0x61, 0x62, 0x65, 0x72, 0x00,
+    0x53, 0x70, 0x72, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x00, 0x53, 0x65, 0x69,
+    0x62, 0x65, 0x72, 0x74, 0x00, 0x50, 0x72, 0x6f, 0x76, 0x6f, 0x73, 0x74,
+    0x00, 0x50, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x65, 0x00, 0x4f, 0x6c,
+    0x69, 0x70, 0x68, 0x61, 0x6e, 0x74, 0x00, 0x4c, 0x61, 0x70, 0x6f, 0x72,
+    0x74, 0x65, 0x00, 0x48, 0x77, 0x61, 0x6e, 0x67, 0x00, 0x48, 0x61, 0x74,
+    0x63, 0x68, 0x65, 0x74, 0x74, 0x00, 0x48, 0x61, 0x73, 0x73, 0x00, 0x47,
+    0x72, 0x65, 0x69, 0x6e, 0x65, 0x72, 0x00, 0x46, 0x72, 0x65, 0x65, 0x64,
+    0x6d, 0x61, 0x6e, 0x00, 0x43, 0x6f, 0x76, 0x65, 0x72, 0x74, 0x00, 0x43,
+    0x68, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x79, 0x61, 0x72, 0x73,
+    0x00, 0x57, 0x69, 0x65, 0x73, 0x65, 0x00, 0x56, 0x65, 0x6e, 0x65, 0x67,
+    0x61, 0x73, 0x00, 0x53, 0x77, 0x61, 0x6e, 0x6b, 0x00, 0x53, 0x68, 0x72,
+    0x61, 0x64, 0x65, 0x72, 0x00, 0x52, 0x6f, 0x64, 0x65, 0x72, 0x69, 0x63,
+    0x6b, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x67, 0x65, 0x00, 0x4d, 0x75,
+    0x6c, 0x6c, 0x69, 0x73, 0x00, 0x4d, 0x6f, 0x72, 0x74, 0x65, 0x6e, 0x73,
+    0x65, 0x6e, 0x00, 0x4d, 0x63, 0x63, 0x75, 0x6e, 0x65, 0x00, 0x4d, 0x61,
+    0x72, 0x6c, 0x6f, 0x77, 0x65, 0x00, 0x4b, 0x69, 0x72, 0x63, 0x68, 0x6e,
+    0x65, 0x72, 0x00, 0x4b, 0x65, 0x63, 0x6b, 0x00, 0x49, 0x73, 0x61, 0x61,
+    0x63, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x6f, 0x73, 0x74, 0x65, 0x74, 0x6c,
+    0x65, 0x72, 0x00, 0x48, 0x61, 0x6c, 0x76, 0x65, 0x72, 0x73, 0x6f, 0x6e,
+    0x00, 0x47, 0x75, 0x6e, 0x74, 0x68, 0x65, 0x72, 0x00, 0x47, 0x72, 0x69,
+    0x73, 0x77, 0x6f, 0x6c, 0x64, 0x00, 0x47, 0x65, 0x72, 0x61, 0x72, 0x64,
+    0x00, 0x46, 0x65, 0x6e, 0x6e, 0x65, 0x72, 0x00, 0x44, 0x75, 0x72, 0x64,
+    0x65, 0x6e, 0x00, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x77, 0x6f, 0x6f, 0x64,
+    0x00, 0x42, 0x65, 0x72, 0x74, 0x72, 0x61, 0x6d, 0x00, 0x41, 0x68, 0x72,
+    0x65, 0x6e, 0x73, 0x00, 0x53, 0x61, 0x77, 0x79, 0x65, 0x72, 0x73, 0x00,
+    0x53, 0x61, 0x76, 0x6f, 0x79, 0x00, 0x4e, 0x61, 0x62, 0x6f, 0x72, 0x73,
+    0x00, 0x4d, 0x63, 0x73, 0x77, 0x61, 0x69, 0x6e, 0x00, 0x4d, 0x61, 0x63,
+    0x6b, 0x61, 0x79, 0x00, 0x4c, 0x6f, 0x79, 0x00, 0x4c, 0x61, 0x76, 0x65,
+    0x6e, 0x64, 0x65, 0x72, 0x00, 0x4c, 0x61, 0x73, 0x68, 0x00, 0x4c, 0x61,
+    0x62, 0x62, 0x65, 0x00, 0x4a, 0x65, 0x73, 0x73, 0x75, 0x70, 0x00, 0x48,
+    0x75, 0x62, 0x65, 0x72, 0x74, 0x00, 0x46, 0x75, 0x6c, 0x6c, 0x65, 0x72,
+    0x74, 0x6f, 0x6e, 0x00, 0x44, 0x6f, 0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00,
+    0x43, 0x72, 0x75, 0x73, 0x65, 0x00, 0x43, 0x72, 0x69, 0x74, 0x74, 0x65,
+    0x6e, 0x64, 0x65, 0x6e, 0x00, 0x43, 0x6f, 0x72, 0x72, 0x65, 0x69, 0x61,
+    0x00, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x6e, 0x6f, 0x00, 0x43, 0x61, 0x75,
+    0x64, 0x6c, 0x65, 0x00, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x79, 0x00, 0x43,
+    0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x41, 0x6c, 0x61,
+    0x72, 0x63, 0x6f, 0x6e, 0x00, 0x41, 0x68, 0x65, 0x72, 0x6e, 0x00, 0x57,
+    0x69, 0x6e, 0x66, 0x72, 0x65, 0x79, 0x00, 0x54, 0x72, 0x69, 0x62, 0x62,
+    0x6c, 0x65, 0x00, 0x54, 0x6f, 0x6d, 0x00, 0x53, 0x74, 0x79, 0x6c, 0x65,
+    0x73, 0x00, 0x53, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x52, 0x6f, 0x64,
+    0x65, 0x6e, 0x00, 0x4d, 0x75, 0x73, 0x67, 0x72, 0x6f, 0x76, 0x65, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x69, 0x63, 0x6b, 0x00, 0x46, 0x6f, 0x72, 0x74,
+    0x65, 0x6e, 0x62, 0x65, 0x72, 0x72, 0x79, 0x00, 0x43, 0x61, 0x72, 0x72,
+    0x69, 0x6f, 0x6e, 0x00, 0x42, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x00,
+    0x42, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x00, 0x42, 0x61, 0x74, 0x69, 0x73,
+    0x74, 0x65, 0x00, 0x57, 0x6f, 0x6f, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65,
+    0x64, 0x00, 0x55, 0x6e, 0x64, 0x65, 0x72, 0x68, 0x69, 0x6c, 0x6c, 0x00,
+    0x53, 0x74, 0x69, 0x6c, 0x6c, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x53, 0x69,
+    0x6c, 0x76, 0x69, 0x61, 0x00, 0x52, 0x61, 0x75, 0x63, 0x68, 0x00, 0x50,
+    0x69, 0x70, 0x70, 0x69, 0x6e, 0x00, 0x50, 0x65, 0x72, 0x72, 0x69, 0x6e,
+    0x00, 0x4d, 0x65, 0x73, 0x73, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x4d,
+    0x61, 0x6e, 0x63, 0x69, 0x6e, 0x69, 0x00, 0x4c, 0x69, 0x73, 0x74, 0x65,
+    0x72, 0x00, 0x4b, 0x69, 0x6e, 0x61, 0x72, 0x64, 0x00, 0x48, 0x61, 0x72,
+    0x74, 0x6d, 0x61, 0x6e, 0x6e, 0x00, 0x46, 0x6c, 0x65, 0x63, 0x6b, 0x00,
+    0x42, 0x72, 0x6f, 0x61, 0x64, 0x77, 0x61, 0x79, 0x00, 0x57, 0x69, 0x6c,
+    0x74, 0x00, 0x54, 0x72, 0x65, 0x61, 0x64, 0x77, 0x61, 0x79, 0x00, 0x54,
+    0x68, 0x6f, 0x72, 0x6e, 0x68, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x70, 0x65,
+    0x65, 0x64, 0x00, 0x53, 0x70, 0x61, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x00,
+    0x53, 0x61, 0x6d, 0x00, 0x52, 0x61, 0x66, 0x66, 0x65, 0x72, 0x74, 0x79,
+    0x00, 0x50, 0x69, 0x74, 0x72, 0x65, 0x00, 0x50, 0x61, 0x74, 0x69, 0x6e,
+    0x6f, 0x00, 0x4f, 0x72, 0x64, 0x6f, 0x6e, 0x65, 0x7a, 0x00, 0x4c, 0x69,
+    0x6e, 0x6b, 0x6f, 0x75, 0x73, 0x00, 0x4b, 0x65, 0x6c, 0x6c, 0x65, 0x68,
+    0x65, 0x72, 0x00, 0x48, 0x6f, 0x6d, 0x61, 0x6e, 0x00, 0x48, 0x6f, 0x6c,
+    0x69, 0x64, 0x61, 0x79, 0x00, 0x47, 0x61, 0x6c, 0x62, 0x72, 0x61, 0x69,
+    0x74, 0x68, 0x00, 0x46, 0x65, 0x65, 0x6e, 0x65, 0x79, 0x00, 0x44, 0x6f,
+    0x72, 0x72, 0x69, 0x73, 0x00, 0x43, 0x75, 0x72, 0x74, 0x69, 0x6e, 0x00,
+    0x43, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x00, 0x43, 0x61, 0x6d, 0x61, 0x72,
+    0x69, 0x6c, 0x6c, 0x6f, 0x00, 0x42, 0x75, 0x73, 0x73, 0x00, 0x42, 0x75,
+    0x6e, 0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x42, 0x6f, 0x6c, 0x74, 0x00, 0x42,
+    0x65, 0x65, 0x6c, 0x65, 0x72, 0x00, 0x41, 0x75, 0x74, 0x72, 0x79, 0x00,
+    0x41, 0x6c, 0x63, 0x61, 0x6c, 0x61, 0x00, 0x57, 0x69, 0x74, 0x74, 0x65,
+    0x00, 0x57, 0x65, 0x6e, 0x74, 0x7a, 0x00, 0x53, 0x74, 0x69, 0x64, 0x68,
+    0x61, 0x6d, 0x00, 0x53, 0x68, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x4e,
+    0x75, 0x6e, 0x6c, 0x65, 0x79, 0x00, 0x4d, 0x65, 0x61, 0x63, 0x68, 0x61,
+    0x6d, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x73, 0x00, 0x4c, 0x65,
+    0x6d, 0x6b, 0x65, 0x00, 0x4c, 0x65, 0x66, 0x65, 0x62, 0x76, 0x72, 0x65,
+    0x00, 0x4b, 0x61, 0x79, 0x65, 0x00, 0x48, 0x79, 0x6e, 0x65, 0x73, 0x00,
+    0x48, 0x6f, 0x72, 0x6f, 0x77, 0x69, 0x74, 0x7a, 0x00, 0x48, 0x6f, 0x70,
+    0x70, 0x65, 0x00, 0x48, 0x6f, 0x6c, 0x63, 0x6f, 0x6d, 0x62, 0x65, 0x00,
+    0x45, 0x73, 0x74, 0x72, 0x65, 0x6c, 0x6c, 0x61, 0x00, 0x44, 0x75, 0x6e,
+    0x6e, 0x65, 0x00, 0x44, 0x65, 0x72, 0x72, 0x00, 0x43, 0x6f, 0x63, 0x68,
+    0x72, 0x61, 0x6e, 0x65, 0x00, 0x42, 0x72, 0x69, 0x74, 0x74, 0x61, 0x69,
+    0x6e, 0x00, 0x42, 0x65, 0x64, 0x61, 0x72, 0x64, 0x00, 0x42, 0x65, 0x61,
+    0x75, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x00, 0x54, 0x6f, 0x72, 0x72,
+    0x65, 0x6e, 0x63, 0x65, 0x00, 0x53, 0x74, 0x72, 0x75, 0x6e, 0x6b, 0x00,
+    0x53, 0x6f, 0x72, 0x69, 0x61, 0x00, 0x53, 0x69, 0x6d, 0x6f, 0x6e, 0x73,
+    0x6f, 0x6e, 0x00, 0x53, 0x68, 0x75, 0x6d, 0x61, 0x6b, 0x65, 0x72, 0x00,
+    0x53, 0x63, 0x6f, 0x67, 0x67, 0x69, 0x6e, 0x73, 0x00, 0x50, 0x61, 0x63,
+    0x6b, 0x65, 0x72, 0x00, 0x4f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x72, 0x00,
+    0x4d, 0x6f, 0x72, 0x69, 0x61, 0x72, 0x74, 0x79, 0x00, 0x4c, 0x65, 0x72,
+    0x6f, 0x79, 0x00, 0x4b, 0x75, 0x6e, 0x74, 0x7a, 0x00, 0x49, 0x76, 0x65,
+    0x73, 0x00, 0x48, 0x75, 0x74, 0x63, 0x68, 0x65, 0x73, 0x6f, 0x6e, 0x00,
+    0x48, 0x6f, 0x72, 0x61, 0x6e, 0x00, 0x48, 0x61, 0x6c, 0x65, 0x73, 0x00,
+    0x47, 0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x00, 0x46, 0x69, 0x74, 0x74, 0x73,
+    0x00, 0x44, 0x65, 0x6c, 0x6c, 0x00, 0x42, 0x6f, 0x68, 0x6e, 0x00, 0x41,
+    0x74, 0x63, 0x68, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x57, 0x6f, 0x72, 0x74,
+    0x68, 0x00, 0x57, 0x69, 0x73, 0x6e, 0x69, 0x65, 0x77, 0x73, 0x6b, 0x69,
+    0x00, 0x57, 0x69, 0x6c, 0x6c, 0x00, 0x56, 0x61, 0x6e, 0x77, 0x69, 0x6e,
+    0x6b, 0x6c, 0x65, 0x00, 0x53, 0x74, 0x75, 0x72, 0x6d, 0x00, 0x53, 0x61,
+    0x6c, 0x6c, 0x65, 0x65, 0x00, 0x50, 0x72, 0x6f, 0x73, 0x73, 0x65, 0x72,
+    0x00, 0x4d, 0x6f, 0x65, 0x6e, 0x00, 0x4c, 0x75, 0x6e, 0x64, 0x62, 0x65,
+    0x72, 0x67, 0x00, 0x4b, 0x75, 0x6e, 0x7a, 0x00, 0x4b, 0x6f, 0x68, 0x6c,
+    0x00, 0x4b, 0x65, 0x61, 0x6e, 0x65, 0x00, 0x4a, 0x6f, 0x72, 0x67, 0x65,
+    0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x61, 0x79, 0x6e, 0x65, 0x73, 0x00,
+    0x46, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x62, 0x75, 0x72, 0x6b, 0x00, 0x46,
+    0x72, 0x65, 0x65, 0x64, 0x00, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x00, 0x44,
+    0x75, 0x72, 0x72, 0x00, 0x43, 0x72, 0x65, 0x61, 0x6d, 0x65, 0x72, 0x00,
+    0x43, 0x6f, 0x73, 0x67, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x43, 0x61, 0x6e,
+    0x64, 0x65, 0x6c, 0x61, 0x72, 0x69, 0x61, 0x00, 0x42, 0x65, 0x72, 0x6c,
+    0x69, 0x6e, 0x00, 0x42, 0x61, 0x74, 0x73, 0x6f, 0x6e, 0x00, 0x56, 0x61,
+    0x6e, 0x68, 0x6f, 0x6f, 0x73, 0x65, 0x00, 0x54, 0x68, 0x6f, 0x6d, 0x73,
+    0x65, 0x6e, 0x00, 0x54, 0x65, 0x65, 0x74, 0x65, 0x72, 0x00, 0x53, 0x6f,
+    0x6d, 0x6d, 0x65, 0x72, 0x00, 0x53, 0x6d, 0x79, 0x74, 0x68, 0x00, 0x53,
+    0x65, 0x6e, 0x61, 0x00, 0x52, 0x65, 0x64, 0x6d, 0x6f, 0x6e, 0x00, 0x4f,
+    0x72, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x61, 0x00, 0x4d, 0x61, 0x6e, 0x65,
+    0x73, 0x73, 0x00, 0x4c, 0x65, 0x6e, 0x6e, 0x6f, 0x6e, 0x00, 0x48, 0x65,
+    0x66, 0x6c, 0x69, 0x6e, 0x00, 0x47, 0x6f, 0x75, 0x6c, 0x65, 0x74, 0x00,
+    0x46, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x46, 0x6f, 0x72, 0x6e, 0x65, 0x79,
+    0x00, 0x44, 0x6f, 0x6c, 0x6c, 0x61, 0x72, 0x00, 0x42, 0x75, 0x6e, 0x6b,
+    0x65, 0x72, 0x00, 0x41, 0x73, 0x62, 0x75, 0x72, 0x79, 0x00, 0x41, 0x67,
+    0x75, 0x69, 0x61, 0x72, 0x00, 0x54, 0x61, 0x6c, 0x62, 0x6f, 0x74, 0x74,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x61, 0x72, 0x64, 0x00, 0x50, 0x6c,
+    0x65, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x00, 0x4d, 0x6f, 0x77, 0x65, 0x72,
+    0x79, 0x00, 0x4d, 0x65, 0x61, 0x72, 0x73, 0x00, 0x4c, 0x65, 0x6d, 0x6d,
+    0x6f, 0x6e, 0x00, 0x4b, 0x72, 0x69, 0x65, 0x67, 0x65, 0x72, 0x00, 0x48,
+    0x69, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x00, 0x47, 0x72, 0x61, 0x63, 0x69,
+    0x61, 0x00, 0x45, 0x6c, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x44, 0x75, 0x6f,
+    0x6e, 0x67, 0x00, 0x44, 0x65, 0x6c, 0x67, 0x61, 0x64, 0x69, 0x6c, 0x6c,
+    0x6f, 0x00, 0x44, 0x61, 0x79, 0x74, 0x6f, 0x6e, 0x00, 0x44, 0x61, 0x73,
+    0x69, 0x6c, 0x76, 0x61, 0x00, 0x43, 0x6f, 0x6e, 0x61, 0x77, 0x61, 0x79,
+    0x00, 0x43, 0x61, 0x74, 0x72, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x75, 0x74,
+    0x6f, 0x6e, 0x00, 0x42, 0x72, 0x61, 0x64, 0x62, 0x75, 0x72, 0x79, 0x00,
+    0x42, 0x6f, 0x72, 0x64, 0x65, 0x6c, 0x6f, 0x6e, 0x00, 0x42, 0x69, 0x76,
+    0x69, 0x6e, 0x73, 0x00, 0x42, 0x69, 0x74, 0x74, 0x6e, 0x65, 0x72, 0x00,
+    0x42, 0x65, 0x72, 0x67, 0x73, 0x74, 0x72, 0x6f, 0x6d, 0x00, 0x42, 0x65,
+    0x61, 0x6c, 0x73, 0x00, 0x41, 0x62, 0x65, 0x6c, 0x6c, 0x00, 0x57, 0x68,
+    0x65, 0x6c, 0x61, 0x6e, 0x00, 0x54, 0x72, 0x61, 0x76, 0x65, 0x72, 0x73,
+    0x00, 0x54, 0x65, 0x6a, 0x61, 0x64, 0x61, 0x00, 0x50, 0x75, 0x6c, 0x6c,
+    0x65, 0x79, 0x00, 0x50, 0x69, 0x6e, 0x6f, 0x00, 0x4e, 0x6f, 0x72, 0x66,
+    0x6c, 0x65, 0x65, 0x74, 0x00, 0x4e, 0x65, 0x61, 0x6c, 0x79, 0x00, 0x4d,
+    0x61, 0x65, 0x73, 0x00, 0x4c, 0x6f, 0x70, 0x65, 0x72, 0x00, 0x48, 0x65,
+    0x6c, 0x64, 0x00, 0x47, 0x65, 0x72, 0x61, 0x6c, 0x64, 0x00, 0x47, 0x61,
+    0x74, 0x65, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x46, 0x72, 0x69, 0x65, 0x72,
+    0x73, 0x6f, 0x6e, 0x00, 0x46, 0x72, 0x65, 0x75, 0x6e, 0x64, 0x00, 0x46,
+    0x69, 0x6e, 0x6e, 0x65, 0x67, 0x61, 0x6e, 0x00, 0x43, 0x75, 0x70, 0x70,
+    0x00, 0x43, 0x6f, 0x76, 0x65, 0x79, 0x00, 0x43, 0x61, 0x74, 0x61, 0x6c,
+    0x61, 0x6e, 0x6f, 0x00, 0x42, 0x6f, 0x65, 0x68, 0x6d, 0x00, 0x42, 0x61,
+    0x64, 0x65, 0x72, 0x00, 0x59, 0x6f, 0x6f, 0x6e, 0x00, 0x57, 0x61, 0x6c,
+    0x73, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x79, 0x00,
+    0x53, 0x69, 0x70, 0x65, 0x73, 0x00, 0x52, 0x6f, 0x6c, 0x6c, 0x65, 0x72,
+    0x00, 0x52, 0x61, 0x77, 0x6c, 0x69, 0x6e, 0x73, 0x00, 0x4d, 0x65, 0x64,
+    0x6c, 0x6f, 0x63, 0x6b, 0x00, 0x4d, 0x63, 0x63, 0x61, 0x73, 0x6b, 0x69,
+    0x6c, 0x6c, 0x00, 0x4d, 0x63, 0x63, 0x61, 0x6c, 0x6c, 0x69, 0x73, 0x74,
+    0x65, 0x72, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x6f, 0x74, 0x74, 0x65, 0x00,
+    0x4d, 0x61, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x00, 0x48, 0x75, 0x67, 0x68,
+    0x65, 0x79, 0x00, 0x48, 0x65, 0x6e, 0x6b, 0x65, 0x00, 0x48, 0x61, 0x72,
+    0x77, 0x65, 0x6c, 0x6c, 0x00, 0x47, 0x6c, 0x61, 0x64, 0x6e, 0x65, 0x79,
+    0x00, 0x47, 0x69, 0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x44, 0x65, 0x77, 0x00,
+    0x43, 0x68, 0x69, 0x73, 0x6d, 0x00, 0x43, 0x61, 0x73, 0x6b, 0x65, 0x79,
+    0x00, 0x42, 0x72, 0x61, 0x6e, 0x64, 0x65, 0x6e, 0x62, 0x75, 0x72, 0x67,
+    0x00, 0x42, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x00, 0x56, 0x69, 0x6c, 0x6c,
+    0x61, 0x73, 0x65, 0x6e, 0x6f, 0x72, 0x00, 0x56, 0x65, 0x61, 0x6c, 0x00,
+    0x56, 0x61, 0x6e, 0x00, 0x54, 0x68, 0x61, 0x74, 0x63, 0x68, 0x65, 0x72,
+    0x00, 0x53, 0x74, 0x65, 0x67, 0x61, 0x6c, 0x6c, 0x00, 0x53, 0x68, 0x6f,
+    0x72, 0x65, 0x00, 0x50, 0x65, 0x74, 0x72, 0x69, 0x65, 0x00, 0x4e, 0x6f,
+    0x77, 0x6c, 0x69, 0x6e, 0x00, 0x4e, 0x61, 0x76, 0x61, 0x72, 0x72, 0x65,
+    0x74, 0x65, 0x00, 0x4d, 0x75, 0x68, 0x61, 0x6d, 0x6d, 0x61, 0x64, 0x00,
+    0x4c, 0x6f, 0x6d, 0x62, 0x61, 0x72, 0x64, 0x00, 0x4c, 0x6f, 0x66, 0x74,
+    0x69, 0x6e, 0x00, 0x4c, 0x65, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x00,
+    0x4b, 0x72, 0x6f, 0x6c, 0x6c, 0x00, 0x4b, 0x6f, 0x76, 0x61, 0x63, 0x68,
+    0x00, 0x4b, 0x69, 0x6d, 0x62, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x4b, 0x69,
+    0x64, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x48, 0x65, 0x72, 0x73, 0x68, 0x62,
+    0x65, 0x72, 0x67, 0x65, 0x72, 0x00, 0x46, 0x75, 0x6c, 0x63, 0x68, 0x65,
+    0x72, 0x00, 0x45, 0x6e, 0x67, 0x00, 0x43, 0x61, 0x6e, 0x74, 0x77, 0x65,
+    0x6c, 0x6c, 0x00, 0x42, 0x75, 0x73, 0x74, 0x6f, 0x73, 0x00, 0x42, 0x6f,
+    0x6c, 0x61, 0x6e, 0x64, 0x00, 0x42, 0x6f, 0x62, 0x62, 0x69, 0x74, 0x74,
+    0x00, 0x42, 0x69, 0x6e, 0x6b, 0x6c, 0x65, 0x79, 0x00, 0x57, 0x65, 0x73,
+    0x74, 0x65, 0x72, 0x00, 0x57, 0x65, 0x69, 0x73, 0x00, 0x56, 0x65, 0x72,
+    0x64, 0x69, 0x6e, 0x00, 0x54, 0x6f, 0x6e, 0x67, 0x00, 0x54, 0x69, 0x6c,
+    0x6c, 0x65, 0x72, 0x00, 0x53, 0x69, 0x73, 0x63, 0x6f, 0x00, 0x53, 0x68,
+    0x61, 0x72, 0x6b, 0x65, 0x79, 0x00, 0x53, 0x65, 0x79, 0x6d, 0x6f, 0x72,
+    0x65, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x6e, 0x62, 0x61, 0x75, 0x6d, 0x00,
+    0x52, 0x6f, 0x68, 0x72, 0x00, 0x51, 0x75, 0x69, 0x6e, 0x6f, 0x6e, 0x65,
+    0x7a, 0x00, 0x50, 0x69, 0x6e, 0x6b, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x4e,
+    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x6c, 0x6c, 0x65, 0x79,
+    0x00, 0x4c, 0x6f, 0x67, 0x75, 0x65, 0x00, 0x4c, 0x65, 0x73, 0x73, 0x61,
+    0x72, 0x64, 0x00, 0x4c, 0x65, 0x72, 0x6e, 0x65, 0x72, 0x00, 0x4c, 0x65,
+    0x62, 0x72, 0x6f, 0x6e, 0x00, 0x4b, 0x72, 0x61, 0x75, 0x73, 0x73, 0x00,
+    0x4b, 0x6c, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x48, 0x61, 0x6c, 0x73,
+    0x74, 0x65, 0x61, 0x64, 0x00, 0x48, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x00,
+    0x47, 0x65, 0x74, 0x7a, 0x00, 0x42, 0x75, 0x72, 0x72, 0x6f, 0x77, 0x00,
+    0x42, 0x72, 0x61, 0x6e, 0x74, 0x00, 0x41, 0x6c, 0x67, 0x65, 0x72, 0x00,
+    0x56, 0x69, 0x63, 0x74, 0x6f, 0x72, 0x00, 0x53, 0x68, 0x6f, 0x72, 0x65,
+    0x73, 0x00, 0x53, 0x63, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x50, 0x6f, 0x75,
+    0x6e, 0x64, 0x73, 0x00, 0x50, 0x66, 0x65, 0x69, 0x66, 0x65, 0x72, 0x00,
+    0x50, 0x65, 0x72, 0x72, 0x6f, 0x6e, 0x00, 0x4e, 0x65, 0x6c, 0x6d, 0x73,
+    0x00, 0x4d, 0x75, 0x6e, 0x6e, 0x00, 0x4d, 0x63, 0x6d, 0x61, 0x73, 0x74,
+    0x65, 0x72, 0x00, 0x4d, 0x63, 0x6b, 0x65, 0x6e, 0x6e, 0x65, 0x79, 0x00,
+    0x4d, 0x61, 0x6e, 0x6e, 0x73, 0x00, 0x4b, 0x6e, 0x75, 0x64, 0x73, 0x6f,
+    0x6e, 0x00, 0x48, 0x75, 0x74, 0x63, 0x68, 0x65, 0x6e, 0x73, 0x00, 0x48,
+    0x75, 0x73, 0x6b, 0x65, 0x79, 0x00, 0x47, 0x6f, 0x65, 0x62, 0x65, 0x6c,
+    0x00, 0x46, 0x6c, 0x61, 0x67, 0x67, 0x00, 0x43, 0x75, 0x73, 0x68, 0x6d,
+    0x61, 0x6e, 0x00, 0x43, 0x6c, 0x69, 0x63, 0x6b, 0x00, 0x43, 0x61, 0x73,
+    0x74, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x6f, 0x00, 0x43, 0x61, 0x72, 0x64,
+    0x65, 0x72, 0x00, 0x42, 0x75, 0x6d, 0x67, 0x61, 0x72, 0x6e, 0x65, 0x72,
+    0x00, 0x42, 0x6c, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x42, 0x69, 0x62, 0x6c,
+    0x65, 0x00, 0x57, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x72, 0x00, 0x53, 0x70,
+    0x69, 0x6e, 0x6b, 0x73, 0x00, 0x52, 0x6f, 0x62, 0x73, 0x6f, 0x6e, 0x00,
+    0x4e, 0x65, 0x65, 0x6c, 0x00, 0x4d, 0x63, 0x72, 0x65, 0x79, 0x6e, 0x6f,
+    0x6c, 0x64, 0x73, 0x00, 0x4d, 0x61, 0x74, 0x68, 0x69, 0x61, 0x73, 0x00,
+    0x4d, 0x61, 0x61, 0x73, 0x00, 0x4c, 0x6f, 0x65, 0x72, 0x61, 0x00, 0x4b,
+    0x61, 0x73, 0x70, 0x65, 0x72, 0x00, 0x4a, 0x6f, 0x73, 0x65, 0x00, 0x4a,
+    0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x65, 0x7a,
+    0x00, 0x43, 0x6f, 0x6f, 0x6e, 0x73, 0x00, 0x42, 0x75, 0x63, 0x6b, 0x69,
+    0x6e, 0x67, 0x68, 0x61, 0x6d, 0x00, 0x42, 0x72, 0x6f, 0x67, 0x61, 0x6e,
+    0x00, 0x42, 0x65, 0x72, 0x72, 0x79, 0x6d, 0x61, 0x6e, 0x00, 0x57, 0x69,
+    0x6c, 0x6d, 0x6f, 0x74, 0x68, 0x00, 0x57, 0x69, 0x6c, 0x68, 0x69, 0x74,
+    0x65, 0x00, 0x54, 0x68, 0x72, 0x61, 0x73, 0x68, 0x00, 0x53, 0x68, 0x65,
+    0x70, 0x68, 0x61, 0x72, 0x64, 0x00, 0x53, 0x65, 0x69, 0x64, 0x65, 0x6c,
+    0x00, 0x53, 0x63, 0x68, 0x75, 0x6c, 0x7a, 0x65, 0x00, 0x52, 0x6f, 0x6c,
+    0x64, 0x61, 0x6e, 0x00, 0x50, 0x65, 0x74, 0x74, 0x69, 0x73, 0x00, 0x4f,
+    0x62, 0x72, 0x79, 0x61, 0x6e, 0x00, 0x4d, 0x61, 0x6b, 0x69, 0x00, 0x4d,
+    0x61, 0x63, 0x6b, 0x69, 0x65, 0x00, 0x48, 0x61, 0x74, 0x6c, 0x65, 0x79,
+    0x00, 0x46, 0x72, 0x61, 0x7a, 0x65, 0x72, 0x00, 0x46, 0x69, 0x6f, 0x72,
+    0x65, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x73, 0x00, 0x43, 0x68, 0x65, 0x73,
+    0x73, 0x65, 0x72, 0x00, 0x42, 0x75, 0x69, 0x00, 0x42, 0x6f, 0x74, 0x74,
+    0x6f, 0x6d, 0x73, 0x00, 0x42, 0x69, 0x73, 0x73, 0x6f, 0x6e, 0x00, 0x42,
+    0x65, 0x6e, 0x65, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x41, 0x6c, 0x6c,
+    0x6d, 0x61, 0x6e, 0x00, 0x57, 0x69, 0x6c, 0x6b, 0x65, 0x00, 0x54, 0x72,
+    0x75, 0x64, 0x65, 0x61, 0x75, 0x00, 0x54, 0x69, 0x6d, 0x6d, 0x00, 0x53,
+    0x68, 0x69, 0x66, 0x66, 0x6c, 0x65, 0x74, 0x74, 0x00, 0x52, 0x61, 0x75,
+    0x00, 0x4d, 0x75, 0x6e, 0x64, 0x79, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x69,
+    0x6b, 0x65, 0x6e, 0x00, 0x4d, 0x61, 0x79, 0x65, 0x72, 0x73, 0x00, 0x4c,
+    0x65, 0x61, 0x6b, 0x65, 0x00, 0x4b, 0x6f, 0x68, 0x6e, 0x00, 0x48, 0x75,
+    0x6e, 0x74, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x48, 0x6f, 0x72,
+    0x73, 0x6c, 0x65, 0x79, 0x00, 0x48, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x6e,
+    0x00, 0x47, 0x75, 0x65, 0x72, 0x69, 0x6e, 0x00, 0x46, 0x72, 0x79, 0x65,
+    0x72, 0x00, 0x46, 0x72, 0x69, 0x7a, 0x7a, 0x65, 0x6c, 0x6c, 0x00, 0x46,
+    0x6f, 0x72, 0x65, 0x74, 0x00, 0x46, 0x6c, 0x65, 0x6d, 0x6d, 0x69, 0x6e,
+    0x67, 0x00, 0x46, 0x69, 0x66, 0x65, 0x00, 0x43, 0x72, 0x69, 0x73, 0x77,
+    0x65, 0x6c, 0x6c, 0x00, 0x43, 0x61, 0x72, 0x62, 0x61, 0x6a, 0x61, 0x6c,
+    0x00, 0x42, 0x6f, 0x7a, 0x65, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x6f, 0x69,
+    0x73, 0x76, 0x65, 0x72, 0x74, 0x00, 0x41, 0x72, 0x63, 0x68, 0x69, 0x65,
+    0x00, 0x41, 0x6e, 0x74, 0x6f, 0x6e, 0x69, 0x6f, 0x00, 0x41, 0x6e, 0x67,
+    0x75, 0x6c, 0x6f, 0x00, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x54,
+    0x61, 0x70, 0x70, 0x00, 0x53, 0x69, 0x6c, 0x76, 0x65, 0x72, 0x73, 0x00,
+    0x52, 0x61, 0x6d, 0x73, 0x61, 0x79, 0x00, 0x4f, 0x73, 0x68, 0x65, 0x61,
+    0x00, 0x4f, 0x72, 0x74, 0x61, 0x00, 0x4d, 0x6f, 0x6c, 0x6c, 0x00, 0x4d,
+    0x63, 0x6b, 0x65, 0x65, 0x76, 0x65, 0x72, 0x00, 0x4d, 0x63, 0x67, 0x65,
+    0x68, 0x65, 0x65, 0x00, 0x4c, 0x75, 0x63, 0x69, 0x61, 0x6e, 0x6f, 0x00,
+    0x4c, 0x69, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4b, 0x69, 0x65,
+    0x66, 0x65, 0x72, 0x00, 0x4b, 0x65, 0x74, 0x63, 0x68, 0x75, 0x6d, 0x00,
+    0x48, 0x6f, 0x77, 0x65, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x47, 0x72, 0x6f,
+    0x63, 0x65, 0x00, 0x47, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x64, 0x00, 0x47,
+    0x61, 0x73, 0x73, 0x00, 0x46, 0x75, 0x73, 0x63, 0x6f, 0x00, 0x43, 0x6f,
+    0x72, 0x62, 0x69, 0x74, 0x74, 0x00, 0x42, 0x6c, 0x79, 0x74, 0x68, 0x65,
+    0x00, 0x42, 0x65, 0x74, 0x7a, 0x00, 0x42, 0x61, 0x72, 0x74, 0x65, 0x6c,
+    0x73, 0x00, 0x41, 0x6d, 0x61, 0x72, 0x61, 0x6c, 0x00, 0x41, 0x69, 0x65,
+    0x6c, 0x6c, 0x6f, 0x00, 0x59, 0x6f, 0x6f, 0x00, 0x57, 0x65, 0x64, 0x64,
+    0x6c, 0x65, 0x00, 0x54, 0x72, 0x6f, 0x79, 0x00, 0x53, 0x75, 0x6e, 0x00,
+    0x53, 0x70, 0x65, 0x72, 0x72, 0x79, 0x00, 0x53, 0x65, 0x69, 0x6c, 0x65,
+    0x72, 0x00, 0x52, 0x75, 0x6e, 0x79, 0x61, 0x6e, 0x00, 0x52, 0x61, 0x6c,
+    0x65, 0x79, 0x00, 0x4f, 0x76, 0x65, 0x72, 0x62, 0x79, 0x00, 0x4f, 0x73,
+    0x74, 0x65, 0x65, 0x6e, 0x00, 0x4f, 0x6c, 0x64, 0x73, 0x00, 0x4d, 0x63,
+    0x6b, 0x65, 0x6f, 0x77, 0x6e, 0x00, 0x4d, 0x61, 0x75, 0x72, 0x6f, 0x00,
+    0x4d, 0x61, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x4c, 0x61, 0x75, 0x65, 0x72,
+    0x00, 0x4c, 0x61, 0x74, 0x74, 0x69, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x48,
+    0x69, 0x6e, 0x64, 0x6d, 0x61, 0x6e, 0x00, 0x48, 0x61, 0x72, 0x74, 0x77,
+    0x65, 0x6c, 0x6c, 0x00, 0x46, 0x72, 0x65, 0x64, 0x72, 0x69, 0x63, 0x6b,
+    0x73, 0x6f, 0x6e, 0x00, 0x46, 0x72, 0x65, 0x64, 0x65, 0x72, 0x69, 0x63,
+    0x6b, 0x73, 0x00, 0x45, 0x73, 0x70, 0x69, 0x6e, 0x6f, 0x00, 0x43, 0x6c,
+    0x65, 0x67, 0x67, 0x00, 0x43, 0x61, 0x72, 0x73, 0x77, 0x65, 0x6c, 0x6c,
+    0x00, 0x43, 0x61, 0x6d, 0x62, 0x65, 0x6c, 0x6c, 0x00, 0x42, 0x75, 0x72,
+    0x6b, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x00, 0x41, 0x75, 0x67, 0x75,
+    0x73, 0x74, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x62, 0x75, 0x72, 0x79, 0x00,
+    0x57, 0x65, 0x6c, 0x6b, 0x65, 0x72, 0x00, 0x54, 0x6f, 0x74, 0x74, 0x65,
+    0x6e, 0x00, 0x54, 0x68, 0x6f, 0x72, 0x6e, 0x62, 0x75, 0x72, 0x67, 0x00,
+    0x54, 0x68, 0x65, 0x72, 0x69, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x53, 0x74,
+    0x69, 0x74, 0x74, 0x00, 0x53, 0x74, 0x61, 0x6d, 0x6d, 0x00, 0x53, 0x74,
+    0x61, 0x63, 0x6b, 0x68, 0x6f, 0x75, 0x73, 0x65, 0x00, 0x53, 0x69, 0x6d,
+    0x6f, 0x6e, 0x65, 0x00, 0x53, 0x63, 0x68, 0x6f, 0x6c, 0x6c, 0x00, 0x53,
+    0x61, 0x78, 0x6f, 0x6e, 0x00, 0x52, 0x69, 0x66, 0x65, 0x00, 0x52, 0x61,
+    0x7a, 0x6f, 0x00, 0x51, 0x75, 0x69, 0x6e, 0x6c, 0x61, 0x6e, 0x00, 0x50,
+    0x69, 0x6e, 0x6b, 0x65, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x4f, 0x6c, 0x69,
+    0x76, 0x6f, 0x00, 0x4e, 0x65, 0x73, 0x6d, 0x69, 0x74, 0x68, 0x00, 0x4e,
+    0x61, 0x6c, 0x6c, 0x00, 0x4d, 0x61, 0x74, 0x74, 0x6f, 0x73, 0x00, 0x4c,
+    0x65, 0x61, 0x6b, 0x00, 0x4c, 0x61, 0x66, 0x66, 0x65, 0x72, 0x74, 0x79,
+    0x00, 0x4a, 0x75, 0x73, 0x74, 0x75, 0x73, 0x00, 0x47, 0x69, 0x72, 0x6f,
+    0x6e, 0x00, 0x47, 0x65, 0x65, 0x72, 0x00, 0x46, 0x69, 0x65, 0x6c, 0x64,
+    0x65, 0x72, 0x00, 0x45, 0x61, 0x67, 0x6c, 0x65, 0x00, 0x44, 0x72, 0x61,
+    0x79, 0x74, 0x6f, 0x6e, 0x00, 0x44, 0x6f, 0x72, 0x74, 0x63, 0x68, 0x00,
+    0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x43, 0x6f, 0x6e, 0x67,
+    0x65, 0x72, 0x00, 0x43, 0x68, 0x61, 0x75, 0x00, 0x42, 0x6f, 0x61, 0x74,
+    0x77, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x42, 0x69, 0x6c, 0x6c, 0x69,
+    0x6f, 0x74, 0x00, 0x42, 0x61, 0x72, 0x64, 0x65, 0x6e, 0x00, 0x41, 0x72,
+    0x6d, 0x65, 0x6e, 0x74, 0x61, 0x00, 0x41, 0x6e, 0x74, 0x6f, 0x69, 0x6e,
+    0x65, 0x00, 0x54, 0x69, 0x62, 0x62, 0x65, 0x74, 0x74, 0x73, 0x00, 0x53,
+    0x74, 0x65, 0x61, 0x64, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x6c, 0x61, 0x74,
+    0x74, 0x65, 0x72, 0x79, 0x00, 0x53, 0x69, 0x64, 0x65, 0x73, 0x00, 0x52,
+    0x69, 0x6e, 0x61, 0x6c, 0x64, 0x69, 0x00, 0x52, 0x61, 0x79, 0x6e, 0x6f,
+    0x72, 0x00, 0x52, 0x61, 0x79, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x50, 0x69,
+    0x6e, 0x63, 0x6b, 0x6e, 0x65, 0x79, 0x00, 0x50, 0x65, 0x74, 0x74, 0x69,
+    0x67, 0x72, 0x65, 0x77, 0x00, 0x4e, 0x69, 0x63, 0x6b, 0x65, 0x6c, 0x00,
+    0x4d, 0x69, 0x6c, 0x6e, 0x65, 0x00, 0x4d, 0x61, 0x74, 0x74, 0x65, 0x73,
+    0x6f, 0x6e, 0x00, 0x48, 0x61, 0x6c, 0x73, 0x65, 0x79, 0x00, 0x47, 0x6f,
+    0x6e, 0x73, 0x61, 0x6c, 0x76, 0x65, 0x73, 0x00, 0x46, 0x65, 0x6c, 0x6c,
+    0x6f, 0x77, 0x73, 0x00, 0x44, 0x75, 0x72, 0x61, 0x6e, 0x64, 0x00, 0x44,
+    0x65, 0x73, 0x69, 0x6d, 0x6f, 0x6e, 0x65, 0x00, 0x43, 0x6f, 0x77, 0x6c,
+    0x65, 0x79, 0x00, 0x43, 0x6f, 0x77, 0x6c, 0x65, 0x73, 0x00, 0x42, 0x72,
+    0x69, 0x6c, 0x6c, 0x00, 0x42, 0x61, 0x72, 0x68, 0x61, 0x6d, 0x00, 0x42,
+    0x61, 0x72, 0x65, 0x6c, 0x61, 0x00, 0x42, 0x61, 0x72, 0x62, 0x61, 0x00,
+    0x41, 0x73, 0x68, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x57, 0x69, 0x74, 0x68,
+    0x72, 0x6f, 0x77, 0x00, 0x56, 0x61, 0x6c, 0x65, 0x6e, 0x74, 0x69, 0x00,
+    0x54, 0x65, 0x6a, 0x65, 0x64, 0x61, 0x00, 0x53, 0x70, 0x72, 0x69, 0x67,
+    0x67, 0x73, 0x00, 0x53, 0x61, 0x79, 0x72, 0x65, 0x00, 0x53, 0x61, 0x6c,
+    0x65, 0x72, 0x6e, 0x6f, 0x00, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x00, 0x50,
+    0x65, 0x6c, 0x74, 0x69, 0x65, 0x72, 0x00, 0x50, 0x65, 0x65, 0x6c, 0x00,
+    0x4d, 0x65, 0x72, 0x72, 0x69, 0x6d, 0x61, 0x6e, 0x00, 0x4d, 0x61, 0x74,
+    0x68, 0x65, 0x73, 0x6f, 0x6e, 0x00, 0x4c, 0x6f, 0x77, 0x6d, 0x61, 0x6e,
+    0x00, 0x4c, 0x69, 0x6e, 0x64, 0x73, 0x74, 0x72, 0x6f, 0x6d, 0x00, 0x48,
+    0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x48, 0x6f, 0x6d, 0x65, 0x72, 0x00,
+    0x48, 0x61, 0x00, 0x47, 0x69, 0x72, 0x6f, 0x75, 0x78, 0x00, 0x46, 0x72,
+    0x69, 0x65, 0x73, 0x00, 0x46, 0x72, 0x61, 0x73, 0x69, 0x65, 0x72, 0x00,
+    0x45, 0x61, 0x72, 0x6c, 0x73, 0x00, 0x44, 0x75, 0x67, 0x61, 0x73, 0x00,
+    0x44, 0x61, 0x6d, 0x6f, 0x6e, 0x00, 0x44, 0x61, 0x62, 0x6e, 0x65, 0x79,
+    0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x61, 0x64, 0x6f, 0x00, 0x42, 0x72, 0x69,
+    0x73, 0x65, 0x6e, 0x6f, 0x00, 0x42, 0x61, 0x78, 0x6c, 0x65, 0x79, 0x00,
+    0x41, 0x6e, 0x64, 0x72, 0x65, 0x00, 0x57, 0x6f, 0x72, 0x64, 0x00, 0x57,
+    0x68, 0x79, 0x74, 0x65, 0x00, 0x57, 0x65, 0x6e, 0x67, 0x65, 0x72, 0x00,
+    0x56, 0x61, 0x6e, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x56, 0x61, 0x6e, 0x62,
+    0x75, 0x72, 0x65, 0x6e, 0x00, 0x54, 0x68, 0x69, 0x65, 0x6c, 0x00, 0x53,
+    0x63, 0x68, 0x69, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00, 0x53, 0x63, 0x68,
+    0x69, 0x6c, 0x6c, 0x65, 0x72, 0x00, 0x52, 0x69, 0x67, 0x62, 0x79, 0x00,
+    0x50, 0x6f, 0x6d, 0x65, 0x72, 0x6f, 0x79, 0x00, 0x50, 0x61, 0x73, 0x73,
+    0x6d, 0x6f, 0x72, 0x65, 0x00, 0x4d, 0x61, 0x72, 0x62, 0x6c, 0x65, 0x00,
+    0x4d, 0x61, 0x6e, 0x7a, 0x6f, 0x00, 0x4d, 0x61, 0x68, 0x61, 0x66, 0x66,
+    0x65, 0x79, 0x00, 0x4c, 0x69, 0x6e, 0x64, 0x67, 0x72, 0x65, 0x6e, 0x00,
+    0x4c, 0x61, 0x66, 0x6c, 0x61, 0x6d, 0x6d, 0x65, 0x00, 0x47, 0x72, 0x65,
+    0x61, 0x74, 0x68, 0x6f, 0x75, 0x73, 0x65, 0x00, 0x46, 0x69, 0x74, 0x65,
+    0x00, 0x46, 0x65, 0x72, 0x72, 0x61, 0x72, 0x69, 0x00, 0x43, 0x61, 0x6c,
+    0x61, 0x62, 0x72, 0x65, 0x73, 0x65, 0x00, 0x42, 0x61, 0x79, 0x6e, 0x65,
+    0x00, 0x59, 0x61, 0x6d, 0x61, 0x6d, 0x6f, 0x74, 0x6f, 0x00, 0x57, 0x69,
+    0x63, 0x6b, 0x00, 0x54, 0x6f, 0x77, 0x6e, 0x65, 0x73, 0x00, 0x54, 0x68,
+    0x61, 0x6d, 0x65, 0x73, 0x00, 0x53, 0x74, 0x65, 0x65, 0x6c, 0x00, 0x52,
+    0x65, 0x69, 0x6e, 0x68, 0x61, 0x72, 0x74, 0x00, 0x50, 0x65, 0x65, 0x6c,
+    0x65, 0x72, 0x00, 0x4e, 0x61, 0x72, 0x61, 0x6e, 0x6a, 0x6f, 0x00, 0x4d,
+    0x6f, 0x6e, 0x74, 0x65, 0x7a, 0x00, 0x4d, 0x63, 0x64, 0x61, 0x64, 0x65,
+    0x00, 0x4d, 0x61, 0x73, 0x74, 0x00, 0x4d, 0x61, 0x72, 0x6b, 0x6c, 0x65,
+    0x79, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x61, 0x6e, 0x64, 0x00, 0x4c,
+    0x65, 0x65, 0x70, 0x65, 0x72, 0x00, 0x4b, 0x6f, 0x6e, 0x67, 0x00, 0x4b,
+    0x65, 0x6c, 0x6c, 0x75, 0x6d, 0x00, 0x48, 0x75, 0x64, 0x67, 0x65, 0x6e,
+    0x73, 0x00, 0x48, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x79, 0x00,
+    0x48, 0x61, 0x64, 0x64, 0x65, 0x6e, 0x00, 0x47, 0x75, 0x65, 0x73, 0x73,
+    0x00, 0x47, 0x61, 0x69, 0x6e, 0x65, 0x79, 0x00, 0x43, 0x6f, 0x70, 0x70,
+    0x6f, 0x6c, 0x61, 0x00, 0x42, 0x6f, 0x72, 0x72, 0x65, 0x67, 0x6f, 0x00,
+    0x42, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x42, 0x65, 0x61, 0x6e,
+    0x65, 0x00, 0x41, 0x75, 0x6c, 0x74, 0x00, 0x53, 0x6c, 0x61, 0x74, 0x6f,
+    0x6e, 0x00, 0x50, 0x6f, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x50, 0x61, 0x70,
+    0x65, 0x00, 0x4e, 0x75, 0x6c, 0x6c, 0x00, 0x4d, 0x75, 0x6c, 0x6b, 0x65,
+    0x79, 0x00, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x65, 0x72, 0x00, 0x4c,
+    0x61, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x61, 0x72,
+    0x64, 0x00, 0x47, 0x6c, 0x61, 0x73, 0x67, 0x6f, 0x77, 0x00, 0x46, 0x61,
+    0x62, 0x69, 0x61, 0x6e, 0x00, 0x45, 0x74, 0x68, 0x72, 0x69, 0x64, 0x67,
+    0x65, 0x00, 0x45, 0x6e, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x44, 0x65,
+    0x72, 0x6f, 0x73, 0x61, 0x00, 0x42, 0x61, 0x73, 0x6b, 0x69, 0x6e, 0x00,
+    0x41, 0x6c, 0x66, 0x72, 0x65, 0x64, 0x00, 0x57, 0x65, 0x69, 0x6e, 0x62,
+    0x65, 0x72, 0x67, 0x00, 0x54, 0x75, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x54,
+    0x69, 0x6e, 0x6b, 0x65, 0x72, 0x00, 0x53, 0x6f, 0x6d, 0x65, 0x72, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x50, 0x61, 0x72, 0x64, 0x6f, 0x00, 0x4e,
+    0x6f, 0x6c, 0x6c, 0x00, 0x4c, 0x61, 0x73, 0x68, 0x6c, 0x65, 0x79, 0x00,
+    0x49, 0x6e, 0x67, 0x72, 0x61, 0x68, 0x61, 0x6d, 0x00, 0x48, 0x69, 0x6c,
+    0x6c, 0x65, 0x72, 0x00, 0x48, 0x65, 0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x47,
+    0x6c, 0x61, 0x7a, 0x65, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x61, 0x00, 0x43,
+    0x6f, 0x74, 0x68, 0x72, 0x61, 0x6e, 0x00, 0x43, 0x6f, 0x6f, 0x6b, 0x73,
+    0x65, 0x79, 0x00, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x00, 0x43, 0x61, 0x72,
+    0x72, 0x69, 0x63, 0x6f, 0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x00, 0x41,
+    0x62, 0x6e, 0x65, 0x72, 0x00, 0x57, 0x6f, 0x6f, 0x6c, 0x65, 0x79, 0x00,
+    0x53, 0x77, 0x6f, 0x70, 0x65, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x6c, 0x69, 0x6e, 0x00, 0x53, 0x74, 0x75, 0x72, 0x67, 0x69, 0x73, 0x00,
+    0x53, 0x74, 0x75, 0x72, 0x64, 0x69, 0x76, 0x61, 0x6e, 0x74, 0x00, 0x53,
+    0x74, 0x6f, 0x74, 0x74, 0x00, 0x53, 0x70, 0x75, 0x72, 0x67, 0x65, 0x6f,
+    0x6e, 0x00, 0x53, 0x70, 0x69, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x00, 0x53,
+    0x70, 0x65, 0x69, 0x67, 0x68, 0x74, 0x00, 0x52, 0x6f, 0x75, 0x73, 0x73,
+    0x65, 0x6c, 0x00, 0x50, 0x6f, 0x70, 0x70, 0x00, 0x4e, 0x75, 0x74, 0x74,
+    0x65, 0x72, 0x00, 0x4d, 0x63, 0x6b, 0x65, 0x6f, 0x6e, 0x00, 0x4d, 0x61,
+    0x7a, 0x7a, 0x61, 0x00, 0x4d, 0x61, 0x67, 0x6e, 0x75, 0x73, 0x6f, 0x6e,
+    0x00, 0x4c, 0x61, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x4b, 0x6f, 0x7a,
+    0x61, 0x6b, 0x00, 0x4a, 0x61, 0x6e, 0x6b, 0x6f, 0x77, 0x73, 0x6b, 0x69,
+    0x00, 0x48, 0x65, 0x79, 0x77, 0x61, 0x72, 0x64, 0x00, 0x46, 0x6f, 0x72,
+    0x73, 0x74, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x72, 0x77, 0x69, 0x6e, 0x00,
+    0x43, 0x61, 0x6c, 0x6c, 0x61, 0x67, 0x68, 0x61, 0x6e, 0x00, 0x42, 0x61,
+    0x79, 0x73, 0x00, 0x57, 0x6f, 0x72, 0x74, 0x68, 0x61, 0x6d, 0x00, 0x55,
+    0x73, 0x68, 0x65, 0x72, 0x00, 0x54, 0x68, 0x65, 0x72, 0x69, 0x6f, 0x74,
+    0x00, 0x53, 0x61, 0x79, 0x65, 0x72, 0x73, 0x00, 0x53, 0x61, 0x62, 0x6f,
+    0x00, 0x52, 0x75, 0x70, 0x65, 0x72, 0x74, 0x00, 0x50, 0x6f, 0x6c, 0x69,
+    0x6e, 0x67, 0x00, 0x4e, 0x61, 0x74, 0x68, 0x61, 0x6e, 0x00, 0x4c, 0x6f,
+    0x79, 0x61, 0x00, 0x4c, 0x69, 0x65, 0x62, 0x65, 0x72, 0x6d, 0x61, 0x6e,
+    0x00, 0x4c, 0x65, 0x76, 0x69, 0x00, 0x4c, 0x61, 0x72, 0x6f, 0x63, 0x68,
+    0x65, 0x00, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x6c, 0x65, 0x00, 0x48, 0x6f,
+    0x77, 0x65, 0x73, 0x00, 0x48, 0x61, 0x72, 0x72, 0x00, 0x47, 0x61, 0x72,
+    0x61, 0x79, 0x00, 0x46, 0x6f, 0x67, 0x61, 0x72, 0x74, 0x79, 0x00, 0x45,
+    0x76, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x44, 0x75, 0x72, 0x6b, 0x69,
+    0x6e, 0x00, 0x44, 0x6f, 0x6d, 0x69, 0x6e, 0x71, 0x75, 0x65, 0x7a, 0x00,
+    0x43, 0x68, 0x61, 0x76, 0x65, 0x73, 0x00, 0x43, 0x68, 0x61, 0x6d, 0x62,
+    0x6c, 0x69, 0x73, 0x73, 0x00, 0x41, 0x6c, 0x66, 0x6f, 0x6e, 0x73, 0x6f,
+    0x00, 0x57, 0x69, 0x74, 0x63, 0x68, 0x65, 0x72, 0x00, 0x57, 0x69, 0x6c,
+    0x62, 0x65, 0x72, 0x00, 0x56, 0x69, 0x65, 0x69, 0x72, 0x61, 0x00, 0x56,
+    0x61, 0x6e, 0x64, 0x69, 0x76, 0x65, 0x72, 0x00, 0x54, 0x65, 0x72, 0x72,
+    0x69, 0x6c, 0x6c, 0x00, 0x53, 0x74, 0x6f, 0x6b, 0x65, 0x72, 0x00, 0x53,
+    0x63, 0x68, 0x72, 0x65, 0x69, 0x6e, 0x65, 0x72, 0x00, 0x4e, 0x65, 0x73,
+    0x74, 0x6f, 0x72, 0x00, 0x4d, 0x6f, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x00,
+    0x4c, 0x69, 0x64, 0x64, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x65, 0x77, 0x00,
+    0x4c, 0x61, 0x77, 0x68, 0x6f, 0x72, 0x6e, 0x00, 0x4b, 0x72, 0x75, 0x67,
+    0x00, 0x49, 0x72, 0x6f, 0x6e, 0x73, 0x00, 0x48, 0x79, 0x6c, 0x74, 0x6f,
+    0x6e, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x65, 0x6e, 0x62, 0x65, 0x63, 0x6b,
+    0x00, 0x48, 0x65, 0x72, 0x72, 0x69, 0x6e, 0x00, 0x48, 0x65, 0x6d, 0x62,
+    0x72, 0x65, 0x65, 0x00, 0x48, 0x61, 0x69, 0x72, 0x00, 0x47, 0x6f, 0x6f,
+    0x6c, 0x73, 0x62, 0x79, 0x00, 0x47, 0x6f, 0x6f, 0x64, 0x69, 0x6e, 0x00,
+    0x47, 0x69, 0x6c, 0x6d, 0x65, 0x72, 0x00, 0x46, 0x6f, 0x6c, 0x74, 0x7a,
+    0x00, 0x44, 0x69, 0x6e, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x44, 0x61, 0x75,
+    0x67, 0x68, 0x74, 0x72, 0x79, 0x00, 0x43, 0x61, 0x62, 0x61, 0x6e, 0x00,
+    0x42, 0x72, 0x69, 0x6d, 0x00, 0x42, 0x72, 0x69, 0x6c, 0x65, 0x79, 0x00,
+    0x42, 0x69, 0x6c, 0x6f, 0x64, 0x65, 0x61, 0x75, 0x00, 0x42, 0x65, 0x61,
+    0x72, 0x00, 0x57, 0x79, 0x61, 0x6e, 0x74, 0x00, 0x56, 0x65, 0x72, 0x67,
+    0x61, 0x72, 0x61, 0x00, 0x54, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x74, 0x00,
+    0x53, 0x77, 0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x65, 0x6e, 0x00, 0x53,
+    0x74, 0x72, 0x6f, 0x75, 0x70, 0x00, 0x53, 0x68, 0x65, 0x72, 0x72, 0x79,
+    0x00, 0x53, 0x63, 0x72, 0x69, 0x62, 0x6e, 0x65, 0x72, 0x00, 0x52, 0x6f,
+    0x67, 0x65, 0x72, 0x00, 0x51, 0x75, 0x69, 0x6c, 0x6c, 0x65, 0x6e, 0x00,
+    0x50, 0x69, 0x74, 0x6d, 0x61, 0x6e, 0x00, 0x4d, 0x6f, 0x6e, 0x61, 0x63,
+    0x6f, 0x00, 0x4d, 0x63, 0x63, 0x61, 0x6e, 0x74, 0x73, 0x00, 0x4d, 0x61,
+    0x78, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69,
+    0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x00,
+    0x48, 0x6f, 0x6c, 0x74, 0x7a, 0x00, 0x46, 0x6c, 0x6f, 0x75, 0x72, 0x6e,
+    0x6f, 0x79, 0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x73, 0x00,
+    0x42, 0x72, 0x6f, 0x64, 0x79, 0x00, 0x42, 0x61, 0x75, 0x6d, 0x67, 0x61,
+    0x72, 0x64, 0x6e, 0x65, 0x72, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x6f,
+    0x00, 0x53, 0x74, 0x72, 0x61, 0x75, 0x62, 0x00, 0x53, 0x69, 0x6c, 0x6c,
+    0x73, 0x00, 0x52, 0x6f, 0x79, 0x62, 0x61, 0x6c, 0x00, 0x52, 0x6f, 0x75,
+    0x6e, 0x64, 0x74, 0x72, 0x65, 0x65, 0x00, 0x4f, 0x73, 0x77, 0x61, 0x6c,
+    0x74, 0x00, 0x4d, 0x6f, 0x6e, 0x65, 0x79, 0x00, 0x4d, 0x63, 0x67, 0x72,
+    0x69, 0x66, 0x66, 0x00, 0x4d, 0x63, 0x64, 0x6f, 0x75, 0x67, 0x61, 0x6c,
+    0x6c, 0x00, 0x4d, 0x63, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x79, 0x00, 0x4d,
+    0x61, 0x67, 0x67, 0x61, 0x72, 0x64, 0x00, 0x47, 0x72, 0x61, 0x67, 0x67,
+    0x00, 0x47, 0x6f, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x47, 0x6f, 0x64,
+    0x69, 0x6e, 0x65, 0x7a, 0x00, 0x44, 0x6f, 0x6f, 0x6c, 0x69, 0x74, 0x74,
+    0x6c, 0x65, 0x00, 0x44, 0x6f, 0x6e, 0x61, 0x74, 0x6f, 0x00, 0x43, 0x6f,
+    0x77, 0x65, 0x6c, 0x6c, 0x00, 0x43, 0x61, 0x73, 0x73, 0x65, 0x6c, 0x6c,
+    0x00, 0x42, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x00, 0x41, 0x70, 0x70,
+    0x65, 0x6c, 0x00, 0x41, 0x68, 0x6d, 0x61, 0x64, 0x00, 0x5a, 0x61, 0x6d,
+    0x62, 0x72, 0x61, 0x6e, 0x6f, 0x00, 0x52, 0x65, 0x75, 0x74, 0x65, 0x72,
+    0x00, 0x50, 0x65, 0x72, 0x65, 0x61, 0x00, 0x4f, 0x6c, 0x69, 0x76, 0x65,
+    0x00, 0x4e, 0x61, 0x6b, 0x61, 0x6d, 0x75, 0x72, 0x61, 0x00, 0x4d, 0x6f,
+    0x6e, 0x61, 0x67, 0x68, 0x61, 0x6e, 0x00, 0x4d, 0x69, 0x63, 0x6b, 0x65,
+    0x6e, 0x73, 0x00, 0x4d, 0x63, 0x63, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x6e,
+    0x00, 0x4d, 0x63, 0x63, 0x6c, 0x61, 0x72, 0x79, 0x00, 0x4d, 0x61, 0x72,
+    0x6c, 0x65, 0x72, 0x00, 0x4b, 0x69, 0x73, 0x68, 0x00, 0x4a, 0x75, 0x64,
+    0x6b, 0x69, 0x6e, 0x73, 0x00, 0x47, 0x69, 0x6c, 0x62, 0x72, 0x65, 0x61,
+    0x74, 0x68, 0x00, 0x46, 0x72, 0x65, 0x65, 0x73, 0x65, 0x00, 0x46, 0x6c,
+    0x61, 0x6e, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x46, 0x65, 0x6c, 0x74, 0x73,
+    0x00, 0x45, 0x72, 0x64, 0x6d, 0x61, 0x6e, 0x6e, 0x00, 0x44, 0x6f, 0x64,
+    0x64, 0x73, 0x00, 0x43, 0x68, 0x65, 0x77, 0x00, 0x42, 0x72, 0x6f, 0x77,
+    0x6e, 0x65, 0x6c, 0x6c, 0x00, 0x42, 0x72, 0x61, 0x7a, 0x69, 0x6c, 0x00,
+    0x42, 0x6f, 0x61, 0x74, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x42, 0x61,
+    0x72, 0x72, 0x65, 0x74, 0x6f, 0x00, 0x53, 0x6c, 0x61, 0x79, 0x74, 0x6f,
+    0x6e, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x62, 0x65, 0x72, 0x67, 0x00, 0x53,
+    0x61, 0x6c, 0x64, 0x69, 0x76, 0x61, 0x72, 0x00, 0x50, 0x65, 0x74, 0x74,
+    0x77, 0x61, 0x79, 0x00, 0x4f, 0x64, 0x75, 0x6d, 0x00, 0x4e, 0x61, 0x72,
+    0x76, 0x61, 0x65, 0x7a, 0x00, 0x4d, 0x6f, 0x75, 0x6c, 0x74, 0x72, 0x69,
+    0x65, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x6d, 0x61, 0x79, 0x6f, 0x72,
+    0x00, 0x4d, 0x65, 0x72, 0x72, 0x65, 0x6c, 0x6c, 0x00, 0x4c, 0x65, 0x65,
+    0x73, 0x00, 0x4b, 0x65, 0x79, 0x73, 0x65, 0x72, 0x00, 0x48, 0x6f, 0x6b,
+    0x65, 0x00, 0x48, 0x61, 0x72, 0x64, 0x61, 0x77, 0x61, 0x79, 0x00, 0x48,
+    0x61, 0x6e, 0x6e, 0x61, 0x6e, 0x00, 0x47, 0x69, 0x6c, 0x62, 0x65, 0x72,
+    0x74, 0x73, 0x6f, 0x6e, 0x00, 0x46, 0x6f, 0x67, 0x67, 0x00, 0x44, 0x75,
+    0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x44, 0x65, 0x62, 0x65, 0x72, 0x72, 0x79,
+    0x00, 0x43, 0x6f, 0x67, 0x67, 0x69, 0x6e, 0x73, 0x00, 0x43, 0x61, 0x72,
+    0x72, 0x65, 0x72, 0x61, 0x00, 0x42, 0x75, 0x78, 0x74, 0x6f, 0x6e, 0x00,
+    0x42, 0x75, 0x63, 0x68, 0x65, 0x72, 0x00, 0x42, 0x72, 0x6f, 0x61, 0x64,
+    0x6e, 0x61, 0x78, 0x00, 0x42, 0x65, 0x65, 0x73, 0x6f, 0x6e, 0x00, 0x41,
+    0x72, 0x61, 0x75, 0x6a, 0x6f, 0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x74,
+    0x6f, 0x6e, 0x00, 0x41, 0x6d, 0x75, 0x6e, 0x64, 0x73, 0x6f, 0x6e, 0x00,
+    0x41, 0x67, 0x75, 0x61, 0x79, 0x6f, 0x00, 0x41, 0x63, 0x6b, 0x6c, 0x65,
+    0x79, 0x00, 0x59, 0x6f, 0x63, 0x75, 0x6d, 0x00, 0x57, 0x6f, 0x72, 0x73,
+    0x68, 0x61, 0x6d, 0x00, 0x53, 0x68, 0x69, 0x76, 0x65, 0x72, 0x73, 0x00,
+    0x53, 0x68, 0x65, 0x6c, 0x6c, 0x79, 0x00, 0x53, 0x61, 0x6e, 0x63, 0x68,
+    0x65, 0x73, 0x00, 0x53, 0x61, 0x63, 0x63, 0x6f, 0x00, 0x52, 0x6f, 0x62,
+    0x65, 0x79, 0x00, 0x52, 0x68, 0x6f, 0x64, 0x65, 0x6e, 0x00, 0x50, 0x65,
+    0x6e, 0x64, 0x65, 0x72, 0x00, 0x4f, 0x63, 0x68, 0x73, 0x00, 0x4d, 0x63,
+    0x63, 0x75, 0x72, 0x72, 0x79, 0x00, 0x4d, 0x61, 0x64, 0x65, 0x72, 0x61,
+    0x00, 0x4c, 0x75, 0x6f, 0x6e, 0x67, 0x00, 0x4c, 0x75, 0x69, 0x73, 0x00,
+    0x4b, 0x6e, 0x6f, 0x74, 0x74, 0x73, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x6d,
+    0x61, 0x6e, 0x00, 0x48, 0x65, 0x69, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x00,
+    0x48, 0x61, 0x72, 0x67, 0x72, 0x61, 0x76, 0x65, 0x00, 0x47, 0x61, 0x75,
+    0x6c, 0x74, 0x00, 0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x00, 0x43, 0x6f,
+    0x6d, 0x65, 0x61, 0x75, 0x78, 0x00, 0x43, 0x68, 0x69, 0x74, 0x77, 0x6f,
+    0x6f, 0x64, 0x00, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x00, 0x43, 0x61, 0x72,
+    0x61, 0x77, 0x61, 0x79, 0x00, 0x42, 0x6f, 0x65, 0x74, 0x74, 0x63, 0x68,
+    0x65, 0x72, 0x00, 0x42, 0x65, 0x72, 0x6e, 0x68, 0x61, 0x72, 0x64, 0x74,
+    0x00, 0x42, 0x61, 0x72, 0x72, 0x69, 0x65, 0x6e, 0x74, 0x6f, 0x73, 0x00,
+    0x5a, 0x69, 0x6e, 0x6b, 0x00, 0x57, 0x69, 0x63, 0x6b, 0x68, 0x61, 0x6d,
+    0x00, 0x57, 0x68, 0x69, 0x74, 0x65, 0x6d, 0x61, 0x6e, 0x00, 0x54, 0x68,
+    0x6f, 0x72, 0x70, 0x00, 0x53, 0x74, 0x69, 0x6c, 0x6c, 0x6d, 0x61, 0x6e,
+    0x00, 0x53, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x73, 0x00, 0x53, 0x63, 0x68,
+    0x6f, 0x6f, 0x6e, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x52, 0x6f, 0x71, 0x75,
+    0x65, 0x00, 0x52, 0x69, 0x64, 0x64, 0x65, 0x6c, 0x6c, 0x00, 0x52, 0x65,
+    0x79, 0x00, 0x50, 0x69, 0x6c, 0x63, 0x68, 0x65, 0x72, 0x00, 0x50, 0x68,
+    0x69, 0x66, 0x65, 0x72, 0x00, 0x4e, 0x6f, 0x76, 0x6f, 0x74, 0x6e, 0x79,
+    0x00, 0x4d, 0x61, 0x70, 0x6c, 0x65, 0x00, 0x4d, 0x61, 0x63, 0x6c, 0x65,
+    0x6f, 0x64, 0x00, 0x48, 0x61, 0x72, 0x64, 0x65, 0x65, 0x00, 0x48, 0x61,
+    0x61, 0x73, 0x65, 0x00, 0x47, 0x72, 0x69, 0x64, 0x65, 0x72, 0x00, 0x46,
+    0x72, 0x65, 0x64, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x45, 0x61, 0x72, 0x6e,
+    0x65, 0x73, 0x74, 0x00, 0x44, 0x6f, 0x75, 0x63, 0x65, 0x74, 0x74, 0x65,
+    0x00, 0x43, 0x6c, 0x61, 0x75, 0x73, 0x65, 0x6e, 0x00, 0x43, 0x68, 0x72,
+    0x69, 0x73, 0x74, 0x6d, 0x61, 0x73, 0x00, 0x42, 0x65, 0x76, 0x69, 0x6e,
+    0x73, 0x00, 0x42, 0x65, 0x61, 0x6d, 0x6f, 0x6e, 0x00, 0x42, 0x61, 0x64,
+    0x69, 0x6c, 0x6c, 0x6f, 0x00, 0x54, 0x6f, 0x6c, 0x6c, 0x65, 0x79, 0x00,
+    0x54, 0x69, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x00, 0x53, 0x6f, 0x75, 0x6c,
+    0x65, 0x00, 0x53, 0x6e, 0x6f, 0x6f, 0x6b, 0x00, 0x53, 0x65, 0x62, 0x61,
+    0x73, 0x74, 0x69, 0x61, 0x6e, 0x00, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x00,
+    0x50, 0x69, 0x74, 0x63, 0x68, 0x65, 0x72, 0x00, 0x50, 0x69, 0x6e, 0x6b,
+    0x6e, 0x65, 0x79, 0x00, 0x50, 0x65, 0x6c, 0x6c, 0x65, 0x67, 0x72, 0x69,
+    0x6e, 0x6f, 0x00, 0x4e, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4e, 0x65,
+    0x6d, 0x65, 0x74, 0x68, 0x00, 0x4e, 0x61, 0x69, 0x6c, 0x00, 0x4d, 0x6f,
+    0x6e, 0x64, 0x72, 0x61, 0x67, 0x6f, 0x6e, 0x00, 0x4d, 0x63, 0x6c, 0x61,
+    0x6e, 0x65, 0x00, 0x4c, 0x75, 0x6e, 0x64, 0x67, 0x72, 0x65, 0x6e, 0x00,
+    0x49, 0x6e, 0x67, 0x61, 0x6c, 0x6c, 0x73, 0x00, 0x48, 0x75, 0x64, 0x73,
+    0x70, 0x65, 0x74, 0x68, 0x00, 0x48, 0x69, 0x78, 0x73, 0x6f, 0x6e, 0x00,
+    0x47, 0x65, 0x61, 0x72, 0x68, 0x61, 0x72, 0x74, 0x00, 0x46, 0x75, 0x72,
+    0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x44, 0x6f, 0x77, 0x6e, 0x65, 0x73, 0x00,
+    0x44, 0x69, 0x6f, 0x6e, 0x6e, 0x65, 0x00, 0x44, 0x69, 0x62, 0x62, 0x6c,
+    0x65, 0x00, 0x44, 0x65, 0x79, 0x6f, 0x75, 0x6e, 0x67, 0x00, 0x43, 0x6f,
+    0x72, 0x6e, 0x65, 0x6a, 0x6f, 0x00, 0x43, 0x61, 0x6d, 0x61, 0x72, 0x61,
+    0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x73, 0x68, 0x69, 0x72, 0x65, 0x00,
+    0x42, 0x6f, 0x79, 0x65, 0x74, 0x74, 0x65, 0x00, 0x57, 0x6f, 0x6c, 0x63,
+    0x6f, 0x74, 0x74, 0x00, 0x54, 0x72, 0x61, 0x63, 0x65, 0x79, 0x00, 0x53,
+    0x75, 0x72, 0x72, 0x61, 0x74, 0x74, 0x00, 0x53, 0x65, 0x6c, 0x6c, 0x61,
+    0x72, 0x73, 0x00, 0x53, 0x65, 0x67, 0x61, 0x6c, 0x00, 0x53, 0x61, 0x6c,
+    0x79, 0x65, 0x72, 0x00, 0x52, 0x65, 0x65, 0x76, 0x65, 0x00, 0x52, 0x61,
+    0x75, 0x73, 0x63, 0x68, 0x00, 0x50, 0x68, 0x69, 0x6c, 0x69, 0x70, 0x73,
+    0x00, 0x4c, 0x61, 0x62, 0x6f, 0x6e, 0x74, 0x65, 0x00, 0x48, 0x61, 0x72,
+    0x6f, 0x00, 0x47, 0x6f, 0x77, 0x65, 0x72, 0x00, 0x46, 0x72, 0x65, 0x65,
+    0x6c, 0x61, 0x6e, 0x64, 0x00, 0x46, 0x61, 0x77, 0x63, 0x65, 0x74, 0x74,
+    0x00, 0x45, 0x61, 0x64, 0x73, 0x00, 0x44, 0x72, 0x69, 0x67, 0x67, 0x65,
+    0x72, 0x73, 0x00, 0x44, 0x6f, 0x6e, 0x6c, 0x65, 0x79, 0x00, 0x43, 0x6f,
+    0x6c, 0x6c, 0x65, 0x74, 0x74, 0x00, 0x43, 0x61, 0x67, 0x65, 0x00, 0x42,
+    0x72, 0x6f, 0x6d, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x6f, 0x61, 0x74, 0x6d,
+    0x61, 0x6e, 0x00, 0x42, 0x61, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x65, 0x72,
+    0x00, 0x42, 0x61, 0x6c, 0x64, 0x72, 0x69, 0x64, 0x67, 0x65, 0x00, 0x56,
+    0x6f, 0x6c, 0x7a, 0x00, 0x54, 0x72, 0x6f, 0x6d, 0x62, 0x6c, 0x65, 0x79,
+    0x00, 0x53, 0x74, 0x6f, 0x6e, 0x67, 0x65, 0x00, 0x53, 0x69, 0x6c, 0x61,
+    0x73, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x61, 0x68, 0x61, 0x6e, 0x00, 0x52,
+    0x69, 0x76, 0x61, 0x72, 0x64, 0x00, 0x52, 0x68, 0x79, 0x6e, 0x65, 0x00,
+    0x50, 0x65, 0x64, 0x72, 0x6f, 0x7a, 0x61, 0x00, 0x4d, 0x61, 0x74, 0x69,
+    0x61, 0x73, 0x00, 0x4d, 0x61, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x00, 0x4a,
+    0x61, 0x6d, 0x69, 0x65, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x65, 0x64, 0x67,
+    0x65, 0x70, 0x65, 0x74, 0x68, 0x00, 0x48, 0x61, 0x72, 0x74, 0x6e, 0x65,
+    0x74, 0x74, 0x00, 0x45, 0x73, 0x74, 0x65, 0x76, 0x65, 0x7a, 0x00, 0x45,
+    0x73, 0x6b, 0x72, 0x69, 0x64, 0x67, 0x65, 0x00, 0x44, 0x65, 0x6e, 0x6d,
+    0x61, 0x6e, 0x00, 0x43, 0x68, 0x69, 0x75, 0x00, 0x43, 0x68, 0x69, 0x6e,
+    0x6e, 0x00, 0x43, 0x61, 0x74, 0x6c, 0x65, 0x74, 0x74, 0x00, 0x43, 0x61,
+    0x72, 0x6d, 0x61, 0x63, 0x6b, 0x00, 0x42, 0x75, 0x69, 0x65, 0x00, 0x42,
+    0x6f, 0x6f, 0x6b, 0x00, 0x42, 0x65, 0x63, 0x68, 0x74, 0x65, 0x6c, 0x00,
+    0x42, 0x65, 0x61, 0x72, 0x64, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x61,
+    0x72, 0x64, 0x00, 0x42, 0x61, 0x6c, 0x6c, 0x6f, 0x75, 0x00, 0x57, 0x69,
+    0x6e, 0x64, 0x73, 0x6f, 0x72, 0x00, 0x55, 0x6c, 0x6d, 0x65, 0x72, 0x00,
+    0x53, 0x74, 0x6f, 0x72, 0x6d, 0x00, 0x53, 0x6b, 0x65, 0x65, 0x6e, 0x00,
+    0x52, 0x6f, 0x62, 0x6c, 0x65, 0x64, 0x6f, 0x00, 0x52, 0x69, 0x6e, 0x63,
+    0x6f, 0x6e, 0x00, 0x52, 0x65, 0x69, 0x74, 0x7a, 0x00, 0x50, 0x69, 0x61,
+    0x7a, 0x7a, 0x61, 0x00, 0x50, 0x65, 0x61, 0x72, 0x6c, 0x00, 0x4d, 0x75,
+    0x6e, 0x67, 0x65, 0x72, 0x00, 0x4d, 0x6f, 0x74, 0x65, 0x6e, 0x00, 0x4d,
+    0x63, 0x6d, 0x69, 0x63, 0x68, 0x61, 0x65, 0x6c, 0x00, 0x4c, 0x6f, 0x66,
+    0x74, 0x75, 0x73, 0x00, 0x4c, 0x65, 0x64, 0x65, 0x74, 0x00, 0x4b, 0x65,
+    0x72, 0x73, 0x65, 0x79, 0x00, 0x47, 0x72, 0x6f, 0x66, 0x66, 0x00, 0x46,
+    0x6f, 0x77, 0x6c, 0x6b, 0x65, 0x73, 0x00, 0x46, 0x6f, 0x6c, 0x6b, 0x00,
+    0x43, 0x72, 0x75, 0x6d, 0x70, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x6c,
+    0x6c, 0x65, 0x74, 0x74, 0x65, 0x00, 0x43, 0x6c, 0x6f, 0x75, 0x73, 0x65,
+    0x00, 0x42, 0x65, 0x74, 0x74, 0x69, 0x73, 0x00, 0x56, 0x69, 0x6c, 0x6c,
+    0x61, 0x67, 0x6f, 0x6d, 0x65, 0x7a, 0x00, 0x54, 0x69, 0x6d, 0x6d, 0x65,
+    0x72, 0x6d, 0x61, 0x6e, 0x00, 0x53, 0x74, 0x72, 0x6f, 0x6d, 0x00, 0x53,
+    0x61, 0x75, 0x6c, 0x00, 0x53, 0x61, 0x6e, 0x74, 0x6f, 0x72, 0x6f, 0x00,
+    0x52, 0x6f, 0x64, 0x64, 0x79, 0x00, 0x50, 0x68, 0x69, 0x6c, 0x6c, 0x69,
+    0x70, 0x00, 0x50, 0x65, 0x6e, 0x72, 0x6f, 0x64, 0x00, 0x4d, 0x75, 0x73,
+    0x73, 0x65, 0x6c, 0x6d, 0x61, 0x6e, 0x00, 0x4d, 0x61, 0x63, 0x70, 0x68,
+    0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x4c, 0x65, 0x62, 0x6f, 0x65, 0x75,
+    0x66, 0x00, 0x48, 0x61, 0x72, 0x6c, 0x65, 0x73, 0x73, 0x00, 0x48, 0x61,
+    0x64, 0x64, 0x61, 0x64, 0x00, 0x47, 0x75, 0x69, 0x64, 0x6f, 0x00, 0x47,
+    0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x46, 0x75, 0x6c, 0x6b, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x00, 0x46, 0x61, 0x6e, 0x6e, 0x69, 0x6e, 0x00,
+    0x44, 0x75, 0x6c, 0x61, 0x6e, 0x65, 0x79, 0x00, 0x44, 0x6f, 0x77, 0x64,
+    0x65, 0x6c, 0x6c, 0x00, 0x44, 0x65, 0x61, 0x6e, 0x65, 0x00, 0x43, 0x6f,
+    0x74, 0x74, 0x6c, 0x65, 0x00, 0x43, 0x65, 0x6a, 0x61, 0x00, 0x43, 0x61,
+    0x74, 0x65, 0x00, 0x42, 0x6f, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x65,
+    0x6e, 0x67, 0x65, 0x00, 0x41, 0x6c, 0x62, 0x72, 0x69, 0x74, 0x74, 0x6f,
+    0x6e, 0x00, 0x56, 0x6f, 0x69, 0x67, 0x74, 0x00, 0x54, 0x72, 0x6f, 0x77,
+    0x62, 0x72, 0x69, 0x64, 0x67, 0x65, 0x00, 0x53, 0x6f, 0x69, 0x6c, 0x65,
+    0x61, 0x75, 0x00, 0x53, 0x65, 0x65, 0x6c, 0x79, 0x00, 0x52, 0x6f, 0x6d,
+    0x65, 0x00, 0x52, 0x6f, 0x68, 0x64, 0x65, 0x00, 0x50, 0x65, 0x61, 0x72,
+    0x73, 0x61, 0x6c, 0x6c, 0x00, 0x50, 0x61, 0x75, 0x6c, 0x6b, 0x00, 0x4f,
+    0x72, 0x74, 0x68, 0x00, 0x4e, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x6f,
+    0x74, 0x61, 0x00, 0x4d, 0x63, 0x6d, 0x75, 0x6c, 0x6c, 0x69, 0x6e, 0x00,
+    0x4d, 0x61, 0x72, 0x71, 0x75, 0x61, 0x72, 0x64, 0x74, 0x00, 0x4d, 0x61,
+    0x64, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x48, 0x6f, 0x61, 0x67, 0x00, 0x47,
+    0x69, 0x6c, 0x6c, 0x75, 0x6d, 0x00, 0x47, 0x61, 0x79, 0x6c, 0x65, 0x00,
+    0x47, 0x61, 0x62, 0x62, 0x61, 0x72, 0x64, 0x00, 0x46, 0x65, 0x6e, 0x77,
+    0x69, 0x63, 0x6b, 0x00, 0x46, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x45,
+    0x63, 0x6b, 0x00, 0x44, 0x61, 0x6e, 0x66, 0x6f, 0x72, 0x74, 0x68, 0x00,
+    0x43, 0x75, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x00, 0x43, 0x72, 0x65, 0x73,
+    0x73, 0x00, 0x43, 0x72, 0x65, 0x65, 0x64, 0x00, 0x43, 0x61, 0x7a, 0x61,
+    0x72, 0x65, 0x73, 0x00, 0x43, 0x61, 0x73, 0x61, 0x6e, 0x6f, 0x76, 0x61,
+    0x00, 0x42, 0x65, 0x79, 0x00, 0x42, 0x65, 0x74, 0x74, 0x65, 0x6e, 0x63,
+    0x6f, 0x75, 0x72, 0x74, 0x00, 0x42, 0x61, 0x72, 0x72, 0x69, 0x6e, 0x67,
+    0x65, 0x72, 0x00, 0x42, 0x61, 0x62, 0x65, 0x72, 0x00, 0x53, 0x74, 0x61,
+    0x6e, 0x73, 0x62, 0x65, 0x72, 0x72, 0x79, 0x00, 0x53, 0x63, 0x68, 0x72,
+    0x61, 0x6d, 0x6d, 0x00, 0x52, 0x75, 0x74, 0x74, 0x65, 0x72, 0x00, 0x52,
+    0x69, 0x76, 0x65, 0x72, 0x6f, 0x00, 0x52, 0x61, 0x63, 0x65, 0x00, 0x4f,
+    0x71, 0x75, 0x65, 0x6e, 0x64, 0x6f, 0x00, 0x4e, 0x65, 0x63, 0x61, 0x69,
+    0x73, 0x65, 0x00, 0x4d, 0x6f, 0x75, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x65, 0x6e, 0x65, 0x67, 0x72, 0x6f, 0x00, 0x4d, 0x69, 0x6c,
+    0x65, 0x79, 0x00, 0x4d, 0x63, 0x67, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x4d,
+    0x61, 0x72, 0x72, 0x61, 0x00, 0x4d, 0x61, 0x63, 0x6d, 0x69, 0x6c, 0x6c,
+    0x61, 0x6e, 0x00, 0x4c, 0x6f, 0x63, 0x6b, 0x00, 0x4c, 0x61, 0x6d, 0x6f,
+    0x6e, 0x74, 0x61, 0x67, 0x6e, 0x65, 0x00, 0x4a, 0x61, 0x73, 0x73, 0x6f,
+    0x00, 0x4a, 0x61, 0x69, 0x6d, 0x65, 0x00, 0x48, 0x6f, 0x72, 0x73, 0x74,
+    0x00, 0x48, 0x65, 0x74, 0x72, 0x69, 0x63, 0x6b, 0x00, 0x48, 0x65, 0x69,
+    0x6c, 0x6d, 0x61, 0x6e, 0x00, 0x47, 0x61, 0x79, 0x74, 0x61, 0x6e, 0x00,
+    0x47, 0x61, 0x6c, 0x6c, 0x00, 0x46, 0x72, 0x69, 0x65, 0x64, 0x00, 0x46,
+    0x6f, 0x72, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x45, 0x64, 0x65, 0x6e, 0x00,
+    0x44, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x00, 0x44, 0x65, 0x73, 0x6a, 0x61,
+    0x72, 0x64, 0x69, 0x6e, 0x73, 0x00, 0x44, 0x61, 0x62, 0x62, 0x73, 0x00,
+    0x42, 0x75, 0x72, 0x62, 0x61, 0x6e, 0x6b, 0x00, 0x42, 0x72, 0x69, 0x67,
+    0x68, 0x61, 0x6d, 0x00, 0x42, 0x72, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00,
+    0x42, 0x65, 0x61, 0x6d, 0x61, 0x6e, 0x00, 0x42, 0x61, 0x6e, 0x6e, 0x65,
+    0x72, 0x00, 0x41, 0x72, 0x72, 0x69, 0x6f, 0x6c, 0x61, 0x00, 0x59, 0x61,
+    0x72, 0x62, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x57, 0x61, 0x6c,
+    0x6c, 0x69, 0x6e, 0x00, 0x54, 0x72, 0x65, 0x61, 0x74, 0x00, 0x54, 0x6f,
+    0x73, 0x63, 0x61, 0x6e, 0x6f, 0x00, 0x53, 0x74, 0x6f, 0x77, 0x65, 0x72,
+    0x73, 0x00, 0x52, 0x65, 0x69, 0x73, 0x73, 0x00, 0x50, 0x69, 0x63, 0x68,
+    0x61, 0x72, 0x64, 0x6f, 0x00, 0x4f, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x4d,
+    0x69, 0x74, 0x63, 0x68, 0x65, 0x6c, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x65,
+    0x6c, 0x73, 0x00, 0x4d, 0x63, 0x6e, 0x61, 0x6d, 0x65, 0x65, 0x00, 0x4d,
+    0x63, 0x63, 0x72, 0x6f, 0x72, 0x79, 0x00, 0x4c, 0x65, 0x61, 0x74, 0x68,
+    0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x4b, 0x65, 0x6c, 0x6c, 0x00, 0x4b,
+    0x65, 0x69, 0x73, 0x74, 0x65, 0x72, 0x00, 0x4a, 0x65, 0x72, 0x6f, 0x6d,
+    0x65, 0x00, 0x48, 0x6f, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x48, 0x61,
+    0x72, 0x67, 0x65, 0x74, 0x74, 0x00, 0x47, 0x75, 0x61, 0x79, 0x00, 0x46,
+    0x72, 0x69, 0x64, 0x61, 0x79, 0x00, 0x46, 0x65, 0x72, 0x72, 0x6f, 0x00,
+    0x44, 0x65, 0x62, 0x6f, 0x65, 0x72, 0x00, 0x44, 0x61, 0x67, 0x6f, 0x73,
+    0x74, 0x69, 0x6e, 0x6f, 0x00, 0x43, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
+    0x65, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x00, 0x43, 0x61, 0x72,
+    0x70, 0x65, 0x72, 0x00, 0x42, 0x6f, 0x77, 0x6c, 0x65, 0x72, 0x00, 0x42,
+    0x6c, 0x61, 0x6e, 0x6b, 0x73, 0x00, 0x42, 0x65, 0x61, 0x75, 0x64, 0x72,
+    0x79, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x65, 0x00, 0x54, 0x6f, 0x77,
+    0x6c, 0x65, 0x00, 0x54, 0x61, 0x66, 0x6f, 0x79, 0x61, 0x00, 0x53, 0x74,
+    0x72, 0x69, 0x63, 0x6b, 0x6c, 0x69, 0x6e, 0x00, 0x53, 0x74, 0x72, 0x61,
+    0x64, 0x65, 0x72, 0x00, 0x53, 0x6f, 0x70, 0x65, 0x72, 0x00, 0x53, 0x6f,
+    0x6e, 0x6e, 0x69, 0x65, 0x72, 0x00, 0x53, 0x69, 0x67, 0x6d, 0x6f, 0x6e,
+    0x00, 0x53, 0x63, 0x68, 0x65, 0x6e, 0x6b, 0x00, 0x53, 0x61, 0x64, 0x64,
+    0x6c, 0x65, 0x72, 0x00, 0x52, 0x6f, 0x64, 0x6d, 0x61, 0x6e, 0x00, 0x50,
+    0x65, 0x64, 0x69, 0x67, 0x6f, 0x00, 0x4d, 0x65, 0x6e, 0x64, 0x65, 0x73,
+    0x00, 0x4c, 0x75, 0x6e, 0x6e, 0x00, 0x4c, 0x6f, 0x68, 0x72, 0x00, 0x4c,
+    0x61, 0x68, 0x72, 0x00, 0x4b, 0x69, 0x6e, 0x67, 0x73, 0x62, 0x75, 0x72,
+    0x79, 0x00, 0x4a, 0x61, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x48, 0x75, 0x6d,
+    0x65, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x69, 0x6d, 0x61, 0x6e, 0x00, 0x48,
+    0x6f, 0x66, 0x6d, 0x61, 0x6e, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x6c, 0x00,
+    0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xbd, 0x00,
+    0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x01, 0x10, 0x00,
+    0x00, 0x01, 0x2d, 0x00, 0x00, 0x01, 0x4a, 0x00, 0x00, 0x01, 0x67, 0x00,
+    0x00, 0x01, 0x84, 0x00, 0x00, 0x01, 0xa1, 0x00, 0x00, 0x01, 0xbe, 0x00,
+    0x00, 0x01, 0xdb, 0x00, 0x00, 0x01, 0xf8, 0x00, 0x00, 0x02, 0x15, 0x00,
+    0x00, 0x02, 0x32, 0x00, 0x00, 0x02, 0x4f, 0x00, 0x00, 0x02, 0x6c, 0x00,
+    0x00, 0x02, 0x89, 0x00, 0x00, 0x02, 0xa6, 0x00, 0x00, 0x02, 0xc3, 0x00,
+    0x00, 0x02, 0xe0, 0x00, 0x00, 0x02, 0xfd, 0x00, 0x00, 0x03, 0x1a, 0x00,
+    0x00, 0x03, 0x37, 0x00, 0x00, 0x03, 0x54, 0x00, 0x00, 0x03, 0x71, 0x00,
+    0x00, 0x03, 0x8f, 0x00, 0x00, 0x03, 0xad, 0x00, 0x00, 0x03, 0xcb, 0x00,
+    0x00, 0x03, 0xe9, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00, 0x04, 0x25, 0x00,
+    0x00, 0x04, 0x43, 0x00, 0x00, 0x04, 0x61, 0x00, 0x00, 0x04, 0x7f, 0x00,
+    0x00, 0x04, 0x9e, 0x00, 0x00, 0x04, 0xbd, 0x00, 0x00, 0x04, 0xdc, 0x00,
+    0x00, 0x04, 0xfb, 0x00, 0x00, 0x05, 0x1a, 0x00, 0x00, 0x05, 0x39, 0x00,
+    0x00, 0x05, 0x58, 0x00, 0x00, 0x05, 0x77, 0x00, 0x00, 0x05, 0x96, 0x00,
+    0x00, 0x05, 0xb5, 0x00, 0x00, 0x05, 0xd4, 0x00, 0x00, 0x05, 0xf3, 0x00,
+    0x00, 0x06, 0x12, 0x00, 0x00, 0x06, 0x31, 0x00, 0x00, 0x06, 0x50, 0x00,
+    0x00, 0x06, 0x6f, 0x00, 0x00, 0x06, 0x8e, 0x00, 0x00, 0x06, 0xad, 0x00,
+    0x00, 0x06, 0xcc, 0x00, 0x00, 0x06, 0xeb, 0x00, 0x00, 0x07, 0x06, 0x00,
+    0x00, 0x07, 0x21, 0x00, 0x00, 0x07, 0x3c, 0x00, 0x00, 0x07, 0x57, 0x00,
+    0x00, 0x07, 0x72, 0x00, 0x00, 0x07, 0x8d, 0x00, 0x00, 0x07, 0xa8, 0x00,
+    0x00, 0x07, 0xc3, 0x00, 0x00, 0x07, 0xde, 0x00, 0x00, 0x07, 0xfa, 0x00,
+    0x00, 0x08, 0x16, 0x00, 0x00, 0x08, 0x32, 0x00, 0x00, 0x08, 0x4e, 0x00,
+    0x00, 0x08, 0x6a, 0x00, 0x00, 0x08, 0x86, 0x00, 0x00, 0x08, 0xa2, 0x00,
+    0x00, 0x08, 0xbe, 0x00, 0x00, 0x08, 0xda, 0x00, 0x00, 0x08, 0xf6, 0x00,
+    0x00, 0x09, 0x12, 0x00, 0x00, 0x09, 0x2e, 0x00, 0x00, 0x09, 0x4a, 0x00,
+    0x00, 0x09, 0x66, 0x00, 0x00, 0x09, 0x82, 0x00, 0x00, 0x09, 0x9e, 0x00,
+    0x00, 0x09, 0xba, 0x00, 0x00, 0x09, 0xd6, 0x00, 0x00, 0x09, 0xf2, 0x00,
+    0x00, 0x0a, 0x0e, 0x00, 0x00, 0x0a, 0x2a, 0x00, 0x00, 0x0a, 0x46, 0x00,
+    0x00, 0x0a, 0x61, 0x00, 0x00, 0x0a, 0x7c, 0x00, 0x00, 0x0a, 0x97, 0x00,
+    0x00, 0x0a, 0xb2, 0x00, 0x00, 0x0a, 0xcd, 0x00, 0x00, 0x0a, 0xe8, 0x00,
+    0x00, 0x0b, 0x03, 0x00, 0x00, 0x0b, 0x1e, 0x00, 0x00, 0x0b, 0x3a, 0x00,
+    0x00, 0x0b, 0x57, 0x00, 0x00, 0x0b, 0x74, 0x00, 0x00, 0x0b, 0x91, 0x00,
+    0x00, 0x0b, 0xae, 0x00, 0x00, 0x0b, 0xcb, 0x00, 0x00, 0x0b, 0xe8, 0x00,
+    0x00, 0x0c, 0x05, 0x00, 0x00, 0x0c, 0x22, 0x00, 0x00, 0x0c, 0x3f, 0x00,
+    0x00, 0x0c, 0x5c, 0x00, 0x00, 0x0c, 0x79, 0x00, 0x00, 0x0c, 0x96, 0x00,
+    0x00, 0x0c, 0xb3, 0x00, 0x00, 0x0c, 0xd0, 0x00, 0x00, 0x0c, 0xed, 0x00,
+    0x00, 0x0d, 0x0a, 0x00, 0x00, 0x0d, 0x27, 0x00, 0x00, 0x0d, 0x44, 0x00,
+    0x00, 0x0d, 0x61, 0x00, 0x00, 0x0d, 0x7e, 0x00, 0x00, 0x0d, 0x9b, 0x00,
+    0x00, 0x0d, 0xb6, 0x00, 0x00, 0x0d, 0xd1, 0x00, 0x00, 0x0d, 0xec, 0x00,
+    0x00, 0x0e, 0x07, 0x00, 0x00, 0x0e, 0x22, 0x00, 0x00, 0x0e, 0x3d, 0x00,
+    0x00, 0x0e, 0x58, 0x00, 0x00, 0x0e, 0x73, 0x00, 0x00, 0x0e, 0x8e, 0x00,
+    0x00, 0x0e, 0xaa, 0x00, 0x00, 0x0e, 0xc6, 0x00, 0x00, 0x0e, 0xe2, 0x00,
+    0x00, 0x0e, 0xfe, 0x00, 0x00, 0x0f, 0x1a, 0x00, 0x00, 0x0f, 0x36, 0x00,
+    0x00, 0x0f, 0x52, 0x00, 0x00, 0x0f, 0x6e, 0x00, 0x00, 0x0f, 0x8a, 0x00,
+    0x00, 0x0f, 0xa6, 0x00, 0x00, 0x0f, 0xc2, 0x00, 0x00, 0x0f, 0xde, 0x00,
+    0x00, 0x0f, 0xfa, 0x00, 0x00, 0x10, 0x16, 0x00, 0x00, 0x10, 0x32, 0x00,
+    0x00, 0x10, 0x4e, 0x00, 0x00, 0x10, 0x6a, 0x00, 0x00, 0x10, 0x86, 0x00,
+    0x00, 0x10, 0xa2, 0x00, 0x00, 0x10, 0xbe, 0x00, 0x00, 0x10, 0xda, 0x00,
+    0x00, 0x10, 0xf6, 0x00, 0x00, 0x11, 0x12, 0x00, 0x00, 0x11, 0x2e, 0x00,
+    0x00, 0x11, 0x4a, 0x00, 0x00, 0x11, 0x66, 0x00, 0x00, 0x11, 0x82, 0x00,
+    0x00, 0x11, 0x9e, 0x00, 0x00, 0x11, 0xba, 0x00, 0x00, 0x11, 0xd6, 0x00,
+    0x00, 0x11, 0xf2, 0x00, 0x00, 0x12, 0x0f, 0x00, 0x00, 0x12, 0x2c, 0x00,
+    0x00, 0x12, 0x49, 0x00, 0x00, 0x12, 0x66, 0x00, 0x00, 0x12, 0x83, 0x00,
+    0x00, 0x12, 0xa0, 0x00, 0x00, 0x12, 0xbd, 0x00, 0x00, 0x12, 0xda, 0x00,
+    0x00, 0x12, 0xf7, 0x00, 0x00, 0x13, 0x14, 0x00, 0x00, 0x13, 0x31, 0x00,
+    0x00, 0x13, 0x4e, 0x00, 0x00, 0x13, 0x6b, 0x00, 0x00, 0x13, 0x88, 0x00,
+    0x00, 0x13, 0xa5, 0x00, 0x00, 0x13, 0xc2, 0x00, 0x00, 0x13, 0xdf, 0x00,
+    0x00, 0x13, 0xfc, 0x00, 0x00, 0x14, 0x19, 0x00, 0x00, 0x14, 0x36, 0x00,
+    0x00, 0x14, 0x53, 0x00, 0x00, 0x14, 0x6f, 0x00, 0x00, 0x14, 0x8b, 0x00,
+    0x00, 0x14, 0xa7, 0x00, 0x00, 0x14, 0xc3, 0x00, 0x00, 0x14, 0xdf, 0x00,
+    0x00, 0x14, 0xfb, 0x00, 0x00, 0x15, 0x17, 0x00, 0x00, 0x15, 0x33, 0x00,
+    0x00, 0x15, 0x4f, 0x00, 0x00, 0x15, 0x6c, 0x00, 0x00, 0x15, 0x89, 0x00,
+    0x00, 0x15, 0xa6, 0x00, 0x00, 0x15, 0xc3, 0x00, 0x00, 0x15, 0xe0, 0x00,
+    0x00, 0x15, 0xfd, 0x00, 0x00, 0x16, 0x1a, 0x00, 0x00, 0x16, 0x37, 0x00,
+    0x00, 0x16, 0x54, 0x00, 0x00, 0x16, 0x71, 0x00, 0x00, 0x16, 0x8e, 0x00,
+    0x00, 0x16, 0xab, 0x00, 0x00, 0x16, 0xc8, 0x00, 0x00, 0x16, 0xe5, 0x00,
+    0x00, 0x17, 0x02, 0x00, 0x00, 0x17, 0x1f, 0x00, 0x00, 0x17, 0x3c, 0x00,
+    0x00, 0x17, 0x59, 0x00, 0x00, 0x17, 0x76, 0x00, 0x00, 0x17, 0x93, 0x00,
+    0x00, 0x17, 0xb0, 0x00, 0x00, 0x17, 0xcd, 0x00, 0x00, 0x17, 0xeb, 0x00,
+    0x00, 0x18, 0x09, 0x00, 0x00, 0x18, 0x27, 0x00, 0x00, 0x18, 0x45, 0x00,
+    0x00, 0x18, 0x63, 0x00, 0x00, 0x18, 0x81, 0x00, 0x00, 0x18, 0x9f, 0x00,
+    0x00, 0x18, 0xbd, 0x00, 0x00, 0x18, 0xdb, 0x00, 0x00, 0x18, 0xfa, 0x00,
+    0x00, 0x19, 0x19, 0x00, 0x00, 0x19, 0x38, 0x00, 0x00, 0x19, 0x57, 0x00,
+    0x00, 0x19, 0x76, 0x00, 0x00, 0x19, 0x95, 0x00, 0x00, 0x19, 0xb4, 0x00,
+    0x00, 0x19, 0xd3, 0x00, 0x00, 0x19, 0xf2, 0x00, 0x00, 0x1a, 0x11, 0x00,
+    0x00, 0x1a, 0x30, 0x00, 0x00, 0x1a, 0x4f, 0x00, 0x00, 0x1a, 0x6e, 0x00,
+    0x00, 0x1a, 0x8d, 0x00, 0x00, 0x1a, 0xac, 0x00, 0x00, 0x1a, 0xcb, 0x00,
+    0x00, 0x1a, 0xea, 0x00, 0x00, 0x1b, 0x09, 0x00, 0x00, 0x1b, 0x28, 0x00,
+    0x00, 0x1b, 0x47, 0x00, 0x00, 0x1b, 0x66, 0x00, 0x00, 0x1b, 0x85, 0x00,
+    0x00, 0x1b, 0xa4, 0x00, 0x00, 0x1b, 0xc3, 0x00, 0x00, 0x1b, 0xe2, 0x00,
+    0x00, 0x1c, 0x01, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x1c, 0x3f, 0x00,
+    0x00, 0x1c, 0x5e, 0x00, 0x00, 0x1c, 0x7d, 0x00, 0x00, 0x1c, 0x9c, 0x00,
+    0x00, 0x1c, 0xbc, 0x00, 0x00, 0x1c, 0xdc, 0x00, 0x00, 0x1c, 0xfc, 0x00,
+    0x00, 0x1d, 0x1c, 0x00, 0x00, 0x1d, 0x3c, 0x00, 0x00, 0x1d, 0x5c, 0x00,
+    0x00, 0x1d, 0x7c, 0x00, 0x00, 0x1d, 0x9c, 0x00, 0x00, 0x1d, 0xbc, 0x00,
+    0x00, 0x1d, 0xdc, 0x00, 0x00, 0x1d, 0xfc, 0x00, 0x00, 0x1e, 0x1c, 0x00,
+    0x00, 0x1e, 0x3c, 0x00, 0x00, 0x1e, 0x5c, 0x00, 0x00, 0x1e, 0x7c, 0x00,
+    0x00, 0x1e, 0x9c, 0x00, 0x00, 0x1e, 0xbc, 0x00, 0x00, 0x1e, 0xdc, 0x00,
+    0x00, 0x1e, 0xfc, 0x00, 0x00, 0x1f, 0x1c, 0x00, 0x00, 0x1f, 0x3c, 0x00,
+    0x00, 0x1f, 0x5a, 0x00, 0x00, 0x1f, 0x78, 0x00, 0x00, 0x1f, 0x96, 0x00,
+    0x00, 0x1f, 0xb4, 0x00, 0x00, 0x1f, 0xd2, 0x00, 0x00, 0x1f, 0xf0, 0x00,
+    0x00, 0x20, 0x0e, 0x00, 0x00, 0x20, 0x2c, 0x00, 0x00, 0x20, 0x4a, 0x00,
+    0x00, 0x20, 0x69, 0x00, 0x00, 0x20, 0x88, 0x00, 0x00, 0x20, 0xa7, 0x00,
+    0x00, 0x20, 0xc6, 0x00, 0x00, 0x20, 0xe5, 0x00, 0x00, 0x21, 0x04, 0x00,
+    0x00, 0x21, 0x23, 0x00, 0x00, 0x21, 0x42, 0x00, 0x00, 0x21, 0x61, 0x00,
+    0x00, 0x21, 0x80, 0x00, 0x00, 0x21, 0x9f, 0x00, 0x00, 0x21, 0xbe, 0x00,
+    0x00, 0x21, 0xdd, 0x00, 0x00, 0x21, 0xfc, 0x00, 0x00, 0x22, 0x1b, 0x00,
+    0x00, 0x22, 0x3a, 0x00, 0x00, 0x22, 0x59, 0x00, 0x00, 0x22, 0x78, 0x00,
+    0x00, 0x22, 0x97, 0x00, 0x00, 0x22, 0xb6, 0x00, 0x00, 0x22, 0xd5, 0x00,
+    0x00, 0x22, 0xf4, 0x00, 0x00, 0x23, 0x13, 0x00, 0x00, 0x23, 0x32, 0x00,
+    0x00, 0x23, 0x51, 0x00, 0x00, 0x23, 0x70, 0x00, 0x00, 0x23, 0x8f, 0x00,
+    0x00, 0x23, 0xae, 0x00, 0x00, 0x23, 0xcd, 0x00, 0x00, 0x23, 0xec, 0x00,
+    0x00, 0x24, 0x0b, 0x00, 0x00, 0x24, 0x2b, 0x00, 0x00, 0x24, 0x4b, 0x00,
+    0x00, 0x24, 0x6b, 0x00, 0x00, 0x24, 0x8b, 0x00, 0x00, 0x24, 0xab, 0x00,
+    0x00, 0x24, 0xcb, 0x00, 0x00, 0x24, 0xeb, 0x00, 0x00, 0x25, 0x0b, 0x00,
+    0x00, 0x25, 0x2b, 0x00, 0x00, 0x25, 0x4b, 0x00, 0x00, 0x25, 0x6b, 0x00,
+    0x00, 0x25, 0x8b, 0x00, 0x00, 0x25, 0xab, 0x00, 0x00, 0x25, 0xcb, 0x00,
+    0x00, 0x25, 0xeb, 0x00, 0x00, 0x26, 0x0b, 0x00, 0x00, 0x26, 0x2b, 0x00,
+    0x00, 0x26, 0x4b, 0x00, 0x00, 0x26, 0x6b, 0x00, 0x00, 0x26, 0x8b, 0x00,
+    0x00, 0x26, 0xab, 0x00, 0x00, 0x26, 0xcc, 0x00, 0x00, 0x26, 0xed, 0x00,
+    0x00, 0x27, 0x0e, 0x00, 0x00, 0x27, 0x2f, 0x00, 0x00, 0x27, 0x50, 0x00,
+    0x00, 0x27, 0x71, 0x00, 0x00, 0x27, 0x92, 0x00, 0x00, 0x27, 0xb3, 0x00,
+    0x00, 0x27, 0xd4, 0x00, 0x00, 0x27, 0xf6, 0x00, 0x00, 0x28, 0x18, 0x00,
+    0x00, 0x28, 0x3a, 0x00, 0x00, 0x28, 0x5c, 0x00, 0x00, 0x28, 0x7e, 0x00,
+    0x00, 0x28, 0xa0, 0x00, 0x00, 0x28, 0xc2, 0x00, 0x00, 0x28, 0xe4, 0x00,
+    0x00, 0x29, 0x06, 0x00, 0x00, 0x29, 0x28, 0x00, 0x00, 0x29, 0x4a, 0x00,
+    0x00, 0x29, 0x6c, 0x00, 0x00, 0x29, 0x8e, 0x00, 0x00, 0x29, 0xb0, 0x00,
+    0x00, 0x29, 0xd2, 0x00, 0x00, 0x29, 0xf4, 0x00, 0x00, 0x2a, 0x16, 0x00,
+    0x00, 0x2a, 0x38, 0x00, 0x00, 0x2a, 0x5a, 0x00, 0x00, 0x2a, 0x7c, 0x00,
+    0x00, 0x2a, 0x9e, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x6e, 0x00,
+    0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0xbf, 0x00,
+    0x00, 0x00, 0xda, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x01, 0x13, 0x00,
+    0x00, 0x01, 0x30, 0x00, 0x00, 0x01, 0x4d, 0x00, 0x00, 0x01, 0x6a, 0x00,
+    0x00, 0x01, 0x87, 0x00, 0x00, 0x01, 0xa4, 0x00, 0x00, 0x01, 0xc1, 0x00,
+    0x00, 0x01, 0xde, 0x00, 0x00, 0x01, 0xfb, 0x00, 0x00, 0x02, 0x18, 0x00,
+    0x00, 0x02, 0x35, 0x00, 0x00, 0x02, 0x52, 0x00, 0x00, 0x02, 0x6f, 0x00,
+    0x00, 0x02, 0x8c, 0x00, 0x00, 0x02, 0xa9, 0x00, 0x00, 0x02, 0xc6, 0x00,
+    0x00, 0x02, 0xe3, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x1d, 0x00,
+    0x00, 0x03, 0x3a, 0x00, 0x00, 0x03, 0x57, 0x00, 0x00, 0x03, 0x74, 0x00,
+    0x00, 0x03, 0x92, 0x00, 0x00, 0x03, 0xb0, 0x00, 0x00, 0x03, 0xce, 0x00,
+    0x00, 0x03, 0xec, 0x00, 0x00, 0x04, 0x0a, 0x00, 0x00, 0x04, 0x28, 0x00,
+    0x00, 0x04, 0x46, 0x00, 0x00, 0x04, 0x64, 0x00, 0x00, 0x04, 0x82, 0x00,
+    0x00, 0x04, 0xa1, 0x00, 0x00, 0x04, 0xc0, 0x00, 0x00, 0x04, 0xdf, 0x00,
+    0x00, 0x04, 0xfe, 0x00, 0x00, 0x05, 0x1d, 0x00, 0x00, 0x05, 0x3c, 0x00,
+    0x00, 0x05, 0x5b, 0x00, 0x00, 0x05, 0x7a, 0x00, 0x00, 0x05, 0x99, 0x00,
+    0x00, 0x05, 0xb8, 0x00, 0x00, 0x05, 0xd7, 0x00, 0x00, 0x05, 0xf6, 0x00,
+    0x00, 0x06, 0x15, 0x00, 0x00, 0x06, 0x34, 0x00, 0x00, 0x06, 0x53, 0x00,
+    0x00, 0x06, 0x72, 0x00, 0x00, 0x06, 0x91, 0x00, 0x00, 0x06, 0xb0, 0x00,
+    0x00, 0x06, 0xcf, 0x00, 0x00, 0x06, 0xee, 0x00, 0x00, 0x07, 0x09, 0x00,
+    0x00, 0x07, 0x24, 0x00, 0x00, 0x07, 0x3f, 0x00, 0x00, 0x07, 0x5a, 0x00,
+    0x00, 0x07, 0x75, 0x00, 0x00, 0x07, 0x90, 0x00, 0x00, 0x07, 0xab, 0x00,
+    0x00, 0x07, 0xc6, 0x00, 0x00, 0x07, 0xe1, 0x00, 0x00, 0x07, 0xfd, 0x00,
+    0x00, 0x08, 0x19, 0x00, 0x00, 0x08, 0x35, 0x00, 0x00, 0x08, 0x51, 0x00,
+    0x00, 0x08, 0x6d, 0x00, 0x00, 0x08, 0x89, 0x00, 0x00, 0x08, 0xa5, 0x00,
+    0x00, 0x08, 0xc1, 0x00, 0x00, 0x08, 0xdd, 0x00, 0x00, 0x08, 0xf9, 0x00,
+    0x00, 0x09, 0x15, 0x00, 0x00, 0x09, 0x31, 0x00, 0x00, 0x09, 0x4d, 0x00,
+    0x00, 0x09, 0x69, 0x00, 0x00, 0x09, 0x85, 0x00, 0x00, 0x09, 0xa1, 0x00,
+    0x00, 0x09, 0xbd, 0x00, 0x00, 0x09, 0xd9, 0x00, 0x00, 0x09, 0xf5, 0x00,
+    0x00, 0x0a, 0x11, 0x00, 0x00, 0x0a, 0x2d, 0x00, 0x00, 0x0a, 0x49, 0x00,
+    0x00, 0x0a, 0x64, 0x00, 0x00, 0x0a, 0x7f, 0x00, 0x00, 0x0a, 0x9a, 0x00,
+    0x00, 0x0a, 0xb5, 0x00, 0x00, 0x0a, 0xd0, 0x00, 0x00, 0x0a, 0xeb, 0x00,
+    0x00, 0x0b, 0x06, 0x00, 0x00, 0x0b, 0x22, 0x00, 0x00, 0x0b, 0x3e, 0x00,
+    0x00, 0x0b, 0x5b, 0x00, 0x00, 0x0b, 0x78, 0x00, 0x00, 0x0b, 0x95, 0x00,
+    0x00, 0x0b, 0xb2, 0x00, 0x00, 0x0b, 0xcf, 0x00, 0x00, 0x0b, 0xec, 0x00,
+    0x00, 0x0c, 0x09, 0x00, 0x00, 0x0c, 0x26, 0x00, 0x00, 0x0c, 0x43, 0x00,
+    0x00, 0x0c, 0x60, 0x00, 0x00, 0x0c, 0x7d, 0x00, 0x00, 0x0c, 0x9a, 0x00,
+    0x00, 0x0c, 0xb7, 0x00, 0x00, 0x0c, 0xd4, 0x00, 0x00, 0x0c, 0xf1, 0x00,
+    0x00, 0x0d, 0x0e, 0x00, 0x00, 0x0d, 0x2b, 0x00, 0x00, 0x0d, 0x48, 0x00,
+    0x00, 0x0d, 0x65, 0x00, 0x00, 0x0d, 0x82, 0x00, 0x00, 0x0d, 0x9f, 0x00,
+    0x00, 0x0d, 0xba, 0x00, 0x00, 0x0d, 0xd5, 0x00, 0x00, 0x0d, 0xf0, 0x00,
+    0x00, 0x0e, 0x0b, 0x00, 0x00, 0x0e, 0x26, 0x00, 0x00, 0x0e, 0x41, 0x00,
+    0x00, 0x0e, 0x5c, 0x00, 0x00, 0x0e, 0x77, 0x00, 0x00, 0x0e, 0x92, 0x00,
+    0x00, 0x0e, 0xae, 0x00, 0x00, 0x0e, 0xca, 0x00, 0x00, 0x0e, 0xe6, 0x00,
+    0x00, 0x0f, 0x02, 0x00, 0x00, 0x0f, 0x1e, 0x00, 0x00, 0x0f, 0x3a, 0x00,
+    0x00, 0x0f, 0x56, 0x00, 0x00, 0x0f, 0x72, 0x00, 0x00, 0x0f, 0x8e, 0x00,
+    0x00, 0x0f, 0xaa, 0x00, 0x00, 0x0f, 0xc6, 0x00, 0x00, 0x0f, 0xe2, 0x00,
+    0x00, 0x0f, 0xfe, 0x00, 0x00, 0x10, 0x1a, 0x00, 0x00, 0x10, 0x36, 0x00,
+    0x00, 0x10, 0x52, 0x00, 0x00, 0x10, 0x6e, 0x00, 0x00, 0x10, 0x8a, 0x00,
+    0x00, 0x10, 0xa6, 0x00, 0x00, 0x10, 0xc2, 0x00, 0x00, 0x10, 0xde, 0x00,
+    0x00, 0x10, 0xfa, 0x00, 0x00, 0x11, 0x16, 0x00, 0x00, 0x11, 0x32, 0x00,
+    0x00, 0x11, 0x4e, 0x00, 0x00, 0x11, 0x6a, 0x00, 0x00, 0x11, 0x86, 0x00,
+    0x00, 0x11, 0xa2, 0x00, 0x00, 0x11, 0xbe, 0x00, 0x00, 0x11, 0xda, 0x00,
+    0x00, 0x11, 0xf6, 0x00, 0x00, 0x12, 0x13, 0x00, 0x00, 0x12, 0x30, 0x00,
+    0x00, 0x12, 0x4d, 0x00, 0x00, 0x12, 0x6a, 0x00, 0x00, 0x12, 0x87, 0x00,
+    0x00, 0x12, 0xa4, 0x00, 0x00, 0x12, 0xc1, 0x00, 0x00, 0x12, 0xde, 0x00,
+    0x00, 0x12, 0xfb, 0x00, 0x00, 0x13, 0x18, 0x00, 0x00, 0x13, 0x35, 0x00,
+    0x00, 0x13, 0x52, 0x00, 0x00, 0x13, 0x6f, 0x00, 0x00, 0x13, 0x8c, 0x00,
+    0x00, 0x13, 0xa9, 0x00, 0x00, 0x13, 0xc6, 0x00, 0x00, 0x13, 0xe3, 0x00,
+    0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x1d, 0x00, 0x00, 0x14, 0x3a, 0x00,
+    0x00, 0x14, 0x57, 0x00, 0x00, 0x14, 0x73, 0x00, 0x00, 0x14, 0x8f, 0x00,
+    0x00, 0x14, 0xab, 0x00, 0x00, 0x14, 0xc7, 0x00, 0x00, 0x14, 0xe3, 0x00,
+    0x00, 0x14, 0xff, 0x00, 0x00, 0x15, 0x1b, 0x00, 0x00, 0x15, 0x37, 0x00,
+    0x00, 0x15, 0x53, 0x00, 0x00, 0x15, 0x70, 0x00, 0x00, 0x15, 0x8d, 0x00,
+    0x00, 0x15, 0xaa, 0x00, 0x00, 0x15, 0xc7, 0x00, 0x00, 0x15, 0xe4, 0x00,
+    0x00, 0x16, 0x01, 0x00, 0x00, 0x16, 0x1e, 0x00, 0x00, 0x16, 0x3b, 0x00,
+    0x00, 0x16, 0x58, 0x00, 0x00, 0x16, 0x75, 0x00, 0x00, 0x16, 0x92, 0x00,
+    0x00, 0x16, 0xaf, 0x00, 0x00, 0x16, 0xcc, 0x00, 0x00, 0x16, 0xe9, 0x00,
+    0x00, 0x17, 0x06, 0x00, 0x00, 0x17, 0x23, 0x00, 0x00, 0x17, 0x40, 0x00,
+    0x00, 0x17, 0x5d, 0x00, 0x00, 0x17, 0x7a, 0x00, 0x00, 0x17, 0x97, 0x00,
+    0x00, 0x17, 0xb4, 0x00, 0x00, 0x17, 0xd1, 0x00, 0x00, 0x17, 0xef, 0x00,
+    0x00, 0x18, 0x0d, 0x00, 0x00, 0x18, 0x2b, 0x00, 0x00, 0x18, 0x49, 0x00,
+    0x00, 0x18, 0x67, 0x00, 0x00, 0x18, 0x85, 0x00, 0x00, 0x18, 0xa3, 0x00,
+    0x00, 0x18, 0xc1, 0x00, 0x00, 0x18, 0xdf, 0x00, 0x00, 0x18, 0xfe, 0x00,
+    0x00, 0x19, 0x1d, 0x00, 0x00, 0x19, 0x3c, 0x00, 0x00, 0x19, 0x5b, 0x00,
+    0x00, 0x19, 0x7a, 0x00, 0x00, 0x19, 0x99, 0x00, 0x00, 0x19, 0xb8, 0x00,
+    0x00, 0x19, 0xd7, 0x00, 0x00, 0x19, 0xf6, 0x00, 0x00, 0x1a, 0x15, 0x00,
+    0x00, 0x1a, 0x34, 0x00, 0x00, 0x1a, 0x53, 0x00, 0x00, 0x1a, 0x72, 0x00,
+    0x00, 0x1a, 0x91, 0x00, 0x00, 0x1a, 0xb0, 0x00, 0x00, 0x1a, 0xcf, 0x00,
+    0x00, 0x1a, 0xee, 0x00, 0x00, 0x1b, 0x0d, 0x00, 0x00, 0x1b, 0x2c, 0x00,
+    0x00, 0x1b, 0x4b, 0x00, 0x00, 0x1b, 0x6a, 0x00, 0x00, 0x1b, 0x89, 0x00,
+    0x00, 0x1b, 0xa8, 0x00, 0x00, 0x1b, 0xc7, 0x00, 0x00, 0x1b, 0xe6, 0x00,
+    0x00, 0x1c, 0x05, 0x00, 0x00, 0x1c, 0x24, 0x00, 0x00, 0x1c, 0x43, 0x00,
+    0x00, 0x1c, 0x62, 0x00, 0x00, 0x1c, 0x81, 0x00, 0x00, 0x1c, 0xa0, 0x00,
+    0x00, 0x1c, 0xc0, 0x00, 0x00, 0x1c, 0xe0, 0x00, 0x00, 0x1d, 0x00, 0x00,
+    0x00, 0x1d, 0x20, 0x00, 0x00, 0x1d, 0x40, 0x00, 0x00, 0x1d, 0x60, 0x00,
+    0x00, 0x1d, 0x80, 0x00, 0x00, 0x1d, 0xa0, 0x00, 0x00, 0x1d, 0xc0, 0x00,
+    0x00, 0x1d, 0xe0, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x20, 0x00,
+    0x00, 0x1e, 0x40, 0x00, 0x00, 0x1e, 0x60, 0x00, 0x00, 0x1e, 0x80, 0x00,
+    0x00, 0x1e, 0xa0, 0x00, 0x00, 0x1e, 0xc0, 0x00, 0x00, 0x1e, 0xe0, 0x00,
+    0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x20, 0x00, 0x00, 0x1f, 0x40, 0x00,
+    0x00, 0x1f, 0x5e, 0x00, 0x00, 0x1f, 0x7c, 0x00, 0x00, 0x1f, 0x9a, 0x00,
+    0x00, 0x1f, 0xb8, 0x00, 0x00, 0x1f, 0xd6, 0x00, 0x00, 0x1f, 0xf4, 0x00,
+    0x00, 0x20, 0x12, 0x00, 0x00, 0x20, 0x30, 0x00, 0x00, 0x20, 0x4e, 0x00,
+    0x00, 0x20, 0x6d, 0x00, 0x00, 0x20, 0x8c, 0x00, 0x00, 0x20, 0xab, 0x00,
+    0x00, 0x20, 0xca, 0x00, 0x00, 0x20, 0xe9, 0x00, 0x00, 0x21, 0x08, 0x00,
+    0x00, 0x21, 0x27, 0x00, 0x00, 0x21, 0x46, 0x00, 0x00, 0x21, 0x65, 0x00,
+    0x00, 0x21, 0x84, 0x00, 0x00, 0x21, 0xa3, 0x00, 0x00, 0x21, 0xc2, 0x00,
+    0x00, 0x21, 0xe1, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x1f, 0x00,
+    0x00, 0x22, 0x3e, 0x00, 0x00, 0x22, 0x5d, 0x00, 0x00, 0x22, 0x7c, 0x00,
+    0x00, 0x22, 0x9b, 0x00, 0x00, 0x22, 0xba, 0x00, 0x00, 0x22, 0xd9, 0x00,
+    0x00, 0x22, 0xf8, 0x00, 0x00, 0x23, 0x17, 0x00, 0x00, 0x23, 0x36, 0x00,
+    0x00, 0x23, 0x55, 0x00, 0x00, 0x23, 0x74, 0x00, 0x00, 0x23, 0x93, 0x00,
+    0x00, 0x23, 0xb2, 0x00, 0x00, 0x23, 0xd1, 0x00, 0x00, 0x23, 0xf0, 0x00,
+    0x00, 0x24, 0x0f, 0x00, 0x00, 0x24, 0x2f, 0x00, 0x00, 0x24, 0x4f, 0x00,
+    0x00, 0x24, 0x6f, 0x00, 0x00, 0x24, 0x8f, 0x00, 0x00, 0x24, 0xaf, 0x00,
+    0x00, 0x24, 0xcf, 0x00, 0x00, 0x24, 0xef, 0x00, 0x00, 0x25, 0x0f, 0x00,
+    0x00, 0x25, 0x2f, 0x00, 0x00, 0x25, 0x4f, 0x00, 0x00, 0x25, 0x6f, 0x00,
+    0x00, 0x25, 0x8f, 0x00, 0x00, 0x25, 0xaf, 0x00, 0x00, 0x25, 0xcf, 0x00,
+    0x00, 0x25, 0xef, 0x00, 0x00, 0x26, 0x0f, 0x00, 0x00, 0x26, 0x2f, 0x00,
+    0x00, 0x26, 0x4f, 0x00, 0x00, 0x26, 0x6f, 0x00, 0x00, 0x26, 0x8f, 0x00,
+    0x00, 0x26, 0xaf, 0x00, 0x00, 0x26, 0xd0, 0x00, 0x00, 0x26, 0xf1, 0x00,
+    0x00, 0x27, 0x12, 0x00, 0x00, 0x27, 0x33, 0x00, 0x00, 0x27, 0x54, 0x00,
+    0x00, 0x27, 0x75, 0x00, 0x00, 0x27, 0x96, 0x00, 0x00, 0x27, 0xb7, 0x00,
+    0x00, 0x27, 0xd8, 0x00, 0x00, 0x27, 0xfa, 0x00, 0x00, 0x28, 0x1c, 0x00,
+    0x00, 0x28, 0x3e, 0x00, 0x00, 0x28, 0x60, 0x00, 0x00, 0x28, 0x82, 0x00,
+    0x00, 0x28, 0xa4, 0x00, 0x00, 0x28, 0xc6, 0x00, 0x00, 0x28, 0xe8, 0x00,
+    0x00, 0x29, 0x0a, 0x00, 0x00, 0x29, 0x2c, 0x00, 0x00, 0x29, 0x4e, 0x00,
+    0x00, 0x29, 0x70, 0x00, 0x00, 0x29, 0x92, 0x00, 0x00, 0x29, 0xb4, 0x00,
+    0x00, 0x29, 0xd6, 0x00, 0x00, 0x29, 0xf8, 0x00, 0x00, 0x2a, 0x1a, 0x00,
+    0x00, 0x2a, 0x3c, 0x00, 0x00, 0x2a, 0x5e, 0x00, 0x00, 0x2a, 0x80, 0x00,
+    0x00, 0x2a, 0xa2, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x25, 0x00,
+    0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x76, 0x00,
+    0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00, 0xc7, 0x00,
+    0x00, 0x00, 0xe2, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x01, 0x1b, 0x00,
+    0x00, 0x01, 0x38, 0x00, 0x00, 0x01, 0x55, 0x00, 0x00, 0x01, 0x72, 0x00,
+    0x00, 0x01, 0x8f, 0x00, 0x00, 0x01, 0xac, 0x00, 0x00, 0x01, 0xc9, 0x00,
+    0x00, 0x01, 0xe6, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x02, 0x20, 0x00,
+    0x00, 0x02, 0x3d, 0x00, 0x00, 0x02, 0x5a, 0x00, 0x00, 0x02, 0x77, 0x00,
+    0x00, 0x02, 0x94, 0x00, 0x00, 0x02, 0xb1, 0x00, 0x00, 0x02, 0xce, 0x00,
+    0x00, 0x02, 0xeb, 0x00, 0x00, 0x03, 0x08, 0x00, 0x00, 0x03, 0x25, 0x00,
+    0x00, 0x03, 0x42, 0x00, 0x00, 0x03, 0x5f, 0x00, 0x00, 0x03, 0x7d, 0x00,
+    0x00, 0x03, 0x9b, 0x00, 0x00, 0x03, 0xb9, 0x00, 0x00, 0x03, 0xd7, 0x00,
+    0x00, 0x03, 0xf5, 0x00, 0x00, 0x04, 0x13, 0x00, 0x00, 0x04, 0x31, 0x00,
+    0x00, 0x04, 0x4f, 0x00, 0x00, 0x04, 0x6d, 0x00, 0x00, 0x04, 0x8b, 0x00,
+    0x00, 0x04, 0xaa, 0x00, 0x00, 0x04, 0xc9, 0x00, 0x00, 0x04, 0xe8, 0x00,
+    0x00, 0x05, 0x07, 0x00, 0x00, 0x05, 0x26, 0x00, 0x00, 0x05, 0x45, 0x00,
+    0x00, 0x05, 0x64, 0x00, 0x00, 0x05, 0x83, 0x00, 0x00, 0x05, 0xa2, 0x00,
+    0x00, 0x05, 0xc1, 0x00, 0x00, 0x05, 0xe0, 0x00, 0x00, 0x05, 0xff, 0x00,
+    0x00, 0x06, 0x1e, 0x00, 0x00, 0x06, 0x3d, 0x00, 0x00, 0x06, 0x5c, 0x00,
+    0x00, 0x06, 0x7b, 0x00, 0x00, 0x06, 0x9a, 0x00, 0x00, 0x06, 0xb9, 0x00,
+    0x00, 0x06, 0xd8, 0x00, 0x00, 0x06, 0xf4, 0x00, 0x00, 0x07, 0x0f, 0x00,
+    0x00, 0x07, 0x2a, 0x00, 0x00, 0x07, 0x45, 0x00, 0x00, 0x07, 0x60, 0x00,
+    0x00, 0x07, 0x7b, 0x00, 0x00, 0x07, 0x96, 0x00, 0x00, 0x07, 0xb1, 0x00,
+    0x00, 0x07, 0xcc, 0x00, 0x00, 0x07, 0xe7, 0x00, 0x00, 0x08, 0x03, 0x00,
+    0x00, 0x08, 0x1f, 0x00, 0x00, 0x08, 0x3b, 0x00, 0x00, 0x08, 0x57, 0x00,
+    0x00, 0x08, 0x73, 0x00, 0x00, 0x08, 0x8f, 0x00, 0x00, 0x08, 0xab, 0x00,
+    0x00, 0x08, 0xc7, 0x00, 0x00, 0x08, 0xe3, 0x00, 0x00, 0x08, 0xff, 0x00,
+    0x00, 0x09, 0x1b, 0x00, 0x00, 0x09, 0x37, 0x00, 0x00, 0x09, 0x53, 0x00,
+    0x00, 0x09, 0x6f, 0x00, 0x00, 0x09, 0x8b, 0x00, 0x00, 0x09, 0xa7, 0x00,
+    0x00, 0x09, 0xc3, 0x00, 0x00, 0x09, 0xdf, 0x00, 0x00, 0x09, 0xfb, 0x00,
+    0x00, 0x0a, 0x17, 0x00, 0x00, 0x0a, 0x33, 0x00, 0x00, 0x0a, 0x4f, 0x00,
+    0x00, 0x0a, 0x6a, 0x00, 0x00, 0x0a, 0x85, 0x00, 0x00, 0x0a, 0xa0, 0x00,
+    0x00, 0x0a, 0xbb, 0x00, 0x00, 0x0a, 0xd6, 0x00, 0x00, 0x0a, 0xf1, 0x00,
+    0x00, 0x0b, 0x0c, 0x00, 0x00, 0x0b, 0x28, 0x00, 0x00, 0x0b, 0x44, 0x00,
+    0x00, 0x0b, 0x61, 0x00, 0x00, 0x0b, 0x7e, 0x00, 0x00, 0x0b, 0x9b, 0x00,
+    0x00, 0x0b, 0xb8, 0x00, 0x00, 0x0b, 0xd5, 0x00, 0x00, 0x0b, 0xf2, 0x00,
+    0x00, 0x0c, 0x0f, 0x00, 0x00, 0x0c, 0x2c, 0x00, 0x00, 0x0c, 0x49, 0x00,
+    0x00, 0x0c, 0x66, 0x00, 0x00, 0x0c, 0x83, 0x00, 0x00, 0x0c, 0xa0, 0x00,
+    0x00, 0x0c, 0xbd, 0x00, 0x00, 0x0c, 0xda, 0x00, 0x00, 0x0c, 0xf7, 0x00,
+    0x00, 0x0d, 0x14, 0x00, 0x00, 0x0d, 0x31, 0x00, 0x00, 0x0d, 0x4e, 0x00,
+    0x00, 0x0d, 0x6b, 0x00, 0x00, 0x0d, 0x88, 0x00, 0x00, 0x0d, 0xa3, 0x00,
+    0x00, 0x0d, 0xbe, 0x00, 0x00, 0x0d, 0xd9, 0x00, 0x00, 0x0d, 0xf4, 0x00,
+    0x00, 0x0e, 0x0f, 0x00, 0x00, 0x0e, 0x2a, 0x00, 0x00, 0x0e, 0x45, 0x00,
+    0x00, 0x0e, 0x60, 0x00, 0x00, 0x0e, 0x7b, 0x00, 0x00, 0x0e, 0x96, 0x00,
+    0x00, 0x0e, 0xb2, 0x00, 0x00, 0x0e, 0xce, 0x00, 0x00, 0x0e, 0xea, 0x00,
+    0x00, 0x0f, 0x06, 0x00, 0x00, 0x0f, 0x22, 0x00, 0x00, 0x0f, 0x3e, 0x00,
+    0x00, 0x0f, 0x5a, 0x00, 0x00, 0x0f, 0x76, 0x00, 0x00, 0x0f, 0x92, 0x00,
+    0x00, 0x0f, 0xae, 0x00, 0x00, 0x0f, 0xca, 0x00, 0x00, 0x0f, 0xe6, 0x00,
+    0x00, 0x10, 0x02, 0x00, 0x00, 0x10, 0x1e, 0x00, 0x00, 0x10, 0x3a, 0x00,
+    0x00, 0x10, 0x56, 0x00, 0x00, 0x10, 0x72, 0x00, 0x00, 0x10, 0x8e, 0x00,
+    0x00, 0x10, 0xaa, 0x00, 0x00, 0x10, 0xc6, 0x00, 0x00, 0x10, 0xe2, 0x00,
+    0x00, 0x10, 0xff, 0x00, 0x00, 0x11, 0x1b, 0x00, 0x00, 0x11, 0x37, 0x00,
+    0x00, 0x11, 0x53, 0x00, 0x00, 0x11, 0x6f, 0x00, 0x00, 0x11, 0x8b, 0x00,
+    0x00, 0x11, 0xa7, 0x00, 0x00, 0x11, 0xc3, 0x00, 0x00, 0x11, 0xdf, 0x00,
+    0x00, 0x11, 0xfb, 0x00, 0x00, 0x12, 0x18, 0x00, 0x00, 0x12, 0x35, 0x00,
+    0x00, 0x12, 0x52, 0x00, 0x00, 0x12, 0x6f, 0x00, 0x00, 0x12, 0x8c, 0x00,
+    0x00, 0x12, 0xa9, 0x00, 0x00, 0x12, 0xc6, 0x00, 0x00, 0x12, 0xe3, 0x00,
+    0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x1d, 0x00, 0x00, 0x13, 0x3a, 0x00,
+    0x00, 0x13, 0x57, 0x00, 0x00, 0x13, 0x74, 0x00, 0x00, 0x13, 0x91, 0x00,
+    0x00, 0x13, 0xae, 0x00, 0x00, 0x13, 0xcb, 0x00, 0x00, 0x13, 0xe8, 0x00,
+    0x00, 0x14, 0x05, 0x00, 0x00, 0x14, 0x22, 0x00, 0x00, 0x14, 0x3f, 0x00,
+    0x00, 0x14, 0x5c, 0x00, 0x00, 0x14, 0x78, 0x00, 0x00, 0x14, 0x94, 0x00,
+    0x00, 0x14, 0xb0, 0x00, 0x00, 0x14, 0xcc, 0x00, 0x00, 0x14, 0xe8, 0x00,
+    0x00, 0x15, 0x04, 0x00, 0x00, 0x15, 0x20, 0x00, 0x00, 0x15, 0x3c, 0x00,
+    0x00, 0x15, 0x58, 0x00, 0x00, 0x15, 0x75, 0x00, 0x00, 0x15, 0x92, 0x00,
+    0x00, 0x15, 0xaf, 0x00, 0x00, 0x15, 0xcc, 0x00, 0x00, 0x15, 0xe9, 0x00,
+    0x00, 0x16, 0x06, 0x00, 0x00, 0x16, 0x23, 0x00, 0x00, 0x16, 0x40, 0x00,
+    0x00, 0x16, 0x5d, 0x00, 0x00, 0x16, 0x7a, 0x00, 0x00, 0x16, 0x97, 0x00,
+    0x00, 0x16, 0xb4, 0x00, 0x00, 0x16, 0xd1, 0x00, 0x00, 0x16, 0xee, 0x00,
+    0x00, 0x17, 0x0b, 0x00, 0x00, 0x17, 0x28, 0x00, 0x00, 0x17, 0x45, 0x00,
+    0x00, 0x17, 0x62, 0x00, 0x00, 0x17, 0x7f, 0x00, 0x00, 0x17, 0x9c, 0x00,
+    0x00, 0x17, 0xb9, 0x00, 0x00, 0x17, 0xd8, 0x00, 0x00, 0x17, 0xf6, 0x00,
+    0x00, 0x18, 0x14, 0x00, 0x00, 0x18, 0x32, 0x00, 0x00, 0x18, 0x50, 0x00,
+    0x00, 0x18, 0x6e, 0x00, 0x00, 0x18, 0x8c, 0x00, 0x00, 0x18, 0xaa, 0x00,
+    0x00, 0x18, 0xc8, 0x00, 0x00, 0x18, 0xe6, 0x00, 0x00, 0x19, 0x05, 0x00,
+    0x00, 0x19, 0x24, 0x00, 0x00, 0x19, 0x43, 0x00, 0x00, 0x19, 0x62, 0x00,
+    0x00, 0x19, 0x81, 0x00, 0x00, 0x19, 0xa0, 0x00, 0x00, 0x19, 0xbf, 0x00,
+    0x00, 0x19, 0xde, 0x00, 0x00, 0x19, 0xfd, 0x00, 0x00, 0x1a, 0x1c, 0x00,
+    0x00, 0x1a, 0x3b, 0x00, 0x00, 0x1a, 0x5a, 0x00, 0x00, 0x1a, 0x79, 0x00,
+    0x00, 0x1a, 0x98, 0x00, 0x00, 0x1a, 0xb7, 0x00, 0x00, 0x1a, 0xd6, 0x00,
+    0x00, 0x1a, 0xf5, 0x00, 0x00, 0x1b, 0x14, 0x00, 0x00, 0x1b, 0x33, 0x00,
+    0x00, 0x1b, 0x52, 0x00, 0x00, 0x1b, 0x71, 0x00, 0x00, 0x1b, 0x93, 0x00,
+    0x00, 0x1b, 0xb2, 0x00, 0x00, 0x1b, 0xd1, 0x00, 0x00, 0x1b, 0xf0, 0x00,
+    0x00, 0x1c, 0x0f, 0x00, 0x00, 0x1c, 0x2e, 0x00, 0x00, 0x1c, 0x4d, 0x00,
+    0x00, 0x1c, 0x6c, 0x00, 0x00, 0x1c, 0x8b, 0x00, 0x00, 0x1c, 0xaa, 0x00,
+    0x00, 0x1c, 0xca, 0x00, 0x00, 0x1c, 0xea, 0x00, 0x00, 0x1d, 0x0a, 0x00,
+    0x00, 0x1d, 0x2a, 0x00, 0x00, 0x1d, 0x4a, 0x00, 0x00, 0x1d, 0x6a, 0x00,
+    0x00, 0x1d, 0x8a, 0x00, 0x00, 0x1d, 0xaa, 0x00, 0x00, 0x1d, 0xca, 0x00,
+    0x00, 0x1d, 0xea, 0x00, 0x00, 0x1e, 0x0a, 0x00, 0x00, 0x1e, 0x2a, 0x00,
+    0x00, 0x1e, 0x4a, 0x00, 0x00, 0x1e, 0x6a, 0x00, 0x00, 0x1e, 0x8a, 0x00,
+    0x00, 0x1e, 0xaa, 0x00, 0x00, 0x1e, 0xca, 0x00, 0x00, 0x1e, 0xea, 0x00,
+    0x00, 0x1f, 0x0a, 0x00, 0x00, 0x1f, 0x2a, 0x00, 0x00, 0x1f, 0x48, 0x00,
+    0x00, 0x1f, 0x66, 0x00, 0x00, 0x1f, 0x84, 0x00, 0x00, 0x1f, 0xa2, 0x00,
+    0x00, 0x1f, 0xc0, 0x00, 0x00, 0x1f, 0xde, 0x00, 0x00, 0x1f, 0xfc, 0x00,
+    0x00, 0x20, 0x1a, 0x00, 0x00, 0x20, 0x38, 0x00, 0x00, 0x20, 0x56, 0x00,
+    0x00, 0x20, 0x75, 0x00, 0x00, 0x20, 0x94, 0x00, 0x00, 0x20, 0xb3, 0x00,
+    0x00, 0x20, 0xd2, 0x00, 0x00, 0x20, 0xf1, 0x00, 0x00, 0x21, 0x10, 0x00,
+    0x00, 0x21, 0x2f, 0x00, 0x00, 0x21, 0x4e, 0x00, 0x00, 0x21, 0x6d, 0x00,
+    0x00, 0x21, 0x8c, 0x00, 0x00, 0x21, 0xab, 0x00, 0x00, 0x21, 0xca, 0x00,
+    0x00, 0x21, 0xe9, 0x00, 0x00, 0x22, 0x08, 0x00, 0x00, 0x22, 0x27, 0x00,
+    0x00, 0x22, 0x46, 0x00, 0x00, 0x22, 0x65, 0x00, 0x00, 0x22, 0x84, 0x00,
+    0x00, 0x22, 0xa3, 0x00, 0x00, 0x22, 0xc2, 0x00, 0x00, 0x22, 0xe1, 0x00,
+    0x00, 0x23, 0x01, 0x00, 0x00, 0x23, 0x20, 0x00, 0x00, 0x23, 0x3f, 0x00,
+    0x00, 0x23, 0x5e, 0x00, 0x00, 0x23, 0x7d, 0x00, 0x00, 0x23, 0x9c, 0x00,
+    0x00, 0x23, 0xbb, 0x00, 0x00, 0x23, 0xda, 0x00, 0x00, 0x23, 0xf9, 0x00,
+    0x00, 0x24, 0x18, 0x00, 0x00, 0x24, 0x38, 0x00, 0x00, 0x24, 0x58, 0x00,
+    0x00, 0x24, 0x78, 0x00, 0x00, 0x24, 0x98, 0x00, 0x00, 0x24, 0xb8, 0x00,
+    0x00, 0x24, 0xd8, 0x00, 0x00, 0x24, 0xf8, 0x00, 0x00, 0x25, 0x18, 0x00,
+    0x00, 0x25, 0x38, 0x00, 0x00, 0x25, 0x58, 0x00, 0x00, 0x25, 0x78, 0x00,
+    0x00, 0x25, 0x98, 0x00, 0x00, 0x25, 0xb8, 0x00, 0x00, 0x25, 0xd8, 0x00,
+    0x00, 0x25, 0xf8, 0x00, 0x00, 0x26, 0x18, 0x00, 0x00, 0x26, 0x38, 0x00,
+    0x00, 0x26, 0x58, 0x00, 0x00, 0x26, 0x78, 0x00, 0x00, 0x26, 0x98, 0x00,
+    0x00, 0x26, 0xb8, 0x00, 0x00, 0x26, 0xd9, 0x00, 0x00, 0x26, 0xfa, 0x00,
+    0x00, 0x27, 0x1b, 0x00, 0x00, 0x27, 0x3c, 0x00, 0x00, 0x27, 0x5d, 0x00,
+    0x00, 0x27, 0x7e, 0x00, 0x00, 0x27, 0x9f, 0x00, 0x00, 0x27, 0xc0, 0x00,
+    0x00, 0x27, 0xe1, 0x00, 0x00, 0x28, 0x03, 0x00, 0x00, 0x28, 0x25, 0x00,
+    0x00, 0x28, 0x47, 0x00, 0x00, 0x28, 0x69, 0x00, 0x00, 0x28, 0x8b, 0x00,
+    0x00, 0x28, 0xad, 0x00, 0x00, 0x28, 0xcf, 0x00, 0x00, 0x28, 0xf1, 0x00,
+    0x00, 0x29, 0x13, 0x00, 0x00, 0x29, 0x35, 0x00, 0x00, 0x29, 0x57, 0x00,
+    0x00, 0x29, 0x79, 0x00, 0x00, 0x29, 0x9b, 0x00, 0x00, 0x29, 0xbd, 0x00,
+    0x00, 0x29, 0xdf, 0x00, 0x00, 0x2a, 0x01, 0x00, 0x00, 0x2a, 0x23, 0x00,
+    0x00, 0x2a, 0x45, 0x00, 0x00, 0x2a, 0x67, 0x00, 0x00, 0x2a, 0x89, 0x00,
+    0x00, 0x2a, 0xab, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x27, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x78, 0x00,
+    0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0xae, 0x00, 0x00, 0x00, 0xc9, 0x00,
+    0x00, 0x00, 0xe4, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x1e, 0x00,
+    0x00, 0x01, 0x3b, 0x00, 0x00, 0x01, 0x58, 0x00, 0x00, 0x01, 0x75, 0x00,
+    0x00, 0x01, 0x92, 0x00, 0x00, 0x01, 0xaf, 0x00, 0x00, 0x01, 0xcc, 0x00,
+    0x00, 0x01, 0xe9, 0x00, 0x00, 0x02, 0x06, 0x00, 0x00, 0x02, 0x23, 0x00,
+    0x00, 0x02, 0x40, 0x00, 0x00, 0x02, 0x5d, 0x00, 0x00, 0x02, 0x7a, 0x00,
+    0x00, 0x02, 0x97, 0x00, 0x00, 0x02, 0xb4, 0x00, 0x00, 0x02, 0xd1, 0x00,
+    0x00, 0x02, 0xee, 0x00, 0x00, 0x03, 0x0b, 0x00, 0x00, 0x03, 0x28, 0x00,
+    0x00, 0x03, 0x45, 0x00, 0x00, 0x03, 0x62, 0x00, 0x00, 0x03, 0x7f, 0x00,
+    0x00, 0x03, 0x9d, 0x00, 0x00, 0x03, 0xbb, 0x00, 0x00, 0x03, 0xd9, 0x00,
+    0x00, 0x03, 0xf7, 0x00, 0x00, 0x04, 0x15, 0x00, 0x00, 0x04, 0x33, 0x00,
+    0x00, 0x04, 0x51, 0x00, 0x00, 0x04, 0x6f, 0x00, 0x00, 0x04, 0x8e, 0x00,
+    0x00, 0x04, 0xad, 0x00, 0x00, 0x04, 0xcc, 0x00, 0x00, 0x04, 0xeb, 0x00,
+    0x00, 0x05, 0x0a, 0x00, 0x00, 0x05, 0x29, 0x00, 0x00, 0x05, 0x48, 0x00,
+    0x00, 0x05, 0x67, 0x00, 0x00, 0x05, 0x86, 0x00, 0x00, 0x05, 0xa5, 0x00,
+    0x00, 0x05, 0xc4, 0x00, 0x00, 0x05, 0xe3, 0x00, 0x00, 0x06, 0x02, 0x00,
+    0x00, 0x06, 0x21, 0x00, 0x00, 0x06, 0x40, 0x00, 0x00, 0x06, 0x5f, 0x00,
+    0x00, 0x06, 0x7e, 0x00, 0x00, 0x06, 0x9d, 0x00, 0x00, 0x06, 0xbc, 0x00,
+    0x00, 0x06, 0xdb, 0x00, 0x00, 0x06, 0xf6, 0x00, 0x00, 0x07, 0x11, 0x00,
+    0x00, 0x07, 0x2c, 0x00, 0x00, 0x07, 0x47, 0x00, 0x00, 0x07, 0x62, 0x00,
+    0x00, 0x07, 0x7d, 0x00, 0x00, 0x07, 0x98, 0x00, 0x00, 0x07, 0xb3, 0x00,
+    0x00, 0x07, 0xce, 0x00, 0x00, 0x07, 0xea, 0x00, 0x00, 0x08, 0x06, 0x00,
+    0x00, 0x08, 0x22, 0x00, 0x00, 0x08, 0x3e, 0x00, 0x00, 0x08, 0x5a, 0x00,
+    0x00, 0x08, 0x76, 0x00, 0x00, 0x08, 0x92, 0x00, 0x00, 0x08, 0xae, 0x00,
+    0x00, 0x08, 0xca, 0x00, 0x00, 0x08, 0xe6, 0x00, 0x00, 0x09, 0x02, 0x00,
+    0x00, 0x09, 0x1e, 0x00, 0x00, 0x09, 0x3a, 0x00, 0x00, 0x09, 0x56, 0x00,
+    0x00, 0x09, 0x72, 0x00, 0x00, 0x09, 0x8e, 0x00, 0x00, 0x09, 0xaa, 0x00,
+    0x00, 0x09, 0xc6, 0x00, 0x00, 0x09, 0xe2, 0x00, 0x00, 0x09, 0xfe, 0x00,
+    0x00, 0x0a, 0x1a, 0x00, 0x00, 0x0a, 0x36, 0x00, 0x00, 0x0a, 0x51, 0x00,
+    0x00, 0x0a, 0x6c, 0x00, 0x00, 0x0a, 0x87, 0x00, 0x00, 0x0a, 0xa2, 0x00,
+    0x00, 0x0a, 0xbd, 0x00, 0x00, 0x0a, 0xd8, 0x00, 0x00, 0x0a, 0xf3, 0x00,
+    0x00, 0x0b, 0x0e, 0x00, 0x00, 0x0b, 0x2a, 0x00, 0x00, 0x0b, 0x47, 0x00,
+    0x00, 0x0b, 0x64, 0x00, 0x00, 0x0b, 0x81, 0x00, 0x00, 0x0b, 0x9e, 0x00,
+    0x00, 0x0b, 0xbb, 0x00, 0x00, 0x0b, 0xd8, 0x00, 0x00, 0x0b, 0xf5, 0x00,
+    0x00, 0x0c, 0x12, 0x00, 0x00, 0x0c, 0x2f, 0x00, 0x00, 0x0c, 0x4c, 0x00,
+    0x00, 0x0c, 0x69, 0x00, 0x00, 0x0c, 0x86, 0x00, 0x00, 0x0c, 0xa3, 0x00,
+    0x00, 0x0c, 0xc0, 0x00, 0x00, 0x0c, 0xdd, 0x00, 0x00, 0x0c, 0xfa, 0x00,
+    0x00, 0x0d, 0x17, 0x00, 0x00, 0x0d, 0x34, 0x00, 0x00, 0x0d, 0x51, 0x00,
+    0x00, 0x0d, 0x6e, 0x00, 0x00, 0x0d, 0x8b, 0x00, 0x00, 0x0d, 0xa5, 0x00,
+    0x00, 0x0d, 0xc0, 0x00, 0x00, 0x0d, 0xdb, 0x00, 0x00, 0x0d, 0xf6, 0x00,
+    0x00, 0x0e, 0x11, 0x00, 0x00, 0x0e, 0x2c, 0x00, 0x00, 0x0e, 0x47, 0x00,
+    0x00, 0x0e, 0x62, 0x00, 0x00, 0x0e, 0x7d, 0x00, 0x00, 0x0e, 0x99, 0x00,
+    0x00, 0x0e, 0xb5, 0x00, 0x00, 0x0e, 0xd1, 0x00, 0x00, 0x0e, 0xed, 0x00,
+    0x00, 0x0f, 0x09, 0x00, 0x00, 0x0f, 0x25, 0x00, 0x00, 0x0f, 0x41, 0x00,
+    0x00, 0x0f, 0x5d, 0x00, 0x00, 0x0f, 0x79, 0x00, 0x00, 0x0f, 0x95, 0x00,
+    0x00, 0x0f, 0xb1, 0x00, 0x00, 0x0f, 0xcd, 0x00, 0x00, 0x0f, 0xe9, 0x00,
+    0x00, 0x10, 0x05, 0x00, 0x00, 0x10, 0x21, 0x00, 0x00, 0x10, 0x3d, 0x00,
+    0x00, 0x10, 0x59, 0x00, 0x00, 0x10, 0x75, 0x00, 0x00, 0x10, 0x91, 0x00,
+    0x00, 0x10, 0xad, 0x00, 0x00, 0x10, 0xc9, 0x00, 0x00, 0x10, 0xe5, 0x00,
+    0x00, 0x11, 0x01, 0x00, 0x00, 0x11, 0x1d, 0x00, 0x00, 0x11, 0x39, 0x00,
+    0x00, 0x11, 0x55, 0x00, 0x00, 0x11, 0x71, 0x00, 0x00, 0x11, 0x8d, 0x00,
+    0x00, 0x11, 0xa9, 0x00, 0x00, 0x11, 0xc5, 0x00, 0x00, 0x11, 0xe1, 0x00,
+    0x00, 0x11, 0xfe, 0x00, 0x00, 0x12, 0x1b, 0x00, 0x00, 0x12, 0x38, 0x00,
+    0x00, 0x12, 0x55, 0x00, 0x00, 0x12, 0x72, 0x00, 0x00, 0x12, 0x8f, 0x00,
+    0x00, 0x12, 0xac, 0x00, 0x00, 0x12, 0xc9, 0x00, 0x00, 0x12, 0xe6, 0x00,
+    0x00, 0x13, 0x03, 0x00, 0x00, 0x13, 0x20, 0x00, 0x00, 0x13, 0x3d, 0x00,
+    0x00, 0x13, 0x5a, 0x00, 0x00, 0x13, 0x77, 0x00, 0x00, 0x13, 0x94, 0x00,
+    0x00, 0x13, 0xb1, 0x00, 0x00, 0x13, 0xce, 0x00, 0x00, 0x13, 0xeb, 0x00,
+    0x00, 0x14, 0x08, 0x00, 0x00, 0x14, 0x25, 0x00, 0x00, 0x14, 0x42, 0x00,
+    0x00, 0x14, 0x5e, 0x00, 0x00, 0x14, 0x7a, 0x00, 0x00, 0x14, 0x96, 0x00,
+    0x00, 0x14, 0xb2, 0x00, 0x00, 0x14, 0xce, 0x00, 0x00, 0x14, 0xea, 0x00,
+    0x00, 0x15, 0x06, 0x00, 0x00, 0x15, 0x22, 0x00, 0x00, 0x15, 0x3e, 0x00,
+    0x00, 0x15, 0x5b, 0x00, 0x00, 0x15, 0x78, 0x00, 0x00, 0x15, 0x95, 0x00,
+    0x00, 0x15, 0xb2, 0x00, 0x00, 0x15, 0xcf, 0x00, 0x00, 0x15, 0xec, 0x00,
+    0x00, 0x16, 0x09, 0x00, 0x00, 0x16, 0x26, 0x00, 0x00, 0x16, 0x43, 0x00,
+    0x00, 0x16, 0x60, 0x00, 0x00, 0x16, 0x7d, 0x00, 0x00, 0x16, 0x9a, 0x00,
+    0x00, 0x16, 0xb7, 0x00, 0x00, 0x16, 0xd4, 0x00, 0x00, 0x16, 0xf1, 0x00,
+    0x00, 0x17, 0x0e, 0x00, 0x00, 0x17, 0x2b, 0x00, 0x00, 0x17, 0x48, 0x00,
+    0x00, 0x17, 0x65, 0x00, 0x00, 0x17, 0x82, 0x00, 0x00, 0x17, 0x9f, 0x00,
+    0x00, 0x17, 0xbc, 0x00, 0x00, 0x17, 0xda, 0x00, 0x00, 0x17, 0xf8, 0x00,
+    0x00, 0x18, 0x16, 0x00, 0x00, 0x18, 0x34, 0x00, 0x00, 0x18, 0x52, 0x00,
+    0x00, 0x18, 0x70, 0x00, 0x00, 0x18, 0x8e, 0x00, 0x00, 0x18, 0xac, 0x00,
+    0x00, 0x18, 0xca, 0x00, 0x00, 0x18, 0xe9, 0x00, 0x00, 0x19, 0x08, 0x00,
+    0x00, 0x19, 0x27, 0x00, 0x00, 0x19, 0x46, 0x00, 0x00, 0x19, 0x65, 0x00,
+    0x00, 0x19, 0x84, 0x00, 0x00, 0x19, 0xa3, 0x00, 0x00, 0x19, 0xc2, 0x00,
+    0x00, 0x19, 0xe1, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x1f, 0x00,
+    0x00, 0x1a, 0x3e, 0x00, 0x00, 0x1a, 0x5d, 0x00, 0x00, 0x1a, 0x7c, 0x00,
+    0x00, 0x1a, 0x9b, 0x00, 0x00, 0x1a, 0xba, 0x00, 0x00, 0x1a, 0xd9, 0x00,
+    0x00, 0x1a, 0xf8, 0x00, 0x00, 0x1b, 0x17, 0x00, 0x00, 0x1b, 0x36, 0x00,
+    0x00, 0x1b, 0x55, 0x00, 0x00, 0x1b, 0x74, 0x00, 0x00, 0x1b, 0x95, 0x00,
+    0x00, 0x1b, 0xb4, 0x00, 0x00, 0x1b, 0xd3, 0x00, 0x00, 0x1b, 0xf2, 0x00,
+    0x00, 0x1c, 0x11, 0x00, 0x00, 0x1c, 0x30, 0x00, 0x00, 0x1c, 0x4f, 0x00,
+    0x00, 0x1c, 0x6e, 0x00, 0x00, 0x1c, 0x8d, 0x00, 0x00, 0x1c, 0xad, 0x00,
+    0x00, 0x1c, 0xcd, 0x00, 0x00, 0x1c, 0xed, 0x00, 0x00, 0x1d, 0x0d, 0x00,
+    0x00, 0x1d, 0x2d, 0x00, 0x00, 0x1d, 0x4d, 0x00, 0x00, 0x1d, 0x6d, 0x00,
+    0x00, 0x1d, 0x8d, 0x00, 0x00, 0x1d, 0xad, 0x00, 0x00, 0x1d, 0xcd, 0x00,
+    0x00, 0x1d, 0xed, 0x00, 0x00, 0x1e, 0x0d, 0x00, 0x00, 0x1e, 0x2d, 0x00,
+    0x00, 0x1e, 0x4d, 0x00, 0x00, 0x1e, 0x6d, 0x00, 0x00, 0x1e, 0x8d, 0x00,
+    0x00, 0x1e, 0xad, 0x00, 0x00, 0x1e, 0xcd, 0x00, 0x00, 0x1e, 0xed, 0x00,
+    0x00, 0x1f, 0x0d, 0x00, 0x00, 0x1f, 0x2d, 0x00, 0x00, 0x1f, 0x4a, 0x00,
+    0x00, 0x1f, 0x68, 0x00, 0x00, 0x1f, 0x86, 0x00, 0x00, 0x1f, 0xa4, 0x00,
+    0x00, 0x1f, 0xc2, 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x1f, 0xfe, 0x00,
+    0x00, 0x20, 0x1c, 0x00, 0x00, 0x20, 0x3a, 0x00, 0x00, 0x20, 0x59, 0x00,
+    0x00, 0x20, 0x78, 0x00, 0x00, 0x20, 0x97, 0x00, 0x00, 0x20, 0xb6, 0x00,
+    0x00, 0x20, 0xd5, 0x00, 0x00, 0x20, 0xf4, 0x00, 0x00, 0x21, 0x13, 0x00,
+    0x00, 0x21, 0x32, 0x00, 0x00, 0x21, 0x51, 0x00, 0x00, 0x21, 0x70, 0x00,
+    0x00, 0x21, 0x8f, 0x00, 0x00, 0x21, 0xae, 0x00, 0x00, 0x21, 0xcd, 0x00,
+    0x00, 0x21, 0xec, 0x00, 0x00, 0x22, 0x0b, 0x00, 0x00, 0x22, 0x2a, 0x00,
+    0x00, 0x22, 0x49, 0x00, 0x00, 0x22, 0x68, 0x00, 0x00, 0x22, 0x87, 0x00,
+    0x00, 0x22, 0xa6, 0x00, 0x00, 0x22, 0xc5, 0x00, 0x00, 0x22, 0xe4, 0x00,
+    0x00, 0x23, 0x03, 0x00, 0x00, 0x23, 0x22, 0x00, 0x00, 0x23, 0x41, 0x00,
+    0x00, 0x23, 0x60, 0x00, 0x00, 0x23, 0x7f, 0x00, 0x00, 0x23, 0x9e, 0x00,
+    0x00, 0x23, 0xbd, 0x00, 0x00, 0x23, 0xdc, 0x00, 0x00, 0x23, 0xfb, 0x00,
+    0x00, 0x24, 0x1b, 0x00, 0x00, 0x24, 0x3b, 0x00, 0x00, 0x24, 0x5b, 0x00,
+    0x00, 0x24, 0x7b, 0x00, 0x00, 0x24, 0x9b, 0x00, 0x00, 0x24, 0xbb, 0x00,
+    0x00, 0x24, 0xdb, 0x00, 0x00, 0x24, 0xfb, 0x00, 0x00, 0x25, 0x1b, 0x00,
+    0x00, 0x25, 0x3b, 0x00, 0x00, 0x25, 0x5b, 0x00, 0x00, 0x25, 0x7b, 0x00,
+    0x00, 0x25, 0x9b, 0x00, 0x00, 0x25, 0xbb, 0x00, 0x00, 0x25, 0xdb, 0x00,
+    0x00, 0x25, 0xfb, 0x00, 0x00, 0x26, 0x1b, 0x00, 0x00, 0x26, 0x3b, 0x00,
+    0x00, 0x26, 0x5b, 0x00, 0x00, 0x26, 0x7b, 0x00, 0x00, 0x26, 0x9b, 0x00,
+    0x00, 0x26, 0xba, 0x00, 0x00, 0x26, 0xdb, 0x00, 0x00, 0x26, 0xfc, 0x00,
+    0x00, 0x27, 0x1d, 0x00, 0x00, 0x27, 0x3e, 0x00, 0x00, 0x27, 0x5f, 0x00,
+    0x00, 0x27, 0x80, 0x00, 0x00, 0x27, 0xa1, 0x00, 0x00, 0x27, 0xc2, 0x00,
+    0x00, 0x27, 0xe4, 0x00, 0x00, 0x28, 0x06, 0x00, 0x00, 0x28, 0x28, 0x00,
+    0x00, 0x28, 0x4a, 0x00, 0x00, 0x28, 0x6c, 0x00, 0x00, 0x28, 0x8e, 0x00,
+    0x00, 0x28, 0xb0, 0x00, 0x00, 0x28, 0xd2, 0x00, 0x00, 0x28, 0xf4, 0x00,
+    0x00, 0x29, 0x16, 0x00, 0x00, 0x29, 0x38, 0x00, 0x00, 0x29, 0x5a, 0x00,
+    0x00, 0x29, 0x7c, 0x00, 0x00, 0x29, 0x9e, 0x00, 0x00, 0x29, 0xc0, 0x00,
+    0x00, 0x29, 0xe2, 0x00, 0x00, 0x2a, 0x04, 0x00, 0x00, 0x2a, 0x26, 0x00,
+    0x00, 0x2a, 0x48, 0x00, 0x00, 0x2a, 0x6a, 0x00, 0x00, 0x2a, 0x8c, 0x00,
+    0x00, 0x2a, 0xae, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x2e, 0x00,
+    0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x7f, 0x00,
+    0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0xb5, 0x00, 0x00, 0x00, 0xd0, 0x00,
+    0x00, 0x00, 0xeb, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x01, 0x25, 0x00,
+    0x00, 0x01, 0x42, 0x00, 0x00, 0x01, 0x5f, 0x00, 0x00, 0x01, 0x7c, 0x00,
+    0x00, 0x01, 0x99, 0x00, 0x00, 0x01, 0xb6, 0x00, 0x00, 0x01, 0xd3, 0x00,
+    0x00, 0x01, 0xf0, 0x00, 0x00, 0x02, 0x0d, 0x00, 0x00, 0x02, 0x2a, 0x00,
+    0x00, 0x02, 0x47, 0x00, 0x00, 0x02, 0x64, 0x00, 0x00, 0x02, 0x81, 0x00,
+    0x00, 0x02, 0x9e, 0x00, 0x00, 0x02, 0xbb, 0x00, 0x00, 0x02, 0xd8, 0x00,
+    0x00, 0x02, 0xf5, 0x00, 0x00, 0x03, 0x12, 0x00, 0x00, 0x03, 0x2f, 0x00,
+    0x00, 0x03, 0x4c, 0x00, 0x00, 0x03, 0x69, 0x00, 0x00, 0x03, 0x86, 0x00,
+    0x00, 0x03, 0xa4, 0x00, 0x00, 0x03, 0xc2, 0x00, 0x00, 0x03, 0xe0, 0x00,
+    0x00, 0x03, 0xfe, 0x00, 0x00, 0x04, 0x1c, 0x00, 0x00, 0x04, 0x3a, 0x00,
+    0x00, 0x04, 0x58, 0x00, 0x00, 0x04, 0x76, 0x00, 0x00, 0x04, 0x95, 0x00,
+    0x00, 0x04, 0xb4, 0x00, 0x00, 0x04, 0xd3, 0x00, 0x00, 0x04, 0xf2, 0x00,
+    0x00, 0x05, 0x11, 0x00, 0x00, 0x05, 0x30, 0x00, 0x00, 0x05, 0x4f, 0x00,
+    0x00, 0x05, 0x6e, 0x00, 0x00, 0x05, 0x8d, 0x00, 0x00, 0x05, 0xac, 0x00,
+    0x00, 0x05, 0xcb, 0x00, 0x00, 0x05, 0xea, 0x00, 0x00, 0x06, 0x09, 0x00,
+    0x00, 0x06, 0x28, 0x00, 0x00, 0x06, 0x47, 0x00, 0x00, 0x06, 0x66, 0x00,
+    0x00, 0x06, 0x85, 0x00, 0x00, 0x06, 0xa4, 0x00, 0x00, 0x06, 0xc3, 0x00,
+    0x00, 0x06, 0xe2, 0x00, 0x00, 0x06, 0xfd, 0x00, 0x00, 0x07, 0x18, 0x00,
+    0x00, 0x07, 0x33, 0x00, 0x00, 0x07, 0x4e, 0x00, 0x00, 0x07, 0x69, 0x00,
+    0x00, 0x07, 0x84, 0x00, 0x00, 0x07, 0x9f, 0x00, 0x00, 0x07, 0xba, 0x00,
+    0x00, 0x07, 0xd5, 0x00, 0x00, 0x07, 0xf1, 0x00, 0x00, 0x08, 0x0d, 0x00,
+    0x00, 0x08, 0x29, 0x00, 0x00, 0x08, 0x45, 0x00, 0x00, 0x08, 0x61, 0x00,
+    0x00, 0x08, 0x7d, 0x00, 0x00, 0x08, 0x99, 0x00, 0x00, 0x08, 0xb5, 0x00,
+    0x00, 0x08, 0xd1, 0x00, 0x00, 0x08, 0xed, 0x00, 0x00, 0x09, 0x09, 0x00,
+    0x00, 0x09, 0x25, 0x00, 0x00, 0x09, 0x41, 0x00, 0x00, 0x09, 0x5d, 0x00,
+    0x00, 0x09, 0x79, 0x00, 0x00, 0x09, 0x95, 0x00, 0x00, 0x09, 0xb1, 0x00,
+    0x00, 0x09, 0xcd, 0x00, 0x00, 0x09, 0xe9, 0x00, 0x00, 0x0a, 0x05, 0x00,
+    0x00, 0x0a, 0x21, 0x00, 0x00, 0x0a, 0x3d, 0x00, 0x00, 0x0a, 0x58, 0x00,
+    0x00, 0x0a, 0x73, 0x00, 0x00, 0x0a, 0x8e, 0x00, 0x00, 0x0a, 0xa9, 0x00,
+    0x00, 0x0a, 0xc4, 0x00, 0x00, 0x0a, 0xdf, 0x00, 0x00, 0x0a, 0xfa, 0x00,
+    0x00, 0x0b, 0x15, 0x00, 0x00, 0x0b, 0x31, 0x00, 0x00, 0x0b, 0x4e, 0x00,
+    0x00, 0x0b, 0x6b, 0x00, 0x00, 0x0b, 0x88, 0x00, 0x00, 0x0b, 0xa5, 0x00,
+    0x00, 0x0b, 0xc2, 0x00, 0x00, 0x0b, 0xdf, 0x00, 0x00, 0x0b, 0xfc, 0x00,
+    0x00, 0x0c, 0x19, 0x00, 0x00, 0x0c, 0x36, 0x00, 0x00, 0x0c, 0x53, 0x00,
+    0x00, 0x0c, 0x70, 0x00, 0x00, 0x0c, 0x8d, 0x00, 0x00, 0x0c, 0xaa, 0x00,
+    0x00, 0x0c, 0xc7, 0x00, 0x00, 0x0c, 0xe4, 0x00, 0x00, 0x0d, 0x01, 0x00,
+    0x00, 0x0d, 0x1e, 0x00, 0x00, 0x0d, 0x3b, 0x00, 0x00, 0x0d, 0x58, 0x00,
+    0x00, 0x0d, 0x75, 0x00, 0x00, 0x0d, 0x92, 0x00, 0x00, 0x0d, 0xac, 0x00,
+    0x00, 0x0d, 0xc7, 0x00, 0x00, 0x0d, 0xe2, 0x00, 0x00, 0x0d, 0xfd, 0x00,
+    0x00, 0x0e, 0x18, 0x00, 0x00, 0x0e, 0x33, 0x00, 0x00, 0x0e, 0x4e, 0x00,
+    0x00, 0x0e, 0x69, 0x00, 0x00, 0x0e, 0x84, 0x00, 0x00, 0x0e, 0xa0, 0x00,
+    0x00, 0x0e, 0xbc, 0x00, 0x00, 0x0e, 0xd8, 0x00, 0x00, 0x0e, 0xf4, 0x00,
+    0x00, 0x0f, 0x10, 0x00, 0x00, 0x0f, 0x2c, 0x00, 0x00, 0x0f, 0x48, 0x00,
+    0x00, 0x0f, 0x64, 0x00, 0x00, 0x0f, 0x80, 0x00, 0x00, 0x0f, 0x9c, 0x00,
+    0x00, 0x0f, 0xb8, 0x00, 0x00, 0x0f, 0xd4, 0x00, 0x00, 0x0f, 0xf0, 0x00,
+    0x00, 0x10, 0x0c, 0x00, 0x00, 0x10, 0x28, 0x00, 0x00, 0x10, 0x44, 0x00,
+    0x00, 0x10, 0x60, 0x00, 0x00, 0x10, 0x7c, 0x00, 0x00, 0x10, 0x98, 0x00,
+    0x00, 0x10, 0xb4, 0x00, 0x00, 0x10, 0xd0, 0x00, 0x00, 0x10, 0xec, 0x00,
+    0x00, 0x11, 0x08, 0x00, 0x00, 0x11, 0x24, 0x00, 0x00, 0x11, 0x40, 0x00,
+    0x00, 0x11, 0x5c, 0x00, 0x00, 0x11, 0x78, 0x00, 0x00, 0x11, 0x94, 0x00,
+    0x00, 0x11, 0xb0, 0x00, 0x00, 0x11, 0xcc, 0x00, 0x00, 0x11, 0xe8, 0x00,
+    0x00, 0x12, 0x05, 0x00, 0x00, 0x12, 0x22, 0x00, 0x00, 0x12, 0x3f, 0x00,
+    0x00, 0x12, 0x5c, 0x00, 0x00, 0x12, 0x79, 0x00, 0x00, 0x12, 0x96, 0x00,
+    0x00, 0x12, 0xb3, 0x00, 0x00, 0x12, 0xd0, 0x00, 0x00, 0x12, 0xed, 0x00,
+    0x00, 0x13, 0x0a, 0x00, 0x00, 0x13, 0x27, 0x00, 0x00, 0x13, 0x44, 0x00,
+    0x00, 0x13, 0x61, 0x00, 0x00, 0x13, 0x7e, 0x00, 0x00, 0x13, 0x9b, 0x00,
+    0x00, 0x13, 0xb8, 0x00, 0x00, 0x13, 0xd5, 0x00, 0x00, 0x13, 0xf2, 0x00,
+    0x00, 0x14, 0x0f, 0x00, 0x00, 0x14, 0x2c, 0x00, 0x00, 0x14, 0x49, 0x00,
+    0x00, 0x14, 0x65, 0x00, 0x00, 0x14, 0x81, 0x00, 0x00, 0x14, 0x9d, 0x00,
+    0x00, 0x14, 0xb9, 0x00, 0x00, 0x14, 0xd5, 0x00, 0x00, 0x14, 0xf1, 0x00,
+    0x00, 0x15, 0x0d, 0x00, 0x00, 0x15, 0x29, 0x00, 0x00, 0x15, 0x45, 0x00,
+    0x00, 0x15, 0x62, 0x00, 0x00, 0x15, 0x7f, 0x00, 0x00, 0x15, 0x9c, 0x00,
+    0x00, 0x15, 0xb9, 0x00, 0x00, 0x15, 0xd6, 0x00, 0x00, 0x15, 0xf3, 0x00,
+    0x00, 0x16, 0x10, 0x00, 0x00, 0x16, 0x2d, 0x00, 0x00, 0x16, 0x4a, 0x00,
+    0x00, 0x16, 0x67, 0x00, 0x00, 0x16, 0x84, 0x00, 0x00, 0x16, 0xa1, 0x00,
+    0x00, 0x16, 0xbe, 0x00, 0x00, 0x16, 0xdb, 0x00, 0x00, 0x16, 0xf8, 0x00,
+    0x00, 0x17, 0x15, 0x00, 0x00, 0x17, 0x32, 0x00, 0x00, 0x17, 0x4f, 0x00,
+    0x00, 0x17, 0x6c, 0x00, 0x00, 0x17, 0x89, 0x00, 0x00, 0x17, 0xa6, 0x00,
+    0x00, 0x17, 0xc3, 0x00, 0x00, 0x17, 0xe1, 0x00, 0x00, 0x17, 0xff, 0x00,
+    0x00, 0x18, 0x1d, 0x00, 0x00, 0x18, 0x3b, 0x00, 0x00, 0x18, 0x59, 0x00,
+    0x00, 0x18, 0x77, 0x00, 0x00, 0x18, 0x95, 0x00, 0x00, 0x18, 0xb3, 0x00,
+    0x00, 0x18, 0xd1, 0x00, 0x00, 0x18, 0xf0, 0x00, 0x00, 0x19, 0x0f, 0x00,
+    0x00, 0x19, 0x2e, 0x00, 0x00, 0x19, 0x4d, 0x00, 0x00, 0x19, 0x6c, 0x00,
+    0x00, 0x19, 0x8b, 0x00, 0x00, 0x19, 0xaa, 0x00, 0x00, 0x19, 0xc9, 0x00,
+    0x00, 0x19, 0xe8, 0x00, 0x00, 0x1a, 0x07, 0x00, 0x00, 0x1a, 0x26, 0x00,
+    0x00, 0x1a, 0x45, 0x00, 0x00, 0x1a, 0x64, 0x00, 0x00, 0x1a, 0x83, 0x00,
+    0x00, 0x1a, 0xa2, 0x00, 0x00, 0x1a, 0xc1, 0x00, 0x00, 0x1a, 0xe0, 0x00,
+    0x00, 0x1a, 0xff, 0x00, 0x00, 0x1b, 0x1e, 0x00, 0x00, 0x1b, 0x3d, 0x00,
+    0x00, 0x1b, 0x5c, 0x00, 0x00, 0x1b, 0x7b, 0x00, 0x00, 0x1b, 0x9a, 0x00,
+    0x00, 0x1b, 0xb9, 0x00, 0x00, 0x1b, 0xd8, 0x00, 0x00, 0x1b, 0xf7, 0x00,
+    0x00, 0x1c, 0x16, 0x00, 0x00, 0x1c, 0x35, 0x00, 0x00, 0x1c, 0x54, 0x00,
+    0x00, 0x1c, 0x73, 0x00, 0x00, 0x1c, 0x92, 0x00, 0x00, 0x1c, 0xb2, 0x00,
+    0x00, 0x1c, 0xd2, 0x00, 0x00, 0x1c, 0xf2, 0x00, 0x00, 0x1d, 0x12, 0x00,
+    0x00, 0x1d, 0x32, 0x00, 0x00, 0x1d, 0x52, 0x00, 0x00, 0x1d, 0x72, 0x00,
+    0x00, 0x1d, 0x92, 0x00, 0x00, 0x1d, 0xb2, 0x00, 0x00, 0x1d, 0xd2, 0x00,
+    0x00, 0x1d, 0xf2, 0x00, 0x00, 0x1e, 0x12, 0x00, 0x00, 0x1e, 0x32, 0x00,
+    0x00, 0x1e, 0x52, 0x00, 0x00, 0x1e, 0x72, 0x00, 0x00, 0x1e, 0x92, 0x00,
+    0x00, 0x1e, 0xb2, 0x00, 0x00, 0x1e, 0xd2, 0x00, 0x00, 0x1e, 0xf2, 0x00,
+    0x00, 0x1f, 0x12, 0x00, 0x00, 0x1f, 0x32, 0x00, 0x00, 0x1f, 0x4f, 0x00,
+    0x00, 0x1f, 0x6d, 0x00, 0x00, 0x1f, 0x8b, 0x00, 0x00, 0x1f, 0xa9, 0x00,
+    0x00, 0x1f, 0xc7, 0x00, 0x00, 0x1f, 0xe5, 0x00, 0x00, 0x20, 0x03, 0x00,
+    0x00, 0x20, 0x21, 0x00, 0x00, 0x20, 0x3f, 0x00, 0x00, 0x20, 0x5e, 0x00,
+    0x00, 0x20, 0x7d, 0x00, 0x00, 0x20, 0x9c, 0x00, 0x00, 0x20, 0xbb, 0x00,
+    0x00, 0x20, 0xda, 0x00, 0x00, 0x20, 0xf9, 0x00, 0x00, 0x21, 0x18, 0x00,
+    0x00, 0x21, 0x37, 0x00, 0x00, 0x21, 0x56, 0x00, 0x00, 0x21, 0x75, 0x00,
+    0x00, 0x21, 0x94, 0x00, 0x00, 0x21, 0xb3, 0x00, 0x00, 0x21, 0xd2, 0x00,
+    0x00, 0x21, 0xf1, 0x00, 0x00, 0x22, 0x10, 0x00, 0x00, 0x22, 0x2f, 0x00,
+    0x00, 0x22, 0x4e, 0x00, 0x00, 0x22, 0x6d, 0x00, 0x00, 0x22, 0x8c, 0x00,
+    0x00, 0x22, 0xab, 0x00, 0x00, 0x22, 0xca, 0x00, 0x00, 0x22, 0xe9, 0x00,
+    0x00, 0x23, 0x08, 0x00, 0x00, 0x23, 0x27, 0x00, 0x00, 0x23, 0x46, 0x00,
+    0x00, 0x23, 0x65, 0x00, 0x00, 0x23, 0x84, 0x00, 0x00, 0x23, 0xa3, 0x00,
+    0x00, 0x23, 0xc2, 0x00, 0x00, 0x23, 0xe1, 0x00, 0x00, 0x24, 0x00, 0x00,
+    0x00, 0x24, 0x20, 0x00, 0x00, 0x24, 0x40, 0x00, 0x00, 0x24, 0x60, 0x00,
+    0x00, 0x24, 0x80, 0x00, 0x00, 0x24, 0xa0, 0x00, 0x00, 0x24, 0xc0, 0x00,
+    0x00, 0x24, 0xe0, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x20, 0x00,
+    0x00, 0x25, 0x40, 0x00, 0x00, 0x25, 0x60, 0x00, 0x00, 0x25, 0x80, 0x00,
+    0x00, 0x25, 0xa0, 0x00, 0x00, 0x25, 0xc0, 0x00, 0x00, 0x25, 0xe0, 0x00,
+    0x00, 0x26, 0x00, 0x00, 0x00, 0x26, 0x20, 0x00, 0x00, 0x26, 0x40, 0x00,
+    0x00, 0x26, 0x60, 0x00, 0x00, 0x26, 0x80, 0x00, 0x00, 0x26, 0xa0, 0x00,
+    0x00, 0x26, 0xc1, 0x00, 0x00, 0x26, 0xe2, 0x00, 0x00, 0x27, 0x03, 0x00,
+    0x00, 0x27, 0x24, 0x00, 0x00, 0x27, 0x45, 0x00, 0x00, 0x27, 0x66, 0x00,
+    0x00, 0x27, 0x87, 0x00, 0x00, 0x27, 0xa8, 0x00, 0x00, 0x27, 0xc9, 0x00,
+    0x00, 0x27, 0xeb, 0x00, 0x00, 0x28, 0x0d, 0x00, 0x00, 0x28, 0x2f, 0x00,
+    0x00, 0x28, 0x51, 0x00, 0x00, 0x28, 0x73, 0x00, 0x00, 0x28, 0x95, 0x00,
+    0x00, 0x28, 0xb7, 0x00, 0x00, 0x28, 0xd9, 0x00, 0x00, 0x28, 0xfb, 0x00,
+    0x00, 0x29, 0x1d, 0x00, 0x00, 0x29, 0x3f, 0x00, 0x00, 0x29, 0x61, 0x00,
+    0x00, 0x29, 0x83, 0x00, 0x00, 0x29, 0xa5, 0x00, 0x00, 0x29, 0xc7, 0x00,
+    0x00, 0x29, 0xe9, 0x00, 0x00, 0x2a, 0x0b, 0x00, 0x00, 0x2a, 0x2d, 0x00,
+    0x00, 0x2a, 0x4f, 0x00, 0x00, 0x2a, 0x71, 0x00, 0x00, 0x2a, 0x93, 0x00,
+    0x00, 0x2a, 0xb5, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x30, 0x00,
+    0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x81, 0x00,
+    0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, 0xd2, 0x00,
+    0x00, 0x00, 0xed, 0x00, 0x00, 0x01, 0x0a, 0x00, 0x00, 0x01, 0x27, 0x00,
+    0x00, 0x01, 0x44, 0x00, 0x00, 0x01, 0x61, 0x00, 0x00, 0x01, 0x7e, 0x00,
+    0x00, 0x01, 0x9b, 0x00, 0x00, 0x01, 0xb8, 0x00, 0x00, 0x01, 0xd5, 0x00,
+    0x00, 0x01, 0xf2, 0x00, 0x00, 0x02, 0x0f, 0x00, 0x00, 0x02, 0x2c, 0x00,
+    0x00, 0x02, 0x49, 0x00, 0x00, 0x02, 0x66, 0x00, 0x00, 0x02, 0x83, 0x00,
+    0x00, 0x02, 0xa0, 0x00, 0x00, 0x02, 0xbd, 0x00, 0x00, 0x02, 0xda, 0x00,
+    0x00, 0x02, 0xf7, 0x00, 0x00, 0x03, 0x14, 0x00, 0x00, 0x03, 0x31, 0x00,
+    0x00, 0x03, 0x4e, 0x00, 0x00, 0x03, 0x6b, 0x00, 0x00, 0x03, 0x88, 0x00,
+    0x00, 0x03, 0xa6, 0x00, 0x00, 0x03, 0xc4, 0x00, 0x00, 0x03, 0xe2, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x1e, 0x00, 0x00, 0x04, 0x3c, 0x00,
+    0x00, 0x04, 0x5a, 0x00, 0x00, 0x04, 0x78, 0x00, 0x00, 0x04, 0x97, 0x00,
+    0x00, 0x04, 0xb6, 0x00, 0x00, 0x04, 0xd5, 0x00, 0x00, 0x04, 0xf4, 0x00,
+    0x00, 0x05, 0x13, 0x00, 0x00, 0x05, 0x32, 0x00, 0x00, 0x05, 0x51, 0x00,
+    0x00, 0x05, 0x70, 0x00, 0x00, 0x05, 0x8f, 0x00, 0x00, 0x05, 0xae, 0x00,
+    0x00, 0x05, 0xcd, 0x00, 0x00, 0x05, 0xec, 0x00, 0x00, 0x06, 0x0b, 0x00,
+    0x00, 0x06, 0x2a, 0x00, 0x00, 0x06, 0x49, 0x00, 0x00, 0x06, 0x68, 0x00,
+    0x00, 0x06, 0x87, 0x00, 0x00, 0x06, 0xa6, 0x00, 0x00, 0x06, 0xc5, 0x00,
+    0x00, 0x06, 0xe4, 0x00, 0x00, 0x06, 0xff, 0x00, 0x00, 0x07, 0x1a, 0x00,
+    0x00, 0x07, 0x35, 0x00, 0x00, 0x07, 0x50, 0x00, 0x00, 0x07, 0x6b, 0x00,
+    0x00, 0x07, 0x86, 0x00, 0x00, 0x07, 0xa1, 0x00, 0x00, 0x07, 0xbc, 0x00,
+    0x00, 0x07, 0xd7, 0x00, 0x00, 0x07, 0xf3, 0x00, 0x00, 0x08, 0x0f, 0x00,
+    0x00, 0x08, 0x2b, 0x00, 0x00, 0x08, 0x47, 0x00, 0x00, 0x08, 0x63, 0x00,
+    0x00, 0x08, 0x7f, 0x00, 0x00, 0x08, 0x9b, 0x00, 0x00, 0x08, 0xb7, 0x00,
+    0x00, 0x08, 0xd3, 0x00, 0x00, 0x08, 0xef, 0x00, 0x00, 0x09, 0x0b, 0x00,
+    0x00, 0x09, 0x27, 0x00, 0x00, 0x09, 0x43, 0x00, 0x00, 0x09, 0x5f, 0x00,
+    0x00, 0x09, 0x7b, 0x00, 0x00, 0x09, 0x97, 0x00, 0x00, 0x09, 0xb3, 0x00,
+    0x00, 0x09, 0xcf, 0x00, 0x00, 0x09, 0xeb, 0x00, 0x00, 0x0a, 0x07, 0x00,
+    0x00, 0x0a, 0x23, 0x00, 0x00, 0x0a, 0x3f, 0x00, 0x00, 0x0a, 0x5a, 0x00,
+    0x00, 0x0a, 0x75, 0x00, 0x00, 0x0a, 0x90, 0x00, 0x00, 0x0a, 0xab, 0x00,
+    0x00, 0x0a, 0xc6, 0x00, 0x00, 0x0a, 0xe1, 0x00, 0x00, 0x0a, 0xfc, 0x00,
+    0x00, 0x0b, 0x17, 0x00, 0x00, 0x0b, 0x33, 0x00, 0x00, 0x0b, 0x50, 0x00,
+    0x00, 0x0b, 0x6d, 0x00, 0x00, 0x0b, 0x8a, 0x00, 0x00, 0x0b, 0xa7, 0x00,
+    0x00, 0x0b, 0xc4, 0x00, 0x00, 0x0b, 0xe1, 0x00, 0x00, 0x0b, 0xfe, 0x00,
+    0x00, 0x0c, 0x1b, 0x00, 0x00, 0x0c, 0x38, 0x00, 0x00, 0x0c, 0x55, 0x00,
+    0x00, 0x0c, 0x72, 0x00, 0x00, 0x0c, 0x8f, 0x00, 0x00, 0x0c, 0xac, 0x00,
+    0x00, 0x0c, 0xc9, 0x00, 0x00, 0x0c, 0xe6, 0x00, 0x00, 0x0d, 0x03, 0x00,
+    0x00, 0x0d, 0x20, 0x00, 0x00, 0x0d, 0x3d, 0x00, 0x00, 0x0d, 0x5a, 0x00,
+    0x00, 0x0d, 0x77, 0x00, 0x00, 0x0d, 0x94, 0x00, 0x00, 0x0d, 0xae, 0x00,
+    0x00, 0x0d, 0xc9, 0x00, 0x00, 0x0d, 0xe4, 0x00, 0x00, 0x0d, 0xff, 0x00,
+    0x00, 0x0e, 0x1a, 0x00, 0x00, 0x0e, 0x35, 0x00, 0x00, 0x0e, 0x50, 0x00,
+    0x00, 0x0e, 0x6b, 0x00, 0x00, 0x0e, 0x86, 0x00, 0x00, 0x0e, 0xa2, 0x00,
+    0x00, 0x0e, 0xbe, 0x00, 0x00, 0x0e, 0xda, 0x00, 0x00, 0x0e, 0xf6, 0x00,
+    0x00, 0x0f, 0x12, 0x00, 0x00, 0x0f, 0x2e, 0x00, 0x00, 0x0f, 0x4a, 0x00,
+    0x00, 0x0f, 0x66, 0x00, 0x00, 0x0f, 0x82, 0x00, 0x00, 0x0f, 0x9e, 0x00,
+    0x00, 0x0f, 0xba, 0x00, 0x00, 0x0f, 0xd6, 0x00, 0x00, 0x0f, 0xf2, 0x00,
+    0x00, 0x10, 0x0e, 0x00, 0x00, 0x10, 0x2a, 0x00, 0x00, 0x10, 0x46, 0x00,
+    0x00, 0x10, 0x62, 0x00, 0x00, 0x10, 0x7e, 0x00, 0x00, 0x10, 0x9a, 0x00,
+    0x00, 0x10, 0xb6, 0x00, 0x00, 0x10, 0xd2, 0x00, 0x00, 0x10, 0xee, 0x00,
+    0x00, 0x11, 0x0a, 0x00, 0x00, 0x11, 0x26, 0x00, 0x00, 0x11, 0x42, 0x00,
+    0x00, 0x11, 0x5e, 0x00, 0x00, 0x11, 0x7a, 0x00, 0x00, 0x11, 0x96, 0x00,
+    0x00, 0x11, 0xb2, 0x00, 0x00, 0x11, 0xce, 0x00, 0x00, 0x11, 0xea, 0x00,
+    0x00, 0x12, 0x07, 0x00, 0x00, 0x12, 0x24, 0x00, 0x00, 0x12, 0x41, 0x00,
+    0x00, 0x12, 0x5e, 0x00, 0x00, 0x12, 0x7b, 0x00, 0x00, 0x12, 0x98, 0x00,
+    0x00, 0x12, 0xb5, 0x00, 0x00, 0x12, 0xd2, 0x00, 0x00, 0x12, 0xef, 0x00,
+    0x00, 0x13, 0x0c, 0x00, 0x00, 0x13, 0x29, 0x00, 0x00, 0x13, 0x46, 0x00,
+    0x00, 0x13, 0x63, 0x00, 0x00, 0x13, 0x80, 0x00, 0x00, 0x13, 0x9d, 0x00,
+    0x00, 0x13, 0xba, 0x00, 0x00, 0x13, 0xd7, 0x00, 0x00, 0x13, 0xf4, 0x00,
+    0x00, 0x14, 0x11, 0x00, 0x00, 0x14, 0x2e, 0x00, 0x00, 0x14, 0x4b, 0x00,
+    0x00, 0x14, 0x67, 0x00, 0x00, 0x14, 0x83, 0x00, 0x00, 0x14, 0x9f, 0x00,
+    0x00, 0x14, 0xbb, 0x00, 0x00, 0x14, 0xd7, 0x00, 0x00, 0x14, 0xf3, 0x00,
+    0x00, 0x15, 0x0f, 0x00, 0x00, 0x15, 0x2b, 0x00, 0x00, 0x15, 0x47, 0x00,
+    0x00, 0x15, 0x64, 0x00, 0x00, 0x15, 0x81, 0x00, 0x00, 0x15, 0x9e, 0x00,
+    0x00, 0x15, 0xbb, 0x00, 0x00, 0x15, 0xd8, 0x00, 0x00, 0x15, 0xf5, 0x00,
+    0x00, 0x16, 0x12, 0x00, 0x00, 0x16, 0x2f, 0x00, 0x00, 0x16, 0x4c, 0x00,
+    0x00, 0x16, 0x69, 0x00, 0x00, 0x16, 0x86, 0x00, 0x00, 0x16, 0xa3, 0x00,
+    0x00, 0x16, 0xc0, 0x00, 0x00, 0x16, 0xdd, 0x00, 0x00, 0x16, 0xfa, 0x00,
+    0x00, 0x17, 0x17, 0x00, 0x00, 0x17, 0x34, 0x00, 0x00, 0x17, 0x51, 0x00,
+    0x00, 0x17, 0x6e, 0x00, 0x00, 0x17, 0x8b, 0x00, 0x00, 0x17, 0xa8, 0x00,
+    0x00, 0x17, 0xc5, 0x00, 0x00, 0x17, 0xe3, 0x00, 0x00, 0x18, 0x01, 0x00,
+    0x00, 0x18, 0x1f, 0x00, 0x00, 0x18, 0x3d, 0x00, 0x00, 0x18, 0x5b, 0x00,
+    0x00, 0x18, 0x79, 0x00, 0x00, 0x18, 0x97, 0x00, 0x00, 0x18, 0xb5, 0x00,
+    0x00, 0x18, 0xd3, 0x00, 0x00, 0x18, 0xf2, 0x00, 0x00, 0x19, 0x11, 0x00,
+    0x00, 0x19, 0x30, 0x00, 0x00, 0x19, 0x4f, 0x00, 0x00, 0x19, 0x6e, 0x00,
+    0x00, 0x19, 0x8d, 0x00, 0x00, 0x19, 0xac, 0x00, 0x00, 0x19, 0xcb, 0x00,
+    0x00, 0x19, 0xea, 0x00, 0x00, 0x1a, 0x09, 0x00, 0x00, 0x1a, 0x28, 0x00,
+    0x00, 0x1a, 0x47, 0x00, 0x00, 0x1a, 0x66, 0x00, 0x00, 0x1a, 0x85, 0x00,
+    0x00, 0x1a, 0xa4, 0x00, 0x00, 0x1a, 0xc3, 0x00, 0x00, 0x1a, 0xe2, 0x00,
+    0x00, 0x1b, 0x01, 0x00, 0x00, 0x1b, 0x20, 0x00, 0x00, 0x1b, 0x3f, 0x00,
+    0x00, 0x1b, 0x5e, 0x00, 0x00, 0x1b, 0x7d, 0x00, 0x00, 0x1b, 0x9c, 0x00,
+    0x00, 0x1b, 0xbb, 0x00, 0x00, 0x1b, 0xda, 0x00, 0x00, 0x1b, 0xf9, 0x00,
+    0x00, 0x1c, 0x18, 0x00, 0x00, 0x1c, 0x37, 0x00, 0x00, 0x1c, 0x56, 0x00,
+    0x00, 0x1c, 0x75, 0x00, 0x00, 0x1c, 0x94, 0x00, 0x00, 0x1c, 0xb4, 0x00,
+    0x00, 0x1c, 0xd4, 0x00, 0x00, 0x1c, 0xf4, 0x00, 0x00, 0x1d, 0x14, 0x00,
+    0x00, 0x1d, 0x34, 0x00, 0x00, 0x1d, 0x54, 0x00, 0x00, 0x1d, 0x74, 0x00,
+    0x00, 0x1d, 0x94, 0x00, 0x00, 0x1d, 0xb4, 0x00, 0x00, 0x1d, 0xd4, 0x00,
+    0x00, 0x1d, 0xf4, 0x00, 0x00, 0x1e, 0x14, 0x00, 0x00, 0x1e, 0x34, 0x00,
+    0x00, 0x1e, 0x54, 0x00, 0x00, 0x1e, 0x74, 0x00, 0x00, 0x1e, 0x94, 0x00,
+    0x00, 0x1e, 0xb4, 0x00, 0x00, 0x1e, 0xd4, 0x00, 0x00, 0x1e, 0xf4, 0x00,
+    0x00, 0x1f, 0x14, 0x00, 0x00, 0x1f, 0x34, 0x00, 0x00, 0x1f, 0x52, 0x00,
+    0x00, 0x1f, 0x70, 0x00, 0x00, 0x1f, 0x8e, 0x00, 0x00, 0x1f, 0xac, 0x00,
+    0x00, 0x1f, 0xca, 0x00, 0x00, 0x1f, 0xe8, 0x00, 0x00, 0x20, 0x06, 0x00,
+    0x00, 0x20, 0x24, 0x00, 0x00, 0x20, 0x42, 0x00, 0x00, 0x20, 0x61, 0x00,
+    0x00, 0x20, 0x80, 0x00, 0x00, 0x20, 0x9f, 0x00, 0x00, 0x20, 0xbe, 0x00,
+    0x00, 0x20, 0xdd, 0x00, 0x00, 0x20, 0xfc, 0x00, 0x00, 0x21, 0x1b, 0x00,
+    0x00, 0x21, 0x3a, 0x00, 0x00, 0x21, 0x59, 0x00, 0x00, 0x21, 0x78, 0x00,
+    0x00, 0x21, 0x97, 0x00, 0x00, 0x21, 0xb6, 0x00, 0x00, 0x21, 0xd5, 0x00,
+    0x00, 0x21, 0xf4, 0x00, 0x00, 0x22, 0x13, 0x00, 0x00, 0x22, 0x32, 0x00,
+    0x00, 0x22, 0x51, 0x00, 0x00, 0x22, 0x70, 0x00, 0x00, 0x22, 0x8f, 0x00,
+    0x00, 0x22, 0xae, 0x00, 0x00, 0x22, 0xcd, 0x00, 0x00, 0x22, 0xec, 0x00,
+    0x00, 0x23, 0x0b, 0x00, 0x00, 0x23, 0x2a, 0x00, 0x00, 0x23, 0x49, 0x00,
+    0x00, 0x23, 0x68, 0x00, 0x00, 0x23, 0x87, 0x00, 0x00, 0x23, 0xa6, 0x00,
+    0x00, 0x23, 0xc5, 0x00, 0x00, 0x23, 0xe4, 0x00, 0x00, 0x24, 0x03, 0x00,
+    0x00, 0x24, 0x23, 0x00, 0x00, 0x24, 0x43, 0x00, 0x00, 0x24, 0x63, 0x00,
+    0x00, 0x24, 0x83, 0x00, 0x00, 0x24, 0xa3, 0x00, 0x00, 0x24, 0xc3, 0x00,
+    0x00, 0x24, 0xe3, 0x00, 0x00, 0x25, 0x03, 0x00, 0x00, 0x25, 0x23, 0x00,
+    0x00, 0x25, 0x43, 0x00, 0x00, 0x25, 0x63, 0x00, 0x00, 0x25, 0x83, 0x00,
+    0x00, 0x25, 0xa3, 0x00, 0x00, 0x25, 0xc3, 0x00, 0x00, 0x25, 0xe3, 0x00,
+    0x00, 0x26, 0x03, 0x00, 0x00, 0x26, 0x23, 0x00, 0x00, 0x26, 0x43, 0x00,
+    0x00, 0x26, 0x63, 0x00, 0x00, 0x26, 0x83, 0x00, 0x00, 0x26, 0xa3, 0x00,
+    0x00, 0x26, 0xc4, 0x00, 0x00, 0x26, 0xe5, 0x00, 0x00, 0x27, 0x06, 0x00,
+    0x00, 0x27, 0x27, 0x00, 0x00, 0x27, 0x48, 0x00, 0x00, 0x27, 0x69, 0x00,
+    0x00, 0x27, 0x8a, 0x00, 0x00, 0x27, 0xab, 0x00, 0x00, 0x27, 0xcc, 0x00,
+    0x00, 0x27, 0xee, 0x00, 0x00, 0x28, 0x10, 0x00, 0x00, 0x28, 0x32, 0x00,
+    0x00, 0x28, 0x54, 0x00, 0x00, 0x28, 0x76, 0x00, 0x00, 0x28, 0x98, 0x00,
+    0x00, 0x28, 0xba, 0x00, 0x00, 0x28, 0xdc, 0x00, 0x00, 0x28, 0xfe, 0x00,
+    0x00, 0x29, 0x20, 0x00, 0x00, 0x29, 0x42, 0x00, 0x00, 0x29, 0x64, 0x00,
+    0x00, 0x29, 0x86, 0x00, 0x00, 0x29, 0xa8, 0x00, 0x00, 0x29, 0xca, 0x00,
+    0x00, 0x29, 0xec, 0x00, 0x00, 0x2a, 0x0e, 0x00, 0x00, 0x2a, 0x30, 0x00,
+    0x00, 0x2a, 0x52, 0x00, 0x00, 0x2a, 0x74, 0x00, 0x00, 0x2a, 0x96, 0x00,
+    0x00, 0x2a, 0xb8, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x32, 0x00,
+    0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x83, 0x00,
+    0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0xd4, 0x00,
+    0x00, 0x00, 0xef, 0x00, 0x00, 0x01, 0x0c, 0x00, 0x00, 0x01, 0x29, 0x00,
+    0x00, 0x01, 0x46, 0x00, 0x00, 0x01, 0x63, 0x00, 0x00, 0x01, 0x80, 0x00,
+    0x00, 0x01, 0x9d, 0x00, 0x00, 0x01, 0xba, 0x00, 0x00, 0x01, 0xd7, 0x00,
+    0x00, 0x01, 0xf4, 0x00, 0x00, 0x02, 0x11, 0x00, 0x00, 0x02, 0x2e, 0x00,
+    0x00, 0x02, 0x4b, 0x00, 0x00, 0x02, 0x68, 0x00, 0x00, 0x02, 0x85, 0x00,
+    0x00, 0x02, 0xa2, 0x00, 0x00, 0x02, 0xbf, 0x00, 0x00, 0x02, 0xdc, 0x00,
+    0x00, 0x02, 0xf9, 0x00, 0x00, 0x03, 0x16, 0x00, 0x00, 0x03, 0x33, 0x00,
+    0x00, 0x03, 0x50, 0x00, 0x00, 0x03, 0x6d, 0x00, 0x00, 0x03, 0x8a, 0x00,
+    0x00, 0x03, 0xa8, 0x00, 0x00, 0x03, 0xc6, 0x00, 0x00, 0x03, 0xe4, 0x00,
+    0x00, 0x04, 0x02, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x04, 0x3e, 0x00,
+    0x00, 0x04, 0x5c, 0x00, 0x00, 0x04, 0x7a, 0x00, 0x00, 0x04, 0x99, 0x00,
+    0x00, 0x04, 0xb8, 0x00, 0x00, 0x04, 0xd7, 0x00, 0x00, 0x04, 0xf6, 0x00,
+    0x00, 0x05, 0x15, 0x00, 0x00, 0x05, 0x34, 0x00, 0x00, 0x05, 0x53, 0x00,
+    0x00, 0x05, 0x72, 0x00, 0x00, 0x05, 0x91, 0x00, 0x00, 0x05, 0xb0, 0x00,
+    0x00, 0x05, 0xcf, 0x00, 0x00, 0x05, 0xee, 0x00, 0x00, 0x06, 0x0d, 0x00,
+    0x00, 0x06, 0x2c, 0x00, 0x00, 0x06, 0x4b, 0x00, 0x00, 0x06, 0x6a, 0x00,
+    0x00, 0x06, 0x89, 0x00, 0x00, 0x06, 0xa8, 0x00, 0x00, 0x06, 0xc7, 0x00,
+    0x00, 0x06, 0xe6, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x07, 0x1c, 0x00,
+    0x00, 0x07, 0x37, 0x00, 0x00, 0x07, 0x52, 0x00, 0x00, 0x07, 0x6d, 0x00,
+    0x00, 0x07, 0x88, 0x00, 0x00, 0x07, 0xa3, 0x00, 0x00, 0x07, 0xbe, 0x00,
+    0x00, 0x07, 0xd9, 0x00, 0x00, 0x07, 0xf5, 0x00, 0x00, 0x08, 0x11, 0x00,
+    0x00, 0x08, 0x2d, 0x00, 0x00, 0x08, 0x49, 0x00, 0x00, 0x08, 0x65, 0x00,
+    0x00, 0x08, 0x81, 0x00, 0x00, 0x08, 0x9d, 0x00, 0x00, 0x08, 0xb9, 0x00,
+    0x00, 0x08, 0xd5, 0x00, 0x00, 0x08, 0xf1, 0x00, 0x00, 0x09, 0x0d, 0x00,
+    0x00, 0x09, 0x29, 0x00, 0x00, 0x09, 0x45, 0x00, 0x00, 0x09, 0x61, 0x00,
+    0x00, 0x09, 0x7d, 0x00, 0x00, 0x09, 0x99, 0x00, 0x00, 0x09, 0xb5, 0x00,
+    0x00, 0x09, 0xd1, 0x00, 0x00, 0x09, 0xed, 0x00, 0x00, 0x0a, 0x09, 0x00,
+    0x00, 0x0a, 0x25, 0x00, 0x00, 0x0a, 0x41, 0x00, 0x00, 0x0a, 0x5c, 0x00,
+    0x00, 0x0a, 0x77, 0x00, 0x00, 0x0a, 0x92, 0x00, 0x00, 0x0a, 0xad, 0x00,
+    0x00, 0x0a, 0xc8, 0x00, 0x00, 0x0a, 0xe3, 0x00, 0x00, 0x0a, 0xfe, 0x00,
+    0x00, 0x0b, 0x19, 0x00, 0x00, 0x0b, 0x35, 0x00, 0x00, 0x0b, 0x52, 0x00,
+    0x00, 0x0b, 0x6f, 0x00, 0x00, 0x0b, 0x8c, 0x00, 0x00, 0x0b, 0xa9, 0x00,
+    0x00, 0x0b, 0xc6, 0x00, 0x00, 0x0b, 0xe3, 0x00, 0x00, 0x0c, 0x00, 0x00,
+    0x00, 0x0c, 0x1d, 0x00, 0x00, 0x0c, 0x3a, 0x00, 0x00, 0x0c, 0x57, 0x00,
+    0x00, 0x0c, 0x74, 0x00, 0x00, 0x0c, 0x91, 0x00, 0x00, 0x0c, 0xae, 0x00,
+    0x00, 0x0c, 0xcb, 0x00, 0x00, 0x0c, 0xe8, 0x00, 0x00, 0x0d, 0x05, 0x00,
+    0x00, 0x0d, 0x22, 0x00, 0x00, 0x0d, 0x3f, 0x00, 0x00, 0x0d, 0x5c, 0x00,
+    0x00, 0x0d, 0x79, 0x00, 0x00, 0x0d, 0x96, 0x00, 0x00, 0x0d, 0xb0, 0x00,
+    0x00, 0x0d, 0xcb, 0x00, 0x00, 0x0d, 0xe6, 0x00, 0x00, 0x0e, 0x01, 0x00,
+    0x00, 0x0e, 0x1c, 0x00, 0x00, 0x0e, 0x37, 0x00, 0x00, 0x0e, 0x52, 0x00,
+    0x00, 0x0e, 0x6d, 0x00, 0x00, 0x0e, 0x88, 0x00, 0x00, 0x0e, 0xa4, 0x00,
+    0x00, 0x0e, 0xc0, 0x00, 0x00, 0x0e, 0xdc, 0x00, 0x00, 0x0e, 0xf8, 0x00,
+    0x00, 0x0f, 0x14, 0x00, 0x00, 0x0f, 0x30, 0x00, 0x00, 0x0f, 0x4c, 0x00,
+    0x00, 0x0f, 0x68, 0x00, 0x00, 0x0f, 0x84, 0x00, 0x00, 0x0f, 0xa0, 0x00,
+    0x00, 0x0f, 0xbc, 0x00, 0x00, 0x0f, 0xd8, 0x00, 0x00, 0x0f, 0xf4, 0x00,
+    0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x2c, 0x00, 0x00, 0x10, 0x48, 0x00,
+    0x00, 0x10, 0x64, 0x00, 0x00, 0x10, 0x80, 0x00, 0x00, 0x10, 0x9c, 0x00,
+    0x00, 0x10, 0xb8, 0x00, 0x00, 0x10, 0xd4, 0x00, 0x00, 0x10, 0xf0, 0x00,
+    0x00, 0x11, 0x0c, 0x00, 0x00, 0x11, 0x28, 0x00, 0x00, 0x11, 0x44, 0x00,
+    0x00, 0x11, 0x60, 0x00, 0x00, 0x11, 0x7c, 0x00, 0x00, 0x11, 0x98, 0x00,
+    0x00, 0x11, 0xb4, 0x00, 0x00, 0x11, 0xd0, 0x00, 0x00, 0x11, 0xec, 0x00,
+    0x00, 0x12, 0x09, 0x00, 0x00, 0x12, 0x26, 0x00, 0x00, 0x12, 0x43, 0x00,
+    0x00, 0x12, 0x60, 0x00, 0x00, 0x12, 0x7d, 0x00, 0x00, 0x12, 0x9a, 0x00,
+    0x00, 0x12, 0xb7, 0x00, 0x00, 0x12, 0xd4, 0x00, 0x00, 0x12, 0xf1, 0x00,
+    0x00, 0x13, 0x0e, 0x00, 0x00, 0x13, 0x2b, 0x00, 0x00, 0x13, 0x48, 0x00,
+    0x00, 0x13, 0x65, 0x00, 0x00, 0x13, 0x82, 0x00, 0x00, 0x13, 0x9f, 0x00,
+    0x00, 0x13, 0xbc, 0x00, 0x00, 0x13, 0xd9, 0x00, 0x00, 0x13, 0xf6, 0x00,
+    0x00, 0x14, 0x13, 0x00, 0x00, 0x14, 0x30, 0x00, 0x00, 0x14, 0x4d, 0x00,
+    0x00, 0x14, 0x69, 0x00, 0x00, 0x14, 0x85, 0x00, 0x00, 0x14, 0xa1, 0x00,
+    0x00, 0x14, 0xbd, 0x00, 0x00, 0x14, 0xd9, 0x00, 0x00, 0x14, 0xf5, 0x00,
+    0x00, 0x15, 0x11, 0x00, 0x00, 0x15, 0x2d, 0x00, 0x00, 0x15, 0x49, 0x00,
+    0x00, 0x15, 0x66, 0x00, 0x00, 0x15, 0x83, 0x00, 0x00, 0x15, 0xa0, 0x00,
+    0x00, 0x15, 0xbd, 0x00, 0x00, 0x15, 0xda, 0x00, 0x00, 0x15, 0xf7, 0x00,
+    0x00, 0x16, 0x14, 0x00, 0x00, 0x16, 0x31, 0x00, 0x00, 0x16, 0x4e, 0x00,
+    0x00, 0x16, 0x6b, 0x00, 0x00, 0x16, 0x88, 0x00, 0x00, 0x16, 0xa5, 0x00,
+    0x00, 0x16, 0xc2, 0x00, 0x00, 0x16, 0xdf, 0x00, 0x00, 0x16, 0xfc, 0x00,
+    0x00, 0x17, 0x19, 0x00, 0x00, 0x17, 0x36, 0x00, 0x00, 0x17, 0x53, 0x00,
+    0x00, 0x17, 0x70, 0x00, 0x00, 0x17, 0x8d, 0x00, 0x00, 0x17, 0xaa, 0x00,
+    0x00, 0x17, 0xc7, 0x00, 0x00, 0x17, 0xe5, 0x00, 0x00, 0x18, 0x03, 0x00,
+    0x00, 0x18, 0x21, 0x00, 0x00, 0x18, 0x3f, 0x00, 0x00, 0x18, 0x5d, 0x00,
+    0x00, 0x18, 0x7b, 0x00, 0x00, 0x18, 0x99, 0x00, 0x00, 0x18, 0xb7, 0x00,
+    0x00, 0x18, 0xd5, 0x00, 0x00, 0x18, 0xf4, 0x00, 0x00, 0x19, 0x13, 0x00,
+    0x00, 0x19, 0x32, 0x00, 0x00, 0x19, 0x51, 0x00, 0x00, 0x19, 0x70, 0x00,
+    0x00, 0x19, 0x8f, 0x00, 0x00, 0x19, 0xae, 0x00, 0x00, 0x19, 0xcd, 0x00,
+    0x00, 0x19, 0xec, 0x00, 0x00, 0x1a, 0x0b, 0x00, 0x00, 0x1a, 0x2a, 0x00,
+    0x00, 0x1a, 0x49, 0x00, 0x00, 0x1a, 0x68, 0x00, 0x00, 0x1a, 0x87, 0x00,
+    0x00, 0x1a, 0xa6, 0x00, 0x00, 0x1a, 0xc5, 0x00, 0x00, 0x1a, 0xe4, 0x00,
+    0x00, 0x1b, 0x03, 0x00, 0x00, 0x1b, 0x22, 0x00, 0x00, 0x1b, 0x41, 0x00,
+    0x00, 0x1b, 0x60, 0x00, 0x00, 0x1b, 0x7f, 0x00, 0x00, 0x1b, 0x9e, 0x00,
+    0x00, 0x1b, 0xbd, 0x00, 0x00, 0x1b, 0xdc, 0x00, 0x00, 0x1b, 0xfb, 0x00,
+    0x00, 0x1c, 0x1a, 0x00, 0x00, 0x1c, 0x39, 0x00, 0x00, 0x1c, 0x58, 0x00,
+    0x00, 0x1c, 0x77, 0x00, 0x00, 0x1c, 0x96, 0x00, 0x00, 0x1c, 0xb6, 0x00,
+    0x00, 0x1c, 0xd6, 0x00, 0x00, 0x1c, 0xf6, 0x00, 0x00, 0x1d, 0x16, 0x00,
+    0x00, 0x1d, 0x36, 0x00, 0x00, 0x1d, 0x56, 0x00, 0x00, 0x1d, 0x76, 0x00,
+    0x00, 0x1d, 0x96, 0x00, 0x00, 0x1d, 0xb6, 0x00, 0x00, 0x1d, 0xd6, 0x00,
+    0x00, 0x1d, 0xf6, 0x00, 0x00, 0x1e, 0x16, 0x00, 0x00, 0x1e, 0x36, 0x00,
+    0x00, 0x1e, 0x56, 0x00, 0x00, 0x1e, 0x76, 0x00, 0x00, 0x1e, 0x96, 0x00,
+    0x00, 0x1e, 0xb6, 0x00, 0x00, 0x1e, 0xd6, 0x00, 0x00, 0x1e, 0xf6, 0x00,
+    0x00, 0x1f, 0x16, 0x00, 0x00, 0x1f, 0x36, 0x00, 0x00, 0x1f, 0x54, 0x00,
+    0x00, 0x1f, 0x72, 0x00, 0x00, 0x1f, 0x90, 0x00, 0x00, 0x1f, 0xae, 0x00,
+    0x00, 0x1f, 0xcc, 0x00, 0x00, 0x1f, 0xea, 0x00, 0x00, 0x20, 0x08, 0x00,
+    0x00, 0x20, 0x26, 0x00, 0x00, 0x20, 0x44, 0x00, 0x00, 0x20, 0x63, 0x00,
+    0x00, 0x20, 0x82, 0x00, 0x00, 0x20, 0xa1, 0x00, 0x00, 0x20, 0xc0, 0x00,
+    0x00, 0x20, 0xdf, 0x00, 0x00, 0x20, 0xfe, 0x00, 0x00, 0x21, 0x1d, 0x00,
+    0x00, 0x21, 0x3c, 0x00, 0x00, 0x21, 0x5b, 0x00, 0x00, 0x21, 0x7a, 0x00,
+    0x00, 0x21, 0x99, 0x00, 0x00, 0x21, 0xb8, 0x00, 0x00, 0x21, 0xd7, 0x00,
+    0x00, 0x21, 0xf6, 0x00, 0x00, 0x22, 0x15, 0x00, 0x00, 0x22, 0x34, 0x00,
+    0x00, 0x22, 0x53, 0x00, 0x00, 0x22, 0x72, 0x00, 0x00, 0x22, 0x91, 0x00,
+    0x00, 0x22, 0xb0, 0x00, 0x00, 0x22, 0xcf, 0x00, 0x00, 0x22, 0xee, 0x00,
+    0x00, 0x23, 0x0d, 0x00, 0x00, 0x23, 0x2c, 0x00, 0x00, 0x23, 0x4b, 0x00,
+    0x00, 0x23, 0x6a, 0x00, 0x00, 0x23, 0x89, 0x00, 0x00, 0x23, 0xa8, 0x00,
+    0x00, 0x23, 0xc7, 0x00, 0x00, 0x23, 0xe6, 0x00, 0x00, 0x24, 0x05, 0x00,
+    0x00, 0x24, 0x25, 0x00, 0x00, 0x24, 0x45, 0x00, 0x00, 0x24, 0x65, 0x00,
+    0x00, 0x24, 0x85, 0x00, 0x00, 0x24, 0xa5, 0x00, 0x00, 0x24, 0xc5, 0x00,
+    0x00, 0x24, 0xe5, 0x00, 0x00, 0x25, 0x05, 0x00, 0x00, 0x25, 0x25, 0x00,
+    0x00, 0x25, 0x45, 0x00, 0x00, 0x25, 0x65, 0x00, 0x00, 0x25, 0x85, 0x00,
+    0x00, 0x25, 0xa5, 0x00, 0x00, 0x25, 0xc5, 0x00, 0x00, 0x25, 0xe5, 0x00,
+    0x00, 0x26, 0x05, 0x00, 0x00, 0x26, 0x25, 0x00, 0x00, 0x26, 0x45, 0x00,
+    0x00, 0x26, 0x65, 0x00, 0x00, 0x26, 0x85, 0x00, 0x00, 0x26, 0xa5, 0x00,
+    0x00, 0x26, 0xc6, 0x00, 0x00, 0x26, 0xe7, 0x00, 0x00, 0x27, 0x08, 0x00,
+    0x00, 0x27, 0x29, 0x00, 0x00, 0x27, 0x4a, 0x00, 0x00, 0x27, 0x6b, 0x00,
+    0x00, 0x27, 0x8c, 0x00, 0x00, 0x27, 0xad, 0x00, 0x00, 0x27, 0xce, 0x00,
+    0x00, 0x27, 0xf0, 0x00, 0x00, 0x28, 0x12, 0x00, 0x00, 0x28, 0x34, 0x00,
+    0x00, 0x28, 0x56, 0x00, 0x00, 0x28, 0x78, 0x00, 0x00, 0x28, 0x9a, 0x00,
+    0x00, 0x28, 0xbc, 0x00, 0x00, 0x28, 0xde, 0x00, 0x00, 0x29, 0x00, 0x00,
+    0x00, 0x29, 0x22, 0x00, 0x00, 0x29, 0x44, 0x00, 0x00, 0x29, 0x66, 0x00,
+    0x00, 0x29, 0x88, 0x00, 0x00, 0x29, 0xaa, 0x00, 0x00, 0x29, 0xcc, 0x00,
+    0x00, 0x29, 0xee, 0x00, 0x00, 0x2a, 0x10, 0x00, 0x00, 0x2a, 0x32, 0x00,
+    0x00, 0x2a, 0x54, 0x00, 0x00, 0x2a, 0x76, 0x00, 0x00, 0x2a, 0x98, 0x00,
+    0x00, 0x2a, 0xba, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x34, 0x00,
+    0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, 0x85, 0x00,
+    0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, 0xd6, 0x00,
+    0x00, 0x00, 0xf1, 0x00, 0x00, 0x01, 0x0e, 0x00, 0x00, 0x01, 0x2b, 0x00,
+    0x00, 0x01, 0x48, 0x00, 0x00, 0x01, 0x65, 0x00, 0x00, 0x01, 0x82, 0x00,
+    0x00, 0x01, 0x9f, 0x00, 0x00, 0x01, 0xbc, 0x00, 0x00, 0x01, 0xd9, 0x00,
+    0x00, 0x01, 0xf6, 0x00, 0x00, 0x02, 0x13, 0x00, 0x00, 0x02, 0x30, 0x00,
+    0x00, 0x02, 0x4d, 0x00, 0x00, 0x02, 0x6a, 0x00, 0x00, 0x02, 0x87, 0x00,
+    0x00, 0x02, 0xa4, 0x00, 0x00, 0x02, 0xc1, 0x00, 0x00, 0x02, 0xde, 0x00,
+    0x00, 0x02, 0xfb, 0x00, 0x00, 0x03, 0x18, 0x00, 0x00, 0x03, 0x35, 0x00,
+    0x00, 0x03, 0x52, 0x00, 0x00, 0x03, 0x6f, 0x00, 0x00, 0x03, 0x8d, 0x00,
+    0x00, 0x03, 0xab, 0x00, 0x00, 0x03, 0xc9, 0x00, 0x00, 0x03, 0xe7, 0x00,
+    0x00, 0x04, 0x05, 0x00, 0x00, 0x04, 0x23, 0x00, 0x00, 0x04, 0x41, 0x00,
+    0x00, 0x04, 0x5f, 0x00, 0x00, 0x04, 0x7d, 0x00, 0x00, 0x04, 0x9c, 0x00,
+    0x00, 0x04, 0xbb, 0x00, 0x00, 0x04, 0xda, 0x00, 0x00, 0x04, 0xf9, 0x00,
+    0x00, 0x05, 0x18, 0x00, 0x00, 0x05, 0x37, 0x00, 0x00, 0x05, 0x56, 0x00,
+    0x00, 0x05, 0x75, 0x00, 0x00, 0x05, 0x94, 0x00, 0x00, 0x05, 0xb3, 0x00,
+    0x00, 0x05, 0xd2, 0x00, 0x00, 0x05, 0xf1, 0x00, 0x00, 0x06, 0x10, 0x00,
+    0x00, 0x06, 0x2f, 0x00, 0x00, 0x06, 0x4e, 0x00, 0x00, 0x06, 0x6d, 0x00,
+    0x00, 0x06, 0x8c, 0x00, 0x00, 0x06, 0xab, 0x00, 0x00, 0x06, 0xca, 0x00,
+    0x00, 0x06, 0xe9, 0x00, 0x00, 0x07, 0x04, 0x00, 0x00, 0x07, 0x1f, 0x00,
+    0x00, 0x07, 0x3a, 0x00, 0x00, 0x07, 0x55, 0x00, 0x00, 0x07, 0x70, 0x00,
+    0x00, 0x07, 0x8b, 0x00, 0x00, 0x07, 0xa6, 0x00, 0x00, 0x07, 0xc1, 0x00,
+    0x00, 0x07, 0xdc, 0x00, 0x00, 0x07, 0xf8, 0x00, 0x00, 0x08, 0x14, 0x00,
+    0x00, 0x08, 0x30, 0x00, 0x00, 0x08, 0x4c, 0x00, 0x00, 0x08, 0x68, 0x00,
+    0x00, 0x08, 0x84, 0x00, 0x00, 0x08, 0xa0, 0x00, 0x00, 0x08, 0xbc, 0x00,
+    0x00, 0x08, 0xd8, 0x00, 0x00, 0x08, 0xf4, 0x00, 0x00, 0x09, 0x10, 0x00,
+    0x00, 0x09, 0x2c, 0x00, 0x00, 0x09, 0x48, 0x00, 0x00, 0x09, 0x64, 0x00,
+    0x00, 0x09, 0x80, 0x00, 0x00, 0x09, 0x9c, 0x00, 0x00, 0x09, 0xb8, 0x00,
+    0x00, 0x09, 0xd4, 0x00, 0x00, 0x09, 0xf0, 0x00, 0x00, 0x0a, 0x0c, 0x00,
+    0x00, 0x0a, 0x28, 0x00, 0x00, 0x0a, 0x44, 0x00, 0x00, 0x0a, 0x5f, 0x00,
+    0x00, 0x0a, 0x7a, 0x00, 0x00, 0x0a, 0x95, 0x00, 0x00, 0x0a, 0xb0, 0x00,
+    0x00, 0x0a, 0xcb, 0x00, 0x00, 0x0a, 0xe6, 0x00, 0x00, 0x0b, 0x01, 0x00,
+    0x00, 0x0b, 0x1c, 0x00, 0x00, 0x0b, 0x38, 0x00, 0x00, 0x0b, 0x55, 0x00,
+    0x00, 0x0b, 0x72, 0x00, 0x00, 0x0b, 0x8f, 0x00, 0x00, 0x0b, 0xac, 0x00,
+    0x00, 0x0b, 0xc9, 0x00, 0x00, 0x0b, 0xe6, 0x00, 0x00, 0x0c, 0x03, 0x00,
+    0x00, 0x0c, 0x20, 0x00, 0x00, 0x0c, 0x3d, 0x00, 0x00, 0x0c, 0x5a, 0x00,
+    0x00, 0x0c, 0x77, 0x00, 0x00, 0x0c, 0x94, 0x00, 0x00, 0x0c, 0xb1, 0x00,
+    0x00, 0x0c, 0xce, 0x00, 0x00, 0x0c, 0xeb, 0x00, 0x00, 0x0d, 0x08, 0x00,
+    0x00, 0x0d, 0x25, 0x00, 0x00, 0x0d, 0x42, 0x00, 0x00, 0x0d, 0x5f, 0x00,
+    0x00, 0x0d, 0x7c, 0x00, 0x00, 0x0d, 0x99, 0x00, 0x00, 0x0d, 0xb4, 0x00,
+    0x00, 0x0d, 0xcf, 0x00, 0x00, 0x0d, 0xea, 0x00, 0x00, 0x0e, 0x05, 0x00,
+    0x00, 0x0e, 0x20, 0x00, 0x00, 0x0e, 0x3b, 0x00, 0x00, 0x0e, 0x56, 0x00,
+    0x00, 0x0e, 0x71, 0x00, 0x00, 0x0e, 0x8c, 0x00, 0x00, 0x0e, 0xa8, 0x00,
+    0x00, 0x0e, 0xc4, 0x00, 0x00, 0x0e, 0xe0, 0x00, 0x00, 0x0e, 0xfc, 0x00,
+    0x00, 0x0f, 0x18, 0x00, 0x00, 0x0f, 0x34, 0x00, 0x00, 0x0f, 0x50, 0x00,
+    0x00, 0x0f, 0x6c, 0x00, 0x00, 0x0f, 0x88, 0x00, 0x00, 0x0f, 0xa4, 0x00,
+    0x00, 0x0f, 0xc0, 0x00, 0x00, 0x0f, 0xdc, 0x00, 0x00, 0x0f, 0xf8, 0x00,
+    0x00, 0x10, 0x14, 0x00, 0x00, 0x10, 0x30, 0x00, 0x00, 0x10, 0x4c, 0x00,
+    0x00, 0x10, 0x68, 0x00, 0x00, 0x10, 0x84, 0x00, 0x00, 0x10, 0xa0, 0x00,
+    0x00, 0x10, 0xbc, 0x00, 0x00, 0x10, 0xd8, 0x00, 0x00, 0x10, 0xf4, 0x00,
+    0x00, 0x11, 0x10, 0x00, 0x00, 0x11, 0x2c, 0x00, 0x00, 0x11, 0x48, 0x00,
+    0x00, 0x11, 0x64, 0x00, 0x00, 0x11, 0x80, 0x00, 0x00, 0x11, 0x9c, 0x00,
+    0x00, 0x11, 0xb8, 0x00, 0x00, 0x11, 0xd4, 0x00, 0x00, 0x11, 0xf0, 0x00,
+    0x00, 0x12, 0x0d, 0x00, 0x00, 0x12, 0x2a, 0x00, 0x00, 0x12, 0x47, 0x00,
+    0x00, 0x12, 0x64, 0x00, 0x00, 0x12, 0x81, 0x00, 0x00, 0x12, 0x9e, 0x00,
+    0x00, 0x12, 0xbb, 0x00, 0x00, 0x12, 0xd8, 0x00, 0x00, 0x12, 0xf5, 0x00,
+    0x00, 0x13, 0x12, 0x00, 0x00, 0x13, 0x2f, 0x00, 0x00, 0x13, 0x4c, 0x00,
+    0x00, 0x13, 0x69, 0x00, 0x00, 0x13, 0x86, 0x00, 0x00, 0x13, 0xa3, 0x00,
+    0x00, 0x13, 0xc0, 0x00, 0x00, 0x13, 0xdd, 0x00, 0x00, 0x13, 0xfa, 0x00,
+    0x00, 0x14, 0x17, 0x00, 0x00, 0x14, 0x34, 0x00, 0x00, 0x14, 0x51, 0x00,
+    0x00, 0x14, 0x6d, 0x00, 0x00, 0x14, 0x89, 0x00, 0x00, 0x14, 0xa5, 0x00,
+    0x00, 0x14, 0xc1, 0x00, 0x00, 0x14, 0xdd, 0x00, 0x00, 0x14, 0xf9, 0x00,
+    0x00, 0x15, 0x15, 0x00, 0x00, 0x15, 0x31, 0x00, 0x00, 0x15, 0x4d, 0x00,
+    0x00, 0x15, 0x6a, 0x00, 0x00, 0x15, 0x87, 0x00, 0x00, 0x15, 0xa4, 0x00,
+    0x00, 0x15, 0xc1, 0x00, 0x00, 0x15, 0xde, 0x00, 0x00, 0x15, 0xfb, 0x00,
+    0x00, 0x16, 0x18, 0x00, 0x00, 0x16, 0x35, 0x00, 0x00, 0x16, 0x52, 0x00,
+    0x00, 0x16, 0x6f, 0x00, 0x00, 0x16, 0x8c, 0x00, 0x00, 0x16, 0xa9, 0x00,
+    0x00, 0x16, 0xc6, 0x00, 0x00, 0x16, 0xe3, 0x00, 0x00, 0x17, 0x00, 0x00,
+    0x00, 0x17, 0x1d, 0x00, 0x00, 0x17, 0x3a, 0x00, 0x00, 0x17, 0x57, 0x00,
+    0x00, 0x17, 0x74, 0x00, 0x00, 0x17, 0x91, 0x00, 0x00, 0x17, 0xae, 0x00,
+    0x00, 0x17, 0xcb, 0x00, 0x00, 0x17, 0xe9, 0x00, 0x00, 0x18, 0x07, 0x00,
+    0x00, 0x18, 0x25, 0x00, 0x00, 0x18, 0x43, 0x00, 0x00, 0x18, 0x61, 0x00,
+    0x00, 0x18, 0x7f, 0x00, 0x00, 0x18, 0x9d, 0x00, 0x00, 0x18, 0xbb, 0x00,
+    0x00, 0x18, 0xd9, 0x00, 0x00, 0x18, 0xf8, 0x00, 0x00, 0x19, 0x17, 0x00,
+    0x00, 0x19, 0x36, 0x00, 0x00, 0x19, 0x55, 0x00, 0x00, 0x19, 0x74, 0x00,
+    0x00, 0x19, 0x93, 0x00, 0x00, 0x19, 0xb2, 0x00, 0x00, 0x19, 0xd1, 0x00,
+    0x00, 0x19, 0xf0, 0x00, 0x00, 0x1a, 0x0f, 0x00, 0x00, 0x1a, 0x2e, 0x00,
+    0x00, 0x1a, 0x4d, 0x00, 0x00, 0x1a, 0x6c, 0x00, 0x00, 0x1a, 0x8b, 0x00,
+    0x00, 0x1a, 0xaa, 0x00, 0x00, 0x1a, 0xc9, 0x00, 0x00, 0x1a, 0xe8, 0x00,
+    0x00, 0x1b, 0x07, 0x00, 0x00, 0x1b, 0x26, 0x00, 0x00, 0x1b, 0x45, 0x00,
+    0x00, 0x1b, 0x64, 0x00, 0x00, 0x1b, 0x83, 0x00, 0x00, 0x1b, 0xa2, 0x00,
+    0x00, 0x1b, 0xc1, 0x00, 0x00, 0x1b, 0xe0, 0x00, 0x00, 0x1b, 0xff, 0x00,
+    0x00, 0x1c, 0x1e, 0x00, 0x00, 0x1c, 0x3d, 0x00, 0x00, 0x1c, 0x5c, 0x00,
+    0x00, 0x1c, 0x7b, 0x00, 0x00, 0x1c, 0x9a, 0x00, 0x00, 0x1c, 0xba, 0x00,
+    0x00, 0x1c, 0xda, 0x00, 0x00, 0x1c, 0xfa, 0x00, 0x00, 0x1d, 0x1a, 0x00,
+    0x00, 0x1d, 0x3a, 0x00, 0x00, 0x1d, 0x5a, 0x00, 0x00, 0x1d, 0x7a, 0x00,
+    0x00, 0x1d, 0x9a, 0x00, 0x00, 0x1d, 0xba, 0x00, 0x00, 0x1d, 0xda, 0x00,
+    0x00, 0x1d, 0xfa, 0x00, 0x00, 0x1e, 0x1a, 0x00, 0x00, 0x1e, 0x3a, 0x00,
+    0x00, 0x1e, 0x5a, 0x00, 0x00, 0x1e, 0x7a, 0x00, 0x00, 0x1e, 0x9a, 0x00,
+    0x00, 0x1e, 0xba, 0x00, 0x00, 0x1e, 0xda, 0x00, 0x00, 0x1e, 0xfa, 0x00,
+    0x00, 0x1f, 0x1a, 0x00, 0x00, 0x1f, 0x3a, 0x00, 0x00, 0x1f, 0x58, 0x00,
+    0x00, 0x1f, 0x76, 0x00, 0x00, 0x1f, 0x94, 0x00, 0x00, 0x1f, 0xb2, 0x00,
+    0x00, 0x1f, 0xd0, 0x00, 0x00, 0x1f, 0xee, 0x00, 0x00, 0x20, 0x0c, 0x00,
+    0x00, 0x20, 0x2a, 0x00, 0x00, 0x20, 0x48, 0x00, 0x00, 0x20, 0x67, 0x00,
+    0x00, 0x20, 0x86, 0x00, 0x00, 0x20, 0xa5, 0x00, 0x00, 0x20, 0xc4, 0x00,
+    0x00, 0x20, 0xe3, 0x00, 0x00, 0x21, 0x02, 0x00, 0x00, 0x21, 0x21, 0x00,
+    0x00, 0x21, 0x40, 0x00, 0x00, 0x21, 0x5f, 0x00, 0x00, 0x21, 0x7e, 0x00,
+    0x00, 0x21, 0x9d, 0x00, 0x00, 0x21, 0xbc, 0x00, 0x00, 0x21, 0xdb, 0x00,
+    0x00, 0x21, 0xfa, 0x00, 0x00, 0x22, 0x19, 0x00, 0x00, 0x22, 0x38, 0x00,
+    0x00, 0x22, 0x57, 0x00, 0x00, 0x22, 0x76, 0x00, 0x00, 0x22, 0x95, 0x00,
+    0x00, 0x22, 0xb4, 0x00, 0x00, 0x22, 0xd3, 0x00, 0x00, 0x22, 0xf2, 0x00,
+    0x00, 0x23, 0x11, 0x00, 0x00, 0x23, 0x30, 0x00, 0x00, 0x23, 0x4f, 0x00,
+    0x00, 0x23, 0x6e, 0x00, 0x00, 0x23, 0x8d, 0x00, 0x00, 0x23, 0xac, 0x00,
+    0x00, 0x23, 0xcb, 0x00, 0x00, 0x23, 0xea, 0x00, 0x00, 0x24, 0x09, 0x00,
+    0x00, 0x24, 0x29, 0x00, 0x00, 0x24, 0x49, 0x00, 0x00, 0x24, 0x69, 0x00,
+    0x00, 0x24, 0x89, 0x00, 0x00, 0x24, 0xa9, 0x00, 0x00, 0x24, 0xc9, 0x00,
+    0x00, 0x24, 0xe9, 0x00, 0x00, 0x25, 0x09, 0x00, 0x00, 0x25, 0x29, 0x00,
+    0x00, 0x25, 0x49, 0x00, 0x00, 0x25, 0x69, 0x00, 0x00, 0x25, 0x89, 0x00,
+    0x00, 0x25, 0xa9, 0x00, 0x00, 0x25, 0xc9, 0x00, 0x00, 0x25, 0xe9, 0x00,
+    0x00, 0x26, 0x09, 0x00, 0x00, 0x26, 0x29, 0x00, 0x00, 0x26, 0x49, 0x00,
+    0x00, 0x26, 0x69, 0x00, 0x00, 0x26, 0x89, 0x00, 0x00, 0x26, 0xa9, 0x00,
+    0x00, 0x26, 0xca, 0x00, 0x00, 0x26, 0xeb, 0x00, 0x00, 0x27, 0x0c, 0x00,
+    0x00, 0x27, 0x2d, 0x00, 0x00, 0x27, 0x4e, 0x00, 0x00, 0x27, 0x6f, 0x00,
+    0x00, 0x27, 0x90, 0x00, 0x00, 0x27, 0xb1, 0x00, 0x00, 0x27, 0xd2, 0x00,
+    0x00, 0x27, 0xf4, 0x00, 0x00, 0x28, 0x16, 0x00, 0x00, 0x28, 0x38, 0x00,
+    0x00, 0x28, 0x5a, 0x00, 0x00, 0x28, 0x7c, 0x00, 0x00, 0x28, 0x9e, 0x00,
+    0x00, 0x28, 0xc0, 0x00, 0x00, 0x28, 0xe2, 0x00, 0x00, 0x29, 0x04, 0x00,
+    0x00, 0x29, 0x26, 0x00, 0x00, 0x29, 0x48, 0x00, 0x00, 0x29, 0x6a, 0x00,
+    0x00, 0x29, 0x8c, 0x00, 0x00, 0x29, 0xae, 0x00, 0x00, 0x29, 0xd0, 0x00,
+    0x00, 0x29, 0xf2, 0x00, 0x00, 0x2a, 0x14, 0x00, 0x00, 0x2a, 0x36, 0x00,
+    0x00, 0x2a, 0x58, 0x00, 0x00, 0x2a, 0x7a, 0x00, 0x00, 0x2a, 0x9c, 0x00,
+    0x00, 0x2a, 0xbe, 0x64, 0x61, 0x79, 0x5f, 0x73, 0x65, 0x71, 0x00, 0x6d,
+    0x6f, 0x6e, 0x74, 0x68, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x64, 0x61,
+    0x74, 0x65, 0x00, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x6d, 0x6f,
+    0x6e, 0x74, 0x68, 0x5f, 0x6e, 0x75, 0x6d, 0x00, 0x71, 0x75, 0x61, 0x72,
+    0x74, 0x65, 0x72, 0x00, 0x66, 0x6f, 0x6d, 0x00, 0x68, 0x6f, 0x6c, 0x69,
+    0x64, 0x61, 0x79, 0x00, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x00,
+    0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x6c, 0x65, 0x61, 0x70,
+    0x00, 0x73, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x73, 0x61, 0x6c, 0x65, 0x73,
+    0x5f, 0x6c, 0x65, 0x61, 0x70, 0x00, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
+    0x73, 0x00, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x5f, 0x6c, 0x65,
+    0x61, 0x70, 0x00, 0x73, 0x6b, 0x65, 0x77, 0x65, 0x64, 0x00, 0x6c, 0x6f,
+    0x77, 0x00, 0x6d, 0x65, 0x64, 0x69, 0x75, 0x6d, 0x00, 0x68, 0x69, 0x67,
+    0x68, 0x00, 0x31, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00,
+    0x31, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31,
+    0x00, 0x31, 0x00, 0x31, 0x00, 0x32, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61,
+    0x72, 0x79, 0x00, 0x32, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00,
+    0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x33, 0x00, 0x4a, 0x61,
+    0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x33, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x34,
+    0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x34, 0x00, 0x57,
+    0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00,
+    0x30, 0x00, 0x35, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00,
+    0x35, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31,
+    0x00, 0x31, 0x00, 0x30, 0x00, 0x36, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61,
+    0x72, 0x79, 0x00, 0x36, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00,
+    0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x37, 0x00, 0x4a, 0x61,
+    0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x37, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x38,
+    0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x38, 0x00, 0x57,
+    0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00,
+    0x30, 0x00, 0x39, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00,
+    0x39, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31,
+    0x00, 0x31, 0x00, 0x30, 0x00, 0x31, 0x30, 0x00, 0x4a, 0x61, 0x6e, 0x75,
+    0x61, 0x72, 0x79, 0x00, 0x31, 0x30, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x31, 0x31,
+    0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x31, 0x00,
+    0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31,
+    0x00, 0x30, 0x00, 0x31, 0x32, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72,
+    0x79, 0x00, 0x31, 0x32, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00,
+    0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x31, 0x33, 0x00, 0x4a,
+    0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x33, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30,
+    0x00, 0x31, 0x34, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00,
+    0x31, 0x34, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00,
+    0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x31, 0x35, 0x00, 0x4a, 0x61, 0x6e,
+    0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x35, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x31,
+    0x36, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x36,
+    0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00,
+    0x31, 0x00, 0x30, 0x00, 0x31, 0x37, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61,
+    0x72, 0x79, 0x00, 0x31, 0x37, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x31, 0x38, 0x00,
+    0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x38, 0x00, 0x57,
+    0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00,
+    0x30, 0x00, 0x31, 0x39, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79,
+    0x00, 0x31, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31,
+    0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x32, 0x30, 0x00, 0x4a, 0x61,
+    0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x30, 0x00, 0x57, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00,
+    0x32, 0x31, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32,
+    0x31, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31,
+    0x00, 0x31, 0x00, 0x30, 0x00, 0x32, 0x32, 0x00, 0x4a, 0x61, 0x6e, 0x75,
+    0x61, 0x72, 0x79, 0x00, 0x32, 0x32, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x32, 0x33,
+    0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x33, 0x00,
+    0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31,
+    0x00, 0x30, 0x00, 0x32, 0x34, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72,
+    0x79, 0x00, 0x32, 0x34, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00,
+    0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x32, 0x35, 0x00, 0x4a,
+    0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x35, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30,
+    0x00, 0x32, 0x36, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00,
+    0x32, 0x36, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00,
+    0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x32, 0x37, 0x00, 0x4a, 0x61, 0x6e,
+    0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x37, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x32,
+    0x38, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x38,
+    0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00,
+    0x31, 0x00, 0x30, 0x00, 0x32, 0x39, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61,
+    0x72, 0x79, 0x00, 0x32, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x33, 0x30, 0x00,
+    0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79, 0x00, 0x33, 0x30, 0x00, 0x57,
+    0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x00, 0x31, 0x00, 0x31, 0x00,
+    0x30, 0x00, 0x33, 0x31, 0x00, 0x4a, 0x61, 0x6e, 0x75, 0x61, 0x72, 0x79,
+    0x00, 0x33, 0x31, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31,
+    0x00, 0x31, 0x00, 0x31, 0x00, 0x30, 0x00, 0x33, 0x32, 0x00, 0x46, 0x65,
+    0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x00, 0x57, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30,
+    0x00, 0x33, 0x33, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79,
+    0x00, 0x32, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00,
+    0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x33, 0x34, 0x00, 0x46, 0x65,
+    0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x33, 0x00, 0x57, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30,
+    0x00, 0x33, 0x35, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79,
+    0x00, 0x34, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00,
+    0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x33, 0x36, 0x00, 0x46, 0x65,
+    0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x35, 0x00, 0x57, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30,
+    0x00, 0x33, 0x37, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79,
+    0x00, 0x36, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00,
+    0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x33, 0x38, 0x00, 0x46, 0x65,
+    0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x37, 0x00, 0x57, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30,
+    0x00, 0x33, 0x39, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79,
+    0x00, 0x38, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00,
+    0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x34, 0x30, 0x00, 0x46, 0x65,
+    0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x39, 0x00, 0x57, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30,
+    0x00, 0x34, 0x31, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79,
+    0x00, 0x31, 0x30, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32,
+    0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x34, 0x32, 0x00, 0x46,
+    0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x31, 0x00, 0x57,
+    0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32,
+    0x00, 0x30, 0x00, 0x34, 0x33, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61,
+    0x72, 0x79, 0x00, 0x31, 0x32, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x34, 0x34,
+    0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x33,
+    0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00,
+    0x33, 0x32, 0x00, 0x30, 0x00, 0x34, 0x35, 0x00, 0x46, 0x65, 0x62, 0x72,
+    0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x34, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00,
+    0x34, 0x36, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00,
+    0x31, 0x35, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00,
+    0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x34, 0x37, 0x00, 0x46, 0x65,
+    0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x36, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00,
+    0x30, 0x00, 0x34, 0x38, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72,
+    0x79, 0x00, 0x31, 0x37, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00,
+    0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x34, 0x39, 0x00,
+    0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x31, 0x38, 0x00,
+    0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33,
+    0x32, 0x00, 0x30, 0x00, 0x35, 0x30, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75,
+    0x61, 0x72, 0x79, 0x00, 0x31, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x35,
+    0x31, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32,
+    0x30, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31,
+    0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x35, 0x32, 0x00, 0x46, 0x65, 0x62,
+    0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x31, 0x00, 0x57, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30,
+    0x00, 0x35, 0x33, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79,
+    0x00, 0x32, 0x32, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32,
+    0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x35, 0x34, 0x00, 0x46,
+    0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x33, 0x00, 0x57,
+    0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32,
+    0x00, 0x30, 0x00, 0x35, 0x35, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61,
+    0x72, 0x79, 0x00, 0x32, 0x34, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x35, 0x36,
+    0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x35,
+    0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00,
+    0x33, 0x32, 0x00, 0x30, 0x00, 0x35, 0x37, 0x00, 0x46, 0x65, 0x62, 0x72,
+    0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x36, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00,
+    0x35, 0x38, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00,
+    0x32, 0x37, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00,
+    0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x35, 0x39, 0x00, 0x46, 0x65,
+    0x62, 0x72, 0x75, 0x61, 0x72, 0x79, 0x00, 0x32, 0x38, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00,
+    0x30, 0x00, 0x36, 0x30, 0x00, 0x46, 0x65, 0x62, 0x72, 0x75, 0x61, 0x72,
+    0x79, 0x00, 0x32, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00,
+    0x32, 0x00, 0x31, 0x00, 0x33, 0x32, 0x00, 0x30, 0x00, 0x36, 0x31, 0x00,
+    0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x31, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x36, 0x32, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x32, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31,
+    0x00, 0x30, 0x00, 0x36, 0x33, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00,
+    0x33, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31,
+    0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x36, 0x34, 0x00, 0x4d, 0x61, 0x72,
+    0x63, 0x68, 0x00, 0x34, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00,
+    0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x36, 0x35, 0x00,
+    0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x35, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x36, 0x36, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x36, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31,
+    0x00, 0x30, 0x00, 0x36, 0x37, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00,
+    0x37, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31,
+    0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x36, 0x38, 0x00, 0x4d, 0x61, 0x72,
+    0x63, 0x68, 0x00, 0x38, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00,
+    0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x36, 0x39, 0x00,
+    0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x39, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x37, 0x30, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x31, 0x30, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36,
+    0x31, 0x00, 0x30, 0x00, 0x37, 0x31, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68,
+    0x00, 0x31, 0x31, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33,
+    0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x37, 0x32, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x68, 0x00, 0x31, 0x32, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x37, 0x33, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x31, 0x33, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36,
+    0x31, 0x00, 0x30, 0x00, 0x37, 0x34, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68,
+    0x00, 0x31, 0x34, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33,
+    0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x37, 0x35, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x68, 0x00, 0x31, 0x35, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x37, 0x36, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x31, 0x36, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36,
+    0x31, 0x00, 0x30, 0x00, 0x37, 0x37, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68,
+    0x00, 0x31, 0x37, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33,
+    0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x37, 0x38, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x68, 0x00, 0x31, 0x38, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x37, 0x39, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x31, 0x39, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36,
+    0x31, 0x00, 0x30, 0x00, 0x38, 0x30, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68,
+    0x00, 0x32, 0x30, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33,
+    0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x38, 0x31, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x68, 0x00, 0x32, 0x31, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x38, 0x32, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x32, 0x32, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36,
+    0x31, 0x00, 0x30, 0x00, 0x38, 0x33, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68,
+    0x00, 0x32, 0x33, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33,
+    0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x38, 0x34, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x68, 0x00, 0x32, 0x34, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x38, 0x35, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x32, 0x35, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36,
+    0x31, 0x00, 0x30, 0x00, 0x38, 0x36, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68,
+    0x00, 0x32, 0x36, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33,
+    0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x38, 0x37, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x68, 0x00, 0x32, 0x37, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x38, 0x38, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x32, 0x38, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36,
+    0x31, 0x00, 0x30, 0x00, 0x38, 0x39, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68,
+    0x00, 0x32, 0x39, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33,
+    0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00, 0x39, 0x30, 0x00, 0x4d,
+    0x61, 0x72, 0x63, 0x68, 0x00, 0x33, 0x30, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36, 0x31, 0x00, 0x30, 0x00,
+    0x39, 0x31, 0x00, 0x4d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x33, 0x31, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x33, 0x00, 0x31, 0x00, 0x36,
+    0x31, 0x00, 0x30, 0x00, 0x39, 0x32, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c,
+    0x00, 0x31, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00,
+    0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x39, 0x33, 0x00, 0x41, 0x70,
+    0x72, 0x69, 0x6c, 0x00, 0x32, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67,
+    0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x39, 0x34,
+    0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x33, 0x00, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30,
+    0x00, 0x39, 0x35, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x34, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39,
+    0x32, 0x00, 0x30, 0x00, 0x39, 0x36, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c,
+    0x00, 0x35, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00,
+    0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x39, 0x37, 0x00, 0x41, 0x70,
+    0x72, 0x69, 0x6c, 0x00, 0x36, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67,
+    0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x39, 0x38,
+    0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x37, 0x00, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30,
+    0x00, 0x39, 0x39, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x38, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x30, 0x30, 0x00, 0x41, 0x70, 0x72, 0x69,
+    0x6c, 0x00, 0x39, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34,
+    0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x30, 0x31, 0x00,
+    0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30,
+    0x00, 0x31, 0x30, 0x32, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x31,
+    0x31, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32,
+    0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x30, 0x33, 0x00, 0x41, 0x70,
+    0x72, 0x69, 0x6c, 0x00, 0x31, 0x32, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31,
+    0x30, 0x34, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x31, 0x33, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x30, 0x35, 0x00, 0x41, 0x70, 0x72, 0x69,
+    0x6c, 0x00, 0x31, 0x34, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00,
+    0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x30, 0x36,
+    0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x31, 0x35, 0x00, 0x53, 0x70,
+    0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00,
+    0x30, 0x00, 0x31, 0x30, 0x37, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00,
+    0x31, 0x36, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00,
+    0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x30, 0x38, 0x00, 0x41,
+    0x70, 0x72, 0x69, 0x6c, 0x00, 0x31, 0x37, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x30, 0x39, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x31, 0x38,
+    0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00,
+    0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x31, 0x30, 0x00, 0x41, 0x70, 0x72,
+    0x69, 0x6c, 0x00, 0x31, 0x39, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67,
+    0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x31,
+    0x31, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x32, 0x30, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32,
+    0x00, 0x30, 0x00, 0x31, 0x31, 0x32, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c,
+    0x00, 0x32, 0x31, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34,
+    0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x31, 0x33, 0x00,
+    0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x32, 0x32, 0x00, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30,
+    0x00, 0x31, 0x31, 0x34, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x32,
+    0x33, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32,
+    0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x31, 0x35, 0x00, 0x41, 0x70,
+    0x72, 0x69, 0x6c, 0x00, 0x32, 0x34, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31,
+    0x31, 0x36, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x32, 0x35, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x31, 0x37, 0x00, 0x41, 0x70, 0x72, 0x69,
+    0x6c, 0x00, 0x32, 0x36, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00,
+    0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x31, 0x38,
+    0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x32, 0x37, 0x00, 0x53, 0x70,
+    0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00,
+    0x30, 0x00, 0x31, 0x31, 0x39, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00,
+    0x32, 0x38, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00,
+    0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x32, 0x30, 0x00, 0x41,
+    0x70, 0x72, 0x69, 0x6c, 0x00, 0x32, 0x39, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00, 0x39, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x32, 0x31, 0x00, 0x41, 0x70, 0x72, 0x69, 0x6c, 0x00, 0x33, 0x30,
+    0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x34, 0x00, 0x32, 0x00,
+    0x39, 0x32, 0x00, 0x30, 0x00, 0x31, 0x32, 0x32, 0x00, 0x4d, 0x61, 0x79,
+    0x00, 0x31, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x32, 0x33, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x32, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67,
+    0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31,
+    0x32, 0x34, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x33, 0x00, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00,
+    0x30, 0x00, 0x31, 0x32, 0x35, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x34, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31,
+    0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x32, 0x36, 0x00, 0x4d, 0x61, 0x79,
+    0x00, 0x35, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x32, 0x37, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x36, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67,
+    0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31,
+    0x32, 0x38, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x37, 0x00, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00,
+    0x30, 0x00, 0x31, 0x32, 0x39, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x38, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31,
+    0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x33, 0x30, 0x00, 0x4d, 0x61, 0x79,
+    0x00, 0x39, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x33, 0x31, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x31, 0x30, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x33, 0x32, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x31, 0x31, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x33, 0x33, 0x00, 0x4d, 0x61, 0x79, 0x00,
+    0x31, 0x32, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x33, 0x34, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x31, 0x33, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x33, 0x35, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x31, 0x34, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x33, 0x36, 0x00, 0x4d, 0x61, 0x79, 0x00,
+    0x31, 0x35, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x33, 0x37, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x31, 0x36, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x33, 0x38, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x31, 0x37, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x33, 0x39, 0x00, 0x4d, 0x61, 0x79, 0x00,
+    0x31, 0x38, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x34, 0x30, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x31, 0x39, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x34, 0x31, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x32, 0x30, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x34, 0x32, 0x00, 0x4d, 0x61, 0x79, 0x00,
+    0x32, 0x31, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x34, 0x33, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x32, 0x32, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x34, 0x34, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x32, 0x33, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x34, 0x35, 0x00, 0x4d, 0x61, 0x79, 0x00,
+    0x32, 0x34, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x34, 0x36, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x32, 0x35, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x34, 0x37, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x32, 0x36, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x34, 0x38, 0x00, 0x4d, 0x61, 0x79, 0x00,
+    0x32, 0x37, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x34, 0x39, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x32, 0x38, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x35, 0x30, 0x00, 0x4d, 0x61, 0x79, 0x00, 0x32, 0x39, 0x00, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32,
+    0x32, 0x00, 0x30, 0x00, 0x31, 0x35, 0x31, 0x00, 0x4d, 0x61, 0x79, 0x00,
+    0x33, 0x30, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x35, 0x00,
+    0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00, 0x31, 0x35, 0x32, 0x00,
+    0x4d, 0x61, 0x79, 0x00, 0x33, 0x31, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x35, 0x00, 0x32, 0x00, 0x31, 0x32, 0x32, 0x00, 0x30, 0x00,
+    0x31, 0x35, 0x33, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x31, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35,
+    0x33, 0x00, 0x30, 0x00, 0x31, 0x35, 0x34, 0x00, 0x4a, 0x75, 0x6e, 0x65,
+    0x00, 0x32, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00,
+    0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x35, 0x35, 0x00,
+    0x4a, 0x75, 0x6e, 0x65, 0x00, 0x33, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00,
+    0x31, 0x35, 0x36, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x34, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35,
+    0x33, 0x00, 0x30, 0x00, 0x31, 0x35, 0x37, 0x00, 0x4a, 0x75, 0x6e, 0x65,
+    0x00, 0x35, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00,
+    0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x35, 0x38, 0x00,
+    0x4a, 0x75, 0x6e, 0x65, 0x00, 0x36, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00,
+    0x31, 0x35, 0x39, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x37, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35,
+    0x33, 0x00, 0x30, 0x00, 0x31, 0x36, 0x30, 0x00, 0x4a, 0x75, 0x6e, 0x65,
+    0x00, 0x38, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00,
+    0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x36, 0x31, 0x00,
+    0x4a, 0x75, 0x6e, 0x65, 0x00, 0x39, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00,
+    0x31, 0x36, 0x32, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x31, 0x30, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31,
+    0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x36, 0x33, 0x00, 0x4a, 0x75, 0x6e,
+    0x65, 0x00, 0x31, 0x31, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00,
+    0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x36,
+    0x34, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x31, 0x32, 0x00, 0x53, 0x75,
+    0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33,
+    0x00, 0x30, 0x00, 0x31, 0x36, 0x35, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00,
+    0x31, 0x33, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00,
+    0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x36, 0x36, 0x00,
+    0x4a, 0x75, 0x6e, 0x65, 0x00, 0x31, 0x34, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30,
+    0x00, 0x31, 0x36, 0x37, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x31, 0x35,
+    0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00,
+    0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x36, 0x38, 0x00, 0x4a, 0x75,
+    0x6e, 0x65, 0x00, 0x31, 0x36, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31,
+    0x36, 0x39, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x31, 0x37, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35,
+    0x33, 0x00, 0x30, 0x00, 0x31, 0x37, 0x30, 0x00, 0x4a, 0x75, 0x6e, 0x65,
+    0x00, 0x31, 0x38, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36,
+    0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x37, 0x31,
+    0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x31, 0x39, 0x00, 0x53, 0x75, 0x6d,
+    0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00,
+    0x30, 0x00, 0x31, 0x37, 0x32, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x32,
+    0x30, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32,
+    0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x37, 0x33, 0x00, 0x4a,
+    0x75, 0x6e, 0x65, 0x00, 0x32, 0x31, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00,
+    0x31, 0x37, 0x34, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x32, 0x32, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31,
+    0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x37, 0x35, 0x00, 0x4a, 0x75, 0x6e,
+    0x65, 0x00, 0x32, 0x33, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00,
+    0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x37,
+    0x36, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x32, 0x34, 0x00, 0x53, 0x75,
+    0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33,
+    0x00, 0x30, 0x00, 0x31, 0x37, 0x37, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00,
+    0x32, 0x35, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00,
+    0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x37, 0x38, 0x00,
+    0x4a, 0x75, 0x6e, 0x65, 0x00, 0x32, 0x36, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30,
+    0x00, 0x31, 0x37, 0x39, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x32, 0x37,
+    0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00,
+    0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x38, 0x30, 0x00, 0x4a, 0x75,
+    0x6e, 0x65, 0x00, 0x32, 0x38, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31,
+    0x38, 0x31, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x00, 0x32, 0x39, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36, 0x00, 0x32, 0x00, 0x31, 0x35,
+    0x33, 0x00, 0x30, 0x00, 0x31, 0x38, 0x32, 0x00, 0x4a, 0x75, 0x6e, 0x65,
+    0x00, 0x33, 0x30, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x36,
+    0x00, 0x32, 0x00, 0x31, 0x35, 0x33, 0x00, 0x30, 0x00, 0x31, 0x38, 0x33,
+    0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x31, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30,
+    0x00, 0x31, 0x38, 0x34, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x32, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31,
+    0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x38, 0x35, 0x00, 0x4a, 0x75, 0x6c,
+    0x79, 0x00, 0x33, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37,
+    0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x38, 0x36,
+    0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x34, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x31,
+    0x00, 0x31, 0x38, 0x37, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x35, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31,
+    0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x38, 0x38, 0x00, 0x4a, 0x75, 0x6c,
+    0x79, 0x00, 0x36, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37,
+    0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x38, 0x39,
+    0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x37, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30,
+    0x00, 0x31, 0x39, 0x30, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x38, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31,
+    0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x39, 0x31, 0x00, 0x4a, 0x75, 0x6c,
+    0x79, 0x00, 0x39, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37,
+    0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x39, 0x32,
+    0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x31, 0x30, 0x00, 0x53, 0x75, 0x6d,
+    0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00,
+    0x30, 0x00, 0x31, 0x39, 0x33, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x31,
+    0x31, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33,
+    0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x39, 0x34, 0x00, 0x4a,
+    0x75, 0x6c, 0x79, 0x00, 0x31, 0x32, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00,
+    0x31, 0x39, 0x35, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x31, 0x33, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31,
+    0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x39, 0x36, 0x00, 0x4a, 0x75, 0x6c,
+    0x79, 0x00, 0x31, 0x34, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00,
+    0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x39,
+    0x37, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x31, 0x35, 0x00, 0x53, 0x75,
+    0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33,
+    0x00, 0x30, 0x00, 0x31, 0x39, 0x38, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00,
+    0x31, 0x36, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00,
+    0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x31, 0x39, 0x39, 0x00,
+    0x4a, 0x75, 0x6c, 0x79, 0x00, 0x31, 0x37, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30,
+    0x00, 0x32, 0x30, 0x30, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x31, 0x38,
+    0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00,
+    0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x32, 0x30, 0x31, 0x00, 0x4a, 0x75,
+    0x6c, 0x79, 0x00, 0x31, 0x39, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x32,
+    0x30, 0x32, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x32, 0x30, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38,
+    0x33, 0x00, 0x30, 0x00, 0x32, 0x30, 0x33, 0x00, 0x4a, 0x75, 0x6c, 0x79,
+    0x00, 0x32, 0x31, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37,
+    0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x32, 0x30, 0x34,
+    0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x32, 0x32, 0x00, 0x53, 0x75, 0x6d,
+    0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00,
+    0x30, 0x00, 0x32, 0x30, 0x35, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x32,
+    0x33, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33,
+    0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x32, 0x30, 0x36, 0x00, 0x4a,
+    0x75, 0x6c, 0x79, 0x00, 0x32, 0x34, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00,
+    0x32, 0x30, 0x37, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x32, 0x35, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31,
+    0x38, 0x33, 0x00, 0x30, 0x00, 0x32, 0x30, 0x38, 0x00, 0x4a, 0x75, 0x6c,
+    0x79, 0x00, 0x32, 0x36, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00,
+    0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x32, 0x30,
+    0x39, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x32, 0x37, 0x00, 0x53, 0x75,
+    0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33,
+    0x00, 0x30, 0x00, 0x32, 0x31, 0x30, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00,
+    0x32, 0x38, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00,
+    0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x32, 0x31, 0x31, 0x00,
+    0x4a, 0x75, 0x6c, 0x79, 0x00, 0x32, 0x39, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30,
+    0x00, 0x32, 0x31, 0x32, 0x00, 0x4a, 0x75, 0x6c, 0x79, 0x00, 0x33, 0x30,
+    0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x37, 0x00, 0x33, 0x00,
+    0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x32, 0x31, 0x33, 0x00, 0x4a, 0x75,
+    0x6c, 0x79, 0x00, 0x33, 0x31, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x37, 0x00, 0x33, 0x00, 0x31, 0x38, 0x33, 0x00, 0x30, 0x00, 0x32,
+    0x31, 0x34, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x31, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32,
+    0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x31, 0x35, 0x00, 0x41, 0x75, 0x67,
+    0x75, 0x73, 0x74, 0x00, 0x32, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32,
+    0x31, 0x36, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x33, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32,
+    0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x31, 0x37, 0x00, 0x41, 0x75, 0x67,
+    0x75, 0x73, 0x74, 0x00, 0x34, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32,
+    0x31, 0x38, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x35, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32,
+    0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x31, 0x39, 0x00, 0x41, 0x75, 0x67,
+    0x75, 0x73, 0x74, 0x00, 0x36, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32,
+    0x32, 0x30, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x37, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32,
+    0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x32, 0x31, 0x00, 0x41, 0x75, 0x67,
+    0x75, 0x73, 0x74, 0x00, 0x38, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32,
+    0x32, 0x32, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x39, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32,
+    0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x32, 0x33, 0x00, 0x41, 0x75, 0x67,
+    0x75, 0x73, 0x74, 0x00, 0x31, 0x30, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00,
+    0x32, 0x32, 0x34, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x31,
+    0x31, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33,
+    0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x32, 0x35, 0x00, 0x41,
+    0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x31, 0x32, 0x00, 0x53, 0x75, 0x6d,
+    0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00,
+    0x30, 0x00, 0x32, 0x32, 0x36, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74,
+    0x00, 0x31, 0x33, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38,
+    0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x32, 0x37,
+    0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x31, 0x34, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31,
+    0x34, 0x00, 0x30, 0x00, 0x32, 0x32, 0x38, 0x00, 0x41, 0x75, 0x67, 0x75,
+    0x73, 0x74, 0x00, 0x31, 0x35, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32,
+    0x32, 0x39, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x31, 0x36,
+    0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00,
+    0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x33, 0x30, 0x00, 0x41, 0x75,
+    0x67, 0x75, 0x73, 0x74, 0x00, 0x31, 0x37, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30,
+    0x00, 0x32, 0x33, 0x31, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00,
+    0x31, 0x38, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00,
+    0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x33, 0x32, 0x00,
+    0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x31, 0x39, 0x00, 0x53, 0x75,
+    0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34,
+    0x00, 0x30, 0x00, 0x32, 0x33, 0x33, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73,
+    0x74, 0x00, 0x32, 0x30, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00,
+    0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x33,
+    0x34, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x32, 0x31, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32,
+    0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x33, 0x35, 0x00, 0x41, 0x75, 0x67,
+    0x75, 0x73, 0x74, 0x00, 0x32, 0x32, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00,
+    0x32, 0x33, 0x36, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x32,
+    0x33, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33,
+    0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x33, 0x37, 0x00, 0x41,
+    0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x32, 0x34, 0x00, 0x53, 0x75, 0x6d,
+    0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00,
+    0x30, 0x00, 0x32, 0x33, 0x38, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74,
+    0x00, 0x32, 0x35, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38,
+    0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x33, 0x39,
+    0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x32, 0x36, 0x00, 0x53,
+    0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31,
+    0x34, 0x00, 0x30, 0x00, 0x32, 0x34, 0x30, 0x00, 0x41, 0x75, 0x67, 0x75,
+    0x73, 0x74, 0x00, 0x32, 0x37, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72,
+    0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32,
+    0x34, 0x31, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x32, 0x38,
+    0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00,
+    0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x34, 0x32, 0x00, 0x41, 0x75,
+    0x67, 0x75, 0x73, 0x74, 0x00, 0x32, 0x39, 0x00, 0x53, 0x75, 0x6d, 0x6d,
+    0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30,
+    0x00, 0x32, 0x34, 0x33, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00,
+    0x33, 0x30, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00,
+    0x33, 0x00, 0x32, 0x31, 0x34, 0x00, 0x30, 0x00, 0x32, 0x34, 0x34, 0x00,
+    0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x00, 0x33, 0x31, 0x00, 0x53, 0x75,
+    0x6d, 0x6d, 0x65, 0x72, 0x00, 0x38, 0x00, 0x33, 0x00, 0x32, 0x31, 0x34,
+    0x00, 0x30, 0x00, 0x32, 0x34, 0x35, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x34,
+    0x36, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x32, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32,
+    0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x34, 0x37, 0x00, 0x53, 0x65, 0x70,
+    0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x33, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00,
+    0x32, 0x34, 0x38, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x34, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33,
+    0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x34, 0x39, 0x00, 0x53,
+    0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x35, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x35, 0x30, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d,
+    0x62, 0x65, 0x72, 0x00, 0x36, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39,
+    0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x35, 0x31,
+    0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x37,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34,
+    0x35, 0x00, 0x30, 0x00, 0x32, 0x35, 0x32, 0x00, 0x53, 0x65, 0x70, 0x74,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x38, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32,
+    0x35, 0x33, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72,
+    0x00, 0x39, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x35, 0x34, 0x00, 0x53, 0x65,
+    0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x30, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x35, 0x35, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d,
+    0x62, 0x65, 0x72, 0x00, 0x31, 0x31, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x35,
+    0x36, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x31, 0x32, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x35, 0x37, 0x00, 0x53, 0x65,
+    0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x33, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x35, 0x38, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d,
+    0x62, 0x65, 0x72, 0x00, 0x31, 0x34, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x35,
+    0x39, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x31, 0x35, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x36, 0x30, 0x00, 0x53, 0x65,
+    0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x36, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x36, 0x31, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d,
+    0x62, 0x65, 0x72, 0x00, 0x31, 0x37, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x36,
+    0x32, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x31, 0x38, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x36, 0x33, 0x00, 0x53, 0x65,
+    0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x39, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x36, 0x34, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d,
+    0x62, 0x65, 0x72, 0x00, 0x32, 0x30, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x36,
+    0x35, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x32, 0x31, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x36, 0x36, 0x00, 0x53, 0x65,
+    0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x32, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x36, 0x37, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d,
+    0x62, 0x65, 0x72, 0x00, 0x32, 0x33, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x36,
+    0x38, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x32, 0x34, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x36, 0x39, 0x00, 0x53, 0x65,
+    0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x35, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x37, 0x30, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d,
+    0x62, 0x65, 0x72, 0x00, 0x32, 0x36, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x37,
+    0x31, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x32, 0x37, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x37, 0x32, 0x00, 0x53, 0x65,
+    0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x38, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x37, 0x33, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d,
+    0x62, 0x65, 0x72, 0x00, 0x32, 0x39, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x39, 0x00, 0x33, 0x00, 0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x37,
+    0x34, 0x00, 0x53, 0x65, 0x70, 0x74, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x33, 0x30, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x39, 0x00, 0x33, 0x00,
+    0x32, 0x34, 0x35, 0x00, 0x30, 0x00, 0x32, 0x37, 0x35, 0x00, 0x4f, 0x63,
+    0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x31, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00,
+    0x32, 0x37, 0x36, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00,
+    0x32, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00,
+    0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x37, 0x37, 0x00, 0x4f, 0x63,
+    0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x33, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00,
+    0x32, 0x37, 0x38, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00,
+    0x34, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00,
+    0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x37, 0x39, 0x00, 0x4f, 0x63,
+    0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x35, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00,
+    0x32, 0x38, 0x30, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00,
+    0x36, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00,
+    0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x38, 0x31, 0x00, 0x4f, 0x63,
+    0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x37, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00,
+    0x32, 0x38, 0x32, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00,
+    0x38, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00,
+    0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x38, 0x33, 0x00, 0x4f, 0x63,
+    0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x39, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00,
+    0x32, 0x38, 0x34, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00,
+    0x31, 0x30, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34,
+    0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x38, 0x35, 0x00, 0x4f,
+    0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x31, 0x31, 0x00, 0x46, 0x61,
+    0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x38, 0x36, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65,
+    0x72, 0x00, 0x31, 0x32, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30,
+    0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x38, 0x37,
+    0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x31, 0x33, 0x00,
+    0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37,
+    0x35, 0x00, 0x30, 0x00, 0x32, 0x38, 0x38, 0x00, 0x4f, 0x63, 0x74, 0x6f,
+    0x62, 0x65, 0x72, 0x00, 0x31, 0x34, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32,
+    0x38, 0x39, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x31,
+    0x35, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00,
+    0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x39, 0x30, 0x00, 0x4f, 0x63,
+    0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x31, 0x36, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30,
+    0x00, 0x32, 0x39, 0x31, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72,
+    0x00, 0x31, 0x37, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00,
+    0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x39, 0x32, 0x00,
+    0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x31, 0x38, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35,
+    0x00, 0x30, 0x00, 0x32, 0x39, 0x33, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62,
+    0x65, 0x72, 0x00, 0x31, 0x39, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31,
+    0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x39,
+    0x34, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x32, 0x30,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32,
+    0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x39, 0x35, 0x00, 0x4f, 0x63, 0x74,
+    0x6f, 0x62, 0x65, 0x72, 0x00, 0x32, 0x31, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00,
+    0x32, 0x39, 0x36, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00,
+    0x32, 0x32, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34,
+    0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x39, 0x37, 0x00, 0x4f,
+    0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x32, 0x33, 0x00, 0x46, 0x61,
+    0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00,
+    0x30, 0x00, 0x32, 0x39, 0x38, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65,
+    0x72, 0x00, 0x32, 0x34, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30,
+    0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x32, 0x39, 0x39,
+    0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x32, 0x35, 0x00,
+    0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37,
+    0x35, 0x00, 0x30, 0x00, 0x33, 0x30, 0x30, 0x00, 0x4f, 0x63, 0x74, 0x6f,
+    0x62, 0x65, 0x72, 0x00, 0x32, 0x36, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x33,
+    0x30, 0x31, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x32,
+    0x37, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00,
+    0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x33, 0x30, 0x32, 0x00, 0x4f, 0x63,
+    0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x32, 0x38, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30,
+    0x00, 0x33, 0x30, 0x33, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72,
+    0x00, 0x32, 0x39, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00,
+    0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x33, 0x30, 0x34, 0x00,
+    0x4f, 0x63, 0x74, 0x6f, 0x62, 0x65, 0x72, 0x00, 0x33, 0x30, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35,
+    0x00, 0x30, 0x00, 0x33, 0x30, 0x35, 0x00, 0x4f, 0x63, 0x74, 0x6f, 0x62,
+    0x65, 0x72, 0x00, 0x33, 0x31, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31,
+    0x30, 0x00, 0x34, 0x00, 0x32, 0x37, 0x35, 0x00, 0x30, 0x00, 0x33, 0x30,
+    0x36, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33,
+    0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x30, 0x37, 0x00, 0x4e, 0x6f, 0x76,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x00, 0x46, 0x61, 0x6c, 0x6c,
+    0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00,
+    0x33, 0x30, 0x38, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72,
+    0x00, 0x33, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34,
+    0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x30, 0x39, 0x00, 0x4e,
+    0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x34, 0x00, 0x46, 0x61,
+    0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00,
+    0x30, 0x00, 0x33, 0x31, 0x30, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62,
+    0x65, 0x72, 0x00, 0x35, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31,
+    0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x31, 0x31,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x36, 0x00,
+    0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30,
+    0x36, 0x00, 0x30, 0x00, 0x33, 0x31, 0x32, 0x00, 0x4e, 0x6f, 0x76, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x37, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00,
+    0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33,
+    0x31, 0x33, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00,
+    0x38, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00,
+    0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x31, 0x34, 0x00, 0x4e, 0x6f,
+    0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x39, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x31, 0x35, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x31, 0x30, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31,
+    0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x31, 0x36,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x31,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33,
+    0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x31, 0x37, 0x00, 0x4e, 0x6f, 0x76,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x31, 0x38, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x31, 0x33, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31,
+    0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x31, 0x39,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x34,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33,
+    0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x32, 0x30, 0x00, 0x4e, 0x6f, 0x76,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x35, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x32, 0x31, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x31, 0x36, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31,
+    0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x32, 0x32,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x37,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33,
+    0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x32, 0x33, 0x00, 0x4e, 0x6f, 0x76,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x38, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x32, 0x34, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x31, 0x39, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31,
+    0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x32, 0x35,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x30,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33,
+    0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x32, 0x36, 0x00, 0x4e, 0x6f, 0x76,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x31, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x32, 0x37, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x32, 0x32, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31,
+    0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x32, 0x38,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x33,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33,
+    0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x32, 0x39, 0x00, 0x4e, 0x6f, 0x76,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x34, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x33, 0x30, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x32, 0x35, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31,
+    0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x33, 0x31,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x36,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33,
+    0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x33, 0x32, 0x00, 0x4e, 0x6f, 0x76,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x37, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x33, 0x33, 0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x32, 0x38, 0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31,
+    0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x33, 0x34,
+    0x00, 0x4e, 0x6f, 0x76, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x39,
+    0x00, 0x46, 0x61, 0x6c, 0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33,
+    0x30, 0x36, 0x00, 0x30, 0x00, 0x33, 0x33, 0x35, 0x00, 0x4e, 0x6f, 0x76,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x33, 0x30, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x31, 0x00, 0x34, 0x00, 0x33, 0x30, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x33, 0x36, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x31, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31,
+    0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x33,
+    0x37, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32,
+    0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34,
+    0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x33, 0x38, 0x00, 0x44,
+    0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x33, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33,
+    0x36, 0x00, 0x30, 0x00, 0x33, 0x33, 0x39, 0x00, 0x44, 0x65, 0x63, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x34, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x34, 0x30, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x35, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31,
+    0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x34,
+    0x31, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x36,
+    0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34,
+    0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x34, 0x32, 0x00, 0x44,
+    0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x37, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33,
+    0x36, 0x00, 0x30, 0x00, 0x33, 0x34, 0x33, 0x00, 0x44, 0x65, 0x63, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x38, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30,
+    0x00, 0x33, 0x34, 0x34, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65,
+    0x72, 0x00, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31,
+    0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x34,
+    0x35, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31,
+    0x30, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00,
+    0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x34, 0x36, 0x00,
+    0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x31, 0x00,
+    0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00,
+    0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x34, 0x37, 0x00, 0x44, 0x65,
+    0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33,
+    0x36, 0x00, 0x30, 0x00, 0x33, 0x34, 0x38, 0x00, 0x44, 0x65, 0x63, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x33, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00,
+    0x30, 0x00, 0x33, 0x34, 0x39, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62,
+    0x65, 0x72, 0x00, 0x31, 0x34, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00,
+    0x33, 0x35, 0x30, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72,
+    0x00, 0x31, 0x35, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31,
+    0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x35,
+    0x31, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31,
+    0x36, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00,
+    0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x35, 0x32, 0x00,
+    0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x37, 0x00,
+    0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00,
+    0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x35, 0x33, 0x00, 0x44, 0x65,
+    0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x38, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33,
+    0x36, 0x00, 0x30, 0x00, 0x33, 0x35, 0x34, 0x00, 0x44, 0x65, 0x63, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x31, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00,
+    0x30, 0x00, 0x33, 0x35, 0x35, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62,
+    0x65, 0x72, 0x00, 0x32, 0x30, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00,
+    0x33, 0x35, 0x36, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72,
+    0x00, 0x32, 0x31, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31,
+    0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x35,
+    0x37, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32,
+    0x32, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00,
+    0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x35, 0x38, 0x00,
+    0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x33, 0x00,
+    0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00,
+    0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x35, 0x39, 0x00, 0x44, 0x65,
+    0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x34, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33,
+    0x36, 0x00, 0x30, 0x00, 0x33, 0x36, 0x30, 0x00, 0x44, 0x65, 0x63, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x35, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00,
+    0x31, 0x00, 0x33, 0x36, 0x31, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62,
+    0x65, 0x72, 0x00, 0x32, 0x36, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00,
+    0x33, 0x36, 0x32, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72,
+    0x00, 0x32, 0x37, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31,
+    0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x36,
+    0x33, 0x00, 0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32,
+    0x38, 0x00, 0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00,
+    0x34, 0x00, 0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x36, 0x34, 0x00,
+    0x44, 0x65, 0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x32, 0x39, 0x00,
+    0x57, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00,
+    0x33, 0x33, 0x36, 0x00, 0x30, 0x00, 0x33, 0x36, 0x35, 0x00, 0x44, 0x65,
+    0x63, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x33, 0x30, 0x00, 0x57, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33,
+    0x36, 0x00, 0x30, 0x00, 0x33, 0x36, 0x36, 0x00, 0x44, 0x65, 0x63, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x33, 0x31, 0x00, 0x57, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x31, 0x32, 0x00, 0x34, 0x00, 0x33, 0x33, 0x36, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x0b, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00,
+    0x00, 0x30, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00,
+    0x00, 0x2c, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00,
+    0x00, 0x51, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+    0x00, 0x20, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00,
+    0x00, 0x46, 0x00, 0x00, 0x00, 0x53, 0x53, 0x75, 0x6e, 0x64, 0x61, 0x79,
+    0x00, 0x30, 0x00, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x64, 0x61, 0x79, 0x00,
+    0x31, 0x00, 0x30, 0x00, 0x54, 0x75, 0x65, 0x73, 0x64, 0x61, 0x79, 0x00,
+    0x31, 0x00, 0x30, 0x00, 0x57, 0x65, 0x64, 0x6e, 0x65, 0x73, 0x64, 0x61,
+    0x79, 0x00, 0x31, 0x00, 0x30, 0x00, 0x54, 0x68, 0x75, 0x72, 0x73, 0x64,
+    0x61, 0x79, 0x00, 0x31, 0x00, 0x30, 0x00, 0x46, 0x72, 0x69, 0x64, 0x61,
+    0x79, 0x00, 0x31, 0x00, 0x30, 0x00, 0x53, 0x61, 0x74, 0x75, 0x72, 0x64,
+    0x61, 0x79, 0x00, 0x30, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0xcb, 0x41, 0x00,
+    0x00, 0x08, 0x80, 0x00, 0x01, 0x15, 0x73, 0x00, 0x00, 0x57, 0x7a, 0x00,
+    0x01, 0xf1, 0x6e, 0x00, 0x00, 0x56, 0x93, 0x00, 0x00, 0x1e, 0xa2, 0x00,
+    0x00, 0x9d, 0x98, 0x00, 0x00, 0x19, 0xf0, 0x00, 0x00, 0x7b, 0x77, 0x00,
+    0x00, 0x71, 0x44, 0x00, 0x00, 0x89, 0xe7, 0x00, 0x03, 0xbf, 0x4b, 0x00,
+    0x12, 0x3e, 0x4f, 0x00, 0x00, 0x7b, 0xe2, 0x00, 0x06, 0x18, 0x45, 0x00,
+    0x00, 0x2c, 0x9a, 0x00, 0x00, 0x33, 0x59, 0x00, 0x00, 0xb1, 0x84, 0x00,
+    0x00, 0x34, 0xfa, 0x00, 0x00, 0x7c, 0x34, 0x00, 0x01, 0x34, 0xda, 0x00,
+    0x00, 0x76, 0x02, 0x00, 0x01, 0xb8, 0xfb, 0x00, 0x00, 0x58, 0x8a, 0x00,
+    0x00, 0xbc, 0x03, 0x00, 0x00, 0x42, 0xc9, 0x00, 0x00, 0x52, 0x38, 0x00,
+    0x01, 0xe4, 0x98, 0x00, 0x00, 0x2b, 0x11, 0x00, 0x00, 0x19, 0x1e, 0x00,
+    0x00, 0x19, 0xb4, 0x00, 0x00, 0x81, 0x3b, 0x00, 0x00, 0x0d, 0x97, 0x00,
+    0x0e, 0x02, 0xb8, 0x00, 0x00, 0x48, 0x9b, 0x00, 0x00, 0x01, 0xac, 0x00,
+    0x03, 0x34, 0xb5, 0x00, 0x01, 0x4b, 0xa9, 0x00, 0x00, 0x2b, 0x8a, 0x00,
+    0x00, 0x17, 0x79, 0x00, 0x00, 0x42, 0x27, 0x00, 0x00, 0x35, 0x1b, 0x00,
+    0x00, 0x32, 0x60, 0x00, 0x00, 0xfd, 0x90, 0x00, 0x00, 0x90, 0xe1, 0x00,
+    0x00, 0x27, 0x28, 0x00, 0x00, 0x3a, 0xd2, 0x00, 0x02, 0x09, 0x1f, 0x00,
+    0x00, 0x30, 0x46, 0x00, 0x00, 0x1f, 0x85, 0x00, 0x00, 0xdb, 0xe6, 0x00,
+    0x00, 0x3e, 0x05, 0x00, 0x00, 0x4b, 0xee, 0x00, 0x00, 0x34, 0x86, 0x00,
+    0x0b, 0x03, 0xd2, 0x00, 0x00, 0x7c, 0xe0, 0x00, 0x00, 0x10, 0x6b, 0x00,
+    0x00, 0xdc, 0x71, 0x00, 0x00, 0x60, 0x38, 0x00, 0x00, 0x19, 0x47, 0x00,
+    0x00, 0x2f, 0x0b, 0x00, 0x00, 0x27, 0x6c, 0x00, 0x00, 0xd3, 0x39, 0x00,
+    0x00, 0x5c, 0xbf, 0x00, 0x00, 0xdb, 0x1b, 0x00, 0x00, 0x2a, 0x56, 0x00,
+    0x00, 0x19, 0x09, 0x00, 0x01, 0x27, 0x92, 0x00, 0x00, 0x20, 0x3b, 0x00,
+    0x00, 0xad, 0xd7, 0x00, 0x00, 0x14, 0x6a, 0x00, 0x00, 0xf6, 0xd1, 0x00,
+    0x00, 0x5e, 0xe8, 0x00, 0x00, 0xb9, 0x53, 0x00, 0x00, 0x25, 0x7f, 0x00,
+    0x00, 0x03, 0x83, 0x00, 0x00, 0x1f, 0x4c, 0x00, 0x00, 0xd9, 0x4b, 0x00,
+    0x00, 0x26, 0xf1, 0x00, 0x00, 0x15, 0x05, 0x00, 0x00, 0x7f, 0xaa, 0x00,
+    0x00, 0x45, 0xe3, 0x00, 0x00, 0x17, 0xbc, 0x00, 0x01, 0x90, 0xa5, 0x00,
+    0x00, 0x3d, 0xc5, 0x00, 0x00, 0x05, 0x7a, 0x00, 0x00, 0x72, 0xc6, 0x00,
+    0x00, 0x52, 0x50, 0x00, 0x00, 0x4a, 0xae, 0x00, 0x00, 0x36, 0x98, 0x00,
+    0x00, 0x82, 0xeb, 0x00, 0x00, 0x75, 0xae, 0x00, 0x03, 0xc5, 0x68, 0x00,
+    0x00, 0x1d, 0x06, 0x00, 0x00, 0x32, 0x20, 0x00, 0x00, 0x38, 0x70, 0x00,
+    0x00, 0xf9, 0x32, 0x00, 0x00, 0x39, 0x36, 0x00, 0x00, 0x38, 0xed, 0x00,
+    0x02, 0x39, 0x3e, 0x00, 0x00, 0x07, 0xb2, 0x00, 0x01, 0x57, 0x39, 0x00,
+    0x00, 0x40, 0xab, 0x00, 0x00, 0x31, 0x57, 0x00, 0x00, 0x67, 0xfb, 0x00,
+    0x00, 0xff, 0xdc, 0x00, 0x00, 0x68, 0xe0, 0x00, 0x00, 0x9e, 0x9e, 0x00,
+    0x02, 0x02, 0xf7, 0x00, 0x00, 0x85, 0xf2, 0x00, 0x00, 0x9f, 0x26, 0x00,
+    0x00, 0x0d, 0x55, 0x00, 0x00, 0x2f, 0xef, 0x00, 0x00, 0x07, 0x7d, 0x00,
+    0x00, 0x0f, 0x69, 0x00, 0x01, 0x54, 0x0f, 0x00, 0x00, 0x52, 0x61, 0x00,
+    0x04, 0x0c, 0x65, 0x00, 0x00, 0x0d, 0xe1, 0x00, 0x01, 0x77, 0x14, 0x00,
+    0x00, 0xf3, 0x08, 0x00, 0x01, 0x50, 0x72, 0x00, 0x00, 0x11, 0xb6, 0x00,
+    0x00, 0x33, 0x4e, 0x00, 0x00, 0x1a, 0xd0, 0x00, 0x09, 0x3b, 0xbc, 0x00,
+    0x00, 0xca, 0x69, 0x00, 0x00, 0x76, 0xd8, 0x00, 0x00, 0x66, 0x78, 0x00,
+    0x00, 0xcd, 0x01, 0x00, 0x00, 0xab, 0x37, 0x00, 0x01, 0x8c, 0x0e, 0x00,
+    0x00, 0x5f, 0x80, 0x00, 0x01, 0x0d, 0x3a, 0x00, 0x02, 0x3a, 0x71, 0x00,
+    0x0a, 0xfb, 0x66, 0x00, 0x00, 0x5a, 0x13, 0x00, 0x00, 0x54, 0x0c, 0x00,
+    0x00, 0x12, 0x00, 0x00, 0x00, 0x1c, 0x23, 0x00, 0x01, 0x9d, 0x50, 0x00,
+    0x03, 0x30, 0x67, 0x00, 0x00, 0x11, 0xfd, 0x00, 0x00, 0x82, 0x05, 0x00,
+    0x01, 0xf1, 0x78, 0x00, 0x00, 0x1e, 0x10, 0x00, 0x02, 0x33, 0xd3, 0x00,
+    0x02, 0x06, 0xdc, 0x00, 0x00, 0x93, 0xd7, 0x00, 0x00, 0x24, 0xcc, 0x00,
+    0x00, 0x10, 0x5c, 0x00, 0x00, 0x26, 0xba, 0x00, 0x00, 0x36, 0x87, 0x00,
+    0x00, 0xec, 0x8f, 0x00, 0x07, 0x22, 0x84, 0x00, 0x01, 0xfe, 0x3a, 0x00,
+    0x00, 0x7c, 0xb6, 0x00, 0x00, 0x51, 0xda, 0x00, 0x00, 0xae, 0xc7, 0x00,
+    0x00, 0x0d, 0xfc, 0x00, 0x00, 0x10, 0xae, 0x00, 0x00, 0x2b, 0x74, 0x00,
+    0x00, 0x18, 0x22, 0x00, 0x00, 0x41, 0x27, 0x00, 0x00, 0x27, 0x98, 0x00,
+    0x00, 0x29, 0x97, 0x00, 0x00, 0x3f, 0xab, 0x00, 0x01, 0xea, 0x41, 0x00,
+    0x05, 0x0f, 0x6d, 0x00, 0x00, 0x50, 0x49, 0x00, 0x00, 0x97, 0x64, 0x00,
+    0x00, 0x0a, 0xef, 0x00, 0x00, 0x3a, 0xa3, 0x00, 0x02, 0xf9, 0x39, 0x00,
+    0x00, 0x2f, 0x58, 0x00, 0x02, 0xff, 0xc1, 0x00, 0x02, 0x3d, 0xf1, 0x00,
+    0x01, 0x11, 0xb4, 0x00, 0x06, 0xe7, 0xe8, 0x00, 0x01, 0xd9, 0xc9, 0x00,
+    0x00, 0x2c, 0xf9, 0x00, 0x00, 0x28, 0x53, 0x00, 0x00, 0x1f, 0x7c, 0x00,
+    0x01, 0xad, 0xc1, 0x00, 0x00, 0xc2, 0xf1, 0x00, 0x00, 0x60, 0xc0, 0x00,
+    0x00, 0x08, 0xb1, 0x00, 0x00, 0x62, 0xfa, 0x00, 0x00, 0x4c, 0xbd, 0x00,
+    0x02, 0x61, 0xb0, 0x00, 0x00, 0x18, 0xf3, 0x00, 0x00, 0x43, 0xbd, 0x00,
+    0x00, 0x5b, 0x8f, 0x00, 0x07, 0x1a, 0x82, 0x00, 0x00, 0x30, 0x2f, 0x00,
+    0x01, 0x37, 0x37, 0x00, 0x01, 0x56, 0xfe, 0x00, 0x00, 0x21, 0x19, 0x00,
+    0x00, 0x75, 0x5a, 0x00, 0x00, 0x12, 0x97, 0x00, 0x00, 0x8f, 0xf4, 0x00,
+    0x02, 0x26, 0xcd, 0x00, 0x01, 0x29, 0x40, 0x00, 0x00, 0x06, 0xa3, 0x00,
+    0x00, 0x62, 0x55, 0x00, 0x00, 0x2a, 0xeb, 0x00, 0x00, 0x40, 0x1d, 0x00,
+    0x0b, 0x48, 0x27, 0x00, 0x00, 0x55, 0xd4, 0x00, 0x00, 0x4a, 0x7e, 0x00,
+    0x00, 0x1c, 0xc6, 0x00, 0x02, 0x32, 0x93, 0x00, 0x01, 0x31, 0xc7, 0x00,
+    0x00, 0x33, 0xe3, 0x00, 0x02, 0x1e, 0xfd, 0x00, 0x00, 0xf3, 0x39, 0x00,
+    0x00, 0x2e, 0x14, 0x00, 0x00, 0x8d, 0xd4, 0x00, 0x00, 0x66, 0x79, 0x00,
+    0x00, 0x7a, 0x7d, 0x00, 0x00, 0x13, 0x9a, 0x00, 0x00, 0x13, 0x8a, 0x00,
+    0x00, 0x13, 0xee, 0x00, 0x00, 0x07, 0x0a, 0x00, 0x00, 0xc3, 0x6a, 0x00,
+    0x00, 0x8e, 0xcc, 0x00, 0x00, 0x24, 0xe4, 0x00, 0x00, 0x51, 0x42, 0x00,
+    0x00, 0xbe, 0xe8, 0x00, 0x00, 0x3f, 0x72, 0x00, 0x06, 0x81, 0xdc, 0x00,
+    0x00, 0x7e, 0x28, 0x00, 0x00, 0x3f, 0x38, 0x00, 0x01, 0x39, 0xda, 0x00,
+    0x09, 0xca, 0xb3, 0x00, 0x00, 0x23, 0xc8, 0x00, 0x00, 0x1e, 0xab, 0x00,
+    0x07, 0xfb, 0x74, 0x00, 0x00, 0x58, 0x18, 0x00, 0x01, 0x52, 0xf0, 0x00,
+    0x00, 0x11, 0x9e, 0x00, 0x00, 0x1d, 0x76, 0x00, 0x01, 0xfe, 0x37, 0x00,
+    0x01, 0x43, 0xb4, 0x00, 0x00, 0x4f, 0x7d, 0x00, 0x00, 0xa8, 0xda, 0x00,
+    0x00, 0x5c, 0xba, 0x00, 0x00, 0x8d, 0xf1, 0x00, 0x00, 0x26, 0x72, 0x00,
+    0x00, 0x15, 0xce, 0x00, 0x00, 0x8b, 0xda, 0x00, 0x00, 0x4a, 0xa6, 0x00,
+    0x00, 0x5c, 0xd3, 0x00, 0x02, 0x49, 0x3a, 0x00, 0x00, 0x9c, 0xbe, 0x00,
+    0x00, 0x9a, 0x56, 0x00, 0x00, 0x1b, 0xf0, 0x00, 0x00, 0x08, 0xc2, 0x00,
+    0x00, 0x1c, 0x3a, 0x00, 0x06, 0xfe, 0x3d, 0x00, 0x00, 0x06, 0x61, 0x00,
+    0x00, 0xa0, 0x7e, 0x00, 0x00, 0x3b, 0xdc, 0x00, 0x00, 0x40, 0x10, 0x00,
+    0x00, 0x66, 0xc5, 0x00, 0x00, 0x18, 0x9c, 0x00, 0x00, 0x35, 0x0e, 0x00,
+    0x00, 0xd4, 0xd5, 0x00, 0x00, 0x6c, 0x05, 0x00, 0x00, 0x0d, 0x72, 0x00,
+    0x00, 0x2f, 0x62, 0x00, 0x00, 0x6c, 0x7f, 0x00, 0x00, 0x72, 0xc5, 0x00,
+    0x00, 0x1d, 0x0d, 0x00, 0x00, 0x3c, 0x07, 0x00, 0x00, 0x6f, 0x53, 0x00,
+    0x01, 0xa0, 0x56, 0x00, 0x00, 0x39, 0x72, 0x00, 0x00, 0x33, 0xc9, 0x00,
+    0x01, 0x48, 0xec, 0x00, 0x00, 0x87, 0x32, 0x00, 0x00, 0x16, 0x0c, 0x00,
+    0x01, 0x5b, 0x9d, 0x00, 0x02, 0x5a, 0xc9, 0x00, 0x00, 0xc9, 0xa1, 0x00,
+    0x00, 0x55, 0xe5, 0x00, 0x00, 0xfe, 0x36, 0x00, 0x00, 0x5e, 0x8e, 0x00,
+    0x02, 0x9b, 0x21, 0x00, 0x00, 0x16, 0xbd, 0x00, 0x00, 0x3e, 0xe1, 0x00,
+    0x0a, 0xd7, 0xe2, 0x00, 0x00, 0x04, 0x9d, 0x00, 0x00, 0x95, 0x4f, 0x00,
+    0x00, 0x43, 0xdd, 0x00, 0x00, 0x39, 0xe0, 0x00, 0x00, 0x79, 0xc5, 0x00,
+    0x00, 0xd8, 0xe6, 0x00, 0x00, 0x8b, 0x87, 0x00, 0x00, 0xa7, 0xf1, 0x00,
+    0x00, 0xcc, 0x9c, 0x00, 0x00, 0x63, 0x1a, 0x00, 0x01, 0x0d, 0xf7, 0x00,
+    0x00, 0x3e, 0x4f, 0x00, 0x00, 0x11, 0xec, 0x00, 0x00, 0xa2, 0x86, 0x00,
+    0x00, 0x23, 0x3d, 0x00, 0x06, 0xf6, 0xde, 0x00, 0x00, 0x3c, 0xa7, 0x00,
+    0x07, 0x4c, 0x73, 0x00, 0x00, 0xd8, 0x35, 0x00, 0x00, 0x74, 0x1f, 0x00,
+    0x00, 0x20, 0x75, 0x00, 0x00, 0x27, 0x62, 0x00, 0x01, 0x13, 0xc5, 0x00,
+    0x01, 0xd7, 0xd1, 0x00, 0x03, 0x2e, 0xfa, 0x00, 0x01, 0xff, 0x5e, 0x00,
+    0x00, 0x83, 0x6f, 0x00, 0x00, 0x25, 0x59, 0x00, 0x03, 0xc1, 0x24, 0x00,
+    0x00, 0x25, 0xe4, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0x60, 0xae, 0x00,
+    0x00, 0x07, 0xd1, 0x00, 0x00, 0x9b, 0x90, 0x00, 0x00, 0x03, 0x1f, 0x00,
+    0x01, 0x6d, 0x17, 0x00, 0x00, 0x79, 0x35, 0x00, 0x0d, 0x66, 0x97, 0x00,
+    0x01, 0x3d, 0x70, 0x00, 0x00, 0xfa, 0x3b, 0x00, 0x00, 0x25, 0xad, 0x00,
+    0x00, 0x60, 0x18, 0x00, 0x00, 0x67, 0x90, 0x00, 0x01, 0x29, 0x35, 0x00,
+    0x01, 0x16, 0xe1, 0x00, 0x02, 0x0d, 0x62, 0x00, 0x00, 0x34, 0x9c, 0x00,
+    0x00, 0x20, 0xdd, 0x00, 0x00, 0xb0, 0xf8, 0x00, 0x00, 0x06, 0x5d, 0x00,
+    0x00, 0x1a, 0x92, 0x00, 0x00, 0x1c, 0x0d, 0x00, 0x01, 0x82, 0x78, 0x00,
+    0x00, 0x5d, 0x14, 0x00, 0x01, 0x7a, 0xd7, 0x00, 0x0e, 0x42, 0x47, 0x00,
+    0x00, 0x1b, 0x80, 0x00, 0x00, 0x18, 0x85, 0x00, 0x00, 0x31, 0x0a, 0x00,
+    0x01, 0x2c, 0xb0, 0x00, 0x00, 0x14, 0xd7, 0x00, 0x00, 0x74, 0x41, 0x00,
+    0x00, 0x06, 0x01, 0x00, 0x00, 0x1e, 0xb0, 0x00, 0x11, 0xbb, 0x91, 0x00,
+    0x0b, 0x61, 0x2e, 0x00, 0x00, 0x47, 0xac, 0x00, 0x00, 0x14, 0x4c, 0x00,
+    0x00, 0x8e, 0xb5, 0x00, 0x00, 0x48, 0xd0, 0x00, 0x00, 0x0e, 0x96, 0x00,
+    0x01, 0x3e, 0x94, 0x00, 0x00, 0x8b, 0x16, 0x00, 0x00, 0xfa, 0xa9, 0x00,
+    0x00, 0xf1, 0x4f, 0x00, 0x00, 0x46, 0xcd, 0x00, 0x00, 0x42, 0x0c, 0x00,
+    0x05, 0x7d, 0x92, 0x00, 0x00, 0x1a, 0x80, 0x00, 0x00, 0xb3, 0x6e, 0x00,
+    0x00, 0x3d, 0x46, 0x00, 0x00, 0x3d, 0x1e, 0x00, 0x00, 0x05, 0xff, 0x00,
+    0x01, 0x42, 0x5a, 0x00, 0x00, 0x51, 0xc2, 0x00, 0x00, 0x27, 0x7e, 0x00,
+    0x01, 0x85, 0x50, 0x00, 0x00, 0x68, 0x0d, 0x00, 0x00, 0x0e, 0xdc, 0x00,
+    0x00, 0x77, 0xdd, 0x00, 0x00, 0xda, 0x40, 0x00, 0x00, 0x05, 0xc4, 0x00,
+    0x01, 0xbc, 0xf2, 0x00, 0x00, 0x3f, 0xe1, 0x00, 0x00, 0x68, 0xda, 0x00,
+    0x00, 0x2e, 0xb6, 0x00, 0x00, 0x5e, 0xf8, 0x00, 0x00, 0x2a, 0x95, 0x00,
+    0x00, 0x66, 0xbe, 0x00, 0x08, 0x25, 0xcf, 0x00, 0x01, 0x45, 0xfc, 0x00,
+    0x02, 0x6b, 0x26, 0x00, 0x00, 0x45, 0x77, 0x00, 0x05, 0x5a, 0x8b, 0x00,
+    0x00, 0x0f, 0xd3, 0x00, 0x00, 0x28, 0xeb, 0x00, 0x00, 0xff, 0xd7, 0x00,
+    0x00, 0x1b, 0x4a, 0x00, 0x00, 0xeb, 0xe7, 0x00, 0x00, 0x44, 0x97, 0x00,
+    0x00, 0xc9, 0x7c, 0x00, 0x00, 0x07, 0x22, 0x00, 0x00, 0x1f, 0x74, 0x00,
+    0x08, 0xf8, 0xa6, 0x00, 0x01, 0x0a, 0x20, 0x00, 0x00, 0x49, 0x22, 0x00,
+    0x00, 0x9a, 0x3f, 0x00, 0x00, 0x43, 0x47, 0x00, 0x00, 0x87, 0x19, 0x00,
+    0x00, 0x53, 0x6f, 0x00, 0x01, 0xca, 0x4a, 0x00, 0x01, 0xeb, 0x21, 0x00,
+    0x00, 0x0e, 0xa5, 0x00, 0x14, 0xec, 0x85, 0x00, 0x20, 0x51, 0xf1, 0x00,
+    0x00, 0xc8, 0x81, 0x00, 0x00, 0x7c, 0x92, 0x00, 0x00, 0xac, 0x05, 0x00,
+    0x01, 0xde, 0x3c, 0x00, 0x00, 0x73, 0xa0, 0x00, 0x00, 0x11, 0x03, 0x00,
+    0x01, 0x8d, 0xcd, 0x00, 0x00, 0x06, 0x1e, 0x00, 0x00, 0x54, 0x85, 0x00,
+    0x00, 0x70, 0x89, 0x00, 0x00, 0x4b, 0xa8, 0x00, 0x00, 0x2e, 0x9b, 0x00,
+    0x00, 0x32, 0x53, 0x00, 0x00, 0x20, 0x54, 0x00, 0x00, 0x3c, 0xca, 0x00,
+    0x01, 0x5a, 0x21, 0x00, 0x02, 0x74, 0x17, 0x00, 0x02, 0x07, 0xae, 0x00,
+    0x00, 0x52, 0x36, 0x00, 0x00, 0x17, 0x40, 0x00, 0x01, 0xd0, 0x52, 0x00,
+    0x00, 0x1d, 0x6f, 0x00, 0x03, 0x84, 0xe4, 0x00, 0x00, 0x64, 0x30, 0x00,
+    0x00, 0xbb, 0x88, 0x00, 0x00, 0x38, 0x99, 0x00, 0x00, 0x4f, 0x7d, 0x00,
+    0x00, 0x30, 0x6f, 0x00, 0x00, 0x4f, 0xaf, 0x00, 0x00, 0x51, 0x0d, 0x00,
+    0x03, 0x4f, 0x92, 0x00, 0x02, 0x71, 0xf5, 0x00, 0x01, 0x16, 0x83, 0x00,
+    0x01, 0x98, 0x56, 0x00, 0x00, 0x4e, 0x6e, 0x00, 0x00, 0x82, 0x47, 0x00,
+    0x00, 0x35, 0xa3, 0x00, 0x00, 0x8e, 0x83, 0x00, 0x00, 0x09, 0xd0, 0x00,
+    0x00, 0x54, 0xe1, 0x00, 0x00, 0xa0, 0x78, 0x00, 0x00, 0x43, 0x75, 0x00,
+    0x00, 0x24, 0x82, 0x00, 0x00, 0x37, 0x17, 0x00, 0x00, 0x3c, 0xbe, 0x00,
+    0x00, 0x1a, 0x66, 0x00, 0x00, 0x46, 0xd5, 0x00, 0x00, 0x3b, 0xde, 0x00,
+    0x00, 0x13, 0xbd, 0x00, 0x03, 0x6a, 0x23, 0x00, 0x00, 0x2d, 0x33, 0x00,
+    0x00, 0x4d, 0xcb, 0x00, 0x00, 0x79, 0x45, 0x00, 0x00, 0x39, 0xc3, 0x00,
+    0x00, 0x8f, 0xae, 0x00, 0x00, 0x47, 0xe4, 0x00, 0x00, 0xd0, 0x3d, 0x00,
+    0x00, 0x71, 0xb4, 0x00, 0x00, 0xc7, 0xdc, 0x00, 0x00, 0x3d, 0x96, 0x00,
+    0x00, 0x81, 0x29, 0x00, 0x00, 0xbb, 0x3a, 0x00, 0x00, 0xbc, 0x9f, 0x00,
+    0x00, 0x32, 0x9f, 0x00, 0x00, 0x1c, 0xc5, 0x00, 0x00, 0x33, 0xbc, 0x00,
+    0x00, 0x22, 0xb2, 0x00, 0x00, 0xf4, 0x3c, 0x00, 0x00, 0x56, 0x71, 0x00,
+    0x00, 0x0d, 0x72, 0x00, 0x00, 0x2c, 0xce, 0x00, 0x00, 0x12, 0x15, 0x00,
+    0x00, 0x41, 0x50, 0x00, 0x00, 0x17, 0x08, 0x00, 0x00, 0x0c, 0xe7, 0x00,
+    0x00, 0xad, 0xe6, 0x00, 0x00, 0xf3, 0x21, 0x00, 0x00, 0x1e, 0xad, 0x00,
+    0x01, 0xb6, 0x63, 0x00, 0x00, 0x7f, 0xbc, 0x00, 0x06, 0xe1, 0x75, 0x00,
+    0x00, 0x23, 0x29, 0x00, 0x00, 0x61, 0x01, 0x00, 0x00, 0x52, 0x3b, 0x00,
+    0x00, 0x0c, 0x66, 0x00, 0x00, 0x0b, 0xed, 0x00, 0x00, 0xec, 0x41, 0x00,
+    0x01, 0x2e, 0x64, 0x00, 0x00, 0x1a, 0x5c, 0x00, 0x00, 0x2e, 0x19, 0x00,
+    0x00, 0x27, 0x0b, 0x00, 0x14, 0xae, 0x09, 0x00, 0x0b, 0x2a, 0xe9, 0x00,
+    0x00, 0xe5, 0x9f, 0x00, 0x00, 0xbf, 0x37, 0x00, 0x02, 0x54, 0x71, 0x00,
+    0x00, 0x6c, 0x7b, 0x00, 0x00, 0x16, 0x61, 0x00, 0x00, 0x3f, 0xdb, 0x00,
+    0x00, 0x46, 0x56, 0x00, 0x00, 0x03, 0x16, 0x00, 0x00, 0xfe, 0xf0, 0x00,
+    0x00, 0x0b, 0xee, 0x00, 0x00, 0xc5, 0x71, 0x00, 0x00, 0x33, 0xa8, 0x00,
+    0x00, 0x64, 0x9c, 0x00, 0x15, 0xba, 0xf4, 0x00, 0x00, 0x31, 0xa5, 0x00,
+    0x00, 0x09, 0xb6, 0x00, 0x00, 0xe5, 0x36, 0x00, 0x00, 0x4e, 0x4c, 0x00,
+    0x00, 0x2c, 0xbd, 0x00, 0x00, 0x1d, 0xc5, 0x00, 0x00, 0x03, 0xab, 0x00,
+    0x00, 0x1c, 0xc8, 0x00, 0x07, 0x69, 0x04, 0x00, 0x00, 0x2e, 0x96, 0x00,
+    0x00, 0x13, 0x30, 0x00, 0x02, 0x24, 0x35, 0x00, 0x00, 0x32, 0x52, 0x00,
+    0x00, 0x64, 0xe4, 0x00, 0x00, 0x90, 0x36, 0x00, 0x00, 0x2b, 0x62, 0x00,
+    0x00, 0x07, 0x2a, 0x00, 0x00, 0x21, 0xb7, 0x00, 0x0c, 0x10, 0xe3, 0x00,
+    0x03, 0x03, 0xe6, 0x00, 0x00, 0x57, 0xed, 0x00, 0x07, 0x5d, 0xf7, 0x00,
+    0x00, 0x35, 0x9c, 0x00, 0x00, 0x29, 0x9a, 0x00, 0x00, 0x9c, 0xdc, 0x00,
+    0x04, 0x4e, 0xbf, 0x00, 0x00, 0x59, 0xcd, 0x00, 0x02, 0xeb, 0x92, 0x00,
+    0x00, 0x67, 0xda, 0x00, 0x03, 0x7f, 0x8b, 0x00, 0x00, 0x12, 0xd5, 0x00,
+    0x00, 0xbf, 0x4e, 0x00, 0x00, 0x5e, 0x5d, 0x00, 0x01, 0x63, 0xee, 0x00,
+    0x01, 0xc7, 0xde, 0x00, 0x00, 0x78, 0xfa, 0x00, 0x00, 0xa8, 0x19, 0x00,
+    0x09, 0x35, 0x2a, 0x00, 0x01, 0x8e, 0xdb, 0x00, 0x00, 0xdb, 0x9c, 0x00,
+    0x03, 0xde, 0x8e, 0x00, 0x00, 0x55, 0x30, 0x00, 0x00, 0x3d, 0x73, 0x00,
+    0x01, 0x58, 0x28, 0x00, 0x01, 0x16, 0x91, 0x00, 0x00, 0x23, 0xd6, 0x00,
+    0x00, 0x0b, 0xa8, 0x00, 0x00, 0x2f, 0xb5, 0x00, 0x00, 0x0c, 0xf1, 0x00,
+    0x00, 0x2e, 0xc3, 0x00, 0x03, 0xf6, 0xf3, 0x00, 0x00, 0x80, 0xae, 0x00,
+    0x00, 0x18, 0x0e, 0x00, 0x00, 0x0e, 0xda, 0x00, 0x00, 0x27, 0x56, 0x00,
+    0x00, 0xc4, 0xd3, 0x00, 0x05, 0x3a, 0x00, 0x00, 0x00, 0xa7, 0x9c, 0x00,
+    0x00, 0x39, 0x6c, 0x00, 0x00, 0x2d, 0xf6, 0x00, 0x00, 0x42, 0x2d, 0x00,
+    0x02, 0x4e, 0xb6, 0x00, 0x03, 0x04, 0x62, 0x00, 0x00, 0x1f, 0xcb, 0x00,
+    0x00, 0x97, 0x5a, 0x00, 0x00, 0x7e, 0xb6, 0x00, 0x00, 0x87, 0x82, 0x00,
+    0x00, 0x21, 0xa3, 0x00, 0x00, 0x95, 0x77, 0x00, 0x00, 0x25, 0x45, 0x00,
+    0x00, 0x37, 0x46, 0x00, 0x00, 0x28, 0x49, 0x00, 0x00, 0x56, 0x25, 0x00,
+    0x00, 0x59, 0x2e, 0x00, 0x00, 0x2c, 0xd9, 0x00, 0x0a, 0xba, 0x97, 0x00,
+    0x00, 0x35, 0xf0, 0x00, 0x00, 0x27, 0x22, 0x00, 0x00, 0x22, 0xed, 0x00,
+    0x00, 0x54, 0x12, 0x00, 0x00, 0x8a, 0x70, 0x00, 0x00, 0xb4, 0x8d, 0x00,
+    0x01, 0x63, 0x58, 0x00, 0x00, 0x54, 0xca, 0x00, 0x00, 0x73, 0x8f, 0x00,
+    0x00, 0x9f, 0x8e, 0x00, 0x00, 0x1c, 0x2f, 0x00, 0x00, 0x3a, 0xe5, 0x00,
+    0x00, 0x4f, 0x90, 0x00, 0x00, 0x2e, 0x79, 0x00, 0x01, 0xe4, 0x5e, 0x00,
+    0x00, 0x04, 0x11, 0x00, 0x00, 0xbb, 0xa1, 0x00, 0x00, 0x8c, 0xcc, 0x00,
+    0x00, 0x19, 0xe0, 0x00, 0x00, 0x1a, 0x38, 0x00, 0x00, 0xc5, 0xb6, 0x00,
+    0x03, 0x8e, 0x35, 0x00, 0x00, 0x1f, 0x45, 0x00, 0x02, 0x2f, 0x1f, 0x00,
+    0x04, 0x3e, 0xab, 0x00, 0x00, 0xab, 0x51, 0x00, 0x00, 0x28, 0x25, 0x00,
+    0x00, 0x71, 0x79, 0x00, 0x01, 0x85, 0x4e, 0x00, 0x00, 0x28, 0x87, 0x00,
+    0x00, 0x85, 0xfa, 0x00, 0x00, 0x34, 0xa4, 0x00, 0x00, 0x52, 0xc6, 0x00,
+    0x00, 0x2a, 0x74, 0x00, 0x03, 0x87, 0x35, 0x00, 0x00, 0x44, 0x02, 0x00,
+    0x00, 0x3d, 0x34, 0x00, 0x00, 0x94, 0x4d, 0x00, 0x00, 0x3e, 0x80, 0x00,
+    0x06, 0xd8, 0x1e, 0x00, 0x00, 0x02, 0xbe, 0x00, 0x00, 0x21, 0xdd, 0x00,
+    0x00, 0x4f, 0x44, 0x00, 0x00, 0x35, 0x3a, 0x00, 0x00, 0x07, 0xe7, 0x00,
+    0x00, 0x63, 0x70, 0x00, 0x00, 0xd7, 0xdb, 0x00, 0x00, 0x3e, 0xee, 0x00,
+    0x00, 0x27, 0x01, 0x00, 0x00, 0x5e, 0x0d, 0x00, 0x00, 0x8c, 0x2c, 0x00,
+    0x00, 0x3d, 0xd5, 0x00, 0x00, 0x21, 0x5f, 0x00, 0x00, 0x14, 0xc8, 0x00,
+    0x00, 0x82, 0x9a, 0x00, 0x00, 0x0d, 0xe1, 0x00, 0x00, 0xfb, 0xcc, 0x00,
+    0x02, 0x40, 0xba, 0x00, 0x00, 0x58, 0xdc, 0x00, 0x00, 0x24, 0xa9, 0x00,
+    0x00, 0x5d, 0x73, 0x00, 0x01, 0xa2, 0x4f, 0x00, 0x02, 0x49, 0x48, 0x00,
+    0x00, 0x0e, 0x59, 0x00, 0x00, 0x0f, 0xa3, 0x00, 0x00, 0x2e, 0xa2, 0x00,
+    0x00, 0x0b, 0x58, 0x00, 0x00, 0x2f, 0x0a, 0x00, 0x00, 0x60, 0x63, 0x00,
+    0x00, 0x6f, 0xf3, 0x00, 0x00, 0xb5, 0x1c, 0x00, 0x00, 0x66, 0xb5, 0x00,
+    0x01, 0x91, 0x44, 0x00, 0x02, 0x37, 0xbd, 0x00, 0x00, 0x96, 0x47, 0x00,
+    0x29, 0x87, 0xa5, 0x00, 0x00, 0x5d, 0x50, 0x00, 0x00, 0xc2, 0xe9, 0x00,
+    0x00, 0x21, 0x2c, 0x00, 0x00, 0x86, 0xeb, 0x00, 0x00, 0x72, 0x01, 0x00,
+    0x00, 0x08, 0xf7, 0x00, 0x00, 0x16, 0x61, 0x00, 0x00, 0x2f, 0x72, 0x00,
+    0x00, 0x6b, 0x66, 0x00, 0x00, 0x91, 0x4a, 0x00, 0x00, 0x36, 0x5d, 0x00,
+    0x00, 0x60, 0xc9, 0x00, 0x00, 0x1a, 0xc5, 0x00, 0x00, 0x0b, 0x30, 0x00,
+    0x06, 0x8b, 0x03, 0x00, 0x00, 0x57, 0xc1, 0x00, 0x00, 0xf6, 0xee, 0x00,
+    0x00, 0x86, 0xe5, 0x00, 0x00, 0x30, 0x87, 0x00, 0x00, 0xc6, 0xb4, 0x00,
+    0x00, 0x39, 0xad, 0x00, 0x04, 0x63, 0xd5, 0x00, 0x19, 0x0a, 0xff, 0x00,
+    0x02, 0x93, 0x4f, 0x00, 0x00, 0xa3, 0xdd, 0x00, 0x00, 0x55, 0x08, 0x00,
+    0x01, 0xf4, 0x02, 0x00, 0x00, 0x99, 0xbe, 0x00, 0x06, 0x19, 0x51, 0x00,
+    0x00, 0xa9, 0x92, 0x00, 0x00, 0xc7, 0x9f, 0x00, 0x01, 0x18, 0xc5, 0x00,
+    0x02, 0x8b, 0x5c, 0x00, 0x00, 0x89, 0x60, 0x00, 0x01, 0x29, 0x04, 0x00,
+    0x00, 0x09, 0x4b, 0x00, 0x00, 0x52, 0x60, 0x00, 0x00, 0x65, 0x85, 0x00,
+    0x08, 0xb4, 0xf7, 0x00, 0x02, 0x05, 0xc1, 0x00, 0x00, 0x52, 0xc0, 0x00,
+    0x00, 0x54, 0x69, 0x00, 0x00, 0x52, 0xb5, 0x00, 0x04, 0x51, 0x14, 0x00,
+    0x00, 0xea, 0xa3, 0x00, 0x01, 0x2e, 0xbc, 0x00, 0x00, 0x02, 0xf6, 0x00,
+    0x00, 0xd7, 0xbd, 0x00, 0x00, 0xbe, 0x86, 0x00, 0x00, 0x98, 0x41, 0x00,
+    0x00, 0x51, 0xe7, 0x00, 0x00, 0x2f, 0xd9, 0x00, 0x00, 0x26, 0x6b, 0x00,
+    0x00, 0x9b, 0xb1, 0x00, 0x00, 0x3d, 0x24, 0x00, 0x00, 0x48, 0xbe, 0x00,
+    0x00, 0x9c, 0x5c, 0x00, 0x00, 0x03, 0x4e, 0x00, 0x00, 0x1f, 0x3e, 0x00,
+    0x00, 0x4a, 0x54, 0x00, 0x01, 0x65, 0xb6, 0x00, 0x00, 0x71, 0x05, 0x00,
+    0x00, 0x1e, 0xce, 0x00, 0x01, 0x48, 0xf9, 0x00, 0x00, 0x75, 0xf8, 0x00,
+    0x00, 0x33, 0x95, 0x00, 0x02, 0x14, 0x3a, 0x00, 0x0a, 0xed, 0x90, 0x00,
+    0x0a, 0xa9, 0xb6, 0x00, 0x00, 0x93, 0x35, 0x00, 0x00, 0xe1, 0x1a, 0x00,
+    0x00, 0x5e, 0x06, 0x00, 0x00, 0x3d, 0x76, 0x00, 0x00, 0x12, 0xb8, 0x00,
+    0x06, 0xc5, 0x92, 0x00, 0x02, 0x81, 0xfd, 0x00, 0x00, 0x6d, 0x11, 0x00,
+    0x00, 0xc7, 0x6c, 0x00, 0x03, 0xc8, 0x59, 0x00, 0x00, 0x3c, 0xb2, 0x00,
+    0x00, 0xa8, 0x19, 0x00, 0x01, 0x46, 0x35, 0x00, 0x00, 0x14, 0x49, 0x00,
+    0x00, 0x81, 0x60, 0x00, 0x00, 0x35, 0x8f, 0x00, 0x00, 0x5f, 0x22, 0x00,
+    0x00, 0x15, 0xb3, 0x00, 0x00, 0x8b, 0xc3, 0x00, 0x00, 0x36, 0x98, 0x00,
+    0x00, 0x3c, 0xe0, 0x00, 0x00, 0x41, 0x13, 0x00, 0x00, 0x1d, 0xb3, 0x00,
+    0x00, 0x73, 0x3f, 0x00, 0x00, 0x25, 0xb2, 0x00, 0x00, 0x25, 0x49, 0x00,
+    0x00, 0x28, 0x94, 0x00, 0x00, 0xa0, 0x78, 0x00, 0x00, 0x38, 0xa2, 0x00,
+    0x00, 0x94, 0x71, 0x00, 0x00, 0x5c, 0x15, 0x00, 0x00, 0x5e, 0x8a, 0x00,
+    0x00, 0x84, 0xe1, 0x00, 0x00, 0x42, 0x3b, 0x00, 0x2a, 0x7b, 0x4b, 0x00,
+    0x00, 0x43, 0x30, 0x00, 0x00, 0xab, 0x80, 0x00, 0x00, 0x1a, 0x67, 0x00,
+    0x00, 0x24, 0xad, 0x00, 0x04, 0x91, 0x4d, 0x00, 0x00, 0x38, 0xed, 0x00,
+    0x00, 0x20, 0xeb, 0x00, 0x00, 0xf4, 0xef, 0x00, 0x01, 0x39, 0x8b, 0x00,
+    0x00, 0x40, 0xad, 0x00, 0x01, 0x03, 0x0a, 0x00, 0x02, 0x90, 0xf3, 0x00,
+    0x00, 0x7c, 0xea, 0x00, 0x03, 0x68, 0xec, 0x00, 0x00, 0x05, 0x4c, 0x00,
+    0x00, 0x39, 0x8e, 0x00, 0x08, 0x06, 0x86, 0x00, 0x00, 0x97, 0x82, 0x00,
+    0x02, 0x47, 0x88, 0x00, 0x01, 0x06, 0x46, 0x00, 0x00, 0x1b, 0xda, 0x00,
+    0x01, 0x18, 0x97, 0x00, 0x00, 0x36, 0x44, 0x00, 0x02, 0x6b, 0x7f, 0x00,
+    0x00, 0xb6, 0x16, 0x00, 0x00, 0x2f, 0x97, 0x00, 0x08, 0x34, 0x82, 0x00,
+    0x00, 0x26, 0xc5, 0x00, 0x00, 0x39, 0x2f, 0x00, 0x00, 0xb5, 0x7b, 0x00,
+    0x00, 0x9c, 0x70, 0x00, 0x01, 0x45, 0x5c, 0x00, 0x00, 0x44, 0x39, 0x00,
+    0x00, 0x0a, 0x6b, 0x00, 0x00, 0xa3, 0xf0, 0x00, 0x00, 0x09, 0x61, 0x00,
+    0x00, 0x19, 0xca, 0x00, 0x00, 0x40, 0x69, 0x00, 0x00, 0x1b, 0x58, 0x00,
+    0x00, 0xde, 0x1b, 0x00, 0x00, 0x36, 0x34, 0x00, 0x01, 0x3a, 0x88, 0x00,
+    0x01, 0x88, 0x5c, 0x00, 0x00, 0xd7, 0x6b, 0x00, 0x02, 0x61, 0xb6, 0x00,
+    0x00, 0x2a, 0x34, 0x00, 0x00, 0x0d, 0x17, 0x00, 0x00, 0x95, 0x52, 0x00,
+    0x00, 0x1d, 0x94, 0x00, 0x00, 0xf1, 0xec, 0x00, 0x0a, 0xb1, 0x5d, 0x00,
+    0x00, 0x33, 0xd3, 0x00, 0x00, 0x0f, 0xa7, 0x00, 0x00, 0xc9, 0x99, 0x00,
+    0x01, 0x38, 0x62, 0x00, 0x00, 0xf6, 0xeb, 0x00, 0x00, 0x14, 0xde, 0x00,
+    0x01, 0x58, 0x41, 0x00, 0x00, 0x7c, 0x47, 0x00, 0x00, 0xd4, 0xfc, 0x00,
+    0x00, 0x7b, 0xed, 0x00, 0x00, 0x33, 0xd2, 0x00, 0x00, 0x73, 0xb7, 0x00,
+    0x00, 0x0d, 0x3d, 0x00, 0x00, 0x37, 0x47, 0x00, 0x00, 0x7a, 0x5c, 0x00,
+    0x00, 0x69, 0xa4, 0x00, 0x00, 0x1b, 0x4b, 0x00, 0x02, 0x38, 0x7a, 0x00,
+    0x00, 0x60, 0xf4, 0x00, 0x00, 0x31, 0xfc, 0x00, 0x00, 0xb3, 0x35, 0x00,
+    0x00, 0xc2, 0x37, 0x00, 0x00, 0x07, 0x05, 0x00, 0x00, 0x27, 0x32, 0x00,
+    0x00, 0x59, 0x1d, 0x00, 0x00, 0x25, 0xfd, 0x00, 0x01, 0xf1, 0x21, 0x00,
+    0x01, 0x7e, 0x9e, 0x00, 0x02, 0x78, 0x13, 0x00, 0x00, 0x6a, 0x45, 0x00,
+    0x00, 0xcc, 0x80, 0x00, 0x00, 0x1f, 0x84, 0x00, 0x00, 0x27, 0x5e, 0x00,
+    0x00, 0x27, 0x21, 0x00, 0x00, 0xd1, 0xa9, 0x00, 0x00, 0x42, 0x24, 0x00,
+    0x00, 0x37, 0x6f, 0x00, 0x0d, 0xe9, 0x61, 0x00, 0x00, 0x16, 0x6a, 0x00,
+    0x00, 0x36, 0xf8, 0x00, 0x00, 0x08, 0xf6, 0x00, 0x00, 0x35, 0x44, 0x00,
+    0x00, 0x33, 0x3d, 0x00, 0x03, 0x52, 0x5d, 0x00, 0x00, 0x96, 0x6b, 0x00,
+    0x00, 0x34, 0xd8, 0x00, 0x00, 0x3c, 0xbe, 0x00, 0x00, 0xfc, 0x0e, 0x00,
+    0x02, 0x61, 0xfd, 0x00, 0x00, 0x20, 0xff, 0x00, 0x03, 0x46, 0x8c, 0x00,
+    0x00, 0xa5, 0x0e, 0x00, 0x00, 0x62, 0xfa, 0x00, 0x00, 0x37, 0x48, 0x00,
+    0x00, 0x7b, 0xd0, 0x00, 0x00, 0x82, 0xe0, 0x00, 0x00, 0xd5, 0x66, 0x00,
+    0x19, 0x40, 0x5c, 0x00, 0x00, 0x2f, 0x2a, 0x00, 0x03, 0x0b, 0x8c, 0x00,
+    0x00, 0x8c, 0x2d, 0x00, 0x00, 0x4c, 0xce, 0x00, 0x00, 0x1a, 0x9c, 0x00,
+    0x00, 0x36, 0xa5, 0x00, 0x00, 0x0d, 0x80, 0x00, 0x00, 0x53, 0x1d, 0x00,
+    0x02, 0xb9, 0xb7, 0x00, 0x00, 0x3b, 0xc0, 0x00, 0x00, 0x1d, 0xd0, 0x00,
+    0x00, 0x3e, 0x9d, 0x00, 0x01, 0x0f, 0xcb, 0x00, 0x00, 0x22, 0x7b, 0x00,
+    0x00, 0x41, 0x78, 0x00, 0x00, 0x3a, 0x44, 0x00, 0x00, 0x30, 0x76, 0x00,
+    0x00, 0x09, 0x55, 0x00, 0x01, 0x58, 0x45, 0x00, 0x00, 0xc4, 0x85, 0x00,
+    0x00, 0x80, 0x6b, 0x00, 0x00, 0xea, 0x96, 0x00, 0x00, 0x24, 0x34, 0x00,
+    0x01, 0xd5, 0xca, 0x00, 0x00, 0x92, 0x1a, 0x00, 0x00, 0x44, 0x7c, 0x00,
+    0x00, 0xce, 0xd2, 0x00, 0x00, 0x0d, 0x9a, 0x00, 0x00, 0x65, 0x0d, 0x00,
+    0x01, 0x4c, 0x24, 0x00, 0x01, 0xc8, 0x5c, 0x00, 0x00, 0x1d, 0x82, 0x00,
+    0x00, 0x73, 0x31, 0x00, 0x00, 0x12, 0xce, 0x00, 0x00, 0x45, 0x9f, 0x00,
+    0x00, 0x69, 0x0f, 0x00, 0x00, 0x55, 0x0a, 0x00, 0x01, 0x96, 0x27, 0x00,
+    0x00, 0x4e, 0x10, 0x00, 0x00, 0x1f, 0x4a, 0x00, 0x00, 0x23, 0x64, 0x00,
+    0x00, 0x21, 0x3a, 0x00, 0x00, 0x99, 0x7b, 0x00, 0x07, 0xb5, 0x74, 0x00,
+    0x00, 0x7b, 0xf8, 0x00, 0x00, 0x69, 0x93, 0x00, 0x00, 0x72, 0x4c, 0x00,
+    0x00, 0x29, 0x33, 0x00, 0x02, 0x2b, 0xf3, 0x00, 0x00, 0x5a, 0x48, 0x00,
+    0x00, 0x57, 0x11, 0x00, 0x00, 0x38, 0xb8, 0x00, 0x00, 0x45, 0x21, 0x00,
+    0x00, 0x25, 0x9d, 0x00, 0x00, 0x57, 0x96, 0x00, 0x00, 0xf8, 0x7f, 0x00,
+    0x00, 0x31, 0x7b, 0x00, 0x00, 0x8a, 0x60, 0x00, 0x02, 0x1b, 0x77, 0x00,
+    0x01, 0x9a, 0x7b, 0x00, 0x00, 0x02, 0xe1, 0x00, 0x00, 0x48, 0x1e, 0x00,
+    0x00, 0x1e, 0xc6, 0x00, 0x00, 0x2b, 0x3e, 0x00, 0x00, 0x55, 0x8d, 0x00,
+    0x01, 0x3f, 0x70, 0x00, 0x00, 0x28, 0x3e, 0x00, 0x00, 0x20, 0xba, 0x00,
+    0x0c, 0xd4, 0xaf, 0x00, 0x00, 0x0c, 0x3b, 0x00, 0x00, 0x91, 0xfd, 0x00,
+    0x04, 0x37, 0xb1, 0x00, 0x02, 0x48, 0xc1, 0x00, 0x01, 0x00, 0xc8, 0x00,
+    0x00, 0x1e, 0xe3, 0x00, 0x00, 0x87, 0x11, 0x00, 0x00, 0x7d, 0xad, 0x00,
+    0x11, 0xf3, 0xa8, 0x00, 0x02, 0xa4, 0x43, 0x00, 0x00, 0x61, 0x3f, 0x00,
+    0x00, 0xa3, 0xe5, 0x00, 0x00, 0x98, 0x8c, 0x00, 0x00, 0x8a, 0x37, 0x00,
+    0x00, 0x3f, 0x18, 0x00, 0x00, 0x31, 0x6b, 0x00, 0x00, 0x27, 0xc9, 0x00,
+    0x01, 0x7a, 0x81, 0x00, 0x00, 0x1e, 0x63, 0x00, 0x00, 0x2d, 0x40, 0x00,
+    0x00, 0x0c, 0xf5, 0x00, 0x00, 0x33, 0x96, 0x00, 0x00, 0x45, 0xad, 0x00,
+    0x00, 0x45, 0xf4, 0x00, 0x00, 0xa3, 0xd8, 0x00, 0x01, 0xcd, 0x6d, 0x00,
+    0x00, 0x33, 0x5a, 0x00, 0x00, 0x1f, 0xff, 0x00, 0x00, 0x49, 0x44, 0x00,
+    0x00, 0x65, 0x71, 0x00, 0x00, 0xc1, 0x87, 0x00, 0x00, 0x05, 0x74, 0x00,
+    0x05, 0xf8, 0x51, 0x00, 0x03, 0x15, 0x1b, 0x00, 0x00, 0x07, 0x74, 0x00,
+    0x07, 0x04, 0x78, 0x00, 0x00, 0x5d, 0x07, 0x00, 0x00, 0xb5, 0xe4, 0x00,
+    0x00, 0x2a, 0x87, 0x00, 0x00, 0x63, 0x4e, 0x00, 0x00, 0x34, 0x81, 0x00,
+    0x00, 0x97, 0x1d, 0x00, 0x00, 0x3f, 0xcd, 0x00, 0x04, 0xf1, 0x0d, 0x00,
+    0x00, 0x9c, 0x5b, 0x00, 0x00, 0x63, 0x95, 0x00, 0x00, 0x2c, 0x11, 0x00,
+    0x00, 0x77, 0x30, 0x00, 0x00, 0x29, 0x11, 0x00, 0x00, 0xbd, 0xc6, 0x00,
+    0x00, 0x2a, 0x37, 0x00, 0x01, 0x4d, 0x69, 0x00, 0x00, 0x77, 0x46, 0x00,
+    0x00, 0x57, 0xd5, 0x00, 0x00, 0x08, 0xa1, 0x00, 0x00, 0xe7, 0x07, 0x00,
+    0x00, 0x40, 0x11, 0x00, 0x09, 0xa8, 0x9c, 0x00, 0x00, 0x9a, 0xf8, 0x00,
+    0x00, 0x89, 0x8c, 0x00, 0x00, 0x97, 0x4c, 0x00, 0x00, 0xb0, 0xea, 0x00,
+    0x00, 0x90, 0x73, 0x00, 0x00, 0x2a, 0xa6, 0x00, 0x00, 0x21, 0x89, 0x00,
+    0x00, 0x3d, 0xc6, 0x00, 0x00, 0x02, 0x33, 0x00, 0x00, 0x09, 0x31, 0x00,
+    0x01, 0x24, 0x72, 0x00, 0x01, 0x7a, 0xe5, 0x00, 0x00, 0x71, 0x18, 0x00,
+    0x00, 0x78, 0x6c, 0x00, 0x00, 0x40, 0x96, 0x00, 0x01, 0x41, 0xec, 0x00,
+    0x00, 0x5c, 0x11, 0x00, 0x00, 0x4b, 0x2d, 0x00, 0x00, 0x93, 0x9b, 0x00,
+    0x02, 0x74, 0x00, 0x00, 0x01, 0x3b, 0x20, 0x00, 0x00, 0x3c, 0x3d, 0x00,
+    0x00, 0x03, 0x69, 0x00, 0x00, 0x68, 0xe3, 0x00, 0x01, 0x0a, 0x5c, 0x00,
+    0x00, 0x42, 0x7d, 0x00, 0x01, 0x01, 0xd0, 0x00, 0x00, 0x0d, 0x7d, 0x00,
+    0x00, 0x69, 0xa3, 0x00, 0x00, 0x17, 0x11, 0x00, 0x00, 0x32, 0xfc, 0x00,
+    0x00, 0x1e, 0x42, 0x00, 0x00, 0xf7, 0x11, 0x00, 0x00, 0x2a, 0xfe, 0x00,
+    0x02, 0x32, 0xb3, 0x00, 0x00, 0xa8, 0x81, 0x00, 0x00, 0x0f, 0xf2, 0x00,
+    0x00, 0x13, 0x40, 0x00, 0x00, 0x15, 0xb2, 0x00, 0x00, 0x27, 0xab, 0x00,
+    0x00, 0x11, 0xfa, 0x00, 0x00, 0x74, 0xdc, 0x00, 0x00, 0x20, 0x6d, 0x00,
+    0x00, 0x58, 0xfc, 0x00, 0x00, 0x62, 0xf5, 0x00, 0x00, 0xd8, 0x94, 0x00,
+    0x00, 0x05, 0xbe, 0x00, 0x00, 0x6f, 0xe6, 0x00, 0x00, 0x48, 0xbe, 0x00,
+    0x00, 0xc0, 0x00, 0x00, 0x00, 0xdb, 0x13, 0x00, 0x01, 0x08, 0x9b, 0x00,
+    0x00, 0x72, 0x36, 0x00, 0x00, 0x21, 0x60, 0x00, 0x00, 0xa0, 0x20, 0x00,
+    0x00, 0x78, 0x2c, 0x00, 0x00, 0x0b, 0x1f, 0x00, 0x00, 0xbf, 0x65, 0x00,
+    0x00, 0x45, 0x32, 0x00, 0x00, 0x93, 0xd1, 0x00, 0x01, 0x18, 0x94, 0x00,
+    0x01, 0x15, 0x9d, 0x00, 0x00, 0x3e, 0x8b, 0x00, 0x00, 0x5e, 0xde, 0x00,
+    0x00, 0x53, 0xa6, 0x00, 0x15, 0xea, 0x7f, 0x00, 0x00, 0x49, 0x57, 0x00,
+    0x00, 0x8a, 0x12, 0x00, 0x00, 0x21, 0x99, 0x00, 0x00, 0x23, 0x9f, 0x00,
+    0x00, 0xda, 0x62, 0x00, 0x01, 0x9e, 0xc4, 0x00, 0x01, 0xc8, 0x60, 0x00,
+    0x00, 0x7a, 0x9e, 0x00, 0x00, 0x1f, 0x67, 0x00, 0x00, 0x37, 0x3a, 0x00,
+    0x00, 0x16, 0xc5, 0x00, 0x00, 0x9a, 0x46, 0x00, 0x00, 0x3c, 0xe4, 0x00,
+    0x02, 0xd0, 0x56, 0x00, 0x00, 0x0d, 0xe8, 0x00, 0x00, 0x84, 0xde, 0x00,
+    0x00, 0x48, 0x81, 0x00, 0x01, 0xab, 0x38, 0x00, 0x00, 0x33, 0xb5, 0x00,
+    0x00, 0x4c, 0xe6, 0x00, 0x00, 0x42, 0x63, 0x00, 0x00, 0xfd, 0x06, 0x00,
+    0x00, 0x42, 0x17, 0x00, 0x00, 0xa0, 0x5c, 0x00, 0x01, 0x0c, 0xae, 0x00,
+    0x04, 0xd3, 0xb4, 0x00, 0x00, 0x22, 0xbd, 0x00, 0x00, 0x4c, 0x61, 0x00,
+    0x00, 0xc9, 0xe1, 0x00, 0x00, 0x3f, 0x85, 0x00, 0x00, 0x40, 0xc1, 0x00,
+    0x8c, 0x96, 0x5d, 0x00, 0x00, 0x2b, 0xd6, 0x00, 0x00, 0xb4, 0x7c, 0x00,
+    0x01, 0x80, 0x6c, 0x00, 0x00, 0x1a, 0x51, 0x00, 0x00, 0xfe, 0x55, 0x00,
+    0x02, 0x4c, 0xd0, 0x00, 0x00, 0x30, 0xf7, 0x00, 0x00, 0x01, 0xb6, 0x00,
+    0x03, 0x48, 0xaf, 0x00, 0x00, 0x4c, 0x7a, 0x00, 0x00, 0x09, 0x45, 0x00,
+    0x00, 0x1a, 0xde, 0x00, 0x00, 0x4a, 0x61, 0x00, 0x00, 0x9e, 0x1c, 0x00,
+    0x01, 0xdc, 0xa0, 0x00, 0x00, 0xe9, 0x7d, 0x00, 0x00, 0x90, 0x24, 0x00,
+    0x00, 0xbf, 0xda, 0x00, 0x01, 0x91, 0x9f, 0x00, 0x05, 0x58, 0x89, 0x00,
+    0x00, 0x59, 0x7e, 0x00, 0x00, 0x1d, 0x2b, 0x00, 0x00, 0x70, 0x05, 0x00,
+    0x00, 0xe8, 0xe7, 0x00, 0x0b, 0x88, 0x12, 0x00, 0x00, 0x0e, 0x6c, 0x00,
+    0x00, 0x79, 0x47, 0x00, 0x00, 0x19, 0x3a, 0x00, 0x00, 0x92, 0xac, 0x00,
+    0x00, 0x52, 0xc9, 0x00, 0x00, 0x82, 0xbb, 0x00, 0x00, 0x32, 0xa6, 0x00,
+    0x00, 0x11, 0x08, 0x00, 0x00, 0x2e, 0x97, 0x00, 0x00, 0x3d, 0x1f, 0x00,
+    0x01, 0x2e, 0x27, 0x00, 0x03, 0x75, 0xc6, 0x00, 0x04, 0x75, 0x55, 0x00,
+    0x00, 0x13, 0x1b, 0x00, 0x18, 0xf3, 0xa2, 0x00, 0x00, 0x27, 0x8e, 0x00,
+    0x00, 0x99, 0xb2, 0x00, 0x00, 0x7b, 0x4a, 0x00, 0x05, 0x66, 0x35, 0x00,
+    0x00, 0x47, 0x43, 0x00, 0x00, 0x2a, 0xed, 0x00, 0x02, 0xdf, 0x06, 0x00,
+    0x00, 0x9c, 0x2b, 0x00, 0x00, 0x34, 0x02, 0x00, 0x00, 0x04, 0xb9, 0x00,
+    0x00, 0x3f, 0xc8, 0x00, 0x00, 0x76, 0xfb, 0x00, 0x00, 0x59, 0xe7, 0x00,
+    0x00, 0x0a, 0x7f, 0x00, 0x01, 0xbd, 0x94, 0x00, 0x00, 0x27, 0xb4, 0x00,
+    0x00, 0x34, 0x6f, 0x00, 0x00, 0xb2, 0x2f, 0x00, 0x03, 0x53, 0xd6, 0x00,
+    0x00, 0x60, 0x51, 0x00, 0x00, 0x1f, 0xf4, 0x00, 0x06, 0x75, 0xf1, 0x00,
+    0x01, 0x3b, 0xb6, 0x00, 0x00, 0x29, 0x22, 0x00, 0x00, 0x97, 0x49, 0x00,
+    0x00, 0x33, 0x9f, 0x00, 0x00, 0x15, 0x3a, 0x00, 0x03, 0xbf, 0xec, 0x00,
+    0x00, 0x52, 0x34, 0x00, 0x00, 0x1b, 0xdd, 0x00, 0x00, 0x1c, 0x1e, 0x00,
+    0x05, 0x1f, 0x13, 0x00, 0x00, 0x1c, 0x5f, 0x00, 0x00, 0x08, 0xcd, 0x00,
+    0x00, 0x32, 0xb8, 0x00, 0x00, 0x38, 0xff, 0x00, 0x00, 0x62, 0xd0, 0x00,
+    0x01, 0x6a, 0x51, 0x00, 0x03, 0xa8, 0x42, 0x00, 0x01, 0xc3, 0x85, 0x00,
+    0x00, 0x84, 0x80, 0x00, 0x00, 0x37, 0x8b, 0x00, 0x05, 0xc2, 0x47, 0x00,
+    0x00, 0xad, 0x03, 0x00, 0x00, 0x2b, 0x92, 0x00, 0x00, 0x82, 0x9d, 0x00,
+    0x00, 0x71, 0x10, 0x00, 0x00, 0x0a, 0xb5, 0x00, 0x00, 0xea, 0x94, 0x00,
+    0x00, 0x44, 0x8f, 0x00, 0x00, 0x10, 0x3c, 0x00, 0x02, 0x64, 0x9e, 0x00,
+    0x00, 0x9c, 0xc5, 0x00, 0x00, 0x4b, 0x70, 0x00, 0x00, 0x45, 0x0b, 0x00,
+    0x00, 0x38, 0x91, 0x00, 0x00, 0x4f, 0xf2, 0x00, 0x04, 0xd4, 0x42, 0x00,
+    0x00, 0xd3, 0x22, 0x00, 0x00, 0x45, 0x6f, 0x00, 0x00, 0x27, 0xea, 0x00,
+    0x04, 0x9f, 0xdd, 0x00, 0x00, 0x1f, 0x04, 0x00, 0x00, 0x97, 0x4e, 0x00,
+    0x04, 0x57, 0xd5, 0x00, 0x00, 0x20, 0x7f, 0x00, 0x00, 0x32, 0xfd, 0x00,
+    0x00, 0x02, 0xe1, 0x00, 0x00, 0x26, 0x3a, 0x00, 0x00, 0x0d, 0x79, 0x00,
+    0x00, 0x1e, 0x95, 0x00, 0x00, 0x5f, 0x94, 0x00, 0x02, 0x2e, 0xb6, 0x00,
+    0x03, 0x9b, 0x64, 0x00, 0x00, 0x30, 0x39, 0x00, 0x0d, 0x41, 0xd9, 0x00,
+    0x00, 0x0b, 0x99, 0x00, 0x01, 0x22, 0x89, 0x00, 0x13, 0x5a, 0xde, 0x00,
+    0x00, 0x21, 0xed, 0x00, 0x00, 0xc3, 0xec, 0x00, 0x00, 0x98, 0xe2, 0x00,
+    0x00, 0x91, 0x01, 0x00, 0x0e, 0x2d, 0xd7, 0x00, 0x00, 0x48, 0xa8, 0x00,
+    0x01, 0x48, 0x08, 0x00, 0x00, 0x1b, 0x56, 0x00, 0x00, 0x34, 0x81, 0x00,
+    0x00, 0x49, 0x7d, 0x00, 0x02, 0x85, 0xe4, 0x00, 0x00, 0xa0, 0x17, 0x00,
+    0x00, 0x7a, 0xda, 0x00, 0x00, 0xa3, 0x9b, 0x00, 0x00, 0x19, 0xf2, 0x00,
+    0x00, 0x3c, 0xd7, 0x00, 0x00, 0x15, 0x62, 0x00, 0x00, 0x21, 0xa9, 0x00,
+    0x00, 0x09, 0x2a, 0x00, 0x00, 0x10, 0xf1, 0x00, 0x00, 0x6f, 0xab, 0x00,
+    0x00, 0x99, 0xa2, 0x00, 0x00, 0x21, 0xad, 0x00, 0x00, 0x87, 0xdf, 0x00,
+    0x00, 0x14, 0xfb, 0x00, 0x00, 0x10, 0x1c, 0x00, 0x00, 0x4c, 0x6c, 0x00,
+    0x00, 0x43, 0x54, 0x00, 0x00, 0x45, 0x67, 0x00, 0x00, 0x2e, 0x71, 0x00,
+    0x00, 0xed, 0x74, 0x00, 0x00, 0x28, 0x7f, 0x00, 0x00, 0x17, 0xa8, 0x00,
+    0x00, 0x3a, 0x03, 0x00, 0x00, 0x90, 0xbb, 0x00, 0x00, 0x22, 0x91, 0x00,
+    0x00, 0x54, 0x5d, 0x00, 0x02, 0xfc, 0x5b, 0x00, 0x00, 0x03, 0x70, 0x00,
+    0x01, 0x40, 0xa5, 0x00, 0x02, 0x06, 0x5c, 0x00, 0x00, 0x55, 0x49, 0x00,
+    0x00, 0x11, 0x00, 0x00, 0x00, 0x0b, 0x22, 0x00, 0x00, 0x8c, 0x80, 0x00,
+    0x00, 0x20, 0x1c, 0x00, 0x00, 0x44, 0xb7, 0x00, 0x05, 0xfe, 0xbf, 0x00,
+    0x00, 0x23, 0x76, 0x00, 0x00, 0x56, 0x61, 0x00, 0x00, 0x29, 0x56, 0x00,
+    0x00, 0x3c, 0xd0, 0x00, 0x00, 0x03, 0x9d, 0x00, 0x03, 0x2e, 0x22, 0x00,
+    0x00, 0x09, 0x1a, 0x00, 0x00, 0x14, 0x50, 0x00, 0x00, 0x86, 0xa4, 0x00,
+    0x00, 0x3f, 0x69, 0x00, 0x03, 0x16, 0x0f, 0x00, 0x05, 0xf1, 0x7e, 0x00,
+    0x00, 0x71, 0x3b, 0x00, 0x00, 0x5a, 0xfd, 0x00, 0x00, 0x38, 0x4a, 0x00,
+    0x00, 0x6f, 0xd6, 0x00, 0x01, 0xbb, 0x64, 0x00, 0x02, 0x7b, 0x25, 0x00,
+    0x00, 0x22, 0x6d, 0x00, 0x00, 0x15, 0xea, 0x00, 0x00, 0x25, 0xec, 0x00,
+    0x00, 0x35, 0x2f, 0x00, 0x00, 0xcc, 0xd6, 0x00, 0x01, 0x14, 0xed, 0x00,
+    0x00, 0x64, 0xb6, 0x00, 0x00, 0x1c, 0xc0, 0x00, 0x01, 0x98, 0x10, 0x00,
+    0x00, 0x15, 0x4f, 0x00, 0x00, 0x0d, 0xc9, 0x00, 0x01, 0xef, 0x2b, 0x00,
+    0x00, 0xef, 0x18, 0x00, 0x03, 0x16, 0xab, 0x00, 0x01, 0xf8, 0x4a, 0x00,
+    0x00, 0x7a, 0xbf, 0x00, 0x00, 0x17, 0xd6, 0x00, 0x04, 0xca, 0xd4, 0x00,
+    0x00, 0x84, 0xb5, 0x00, 0x00, 0x14, 0xad, 0x00, 0x1f, 0x4b, 0x31, 0x00,
+    0x00, 0x67, 0x12, 0x00, 0x00, 0x54, 0x0c, 0x00, 0x04, 0x34, 0xe7, 0x00,
+    0x00, 0x46, 0x2a, 0x00, 0x16, 0x90, 0xb6, 0x00, 0x00, 0xb8, 0x66, 0x00,
+    0x04, 0xc9, 0xa7, 0x00, 0x00, 0x40, 0x5a, 0x00, 0x01, 0xc1, 0xba, 0x00,
+    0x00, 0x4f, 0x7b, 0x00, 0x00, 0x3c, 0x0d, 0x00, 0x00, 0x78, 0x5e, 0x00,
+    0x00, 0x19, 0x6f, 0x00, 0x01, 0xf4, 0x5e, 0x00, 0x00, 0x74, 0xe3, 0x00,
+    0x00, 0x26, 0x9f, 0x00, 0x00, 0x39, 0x1f, 0x00, 0x00, 0x27, 0xf6, 0x00,
+    0x00, 0x54, 0xb6, 0x00, 0x00, 0x53, 0xdc, 0x00, 0x00, 0x3a, 0x90, 0x00,
+    0x00, 0x35, 0x19, 0x00, 0x00, 0x06, 0xfd, 0x00, 0x01, 0x4c, 0xc1, 0x00,
+    0x00, 0x90, 0x0a, 0x00, 0x03, 0xb5, 0x32, 0x00, 0x01, 0x34, 0xb7, 0x00,
+    0x00, 0x5f, 0x68, 0x00, 0x00, 0x30, 0xcd, 0x00, 0x00, 0x66, 0x8a, 0x00,
+    0x01, 0x8d, 0x28, 0x00, 0x00, 0x08, 0xae, 0x00, 0x00, 0x5d, 0xd4, 0x00,
+    0x00, 0x1a, 0x28, 0x00, 0x00, 0x2d, 0x19, 0x00, 0x00, 0x45, 0x42, 0x00,
+    0x01, 0x1b, 0x7a, 0x00, 0x00, 0x39, 0x56, 0x00, 0x00, 0x48, 0x02, 0x00,
+    0x00, 0x35, 0x03, 0x00, 0x00, 0x17, 0xab, 0x00, 0x00, 0x74, 0x73, 0x00,
+    0x00, 0x1b, 0x12, 0x00, 0x01, 0x17, 0xcc, 0x00, 0x00, 0x1a, 0x9d, 0x00,
+    0x00, 0xb4, 0xcb, 0x00, 0x00, 0x36, 0x92, 0x00, 0x03, 0x80, 0x63, 0x00,
+    0x02, 0x6e, 0xc5, 0x00, 0x00, 0x3a, 0x2d, 0x00, 0x00, 0x0e, 0x39, 0x00,
+    0x00, 0x39, 0xa8, 0x00, 0x00, 0xba, 0x1c, 0x00, 0x00, 0x10, 0xc3, 0x00,
+    0x00, 0x67, 0x65, 0x00, 0x00, 0xa6, 0xd3, 0x00, 0x00, 0x4b, 0xfe, 0x00,
+    0x00, 0x2f, 0x6b, 0x00, 0x00, 0x51, 0xc4, 0x00, 0x00, 0x1a, 0xbc, 0x00,
+    0x00, 0x07, 0xed, 0x00, 0x01, 0x26, 0x04, 0x00, 0x00, 0x82, 0xd1, 0x00,
+    0x01, 0x48, 0xc9, 0x00, 0x00, 0x19, 0xb7, 0x00, 0x00, 0x58, 0xb4, 0x00,
+    0x00, 0x3a, 0x46, 0x00, 0x00, 0x08, 0xa1, 0x00, 0x07, 0xf7, 0x6f, 0x00,
+    0x00, 0x27, 0xd8, 0x00, 0x03, 0xc6, 0xa2, 0x00, 0x00, 0x07, 0xac, 0x00,
+    0x00, 0x37, 0xc2, 0x00, 0x00, 0x20, 0x03, 0x00, 0x03, 0x81, 0x1c, 0x00,
+    0x2a, 0x6d, 0xb0, 0x00, 0x00, 0x0e, 0x17, 0x00, 0x00, 0x11, 0xfa, 0x00,
+    0x00, 0x55, 0x01, 0x00, 0x00, 0x41, 0x73, 0x00, 0x02, 0x0c, 0x12, 0x00,
+    0x00, 0x10, 0x5e, 0x00, 0x00, 0x40, 0x72, 0x00, 0x00, 0x26, 0xb4, 0x00,
+    0x00, 0x2c, 0x2f, 0x00, 0x00, 0x82, 0x36, 0x00, 0x00, 0x90, 0xcd, 0x00,
+    0x00, 0x2d, 0x26, 0x00, 0x00, 0x42, 0xd9, 0x00, 0x00, 0x42, 0x5d, 0x00,
+    0x00, 0x86, 0x39, 0x00, 0x02, 0xc0, 0x6a, 0x00, 0x00, 0x07, 0xed, 0x00,
+    0x01, 0x55, 0x1b, 0x00, 0x00, 0x18, 0xbd, 0x00, 0x00, 0x4b, 0x43, 0x00,
+    0x01, 0xa8, 0x6a, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0x08, 0xc2, 0x56, 0x00,
+    0x00, 0x13, 0xfa, 0x00, 0x00, 0x1a, 0xa8, 0x00, 0x00, 0x3d, 0xdc, 0x00,
+    0x00, 0x12, 0x77, 0x00, 0x01, 0x46, 0xec, 0x00, 0x00, 0xe7, 0xa8, 0x00,
+    0x00, 0x97, 0xcc, 0x00, 0x00, 0x49, 0xa1, 0x00, 0x00, 0x3a, 0x97, 0x00,
+    0x00, 0x34, 0x53, 0x00, 0x00, 0x45, 0x0d, 0x00, 0x02, 0x26, 0xaf, 0x00,
+    0x05, 0x63, 0x56, 0x00, 0x00, 0x7d, 0xdb, 0x00, 0x00, 0xae, 0x37, 0x00,
+    0x00, 0x8a, 0x69, 0x00, 0x00, 0x49, 0x88, 0x00, 0x01, 0x81, 0x28, 0x00,
+    0x00, 0x57, 0x9b, 0x00, 0x01, 0x6c, 0xae, 0x00, 0x00, 0x56, 0x55, 0x00,
+    0x00, 0x0b, 0xab, 0x00, 0x00, 0xcb, 0x5b, 0x00, 0x00, 0x5b, 0xba, 0x00,
+    0x00, 0x53, 0xcc, 0x00, 0x00, 0x2f, 0x2e, 0x00, 0x00, 0x0d, 0x8e, 0x00,
+    0x00, 0x7a, 0x81, 0x00, 0x00, 0x27, 0x99, 0x00, 0x00, 0x01, 0x6b, 0x00,
+    0x00, 0x39, 0xef, 0x00, 0x01, 0x19, 0x36, 0x00, 0x00, 0x02, 0x9a, 0x00,
+    0x00, 0x52, 0xe6, 0x00, 0x02, 0x01, 0x20, 0x00, 0x00, 0x67, 0x61, 0x00,
+    0x00, 0x4b, 0x96, 0x00, 0x00, 0x05, 0x71, 0x00, 0x00, 0x92, 0x22, 0x00,
+    0x00, 0x3a, 0xda, 0x00, 0x01, 0xa9, 0x9f, 0x00, 0x00, 0x0d, 0x70, 0x00,
+    0x00, 0x07, 0x1e, 0x00, 0x00, 0x86, 0xe9, 0x00, 0x00, 0x59, 0x2a, 0x00,
+    0x01, 0x3d, 0x33, 0x00, 0x00, 0x33, 0x6e, 0x00, 0x00, 0x51, 0xc9, 0x00,
+    0x00, 0x7a, 0x0b, 0x00, 0x00, 0x31, 0xeb, 0x00, 0x00, 0x10, 0x30, 0x00,
+    0x00, 0x90, 0x88, 0x00, 0x00, 0x31, 0x56, 0x00, 0x00, 0x8d, 0x13, 0x00,
+    0x00, 0x4d, 0xd3, 0x00, 0x00, 0x47, 0xa8, 0x00, 0x01, 0x1c, 0x99, 0x00,
+    0x00, 0x0b, 0x71, 0x00, 0x01, 0x4c, 0xef, 0x00, 0x00, 0x24, 0x79, 0x00,
+    0x00, 0x2e, 0x9b, 0x00, 0x00, 0x7c, 0xe8, 0x00, 0x00, 0x49, 0xb1, 0x00,
+    0x01, 0x0a, 0x43, 0x00, 0x00, 0x8d, 0x60, 0x00, 0x00, 0x4b, 0x46, 0x00,
+    0x00, 0x4d, 0x5e, 0x00, 0x02, 0x15, 0x60, 0x00, 0x01, 0x9c, 0xa8, 0x00,
+    0x00, 0x15, 0x1c, 0x00, 0x00, 0x37, 0xe4, 0x00, 0x00, 0x71, 0xdd, 0x00,
+    0x08, 0x66, 0x2d, 0x00, 0x00, 0x1b, 0x57, 0x00, 0x00, 0x02, 0x42, 0x00,
+    0x00, 0xb1, 0x5e, 0x00, 0x00, 0x85, 0x31, 0x00, 0x0f, 0xc1, 0xb1, 0x00,
+    0x00, 0xa5, 0xc4, 0x00, 0x00, 0x4c, 0xcd, 0x00, 0x00, 0x35, 0x48, 0x00,
+    0x00, 0x4c, 0x65, 0x00, 0x00, 0x56, 0x5a, 0x00, 0x00, 0xa7, 0x2e, 0x00,
+    0x00, 0xcd, 0x9a, 0x00, 0x00, 0x7b, 0x60, 0x00, 0x00, 0x30, 0x4e, 0x00,
+    0x00, 0xa7, 0xc3, 0x00, 0x00, 0x06, 0xcf, 0x00, 0x00, 0x36, 0xb3, 0x00,
+    0x00, 0x6c, 0xbc, 0x00, 0x01, 0x16, 0xa5, 0x00, 0x06, 0x36, 0x53, 0x00,
+    0x00, 0xad, 0x6b, 0x00, 0x00, 0x4b, 0xbb, 0x00, 0x02, 0x88, 0x93, 0x00,
+    0x00, 0x5b, 0x73, 0x00, 0x09, 0xa1, 0x2a, 0x00, 0x03, 0x22, 0xfe, 0x00,
+    0x02, 0xb4, 0x7b, 0x00, 0x00, 0x61, 0x59, 0x00, 0x00, 0x2c, 0xeb, 0x00,
+    0x00, 0x38, 0x5f, 0x00, 0x00, 0x5f, 0xff, 0x00, 0x00, 0x63, 0x4a, 0x00,
+    0x00, 0xaa, 0x72, 0x00, 0x00, 0x10, 0x3b, 0x00, 0x00, 0x34, 0x83, 0x00,
+    0x00, 0x12, 0xfd, 0x00, 0x01, 0x66, 0x73, 0x00, 0x00, 0x4a, 0x2e, 0x00,
+    0x00, 0x56, 0xb0, 0x00, 0x00, 0x6e, 0xb2, 0x00, 0x00, 0x37, 0x04, 0x00,
+    0x01, 0xd2, 0x65, 0x00, 0x00, 0x34, 0xdc, 0x00, 0x01, 0xca, 0xba, 0x00,
+    0x0c, 0x69, 0x5d, 0x00, 0x00, 0x6f, 0x91, 0x00, 0x00, 0x87, 0x67, 0x00,
+    0x00, 0x87, 0xaa, 0x00, 0x00, 0x6c, 0xe1, 0x00, 0x00, 0x09, 0xc3, 0x00,
+    0x01, 0x6b, 0xd1, 0x00, 0x00, 0x1b, 0x11, 0x00, 0x00, 0xc6, 0x43, 0x00,
+    0x00, 0x42, 0x0c, 0x00, 0x00, 0xcf, 0x55, 0x00, 0x00, 0x22, 0xbd, 0x00,
+    0x00, 0x24, 0xc2, 0x00, 0x00, 0xe3, 0x45, 0x00, 0x00, 0x0b, 0x77, 0x00,
+    0x04, 0xfb, 0x31, 0x00, 0x00, 0x1c, 0x0e, 0x00, 0x01, 0x72, 0xa7, 0x00,
+    0x00, 0x0e, 0xc3, 0x00, 0x00, 0x37, 0xda, 0x00, 0x01, 0x52, 0x09, 0x00,
+    0x00, 0x9b, 0x02, 0x00, 0x00, 0x1b, 0x44, 0x00, 0x00, 0x90, 0xbb, 0x00,
+    0x00, 0xa6, 0x9a, 0x00, 0x03, 0x21, 0xcc, 0x00, 0x01, 0xc4, 0xe4, 0x00,
+    0x00, 0x55, 0x97, 0x00, 0x00, 0x29, 0x46, 0x00, 0x00, 0x07, 0xdc, 0x00,
+    0x00, 0x24, 0xd8, 0x00, 0x00, 0x3d, 0x4d, 0x00, 0x01, 0x40, 0x41, 0x00,
+    0x00, 0x1c, 0x02, 0x00, 0x01, 0x9a, 0xa1, 0x00, 0x00, 0x2a, 0x86, 0x00,
+    0x00, 0x16, 0x68, 0x00, 0x00, 0x26, 0x06, 0x00, 0x00, 0x45, 0x4a, 0x00,
+    0x00, 0x38, 0x72, 0x00, 0x00, 0x2f, 0xe3, 0x00, 0x00, 0x26, 0x53, 0x00,
+    0x00, 0x87, 0x00, 0x00, 0x00, 0x6f, 0xf2, 0x00, 0x00, 0x12, 0xab, 0x00,
+    0x00, 0x55, 0xf5, 0x00, 0x00, 0x2d, 0x09, 0x00, 0x00, 0x11, 0x0d, 0x00,
+    0x05, 0x94, 0x25, 0x00, 0x00, 0x96, 0xc0, 0x00, 0x00, 0x30, 0x86, 0x00,
+    0x00, 0x3b, 0xfd, 0x00, 0x00, 0x8f, 0x44, 0x00, 0x00, 0x63, 0x4d, 0x00,
+    0x00, 0x63, 0xba, 0x00, 0x05, 0x06, 0x04, 0x00, 0x00, 0x40, 0x3e, 0x00,
+    0x00, 0x0e, 0xb8, 0x00, 0x02, 0x95, 0x49, 0x00, 0x00, 0x26, 0xa9, 0x00,
+    0x00, 0x0b, 0xea, 0x00, 0x00, 0x36, 0x56, 0x00, 0x00, 0x1a, 0x31, 0x00,
+    0x00, 0x06, 0xa3, 0x00, 0x00, 0x90, 0x18, 0x00, 0x00, 0x7a, 0x39, 0x00,
+    0x00, 0x08, 0xda, 0x00, 0x00, 0x1b, 0x1a, 0x00, 0x02, 0x94, 0xcd, 0x00,
+    0x02, 0x32, 0x44, 0x00, 0x01, 0xdd, 0x96, 0x00, 0x00, 0x79, 0x49, 0x00,
+    0x00, 0x0a, 0x53, 0x00, 0x00, 0x8f, 0x84, 0x00, 0x00, 0x3c, 0xce, 0x00,
+    0x00, 0xe5, 0xe9, 0x00, 0x00, 0x70, 0x7f, 0x00, 0x04, 0xc9, 0x3c, 0x00,
+    0x00, 0x1e, 0x11, 0x00, 0x05, 0xdc, 0x14, 0x00, 0x00, 0x2f, 0x7e, 0x00,
+    0x00, 0x20, 0x5d, 0x00, 0x01, 0x23, 0x3e, 0x00, 0x00, 0x35, 0xa1, 0x00,
+    0x01, 0x53, 0xa5, 0x00, 0x00, 0x73, 0x18, 0x00, 0x00, 0x27, 0xd7, 0x00,
+    0x00, 0x55, 0x06, 0x00, 0x00, 0xce, 0xb2, 0x00, 0x00, 0x33, 0x25, 0x00,
+    0x00, 0x71, 0xa7, 0x00, 0x00, 0x0a, 0xf8, 0x00, 0x00, 0x17, 0xbc, 0x00,
+    0x00, 0x19, 0x00, 0x00, 0x00, 0x50, 0xbf, 0x00, 0x00, 0x59, 0x9f, 0x00,
+    0x00, 0x07, 0xf7, 0x00, 0x02, 0x4a, 0x12, 0x00, 0x00, 0xd6, 0x7f, 0x00,
+    0x01, 0xa9, 0x8f, 0x00, 0x00, 0x3e, 0x47, 0x00, 0x00, 0x08, 0x74, 0x00,
+    0x00, 0x5e, 0xde, 0x00, 0x03, 0x49, 0x4d, 0x00, 0x00, 0x40, 0x3f, 0x00,
+    0x00, 0x28, 0x51, 0x00, 0x00, 0x12, 0x73, 0x00, 0x00, 0x12, 0x68, 0x00,
+    0x00, 0x77, 0xfd, 0x00, 0x00, 0x9d, 0x04, 0x00, 0x00, 0x30, 0x84, 0x00,
+    0x00, 0x5d, 0xc6, 0x00, 0x00, 0xa9, 0x1c, 0x00, 0x00, 0x6a, 0xcf, 0x00,
+    0x00, 0xf2, 0xd2, 0x00, 0x00, 0x04, 0x2d, 0x00, 0x03, 0x71, 0x07, 0x00,
+    0x00, 0x5b, 0xab, 0x00, 0x00, 0x2a, 0x77, 0x00, 0x00, 0x1d, 0x6c, 0x00,
+    0x01, 0x07, 0xe6, 0x00, 0x00, 0xac, 0x0b, 0x00, 0x00, 0x88, 0x0e, 0x00,
+    0x00, 0x4c, 0xc4, 0x00, 0x00, 0x08, 0xd9, 0x00, 0x00, 0x3f, 0x6c, 0x00,
+    0x00, 0x3a, 0x2a, 0x00, 0x0c, 0xfa, 0xeb, 0x00, 0x02, 0xc9, 0xe0, 0x00,
+    0x00, 0x24, 0xca, 0x00, 0x00, 0x15, 0x70, 0x00, 0x01, 0xdc, 0x52, 0x00,
+    0x00, 0x21, 0x58, 0x00, 0x00, 0x30, 0x89, 0x00, 0x01, 0x0c, 0x95, 0x00,
+    0x00, 0x0e, 0x0c, 0x00, 0x00, 0x63, 0xda, 0x00, 0x00, 0x73, 0x95, 0x00,
+    0x00, 0x31, 0x99, 0x00, 0x00, 0x79, 0x0a, 0x00, 0x01, 0xae, 0x24, 0x00,
+    0x00, 0x4e, 0x0f, 0x00, 0x00, 0x47, 0x79, 0x00, 0x00, 0x09, 0x13, 0x00,
+    0x00, 0x51, 0x6f, 0x00, 0x00, 0x41, 0x81, 0x00, 0x00, 0xfb, 0xab, 0x00,
+    0x00, 0xa8, 0x33, 0x00, 0x00, 0xa8, 0xf0, 0x00, 0x03, 0xaf, 0x69, 0x00,
+    0x00, 0x7e, 0xbf, 0x00, 0x00, 0x31, 0xfe, 0x00, 0x01, 0x6e, 0x35, 0x00,
+    0x00, 0x6b, 0xf9, 0x00, 0x00, 0x41, 0x62, 0x00, 0x00, 0x33, 0x23, 0x00,
+    0x00, 0x93, 0x06, 0x00, 0x00, 0x04, 0xc3, 0x00, 0x00, 0x2f, 0x58, 0x00,
+    0x00, 0x18, 0xde, 0x00, 0x04, 0x18, 0xfd, 0x00, 0x00, 0xaa, 0x8f, 0x00,
+    0x00, 0x07, 0x54, 0x00, 0x00, 0x48, 0x79, 0x00, 0x00, 0x79, 0x71, 0x00,
+    0x00, 0x35, 0x8f, 0x00, 0x00, 0xc7, 0xd0, 0x00, 0x00, 0xed, 0xaa, 0x00,
+    0x00, 0xa9, 0xbb, 0x00, 0x00, 0x54, 0xbf, 0x00, 0x00, 0x6f, 0x41, 0x00,
+    0x00, 0x42, 0xf3, 0x00, 0x00, 0xb5, 0x66, 0x00, 0x00, 0x9b, 0x96, 0x00,
+    0x00, 0x30, 0x89, 0x00, 0x08, 0x51, 0x8e, 0x00, 0x00, 0x21, 0xf8, 0x00,
+    0x00, 0xcc, 0x0d, 0x00, 0x00, 0x11, 0xd3, 0x00, 0x00, 0x43, 0x54, 0x00,
+    0x00, 0x9f, 0x5b, 0x00, 0x00, 0x1c, 0xfd, 0x00, 0x00, 0x21, 0x07, 0x00,
+    0x00, 0x28, 0x6a, 0x00, 0x00, 0x38, 0xc8, 0x00, 0x00, 0xa4, 0xab, 0x00,
+    0x00, 0x15, 0x5c, 0x00, 0x00, 0x5d, 0x9d, 0x00, 0x00, 0x69, 0x9b, 0x00,
+    0x00, 0xad, 0x80, 0x00, 0x00, 0x64, 0x3c, 0x00, 0x00, 0x41, 0x4c, 0x00,
+    0x00, 0x52, 0x27, 0x00, 0x08, 0xf8, 0x07, 0x00, 0x00, 0xf3, 0x24, 0x00,
+    0x00, 0x40, 0xc0, 0x00, 0x00, 0x62, 0x17, 0x00, 0x01, 0x50, 0x9e, 0x00,
+    0x01, 0xb7, 0xb4, 0x00, 0x00, 0xef, 0x4d, 0x00, 0x00, 0x1f, 0x7f, 0x00,
+    0x03, 0x15, 0xdf, 0x00, 0x00, 0x1f, 0x5e, 0x00, 0x00, 0x4e, 0x23, 0x00,
+    0x00, 0x1f, 0x74, 0x00, 0x01, 0x4c, 0x5e, 0x00, 0x00, 0x3d, 0x8a, 0x00,
+    0x00, 0x13, 0xd5, 0x00, 0x00, 0x4d, 0x1e, 0x00, 0x01, 0xba, 0x5f, 0x00,
+    0x00, 0x0c, 0xd3, 0x00, 0x00, 0x5b, 0x32, 0x00, 0x01, 0x5f, 0xb7, 0x00,
+    0x01, 0x34, 0x18, 0x00, 0x00, 0x50, 0xd9, 0x00, 0x00, 0x52, 0x6f, 0x00,
+    0x00, 0x11, 0xa0, 0x00, 0x00, 0xac, 0xc9, 0x00, 0x00, 0x4f, 0x92, 0x00,
+    0x00, 0x15, 0xdb, 0x00, 0x00, 0x0e, 0x3c, 0x00, 0x00, 0x96, 0xc7, 0x00,
+    0x08, 0x4b, 0x33, 0x00, 0x01, 0x1d, 0xc2, 0x00, 0x03, 0x8c, 0xaf, 0x00,
+    0x00, 0x2c, 0xc4, 0x00, 0x00, 0x86, 0xec, 0x00, 0x00, 0x10, 0x9c, 0x00,
+    0x00, 0x36, 0xa7, 0x00, 0x00, 0x83, 0x07, 0x00, 0x00, 0x27, 0xaf, 0x00,
+    0x00, 0x8a, 0x92, 0x00, 0x00, 0xb4, 0xaa, 0x00, 0x00, 0x73, 0x59, 0x00,
+    0x00, 0x58, 0xcb, 0x00, 0x01, 0xd7, 0x49, 0x00, 0x01, 0xc9, 0x1a, 0x00,
+    0x00, 0x61, 0xff, 0x00, 0x00, 0x48, 0x3c, 0x00, 0x00, 0x30, 0xb5, 0x00,
+    0x05, 0x98, 0xfe, 0x00, 0x00, 0x50, 0xe0, 0x00, 0x00, 0x24, 0xb8, 0x00,
+    0x00, 0x08, 0xd7, 0x00, 0x03, 0x6a, 0xa6, 0x00, 0x06, 0x7a, 0x8a, 0x00,
+    0x00, 0x19, 0x36, 0x00, 0x00, 0x6a, 0xf4, 0x00, 0x00, 0x60, 0xc2, 0x00,
+    0x00, 0x6d, 0x2e, 0x00, 0x09, 0xd9, 0xd9, 0x00, 0x02, 0xaf, 0x58, 0x00,
+    0x00, 0xb7, 0x71, 0x00, 0x00, 0xc3, 0x0c, 0x00, 0x02, 0xa1, 0x16, 0x00,
+    0x05, 0x27, 0x86, 0x00, 0x00, 0x52, 0xa5, 0x00, 0x00, 0x61, 0x70, 0x00,
+    0x0a, 0x52, 0x99, 0x00, 0x00, 0x34, 0xa8, 0x00, 0x00, 0x45, 0x47, 0x00,
+    0x00, 0x13, 0x93, 0x00, 0x07, 0x69, 0x69, 0x00, 0x00, 0x4a, 0xc6, 0x00,
+    0x00, 0x07, 0xca, 0x00, 0x00, 0x21, 0x28, 0x00, 0x00, 0x69, 0x9d, 0x00,
+    0x00, 0x14, 0xe3, 0x00, 0x01, 0x14, 0xeb, 0x00, 0x00, 0x43, 0x40, 0x00,
+    0x00, 0x2c, 0xa1, 0x00, 0x00, 0x04, 0x6f, 0x00, 0x00, 0x9d, 0xdd, 0x00,
+    0x03, 0xbf, 0x34, 0x00, 0x00, 0x18, 0xb6, 0x00, 0x00, 0x8e, 0x71, 0x00,
+    0x02, 0xcf, 0x01, 0x00, 0x0b, 0x2b, 0x3f, 0x00, 0x00, 0x24, 0x1f, 0x00,
+    0x02, 0x8f, 0x6c, 0x00, 0x00, 0xc5, 0xcb, 0x00, 0x00, 0x7f, 0xf5, 0x00,
+    0x00, 0xe2, 0xaa, 0x00, 0x00, 0xc0, 0xbc, 0x00, 0x00, 0xf1, 0x04, 0x00,
+    0x00, 0x21, 0x51, 0x00, 0x00, 0x5d, 0x0e, 0x00, 0x00, 0x09, 0x27, 0x00,
+    0x00, 0x77, 0x1f, 0x00, 0x01, 0x40, 0x37, 0x00, 0x02, 0x3a, 0xf5, 0x00,
+    0x00, 0x0f, 0x70, 0x00, 0x00, 0x02, 0xfb, 0x00, 0x00, 0x40, 0x10, 0x00,
+    0x00, 0x14, 0x4f, 0x00, 0x00, 0x80, 0x45, 0x00, 0x00, 0x3a, 0xfd, 0x00,
+    0x00, 0x3f, 0x9a, 0x00, 0x0c, 0x1b, 0xa0, 0x00, 0x00, 0x10, 0xd6, 0x00,
+    0x00, 0x38, 0x95, 0x00, 0x00, 0x9c, 0x46, 0x00, 0x00, 0xd7, 0x9f, 0x00,
+    0x00, 0x71, 0xcd, 0x00, 0x00, 0x19, 0x3b, 0x00, 0x00, 0x7f, 0x8d, 0x00,
+    0x00, 0x10, 0xb0, 0x00, 0x00, 0xab, 0x43, 0x00, 0x01, 0x45, 0x3d, 0x00,
+    0x00, 0x63, 0x40, 0x00, 0x00, 0xad, 0x60, 0x00, 0x00, 0x6a, 0x32, 0x00,
+    0x00, 0x24, 0x58, 0x00, 0x00, 0x10, 0x98, 0x00, 0x00, 0x1a, 0x32, 0x00,
+    0x00, 0x30, 0x26, 0x00, 0x03, 0xb0, 0xed, 0x00, 0x00, 0xc4, 0x9f, 0x00,
+    0x00, 0x55, 0xbe, 0x00, 0x00, 0x44, 0x1a, 0x00, 0x00, 0xb4, 0xba, 0x00,
+    0x00, 0x1c, 0x65, 0x00, 0x01, 0x1b, 0x79, 0x00, 0x01, 0x16, 0x27, 0x00,
+    0x00, 0x16, 0x1c, 0x00, 0x00, 0x30, 0xfc, 0x00, 0x00, 0x5a, 0x1e, 0x00,
+    0x00, 0x89, 0x09, 0x00, 0x01, 0x5e, 0xf3, 0x00, 0x0b, 0x39, 0xf5, 0x00,
+    0x02, 0x16, 0xc0, 0x00, 0x01, 0x73, 0x01, 0x00, 0x00, 0x52, 0xf0, 0x00,
+    0x05, 0x8a, 0x17, 0x00, 0x00, 0x6c, 0x46, 0x00, 0x00, 0x5d, 0xf0, 0x00,
+    0x00, 0xb6, 0xae, 0x00, 0x01, 0xa2, 0x77, 0x00, 0x01, 0xea, 0x8f, 0x00,
+    0x00, 0x45, 0x8a, 0x00, 0x00, 0x48, 0xed, 0x00, 0x00, 0x22, 0xc9, 0x00,
+    0x00, 0x3d, 0x8d, 0x00, 0x00, 0x86, 0xef, 0x00, 0x00, 0x3a, 0x20, 0x00,
+    0x00, 0x44, 0x13, 0x00, 0x01, 0x22, 0x7c, 0x00, 0x00, 0x25, 0xbc, 0x00,
+    0x00, 0x15, 0x2f, 0x00, 0x00, 0x08, 0x91, 0x00, 0x04, 0xcb, 0x6a, 0x00,
+    0x00, 0x30, 0x31, 0x00, 0x00, 0x0d, 0x0a, 0x00, 0x00, 0x8c, 0x62, 0x00,
+    0x01, 0xae, 0x2d, 0x00, 0x02, 0x43, 0x2a, 0x00, 0x00, 0x8f, 0x41, 0x00,
+    0x00, 0x74, 0x33, 0x00, 0x06, 0x05, 0xda, 0x00, 0x00, 0x12, 0xc8, 0x00,
+    0x03, 0xf2, 0x77, 0x00, 0x01, 0xba, 0xb2, 0x00, 0x00, 0xa6, 0x82, 0x00,
+    0x00, 0x3b, 0x8d, 0x00, 0x00, 0x23, 0xa7, 0x00, 0x00, 0x7a, 0x30, 0x00,
+    0x01, 0x19, 0xb9, 0x00, 0x00, 0x24, 0xff, 0x00, 0x00, 0x44, 0xf4, 0x00,
+    0x00, 0x3d, 0xf2, 0x00, 0x00, 0x11, 0xef, 0x00, 0x00, 0x11, 0x48, 0x00,
+    0x00, 0x41, 0x9c, 0x00, 0x00, 0xce, 0xdc, 0x00, 0x00, 0x42, 0x90, 0x00,
+    0x00, 0x1a, 0xa6, 0x00, 0x00, 0x3a, 0x3e, 0x00, 0x03, 0x1a, 0xb6, 0x00,
+    0x00, 0x20, 0xd1, 0x00, 0x00, 0x32, 0x98, 0x00, 0x00, 0x5e, 0x10, 0x00,
+    0x00, 0x47, 0x37, 0x00, 0x00, 0xfc, 0xa2, 0x00, 0x00, 0x1a, 0xdb, 0x00,
+    0x00, 0x10, 0x51, 0x00, 0x00, 0xa3, 0xa7, 0x00, 0x00, 0x57, 0x55, 0x00,
+    0x00, 0x48, 0x92, 0x00, 0x00, 0x2c, 0x68, 0x00, 0x00, 0x03, 0xcc, 0x00,
+    0x01, 0xa2, 0x83, 0x00, 0x00, 0x13, 0xb3, 0x00, 0x00, 0xb6, 0x6a, 0x00,
+    0x00, 0x15, 0xec, 0x00, 0x00, 0x18, 0x19, 0x00, 0x00, 0x01, 0xf3, 0x00,
+    0x01, 0x47, 0x16, 0x00, 0x00, 0x9d, 0x7e, 0x00, 0x00, 0x31, 0xe0, 0x00,
+    0x00, 0x75, 0xef, 0x00, 0x01, 0x57, 0xf1, 0x00, 0x00, 0x5f, 0x8e, 0x00,
+    0x00, 0x7a, 0xeb, 0x00, 0x01, 0x8b, 0xaf, 0x00, 0x00, 0x46, 0x5d, 0x00,
+    0x00, 0x4a, 0x1f, 0x00, 0x00, 0x5b, 0x22, 0x00, 0x00, 0x50, 0xf5, 0x00,
+    0x00, 0x29, 0x48, 0x00, 0x03, 0x08, 0x06, 0x00, 0x00, 0x8a, 0x71, 0x00,
+    0x07, 0x01, 0xb5, 0x00, 0x00, 0x65, 0x94, 0x00, 0x05, 0xad, 0x87, 0x00,
+    0x01, 0xf1, 0x95, 0x00, 0x00, 0x51, 0x39, 0x00, 0x01, 0x1e, 0xaf, 0x00,
+    0x00, 0x45, 0x8a, 0x00, 0x00, 0x0d, 0x34, 0x00, 0x00, 0x10, 0x91, 0x00,
+    0x00, 0x71, 0xc7, 0x00, 0x00, 0x46, 0xbc, 0x00, 0x01, 0x42, 0xda, 0x00,
+    0x00, 0xa7, 0x56, 0x00, 0x00, 0xec, 0x56, 0x00, 0x00, 0x4b, 0xec, 0x00,
+    0x00, 0xd0, 0x79, 0x00, 0x00, 0x0e, 0x92, 0x00, 0x00, 0x1f, 0x1c, 0x00,
+    0x00, 0x10, 0x24, 0x00, 0x00, 0x0c, 0x84, 0x00, 0x00, 0xc0, 0x12, 0x00,
+    0x0c, 0xee, 0x2b, 0x00, 0x00, 0x2c, 0x74, 0x00, 0x00, 0x4a, 0x25, 0x00,
+    0x00, 0x20, 0xd3, 0x00, 0x00, 0x2f, 0x03, 0x00, 0x00, 0x1d, 0xcf, 0x00,
+    0x00, 0x27, 0x94, 0x00, 0x00, 0x4f, 0xeb, 0x00, 0x00, 0x4b, 0x71, 0x00,
+    0x00, 0x7c, 0x72, 0x00, 0x00, 0x20, 0xd0, 0x00, 0x00, 0x7d, 0x33, 0x00,
+    0x00, 0x5f, 0x74, 0x00, 0x00, 0x24, 0xf0, 0x00, 0x00, 0x58, 0x06, 0x00,
+    0x00, 0x19, 0xca, 0x00, 0x00, 0x25, 0x1f, 0x00, 0x01, 0x3f, 0xb2, 0x00,
+    0x00, 0x41, 0x54, 0x00, 0x00, 0x08, 0x69, 0x00, 0x00, 0x2d, 0x06, 0x00,
+    0x00, 0x36, 0xe3, 0x00, 0x00, 0x9f, 0xc1, 0x00, 0x01, 0xf7, 0x88, 0x00,
+    0x00, 0x0b, 0x7d, 0x00, 0x00, 0xf2, 0x29, 0x00, 0x00, 0x51, 0xe4, 0x00,
+    0x00, 0x25, 0xa8, 0x00, 0x00, 0x0d, 0x27, 0x00, 0x00, 0x45, 0x4b, 0x00,
+    0x00, 0x86, 0xc8, 0x00, 0x00, 0x38, 0xb0, 0x00, 0x03, 0x6f, 0x2a, 0x00,
+    0x00, 0x0b, 0x29, 0x00, 0x00, 0x09, 0x3e, 0x00, 0x08, 0xa3, 0xbb, 0x00,
+    0x00, 0x24, 0x5e, 0x00, 0x01, 0x2e, 0xc1, 0x00, 0x00, 0xab, 0xf1, 0x00,
+    0x00, 0x5a, 0xfd, 0x00, 0x00, 0x75, 0x72, 0x00, 0x01, 0xad, 0xe0, 0x00,
+    0x00, 0x44, 0x58, 0x00, 0x00, 0xa0, 0x22, 0x00, 0x00, 0x4d, 0xd0, 0x00,
+    0x00, 0x81, 0xbf, 0x00, 0x00, 0x0a, 0xb4, 0x00, 0x01, 0x28, 0x66, 0x00,
+    0x01, 0x15, 0xcc, 0x00, 0x00, 0x44, 0x9d, 0x00, 0x00, 0x5f, 0x13, 0x00,
+    0x00, 0x90, 0x9a, 0x00, 0x00, 0x63, 0x5d, 0x00, 0x03, 0xb0, 0x55, 0x00,
+    0x00, 0x51, 0xcf, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x17, 0x73, 0x00,
+    0x00, 0x92, 0x59, 0x00, 0x00, 0x17, 0x92, 0x00, 0x00, 0x8a, 0xca, 0x00,
+    0x00, 0x72, 0x01, 0x00, 0x00, 0x4a, 0x6a, 0x00, 0x01, 0x59, 0xd8, 0x00,
+    0x00, 0x04, 0x22, 0x00, 0x00, 0x39, 0xf9, 0x00, 0x00, 0x0b, 0x6c, 0x00,
+    0x00, 0x35, 0x53, 0x00, 0x00, 0x1f, 0x65, 0x00, 0x00, 0x41, 0xc3, 0x00,
+    0x00, 0x9a, 0x6c, 0x00, 0x00, 0x43, 0x1f, 0x00, 0x00, 0xa2, 0x68, 0x00,
+    0x00, 0x35, 0x75, 0x00, 0x02, 0x39, 0x02, 0x00, 0x00, 0xc0, 0xb0, 0x00,
+    0x00, 0x3e, 0x83, 0x00, 0x06, 0x98, 0xfc, 0x00, 0x00, 0x70, 0x63, 0x00,
+    0x00, 0x23, 0x16, 0x00, 0x00, 0x08, 0xd8, 0x00, 0x01, 0x4d, 0xd7, 0x00,
+    0x00, 0x27, 0x51, 0x00, 0x06, 0xb5, 0x39, 0x00, 0x02, 0x44, 0x1f, 0x00,
+    0x01, 0x4f, 0xc2, 0x00, 0x00, 0x6c, 0xfc, 0x00, 0x00, 0xab, 0x60, 0x00,
+    0x00, 0x84, 0x7d, 0x00, 0x02, 0x2d, 0x3c, 0x00, 0x00, 0x59, 0x46, 0x00,
+    0x00, 0x94, 0xe4, 0x00, 0x00, 0x6b, 0xcb, 0x00, 0x00, 0x1f, 0x69, 0x00,
+    0x00, 0x8c, 0x07, 0x00, 0x00, 0x21, 0x25, 0x00, 0x00, 0x46, 0x39, 0x00,
+    0x01, 0x64, 0x03, 0x00, 0x00, 0x1a, 0xc9, 0x00, 0x08, 0x47, 0x81, 0x00,
+    0x00, 0x7c, 0x80, 0x00, 0x00, 0x9c, 0xec, 0x00, 0x00, 0x20, 0xae, 0x00,
+    0x00, 0x44, 0x31, 0x00, 0x00, 0x32, 0x08, 0x00, 0x00, 0x1b, 0xce, 0x00,
+    0x02, 0xb7, 0x3d, 0x00, 0x00, 0x4e, 0xb6, 0x00, 0x00, 0x79, 0xb6, 0x00,
+    0x00, 0x3f, 0x74, 0x00, 0x00, 0x92, 0x3d, 0x00, 0x00, 0x0f, 0x88, 0x00,
+    0x11, 0x75, 0x8a, 0x00, 0x00, 0x3b, 0x9c, 0x00, 0x00, 0x1f, 0x55, 0x00,
+    0x01, 0x11, 0x74, 0x00, 0x01, 0x9e, 0x24, 0x00, 0x00, 0x95, 0x26, 0x00,
+    0x00, 0x13, 0x12, 0x00, 0x00, 0x87, 0x1f, 0x00, 0x00, 0x4f, 0xb8, 0x00,
+    0x00, 0xeb, 0x85, 0x00, 0x00, 0x48, 0xde, 0x00, 0x00, 0x2b, 0xc1, 0x00,
+    0x00, 0x09, 0x39, 0x00, 0x00, 0x27, 0x79, 0x00, 0x02, 0x0b, 0xa3, 0x00,
+    0x00, 0x03, 0x70, 0x00, 0x00, 0x58, 0x01, 0x00, 0x00, 0x16, 0x32, 0x00,
+    0x00, 0x45, 0xe2, 0x00, 0x00, 0x13, 0x26, 0x00, 0x00, 0xdb, 0xc2, 0x00,
+    0x00, 0x5e, 0xe7, 0x00, 0x00, 0x09, 0x19, 0x00, 0x00, 0x07, 0x82, 0x00,
+    0x00, 0x2c, 0xa9, 0x00, 0x00, 0xb9, 0x9f, 0x00, 0x00, 0x2b, 0x79, 0x00,
+    0x01, 0x7f, 0x63, 0x00, 0x00, 0x21, 0x04, 0x00, 0x00, 0x3b, 0x06, 0x00,
+    0x00, 0x99, 0xdc, 0x00, 0x00, 0x1a, 0xed, 0x00, 0x00, 0xbd, 0xd1, 0x00,
+    0x00, 0x1f, 0xeb, 0x00, 0x02, 0x0e, 0xd3, 0x00, 0x01, 0x49, 0x65, 0x00,
+    0x00, 0x0d, 0x4f, 0x00, 0x00, 0x49, 0x68, 0x00, 0x00, 0x00, 0x72, 0x00,
+    0x00, 0x2b, 0x38, 0x00, 0x00, 0x0f, 0x27, 0x00, 0x00, 0x05, 0x35, 0x00,
+    0x00, 0x0c, 0x63, 0x00, 0x01, 0xc0, 0x3c, 0x00, 0x00, 0x4f, 0xc3, 0x00,
+    0x00, 0x26, 0x75, 0x00, 0x00, 0x9d, 0xea, 0x00, 0x00, 0x46, 0x4c, 0x00,
+    0x00, 0xc0, 0xfc, 0x00, 0x00, 0x50, 0xcb, 0x00, 0x15, 0x5e, 0x02, 0x00,
+    0x01, 0x6e, 0x6d, 0x00, 0x00, 0x2c, 0x98, 0x00, 0x00, 0x13, 0x75, 0x00,
+    0x00, 0x8f, 0x69, 0x00, 0x00, 0x35, 0x5e, 0x00, 0x00, 0x28, 0x30, 0x00,
+    0x00, 0x0b, 0x1d, 0x00, 0x00, 0x1e, 0x51, 0x00, 0x00, 0xfc, 0xf0, 0x00,
+    0x00, 0x76, 0x68, 0x00, 0x00, 0x8a, 0x05, 0x00, 0x00, 0x37, 0x01, 0x00,
+    0x00, 0x55, 0xad, 0x00, 0x00, 0x40, 0xf3, 0x00, 0x00, 0x47, 0x6a, 0x00,
+    0x00, 0x4a, 0x88, 0x00, 0x00, 0x05, 0xce, 0x00, 0x00, 0x5c, 0x9c, 0x00,
+    0x01, 0xc2, 0x07, 0x00, 0x00, 0x9f, 0x94, 0x00, 0x00, 0x29, 0x75, 0x00,
+    0x00, 0x8b, 0x58, 0x00, 0x02, 0xc9, 0x7b, 0x00, 0x00, 0x4b, 0x5f, 0x00,
+    0x00, 0x2b, 0x5a, 0x00, 0x00, 0x25, 0xe8, 0x00, 0x00, 0x3e, 0x2d, 0x00,
+    0x00, 0x59, 0x0f, 0x00, 0x02, 0xc4, 0x1d, 0x00, 0x00, 0x0b, 0x8f, 0x00,
+    0x00, 0x4e, 0x2a, 0x00, 0x00, 0x46, 0x45, 0x00, 0x00, 0xeb, 0xfa, 0x00,
+    0x00, 0x4c, 0x45, 0x00, 0x01, 0x12, 0xaf, 0x00, 0x00, 0x0f, 0xd2, 0x00,
+    0x00, 0x5a, 0x8f, 0x00, 0x00, 0xfc, 0x72, 0x00, 0x10, 0x2b, 0x55, 0x00,
+    0x05, 0xb1, 0x78, 0x00, 0x01, 0x67, 0x75, 0x00, 0x00, 0x3d, 0x7e, 0x00,
+    0x01, 0x8f, 0x43, 0x00, 0x00, 0x43, 0x98, 0x00, 0x00, 0x2b, 0x59, 0x00,
+    0x00, 0x2e, 0x35, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x42, 0xa3, 0x00,
+    0x01, 0x29, 0x6f, 0x00, 0x00, 0x0e, 0xee, 0x00, 0x0c, 0xca, 0xda, 0x00,
+    0x00, 0xa0, 0xee, 0x00, 0x00, 0x23, 0x13, 0x00, 0x00, 0x19, 0xe9, 0x00,
+    0x00, 0x18, 0x47, 0x00, 0x02, 0x30, 0x8b, 0x00, 0x00, 0x4a, 0xa3, 0x00,
+    0x00, 0x1e, 0xd4, 0x00, 0x00, 0x75, 0xb7, 0x00, 0x02, 0x18, 0xef, 0x00,
+    0x00, 0x29, 0x23, 0x00, 0x00, 0x48, 0x14, 0x00, 0x00, 0x35, 0x5d, 0x00,
+    0x00, 0xc9, 0x8f, 0x00, 0x00, 0x5c, 0x0d, 0x00, 0x00, 0x8c, 0xb5, 0x00,
+    0x00, 0xb6, 0xb0, 0x00, 0x00, 0x1d, 0x54, 0x00, 0x00, 0x6a, 0xe3, 0x00,
+    0x00, 0xe6, 0xa6, 0x00, 0x00, 0x85, 0xb1, 0x00, 0x02, 0x3d, 0x2c, 0x00,
+    0x00, 0x50, 0x74, 0x00, 0x00, 0x2b, 0x83, 0x00, 0x00, 0x05, 0x19, 0x00,
+    0x01, 0xe4, 0xb9, 0x00, 0x01, 0x0e, 0x37, 0x00, 0x00, 0x11, 0x5b, 0x00,
+    0x00, 0x06, 0xca, 0x00, 0x00, 0x4e, 0x41, 0x00, 0x00, 0x2a, 0x2b, 0x00,
+    0x00, 0x08, 0x1d, 0x00, 0x00, 0x15, 0xef, 0x00, 0x00, 0x18, 0xad, 0x00,
+    0x00, 0x2c, 0xf3, 0x00, 0x02, 0xf6, 0x7d, 0x00, 0x00, 0x0c, 0x0a, 0x00,
+    0x00, 0x25, 0x04, 0x00, 0x00, 0x4c, 0xbd, 0x00, 0x00, 0x56, 0x95, 0x00,
+    0x00, 0x5c, 0x33, 0x00, 0x00, 0x48, 0x6b, 0x00, 0x03, 0x98, 0x45, 0x00,
+    0x00, 0x2f, 0xa5, 0x00, 0x00, 0x9d, 0x46, 0x00, 0x03, 0xb3, 0x27, 0x00,
+    0x01, 0x94, 0xd6, 0x00, 0x00, 0x1b, 0x56, 0x00, 0x01, 0xe4, 0x66, 0x00,
+    0x00, 0x25, 0x83, 0x00, 0x00, 0x1f, 0x96, 0x00, 0x0d, 0x6f, 0x6b, 0x00,
+    0x02, 0xff, 0x86, 0x00, 0x01, 0x56, 0x96, 0x00, 0x00, 0x38, 0x8e, 0x00,
+    0x01, 0x68, 0x31, 0x00, 0x00, 0x19, 0x15, 0x00, 0x00, 0xad, 0xa9, 0x00,
+    0x09, 0xa0, 0x40, 0x00, 0x00, 0x08, 0x5a, 0x00, 0x02, 0x35, 0xcf, 0x00,
+    0x00, 0xb4, 0x06, 0x00, 0x00, 0x86, 0xfb, 0x00, 0x30, 0xeb, 0xaf, 0x00,
+    0x00, 0x9d, 0x87, 0x00, 0x00, 0x88, 0x8b, 0x00, 0x00, 0x1b, 0xf1, 0x00,
+    0x01, 0x1f, 0x3e, 0x00, 0x00, 0xfb, 0xf9, 0x00, 0x0d, 0x19, 0xa1, 0x00,
+    0x00, 0x53, 0x9b, 0x00, 0x00, 0x0b, 0x9d, 0x00, 0x04, 0xaf, 0x70, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x2c, 0xbf, 0x00, 0x00, 0x53, 0x7d, 0x00,
+    0x00, 0x91, 0xf4, 0x00, 0x00, 0x14, 0x7f, 0x00, 0x01, 0x03, 0x3e, 0x00,
+    0x00, 0x0c, 0xf0, 0x00, 0x01, 0xf3, 0xd6, 0x00, 0x00, 0x10, 0xe5, 0x00,
+    0x00, 0x8a, 0x08, 0x00, 0x00, 0xd2, 0x07, 0x00, 0x01, 0x84, 0x1d, 0x00,
+    0x00, 0x2f, 0x0c, 0x00, 0x00, 0x53, 0xfd, 0x00, 0x00, 0x21, 0xaa, 0x00,
+    0x00, 0x66, 0x50, 0x00, 0x00, 0x34, 0xaa, 0x00, 0x05, 0xea, 0x8a, 0x00,
+    0x00, 0x44, 0x6a, 0x00, 0x00, 0x35, 0x87, 0x00, 0x00, 0x5d, 0xd6, 0x00,
+    0x00, 0x90, 0xaf, 0x00, 0x00, 0x11, 0xe0, 0x00, 0x00, 0x23, 0x99, 0x00,
+    0x00, 0x7c, 0xc7, 0x00, 0x00, 0x48, 0x8f, 0x00, 0x00, 0xc8, 0xde, 0x00,
+    0x00, 0x57, 0x96, 0x00, 0x00, 0x2a, 0x86, 0x00, 0x00, 0x2f, 0x97, 0x00,
+    0x00, 0x4c, 0x96, 0x00, 0x00, 0x13, 0x54, 0x00, 0x00, 0x8a, 0x10, 0x00,
+    0x00, 0x49, 0x3d, 0x00, 0x00, 0x1c, 0x0d, 0x00, 0x00, 0x10, 0x7b, 0x00,
+    0x02, 0xaa, 0xaa, 0x00, 0x00, 0x43, 0x39, 0x00, 0x00, 0xf3, 0xfb, 0x00,
+    0x00, 0x2c, 0x72, 0x00, 0x01, 0x10, 0x01, 0x00, 0x00, 0x4a, 0x4d, 0x00,
+    0x00, 0x38, 0x21, 0x00, 0x00, 0x71, 0x6b, 0x00, 0x00, 0x7d, 0x5f, 0x00,
+    0x01, 0x21, 0x96, 0x00, 0x00, 0x7d, 0xf5, 0x00, 0x00, 0x1b, 0xb4, 0x00,
+    0x00, 0x27, 0x0f, 0x00, 0x00, 0x10, 0x38, 0x00, 0x00, 0x28, 0x7c, 0x00,
+    0x07, 0xe5, 0xa7, 0x00, 0x00, 0x27, 0x5f, 0x00, 0x00, 0x63, 0xa6, 0x00,
+    0x00, 0xe4, 0x56, 0x00, 0x03, 0xc0, 0x9b, 0x00, 0x00, 0x23, 0x67, 0x00,
+    0x00, 0x13, 0x88, 0x00, 0x00, 0x14, 0x43, 0x00, 0x03, 0x83, 0xbf, 0x00,
+    0x02, 0x16, 0x03, 0x00, 0x00, 0xf7, 0x6d, 0x00, 0x00, 0x1a, 0xfb, 0x00,
+    0x00, 0xb4, 0x4f, 0x00, 0x00, 0x35, 0x1d, 0x00, 0x00, 0xa3, 0x71, 0x00,
+    0x01, 0xb3, 0xa1, 0x00, 0x04, 0x76, 0xea, 0x00, 0x00, 0x2f, 0x0d, 0x00,
+    0x00, 0xa4, 0xa0, 0x00, 0x00, 0x11, 0x69, 0x00, 0x00, 0x6d, 0xe1, 0x00,
+    0x07, 0x43, 0x9c, 0x00, 0x00, 0x5d, 0x10, 0x00, 0x01, 0x4c, 0x83, 0x00,
+    0x02, 0x25, 0xab, 0x00, 0x00, 0x33, 0xcf, 0x00, 0x00, 0x91, 0x8b, 0x00,
+    0x00, 0x7c, 0x1b, 0x00, 0x00, 0x68, 0xbf, 0x00, 0x16, 0xf0, 0xaf, 0x00,
+    0x00, 0x3e, 0xf6, 0x00, 0x00, 0x20, 0x3c, 0x00, 0x00, 0x4e, 0x4d, 0x00,
+    0x00, 0x44, 0xe8, 0x00, 0x00, 0x85, 0x6a, 0x00, 0x00, 0xbe, 0x91, 0x00,
+    0x00, 0xa1, 0x98, 0x00, 0x00, 0x6b, 0xec, 0x00, 0x01, 0xac, 0x2d, 0x00,
+    0x01, 0xe7, 0xe8, 0x00, 0x00, 0x05, 0x54, 0x00, 0x00, 0x8b, 0xc0, 0x00,
+    0x00, 0x40, 0xdf, 0x00, 0x00, 0x08, 0xa7, 0x00, 0x00, 0x0d, 0xb1, 0x00,
+    0x01, 0x18, 0xf9, 0x00, 0x00, 0x44, 0x2a, 0x00, 0x00, 0x2c, 0xf9, 0x00,
+    0x00, 0x11, 0xd4, 0x00, 0x00, 0x27, 0x09, 0x00, 0x00, 0xc6, 0x2e, 0x00,
+    0x00, 0x0a, 0x9a, 0x00, 0x00, 0x6f, 0x4d, 0x00, 0x01, 0x64, 0xc6, 0x00,
+    0x00, 0x38, 0xdc, 0x00, 0x00, 0x40, 0x75, 0x00, 0x00, 0x3a, 0xf3, 0x00,
+    0x00, 0x3a, 0xe3, 0x00, 0x01, 0x93, 0x84, 0x00, 0x00, 0x82, 0x78, 0x00,
+    0x00, 0x7e, 0xd1, 0x00, 0x01, 0x25, 0xc6, 0x00, 0x00, 0xe6, 0x07, 0x00,
+    0x01, 0x49, 0xf6, 0x00, 0x00, 0x0a, 0x05, 0x00, 0x00, 0x1f, 0x80, 0x00,
+    0x00, 0x36, 0x40, 0x00, 0x00, 0x38, 0x58, 0x00, 0x00, 0x78, 0x11, 0x00,
+    0x03, 0x6c, 0x65, 0x00, 0x00, 0x15, 0x3d, 0x00, 0x00, 0x66, 0x7a, 0x00,
+    0x00, 0x8a, 0xae, 0x00, 0x00, 0x37, 0x53, 0x00, 0x00, 0x19, 0x81, 0x00,
+    0x00, 0x20, 0x92, 0x00, 0x00, 0x5f, 0x24, 0x00, 0x00, 0xf4, 0x29, 0x00,
+    0x02, 0x3c, 0xaf, 0x00, 0x00, 0xbc, 0x3a, 0x00, 0x00, 0xd1, 0x97, 0x00,
+    0x00, 0x0f, 0x1b, 0x00, 0x00, 0x44, 0xa7, 0x00, 0x02, 0xd9, 0x99, 0x00,
+    0x00, 0x3c, 0xbd, 0x00, 0x00, 0xd5, 0x2e, 0x00, 0x00, 0x06, 0xcb, 0x00,
+    0x00, 0x47, 0x05, 0x00, 0x00, 0x7a, 0xea, 0x00, 0x00, 0x8d, 0x40, 0x00,
+    0x00, 0x89, 0x9a, 0x00, 0x00, 0x3c, 0x49, 0x00, 0x00, 0x22, 0x65, 0x00,
+    0x00, 0x22, 0xde, 0x00, 0x01, 0x40, 0xc3, 0x00, 0x00, 0xad, 0xfa, 0x00,
+    0x00, 0x9b, 0x16, 0x00, 0x00, 0x1f, 0x24, 0x00, 0x00, 0xca, 0x8b, 0x00,
+    0x01, 0xe1, 0xfa, 0x00, 0x00, 0xac, 0x67, 0x00, 0x00, 0x91, 0x36, 0x00,
+    0x00, 0x18, 0x8d, 0x00, 0x00, 0x19, 0xe7, 0x00, 0x00, 0x1b, 0xeb, 0x00,
+    0x00, 0x2e, 0xec, 0x00, 0x00, 0x2c, 0x50, 0x00, 0x00, 0x2b, 0x04, 0x00,
+    0x00, 0x58, 0xe6, 0x00, 0x00, 0x1e, 0xea, 0x00, 0x00, 0x52, 0x1e, 0x00,
+    0x00, 0x30, 0xa8, 0x00, 0x00, 0x62, 0x4d, 0x00, 0x00, 0x18, 0x90, 0x00,
+    0x00, 0x27, 0x1b, 0x00, 0x00, 0x26, 0xe3, 0x00, 0x00, 0x41, 0xc5, 0x00,
+    0x00, 0x32, 0xfd, 0x00, 0x00, 0x23, 0xc6, 0x00, 0x07, 0x79, 0x5b, 0x00,
+    0x00, 0x0e, 0xa4, 0x00, 0x00, 0x8f, 0xff, 0x00, 0x00, 0x06, 0xa8, 0x00,
+    0x00, 0x2f, 0xb5, 0x00, 0x00, 0x55, 0x8d, 0x00, 0x0d, 0xb3, 0x80, 0x00,
+    0x00, 0x27, 0x3a, 0x00, 0x00, 0x29, 0x4f, 0x00, 0x00, 0x57, 0x5f, 0x00,
+    0x00, 0x2c, 0x6d, 0x00, 0x00, 0x20, 0x72, 0x00, 0x00, 0xba, 0xbf, 0x00,
+    0x00, 0xb2, 0xd8, 0x00, 0x0b, 0x72, 0xc1, 0x00, 0x00, 0xed, 0x93, 0x00,
+    0x00, 0x16, 0xc2, 0x00, 0x00, 0x48, 0xe5, 0x00, 0x00, 0xf5, 0x75, 0x00,
+    0x00, 0x5d, 0xd9, 0x00, 0x00, 0x7f, 0x99, 0x00, 0x00, 0x59, 0xb6, 0x00,
+    0x01, 0x55, 0x55, 0x00, 0x00, 0x95, 0x5d, 0x00, 0x00, 0x19, 0x02, 0x00,
+    0x01, 0x2b, 0x59, 0x00, 0x00, 0x34, 0x5e, 0x00, 0x01, 0x32, 0x2e, 0x00,
+    0x00, 0x26, 0xdd, 0x00, 0x00, 0x2e, 0x16, 0x00, 0x00, 0x28, 0x74, 0x00,
+    0x03, 0x0b, 0x0c, 0x00, 0x00, 0x2a, 0x6f, 0x00, 0x00, 0x25, 0xcc, 0x00,
+    0x04, 0x25, 0xac, 0x00, 0x00, 0x78, 0xea, 0x00, 0x00, 0xf7, 0x93, 0x00,
+    0x00, 0x67, 0xe5, 0x00, 0x00, 0x1a, 0x03, 0x00, 0x01, 0x0e, 0xbb, 0x00,
+    0x00, 0xcc, 0xfd, 0x00, 0x01, 0x39, 0xe3, 0x00, 0x04, 0xa1, 0x28, 0x00,
+    0x01, 0xcc, 0xcb, 0x00, 0x06, 0x3c, 0x5d, 0x00, 0x00, 0xc0, 0xdd, 0x00,
+    0x00, 0xbe, 0xe8, 0x00, 0x00, 0xfa, 0x78, 0x00, 0x00, 0x09, 0xd9, 0x00,
+    0x00, 0x5b, 0xe6, 0x00, 0x00, 0x82, 0xcc, 0x00, 0x02, 0x04, 0xa3, 0x00,
+    0x00, 0x1b, 0x6e, 0x00, 0x01, 0xd9, 0x21, 0x00, 0x00, 0x2d, 0x8a, 0x00,
+    0x0c, 0xa3, 0x28, 0x00, 0x00, 0x5d, 0xd8, 0x00, 0x00, 0x90, 0x57, 0x00,
+    0x0f, 0x95, 0x0a, 0x00, 0x01, 0x36, 0x07, 0x00, 0x00, 0xd3, 0xa4, 0x00,
+    0x00, 0x66, 0x21, 0x00, 0x00, 0xfa, 0x31, 0x00, 0x00, 0x20, 0x7c, 0x00,
+    0x00, 0x83, 0x02, 0x00, 0x00, 0x3e, 0x6e, 0x00, 0x01, 0x98, 0xdb, 0x00,
+    0x00, 0xea, 0xc3, 0x00, 0x00, 0x1a, 0xac, 0x00, 0x03, 0x53, 0xce, 0x00,
+    0x00, 0x1b, 0xe2, 0x00, 0x09, 0x0f, 0xba, 0x00, 0x00, 0x47, 0x84, 0x00,
+    0x00, 0x0b, 0x86, 0x00, 0x00, 0xa4, 0x6f, 0x00, 0x04, 0x5a, 0x1e, 0x00,
+    0x00, 0x2a, 0xd2, 0x00, 0x00, 0x1e, 0xe8, 0x00, 0x01, 0xd2, 0xca, 0x00,
+    0x00, 0x4c, 0xdf, 0x00, 0x00, 0x94, 0x50, 0x00, 0x00, 0x9e, 0x71, 0x00,
+    0x00, 0x1a, 0x7a, 0x00, 0x00, 0x55, 0xe0, 0x00, 0x00, 0xa0, 0xa6, 0x00,
+    0x01, 0x70, 0x41, 0x00, 0x01, 0x0a, 0xd1, 0x00, 0x01, 0x83, 0x53, 0x00,
+    0x00, 0x21, 0xe8, 0x00, 0x00, 0x7d, 0x95, 0x00, 0x00, 0x16, 0x90, 0x00,
+    0x00, 0x26, 0x0d, 0x00, 0x00, 0x59, 0x8b, 0x00, 0x00, 0x29, 0x60, 0x00,
+    0x02, 0x17, 0x08, 0x00, 0x00, 0x41, 0x68, 0x00, 0x00, 0xb7, 0xff, 0x00,
+    0x00, 0x22, 0x07, 0x00, 0x00, 0x75, 0xa9, 0x00, 0x00, 0x29, 0xdc, 0x00,
+    0x00, 0x48, 0x09, 0x00, 0x00, 0x36, 0x0e, 0x00, 0x01, 0xd1, 0xaa, 0x00,
+    0x00, 0x5b, 0x52, 0x00, 0x00, 0x54, 0xe7, 0x00, 0x02, 0x62, 0x6d, 0x00,
+    0x07, 0x7b, 0x8a, 0x00, 0x00, 0x38, 0x8d, 0x00, 0x00, 0x26, 0x98, 0x00,
+    0x00, 0x1b, 0x26, 0x00, 0x00, 0x59, 0x9b, 0x00, 0x00, 0x09, 0xf3, 0x00,
+    0x00, 0x30, 0x0c, 0x00, 0x00, 0x8d, 0x0d, 0x00, 0x00, 0x43, 0x20, 0x00,
+    0x01, 0x06, 0x21, 0x00, 0x0b, 0xde, 0x53, 0x00, 0x0c, 0x4b, 0xcd, 0x00,
+    0x00, 0x58, 0x4d, 0x00, 0x00, 0x81, 0x1e, 0x00, 0x00, 0xc5, 0x4f, 0x00,
+    0x00, 0x85, 0x50, 0x00, 0x00, 0x63, 0x35, 0x00, 0x00, 0x66, 0x49, 0x00,
+    0x00, 0x81, 0x3b, 0x00, 0x00, 0xd0, 0x4b, 0x00, 0x00, 0x27, 0x42, 0x00,
+    0x4f, 0x30, 0x39, 0x00, 0x00, 0x29, 0xab, 0x00, 0x00, 0xe1, 0xf7, 0x00,
+    0x04, 0x15, 0x7a, 0x00, 0x00, 0xd3, 0x5a, 0x00, 0x00, 0x89, 0xb7, 0x00,
+    0x00, 0x51, 0xc6, 0x00, 0x00, 0x0f, 0x8f, 0x00, 0x03, 0xe4, 0x06, 0x00,
+    0x00, 0x36, 0x24, 0x00, 0x01, 0xd3, 0x5f, 0x00, 0x00, 0x36, 0x30, 0x00,
+    0x00, 0x02, 0x12, 0x00, 0x00, 0x1d, 0xdf, 0x00, 0x00, 0x21, 0x7f, 0x00,
+    0x00, 0x48, 0x8c, 0x00, 0x02, 0xcf, 0xb7, 0x00, 0x00, 0x4f, 0xf1, 0x00,
+    0x00, 0xd1, 0xdf, 0x00, 0x00, 0x66, 0x9c, 0x00, 0x00, 0x8b, 0x07, 0x00,
+    0x00, 0x86, 0x9e, 0x00, 0x01, 0x34, 0x87, 0x00, 0x00, 0x4c, 0x65, 0x00,
+    0x00, 0x3e, 0xf8, 0x00, 0x00, 0x31, 0x45, 0x00, 0x00, 0xbb, 0xd0, 0x00,
+    0x04, 0x7f, 0x59, 0x00, 0x00, 0x71, 0x01, 0x00, 0x00, 0x0c, 0xb2, 0x00,
+    0x00, 0xf0, 0x7d, 0x00, 0x00, 0x23, 0xae, 0x00, 0x01, 0x3a, 0x58, 0x00,
+    0x00, 0x4f, 0xbb, 0x00, 0x06, 0x9c, 0x98, 0x00, 0x07, 0x1c, 0xad, 0x00,
+    0x00, 0x15, 0xf4, 0x00, 0x00, 0xb8, 0xef, 0x00, 0x00, 0x09, 0x20, 0x00,
+    0x01, 0xd7, 0x87, 0x00, 0x00, 0x82, 0x7c, 0x00, 0x00, 0x49, 0x08, 0x00,
+    0x06, 0x8d, 0xfb, 0x00, 0x00, 0xd1, 0xe3, 0x00, 0x00, 0x14, 0xea, 0x00,
+    0x00, 0x7a, 0xf5, 0x00, 0x00, 0x0c, 0xd7, 0x00, 0x01, 0x5a, 0xd4, 0x00,
+    0x00, 0x50, 0x27, 0x00, 0x00, 0x86, 0x11, 0x00, 0x00, 0x18, 0xe9, 0x00,
+    0x15, 0x11, 0x58, 0x00, 0x02, 0xd9, 0x07, 0x00, 0x01, 0x26, 0xd1, 0x00,
+    0x00, 0x28, 0x27, 0x00, 0x00, 0x87, 0xa4, 0x00, 0x01, 0x59, 0xf7, 0x00,
+    0x00, 0x49, 0xed, 0x00, 0x00, 0x2c, 0x8a, 0x00, 0x00, 0xf7, 0xe5, 0x00,
+    0x00, 0x6f, 0x7e, 0x00, 0x1e, 0x80, 0x05, 0x00, 0x00, 0x36, 0x2e, 0x00,
+    0x00, 0x02, 0xb6, 0x00, 0x00, 0x35, 0x10, 0x00, 0x00, 0x3b, 0x2f, 0x00,
+    0x09, 0xce, 0x91, 0x00, 0x01, 0xca, 0x3c, 0x00, 0x00, 0xb9, 0x5f, 0x00,
+    0x08, 0x80, 0x67, 0x00, 0x00, 0xc2, 0xcb, 0x00, 0x00, 0x0d, 0x68, 0x00,
+    0x00, 0x0a, 0xb2, 0x00, 0x00, 0x03, 0x6e, 0x00, 0x00, 0x10, 0xd7, 0x00,
+    0x00, 0x40, 0x6f, 0x00, 0x00, 0x41, 0xfe, 0x00, 0x02, 0xc5, 0x69, 0x00,
+    0x02, 0x2d, 0x32, 0x00, 0x01, 0x1b, 0x2d, 0x00, 0x00, 0x15, 0xff, 0x00,
+    0x00, 0x0f, 0x91, 0x00, 0x01, 0x13, 0x91, 0x00, 0x00, 0x23, 0xbc, 0x00,
+    0x02, 0x2e, 0xa3, 0x00, 0x00, 0x03, 0x1d, 0x00, 0x00, 0x1d, 0x86, 0x00,
+    0x00, 0x1c, 0x91, 0x00, 0x00, 0x56, 0xc7, 0x00, 0x02, 0xd7, 0x07, 0x00,
+    0x00, 0x63, 0xdd, 0x00, 0x01, 0x5c, 0xec, 0x00, 0x00, 0x19, 0x5a, 0x00,
+    0x00, 0x26, 0x3c, 0x00, 0x00, 0xe1, 0x79, 0x00, 0x00, 0xf0, 0x32, 0x00,
+    0x01, 0x65, 0x46, 0x00, 0x00, 0xb5, 0xa4, 0x00, 0x00, 0x59, 0xec, 0x00,
+    0x03, 0xe4, 0xbd, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x4d, 0x75, 0x00,
+    0x0d, 0x50, 0x1e, 0x00, 0x00, 0x40, 0x6d, 0x00, 0x00, 0x10, 0xad, 0x00,
+    0x02, 0x1c, 0xd6, 0x00, 0x00, 0x99, 0x85, 0x00, 0x00, 0x93, 0x09, 0x00,
+    0x00, 0x58, 0xaf, 0x00, 0x00, 0x4e, 0xef, 0x00, 0x00, 0xbe, 0x76, 0x00,
+    0x00, 0x26, 0x48, 0x00, 0x00, 0x33, 0x02, 0x00, 0x02, 0xac, 0x3d, 0x00,
+    0x00, 0x26, 0x0f, 0x00, 0x03, 0xf5, 0x17, 0x00, 0x00, 0x61, 0xa9, 0x00,
+    0x00, 0x2c, 0x12, 0x00, 0x00, 0x57, 0x2b, 0x00, 0x00, 0x1d, 0x94, 0x00,
+    0x00, 0x03, 0x61, 0x00, 0x00, 0xaa, 0xfc, 0x00, 0x00, 0x18, 0x38, 0x00,
+    0x0a, 0xed, 0x28, 0x00, 0x01, 0x8a, 0xe2, 0x00, 0x00, 0x21, 0xcf, 0x00,
+    0x02, 0x0e, 0xf3, 0x00, 0x00, 0x24, 0xe2, 0x00, 0x00, 0x28, 0x78, 0x00,
+    0x00, 0xb3, 0xdd, 0x00, 0x00, 0x84, 0xa0, 0x00, 0x00, 0x18, 0xb5, 0x00,
+    0x00, 0x33, 0x03, 0x00, 0x00, 0x06, 0xf7, 0x00, 0x00, 0x59, 0xf6, 0x00,
+    0x00, 0xe5, 0xa5, 0x00, 0x00, 0xb9, 0x61, 0x00, 0x00, 0xcb, 0x7a, 0x00,
+    0x04, 0x4e, 0x25, 0x00, 0x00, 0x53, 0x10, 0x00, 0x00, 0x5d, 0xa0, 0x00,
+    0x00, 0x98, 0x23, 0x00, 0x00, 0x1b, 0xec, 0x00, 0x00, 0x61, 0xe4, 0x00,
+    0x00, 0x15, 0x79, 0x00, 0x00, 0x25, 0x9e, 0x00, 0x00, 0xd6, 0xbc, 0x00,
+    0x00, 0xb2, 0x5c, 0x00, 0x00, 0x21, 0xd9, 0x00, 0x00, 0x82, 0xc6, 0x00,
+    0x00, 0x19, 0xfa, 0x00, 0x00, 0x29, 0xbe, 0x00, 0x00, 0x34, 0x57, 0x00,
+    0x00, 0x5d, 0x6c, 0x00, 0x00, 0x0f, 0x11, 0x00, 0x00, 0x23, 0x38, 0x00,
+    0x00, 0x56, 0xb4, 0x00, 0x02, 0x27, 0x7a, 0x00, 0x00, 0xad, 0xf3, 0x00,
+    0x00, 0x6f, 0x71, 0x00, 0x00, 0x69, 0xc2, 0x00, 0x00, 0x69, 0x78, 0x00,
+    0x00, 0x3b, 0x94, 0x00, 0x00, 0xa2, 0x58, 0x00, 0x00, 0x4a, 0x75, 0x00,
+    0x00, 0x62, 0xe8, 0x00, 0x00, 0xb8, 0x71, 0x00, 0x00, 0x7a, 0x30, 0x00,
+    0x00, 0x29, 0x4a, 0x00, 0x07, 0x38, 0x50, 0x00, 0x00, 0x60, 0x67, 0x00,
+    0x17, 0xa9, 0x39, 0x00, 0x00, 0x2b, 0x64, 0x00, 0x00, 0x35, 0xdf, 0x00,
+    0x04, 0x23, 0x30, 0x00, 0x00, 0xdd, 0x1b, 0x00, 0x02, 0x4c, 0x59, 0x00,
+    0x00, 0xc0, 0x10, 0x00, 0x01, 0xae, 0x5a, 0x00, 0x00, 0x72, 0xad, 0x00,
+    0x01, 0xce, 0x1c, 0x00, 0x00, 0x39, 0xb5, 0x00, 0x00, 0x10, 0x03, 0x00,
+    0x00, 0x10, 0x98, 0x00, 0x06, 0x69, 0xe3, 0x00, 0x02, 0x3e, 0x37, 0x00,
+    0x00, 0x71, 0xbb, 0x00, 0x00, 0x33, 0x87, 0x00, 0x00, 0x1e, 0xc9, 0x00,
+    0x00, 0x42, 0x61, 0x00, 0x00, 0x78, 0x61, 0x00, 0x00, 0x11, 0x6f, 0x00,
+    0x01, 0x31, 0xc5, 0x00, 0x05, 0x0a, 0xbc, 0x00, 0x00, 0xf6, 0xf5, 0x00,
+    0x00, 0x60, 0xfd, 0x00, 0x01, 0x62, 0x06, 0x00, 0x00, 0x09, 0x34, 0x00,
+    0x01, 0x1f, 0x4e, 0x00, 0x00, 0xc7, 0x35, 0x00, 0x00, 0x21, 0xd9, 0x00,
+    0x00, 0x0b, 0x3d, 0x00, 0x07, 0xf7, 0xdc, 0x00, 0x00, 0x1f, 0x56, 0x00,
+    0x00, 0x95, 0xe9, 0x00, 0x00, 0x13, 0x51, 0x00, 0x01, 0x74, 0x4d, 0x00,
+    0x00, 0x32, 0xb2, 0x00, 0x00, 0x83, 0x5f, 0x00, 0x00, 0x25, 0xd9, 0x00,
+    0x0a, 0x10, 0x44, 0x00, 0x00, 0x21, 0x35, 0x00, 0x00, 0xe7, 0x1a, 0x00,
+    0x00, 0x8e, 0xa2, 0x00, 0x00, 0x47, 0x02, 0x00, 0x00, 0x97, 0x31, 0x00,
+    0x00, 0x35, 0xb8, 0x00, 0x00, 0xd1, 0x27, 0x00, 0x00, 0x46, 0x99, 0x00,
+    0x00, 0x8d, 0xdf, 0x00, 0x00, 0x72, 0x44, 0x00, 0x00, 0x4f, 0x92, 0x00,
+    0x00, 0x8e, 0x77, 0x00, 0x01, 0x4f, 0x75, 0x00, 0x00, 0x22, 0x49, 0x00,
+    0x00, 0x3b, 0x3f, 0x00, 0x05, 0x6b, 0xa8, 0x00, 0x00, 0x82, 0xa7, 0x00,
+    0x00, 0x21, 0xbc, 0x00, 0x00, 0x78, 0xe0, 0x00, 0x01, 0xab, 0x95, 0x00,
+    0x0e, 0x1e, 0x5d, 0x00, 0x00, 0x10, 0x60, 0x00, 0x05, 0xb2, 0x07, 0x00,
+    0x07, 0xa7, 0x57, 0x00, 0x00, 0x1e, 0x3d, 0x00, 0x00, 0x47, 0x09, 0x00,
+    0x01, 0x71, 0xe2, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x8a, 0x24, 0x00,
+    0x00, 0x14, 0xca, 0x00, 0x01, 0xd1, 0xf8, 0x00, 0x00, 0x6d, 0x44, 0x00,
+    0x00, 0x27, 0xe9, 0x00, 0x00, 0x7b, 0x7c, 0x00, 0x00, 0xc4, 0xd6, 0x00,
+    0x00, 0x26, 0x11, 0x00, 0x00, 0xa9, 0x4c, 0x00, 0x00, 0x16, 0x78, 0x00,
+    0x00, 0x06, 0xbf, 0x00, 0x00, 0x19, 0x8b, 0x00, 0x00, 0x7f, 0x33, 0x00,
+    0x00, 0xac, 0x0c, 0x00, 0x13, 0xde, 0xcc, 0x00, 0x00, 0x4a, 0xb5, 0x00,
+    0x00, 0x08, 0xfe, 0x00, 0x01, 0xee, 0xa6, 0x00, 0x00, 0x44, 0x4e, 0x00,
+    0x00, 0x3b, 0xee, 0x00, 0x00, 0x47, 0x50, 0x00, 0x00, 0x22, 0xb8, 0x00,
+    0x00, 0x4d, 0xaf, 0x00, 0x00, 0x92, 0x9b, 0x00, 0x02, 0xeb, 0x61, 0x00,
+    0x00, 0xc2, 0x1d, 0x00, 0x00, 0x16, 0x50, 0x00, 0x00, 0x22, 0xa3, 0x00,
+    0x03, 0x9c, 0xe2, 0x00, 0x00, 0x5c, 0xec, 0x00, 0x03, 0xa1, 0xdf, 0x00,
+    0x14, 0xa5, 0x5c, 0x00, 0x00, 0x19, 0x69, 0x00, 0x00, 0x0c, 0x35, 0x00,
+    0x00, 0x8e, 0x32, 0x00, 0x00, 0x15, 0x57, 0x00, 0x00, 0xa7, 0xc9, 0x00,
+    0x00, 0x1b, 0x18, 0x00, 0x01, 0x84, 0xcc, 0x00, 0x00, 0x42, 0x81, 0x00,
+    0x00, 0x3b, 0xef, 0x00, 0x01, 0x58, 0xce, 0x00, 0x00, 0x10, 0x7c, 0x00,
+    0x00, 0x0b, 0x9f, 0x00, 0x00, 0x25, 0x66, 0x00, 0x00, 0x3d, 0xb2, 0x00,
+    0x00, 0x39, 0x6c, 0x00, 0x01, 0x41, 0xd7, 0x00, 0x00, 0xf7, 0xb5, 0x00,
+    0x01, 0x47, 0xd3, 0x00, 0x00, 0x3e, 0x19, 0x00, 0x00, 0x1f, 0x6d, 0x00,
+    0x00, 0x37, 0xa3, 0x00, 0x00, 0x07, 0x60, 0x00, 0x01, 0x0b, 0x40, 0x00,
+    0x01, 0x40, 0x77, 0x00, 0x01, 0x15, 0x3a, 0x00, 0x00, 0x40, 0x87, 0x00,
+    0x22, 0x9b, 0x26, 0x00, 0x00, 0xb0, 0xaa, 0x00, 0x00, 0x2b, 0xf7, 0x00,
+    0x00, 0x45, 0x08, 0x00, 0x00, 0x50, 0x7e, 0x00, 0x00, 0x3c, 0x04, 0x00,
+    0x00, 0x2e, 0x86, 0x00, 0x05, 0x1b, 0x8c, 0x00, 0x05, 0x6e, 0x74, 0x00,
+    0x00, 0x54, 0x12, 0x00, 0x04, 0x14, 0x0a, 0x00, 0x00, 0xa7, 0xdf, 0x00,
+    0x00, 0xf4, 0x51, 0x00, 0x00, 0x20, 0x8d, 0x00, 0x00, 0x18, 0xf7, 0x00,
+    0x00, 0xb2, 0xc7, 0x00, 0x00, 0x27, 0x42, 0x00, 0x00, 0x14, 0xda, 0x00,
+    0x00, 0x06, 0x9e, 0x00, 0x00, 0x88, 0x86, 0x00, 0x00, 0x27, 0x2b, 0x00,
+    0x01, 0x5c, 0xc7, 0x00, 0x0a, 0x41, 0x68, 0x00, 0x00, 0xac, 0x11, 0x00,
+    0x00, 0xa7, 0x25, 0x00, 0x02, 0x53, 0x23, 0x00, 0x00, 0x03, 0x66, 0x00,
+    0x00, 0x55, 0x49, 0x00, 0x00, 0x19, 0xfb, 0x00, 0x00, 0x19, 0x48, 0x00,
+    0x00, 0x3f, 0x84, 0x00, 0x04, 0xf8, 0xc0, 0x00, 0x01, 0x23, 0x8d, 0x00,
+    0x02, 0xb0, 0x4e, 0x00, 0x01, 0xec, 0xce, 0x00, 0x00, 0x3a, 0x23, 0x00,
+    0x00, 0xe2, 0xed, 0x00, 0x00, 0x42, 0x1b, 0x00, 0x00, 0x66, 0x06, 0x00,
+    0x01, 0x3b, 0x70, 0x00, 0x00, 0x46, 0xe1, 0x00, 0x00, 0x18, 0x42, 0x00,
+    0x01, 0x5a, 0x20, 0x00, 0x06, 0xd6, 0x32, 0x00, 0x00, 0xf6, 0x6a, 0x00,
+    0x00, 0x68, 0x7a, 0x00, 0x00, 0x9a, 0x28, 0x00, 0x00, 0x51, 0xe6, 0x00,
+    0x00, 0x0e, 0xd0, 0x00, 0x00, 0x8e, 0x08, 0x00, 0x01, 0xd4, 0xf9, 0x00,
+    0x00, 0x12, 0x0f, 0x00, 0x00, 0x77, 0x4f, 0x00, 0x00, 0x58, 0x83, 0x00,
+    0x00, 0x1f, 0x7e, 0x00, 0x00, 0xc4, 0x9e, 0x00, 0x00, 0x71, 0x4c, 0x00,
+    0x07, 0x9d, 0x6f, 0x00, 0x00, 0x13, 0x8f, 0x00, 0x00, 0x60, 0x4d, 0x00,
+    0x00, 0xd5, 0x07, 0x00, 0x02, 0x58, 0xf9, 0x00, 0x00, 0x20, 0xaa, 0x00,
+    0x00, 0x32, 0x52, 0x00, 0x09, 0xfe, 0x8a, 0x00, 0x00, 0x7d, 0x33, 0x00,
+    0x01, 0xab, 0x39, 0x00, 0x00, 0x3e, 0x5f, 0x00, 0x01, 0xe1, 0x57, 0x00,
+    0x00, 0x10, 0xf6, 0x00, 0x00, 0xc5, 0x73, 0x00, 0x00, 0xdb, 0xf4, 0x00,
+    0x00, 0x9b, 0x64, 0x00, 0x00, 0x34, 0xf7, 0x00, 0x00, 0x2c, 0xe3, 0x00,
+    0x01, 0xbd, 0xfb, 0x00, 0x00, 0xec, 0xee, 0x00, 0x00, 0x76, 0xc5, 0x00,
+    0x00, 0x8f, 0x4e, 0x00, 0x00, 0x50, 0x8c, 0x00, 0x00, 0x52, 0xb8, 0x00,
+    0x00, 0x75, 0xd3, 0x00, 0x00, 0x47, 0x60, 0x00, 0x06, 0x6f, 0x36, 0x00,
+    0x00, 0x31, 0x65, 0x00, 0x00, 0xd1, 0xc6, 0x00, 0x00, 0x2c, 0x59, 0x00,
+    0x01, 0x7f, 0x15, 0x00, 0x03, 0x11, 0x96, 0x00, 0x00, 0x1c, 0x57, 0x00,
+    0x00, 0x24, 0xb6, 0x00, 0x00, 0x86, 0x61, 0x00, 0x00, 0x17, 0xdb, 0x00,
+    0x00, 0x16, 0x25, 0x00, 0x02, 0xf8, 0x25, 0x00, 0x00, 0x10, 0x0b, 0x00,
+    0x00, 0x5c, 0xb9, 0x00, 0x00, 0x68, 0x71, 0x00, 0x06, 0xa7, 0x74, 0x00,
+    0x01, 0x06, 0xf8, 0x00, 0x00, 0x22, 0x86, 0x00, 0x00, 0x4b, 0x87, 0x00,
+    0x00, 0xe1, 0xf4, 0x00, 0x00, 0x7f, 0xcc, 0x00, 0x00, 0x18, 0xce, 0x00,
+    0x00, 0x23, 0x71, 0x00, 0x00, 0x37, 0x5d, 0x00, 0x00, 0x49, 0x03, 0x00,
+    0x00, 0x1e, 0xa4, 0x00, 0x00, 0x23, 0xc0, 0x00, 0x01, 0x05, 0x33, 0x00,
+    0x00, 0xb1, 0x38, 0x00, 0x00, 0x18, 0x5c, 0x00, 0x00, 0x70, 0xfd, 0x00,
+    0x00, 0x49, 0xee, 0x00, 0x00, 0xe0, 0x28, 0x00, 0x00, 0xd3, 0x5d, 0x00,
+    0x00, 0x20, 0xa5, 0x00, 0x00, 0x9d, 0xac, 0x00, 0x00, 0x1b, 0xf0, 0x00,
+    0x00, 0x32, 0x56, 0x00, 0x00, 0x66, 0x25, 0x00, 0x00, 0x1c, 0x90, 0x00,
+    0x00, 0x1f, 0xcc, 0x00, 0x00, 0x39, 0xe6, 0x00, 0x01, 0x13, 0x13, 0x00,
+    0x00, 0x2e, 0xfa, 0x00, 0x01, 0xae, 0x6d, 0x00, 0x00, 0x13, 0xcf, 0x00,
+    0x00, 0x1a, 0x04, 0x00, 0x03, 0xad, 0x31, 0x00, 0x00, 0xc9, 0x72, 0x00,
+    0x00, 0xa3, 0x0a, 0x00, 0x01, 0xbc, 0x6c, 0x00, 0x01, 0x32, 0x41, 0x00,
+    0x00, 0x59, 0xa7, 0x00, 0x00, 0x33, 0x81, 0x00, 0x08, 0x85, 0x5b, 0x00,
+    0x01, 0xf0, 0xfb, 0x00, 0x00, 0xa0, 0x05, 0x00, 0x00, 0x4c, 0x80, 0x00,
+    0x01, 0x73, 0xaa, 0x00, 0x03, 0x2e, 0x47, 0x00, 0x00, 0x0a, 0x92, 0x00,
+    0x00, 0x8c, 0x79, 0x00, 0x01, 0x3c, 0xb4, 0x00, 0x02, 0x2c, 0x16, 0x00,
+    0x00, 0x09, 0x33, 0x00, 0x00, 0x0e, 0xa4, 0x00, 0x00, 0x29, 0x47, 0x00,
+    0x00, 0x34, 0x2e, 0x00, 0x00, 0x1b, 0x17, 0x00, 0x01, 0x05, 0x35, 0x00,
+    0x00, 0xb7, 0x0e, 0x00, 0x00, 0x22, 0x2f, 0x00, 0x00, 0x1f, 0x8b, 0x00,
+    0x01, 0x1d, 0xdd, 0x00, 0x00, 0x0f, 0xb3, 0x00, 0x01, 0x05, 0xec, 0x00,
+    0x00, 0x5f, 0xa6, 0x00, 0x00, 0x0b, 0xd9, 0x00, 0x00, 0x66, 0x70, 0x00,
+    0x01, 0x03, 0xc6, 0x00, 0x00, 0x75, 0x78, 0x00, 0x00, 0x32, 0x91, 0x00,
+    0x00, 0x3f, 0xe1, 0x00, 0x00, 0x51, 0x29, 0x00, 0x00, 0x2b, 0xb1, 0x00,
+    0x01, 0x6f, 0x41, 0x00, 0x00, 0xab, 0x86, 0x00, 0x00, 0x24, 0x00, 0x00,
+    0x00, 0x6a, 0x52, 0x00, 0x00, 0x29, 0x37, 0x00, 0x00, 0x94, 0x20, 0x00,
+    0x00, 0x18, 0x79, 0x00, 0x00, 0x82, 0x8e, 0x00, 0x00, 0x68, 0xb7, 0x00,
+    0x00, 0x15, 0xde, 0x00, 0x00, 0x52, 0x1f, 0x00, 0x00, 0x4e, 0x6e, 0x00,
+    0x03, 0x93, 0x7e, 0x00, 0x00, 0x48, 0xdc, 0x00, 0x00, 0x26, 0x4d, 0x00,
+    0x00, 0x48, 0xf0, 0x00, 0x00, 0xf8, 0x87, 0x00, 0x00, 0xb4, 0x04, 0x00,
+    0x00, 0x81, 0x7b, 0x00, 0x00, 0x31, 0xcf, 0x00, 0x01, 0x8d, 0x1e, 0x00,
+    0x00, 0x30, 0x4e, 0x00, 0x00, 0x76, 0xf9, 0x00, 0x01, 0xb1, 0xca, 0x00,
+    0x00, 0x3b, 0xae, 0x00, 0x01, 0x24, 0xf2, 0x00, 0x00, 0x18, 0x92, 0x00,
+    0x00, 0x28, 0x7f, 0x00, 0x01, 0x91, 0x77, 0x00, 0x00, 0x47, 0x83, 0x00,
+    0x00, 0xff, 0xc1, 0x00, 0x01, 0x8b, 0xa0, 0x00, 0x00, 0x0b, 0xca, 0x00,
+    0x00, 0x23, 0x3a, 0x00, 0x00, 0xc0, 0x95, 0x00, 0x00, 0x06, 0x45, 0x00,
+    0x00, 0x51, 0x33, 0x00, 0x00, 0x79, 0x05, 0x00, 0x00, 0x73, 0x8a, 0x00,
+    0x00, 0x42, 0x7a, 0x00, 0x00, 0x28, 0x7c, 0x00, 0x01, 0x42, 0xff, 0x00,
+    0x00, 0x28, 0x18, 0x00, 0x01, 0x5d, 0x47, 0x00, 0x04, 0xfd, 0x1f, 0x00,
+    0x00, 0x30, 0x37, 0x00, 0x00, 0x0b, 0x1a, 0x00, 0x00, 0x17, 0xc0, 0x00,
+    0x00, 0x0e, 0x84, 0x00, 0x00, 0x6d, 0x14, 0x00, 0x00, 0x69, 0xc3, 0x00,
+    0x00, 0x89, 0x54, 0x00, 0x01, 0x30, 0x9d, 0x00, 0x0c, 0x04, 0xf2, 0x00,
+    0x00, 0x95, 0x61, 0x00, 0x07, 0xa3, 0x80, 0x00, 0x00, 0x36, 0x5c, 0x00,
+    0x01, 0x2f, 0xbb, 0x00, 0x00, 0x81, 0x62, 0x00, 0x00, 0x12, 0x77, 0x00,
+    0x01, 0x3b, 0xc7, 0x00, 0x00, 0x6c, 0x8d, 0x00, 0x00, 0x61, 0x81, 0x00,
+    0x00, 0x4c, 0xa6, 0x00, 0x00, 0x16, 0x16, 0x00, 0x01, 0x16, 0xe2, 0x00,
+    0x01, 0x44, 0x4d, 0x00, 0x04, 0x4a, 0xfa, 0x00, 0x02, 0x3e, 0x23, 0x00,
+    0x00, 0xa3, 0x5c, 0x00, 0x00, 0x7d, 0xc3, 0x00, 0x00, 0x0c, 0x2f, 0x00,
+    0x00, 0x11, 0xd3, 0x00, 0x00, 0x27, 0x67, 0x00, 0x00, 0x3d, 0x9a, 0x00,
+    0x00, 0x17, 0x9c, 0x00, 0x00, 0x32, 0x6c, 0x00, 0x00, 0x40, 0x36, 0x00,
+    0x09, 0xa2, 0xa3, 0x00, 0x00, 0x21, 0xb2, 0x00, 0x00, 0x2d, 0x8e, 0x00,
+    0x00, 0x58, 0xef, 0x00, 0x00, 0x4b, 0xac, 0x00, 0x02, 0x89, 0xcf, 0x00,
+    0x00, 0x9e, 0x94, 0x00, 0x00, 0xdb, 0xfe, 0x00, 0x00, 0x25, 0x2d, 0x00,
+    0x00, 0x60, 0xf9, 0x00, 0x00, 0x1d, 0x02, 0x00, 0x00, 0xf0, 0x78, 0x00,
+    0x00, 0x73, 0xf2, 0x00, 0x00, 0x27, 0xbb, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x96, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x96, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x96, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x1a, 0x5e, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x96, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x96, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x96, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x96, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x1a, 0x5e, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x96, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x1a, 0x5e, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x1a, 0x5e, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x96, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x96, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x0c, 0xa8, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x0c, 0xa8, 0x00,
+    0x00, 0x04, 0x7c, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x77, 0x00,
+    0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, 0xf0, 0x00,
+    0x00, 0x01, 0x16, 0x00, 0x00, 0x01, 0x3a, 0x00, 0x00, 0x01, 0x5d, 0x00,
+    0x00, 0x01, 0x8c, 0x00, 0x00, 0x01, 0xb7, 0x00, 0x00, 0x01, 0xdb, 0x00,
+    0x00, 0x02, 0x05, 0x00, 0x00, 0x02, 0x29, 0x00, 0x00, 0x02, 0x53, 0x00,
+    0x00, 0x02, 0x77, 0x00, 0x00, 0x02, 0x9f, 0x00, 0x00, 0x02, 0xc5, 0x00,
+    0x00, 0x02, 0xeb, 0x00, 0x00, 0x03, 0x15, 0x00, 0x00, 0x03, 0x37, 0x00,
+    0x00, 0x03, 0x62, 0x00, 0x00, 0x03, 0x8e, 0x00, 0x00, 0x03, 0xb1, 0x00,
+    0x00, 0x03, 0xd4, 0x00, 0x00, 0x03, 0xf8, 0x00, 0x00, 0x04, 0x1e, 0x00,
+    0x00, 0x04, 0x42, 0x00, 0x00, 0x04, 0x67, 0x00, 0x00, 0x04, 0x8e, 0x00,
+    0x00, 0x04, 0xb1, 0x00, 0x00, 0x04, 0xd4, 0x00, 0x00, 0x04, 0xf7, 0x00,
+    0x00, 0x05, 0x1c, 0x00, 0x00, 0x05, 0x49, 0x00, 0x00, 0x05, 0x70, 0x00,
+    0x00, 0x05, 0x95, 0x00, 0x00, 0x05, 0xbb, 0x00, 0x00, 0x05, 0xdd, 0x00,
+    0x00, 0x06, 0x02, 0x00, 0x00, 0x06, 0x25, 0x00, 0x00, 0x06, 0x4c, 0x00,
+    0x00, 0x06, 0x70, 0x00, 0x00, 0x06, 0x91, 0x00, 0x00, 0x06, 0xb7, 0x00,
+    0x00, 0x06, 0xde, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00, 0x07, 0x25, 0x00,
+    0x00, 0x07, 0x47, 0x00, 0x00, 0x07, 0x69, 0x00, 0x00, 0x07, 0x91, 0x00,
+    0x00, 0x07, 0xb7, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x00, 0x08, 0x0b, 0x00,
+    0x00, 0x08, 0x39, 0x00, 0x00, 0x08, 0x61, 0x00, 0x00, 0x08, 0x85, 0x00,
+    0x00, 0x08, 0xa7, 0x00, 0x00, 0x08, 0xd3, 0x00, 0x00, 0x09, 0x01, 0x00,
+    0x00, 0x09, 0x25, 0x00, 0x00, 0x09, 0x4d, 0x00, 0x00, 0x09, 0x76, 0x00,
+    0x00, 0x09, 0x9d, 0x00, 0x00, 0x09, 0xc1, 0x00, 0x00, 0x09, 0xe5, 0x00,
+    0x00, 0x0a, 0x0c, 0x00, 0x00, 0x0a, 0x30, 0x00, 0x00, 0x0a, 0x58, 0x00,
+    0x00, 0x0a, 0x7c, 0x00, 0x00, 0x0a, 0xa1, 0x00, 0x00, 0x0a, 0xc8, 0x00,
+    0x00, 0x0a, 0xec, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x37, 0x00,
+    0x00, 0x0b, 0x60, 0x00, 0x00, 0x0b, 0x88, 0x00, 0x00, 0x0b, 0xaa, 0x00,
+    0x00, 0x0b, 0xce, 0x00, 0x00, 0x0b, 0xf3, 0x00, 0x00, 0x0c, 0x18, 0x00,
+    0x00, 0x0c, 0x3c, 0x00, 0x00, 0x0c, 0x65, 0x00, 0x00, 0x0c, 0x8f, 0x00,
+    0x00, 0x0c, 0xb9, 0x00, 0x00, 0x0c, 0xdf, 0x00, 0x00, 0x0c, 0xff, 0x00,
+    0x00, 0x0d, 0x20, 0x00, 0x00, 0x0d, 0x47, 0x00, 0x00, 0x0d, 0x6c, 0x00,
+    0x00, 0x0d, 0x91, 0x00, 0x00, 0x0d, 0xb7, 0x00, 0x00, 0x0d, 0xdc, 0x00,
+    0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x20, 0x00, 0x00, 0x0e, 0x48, 0x00,
+    0x00, 0x0e, 0x6e, 0x00, 0x00, 0x0e, 0x98, 0x00, 0x00, 0x0e, 0xc0, 0x00,
+    0x00, 0x0e, 0xe6, 0x00, 0x00, 0x0f, 0x0a, 0x00, 0x00, 0x0f, 0x2e, 0x00,
+    0x00, 0x0f, 0x5d, 0x00, 0x00, 0x0f, 0x81, 0x00, 0x00, 0x0f, 0xa7, 0x00,
+    0x00, 0x0f, 0xcb, 0x00, 0x00, 0x0f, 0xef, 0x00, 0x00, 0x10, 0x14, 0x00,
+    0x00, 0x10, 0x3c, 0x00, 0x00, 0x10, 0x65, 0x00, 0x00, 0x10, 0x85, 0x00,
+    0x00, 0x10, 0xae, 0x00, 0x00, 0x10, 0xcf, 0x00, 0x00, 0x10, 0xf3, 0x00,
+    0x00, 0x11, 0x1e, 0x00, 0x00, 0x11, 0x42, 0x00, 0x00, 0x11, 0x69, 0x00,
+    0x00, 0x11, 0x8e, 0x00, 0x00, 0x11, 0xb5, 0x00, 0x00, 0x11, 0xd9, 0x00,
+    0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x23, 0x00, 0x00, 0x12, 0x48, 0x00,
+    0x00, 0x12, 0x74, 0x00, 0x00, 0x12, 0x9d, 0x00, 0x00, 0x12, 0xbf, 0x00,
+    0x00, 0x12, 0xe2, 0x00, 0x00, 0x13, 0x08, 0x00, 0x00, 0x13, 0x31, 0x00,
+    0x00, 0x13, 0x5c, 0x00, 0x00, 0x13, 0x87, 0x00, 0x00, 0x13, 0xac, 0x00,
+    0x00, 0x13, 0xd0, 0x00, 0x00, 0x13, 0xf5, 0x00, 0x00, 0x14, 0x17, 0x00,
+    0x00, 0x14, 0x38, 0x00, 0x00, 0x14, 0x65, 0x00, 0x00, 0x14, 0x87, 0x00,
+    0x00, 0x14, 0xac, 0x00, 0x00, 0x14, 0xcd, 0x00, 0x00, 0x14, 0xf3, 0x00,
+    0x00, 0x15, 0x18, 0x00, 0x00, 0x15, 0x3d, 0x00, 0x00, 0x15, 0x66, 0x00,
+    0x00, 0x15, 0x8d, 0x00, 0x00, 0x15, 0xb6, 0x00, 0x00, 0x15, 0xe2, 0x00,
+    0x00, 0x16, 0x0a, 0x00, 0x00, 0x16, 0x2f, 0x00, 0x00, 0x16, 0x4f, 0x00,
+    0x00, 0x16, 0x78, 0x00, 0x00, 0x16, 0x9d, 0x00, 0x00, 0x16, 0xc3, 0x00,
+    0x00, 0x16, 0xea, 0x00, 0x00, 0x17, 0x11, 0x00, 0x00, 0x17, 0x3d, 0x00,
+    0x00, 0x17, 0x61, 0x00, 0x00, 0x17, 0x8a, 0x00, 0x00, 0x17, 0xb1, 0x00,
+    0x00, 0x17, 0xde, 0x00, 0x00, 0x18, 0x08, 0x00, 0x00, 0x18, 0x30, 0x00,
+    0x00, 0x18, 0x59, 0x00, 0x00, 0x18, 0x7e, 0x00, 0x00, 0x18, 0xa9, 0x00,
+    0x00, 0x18, 0xd0, 0x00, 0x00, 0x18, 0xf5, 0x00, 0x00, 0x19, 0x1a, 0x00,
+    0x00, 0x19, 0x44, 0x00, 0x00, 0x19, 0x6b, 0x00, 0x00, 0x19, 0x91, 0x00,
+    0x00, 0x19, 0xb9, 0x00, 0x00, 0x19, 0xe1, 0x00, 0x00, 0x1a, 0x03, 0x00,
+    0x00, 0x1a, 0x30, 0x00, 0x00, 0x1a, 0x55, 0x00, 0x00, 0x1a, 0x7a, 0x00,
+    0x00, 0x1a, 0x9d, 0x00, 0x00, 0x1a, 0xc2, 0x00, 0x00, 0x1a, 0xe4, 0x00,
+    0x00, 0x1b, 0x11, 0x00, 0x00, 0x1b, 0x3e, 0x00, 0x00, 0x1b, 0x61, 0x00,
+    0x00, 0x1b, 0x86, 0x00, 0x00, 0x1b, 0xb0, 0x00, 0x00, 0x1b, 0xd9, 0x00,
+    0x00, 0x1b, 0xfe, 0x00, 0x00, 0x1c, 0x22, 0x00, 0x00, 0x1c, 0x45, 0x00,
+    0x00, 0x1c, 0x69, 0x00, 0x00, 0x1c, 0x93, 0x00, 0x00, 0x1c, 0xb8, 0x00,
+    0x00, 0x1c, 0xdb, 0x00, 0x00, 0x1c, 0xfd, 0x00, 0x00, 0x1d, 0x24, 0x00,
+    0x00, 0x1d, 0x49, 0x00, 0x00, 0x1d, 0x6d, 0x00, 0x00, 0x1d, 0x8f, 0x00,
+    0x00, 0x1d, 0xb4, 0x00, 0x00, 0x1d, 0xda, 0x00, 0x00, 0x1e, 0x04, 0x00,
+    0x00, 0x1e, 0x29, 0x00, 0x00, 0x1e, 0x4f, 0x00, 0x00, 0x1e, 0x7c, 0x00,
+    0x00, 0x1e, 0xac, 0x00, 0x00, 0x1e, 0xce, 0x00, 0x00, 0x1e, 0xf5, 0x00,
+    0x00, 0x1f, 0x1a, 0x00, 0x00, 0x1f, 0x3e, 0x00, 0x00, 0x1f, 0x64, 0x00,
+    0x00, 0x1f, 0x8a, 0x00, 0x00, 0x1f, 0xae, 0x00, 0x00, 0x1f, 0xcf, 0x00,
+    0x00, 0x1f, 0xee, 0x00, 0x00, 0x20, 0x14, 0x00, 0x00, 0x20, 0x3c, 0x00,
+    0x00, 0x20, 0x62, 0x00, 0x00, 0x20, 0x88, 0x00, 0x00, 0x20, 0xaa, 0x00,
+    0x00, 0x20, 0xca, 0x00, 0x00, 0x20, 0xeb, 0x00, 0x00, 0x21, 0x0d, 0x00,
+    0x00, 0x21, 0x36, 0x00, 0x00, 0x21, 0x59, 0x00, 0x00, 0x21, 0x7d, 0x00,
+    0x00, 0x21, 0xa1, 0x00, 0x00, 0x21, 0xc7, 0x00, 0x00, 0x21, 0xeb, 0x00,
+    0x00, 0x22, 0x14, 0x00, 0x00, 0x22, 0x36, 0x00, 0x00, 0x22, 0x5a, 0x00,
+    0x00, 0x22, 0x85, 0x00, 0x00, 0x22, 0xac, 0x00, 0x00, 0x22, 0xd3, 0x00,
+    0x00, 0x22, 0xf9, 0x00, 0x00, 0x23, 0x24, 0x00, 0x00, 0x23, 0x48, 0x00,
+    0x00, 0x23, 0x71, 0x00, 0x00, 0x23, 0xa9, 0x00, 0x00, 0x23, 0xce, 0x00,
+    0x00, 0x23, 0xf6, 0x00, 0x00, 0x24, 0x17, 0x00, 0x00, 0x24, 0x3c, 0x00,
+    0x00, 0x24, 0x64, 0x00, 0x00, 0x24, 0x8e, 0x00, 0x00, 0x24, 0xae, 0x00,
+    0x00, 0x24, 0xcf, 0x00, 0x00, 0x24, 0xf7, 0x00, 0x00, 0x25, 0x1f, 0x00,
+    0x00, 0x25, 0x4d, 0x00, 0x00, 0x25, 0x78, 0x00, 0x00, 0x25, 0xa5, 0x00,
+    0x00, 0x25, 0xc8, 0x00, 0x00, 0x25, 0xee, 0x00, 0x00, 0x26, 0x18, 0x00,
+    0x00, 0x26, 0x3e, 0x00, 0x00, 0x26, 0x69, 0x00, 0x00, 0x26, 0x8a, 0x00,
+    0x00, 0x26, 0xad, 0x00, 0x00, 0x26, 0xd9, 0x00, 0x00, 0x27, 0x00, 0x00,
+    0x00, 0x27, 0x24, 0x00, 0x00, 0x27, 0x4d, 0x00, 0x00, 0x27, 0x74, 0x00,
+    0x00, 0x27, 0x9c, 0x00, 0x00, 0x27, 0xbe, 0x00, 0x00, 0x27, 0xe2, 0x00,
+    0x00, 0x28, 0x07, 0x00, 0x00, 0x28, 0x2b, 0x00, 0x00, 0x28, 0x51, 0x00,
+    0x00, 0x28, 0x79, 0x00, 0x00, 0x28, 0x9d, 0x00, 0x00, 0x28, 0xbc, 0x00,
+    0x00, 0x28, 0xe2, 0x00, 0x00, 0x29, 0x05, 0x00, 0x00, 0x29, 0x2e, 0x00,
+    0x00, 0x29, 0x52, 0x00, 0x00, 0x29, 0x7f, 0x00, 0x00, 0x29, 0xa2, 0x00,
+    0x00, 0x29, 0xc7, 0x00, 0x00, 0x29, 0xef, 0x00, 0x00, 0x2a, 0x1a, 0x00,
+    0x00, 0x2a, 0x43, 0x00, 0x00, 0x2a, 0x69, 0x00, 0x00, 0x2a, 0x92, 0x00,
+    0x00, 0x2a, 0xb5, 0x00, 0x00, 0x2a, 0xda, 0x00, 0x00, 0x2a, 0xfd, 0x00,
+    0x00, 0x2b, 0x26, 0x00, 0x00, 0x2b, 0x4f, 0x00, 0x00, 0x2b, 0x77, 0x00,
+    0x00, 0x2b, 0x9a, 0x00, 0x00, 0x2b, 0xbc, 0x00, 0x00, 0x2b, 0xdf, 0x00,
+    0x00, 0x2c, 0x0b, 0x00, 0x00, 0x2c, 0x2d, 0x00, 0x00, 0x2c, 0x4c, 0x00,
+    0x00, 0x2c, 0x75, 0x00, 0x00, 0x2c, 0x98, 0x00, 0x00, 0x2c, 0xbf, 0x00,
+    0x00, 0x2c, 0xea, 0x00, 0x00, 0x2d, 0x0e, 0x00, 0x00, 0x2d, 0x30, 0x00,
+    0x00, 0x2d, 0x57, 0x00, 0x00, 0x2d, 0x80, 0x00, 0x00, 0x2d, 0xa2, 0x00,
+    0x00, 0x2d, 0xca, 0x00, 0x00, 0x2d, 0xef, 0x00, 0x00, 0x2e, 0x1b, 0x00,
+    0x00, 0x2e, 0x40, 0x00, 0x00, 0x2e, 0x62, 0x00, 0x00, 0x2e, 0x86, 0x00,
+    0x00, 0x2e, 0xae, 0x00, 0x00, 0x2e, 0xcf, 0x00, 0x00, 0x2e, 0xf2, 0x00,
+    0x00, 0x2f, 0x1e, 0x00, 0x00, 0x2f, 0x42, 0x00, 0x00, 0x2f, 0x6f, 0x00,
+    0x00, 0x2f, 0x95, 0x00, 0x00, 0x2f, 0xc0, 0x00, 0x00, 0x2f, 0xe7, 0x00,
+    0x00, 0x30, 0x0d, 0x00, 0x00, 0x30, 0x2f, 0x00, 0x00, 0x30, 0x58, 0x00,
+    0x00, 0x30, 0x7f, 0x00, 0x00, 0x30, 0xa4, 0x00, 0x00, 0x30, 0xc7, 0x00,
+    0x00, 0x30, 0xec, 0x00, 0x00, 0x31, 0x13, 0x00, 0x00, 0x31, 0x39, 0x00,
+    0x00, 0x31, 0x5f, 0x00, 0x00, 0x31, 0x84, 0x00, 0x00, 0x31, 0xaf, 0x00,
+    0x00, 0x31, 0xd6, 0x00, 0x00, 0x31, 0xfb, 0x00, 0x00, 0x32, 0x1e, 0x00,
+    0x00, 0x32, 0x43, 0x00, 0x00, 0x32, 0x6b, 0x00, 0x00, 0x32, 0x91, 0x00,
+    0x00, 0x32, 0xb5, 0x00, 0x00, 0x32, 0xda, 0x00, 0x00, 0x32, 0xfe, 0x00,
+    0x00, 0x33, 0x26, 0x00, 0x00, 0x33, 0x4b, 0x00, 0x00, 0x33, 0x72, 0x00,
+    0x00, 0x33, 0x99, 0x00, 0x00, 0x33, 0xbd, 0x00, 0x00, 0x33, 0xe7, 0x00,
+    0x00, 0x34, 0x0a, 0x00, 0x00, 0x34, 0x31, 0x00, 0x00, 0x34, 0x56, 0x00,
+    0x00, 0x34, 0x76, 0x00, 0x00, 0x34, 0x9d, 0x00, 0x00, 0x34, 0xc6, 0x00,
+    0x00, 0x34, 0xec, 0x00, 0x00, 0x35, 0x10, 0x00, 0x00, 0x35, 0x35, 0x00,
+    0x00, 0x35, 0x57, 0x00, 0x00, 0x35, 0x85, 0x00, 0x00, 0x35, 0xab, 0x00,
+    0x00, 0x35, 0xcf, 0x00, 0x00, 0x35, 0xf7, 0x00, 0x00, 0x36, 0x1b, 0x00,
+    0x00, 0x36, 0x47, 0x00, 0x00, 0x36, 0x6f, 0x00, 0x00, 0x36, 0x96, 0x00,
+    0x00, 0x36, 0xbf, 0x00, 0x00, 0x36, 0xe5, 0x00, 0x00, 0x37, 0x0a, 0x00,
+    0x00, 0x37, 0x32, 0x00, 0x00, 0x37, 0x51, 0x00, 0x00, 0x37, 0x73, 0x00,
+    0x00, 0x37, 0x97, 0x00, 0x00, 0x37, 0xbf, 0x00, 0x00, 0x37, 0xe3, 0x00,
+    0x00, 0x38, 0x09, 0x00, 0x00, 0x38, 0x2d, 0x00, 0x00, 0x38, 0x52, 0x00,
+    0x00, 0x38, 0x73, 0x00, 0x00, 0x38, 0x96, 0x00, 0x00, 0x38, 0xb8, 0x00,
+    0x00, 0x38, 0xd9, 0x00, 0x00, 0x38, 0xfd, 0x00, 0x00, 0x39, 0x23, 0x00,
+    0x00, 0x39, 0x4d, 0x00, 0x00, 0x39, 0x78, 0x00, 0x00, 0x39, 0x98, 0x00,
+    0x00, 0x39, 0xbb, 0x00, 0x00, 0x39, 0xe4, 0x00, 0x00, 0x3a, 0x09, 0x00,
+    0x00, 0x3a, 0x2e, 0x00, 0x00, 0x3a, 0x55, 0x00, 0x00, 0x3a, 0x7c, 0x00,
+    0x00, 0x3a, 0xa0, 0x00, 0x00, 0x3a, 0xca, 0x00, 0x00, 0x3a, 0xf0, 0x00,
+    0x00, 0x3b, 0x16, 0x00, 0x00, 0x3b, 0x38, 0x00, 0x00, 0x3b, 0x5b, 0x00,
+    0x00, 0x3b, 0x80, 0x00, 0x00, 0x3b, 0xa4, 0x00, 0x00, 0x3b, 0xcd, 0x00,
+    0x00, 0x3b, 0xf1, 0x00, 0x00, 0x3c, 0x15, 0x00, 0x00, 0x3c, 0x3f, 0x00,
+    0x00, 0x3c, 0x65, 0x00, 0x00, 0x3c, 0x8d, 0x00, 0x00, 0x3c, 0xb2, 0x00,
+    0x00, 0x3c, 0xd4, 0x00, 0x00, 0x3c, 0xfd, 0x00, 0x00, 0x3d, 0x20, 0x00,
+    0x00, 0x3d, 0x46, 0x00, 0x00, 0x3d, 0x68, 0x00, 0x00, 0x3d, 0x90, 0x00,
+    0x00, 0x3d, 0xb1, 0x00, 0x00, 0x3d, 0xd2, 0x00, 0x00, 0x3d, 0xf8, 0x00,
+    0x00, 0x3e, 0x1c, 0x00, 0x00, 0x3e, 0x41, 0x00, 0x00, 0x3e, 0x64, 0x00,
+    0x00, 0x3e, 0x89, 0x00, 0x00, 0x3e, 0xb3, 0x00, 0x00, 0x3e, 0xdb, 0x00,
+    0x00, 0x3e, 0xfe, 0x00, 0x00, 0x3f, 0x22, 0x00, 0x00, 0x3f, 0x46, 0x00,
+    0x00, 0x3f, 0x69, 0x00, 0x00, 0x3f, 0x8d, 0x00, 0x00, 0x3f, 0xb3, 0x00,
+    0x00, 0x3f, 0xd7, 0x00, 0x00, 0x3f, 0xfa, 0x00, 0x00, 0x40, 0x1f, 0x00,
+    0x00, 0x40, 0x44, 0x00, 0x00, 0x40, 0x69, 0x00, 0x00, 0x40, 0x96, 0x00,
+    0x00, 0x40, 0xc3, 0x00, 0x00, 0x40, 0xe7, 0x00, 0x00, 0x41, 0x16, 0x00,
+    0x00, 0x41, 0x3c, 0x00, 0x00, 0x41, 0x62, 0x00, 0x00, 0x41, 0x87, 0x00,
+    0x00, 0x41, 0xa9, 0x00, 0x00, 0x41, 0xd6, 0x00, 0x00, 0x41, 0xf6, 0x00,
+    0x00, 0x42, 0x1a, 0x00, 0x00, 0x42, 0x3e, 0x00, 0x00, 0x42, 0x66, 0x00,
+    0x00, 0x42, 0x8f, 0x00, 0x00, 0x42, 0xb1, 0x00, 0x00, 0x42, 0xd7, 0x00,
+    0x00, 0x42, 0xff, 0x00, 0x00, 0x43, 0x29, 0x00, 0x00, 0x43, 0x4b, 0x00,
+    0x00, 0x43, 0x6c, 0x00, 0x00, 0x43, 0x91, 0x00, 0x00, 0x43, 0xb8, 0x00,
+    0x00, 0x43, 0xde, 0x00, 0x00, 0x43, 0xff, 0x00, 0x00, 0x44, 0x30, 0x00,
+    0x00, 0x44, 0x4f, 0x00, 0x00, 0x44, 0x75, 0x00, 0x00, 0x44, 0x98, 0x00,
+    0x00, 0x44, 0xc0, 0x00, 0x00, 0x44, 0xee, 0x00, 0x00, 0x45, 0x13, 0x00,
+    0x00, 0x45, 0x3d, 0x00, 0x00, 0x45, 0x62, 0x00, 0x00, 0x45, 0x81, 0x00,
+    0x00, 0x45, 0xa3, 0x00, 0x00, 0x45, 0xc9, 0x00, 0x00, 0x45, 0xf0, 0x00,
+    0x00, 0x46, 0x13, 0x00, 0x00, 0x46, 0x36, 0x00, 0x00, 0x46, 0x5b, 0x00,
+    0x00, 0x46, 0x7a, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x00, 0x46, 0xca, 0x00,
+    0x00, 0x46, 0xee, 0x00, 0x00, 0x47, 0x13, 0x00, 0x00, 0x47, 0x3e, 0x00,
+    0x00, 0x47, 0x66, 0x00, 0x00, 0x47, 0x89, 0x00, 0x00, 0x47, 0xad, 0x00,
+    0x00, 0x47, 0xd0, 0x00, 0x00, 0x47, 0xf5, 0x00, 0x00, 0x48, 0x1a, 0x00,
+    0x00, 0x48, 0x3f, 0x00, 0x00, 0x48, 0x6a, 0x00, 0x00, 0x48, 0x92, 0x00,
+    0x00, 0x48, 0xb8, 0x00, 0x00, 0x48, 0xdb, 0x00, 0x00, 0x48, 0xfc, 0x00,
+    0x00, 0x49, 0x23, 0x00, 0x00, 0x49, 0x49, 0x00, 0x00, 0x49, 0x70, 0x00,
+    0x00, 0x49, 0x96, 0x00, 0x00, 0x49, 0xc0, 0x00, 0x00, 0x49, 0xe6, 0x00,
+    0x00, 0x4a, 0x0f, 0x00, 0x00, 0x4a, 0x39, 0x00, 0x00, 0x4a, 0x5e, 0x00,
+    0x00, 0x4a, 0x88, 0x00, 0x00, 0x4a, 0xad, 0x00, 0x00, 0x4a, 0xd0, 0x00,
+    0x00, 0x4a, 0xf9, 0x00, 0x00, 0x4b, 0x1e, 0x00, 0x00, 0x4b, 0x42, 0x00,
+    0x00, 0x4b, 0x62, 0x00, 0x00, 0x4b, 0x88, 0x00, 0x00, 0x4b, 0xab, 0x00,
+    0x00, 0x4b, 0xd8, 0x00, 0x00, 0x4b, 0xfb, 0x00, 0x00, 0x4c, 0x24, 0x00,
+    0x00, 0x4c, 0x4d, 0x00, 0x00, 0x4c, 0x72, 0x00, 0x00, 0x4c, 0x98, 0x00,
+    0x00, 0x4c, 0xbb, 0x00, 0x00, 0x4c, 0xe5, 0x00, 0x00, 0x4d, 0x09, 0x00,
+    0x00, 0x4d, 0x32, 0x00, 0x00, 0x4d, 0x53, 0x00, 0x00, 0x4d, 0x7b, 0x00,
+    0x00, 0x4d, 0xa1, 0x00, 0x00, 0x4d, 0xc7, 0x00, 0x00, 0x4d, 0xf4, 0x00,
+    0x00, 0x4e, 0x1e, 0x00, 0x00, 0x4e, 0x43, 0x00, 0x00, 0x4e, 0x6a, 0x00,
+    0x00, 0x4e, 0x8e, 0x00, 0x00, 0x4e, 0xb7, 0x00, 0x00, 0x4e, 0xdd, 0x00,
+    0x00, 0x4f, 0x00, 0x00, 0x00, 0x4f, 0x24, 0x00, 0x00, 0x4f, 0x4a, 0x00,
+    0x00, 0x4f, 0x6f, 0x00, 0x00, 0x4f, 0x94, 0x00, 0x00, 0x4f, 0xbf, 0x00,
+    0x00, 0x4f, 0xe1, 0x00, 0x00, 0x50, 0x05, 0x00, 0x00, 0x50, 0x2a, 0x00,
+    0x00, 0x50, 0x4e, 0x00, 0x00, 0x50, 0x6d, 0x00, 0x00, 0x50, 0x96, 0x00,
+    0x00, 0x50, 0xb8, 0x00, 0x00, 0x50, 0xdf, 0x00, 0x00, 0x51, 0x0a, 0x00,
+    0x00, 0x51, 0x33, 0x00, 0x00, 0x51, 0x58, 0x00, 0x00, 0x51, 0x7c, 0x00,
+    0x00, 0x51, 0xa2, 0x00, 0x00, 0x51, 0xc8, 0x00, 0x00, 0x51, 0xeb, 0x00,
+    0x00, 0x52, 0x12, 0x00, 0x00, 0x52, 0x37, 0x00, 0x00, 0x52, 0x5e, 0x00,
+    0x00, 0x52, 0x84, 0x00, 0x00, 0x52, 0xa6, 0x00, 0x00, 0x52, 0xcb, 0x00,
+    0x00, 0x52, 0xf1, 0x00, 0x00, 0x53, 0x18, 0x00, 0x00, 0x53, 0x3c, 0x00,
+    0x00, 0x53, 0x64, 0x00, 0x00, 0x53, 0x8d, 0x00, 0x00, 0x53, 0xb4, 0x00,
+    0x00, 0x53, 0xdb, 0x00, 0x00, 0x54, 0x01, 0x00, 0x00, 0x54, 0x27, 0x00,
+    0x00, 0x54, 0x4a, 0x00, 0x00, 0x54, 0x74, 0x00, 0x00, 0x54, 0x97, 0x00,
+    0x00, 0x54, 0xbf, 0x00, 0x00, 0x54, 0xe5, 0x00, 0x00, 0x55, 0x11, 0x00,
+    0x00, 0x55, 0x35, 0x00, 0x00, 0x55, 0x5e, 0x00, 0x00, 0x55, 0x8b, 0x00,
+    0x00, 0x55, 0xb1, 0x00, 0x00, 0x55, 0xd4, 0x00, 0x00, 0x55, 0xfd, 0x00,
+    0x00, 0x56, 0x27, 0x00, 0x00, 0x56, 0x4c, 0x00, 0x00, 0x56, 0x72, 0x00,
+    0x00, 0x56, 0xa0, 0x00, 0x00, 0x56, 0xc6, 0x00, 0x00, 0x56, 0xeb, 0x00,
+    0x00, 0x57, 0x11, 0x00, 0x00, 0x57, 0x33, 0x00, 0x00, 0x57, 0x5a, 0x00,
+    0x00, 0x57, 0x80, 0x00, 0x00, 0x57, 0xa5, 0x00, 0x00, 0x57, 0xcd, 0x00,
+    0x00, 0x57, 0xf1, 0x00, 0x00, 0x58, 0x18, 0x00, 0x00, 0x58, 0x3d, 0x00,
+    0x00, 0x58, 0x60, 0x00, 0x00, 0x58, 0x87, 0x00, 0x00, 0x58, 0xaf, 0x00,
+    0x00, 0x58, 0xd6, 0x00, 0x00, 0x58, 0xfd, 0x00, 0x00, 0x59, 0x23, 0x00,
+    0x00, 0x59, 0x46, 0x00, 0x00, 0x59, 0x69, 0x00, 0x00, 0x59, 0x8f, 0x00,
+    0x00, 0x59, 0xb5, 0x00, 0x00, 0x59, 0xda, 0x00, 0x00, 0x59, 0xfc, 0x00,
+    0x00, 0x5a, 0x29, 0x00, 0x00, 0x5a, 0x52, 0x00, 0x00, 0x5a, 0x74, 0x00,
+    0x00, 0x5a, 0x99, 0x00, 0x00, 0x5a, 0xc2, 0x00, 0x00, 0x5a, 0xe4, 0x00,
+    0x00, 0x5b, 0x0a, 0x00, 0x00, 0x5b, 0x2e, 0x00, 0x00, 0x5b, 0x51, 0x00,
+    0x00, 0x5b, 0x75, 0x00, 0x00, 0x5b, 0xa0, 0x00, 0x00, 0x5b, 0xc7, 0x00,
+    0x00, 0x5b, 0xec, 0x00, 0x00, 0x5c, 0x13, 0x00, 0x00, 0x5c, 0x37, 0x00,
+    0x00, 0x5c, 0x5c, 0x00, 0x00, 0x5c, 0x7c, 0x00, 0x00, 0x5c, 0x9e, 0x00,
+    0x00, 0x5c, 0xc2, 0x00, 0x00, 0x5c, 0xe7, 0x00, 0x00, 0x5d, 0x0d, 0x00,
+    0x00, 0x5d, 0x2f, 0x00, 0x00, 0x5d, 0x55, 0x00, 0x00, 0x5d, 0x7b, 0x00,
+    0x00, 0x5d, 0x9e, 0x00, 0x00, 0x5d, 0xc2, 0x00, 0x00, 0x5d, 0xe4, 0x00,
+    0x00, 0x5e, 0x07, 0x00, 0x00, 0x5e, 0x2b, 0x00, 0x00, 0x5e, 0x51, 0x00,
+    0x00, 0x5e, 0x75, 0x00, 0x00, 0x5e, 0x9e, 0x00, 0x00, 0x5e, 0xc3, 0x00,
+    0x00, 0x5e, 0xe7, 0x00, 0x00, 0x5f, 0x07, 0x00, 0x00, 0x5f, 0x2c, 0x00,
+    0x00, 0x5f, 0x52, 0x00, 0x00, 0x5f, 0x7a, 0x00, 0x00, 0x5f, 0x9d, 0x00,
+    0x00, 0x5f, 0xc1, 0x00, 0x00, 0x5f, 0xed, 0x00, 0x00, 0x60, 0x13, 0x00,
+    0x00, 0x60, 0x3a, 0x00, 0x00, 0x60, 0x5d, 0x00, 0x00, 0x60, 0x83, 0x00,
+    0x00, 0x60, 0xa8, 0x00, 0x00, 0x60, 0xca, 0x00, 0x00, 0x60, 0xee, 0x00,
+    0x00, 0x61, 0x15, 0x00, 0x00, 0x61, 0x3e, 0x00, 0x00, 0x61, 0x68, 0x00,
+    0x00, 0x61, 0x90, 0x00, 0x00, 0x61, 0xba, 0x00, 0x00, 0x61, 0xdc, 0x00,
+    0x00, 0x62, 0x02, 0x00, 0x00, 0x62, 0x25, 0x00, 0x00, 0x62, 0x51, 0x00,
+    0x00, 0x62, 0x81, 0x00, 0x00, 0x62, 0xa4, 0x00, 0x00, 0x62, 0xc9, 0x00,
+    0x00, 0x62, 0xea, 0x00, 0x00, 0x63, 0x14, 0x00, 0x00, 0x63, 0x37, 0x00,
+    0x00, 0x63, 0x5c, 0x00, 0x00, 0x63, 0x7b, 0x00, 0x00, 0x63, 0xa1, 0x00,
+    0x00, 0x63, 0xcc, 0x00, 0x00, 0x63, 0xee, 0x00, 0x00, 0x64, 0x0e, 0x00,
+    0x00, 0x64, 0x2c, 0x00, 0x00, 0x64, 0x53, 0x00, 0x00, 0x64, 0x78, 0x00,
+    0x00, 0x64, 0x9a, 0x00, 0x00, 0x64, 0xbe, 0x00, 0x00, 0x64, 0xe4, 0x00,
+    0x00, 0x65, 0x08, 0x00, 0x00, 0x65, 0x2c, 0x00, 0x00, 0x65, 0x52, 0x00,
+    0x00, 0x65, 0x7a, 0x00, 0x00, 0x65, 0x9e, 0x00, 0x00, 0x65, 0xbe, 0x00,
+    0x00, 0x65, 0xe3, 0x00, 0x00, 0x66, 0x09, 0x00, 0x00, 0x66, 0x2f, 0x00,
+    0x00, 0x66, 0x52, 0x00, 0x00, 0x66, 0x74, 0x00, 0x00, 0x66, 0x9c, 0x00,
+    0x00, 0x66, 0xc5, 0x00, 0x00, 0x66, 0xeb, 0x00, 0x00, 0x67, 0x0e, 0x00,
+    0x00, 0x67, 0x33, 0x00, 0x00, 0x67, 0x57, 0x00, 0x00, 0x67, 0x83, 0x00,
+    0x00, 0x67, 0xaf, 0x00, 0x00, 0x67, 0xd0, 0x00, 0x00, 0x67, 0xf4, 0x00,
+    0x00, 0x68, 0x1b, 0x00, 0x00, 0x68, 0x46, 0x00, 0x00, 0x68, 0x6d, 0x00,
+    0x00, 0x68, 0x94, 0x00, 0x00, 0x68, 0xbb, 0x00, 0x00, 0x68, 0xdf, 0x00,
+    0x00, 0x69, 0x05, 0x00, 0x00, 0x69, 0x2c, 0x00, 0x00, 0x69, 0x51, 0x00,
+    0x00, 0x69, 0x76, 0x00, 0x00, 0x69, 0x96, 0x00, 0x00, 0x69, 0xbc, 0x00,
+    0x00, 0x69, 0xe8, 0x00, 0x00, 0x6a, 0x11, 0x00, 0x00, 0x6a, 0x3d, 0x00,
+    0x00, 0x6a, 0x6d, 0x00, 0x00, 0x6a, 0x96, 0x00, 0x00, 0x6a, 0xba, 0x00,
+    0x00, 0x6a, 0xe3, 0x00, 0x00, 0x6b, 0x08, 0x00, 0x00, 0x6b, 0x30, 0x00,
+    0x00, 0x6b, 0x52, 0x00, 0x00, 0x6b, 0x7a, 0x00, 0x00, 0x6b, 0xa5, 0x00,
+    0x00, 0x6b, 0xca, 0x00, 0x00, 0x6b, 0xef, 0x00, 0x00, 0x6c, 0x11, 0x00,
+    0x00, 0x6c, 0x3a, 0x00, 0x00, 0x6c, 0x5f, 0x00, 0x00, 0x6c, 0x83, 0x00,
+    0x00, 0x6c, 0xa7, 0x00, 0x00, 0x6c, 0xcc, 0x00, 0x00, 0x6c, 0xed, 0x00,
+    0x00, 0x6d, 0x10, 0x00, 0x00, 0x6d, 0x3c, 0x00, 0x00, 0x6d, 0x65, 0x00,
+    0x00, 0x6d, 0x89, 0x00, 0x00, 0x6d, 0xad, 0x00, 0x00, 0x6d, 0xdf, 0x00,
+    0x00, 0x6e, 0x02, 0x00, 0x00, 0x6e, 0x2c, 0x00, 0x00, 0x6e, 0x54, 0x00,
+    0x00, 0x6e, 0x7e, 0x00, 0x00, 0x6e, 0xa7, 0x00, 0x00, 0x6e, 0xc9, 0x00,
+    0x00, 0x6e, 0xef, 0x00, 0x00, 0x6f, 0x14, 0x00, 0x00, 0x6f, 0x38, 0x00,
+    0x00, 0x6f, 0x5c, 0x00, 0x00, 0x6f, 0x82, 0x00, 0x00, 0x6f, 0xa9, 0x00,
+    0x00, 0x6f, 0xd0, 0x00, 0x00, 0x6f, 0xf7, 0x00, 0x00, 0x70, 0x22, 0x00,
+    0x00, 0x70, 0x4d, 0x00, 0x00, 0x70, 0x77, 0x00, 0x00, 0x70, 0x98, 0x00,
+    0x00, 0x70, 0xbf, 0x00, 0x00, 0x70, 0xe3, 0x00, 0x00, 0x71, 0x06, 0x00,
+    0x00, 0x71, 0x30, 0x00, 0x00, 0x71, 0x58, 0x00, 0x00, 0x71, 0x7d, 0x00,
+    0x00, 0x71, 0xa0, 0x00, 0x00, 0x71, 0xc5, 0x00, 0x00, 0x71, 0xec, 0x00,
+    0x00, 0x72, 0x10, 0x00, 0x00, 0x72, 0x39, 0x00, 0x00, 0x72, 0x5d, 0x00,
+    0x00, 0x72, 0x8b, 0x00, 0x00, 0x72, 0xae, 0x00, 0x00, 0x72, 0xd7, 0x00,
+    0x00, 0x73, 0x00, 0x00, 0x00, 0x73, 0x23, 0x00, 0x00, 0x73, 0x49, 0x00,
+    0x00, 0x73, 0x6d, 0x00, 0x00, 0x73, 0x93, 0x00, 0x00, 0x73, 0xc0, 0x00,
+    0x00, 0x73, 0xe6, 0x00, 0x00, 0x74, 0x08, 0x00, 0x00, 0x74, 0x2e, 0x00,
+    0x00, 0x74, 0x53, 0x00, 0x00, 0x74, 0x76, 0x00, 0x00, 0x74, 0x9f, 0x00,
+    0x00, 0x74, 0xc8, 0x00, 0x00, 0x74, 0xf0, 0x00, 0x00, 0x75, 0x14, 0x00,
+    0x00, 0x75, 0x3f, 0x00, 0x00, 0x75, 0x61, 0x00, 0x00, 0x75, 0x8e, 0x00,
+    0x00, 0x75, 0xb7, 0x00, 0x00, 0x75, 0xdb, 0x00, 0x00, 0x75, 0xfb, 0x00,
+    0x00, 0x76, 0x24, 0x00, 0x00, 0x76, 0x48, 0x00, 0x00, 0x76, 0x73, 0x00,
+    0x00, 0x76, 0x98, 0x00, 0x00, 0x76, 0xc5, 0x00, 0x00, 0x76, 0xe9, 0x00,
+    0x00, 0x77, 0x13, 0x00, 0x00, 0x77, 0x39, 0x00, 0x00, 0x77, 0x61, 0x00,
+    0x00, 0x77, 0x81, 0x00, 0x00, 0x77, 0xa9, 0x00, 0x00, 0x77, 0xca, 0x00,
+    0x00, 0x77, 0xeb, 0x00, 0x00, 0x78, 0x10, 0x00, 0x00, 0x78, 0x39, 0x00,
+    0x00, 0x78, 0x63, 0x00, 0x00, 0x78, 0x90, 0x00, 0x00, 0x78, 0xb6, 0x00,
+    0x00, 0x78, 0xe1, 0x00, 0x00, 0x79, 0x06, 0x00, 0x00, 0x79, 0x2b, 0x00,
+    0x00, 0x79, 0x4f, 0x00, 0x00, 0x79, 0x75, 0x00, 0x00, 0x79, 0x9c, 0x00,
+    0x00, 0x79, 0xc0, 0x00, 0x00, 0x79, 0xe7, 0x00, 0x00, 0x7a, 0x0c, 0x00,
+    0x00, 0x7a, 0x2f, 0x00, 0x00, 0x7a, 0x50, 0x00, 0x00, 0x7a, 0x75, 0x00,
+    0x00, 0x7a, 0x97, 0x00, 0x00, 0x7a, 0xbc, 0x00, 0x00, 0x7a, 0xdc, 0x00,
+    0x00, 0x7b, 0x05, 0x00, 0x00, 0x7b, 0x2d, 0x00, 0x00, 0x7b, 0x50, 0x00,
+    0x00, 0x7b, 0x7a, 0x00, 0x00, 0x7b, 0x9c, 0x00, 0x00, 0x7b, 0xbd, 0x00,
+    0x00, 0x7b, 0xe2, 0x00, 0x00, 0x7c, 0x08, 0x00, 0x00, 0x7c, 0x29, 0x00,
+    0x00, 0x7c, 0x4c, 0x00, 0x00, 0x7c, 0x77, 0x00, 0x00, 0x7c, 0x9a, 0x00,
+    0x00, 0x7c, 0xbf, 0x00, 0x00, 0x7c, 0xe0, 0x00, 0x00, 0x7d, 0x03, 0x00,
+    0x00, 0x7d, 0x2a, 0x00, 0x00, 0x7d, 0x54, 0x00, 0x00, 0x7d, 0x7d, 0x00,
+    0x00, 0x7d, 0xa1, 0x00, 0x00, 0x7d, 0xc6, 0x00, 0x00, 0x7d, 0xe9, 0x00,
+    0x00, 0x7e, 0x13, 0x00, 0x00, 0x7e, 0x37, 0x00, 0x00, 0x7e, 0x5b, 0x00,
+    0x00, 0x7e, 0x7b, 0x00, 0x00, 0x7e, 0xa1, 0x00, 0x00, 0x7e, 0xc6, 0x00,
+    0x00, 0x7e, 0xeb, 0x00, 0x00, 0x7f, 0x12, 0x00, 0x00, 0x7f, 0x36, 0x00,
+    0x00, 0x7f, 0x5f, 0x00, 0x00, 0x7f, 0x85, 0x00, 0x00, 0x7f, 0xac, 0x00,
+    0x00, 0x7f, 0xd0, 0x00, 0x00, 0x7f, 0xf4, 0x00, 0x00, 0x80, 0x14, 0x00,
+    0x00, 0x80, 0x3b, 0x00, 0x00, 0x80, 0x5f, 0x00, 0x00, 0x80, 0x81, 0x00,
+    0x00, 0x80, 0xa8, 0x00, 0x00, 0x80, 0xd3, 0x00, 0x00, 0x80, 0xfd, 0x00,
+    0x00, 0x81, 0x23, 0x00, 0x00, 0x81, 0x48, 0x00, 0x00, 0x81, 0x72, 0x00,
+    0x00, 0x81, 0x98, 0x00, 0x00, 0x81, 0xc0, 0x00, 0x00, 0x81, 0xe8, 0x00,
+    0x00, 0x82, 0x0e, 0x00, 0x00, 0x82, 0x37, 0x00, 0x00, 0x82, 0x56, 0x00,
+    0x00, 0x82, 0x7a, 0x00, 0x00, 0x82, 0xa0, 0x00, 0x00, 0x82, 0xc5, 0x00,
+    0x00, 0x82, 0xeb, 0x00, 0x00, 0x83, 0x11, 0x00, 0x00, 0x83, 0x37, 0x00,
+    0x00, 0x83, 0x5d, 0x00, 0x00, 0x83, 0x81, 0x00, 0x00, 0x83, 0xa9, 0x00,
+    0x00, 0x83, 0xcf, 0x00, 0x00, 0x83, 0xf5, 0x00, 0x00, 0x84, 0x1e, 0x00,
+    0x00, 0x84, 0x45, 0x00, 0x00, 0x84, 0x67, 0x00, 0x00, 0x84, 0x8a, 0x00,
+    0x00, 0x84, 0xb8, 0x00, 0x00, 0x84, 0xdc, 0x00, 0x00, 0x85, 0x00, 0x00,
+    0x00, 0x85, 0x26, 0x00, 0x00, 0x85, 0x4f, 0x00, 0x00, 0x85, 0x73, 0x00,
+    0x00, 0x85, 0x9a, 0x00, 0x00, 0x85, 0xbf, 0x00, 0x00, 0x85, 0xe8, 0x00,
+    0x00, 0x86, 0x0d, 0x00, 0x00, 0x86, 0x30, 0x00, 0x00, 0x86, 0x4f, 0x00,
+    0x00, 0x86, 0x71, 0x00, 0x00, 0x86, 0x98, 0x00, 0x00, 0x86, 0xc7, 0x00,
+    0x00, 0x86, 0xe7, 0x00, 0x00, 0x87, 0x0f, 0x00, 0x00, 0x87, 0x3c, 0x00,
+    0x00, 0x87, 0x6a, 0x00, 0x00, 0x87, 0x8c, 0x00, 0x00, 0x87, 0xb3, 0x00,
+    0x00, 0x87, 0xd2, 0x00, 0x00, 0x87, 0xf7, 0x00, 0x00, 0x88, 0x19, 0x00,
+    0x00, 0x88, 0x42, 0x00, 0x00, 0x88, 0x66, 0x00, 0x00, 0x88, 0x8c, 0x00,
+    0x00, 0x88, 0xb9, 0x00, 0x00, 0x88, 0xe0, 0x00, 0x00, 0x89, 0x07, 0x00,
+    0x00, 0x89, 0x2f, 0x00, 0x00, 0x89, 0x54, 0x00, 0x00, 0x89, 0x7a, 0x00,
+    0x00, 0x89, 0x9e, 0x00, 0x00, 0x89, 0xc1, 0x00, 0x00, 0x89, 0xe3, 0x00,
+    0x00, 0x8a, 0x08, 0x00, 0x00, 0x8a, 0x2f, 0x00, 0x00, 0x8a, 0x57, 0x00,
+    0x00, 0x8a, 0x7e, 0x00, 0x00, 0x8a, 0xa4, 0x00, 0x00, 0x8a, 0xc9, 0x00,
+    0x00, 0x8a, 0xed, 0x00, 0x00, 0x8b, 0x13, 0x00, 0x00, 0x8b, 0x38, 0x00,
+    0x00, 0x8b, 0x60, 0x00, 0x00, 0x8b, 0x8d, 0x00, 0x00, 0x8b, 0xb8, 0x00,
+    0x00, 0x8b, 0xd9, 0x00, 0x00, 0x8b, 0xff, 0x00, 0x00, 0x8c, 0x24, 0x00,
+    0x00, 0x8c, 0x46, 0x00, 0x00, 0x8c, 0x69, 0x00, 0x00, 0x8c, 0x8d, 0x00,
+    0x00, 0x8c, 0xb6, 0x00, 0x00, 0x8c, 0xd8, 0x00, 0x00, 0x8c, 0xfa, 0x00,
+    0x00, 0x8d, 0x1b, 0x00, 0x00, 0x8d, 0x43, 0x00, 0x00, 0x8d, 0x65, 0x00,
+    0x00, 0x8d, 0x88, 0x00, 0x00, 0x8d, 0xaf, 0x00, 0x00, 0x8d, 0xd1, 0x00,
+    0x00, 0x8d, 0xf9, 0x00, 0x00, 0x8e, 0x22, 0x00, 0x00, 0x8e, 0x47, 0x00,
+    0x00, 0x8e, 0x6f, 0x00, 0x00, 0x8e, 0x96, 0x00, 0x00, 0x8e, 0xbc, 0x00,
+    0x00, 0x8e, 0xdf, 0x00, 0x00, 0x8f, 0x02, 0x00, 0x00, 0x8f, 0x2a, 0x00,
+    0x00, 0x8f, 0x53, 0x00, 0x00, 0x8f, 0x79, 0x00, 0x00, 0x8f, 0x9d, 0x00,
+    0x00, 0x8f, 0xc4, 0x00, 0x00, 0x8f, 0xed, 0x00, 0x00, 0x90, 0x12, 0x00,
+    0x00, 0x90, 0x40, 0x00, 0x00, 0x90, 0x6b, 0x00, 0x00, 0x90, 0x91, 0x00,
+    0x00, 0x90, 0xb6, 0x00, 0x00, 0x90, 0xdb, 0x00, 0x00, 0x90, 0xfb, 0x00,
+    0x00, 0x91, 0x24, 0x00, 0x00, 0x91, 0x4d, 0x00, 0x00, 0x91, 0x78, 0x00,
+    0x00, 0x91, 0x9b, 0x00, 0x00, 0x91, 0xc9, 0x00, 0x00, 0x91, 0xee, 0x00,
+    0x00, 0x92, 0x11, 0x00, 0x00, 0x92, 0x3c, 0x00, 0x00, 0x92, 0x5d, 0x00,
+    0x00, 0x92, 0x89, 0x00, 0x00, 0x92, 0xae, 0x00, 0x00, 0x92, 0xd1, 0x00,
+    0x00, 0x92, 0xf6, 0x00, 0x00, 0x93, 0x19, 0x00, 0x00, 0x93, 0x44, 0x00,
+    0x00, 0x93, 0x6c, 0x00, 0x00, 0x93, 0x93, 0x00, 0x00, 0x93, 0xb5, 0x00,
+    0x00, 0x93, 0xdc, 0x00, 0x00, 0x93, 0xfc, 0x00, 0x00, 0x94, 0x1d, 0x00,
+    0x00, 0x94, 0x43, 0x00, 0x00, 0x94, 0x65, 0x00, 0x00, 0x94, 0x8d, 0x00,
+    0x00, 0x94, 0xb1, 0x00, 0x00, 0x94, 0xdd, 0x00, 0x00, 0x95, 0x02, 0x00,
+    0x00, 0x95, 0x2c, 0x00, 0x00, 0x95, 0x4f, 0x00, 0x00, 0x95, 0x74, 0x00,
+    0x00, 0x95, 0x9b, 0x00, 0x00, 0x95, 0xc1, 0x00, 0x00, 0x95, 0xea, 0x00,
+    0x00, 0x96, 0x0a, 0x00, 0x00, 0x96, 0x2d, 0x00, 0x00, 0x96, 0x55, 0x00,
+    0x00, 0x96, 0x7a, 0x00, 0x00, 0x96, 0xa0, 0x00, 0x00, 0x96, 0xc7, 0x00,
+    0x00, 0x96, 0xf0, 0x00, 0x00, 0x97, 0x17, 0x00, 0x00, 0x97, 0x3a, 0x00,
+    0x00, 0x97, 0x60, 0x00, 0x00, 0x97, 0x85, 0x00, 0x00, 0x97, 0xae, 0x00,
+    0x00, 0x97, 0xd0, 0x00, 0x00, 0x97, 0xf9, 0x00, 0x00, 0x98, 0x21, 0x00,
+    0x00, 0x98, 0x4a, 0x00, 0x00, 0x98, 0x6d, 0x00, 0x00, 0x98, 0x91, 0x00,
+    0x00, 0x98, 0xba, 0x00, 0x00, 0x98, 0xda, 0x00, 0x00, 0x98, 0xfe, 0x00,
+    0x00, 0x99, 0x28, 0x00, 0x00, 0x99, 0x4b, 0x00, 0x00, 0x99, 0x72, 0x00,
+    0x00, 0x99, 0x9d, 0x00, 0x00, 0x99, 0xc5, 0x00, 0x00, 0x99, 0xeb, 0x00,
+    0x00, 0x9a, 0x14, 0x00, 0x00, 0x9a, 0x35, 0x00, 0x00, 0x9a, 0x5a, 0x00,
+    0x00, 0x9a, 0x85, 0x00, 0x00, 0x9a, 0xa9, 0x00, 0x00, 0x9a, 0xd2, 0x00,
+    0x00, 0x9a, 0xf4, 0x00, 0x00, 0x9b, 0x17, 0x00, 0x00, 0x9b, 0x3a, 0x00,
+    0x00, 0x9b, 0x61, 0x00, 0x00, 0x9b, 0x83, 0x00, 0x00, 0x9b, 0xaf, 0x00,
+    0x00, 0x9b, 0xd4, 0x00, 0x00, 0x9b, 0xfd, 0x00, 0x00, 0x9c, 0x24, 0x00,
+    0x00, 0x9c, 0x4a, 0x00, 0x00, 0x9c, 0x6e, 0x00, 0x00, 0x9c, 0x91, 0x00,
+    0x00, 0x9c, 0xb5, 0x00, 0x00, 0x9c, 0xd9, 0x00, 0x00, 0x9d, 0x05, 0x00,
+    0x00, 0x9d, 0x28, 0x00, 0x00, 0x9d, 0x50, 0x00, 0x00, 0x9d, 0x76, 0x00,
+    0x00, 0x9d, 0x9b, 0x00, 0x00, 0x9d, 0xc3, 0x00, 0x00, 0x9d, 0xe5, 0x00,
+    0x00, 0x9e, 0x09, 0x00, 0x00, 0x9e, 0x2e, 0x00, 0x00, 0x9e, 0x59, 0x00,
+    0x00, 0x9e, 0x87, 0x00, 0x00, 0x9e, 0xad, 0x00, 0x00, 0x9e, 0xd6, 0x00,
+    0x00, 0x9e, 0xfb, 0x00, 0x00, 0x9f, 0x22, 0x00, 0x00, 0x9f, 0x49, 0x00,
+    0x00, 0x9f, 0x71, 0x00, 0x00, 0x9f, 0x95, 0x00, 0x00, 0x9f, 0xb6, 0x00,
+    0x00, 0x9f, 0xe2, 0x00, 0x00, 0xa0, 0x08, 0x00, 0x00, 0xa0, 0x2b, 0x00,
+    0x00, 0xa0, 0x4f, 0x00, 0x00, 0xa0, 0x72, 0x00, 0x00, 0xa0, 0xa1, 0x00,
+    0x00, 0xa0, 0xc6, 0x00, 0x00, 0xa0, 0xeb, 0x00, 0x00, 0xa1, 0x13, 0x00,
+    0x00, 0xa1, 0x36, 0x00, 0x00, 0xa1, 0x57, 0x00, 0x00, 0xa1, 0x7f, 0x00,
+    0x00, 0xa1, 0xa6, 0x00, 0x00, 0xa1, 0xcf, 0x00, 0x00, 0xa1, 0xf4, 0x00,
+    0x00, 0xa2, 0x19, 0x00, 0x00, 0xa2, 0x3c, 0x00, 0x00, 0xa2, 0x5c, 0x00,
+    0x00, 0xa2, 0x81, 0x00, 0x00, 0xa2, 0xaa, 0x00, 0x00, 0xa2, 0xd1, 0x00,
+    0x00, 0xa2, 0xf8, 0x00, 0x00, 0xa3, 0x1f, 0x00, 0x00, 0xa3, 0x44, 0x00,
+    0x00, 0xa3, 0x68, 0x00, 0x00, 0xa3, 0x89, 0x00, 0x00, 0xa3, 0xb4, 0x00,
+    0x00, 0xa3, 0xd5, 0x00, 0x00, 0xa3, 0xfe, 0x00, 0x00, 0xa4, 0x22, 0x00,
+    0x00, 0xa4, 0x46, 0x00, 0x00, 0xa4, 0x68, 0x00, 0x00, 0xa4, 0x91, 0x00,
+    0x00, 0xa4, 0xb8, 0x00, 0x00, 0xa4, 0xe1, 0x00, 0x00, 0xa5, 0x0b, 0x00,
+    0x00, 0xa5, 0x2f, 0x00, 0x00, 0xa5, 0x5b, 0x00, 0x00, 0xa5, 0x7e, 0x00,
+    0x00, 0xa5, 0x9e, 0x00, 0x00, 0xa5, 0xc4, 0x00, 0x00, 0xa5, 0xec, 0x00,
+    0x00, 0xa6, 0x10, 0x00, 0x00, 0xa6, 0x35, 0x00, 0x00, 0xa6, 0x5a, 0x00,
+    0x00, 0xa6, 0x7c, 0x00, 0x00, 0xa6, 0xa0, 0x00, 0x00, 0xa6, 0xc5, 0x00,
+    0x00, 0xa6, 0xec, 0x00, 0x00, 0xa7, 0x17, 0x00, 0x00, 0xa7, 0x44, 0x00,
+    0x00, 0xa7, 0x6b, 0x00, 0x00, 0xa7, 0x8d, 0x00, 0x00, 0xa7, 0xb1, 0x00,
+    0x00, 0xa7, 0xd2, 0x00, 0x00, 0xa7, 0xfc, 0x00, 0x00, 0xa8, 0x1f, 0x00,
+    0x00, 0xa8, 0x45, 0x00, 0x00, 0xa8, 0x68, 0x00, 0x00, 0xa8, 0x8c, 0x00,
+    0x00, 0xa8, 0xb0, 0x00, 0x00, 0xa8, 0xd8, 0x00, 0x00, 0xa8, 0xff, 0x00,
+    0x00, 0xa9, 0x20, 0x00, 0x00, 0xa9, 0x4a, 0x00, 0x00, 0xa9, 0x6f, 0x00,
+    0x00, 0xa9, 0x93, 0x00, 0x00, 0xa9, 0xb8, 0x00, 0x00, 0xa9, 0xdc, 0x00,
+    0x00, 0xaa, 0x01, 0x00, 0x00, 0xaa, 0x28, 0x00, 0x00, 0xaa, 0x4a, 0x00,
+    0x00, 0xaa, 0x71, 0x00, 0x00, 0xaa, 0x95, 0x00, 0x00, 0xaa, 0xba, 0x00,
+    0x00, 0xaa, 0xdf, 0x00, 0x00, 0xab, 0x02, 0x00, 0x00, 0xab, 0x31, 0x00,
+    0x00, 0xab, 0x55, 0x00, 0x00, 0xab, 0x80, 0x00, 0x00, 0xab, 0xa1, 0x00,
+    0x00, 0xab, 0xd0, 0x00, 0x00, 0xab, 0xf6, 0x00, 0x00, 0xac, 0x16, 0x00,
+    0x00, 0xac, 0x36, 0x00, 0x00, 0xac, 0x58, 0x00, 0x00, 0xac, 0x7f, 0x00,
+    0x00, 0xac, 0xa6, 0x00, 0x00, 0xac, 0xcb, 0x00, 0x00, 0xac, 0xf0, 0x00,
+    0x00, 0xad, 0x1a, 0x00, 0x00, 0xad, 0x3a, 0x00, 0x00, 0xad, 0x5e, 0x00,
+    0x00, 0xad, 0x83, 0x00, 0x00, 0xad, 0xa8, 0x00, 0x00, 0xad, 0xce, 0x00,
+    0x00, 0xad, 0xf4, 0x00, 0x00, 0xae, 0x1c, 0x00, 0x00, 0xae, 0x41, 0x00,
+    0x00, 0xae, 0x66, 0x00, 0x00, 0xae, 0x94, 0x00, 0x00, 0xae, 0xbc, 0x00,
+    0x00, 0xae, 0xe4, 0x00, 0x00, 0xaf, 0x08, 0x00, 0x00, 0xaf, 0x2d, 0x00,
+    0x00, 0xaf, 0x59, 0x00, 0x00, 0xaf, 0x83, 0x00, 0x00, 0xaf, 0xb0, 0x00,
+    0x00, 0xaf, 0xd3, 0x00, 0x00, 0xaf, 0xf2, 0x00, 0x00, 0xb0, 0x15, 0x00,
+    0x00, 0xb0, 0x41, 0x00, 0x00, 0xb0, 0x66, 0x00, 0x00, 0xb0, 0x85, 0x00,
+    0x00, 0xb0, 0xaa, 0x00, 0x00, 0xb0, 0xd8, 0x00, 0x00, 0xb0, 0xfd, 0x00,
+    0x00, 0xb1, 0x29, 0x00, 0x00, 0xb1, 0x4a, 0x00, 0x00, 0xb1, 0x74, 0x00,
+    0x00, 0xb1, 0x9b, 0x00, 0x00, 0xb1, 0xc4, 0x00, 0x00, 0xb1, 0xe8, 0x00,
+    0x00, 0xb2, 0x0a, 0x00, 0x00, 0xb2, 0x2f, 0x00, 0x00, 0xb2, 0x54, 0x00,
+    0x00, 0xb2, 0x7c, 0x00, 0x00, 0xb2, 0xa0, 0x00, 0x00, 0xb2, 0xca, 0x00,
+    0x00, 0xb2, 0xf3, 0x00, 0x00, 0xb3, 0x16, 0x00, 0x00, 0xb3, 0x3c, 0x00,
+    0x00, 0xb3, 0x61, 0x00, 0x00, 0xb3, 0x84, 0x00, 0x00, 0xb3, 0xad, 0x00,
+    0x00, 0xb3, 0xdc, 0x00, 0x00, 0xb4, 0x02, 0x00, 0x00, 0xb4, 0x26, 0x00,
+    0x00, 0xb4, 0x49, 0x00, 0x00, 0xb4, 0x71, 0x00, 0x00, 0xb4, 0x9c, 0x00,
+    0x00, 0xb4, 0xc0, 0x00, 0x00, 0xb4, 0xef, 0x00, 0x00, 0xb5, 0x16, 0x00,
+    0x00, 0xb5, 0x3e, 0x00, 0x00, 0xb5, 0x65, 0x00, 0x00, 0xb5, 0x8f, 0x00,
+    0x00, 0xb5, 0xb4, 0x00, 0x00, 0xb5, 0xd8, 0x00, 0x00, 0xb6, 0x00, 0x00,
+    0x00, 0xb6, 0x27, 0x00, 0x00, 0xb6, 0x4c, 0x00, 0x00, 0xb6, 0x78, 0x00,
+    0x00, 0xb6, 0x9d, 0x00, 0x00, 0xb6, 0xc5, 0x00, 0x00, 0xb6, 0xeb, 0x00,
+    0x00, 0xb7, 0x17, 0x00, 0x00, 0xb7, 0x3c, 0x00, 0x00, 0xb7, 0x61, 0x00,
+    0x00, 0xb7, 0x88, 0x00, 0x00, 0xb7, 0xb9, 0x00, 0x00, 0xb7, 0xdf, 0x00,
+    0x00, 0xb8, 0x04, 0x00, 0x00, 0xb8, 0x2a, 0x00, 0x00, 0xb8, 0x51, 0x00,
+    0x00, 0xb8, 0x75, 0x00, 0x00, 0xb8, 0x97, 0x00, 0x00, 0xb8, 0xbb, 0x00,
+    0x00, 0xb8, 0xdc, 0x00, 0x00, 0xb9, 0x01, 0x00, 0x00, 0xb9, 0x26, 0x00,
+    0x00, 0xb9, 0x4d, 0x00, 0x00, 0xb9, 0x71, 0x00, 0x00, 0xb9, 0x95, 0x00,
+    0x00, 0xb9, 0xbb, 0x00, 0x00, 0xb9, 0xe2, 0x00, 0x00, 0xba, 0x0a, 0x00,
+    0x00, 0xba, 0x2a, 0x00, 0x00, 0xba, 0x4f, 0x00, 0x00, 0xba, 0x76, 0x00,
+    0x00, 0xba, 0x9e, 0x00, 0x00, 0xba, 0xc2, 0x00, 0x00, 0xba, 0xe4, 0x00,
+    0x00, 0xbb, 0x08, 0x00, 0x00, 0xbb, 0x2a, 0x00, 0x00, 0xbb, 0x51, 0x00,
+    0x00, 0xbb, 0x74, 0x00, 0x00, 0xbb, 0x99, 0x00, 0x00, 0xbb, 0xbe, 0x00,
+    0x00, 0xbb, 0xe3, 0x00, 0x00, 0xbc, 0x07, 0x00, 0x00, 0xbc, 0x28, 0x00,
+    0x00, 0xbc, 0x4c, 0x00, 0x00, 0xbc, 0x72, 0x00, 0x00, 0xbc, 0x9a, 0x00,
+    0x00, 0xbc, 0xba, 0x00, 0x00, 0xbc, 0xde, 0x00, 0x00, 0xbd, 0x07, 0x00,
+    0x00, 0xbd, 0x29, 0x00, 0x00, 0xbd, 0x49, 0x00, 0x00, 0xbd, 0x6f, 0x00,
+    0x00, 0xbd, 0x97, 0x00, 0x00, 0xbd, 0xb9, 0x00, 0x00, 0xbd, 0xdd, 0x00,
+    0x00, 0xbd, 0xfe, 0x00, 0x00, 0xbe, 0x23, 0x00, 0x00, 0xbe, 0x4b, 0x00,
+    0x00, 0xbe, 0x71, 0x00, 0x00, 0xbe, 0x98, 0x00, 0x00, 0xbe, 0xbe, 0x00,
+    0x00, 0xbe, 0xec, 0x00, 0x00, 0xbf, 0x16, 0x00, 0x00, 0xbf, 0x3e, 0x00,
+    0x00, 0xbf, 0x62, 0x00, 0x00, 0xbf, 0x88, 0x00, 0x00, 0xbf, 0xb2, 0x00,
+    0x00, 0xbf, 0xe0, 0x00, 0x00, 0xc0, 0x05, 0x00, 0x00, 0xc0, 0x27, 0x00,
+    0x00, 0xc0, 0x4e, 0x00, 0x00, 0xc0, 0x74, 0x00, 0x00, 0xc0, 0x9b, 0x00,
+    0x00, 0xc0, 0xc1, 0x00, 0x00, 0xc0, 0xe5, 0x00, 0x00, 0xc1, 0x09, 0x00,
+    0x00, 0xc1, 0x2d, 0x00, 0x00, 0xc1, 0x5c, 0x00, 0x00, 0xc1, 0x88, 0x00,
+    0x00, 0xc1, 0xa8, 0x00, 0x00, 0xc1, 0xca, 0x00, 0x00, 0xc1, 0xf0, 0x00,
+    0x00, 0xc2, 0x11, 0x00, 0x00, 0xc2, 0x37, 0x00, 0x00, 0xc2, 0x5b, 0x00,
+    0x00, 0xc2, 0x82, 0x00, 0x00, 0xc2, 0xa8, 0x00, 0x00, 0xc2, 0xd3, 0x00,
+    0x00, 0xc2, 0xf7, 0x00, 0x00, 0xc3, 0x19, 0x00, 0x00, 0xc3, 0x3e, 0x00,
+    0x00, 0xc3, 0x5f, 0x00, 0x00, 0xc3, 0x8a, 0x00, 0x00, 0xc3, 0xad, 0x00,
+    0x00, 0xc3, 0xcf, 0x00, 0x00, 0xc3, 0xf4, 0x00, 0x00, 0xc4, 0x1b, 0x00,
+    0x00, 0xc4, 0x3a, 0x00, 0x00, 0xc4, 0x5c, 0x00, 0x00, 0xc4, 0x86, 0x00,
+    0x00, 0xc4, 0xac, 0x00, 0x00, 0xc4, 0xd6, 0x00, 0x00, 0xc4, 0xfe, 0x00,
+    0x00, 0xc5, 0x22, 0x00, 0x00, 0xc5, 0x46, 0x00, 0x00, 0xc5, 0x6f, 0x00,
+    0x00, 0xc5, 0x9d, 0x00, 0x00, 0xc5, 0xc1, 0x00, 0x00, 0xc5, 0xe8, 0x00,
+    0x00, 0xc6, 0x08, 0x00, 0x00, 0xc6, 0x2c, 0x00, 0x00, 0xc6, 0x51, 0x00,
+    0x00, 0xc6, 0x7c, 0x00, 0x00, 0xc6, 0xa7, 0x00, 0x00, 0xc6, 0xd0, 0x00,
+    0x00, 0xc6, 0xf2, 0x00, 0x00, 0xc7, 0x15, 0x00, 0x00, 0xc7, 0x39, 0x00,
+    0x00, 0xc7, 0x5c, 0x00, 0x00, 0xc7, 0x82, 0x00, 0x00, 0xc7, 0xad, 0x00,
+    0x00, 0xc7, 0xd2, 0x00, 0x00, 0xc7, 0xfa, 0x00, 0x00, 0xc8, 0x24, 0x00,
+    0x00, 0xc8, 0x4b, 0x00, 0x00, 0xc8, 0x6e, 0x00, 0x00, 0xc8, 0x98, 0x00,
+    0x00, 0xc8, 0xbc, 0x00, 0x00, 0xc8, 0xde, 0x00, 0x00, 0xc9, 0x04, 0x00,
+    0x00, 0xc9, 0x2e, 0x00, 0x00, 0xc9, 0x51, 0x00, 0x00, 0xc9, 0x76, 0x00,
+    0x00, 0xc9, 0x9b, 0x00, 0x00, 0xc9, 0xc1, 0x00, 0x00, 0xc9, 0xe5, 0x00,
+    0x00, 0xca, 0x10, 0x00, 0x00, 0xca, 0x39, 0x00, 0x00, 0xca, 0x62, 0x00,
+    0x00, 0xca, 0x89, 0x00, 0x00, 0xca, 0xae, 0x00, 0x00, 0xca, 0xd0, 0x00,
+    0x00, 0xca, 0xf3, 0x00, 0x00, 0xcb, 0x16, 0x00, 0x00, 0xcb, 0x41, 0x00,
+    0x00, 0xcb, 0x68, 0x00, 0x00, 0xcb, 0x88, 0x00, 0x00, 0xcb, 0xae, 0x00,
+    0x00, 0xcb, 0xd2, 0x00, 0x00, 0xcb, 0xfe, 0x00, 0x00, 0xcc, 0x25, 0x00,
+    0x00, 0xcc, 0x4b, 0x00, 0x00, 0xcc, 0x70, 0x00, 0x00, 0xcc, 0x99, 0x00,
+    0x00, 0xcc, 0xc1, 0x00, 0x00, 0xcc, 0xe5, 0x00, 0x00, 0xcd, 0x05, 0x00,
+    0x00, 0xcd, 0x2c, 0x00, 0x00, 0xcd, 0x51, 0x00, 0x00, 0xcd, 0x79, 0x00,
+    0x00, 0xcd, 0x9d, 0x00, 0x00, 0xcd, 0xc2, 0x00, 0x00, 0xcd, 0xe7, 0x00,
+    0x00, 0xce, 0x0d, 0x00, 0x00, 0xce, 0x32, 0x00, 0x00, 0xce, 0x62, 0x00,
+    0x00, 0xce, 0x86, 0x00, 0x00, 0xce, 0xac, 0x00, 0x00, 0xce, 0xd0, 0x00,
+    0x00, 0xce, 0xf8, 0x00, 0x00, 0xcf, 0x22, 0x00, 0x00, 0xcf, 0x43, 0x00,
+    0x00, 0xcf, 0x68, 0x00, 0x00, 0xcf, 0x8a, 0x00, 0x00, 0xcf, 0xb0, 0x00,
+    0x00, 0xcf, 0xd5, 0x00, 0x00, 0xcf, 0xfe, 0x00, 0x00, 0xd0, 0x2a, 0x00,
+    0x00, 0xd0, 0x4f, 0x00, 0x00, 0xd0, 0x74, 0x00, 0x00, 0xd0, 0x9b, 0x00,
+    0x00, 0xd0, 0xc0, 0x00, 0x00, 0xd0, 0xe5, 0x00, 0x00, 0xd1, 0x09, 0x00,
+    0x00, 0xd1, 0x2d, 0x00, 0x00, 0xd1, 0x50, 0x00, 0x00, 0xd1, 0x79, 0x00,
+    0x00, 0xd1, 0xa4, 0x00, 0x00, 0xd1, 0xc9, 0x00, 0x00, 0xd1, 0xec, 0x00,
+    0x00, 0xd2, 0x13, 0x00, 0x00, 0xd2, 0x40, 0x00, 0x00, 0xd2, 0x64, 0x00,
+    0x00, 0xd2, 0x91, 0x00, 0x00, 0xd2, 0xb2, 0x00, 0x00, 0xd2, 0xd7, 0x00,
+    0x00, 0xd2, 0xfa, 0x00, 0x00, 0xd3, 0x1d, 0x00, 0x00, 0xd3, 0x48, 0x00,
+    0x00, 0xd3, 0x6e, 0x00, 0x00, 0xd3, 0x95, 0x00, 0x00, 0xd3, 0xb9, 0x00,
+    0x00, 0xd3, 0xe0, 0x00, 0x00, 0xd4, 0x0a, 0x00, 0x00, 0xd4, 0x32, 0x00,
+    0x00, 0xd4, 0x58, 0x00, 0x00, 0xd4, 0x81, 0x00, 0x00, 0xd4, 0xa5, 0x00,
+    0x00, 0xd4, 0xd2, 0x00, 0x00, 0xd4, 0xfa, 0x00, 0x00, 0xd5, 0x1f, 0x00,
+    0x00, 0xd5, 0x46, 0x00, 0x00, 0xd5, 0x6c, 0x00, 0x00, 0xd5, 0x91, 0x00,
+    0x00, 0xd5, 0xbb, 0x00, 0x00, 0xd5, 0xdd, 0x00, 0x00, 0xd6, 0x00, 0x00,
+    0x00, 0xd6, 0x23, 0x00, 0x00, 0xd6, 0x45, 0x00, 0x00, 0xd6, 0x6a, 0x00,
+    0x00, 0xd6, 0x8c, 0x00, 0x00, 0xd6, 0xb2, 0x00, 0x00, 0xd6, 0xd6, 0x00,
+    0x00, 0xd6, 0xf6, 0x00, 0x00, 0xd7, 0x23, 0x00, 0x00, 0xd7, 0x46, 0x00,
+    0x00, 0xd7, 0x69, 0x00, 0x00, 0xd7, 0x8c, 0x00, 0x00, 0xd7, 0xb1, 0x00,
+    0x00, 0xd7, 0xd5, 0x00, 0x00, 0xd7, 0xf8, 0x00, 0x00, 0xd8, 0x1e, 0x00,
+    0x00, 0xd8, 0x42, 0x00, 0x00, 0xd8, 0x63, 0x00, 0x00, 0xd8, 0x90, 0x00,
+    0x00, 0xd8, 0xb3, 0x00, 0x00, 0xd8, 0xd9, 0x00, 0x00, 0xd8, 0xfd, 0x00,
+    0x00, 0xd9, 0x1f, 0x00, 0x00, 0xd9, 0x43, 0x00, 0x00, 0xd9, 0x67, 0x00,
+    0x00, 0xd9, 0x8c, 0x00, 0x00, 0xd9, 0xb3, 0x00, 0x00, 0xd9, 0xd8, 0x00,
+    0x00, 0xd9, 0xff, 0x00, 0x00, 0xda, 0x29, 0x00, 0x00, 0xda, 0x4e, 0x00,
+    0x00, 0xda, 0x72, 0x00, 0x00, 0xda, 0x98, 0x00, 0x00, 0xda, 0xc3, 0x00,
+    0x00, 0xda, 0xe9, 0x00, 0x00, 0xdb, 0x13, 0x00, 0x00, 0xdb, 0x38, 0x00,
+    0x00, 0xdb, 0x66, 0x00, 0x00, 0xdb, 0x84, 0x00, 0x00, 0xdb, 0xae, 0x00,
+    0x00, 0xdb, 0xd2, 0x00, 0x00, 0xdb, 0xf9, 0x00, 0x00, 0xdc, 0x1e, 0x00,
+    0x00, 0xdc, 0x44, 0x00, 0x00, 0xdc, 0x6d, 0x00, 0x00, 0xdc, 0x9a, 0x00,
+    0x00, 0xdc, 0xc0, 0x00, 0x00, 0xdc, 0xe5, 0x00, 0x00, 0xdd, 0x0b, 0x00,
+    0x00, 0xdd, 0x35, 0x00, 0x00, 0xdd, 0x61, 0x00, 0x00, 0xdd, 0x88, 0x00,
+    0x00, 0xdd, 0xad, 0x00, 0x00, 0xdd, 0xd9, 0x00, 0x00, 0xde, 0x03, 0x00,
+    0x00, 0xde, 0x2b, 0x00, 0x00, 0xde, 0x4f, 0x00, 0x00, 0xde, 0x71, 0x00,
+    0x00, 0xde, 0x9b, 0x00, 0x00, 0xde, 0xc1, 0x00, 0x00, 0xde, 0xe7, 0x00,
+    0x00, 0xdf, 0x0f, 0x00, 0x00, 0xdf, 0x3c, 0x00, 0x00, 0xdf, 0x64, 0x00,
+    0x00, 0xdf, 0x8a, 0x00, 0x00, 0xdf, 0xae, 0x00, 0x00, 0xdf, 0xd1, 0x00,
+    0x00, 0xdf, 0xf2, 0x00, 0x00, 0xe0, 0x15, 0x00, 0x00, 0xe0, 0x3c, 0x00,
+    0x00, 0xe0, 0x63, 0x00, 0x00, 0xe0, 0x88, 0x00, 0x00, 0xe0, 0xae, 0x00,
+    0x00, 0xe0, 0xd7, 0x00, 0x00, 0xe0, 0xf8, 0x00, 0x00, 0xe1, 0x1e, 0x00,
+    0x00, 0xe1, 0x4b, 0x00, 0x00, 0xe1, 0x73, 0x00, 0x00, 0xe1, 0x9a, 0x00,
+    0x00, 0xe1, 0xbb, 0x00, 0x00, 0xe1, 0xe0, 0x00, 0x00, 0xe2, 0x09, 0x00,
+    0x00, 0xe2, 0x2a, 0x00, 0x00, 0xe2, 0x4f, 0x00, 0x00, 0xe2, 0x72, 0x00,
+    0x00, 0xe2, 0xa1, 0x00, 0x00, 0xe2, 0xc6, 0x00, 0x00, 0xe2, 0xed, 0x00,
+    0x00, 0xe3, 0x12, 0x00, 0x00, 0xe3, 0x3d, 0x00, 0x00, 0xe3, 0x67, 0x00,
+    0x00, 0xe3, 0x8a, 0x00, 0x00, 0xe3, 0xb7, 0x00, 0x00, 0xe3, 0xdf, 0x00,
+    0x00, 0xe4, 0x09, 0x00, 0x00, 0xe4, 0x2d, 0x00, 0x00, 0xe4, 0x55, 0x00,
+    0x00, 0xe4, 0x7e, 0x00, 0x00, 0xe4, 0xa4, 0x00, 0x00, 0xe4, 0xca, 0x00,
+    0x00, 0xe4, 0xf1, 0x00, 0x00, 0xe5, 0x15, 0x00, 0x00, 0xe5, 0x3c, 0x00,
+    0x00, 0xe5, 0x65, 0x00, 0x00, 0xe5, 0x8a, 0x00, 0x00, 0xe5, 0xb2, 0x00,
+    0x00, 0xe5, 0xd6, 0x00, 0x00, 0xe5, 0xfc, 0x00, 0x00, 0xe6, 0x22, 0x00,
+    0x00, 0xe6, 0x4b, 0x00, 0x00, 0xe6, 0x6e, 0x00, 0x00, 0xe6, 0x95, 0x00,
+    0x00, 0xe6, 0xc0, 0x00, 0x00, 0xe6, 0xe3, 0x00, 0x00, 0xe7, 0x0b, 0x00,
+    0x00, 0xe7, 0x33, 0x00, 0x00, 0xe7, 0x57, 0x00, 0x00, 0xe7, 0x79, 0x00,
+    0x00, 0xe7, 0x9d, 0x00, 0x00, 0xe7, 0xc2, 0x00, 0x00, 0xe7, 0xf0, 0x00,
+    0x00, 0xe8, 0x14, 0x00, 0x00, 0xe8, 0x3c, 0x00, 0x00, 0xe8, 0x60, 0x00,
+    0x00, 0xe8, 0x85, 0x00, 0x00, 0xe8, 0xae, 0x00, 0x00, 0xe8, 0xcf, 0x00,
+    0x00, 0xe8, 0xf1, 0x00, 0x00, 0xe9, 0x18, 0x00, 0x00, 0xe9, 0x41, 0x00,
+    0x00, 0xe9, 0x63, 0x00, 0x00, 0xe9, 0x89, 0x00, 0x00, 0xe9, 0xb2, 0x00,
+    0x00, 0xe9, 0xd4, 0x00, 0x00, 0xe9, 0xf8, 0x00, 0x00, 0xea, 0x20, 0x00,
+    0x00, 0xea, 0x44, 0x00, 0x00, 0xea, 0x6c, 0x00, 0x00, 0xea, 0x98, 0x00,
+    0x00, 0xea, 0xc2, 0x00, 0x00, 0xea, 0xe5, 0x00, 0x00, 0xeb, 0x0c, 0x00,
+    0x00, 0xeb, 0x2f, 0x00, 0x00, 0xeb, 0x58, 0x00, 0x00, 0xeb, 0x7d, 0x00,
+    0x00, 0xeb, 0xa3, 0x00, 0x00, 0xeb, 0xc4, 0x00, 0x00, 0xeb, 0xe4, 0x00,
+    0x00, 0xec, 0x0a, 0x00, 0x00, 0xec, 0x2d, 0x00, 0x00, 0xec, 0x52, 0x00,
+    0x00, 0xec, 0x75, 0x00, 0x00, 0xec, 0x9d, 0x00, 0x00, 0xec, 0xc3, 0x00,
+    0x00, 0xec, 0xe7, 0x00, 0x00, 0xed, 0x0c, 0x00, 0x00, 0xed, 0x33, 0x00,
+    0x00, 0xed, 0x58, 0x00, 0x00, 0xed, 0x79, 0x00, 0x00, 0xed, 0x9d, 0x00,
+    0x00, 0xed, 0xc1, 0x00, 0x00, 0xed, 0xe9, 0x00, 0x00, 0xee, 0x0e, 0x00,
+    0x00, 0xee, 0x37, 0x00, 0x00, 0xee, 0x5d, 0x00, 0x00, 0xee, 0x86, 0x00,
+    0x00, 0xee, 0xaa, 0x00, 0x00, 0xee, 0xce, 0x00, 0x00, 0xee, 0xf4, 0x00,
+    0x00, 0xef, 0x1b, 0x00, 0x00, 0xef, 0x44, 0x00, 0x00, 0xef, 0x64, 0x00,
+    0x00, 0xef, 0x87, 0x00, 0x00, 0xef, 0xac, 0x00, 0x00, 0xef, 0xce, 0x00,
+    0x00, 0xef, 0xef, 0x00, 0x00, 0xf0, 0x19, 0x00, 0x00, 0xf0, 0x3d, 0x00,
+    0x00, 0xf0, 0x63, 0x00, 0x00, 0xf0, 0x83, 0x00, 0x00, 0xf0, 0xa7, 0x00,
+    0x00, 0xf0, 0xcb, 0x00, 0x00, 0xf0, 0xf8, 0x00, 0x00, 0xf1, 0x1d, 0x00,
+    0x00, 0xf1, 0x41, 0x00, 0x00, 0xf1, 0x63, 0x00, 0x00, 0xf1, 0x8e, 0x00,
+    0x00, 0xf1, 0xb5, 0x00, 0x00, 0xf1, 0xdb, 0x00, 0x00, 0xf1, 0xff, 0x00,
+    0x00, 0xf2, 0x24, 0x00, 0x00, 0xf2, 0x4b, 0x00, 0x00, 0xf2, 0x76, 0x00,
+    0x00, 0xf2, 0xa0, 0x00, 0x00, 0xf2, 0xc2, 0x00, 0x00, 0xf2, 0xe7, 0x00,
+    0x00, 0xf3, 0x0c, 0x00, 0x00, 0xf3, 0x2d, 0x00, 0x00, 0xf3, 0x53, 0x00,
+    0x00, 0xf3, 0x77, 0x00, 0x00, 0xf3, 0x9d, 0x00, 0x00, 0xf3, 0xbe, 0x00,
+    0x00, 0xf3, 0xe2, 0x00, 0x00, 0xf4, 0x0d, 0x00, 0x00, 0xf4, 0x2e, 0x00,
+    0x00, 0xf4, 0x53, 0x00, 0x00, 0xf4, 0x73, 0x00, 0x00, 0xf4, 0x9e, 0x00,
+    0x00, 0xf4, 0xc5, 0x00, 0x00, 0xf4, 0xe6, 0x00, 0x00, 0xf5, 0x0a, 0x00,
+    0x00, 0xf5, 0x2f, 0x00, 0x00, 0xf5, 0x57, 0x00, 0x00, 0xf5, 0x7a, 0x00,
+    0x00, 0xf5, 0x9f, 0x00, 0x00, 0xf5, 0xc8, 0x00, 0x00, 0xf5, 0xed, 0x00,
+    0x00, 0xf6, 0x12, 0x00, 0x00, 0xf6, 0x36, 0x00, 0x00, 0xf6, 0x5a, 0x00,
+    0x00, 0xf6, 0x7e, 0x00, 0x00, 0xf6, 0xa6, 0x00, 0x00, 0xf6, 0xca, 0x00,
+    0x00, 0xf6, 0xf0, 0x00, 0x00, 0xf7, 0x19, 0x00, 0x00, 0xf7, 0x3a, 0x00,
+    0x00, 0xf7, 0x63, 0x00, 0x00, 0xf7, 0x86, 0x00, 0x00, 0xf7, 0xaa, 0x00,
+    0x00, 0xf7, 0xcf, 0x00, 0x00, 0xf7, 0xf4, 0x00, 0x00, 0xf8, 0x19, 0x00,
+    0x00, 0xf8, 0x46, 0x00, 0x00, 0xf8, 0x6c, 0x00, 0x00, 0xf8, 0x90, 0x00,
+    0x00, 0xf8, 0xbb, 0x00, 0x00, 0xf8, 0xdb, 0x00, 0x00, 0xf9, 0x06, 0x00,
+    0x00, 0xf9, 0x2b, 0x00, 0x00, 0xf9, 0x59, 0x00, 0x00, 0xf9, 0x80, 0x00,
+    0x00, 0xf9, 0xa3, 0x00, 0x00, 0xf9, 0xcd, 0x00, 0x00, 0xf9, 0xed, 0x00,
+    0x00, 0xfa, 0x11, 0x00, 0x00, 0xfa, 0x35, 0x00, 0x00, 0xfa, 0x58, 0x00,
+    0x00, 0xfa, 0x7c, 0x00, 0x00, 0xfa, 0x9f, 0x00, 0x00, 0xfa, 0xc2, 0x00,
+    0x00, 0xfa, 0xe6, 0x00, 0x00, 0xfb, 0x0a, 0x00, 0x00, 0xfb, 0x32, 0x00,
+    0x00, 0xfb, 0x5b, 0x00, 0x00, 0xfb, 0x7f, 0x00, 0x00, 0xfb, 0xa2, 0x00,
+    0x00, 0xfb, 0xca, 0x00, 0x00, 0xfb, 0xfa, 0x00, 0x00, 0xfc, 0x21, 0x00,
+    0x00, 0xfc, 0x47, 0x00, 0x00, 0xfc, 0x6c, 0x00, 0x00, 0xfc, 0x95, 0x00,
+    0x00, 0xfc, 0xc4, 0x00, 0x00, 0xfc, 0xe8, 0x00, 0x00, 0xfd, 0x0c, 0x00,
+    0x00, 0xfd, 0x3d, 0x00, 0x00, 0xfd, 0x5f, 0x00, 0x00, 0xfd, 0x86, 0x00,
+    0x00, 0xfd, 0xb0, 0x00, 0x00, 0xfd, 0xd9, 0x00, 0x00, 0xfd, 0xfc, 0x00,
+    0x00, 0xfe, 0x1f, 0x00, 0x00, 0xfe, 0x41, 0x00, 0x00, 0xfe, 0x72, 0x00,
+    0x00, 0xfe, 0x9c, 0x00, 0x00, 0xfe, 0xbc, 0x00, 0x00, 0xfe, 0xe9, 0x00,
+    0x00, 0xff, 0x0f, 0x00, 0x00, 0xff, 0x36, 0x00, 0x00, 0xff, 0x57, 0x00,
+    0x00, 0xff, 0x81, 0x00, 0x00, 0xff, 0xa6, 0x00, 0x00, 0xff, 0xca, 0x00,
+    0x00, 0xff, 0xef, 0x00, 0x01, 0x00, 0x14, 0x00, 0x01, 0x00, 0x35, 0x00,
+    0x01, 0x00, 0x5d, 0x00, 0x01, 0x00, 0x82, 0x00, 0x01, 0x00, 0xad, 0x00,
+    0x01, 0x00, 0xd8, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x25, 0x00,
+    0x01, 0x01, 0x4d, 0x00, 0x01, 0x01, 0x72, 0x00, 0x01, 0x01, 0x97, 0x00,
+    0x01, 0x01, 0xbf, 0x00, 0x01, 0x01, 0xe1, 0x00, 0x01, 0x02, 0x02, 0x00,
+    0x01, 0x02, 0x30, 0x00, 0x01, 0x02, 0x53, 0x00, 0x01, 0x02, 0x7d, 0x00,
+    0x01, 0x02, 0xa0, 0x00, 0x01, 0x02, 0xc8, 0x00, 0x01, 0x02, 0xee, 0x00,
+    0x01, 0x03, 0x1a, 0x00, 0x01, 0x03, 0x3c, 0x00, 0x01, 0x03, 0x61, 0x00,
+    0x01, 0x03, 0x90, 0x00, 0x01, 0x03, 0xb5, 0x00, 0x01, 0x03, 0xd9, 0x00,
+    0x01, 0x03, 0xfc, 0x00, 0x01, 0x04, 0x24, 0x00, 0x01, 0x04, 0x4d, 0x00,
+    0x01, 0x04, 0x74, 0x00, 0x01, 0x04, 0x95, 0x00, 0x01, 0x04, 0xb5, 0x00,
+    0x01, 0x04, 0xd8, 0x00, 0x01, 0x04, 0xfc, 0x00, 0x01, 0x05, 0x22, 0x00,
+    0x01, 0x05, 0x4a, 0x00, 0x01, 0x05, 0x78, 0x00, 0x01, 0x05, 0x9e, 0x00,
+    0x01, 0x05, 0xbe, 0x00, 0x01, 0x05, 0xe3, 0x00, 0x01, 0x06, 0x06, 0x00,
+    0x01, 0x06, 0x2b, 0x00, 0x01, 0x06, 0x5a, 0x00, 0x01, 0x06, 0x86, 0x00,
+    0x01, 0x06, 0xae, 0x00, 0x01, 0x06, 0xd3, 0x00, 0x01, 0x07, 0x00, 0x00,
+    0x01, 0x07, 0x25, 0x00, 0x01, 0x07, 0x4a, 0x00, 0x01, 0x07, 0x70, 0x00,
+    0x01, 0x07, 0x95, 0x00, 0x01, 0x07, 0xb8, 0x00, 0x01, 0x07, 0xdd, 0x00,
+    0x01, 0x08, 0x01, 0x00, 0x01, 0x08, 0x2a, 0x00, 0x01, 0x08, 0x50, 0x00,
+    0x01, 0x08, 0x75, 0x00, 0x01, 0x08, 0x9c, 0x00, 0x01, 0x08, 0xc7, 0x00,
+    0x01, 0x08, 0xee, 0x00, 0x01, 0x09, 0x12, 0x00, 0x01, 0x09, 0x38, 0x00,
+    0x01, 0x09, 0x5b, 0x00, 0x01, 0x09, 0x85, 0x00, 0x01, 0x09, 0xa8, 0x00,
+    0x01, 0x09, 0xcd, 0x00, 0x01, 0x09, 0xf2, 0x00, 0x01, 0x0a, 0x14, 0x00,
+    0x01, 0x0a, 0x38, 0x00, 0x01, 0x0a, 0x60, 0x00, 0x01, 0x0a, 0x81, 0x00,
+    0x01, 0x0a, 0xa9, 0x00, 0x01, 0x0a, 0xd4, 0x00, 0x01, 0x0a, 0xfc, 0x00,
+    0x01, 0x0b, 0x23, 0x00, 0x01, 0x0b, 0x46, 0x00, 0x01, 0x0b, 0x6c, 0x00,
+    0x01, 0x0b, 0x91, 0x00, 0x01, 0x0b, 0xb5, 0x00, 0x01, 0x0b, 0xe1, 0x00,
+    0x01, 0x0c, 0x06, 0x00, 0x01, 0x0c, 0x2a, 0x00, 0x01, 0x0c, 0x50, 0x00,
+    0x01, 0x0c, 0x77, 0x00, 0x01, 0x0c, 0x9c, 0x00, 0x01, 0x0c, 0xc1, 0x00,
+    0x01, 0x0c, 0xe2, 0x00, 0x01, 0x0d, 0x02, 0x00, 0x01, 0x0d, 0x2a, 0x00,
+    0x01, 0x0d, 0x51, 0x00, 0x01, 0x0d, 0x79, 0x00, 0x01, 0x0d, 0xa3, 0x00,
+    0x01, 0x0d, 0xc7, 0x00, 0x01, 0x0d, 0xee, 0x00, 0x01, 0x0e, 0x14, 0x00,
+    0x01, 0x0e, 0x38, 0x00, 0x01, 0x0e, 0x5b, 0x00, 0x01, 0x0e, 0x82, 0x00,
+    0x01, 0x0e, 0xa7, 0x00, 0x01, 0x0e, 0xd1, 0x00, 0x01, 0x0e, 0xf7, 0x00,
+    0x01, 0x0f, 0x20, 0x00, 0x01, 0x0f, 0x43, 0x00, 0x01, 0x0f, 0x67, 0x00,
+    0x01, 0x0f, 0x8b, 0x00, 0x01, 0x0f, 0xb4, 0x00, 0x01, 0x0f, 0xd5, 0x00,
+    0x01, 0x0f, 0xff, 0x00, 0x01, 0x10, 0x2a, 0x00, 0x01, 0x10, 0x55, 0x00,
+    0x01, 0x10, 0x7b, 0x00, 0x01, 0x10, 0x9e, 0x00, 0x01, 0x10, 0xc4, 0x00,
+    0x01, 0x10, 0xf2, 0x00, 0x01, 0x11, 0x15, 0x00, 0x01, 0x11, 0x3c, 0x00,
+    0x01, 0x11, 0x64, 0x00, 0x01, 0x11, 0x87, 0x00, 0x01, 0x11, 0xaa, 0x00,
+    0x01, 0x11, 0xd0, 0x00, 0x01, 0x11, 0xf5, 0x00, 0x01, 0x12, 0x1d, 0x00,
+    0x01, 0x12, 0x41, 0x00, 0x01, 0x12, 0x67, 0x00, 0x01, 0x12, 0x8b, 0x00,
+    0x01, 0x12, 0xab, 0x00, 0x01, 0x12, 0xd2, 0x00, 0x01, 0x12, 0xf7, 0x00,
+    0x01, 0x13, 0x1e, 0x00, 0x01, 0x13, 0x45, 0x00, 0x01, 0x13, 0x66, 0x00,
+    0x01, 0x13, 0x8a, 0x00, 0x01, 0x13, 0xb5, 0x00, 0x01, 0x13, 0xde, 0x00,
+    0x01, 0x14, 0x05, 0x00, 0x01, 0x14, 0x27, 0x00, 0x01, 0x14, 0x4c, 0x00,
+    0x01, 0x14, 0x6e, 0x00, 0x01, 0x14, 0x97, 0x00, 0x01, 0x14, 0xbc, 0x00,
+    0x01, 0x14, 0xdf, 0x00, 0x01, 0x15, 0x01, 0x00, 0x01, 0x15, 0x25, 0x00,
+    0x01, 0x15, 0x49, 0x00, 0x01, 0x15, 0x79, 0x00, 0x01, 0x15, 0x98, 0x00,
+    0x01, 0x15, 0xbe, 0x00, 0x01, 0x15, 0xe5, 0x00, 0x01, 0x16, 0x10, 0x00,
+    0x01, 0x16, 0x39, 0x00, 0x01, 0x16, 0x60, 0x00, 0x01, 0x16, 0x81, 0x00,
+    0x01, 0x16, 0xad, 0x00, 0x01, 0x16, 0xcd, 0x00, 0x01, 0x16, 0xf5, 0x00,
+    0x01, 0x17, 0x19, 0x00, 0x01, 0x17, 0x42, 0x00, 0x01, 0x17, 0x68, 0x00,
+    0x01, 0x17, 0x8e, 0x00, 0x01, 0x17, 0xb0, 0x00, 0x01, 0x17, 0xd5, 0x00,
+    0x01, 0x17, 0xf8, 0x00, 0x01, 0x18, 0x1e, 0x00, 0x01, 0x18, 0x42, 0x00,
+    0x01, 0x18, 0x68, 0x00, 0x01, 0x18, 0x88, 0x00, 0x01, 0x18, 0xb5, 0x00,
+    0x01, 0x18, 0xd7, 0x00, 0x01, 0x19, 0x02, 0x00, 0x01, 0x19, 0x32, 0x00,
+    0x01, 0x19, 0x55, 0x00, 0x01, 0x19, 0x83, 0x00, 0x01, 0x19, 0xa4, 0x00,
+    0x01, 0x19, 0xc7, 0x00, 0x01, 0x19, 0xec, 0x00, 0x01, 0x1a, 0x10, 0x00,
+    0x01, 0x1a, 0x30, 0x00, 0x01, 0x1a, 0x53, 0x00, 0x01, 0x1a, 0x7a, 0x00,
+    0x01, 0x1a, 0x9f, 0x00, 0x01, 0x1a, 0xc2, 0x00, 0x01, 0x1a, 0xe6, 0x00,
+    0x01, 0x1b, 0x08, 0x00, 0x01, 0x1b, 0x2e, 0x00, 0x01, 0x1b, 0x54, 0x00,
+    0x01, 0x1b, 0x79, 0x00, 0x01, 0x1b, 0x9d, 0x00, 0x01, 0x1b, 0xbf, 0x00,
+    0x01, 0x1b, 0xe3, 0x00, 0x01, 0x1c, 0x08, 0x00, 0x01, 0x1c, 0x2f, 0x00,
+    0x01, 0x1c, 0x5e, 0x00, 0x01, 0x1c, 0x83, 0x00, 0x01, 0x1c, 0xa9, 0x00,
+    0x01, 0x1c, 0xce, 0x00, 0x01, 0x1c, 0xf1, 0x00, 0x01, 0x1d, 0x12, 0x00,
+    0x01, 0x1d, 0x36, 0x00, 0x01, 0x1d, 0x59, 0x00, 0x01, 0x1d, 0x7f, 0x00,
+    0x01, 0x1d, 0xa7, 0x00, 0x01, 0x1d, 0xc7, 0x00, 0x01, 0x1d, 0xe9, 0x00,
+    0x01, 0x1e, 0x0b, 0x00, 0x01, 0x1e, 0x34, 0x00, 0x01, 0x1e, 0x57, 0x00,
+    0x01, 0x1e, 0x7e, 0x00, 0x01, 0x1e, 0xa8, 0x00, 0x01, 0x1e, 0xce, 0x00,
+    0x01, 0x1e, 0xf9, 0x00, 0x01, 0x1f, 0x1d, 0x00, 0x01, 0x1f, 0x46, 0x00,
+    0x01, 0x1f, 0x69, 0x00, 0x01, 0x1f, 0x8a, 0x00, 0x01, 0x1f, 0xaf, 0x00,
+    0x01, 0x1f, 0xd7, 0x00, 0x01, 0x1f, 0xfd, 0x00, 0x01, 0x20, 0x24, 0x00,
+    0x01, 0x20, 0x47, 0x00, 0x01, 0x20, 0x6b, 0x00, 0x01, 0x20, 0x90, 0x00,
+    0x01, 0x20, 0xbc, 0x00, 0x01, 0x20, 0xdf, 0x00, 0x01, 0x21, 0x09, 0x00,
+    0x01, 0x21, 0x38, 0x00, 0x01, 0x21, 0x65, 0x00, 0x01, 0x21, 0x8d, 0x00,
+    0x01, 0x21, 0xae, 0x00, 0x01, 0x21, 0xd6, 0x00, 0x01, 0x21, 0xfd, 0x00,
+    0x01, 0x22, 0x1f, 0x00, 0x01, 0x22, 0x45, 0x00, 0x01, 0x22, 0x68, 0x00,
+    0x01, 0x22, 0x8c, 0x00, 0x01, 0x22, 0xb0, 0x00, 0x01, 0x22, 0xd5, 0x00,
+    0x01, 0x22, 0xfa, 0x00, 0x01, 0x23, 0x1f, 0x00, 0x01, 0x23, 0x46, 0x00,
+    0x01, 0x23, 0x69, 0x00, 0x01, 0x23, 0x91, 0x00, 0x01, 0x23, 0xb4, 0x00,
+    0x01, 0x23, 0xe1, 0x00, 0x01, 0x24, 0x04, 0x00, 0x01, 0x24, 0x2a, 0x00,
+    0x01, 0x24, 0x4f, 0x00, 0x01, 0x24, 0x6f, 0x00, 0x01, 0x24, 0x93, 0x00,
+    0x01, 0x24, 0xbd, 0x00, 0x01, 0x24, 0xe0, 0x00, 0x01, 0x25, 0x0b, 0x00,
+    0x01, 0x25, 0x32, 0x00, 0x01, 0x25, 0x59, 0x00, 0x01, 0x25, 0x7b, 0x00,
+    0x01, 0x25, 0x9c, 0x00, 0x01, 0x25, 0xc5, 0x00, 0x01, 0x25, 0xef, 0x00,
+    0x01, 0x26, 0x15, 0x00, 0x01, 0x26, 0x37, 0x00, 0x01, 0x26, 0x5d, 0x00,
+    0x01, 0x26, 0x83, 0x00, 0x01, 0x26, 0xa7, 0x00, 0x01, 0x26, 0xc9, 0x00,
+    0x01, 0x26, 0xf7, 0x00, 0x01, 0x27, 0x23, 0x00, 0x01, 0x27, 0x4b, 0x00,
+    0x01, 0x27, 0x6e, 0x00, 0x01, 0x27, 0x92, 0x00, 0x01, 0x27, 0xb6, 0x00,
+    0x01, 0x27, 0xe1, 0x00, 0x01, 0x28, 0x05, 0x00, 0x01, 0x28, 0x25, 0x00,
+    0x01, 0x28, 0x44, 0x00, 0x01, 0x28, 0x68, 0x00, 0x01, 0x28, 0x8b, 0x00,
+    0x01, 0x28, 0xae, 0x00, 0x01, 0x28, 0xd7, 0x00, 0x01, 0x29, 0x00, 0x00,
+    0x01, 0x29, 0x22, 0x00, 0x01, 0x29, 0x48, 0x00, 0x01, 0x29, 0x76, 0x00,
+    0x01, 0x29, 0x9c, 0x00, 0x01, 0x29, 0xc2, 0x00, 0x01, 0x29, 0xe6, 0x00,
+    0x01, 0x2a, 0x08, 0x00, 0x01, 0x2a, 0x2e, 0x00, 0x01, 0x2a, 0x51, 0x00,
+    0x01, 0x2a, 0x76, 0x00, 0x01, 0x2a, 0x9b, 0x00, 0x01, 0x2a, 0xc5, 0x00,
+    0x01, 0x2a, 0xee, 0x00, 0x01, 0x2b, 0x15, 0x00, 0x01, 0x2b, 0x3c, 0x00,
+    0x01, 0x2b, 0x60, 0x00, 0x01, 0x2b, 0x8c, 0x00, 0x01, 0x2b, 0xaf, 0x00,
+    0x01, 0x2b, 0xd5, 0x00, 0x01, 0x2b, 0xfc, 0x00, 0x01, 0x2c, 0x1e, 0x00,
+    0x01, 0x2c, 0x44, 0x00, 0x01, 0x2c, 0x6b, 0x00, 0x01, 0x2c, 0x8f, 0x00,
+    0x01, 0x2c, 0xb4, 0x00, 0x01, 0x2c, 0xda, 0x00, 0x01, 0x2d, 0x01, 0x00,
+    0x01, 0x2d, 0x21, 0x00, 0x01, 0x2d, 0x4c, 0x00, 0x01, 0x2d, 0x71, 0x00,
+    0x01, 0x2d, 0x9d, 0x00, 0x01, 0x2d, 0xc1, 0x00, 0x01, 0x2d, 0xe4, 0x00,
+    0x01, 0x2e, 0x0d, 0x00, 0x01, 0x2e, 0x34, 0x00, 0x01, 0x2e, 0x5d, 0x00,
+    0x01, 0x2e, 0x7f, 0x00, 0x01, 0x2e, 0xa2, 0x00, 0x01, 0x2e, 0xc7, 0x00,
+    0x01, 0x2e, 0xef, 0x00, 0x01, 0x2f, 0x10, 0x00, 0x01, 0x2f, 0x3b, 0x00,
+    0x01, 0x2f, 0x61, 0x00, 0x01, 0x2f, 0x84, 0x00, 0x01, 0x2f, 0xa5, 0x00,
+    0x01, 0x2f, 0xcc, 0x00, 0x01, 0x2f, 0xed, 0x00, 0x01, 0x30, 0x18, 0x00,
+    0x01, 0x30, 0x3d, 0x00, 0x01, 0x30, 0x63, 0x00, 0x01, 0x30, 0x8b, 0x00,
+    0x01, 0x30, 0xb2, 0x00, 0x01, 0x30, 0xda, 0x00, 0x01, 0x30, 0xff, 0x00,
+    0x01, 0x31, 0x22, 0x00, 0x01, 0x31, 0x4a, 0x00, 0x01, 0x31, 0x76, 0x00,
+    0x01, 0x31, 0x97, 0x00, 0x01, 0x31, 0xbc, 0x00, 0x01, 0x31, 0xe6, 0x00,
+    0x01, 0x32, 0x06, 0x00, 0x01, 0x32, 0x2c, 0x00, 0x01, 0x32, 0x52, 0x00,
+    0x01, 0x32, 0x7d, 0x00, 0x01, 0x32, 0xa1, 0x00, 0x01, 0x32, 0xc8, 0x00,
+    0x01, 0x32, 0xec, 0x00, 0x01, 0x33, 0x0f, 0x00, 0x01, 0x33, 0x36, 0x00,
+    0x01, 0x33, 0x5c, 0x00, 0x01, 0x33, 0x83, 0x00, 0x01, 0x33, 0xae, 0x00,
+    0x01, 0x33, 0xd6, 0x00, 0x01, 0x33, 0xff, 0x00, 0x01, 0x34, 0x26, 0x00,
+    0x01, 0x34, 0x4a, 0x00, 0x01, 0x34, 0x75, 0x00, 0x01, 0x34, 0x99, 0x00,
+    0x01, 0x34, 0xbb, 0x00, 0x01, 0x34, 0xe2, 0x00, 0x01, 0x35, 0x0b, 0x00,
+    0x01, 0x35, 0x2f, 0x00, 0x01, 0x35, 0x53, 0x00, 0x01, 0x35, 0x7a, 0x00,
+    0x01, 0x35, 0x9b, 0x00, 0x01, 0x35, 0xbb, 0x00, 0x01, 0x35, 0xe4, 0x00,
+    0x01, 0x36, 0x09, 0x00, 0x01, 0x36, 0x2b, 0x00, 0x01, 0x36, 0x51, 0x00,
+    0x01, 0x36, 0x7b, 0x00, 0x01, 0x36, 0x9f, 0x00, 0x01, 0x36, 0xc4, 0x00,
+    0x01, 0x36, 0xef, 0x00, 0x01, 0x37, 0x13, 0x00, 0x01, 0x37, 0x38, 0x00,
+    0x01, 0x37, 0x67, 0x00, 0x01, 0x37, 0x8e, 0x00, 0x01, 0x37, 0xb3, 0x00,
+    0x01, 0x37, 0xd5, 0x00, 0x01, 0x37, 0xfb, 0x00, 0x01, 0x38, 0x24, 0x00,
+    0x01, 0x38, 0x49, 0x00, 0x01, 0x38, 0x69, 0x00, 0x01, 0x38, 0x91, 0x00,
+    0x01, 0x38, 0xb5, 0x00, 0x01, 0x38, 0xd7, 0x00, 0x01, 0x39, 0x00, 0x00,
+    0x01, 0x39, 0x2c, 0x00, 0x01, 0x39, 0x4f, 0x00, 0x01, 0x39, 0x74, 0x00,
+    0x01, 0x39, 0x9c, 0x00, 0x01, 0x39, 0xc5, 0x00, 0x01, 0x39, 0xea, 0x00,
+    0x01, 0x3a, 0x0c, 0x00, 0x01, 0x3a, 0x35, 0x00, 0x01, 0x3a, 0x65, 0x00,
+    0x01, 0x3a, 0x8a, 0x00, 0x01, 0x3a, 0xb0, 0x00, 0x01, 0x3a, 0xd7, 0x00,
+    0x01, 0x3a, 0xf9, 0x00, 0x01, 0x3b, 0x1e, 0x00, 0x01, 0x3b, 0x42, 0x00,
+    0x01, 0x3b, 0x66, 0x00, 0x01, 0x3b, 0x8b, 0x00, 0x01, 0x3b, 0xbb, 0x00,
+    0x01, 0x3b, 0xe3, 0x00, 0x01, 0x3c, 0x06, 0x00, 0x01, 0x3c, 0x35, 0x00,
+    0x01, 0x3c, 0x5b, 0x00, 0x01, 0x3c, 0x81, 0x00, 0x01, 0x3c, 0xa2, 0x00,
+    0x01, 0x3c, 0xc7, 0x00, 0x01, 0x3c, 0xee, 0x00, 0x01, 0x3d, 0x13, 0x00,
+    0x01, 0x3d, 0x3b, 0x00, 0x01, 0x3d, 0x62, 0x00, 0x01, 0x3d, 0x86, 0x00,
+    0x01, 0x3d, 0xab, 0x00, 0x01, 0x3d, 0xcf, 0x00, 0x01, 0x3d, 0xf5, 0x00,
+    0x01, 0x3e, 0x1c, 0x00, 0x01, 0x3e, 0x42, 0x00, 0x01, 0x3e, 0x66, 0x00,
+    0x01, 0x3e, 0x88, 0x00, 0x01, 0x3e, 0xac, 0x00, 0x01, 0x3e, 0xd3, 0x00,
+    0x01, 0x3e, 0xf7, 0x00, 0x01, 0x3f, 0x1e, 0x00, 0x01, 0x3f, 0x3d, 0x00,
+    0x01, 0x3f, 0x68, 0x00, 0x01, 0x3f, 0x91, 0x00, 0x01, 0x3f, 0xba, 0x00,
+    0x01, 0x3f, 0xdf, 0x00, 0x01, 0x40, 0x02, 0x00, 0x01, 0x40, 0x2e, 0x00,
+    0x01, 0x40, 0x55, 0x00, 0x01, 0x40, 0x7a, 0x00, 0x01, 0x40, 0x9e, 0x00,
+    0x01, 0x40, 0xc4, 0x00, 0x01, 0x40, 0xea, 0x00, 0x01, 0x41, 0x12, 0x00,
+    0x01, 0x41, 0x3c, 0x00, 0x01, 0x41, 0x61, 0x00, 0x01, 0x41, 0x8a, 0x00,
+    0x01, 0x41, 0xb2, 0x00, 0x01, 0x41, 0xd2, 0x00, 0x01, 0x41, 0xf8, 0x00,
+    0x01, 0x42, 0x22, 0x00, 0x01, 0x42, 0x4b, 0x00, 0x01, 0x42, 0x72, 0x00,
+    0x01, 0x42, 0x99, 0x00, 0x01, 0x42, 0xc2, 0x00, 0x01, 0x42, 0xee, 0x00,
+    0x01, 0x43, 0x16, 0x00, 0x01, 0x43, 0x3f, 0x00, 0x01, 0x43, 0x61, 0x00,
+    0x01, 0x43, 0x8c, 0x00, 0x01, 0x43, 0xad, 0x00, 0x01, 0x43, 0xd1, 0x00,
+    0x01, 0x43, 0xfd, 0x00, 0x01, 0x44, 0x23, 0x00, 0x01, 0x44, 0x48, 0x00,
+    0x01, 0x44, 0x6c, 0x00, 0x01, 0x44, 0x8f, 0x00, 0x01, 0x44, 0xbb, 0x00,
+    0x01, 0x44, 0xdd, 0x00, 0x01, 0x45, 0x01, 0x00, 0x01, 0x45, 0x22, 0x00,
+    0x01, 0x45, 0x4a, 0x00, 0x01, 0x45, 0x6e, 0x00, 0x01, 0x45, 0x9b, 0x00,
+    0x01, 0x45, 0xbd, 0x00, 0x01, 0x45, 0xe1, 0x00, 0x01, 0x46, 0x05, 0x00,
+    0x01, 0x46, 0x2c, 0x00, 0x01, 0x46, 0x57, 0x00, 0x01, 0x46, 0x7b, 0x00,
+    0x01, 0x46, 0xa0, 0x00, 0x01, 0x46, 0xc3, 0x00, 0x01, 0x46, 0xea, 0x00,
+    0x01, 0x47, 0x0c, 0x00, 0x01, 0x47, 0x2f, 0x00, 0x01, 0x47, 0x51, 0x00,
+    0x01, 0x47, 0x78, 0x00, 0x01, 0x47, 0xa2, 0x00, 0x01, 0x47, 0xca, 0x00,
+    0x01, 0x47, 0xf0, 0x00, 0x01, 0x48, 0x17, 0x00, 0x01, 0x48, 0x3b, 0x00,
+    0x01, 0x48, 0x5f, 0x00, 0x01, 0x48, 0x82, 0x00, 0x01, 0x48, 0xa7, 0x00,
+    0x01, 0x48, 0xce, 0x00, 0x01, 0x48, 0xf5, 0x00, 0x01, 0x49, 0x1a, 0x00,
+    0x01, 0x49, 0x41, 0x00, 0x01, 0x49, 0x61, 0x00, 0x01, 0x49, 0x85, 0x00,
+    0x01, 0x49, 0xad, 0x00, 0x01, 0x49, 0xd0, 0x00, 0x01, 0x49, 0xf4, 0x00,
+    0x01, 0x4a, 0x19, 0x00, 0x01, 0x4a, 0x3a, 0x00, 0x01, 0x4a, 0x5c, 0x00,
+    0x01, 0x4a, 0x81, 0x00, 0x01, 0x4a, 0xa7, 0x00, 0x01, 0x4a, 0xd0, 0x00,
+    0x01, 0x4a, 0xf5, 0x00, 0x01, 0x4b, 0x1f, 0x00, 0x01, 0x4b, 0x4c, 0x00,
+    0x01, 0x4b, 0x6e, 0x00, 0x01, 0x4b, 0x91, 0x00, 0x01, 0x4b, 0xb6, 0x00,
+    0x01, 0x4b, 0xde, 0x00, 0x01, 0x4c, 0x0e, 0x00, 0x01, 0x4c, 0x33, 0x00,
+    0x01, 0x4c, 0x5d, 0x00, 0x01, 0x4c, 0x84, 0x00, 0x01, 0x4c, 0xac, 0x00,
+    0x01, 0x4c, 0xce, 0x00, 0x01, 0x4c, 0xf4, 0x00, 0x01, 0x4d, 0x1f, 0x00,
+    0x01, 0x4d, 0x40, 0x00, 0x01, 0x4d, 0x66, 0x00, 0x01, 0x4d, 0x8b, 0x00,
+    0x01, 0x4d, 0xb2, 0x00, 0x01, 0x4d, 0xd8, 0x00, 0x01, 0x4d, 0xfc, 0x00,
+    0x01, 0x4e, 0x29, 0x00, 0x01, 0x4e, 0x4d, 0x00, 0x01, 0x4e, 0x72, 0x00,
+    0x01, 0x4e, 0x97, 0x00, 0x01, 0x4e, 0xc4, 0x00, 0x01, 0x4e, 0xea, 0x00,
+    0x01, 0x4f, 0x19, 0x00, 0x01, 0x4f, 0x3d, 0x00, 0x01, 0x4f, 0x64, 0x00,
+    0x01, 0x4f, 0x8b, 0x00, 0x01, 0x4f, 0xb0, 0x00, 0x01, 0x4f, 0xda, 0x00,
+    0x01, 0x50, 0x02, 0x00, 0x01, 0x50, 0x24, 0x00, 0x01, 0x50, 0x47, 0x00,
+    0x01, 0x50, 0x68, 0x00, 0x01, 0x50, 0x93, 0x00, 0x01, 0x50, 0xb9, 0x00,
+    0x01, 0x50, 0xe6, 0x00, 0x01, 0x51, 0x0a, 0x00, 0x01, 0x51, 0x32, 0x00,
+    0x01, 0x51, 0x58, 0x00, 0x01, 0x51, 0x7d, 0x00, 0x01, 0x51, 0xa6, 0x00,
+    0x01, 0x51, 0xce, 0x00, 0x01, 0x51, 0xf3, 0x00, 0x01, 0x52, 0x1a, 0x00,
+    0x01, 0x52, 0x46, 0x00, 0x01, 0x52, 0x6b, 0x00, 0x01, 0x52, 0x8f, 0x00,
+    0x01, 0x52, 0xb9, 0x00, 0x01, 0x52, 0xdd, 0x00, 0x01, 0x53, 0x07, 0x00,
+    0x01, 0x53, 0x2e, 0x00, 0x01, 0x53, 0x53, 0x00, 0x01, 0x53, 0x7a, 0x00,
+    0x01, 0x53, 0xa4, 0x00, 0x01, 0x53, 0xce, 0x00, 0x01, 0x53, 0xf3, 0x00,
+    0x01, 0x54, 0x1e, 0x00, 0x01, 0x54, 0x40, 0x00, 0x01, 0x54, 0x64, 0x00,
+    0x01, 0x54, 0x88, 0x00, 0x01, 0x54, 0xaf, 0x00, 0x01, 0x54, 0xd8, 0x00,
+    0x01, 0x55, 0x02, 0x00, 0x01, 0x55, 0x2f, 0x00, 0x01, 0x55, 0x56, 0x00,
+    0x01, 0x55, 0x81, 0x00, 0x01, 0x55, 0xa9, 0x00, 0x01, 0x55, 0xcb, 0x00,
+    0x01, 0x55, 0xf3, 0x00, 0x01, 0x56, 0x1e, 0x00, 0x01, 0x56, 0x44, 0x00,
+    0x01, 0x56, 0x68, 0x00, 0x01, 0x56, 0x8c, 0x00, 0x01, 0x56, 0xb7, 0x00,
+    0x01, 0x56, 0xde, 0x00, 0x01, 0x57, 0x03, 0x00, 0x01, 0x57, 0x29, 0x00,
+    0x01, 0x57, 0x4d, 0x00, 0x01, 0x57, 0x72, 0x00, 0x01, 0x57, 0x97, 0x00,
+    0x01, 0x57, 0xb9, 0x00, 0x01, 0x57, 0xdf, 0x00, 0x01, 0x58, 0x06, 0x00,
+    0x01, 0x58, 0x30, 0x00, 0x01, 0x58, 0x55, 0x00, 0x01, 0x58, 0x7a, 0x00,
+    0x01, 0x58, 0xa4, 0x00, 0x01, 0x58, 0xd2, 0x00, 0x01, 0x58, 0xfc, 0x00,
+    0x01, 0x59, 0x1e, 0x00, 0x01, 0x59, 0x49, 0x00, 0x01, 0x59, 0x6f, 0x00,
+    0x01, 0x59, 0x95, 0x00, 0x01, 0x59, 0xb9, 0x00, 0x01, 0x59, 0xe0, 0x00,
+    0x01, 0x5a, 0x08, 0x00, 0x01, 0x5a, 0x2e, 0x00, 0x01, 0x5a, 0x53, 0x00,
+    0x01, 0x5a, 0x78, 0x00, 0x01, 0x5a, 0x9e, 0x00, 0x01, 0x5a, 0xc4, 0x00,
+    0x01, 0x5a, 0xe9, 0x00, 0x01, 0x5b, 0x0e, 0x00, 0x01, 0x5b, 0x35, 0x00,
+    0x01, 0x5b, 0x58, 0x00, 0x01, 0x5b, 0x85, 0x00, 0x01, 0x5b, 0xab, 0x00,
+    0x01, 0x5b, 0xd0, 0x00, 0x01, 0x5b, 0xfd, 0x00, 0x01, 0x5c, 0x21, 0x00,
+    0x01, 0x5c, 0x46, 0x00, 0x01, 0x5c, 0x71, 0x00, 0x01, 0x5c, 0x9a, 0x00,
+    0x01, 0x5c, 0xc4, 0x00, 0x01, 0x5c, 0xe8, 0x00, 0x01, 0x5d, 0x12, 0x00,
+    0x01, 0x5d, 0x3a, 0x00, 0x01, 0x5d, 0x60, 0x00, 0x01, 0x5d, 0x85, 0x00,
+    0x01, 0x5d, 0xaa, 0x00, 0x01, 0x5d, 0xd2, 0x00, 0x01, 0x5d, 0xf4, 0x00,
+    0x01, 0x5e, 0x1b, 0x00, 0x01, 0x5e, 0x3d, 0x00, 0x01, 0x5e, 0x5e, 0x00,
+    0x01, 0x5e, 0x82, 0x00, 0x01, 0x5e, 0xa8, 0x00, 0x01, 0x5e, 0xcc, 0x00,
+    0x01, 0x5e, 0xf1, 0x00, 0x01, 0x5f, 0x17, 0x00, 0x01, 0x5f, 0x3e, 0x00,
+    0x01, 0x5f, 0x6c, 0x00, 0x01, 0x5f, 0x90, 0x00, 0x01, 0x5f, 0xb3, 0x00,
+    0x01, 0x5f, 0xd3, 0x00, 0x01, 0x5f, 0xfc, 0x00, 0x01, 0x60, 0x27, 0x00,
+    0x01, 0x60, 0x4c, 0x00, 0x01, 0x60, 0x71, 0x00, 0x01, 0x60, 0x9a, 0x00,
+    0x01, 0x60, 0xc0, 0x00, 0x01, 0x60, 0xe6, 0x00, 0x01, 0x61, 0x09, 0x00,
+    0x01, 0x61, 0x36, 0x00, 0x01, 0x61, 0x59, 0x00, 0x01, 0x61, 0x7f, 0x00,
+    0x01, 0x61, 0xa6, 0x00, 0x01, 0x61, 0xc7, 0x00, 0x01, 0x61, 0xec, 0x00,
+    0x01, 0x62, 0x19, 0x00, 0x01, 0x62, 0x3c, 0x00, 0x01, 0x62, 0x5f, 0x00,
+    0x01, 0x62, 0x87, 0x00, 0x01, 0x62, 0xac, 0x00, 0x01, 0x62, 0xd5, 0x00,
+    0x01, 0x62, 0xf6, 0x00, 0x01, 0x63, 0x1a, 0x00, 0x01, 0x63, 0x41, 0x00,
+    0x01, 0x63, 0x66, 0x00, 0x01, 0x63, 0x88, 0x00, 0x01, 0x63, 0xb1, 0x00,
+    0x01, 0x63, 0xdb, 0x00, 0x01, 0x64, 0x03, 0x00, 0x01, 0x64, 0x28, 0x00,
+    0x01, 0x64, 0x4f, 0x00, 0x01, 0x64, 0x78, 0x00, 0x01, 0x64, 0x9e, 0x00,
+    0x01, 0x64, 0xc1, 0x00, 0x01, 0x64, 0xea, 0x00, 0x01, 0x65, 0x0a, 0x00,
+    0x01, 0x65, 0x2e, 0x00, 0x01, 0x65, 0x54, 0x00, 0x01, 0x65, 0x7a, 0x00,
+    0x01, 0x65, 0x9d, 0x00, 0x01, 0x65, 0xbc, 0x00, 0x01, 0x65, 0xe4, 0x00,
+    0x01, 0x66, 0x07, 0x00, 0x01, 0x66, 0x34, 0x00, 0x01, 0x66, 0x59, 0x00,
+    0x01, 0x66, 0x81, 0x00, 0x01, 0x66, 0xa8, 0x00, 0x01, 0x66, 0xce, 0x00,
+    0x01, 0x66, 0xf6, 0x00, 0x01, 0x67, 0x20, 0x00, 0x01, 0x67, 0x44, 0x00,
+    0x01, 0x67, 0x68, 0x00, 0x01, 0x67, 0x8f, 0x00, 0x01, 0x67, 0xb0, 0x00,
+    0x01, 0x67, 0xd6, 0x00, 0x01, 0x67, 0xfb, 0x00, 0x01, 0x68, 0x21, 0x00,
+    0x01, 0x68, 0x45, 0x00, 0x01, 0x68, 0x6d, 0x00, 0x01, 0x68, 0x8f, 0x00,
+    0x01, 0x68, 0xb9, 0x00, 0x01, 0x68, 0xe2, 0x00, 0x01, 0x69, 0x07, 0x00,
+    0x01, 0x69, 0x2d, 0x00, 0x01, 0x69, 0x55, 0x00, 0x01, 0x69, 0x79, 0x00,
+    0x01, 0x69, 0x9e, 0x00, 0x01, 0x69, 0xc4, 0x00, 0x01, 0x69, 0xea, 0x00,
+    0x01, 0x6a, 0x13, 0x00, 0x01, 0x6a, 0x38, 0x00, 0x01, 0x6a, 0x61, 0x00,
+    0x01, 0x6a, 0x8c, 0x00, 0x01, 0x6a, 0xb5, 0x00, 0x01, 0x6a, 0xdb, 0x00,
+    0x01, 0x6b, 0x04, 0x00, 0x01, 0x6b, 0x2b, 0x00, 0x01, 0x6b, 0x55, 0x00,
+    0x01, 0x6b, 0x7a, 0x00, 0x01, 0x6b, 0xa1, 0x00, 0x01, 0x6b, 0xc4, 0x00,
+    0x01, 0x6b, 0xeb, 0x00, 0x01, 0x6c, 0x0e, 0x00, 0x01, 0x6c, 0x32, 0x00,
+    0x01, 0x6c, 0x5d, 0x00, 0x01, 0x6c, 0x82, 0x00, 0x01, 0x6c, 0xa5, 0x00,
+    0x01, 0x6c, 0xc9, 0x00, 0x01, 0x6c, 0xef, 0x00, 0x01, 0x6d, 0x13, 0x00,
+    0x01, 0x6d, 0x39, 0x00, 0x01, 0x6d, 0x5b, 0x00, 0x01, 0x6d, 0x7b, 0x00,
+    0x01, 0x6d, 0x9e, 0x00, 0x01, 0x6d, 0xc2, 0x00, 0x01, 0x6d, 0xe3, 0x00,
+    0x01, 0x6e, 0x09, 0x00, 0x01, 0x6e, 0x2f, 0x00, 0x01, 0x6e, 0x58, 0x00,
+    0x01, 0x6e, 0x82, 0x00, 0x01, 0x6e, 0xa9, 0x00, 0x01, 0x6e, 0xd4, 0x00,
+    0x01, 0x6e, 0xfc, 0x00, 0x01, 0x6f, 0x26, 0x00, 0x01, 0x6f, 0x4c, 0x00,
+    0x01, 0x6f, 0x6e, 0x00, 0x01, 0x6f, 0x8f, 0x00, 0x01, 0x6f, 0xb4, 0x00,
+    0x01, 0x6f, 0xd7, 0x00, 0x01, 0x70, 0x01, 0x00, 0x01, 0x70, 0x28, 0x00,
+    0x01, 0x70, 0x4e, 0x00, 0x01, 0x70, 0x71, 0x00, 0x01, 0x70, 0x98, 0x00,
+    0x01, 0x70, 0xb8, 0x00, 0x01, 0x70, 0xdc, 0x00, 0x01, 0x71, 0x03, 0x00,
+    0x01, 0x71, 0x28, 0x00, 0x01, 0x71, 0x4c, 0x00, 0x01, 0x71, 0x6f, 0x00,
+    0x01, 0x71, 0x92, 0x00, 0x01, 0x71, 0xb3, 0x00, 0x01, 0x71, 0xdc, 0x00,
+    0x01, 0x72, 0x04, 0x00, 0x01, 0x72, 0x2a, 0x00, 0x01, 0x72, 0x4e, 0x00,
+    0x01, 0x72, 0x79, 0x00, 0x01, 0x72, 0x9b, 0x00, 0x01, 0x72, 0xc0, 0x00,
+    0x01, 0x72, 0xe5, 0x00, 0x01, 0x73, 0x05, 0x00, 0x01, 0x73, 0x23, 0x00,
+    0x01, 0x73, 0x42, 0x00, 0x01, 0x73, 0x67, 0x00, 0x01, 0x73, 0x8e, 0x00,
+    0x01, 0x73, 0xb3, 0x00, 0x01, 0x73, 0xd9, 0x00, 0x01, 0x73, 0xff, 0x00,
+    0x01, 0x74, 0x23, 0x00, 0x01, 0x74, 0x4d, 0x00, 0x01, 0x74, 0x73, 0x00,
+    0x01, 0x74, 0x9d, 0x00, 0x01, 0x74, 0xc2, 0x00, 0x01, 0x74, 0xe6, 0x00,
+    0x01, 0x75, 0x0f, 0x00, 0x01, 0x75, 0x34, 0x00, 0x01, 0x75, 0x5b, 0x00,
+    0x01, 0x75, 0x7e, 0x00, 0x01, 0x75, 0xa2, 0x00, 0x01, 0x75, 0xc4, 0x00,
+    0x01, 0x75, 0xe7, 0x00, 0x01, 0x76, 0x11, 0x00, 0x01, 0x76, 0x37, 0x00,
+    0x01, 0x76, 0x5c, 0x00, 0x01, 0x76, 0x82, 0x00, 0x01, 0x76, 0xa9, 0x00,
+    0x01, 0x76, 0xcb, 0x00, 0x01, 0x76, 0xf0, 0x00, 0x01, 0x77, 0x16, 0x00,
+    0x01, 0x77, 0x40, 0x00, 0x01, 0x77, 0x66, 0x00, 0x01, 0x77, 0x86, 0x00,
+    0x01, 0x77, 0xaa, 0x00, 0x01, 0x77, 0xd0, 0x00, 0x01, 0x77, 0xf3, 0x00,
+    0x01, 0x78, 0x1a, 0x00, 0x01, 0x78, 0x44, 0x00, 0x01, 0x78, 0x6f, 0x00,
+    0x01, 0x78, 0x98, 0x00, 0x01, 0x78, 0xbc, 0x00, 0x01, 0x78, 0xe8, 0x00,
+    0x01, 0x79, 0x0c, 0x00, 0x01, 0x79, 0x30, 0x00, 0x01, 0x79, 0x5b, 0x00,
+    0x01, 0x79, 0x7e, 0x00, 0x01, 0x79, 0xa4, 0x00, 0x01, 0x79, 0xcb, 0x00,
+    0x01, 0x79, 0xf1, 0x00, 0x01, 0x7a, 0x18, 0x00, 0x01, 0x7a, 0x3d, 0x00,
+    0x01, 0x7a, 0x61, 0x00, 0x01, 0x7a, 0x84, 0x00, 0x01, 0x7a, 0xaa, 0x00,
+    0x01, 0x7a, 0xce, 0x00, 0x01, 0x7a, 0xf6, 0x00, 0x01, 0x7b, 0x1a, 0x00,
+    0x01, 0x7b, 0x3b, 0x00, 0x01, 0x7b, 0x60, 0x00, 0x01, 0x7b, 0x84, 0x00,
+    0x01, 0x7b, 0xab, 0x00, 0x01, 0x7b, 0xd9, 0x00, 0x01, 0x7b, 0xfc, 0x00,
+    0x01, 0x7c, 0x1e, 0x00, 0x01, 0x7c, 0x45, 0x00, 0x01, 0x7c, 0x70, 0x00,
+    0x01, 0x7c, 0x99, 0x00, 0x01, 0x7c, 0xc0, 0x00, 0x01, 0x7c, 0xeb, 0x00,
+    0x01, 0x7d, 0x0e, 0x00, 0x01, 0x7d, 0x3d, 0x00, 0x01, 0x7d, 0x61, 0x00,
+    0x01, 0x7d, 0x87, 0x00, 0x01, 0x7d, 0xb4, 0x00, 0x01, 0x7d, 0xd9, 0x00,
+    0x01, 0x7e, 0x02, 0x00, 0x01, 0x7e, 0x28, 0x00, 0x01, 0x7e, 0x4b, 0x00,
+    0x01, 0x7e, 0x71, 0x00, 0x01, 0x7e, 0x98, 0x00, 0x01, 0x7e, 0xbf, 0x00,
+    0x01, 0x7e, 0xe3, 0x00, 0x01, 0x7f, 0x0b, 0x00, 0x01, 0x7f, 0x30, 0x00,
+    0x01, 0x7f, 0x55, 0x00, 0x01, 0x7f, 0x7f, 0x00, 0x01, 0x7f, 0xa6, 0x00,
+    0x01, 0x7f, 0xcb, 0x00, 0x01, 0x7f, 0xf5, 0x00, 0x01, 0x80, 0x1a, 0x00,
+    0x01, 0x80, 0x3c, 0x00, 0x01, 0x80, 0x5e, 0x00, 0x01, 0x80, 0x84, 0x00,
+    0x01, 0x80, 0xa9, 0x00, 0x01, 0x80, 0xcd, 0x00, 0x01, 0x80, 0xf0, 0x00,
+    0x01, 0x81, 0x13, 0x00, 0x01, 0x81, 0x3c, 0x00, 0x01, 0x81, 0x65, 0x00,
+    0x01, 0x81, 0x86, 0x00, 0x01, 0x81, 0xa9, 0x00, 0x01, 0x81, 0xc9, 0x00,
+    0x01, 0x81, 0xed, 0x00, 0x01, 0x82, 0x10, 0x00, 0x01, 0x82, 0x39, 0x00,
+    0x01, 0x82, 0x58, 0x00, 0x01, 0x82, 0x88, 0x00, 0x01, 0x82, 0xaf, 0x00,
+    0x01, 0x82, 0xd9, 0x00, 0x01, 0x82, 0xfc, 0x00, 0x01, 0x83, 0x23, 0x00,
+    0x01, 0x83, 0x47, 0x00, 0x01, 0x83, 0x6b, 0x00, 0x01, 0x83, 0x90, 0x00,
+    0x01, 0x83, 0xb4, 0x00, 0x01, 0x83, 0xda, 0x00, 0x01, 0x83, 0xfe, 0x00,
+    0x01, 0x84, 0x27, 0x00, 0x01, 0x84, 0x52, 0x00, 0x01, 0x84, 0x7d, 0x00,
+    0x01, 0x84, 0xa2, 0x00, 0x01, 0x84, 0xc9, 0x00, 0x01, 0x84, 0xf0, 0x00,
+    0x01, 0x85, 0x16, 0x00, 0x01, 0x85, 0x42, 0x00, 0x01, 0x85, 0x67, 0x00,
+    0x01, 0x85, 0x90, 0x00, 0x01, 0x85, 0xb4, 0x00, 0x01, 0x85, 0xdc, 0x00,
+    0x01, 0x86, 0x01, 0x00, 0x01, 0x86, 0x29, 0x00, 0x01, 0x86, 0x51, 0x00,
+    0x01, 0x86, 0x74, 0x00, 0x01, 0x86, 0x9a, 0x00, 0x01, 0x86, 0xc1, 0x00,
+    0x01, 0x86, 0xe2, 0x00, 0x01, 0x87, 0x0e, 0x00, 0x01, 0x87, 0x33, 0x00,
+    0x01, 0x87, 0x57, 0x00, 0x01, 0x87, 0x80, 0x00, 0x01, 0x87, 0xac, 0x00,
+    0x01, 0x87, 0xd3, 0x00, 0x01, 0x87, 0xf5, 0x00, 0x01, 0x88, 0x1e, 0x00,
+    0x01, 0x88, 0x45, 0x00, 0x01, 0x88, 0x6b, 0x00, 0x01, 0x88, 0x91, 0x00,
+    0x01, 0x88, 0xb2, 0x00, 0x01, 0x88, 0xd7, 0x00, 0x01, 0x89, 0x00, 0x00,
+    0x01, 0x89, 0x23, 0x00, 0x01, 0x89, 0x46, 0x00, 0x01, 0x89, 0x6a, 0x00,
+    0x01, 0x89, 0x91, 0x00, 0x01, 0x89, 0xb7, 0x00, 0x01, 0x89, 0xdc, 0x00,
+    0x01, 0x8a, 0x02, 0x00, 0x01, 0x8a, 0x2b, 0x00, 0x01, 0x8a, 0x52, 0x00,
+    0x01, 0x8a, 0x77, 0x00, 0x01, 0x8a, 0x9c, 0x00, 0x01, 0x8a, 0xc0, 0x00,
+    0x01, 0x8a, 0xe2, 0x00, 0x01, 0x8b, 0x06, 0x00, 0x01, 0x8b, 0x2a, 0x00,
+    0x01, 0x8b, 0x4a, 0x00, 0x01, 0x8b, 0x6e, 0x00, 0x01, 0x8b, 0x94, 0x00,
+    0x01, 0x8b, 0xb8, 0x00, 0x01, 0x8b, 0xe7, 0x00, 0x01, 0x8c, 0x0b, 0x00,
+    0x01, 0x8c, 0x2a, 0x00, 0x01, 0x8c, 0x52, 0x00, 0x01, 0x8c, 0x77, 0x00,
+    0x01, 0x8c, 0x96, 0x00, 0x01, 0x8c, 0xbb, 0x00, 0x01, 0x8c, 0xdf, 0x00,
+    0x01, 0x8d, 0x08, 0x00, 0x01, 0x8d, 0x2f, 0x00, 0x01, 0x8d, 0x55, 0x00,
+    0x01, 0x8d, 0x76, 0x00, 0x01, 0x8d, 0x97, 0x00, 0x01, 0x8d, 0xbc, 0x00,
+    0x01, 0x8d, 0xe3, 0x00, 0x01, 0x8e, 0x07, 0x00, 0x01, 0x8e, 0x2c, 0x00,
+    0x01, 0x8e, 0x50, 0x00, 0x01, 0x8e, 0x73, 0x00, 0x01, 0x8e, 0x94, 0x00,
+    0x01, 0x8e, 0xbd, 0x00, 0x01, 0x8e, 0xde, 0x00, 0x01, 0x8f, 0x06, 0x00,
+    0x01, 0x8f, 0x2a, 0x00, 0x01, 0x8f, 0x4e, 0x00, 0x01, 0x8f, 0x72, 0x00,
+    0x01, 0x8f, 0x99, 0x00, 0x01, 0x8f, 0xbc, 0x00, 0x01, 0x8f, 0xe4, 0x00,
+    0x01, 0x90, 0x06, 0x00, 0x01, 0x90, 0x2b, 0x00, 0x01, 0x90, 0x4f, 0x00,
+    0x01, 0x90, 0x76, 0x00, 0x01, 0x90, 0x9c, 0x00, 0x01, 0x90, 0xc0, 0x00,
+    0x01, 0x90, 0xe3, 0x00, 0x01, 0x91, 0x07, 0x00, 0x01, 0x91, 0x32, 0x00,
+    0x01, 0x91, 0x58, 0x00, 0x01, 0x91, 0x7c, 0x00, 0x01, 0x91, 0xa9, 0x00,
+    0x01, 0x91, 0xd6, 0x00, 0x01, 0x91, 0xfd, 0x00, 0x01, 0x92, 0x25, 0x00,
+    0x01, 0x92, 0x4f, 0x00, 0x01, 0x92, 0x74, 0x00, 0x01, 0x92, 0x9b, 0x00,
+    0x01, 0x92, 0xc1, 0x00, 0x01, 0x92, 0xe9, 0x00, 0x01, 0x93, 0x0c, 0x00,
+    0x01, 0x93, 0x3a, 0x00, 0x01, 0x93, 0x5d, 0x00, 0x01, 0x93, 0x84, 0x00,
+    0x01, 0x93, 0xa6, 0x00, 0x01, 0x93, 0xcd, 0x00, 0x01, 0x93, 0xf2, 0x00,
+    0x01, 0x94, 0x19, 0x00, 0x01, 0x94, 0x47, 0x00, 0x01, 0x94, 0x6a, 0x00,
+    0x01, 0x94, 0x91, 0x00, 0x01, 0x94, 0xba, 0x00, 0x01, 0x94, 0xe4, 0x00,
+    0x01, 0x95, 0x08, 0x00, 0x01, 0x95, 0x2f, 0x00, 0x01, 0x95, 0x53, 0x00,
+    0x01, 0x95, 0x77, 0x00, 0x01, 0x95, 0x9f, 0x00, 0x01, 0x95, 0xca, 0x00,
+    0x01, 0x95, 0xeb, 0x00, 0x01, 0x96, 0x11, 0x00, 0x01, 0x96, 0x34, 0x00,
+    0x01, 0x96, 0x5a, 0x00, 0x01, 0x96, 0x7e, 0x00, 0x01, 0x96, 0xa5, 0x00,
+    0x01, 0x96, 0xc7, 0x00, 0x01, 0x96, 0xf2, 0x00, 0x01, 0x97, 0x13, 0x00,
+    0x01, 0x97, 0x3a, 0x00, 0x01, 0x97, 0x5c, 0x00, 0x01, 0x97, 0x80, 0x00,
+    0x01, 0x97, 0xa6, 0x00, 0x01, 0x97, 0xd0, 0x00, 0x01, 0x97, 0xf7, 0x00,
+    0x01, 0x98, 0x1e, 0x00, 0x01, 0x98, 0x47, 0x00, 0x01, 0x98, 0x6a, 0x00,
+    0x01, 0x98, 0x97, 0x00, 0x01, 0x98, 0xbf, 0x00, 0x01, 0x98, 0xe0, 0x00,
+    0x01, 0x99, 0x07, 0x00, 0x01, 0x99, 0x28, 0x00, 0x01, 0x99, 0x51, 0x00,
+    0x01, 0x99, 0x72, 0x00, 0x01, 0x99, 0x99, 0x00, 0x01, 0x99, 0xbb, 0x00,
+    0x01, 0x99, 0xe0, 0x00, 0x01, 0x9a, 0x03, 0x00, 0x01, 0x9a, 0x29, 0x00,
+    0x01, 0x9a, 0x4b, 0x00, 0x01, 0x9a, 0x6f, 0x00, 0x01, 0x9a, 0x94, 0x00,
+    0x01, 0x9a, 0xb6, 0x00, 0x01, 0x9a, 0xd9, 0x00, 0x01, 0x9b, 0x05, 0x00,
+    0x01, 0x9b, 0x2e, 0x00, 0x01, 0x9b, 0x52, 0x00, 0x01, 0x9b, 0x77, 0x00,
+    0x01, 0x9b, 0x9c, 0x00, 0x01, 0x9b, 0xc3, 0x00, 0x01, 0x9b, 0xea, 0x00,
+    0x01, 0x9c, 0x10, 0x00, 0x01, 0x9c, 0x34, 0x00, 0x01, 0x9c, 0x59, 0x00,
+    0x01, 0x9c, 0x7f, 0x00, 0x01, 0x9c, 0xa9, 0x00, 0x01, 0x9c, 0xd1, 0x00,
+    0x01, 0x9c, 0xf8, 0x00, 0x01, 0x9d, 0x20, 0x00, 0x01, 0x9d, 0x48, 0x00,
+    0x01, 0x9d, 0x72, 0x00, 0x01, 0x9d, 0x9e, 0x00, 0x01, 0x9d, 0xc3, 0x00,
+    0x01, 0x9d, 0xe5, 0x00, 0x01, 0x9e, 0x0c, 0x00, 0x01, 0x9e, 0x31, 0x00,
+    0x01, 0x9e, 0x5c, 0x00, 0x01, 0x9e, 0x82, 0x00, 0x01, 0x9e, 0xa8, 0x00,
+    0x01, 0x9e, 0xcb, 0x00, 0x01, 0x9e, 0xf3, 0x00, 0x01, 0x9f, 0x17, 0x00,
+    0x01, 0x9f, 0x3a, 0x00, 0x01, 0x9f, 0x62, 0x00, 0x01, 0x9f, 0x87, 0x00,
+    0x01, 0x9f, 0xa9, 0x00, 0x01, 0x9f, 0xd2, 0x00, 0x01, 0x9f, 0xf7, 0x00,
+    0x01, 0xa0, 0x1e, 0x00, 0x01, 0xa0, 0x42, 0x00, 0x01, 0xa0, 0x6b, 0x00,
+    0x01, 0xa0, 0x8f, 0x00, 0x01, 0xa0, 0xb8, 0x00, 0x01, 0xa0, 0xe2, 0x00,
+    0x01, 0xa1, 0x09, 0x00, 0x01, 0xa1, 0x30, 0x00, 0x01, 0xa1, 0x57, 0x00,
+    0x01, 0xa1, 0x7d, 0x00, 0x01, 0xa1, 0xa0, 0x00, 0x01, 0xa1, 0xcc, 0x00,
+    0x01, 0xa1, 0xf4, 0x00, 0x01, 0xa2, 0x1a, 0x00, 0x01, 0xa2, 0x3d, 0x00,
+    0x01, 0xa2, 0x66, 0x00, 0x01, 0xa2, 0x87, 0x00, 0x01, 0xa2, 0xaf, 0x00,
+    0x01, 0xa2, 0xd3, 0x00, 0x01, 0xa2, 0xf8, 0x00, 0x01, 0xa3, 0x1c, 0x00,
+    0x01, 0xa3, 0x40, 0x00, 0x01, 0xa3, 0x65, 0x00, 0x01, 0xa3, 0x8a, 0x00,
+    0x01, 0xa3, 0xb5, 0x00, 0x01, 0xa3, 0xdc, 0x00, 0x01, 0xa4, 0x01, 0x00,
+    0x01, 0xa4, 0x25, 0x00, 0x01, 0xa4, 0x4e, 0x00, 0x01, 0xa4, 0x77, 0x00,
+    0x01, 0xa4, 0x9b, 0x00, 0x01, 0xa4, 0xbd, 0x00, 0x01, 0xa4, 0xe9, 0x00,
+    0x01, 0xa5, 0x0e, 0x00, 0x01, 0xa5, 0x33, 0x00, 0x01, 0xa5, 0x57, 0x00,
+    0x01, 0xa5, 0x84, 0x00, 0x01, 0xa5, 0xa6, 0x00, 0x01, 0xa5, 0xc9, 0x00,
+    0x01, 0xa5, 0xf7, 0x00, 0x01, 0xa6, 0x1e, 0x00, 0x01, 0xa6, 0x4a, 0x00,
+    0x01, 0xa6, 0x6d, 0x00, 0x01, 0xa6, 0x91, 0x00, 0x01, 0xa6, 0xb9, 0x00,
+    0x01, 0xa6, 0xe2, 0x00, 0x01, 0xa7, 0x07, 0x00, 0x01, 0xa7, 0x2c, 0x00,
+    0x01, 0xa7, 0x4f, 0x00, 0x01, 0xa7, 0x74, 0x00, 0x01, 0xa7, 0x9a, 0x00,
+    0x01, 0xa7, 0xc2, 0x00, 0x01, 0xa7, 0xe7, 0x00, 0x01, 0xa8, 0x0d, 0x00,
+    0x01, 0xa8, 0x33, 0x00, 0x01, 0xa8, 0x59, 0x00, 0x01, 0xa8, 0x7b, 0x00,
+    0x01, 0xa8, 0x9e, 0x00, 0x01, 0xa8, 0xc3, 0x00, 0x01, 0xa8, 0xe8, 0x00,
+    0x01, 0xa9, 0x0c, 0x00, 0x01, 0xa9, 0x37, 0x00, 0x01, 0xa9, 0x5c, 0x00,
+    0x01, 0xa9, 0x7e, 0x00, 0x01, 0xa9, 0xa9, 0x00, 0x01, 0xa9, 0xd1, 0x00,
+    0x01, 0xa9, 0xf7, 0x00, 0x01, 0xaa, 0x1f, 0x00, 0x01, 0xaa, 0x45, 0x00,
+    0x01, 0xaa, 0x6b, 0x00, 0x01, 0xaa, 0x91, 0x00, 0x01, 0xaa, 0xb7, 0x00,
+    0x01, 0xaa, 0xdb, 0x00, 0x01, 0xaa, 0xff, 0x00, 0x01, 0xab, 0x22, 0x00,
+    0x01, 0xab, 0x44, 0x00, 0x01, 0xab, 0x67, 0x00, 0x01, 0xab, 0x90, 0x00,
+    0x01, 0xab, 0xb3, 0x00, 0x01, 0xab, 0xdf, 0x00, 0x01, 0xac, 0x07, 0x00,
+    0x01, 0xac, 0x30, 0x00, 0x01, 0xac, 0x5d, 0x00, 0x01, 0xac, 0x82, 0x00,
+    0x01, 0xac, 0xaa, 0x00, 0x01, 0xac, 0xcf, 0x00, 0x01, 0xac, 0xf4, 0x00,
+    0x01, 0xad, 0x18, 0x00, 0x01, 0xad, 0x39, 0x00, 0x01, 0xad, 0x62, 0x00,
+    0x01, 0xad, 0x83, 0x00, 0x01, 0xad, 0xa6, 0x00, 0x01, 0xad, 0xcb, 0x00,
+    0x01, 0xad, 0xf8, 0x00, 0x01, 0xae, 0x21, 0x00, 0x01, 0xae, 0x49, 0x00,
+    0x01, 0xae, 0x70, 0x00, 0x01, 0xae, 0x9d, 0x00, 0x01, 0xae, 0xc4, 0x00,
+    0x01, 0xae, 0xe6, 0x00, 0x01, 0xaf, 0x0b, 0x00, 0x01, 0xaf, 0x2f, 0x00,
+    0x01, 0xaf, 0x55, 0x00, 0x01, 0xaf, 0x79, 0x00, 0x01, 0xaf, 0x9e, 0x00,
+    0x01, 0xaf, 0xbf, 0x00, 0x01, 0xaf, 0xe6, 0x00, 0x01, 0xb0, 0x0c, 0x00,
+    0x01, 0xb0, 0x2e, 0x00, 0x01, 0xb0, 0x52, 0x00, 0x01, 0xb0, 0x7a, 0x00,
+    0x01, 0xb0, 0xa3, 0x00, 0x01, 0xb0, 0xcd, 0x00, 0x01, 0xb0, 0xf2, 0x00,
+    0x01, 0xb1, 0x1a, 0x00, 0x01, 0xb1, 0x42, 0x00, 0x01, 0xb1, 0x67, 0x00,
+    0x01, 0xb1, 0x89, 0x00, 0x01, 0xb1, 0xaf, 0x00, 0x01, 0xb1, 0xd5, 0x00,
+    0x01, 0xb1, 0xfa, 0x00, 0x01, 0xb2, 0x1f, 0x00, 0x01, 0xb2, 0x43, 0x00,
+    0x01, 0xb2, 0x69, 0x00, 0x01, 0xb2, 0x8c, 0x00, 0x01, 0xb2, 0xb7, 0x00,
+    0x01, 0xb2, 0xe1, 0x00, 0x01, 0xb3, 0x03, 0x00, 0x01, 0xb3, 0x30, 0x00,
+    0x01, 0xb3, 0x57, 0x00, 0x01, 0xb3, 0x80, 0x00, 0x01, 0xb3, 0xa8, 0x00,
+    0x01, 0xb3, 0xcb, 0x00, 0x01, 0xb3, 0xf1, 0x00, 0x01, 0xb4, 0x1d, 0x00,
+    0x01, 0xb4, 0x48, 0x00, 0x01, 0xb4, 0x70, 0x00, 0x01, 0xb4, 0x96, 0x00,
+    0x01, 0xb4, 0xb8, 0x00, 0x01, 0xb4, 0xdc, 0x00, 0x01, 0xb5, 0x07, 0x00,
+    0x01, 0xb5, 0x2d, 0x00, 0x01, 0xb5, 0x50, 0x00, 0x01, 0xb5, 0x77, 0x00,
+    0x01, 0xb5, 0x9b, 0x00, 0x01, 0xb5, 0xc5, 0x00, 0x01, 0xb5, 0xea, 0x00,
+    0x01, 0xb6, 0x0f, 0x00, 0x01, 0xb6, 0x35, 0x00, 0x01, 0xb6, 0x5c, 0x00,
+    0x01, 0xb6, 0x85, 0x00, 0x01, 0xb6, 0xb2, 0x00, 0x01, 0xb6, 0xd2, 0x00,
+    0x01, 0xb6, 0xfd, 0x00, 0x01, 0xb7, 0x21, 0x00, 0x01, 0xb7, 0x49, 0x00,
+    0x01, 0xb7, 0x6d, 0x00, 0x01, 0xb7, 0x8f, 0x00, 0x01, 0xb7, 0xba, 0x00,
+    0x01, 0xb7, 0xe1, 0x00, 0x01, 0xb8, 0x03, 0x00, 0x01, 0xb8, 0x26, 0x00,
+    0x01, 0xb8, 0x4f, 0x00, 0x01, 0xb8, 0x73, 0x00, 0x01, 0xb8, 0x98, 0x00,
+    0x01, 0xb8, 0xbe, 0x00, 0x01, 0xb8, 0xe3, 0x00, 0x01, 0xb9, 0x09, 0x00,
+    0x01, 0xb9, 0x2d, 0x00, 0x01, 0xb9, 0x52, 0x00, 0x01, 0xb9, 0x79, 0x00,
+    0x01, 0xb9, 0xa1, 0x00, 0x01, 0xb9, 0xc5, 0x00, 0x01, 0xb9, 0xeb, 0x00,
+    0x01, 0xba, 0x11, 0x00, 0x01, 0xba, 0x34, 0x00, 0x01, 0xba, 0x58, 0x00,
+    0x01, 0xba, 0x80, 0x00, 0x01, 0xba, 0xa3, 0x00, 0x01, 0xba, 0xce, 0x00,
+    0x01, 0xba, 0xf3, 0x00, 0x01, 0xbb, 0x19, 0x00, 0x01, 0xbb, 0x45, 0x00,
+    0x01, 0xbb, 0x6b, 0x00, 0x01, 0xbb, 0x92, 0x00, 0x01, 0xbb, 0xbf, 0x00,
+    0x01, 0xbb, 0xe5, 0x00, 0x01, 0xbc, 0x06, 0x00, 0x01, 0xbc, 0x2e, 0x00,
+    0x01, 0xbc, 0x59, 0x00, 0x01, 0xbc, 0x81, 0x00, 0x01, 0xbc, 0xa6, 0x00,
+    0x01, 0xbc, 0xc6, 0x00, 0x01, 0xbc, 0xe8, 0x00, 0x01, 0xbd, 0x0c, 0x00,
+    0x01, 0xbd, 0x3a, 0x00, 0x01, 0xbd, 0x64, 0x00, 0x01, 0xbd, 0x89, 0x00,
+    0x01, 0xbd, 0xab, 0x00, 0x01, 0xbd, 0xd7, 0x00, 0x01, 0xbd, 0xfd, 0x00,
+    0x01, 0xbe, 0x27, 0x00, 0x01, 0xbe, 0x4a, 0x00, 0x01, 0xbe, 0x6b, 0x00,
+    0x01, 0xbe, 0x91, 0x00, 0x01, 0xbe, 0xb7, 0x00, 0x01, 0xbe, 0xd8, 0x00,
+    0x01, 0xbe, 0xfd, 0x00, 0x01, 0xbf, 0x22, 0x00, 0x01, 0xbf, 0x48, 0x00,
+    0x01, 0xbf, 0x6e, 0x00, 0x01, 0xbf, 0x9f, 0x00, 0x01, 0xbf, 0xc8, 0x00,
+    0x01, 0xbf, 0xeb, 0x00, 0x01, 0xc0, 0x0d, 0x00, 0x01, 0xc0, 0x2f, 0x00,
+    0x01, 0xc0, 0x52, 0x00, 0x01, 0xc0, 0x7b, 0x00, 0x01, 0xc0, 0x9c, 0x00,
+    0x01, 0xc0, 0xc0, 0x00, 0x01, 0xc0, 0xe9, 0x00, 0x01, 0xc1, 0x0e, 0x00,
+    0x01, 0xc1, 0x31, 0x00, 0x01, 0xc1, 0x61, 0x00, 0x01, 0xc1, 0x86, 0x00,
+    0x01, 0xc1, 0xb0, 0x00, 0x01, 0xc1, 0xd4, 0x00, 0x01, 0xc2, 0x02, 0x00,
+    0x01, 0xc2, 0x23, 0x00, 0x01, 0xc2, 0x49, 0x00, 0x01, 0xc2, 0x71, 0x00,
+    0x01, 0xc2, 0x97, 0x00, 0x01, 0xc2, 0xbf, 0x00, 0x01, 0xc2, 0xe5, 0x00,
+    0x01, 0xc3, 0x0d, 0x00, 0x01, 0xc3, 0x31, 0x00, 0x01, 0xc3, 0x56, 0x00,
+    0x01, 0xc3, 0x7a, 0x00, 0x01, 0xc3, 0xa3, 0x00, 0x01, 0xc3, 0xc8, 0x00,
+    0x01, 0xc3, 0xea, 0x00, 0x01, 0xc4, 0x10, 0x00, 0x01, 0xc4, 0x38, 0x00,
+    0x01, 0xc4, 0x61, 0x00, 0x01, 0xc4, 0x89, 0x00, 0x01, 0xc4, 0xaa, 0x00,
+    0x01, 0xc4, 0xd1, 0x00, 0x01, 0xc4, 0xf8, 0x00, 0x01, 0xc5, 0x1c, 0x00,
+    0x01, 0xc5, 0x40, 0x00, 0x01, 0xc5, 0x65, 0x00, 0x01, 0xc5, 0x87, 0x00,
+    0x01, 0xc5, 0xb1, 0x00, 0x01, 0xc5, 0xd4, 0x00, 0x01, 0xc5, 0xff, 0x00,
+    0x01, 0xc6, 0x26, 0x00, 0x01, 0xc6, 0x46, 0x00, 0x01, 0xc6, 0x6f, 0x00,
+    0x01, 0xc6, 0x94, 0x00, 0x01, 0xc6, 0xbd, 0x00, 0x01, 0xc6, 0xe1, 0x00,
+    0x01, 0xc7, 0x04, 0x00, 0x01, 0xc7, 0x29, 0x00, 0x01, 0xc7, 0x4c, 0x00,
+    0x01, 0xc7, 0x71, 0x00, 0x01, 0xc7, 0x98, 0x00, 0x01, 0xc7, 0xbe, 0x00,
+    0x01, 0xc7, 0xe4, 0x00, 0x01, 0xc8, 0x07, 0x00, 0x01, 0xc8, 0x2e, 0x00,
+    0x01, 0xc8, 0x57, 0x00, 0x01, 0xc8, 0x7d, 0x00, 0x01, 0xc8, 0xa3, 0x00,
+    0x01, 0xc8, 0xc8, 0x00, 0x01, 0xc8, 0xeb, 0x00, 0x01, 0xc9, 0x14, 0x00,
+    0x01, 0xc9, 0x3e, 0x00, 0x01, 0xc9, 0x63, 0x00, 0x01, 0xc9, 0x8a, 0x00,
+    0x01, 0xc9, 0xb2, 0x00, 0x01, 0xc9, 0xd5, 0x00, 0x01, 0xc9, 0xf7, 0x00,
+    0x01, 0xca, 0x19, 0x00, 0x01, 0xca, 0x44, 0x00, 0x01, 0xca, 0x6b, 0x00,
+    0x01, 0xca, 0x8f, 0x00, 0x01, 0xca, 0xb5, 0x00, 0x01, 0xca, 0xdb, 0x00,
+    0x01, 0xcb, 0x00, 0x00, 0x01, 0xcb, 0x25, 0x00, 0x01, 0xcb, 0x49, 0x00,
+    0x01, 0xcb, 0x71, 0x00, 0x01, 0xcb, 0x92, 0x00, 0x01, 0xcb, 0xb6, 0x00,
+    0x01, 0xcb, 0xdb, 0x00, 0x01, 0xcc, 0x01, 0x00, 0x01, 0xcc, 0x2b, 0x00,
+    0x01, 0xcc, 0x51, 0x00, 0x01, 0xcc, 0x74, 0x00, 0x01, 0xcc, 0x97, 0x00,
+    0x01, 0xcc, 0xb8, 0x00, 0x01, 0xcc, 0xde, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x7d, 0x00,
+    0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0xce, 0x00, 0x00, 0x00, 0xf6, 0x00,
+    0x00, 0x01, 0x1c, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x01, 0x63, 0x00,
+    0x00, 0x01, 0x92, 0x00, 0x00, 0x01, 0xbd, 0x00, 0x00, 0x01, 0xe1, 0x00,
+    0x00, 0x02, 0x0b, 0x00, 0x00, 0x02, 0x2f, 0x00, 0x00, 0x02, 0x59, 0x00,
+    0x00, 0x02, 0x7d, 0x00, 0x00, 0x02, 0xa5, 0x00, 0x00, 0x02, 0xcb, 0x00,
+    0x00, 0x02, 0xf1, 0x00, 0x00, 0x03, 0x1b, 0x00, 0x00, 0x03, 0x3d, 0x00,
+    0x00, 0x03, 0x68, 0x00, 0x00, 0x03, 0x94, 0x00, 0x00, 0x03, 0xb7, 0x00,
+    0x00, 0x03, 0xda, 0x00, 0x00, 0x03, 0xfe, 0x00, 0x00, 0x04, 0x24, 0x00,
+    0x00, 0x04, 0x48, 0x00, 0x00, 0x04, 0x6d, 0x00, 0x00, 0x04, 0x94, 0x00,
+    0x00, 0x04, 0xb7, 0x00, 0x00, 0x04, 0xda, 0x00, 0x00, 0x04, 0xfd, 0x00,
+    0x00, 0x05, 0x22, 0x00, 0x00, 0x05, 0x4f, 0x00, 0x00, 0x05, 0x76, 0x00,
+    0x00, 0x05, 0x9b, 0x00, 0x00, 0x05, 0xc1, 0x00, 0x00, 0x05, 0xe3, 0x00,
+    0x00, 0x06, 0x08, 0x00, 0x00, 0x06, 0x2b, 0x00, 0x00, 0x06, 0x52, 0x00,
+    0x00, 0x06, 0x76, 0x00, 0x00, 0x06, 0x97, 0x00, 0x00, 0x06, 0xbd, 0x00,
+    0x00, 0x06, 0xe4, 0x00, 0x00, 0x07, 0x09, 0x00, 0x00, 0x07, 0x2b, 0x00,
+    0x00, 0x07, 0x4d, 0x00, 0x00, 0x07, 0x6f, 0x00, 0x00, 0x07, 0x97, 0x00,
+    0x00, 0x07, 0xbd, 0x00, 0x00, 0x07, 0xe6, 0x00, 0x00, 0x08, 0x11, 0x00,
+    0x00, 0x08, 0x3f, 0x00, 0x00, 0x08, 0x67, 0x00, 0x00, 0x08, 0x8b, 0x00,
+    0x00, 0x08, 0xad, 0x00, 0x00, 0x08, 0xd9, 0x00, 0x00, 0x09, 0x07, 0x00,
+    0x00, 0x09, 0x2b, 0x00, 0x00, 0x09, 0x53, 0x00, 0x00, 0x09, 0x7c, 0x00,
+    0x00, 0x09, 0xa3, 0x00, 0x00, 0x09, 0xc7, 0x00, 0x00, 0x09, 0xeb, 0x00,
+    0x00, 0x0a, 0x12, 0x00, 0x00, 0x0a, 0x36, 0x00, 0x00, 0x0a, 0x5e, 0x00,
+    0x00, 0x0a, 0x82, 0x00, 0x00, 0x0a, 0xa7, 0x00, 0x00, 0x0a, 0xce, 0x00,
+    0x00, 0x0a, 0xf2, 0x00, 0x00, 0x0b, 0x19, 0x00, 0x00, 0x0b, 0x3d, 0x00,
+    0x00, 0x0b, 0x66, 0x00, 0x00, 0x0b, 0x8e, 0x00, 0x00, 0x0b, 0xb0, 0x00,
+    0x00, 0x0b, 0xd4, 0x00, 0x00, 0x0b, 0xf9, 0x00, 0x00, 0x0c, 0x1e, 0x00,
+    0x00, 0x0c, 0x42, 0x00, 0x00, 0x0c, 0x6b, 0x00, 0x00, 0x0c, 0x95, 0x00,
+    0x00, 0x0c, 0xbf, 0x00, 0x00, 0x0c, 0xe5, 0x00, 0x00, 0x0d, 0x05, 0x00,
+    0x00, 0x0d, 0x26, 0x00, 0x00, 0x0d, 0x4d, 0x00, 0x00, 0x0d, 0x72, 0x00,
+    0x00, 0x0d, 0x97, 0x00, 0x00, 0x0d, 0xbd, 0x00, 0x00, 0x0d, 0xe2, 0x00,
+    0x00, 0x0e, 0x06, 0x00, 0x00, 0x0e, 0x26, 0x00, 0x00, 0x0e, 0x4e, 0x00,
+    0x00, 0x0e, 0x74, 0x00, 0x00, 0x0e, 0x9e, 0x00, 0x00, 0x0e, 0xc6, 0x00,
+    0x00, 0x0e, 0xec, 0x00, 0x00, 0x0f, 0x10, 0x00, 0x00, 0x0f, 0x34, 0x00,
+    0x00, 0x0f, 0x63, 0x00, 0x00, 0x0f, 0x87, 0x00, 0x00, 0x0f, 0xad, 0x00,
+    0x00, 0x0f, 0xd1, 0x00, 0x00, 0x0f, 0xf5, 0x00, 0x00, 0x10, 0x1a, 0x00,
+    0x00, 0x10, 0x42, 0x00, 0x00, 0x10, 0x6b, 0x00, 0x00, 0x10, 0x8b, 0x00,
+    0x00, 0x10, 0xb4, 0x00, 0x00, 0x10, 0xd5, 0x00, 0x00, 0x10, 0xf9, 0x00,
+    0x00, 0x11, 0x24, 0x00, 0x00, 0x11, 0x48, 0x00, 0x00, 0x11, 0x6f, 0x00,
+    0x00, 0x11, 0x94, 0x00, 0x00, 0x11, 0xbb, 0x00, 0x00, 0x11, 0xdf, 0x00,
+    0x00, 0x12, 0x06, 0x00, 0x00, 0x12, 0x29, 0x00, 0x00, 0x12, 0x4e, 0x00,
+    0x00, 0x12, 0x7a, 0x00, 0x00, 0x12, 0xa3, 0x00, 0x00, 0x12, 0xc5, 0x00,
+    0x00, 0x12, 0xe8, 0x00, 0x00, 0x13, 0x0e, 0x00, 0x00, 0x13, 0x37, 0x00,
+    0x00, 0x13, 0x62, 0x00, 0x00, 0x13, 0x8d, 0x00, 0x00, 0x13, 0xb2, 0x00,
+    0x00, 0x13, 0xd6, 0x00, 0x00, 0x13, 0xfb, 0x00, 0x00, 0x14, 0x1d, 0x00,
+    0x00, 0x14, 0x3e, 0x00, 0x00, 0x14, 0x6b, 0x00, 0x00, 0x14, 0x8d, 0x00,
+    0x00, 0x14, 0xb2, 0x00, 0x00, 0x14, 0xd3, 0x00, 0x00, 0x14, 0xf9, 0x00,
+    0x00, 0x15, 0x1e, 0x00, 0x00, 0x15, 0x43, 0x00, 0x00, 0x15, 0x6c, 0x00,
+    0x00, 0x15, 0x93, 0x00, 0x00, 0x15, 0xbc, 0x00, 0x00, 0x15, 0xe8, 0x00,
+    0x00, 0x16, 0x10, 0x00, 0x00, 0x16, 0x35, 0x00, 0x00, 0x16, 0x55, 0x00,
+    0x00, 0x16, 0x7e, 0x00, 0x00, 0x16, 0xa3, 0x00, 0x00, 0x16, 0xc9, 0x00,
+    0x00, 0x16, 0xf0, 0x00, 0x00, 0x17, 0x17, 0x00, 0x00, 0x17, 0x43, 0x00,
+    0x00, 0x17, 0x67, 0x00, 0x00, 0x17, 0x90, 0x00, 0x00, 0x17, 0xb7, 0x00,
+    0x00, 0x17, 0xe4, 0x00, 0x00, 0x18, 0x0e, 0x00, 0x00, 0x18, 0x36, 0x00,
+    0x00, 0x18, 0x5f, 0x00, 0x00, 0x18, 0x84, 0x00, 0x00, 0x18, 0xaf, 0x00,
+    0x00, 0x18, 0xd6, 0x00, 0x00, 0x18, 0xfb, 0x00, 0x00, 0x19, 0x20, 0x00,
+    0x00, 0x19, 0x4a, 0x00, 0x00, 0x19, 0x71, 0x00, 0x00, 0x19, 0x97, 0x00,
+    0x00, 0x19, 0xbf, 0x00, 0x00, 0x19, 0xe7, 0x00, 0x00, 0x1a, 0x09, 0x00,
+    0x00, 0x1a, 0x36, 0x00, 0x00, 0x1a, 0x5b, 0x00, 0x00, 0x1a, 0x80, 0x00,
+    0x00, 0x1a, 0xa3, 0x00, 0x00, 0x1a, 0xc8, 0x00, 0x00, 0x1a, 0xea, 0x00,
+    0x00, 0x1b, 0x17, 0x00, 0x00, 0x1b, 0x44, 0x00, 0x00, 0x1b, 0x67, 0x00,
+    0x00, 0x1b, 0x8c, 0x00, 0x00, 0x1b, 0xb6, 0x00, 0x00, 0x1b, 0xdf, 0x00,
+    0x00, 0x1c, 0x04, 0x00, 0x00, 0x1c, 0x28, 0x00, 0x00, 0x1c, 0x4b, 0x00,
+    0x00, 0x1c, 0x6f, 0x00, 0x00, 0x1c, 0x99, 0x00, 0x00, 0x1c, 0xbe, 0x00,
+    0x00, 0x1c, 0xe1, 0x00, 0x00, 0x1d, 0x03, 0x00, 0x00, 0x1d, 0x2a, 0x00,
+    0x00, 0x1d, 0x4f, 0x00, 0x00, 0x1d, 0x73, 0x00, 0x00, 0x1d, 0x95, 0x00,
+    0x00, 0x1d, 0xba, 0x00, 0x00, 0x1d, 0xe0, 0x00, 0x00, 0x1e, 0x0a, 0x00,
+    0x00, 0x1e, 0x2f, 0x00, 0x00, 0x1e, 0x55, 0x00, 0x00, 0x1e, 0x82, 0x00,
+    0x00, 0x1e, 0xb2, 0x00, 0x00, 0x1e, 0xd4, 0x00, 0x00, 0x1e, 0xfb, 0x00,
+    0x00, 0x1f, 0x20, 0x00, 0x00, 0x1f, 0x44, 0x00, 0x00, 0x1f, 0x6a, 0x00,
+    0x00, 0x1f, 0x90, 0x00, 0x00, 0x1f, 0xb4, 0x00, 0x00, 0x1f, 0xd5, 0x00,
+    0x00, 0x1f, 0xf4, 0x00, 0x00, 0x20, 0x1a, 0x00, 0x00, 0x20, 0x42, 0x00,
+    0x00, 0x20, 0x68, 0x00, 0x00, 0x20, 0x8e, 0x00, 0x00, 0x20, 0xb0, 0x00,
+    0x00, 0x20, 0xd0, 0x00, 0x00, 0x20, 0xf1, 0x00, 0x00, 0x21, 0x13, 0x00,
+    0x00, 0x21, 0x3c, 0x00, 0x00, 0x21, 0x5f, 0x00, 0x00, 0x21, 0x83, 0x00,
+    0x00, 0x21, 0xa7, 0x00, 0x00, 0x21, 0xcd, 0x00, 0x00, 0x21, 0xf1, 0x00,
+    0x00, 0x22, 0x1a, 0x00, 0x00, 0x22, 0x3c, 0x00, 0x00, 0x22, 0x60, 0x00,
+    0x00, 0x22, 0x8b, 0x00, 0x00, 0x22, 0xb2, 0x00, 0x00, 0x22, 0xd9, 0x00,
+    0x00, 0x22, 0xff, 0x00, 0x00, 0x23, 0x2a, 0x00, 0x00, 0x23, 0x4e, 0x00,
+    0x00, 0x23, 0x77, 0x00, 0x00, 0x23, 0xaf, 0x00, 0x00, 0x23, 0xd4, 0x00,
+    0x00, 0x23, 0xfc, 0x00, 0x00, 0x24, 0x1d, 0x00, 0x00, 0x24, 0x42, 0x00,
+    0x00, 0x24, 0x6a, 0x00, 0x00, 0x24, 0x94, 0x00, 0x00, 0x24, 0xb4, 0x00,
+    0x00, 0x24, 0xd5, 0x00, 0x00, 0x24, 0xfd, 0x00, 0x00, 0x25, 0x25, 0x00,
+    0x00, 0x25, 0x53, 0x00, 0x00, 0x25, 0x7e, 0x00, 0x00, 0x25, 0xab, 0x00,
+    0x00, 0x25, 0xce, 0x00, 0x00, 0x25, 0xf4, 0x00, 0x00, 0x26, 0x1e, 0x00,
+    0x00, 0x26, 0x44, 0x00, 0x00, 0x26, 0x6f, 0x00, 0x00, 0x26, 0x90, 0x00,
+    0x00, 0x26, 0xb3, 0x00, 0x00, 0x26, 0xdf, 0x00, 0x00, 0x27, 0x06, 0x00,
+    0x00, 0x27, 0x2a, 0x00, 0x00, 0x27, 0x53, 0x00, 0x00, 0x27, 0x7a, 0x00,
+    0x00, 0x27, 0xa2, 0x00, 0x00, 0x27, 0xc4, 0x00, 0x00, 0x27, 0xe8, 0x00,
+    0x00, 0x28, 0x0d, 0x00, 0x00, 0x28, 0x31, 0x00, 0x00, 0x28, 0x57, 0x00,
+    0x00, 0x28, 0x7f, 0x00, 0x00, 0x28, 0xa3, 0x00, 0x00, 0x28, 0xc2, 0x00,
+    0x00, 0x28, 0xe8, 0x00, 0x00, 0x29, 0x0b, 0x00, 0x00, 0x29, 0x34, 0x00,
+    0x00, 0x29, 0x58, 0x00, 0x00, 0x29, 0x85, 0x00, 0x00, 0x29, 0xa8, 0x00,
+    0x00, 0x29, 0xcd, 0x00, 0x00, 0x29, 0xf5, 0x00, 0x00, 0x2a, 0x20, 0x00,
+    0x00, 0x2a, 0x49, 0x00, 0x00, 0x2a, 0x6f, 0x00, 0x00, 0x2a, 0x98, 0x00,
+    0x00, 0x2a, 0xbb, 0x00, 0x00, 0x2a, 0xe0, 0x00, 0x00, 0x2b, 0x03, 0x00,
+    0x00, 0x2b, 0x2c, 0x00, 0x00, 0x2b, 0x55, 0x00, 0x00, 0x2b, 0x7d, 0x00,
+    0x00, 0x2b, 0xa0, 0x00, 0x00, 0x2b, 0xc2, 0x00, 0x00, 0x2b, 0xe5, 0x00,
+    0x00, 0x2c, 0x11, 0x00, 0x00, 0x2c, 0x33, 0x00, 0x00, 0x2c, 0x52, 0x00,
+    0x00, 0x2c, 0x7b, 0x00, 0x00, 0x2c, 0x9e, 0x00, 0x00, 0x2c, 0xc5, 0x00,
+    0x00, 0x2c, 0xf0, 0x00, 0x00, 0x2d, 0x14, 0x00, 0x00, 0x2d, 0x36, 0x00,
+    0x00, 0x2d, 0x5d, 0x00, 0x00, 0x2d, 0x86, 0x00, 0x00, 0x2d, 0xa8, 0x00,
+    0x00, 0x2d, 0xd0, 0x00, 0x00, 0x2d, 0xf5, 0x00, 0x00, 0x2e, 0x21, 0x00,
+    0x00, 0x2e, 0x46, 0x00, 0x00, 0x2e, 0x68, 0x00, 0x00, 0x2e, 0x8c, 0x00,
+    0x00, 0x2e, 0xb4, 0x00, 0x00, 0x2e, 0xd5, 0x00, 0x00, 0x2e, 0xf8, 0x00,
+    0x00, 0x2f, 0x24, 0x00, 0x00, 0x2f, 0x48, 0x00, 0x00, 0x2f, 0x75, 0x00,
+    0x00, 0x2f, 0x9b, 0x00, 0x00, 0x2f, 0xc6, 0x00, 0x00, 0x2f, 0xed, 0x00,
+    0x00, 0x30, 0x13, 0x00, 0x00, 0x30, 0x35, 0x00, 0x00, 0x30, 0x5e, 0x00,
+    0x00, 0x30, 0x85, 0x00, 0x00, 0x30, 0xaa, 0x00, 0x00, 0x30, 0xcd, 0x00,
+    0x00, 0x30, 0xf2, 0x00, 0x00, 0x31, 0x19, 0x00, 0x00, 0x31, 0x3f, 0x00,
+    0x00, 0x31, 0x65, 0x00, 0x00, 0x31, 0x8a, 0x00, 0x00, 0x31, 0xb5, 0x00,
+    0x00, 0x31, 0xdc, 0x00, 0x00, 0x32, 0x01, 0x00, 0x00, 0x32, 0x24, 0x00,
+    0x00, 0x32, 0x49, 0x00, 0x00, 0x32, 0x71, 0x00, 0x00, 0x32, 0x97, 0x00,
+    0x00, 0x32, 0xbb, 0x00, 0x00, 0x32, 0xe0, 0x00, 0x00, 0x33, 0x04, 0x00,
+    0x00, 0x33, 0x2c, 0x00, 0x00, 0x33, 0x51, 0x00, 0x00, 0x33, 0x78, 0x00,
+    0x00, 0x33, 0x9f, 0x00, 0x00, 0x33, 0xc3, 0x00, 0x00, 0x33, 0xed, 0x00,
+    0x00, 0x34, 0x10, 0x00, 0x00, 0x34, 0x37, 0x00, 0x00, 0x34, 0x5c, 0x00,
+    0x00, 0x34, 0x7c, 0x00, 0x00, 0x34, 0xa3, 0x00, 0x00, 0x34, 0xcc, 0x00,
+    0x00, 0x34, 0xf2, 0x00, 0x00, 0x35, 0x16, 0x00, 0x00, 0x35, 0x3b, 0x00,
+    0x00, 0x35, 0x5d, 0x00, 0x00, 0x35, 0x8b, 0x00, 0x00, 0x35, 0xb1, 0x00,
+    0x00, 0x35, 0xd5, 0x00, 0x00, 0x35, 0xfd, 0x00, 0x00, 0x36, 0x21, 0x00,
+    0x00, 0x36, 0x4d, 0x00, 0x00, 0x36, 0x75, 0x00, 0x00, 0x36, 0x9c, 0x00,
+    0x00, 0x36, 0xc5, 0x00, 0x00, 0x36, 0xeb, 0x00, 0x00, 0x37, 0x10, 0x00,
+    0x00, 0x37, 0x38, 0x00, 0x00, 0x37, 0x57, 0x00, 0x00, 0x37, 0x79, 0x00,
+    0x00, 0x37, 0x9d, 0x00, 0x00, 0x37, 0xc5, 0x00, 0x00, 0x37, 0xe9, 0x00,
+    0x00, 0x38, 0x0f, 0x00, 0x00, 0x38, 0x33, 0x00, 0x00, 0x38, 0x58, 0x00,
+    0x00, 0x38, 0x79, 0x00, 0x00, 0x38, 0x9c, 0x00, 0x00, 0x38, 0xbe, 0x00,
+    0x00, 0x38, 0xdf, 0x00, 0x00, 0x39, 0x03, 0x00, 0x00, 0x39, 0x29, 0x00,
+    0x00, 0x39, 0x53, 0x00, 0x00, 0x39, 0x7e, 0x00, 0x00, 0x39, 0x9e, 0x00,
+    0x00, 0x39, 0xc1, 0x00, 0x00, 0x39, 0xea, 0x00, 0x00, 0x3a, 0x0f, 0x00,
+    0x00, 0x3a, 0x34, 0x00, 0x00, 0x3a, 0x5b, 0x00, 0x00, 0x3a, 0x82, 0x00,
+    0x00, 0x3a, 0xa6, 0x00, 0x00, 0x3a, 0xd0, 0x00, 0x00, 0x3a, 0xf6, 0x00,
+    0x00, 0x3b, 0x1c, 0x00, 0x00, 0x3b, 0x3e, 0x00, 0x00, 0x3b, 0x61, 0x00,
+    0x00, 0x3b, 0x86, 0x00, 0x00, 0x3b, 0xaa, 0x00, 0x00, 0x3b, 0xd3, 0x00,
+    0x00, 0x3b, 0xf7, 0x00, 0x00, 0x3c, 0x1b, 0x00, 0x00, 0x3c, 0x45, 0x00,
+    0x00, 0x3c, 0x6b, 0x00, 0x00, 0x3c, 0x93, 0x00, 0x00, 0x3c, 0xb8, 0x00,
+    0x00, 0x3c, 0xda, 0x00, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x3d, 0x26, 0x00,
+    0x00, 0x3d, 0x4c, 0x00, 0x00, 0x3d, 0x6e, 0x00, 0x00, 0x3d, 0x96, 0x00,
+    0x00, 0x3d, 0xb7, 0x00, 0x00, 0x3d, 0xd8, 0x00, 0x00, 0x3d, 0xfe, 0x00,
+    0x00, 0x3e, 0x22, 0x00, 0x00, 0x3e, 0x47, 0x00, 0x00, 0x3e, 0x6a, 0x00,
+    0x00, 0x3e, 0x8f, 0x00, 0x00, 0x3e, 0xb9, 0x00, 0x00, 0x3e, 0xe1, 0x00,
+    0x00, 0x3f, 0x04, 0x00, 0x00, 0x3f, 0x28, 0x00, 0x00, 0x3f, 0x4c, 0x00,
+    0x00, 0x3f, 0x6f, 0x00, 0x00, 0x3f, 0x93, 0x00, 0x00, 0x3f, 0xb9, 0x00,
+    0x00, 0x3f, 0xdd, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, 0x25, 0x00,
+    0x00, 0x40, 0x4a, 0x00, 0x00, 0x40, 0x6f, 0x00, 0x00, 0x40, 0x9c, 0x00,
+    0x00, 0x40, 0xc9, 0x00, 0x00, 0x40, 0xed, 0x00, 0x00, 0x41, 0x1c, 0x00,
+    0x00, 0x41, 0x42, 0x00, 0x00, 0x41, 0x68, 0x00, 0x00, 0x41, 0x8d, 0x00,
+    0x00, 0x41, 0xaf, 0x00, 0x00, 0x41, 0xdc, 0x00, 0x00, 0x41, 0xfc, 0x00,
+    0x00, 0x42, 0x20, 0x00, 0x00, 0x42, 0x44, 0x00, 0x00, 0x42, 0x6c, 0x00,
+    0x00, 0x42, 0x95, 0x00, 0x00, 0x42, 0xb7, 0x00, 0x00, 0x42, 0xdd, 0x00,
+    0x00, 0x43, 0x05, 0x00, 0x00, 0x43, 0x2f, 0x00, 0x00, 0x43, 0x51, 0x00,
+    0x00, 0x43, 0x72, 0x00, 0x00, 0x43, 0x97, 0x00, 0x00, 0x43, 0xbe, 0x00,
+    0x00, 0x43, 0xe4, 0x00, 0x00, 0x44, 0x05, 0x00, 0x00, 0x44, 0x36, 0x00,
+    0x00, 0x44, 0x55, 0x00, 0x00, 0x44, 0x7b, 0x00, 0x00, 0x44, 0x9e, 0x00,
+    0x00, 0x44, 0xc6, 0x00, 0x00, 0x44, 0xf4, 0x00, 0x00, 0x45, 0x19, 0x00,
+    0x00, 0x45, 0x43, 0x00, 0x00, 0x45, 0x68, 0x00, 0x00, 0x45, 0x87, 0x00,
+    0x00, 0x45, 0xa9, 0x00, 0x00, 0x45, 0xcf, 0x00, 0x00, 0x45, 0xf6, 0x00,
+    0x00, 0x46, 0x19, 0x00, 0x00, 0x46, 0x3c, 0x00, 0x00, 0x46, 0x61, 0x00,
+    0x00, 0x46, 0x80, 0x00, 0x00, 0x46, 0xa6, 0x00, 0x00, 0x46, 0xd0, 0x00,
+    0x00, 0x46, 0xf4, 0x00, 0x00, 0x47, 0x19, 0x00, 0x00, 0x47, 0x44, 0x00,
+    0x00, 0x47, 0x6c, 0x00, 0x00, 0x47, 0x8f, 0x00, 0x00, 0x47, 0xb3, 0x00,
+    0x00, 0x47, 0xd6, 0x00, 0x00, 0x47, 0xfb, 0x00, 0x00, 0x48, 0x20, 0x00,
+    0x00, 0x48, 0x45, 0x00, 0x00, 0x48, 0x70, 0x00, 0x00, 0x48, 0x98, 0x00,
+    0x00, 0x48, 0xbe, 0x00, 0x00, 0x48, 0xe1, 0x00, 0x00, 0x49, 0x02, 0x00,
+    0x00, 0x49, 0x29, 0x00, 0x00, 0x49, 0x4f, 0x00, 0x00, 0x49, 0x76, 0x00,
+    0x00, 0x49, 0x9c, 0x00, 0x00, 0x49, 0xc6, 0x00, 0x00, 0x49, 0xec, 0x00,
+    0x00, 0x4a, 0x15, 0x00, 0x00, 0x4a, 0x3f, 0x00, 0x00, 0x4a, 0x64, 0x00,
+    0x00, 0x4a, 0x8e, 0x00, 0x00, 0x4a, 0xb3, 0x00, 0x00, 0x4a, 0xd6, 0x00,
+    0x00, 0x4a, 0xff, 0x00, 0x00, 0x4b, 0x24, 0x00, 0x00, 0x4b, 0x48, 0x00,
+    0x00, 0x4b, 0x68, 0x00, 0x00, 0x4b, 0x8e, 0x00, 0x00, 0x4b, 0xb1, 0x00,
+    0x00, 0x4b, 0xde, 0x00, 0x00, 0x4c, 0x01, 0x00, 0x00, 0x4c, 0x2a, 0x00,
+    0x00, 0x4c, 0x53, 0x00, 0x00, 0x4c, 0x78, 0x00, 0x00, 0x4c, 0x9e, 0x00,
+    0x00, 0x4c, 0xc1, 0x00, 0x00, 0x4c, 0xeb, 0x00, 0x00, 0x4d, 0x0f, 0x00,
+    0x00, 0x4d, 0x38, 0x00, 0x00, 0x4d, 0x59, 0x00, 0x00, 0x4d, 0x81, 0x00,
+    0x00, 0x4d, 0xa7, 0x00, 0x00, 0x4d, 0xcd, 0x00, 0x00, 0x4d, 0xfa, 0x00,
+    0x00, 0x4e, 0x24, 0x00, 0x00, 0x4e, 0x49, 0x00, 0x00, 0x4e, 0x70, 0x00,
+    0x00, 0x4e, 0x94, 0x00, 0x00, 0x4e, 0xbd, 0x00, 0x00, 0x4e, 0xe3, 0x00,
+    0x00, 0x4f, 0x06, 0x00, 0x00, 0x4f, 0x2a, 0x00, 0x00, 0x4f, 0x50, 0x00,
+    0x00, 0x4f, 0x75, 0x00, 0x00, 0x4f, 0x9a, 0x00, 0x00, 0x4f, 0xc5, 0x00,
+    0x00, 0x4f, 0xe7, 0x00, 0x00, 0x50, 0x0b, 0x00, 0x00, 0x50, 0x30, 0x00,
+    0x00, 0x50, 0x54, 0x00, 0x00, 0x50, 0x73, 0x00, 0x00, 0x50, 0x9c, 0x00,
+    0x00, 0x50, 0xbe, 0x00, 0x00, 0x50, 0xe5, 0x00, 0x00, 0x51, 0x10, 0x00,
+    0x00, 0x51, 0x39, 0x00, 0x00, 0x51, 0x5e, 0x00, 0x00, 0x51, 0x82, 0x00,
+    0x00, 0x51, 0xa8, 0x00, 0x00, 0x51, 0xce, 0x00, 0x00, 0x51, 0xf1, 0x00,
+    0x00, 0x52, 0x18, 0x00, 0x00, 0x52, 0x3d, 0x00, 0x00, 0x52, 0x64, 0x00,
+    0x00, 0x52, 0x8a, 0x00, 0x00, 0x52, 0xac, 0x00, 0x00, 0x52, 0xd1, 0x00,
+    0x00, 0x52, 0xf7, 0x00, 0x00, 0x53, 0x1e, 0x00, 0x00, 0x53, 0x42, 0x00,
+    0x00, 0x53, 0x6a, 0x00, 0x00, 0x53, 0x93, 0x00, 0x00, 0x53, 0xba, 0x00,
+    0x00, 0x53, 0xe1, 0x00, 0x00, 0x54, 0x07, 0x00, 0x00, 0x54, 0x2d, 0x00,
+    0x00, 0x54, 0x50, 0x00, 0x00, 0x54, 0x7a, 0x00, 0x00, 0x54, 0x9d, 0x00,
+    0x00, 0x54, 0xc5, 0x00, 0x00, 0x54, 0xeb, 0x00, 0x00, 0x55, 0x17, 0x00,
+    0x00, 0x55, 0x3b, 0x00, 0x00, 0x55, 0x64, 0x00, 0x00, 0x55, 0x91, 0x00,
+    0x00, 0x55, 0xb7, 0x00, 0x00, 0x55, 0xda, 0x00, 0x00, 0x56, 0x03, 0x00,
+    0x00, 0x56, 0x2d, 0x00, 0x00, 0x56, 0x52, 0x00, 0x00, 0x56, 0x78, 0x00,
+    0x00, 0x56, 0xa6, 0x00, 0x00, 0x56, 0xcc, 0x00, 0x00, 0x56, 0xf1, 0x00,
+    0x00, 0x57, 0x17, 0x00, 0x00, 0x57, 0x39, 0x00, 0x00, 0x57, 0x60, 0x00,
+    0x00, 0x57, 0x86, 0x00, 0x00, 0x57, 0xab, 0x00, 0x00, 0x57, 0xd3, 0x00,
+    0x00, 0x57, 0xf7, 0x00, 0x00, 0x58, 0x1e, 0x00, 0x00, 0x58, 0x43, 0x00,
+    0x00, 0x58, 0x66, 0x00, 0x00, 0x58, 0x8d, 0x00, 0x00, 0x58, 0xb5, 0x00,
+    0x00, 0x58, 0xdc, 0x00, 0x00, 0x59, 0x03, 0x00, 0x00, 0x59, 0x29, 0x00,
+    0x00, 0x59, 0x4c, 0x00, 0x00, 0x59, 0x6f, 0x00, 0x00, 0x59, 0x95, 0x00,
+    0x00, 0x59, 0xbb, 0x00, 0x00, 0x59, 0xe0, 0x00, 0x00, 0x5a, 0x02, 0x00,
+    0x00, 0x5a, 0x2f, 0x00, 0x00, 0x5a, 0x58, 0x00, 0x00, 0x5a, 0x7a, 0x00,
+    0x00, 0x5a, 0x9f, 0x00, 0x00, 0x5a, 0xc8, 0x00, 0x00, 0x5a, 0xea, 0x00,
+    0x00, 0x5b, 0x10, 0x00, 0x00, 0x5b, 0x34, 0x00, 0x00, 0x5b, 0x57, 0x00,
+    0x00, 0x5b, 0x7b, 0x00, 0x00, 0x5b, 0xa6, 0x00, 0x00, 0x5b, 0xcd, 0x00,
+    0x00, 0x5b, 0xf2, 0x00, 0x00, 0x5c, 0x19, 0x00, 0x00, 0x5c, 0x3d, 0x00,
+    0x00, 0x5c, 0x62, 0x00, 0x00, 0x5c, 0x82, 0x00, 0x00, 0x5c, 0xa4, 0x00,
+    0x00, 0x5c, 0xc8, 0x00, 0x00, 0x5c, 0xed, 0x00, 0x00, 0x5d, 0x13, 0x00,
+    0x00, 0x5d, 0x35, 0x00, 0x00, 0x5d, 0x5b, 0x00, 0x00, 0x5d, 0x81, 0x00,
+    0x00, 0x5d, 0xa4, 0x00, 0x00, 0x5d, 0xc8, 0x00, 0x00, 0x5d, 0xea, 0x00,
+    0x00, 0x5e, 0x0d, 0x00, 0x00, 0x5e, 0x31, 0x00, 0x00, 0x5e, 0x57, 0x00,
+    0x00, 0x5e, 0x7b, 0x00, 0x00, 0x5e, 0xa4, 0x00, 0x00, 0x5e, 0xc9, 0x00,
+    0x00, 0x5e, 0xed, 0x00, 0x00, 0x5f, 0x0d, 0x00, 0x00, 0x5f, 0x32, 0x00,
+    0x00, 0x5f, 0x58, 0x00, 0x00, 0x5f, 0x80, 0x00, 0x00, 0x5f, 0xa3, 0x00,
+    0x00, 0x5f, 0xc7, 0x00, 0x00, 0x5f, 0xf3, 0x00, 0x00, 0x60, 0x19, 0x00,
+    0x00, 0x60, 0x40, 0x00, 0x00, 0x60, 0x63, 0x00, 0x00, 0x60, 0x89, 0x00,
+    0x00, 0x60, 0xae, 0x00, 0x00, 0x60, 0xd0, 0x00, 0x00, 0x60, 0xf4, 0x00,
+    0x00, 0x61, 0x1b, 0x00, 0x00, 0x61, 0x44, 0x00, 0x00, 0x61, 0x6e, 0x00,
+    0x00, 0x61, 0x96, 0x00, 0x00, 0x61, 0xc0, 0x00, 0x00, 0x61, 0xe2, 0x00,
+    0x00, 0x62, 0x08, 0x00, 0x00, 0x62, 0x2b, 0x00, 0x00, 0x62, 0x57, 0x00,
+    0x00, 0x62, 0x87, 0x00, 0x00, 0x62, 0xaa, 0x00, 0x00, 0x62, 0xcf, 0x00,
+    0x00, 0x62, 0xf0, 0x00, 0x00, 0x63, 0x1a, 0x00, 0x00, 0x63, 0x3d, 0x00,
+    0x00, 0x63, 0x62, 0x00, 0x00, 0x63, 0x81, 0x00, 0x00, 0x63, 0xa7, 0x00,
+    0x00, 0x63, 0xd2, 0x00, 0x00, 0x63, 0xf4, 0x00, 0x00, 0x64, 0x14, 0x00,
+    0x00, 0x64, 0x32, 0x00, 0x00, 0x64, 0x59, 0x00, 0x00, 0x64, 0x7e, 0x00,
+    0x00, 0x64, 0xa0, 0x00, 0x00, 0x64, 0xc4, 0x00, 0x00, 0x64, 0xea, 0x00,
+    0x00, 0x65, 0x0e, 0x00, 0x00, 0x65, 0x32, 0x00, 0x00, 0x65, 0x58, 0x00,
+    0x00, 0x65, 0x80, 0x00, 0x00, 0x65, 0xa4, 0x00, 0x00, 0x65, 0xc4, 0x00,
+    0x00, 0x65, 0xe9, 0x00, 0x00, 0x66, 0x0f, 0x00, 0x00, 0x66, 0x35, 0x00,
+    0x00, 0x66, 0x58, 0x00, 0x00, 0x66, 0x7a, 0x00, 0x00, 0x66, 0xa2, 0x00,
+    0x00, 0x66, 0xcb, 0x00, 0x00, 0x66, 0xf1, 0x00, 0x00, 0x67, 0x14, 0x00,
+    0x00, 0x67, 0x39, 0x00, 0x00, 0x67, 0x5d, 0x00, 0x00, 0x67, 0x89, 0x00,
+    0x00, 0x67, 0xb5, 0x00, 0x00, 0x67, 0xd6, 0x00, 0x00, 0x67, 0xfa, 0x00,
+    0x00, 0x68, 0x21, 0x00, 0x00, 0x68, 0x4c, 0x00, 0x00, 0x68, 0x73, 0x00,
+    0x00, 0x68, 0x9a, 0x00, 0x00, 0x68, 0xc1, 0x00, 0x00, 0x68, 0xe5, 0x00,
+    0x00, 0x69, 0x0b, 0x00, 0x00, 0x69, 0x32, 0x00, 0x00, 0x69, 0x57, 0x00,
+    0x00, 0x69, 0x7c, 0x00, 0x00, 0x69, 0x9c, 0x00, 0x00, 0x69, 0xc2, 0x00,
+    0x00, 0x69, 0xee, 0x00, 0x00, 0x6a, 0x17, 0x00, 0x00, 0x6a, 0x43, 0x00,
+    0x00, 0x6a, 0x73, 0x00, 0x00, 0x6a, 0x9c, 0x00, 0x00, 0x6a, 0xc0, 0x00,
+    0x00, 0x6a, 0xe9, 0x00, 0x00, 0x6b, 0x0e, 0x00, 0x00, 0x6b, 0x36, 0x00,
+    0x00, 0x6b, 0x58, 0x00, 0x00, 0x6b, 0x80, 0x00, 0x00, 0x6b, 0xab, 0x00,
+    0x00, 0x6b, 0xd0, 0x00, 0x00, 0x6b, 0xf5, 0x00, 0x00, 0x6c, 0x17, 0x00,
+    0x00, 0x6c, 0x40, 0x00, 0x00, 0x6c, 0x65, 0x00, 0x00, 0x6c, 0x89, 0x00,
+    0x00, 0x6c, 0xad, 0x00, 0x00, 0x6c, 0xd2, 0x00, 0x00, 0x6c, 0xf3, 0x00,
+    0x00, 0x6d, 0x16, 0x00, 0x00, 0x6d, 0x42, 0x00, 0x00, 0x6d, 0x6b, 0x00,
+    0x00, 0x6d, 0x8f, 0x00, 0x00, 0x6d, 0xb3, 0x00, 0x00, 0x6d, 0xe5, 0x00,
+    0x00, 0x6e, 0x08, 0x00, 0x00, 0x6e, 0x32, 0x00, 0x00, 0x6e, 0x5a, 0x00,
+    0x00, 0x6e, 0x84, 0x00, 0x00, 0x6e, 0xad, 0x00, 0x00, 0x6e, 0xcf, 0x00,
+    0x00, 0x6e, 0xf5, 0x00, 0x00, 0x6f, 0x1a, 0x00, 0x00, 0x6f, 0x3e, 0x00,
+    0x00, 0x6f, 0x62, 0x00, 0x00, 0x6f, 0x88, 0x00, 0x00, 0x6f, 0xaf, 0x00,
+    0x00, 0x6f, 0xd6, 0x00, 0x00, 0x6f, 0xfd, 0x00, 0x00, 0x70, 0x28, 0x00,
+    0x00, 0x70, 0x53, 0x00, 0x00, 0x70, 0x7d, 0x00, 0x00, 0x70, 0x9e, 0x00,
+    0x00, 0x70, 0xc5, 0x00, 0x00, 0x70, 0xe9, 0x00, 0x00, 0x71, 0x0c, 0x00,
+    0x00, 0x71, 0x36, 0x00, 0x00, 0x71, 0x5e, 0x00, 0x00, 0x71, 0x83, 0x00,
+    0x00, 0x71, 0xa6, 0x00, 0x00, 0x71, 0xcb, 0x00, 0x00, 0x71, 0xf2, 0x00,
+    0x00, 0x72, 0x16, 0x00, 0x00, 0x72, 0x3f, 0x00, 0x00, 0x72, 0x63, 0x00,
+    0x00, 0x72, 0x91, 0x00, 0x00, 0x72, 0xb4, 0x00, 0x00, 0x72, 0xdd, 0x00,
+    0x00, 0x73, 0x06, 0x00, 0x00, 0x73, 0x29, 0x00, 0x00, 0x73, 0x4f, 0x00,
+    0x00, 0x73, 0x73, 0x00, 0x00, 0x73, 0x99, 0x00, 0x00, 0x73, 0xc6, 0x00,
+    0x00, 0x73, 0xec, 0x00, 0x00, 0x74, 0x0e, 0x00, 0x00, 0x74, 0x34, 0x00,
+    0x00, 0x74, 0x59, 0x00, 0x00, 0x74, 0x7c, 0x00, 0x00, 0x74, 0xa5, 0x00,
+    0x00, 0x74, 0xce, 0x00, 0x00, 0x74, 0xf6, 0x00, 0x00, 0x75, 0x1a, 0x00,
+    0x00, 0x75, 0x45, 0x00, 0x00, 0x75, 0x67, 0x00, 0x00, 0x75, 0x94, 0x00,
+    0x00, 0x75, 0xbd, 0x00, 0x00, 0x75, 0xe1, 0x00, 0x00, 0x76, 0x01, 0x00,
+    0x00, 0x76, 0x2a, 0x00, 0x00, 0x76, 0x4e, 0x00, 0x00, 0x76, 0x79, 0x00,
+    0x00, 0x76, 0x9e, 0x00, 0x00, 0x76, 0xcb, 0x00, 0x00, 0x76, 0xef, 0x00,
+    0x00, 0x77, 0x19, 0x00, 0x00, 0x77, 0x3f, 0x00, 0x00, 0x77, 0x67, 0x00,
+    0x00, 0x77, 0x87, 0x00, 0x00, 0x77, 0xaf, 0x00, 0x00, 0x77, 0xd0, 0x00,
+    0x00, 0x77, 0xf1, 0x00, 0x00, 0x78, 0x16, 0x00, 0x00, 0x78, 0x3f, 0x00,
+    0x00, 0x78, 0x69, 0x00, 0x00, 0x78, 0x96, 0x00, 0x00, 0x78, 0xbc, 0x00,
+    0x00, 0x78, 0xe7, 0x00, 0x00, 0x79, 0x0c, 0x00, 0x00, 0x79, 0x31, 0x00,
+    0x00, 0x79, 0x55, 0x00, 0x00, 0x79, 0x7b, 0x00, 0x00, 0x79, 0xa2, 0x00,
+    0x00, 0x79, 0xc6, 0x00, 0x00, 0x79, 0xed, 0x00, 0x00, 0x7a, 0x12, 0x00,
+    0x00, 0x7a, 0x35, 0x00, 0x00, 0x7a, 0x56, 0x00, 0x00, 0x7a, 0x7b, 0x00,
+    0x00, 0x7a, 0x9d, 0x00, 0x00, 0x7a, 0xc2, 0x00, 0x00, 0x7a, 0xe2, 0x00,
+    0x00, 0x7b, 0x0b, 0x00, 0x00, 0x7b, 0x33, 0x00, 0x00, 0x7b, 0x56, 0x00,
+    0x00, 0x7b, 0x80, 0x00, 0x00, 0x7b, 0xa2, 0x00, 0x00, 0x7b, 0xc3, 0x00,
+    0x00, 0x7b, 0xe8, 0x00, 0x00, 0x7c, 0x0e, 0x00, 0x00, 0x7c, 0x2f, 0x00,
+    0x00, 0x7c, 0x52, 0x00, 0x00, 0x7c, 0x7d, 0x00, 0x00, 0x7c, 0xa0, 0x00,
+    0x00, 0x7c, 0xc5, 0x00, 0x00, 0x7c, 0xe6, 0x00, 0x00, 0x7d, 0x09, 0x00,
+    0x00, 0x7d, 0x30, 0x00, 0x00, 0x7d, 0x5a, 0x00, 0x00, 0x7d, 0x83, 0x00,
+    0x00, 0x7d, 0xa7, 0x00, 0x00, 0x7d, 0xcc, 0x00, 0x00, 0x7d, 0xef, 0x00,
+    0x00, 0x7e, 0x19, 0x00, 0x00, 0x7e, 0x3d, 0x00, 0x00, 0x7e, 0x61, 0x00,
+    0x00, 0x7e, 0x81, 0x00, 0x00, 0x7e, 0xa7, 0x00, 0x00, 0x7e, 0xcc, 0x00,
+    0x00, 0x7e, 0xf1, 0x00, 0x00, 0x7f, 0x18, 0x00, 0x00, 0x7f, 0x3c, 0x00,
+    0x00, 0x7f, 0x65, 0x00, 0x00, 0x7f, 0x8b, 0x00, 0x00, 0x7f, 0xb2, 0x00,
+    0x00, 0x7f, 0xd6, 0x00, 0x00, 0x7f, 0xfa, 0x00, 0x00, 0x80, 0x1a, 0x00,
+    0x00, 0x80, 0x41, 0x00, 0x00, 0x80, 0x65, 0x00, 0x00, 0x80, 0x87, 0x00,
+    0x00, 0x80, 0xae, 0x00, 0x00, 0x80, 0xd9, 0x00, 0x00, 0x81, 0x03, 0x00,
+    0x00, 0x81, 0x29, 0x00, 0x00, 0x81, 0x4e, 0x00, 0x00, 0x81, 0x78, 0x00,
+    0x00, 0x81, 0x9e, 0x00, 0x00, 0x81, 0xc6, 0x00, 0x00, 0x81, 0xee, 0x00,
+    0x00, 0x82, 0x14, 0x00, 0x00, 0x82, 0x3d, 0x00, 0x00, 0x82, 0x5c, 0x00,
+    0x00, 0x82, 0x80, 0x00, 0x00, 0x82, 0xa6, 0x00, 0x00, 0x82, 0xcb, 0x00,
+    0x00, 0x82, 0xf1, 0x00, 0x00, 0x83, 0x17, 0x00, 0x00, 0x83, 0x3d, 0x00,
+    0x00, 0x83, 0x63, 0x00, 0x00, 0x83, 0x87, 0x00, 0x00, 0x83, 0xaf, 0x00,
+    0x00, 0x83, 0xd5, 0x00, 0x00, 0x83, 0xfb, 0x00, 0x00, 0x84, 0x24, 0x00,
+    0x00, 0x84, 0x4b, 0x00, 0x00, 0x84, 0x6d, 0x00, 0x00, 0x84, 0x90, 0x00,
+    0x00, 0x84, 0xbe, 0x00, 0x00, 0x84, 0xe2, 0x00, 0x00, 0x85, 0x06, 0x00,
+    0x00, 0x85, 0x2c, 0x00, 0x00, 0x85, 0x55, 0x00, 0x00, 0x85, 0x79, 0x00,
+    0x00, 0x85, 0xa0, 0x00, 0x00, 0x85, 0xc5, 0x00, 0x00, 0x85, 0xee, 0x00,
+    0x00, 0x86, 0x13, 0x00, 0x00, 0x86, 0x36, 0x00, 0x00, 0x86, 0x55, 0x00,
+    0x00, 0x86, 0x77, 0x00, 0x00, 0x86, 0x9e, 0x00, 0x00, 0x86, 0xcd, 0x00,
+    0x00, 0x86, 0xed, 0x00, 0x00, 0x87, 0x15, 0x00, 0x00, 0x87, 0x42, 0x00,
+    0x00, 0x87, 0x70, 0x00, 0x00, 0x87, 0x92, 0x00, 0x00, 0x87, 0xb9, 0x00,
+    0x00, 0x87, 0xd8, 0x00, 0x00, 0x87, 0xfd, 0x00, 0x00, 0x88, 0x1f, 0x00,
+    0x00, 0x88, 0x48, 0x00, 0x00, 0x88, 0x6c, 0x00, 0x00, 0x88, 0x92, 0x00,
+    0x00, 0x88, 0xbf, 0x00, 0x00, 0x88, 0xe6, 0x00, 0x00, 0x89, 0x0d, 0x00,
+    0x00, 0x89, 0x35, 0x00, 0x00, 0x89, 0x5a, 0x00, 0x00, 0x89, 0x80, 0x00,
+    0x00, 0x89, 0xa4, 0x00, 0x00, 0x89, 0xc7, 0x00, 0x00, 0x89, 0xe9, 0x00,
+    0x00, 0x8a, 0x0e, 0x00, 0x00, 0x8a, 0x35, 0x00, 0x00, 0x8a, 0x5d, 0x00,
+    0x00, 0x8a, 0x84, 0x00, 0x00, 0x8a, 0xaa, 0x00, 0x00, 0x8a, 0xcf, 0x00,
+    0x00, 0x8a, 0xf3, 0x00, 0x00, 0x8b, 0x19, 0x00, 0x00, 0x8b, 0x3e, 0x00,
+    0x00, 0x8b, 0x66, 0x00, 0x00, 0x8b, 0x93, 0x00, 0x00, 0x8b, 0xbe, 0x00,
+    0x00, 0x8b, 0xdf, 0x00, 0x00, 0x8c, 0x05, 0x00, 0x00, 0x8c, 0x2a, 0x00,
+    0x00, 0x8c, 0x4c, 0x00, 0x00, 0x8c, 0x6f, 0x00, 0x00, 0x8c, 0x93, 0x00,
+    0x00, 0x8c, 0xbc, 0x00, 0x00, 0x8c, 0xde, 0x00, 0x00, 0x8d, 0x00, 0x00,
+    0x00, 0x8d, 0x21, 0x00, 0x00, 0x8d, 0x49, 0x00, 0x00, 0x8d, 0x6b, 0x00,
+    0x00, 0x8d, 0x8e, 0x00, 0x00, 0x8d, 0xb5, 0x00, 0x00, 0x8d, 0xd7, 0x00,
+    0x00, 0x8d, 0xff, 0x00, 0x00, 0x8e, 0x28, 0x00, 0x00, 0x8e, 0x4d, 0x00,
+    0x00, 0x8e, 0x75, 0x00, 0x00, 0x8e, 0x9c, 0x00, 0x00, 0x8e, 0xc2, 0x00,
+    0x00, 0x8e, 0xe5, 0x00, 0x00, 0x8f, 0x08, 0x00, 0x00, 0x8f, 0x30, 0x00,
+    0x00, 0x8f, 0x59, 0x00, 0x00, 0x8f, 0x7f, 0x00, 0x00, 0x8f, 0xa3, 0x00,
+    0x00, 0x8f, 0xca, 0x00, 0x00, 0x8f, 0xf3, 0x00, 0x00, 0x90, 0x18, 0x00,
+    0x00, 0x90, 0x46, 0x00, 0x00, 0x90, 0x71, 0x00, 0x00, 0x90, 0x97, 0x00,
+    0x00, 0x90, 0xbc, 0x00, 0x00, 0x90, 0xe1, 0x00, 0x00, 0x91, 0x01, 0x00,
+    0x00, 0x91, 0x2a, 0x00, 0x00, 0x91, 0x53, 0x00, 0x00, 0x91, 0x7e, 0x00,
+    0x00, 0x91, 0xa1, 0x00, 0x00, 0x91, 0xcf, 0x00, 0x00, 0x91, 0xf4, 0x00,
+    0x00, 0x92, 0x17, 0x00, 0x00, 0x92, 0x42, 0x00, 0x00, 0x92, 0x63, 0x00,
+    0x00, 0x92, 0x8f, 0x00, 0x00, 0x92, 0xb4, 0x00, 0x00, 0x92, 0xd7, 0x00,
+    0x00, 0x92, 0xfc, 0x00, 0x00, 0x93, 0x1f, 0x00, 0x00, 0x93, 0x4a, 0x00,
+    0x00, 0x93, 0x72, 0x00, 0x00, 0x93, 0x99, 0x00, 0x00, 0x93, 0xbb, 0x00,
+    0x00, 0x93, 0xe2, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00, 0x94, 0x23, 0x00,
+    0x00, 0x94, 0x49, 0x00, 0x00, 0x94, 0x6b, 0x00, 0x00, 0x94, 0x93, 0x00,
+    0x00, 0x94, 0xb7, 0x00, 0x00, 0x94, 0xe3, 0x00, 0x00, 0x95, 0x08, 0x00,
+    0x00, 0x95, 0x32, 0x00, 0x00, 0x95, 0x55, 0x00, 0x00, 0x95, 0x7a, 0x00,
+    0x00, 0x95, 0xa1, 0x00, 0x00, 0x95, 0xc7, 0x00, 0x00, 0x95, 0xf0, 0x00,
+    0x00, 0x96, 0x10, 0x00, 0x00, 0x96, 0x33, 0x00, 0x00, 0x96, 0x5b, 0x00,
+    0x00, 0x96, 0x80, 0x00, 0x00, 0x96, 0xa6, 0x00, 0x00, 0x96, 0xcd, 0x00,
+    0x00, 0x96, 0xf6, 0x00, 0x00, 0x97, 0x1d, 0x00, 0x00, 0x97, 0x40, 0x00,
+    0x00, 0x97, 0x66, 0x00, 0x00, 0x97, 0x8b, 0x00, 0x00, 0x97, 0xb4, 0x00,
+    0x00, 0x97, 0xd6, 0x00, 0x00, 0x97, 0xff, 0x00, 0x00, 0x98, 0x27, 0x00,
+    0x00, 0x98, 0x50, 0x00, 0x00, 0x98, 0x73, 0x00, 0x00, 0x98, 0x97, 0x00,
+    0x00, 0x98, 0xc0, 0x00, 0x00, 0x98, 0xe0, 0x00, 0x00, 0x99, 0x04, 0x00,
+    0x00, 0x99, 0x2e, 0x00, 0x00, 0x99, 0x51, 0x00, 0x00, 0x99, 0x78, 0x00,
+    0x00, 0x99, 0xa3, 0x00, 0x00, 0x99, 0xcb, 0x00, 0x00, 0x99, 0xf1, 0x00,
+    0x00, 0x9a, 0x1a, 0x00, 0x00, 0x9a, 0x3b, 0x00, 0x00, 0x9a, 0x60, 0x00,
+    0x00, 0x9a, 0x8b, 0x00, 0x00, 0x9a, 0xaf, 0x00, 0x00, 0x9a, 0xd8, 0x00,
+    0x00, 0x9a, 0xfa, 0x00, 0x00, 0x9b, 0x1d, 0x00, 0x00, 0x9b, 0x40, 0x00,
+    0x00, 0x9b, 0x67, 0x00, 0x00, 0x9b, 0x89, 0x00, 0x00, 0x9b, 0xb5, 0x00,
+    0x00, 0x9b, 0xda, 0x00, 0x00, 0x9c, 0x03, 0x00, 0x00, 0x9c, 0x2a, 0x00,
+    0x00, 0x9c, 0x50, 0x00, 0x00, 0x9c, 0x74, 0x00, 0x00, 0x9c, 0x97, 0x00,
+    0x00, 0x9c, 0xbb, 0x00, 0x00, 0x9c, 0xdf, 0x00, 0x00, 0x9d, 0x0b, 0x00,
+    0x00, 0x9d, 0x2e, 0x00, 0x00, 0x9d, 0x56, 0x00, 0x00, 0x9d, 0x7c, 0x00,
+    0x00, 0x9d, 0xa1, 0x00, 0x00, 0x9d, 0xc9, 0x00, 0x00, 0x9d, 0xeb, 0x00,
+    0x00, 0x9e, 0x0f, 0x00, 0x00, 0x9e, 0x34, 0x00, 0x00, 0x9e, 0x5f, 0x00,
+    0x00, 0x9e, 0x8d, 0x00, 0x00, 0x9e, 0xb3, 0x00, 0x00, 0x9e, 0xdc, 0x00,
+    0x00, 0x9f, 0x01, 0x00, 0x00, 0x9f, 0x28, 0x00, 0x00, 0x9f, 0x4f, 0x00,
+    0x00, 0x9f, 0x77, 0x00, 0x00, 0x9f, 0x9b, 0x00, 0x00, 0x9f, 0xbc, 0x00,
+    0x00, 0x9f, 0xe8, 0x00, 0x00, 0xa0, 0x0e, 0x00, 0x00, 0xa0, 0x31, 0x00,
+    0x00, 0xa0, 0x55, 0x00, 0x00, 0xa0, 0x78, 0x00, 0x00, 0xa0, 0xa7, 0x00,
+    0x00, 0xa0, 0xcc, 0x00, 0x00, 0xa0, 0xf1, 0x00, 0x00, 0xa1, 0x19, 0x00,
+    0x00, 0xa1, 0x3c, 0x00, 0x00, 0xa1, 0x5d, 0x00, 0x00, 0xa1, 0x85, 0x00,
+    0x00, 0xa1, 0xac, 0x00, 0x00, 0xa1, 0xd5, 0x00, 0x00, 0xa1, 0xfa, 0x00,
+    0x00, 0xa2, 0x1f, 0x00, 0x00, 0xa2, 0x42, 0x00, 0x00, 0xa2, 0x62, 0x00,
+    0x00, 0xa2, 0x87, 0x00, 0x00, 0xa2, 0xb0, 0x00, 0x00, 0xa2, 0xd7, 0x00,
+    0x00, 0xa2, 0xfe, 0x00, 0x00, 0xa3, 0x25, 0x00, 0x00, 0xa3, 0x4a, 0x00,
+    0x00, 0xa3, 0x6e, 0x00, 0x00, 0xa3, 0x8f, 0x00, 0x00, 0xa3, 0xba, 0x00,
+    0x00, 0xa3, 0xdb, 0x00, 0x00, 0xa4, 0x04, 0x00, 0x00, 0xa4, 0x28, 0x00,
+    0x00, 0xa4, 0x4c, 0x00, 0x00, 0xa4, 0x6e, 0x00, 0x00, 0xa4, 0x97, 0x00,
+    0x00, 0xa4, 0xbe, 0x00, 0x00, 0xa4, 0xe7, 0x00, 0x00, 0xa5, 0x11, 0x00,
+    0x00, 0xa5, 0x35, 0x00, 0x00, 0xa5, 0x61, 0x00, 0x00, 0xa5, 0x84, 0x00,
+    0x00, 0xa5, 0xa4, 0x00, 0x00, 0xa5, 0xca, 0x00, 0x00, 0xa5, 0xf2, 0x00,
+    0x00, 0xa6, 0x16, 0x00, 0x00, 0xa6, 0x3b, 0x00, 0x00, 0xa6, 0x60, 0x00,
+    0x00, 0xa6, 0x82, 0x00, 0x00, 0xa6, 0xa6, 0x00, 0x00, 0xa6, 0xcb, 0x00,
+    0x00, 0xa6, 0xf2, 0x00, 0x00, 0xa7, 0x1d, 0x00, 0x00, 0xa7, 0x4a, 0x00,
+    0x00, 0xa7, 0x71, 0x00, 0x00, 0xa7, 0x93, 0x00, 0x00, 0xa7, 0xb7, 0x00,
+    0x00, 0xa7, 0xd8, 0x00, 0x00, 0xa8, 0x02, 0x00, 0x00, 0xa8, 0x25, 0x00,
+    0x00, 0xa8, 0x4b, 0x00, 0x00, 0xa8, 0x6e, 0x00, 0x00, 0xa8, 0x92, 0x00,
+    0x00, 0xa8, 0xb6, 0x00, 0x00, 0xa8, 0xde, 0x00, 0x00, 0xa9, 0x05, 0x00,
+    0x00, 0xa9, 0x26, 0x00, 0x00, 0xa9, 0x50, 0x00, 0x00, 0xa9, 0x75, 0x00,
+    0x00, 0xa9, 0x99, 0x00, 0x00, 0xa9, 0xbe, 0x00, 0x00, 0xa9, 0xe2, 0x00,
+    0x00, 0xaa, 0x07, 0x00, 0x00, 0xaa, 0x2e, 0x00, 0x00, 0xaa, 0x50, 0x00,
+    0x00, 0xaa, 0x77, 0x00, 0x00, 0xaa, 0x9b, 0x00, 0x00, 0xaa, 0xc0, 0x00,
+    0x00, 0xaa, 0xe5, 0x00, 0x00, 0xab, 0x08, 0x00, 0x00, 0xab, 0x37, 0x00,
+    0x00, 0xab, 0x5b, 0x00, 0x00, 0xab, 0x86, 0x00, 0x00, 0xab, 0xa7, 0x00,
+    0x00, 0xab, 0xd6, 0x00, 0x00, 0xab, 0xfc, 0x00, 0x00, 0xac, 0x1c, 0x00,
+    0x00, 0xac, 0x3c, 0x00, 0x00, 0xac, 0x5e, 0x00, 0x00, 0xac, 0x85, 0x00,
+    0x00, 0xac, 0xac, 0x00, 0x00, 0xac, 0xd1, 0x00, 0x00, 0xac, 0xf6, 0x00,
+    0x00, 0xad, 0x20, 0x00, 0x00, 0xad, 0x40, 0x00, 0x00, 0xad, 0x64, 0x00,
+    0x00, 0xad, 0x89, 0x00, 0x00, 0xad, 0xae, 0x00, 0x00, 0xad, 0xd4, 0x00,
+    0x00, 0xad, 0xfa, 0x00, 0x00, 0xae, 0x22, 0x00, 0x00, 0xae, 0x47, 0x00,
+    0x00, 0xae, 0x6c, 0x00, 0x00, 0xae, 0x9a, 0x00, 0x00, 0xae, 0xc2, 0x00,
+    0x00, 0xae, 0xea, 0x00, 0x00, 0xaf, 0x0e, 0x00, 0x00, 0xaf, 0x33, 0x00,
+    0x00, 0xaf, 0x5f, 0x00, 0x00, 0xaf, 0x89, 0x00, 0x00, 0xaf, 0xb6, 0x00,
+    0x00, 0xaf, 0xd9, 0x00, 0x00, 0xaf, 0xf8, 0x00, 0x00, 0xb0, 0x1b, 0x00,
+    0x00, 0xb0, 0x47, 0x00, 0x00, 0xb0, 0x6c, 0x00, 0x00, 0xb0, 0x8b, 0x00,
+    0x00, 0xb0, 0xb0, 0x00, 0x00, 0xb0, 0xde, 0x00, 0x00, 0xb1, 0x03, 0x00,
+    0x00, 0xb1, 0x2f, 0x00, 0x00, 0xb1, 0x50, 0x00, 0x00, 0xb1, 0x7a, 0x00,
+    0x00, 0xb1, 0xa1, 0x00, 0x00, 0xb1, 0xca, 0x00, 0x00, 0xb1, 0xee, 0x00,
+    0x00, 0xb2, 0x10, 0x00, 0x00, 0xb2, 0x35, 0x00, 0x00, 0xb2, 0x5a, 0x00,
+    0x00, 0xb2, 0x82, 0x00, 0x00, 0xb2, 0xa6, 0x00, 0x00, 0xb2, 0xd0, 0x00,
+    0x00, 0xb2, 0xf9, 0x00, 0x00, 0xb3, 0x1c, 0x00, 0x00, 0xb3, 0x42, 0x00,
+    0x00, 0xb3, 0x67, 0x00, 0x00, 0xb3, 0x8a, 0x00, 0x00, 0xb3, 0xb3, 0x00,
+    0x00, 0xb3, 0xe2, 0x00, 0x00, 0xb4, 0x08, 0x00, 0x00, 0xb4, 0x2c, 0x00,
+    0x00, 0xb4, 0x4f, 0x00, 0x00, 0xb4, 0x77, 0x00, 0x00, 0xb4, 0xa2, 0x00,
+    0x00, 0xb4, 0xc6, 0x00, 0x00, 0xb4, 0xf5, 0x00, 0x00, 0xb5, 0x1c, 0x00,
+    0x00, 0xb5, 0x44, 0x00, 0x00, 0xb5, 0x6b, 0x00, 0x00, 0xb5, 0x95, 0x00,
+    0x00, 0xb5, 0xba, 0x00, 0x00, 0xb5, 0xde, 0x00, 0x00, 0xb6, 0x06, 0x00,
+    0x00, 0xb6, 0x2d, 0x00, 0x00, 0xb6, 0x52, 0x00, 0x00, 0xb6, 0x7e, 0x00,
+    0x00, 0xb6, 0xa3, 0x00, 0x00, 0xb6, 0xcb, 0x00, 0x00, 0xb6, 0xf1, 0x00,
+    0x00, 0xb7, 0x1d, 0x00, 0x00, 0xb7, 0x42, 0x00, 0x00, 0xb7, 0x67, 0x00,
+    0x00, 0xb7, 0x8e, 0x00, 0x00, 0xb7, 0xbf, 0x00, 0x00, 0xb7, 0xe5, 0x00,
+    0x00, 0xb8, 0x0a, 0x00, 0x00, 0xb8, 0x30, 0x00, 0x00, 0xb8, 0x57, 0x00,
+    0x00, 0xb8, 0x7b, 0x00, 0x00, 0xb8, 0x9d, 0x00, 0x00, 0xb8, 0xc1, 0x00,
+    0x00, 0xb8, 0xe2, 0x00, 0x00, 0xb9, 0x07, 0x00, 0x00, 0xb9, 0x2c, 0x00,
+    0x00, 0xb9, 0x53, 0x00, 0x00, 0xb9, 0x77, 0x00, 0x00, 0xb9, 0x9b, 0x00,
+    0x00, 0xb9, 0xc1, 0x00, 0x00, 0xb9, 0xe8, 0x00, 0x00, 0xba, 0x10, 0x00,
+    0x00, 0xba, 0x30, 0x00, 0x00, 0xba, 0x55, 0x00, 0x00, 0xba, 0x7c, 0x00,
+    0x00, 0xba, 0xa4, 0x00, 0x00, 0xba, 0xc8, 0x00, 0x00, 0xba, 0xea, 0x00,
+    0x00, 0xbb, 0x0e, 0x00, 0x00, 0xbb, 0x30, 0x00, 0x00, 0xbb, 0x57, 0x00,
+    0x00, 0xbb, 0x7a, 0x00, 0x00, 0xbb, 0x9f, 0x00, 0x00, 0xbb, 0xc4, 0x00,
+    0x00, 0xbb, 0xe9, 0x00, 0x00, 0xbc, 0x0d, 0x00, 0x00, 0xbc, 0x2e, 0x00,
+    0x00, 0xbc, 0x52, 0x00, 0x00, 0xbc, 0x78, 0x00, 0x00, 0xbc, 0xa0, 0x00,
+    0x00, 0xbc, 0xc0, 0x00, 0x00, 0xbc, 0xe4, 0x00, 0x00, 0xbd, 0x0d, 0x00,
+    0x00, 0xbd, 0x2f, 0x00, 0x00, 0xbd, 0x4f, 0x00, 0x00, 0xbd, 0x75, 0x00,
+    0x00, 0xbd, 0x9d, 0x00, 0x00, 0xbd, 0xbf, 0x00, 0x00, 0xbd, 0xe3, 0x00,
+    0x00, 0xbe, 0x04, 0x00, 0x00, 0xbe, 0x29, 0x00, 0x00, 0xbe, 0x51, 0x00,
+    0x00, 0xbe, 0x77, 0x00, 0x00, 0xbe, 0x9e, 0x00, 0x00, 0xbe, 0xc4, 0x00,
+    0x00, 0xbe, 0xf2, 0x00, 0x00, 0xbf, 0x1c, 0x00, 0x00, 0xbf, 0x44, 0x00,
+    0x00, 0xbf, 0x68, 0x00, 0x00, 0xbf, 0x8e, 0x00, 0x00, 0xbf, 0xb8, 0x00,
+    0x00, 0xbf, 0xe6, 0x00, 0x00, 0xc0, 0x0b, 0x00, 0x00, 0xc0, 0x2d, 0x00,
+    0x00, 0xc0, 0x54, 0x00, 0x00, 0xc0, 0x7a, 0x00, 0x00, 0xc0, 0xa1, 0x00,
+    0x00, 0xc0, 0xc7, 0x00, 0x00, 0xc0, 0xeb, 0x00, 0x00, 0xc1, 0x0f, 0x00,
+    0x00, 0xc1, 0x33, 0x00, 0x00, 0xc1, 0x62, 0x00, 0x00, 0xc1, 0x8e, 0x00,
+    0x00, 0xc1, 0xae, 0x00, 0x00, 0xc1, 0xd0, 0x00, 0x00, 0xc1, 0xf6, 0x00,
+    0x00, 0xc2, 0x17, 0x00, 0x00, 0xc2, 0x3d, 0x00, 0x00, 0xc2, 0x61, 0x00,
+    0x00, 0xc2, 0x88, 0x00, 0x00, 0xc2, 0xae, 0x00, 0x00, 0xc2, 0xd9, 0x00,
+    0x00, 0xc2, 0xfd, 0x00, 0x00, 0xc3, 0x1f, 0x00, 0x00, 0xc3, 0x44, 0x00,
+    0x00, 0xc3, 0x65, 0x00, 0x00, 0xc3, 0x90, 0x00, 0x00, 0xc3, 0xb3, 0x00,
+    0x00, 0xc3, 0xd5, 0x00, 0x00, 0xc3, 0xfa, 0x00, 0x00, 0xc4, 0x21, 0x00,
+    0x00, 0xc4, 0x40, 0x00, 0x00, 0xc4, 0x62, 0x00, 0x00, 0xc4, 0x8c, 0x00,
+    0x00, 0xc4, 0xb2, 0x00, 0x00, 0xc4, 0xdc, 0x00, 0x00, 0xc5, 0x04, 0x00,
+    0x00, 0xc5, 0x28, 0x00, 0x00, 0xc5, 0x4c, 0x00, 0x00, 0xc5, 0x75, 0x00,
+    0x00, 0xc5, 0xa3, 0x00, 0x00, 0xc5, 0xc7, 0x00, 0x00, 0xc5, 0xee, 0x00,
+    0x00, 0xc6, 0x0e, 0x00, 0x00, 0xc6, 0x32, 0x00, 0x00, 0xc6, 0x57, 0x00,
+    0x00, 0xc6, 0x82, 0x00, 0x00, 0xc6, 0xad, 0x00, 0x00, 0xc6, 0xd6, 0x00,
+    0x00, 0xc6, 0xf8, 0x00, 0x00, 0xc7, 0x1b, 0x00, 0x00, 0xc7, 0x3f, 0x00,
+    0x00, 0xc7, 0x62, 0x00, 0x00, 0xc7, 0x88, 0x00, 0x00, 0xc7, 0xb3, 0x00,
+    0x00, 0xc7, 0xd8, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, 0xc8, 0x2a, 0x00,
+    0x00, 0xc8, 0x51, 0x00, 0x00, 0xc8, 0x74, 0x00, 0x00, 0xc8, 0x9e, 0x00,
+    0x00, 0xc8, 0xc2, 0x00, 0x00, 0xc8, 0xe4, 0x00, 0x00, 0xc9, 0x0a, 0x00,
+    0x00, 0xc9, 0x34, 0x00, 0x00, 0xc9, 0x57, 0x00, 0x00, 0xc9, 0x7c, 0x00,
+    0x00, 0xc9, 0xa1, 0x00, 0x00, 0xc9, 0xc7, 0x00, 0x00, 0xc9, 0xeb, 0x00,
+    0x00, 0xca, 0x16, 0x00, 0x00, 0xca, 0x3f, 0x00, 0x00, 0xca, 0x68, 0x00,
+    0x00, 0xca, 0x8f, 0x00, 0x00, 0xca, 0xb4, 0x00, 0x00, 0xca, 0xd6, 0x00,
+    0x00, 0xca, 0xf9, 0x00, 0x00, 0xcb, 0x1c, 0x00, 0x00, 0xcb, 0x47, 0x00,
+    0x00, 0xcb, 0x6e, 0x00, 0x00, 0xcb, 0x8e, 0x00, 0x00, 0xcb, 0xb4, 0x00,
+    0x00, 0xcb, 0xd8, 0x00, 0x00, 0xcc, 0x04, 0x00, 0x00, 0xcc, 0x2b, 0x00,
+    0x00, 0xcc, 0x51, 0x00, 0x00, 0xcc, 0x76, 0x00, 0x00, 0xcc, 0x9f, 0x00,
+    0x00, 0xcc, 0xc7, 0x00, 0x00, 0xcc, 0xeb, 0x00, 0x00, 0xcd, 0x0b, 0x00,
+    0x00, 0xcd, 0x32, 0x00, 0x00, 0xcd, 0x57, 0x00, 0x00, 0xcd, 0x7f, 0x00,
+    0x00, 0xcd, 0xa3, 0x00, 0x00, 0xcd, 0xc8, 0x00, 0x00, 0xcd, 0xed, 0x00,
+    0x00, 0xce, 0x13, 0x00, 0x00, 0xce, 0x38, 0x00, 0x00, 0xce, 0x68, 0x00,
+    0x00, 0xce, 0x8c, 0x00, 0x00, 0xce, 0xb2, 0x00, 0x00, 0xce, 0xd6, 0x00,
+    0x00, 0xce, 0xfe, 0x00, 0x00, 0xcf, 0x28, 0x00, 0x00, 0xcf, 0x49, 0x00,
+    0x00, 0xcf, 0x6e, 0x00, 0x00, 0xcf, 0x90, 0x00, 0x00, 0xcf, 0xb6, 0x00,
+    0x00, 0xcf, 0xdb, 0x00, 0x00, 0xd0, 0x04, 0x00, 0x00, 0xd0, 0x30, 0x00,
+    0x00, 0xd0, 0x55, 0x00, 0x00, 0xd0, 0x7a, 0x00, 0x00, 0xd0, 0xa1, 0x00,
+    0x00, 0xd0, 0xc6, 0x00, 0x00, 0xd0, 0xeb, 0x00, 0x00, 0xd1, 0x0f, 0x00,
+    0x00, 0xd1, 0x33, 0x00, 0x00, 0xd1, 0x56, 0x00, 0x00, 0xd1, 0x7f, 0x00,
+    0x00, 0xd1, 0xaa, 0x00, 0x00, 0xd1, 0xcf, 0x00, 0x00, 0xd1, 0xf2, 0x00,
+    0x00, 0xd2, 0x19, 0x00, 0x00, 0xd2, 0x46, 0x00, 0x00, 0xd2, 0x6a, 0x00,
+    0x00, 0xd2, 0x97, 0x00, 0x00, 0xd2, 0xb8, 0x00, 0x00, 0xd2, 0xdd, 0x00,
+    0x00, 0xd3, 0x00, 0x00, 0x00, 0xd3, 0x23, 0x00, 0x00, 0xd3, 0x4e, 0x00,
+    0x00, 0xd3, 0x74, 0x00, 0x00, 0xd3, 0x9b, 0x00, 0x00, 0xd3, 0xbf, 0x00,
+    0x00, 0xd3, 0xe6, 0x00, 0x00, 0xd4, 0x10, 0x00, 0x00, 0xd4, 0x38, 0x00,
+    0x00, 0xd4, 0x5e, 0x00, 0x00, 0xd4, 0x87, 0x00, 0x00, 0xd4, 0xab, 0x00,
+    0x00, 0xd4, 0xd8, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00, 0xd5, 0x25, 0x00,
+    0x00, 0xd5, 0x4c, 0x00, 0x00, 0xd5, 0x72, 0x00, 0x00, 0xd5, 0x97, 0x00,
+    0x00, 0xd5, 0xc1, 0x00, 0x00, 0xd5, 0xe3, 0x00, 0x00, 0xd6, 0x06, 0x00,
+    0x00, 0xd6, 0x29, 0x00, 0x00, 0xd6, 0x4b, 0x00, 0x00, 0xd6, 0x70, 0x00,
+    0x00, 0xd6, 0x92, 0x00, 0x00, 0xd6, 0xb8, 0x00, 0x00, 0xd6, 0xdc, 0x00,
+    0x00, 0xd6, 0xfc, 0x00, 0x00, 0xd7, 0x29, 0x00, 0x00, 0xd7, 0x4c, 0x00,
+    0x00, 0xd7, 0x6f, 0x00, 0x00, 0xd7, 0x92, 0x00, 0x00, 0xd7, 0xb7, 0x00,
+    0x00, 0xd7, 0xdb, 0x00, 0x00, 0xd7, 0xfe, 0x00, 0x00, 0xd8, 0x24, 0x00,
+    0x00, 0xd8, 0x48, 0x00, 0x00, 0xd8, 0x69, 0x00, 0x00, 0xd8, 0x96, 0x00,
+    0x00, 0xd8, 0xb9, 0x00, 0x00, 0xd8, 0xdf, 0x00, 0x00, 0xd9, 0x03, 0x00,
+    0x00, 0xd9, 0x25, 0x00, 0x00, 0xd9, 0x49, 0x00, 0x00, 0xd9, 0x6d, 0x00,
+    0x00, 0xd9, 0x92, 0x00, 0x00, 0xd9, 0xb9, 0x00, 0x00, 0xd9, 0xde, 0x00,
+    0x00, 0xda, 0x05, 0x00, 0x00, 0xda, 0x2f, 0x00, 0x00, 0xda, 0x54, 0x00,
+    0x00, 0xda, 0x78, 0x00, 0x00, 0xda, 0x9e, 0x00, 0x00, 0xda, 0xc9, 0x00,
+    0x00, 0xda, 0xef, 0x00, 0x00, 0xdb, 0x19, 0x00, 0x00, 0xdb, 0x3e, 0x00,
+    0x00, 0xdb, 0x6c, 0x00, 0x00, 0xdb, 0x8a, 0x00, 0x00, 0xdb, 0xb4, 0x00,
+    0x00, 0xdb, 0xd8, 0x00, 0x00, 0xdb, 0xff, 0x00, 0x00, 0xdc, 0x24, 0x00,
+    0x00, 0xdc, 0x4a, 0x00, 0x00, 0xdc, 0x73, 0x00, 0x00, 0xdc, 0xa0, 0x00,
+    0x00, 0xdc, 0xc6, 0x00, 0x00, 0xdc, 0xeb, 0x00, 0x00, 0xdd, 0x11, 0x00,
+    0x00, 0xdd, 0x3b, 0x00, 0x00, 0xdd, 0x67, 0x00, 0x00, 0xdd, 0x8e, 0x00,
+    0x00, 0xdd, 0xb3, 0x00, 0x00, 0xdd, 0xdf, 0x00, 0x00, 0xde, 0x09, 0x00,
+    0x00, 0xde, 0x31, 0x00, 0x00, 0xde, 0x55, 0x00, 0x00, 0xde, 0x77, 0x00,
+    0x00, 0xde, 0xa1, 0x00, 0x00, 0xde, 0xc7, 0x00, 0x00, 0xde, 0xed, 0x00,
+    0x00, 0xdf, 0x15, 0x00, 0x00, 0xdf, 0x42, 0x00, 0x00, 0xdf, 0x6a, 0x00,
+    0x00, 0xdf, 0x90, 0x00, 0x00, 0xdf, 0xb4, 0x00, 0x00, 0xdf, 0xd7, 0x00,
+    0x00, 0xdf, 0xf8, 0x00, 0x00, 0xe0, 0x1b, 0x00, 0x00, 0xe0, 0x42, 0x00,
+    0x00, 0xe0, 0x69, 0x00, 0x00, 0xe0, 0x8e, 0x00, 0x00, 0xe0, 0xb4, 0x00,
+    0x00, 0xe0, 0xdd, 0x00, 0x00, 0xe0, 0xfe, 0x00, 0x00, 0xe1, 0x24, 0x00,
+    0x00, 0xe1, 0x51, 0x00, 0x00, 0xe1, 0x79, 0x00, 0x00, 0xe1, 0xa0, 0x00,
+    0x00, 0xe1, 0xc1, 0x00, 0x00, 0xe1, 0xe6, 0x00, 0x00, 0xe2, 0x0f, 0x00,
+    0x00, 0xe2, 0x30, 0x00, 0x00, 0xe2, 0x55, 0x00, 0x00, 0xe2, 0x78, 0x00,
+    0x00, 0xe2, 0xa7, 0x00, 0x00, 0xe2, 0xcc, 0x00, 0x00, 0xe2, 0xf3, 0x00,
+    0x00, 0xe3, 0x18, 0x00, 0x00, 0xe3, 0x43, 0x00, 0x00, 0xe3, 0x6d, 0x00,
+    0x00, 0xe3, 0x90, 0x00, 0x00, 0xe3, 0xbd, 0x00, 0x00, 0xe3, 0xe5, 0x00,
+    0x00, 0xe4, 0x0f, 0x00, 0x00, 0xe4, 0x33, 0x00, 0x00, 0xe4, 0x5b, 0x00,
+    0x00, 0xe4, 0x84, 0x00, 0x00, 0xe4, 0xaa, 0x00, 0x00, 0xe4, 0xd0, 0x00,
+    0x00, 0xe4, 0xf7, 0x00, 0x00, 0xe5, 0x1b, 0x00, 0x00, 0xe5, 0x42, 0x00,
+    0x00, 0xe5, 0x6b, 0x00, 0x00, 0xe5, 0x90, 0x00, 0x00, 0xe5, 0xb8, 0x00,
+    0x00, 0xe5, 0xdc, 0x00, 0x00, 0xe6, 0x02, 0x00, 0x00, 0xe6, 0x28, 0x00,
+    0x00, 0xe6, 0x51, 0x00, 0x00, 0xe6, 0x74, 0x00, 0x00, 0xe6, 0x9b, 0x00,
+    0x00, 0xe6, 0xc6, 0x00, 0x00, 0xe6, 0xe9, 0x00, 0x00, 0xe7, 0x11, 0x00,
+    0x00, 0xe7, 0x39, 0x00, 0x00, 0xe7, 0x5d, 0x00, 0x00, 0xe7, 0x7f, 0x00,
+    0x00, 0xe7, 0xa3, 0x00, 0x00, 0xe7, 0xc8, 0x00, 0x00, 0xe7, 0xf6, 0x00,
+    0x00, 0xe8, 0x1a, 0x00, 0x00, 0xe8, 0x42, 0x00, 0x00, 0xe8, 0x66, 0x00,
+    0x00, 0xe8, 0x8b, 0x00, 0x00, 0xe8, 0xb4, 0x00, 0x00, 0xe8, 0xd5, 0x00,
+    0x00, 0xe8, 0xf7, 0x00, 0x00, 0xe9, 0x1e, 0x00, 0x00, 0xe9, 0x47, 0x00,
+    0x00, 0xe9, 0x69, 0x00, 0x00, 0xe9, 0x8f, 0x00, 0x00, 0xe9, 0xb8, 0x00,
+    0x00, 0xe9, 0xda, 0x00, 0x00, 0xe9, 0xfe, 0x00, 0x00, 0xea, 0x26, 0x00,
+    0x00, 0xea, 0x4a, 0x00, 0x00, 0xea, 0x72, 0x00, 0x00, 0xea, 0x9e, 0x00,
+    0x00, 0xea, 0xc8, 0x00, 0x00, 0xea, 0xeb, 0x00, 0x00, 0xeb, 0x12, 0x00,
+    0x00, 0xeb, 0x35, 0x00, 0x00, 0xeb, 0x5e, 0x00, 0x00, 0xeb, 0x83, 0x00,
+    0x00, 0xeb, 0xa9, 0x00, 0x00, 0xeb, 0xca, 0x00, 0x00, 0xeb, 0xea, 0x00,
+    0x00, 0xec, 0x10, 0x00, 0x00, 0xec, 0x33, 0x00, 0x00, 0xec, 0x58, 0x00,
+    0x00, 0xec, 0x7b, 0x00, 0x00, 0xec, 0xa3, 0x00, 0x00, 0xec, 0xc9, 0x00,
+    0x00, 0xec, 0xed, 0x00, 0x00, 0xed, 0x12, 0x00, 0x00, 0xed, 0x39, 0x00,
+    0x00, 0xed, 0x5e, 0x00, 0x00, 0xed, 0x7f, 0x00, 0x00, 0xed, 0xa3, 0x00,
+    0x00, 0xed, 0xc7, 0x00, 0x00, 0xed, 0xef, 0x00, 0x00, 0xee, 0x14, 0x00,
+    0x00, 0xee, 0x3d, 0x00, 0x00, 0xee, 0x63, 0x00, 0x00, 0xee, 0x8c, 0x00,
+    0x00, 0xee, 0xb0, 0x00, 0x00, 0xee, 0xd4, 0x00, 0x00, 0xee, 0xfa, 0x00,
+    0x00, 0xef, 0x21, 0x00, 0x00, 0xef, 0x4a, 0x00, 0x00, 0xef, 0x6a, 0x00,
+    0x00, 0xef, 0x8d, 0x00, 0x00, 0xef, 0xb2, 0x00, 0x00, 0xef, 0xd4, 0x00,
+    0x00, 0xef, 0xf5, 0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00, 0xf0, 0x43, 0x00,
+    0x00, 0xf0, 0x69, 0x00, 0x00, 0xf0, 0x89, 0x00, 0x00, 0xf0, 0xad, 0x00,
+    0x00, 0xf0, 0xd1, 0x00, 0x00, 0xf0, 0xfe, 0x00, 0x00, 0xf1, 0x23, 0x00,
+    0x00, 0xf1, 0x47, 0x00, 0x00, 0xf1, 0x69, 0x00, 0x00, 0xf1, 0x94, 0x00,
+    0x00, 0xf1, 0xbb, 0x00, 0x00, 0xf1, 0xe1, 0x00, 0x00, 0xf2, 0x05, 0x00,
+    0x00, 0xf2, 0x2a, 0x00, 0x00, 0xf2, 0x51, 0x00, 0x00, 0xf2, 0x7c, 0x00,
+    0x00, 0xf2, 0xa6, 0x00, 0x00, 0xf2, 0xc8, 0x00, 0x00, 0xf2, 0xed, 0x00,
+    0x00, 0xf3, 0x12, 0x00, 0x00, 0xf3, 0x33, 0x00, 0x00, 0xf3, 0x59, 0x00,
+    0x00, 0xf3, 0x7d, 0x00, 0x00, 0xf3, 0xa3, 0x00, 0x00, 0xf3, 0xc4, 0x00,
+    0x00, 0xf3, 0xe8, 0x00, 0x00, 0xf4, 0x13, 0x00, 0x00, 0xf4, 0x34, 0x00,
+    0x00, 0xf4, 0x59, 0x00, 0x00, 0xf4, 0x79, 0x00, 0x00, 0xf4, 0xa4, 0x00,
+    0x00, 0xf4, 0xcb, 0x00, 0x00, 0xf4, 0xec, 0x00, 0x00, 0xf5, 0x10, 0x00,
+    0x00, 0xf5, 0x35, 0x00, 0x00, 0xf5, 0x5d, 0x00, 0x00, 0xf5, 0x80, 0x00,
+    0x00, 0xf5, 0xa5, 0x00, 0x00, 0xf5, 0xce, 0x00, 0x00, 0xf5, 0xf3, 0x00,
+    0x00, 0xf6, 0x18, 0x00, 0x00, 0xf6, 0x3c, 0x00, 0x00, 0xf6, 0x60, 0x00,
+    0x00, 0xf6, 0x84, 0x00, 0x00, 0xf6, 0xac, 0x00, 0x00, 0xf6, 0xd0, 0x00,
+    0x00, 0xf6, 0xf6, 0x00, 0x00, 0xf7, 0x1f, 0x00, 0x00, 0xf7, 0x40, 0x00,
+    0x00, 0xf7, 0x69, 0x00, 0x00, 0xf7, 0x8c, 0x00, 0x00, 0xf7, 0xb0, 0x00,
+    0x00, 0xf7, 0xd5, 0x00, 0x00, 0xf7, 0xfa, 0x00, 0x00, 0xf8, 0x1f, 0x00,
+    0x00, 0xf8, 0x4c, 0x00, 0x00, 0xf8, 0x72, 0x00, 0x00, 0xf8, 0x96, 0x00,
+    0x00, 0xf8, 0xc1, 0x00, 0x00, 0xf8, 0xe1, 0x00, 0x00, 0xf9, 0x0c, 0x00,
+    0x00, 0xf9, 0x31, 0x00, 0x00, 0xf9, 0x5f, 0x00, 0x00, 0xf9, 0x86, 0x00,
+    0x00, 0xf9, 0xa9, 0x00, 0x00, 0xf9, 0xd3, 0x00, 0x00, 0xf9, 0xf3, 0x00,
+    0x00, 0xfa, 0x17, 0x00, 0x00, 0xfa, 0x3b, 0x00, 0x00, 0xfa, 0x5e, 0x00,
+    0x00, 0xfa, 0x82, 0x00, 0x00, 0xfa, 0xa5, 0x00, 0x00, 0xfa, 0xc8, 0x00,
+    0x00, 0xfa, 0xec, 0x00, 0x00, 0xfb, 0x10, 0x00, 0x00, 0xfb, 0x38, 0x00,
+    0x00, 0xfb, 0x61, 0x00, 0x00, 0xfb, 0x85, 0x00, 0x00, 0xfb, 0xa8, 0x00,
+    0x00, 0xfb, 0xd0, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x27, 0x00,
+    0x00, 0xfc, 0x4d, 0x00, 0x00, 0xfc, 0x72, 0x00, 0x00, 0xfc, 0x9b, 0x00,
+    0x00, 0xfc, 0xca, 0x00, 0x00, 0xfc, 0xee, 0x00, 0x00, 0xfd, 0x12, 0x00,
+    0x00, 0xfd, 0x43, 0x00, 0x00, 0xfd, 0x65, 0x00, 0x00, 0xfd, 0x8c, 0x00,
+    0x00, 0xfd, 0xb6, 0x00, 0x00, 0xfd, 0xdf, 0x00, 0x00, 0xfe, 0x02, 0x00,
+    0x00, 0xfe, 0x25, 0x00, 0x00, 0xfe, 0x47, 0x00, 0x00, 0xfe, 0x78, 0x00,
+    0x00, 0xfe, 0xa2, 0x00, 0x00, 0xfe, 0xc2, 0x00, 0x00, 0xfe, 0xef, 0x00,
+    0x00, 0xff, 0x15, 0x00, 0x00, 0xff, 0x3c, 0x00, 0x00, 0xff, 0x5d, 0x00,
+    0x00, 0xff, 0x87, 0x00, 0x00, 0xff, 0xac, 0x00, 0x00, 0xff, 0xd0, 0x00,
+    0x00, 0xff, 0xf5, 0x00, 0x01, 0x00, 0x1a, 0x00, 0x01, 0x00, 0x3b, 0x00,
+    0x01, 0x00, 0x63, 0x00, 0x01, 0x00, 0x88, 0x00, 0x01, 0x00, 0xb3, 0x00,
+    0x01, 0x00, 0xde, 0x00, 0x01, 0x01, 0x07, 0x00, 0x01, 0x01, 0x2b, 0x00,
+    0x01, 0x01, 0x53, 0x00, 0x01, 0x01, 0x78, 0x00, 0x01, 0x01, 0x9d, 0x00,
+    0x01, 0x01, 0xc5, 0x00, 0x01, 0x01, 0xe7, 0x00, 0x01, 0x02, 0x08, 0x00,
+    0x01, 0x02, 0x36, 0x00, 0x01, 0x02, 0x59, 0x00, 0x01, 0x02, 0x83, 0x00,
+    0x01, 0x02, 0xa6, 0x00, 0x01, 0x02, 0xce, 0x00, 0x01, 0x02, 0xf4, 0x00,
+    0x01, 0x03, 0x20, 0x00, 0x01, 0x03, 0x42, 0x00, 0x01, 0x03, 0x67, 0x00,
+    0x01, 0x03, 0x96, 0x00, 0x01, 0x03, 0xbb, 0x00, 0x01, 0x03, 0xdf, 0x00,
+    0x01, 0x04, 0x02, 0x00, 0x01, 0x04, 0x2a, 0x00, 0x01, 0x04, 0x53, 0x00,
+    0x01, 0x04, 0x7a, 0x00, 0x01, 0x04, 0x9b, 0x00, 0x01, 0x04, 0xbb, 0x00,
+    0x01, 0x04, 0xde, 0x00, 0x01, 0x05, 0x02, 0x00, 0x01, 0x05, 0x28, 0x00,
+    0x01, 0x05, 0x50, 0x00, 0x01, 0x05, 0x7e, 0x00, 0x01, 0x05, 0xa4, 0x00,
+    0x01, 0x05, 0xc4, 0x00, 0x01, 0x05, 0xe9, 0x00, 0x01, 0x06, 0x0c, 0x00,
+    0x01, 0x06, 0x31, 0x00, 0x01, 0x06, 0x60, 0x00, 0x01, 0x06, 0x8c, 0x00,
+    0x01, 0x06, 0xb4, 0x00, 0x01, 0x06, 0xd9, 0x00, 0x01, 0x07, 0x06, 0x00,
+    0x01, 0x07, 0x2b, 0x00, 0x01, 0x07, 0x50, 0x00, 0x01, 0x07, 0x76, 0x00,
+    0x01, 0x07, 0x9b, 0x00, 0x01, 0x07, 0xbe, 0x00, 0x01, 0x07, 0xe3, 0x00,
+    0x01, 0x08, 0x07, 0x00, 0x01, 0x08, 0x30, 0x00, 0x01, 0x08, 0x56, 0x00,
+    0x01, 0x08, 0x7b, 0x00, 0x01, 0x08, 0xa2, 0x00, 0x01, 0x08, 0xcd, 0x00,
+    0x01, 0x08, 0xf4, 0x00, 0x01, 0x09, 0x18, 0x00, 0x01, 0x09, 0x3e, 0x00,
+    0x01, 0x09, 0x61, 0x00, 0x01, 0x09, 0x8b, 0x00, 0x01, 0x09, 0xae, 0x00,
+    0x01, 0x09, 0xd3, 0x00, 0x01, 0x09, 0xf8, 0x00, 0x01, 0x0a, 0x1a, 0x00,
+    0x01, 0x0a, 0x3e, 0x00, 0x01, 0x0a, 0x66, 0x00, 0x01, 0x0a, 0x87, 0x00,
+    0x01, 0x0a, 0xaf, 0x00, 0x01, 0x0a, 0xda, 0x00, 0x01, 0x0b, 0x02, 0x00,
+    0x01, 0x0b, 0x29, 0x00, 0x01, 0x0b, 0x4c, 0x00, 0x01, 0x0b, 0x72, 0x00,
+    0x01, 0x0b, 0x97, 0x00, 0x01, 0x0b, 0xbb, 0x00, 0x01, 0x0b, 0xe7, 0x00,
+    0x01, 0x0c, 0x0c, 0x00, 0x01, 0x0c, 0x30, 0x00, 0x01, 0x0c, 0x56, 0x00,
+    0x01, 0x0c, 0x7d, 0x00, 0x01, 0x0c, 0xa2, 0x00, 0x01, 0x0c, 0xc7, 0x00,
+    0x01, 0x0c, 0xe8, 0x00, 0x01, 0x0d, 0x08, 0x00, 0x01, 0x0d, 0x30, 0x00,
+    0x01, 0x0d, 0x57, 0x00, 0x01, 0x0d, 0x7f, 0x00, 0x01, 0x0d, 0xa9, 0x00,
+    0x01, 0x0d, 0xcd, 0x00, 0x01, 0x0d, 0xf4, 0x00, 0x01, 0x0e, 0x1a, 0x00,
+    0x01, 0x0e, 0x3e, 0x00, 0x01, 0x0e, 0x61, 0x00, 0x01, 0x0e, 0x88, 0x00,
+    0x01, 0x0e, 0xad, 0x00, 0x01, 0x0e, 0xd7, 0x00, 0x01, 0x0e, 0xfd, 0x00,
+    0x01, 0x0f, 0x26, 0x00, 0x01, 0x0f, 0x49, 0x00, 0x01, 0x0f, 0x6d, 0x00,
+    0x01, 0x0f, 0x91, 0x00, 0x01, 0x0f, 0xba, 0x00, 0x01, 0x0f, 0xdb, 0x00,
+    0x01, 0x10, 0x05, 0x00, 0x01, 0x10, 0x30, 0x00, 0x01, 0x10, 0x5b, 0x00,
+    0x01, 0x10, 0x81, 0x00, 0x01, 0x10, 0xa4, 0x00, 0x01, 0x10, 0xca, 0x00,
+    0x01, 0x10, 0xf8, 0x00, 0x01, 0x11, 0x1b, 0x00, 0x01, 0x11, 0x42, 0x00,
+    0x01, 0x11, 0x6a, 0x00, 0x01, 0x11, 0x8d, 0x00, 0x01, 0x11, 0xb0, 0x00,
+    0x01, 0x11, 0xd6, 0x00, 0x01, 0x11, 0xfb, 0x00, 0x01, 0x12, 0x23, 0x00,
+    0x01, 0x12, 0x47, 0x00, 0x01, 0x12, 0x6d, 0x00, 0x01, 0x12, 0x91, 0x00,
+    0x01, 0x12, 0xb1, 0x00, 0x01, 0x12, 0xd8, 0x00, 0x01, 0x12, 0xfd, 0x00,
+    0x01, 0x13, 0x24, 0x00, 0x01, 0x13, 0x4b, 0x00, 0x01, 0x13, 0x6c, 0x00,
+    0x01, 0x13, 0x90, 0x00, 0x01, 0x13, 0xbb, 0x00, 0x01, 0x13, 0xe4, 0x00,
+    0x01, 0x14, 0x0b, 0x00, 0x01, 0x14, 0x2d, 0x00, 0x01, 0x14, 0x52, 0x00,
+    0x01, 0x14, 0x74, 0x00, 0x01, 0x14, 0x9d, 0x00, 0x01, 0x14, 0xc2, 0x00,
+    0x01, 0x14, 0xe5, 0x00, 0x01, 0x15, 0x07, 0x00, 0x01, 0x15, 0x2b, 0x00,
+    0x01, 0x15, 0x4f, 0x00, 0x01, 0x15, 0x7f, 0x00, 0x01, 0x15, 0x9e, 0x00,
+    0x01, 0x15, 0xc4, 0x00, 0x01, 0x15, 0xeb, 0x00, 0x01, 0x16, 0x16, 0x00,
+    0x01, 0x16, 0x3f, 0x00, 0x01, 0x16, 0x66, 0x00, 0x01, 0x16, 0x87, 0x00,
+    0x01, 0x16, 0xb3, 0x00, 0x01, 0x16, 0xd3, 0x00, 0x01, 0x16, 0xfb, 0x00,
+    0x01, 0x17, 0x1f, 0x00, 0x01, 0x17, 0x48, 0x00, 0x01, 0x17, 0x6e, 0x00,
+    0x01, 0x17, 0x94, 0x00, 0x01, 0x17, 0xb6, 0x00, 0x01, 0x17, 0xdb, 0x00,
+    0x01, 0x17, 0xfe, 0x00, 0x01, 0x18, 0x24, 0x00, 0x01, 0x18, 0x48, 0x00,
+    0x01, 0x18, 0x6e, 0x00, 0x01, 0x18, 0x8e, 0x00, 0x01, 0x18, 0xbb, 0x00,
+    0x01, 0x18, 0xdd, 0x00, 0x01, 0x19, 0x08, 0x00, 0x01, 0x19, 0x38, 0x00,
+    0x01, 0x19, 0x5b, 0x00, 0x01, 0x19, 0x89, 0x00, 0x01, 0x19, 0xaa, 0x00,
+    0x01, 0x19, 0xcd, 0x00, 0x01, 0x19, 0xf2, 0x00, 0x01, 0x1a, 0x16, 0x00,
+    0x01, 0x1a, 0x36, 0x00, 0x01, 0x1a, 0x59, 0x00, 0x01, 0x1a, 0x80, 0x00,
+    0x01, 0x1a, 0xa5, 0x00, 0x01, 0x1a, 0xc8, 0x00, 0x01, 0x1a, 0xec, 0x00,
+    0x01, 0x1b, 0x0e, 0x00, 0x01, 0x1b, 0x34, 0x00, 0x01, 0x1b, 0x5a, 0x00,
+    0x01, 0x1b, 0x7f, 0x00, 0x01, 0x1b, 0xa3, 0x00, 0x01, 0x1b, 0xc5, 0x00,
+    0x01, 0x1b, 0xe9, 0x00, 0x01, 0x1c, 0x0e, 0x00, 0x01, 0x1c, 0x35, 0x00,
+    0x01, 0x1c, 0x64, 0x00, 0x01, 0x1c, 0x89, 0x00, 0x01, 0x1c, 0xaf, 0x00,
+    0x01, 0x1c, 0xd4, 0x00, 0x01, 0x1c, 0xf7, 0x00, 0x01, 0x1d, 0x18, 0x00,
+    0x01, 0x1d, 0x3c, 0x00, 0x01, 0x1d, 0x5f, 0x00, 0x01, 0x1d, 0x85, 0x00,
+    0x01, 0x1d, 0xad, 0x00, 0x01, 0x1d, 0xcd, 0x00, 0x01, 0x1d, 0xef, 0x00,
+    0x01, 0x1e, 0x11, 0x00, 0x01, 0x1e, 0x3a, 0x00, 0x01, 0x1e, 0x5d, 0x00,
+    0x01, 0x1e, 0x84, 0x00, 0x01, 0x1e, 0xae, 0x00, 0x01, 0x1e, 0xd4, 0x00,
+    0x01, 0x1e, 0xff, 0x00, 0x01, 0x1f, 0x23, 0x00, 0x01, 0x1f, 0x4c, 0x00,
+    0x01, 0x1f, 0x6f, 0x00, 0x01, 0x1f, 0x90, 0x00, 0x01, 0x1f, 0xb5, 0x00,
+    0x01, 0x1f, 0xdd, 0x00, 0x01, 0x20, 0x03, 0x00, 0x01, 0x20, 0x2a, 0x00,
+    0x01, 0x20, 0x4d, 0x00, 0x01, 0x20, 0x71, 0x00, 0x01, 0x20, 0x96, 0x00,
+    0x01, 0x20, 0xc2, 0x00, 0x01, 0x20, 0xe5, 0x00, 0x01, 0x21, 0x0f, 0x00,
+    0x01, 0x21, 0x3e, 0x00, 0x01, 0x21, 0x6b, 0x00, 0x01, 0x21, 0x93, 0x00,
+    0x01, 0x21, 0xb4, 0x00, 0x01, 0x21, 0xdc, 0x00, 0x01, 0x22, 0x03, 0x00,
+    0x01, 0x22, 0x25, 0x00, 0x01, 0x22, 0x4b, 0x00, 0x01, 0x22, 0x6e, 0x00,
+    0x01, 0x22, 0x92, 0x00, 0x01, 0x22, 0xb6, 0x00, 0x01, 0x22, 0xdb, 0x00,
+    0x01, 0x23, 0x00, 0x00, 0x01, 0x23, 0x25, 0x00, 0x01, 0x23, 0x4c, 0x00,
+    0x01, 0x23, 0x6f, 0x00, 0x01, 0x23, 0x97, 0x00, 0x01, 0x23, 0xba, 0x00,
+    0x01, 0x23, 0xe7, 0x00, 0x01, 0x24, 0x0a, 0x00, 0x01, 0x24, 0x30, 0x00,
+    0x01, 0x24, 0x55, 0x00, 0x01, 0x24, 0x75, 0x00, 0x01, 0x24, 0x99, 0x00,
+    0x01, 0x24, 0xc3, 0x00, 0x01, 0x24, 0xe6, 0x00, 0x01, 0x25, 0x11, 0x00,
+    0x01, 0x25, 0x38, 0x00, 0x01, 0x25, 0x5f, 0x00, 0x01, 0x25, 0x81, 0x00,
+    0x01, 0x25, 0xa2, 0x00, 0x01, 0x25, 0xcb, 0x00, 0x01, 0x25, 0xf5, 0x00,
+    0x01, 0x26, 0x1b, 0x00, 0x01, 0x26, 0x3d, 0x00, 0x01, 0x26, 0x63, 0x00,
+    0x01, 0x26, 0x89, 0x00, 0x01, 0x26, 0xad, 0x00, 0x01, 0x26, 0xcf, 0x00,
+    0x01, 0x26, 0xfd, 0x00, 0x01, 0x27, 0x29, 0x00, 0x01, 0x27, 0x51, 0x00,
+    0x01, 0x27, 0x74, 0x00, 0x01, 0x27, 0x98, 0x00, 0x01, 0x27, 0xbc, 0x00,
+    0x01, 0x27, 0xe7, 0x00, 0x01, 0x28, 0x0b, 0x00, 0x01, 0x28, 0x2b, 0x00,
+    0x01, 0x28, 0x4a, 0x00, 0x01, 0x28, 0x6e, 0x00, 0x01, 0x28, 0x91, 0x00,
+    0x01, 0x28, 0xb4, 0x00, 0x01, 0x28, 0xdd, 0x00, 0x01, 0x29, 0x06, 0x00,
+    0x01, 0x29, 0x28, 0x00, 0x01, 0x29, 0x4e, 0x00, 0x01, 0x29, 0x7c, 0x00,
+    0x01, 0x29, 0xa2, 0x00, 0x01, 0x29, 0xc8, 0x00, 0x01, 0x29, 0xec, 0x00,
+    0x01, 0x2a, 0x0e, 0x00, 0x01, 0x2a, 0x34, 0x00, 0x01, 0x2a, 0x57, 0x00,
+    0x01, 0x2a, 0x7c, 0x00, 0x01, 0x2a, 0xa1, 0x00, 0x01, 0x2a, 0xcb, 0x00,
+    0x01, 0x2a, 0xf4, 0x00, 0x01, 0x2b, 0x1b, 0x00, 0x01, 0x2b, 0x42, 0x00,
+    0x01, 0x2b, 0x66, 0x00, 0x01, 0x2b, 0x92, 0x00, 0x01, 0x2b, 0xb5, 0x00,
+    0x01, 0x2b, 0xdb, 0x00, 0x01, 0x2c, 0x02, 0x00, 0x01, 0x2c, 0x24, 0x00,
+    0x01, 0x2c, 0x4a, 0x00, 0x01, 0x2c, 0x71, 0x00, 0x01, 0x2c, 0x95, 0x00,
+    0x01, 0x2c, 0xba, 0x00, 0x01, 0x2c, 0xe0, 0x00, 0x01, 0x2d, 0x07, 0x00,
+    0x01, 0x2d, 0x27, 0x00, 0x01, 0x2d, 0x52, 0x00, 0x01, 0x2d, 0x77, 0x00,
+    0x01, 0x2d, 0xa3, 0x00, 0x01, 0x2d, 0xc7, 0x00, 0x01, 0x2d, 0xea, 0x00,
+    0x01, 0x2e, 0x13, 0x00, 0x01, 0x2e, 0x3a, 0x00, 0x01, 0x2e, 0x63, 0x00,
+    0x01, 0x2e, 0x85, 0x00, 0x01, 0x2e, 0xa8, 0x00, 0x01, 0x2e, 0xcd, 0x00,
+    0x01, 0x2e, 0xf5, 0x00, 0x01, 0x2f, 0x16, 0x00, 0x01, 0x2f, 0x41, 0x00,
+    0x01, 0x2f, 0x67, 0x00, 0x01, 0x2f, 0x8a, 0x00, 0x01, 0x2f, 0xab, 0x00,
+    0x01, 0x2f, 0xd2, 0x00, 0x01, 0x2f, 0xf3, 0x00, 0x01, 0x30, 0x1e, 0x00,
+    0x01, 0x30, 0x43, 0x00, 0x01, 0x30, 0x69, 0x00, 0x01, 0x30, 0x91, 0x00,
+    0x01, 0x30, 0xb8, 0x00, 0x01, 0x30, 0xe0, 0x00, 0x01, 0x31, 0x05, 0x00,
+    0x01, 0x31, 0x28, 0x00, 0x01, 0x31, 0x50, 0x00, 0x01, 0x31, 0x7c, 0x00,
+    0x01, 0x31, 0x9d, 0x00, 0x01, 0x31, 0xc2, 0x00, 0x01, 0x31, 0xec, 0x00,
+    0x01, 0x32, 0x0c, 0x00, 0x01, 0x32, 0x32, 0x00, 0x01, 0x32, 0x58, 0x00,
+    0x01, 0x32, 0x83, 0x00, 0x01, 0x32, 0xa7, 0x00, 0x01, 0x32, 0xce, 0x00,
+    0x01, 0x32, 0xf2, 0x00, 0x01, 0x33, 0x15, 0x00, 0x01, 0x33, 0x3c, 0x00,
+    0x01, 0x33, 0x62, 0x00, 0x01, 0x33, 0x89, 0x00, 0x01, 0x33, 0xb4, 0x00,
+    0x01, 0x33, 0xdc, 0x00, 0x01, 0x34, 0x05, 0x00, 0x01, 0x34, 0x2c, 0x00,
+    0x01, 0x34, 0x50, 0x00, 0x01, 0x34, 0x7b, 0x00, 0x01, 0x34, 0x9f, 0x00,
+    0x01, 0x34, 0xc1, 0x00, 0x01, 0x34, 0xe8, 0x00, 0x01, 0x35, 0x11, 0x00,
+    0x01, 0x35, 0x35, 0x00, 0x01, 0x35, 0x59, 0x00, 0x01, 0x35, 0x80, 0x00,
+    0x01, 0x35, 0xa1, 0x00, 0x01, 0x35, 0xc1, 0x00, 0x01, 0x35, 0xea, 0x00,
+    0x01, 0x36, 0x0f, 0x00, 0x01, 0x36, 0x31, 0x00, 0x01, 0x36, 0x57, 0x00,
+    0x01, 0x36, 0x81, 0x00, 0x01, 0x36, 0xa5, 0x00, 0x01, 0x36, 0xca, 0x00,
+    0x01, 0x36, 0xf5, 0x00, 0x01, 0x37, 0x19, 0x00, 0x01, 0x37, 0x3e, 0x00,
+    0x01, 0x37, 0x6d, 0x00, 0x01, 0x37, 0x94, 0x00, 0x01, 0x37, 0xb9, 0x00,
+    0x01, 0x37, 0xdb, 0x00, 0x01, 0x38, 0x01, 0x00, 0x01, 0x38, 0x2a, 0x00,
+    0x01, 0x38, 0x4f, 0x00, 0x01, 0x38, 0x6f, 0x00, 0x01, 0x38, 0x97, 0x00,
+    0x01, 0x38, 0xbb, 0x00, 0x01, 0x38, 0xdd, 0x00, 0x01, 0x39, 0x06, 0x00,
+    0x01, 0x39, 0x32, 0x00, 0x01, 0x39, 0x55, 0x00, 0x01, 0x39, 0x7a, 0x00,
+    0x01, 0x39, 0xa2, 0x00, 0x01, 0x39, 0xcb, 0x00, 0x01, 0x39, 0xf0, 0x00,
+    0x01, 0x3a, 0x12, 0x00, 0x01, 0x3a, 0x3b, 0x00, 0x01, 0x3a, 0x6b, 0x00,
+    0x01, 0x3a, 0x90, 0x00, 0x01, 0x3a, 0xb6, 0x00, 0x01, 0x3a, 0xdd, 0x00,
+    0x01, 0x3a, 0xff, 0x00, 0x01, 0x3b, 0x24, 0x00, 0x01, 0x3b, 0x48, 0x00,
+    0x01, 0x3b, 0x6c, 0x00, 0x01, 0x3b, 0x91, 0x00, 0x01, 0x3b, 0xc1, 0x00,
+    0x01, 0x3b, 0xe9, 0x00, 0x01, 0x3c, 0x0c, 0x00, 0x01, 0x3c, 0x3b, 0x00,
+    0x01, 0x3c, 0x61, 0x00, 0x01, 0x3c, 0x87, 0x00, 0x01, 0x3c, 0xa8, 0x00,
+    0x01, 0x3c, 0xcd, 0x00, 0x01, 0x3c, 0xf4, 0x00, 0x01, 0x3d, 0x19, 0x00,
+    0x01, 0x3d, 0x41, 0x00, 0x01, 0x3d, 0x68, 0x00, 0x01, 0x3d, 0x8c, 0x00,
+    0x01, 0x3d, 0xb1, 0x00, 0x01, 0x3d, 0xd5, 0x00, 0x01, 0x3d, 0xfb, 0x00,
+    0x01, 0x3e, 0x22, 0x00, 0x01, 0x3e, 0x48, 0x00, 0x01, 0x3e, 0x6c, 0x00,
+    0x01, 0x3e, 0x8e, 0x00, 0x01, 0x3e, 0xb2, 0x00, 0x01, 0x3e, 0xd9, 0x00,
+    0x01, 0x3e, 0xfd, 0x00, 0x01, 0x3f, 0x24, 0x00, 0x01, 0x3f, 0x43, 0x00,
+    0x01, 0x3f, 0x6e, 0x00, 0x01, 0x3f, 0x97, 0x00, 0x01, 0x3f, 0xc0, 0x00,
+    0x01, 0x3f, 0xe5, 0x00, 0x01, 0x40, 0x08, 0x00, 0x01, 0x40, 0x34, 0x00,
+    0x01, 0x40, 0x5b, 0x00, 0x01, 0x40, 0x80, 0x00, 0x01, 0x40, 0xa4, 0x00,
+    0x01, 0x40, 0xca, 0x00, 0x01, 0x40, 0xf0, 0x00, 0x01, 0x41, 0x18, 0x00,
+    0x01, 0x41, 0x42, 0x00, 0x01, 0x41, 0x67, 0x00, 0x01, 0x41, 0x90, 0x00,
+    0x01, 0x41, 0xb8, 0x00, 0x01, 0x41, 0xd8, 0x00, 0x01, 0x41, 0xfe, 0x00,
+    0x01, 0x42, 0x28, 0x00, 0x01, 0x42, 0x51, 0x00, 0x01, 0x42, 0x78, 0x00,
+    0x01, 0x42, 0x9f, 0x00, 0x01, 0x42, 0xc8, 0x00, 0x01, 0x42, 0xf4, 0x00,
+    0x01, 0x43, 0x1c, 0x00, 0x01, 0x43, 0x45, 0x00, 0x01, 0x43, 0x67, 0x00,
+    0x01, 0x43, 0x92, 0x00, 0x01, 0x43, 0xb3, 0x00, 0x01, 0x43, 0xd7, 0x00,
+    0x01, 0x44, 0x03, 0x00, 0x01, 0x44, 0x29, 0x00, 0x01, 0x44, 0x4e, 0x00,
+    0x01, 0x44, 0x72, 0x00, 0x01, 0x44, 0x95, 0x00, 0x01, 0x44, 0xc1, 0x00,
+    0x01, 0x44, 0xe3, 0x00, 0x01, 0x45, 0x07, 0x00, 0x01, 0x45, 0x28, 0x00,
+    0x01, 0x45, 0x50, 0x00, 0x01, 0x45, 0x74, 0x00, 0x01, 0x45, 0xa1, 0x00,
+    0x01, 0x45, 0xc3, 0x00, 0x01, 0x45, 0xe7, 0x00, 0x01, 0x46, 0x0b, 0x00,
+    0x01, 0x46, 0x32, 0x00, 0x01, 0x46, 0x5d, 0x00, 0x01, 0x46, 0x81, 0x00,
+    0x01, 0x46, 0xa6, 0x00, 0x01, 0x46, 0xc9, 0x00, 0x01, 0x46, 0xf0, 0x00,
+    0x01, 0x47, 0x12, 0x00, 0x01, 0x47, 0x35, 0x00, 0x01, 0x47, 0x57, 0x00,
+    0x01, 0x47, 0x7e, 0x00, 0x01, 0x47, 0xa8, 0x00, 0x01, 0x47, 0xd0, 0x00,
+    0x01, 0x47, 0xf6, 0x00, 0x01, 0x48, 0x1d, 0x00, 0x01, 0x48, 0x41, 0x00,
+    0x01, 0x48, 0x65, 0x00, 0x01, 0x48, 0x88, 0x00, 0x01, 0x48, 0xad, 0x00,
+    0x01, 0x48, 0xd4, 0x00, 0x01, 0x48, 0xfb, 0x00, 0x01, 0x49, 0x20, 0x00,
+    0x01, 0x49, 0x47, 0x00, 0x01, 0x49, 0x67, 0x00, 0x01, 0x49, 0x8b, 0x00,
+    0x01, 0x49, 0xb3, 0x00, 0x01, 0x49, 0xd6, 0x00, 0x01, 0x49, 0xfa, 0x00,
+    0x01, 0x4a, 0x1f, 0x00, 0x01, 0x4a, 0x40, 0x00, 0x01, 0x4a, 0x62, 0x00,
+    0x01, 0x4a, 0x87, 0x00, 0x01, 0x4a, 0xad, 0x00, 0x01, 0x4a, 0xd6, 0x00,
+    0x01, 0x4a, 0xfb, 0x00, 0x01, 0x4b, 0x25, 0x00, 0x01, 0x4b, 0x52, 0x00,
+    0x01, 0x4b, 0x74, 0x00, 0x01, 0x4b, 0x97, 0x00, 0x01, 0x4b, 0xbc, 0x00,
+    0x01, 0x4b, 0xe4, 0x00, 0x01, 0x4c, 0x14, 0x00, 0x01, 0x4c, 0x39, 0x00,
+    0x01, 0x4c, 0x63, 0x00, 0x01, 0x4c, 0x8a, 0x00, 0x01, 0x4c, 0xb2, 0x00,
+    0x01, 0x4c, 0xd4, 0x00, 0x01, 0x4c, 0xfa, 0x00, 0x01, 0x4d, 0x25, 0x00,
+    0x01, 0x4d, 0x46, 0x00, 0x01, 0x4d, 0x6c, 0x00, 0x01, 0x4d, 0x91, 0x00,
+    0x01, 0x4d, 0xb8, 0x00, 0x01, 0x4d, 0xde, 0x00, 0x01, 0x4e, 0x02, 0x00,
+    0x01, 0x4e, 0x2f, 0x00, 0x01, 0x4e, 0x53, 0x00, 0x01, 0x4e, 0x78, 0x00,
+    0x01, 0x4e, 0x9d, 0x00, 0x01, 0x4e, 0xca, 0x00, 0x01, 0x4e, 0xf0, 0x00,
+    0x01, 0x4f, 0x1f, 0x00, 0x01, 0x4f, 0x43, 0x00, 0x01, 0x4f, 0x6a, 0x00,
+    0x01, 0x4f, 0x91, 0x00, 0x01, 0x4f, 0xb6, 0x00, 0x01, 0x4f, 0xe0, 0x00,
+    0x01, 0x50, 0x08, 0x00, 0x01, 0x50, 0x2a, 0x00, 0x01, 0x50, 0x4d, 0x00,
+    0x01, 0x50, 0x6e, 0x00, 0x01, 0x50, 0x99, 0x00, 0x01, 0x50, 0xbf, 0x00,
+    0x01, 0x50, 0xec, 0x00, 0x01, 0x51, 0x10, 0x00, 0x01, 0x51, 0x38, 0x00,
+    0x01, 0x51, 0x5e, 0x00, 0x01, 0x51, 0x83, 0x00, 0x01, 0x51, 0xac, 0x00,
+    0x01, 0x51, 0xd4, 0x00, 0x01, 0x51, 0xf9, 0x00, 0x01, 0x52, 0x20, 0x00,
+    0x01, 0x52, 0x4c, 0x00, 0x01, 0x52, 0x71, 0x00, 0x01, 0x52, 0x95, 0x00,
+    0x01, 0x52, 0xbf, 0x00, 0x01, 0x52, 0xe3, 0x00, 0x01, 0x53, 0x0d, 0x00,
+    0x01, 0x53, 0x34, 0x00, 0x01, 0x53, 0x59, 0x00, 0x01, 0x53, 0x80, 0x00,
+    0x01, 0x53, 0xaa, 0x00, 0x01, 0x53, 0xd4, 0x00, 0x01, 0x53, 0xf9, 0x00,
+    0x01, 0x54, 0x24, 0x00, 0x01, 0x54, 0x46, 0x00, 0x01, 0x54, 0x6a, 0x00,
+    0x01, 0x54, 0x8e, 0x00, 0x01, 0x54, 0xb5, 0x00, 0x01, 0x54, 0xde, 0x00,
+    0x01, 0x55, 0x08, 0x00, 0x01, 0x55, 0x35, 0x00, 0x01, 0x55, 0x5c, 0x00,
+    0x01, 0x55, 0x87, 0x00, 0x01, 0x55, 0xaf, 0x00, 0x01, 0x55, 0xd1, 0x00,
+    0x01, 0x55, 0xf9, 0x00, 0x01, 0x56, 0x24, 0x00, 0x01, 0x56, 0x4a, 0x00,
+    0x01, 0x56, 0x6e, 0x00, 0x01, 0x56, 0x92, 0x00, 0x01, 0x56, 0xbd, 0x00,
+    0x01, 0x56, 0xe4, 0x00, 0x01, 0x57, 0x09, 0x00, 0x01, 0x57, 0x2f, 0x00,
+    0x01, 0x57, 0x53, 0x00, 0x01, 0x57, 0x78, 0x00, 0x01, 0x57, 0x9d, 0x00,
+    0x01, 0x57, 0xbf, 0x00, 0x01, 0x57, 0xe5, 0x00, 0x01, 0x58, 0x0c, 0x00,
+    0x01, 0x58, 0x36, 0x00, 0x01, 0x58, 0x5b, 0x00, 0x01, 0x58, 0x80, 0x00,
+    0x01, 0x58, 0xaa, 0x00, 0x01, 0x58, 0xd8, 0x00, 0x01, 0x59, 0x02, 0x00,
+    0x01, 0x59, 0x24, 0x00, 0x01, 0x59, 0x4f, 0x00, 0x01, 0x59, 0x75, 0x00,
+    0x01, 0x59, 0x9b, 0x00, 0x01, 0x59, 0xbf, 0x00, 0x01, 0x59, 0xe6, 0x00,
+    0x01, 0x5a, 0x0e, 0x00, 0x01, 0x5a, 0x34, 0x00, 0x01, 0x5a, 0x59, 0x00,
+    0x01, 0x5a, 0x7e, 0x00, 0x01, 0x5a, 0xa4, 0x00, 0x01, 0x5a, 0xca, 0x00,
+    0x01, 0x5a, 0xef, 0x00, 0x01, 0x5b, 0x14, 0x00, 0x01, 0x5b, 0x3b, 0x00,
+    0x01, 0x5b, 0x5e, 0x00, 0x01, 0x5b, 0x8b, 0x00, 0x01, 0x5b, 0xb1, 0x00,
+    0x01, 0x5b, 0xd6, 0x00, 0x01, 0x5c, 0x03, 0x00, 0x01, 0x5c, 0x27, 0x00,
+    0x01, 0x5c, 0x4c, 0x00, 0x01, 0x5c, 0x77, 0x00, 0x01, 0x5c, 0xa0, 0x00,
+    0x01, 0x5c, 0xca, 0x00, 0x01, 0x5c, 0xee, 0x00, 0x01, 0x5d, 0x18, 0x00,
+    0x01, 0x5d, 0x40, 0x00, 0x01, 0x5d, 0x66, 0x00, 0x01, 0x5d, 0x8b, 0x00,
+    0x01, 0x5d, 0xb0, 0x00, 0x01, 0x5d, 0xd8, 0x00, 0x01, 0x5d, 0xfa, 0x00,
+    0x01, 0x5e, 0x21, 0x00, 0x01, 0x5e, 0x43, 0x00, 0x01, 0x5e, 0x64, 0x00,
+    0x01, 0x5e, 0x88, 0x00, 0x01, 0x5e, 0xae, 0x00, 0x01, 0x5e, 0xd2, 0x00,
+    0x01, 0x5e, 0xf7, 0x00, 0x01, 0x5f, 0x1d, 0x00, 0x01, 0x5f, 0x44, 0x00,
+    0x01, 0x5f, 0x72, 0x00, 0x01, 0x5f, 0x96, 0x00, 0x01, 0x5f, 0xb9, 0x00,
+    0x01, 0x5f, 0xd9, 0x00, 0x01, 0x60, 0x02, 0x00, 0x01, 0x60, 0x2d, 0x00,
+    0x01, 0x60, 0x52, 0x00, 0x01, 0x60, 0x77, 0x00, 0x01, 0x60, 0xa0, 0x00,
+    0x01, 0x60, 0xc6, 0x00, 0x01, 0x60, 0xec, 0x00, 0x01, 0x61, 0x0f, 0x00,
+    0x01, 0x61, 0x3c, 0x00, 0x01, 0x61, 0x5f, 0x00, 0x01, 0x61, 0x85, 0x00,
+    0x01, 0x61, 0xac, 0x00, 0x01, 0x61, 0xcd, 0x00, 0x01, 0x61, 0xf2, 0x00,
+    0x01, 0x62, 0x1f, 0x00, 0x01, 0x62, 0x42, 0x00, 0x01, 0x62, 0x65, 0x00,
+    0x01, 0x62, 0x8d, 0x00, 0x01, 0x62, 0xb2, 0x00, 0x01, 0x62, 0xdb, 0x00,
+    0x01, 0x62, 0xfc, 0x00, 0x01, 0x63, 0x20, 0x00, 0x01, 0x63, 0x47, 0x00,
+    0x01, 0x63, 0x6c, 0x00, 0x01, 0x63, 0x8e, 0x00, 0x01, 0x63, 0xb7, 0x00,
+    0x01, 0x63, 0xe1, 0x00, 0x01, 0x64, 0x09, 0x00, 0x01, 0x64, 0x2e, 0x00,
+    0x01, 0x64, 0x55, 0x00, 0x01, 0x64, 0x7e, 0x00, 0x01, 0x64, 0xa4, 0x00,
+    0x01, 0x64, 0xc7, 0x00, 0x01, 0x64, 0xf0, 0x00, 0x01, 0x65, 0x10, 0x00,
+    0x01, 0x65, 0x34, 0x00, 0x01, 0x65, 0x5a, 0x00, 0x01, 0x65, 0x80, 0x00,
+    0x01, 0x65, 0xa3, 0x00, 0x01, 0x65, 0xc2, 0x00, 0x01, 0x65, 0xea, 0x00,
+    0x01, 0x66, 0x0d, 0x00, 0x01, 0x66, 0x3a, 0x00, 0x01, 0x66, 0x5f, 0x00,
+    0x01, 0x66, 0x87, 0x00, 0x01, 0x66, 0xae, 0x00, 0x01, 0x66, 0xd4, 0x00,
+    0x01, 0x66, 0xfc, 0x00, 0x01, 0x67, 0x26, 0x00, 0x01, 0x67, 0x4a, 0x00,
+    0x01, 0x67, 0x6e, 0x00, 0x01, 0x67, 0x95, 0x00, 0x01, 0x67, 0xb6, 0x00,
+    0x01, 0x67, 0xdc, 0x00, 0x01, 0x68, 0x01, 0x00, 0x01, 0x68, 0x27, 0x00,
+    0x01, 0x68, 0x4b, 0x00, 0x01, 0x68, 0x73, 0x00, 0x01, 0x68, 0x95, 0x00,
+    0x01, 0x68, 0xbf, 0x00, 0x01, 0x68, 0xe8, 0x00, 0x01, 0x69, 0x0d, 0x00,
+    0x01, 0x69, 0x33, 0x00, 0x01, 0x69, 0x5b, 0x00, 0x01, 0x69, 0x7f, 0x00,
+    0x01, 0x69, 0xa4, 0x00, 0x01, 0x69, 0xca, 0x00, 0x01, 0x69, 0xf0, 0x00,
+    0x01, 0x6a, 0x19, 0x00, 0x01, 0x6a, 0x3e, 0x00, 0x01, 0x6a, 0x67, 0x00,
+    0x01, 0x6a, 0x92, 0x00, 0x01, 0x6a, 0xbb, 0x00, 0x01, 0x6a, 0xe1, 0x00,
+    0x01, 0x6b, 0x0a, 0x00, 0x01, 0x6b, 0x31, 0x00, 0x01, 0x6b, 0x5b, 0x00,
+    0x01, 0x6b, 0x80, 0x00, 0x01, 0x6b, 0xa7, 0x00, 0x01, 0x6b, 0xca, 0x00,
+    0x01, 0x6b, 0xf1, 0x00, 0x01, 0x6c, 0x14, 0x00, 0x01, 0x6c, 0x38, 0x00,
+    0x01, 0x6c, 0x63, 0x00, 0x01, 0x6c, 0x88, 0x00, 0x01, 0x6c, 0xab, 0x00,
+    0x01, 0x6c, 0xcf, 0x00, 0x01, 0x6c, 0xf5, 0x00, 0x01, 0x6d, 0x19, 0x00,
+    0x01, 0x6d, 0x3f, 0x00, 0x01, 0x6d, 0x61, 0x00, 0x01, 0x6d, 0x81, 0x00,
+    0x01, 0x6d, 0xa4, 0x00, 0x01, 0x6d, 0xc8, 0x00, 0x01, 0x6d, 0xe9, 0x00,
+    0x01, 0x6e, 0x0f, 0x00, 0x01, 0x6e, 0x35, 0x00, 0x01, 0x6e, 0x5e, 0x00,
+    0x01, 0x6e, 0x88, 0x00, 0x01, 0x6e, 0xaf, 0x00, 0x01, 0x6e, 0xda, 0x00,
+    0x01, 0x6f, 0x02, 0x00, 0x01, 0x6f, 0x2c, 0x00, 0x01, 0x6f, 0x52, 0x00,
+    0x01, 0x6f, 0x74, 0x00, 0x01, 0x6f, 0x95, 0x00, 0x01, 0x6f, 0xba, 0x00,
+    0x01, 0x6f, 0xdd, 0x00, 0x01, 0x70, 0x07, 0x00, 0x01, 0x70, 0x2e, 0x00,
+    0x01, 0x70, 0x54, 0x00, 0x01, 0x70, 0x77, 0x00, 0x01, 0x70, 0x9e, 0x00,
+    0x01, 0x70, 0xbe, 0x00, 0x01, 0x70, 0xe2, 0x00, 0x01, 0x71, 0x09, 0x00,
+    0x01, 0x71, 0x2e, 0x00, 0x01, 0x71, 0x52, 0x00, 0x01, 0x71, 0x75, 0x00,
+    0x01, 0x71, 0x98, 0x00, 0x01, 0x71, 0xb9, 0x00, 0x01, 0x71, 0xe2, 0x00,
+    0x01, 0x72, 0x0a, 0x00, 0x01, 0x72, 0x30, 0x00, 0x01, 0x72, 0x54, 0x00,
+    0x01, 0x72, 0x7f, 0x00, 0x01, 0x72, 0xa1, 0x00, 0x01, 0x72, 0xc6, 0x00,
+    0x01, 0x72, 0xeb, 0x00, 0x01, 0x73, 0x0b, 0x00, 0x01, 0x73, 0x29, 0x00,
+    0x01, 0x73, 0x48, 0x00, 0x01, 0x73, 0x6d, 0x00, 0x01, 0x73, 0x94, 0x00,
+    0x01, 0x73, 0xb9, 0x00, 0x01, 0x73, 0xdf, 0x00, 0x01, 0x74, 0x05, 0x00,
+    0x01, 0x74, 0x29, 0x00, 0x01, 0x74, 0x53, 0x00, 0x01, 0x74, 0x79, 0x00,
+    0x01, 0x74, 0xa3, 0x00, 0x01, 0x74, 0xc8, 0x00, 0x01, 0x74, 0xec, 0x00,
+    0x01, 0x75, 0x15, 0x00, 0x01, 0x75, 0x3a, 0x00, 0x01, 0x75, 0x61, 0x00,
+    0x01, 0x75, 0x84, 0x00, 0x01, 0x75, 0xa8, 0x00, 0x01, 0x75, 0xca, 0x00,
+    0x01, 0x75, 0xed, 0x00, 0x01, 0x76, 0x17, 0x00, 0x01, 0x76, 0x3d, 0x00,
+    0x01, 0x76, 0x62, 0x00, 0x01, 0x76, 0x88, 0x00, 0x01, 0x76, 0xaf, 0x00,
+    0x01, 0x76, 0xd1, 0x00, 0x01, 0x76, 0xf6, 0x00, 0x01, 0x77, 0x1c, 0x00,
+    0x01, 0x77, 0x46, 0x00, 0x01, 0x77, 0x6c, 0x00, 0x01, 0x77, 0x8c, 0x00,
+    0x01, 0x77, 0xb0, 0x00, 0x01, 0x77, 0xd6, 0x00, 0x01, 0x77, 0xf9, 0x00,
+    0x01, 0x78, 0x20, 0x00, 0x01, 0x78, 0x4a, 0x00, 0x01, 0x78, 0x75, 0x00,
+    0x01, 0x78, 0x9e, 0x00, 0x01, 0x78, 0xc2, 0x00, 0x01, 0x78, 0xee, 0x00,
+    0x01, 0x79, 0x12, 0x00, 0x01, 0x79, 0x36, 0x00, 0x01, 0x79, 0x61, 0x00,
+    0x01, 0x79, 0x84, 0x00, 0x01, 0x79, 0xaa, 0x00, 0x01, 0x79, 0xd1, 0x00,
+    0x01, 0x79, 0xf7, 0x00, 0x01, 0x7a, 0x1e, 0x00, 0x01, 0x7a, 0x43, 0x00,
+    0x01, 0x7a, 0x67, 0x00, 0x01, 0x7a, 0x8a, 0x00, 0x01, 0x7a, 0xb0, 0x00,
+    0x01, 0x7a, 0xd4, 0x00, 0x01, 0x7a, 0xfc, 0x00, 0x01, 0x7b, 0x20, 0x00,
+    0x01, 0x7b, 0x41, 0x00, 0x01, 0x7b, 0x66, 0x00, 0x01, 0x7b, 0x8a, 0x00,
+    0x01, 0x7b, 0xb1, 0x00, 0x01, 0x7b, 0xdf, 0x00, 0x01, 0x7c, 0x02, 0x00,
+    0x01, 0x7c, 0x24, 0x00, 0x01, 0x7c, 0x4b, 0x00, 0x01, 0x7c, 0x76, 0x00,
+    0x01, 0x7c, 0x9f, 0x00, 0x01, 0x7c, 0xc6, 0x00, 0x01, 0x7c, 0xf1, 0x00,
+    0x01, 0x7d, 0x14, 0x00, 0x01, 0x7d, 0x43, 0x00, 0x01, 0x7d, 0x67, 0x00,
+    0x01, 0x7d, 0x8d, 0x00, 0x01, 0x7d, 0xba, 0x00, 0x01, 0x7d, 0xdf, 0x00,
+    0x01, 0x7e, 0x08, 0x00, 0x01, 0x7e, 0x2e, 0x00, 0x01, 0x7e, 0x51, 0x00,
+    0x01, 0x7e, 0x77, 0x00, 0x01, 0x7e, 0x9e, 0x00, 0x01, 0x7e, 0xc5, 0x00,
+    0x01, 0x7e, 0xe9, 0x00, 0x01, 0x7f, 0x11, 0x00, 0x01, 0x7f, 0x36, 0x00,
+    0x01, 0x7f, 0x5b, 0x00, 0x01, 0x7f, 0x85, 0x00, 0x01, 0x7f, 0xac, 0x00,
+    0x01, 0x7f, 0xd1, 0x00, 0x01, 0x7f, 0xfb, 0x00, 0x01, 0x80, 0x20, 0x00,
+    0x01, 0x80, 0x42, 0x00, 0x01, 0x80, 0x64, 0x00, 0x01, 0x80, 0x8a, 0x00,
+    0x01, 0x80, 0xaf, 0x00, 0x01, 0x80, 0xd3, 0x00, 0x01, 0x80, 0xf6, 0x00,
+    0x01, 0x81, 0x19, 0x00, 0x01, 0x81, 0x42, 0x00, 0x01, 0x81, 0x6b, 0x00,
+    0x01, 0x81, 0x8c, 0x00, 0x01, 0x81, 0xaf, 0x00, 0x01, 0x81, 0xcf, 0x00,
+    0x01, 0x81, 0xf3, 0x00, 0x01, 0x82, 0x16, 0x00, 0x01, 0x82, 0x3f, 0x00,
+    0x01, 0x82, 0x5e, 0x00, 0x01, 0x82, 0x8e, 0x00, 0x01, 0x82, 0xb5, 0x00,
+    0x01, 0x82, 0xdf, 0x00, 0x01, 0x83, 0x02, 0x00, 0x01, 0x83, 0x29, 0x00,
+    0x01, 0x83, 0x4d, 0x00, 0x01, 0x83, 0x71, 0x00, 0x01, 0x83, 0x96, 0x00,
+    0x01, 0x83, 0xba, 0x00, 0x01, 0x83, 0xe0, 0x00, 0x01, 0x84, 0x04, 0x00,
+    0x01, 0x84, 0x2d, 0x00, 0x01, 0x84, 0x58, 0x00, 0x01, 0x84, 0x83, 0x00,
+    0x01, 0x84, 0xa8, 0x00, 0x01, 0x84, 0xcf, 0x00, 0x01, 0x84, 0xf6, 0x00,
+    0x01, 0x85, 0x1c, 0x00, 0x01, 0x85, 0x48, 0x00, 0x01, 0x85, 0x6d, 0x00,
+    0x01, 0x85, 0x96, 0x00, 0x01, 0x85, 0xba, 0x00, 0x01, 0x85, 0xe2, 0x00,
+    0x01, 0x86, 0x07, 0x00, 0x01, 0x86, 0x2f, 0x00, 0x01, 0x86, 0x57, 0x00,
+    0x01, 0x86, 0x7a, 0x00, 0x01, 0x86, 0xa0, 0x00, 0x01, 0x86, 0xc7, 0x00,
+    0x01, 0x86, 0xe8, 0x00, 0x01, 0x87, 0x14, 0x00, 0x01, 0x87, 0x39, 0x00,
+    0x01, 0x87, 0x5d, 0x00, 0x01, 0x87, 0x86, 0x00, 0x01, 0x87, 0xb2, 0x00,
+    0x01, 0x87, 0xd9, 0x00, 0x01, 0x87, 0xfb, 0x00, 0x01, 0x88, 0x24, 0x00,
+    0x01, 0x88, 0x4b, 0x00, 0x01, 0x88, 0x71, 0x00, 0x01, 0x88, 0x97, 0x00,
+    0x01, 0x88, 0xb8, 0x00, 0x01, 0x88, 0xdd, 0x00, 0x01, 0x89, 0x06, 0x00,
+    0x01, 0x89, 0x29, 0x00, 0x01, 0x89, 0x4c, 0x00, 0x01, 0x89, 0x70, 0x00,
+    0x01, 0x89, 0x97, 0x00, 0x01, 0x89, 0xbd, 0x00, 0x01, 0x89, 0xe2, 0x00,
+    0x01, 0x8a, 0x08, 0x00, 0x01, 0x8a, 0x31, 0x00, 0x01, 0x8a, 0x58, 0x00,
+    0x01, 0x8a, 0x7d, 0x00, 0x01, 0x8a, 0xa2, 0x00, 0x01, 0x8a, 0xc6, 0x00,
+    0x01, 0x8a, 0xe8, 0x00, 0x01, 0x8b, 0x0c, 0x00, 0x01, 0x8b, 0x30, 0x00,
+    0x01, 0x8b, 0x50, 0x00, 0x01, 0x8b, 0x74, 0x00, 0x01, 0x8b, 0x9a, 0x00,
+    0x01, 0x8b, 0xbe, 0x00, 0x01, 0x8b, 0xed, 0x00, 0x01, 0x8c, 0x11, 0x00,
+    0x01, 0x8c, 0x30, 0x00, 0x01, 0x8c, 0x58, 0x00, 0x01, 0x8c, 0x7d, 0x00,
+    0x01, 0x8c, 0x9c, 0x00, 0x01, 0x8c, 0xc1, 0x00, 0x01, 0x8c, 0xe5, 0x00,
+    0x01, 0x8d, 0x0e, 0x00, 0x01, 0x8d, 0x35, 0x00, 0x01, 0x8d, 0x5b, 0x00,
+    0x01, 0x8d, 0x7c, 0x00, 0x01, 0x8d, 0x9d, 0x00, 0x01, 0x8d, 0xc2, 0x00,
+    0x01, 0x8d, 0xe9, 0x00, 0x01, 0x8e, 0x0d, 0x00, 0x01, 0x8e, 0x32, 0x00,
+    0x01, 0x8e, 0x56, 0x00, 0x01, 0x8e, 0x79, 0x00, 0x01, 0x8e, 0x9a, 0x00,
+    0x01, 0x8e, 0xc3, 0x00, 0x01, 0x8e, 0xe4, 0x00, 0x01, 0x8f, 0x0c, 0x00,
+    0x01, 0x8f, 0x30, 0x00, 0x01, 0x8f, 0x54, 0x00, 0x01, 0x8f, 0x78, 0x00,
+    0x01, 0x8f, 0x9f, 0x00, 0x01, 0x8f, 0xc2, 0x00, 0x01, 0x8f, 0xea, 0x00,
+    0x01, 0x90, 0x0c, 0x00, 0x01, 0x90, 0x31, 0x00, 0x01, 0x90, 0x55, 0x00,
+    0x01, 0x90, 0x7c, 0x00, 0x01, 0x90, 0xa2, 0x00, 0x01, 0x90, 0xc6, 0x00,
+    0x01, 0x90, 0xe9, 0x00, 0x01, 0x91, 0x0d, 0x00, 0x01, 0x91, 0x38, 0x00,
+    0x01, 0x91, 0x5e, 0x00, 0x01, 0x91, 0x82, 0x00, 0x01, 0x91, 0xaf, 0x00,
+    0x01, 0x91, 0xdc, 0x00, 0x01, 0x92, 0x03, 0x00, 0x01, 0x92, 0x2b, 0x00,
+    0x01, 0x92, 0x55, 0x00, 0x01, 0x92, 0x7a, 0x00, 0x01, 0x92, 0xa1, 0x00,
+    0x01, 0x92, 0xc7, 0x00, 0x01, 0x92, 0xef, 0x00, 0x01, 0x93, 0x12, 0x00,
+    0x01, 0x93, 0x40, 0x00, 0x01, 0x93, 0x63, 0x00, 0x01, 0x93, 0x8a, 0x00,
+    0x01, 0x93, 0xac, 0x00, 0x01, 0x93, 0xd3, 0x00, 0x01, 0x93, 0xf8, 0x00,
+    0x01, 0x94, 0x1f, 0x00, 0x01, 0x94, 0x4d, 0x00, 0x01, 0x94, 0x70, 0x00,
+    0x01, 0x94, 0x97, 0x00, 0x01, 0x94, 0xc0, 0x00, 0x01, 0x94, 0xea, 0x00,
+    0x01, 0x95, 0x0e, 0x00, 0x01, 0x95, 0x35, 0x00, 0x01, 0x95, 0x59, 0x00,
+    0x01, 0x95, 0x7d, 0x00, 0x01, 0x95, 0xa5, 0x00, 0x01, 0x95, 0xd0, 0x00,
+    0x01, 0x95, 0xf1, 0x00, 0x01, 0x96, 0x17, 0x00, 0x01, 0x96, 0x3a, 0x00,
+    0x01, 0x96, 0x60, 0x00, 0x01, 0x96, 0x84, 0x00, 0x01, 0x96, 0xab, 0x00,
+    0x01, 0x96, 0xcd, 0x00, 0x01, 0x96, 0xf8, 0x00, 0x01, 0x97, 0x19, 0x00,
+    0x01, 0x97, 0x40, 0x00, 0x01, 0x97, 0x62, 0x00, 0x01, 0x97, 0x86, 0x00,
+    0x01, 0x97, 0xac, 0x00, 0x01, 0x97, 0xd6, 0x00, 0x01, 0x97, 0xfd, 0x00,
+    0x01, 0x98, 0x24, 0x00, 0x01, 0x98, 0x4d, 0x00, 0x01, 0x98, 0x70, 0x00,
+    0x01, 0x98, 0x9d, 0x00, 0x01, 0x98, 0xc5, 0x00, 0x01, 0x98, 0xe6, 0x00,
+    0x01, 0x99, 0x0d, 0x00, 0x01, 0x99, 0x2e, 0x00, 0x01, 0x99, 0x57, 0x00,
+    0x01, 0x99, 0x78, 0x00, 0x01, 0x99, 0x9f, 0x00, 0x01, 0x99, 0xc1, 0x00,
+    0x01, 0x99, 0xe6, 0x00, 0x01, 0x9a, 0x09, 0x00, 0x01, 0x9a, 0x2f, 0x00,
+    0x01, 0x9a, 0x51, 0x00, 0x01, 0x9a, 0x75, 0x00, 0x01, 0x9a, 0x9a, 0x00,
+    0x01, 0x9a, 0xbc, 0x00, 0x01, 0x9a, 0xdf, 0x00, 0x01, 0x9b, 0x0b, 0x00,
+    0x01, 0x9b, 0x34, 0x00, 0x01, 0x9b, 0x58, 0x00, 0x01, 0x9b, 0x7d, 0x00,
+    0x01, 0x9b, 0xa2, 0x00, 0x01, 0x9b, 0xc9, 0x00, 0x01, 0x9b, 0xf0, 0x00,
+    0x01, 0x9c, 0x16, 0x00, 0x01, 0x9c, 0x3a, 0x00, 0x01, 0x9c, 0x5f, 0x00,
+    0x01, 0x9c, 0x85, 0x00, 0x01, 0x9c, 0xaf, 0x00, 0x01, 0x9c, 0xd7, 0x00,
+    0x01, 0x9c, 0xfe, 0x00, 0x01, 0x9d, 0x26, 0x00, 0x01, 0x9d, 0x4e, 0x00,
+    0x01, 0x9d, 0x78, 0x00, 0x01, 0x9d, 0xa4, 0x00, 0x01, 0x9d, 0xc9, 0x00,
+    0x01, 0x9d, 0xeb, 0x00, 0x01, 0x9e, 0x12, 0x00, 0x01, 0x9e, 0x37, 0x00,
+    0x01, 0x9e, 0x62, 0x00, 0x01, 0x9e, 0x88, 0x00, 0x01, 0x9e, 0xae, 0x00,
+    0x01, 0x9e, 0xd1, 0x00, 0x01, 0x9e, 0xf9, 0x00, 0x01, 0x9f, 0x1d, 0x00,
+    0x01, 0x9f, 0x40, 0x00, 0x01, 0x9f, 0x68, 0x00, 0x01, 0x9f, 0x8d, 0x00,
+    0x01, 0x9f, 0xaf, 0x00, 0x01, 0x9f, 0xd8, 0x00, 0x01, 0x9f, 0xfd, 0x00,
+    0x01, 0xa0, 0x24, 0x00, 0x01, 0xa0, 0x48, 0x00, 0x01, 0xa0, 0x71, 0x00,
+    0x01, 0xa0, 0x95, 0x00, 0x01, 0xa0, 0xbe, 0x00, 0x01, 0xa0, 0xe8, 0x00,
+    0x01, 0xa1, 0x0f, 0x00, 0x01, 0xa1, 0x36, 0x00, 0x01, 0xa1, 0x5d, 0x00,
+    0x01, 0xa1, 0x83, 0x00, 0x01, 0xa1, 0xa6, 0x00, 0x01, 0xa1, 0xd2, 0x00,
+    0x01, 0xa1, 0xfa, 0x00, 0x01, 0xa2, 0x20, 0x00, 0x01, 0xa2, 0x43, 0x00,
+    0x01, 0xa2, 0x6c, 0x00, 0x01, 0xa2, 0x8d, 0x00, 0x01, 0xa2, 0xb5, 0x00,
+    0x01, 0xa2, 0xd9, 0x00, 0x01, 0xa2, 0xfe, 0x00, 0x01, 0xa3, 0x22, 0x00,
+    0x01, 0xa3, 0x46, 0x00, 0x01, 0xa3, 0x6b, 0x00, 0x01, 0xa3, 0x90, 0x00,
+    0x01, 0xa3, 0xbb, 0x00, 0x01, 0xa3, 0xe2, 0x00, 0x01, 0xa4, 0x07, 0x00,
+    0x01, 0xa4, 0x2b, 0x00, 0x01, 0xa4, 0x54, 0x00, 0x01, 0xa4, 0x7d, 0x00,
+    0x01, 0xa4, 0xa1, 0x00, 0x01, 0xa4, 0xc3, 0x00, 0x01, 0xa4, 0xef, 0x00,
+    0x01, 0xa5, 0x14, 0x00, 0x01, 0xa5, 0x39, 0x00, 0x01, 0xa5, 0x5d, 0x00,
+    0x01, 0xa5, 0x8a, 0x00, 0x01, 0xa5, 0xac, 0x00, 0x01, 0xa5, 0xcf, 0x00,
+    0x01, 0xa5, 0xfd, 0x00, 0x01, 0xa6, 0x24, 0x00, 0x01, 0xa6, 0x50, 0x00,
+    0x01, 0xa6, 0x73, 0x00, 0x01, 0xa6, 0x97, 0x00, 0x01, 0xa6, 0xbf, 0x00,
+    0x01, 0xa6, 0xe8, 0x00, 0x01, 0xa7, 0x0d, 0x00, 0x01, 0xa7, 0x32, 0x00,
+    0x01, 0xa7, 0x55, 0x00, 0x01, 0xa7, 0x7a, 0x00, 0x01, 0xa7, 0xa0, 0x00,
+    0x01, 0xa7, 0xc8, 0x00, 0x01, 0xa7, 0xed, 0x00, 0x01, 0xa8, 0x13, 0x00,
+    0x01, 0xa8, 0x39, 0x00, 0x01, 0xa8, 0x5f, 0x00, 0x01, 0xa8, 0x81, 0x00,
+    0x01, 0xa8, 0xa4, 0x00, 0x01, 0xa8, 0xc9, 0x00, 0x01, 0xa8, 0xee, 0x00,
+    0x01, 0xa9, 0x12, 0x00, 0x01, 0xa9, 0x3d, 0x00, 0x01, 0xa9, 0x62, 0x00,
+    0x01, 0xa9, 0x84, 0x00, 0x01, 0xa9, 0xaf, 0x00, 0x01, 0xa9, 0xd7, 0x00,
+    0x01, 0xa9, 0xfd, 0x00, 0x01, 0xaa, 0x25, 0x00, 0x01, 0xaa, 0x4b, 0x00,
+    0x01, 0xaa, 0x71, 0x00, 0x01, 0xaa, 0x97, 0x00, 0x01, 0xaa, 0xbd, 0x00,
+    0x01, 0xaa, 0xe1, 0x00, 0x01, 0xab, 0x05, 0x00, 0x01, 0xab, 0x28, 0x00,
+    0x01, 0xab, 0x4a, 0x00, 0x01, 0xab, 0x6d, 0x00, 0x01, 0xab, 0x96, 0x00,
+    0x01, 0xab, 0xb9, 0x00, 0x01, 0xab, 0xe5, 0x00, 0x01, 0xac, 0x0d, 0x00,
+    0x01, 0xac, 0x36, 0x00, 0x01, 0xac, 0x63, 0x00, 0x01, 0xac, 0x88, 0x00,
+    0x01, 0xac, 0xb0, 0x00, 0x01, 0xac, 0xd5, 0x00, 0x01, 0xac, 0xfa, 0x00,
+    0x01, 0xad, 0x1e, 0x00, 0x01, 0xad, 0x3f, 0x00, 0x01, 0xad, 0x68, 0x00,
+    0x01, 0xad, 0x89, 0x00, 0x01, 0xad, 0xac, 0x00, 0x01, 0xad, 0xd1, 0x00,
+    0x01, 0xad, 0xfe, 0x00, 0x01, 0xae, 0x27, 0x00, 0x01, 0xae, 0x4f, 0x00,
+    0x01, 0xae, 0x76, 0x00, 0x01, 0xae, 0xa3, 0x00, 0x01, 0xae, 0xca, 0x00,
+    0x01, 0xae, 0xec, 0x00, 0x01, 0xaf, 0x11, 0x00, 0x01, 0xaf, 0x35, 0x00,
+    0x01, 0xaf, 0x5b, 0x00, 0x01, 0xaf, 0x7f, 0x00, 0x01, 0xaf, 0xa4, 0x00,
+    0x01, 0xaf, 0xc5, 0x00, 0x01, 0xaf, 0xec, 0x00, 0x01, 0xb0, 0x12, 0x00,
+    0x01, 0xb0, 0x34, 0x00, 0x01, 0xb0, 0x58, 0x00, 0x01, 0xb0, 0x80, 0x00,
+    0x01, 0xb0, 0xa9, 0x00, 0x01, 0xb0, 0xd3, 0x00, 0x01, 0xb0, 0xf8, 0x00,
+    0x01, 0xb1, 0x20, 0x00, 0x01, 0xb1, 0x48, 0x00, 0x01, 0xb1, 0x6d, 0x00,
+    0x01, 0xb1, 0x8f, 0x00, 0x01, 0xb1, 0xb5, 0x00, 0x01, 0xb1, 0xdb, 0x00,
+    0x01, 0xb2, 0x00, 0x00, 0x01, 0xb2, 0x25, 0x00, 0x01, 0xb2, 0x49, 0x00,
+    0x01, 0xb2, 0x6f, 0x00, 0x01, 0xb2, 0x92, 0x00, 0x01, 0xb2, 0xbd, 0x00,
+    0x01, 0xb2, 0xe7, 0x00, 0x01, 0xb3, 0x09, 0x00, 0x01, 0xb3, 0x36, 0x00,
+    0x01, 0xb3, 0x5d, 0x00, 0x01, 0xb3, 0x86, 0x00, 0x01, 0xb3, 0xae, 0x00,
+    0x01, 0xb3, 0xd1, 0x00, 0x01, 0xb3, 0xf7, 0x00, 0x01, 0xb4, 0x23, 0x00,
+    0x01, 0xb4, 0x4e, 0x00, 0x01, 0xb4, 0x76, 0x00, 0x01, 0xb4, 0x9c, 0x00,
+    0x01, 0xb4, 0xbe, 0x00, 0x01, 0xb4, 0xe2, 0x00, 0x01, 0xb5, 0x0d, 0x00,
+    0x01, 0xb5, 0x33, 0x00, 0x01, 0xb5, 0x56, 0x00, 0x01, 0xb5, 0x7d, 0x00,
+    0x01, 0xb5, 0xa1, 0x00, 0x01, 0xb5, 0xcb, 0x00, 0x01, 0xb5, 0xf0, 0x00,
+    0x01, 0xb6, 0x15, 0x00, 0x01, 0xb6, 0x3b, 0x00, 0x01, 0xb6, 0x62, 0x00,
+    0x01, 0xb6, 0x8b, 0x00, 0x01, 0xb6, 0xb8, 0x00, 0x01, 0xb6, 0xd8, 0x00,
+    0x01, 0xb7, 0x03, 0x00, 0x01, 0xb7, 0x27, 0x00, 0x01, 0xb7, 0x4f, 0x00,
+    0x01, 0xb7, 0x73, 0x00, 0x01, 0xb7, 0x95, 0x00, 0x01, 0xb7, 0xc0, 0x00,
+    0x01, 0xb7, 0xe7, 0x00, 0x01, 0xb8, 0x09, 0x00, 0x01, 0xb8, 0x2c, 0x00,
+    0x01, 0xb8, 0x55, 0x00, 0x01, 0xb8, 0x79, 0x00, 0x01, 0xb8, 0x9e, 0x00,
+    0x01, 0xb8, 0xc4, 0x00, 0x01, 0xb8, 0xe9, 0x00, 0x01, 0xb9, 0x0f, 0x00,
+    0x01, 0xb9, 0x33, 0x00, 0x01, 0xb9, 0x58, 0x00, 0x01, 0xb9, 0x7f, 0x00,
+    0x01, 0xb9, 0xa7, 0x00, 0x01, 0xb9, 0xcb, 0x00, 0x01, 0xb9, 0xf1, 0x00,
+    0x01, 0xba, 0x17, 0x00, 0x01, 0xba, 0x3a, 0x00, 0x01, 0xba, 0x5e, 0x00,
+    0x01, 0xba, 0x86, 0x00, 0x01, 0xba, 0xa9, 0x00, 0x01, 0xba, 0xd4, 0x00,
+    0x01, 0xba, 0xf9, 0x00, 0x01, 0xbb, 0x1f, 0x00, 0x01, 0xbb, 0x4b, 0x00,
+    0x01, 0xbb, 0x71, 0x00, 0x01, 0xbb, 0x98, 0x00, 0x01, 0xbb, 0xc5, 0x00,
+    0x01, 0xbb, 0xeb, 0x00, 0x01, 0xbc, 0x0c, 0x00, 0x01, 0xbc, 0x34, 0x00,
+    0x01, 0xbc, 0x5f, 0x00, 0x01, 0xbc, 0x87, 0x00, 0x01, 0xbc, 0xac, 0x00,
+    0x01, 0xbc, 0xcc, 0x00, 0x01, 0xbc, 0xee, 0x00, 0x01, 0xbd, 0x12, 0x00,
+    0x01, 0xbd, 0x40, 0x00, 0x01, 0xbd, 0x6a, 0x00, 0x01, 0xbd, 0x8f, 0x00,
+    0x01, 0xbd, 0xb1, 0x00, 0x01, 0xbd, 0xdd, 0x00, 0x01, 0xbe, 0x03, 0x00,
+    0x01, 0xbe, 0x2d, 0x00, 0x01, 0xbe, 0x50, 0x00, 0x01, 0xbe, 0x71, 0x00,
+    0x01, 0xbe, 0x97, 0x00, 0x01, 0xbe, 0xbd, 0x00, 0x01, 0xbe, 0xde, 0x00,
+    0x01, 0xbf, 0x03, 0x00, 0x01, 0xbf, 0x28, 0x00, 0x01, 0xbf, 0x4e, 0x00,
+    0x01, 0xbf, 0x74, 0x00, 0x01, 0xbf, 0xa5, 0x00, 0x01, 0xbf, 0xce, 0x00,
+    0x01, 0xbf, 0xf1, 0x00, 0x01, 0xc0, 0x13, 0x00, 0x01, 0xc0, 0x35, 0x00,
+    0x01, 0xc0, 0x58, 0x00, 0x01, 0xc0, 0x81, 0x00, 0x01, 0xc0, 0xa2, 0x00,
+    0x01, 0xc0, 0xc6, 0x00, 0x01, 0xc0, 0xef, 0x00, 0x01, 0xc1, 0x14, 0x00,
+    0x01, 0xc1, 0x37, 0x00, 0x01, 0xc1, 0x67, 0x00, 0x01, 0xc1, 0x8c, 0x00,
+    0x01, 0xc1, 0xb6, 0x00, 0x01, 0xc1, 0xda, 0x00, 0x01, 0xc2, 0x08, 0x00,
+    0x01, 0xc2, 0x29, 0x00, 0x01, 0xc2, 0x4f, 0x00, 0x01, 0xc2, 0x77, 0x00,
+    0x01, 0xc2, 0x9d, 0x00, 0x01, 0xc2, 0xc5, 0x00, 0x01, 0xc2, 0xeb, 0x00,
+    0x01, 0xc3, 0x13, 0x00, 0x01, 0xc3, 0x37, 0x00, 0x01, 0xc3, 0x5c, 0x00,
+    0x01, 0xc3, 0x80, 0x00, 0x01, 0xc3, 0xa9, 0x00, 0x01, 0xc3, 0xce, 0x00,
+    0x01, 0xc3, 0xf0, 0x00, 0x01, 0xc4, 0x16, 0x00, 0x01, 0xc4, 0x3e, 0x00,
+    0x01, 0xc4, 0x67, 0x00, 0x01, 0xc4, 0x8f, 0x00, 0x01, 0xc4, 0xb0, 0x00,
+    0x01, 0xc4, 0xd7, 0x00, 0x01, 0xc4, 0xfe, 0x00, 0x01, 0xc5, 0x22, 0x00,
+    0x01, 0xc5, 0x46, 0x00, 0x01, 0xc5, 0x6b, 0x00, 0x01, 0xc5, 0x8d, 0x00,
+    0x01, 0xc5, 0xb7, 0x00, 0x01, 0xc5, 0xda, 0x00, 0x01, 0xc6, 0x05, 0x00,
+    0x01, 0xc6, 0x2c, 0x00, 0x01, 0xc6, 0x4c, 0x00, 0x01, 0xc6, 0x75, 0x00,
+    0x01, 0xc6, 0x9a, 0x00, 0x01, 0xc6, 0xc3, 0x00, 0x01, 0xc6, 0xe7, 0x00,
+    0x01, 0xc7, 0x0a, 0x00, 0x01, 0xc7, 0x2f, 0x00, 0x01, 0xc7, 0x52, 0x00,
+    0x01, 0xc7, 0x77, 0x00, 0x01, 0xc7, 0x9e, 0x00, 0x01, 0xc7, 0xc4, 0x00,
+    0x01, 0xc7, 0xea, 0x00, 0x01, 0xc8, 0x0d, 0x00, 0x01, 0xc8, 0x34, 0x00,
+    0x01, 0xc8, 0x5d, 0x00, 0x01, 0xc8, 0x83, 0x00, 0x01, 0xc8, 0xa9, 0x00,
+    0x01, 0xc8, 0xce, 0x00, 0x01, 0xc8, 0xf1, 0x00, 0x01, 0xc9, 0x1a, 0x00,
+    0x01, 0xc9, 0x44, 0x00, 0x01, 0xc9, 0x69, 0x00, 0x01, 0xc9, 0x90, 0x00,
+    0x01, 0xc9, 0xb8, 0x00, 0x01, 0xc9, 0xdb, 0x00, 0x01, 0xc9, 0xfd, 0x00,
+    0x01, 0xca, 0x1f, 0x00, 0x01, 0xca, 0x4a, 0x00, 0x01, 0xca, 0x71, 0x00,
+    0x01, 0xca, 0x95, 0x00, 0x01, 0xca, 0xbb, 0x00, 0x01, 0xca, 0xe1, 0x00,
+    0x01, 0xcb, 0x06, 0x00, 0x01, 0xcb, 0x2b, 0x00, 0x01, 0xcb, 0x4f, 0x00,
+    0x01, 0xcb, 0x77, 0x00, 0x01, 0xcb, 0x98, 0x00, 0x01, 0xcb, 0xbc, 0x00,
+    0x01, 0xcb, 0xe1, 0x00, 0x01, 0xcc, 0x07, 0x00, 0x01, 0xcc, 0x31, 0x00,
+    0x01, 0xcc, 0x57, 0x00, 0x01, 0xcc, 0x7a, 0x00, 0x01, 0xcc, 0x9d, 0x00,
+    0x01, 0xcc, 0xbe, 0x00, 0x01, 0xcc, 0xe4, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x8e, 0x00,
+    0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, 0xde, 0x00, 0x00, 0x01, 0x05, 0x00,
+    0x00, 0x01, 0x2a, 0x00, 0x00, 0x01, 0x4c, 0x00, 0x00, 0x01, 0x7a, 0x00,
+    0x00, 0x01, 0xa4, 0x00, 0x00, 0x01, 0xca, 0x00, 0x00, 0x01, 0xf0, 0x00,
+    0x00, 0x02, 0x18, 0x00, 0x00, 0x02, 0x3f, 0x00, 0x00, 0x02, 0x67, 0x00,
+    0x00, 0x02, 0x8f, 0x00, 0x00, 0x02, 0xb3, 0x00, 0x00, 0x02, 0xdb, 0x00,
+    0x00, 0x03, 0x03, 0x00, 0x00, 0x03, 0x27, 0x00, 0x00, 0x03, 0x4c, 0x00,
+    0x00, 0x03, 0x77, 0x00, 0x00, 0x03, 0xa0, 0x00, 0x00, 0x03, 0xc3, 0x00,
+    0x00, 0x03, 0xea, 0x00, 0x00, 0x04, 0x0d, 0x00, 0x00, 0x04, 0x31, 0x00,
+    0x00, 0x04, 0x56, 0x00, 0x00, 0x04, 0x7b, 0x00, 0x00, 0x04, 0xa2, 0x00,
+    0x00, 0x04, 0xc4, 0x00, 0x00, 0x04, 0xe7, 0x00, 0x00, 0x05, 0x0b, 0x00,
+    0x00, 0x05, 0x36, 0x00, 0x00, 0x05, 0x5f, 0x00, 0x00, 0x05, 0x84, 0x00,
+    0x00, 0x05, 0xaa, 0x00, 0x00, 0x05, 0xcf, 0x00, 0x00, 0x05, 0xf2, 0x00,
+    0x00, 0x06, 0x14, 0x00, 0x00, 0x06, 0x3a, 0x00, 0x00, 0x06, 0x63, 0x00,
+    0x00, 0x06, 0x83, 0x00, 0x00, 0x06, 0xa4, 0x00, 0x00, 0x06, 0xcf, 0x00,
+    0x00, 0x06, 0xf0, 0x00, 0x00, 0x07, 0x15, 0x00, 0x00, 0x07, 0x39, 0x00,
+    0x00, 0x07, 0x5b, 0x00, 0x00, 0x07, 0x81, 0x00, 0x00, 0x07, 0xa6, 0x00,
+    0x00, 0x07, 0xcd, 0x00, 0x00, 0x07, 0xf8, 0x00, 0x00, 0x08, 0x27, 0x00,
+    0x00, 0x08, 0x50, 0x00, 0x00, 0x08, 0x74, 0x00, 0x00, 0x08, 0x99, 0x00,
+    0x00, 0x08, 0xbc, 0x00, 0x00, 0x08, 0xea, 0x00, 0x00, 0x09, 0x14, 0x00,
+    0x00, 0x09, 0x3c, 0x00, 0x00, 0x09, 0x64, 0x00, 0x00, 0x09, 0x8a, 0x00,
+    0x00, 0x09, 0xb3, 0x00, 0x00, 0x09, 0xd2, 0x00, 0x00, 0x09, 0xfc, 0x00,
+    0x00, 0x0a, 0x20, 0x00, 0x00, 0x0a, 0x47, 0x00, 0x00, 0x0a, 0x6c, 0x00,
+    0x00, 0x0a, 0x90, 0x00, 0x00, 0x0a, 0xb7, 0x00, 0x00, 0x0a, 0xdd, 0x00,
+    0x00, 0x0b, 0x02, 0x00, 0x00, 0x0b, 0x27, 0x00, 0x00, 0x0b, 0x4e, 0x00,
+    0x00, 0x0b, 0x75, 0x00, 0x00, 0x0b, 0x9b, 0x00, 0x00, 0x0b, 0xbd, 0x00,
+    0x00, 0x0b, 0xe2, 0x00, 0x00, 0x0c, 0x07, 0x00, 0x00, 0x0c, 0x2c, 0x00,
+    0x00, 0x0c, 0x52, 0x00, 0x00, 0x0c, 0x7a, 0x00, 0x00, 0x0c, 0xa6, 0x00,
+    0x00, 0x0c, 0xcc, 0x00, 0x00, 0x0c, 0xf2, 0x00, 0x00, 0x0d, 0x11, 0x00,
+    0x00, 0x0d, 0x36, 0x00, 0x00, 0x0d, 0x5e, 0x00, 0x00, 0x0d, 0x81, 0x00,
+    0x00, 0x0d, 0xa6, 0x00, 0x00, 0x0d, 0xcb, 0x00, 0x00, 0x0d, 0xef, 0x00,
+    0x00, 0x0e, 0x12, 0x00, 0x00, 0x0e, 0x37, 0x00, 0x00, 0x0e, 0x5d, 0x00,
+    0x00, 0x0e, 0x82, 0x00, 0x00, 0x0e, 0xad, 0x00, 0x00, 0x0e, 0xd4, 0x00,
+    0x00, 0x0e, 0xfa, 0x00, 0x00, 0x0f, 0x1f, 0x00, 0x00, 0x0f, 0x46, 0x00,
+    0x00, 0x0f, 0x70, 0x00, 0x00, 0x0f, 0x97, 0x00, 0x00, 0x0f, 0xba, 0x00,
+    0x00, 0x0f, 0xdf, 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x10, 0x2c, 0x00,
+    0x00, 0x10, 0x51, 0x00, 0x00, 0x10, 0x78, 0x00, 0x00, 0x10, 0x99, 0x00,
+    0x00, 0x10, 0xc0, 0x00, 0x00, 0x10, 0xe3, 0x00, 0x00, 0x11, 0x09, 0x00,
+    0x00, 0x11, 0x32, 0x00, 0x00, 0x11, 0x58, 0x00, 0x00, 0x11, 0x7e, 0x00,
+    0x00, 0x11, 0xa4, 0x00, 0x00, 0x11, 0xc8, 0x00, 0x00, 0x11, 0xef, 0x00,
+    0x00, 0x12, 0x16, 0x00, 0x00, 0x12, 0x38, 0x00, 0x00, 0x12, 0x65, 0x00,
+    0x00, 0x12, 0x8c, 0x00, 0x00, 0x12, 0xae, 0x00, 0x00, 0x12, 0xd1, 0x00,
+    0x00, 0x12, 0xf7, 0x00, 0x00, 0x13, 0x1a, 0x00, 0x00, 0x13, 0x48, 0x00,
+    0x00, 0x13, 0x71, 0x00, 0x00, 0x13, 0x9e, 0x00, 0x00, 0x13, 0xc2, 0x00,
+    0x00, 0x13, 0xe4, 0x00, 0x00, 0x14, 0x0a, 0x00, 0x00, 0x14, 0x2b, 0x00,
+    0x00, 0x14, 0x50, 0x00, 0x00, 0x14, 0x78, 0x00, 0x00, 0x14, 0x9b, 0x00,
+    0x00, 0x14, 0xbf, 0x00, 0x00, 0x14, 0xe2, 0x00, 0x00, 0x15, 0x08, 0x00,
+    0x00, 0x15, 0x2d, 0x00, 0x00, 0x15, 0x56, 0x00, 0x00, 0x15, 0x7a, 0x00,
+    0x00, 0x15, 0xa5, 0x00, 0x00, 0x15, 0xcd, 0x00, 0x00, 0x15, 0xf7, 0x00,
+    0x00, 0x16, 0x1f, 0x00, 0x00, 0x16, 0x41, 0x00, 0x00, 0x16, 0x67, 0x00,
+    0x00, 0x16, 0x8c, 0x00, 0x00, 0x16, 0xb2, 0x00, 0x00, 0x16, 0xd9, 0x00,
+    0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x27, 0x00, 0x00, 0x17, 0x51, 0x00,
+    0x00, 0x17, 0x74, 0x00, 0x00, 0x17, 0xa0, 0x00, 0x00, 0x17, 0xc7, 0x00,
+    0x00, 0x17, 0xf7, 0x00, 0x00, 0x18, 0x1e, 0x00, 0x00, 0x18, 0x48, 0x00,
+    0x00, 0x18, 0x6c, 0x00, 0x00, 0x18, 0x99, 0x00, 0x00, 0x18, 0xbe, 0x00,
+    0x00, 0x18, 0xe4, 0x00, 0x00, 0x19, 0x09, 0x00, 0x00, 0x19, 0x2d, 0x00,
+    0x00, 0x19, 0x58, 0x00, 0x00, 0x19, 0x80, 0x00, 0x00, 0x19, 0xa6, 0x00,
+    0x00, 0x19, 0xcc, 0x00, 0x00, 0x19, 0xf3, 0x00, 0x00, 0x1a, 0x19, 0x00,
+    0x00, 0x1a, 0x44, 0x00, 0x00, 0x1a, 0x69, 0x00, 0x00, 0x1a, 0x8d, 0x00,
+    0x00, 0x1a, 0xb1, 0x00, 0x00, 0x1a, 0xd4, 0x00, 0x00, 0x1a, 0xfa, 0x00,
+    0x00, 0x1b, 0x2d, 0x00, 0x00, 0x1b, 0x54, 0x00, 0x00, 0x1b, 0x77, 0x00,
+    0x00, 0x1b, 0x99, 0x00, 0x00, 0x1b, 0xc8, 0x00, 0x00, 0x1b, 0xef, 0x00,
+    0x00, 0x1c, 0x13, 0x00, 0x00, 0x1c, 0x35, 0x00, 0x00, 0x1c, 0x59, 0x00,
+    0x00, 0x1c, 0x7e, 0x00, 0x00, 0x1c, 0xa7, 0x00, 0x00, 0x1c, 0xca, 0x00,
+    0x00, 0x1c, 0xef, 0x00, 0x00, 0x1d, 0x12, 0x00, 0x00, 0x1d, 0x38, 0x00,
+    0x00, 0x1d, 0x5c, 0x00, 0x00, 0x1d, 0x82, 0x00, 0x00, 0x1d, 0xa3, 0x00,
+    0x00, 0x1d, 0xc9, 0x00, 0x00, 0x1d, 0xef, 0x00, 0x00, 0x1e, 0x1b, 0x00,
+    0x00, 0x1e, 0x3e, 0x00, 0x00, 0x1e, 0x65, 0x00, 0x00, 0x1e, 0x9d, 0x00,
+    0x00, 0x1e, 0xc0, 0x00, 0x00, 0x1e, 0xe5, 0x00, 0x00, 0x1f, 0x09, 0x00,
+    0x00, 0x1f, 0x2e, 0x00, 0x00, 0x1f, 0x53, 0x00, 0x00, 0x1f, 0x79, 0x00,
+    0x00, 0x1f, 0x9d, 0x00, 0x00, 0x1f, 0xc2, 0x00, 0x00, 0x1f, 0xe1, 0x00,
+    0x00, 0x20, 0x03, 0x00, 0x00, 0x20, 0x2c, 0x00, 0x00, 0x20, 0x54, 0x00,
+    0x00, 0x20, 0x77, 0x00, 0x00, 0x20, 0x9a, 0x00, 0x00, 0x20, 0xbd, 0x00,
+    0x00, 0x20, 0xde, 0x00, 0x00, 0x20, 0xfe, 0x00, 0x00, 0x21, 0x21, 0x00,
+    0x00, 0x21, 0x4b, 0x00, 0x00, 0x21, 0x6e, 0x00, 0x00, 0x21, 0x90, 0x00,
+    0x00, 0x21, 0xb6, 0x00, 0x00, 0x21, 0xdb, 0x00, 0x00, 0x22, 0x00, 0x00,
+    0x00, 0x22, 0x26, 0x00, 0x00, 0x22, 0x49, 0x00, 0x00, 0x22, 0x72, 0x00,
+    0x00, 0x22, 0x9b, 0x00, 0x00, 0x22, 0xc2, 0x00, 0x00, 0x22, 0xe9, 0x00,
+    0x00, 0x23, 0x0e, 0x00, 0x00, 0x23, 0x38, 0x00, 0x00, 0x23, 0x60, 0x00,
+    0x00, 0x23, 0x8c, 0x00, 0x00, 0x23, 0xbf, 0x00, 0x00, 0x23, 0xe0, 0x00,
+    0x00, 0x24, 0x09, 0x00, 0x00, 0x24, 0x2b, 0x00, 0x00, 0x24, 0x4f, 0x00,
+    0x00, 0x24, 0x79, 0x00, 0x00, 0x24, 0xa1, 0x00, 0x00, 0x24, 0xc2, 0x00,
+    0x00, 0x24, 0xe6, 0x00, 0x00, 0x25, 0x0f, 0x00, 0x00, 0x25, 0x36, 0x00,
+    0x00, 0x25, 0x63, 0x00, 0x00, 0x25, 0x8e, 0x00, 0x00, 0x25, 0xb7, 0x00,
+    0x00, 0x25, 0xdd, 0x00, 0x00, 0x26, 0x05, 0x00, 0x00, 0x26, 0x2d, 0x00,
+    0x00, 0x26, 0x52, 0x00, 0x00, 0x26, 0x7b, 0x00, 0x00, 0x26, 0x9f, 0x00,
+    0x00, 0x26, 0xc4, 0x00, 0x00, 0x26, 0xef, 0x00, 0x00, 0x27, 0x13, 0x00,
+    0x00, 0x27, 0x3b, 0x00, 0x00, 0x27, 0x60, 0x00, 0x00, 0x27, 0x89, 0x00,
+    0x00, 0x27, 0xaf, 0x00, 0x00, 0x27, 0xd1, 0x00, 0x00, 0x27, 0xf6, 0x00,
+    0x00, 0x28, 0x1b, 0x00, 0x00, 0x28, 0x40, 0x00, 0x00, 0x28, 0x68, 0x00,
+    0x00, 0x28, 0x8e, 0x00, 0x00, 0x28, 0xaf, 0x00, 0x00, 0x28, 0xd0, 0x00,
+    0x00, 0x28, 0xf6, 0x00, 0x00, 0x29, 0x1d, 0x00, 0x00, 0x29, 0x42, 0x00,
+    0x00, 0x29, 0x68, 0x00, 0x00, 0x29, 0x92, 0x00, 0x00, 0x29, 0xb7, 0x00,
+    0x00, 0x29, 0xde, 0x00, 0x00, 0x2a, 0x03, 0x00, 0x00, 0x2a, 0x2e, 0x00,
+    0x00, 0x2a, 0x59, 0x00, 0x00, 0x2a, 0x7b, 0x00, 0x00, 0x2a, 0xa6, 0x00,
+    0x00, 0x2a, 0xc8, 0x00, 0x00, 0x2a, 0xef, 0x00, 0x00, 0x2b, 0x15, 0x00,
+    0x00, 0x2b, 0x3a, 0x00, 0x00, 0x2b, 0x62, 0x00, 0x00, 0x2b, 0x8d, 0x00,
+    0x00, 0x2b, 0xae, 0x00, 0x00, 0x2b, 0xd1, 0x00, 0x00, 0x2b, 0xfa, 0x00,
+    0x00, 0x2c, 0x1d, 0x00, 0x00, 0x2c, 0x3e, 0x00, 0x00, 0x2c, 0x63, 0x00,
+    0x00, 0x2c, 0x87, 0x00, 0x00, 0x2c, 0xae, 0x00, 0x00, 0x2c, 0xd3, 0x00,
+    0x00, 0x2d, 0x00, 0x00, 0x00, 0x2d, 0x21, 0x00, 0x00, 0x2d, 0x46, 0x00,
+    0x00, 0x2d, 0x6f, 0x00, 0x00, 0x2d, 0x93, 0x00, 0x00, 0x2d, 0xb5, 0x00,
+    0x00, 0x2d, 0xde, 0x00, 0x00, 0x2e, 0x06, 0x00, 0x00, 0x2e, 0x32, 0x00,
+    0x00, 0x2e, 0x52, 0x00, 0x00, 0x2e, 0x76, 0x00, 0x00, 0x2e, 0x9b, 0x00,
+    0x00, 0x2e, 0xc1, 0x00, 0x00, 0x2e, 0xe2, 0x00, 0x00, 0x2f, 0x08, 0x00,
+    0x00, 0x2f, 0x31, 0x00, 0x00, 0x2f, 0x5a, 0x00, 0x00, 0x2f, 0x84, 0x00,
+    0x00, 0x2f, 0xa9, 0x00, 0x00, 0x2f, 0xd6, 0x00, 0x00, 0x2f, 0xfc, 0x00,
+    0x00, 0x30, 0x20, 0x00, 0x00, 0x30, 0x45, 0x00, 0x00, 0x30, 0x6e, 0x00,
+    0x00, 0x30, 0x94, 0x00, 0x00, 0x30, 0xba, 0x00, 0x00, 0x30, 0xdd, 0x00,
+    0x00, 0x31, 0x01, 0x00, 0x00, 0x31, 0x28, 0x00, 0x00, 0x31, 0x4f, 0x00,
+    0x00, 0x31, 0x73, 0x00, 0x00, 0x31, 0x98, 0x00, 0x00, 0x31, 0xc3, 0x00,
+    0x00, 0x31, 0xea, 0x00, 0x00, 0x32, 0x0e, 0x00, 0x00, 0x32, 0x35, 0x00,
+    0x00, 0x32, 0x5d, 0x00, 0x00, 0x32, 0x81, 0x00, 0x00, 0x32, 0xa5, 0x00,
+    0x00, 0x32, 0xc9, 0x00, 0x00, 0x32, 0xed, 0x00, 0x00, 0x33, 0x15, 0x00,
+    0x00, 0x33, 0x3a, 0x00, 0x00, 0x33, 0x61, 0x00, 0x00, 0x33, 0x88, 0x00,
+    0x00, 0x33, 0xac, 0x00, 0x00, 0x33, 0xd5, 0x00, 0x00, 0x33, 0xf9, 0x00,
+    0x00, 0x34, 0x20, 0x00, 0x00, 0x34, 0x45, 0x00, 0x00, 0x34, 0x69, 0x00,
+    0x00, 0x34, 0x8a, 0x00, 0x00, 0x34, 0xb1, 0x00, 0x00, 0x34, 0xdb, 0x00,
+    0x00, 0x35, 0x00, 0x00, 0x00, 0x35, 0x26, 0x00, 0x00, 0x35, 0x48, 0x00,
+    0x00, 0x35, 0x72, 0x00, 0x00, 0x35, 0x9b, 0x00, 0x00, 0x35, 0xbe, 0x00,
+    0x00, 0x35, 0xe6, 0x00, 0x00, 0x36, 0x0a, 0x00, 0x00, 0x36, 0x30, 0x00,
+    0x00, 0x36, 0x5e, 0x00, 0x00, 0x36, 0x83, 0x00, 0x00, 0x36, 0xab, 0x00,
+    0x00, 0x36, 0xd4, 0x00, 0x00, 0x36, 0xf7, 0x00, 0x00, 0x37, 0x22, 0x00,
+    0x00, 0x37, 0x44, 0x00, 0x00, 0x37, 0x66, 0x00, 0x00, 0x37, 0x86, 0x00,
+    0x00, 0x37, 0xae, 0x00, 0x00, 0x37, 0xd2, 0x00, 0x00, 0x37, 0xf8, 0x00,
+    0x00, 0x38, 0x1c, 0x00, 0x00, 0x38, 0x44, 0x00, 0x00, 0x38, 0x66, 0x00,
+    0x00, 0x38, 0x88, 0x00, 0x00, 0x38, 0xa8, 0x00, 0x00, 0x38, 0xcb, 0x00,
+    0x00, 0x38, 0xec, 0x00, 0x00, 0x39, 0x12, 0x00, 0x00, 0x39, 0x38, 0x00,
+    0x00, 0x39, 0x65, 0x00, 0x00, 0x39, 0x8b, 0x00, 0x00, 0x39, 0xab, 0x00,
+    0x00, 0x39, 0xcf, 0x00, 0x00, 0x39, 0xf9, 0x00, 0x00, 0x3a, 0x1d, 0x00,
+    0x00, 0x3a, 0x44, 0x00, 0x00, 0x3a, 0x6b, 0x00, 0x00, 0x3a, 0x90, 0x00,
+    0x00, 0x3a, 0xb7, 0x00, 0x00, 0x3a, 0xdf, 0x00, 0x00, 0x3b, 0x06, 0x00,
+    0x00, 0x3b, 0x2a, 0x00, 0x00, 0x3b, 0x4a, 0x00, 0x00, 0x3b, 0x71, 0x00,
+    0x00, 0x3b, 0x94, 0x00, 0x00, 0x3b, 0xbb, 0x00, 0x00, 0x3b, 0xe1, 0x00,
+    0x00, 0x3c, 0x04, 0x00, 0x00, 0x3c, 0x2f, 0x00, 0x00, 0x3c, 0x54, 0x00,
+    0x00, 0x3c, 0x78, 0x00, 0x00, 0x3c, 0xa1, 0x00, 0x00, 0x3c, 0xc7, 0x00,
+    0x00, 0x3c, 0xe9, 0x00, 0x00, 0x3d, 0x0f, 0x00, 0x00, 0x3d, 0x35, 0x00,
+    0x00, 0x3d, 0x5a, 0x00, 0x00, 0x3d, 0x80, 0x00, 0x00, 0x3d, 0xa3, 0x00,
+    0x00, 0x3d, 0xc4, 0x00, 0x00, 0x3d, 0xe7, 0x00, 0x00, 0x3e, 0x0b, 0x00,
+    0x00, 0x3e, 0x31, 0x00, 0x00, 0x3e, 0x53, 0x00, 0x00, 0x3e, 0x7b, 0x00,
+    0x00, 0x3e, 0xa0, 0x00, 0x00, 0x3e, 0xc9, 0x00, 0x00, 0x3e, 0xed, 0x00,
+    0x00, 0x3f, 0x13, 0x00, 0x00, 0x3f, 0x37, 0x00, 0x00, 0x3f, 0x58, 0x00,
+    0x00, 0x3f, 0x7c, 0x00, 0x00, 0x3f, 0xa2, 0x00, 0x00, 0x3f, 0xca, 0x00,
+    0x00, 0x3f, 0xe9, 0x00, 0x00, 0x40, 0x0f, 0x00, 0x00, 0x40, 0x33, 0x00,
+    0x00, 0x40, 0x59, 0x00, 0x00, 0x40, 0x7f, 0x00, 0x00, 0x40, 0xad, 0x00,
+    0x00, 0x40, 0xd7, 0x00, 0x00, 0x41, 0x07, 0x00, 0x00, 0x41, 0x29, 0x00,
+    0x00, 0x41, 0x50, 0x00, 0x00, 0x41, 0x76, 0x00, 0x00, 0x41, 0x99, 0x00,
+    0x00, 0x41, 0xc7, 0x00, 0x00, 0x41, 0xe8, 0x00, 0x00, 0x42, 0x09, 0x00,
+    0x00, 0x42, 0x2d, 0x00, 0x00, 0x42, 0x4f, 0x00, 0x00, 0x42, 0x7d, 0x00,
+    0x00, 0x42, 0xa1, 0x00, 0x00, 0x42, 0xc6, 0x00, 0x00, 0x42, 0xf0, 0x00,
+    0x00, 0x43, 0x17, 0x00, 0x00, 0x43, 0x3e, 0x00, 0x00, 0x43, 0x5f, 0x00,
+    0x00, 0x43, 0x83, 0x00, 0x00, 0x43, 0xa8, 0x00, 0x00, 0x43, 0xce, 0x00,
+    0x00, 0x43, 0xef, 0x00, 0x00, 0x44, 0x19, 0x00, 0x00, 0x44, 0x42, 0x00,
+    0x00, 0x44, 0x64, 0x00, 0x00, 0x44, 0x87, 0x00, 0x00, 0x44, 0xaf, 0x00,
+    0x00, 0x44, 0xdf, 0x00, 0x00, 0x45, 0x03, 0x00, 0x00, 0x45, 0x27, 0x00,
+    0x00, 0x45, 0x52, 0x00, 0x00, 0x45, 0x74, 0x00, 0x00, 0x45, 0x96, 0x00,
+    0x00, 0x45, 0xb8, 0x00, 0x00, 0x45, 0xde, 0x00, 0x00, 0x46, 0x02, 0x00,
+    0x00, 0x46, 0x25, 0x00, 0x00, 0x46, 0x4a, 0x00, 0x00, 0x46, 0x6d, 0x00,
+    0x00, 0x46, 0x8f, 0x00, 0x00, 0x46, 0xb4, 0x00, 0x00, 0x46, 0xde, 0x00,
+    0x00, 0x47, 0x02, 0x00, 0x00, 0x47, 0x28, 0x00, 0x00, 0x47, 0x50, 0x00,
+    0x00, 0x47, 0x79, 0x00, 0x00, 0x47, 0x9d, 0x00, 0x00, 0x47, 0xc0, 0x00,
+    0x00, 0x47, 0xe4, 0x00, 0x00, 0x48, 0x0a, 0x00, 0x00, 0x48, 0x2e, 0x00,
+    0x00, 0x48, 0x55, 0x00, 0x00, 0x48, 0x80, 0x00, 0x00, 0x48, 0xa7, 0x00,
+    0x00, 0x48, 0xcb, 0x00, 0x00, 0x48, 0xef, 0x00, 0x00, 0x49, 0x15, 0x00,
+    0x00, 0x49, 0x38, 0x00, 0x00, 0x49, 0x60, 0x00, 0x00, 0x49, 0x85, 0x00,
+    0x00, 0x49, 0xa9, 0x00, 0x00, 0x49, 0xd5, 0x00, 0x00, 0x49, 0xfd, 0x00,
+    0x00, 0x4a, 0x28, 0x00, 0x00, 0x4a, 0x4d, 0x00, 0x00, 0x4a, 0x73, 0x00,
+    0x00, 0x4a, 0x9e, 0x00, 0x00, 0x4a, 0xc1, 0x00, 0x00, 0x4a, 0xe8, 0x00,
+    0x00, 0x4b, 0x0d, 0x00, 0x00, 0x4b, 0x31, 0x00, 0x00, 0x4b, 0x54, 0x00,
+    0x00, 0x4b, 0x77, 0x00, 0x00, 0x4b, 0x9d, 0x00, 0x00, 0x4b, 0xc2, 0x00,
+    0x00, 0x4b, 0xeb, 0x00, 0x00, 0x4c, 0x13, 0x00, 0x00, 0x4c, 0x3c, 0x00,
+    0x00, 0x4c, 0x61, 0x00, 0x00, 0x4c, 0x87, 0x00, 0x00, 0x4c, 0xaa, 0x00,
+    0x00, 0x4c, 0xd0, 0x00, 0x00, 0x4c, 0xfb, 0x00, 0x00, 0x4d, 0x21, 0x00,
+    0x00, 0x4d, 0x44, 0x00, 0x00, 0x4d, 0x68, 0x00, 0x00, 0x4d, 0x90, 0x00,
+    0x00, 0x4d, 0xb9, 0x00, 0x00, 0x4d, 0xde, 0x00, 0x00, 0x4e, 0x0d, 0x00,
+    0x00, 0x4e, 0x33, 0x00, 0x00, 0x4e, 0x55, 0x00, 0x00, 0x4e, 0x7d, 0x00,
+    0x00, 0x4e, 0xa6, 0x00, 0x00, 0x4e, 0xcc, 0x00, 0x00, 0x4e, 0xf2, 0x00,
+    0x00, 0x4f, 0x15, 0x00, 0x00, 0x4f, 0x38, 0x00, 0x00, 0x4f, 0x5e, 0x00,
+    0x00, 0x4f, 0x83, 0x00, 0x00, 0x4f, 0xac, 0x00, 0x00, 0x4f, 0xd1, 0x00,
+    0x00, 0x4f, 0xf5, 0x00, 0x00, 0x50, 0x1a, 0x00, 0x00, 0x50, 0x40, 0x00,
+    0x00, 0x50, 0x60, 0x00, 0x00, 0x50, 0x81, 0x00, 0x00, 0x50, 0xa8, 0x00,
+    0x00, 0x50, 0xce, 0x00, 0x00, 0x50, 0xf5, 0x00, 0x00, 0x51, 0x22, 0x00,
+    0x00, 0x51, 0x47, 0x00, 0x00, 0x51, 0x6b, 0x00, 0x00, 0x51, 0x92, 0x00,
+    0x00, 0x51, 0xb8, 0x00, 0x00, 0x51, 0xda, 0x00, 0x00, 0x52, 0x01, 0x00,
+    0x00, 0x52, 0x26, 0x00, 0x00, 0x52, 0x4b, 0x00, 0x00, 0x52, 0x74, 0x00,
+    0x00, 0x52, 0x96, 0x00, 0x00, 0x52, 0xbb, 0x00, 0x00, 0x52, 0xe1, 0x00,
+    0x00, 0x53, 0x06, 0x00, 0x00, 0x53, 0x2b, 0x00, 0x00, 0x53, 0x51, 0x00,
+    0x00, 0x53, 0x7a, 0x00, 0x00, 0x53, 0xa3, 0x00, 0x00, 0x53, 0xcd, 0x00,
+    0x00, 0x53, 0xf3, 0x00, 0x00, 0x54, 0x17, 0x00, 0x00, 0x54, 0x3a, 0x00,
+    0x00, 0x54, 0x62, 0x00, 0x00, 0x54, 0x87, 0x00, 0x00, 0x54, 0xae, 0x00,
+    0x00, 0x54, 0xd7, 0x00, 0x00, 0x54, 0xff, 0x00, 0x00, 0x55, 0x24, 0x00,
+    0x00, 0x55, 0x4d, 0x00, 0x00, 0x55, 0x7a, 0x00, 0x00, 0x55, 0xa0, 0x00,
+    0x00, 0x55, 0xc6, 0x00, 0x00, 0x55, 0xe8, 0x00, 0x00, 0x56, 0x10, 0x00,
+    0x00, 0x56, 0x3c, 0x00, 0x00, 0x56, 0x60, 0x00, 0x00, 0x56, 0x89, 0x00,
+    0x00, 0x56, 0xb5, 0x00, 0x00, 0x56, 0xda, 0x00, 0x00, 0x57, 0x00, 0x00,
+    0x00, 0x57, 0x26, 0x00, 0x00, 0x57, 0x47, 0x00, 0x00, 0x57, 0x71, 0x00,
+    0x00, 0x57, 0x94, 0x00, 0x00, 0x57, 0xbc, 0x00, 0x00, 0x57, 0xe0, 0x00,
+    0x00, 0x58, 0x07, 0x00, 0x00, 0x58, 0x2c, 0x00, 0x00, 0x58, 0x52, 0x00,
+    0x00, 0x58, 0x76, 0x00, 0x00, 0x58, 0x9d, 0x00, 0x00, 0x58, 0xc5, 0x00,
+    0x00, 0x58, 0xec, 0x00, 0x00, 0x59, 0x12, 0x00, 0x00, 0x59, 0x38, 0x00,
+    0x00, 0x59, 0x58, 0x00, 0x00, 0x59, 0x7f, 0x00, 0x00, 0x59, 0xa4, 0x00,
+    0x00, 0x59, 0xc9, 0x00, 0x00, 0x59, 0xef, 0x00, 0x00, 0x5a, 0x12, 0x00,
+    0x00, 0x5a, 0x3b, 0x00, 0x00, 0x5a, 0x67, 0x00, 0x00, 0x5a, 0x88, 0x00,
+    0x00, 0x5a, 0xb0, 0x00, 0x00, 0x5a, 0xd6, 0x00, 0x00, 0x5a, 0xf9, 0x00,
+    0x00, 0x5b, 0x1d, 0x00, 0x00, 0x5b, 0x43, 0x00, 0x00, 0x5b, 0x68, 0x00,
+    0x00, 0x5b, 0x90, 0x00, 0x00, 0x5b, 0xb6, 0x00, 0x00, 0x5b, 0xdc, 0x00,
+    0x00, 0x5c, 0x02, 0x00, 0x00, 0x5c, 0x27, 0x00, 0x00, 0x5c, 0x4c, 0x00,
+    0x00, 0x5c, 0x6f, 0x00, 0x00, 0x5c, 0x90, 0x00, 0x00, 0x5c, 0xb2, 0x00,
+    0x00, 0x5c, 0xd7, 0x00, 0x00, 0x5c, 0xfb, 0x00, 0x00, 0x5d, 0x21, 0x00,
+    0x00, 0x5d, 0x44, 0x00, 0x00, 0x5d, 0x6a, 0x00, 0x00, 0x5d, 0x8e, 0x00,
+    0x00, 0x5d, 0xb2, 0x00, 0x00, 0x5d, 0xd4, 0x00, 0x00, 0x5d, 0xfa, 0x00,
+    0x00, 0x5e, 0x1a, 0x00, 0x00, 0x5e, 0x40, 0x00, 0x00, 0x5e, 0x64, 0x00,
+    0x00, 0x5e, 0x8d, 0x00, 0x00, 0x5e, 0xb5, 0x00, 0x00, 0x5e, 0xd7, 0x00,
+    0x00, 0x5e, 0xfa, 0x00, 0x00, 0x5f, 0x1b, 0x00, 0x00, 0x5f, 0x42, 0x00,
+    0x00, 0x5f, 0x6a, 0x00, 0x00, 0x5f, 0x8f, 0x00, 0x00, 0x5f, 0xb2, 0x00,
+    0x00, 0x5f, 0xd8, 0x00, 0x00, 0x60, 0x02, 0x00, 0x00, 0x60, 0x27, 0x00,
+    0x00, 0x60, 0x4e, 0x00, 0x00, 0x60, 0x75, 0x00, 0x00, 0x60, 0x97, 0x00,
+    0x00, 0x60, 0xba, 0x00, 0x00, 0x60, 0xdf, 0x00, 0x00, 0x61, 0x04, 0x00,
+    0x00, 0x61, 0x2d, 0x00, 0x00, 0x61, 0x53, 0x00, 0x00, 0x61, 0x7f, 0x00,
+    0x00, 0x61, 0xa9, 0x00, 0x00, 0x61, 0xce, 0x00, 0x00, 0x61, 0xf1, 0x00,
+    0x00, 0x62, 0x14, 0x00, 0x00, 0x62, 0x3a, 0x00, 0x00, 0x62, 0x6a, 0x00,
+    0x00, 0x62, 0x94, 0x00, 0x00, 0x62, 0xb8, 0x00, 0x00, 0x62, 0xdd, 0x00,
+    0x00, 0x62, 0xff, 0x00, 0x00, 0x63, 0x26, 0x00, 0x00, 0x63, 0x4b, 0x00,
+    0x00, 0x63, 0x6e, 0x00, 0x00, 0x63, 0x90, 0x00, 0x00, 0x63, 0xba, 0x00,
+    0x00, 0x63, 0xe1, 0x00, 0x00, 0x64, 0x01, 0x00, 0x00, 0x64, 0x1f, 0x00,
+    0x00, 0x64, 0x40, 0x00, 0x00, 0x64, 0x66, 0x00, 0x00, 0x64, 0x8d, 0x00,
+    0x00, 0x64, 0xae, 0x00, 0x00, 0x64, 0xd3, 0x00, 0x00, 0x64, 0xf8, 0x00,
+    0x00, 0x65, 0x1b, 0x00, 0x00, 0x65, 0x41, 0x00, 0x00, 0x65, 0x69, 0x00,
+    0x00, 0x65, 0x8d, 0x00, 0x00, 0x65, 0xb0, 0x00, 0x00, 0x65, 0xd2, 0x00,
+    0x00, 0x65, 0xf9, 0x00, 0x00, 0x66, 0x1e, 0x00, 0x00, 0x66, 0x44, 0x00,
+    0x00, 0x66, 0x66, 0x00, 0x00, 0x66, 0x8b, 0x00, 0x00, 0x66, 0xb4, 0x00,
+    0x00, 0x66, 0xda, 0x00, 0x00, 0x66, 0xfe, 0x00, 0x00, 0x67, 0x22, 0x00,
+    0x00, 0x67, 0x46, 0x00, 0x00, 0x67, 0x6c, 0x00, 0x00, 0x67, 0x9c, 0x00,
+    0x00, 0x67, 0xc2, 0x00, 0x00, 0x67, 0xe7, 0x00, 0x00, 0x68, 0x0d, 0x00,
+    0x00, 0x68, 0x31, 0x00, 0x00, 0x68, 0x5c, 0x00, 0x00, 0x68, 0x85, 0x00,
+    0x00, 0x68, 0xaa, 0x00, 0x00, 0x68, 0xce, 0x00, 0x00, 0x68, 0xf4, 0x00,
+    0x00, 0x69, 0x1b, 0x00, 0x00, 0x69, 0x41, 0x00, 0x00, 0x69, 0x63, 0x00,
+    0x00, 0x69, 0x89, 0x00, 0x00, 0x69, 0xab, 0x00, 0x00, 0x69, 0xd3, 0x00,
+    0x00, 0x69, 0xfa, 0x00, 0x00, 0x6a, 0x26, 0x00, 0x00, 0x6a, 0x56, 0x00,
+    0x00, 0x6a, 0x83, 0x00, 0x00, 0x6a, 0xa9, 0x00, 0x00, 0x6a, 0xd0, 0x00,
+    0x00, 0x6a, 0xf5, 0x00, 0x00, 0x6b, 0x1f, 0x00, 0x00, 0x6b, 0x44, 0x00,
+    0x00, 0x6b, 0x69, 0x00, 0x00, 0x6b, 0x92, 0x00, 0x00, 0x6b, 0xb7, 0x00,
+    0x00, 0x6b, 0xe2, 0x00, 0x00, 0x6c, 0x04, 0x00, 0x00, 0x6c, 0x24, 0x00,
+    0x00, 0x6c, 0x4e, 0x00, 0x00, 0x6c, 0x75, 0x00, 0x00, 0x6c, 0x97, 0x00,
+    0x00, 0x6c, 0xbe, 0x00, 0x00, 0x6c, 0xdf, 0x00, 0x00, 0x6c, 0xff, 0x00,
+    0x00, 0x6d, 0x2b, 0x00, 0x00, 0x6d, 0x51, 0x00, 0x00, 0x6d, 0x7b, 0x00,
+    0x00, 0x6d, 0xa0, 0x00, 0x00, 0x6d, 0xd0, 0x00, 0x00, 0x6d, 0xf5, 0x00,
+    0x00, 0x6e, 0x16, 0x00, 0x00, 0x6e, 0x40, 0x00, 0x00, 0x6e, 0x6b, 0x00,
+    0x00, 0x6e, 0x91, 0x00, 0x00, 0x6e, 0xbb, 0x00, 0x00, 0x6e, 0xdf, 0x00,
+    0x00, 0x6f, 0x01, 0x00, 0x00, 0x6f, 0x27, 0x00, 0x00, 0x6f, 0x4a, 0x00,
+    0x00, 0x6f, 0x71, 0x00, 0x00, 0x6f, 0x96, 0x00, 0x00, 0x6f, 0xbf, 0x00,
+    0x00, 0x6f, 0xe6, 0x00, 0x00, 0x70, 0x0f, 0x00, 0x00, 0x70, 0x3b, 0x00,
+    0x00, 0x70, 0x64, 0x00, 0x00, 0x70, 0x8a, 0x00, 0x00, 0x70, 0xae, 0x00,
+    0x00, 0x70, 0xd2, 0x00, 0x00, 0x70, 0xf9, 0x00, 0x00, 0x71, 0x19, 0x00,
+    0x00, 0x71, 0x43, 0x00, 0x00, 0x71, 0x6f, 0x00, 0x00, 0x71, 0x92, 0x00,
+    0x00, 0x71, 0xb4, 0x00, 0x00, 0x71, 0xdb, 0x00, 0x00, 0x72, 0x02, 0x00,
+    0x00, 0x72, 0x28, 0x00, 0x00, 0x72, 0x4c, 0x00, 0x00, 0x72, 0x74, 0x00,
+    0x00, 0x72, 0x9e, 0x00, 0x00, 0x72, 0xc1, 0x00, 0x00, 0x72, 0xeb, 0x00,
+    0x00, 0x73, 0x16, 0x00, 0x00, 0x73, 0x38, 0x00, 0x00, 0x73, 0x5c, 0x00,
+    0x00, 0x73, 0x81, 0x00, 0x00, 0x73, 0xaf, 0x00, 0x00, 0x73, 0xd6, 0x00,
+    0x00, 0x73, 0xfa, 0x00, 0x00, 0x74, 0x1d, 0x00, 0x00, 0x74, 0x43, 0x00,
+    0x00, 0x74, 0x65, 0x00, 0x00, 0x74, 0x8a, 0x00, 0x00, 0x74, 0xb7, 0x00,
+    0x00, 0x74, 0xdf, 0x00, 0x00, 0x75, 0x03, 0x00, 0x00, 0x75, 0x2a, 0x00,
+    0x00, 0x75, 0x53, 0x00, 0x00, 0x75, 0x7d, 0x00, 0x00, 0x75, 0xa7, 0x00,
+    0x00, 0x75, 0xca, 0x00, 0x00, 0x75, 0xed, 0x00, 0x00, 0x76, 0x15, 0x00,
+    0x00, 0x76, 0x38, 0x00, 0x00, 0x76, 0x60, 0x00, 0x00, 0x76, 0x85, 0x00,
+    0x00, 0x76, 0xaf, 0x00, 0x00, 0x76, 0xd8, 0x00, 0x00, 0x76, 0xfd, 0x00,
+    0x00, 0x77, 0x29, 0x00, 0x00, 0x77, 0x50, 0x00, 0x00, 0x77, 0x74, 0x00,
+    0x00, 0x77, 0x98, 0x00, 0x00, 0x77, 0xbd, 0x00, 0x00, 0x77, 0xde, 0x00,
+    0x00, 0x77, 0xff, 0x00, 0x00, 0x78, 0x28, 0x00, 0x00, 0x78, 0x4f, 0x00,
+    0x00, 0x78, 0x79, 0x00, 0x00, 0x78, 0xa5, 0x00, 0x00, 0x78, 0xd0, 0x00,
+    0x00, 0x78, 0xf6, 0x00, 0x00, 0x79, 0x1b, 0x00, 0x00, 0x79, 0x3f, 0x00,
+    0x00, 0x79, 0x64, 0x00, 0x00, 0x79, 0x8a, 0x00, 0x00, 0x79, 0xb0, 0x00,
+    0x00, 0x79, 0xd6, 0x00, 0x00, 0x79, 0xfc, 0x00, 0x00, 0x7a, 0x1e, 0x00,
+    0x00, 0x7a, 0x40, 0x00, 0x00, 0x7a, 0x62, 0x00, 0x00, 0x7a, 0x87, 0x00,
+    0x00, 0x7a, 0xaa, 0x00, 0x00, 0x7a, 0xcd, 0x00, 0x00, 0x7a, 0xf0, 0x00,
+    0x00, 0x7b, 0x18, 0x00, 0x00, 0x7b, 0x41, 0x00, 0x00, 0x7b, 0x67, 0x00,
+    0x00, 0x7b, 0x8f, 0x00, 0x00, 0x7b, 0xaf, 0x00, 0x00, 0x7b, 0xd2, 0x00,
+    0x00, 0x7b, 0xf7, 0x00, 0x00, 0x7c, 0x1a, 0x00, 0x00, 0x7c, 0x3d, 0x00,
+    0x00, 0x7c, 0x60, 0x00, 0x00, 0x7c, 0x8c, 0x00, 0x00, 0x7c, 0xaf, 0x00,
+    0x00, 0x7c, 0xd3, 0x00, 0x00, 0x7c, 0xf2, 0x00, 0x00, 0x7d, 0x19, 0x00,
+    0x00, 0x7d, 0x3f, 0x00, 0x00, 0x7d, 0x6c, 0x00, 0x00, 0x7d, 0x91, 0x00,
+    0x00, 0x7d, 0xb5, 0x00, 0x00, 0x7d, 0xda, 0x00, 0x00, 0x7e, 0x02, 0x00,
+    0x00, 0x7e, 0x27, 0x00, 0x00, 0x7e, 0x4d, 0x00, 0x00, 0x7e, 0x6d, 0x00,
+    0x00, 0x7e, 0x90, 0x00, 0x00, 0x7e, 0xb6, 0x00, 0x00, 0x7e, 0xda, 0x00,
+    0x00, 0x7f, 0x02, 0x00, 0x00, 0x7f, 0x26, 0x00, 0x00, 0x7f, 0x4e, 0x00,
+    0x00, 0x7f, 0x74, 0x00, 0x00, 0x7f, 0x97, 0x00, 0x00, 0x7f, 0xc0, 0x00,
+    0x00, 0x7f, 0xe6, 0x00, 0x00, 0x80, 0x07, 0x00, 0x00, 0x80, 0x2c, 0x00,
+    0x00, 0x80, 0x52, 0x00, 0x00, 0x80, 0x73, 0x00, 0x00, 0x80, 0x97, 0x00,
+    0x00, 0x80, 0xbc, 0x00, 0x00, 0x80, 0xea, 0x00, 0x00, 0x81, 0x13, 0x00,
+    0x00, 0x81, 0x37, 0x00, 0x00, 0x81, 0x62, 0x00, 0x00, 0x81, 0x88, 0x00,
+    0x00, 0x81, 0xad, 0x00, 0x00, 0x81, 0xd8, 0x00, 0x00, 0x81, 0xfd, 0x00,
+    0x00, 0x82, 0x26, 0x00, 0x00, 0x82, 0x49, 0x00, 0x00, 0x82, 0x69, 0x00,
+    0x00, 0x82, 0x8f, 0x00, 0x00, 0x82, 0xb5, 0x00, 0x00, 0x82, 0xda, 0x00,
+    0x00, 0x83, 0x00, 0x00, 0x00, 0x83, 0x26, 0x00, 0x00, 0x83, 0x4b, 0x00,
+    0x00, 0x83, 0x71, 0x00, 0x00, 0x83, 0x98, 0x00, 0x00, 0x83, 0xbc, 0x00,
+    0x00, 0x83, 0xe1, 0x00, 0x00, 0x84, 0x0d, 0x00, 0x00, 0x84, 0x34, 0x00,
+    0x00, 0x84, 0x59, 0x00, 0x00, 0x84, 0x79, 0x00, 0x00, 0x84, 0xa9, 0x00,
+    0x00, 0x84, 0xcf, 0x00, 0x00, 0x84, 0xf1, 0x00, 0x00, 0x85, 0x13, 0x00,
+    0x00, 0x85, 0x3e, 0x00, 0x00, 0x85, 0x62, 0x00, 0x00, 0x85, 0x89, 0x00,
+    0x00, 0x85, 0xae, 0x00, 0x00, 0x85, 0xd8, 0x00, 0x00, 0x85, 0xff, 0x00,
+    0x00, 0x86, 0x21, 0x00, 0x00, 0x86, 0x41, 0x00, 0x00, 0x86, 0x60, 0x00,
+    0x00, 0x86, 0x85, 0x00, 0x00, 0x86, 0xb0, 0x00, 0x00, 0x86, 0xd9, 0x00,
+    0x00, 0x86, 0xf9, 0x00, 0x00, 0x87, 0x25, 0x00, 0x00, 0x87, 0x54, 0x00,
+    0x00, 0x87, 0x7e, 0x00, 0x00, 0x87, 0xa3, 0x00, 0x00, 0x87, 0xc5, 0x00,
+    0x00, 0x87, 0xe7, 0x00, 0x00, 0x88, 0x0b, 0x00, 0x00, 0x88, 0x2c, 0x00,
+    0x00, 0x88, 0x56, 0x00, 0x00, 0x88, 0x7c, 0x00, 0x00, 0x88, 0xa3, 0x00,
+    0x00, 0x88, 0xcf, 0x00, 0x00, 0x88, 0xf6, 0x00, 0x00, 0x89, 0x1e, 0x00,
+    0x00, 0x89, 0x44, 0x00, 0x00, 0x89, 0x6a, 0x00, 0x00, 0x89, 0x8e, 0x00,
+    0x00, 0x89, 0xb2, 0x00, 0x00, 0x89, 0xd5, 0x00, 0x00, 0x89, 0xf7, 0x00,
+    0x00, 0x8a, 0x1e, 0x00, 0x00, 0x8a, 0x46, 0x00, 0x00, 0x8a, 0x6b, 0x00,
+    0x00, 0x8a, 0x92, 0x00, 0x00, 0x8a, 0xb6, 0x00, 0x00, 0x8a, 0xdd, 0x00,
+    0x00, 0x8b, 0x02, 0x00, 0x00, 0x8b, 0x2a, 0x00, 0x00, 0x8b, 0x50, 0x00,
+    0x00, 0x8b, 0x76, 0x00, 0x00, 0x8b, 0xa9, 0x00, 0x00, 0x8b, 0xcb, 0x00,
+    0x00, 0x8b, 0xee, 0x00, 0x00, 0x8c, 0x13, 0x00, 0x00, 0x8c, 0x37, 0x00,
+    0x00, 0x8c, 0x59, 0x00, 0x00, 0x8c, 0x7e, 0x00, 0x00, 0x8c, 0xa5, 0x00,
+    0x00, 0x8c, 0xc8, 0x00, 0x00, 0x8c, 0xed, 0x00, 0x00, 0x8d, 0x0e, 0x00,
+    0x00, 0x8d, 0x32, 0x00, 0x00, 0x8d, 0x56, 0x00, 0x00, 0x8d, 0x7a, 0x00,
+    0x00, 0x8d, 0x9e, 0x00, 0x00, 0x8d, 0xc3, 0x00, 0x00, 0x8d, 0xe8, 0x00,
+    0x00, 0x8e, 0x11, 0x00, 0x00, 0x8e, 0x36, 0x00, 0x00, 0x8e, 0x5e, 0x00,
+    0x00, 0x8e, 0x81, 0x00, 0x00, 0x8e, 0xab, 0x00, 0x00, 0x8e, 0xd1, 0x00,
+    0x00, 0x8e, 0xf4, 0x00, 0x00, 0x8f, 0x19, 0x00, 0x00, 0x8f, 0x42, 0x00,
+    0x00, 0x8f, 0x68, 0x00, 0x00, 0x8f, 0x8e, 0x00, 0x00, 0x8f, 0xb3, 0x00,
+    0x00, 0x8f, 0xd7, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x90, 0x2a, 0x00,
+    0x00, 0x90, 0x55, 0x00, 0x00, 0x90, 0x81, 0x00, 0x00, 0x90, 0xa6, 0x00,
+    0x00, 0x90, 0xca, 0x00, 0x00, 0x90, 0xee, 0x00, 0x00, 0x91, 0x13, 0x00,
+    0x00, 0x91, 0x38, 0x00, 0x00, 0x91, 0x67, 0x00, 0x00, 0x91, 0x8b, 0x00,
+    0x00, 0x91, 0xb2, 0x00, 0x00, 0x91, 0xe1, 0x00, 0x00, 0x92, 0x03, 0x00,
+    0x00, 0x92, 0x26, 0x00, 0x00, 0x92, 0x4f, 0x00, 0x00, 0x92, 0x72, 0x00,
+    0x00, 0x92, 0x9e, 0x00, 0x00, 0x92, 0xc0, 0x00, 0x00, 0x92, 0xe8, 0x00,
+    0x00, 0x93, 0x08, 0x00, 0x00, 0x93, 0x2e, 0x00, 0x00, 0x93, 0x5c, 0x00,
+    0x00, 0x93, 0x80, 0x00, 0x00, 0x93, 0xa4, 0x00, 0x00, 0x93, 0xcb, 0x00,
+    0x00, 0x93, 0xef, 0x00, 0x00, 0x94, 0x0f, 0x00, 0x00, 0x94, 0x32, 0x00,
+    0x00, 0x94, 0x55, 0x00, 0x00, 0x94, 0x7a, 0x00, 0x00, 0x94, 0xa0, 0x00,
+    0x00, 0x94, 0xc7, 0x00, 0x00, 0x94, 0xf1, 0x00, 0x00, 0x95, 0x1b, 0x00,
+    0x00, 0x95, 0x41, 0x00, 0x00, 0x95, 0x63, 0x00, 0x00, 0x95, 0x8a, 0x00,
+    0x00, 0x95, 0xb0, 0x00, 0x00, 0x95, 0xd7, 0x00, 0x00, 0x95, 0xfc, 0x00,
+    0x00, 0x96, 0x1d, 0x00, 0x00, 0x96, 0x44, 0x00, 0x00, 0x96, 0x69, 0x00,
+    0x00, 0x96, 0x8f, 0x00, 0x00, 0x96, 0xb6, 0x00, 0x00, 0x96, 0xdf, 0x00,
+    0x00, 0x97, 0x06, 0x00, 0x00, 0x97, 0x2d, 0x00, 0x00, 0x97, 0x4d, 0x00,
+    0x00, 0x97, 0x74, 0x00, 0x00, 0x97, 0x9d, 0x00, 0x00, 0x97, 0xc0, 0x00,
+    0x00, 0x97, 0xe7, 0x00, 0x00, 0x98, 0x10, 0x00, 0x00, 0x98, 0x35, 0x00,
+    0x00, 0x98, 0x5f, 0x00, 0x00, 0x98, 0x81, 0x00, 0x00, 0x98, 0xa3, 0x00,
+    0x00, 0x98, 0xcc, 0x00, 0x00, 0x98, 0xed, 0x00, 0x00, 0x99, 0x15, 0x00,
+    0x00, 0x99, 0x3d, 0x00, 0x00, 0x99, 0x61, 0x00, 0x00, 0x99, 0x8a, 0x00,
+    0x00, 0x99, 0xb5, 0x00, 0x00, 0x99, 0xdd, 0x00, 0x00, 0x9a, 0x01, 0x00,
+    0x00, 0x9a, 0x27, 0x00, 0x00, 0x9a, 0x49, 0x00, 0x00, 0x9a, 0x6e, 0x00,
+    0x00, 0x9a, 0x98, 0x00, 0x00, 0x9a, 0xc1, 0x00, 0x00, 0x9a, 0xe4, 0x00,
+    0x00, 0x9b, 0x08, 0x00, 0x00, 0x9b, 0x2b, 0x00, 0x00, 0x9b, 0x50, 0x00,
+    0x00, 0x9b, 0x76, 0x00, 0x00, 0x9b, 0x98, 0x00, 0x00, 0x9b, 0xc5, 0x00,
+    0x00, 0x9b, 0xea, 0x00, 0x00, 0x9c, 0x12, 0x00, 0x00, 0x9c, 0x39, 0x00,
+    0x00, 0x9c, 0x5d, 0x00, 0x00, 0x9c, 0x80, 0x00, 0x00, 0x9c, 0xa5, 0x00,
+    0x00, 0x9c, 0xcb, 0x00, 0x00, 0x9c, 0xef, 0x00, 0x00, 0x9d, 0x1a, 0x00,
+    0x00, 0x9d, 0x3b, 0x00, 0x00, 0x9d, 0x65, 0x00, 0x00, 0x9d, 0x8b, 0x00,
+    0x00, 0x9d, 0xae, 0x00, 0x00, 0x9d, 0xd5, 0x00, 0x00, 0x9d, 0xf9, 0x00,
+    0x00, 0x9e, 0x1d, 0x00, 0x00, 0x9e, 0x42, 0x00, 0x00, 0x9e, 0x73, 0x00,
+    0x00, 0x9e, 0x9c, 0x00, 0x00, 0x9e, 0xc1, 0x00, 0x00, 0x9e, 0xeb, 0x00,
+    0x00, 0x9f, 0x11, 0x00, 0x00, 0x9f, 0x34, 0x00, 0x00, 0x9f, 0x60, 0x00,
+    0x00, 0x9f, 0x83, 0x00, 0x00, 0x9f, 0xa9, 0x00, 0x00, 0x9f, 0xcc, 0x00,
+    0x00, 0x9f, 0xf7, 0x00, 0x00, 0xa0, 0x1e, 0x00, 0x00, 0xa0, 0x3e, 0x00,
+    0x00, 0xa0, 0x64, 0x00, 0x00, 0xa0, 0x8c, 0x00, 0x00, 0xa0, 0xb5, 0x00,
+    0x00, 0xa0, 0xda, 0x00, 0x00, 0xa1, 0x02, 0x00, 0x00, 0xa1, 0x28, 0x00,
+    0x00, 0xa1, 0x49, 0x00, 0x00, 0xa1, 0x6e, 0x00, 0x00, 0xa1, 0x91, 0x00,
+    0x00, 0xa1, 0xbe, 0x00, 0x00, 0xa1, 0xe3, 0x00, 0x00, 0xa2, 0x08, 0x00,
+    0x00, 0xa2, 0x2c, 0x00, 0x00, 0xa2, 0x4f, 0x00, 0x00, 0xa2, 0x70, 0x00,
+    0x00, 0xa2, 0x95, 0x00, 0x00, 0xa2, 0xbc, 0x00, 0x00, 0xa2, 0xe5, 0x00,
+    0x00, 0xa3, 0x0e, 0x00, 0x00, 0xa3, 0x34, 0x00, 0x00, 0xa3, 0x57, 0x00,
+    0x00, 0xa3, 0x7b, 0x00, 0x00, 0xa3, 0x9d, 0x00, 0x00, 0xa3, 0xc8, 0x00,
+    0x00, 0xa3, 0xec, 0x00, 0x00, 0xa4, 0x12, 0x00, 0x00, 0xa4, 0x36, 0x00,
+    0x00, 0xa4, 0x5a, 0x00, 0x00, 0xa4, 0x81, 0x00, 0x00, 0xa4, 0xa9, 0x00,
+    0x00, 0xa4, 0xcf, 0x00, 0x00, 0xa4, 0xf8, 0x00, 0x00, 0xa5, 0x1e, 0x00,
+    0x00, 0xa5, 0x48, 0x00, 0x00, 0xa5, 0x6d, 0x00, 0x00, 0xa5, 0x91, 0x00,
+    0x00, 0xa5, 0xb3, 0x00, 0x00, 0xa5, 0xd7, 0x00, 0x00, 0xa5, 0xff, 0x00,
+    0x00, 0xa6, 0x22, 0x00, 0x00, 0xa6, 0x49, 0x00, 0x00, 0xa6, 0x6e, 0x00,
+    0x00, 0xa6, 0x8f, 0x00, 0x00, 0xa6, 0xb4, 0x00, 0x00, 0xa6, 0xdc, 0x00,
+    0x00, 0xa7, 0x00, 0x00, 0x00, 0xa7, 0x2e, 0x00, 0x00, 0xa7, 0x5a, 0x00,
+    0x00, 0xa7, 0x7f, 0x00, 0x00, 0xa7, 0xa3, 0x00, 0x00, 0xa7, 0xc5, 0x00,
+    0x00, 0xa7, 0xe7, 0x00, 0x00, 0xa8, 0x11, 0x00, 0x00, 0xa8, 0x34, 0x00,
+    0x00, 0xa8, 0x5a, 0x00, 0x00, 0xa8, 0x7b, 0x00, 0x00, 0xa8, 0x9f, 0x00,
+    0x00, 0xa8, 0xc7, 0x00, 0x00, 0xa8, 0xec, 0x00, 0x00, 0xa9, 0x12, 0x00,
+    0x00, 0xa9, 0x39, 0x00, 0x00, 0xa9, 0x5e, 0x00, 0x00, 0xa9, 0x82, 0x00,
+    0x00, 0xa9, 0xa7, 0x00, 0x00, 0xa9, 0xcc, 0x00, 0x00, 0xa9, 0xf0, 0x00,
+    0x00, 0xaa, 0x19, 0x00, 0x00, 0xaa, 0x3c, 0x00, 0x00, 0xaa, 0x60, 0x00,
+    0x00, 0xaa, 0x87, 0x00, 0x00, 0xaa, 0xa9, 0x00, 0x00, 0xaa, 0xcd, 0x00,
+    0x00, 0xaa, 0xf1, 0x00, 0x00, 0xab, 0x1e, 0x00, 0x00, 0xab, 0x45, 0x00,
+    0x00, 0xab, 0x6a, 0x00, 0x00, 0xab, 0x93, 0x00, 0x00, 0xab, 0xb9, 0x00,
+    0x00, 0xab, 0xe7, 0x00, 0x00, 0xac, 0x09, 0x00, 0x00, 0xac, 0x28, 0x00,
+    0x00, 0xac, 0x4b, 0x00, 0x00, 0xac, 0x6e, 0x00, 0x00, 0xac, 0x93, 0x00,
+    0x00, 0xac, 0xba, 0x00, 0x00, 0xac, 0xe0, 0x00, 0x00, 0xad, 0x08, 0x00,
+    0x00, 0xad, 0x2c, 0x00, 0x00, 0xad, 0x4e, 0x00, 0x00, 0xad, 0x72, 0x00,
+    0x00, 0xad, 0x97, 0x00, 0x00, 0xad, 0xbe, 0x00, 0x00, 0xad, 0xe3, 0x00,
+    0x00, 0xae, 0x0b, 0x00, 0x00, 0xae, 0x30, 0x00, 0x00, 0xae, 0x56, 0x00,
+    0x00, 0xae, 0x7d, 0x00, 0x00, 0xae, 0xa6, 0x00, 0x00, 0xae, 0xd2, 0x00,
+    0x00, 0xae, 0xf7, 0x00, 0x00, 0xaf, 0x1e, 0x00, 0x00, 0xaf, 0x45, 0x00,
+    0x00, 0xaf, 0x71, 0x00, 0x00, 0xaf, 0x9b, 0x00, 0x00, 0xaf, 0xc4, 0x00,
+    0x00, 0xaf, 0xe5, 0x00, 0x00, 0xb0, 0x05, 0x00, 0x00, 0xb0, 0x32, 0x00,
+    0x00, 0xb0, 0x56, 0x00, 0x00, 0xb0, 0x78, 0x00, 0x00, 0xb0, 0x9a, 0x00,
+    0x00, 0xb0, 0xc1, 0x00, 0x00, 0xb0, 0xed, 0x00, 0x00, 0xb1, 0x12, 0x00,
+    0x00, 0xb1, 0x3b, 0x00, 0x00, 0xb1, 0x5f, 0x00, 0x00, 0xb1, 0x88, 0x00,
+    0x00, 0xb1, 0xb3, 0x00, 0x00, 0xb1, 0xd7, 0x00, 0x00, 0xb1, 0xfc, 0x00,
+    0x00, 0xb2, 0x1e, 0x00, 0x00, 0xb2, 0x45, 0x00, 0x00, 0xb2, 0x68, 0x00,
+    0x00, 0xb2, 0x92, 0x00, 0x00, 0xb2, 0xb6, 0x00, 0x00, 0xb2, 0xdf, 0x00,
+    0x00, 0xb3, 0x08, 0x00, 0x00, 0xb3, 0x2a, 0x00, 0x00, 0xb3, 0x53, 0x00,
+    0x00, 0xb3, 0x77, 0x00, 0x00, 0xb3, 0x9a, 0x00, 0x00, 0xb3, 0xc5, 0x00,
+    0x00, 0xb3, 0xf1, 0x00, 0x00, 0xb4, 0x18, 0x00, 0x00, 0xb4, 0x3a, 0x00,
+    0x00, 0xb4, 0x60, 0x00, 0x00, 0xb4, 0x86, 0x00, 0x00, 0xb4, 0xaf, 0x00,
+    0x00, 0xb4, 0xd8, 0x00, 0x00, 0xb5, 0x05, 0x00, 0x00, 0xb5, 0x2c, 0x00,
+    0x00, 0xb5, 0x54, 0x00, 0x00, 0xb5, 0x7a, 0x00, 0x00, 0xb5, 0xa3, 0x00,
+    0x00, 0xb5, 0xc7, 0x00, 0x00, 0xb5, 0xef, 0x00, 0x00, 0xb6, 0x14, 0x00,
+    0x00, 0xb6, 0x3b, 0x00, 0x00, 0xb6, 0x61, 0x00, 0x00, 0xb6, 0x8c, 0x00,
+    0x00, 0xb6, 0xb0, 0x00, 0x00, 0xb6, 0xdc, 0x00, 0x00, 0xb7, 0x02, 0x00,
+    0x00, 0xb7, 0x2b, 0x00, 0x00, 0xb7, 0x50, 0x00, 0x00, 0xb7, 0x77, 0x00,
+    0x00, 0xb7, 0xa2, 0x00, 0x00, 0xb7, 0xce, 0x00, 0x00, 0xb7, 0xf3, 0x00,
+    0x00, 0xb8, 0x19, 0x00, 0x00, 0xb8, 0x40, 0x00, 0x00, 0xb8, 0x68, 0x00,
+    0x00, 0xb8, 0x89, 0x00, 0x00, 0xb8, 0xac, 0x00, 0x00, 0xb8, 0xcf, 0x00,
+    0x00, 0xb8, 0xf1, 0x00, 0x00, 0xb9, 0x15, 0x00, 0x00, 0xb9, 0x3c, 0x00,
+    0x00, 0xb9, 0x61, 0x00, 0x00, 0xb9, 0x84, 0x00, 0x00, 0xb9, 0xaa, 0x00,
+    0x00, 0xb9, 0xd1, 0x00, 0x00, 0xb9, 0xf5, 0x00, 0x00, 0xba, 0x1d, 0x00,
+    0x00, 0xba, 0x3f, 0x00, 0x00, 0xba, 0x65, 0x00, 0x00, 0xba, 0x8d, 0x00,
+    0x00, 0xba, 0xb3, 0x00, 0x00, 0xba, 0xd6, 0x00, 0x00, 0xba, 0xf7, 0x00,
+    0x00, 0xbb, 0x1b, 0x00, 0x00, 0xbb, 0x41, 0x00, 0x00, 0xbb, 0x66, 0x00,
+    0x00, 0xbb, 0x88, 0x00, 0x00, 0xbb, 0xad, 0x00, 0x00, 0xbb, 0xd2, 0x00,
+    0x00, 0xbb, 0xf7, 0x00, 0x00, 0xbc, 0x1a, 0x00, 0x00, 0xbc, 0x3c, 0x00,
+    0x00, 0xbc, 0x62, 0x00, 0x00, 0xbc, 0x89, 0x00, 0x00, 0xbc, 0xac, 0x00,
+    0x00, 0xbc, 0xcf, 0x00, 0x00, 0xbc, 0xf2, 0x00, 0x00, 0xbd, 0x19, 0x00,
+    0x00, 0xbd, 0x3c, 0x00, 0x00, 0xbd, 0x5e, 0x00, 0x00, 0xbd, 0x87, 0x00,
+    0x00, 0xbd, 0xac, 0x00, 0x00, 0xbd, 0xcf, 0x00, 0x00, 0xbd, 0xee, 0x00,
+    0x00, 0xbe, 0x13, 0x00, 0x00, 0xbe, 0x3a, 0x00, 0x00, 0xbe, 0x61, 0x00,
+    0x00, 0xbe, 0x87, 0x00, 0x00, 0xbe, 0xad, 0x00, 0x00, 0xbe, 0xd6, 0x00,
+    0x00, 0xbf, 0x02, 0x00, 0x00, 0xbf, 0x29, 0x00, 0x00, 0xbf, 0x52, 0x00,
+    0x00, 0xbf, 0x77, 0x00, 0x00, 0xbf, 0x9e, 0x00, 0x00, 0xbf, 0xcd, 0x00,
+    0x00, 0xbf, 0xf5, 0x00, 0x00, 0xc0, 0x19, 0x00, 0x00, 0xc0, 0x3d, 0x00,
+    0x00, 0xc0, 0x65, 0x00, 0x00, 0xc0, 0x8a, 0x00, 0x00, 0xc0, 0xb1, 0x00,
+    0x00, 0xc0, 0xd4, 0x00, 0x00, 0xc0, 0xf8, 0x00, 0x00, 0xc1, 0x1f, 0x00,
+    0x00, 0xc1, 0x45, 0x00, 0x00, 0xc1, 0x71, 0x00, 0x00, 0xc1, 0x9a, 0x00,
+    0x00, 0xc1, 0xba, 0x00, 0x00, 0xc1, 0xdf, 0x00, 0x00, 0xc2, 0x02, 0x00,
+    0x00, 0xc2, 0x26, 0x00, 0x00, 0xc2, 0x4d, 0x00, 0x00, 0xc2, 0x70, 0x00,
+    0x00, 0xc2, 0x97, 0x00, 0x00, 0xc2, 0xbc, 0x00, 0x00, 0xc2, 0xe6, 0x00,
+    0x00, 0xc3, 0x0b, 0x00, 0x00, 0xc3, 0x2f, 0x00, 0x00, 0xc3, 0x50, 0x00,
+    0x00, 0xc3, 0x74, 0x00, 0x00, 0xc3, 0x9f, 0x00, 0x00, 0xc3, 0xc1, 0x00,
+    0x00, 0xc3, 0xe3, 0x00, 0x00, 0xc4, 0x0a, 0x00, 0x00, 0xc4, 0x2c, 0x00,
+    0x00, 0xc4, 0x4e, 0x00, 0x00, 0xc4, 0x73, 0x00, 0x00, 0xc4, 0x9c, 0x00,
+    0x00, 0xc4, 0xc1, 0x00, 0x00, 0xc4, 0xeb, 0x00, 0x00, 0xc5, 0x12, 0x00,
+    0x00, 0xc5, 0x35, 0x00, 0x00, 0xc5, 0x5a, 0x00, 0x00, 0xc5, 0x86, 0x00,
+    0x00, 0xc5, 0xb2, 0x00, 0x00, 0xc5, 0xd6, 0x00, 0x00, 0xc5, 0xfb, 0x00,
+    0x00, 0xc6, 0x1b, 0x00, 0x00, 0xc6, 0x40, 0x00, 0x00, 0xc6, 0x66, 0x00,
+    0x00, 0xc6, 0x96, 0x00, 0x00, 0xc6, 0xbf, 0x00, 0x00, 0xc6, 0xe4, 0x00,
+    0x00, 0xc7, 0x06, 0x00, 0x00, 0xc7, 0x2a, 0x00, 0x00, 0xc7, 0x4c, 0x00,
+    0x00, 0xc7, 0x71, 0x00, 0x00, 0xc7, 0x9a, 0x00, 0x00, 0xc7, 0xc0, 0x00,
+    0x00, 0xc7, 0xe9, 0x00, 0x00, 0xc8, 0x10, 0x00, 0x00, 0xc8, 0x38, 0x00,
+    0x00, 0xc8, 0x61, 0x00, 0x00, 0xc8, 0x83, 0x00, 0x00, 0xc8, 0xaa, 0x00,
+    0x00, 0xc8, 0xd0, 0x00, 0x00, 0xc8, 0xf3, 0x00, 0x00, 0xc9, 0x19, 0x00,
+    0x00, 0xc9, 0x41, 0x00, 0x00, 0xc9, 0x65, 0x00, 0x00, 0xc9, 0x8a, 0x00,
+    0x00, 0xc9, 0xb1, 0x00, 0x00, 0xc9, 0xd5, 0x00, 0x00, 0xc9, 0xfa, 0x00,
+    0x00, 0xca, 0x24, 0x00, 0x00, 0xca, 0x50, 0x00, 0x00, 0xca, 0x78, 0x00,
+    0x00, 0xca, 0x9d, 0x00, 0x00, 0xca, 0xc0, 0x00, 0x00, 0xca, 0xe5, 0x00,
+    0x00, 0xcb, 0x05, 0x00, 0x00, 0xcb, 0x30, 0x00, 0x00, 0xcb, 0x57, 0x00,
+    0x00, 0xcb, 0x7a, 0x00, 0x00, 0xcb, 0x9d, 0x00, 0x00, 0xcb, 0xc1, 0x00,
+    0x00, 0xcb, 0xeb, 0x00, 0x00, 0xcc, 0x13, 0x00, 0x00, 0xcc, 0x3e, 0x00,
+    0x00, 0xcc, 0x5f, 0x00, 0x00, 0xcc, 0x88, 0x00, 0x00, 0xcc, 0xb0, 0x00,
+    0x00, 0xcc, 0xd4, 0x00, 0x00, 0xcc, 0xf8, 0x00, 0x00, 0xcd, 0x1b, 0x00,
+    0x00, 0xcd, 0x40, 0x00, 0x00, 0xcd, 0x68, 0x00, 0x00, 0xcd, 0x8c, 0x00,
+    0x00, 0xcd, 0xb1, 0x00, 0x00, 0xcd, 0xd8, 0x00, 0x00, 0xcd, 0xfd, 0x00,
+    0x00, 0xce, 0x21, 0x00, 0x00, 0xce, 0x4b, 0x00, 0x00, 0xce, 0x76, 0x00,
+    0x00, 0xce, 0x9b, 0x00, 0x00, 0xce, 0xc0, 0x00, 0x00, 0xce, 0xe7, 0x00,
+    0x00, 0xcf, 0x0f, 0x00, 0x00, 0xcf, 0x34, 0x00, 0x00, 0xcf, 0x57, 0x00,
+    0x00, 0xcf, 0x7d, 0x00, 0x00, 0xcf, 0x9f, 0x00, 0x00, 0xcf, 0xc4, 0x00,
+    0x00, 0xcf, 0xe9, 0x00, 0x00, 0xd0, 0x13, 0x00, 0x00, 0xd0, 0x3e, 0x00,
+    0x00, 0xd0, 0x64, 0x00, 0x00, 0xd0, 0x88, 0x00, 0x00, 0xd0, 0xaf, 0x00,
+    0x00, 0xd0, 0xd5, 0x00, 0x00, 0xd0, 0xfc, 0x00, 0x00, 0xd1, 0x1c, 0x00,
+    0x00, 0xd1, 0x41, 0x00, 0x00, 0xd1, 0x67, 0x00, 0x00, 0xd1, 0x8f, 0x00,
+    0x00, 0xd1, 0xb8, 0x00, 0x00, 0xd1, 0xdc, 0x00, 0x00, 0xd2, 0x01, 0x00,
+    0x00, 0xd2, 0x2a, 0x00, 0x00, 0xd2, 0x53, 0x00, 0x00, 0xd2, 0x7c, 0x00,
+    0x00, 0xd2, 0xa4, 0x00, 0x00, 0xd2, 0xc7, 0x00, 0x00, 0xd2, 0xea, 0x00,
+    0x00, 0xd3, 0x0d, 0x00, 0x00, 0xd3, 0x37, 0x00, 0x00, 0xd3, 0x5d, 0x00,
+    0x00, 0xd3, 0x84, 0x00, 0x00, 0xd3, 0xa9, 0x00, 0x00, 0xd3, 0xcf, 0x00,
+    0x00, 0xd3, 0xf9, 0x00, 0x00, 0xd4, 0x22, 0x00, 0x00, 0xd4, 0x47, 0x00,
+    0x00, 0xd4, 0x6e, 0x00, 0x00, 0xd4, 0x94, 0x00, 0x00, 0xd4, 0xbd, 0x00,
+    0x00, 0xd4, 0xe5, 0x00, 0x00, 0xd5, 0x0e, 0x00, 0x00, 0xd5, 0x33, 0x00,
+    0x00, 0xd5, 0x5b, 0x00, 0x00, 0xd5, 0x80, 0x00, 0x00, 0xd5, 0xa6, 0x00,
+    0x00, 0xd5, 0xce, 0x00, 0x00, 0xd5, 0xef, 0x00, 0x00, 0xd6, 0x13, 0x00,
+    0x00, 0xd6, 0x38, 0x00, 0x00, 0xd6, 0x59, 0x00, 0x00, 0xd6, 0x7d, 0x00,
+    0x00, 0xd6, 0xa1, 0x00, 0x00, 0xd6, 0xc8, 0x00, 0x00, 0xd6, 0xe8, 0x00,
+    0x00, 0xd7, 0x0c, 0x00, 0x00, 0xd7, 0x36, 0x00, 0x00, 0xd7, 0x58, 0x00,
+    0x00, 0xd7, 0x7e, 0x00, 0x00, 0xd7, 0xa1, 0x00, 0x00, 0xd7, 0xc3, 0x00,
+    0x00, 0xd7, 0xe8, 0x00, 0x00, 0xd8, 0x0e, 0x00, 0x00, 0xd8, 0x32, 0x00,
+    0x00, 0xd8, 0x55, 0x00, 0x00, 0xd8, 0x79, 0x00, 0x00, 0xd8, 0xa4, 0x00,
+    0x00, 0xd8, 0xc8, 0x00, 0x00, 0xd8, 0xed, 0x00, 0x00, 0xd9, 0x12, 0x00,
+    0x00, 0xd9, 0x33, 0x00, 0x00, 0xd9, 0x56, 0x00, 0x00, 0xd9, 0x7c, 0x00,
+    0x00, 0xd9, 0xa2, 0x00, 0x00, 0xd9, 0xc7, 0x00, 0x00, 0xd9, 0xea, 0x00,
+    0x00, 0xda, 0x14, 0x00, 0x00, 0xda, 0x3d, 0x00, 0x00, 0xda, 0x65, 0x00,
+    0x00, 0xda, 0x88, 0x00, 0x00, 0xda, 0xb0, 0x00, 0x00, 0xda, 0xd8, 0x00,
+    0x00, 0xda, 0xfe, 0x00, 0x00, 0xdb, 0x28, 0x00, 0x00, 0xdb, 0x51, 0x00,
+    0x00, 0xdb, 0x77, 0x00, 0x00, 0xdb, 0x9c, 0x00, 0x00, 0xdb, 0xc5, 0x00,
+    0x00, 0xdb, 0xe5, 0x00, 0x00, 0xdc, 0x0d, 0x00, 0x00, 0xdc, 0x34, 0x00,
+    0x00, 0xdc, 0x5a, 0x00, 0x00, 0xdc, 0x83, 0x00, 0x00, 0xdc, 0xb1, 0x00,
+    0x00, 0xdc, 0xd4, 0x00, 0x00, 0xdc, 0xfb, 0x00, 0x00, 0xdd, 0x20, 0x00,
+    0x00, 0xdd, 0x4e, 0x00, 0x00, 0xdd, 0x77, 0x00, 0x00, 0xdd, 0x9c, 0x00,
+    0x00, 0xdd, 0xc2, 0x00, 0x00, 0xdd, 0xf1, 0x00, 0x00, 0xde, 0x1b, 0x00,
+    0x00, 0xde, 0x3f, 0x00, 0x00, 0xde, 0x63, 0x00, 0x00, 0xde, 0x85, 0x00,
+    0x00, 0xde, 0xb0, 0x00, 0x00, 0xde, 0xd6, 0x00, 0x00, 0xde, 0xfe, 0x00,
+    0x00, 0xdf, 0x25, 0x00, 0x00, 0xdf, 0x52, 0x00, 0x00, 0xdf, 0x79, 0x00,
+    0x00, 0xdf, 0xa0, 0x00, 0x00, 0xdf, 0xc0, 0x00, 0x00, 0xdf, 0xe5, 0x00,
+    0x00, 0xe0, 0x04, 0x00, 0x00, 0xe0, 0x2b, 0x00, 0x00, 0xe0, 0x52, 0x00,
+    0x00, 0xe0, 0x77, 0x00, 0x00, 0xe0, 0x9d, 0x00, 0x00, 0xe0, 0xc6, 0x00,
+    0x00, 0xe0, 0xeb, 0x00, 0x00, 0xe1, 0x0f, 0x00, 0x00, 0xe1, 0x36, 0x00,
+    0x00, 0xe1, 0x62, 0x00, 0x00, 0xe1, 0x88, 0x00, 0x00, 0xe1, 0xae, 0x00,
+    0x00, 0xe1, 0xd0, 0x00, 0x00, 0xe1, 0xf4, 0x00, 0x00, 0xe2, 0x1d, 0x00,
+    0x00, 0xe2, 0x3e, 0x00, 0x00, 0xe2, 0x61, 0x00, 0x00, 0xe2, 0x92, 0x00,
+    0x00, 0xe2, 0xb3, 0x00, 0x00, 0xe2, 0xdc, 0x00, 0x00, 0xe3, 0x00, 0x00,
+    0x00, 0xe3, 0x27, 0x00, 0x00, 0xe3, 0x50, 0x00, 0x00, 0xe3, 0x79, 0x00,
+    0x00, 0xe3, 0xa0, 0x00, 0x00, 0xe3, 0xca, 0x00, 0x00, 0xe3, 0xf4, 0x00,
+    0x00, 0xe4, 0x1d, 0x00, 0x00, 0xe4, 0x44, 0x00, 0x00, 0xe4, 0x6d, 0x00,
+    0x00, 0xe4, 0x94, 0x00, 0x00, 0xe4, 0xb9, 0x00, 0x00, 0xe4, 0xe0, 0x00,
+    0x00, 0xe5, 0x06, 0x00, 0x00, 0xe5, 0x2b, 0x00, 0x00, 0xe5, 0x54, 0x00,
+    0x00, 0xe5, 0x7b, 0x00, 0x00, 0xe5, 0xa1, 0x00, 0x00, 0xe5, 0xc8, 0x00,
+    0x00, 0xe5, 0xeb, 0x00, 0x00, 0xe6, 0x11, 0x00, 0x00, 0xe6, 0x36, 0x00,
+    0x00, 0xe6, 0x60, 0x00, 0x00, 0xe6, 0x84, 0x00, 0x00, 0xe6, 0xab, 0x00,
+    0x00, 0xe6, 0xd5, 0x00, 0x00, 0xe6, 0xf8, 0x00, 0x00, 0xe7, 0x1e, 0x00,
+    0x00, 0xe7, 0x47, 0x00, 0x00, 0xe7, 0x6c, 0x00, 0x00, 0xe7, 0x8e, 0x00,
+    0x00, 0xe7, 0xb2, 0x00, 0x00, 0xe7, 0xd9, 0x00, 0x00, 0xe8, 0x04, 0x00,
+    0x00, 0xe8, 0x27, 0x00, 0x00, 0xe8, 0x4e, 0x00, 0x00, 0xe8, 0x76, 0x00,
+    0x00, 0xe8, 0x9d, 0x00, 0x00, 0xe8, 0xc2, 0x00, 0x00, 0xe8, 0xe3, 0x00,
+    0x00, 0xe9, 0x04, 0x00, 0x00, 0xe9, 0x2d, 0x00, 0x00, 0xe9, 0x55, 0x00,
+    0x00, 0xe9, 0x78, 0x00, 0x00, 0xe9, 0x9e, 0x00, 0x00, 0xe9, 0xc7, 0x00,
+    0x00, 0xe9, 0xe7, 0x00, 0x00, 0xea, 0x0f, 0x00, 0x00, 0xea, 0x36, 0x00,
+    0x00, 0xea, 0x5c, 0x00, 0x00, 0xea, 0x82, 0x00, 0x00, 0xea, 0xaf, 0x00,
+    0x00, 0xea, 0xd4, 0x00, 0x00, 0xea, 0xfa, 0x00, 0x00, 0xeb, 0x1e, 0x00,
+    0x00, 0xeb, 0x45, 0x00, 0x00, 0xeb, 0x6c, 0x00, 0x00, 0xeb, 0x92, 0x00,
+    0x00, 0xeb, 0xb7, 0x00, 0x00, 0xeb, 0xd6, 0x00, 0x00, 0xeb, 0xfa, 0x00,
+    0x00, 0xec, 0x1c, 0x00, 0x00, 0xec, 0x41, 0x00, 0x00, 0xec, 0x68, 0x00,
+    0x00, 0xec, 0x88, 0x00, 0x00, 0xec, 0xb3, 0x00, 0x00, 0xec, 0xd6, 0x00,
+    0x00, 0xec, 0xfe, 0x00, 0x00, 0xed, 0x23, 0x00, 0x00, 0xed, 0x47, 0x00,
+    0x00, 0xed, 0x6b, 0x00, 0x00, 0xed, 0x8c, 0x00, 0x00, 0xed, 0xb0, 0x00,
+    0x00, 0xed, 0xd4, 0x00, 0x00, 0xed, 0xfd, 0x00, 0x00, 0xee, 0x24, 0x00,
+    0x00, 0xee, 0x4c, 0x00, 0x00, 0xee, 0x73, 0x00, 0x00, 0xee, 0x99, 0x00,
+    0x00, 0xee, 0xbf, 0x00, 0x00, 0xee, 0xe4, 0x00, 0x00, 0xef, 0x09, 0x00,
+    0x00, 0xef, 0x2f, 0x00, 0x00, 0xef, 0x55, 0x00, 0x00, 0xef, 0x78, 0x00,
+    0x00, 0xef, 0x9b, 0x00, 0x00, 0xef, 0xc0, 0x00, 0x00, 0xef, 0xe2, 0x00,
+    0x00, 0xf0, 0x07, 0x00, 0x00, 0xf0, 0x30, 0x00, 0x00, 0xf0, 0x52, 0x00,
+    0x00, 0xf0, 0x76, 0x00, 0x00, 0xf0, 0x96, 0x00, 0x00, 0xf0, 0xba, 0x00,
+    0x00, 0xf0, 0xe1, 0x00, 0x00, 0xf1, 0x0c, 0x00, 0x00, 0xf1, 0x30, 0x00,
+    0x00, 0xf1, 0x56, 0x00, 0x00, 0xf1, 0x79, 0x00, 0x00, 0xf1, 0xa4, 0x00,
+    0x00, 0xf1, 0xc6, 0x00, 0x00, 0xf1, 0xee, 0x00, 0x00, 0xf2, 0x13, 0x00,
+    0x00, 0xf2, 0x3a, 0x00, 0x00, 0xf2, 0x62, 0x00, 0x00, 0xf2, 0x8e, 0x00,
+    0x00, 0xf2, 0xb4, 0x00, 0x00, 0xf2, 0xd6, 0x00, 0x00, 0xf2, 0xfe, 0x00,
+    0x00, 0xf3, 0x1f, 0x00, 0x00, 0xf3, 0x40, 0x00, 0x00, 0xf3, 0x66, 0x00,
+    0x00, 0xf3, 0x8c, 0x00, 0x00, 0xf3, 0xb0, 0x00, 0x00, 0xf3, 0xd3, 0x00,
+    0x00, 0xf3, 0xf6, 0x00, 0x00, 0xf4, 0x21, 0x00, 0x00, 0xf4, 0x43, 0x00,
+    0x00, 0xf4, 0x66, 0x00, 0x00, 0xf4, 0x87, 0x00, 0x00, 0xf4, 0xb2, 0x00,
+    0x00, 0xf4, 0xd7, 0x00, 0x00, 0xf4, 0xf9, 0x00, 0x00, 0xf5, 0x1f, 0x00,
+    0x00, 0xf5, 0x46, 0x00, 0x00, 0xf5, 0x69, 0x00, 0x00, 0xf5, 0x91, 0x00,
+    0x00, 0xf5, 0xb5, 0x00, 0x00, 0xf5, 0xdd, 0x00, 0x00, 0xf6, 0x01, 0x00,
+    0x00, 0xf6, 0x25, 0x00, 0x00, 0xf6, 0x4b, 0x00, 0x00, 0xf6, 0x71, 0x00,
+    0x00, 0xf6, 0x95, 0x00, 0x00, 0xf6, 0xbd, 0x00, 0x00, 0xf6, 0xe0, 0x00,
+    0x00, 0xf7, 0x04, 0x00, 0x00, 0xf7, 0x2c, 0x00, 0x00, 0xf7, 0x4e, 0x00,
+    0x00, 0xf7, 0x75, 0x00, 0x00, 0xf7, 0x99, 0x00, 0x00, 0xf7, 0xc1, 0x00,
+    0x00, 0xf7, 0xe3, 0x00, 0x00, 0xf8, 0x09, 0x00, 0x00, 0xf8, 0x2f, 0x00,
+    0x00, 0xf8, 0x5b, 0x00, 0x00, 0xf8, 0x80, 0x00, 0x00, 0xf8, 0xa4, 0x00,
+    0x00, 0xf8, 0xce, 0x00, 0x00, 0xf8, 0xef, 0x00, 0x00, 0xf9, 0x1b, 0x00,
+    0x00, 0xf9, 0x47, 0x00, 0x00, 0xf9, 0x6f, 0x00, 0x00, 0xf9, 0x96, 0x00,
+    0x00, 0xf9, 0xbb, 0x00, 0x00, 0xf9, 0xdf, 0x00, 0x00, 0xfa, 0x01, 0x00,
+    0x00, 0xfa, 0x27, 0x00, 0x00, 0xfa, 0x48, 0x00, 0x00, 0xfa, 0x6b, 0x00,
+    0x00, 0xfa, 0x90, 0x00, 0x00, 0xfa, 0xb1, 0x00, 0x00, 0xfa, 0xd5, 0x00,
+    0x00, 0xfa, 0xf9, 0x00, 0x00, 0xfb, 0x1d, 0x00, 0x00, 0xfb, 0x46, 0x00,
+    0x00, 0xfb, 0x6e, 0x00, 0x00, 0xfb, 0x93, 0x00, 0x00, 0xfb, 0xb9, 0x00,
+    0x00, 0xfb, 0xe5, 0x00, 0x00, 0xfc, 0x10, 0x00, 0x00, 0xfc, 0x36, 0x00,
+    0x00, 0xfc, 0x5e, 0x00, 0x00, 0xfc, 0x82, 0x00, 0x00, 0xfc, 0xad, 0x00,
+    0x00, 0xfc, 0xd8, 0x00, 0x00, 0xfc, 0xfc, 0x00, 0x00, 0xfd, 0x26, 0x00,
+    0x00, 0xfd, 0x50, 0x00, 0x00, 0xfd, 0x75, 0x00, 0x00, 0xfd, 0x9d, 0x00,
+    0x00, 0xfd, 0xc8, 0x00, 0x00, 0xfd, 0xeb, 0x00, 0x00, 0xfe, 0x10, 0x00,
+    0x00, 0xfe, 0x34, 0x00, 0x00, 0xfe, 0x60, 0x00, 0x00, 0xfe, 0x8b, 0x00,
+    0x00, 0xfe, 0xaf, 0x00, 0x00, 0xfe, 0xd3, 0x00, 0x00, 0xfe, 0xfe, 0x00,
+    0x00, 0xff, 0x25, 0x00, 0x00, 0xff, 0x4a, 0x00, 0x00, 0xff, 0x6a, 0x00,
+    0x00, 0xff, 0x96, 0x00, 0x00, 0xff, 0xba, 0x00, 0x00, 0xff, 0xdf, 0x00,
+    0x01, 0x00, 0x05, 0x00, 0x01, 0x00, 0x28, 0x00, 0x01, 0x00, 0x4c, 0x00,
+    0x01, 0x00, 0x71, 0x00, 0x01, 0x00, 0x99, 0x00, 0x01, 0x00, 0xc7, 0x00,
+    0x01, 0x00, 0xee, 0x00, 0x01, 0x01, 0x14, 0x00, 0x01, 0x01, 0x40, 0x00,
+    0x01, 0x01, 0x62, 0x00, 0x01, 0x01, 0x86, 0x00, 0x01, 0x01, 0xaa, 0x00,
+    0x01, 0x01, 0xd1, 0x00, 0x01, 0x01, 0xf4, 0x00, 0x01, 0x02, 0x19, 0x00,
+    0x01, 0x02, 0x42, 0x00, 0x01, 0x02, 0x6c, 0x00, 0x01, 0x02, 0x92, 0x00,
+    0x01, 0x02, 0xb6, 0x00, 0x01, 0x02, 0xdf, 0x00, 0x01, 0x03, 0x03, 0x00,
+    0x01, 0x03, 0x2d, 0x00, 0x01, 0x03, 0x50, 0x00, 0x01, 0x03, 0x79, 0x00,
+    0x01, 0x03, 0xa5, 0x00, 0x01, 0x03, 0xc8, 0x00, 0x01, 0x03, 0xec, 0x00,
+    0x01, 0x04, 0x0f, 0x00, 0x01, 0x04, 0x3c, 0x00, 0x01, 0x04, 0x61, 0x00,
+    0x01, 0x04, 0x86, 0x00, 0x01, 0x04, 0xa7, 0x00, 0x01, 0x04, 0xc7, 0x00,
+    0x01, 0x04, 0xeb, 0x00, 0x01, 0x05, 0x10, 0x00, 0x01, 0x05, 0x36, 0x00,
+    0x01, 0x05, 0x61, 0x00, 0x01, 0x05, 0x89, 0x00, 0x01, 0x05, 0xb0, 0x00,
+    0x01, 0x05, 0xd2, 0x00, 0x01, 0x05, 0xf6, 0x00, 0x01, 0x06, 0x1a, 0x00,
+    0x01, 0x06, 0x43, 0x00, 0x01, 0x06, 0x71, 0x00, 0x01, 0x06, 0x9d, 0x00,
+    0x01, 0x06, 0xc2, 0x00, 0x01, 0x06, 0xeb, 0x00, 0x01, 0x07, 0x15, 0x00,
+    0x01, 0x07, 0x39, 0x00, 0x01, 0x07, 0x5d, 0x00, 0x01, 0x07, 0x84, 0x00,
+    0x01, 0x07, 0xa7, 0x00, 0x01, 0x07, 0xcc, 0x00, 0x01, 0x07, 0xf0, 0x00,
+    0x01, 0x08, 0x15, 0x00, 0x01, 0x08, 0x42, 0x00, 0x01, 0x08, 0x62, 0x00,
+    0x01, 0x08, 0x8b, 0x00, 0x01, 0x08, 0xb1, 0x00, 0x01, 0x08, 0xdd, 0x00,
+    0x01, 0x09, 0x01, 0x00, 0x01, 0x09, 0x27, 0x00, 0x01, 0x09, 0x4e, 0x00,
+    0x01, 0x09, 0x70, 0x00, 0x01, 0x09, 0x9a, 0x00, 0x01, 0x09, 0xbd, 0x00,
+    0x01, 0x09, 0xe4, 0x00, 0x01, 0x0a, 0x05, 0x00, 0x01, 0x0a, 0x28, 0x00,
+    0x01, 0x0a, 0x4c, 0x00, 0x01, 0x0a, 0x73, 0x00, 0x01, 0x0a, 0x96, 0x00,
+    0x01, 0x0a, 0xbf, 0x00, 0x01, 0x0a, 0xe9, 0x00, 0x01, 0x0b, 0x12, 0x00,
+    0x01, 0x0b, 0x37, 0x00, 0x01, 0x0b, 0x5b, 0x00, 0x01, 0x0b, 0x7f, 0x00,
+    0x01, 0x0b, 0xa7, 0x00, 0x01, 0x0b, 0xcb, 0x00, 0x01, 0x0b, 0xf5, 0x00,
+    0x01, 0x0c, 0x19, 0x00, 0x01, 0x0c, 0x41, 0x00, 0x01, 0x0c, 0x66, 0x00,
+    0x01, 0x0c, 0x8e, 0x00, 0x01, 0x0c, 0xb0, 0x00, 0x01, 0x0c, 0xd4, 0x00,
+    0x01, 0x0c, 0xf5, 0x00, 0x01, 0x0d, 0x17, 0x00, 0x01, 0x0d, 0x3c, 0x00,
+    0x01, 0x0d, 0x68, 0x00, 0x01, 0x0d, 0x92, 0x00, 0x01, 0x0d, 0xb6, 0x00,
+    0x01, 0x0d, 0xdd, 0x00, 0x01, 0x0e, 0x01, 0x00, 0x01, 0x0e, 0x27, 0x00,
+    0x01, 0x0e, 0x4b, 0x00, 0x01, 0x0e, 0x6f, 0x00, 0x01, 0x0e, 0x98, 0x00,
+    0x01, 0x0e, 0xba, 0x00, 0x01, 0x0e, 0xe6, 0x00, 0x01, 0x0f, 0x0f, 0x00,
+    0x01, 0x0f, 0x35, 0x00, 0x01, 0x0f, 0x56, 0x00, 0x01, 0x0f, 0x7a, 0x00,
+    0x01, 0x0f, 0xa1, 0x00, 0x01, 0x0f, 0xc7, 0x00, 0x01, 0x0f, 0xec, 0x00,
+    0x01, 0x10, 0x19, 0x00, 0x01, 0x10, 0x41, 0x00, 0x01, 0x10, 0x6a, 0x00,
+    0x01, 0x10, 0x8d, 0x00, 0x01, 0x10, 0xb3, 0x00, 0x01, 0x10, 0xdb, 0x00,
+    0x01, 0x11, 0x04, 0x00, 0x01, 0x11, 0x2a, 0x00, 0x01, 0x11, 0x53, 0x00,
+    0x01, 0x11, 0x7a, 0x00, 0x01, 0x11, 0x9a, 0x00, 0x01, 0x11, 0xbd, 0x00,
+    0x01, 0x11, 0xe4, 0x00, 0x01, 0x12, 0x08, 0x00, 0x01, 0x12, 0x30, 0x00,
+    0x01, 0x12, 0x57, 0x00, 0x01, 0x12, 0x7a, 0x00, 0x01, 0x12, 0x9d, 0x00,
+    0x01, 0x12, 0xc1, 0x00, 0x01, 0x12, 0xe9, 0x00, 0x01, 0x13, 0x0d, 0x00,
+    0x01, 0x13, 0x34, 0x00, 0x01, 0x13, 0x58, 0x00, 0x01, 0x13, 0x7a, 0x00,
+    0x01, 0x13, 0xa4, 0x00, 0x01, 0x13, 0xcd, 0x00, 0x01, 0x13, 0xf5, 0x00,
+    0x01, 0x14, 0x18, 0x00, 0x01, 0x14, 0x3c, 0x00, 0x01, 0x14, 0x60, 0x00,
+    0x01, 0x14, 0x86, 0x00, 0x01, 0x14, 0xac, 0x00, 0x01, 0x14, 0xcf, 0x00,
+    0x01, 0x14, 0xf4, 0x00, 0x01, 0x15, 0x14, 0x00, 0x01, 0x15, 0x38, 0x00,
+    0x01, 0x15, 0x63, 0x00, 0x01, 0x15, 0x8a, 0x00, 0x01, 0x15, 0xad, 0x00,
+    0x01, 0x15, 0xd4, 0x00, 0x01, 0x15, 0xf9, 0x00, 0x01, 0x16, 0x24, 0x00,
+    0x01, 0x16, 0x4f, 0x00, 0x01, 0x16, 0x73, 0x00, 0x01, 0x16, 0x9b, 0x00,
+    0x01, 0x16, 0xbf, 0x00, 0x01, 0x16, 0xe4, 0x00, 0x01, 0x17, 0x09, 0x00,
+    0x01, 0x17, 0x2c, 0x00, 0x01, 0x17, 0x57, 0x00, 0x01, 0x17, 0x7d, 0x00,
+    0x01, 0x17, 0xa0, 0x00, 0x01, 0x17, 0xc5, 0x00, 0x01, 0x17, 0xe8, 0x00,
+    0x01, 0x18, 0x0e, 0x00, 0x01, 0x18, 0x33, 0x00, 0x01, 0x18, 0x57, 0x00,
+    0x01, 0x18, 0x7b, 0x00, 0x01, 0x18, 0xa0, 0x00, 0x01, 0x18, 0xc7, 0x00,
+    0x01, 0x18, 0xeb, 0x00, 0x01, 0x19, 0x20, 0x00, 0x01, 0x19, 0x44, 0x00,
+    0x01, 0x19, 0x6e, 0x00, 0x01, 0x19, 0x96, 0x00, 0x01, 0x19, 0xb7, 0x00,
+    0x01, 0x19, 0xdb, 0x00, 0x01, 0x19, 0xff, 0x00, 0x01, 0x1a, 0x23, 0x00,
+    0x01, 0x1a, 0x42, 0x00, 0x01, 0x1a, 0x69, 0x00, 0x01, 0x1a, 0x8f, 0x00,
+    0x01, 0x1a, 0xb1, 0x00, 0x01, 0x1a, 0xd8, 0x00, 0x01, 0x1a, 0xf9, 0x00,
+    0x01, 0x1b, 0x1d, 0x00, 0x01, 0x1b, 0x44, 0x00, 0x01, 0x1b, 0x68, 0x00,
+    0x01, 0x1b, 0x8c, 0x00, 0x01, 0x1b, 0xb2, 0x00, 0x01, 0x1b, 0xd5, 0x00,
+    0x01, 0x1b, 0xf8, 0x00, 0x01, 0x1c, 0x1f, 0x00, 0x01, 0x1c, 0x47, 0x00,
+    0x01, 0x1c, 0x72, 0x00, 0x01, 0x1c, 0x97, 0x00, 0x01, 0x1c, 0xbe, 0x00,
+    0x01, 0x1c, 0xe2, 0x00, 0x01, 0x1d, 0x05, 0x00, 0x01, 0x1d, 0x25, 0x00,
+    0x01, 0x1d, 0x4c, 0x00, 0x01, 0x1d, 0x6e, 0x00, 0x01, 0x1d, 0x96, 0x00,
+    0x01, 0x1d, 0xba, 0x00, 0x01, 0x1d, 0xdb, 0x00, 0x01, 0x1d, 0xfa, 0x00,
+    0x01, 0x1e, 0x1d, 0x00, 0x01, 0x1e, 0x48, 0x00, 0x01, 0x1e, 0x6e, 0x00,
+    0x01, 0x1e, 0x95, 0x00, 0x01, 0x1e, 0xbd, 0x00, 0x01, 0x1e, 0xe8, 0x00,
+    0x01, 0x1f, 0x0e, 0x00, 0x01, 0x1f, 0x33, 0x00, 0x01, 0x1f, 0x59, 0x00,
+    0x01, 0x1f, 0x7d, 0x00, 0x01, 0x1f, 0x9e, 0x00, 0x01, 0x1f, 0xc6, 0x00,
+    0x01, 0x1f, 0xed, 0x00, 0x01, 0x20, 0x13, 0x00, 0x01, 0x20, 0x37, 0x00,
+    0x01, 0x20, 0x5b, 0x00, 0x01, 0x20, 0x80, 0x00, 0x01, 0x20, 0xa6, 0x00,
+    0x01, 0x20, 0xce, 0x00, 0x01, 0x20, 0xf3, 0x00, 0x01, 0x21, 0x23, 0x00,
+    0x01, 0x21, 0x4f, 0x00, 0x01, 0x21, 0x7b, 0x00, 0x01, 0x21, 0xa0, 0x00,
+    0x01, 0x21, 0xc5, 0x00, 0x01, 0x21, 0xea, 0x00, 0x01, 0x22, 0x11, 0x00,
+    0x01, 0x22, 0x37, 0x00, 0x01, 0x22, 0x58, 0x00, 0x01, 0x22, 0x7e, 0x00,
+    0x01, 0x22, 0x9f, 0x00, 0x01, 0x22, 0xc4, 0x00, 0x01, 0x22, 0xe9, 0x00,
+    0x01, 0x23, 0x0c, 0x00, 0x01, 0x23, 0x35, 0x00, 0x01, 0x23, 0x5b, 0x00,
+    0x01, 0x23, 0x81, 0x00, 0x01, 0x23, 0xa5, 0x00, 0x01, 0x23, 0xca, 0x00,
+    0x01, 0x23, 0xf7, 0x00, 0x01, 0x24, 0x1a, 0x00, 0x01, 0x24, 0x3f, 0x00,
+    0x01, 0x24, 0x62, 0x00, 0x01, 0x24, 0x83, 0x00, 0x01, 0x24, 0xa7, 0x00,
+    0x01, 0x24, 0xd1, 0x00, 0x01, 0x24, 0xf4, 0x00, 0x01, 0x25, 0x1f, 0x00,
+    0x01, 0x25, 0x49, 0x00, 0x01, 0x25, 0x6d, 0x00, 0x01, 0x25, 0x8e, 0x00,
+    0x01, 0x25, 0xb4, 0x00, 0x01, 0x25, 0xd8, 0x00, 0x01, 0x26, 0x04, 0x00,
+    0x01, 0x26, 0x29, 0x00, 0x01, 0x26, 0x4c, 0x00, 0x01, 0x26, 0x72, 0x00,
+    0x01, 0x26, 0x97, 0x00, 0x01, 0x26, 0xbb, 0x00, 0x01, 0x26, 0xe3, 0x00,
+    0x01, 0x27, 0x0c, 0x00, 0x01, 0x27, 0x36, 0x00, 0x01, 0x27, 0x60, 0x00,
+    0x01, 0x27, 0x82, 0x00, 0x01, 0x27, 0xa6, 0x00, 0x01, 0x27, 0xcc, 0x00,
+    0x01, 0x27, 0xf4, 0x00, 0x01, 0x28, 0x17, 0x00, 0x01, 0x28, 0x37, 0x00,
+    0x01, 0x28, 0x57, 0x00, 0x01, 0x28, 0x7a, 0x00, 0x01, 0x28, 0xa1, 0x00,
+    0x01, 0x28, 0xc2, 0x00, 0x01, 0x28, 0xeb, 0x00, 0x01, 0x29, 0x12, 0x00,
+    0x01, 0x29, 0x3a, 0x00, 0x01, 0x29, 0x60, 0x00, 0x01, 0x29, 0x8c, 0x00,
+    0x01, 0x29, 0xb3, 0x00, 0x01, 0x29, 0xd5, 0x00, 0x01, 0x29, 0xf7, 0x00,
+    0x01, 0x2a, 0x1e, 0x00, 0x01, 0x2a, 0x44, 0x00, 0x01, 0x2a, 0x65, 0x00,
+    0x01, 0x2a, 0x8b, 0x00, 0x01, 0x2a, 0xb0, 0x00, 0x01, 0x2a, 0xdd, 0x00,
+    0x01, 0x2b, 0x04, 0x00, 0x01, 0x2b, 0x2b, 0x00, 0x01, 0x2b, 0x4e, 0x00,
+    0x01, 0x2b, 0x7a, 0x00, 0x01, 0x2b, 0x9f, 0x00, 0x01, 0x2b, 0xc4, 0x00,
+    0x01, 0x2b, 0xea, 0x00, 0x01, 0x2c, 0x0f, 0x00, 0x01, 0x2c, 0x34, 0x00,
+    0x01, 0x2c, 0x5a, 0x00, 0x01, 0x2c, 0x81, 0x00, 0x01, 0x2c, 0xa3, 0x00,
+    0x01, 0x2c, 0xc9, 0x00, 0x01, 0x2c, 0xf0, 0x00, 0x01, 0x2d, 0x13, 0x00,
+    0x01, 0x2d, 0x37, 0x00, 0x01, 0x2d, 0x60, 0x00, 0x01, 0x2d, 0x88, 0x00,
+    0x01, 0x2d, 0xb1, 0x00, 0x01, 0x2d, 0xd5, 0x00, 0x01, 0x2d, 0xf6, 0x00,
+    0x01, 0x2e, 0x21, 0x00, 0x01, 0x2e, 0x48, 0x00, 0x01, 0x2e, 0x72, 0x00,
+    0x01, 0x2e, 0x94, 0x00, 0x01, 0x2e, 0xb7, 0x00, 0x01, 0x2e, 0xd8, 0x00,
+    0x01, 0x2f, 0x02, 0x00, 0x01, 0x2f, 0x2a, 0x00, 0x01, 0x2f, 0x50, 0x00,
+    0x01, 0x2f, 0x74, 0x00, 0x01, 0x2f, 0x96, 0x00, 0x01, 0x2f, 0xbb, 0x00,
+    0x01, 0x2f, 0xe0, 0x00, 0x01, 0x30, 0x02, 0x00, 0x01, 0x30, 0x2d, 0x00,
+    0x01, 0x30, 0x52, 0x00, 0x01, 0x30, 0x7b, 0x00, 0x01, 0x30, 0x9f, 0x00,
+    0x01, 0x30, 0xc9, 0x00, 0x01, 0x30, 0xee, 0x00, 0x01, 0x31, 0x12, 0x00,
+    0x01, 0x31, 0x3a, 0x00, 0x01, 0x31, 0x60, 0x00, 0x01, 0x31, 0x8a, 0x00,
+    0x01, 0x31, 0xab, 0x00, 0x01, 0x31, 0xd1, 0x00, 0x01, 0x31, 0xf9, 0x00,
+    0x01, 0x32, 0x1b, 0x00, 0x01, 0x32, 0x41, 0x00, 0x01, 0x32, 0x68, 0x00,
+    0x01, 0x32, 0x90, 0x00, 0x01, 0x32, 0xb3, 0x00, 0x01, 0x32, 0xdb, 0x00,
+    0x01, 0x32, 0xff, 0x00, 0x01, 0x33, 0x24, 0x00, 0x01, 0x33, 0x49, 0x00,
+    0x01, 0x33, 0x72, 0x00, 0x01, 0x33, 0x99, 0x00, 0x01, 0x33, 0xc6, 0x00,
+    0x01, 0x33, 0xed, 0x00, 0x01, 0x34, 0x15, 0x00, 0x01, 0x34, 0x3b, 0x00,
+    0x01, 0x34, 0x62, 0x00, 0x01, 0x34, 0x8a, 0x00, 0x01, 0x34, 0xaa, 0x00,
+    0x01, 0x34, 0xd1, 0x00, 0x01, 0x34, 0xf8, 0x00, 0x01, 0x35, 0x22, 0x00,
+    0x01, 0x35, 0x42, 0x00, 0x01, 0x35, 0x69, 0x00, 0x01, 0x35, 0x8d, 0x00,
+    0x01, 0x35, 0xae, 0x00, 0x01, 0x35, 0xd3, 0x00, 0x01, 0x35, 0xf8, 0x00,
+    0x01, 0x36, 0x1c, 0x00, 0x01, 0x36, 0x41, 0x00, 0x01, 0x36, 0x64, 0x00,
+    0x01, 0x36, 0x8e, 0x00, 0x01, 0x36, 0xb3, 0x00, 0x01, 0x36, 0xda, 0x00,
+    0x01, 0x37, 0x02, 0x00, 0x01, 0x37, 0x27, 0x00, 0x01, 0x37, 0x58, 0x00,
+    0x01, 0x37, 0x7d, 0x00, 0x01, 0x37, 0xa2, 0x00, 0x01, 0x37, 0xc7, 0x00,
+    0x01, 0x37, 0xea, 0x00, 0x01, 0x38, 0x13, 0x00, 0x01, 0x38, 0x38, 0x00,
+    0x01, 0x38, 0x5c, 0x00, 0x01, 0x38, 0x80, 0x00, 0x01, 0x38, 0xa4, 0x00,
+    0x01, 0x38, 0xc7, 0x00, 0x01, 0x38, 0xeb, 0x00, 0x01, 0x39, 0x15, 0x00,
+    0x01, 0x39, 0x3e, 0x00, 0x01, 0x39, 0x63, 0x00, 0x01, 0x39, 0x8c, 0x00,
+    0x01, 0x39, 0xb5, 0x00, 0x01, 0x39, 0xd9, 0x00, 0x01, 0x39, 0xfe, 0x00,
+    0x01, 0x3a, 0x23, 0x00, 0x01, 0x3a, 0x56, 0x00, 0x01, 0x3a, 0x7a, 0x00,
+    0x01, 0x3a, 0x9f, 0x00, 0x01, 0x3a, 0xc4, 0x00, 0x01, 0x3a, 0xe9, 0x00,
+    0x01, 0x3b, 0x0d, 0x00, 0x01, 0x3b, 0x32, 0x00, 0x01, 0x3b, 0x55, 0x00,
+    0x01, 0x3b, 0x7a, 0x00, 0x01, 0x3b, 0xa9, 0x00, 0x01, 0x3b, 0xd0, 0x00,
+    0x01, 0x3b, 0xf6, 0x00, 0x01, 0x3c, 0x23, 0x00, 0x01, 0x3c, 0x4a, 0x00,
+    0x01, 0x3c, 0x71, 0x00, 0x01, 0x3c, 0x94, 0x00, 0x01, 0x3c, 0xb4, 0x00,
+    0x01, 0x3c, 0xdb, 0x00, 0x01, 0x3d, 0x02, 0x00, 0x01, 0x3d, 0x28, 0x00,
+    0x01, 0x3d, 0x51, 0x00, 0x01, 0x3d, 0x75, 0x00, 0x01, 0x3d, 0x9a, 0x00,
+    0x01, 0x3d, 0xbe, 0x00, 0x01, 0x3d, 0xe6, 0x00, 0x01, 0x3e, 0x0e, 0x00,
+    0x01, 0x3e, 0x32, 0x00, 0x01, 0x3e, 0x55, 0x00, 0x01, 0x3e, 0x77, 0x00,
+    0x01, 0x3e, 0x9e, 0x00, 0x01, 0x3e, 0xc1, 0x00, 0x01, 0x3e, 0xe6, 0x00,
+    0x01, 0x3f, 0x0b, 0x00, 0x01, 0x3f, 0x30, 0x00, 0x01, 0x3f, 0x54, 0x00,
+    0x01, 0x3f, 0x7b, 0x00, 0x01, 0x3f, 0xa5, 0x00, 0x01, 0x3f, 0xcf, 0x00,
+    0x01, 0x3f, 0xf1, 0x00, 0x01, 0x40, 0x1a, 0x00, 0x01, 0x40, 0x44, 0x00,
+    0x01, 0x40, 0x6a, 0x00, 0x01, 0x40, 0x8d, 0x00, 0x01, 0x40, 0xb3, 0x00,
+    0x01, 0x40, 0xd9, 0x00, 0x01, 0x40, 0xfe, 0x00, 0x01, 0x41, 0x29, 0x00,
+    0x01, 0x41, 0x50, 0x00, 0x01, 0x41, 0x77, 0x00, 0x01, 0x41, 0xa0, 0x00,
+    0x01, 0x41, 0xc5, 0x00, 0x01, 0x41, 0xe7, 0x00, 0x01, 0x42, 0x0b, 0x00,
+    0x01, 0x42, 0x3a, 0x00, 0x01, 0x42, 0x61, 0x00, 0x01, 0x42, 0x88, 0x00,
+    0x01, 0x42, 0xac, 0x00, 0x01, 0x42, 0xd7, 0x00, 0x01, 0x43, 0x05, 0x00,
+    0x01, 0x43, 0x2e, 0x00, 0x01, 0x43, 0x53, 0x00, 0x01, 0x43, 0x78, 0x00,
+    0x01, 0x43, 0xa0, 0x00, 0x01, 0x43, 0xc0, 0x00, 0x01, 0x43, 0xe8, 0x00,
+    0x01, 0x44, 0x12, 0x00, 0x01, 0x44, 0x37, 0x00, 0x01, 0x44, 0x5b, 0x00,
+    0x01, 0x44, 0x7e, 0x00, 0x01, 0x44, 0xaa, 0x00, 0x01, 0x44, 0xcd, 0x00,
+    0x01, 0x44, 0xf1, 0x00, 0x01, 0x45, 0x15, 0x00, 0x01, 0x45, 0x38, 0x00,
+    0x01, 0x45, 0x5c, 0x00, 0x01, 0x45, 0x89, 0x00, 0x01, 0x45, 0xac, 0x00,
+    0x01, 0x45, 0xd1, 0x00, 0x01, 0x45, 0xf4, 0x00, 0x01, 0x46, 0x1b, 0x00,
+    0x01, 0x46, 0x40, 0x00, 0x01, 0x46, 0x6a, 0x00, 0x01, 0x46, 0x8f, 0x00,
+    0x01, 0x46, 0xb5, 0x00, 0x01, 0x46, 0xd5, 0x00, 0x01, 0x46, 0xfe, 0x00,
+    0x01, 0x47, 0x1e, 0x00, 0x01, 0x47, 0x44, 0x00, 0x01, 0x47, 0x67, 0x00,
+    0x01, 0x47, 0x8d, 0x00, 0x01, 0x47, 0xba, 0x00, 0x01, 0x47, 0xdf, 0x00,
+    0x01, 0x48, 0x06, 0x00, 0x01, 0x48, 0x2d, 0x00, 0x01, 0x48, 0x4e, 0x00,
+    0x01, 0x48, 0x74, 0x00, 0x01, 0x48, 0x96, 0x00, 0x01, 0x48, 0xbd, 0x00,
+    0x01, 0x48, 0xe4, 0x00, 0x01, 0x49, 0x09, 0x00, 0x01, 0x49, 0x30, 0x00,
+    0x01, 0x49, 0x53, 0x00, 0x01, 0x49, 0x77, 0x00, 0x01, 0x49, 0x9c, 0x00,
+    0x01, 0x49, 0xc0, 0x00, 0x01, 0x49, 0xe3, 0x00, 0x01, 0x4a, 0x07, 0x00,
+    0x01, 0x4a, 0x2c, 0x00, 0x01, 0x4a, 0x4e, 0x00, 0x01, 0x4a, 0x70, 0x00,
+    0x01, 0x4a, 0x96, 0x00, 0x01, 0x4a, 0xc2, 0x00, 0x01, 0x4a, 0xe4, 0x00,
+    0x01, 0x4b, 0x0d, 0x00, 0x01, 0x4b, 0x37, 0x00, 0x01, 0x4b, 0x60, 0x00,
+    0x01, 0x4b, 0x84, 0x00, 0x01, 0x4b, 0xa8, 0x00, 0x01, 0x4b, 0xcd, 0x00,
+    0x01, 0x4b, 0xf7, 0x00, 0x01, 0x4c, 0x22, 0x00, 0x01, 0x4c, 0x48, 0x00,
+    0x01, 0x4c, 0x73, 0x00, 0x01, 0x4c, 0x9b, 0x00, 0x01, 0x4c, 0xc0, 0x00,
+    0x01, 0x4c, 0xe3, 0x00, 0x01, 0x4d, 0x08, 0x00, 0x01, 0x4d, 0x33, 0x00,
+    0x01, 0x4d, 0x56, 0x00, 0x01, 0x4d, 0x7a, 0x00, 0x01, 0x4d, 0x9f, 0x00,
+    0x01, 0x4d, 0xc7, 0x00, 0x01, 0x4d, 0xee, 0x00, 0x01, 0x4e, 0x12, 0x00,
+    0x01, 0x4e, 0x3d, 0x00, 0x01, 0x4e, 0x61, 0x00, 0x01, 0x4e, 0x86, 0x00,
+    0x01, 0x4e, 0xad, 0x00, 0x01, 0x4e, 0xd9, 0x00, 0x01, 0x4f, 0x02, 0x00,
+    0x01, 0x4f, 0x2e, 0x00, 0x01, 0x4f, 0x53, 0x00, 0x01, 0x4f, 0x7a, 0x00,
+    0x01, 0x4f, 0x9f, 0x00, 0x01, 0x4f, 0xc8, 0x00, 0x01, 0x4f, 0xee, 0x00,
+    0x01, 0x50, 0x17, 0x00, 0x01, 0x50, 0x37, 0x00, 0x01, 0x50, 0x5a, 0x00,
+    0x01, 0x50, 0x7c, 0x00, 0x01, 0x50, 0xa8, 0x00, 0x01, 0x50, 0xcf, 0x00,
+    0x01, 0x50, 0xf9, 0x00, 0x01, 0x51, 0x21, 0x00, 0x01, 0x51, 0x47, 0x00,
+    0x01, 0x51, 0x6b, 0x00, 0x01, 0x51, 0x95, 0x00, 0x01, 0x51, 0xbd, 0x00,
+    0x01, 0x51, 0xe2, 0x00, 0x01, 0x52, 0x09, 0x00, 0x01, 0x52, 0x2f, 0x00,
+    0x01, 0x52, 0x58, 0x00, 0x01, 0x52, 0x7d, 0x00, 0x01, 0x52, 0xa4, 0x00,
+    0x01, 0x52, 0xcd, 0x00, 0x01, 0x52, 0xf2, 0x00, 0x01, 0x53, 0x1d, 0x00,
+    0x01, 0x53, 0x42, 0x00, 0x01, 0x53, 0x69, 0x00, 0x01, 0x53, 0x8f, 0x00,
+    0x01, 0x53, 0xb7, 0x00, 0x01, 0x53, 0xe1, 0x00, 0x01, 0x54, 0x09, 0x00,
+    0x01, 0x54, 0x33, 0x00, 0x01, 0x54, 0x53, 0x00, 0x01, 0x54, 0x7a, 0x00,
+    0x01, 0x54, 0x9e, 0x00, 0x01, 0x54, 0xc7, 0x00, 0x01, 0x54, 0xeb, 0x00,
+    0x01, 0x55, 0x1e, 0x00, 0x01, 0x55, 0x45, 0x00, 0x01, 0x55, 0x70, 0x00,
+    0x01, 0x55, 0x99, 0x00, 0x01, 0x55, 0xbd, 0x00, 0x01, 0x55, 0xe1, 0x00,
+    0x01, 0x56, 0x08, 0x00, 0x01, 0x56, 0x34, 0x00, 0x01, 0x56, 0x57, 0x00,
+    0x01, 0x56, 0x7c, 0x00, 0x01, 0x56, 0xa6, 0x00, 0x01, 0x56, 0xcc, 0x00,
+    0x01, 0x56, 0xf4, 0x00, 0x01, 0x57, 0x19, 0x00, 0x01, 0x57, 0x3f, 0x00,
+    0x01, 0x57, 0x61, 0x00, 0x01, 0x57, 0x87, 0x00, 0x01, 0x57, 0xab, 0x00,
+    0x01, 0x57, 0xd2, 0x00, 0x01, 0x57, 0xf3, 0x00, 0x01, 0x58, 0x1b, 0x00,
+    0x01, 0x58, 0x48, 0x00, 0x01, 0x58, 0x69, 0x00, 0x01, 0x58, 0x92, 0x00,
+    0x01, 0x58, 0xbd, 0x00, 0x01, 0x58, 0xe7, 0x00, 0x01, 0x59, 0x10, 0x00,
+    0x01, 0x59, 0x38, 0x00, 0x01, 0x59, 0x5d, 0x00, 0x01, 0x59, 0x83, 0x00,
+    0x01, 0x59, 0xa9, 0x00, 0x01, 0x59, 0xcf, 0x00, 0x01, 0x59, 0xf8, 0x00,
+    0x01, 0x5a, 0x1d, 0x00, 0x01, 0x5a, 0x40, 0x00, 0x01, 0x5a, 0x68, 0x00,
+    0x01, 0x5a, 0x8d, 0x00, 0x01, 0x5a, 0xb3, 0x00, 0x01, 0x5a, 0xdb, 0x00,
+    0x01, 0x5a, 0xfd, 0x00, 0x01, 0x5b, 0x24, 0x00, 0x01, 0x5b, 0x48, 0x00,
+    0x01, 0x5b, 0x6f, 0x00, 0x01, 0x5b, 0x9b, 0x00, 0x01, 0x5b, 0xbf, 0x00,
+    0x01, 0x5b, 0xe6, 0x00, 0x01, 0x5c, 0x13, 0x00, 0x01, 0x5c, 0x35, 0x00,
+    0x01, 0x5c, 0x5a, 0x00, 0x01, 0x5c, 0x85, 0x00, 0x01, 0x5c, 0xaf, 0x00,
+    0x01, 0x5c, 0xd8, 0x00, 0x01, 0x5d, 0x01, 0x00, 0x01, 0x5d, 0x29, 0x00,
+    0x01, 0x5d, 0x4f, 0x00, 0x01, 0x5d, 0x74, 0x00, 0x01, 0x5d, 0x99, 0x00,
+    0x01, 0x5d, 0xbd, 0x00, 0x01, 0x5d, 0xe7, 0x00, 0x01, 0x5e, 0x08, 0x00,
+    0x01, 0x5e, 0x2e, 0x00, 0x01, 0x5e, 0x50, 0x00, 0x01, 0x5e, 0x72, 0x00,
+    0x01, 0x5e, 0x97, 0x00, 0x01, 0x5e, 0xbf, 0x00, 0x01, 0x5e, 0xe0, 0x00,
+    0x01, 0x5f, 0x07, 0x00, 0x01, 0x5f, 0x2e, 0x00, 0x01, 0x5f, 0x55, 0x00,
+    0x01, 0x5f, 0x83, 0x00, 0x01, 0x5f, 0xa2, 0x00, 0x01, 0x5f, 0xc6, 0x00,
+    0x01, 0x5f, 0xe6, 0x00, 0x01, 0x60, 0x16, 0x00, 0x01, 0x60, 0x3b, 0x00,
+    0x01, 0x60, 0x60, 0x00, 0x01, 0x60, 0x89, 0x00, 0x01, 0x60, 0xad, 0x00,
+    0x01, 0x60, 0xd8, 0x00, 0x01, 0x60, 0xf9, 0x00, 0x01, 0x61, 0x25, 0x00,
+    0x01, 0x61, 0x4a, 0x00, 0x01, 0x61, 0x70, 0x00, 0x01, 0x61, 0x93, 0x00,
+    0x01, 0x61, 0xba, 0x00, 0x01, 0x61, 0xdb, 0x00, 0x01, 0x62, 0x09, 0x00,
+    0x01, 0x62, 0x2d, 0x00, 0x01, 0x62, 0x4e, 0x00, 0x01, 0x62, 0x76, 0x00,
+    0x01, 0x62, 0x9b, 0x00, 0x01, 0x62, 0xc2, 0x00, 0x01, 0x62, 0xe8, 0x00,
+    0x01, 0x63, 0x09, 0x00, 0x01, 0x63, 0x31, 0x00, 0x01, 0x63, 0x55, 0x00,
+    0x01, 0x63, 0x7a, 0x00, 0x01, 0x63, 0x9e, 0x00, 0x01, 0x63, 0xca, 0x00,
+    0x01, 0x63, 0xf2, 0x00, 0x01, 0x64, 0x1b, 0x00, 0x01, 0x64, 0x3e, 0x00,
+    0x01, 0x64, 0x67, 0x00, 0x01, 0x64, 0x8d, 0x00, 0x01, 0x64, 0xb0, 0x00,
+    0x01, 0x64, 0xd7, 0x00, 0x01, 0x64, 0xfc, 0x00, 0x01, 0x65, 0x20, 0x00,
+    0x01, 0x65, 0x45, 0x00, 0x01, 0x65, 0x68, 0x00, 0x01, 0x65, 0x8c, 0x00,
+    0x01, 0x65, 0xaf, 0x00, 0x01, 0x65, 0xd3, 0x00, 0x01, 0x65, 0xfa, 0x00,
+    0x01, 0x66, 0x1d, 0x00, 0x01, 0x66, 0x48, 0x00, 0x01, 0x66, 0x6f, 0x00,
+    0x01, 0x66, 0x97, 0x00, 0x01, 0x66, 0xbe, 0x00, 0x01, 0x66, 0xe5, 0x00,
+    0x01, 0x67, 0x0f, 0x00, 0x01, 0x67, 0x33, 0x00, 0x01, 0x67, 0x57, 0x00,
+    0x01, 0x67, 0x7e, 0x00, 0x01, 0x67, 0xa1, 0x00, 0x01, 0x67, 0xc3, 0x00,
+    0x01, 0x67, 0xea, 0x00, 0x01, 0x68, 0x10, 0x00, 0x01, 0x68, 0x36, 0x00,
+    0x01, 0x68, 0x58, 0x00, 0x01, 0x68, 0x82, 0x00, 0x01, 0x68, 0xa8, 0x00,
+    0x01, 0x68, 0xd1, 0x00, 0x01, 0x68, 0xf6, 0x00, 0x01, 0x69, 0x1c, 0x00,
+    0x01, 0x69, 0x44, 0x00, 0x01, 0x69, 0x69, 0x00, 0x01, 0x69, 0x8d, 0x00,
+    0x01, 0x69, 0xb3, 0x00, 0x01, 0x69, 0xd7, 0x00, 0x01, 0x6a, 0x02, 0x00,
+    0x01, 0x6a, 0x27, 0x00, 0x01, 0x6a, 0x50, 0x00, 0x01, 0x6a, 0x75, 0x00,
+    0x01, 0x6a, 0x9e, 0x00, 0x01, 0x6a, 0xcb, 0x00, 0x01, 0x6a, 0xf3, 0x00,
+    0x01, 0x6b, 0x1a, 0x00, 0x01, 0x6b, 0x41, 0x00, 0x01, 0x6b, 0x6a, 0x00,
+    0x01, 0x6b, 0x91, 0x00, 0x01, 0x6b, 0xb4, 0x00, 0x01, 0x6b, 0xda, 0x00,
+    0x01, 0x6b, 0xfe, 0x00, 0x01, 0x6c, 0x21, 0x00, 0x01, 0x6c, 0x47, 0x00,
+    0x01, 0x6c, 0x72, 0x00, 0x01, 0x6c, 0x98, 0x00, 0x01, 0x6c, 0xbb, 0x00,
+    0x01, 0x6c, 0xe1, 0x00, 0x01, 0x6d, 0x01, 0x00, 0x01, 0x6d, 0x28, 0x00,
+    0x01, 0x6d, 0x4c, 0x00, 0x01, 0x6d, 0x6e, 0x00, 0x01, 0x6d, 0x8d, 0x00,
+    0x01, 0x6d, 0xb1, 0x00, 0x01, 0x6d, 0xd6, 0x00, 0x01, 0x6d, 0xf9, 0x00,
+    0x01, 0x6e, 0x1e, 0x00, 0x01, 0x6e, 0x44, 0x00, 0x01, 0x6e, 0x6d, 0x00,
+    0x01, 0x6e, 0x98, 0x00, 0x01, 0x6e, 0xbf, 0x00, 0x01, 0x6e, 0xe7, 0x00,
+    0x01, 0x6f, 0x10, 0x00, 0x01, 0x6f, 0x3c, 0x00, 0x01, 0x6f, 0x5e, 0x00,
+    0x01, 0x6f, 0x82, 0x00, 0x01, 0x6f, 0xa7, 0x00, 0x01, 0x6f, 0xc7, 0x00,
+    0x01, 0x6f, 0xed, 0x00, 0x01, 0x70, 0x17, 0x00, 0x01, 0x70, 0x3d, 0x00,
+    0x01, 0x70, 0x64, 0x00, 0x01, 0x70, 0x87, 0x00, 0x01, 0x70, 0xab, 0x00,
+    0x01, 0x70, 0xcb, 0x00, 0x01, 0x70, 0xf2, 0x00, 0x01, 0x71, 0x18, 0x00,
+    0x01, 0x71, 0x3b, 0x00, 0x01, 0x71, 0x5f, 0x00, 0x01, 0x71, 0x82, 0x00,
+    0x01, 0x71, 0xa6, 0x00, 0x01, 0x71, 0xcb, 0x00, 0x01, 0x71, 0xf0, 0x00,
+    0x01, 0x72, 0x1a, 0x00, 0x01, 0x72, 0x3e, 0x00, 0x01, 0x72, 0x62, 0x00,
+    0x01, 0x72, 0x8c, 0x00, 0x01, 0x72, 0xb0, 0x00, 0x01, 0x72, 0xd4, 0x00,
+    0x01, 0x72, 0xf7, 0x00, 0x01, 0x73, 0x16, 0x00, 0x01, 0x73, 0x35, 0x00,
+    0x01, 0x73, 0x57, 0x00, 0x01, 0x73, 0x7d, 0x00, 0x01, 0x73, 0xa2, 0x00,
+    0x01, 0x73, 0xc8, 0x00, 0x01, 0x73, 0xed, 0x00, 0x01, 0x74, 0x16, 0x00,
+    0x01, 0x74, 0x37, 0x00, 0x01, 0x74, 0x63, 0x00, 0x01, 0x74, 0x8d, 0x00,
+    0x01, 0x74, 0xb1, 0x00, 0x01, 0x74, 0xd6, 0x00, 0x01, 0x74, 0xfa, 0x00,
+    0x01, 0x75, 0x23, 0x00, 0x01, 0x75, 0x4a, 0x00, 0x01, 0x75, 0x6d, 0x00,
+    0x01, 0x75, 0x91, 0x00, 0x01, 0x75, 0xb4, 0x00, 0x01, 0x75, 0xda, 0x00,
+    0x01, 0x76, 0x00, 0x00, 0x01, 0x76, 0x25, 0x00, 0x01, 0x76, 0x4b, 0x00,
+    0x01, 0x76, 0x71, 0x00, 0x01, 0x76, 0x98, 0x00, 0x01, 0x76, 0xbb, 0x00,
+    0x01, 0x76, 0xe0, 0x00, 0x01, 0x77, 0x04, 0x00, 0x01, 0x77, 0x2d, 0x00,
+    0x01, 0x77, 0x55, 0x00, 0x01, 0x77, 0x79, 0x00, 0x01, 0x77, 0x9a, 0x00,
+    0x01, 0x77, 0xbf, 0x00, 0x01, 0x77, 0xe3, 0x00, 0x01, 0x78, 0x09, 0x00,
+    0x01, 0x78, 0x2d, 0x00, 0x01, 0x78, 0x5e, 0x00, 0x01, 0x78, 0x83, 0x00,
+    0x01, 0x78, 0xab, 0x00, 0x01, 0x78, 0xd7, 0x00, 0x01, 0x78, 0xfc, 0x00,
+    0x01, 0x79, 0x1f, 0x00, 0x01, 0x79, 0x4a, 0x00, 0x01, 0x79, 0x6d, 0x00,
+    0x01, 0x79, 0x92, 0x00, 0x01, 0x79, 0xba, 0x00, 0x01, 0x79, 0xe0, 0x00,
+    0x01, 0x7a, 0x07, 0x00, 0x01, 0x7a, 0x2c, 0x00, 0x01, 0x7a, 0x50, 0x00,
+    0x01, 0x7a, 0x73, 0x00, 0x01, 0x7a, 0x9a, 0x00, 0x01, 0x7a, 0xbe, 0x00,
+    0x01, 0x7a, 0xe5, 0x00, 0x01, 0x7b, 0x08, 0x00, 0x01, 0x7b, 0x2e, 0x00,
+    0x01, 0x7b, 0x53, 0x00, 0x01, 0x7b, 0x75, 0x00, 0x01, 0x7b, 0x9c, 0x00,
+    0x01, 0x7b, 0xc8, 0x00, 0x01, 0x7b, 0xee, 0x00, 0x01, 0x7c, 0x11, 0x00,
+    0x01, 0x7c, 0x34, 0x00, 0x01, 0x7c, 0x59, 0x00, 0x01, 0x7c, 0x82, 0x00,
+    0x01, 0x7c, 0xad, 0x00, 0x01, 0x7c, 0xd4, 0x00, 0x01, 0x7c, 0xfe, 0x00,
+    0x01, 0x7d, 0x26, 0x00, 0x01, 0x7d, 0x50, 0x00, 0x01, 0x7d, 0x76, 0x00,
+    0x01, 0x7d, 0x9d, 0x00, 0x01, 0x7d, 0xc9, 0x00, 0x01, 0x7d, 0xf1, 0x00,
+    0x01, 0x7e, 0x16, 0x00, 0x01, 0x7e, 0x3d, 0x00, 0x01, 0x7e, 0x5f, 0x00,
+    0x01, 0x7e, 0x87, 0x00, 0x01, 0x7e, 0xae, 0x00, 0x01, 0x7e, 0xd5, 0x00,
+    0x01, 0x7e, 0xfa, 0x00, 0x01, 0x7f, 0x20, 0x00, 0x01, 0x7f, 0x47, 0x00,
+    0x01, 0x7f, 0x6a, 0x00, 0x01, 0x7f, 0x93, 0x00, 0x01, 0x7f, 0xbb, 0x00,
+    0x01, 0x7f, 0xe0, 0x00, 0x01, 0x80, 0x09, 0x00, 0x01, 0x80, 0x2e, 0x00,
+    0x01, 0x80, 0x4e, 0x00, 0x01, 0x80, 0x71, 0x00, 0x01, 0x80, 0x99, 0x00,
+    0x01, 0x80, 0xbe, 0x00, 0x01, 0x80, 0xe3, 0x00, 0x01, 0x81, 0x06, 0x00,
+    0x01, 0x81, 0x2a, 0x00, 0x01, 0x81, 0x57, 0x00, 0x01, 0x81, 0x79, 0x00,
+    0x01, 0x81, 0x9b, 0x00, 0x01, 0x81, 0xbb, 0x00, 0x01, 0x81, 0xdc, 0x00,
+    0x01, 0x82, 0x03, 0x00, 0x01, 0x82, 0x27, 0x00, 0x01, 0x82, 0x4b, 0x00,
+    0x01, 0x82, 0x79, 0x00, 0x01, 0x82, 0x9e, 0x00, 0x01, 0x82, 0xc4, 0x00,
+    0x01, 0x82, 0xeb, 0x00, 0x01, 0x83, 0x12, 0x00, 0x01, 0x83, 0x36, 0x00,
+    0x01, 0x83, 0x5c, 0x00, 0x01, 0x83, 0x7f, 0x00, 0x01, 0x83, 0xa6, 0x00,
+    0x01, 0x83, 0xc9, 0x00, 0x01, 0x83, 0xed, 0x00, 0x01, 0x84, 0x14, 0x00,
+    0x01, 0x84, 0x3c, 0x00, 0x01, 0x84, 0x68, 0x00, 0x01, 0x84, 0x92, 0x00,
+    0x01, 0x84, 0xb6, 0x00, 0x01, 0x84, 0xdc, 0x00, 0x01, 0x85, 0x05, 0x00,
+    0x01, 0x85, 0x2d, 0x00, 0x01, 0x85, 0x56, 0x00, 0x01, 0x85, 0x7b, 0x00,
+    0x01, 0x85, 0xa3, 0x00, 0x01, 0x85, 0xcb, 0x00, 0x01, 0x85, 0xf0, 0x00,
+    0x01, 0x86, 0x19, 0x00, 0x01, 0x86, 0x40, 0x00, 0x01, 0x86, 0x63, 0x00,
+    0x01, 0x86, 0x87, 0x00, 0x01, 0x86, 0xad, 0x00, 0x01, 0x86, 0xd3, 0x00,
+    0x01, 0x86, 0xf9, 0x00, 0x01, 0x87, 0x22, 0x00, 0x01, 0x87, 0x48, 0x00,
+    0x01, 0x87, 0x6f, 0x00, 0x01, 0x87, 0x95, 0x00, 0x01, 0x87, 0xc0, 0x00,
+    0x01, 0x87, 0xe7, 0x00, 0x01, 0x88, 0x0c, 0x00, 0x01, 0x88, 0x36, 0x00,
+    0x01, 0x88, 0x5b, 0x00, 0x01, 0x88, 0x7f, 0x00, 0x01, 0x88, 0xa5, 0x00,
+    0x01, 0x88, 0xc6, 0x00, 0x01, 0x88, 0xeb, 0x00, 0x01, 0x89, 0x13, 0x00,
+    0x01, 0x89, 0x39, 0x00, 0x01, 0x89, 0x5c, 0x00, 0x01, 0x89, 0x80, 0x00,
+    0x01, 0x89, 0xa7, 0x00, 0x01, 0x89, 0xcc, 0x00, 0x01, 0x89, 0xf2, 0x00,
+    0x01, 0x8a, 0x1a, 0x00, 0x01, 0x8a, 0x41, 0x00, 0x01, 0x8a, 0x67, 0x00,
+    0x01, 0x8a, 0x8b, 0x00, 0x01, 0x8a, 0xb2, 0x00, 0x01, 0x8a, 0xd4, 0x00,
+    0x01, 0x8a, 0xf8, 0x00, 0x01, 0x8b, 0x19, 0x00, 0x01, 0x8b, 0x3c, 0x00,
+    0x01, 0x8b, 0x5c, 0x00, 0x01, 0x8b, 0x83, 0x00, 0x01, 0x8b, 0xa7, 0x00,
+    0x01, 0x8b, 0xd0, 0x00, 0x01, 0x8b, 0xfb, 0x00, 0x01, 0x8c, 0x1d, 0x00,
+    0x01, 0x8c, 0x3d, 0x00, 0x01, 0x8c, 0x67, 0x00, 0x01, 0x8c, 0x89, 0x00,
+    0x01, 0x8c, 0xaa, 0x00, 0x01, 0x8c, 0xce, 0x00, 0x01, 0x8c, 0xf7, 0x00,
+    0x01, 0x8d, 0x1f, 0x00, 0x01, 0x8d, 0x45, 0x00, 0x01, 0x8d, 0x67, 0x00,
+    0x01, 0x8d, 0x89, 0x00, 0x01, 0x8d, 0xab, 0x00, 0x01, 0x8d, 0xd3, 0x00,
+    0x01, 0x8d, 0xf6, 0x00, 0x01, 0x8e, 0x1e, 0x00, 0x01, 0x8e, 0x41, 0x00,
+    0x01, 0x8e, 0x62, 0x00, 0x01, 0x8e, 0x87, 0x00, 0x01, 0x8e, 0xab, 0x00,
+    0x01, 0x8e, 0xd1, 0x00, 0x01, 0x8e, 0xf2, 0x00, 0x01, 0x8f, 0x1a, 0x00,
+    0x01, 0x8f, 0x3d, 0x00, 0x01, 0x8f, 0x62, 0x00, 0x01, 0x8f, 0x88, 0x00,
+    0x01, 0x8f, 0xab, 0x00, 0x01, 0x8f, 0xd3, 0x00, 0x01, 0x8f, 0xf8, 0x00,
+    0x01, 0x90, 0x1b, 0x00, 0x01, 0x90, 0x3e, 0x00, 0x01, 0x90, 0x65, 0x00,
+    0x01, 0x90, 0x8b, 0x00, 0x01, 0x90, 0xaf, 0x00, 0x01, 0x90, 0xd2, 0x00,
+    0x01, 0x90, 0xf5, 0x00, 0x01, 0x91, 0x1e, 0x00, 0x01, 0x91, 0x49, 0x00,
+    0x01, 0x91, 0x6b, 0x00, 0x01, 0x91, 0x92, 0x00, 0x01, 0x91, 0xbf, 0x00,
+    0x01, 0x91, 0xed, 0x00, 0x01, 0x92, 0x14, 0x00, 0x01, 0x92, 0x3c, 0x00,
+    0x01, 0x92, 0x61, 0x00, 0x01, 0x92, 0x89, 0x00, 0x01, 0x92, 0xb3, 0x00,
+    0x01, 0x92, 0xd7, 0x00, 0x01, 0x92, 0xff, 0x00, 0x01, 0x93, 0x23, 0x00,
+    0x01, 0x93, 0x4c, 0x00, 0x01, 0x93, 0x73, 0x00, 0x01, 0x93, 0x95, 0x00,
+    0x01, 0x93, 0xbc, 0x00, 0x01, 0x93, 0xe1, 0x00, 0x01, 0x94, 0x09, 0x00,
+    0x01, 0x94, 0x31, 0x00, 0x01, 0x94, 0x5a, 0x00, 0x01, 0x94, 0x80, 0x00,
+    0x01, 0x94, 0xa9, 0x00, 0x01, 0x94, 0xd1, 0x00, 0x01, 0x94, 0xf8, 0x00,
+    0x01, 0x95, 0x1e, 0x00, 0x01, 0x95, 0x42, 0x00, 0x01, 0x95, 0x66, 0x00,
+    0x01, 0x95, 0x8d, 0x00, 0x01, 0x95, 0xb7, 0x00, 0x01, 0x95, 0xdb, 0x00,
+    0x01, 0x96, 0x00, 0x00, 0x01, 0x96, 0x27, 0x00, 0x01, 0x96, 0x4a, 0x00,
+    0x01, 0x96, 0x6d, 0x00, 0x01, 0x96, 0x93, 0x00, 0x01, 0x96, 0xb9, 0x00,
+    0x01, 0x96, 0xdc, 0x00, 0x01, 0x97, 0x06, 0x00, 0x01, 0x97, 0x29, 0x00,
+    0x01, 0x97, 0x4d, 0x00, 0x01, 0x97, 0x70, 0x00, 0x01, 0x97, 0x98, 0x00,
+    0x01, 0x97, 0xbd, 0x00, 0x01, 0x97, 0xe6, 0x00, 0x01, 0x98, 0x0d, 0x00,
+    0x01, 0x98, 0x32, 0x00, 0x01, 0x98, 0x5c, 0x00, 0x01, 0x98, 0x85, 0x00,
+    0x01, 0x98, 0xac, 0x00, 0x01, 0x98, 0xd2, 0x00, 0x01, 0x98, 0xf7, 0x00,
+    0x01, 0x99, 0x1b, 0x00, 0x01, 0x99, 0x3d, 0x00, 0x01, 0x99, 0x65, 0x00,
+    0x01, 0x99, 0x89, 0x00, 0x01, 0x99, 0xad, 0x00, 0x01, 0x99, 0xd0, 0x00,
+    0x01, 0x99, 0xf4, 0x00, 0x01, 0x9a, 0x17, 0x00, 0x01, 0x9a, 0x3e, 0x00,
+    0x01, 0x9a, 0x5e, 0x00, 0x01, 0x9a, 0x81, 0x00, 0x01, 0x9a, 0xa8, 0x00,
+    0x01, 0x9a, 0xca, 0x00, 0x01, 0x9a, 0xf4, 0x00, 0x01, 0x9b, 0x1d, 0x00,
+    0x01, 0x9b, 0x44, 0x00, 0x01, 0x9b, 0x67, 0x00, 0x01, 0x9b, 0x8f, 0x00,
+    0x01, 0x9b, 0xae, 0x00, 0x01, 0x9b, 0xd7, 0x00, 0x01, 0x9c, 0x00, 0x00,
+    0x01, 0x9c, 0x26, 0x00, 0x01, 0x9c, 0x48, 0x00, 0x01, 0x9c, 0x6f, 0x00,
+    0x01, 0x9c, 0x99, 0x00, 0x01, 0x9c, 0xbc, 0x00, 0x01, 0x9c, 0xe3, 0x00,
+    0x01, 0x9d, 0x0f, 0x00, 0x01, 0x9d, 0x38, 0x00, 0x01, 0x9d, 0x5f, 0x00,
+    0x01, 0x9d, 0x8b, 0x00, 0x01, 0x9d, 0xb3, 0x00, 0x01, 0x9d, 0xd5, 0x00,
+    0x01, 0x9d, 0xfa, 0x00, 0x01, 0x9e, 0x1e, 0x00, 0x01, 0x9e, 0x46, 0x00,
+    0x01, 0x9e, 0x71, 0x00, 0x01, 0x9e, 0x95, 0x00, 0x01, 0x9e, 0xbd, 0x00,
+    0x01, 0x9e, 0xe2, 0x00, 0x01, 0x9f, 0x06, 0x00, 0x01, 0x9f, 0x2b, 0x00,
+    0x01, 0x9f, 0x54, 0x00, 0x01, 0x9f, 0x79, 0x00, 0x01, 0x9f, 0x9c, 0x00,
+    0x01, 0x9f, 0xbf, 0x00, 0x01, 0x9f, 0xe6, 0x00, 0x01, 0xa0, 0x0d, 0x00,
+    0x01, 0xa0, 0x31, 0x00, 0x01, 0xa0, 0x54, 0x00, 0x01, 0xa0, 0x7e, 0x00,
+    0x01, 0xa0, 0xa2, 0x00, 0x01, 0xa0, 0xcc, 0x00, 0x01, 0xa0, 0xf8, 0x00,
+    0x01, 0xa1, 0x1f, 0x00, 0x01, 0xa1, 0x46, 0x00, 0x01, 0xa1, 0x6d, 0x00,
+    0x01, 0xa1, 0x8f, 0x00, 0x01, 0xa1, 0xb7, 0x00, 0x01, 0xa1, 0xe4, 0x00,
+    0x01, 0xa2, 0x07, 0x00, 0x01, 0xa2, 0x2f, 0x00, 0x01, 0xa2, 0x53, 0x00,
+    0x01, 0xa2, 0x79, 0x00, 0x01, 0xa2, 0x9a, 0x00, 0x01, 0xa2, 0xc4, 0x00,
+    0x01, 0xa2, 0xe7, 0x00, 0x01, 0xa3, 0x0d, 0x00, 0x01, 0xa3, 0x30, 0x00,
+    0x01, 0xa3, 0x56, 0x00, 0x01, 0xa3, 0x79, 0x00, 0x01, 0xa3, 0x9e, 0x00,
+    0x01, 0xa3, 0xcb, 0x00, 0x01, 0xa3, 0xf0, 0x00, 0x01, 0xa4, 0x16, 0x00,
+    0x01, 0xa4, 0x39, 0x00, 0x01, 0xa4, 0x66, 0x00, 0x01, 0xa4, 0x8b, 0x00,
+    0x01, 0xa4, 0xaf, 0x00, 0x01, 0xa4, 0xd2, 0x00, 0x01, 0xa5, 0x01, 0x00,
+    0x01, 0xa5, 0x22, 0x00, 0x01, 0xa5, 0x46, 0x00, 0x01, 0xa5, 0x6f, 0x00,
+    0x01, 0xa5, 0x98, 0x00, 0x01, 0xa5, 0xbb, 0x00, 0x01, 0xa5, 0xe0, 0x00,
+    0x01, 0xa6, 0x0e, 0x00, 0x01, 0xa6, 0x34, 0x00, 0x01, 0xa6, 0x5d, 0x00,
+    0x01, 0xa6, 0x80, 0x00, 0x01, 0xa6, 0xa4, 0x00, 0x01, 0xa6, 0xd1, 0x00,
+    0x01, 0xa6, 0xf6, 0x00, 0x01, 0xa7, 0x1b, 0x00, 0x01, 0xa7, 0x42, 0x00,
+    0x01, 0xa7, 0x67, 0x00, 0x01, 0xa7, 0x8b, 0x00, 0x01, 0xa7, 0xad, 0x00,
+    0x01, 0xa7, 0xd6, 0x00, 0x01, 0xa7, 0xfc, 0x00, 0x01, 0xa8, 0x22, 0x00,
+    0x01, 0xa8, 0x49, 0x00, 0x01, 0xa8, 0x6d, 0x00, 0x01, 0xa8, 0x8d, 0x00,
+    0x01, 0xa8, 0xb2, 0x00, 0x01, 0xa8, 0xd8, 0x00, 0x01, 0xa8, 0xfb, 0x00,
+    0x01, 0xa9, 0x22, 0x00, 0x01, 0xa9, 0x4b, 0x00, 0x01, 0xa9, 0x6f, 0x00,
+    0x01, 0xa9, 0x96, 0x00, 0x01, 0xa9, 0xc0, 0x00, 0x01, 0xa9, 0xe6, 0x00,
+    0x01, 0xaa, 0x0e, 0x00, 0x01, 0xaa, 0x36, 0x00, 0x01, 0xaa, 0x5b, 0x00,
+    0x01, 0xaa, 0x81, 0x00, 0x01, 0xaa, 0xa8, 0x00, 0x01, 0xaa, 0xcb, 0x00,
+    0x01, 0xaa, 0xee, 0x00, 0x01, 0xab, 0x12, 0x00, 0x01, 0xab, 0x33, 0x00,
+    0x01, 0xab, 0x56, 0x00, 0x01, 0xab, 0x80, 0x00, 0x01, 0xab, 0xa2, 0x00,
+    0x01, 0xab, 0xc8, 0x00, 0x01, 0xab, 0xf5, 0x00, 0x01, 0xac, 0x1a, 0x00,
+    0x01, 0xac, 0x48, 0x00, 0x01, 0xac, 0x73, 0x00, 0x01, 0xac, 0x97, 0x00,
+    0x01, 0xac, 0xc2, 0x00, 0x01, 0xac, 0xe5, 0x00, 0x01, 0xad, 0x08, 0x00,
+    0x01, 0xad, 0x2c, 0x00, 0x01, 0xad, 0x4e, 0x00, 0x01, 0xad, 0x76, 0x00,
+    0x01, 0xad, 0x98, 0x00, 0x01, 0xad, 0xbc, 0x00, 0x01, 0xad, 0xe1, 0x00,
+    0x01, 0xae, 0x0c, 0x00, 0x01, 0xae, 0x37, 0x00, 0x01, 0xae, 0x5f, 0x00,
+    0x01, 0xae, 0x87, 0x00, 0x01, 0xae, 0xb3, 0x00, 0x01, 0xae, 0xd9, 0x00,
+    0x01, 0xae, 0xfa, 0x00, 0x01, 0xaf, 0x21, 0x00, 0x01, 0xaf, 0x45, 0x00,
+    0x01, 0xaf, 0x68, 0x00, 0x01, 0xaf, 0x8b, 0x00, 0x01, 0xaf, 0xb2, 0x00,
+    0x01, 0xaf, 0xd5, 0x00, 0x01, 0xaf, 0xfb, 0x00, 0x01, 0xb0, 0x20, 0x00,
+    0x01, 0xb0, 0x42, 0x00, 0x01, 0xb0, 0x6b, 0x00, 0x01, 0xb0, 0x90, 0x00,
+    0x01, 0xb0, 0xbc, 0x00, 0x01, 0xb0, 0xe2, 0x00, 0x01, 0xb1, 0x0a, 0x00,
+    0x01, 0xb1, 0x32, 0x00, 0x01, 0xb1, 0x56, 0x00, 0x01, 0xb1, 0x7b, 0x00,
+    0x01, 0xb1, 0x9f, 0x00, 0x01, 0xb1, 0xc4, 0x00, 0x01, 0xb1, 0xe9, 0x00,
+    0x01, 0xb2, 0x0e, 0x00, 0x01, 0xb2, 0x33, 0x00, 0x01, 0xb2, 0x59, 0x00,
+    0x01, 0xb2, 0x7e, 0x00, 0x01, 0xb2, 0xa2, 0x00, 0x01, 0xb2, 0xcc, 0x00,
+    0x01, 0xb2, 0xf3, 0x00, 0x01, 0xb3, 0x1c, 0x00, 0x01, 0xb3, 0x46, 0x00,
+    0x01, 0xb3, 0x6d, 0x00, 0x01, 0xb3, 0x97, 0x00, 0x01, 0xb3, 0xba, 0x00,
+    0x01, 0xb3, 0xde, 0x00, 0x01, 0xb4, 0x06, 0x00, 0x01, 0xb4, 0x33, 0x00,
+    0x01, 0xb4, 0x5a, 0x00, 0x01, 0xb4, 0x83, 0x00, 0x01, 0xb4, 0xaa, 0x00,
+    0x01, 0xb4, 0xcc, 0x00, 0x01, 0xb4, 0xf1, 0x00, 0x01, 0xb5, 0x1c, 0x00,
+    0x01, 0xb5, 0x40, 0x00, 0x01, 0xb5, 0x66, 0x00, 0x01, 0xb5, 0x8b, 0x00,
+    0x01, 0xb5, 0xb0, 0x00, 0x01, 0xb5, 0xd9, 0x00, 0x01, 0xb5, 0xfc, 0x00,
+    0x01, 0xb6, 0x24, 0x00, 0x01, 0xb6, 0x4a, 0x00, 0x01, 0xb6, 0x76, 0x00,
+    0x01, 0xb6, 0x9c, 0x00, 0x01, 0xb6, 0xc5, 0x00, 0x01, 0xb6, 0xe8, 0x00,
+    0x01, 0xb7, 0x12, 0x00, 0x01, 0xb7, 0x39, 0x00, 0x01, 0xb7, 0x5c, 0x00,
+    0x01, 0xb7, 0x7f, 0x00, 0x01, 0xb7, 0xa9, 0x00, 0x01, 0xb7, 0xd0, 0x00,
+    0x01, 0xb7, 0xf5, 0x00, 0x01, 0xb8, 0x19, 0x00, 0x01, 0xb8, 0x40, 0x00,
+    0x01, 0xb8, 0x63, 0x00, 0x01, 0xb8, 0x87, 0x00, 0x01, 0xb8, 0xac, 0x00,
+    0x01, 0xb8, 0xd2, 0x00, 0x01, 0xb8, 0xf8, 0x00, 0x01, 0xb9, 0x1d, 0x00,
+    0x01, 0xb9, 0x41, 0x00, 0x01, 0xb9, 0x68, 0x00, 0x01, 0xb9, 0x90, 0x00,
+    0x01, 0xb9, 0xb5, 0x00, 0x01, 0xb9, 0xda, 0x00, 0x01, 0xb9, 0xff, 0x00,
+    0x01, 0xba, 0x26, 0x00, 0x01, 0xba, 0x47, 0x00, 0x01, 0xba, 0x6f, 0x00,
+    0x01, 0xba, 0x93, 0x00, 0x01, 0xba, 0xb8, 0x00, 0x01, 0xba, 0xe6, 0x00,
+    0x01, 0xbb, 0x09, 0x00, 0x01, 0xbb, 0x2e, 0x00, 0x01, 0xbb, 0x5a, 0x00,
+    0x01, 0xbb, 0x82, 0x00, 0x01, 0xbb, 0xaa, 0x00, 0x01, 0xbb, 0xd5, 0x00,
+    0x01, 0xbb, 0xf9, 0x00, 0x01, 0xbc, 0x1b, 0x00, 0x01, 0xbc, 0x42, 0x00,
+    0x01, 0xbc, 0x6c, 0x00, 0x01, 0xbc, 0x96, 0x00, 0x01, 0xbc, 0xb8, 0x00,
+    0x01, 0xbc, 0xda, 0x00, 0x01, 0xbc, 0xfc, 0x00, 0x01, 0xbd, 0x25, 0x00,
+    0x01, 0xbd, 0x53, 0x00, 0x01, 0xbd, 0x7b, 0x00, 0x01, 0xbd, 0x9c, 0x00,
+    0x01, 0xbd, 0xc2, 0x00, 0x01, 0xbd, 0xec, 0x00, 0x01, 0xbe, 0x10, 0x00,
+    0x01, 0xbe, 0x39, 0x00, 0x01, 0xbe, 0x5d, 0x00, 0x01, 0xbe, 0x80, 0x00,
+    0x01, 0xbe, 0xa6, 0x00, 0x01, 0xbe, 0xc9, 0x00, 0x01, 0xbe, 0xec, 0x00,
+    0x01, 0xbf, 0x12, 0x00, 0x01, 0xbf, 0x37, 0x00, 0x01, 0xbf, 0x5e, 0x00,
+    0x01, 0xbf, 0x8a, 0x00, 0x01, 0xbf, 0xb3, 0x00, 0x01, 0xbf, 0xda, 0x00,
+    0x01, 0xbf, 0xff, 0x00, 0x01, 0xc0, 0x21, 0x00, 0x01, 0xc0, 0x41, 0x00,
+    0x01, 0xc0, 0x6a, 0x00, 0x01, 0xc0, 0x8f, 0x00, 0x01, 0xc0, 0xaf, 0x00,
+    0x01, 0xc0, 0xd4, 0x00, 0x01, 0xc0, 0xfe, 0x00, 0x01, 0xc1, 0x24, 0x00,
+    0x01, 0xc1, 0x4e, 0x00, 0x01, 0xc1, 0x76, 0x00, 0x01, 0xc1, 0x9c, 0x00,
+    0x01, 0xc1, 0xc4, 0x00, 0x01, 0xc1, 0xeb, 0x00, 0x01, 0xc2, 0x14, 0x00,
+    0x01, 0xc2, 0x36, 0x00, 0x01, 0xc2, 0x61, 0x00, 0x01, 0xc2, 0x86, 0x00,
+    0x01, 0xc2, 0xae, 0x00, 0x01, 0xc2, 0xd4, 0x00, 0x01, 0xc2, 0xfc, 0x00,
+    0x01, 0xc3, 0x20, 0x00, 0x01, 0xc3, 0x46, 0x00, 0x01, 0xc3, 0x69, 0x00,
+    0x01, 0xc3, 0x92, 0x00, 0x01, 0xc3, 0xba, 0x00, 0x01, 0xc3, 0xda, 0x00,
+    0x01, 0xc3, 0xff, 0x00, 0x01, 0xc4, 0x2a, 0x00, 0x01, 0xc4, 0x4c, 0x00,
+    0x01, 0xc4, 0x74, 0x00, 0x01, 0xc4, 0x9b, 0x00, 0x01, 0xc4, 0xbc, 0x00,
+    0x01, 0xc4, 0xe7, 0x00, 0x01, 0xc5, 0x0b, 0x00, 0x01, 0xc5, 0x2f, 0x00,
+    0x01, 0xc5, 0x54, 0x00, 0x01, 0xc5, 0x79, 0x00, 0x01, 0xc5, 0x9a, 0x00,
+    0x01, 0xc5, 0xc3, 0x00, 0x01, 0xc5, 0xea, 0x00, 0x01, 0xc6, 0x12, 0x00,
+    0x01, 0xc6, 0x39, 0x00, 0x01, 0xc6, 0x5a, 0x00, 0x01, 0xc6, 0x85, 0x00,
+    0x01, 0xc6, 0xa8, 0x00, 0x01, 0xc6, 0xd1, 0x00, 0x01, 0xc6, 0xf4, 0x00,
+    0x01, 0xc7, 0x19, 0x00, 0x01, 0xc7, 0x3e, 0x00, 0x01, 0xc7, 0x60, 0x00,
+    0x01, 0xc7, 0x87, 0x00, 0x01, 0xc7, 0xab, 0x00, 0x01, 0xc7, 0xd3, 0x00,
+    0x01, 0xc7, 0xf8, 0x00, 0x01, 0xc8, 0x1d, 0x00, 0x01, 0xc8, 0x47, 0x00,
+    0x01, 0xc8, 0x6c, 0x00, 0x01, 0xc8, 0x93, 0x00, 0x01, 0xc8, 0xb7, 0x00,
+    0x01, 0xc8, 0xdd, 0x00, 0x01, 0xc9, 0x02, 0x00, 0x01, 0xc9, 0x27, 0x00,
+    0x01, 0xc9, 0x53, 0x00, 0x01, 0xc9, 0x79, 0x00, 0x01, 0xc9, 0xa0, 0x00,
+    0x01, 0xc9, 0xc7, 0x00, 0x01, 0xc9, 0xe9, 0x00, 0x01, 0xca, 0x0b, 0x00,
+    0x01, 0xca, 0x2f, 0x00, 0x01, 0xca, 0x5b, 0x00, 0x01, 0xca, 0x7e, 0x00,
+    0x01, 0xca, 0xa4, 0x00, 0x01, 0xca, 0xca, 0x00, 0x01, 0xca, 0xef, 0x00,
+    0x01, 0xcb, 0x12, 0x00, 0x01, 0xcb, 0x39, 0x00, 0x01, 0xcb, 0x60, 0x00,
+    0x01, 0xcb, 0x82, 0x00, 0x01, 0xcb, 0xa5, 0x00, 0x01, 0xcb, 0xca, 0x00,
+    0x01, 0xcb, 0xf0, 0x00, 0x01, 0xcc, 0x15, 0x00, 0x01, 0xcc, 0x3f, 0x00,
+    0x01, 0xcc, 0x67, 0x00, 0x01, 0xcc, 0x89, 0x00, 0x01, 0xcc, 0xa9, 0x00,
+    0x01, 0xcc, 0xce, 0x00, 0x01, 0xcc, 0xf6, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, 0x91, 0x00,
+    0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0xe1, 0x00, 0x00, 0x01, 0x08, 0x00,
+    0x00, 0x01, 0x2d, 0x00, 0x00, 0x01, 0x4f, 0x00, 0x00, 0x01, 0x7d, 0x00,
+    0x00, 0x01, 0xa7, 0x00, 0x00, 0x01, 0xcd, 0x00, 0x00, 0x01, 0xf3, 0x00,
+    0x00, 0x02, 0x1b, 0x00, 0x00, 0x02, 0x42, 0x00, 0x00, 0x02, 0x6a, 0x00,
+    0x00, 0x02, 0x92, 0x00, 0x00, 0x02, 0xb6, 0x00, 0x00, 0x02, 0xde, 0x00,
+    0x00, 0x03, 0x06, 0x00, 0x00, 0x03, 0x2a, 0x00, 0x00, 0x03, 0x4f, 0x00,
+    0x00, 0x03, 0x7a, 0x00, 0x00, 0x03, 0xa3, 0x00, 0x00, 0x03, 0xc6, 0x00,
+    0x00, 0x03, 0xed, 0x00, 0x00, 0x04, 0x10, 0x00, 0x00, 0x04, 0x34, 0x00,
+    0x00, 0x04, 0x59, 0x00, 0x00, 0x04, 0x7e, 0x00, 0x00, 0x04, 0xa5, 0x00,
+    0x00, 0x04, 0xc7, 0x00, 0x00, 0x04, 0xea, 0x00, 0x00, 0x05, 0x0e, 0x00,
+    0x00, 0x05, 0x39, 0x00, 0x00, 0x05, 0x62, 0x00, 0x00, 0x05, 0x87, 0x00,
+    0x00, 0x05, 0xad, 0x00, 0x00, 0x05, 0xd2, 0x00, 0x00, 0x05, 0xf5, 0x00,
+    0x00, 0x06, 0x17, 0x00, 0x00, 0x06, 0x3d, 0x00, 0x00, 0x06, 0x66, 0x00,
+    0x00, 0x06, 0x86, 0x00, 0x00, 0x06, 0xa7, 0x00, 0x00, 0x06, 0xd2, 0x00,
+    0x00, 0x06, 0xf3, 0x00, 0x00, 0x07, 0x18, 0x00, 0x00, 0x07, 0x3c, 0x00,
+    0x00, 0x07, 0x5e, 0x00, 0x00, 0x07, 0x84, 0x00, 0x00, 0x07, 0xa9, 0x00,
+    0x00, 0x07, 0xd0, 0x00, 0x00, 0x07, 0xfb, 0x00, 0x00, 0x08, 0x2a, 0x00,
+    0x00, 0x08, 0x53, 0x00, 0x00, 0x08, 0x77, 0x00, 0x00, 0x08, 0x9c, 0x00,
+    0x00, 0x08, 0xbf, 0x00, 0x00, 0x08, 0xed, 0x00, 0x00, 0x09, 0x17, 0x00,
+    0x00, 0x09, 0x3f, 0x00, 0x00, 0x09, 0x67, 0x00, 0x00, 0x09, 0x8d, 0x00,
+    0x00, 0x09, 0xb6, 0x00, 0x00, 0x09, 0xd5, 0x00, 0x00, 0x09, 0xff, 0x00,
+    0x00, 0x0a, 0x23, 0x00, 0x00, 0x0a, 0x4a, 0x00, 0x00, 0x0a, 0x6f, 0x00,
+    0x00, 0x0a, 0x93, 0x00, 0x00, 0x0a, 0xba, 0x00, 0x00, 0x0a, 0xe0, 0x00,
+    0x00, 0x0b, 0x05, 0x00, 0x00, 0x0b, 0x2a, 0x00, 0x00, 0x0b, 0x51, 0x00,
+    0x00, 0x0b, 0x78, 0x00, 0x00, 0x0b, 0x9e, 0x00, 0x00, 0x0b, 0xc0, 0x00,
+    0x00, 0x0b, 0xe5, 0x00, 0x00, 0x0c, 0x0a, 0x00, 0x00, 0x0c, 0x2f, 0x00,
+    0x00, 0x0c, 0x55, 0x00, 0x00, 0x0c, 0x7d, 0x00, 0x00, 0x0c, 0xa9, 0x00,
+    0x00, 0x0c, 0xcf, 0x00, 0x00, 0x0c, 0xf5, 0x00, 0x00, 0x0d, 0x14, 0x00,
+    0x00, 0x0d, 0x39, 0x00, 0x00, 0x0d, 0x61, 0x00, 0x00, 0x0d, 0x84, 0x00,
+    0x00, 0x0d, 0xa9, 0x00, 0x00, 0x0d, 0xce, 0x00, 0x00, 0x0d, 0xf2, 0x00,
+    0x00, 0x0e, 0x15, 0x00, 0x00, 0x0e, 0x3a, 0x00, 0x00, 0x0e, 0x60, 0x00,
+    0x00, 0x0e, 0x85, 0x00, 0x00, 0x0e, 0xb0, 0x00, 0x00, 0x0e, 0xd7, 0x00,
+    0x00, 0x0e, 0xfd, 0x00, 0x00, 0x0f, 0x22, 0x00, 0x00, 0x0f, 0x49, 0x00,
+    0x00, 0x0f, 0x73, 0x00, 0x00, 0x0f, 0x9a, 0x00, 0x00, 0x0f, 0xbd, 0x00,
+    0x00, 0x0f, 0xe2, 0x00, 0x00, 0x10, 0x06, 0x00, 0x00, 0x10, 0x2f, 0x00,
+    0x00, 0x10, 0x54, 0x00, 0x00, 0x10, 0x7b, 0x00, 0x00, 0x10, 0x9c, 0x00,
+    0x00, 0x10, 0xc3, 0x00, 0x00, 0x10, 0xe6, 0x00, 0x00, 0x11, 0x0c, 0x00,
+    0x00, 0x11, 0x35, 0x00, 0x00, 0x11, 0x5b, 0x00, 0x00, 0x11, 0x81, 0x00,
+    0x00, 0x11, 0xa7, 0x00, 0x00, 0x11, 0xcb, 0x00, 0x00, 0x11, 0xf2, 0x00,
+    0x00, 0x12, 0x19, 0x00, 0x00, 0x12, 0x3b, 0x00, 0x00, 0x12, 0x68, 0x00,
+    0x00, 0x12, 0x8f, 0x00, 0x00, 0x12, 0xb1, 0x00, 0x00, 0x12, 0xd4, 0x00,
+    0x00, 0x12, 0xfa, 0x00, 0x00, 0x13, 0x1d, 0x00, 0x00, 0x13, 0x4b, 0x00,
+    0x00, 0x13, 0x74, 0x00, 0x00, 0x13, 0xa1, 0x00, 0x00, 0x13, 0xc5, 0x00,
+    0x00, 0x13, 0xe7, 0x00, 0x00, 0x14, 0x0d, 0x00, 0x00, 0x14, 0x2e, 0x00,
+    0x00, 0x14, 0x53, 0x00, 0x00, 0x14, 0x7b, 0x00, 0x00, 0x14, 0x9e, 0x00,
+    0x00, 0x14, 0xc2, 0x00, 0x00, 0x14, 0xe5, 0x00, 0x00, 0x15, 0x0b, 0x00,
+    0x00, 0x15, 0x30, 0x00, 0x00, 0x15, 0x59, 0x00, 0x00, 0x15, 0x7d, 0x00,
+    0x00, 0x15, 0xa8, 0x00, 0x00, 0x15, 0xd0, 0x00, 0x00, 0x15, 0xfa, 0x00,
+    0x00, 0x16, 0x22, 0x00, 0x00, 0x16, 0x44, 0x00, 0x00, 0x16, 0x6a, 0x00,
+    0x00, 0x16, 0x8f, 0x00, 0x00, 0x16, 0xb5, 0x00, 0x00, 0x16, 0xdc, 0x00,
+    0x00, 0x17, 0x03, 0x00, 0x00, 0x17, 0x2a, 0x00, 0x00, 0x17, 0x54, 0x00,
+    0x00, 0x17, 0x77, 0x00, 0x00, 0x17, 0xa3, 0x00, 0x00, 0x17, 0xca, 0x00,
+    0x00, 0x17, 0xfa, 0x00, 0x00, 0x18, 0x21, 0x00, 0x00, 0x18, 0x4b, 0x00,
+    0x00, 0x18, 0x6f, 0x00, 0x00, 0x18, 0x9c, 0x00, 0x00, 0x18, 0xc1, 0x00,
+    0x00, 0x18, 0xe7, 0x00, 0x00, 0x19, 0x0c, 0x00, 0x00, 0x19, 0x30, 0x00,
+    0x00, 0x19, 0x5b, 0x00, 0x00, 0x19, 0x83, 0x00, 0x00, 0x19, 0xa9, 0x00,
+    0x00, 0x19, 0xcf, 0x00, 0x00, 0x19, 0xf6, 0x00, 0x00, 0x1a, 0x1c, 0x00,
+    0x00, 0x1a, 0x47, 0x00, 0x00, 0x1a, 0x6c, 0x00, 0x00, 0x1a, 0x90, 0x00,
+    0x00, 0x1a, 0xb4, 0x00, 0x00, 0x1a, 0xd7, 0x00, 0x00, 0x1a, 0xfd, 0x00,
+    0x00, 0x1b, 0x30, 0x00, 0x00, 0x1b, 0x57, 0x00, 0x00, 0x1b, 0x7a, 0x00,
+    0x00, 0x1b, 0x9c, 0x00, 0x00, 0x1b, 0xcb, 0x00, 0x00, 0x1b, 0xf2, 0x00,
+    0x00, 0x1c, 0x16, 0x00, 0x00, 0x1c, 0x38, 0x00, 0x00, 0x1c, 0x5c, 0x00,
+    0x00, 0x1c, 0x81, 0x00, 0x00, 0x1c, 0xaa, 0x00, 0x00, 0x1c, 0xcd, 0x00,
+    0x00, 0x1c, 0xf2, 0x00, 0x00, 0x1d, 0x15, 0x00, 0x00, 0x1d, 0x3b, 0x00,
+    0x00, 0x1d, 0x5f, 0x00, 0x00, 0x1d, 0x85, 0x00, 0x00, 0x1d, 0xa6, 0x00,
+    0x00, 0x1d, 0xcc, 0x00, 0x00, 0x1d, 0xf2, 0x00, 0x00, 0x1e, 0x1e, 0x00,
+    0x00, 0x1e, 0x41, 0x00, 0x00, 0x1e, 0x68, 0x00, 0x00, 0x1e, 0xa0, 0x00,
+    0x00, 0x1e, 0xc3, 0x00, 0x00, 0x1e, 0xe8, 0x00, 0x00, 0x1f, 0x0c, 0x00,
+    0x00, 0x1f, 0x31, 0x00, 0x00, 0x1f, 0x56, 0x00, 0x00, 0x1f, 0x7c, 0x00,
+    0x00, 0x1f, 0xa0, 0x00, 0x00, 0x1f, 0xc5, 0x00, 0x00, 0x1f, 0xe4, 0x00,
+    0x00, 0x20, 0x06, 0x00, 0x00, 0x20, 0x2f, 0x00, 0x00, 0x20, 0x57, 0x00,
+    0x00, 0x20, 0x7a, 0x00, 0x00, 0x20, 0x9d, 0x00, 0x00, 0x20, 0xc0, 0x00,
+    0x00, 0x20, 0xe1, 0x00, 0x00, 0x21, 0x01, 0x00, 0x00, 0x21, 0x24, 0x00,
+    0x00, 0x21, 0x4e, 0x00, 0x00, 0x21, 0x71, 0x00, 0x00, 0x21, 0x93, 0x00,
+    0x00, 0x21, 0xb9, 0x00, 0x00, 0x21, 0xde, 0x00, 0x00, 0x22, 0x03, 0x00,
+    0x00, 0x22, 0x29, 0x00, 0x00, 0x22, 0x4c, 0x00, 0x00, 0x22, 0x75, 0x00,
+    0x00, 0x22, 0x9e, 0x00, 0x00, 0x22, 0xc5, 0x00, 0x00, 0x22, 0xec, 0x00,
+    0x00, 0x23, 0x11, 0x00, 0x00, 0x23, 0x3b, 0x00, 0x00, 0x23, 0x63, 0x00,
+    0x00, 0x23, 0x8f, 0x00, 0x00, 0x23, 0xc2, 0x00, 0x00, 0x23, 0xe3, 0x00,
+    0x00, 0x24, 0x0c, 0x00, 0x00, 0x24, 0x2e, 0x00, 0x00, 0x24, 0x52, 0x00,
+    0x00, 0x24, 0x7c, 0x00, 0x00, 0x24, 0xa4, 0x00, 0x00, 0x24, 0xc5, 0x00,
+    0x00, 0x24, 0xe9, 0x00, 0x00, 0x25, 0x12, 0x00, 0x00, 0x25, 0x39, 0x00,
+    0x00, 0x25, 0x66, 0x00, 0x00, 0x25, 0x91, 0x00, 0x00, 0x25, 0xba, 0x00,
+    0x00, 0x25, 0xe0, 0x00, 0x00, 0x26, 0x08, 0x00, 0x00, 0x26, 0x30, 0x00,
+    0x00, 0x26, 0x55, 0x00, 0x00, 0x26, 0x7e, 0x00, 0x00, 0x26, 0xa2, 0x00,
+    0x00, 0x26, 0xc7, 0x00, 0x00, 0x26, 0xf2, 0x00, 0x00, 0x27, 0x16, 0x00,
+    0x00, 0x27, 0x3e, 0x00, 0x00, 0x27, 0x63, 0x00, 0x00, 0x27, 0x8c, 0x00,
+    0x00, 0x27, 0xb2, 0x00, 0x00, 0x27, 0xd4, 0x00, 0x00, 0x27, 0xf9, 0x00,
+    0x00, 0x28, 0x1e, 0x00, 0x00, 0x28, 0x43, 0x00, 0x00, 0x28, 0x6b, 0x00,
+    0x00, 0x28, 0x91, 0x00, 0x00, 0x28, 0xb2, 0x00, 0x00, 0x28, 0xd3, 0x00,
+    0x00, 0x28, 0xf9, 0x00, 0x00, 0x29, 0x20, 0x00, 0x00, 0x29, 0x45, 0x00,
+    0x00, 0x29, 0x6b, 0x00, 0x00, 0x29, 0x95, 0x00, 0x00, 0x29, 0xba, 0x00,
+    0x00, 0x29, 0xe1, 0x00, 0x00, 0x2a, 0x06, 0x00, 0x00, 0x2a, 0x31, 0x00,
+    0x00, 0x2a, 0x5c, 0x00, 0x00, 0x2a, 0x7e, 0x00, 0x00, 0x2a, 0xa9, 0x00,
+    0x00, 0x2a, 0xcb, 0x00, 0x00, 0x2a, 0xf2, 0x00, 0x00, 0x2b, 0x18, 0x00,
+    0x00, 0x2b, 0x3d, 0x00, 0x00, 0x2b, 0x65, 0x00, 0x00, 0x2b, 0x90, 0x00,
+    0x00, 0x2b, 0xb1, 0x00, 0x00, 0x2b, 0xd4, 0x00, 0x00, 0x2b, 0xfd, 0x00,
+    0x00, 0x2c, 0x20, 0x00, 0x00, 0x2c, 0x41, 0x00, 0x00, 0x2c, 0x66, 0x00,
+    0x00, 0x2c, 0x8a, 0x00, 0x00, 0x2c, 0xb1, 0x00, 0x00, 0x2c, 0xd6, 0x00,
+    0x00, 0x2d, 0x03, 0x00, 0x00, 0x2d, 0x24, 0x00, 0x00, 0x2d, 0x49, 0x00,
+    0x00, 0x2d, 0x72, 0x00, 0x00, 0x2d, 0x96, 0x00, 0x00, 0x2d, 0xb8, 0x00,
+    0x00, 0x2d, 0xe1, 0x00, 0x00, 0x2e, 0x09, 0x00, 0x00, 0x2e, 0x35, 0x00,
+    0x00, 0x2e, 0x55, 0x00, 0x00, 0x2e, 0x79, 0x00, 0x00, 0x2e, 0x9e, 0x00,
+    0x00, 0x2e, 0xc4, 0x00, 0x00, 0x2e, 0xe5, 0x00, 0x00, 0x2f, 0x0b, 0x00,
+    0x00, 0x2f, 0x34, 0x00, 0x00, 0x2f, 0x5d, 0x00, 0x00, 0x2f, 0x87, 0x00,
+    0x00, 0x2f, 0xac, 0x00, 0x00, 0x2f, 0xd9, 0x00, 0x00, 0x2f, 0xff, 0x00,
+    0x00, 0x30, 0x23, 0x00, 0x00, 0x30, 0x48, 0x00, 0x00, 0x30, 0x71, 0x00,
+    0x00, 0x30, 0x97, 0x00, 0x00, 0x30, 0xbd, 0x00, 0x00, 0x30, 0xe0, 0x00,
+    0x00, 0x31, 0x04, 0x00, 0x00, 0x31, 0x2b, 0x00, 0x00, 0x31, 0x52, 0x00,
+    0x00, 0x31, 0x76, 0x00, 0x00, 0x31, 0x9b, 0x00, 0x00, 0x31, 0xc6, 0x00,
+    0x00, 0x31, 0xed, 0x00, 0x00, 0x32, 0x11, 0x00, 0x00, 0x32, 0x38, 0x00,
+    0x00, 0x32, 0x60, 0x00, 0x00, 0x32, 0x84, 0x00, 0x00, 0x32, 0xa8, 0x00,
+    0x00, 0x32, 0xcc, 0x00, 0x00, 0x32, 0xf0, 0x00, 0x00, 0x33, 0x18, 0x00,
+    0x00, 0x33, 0x3d, 0x00, 0x00, 0x33, 0x64, 0x00, 0x00, 0x33, 0x8b, 0x00,
+    0x00, 0x33, 0xaf, 0x00, 0x00, 0x33, 0xd8, 0x00, 0x00, 0x33, 0xfc, 0x00,
+    0x00, 0x34, 0x23, 0x00, 0x00, 0x34, 0x48, 0x00, 0x00, 0x34, 0x6c, 0x00,
+    0x00, 0x34, 0x8d, 0x00, 0x00, 0x34, 0xb4, 0x00, 0x00, 0x34, 0xde, 0x00,
+    0x00, 0x35, 0x03, 0x00, 0x00, 0x35, 0x29, 0x00, 0x00, 0x35, 0x4b, 0x00,
+    0x00, 0x35, 0x75, 0x00, 0x00, 0x35, 0x9e, 0x00, 0x00, 0x35, 0xc1, 0x00,
+    0x00, 0x35, 0xe9, 0x00, 0x00, 0x36, 0x0d, 0x00, 0x00, 0x36, 0x33, 0x00,
+    0x00, 0x36, 0x61, 0x00, 0x00, 0x36, 0x86, 0x00, 0x00, 0x36, 0xae, 0x00,
+    0x00, 0x36, 0xd7, 0x00, 0x00, 0x36, 0xfa, 0x00, 0x00, 0x37, 0x25, 0x00,
+    0x00, 0x37, 0x47, 0x00, 0x00, 0x37, 0x69, 0x00, 0x00, 0x37, 0x89, 0x00,
+    0x00, 0x37, 0xb1, 0x00, 0x00, 0x37, 0xd5, 0x00, 0x00, 0x37, 0xfb, 0x00,
+    0x00, 0x38, 0x1f, 0x00, 0x00, 0x38, 0x47, 0x00, 0x00, 0x38, 0x69, 0x00,
+    0x00, 0x38, 0x8b, 0x00, 0x00, 0x38, 0xab, 0x00, 0x00, 0x38, 0xce, 0x00,
+    0x00, 0x38, 0xef, 0x00, 0x00, 0x39, 0x15, 0x00, 0x00, 0x39, 0x3b, 0x00,
+    0x00, 0x39, 0x68, 0x00, 0x00, 0x39, 0x8e, 0x00, 0x00, 0x39, 0xae, 0x00,
+    0x00, 0x39, 0xd2, 0x00, 0x00, 0x39, 0xfc, 0x00, 0x00, 0x3a, 0x20, 0x00,
+    0x00, 0x3a, 0x47, 0x00, 0x00, 0x3a, 0x6e, 0x00, 0x00, 0x3a, 0x93, 0x00,
+    0x00, 0x3a, 0xba, 0x00, 0x00, 0x3a, 0xe2, 0x00, 0x00, 0x3b, 0x09, 0x00,
+    0x00, 0x3b, 0x2d, 0x00, 0x00, 0x3b, 0x4d, 0x00, 0x00, 0x3b, 0x74, 0x00,
+    0x00, 0x3b, 0x97, 0x00, 0x00, 0x3b, 0xbe, 0x00, 0x00, 0x3b, 0xe4, 0x00,
+    0x00, 0x3c, 0x07, 0x00, 0x00, 0x3c, 0x32, 0x00, 0x00, 0x3c, 0x57, 0x00,
+    0x00, 0x3c, 0x7b, 0x00, 0x00, 0x3c, 0xa4, 0x00, 0x00, 0x3c, 0xca, 0x00,
+    0x00, 0x3c, 0xec, 0x00, 0x00, 0x3d, 0x12, 0x00, 0x00, 0x3d, 0x38, 0x00,
+    0x00, 0x3d, 0x5d, 0x00, 0x00, 0x3d, 0x83, 0x00, 0x00, 0x3d, 0xa6, 0x00,
+    0x00, 0x3d, 0xc7, 0x00, 0x00, 0x3d, 0xea, 0x00, 0x00, 0x3e, 0x0e, 0x00,
+    0x00, 0x3e, 0x34, 0x00, 0x00, 0x3e, 0x56, 0x00, 0x00, 0x3e, 0x7e, 0x00,
+    0x00, 0x3e, 0xa3, 0x00, 0x00, 0x3e, 0xcc, 0x00, 0x00, 0x3e, 0xf0, 0x00,
+    0x00, 0x3f, 0x16, 0x00, 0x00, 0x3f, 0x3a, 0x00, 0x00, 0x3f, 0x5b, 0x00,
+    0x00, 0x3f, 0x7f, 0x00, 0x00, 0x3f, 0xa5, 0x00, 0x00, 0x3f, 0xcd, 0x00,
+    0x00, 0x3f, 0xec, 0x00, 0x00, 0x40, 0x12, 0x00, 0x00, 0x40, 0x36, 0x00,
+    0x00, 0x40, 0x5c, 0x00, 0x00, 0x40, 0x82, 0x00, 0x00, 0x40, 0xb0, 0x00,
+    0x00, 0x40, 0xda, 0x00, 0x00, 0x41, 0x0a, 0x00, 0x00, 0x41, 0x2c, 0x00,
+    0x00, 0x41, 0x53, 0x00, 0x00, 0x41, 0x79, 0x00, 0x00, 0x41, 0x9c, 0x00,
+    0x00, 0x41, 0xca, 0x00, 0x00, 0x41, 0xeb, 0x00, 0x00, 0x42, 0x0c, 0x00,
+    0x00, 0x42, 0x30, 0x00, 0x00, 0x42, 0x52, 0x00, 0x00, 0x42, 0x80, 0x00,
+    0x00, 0x42, 0xa4, 0x00, 0x00, 0x42, 0xc9, 0x00, 0x00, 0x42, 0xf3, 0x00,
+    0x00, 0x43, 0x1a, 0x00, 0x00, 0x43, 0x41, 0x00, 0x00, 0x43, 0x62, 0x00,
+    0x00, 0x43, 0x86, 0x00, 0x00, 0x43, 0xab, 0x00, 0x00, 0x43, 0xd1, 0x00,
+    0x00, 0x43, 0xf2, 0x00, 0x00, 0x44, 0x1c, 0x00, 0x00, 0x44, 0x45, 0x00,
+    0x00, 0x44, 0x67, 0x00, 0x00, 0x44, 0x8a, 0x00, 0x00, 0x44, 0xb2, 0x00,
+    0x00, 0x44, 0xe2, 0x00, 0x00, 0x45, 0x06, 0x00, 0x00, 0x45, 0x2a, 0x00,
+    0x00, 0x45, 0x55, 0x00, 0x00, 0x45, 0x77, 0x00, 0x00, 0x45, 0x99, 0x00,
+    0x00, 0x45, 0xbb, 0x00, 0x00, 0x45, 0xe1, 0x00, 0x00, 0x46, 0x05, 0x00,
+    0x00, 0x46, 0x28, 0x00, 0x00, 0x46, 0x4d, 0x00, 0x00, 0x46, 0x70, 0x00,
+    0x00, 0x46, 0x92, 0x00, 0x00, 0x46, 0xb7, 0x00, 0x00, 0x46, 0xe1, 0x00,
+    0x00, 0x47, 0x05, 0x00, 0x00, 0x47, 0x2b, 0x00, 0x00, 0x47, 0x53, 0x00,
+    0x00, 0x47, 0x7c, 0x00, 0x00, 0x47, 0xa0, 0x00, 0x00, 0x47, 0xc3, 0x00,
+    0x00, 0x47, 0xe7, 0x00, 0x00, 0x48, 0x0d, 0x00, 0x00, 0x48, 0x31, 0x00,
+    0x00, 0x48, 0x58, 0x00, 0x00, 0x48, 0x83, 0x00, 0x00, 0x48, 0xaa, 0x00,
+    0x00, 0x48, 0xce, 0x00, 0x00, 0x48, 0xf2, 0x00, 0x00, 0x49, 0x18, 0x00,
+    0x00, 0x49, 0x3b, 0x00, 0x00, 0x49, 0x63, 0x00, 0x00, 0x49, 0x88, 0x00,
+    0x00, 0x49, 0xac, 0x00, 0x00, 0x49, 0xd8, 0x00, 0x00, 0x4a, 0x00, 0x00,
+    0x00, 0x4a, 0x2b, 0x00, 0x00, 0x4a, 0x50, 0x00, 0x00, 0x4a, 0x76, 0x00,
+    0x00, 0x4a, 0xa1, 0x00, 0x00, 0x4a, 0xc4, 0x00, 0x00, 0x4a, 0xeb, 0x00,
+    0x00, 0x4b, 0x10, 0x00, 0x00, 0x4b, 0x34, 0x00, 0x00, 0x4b, 0x57, 0x00,
+    0x00, 0x4b, 0x7a, 0x00, 0x00, 0x4b, 0xa0, 0x00, 0x00, 0x4b, 0xc5, 0x00,
+    0x00, 0x4b, 0xee, 0x00, 0x00, 0x4c, 0x16, 0x00, 0x00, 0x4c, 0x3f, 0x00,
+    0x00, 0x4c, 0x64, 0x00, 0x00, 0x4c, 0x8a, 0x00, 0x00, 0x4c, 0xad, 0x00,
+    0x00, 0x4c, 0xd3, 0x00, 0x00, 0x4c, 0xfe, 0x00, 0x00, 0x4d, 0x24, 0x00,
+    0x00, 0x4d, 0x47, 0x00, 0x00, 0x4d, 0x6b, 0x00, 0x00, 0x4d, 0x93, 0x00,
+    0x00, 0x4d, 0xbc, 0x00, 0x00, 0x4d, 0xe1, 0x00, 0x00, 0x4e, 0x10, 0x00,
+    0x00, 0x4e, 0x36, 0x00, 0x00, 0x4e, 0x58, 0x00, 0x00, 0x4e, 0x80, 0x00,
+    0x00, 0x4e, 0xa9, 0x00, 0x00, 0x4e, 0xcf, 0x00, 0x00, 0x4e, 0xf5, 0x00,
+    0x00, 0x4f, 0x18, 0x00, 0x00, 0x4f, 0x3b, 0x00, 0x00, 0x4f, 0x61, 0x00,
+    0x00, 0x4f, 0x86, 0x00, 0x00, 0x4f, 0xaf, 0x00, 0x00, 0x4f, 0xd4, 0x00,
+    0x00, 0x4f, 0xf8, 0x00, 0x00, 0x50, 0x1d, 0x00, 0x00, 0x50, 0x43, 0x00,
+    0x00, 0x50, 0x63, 0x00, 0x00, 0x50, 0x84, 0x00, 0x00, 0x50, 0xab, 0x00,
+    0x00, 0x50, 0xd1, 0x00, 0x00, 0x50, 0xf8, 0x00, 0x00, 0x51, 0x25, 0x00,
+    0x00, 0x51, 0x4a, 0x00, 0x00, 0x51, 0x6e, 0x00, 0x00, 0x51, 0x95, 0x00,
+    0x00, 0x51, 0xbb, 0x00, 0x00, 0x51, 0xdd, 0x00, 0x00, 0x52, 0x04, 0x00,
+    0x00, 0x52, 0x29, 0x00, 0x00, 0x52, 0x4e, 0x00, 0x00, 0x52, 0x77, 0x00,
+    0x00, 0x52, 0x99, 0x00, 0x00, 0x52, 0xbe, 0x00, 0x00, 0x52, 0xe4, 0x00,
+    0x00, 0x53, 0x09, 0x00, 0x00, 0x53, 0x2e, 0x00, 0x00, 0x53, 0x54, 0x00,
+    0x00, 0x53, 0x7d, 0x00, 0x00, 0x53, 0xa6, 0x00, 0x00, 0x53, 0xd0, 0x00,
+    0x00, 0x53, 0xf6, 0x00, 0x00, 0x54, 0x1a, 0x00, 0x00, 0x54, 0x3d, 0x00,
+    0x00, 0x54, 0x65, 0x00, 0x00, 0x54, 0x8a, 0x00, 0x00, 0x54, 0xb1, 0x00,
+    0x00, 0x54, 0xda, 0x00, 0x00, 0x55, 0x02, 0x00, 0x00, 0x55, 0x27, 0x00,
+    0x00, 0x55, 0x50, 0x00, 0x00, 0x55, 0x7d, 0x00, 0x00, 0x55, 0xa3, 0x00,
+    0x00, 0x55, 0xc9, 0x00, 0x00, 0x55, 0xeb, 0x00, 0x00, 0x56, 0x13, 0x00,
+    0x00, 0x56, 0x3f, 0x00, 0x00, 0x56, 0x63, 0x00, 0x00, 0x56, 0x8c, 0x00,
+    0x00, 0x56, 0xb8, 0x00, 0x00, 0x56, 0xdd, 0x00, 0x00, 0x57, 0x03, 0x00,
+    0x00, 0x57, 0x29, 0x00, 0x00, 0x57, 0x4a, 0x00, 0x00, 0x57, 0x74, 0x00,
+    0x00, 0x57, 0x97, 0x00, 0x00, 0x57, 0xbf, 0x00, 0x00, 0x57, 0xe3, 0x00,
+    0x00, 0x58, 0x0a, 0x00, 0x00, 0x58, 0x2f, 0x00, 0x00, 0x58, 0x55, 0x00,
+    0x00, 0x58, 0x79, 0x00, 0x00, 0x58, 0xa0, 0x00, 0x00, 0x58, 0xc8, 0x00,
+    0x00, 0x58, 0xef, 0x00, 0x00, 0x59, 0x15, 0x00, 0x00, 0x59, 0x3b, 0x00,
+    0x00, 0x59, 0x5b, 0x00, 0x00, 0x59, 0x82, 0x00, 0x00, 0x59, 0xa7, 0x00,
+    0x00, 0x59, 0xcc, 0x00, 0x00, 0x59, 0xf2, 0x00, 0x00, 0x5a, 0x15, 0x00,
+    0x00, 0x5a, 0x3e, 0x00, 0x00, 0x5a, 0x6a, 0x00, 0x00, 0x5a, 0x8b, 0x00,
+    0x00, 0x5a, 0xb3, 0x00, 0x00, 0x5a, 0xd9, 0x00, 0x00, 0x5a, 0xfc, 0x00,
+    0x00, 0x5b, 0x20, 0x00, 0x00, 0x5b, 0x46, 0x00, 0x00, 0x5b, 0x6b, 0x00,
+    0x00, 0x5b, 0x93, 0x00, 0x00, 0x5b, 0xb9, 0x00, 0x00, 0x5b, 0xdf, 0x00,
+    0x00, 0x5c, 0x05, 0x00, 0x00, 0x5c, 0x2a, 0x00, 0x00, 0x5c, 0x4f, 0x00,
+    0x00, 0x5c, 0x72, 0x00, 0x00, 0x5c, 0x93, 0x00, 0x00, 0x5c, 0xb5, 0x00,
+    0x00, 0x5c, 0xda, 0x00, 0x00, 0x5c, 0xfe, 0x00, 0x00, 0x5d, 0x24, 0x00,
+    0x00, 0x5d, 0x47, 0x00, 0x00, 0x5d, 0x6d, 0x00, 0x00, 0x5d, 0x91, 0x00,
+    0x00, 0x5d, 0xb5, 0x00, 0x00, 0x5d, 0xd7, 0x00, 0x00, 0x5d, 0xfd, 0x00,
+    0x00, 0x5e, 0x1d, 0x00, 0x00, 0x5e, 0x43, 0x00, 0x00, 0x5e, 0x67, 0x00,
+    0x00, 0x5e, 0x90, 0x00, 0x00, 0x5e, 0xb8, 0x00, 0x00, 0x5e, 0xda, 0x00,
+    0x00, 0x5e, 0xfd, 0x00, 0x00, 0x5f, 0x1e, 0x00, 0x00, 0x5f, 0x45, 0x00,
+    0x00, 0x5f, 0x6d, 0x00, 0x00, 0x5f, 0x92, 0x00, 0x00, 0x5f, 0xb5, 0x00,
+    0x00, 0x5f, 0xdb, 0x00, 0x00, 0x60, 0x05, 0x00, 0x00, 0x60, 0x2a, 0x00,
+    0x00, 0x60, 0x51, 0x00, 0x00, 0x60, 0x78, 0x00, 0x00, 0x60, 0x9a, 0x00,
+    0x00, 0x60, 0xbd, 0x00, 0x00, 0x60, 0xe2, 0x00, 0x00, 0x61, 0x07, 0x00,
+    0x00, 0x61, 0x30, 0x00, 0x00, 0x61, 0x56, 0x00, 0x00, 0x61, 0x82, 0x00,
+    0x00, 0x61, 0xac, 0x00, 0x00, 0x61, 0xd1, 0x00, 0x00, 0x61, 0xf4, 0x00,
+    0x00, 0x62, 0x17, 0x00, 0x00, 0x62, 0x3d, 0x00, 0x00, 0x62, 0x6d, 0x00,
+    0x00, 0x62, 0x97, 0x00, 0x00, 0x62, 0xbb, 0x00, 0x00, 0x62, 0xe0, 0x00,
+    0x00, 0x63, 0x02, 0x00, 0x00, 0x63, 0x29, 0x00, 0x00, 0x63, 0x4e, 0x00,
+    0x00, 0x63, 0x71, 0x00, 0x00, 0x63, 0x93, 0x00, 0x00, 0x63, 0xbd, 0x00,
+    0x00, 0x63, 0xe4, 0x00, 0x00, 0x64, 0x04, 0x00, 0x00, 0x64, 0x22, 0x00,
+    0x00, 0x64, 0x43, 0x00, 0x00, 0x64, 0x69, 0x00, 0x00, 0x64, 0x90, 0x00,
+    0x00, 0x64, 0xb1, 0x00, 0x00, 0x64, 0xd6, 0x00, 0x00, 0x64, 0xfb, 0x00,
+    0x00, 0x65, 0x1e, 0x00, 0x00, 0x65, 0x44, 0x00, 0x00, 0x65, 0x6c, 0x00,
+    0x00, 0x65, 0x90, 0x00, 0x00, 0x65, 0xb3, 0x00, 0x00, 0x65, 0xd5, 0x00,
+    0x00, 0x65, 0xfc, 0x00, 0x00, 0x66, 0x21, 0x00, 0x00, 0x66, 0x47, 0x00,
+    0x00, 0x66, 0x69, 0x00, 0x00, 0x66, 0x8e, 0x00, 0x00, 0x66, 0xb7, 0x00,
+    0x00, 0x66, 0xdd, 0x00, 0x00, 0x67, 0x01, 0x00, 0x00, 0x67, 0x25, 0x00,
+    0x00, 0x67, 0x49, 0x00, 0x00, 0x67, 0x6f, 0x00, 0x00, 0x67, 0x9f, 0x00,
+    0x00, 0x67, 0xc5, 0x00, 0x00, 0x67, 0xea, 0x00, 0x00, 0x68, 0x10, 0x00,
+    0x00, 0x68, 0x34, 0x00, 0x00, 0x68, 0x5f, 0x00, 0x00, 0x68, 0x88, 0x00,
+    0x00, 0x68, 0xad, 0x00, 0x00, 0x68, 0xd1, 0x00, 0x00, 0x68, 0xf7, 0x00,
+    0x00, 0x69, 0x1e, 0x00, 0x00, 0x69, 0x44, 0x00, 0x00, 0x69, 0x66, 0x00,
+    0x00, 0x69, 0x8c, 0x00, 0x00, 0x69, 0xae, 0x00, 0x00, 0x69, 0xd6, 0x00,
+    0x00, 0x69, 0xfd, 0x00, 0x00, 0x6a, 0x29, 0x00, 0x00, 0x6a, 0x59, 0x00,
+    0x00, 0x6a, 0x86, 0x00, 0x00, 0x6a, 0xac, 0x00, 0x00, 0x6a, 0xd3, 0x00,
+    0x00, 0x6a, 0xf8, 0x00, 0x00, 0x6b, 0x22, 0x00, 0x00, 0x6b, 0x47, 0x00,
+    0x00, 0x6b, 0x6c, 0x00, 0x00, 0x6b, 0x95, 0x00, 0x00, 0x6b, 0xba, 0x00,
+    0x00, 0x6b, 0xe5, 0x00, 0x00, 0x6c, 0x07, 0x00, 0x00, 0x6c, 0x27, 0x00,
+    0x00, 0x6c, 0x51, 0x00, 0x00, 0x6c, 0x78, 0x00, 0x00, 0x6c, 0x9a, 0x00,
+    0x00, 0x6c, 0xc1, 0x00, 0x00, 0x6c, 0xe2, 0x00, 0x00, 0x6d, 0x02, 0x00,
+    0x00, 0x6d, 0x2e, 0x00, 0x00, 0x6d, 0x54, 0x00, 0x00, 0x6d, 0x7e, 0x00,
+    0x00, 0x6d, 0xa3, 0x00, 0x00, 0x6d, 0xd3, 0x00, 0x00, 0x6d, 0xf8, 0x00,
+    0x00, 0x6e, 0x19, 0x00, 0x00, 0x6e, 0x43, 0x00, 0x00, 0x6e, 0x6e, 0x00,
+    0x00, 0x6e, 0x94, 0x00, 0x00, 0x6e, 0xbe, 0x00, 0x00, 0x6e, 0xe2, 0x00,
+    0x00, 0x6f, 0x04, 0x00, 0x00, 0x6f, 0x2a, 0x00, 0x00, 0x6f, 0x4d, 0x00,
+    0x00, 0x6f, 0x74, 0x00, 0x00, 0x6f, 0x99, 0x00, 0x00, 0x6f, 0xc2, 0x00,
+    0x00, 0x6f, 0xe9, 0x00, 0x00, 0x70, 0x12, 0x00, 0x00, 0x70, 0x3e, 0x00,
+    0x00, 0x70, 0x67, 0x00, 0x00, 0x70, 0x8d, 0x00, 0x00, 0x70, 0xb1, 0x00,
+    0x00, 0x70, 0xd5, 0x00, 0x00, 0x70, 0xfc, 0x00, 0x00, 0x71, 0x1c, 0x00,
+    0x00, 0x71, 0x46, 0x00, 0x00, 0x71, 0x72, 0x00, 0x00, 0x71, 0x95, 0x00,
+    0x00, 0x71, 0xb7, 0x00, 0x00, 0x71, 0xde, 0x00, 0x00, 0x72, 0x05, 0x00,
+    0x00, 0x72, 0x2b, 0x00, 0x00, 0x72, 0x4f, 0x00, 0x00, 0x72, 0x77, 0x00,
+    0x00, 0x72, 0xa1, 0x00, 0x00, 0x72, 0xc4, 0x00, 0x00, 0x72, 0xee, 0x00,
+    0x00, 0x73, 0x19, 0x00, 0x00, 0x73, 0x3b, 0x00, 0x00, 0x73, 0x5f, 0x00,
+    0x00, 0x73, 0x84, 0x00, 0x00, 0x73, 0xb2, 0x00, 0x00, 0x73, 0xd9, 0x00,
+    0x00, 0x73, 0xfd, 0x00, 0x00, 0x74, 0x20, 0x00, 0x00, 0x74, 0x46, 0x00,
+    0x00, 0x74, 0x68, 0x00, 0x00, 0x74, 0x8d, 0x00, 0x00, 0x74, 0xba, 0x00,
+    0x00, 0x74, 0xe2, 0x00, 0x00, 0x75, 0x06, 0x00, 0x00, 0x75, 0x2d, 0x00,
+    0x00, 0x75, 0x56, 0x00, 0x00, 0x75, 0x80, 0x00, 0x00, 0x75, 0xaa, 0x00,
+    0x00, 0x75, 0xcd, 0x00, 0x00, 0x75, 0xf0, 0x00, 0x00, 0x76, 0x18, 0x00,
+    0x00, 0x76, 0x3b, 0x00, 0x00, 0x76, 0x63, 0x00, 0x00, 0x76, 0x88, 0x00,
+    0x00, 0x76, 0xb2, 0x00, 0x00, 0x76, 0xdb, 0x00, 0x00, 0x77, 0x00, 0x00,
+    0x00, 0x77, 0x2c, 0x00, 0x00, 0x77, 0x53, 0x00, 0x00, 0x77, 0x77, 0x00,
+    0x00, 0x77, 0x9b, 0x00, 0x00, 0x77, 0xc0, 0x00, 0x00, 0x77, 0xe1, 0x00,
+    0x00, 0x78, 0x02, 0x00, 0x00, 0x78, 0x2b, 0x00, 0x00, 0x78, 0x52, 0x00,
+    0x00, 0x78, 0x7c, 0x00, 0x00, 0x78, 0xa8, 0x00, 0x00, 0x78, 0xd3, 0x00,
+    0x00, 0x78, 0xf9, 0x00, 0x00, 0x79, 0x1e, 0x00, 0x00, 0x79, 0x42, 0x00,
+    0x00, 0x79, 0x67, 0x00, 0x00, 0x79, 0x8d, 0x00, 0x00, 0x79, 0xb3, 0x00,
+    0x00, 0x79, 0xd9, 0x00, 0x00, 0x79, 0xff, 0x00, 0x00, 0x7a, 0x21, 0x00,
+    0x00, 0x7a, 0x43, 0x00, 0x00, 0x7a, 0x65, 0x00, 0x00, 0x7a, 0x8a, 0x00,
+    0x00, 0x7a, 0xad, 0x00, 0x00, 0x7a, 0xd0, 0x00, 0x00, 0x7a, 0xf3, 0x00,
+    0x00, 0x7b, 0x1b, 0x00, 0x00, 0x7b, 0x44, 0x00, 0x00, 0x7b, 0x6a, 0x00,
+    0x00, 0x7b, 0x92, 0x00, 0x00, 0x7b, 0xb2, 0x00, 0x00, 0x7b, 0xd5, 0x00,
+    0x00, 0x7b, 0xfa, 0x00, 0x00, 0x7c, 0x1d, 0x00, 0x00, 0x7c, 0x40, 0x00,
+    0x00, 0x7c, 0x63, 0x00, 0x00, 0x7c, 0x8f, 0x00, 0x00, 0x7c, 0xb2, 0x00,
+    0x00, 0x7c, 0xd6, 0x00, 0x00, 0x7c, 0xf5, 0x00, 0x00, 0x7d, 0x1c, 0x00,
+    0x00, 0x7d, 0x42, 0x00, 0x00, 0x7d, 0x6f, 0x00, 0x00, 0x7d, 0x94, 0x00,
+    0x00, 0x7d, 0xb8, 0x00, 0x00, 0x7d, 0xdd, 0x00, 0x00, 0x7e, 0x05, 0x00,
+    0x00, 0x7e, 0x2a, 0x00, 0x00, 0x7e, 0x50, 0x00, 0x00, 0x7e, 0x70, 0x00,
+    0x00, 0x7e, 0x93, 0x00, 0x00, 0x7e, 0xb9, 0x00, 0x00, 0x7e, 0xdd, 0x00,
+    0x00, 0x7f, 0x05, 0x00, 0x00, 0x7f, 0x29, 0x00, 0x00, 0x7f, 0x51, 0x00,
+    0x00, 0x7f, 0x77, 0x00, 0x00, 0x7f, 0x9a, 0x00, 0x00, 0x7f, 0xc3, 0x00,
+    0x00, 0x7f, 0xe9, 0x00, 0x00, 0x80, 0x0a, 0x00, 0x00, 0x80, 0x2f, 0x00,
+    0x00, 0x80, 0x55, 0x00, 0x00, 0x80, 0x76, 0x00, 0x00, 0x80, 0x9a, 0x00,
+    0x00, 0x80, 0xbf, 0x00, 0x00, 0x80, 0xed, 0x00, 0x00, 0x81, 0x16, 0x00,
+    0x00, 0x81, 0x3a, 0x00, 0x00, 0x81, 0x65, 0x00, 0x00, 0x81, 0x8b, 0x00,
+    0x00, 0x81, 0xb0, 0x00, 0x00, 0x81, 0xdb, 0x00, 0x00, 0x82, 0x00, 0x00,
+    0x00, 0x82, 0x29, 0x00, 0x00, 0x82, 0x4c, 0x00, 0x00, 0x82, 0x6c, 0x00,
+    0x00, 0x82, 0x92, 0x00, 0x00, 0x82, 0xb8, 0x00, 0x00, 0x82, 0xdd, 0x00,
+    0x00, 0x83, 0x03, 0x00, 0x00, 0x83, 0x29, 0x00, 0x00, 0x83, 0x4e, 0x00,
+    0x00, 0x83, 0x74, 0x00, 0x00, 0x83, 0x9b, 0x00, 0x00, 0x83, 0xbf, 0x00,
+    0x00, 0x83, 0xe4, 0x00, 0x00, 0x84, 0x10, 0x00, 0x00, 0x84, 0x37, 0x00,
+    0x00, 0x84, 0x5c, 0x00, 0x00, 0x84, 0x7c, 0x00, 0x00, 0x84, 0xac, 0x00,
+    0x00, 0x84, 0xd2, 0x00, 0x00, 0x84, 0xf4, 0x00, 0x00, 0x85, 0x16, 0x00,
+    0x00, 0x85, 0x41, 0x00, 0x00, 0x85, 0x65, 0x00, 0x00, 0x85, 0x8c, 0x00,
+    0x00, 0x85, 0xb1, 0x00, 0x00, 0x85, 0xdb, 0x00, 0x00, 0x86, 0x02, 0x00,
+    0x00, 0x86, 0x24, 0x00, 0x00, 0x86, 0x44, 0x00, 0x00, 0x86, 0x63, 0x00,
+    0x00, 0x86, 0x88, 0x00, 0x00, 0x86, 0xb3, 0x00, 0x00, 0x86, 0xdc, 0x00,
+    0x00, 0x86, 0xfc, 0x00, 0x00, 0x87, 0x28, 0x00, 0x00, 0x87, 0x57, 0x00,
+    0x00, 0x87, 0x81, 0x00, 0x00, 0x87, 0xa6, 0x00, 0x00, 0x87, 0xc8, 0x00,
+    0x00, 0x87, 0xea, 0x00, 0x00, 0x88, 0x0e, 0x00, 0x00, 0x88, 0x2f, 0x00,
+    0x00, 0x88, 0x59, 0x00, 0x00, 0x88, 0x7f, 0x00, 0x00, 0x88, 0xa6, 0x00,
+    0x00, 0x88, 0xd2, 0x00, 0x00, 0x88, 0xf9, 0x00, 0x00, 0x89, 0x21, 0x00,
+    0x00, 0x89, 0x47, 0x00, 0x00, 0x89, 0x6d, 0x00, 0x00, 0x89, 0x91, 0x00,
+    0x00, 0x89, 0xb5, 0x00, 0x00, 0x89, 0xd8, 0x00, 0x00, 0x89, 0xfa, 0x00,
+    0x00, 0x8a, 0x21, 0x00, 0x00, 0x8a, 0x49, 0x00, 0x00, 0x8a, 0x6e, 0x00,
+    0x00, 0x8a, 0x95, 0x00, 0x00, 0x8a, 0xb9, 0x00, 0x00, 0x8a, 0xe0, 0x00,
+    0x00, 0x8b, 0x05, 0x00, 0x00, 0x8b, 0x2d, 0x00, 0x00, 0x8b, 0x53, 0x00,
+    0x00, 0x8b, 0x79, 0x00, 0x00, 0x8b, 0xac, 0x00, 0x00, 0x8b, 0xce, 0x00,
+    0x00, 0x8b, 0xf1, 0x00, 0x00, 0x8c, 0x16, 0x00, 0x00, 0x8c, 0x3a, 0x00,
+    0x00, 0x8c, 0x5c, 0x00, 0x00, 0x8c, 0x81, 0x00, 0x00, 0x8c, 0xa8, 0x00,
+    0x00, 0x8c, 0xcb, 0x00, 0x00, 0x8c, 0xf0, 0x00, 0x00, 0x8d, 0x11, 0x00,
+    0x00, 0x8d, 0x35, 0x00, 0x00, 0x8d, 0x59, 0x00, 0x00, 0x8d, 0x7d, 0x00,
+    0x00, 0x8d, 0xa1, 0x00, 0x00, 0x8d, 0xc6, 0x00, 0x00, 0x8d, 0xeb, 0x00,
+    0x00, 0x8e, 0x14, 0x00, 0x00, 0x8e, 0x39, 0x00, 0x00, 0x8e, 0x61, 0x00,
+    0x00, 0x8e, 0x84, 0x00, 0x00, 0x8e, 0xae, 0x00, 0x00, 0x8e, 0xd4, 0x00,
+    0x00, 0x8e, 0xf7, 0x00, 0x00, 0x8f, 0x1c, 0x00, 0x00, 0x8f, 0x45, 0x00,
+    0x00, 0x8f, 0x6b, 0x00, 0x00, 0x8f, 0x91, 0x00, 0x00, 0x8f, 0xb6, 0x00,
+    0x00, 0x8f, 0xda, 0x00, 0x00, 0x90, 0x04, 0x00, 0x00, 0x90, 0x2d, 0x00,
+    0x00, 0x90, 0x58, 0x00, 0x00, 0x90, 0x84, 0x00, 0x00, 0x90, 0xa9, 0x00,
+    0x00, 0x90, 0xcd, 0x00, 0x00, 0x90, 0xf1, 0x00, 0x00, 0x91, 0x16, 0x00,
+    0x00, 0x91, 0x3b, 0x00, 0x00, 0x91, 0x6a, 0x00, 0x00, 0x91, 0x8e, 0x00,
+    0x00, 0x91, 0xb5, 0x00, 0x00, 0x91, 0xe4, 0x00, 0x00, 0x92, 0x06, 0x00,
+    0x00, 0x92, 0x29, 0x00, 0x00, 0x92, 0x52, 0x00, 0x00, 0x92, 0x75, 0x00,
+    0x00, 0x92, 0xa1, 0x00, 0x00, 0x92, 0xc3, 0x00, 0x00, 0x92, 0xeb, 0x00,
+    0x00, 0x93, 0x0b, 0x00, 0x00, 0x93, 0x31, 0x00, 0x00, 0x93, 0x5f, 0x00,
+    0x00, 0x93, 0x83, 0x00, 0x00, 0x93, 0xa7, 0x00, 0x00, 0x93, 0xce, 0x00,
+    0x00, 0x93, 0xf2, 0x00, 0x00, 0x94, 0x12, 0x00, 0x00, 0x94, 0x35, 0x00,
+    0x00, 0x94, 0x58, 0x00, 0x00, 0x94, 0x7d, 0x00, 0x00, 0x94, 0xa3, 0x00,
+    0x00, 0x94, 0xca, 0x00, 0x00, 0x94, 0xf4, 0x00, 0x00, 0x95, 0x1e, 0x00,
+    0x00, 0x95, 0x44, 0x00, 0x00, 0x95, 0x66, 0x00, 0x00, 0x95, 0x8d, 0x00,
+    0x00, 0x95, 0xb3, 0x00, 0x00, 0x95, 0xda, 0x00, 0x00, 0x95, 0xff, 0x00,
+    0x00, 0x96, 0x20, 0x00, 0x00, 0x96, 0x47, 0x00, 0x00, 0x96, 0x6c, 0x00,
+    0x00, 0x96, 0x92, 0x00, 0x00, 0x96, 0xb9, 0x00, 0x00, 0x96, 0xe2, 0x00,
+    0x00, 0x97, 0x09, 0x00, 0x00, 0x97, 0x30, 0x00, 0x00, 0x97, 0x50, 0x00,
+    0x00, 0x97, 0x77, 0x00, 0x00, 0x97, 0xa0, 0x00, 0x00, 0x97, 0xc3, 0x00,
+    0x00, 0x97, 0xea, 0x00, 0x00, 0x98, 0x13, 0x00, 0x00, 0x98, 0x38, 0x00,
+    0x00, 0x98, 0x62, 0x00, 0x00, 0x98, 0x84, 0x00, 0x00, 0x98, 0xa6, 0x00,
+    0x00, 0x98, 0xcf, 0x00, 0x00, 0x98, 0xf0, 0x00, 0x00, 0x99, 0x18, 0x00,
+    0x00, 0x99, 0x40, 0x00, 0x00, 0x99, 0x64, 0x00, 0x00, 0x99, 0x8d, 0x00,
+    0x00, 0x99, 0xb8, 0x00, 0x00, 0x99, 0xe0, 0x00, 0x00, 0x9a, 0x04, 0x00,
+    0x00, 0x9a, 0x2a, 0x00, 0x00, 0x9a, 0x4c, 0x00, 0x00, 0x9a, 0x71, 0x00,
+    0x00, 0x9a, 0x9b, 0x00, 0x00, 0x9a, 0xc4, 0x00, 0x00, 0x9a, 0xe7, 0x00,
+    0x00, 0x9b, 0x0b, 0x00, 0x00, 0x9b, 0x2e, 0x00, 0x00, 0x9b, 0x53, 0x00,
+    0x00, 0x9b, 0x79, 0x00, 0x00, 0x9b, 0x9b, 0x00, 0x00, 0x9b, 0xc8, 0x00,
+    0x00, 0x9b, 0xed, 0x00, 0x00, 0x9c, 0x15, 0x00, 0x00, 0x9c, 0x3c, 0x00,
+    0x00, 0x9c, 0x60, 0x00, 0x00, 0x9c, 0x83, 0x00, 0x00, 0x9c, 0xa8, 0x00,
+    0x00, 0x9c, 0xce, 0x00, 0x00, 0x9c, 0xf2, 0x00, 0x00, 0x9d, 0x1d, 0x00,
+    0x00, 0x9d, 0x3e, 0x00, 0x00, 0x9d, 0x68, 0x00, 0x00, 0x9d, 0x8e, 0x00,
+    0x00, 0x9d, 0xb1, 0x00, 0x00, 0x9d, 0xd8, 0x00, 0x00, 0x9d, 0xfc, 0x00,
+    0x00, 0x9e, 0x20, 0x00, 0x00, 0x9e, 0x45, 0x00, 0x00, 0x9e, 0x76, 0x00,
+    0x00, 0x9e, 0x9f, 0x00, 0x00, 0x9e, 0xc4, 0x00, 0x00, 0x9e, 0xee, 0x00,
+    0x00, 0x9f, 0x14, 0x00, 0x00, 0x9f, 0x37, 0x00, 0x00, 0x9f, 0x63, 0x00,
+    0x00, 0x9f, 0x86, 0x00, 0x00, 0x9f, 0xac, 0x00, 0x00, 0x9f, 0xcf, 0x00,
+    0x00, 0x9f, 0xfa, 0x00, 0x00, 0xa0, 0x21, 0x00, 0x00, 0xa0, 0x41, 0x00,
+    0x00, 0xa0, 0x67, 0x00, 0x00, 0xa0, 0x8f, 0x00, 0x00, 0xa0, 0xb8, 0x00,
+    0x00, 0xa0, 0xdd, 0x00, 0x00, 0xa1, 0x05, 0x00, 0x00, 0xa1, 0x2b, 0x00,
+    0x00, 0xa1, 0x4c, 0x00, 0x00, 0xa1, 0x71, 0x00, 0x00, 0xa1, 0x94, 0x00,
+    0x00, 0xa1, 0xc1, 0x00, 0x00, 0xa1, 0xe6, 0x00, 0x00, 0xa2, 0x0b, 0x00,
+    0x00, 0xa2, 0x2f, 0x00, 0x00, 0xa2, 0x52, 0x00, 0x00, 0xa2, 0x73, 0x00,
+    0x00, 0xa2, 0x98, 0x00, 0x00, 0xa2, 0xbf, 0x00, 0x00, 0xa2, 0xe8, 0x00,
+    0x00, 0xa3, 0x11, 0x00, 0x00, 0xa3, 0x37, 0x00, 0x00, 0xa3, 0x5a, 0x00,
+    0x00, 0xa3, 0x7e, 0x00, 0x00, 0xa3, 0xa0, 0x00, 0x00, 0xa3, 0xcb, 0x00,
+    0x00, 0xa3, 0xef, 0x00, 0x00, 0xa4, 0x15, 0x00, 0x00, 0xa4, 0x39, 0x00,
+    0x00, 0xa4, 0x5d, 0x00, 0x00, 0xa4, 0x84, 0x00, 0x00, 0xa4, 0xac, 0x00,
+    0x00, 0xa4, 0xd2, 0x00, 0x00, 0xa4, 0xfb, 0x00, 0x00, 0xa5, 0x21, 0x00,
+    0x00, 0xa5, 0x4b, 0x00, 0x00, 0xa5, 0x70, 0x00, 0x00, 0xa5, 0x94, 0x00,
+    0x00, 0xa5, 0xb6, 0x00, 0x00, 0xa5, 0xda, 0x00, 0x00, 0xa6, 0x02, 0x00,
+    0x00, 0xa6, 0x25, 0x00, 0x00, 0xa6, 0x4c, 0x00, 0x00, 0xa6, 0x71, 0x00,
+    0x00, 0xa6, 0x92, 0x00, 0x00, 0xa6, 0xb7, 0x00, 0x00, 0xa6, 0xdf, 0x00,
+    0x00, 0xa7, 0x03, 0x00, 0x00, 0xa7, 0x31, 0x00, 0x00, 0xa7, 0x5d, 0x00,
+    0x00, 0xa7, 0x82, 0x00, 0x00, 0xa7, 0xa6, 0x00, 0x00, 0xa7, 0xc8, 0x00,
+    0x00, 0xa7, 0xea, 0x00, 0x00, 0xa8, 0x14, 0x00, 0x00, 0xa8, 0x37, 0x00,
+    0x00, 0xa8, 0x5d, 0x00, 0x00, 0xa8, 0x7e, 0x00, 0x00, 0xa8, 0xa2, 0x00,
+    0x00, 0xa8, 0xca, 0x00, 0x00, 0xa8, 0xef, 0x00, 0x00, 0xa9, 0x15, 0x00,
+    0x00, 0xa9, 0x3c, 0x00, 0x00, 0xa9, 0x61, 0x00, 0x00, 0xa9, 0x85, 0x00,
+    0x00, 0xa9, 0xaa, 0x00, 0x00, 0xa9, 0xcf, 0x00, 0x00, 0xa9, 0xf3, 0x00,
+    0x00, 0xaa, 0x1c, 0x00, 0x00, 0xaa, 0x3f, 0x00, 0x00, 0xaa, 0x63, 0x00,
+    0x00, 0xaa, 0x8a, 0x00, 0x00, 0xaa, 0xac, 0x00, 0x00, 0xaa, 0xd0, 0x00,
+    0x00, 0xaa, 0xf4, 0x00, 0x00, 0xab, 0x21, 0x00, 0x00, 0xab, 0x48, 0x00,
+    0x00, 0xab, 0x6d, 0x00, 0x00, 0xab, 0x96, 0x00, 0x00, 0xab, 0xbc, 0x00,
+    0x00, 0xab, 0xea, 0x00, 0x00, 0xac, 0x0c, 0x00, 0x00, 0xac, 0x2b, 0x00,
+    0x00, 0xac, 0x4e, 0x00, 0x00, 0xac, 0x71, 0x00, 0x00, 0xac, 0x96, 0x00,
+    0x00, 0xac, 0xbd, 0x00, 0x00, 0xac, 0xe3, 0x00, 0x00, 0xad, 0x0b, 0x00,
+    0x00, 0xad, 0x2f, 0x00, 0x00, 0xad, 0x51, 0x00, 0x00, 0xad, 0x75, 0x00,
+    0x00, 0xad, 0x9a, 0x00, 0x00, 0xad, 0xc1, 0x00, 0x00, 0xad, 0xe6, 0x00,
+    0x00, 0xae, 0x0e, 0x00, 0x00, 0xae, 0x33, 0x00, 0x00, 0xae, 0x59, 0x00,
+    0x00, 0xae, 0x80, 0x00, 0x00, 0xae, 0xa9, 0x00, 0x00, 0xae, 0xd5, 0x00,
+    0x00, 0xae, 0xfa, 0x00, 0x00, 0xaf, 0x21, 0x00, 0x00, 0xaf, 0x48, 0x00,
+    0x00, 0xaf, 0x74, 0x00, 0x00, 0xaf, 0x9e, 0x00, 0x00, 0xaf, 0xc7, 0x00,
+    0x00, 0xaf, 0xe8, 0x00, 0x00, 0xb0, 0x08, 0x00, 0x00, 0xb0, 0x35, 0x00,
+    0x00, 0xb0, 0x59, 0x00, 0x00, 0xb0, 0x7b, 0x00, 0x00, 0xb0, 0x9d, 0x00,
+    0x00, 0xb0, 0xc4, 0x00, 0x00, 0xb0, 0xf0, 0x00, 0x00, 0xb1, 0x15, 0x00,
+    0x00, 0xb1, 0x3e, 0x00, 0x00, 0xb1, 0x62, 0x00, 0x00, 0xb1, 0x8b, 0x00,
+    0x00, 0xb1, 0xb6, 0x00, 0x00, 0xb1, 0xda, 0x00, 0x00, 0xb1, 0xff, 0x00,
+    0x00, 0xb2, 0x21, 0x00, 0x00, 0xb2, 0x48, 0x00, 0x00, 0xb2, 0x6b, 0x00,
+    0x00, 0xb2, 0x95, 0x00, 0x00, 0xb2, 0xb9, 0x00, 0x00, 0xb2, 0xe2, 0x00,
+    0x00, 0xb3, 0x0b, 0x00, 0x00, 0xb3, 0x2d, 0x00, 0x00, 0xb3, 0x56, 0x00,
+    0x00, 0xb3, 0x7a, 0x00, 0x00, 0xb3, 0x9d, 0x00, 0x00, 0xb3, 0xc8, 0x00,
+    0x00, 0xb3, 0xf4, 0x00, 0x00, 0xb4, 0x1b, 0x00, 0x00, 0xb4, 0x3d, 0x00,
+    0x00, 0xb4, 0x63, 0x00, 0x00, 0xb4, 0x89, 0x00, 0x00, 0xb4, 0xb2, 0x00,
+    0x00, 0xb4, 0xdb, 0x00, 0x00, 0xb5, 0x08, 0x00, 0x00, 0xb5, 0x2f, 0x00,
+    0x00, 0xb5, 0x57, 0x00, 0x00, 0xb5, 0x7d, 0x00, 0x00, 0xb5, 0xa6, 0x00,
+    0x00, 0xb5, 0xca, 0x00, 0x00, 0xb5, 0xf2, 0x00, 0x00, 0xb6, 0x17, 0x00,
+    0x00, 0xb6, 0x3e, 0x00, 0x00, 0xb6, 0x64, 0x00, 0x00, 0xb6, 0x8f, 0x00,
+    0x00, 0xb6, 0xb3, 0x00, 0x00, 0xb6, 0xdf, 0x00, 0x00, 0xb7, 0x05, 0x00,
+    0x00, 0xb7, 0x2e, 0x00, 0x00, 0xb7, 0x53, 0x00, 0x00, 0xb7, 0x7a, 0x00,
+    0x00, 0xb7, 0xa5, 0x00, 0x00, 0xb7, 0xd1, 0x00, 0x00, 0xb7, 0xf6, 0x00,
+    0x00, 0xb8, 0x1c, 0x00, 0x00, 0xb8, 0x43, 0x00, 0x00, 0xb8, 0x6b, 0x00,
+    0x00, 0xb8, 0x8c, 0x00, 0x00, 0xb8, 0xaf, 0x00, 0x00, 0xb8, 0xd2, 0x00,
+    0x00, 0xb8, 0xf4, 0x00, 0x00, 0xb9, 0x18, 0x00, 0x00, 0xb9, 0x3f, 0x00,
+    0x00, 0xb9, 0x64, 0x00, 0x00, 0xb9, 0x87, 0x00, 0x00, 0xb9, 0xad, 0x00,
+    0x00, 0xb9, 0xd4, 0x00, 0x00, 0xb9, 0xf8, 0x00, 0x00, 0xba, 0x20, 0x00,
+    0x00, 0xba, 0x42, 0x00, 0x00, 0xba, 0x68, 0x00, 0x00, 0xba, 0x90, 0x00,
+    0x00, 0xba, 0xb6, 0x00, 0x00, 0xba, 0xd9, 0x00, 0x00, 0xba, 0xfa, 0x00,
+    0x00, 0xbb, 0x1e, 0x00, 0x00, 0xbb, 0x44, 0x00, 0x00, 0xbb, 0x69, 0x00,
+    0x00, 0xbb, 0x8b, 0x00, 0x00, 0xbb, 0xb0, 0x00, 0x00, 0xbb, 0xd5, 0x00,
+    0x00, 0xbb, 0xfa, 0x00, 0x00, 0xbc, 0x1d, 0x00, 0x00, 0xbc, 0x3f, 0x00,
+    0x00, 0xbc, 0x65, 0x00, 0x00, 0xbc, 0x8c, 0x00, 0x00, 0xbc, 0xaf, 0x00,
+    0x00, 0xbc, 0xd2, 0x00, 0x00, 0xbc, 0xf5, 0x00, 0x00, 0xbd, 0x1c, 0x00,
+    0x00, 0xbd, 0x3f, 0x00, 0x00, 0xbd, 0x61, 0x00, 0x00, 0xbd, 0x8a, 0x00,
+    0x00, 0xbd, 0xaf, 0x00, 0x00, 0xbd, 0xd2, 0x00, 0x00, 0xbd, 0xf1, 0x00,
+    0x00, 0xbe, 0x16, 0x00, 0x00, 0xbe, 0x3d, 0x00, 0x00, 0xbe, 0x64, 0x00,
+    0x00, 0xbe, 0x8a, 0x00, 0x00, 0xbe, 0xb0, 0x00, 0x00, 0xbe, 0xd9, 0x00,
+    0x00, 0xbf, 0x05, 0x00, 0x00, 0xbf, 0x2c, 0x00, 0x00, 0xbf, 0x55, 0x00,
+    0x00, 0xbf, 0x7a, 0x00, 0x00, 0xbf, 0xa1, 0x00, 0x00, 0xbf, 0xd0, 0x00,
+    0x00, 0xbf, 0xf8, 0x00, 0x00, 0xc0, 0x1c, 0x00, 0x00, 0xc0, 0x40, 0x00,
+    0x00, 0xc0, 0x68, 0x00, 0x00, 0xc0, 0x8d, 0x00, 0x00, 0xc0, 0xb4, 0x00,
+    0x00, 0xc0, 0xd7, 0x00, 0x00, 0xc0, 0xfb, 0x00, 0x00, 0xc1, 0x22, 0x00,
+    0x00, 0xc1, 0x48, 0x00, 0x00, 0xc1, 0x74, 0x00, 0x00, 0xc1, 0x9d, 0x00,
+    0x00, 0xc1, 0xbd, 0x00, 0x00, 0xc1, 0xe2, 0x00, 0x00, 0xc2, 0x05, 0x00,
+    0x00, 0xc2, 0x29, 0x00, 0x00, 0xc2, 0x50, 0x00, 0x00, 0xc2, 0x73, 0x00,
+    0x00, 0xc2, 0x9a, 0x00, 0x00, 0xc2, 0xbf, 0x00, 0x00, 0xc2, 0xe9, 0x00,
+    0x00, 0xc3, 0x0e, 0x00, 0x00, 0xc3, 0x32, 0x00, 0x00, 0xc3, 0x53, 0x00,
+    0x00, 0xc3, 0x77, 0x00, 0x00, 0xc3, 0xa2, 0x00, 0x00, 0xc3, 0xc4, 0x00,
+    0x00, 0xc3, 0xe6, 0x00, 0x00, 0xc4, 0x0d, 0x00, 0x00, 0xc4, 0x2f, 0x00,
+    0x00, 0xc4, 0x51, 0x00, 0x00, 0xc4, 0x76, 0x00, 0x00, 0xc4, 0x9f, 0x00,
+    0x00, 0xc4, 0xc4, 0x00, 0x00, 0xc4, 0xee, 0x00, 0x00, 0xc5, 0x15, 0x00,
+    0x00, 0xc5, 0x38, 0x00, 0x00, 0xc5, 0x5d, 0x00, 0x00, 0xc5, 0x89, 0x00,
+    0x00, 0xc5, 0xb5, 0x00, 0x00, 0xc5, 0xd9, 0x00, 0x00, 0xc5, 0xfe, 0x00,
+    0x00, 0xc6, 0x1e, 0x00, 0x00, 0xc6, 0x43, 0x00, 0x00, 0xc6, 0x69, 0x00,
+    0x00, 0xc6, 0x99, 0x00, 0x00, 0xc6, 0xc2, 0x00, 0x00, 0xc6, 0xe7, 0x00,
+    0x00, 0xc7, 0x09, 0x00, 0x00, 0xc7, 0x2d, 0x00, 0x00, 0xc7, 0x4f, 0x00,
+    0x00, 0xc7, 0x74, 0x00, 0x00, 0xc7, 0x9d, 0x00, 0x00, 0xc7, 0xc3, 0x00,
+    0x00, 0xc7, 0xec, 0x00, 0x00, 0xc8, 0x13, 0x00, 0x00, 0xc8, 0x3b, 0x00,
+    0x00, 0xc8, 0x64, 0x00, 0x00, 0xc8, 0x86, 0x00, 0x00, 0xc8, 0xad, 0x00,
+    0x00, 0xc8, 0xd3, 0x00, 0x00, 0xc8, 0xf6, 0x00, 0x00, 0xc9, 0x1c, 0x00,
+    0x00, 0xc9, 0x44, 0x00, 0x00, 0xc9, 0x68, 0x00, 0x00, 0xc9, 0x8d, 0x00,
+    0x00, 0xc9, 0xb4, 0x00, 0x00, 0xc9, 0xd8, 0x00, 0x00, 0xc9, 0xfd, 0x00,
+    0x00, 0xca, 0x27, 0x00, 0x00, 0xca, 0x53, 0x00, 0x00, 0xca, 0x7b, 0x00,
+    0x00, 0xca, 0xa0, 0x00, 0x00, 0xca, 0xc3, 0x00, 0x00, 0xca, 0xe8, 0x00,
+    0x00, 0xcb, 0x08, 0x00, 0x00, 0xcb, 0x33, 0x00, 0x00, 0xcb, 0x5a, 0x00,
+    0x00, 0xcb, 0x7d, 0x00, 0x00, 0xcb, 0xa0, 0x00, 0x00, 0xcb, 0xc4, 0x00,
+    0x00, 0xcb, 0xee, 0x00, 0x00, 0xcc, 0x16, 0x00, 0x00, 0xcc, 0x41, 0x00,
+    0x00, 0xcc, 0x62, 0x00, 0x00, 0xcc, 0x8b, 0x00, 0x00, 0xcc, 0xb3, 0x00,
+    0x00, 0xcc, 0xd7, 0x00, 0x00, 0xcc, 0xfb, 0x00, 0x00, 0xcd, 0x1e, 0x00,
+    0x00, 0xcd, 0x43, 0x00, 0x00, 0xcd, 0x6b, 0x00, 0x00, 0xcd, 0x8f, 0x00,
+    0x00, 0xcd, 0xb4, 0x00, 0x00, 0xcd, 0xdb, 0x00, 0x00, 0xce, 0x00, 0x00,
+    0x00, 0xce, 0x24, 0x00, 0x00, 0xce, 0x4e, 0x00, 0x00, 0xce, 0x79, 0x00,
+    0x00, 0xce, 0x9e, 0x00, 0x00, 0xce, 0xc3, 0x00, 0x00, 0xce, 0xea, 0x00,
+    0x00, 0xcf, 0x12, 0x00, 0x00, 0xcf, 0x37, 0x00, 0x00, 0xcf, 0x5a, 0x00,
+    0x00, 0xcf, 0x80, 0x00, 0x00, 0xcf, 0xa2, 0x00, 0x00, 0xcf, 0xc7, 0x00,
+    0x00, 0xcf, 0xec, 0x00, 0x00, 0xd0, 0x16, 0x00, 0x00, 0xd0, 0x41, 0x00,
+    0x00, 0xd0, 0x67, 0x00, 0x00, 0xd0, 0x8b, 0x00, 0x00, 0xd0, 0xb2, 0x00,
+    0x00, 0xd0, 0xd8, 0x00, 0x00, 0xd0, 0xff, 0x00, 0x00, 0xd1, 0x1f, 0x00,
+    0x00, 0xd1, 0x44, 0x00, 0x00, 0xd1, 0x6a, 0x00, 0x00, 0xd1, 0x92, 0x00,
+    0x00, 0xd1, 0xbb, 0x00, 0x00, 0xd1, 0xdf, 0x00, 0x00, 0xd2, 0x04, 0x00,
+    0x00, 0xd2, 0x2d, 0x00, 0x00, 0xd2, 0x56, 0x00, 0x00, 0xd2, 0x7f, 0x00,
+    0x00, 0xd2, 0xa7, 0x00, 0x00, 0xd2, 0xca, 0x00, 0x00, 0xd2, 0xed, 0x00,
+    0x00, 0xd3, 0x10, 0x00, 0x00, 0xd3, 0x3a, 0x00, 0x00, 0xd3, 0x60, 0x00,
+    0x00, 0xd3, 0x87, 0x00, 0x00, 0xd3, 0xac, 0x00, 0x00, 0xd3, 0xd2, 0x00,
+    0x00, 0xd3, 0xfc, 0x00, 0x00, 0xd4, 0x25, 0x00, 0x00, 0xd4, 0x4a, 0x00,
+    0x00, 0xd4, 0x71, 0x00, 0x00, 0xd4, 0x97, 0x00, 0x00, 0xd4, 0xc0, 0x00,
+    0x00, 0xd4, 0xe8, 0x00, 0x00, 0xd5, 0x11, 0x00, 0x00, 0xd5, 0x36, 0x00,
+    0x00, 0xd5, 0x5e, 0x00, 0x00, 0xd5, 0x83, 0x00, 0x00, 0xd5, 0xa9, 0x00,
+    0x00, 0xd5, 0xd1, 0x00, 0x00, 0xd5, 0xf2, 0x00, 0x00, 0xd6, 0x16, 0x00,
+    0x00, 0xd6, 0x3b, 0x00, 0x00, 0xd6, 0x5c, 0x00, 0x00, 0xd6, 0x80, 0x00,
+    0x00, 0xd6, 0xa4, 0x00, 0x00, 0xd6, 0xcb, 0x00, 0x00, 0xd6, 0xeb, 0x00,
+    0x00, 0xd7, 0x0f, 0x00, 0x00, 0xd7, 0x39, 0x00, 0x00, 0xd7, 0x5b, 0x00,
+    0x00, 0xd7, 0x81, 0x00, 0x00, 0xd7, 0xa4, 0x00, 0x00, 0xd7, 0xc6, 0x00,
+    0x00, 0xd7, 0xeb, 0x00, 0x00, 0xd8, 0x11, 0x00, 0x00, 0xd8, 0x35, 0x00,
+    0x00, 0xd8, 0x58, 0x00, 0x00, 0xd8, 0x7c, 0x00, 0x00, 0xd8, 0xa7, 0x00,
+    0x00, 0xd8, 0xcb, 0x00, 0x00, 0xd8, 0xf0, 0x00, 0x00, 0xd9, 0x15, 0x00,
+    0x00, 0xd9, 0x36, 0x00, 0x00, 0xd9, 0x59, 0x00, 0x00, 0xd9, 0x7f, 0x00,
+    0x00, 0xd9, 0xa5, 0x00, 0x00, 0xd9, 0xca, 0x00, 0x00, 0xd9, 0xed, 0x00,
+    0x00, 0xda, 0x17, 0x00, 0x00, 0xda, 0x40, 0x00, 0x00, 0xda, 0x68, 0x00,
+    0x00, 0xda, 0x8b, 0x00, 0x00, 0xda, 0xb3, 0x00, 0x00, 0xda, 0xdb, 0x00,
+    0x00, 0xdb, 0x01, 0x00, 0x00, 0xdb, 0x2b, 0x00, 0x00, 0xdb, 0x54, 0x00,
+    0x00, 0xdb, 0x7a, 0x00, 0x00, 0xdb, 0x9f, 0x00, 0x00, 0xdb, 0xc8, 0x00,
+    0x00, 0xdb, 0xe8, 0x00, 0x00, 0xdc, 0x10, 0x00, 0x00, 0xdc, 0x37, 0x00,
+    0x00, 0xdc, 0x5d, 0x00, 0x00, 0xdc, 0x86, 0x00, 0x00, 0xdc, 0xb4, 0x00,
+    0x00, 0xdc, 0xd7, 0x00, 0x00, 0xdc, 0xfe, 0x00, 0x00, 0xdd, 0x23, 0x00,
+    0x00, 0xdd, 0x51, 0x00, 0x00, 0xdd, 0x7a, 0x00, 0x00, 0xdd, 0x9f, 0x00,
+    0x00, 0xdd, 0xc5, 0x00, 0x00, 0xdd, 0xf4, 0x00, 0x00, 0xde, 0x1e, 0x00,
+    0x00, 0xde, 0x42, 0x00, 0x00, 0xde, 0x66, 0x00, 0x00, 0xde, 0x88, 0x00,
+    0x00, 0xde, 0xb3, 0x00, 0x00, 0xde, 0xd9, 0x00, 0x00, 0xdf, 0x01, 0x00,
+    0x00, 0xdf, 0x28, 0x00, 0x00, 0xdf, 0x55, 0x00, 0x00, 0xdf, 0x7c, 0x00,
+    0x00, 0xdf, 0xa3, 0x00, 0x00, 0xdf, 0xc3, 0x00, 0x00, 0xdf, 0xe8, 0x00,
+    0x00, 0xe0, 0x07, 0x00, 0x00, 0xe0, 0x2e, 0x00, 0x00, 0xe0, 0x55, 0x00,
+    0x00, 0xe0, 0x7a, 0x00, 0x00, 0xe0, 0xa0, 0x00, 0x00, 0xe0, 0xc9, 0x00,
+    0x00, 0xe0, 0xee, 0x00, 0x00, 0xe1, 0x12, 0x00, 0x00, 0xe1, 0x39, 0x00,
+    0x00, 0xe1, 0x65, 0x00, 0x00, 0xe1, 0x8b, 0x00, 0x00, 0xe1, 0xb1, 0x00,
+    0x00, 0xe1, 0xd3, 0x00, 0x00, 0xe1, 0xf7, 0x00, 0x00, 0xe2, 0x20, 0x00,
+    0x00, 0xe2, 0x41, 0x00, 0x00, 0xe2, 0x64, 0x00, 0x00, 0xe2, 0x95, 0x00,
+    0x00, 0xe2, 0xb6, 0x00, 0x00, 0xe2, 0xdf, 0x00, 0x00, 0xe3, 0x03, 0x00,
+    0x00, 0xe3, 0x2a, 0x00, 0x00, 0xe3, 0x53, 0x00, 0x00, 0xe3, 0x7c, 0x00,
+    0x00, 0xe3, 0xa3, 0x00, 0x00, 0xe3, 0xcd, 0x00, 0x00, 0xe3, 0xf7, 0x00,
+    0x00, 0xe4, 0x20, 0x00, 0x00, 0xe4, 0x47, 0x00, 0x00, 0xe4, 0x70, 0x00,
+    0x00, 0xe4, 0x97, 0x00, 0x00, 0xe4, 0xbc, 0x00, 0x00, 0xe4, 0xe3, 0x00,
+    0x00, 0xe5, 0x09, 0x00, 0x00, 0xe5, 0x2e, 0x00, 0x00, 0xe5, 0x57, 0x00,
+    0x00, 0xe5, 0x7e, 0x00, 0x00, 0xe5, 0xa4, 0x00, 0x00, 0xe5, 0xcb, 0x00,
+    0x00, 0xe5, 0xee, 0x00, 0x00, 0xe6, 0x14, 0x00, 0x00, 0xe6, 0x39, 0x00,
+    0x00, 0xe6, 0x63, 0x00, 0x00, 0xe6, 0x87, 0x00, 0x00, 0xe6, 0xae, 0x00,
+    0x00, 0xe6, 0xd8, 0x00, 0x00, 0xe6, 0xfb, 0x00, 0x00, 0xe7, 0x21, 0x00,
+    0x00, 0xe7, 0x4a, 0x00, 0x00, 0xe7, 0x6f, 0x00, 0x00, 0xe7, 0x91, 0x00,
+    0x00, 0xe7, 0xb5, 0x00, 0x00, 0xe7, 0xdc, 0x00, 0x00, 0xe8, 0x07, 0x00,
+    0x00, 0xe8, 0x2a, 0x00, 0x00, 0xe8, 0x51, 0x00, 0x00, 0xe8, 0x79, 0x00,
+    0x00, 0xe8, 0xa0, 0x00, 0x00, 0xe8, 0xc5, 0x00, 0x00, 0xe8, 0xe6, 0x00,
+    0x00, 0xe9, 0x07, 0x00, 0x00, 0xe9, 0x30, 0x00, 0x00, 0xe9, 0x58, 0x00,
+    0x00, 0xe9, 0x7b, 0x00, 0x00, 0xe9, 0xa1, 0x00, 0x00, 0xe9, 0xca, 0x00,
+    0x00, 0xe9, 0xea, 0x00, 0x00, 0xea, 0x12, 0x00, 0x00, 0xea, 0x39, 0x00,
+    0x00, 0xea, 0x5f, 0x00, 0x00, 0xea, 0x85, 0x00, 0x00, 0xea, 0xb2, 0x00,
+    0x00, 0xea, 0xd7, 0x00, 0x00, 0xea, 0xfd, 0x00, 0x00, 0xeb, 0x21, 0x00,
+    0x00, 0xeb, 0x48, 0x00, 0x00, 0xeb, 0x6f, 0x00, 0x00, 0xeb, 0x95, 0x00,
+    0x00, 0xeb, 0xba, 0x00, 0x00, 0xeb, 0xd9, 0x00, 0x00, 0xeb, 0xfd, 0x00,
+    0x00, 0xec, 0x1f, 0x00, 0x00, 0xec, 0x44, 0x00, 0x00, 0xec, 0x6b, 0x00,
+    0x00, 0xec, 0x8b, 0x00, 0x00, 0xec, 0xb6, 0x00, 0x00, 0xec, 0xd9, 0x00,
+    0x00, 0xed, 0x01, 0x00, 0x00, 0xed, 0x26, 0x00, 0x00, 0xed, 0x4a, 0x00,
+    0x00, 0xed, 0x6e, 0x00, 0x00, 0xed, 0x8f, 0x00, 0x00, 0xed, 0xb3, 0x00,
+    0x00, 0xed, 0xd7, 0x00, 0x00, 0xee, 0x00, 0x00, 0x00, 0xee, 0x27, 0x00,
+    0x00, 0xee, 0x4f, 0x00, 0x00, 0xee, 0x76, 0x00, 0x00, 0xee, 0x9c, 0x00,
+    0x00, 0xee, 0xc2, 0x00, 0x00, 0xee, 0xe7, 0x00, 0x00, 0xef, 0x0c, 0x00,
+    0x00, 0xef, 0x32, 0x00, 0x00, 0xef, 0x58, 0x00, 0x00, 0xef, 0x7b, 0x00,
+    0x00, 0xef, 0x9e, 0x00, 0x00, 0xef, 0xc3, 0x00, 0x00, 0xef, 0xe5, 0x00,
+    0x00, 0xf0, 0x0a, 0x00, 0x00, 0xf0, 0x33, 0x00, 0x00, 0xf0, 0x55, 0x00,
+    0x00, 0xf0, 0x79, 0x00, 0x00, 0xf0, 0x99, 0x00, 0x00, 0xf0, 0xbd, 0x00,
+    0x00, 0xf0, 0xe4, 0x00, 0x00, 0xf1, 0x0f, 0x00, 0x00, 0xf1, 0x33, 0x00,
+    0x00, 0xf1, 0x59, 0x00, 0x00, 0xf1, 0x7c, 0x00, 0x00, 0xf1, 0xa7, 0x00,
+    0x00, 0xf1, 0xc9, 0x00, 0x00, 0xf1, 0xf1, 0x00, 0x00, 0xf2, 0x16, 0x00,
+    0x00, 0xf2, 0x3d, 0x00, 0x00, 0xf2, 0x65, 0x00, 0x00, 0xf2, 0x91, 0x00,
+    0x00, 0xf2, 0xb7, 0x00, 0x00, 0xf2, 0xd9, 0x00, 0x00, 0xf3, 0x01, 0x00,
+    0x00, 0xf3, 0x22, 0x00, 0x00, 0xf3, 0x43, 0x00, 0x00, 0xf3, 0x69, 0x00,
+    0x00, 0xf3, 0x8f, 0x00, 0x00, 0xf3, 0xb3, 0x00, 0x00, 0xf3, 0xd6, 0x00,
+    0x00, 0xf3, 0xf9, 0x00, 0x00, 0xf4, 0x24, 0x00, 0x00, 0xf4, 0x46, 0x00,
+    0x00, 0xf4, 0x69, 0x00, 0x00, 0xf4, 0x8a, 0x00, 0x00, 0xf4, 0xb5, 0x00,
+    0x00, 0xf4, 0xda, 0x00, 0x00, 0xf4, 0xfc, 0x00, 0x00, 0xf5, 0x22, 0x00,
+    0x00, 0xf5, 0x49, 0x00, 0x00, 0xf5, 0x6c, 0x00, 0x00, 0xf5, 0x94, 0x00,
+    0x00, 0xf5, 0xb8, 0x00, 0x00, 0xf5, 0xe0, 0x00, 0x00, 0xf6, 0x04, 0x00,
+    0x00, 0xf6, 0x28, 0x00, 0x00, 0xf6, 0x4e, 0x00, 0x00, 0xf6, 0x74, 0x00,
+    0x00, 0xf6, 0x98, 0x00, 0x00, 0xf6, 0xc0, 0x00, 0x00, 0xf6, 0xe3, 0x00,
+    0x00, 0xf7, 0x07, 0x00, 0x00, 0xf7, 0x2f, 0x00, 0x00, 0xf7, 0x51, 0x00,
+    0x00, 0xf7, 0x78, 0x00, 0x00, 0xf7, 0x9c, 0x00, 0x00, 0xf7, 0xc4, 0x00,
+    0x00, 0xf7, 0xe6, 0x00, 0x00, 0xf8, 0x0c, 0x00, 0x00, 0xf8, 0x32, 0x00,
+    0x00, 0xf8, 0x5e, 0x00, 0x00, 0xf8, 0x83, 0x00, 0x00, 0xf8, 0xa7, 0x00,
+    0x00, 0xf8, 0xd1, 0x00, 0x00, 0xf8, 0xf2, 0x00, 0x00, 0xf9, 0x1e, 0x00,
+    0x00, 0xf9, 0x4a, 0x00, 0x00, 0xf9, 0x72, 0x00, 0x00, 0xf9, 0x99, 0x00,
+    0x00, 0xf9, 0xbe, 0x00, 0x00, 0xf9, 0xe2, 0x00, 0x00, 0xfa, 0x04, 0x00,
+    0x00, 0xfa, 0x2a, 0x00, 0x00, 0xfa, 0x4b, 0x00, 0x00, 0xfa, 0x6e, 0x00,
+    0x00, 0xfa, 0x93, 0x00, 0x00, 0xfa, 0xb4, 0x00, 0x00, 0xfa, 0xd8, 0x00,
+    0x00, 0xfa, 0xfc, 0x00, 0x00, 0xfb, 0x20, 0x00, 0x00, 0xfb, 0x49, 0x00,
+    0x00, 0xfb, 0x71, 0x00, 0x00, 0xfb, 0x96, 0x00, 0x00, 0xfb, 0xbc, 0x00,
+    0x00, 0xfb, 0xe8, 0x00, 0x00, 0xfc, 0x13, 0x00, 0x00, 0xfc, 0x39, 0x00,
+    0x00, 0xfc, 0x61, 0x00, 0x00, 0xfc, 0x85, 0x00, 0x00, 0xfc, 0xb0, 0x00,
+    0x00, 0xfc, 0xdb, 0x00, 0x00, 0xfc, 0xff, 0x00, 0x00, 0xfd, 0x29, 0x00,
+    0x00, 0xfd, 0x53, 0x00, 0x00, 0xfd, 0x78, 0x00, 0x00, 0xfd, 0xa0, 0x00,
+    0x00, 0xfd, 0xcb, 0x00, 0x00, 0xfd, 0xee, 0x00, 0x00, 0xfe, 0x13, 0x00,
+    0x00, 0xfe, 0x37, 0x00, 0x00, 0xfe, 0x63, 0x00, 0x00, 0xfe, 0x8e, 0x00,
+    0x00, 0xfe, 0xb2, 0x00, 0x00, 0xfe, 0xd6, 0x00, 0x00, 0xff, 0x01, 0x00,
+    0x00, 0xff, 0x28, 0x00, 0x00, 0xff, 0x4d, 0x00, 0x00, 0xff, 0x6d, 0x00,
+    0x00, 0xff, 0x99, 0x00, 0x00, 0xff, 0xbd, 0x00, 0x00, 0xff, 0xe2, 0x00,
+    0x01, 0x00, 0x08, 0x00, 0x01, 0x00, 0x2b, 0x00, 0x01, 0x00, 0x4f, 0x00,
+    0x01, 0x00, 0x74, 0x00, 0x01, 0x00, 0x9c, 0x00, 0x01, 0x00, 0xca, 0x00,
+    0x01, 0x00, 0xf1, 0x00, 0x01, 0x01, 0x17, 0x00, 0x01, 0x01, 0x43, 0x00,
+    0x01, 0x01, 0x65, 0x00, 0x01, 0x01, 0x89, 0x00, 0x01, 0x01, 0xad, 0x00,
+    0x01, 0x01, 0xd4, 0x00, 0x01, 0x01, 0xf7, 0x00, 0x01, 0x02, 0x1c, 0x00,
+    0x01, 0x02, 0x45, 0x00, 0x01, 0x02, 0x6f, 0x00, 0x01, 0x02, 0x95, 0x00,
+    0x01, 0x02, 0xb9, 0x00, 0x01, 0x02, 0xe2, 0x00, 0x01, 0x03, 0x06, 0x00,
+    0x01, 0x03, 0x30, 0x00, 0x01, 0x03, 0x53, 0x00, 0x01, 0x03, 0x7c, 0x00,
+    0x01, 0x03, 0xa8, 0x00, 0x01, 0x03, 0xcb, 0x00, 0x01, 0x03, 0xef, 0x00,
+    0x01, 0x04, 0x12, 0x00, 0x01, 0x04, 0x3f, 0x00, 0x01, 0x04, 0x64, 0x00,
+    0x01, 0x04, 0x89, 0x00, 0x01, 0x04, 0xaa, 0x00, 0x01, 0x04, 0xca, 0x00,
+    0x01, 0x04, 0xee, 0x00, 0x01, 0x05, 0x13, 0x00, 0x01, 0x05, 0x39, 0x00,
+    0x01, 0x05, 0x64, 0x00, 0x01, 0x05, 0x8c, 0x00, 0x01, 0x05, 0xb3, 0x00,
+    0x01, 0x05, 0xd5, 0x00, 0x01, 0x05, 0xf9, 0x00, 0x01, 0x06, 0x1d, 0x00,
+    0x01, 0x06, 0x46, 0x00, 0x01, 0x06, 0x74, 0x00, 0x01, 0x06, 0xa0, 0x00,
+    0x01, 0x06, 0xc5, 0x00, 0x01, 0x06, 0xee, 0x00, 0x01, 0x07, 0x18, 0x00,
+    0x01, 0x07, 0x3c, 0x00, 0x01, 0x07, 0x60, 0x00, 0x01, 0x07, 0x87, 0x00,
+    0x01, 0x07, 0xaa, 0x00, 0x01, 0x07, 0xcf, 0x00, 0x01, 0x07, 0xf3, 0x00,
+    0x01, 0x08, 0x18, 0x00, 0x01, 0x08, 0x45, 0x00, 0x01, 0x08, 0x65, 0x00,
+    0x01, 0x08, 0x8e, 0x00, 0x01, 0x08, 0xb4, 0x00, 0x01, 0x08, 0xe0, 0x00,
+    0x01, 0x09, 0x04, 0x00, 0x01, 0x09, 0x2a, 0x00, 0x01, 0x09, 0x51, 0x00,
+    0x01, 0x09, 0x73, 0x00, 0x01, 0x09, 0x9d, 0x00, 0x01, 0x09, 0xc0, 0x00,
+    0x01, 0x09, 0xe7, 0x00, 0x01, 0x0a, 0x08, 0x00, 0x01, 0x0a, 0x2b, 0x00,
+    0x01, 0x0a, 0x4f, 0x00, 0x01, 0x0a, 0x76, 0x00, 0x01, 0x0a, 0x99, 0x00,
+    0x01, 0x0a, 0xc2, 0x00, 0x01, 0x0a, 0xec, 0x00, 0x01, 0x0b, 0x15, 0x00,
+    0x01, 0x0b, 0x3a, 0x00, 0x01, 0x0b, 0x5e, 0x00, 0x01, 0x0b, 0x82, 0x00,
+    0x01, 0x0b, 0xaa, 0x00, 0x01, 0x0b, 0xce, 0x00, 0x01, 0x0b, 0xf8, 0x00,
+    0x01, 0x0c, 0x1c, 0x00, 0x01, 0x0c, 0x44, 0x00, 0x01, 0x0c, 0x69, 0x00,
+    0x01, 0x0c, 0x91, 0x00, 0x01, 0x0c, 0xb3, 0x00, 0x01, 0x0c, 0xd7, 0x00,
+    0x01, 0x0c, 0xf8, 0x00, 0x01, 0x0d, 0x1a, 0x00, 0x01, 0x0d, 0x3f, 0x00,
+    0x01, 0x0d, 0x6b, 0x00, 0x01, 0x0d, 0x95, 0x00, 0x01, 0x0d, 0xb9, 0x00,
+    0x01, 0x0d, 0xe0, 0x00, 0x01, 0x0e, 0x04, 0x00, 0x01, 0x0e, 0x2a, 0x00,
+    0x01, 0x0e, 0x4e, 0x00, 0x01, 0x0e, 0x72, 0x00, 0x01, 0x0e, 0x9b, 0x00,
+    0x01, 0x0e, 0xbd, 0x00, 0x01, 0x0e, 0xe9, 0x00, 0x01, 0x0f, 0x12, 0x00,
+    0x01, 0x0f, 0x38, 0x00, 0x01, 0x0f, 0x59, 0x00, 0x01, 0x0f, 0x7d, 0x00,
+    0x01, 0x0f, 0xa4, 0x00, 0x01, 0x0f, 0xca, 0x00, 0x01, 0x0f, 0xef, 0x00,
+    0x01, 0x10, 0x1c, 0x00, 0x01, 0x10, 0x44, 0x00, 0x01, 0x10, 0x6d, 0x00,
+    0x01, 0x10, 0x90, 0x00, 0x01, 0x10, 0xb6, 0x00, 0x01, 0x10, 0xde, 0x00,
+    0x01, 0x11, 0x07, 0x00, 0x01, 0x11, 0x2d, 0x00, 0x01, 0x11, 0x56, 0x00,
+    0x01, 0x11, 0x7d, 0x00, 0x01, 0x11, 0x9d, 0x00, 0x01, 0x11, 0xc0, 0x00,
+    0x01, 0x11, 0xe7, 0x00, 0x01, 0x12, 0x0b, 0x00, 0x01, 0x12, 0x33, 0x00,
+    0x01, 0x12, 0x5a, 0x00, 0x01, 0x12, 0x7d, 0x00, 0x01, 0x12, 0xa0, 0x00,
+    0x01, 0x12, 0xc4, 0x00, 0x01, 0x12, 0xec, 0x00, 0x01, 0x13, 0x10, 0x00,
+    0x01, 0x13, 0x37, 0x00, 0x01, 0x13, 0x5b, 0x00, 0x01, 0x13, 0x7d, 0x00,
+    0x01, 0x13, 0xa7, 0x00, 0x01, 0x13, 0xd0, 0x00, 0x01, 0x13, 0xf8, 0x00,
+    0x01, 0x14, 0x1b, 0x00, 0x01, 0x14, 0x3f, 0x00, 0x01, 0x14, 0x63, 0x00,
+    0x01, 0x14, 0x89, 0x00, 0x01, 0x14, 0xaf, 0x00, 0x01, 0x14, 0xd2, 0x00,
+    0x01, 0x14, 0xf7, 0x00, 0x01, 0x15, 0x17, 0x00, 0x01, 0x15, 0x3b, 0x00,
+    0x01, 0x15, 0x66, 0x00, 0x01, 0x15, 0x8d, 0x00, 0x01, 0x15, 0xb0, 0x00,
+    0x01, 0x15, 0xd7, 0x00, 0x01, 0x15, 0xfc, 0x00, 0x01, 0x16, 0x27, 0x00,
+    0x01, 0x16, 0x52, 0x00, 0x01, 0x16, 0x76, 0x00, 0x01, 0x16, 0x9e, 0x00,
+    0x01, 0x16, 0xc2, 0x00, 0x01, 0x16, 0xe7, 0x00, 0x01, 0x17, 0x0c, 0x00,
+    0x01, 0x17, 0x2f, 0x00, 0x01, 0x17, 0x5a, 0x00, 0x01, 0x17, 0x80, 0x00,
+    0x01, 0x17, 0xa3, 0x00, 0x01, 0x17, 0xc8, 0x00, 0x01, 0x17, 0xeb, 0x00,
+    0x01, 0x18, 0x11, 0x00, 0x01, 0x18, 0x36, 0x00, 0x01, 0x18, 0x5a, 0x00,
+    0x01, 0x18, 0x7e, 0x00, 0x01, 0x18, 0xa3, 0x00, 0x01, 0x18, 0xca, 0x00,
+    0x01, 0x18, 0xee, 0x00, 0x01, 0x19, 0x23, 0x00, 0x01, 0x19, 0x47, 0x00,
+    0x01, 0x19, 0x71, 0x00, 0x01, 0x19, 0x99, 0x00, 0x01, 0x19, 0xba, 0x00,
+    0x01, 0x19, 0xde, 0x00, 0x01, 0x1a, 0x02, 0x00, 0x01, 0x1a, 0x26, 0x00,
+    0x01, 0x1a, 0x45, 0x00, 0x01, 0x1a, 0x6c, 0x00, 0x01, 0x1a, 0x92, 0x00,
+    0x01, 0x1a, 0xb4, 0x00, 0x01, 0x1a, 0xdb, 0x00, 0x01, 0x1a, 0xfc, 0x00,
+    0x01, 0x1b, 0x20, 0x00, 0x01, 0x1b, 0x47, 0x00, 0x01, 0x1b, 0x6b, 0x00,
+    0x01, 0x1b, 0x8f, 0x00, 0x01, 0x1b, 0xb5, 0x00, 0x01, 0x1b, 0xd8, 0x00,
+    0x01, 0x1b, 0xfb, 0x00, 0x01, 0x1c, 0x22, 0x00, 0x01, 0x1c, 0x4a, 0x00,
+    0x01, 0x1c, 0x75, 0x00, 0x01, 0x1c, 0x9a, 0x00, 0x01, 0x1c, 0xc1, 0x00,
+    0x01, 0x1c, 0xe5, 0x00, 0x01, 0x1d, 0x08, 0x00, 0x01, 0x1d, 0x28, 0x00,
+    0x01, 0x1d, 0x4f, 0x00, 0x01, 0x1d, 0x71, 0x00, 0x01, 0x1d, 0x99, 0x00,
+    0x01, 0x1d, 0xbd, 0x00, 0x01, 0x1d, 0xde, 0x00, 0x01, 0x1d, 0xfd, 0x00,
+    0x01, 0x1e, 0x20, 0x00, 0x01, 0x1e, 0x4b, 0x00, 0x01, 0x1e, 0x71, 0x00,
+    0x01, 0x1e, 0x98, 0x00, 0x01, 0x1e, 0xc0, 0x00, 0x01, 0x1e, 0xeb, 0x00,
+    0x01, 0x1f, 0x11, 0x00, 0x01, 0x1f, 0x36, 0x00, 0x01, 0x1f, 0x5c, 0x00,
+    0x01, 0x1f, 0x80, 0x00, 0x01, 0x1f, 0xa1, 0x00, 0x01, 0x1f, 0xc9, 0x00,
+    0x01, 0x1f, 0xf0, 0x00, 0x01, 0x20, 0x16, 0x00, 0x01, 0x20, 0x3a, 0x00,
+    0x01, 0x20, 0x5e, 0x00, 0x01, 0x20, 0x83, 0x00, 0x01, 0x20, 0xa9, 0x00,
+    0x01, 0x20, 0xd1, 0x00, 0x01, 0x20, 0xf6, 0x00, 0x01, 0x21, 0x26, 0x00,
+    0x01, 0x21, 0x52, 0x00, 0x01, 0x21, 0x7e, 0x00, 0x01, 0x21, 0xa3, 0x00,
+    0x01, 0x21, 0xc8, 0x00, 0x01, 0x21, 0xed, 0x00, 0x01, 0x22, 0x14, 0x00,
+    0x01, 0x22, 0x3a, 0x00, 0x01, 0x22, 0x5b, 0x00, 0x01, 0x22, 0x81, 0x00,
+    0x01, 0x22, 0xa2, 0x00, 0x01, 0x22, 0xc7, 0x00, 0x01, 0x22, 0xec, 0x00,
+    0x01, 0x23, 0x0f, 0x00, 0x01, 0x23, 0x38, 0x00, 0x01, 0x23, 0x5e, 0x00,
+    0x01, 0x23, 0x84, 0x00, 0x01, 0x23, 0xa8, 0x00, 0x01, 0x23, 0xcd, 0x00,
+    0x01, 0x23, 0xfa, 0x00, 0x01, 0x24, 0x1d, 0x00, 0x01, 0x24, 0x42, 0x00,
+    0x01, 0x24, 0x65, 0x00, 0x01, 0x24, 0x86, 0x00, 0x01, 0x24, 0xaa, 0x00,
+    0x01, 0x24, 0xd4, 0x00, 0x01, 0x24, 0xf7, 0x00, 0x01, 0x25, 0x22, 0x00,
+    0x01, 0x25, 0x4c, 0x00, 0x01, 0x25, 0x70, 0x00, 0x01, 0x25, 0x91, 0x00,
+    0x01, 0x25, 0xb7, 0x00, 0x01, 0x25, 0xdb, 0x00, 0x01, 0x26, 0x07, 0x00,
+    0x01, 0x26, 0x2c, 0x00, 0x01, 0x26, 0x4f, 0x00, 0x01, 0x26, 0x75, 0x00,
+    0x01, 0x26, 0x9a, 0x00, 0x01, 0x26, 0xbe, 0x00, 0x01, 0x26, 0xe6, 0x00,
+    0x01, 0x27, 0x0f, 0x00, 0x01, 0x27, 0x39, 0x00, 0x01, 0x27, 0x63, 0x00,
+    0x01, 0x27, 0x85, 0x00, 0x01, 0x27, 0xa9, 0x00, 0x01, 0x27, 0xcf, 0x00,
+    0x01, 0x27, 0xf7, 0x00, 0x01, 0x28, 0x1a, 0x00, 0x01, 0x28, 0x3a, 0x00,
+    0x01, 0x28, 0x5a, 0x00, 0x01, 0x28, 0x7d, 0x00, 0x01, 0x28, 0xa4, 0x00,
+    0x01, 0x28, 0xc5, 0x00, 0x01, 0x28, 0xee, 0x00, 0x01, 0x29, 0x15, 0x00,
+    0x01, 0x29, 0x3d, 0x00, 0x01, 0x29, 0x63, 0x00, 0x01, 0x29, 0x8f, 0x00,
+    0x01, 0x29, 0xb6, 0x00, 0x01, 0x29, 0xd8, 0x00, 0x01, 0x29, 0xfa, 0x00,
+    0x01, 0x2a, 0x21, 0x00, 0x01, 0x2a, 0x47, 0x00, 0x01, 0x2a, 0x68, 0x00,
+    0x01, 0x2a, 0x8e, 0x00, 0x01, 0x2a, 0xb3, 0x00, 0x01, 0x2a, 0xe0, 0x00,
+    0x01, 0x2b, 0x07, 0x00, 0x01, 0x2b, 0x2e, 0x00, 0x01, 0x2b, 0x51, 0x00,
+    0x01, 0x2b, 0x7d, 0x00, 0x01, 0x2b, 0xa2, 0x00, 0x01, 0x2b, 0xc7, 0x00,
+    0x01, 0x2b, 0xed, 0x00, 0x01, 0x2c, 0x12, 0x00, 0x01, 0x2c, 0x37, 0x00,
+    0x01, 0x2c, 0x5d, 0x00, 0x01, 0x2c, 0x84, 0x00, 0x01, 0x2c, 0xa6, 0x00,
+    0x01, 0x2c, 0xcc, 0x00, 0x01, 0x2c, 0xf3, 0x00, 0x01, 0x2d, 0x16, 0x00,
+    0x01, 0x2d, 0x3a, 0x00, 0x01, 0x2d, 0x63, 0x00, 0x01, 0x2d, 0x8b, 0x00,
+    0x01, 0x2d, 0xb4, 0x00, 0x01, 0x2d, 0xd8, 0x00, 0x01, 0x2d, 0xf9, 0x00,
+    0x01, 0x2e, 0x24, 0x00, 0x01, 0x2e, 0x4b, 0x00, 0x01, 0x2e, 0x75, 0x00,
+    0x01, 0x2e, 0x97, 0x00, 0x01, 0x2e, 0xba, 0x00, 0x01, 0x2e, 0xdb, 0x00,
+    0x01, 0x2f, 0x05, 0x00, 0x01, 0x2f, 0x2d, 0x00, 0x01, 0x2f, 0x53, 0x00,
+    0x01, 0x2f, 0x77, 0x00, 0x01, 0x2f, 0x99, 0x00, 0x01, 0x2f, 0xbe, 0x00,
+    0x01, 0x2f, 0xe3, 0x00, 0x01, 0x30, 0x05, 0x00, 0x01, 0x30, 0x30, 0x00,
+    0x01, 0x30, 0x55, 0x00, 0x01, 0x30, 0x7e, 0x00, 0x01, 0x30, 0xa2, 0x00,
+    0x01, 0x30, 0xcc, 0x00, 0x01, 0x30, 0xf1, 0x00, 0x01, 0x31, 0x15, 0x00,
+    0x01, 0x31, 0x3d, 0x00, 0x01, 0x31, 0x63, 0x00, 0x01, 0x31, 0x8d, 0x00,
+    0x01, 0x31, 0xae, 0x00, 0x01, 0x31, 0xd4, 0x00, 0x01, 0x31, 0xfc, 0x00,
+    0x01, 0x32, 0x1e, 0x00, 0x01, 0x32, 0x44, 0x00, 0x01, 0x32, 0x6b, 0x00,
+    0x01, 0x32, 0x93, 0x00, 0x01, 0x32, 0xb6, 0x00, 0x01, 0x32, 0xde, 0x00,
+    0x01, 0x33, 0x02, 0x00, 0x01, 0x33, 0x27, 0x00, 0x01, 0x33, 0x4c, 0x00,
+    0x01, 0x33, 0x75, 0x00, 0x01, 0x33, 0x9c, 0x00, 0x01, 0x33, 0xc9, 0x00,
+    0x01, 0x33, 0xf0, 0x00, 0x01, 0x34, 0x18, 0x00, 0x01, 0x34, 0x3e, 0x00,
+    0x01, 0x34, 0x65, 0x00, 0x01, 0x34, 0x8d, 0x00, 0x01, 0x34, 0xad, 0x00,
+    0x01, 0x34, 0xd4, 0x00, 0x01, 0x34, 0xfb, 0x00, 0x01, 0x35, 0x25, 0x00,
+    0x01, 0x35, 0x45, 0x00, 0x01, 0x35, 0x6c, 0x00, 0x01, 0x35, 0x90, 0x00,
+    0x01, 0x35, 0xb1, 0x00, 0x01, 0x35, 0xd6, 0x00, 0x01, 0x35, 0xfb, 0x00,
+    0x01, 0x36, 0x1f, 0x00, 0x01, 0x36, 0x44, 0x00, 0x01, 0x36, 0x67, 0x00,
+    0x01, 0x36, 0x91, 0x00, 0x01, 0x36, 0xb6, 0x00, 0x01, 0x36, 0xdd, 0x00,
+    0x01, 0x37, 0x05, 0x00, 0x01, 0x37, 0x2a, 0x00, 0x01, 0x37, 0x5b, 0x00,
+    0x01, 0x37, 0x80, 0x00, 0x01, 0x37, 0xa5, 0x00, 0x01, 0x37, 0xca, 0x00,
+    0x01, 0x37, 0xed, 0x00, 0x01, 0x38, 0x16, 0x00, 0x01, 0x38, 0x3b, 0x00,
+    0x01, 0x38, 0x5f, 0x00, 0x01, 0x38, 0x83, 0x00, 0x01, 0x38, 0xa7, 0x00,
+    0x01, 0x38, 0xca, 0x00, 0x01, 0x38, 0xee, 0x00, 0x01, 0x39, 0x18, 0x00,
+    0x01, 0x39, 0x41, 0x00, 0x01, 0x39, 0x66, 0x00, 0x01, 0x39, 0x8f, 0x00,
+    0x01, 0x39, 0xb8, 0x00, 0x01, 0x39, 0xdc, 0x00, 0x01, 0x3a, 0x01, 0x00,
+    0x01, 0x3a, 0x26, 0x00, 0x01, 0x3a, 0x59, 0x00, 0x01, 0x3a, 0x7d, 0x00,
+    0x01, 0x3a, 0xa2, 0x00, 0x01, 0x3a, 0xc7, 0x00, 0x01, 0x3a, 0xec, 0x00,
+    0x01, 0x3b, 0x10, 0x00, 0x01, 0x3b, 0x35, 0x00, 0x01, 0x3b, 0x58, 0x00,
+    0x01, 0x3b, 0x7d, 0x00, 0x01, 0x3b, 0xac, 0x00, 0x01, 0x3b, 0xd3, 0x00,
+    0x01, 0x3b, 0xf9, 0x00, 0x01, 0x3c, 0x26, 0x00, 0x01, 0x3c, 0x4d, 0x00,
+    0x01, 0x3c, 0x74, 0x00, 0x01, 0x3c, 0x97, 0x00, 0x01, 0x3c, 0xb7, 0x00,
+    0x01, 0x3c, 0xde, 0x00, 0x01, 0x3d, 0x05, 0x00, 0x01, 0x3d, 0x2b, 0x00,
+    0x01, 0x3d, 0x54, 0x00, 0x01, 0x3d, 0x78, 0x00, 0x01, 0x3d, 0x9d, 0x00,
+    0x01, 0x3d, 0xc1, 0x00, 0x01, 0x3d, 0xe9, 0x00, 0x01, 0x3e, 0x11, 0x00,
+    0x01, 0x3e, 0x35, 0x00, 0x01, 0x3e, 0x58, 0x00, 0x01, 0x3e, 0x7a, 0x00,
+    0x01, 0x3e, 0xa1, 0x00, 0x01, 0x3e, 0xc4, 0x00, 0x01, 0x3e, 0xe9, 0x00,
+    0x01, 0x3f, 0x0e, 0x00, 0x01, 0x3f, 0x33, 0x00, 0x01, 0x3f, 0x57, 0x00,
+    0x01, 0x3f, 0x7e, 0x00, 0x01, 0x3f, 0xa8, 0x00, 0x01, 0x3f, 0xd2, 0x00,
+    0x01, 0x3f, 0xf4, 0x00, 0x01, 0x40, 0x1d, 0x00, 0x01, 0x40, 0x47, 0x00,
+    0x01, 0x40, 0x6d, 0x00, 0x01, 0x40, 0x90, 0x00, 0x01, 0x40, 0xb6, 0x00,
+    0x01, 0x40, 0xdc, 0x00, 0x01, 0x41, 0x01, 0x00, 0x01, 0x41, 0x2c, 0x00,
+    0x01, 0x41, 0x53, 0x00, 0x01, 0x41, 0x7a, 0x00, 0x01, 0x41, 0xa3, 0x00,
+    0x01, 0x41, 0xc8, 0x00, 0x01, 0x41, 0xea, 0x00, 0x01, 0x42, 0x0e, 0x00,
+    0x01, 0x42, 0x3d, 0x00, 0x01, 0x42, 0x64, 0x00, 0x01, 0x42, 0x8b, 0x00,
+    0x01, 0x42, 0xaf, 0x00, 0x01, 0x42, 0xda, 0x00, 0x01, 0x43, 0x08, 0x00,
+    0x01, 0x43, 0x31, 0x00, 0x01, 0x43, 0x56, 0x00, 0x01, 0x43, 0x7b, 0x00,
+    0x01, 0x43, 0xa3, 0x00, 0x01, 0x43, 0xc3, 0x00, 0x01, 0x43, 0xeb, 0x00,
+    0x01, 0x44, 0x15, 0x00, 0x01, 0x44, 0x3a, 0x00, 0x01, 0x44, 0x5e, 0x00,
+    0x01, 0x44, 0x81, 0x00, 0x01, 0x44, 0xad, 0x00, 0x01, 0x44, 0xd0, 0x00,
+    0x01, 0x44, 0xf4, 0x00, 0x01, 0x45, 0x18, 0x00, 0x01, 0x45, 0x3b, 0x00,
+    0x01, 0x45, 0x5f, 0x00, 0x01, 0x45, 0x8c, 0x00, 0x01, 0x45, 0xaf, 0x00,
+    0x01, 0x45, 0xd4, 0x00, 0x01, 0x45, 0xf7, 0x00, 0x01, 0x46, 0x1e, 0x00,
+    0x01, 0x46, 0x43, 0x00, 0x01, 0x46, 0x6d, 0x00, 0x01, 0x46, 0x92, 0x00,
+    0x01, 0x46, 0xb8, 0x00, 0x01, 0x46, 0xd8, 0x00, 0x01, 0x47, 0x01, 0x00,
+    0x01, 0x47, 0x21, 0x00, 0x01, 0x47, 0x47, 0x00, 0x01, 0x47, 0x6a, 0x00,
+    0x01, 0x47, 0x90, 0x00, 0x01, 0x47, 0xbd, 0x00, 0x01, 0x47, 0xe2, 0x00,
+    0x01, 0x48, 0x09, 0x00, 0x01, 0x48, 0x30, 0x00, 0x01, 0x48, 0x51, 0x00,
+    0x01, 0x48, 0x77, 0x00, 0x01, 0x48, 0x99, 0x00, 0x01, 0x48, 0xc0, 0x00,
+    0x01, 0x48, 0xe7, 0x00, 0x01, 0x49, 0x0c, 0x00, 0x01, 0x49, 0x33, 0x00,
+    0x01, 0x49, 0x56, 0x00, 0x01, 0x49, 0x7a, 0x00, 0x01, 0x49, 0x9f, 0x00,
+    0x01, 0x49, 0xc3, 0x00, 0x01, 0x49, 0xe6, 0x00, 0x01, 0x4a, 0x0a, 0x00,
+    0x01, 0x4a, 0x2f, 0x00, 0x01, 0x4a, 0x51, 0x00, 0x01, 0x4a, 0x73, 0x00,
+    0x01, 0x4a, 0x99, 0x00, 0x01, 0x4a, 0xc5, 0x00, 0x01, 0x4a, 0xe7, 0x00,
+    0x01, 0x4b, 0x10, 0x00, 0x01, 0x4b, 0x3a, 0x00, 0x01, 0x4b, 0x63, 0x00,
+    0x01, 0x4b, 0x87, 0x00, 0x01, 0x4b, 0xab, 0x00, 0x01, 0x4b, 0xd0, 0x00,
+    0x01, 0x4b, 0xfa, 0x00, 0x01, 0x4c, 0x25, 0x00, 0x01, 0x4c, 0x4b, 0x00,
+    0x01, 0x4c, 0x76, 0x00, 0x01, 0x4c, 0x9e, 0x00, 0x01, 0x4c, 0xc3, 0x00,
+    0x01, 0x4c, 0xe6, 0x00, 0x01, 0x4d, 0x0b, 0x00, 0x01, 0x4d, 0x36, 0x00,
+    0x01, 0x4d, 0x59, 0x00, 0x01, 0x4d, 0x7d, 0x00, 0x01, 0x4d, 0xa2, 0x00,
+    0x01, 0x4d, 0xca, 0x00, 0x01, 0x4d, 0xf1, 0x00, 0x01, 0x4e, 0x15, 0x00,
+    0x01, 0x4e, 0x40, 0x00, 0x01, 0x4e, 0x64, 0x00, 0x01, 0x4e, 0x89, 0x00,
+    0x01, 0x4e, 0xb0, 0x00, 0x01, 0x4e, 0xdc, 0x00, 0x01, 0x4f, 0x05, 0x00,
+    0x01, 0x4f, 0x31, 0x00, 0x01, 0x4f, 0x56, 0x00, 0x01, 0x4f, 0x7d, 0x00,
+    0x01, 0x4f, 0xa2, 0x00, 0x01, 0x4f, 0xcb, 0x00, 0x01, 0x4f, 0xf1, 0x00,
+    0x01, 0x50, 0x1a, 0x00, 0x01, 0x50, 0x3a, 0x00, 0x01, 0x50, 0x5d, 0x00,
+    0x01, 0x50, 0x7f, 0x00, 0x01, 0x50, 0xab, 0x00, 0x01, 0x50, 0xd2, 0x00,
+    0x01, 0x50, 0xfc, 0x00, 0x01, 0x51, 0x24, 0x00, 0x01, 0x51, 0x4a, 0x00,
+    0x01, 0x51, 0x6e, 0x00, 0x01, 0x51, 0x98, 0x00, 0x01, 0x51, 0xc0, 0x00,
+    0x01, 0x51, 0xe5, 0x00, 0x01, 0x52, 0x0c, 0x00, 0x01, 0x52, 0x32, 0x00,
+    0x01, 0x52, 0x5b, 0x00, 0x01, 0x52, 0x80, 0x00, 0x01, 0x52, 0xa7, 0x00,
+    0x01, 0x52, 0xd0, 0x00, 0x01, 0x52, 0xf5, 0x00, 0x01, 0x53, 0x20, 0x00,
+    0x01, 0x53, 0x45, 0x00, 0x01, 0x53, 0x6c, 0x00, 0x01, 0x53, 0x92, 0x00,
+    0x01, 0x53, 0xba, 0x00, 0x01, 0x53, 0xe4, 0x00, 0x01, 0x54, 0x0c, 0x00,
+    0x01, 0x54, 0x36, 0x00, 0x01, 0x54, 0x56, 0x00, 0x01, 0x54, 0x7d, 0x00,
+    0x01, 0x54, 0xa1, 0x00, 0x01, 0x54, 0xca, 0x00, 0x01, 0x54, 0xee, 0x00,
+    0x01, 0x55, 0x21, 0x00, 0x01, 0x55, 0x48, 0x00, 0x01, 0x55, 0x73, 0x00,
+    0x01, 0x55, 0x9c, 0x00, 0x01, 0x55, 0xc0, 0x00, 0x01, 0x55, 0xe4, 0x00,
+    0x01, 0x56, 0x0b, 0x00, 0x01, 0x56, 0x37, 0x00, 0x01, 0x56, 0x5a, 0x00,
+    0x01, 0x56, 0x7f, 0x00, 0x01, 0x56, 0xa9, 0x00, 0x01, 0x56, 0xcf, 0x00,
+    0x01, 0x56, 0xf7, 0x00, 0x01, 0x57, 0x1c, 0x00, 0x01, 0x57, 0x42, 0x00,
+    0x01, 0x57, 0x64, 0x00, 0x01, 0x57, 0x8a, 0x00, 0x01, 0x57, 0xae, 0x00,
+    0x01, 0x57, 0xd5, 0x00, 0x01, 0x57, 0xf6, 0x00, 0x01, 0x58, 0x1e, 0x00,
+    0x01, 0x58, 0x4b, 0x00, 0x01, 0x58, 0x6c, 0x00, 0x01, 0x58, 0x95, 0x00,
+    0x01, 0x58, 0xc0, 0x00, 0x01, 0x58, 0xea, 0x00, 0x01, 0x59, 0x13, 0x00,
+    0x01, 0x59, 0x3b, 0x00, 0x01, 0x59, 0x60, 0x00, 0x01, 0x59, 0x86, 0x00,
+    0x01, 0x59, 0xac, 0x00, 0x01, 0x59, 0xd2, 0x00, 0x01, 0x59, 0xfb, 0x00,
+    0x01, 0x5a, 0x20, 0x00, 0x01, 0x5a, 0x43, 0x00, 0x01, 0x5a, 0x6b, 0x00,
+    0x01, 0x5a, 0x90, 0x00, 0x01, 0x5a, 0xb6, 0x00, 0x01, 0x5a, 0xde, 0x00,
+    0x01, 0x5b, 0x00, 0x00, 0x01, 0x5b, 0x27, 0x00, 0x01, 0x5b, 0x4b, 0x00,
+    0x01, 0x5b, 0x72, 0x00, 0x01, 0x5b, 0x9e, 0x00, 0x01, 0x5b, 0xc2, 0x00,
+    0x01, 0x5b, 0xe9, 0x00, 0x01, 0x5c, 0x16, 0x00, 0x01, 0x5c, 0x38, 0x00,
+    0x01, 0x5c, 0x5d, 0x00, 0x01, 0x5c, 0x88, 0x00, 0x01, 0x5c, 0xb2, 0x00,
+    0x01, 0x5c, 0xdb, 0x00, 0x01, 0x5d, 0x04, 0x00, 0x01, 0x5d, 0x2c, 0x00,
+    0x01, 0x5d, 0x52, 0x00, 0x01, 0x5d, 0x77, 0x00, 0x01, 0x5d, 0x9c, 0x00,
+    0x01, 0x5d, 0xc0, 0x00, 0x01, 0x5d, 0xea, 0x00, 0x01, 0x5e, 0x0b, 0x00,
+    0x01, 0x5e, 0x31, 0x00, 0x01, 0x5e, 0x53, 0x00, 0x01, 0x5e, 0x75, 0x00,
+    0x01, 0x5e, 0x9a, 0x00, 0x01, 0x5e, 0xc2, 0x00, 0x01, 0x5e, 0xe3, 0x00,
+    0x01, 0x5f, 0x0a, 0x00, 0x01, 0x5f, 0x31, 0x00, 0x01, 0x5f, 0x58, 0x00,
+    0x01, 0x5f, 0x86, 0x00, 0x01, 0x5f, 0xa5, 0x00, 0x01, 0x5f, 0xc9, 0x00,
+    0x01, 0x5f, 0xe9, 0x00, 0x01, 0x60, 0x19, 0x00, 0x01, 0x60, 0x3e, 0x00,
+    0x01, 0x60, 0x63, 0x00, 0x01, 0x60, 0x8c, 0x00, 0x01, 0x60, 0xb0, 0x00,
+    0x01, 0x60, 0xdb, 0x00, 0x01, 0x60, 0xfc, 0x00, 0x01, 0x61, 0x28, 0x00,
+    0x01, 0x61, 0x4d, 0x00, 0x01, 0x61, 0x73, 0x00, 0x01, 0x61, 0x96, 0x00,
+    0x01, 0x61, 0xbd, 0x00, 0x01, 0x61, 0xde, 0x00, 0x01, 0x62, 0x0c, 0x00,
+    0x01, 0x62, 0x30, 0x00, 0x01, 0x62, 0x51, 0x00, 0x01, 0x62, 0x79, 0x00,
+    0x01, 0x62, 0x9e, 0x00, 0x01, 0x62, 0xc5, 0x00, 0x01, 0x62, 0xeb, 0x00,
+    0x01, 0x63, 0x0c, 0x00, 0x01, 0x63, 0x34, 0x00, 0x01, 0x63, 0x58, 0x00,
+    0x01, 0x63, 0x7d, 0x00, 0x01, 0x63, 0xa1, 0x00, 0x01, 0x63, 0xcd, 0x00,
+    0x01, 0x63, 0xf5, 0x00, 0x01, 0x64, 0x1e, 0x00, 0x01, 0x64, 0x41, 0x00,
+    0x01, 0x64, 0x6a, 0x00, 0x01, 0x64, 0x90, 0x00, 0x01, 0x64, 0xb3, 0x00,
+    0x01, 0x64, 0xda, 0x00, 0x01, 0x64, 0xff, 0x00, 0x01, 0x65, 0x23, 0x00,
+    0x01, 0x65, 0x48, 0x00, 0x01, 0x65, 0x6b, 0x00, 0x01, 0x65, 0x8f, 0x00,
+    0x01, 0x65, 0xb2, 0x00, 0x01, 0x65, 0xd6, 0x00, 0x01, 0x65, 0xfd, 0x00,
+    0x01, 0x66, 0x20, 0x00, 0x01, 0x66, 0x4b, 0x00, 0x01, 0x66, 0x72, 0x00,
+    0x01, 0x66, 0x9a, 0x00, 0x01, 0x66, 0xc1, 0x00, 0x01, 0x66, 0xe8, 0x00,
+    0x01, 0x67, 0x12, 0x00, 0x01, 0x67, 0x36, 0x00, 0x01, 0x67, 0x5a, 0x00,
+    0x01, 0x67, 0x81, 0x00, 0x01, 0x67, 0xa4, 0x00, 0x01, 0x67, 0xc6, 0x00,
+    0x01, 0x67, 0xed, 0x00, 0x01, 0x68, 0x13, 0x00, 0x01, 0x68, 0x39, 0x00,
+    0x01, 0x68, 0x5b, 0x00, 0x01, 0x68, 0x85, 0x00, 0x01, 0x68, 0xab, 0x00,
+    0x01, 0x68, 0xd4, 0x00, 0x01, 0x68, 0xf9, 0x00, 0x01, 0x69, 0x1f, 0x00,
+    0x01, 0x69, 0x47, 0x00, 0x01, 0x69, 0x6c, 0x00, 0x01, 0x69, 0x90, 0x00,
+    0x01, 0x69, 0xb6, 0x00, 0x01, 0x69, 0xda, 0x00, 0x01, 0x6a, 0x05, 0x00,
+    0x01, 0x6a, 0x2a, 0x00, 0x01, 0x6a, 0x53, 0x00, 0x01, 0x6a, 0x78, 0x00,
+    0x01, 0x6a, 0xa1, 0x00, 0x01, 0x6a, 0xce, 0x00, 0x01, 0x6a, 0xf6, 0x00,
+    0x01, 0x6b, 0x1d, 0x00, 0x01, 0x6b, 0x44, 0x00, 0x01, 0x6b, 0x6d, 0x00,
+    0x01, 0x6b, 0x94, 0x00, 0x01, 0x6b, 0xb7, 0x00, 0x01, 0x6b, 0xdd, 0x00,
+    0x01, 0x6c, 0x01, 0x00, 0x01, 0x6c, 0x24, 0x00, 0x01, 0x6c, 0x4a, 0x00,
+    0x01, 0x6c, 0x75, 0x00, 0x01, 0x6c, 0x9b, 0x00, 0x01, 0x6c, 0xbe, 0x00,
+    0x01, 0x6c, 0xe4, 0x00, 0x01, 0x6d, 0x04, 0x00, 0x01, 0x6d, 0x2b, 0x00,
+    0x01, 0x6d, 0x4f, 0x00, 0x01, 0x6d, 0x71, 0x00, 0x01, 0x6d, 0x90, 0x00,
+    0x01, 0x6d, 0xb4, 0x00, 0x01, 0x6d, 0xd9, 0x00, 0x01, 0x6d, 0xfc, 0x00,
+    0x01, 0x6e, 0x21, 0x00, 0x01, 0x6e, 0x47, 0x00, 0x01, 0x6e, 0x70, 0x00,
+    0x01, 0x6e, 0x9b, 0x00, 0x01, 0x6e, 0xc2, 0x00, 0x01, 0x6e, 0xea, 0x00,
+    0x01, 0x6f, 0x13, 0x00, 0x01, 0x6f, 0x3f, 0x00, 0x01, 0x6f, 0x61, 0x00,
+    0x01, 0x6f, 0x85, 0x00, 0x01, 0x6f, 0xaa, 0x00, 0x01, 0x6f, 0xca, 0x00,
+    0x01, 0x6f, 0xf0, 0x00, 0x01, 0x70, 0x1a, 0x00, 0x01, 0x70, 0x40, 0x00,
+    0x01, 0x70, 0x67, 0x00, 0x01, 0x70, 0x8a, 0x00, 0x01, 0x70, 0xae, 0x00,
+    0x01, 0x70, 0xce, 0x00, 0x01, 0x70, 0xf5, 0x00, 0x01, 0x71, 0x1b, 0x00,
+    0x01, 0x71, 0x3e, 0x00, 0x01, 0x71, 0x62, 0x00, 0x01, 0x71, 0x85, 0x00,
+    0x01, 0x71, 0xa9, 0x00, 0x01, 0x71, 0xce, 0x00, 0x01, 0x71, 0xf3, 0x00,
+    0x01, 0x72, 0x1d, 0x00, 0x01, 0x72, 0x41, 0x00, 0x01, 0x72, 0x65, 0x00,
+    0x01, 0x72, 0x8f, 0x00, 0x01, 0x72, 0xb3, 0x00, 0x01, 0x72, 0xd7, 0x00,
+    0x01, 0x72, 0xfa, 0x00, 0x01, 0x73, 0x19, 0x00, 0x01, 0x73, 0x38, 0x00,
+    0x01, 0x73, 0x5a, 0x00, 0x01, 0x73, 0x80, 0x00, 0x01, 0x73, 0xa5, 0x00,
+    0x01, 0x73, 0xcb, 0x00, 0x01, 0x73, 0xf0, 0x00, 0x01, 0x74, 0x19, 0x00,
+    0x01, 0x74, 0x3a, 0x00, 0x01, 0x74, 0x66, 0x00, 0x01, 0x74, 0x90, 0x00,
+    0x01, 0x74, 0xb4, 0x00, 0x01, 0x74, 0xd9, 0x00, 0x01, 0x74, 0xfd, 0x00,
+    0x01, 0x75, 0x26, 0x00, 0x01, 0x75, 0x4d, 0x00, 0x01, 0x75, 0x70, 0x00,
+    0x01, 0x75, 0x94, 0x00, 0x01, 0x75, 0xb7, 0x00, 0x01, 0x75, 0xdd, 0x00,
+    0x01, 0x76, 0x03, 0x00, 0x01, 0x76, 0x28, 0x00, 0x01, 0x76, 0x4e, 0x00,
+    0x01, 0x76, 0x74, 0x00, 0x01, 0x76, 0x9b, 0x00, 0x01, 0x76, 0xbe, 0x00,
+    0x01, 0x76, 0xe3, 0x00, 0x01, 0x77, 0x07, 0x00, 0x01, 0x77, 0x30, 0x00,
+    0x01, 0x77, 0x58, 0x00, 0x01, 0x77, 0x7c, 0x00, 0x01, 0x77, 0x9d, 0x00,
+    0x01, 0x77, 0xc2, 0x00, 0x01, 0x77, 0xe6, 0x00, 0x01, 0x78, 0x0c, 0x00,
+    0x01, 0x78, 0x30, 0x00, 0x01, 0x78, 0x61, 0x00, 0x01, 0x78, 0x86, 0x00,
+    0x01, 0x78, 0xae, 0x00, 0x01, 0x78, 0xda, 0x00, 0x01, 0x78, 0xff, 0x00,
+    0x01, 0x79, 0x22, 0x00, 0x01, 0x79, 0x4d, 0x00, 0x01, 0x79, 0x70, 0x00,
+    0x01, 0x79, 0x95, 0x00, 0x01, 0x79, 0xbd, 0x00, 0x01, 0x79, 0xe3, 0x00,
+    0x01, 0x7a, 0x0a, 0x00, 0x01, 0x7a, 0x2f, 0x00, 0x01, 0x7a, 0x53, 0x00,
+    0x01, 0x7a, 0x76, 0x00, 0x01, 0x7a, 0x9d, 0x00, 0x01, 0x7a, 0xc1, 0x00,
+    0x01, 0x7a, 0xe8, 0x00, 0x01, 0x7b, 0x0b, 0x00, 0x01, 0x7b, 0x31, 0x00,
+    0x01, 0x7b, 0x56, 0x00, 0x01, 0x7b, 0x78, 0x00, 0x01, 0x7b, 0x9f, 0x00,
+    0x01, 0x7b, 0xcb, 0x00, 0x01, 0x7b, 0xf1, 0x00, 0x01, 0x7c, 0x14, 0x00,
+    0x01, 0x7c, 0x37, 0x00, 0x01, 0x7c, 0x5c, 0x00, 0x01, 0x7c, 0x85, 0x00,
+    0x01, 0x7c, 0xb0, 0x00, 0x01, 0x7c, 0xd7, 0x00, 0x01, 0x7d, 0x01, 0x00,
+    0x01, 0x7d, 0x29, 0x00, 0x01, 0x7d, 0x53, 0x00, 0x01, 0x7d, 0x79, 0x00,
+    0x01, 0x7d, 0xa0, 0x00, 0x01, 0x7d, 0xcc, 0x00, 0x01, 0x7d, 0xf4, 0x00,
+    0x01, 0x7e, 0x19, 0x00, 0x01, 0x7e, 0x40, 0x00, 0x01, 0x7e, 0x62, 0x00,
+    0x01, 0x7e, 0x8a, 0x00, 0x01, 0x7e, 0xb1, 0x00, 0x01, 0x7e, 0xd8, 0x00,
+    0x01, 0x7e, 0xfd, 0x00, 0x01, 0x7f, 0x23, 0x00, 0x01, 0x7f, 0x4a, 0x00,
+    0x01, 0x7f, 0x6d, 0x00, 0x01, 0x7f, 0x96, 0x00, 0x01, 0x7f, 0xbe, 0x00,
+    0x01, 0x7f, 0xe3, 0x00, 0x01, 0x80, 0x0c, 0x00, 0x01, 0x80, 0x31, 0x00,
+    0x01, 0x80, 0x51, 0x00, 0x01, 0x80, 0x74, 0x00, 0x01, 0x80, 0x9c, 0x00,
+    0x01, 0x80, 0xc1, 0x00, 0x01, 0x80, 0xe6, 0x00, 0x01, 0x81, 0x09, 0x00,
+    0x01, 0x81, 0x2d, 0x00, 0x01, 0x81, 0x5a, 0x00, 0x01, 0x81, 0x7c, 0x00,
+    0x01, 0x81, 0x9e, 0x00, 0x01, 0x81, 0xbe, 0x00, 0x01, 0x81, 0xdf, 0x00,
+    0x01, 0x82, 0x06, 0x00, 0x01, 0x82, 0x2a, 0x00, 0x01, 0x82, 0x4e, 0x00,
+    0x01, 0x82, 0x7c, 0x00, 0x01, 0x82, 0xa1, 0x00, 0x01, 0x82, 0xc7, 0x00,
+    0x01, 0x82, 0xee, 0x00, 0x01, 0x83, 0x15, 0x00, 0x01, 0x83, 0x39, 0x00,
+    0x01, 0x83, 0x5f, 0x00, 0x01, 0x83, 0x82, 0x00, 0x01, 0x83, 0xa9, 0x00,
+    0x01, 0x83, 0xcc, 0x00, 0x01, 0x83, 0xf0, 0x00, 0x01, 0x84, 0x17, 0x00,
+    0x01, 0x84, 0x3f, 0x00, 0x01, 0x84, 0x6b, 0x00, 0x01, 0x84, 0x95, 0x00,
+    0x01, 0x84, 0xb9, 0x00, 0x01, 0x84, 0xdf, 0x00, 0x01, 0x85, 0x08, 0x00,
+    0x01, 0x85, 0x30, 0x00, 0x01, 0x85, 0x59, 0x00, 0x01, 0x85, 0x7e, 0x00,
+    0x01, 0x85, 0xa6, 0x00, 0x01, 0x85, 0xce, 0x00, 0x01, 0x85, 0xf3, 0x00,
+    0x01, 0x86, 0x1c, 0x00, 0x01, 0x86, 0x43, 0x00, 0x01, 0x86, 0x66, 0x00,
+    0x01, 0x86, 0x8a, 0x00, 0x01, 0x86, 0xb0, 0x00, 0x01, 0x86, 0xd6, 0x00,
+    0x01, 0x86, 0xfc, 0x00, 0x01, 0x87, 0x25, 0x00, 0x01, 0x87, 0x4b, 0x00,
+    0x01, 0x87, 0x72, 0x00, 0x01, 0x87, 0x98, 0x00, 0x01, 0x87, 0xc3, 0x00,
+    0x01, 0x87, 0xea, 0x00, 0x01, 0x88, 0x0f, 0x00, 0x01, 0x88, 0x39, 0x00,
+    0x01, 0x88, 0x5e, 0x00, 0x01, 0x88, 0x82, 0x00, 0x01, 0x88, 0xa8, 0x00,
+    0x01, 0x88, 0xc9, 0x00, 0x01, 0x88, 0xee, 0x00, 0x01, 0x89, 0x16, 0x00,
+    0x01, 0x89, 0x3c, 0x00, 0x01, 0x89, 0x5f, 0x00, 0x01, 0x89, 0x83, 0x00,
+    0x01, 0x89, 0xaa, 0x00, 0x01, 0x89, 0xcf, 0x00, 0x01, 0x89, 0xf5, 0x00,
+    0x01, 0x8a, 0x1d, 0x00, 0x01, 0x8a, 0x44, 0x00, 0x01, 0x8a, 0x6a, 0x00,
+    0x01, 0x8a, 0x8e, 0x00, 0x01, 0x8a, 0xb5, 0x00, 0x01, 0x8a, 0xd7, 0x00,
+    0x01, 0x8a, 0xfb, 0x00, 0x01, 0x8b, 0x1c, 0x00, 0x01, 0x8b, 0x3f, 0x00,
+    0x01, 0x8b, 0x5f, 0x00, 0x01, 0x8b, 0x86, 0x00, 0x01, 0x8b, 0xaa, 0x00,
+    0x01, 0x8b, 0xd3, 0x00, 0x01, 0x8b, 0xfe, 0x00, 0x01, 0x8c, 0x20, 0x00,
+    0x01, 0x8c, 0x40, 0x00, 0x01, 0x8c, 0x6a, 0x00, 0x01, 0x8c, 0x8c, 0x00,
+    0x01, 0x8c, 0xad, 0x00, 0x01, 0x8c, 0xd1, 0x00, 0x01, 0x8c, 0xfa, 0x00,
+    0x01, 0x8d, 0x22, 0x00, 0x01, 0x8d, 0x48, 0x00, 0x01, 0x8d, 0x6a, 0x00,
+    0x01, 0x8d, 0x8c, 0x00, 0x01, 0x8d, 0xae, 0x00, 0x01, 0x8d, 0xd6, 0x00,
+    0x01, 0x8d, 0xf9, 0x00, 0x01, 0x8e, 0x21, 0x00, 0x01, 0x8e, 0x44, 0x00,
+    0x01, 0x8e, 0x65, 0x00, 0x01, 0x8e, 0x8a, 0x00, 0x01, 0x8e, 0xae, 0x00,
+    0x01, 0x8e, 0xd4, 0x00, 0x01, 0x8e, 0xf5, 0x00, 0x01, 0x8f, 0x1d, 0x00,
+    0x01, 0x8f, 0x40, 0x00, 0x01, 0x8f, 0x65, 0x00, 0x01, 0x8f, 0x8b, 0x00,
+    0x01, 0x8f, 0xae, 0x00, 0x01, 0x8f, 0xd6, 0x00, 0x01, 0x8f, 0xfb, 0x00,
+    0x01, 0x90, 0x1e, 0x00, 0x01, 0x90, 0x41, 0x00, 0x01, 0x90, 0x68, 0x00,
+    0x01, 0x90, 0x8e, 0x00, 0x01, 0x90, 0xb2, 0x00, 0x01, 0x90, 0xd5, 0x00,
+    0x01, 0x90, 0xf8, 0x00, 0x01, 0x91, 0x21, 0x00, 0x01, 0x91, 0x4c, 0x00,
+    0x01, 0x91, 0x6e, 0x00, 0x01, 0x91, 0x95, 0x00, 0x01, 0x91, 0xc2, 0x00,
+    0x01, 0x91, 0xf0, 0x00, 0x01, 0x92, 0x17, 0x00, 0x01, 0x92, 0x3f, 0x00,
+    0x01, 0x92, 0x64, 0x00, 0x01, 0x92, 0x8c, 0x00, 0x01, 0x92, 0xb6, 0x00,
+    0x01, 0x92, 0xda, 0x00, 0x01, 0x93, 0x02, 0x00, 0x01, 0x93, 0x26, 0x00,
+    0x01, 0x93, 0x4f, 0x00, 0x01, 0x93, 0x76, 0x00, 0x01, 0x93, 0x98, 0x00,
+    0x01, 0x93, 0xbf, 0x00, 0x01, 0x93, 0xe4, 0x00, 0x01, 0x94, 0x0c, 0x00,
+    0x01, 0x94, 0x34, 0x00, 0x01, 0x94, 0x5d, 0x00, 0x01, 0x94, 0x83, 0x00,
+    0x01, 0x94, 0xac, 0x00, 0x01, 0x94, 0xd4, 0x00, 0x01, 0x94, 0xfb, 0x00,
+    0x01, 0x95, 0x21, 0x00, 0x01, 0x95, 0x45, 0x00, 0x01, 0x95, 0x69, 0x00,
+    0x01, 0x95, 0x90, 0x00, 0x01, 0x95, 0xba, 0x00, 0x01, 0x95, 0xde, 0x00,
+    0x01, 0x96, 0x03, 0x00, 0x01, 0x96, 0x2a, 0x00, 0x01, 0x96, 0x4d, 0x00,
+    0x01, 0x96, 0x70, 0x00, 0x01, 0x96, 0x96, 0x00, 0x01, 0x96, 0xbc, 0x00,
+    0x01, 0x96, 0xdf, 0x00, 0x01, 0x97, 0x09, 0x00, 0x01, 0x97, 0x2c, 0x00,
+    0x01, 0x97, 0x50, 0x00, 0x01, 0x97, 0x73, 0x00, 0x01, 0x97, 0x9b, 0x00,
+    0x01, 0x97, 0xc0, 0x00, 0x01, 0x97, 0xe9, 0x00, 0x01, 0x98, 0x10, 0x00,
+    0x01, 0x98, 0x35, 0x00, 0x01, 0x98, 0x5f, 0x00, 0x01, 0x98, 0x88, 0x00,
+    0x01, 0x98, 0xaf, 0x00, 0x01, 0x98, 0xd5, 0x00, 0x01, 0x98, 0xfa, 0x00,
+    0x01, 0x99, 0x1e, 0x00, 0x01, 0x99, 0x40, 0x00, 0x01, 0x99, 0x68, 0x00,
+    0x01, 0x99, 0x8c, 0x00, 0x01, 0x99, 0xb0, 0x00, 0x01, 0x99, 0xd3, 0x00,
+    0x01, 0x99, 0xf7, 0x00, 0x01, 0x9a, 0x1a, 0x00, 0x01, 0x9a, 0x41, 0x00,
+    0x01, 0x9a, 0x61, 0x00, 0x01, 0x9a, 0x84, 0x00, 0x01, 0x9a, 0xab, 0x00,
+    0x01, 0x9a, 0xcd, 0x00, 0x01, 0x9a, 0xf7, 0x00, 0x01, 0x9b, 0x20, 0x00,
+    0x01, 0x9b, 0x47, 0x00, 0x01, 0x9b, 0x6a, 0x00, 0x01, 0x9b, 0x92, 0x00,
+    0x01, 0x9b, 0xb1, 0x00, 0x01, 0x9b, 0xda, 0x00, 0x01, 0x9c, 0x03, 0x00,
+    0x01, 0x9c, 0x29, 0x00, 0x01, 0x9c, 0x4b, 0x00, 0x01, 0x9c, 0x72, 0x00,
+    0x01, 0x9c, 0x9c, 0x00, 0x01, 0x9c, 0xbf, 0x00, 0x01, 0x9c, 0xe6, 0x00,
+    0x01, 0x9d, 0x12, 0x00, 0x01, 0x9d, 0x3b, 0x00, 0x01, 0x9d, 0x62, 0x00,
+    0x01, 0x9d, 0x8e, 0x00, 0x01, 0x9d, 0xb6, 0x00, 0x01, 0x9d, 0xd8, 0x00,
+    0x01, 0x9d, 0xfd, 0x00, 0x01, 0x9e, 0x21, 0x00, 0x01, 0x9e, 0x49, 0x00,
+    0x01, 0x9e, 0x74, 0x00, 0x01, 0x9e, 0x98, 0x00, 0x01, 0x9e, 0xc0, 0x00,
+    0x01, 0x9e, 0xe5, 0x00, 0x01, 0x9f, 0x09, 0x00, 0x01, 0x9f, 0x2e, 0x00,
+    0x01, 0x9f, 0x57, 0x00, 0x01, 0x9f, 0x7c, 0x00, 0x01, 0x9f, 0x9f, 0x00,
+    0x01, 0x9f, 0xc2, 0x00, 0x01, 0x9f, 0xe9, 0x00, 0x01, 0xa0, 0x10, 0x00,
+    0x01, 0xa0, 0x34, 0x00, 0x01, 0xa0, 0x57, 0x00, 0x01, 0xa0, 0x81, 0x00,
+    0x01, 0xa0, 0xa5, 0x00, 0x01, 0xa0, 0xcf, 0x00, 0x01, 0xa0, 0xfb, 0x00,
+    0x01, 0xa1, 0x22, 0x00, 0x01, 0xa1, 0x49, 0x00, 0x01, 0xa1, 0x70, 0x00,
+    0x01, 0xa1, 0x92, 0x00, 0x01, 0xa1, 0xba, 0x00, 0x01, 0xa1, 0xe7, 0x00,
+    0x01, 0xa2, 0x0a, 0x00, 0x01, 0xa2, 0x32, 0x00, 0x01, 0xa2, 0x56, 0x00,
+    0x01, 0xa2, 0x7c, 0x00, 0x01, 0xa2, 0x9d, 0x00, 0x01, 0xa2, 0xc7, 0x00,
+    0x01, 0xa2, 0xea, 0x00, 0x01, 0xa3, 0x10, 0x00, 0x01, 0xa3, 0x33, 0x00,
+    0x01, 0xa3, 0x59, 0x00, 0x01, 0xa3, 0x7c, 0x00, 0x01, 0xa3, 0xa1, 0x00,
+    0x01, 0xa3, 0xce, 0x00, 0x01, 0xa3, 0xf3, 0x00, 0x01, 0xa4, 0x19, 0x00,
+    0x01, 0xa4, 0x3c, 0x00, 0x01, 0xa4, 0x69, 0x00, 0x01, 0xa4, 0x8e, 0x00,
+    0x01, 0xa4, 0xb2, 0x00, 0x01, 0xa4, 0xd5, 0x00, 0x01, 0xa5, 0x04, 0x00,
+    0x01, 0xa5, 0x25, 0x00, 0x01, 0xa5, 0x49, 0x00, 0x01, 0xa5, 0x72, 0x00,
+    0x01, 0xa5, 0x9b, 0x00, 0x01, 0xa5, 0xbe, 0x00, 0x01, 0xa5, 0xe3, 0x00,
+    0x01, 0xa6, 0x11, 0x00, 0x01, 0xa6, 0x37, 0x00, 0x01, 0xa6, 0x60, 0x00,
+    0x01, 0xa6, 0x83, 0x00, 0x01, 0xa6, 0xa7, 0x00, 0x01, 0xa6, 0xd4, 0x00,
+    0x01, 0xa6, 0xf9, 0x00, 0x01, 0xa7, 0x1e, 0x00, 0x01, 0xa7, 0x45, 0x00,
+    0x01, 0xa7, 0x6a, 0x00, 0x01, 0xa7, 0x8e, 0x00, 0x01, 0xa7, 0xb0, 0x00,
+    0x01, 0xa7, 0xd9, 0x00, 0x01, 0xa7, 0xff, 0x00, 0x01, 0xa8, 0x25, 0x00,
+    0x01, 0xa8, 0x4c, 0x00, 0x01, 0xa8, 0x70, 0x00, 0x01, 0xa8, 0x90, 0x00,
+    0x01, 0xa8, 0xb5, 0x00, 0x01, 0xa8, 0xdb, 0x00, 0x01, 0xa8, 0xfe, 0x00,
+    0x01, 0xa9, 0x25, 0x00, 0x01, 0xa9, 0x4e, 0x00, 0x01, 0xa9, 0x72, 0x00,
+    0x01, 0xa9, 0x99, 0x00, 0x01, 0xa9, 0xc3, 0x00, 0x01, 0xa9, 0xe9, 0x00,
+    0x01, 0xaa, 0x11, 0x00, 0x01, 0xaa, 0x39, 0x00, 0x01, 0xaa, 0x5e, 0x00,
+    0x01, 0xaa, 0x84, 0x00, 0x01, 0xaa, 0xab, 0x00, 0x01, 0xaa, 0xce, 0x00,
+    0x01, 0xaa, 0xf1, 0x00, 0x01, 0xab, 0x15, 0x00, 0x01, 0xab, 0x36, 0x00,
+    0x01, 0xab, 0x59, 0x00, 0x01, 0xab, 0x83, 0x00, 0x01, 0xab, 0xa5, 0x00,
+    0x01, 0xab, 0xcb, 0x00, 0x01, 0xab, 0xf8, 0x00, 0x01, 0xac, 0x1d, 0x00,
+    0x01, 0xac, 0x4b, 0x00, 0x01, 0xac, 0x76, 0x00, 0x01, 0xac, 0x9a, 0x00,
+    0x01, 0xac, 0xc5, 0x00, 0x01, 0xac, 0xe8, 0x00, 0x01, 0xad, 0x0b, 0x00,
+    0x01, 0xad, 0x2f, 0x00, 0x01, 0xad, 0x51, 0x00, 0x01, 0xad, 0x79, 0x00,
+    0x01, 0xad, 0x9b, 0x00, 0x01, 0xad, 0xbf, 0x00, 0x01, 0xad, 0xe4, 0x00,
+    0x01, 0xae, 0x0f, 0x00, 0x01, 0xae, 0x3a, 0x00, 0x01, 0xae, 0x62, 0x00,
+    0x01, 0xae, 0x8a, 0x00, 0x01, 0xae, 0xb6, 0x00, 0x01, 0xae, 0xdc, 0x00,
+    0x01, 0xae, 0xfd, 0x00, 0x01, 0xaf, 0x24, 0x00, 0x01, 0xaf, 0x48, 0x00,
+    0x01, 0xaf, 0x6b, 0x00, 0x01, 0xaf, 0x8e, 0x00, 0x01, 0xaf, 0xb5, 0x00,
+    0x01, 0xaf, 0xd8, 0x00, 0x01, 0xaf, 0xfe, 0x00, 0x01, 0xb0, 0x23, 0x00,
+    0x01, 0xb0, 0x45, 0x00, 0x01, 0xb0, 0x6e, 0x00, 0x01, 0xb0, 0x93, 0x00,
+    0x01, 0xb0, 0xbf, 0x00, 0x01, 0xb0, 0xe5, 0x00, 0x01, 0xb1, 0x0d, 0x00,
+    0x01, 0xb1, 0x35, 0x00, 0x01, 0xb1, 0x59, 0x00, 0x01, 0xb1, 0x7e, 0x00,
+    0x01, 0xb1, 0xa2, 0x00, 0x01, 0xb1, 0xc7, 0x00, 0x01, 0xb1, 0xec, 0x00,
+    0x01, 0xb2, 0x11, 0x00, 0x01, 0xb2, 0x36, 0x00, 0x01, 0xb2, 0x5c, 0x00,
+    0x01, 0xb2, 0x81, 0x00, 0x01, 0xb2, 0xa5, 0x00, 0x01, 0xb2, 0xcf, 0x00,
+    0x01, 0xb2, 0xf6, 0x00, 0x01, 0xb3, 0x1f, 0x00, 0x01, 0xb3, 0x49, 0x00,
+    0x01, 0xb3, 0x70, 0x00, 0x01, 0xb3, 0x9a, 0x00, 0x01, 0xb3, 0xbd, 0x00,
+    0x01, 0xb3, 0xe1, 0x00, 0x01, 0xb4, 0x09, 0x00, 0x01, 0xb4, 0x36, 0x00,
+    0x01, 0xb4, 0x5d, 0x00, 0x01, 0xb4, 0x86, 0x00, 0x01, 0xb4, 0xad, 0x00,
+    0x01, 0xb4, 0xcf, 0x00, 0x01, 0xb4, 0xf4, 0x00, 0x01, 0xb5, 0x1f, 0x00,
+    0x01, 0xb5, 0x43, 0x00, 0x01, 0xb5, 0x69, 0x00, 0x01, 0xb5, 0x8e, 0x00,
+    0x01, 0xb5, 0xb3, 0x00, 0x01, 0xb5, 0xdc, 0x00, 0x01, 0xb5, 0xff, 0x00,
+    0x01, 0xb6, 0x27, 0x00, 0x01, 0xb6, 0x4d, 0x00, 0x01, 0xb6, 0x79, 0x00,
+    0x01, 0xb6, 0x9f, 0x00, 0x01, 0xb6, 0xc8, 0x00, 0x01, 0xb6, 0xeb, 0x00,
+    0x01, 0xb7, 0x15, 0x00, 0x01, 0xb7, 0x3c, 0x00, 0x01, 0xb7, 0x5f, 0x00,
+    0x01, 0xb7, 0x82, 0x00, 0x01, 0xb7, 0xac, 0x00, 0x01, 0xb7, 0xd3, 0x00,
+    0x01, 0xb7, 0xf8, 0x00, 0x01, 0xb8, 0x1c, 0x00, 0x01, 0xb8, 0x43, 0x00,
+    0x01, 0xb8, 0x66, 0x00, 0x01, 0xb8, 0x8a, 0x00, 0x01, 0xb8, 0xaf, 0x00,
+    0x01, 0xb8, 0xd5, 0x00, 0x01, 0xb8, 0xfb, 0x00, 0x01, 0xb9, 0x20, 0x00,
+    0x01, 0xb9, 0x44, 0x00, 0x01, 0xb9, 0x6b, 0x00, 0x01, 0xb9, 0x93, 0x00,
+    0x01, 0xb9, 0xb8, 0x00, 0x01, 0xb9, 0xdd, 0x00, 0x01, 0xba, 0x02, 0x00,
+    0x01, 0xba, 0x29, 0x00, 0x01, 0xba, 0x4a, 0x00, 0x01, 0xba, 0x72, 0x00,
+    0x01, 0xba, 0x96, 0x00, 0x01, 0xba, 0xbb, 0x00, 0x01, 0xba, 0xe9, 0x00,
+    0x01, 0xbb, 0x0c, 0x00, 0x01, 0xbb, 0x31, 0x00, 0x01, 0xbb, 0x5d, 0x00,
+    0x01, 0xbb, 0x85, 0x00, 0x01, 0xbb, 0xad, 0x00, 0x01, 0xbb, 0xd8, 0x00,
+    0x01, 0xbb, 0xfc, 0x00, 0x01, 0xbc, 0x1e, 0x00, 0x01, 0xbc, 0x45, 0x00,
+    0x01, 0xbc, 0x6f, 0x00, 0x01, 0xbc, 0x99, 0x00, 0x01, 0xbc, 0xbb, 0x00,
+    0x01, 0xbc, 0xdd, 0x00, 0x01, 0xbc, 0xff, 0x00, 0x01, 0xbd, 0x28, 0x00,
+    0x01, 0xbd, 0x56, 0x00, 0x01, 0xbd, 0x7e, 0x00, 0x01, 0xbd, 0x9f, 0x00,
+    0x01, 0xbd, 0xc5, 0x00, 0x01, 0xbd, 0xef, 0x00, 0x01, 0xbe, 0x13, 0x00,
+    0x01, 0xbe, 0x3c, 0x00, 0x01, 0xbe, 0x60, 0x00, 0x01, 0xbe, 0x83, 0x00,
+    0x01, 0xbe, 0xa9, 0x00, 0x01, 0xbe, 0xcc, 0x00, 0x01, 0xbe, 0xef, 0x00,
+    0x01, 0xbf, 0x15, 0x00, 0x01, 0xbf, 0x3a, 0x00, 0x01, 0xbf, 0x61, 0x00,
+    0x01, 0xbf, 0x8d, 0x00, 0x01, 0xbf, 0xb6, 0x00, 0x01, 0xbf, 0xdd, 0x00,
+    0x01, 0xc0, 0x02, 0x00, 0x01, 0xc0, 0x24, 0x00, 0x01, 0xc0, 0x44, 0x00,
+    0x01, 0xc0, 0x6d, 0x00, 0x01, 0xc0, 0x92, 0x00, 0x01, 0xc0, 0xb2, 0x00,
+    0x01, 0xc0, 0xd7, 0x00, 0x01, 0xc1, 0x01, 0x00, 0x01, 0xc1, 0x27, 0x00,
+    0x01, 0xc1, 0x51, 0x00, 0x01, 0xc1, 0x79, 0x00, 0x01, 0xc1, 0x9f, 0x00,
+    0x01, 0xc1, 0xc7, 0x00, 0x01, 0xc1, 0xee, 0x00, 0x01, 0xc2, 0x17, 0x00,
+    0x01, 0xc2, 0x39, 0x00, 0x01, 0xc2, 0x64, 0x00, 0x01, 0xc2, 0x89, 0x00,
+    0x01, 0xc2, 0xb1, 0x00, 0x01, 0xc2, 0xd7, 0x00, 0x01, 0xc2, 0xff, 0x00,
+    0x01, 0xc3, 0x23, 0x00, 0x01, 0xc3, 0x49, 0x00, 0x01, 0xc3, 0x6c, 0x00,
+    0x01, 0xc3, 0x95, 0x00, 0x01, 0xc3, 0xbd, 0x00, 0x01, 0xc3, 0xdd, 0x00,
+    0x01, 0xc4, 0x02, 0x00, 0x01, 0xc4, 0x2d, 0x00, 0x01, 0xc4, 0x4f, 0x00,
+    0x01, 0xc4, 0x77, 0x00, 0x01, 0xc4, 0x9e, 0x00, 0x01, 0xc4, 0xbf, 0x00,
+    0x01, 0xc4, 0xea, 0x00, 0x01, 0xc5, 0x0e, 0x00, 0x01, 0xc5, 0x32, 0x00,
+    0x01, 0xc5, 0x57, 0x00, 0x01, 0xc5, 0x7c, 0x00, 0x01, 0xc5, 0x9d, 0x00,
+    0x01, 0xc5, 0xc6, 0x00, 0x01, 0xc5, 0xed, 0x00, 0x01, 0xc6, 0x15, 0x00,
+    0x01, 0xc6, 0x3c, 0x00, 0x01, 0xc6, 0x5d, 0x00, 0x01, 0xc6, 0x88, 0x00,
+    0x01, 0xc6, 0xab, 0x00, 0x01, 0xc6, 0xd4, 0x00, 0x01, 0xc6, 0xf7, 0x00,
+    0x01, 0xc7, 0x1c, 0x00, 0x01, 0xc7, 0x41, 0x00, 0x01, 0xc7, 0x63, 0x00,
+    0x01, 0xc7, 0x8a, 0x00, 0x01, 0xc7, 0xae, 0x00, 0x01, 0xc7, 0xd6, 0x00,
+    0x01, 0xc7, 0xfb, 0x00, 0x01, 0xc8, 0x20, 0x00, 0x01, 0xc8, 0x4a, 0x00,
+    0x01, 0xc8, 0x6f, 0x00, 0x01, 0xc8, 0x96, 0x00, 0x01, 0xc8, 0xba, 0x00,
+    0x01, 0xc8, 0xe0, 0x00, 0x01, 0xc9, 0x05, 0x00, 0x01, 0xc9, 0x2a, 0x00,
+    0x01, 0xc9, 0x56, 0x00, 0x01, 0xc9, 0x7c, 0x00, 0x01, 0xc9, 0xa3, 0x00,
+    0x01, 0xc9, 0xca, 0x00, 0x01, 0xc9, 0xec, 0x00, 0x01, 0xca, 0x0e, 0x00,
+    0x01, 0xca, 0x32, 0x00, 0x01, 0xca, 0x5e, 0x00, 0x01, 0xca, 0x81, 0x00,
+    0x01, 0xca, 0xa7, 0x00, 0x01, 0xca, 0xcd, 0x00, 0x01, 0xca, 0xf2, 0x00,
+    0x01, 0xcb, 0x15, 0x00, 0x01, 0xcb, 0x3c, 0x00, 0x01, 0xcb, 0x63, 0x00,
+    0x01, 0xcb, 0x85, 0x00, 0x01, 0xcb, 0xa8, 0x00, 0x01, 0xcb, 0xcd, 0x00,
+    0x01, 0xcb, 0xf3, 0x00, 0x01, 0xcc, 0x18, 0x00, 0x01, 0xcc, 0x42, 0x00,
+    0x01, 0xcc, 0x6a, 0x00, 0x01, 0xcc, 0x8c, 0x00, 0x01, 0xcc, 0xac, 0x00,
+    0x01, 0xcc, 0xd1, 0x00, 0x01, 0xcc, 0xf9, 0x00, 0x00, 0x00, 0x24, 0x00,
+    0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0xa0, 0x00,
+    0x00, 0x00, 0xc3, 0x00, 0x00, 0x00, 0xeb, 0x00, 0x00, 0x01, 0x11, 0x00,
+    0x00, 0x01, 0x35, 0x00, 0x00, 0x01, 0x58, 0x00, 0x00, 0x01, 0x87, 0x00,
+    0x00, 0x01, 0xb2, 0x00, 0x00, 0x01, 0xd6, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x24, 0x00, 0x00, 0x02, 0x4e, 0x00, 0x00, 0x02, 0x72, 0x00,
+    0x00, 0x02, 0x9a, 0x00, 0x00, 0x02, 0xc0, 0x00, 0x00, 0x02, 0xe6, 0x00,
+    0x00, 0x03, 0x10, 0x00, 0x00, 0x03, 0x32, 0x00, 0x00, 0x03, 0x5d, 0x00,
+    0x00, 0x03, 0x89, 0x00, 0x00, 0x03, 0xac, 0x00, 0x00, 0x03, 0xcf, 0x00,
+    0x00, 0x03, 0xf3, 0x00, 0x00, 0x04, 0x19, 0x00, 0x00, 0x04, 0x3d, 0x00,
+    0x00, 0x04, 0x62, 0x00, 0x00, 0x04, 0x89, 0x00, 0x00, 0x04, 0xac, 0x00,
+    0x00, 0x04, 0xcf, 0x00, 0x00, 0x04, 0xf2, 0x00, 0x00, 0x05, 0x17, 0x00,
+    0x00, 0x05, 0x44, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x90, 0x00,
+    0x00, 0x05, 0xb6, 0x00, 0x00, 0x05, 0xd8, 0x00, 0x00, 0x05, 0xfd, 0x00,
+    0x00, 0x06, 0x20, 0x00, 0x00, 0x06, 0x47, 0x00, 0x00, 0x06, 0x6b, 0x00,
+    0x00, 0x06, 0x8c, 0x00, 0x00, 0x06, 0xb2, 0x00, 0x00, 0x06, 0xd9, 0x00,
+    0x00, 0x06, 0xfe, 0x00, 0x00, 0x07, 0x20, 0x00, 0x00, 0x07, 0x42, 0x00,
+    0x00, 0x07, 0x64, 0x00, 0x00, 0x07, 0x8c, 0x00, 0x00, 0x07, 0xb2, 0x00,
+    0x00, 0x07, 0xdb, 0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x08, 0x34, 0x00,
+    0x00, 0x08, 0x5c, 0x00, 0x00, 0x08, 0x80, 0x00, 0x00, 0x08, 0xa2, 0x00,
+    0x00, 0x08, 0xce, 0x00, 0x00, 0x08, 0xfc, 0x00, 0x00, 0x09, 0x20, 0x00,
+    0x00, 0x09, 0x48, 0x00, 0x00, 0x09, 0x71, 0x00, 0x00, 0x09, 0x98, 0x00,
+    0x00, 0x09, 0xbc, 0x00, 0x00, 0x09, 0xe0, 0x00, 0x00, 0x0a, 0x07, 0x00,
+    0x00, 0x0a, 0x2b, 0x00, 0x00, 0x0a, 0x53, 0x00, 0x00, 0x0a, 0x77, 0x00,
+    0x00, 0x0a, 0x9c, 0x00, 0x00, 0x0a, 0xc3, 0x00, 0x00, 0x0a, 0xe7, 0x00,
+    0x00, 0x0b, 0x0e, 0x00, 0x00, 0x0b, 0x32, 0x00, 0x00, 0x0b, 0x5b, 0x00,
+    0x00, 0x0b, 0x83, 0x00, 0x00, 0x0b, 0xa5, 0x00, 0x00, 0x0b, 0xc9, 0x00,
+    0x00, 0x0b, 0xee, 0x00, 0x00, 0x0c, 0x13, 0x00, 0x00, 0x0c, 0x37, 0x00,
+    0x00, 0x0c, 0x60, 0x00, 0x00, 0x0c, 0x8a, 0x00, 0x00, 0x0c, 0xb4, 0x00,
+    0x00, 0x0c, 0xda, 0x00, 0x00, 0x0c, 0xfa, 0x00, 0x00, 0x0d, 0x1b, 0x00,
+    0x00, 0x0d, 0x42, 0x00, 0x00, 0x0d, 0x67, 0x00, 0x00, 0x0d, 0x8c, 0x00,
+    0x00, 0x0d, 0xb2, 0x00, 0x00, 0x0d, 0xd7, 0x00, 0x00, 0x0d, 0xfb, 0x00,
+    0x00, 0x0e, 0x1b, 0x00, 0x00, 0x0e, 0x43, 0x00, 0x00, 0x0e, 0x69, 0x00,
+    0x00, 0x0e, 0x93, 0x00, 0x00, 0x0e, 0xbb, 0x00, 0x00, 0x0e, 0xe1, 0x00,
+    0x00, 0x0f, 0x05, 0x00, 0x00, 0x0f, 0x29, 0x00, 0x00, 0x0f, 0x58, 0x00,
+    0x00, 0x0f, 0x7c, 0x00, 0x00, 0x0f, 0xa2, 0x00, 0x00, 0x0f, 0xc6, 0x00,
+    0x00, 0x0f, 0xea, 0x00, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x10, 0x37, 0x00,
+    0x00, 0x10, 0x60, 0x00, 0x00, 0x10, 0x80, 0x00, 0x00, 0x10, 0xa9, 0x00,
+    0x00, 0x10, 0xca, 0x00, 0x00, 0x10, 0xee, 0x00, 0x00, 0x11, 0x19, 0x00,
+    0x00, 0x11, 0x3d, 0x00, 0x00, 0x11, 0x64, 0x00, 0x00, 0x11, 0x89, 0x00,
+    0x00, 0x11, 0xb0, 0x00, 0x00, 0x11, 0xd4, 0x00, 0x00, 0x11, 0xfb, 0x00,
+    0x00, 0x12, 0x1e, 0x00, 0x00, 0x12, 0x43, 0x00, 0x00, 0x12, 0x6f, 0x00,
+    0x00, 0x12, 0x98, 0x00, 0x00, 0x12, 0xba, 0x00, 0x00, 0x12, 0xdd, 0x00,
+    0x00, 0x13, 0x03, 0x00, 0x00, 0x13, 0x2c, 0x00, 0x00, 0x13, 0x57, 0x00,
+    0x00, 0x13, 0x82, 0x00, 0x00, 0x13, 0xa7, 0x00, 0x00, 0x13, 0xcb, 0x00,
+    0x00, 0x13, 0xf0, 0x00, 0x00, 0x14, 0x12, 0x00, 0x00, 0x14, 0x33, 0x00,
+    0x00, 0x14, 0x60, 0x00, 0x00, 0x14, 0x82, 0x00, 0x00, 0x14, 0xa7, 0x00,
+    0x00, 0x14, 0xc8, 0x00, 0x00, 0x14, 0xee, 0x00, 0x00, 0x15, 0x13, 0x00,
+    0x00, 0x15, 0x38, 0x00, 0x00, 0x15, 0x61, 0x00, 0x00, 0x15, 0x88, 0x00,
+    0x00, 0x15, 0xb1, 0x00, 0x00, 0x15, 0xdd, 0x00, 0x00, 0x16, 0x05, 0x00,
+    0x00, 0x16, 0x2a, 0x00, 0x00, 0x16, 0x4a, 0x00, 0x00, 0x16, 0x73, 0x00,
+    0x00, 0x16, 0x98, 0x00, 0x00, 0x16, 0xbe, 0x00, 0x00, 0x16, 0xe5, 0x00,
+    0x00, 0x17, 0x0c, 0x00, 0x00, 0x17, 0x38, 0x00, 0x00, 0x17, 0x5c, 0x00,
+    0x00, 0x17, 0x85, 0x00, 0x00, 0x17, 0xac, 0x00, 0x00, 0x17, 0xd9, 0x00,
+    0x00, 0x18, 0x03, 0x00, 0x00, 0x18, 0x2b, 0x00, 0x00, 0x18, 0x54, 0x00,
+    0x00, 0x18, 0x79, 0x00, 0x00, 0x18, 0xa4, 0x00, 0x00, 0x18, 0xcb, 0x00,
+    0x00, 0x18, 0xf0, 0x00, 0x00, 0x19, 0x15, 0x00, 0x00, 0x19, 0x3f, 0x00,
+    0x00, 0x19, 0x66, 0x00, 0x00, 0x19, 0x8c, 0x00, 0x00, 0x19, 0xb4, 0x00,
+    0x00, 0x19, 0xdc, 0x00, 0x00, 0x19, 0xfe, 0x00, 0x00, 0x1a, 0x2b, 0x00,
+    0x00, 0x1a, 0x50, 0x00, 0x00, 0x1a, 0x75, 0x00, 0x00, 0x1a, 0x98, 0x00,
+    0x00, 0x1a, 0xbd, 0x00, 0x00, 0x1a, 0xdf, 0x00, 0x00, 0x1b, 0x0c, 0x00,
+    0x00, 0x1b, 0x39, 0x00, 0x00, 0x1b, 0x5c, 0x00, 0x00, 0x1b, 0x81, 0x00,
+    0x00, 0x1b, 0xab, 0x00, 0x00, 0x1b, 0xd4, 0x00, 0x00, 0x1b, 0xf9, 0x00,
+    0x00, 0x1c, 0x1d, 0x00, 0x00, 0x1c, 0x40, 0x00, 0x00, 0x1c, 0x64, 0x00,
+    0x00, 0x1c, 0x8e, 0x00, 0x00, 0x1c, 0xb3, 0x00, 0x00, 0x1c, 0xd6, 0x00,
+    0x00, 0x1c, 0xf8, 0x00, 0x00, 0x1d, 0x1f, 0x00, 0x00, 0x1d, 0x44, 0x00,
+    0x00, 0x1d, 0x68, 0x00, 0x00, 0x1d, 0x8a, 0x00, 0x00, 0x1d, 0xaf, 0x00,
+    0x00, 0x1d, 0xd5, 0x00, 0x00, 0x1d, 0xff, 0x00, 0x00, 0x1e, 0x24, 0x00,
+    0x00, 0x1e, 0x4a, 0x00, 0x00, 0x1e, 0x77, 0x00, 0x00, 0x1e, 0xa7, 0x00,
+    0x00, 0x1e, 0xc9, 0x00, 0x00, 0x1e, 0xf0, 0x00, 0x00, 0x1f, 0x15, 0x00,
+    0x00, 0x1f, 0x39, 0x00, 0x00, 0x1f, 0x5f, 0x00, 0x00, 0x1f, 0x85, 0x00,
+    0x00, 0x1f, 0xa9, 0x00, 0x00, 0x1f, 0xca, 0x00, 0x00, 0x1f, 0xe9, 0x00,
+    0x00, 0x20, 0x0f, 0x00, 0x00, 0x20, 0x37, 0x00, 0x00, 0x20, 0x5d, 0x00,
+    0x00, 0x20, 0x83, 0x00, 0x00, 0x20, 0xa5, 0x00, 0x00, 0x20, 0xc5, 0x00,
+    0x00, 0x20, 0xe6, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x31, 0x00,
+    0x00, 0x21, 0x54, 0x00, 0x00, 0x21, 0x78, 0x00, 0x00, 0x21, 0x9c, 0x00,
+    0x00, 0x21, 0xc2, 0x00, 0x00, 0x21, 0xe6, 0x00, 0x00, 0x22, 0x0f, 0x00,
+    0x00, 0x22, 0x31, 0x00, 0x00, 0x22, 0x55, 0x00, 0x00, 0x22, 0x80, 0x00,
+    0x00, 0x22, 0xa7, 0x00, 0x00, 0x22, 0xce, 0x00, 0x00, 0x22, 0xf4, 0x00,
+    0x00, 0x23, 0x1f, 0x00, 0x00, 0x23, 0x43, 0x00, 0x00, 0x23, 0x6c, 0x00,
+    0x00, 0x23, 0xa4, 0x00, 0x00, 0x23, 0xc9, 0x00, 0x00, 0x23, 0xf1, 0x00,
+    0x00, 0x24, 0x12, 0x00, 0x00, 0x24, 0x37, 0x00, 0x00, 0x24, 0x5f, 0x00,
+    0x00, 0x24, 0x89, 0x00, 0x00, 0x24, 0xa9, 0x00, 0x00, 0x24, 0xca, 0x00,
+    0x00, 0x24, 0xf2, 0x00, 0x00, 0x25, 0x1a, 0x00, 0x00, 0x25, 0x48, 0x00,
+    0x00, 0x25, 0x73, 0x00, 0x00, 0x25, 0xa0, 0x00, 0x00, 0x25, 0xc3, 0x00,
+    0x00, 0x25, 0xe9, 0x00, 0x00, 0x26, 0x13, 0x00, 0x00, 0x26, 0x39, 0x00,
+    0x00, 0x26, 0x64, 0x00, 0x00, 0x26, 0x85, 0x00, 0x00, 0x26, 0xa8, 0x00,
+    0x00, 0x26, 0xd4, 0x00, 0x00, 0x26, 0xfb, 0x00, 0x00, 0x27, 0x1f, 0x00,
+    0x00, 0x27, 0x48, 0x00, 0x00, 0x27, 0x6f, 0x00, 0x00, 0x27, 0x97, 0x00,
+    0x00, 0x27, 0xb9, 0x00, 0x00, 0x27, 0xdd, 0x00, 0x00, 0x28, 0x02, 0x00,
+    0x00, 0x28, 0x26, 0x00, 0x00, 0x28, 0x4c, 0x00, 0x00, 0x28, 0x74, 0x00,
+    0x00, 0x28, 0x98, 0x00, 0x00, 0x28, 0xb7, 0x00, 0x00, 0x28, 0xdd, 0x00,
+    0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x29, 0x00, 0x00, 0x29, 0x4d, 0x00,
+    0x00, 0x29, 0x7a, 0x00, 0x00, 0x29, 0x9d, 0x00, 0x00, 0x29, 0xc2, 0x00,
+    0x00, 0x29, 0xea, 0x00, 0x00, 0x2a, 0x15, 0x00, 0x00, 0x2a, 0x3e, 0x00,
+    0x00, 0x2a, 0x64, 0x00, 0x00, 0x2a, 0x8d, 0x00, 0x00, 0x2a, 0xb0, 0x00,
+    0x00, 0x2a, 0xd5, 0x00, 0x00, 0x2a, 0xf8, 0x00, 0x00, 0x2b, 0x21, 0x00,
+    0x00, 0x2b, 0x4a, 0x00, 0x00, 0x2b, 0x72, 0x00, 0x00, 0x2b, 0x95, 0x00,
+    0x00, 0x2b, 0xb7, 0x00, 0x00, 0x2b, 0xda, 0x00, 0x00, 0x2c, 0x06, 0x00,
+    0x00, 0x2c, 0x28, 0x00, 0x00, 0x2c, 0x47, 0x00, 0x00, 0x2c, 0x70, 0x00,
+    0x00, 0x2c, 0x93, 0x00, 0x00, 0x2c, 0xba, 0x00, 0x00, 0x2c, 0xe5, 0x00,
+    0x00, 0x2d, 0x09, 0x00, 0x00, 0x2d, 0x2b, 0x00, 0x00, 0x2d, 0x52, 0x00,
+    0x00, 0x2d, 0x7b, 0x00, 0x00, 0x2d, 0x9d, 0x00, 0x00, 0x2d, 0xc5, 0x00,
+    0x00, 0x2d, 0xea, 0x00, 0x00, 0x2e, 0x16, 0x00, 0x00, 0x2e, 0x3b, 0x00,
+    0x00, 0x2e, 0x5d, 0x00, 0x00, 0x2e, 0x81, 0x00, 0x00, 0x2e, 0xa9, 0x00,
+    0x00, 0x2e, 0xca, 0x00, 0x00, 0x2e, 0xed, 0x00, 0x00, 0x2f, 0x19, 0x00,
+    0x00, 0x2f, 0x3d, 0x00, 0x00, 0x2f, 0x6a, 0x00, 0x00, 0x2f, 0x90, 0x00,
+    0x00, 0x2f, 0xbb, 0x00, 0x00, 0x2f, 0xe2, 0x00, 0x00, 0x30, 0x08, 0x00,
+    0x00, 0x30, 0x2a, 0x00, 0x00, 0x30, 0x53, 0x00, 0x00, 0x30, 0x7a, 0x00,
+    0x00, 0x30, 0x9f, 0x00, 0x00, 0x30, 0xc2, 0x00, 0x00, 0x30, 0xe7, 0x00,
+    0x00, 0x31, 0x0e, 0x00, 0x00, 0x31, 0x34, 0x00, 0x00, 0x31, 0x5a, 0x00,
+    0x00, 0x31, 0x7f, 0x00, 0x00, 0x31, 0xaa, 0x00, 0x00, 0x31, 0xd1, 0x00,
+    0x00, 0x31, 0xf6, 0x00, 0x00, 0x32, 0x19, 0x00, 0x00, 0x32, 0x3e, 0x00,
+    0x00, 0x32, 0x66, 0x00, 0x00, 0x32, 0x8c, 0x00, 0x00, 0x32, 0xb0, 0x00,
+    0x00, 0x32, 0xd5, 0x00, 0x00, 0x32, 0xf9, 0x00, 0x00, 0x33, 0x21, 0x00,
+    0x00, 0x33, 0x46, 0x00, 0x00, 0x33, 0x6d, 0x00, 0x00, 0x33, 0x94, 0x00,
+    0x00, 0x33, 0xb8, 0x00, 0x00, 0x33, 0xe2, 0x00, 0x00, 0x34, 0x05, 0x00,
+    0x00, 0x34, 0x2c, 0x00, 0x00, 0x34, 0x51, 0x00, 0x00, 0x34, 0x71, 0x00,
+    0x00, 0x34, 0x98, 0x00, 0x00, 0x34, 0xc1, 0x00, 0x00, 0x34, 0xe7, 0x00,
+    0x00, 0x35, 0x0b, 0x00, 0x00, 0x35, 0x30, 0x00, 0x00, 0x35, 0x52, 0x00,
+    0x00, 0x35, 0x80, 0x00, 0x00, 0x35, 0xa6, 0x00, 0x00, 0x35, 0xca, 0x00,
+    0x00, 0x35, 0xf2, 0x00, 0x00, 0x36, 0x16, 0x00, 0x00, 0x36, 0x42, 0x00,
+    0x00, 0x36, 0x6a, 0x00, 0x00, 0x36, 0x91, 0x00, 0x00, 0x36, 0xba, 0x00,
+    0x00, 0x36, 0xe0, 0x00, 0x00, 0x37, 0x05, 0x00, 0x00, 0x37, 0x2d, 0x00,
+    0x00, 0x37, 0x4c, 0x00, 0x00, 0x37, 0x6e, 0x00, 0x00, 0x37, 0x92, 0x00,
+    0x00, 0x37, 0xba, 0x00, 0x00, 0x37, 0xde, 0x00, 0x00, 0x38, 0x04, 0x00,
+    0x00, 0x38, 0x28, 0x00, 0x00, 0x38, 0x4d, 0x00, 0x00, 0x38, 0x6e, 0x00,
+    0x00, 0x38, 0x91, 0x00, 0x00, 0x38, 0xb3, 0x00, 0x00, 0x38, 0xd4, 0x00,
+    0x00, 0x38, 0xf8, 0x00, 0x00, 0x39, 0x1e, 0x00, 0x00, 0x39, 0x48, 0x00,
+    0x00, 0x39, 0x73, 0x00, 0x00, 0x39, 0x93, 0x00, 0x00, 0x39, 0xb6, 0x00,
+    0x00, 0x39, 0xdf, 0x00, 0x00, 0x3a, 0x04, 0x00, 0x00, 0x3a, 0x29, 0x00,
+    0x00, 0x3a, 0x50, 0x00, 0x00, 0x3a, 0x77, 0x00, 0x00, 0x3a, 0x9b, 0x00,
+    0x00, 0x3a, 0xc5, 0x00, 0x00, 0x3a, 0xeb, 0x00, 0x00, 0x3b, 0x11, 0x00,
+    0x00, 0x3b, 0x33, 0x00, 0x00, 0x3b, 0x56, 0x00, 0x00, 0x3b, 0x7b, 0x00,
+    0x00, 0x3b, 0x9f, 0x00, 0x00, 0x3b, 0xc8, 0x00, 0x00, 0x3b, 0xec, 0x00,
+    0x00, 0x3c, 0x10, 0x00, 0x00, 0x3c, 0x3a, 0x00, 0x00, 0x3c, 0x60, 0x00,
+    0x00, 0x3c, 0x88, 0x00, 0x00, 0x3c, 0xad, 0x00, 0x00, 0x3c, 0xcf, 0x00,
+    0x00, 0x3c, 0xf8, 0x00, 0x00, 0x3d, 0x1b, 0x00, 0x00, 0x3d, 0x41, 0x00,
+    0x00, 0x3d, 0x63, 0x00, 0x00, 0x3d, 0x8b, 0x00, 0x00, 0x3d, 0xac, 0x00,
+    0x00, 0x3d, 0xcd, 0x00, 0x00, 0x3d, 0xf3, 0x00, 0x00, 0x3e, 0x17, 0x00,
+    0x00, 0x3e, 0x3c, 0x00, 0x00, 0x3e, 0x5f, 0x00, 0x00, 0x3e, 0x84, 0x00,
+    0x00, 0x3e, 0xae, 0x00, 0x00, 0x3e, 0xd6, 0x00, 0x00, 0x3e, 0xf9, 0x00,
+    0x00, 0x3f, 0x1d, 0x00, 0x00, 0x3f, 0x41, 0x00, 0x00, 0x3f, 0x64, 0x00,
+    0x00, 0x3f, 0x88, 0x00, 0x00, 0x3f, 0xae, 0x00, 0x00, 0x3f, 0xd2, 0x00,
+    0x00, 0x3f, 0xf5, 0x00, 0x00, 0x40, 0x1a, 0x00, 0x00, 0x40, 0x3f, 0x00,
+    0x00, 0x40, 0x64, 0x00, 0x00, 0x40, 0x91, 0x00, 0x00, 0x40, 0xbe, 0x00,
+    0x00, 0x40, 0xe2, 0x00, 0x00, 0x41, 0x11, 0x00, 0x00, 0x41, 0x37, 0x00,
+    0x00, 0x41, 0x5d, 0x00, 0x00, 0x41, 0x82, 0x00, 0x00, 0x41, 0xa4, 0x00,
+    0x00, 0x41, 0xd1, 0x00, 0x00, 0x41, 0xf1, 0x00, 0x00, 0x42, 0x15, 0x00,
+    0x00, 0x42, 0x39, 0x00, 0x00, 0x42, 0x61, 0x00, 0x00, 0x42, 0x8a, 0x00,
+    0x00, 0x42, 0xac, 0x00, 0x00, 0x42, 0xd2, 0x00, 0x00, 0x42, 0xfa, 0x00,
+    0x00, 0x43, 0x24, 0x00, 0x00, 0x43, 0x46, 0x00, 0x00, 0x43, 0x67, 0x00,
+    0x00, 0x43, 0x8c, 0x00, 0x00, 0x43, 0xb3, 0x00, 0x00, 0x43, 0xd9, 0x00,
+    0x00, 0x43, 0xfa, 0x00, 0x00, 0x44, 0x2b, 0x00, 0x00, 0x44, 0x4a, 0x00,
+    0x00, 0x44, 0x70, 0x00, 0x00, 0x44, 0x93, 0x00, 0x00, 0x44, 0xbb, 0x00,
+    0x00, 0x44, 0xe9, 0x00, 0x00, 0x45, 0x0e, 0x00, 0x00, 0x45, 0x38, 0x00,
+    0x00, 0x45, 0x5d, 0x00, 0x00, 0x45, 0x7c, 0x00, 0x00, 0x45, 0x9e, 0x00,
+    0x00, 0x45, 0xc4, 0x00, 0x00, 0x45, 0xeb, 0x00, 0x00, 0x46, 0x0e, 0x00,
+    0x00, 0x46, 0x31, 0x00, 0x00, 0x46, 0x56, 0x00, 0x00, 0x46, 0x75, 0x00,
+    0x00, 0x46, 0x9b, 0x00, 0x00, 0x46, 0xc5, 0x00, 0x00, 0x46, 0xe9, 0x00,
+    0x00, 0x47, 0x0e, 0x00, 0x00, 0x47, 0x39, 0x00, 0x00, 0x47, 0x61, 0x00,
+    0x00, 0x47, 0x84, 0x00, 0x00, 0x47, 0xa8, 0x00, 0x00, 0x47, 0xcb, 0x00,
+    0x00, 0x47, 0xf0, 0x00, 0x00, 0x48, 0x15, 0x00, 0x00, 0x48, 0x3a, 0x00,
+    0x00, 0x48, 0x65, 0x00, 0x00, 0x48, 0x8d, 0x00, 0x00, 0x48, 0xb3, 0x00,
+    0x00, 0x48, 0xd6, 0x00, 0x00, 0x48, 0xf7, 0x00, 0x00, 0x49, 0x1e, 0x00,
+    0x00, 0x49, 0x44, 0x00, 0x00, 0x49, 0x6b, 0x00, 0x00, 0x49, 0x91, 0x00,
+    0x00, 0x49, 0xbb, 0x00, 0x00, 0x49, 0xe1, 0x00, 0x00, 0x4a, 0x0a, 0x00,
+    0x00, 0x4a, 0x34, 0x00, 0x00, 0x4a, 0x59, 0x00, 0x00, 0x4a, 0x83, 0x00,
+    0x00, 0x4a, 0xa8, 0x00, 0x00, 0x4a, 0xcb, 0x00, 0x00, 0x4a, 0xf4, 0x00,
+    0x00, 0x4b, 0x19, 0x00, 0x00, 0x4b, 0x3d, 0x00, 0x00, 0x4b, 0x5d, 0x00,
+    0x00, 0x4b, 0x83, 0x00, 0x00, 0x4b, 0xa6, 0x00, 0x00, 0x4b, 0xd3, 0x00,
+    0x00, 0x4b, 0xf6, 0x00, 0x00, 0x4c, 0x1f, 0x00, 0x00, 0x4c, 0x48, 0x00,
+    0x00, 0x4c, 0x6d, 0x00, 0x00, 0x4c, 0x93, 0x00, 0x00, 0x4c, 0xb6, 0x00,
+    0x00, 0x4c, 0xe0, 0x00, 0x00, 0x4d, 0x04, 0x00, 0x00, 0x4d, 0x2d, 0x00,
+    0x00, 0x4d, 0x4e, 0x00, 0x00, 0x4d, 0x76, 0x00, 0x00, 0x4d, 0x9c, 0x00,
+    0x00, 0x4d, 0xc2, 0x00, 0x00, 0x4d, 0xef, 0x00, 0x00, 0x4e, 0x19, 0x00,
+    0x00, 0x4e, 0x3e, 0x00, 0x00, 0x4e, 0x65, 0x00, 0x00, 0x4e, 0x89, 0x00,
+    0x00, 0x4e, 0xb2, 0x00, 0x00, 0x4e, 0xd8, 0x00, 0x00, 0x4e, 0xfb, 0x00,
+    0x00, 0x4f, 0x1f, 0x00, 0x00, 0x4f, 0x45, 0x00, 0x00, 0x4f, 0x6a, 0x00,
+    0x00, 0x4f, 0x8f, 0x00, 0x00, 0x4f, 0xba, 0x00, 0x00, 0x4f, 0xdc, 0x00,
+    0x00, 0x50, 0x00, 0x00, 0x00, 0x50, 0x25, 0x00, 0x00, 0x50, 0x49, 0x00,
+    0x00, 0x50, 0x68, 0x00, 0x00, 0x50, 0x91, 0x00, 0x00, 0x50, 0xb3, 0x00,
+    0x00, 0x50, 0xda, 0x00, 0x00, 0x51, 0x05, 0x00, 0x00, 0x51, 0x2e, 0x00,
+    0x00, 0x51, 0x53, 0x00, 0x00, 0x51, 0x77, 0x00, 0x00, 0x51, 0x9d, 0x00,
+    0x00, 0x51, 0xc3, 0x00, 0x00, 0x51, 0xe6, 0x00, 0x00, 0x52, 0x0d, 0x00,
+    0x00, 0x52, 0x32, 0x00, 0x00, 0x52, 0x59, 0x00, 0x00, 0x52, 0x7f, 0x00,
+    0x00, 0x52, 0xa1, 0x00, 0x00, 0x52, 0xc6, 0x00, 0x00, 0x52, 0xec, 0x00,
+    0x00, 0x53, 0x13, 0x00, 0x00, 0x53, 0x37, 0x00, 0x00, 0x53, 0x5f, 0x00,
+    0x00, 0x53, 0x88, 0x00, 0x00, 0x53, 0xaf, 0x00, 0x00, 0x53, 0xd6, 0x00,
+    0x00, 0x53, 0xfc, 0x00, 0x00, 0x54, 0x22, 0x00, 0x00, 0x54, 0x45, 0x00,
+    0x00, 0x54, 0x6f, 0x00, 0x00, 0x54, 0x92, 0x00, 0x00, 0x54, 0xba, 0x00,
+    0x00, 0x54, 0xe0, 0x00, 0x00, 0x55, 0x0c, 0x00, 0x00, 0x55, 0x30, 0x00,
+    0x00, 0x55, 0x59, 0x00, 0x00, 0x55, 0x86, 0x00, 0x00, 0x55, 0xac, 0x00,
+    0x00, 0x55, 0xcf, 0x00, 0x00, 0x55, 0xf8, 0x00, 0x00, 0x56, 0x22, 0x00,
+    0x00, 0x56, 0x47, 0x00, 0x00, 0x56, 0x6d, 0x00, 0x00, 0x56, 0x9b, 0x00,
+    0x00, 0x56, 0xc1, 0x00, 0x00, 0x56, 0xe6, 0x00, 0x00, 0x57, 0x0c, 0x00,
+    0x00, 0x57, 0x2e, 0x00, 0x00, 0x57, 0x55, 0x00, 0x00, 0x57, 0x7b, 0x00,
+    0x00, 0x57, 0xa0, 0x00, 0x00, 0x57, 0xc8, 0x00, 0x00, 0x57, 0xec, 0x00,
+    0x00, 0x58, 0x13, 0x00, 0x00, 0x58, 0x38, 0x00, 0x00, 0x58, 0x5b, 0x00,
+    0x00, 0x58, 0x82, 0x00, 0x00, 0x58, 0xaa, 0x00, 0x00, 0x58, 0xd1, 0x00,
+    0x00, 0x58, 0xf8, 0x00, 0x00, 0x59, 0x1e, 0x00, 0x00, 0x59, 0x41, 0x00,
+    0x00, 0x59, 0x64, 0x00, 0x00, 0x59, 0x8a, 0x00, 0x00, 0x59, 0xb0, 0x00,
+    0x00, 0x59, 0xd5, 0x00, 0x00, 0x59, 0xf7, 0x00, 0x00, 0x5a, 0x24, 0x00,
+    0x00, 0x5a, 0x4d, 0x00, 0x00, 0x5a, 0x6f, 0x00, 0x00, 0x5a, 0x94, 0x00,
+    0x00, 0x5a, 0xbd, 0x00, 0x00, 0x5a, 0xdf, 0x00, 0x00, 0x5b, 0x05, 0x00,
+    0x00, 0x5b, 0x29, 0x00, 0x00, 0x5b, 0x4c, 0x00, 0x00, 0x5b, 0x70, 0x00,
+    0x00, 0x5b, 0x9b, 0x00, 0x00, 0x5b, 0xc2, 0x00, 0x00, 0x5b, 0xe7, 0x00,
+    0x00, 0x5c, 0x0e, 0x00, 0x00, 0x5c, 0x32, 0x00, 0x00, 0x5c, 0x57, 0x00,
+    0x00, 0x5c, 0x77, 0x00, 0x00, 0x5c, 0x99, 0x00, 0x00, 0x5c, 0xbc, 0x00,
+    0x00, 0x5c, 0xe2, 0x00, 0x00, 0x5d, 0x08, 0x00, 0x00, 0x5d, 0x2a, 0x00,
+    0x00, 0x5d, 0x50, 0x00, 0x00, 0x5d, 0x76, 0x00, 0x00, 0x5d, 0x99, 0x00,
+    0x00, 0x5d, 0xbd, 0x00, 0x00, 0x5d, 0xdf, 0x00, 0x00, 0x5e, 0x02, 0x00,
+    0x00, 0x5e, 0x26, 0x00, 0x00, 0x5e, 0x4c, 0x00, 0x00, 0x5e, 0x70, 0x00,
+    0x00, 0x5e, 0x99, 0x00, 0x00, 0x5e, 0xbe, 0x00, 0x00, 0x5e, 0xe2, 0x00,
+    0x00, 0x5f, 0x02, 0x00, 0x00, 0x5f, 0x27, 0x00, 0x00, 0x5f, 0x4d, 0x00,
+    0x00, 0x5f, 0x75, 0x00, 0x00, 0x5f, 0x98, 0x00, 0x00, 0x5f, 0xbc, 0x00,
+    0x00, 0x5f, 0xe8, 0x00, 0x00, 0x60, 0x0e, 0x00, 0x00, 0x60, 0x35, 0x00,
+    0x00, 0x60, 0x58, 0x00, 0x00, 0x60, 0x7e, 0x00, 0x00, 0x60, 0xa3, 0x00,
+    0x00, 0x60, 0xc5, 0x00, 0x00, 0x60, 0xe9, 0x00, 0x00, 0x61, 0x10, 0x00,
+    0x00, 0x61, 0x39, 0x00, 0x00, 0x61, 0x63, 0x00, 0x00, 0x61, 0x8b, 0x00,
+    0x00, 0x61, 0xb5, 0x00, 0x00, 0x61, 0xd7, 0x00, 0x00, 0x61, 0xfd, 0x00,
+    0x00, 0x62, 0x20, 0x00, 0x00, 0x62, 0x4c, 0x00, 0x00, 0x62, 0x7c, 0x00,
+    0x00, 0x62, 0x9f, 0x00, 0x00, 0x62, 0xc4, 0x00, 0x00, 0x62, 0xe5, 0x00,
+    0x00, 0x63, 0x0f, 0x00, 0x00, 0x63, 0x32, 0x00, 0x00, 0x63, 0x57, 0x00,
+    0x00, 0x63, 0x76, 0x00, 0x00, 0x63, 0x9c, 0x00, 0x00, 0x63, 0xc7, 0x00,
+    0x00, 0x63, 0xe9, 0x00, 0x00, 0x64, 0x09, 0x00, 0x00, 0x64, 0x27, 0x00,
+    0x00, 0x64, 0x4e, 0x00, 0x00, 0x64, 0x73, 0x00, 0x00, 0x64, 0x95, 0x00,
+    0x00, 0x64, 0xb9, 0x00, 0x00, 0x64, 0xdf, 0x00, 0x00, 0x65, 0x03, 0x00,
+    0x00, 0x65, 0x27, 0x00, 0x00, 0x65, 0x4d, 0x00, 0x00, 0x65, 0x75, 0x00,
+    0x00, 0x65, 0x99, 0x00, 0x00, 0x65, 0xb9, 0x00, 0x00, 0x65, 0xde, 0x00,
+    0x00, 0x66, 0x04, 0x00, 0x00, 0x66, 0x2a, 0x00, 0x00, 0x66, 0x4d, 0x00,
+    0x00, 0x66, 0x6f, 0x00, 0x00, 0x66, 0x97, 0x00, 0x00, 0x66, 0xc0, 0x00,
+    0x00, 0x66, 0xe6, 0x00, 0x00, 0x67, 0x09, 0x00, 0x00, 0x67, 0x2e, 0x00,
+    0x00, 0x67, 0x52, 0x00, 0x00, 0x67, 0x7e, 0x00, 0x00, 0x67, 0xaa, 0x00,
+    0x00, 0x67, 0xcb, 0x00, 0x00, 0x67, 0xef, 0x00, 0x00, 0x68, 0x16, 0x00,
+    0x00, 0x68, 0x41, 0x00, 0x00, 0x68, 0x68, 0x00, 0x00, 0x68, 0x8f, 0x00,
+    0x00, 0x68, 0xb6, 0x00, 0x00, 0x68, 0xda, 0x00, 0x00, 0x69, 0x00, 0x00,
+    0x00, 0x69, 0x27, 0x00, 0x00, 0x69, 0x4c, 0x00, 0x00, 0x69, 0x71, 0x00,
+    0x00, 0x69, 0x91, 0x00, 0x00, 0x69, 0xb7, 0x00, 0x00, 0x69, 0xe3, 0x00,
+    0x00, 0x6a, 0x0c, 0x00, 0x00, 0x6a, 0x38, 0x00, 0x00, 0x6a, 0x68, 0x00,
+    0x00, 0x6a, 0x91, 0x00, 0x00, 0x6a, 0xb5, 0x00, 0x00, 0x6a, 0xde, 0x00,
+    0x00, 0x6b, 0x03, 0x00, 0x00, 0x6b, 0x2b, 0x00, 0x00, 0x6b, 0x4d, 0x00,
+    0x00, 0x6b, 0x75, 0x00, 0x00, 0x6b, 0xa0, 0x00, 0x00, 0x6b, 0xc5, 0x00,
+    0x00, 0x6b, 0xea, 0x00, 0x00, 0x6c, 0x0c, 0x00, 0x00, 0x6c, 0x35, 0x00,
+    0x00, 0x6c, 0x5a, 0x00, 0x00, 0x6c, 0x7e, 0x00, 0x00, 0x6c, 0xa2, 0x00,
+    0x00, 0x6c, 0xc7, 0x00, 0x00, 0x6c, 0xe8, 0x00, 0x00, 0x6d, 0x0b, 0x00,
+    0x00, 0x6d, 0x37, 0x00, 0x00, 0x6d, 0x60, 0x00, 0x00, 0x6d, 0x84, 0x00,
+    0x00, 0x6d, 0xa8, 0x00, 0x00, 0x6d, 0xda, 0x00, 0x00, 0x6d, 0xfd, 0x00,
+    0x00, 0x6e, 0x27, 0x00, 0x00, 0x6e, 0x4f, 0x00, 0x00, 0x6e, 0x79, 0x00,
+    0x00, 0x6e, 0xa2, 0x00, 0x00, 0x6e, 0xc4, 0x00, 0x00, 0x6e, 0xea, 0x00,
+    0x00, 0x6f, 0x0f, 0x00, 0x00, 0x6f, 0x33, 0x00, 0x00, 0x6f, 0x57, 0x00,
+    0x00, 0x6f, 0x7d, 0x00, 0x00, 0x6f, 0xa4, 0x00, 0x00, 0x6f, 0xcb, 0x00,
+    0x00, 0x6f, 0xf2, 0x00, 0x00, 0x70, 0x1d, 0x00, 0x00, 0x70, 0x48, 0x00,
+    0x00, 0x70, 0x72, 0x00, 0x00, 0x70, 0x93, 0x00, 0x00, 0x70, 0xba, 0x00,
+    0x00, 0x70, 0xde, 0x00, 0x00, 0x71, 0x01, 0x00, 0x00, 0x71, 0x2b, 0x00,
+    0x00, 0x71, 0x53, 0x00, 0x00, 0x71, 0x78, 0x00, 0x00, 0x71, 0x9b, 0x00,
+    0x00, 0x71, 0xc0, 0x00, 0x00, 0x71, 0xe7, 0x00, 0x00, 0x72, 0x0b, 0x00,
+    0x00, 0x72, 0x34, 0x00, 0x00, 0x72, 0x58, 0x00, 0x00, 0x72, 0x86, 0x00,
+    0x00, 0x72, 0xa9, 0x00, 0x00, 0x72, 0xd2, 0x00, 0x00, 0x72, 0xfb, 0x00,
+    0x00, 0x73, 0x1e, 0x00, 0x00, 0x73, 0x44, 0x00, 0x00, 0x73, 0x68, 0x00,
+    0x00, 0x73, 0x8e, 0x00, 0x00, 0x73, 0xbb, 0x00, 0x00, 0x73, 0xe1, 0x00,
+    0x00, 0x74, 0x03, 0x00, 0x00, 0x74, 0x29, 0x00, 0x00, 0x74, 0x4e, 0x00,
+    0x00, 0x74, 0x71, 0x00, 0x00, 0x74, 0x9a, 0x00, 0x00, 0x74, 0xc3, 0x00,
+    0x00, 0x74, 0xeb, 0x00, 0x00, 0x75, 0x0f, 0x00, 0x00, 0x75, 0x3a, 0x00,
+    0x00, 0x75, 0x5c, 0x00, 0x00, 0x75, 0x89, 0x00, 0x00, 0x75, 0xb2, 0x00,
+    0x00, 0x75, 0xd6, 0x00, 0x00, 0x75, 0xf6, 0x00, 0x00, 0x76, 0x1f, 0x00,
+    0x00, 0x76, 0x43, 0x00, 0x00, 0x76, 0x6e, 0x00, 0x00, 0x76, 0x93, 0x00,
+    0x00, 0x76, 0xc0, 0x00, 0x00, 0x76, 0xe4, 0x00, 0x00, 0x77, 0x0e, 0x00,
+    0x00, 0x77, 0x34, 0x00, 0x00, 0x77, 0x5c, 0x00, 0x00, 0x77, 0x7c, 0x00,
+    0x00, 0x77, 0xa4, 0x00, 0x00, 0x77, 0xc5, 0x00, 0x00, 0x77, 0xe6, 0x00,
+    0x00, 0x78, 0x0b, 0x00, 0x00, 0x78, 0x34, 0x00, 0x00, 0x78, 0x5e, 0x00,
+    0x00, 0x78, 0x8b, 0x00, 0x00, 0x78, 0xb1, 0x00, 0x00, 0x78, 0xdc, 0x00,
+    0x00, 0x79, 0x01, 0x00, 0x00, 0x79, 0x26, 0x00, 0x00, 0x79, 0x4a, 0x00,
+    0x00, 0x79, 0x70, 0x00, 0x00, 0x79, 0x97, 0x00, 0x00, 0x79, 0xbb, 0x00,
+    0x00, 0x79, 0xe2, 0x00, 0x00, 0x7a, 0x07, 0x00, 0x00, 0x7a, 0x2a, 0x00,
+    0x00, 0x7a, 0x4b, 0x00, 0x00, 0x7a, 0x70, 0x00, 0x00, 0x7a, 0x92, 0x00,
+    0x00, 0x7a, 0xb7, 0x00, 0x00, 0x7a, 0xd7, 0x00, 0x00, 0x7b, 0x00, 0x00,
+    0x00, 0x7b, 0x28, 0x00, 0x00, 0x7b, 0x4b, 0x00, 0x00, 0x7b, 0x75, 0x00,
+    0x00, 0x7b, 0x97, 0x00, 0x00, 0x7b, 0xb8, 0x00, 0x00, 0x7b, 0xdd, 0x00,
+    0x00, 0x7c, 0x03, 0x00, 0x00, 0x7c, 0x24, 0x00, 0x00, 0x7c, 0x47, 0x00,
+    0x00, 0x7c, 0x72, 0x00, 0x00, 0x7c, 0x95, 0x00, 0x00, 0x7c, 0xba, 0x00,
+    0x00, 0x7c, 0xdb, 0x00, 0x00, 0x7c, 0xfe, 0x00, 0x00, 0x7d, 0x25, 0x00,
+    0x00, 0x7d, 0x4f, 0x00, 0x00, 0x7d, 0x78, 0x00, 0x00, 0x7d, 0x9c, 0x00,
+    0x00, 0x7d, 0xc1, 0x00, 0x00, 0x7d, 0xe4, 0x00, 0x00, 0x7e, 0x0e, 0x00,
+    0x00, 0x7e, 0x32, 0x00, 0x00, 0x7e, 0x56, 0x00, 0x00, 0x7e, 0x76, 0x00,
+    0x00, 0x7e, 0x9c, 0x00, 0x00, 0x7e, 0xc1, 0x00, 0x00, 0x7e, 0xe6, 0x00,
+    0x00, 0x7f, 0x0d, 0x00, 0x00, 0x7f, 0x31, 0x00, 0x00, 0x7f, 0x5a, 0x00,
+    0x00, 0x7f, 0x80, 0x00, 0x00, 0x7f, 0xa7, 0x00, 0x00, 0x7f, 0xcb, 0x00,
+    0x00, 0x7f, 0xef, 0x00, 0x00, 0x80, 0x0f, 0x00, 0x00, 0x80, 0x36, 0x00,
+    0x00, 0x80, 0x5a, 0x00, 0x00, 0x80, 0x7c, 0x00, 0x00, 0x80, 0xa3, 0x00,
+    0x00, 0x80, 0xce, 0x00, 0x00, 0x80, 0xf8, 0x00, 0x00, 0x81, 0x1e, 0x00,
+    0x00, 0x81, 0x43, 0x00, 0x00, 0x81, 0x6d, 0x00, 0x00, 0x81, 0x93, 0x00,
+    0x00, 0x81, 0xbb, 0x00, 0x00, 0x81, 0xe3, 0x00, 0x00, 0x82, 0x09, 0x00,
+    0x00, 0x82, 0x32, 0x00, 0x00, 0x82, 0x51, 0x00, 0x00, 0x82, 0x75, 0x00,
+    0x00, 0x82, 0x9b, 0x00, 0x00, 0x82, 0xc0, 0x00, 0x00, 0x82, 0xe6, 0x00,
+    0x00, 0x83, 0x0c, 0x00, 0x00, 0x83, 0x32, 0x00, 0x00, 0x83, 0x58, 0x00,
+    0x00, 0x83, 0x7c, 0x00, 0x00, 0x83, 0xa4, 0x00, 0x00, 0x83, 0xca, 0x00,
+    0x00, 0x83, 0xf0, 0x00, 0x00, 0x84, 0x19, 0x00, 0x00, 0x84, 0x40, 0x00,
+    0x00, 0x84, 0x62, 0x00, 0x00, 0x84, 0x85, 0x00, 0x00, 0x84, 0xb3, 0x00,
+    0x00, 0x84, 0xd7, 0x00, 0x00, 0x84, 0xfb, 0x00, 0x00, 0x85, 0x21, 0x00,
+    0x00, 0x85, 0x4a, 0x00, 0x00, 0x85, 0x6e, 0x00, 0x00, 0x85, 0x95, 0x00,
+    0x00, 0x85, 0xba, 0x00, 0x00, 0x85, 0xe3, 0x00, 0x00, 0x86, 0x08, 0x00,
+    0x00, 0x86, 0x2b, 0x00, 0x00, 0x86, 0x4a, 0x00, 0x00, 0x86, 0x6c, 0x00,
+    0x00, 0x86, 0x93, 0x00, 0x00, 0x86, 0xc2, 0x00, 0x00, 0x86, 0xe2, 0x00,
+    0x00, 0x87, 0x0a, 0x00, 0x00, 0x87, 0x37, 0x00, 0x00, 0x87, 0x65, 0x00,
+    0x00, 0x87, 0x87, 0x00, 0x00, 0x87, 0xae, 0x00, 0x00, 0x87, 0xcd, 0x00,
+    0x00, 0x87, 0xf2, 0x00, 0x00, 0x88, 0x14, 0x00, 0x00, 0x88, 0x3d, 0x00,
+    0x00, 0x88, 0x61, 0x00, 0x00, 0x88, 0x87, 0x00, 0x00, 0x88, 0xb4, 0x00,
+    0x00, 0x88, 0xdb, 0x00, 0x00, 0x89, 0x02, 0x00, 0x00, 0x89, 0x2a, 0x00,
+    0x00, 0x89, 0x4f, 0x00, 0x00, 0x89, 0x75, 0x00, 0x00, 0x89, 0x99, 0x00,
+    0x00, 0x89, 0xbc, 0x00, 0x00, 0x89, 0xde, 0x00, 0x00, 0x8a, 0x03, 0x00,
+    0x00, 0x8a, 0x2a, 0x00, 0x00, 0x8a, 0x52, 0x00, 0x00, 0x8a, 0x79, 0x00,
+    0x00, 0x8a, 0x9f, 0x00, 0x00, 0x8a, 0xc4, 0x00, 0x00, 0x8a, 0xe8, 0x00,
+    0x00, 0x8b, 0x0e, 0x00, 0x00, 0x8b, 0x33, 0x00, 0x00, 0x8b, 0x5b, 0x00,
+    0x00, 0x8b, 0x88, 0x00, 0x00, 0x8b, 0xb3, 0x00, 0x00, 0x8b, 0xd4, 0x00,
+    0x00, 0x8b, 0xfa, 0x00, 0x00, 0x8c, 0x1f, 0x00, 0x00, 0x8c, 0x41, 0x00,
+    0x00, 0x8c, 0x64, 0x00, 0x00, 0x8c, 0x88, 0x00, 0x00, 0x8c, 0xb1, 0x00,
+    0x00, 0x8c, 0xd3, 0x00, 0x00, 0x8c, 0xf5, 0x00, 0x00, 0x8d, 0x16, 0x00,
+    0x00, 0x8d, 0x3e, 0x00, 0x00, 0x8d, 0x60, 0x00, 0x00, 0x8d, 0x83, 0x00,
+    0x00, 0x8d, 0xaa, 0x00, 0x00, 0x8d, 0xcc, 0x00, 0x00, 0x8d, 0xf4, 0x00,
+    0x00, 0x8e, 0x1d, 0x00, 0x00, 0x8e, 0x42, 0x00, 0x00, 0x8e, 0x6a, 0x00,
+    0x00, 0x8e, 0x91, 0x00, 0x00, 0x8e, 0xb7, 0x00, 0x00, 0x8e, 0xda, 0x00,
+    0x00, 0x8e, 0xfd, 0x00, 0x00, 0x8f, 0x25, 0x00, 0x00, 0x8f, 0x4e, 0x00,
+    0x00, 0x8f, 0x74, 0x00, 0x00, 0x8f, 0x98, 0x00, 0x00, 0x8f, 0xbf, 0x00,
+    0x00, 0x8f, 0xe8, 0x00, 0x00, 0x90, 0x0d, 0x00, 0x00, 0x90, 0x3b, 0x00,
+    0x00, 0x90, 0x66, 0x00, 0x00, 0x90, 0x8c, 0x00, 0x00, 0x90, 0xb1, 0x00,
+    0x00, 0x90, 0xd6, 0x00, 0x00, 0x90, 0xf6, 0x00, 0x00, 0x91, 0x1f, 0x00,
+    0x00, 0x91, 0x48, 0x00, 0x00, 0x91, 0x73, 0x00, 0x00, 0x91, 0x96, 0x00,
+    0x00, 0x91, 0xc4, 0x00, 0x00, 0x91, 0xe9, 0x00, 0x00, 0x92, 0x0c, 0x00,
+    0x00, 0x92, 0x37, 0x00, 0x00, 0x92, 0x58, 0x00, 0x00, 0x92, 0x84, 0x00,
+    0x00, 0x92, 0xa9, 0x00, 0x00, 0x92, 0xcc, 0x00, 0x00, 0x92, 0xf1, 0x00,
+    0x00, 0x93, 0x14, 0x00, 0x00, 0x93, 0x3f, 0x00, 0x00, 0x93, 0x67, 0x00,
+    0x00, 0x93, 0x8e, 0x00, 0x00, 0x93, 0xb0, 0x00, 0x00, 0x93, 0xd7, 0x00,
+    0x00, 0x93, 0xf7, 0x00, 0x00, 0x94, 0x18, 0x00, 0x00, 0x94, 0x3e, 0x00,
+    0x00, 0x94, 0x60, 0x00, 0x00, 0x94, 0x88, 0x00, 0x00, 0x94, 0xac, 0x00,
+    0x00, 0x94, 0xd8, 0x00, 0x00, 0x94, 0xfd, 0x00, 0x00, 0x95, 0x27, 0x00,
+    0x00, 0x95, 0x4a, 0x00, 0x00, 0x95, 0x6f, 0x00, 0x00, 0x95, 0x96, 0x00,
+    0x00, 0x95, 0xbc, 0x00, 0x00, 0x95, 0xe5, 0x00, 0x00, 0x96, 0x05, 0x00,
+    0x00, 0x96, 0x28, 0x00, 0x00, 0x96, 0x50, 0x00, 0x00, 0x96, 0x75, 0x00,
+    0x00, 0x96, 0x9b, 0x00, 0x00, 0x96, 0xc2, 0x00, 0x00, 0x96, 0xeb, 0x00,
+    0x00, 0x97, 0x12, 0x00, 0x00, 0x97, 0x35, 0x00, 0x00, 0x97, 0x5b, 0x00,
+    0x00, 0x97, 0x80, 0x00, 0x00, 0x97, 0xa9, 0x00, 0x00, 0x97, 0xcb, 0x00,
+    0x00, 0x97, 0xf4, 0x00, 0x00, 0x98, 0x1c, 0x00, 0x00, 0x98, 0x45, 0x00,
+    0x00, 0x98, 0x68, 0x00, 0x00, 0x98, 0x8c, 0x00, 0x00, 0x98, 0xb5, 0x00,
+    0x00, 0x98, 0xd5, 0x00, 0x00, 0x98, 0xf9, 0x00, 0x00, 0x99, 0x23, 0x00,
+    0x00, 0x99, 0x46, 0x00, 0x00, 0x99, 0x6d, 0x00, 0x00, 0x99, 0x98, 0x00,
+    0x00, 0x99, 0xc0, 0x00, 0x00, 0x99, 0xe6, 0x00, 0x00, 0x9a, 0x0f, 0x00,
+    0x00, 0x9a, 0x30, 0x00, 0x00, 0x9a, 0x55, 0x00, 0x00, 0x9a, 0x80, 0x00,
+    0x00, 0x9a, 0xa4, 0x00, 0x00, 0x9a, 0xcd, 0x00, 0x00, 0x9a, 0xef, 0x00,
+    0x00, 0x9b, 0x12, 0x00, 0x00, 0x9b, 0x35, 0x00, 0x00, 0x9b, 0x5c, 0x00,
+    0x00, 0x9b, 0x7e, 0x00, 0x00, 0x9b, 0xaa, 0x00, 0x00, 0x9b, 0xcf, 0x00,
+    0x00, 0x9b, 0xf8, 0x00, 0x00, 0x9c, 0x1f, 0x00, 0x00, 0x9c, 0x45, 0x00,
+    0x00, 0x9c, 0x69, 0x00, 0x00, 0x9c, 0x8c, 0x00, 0x00, 0x9c, 0xb0, 0x00,
+    0x00, 0x9c, 0xd4, 0x00, 0x00, 0x9d, 0x00, 0x00, 0x00, 0x9d, 0x23, 0x00,
+    0x00, 0x9d, 0x4b, 0x00, 0x00, 0x9d, 0x71, 0x00, 0x00, 0x9d, 0x96, 0x00,
+    0x00, 0x9d, 0xbe, 0x00, 0x00, 0x9d, 0xe0, 0x00, 0x00, 0x9e, 0x04, 0x00,
+    0x00, 0x9e, 0x29, 0x00, 0x00, 0x9e, 0x54, 0x00, 0x00, 0x9e, 0x82, 0x00,
+    0x00, 0x9e, 0xa8, 0x00, 0x00, 0x9e, 0xd1, 0x00, 0x00, 0x9e, 0xf6, 0x00,
+    0x00, 0x9f, 0x1d, 0x00, 0x00, 0x9f, 0x44, 0x00, 0x00, 0x9f, 0x6c, 0x00,
+    0x00, 0x9f, 0x90, 0x00, 0x00, 0x9f, 0xb1, 0x00, 0x00, 0x9f, 0xdd, 0x00,
+    0x00, 0xa0, 0x03, 0x00, 0x00, 0xa0, 0x26, 0x00, 0x00, 0xa0, 0x4a, 0x00,
+    0x00, 0xa0, 0x6d, 0x00, 0x00, 0xa0, 0x9c, 0x00, 0x00, 0xa0, 0xc1, 0x00,
+    0x00, 0xa0, 0xe6, 0x00, 0x00, 0xa1, 0x0e, 0x00, 0x00, 0xa1, 0x31, 0x00,
+    0x00, 0xa1, 0x52, 0x00, 0x00, 0xa1, 0x7a, 0x00, 0x00, 0xa1, 0xa1, 0x00,
+    0x00, 0xa1, 0xca, 0x00, 0x00, 0xa1, 0xef, 0x00, 0x00, 0xa2, 0x14, 0x00,
+    0x00, 0xa2, 0x37, 0x00, 0x00, 0xa2, 0x57, 0x00, 0x00, 0xa2, 0x7c, 0x00,
+    0x00, 0xa2, 0xa5, 0x00, 0x00, 0xa2, 0xcc, 0x00, 0x00, 0xa2, 0xf3, 0x00,
+    0x00, 0xa3, 0x1a, 0x00, 0x00, 0xa3, 0x3f, 0x00, 0x00, 0xa3, 0x63, 0x00,
+    0x00, 0xa3, 0x84, 0x00, 0x00, 0xa3, 0xaf, 0x00, 0x00, 0xa3, 0xd0, 0x00,
+    0x00, 0xa3, 0xf9, 0x00, 0x00, 0xa4, 0x1d, 0x00, 0x00, 0xa4, 0x41, 0x00,
+    0x00, 0xa4, 0x63, 0x00, 0x00, 0xa4, 0x8c, 0x00, 0x00, 0xa4, 0xb3, 0x00,
+    0x00, 0xa4, 0xdc, 0x00, 0x00, 0xa5, 0x06, 0x00, 0x00, 0xa5, 0x2a, 0x00,
+    0x00, 0xa5, 0x56, 0x00, 0x00, 0xa5, 0x79, 0x00, 0x00, 0xa5, 0x99, 0x00,
+    0x00, 0xa5, 0xbf, 0x00, 0x00, 0xa5, 0xe7, 0x00, 0x00, 0xa6, 0x0b, 0x00,
+    0x00, 0xa6, 0x30, 0x00, 0x00, 0xa6, 0x55, 0x00, 0x00, 0xa6, 0x77, 0x00,
+    0x00, 0xa6, 0x9b, 0x00, 0x00, 0xa6, 0xc0, 0x00, 0x00, 0xa6, 0xe7, 0x00,
+    0x00, 0xa7, 0x12, 0x00, 0x00, 0xa7, 0x3f, 0x00, 0x00, 0xa7, 0x66, 0x00,
+    0x00, 0xa7, 0x88, 0x00, 0x00, 0xa7, 0xac, 0x00, 0x00, 0xa7, 0xcd, 0x00,
+    0x00, 0xa7, 0xf7, 0x00, 0x00, 0xa8, 0x1a, 0x00, 0x00, 0xa8, 0x40, 0x00,
+    0x00, 0xa8, 0x63, 0x00, 0x00, 0xa8, 0x87, 0x00, 0x00, 0xa8, 0xab, 0x00,
+    0x00, 0xa8, 0xd3, 0x00, 0x00, 0xa8, 0xfa, 0x00, 0x00, 0xa9, 0x1b, 0x00,
+    0x00, 0xa9, 0x45, 0x00, 0x00, 0xa9, 0x6a, 0x00, 0x00, 0xa9, 0x8e, 0x00,
+    0x00, 0xa9, 0xb3, 0x00, 0x00, 0xa9, 0xd7, 0x00, 0x00, 0xa9, 0xfc, 0x00,
+    0x00, 0xaa, 0x23, 0x00, 0x00, 0xaa, 0x45, 0x00, 0x00, 0xaa, 0x6c, 0x00,
+    0x00, 0xaa, 0x90, 0x00, 0x00, 0xaa, 0xb5, 0x00, 0x00, 0xaa, 0xda, 0x00,
+    0x00, 0xaa, 0xfd, 0x00, 0x00, 0xab, 0x2c, 0x00, 0x00, 0xab, 0x50, 0x00,
+    0x00, 0xab, 0x7b, 0x00, 0x00, 0xab, 0x9c, 0x00, 0x00, 0xab, 0xcb, 0x00,
+    0x00, 0xab, 0xf1, 0x00, 0x00, 0xac, 0x11, 0x00, 0x00, 0xac, 0x31, 0x00,
+    0x00, 0xac, 0x53, 0x00, 0x00, 0xac, 0x7a, 0x00, 0x00, 0xac, 0xa1, 0x00,
+    0x00, 0xac, 0xc6, 0x00, 0x00, 0xac, 0xeb, 0x00, 0x00, 0xad, 0x15, 0x00,
+    0x00, 0xad, 0x35, 0x00, 0x00, 0xad, 0x59, 0x00, 0x00, 0xad, 0x7e, 0x00,
+    0x00, 0xad, 0xa3, 0x00, 0x00, 0xad, 0xc9, 0x00, 0x00, 0xad, 0xef, 0x00,
+    0x00, 0xae, 0x17, 0x00, 0x00, 0xae, 0x3c, 0x00, 0x00, 0xae, 0x61, 0x00,
+    0x00, 0xae, 0x8f, 0x00, 0x00, 0xae, 0xb7, 0x00, 0x00, 0xae, 0xdf, 0x00,
+    0x00, 0xaf, 0x03, 0x00, 0x00, 0xaf, 0x28, 0x00, 0x00, 0xaf, 0x54, 0x00,
+    0x00, 0xaf, 0x7e, 0x00, 0x00, 0xaf, 0xab, 0x00, 0x00, 0xaf, 0xce, 0x00,
+    0x00, 0xaf, 0xed, 0x00, 0x00, 0xb0, 0x10, 0x00, 0x00, 0xb0, 0x3c, 0x00,
+    0x00, 0xb0, 0x61, 0x00, 0x00, 0xb0, 0x80, 0x00, 0x00, 0xb0, 0xa5, 0x00,
+    0x00, 0xb0, 0xd3, 0x00, 0x00, 0xb0, 0xf8, 0x00, 0x00, 0xb1, 0x24, 0x00,
+    0x00, 0xb1, 0x45, 0x00, 0x00, 0xb1, 0x6f, 0x00, 0x00, 0xb1, 0x96, 0x00,
+    0x00, 0xb1, 0xbf, 0x00, 0x00, 0xb1, 0xe3, 0x00, 0x00, 0xb2, 0x05, 0x00,
+    0x00, 0xb2, 0x2a, 0x00, 0x00, 0xb2, 0x4f, 0x00, 0x00, 0xb2, 0x77, 0x00,
+    0x00, 0xb2, 0x9b, 0x00, 0x00, 0xb2, 0xc5, 0x00, 0x00, 0xb2, 0xee, 0x00,
+    0x00, 0xb3, 0x11, 0x00, 0x00, 0xb3, 0x37, 0x00, 0x00, 0xb3, 0x5c, 0x00,
+    0x00, 0xb3, 0x7f, 0x00, 0x00, 0xb3, 0xa8, 0x00, 0x00, 0xb3, 0xd7, 0x00,
+    0x00, 0xb3, 0xfd, 0x00, 0x00, 0xb4, 0x21, 0x00, 0x00, 0xb4, 0x44, 0x00,
+    0x00, 0xb4, 0x6c, 0x00, 0x00, 0xb4, 0x97, 0x00, 0x00, 0xb4, 0xbb, 0x00,
+    0x00, 0xb4, 0xea, 0x00, 0x00, 0xb5, 0x11, 0x00, 0x00, 0xb5, 0x39, 0x00,
+    0x00, 0xb5, 0x60, 0x00, 0x00, 0xb5, 0x8a, 0x00, 0x00, 0xb5, 0xaf, 0x00,
+    0x00, 0xb5, 0xd3, 0x00, 0x00, 0xb5, 0xfb, 0x00, 0x00, 0xb6, 0x22, 0x00,
+    0x00, 0xb6, 0x47, 0x00, 0x00, 0xb6, 0x73, 0x00, 0x00, 0xb6, 0x98, 0x00,
+    0x00, 0xb6, 0xc0, 0x00, 0x00, 0xb6, 0xe6, 0x00, 0x00, 0xb7, 0x12, 0x00,
+    0x00, 0xb7, 0x37, 0x00, 0x00, 0xb7, 0x5c, 0x00, 0x00, 0xb7, 0x83, 0x00,
+    0x00, 0xb7, 0xb4, 0x00, 0x00, 0xb7, 0xda, 0x00, 0x00, 0xb7, 0xff, 0x00,
+    0x00, 0xb8, 0x25, 0x00, 0x00, 0xb8, 0x4c, 0x00, 0x00, 0xb8, 0x70, 0x00,
+    0x00, 0xb8, 0x92, 0x00, 0x00, 0xb8, 0xb6, 0x00, 0x00, 0xb8, 0xd7, 0x00,
+    0x00, 0xb8, 0xfc, 0x00, 0x00, 0xb9, 0x21, 0x00, 0x00, 0xb9, 0x48, 0x00,
+    0x00, 0xb9, 0x6c, 0x00, 0x00, 0xb9, 0x90, 0x00, 0x00, 0xb9, 0xb6, 0x00,
+    0x00, 0xb9, 0xdd, 0x00, 0x00, 0xba, 0x05, 0x00, 0x00, 0xba, 0x25, 0x00,
+    0x00, 0xba, 0x4a, 0x00, 0x00, 0xba, 0x71, 0x00, 0x00, 0xba, 0x99, 0x00,
+    0x00, 0xba, 0xbd, 0x00, 0x00, 0xba, 0xdf, 0x00, 0x00, 0xbb, 0x03, 0x00,
+    0x00, 0xbb, 0x25, 0x00, 0x00, 0xbb, 0x4c, 0x00, 0x00, 0xbb, 0x6f, 0x00,
+    0x00, 0xbb, 0x94, 0x00, 0x00, 0xbb, 0xb9, 0x00, 0x00, 0xbb, 0xde, 0x00,
+    0x00, 0xbc, 0x02, 0x00, 0x00, 0xbc, 0x23, 0x00, 0x00, 0xbc, 0x47, 0x00,
+    0x00, 0xbc, 0x6d, 0x00, 0x00, 0xbc, 0x95, 0x00, 0x00, 0xbc, 0xb5, 0x00,
+    0x00, 0xbc, 0xd9, 0x00, 0x00, 0xbd, 0x02, 0x00, 0x00, 0xbd, 0x24, 0x00,
+    0x00, 0xbd, 0x44, 0x00, 0x00, 0xbd, 0x6a, 0x00, 0x00, 0xbd, 0x92, 0x00,
+    0x00, 0xbd, 0xb4, 0x00, 0x00, 0xbd, 0xd8, 0x00, 0x00, 0xbd, 0xf9, 0x00,
+    0x00, 0xbe, 0x1e, 0x00, 0x00, 0xbe, 0x46, 0x00, 0x00, 0xbe, 0x6c, 0x00,
+    0x00, 0xbe, 0x93, 0x00, 0x00, 0xbe, 0xb9, 0x00, 0x00, 0xbe, 0xe7, 0x00,
+    0x00, 0xbf, 0x11, 0x00, 0x00, 0xbf, 0x39, 0x00, 0x00, 0xbf, 0x5d, 0x00,
+    0x00, 0xbf, 0x83, 0x00, 0x00, 0xbf, 0xad, 0x00, 0x00, 0xbf, 0xdb, 0x00,
+    0x00, 0xc0, 0x00, 0x00, 0x00, 0xc0, 0x22, 0x00, 0x00, 0xc0, 0x49, 0x00,
+    0x00, 0xc0, 0x6f, 0x00, 0x00, 0xc0, 0x96, 0x00, 0x00, 0xc0, 0xbc, 0x00,
+    0x00, 0xc0, 0xe0, 0x00, 0x00, 0xc1, 0x04, 0x00, 0x00, 0xc1, 0x28, 0x00,
+    0x00, 0xc1, 0x57, 0x00, 0x00, 0xc1, 0x83, 0x00, 0x00, 0xc1, 0xa3, 0x00,
+    0x00, 0xc1, 0xc5, 0x00, 0x00, 0xc1, 0xeb, 0x00, 0x00, 0xc2, 0x0c, 0x00,
+    0x00, 0xc2, 0x32, 0x00, 0x00, 0xc2, 0x56, 0x00, 0x00, 0xc2, 0x7d, 0x00,
+    0x00, 0xc2, 0xa3, 0x00, 0x00, 0xc2, 0xce, 0x00, 0x00, 0xc2, 0xf2, 0x00,
+    0x00, 0xc3, 0x14, 0x00, 0x00, 0xc3, 0x39, 0x00, 0x00, 0xc3, 0x5a, 0x00,
+    0x00, 0xc3, 0x85, 0x00, 0x00, 0xc3, 0xa8, 0x00, 0x00, 0xc3, 0xca, 0x00,
+    0x00, 0xc3, 0xef, 0x00, 0x00, 0xc4, 0x16, 0x00, 0x00, 0xc4, 0x35, 0x00,
+    0x00, 0xc4, 0x57, 0x00, 0x00, 0xc4, 0x81, 0x00, 0x00, 0xc4, 0xa7, 0x00,
+    0x00, 0xc4, 0xd1, 0x00, 0x00, 0xc4, 0xf9, 0x00, 0x00, 0xc5, 0x1d, 0x00,
+    0x00, 0xc5, 0x41, 0x00, 0x00, 0xc5, 0x6a, 0x00, 0x00, 0xc5, 0x98, 0x00,
+    0x00, 0xc5, 0xbc, 0x00, 0x00, 0xc5, 0xe3, 0x00, 0x00, 0xc6, 0x03, 0x00,
+    0x00, 0xc6, 0x27, 0x00, 0x00, 0xc6, 0x4c, 0x00, 0x00, 0xc6, 0x77, 0x00,
+    0x00, 0xc6, 0xa2, 0x00, 0x00, 0xc6, 0xcb, 0x00, 0x00, 0xc6, 0xed, 0x00,
+    0x00, 0xc7, 0x10, 0x00, 0x00, 0xc7, 0x34, 0x00, 0x00, 0xc7, 0x57, 0x00,
+    0x00, 0xc7, 0x7d, 0x00, 0x00, 0xc7, 0xa8, 0x00, 0x00, 0xc7, 0xcd, 0x00,
+    0x00, 0xc7, 0xf5, 0x00, 0x00, 0xc8, 0x1f, 0x00, 0x00, 0xc8, 0x46, 0x00,
+    0x00, 0xc8, 0x69, 0x00, 0x00, 0xc8, 0x93, 0x00, 0x00, 0xc8, 0xb7, 0x00,
+    0x00, 0xc8, 0xd9, 0x00, 0x00, 0xc8, 0xff, 0x00, 0x00, 0xc9, 0x29, 0x00,
+    0x00, 0xc9, 0x4c, 0x00, 0x00, 0xc9, 0x71, 0x00, 0x00, 0xc9, 0x96, 0x00,
+    0x00, 0xc9, 0xbc, 0x00, 0x00, 0xc9, 0xe0, 0x00, 0x00, 0xca, 0x0b, 0x00,
+    0x00, 0xca, 0x34, 0x00, 0x00, 0xca, 0x5d, 0x00, 0x00, 0xca, 0x84, 0x00,
+    0x00, 0xca, 0xa9, 0x00, 0x00, 0xca, 0xcb, 0x00, 0x00, 0xca, 0xee, 0x00,
+    0x00, 0xcb, 0x11, 0x00, 0x00, 0xcb, 0x3c, 0x00, 0x00, 0xcb, 0x63, 0x00,
+    0x00, 0xcb, 0x83, 0x00, 0x00, 0xcb, 0xa9, 0x00, 0x00, 0xcb, 0xcd, 0x00,
+    0x00, 0xcb, 0xf9, 0x00, 0x00, 0xcc, 0x20, 0x00, 0x00, 0xcc, 0x46, 0x00,
+    0x00, 0xcc, 0x6b, 0x00, 0x00, 0xcc, 0x94, 0x00, 0x00, 0xcc, 0xbc, 0x00,
+    0x00, 0xcc, 0xe0, 0x00, 0x00, 0xcd, 0x00, 0x00, 0x00, 0xcd, 0x27, 0x00,
+    0x00, 0xcd, 0x4c, 0x00, 0x00, 0xcd, 0x74, 0x00, 0x00, 0xcd, 0x98, 0x00,
+    0x00, 0xcd, 0xbd, 0x00, 0x00, 0xcd, 0xe2, 0x00, 0x00, 0xce, 0x08, 0x00,
+    0x00, 0xce, 0x2d, 0x00, 0x00, 0xce, 0x5d, 0x00, 0x00, 0xce, 0x81, 0x00,
+    0x00, 0xce, 0xa7, 0x00, 0x00, 0xce, 0xcb, 0x00, 0x00, 0xce, 0xf3, 0x00,
+    0x00, 0xcf, 0x1d, 0x00, 0x00, 0xcf, 0x3e, 0x00, 0x00, 0xcf, 0x63, 0x00,
+    0x00, 0xcf, 0x85, 0x00, 0x00, 0xcf, 0xab, 0x00, 0x00, 0xcf, 0xd0, 0x00,
+    0x00, 0xcf, 0xf9, 0x00, 0x00, 0xd0, 0x25, 0x00, 0x00, 0xd0, 0x4a, 0x00,
+    0x00, 0xd0, 0x6f, 0x00, 0x00, 0xd0, 0x96, 0x00, 0x00, 0xd0, 0xbb, 0x00,
+    0x00, 0xd0, 0xe0, 0x00, 0x00, 0xd1, 0x04, 0x00, 0x00, 0xd1, 0x28, 0x00,
+    0x00, 0xd1, 0x4b, 0x00, 0x00, 0xd1, 0x74, 0x00, 0x00, 0xd1, 0x9f, 0x00,
+    0x00, 0xd1, 0xc4, 0x00, 0x00, 0xd1, 0xe7, 0x00, 0x00, 0xd2, 0x0e, 0x00,
+    0x00, 0xd2, 0x3b, 0x00, 0x00, 0xd2, 0x5f, 0x00, 0x00, 0xd2, 0x8c, 0x00,
+    0x00, 0xd2, 0xad, 0x00, 0x00, 0xd2, 0xd2, 0x00, 0x00, 0xd2, 0xf5, 0x00,
+    0x00, 0xd3, 0x18, 0x00, 0x00, 0xd3, 0x43, 0x00, 0x00, 0xd3, 0x69, 0x00,
+    0x00, 0xd3, 0x90, 0x00, 0x00, 0xd3, 0xb4, 0x00, 0x00, 0xd3, 0xdb, 0x00,
+    0x00, 0xd4, 0x05, 0x00, 0x00, 0xd4, 0x2d, 0x00, 0x00, 0xd4, 0x53, 0x00,
+    0x00, 0xd4, 0x7c, 0x00, 0x00, 0xd4, 0xa0, 0x00, 0x00, 0xd4, 0xcd, 0x00,
+    0x00, 0xd4, 0xf5, 0x00, 0x00, 0xd5, 0x1a, 0x00, 0x00, 0xd5, 0x41, 0x00,
+    0x00, 0xd5, 0x67, 0x00, 0x00, 0xd5, 0x8c, 0x00, 0x00, 0xd5, 0xb6, 0x00,
+    0x00, 0xd5, 0xd8, 0x00, 0x00, 0xd5, 0xfb, 0x00, 0x00, 0xd6, 0x1e, 0x00,
+    0x00, 0xd6, 0x40, 0x00, 0x00, 0xd6, 0x65, 0x00, 0x00, 0xd6, 0x87, 0x00,
+    0x00, 0xd6, 0xad, 0x00, 0x00, 0xd6, 0xd1, 0x00, 0x00, 0xd6, 0xf1, 0x00,
+    0x00, 0xd7, 0x1e, 0x00, 0x00, 0xd7, 0x41, 0x00, 0x00, 0xd7, 0x64, 0x00,
+    0x00, 0xd7, 0x87, 0x00, 0x00, 0xd7, 0xac, 0x00, 0x00, 0xd7, 0xd0, 0x00,
+    0x00, 0xd7, 0xf3, 0x00, 0x00, 0xd8, 0x19, 0x00, 0x00, 0xd8, 0x3d, 0x00,
+    0x00, 0xd8, 0x5e, 0x00, 0x00, 0xd8, 0x8b, 0x00, 0x00, 0xd8, 0xae, 0x00,
+    0x00, 0xd8, 0xd4, 0x00, 0x00, 0xd8, 0xf8, 0x00, 0x00, 0xd9, 0x1a, 0x00,
+    0x00, 0xd9, 0x3e, 0x00, 0x00, 0xd9, 0x62, 0x00, 0x00, 0xd9, 0x87, 0x00,
+    0x00, 0xd9, 0xae, 0x00, 0x00, 0xd9, 0xd3, 0x00, 0x00, 0xd9, 0xfa, 0x00,
+    0x00, 0xda, 0x24, 0x00, 0x00, 0xda, 0x49, 0x00, 0x00, 0xda, 0x6d, 0x00,
+    0x00, 0xda, 0x93, 0x00, 0x00, 0xda, 0xbe, 0x00, 0x00, 0xda, 0xe4, 0x00,
+    0x00, 0xdb, 0x0e, 0x00, 0x00, 0xdb, 0x33, 0x00, 0x00, 0xdb, 0x61, 0x00,
+    0x00, 0xdb, 0x7f, 0x00, 0x00, 0xdb, 0xa9, 0x00, 0x00, 0xdb, 0xcd, 0x00,
+    0x00, 0xdb, 0xf4, 0x00, 0x00, 0xdc, 0x19, 0x00, 0x00, 0xdc, 0x3f, 0x00,
+    0x00, 0xdc, 0x68, 0x00, 0x00, 0xdc, 0x95, 0x00, 0x00, 0xdc, 0xbb, 0x00,
+    0x00, 0xdc, 0xe0, 0x00, 0x00, 0xdd, 0x06, 0x00, 0x00, 0xdd, 0x30, 0x00,
+    0x00, 0xdd, 0x5c, 0x00, 0x00, 0xdd, 0x83, 0x00, 0x00, 0xdd, 0xa8, 0x00,
+    0x00, 0xdd, 0xd4, 0x00, 0x00, 0xdd, 0xfe, 0x00, 0x00, 0xde, 0x26, 0x00,
+    0x00, 0xde, 0x4a, 0x00, 0x00, 0xde, 0x6c, 0x00, 0x00, 0xde, 0x96, 0x00,
+    0x00, 0xde, 0xbc, 0x00, 0x00, 0xde, 0xe2, 0x00, 0x00, 0xdf, 0x0a, 0x00,
+    0x00, 0xdf, 0x37, 0x00, 0x00, 0xdf, 0x5f, 0x00, 0x00, 0xdf, 0x85, 0x00,
+    0x00, 0xdf, 0xa9, 0x00, 0x00, 0xdf, 0xcc, 0x00, 0x00, 0xdf, 0xed, 0x00,
+    0x00, 0xe0, 0x10, 0x00, 0x00, 0xe0, 0x37, 0x00, 0x00, 0xe0, 0x5e, 0x00,
+    0x00, 0xe0, 0x83, 0x00, 0x00, 0xe0, 0xa9, 0x00, 0x00, 0xe0, 0xd2, 0x00,
+    0x00, 0xe0, 0xf3, 0x00, 0x00, 0xe1, 0x19, 0x00, 0x00, 0xe1, 0x46, 0x00,
+    0x00, 0xe1, 0x6e, 0x00, 0x00, 0xe1, 0x95, 0x00, 0x00, 0xe1, 0xb6, 0x00,
+    0x00, 0xe1, 0xdb, 0x00, 0x00, 0xe2, 0x04, 0x00, 0x00, 0xe2, 0x25, 0x00,
+    0x00, 0xe2, 0x4a, 0x00, 0x00, 0xe2, 0x6d, 0x00, 0x00, 0xe2, 0x9c, 0x00,
+    0x00, 0xe2, 0xc1, 0x00, 0x00, 0xe2, 0xe8, 0x00, 0x00, 0xe3, 0x0d, 0x00,
+    0x00, 0xe3, 0x38, 0x00, 0x00, 0xe3, 0x62, 0x00, 0x00, 0xe3, 0x85, 0x00,
+    0x00, 0xe3, 0xb2, 0x00, 0x00, 0xe3, 0xda, 0x00, 0x00, 0xe4, 0x04, 0x00,
+    0x00, 0xe4, 0x28, 0x00, 0x00, 0xe4, 0x50, 0x00, 0x00, 0xe4, 0x79, 0x00,
+    0x00, 0xe4, 0x9f, 0x00, 0x00, 0xe4, 0xc5, 0x00, 0x00, 0xe4, 0xec, 0x00,
+    0x00, 0xe5, 0x10, 0x00, 0x00, 0xe5, 0x37, 0x00, 0x00, 0xe5, 0x60, 0x00,
+    0x00, 0xe5, 0x85, 0x00, 0x00, 0xe5, 0xad, 0x00, 0x00, 0xe5, 0xd1, 0x00,
+    0x00, 0xe5, 0xf7, 0x00, 0x00, 0xe6, 0x1d, 0x00, 0x00, 0xe6, 0x46, 0x00,
+    0x00, 0xe6, 0x69, 0x00, 0x00, 0xe6, 0x90, 0x00, 0x00, 0xe6, 0xbb, 0x00,
+    0x00, 0xe6, 0xde, 0x00, 0x00, 0xe7, 0x06, 0x00, 0x00, 0xe7, 0x2e, 0x00,
+    0x00, 0xe7, 0x52, 0x00, 0x00, 0xe7, 0x74, 0x00, 0x00, 0xe7, 0x98, 0x00,
+    0x00, 0xe7, 0xbd, 0x00, 0x00, 0xe7, 0xeb, 0x00, 0x00, 0xe8, 0x0f, 0x00,
+    0x00, 0xe8, 0x37, 0x00, 0x00, 0xe8, 0x5b, 0x00, 0x00, 0xe8, 0x80, 0x00,
+    0x00, 0xe8, 0xa9, 0x00, 0x00, 0xe8, 0xca, 0x00, 0x00, 0xe8, 0xec, 0x00,
+    0x00, 0xe9, 0x13, 0x00, 0x00, 0xe9, 0x3c, 0x00, 0x00, 0xe9, 0x5e, 0x00,
+    0x00, 0xe9, 0x84, 0x00, 0x00, 0xe9, 0xad, 0x00, 0x00, 0xe9, 0xcf, 0x00,
+    0x00, 0xe9, 0xf3, 0x00, 0x00, 0xea, 0x1b, 0x00, 0x00, 0xea, 0x3f, 0x00,
+    0x00, 0xea, 0x67, 0x00, 0x00, 0xea, 0x93, 0x00, 0x00, 0xea, 0xbd, 0x00,
+    0x00, 0xea, 0xe0, 0x00, 0x00, 0xeb, 0x07, 0x00, 0x00, 0xeb, 0x2a, 0x00,
+    0x00, 0xeb, 0x53, 0x00, 0x00, 0xeb, 0x78, 0x00, 0x00, 0xeb, 0x9e, 0x00,
+    0x00, 0xeb, 0xbf, 0x00, 0x00, 0xeb, 0xdf, 0x00, 0x00, 0xec, 0x05, 0x00,
+    0x00, 0xec, 0x28, 0x00, 0x00, 0xec, 0x4d, 0x00, 0x00, 0xec, 0x70, 0x00,
+    0x00, 0xec, 0x98, 0x00, 0x00, 0xec, 0xbe, 0x00, 0x00, 0xec, 0xe2, 0x00,
+    0x00, 0xed, 0x07, 0x00, 0x00, 0xed, 0x2e, 0x00, 0x00, 0xed, 0x53, 0x00,
+    0x00, 0xed, 0x74, 0x00, 0x00, 0xed, 0x98, 0x00, 0x00, 0xed, 0xbc, 0x00,
+    0x00, 0xed, 0xe4, 0x00, 0x00, 0xee, 0x09, 0x00, 0x00, 0xee, 0x32, 0x00,
+    0x00, 0xee, 0x58, 0x00, 0x00, 0xee, 0x81, 0x00, 0x00, 0xee, 0xa5, 0x00,
+    0x00, 0xee, 0xc9, 0x00, 0x00, 0xee, 0xef, 0x00, 0x00, 0xef, 0x16, 0x00,
+    0x00, 0xef, 0x3f, 0x00, 0x00, 0xef, 0x5f, 0x00, 0x00, 0xef, 0x82, 0x00,
+    0x00, 0xef, 0xa7, 0x00, 0x00, 0xef, 0xc9, 0x00, 0x00, 0xef, 0xea, 0x00,
+    0x00, 0xf0, 0x14, 0x00, 0x00, 0xf0, 0x38, 0x00, 0x00, 0xf0, 0x5e, 0x00,
+    0x00, 0xf0, 0x7e, 0x00, 0x00, 0xf0, 0xa2, 0x00, 0x00, 0xf0, 0xc6, 0x00,
+    0x00, 0xf0, 0xf3, 0x00, 0x00, 0xf1, 0x18, 0x00, 0x00, 0xf1, 0x3c, 0x00,
+    0x00, 0xf1, 0x5e, 0x00, 0x00, 0xf1, 0x89, 0x00, 0x00, 0xf1, 0xb0, 0x00,
+    0x00, 0xf1, 0xd6, 0x00, 0x00, 0xf1, 0xfa, 0x00, 0x00, 0xf2, 0x1f, 0x00,
+    0x00, 0xf2, 0x46, 0x00, 0x00, 0xf2, 0x71, 0x00, 0x00, 0xf2, 0x9b, 0x00,
+    0x00, 0xf2, 0xbd, 0x00, 0x00, 0xf2, 0xe2, 0x00, 0x00, 0xf3, 0x07, 0x00,
+    0x00, 0xf3, 0x28, 0x00, 0x00, 0xf3, 0x4e, 0x00, 0x00, 0xf3, 0x72, 0x00,
+    0x00, 0xf3, 0x98, 0x00, 0x00, 0xf3, 0xb9, 0x00, 0x00, 0xf3, 0xdd, 0x00,
+    0x00, 0xf4, 0x08, 0x00, 0x00, 0xf4, 0x29, 0x00, 0x00, 0xf4, 0x4e, 0x00,
+    0x00, 0xf4, 0x6e, 0x00, 0x00, 0xf4, 0x99, 0x00, 0x00, 0xf4, 0xc0, 0x00,
+    0x00, 0xf4, 0xe1, 0x00, 0x00, 0xf5, 0x05, 0x00, 0x00, 0xf5, 0x2a, 0x00,
+    0x00, 0xf5, 0x52, 0x00, 0x00, 0xf5, 0x75, 0x00, 0x00, 0xf5, 0x9a, 0x00,
+    0x00, 0xf5, 0xc3, 0x00, 0x00, 0xf5, 0xe8, 0x00, 0x00, 0xf6, 0x0d, 0x00,
+    0x00, 0xf6, 0x31, 0x00, 0x00, 0xf6, 0x55, 0x00, 0x00, 0xf6, 0x79, 0x00,
+    0x00, 0xf6, 0xa1, 0x00, 0x00, 0xf6, 0xc5, 0x00, 0x00, 0xf6, 0xeb, 0x00,
+    0x00, 0xf7, 0x14, 0x00, 0x00, 0xf7, 0x35, 0x00, 0x00, 0xf7, 0x5e, 0x00,
+    0x00, 0xf7, 0x81, 0x00, 0x00, 0xf7, 0xa5, 0x00, 0x00, 0xf7, 0xca, 0x00,
+    0x00, 0xf7, 0xef, 0x00, 0x00, 0xf8, 0x14, 0x00, 0x00, 0xf8, 0x41, 0x00,
+    0x00, 0xf8, 0x67, 0x00, 0x00, 0xf8, 0x8b, 0x00, 0x00, 0xf8, 0xb6, 0x00,
+    0x00, 0xf8, 0xd6, 0x00, 0x00, 0xf9, 0x01, 0x00, 0x00, 0xf9, 0x26, 0x00,
+    0x00, 0xf9, 0x54, 0x00, 0x00, 0xf9, 0x7b, 0x00, 0x00, 0xf9, 0x9e, 0x00,
+    0x00, 0xf9, 0xc8, 0x00, 0x00, 0xf9, 0xe8, 0x00, 0x00, 0xfa, 0x0c, 0x00,
+    0x00, 0xfa, 0x30, 0x00, 0x00, 0xfa, 0x53, 0x00, 0x00, 0xfa, 0x77, 0x00,
+    0x00, 0xfa, 0x9a, 0x00, 0x00, 0xfa, 0xbd, 0x00, 0x00, 0xfa, 0xe1, 0x00,
+    0x00, 0xfb, 0x05, 0x00, 0x00, 0xfb, 0x2d, 0x00, 0x00, 0xfb, 0x56, 0x00,
+    0x00, 0xfb, 0x7a, 0x00, 0x00, 0xfb, 0x9d, 0x00, 0x00, 0xfb, 0xc5, 0x00,
+    0x00, 0xfb, 0xf5, 0x00, 0x00, 0xfc, 0x1c, 0x00, 0x00, 0xfc, 0x42, 0x00,
+    0x00, 0xfc, 0x67, 0x00, 0x00, 0xfc, 0x90, 0x00, 0x00, 0xfc, 0xbf, 0x00,
+    0x00, 0xfc, 0xe3, 0x00, 0x00, 0xfd, 0x07, 0x00, 0x00, 0xfd, 0x38, 0x00,
+    0x00, 0xfd, 0x5a, 0x00, 0x00, 0xfd, 0x81, 0x00, 0x00, 0xfd, 0xab, 0x00,
+    0x00, 0xfd, 0xd4, 0x00, 0x00, 0xfd, 0xf7, 0x00, 0x00, 0xfe, 0x1a, 0x00,
+    0x00, 0xfe, 0x3c, 0x00, 0x00, 0xfe, 0x6d, 0x00, 0x00, 0xfe, 0x97, 0x00,
+    0x00, 0xfe, 0xb7, 0x00, 0x00, 0xfe, 0xe4, 0x00, 0x00, 0xff, 0x0a, 0x00,
+    0x00, 0xff, 0x31, 0x00, 0x00, 0xff, 0x52, 0x00, 0x00, 0xff, 0x7c, 0x00,
+    0x00, 0xff, 0xa1, 0x00, 0x00, 0xff, 0xc5, 0x00, 0x00, 0xff, 0xea, 0x00,
+    0x01, 0x00, 0x0f, 0x00, 0x01, 0x00, 0x30, 0x00, 0x01, 0x00, 0x58, 0x00,
+    0x01, 0x00, 0x7d, 0x00, 0x01, 0x00, 0xa8, 0x00, 0x01, 0x00, 0xd3, 0x00,
+    0x01, 0x00, 0xfc, 0x00, 0x01, 0x01, 0x20, 0x00, 0x01, 0x01, 0x48, 0x00,
+    0x01, 0x01, 0x6d, 0x00, 0x01, 0x01, 0x92, 0x00, 0x01, 0x01, 0xba, 0x00,
+    0x01, 0x01, 0xdc, 0x00, 0x01, 0x01, 0xfd, 0x00, 0x01, 0x02, 0x2b, 0x00,
+    0x01, 0x02, 0x4e, 0x00, 0x01, 0x02, 0x78, 0x00, 0x01, 0x02, 0x9b, 0x00,
+    0x01, 0x02, 0xc3, 0x00, 0x01, 0x02, 0xe9, 0x00, 0x01, 0x03, 0x15, 0x00,
+    0x01, 0x03, 0x37, 0x00, 0x01, 0x03, 0x5c, 0x00, 0x01, 0x03, 0x8b, 0x00,
+    0x01, 0x03, 0xb0, 0x00, 0x01, 0x03, 0xd4, 0x00, 0x01, 0x03, 0xf7, 0x00,
+    0x01, 0x04, 0x1f, 0x00, 0x01, 0x04, 0x48, 0x00, 0x01, 0x04, 0x6f, 0x00,
+    0x01, 0x04, 0x90, 0x00, 0x01, 0x04, 0xb0, 0x00, 0x01, 0x04, 0xd3, 0x00,
+    0x01, 0x04, 0xf7, 0x00, 0x01, 0x05, 0x1d, 0x00, 0x01, 0x05, 0x45, 0x00,
+    0x01, 0x05, 0x73, 0x00, 0x01, 0x05, 0x99, 0x00, 0x01, 0x05, 0xb9, 0x00,
+    0x01, 0x05, 0xde, 0x00, 0x01, 0x06, 0x01, 0x00, 0x01, 0x06, 0x26, 0x00,
+    0x01, 0x06, 0x55, 0x00, 0x01, 0x06, 0x81, 0x00, 0x01, 0x06, 0xa9, 0x00,
+    0x01, 0x06, 0xce, 0x00, 0x01, 0x06, 0xfb, 0x00, 0x01, 0x07, 0x20, 0x00,
+    0x01, 0x07, 0x45, 0x00, 0x01, 0x07, 0x6b, 0x00, 0x01, 0x07, 0x90, 0x00,
+    0x01, 0x07, 0xb3, 0x00, 0x01, 0x07, 0xd8, 0x00, 0x01, 0x07, 0xfc, 0x00,
+    0x01, 0x08, 0x25, 0x00, 0x01, 0x08, 0x4b, 0x00, 0x01, 0x08, 0x70, 0x00,
+    0x01, 0x08, 0x97, 0x00, 0x01, 0x08, 0xc2, 0x00, 0x01, 0x08, 0xe9, 0x00,
+    0x01, 0x09, 0x0d, 0x00, 0x01, 0x09, 0x33, 0x00, 0x01, 0x09, 0x56, 0x00,
+    0x01, 0x09, 0x80, 0x00, 0x01, 0x09, 0xa3, 0x00, 0x01, 0x09, 0xc8, 0x00,
+    0x01, 0x09, 0xed, 0x00, 0x01, 0x0a, 0x0f, 0x00, 0x01, 0x0a, 0x33, 0x00,
+    0x01, 0x0a, 0x5b, 0x00, 0x01, 0x0a, 0x7c, 0x00, 0x01, 0x0a, 0xa4, 0x00,
+    0x01, 0x0a, 0xcf, 0x00, 0x01, 0x0a, 0xf7, 0x00, 0x01, 0x0b, 0x1e, 0x00,
+    0x01, 0x0b, 0x41, 0x00, 0x01, 0x0b, 0x67, 0x00, 0x01, 0x0b, 0x8c, 0x00,
+    0x01, 0x0b, 0xb0, 0x00, 0x01, 0x0b, 0xdc, 0x00, 0x01, 0x0c, 0x01, 0x00,
+    0x01, 0x0c, 0x25, 0x00, 0x01, 0x0c, 0x4b, 0x00, 0x01, 0x0c, 0x72, 0x00,
+    0x01, 0x0c, 0x97, 0x00, 0x01, 0x0c, 0xbc, 0x00, 0x01, 0x0c, 0xdd, 0x00,
+    0x01, 0x0c, 0xfd, 0x00, 0x01, 0x0d, 0x25, 0x00, 0x01, 0x0d, 0x4c, 0x00,
+    0x01, 0x0d, 0x74, 0x00, 0x01, 0x0d, 0x9e, 0x00, 0x01, 0x0d, 0xc2, 0x00,
+    0x01, 0x0d, 0xe9, 0x00, 0x01, 0x0e, 0x0f, 0x00, 0x01, 0x0e, 0x33, 0x00,
+    0x01, 0x0e, 0x56, 0x00, 0x01, 0x0e, 0x7d, 0x00, 0x01, 0x0e, 0xa2, 0x00,
+    0x01, 0x0e, 0xcc, 0x00, 0x01, 0x0e, 0xf2, 0x00, 0x01, 0x0f, 0x1b, 0x00,
+    0x01, 0x0f, 0x3e, 0x00, 0x01, 0x0f, 0x62, 0x00, 0x01, 0x0f, 0x86, 0x00,
+    0x01, 0x0f, 0xaf, 0x00, 0x01, 0x0f, 0xd0, 0x00, 0x01, 0x0f, 0xfa, 0x00,
+    0x01, 0x10, 0x25, 0x00, 0x01, 0x10, 0x50, 0x00, 0x01, 0x10, 0x76, 0x00,
+    0x01, 0x10, 0x99, 0x00, 0x01, 0x10, 0xbf, 0x00, 0x01, 0x10, 0xed, 0x00,
+    0x01, 0x11, 0x10, 0x00, 0x01, 0x11, 0x37, 0x00, 0x01, 0x11, 0x5f, 0x00,
+    0x01, 0x11, 0x82, 0x00, 0x01, 0x11, 0xa5, 0x00, 0x01, 0x11, 0xcb, 0x00,
+    0x01, 0x11, 0xf0, 0x00, 0x01, 0x12, 0x18, 0x00, 0x01, 0x12, 0x3c, 0x00,
+    0x01, 0x12, 0x62, 0x00, 0x01, 0x12, 0x86, 0x00, 0x01, 0x12, 0xa6, 0x00,
+    0x01, 0x12, 0xcd, 0x00, 0x01, 0x12, 0xf2, 0x00, 0x01, 0x13, 0x19, 0x00,
+    0x01, 0x13, 0x40, 0x00, 0x01, 0x13, 0x61, 0x00, 0x01, 0x13, 0x85, 0x00,
+    0x01, 0x13, 0xb0, 0x00, 0x01, 0x13, 0xd9, 0x00, 0x01, 0x14, 0x00, 0x00,
+    0x01, 0x14, 0x22, 0x00, 0x01, 0x14, 0x47, 0x00, 0x01, 0x14, 0x69, 0x00,
+    0x01, 0x14, 0x92, 0x00, 0x01, 0x14, 0xb7, 0x00, 0x01, 0x14, 0xda, 0x00,
+    0x01, 0x14, 0xfc, 0x00, 0x01, 0x15, 0x20, 0x00, 0x01, 0x15, 0x44, 0x00,
+    0x01, 0x15, 0x74, 0x00, 0x01, 0x15, 0x93, 0x00, 0x01, 0x15, 0xb9, 0x00,
+    0x01, 0x15, 0xe0, 0x00, 0x01, 0x16, 0x0b, 0x00, 0x01, 0x16, 0x34, 0x00,
+    0x01, 0x16, 0x5b, 0x00, 0x01, 0x16, 0x7c, 0x00, 0x01, 0x16, 0xa8, 0x00,
+    0x01, 0x16, 0xc8, 0x00, 0x01, 0x16, 0xf0, 0x00, 0x01, 0x17, 0x14, 0x00,
+    0x01, 0x17, 0x3d, 0x00, 0x01, 0x17, 0x63, 0x00, 0x01, 0x17, 0x89, 0x00,
+    0x01, 0x17, 0xab, 0x00, 0x01, 0x17, 0xd0, 0x00, 0x01, 0x17, 0xf3, 0x00,
+    0x01, 0x18, 0x19, 0x00, 0x01, 0x18, 0x3d, 0x00, 0x01, 0x18, 0x63, 0x00,
+    0x01, 0x18, 0x83, 0x00, 0x01, 0x18, 0xb0, 0x00, 0x01, 0x18, 0xd2, 0x00,
+    0x01, 0x18, 0xfd, 0x00, 0x01, 0x19, 0x2d, 0x00, 0x01, 0x19, 0x50, 0x00,
+    0x01, 0x19, 0x7e, 0x00, 0x01, 0x19, 0x9f, 0x00, 0x01, 0x19, 0xc2, 0x00,
+    0x01, 0x19, 0xe7, 0x00, 0x01, 0x1a, 0x0b, 0x00, 0x01, 0x1a, 0x2b, 0x00,
+    0x01, 0x1a, 0x4e, 0x00, 0x01, 0x1a, 0x75, 0x00, 0x01, 0x1a, 0x9a, 0x00,
+    0x01, 0x1a, 0xbd, 0x00, 0x01, 0x1a, 0xe1, 0x00, 0x01, 0x1b, 0x03, 0x00,
+    0x01, 0x1b, 0x29, 0x00, 0x01, 0x1b, 0x4f, 0x00, 0x01, 0x1b, 0x74, 0x00,
+    0x01, 0x1b, 0x98, 0x00, 0x01, 0x1b, 0xba, 0x00, 0x01, 0x1b, 0xde, 0x00,
+    0x01, 0x1c, 0x03, 0x00, 0x01, 0x1c, 0x2a, 0x00, 0x01, 0x1c, 0x59, 0x00,
+    0x01, 0x1c, 0x7e, 0x00, 0x01, 0x1c, 0xa4, 0x00, 0x01, 0x1c, 0xc9, 0x00,
+    0x01, 0x1c, 0xec, 0x00, 0x01, 0x1d, 0x0d, 0x00, 0x01, 0x1d, 0x31, 0x00,
+    0x01, 0x1d, 0x54, 0x00, 0x01, 0x1d, 0x7a, 0x00, 0x01, 0x1d, 0xa2, 0x00,
+    0x01, 0x1d, 0xc2, 0x00, 0x01, 0x1d, 0xe4, 0x00, 0x01, 0x1e, 0x06, 0x00,
+    0x01, 0x1e, 0x2f, 0x00, 0x01, 0x1e, 0x52, 0x00, 0x01, 0x1e, 0x79, 0x00,
+    0x01, 0x1e, 0xa3, 0x00, 0x01, 0x1e, 0xc9, 0x00, 0x01, 0x1e, 0xf4, 0x00,
+    0x01, 0x1f, 0x18, 0x00, 0x01, 0x1f, 0x41, 0x00, 0x01, 0x1f, 0x64, 0x00,
+    0x01, 0x1f, 0x85, 0x00, 0x01, 0x1f, 0xaa, 0x00, 0x01, 0x1f, 0xd2, 0x00,
+    0x01, 0x1f, 0xf8, 0x00, 0x01, 0x20, 0x1f, 0x00, 0x01, 0x20, 0x42, 0x00,
+    0x01, 0x20, 0x66, 0x00, 0x01, 0x20, 0x8b, 0x00, 0x01, 0x20, 0xb7, 0x00,
+    0x01, 0x20, 0xda, 0x00, 0x01, 0x21, 0x04, 0x00, 0x01, 0x21, 0x33, 0x00,
+    0x01, 0x21, 0x60, 0x00, 0x01, 0x21, 0x88, 0x00, 0x01, 0x21, 0xa9, 0x00,
+    0x01, 0x21, 0xd1, 0x00, 0x01, 0x21, 0xf8, 0x00, 0x01, 0x22, 0x1a, 0x00,
+    0x01, 0x22, 0x40, 0x00, 0x01, 0x22, 0x63, 0x00, 0x01, 0x22, 0x87, 0x00,
+    0x01, 0x22, 0xab, 0x00, 0x01, 0x22, 0xd0, 0x00, 0x01, 0x22, 0xf5, 0x00,
+    0x01, 0x23, 0x1a, 0x00, 0x01, 0x23, 0x41, 0x00, 0x01, 0x23, 0x64, 0x00,
+    0x01, 0x23, 0x8c, 0x00, 0x01, 0x23, 0xaf, 0x00, 0x01, 0x23, 0xdc, 0x00,
+    0x01, 0x23, 0xff, 0x00, 0x01, 0x24, 0x25, 0x00, 0x01, 0x24, 0x4a, 0x00,
+    0x01, 0x24, 0x6a, 0x00, 0x01, 0x24, 0x8e, 0x00, 0x01, 0x24, 0xb8, 0x00,
+    0x01, 0x24, 0xdb, 0x00, 0x01, 0x25, 0x06, 0x00, 0x01, 0x25, 0x2d, 0x00,
+    0x01, 0x25, 0x54, 0x00, 0x01, 0x25, 0x76, 0x00, 0x01, 0x25, 0x97, 0x00,
+    0x01, 0x25, 0xc0, 0x00, 0x01, 0x25, 0xea, 0x00, 0x01, 0x26, 0x10, 0x00,
+    0x01, 0x26, 0x32, 0x00, 0x01, 0x26, 0x58, 0x00, 0x01, 0x26, 0x7e, 0x00,
+    0x01, 0x26, 0xa2, 0x00, 0x01, 0x26, 0xc4, 0x00, 0x01, 0x26, 0xf2, 0x00,
+    0x01, 0x27, 0x1e, 0x00, 0x01, 0x27, 0x46, 0x00, 0x01, 0x27, 0x69, 0x00,
+    0x01, 0x27, 0x8d, 0x00, 0x01, 0x27, 0xb1, 0x00, 0x01, 0x27, 0xdc, 0x00,
+    0x01, 0x28, 0x00, 0x00, 0x01, 0x28, 0x20, 0x00, 0x01, 0x28, 0x3f, 0x00,
+    0x01, 0x28, 0x63, 0x00, 0x01, 0x28, 0x86, 0x00, 0x01, 0x28, 0xa9, 0x00,
+    0x01, 0x28, 0xd2, 0x00, 0x01, 0x28, 0xfb, 0x00, 0x01, 0x29, 0x1d, 0x00,
+    0x01, 0x29, 0x43, 0x00, 0x01, 0x29, 0x71, 0x00, 0x01, 0x29, 0x97, 0x00,
+    0x01, 0x29, 0xbd, 0x00, 0x01, 0x29, 0xe1, 0x00, 0x01, 0x2a, 0x03, 0x00,
+    0x01, 0x2a, 0x29, 0x00, 0x01, 0x2a, 0x4c, 0x00, 0x01, 0x2a, 0x71, 0x00,
+    0x01, 0x2a, 0x96, 0x00, 0x01, 0x2a, 0xc0, 0x00, 0x01, 0x2a, 0xe9, 0x00,
+    0x01, 0x2b, 0x10, 0x00, 0x01, 0x2b, 0x37, 0x00, 0x01, 0x2b, 0x5b, 0x00,
+    0x01, 0x2b, 0x87, 0x00, 0x01, 0x2b, 0xaa, 0x00, 0x01, 0x2b, 0xd0, 0x00,
+    0x01, 0x2b, 0xf7, 0x00, 0x01, 0x2c, 0x19, 0x00, 0x01, 0x2c, 0x3f, 0x00,
+    0x01, 0x2c, 0x66, 0x00, 0x01, 0x2c, 0x8a, 0x00, 0x01, 0x2c, 0xaf, 0x00,
+    0x01, 0x2c, 0xd5, 0x00, 0x01, 0x2c, 0xfc, 0x00, 0x01, 0x2d, 0x1c, 0x00,
+    0x01, 0x2d, 0x47, 0x00, 0x01, 0x2d, 0x6c, 0x00, 0x01, 0x2d, 0x98, 0x00,
+    0x01, 0x2d, 0xbc, 0x00, 0x01, 0x2d, 0xdf, 0x00, 0x01, 0x2e, 0x08, 0x00,
+    0x01, 0x2e, 0x2f, 0x00, 0x01, 0x2e, 0x58, 0x00, 0x01, 0x2e, 0x7a, 0x00,
+    0x01, 0x2e, 0x9d, 0x00, 0x01, 0x2e, 0xc2, 0x00, 0x01, 0x2e, 0xea, 0x00,
+    0x01, 0x2f, 0x0b, 0x00, 0x01, 0x2f, 0x36, 0x00, 0x01, 0x2f, 0x5c, 0x00,
+    0x01, 0x2f, 0x7f, 0x00, 0x01, 0x2f, 0xa0, 0x00, 0x01, 0x2f, 0xc7, 0x00,
+    0x01, 0x2f, 0xe8, 0x00, 0x01, 0x30, 0x13, 0x00, 0x01, 0x30, 0x38, 0x00,
+    0x01, 0x30, 0x5e, 0x00, 0x01, 0x30, 0x86, 0x00, 0x01, 0x30, 0xad, 0x00,
+    0x01, 0x30, 0xd5, 0x00, 0x01, 0x30, 0xfa, 0x00, 0x01, 0x31, 0x1d, 0x00,
+    0x01, 0x31, 0x45, 0x00, 0x01, 0x31, 0x71, 0x00, 0x01, 0x31, 0x92, 0x00,
+    0x01, 0x31, 0xb7, 0x00, 0x01, 0x31, 0xe1, 0x00, 0x01, 0x32, 0x01, 0x00,
+    0x01, 0x32, 0x27, 0x00, 0x01, 0x32, 0x4d, 0x00, 0x01, 0x32, 0x78, 0x00,
+    0x01, 0x32, 0x9c, 0x00, 0x01, 0x32, 0xc3, 0x00, 0x01, 0x32, 0xe7, 0x00,
+    0x01, 0x33, 0x0a, 0x00, 0x01, 0x33, 0x31, 0x00, 0x01, 0x33, 0x57, 0x00,
+    0x01, 0x33, 0x7e, 0x00, 0x01, 0x33, 0xa9, 0x00, 0x01, 0x33, 0xd1, 0x00,
+    0x01, 0x33, 0xfa, 0x00, 0x01, 0x34, 0x21, 0x00, 0x01, 0x34, 0x45, 0x00,
+    0x01, 0x34, 0x70, 0x00, 0x01, 0x34, 0x94, 0x00, 0x01, 0x34, 0xb6, 0x00,
+    0x01, 0x34, 0xdd, 0x00, 0x01, 0x35, 0x06, 0x00, 0x01, 0x35, 0x2a, 0x00,
+    0x01, 0x35, 0x4e, 0x00, 0x01, 0x35, 0x75, 0x00, 0x01, 0x35, 0x96, 0x00,
+    0x01, 0x35, 0xb6, 0x00, 0x01, 0x35, 0xdf, 0x00, 0x01, 0x36, 0x04, 0x00,
+    0x01, 0x36, 0x26, 0x00, 0x01, 0x36, 0x4c, 0x00, 0x01, 0x36, 0x76, 0x00,
+    0x01, 0x36, 0x9a, 0x00, 0x01, 0x36, 0xbf, 0x00, 0x01, 0x36, 0xea, 0x00,
+    0x01, 0x37, 0x0e, 0x00, 0x01, 0x37, 0x33, 0x00, 0x01, 0x37, 0x62, 0x00,
+    0x01, 0x37, 0x89, 0x00, 0x01, 0x37, 0xae, 0x00, 0x01, 0x37, 0xd0, 0x00,
+    0x01, 0x37, 0xf6, 0x00, 0x01, 0x38, 0x1f, 0x00, 0x01, 0x38, 0x44, 0x00,
+    0x01, 0x38, 0x64, 0x00, 0x01, 0x38, 0x8c, 0x00, 0x01, 0x38, 0xb0, 0x00,
+    0x01, 0x38, 0xd2, 0x00, 0x01, 0x38, 0xfb, 0x00, 0x01, 0x39, 0x27, 0x00,
+    0x01, 0x39, 0x4a, 0x00, 0x01, 0x39, 0x6f, 0x00, 0x01, 0x39, 0x97, 0x00,
+    0x01, 0x39, 0xc0, 0x00, 0x01, 0x39, 0xe5, 0x00, 0x01, 0x3a, 0x07, 0x00,
+    0x01, 0x3a, 0x30, 0x00, 0x01, 0x3a, 0x60, 0x00, 0x01, 0x3a, 0x85, 0x00,
+    0x01, 0x3a, 0xab, 0x00, 0x01, 0x3a, 0xd2, 0x00, 0x01, 0x3a, 0xf4, 0x00,
+    0x01, 0x3b, 0x19, 0x00, 0x01, 0x3b, 0x3d, 0x00, 0x01, 0x3b, 0x61, 0x00,
+    0x01, 0x3b, 0x86, 0x00, 0x01, 0x3b, 0xb6, 0x00, 0x01, 0x3b, 0xde, 0x00,
+    0x01, 0x3c, 0x01, 0x00, 0x01, 0x3c, 0x30, 0x00, 0x01, 0x3c, 0x56, 0x00,
+    0x01, 0x3c, 0x7c, 0x00, 0x01, 0x3c, 0x9d, 0x00, 0x01, 0x3c, 0xc2, 0x00,
+    0x01, 0x3c, 0xe9, 0x00, 0x01, 0x3d, 0x0e, 0x00, 0x01, 0x3d, 0x36, 0x00,
+    0x01, 0x3d, 0x5d, 0x00, 0x01, 0x3d, 0x81, 0x00, 0x01, 0x3d, 0xa6, 0x00,
+    0x01, 0x3d, 0xca, 0x00, 0x01, 0x3d, 0xf0, 0x00, 0x01, 0x3e, 0x17, 0x00,
+    0x01, 0x3e, 0x3d, 0x00, 0x01, 0x3e, 0x61, 0x00, 0x01, 0x3e, 0x83, 0x00,
+    0x01, 0x3e, 0xa7, 0x00, 0x01, 0x3e, 0xce, 0x00, 0x01, 0x3e, 0xf2, 0x00,
+    0x01, 0x3f, 0x19, 0x00, 0x01, 0x3f, 0x38, 0x00, 0x01, 0x3f, 0x63, 0x00,
+    0x01, 0x3f, 0x8c, 0x00, 0x01, 0x3f, 0xb5, 0x00, 0x01, 0x3f, 0xda, 0x00,
+    0x01, 0x3f, 0xfd, 0x00, 0x01, 0x40, 0x29, 0x00, 0x01, 0x40, 0x50, 0x00,
+    0x01, 0x40, 0x75, 0x00, 0x01, 0x40, 0x99, 0x00, 0x01, 0x40, 0xbf, 0x00,
+    0x01, 0x40, 0xe5, 0x00, 0x01, 0x41, 0x0d, 0x00, 0x01, 0x41, 0x37, 0x00,
+    0x01, 0x41, 0x5c, 0x00, 0x01, 0x41, 0x85, 0x00, 0x01, 0x41, 0xad, 0x00,
+    0x01, 0x41, 0xcd, 0x00, 0x01, 0x41, 0xf3, 0x00, 0x01, 0x42, 0x1d, 0x00,
+    0x01, 0x42, 0x46, 0x00, 0x01, 0x42, 0x6d, 0x00, 0x01, 0x42, 0x94, 0x00,
+    0x01, 0x42, 0xbd, 0x00, 0x01, 0x42, 0xe9, 0x00, 0x01, 0x43, 0x11, 0x00,
+    0x01, 0x43, 0x3a, 0x00, 0x01, 0x43, 0x5c, 0x00, 0x01, 0x43, 0x87, 0x00,
+    0x01, 0x43, 0xa8, 0x00, 0x01, 0x43, 0xcc, 0x00, 0x01, 0x43, 0xf8, 0x00,
+    0x01, 0x44, 0x1e, 0x00, 0x01, 0x44, 0x43, 0x00, 0x01, 0x44, 0x67, 0x00,
+    0x01, 0x44, 0x8a, 0x00, 0x01, 0x44, 0xb6, 0x00, 0x01, 0x44, 0xd8, 0x00,
+    0x01, 0x44, 0xfc, 0x00, 0x01, 0x45, 0x1d, 0x00, 0x01, 0x45, 0x45, 0x00,
+    0x01, 0x45, 0x69, 0x00, 0x01, 0x45, 0x96, 0x00, 0x01, 0x45, 0xb8, 0x00,
+    0x01, 0x45, 0xdc, 0x00, 0x01, 0x46, 0x00, 0x00, 0x01, 0x46, 0x27, 0x00,
+    0x01, 0x46, 0x52, 0x00, 0x01, 0x46, 0x76, 0x00, 0x01, 0x46, 0x9b, 0x00,
+    0x01, 0x46, 0xbe, 0x00, 0x01, 0x46, 0xe5, 0x00, 0x01, 0x47, 0x07, 0x00,
+    0x01, 0x47, 0x2a, 0x00, 0x01, 0x47, 0x4c, 0x00, 0x01, 0x47, 0x73, 0x00,
+    0x01, 0x47, 0x9d, 0x00, 0x01, 0x47, 0xc5, 0x00, 0x01, 0x47, 0xeb, 0x00,
+    0x01, 0x48, 0x12, 0x00, 0x01, 0x48, 0x36, 0x00, 0x01, 0x48, 0x5a, 0x00,
+    0x01, 0x48, 0x7d, 0x00, 0x01, 0x48, 0xa2, 0x00, 0x01, 0x48, 0xc9, 0x00,
+    0x01, 0x48, 0xf0, 0x00, 0x01, 0x49, 0x15, 0x00, 0x01, 0x49, 0x3c, 0x00,
+    0x01, 0x49, 0x5c, 0x00, 0x01, 0x49, 0x80, 0x00, 0x01, 0x49, 0xa8, 0x00,
+    0x01, 0x49, 0xcb, 0x00, 0x01, 0x49, 0xef, 0x00, 0x01, 0x4a, 0x14, 0x00,
+    0x01, 0x4a, 0x35, 0x00, 0x01, 0x4a, 0x57, 0x00, 0x01, 0x4a, 0x7c, 0x00,
+    0x01, 0x4a, 0xa2, 0x00, 0x01, 0x4a, 0xcb, 0x00, 0x01, 0x4a, 0xf0, 0x00,
+    0x01, 0x4b, 0x1a, 0x00, 0x01, 0x4b, 0x47, 0x00, 0x01, 0x4b, 0x69, 0x00,
+    0x01, 0x4b, 0x8c, 0x00, 0x01, 0x4b, 0xb1, 0x00, 0x01, 0x4b, 0xd9, 0x00,
+    0x01, 0x4c, 0x09, 0x00, 0x01, 0x4c, 0x2e, 0x00, 0x01, 0x4c, 0x58, 0x00,
+    0x01, 0x4c, 0x7f, 0x00, 0x01, 0x4c, 0xa7, 0x00, 0x01, 0x4c, 0xc9, 0x00,
+    0x01, 0x4c, 0xef, 0x00, 0x01, 0x4d, 0x1a, 0x00, 0x01, 0x4d, 0x3b, 0x00,
+    0x01, 0x4d, 0x61, 0x00, 0x01, 0x4d, 0x86, 0x00, 0x01, 0x4d, 0xad, 0x00,
+    0x01, 0x4d, 0xd3, 0x00, 0x01, 0x4d, 0xf7, 0x00, 0x01, 0x4e, 0x24, 0x00,
+    0x01, 0x4e, 0x48, 0x00, 0x01, 0x4e, 0x6d, 0x00, 0x01, 0x4e, 0x92, 0x00,
+    0x01, 0x4e, 0xbf, 0x00, 0x01, 0x4e, 0xe5, 0x00, 0x01, 0x4f, 0x14, 0x00,
+    0x01, 0x4f, 0x38, 0x00, 0x01, 0x4f, 0x5f, 0x00, 0x01, 0x4f, 0x86, 0x00,
+    0x01, 0x4f, 0xab, 0x00, 0x01, 0x4f, 0xd5, 0x00, 0x01, 0x4f, 0xfd, 0x00,
+    0x01, 0x50, 0x1f, 0x00, 0x01, 0x50, 0x42, 0x00, 0x01, 0x50, 0x63, 0x00,
+    0x01, 0x50, 0x8e, 0x00, 0x01, 0x50, 0xb4, 0x00, 0x01, 0x50, 0xe1, 0x00,
+    0x01, 0x51, 0x05, 0x00, 0x01, 0x51, 0x2d, 0x00, 0x01, 0x51, 0x53, 0x00,
+    0x01, 0x51, 0x78, 0x00, 0x01, 0x51, 0xa1, 0x00, 0x01, 0x51, 0xc9, 0x00,
+    0x01, 0x51, 0xee, 0x00, 0x01, 0x52, 0x15, 0x00, 0x01, 0x52, 0x41, 0x00,
+    0x01, 0x52, 0x66, 0x00, 0x01, 0x52, 0x8a, 0x00, 0x01, 0x52, 0xb4, 0x00,
+    0x01, 0x52, 0xd8, 0x00, 0x01, 0x53, 0x02, 0x00, 0x01, 0x53, 0x29, 0x00,
+    0x01, 0x53, 0x4e, 0x00, 0x01, 0x53, 0x75, 0x00, 0x01, 0x53, 0x9f, 0x00,
+    0x01, 0x53, 0xc9, 0x00, 0x01, 0x53, 0xee, 0x00, 0x01, 0x54, 0x19, 0x00,
+    0x01, 0x54, 0x3b, 0x00, 0x01, 0x54, 0x5f, 0x00, 0x01, 0x54, 0x83, 0x00,
+    0x01, 0x54, 0xaa, 0x00, 0x01, 0x54, 0xd3, 0x00, 0x01, 0x54, 0xfd, 0x00,
+    0x01, 0x55, 0x2a, 0x00, 0x01, 0x55, 0x51, 0x00, 0x01, 0x55, 0x7c, 0x00,
+    0x01, 0x55, 0xa4, 0x00, 0x01, 0x55, 0xc6, 0x00, 0x01, 0x55, 0xee, 0x00,
+    0x01, 0x56, 0x19, 0x00, 0x01, 0x56, 0x3f, 0x00, 0x01, 0x56, 0x63, 0x00,
+    0x01, 0x56, 0x87, 0x00, 0x01, 0x56, 0xb2, 0x00, 0x01, 0x56, 0xd9, 0x00,
+    0x01, 0x56, 0xfe, 0x00, 0x01, 0x57, 0x24, 0x00, 0x01, 0x57, 0x48, 0x00,
+    0x01, 0x57, 0x6d, 0x00, 0x01, 0x57, 0x92, 0x00, 0x01, 0x57, 0xb4, 0x00,
+    0x01, 0x57, 0xda, 0x00, 0x01, 0x58, 0x01, 0x00, 0x01, 0x58, 0x2b, 0x00,
+    0x01, 0x58, 0x50, 0x00, 0x01, 0x58, 0x75, 0x00, 0x01, 0x58, 0x9f, 0x00,
+    0x01, 0x58, 0xcd, 0x00, 0x01, 0x58, 0xf7, 0x00, 0x01, 0x59, 0x19, 0x00,
+    0x01, 0x59, 0x44, 0x00, 0x01, 0x59, 0x6a, 0x00, 0x01, 0x59, 0x90, 0x00,
+    0x01, 0x59, 0xb4, 0x00, 0x01, 0x59, 0xdb, 0x00, 0x01, 0x5a, 0x03, 0x00,
+    0x01, 0x5a, 0x29, 0x00, 0x01, 0x5a, 0x4e, 0x00, 0x01, 0x5a, 0x73, 0x00,
+    0x01, 0x5a, 0x99, 0x00, 0x01, 0x5a, 0xbf, 0x00, 0x01, 0x5a, 0xe4, 0x00,
+    0x01, 0x5b, 0x09, 0x00, 0x01, 0x5b, 0x30, 0x00, 0x01, 0x5b, 0x53, 0x00,
+    0x01, 0x5b, 0x80, 0x00, 0x01, 0x5b, 0xa6, 0x00, 0x01, 0x5b, 0xcb, 0x00,
+    0x01, 0x5b, 0xf8, 0x00, 0x01, 0x5c, 0x1c, 0x00, 0x01, 0x5c, 0x41, 0x00,
+    0x01, 0x5c, 0x6c, 0x00, 0x01, 0x5c, 0x95, 0x00, 0x01, 0x5c, 0xbf, 0x00,
+    0x01, 0x5c, 0xe3, 0x00, 0x01, 0x5d, 0x0d, 0x00, 0x01, 0x5d, 0x35, 0x00,
+    0x01, 0x5d, 0x5b, 0x00, 0x01, 0x5d, 0x80, 0x00, 0x01, 0x5d, 0xa5, 0x00,
+    0x01, 0x5d, 0xcd, 0x00, 0x01, 0x5d, 0xef, 0x00, 0x01, 0x5e, 0x16, 0x00,
+    0x01, 0x5e, 0x38, 0x00, 0x01, 0x5e, 0x59, 0x00, 0x01, 0x5e, 0x7d, 0x00,
+    0x01, 0x5e, 0xa3, 0x00, 0x01, 0x5e, 0xc7, 0x00, 0x01, 0x5e, 0xec, 0x00,
+    0x01, 0x5f, 0x12, 0x00, 0x01, 0x5f, 0x39, 0x00, 0x01, 0x5f, 0x67, 0x00,
+    0x01, 0x5f, 0x8b, 0x00, 0x01, 0x5f, 0xae, 0x00, 0x01, 0x5f, 0xce, 0x00,
+    0x01, 0x5f, 0xf7, 0x00, 0x01, 0x60, 0x22, 0x00, 0x01, 0x60, 0x47, 0x00,
+    0x01, 0x60, 0x6c, 0x00, 0x01, 0x60, 0x95, 0x00, 0x01, 0x60, 0xbb, 0x00,
+    0x01, 0x60, 0xe1, 0x00, 0x01, 0x61, 0x04, 0x00, 0x01, 0x61, 0x31, 0x00,
+    0x01, 0x61, 0x54, 0x00, 0x01, 0x61, 0x7a, 0x00, 0x01, 0x61, 0xa1, 0x00,
+    0x01, 0x61, 0xc2, 0x00, 0x01, 0x61, 0xe7, 0x00, 0x01, 0x62, 0x14, 0x00,
+    0x01, 0x62, 0x37, 0x00, 0x01, 0x62, 0x5a, 0x00, 0x01, 0x62, 0x82, 0x00,
+    0x01, 0x62, 0xa7, 0x00, 0x01, 0x62, 0xd0, 0x00, 0x01, 0x62, 0xf1, 0x00,
+    0x01, 0x63, 0x15, 0x00, 0x01, 0x63, 0x3c, 0x00, 0x01, 0x63, 0x61, 0x00,
+    0x01, 0x63, 0x83, 0x00, 0x01, 0x63, 0xac, 0x00, 0x01, 0x63, 0xd6, 0x00,
+    0x01, 0x63, 0xfe, 0x00, 0x01, 0x64, 0x23, 0x00, 0x01, 0x64, 0x4a, 0x00,
+    0x01, 0x64, 0x73, 0x00, 0x01, 0x64, 0x99, 0x00, 0x01, 0x64, 0xbc, 0x00,
+    0x01, 0x64, 0xe5, 0x00, 0x01, 0x65, 0x05, 0x00, 0x01, 0x65, 0x29, 0x00,
+    0x01, 0x65, 0x4f, 0x00, 0x01, 0x65, 0x75, 0x00, 0x01, 0x65, 0x98, 0x00,
+    0x01, 0x65, 0xb7, 0x00, 0x01, 0x65, 0xdf, 0x00, 0x01, 0x66, 0x02, 0x00,
+    0x01, 0x66, 0x2f, 0x00, 0x01, 0x66, 0x54, 0x00, 0x01, 0x66, 0x7c, 0x00,
+    0x01, 0x66, 0xa3, 0x00, 0x01, 0x66, 0xc9, 0x00, 0x01, 0x66, 0xf1, 0x00,
+    0x01, 0x67, 0x1b, 0x00, 0x01, 0x67, 0x3f, 0x00, 0x01, 0x67, 0x63, 0x00,
+    0x01, 0x67, 0x8a, 0x00, 0x01, 0x67, 0xab, 0x00, 0x01, 0x67, 0xd1, 0x00,
+    0x01, 0x67, 0xf6, 0x00, 0x01, 0x68, 0x1c, 0x00, 0x01, 0x68, 0x40, 0x00,
+    0x01, 0x68, 0x68, 0x00, 0x01, 0x68, 0x8a, 0x00, 0x01, 0x68, 0xb4, 0x00,
+    0x01, 0x68, 0xdd, 0x00, 0x01, 0x69, 0x02, 0x00, 0x01, 0x69, 0x28, 0x00,
+    0x01, 0x69, 0x50, 0x00, 0x01, 0x69, 0x74, 0x00, 0x01, 0x69, 0x99, 0x00,
+    0x01, 0x69, 0xbf, 0x00, 0x01, 0x69, 0xe5, 0x00, 0x01, 0x6a, 0x0e, 0x00,
+    0x01, 0x6a, 0x33, 0x00, 0x01, 0x6a, 0x5c, 0x00, 0x01, 0x6a, 0x87, 0x00,
+    0x01, 0x6a, 0xb0, 0x00, 0x01, 0x6a, 0xd6, 0x00, 0x01, 0x6a, 0xff, 0x00,
+    0x01, 0x6b, 0x26, 0x00, 0x01, 0x6b, 0x50, 0x00, 0x01, 0x6b, 0x75, 0x00,
+    0x01, 0x6b, 0x9c, 0x00, 0x01, 0x6b, 0xbf, 0x00, 0x01, 0x6b, 0xe6, 0x00,
+    0x01, 0x6c, 0x09, 0x00, 0x01, 0x6c, 0x2d, 0x00, 0x01, 0x6c, 0x58, 0x00,
+    0x01, 0x6c, 0x7d, 0x00, 0x01, 0x6c, 0xa0, 0x00, 0x01, 0x6c, 0xc4, 0x00,
+    0x01, 0x6c, 0xea, 0x00, 0x01, 0x6d, 0x0e, 0x00, 0x01, 0x6d, 0x34, 0x00,
+    0x01, 0x6d, 0x56, 0x00, 0x01, 0x6d, 0x76, 0x00, 0x01, 0x6d, 0x99, 0x00,
+    0x01, 0x6d, 0xbd, 0x00, 0x01, 0x6d, 0xde, 0x00, 0x01, 0x6e, 0x04, 0x00,
+    0x01, 0x6e, 0x2a, 0x00, 0x01, 0x6e, 0x53, 0x00, 0x01, 0x6e, 0x7d, 0x00,
+    0x01, 0x6e, 0xa4, 0x00, 0x01, 0x6e, 0xcf, 0x00, 0x01, 0x6e, 0xf7, 0x00,
+    0x01, 0x6f, 0x21, 0x00, 0x01, 0x6f, 0x47, 0x00, 0x01, 0x6f, 0x69, 0x00,
+    0x01, 0x6f, 0x8a, 0x00, 0x01, 0x6f, 0xaf, 0x00, 0x01, 0x6f, 0xd2, 0x00,
+    0x01, 0x6f, 0xfc, 0x00, 0x01, 0x70, 0x23, 0x00, 0x01, 0x70, 0x49, 0x00,
+    0x01, 0x70, 0x6c, 0x00, 0x01, 0x70, 0x93, 0x00, 0x01, 0x70, 0xb3, 0x00,
+    0x01, 0x70, 0xd7, 0x00, 0x01, 0x70, 0xfe, 0x00, 0x01, 0x71, 0x23, 0x00,
+    0x01, 0x71, 0x47, 0x00, 0x01, 0x71, 0x6a, 0x00, 0x01, 0x71, 0x8d, 0x00,
+    0x01, 0x71, 0xae, 0x00, 0x01, 0x71, 0xd7, 0x00, 0x01, 0x71, 0xff, 0x00,
+    0x01, 0x72, 0x25, 0x00, 0x01, 0x72, 0x49, 0x00, 0x01, 0x72, 0x74, 0x00,
+    0x01, 0x72, 0x96, 0x00, 0x01, 0x72, 0xbb, 0x00, 0x01, 0x72, 0xe0, 0x00,
+    0x01, 0x73, 0x00, 0x00, 0x01, 0x73, 0x1e, 0x00, 0x01, 0x73, 0x3d, 0x00,
+    0x01, 0x73, 0x62, 0x00, 0x01, 0x73, 0x89, 0x00, 0x01, 0x73, 0xae, 0x00,
+    0x01, 0x73, 0xd4, 0x00, 0x01, 0x73, 0xfa, 0x00, 0x01, 0x74, 0x1e, 0x00,
+    0x01, 0x74, 0x48, 0x00, 0x01, 0x74, 0x6e, 0x00, 0x01, 0x74, 0x98, 0x00,
+    0x01, 0x74, 0xbd, 0x00, 0x01, 0x74, 0xe1, 0x00, 0x01, 0x75, 0x0a, 0x00,
+    0x01, 0x75, 0x2f, 0x00, 0x01, 0x75, 0x56, 0x00, 0x01, 0x75, 0x79, 0x00,
+    0x01, 0x75, 0x9d, 0x00, 0x01, 0x75, 0xbf, 0x00, 0x01, 0x75, 0xe2, 0x00,
+    0x01, 0x76, 0x0c, 0x00, 0x01, 0x76, 0x32, 0x00, 0x01, 0x76, 0x57, 0x00,
+    0x01, 0x76, 0x7d, 0x00, 0x01, 0x76, 0xa4, 0x00, 0x01, 0x76, 0xc6, 0x00,
+    0x01, 0x76, 0xeb, 0x00, 0x01, 0x77, 0x11, 0x00, 0x01, 0x77, 0x3b, 0x00,
+    0x01, 0x77, 0x61, 0x00, 0x01, 0x77, 0x81, 0x00, 0x01, 0x77, 0xa5, 0x00,
+    0x01, 0x77, 0xcb, 0x00, 0x01, 0x77, 0xee, 0x00, 0x01, 0x78, 0x15, 0x00,
+    0x01, 0x78, 0x3f, 0x00, 0x01, 0x78, 0x6a, 0x00, 0x01, 0x78, 0x93, 0x00,
+    0x01, 0x78, 0xb7, 0x00, 0x01, 0x78, 0xe3, 0x00, 0x01, 0x79, 0x07, 0x00,
+    0x01, 0x79, 0x2b, 0x00, 0x01, 0x79, 0x56, 0x00, 0x01, 0x79, 0x79, 0x00,
+    0x01, 0x79, 0x9f, 0x00, 0x01, 0x79, 0xc6, 0x00, 0x01, 0x79, 0xec, 0x00,
+    0x01, 0x7a, 0x13, 0x00, 0x01, 0x7a, 0x38, 0x00, 0x01, 0x7a, 0x5c, 0x00,
+    0x01, 0x7a, 0x7f, 0x00, 0x01, 0x7a, 0xa5, 0x00, 0x01, 0x7a, 0xc9, 0x00,
+    0x01, 0x7a, 0xf1, 0x00, 0x01, 0x7b, 0x15, 0x00, 0x01, 0x7b, 0x36, 0x00,
+    0x01, 0x7b, 0x5b, 0x00, 0x01, 0x7b, 0x7f, 0x00, 0x01, 0x7b, 0xa6, 0x00,
+    0x01, 0x7b, 0xd4, 0x00, 0x01, 0x7b, 0xf7, 0x00, 0x01, 0x7c, 0x19, 0x00,
+    0x01, 0x7c, 0x40, 0x00, 0x01, 0x7c, 0x6b, 0x00, 0x01, 0x7c, 0x94, 0x00,
+    0x01, 0x7c, 0xbb, 0x00, 0x01, 0x7c, 0xe6, 0x00, 0x01, 0x7d, 0x09, 0x00,
+    0x01, 0x7d, 0x38, 0x00, 0x01, 0x7d, 0x5c, 0x00, 0x01, 0x7d, 0x82, 0x00,
+    0x01, 0x7d, 0xaf, 0x00, 0x01, 0x7d, 0xd4, 0x00, 0x01, 0x7d, 0xfd, 0x00,
+    0x01, 0x7e, 0x23, 0x00, 0x01, 0x7e, 0x46, 0x00, 0x01, 0x7e, 0x6c, 0x00,
+    0x01, 0x7e, 0x93, 0x00, 0x01, 0x7e, 0xba, 0x00, 0x01, 0x7e, 0xde, 0x00,
+    0x01, 0x7f, 0x06, 0x00, 0x01, 0x7f, 0x2b, 0x00, 0x01, 0x7f, 0x50, 0x00,
+    0x01, 0x7f, 0x7a, 0x00, 0x01, 0x7f, 0xa1, 0x00, 0x01, 0x7f, 0xc6, 0x00,
+    0x01, 0x7f, 0xf0, 0x00, 0x01, 0x80, 0x15, 0x00, 0x01, 0x80, 0x37, 0x00,
+    0x01, 0x80, 0x58, 0x00, 0x01, 0x80, 0x7f, 0x00, 0x01, 0x80, 0xa4, 0x00,
+    0x01, 0x80, 0xc8, 0x00, 0x01, 0x80, 0xeb, 0x00, 0x01, 0x81, 0x0e, 0x00,
+    0x01, 0x81, 0x37, 0x00, 0x01, 0x81, 0x60, 0x00, 0x01, 0x81, 0x81, 0x00,
+    0x01, 0x81, 0xa4, 0x00, 0x01, 0x81, 0xc4, 0x00, 0x01, 0x81, 0xe8, 0x00,
+    0x01, 0x82, 0x0b, 0x00, 0x01, 0x82, 0x34, 0x00, 0x01, 0x82, 0x53, 0x00,
+    0x01, 0x82, 0x83, 0x00, 0x01, 0x82, 0xaa, 0x00, 0x01, 0x82, 0xd4, 0x00,
+    0x01, 0x82, 0xf7, 0x00, 0x01, 0x83, 0x1e, 0x00, 0x01, 0x83, 0x42, 0x00,
+    0x01, 0x83, 0x66, 0x00, 0x01, 0x83, 0x8b, 0x00, 0x01, 0x83, 0xaf, 0x00,
+    0x01, 0x83, 0xd5, 0x00, 0x01, 0x83, 0xf9, 0x00, 0x01, 0x84, 0x22, 0x00,
+    0x01, 0x84, 0x4d, 0x00, 0x01, 0x84, 0x78, 0x00, 0x01, 0x84, 0x9d, 0x00,
+    0x01, 0x84, 0xc4, 0x00, 0x01, 0x84, 0xeb, 0x00, 0x01, 0x85, 0x11, 0x00,
+    0x01, 0x85, 0x3d, 0x00, 0x01, 0x85, 0x62, 0x00, 0x01, 0x85, 0x8b, 0x00,
+    0x01, 0x85, 0xaf, 0x00, 0x01, 0x85, 0xd7, 0x00, 0x01, 0x85, 0xfc, 0x00,
+    0x01, 0x86, 0x24, 0x00, 0x01, 0x86, 0x4c, 0x00, 0x01, 0x86, 0x6f, 0x00,
+    0x01, 0x86, 0x95, 0x00, 0x01, 0x86, 0xbc, 0x00, 0x01, 0x86, 0xdd, 0x00,
+    0x01, 0x87, 0x09, 0x00, 0x01, 0x87, 0x2e, 0x00, 0x01, 0x87, 0x52, 0x00,
+    0x01, 0x87, 0x7b, 0x00, 0x01, 0x87, 0xa7, 0x00, 0x01, 0x87, 0xce, 0x00,
+    0x01, 0x87, 0xf0, 0x00, 0x01, 0x88, 0x19, 0x00, 0x01, 0x88, 0x40, 0x00,
+    0x01, 0x88, 0x66, 0x00, 0x01, 0x88, 0x8c, 0x00, 0x01, 0x88, 0xad, 0x00,
+    0x01, 0x88, 0xd2, 0x00, 0x01, 0x88, 0xfb, 0x00, 0x01, 0x89, 0x1e, 0x00,
+    0x01, 0x89, 0x41, 0x00, 0x01, 0x89, 0x65, 0x00, 0x01, 0x89, 0x8c, 0x00,
+    0x01, 0x89, 0xb1, 0x00, 0x01, 0x89, 0xd7, 0x00, 0x01, 0x89, 0xfd, 0x00,
+    0x01, 0x8a, 0x26, 0x00, 0x01, 0x8a, 0x4d, 0x00, 0x01, 0x8a, 0x72, 0x00,
+    0x01, 0x8a, 0x97, 0x00, 0x01, 0x8a, 0xbb, 0x00, 0x01, 0x8a, 0xdd, 0x00,
+    0x01, 0x8b, 0x01, 0x00, 0x01, 0x8b, 0x25, 0x00, 0x01, 0x8b, 0x45, 0x00,
+    0x01, 0x8b, 0x69, 0x00, 0x01, 0x8b, 0x8f, 0x00, 0x01, 0x8b, 0xb3, 0x00,
+    0x01, 0x8b, 0xe2, 0x00, 0x01, 0x8c, 0x06, 0x00, 0x01, 0x8c, 0x25, 0x00,
+    0x01, 0x8c, 0x4d, 0x00, 0x01, 0x8c, 0x72, 0x00, 0x01, 0x8c, 0x91, 0x00,
+    0x01, 0x8c, 0xb6, 0x00, 0x01, 0x8c, 0xda, 0x00, 0x01, 0x8d, 0x03, 0x00,
+    0x01, 0x8d, 0x2a, 0x00, 0x01, 0x8d, 0x50, 0x00, 0x01, 0x8d, 0x71, 0x00,
+    0x01, 0x8d, 0x92, 0x00, 0x01, 0x8d, 0xb7, 0x00, 0x01, 0x8d, 0xde, 0x00,
+    0x01, 0x8e, 0x02, 0x00, 0x01, 0x8e, 0x27, 0x00, 0x01, 0x8e, 0x4b, 0x00,
+    0x01, 0x8e, 0x6e, 0x00, 0x01, 0x8e, 0x8f, 0x00, 0x01, 0x8e, 0xb8, 0x00,
+    0x01, 0x8e, 0xd9, 0x00, 0x01, 0x8f, 0x01, 0x00, 0x01, 0x8f, 0x25, 0x00,
+    0x01, 0x8f, 0x49, 0x00, 0x01, 0x8f, 0x6d, 0x00, 0x01, 0x8f, 0x94, 0x00,
+    0x01, 0x8f, 0xb7, 0x00, 0x01, 0x8f, 0xdf, 0x00, 0x01, 0x90, 0x01, 0x00,
+    0x01, 0x90, 0x26, 0x00, 0x01, 0x90, 0x4a, 0x00, 0x01, 0x90, 0x71, 0x00,
+    0x01, 0x90, 0x97, 0x00, 0x01, 0x90, 0xbb, 0x00, 0x01, 0x90, 0xde, 0x00,
+    0x01, 0x91, 0x02, 0x00, 0x01, 0x91, 0x2d, 0x00, 0x01, 0x91, 0x53, 0x00,
+    0x01, 0x91, 0x77, 0x00, 0x01, 0x91, 0xa4, 0x00, 0x01, 0x91, 0xd1, 0x00,
+    0x01, 0x91, 0xf8, 0x00, 0x01, 0x92, 0x20, 0x00, 0x01, 0x92, 0x4a, 0x00,
+    0x01, 0x92, 0x6f, 0x00, 0x01, 0x92, 0x96, 0x00, 0x01, 0x92, 0xbc, 0x00,
+    0x01, 0x92, 0xe4, 0x00, 0x01, 0x93, 0x07, 0x00, 0x01, 0x93, 0x35, 0x00,
+    0x01, 0x93, 0x58, 0x00, 0x01, 0x93, 0x7f, 0x00, 0x01, 0x93, 0xa1, 0x00,
+    0x01, 0x93, 0xc8, 0x00, 0x01, 0x93, 0xed, 0x00, 0x01, 0x94, 0x14, 0x00,
+    0x01, 0x94, 0x42, 0x00, 0x01, 0x94, 0x64, 0x00, 0x01, 0x94, 0x8c, 0x00,
+    0x01, 0x94, 0xb5, 0x00, 0x01, 0x94, 0xdf, 0x00, 0x01, 0x95, 0x03, 0x00,
+    0x01, 0x95, 0x2a, 0x00, 0x01, 0x95, 0x4e, 0x00, 0x01, 0x95, 0x72, 0x00,
+    0x01, 0x95, 0x9a, 0x00, 0x01, 0x95, 0xc5, 0x00, 0x01, 0x95, 0xe6, 0x00,
+    0x01, 0x96, 0x0c, 0x00, 0x01, 0x96, 0x2f, 0x00, 0x01, 0x96, 0x55, 0x00,
+    0x01, 0x96, 0x79, 0x00, 0x01, 0x96, 0xa0, 0x00, 0x01, 0x96, 0xc2, 0x00,
+    0x01, 0x96, 0xed, 0x00, 0x01, 0x97, 0x0e, 0x00, 0x01, 0x97, 0x35, 0x00,
+    0x01, 0x97, 0x57, 0x00, 0x01, 0x97, 0x7b, 0x00, 0x01, 0x97, 0xa1, 0x00,
+    0x01, 0x97, 0xcb, 0x00, 0x01, 0x97, 0xf2, 0x00, 0x01, 0x98, 0x19, 0x00,
+    0x01, 0x98, 0x42, 0x00, 0x01, 0x98, 0x65, 0x00, 0x01, 0x98, 0x92, 0x00,
+    0x01, 0x98, 0xba, 0x00, 0x01, 0x98, 0xdb, 0x00, 0x01, 0x99, 0x02, 0x00,
+    0x01, 0x99, 0x23, 0x00, 0x01, 0x99, 0x4c, 0x00, 0x01, 0x99, 0x6d, 0x00,
+    0x01, 0x99, 0x94, 0x00, 0x01, 0x99, 0xb6, 0x00, 0x01, 0x99, 0xdb, 0x00,
+    0x01, 0x99, 0xfe, 0x00, 0x01, 0x9a, 0x24, 0x00, 0x01, 0x9a, 0x46, 0x00,
+    0x01, 0x9a, 0x6a, 0x00, 0x01, 0x9a, 0x8f, 0x00, 0x01, 0x9a, 0xb1, 0x00,
+    0x01, 0x9a, 0xd4, 0x00, 0x01, 0x9b, 0x00, 0x00, 0x01, 0x9b, 0x29, 0x00,
+    0x01, 0x9b, 0x4d, 0x00, 0x01, 0x9b, 0x72, 0x00, 0x01, 0x9b, 0x97, 0x00,
+    0x01, 0x9b, 0xbe, 0x00, 0x01, 0x9b, 0xe5, 0x00, 0x01, 0x9c, 0x0b, 0x00,
+    0x01, 0x9c, 0x2f, 0x00, 0x01, 0x9c, 0x54, 0x00, 0x01, 0x9c, 0x7a, 0x00,
+    0x01, 0x9c, 0xa4, 0x00, 0x01, 0x9c, 0xcc, 0x00, 0x01, 0x9c, 0xf3, 0x00,
+    0x01, 0x9d, 0x1b, 0x00, 0x01, 0x9d, 0x43, 0x00, 0x01, 0x9d, 0x6d, 0x00,
+    0x01, 0x9d, 0x99, 0x00, 0x01, 0x9d, 0xbe, 0x00, 0x01, 0x9d, 0xe0, 0x00,
+    0x01, 0x9e, 0x07, 0x00, 0x01, 0x9e, 0x2c, 0x00, 0x01, 0x9e, 0x57, 0x00,
+    0x01, 0x9e, 0x7d, 0x00, 0x01, 0x9e, 0xa3, 0x00, 0x01, 0x9e, 0xc6, 0x00,
+    0x01, 0x9e, 0xee, 0x00, 0x01, 0x9f, 0x12, 0x00, 0x01, 0x9f, 0x35, 0x00,
+    0x01, 0x9f, 0x5d, 0x00, 0x01, 0x9f, 0x82, 0x00, 0x01, 0x9f, 0xa4, 0x00,
+    0x01, 0x9f, 0xcd, 0x00, 0x01, 0x9f, 0xf2, 0x00, 0x01, 0xa0, 0x19, 0x00,
+    0x01, 0xa0, 0x3d, 0x00, 0x01, 0xa0, 0x66, 0x00, 0x01, 0xa0, 0x8a, 0x00,
+    0x01, 0xa0, 0xb3, 0x00, 0x01, 0xa0, 0xdd, 0x00, 0x01, 0xa1, 0x04, 0x00,
+    0x01, 0xa1, 0x2b, 0x00, 0x01, 0xa1, 0x52, 0x00, 0x01, 0xa1, 0x78, 0x00,
+    0x01, 0xa1, 0x9b, 0x00, 0x01, 0xa1, 0xc7, 0x00, 0x01, 0xa1, 0xef, 0x00,
+    0x01, 0xa2, 0x15, 0x00, 0x01, 0xa2, 0x38, 0x00, 0x01, 0xa2, 0x61, 0x00,
+    0x01, 0xa2, 0x82, 0x00, 0x01, 0xa2, 0xaa, 0x00, 0x01, 0xa2, 0xce, 0x00,
+    0x01, 0xa2, 0xf3, 0x00, 0x01, 0xa3, 0x17, 0x00, 0x01, 0xa3, 0x3b, 0x00,
+    0x01, 0xa3, 0x60, 0x00, 0x01, 0xa3, 0x85, 0x00, 0x01, 0xa3, 0xb0, 0x00,
+    0x01, 0xa3, 0xd7, 0x00, 0x01, 0xa3, 0xfc, 0x00, 0x01, 0xa4, 0x20, 0x00,
+    0x01, 0xa4, 0x49, 0x00, 0x01, 0xa4, 0x72, 0x00, 0x01, 0xa4, 0x96, 0x00,
+    0x01, 0xa4, 0xb8, 0x00, 0x01, 0xa4, 0xe4, 0x00, 0x01, 0xa5, 0x09, 0x00,
+    0x01, 0xa5, 0x2e, 0x00, 0x01, 0xa5, 0x52, 0x00, 0x01, 0xa5, 0x7f, 0x00,
+    0x01, 0xa5, 0xa1, 0x00, 0x01, 0xa5, 0xc4, 0x00, 0x01, 0xa5, 0xf2, 0x00,
+    0x01, 0xa6, 0x19, 0x00, 0x01, 0xa6, 0x45, 0x00, 0x01, 0xa6, 0x68, 0x00,
+    0x01, 0xa6, 0x8c, 0x00, 0x01, 0xa6, 0xb4, 0x00, 0x01, 0xa6, 0xdd, 0x00,
+    0x01, 0xa7, 0x02, 0x00, 0x01, 0xa7, 0x27, 0x00, 0x01, 0xa7, 0x4a, 0x00,
+    0x01, 0xa7, 0x6f, 0x00, 0x01, 0xa7, 0x95, 0x00, 0x01, 0xa7, 0xbd, 0x00,
+    0x01, 0xa7, 0xe2, 0x00, 0x01, 0xa8, 0x08, 0x00, 0x01, 0xa8, 0x2e, 0x00,
+    0x01, 0xa8, 0x54, 0x00, 0x01, 0xa8, 0x76, 0x00, 0x01, 0xa8, 0x99, 0x00,
+    0x01, 0xa8, 0xbe, 0x00, 0x01, 0xa8, 0xe3, 0x00, 0x01, 0xa9, 0x07, 0x00,
+    0x01, 0xa9, 0x32, 0x00, 0x01, 0xa9, 0x57, 0x00, 0x01, 0xa9, 0x79, 0x00,
+    0x01, 0xa9, 0xa4, 0x00, 0x01, 0xa9, 0xcc, 0x00, 0x01, 0xa9, 0xf2, 0x00,
+    0x01, 0xaa, 0x1a, 0x00, 0x01, 0xaa, 0x40, 0x00, 0x01, 0xaa, 0x66, 0x00,
+    0x01, 0xaa, 0x8c, 0x00, 0x01, 0xaa, 0xb2, 0x00, 0x01, 0xaa, 0xd6, 0x00,
+    0x01, 0xaa, 0xfa, 0x00, 0x01, 0xab, 0x1d, 0x00, 0x01, 0xab, 0x3f, 0x00,
+    0x01, 0xab, 0x62, 0x00, 0x01, 0xab, 0x8b, 0x00, 0x01, 0xab, 0xae, 0x00,
+    0x01, 0xab, 0xda, 0x00, 0x01, 0xac, 0x02, 0x00, 0x01, 0xac, 0x2b, 0x00,
+    0x01, 0xac, 0x58, 0x00, 0x01, 0xac, 0x7d, 0x00, 0x01, 0xac, 0xa5, 0x00,
+    0x01, 0xac, 0xca, 0x00, 0x01, 0xac, 0xef, 0x00, 0x01, 0xad, 0x13, 0x00,
+    0x01, 0xad, 0x34, 0x00, 0x01, 0xad, 0x5d, 0x00, 0x01, 0xad, 0x7e, 0x00,
+    0x01, 0xad, 0xa1, 0x00, 0x01, 0xad, 0xc6, 0x00, 0x01, 0xad, 0xf3, 0x00,
+    0x01, 0xae, 0x1c, 0x00, 0x01, 0xae, 0x44, 0x00, 0x01, 0xae, 0x6b, 0x00,
+    0x01, 0xae, 0x98, 0x00, 0x01, 0xae, 0xbf, 0x00, 0x01, 0xae, 0xe1, 0x00,
+    0x01, 0xaf, 0x06, 0x00, 0x01, 0xaf, 0x2a, 0x00, 0x01, 0xaf, 0x50, 0x00,
+    0x01, 0xaf, 0x74, 0x00, 0x01, 0xaf, 0x99, 0x00, 0x01, 0xaf, 0xba, 0x00,
+    0x01, 0xaf, 0xe1, 0x00, 0x01, 0xb0, 0x07, 0x00, 0x01, 0xb0, 0x29, 0x00,
+    0x01, 0xb0, 0x4d, 0x00, 0x01, 0xb0, 0x75, 0x00, 0x01, 0xb0, 0x9e, 0x00,
+    0x01, 0xb0, 0xc8, 0x00, 0x01, 0xb0, 0xed, 0x00, 0x01, 0xb1, 0x15, 0x00,
+    0x01, 0xb1, 0x3d, 0x00, 0x01, 0xb1, 0x62, 0x00, 0x01, 0xb1, 0x84, 0x00,
+    0x01, 0xb1, 0xaa, 0x00, 0x01, 0xb1, 0xd0, 0x00, 0x01, 0xb1, 0xf5, 0x00,
+    0x01, 0xb2, 0x1a, 0x00, 0x01, 0xb2, 0x3e, 0x00, 0x01, 0xb2, 0x64, 0x00,
+    0x01, 0xb2, 0x87, 0x00, 0x01, 0xb2, 0xb2, 0x00, 0x01, 0xb2, 0xdc, 0x00,
+    0x01, 0xb2, 0xfe, 0x00, 0x01, 0xb3, 0x2b, 0x00, 0x01, 0xb3, 0x52, 0x00,
+    0x01, 0xb3, 0x7b, 0x00, 0x01, 0xb3, 0xa3, 0x00, 0x01, 0xb3, 0xc6, 0x00,
+    0x01, 0xb3, 0xec, 0x00, 0x01, 0xb4, 0x18, 0x00, 0x01, 0xb4, 0x43, 0x00,
+    0x01, 0xb4, 0x6b, 0x00, 0x01, 0xb4, 0x91, 0x00, 0x01, 0xb4, 0xb3, 0x00,
+    0x01, 0xb4, 0xd7, 0x00, 0x01, 0xb5, 0x02, 0x00, 0x01, 0xb5, 0x28, 0x00,
+    0x01, 0xb5, 0x4b, 0x00, 0x01, 0xb5, 0x72, 0x00, 0x01, 0xb5, 0x96, 0x00,
+    0x01, 0xb5, 0xc0, 0x00, 0x01, 0xb5, 0xe5, 0x00, 0x01, 0xb6, 0x0a, 0x00,
+    0x01, 0xb6, 0x30, 0x00, 0x01, 0xb6, 0x57, 0x00, 0x01, 0xb6, 0x80, 0x00,
+    0x01, 0xb6, 0xad, 0x00, 0x01, 0xb6, 0xcd, 0x00, 0x01, 0xb6, 0xf8, 0x00,
+    0x01, 0xb7, 0x1c, 0x00, 0x01, 0xb7, 0x44, 0x00, 0x01, 0xb7, 0x68, 0x00,
+    0x01, 0xb7, 0x8a, 0x00, 0x01, 0xb7, 0xb5, 0x00, 0x01, 0xb7, 0xdc, 0x00,
+    0x01, 0xb7, 0xfe, 0x00, 0x01, 0xb8, 0x21, 0x00, 0x01, 0xb8, 0x4a, 0x00,
+    0x01, 0xb8, 0x6e, 0x00, 0x01, 0xb8, 0x93, 0x00, 0x01, 0xb8, 0xb9, 0x00,
+    0x01, 0xb8, 0xde, 0x00, 0x01, 0xb9, 0x04, 0x00, 0x01, 0xb9, 0x28, 0x00,
+    0x01, 0xb9, 0x4d, 0x00, 0x01, 0xb9, 0x74, 0x00, 0x01, 0xb9, 0x9c, 0x00,
+    0x01, 0xb9, 0xc0, 0x00, 0x01, 0xb9, 0xe6, 0x00, 0x01, 0xba, 0x0c, 0x00,
+    0x01, 0xba, 0x2f, 0x00, 0x01, 0xba, 0x53, 0x00, 0x01, 0xba, 0x7b, 0x00,
+    0x01, 0xba, 0x9e, 0x00, 0x01, 0xba, 0xc9, 0x00, 0x01, 0xba, 0xee, 0x00,
+    0x01, 0xbb, 0x14, 0x00, 0x01, 0xbb, 0x40, 0x00, 0x01, 0xbb, 0x66, 0x00,
+    0x01, 0xbb, 0x8d, 0x00, 0x01, 0xbb, 0xba, 0x00, 0x01, 0xbb, 0xe0, 0x00,
+    0x01, 0xbc, 0x01, 0x00, 0x01, 0xbc, 0x29, 0x00, 0x01, 0xbc, 0x54, 0x00,
+    0x01, 0xbc, 0x7c, 0x00, 0x01, 0xbc, 0xa1, 0x00, 0x01, 0xbc, 0xc1, 0x00,
+    0x01, 0xbc, 0xe3, 0x00, 0x01, 0xbd, 0x07, 0x00, 0x01, 0xbd, 0x35, 0x00,
+    0x01, 0xbd, 0x5f, 0x00, 0x01, 0xbd, 0x84, 0x00, 0x01, 0xbd, 0xa6, 0x00,
+    0x01, 0xbd, 0xd2, 0x00, 0x01, 0xbd, 0xf8, 0x00, 0x01, 0xbe, 0x22, 0x00,
+    0x01, 0xbe, 0x45, 0x00, 0x01, 0xbe, 0x66, 0x00, 0x01, 0xbe, 0x8c, 0x00,
+    0x01, 0xbe, 0xb2, 0x00, 0x01, 0xbe, 0xd3, 0x00, 0x01, 0xbe, 0xf8, 0x00,
+    0x01, 0xbf, 0x1d, 0x00, 0x01, 0xbf, 0x43, 0x00, 0x01, 0xbf, 0x69, 0x00,
+    0x01, 0xbf, 0x9a, 0x00, 0x01, 0xbf, 0xc3, 0x00, 0x01, 0xbf, 0xe6, 0x00,
+    0x01, 0xc0, 0x08, 0x00, 0x01, 0xc0, 0x2a, 0x00, 0x01, 0xc0, 0x4d, 0x00,
+    0x01, 0xc0, 0x76, 0x00, 0x01, 0xc0, 0x97, 0x00, 0x01, 0xc0, 0xbb, 0x00,
+    0x01, 0xc0, 0xe4, 0x00, 0x01, 0xc1, 0x09, 0x00, 0x01, 0xc1, 0x2c, 0x00,
+    0x01, 0xc1, 0x5c, 0x00, 0x01, 0xc1, 0x81, 0x00, 0x01, 0xc1, 0xab, 0x00,
+    0x01, 0xc1, 0xcf, 0x00, 0x01, 0xc1, 0xfd, 0x00, 0x01, 0xc2, 0x1e, 0x00,
+    0x01, 0xc2, 0x44, 0x00, 0x01, 0xc2, 0x6c, 0x00, 0x01, 0xc2, 0x92, 0x00,
+    0x01, 0xc2, 0xba, 0x00, 0x01, 0xc2, 0xe0, 0x00, 0x01, 0xc3, 0x08, 0x00,
+    0x01, 0xc3, 0x2c, 0x00, 0x01, 0xc3, 0x51, 0x00, 0x01, 0xc3, 0x75, 0x00,
+    0x01, 0xc3, 0x9e, 0x00, 0x01, 0xc3, 0xc3, 0x00, 0x01, 0xc3, 0xe5, 0x00,
+    0x01, 0xc4, 0x0b, 0x00, 0x01, 0xc4, 0x33, 0x00, 0x01, 0xc4, 0x5c, 0x00,
+    0x01, 0xc4, 0x84, 0x00, 0x01, 0xc4, 0xa5, 0x00, 0x01, 0xc4, 0xcc, 0x00,
+    0x01, 0xc4, 0xf3, 0x00, 0x01, 0xc5, 0x17, 0x00, 0x01, 0xc5, 0x3b, 0x00,
+    0x01, 0xc5, 0x60, 0x00, 0x01, 0xc5, 0x82, 0x00, 0x01, 0xc5, 0xac, 0x00,
+    0x01, 0xc5, 0xcf, 0x00, 0x01, 0xc5, 0xfa, 0x00, 0x01, 0xc6, 0x21, 0x00,
+    0x01, 0xc6, 0x41, 0x00, 0x01, 0xc6, 0x6a, 0x00, 0x01, 0xc6, 0x8f, 0x00,
+    0x01, 0xc6, 0xb8, 0x00, 0x01, 0xc6, 0xdc, 0x00, 0x01, 0xc6, 0xff, 0x00,
+    0x01, 0xc7, 0x24, 0x00, 0x01, 0xc7, 0x47, 0x00, 0x01, 0xc7, 0x6c, 0x00,
+    0x01, 0xc7, 0x93, 0x00, 0x01, 0xc7, 0xb9, 0x00, 0x01, 0xc7, 0xdf, 0x00,
+    0x01, 0xc8, 0x02, 0x00, 0x01, 0xc8, 0x29, 0x00, 0x01, 0xc8, 0x52, 0x00,
+    0x01, 0xc8, 0x78, 0x00, 0x01, 0xc8, 0x9e, 0x00, 0x01, 0xc8, 0xc3, 0x00,
+    0x01, 0xc8, 0xe6, 0x00, 0x01, 0xc9, 0x0f, 0x00, 0x01, 0xc9, 0x39, 0x00,
+    0x01, 0xc9, 0x5e, 0x00, 0x01, 0xc9, 0x85, 0x00, 0x01, 0xc9, 0xad, 0x00,
+    0x01, 0xc9, 0xd0, 0x00, 0x01, 0xc9, 0xf2, 0x00, 0x01, 0xca, 0x14, 0x00,
+    0x01, 0xca, 0x3f, 0x00, 0x01, 0xca, 0x66, 0x00, 0x01, 0xca, 0x8a, 0x00,
+    0x01, 0xca, 0xb0, 0x00, 0x01, 0xca, 0xd6, 0x00, 0x01, 0xca, 0xfb, 0x00,
+    0x01, 0xcb, 0x20, 0x00, 0x01, 0xcb, 0x44, 0x00, 0x01, 0xcb, 0x6c, 0x00,
+    0x01, 0xcb, 0x8d, 0x00, 0x01, 0xcb, 0xb1, 0x00, 0x01, 0xcb, 0xd6, 0x00,
+    0x01, 0xcb, 0xfc, 0x00, 0x01, 0xcc, 0x26, 0x00, 0x01, 0xcc, 0x4c, 0x00,
+    0x01, 0xcc, 0x6f, 0x00, 0x01, 0xcc, 0x92, 0x00, 0x01, 0xcc, 0xb3, 0x00,
+    0x01, 0xcc, 0xd9, 0x00, 0x01, 0xcc, 0xff, 0x00, 0x00, 0x00, 0x26, 0x00,
+    0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0xa2, 0x00,
+    0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0xed, 0x00, 0x00, 0x01, 0x13, 0x00,
+    0x00, 0x01, 0x37, 0x00, 0x00, 0x01, 0x5a, 0x00, 0x00, 0x01, 0x89, 0x00,
+    0x00, 0x01, 0xb4, 0x00, 0x00, 0x01, 0xd8, 0x00, 0x00, 0x02, 0x02, 0x00,
+    0x00, 0x02, 0x26, 0x00, 0x00, 0x02, 0x50, 0x00, 0x00, 0x02, 0x74, 0x00,
+    0x00, 0x02, 0x9c, 0x00, 0x00, 0x02, 0xc2, 0x00, 0x00, 0x02, 0xe8, 0x00,
+    0x00, 0x03, 0x12, 0x00, 0x00, 0x03, 0x34, 0x00, 0x00, 0x03, 0x5f, 0x00,
+    0x00, 0x03, 0x8b, 0x00, 0x00, 0x03, 0xae, 0x00, 0x00, 0x03, 0xd1, 0x00,
+    0x00, 0x03, 0xf5, 0x00, 0x00, 0x04, 0x1b, 0x00, 0x00, 0x04, 0x3f, 0x00,
+    0x00, 0x04, 0x64, 0x00, 0x00, 0x04, 0x8b, 0x00, 0x00, 0x04, 0xae, 0x00,
+    0x00, 0x04, 0xd1, 0x00, 0x00, 0x04, 0xf4, 0x00, 0x00, 0x05, 0x19, 0x00,
+    0x00, 0x05, 0x46, 0x00, 0x00, 0x05, 0x6d, 0x00, 0x00, 0x05, 0x92, 0x00,
+    0x00, 0x05, 0xb8, 0x00, 0x00, 0x05, 0xda, 0x00, 0x00, 0x05, 0xff, 0x00,
+    0x00, 0x06, 0x22, 0x00, 0x00, 0x06, 0x49, 0x00, 0x00, 0x06, 0x6d, 0x00,
+    0x00, 0x06, 0x8e, 0x00, 0x00, 0x06, 0xb4, 0x00, 0x00, 0x06, 0xdb, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x22, 0x00, 0x00, 0x07, 0x44, 0x00,
+    0x00, 0x07, 0x66, 0x00, 0x00, 0x07, 0x8e, 0x00, 0x00, 0x07, 0xb4, 0x00,
+    0x00, 0x07, 0xdd, 0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x08, 0x36, 0x00,
+    0x00, 0x08, 0x5e, 0x00, 0x00, 0x08, 0x82, 0x00, 0x00, 0x08, 0xa4, 0x00,
+    0x00, 0x08, 0xd0, 0x00, 0x00, 0x08, 0xfe, 0x00, 0x00, 0x09, 0x22, 0x00,
+    0x00, 0x09, 0x4a, 0x00, 0x00, 0x09, 0x73, 0x00, 0x00, 0x09, 0x9a, 0x00,
+    0x00, 0x09, 0xbe, 0x00, 0x00, 0x09, 0xe2, 0x00, 0x00, 0x0a, 0x09, 0x00,
+    0x00, 0x0a, 0x2d, 0x00, 0x00, 0x0a, 0x55, 0x00, 0x00, 0x0a, 0x79, 0x00,
+    0x00, 0x0a, 0x9e, 0x00, 0x00, 0x0a, 0xc5, 0x00, 0x00, 0x0a, 0xe9, 0x00,
+    0x00, 0x0b, 0x10, 0x00, 0x00, 0x0b, 0x34, 0x00, 0x00, 0x0b, 0x5d, 0x00,
+    0x00, 0x0b, 0x85, 0x00, 0x00, 0x0b, 0xa7, 0x00, 0x00, 0x0b, 0xcb, 0x00,
+    0x00, 0x0b, 0xf0, 0x00, 0x00, 0x0c, 0x15, 0x00, 0x00, 0x0c, 0x39, 0x00,
+    0x00, 0x0c, 0x62, 0x00, 0x00, 0x0c, 0x8c, 0x00, 0x00, 0x0c, 0xb6, 0x00,
+    0x00, 0x0c, 0xdc, 0x00, 0x00, 0x0c, 0xfc, 0x00, 0x00, 0x0d, 0x1d, 0x00,
+    0x00, 0x0d, 0x44, 0x00, 0x00, 0x0d, 0x69, 0x00, 0x00, 0x0d, 0x8e, 0x00,
+    0x00, 0x0d, 0xb4, 0x00, 0x00, 0x0d, 0xd9, 0x00, 0x00, 0x0d, 0xfd, 0x00,
+    0x00, 0x0e, 0x1d, 0x00, 0x00, 0x0e, 0x45, 0x00, 0x00, 0x0e, 0x6b, 0x00,
+    0x00, 0x0e, 0x95, 0x00, 0x00, 0x0e, 0xbd, 0x00, 0x00, 0x0e, 0xe3, 0x00,
+    0x00, 0x0f, 0x07, 0x00, 0x00, 0x0f, 0x2b, 0x00, 0x00, 0x0f, 0x5a, 0x00,
+    0x00, 0x0f, 0x7e, 0x00, 0x00, 0x0f, 0xa4, 0x00, 0x00, 0x0f, 0xc8, 0x00,
+    0x00, 0x0f, 0xec, 0x00, 0x00, 0x10, 0x11, 0x00, 0x00, 0x10, 0x39, 0x00,
+    0x00, 0x10, 0x62, 0x00, 0x00, 0x10, 0x82, 0x00, 0x00, 0x10, 0xab, 0x00,
+    0x00, 0x10, 0xcc, 0x00, 0x00, 0x10, 0xf0, 0x00, 0x00, 0x11, 0x1b, 0x00,
+    0x00, 0x11, 0x3f, 0x00, 0x00, 0x11, 0x66, 0x00, 0x00, 0x11, 0x8b, 0x00,
+    0x00, 0x11, 0xb2, 0x00, 0x00, 0x11, 0xd6, 0x00, 0x00, 0x11, 0xfd, 0x00,
+    0x00, 0x12, 0x20, 0x00, 0x00, 0x12, 0x45, 0x00, 0x00, 0x12, 0x71, 0x00,
+    0x00, 0x12, 0x9a, 0x00, 0x00, 0x12, 0xbc, 0x00, 0x00, 0x12, 0xdf, 0x00,
+    0x00, 0x13, 0x05, 0x00, 0x00, 0x13, 0x2e, 0x00, 0x00, 0x13, 0x59, 0x00,
+    0x00, 0x13, 0x84, 0x00, 0x00, 0x13, 0xa9, 0x00, 0x00, 0x13, 0xcd, 0x00,
+    0x00, 0x13, 0xf2, 0x00, 0x00, 0x14, 0x14, 0x00, 0x00, 0x14, 0x35, 0x00,
+    0x00, 0x14, 0x62, 0x00, 0x00, 0x14, 0x84, 0x00, 0x00, 0x14, 0xa9, 0x00,
+    0x00, 0x14, 0xca, 0x00, 0x00, 0x14, 0xf0, 0x00, 0x00, 0x15, 0x15, 0x00,
+    0x00, 0x15, 0x3a, 0x00, 0x00, 0x15, 0x63, 0x00, 0x00, 0x15, 0x8a, 0x00,
+    0x00, 0x15, 0xb3, 0x00, 0x00, 0x15, 0xdf, 0x00, 0x00, 0x16, 0x07, 0x00,
+    0x00, 0x16, 0x2c, 0x00, 0x00, 0x16, 0x4c, 0x00, 0x00, 0x16, 0x75, 0x00,
+    0x00, 0x16, 0x9a, 0x00, 0x00, 0x16, 0xc0, 0x00, 0x00, 0x16, 0xe7, 0x00,
+    0x00, 0x17, 0x0e, 0x00, 0x00, 0x17, 0x3a, 0x00, 0x00, 0x17, 0x5e, 0x00,
+    0x00, 0x17, 0x87, 0x00, 0x00, 0x17, 0xae, 0x00, 0x00, 0x17, 0xdb, 0x00,
+    0x00, 0x18, 0x05, 0x00, 0x00, 0x18, 0x2d, 0x00, 0x00, 0x18, 0x56, 0x00,
+    0x00, 0x18, 0x7b, 0x00, 0x00, 0x18, 0xa6, 0x00, 0x00, 0x18, 0xcd, 0x00,
+    0x00, 0x18, 0xf2, 0x00, 0x00, 0x19, 0x17, 0x00, 0x00, 0x19, 0x41, 0x00,
+    0x00, 0x19, 0x68, 0x00, 0x00, 0x19, 0x8e, 0x00, 0x00, 0x19, 0xb6, 0x00,
+    0x00, 0x19, 0xde, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x2d, 0x00,
+    0x00, 0x1a, 0x52, 0x00, 0x00, 0x1a, 0x77, 0x00, 0x00, 0x1a, 0x9a, 0x00,
+    0x00, 0x1a, 0xbf, 0x00, 0x00, 0x1a, 0xe1, 0x00, 0x00, 0x1b, 0x0e, 0x00,
+    0x00, 0x1b, 0x3b, 0x00, 0x00, 0x1b, 0x5e, 0x00, 0x00, 0x1b, 0x83, 0x00,
+    0x00, 0x1b, 0xad, 0x00, 0x00, 0x1b, 0xd6, 0x00, 0x00, 0x1b, 0xfb, 0x00,
+    0x00, 0x1c, 0x1f, 0x00, 0x00, 0x1c, 0x42, 0x00, 0x00, 0x1c, 0x66, 0x00,
+    0x00, 0x1c, 0x90, 0x00, 0x00, 0x1c, 0xb5, 0x00, 0x00, 0x1c, 0xd8, 0x00,
+    0x00, 0x1c, 0xfa, 0x00, 0x00, 0x1d, 0x21, 0x00, 0x00, 0x1d, 0x46, 0x00,
+    0x00, 0x1d, 0x6a, 0x00, 0x00, 0x1d, 0x8c, 0x00, 0x00, 0x1d, 0xb1, 0x00,
+    0x00, 0x1d, 0xd7, 0x00, 0x00, 0x1e, 0x01, 0x00, 0x00, 0x1e, 0x26, 0x00,
+    0x00, 0x1e, 0x4c, 0x00, 0x00, 0x1e, 0x79, 0x00, 0x00, 0x1e, 0xa9, 0x00,
+    0x00, 0x1e, 0xcb, 0x00, 0x00, 0x1e, 0xf2, 0x00, 0x00, 0x1f, 0x17, 0x00,
+    0x00, 0x1f, 0x3b, 0x00, 0x00, 0x1f, 0x61, 0x00, 0x00, 0x1f, 0x87, 0x00,
+    0x00, 0x1f, 0xab, 0x00, 0x00, 0x1f, 0xcc, 0x00, 0x00, 0x1f, 0xeb, 0x00,
+    0x00, 0x20, 0x11, 0x00, 0x00, 0x20, 0x39, 0x00, 0x00, 0x20, 0x5f, 0x00,
+    0x00, 0x20, 0x85, 0x00, 0x00, 0x20, 0xa7, 0x00, 0x00, 0x20, 0xc7, 0x00,
+    0x00, 0x20, 0xe8, 0x00, 0x00, 0x21, 0x0a, 0x00, 0x00, 0x21, 0x33, 0x00,
+    0x00, 0x21, 0x56, 0x00, 0x00, 0x21, 0x7a, 0x00, 0x00, 0x21, 0x9e, 0x00,
+    0x00, 0x21, 0xc4, 0x00, 0x00, 0x21, 0xe8, 0x00, 0x00, 0x22, 0x11, 0x00,
+    0x00, 0x22, 0x33, 0x00, 0x00, 0x22, 0x57, 0x00, 0x00, 0x22, 0x82, 0x00,
+    0x00, 0x22, 0xa9, 0x00, 0x00, 0x22, 0xd0, 0x00, 0x00, 0x22, 0xf6, 0x00,
+    0x00, 0x23, 0x21, 0x00, 0x00, 0x23, 0x45, 0x00, 0x00, 0x23, 0x6e, 0x00,
+    0x00, 0x23, 0xa6, 0x00, 0x00, 0x23, 0xcb, 0x00, 0x00, 0x23, 0xf3, 0x00,
+    0x00, 0x24, 0x14, 0x00, 0x00, 0x24, 0x39, 0x00, 0x00, 0x24, 0x61, 0x00,
+    0x00, 0x24, 0x8b, 0x00, 0x00, 0x24, 0xab, 0x00, 0x00, 0x24, 0xcc, 0x00,
+    0x00, 0x24, 0xf4, 0x00, 0x00, 0x25, 0x1c, 0x00, 0x00, 0x25, 0x4a, 0x00,
+    0x00, 0x25, 0x75, 0x00, 0x00, 0x25, 0xa2, 0x00, 0x00, 0x25, 0xc5, 0x00,
+    0x00, 0x25, 0xeb, 0x00, 0x00, 0x26, 0x15, 0x00, 0x00, 0x26, 0x3b, 0x00,
+    0x00, 0x26, 0x66, 0x00, 0x00, 0x26, 0x87, 0x00, 0x00, 0x26, 0xaa, 0x00,
+    0x00, 0x26, 0xd6, 0x00, 0x00, 0x26, 0xfd, 0x00, 0x00, 0x27, 0x21, 0x00,
+    0x00, 0x27, 0x4a, 0x00, 0x00, 0x27, 0x71, 0x00, 0x00, 0x27, 0x99, 0x00,
+    0x00, 0x27, 0xbb, 0x00, 0x00, 0x27, 0xdf, 0x00, 0x00, 0x28, 0x04, 0x00,
+    0x00, 0x28, 0x28, 0x00, 0x00, 0x28, 0x4e, 0x00, 0x00, 0x28, 0x76, 0x00,
+    0x00, 0x28, 0x9a, 0x00, 0x00, 0x28, 0xb9, 0x00, 0x00, 0x28, 0xdf, 0x00,
+    0x00, 0x29, 0x02, 0x00, 0x00, 0x29, 0x2b, 0x00, 0x00, 0x29, 0x4f, 0x00,
+    0x00, 0x29, 0x7c, 0x00, 0x00, 0x29, 0x9f, 0x00, 0x00, 0x29, 0xc4, 0x00,
+    0x00, 0x29, 0xec, 0x00, 0x00, 0x2a, 0x17, 0x00, 0x00, 0x2a, 0x40, 0x00,
+    0x00, 0x2a, 0x66, 0x00, 0x00, 0x2a, 0x8f, 0x00, 0x00, 0x2a, 0xb2, 0x00,
+    0x00, 0x2a, 0xd7, 0x00, 0x00, 0x2a, 0xfa, 0x00, 0x00, 0x2b, 0x23, 0x00,
+    0x00, 0x2b, 0x4c, 0x00, 0x00, 0x2b, 0x74, 0x00, 0x00, 0x2b, 0x97, 0x00,
+    0x00, 0x2b, 0xb9, 0x00, 0x00, 0x2b, 0xdc, 0x00, 0x00, 0x2c, 0x08, 0x00,
+    0x00, 0x2c, 0x2a, 0x00, 0x00, 0x2c, 0x49, 0x00, 0x00, 0x2c, 0x72, 0x00,
+    0x00, 0x2c, 0x95, 0x00, 0x00, 0x2c, 0xbc, 0x00, 0x00, 0x2c, 0xe7, 0x00,
+    0x00, 0x2d, 0x0b, 0x00, 0x00, 0x2d, 0x2d, 0x00, 0x00, 0x2d, 0x54, 0x00,
+    0x00, 0x2d, 0x7d, 0x00, 0x00, 0x2d, 0x9f, 0x00, 0x00, 0x2d, 0xc7, 0x00,
+    0x00, 0x2d, 0xec, 0x00, 0x00, 0x2e, 0x18, 0x00, 0x00, 0x2e, 0x3d, 0x00,
+    0x00, 0x2e, 0x5f, 0x00, 0x00, 0x2e, 0x83, 0x00, 0x00, 0x2e, 0xab, 0x00,
+    0x00, 0x2e, 0xcc, 0x00, 0x00, 0x2e, 0xef, 0x00, 0x00, 0x2f, 0x1b, 0x00,
+    0x00, 0x2f, 0x3f, 0x00, 0x00, 0x2f, 0x6c, 0x00, 0x00, 0x2f, 0x92, 0x00,
+    0x00, 0x2f, 0xbd, 0x00, 0x00, 0x2f, 0xe4, 0x00, 0x00, 0x30, 0x0a, 0x00,
+    0x00, 0x30, 0x2c, 0x00, 0x00, 0x30, 0x55, 0x00, 0x00, 0x30, 0x7c, 0x00,
+    0x00, 0x30, 0xa1, 0x00, 0x00, 0x30, 0xc4, 0x00, 0x00, 0x30, 0xe9, 0x00,
+    0x00, 0x31, 0x10, 0x00, 0x00, 0x31, 0x36, 0x00, 0x00, 0x31, 0x5c, 0x00,
+    0x00, 0x31, 0x81, 0x00, 0x00, 0x31, 0xac, 0x00, 0x00, 0x31, 0xd3, 0x00,
+    0x00, 0x31, 0xf8, 0x00, 0x00, 0x32, 0x1b, 0x00, 0x00, 0x32, 0x40, 0x00,
+    0x00, 0x32, 0x68, 0x00, 0x00, 0x32, 0x8e, 0x00, 0x00, 0x32, 0xb2, 0x00,
+    0x00, 0x32, 0xd7, 0x00, 0x00, 0x32, 0xfb, 0x00, 0x00, 0x33, 0x23, 0x00,
+    0x00, 0x33, 0x48, 0x00, 0x00, 0x33, 0x6f, 0x00, 0x00, 0x33, 0x96, 0x00,
+    0x00, 0x33, 0xba, 0x00, 0x00, 0x33, 0xe4, 0x00, 0x00, 0x34, 0x07, 0x00,
+    0x00, 0x34, 0x2e, 0x00, 0x00, 0x34, 0x53, 0x00, 0x00, 0x34, 0x73, 0x00,
+    0x00, 0x34, 0x9a, 0x00, 0x00, 0x34, 0xc3, 0x00, 0x00, 0x34, 0xe9, 0x00,
+    0x00, 0x35, 0x0d, 0x00, 0x00, 0x35, 0x32, 0x00, 0x00, 0x35, 0x54, 0x00,
+    0x00, 0x35, 0x82, 0x00, 0x00, 0x35, 0xa8, 0x00, 0x00, 0x35, 0xcc, 0x00,
+    0x00, 0x35, 0xf4, 0x00, 0x00, 0x36, 0x18, 0x00, 0x00, 0x36, 0x44, 0x00,
+    0x00, 0x36, 0x6c, 0x00, 0x00, 0x36, 0x93, 0x00, 0x00, 0x36, 0xbc, 0x00,
+    0x00, 0x36, 0xe2, 0x00, 0x00, 0x37, 0x07, 0x00, 0x00, 0x37, 0x2f, 0x00,
+    0x00, 0x37, 0x4e, 0x00, 0x00, 0x37, 0x70, 0x00, 0x00, 0x37, 0x94, 0x00,
+    0x00, 0x37, 0xbc, 0x00, 0x00, 0x37, 0xe0, 0x00, 0x00, 0x38, 0x06, 0x00,
+    0x00, 0x38, 0x2a, 0x00, 0x00, 0x38, 0x4f, 0x00, 0x00, 0x38, 0x70, 0x00,
+    0x00, 0x38, 0x93, 0x00, 0x00, 0x38, 0xb5, 0x00, 0x00, 0x38, 0xd6, 0x00,
+    0x00, 0x38, 0xfa, 0x00, 0x00, 0x39, 0x20, 0x00, 0x00, 0x39, 0x4a, 0x00,
+    0x00, 0x39, 0x75, 0x00, 0x00, 0x39, 0x95, 0x00, 0x00, 0x39, 0xb8, 0x00,
+    0x00, 0x39, 0xe1, 0x00, 0x00, 0x3a, 0x06, 0x00, 0x00, 0x3a, 0x2b, 0x00,
+    0x00, 0x3a, 0x52, 0x00, 0x00, 0x3a, 0x79, 0x00, 0x00, 0x3a, 0x9d, 0x00,
+    0x00, 0x3a, 0xc7, 0x00, 0x00, 0x3a, 0xed, 0x00, 0x00, 0x3b, 0x13, 0x00,
+    0x00, 0x3b, 0x35, 0x00, 0x00, 0x3b, 0x58, 0x00, 0x00, 0x3b, 0x7d, 0x00,
+    0x00, 0x3b, 0xa1, 0x00, 0x00, 0x3b, 0xca, 0x00, 0x00, 0x3b, 0xee, 0x00,
+    0x00, 0x3c, 0x12, 0x00, 0x00, 0x3c, 0x3c, 0x00, 0x00, 0x3c, 0x62, 0x00,
+    0x00, 0x3c, 0x8a, 0x00, 0x00, 0x3c, 0xaf, 0x00, 0x00, 0x3c, 0xd1, 0x00,
+    0x00, 0x3c, 0xfa, 0x00, 0x00, 0x3d, 0x1d, 0x00, 0x00, 0x3d, 0x43, 0x00,
+    0x00, 0x3d, 0x65, 0x00, 0x00, 0x3d, 0x8d, 0x00, 0x00, 0x3d, 0xae, 0x00,
+    0x00, 0x3d, 0xcf, 0x00, 0x00, 0x3d, 0xf5, 0x00, 0x00, 0x3e, 0x19, 0x00,
+    0x00, 0x3e, 0x3e, 0x00, 0x00, 0x3e, 0x61, 0x00, 0x00, 0x3e, 0x86, 0x00,
+    0x00, 0x3e, 0xb0, 0x00, 0x00, 0x3e, 0xd8, 0x00, 0x00, 0x3e, 0xfb, 0x00,
+    0x00, 0x3f, 0x1f, 0x00, 0x00, 0x3f, 0x43, 0x00, 0x00, 0x3f, 0x66, 0x00,
+    0x00, 0x3f, 0x8a, 0x00, 0x00, 0x3f, 0xb0, 0x00, 0x00, 0x3f, 0xd4, 0x00,
+    0x00, 0x3f, 0xf7, 0x00, 0x00, 0x40, 0x1c, 0x00, 0x00, 0x40, 0x41, 0x00,
+    0x00, 0x40, 0x66, 0x00, 0x00, 0x40, 0x93, 0x00, 0x00, 0x40, 0xc0, 0x00,
+    0x00, 0x40, 0xe4, 0x00, 0x00, 0x41, 0x13, 0x00, 0x00, 0x41, 0x39, 0x00,
+    0x00, 0x41, 0x5f, 0x00, 0x00, 0x41, 0x84, 0x00, 0x00, 0x41, 0xa6, 0x00,
+    0x00, 0x41, 0xd3, 0x00, 0x00, 0x41, 0xf3, 0x00, 0x00, 0x42, 0x17, 0x00,
+    0x00, 0x42, 0x3b, 0x00, 0x00, 0x42, 0x63, 0x00, 0x00, 0x42, 0x8c, 0x00,
+    0x00, 0x42, 0xae, 0x00, 0x00, 0x42, 0xd4, 0x00, 0x00, 0x42, 0xfc, 0x00,
+    0x00, 0x43, 0x26, 0x00, 0x00, 0x43, 0x48, 0x00, 0x00, 0x43, 0x69, 0x00,
+    0x00, 0x43, 0x8e, 0x00, 0x00, 0x43, 0xb5, 0x00, 0x00, 0x43, 0xdb, 0x00,
+    0x00, 0x43, 0xfc, 0x00, 0x00, 0x44, 0x2d, 0x00, 0x00, 0x44, 0x4c, 0x00,
+    0x00, 0x44, 0x72, 0x00, 0x00, 0x44, 0x95, 0x00, 0x00, 0x44, 0xbd, 0x00,
+    0x00, 0x44, 0xeb, 0x00, 0x00, 0x45, 0x10, 0x00, 0x00, 0x45, 0x3a, 0x00,
+    0x00, 0x45, 0x5f, 0x00, 0x00, 0x45, 0x7e, 0x00, 0x00, 0x45, 0xa0, 0x00,
+    0x00, 0x45, 0xc6, 0x00, 0x00, 0x45, 0xed, 0x00, 0x00, 0x46, 0x10, 0x00,
+    0x00, 0x46, 0x33, 0x00, 0x00, 0x46, 0x58, 0x00, 0x00, 0x46, 0x77, 0x00,
+    0x00, 0x46, 0x9d, 0x00, 0x00, 0x46, 0xc7, 0x00, 0x00, 0x46, 0xeb, 0x00,
+    0x00, 0x47, 0x10, 0x00, 0x00, 0x47, 0x3b, 0x00, 0x00, 0x47, 0x63, 0x00,
+    0x00, 0x47, 0x86, 0x00, 0x00, 0x47, 0xaa, 0x00, 0x00, 0x47, 0xcd, 0x00,
+    0x00, 0x47, 0xf2, 0x00, 0x00, 0x48, 0x17, 0x00, 0x00, 0x48, 0x3c, 0x00,
+    0x00, 0x48, 0x67, 0x00, 0x00, 0x48, 0x8f, 0x00, 0x00, 0x48, 0xb5, 0x00,
+    0x00, 0x48, 0xd8, 0x00, 0x00, 0x48, 0xf9, 0x00, 0x00, 0x49, 0x20, 0x00,
+    0x00, 0x49, 0x46, 0x00, 0x00, 0x49, 0x6d, 0x00, 0x00, 0x49, 0x93, 0x00,
+    0x00, 0x49, 0xbd, 0x00, 0x00, 0x49, 0xe3, 0x00, 0x00, 0x4a, 0x0c, 0x00,
+    0x00, 0x4a, 0x36, 0x00, 0x00, 0x4a, 0x5b, 0x00, 0x00, 0x4a, 0x85, 0x00,
+    0x00, 0x4a, 0xaa, 0x00, 0x00, 0x4a, 0xcd, 0x00, 0x00, 0x4a, 0xf6, 0x00,
+    0x00, 0x4b, 0x1b, 0x00, 0x00, 0x4b, 0x3f, 0x00, 0x00, 0x4b, 0x5f, 0x00,
+    0x00, 0x4b, 0x85, 0x00, 0x00, 0x4b, 0xa8, 0x00, 0x00, 0x4b, 0xd5, 0x00,
+    0x00, 0x4b, 0xf8, 0x00, 0x00, 0x4c, 0x21, 0x00, 0x00, 0x4c, 0x4a, 0x00,
+    0x00, 0x4c, 0x6f, 0x00, 0x00, 0x4c, 0x95, 0x00, 0x00, 0x4c, 0xb8, 0x00,
+    0x00, 0x4c, 0xe2, 0x00, 0x00, 0x4d, 0x06, 0x00, 0x00, 0x4d, 0x2f, 0x00,
+    0x00, 0x4d, 0x50, 0x00, 0x00, 0x4d, 0x78, 0x00, 0x00, 0x4d, 0x9e, 0x00,
+    0x00, 0x4d, 0xc4, 0x00, 0x00, 0x4d, 0xf1, 0x00, 0x00, 0x4e, 0x1b, 0x00,
+    0x00, 0x4e, 0x40, 0x00, 0x00, 0x4e, 0x67, 0x00, 0x00, 0x4e, 0x8b, 0x00,
+    0x00, 0x4e, 0xb4, 0x00, 0x00, 0x4e, 0xda, 0x00, 0x00, 0x4e, 0xfd, 0x00,
+    0x00, 0x4f, 0x21, 0x00, 0x00, 0x4f, 0x47, 0x00, 0x00, 0x4f, 0x6c, 0x00,
+    0x00, 0x4f, 0x91, 0x00, 0x00, 0x4f, 0xbc, 0x00, 0x00, 0x4f, 0xde, 0x00,
+    0x00, 0x50, 0x02, 0x00, 0x00, 0x50, 0x27, 0x00, 0x00, 0x50, 0x4b, 0x00,
+    0x00, 0x50, 0x6a, 0x00, 0x00, 0x50, 0x93, 0x00, 0x00, 0x50, 0xb5, 0x00,
+    0x00, 0x50, 0xdc, 0x00, 0x00, 0x51, 0x07, 0x00, 0x00, 0x51, 0x30, 0x00,
+    0x00, 0x51, 0x55, 0x00, 0x00, 0x51, 0x79, 0x00, 0x00, 0x51, 0x9f, 0x00,
+    0x00, 0x51, 0xc5, 0x00, 0x00, 0x51, 0xe8, 0x00, 0x00, 0x52, 0x0f, 0x00,
+    0x00, 0x52, 0x34, 0x00, 0x00, 0x52, 0x5b, 0x00, 0x00, 0x52, 0x81, 0x00,
+    0x00, 0x52, 0xa3, 0x00, 0x00, 0x52, 0xc8, 0x00, 0x00, 0x52, 0xee, 0x00,
+    0x00, 0x53, 0x15, 0x00, 0x00, 0x53, 0x39, 0x00, 0x00, 0x53, 0x61, 0x00,
+    0x00, 0x53, 0x8a, 0x00, 0x00, 0x53, 0xb1, 0x00, 0x00, 0x53, 0xd8, 0x00,
+    0x00, 0x53, 0xfe, 0x00, 0x00, 0x54, 0x24, 0x00, 0x00, 0x54, 0x47, 0x00,
+    0x00, 0x54, 0x71, 0x00, 0x00, 0x54, 0x94, 0x00, 0x00, 0x54, 0xbc, 0x00,
+    0x00, 0x54, 0xe2, 0x00, 0x00, 0x55, 0x0e, 0x00, 0x00, 0x55, 0x32, 0x00,
+    0x00, 0x55, 0x5b, 0x00, 0x00, 0x55, 0x88, 0x00, 0x00, 0x55, 0xae, 0x00,
+    0x00, 0x55, 0xd1, 0x00, 0x00, 0x55, 0xfa, 0x00, 0x00, 0x56, 0x24, 0x00,
+    0x00, 0x56, 0x49, 0x00, 0x00, 0x56, 0x6f, 0x00, 0x00, 0x56, 0x9d, 0x00,
+    0x00, 0x56, 0xc3, 0x00, 0x00, 0x56, 0xe8, 0x00, 0x00, 0x57, 0x0e, 0x00,
+    0x00, 0x57, 0x30, 0x00, 0x00, 0x57, 0x57, 0x00, 0x00, 0x57, 0x7d, 0x00,
+    0x00, 0x57, 0xa2, 0x00, 0x00, 0x57, 0xca, 0x00, 0x00, 0x57, 0xee, 0x00,
+    0x00, 0x58, 0x15, 0x00, 0x00, 0x58, 0x3a, 0x00, 0x00, 0x58, 0x5d, 0x00,
+    0x00, 0x58, 0x84, 0x00, 0x00, 0x58, 0xac, 0x00, 0x00, 0x58, 0xd3, 0x00,
+    0x00, 0x58, 0xfa, 0x00, 0x00, 0x59, 0x20, 0x00, 0x00, 0x59, 0x43, 0x00,
+    0x00, 0x59, 0x66, 0x00, 0x00, 0x59, 0x8c, 0x00, 0x00, 0x59, 0xb2, 0x00,
+    0x00, 0x59, 0xd7, 0x00, 0x00, 0x59, 0xf9, 0x00, 0x00, 0x5a, 0x26, 0x00,
+    0x00, 0x5a, 0x4f, 0x00, 0x00, 0x5a, 0x71, 0x00, 0x00, 0x5a, 0x96, 0x00,
+    0x00, 0x5a, 0xbf, 0x00, 0x00, 0x5a, 0xe1, 0x00, 0x00, 0x5b, 0x07, 0x00,
+    0x00, 0x5b, 0x2b, 0x00, 0x00, 0x5b, 0x4e, 0x00, 0x00, 0x5b, 0x72, 0x00,
+    0x00, 0x5b, 0x9d, 0x00, 0x00, 0x5b, 0xc4, 0x00, 0x00, 0x5b, 0xe9, 0x00,
+    0x00, 0x5c, 0x10, 0x00, 0x00, 0x5c, 0x34, 0x00, 0x00, 0x5c, 0x59, 0x00,
+    0x00, 0x5c, 0x79, 0x00, 0x00, 0x5c, 0x9b, 0x00, 0x00, 0x5c, 0xbe, 0x00,
+    0x00, 0x5c, 0xe4, 0x00, 0x00, 0x5d, 0x0a, 0x00, 0x00, 0x5d, 0x2c, 0x00,
+    0x00, 0x5d, 0x52, 0x00, 0x00, 0x5d, 0x78, 0x00, 0x00, 0x5d, 0x9b, 0x00,
+    0x00, 0x5d, 0xbf, 0x00, 0x00, 0x5d, 0xe1, 0x00, 0x00, 0x5e, 0x04, 0x00,
+    0x00, 0x5e, 0x28, 0x00, 0x00, 0x5e, 0x4e, 0x00, 0x00, 0x5e, 0x72, 0x00,
+    0x00, 0x5e, 0x9b, 0x00, 0x00, 0x5e, 0xc0, 0x00, 0x00, 0x5e, 0xe4, 0x00,
+    0x00, 0x5f, 0x04, 0x00, 0x00, 0x5f, 0x29, 0x00, 0x00, 0x5f, 0x4f, 0x00,
+    0x00, 0x5f, 0x77, 0x00, 0x00, 0x5f, 0x9a, 0x00, 0x00, 0x5f, 0xbe, 0x00,
+    0x00, 0x5f, 0xea, 0x00, 0x00, 0x60, 0x10, 0x00, 0x00, 0x60, 0x37, 0x00,
+    0x00, 0x60, 0x5a, 0x00, 0x00, 0x60, 0x80, 0x00, 0x00, 0x60, 0xa5, 0x00,
+    0x00, 0x60, 0xc7, 0x00, 0x00, 0x60, 0xeb, 0x00, 0x00, 0x61, 0x12, 0x00,
+    0x00, 0x61, 0x3b, 0x00, 0x00, 0x61, 0x65, 0x00, 0x00, 0x61, 0x8d, 0x00,
+    0x00, 0x61, 0xb7, 0x00, 0x00, 0x61, 0xd9, 0x00, 0x00, 0x61, 0xff, 0x00,
+    0x00, 0x62, 0x22, 0x00, 0x00, 0x62, 0x4e, 0x00, 0x00, 0x62, 0x7e, 0x00,
+    0x00, 0x62, 0xa1, 0x00, 0x00, 0x62, 0xc6, 0x00, 0x00, 0x62, 0xe7, 0x00,
+    0x00, 0x63, 0x11, 0x00, 0x00, 0x63, 0x34, 0x00, 0x00, 0x63, 0x59, 0x00,
+    0x00, 0x63, 0x78, 0x00, 0x00, 0x63, 0x9e, 0x00, 0x00, 0x63, 0xc9, 0x00,
+    0x00, 0x63, 0xeb, 0x00, 0x00, 0x64, 0x0b, 0x00, 0x00, 0x64, 0x29, 0x00,
+    0x00, 0x64, 0x50, 0x00, 0x00, 0x64, 0x75, 0x00, 0x00, 0x64, 0x97, 0x00,
+    0x00, 0x64, 0xbb, 0x00, 0x00, 0x64, 0xe1, 0x00, 0x00, 0x65, 0x05, 0x00,
+    0x00, 0x65, 0x29, 0x00, 0x00, 0x65, 0x4f, 0x00, 0x00, 0x65, 0x77, 0x00,
+    0x00, 0x65, 0x9b, 0x00, 0x00, 0x65, 0xbb, 0x00, 0x00, 0x65, 0xe0, 0x00,
+    0x00, 0x66, 0x06, 0x00, 0x00, 0x66, 0x2c, 0x00, 0x00, 0x66, 0x4f, 0x00,
+    0x00, 0x66, 0x71, 0x00, 0x00, 0x66, 0x99, 0x00, 0x00, 0x66, 0xc2, 0x00,
+    0x00, 0x66, 0xe8, 0x00, 0x00, 0x67, 0x0b, 0x00, 0x00, 0x67, 0x30, 0x00,
+    0x00, 0x67, 0x54, 0x00, 0x00, 0x67, 0x80, 0x00, 0x00, 0x67, 0xac, 0x00,
+    0x00, 0x67, 0xcd, 0x00, 0x00, 0x67, 0xf1, 0x00, 0x00, 0x68, 0x18, 0x00,
+    0x00, 0x68, 0x43, 0x00, 0x00, 0x68, 0x6a, 0x00, 0x00, 0x68, 0x91, 0x00,
+    0x00, 0x68, 0xb8, 0x00, 0x00, 0x68, 0xdc, 0x00, 0x00, 0x69, 0x02, 0x00,
+    0x00, 0x69, 0x29, 0x00, 0x00, 0x69, 0x4e, 0x00, 0x00, 0x69, 0x73, 0x00,
+    0x00, 0x69, 0x93, 0x00, 0x00, 0x69, 0xb9, 0x00, 0x00, 0x69, 0xe5, 0x00,
+    0x00, 0x6a, 0x0e, 0x00, 0x00, 0x6a, 0x3a, 0x00, 0x00, 0x6a, 0x6a, 0x00,
+    0x00, 0x6a, 0x93, 0x00, 0x00, 0x6a, 0xb7, 0x00, 0x00, 0x6a, 0xe0, 0x00,
+    0x00, 0x6b, 0x05, 0x00, 0x00, 0x6b, 0x2d, 0x00, 0x00, 0x6b, 0x4f, 0x00,
+    0x00, 0x6b, 0x77, 0x00, 0x00, 0x6b, 0xa2, 0x00, 0x00, 0x6b, 0xc7, 0x00,
+    0x00, 0x6b, 0xec, 0x00, 0x00, 0x6c, 0x0e, 0x00, 0x00, 0x6c, 0x37, 0x00,
+    0x00, 0x6c, 0x5c, 0x00, 0x00, 0x6c, 0x80, 0x00, 0x00, 0x6c, 0xa4, 0x00,
+    0x00, 0x6c, 0xc9, 0x00, 0x00, 0x6c, 0xea, 0x00, 0x00, 0x6d, 0x0d, 0x00,
+    0x00, 0x6d, 0x39, 0x00, 0x00, 0x6d, 0x62, 0x00, 0x00, 0x6d, 0x86, 0x00,
+    0x00, 0x6d, 0xaa, 0x00, 0x00, 0x6d, 0xdc, 0x00, 0x00, 0x6d, 0xff, 0x00,
+    0x00, 0x6e, 0x29, 0x00, 0x00, 0x6e, 0x51, 0x00, 0x00, 0x6e, 0x7b, 0x00,
+    0x00, 0x6e, 0xa4, 0x00, 0x00, 0x6e, 0xc6, 0x00, 0x00, 0x6e, 0xec, 0x00,
+    0x00, 0x6f, 0x11, 0x00, 0x00, 0x6f, 0x35, 0x00, 0x00, 0x6f, 0x59, 0x00,
+    0x00, 0x6f, 0x7f, 0x00, 0x00, 0x6f, 0xa6, 0x00, 0x00, 0x6f, 0xcd, 0x00,
+    0x00, 0x6f, 0xf4, 0x00, 0x00, 0x70, 0x1f, 0x00, 0x00, 0x70, 0x4a, 0x00,
+    0x00, 0x70, 0x74, 0x00, 0x00, 0x70, 0x95, 0x00, 0x00, 0x70, 0xbc, 0x00,
+    0x00, 0x70, 0xe0, 0x00, 0x00, 0x71, 0x03, 0x00, 0x00, 0x71, 0x2d, 0x00,
+    0x00, 0x71, 0x55, 0x00, 0x00, 0x71, 0x7a, 0x00, 0x00, 0x71, 0x9d, 0x00,
+    0x00, 0x71, 0xc2, 0x00, 0x00, 0x71, 0xe9, 0x00, 0x00, 0x72, 0x0d, 0x00,
+    0x00, 0x72, 0x36, 0x00, 0x00, 0x72, 0x5a, 0x00, 0x00, 0x72, 0x88, 0x00,
+    0x00, 0x72, 0xab, 0x00, 0x00, 0x72, 0xd4, 0x00, 0x00, 0x72, 0xfd, 0x00,
+    0x00, 0x73, 0x20, 0x00, 0x00, 0x73, 0x46, 0x00, 0x00, 0x73, 0x6a, 0x00,
+    0x00, 0x73, 0x90, 0x00, 0x00, 0x73, 0xbd, 0x00, 0x00, 0x73, 0xe3, 0x00,
+    0x00, 0x74, 0x05, 0x00, 0x00, 0x74, 0x2b, 0x00, 0x00, 0x74, 0x50, 0x00,
+    0x00, 0x74, 0x73, 0x00, 0x00, 0x74, 0x9c, 0x00, 0x00, 0x74, 0xc5, 0x00,
+    0x00, 0x74, 0xed, 0x00, 0x00, 0x75, 0x11, 0x00, 0x00, 0x75, 0x3c, 0x00,
+    0x00, 0x75, 0x5e, 0x00, 0x00, 0x75, 0x8b, 0x00, 0x00, 0x75, 0xb4, 0x00,
+    0x00, 0x75, 0xd8, 0x00, 0x00, 0x75, 0xf8, 0x00, 0x00, 0x76, 0x21, 0x00,
+    0x00, 0x76, 0x45, 0x00, 0x00, 0x76, 0x70, 0x00, 0x00, 0x76, 0x95, 0x00,
+    0x00, 0x76, 0xc2, 0x00, 0x00, 0x76, 0xe6, 0x00, 0x00, 0x77, 0x10, 0x00,
+    0x00, 0x77, 0x36, 0x00, 0x00, 0x77, 0x5e, 0x00, 0x00, 0x77, 0x7e, 0x00,
+    0x00, 0x77, 0xa6, 0x00, 0x00, 0x77, 0xc7, 0x00, 0x00, 0x77, 0xe8, 0x00,
+    0x00, 0x78, 0x0d, 0x00, 0x00, 0x78, 0x36, 0x00, 0x00, 0x78, 0x60, 0x00,
+    0x00, 0x78, 0x8d, 0x00, 0x00, 0x78, 0xb3, 0x00, 0x00, 0x78, 0xde, 0x00,
+    0x00, 0x79, 0x03, 0x00, 0x00, 0x79, 0x28, 0x00, 0x00, 0x79, 0x4c, 0x00,
+    0x00, 0x79, 0x72, 0x00, 0x00, 0x79, 0x99, 0x00, 0x00, 0x79, 0xbd, 0x00,
+    0x00, 0x79, 0xe4, 0x00, 0x00, 0x7a, 0x09, 0x00, 0x00, 0x7a, 0x2c, 0x00,
+    0x00, 0x7a, 0x4d, 0x00, 0x00, 0x7a, 0x72, 0x00, 0x00, 0x7a, 0x94, 0x00,
+    0x00, 0x7a, 0xb9, 0x00, 0x00, 0x7a, 0xd9, 0x00, 0x00, 0x7b, 0x02, 0x00,
+    0x00, 0x7b, 0x2a, 0x00, 0x00, 0x7b, 0x4d, 0x00, 0x00, 0x7b, 0x77, 0x00,
+    0x00, 0x7b, 0x99, 0x00, 0x00, 0x7b, 0xba, 0x00, 0x00, 0x7b, 0xdf, 0x00,
+    0x00, 0x7c, 0x05, 0x00, 0x00, 0x7c, 0x26, 0x00, 0x00, 0x7c, 0x49, 0x00,
+    0x00, 0x7c, 0x74, 0x00, 0x00, 0x7c, 0x97, 0x00, 0x00, 0x7c, 0xbc, 0x00,
+    0x00, 0x7c, 0xdd, 0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x7d, 0x27, 0x00,
+    0x00, 0x7d, 0x51, 0x00, 0x00, 0x7d, 0x7a, 0x00, 0x00, 0x7d, 0x9e, 0x00,
+    0x00, 0x7d, 0xc3, 0x00, 0x00, 0x7d, 0xe6, 0x00, 0x00, 0x7e, 0x10, 0x00,
+    0x00, 0x7e, 0x34, 0x00, 0x00, 0x7e, 0x58, 0x00, 0x00, 0x7e, 0x78, 0x00,
+    0x00, 0x7e, 0x9e, 0x00, 0x00, 0x7e, 0xc3, 0x00, 0x00, 0x7e, 0xe8, 0x00,
+    0x00, 0x7f, 0x0f, 0x00, 0x00, 0x7f, 0x33, 0x00, 0x00, 0x7f, 0x5c, 0x00,
+    0x00, 0x7f, 0x82, 0x00, 0x00, 0x7f, 0xa9, 0x00, 0x00, 0x7f, 0xcd, 0x00,
+    0x00, 0x7f, 0xf1, 0x00, 0x00, 0x80, 0x11, 0x00, 0x00, 0x80, 0x38, 0x00,
+    0x00, 0x80, 0x5c, 0x00, 0x00, 0x80, 0x7e, 0x00, 0x00, 0x80, 0xa5, 0x00,
+    0x00, 0x80, 0xd0, 0x00, 0x00, 0x80, 0xfa, 0x00, 0x00, 0x81, 0x20, 0x00,
+    0x00, 0x81, 0x45, 0x00, 0x00, 0x81, 0x6f, 0x00, 0x00, 0x81, 0x95, 0x00,
+    0x00, 0x81, 0xbd, 0x00, 0x00, 0x81, 0xe5, 0x00, 0x00, 0x82, 0x0b, 0x00,
+    0x00, 0x82, 0x34, 0x00, 0x00, 0x82, 0x53, 0x00, 0x00, 0x82, 0x77, 0x00,
+    0x00, 0x82, 0x9d, 0x00, 0x00, 0x82, 0xc2, 0x00, 0x00, 0x82, 0xe8, 0x00,
+    0x00, 0x83, 0x0e, 0x00, 0x00, 0x83, 0x34, 0x00, 0x00, 0x83, 0x5a, 0x00,
+    0x00, 0x83, 0x7e, 0x00, 0x00, 0x83, 0xa6, 0x00, 0x00, 0x83, 0xcc, 0x00,
+    0x00, 0x83, 0xf2, 0x00, 0x00, 0x84, 0x1b, 0x00, 0x00, 0x84, 0x42, 0x00,
+    0x00, 0x84, 0x64, 0x00, 0x00, 0x84, 0x87, 0x00, 0x00, 0x84, 0xb5, 0x00,
+    0x00, 0x84, 0xd9, 0x00, 0x00, 0x84, 0xfd, 0x00, 0x00, 0x85, 0x23, 0x00,
+    0x00, 0x85, 0x4c, 0x00, 0x00, 0x85, 0x70, 0x00, 0x00, 0x85, 0x97, 0x00,
+    0x00, 0x85, 0xbc, 0x00, 0x00, 0x85, 0xe5, 0x00, 0x00, 0x86, 0x0a, 0x00,
+    0x00, 0x86, 0x2d, 0x00, 0x00, 0x86, 0x4c, 0x00, 0x00, 0x86, 0x6e, 0x00,
+    0x00, 0x86, 0x95, 0x00, 0x00, 0x86, 0xc4, 0x00, 0x00, 0x86, 0xe4, 0x00,
+    0x00, 0x87, 0x0c, 0x00, 0x00, 0x87, 0x39, 0x00, 0x00, 0x87, 0x67, 0x00,
+    0x00, 0x87, 0x89, 0x00, 0x00, 0x87, 0xb0, 0x00, 0x00, 0x87, 0xcf, 0x00,
+    0x00, 0x87, 0xf4, 0x00, 0x00, 0x88, 0x16, 0x00, 0x00, 0x88, 0x3f, 0x00,
+    0x00, 0x88, 0x63, 0x00, 0x00, 0x88, 0x89, 0x00, 0x00, 0x88, 0xb6, 0x00,
+    0x00, 0x88, 0xdd, 0x00, 0x00, 0x89, 0x04, 0x00, 0x00, 0x89, 0x2c, 0x00,
+    0x00, 0x89, 0x51, 0x00, 0x00, 0x89, 0x77, 0x00, 0x00, 0x89, 0x9b, 0x00,
+    0x00, 0x89, 0xbe, 0x00, 0x00, 0x89, 0xe0, 0x00, 0x00, 0x8a, 0x05, 0x00,
+    0x00, 0x8a, 0x2c, 0x00, 0x00, 0x8a, 0x54, 0x00, 0x00, 0x8a, 0x7b, 0x00,
+    0x00, 0x8a, 0xa1, 0x00, 0x00, 0x8a, 0xc6, 0x00, 0x00, 0x8a, 0xea, 0x00,
+    0x00, 0x8b, 0x10, 0x00, 0x00, 0x8b, 0x35, 0x00, 0x00, 0x8b, 0x5d, 0x00,
+    0x00, 0x8b, 0x8a, 0x00, 0x00, 0x8b, 0xb5, 0x00, 0x00, 0x8b, 0xd6, 0x00,
+    0x00, 0x8b, 0xfc, 0x00, 0x00, 0x8c, 0x21, 0x00, 0x00, 0x8c, 0x43, 0x00,
+    0x00, 0x8c, 0x66, 0x00, 0x00, 0x8c, 0x8a, 0x00, 0x00, 0x8c, 0xb3, 0x00,
+    0x00, 0x8c, 0xd5, 0x00, 0x00, 0x8c, 0xf7, 0x00, 0x00, 0x8d, 0x18, 0x00,
+    0x00, 0x8d, 0x40, 0x00, 0x00, 0x8d, 0x62, 0x00, 0x00, 0x8d, 0x85, 0x00,
+    0x00, 0x8d, 0xac, 0x00, 0x00, 0x8d, 0xce, 0x00, 0x00, 0x8d, 0xf6, 0x00,
+    0x00, 0x8e, 0x1f, 0x00, 0x00, 0x8e, 0x44, 0x00, 0x00, 0x8e, 0x6c, 0x00,
+    0x00, 0x8e, 0x93, 0x00, 0x00, 0x8e, 0xb9, 0x00, 0x00, 0x8e, 0xdc, 0x00,
+    0x00, 0x8e, 0xff, 0x00, 0x00, 0x8f, 0x27, 0x00, 0x00, 0x8f, 0x50, 0x00,
+    0x00, 0x8f, 0x76, 0x00, 0x00, 0x8f, 0x9a, 0x00, 0x00, 0x8f, 0xc1, 0x00,
+    0x00, 0x8f, 0xea, 0x00, 0x00, 0x90, 0x0f, 0x00, 0x00, 0x90, 0x3d, 0x00,
+    0x00, 0x90, 0x68, 0x00, 0x00, 0x90, 0x8e, 0x00, 0x00, 0x90, 0xb3, 0x00,
+    0x00, 0x90, 0xd8, 0x00, 0x00, 0x90, 0xf8, 0x00, 0x00, 0x91, 0x21, 0x00,
+    0x00, 0x91, 0x4a, 0x00, 0x00, 0x91, 0x75, 0x00, 0x00, 0x91, 0x98, 0x00,
+    0x00, 0x91, 0xc6, 0x00, 0x00, 0x91, 0xeb, 0x00, 0x00, 0x92, 0x0e, 0x00,
+    0x00, 0x92, 0x39, 0x00, 0x00, 0x92, 0x5a, 0x00, 0x00, 0x92, 0x86, 0x00,
+    0x00, 0x92, 0xab, 0x00, 0x00, 0x92, 0xce, 0x00, 0x00, 0x92, 0xf3, 0x00,
+    0x00, 0x93, 0x16, 0x00, 0x00, 0x93, 0x41, 0x00, 0x00, 0x93, 0x69, 0x00,
+    0x00, 0x93, 0x90, 0x00, 0x00, 0x93, 0xb2, 0x00, 0x00, 0x93, 0xd9, 0x00,
+    0x00, 0x93, 0xf9, 0x00, 0x00, 0x94, 0x1a, 0x00, 0x00, 0x94, 0x40, 0x00,
+    0x00, 0x94, 0x62, 0x00, 0x00, 0x94, 0x8a, 0x00, 0x00, 0x94, 0xae, 0x00,
+    0x00, 0x94, 0xda, 0x00, 0x00, 0x94, 0xff, 0x00, 0x00, 0x95, 0x29, 0x00,
+    0x00, 0x95, 0x4c, 0x00, 0x00, 0x95, 0x71, 0x00, 0x00, 0x95, 0x98, 0x00,
+    0x00, 0x95, 0xbe, 0x00, 0x00, 0x95, 0xe7, 0x00, 0x00, 0x96, 0x07, 0x00,
+    0x00, 0x96, 0x2a, 0x00, 0x00, 0x96, 0x52, 0x00, 0x00, 0x96, 0x77, 0x00,
+    0x00, 0x96, 0x9d, 0x00, 0x00, 0x96, 0xc4, 0x00, 0x00, 0x96, 0xed, 0x00,
+    0x00, 0x97, 0x14, 0x00, 0x00, 0x97, 0x37, 0x00, 0x00, 0x97, 0x5d, 0x00,
+    0x00, 0x97, 0x82, 0x00, 0x00, 0x97, 0xab, 0x00, 0x00, 0x97, 0xcd, 0x00,
+    0x00, 0x97, 0xf6, 0x00, 0x00, 0x98, 0x1e, 0x00, 0x00, 0x98, 0x47, 0x00,
+    0x00, 0x98, 0x6a, 0x00, 0x00, 0x98, 0x8e, 0x00, 0x00, 0x98, 0xb7, 0x00,
+    0x00, 0x98, 0xd7, 0x00, 0x00, 0x98, 0xfb, 0x00, 0x00, 0x99, 0x25, 0x00,
+    0x00, 0x99, 0x48, 0x00, 0x00, 0x99, 0x6f, 0x00, 0x00, 0x99, 0x9a, 0x00,
+    0x00, 0x99, 0xc2, 0x00, 0x00, 0x99, 0xe8, 0x00, 0x00, 0x9a, 0x11, 0x00,
+    0x00, 0x9a, 0x32, 0x00, 0x00, 0x9a, 0x57, 0x00, 0x00, 0x9a, 0x82, 0x00,
+    0x00, 0x9a, 0xa6, 0x00, 0x00, 0x9a, 0xcf, 0x00, 0x00, 0x9a, 0xf1, 0x00,
+    0x00, 0x9b, 0x14, 0x00, 0x00, 0x9b, 0x37, 0x00, 0x00, 0x9b, 0x5e, 0x00,
+    0x00, 0x9b, 0x80, 0x00, 0x00, 0x9b, 0xac, 0x00, 0x00, 0x9b, 0xd1, 0x00,
+    0x00, 0x9b, 0xfa, 0x00, 0x00, 0x9c, 0x21, 0x00, 0x00, 0x9c, 0x47, 0x00,
+    0x00, 0x9c, 0x6b, 0x00, 0x00, 0x9c, 0x8e, 0x00, 0x00, 0x9c, 0xb2, 0x00,
+    0x00, 0x9c, 0xd6, 0x00, 0x00, 0x9d, 0x02, 0x00, 0x00, 0x9d, 0x25, 0x00,
+    0x00, 0x9d, 0x4d, 0x00, 0x00, 0x9d, 0x73, 0x00, 0x00, 0x9d, 0x98, 0x00,
+    0x00, 0x9d, 0xc0, 0x00, 0x00, 0x9d, 0xe2, 0x00, 0x00, 0x9e, 0x06, 0x00,
+    0x00, 0x9e, 0x2b, 0x00, 0x00, 0x9e, 0x56, 0x00, 0x00, 0x9e, 0x84, 0x00,
+    0x00, 0x9e, 0xaa, 0x00, 0x00, 0x9e, 0xd3, 0x00, 0x00, 0x9e, 0xf8, 0x00,
+    0x00, 0x9f, 0x1f, 0x00, 0x00, 0x9f, 0x46, 0x00, 0x00, 0x9f, 0x6e, 0x00,
+    0x00, 0x9f, 0x92, 0x00, 0x00, 0x9f, 0xb3, 0x00, 0x00, 0x9f, 0xdf, 0x00,
+    0x00, 0xa0, 0x05, 0x00, 0x00, 0xa0, 0x28, 0x00, 0x00, 0xa0, 0x4c, 0x00,
+    0x00, 0xa0, 0x6f, 0x00, 0x00, 0xa0, 0x9e, 0x00, 0x00, 0xa0, 0xc3, 0x00,
+    0x00, 0xa0, 0xe8, 0x00, 0x00, 0xa1, 0x10, 0x00, 0x00, 0xa1, 0x33, 0x00,
+    0x00, 0xa1, 0x54, 0x00, 0x00, 0xa1, 0x7c, 0x00, 0x00, 0xa1, 0xa3, 0x00,
+    0x00, 0xa1, 0xcc, 0x00, 0x00, 0xa1, 0xf1, 0x00, 0x00, 0xa2, 0x16, 0x00,
+    0x00, 0xa2, 0x39, 0x00, 0x00, 0xa2, 0x59, 0x00, 0x00, 0xa2, 0x7e, 0x00,
+    0x00, 0xa2, 0xa7, 0x00, 0x00, 0xa2, 0xce, 0x00, 0x00, 0xa2, 0xf5, 0x00,
+    0x00, 0xa3, 0x1c, 0x00, 0x00, 0xa3, 0x41, 0x00, 0x00, 0xa3, 0x65, 0x00,
+    0x00, 0xa3, 0x86, 0x00, 0x00, 0xa3, 0xb1, 0x00, 0x00, 0xa3, 0xd2, 0x00,
+    0x00, 0xa3, 0xfb, 0x00, 0x00, 0xa4, 0x1f, 0x00, 0x00, 0xa4, 0x43, 0x00,
+    0x00, 0xa4, 0x65, 0x00, 0x00, 0xa4, 0x8e, 0x00, 0x00, 0xa4, 0xb5, 0x00,
+    0x00, 0xa4, 0xde, 0x00, 0x00, 0xa5, 0x08, 0x00, 0x00, 0xa5, 0x2c, 0x00,
+    0x00, 0xa5, 0x58, 0x00, 0x00, 0xa5, 0x7b, 0x00, 0x00, 0xa5, 0x9b, 0x00,
+    0x00, 0xa5, 0xc1, 0x00, 0x00, 0xa5, 0xe9, 0x00, 0x00, 0xa6, 0x0d, 0x00,
+    0x00, 0xa6, 0x32, 0x00, 0x00, 0xa6, 0x57, 0x00, 0x00, 0xa6, 0x79, 0x00,
+    0x00, 0xa6, 0x9d, 0x00, 0x00, 0xa6, 0xc2, 0x00, 0x00, 0xa6, 0xe9, 0x00,
+    0x00, 0xa7, 0x14, 0x00, 0x00, 0xa7, 0x41, 0x00, 0x00, 0xa7, 0x68, 0x00,
+    0x00, 0xa7, 0x8a, 0x00, 0x00, 0xa7, 0xae, 0x00, 0x00, 0xa7, 0xcf, 0x00,
+    0x00, 0xa7, 0xf9, 0x00, 0x00, 0xa8, 0x1c, 0x00, 0x00, 0xa8, 0x42, 0x00,
+    0x00, 0xa8, 0x65, 0x00, 0x00, 0xa8, 0x89, 0x00, 0x00, 0xa8, 0xad, 0x00,
+    0x00, 0xa8, 0xd5, 0x00, 0x00, 0xa8, 0xfc, 0x00, 0x00, 0xa9, 0x1d, 0x00,
+    0x00, 0xa9, 0x47, 0x00, 0x00, 0xa9, 0x6c, 0x00, 0x00, 0xa9, 0x90, 0x00,
+    0x00, 0xa9, 0xb5, 0x00, 0x00, 0xa9, 0xd9, 0x00, 0x00, 0xa9, 0xfe, 0x00,
+    0x00, 0xaa, 0x25, 0x00, 0x00, 0xaa, 0x47, 0x00, 0x00, 0xaa, 0x6e, 0x00,
+    0x00, 0xaa, 0x92, 0x00, 0x00, 0xaa, 0xb7, 0x00, 0x00, 0xaa, 0xdc, 0x00,
+    0x00, 0xaa, 0xff, 0x00, 0x00, 0xab, 0x2e, 0x00, 0x00, 0xab, 0x52, 0x00,
+    0x00, 0xab, 0x7d, 0x00, 0x00, 0xab, 0x9e, 0x00, 0x00, 0xab, 0xcd, 0x00,
+    0x00, 0xab, 0xf3, 0x00, 0x00, 0xac, 0x13, 0x00, 0x00, 0xac, 0x33, 0x00,
+    0x00, 0xac, 0x55, 0x00, 0x00, 0xac, 0x7c, 0x00, 0x00, 0xac, 0xa3, 0x00,
+    0x00, 0xac, 0xc8, 0x00, 0x00, 0xac, 0xed, 0x00, 0x00, 0xad, 0x17, 0x00,
+    0x00, 0xad, 0x37, 0x00, 0x00, 0xad, 0x5b, 0x00, 0x00, 0xad, 0x80, 0x00,
+    0x00, 0xad, 0xa5, 0x00, 0x00, 0xad, 0xcb, 0x00, 0x00, 0xad, 0xf1, 0x00,
+    0x00, 0xae, 0x19, 0x00, 0x00, 0xae, 0x3e, 0x00, 0x00, 0xae, 0x63, 0x00,
+    0x00, 0xae, 0x91, 0x00, 0x00, 0xae, 0xb9, 0x00, 0x00, 0xae, 0xe1, 0x00,
+    0x00, 0xaf, 0x05, 0x00, 0x00, 0xaf, 0x2a, 0x00, 0x00, 0xaf, 0x56, 0x00,
+    0x00, 0xaf, 0x80, 0x00, 0x00, 0xaf, 0xad, 0x00, 0x00, 0xaf, 0xd0, 0x00,
+    0x00, 0xaf, 0xef, 0x00, 0x00, 0xb0, 0x12, 0x00, 0x00, 0xb0, 0x3e, 0x00,
+    0x00, 0xb0, 0x63, 0x00, 0x00, 0xb0, 0x82, 0x00, 0x00, 0xb0, 0xa7, 0x00,
+    0x00, 0xb0, 0xd5, 0x00, 0x00, 0xb0, 0xfa, 0x00, 0x00, 0xb1, 0x26, 0x00,
+    0x00, 0xb1, 0x47, 0x00, 0x00, 0xb1, 0x71, 0x00, 0x00, 0xb1, 0x98, 0x00,
+    0x00, 0xb1, 0xc1, 0x00, 0x00, 0xb1, 0xe5, 0x00, 0x00, 0xb2, 0x07, 0x00,
+    0x00, 0xb2, 0x2c, 0x00, 0x00, 0xb2, 0x51, 0x00, 0x00, 0xb2, 0x79, 0x00,
+    0x00, 0xb2, 0x9d, 0x00, 0x00, 0xb2, 0xc7, 0x00, 0x00, 0xb2, 0xf0, 0x00,
+    0x00, 0xb3, 0x13, 0x00, 0x00, 0xb3, 0x39, 0x00, 0x00, 0xb3, 0x5e, 0x00,
+    0x00, 0xb3, 0x81, 0x00, 0x00, 0xb3, 0xaa, 0x00, 0x00, 0xb3, 0xd9, 0x00,
+    0x00, 0xb3, 0xff, 0x00, 0x00, 0xb4, 0x23, 0x00, 0x00, 0xb4, 0x46, 0x00,
+    0x00, 0xb4, 0x6e, 0x00, 0x00, 0xb4, 0x99, 0x00, 0x00, 0xb4, 0xbd, 0x00,
+    0x00, 0xb4, 0xec, 0x00, 0x00, 0xb5, 0x13, 0x00, 0x00, 0xb5, 0x3b, 0x00,
+    0x00, 0xb5, 0x62, 0x00, 0x00, 0xb5, 0x8c, 0x00, 0x00, 0xb5, 0xb1, 0x00,
+    0x00, 0xb5, 0xd5, 0x00, 0x00, 0xb5, 0xfd, 0x00, 0x00, 0xb6, 0x24, 0x00,
+    0x00, 0xb6, 0x49, 0x00, 0x00, 0xb6, 0x75, 0x00, 0x00, 0xb6, 0x9a, 0x00,
+    0x00, 0xb6, 0xc2, 0x00, 0x00, 0xb6, 0xe8, 0x00, 0x00, 0xb7, 0x14, 0x00,
+    0x00, 0xb7, 0x39, 0x00, 0x00, 0xb7, 0x5e, 0x00, 0x00, 0xb7, 0x85, 0x00,
+    0x00, 0xb7, 0xb6, 0x00, 0x00, 0xb7, 0xdc, 0x00, 0x00, 0xb8, 0x01, 0x00,
+    0x00, 0xb8, 0x27, 0x00, 0x00, 0xb8, 0x4e, 0x00, 0x00, 0xb8, 0x72, 0x00,
+    0x00, 0xb8, 0x94, 0x00, 0x00, 0xb8, 0xb8, 0x00, 0x00, 0xb8, 0xd9, 0x00,
+    0x00, 0xb8, 0xfe, 0x00, 0x00, 0xb9, 0x23, 0x00, 0x00, 0xb9, 0x4a, 0x00,
+    0x00, 0xb9, 0x6e, 0x00, 0x00, 0xb9, 0x92, 0x00, 0x00, 0xb9, 0xb8, 0x00,
+    0x00, 0xb9, 0xdf, 0x00, 0x00, 0xba, 0x07, 0x00, 0x00, 0xba, 0x27, 0x00,
+    0x00, 0xba, 0x4c, 0x00, 0x00, 0xba, 0x73, 0x00, 0x00, 0xba, 0x9b, 0x00,
+    0x00, 0xba, 0xbf, 0x00, 0x00, 0xba, 0xe1, 0x00, 0x00, 0xbb, 0x05, 0x00,
+    0x00, 0xbb, 0x27, 0x00, 0x00, 0xbb, 0x4e, 0x00, 0x00, 0xbb, 0x71, 0x00,
+    0x00, 0xbb, 0x96, 0x00, 0x00, 0xbb, 0xbb, 0x00, 0x00, 0xbb, 0xe0, 0x00,
+    0x00, 0xbc, 0x04, 0x00, 0x00, 0xbc, 0x25, 0x00, 0x00, 0xbc, 0x49, 0x00,
+    0x00, 0xbc, 0x6f, 0x00, 0x00, 0xbc, 0x97, 0x00, 0x00, 0xbc, 0xb7, 0x00,
+    0x00, 0xbc, 0xdb, 0x00, 0x00, 0xbd, 0x04, 0x00, 0x00, 0xbd, 0x26, 0x00,
+    0x00, 0xbd, 0x46, 0x00, 0x00, 0xbd, 0x6c, 0x00, 0x00, 0xbd, 0x94, 0x00,
+    0x00, 0xbd, 0xb6, 0x00, 0x00, 0xbd, 0xda, 0x00, 0x00, 0xbd, 0xfb, 0x00,
+    0x00, 0xbe, 0x20, 0x00, 0x00, 0xbe, 0x48, 0x00, 0x00, 0xbe, 0x6e, 0x00,
+    0x00, 0xbe, 0x95, 0x00, 0x00, 0xbe, 0xbb, 0x00, 0x00, 0xbe, 0xe9, 0x00,
+    0x00, 0xbf, 0x13, 0x00, 0x00, 0xbf, 0x3b, 0x00, 0x00, 0xbf, 0x5f, 0x00,
+    0x00, 0xbf, 0x85, 0x00, 0x00, 0xbf, 0xaf, 0x00, 0x00, 0xbf, 0xdd, 0x00,
+    0x00, 0xc0, 0x02, 0x00, 0x00, 0xc0, 0x24, 0x00, 0x00, 0xc0, 0x4b, 0x00,
+    0x00, 0xc0, 0x71, 0x00, 0x00, 0xc0, 0x98, 0x00, 0x00, 0xc0, 0xbe, 0x00,
+    0x00, 0xc0, 0xe2, 0x00, 0x00, 0xc1, 0x06, 0x00, 0x00, 0xc1, 0x2a, 0x00,
+    0x00, 0xc1, 0x59, 0x00, 0x00, 0xc1, 0x85, 0x00, 0x00, 0xc1, 0xa5, 0x00,
+    0x00, 0xc1, 0xc7, 0x00, 0x00, 0xc1, 0xed, 0x00, 0x00, 0xc2, 0x0e, 0x00,
+    0x00, 0xc2, 0x34, 0x00, 0x00, 0xc2, 0x58, 0x00, 0x00, 0xc2, 0x7f, 0x00,
+    0x00, 0xc2, 0xa5, 0x00, 0x00, 0xc2, 0xd0, 0x00, 0x00, 0xc2, 0xf4, 0x00,
+    0x00, 0xc3, 0x16, 0x00, 0x00, 0xc3, 0x3b, 0x00, 0x00, 0xc3, 0x5c, 0x00,
+    0x00, 0xc3, 0x87, 0x00, 0x00, 0xc3, 0xaa, 0x00, 0x00, 0xc3, 0xcc, 0x00,
+    0x00, 0xc3, 0xf1, 0x00, 0x00, 0xc4, 0x18, 0x00, 0x00, 0xc4, 0x37, 0x00,
+    0x00, 0xc4, 0x59, 0x00, 0x00, 0xc4, 0x83, 0x00, 0x00, 0xc4, 0xa9, 0x00,
+    0x00, 0xc4, 0xd3, 0x00, 0x00, 0xc4, 0xfb, 0x00, 0x00, 0xc5, 0x1f, 0x00,
+    0x00, 0xc5, 0x43, 0x00, 0x00, 0xc5, 0x6c, 0x00, 0x00, 0xc5, 0x9a, 0x00,
+    0x00, 0xc5, 0xbe, 0x00, 0x00, 0xc5, 0xe5, 0x00, 0x00, 0xc6, 0x05, 0x00,
+    0x00, 0xc6, 0x29, 0x00, 0x00, 0xc6, 0x4e, 0x00, 0x00, 0xc6, 0x79, 0x00,
+    0x00, 0xc6, 0xa4, 0x00, 0x00, 0xc6, 0xcd, 0x00, 0x00, 0xc6, 0xef, 0x00,
+    0x00, 0xc7, 0x12, 0x00, 0x00, 0xc7, 0x36, 0x00, 0x00, 0xc7, 0x59, 0x00,
+    0x00, 0xc7, 0x7f, 0x00, 0x00, 0xc7, 0xaa, 0x00, 0x00, 0xc7, 0xcf, 0x00,
+    0x00, 0xc7, 0xf7, 0x00, 0x00, 0xc8, 0x21, 0x00, 0x00, 0xc8, 0x48, 0x00,
+    0x00, 0xc8, 0x6b, 0x00, 0x00, 0xc8, 0x95, 0x00, 0x00, 0xc8, 0xb9, 0x00,
+    0x00, 0xc8, 0xdb, 0x00, 0x00, 0xc9, 0x01, 0x00, 0x00, 0xc9, 0x2b, 0x00,
+    0x00, 0xc9, 0x4e, 0x00, 0x00, 0xc9, 0x73, 0x00, 0x00, 0xc9, 0x98, 0x00,
+    0x00, 0xc9, 0xbe, 0x00, 0x00, 0xc9, 0xe2, 0x00, 0x00, 0xca, 0x0d, 0x00,
+    0x00, 0xca, 0x36, 0x00, 0x00, 0xca, 0x5f, 0x00, 0x00, 0xca, 0x86, 0x00,
+    0x00, 0xca, 0xab, 0x00, 0x00, 0xca, 0xcd, 0x00, 0x00, 0xca, 0xf0, 0x00,
+    0x00, 0xcb, 0x13, 0x00, 0x00, 0xcb, 0x3e, 0x00, 0x00, 0xcb, 0x65, 0x00,
+    0x00, 0xcb, 0x85, 0x00, 0x00, 0xcb, 0xab, 0x00, 0x00, 0xcb, 0xcf, 0x00,
+    0x00, 0xcb, 0xfb, 0x00, 0x00, 0xcc, 0x22, 0x00, 0x00, 0xcc, 0x48, 0x00,
+    0x00, 0xcc, 0x6d, 0x00, 0x00, 0xcc, 0x96, 0x00, 0x00, 0xcc, 0xbe, 0x00,
+    0x00, 0xcc, 0xe2, 0x00, 0x00, 0xcd, 0x02, 0x00, 0x00, 0xcd, 0x29, 0x00,
+    0x00, 0xcd, 0x4e, 0x00, 0x00, 0xcd, 0x76, 0x00, 0x00, 0xcd, 0x9a, 0x00,
+    0x00, 0xcd, 0xbf, 0x00, 0x00, 0xcd, 0xe4, 0x00, 0x00, 0xce, 0x0a, 0x00,
+    0x00, 0xce, 0x2f, 0x00, 0x00, 0xce, 0x5f, 0x00, 0x00, 0xce, 0x83, 0x00,
+    0x00, 0xce, 0xa9, 0x00, 0x00, 0xce, 0xcd, 0x00, 0x00, 0xce, 0xf5, 0x00,
+    0x00, 0xcf, 0x1f, 0x00, 0x00, 0xcf, 0x40, 0x00, 0x00, 0xcf, 0x65, 0x00,
+    0x00, 0xcf, 0x87, 0x00, 0x00, 0xcf, 0xad, 0x00, 0x00, 0xcf, 0xd2, 0x00,
+    0x00, 0xcf, 0xfb, 0x00, 0x00, 0xd0, 0x27, 0x00, 0x00, 0xd0, 0x4c, 0x00,
+    0x00, 0xd0, 0x71, 0x00, 0x00, 0xd0, 0x98, 0x00, 0x00, 0xd0, 0xbd, 0x00,
+    0x00, 0xd0, 0xe2, 0x00, 0x00, 0xd1, 0x06, 0x00, 0x00, 0xd1, 0x2a, 0x00,
+    0x00, 0xd1, 0x4d, 0x00, 0x00, 0xd1, 0x76, 0x00, 0x00, 0xd1, 0xa1, 0x00,
+    0x00, 0xd1, 0xc6, 0x00, 0x00, 0xd1, 0xe9, 0x00, 0x00, 0xd2, 0x10, 0x00,
+    0x00, 0xd2, 0x3d, 0x00, 0x00, 0xd2, 0x61, 0x00, 0x00, 0xd2, 0x8e, 0x00,
+    0x00, 0xd2, 0xaf, 0x00, 0x00, 0xd2, 0xd4, 0x00, 0x00, 0xd2, 0xf7, 0x00,
+    0x00, 0xd3, 0x1a, 0x00, 0x00, 0xd3, 0x45, 0x00, 0x00, 0xd3, 0x6b, 0x00,
+    0x00, 0xd3, 0x92, 0x00, 0x00, 0xd3, 0xb6, 0x00, 0x00, 0xd3, 0xdd, 0x00,
+    0x00, 0xd4, 0x07, 0x00, 0x00, 0xd4, 0x2f, 0x00, 0x00, 0xd4, 0x55, 0x00,
+    0x00, 0xd4, 0x7e, 0x00, 0x00, 0xd4, 0xa2, 0x00, 0x00, 0xd4, 0xcf, 0x00,
+    0x00, 0xd4, 0xf7, 0x00, 0x00, 0xd5, 0x1c, 0x00, 0x00, 0xd5, 0x43, 0x00,
+    0x00, 0xd5, 0x69, 0x00, 0x00, 0xd5, 0x8e, 0x00, 0x00, 0xd5, 0xb8, 0x00,
+    0x00, 0xd5, 0xda, 0x00, 0x00, 0xd5, 0xfd, 0x00, 0x00, 0xd6, 0x20, 0x00,
+    0x00, 0xd6, 0x42, 0x00, 0x00, 0xd6, 0x67, 0x00, 0x00, 0xd6, 0x89, 0x00,
+    0x00, 0xd6, 0xaf, 0x00, 0x00, 0xd6, 0xd3, 0x00, 0x00, 0xd6, 0xf3, 0x00,
+    0x00, 0xd7, 0x20, 0x00, 0x00, 0xd7, 0x43, 0x00, 0x00, 0xd7, 0x66, 0x00,
+    0x00, 0xd7, 0x89, 0x00, 0x00, 0xd7, 0xae, 0x00, 0x00, 0xd7, 0xd2, 0x00,
+    0x00, 0xd7, 0xf5, 0x00, 0x00, 0xd8, 0x1b, 0x00, 0x00, 0xd8, 0x3f, 0x00,
+    0x00, 0xd8, 0x60, 0x00, 0x00, 0xd8, 0x8d, 0x00, 0x00, 0xd8, 0xb0, 0x00,
+    0x00, 0xd8, 0xd6, 0x00, 0x00, 0xd8, 0xfa, 0x00, 0x00, 0xd9, 0x1c, 0x00,
+    0x00, 0xd9, 0x40, 0x00, 0x00, 0xd9, 0x64, 0x00, 0x00, 0xd9, 0x89, 0x00,
+    0x00, 0xd9, 0xb0, 0x00, 0x00, 0xd9, 0xd5, 0x00, 0x00, 0xd9, 0xfc, 0x00,
+    0x00, 0xda, 0x26, 0x00, 0x00, 0xda, 0x4b, 0x00, 0x00, 0xda, 0x6f, 0x00,
+    0x00, 0xda, 0x95, 0x00, 0x00, 0xda, 0xc0, 0x00, 0x00, 0xda, 0xe6, 0x00,
+    0x00, 0xdb, 0x10, 0x00, 0x00, 0xdb, 0x35, 0x00, 0x00, 0xdb, 0x63, 0x00,
+    0x00, 0xdb, 0x81, 0x00, 0x00, 0xdb, 0xab, 0x00, 0x00, 0xdb, 0xcf, 0x00,
+    0x00, 0xdb, 0xf6, 0x00, 0x00, 0xdc, 0x1b, 0x00, 0x00, 0xdc, 0x41, 0x00,
+    0x00, 0xdc, 0x6a, 0x00, 0x00, 0xdc, 0x97, 0x00, 0x00, 0xdc, 0xbd, 0x00,
+    0x00, 0xdc, 0xe2, 0x00, 0x00, 0xdd, 0x08, 0x00, 0x00, 0xdd, 0x32, 0x00,
+    0x00, 0xdd, 0x5e, 0x00, 0x00, 0xdd, 0x85, 0x00, 0x00, 0xdd, 0xaa, 0x00,
+    0x00, 0xdd, 0xd6, 0x00, 0x00, 0xde, 0x00, 0x00, 0x00, 0xde, 0x28, 0x00,
+    0x00, 0xde, 0x4c, 0x00, 0x00, 0xde, 0x6e, 0x00, 0x00, 0xde, 0x98, 0x00,
+    0x00, 0xde, 0xbe, 0x00, 0x00, 0xde, 0xe4, 0x00, 0x00, 0xdf, 0x0c, 0x00,
+    0x00, 0xdf, 0x39, 0x00, 0x00, 0xdf, 0x61, 0x00, 0x00, 0xdf, 0x87, 0x00,
+    0x00, 0xdf, 0xab, 0x00, 0x00, 0xdf, 0xce, 0x00, 0x00, 0xdf, 0xef, 0x00,
+    0x00, 0xe0, 0x12, 0x00, 0x00, 0xe0, 0x39, 0x00, 0x00, 0xe0, 0x60, 0x00,
+    0x00, 0xe0, 0x85, 0x00, 0x00, 0xe0, 0xab, 0x00, 0x00, 0xe0, 0xd4, 0x00,
+    0x00, 0xe0, 0xf5, 0x00, 0x00, 0xe1, 0x1b, 0x00, 0x00, 0xe1, 0x48, 0x00,
+    0x00, 0xe1, 0x70, 0x00, 0x00, 0xe1, 0x97, 0x00, 0x00, 0xe1, 0xb8, 0x00,
+    0x00, 0xe1, 0xdd, 0x00, 0x00, 0xe2, 0x06, 0x00, 0x00, 0xe2, 0x27, 0x00,
+    0x00, 0xe2, 0x4c, 0x00, 0x00, 0xe2, 0x6f, 0x00, 0x00, 0xe2, 0x9e, 0x00,
+    0x00, 0xe2, 0xc3, 0x00, 0x00, 0xe2, 0xea, 0x00, 0x00, 0xe3, 0x0f, 0x00,
+    0x00, 0xe3, 0x3a, 0x00, 0x00, 0xe3, 0x64, 0x00, 0x00, 0xe3, 0x87, 0x00,
+    0x00, 0xe3, 0xb4, 0x00, 0x00, 0xe3, 0xdc, 0x00, 0x00, 0xe4, 0x06, 0x00,
+    0x00, 0xe4, 0x2a, 0x00, 0x00, 0xe4, 0x52, 0x00, 0x00, 0xe4, 0x7b, 0x00,
+    0x00, 0xe4, 0xa1, 0x00, 0x00, 0xe4, 0xc7, 0x00, 0x00, 0xe4, 0xee, 0x00,
+    0x00, 0xe5, 0x12, 0x00, 0x00, 0xe5, 0x39, 0x00, 0x00, 0xe5, 0x62, 0x00,
+    0x00, 0xe5, 0x87, 0x00, 0x00, 0xe5, 0xaf, 0x00, 0x00, 0xe5, 0xd3, 0x00,
+    0x00, 0xe5, 0xf9, 0x00, 0x00, 0xe6, 0x1f, 0x00, 0x00, 0xe6, 0x48, 0x00,
+    0x00, 0xe6, 0x6b, 0x00, 0x00, 0xe6, 0x92, 0x00, 0x00, 0xe6, 0xbd, 0x00,
+    0x00, 0xe6, 0xe0, 0x00, 0x00, 0xe7, 0x08, 0x00, 0x00, 0xe7, 0x30, 0x00,
+    0x00, 0xe7, 0x54, 0x00, 0x00, 0xe7, 0x76, 0x00, 0x00, 0xe7, 0x9a, 0x00,
+    0x00, 0xe7, 0xbf, 0x00, 0x00, 0xe7, 0xed, 0x00, 0x00, 0xe8, 0x11, 0x00,
+    0x00, 0xe8, 0x39, 0x00, 0x00, 0xe8, 0x5d, 0x00, 0x00, 0xe8, 0x82, 0x00,
+    0x00, 0xe8, 0xab, 0x00, 0x00, 0xe8, 0xcc, 0x00, 0x00, 0xe8, 0xee, 0x00,
+    0x00, 0xe9, 0x15, 0x00, 0x00, 0xe9, 0x3e, 0x00, 0x00, 0xe9, 0x60, 0x00,
+    0x00, 0xe9, 0x86, 0x00, 0x00, 0xe9, 0xaf, 0x00, 0x00, 0xe9, 0xd1, 0x00,
+    0x00, 0xe9, 0xf5, 0x00, 0x00, 0xea, 0x1d, 0x00, 0x00, 0xea, 0x41, 0x00,
+    0x00, 0xea, 0x69, 0x00, 0x00, 0xea, 0x95, 0x00, 0x00, 0xea, 0xbf, 0x00,
+    0x00, 0xea, 0xe2, 0x00, 0x00, 0xeb, 0x09, 0x00, 0x00, 0xeb, 0x2c, 0x00,
+    0x00, 0xeb, 0x55, 0x00, 0x00, 0xeb, 0x7a, 0x00, 0x00, 0xeb, 0xa0, 0x00,
+    0x00, 0xeb, 0xc1, 0x00, 0x00, 0xeb, 0xe1, 0x00, 0x00, 0xec, 0x07, 0x00,
+    0x00, 0xec, 0x2a, 0x00, 0x00, 0xec, 0x4f, 0x00, 0x00, 0xec, 0x72, 0x00,
+    0x00, 0xec, 0x9a, 0x00, 0x00, 0xec, 0xc0, 0x00, 0x00, 0xec, 0xe4, 0x00,
+    0x00, 0xed, 0x09, 0x00, 0x00, 0xed, 0x30, 0x00, 0x00, 0xed, 0x55, 0x00,
+    0x00, 0xed, 0x76, 0x00, 0x00, 0xed, 0x9a, 0x00, 0x00, 0xed, 0xbe, 0x00,
+    0x00, 0xed, 0xe6, 0x00, 0x00, 0xee, 0x0b, 0x00, 0x00, 0xee, 0x34, 0x00,
+    0x00, 0xee, 0x5a, 0x00, 0x00, 0xee, 0x83, 0x00, 0x00, 0xee, 0xa7, 0x00,
+    0x00, 0xee, 0xcb, 0x00, 0x00, 0xee, 0xf1, 0x00, 0x00, 0xef, 0x18, 0x00,
+    0x00, 0xef, 0x41, 0x00, 0x00, 0xef, 0x61, 0x00, 0x00, 0xef, 0x84, 0x00,
+    0x00, 0xef, 0xa9, 0x00, 0x00, 0xef, 0xcb, 0x00, 0x00, 0xef, 0xec, 0x00,
+    0x00, 0xf0, 0x16, 0x00, 0x00, 0xf0, 0x3a, 0x00, 0x00, 0xf0, 0x60, 0x00,
+    0x00, 0xf0, 0x80, 0x00, 0x00, 0xf0, 0xa4, 0x00, 0x00, 0xf0, 0xc8, 0x00,
+    0x00, 0xf0, 0xf5, 0x00, 0x00, 0xf1, 0x1a, 0x00, 0x00, 0xf1, 0x3e, 0x00,
+    0x00, 0xf1, 0x60, 0x00, 0x00, 0xf1, 0x8b, 0x00, 0x00, 0xf1, 0xb2, 0x00,
+    0x00, 0xf1, 0xd8, 0x00, 0x00, 0xf1, 0xfc, 0x00, 0x00, 0xf2, 0x21, 0x00,
+    0x00, 0xf2, 0x48, 0x00, 0x00, 0xf2, 0x73, 0x00, 0x00, 0xf2, 0x9d, 0x00,
+    0x00, 0xf2, 0xbf, 0x00, 0x00, 0xf2, 0xe4, 0x00, 0x00, 0xf3, 0x09, 0x00,
+    0x00, 0xf3, 0x2a, 0x00, 0x00, 0xf3, 0x50, 0x00, 0x00, 0xf3, 0x74, 0x00,
+    0x00, 0xf3, 0x9a, 0x00, 0x00, 0xf3, 0xbb, 0x00, 0x00, 0xf3, 0xdf, 0x00,
+    0x00, 0xf4, 0x0a, 0x00, 0x00, 0xf4, 0x2b, 0x00, 0x00, 0xf4, 0x50, 0x00,
+    0x00, 0xf4, 0x70, 0x00, 0x00, 0xf4, 0x9b, 0x00, 0x00, 0xf4, 0xc2, 0x00,
+    0x00, 0xf4, 0xe3, 0x00, 0x00, 0xf5, 0x07, 0x00, 0x00, 0xf5, 0x2c, 0x00,
+    0x00, 0xf5, 0x54, 0x00, 0x00, 0xf5, 0x77, 0x00, 0x00, 0xf5, 0x9c, 0x00,
+    0x00, 0xf5, 0xc5, 0x00, 0x00, 0xf5, 0xea, 0x00, 0x00, 0xf6, 0x0f, 0x00,
+    0x00, 0xf6, 0x33, 0x00, 0x00, 0xf6, 0x57, 0x00, 0x00, 0xf6, 0x7b, 0x00,
+    0x00, 0xf6, 0xa3, 0x00, 0x00, 0xf6, 0xc7, 0x00, 0x00, 0xf6, 0xed, 0x00,
+    0x00, 0xf7, 0x16, 0x00, 0x00, 0xf7, 0x37, 0x00, 0x00, 0xf7, 0x60, 0x00,
+    0x00, 0xf7, 0x83, 0x00, 0x00, 0xf7, 0xa7, 0x00, 0x00, 0xf7, 0xcc, 0x00,
+    0x00, 0xf7, 0xf1, 0x00, 0x00, 0xf8, 0x16, 0x00, 0x00, 0xf8, 0x43, 0x00,
+    0x00, 0xf8, 0x69, 0x00, 0x00, 0xf8, 0x8d, 0x00, 0x00, 0xf8, 0xb8, 0x00,
+    0x00, 0xf8, 0xd8, 0x00, 0x00, 0xf9, 0x03, 0x00, 0x00, 0xf9, 0x28, 0x00,
+    0x00, 0xf9, 0x56, 0x00, 0x00, 0xf9, 0x7d, 0x00, 0x00, 0xf9, 0xa0, 0x00,
+    0x00, 0xf9, 0xca, 0x00, 0x00, 0xf9, 0xea, 0x00, 0x00, 0xfa, 0x0e, 0x00,
+    0x00, 0xfa, 0x32, 0x00, 0x00, 0xfa, 0x55, 0x00, 0x00, 0xfa, 0x79, 0x00,
+    0x00, 0xfa, 0x9c, 0x00, 0x00, 0xfa, 0xbf, 0x00, 0x00, 0xfa, 0xe3, 0x00,
+    0x00, 0xfb, 0x07, 0x00, 0x00, 0xfb, 0x2f, 0x00, 0x00, 0xfb, 0x58, 0x00,
+    0x00, 0xfb, 0x7c, 0x00, 0x00, 0xfb, 0x9f, 0x00, 0x00, 0xfb, 0xc7, 0x00,
+    0x00, 0xfb, 0xf7, 0x00, 0x00, 0xfc, 0x1e, 0x00, 0x00, 0xfc, 0x44, 0x00,
+    0x00, 0xfc, 0x69, 0x00, 0x00, 0xfc, 0x92, 0x00, 0x00, 0xfc, 0xc1, 0x00,
+    0x00, 0xfc, 0xe5, 0x00, 0x00, 0xfd, 0x09, 0x00, 0x00, 0xfd, 0x3a, 0x00,
+    0x00, 0xfd, 0x5c, 0x00, 0x00, 0xfd, 0x83, 0x00, 0x00, 0xfd, 0xad, 0x00,
+    0x00, 0xfd, 0xd6, 0x00, 0x00, 0xfd, 0xf9, 0x00, 0x00, 0xfe, 0x1c, 0x00,
+    0x00, 0xfe, 0x3e, 0x00, 0x00, 0xfe, 0x6f, 0x00, 0x00, 0xfe, 0x99, 0x00,
+    0x00, 0xfe, 0xb9, 0x00, 0x00, 0xfe, 0xe6, 0x00, 0x00, 0xff, 0x0c, 0x00,
+    0x00, 0xff, 0x33, 0x00, 0x00, 0xff, 0x54, 0x00, 0x00, 0xff, 0x7e, 0x00,
+    0x00, 0xff, 0xa3, 0x00, 0x00, 0xff, 0xc7, 0x00, 0x00, 0xff, 0xec, 0x00,
+    0x01, 0x00, 0x11, 0x00, 0x01, 0x00, 0x32, 0x00, 0x01, 0x00, 0x5a, 0x00,
+    0x01, 0x00, 0x7f, 0x00, 0x01, 0x00, 0xaa, 0x00, 0x01, 0x00, 0xd5, 0x00,
+    0x01, 0x00, 0xfe, 0x00, 0x01, 0x01, 0x22, 0x00, 0x01, 0x01, 0x4a, 0x00,
+    0x01, 0x01, 0x6f, 0x00, 0x01, 0x01, 0x94, 0x00, 0x01, 0x01, 0xbc, 0x00,
+    0x01, 0x01, 0xde, 0x00, 0x01, 0x01, 0xff, 0x00, 0x01, 0x02, 0x2d, 0x00,
+    0x01, 0x02, 0x50, 0x00, 0x01, 0x02, 0x7a, 0x00, 0x01, 0x02, 0x9d, 0x00,
+    0x01, 0x02, 0xc5, 0x00, 0x01, 0x02, 0xeb, 0x00, 0x01, 0x03, 0x17, 0x00,
+    0x01, 0x03, 0x39, 0x00, 0x01, 0x03, 0x5e, 0x00, 0x01, 0x03, 0x8d, 0x00,
+    0x01, 0x03, 0xb2, 0x00, 0x01, 0x03, 0xd6, 0x00, 0x01, 0x03, 0xf9, 0x00,
+    0x01, 0x04, 0x21, 0x00, 0x01, 0x04, 0x4a, 0x00, 0x01, 0x04, 0x71, 0x00,
+    0x01, 0x04, 0x92, 0x00, 0x01, 0x04, 0xb2, 0x00, 0x01, 0x04, 0xd5, 0x00,
+    0x01, 0x04, 0xf9, 0x00, 0x01, 0x05, 0x1f, 0x00, 0x01, 0x05, 0x47, 0x00,
+    0x01, 0x05, 0x75, 0x00, 0x01, 0x05, 0x9b, 0x00, 0x01, 0x05, 0xbb, 0x00,
+    0x01, 0x05, 0xe0, 0x00, 0x01, 0x06, 0x03, 0x00, 0x01, 0x06, 0x28, 0x00,
+    0x01, 0x06, 0x57, 0x00, 0x01, 0x06, 0x83, 0x00, 0x01, 0x06, 0xab, 0x00,
+    0x01, 0x06, 0xd0, 0x00, 0x01, 0x06, 0xfd, 0x00, 0x01, 0x07, 0x22, 0x00,
+    0x01, 0x07, 0x47, 0x00, 0x01, 0x07, 0x6d, 0x00, 0x01, 0x07, 0x92, 0x00,
+    0x01, 0x07, 0xb5, 0x00, 0x01, 0x07, 0xda, 0x00, 0x01, 0x07, 0xfe, 0x00,
+    0x01, 0x08, 0x27, 0x00, 0x01, 0x08, 0x4d, 0x00, 0x01, 0x08, 0x72, 0x00,
+    0x01, 0x08, 0x99, 0x00, 0x01, 0x08, 0xc4, 0x00, 0x01, 0x08, 0xeb, 0x00,
+    0x01, 0x09, 0x0f, 0x00, 0x01, 0x09, 0x35, 0x00, 0x01, 0x09, 0x58, 0x00,
+    0x01, 0x09, 0x82, 0x00, 0x01, 0x09, 0xa5, 0x00, 0x01, 0x09, 0xca, 0x00,
+    0x01, 0x09, 0xef, 0x00, 0x01, 0x0a, 0x11, 0x00, 0x01, 0x0a, 0x35, 0x00,
+    0x01, 0x0a, 0x5d, 0x00, 0x01, 0x0a, 0x7e, 0x00, 0x01, 0x0a, 0xa6, 0x00,
+    0x01, 0x0a, 0xd1, 0x00, 0x01, 0x0a, 0xf9, 0x00, 0x01, 0x0b, 0x20, 0x00,
+    0x01, 0x0b, 0x43, 0x00, 0x01, 0x0b, 0x69, 0x00, 0x01, 0x0b, 0x8e, 0x00,
+    0x01, 0x0b, 0xb2, 0x00, 0x01, 0x0b, 0xde, 0x00, 0x01, 0x0c, 0x03, 0x00,
+    0x01, 0x0c, 0x27, 0x00, 0x01, 0x0c, 0x4d, 0x00, 0x01, 0x0c, 0x74, 0x00,
+    0x01, 0x0c, 0x99, 0x00, 0x01, 0x0c, 0xbe, 0x00, 0x01, 0x0c, 0xdf, 0x00,
+    0x01, 0x0c, 0xff, 0x00, 0x01, 0x0d, 0x27, 0x00, 0x01, 0x0d, 0x4e, 0x00,
+    0x01, 0x0d, 0x76, 0x00, 0x01, 0x0d, 0xa0, 0x00, 0x01, 0x0d, 0xc4, 0x00,
+    0x01, 0x0d, 0xeb, 0x00, 0x01, 0x0e, 0x11, 0x00, 0x01, 0x0e, 0x35, 0x00,
+    0x01, 0x0e, 0x58, 0x00, 0x01, 0x0e, 0x7f, 0x00, 0x01, 0x0e, 0xa4, 0x00,
+    0x01, 0x0e, 0xce, 0x00, 0x01, 0x0e, 0xf4, 0x00, 0x01, 0x0f, 0x1d, 0x00,
+    0x01, 0x0f, 0x40, 0x00, 0x01, 0x0f, 0x64, 0x00, 0x01, 0x0f, 0x88, 0x00,
+    0x01, 0x0f, 0xb1, 0x00, 0x01, 0x0f, 0xd2, 0x00, 0x01, 0x0f, 0xfc, 0x00,
+    0x01, 0x10, 0x27, 0x00, 0x01, 0x10, 0x52, 0x00, 0x01, 0x10, 0x78, 0x00,
+    0x01, 0x10, 0x9b, 0x00, 0x01, 0x10, 0xc1, 0x00, 0x01, 0x10, 0xef, 0x00,
+    0x01, 0x11, 0x12, 0x00, 0x01, 0x11, 0x39, 0x00, 0x01, 0x11, 0x61, 0x00,
+    0x01, 0x11, 0x84, 0x00, 0x01, 0x11, 0xa7, 0x00, 0x01, 0x11, 0xcd, 0x00,
+    0x01, 0x11, 0xf2, 0x00, 0x01, 0x12, 0x1a, 0x00, 0x01, 0x12, 0x3e, 0x00,
+    0x01, 0x12, 0x64, 0x00, 0x01, 0x12, 0x88, 0x00, 0x01, 0x12, 0xa8, 0x00,
+    0x01, 0x12, 0xcf, 0x00, 0x01, 0x12, 0xf4, 0x00, 0x01, 0x13, 0x1b, 0x00,
+    0x01, 0x13, 0x42, 0x00, 0x01, 0x13, 0x63, 0x00, 0x01, 0x13, 0x87, 0x00,
+    0x01, 0x13, 0xb2, 0x00, 0x01, 0x13, 0xdb, 0x00, 0x01, 0x14, 0x02, 0x00,
+    0x01, 0x14, 0x24, 0x00, 0x01, 0x14, 0x49, 0x00, 0x01, 0x14, 0x6b, 0x00,
+    0x01, 0x14, 0x94, 0x00, 0x01, 0x14, 0xb9, 0x00, 0x01, 0x14, 0xdc, 0x00,
+    0x01, 0x14, 0xfe, 0x00, 0x01, 0x15, 0x22, 0x00, 0x01, 0x15, 0x46, 0x00,
+    0x01, 0x15, 0x76, 0x00, 0x01, 0x15, 0x95, 0x00, 0x01, 0x15, 0xbb, 0x00,
+    0x01, 0x15, 0xe2, 0x00, 0x01, 0x16, 0x0d, 0x00, 0x01, 0x16, 0x36, 0x00,
+    0x01, 0x16, 0x5d, 0x00, 0x01, 0x16, 0x7e, 0x00, 0x01, 0x16, 0xaa, 0x00,
+    0x01, 0x16, 0xca, 0x00, 0x01, 0x16, 0xf2, 0x00, 0x01, 0x17, 0x16, 0x00,
+    0x01, 0x17, 0x3f, 0x00, 0x01, 0x17, 0x65, 0x00, 0x01, 0x17, 0x8b, 0x00,
+    0x01, 0x17, 0xad, 0x00, 0x01, 0x17, 0xd2, 0x00, 0x01, 0x17, 0xf5, 0x00,
+    0x01, 0x18, 0x1b, 0x00, 0x01, 0x18, 0x3f, 0x00, 0x01, 0x18, 0x65, 0x00,
+    0x01, 0x18, 0x85, 0x00, 0x01, 0x18, 0xb2, 0x00, 0x01, 0x18, 0xd4, 0x00,
+    0x01, 0x18, 0xff, 0x00, 0x01, 0x19, 0x2f, 0x00, 0x01, 0x19, 0x52, 0x00,
+    0x01, 0x19, 0x80, 0x00, 0x01, 0x19, 0xa1, 0x00, 0x01, 0x19, 0xc4, 0x00,
+    0x01, 0x19, 0xe9, 0x00, 0x01, 0x1a, 0x0d, 0x00, 0x01, 0x1a, 0x2d, 0x00,
+    0x01, 0x1a, 0x50, 0x00, 0x01, 0x1a, 0x77, 0x00, 0x01, 0x1a, 0x9c, 0x00,
+    0x01, 0x1a, 0xbf, 0x00, 0x01, 0x1a, 0xe3, 0x00, 0x01, 0x1b, 0x05, 0x00,
+    0x01, 0x1b, 0x2b, 0x00, 0x01, 0x1b, 0x51, 0x00, 0x01, 0x1b, 0x76, 0x00,
+    0x01, 0x1b, 0x9a, 0x00, 0x01, 0x1b, 0xbc, 0x00, 0x01, 0x1b, 0xe0, 0x00,
+    0x01, 0x1c, 0x05, 0x00, 0x01, 0x1c, 0x2c, 0x00, 0x01, 0x1c, 0x5b, 0x00,
+    0x01, 0x1c, 0x80, 0x00, 0x01, 0x1c, 0xa6, 0x00, 0x01, 0x1c, 0xcb, 0x00,
+    0x01, 0x1c, 0xee, 0x00, 0x01, 0x1d, 0x0f, 0x00, 0x01, 0x1d, 0x33, 0x00,
+    0x01, 0x1d, 0x56, 0x00, 0x01, 0x1d, 0x7c, 0x00, 0x01, 0x1d, 0xa4, 0x00,
+    0x01, 0x1d, 0xc4, 0x00, 0x01, 0x1d, 0xe6, 0x00, 0x01, 0x1e, 0x08, 0x00,
+    0x01, 0x1e, 0x31, 0x00, 0x01, 0x1e, 0x54, 0x00, 0x01, 0x1e, 0x7b, 0x00,
+    0x01, 0x1e, 0xa5, 0x00, 0x01, 0x1e, 0xcb, 0x00, 0x01, 0x1e, 0xf6, 0x00,
+    0x01, 0x1f, 0x1a, 0x00, 0x01, 0x1f, 0x43, 0x00, 0x01, 0x1f, 0x66, 0x00,
+    0x01, 0x1f, 0x87, 0x00, 0x01, 0x1f, 0xac, 0x00, 0x01, 0x1f, 0xd4, 0x00,
+    0x01, 0x1f, 0xfa, 0x00, 0x01, 0x20, 0x21, 0x00, 0x01, 0x20, 0x44, 0x00,
+    0x01, 0x20, 0x68, 0x00, 0x01, 0x20, 0x8d, 0x00, 0x01, 0x20, 0xb9, 0x00,
+    0x01, 0x20, 0xdc, 0x00, 0x01, 0x21, 0x06, 0x00, 0x01, 0x21, 0x35, 0x00,
+    0x01, 0x21, 0x62, 0x00, 0x01, 0x21, 0x8a, 0x00, 0x01, 0x21, 0xab, 0x00,
+    0x01, 0x21, 0xd3, 0x00, 0x01, 0x21, 0xfa, 0x00, 0x01, 0x22, 0x1c, 0x00,
+    0x01, 0x22, 0x42, 0x00, 0x01, 0x22, 0x65, 0x00, 0x01, 0x22, 0x89, 0x00,
+    0x01, 0x22, 0xad, 0x00, 0x01, 0x22, 0xd2, 0x00, 0x01, 0x22, 0xf7, 0x00,
+    0x01, 0x23, 0x1c, 0x00, 0x01, 0x23, 0x43, 0x00, 0x01, 0x23, 0x66, 0x00,
+    0x01, 0x23, 0x8e, 0x00, 0x01, 0x23, 0xb1, 0x00, 0x01, 0x23, 0xde, 0x00,
+    0x01, 0x24, 0x01, 0x00, 0x01, 0x24, 0x27, 0x00, 0x01, 0x24, 0x4c, 0x00,
+    0x01, 0x24, 0x6c, 0x00, 0x01, 0x24, 0x90, 0x00, 0x01, 0x24, 0xba, 0x00,
+    0x01, 0x24, 0xdd, 0x00, 0x01, 0x25, 0x08, 0x00, 0x01, 0x25, 0x2f, 0x00,
+    0x01, 0x25, 0x56, 0x00, 0x01, 0x25, 0x78, 0x00, 0x01, 0x25, 0x99, 0x00,
+    0x01, 0x25, 0xc2, 0x00, 0x01, 0x25, 0xec, 0x00, 0x01, 0x26, 0x12, 0x00,
+    0x01, 0x26, 0x34, 0x00, 0x01, 0x26, 0x5a, 0x00, 0x01, 0x26, 0x80, 0x00,
+    0x01, 0x26, 0xa4, 0x00, 0x01, 0x26, 0xc6, 0x00, 0x01, 0x26, 0xf4, 0x00,
+    0x01, 0x27, 0x20, 0x00, 0x01, 0x27, 0x48, 0x00, 0x01, 0x27, 0x6b, 0x00,
+    0x01, 0x27, 0x8f, 0x00, 0x01, 0x27, 0xb3, 0x00, 0x01, 0x27, 0xde, 0x00,
+    0x01, 0x28, 0x02, 0x00, 0x01, 0x28, 0x22, 0x00, 0x01, 0x28, 0x41, 0x00,
+    0x01, 0x28, 0x65, 0x00, 0x01, 0x28, 0x88, 0x00, 0x01, 0x28, 0xab, 0x00,
+    0x01, 0x28, 0xd4, 0x00, 0x01, 0x28, 0xfd, 0x00, 0x01, 0x29, 0x1f, 0x00,
+    0x01, 0x29, 0x45, 0x00, 0x01, 0x29, 0x73, 0x00, 0x01, 0x29, 0x99, 0x00,
+    0x01, 0x29, 0xbf, 0x00, 0x01, 0x29, 0xe3, 0x00, 0x01, 0x2a, 0x05, 0x00,
+    0x01, 0x2a, 0x2b, 0x00, 0x01, 0x2a, 0x4e, 0x00, 0x01, 0x2a, 0x73, 0x00,
+    0x01, 0x2a, 0x98, 0x00, 0x01, 0x2a, 0xc2, 0x00, 0x01, 0x2a, 0xeb, 0x00,
+    0x01, 0x2b, 0x12, 0x00, 0x01, 0x2b, 0x39, 0x00, 0x01, 0x2b, 0x5d, 0x00,
+    0x01, 0x2b, 0x89, 0x00, 0x01, 0x2b, 0xac, 0x00, 0x01, 0x2b, 0xd2, 0x00,
+    0x01, 0x2b, 0xf9, 0x00, 0x01, 0x2c, 0x1b, 0x00, 0x01, 0x2c, 0x41, 0x00,
+    0x01, 0x2c, 0x68, 0x00, 0x01, 0x2c, 0x8c, 0x00, 0x01, 0x2c, 0xb1, 0x00,
+    0x01, 0x2c, 0xd7, 0x00, 0x01, 0x2c, 0xfe, 0x00, 0x01, 0x2d, 0x1e, 0x00,
+    0x01, 0x2d, 0x49, 0x00, 0x01, 0x2d, 0x6e, 0x00, 0x01, 0x2d, 0x9a, 0x00,
+    0x01, 0x2d, 0xbe, 0x00, 0x01, 0x2d, 0xe1, 0x00, 0x01, 0x2e, 0x0a, 0x00,
+    0x01, 0x2e, 0x31, 0x00, 0x01, 0x2e, 0x5a, 0x00, 0x01, 0x2e, 0x7c, 0x00,
+    0x01, 0x2e, 0x9f, 0x00, 0x01, 0x2e, 0xc4, 0x00, 0x01, 0x2e, 0xec, 0x00,
+    0x01, 0x2f, 0x0d, 0x00, 0x01, 0x2f, 0x38, 0x00, 0x01, 0x2f, 0x5e, 0x00,
+    0x01, 0x2f, 0x81, 0x00, 0x01, 0x2f, 0xa2, 0x00, 0x01, 0x2f, 0xc9, 0x00,
+    0x01, 0x2f, 0xea, 0x00, 0x01, 0x30, 0x15, 0x00, 0x01, 0x30, 0x3a, 0x00,
+    0x01, 0x30, 0x60, 0x00, 0x01, 0x30, 0x88, 0x00, 0x01, 0x30, 0xaf, 0x00,
+    0x01, 0x30, 0xd7, 0x00, 0x01, 0x30, 0xfc, 0x00, 0x01, 0x31, 0x1f, 0x00,
+    0x01, 0x31, 0x47, 0x00, 0x01, 0x31, 0x73, 0x00, 0x01, 0x31, 0x94, 0x00,
+    0x01, 0x31, 0xb9, 0x00, 0x01, 0x31, 0xe3, 0x00, 0x01, 0x32, 0x03, 0x00,
+    0x01, 0x32, 0x29, 0x00, 0x01, 0x32, 0x4f, 0x00, 0x01, 0x32, 0x7a, 0x00,
+    0x01, 0x32, 0x9e, 0x00, 0x01, 0x32, 0xc5, 0x00, 0x01, 0x32, 0xe9, 0x00,
+    0x01, 0x33, 0x0c, 0x00, 0x01, 0x33, 0x33, 0x00, 0x01, 0x33, 0x59, 0x00,
+    0x01, 0x33, 0x80, 0x00, 0x01, 0x33, 0xab, 0x00, 0x01, 0x33, 0xd3, 0x00,
+    0x01, 0x33, 0xfc, 0x00, 0x01, 0x34, 0x23, 0x00, 0x01, 0x34, 0x47, 0x00,
+    0x01, 0x34, 0x72, 0x00, 0x01, 0x34, 0x96, 0x00, 0x01, 0x34, 0xb8, 0x00,
+    0x01, 0x34, 0xdf, 0x00, 0x01, 0x35, 0x08, 0x00, 0x01, 0x35, 0x2c, 0x00,
+    0x01, 0x35, 0x50, 0x00, 0x01, 0x35, 0x77, 0x00, 0x01, 0x35, 0x98, 0x00,
+    0x01, 0x35, 0xb8, 0x00, 0x01, 0x35, 0xe1, 0x00, 0x01, 0x36, 0x06, 0x00,
+    0x01, 0x36, 0x28, 0x00, 0x01, 0x36, 0x4e, 0x00, 0x01, 0x36, 0x78, 0x00,
+    0x01, 0x36, 0x9c, 0x00, 0x01, 0x36, 0xc1, 0x00, 0x01, 0x36, 0xec, 0x00,
+    0x01, 0x37, 0x10, 0x00, 0x01, 0x37, 0x35, 0x00, 0x01, 0x37, 0x64, 0x00,
+    0x01, 0x37, 0x8b, 0x00, 0x01, 0x37, 0xb0, 0x00, 0x01, 0x37, 0xd2, 0x00,
+    0x01, 0x37, 0xf8, 0x00, 0x01, 0x38, 0x21, 0x00, 0x01, 0x38, 0x46, 0x00,
+    0x01, 0x38, 0x66, 0x00, 0x01, 0x38, 0x8e, 0x00, 0x01, 0x38, 0xb2, 0x00,
+    0x01, 0x38, 0xd4, 0x00, 0x01, 0x38, 0xfd, 0x00, 0x01, 0x39, 0x29, 0x00,
+    0x01, 0x39, 0x4c, 0x00, 0x01, 0x39, 0x71, 0x00, 0x01, 0x39, 0x99, 0x00,
+    0x01, 0x39, 0xc2, 0x00, 0x01, 0x39, 0xe7, 0x00, 0x01, 0x3a, 0x09, 0x00,
+    0x01, 0x3a, 0x32, 0x00, 0x01, 0x3a, 0x62, 0x00, 0x01, 0x3a, 0x87, 0x00,
+    0x01, 0x3a, 0xad, 0x00, 0x01, 0x3a, 0xd4, 0x00, 0x01, 0x3a, 0xf6, 0x00,
+    0x01, 0x3b, 0x1b, 0x00, 0x01, 0x3b, 0x3f, 0x00, 0x01, 0x3b, 0x63, 0x00,
+    0x01, 0x3b, 0x88, 0x00, 0x01, 0x3b, 0xb8, 0x00, 0x01, 0x3b, 0xe0, 0x00,
+    0x01, 0x3c, 0x03, 0x00, 0x01, 0x3c, 0x32, 0x00, 0x01, 0x3c, 0x58, 0x00,
+    0x01, 0x3c, 0x7e, 0x00, 0x01, 0x3c, 0x9f, 0x00, 0x01, 0x3c, 0xc4, 0x00,
+    0x01, 0x3c, 0xeb, 0x00, 0x01, 0x3d, 0x10, 0x00, 0x01, 0x3d, 0x38, 0x00,
+    0x01, 0x3d, 0x5f, 0x00, 0x01, 0x3d, 0x83, 0x00, 0x01, 0x3d, 0xa8, 0x00,
+    0x01, 0x3d, 0xcc, 0x00, 0x01, 0x3d, 0xf2, 0x00, 0x01, 0x3e, 0x19, 0x00,
+    0x01, 0x3e, 0x3f, 0x00, 0x01, 0x3e, 0x63, 0x00, 0x01, 0x3e, 0x85, 0x00,
+    0x01, 0x3e, 0xa9, 0x00, 0x01, 0x3e, 0xd0, 0x00, 0x01, 0x3e, 0xf4, 0x00,
+    0x01, 0x3f, 0x1b, 0x00, 0x01, 0x3f, 0x3a, 0x00, 0x01, 0x3f, 0x65, 0x00,
+    0x01, 0x3f, 0x8e, 0x00, 0x01, 0x3f, 0xb7, 0x00, 0x01, 0x3f, 0xdc, 0x00,
+    0x01, 0x3f, 0xff, 0x00, 0x01, 0x40, 0x2b, 0x00, 0x01, 0x40, 0x52, 0x00,
+    0x01, 0x40, 0x77, 0x00, 0x01, 0x40, 0x9b, 0x00, 0x01, 0x40, 0xc1, 0x00,
+    0x01, 0x40, 0xe7, 0x00, 0x01, 0x41, 0x0f, 0x00, 0x01, 0x41, 0x39, 0x00,
+    0x01, 0x41, 0x5e, 0x00, 0x01, 0x41, 0x87, 0x00, 0x01, 0x41, 0xaf, 0x00,
+    0x01, 0x41, 0xcf, 0x00, 0x01, 0x41, 0xf5, 0x00, 0x01, 0x42, 0x1f, 0x00,
+    0x01, 0x42, 0x48, 0x00, 0x01, 0x42, 0x6f, 0x00, 0x01, 0x42, 0x96, 0x00,
+    0x01, 0x42, 0xbf, 0x00, 0x01, 0x42, 0xeb, 0x00, 0x01, 0x43, 0x13, 0x00,
+    0x01, 0x43, 0x3c, 0x00, 0x01, 0x43, 0x5e, 0x00, 0x01, 0x43, 0x89, 0x00,
+    0x01, 0x43, 0xaa, 0x00, 0x01, 0x43, 0xce, 0x00, 0x01, 0x43, 0xfa, 0x00,
+    0x01, 0x44, 0x20, 0x00, 0x01, 0x44, 0x45, 0x00, 0x01, 0x44, 0x69, 0x00,
+    0x01, 0x44, 0x8c, 0x00, 0x01, 0x44, 0xb8, 0x00, 0x01, 0x44, 0xda, 0x00,
+    0x01, 0x44, 0xfe, 0x00, 0x01, 0x45, 0x1f, 0x00, 0x01, 0x45, 0x47, 0x00,
+    0x01, 0x45, 0x6b, 0x00, 0x01, 0x45, 0x98, 0x00, 0x01, 0x45, 0xba, 0x00,
+    0x01, 0x45, 0xde, 0x00, 0x01, 0x46, 0x02, 0x00, 0x01, 0x46, 0x29, 0x00,
+    0x01, 0x46, 0x54, 0x00, 0x01, 0x46, 0x78, 0x00, 0x01, 0x46, 0x9d, 0x00,
+    0x01, 0x46, 0xc0, 0x00, 0x01, 0x46, 0xe7, 0x00, 0x01, 0x47, 0x09, 0x00,
+    0x01, 0x47, 0x2c, 0x00, 0x01, 0x47, 0x4e, 0x00, 0x01, 0x47, 0x75, 0x00,
+    0x01, 0x47, 0x9f, 0x00, 0x01, 0x47, 0xc7, 0x00, 0x01, 0x47, 0xed, 0x00,
+    0x01, 0x48, 0x14, 0x00, 0x01, 0x48, 0x38, 0x00, 0x01, 0x48, 0x5c, 0x00,
+    0x01, 0x48, 0x7f, 0x00, 0x01, 0x48, 0xa4, 0x00, 0x01, 0x48, 0xcb, 0x00,
+    0x01, 0x48, 0xf2, 0x00, 0x01, 0x49, 0x17, 0x00, 0x01, 0x49, 0x3e, 0x00,
+    0x01, 0x49, 0x5e, 0x00, 0x01, 0x49, 0x82, 0x00, 0x01, 0x49, 0xaa, 0x00,
+    0x01, 0x49, 0xcd, 0x00, 0x01, 0x49, 0xf1, 0x00, 0x01, 0x4a, 0x16, 0x00,
+    0x01, 0x4a, 0x37, 0x00, 0x01, 0x4a, 0x59, 0x00, 0x01, 0x4a, 0x7e, 0x00,
+    0x01, 0x4a, 0xa4, 0x00, 0x01, 0x4a, 0xcd, 0x00, 0x01, 0x4a, 0xf2, 0x00,
+    0x01, 0x4b, 0x1c, 0x00, 0x01, 0x4b, 0x49, 0x00, 0x01, 0x4b, 0x6b, 0x00,
+    0x01, 0x4b, 0x8e, 0x00, 0x01, 0x4b, 0xb3, 0x00, 0x01, 0x4b, 0xdb, 0x00,
+    0x01, 0x4c, 0x0b, 0x00, 0x01, 0x4c, 0x30, 0x00, 0x01, 0x4c, 0x5a, 0x00,
+    0x01, 0x4c, 0x81, 0x00, 0x01, 0x4c, 0xa9, 0x00, 0x01, 0x4c, 0xcb, 0x00,
+    0x01, 0x4c, 0xf1, 0x00, 0x01, 0x4d, 0x1c, 0x00, 0x01, 0x4d, 0x3d, 0x00,
+    0x01, 0x4d, 0x63, 0x00, 0x01, 0x4d, 0x88, 0x00, 0x01, 0x4d, 0xaf, 0x00,
+    0x01, 0x4d, 0xd5, 0x00, 0x01, 0x4d, 0xf9, 0x00, 0x01, 0x4e, 0x26, 0x00,
+    0x01, 0x4e, 0x4a, 0x00, 0x01, 0x4e, 0x6f, 0x00, 0x01, 0x4e, 0x94, 0x00,
+    0x01, 0x4e, 0xc1, 0x00, 0x01, 0x4e, 0xe7, 0x00, 0x01, 0x4f, 0x16, 0x00,
+    0x01, 0x4f, 0x3a, 0x00, 0x01, 0x4f, 0x61, 0x00, 0x01, 0x4f, 0x88, 0x00,
+    0x01, 0x4f, 0xad, 0x00, 0x01, 0x4f, 0xd7, 0x00, 0x01, 0x4f, 0xff, 0x00,
+    0x01, 0x50, 0x21, 0x00, 0x01, 0x50, 0x44, 0x00, 0x01, 0x50, 0x65, 0x00,
+    0x01, 0x50, 0x90, 0x00, 0x01, 0x50, 0xb6, 0x00, 0x01, 0x50, 0xe3, 0x00,
+    0x01, 0x51, 0x07, 0x00, 0x01, 0x51, 0x2f, 0x00, 0x01, 0x51, 0x55, 0x00,
+    0x01, 0x51, 0x7a, 0x00, 0x01, 0x51, 0xa3, 0x00, 0x01, 0x51, 0xcb, 0x00,
+    0x01, 0x51, 0xf0, 0x00, 0x01, 0x52, 0x17, 0x00, 0x01, 0x52, 0x43, 0x00,
+    0x01, 0x52, 0x68, 0x00, 0x01, 0x52, 0x8c, 0x00, 0x01, 0x52, 0xb6, 0x00,
+    0x01, 0x52, 0xda, 0x00, 0x01, 0x53, 0x04, 0x00, 0x01, 0x53, 0x2b, 0x00,
+    0x01, 0x53, 0x50, 0x00, 0x01, 0x53, 0x77, 0x00, 0x01, 0x53, 0xa1, 0x00,
+    0x01, 0x53, 0xcb, 0x00, 0x01, 0x53, 0xf0, 0x00, 0x01, 0x54, 0x1b, 0x00,
+    0x01, 0x54, 0x3d, 0x00, 0x01, 0x54, 0x61, 0x00, 0x01, 0x54, 0x85, 0x00,
+    0x01, 0x54, 0xac, 0x00, 0x01, 0x54, 0xd5, 0x00, 0x01, 0x54, 0xff, 0x00,
+    0x01, 0x55, 0x2c, 0x00, 0x01, 0x55, 0x53, 0x00, 0x01, 0x55, 0x7e, 0x00,
+    0x01, 0x55, 0xa6, 0x00, 0x01, 0x55, 0xc8, 0x00, 0x01, 0x55, 0xf0, 0x00,
+    0x01, 0x56, 0x1b, 0x00, 0x01, 0x56, 0x41, 0x00, 0x01, 0x56, 0x65, 0x00,
+    0x01, 0x56, 0x89, 0x00, 0x01, 0x56, 0xb4, 0x00, 0x01, 0x56, 0xdb, 0x00,
+    0x01, 0x57, 0x00, 0x00, 0x01, 0x57, 0x26, 0x00, 0x01, 0x57, 0x4a, 0x00,
+    0x01, 0x57, 0x6f, 0x00, 0x01, 0x57, 0x94, 0x00, 0x01, 0x57, 0xb6, 0x00,
+    0x01, 0x57, 0xdc, 0x00, 0x01, 0x58, 0x03, 0x00, 0x01, 0x58, 0x2d, 0x00,
+    0x01, 0x58, 0x52, 0x00, 0x01, 0x58, 0x77, 0x00, 0x01, 0x58, 0xa1, 0x00,
+    0x01, 0x58, 0xcf, 0x00, 0x01, 0x58, 0xf9, 0x00, 0x01, 0x59, 0x1b, 0x00,
+    0x01, 0x59, 0x46, 0x00, 0x01, 0x59, 0x6c, 0x00, 0x01, 0x59, 0x92, 0x00,
+    0x01, 0x59, 0xb6, 0x00, 0x01, 0x59, 0xdd, 0x00, 0x01, 0x5a, 0x05, 0x00,
+    0x01, 0x5a, 0x2b, 0x00, 0x01, 0x5a, 0x50, 0x00, 0x01, 0x5a, 0x75, 0x00,
+    0x01, 0x5a, 0x9b, 0x00, 0x01, 0x5a, 0xc1, 0x00, 0x01, 0x5a, 0xe6, 0x00,
+    0x01, 0x5b, 0x0b, 0x00, 0x01, 0x5b, 0x32, 0x00, 0x01, 0x5b, 0x55, 0x00,
+    0x01, 0x5b, 0x82, 0x00, 0x01, 0x5b, 0xa8, 0x00, 0x01, 0x5b, 0xcd, 0x00,
+    0x01, 0x5b, 0xfa, 0x00, 0x01, 0x5c, 0x1e, 0x00, 0x01, 0x5c, 0x43, 0x00,
+    0x01, 0x5c, 0x6e, 0x00, 0x01, 0x5c, 0x97, 0x00, 0x01, 0x5c, 0xc1, 0x00,
+    0x01, 0x5c, 0xe5, 0x00, 0x01, 0x5d, 0x0f, 0x00, 0x01, 0x5d, 0x37, 0x00,
+    0x01, 0x5d, 0x5d, 0x00, 0x01, 0x5d, 0x82, 0x00, 0x01, 0x5d, 0xa7, 0x00,
+    0x01, 0x5d, 0xcf, 0x00, 0x01, 0x5d, 0xf1, 0x00, 0x01, 0x5e, 0x18, 0x00,
+    0x01, 0x5e, 0x3a, 0x00, 0x01, 0x5e, 0x5b, 0x00, 0x01, 0x5e, 0x7f, 0x00,
+    0x01, 0x5e, 0xa5, 0x00, 0x01, 0x5e, 0xc9, 0x00, 0x01, 0x5e, 0xee, 0x00,
+    0x01, 0x5f, 0x14, 0x00, 0x01, 0x5f, 0x3b, 0x00, 0x01, 0x5f, 0x69, 0x00,
+    0x01, 0x5f, 0x8d, 0x00, 0x01, 0x5f, 0xb0, 0x00, 0x01, 0x5f, 0xd0, 0x00,
+    0x01, 0x5f, 0xf9, 0x00, 0x01, 0x60, 0x24, 0x00, 0x01, 0x60, 0x49, 0x00,
+    0x01, 0x60, 0x6e, 0x00, 0x01, 0x60, 0x97, 0x00, 0x01, 0x60, 0xbd, 0x00,
+    0x01, 0x60, 0xe3, 0x00, 0x01, 0x61, 0x06, 0x00, 0x01, 0x61, 0x33, 0x00,
+    0x01, 0x61, 0x56, 0x00, 0x01, 0x61, 0x7c, 0x00, 0x01, 0x61, 0xa3, 0x00,
+    0x01, 0x61, 0xc4, 0x00, 0x01, 0x61, 0xe9, 0x00, 0x01, 0x62, 0x16, 0x00,
+    0x01, 0x62, 0x39, 0x00, 0x01, 0x62, 0x5c, 0x00, 0x01, 0x62, 0x84, 0x00,
+    0x01, 0x62, 0xa9, 0x00, 0x01, 0x62, 0xd2, 0x00, 0x01, 0x62, 0xf3, 0x00,
+    0x01, 0x63, 0x17, 0x00, 0x01, 0x63, 0x3e, 0x00, 0x01, 0x63, 0x63, 0x00,
+    0x01, 0x63, 0x85, 0x00, 0x01, 0x63, 0xae, 0x00, 0x01, 0x63, 0xd8, 0x00,
+    0x01, 0x64, 0x00, 0x00, 0x01, 0x64, 0x25, 0x00, 0x01, 0x64, 0x4c, 0x00,
+    0x01, 0x64, 0x75, 0x00, 0x01, 0x64, 0x9b, 0x00, 0x01, 0x64, 0xbe, 0x00,
+    0x01, 0x64, 0xe7, 0x00, 0x01, 0x65, 0x07, 0x00, 0x01, 0x65, 0x2b, 0x00,
+    0x01, 0x65, 0x51, 0x00, 0x01, 0x65, 0x77, 0x00, 0x01, 0x65, 0x9a, 0x00,
+    0x01, 0x65, 0xb9, 0x00, 0x01, 0x65, 0xe1, 0x00, 0x01, 0x66, 0x04, 0x00,
+    0x01, 0x66, 0x31, 0x00, 0x01, 0x66, 0x56, 0x00, 0x01, 0x66, 0x7e, 0x00,
+    0x01, 0x66, 0xa5, 0x00, 0x01, 0x66, 0xcb, 0x00, 0x01, 0x66, 0xf3, 0x00,
+    0x01, 0x67, 0x1d, 0x00, 0x01, 0x67, 0x41, 0x00, 0x01, 0x67, 0x65, 0x00,
+    0x01, 0x67, 0x8c, 0x00, 0x01, 0x67, 0xad, 0x00, 0x01, 0x67, 0xd3, 0x00,
+    0x01, 0x67, 0xf8, 0x00, 0x01, 0x68, 0x1e, 0x00, 0x01, 0x68, 0x42, 0x00,
+    0x01, 0x68, 0x6a, 0x00, 0x01, 0x68, 0x8c, 0x00, 0x01, 0x68, 0xb6, 0x00,
+    0x01, 0x68, 0xdf, 0x00, 0x01, 0x69, 0x04, 0x00, 0x01, 0x69, 0x2a, 0x00,
+    0x01, 0x69, 0x52, 0x00, 0x01, 0x69, 0x76, 0x00, 0x01, 0x69, 0x9b, 0x00,
+    0x01, 0x69, 0xc1, 0x00, 0x01, 0x69, 0xe7, 0x00, 0x01, 0x6a, 0x10, 0x00,
+    0x01, 0x6a, 0x35, 0x00, 0x01, 0x6a, 0x5e, 0x00, 0x01, 0x6a, 0x89, 0x00,
+    0x01, 0x6a, 0xb2, 0x00, 0x01, 0x6a, 0xd8, 0x00, 0x01, 0x6b, 0x01, 0x00,
+    0x01, 0x6b, 0x28, 0x00, 0x01, 0x6b, 0x52, 0x00, 0x01, 0x6b, 0x77, 0x00,
+    0x01, 0x6b, 0x9e, 0x00, 0x01, 0x6b, 0xc1, 0x00, 0x01, 0x6b, 0xe8, 0x00,
+    0x01, 0x6c, 0x0b, 0x00, 0x01, 0x6c, 0x2f, 0x00, 0x01, 0x6c, 0x5a, 0x00,
+    0x01, 0x6c, 0x7f, 0x00, 0x01, 0x6c, 0xa2, 0x00, 0x01, 0x6c, 0xc6, 0x00,
+    0x01, 0x6c, 0xec, 0x00, 0x01, 0x6d, 0x10, 0x00, 0x01, 0x6d, 0x36, 0x00,
+    0x01, 0x6d, 0x58, 0x00, 0x01, 0x6d, 0x78, 0x00, 0x01, 0x6d, 0x9b, 0x00,
+    0x01, 0x6d, 0xbf, 0x00, 0x01, 0x6d, 0xe0, 0x00, 0x01, 0x6e, 0x06, 0x00,
+    0x01, 0x6e, 0x2c, 0x00, 0x01, 0x6e, 0x55, 0x00, 0x01, 0x6e, 0x7f, 0x00,
+    0x01, 0x6e, 0xa6, 0x00, 0x01, 0x6e, 0xd1, 0x00, 0x01, 0x6e, 0xf9, 0x00,
+    0x01, 0x6f, 0x23, 0x00, 0x01, 0x6f, 0x49, 0x00, 0x01, 0x6f, 0x6b, 0x00,
+    0x01, 0x6f, 0x8c, 0x00, 0x01, 0x6f, 0xb1, 0x00, 0x01, 0x6f, 0xd4, 0x00,
+    0x01, 0x6f, 0xfe, 0x00, 0x01, 0x70, 0x25, 0x00, 0x01, 0x70, 0x4b, 0x00,
+    0x01, 0x70, 0x6e, 0x00, 0x01, 0x70, 0x95, 0x00, 0x01, 0x70, 0xb5, 0x00,
+    0x01, 0x70, 0xd9, 0x00, 0x01, 0x71, 0x00, 0x00, 0x01, 0x71, 0x25, 0x00,
+    0x01, 0x71, 0x49, 0x00, 0x01, 0x71, 0x6c, 0x00, 0x01, 0x71, 0x8f, 0x00,
+    0x01, 0x71, 0xb0, 0x00, 0x01, 0x71, 0xd9, 0x00, 0x01, 0x72, 0x01, 0x00,
+    0x01, 0x72, 0x27, 0x00, 0x01, 0x72, 0x4b, 0x00, 0x01, 0x72, 0x76, 0x00,
+    0x01, 0x72, 0x98, 0x00, 0x01, 0x72, 0xbd, 0x00, 0x01, 0x72, 0xe2, 0x00,
+    0x01, 0x73, 0x02, 0x00, 0x01, 0x73, 0x20, 0x00, 0x01, 0x73, 0x3f, 0x00,
+    0x01, 0x73, 0x64, 0x00, 0x01, 0x73, 0x8b, 0x00, 0x01, 0x73, 0xb0, 0x00,
+    0x01, 0x73, 0xd6, 0x00, 0x01, 0x73, 0xfc, 0x00, 0x01, 0x74, 0x20, 0x00,
+    0x01, 0x74, 0x4a, 0x00, 0x01, 0x74, 0x70, 0x00, 0x01, 0x74, 0x9a, 0x00,
+    0x01, 0x74, 0xbf, 0x00, 0x01, 0x74, 0xe3, 0x00, 0x01, 0x75, 0x0c, 0x00,
+    0x01, 0x75, 0x31, 0x00, 0x01, 0x75, 0x58, 0x00, 0x01, 0x75, 0x7b, 0x00,
+    0x01, 0x75, 0x9f, 0x00, 0x01, 0x75, 0xc1, 0x00, 0x01, 0x75, 0xe4, 0x00,
+    0x01, 0x76, 0x0e, 0x00, 0x01, 0x76, 0x34, 0x00, 0x01, 0x76, 0x59, 0x00,
+    0x01, 0x76, 0x7f, 0x00, 0x01, 0x76, 0xa6, 0x00, 0x01, 0x76, 0xc8, 0x00,
+    0x01, 0x76, 0xed, 0x00, 0x01, 0x77, 0x13, 0x00, 0x01, 0x77, 0x3d, 0x00,
+    0x01, 0x77, 0x63, 0x00, 0x01, 0x77, 0x83, 0x00, 0x01, 0x77, 0xa7, 0x00,
+    0x01, 0x77, 0xcd, 0x00, 0x01, 0x77, 0xf0, 0x00, 0x01, 0x78, 0x17, 0x00,
+    0x01, 0x78, 0x41, 0x00, 0x01, 0x78, 0x6c, 0x00, 0x01, 0x78, 0x95, 0x00,
+    0x01, 0x78, 0xb9, 0x00, 0x01, 0x78, 0xe5, 0x00, 0x01, 0x79, 0x09, 0x00,
+    0x01, 0x79, 0x2d, 0x00, 0x01, 0x79, 0x58, 0x00, 0x01, 0x79, 0x7b, 0x00,
+    0x01, 0x79, 0xa1, 0x00, 0x01, 0x79, 0xc8, 0x00, 0x01, 0x79, 0xee, 0x00,
+    0x01, 0x7a, 0x15, 0x00, 0x01, 0x7a, 0x3a, 0x00, 0x01, 0x7a, 0x5e, 0x00,
+    0x01, 0x7a, 0x81, 0x00, 0x01, 0x7a, 0xa7, 0x00, 0x01, 0x7a, 0xcb, 0x00,
+    0x01, 0x7a, 0xf3, 0x00, 0x01, 0x7b, 0x17, 0x00, 0x01, 0x7b, 0x38, 0x00,
+    0x01, 0x7b, 0x5d, 0x00, 0x01, 0x7b, 0x81, 0x00, 0x01, 0x7b, 0xa8, 0x00,
+    0x01, 0x7b, 0xd6, 0x00, 0x01, 0x7b, 0xf9, 0x00, 0x01, 0x7c, 0x1b, 0x00,
+    0x01, 0x7c, 0x42, 0x00, 0x01, 0x7c, 0x6d, 0x00, 0x01, 0x7c, 0x96, 0x00,
+    0x01, 0x7c, 0xbd, 0x00, 0x01, 0x7c, 0xe8, 0x00, 0x01, 0x7d, 0x0b, 0x00,
+    0x01, 0x7d, 0x3a, 0x00, 0x01, 0x7d, 0x5e, 0x00, 0x01, 0x7d, 0x84, 0x00,
+    0x01, 0x7d, 0xb1, 0x00, 0x01, 0x7d, 0xd6, 0x00, 0x01, 0x7d, 0xff, 0x00,
+    0x01, 0x7e, 0x25, 0x00, 0x01, 0x7e, 0x48, 0x00, 0x01, 0x7e, 0x6e, 0x00,
+    0x01, 0x7e, 0x95, 0x00, 0x01, 0x7e, 0xbc, 0x00, 0x01, 0x7e, 0xe0, 0x00,
+    0x01, 0x7f, 0x08, 0x00, 0x01, 0x7f, 0x2d, 0x00, 0x01, 0x7f, 0x52, 0x00,
+    0x01, 0x7f, 0x7c, 0x00, 0x01, 0x7f, 0xa3, 0x00, 0x01, 0x7f, 0xc8, 0x00,
+    0x01, 0x7f, 0xf2, 0x00, 0x01, 0x80, 0x17, 0x00, 0x01, 0x80, 0x39, 0x00,
+    0x01, 0x80, 0x5a, 0x00, 0x01, 0x80, 0x81, 0x00, 0x01, 0x80, 0xa6, 0x00,
+    0x01, 0x80, 0xca, 0x00, 0x01, 0x80, 0xed, 0x00, 0x01, 0x81, 0x10, 0x00,
+    0x01, 0x81, 0x39, 0x00, 0x01, 0x81, 0x62, 0x00, 0x01, 0x81, 0x83, 0x00,
+    0x01, 0x81, 0xa6, 0x00, 0x01, 0x81, 0xc6, 0x00, 0x01, 0x81, 0xea, 0x00,
+    0x01, 0x82, 0x0d, 0x00, 0x01, 0x82, 0x36, 0x00, 0x01, 0x82, 0x55, 0x00,
+    0x01, 0x82, 0x85, 0x00, 0x01, 0x82, 0xac, 0x00, 0x01, 0x82, 0xd6, 0x00,
+    0x01, 0x82, 0xf9, 0x00, 0x01, 0x83, 0x20, 0x00, 0x01, 0x83, 0x44, 0x00,
+    0x01, 0x83, 0x68, 0x00, 0x01, 0x83, 0x8d, 0x00, 0x01, 0x83, 0xb1, 0x00,
+    0x01, 0x83, 0xd7, 0x00, 0x01, 0x83, 0xfb, 0x00, 0x01, 0x84, 0x24, 0x00,
+    0x01, 0x84, 0x4f, 0x00, 0x01, 0x84, 0x7a, 0x00, 0x01, 0x84, 0x9f, 0x00,
+    0x01, 0x84, 0xc6, 0x00, 0x01, 0x84, 0xed, 0x00, 0x01, 0x85, 0x13, 0x00,
+    0x01, 0x85, 0x3f, 0x00, 0x01, 0x85, 0x64, 0x00, 0x01, 0x85, 0x8d, 0x00,
+    0x01, 0x85, 0xb1, 0x00, 0x01, 0x85, 0xd9, 0x00, 0x01, 0x85, 0xfe, 0x00,
+    0x01, 0x86, 0x26, 0x00, 0x01, 0x86, 0x4e, 0x00, 0x01, 0x86, 0x71, 0x00,
+    0x01, 0x86, 0x97, 0x00, 0x01, 0x86, 0xbe, 0x00, 0x01, 0x86, 0xdf, 0x00,
+    0x01, 0x87, 0x0b, 0x00, 0x01, 0x87, 0x30, 0x00, 0x01, 0x87, 0x54, 0x00,
+    0x01, 0x87, 0x7d, 0x00, 0x01, 0x87, 0xa9, 0x00, 0x01, 0x87, 0xd0, 0x00,
+    0x01, 0x87, 0xf2, 0x00, 0x01, 0x88, 0x1b, 0x00, 0x01, 0x88, 0x42, 0x00,
+    0x01, 0x88, 0x68, 0x00, 0x01, 0x88, 0x8e, 0x00, 0x01, 0x88, 0xaf, 0x00,
+    0x01, 0x88, 0xd4, 0x00, 0x01, 0x88, 0xfd, 0x00, 0x01, 0x89, 0x20, 0x00,
+    0x01, 0x89, 0x43, 0x00, 0x01, 0x89, 0x67, 0x00, 0x01, 0x89, 0x8e, 0x00,
+    0x01, 0x89, 0xb3, 0x00, 0x01, 0x89, 0xd9, 0x00, 0x01, 0x89, 0xff, 0x00,
+    0x01, 0x8a, 0x28, 0x00, 0x01, 0x8a, 0x4f, 0x00, 0x01, 0x8a, 0x74, 0x00,
+    0x01, 0x8a, 0x99, 0x00, 0x01, 0x8a, 0xbd, 0x00, 0x01, 0x8a, 0xdf, 0x00,
+    0x01, 0x8b, 0x03, 0x00, 0x01, 0x8b, 0x27, 0x00, 0x01, 0x8b, 0x47, 0x00,
+    0x01, 0x8b, 0x6b, 0x00, 0x01, 0x8b, 0x91, 0x00, 0x01, 0x8b, 0xb5, 0x00,
+    0x01, 0x8b, 0xe4, 0x00, 0x01, 0x8c, 0x08, 0x00, 0x01, 0x8c, 0x27, 0x00,
+    0x01, 0x8c, 0x4f, 0x00, 0x01, 0x8c, 0x74, 0x00, 0x01, 0x8c, 0x93, 0x00,
+    0x01, 0x8c, 0xb8, 0x00, 0x01, 0x8c, 0xdc, 0x00, 0x01, 0x8d, 0x05, 0x00,
+    0x01, 0x8d, 0x2c, 0x00, 0x01, 0x8d, 0x52, 0x00, 0x01, 0x8d, 0x73, 0x00,
+    0x01, 0x8d, 0x94, 0x00, 0x01, 0x8d, 0xb9, 0x00, 0x01, 0x8d, 0xe0, 0x00,
+    0x01, 0x8e, 0x04, 0x00, 0x01, 0x8e, 0x29, 0x00, 0x01, 0x8e, 0x4d, 0x00,
+    0x01, 0x8e, 0x70, 0x00, 0x01, 0x8e, 0x91, 0x00, 0x01, 0x8e, 0xba, 0x00,
+    0x01, 0x8e, 0xdb, 0x00, 0x01, 0x8f, 0x03, 0x00, 0x01, 0x8f, 0x27, 0x00,
+    0x01, 0x8f, 0x4b, 0x00, 0x01, 0x8f, 0x6f, 0x00, 0x01, 0x8f, 0x96, 0x00,
+    0x01, 0x8f, 0xb9, 0x00, 0x01, 0x8f, 0xe1, 0x00, 0x01, 0x90, 0x03, 0x00,
+    0x01, 0x90, 0x28, 0x00, 0x01, 0x90, 0x4c, 0x00, 0x01, 0x90, 0x73, 0x00,
+    0x01, 0x90, 0x99, 0x00, 0x01, 0x90, 0xbd, 0x00, 0x01, 0x90, 0xe0, 0x00,
+    0x01, 0x91, 0x04, 0x00, 0x01, 0x91, 0x2f, 0x00, 0x01, 0x91, 0x55, 0x00,
+    0x01, 0x91, 0x79, 0x00, 0x01, 0x91, 0xa6, 0x00, 0x01, 0x91, 0xd3, 0x00,
+    0x01, 0x91, 0xfa, 0x00, 0x01, 0x92, 0x22, 0x00, 0x01, 0x92, 0x4c, 0x00,
+    0x01, 0x92, 0x71, 0x00, 0x01, 0x92, 0x98, 0x00, 0x01, 0x92, 0xbe, 0x00,
+    0x01, 0x92, 0xe6, 0x00, 0x01, 0x93, 0x09, 0x00, 0x01, 0x93, 0x37, 0x00,
+    0x01, 0x93, 0x5a, 0x00, 0x01, 0x93, 0x81, 0x00, 0x01, 0x93, 0xa3, 0x00,
+    0x01, 0x93, 0xca, 0x00, 0x01, 0x93, 0xef, 0x00, 0x01, 0x94, 0x16, 0x00,
+    0x01, 0x94, 0x44, 0x00, 0x01, 0x94, 0x66, 0x00, 0x01, 0x94, 0x8e, 0x00,
+    0x01, 0x94, 0xb7, 0x00, 0x01, 0x94, 0xe1, 0x00, 0x01, 0x95, 0x05, 0x00,
+    0x01, 0x95, 0x2c, 0x00, 0x01, 0x95, 0x50, 0x00, 0x01, 0x95, 0x74, 0x00,
+    0x01, 0x95, 0x9c, 0x00, 0x01, 0x95, 0xc7, 0x00, 0x01, 0x95, 0xe8, 0x00,
+    0x01, 0x96, 0x0e, 0x00, 0x01, 0x96, 0x31, 0x00, 0x01, 0x96, 0x57, 0x00,
+    0x01, 0x96, 0x7b, 0x00, 0x01, 0x96, 0xa2, 0x00, 0x01, 0x96, 0xc4, 0x00,
+    0x01, 0x96, 0xef, 0x00, 0x01, 0x97, 0x10, 0x00, 0x01, 0x97, 0x37, 0x00,
+    0x01, 0x97, 0x59, 0x00, 0x01, 0x97, 0x7d, 0x00, 0x01, 0x97, 0xa3, 0x00,
+    0x01, 0x97, 0xcd, 0x00, 0x01, 0x97, 0xf4, 0x00, 0x01, 0x98, 0x1b, 0x00,
+    0x01, 0x98, 0x44, 0x00, 0x01, 0x98, 0x67, 0x00, 0x01, 0x98, 0x94, 0x00,
+    0x01, 0x98, 0xbc, 0x00, 0x01, 0x98, 0xdd, 0x00, 0x01, 0x99, 0x04, 0x00,
+    0x01, 0x99, 0x25, 0x00, 0x01, 0x99, 0x4e, 0x00, 0x01, 0x99, 0x6f, 0x00,
+    0x01, 0x99, 0x96, 0x00, 0x01, 0x99, 0xb8, 0x00, 0x01, 0x99, 0xdd, 0x00,
+    0x01, 0x9a, 0x00, 0x00, 0x01, 0x9a, 0x26, 0x00, 0x01, 0x9a, 0x48, 0x00,
+    0x01, 0x9a, 0x6c, 0x00, 0x01, 0x9a, 0x91, 0x00, 0x01, 0x9a, 0xb3, 0x00,
+    0x01, 0x9a, 0xd6, 0x00, 0x01, 0x9b, 0x02, 0x00, 0x01, 0x9b, 0x2b, 0x00,
+    0x01, 0x9b, 0x4f, 0x00, 0x01, 0x9b, 0x74, 0x00, 0x01, 0x9b, 0x99, 0x00,
+    0x01, 0x9b, 0xc0, 0x00, 0x01, 0x9b, 0xe7, 0x00, 0x01, 0x9c, 0x0d, 0x00,
+    0x01, 0x9c, 0x31, 0x00, 0x01, 0x9c, 0x56, 0x00, 0x01, 0x9c, 0x7c, 0x00,
+    0x01, 0x9c, 0xa6, 0x00, 0x01, 0x9c, 0xce, 0x00, 0x01, 0x9c, 0xf5, 0x00,
+    0x01, 0x9d, 0x1d, 0x00, 0x01, 0x9d, 0x45, 0x00, 0x01, 0x9d, 0x6f, 0x00,
+    0x01, 0x9d, 0x9b, 0x00, 0x01, 0x9d, 0xc0, 0x00, 0x01, 0x9d, 0xe2, 0x00,
+    0x01, 0x9e, 0x09, 0x00, 0x01, 0x9e, 0x2e, 0x00, 0x01, 0x9e, 0x59, 0x00,
+    0x01, 0x9e, 0x7f, 0x00, 0x01, 0x9e, 0xa5, 0x00, 0x01, 0x9e, 0xc8, 0x00,
+    0x01, 0x9e, 0xf0, 0x00, 0x01, 0x9f, 0x14, 0x00, 0x01, 0x9f, 0x37, 0x00,
+    0x01, 0x9f, 0x5f, 0x00, 0x01, 0x9f, 0x84, 0x00, 0x01, 0x9f, 0xa6, 0x00,
+    0x01, 0x9f, 0xcf, 0x00, 0x01, 0x9f, 0xf4, 0x00, 0x01, 0xa0, 0x1b, 0x00,
+    0x01, 0xa0, 0x3f, 0x00, 0x01, 0xa0, 0x68, 0x00, 0x01, 0xa0, 0x8c, 0x00,
+    0x01, 0xa0, 0xb5, 0x00, 0x01, 0xa0, 0xdf, 0x00, 0x01, 0xa1, 0x06, 0x00,
+    0x01, 0xa1, 0x2d, 0x00, 0x01, 0xa1, 0x54, 0x00, 0x01, 0xa1, 0x7a, 0x00,
+    0x01, 0xa1, 0x9d, 0x00, 0x01, 0xa1, 0xc9, 0x00, 0x01, 0xa1, 0xf1, 0x00,
+    0x01, 0xa2, 0x17, 0x00, 0x01, 0xa2, 0x3a, 0x00, 0x01, 0xa2, 0x63, 0x00,
+    0x01, 0xa2, 0x84, 0x00, 0x01, 0xa2, 0xac, 0x00, 0x01, 0xa2, 0xd0, 0x00,
+    0x01, 0xa2, 0xf5, 0x00, 0x01, 0xa3, 0x19, 0x00, 0x01, 0xa3, 0x3d, 0x00,
+    0x01, 0xa3, 0x62, 0x00, 0x01, 0xa3, 0x87, 0x00, 0x01, 0xa3, 0xb2, 0x00,
+    0x01, 0xa3, 0xd9, 0x00, 0x01, 0xa3, 0xfe, 0x00, 0x01, 0xa4, 0x22, 0x00,
+    0x01, 0xa4, 0x4b, 0x00, 0x01, 0xa4, 0x74, 0x00, 0x01, 0xa4, 0x98, 0x00,
+    0x01, 0xa4, 0xba, 0x00, 0x01, 0xa4, 0xe6, 0x00, 0x01, 0xa5, 0x0b, 0x00,
+    0x01, 0xa5, 0x30, 0x00, 0x01, 0xa5, 0x54, 0x00, 0x01, 0xa5, 0x81, 0x00,
+    0x01, 0xa5, 0xa3, 0x00, 0x01, 0xa5, 0xc6, 0x00, 0x01, 0xa5, 0xf4, 0x00,
+    0x01, 0xa6, 0x1b, 0x00, 0x01, 0xa6, 0x47, 0x00, 0x01, 0xa6, 0x6a, 0x00,
+    0x01, 0xa6, 0x8e, 0x00, 0x01, 0xa6, 0xb6, 0x00, 0x01, 0xa6, 0xdf, 0x00,
+    0x01, 0xa7, 0x04, 0x00, 0x01, 0xa7, 0x29, 0x00, 0x01, 0xa7, 0x4c, 0x00,
+    0x01, 0xa7, 0x71, 0x00, 0x01, 0xa7, 0x97, 0x00, 0x01, 0xa7, 0xbf, 0x00,
+    0x01, 0xa7, 0xe4, 0x00, 0x01, 0xa8, 0x0a, 0x00, 0x01, 0xa8, 0x30, 0x00,
+    0x01, 0xa8, 0x56, 0x00, 0x01, 0xa8, 0x78, 0x00, 0x01, 0xa8, 0x9b, 0x00,
+    0x01, 0xa8, 0xc0, 0x00, 0x01, 0xa8, 0xe5, 0x00, 0x01, 0xa9, 0x09, 0x00,
+    0x01, 0xa9, 0x34, 0x00, 0x01, 0xa9, 0x59, 0x00, 0x01, 0xa9, 0x7b, 0x00,
+    0x01, 0xa9, 0xa6, 0x00, 0x01, 0xa9, 0xce, 0x00, 0x01, 0xa9, 0xf4, 0x00,
+    0x01, 0xaa, 0x1c, 0x00, 0x01, 0xaa, 0x42, 0x00, 0x01, 0xaa, 0x68, 0x00,
+    0x01, 0xaa, 0x8e, 0x00, 0x01, 0xaa, 0xb4, 0x00, 0x01, 0xaa, 0xd8, 0x00,
+    0x01, 0xaa, 0xfc, 0x00, 0x01, 0xab, 0x1f, 0x00, 0x01, 0xab, 0x41, 0x00,
+    0x01, 0xab, 0x64, 0x00, 0x01, 0xab, 0x8d, 0x00, 0x01, 0xab, 0xb0, 0x00,
+    0x01, 0xab, 0xdc, 0x00, 0x01, 0xac, 0x04, 0x00, 0x01, 0xac, 0x2d, 0x00,
+    0x01, 0xac, 0x5a, 0x00, 0x01, 0xac, 0x7f, 0x00, 0x01, 0xac, 0xa7, 0x00,
+    0x01, 0xac, 0xcc, 0x00, 0x01, 0xac, 0xf1, 0x00, 0x01, 0xad, 0x15, 0x00,
+    0x01, 0xad, 0x36, 0x00, 0x01, 0xad, 0x5f, 0x00, 0x01, 0xad, 0x80, 0x00,
+    0x01, 0xad, 0xa3, 0x00, 0x01, 0xad, 0xc8, 0x00, 0x01, 0xad, 0xf5, 0x00,
+    0x01, 0xae, 0x1e, 0x00, 0x01, 0xae, 0x46, 0x00, 0x01, 0xae, 0x6d, 0x00,
+    0x01, 0xae, 0x9a, 0x00, 0x01, 0xae, 0xc1, 0x00, 0x01, 0xae, 0xe3, 0x00,
+    0x01, 0xaf, 0x08, 0x00, 0x01, 0xaf, 0x2c, 0x00, 0x01, 0xaf, 0x52, 0x00,
+    0x01, 0xaf, 0x76, 0x00, 0x01, 0xaf, 0x9b, 0x00, 0x01, 0xaf, 0xbc, 0x00,
+    0x01, 0xaf, 0xe3, 0x00, 0x01, 0xb0, 0x09, 0x00, 0x01, 0xb0, 0x2b, 0x00,
+    0x01, 0xb0, 0x4f, 0x00, 0x01, 0xb0, 0x77, 0x00, 0x01, 0xb0, 0xa0, 0x00,
+    0x01, 0xb0, 0xca, 0x00, 0x01, 0xb0, 0xef, 0x00, 0x01, 0xb1, 0x17, 0x00,
+    0x01, 0xb1, 0x3f, 0x00, 0x01, 0xb1, 0x64, 0x00, 0x01, 0xb1, 0x86, 0x00,
+    0x01, 0xb1, 0xac, 0x00, 0x01, 0xb1, 0xd2, 0x00, 0x01, 0xb1, 0xf7, 0x00,
+    0x01, 0xb2, 0x1c, 0x00, 0x01, 0xb2, 0x40, 0x00, 0x01, 0xb2, 0x66, 0x00,
+    0x01, 0xb2, 0x89, 0x00, 0x01, 0xb2, 0xb4, 0x00, 0x01, 0xb2, 0xde, 0x00,
+    0x01, 0xb3, 0x00, 0x00, 0x01, 0xb3, 0x2d, 0x00, 0x01, 0xb3, 0x54, 0x00,
+    0x01, 0xb3, 0x7d, 0x00, 0x01, 0xb3, 0xa5, 0x00, 0x01, 0xb3, 0xc8, 0x00,
+    0x01, 0xb3, 0xee, 0x00, 0x01, 0xb4, 0x1a, 0x00, 0x01, 0xb4, 0x45, 0x00,
+    0x01, 0xb4, 0x6d, 0x00, 0x01, 0xb4, 0x93, 0x00, 0x01, 0xb4, 0xb5, 0x00,
+    0x01, 0xb4, 0xd9, 0x00, 0x01, 0xb5, 0x04, 0x00, 0x01, 0xb5, 0x2a, 0x00,
+    0x01, 0xb5, 0x4d, 0x00, 0x01, 0xb5, 0x74, 0x00, 0x01, 0xb5, 0x98, 0x00,
+    0x01, 0xb5, 0xc2, 0x00, 0x01, 0xb5, 0xe7, 0x00, 0x01, 0xb6, 0x0c, 0x00,
+    0x01, 0xb6, 0x32, 0x00, 0x01, 0xb6, 0x59, 0x00, 0x01, 0xb6, 0x82, 0x00,
+    0x01, 0xb6, 0xaf, 0x00, 0x01, 0xb6, 0xcf, 0x00, 0x01, 0xb6, 0xfa, 0x00,
+    0x01, 0xb7, 0x1e, 0x00, 0x01, 0xb7, 0x46, 0x00, 0x01, 0xb7, 0x6a, 0x00,
+    0x01, 0xb7, 0x8c, 0x00, 0x01, 0xb7, 0xb7, 0x00, 0x01, 0xb7, 0xde, 0x00,
+    0x01, 0xb8, 0x00, 0x00, 0x01, 0xb8, 0x23, 0x00, 0x01, 0xb8, 0x4c, 0x00,
+    0x01, 0xb8, 0x70, 0x00, 0x01, 0xb8, 0x95, 0x00, 0x01, 0xb8, 0xbb, 0x00,
+    0x01, 0xb8, 0xe0, 0x00, 0x01, 0xb9, 0x06, 0x00, 0x01, 0xb9, 0x2a, 0x00,
+    0x01, 0xb9, 0x4f, 0x00, 0x01, 0xb9, 0x76, 0x00, 0x01, 0xb9, 0x9e, 0x00,
+    0x01, 0xb9, 0xc2, 0x00, 0x01, 0xb9, 0xe8, 0x00, 0x01, 0xba, 0x0e, 0x00,
+    0x01, 0xba, 0x31, 0x00, 0x01, 0xba, 0x55, 0x00, 0x01, 0xba, 0x7d, 0x00,
+    0x01, 0xba, 0xa0, 0x00, 0x01, 0xba, 0xcb, 0x00, 0x01, 0xba, 0xf0, 0x00,
+    0x01, 0xbb, 0x16, 0x00, 0x01, 0xbb, 0x42, 0x00, 0x01, 0xbb, 0x68, 0x00,
+    0x01, 0xbb, 0x8f, 0x00, 0x01, 0xbb, 0xbc, 0x00, 0x01, 0xbb, 0xe2, 0x00,
+    0x01, 0xbc, 0x03, 0x00, 0x01, 0xbc, 0x2b, 0x00, 0x01, 0xbc, 0x56, 0x00,
+    0x01, 0xbc, 0x7e, 0x00, 0x01, 0xbc, 0xa3, 0x00, 0x01, 0xbc, 0xc3, 0x00,
+    0x01, 0xbc, 0xe5, 0x00, 0x01, 0xbd, 0x09, 0x00, 0x01, 0xbd, 0x37, 0x00,
+    0x01, 0xbd, 0x61, 0x00, 0x01, 0xbd, 0x86, 0x00, 0x01, 0xbd, 0xa8, 0x00,
+    0x01, 0xbd, 0xd4, 0x00, 0x01, 0xbd, 0xfa, 0x00, 0x01, 0xbe, 0x24, 0x00,
+    0x01, 0xbe, 0x47, 0x00, 0x01, 0xbe, 0x68, 0x00, 0x01, 0xbe, 0x8e, 0x00,
+    0x01, 0xbe, 0xb4, 0x00, 0x01, 0xbe, 0xd5, 0x00, 0x01, 0xbe, 0xfa, 0x00,
+    0x01, 0xbf, 0x1f, 0x00, 0x01, 0xbf, 0x45, 0x00, 0x01, 0xbf, 0x6b, 0x00,
+    0x01, 0xbf, 0x9c, 0x00, 0x01, 0xbf, 0xc5, 0x00, 0x01, 0xbf, 0xe8, 0x00,
+    0x01, 0xc0, 0x0a, 0x00, 0x01, 0xc0, 0x2c, 0x00, 0x01, 0xc0, 0x4f, 0x00,
+    0x01, 0xc0, 0x78, 0x00, 0x01, 0xc0, 0x99, 0x00, 0x01, 0xc0, 0xbd, 0x00,
+    0x01, 0xc0, 0xe6, 0x00, 0x01, 0xc1, 0x0b, 0x00, 0x01, 0xc1, 0x2e, 0x00,
+    0x01, 0xc1, 0x5e, 0x00, 0x01, 0xc1, 0x83, 0x00, 0x01, 0xc1, 0xad, 0x00,
+    0x01, 0xc1, 0xd1, 0x00, 0x01, 0xc1, 0xff, 0x00, 0x01, 0xc2, 0x20, 0x00,
+    0x01, 0xc2, 0x46, 0x00, 0x01, 0xc2, 0x6e, 0x00, 0x01, 0xc2, 0x94, 0x00,
+    0x01, 0xc2, 0xbc, 0x00, 0x01, 0xc2, 0xe2, 0x00, 0x01, 0xc3, 0x0a, 0x00,
+    0x01, 0xc3, 0x2e, 0x00, 0x01, 0xc3, 0x53, 0x00, 0x01, 0xc3, 0x77, 0x00,
+    0x01, 0xc3, 0xa0, 0x00, 0x01, 0xc3, 0xc5, 0x00, 0x01, 0xc3, 0xe7, 0x00,
+    0x01, 0xc4, 0x0d, 0x00, 0x01, 0xc4, 0x35, 0x00, 0x01, 0xc4, 0x5e, 0x00,
+    0x01, 0xc4, 0x86, 0x00, 0x01, 0xc4, 0xa7, 0x00, 0x01, 0xc4, 0xce, 0x00,
+    0x01, 0xc4, 0xf5, 0x00, 0x01, 0xc5, 0x19, 0x00, 0x01, 0xc5, 0x3d, 0x00,
+    0x01, 0xc5, 0x62, 0x00, 0x01, 0xc5, 0x84, 0x00, 0x01, 0xc5, 0xae, 0x00,
+    0x01, 0xc5, 0xd1, 0x00, 0x01, 0xc5, 0xfc, 0x00, 0x01, 0xc6, 0x23, 0x00,
+    0x01, 0xc6, 0x43, 0x00, 0x01, 0xc6, 0x6c, 0x00, 0x01, 0xc6, 0x91, 0x00,
+    0x01, 0xc6, 0xba, 0x00, 0x01, 0xc6, 0xde, 0x00, 0x01, 0xc7, 0x01, 0x00,
+    0x01, 0xc7, 0x26, 0x00, 0x01, 0xc7, 0x49, 0x00, 0x01, 0xc7, 0x6e, 0x00,
+    0x01, 0xc7, 0x95, 0x00, 0x01, 0xc7, 0xbb, 0x00, 0x01, 0xc7, 0xe1, 0x00,
+    0x01, 0xc8, 0x04, 0x00, 0x01, 0xc8, 0x2b, 0x00, 0x01, 0xc8, 0x54, 0x00,
+    0x01, 0xc8, 0x7a, 0x00, 0x01, 0xc8, 0xa0, 0x00, 0x01, 0xc8, 0xc5, 0x00,
+    0x01, 0xc8, 0xe8, 0x00, 0x01, 0xc9, 0x11, 0x00, 0x01, 0xc9, 0x3b, 0x00,
+    0x01, 0xc9, 0x60, 0x00, 0x01, 0xc9, 0x87, 0x00, 0x01, 0xc9, 0xaf, 0x00,
+    0x01, 0xc9, 0xd2, 0x00, 0x01, 0xc9, 0xf4, 0x00, 0x01, 0xca, 0x16, 0x00,
+    0x01, 0xca, 0x41, 0x00, 0x01, 0xca, 0x68, 0x00, 0x01, 0xca, 0x8c, 0x00,
+    0x01, 0xca, 0xb2, 0x00, 0x01, 0xca, 0xd8, 0x00, 0x01, 0xca, 0xfd, 0x00,
+    0x01, 0xcb, 0x22, 0x00, 0x01, 0xcb, 0x46, 0x00, 0x01, 0xcb, 0x6e, 0x00,
+    0x01, 0xcb, 0x8f, 0x00, 0x01, 0xcb, 0xb3, 0x00, 0x01, 0xcb, 0xd8, 0x00,
+    0x01, 0xcb, 0xfe, 0x00, 0x01, 0xcc, 0x28, 0x00, 0x01, 0xcc, 0x4e, 0x00,
+    0x01, 0xcc, 0x71, 0x00, 0x01, 0xcc, 0x94, 0x00, 0x01, 0xcc, 0xb5, 0x00,
+    0x01, 0xcc, 0xdb, 0x00, 0x01, 0xcd, 0x01, 0x66, 0x69, 0x70, 0x73, 0x00,
+    0x63, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x73, 0x74, 0x00, 0x73, 0x74,
+    0x61, 0x74, 0x65, 0x00, 0x7a, 0x6f, 0x6e, 0x65, 0x00, 0x67, 0x6d, 0x74,
+    0x00, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x70, 0x6f, 0x70,
+    0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x74, 0x7a, 0x00, 0x74,
+    0x7a, 0x39, 0x30, 0x00, 0x74, 0x7a, 0x39, 0x00, 0x74, 0x7a, 0x31, 0x00,
+    0x34, 0x37, 0x31, 0x38, 0x37, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61,
+    0x6d, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x31, 0x33, 0x37, 0x00, 0x5a,
+    0x69, 0x65, 0x62, 0x61, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44,
+    0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x31, 0x31, 0x32, 0x37, 0x00, 0x57, 0x61, 0x6c, 0x6b, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c,
+    0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x35, 0x30, 0x33, 0x39, 0x00, 0x46, 0x61, 0x69, 0x72, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31,
+    0x33, 0x39, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6c, 0x61, 0x6e, 0x64, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x34,
+    0x31, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x50,
+    0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75,
+    0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x39, 0x30, 0x36, 0x31, 0x00, 0x44, 0x61, 0x76, 0x69, 0x65, 0x73,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00,
+    0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x33, 0x30, 0x31, 0x33, 0x00, 0x42, 0x61, 0x72, 0x72,
+    0x6f, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x36, 0x30, 0x39, 0x35, 0x00, 0x4c, 0x75, 0x63, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x32, 0x30, 0x35, 0x33, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x20, 0x44, 0x61, 0x76, 0x69, 0x73, 0x20, 0x50,
+    0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75,
+    0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x35, 0x30, 0x34, 0x37, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x4d, 0x69,
+    0x67, 0x75, 0x65, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x30, 0x36, 0x33,
+    0x00, 0x48, 0x75, 0x72, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x34, 0x33,
+    0x00, 0x44, 0x61, 0x75, 0x70, 0x68, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73,
+    0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x36, 0x30, 0x30, 0x35, 0x00, 0x42, 0x72, 0x6f, 0x6e, 0x78,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x33, 0x30, 0x33, 0x37, 0x00, 0x4b, 0x69, 0x74, 0x74, 0x69,
+    0x74, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x30, 0x31, 0x30, 0x39, 0x37,
+    0x00, 0x4d, 0x6f, 0x62, 0x69, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x32, 0x31,
+    0x00, 0x4f, 0x67, 0x6c, 0x65, 0x74, 0x68, 0x6f, 0x72, 0x70, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x37, 0x31, 0x35, 0x39, 0x00, 0x57, 0x61, 0x64, 0x65, 0x6e, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x38, 0x30, 0x39, 0x39, 0x00, 0x4d, 0x61, 0x72, 0x73, 0x68,
+    0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x31, 0x33, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x30,
+    0x37, 0x35, 0x00, 0x4c, 0x65, 0x76, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x38, 0x31,
+    0x00, 0x52, 0x61, 0x6c, 0x65, 0x69, 0x67, 0x68, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x37, 0x30, 0x39, 0x39, 0x00, 0x4a, 0x61, 0x63, 0x6b,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38,
+    0x30, 0x37, 0x37, 0x00, 0x4d, 0x65, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
+    0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x31, 0x30,
+    0x36, 0x37, 0x00, 0x47, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x32,
+    0x33, 0x00, 0x4d, 0x61, 0x76, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x35,
+    0x33, 0x00, 0x47, 0x6f, 0x67, 0x65, 0x62, 0x69, 0x63, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68,
+    0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37,
+    0x31, 0x34, 0x35, 0x00, 0x50, 0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37,
+    0x31, 0x36, 0x35, 0x00, 0x53, 0x75, 0x6d, 0x6e, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x35, 0x30, 0x35, 0x31, 0x00, 0x53, 0x69, 0x65, 0x72, 0x72, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x32, 0x30, 0x30, 0x37, 0x37, 0x00, 0x48, 0x61, 0x72, 0x70,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x30, 0x30, 0x30, 0x39, 0x00, 0x45, 0x73, 0x73, 0x65, 0x78,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54, 0x00, 0x56,
+    0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x38, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x30, 0x30, 0x35, 0x37, 0x00, 0x48, 0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b,
+    0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x36, 0x30, 0x31, 0x33, 0x00, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61,
+    0x20, 0x43, 0x6f, 0x73, 0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x31, 0x30,
+    0x30, 0x35, 0x00, 0x41, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x31, 0x30, 0x30, 0x35, 0x00, 0x41, 0x72, 0x74, 0x68, 0x75, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x36, 0x31, 0x34, 0x35, 0x00, 0x53, 0x61, 0x67, 0x69, 0x6e,
+    0x61, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49,
+    0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x36, 0x31, 0x00, 0x4f, 0x72, 0x61,
+    0x6e, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x33, 0x32, 0x37, 0x33, 0x00, 0x54, 0x65, 0x72, 0x72, 0x65,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x30, 0x30, 0x32, 0x39, 0x00, 0x43, 0x6f, 0x61, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f,
+    0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x37, 0x30, 0x35, 0x37, 0x00, 0x48, 0x75, 0x62, 0x62, 0x61,
+    0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30, 0x30, 0x37, 0x00, 0x41, 0x70,
+    0x70, 0x61, 0x6e, 0x6f, 0x6f, 0x73, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x34, 0x35, 0x00, 0x54, 0x65,
+    0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x34, 0x30, 0x33, 0x33, 0x00, 0x53, 0x61, 0x6c, 0x65, 0x6d,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x32, 0x35, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x35, 0x30, 0x33, 0x37, 0x00,
+    0x51, 0x75, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33, 0x30, 0x38, 0x33,
+    0x00, 0x44, 0x61, 0x64, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x30, 0x34, 0x31, 0x00, 0x42,
+    0x72, 0x61, 0x7a, 0x6f, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x35, 0x35, 0x00, 0x4b, 0x61, 0x72,
+    0x6e, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x30, 0x30, 0x39, 0x35, 0x00, 0x53, 0x74, 0x69, 0x6c, 0x6c,
+    0x77, 0x61, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x31, 0x31, 0x39, 0x39, 0x00, 0x50,
+    0x75, 0x6c, 0x61, 0x73, 0x6b, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b,
+    0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x34, 0x33,
+    0x00, 0x4d, 0x61, 0x72, 0x69, 0x70, 0x6f, 0x73, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69,
+    0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x35, 0x35, 0x30, 0x34, 0x37, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x20,
+    0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69,
+    0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x31, 0x32, 0x35,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x46, 0x65, 0x6c, 0x69, 0x63, 0x69,
+    0x61, 0x6e, 0x61, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c,
+    0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x34, 0x30, 0x30, 0x35, 0x00, 0x42,
+    0x61, 0x6c, 0x74, 0x69, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c,
+    0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30,
+    0x32, 0x39, 0x00, 0x43, 0x6f, 0x63, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65,
+    0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x33,
+    0x38, 0x33, 0x00, 0x52, 0x65, 0x61, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x38, 0x33,
+    0x00, 0x48, 0x61, 0x6c, 0x69, 0x66, 0x61, 0x78, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x35, 0x30, 0x30, 0x31, 0x00, 0x41, 0x62, 0x62,
+    0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43,
+    0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x31, 0x31, 0x38, 0x31, 0x00, 0x53, 0x75, 0x72, 0x72, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x31, 0x31, 0x31, 0x31, 0x00, 0x4c, 0x75, 0x6e, 0x65, 0x6e,
+    0x62, 0x75, 0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x31, 0x37, 0x00, 0x50,
+    0x69, 0x70, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65,
+    0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36,
+    0x31, 0x30, 0x33, 0x00, 0x54, 0x65, 0x68, 0x61, 0x6d, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c,
+    0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x34, 0x38, 0x30, 0x37, 0x31, 0x00, 0x43, 0x68, 0x61, 0x6d, 0x62,
+    0x65, 0x72, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x35, 0x30, 0x32, 0x35, 0x00, 0x4c, 0x65, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x31, 0x33, 0x33, 0x31, 0x39, 0x00, 0x57, 0x69, 0x6c, 0x6b, 0x69,
+    0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x30, 0x31, 0x00, 0x4d, 0x69,
+    0x6c, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x31, 0x35, 0x39, 0x00, 0x56, 0x61,
+    0x6e, 0x20, 0x42, 0x75, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x31, 0x37,
+    0x31, 0x00, 0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x30, 0x31,
+    0x39, 0x00, 0x43, 0x61, 0x72, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31,
+    0x32, 0x39, 0x00, 0x4e, 0x75, 0x63, 0x6b, 0x6f, 0x6c, 0x6c, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65,
+    0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00,
+    0x34, 0x31, 0x30, 0x33, 0x35, 0x00, 0x4b, 0x6c, 0x61, 0x6d, 0x61, 0x74,
+    0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00,
+    0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x32, 0x34, 0x30, 0x33, 0x39, 0x00, 0x53, 0x6f, 0x6d, 0x65, 0x72, 0x73,
+    0x65, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44,
+    0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x33, 0x30, 0x33, 0x39, 0x00, 0x43, 0x61, 0x6d,
+    0x64, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x38, 0x31, 0x00, 0x52, 0x65, 0x64,
+    0x20, 0x52, 0x69, 0x76, 0x65, 0x72, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73,
+    0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x35, 0x30, 0x32,
+    0x31, 0x00, 0x48, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x32, 0x30, 0x30, 0x36, 0x37, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31,
+    0x30, 0x38, 0x39, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30,
+    0x31, 0x30, 0x35, 0x00, 0x4e, 0x6f, 0x77, 0x61, 0x74, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c,
+    0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x31, 0x30, 0x36, 0x35, 0x00, 0x46, 0x75, 0x72, 0x6e, 0x61, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65,
+    0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x32, 0x31, 0x33, 0x00, 0x4d, 0x75, 0x72, 0x72, 0x61, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x35, 0x31, 0x30, 0x33, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6c, 0x61,
+    0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49,
+    0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x34, 0x39, 0x00, 0x4d,
+    0x63, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44,
+    0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35,
+    0x35, 0x30, 0x36, 0x33, 0x00, 0x4c, 0x61, 0x20, 0x43, 0x72, 0x6f, 0x73,
+    0x73, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49,
+    0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x39, 0x39, 0x00, 0x50,
+    0x72, 0x69, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69,
+    0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39, 0x30, 0x33, 0x31,
+    0x00, 0x50, 0x69, 0x75, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x32, 0x30, 0x30, 0x35, 0x37, 0x00, 0x46, 0x6f, 0x72,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x38, 0x30, 0x35, 0x37, 0x00, 0x49, 0x74, 0x61, 0x77, 0x61, 0x6d,
+    0x62, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53,
+    0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x35, 0x31, 0x00, 0x4a, 0x65, 0x66,
+    0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x30, 0x31, 0x30, 0x33, 0x35, 0x00, 0x43, 0x6f,
+    0x6e, 0x65, 0x63, 0x75, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31, 0x31, 0x31, 0x00, 0x4c,
+    0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x31, 0x38, 0x37,
+    0x00, 0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x30, 0x34,
+    0x39, 0x00, 0x48, 0x69, 0x6e, 0x64, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70,
+    0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x33,
+    0x37, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x30, 0x31, 0x33, 0x00, 0x42, 0x6f,
+    0x78, 0x20, 0x42, 0x75, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x30,
+    0x33, 0x00, 0x41, 0x6c, 0x61, 0x6d, 0x6f, 0x73, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f,
+    0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x34,
+    0x30, 0x35, 0x35, 0x00, 0x4d, 0x65, 0x72, 0x63, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73,
+    0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x30, 0x31, 0x33, 0x00, 0x42, 0x75,
+    0x72, 0x6e, 0x65, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73,
+    0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x34,
+    0x33, 0x00, 0x53, 0x69, 0x62, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65,
+    0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38,
+    0x31, 0x32, 0x37, 0x00, 0x50, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x32,
+    0x30, 0x36, 0x38, 0x00, 0x44, 0x65, 0x6e, 0x61, 0x6c, 0x69, 0x20, 0x42,
+    0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c,
+    0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x34, 0x35,
+    0x30, 0x37, 0x35, 0x00, 0x4f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x62, 0x75,
+    0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30,
+    0x30, 0x33, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30,
+    0x30, 0x33, 0x00, 0x42, 0x69, 0x67, 0x20, 0x48, 0x6f, 0x72, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30,
+    0x38, 0x30, 0x32, 0x39, 0x00, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c,
+    0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31,
+    0x38, 0x31, 0x30, 0x39, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x31, 0x30, 0x34, 0x33, 0x00, 0x43, 0x61, 0x72, 0x74, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x31, 0x31, 0x32, 0x33, 0x00, 0x54, 0x61, 0x6c, 0x6c, 0x61, 0x70,
+    0x6f, 0x6f, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x39, 0x30, 0x31, 0x33, 0x00, 0x54, 0x6f,
+    0x6c, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x54, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69,
+    0x63, 0x75, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31,
+    0x32, 0x37, 0x00, 0x50, 0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x35, 0x39, 0x00, 0x47,
+    0x72, 0x65, 0x65, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76,
+    0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30,
+    0x31, 0x36, 0x35, 0x00, 0x52, 0x75, 0x73, 0x68, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x32, 0x37,
+    0x00, 0x46, 0x65, 0x72, 0x67, 0x75, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x36, 0x30, 0x32, 0x31,
+    0x00, 0x43, 0x61, 0x6d, 0x70, 0x62, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74,
+    0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x33, 0x32, 0x34, 0x39, 0x00, 0x53, 0x63, 0x68, 0x6c,
+    0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x31, 0x31, 0x37, 0x39, 0x00, 0x53, 0x74, 0x61, 0x66,
+    0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x31, 0x30, 0x37, 0x00, 0x50,
+    0x69, 0x63, 0x6b, 0x65, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x32, 0x37, 0x00,
+    0x44, 0x75, 0x74, 0x63, 0x68, 0x65, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59,
+    0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x30,
+    0x31, 0x37, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x31,
+    0x30, 0x39, 0x00, 0x54, 0x6f, 0x6d, 0x70, 0x6b, 0x69, 0x6e, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x39, 0x31, 0x34, 0x33, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x75, 0x73,
+    0x6b, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48,
+    0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x33, 0x31, 0x31, 0x37, 0x00, 0x46, 0x6f, 0x72, 0x73, 0x79, 0x74, 0x68,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x30, 0x32, 0x30, 0x37, 0x30, 0x00, 0x44, 0x69, 0x6c, 0x6c, 0x69, 0x6e,
+    0x67, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x20,
+    0x41, 0x72, 0x65, 0x61, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x35, 0x31, 0x30, 0x31,
+    0x31, 0x00, 0x41, 0x70, 0x70, 0x6f, 0x6d, 0x61, 0x74, 0x74, 0x6f, 0x78,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x31, 0x36, 0x34, 0x30, 0x00, 0x47, 0x61, 0x6c, 0x61, 0x78,
+    0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x37, 0x30, 0x39, 0x37, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37,
+    0x30, 0x39, 0x33, 0x00, 0x4b, 0x65, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x37, 0x30, 0x39, 0x33, 0x00, 0x48, 0x6f, 0x6b, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x33, 0x30, 0x33, 0x31, 0x00, 0x4a,
+    0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x33, 0x33, 0x30, 0x30, 0x31, 0x00, 0x42, 0x65, 0x6c, 0x6b, 0x6e, 0x61,
+    0x70, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x48, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68, 0x69, 0x72,
+    0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x36, 0x35,
+    0x00, 0x56, 0x61, 0x6c, 0x20, 0x56, 0x65, 0x72, 0x64, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x35,
+    0x35, 0x00, 0x4b, 0x6f, 0x6f, 0x74, 0x65, 0x6e, 0x61, 0x69, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61,
+    0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x35, 0x30, 0x30,
+    0x33, 0x00, 0x41, 0x73, 0x68, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30,
+    0x36, 0x33, 0x00, 0x48, 0x61, 0x6e, 0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x36, 0x35,
+    0x00, 0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x39, 0x31, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73,
+    0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x31, 0x30, 0x36, 0x35, 0x00, 0x57, 0x61, 0x73, 0x63, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f,
+    0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32,
+    0x38, 0x31, 0x30, 0x31, 0x00, 0x4e, 0x65, 0x77, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x31, 0x36, 0x39, 0x00, 0x47, 0x61, 0x72, 0x7a, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31,
+    0x35, 0x33, 0x00, 0x50, 0x75, 0x6c, 0x61, 0x73, 0x6b, 0x69, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x33, 0x31, 0x35, 0x33, 0x00, 0x48, 0x6f, 0x75, 0x73, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x33, 0x30, 0x36, 0x33, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x30, 0x30, 0x36, 0x35, 0x00, 0x4d, 0x75, 0x73, 0x73, 0x65,
+    0x6c, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x36, 0x30, 0x33, 0x35, 0x00,
+    0x4c, 0x61, 0x73, 0x73, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x34, 0x30,
+    0x34, 0x33, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00,
+    0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x36, 0x30, 0x30, 0x39, 0x00, 0x42, 0x6f, 0x6e, 0x20,
+    0x48, 0x6f, 0x6d, 0x6d, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35,
+    0x30, 0x35, 0x39, 0x00, 0x4b, 0x65, 0x6e, 0x6f, 0x73, 0x68, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69,
+    0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x31, 0x30, 0x30, 0x33, 0x00, 0x42, 0x61, 0x6c, 0x64,
+    0x77, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x33, 0x30, 0x31, 0x33, 0x00, 0x4b, 0x6e, 0x6f,
+    0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x45, 0x00,
+    0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x31, 0x31, 0x34, 0x37, 0x00, 0x52, 0x69, 0x63, 0x68, 0x61, 0x72, 0x64,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x30, 0x38, 0x30, 0x34, 0x37, 0x00, 0x47, 0x69,
+    0x6c, 0x70, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x38, 0x31, 0x31, 0x39, 0x00, 0x51,
+    0x75, 0x69, 0x74, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70,
+    0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x33, 0x33,
+    0x00, 0x43, 0x72, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36,
+    0x31, 0x31, 0x37, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x63, 0x61, 0x6c, 0x6d,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x35, 0x30, 0x32, 0x33, 0x00, 0x50, 0x6c, 0x79, 0x6d, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68, 0x75, 0x73, 0x65,
+    0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x34, 0x30,
+    0x31, 0x35, 0x00, 0x4d, 0x6f, 0x68, 0x61, 0x76, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69, 0x7a,
+    0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x34, 0x30,
+    0x35, 0x39, 0x00, 0x4d, 0x69, 0x6e, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x37, 0x30, 0x33, 0x33, 0x00, 0x43, 0x72, 0x61, 0x77,
+    0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x36, 0x39, 0x00, 0x46,
+    0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x30, 0x31, 0x32, 0x39, 0x00, 0x52, 0x6f, 0x67, 0x65,
+    0x72, 0x20, 0x4d, 0x69, 0x6c, 0x6c, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f,
+    0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x32,
+    0x35, 0x00, 0x52, 0x65, 0x64, 0x20, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x37, 0x30, 0x33, 0x35, 0x00, 0x43, 0x75, 0x6d, 0x62, 0x65, 0x72,
+    0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x35, 0x31, 0x00, 0x47,
+    0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x35, 0x33, 0x00,
+    0x43, 0x68, 0x61, 0x74, 0x74, 0x61, 0x68, 0x6f, 0x6f, 0x63, 0x68, 0x65,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x37, 0x31, 0x34, 0x39, 0x00, 0x53, 0x74, 0x65, 0x76, 0x65,
+    0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x37, 0x39, 0x00, 0x4a, 0x61,
+    0x73, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31, 0x35, 0x39, 0x00, 0x53,
+    0x65, 0x77, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x37, 0x31, 0x35, 0x39, 0x00,
+    0x52, 0x6f, 0x77, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x34, 0x30, 0x32, 0x31, 0x00, 0x4d, 0x65, 0x72, 0x63, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x38, 0x31, 0x00, 0x48, 0x69, 0x63,
+    0x6b, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x31, 0x31, 0x35, 0x00, 0x53,
+    0x68, 0x61, 0x77, 0x61, 0x6e, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30,
+    0x39, 0x37, 0x00, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37,
+    0x00, 0x31, 0x33, 0x30, 0x37, 0x35, 0x00, 0x43, 0x6f, 0x6f, 0x6b, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x37, 0x30, 0x32, 0x31, 0x00, 0x42, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x62,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x35,
+    0x39, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30,
+    0x30, 0x37, 0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6d, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x34,
+    0x30, 0x32, 0x31, 0x00, 0x50, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69, 0x7a,
+    0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x39, 0x31,
+    0x36, 0x35, 0x00, 0x50, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32,
+    0x31, 0x30, 0x35, 0x00, 0x50, 0x6f, 0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69,
+    0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31, 0x35,
+    0x31, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6c, 0x70, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x31, 0x33, 0x33, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x61, 0x6e,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x39, 0x30, 0x39, 0x31, 0x00, 0x48, 0x75, 0x6d, 0x62,
+    0x6f, 0x6c, 0x64, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x30, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6e, 0x64, 0x65, 0x72,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x37, 0x31, 0x37, 0x39, 0x00, 0x55, 0x6e, 0x69, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x33,
+    0x35, 0x00, 0x43, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41,
+    0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x30, 0x30, 0x35, 0x39, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b,
+    0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x32, 0x31, 0x30, 0x30, 0x00, 0x48, 0x61, 0x69, 0x6e,
+    0x65, 0x73, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x41,
+    0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d,
+    0x39, 0x00, 0x31, 0x38, 0x31, 0x38, 0x31, 0x00, 0x57, 0x68, 0x69, 0x74,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00,
+    0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x33, 0x32, 0x30, 0x37, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x32, 0x30, 0x32, 0x31, 0x00, 0x43, 0x61, 0x6d, 0x62, 0x72,
+    0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41,
+    0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x33, 0x35,
+    0x00, 0x43, 0x61, 0x72, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x34,
+    0x39, 0x00, 0x50, 0x69, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x31, 0x35,
+    0x00, 0x41, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x37, 0x31, 0x00, 0x4f,
+    0x72, 0x6c, 0x65, 0x61, 0x6e, 0x73, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73,
+    0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x39,
+    0x39, 0x00, 0x4d, 0x75, 0x72, 0x72, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x30,
+    0x31, 0x35, 0x00, 0x42, 0x6f, 0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30,
+    0x36, 0x31, 0x00, 0x44, 0x75, 0x62, 0x75, 0x71, 0x75, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x32, 0x35,
+    0x00, 0x4d, 0x61, 0x72, 0x69, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x30,
+    0x39, 0x00, 0x41, 0x6d, 0x68, 0x65, 0x72, 0x73, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38,
+    0x30, 0x34, 0x35, 0x00, 0x4c, 0x61, 0x4d, 0x6f, 0x75, 0x72, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x36, 0x39, 0x00, 0x4e, 0x65,
+    0x7a, 0x20, 0x50, 0x65, 0x72, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x30, 0x32, 0x35, 0x00, 0x43,
+    0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x32, 0x37,
+    0x00, 0x43, 0x61, 0x6c, 0x64, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x32, 0x31, 0x36, 0x34, 0x00, 0x4c, 0x61,
+    0x6b, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x50, 0x65, 0x6e, 0x69, 0x6e,
+    0x73, 0x75, 0x6c, 0x61, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68,
+    0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x39, 0x00, 0x31, 0x36, 0x30, 0x33, 0x39, 0x00, 0x45, 0x6c,
+    0x6d, 0x6f, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x33, 0x30, 0x30, 0x38, 0x35, 0x00, 0x52, 0x6f, 0x6f, 0x73,
+    0x65, 0x76, 0x65, 0x6c, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x30, 0x31, 0x31, 0x00, 0x41,
+    0x72, 0x65, 0x6e, 0x61, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x32, 0x31, 0x00,
+    0x46, 0x75, 0x6c, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x30, 0x35, 0x31, 0x00,
+    0x46, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f,
+    0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x34,
+    0x39, 0x00, 0x43, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31,
+    0x32, 0x33, 0x37, 0x00, 0x57, 0x6f, 0x6c, 0x66, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39,
+    0x31, 0x30, 0x33, 0x00, 0x4d, 0x65, 0x64, 0x69, 0x6e, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x34, 0x33,
+    0x00, 0x45, 0x72, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x37, 0x30, 0x38, 0x37, 0x00, 0x4a, 0x6f, 0x68, 0x6e,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x35, 0x37, 0x00, 0x54, 0x69,
+    0x70, 0x70, 0x65, 0x63, 0x61, 0x6e, 0x6f, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x36, 0x30, 0x38,
+    0x33, 0x00, 0x54, 0x77, 0x69, 0x6e, 0x20, 0x46, 0x61, 0x6c, 0x6c, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49,
+    0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x30,
+    0x31, 0x34, 0x39, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x74, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b,
+    0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x32, 0x33, 0x33, 0x00, 0x50, 0x6f, 0x6c, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39,
+    0x30, 0x31, 0x35, 0x00, 0x42, 0x6f, 0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x32, 0x35, 0x00,
+    0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x37, 0x31, 0x00, 0x53, 0x63, 0x6f,
+    0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x32, 0x30, 0x35, 0x33, 0x00, 0x46, 0x6f, 0x72, 0x65, 0x73,
+    0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00,
+    0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61,
+    0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x32, 0x30, 0x35, 0x00,
+    0x48, 0x61, 0x72, 0x74, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x39, 0x39, 0x00, 0x57,
+    0x61, 0x6c, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x31, 0x34, 0x35, 0x00, 0x52,
+    0x6f, 0x61, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x31, 0x33, 0x00, 0x4c,
+    0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x30, 0x39,
+    0x00, 0x43, 0x61, 0x72, 0x62, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x33, 0x30, 0x34, 0x39,
+    0x00, 0x50, 0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x30, 0x31, 0x30, 0x34, 0x35, 0x00, 0x44, 0x61, 0x6c, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61,
+    0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31,
+    0x30, 0x37, 0x31, 0x00, 0x47, 0x69, 0x6c, 0x65, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36,
+    0x30, 0x39, 0x39, 0x00, 0x53, 0x74, 0x61, 0x6e, 0x69, 0x73, 0x6c, 0x61,
+    0x75, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41,
+    0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00,
+    0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x38, 0x30, 0x39, 0x33, 0x00, 0x4d,
+    0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70,
+    0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x34,
+    0x39, 0x00, 0x46, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x73, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30,
+    0x31, 0x30, 0x39, 0x35, 0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00,
+    0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x35, 0x30, 0x32, 0x35, 0x00, 0x53, 0x75, 0x66, 0x66, 0x6f,
+    0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x41,
+    0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68, 0x75, 0x73, 0x65, 0x74,
+    0x74, 0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x38,
+    0x37, 0x00, 0x54, 0x75, 0x72, 0x6e, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x34,
+    0x39, 0x00, 0x43, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x31, 0x30, 0x30, 0x31, 0x00, 0x44, 0x69, 0x73, 0x74, 0x72,
+    0x69, 0x63, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x43, 0x6f, 0x6c, 0x75, 0x6d,
+    0x62, 0x69, 0x61, 0x00, 0x44, 0x43, 0x00, 0x44, 0x69, 0x73, 0x74, 0x72,
+    0x69, 0x63, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x43, 0x6f, 0x6c, 0x75, 0x6d,
+    0x62, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30,
+    0x32, 0x31, 0x00, 0x43, 0x68, 0x65, 0x72, 0x6f, 0x6b, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34,
+    0x31, 0x30, 0x37, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x38, 0x31, 0x30, 0x33, 0x00, 0x43, 0x72, 0x61, 0x6e,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x30, 0x37, 0x35, 0x00, 0x46, 0x75, 0x6c, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x32, 0x30, 0x31, 0x33, 0x00, 0x42, 0x6c, 0x61, 0x69, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65,
+    0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x34, 0x30, 0x30, 0x35, 0x00, 0x4e, 0x65,
+    0x77, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x52, 0x49, 0x00, 0x52, 0x68, 0x6f, 0x64, 0x65, 0x20, 0x49, 0x73,
+    0x6c, 0x61, 0x6e, 0x64, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39,
+    0x31, 0x30, 0x35, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x33, 0x35, 0x00,
+    0x50, 0x72, 0x65, 0x62, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x33, 0x31, 0x00, 0x43, 0x68, 0x65,
+    0x62, 0x6f, 0x79, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x31, 0x30, 0x37,
+    0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x37, 0x30, 0x30, 0x35, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x67, 0x68, 0x61,
+    0x6e, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x31,
+    0x32, 0x39, 0x00, 0x57, 0x61, 0x6c, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x37, 0x00, 0x33, 0x37, 0x31, 0x36, 0x35, 0x00, 0x53, 0x63,
+    0x6f, 0x74, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43,
+    0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x35, 0x31, 0x34, 0x39, 0x00, 0x59, 0x65, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72,
+    0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x31, 0x30, 0x38, 0x35, 0x00, 0x47, 0x72, 0x61, 0x79, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00,
+    0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x35, 0x31, 0x33, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x6e,
+    0x65, 0x62, 0x61, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73,
+    0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x35,
+    0x37, 0x00, 0x47, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68,
+    0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37,
+    0x31, 0x34, 0x31, 0x00, 0x50, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x31, 0x30, 0x33, 0x37, 0x00, 0x4c,
+    0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x38, 0x31, 0x32, 0x35, 0x00, 0x44, 0x69, 0x63, 0x6b,
+    0x65, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x38, 0x30, 0x30, 0x39, 0x00, 0x42, 0x6f, 0x74, 0x74, 0x69,
+    0x6e, 0x65, 0x61, 0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30,
+    0x36, 0x37, 0x00, 0x4f, 0x6e, 0x6f, 0x6e, 0x64, 0x61, 0x67, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x30, 0x38, 0x30, 0x36, 0x31, 0x00, 0x4b, 0x69, 0x6f, 0x77, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f,
+    0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x32, 0x37, 0x30, 0x36, 0x37, 0x00, 0x4b, 0x61, 0x6e, 0x64, 0x69, 0x79,
+    0x6f, 0x68, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x30, 0x31, 0x00, 0x41,
+    0x64, 0x61, 0x6d, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x35, 0x30, 0x32,
+    0x37, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x32, 0x30, 0x30, 0x35, 0x31, 0x00, 0x45, 0x6c, 0x6c, 0x69, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31,
+    0x30, 0x35, 0x31, 0x00, 0x44, 0x69, 0x78, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72,
+    0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31,
+    0x31, 0x33, 0x31, 0x00, 0x4c, 0x65, 0x73, 0x6c, 0x69, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x33, 0x32, 0x39, 0x37, 0x00, 0x57, 0x61, 0x6c, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x38, 0x30, 0x39, 0x39, 0x00, 0x4e, 0x65, 0x73, 0x68, 0x6f, 0x62, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d,
+    0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x31, 0x30, 0x38, 0x37, 0x00, 0x48, 0x69, 0x74, 0x63, 0x68,
+    0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x38, 0x35, 0x00, 0x4a,
+    0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x33, 0x31, 0x00, 0x50,
+    0x69, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x37, 0x30, 0x30, 0x35, 0x00, 0x42, 0x65, 0x63, 0x6b, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d,
+    0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x30, 0x31, 0x34, 0x35, 0x00, 0x50, 0x61, 0x77, 0x6e,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x37, 0x31, 0x38, 0x39, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x30, 0x32, 0x35, 0x00,
+    0x43, 0x6c, 0x61, 0x72, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x30, 0x31, 0x00,
+    0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x37, 0x31, 0x00, 0x4c, 0x61, 0x6d,
+    0x61, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x38, 0x31, 0x33, 0x31, 0x00, 0x50, 0x75, 0x6c, 0x61,
+    0x73, 0x6b, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x37, 0x31, 0x38, 0x33, 0x00, 0x56, 0x65, 0x72,
+    0x6d, 0x69, 0x6c, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30, 0x36, 0x37,
+    0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x38, 0x30, 0x32, 0x31, 0x00, 0x44, 0x69, 0x63, 0x6b,
+    0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x36, 0x33,
+    0x00, 0x4d, 0x69, 0x73, 0x73, 0x6f, 0x75, 0x6c, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74,
+    0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x35, 0x30,
+    0x39, 0x31, 0x00, 0x59, 0x6f, 0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x30, 0x31, 0x36, 0x39, 0x00, 0x53, 0x61, 0x6c, 0x69,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x32, 0x31, 0x31, 0x31, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e,
+    0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c,
+    0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x32, 0x39, 0x31, 0x00, 0x4c, 0x69, 0x62, 0x65,
+    0x72, 0x74, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x37, 0x30, 0x39, 0x37, 0x00, 0x4c, 0x61, 0x75, 0x64, 0x65,
+    0x72, 0x64, 0x61, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x30, 0x31, 0x39, 0x00,
+    0x42, 0x75, 0x74, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c,
+    0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x36, 0x30, 0x34, 0x31, 0x00, 0x44, 0x65, 0x77, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x36, 0x37, 0x00, 0x48, 0x61, 0x72,
+    0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x38, 0x34, 0x35, 0x33, 0x00, 0x54, 0x72, 0x61, 0x76,
+    0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x34, 0x34, 0x33, 0x00, 0x54, 0x65, 0x72, 0x72, 0x65, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35,
+    0x31, 0x35, 0x34, 0x30, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x6f, 0x74,
+    0x74, 0x65, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x63, 0x69, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x34, 0x31,
+    0x00, 0x48, 0x69, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x36, 0x30, 0x34, 0x35, 0x00, 0x47,
+    0x65, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44,
+    0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x32, 0x32, 0x30, 0x34, 0x37, 0x00, 0x49, 0x62, 0x65, 0x72, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c,
+    0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x39, 0x35, 0x00, 0x4b,
+    0x6e, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x36, 0x31, 0x00, 0x48, 0x6f,
+    0x75, 0x67, 0x68, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x36, 0x31,
+    0x00, 0x44, 0x75, 0x70, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x33, 0x30, 0x32, 0x35, 0x00, 0x53, 0x6f, 0x6d, 0x65,
+    0x72, 0x73, 0x65, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x30, 0x30, 0x36, 0x31, 0x00, 0x47, 0x65, 0x61, 0x72,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x36, 0x31, 0x30, 0x35, 0x00, 0x53, 0x75, 0x6c, 0x6c, 0x69, 0x76,
+    0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x31, 0x32, 0x30, 0x33, 0x00, 0x52, 0x6f, 0x63,
+    0x6b, 0x63, 0x61, 0x73, 0x74, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63,
+    0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x38,
+    0x33, 0x00, 0x53, 0x6d, 0x69, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x31, 0x31, 0x37, 0x00,
+    0x54, 0x69, 0x6f, 0x67, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76,
+    0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39,
+    0x31, 0x33, 0x37, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x32, 0x30, 0x37, 0x31, 0x00, 0x4c, 0x61, 0x6e, 0x63, 0x61, 0x73, 0x74,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41,
+    0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x39, 0x35,
+    0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x38,
+    0x39, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x38, 0x39, 0x00,
+    0x4e, 0x61, 0x73, 0x73, 0x61, 0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x30, 0x36, 0x39, 0x00,
+    0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36,
+    0x30, 0x37, 0x37, 0x00, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33, 0x31, 0x34, 0x39,
+    0x00, 0x48, 0x65, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x35, 0x30, 0x31, 0x31, 0x00,
+    0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61,
+    0x63, 0x68, 0x75, 0x73, 0x65, 0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x31, 0x31, 0x35, 0x33, 0x00, 0x53, 0x61, 0x72, 0x70,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00,
+    0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x32, 0x30, 0x34, 0x31, 0x00, 0x43, 0x75, 0x6d, 0x62,
+    0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c,
+    0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x38, 0x30, 0x35, 0x39, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d,
+    0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x37, 0x31, 0x34, 0x35, 0x00, 0x50, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x36,
+    0x39, 0x00, 0x4d, 0x65, 0x74, 0x63, 0x61, 0x6c, 0x66, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35,
+    0x31, 0x30, 0x38, 0x37, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x69, 0x63, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x30, 0x31, 0x35, 0x31, 0x00, 0x50, 0x72, 0x61, 0x74, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x36, 0x31, 0x30, 0x39, 0x00, 0x54, 0x75, 0x6f, 0x6c, 0x75, 0x6d, 0x6e,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00,
+    0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x30, 0x35, 0x31, 0x31, 0x31, 0x00, 0x50, 0x6f,
+    0x69, 0x6e, 0x73, 0x65, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x31, 0x39,
+    0x00, 0x44, 0x61, 0x6e, 0x69, 0x65, 0x6c, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61,
+    0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x39, 0x30, 0x33,
+    0x39, 0x00, 0x44, 0x65, 0x66, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x32, 0x32, 0x38, 0x32,
+    0x00, 0x59, 0x61, 0x6b, 0x75, 0x74, 0x61, 0x74, 0x20, 0x42, 0x6f, 0x72,
+    0x6f, 0x75, 0x67, 0x68, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x32, 0x32, 0x30, 0x31,
+    0x35, 0x00, 0x42, 0x6f, 0x73, 0x73, 0x69, 0x65, 0x72, 0x20, 0x50, 0x61,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69,
+    0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x39, 0x31, 0x30, 0x35, 0x00, 0x4c, 0x61, 0x63, 0x6c, 0x65, 0x64, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d,
+    0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x32, 0x31, 0x30, 0x33, 0x00, 0x50, 0x69, 0x6e, 0x65, 0x6c,
+    0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46,
+    0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x31, 0x31, 0x00, 0x43, 0x61, 0x79,
+    0x75, 0x67, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x35, 0x30, 0x37, 0x33, 0x00, 0x4f, 0x63,
+    0x6f, 0x6e, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35,
+    0x35, 0x30, 0x34, 0x31, 0x00, 0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69,
+    0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x39, 0x32, 0x31, 0x39, 0x00, 0x57, 0x61, 0x72, 0x72,
+    0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x32, 0x39, 0x00, 0x50, 0x6f, 0x73,
+    0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e,
+    0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x33, 0x30, 0x30, 0x33, 0x00, 0x41, 0x72, 0x6f, 0x6f,
+    0x73, 0x74, 0x6f, 0x6f, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x30, 0x39, 0x00, 0x53, 0x61, 0x6e,
+    0x20, 0x50, 0x61, 0x74, 0x72, 0x69, 0x63, 0x69, 0x6f, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x35, 0x37,
+    0x00, 0x43, 0x68, 0x65, 0x72, 0x6f, 0x6b, 0x65, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x31,
+    0x33, 0x31, 0x00, 0x57, 0x69, 0x6c, 0x63, 0x6f, 0x78, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62,
+    0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30,
+    0x31, 0x33, 0x00, 0x42, 0x61, 0x72, 0x61, 0x67, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68,
+    0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35,
+    0x31, 0x33, 0x39, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38,
+    0x30, 0x35, 0x35, 0x00, 0x49, 0x73, 0x73, 0x61, 0x71, 0x75, 0x65, 0x6e,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x39, 0x32, 0x30, 0x35, 0x00, 0x53, 0x68, 0x65, 0x6c,
+    0x62, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x31, 0x31, 0x37, 0x33, 0x00, 0x54, 0x68, 0x75,
+    0x72, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x37, 0x34, 0x30, 0x00,
+    0x50, 0x6f, 0x72, 0x74, 0x73, 0x6d, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x63,
+    0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x31,
+    0x34, 0x35, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69,
+    0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x31,
+    0x30, 0x35, 0x00, 0x54, 0x61, 0x6e, 0x67, 0x69, 0x70, 0x61, 0x68, 0x6f,
+    0x61, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00,
+    0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x32, 0x39, 0x00, 0x45, 0x72, 0x69,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x39, 0x32, 0x31, 0x31, 0x00, 0x53, 0x75, 0x6c, 0x6c,
+    0x69, 0x76, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31, 0x36, 0x39, 0x00, 0x54,
+    0x68, 0x61, 0x79, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x39, 0x31, 0x37, 0x35, 0x00,
+    0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x36, 0x31, 0x30, 0x31, 0x00, 0x53, 0x75, 0x74, 0x74,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41,
+    0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00,
+    0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x36, 0x30, 0x35, 0x37, 0x00, 0x48,
+    0x61, 0x6d, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x37,
+    0x31, 0x30, 0x33, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65,
+    0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x30, 0x30, 0x31, 0x31, 0x00, 0x43, 0x61, 0x72, 0x74, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d,
+    0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00,
+    0x32, 0x30, 0x30, 0x34, 0x33, 0x00, 0x44, 0x6f, 0x6e, 0x69, 0x70, 0x68,
+    0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x32, 0x30, 0x30, 0x33, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00, 0x4e,
+    0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00, 0x30,
+    0x36, 0x30, 0x37, 0x35, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x46, 0x72, 0x61,
+    0x6e, 0x63, 0x69, 0x73, 0x63, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x38, 0x30,
+    0x34, 0x35, 0x00, 0x46, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x37, 0x31, 0x32, 0x37, 0x00, 0x4d, 0x6f, 0x6f, 0x72, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x31, 0x31, 0x33, 0x00, 0x4a, 0x65, 0x73, 0x73, 0x61, 0x6d, 0x69,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59,
+    0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x30, 0x31, 0x33, 0x39, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b,
+    0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x37, 0x37, 0x00, 0x54, 0x79, 0x72,
+    0x72, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30,
+    0x35, 0x30, 0x36, 0x39, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52,
+    0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x39, 0x33, 0x00, 0x50, 0x69, 0x65,
+    0x72, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x30, 0x39, 0x00,
+    0x43, 0x6c, 0x61, 0x6c, 0x6c, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x35,
+    0x31, 0x30, 0x31, 0x35, 0x00, 0x41, 0x75, 0x67, 0x75, 0x73, 0x74, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x36, 0x30, 0x32, 0x37, 0x00, 0x49, 0x6e, 0x79, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61,
+    0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x31, 0x38, 0x31, 0x36, 0x35, 0x00, 0x56, 0x65, 0x72, 0x6d,
+    0x69, 0x6c, 0x6c, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x35, 0x33, 0x00,
+    0x50, 0x6f, 0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x39, 0x30, 0x30, 0x39, 0x00, 0x41, 0x75, 0x64, 0x75, 0x62,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x30, 0x30, 0x35, 0x31, 0x00, 0x47, 0x72, 0x61, 0x64, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c,
+    0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x30, 0x32, 0x35, 0x00, 0x42, 0x72, 0x65, 0x61, 0x74, 0x68, 0x69,
+    0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59,
+    0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x39, 0x33, 0x00, 0x57, 0x68, 0x69,
+    0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x35, 0x37, 0x00, 0x4a, 0x61, 0x63,
+    0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x34, 0x30, 0x31, 0x35, 0x00, 0x43,
+    0x65, 0x63, 0x69, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x32, 0x39, 0x33, 0x00, 0x4c,
+    0x69, 0x6d, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x33, 0x33, 0x00,
+    0x4d, 0x6f, 0x6e, 0x6f, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x38, 0x31, 0x00, 0x52, 0x61, 0x6e,
+    0x64, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x38, 0x30, 0x32, 0x31, 0x00, 0x43, 0x6c, 0x61, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49,
+    0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x36, 0x30, 0x30, 0x33, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64,
+    0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x31, 0x32,
+    0x30, 0x39, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30,
+    0x31, 0x39, 0x00, 0x42, 0x65, 0x64, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x36, 0x30, 0x36, 0x33, 0x00, 0x48, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53,
+    0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x35, 0x31, 0x33, 0x31, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x39, 0x30, 0x36, 0x37, 0x00, 0x46, 0x6c, 0x6f, 0x79, 0x64, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x37,
+    0x39, 0x00, 0x57, 0x65, 0x6c, 0x6c, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e,
+    0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x30, 0x33,
+    0x00, 0x42, 0x61, 0x72, 0x6e, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x31, 0x39, 0x35, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x35, 0x30, 0x34, 0x39, 0x00, 0x46, 0x75, 0x6c, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00,
+    0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x37, 0x31, 0x31, 0x37, 0x00, 0x4d, 0x61, 0x72, 0x73,
+    0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x33, 0x37, 0x00, 0x44,
+    0x61, 0x76, 0x69, 0x64, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73,
+    0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x36,
+    0x37, 0x00, 0x48, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x31,
+    0x37, 0x00, 0x45, 0x6c, 0x20, 0x44, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61,
+    0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x30, 0x35, 0x30, 0x36, 0x37, 0x00, 0x4a, 0x61, 0x63, 0x6b,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x31, 0x31, 0x37, 0x00, 0x53, 0x65,
+    0x6d, 0x69, 0x6e, 0x6f, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x36, 0x30, 0x37, 0x31, 0x00,
+    0x4f, 0x6e, 0x65, 0x69, 0x64, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x30, 0x38, 0x35, 0x00, 0x4c, 0x61,
+    0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49,
+    0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x31, 0x30, 0x35, 0x39, 0x00, 0x55, 0x6d, 0x61,
+    0x74, 0x69, 0x6c, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x31, 0x33, 0x31, 0x37, 0x33, 0x00, 0x4c, 0x61,
+    0x6e, 0x69, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x34, 0x31, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x62, 0x75, 0x72, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32,
+    0x33, 0x37, 0x00, 0x50, 0x75, 0x74, 0x6e, 0x61, 0x6d, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x30,
+    0x37, 0x33, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e,
+    0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30,
+    0x37, 0x35, 0x00, 0x50, 0x6f, 0x77, 0x64, 0x65, 0x72, 0x20, 0x52, 0x69,
+    0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00,
+    0x2d, 0x37, 0x00, 0x33, 0x31, 0x31, 0x32, 0x31, 0x00, 0x4d, 0x65, 0x72,
+    0x72, 0x69, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x32, 0x30, 0x31, 0x37, 0x00, 0x42,
+    0x75, 0x63, 0x6b, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61,
+    0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x31,
+    0x33, 0x31, 0x00, 0x52, 0x6f, 0x67, 0x65, 0x72, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61,
+    0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39,
+    0x30, 0x34, 0x33, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x37,
+    0x35, 0x00, 0x57, 0x68, 0x69, 0x74, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x30, 0x35, 0x30, 0x32, 0x31, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72,
+    0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x31, 0x31, 0x31, 0x39, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00,
+    0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x37, 0x00, 0x31, 0x36, 0x30, 0x33, 0x31, 0x00, 0x43, 0x61, 0x73, 0x73,
+    0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44,
+    0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x31, 0x32, 0x31, 0x31, 0x33, 0x00, 0x53, 0x61, 0x6e, 0x74, 0x61, 0x20,
+    0x52, 0x6f, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x33, 0x35, 0x00, 0x45, 0x63,
+    0x74, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x34, 0x36, 0x31, 0x00, 0x55, 0x70, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36,
+    0x31, 0x30, 0x33, 0x00, 0x53, 0x75, 0x66, 0x66, 0x6f, 0x6c, 0x6b, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x36, 0x31, 0x36, 0x33, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x30, 0x31, 0x30, 0x37, 0x31, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00,
+    0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x31, 0x31, 0x32, 0x31, 0x00, 0x4b, 0x6e, 0x6f, 0x78, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x38, 0x34, 0x36, 0x37, 0x00, 0x56, 0x61, 0x6e, 0x20, 0x5a, 0x61,
+    0x6e, 0x64, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x34, 0x30, 0x31, 0x39, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x65,
+    0x72, 0x64, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65,
+    0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x30, 0x33,
+    0x00, 0x4e, 0x69, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e,
+    0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x39, 0x31, 0x30, 0x33, 0x00, 0x4b, 0x6e, 0x6f, 0x78, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31,
+    0x30, 0x31, 0x39, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72,
+    0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x31,
+    0x30, 0x36, 0x39, 0x00, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72,
+    0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x38,
+    0x30, 0x32, 0x35, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69,
+    0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31,
+    0x36, 0x33, 0x00, 0x4d, 0x65, 0x61, 0x64, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30,
+    0x31, 0x37, 0x00, 0x42, 0x6f, 0x75, 0x72, 0x62, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x39, 0x31, 0x38, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x6e, 0x65, 0x62, 0x61,
+    0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x36, 0x30, 0x37, 0x31, 0x00, 0x49, 0x72, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68,
+    0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33,
+    0x31, 0x38, 0x31, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x39, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x31, 0x31, 0x33, 0x00, 0x46, 0x61, 0x79, 0x65, 0x74, 0x74,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x35, 0x30, 0x30, 0x37, 0x00, 0x41, 0x6e, 0x64, 0x65, 0x72,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x35,
+    0x30, 0x30, 0x33, 0x00, 0x42, 0x65, 0x72, 0x6b, 0x73, 0x68, 0x69, 0x72,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x41, 0x00,
+    0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68, 0x75, 0x73, 0x65, 0x74, 0x74,
+    0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x34, 0x39,
+    0x00, 0x48, 0x61, 0x72, 0x64, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x32, 0x32, 0x39, 0x30,
+    0x00, 0x59, 0x75, 0x6b, 0x6f, 0x6e, 0x2d, 0x4b, 0x6f, 0x79, 0x75, 0x6b,
+    0x75, 0x6b, 0x20, 0x43, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x20, 0x41, 0x72,
+    0x65, 0x61, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x30, 0x36, 0x30, 0x33, 0x31, 0x00,
+    0x4b, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e,
+    0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x37, 0x31, 0x30,
+    0x37, 0x00, 0x4e, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65,
+    0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36,
+    0x30, 0x36, 0x35, 0x00, 0x4f, 0x6e, 0x65, 0x69, 0x64, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x30, 0x30, 0x34, 0x37, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74,
+    0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x32, 0x31,
+    0x32, 0x32, 0x00, 0x4b, 0x65, 0x6e, 0x61, 0x69, 0x20, 0x50, 0x65, 0x6e,
+    0x69, 0x6e, 0x73, 0x75, 0x6c, 0x61, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75,
+    0x67, 0x68, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x34, 0x38, 0x32, 0x38, 0x39, 0x00,
+    0x4c, 0x65, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x30, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x69,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00,
+    0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x31, 0x32, 0x32, 0x31, 0x00, 0x54, 0x72, 0x69, 0x67,
+    0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00,
+    0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x35, 0x30, 0x36, 0x31, 0x00, 0x4c, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x32, 0x39, 0x00,
+    0x43, 0x6f, 0x6e, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x61, 0x20, 0x50, 0x61,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69,
+    0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x32, 0x30, 0x37, 0x33, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30,
+    0x32, 0x31, 0x00, 0x42, 0x65, 0x72, 0x72, 0x69, 0x65, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63,
+    0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x30, 0x31, 0x30, 0x33, 0x00, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x6e, 0x77,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x32, 0x31, 0x30, 0x39, 0x00, 0x54, 0x65, 0x72,
+    0x72, 0x65, 0x62, 0x6f, 0x6e, 0x6e, 0x65, 0x20, 0x50, 0x61, 0x72, 0x69,
+    0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30,
+    0x39, 0x37, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39, 0x30, 0x34, 0x35,
+    0x00, 0x54, 0x6f, 0x6f, 0x65, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x33, 0x38, 0x37, 0x00, 0x52, 0x65,
+    0x64, 0x20, 0x52, 0x69, 0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x30, 0x33, 0x00, 0x45,
+    0x66, 0x66, 0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x32,
+    0x35, 0x00, 0x47, 0x6c, 0x61, 0x73, 0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38,
+    0x30, 0x37, 0x35, 0x00, 0x4a, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e,
+    0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x35, 0x30, 0x32, 0x35,
+    0x00, 0x43, 0x68, 0x65, 0x73, 0x74, 0x65, 0x72, 0x66, 0x69, 0x65, 0x6c,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x34,
+    0x35, 0x00, 0x50, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x35, 0x33, 0x00, 0x43, 0x6c, 0x69,
+    0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x36, 0x35, 0x00, 0x44,
+    0x65, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x31, 0x34, 0x31, 0x00, 0x56, 0x61,
+    0x6e, 0x20, 0x42, 0x75, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x32, 0x31, 0x38,
+    0x38, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x77, 0x65, 0x73, 0x74, 0x20,
+    0x41, 0x72, 0x63, 0x74, 0x69, 0x63, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75,
+    0x67, 0x68, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x30, 0x31, 0x30, 0x35, 0x37, 0x00,
+    0x46, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x39, 0x31,
+    0x00, 0x54, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x33, 0x30, 0x33, 0x37, 0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f,
+    0x75, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x39, 0x30, 0x38, 0x35, 0x00, 0x4c, 0x61, 0x6b, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f,
+    0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x30,
+    0x37, 0x37, 0x00, 0x47, 0x75, 0x74, 0x68, 0x72, 0x69, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x34, 0x31,
+    0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e,
+    0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30,
+    0x34, 0x31, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x31, 0x31, 0x33, 0x31, 0x00, 0x4f, 0x74, 0x6f, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34,
+    0x37, 0x30, 0x34, 0x35, 0x00, 0x44, 0x79, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38,
+    0x30, 0x30, 0x37, 0x00, 0x41, 0x74, 0x74, 0x61, 0x6c, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x39, 0x30, 0x38, 0x33, 0x00, 0x4b, 0x6e, 0x6f, 0x78, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x32, 0x32, 0x35, 0x00,
+    0x57, 0x65, 0x62, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x37,
+    0x39, 0x00, 0x50, 0x75, 0x74, 0x6e, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x30, 0x31, 0x31, 0x31, 0x39, 0x00, 0x53, 0x75, 0x6d, 0x74,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c,
+    0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x34, 0x30, 0x34, 0x31, 0x00, 0x54, 0x61, 0x6c, 0x62,
+    0x6f, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44,
+    0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x31, 0x39, 0x00, 0x46, 0x61, 0x79,
+    0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34,
+    0x30, 0x36, 0x39, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x32, 0x30, 0x32, 0x39, 0x00, 0x44, 0x69, 0x78, 0x69,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00,
+    0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x33, 0x33, 0x31, 0x35, 0x00, 0x57, 0x69, 0x6c, 0x63, 0x6f,
+    0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x33, 0x31, 0x39, 0x33, 0x00, 0x4d, 0x61, 0x63, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x36, 0x31, 0x33, 0x35, 0x00, 0x4f, 0x73, 0x63, 0x6f, 0x64, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x30, 0x30, 0x32, 0x31, 0x00, 0x52, 0x75, 0x74, 0x6c, 0x61,
+    0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54,
+    0x00, 0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x36, 0x31, 0x33, 0x37, 0x00, 0x4f, 0x74, 0x73, 0x65,
+    0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49,
+    0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x35, 0x31, 0x00, 0x4d, 0x63, 0x49,
+    0x6e, 0x74, 0x6f, 0x73, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37,
+    0x31, 0x36, 0x35, 0x00, 0x57, 0x61, 0x74, 0x6f, 0x6e, 0x77, 0x61, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d,
+    0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x37, 0x31, 0x33, 0x37, 0x00, 0x50, 0x69, 0x63, 0x6b,
+    0x65, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x32, 0x31, 0x00, 0x50, 0x61,
+    0x72, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x39, 0x30, 0x30, 0x31, 0x00, 0x42, 0x65, 0x61,
+    0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55,
+    0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x34, 0x38, 0x34, 0x31, 0x37, 0x00, 0x53, 0x68, 0x61, 0x63, 0x6b, 0x65,
+    0x6c, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x37, 0x33, 0x00, 0x4f, 0x72, 0x6c,
+    0x65, 0x61, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x38, 0x33, 0x00, 0x4c,
+    0x69, 0x6d, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x38,
+    0x33, 0x00, 0x48, 0x6f, 0x75, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37,
+    0x31, 0x39, 0x31, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x36, 0x39, 0x00, 0x44, 0x75,
+    0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x35, 0x31, 0x00,
+    0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x50, 0x61,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69,
+    0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x38, 0x30, 0x31, 0x39, 0x00, 0x43, 0x6c, 0x65, 0x61, 0x72, 0x20, 0x43,
+    0x72, 0x65, 0x65, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x31, 0x32, 0x37, 0x00, 0x4f,
+    0x63, 0x65, 0x61, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x31, 0x33, 0x35, 0x00,
+    0x59, 0x61, 0x6e, 0x6b, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x30, 0x30, 0x32, 0x33, 0x00, 0x43, 0x68, 0x65, 0x79, 0x65, 0x6e,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x32, 0x30, 0x32, 0x39, 0x00, 0x53, 0x74, 0x6f, 0x72, 0x65,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00,
+    0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00,
+    0x33, 0x36, 0x31, 0x31, 0x35, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e,
+    0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x31, 0x32, 0x35, 0x00, 0x53,
+    0x61, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x32, 0x31, 0x00,
+    0x42, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x37, 0x35, 0x00,
+    0x57, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x38, 0x30, 0x31, 0x35, 0x00, 0x43, 0x61, 0x72, 0x72,
+    0x6f, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x33, 0x39, 0x00, 0x54, 0x61,
+    0x72, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x35, 0x30, 0x32, 0x37, 0x00, 0x57, 0x6f, 0x72,
+    0x63, 0x65, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68,
+    0x75, 0x73, 0x65, 0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x33, 0x32, 0x38, 0x35, 0x00, 0x54, 0x72, 0x6f, 0x75, 0x70, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x37, 0x31, 0x37, 0x37, 0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x65, 0x6e,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x38, 0x33, 0x00, 0x52, 0x65,
+    0x6e, 0x73, 0x73, 0x65, 0x6c, 0x61, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59,
+    0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31,
+    0x32, 0x37, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35,
+    0x30, 0x31, 0x33, 0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72,
+    0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x39, 0x31, 0x36, 0x33, 0x00, 0x50, 0x69, 0x6b, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x36, 0x30, 0x33, 0x35, 0x00, 0x44, 0x61, 0x76, 0x69, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53,
+    0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x31, 0x31, 0x00, 0x4d,
+    0x63, 0x4d, 0x75, 0x6c, 0x6c, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x31, 0x35, 0x31, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73,
+    0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30,
+    0x30, 0x36, 0x33, 0x00, 0x47, 0x6f, 0x76, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x31, 0x33, 0x35,
+    0x00, 0x57, 0x61, 0x75, 0x70, 0x61, 0x63, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f,
+    0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x35, 0x30, 0x38, 0x37, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41,
+    0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x33, 0x36, 0x33, 0x00, 0x50, 0x61, 0x6c, 0x6f, 0x20,
+    0x50, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x35, 0x30, 0x31, 0x37, 0x00, 0x4d, 0x69, 0x64,
+    0x64, 0x6c, 0x65, 0x73, 0x65, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68,
+    0x75, 0x73, 0x65, 0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x31, 0x31, 0x33, 0x31, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x61,
+    0x6d, 0x70, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x33, 0x39, 0x00,
+    0x51, 0x75, 0x69, 0x74, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x31, 0x30, 0x31,
+    0x00, 0x57, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37,
+    0x31, 0x35, 0x31, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38,
+    0x31, 0x30, 0x35, 0x00, 0x52, 0x69, 0x6f, 0x20, 0x47, 0x72, 0x61, 0x6e,
+    0x64, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f,
+    0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x32, 0x31, 0x32, 0x32, 0x33, 0x00, 0x54, 0x72, 0x69,
+    0x6d, 0x62, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x39, 0x33, 0x00, 0x52,
+    0x6f, 0x62, 0x65, 0x72, 0x74, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30, 0x36, 0x33, 0x00, 0x57, 0x61,
+    0x6c, 0x6c, 0x6f, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x32, 0x37, 0x31, 0x32, 0x33, 0x00, 0x52, 0x61,
+    0x6d, 0x73, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x33, 0x31, 0x00,
+    0x42, 0x75, 0x74, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b,
+    0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x37, 0x31,
+    0x00, 0x50, 0x75, 0x74, 0x6e, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x31,
+    0x31, 0x00, 0x43, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x38, 0x31, 0x32, 0x35, 0x00, 0x50, 0x69, 0x6b,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00,
+    0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x33, 0x32, 0x37, 0x39, 0x00, 0x54, 0x6f, 0x6f, 0x6d, 0x62,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x31, 0x30, 0x32, 0x31, 0x00, 0x43, 0x68, 0x69, 0x6c, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c,
+    0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x36, 0x30, 0x34, 0x31, 0x00, 0x46, 0x72, 0x61, 0x6e,
+    0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x39, 0x30, 0x33, 0x33, 0x00, 0x52, 0x69, 0x63, 0x68,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55,
+    0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x36, 0x31,
+    0x32, 0x35, 0x00, 0x54, 0x75, 0x72, 0x6e, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74,
+    0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x37, 0x00, 0x30, 0x34, 0x30, 0x31, 0x39, 0x00, 0x50, 0x69, 0x6d, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a, 0x00, 0x41,
+    0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x33, 0x36, 0x30, 0x39, 0x31, 0x00, 0x53, 0x61, 0x72, 0x61, 0x74, 0x6f,
+    0x67, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x38, 0x31, 0x00, 0x4c, 0x61, 0x77,
+    0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x30,
+    0x30, 0x30, 0x33, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x43, 0x61, 0x73, 0x74,
+    0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x44, 0x45,
+    0x00, 0x44, 0x65, 0x6c, 0x61, 0x77, 0x61, 0x72, 0x65, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x36, 0x31, 0x00, 0x48, 0x6f, 0x77,
+    0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x38, 0x37, 0x00, 0x47, 0x72,
+    0x65, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x37, 0x31, 0x00, 0x43, 0x6f,
+    0x6c, 0x71, 0x75, 0x69, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x33, 0x33, 0x00,
+    0x45, 0x73, 0x63, 0x61, 0x6d, 0x62, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69,
+    0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x31, 0x33,
+    0x39, 0x00, 0x50, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x31, 0x36, 0x37,
+    0x00, 0x53, 0x61, 0x6e, 0x67, 0x61, 0x6d, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37,
+    0x31, 0x33, 0x33, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x36, 0x30, 0x36, 0x31, 0x00, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61,
+    0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x33, 0x30, 0x30, 0x37, 0x31, 0x00, 0x50, 0x68, 0x69, 0x6c,
+    0x6c, 0x69, 0x70, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x30, 0x34, 0x30, 0x30, 0x37, 0x00, 0x47, 0x69,
+    0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a,
+    0x00, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x30, 0x31, 0x31, 0x33, 0x33, 0x00, 0x57, 0x69, 0x6e, 0x73,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x37, 0x33, 0x00, 0x43, 0x6f, 0x6c,
+    0x75, 0x6d, 0x62, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x30, 0x39, 0x00, 0x4f,
+    0x6c, 0x6d, 0x73, 0x74, 0x65, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x38,
+    0x33, 0x00, 0x4c, 0x6f, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f,
+    0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x33,
+    0x31, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x34, 0x30, 0x32, 0x35, 0x00, 0x4d, 0x6f, 0x6e, 0x6d, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00,
+    0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x30, 0x39, 0x31, 0x00, 0x4b,
+    0x61, 0x6e, 0x6b, 0x61, 0x6b, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f,
+    0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x34,
+    0x37, 0x00, 0x4e, 0x61, 0x63, 0x6f, 0x67, 0x64, 0x6f, 0x63, 0x68, 0x65,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x33, 0x30, 0x30, 0x35, 0x00, 0x43, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6c,
+    0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x38, 0x30, 0x34, 0x37, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b,
+    0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x37, 0x35, 0x00, 0x4c, 0x61, 0x6d,
+    0x61, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c,
+    0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x32, 0x30, 0x36, 0x33, 0x00, 0x4c, 0x69, 0x76, 0x69,
+    0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73,
+    0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x37,
+    0x37, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e,
+    0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x31, 0x35, 0x37,
+    0x00, 0x57, 0x69, 0x6c, 0x6b, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x34, 0x31, 0x33, 0x00, 0x53, 0x63, 0x68, 0x6c, 0x65, 0x69, 0x63,
+    0x68, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x32, 0x31, 0x32, 0x33, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20,
+    0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x50, 0x61, 0x72, 0x69,
+    0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30,
+    0x39, 0x31, 0x00, 0x4f, 0x75, 0x72, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
+    0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x38,
+    0x33, 0x30, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73, 0x62,
+    0x75, 0x72, 0x67, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x31, 0x31, 0x35, 0x33, 0x00, 0x50, 0x72, 0x69, 0x6e,
+    0x63, 0x65, 0x20, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x37, 0x31, 0x38, 0x33, 0x00, 0x57, 0x65, 0x61, 0x6b, 0x6c, 0x65, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x32, 0x30, 0x37, 0x00, 0x48, 0x61, 0x73, 0x6b, 0x65,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x38, 0x30, 0x33, 0x31, 0x00, 0x46, 0x6f, 0x73, 0x74, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x37, 0x33, 0x00, 0x47,
+    0x61, 0x74, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30,
+    0x31, 0x31, 0x31, 0x33, 0x00, 0x52, 0x75, 0x73, 0x73, 0x65, 0x6c, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41,
+    0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x37, 0x30, 0x33, 0x37, 0x00, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d,
+    0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x37, 0x30, 0x37, 0x37, 0x00, 0x47, 0x72, 0x61, 0x6e,
+    0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x37, 0x30, 0x32, 0x33, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x38, 0x30, 0x34, 0x31, 0x00, 0x47, 0x72, 0x65, 0x65,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53,
+    0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x31, 0x35, 0x00, 0x43, 0x61, 0x72,
+    0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x33, 0x33, 0x00, 0x50,
+    0x6f, 0x72, 0x74, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x34, 0x37, 0x00, 0x4d, 0x65, 0x72,
+    0x63, 0x65, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x30, 0x30, 0x37, 0x33, 0x00,
+    0x47, 0x72, 0x65, 0x65, 0x6e, 0x77, 0x6f, 0x6f, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x35,
+    0x37, 0x00, 0x46, 0x75, 0x6c, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e,
+    0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30,
+    0x39, 0x35, 0x00, 0x53, 0x63, 0x68, 0x6f, 0x68, 0x61, 0x72, 0x69, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x30, 0x30, 0x31, 0x33, 0x00, 0x42, 0x72, 0x79, 0x61, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f,
+    0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x37, 0x30, 0x36, 0x35, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30, 0x39, 0x35, 0x00, 0x4d, 0x6f,
+    0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x38, 0x33, 0x00, 0x43,
+    0x6f, 0x6c, 0x65, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x33, 0x39, 0x00, 0x43, 0x72,
+    0x61, 0x77, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x38, 0x39,
+    0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e,
+    0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35,
+    0x31, 0x30, 0x33, 0x33, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x31, 0x32, 0x33, 0x39, 0x00, 0x57, 0x6f, 0x6f, 0x64,
+    0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x32, 0x33, 0x00, 0x4d,
+    0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x34, 0x31,
+    0x00, 0x45, 0x6c, 0x20, 0x50, 0x61, 0x73, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x31, 0x35, 0x00,
+    0x4c, 0x69, 0x6e, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x39, 0x31, 0x00, 0x4d,
+    0x63, 0x49, 0x6e, 0x74, 0x6f, 0x73, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x39, 0x31,
+    0x00, 0x48, 0x61, 0x6e, 0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30,
+    0x35, 0x31, 0x00, 0x48, 0x6f, 0x6c, 0x6d, 0x65, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73,
+    0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39,
+    0x31, 0x37, 0x39, 0x00, 0x57, 0x61, 0x70, 0x65, 0x6c, 0x6c, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x35,
+    0x33, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6d, 0x6f, 0x6e, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31, 0x32, 0x37, 0x00, 0x4e,
+    0x61, 0x73, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39,
+    0x30, 0x32, 0x37, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x32, 0x31,
+    0x31, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x62, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30,
+    0x30, 0x39, 0x00, 0x41, 0x76, 0x6f, 0x79, 0x65, 0x6c, 0x6c, 0x65, 0x73,
+    0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c,
+    0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x31, 0x30, 0x37, 0x00, 0x43, 0x72, 0x6f, 0x73,
+    0x62, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x30, 0x30, 0x32, 0x33, 0x00, 0x43, 0x68, 0x6f, 0x63, 0x74, 0x61,
+    0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00,
+    0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x38, 0x31, 0x35, 0x33, 0x00, 0x57, 0x61, 0x79, 0x6e,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x36, 0x30, 0x34, 0x33, 0x00, 0x46, 0x72, 0x65, 0x6d,
+    0x6f, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x33, 0x39, 0x30, 0x34, 0x35, 0x00, 0x46, 0x61, 0x69, 0x72, 0x66,
+    0x69, 0x65, 0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x30, 0x30, 0x33, 0x37, 0x00, 0x47, 0x6f, 0x6c, 0x64, 0x65,
+    0x6e, 0x20, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61,
+    0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x36, 0x30, 0x32,
+    0x33, 0x00, 0x43, 0x6f, 0x72, 0x74, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x35,
+    0x36, 0x30, 0x31, 0x33, 0x00, 0x46, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57,
+    0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x32, 0x39, 0x31, 0x37, 0x39, 0x00, 0x52, 0x65, 0x79, 0x6e, 0x6f, 0x6c,
+    0x64, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x39, 0x37, 0x00, 0x4d, 0x61, 0x72,
+    0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x33, 0x30, 0x33, 0x31, 0x00, 0x42, 0x75, 0x6c,
+    0x6c, 0x6f, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x39, 0x30, 0x31, 0x31, 0x00, 0x44, 0x61,
+    0x76, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55,
+    0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x31, 0x36, 0x30, 0x38, 0x35, 0x00, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49,
+    0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x35,
+    0x30, 0x30, 0x31, 0x00, 0x48, 0x61, 0x77, 0x61, 0x69, 0x69, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x48, 0x49, 0x00, 0x48, 0x61, 0x77,
+    0x61, 0x69, 0x69, 0x00, 0x39, 0x00, 0x2d, 0x31, 0x30, 0x00, 0x30, 0x31,
+    0x30, 0x38, 0x39, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c,
+    0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x37, 0x30, 0x36, 0x31, 0x00, 0x49, 0x74, 0x61, 0x73, 0x63, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x36, 0x30, 0x37, 0x33, 0x00, 0x4f, 0x77, 0x79, 0x68, 0x65,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00,
+    0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35,
+    0x31, 0x31, 0x36, 0x37, 0x00, 0x52, 0x75, 0x73, 0x73, 0x65, 0x6c, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x36, 0x30, 0x36, 0x39, 0x00, 0x4f, 0x6e, 0x74, 0x61, 0x72,
+    0x69, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x33, 0x30, 0x30, 0x35, 0x00, 0x42, 0x61, 0x63,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x33, 0x30, 0x36, 0x39, 0x00, 0x43, 0x6f, 0x66, 0x66,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x32, 0x30, 0x34, 0x35, 0x00, 0x47, 0x75, 0x6c, 0x66,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46,
+    0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x39, 0x30, 0x31, 0x39, 0x00, 0x42, 0x75, 0x63, 0x68, 0x61, 0x6e,
+    0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x37, 0x31, 0x30, 0x31, 0x00, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x38, 0x30, 0x36, 0x39, 0x00, 0x4c, 0x61, 0x72, 0x69, 0x6d, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43,
+    0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x32, 0x39, 0x31, 0x35, 0x37, 0x00, 0x50, 0x65, 0x72, 0x72, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d,
+    0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x31, 0x36, 0x39, 0x30, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69,
+    0x6e, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x63, 0x69, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x32, 0x31, 0x00,
+    0x4d, 0x61, 0x74, 0x61, 0x67, 0x6f, 0x72, 0x64, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x32, 0x37,
+    0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x39, 0x35,
+    0x00, 0x4c, 0x75, 0x63, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x31, 0x30, 0x39, 0x31, 0x00, 0x48, 0x6f, 0x6f,
+    0x6b, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x35, 0x36, 0x30, 0x34, 0x33, 0x00, 0x57, 0x61,
+    0x73, 0x68, 0x61, 0x6b, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x32, 0x31, 0x33, 0x33, 0x00,
+    0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f,
+    0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x36,
+    0x30, 0x34, 0x37, 0x00, 0x47, 0x6f, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64,
+    0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x31, 0x30,
+    0x32, 0x31, 0x00, 0x47, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65,
+    0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x36, 0x30,
+    0x32, 0x39, 0x00, 0x43, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53,
+    0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x31, 0x34, 0x35, 0x00, 0x57,
+    0x61, 0x67, 0x6f, 0x6e, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d,
+    0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x31, 0x31, 0x33,
+    0x00, 0x53, 0x61, 0x77, 0x79, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31,
+    0x30, 0x34, 0x39, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65,
+    0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x38, 0x32,
+    0x33, 0x33, 0x00, 0x48, 0x75, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x31, 0x37, 0x39, 0x00, 0x4e, 0x65, 0x6c, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x30, 0x30, 0x36, 0x37, 0x00, 0x50, 0x61, 0x72, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x30,
+    0x30, 0x39, 0x35, 0x00, 0x4b, 0x69, 0x6e, 0x67, 0x6d, 0x61, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31,
+    0x30, 0x33, 0x39, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x69, 0x73, 0x6c, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x31, 0x36, 0x36, 0x30, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69,
+    0x73, 0x6f, 0x6e, 0x62, 0x75, 0x72, 0x67, 0x20, 0x63, 0x69, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x34, 0x33, 0x00,
+    0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x31, 0x31, 0x34, 0x35, 0x00, 0x4d, 0x63, 0x43, 0x72, 0x61, 0x63,
+    0x6b, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x31, 0x36, 0x31, 0x00, 0x52, 0x6f,
+    0x63, 0x6b, 0x20, 0x49, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x34, 0x31, 0x39, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x62, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30, 0x31,
+    0x39, 0x00, 0x43, 0x68, 0x6f, 0x63, 0x74, 0x61, 0x77, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73,
+    0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38,
+    0x31, 0x33, 0x37, 0x00, 0x54, 0x61, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69,
+    0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30,
+    0x37, 0x37, 0x00, 0x50, 0x69, 0x63, 0x6b, 0x65, 0x6e, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31, 0x32, 0x39, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x48, 0x61, 0x6e, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x30, 0x30, 0x37, 0x00, 0x42,
+    0x61, 0x6b, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31, 0x32, 0x39, 0x00, 0x4d, 0x65,
+    0x72, 0x63, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x31, 0x35, 0x00, 0x4c,
+    0x6f, 0x75, 0x69, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x36, 0x30, 0x37, 0x31, 0x00, 0x4a, 0x61, 0x63, 0x6b,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x31, 0x30, 0x38,
+    0x39, 0x00, 0x48, 0x6f, 0x6c, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x31, 0x30, 0x39,
+    0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x39, 0x30, 0x32,
+    0x31, 0x00, 0x49, 0x72, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x32, 0x31, 0x31, 0x30, 0x37, 0x00, 0x48, 0x6f, 0x70,
+    0x6b, 0x69, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x37, 0x35, 0x00, 0x50,
+    0x6c, 0x61, 0x71, 0x75, 0x65, 0x6d, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x50,
+    0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75,
+    0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x39, 0x31, 0x30, 0x33, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00,
+    0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39,
+    0x30, 0x32, 0x33, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x31, 0x31, 0x00,
+    0x4c, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x36, 0x30, 0x35, 0x39, 0x00, 0x4f, 0x72, 0x61, 0x6e, 0x67, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43,
+    0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00,
+    0x2d, 0x38, 0x00, 0x32, 0x32, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6c, 0x6c,
+    0x65, 0x6e, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41,
+    0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30, 0x34, 0x35, 0x00, 0x43, 0x6c,
+    0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x32, 0x30, 0x34, 0x33, 0x00, 0x47, 0x6c, 0x61, 0x64,
+    0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c,
+    0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x31, 0x31, 0x35, 0x35, 0x00, 0x50, 0x75, 0x6c, 0x61,
+    0x73, 0x6b, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x36, 0x30, 0x30, 0x31, 0x00, 0x41, 0x6c,
+    0x62, 0x61, 0x6e, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x32, 0x39, 0x32, 0x32, 0x37, 0x00, 0x57, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x37, 0x33, 0x00, 0x4c, 0x69,
+    0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x30, 0x30, 0x35, 0x00,
+    0x41, 0x6c, 0x6c, 0x65, 0x67, 0x68, 0x61, 0x6e, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36,
+    0x30, 0x34, 0x39, 0x00, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38,
+    0x32, 0x32, 0x31, 0x00, 0x48, 0x6f, 0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x32, 0x35, 0x00,
+    0x4e, 0x65, 0x6c, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x30, 0x37,
+    0x00, 0x42, 0x72, 0x61, 0x64, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x30,
+    0x39, 0x39, 0x00, 0x4b, 0x65, 0x61, 0x72, 0x6e, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34,
+    0x38, 0x34, 0x32, 0x31, 0x00, 0x53, 0x68, 0x65, 0x72, 0x6d, 0x61, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x30, 0x38, 0x35, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x38,
+    0x33, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x7a, 0x75, 0x6d, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f,
+    0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x35, 0x31, 0x31, 0x36, 0x35, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x69, 0x6e,
+    0x67, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x30, 0x33, 0x00, 0x42,
+    0x65, 0x64, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65,
+    0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x31, 0x32, 0x35,
+    0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x35, 0x39, 0x30, 0x00,
+    0x44, 0x61, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x63, 0x69, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x30, 0x33,
+    0x00, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b,
+    0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x36, 0x37,
+    0x00, 0x46, 0x6f, 0x72, 0x73, 0x79, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x38, 0x35, 0x00, 0x53, 0x61, 0x6e,
+    0x74, 0x61, 0x20, 0x43, 0x6c, 0x61, 0x72, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66,
+    0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34,
+    0x38, 0x34, 0x32, 0x33, 0x00, 0x53, 0x6d, 0x69, 0x74, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39, 0x30, 0x30,
+    0x33, 0x00, 0x42, 0x6f, 0x78, 0x20, 0x45, 0x6c, 0x64, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74,
+    0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x34, 0x30,
+    0x37, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x4a, 0x61, 0x63, 0x69, 0x6e, 0x74,
+    0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x32, 0x30, 0x35, 0x35, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00,
+    0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61,
+    0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x39, 0x39, 0x00,
+    0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65,
+    0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30,
+    0x36, 0x37, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00,
+    0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x34, 0x30, 0x31, 0x33, 0x37, 0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x65,
+    0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b,
+    0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x32, 0x39, 0x00, 0x43, 0x6f, 0x6c,
+    0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x34, 0x30, 0x30, 0x39, 0x00, 0x43, 0x61, 0x6c,
+    0x76, 0x65, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x31, 0x32, 0x31, 0x00, 0x4d,
+    0x75, 0x73, 0x6b, 0x65, 0x67, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x30, 0x30, 0x30,
+    0x31, 0x00, 0x41, 0x64, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54, 0x00, 0x56, 0x65, 0x72, 0x6d,
+    0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x31,
+    0x34, 0x31, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39,
+    0x30, 0x35, 0x35, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x37, 0x30, 0x36, 0x37, 0x00,
+    0x48, 0x61, 0x6e, 0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f,
+    0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30, 0x31,
+    0x31, 0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x38, 0x33, 0x00, 0x57, 0x61,
+    0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30,
+    0x33, 0x35, 0x00, 0x43, 0x61, 0x74, 0x61, 0x77, 0x62, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31, 0x33, 0x31, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x61, 0x6d, 0x70, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x31, 0x33, 0x37, 0x00, 0x57,
+    0x61, 0x75, 0x73, 0x68, 0x61, 0x72, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35,
+    0x30, 0x38, 0x33, 0x00, 0x4c, 0x6f, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x34,
+    0x30, 0x33, 0x35, 0x00, 0x53, 0x6f, 0x6d, 0x65, 0x72, 0x73, 0x65, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00,
+    0x2d, 0x35, 0x00, 0x30, 0x36, 0x31, 0x31, 0x35, 0x00, 0x59, 0x75, 0x62,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00,
+    0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x30, 0x35, 0x30, 0x33, 0x31, 0x00, 0x43, 0x72,
+    0x61, 0x69, 0x67, 0x68, 0x65, 0x61, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x33,
+    0x33, 0x00, 0x42, 0x6f, 0x72, 0x64, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x36, 0x39, 0x00,
+    0x46, 0x72, 0x65, 0x64, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36,
+    0x30, 0x36, 0x39, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x42, 0x65, 0x6e, 0x69,
+    0x74, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41,
+    0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00,
+    0x39, 0x00, 0x2d, 0x38, 0x00, 0x35, 0x35, 0x30, 0x33, 0x33, 0x00, 0x44,
+    0x75, 0x6e, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x38, 0x33, 0x00,
+    0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39, 0x30, 0x32, 0x37,
+    0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x34, 0x30, 0x39, 0x35, 0x00, 0x54,
+    0x79, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35,
+    0x30, 0x39, 0x31, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x30, 0x35, 0x31, 0x00, 0x42, 0x75, 0x72, 0x6c, 0x65, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x33, 0x31, 0x31, 0x31, 0x00, 0x46, 0x61, 0x6e, 0x6e, 0x69, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x38, 0x32, 0x34, 0x39, 0x00, 0x4a, 0x69, 0x6d, 0x20, 0x57, 0x65, 0x6c,
+    0x6c, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x36, 0x30, 0x32, 0x35, 0x00, 0x43, 0x61, 0x6d, 0x61, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64,
+    0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x31, 0x30,
+    0x32, 0x31, 0x00, 0x42, 0x75, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x34,
+    0x37, 0x00, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65, 0x20, 0x45, 0x64, 0x77,
+    0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x33, 0x30, 0x31, 0x35, 0x00, 0x43, 0x6f,
+    0x77, 0x6c, 0x69, 0x74, 0x7a, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x33, 0x30,
+    0x30, 0x37, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x45, 0x00, 0x4d, 0x61,
+    0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31,
+    0x37, 0x37, 0x00, 0x56, 0x61, 0x6e, 0x20, 0x42, 0x75, 0x72, 0x65, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49,
+    0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x32, 0x30,
+    0x39, 0x30, 0x00, 0x46, 0x61, 0x69, 0x72, 0x62, 0x61, 0x6e, 0x6b, 0x73,
+    0x20, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x53, 0x74, 0x61, 0x72, 0x20,
+    0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x41, 0x4b, 0x00, 0x41,
+    0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x33,
+    0x39, 0x31, 0x36, 0x31, 0x00, 0x56, 0x61, 0x6e, 0x20, 0x57, 0x65, 0x72,
+    0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00,
+    0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34,
+    0x30, 0x36, 0x33, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73,
+    0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x33, 0x30, 0x30, 0x35, 0x00, 0x42, 0x65,
+    0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x34, 0x30, 0x32,
+    0x33, 0x00, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x73, 0x65, 0x78, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x35, 0x30, 0x30, 0x39, 0x00, 0x45, 0x73, 0x73, 0x65,
+    0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x41, 0x00,
+    0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68, 0x75, 0x73, 0x65, 0x74, 0x74,
+    0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x32, 0x35,
+    0x00, 0x4d, 0x65, 0x64, 0x69, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x35, 0x35, 0x00, 0x53,
+    0x70, 0x61, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x35, 0x30, 0x32, 0x39,
+    0x00, 0x4c, 0x75, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69,
+    0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x37, 0x35,
+    0x30, 0x00, 0x52, 0x61, 0x64, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x63, 0x69,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x33,
+    0x31, 0x00, 0x43, 0x6f, 0x6f, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x30, 0x35,
+    0x35, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72,
+    0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36,
+    0x30, 0x38, 0x39, 0x00, 0x53, 0x68, 0x61, 0x73, 0x74, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c,
+    0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x30, 0x35, 0x31, 0x30, 0x33, 0x00, 0x4f, 0x75, 0x61, 0x63, 0x68,
+    0x69, 0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x31, 0x37, 0x00, 0x43, 0x68,
+    0x65, 0x6e, 0x61, 0x6e, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72,
+    0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x34, 0x30, 0x31, 0x35,
+    0x00, 0x47, 0x6c, 0x6f, 0x75, 0x63, 0x65, 0x73, 0x74, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x37, 0x30, 0x37, 0x31, 0x00, 0x4b, 0x6f, 0x6f, 0x63,
+    0x68, 0x69, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30,
+    0x37, 0x35, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6e, 0x65, 0x74, 0x74, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57,
+    0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x33, 0x37, 0x00, 0x42, 0x6f, 0x77,
+    0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x36, 0x30, 0x34, 0x31, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x30, 0x39, 0x00, 0x42, 0x61, 0x72,
+    0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x39, 0x30, 0x33, 0x37, 0x00, 0x53, 0x61, 0x6e,
+    0x20, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x33, 0x37, 0x30, 0x30, 0x37, 0x00, 0x41, 0x6e, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x31,
+    0x35, 0x00, 0x42, 0x72, 0x75, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x33, 0x30, 0x32, 0x33, 0x00, 0x53, 0x61, 0x67, 0x61, 0x64, 0x61,
+    0x68, 0x6f, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x38, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x65,
+    0x77, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x37, 0x31, 0x32, 0x37, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x31, 0x31, 0x34, 0x37, 0x00, 0x4d, 0x63, 0x43, 0x72, 0x65,
+    0x61, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x39, 0x33, 0x00, 0x48, 0x61,
+    0x6d, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x34, 0x30, 0x31, 0x39, 0x00, 0x44, 0x6f,
+    0x72, 0x63, 0x68, 0x65, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c,
+    0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x30,
+    0x32, 0x37, 0x00, 0x43, 0x65, 0x64, 0x61, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30,
+    0x36, 0x35, 0x00, 0x4d, 0x63, 0x43, 0x6f, 0x72, 0x6d, 0x69, 0x63, 0x6b,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53,
+    0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x30, 0x39, 0x33,
+    0x00, 0x44, 0x6f, 0x6f, 0x6c, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x34, 0x35, 0x00,
+    0x4c, 0x6f, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x32, 0x30, 0x35, 0x37, 0x00, 0x46, 0x75, 0x6c, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65,
+    0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x37, 0x31, 0x00, 0x57, 0x69,
+    0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x30, 0x37, 0x00, 0x41, 0x75, 0x64,
+    0x72, 0x61, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x31, 0x32, 0x33, 0x00, 0x59,
+    0x61, 0x74, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x38, 0x35, 0x00, 0x4d,
+    0x63, 0x4c, 0x65, 0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x35, 0x37, 0x30,
+    0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x6e, 0x69, 0x61, 0x6c, 0x20, 0x48, 0x65,
+    0x69, 0x67, 0x68, 0x74, 0x73, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x34, 0x30, 0x31, 0x33, 0x00, 0x4d, 0x61,
+    0x72, 0x69, 0x63, 0x6f, 0x70, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x36, 0x30, 0x31, 0x33, 0x00,
+    0x42, 0x6c, 0x61, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x30, 0x38, 0x30, 0x34, 0x33, 0x00, 0x46, 0x72,
+    0x65, 0x6d, 0x6f, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x32, 0x30, 0x37, 0x37, 0x00,
+    0x4c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38, 0x31, 0x32, 0x35,
+    0x00, 0x59, 0x75, 0x6d, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x32, 0x30, 0x37, 0x37, 0x00,
+    0x4c, 0x65, 0x68, 0x69, 0x67, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c,
+    0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x30,
+    0x38, 0x30, 0x37, 0x31, 0x00, 0x4c, 0x61, 0x73, 0x20, 0x41, 0x6e, 0x69,
+    0x6d, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x32, 0x38, 0x30, 0x36, 0x33, 0x00, 0x4a, 0x65,
+    0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70,
+    0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x38, 0x30,
+    0x30, 0x00, 0x53, 0x75, 0x66, 0x66, 0x6f, 0x6c, 0x6b, 0x20, 0x63, 0x69,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x31, 0x31,
+    0x31, 0x00, 0x53, 0x6f, 0x6d, 0x65, 0x72, 0x73, 0x65, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x30, 0x33, 0x35, 0x00, 0x42, 0x6f, 0x73,
+    0x71, 0x75, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x39, 0x30, 0x33, 0x31, 0x00, 0x43, 0x61, 0x70, 0x65, 0x20,
+    0x47, 0x69, 0x72, 0x61, 0x72, 0x64, 0x65, 0x61, 0x75, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38,
+    0x31, 0x36, 0x33, 0x00, 0x56, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x62, 0x75,
+    0x72, 0x67, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x34, 0x39, 0x00, 0x43, 0x6c, 0x61,
+    0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59,
+    0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x32, 0x37, 0x00, 0x42, 0x65, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x32, 0x30, 0x36, 0x30, 0x00, 0x42, 0x72, 0x69, 0x73, 0x74, 0x6f, 0x6c,
+    0x20, 0x42, 0x61, 0x79, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68,
+    0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x39, 0x00, 0x31, 0x38, 0x31, 0x31, 0x31, 0x00, 0x4e, 0x65,
+    0x77, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x35, 0x30, 0x30, 0x31, 0x00, 0x42, 0x65,
+    0x72, 0x6e, 0x61, 0x6c, 0x69, 0x6c, 0x6c, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d,
+    0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35,
+    0x35, 0x30, 0x39, 0x35, 0x00, 0x50, 0x6f, 0x6c, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x35, 0x30, 0x31, 0x35, 0x00, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68,
+    0x69, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68, 0x75, 0x73, 0x65,
+    0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x30,
+    0x33, 0x37, 0x00, 0x43, 0x72, 0x65, 0x65, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30,
+    0x32, 0x31, 0x00, 0x47, 0x69, 0x6c, 0x6d, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74,
+    0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x32, 0x39, 0x00, 0x46, 0x6c, 0x61,
+    0x74, 0x68, 0x65, 0x61, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x31, 0x31, 0x33, 0x00, 0x4d,
+    0x69, 0x73, 0x73, 0x61, 0x75, 0x6b, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69,
+    0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31,
+    0x36, 0x33, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x35, 0x39, 0x00, 0x48,
+    0x69, 0x6c, 0x6c, 0x73, 0x64, 0x61, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69,
+    0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x30,
+    0x37, 0x35, 0x00, 0x47, 0x72, 0x75, 0x6e, 0x64, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x35, 0x33, 0x00,
+    0x53, 0x75, 0x6d, 0x6d, 0x69, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x31, 0x31, 0x38, 0x33, 0x00, 0x53, 0x75, 0x73,
+    0x73, 0x65, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x32, 0x39, 0x00, 0x42, 0x75,
+    0x63, 0x6b, 0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x33, 0x30,
+    0x32, 0x31, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61,
+    0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00,
+    0x2d, 0x38, 0x00, 0x33, 0x37, 0x31, 0x31, 0x31, 0x00, 0x4d, 0x63, 0x44,
+    0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x37, 0x30, 0x31, 0x31, 0x00, 0x42, 0x72, 0x61, 0x64, 0x6c, 0x65,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x31, 0x30, 0x32, 0x37, 0x00, 0x42, 0x72, 0x65, 0x63,
+    0x6b, 0x69, 0x6e, 0x72, 0x69, 0x64, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30,
+    0x33, 0x39, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x69, 0x74, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33,
+    0x30, 0x30, 0x39, 0x00, 0x42, 0x61, 0x6c, 0x64, 0x77, 0x69, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x33, 0x31, 0x30, 0x31, 0x00, 0x45, 0x63, 0x68, 0x6f, 0x6c, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x31, 0x30, 0x36, 0x33, 0x00, 0x45, 0x6c, 0x6c, 0x69, 0x6f, 0x74, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x37, 0x31, 0x32, 0x37, 0x00, 0x52, 0x65, 0x64, 0x77, 0x6f,
+    0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x37, 0x37, 0x00, 0x50, 0x6f,
+    0x77, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x30, 0x30, 0x34, 0x37, 0x00, 0x47, 0x61,
+    0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d,
+    0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x36, 0x30, 0x32, 0x33,
+    0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69,
+    0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x39, 0x30, 0x33,
+    0x37, 0x00, 0x43, 0x61, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x30, 0x38, 0x31,
+    0x00, 0x4c, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x36, 0x30, 0x33, 0x33, 0x00, 0x4c, 0x61,
+    0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41,
+    0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00,
+    0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x33, 0x30, 0x32, 0x31, 0x00, 0x42,
+    0x69, 0x62, 0x62, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x35, 0x31, 0x00, 0x53, 0x77, 0x69,
+    0x66, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x34, 0x39, 0x00, 0x45, 0x6c,
+    0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x32, 0x31, 0x30, 0x39, 0x00, 0x53, 0x6e, 0x79, 0x64, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x31, 0x31, 0x35, 0x00, 0x53,
+    0x70, 0x69, 0x6e, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x30, 0x30,
+    0x31, 0x35, 0x00, 0x42, 0x75, 0x74, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36, 0x30, 0x38,
+    0x31, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x4d, 0x61, 0x74, 0x65, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61,
+    0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x39, 0x30, 0x35, 0x31, 0x00, 0x57, 0x61, 0x73, 0x61,
+    0x74, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55,
+    0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x31, 0x36, 0x30, 0x36, 0x31, 0x00, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64,
+    0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x38, 0x31,
+    0x37, 0x33, 0x00, 0x57, 0x61, 0x72, 0x72, 0x69, 0x63, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36,
+    0x30, 0x31, 0x39, 0x00, 0x43, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x30, 0x31, 0x35, 0x35, 0x00, 0x52, 0x65, 0x6e, 0x6f, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30,
+    0x30, 0x37, 0x00, 0x42, 0x61, 0x72, 0x62, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x34,
+    0x39, 0x00, 0x43, 0x72, 0x61, 0x76, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x33, 0x30, 0x31, 0x35, 0x00, 0x4c, 0x69, 0x6e,
+    0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x38, 0x30, 0x35, 0x39, 0x00, 0x48, 0x61, 0x6e, 0x63,
+    0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x36, 0x35, 0x00, 0x48, 0x61, 0x72,
+    0x64, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x37, 0x30, 0x31, 0x37, 0x00, 0x43, 0x61, 0x73, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x39, 0x32, 0x30, 0x37, 0x00, 0x53, 0x74, 0x6f, 0x64, 0x64, 0x61, 0x72,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00,
+    0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x36, 0x30, 0x30, 0x37, 0x00, 0x42, 0x65, 0x6e, 0x6e,
+    0x65, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x31,
+    0x37, 0x00, 0x4c, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d,
+    0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x33, 0x32, 0x36, 0x31, 0x00, 0x53, 0x75, 0x6d, 0x74, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x30, 0x30, 0x34, 0x39, 0x00, 0x47, 0x61, 0x72, 0x76, 0x69,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00,
+    0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x32, 0x30, 0x31, 0x35, 0x00, 0x4c, 0x61, 0x6e, 0x64,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56,
+    0x00, 0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38,
+    0x00, 0x33, 0x36, 0x30, 0x39, 0x33, 0x00, 0x53, 0x63, 0x68, 0x65, 0x6e,
+    0x65, 0x63, 0x74, 0x61, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72,
+    0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x32, 0x37,
+    0x00, 0x44, 0x65, 0x53, 0x6f, 0x74, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x30, 0x35, 0x39,
+    0x00, 0x43, 0x61, 0x6c, 0x6c, 0x61, 0x68, 0x61, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x30, 0x31,
+    0x00, 0x52, 0x75, 0x73, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x37, 0x33, 0x00, 0x48, 0x61, 0x77,
+    0x6b, 0x69, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x35, 0x39, 0x00, 0x4d,
+    0x65, 0x61, 0x67, 0x68, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x35, 0x30, 0x39, 0x39, 0x00,
+    0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x35, 0x35,
+    0x00, 0x43, 0x68, 0x61, 0x74, 0x74, 0x6f, 0x6f, 0x67, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38,
+    0x30, 0x30, 0x37, 0x00, 0x42, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37,
+    0x31, 0x32, 0x35, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65,
+    0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e,
+    0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x36, 0x31, 0x30, 0x31, 0x00, 0x53, 0x74, 0x65,
+    0x75, 0x62, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x34, 0x30, 0x30, 0x33, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x52,
+    0x49, 0x00, 0x52, 0x68, 0x6f, 0x64, 0x65, 0x20, 0x49, 0x73, 0x6c, 0x61,
+    0x6e, 0x64, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x31, 0x33,
+    0x37, 0x00, 0x52, 0x69, 0x70, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x30, 0x30,
+    0x31, 0x00, 0x41, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39, 0x30, 0x31,
+    0x39, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x33, 0x32, 0x30, 0x33, 0x33, 0x00, 0x57, 0x68,
+    0x69, 0x74, 0x65, 0x20, 0x50, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00, 0x4e, 0x65, 0x76, 0x61, 0x64,
+    0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x39, 0x31, 0x34, 0x37,
+    0x00, 0x50, 0x61, 0x6c, 0x6f, 0x20, 0x41, 0x6c, 0x74, 0x6f, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x33, 0x30, 0x31, 0x37,
+    0x00, 0x4f, 0x78, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00,
+    0x30, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x34, 0x37, 0x00, 0x46,
+    0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x34,
+    0x31, 0x00, 0x43, 0x68, 0x6f, 0x77, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x35, 0x30, 0x37, 0x39, 0x00, 0x4d, 0x69, 0x6c,
+    0x77, 0x61, 0x75, 0x6b, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x36, 0x30,
+    0x33, 0x35, 0x00, 0x53, 0x75, 0x62, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79,
+    0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32,
+    0x39, 0x31, 0x38, 0x31, 0x00, 0x52, 0x69, 0x70, 0x6c, 0x65, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x30, 0x30, 0x34, 0x35, 0x00, 0x4a, 0x75, 0x64, 0x69, 0x74, 0x68,
+    0x20, 0x42, 0x61, 0x73, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x31, 0x30, 0x34, 0x31, 0x00,
+    0x43, 0x72, 0x65, 0x6e, 0x73, 0x68, 0x61, 0x77, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36, 0x31, 0x30,
+    0x35, 0x00, 0x54, 0x72, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69,
+    0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x30, 0x31, 0x31, 0x30, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f,
+    0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x36, 0x39, 0x00, 0x50, 0x75,
+    0x6c, 0x61, 0x73, 0x6b, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x37, 0x33, 0x00,
+    0x4b, 0x69, 0x6e, 0x67, 0x66, 0x69, 0x73, 0x68, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c,
+    0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x39, 0x30, 0x39, 0x35, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x31, 0x34, 0x35, 0x00,
+    0x57, 0x68, 0x69, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x37, 0x35, 0x00,
+    0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x36,
+    0x35, 0x00, 0x4a, 0x65, 0x6e, 0x6b, 0x69, 0x6e, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x34, 0x30,
+    0x32, 0x35, 0x00, 0x48, 0x61, 0x72, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72,
+    0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x37, 0x30, 0x34, 0x33, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x38, 0x31, 0x32, 0x37, 0x00, 0x53, 0x69, 0x6d, 0x70, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53,
+    0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x30, 0x31, 0x00, 0x41, 0x69, 0x74,
+    0x6b, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x34, 0x30, 0x30, 0x39, 0x00, 0x47,
+    0x72, 0x61, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x37, 0x30, 0x34, 0x39, 0x00, 0x45,
+    0x66, 0x66, 0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e,
+    0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x35, 0x30,
+    0x33, 0x35, 0x00, 0x4f, 0x74, 0x65, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d,
+    0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35,
+    0x33, 0x30, 0x33, 0x33, 0x00, 0x4b, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x32, 0x39, 0x31, 0x33, 0x39, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67,
+    0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x35, 0x35, 0x30, 0x00,
+    0x43, 0x68, 0x65, 0x73, 0x61, 0x70, 0x65, 0x61, 0x6b, 0x65, 0x20, 0x63,
+    0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34,
+    0x35, 0x39, 0x00, 0x55, 0x70, 0x73, 0x68, 0x75, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x31, 0x31, 0x33,
+    0x00, 0x50, 0x6f, 0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x32, 0x32, 0x37, 0x30, 0x00,
+    0x57, 0x61, 0x64, 0x65, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x20, 0x41, 0x72, 0x65, 0x61,
+    0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x39, 0x00, 0x31, 0x39, 0x30, 0x30, 0x35, 0x00, 0x41, 0x6c,
+    0x6c, 0x61, 0x6d, 0x61, 0x6b, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x33, 0x39, 0x00, 0x44, 0x65,
+    0x63, 0x61, 0x74, 0x75, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x31, 0x32, 0x35, 0x00, 0x56, 0x69,
+    0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x37, 0x30, 0x30, 0x00,
+    0x4e, 0x65, 0x77, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x4e, 0x65, 0x77, 0x73,
+    0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x38, 0x31, 0x32, 0x39, 0x00, 0x53, 0x6d, 0x69, 0x74, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x37, 0x31, 0x36, 0x39, 0x00, 0x53, 0x63, 0x68, 0x75, 0x79, 0x6c, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00,
+    0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x39, 0x30, 0x35, 0x33, 0x00, 0x43, 0x6f, 0x6f, 0x70,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x30, 0x35, 0x00, 0x42, 0x61, 0x72,
+    0x74, 0x68, 0x6f, 0x6c, 0x6f, 0x6d, 0x65, 0x77, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x35,
+    0x37, 0x00, 0x4f, 0x63, 0x68, 0x69, 0x6c, 0x74, 0x72, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31,
+    0x33, 0x33, 0x00, 0x4e, 0x65, 0x6f, 0x73, 0x68, 0x6f, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x38,
+    0x37, 0x00, 0x4c, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x30, 0x35, 0x30, 0x37, 0x37, 0x00, 0x4c, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41,
+    0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x35, 0x30, 0x31, 0x31, 0x00, 0x44, 0x65, 0x42, 0x61, 0x63,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x35, 0x30, 0x33, 0x35, 0x00, 0x44, 0x6f,
+    0x72, 0x63, 0x68, 0x65, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x37, 0x33, 0x00, 0x50, 0x6f, 0x6c,
+    0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x33, 0x30, 0x30, 0x37, 0x00, 0x43, 0x6f, 0x6f, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x48, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x48, 0x61, 0x6d, 0x70, 0x73, 0x68, 0x69, 0x72, 0x65, 0x00, 0x30, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x33, 0x31, 0x00, 0x43, 0x61, 0x72,
+    0x74, 0x65, 0x72, 0x65, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x34, 0x30, 0x37, 0x35, 0x00, 0x50, 0x6f, 0x63, 0x61, 0x68, 0x6f,
+    0x6e, 0x74, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x36,
+    0x30, 0x32, 0x37, 0x00, 0x43, 0x61, 0x6e, 0x79, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61,
+    0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x31, 0x30, 0x33,
+    0x39, 0x00, 0x43, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c,
+    0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x39, 0x30, 0x34, 0x31, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x30, 0x33, 0x33, 0x00,
+    0x43, 0x6f, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x37, 0x31,
+    0x00, 0x4b, 0x69, 0x6e, 0x6e, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x35, 0x33, 0x00, 0x4d,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33,
+    0x30, 0x37, 0x37, 0x00, 0x43, 0x6f, 0x77, 0x65, 0x74, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38,
+    0x30, 0x33, 0x35, 0x00, 0x44, 0x65, 0x6c, 0x61, 0x77, 0x61, 0x72, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49,
+    0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x34, 0x30, 0x31, 0x37, 0x00, 0x44, 0x6f, 0x64, 0x64, 0x72, 0x69,
+    0x64, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x34, 0x30,
+    0x31, 0x31, 0x00, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61,
+    0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x39, 0x31, 0x39, 0x39, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x6c, 0x61,
+    0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x37, 0x35, 0x00, 0x47, 0x6f, 0x6f,
+    0x63, 0x68, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x30, 0x35,
+    0x00, 0x42, 0x61, 0x72, 0x62, 0x6f, 0x75, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x38,
+    0x39, 0x00, 0x4d, 0x63, 0x44, 0x75, 0x66, 0x66, 0x69, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31,
+    0x30, 0x35, 0x35, 0x00, 0x45, 0x74, 0x6f, 0x77, 0x61, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61,
+    0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30,
+    0x31, 0x37, 0x35, 0x00, 0x53, 0x65, 0x77, 0x61, 0x72, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x35,
+    0x30, 0x31, 0x00, 0x59, 0x6f, 0x61, 0x6b, 0x75, 0x6d, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30, 0x33, 0x39,
+    0x00, 0x44, 0x61, 0x6c, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x38,
+    0x31, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x38, 0x31, 0x30, 0x35, 0x00, 0x4f, 0x6b, 0x74, 0x69, 0x62, 0x62, 0x65,
+    0x68, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53,
+    0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x30, 0x37, 0x00, 0x43, 0x61, 0x6d,
+    0x64, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x34, 0x37, 0x00,
+    0x53, 0x74, 0x65, 0x65, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x32,
+    0x39, 0x00, 0x44, 0x6f, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30,
+    0x37, 0x33, 0x00, 0x4a, 0x61, 0x73, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x31,
+    0x35, 0x35, 0x00, 0x57, 0x65, 0x62, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x33, 0x30, 0x31, 0x39, 0x00, 0x50, 0x65, 0x6e, 0x6f, 0x62, 0x73, 0x63,
+    0x6f, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x45,
+    0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x33, 0x31, 0x39, 0x39, 0x00, 0x4d, 0x65, 0x72, 0x69, 0x77, 0x65,
+    0x74, 0x68, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x39, 0x31, 0x00, 0x48, 0x65,
+    0x72, 0x74, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43,
+    0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x32, 0x31, 0x35, 0x30, 0x00, 0x4b, 0x6f, 0x64, 0x69, 0x61,
+    0x6b, 0x20, 0x49, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x42, 0x6f, 0x72,
+    0x6f, 0x75, 0x67, 0x68, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x34, 0x38, 0x35, 0x30,
+    0x33, 0x00, 0x59, 0x6f, 0x75, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x38, 0x37, 0x00, 0x4a,
+    0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65,
+    0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31, 0x33, 0x31,
+    0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x36,
+    0x31, 0x00, 0x52, 0x69, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x31, 0x30, 0x35, 0x00,
+    0x50, 0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30, 0x30, 0x37, 0x00, 0x43,
+    0x6c, 0x61, 0x74, 0x73, 0x6f, 0x70, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00,
+    0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x36, 0x30, 0x31, 0x33, 0x00, 0x43,
+    0x68, 0x61, 0x75, 0x74, 0x61, 0x75, 0x71, 0x75, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38,
+    0x31, 0x36, 0x37, 0x00, 0x56, 0x69, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x39, 0x30, 0x30,
+    0x39, 0x00, 0x44, 0x61, 0x67, 0x67, 0x65, 0x74, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x39, 0x30, 0x38, 0x33, 0x00,
+    0x48, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x36, 0x31, 0x33, 0x31, 0x00, 0x4f, 0x6e, 0x74,
+    0x6f, 0x6e, 0x61, 0x67, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30, 0x31, 0x33,
+    0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x32, 0x35, 0x00, 0x48,
+    0x6f, 0x75, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x32, 0x31, 0x00, 0x42, 0x75,
+    0x63, 0x68, 0x61, 0x6e, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x36, 0x39,
+    0x00, 0x50, 0x61, 0x72, 0x6d, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x30, 0x39, 0x35, 0x00, 0x4a,
+    0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x34, 0x30,
+    0x33, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00,
+    0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x31, 0x31, 0x33, 0x33, 0x00, 0x50, 0x61, 0x77, 0x6e,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45,
+    0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00,
+    0x2d, 0x37, 0x00, 0x31, 0x37, 0x30, 0x38, 0x31, 0x00, 0x4a, 0x65, 0x66,
+    0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x30, 0x34, 0x39,
+    0x00, 0x45, 0x72, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76,
+    0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x34,
+    0x30, 0x31, 0x33, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61,
+    0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x38, 0x32, 0x35, 0x37, 0x00, 0x4b, 0x61, 0x75, 0x66, 0x6d, 0x61,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x33, 0x39, 0x31, 0x00, 0x52, 0x65, 0x66, 0x75, 0x67, 0x69, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38,
+    0x31, 0x33, 0x33, 0x00, 0x53, 0x75, 0x6e, 0x66, 0x6c, 0x6f, 0x77, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x31, 0x31, 0x37, 0x37, 0x00, 0x4d, 0x75, 0x68, 0x6c,
+    0x65, 0x6e, 0x62, 0x65, 0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b,
+    0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x31, 0x32, 0x35,
+    0x00, 0x4f, 0x61, 0x6b, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69,
+    0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x31, 0x30,
+    0x32, 0x39, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65,
+    0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x37, 0x30,
+    0x36, 0x39, 0x00, 0x48, 0x61, 0x72, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65,
+    0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x34, 0x30, 0x39, 0x39, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65,
+    0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31, 0x30, 0x35, 0x00, 0x4c,
+    0x6f, 0x75, 0x64, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x32, 0x35, 0x00,
+    0x47, 0x72, 0x65, 0x65, 0x6e, 0x62, 0x72, 0x69, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73,
+    0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x30, 0x31, 0x00, 0x42, 0x61,
+    0x72, 0x62, 0x6f, 0x75, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x32, 0x30, 0x34, 0x37, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00,
+    0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x30, 0x30, 0x38, 0x39, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x65,
+    0x72, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54,
+    0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x37, 0x00, 0x32, 0x38, 0x30, 0x33, 0x33, 0x00, 0x44, 0x65, 0x53, 0x6f,
+    0x74, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53,
+    0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x39, 0x35, 0x00, 0x57, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x30, 0x31, 0x32, 0x37, 0x00, 0x50, 0x75, 0x73, 0x68, 0x6d, 0x61, 0x74,
+    0x61, 0x68, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x31, 0x31, 0x00, 0x42, 0x6f,
+    0x77, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30,
+    0x38, 0x31, 0x00, 0x4c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x20, 0x52, 0x69,
+    0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x33, 0x35, 0x00, 0x42, 0x75,
+    0x74, 0x74, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x35, 0x33, 0x00, 0x43, 0x75, 0x72,
+    0x72, 0x69, 0x74, 0x75, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43,
+    0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x39, 0x30, 0x35, 0x37, 0x00, 0x44, 0x65, 0x73, 0x20, 0x4d,
+    0x6f, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x32, 0x35, 0x31, 0x00, 0x4a, 0x6f, 0x68, 0x6e,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x34, 0x30, 0x38, 0x39, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x35,
+    0x33, 0x00, 0x46, 0x6c, 0x6f, 0x79, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x31, 0x35, 0x00, 0x4d,
+    0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43,
+    0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x38, 0x30, 0x34, 0x31, 0x00, 0x46, 0x61, 0x79, 0x65, 0x74,
+    0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e,
+    0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x31, 0x30, 0x31, 0x39, 0x00, 0x42, 0x6f, 0x79, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x31, 0x37, 0x33, 0x00, 0x47, 0x6c, 0x61, 0x73, 0x73,
+    0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x37, 0x30, 0x38, 0x39, 0x00, 0x4b, 0x61, 0x6e, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x34, 0x30, 0x33, 0x39, 0x00, 0x4b, 0x61, 0x6e, 0x61, 0x77,
+    0x68, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x36,
+    0x35, 0x00, 0x54, 0x61, 0x6c, 0x69, 0x61, 0x66, 0x65, 0x72, 0x72, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x34, 0x30, 0x32, 0x37, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x69, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x31, 0x31, 0x30, 0x35, 0x00, 0x4c, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x30, 0x30, 0x37, 0x39, 0x00, 0x4c, 0x65, 0x20, 0x46, 0x6c,
+    0x6f, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30, 0x36, 0x33, 0x00, 0x45, 0x6d,
+    0x6d, 0x65, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x34, 0x34, 0x39, 0x00, 0x54, 0x69, 0x74, 0x75, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x30,
+    0x36, 0x39, 0x00, 0x46, 0x6c, 0x65, 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x38, 0x30, 0x31, 0x37, 0x00, 0x43, 0x61, 0x73, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x35, 0x30,
+    0x35, 0x33, 0x00, 0x53, 0x6f, 0x63, 0x6f, 0x72, 0x72, 0x6f, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x30, 0x38, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43,
+    0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x33, 0x33, 0x30, 0x31, 0x39, 0x00, 0x53, 0x75, 0x6c, 0x6c, 0x69,
+    0x76, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x48, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68,
+    0x69, 0x72, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x30,
+    0x33, 0x39, 0x00, 0x43, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61,
+    0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31,
+    0x30, 0x38, 0x31, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x73, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x32, 0x32, 0x33, 0x00, 0x48, 0x6f,
+    0x70, 0x6b, 0x69, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x31, 0x31, 0x00, 0x42, 0x6c, 0x61,
+    0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x33, 0x33, 0x00, 0x46, 0x72,
+    0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72,
+    0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x33, 0x39,
+    0x00, 0x44, 0x65, 0x63, 0x61, 0x74, 0x75, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65,
+    0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x31,
+    0x32, 0x37, 0x00, 0x57, 0x61, 0x6c, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69,
+    0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x32, 0x31, 0x37, 0x00, 0x48, 0x69, 0x6c, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33,
+    0x33, 0x32, 0x31, 0x00, 0x57, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x32,
+    0x30, 0x31, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x37, 0x31, 0x34, 0x31, 0x00, 0x50, 0x75, 0x74, 0x6e, 0x61,
+    0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x31, 0x32, 0x31, 0x33, 0x00, 0x53, 0x69, 0x6d, 0x70,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x31, 0x30, 0x39, 0x00, 0x4f, 0x6b,
+    0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d,
+    0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x34, 0x30, 0x33, 0x35,
+    0x00, 0x51, 0x75, 0x65, 0x65, 0x6e, 0x20, 0x41, 0x6e, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61,
+    0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x37, 0x32, 0x30, 0x33, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x66, 0x6f,
+    0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x32, 0x37, 0x00, 0x4d, 0x61, 0x72,
+    0x73, 0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x35, 0x30, 0x30, 0x39, 0x00, 0x43, 0x75, 0x72, 0x72,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x32, 0x31, 0x30, 0x30, 0x39, 0x00, 0x42, 0x61,
+    0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x32, 0x32, 0x39, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33,
+    0x31, 0x38, 0x33, 0x00, 0x4c, 0x6f, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x31,
+    0x33, 0x00, 0x42, 0x69, 0x65, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20,
+    0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f,
+    0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x31, 0x31, 0x31, 0x37, 0x00, 0x4d, 0x63, 0x50, 0x68, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x36, 0x30, 0x35, 0x35, 0x00, 0x48,
+    0x61, 0x61, 0x6b, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x36,
+    0x30, 0x30, 0x35, 0x00, 0x42, 0x61, 0x6e, 0x6e, 0x6f, 0x63, 0x6b, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64,
+    0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x34, 0x30,
+    0x31, 0x37, 0x00, 0x4e, 0x61, 0x76, 0x61, 0x6a, 0x6f, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69, 0x7a,
+    0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x37, 0x30,
+    0x35, 0x35, 0x00, 0x44, 0x61, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x38, 0x30, 0x36, 0x37, 0x00, 0x43, 0x61, 0x73, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37,
+    0x30, 0x32, 0x33, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35,
+    0x30, 0x37, 0x31, 0x00, 0x4d, 0x61, 0x6e, 0x69, 0x74, 0x6f, 0x77, 0x6f,
+    0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00,
+    0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x36, 0x35, 0x00, 0x4d, 0x61,
+    0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x33, 0x31, 0x31, 0x35, 0x35, 0x00, 0x53, 0x61, 0x75,
+    0x6e, 0x64, 0x65, 0x72, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x35, 0x30, 0x33, 0x39, 0x00,
+    0x52, 0x69, 0x6f, 0x20, 0x41, 0x72, 0x72, 0x69, 0x62, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x30, 0x31, 0x31, 0x32, 0x35, 0x00, 0x54, 0x75, 0x73, 0x63, 0x61,
+    0x6c, 0x6f, 0x6f, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x31, 0x39, 0x00, 0x42,
+    0x6f, 0x6e, 0x6e, 0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x35, 0x31, 0x32, 0x39,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x62, 0x75, 0x72, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x36, 0x30, 0x33, 0x33, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64,
+    0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x37, 0x31,
+    0x31, 0x35, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37,
+    0x31, 0x39, 0x35, 0x00, 0x57, 0x69, 0x6c, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x36, 0x31, 0x00, 0x4d,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x35, 0x31, 0x00, 0x4c,
+    0x69, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33,
+    0x30, 0x36, 0x31, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x39,
+    0x31, 0x00, 0x53, 0x75, 0x6d, 0x6e, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x34, 0x33,
+    0x00, 0x4f, 0x74, 0x74, 0x61, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x32, 0x37, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x4b, 0x65, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x30,
+    0x37, 0x31, 0x00, 0x46, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30, 0x35, 0x39,
+    0x00, 0x4c, 0x61, 0x75, 0x72, 0x65, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x31, 0x37, 0x00, 0x4d, 0x61, 0x72,
+    0x73, 0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x36, 0x30, 0x32, 0x35, 0x00, 0x49, 0x6d,
+    0x70, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x37, 0x30,
+    0x34, 0x39, 0x00, 0x47, 0x6f, 0x6f, 0x64, 0x68, 0x75, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x31, 0x31, 0x30, 0x35, 0x00, 0x4b, 0x69, 0x6d, 0x62, 0x61, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00,
+    0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x30, 0x30, 0x34, 0x33, 0x00, 0x44, 0x65, 0x77, 0x65,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00,
+    0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x39, 0x30, 0x38, 0x37, 0x00, 0x48, 0x6f, 0x6c, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d,
+    0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x33, 0x31, 0x35, 0x39, 0x00, 0x4a, 0x61, 0x73, 0x70, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x38, 0x31, 0x30, 0x35, 0x00, 0x43, 0x72, 0x6f, 0x63, 0x6b,
+    0x65, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x34, 0x30, 0x34, 0x37, 0x00, 0x4d, 0x63, 0x44, 0x6f, 0x77,
+    0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34,
+    0x33, 0x37, 0x00, 0x53, 0x77, 0x69, 0x73, 0x68, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x38,
+    0x39, 0x00, 0x53, 0x74, 0x61, 0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x36, 0x30, 0x35, 0x31, 0x00, 0x47, 0x6c, 0x61, 0x64, 0x77, 0x69,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00,
+    0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x30, 0x30, 0x32, 0x37, 0x00, 0x57, 0x69, 0x6e, 0x64,
+    0x73, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x54, 0x00, 0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x36, 0x31, 0x31, 0x39, 0x00, 0x53, 0x75, 0x6c,
+    0x6c, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x31, 0x31, 0x30, 0x39,
+    0x00, 0x50, 0x69, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x30, 0x35, 0x39, 0x00, 0x48,
+    0x6f, 0x6c, 0x6d, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31, 0x34, 0x35, 0x00, 0x4e,
+    0x65, 0x77, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x36, 0x37, 0x00,
+    0x53, 0x74, 0x61, 0x6e, 0x6c, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43,
+    0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x33, 0x30, 0x32, 0x37, 0x00, 0x47, 0x72, 0x61, 0x79, 0x73,
+    0x20, 0x48, 0x61, 0x72, 0x62, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32,
+    0x34, 0x30, 0x32, 0x33, 0x00, 0x47, 0x61, 0x72, 0x72, 0x65, 0x74, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d,
+    0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x38, 0x30, 0x39, 0x37, 0x00, 0x54, 0x72, 0x61, 0x69, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x37, 0x31, 0x00,
+    0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e,
+    0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38, 0x30, 0x38, 0x35,
+    0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x73, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f,
+    0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x38,
+    0x30, 0x32, 0x37, 0x00, 0x45, 0x64, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x39, 0x30, 0x34, 0x33, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73,
+    0x74, 0x69, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x31, 0x32, 0x37, 0x00, 0x57,
+    0x69, 0x6e, 0x6e, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c,
+    0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x37, 0x35, 0x00, 0x48,
+    0x6f, 0x6c, 0x6d, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x33, 0x30, 0x30, 0x35, 0x00, 0x43, 0x68, 0x65, 0x73,
+    0x68, 0x69, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x48, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x73,
+    0x68, 0x69, 0x72, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36,
+    0x30, 0x35, 0x33, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x39, 0x30, 0x37, 0x39, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x39, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x69, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x31, 0x34, 0x39, 0x00, 0x46, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32,
+    0x31, 0x30, 0x31, 0x00, 0x50, 0x68, 0x69, 0x6c, 0x61, 0x64, 0x65, 0x6c,
+    0x70, 0x68, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61,
+    0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31,
+    0x32, 0x39, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37,
+    0x31, 0x33, 0x37, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x37, 0x30, 0x37, 0x31, 0x00, 0x48, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x30, 0x39, 0x00, 0x42, 0x65, 0x6e,
+    0x65, 0x77, 0x61, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x38, 0x34, 0x32, 0x37, 0x00, 0x53, 0x74, 0x61, 0x72,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x35, 0x31, 0x33, 0x31, 0x00, 0x53, 0x65, 0x62, 0x61, 0x73, 0x74, 0x69,
+    0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52,
+    0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x31, 0x37, 0x00, 0x43, 0x61, 0x73,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x33, 0x35, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x38, 0x31, 0x34, 0x33, 0x00, 0x54, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x37, 0x30, 0x36, 0x31, 0x00, 0x47, 0x72, 0x75, 0x6e, 0x64, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x36, 0x30, 0x31, 0x31, 0x00, 0x43, 0x72, 0x6f, 0x6f, 0x6b,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57,
+    0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x33, 0x39, 0x31, 0x35, 0x39, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x36,
+    0x35, 0x00, 0x45, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x30,
+    0x30, 0x37, 0x00, 0x42, 0x65, 0x61, 0x76, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e,
+    0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x38, 0x30, 0x32, 0x35, 0x00, 0x44, 0x75, 0x6e, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x38, 0x33, 0x00, 0x4f,
+    0x63, 0x6f, 0x6e, 0x74, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73,
+    0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x38, 0x32,
+    0x30, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x73, 0x62, 0x6f, 0x72, 0x6f,
+    0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x38, 0x30, 0x38, 0x31, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49,
+    0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x30, 0x30, 0x30, 0x35, 0x00, 0x41, 0x74, 0x6f, 0x6b, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b,
+    0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x33, 0x34, 0x31, 0x00, 0x4d, 0x6f, 0x6f, 0x72, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30,
+    0x35, 0x33, 0x00, 0x4a, 0x61, 0x73, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x30, 0x31, 0x00, 0x4d, 0x61,
+    0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x32, 0x30, 0x32, 0x37, 0x00, 0x43, 0x6c, 0x61, 0x69, 0x62,
+    0x6f, 0x72, 0x6e, 0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00,
+    0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x32, 0x39, 0x00,
+    0x47, 0x6f, 0x72, 0x64, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x34, 0x30, 0x30, 0x31, 0x00,
+    0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x33, 0x35, 0x35, 0x00,
+    0x4e, 0x75, 0x65, 0x63, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x35, 0x35, 0x00, 0x53, 0x77,
+    0x69, 0x74, 0x7a, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x31, 0x30,
+    0x32, 0x37, 0x00, 0x48, 0x6f, 0x6f, 0x64, 0x20, 0x52, 0x69, 0x76, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00,
+    0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x32, 0x37, 0x30, 0x33, 0x35, 0x00, 0x43, 0x72, 0x6f, 0x77, 0x20, 0x57,
+    0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x36, 0x35, 0x00, 0x4c,
+    0x61, 0x66, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f,
+    0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x32, 0x32, 0x35, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30,
+    0x36, 0x30, 0x33, 0x37, 0x00, 0x4c, 0x6f, 0x73, 0x20, 0x41, 0x6e, 0x67,
+    0x65, 0x6c, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69,
+    0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x31, 0x32, 0x31, 0x39,
+    0x00, 0x54, 0x6f, 0x64, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x39, 0x31, 0x00,
+    0x4c, 0x6f, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x36, 0x30, 0x39, 0x31, 0x00, 0x4c, 0x65, 0x6e, 0x61,
+    0x77, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x31, 0x32, 0x33, 0x00, 0x54, 0x72,
+    0x69, 0x70, 0x70, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x30, 0x31, 0x31,
+    0x39, 0x00, 0x50, 0x61, 0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f,
+    0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x31, 0x30,
+    0x35, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30,
+    0x38, 0x31, 0x00, 0x4d, 0x6f, 0x66, 0x66, 0x61, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f,
+    0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38,
+    0x32, 0x36, 0x31, 0x00, 0x4b, 0x65, 0x6e, 0x65, 0x64, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x37, 0x31,
+    0x30, 0x00, 0x4e, 0x6f, 0x72, 0x66, 0x6f, 0x6c, 0x6b, 0x20, 0x63, 0x69,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x32, 0x32,
+    0x39, 0x00, 0x57, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75,
+    0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x31,
+    0x30, 0x37, 0x00, 0x57, 0x68, 0x65, 0x61, 0x74, 0x6c, 0x61, 0x6e, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d,
+    0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00,
+    0x33, 0x37, 0x30, 0x32, 0x39, 0x00, 0x43, 0x61, 0x6d, 0x64, 0x65, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x32, 0x37,
+    0x00, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68, 0x69, 0x72, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73,
+    0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x30, 0x35, 0x35, 0x00, 0x46, 0x72,
+    0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x34, 0x31,
+    0x00, 0x54, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x30, 0x33, 0x00, 0x48,
+    0x61, 0x72, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30, 0x34, 0x39, 0x00, 0x44,
+    0x61, 0x6c, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x34, 0x30, 0x30, 0x31, 0x00, 0x42, 0x72, 0x69, 0x73,
+    0x74, 0x6f, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x52,
+    0x49, 0x00, 0x52, 0x68, 0x6f, 0x64, 0x65, 0x20, 0x49, 0x73, 0x6c, 0x61,
+    0x6e, 0x64, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x38,
+    0x31, 0x00, 0x47, 0x72, 0x61, 0x79, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x31, 0x31, 0x39,
+    0x00, 0x50, 0x75, 0x6c, 0x61, 0x73, 0x6b, 0x69, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x30,
+    0x30, 0x37, 0x00, 0x41, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x34,
+    0x35, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x34,
+    0x37, 0x00, 0x45, 0x6d, 0x6d, 0x65, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x31, 0x39,
+    0x35, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65, 0x73, 0x69, 0x64, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x36, 0x30, 0x31, 0x39, 0x00, 0x46, 0x72, 0x65, 0x73, 0x6e, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43,
+    0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00,
+    0x2d, 0x38, 0x00, 0x34, 0x38, 0x33, 0x31, 0x39, 0x00, 0x4d, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x35, 0x31, 0x31, 0x31, 0x37, 0x00, 0x4d, 0x65, 0x63, 0x6b, 0x6c, 0x65,
+    0x6e, 0x62, 0x75, 0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x30, 0x39, 0x33, 0x00,
+    0x48, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x36, 0x30, 0x33, 0x31,
+    0x00, 0x45, 0x73, 0x73, 0x65, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72,
+    0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x31, 0x32, 0x39,
+    0x00, 0x4f, 0x67, 0x65, 0x6d, 0x61, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x35,
+    0x35, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x31, 0x35,
+    0x31, 0x00, 0x53, 0x61, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x30, 0x30,
+    0x31, 0x39, 0x00, 0x43, 0x68, 0x61, 0x75, 0x74, 0x61, 0x75, 0x71, 0x75,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x35, 0x30, 0x37, 0x00, 0x5a, 0x61, 0x76, 0x61, 0x6c, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31,
+    0x31, 0x32, 0x37, 0x00, 0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x38, 0x30, 0x30, 0x35, 0x00, 0x41, 0x6e, 0x67, 0x65, 0x6c,
+    0x69, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x39, 0x30, 0x37, 0x37, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00,
+    0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x37, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6e, 0x6f, 0x6b,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x31, 0x37, 0x00, 0x42, 0x61, 0x74,
+    0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x30, 0x36, 0x30, 0x37, 0x31, 0x00, 0x53, 0x61, 0x6e, 0x20,
+    0x42, 0x65, 0x72, 0x6e, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x6f, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c,
+    0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x31, 0x33, 0x32, 0x38, 0x39, 0x00, 0x54, 0x77, 0x69, 0x67, 0x67,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x33, 0x30, 0x30, 0x33, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x48,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68, 0x69,
+    0x72, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x34,
+    0x33, 0x00, 0x45, 0x72, 0x61, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30, 0x34, 0x35, 0x00, 0x47,
+    0x72, 0x65, 0x65, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30, 0x38, 0x37, 0x00, 0x4a, 0x65,
+    0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39, 0x30, 0x31, 0x35, 0x00,
+    0x45, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x38, 0x34, 0x37, 0x39, 0x00, 0x57, 0x65, 0x62, 0x62,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39,
+    0x30, 0x32, 0x37, 0x00, 0x43, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x33,
+    0x33, 0x00, 0x43, 0x61, 0x6c, 0x64, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x36, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6c, 0x70, 0x69, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61,
+    0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x37, 0x30, 0x30, 0x35, 0x00, 0x42, 0x65, 0x6e, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e,
+    0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x38, 0x31, 0x38, 0x33, 0x00, 0x57, 0x68, 0x69,
+    0x74, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x30, 0x37, 0x00, 0x41, 0x73,
+    0x73, 0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x72,
+    0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x33, 0x38, 0x35, 0x00, 0x52, 0x65, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x30, 0x31, 0x37, 0x00,
+    0x43, 0x69, 0x74, 0x72, 0x75, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31, 0x34, 0x39, 0x00,
+    0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x39, 0x37,
+    0x00, 0x50, 0x69, 0x74, 0x6b, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61,
+    0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x38, 0x30, 0x39,
+    0x33, 0x00, 0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36,
+    0x30, 0x36, 0x33, 0x00, 0x4e, 0x69, 0x61, 0x67, 0x61, 0x72, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x31, 0x30, 0x35, 0x33, 0x00, 0x44, 0x69, 0x6e, 0x77, 0x69, 0x64,
+    0x64, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x31, 0x30, 0x31, 0x00, 0x4e, 0x65,
+    0x77, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x31, 0x32, 0x37, 0x00, 0x56,
+    0x6f, 0x6c, 0x75, 0x73, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x38, 0x39, 0x00,
+    0x48, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x31, 0x35, 0x00, 0x43, 0x6c,
+    0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x30,
+    0x37, 0x00, 0x42, 0x65, 0x6c, 0x74, 0x72, 0x61, 0x6d, 0x69, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x39, 0x30, 0x33, 0x39, 0x00, 0x43, 0x65, 0x64, 0x61, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x32, 0x30, 0x32, 0x37, 0x00, 0x50, 0x65, 0x72, 0x73, 0x68, 0x69,
+    0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56,
+    0x00, 0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38,
+    0x00, 0x30, 0x39, 0x30, 0x31, 0x31, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4c,
+    0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x54, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69,
+    0x63, 0x75, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30,
+    0x39, 0x35, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x4c, 0x61, 0x63,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x36, 0x30, 0x34, 0x37, 0x00, 0x46, 0x61, 0x6c,
+    0x6c, 0x20, 0x52, 0x69, 0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x31, 0x30, 0x32, 0x35, 0x00, 0x48, 0x61, 0x72, 0x6e, 0x65, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f,
+    0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34,
+    0x39, 0x30, 0x34, 0x39, 0x00, 0x55, 0x74, 0x61, 0x68, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x38, 0x31, 0x36, 0x31, 0x00,
+    0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x32, 0x30, 0x31, 0x33, 0x00, 0x41,
+    0x6c, 0x65, 0x75, 0x74, 0x69, 0x61, 0x6e, 0x73, 0x20, 0x45, 0x61, 0x73,
+    0x74, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x41, 0x4b,
+    0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39,
+    0x00, 0x30, 0x31, 0x30, 0x38, 0x35, 0x00, 0x4c, 0x6f, 0x77, 0x6e, 0x64,
+    0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c,
+    0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x39, 0x30, 0x32, 0x39, 0x00, 0x43, 0x61, 0x73, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49,
+    0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x30, 0x30,
+    0x31, 0x39, 0x00, 0x4f, 0x72, 0x6c, 0x65, 0x61, 0x6e, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54, 0x00, 0x56, 0x65, 0x72,
+    0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37,
+    0x30, 0x34, 0x35, 0x00, 0x43, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x61, 0x6e,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x38,
+    0x31, 0x00, 0x4d, 0x61, 0x6e, 0x61, 0x74, 0x65, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31,
+    0x35, 0x35, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x31, 0x31, 0x00, 0x4c,
+    0x79, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x38, 0x30, 0x37, 0x39, 0x00, 0x52, 0x6f, 0x6c, 0x65,
+    0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36, 0x30, 0x39,
+    0x35, 0x00, 0x53, 0x6f, 0x6c, 0x61, 0x6e, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66,
+    0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34,
+    0x37, 0x30, 0x33, 0x35, 0x00, 0x43, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6c,
+    0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x31, 0x33, 0x37, 0x00, 0x53, 0x74,
+    0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x34, 0x31, 0x00, 0x4a, 0x61,
+    0x73, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x38, 0x30, 0x32, 0x39, 0x00, 0x43, 0x6f, 0x70, 0x69,
+    0x61, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53,
+    0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x37, 0x39, 0x00, 0x53, 0x68, 0x65,
+    0x72, 0x69, 0x64, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x30, 0x37, 0x00, 0x43, 0x68,
+    0x65, 0x6c, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x38, 0x31, 0x37,
+    0x37, 0x00, 0x47, 0x6f, 0x6e, 0x7a, 0x61, 0x6c, 0x65, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x31,
+    0x33, 0x00, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x69, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73,
+    0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x35, 0x33, 0x30, 0x37, 0x33, 0x00, 0x57, 0x68, 0x61, 0x74,
+    0x63, 0x6f, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x38, 0x34, 0x38, 0x31,
+    0x00, 0x57, 0x68, 0x61, 0x72, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x30, 0x35, 0x00,
+    0x4e, 0x6f, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x36,
+    0x31, 0x00, 0x46, 0x72, 0x65, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39, 0x30,
+    0x31, 0x33, 0x00, 0x44, 0x75, 0x63, 0x68, 0x65, 0x73, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74,
+    0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x35, 0x30, 0x36,
+    0x37, 0x00, 0x4c, 0x61, 0x6e, 0x67, 0x6c, 0x61, 0x64, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73,
+    0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x35, 0x30, 0x31, 0x39, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c,
+    0x65, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x37, 0x30, 0x36, 0x33, 0x00, 0x48, 0x61, 0x6d, 0x62, 0x6c, 0x65,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x38, 0x32, 0x38, 0x31, 0x00, 0x4c, 0x61, 0x6d, 0x70,
+    0x61, 0x73, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x30, 0x32, 0x30, 0x35, 0x00, 0x57, 0x69, 0x6c, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x36, 0x31, 0x36, 0x31, 0x00, 0x57, 0x61, 0x73, 0x68, 0x74,
+    0x65, 0x6e, 0x61, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x31, 0x33, 0x00, 0x43,
+    0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x37, 0x30, 0x30, 0x37, 0x00, 0x42, 0x6f, 0x6f, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x37, 0x30, 0x35, 0x31, 0x00, 0x43, 0x75, 0x6d, 0x62, 0x65, 0x72,
+    0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x38, 0x30, 0x33, 0x37, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x37, 0x30, 0x32, 0x33, 0x00, 0x43, 0x68, 0x69, 0x70,
+    0x70, 0x65, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x35, 0x33, 0x00,
+    0x48, 0x69, 0x6e, 0x73, 0x64, 0x61, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
+    0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x36, 0x31,
+    0x30, 0x39, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x37, 0x00, 0x30, 0x38, 0x30, 0x32, 0x37, 0x00, 0x43, 0x75, 0x73,
+    0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x30, 0x30, 0x39, 0x33, 0x00, 0x4d, 0x61,
+    0x6a, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x31, 0x30, 0x39, 0x00, 0x4d, 0x65,
+    0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x34, 0x30, 0x33,
+    0x37, 0x00, 0x53, 0x75, 0x73, 0x73, 0x65, 0x78, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a,
+    0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x34, 0x30, 0x32, 0x37, 0x00, 0x48, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61,
+    0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x37, 0x31, 0x33, 0x37, 0x00, 0x50, 0x61, 0x6d, 0x6c, 0x69, 0x63,
+    0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31, 0x35,
+    0x37, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x62, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65,
+    0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30,
+    0x33, 0x37, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x31, 0x30, 0x33, 0x33, 0x00, 0x4a, 0x6f, 0x73, 0x65, 0x70,
+    0x68, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00,
+    0x2d, 0x38, 0x00, 0x34, 0x32, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6c, 0x6c,
+    0x65, 0x67, 0x68, 0x65, 0x6e, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c,
+    0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x35,
+    0x31, 0x36, 0x32, 0x30, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69,
+    0x6e, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x30, 0x35, 0x30, 0x38, 0x35, 0x00, 0x4c, 0x6f, 0x6e, 0x6f, 0x6b, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41,
+    0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x30, 0x30, 0x32, 0x31, 0x00, 0x43, 0x68, 0x65, 0x72, 0x6f,
+    0x6b, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30, 0x38, 0x39, 0x00, 0x57, 0x69,
+    0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73, 0x62, 0x75, 0x72, 0x67, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x35, 0x39, 0x00, 0x46,
+    0x61, 0x69, 0x72, 0x66, 0x61, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38, 0x30, 0x33, 0x39,
+    0x00, 0x45, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61,
+    0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x35, 0x30, 0x35,
+    0x31, 0x00, 0x47, 0x61, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31,
+    0x31, 0x38, 0x31, 0x00, 0x4e, 0x69, 0x63, 0x68, 0x6f, 0x6c, 0x61, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x39, 0x30, 0x33, 0x37, 0x00, 0x43, 0x68, 0x69, 0x63, 0x6b,
+    0x61, 0x73, 0x61, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x32, 0x38, 0x35, 0x00, 0x4c, 0x61, 0x76, 0x61, 0x63,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x30, 0x31, 0x37, 0x37, 0x00, 0x53, 0x68, 0x61, 0x77, 0x6e, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x39, 0x31, 0x32, 0x33, 0x00, 0x4f, 0x74, 0x74, 0x61, 0x77, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x31, 0x35,
+    0x31, 0x00, 0x53, 0x74, 0x65, 0x75, 0x62, 0x65, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x31,
+    0x32, 0x31, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37,
+    0x30, 0x35, 0x39, 0x00, 0x47, 0x61, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x36, 0x30, 0x30, 0x37, 0x00, 0x43, 0x61, 0x72, 0x62, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00,
+    0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x35, 0x31, 0x35, 0x39, 0x35, 0x00, 0x45, 0x6d, 0x70, 0x6f, 0x72,
+    0x69, 0x61, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x39, 0x30, 0x38, 0x35, 0x00, 0x48, 0x69, 0x63, 0x6b, 0x6f,
+    0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x31, 0x37, 0x00, 0x43, 0x68, 0x65,
+    0x79, 0x65, 0x6e, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x36, 0x30, 0x32, 0x35, 0x00,
+    0x43, 0x6c, 0x61, 0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39,
+    0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x33, 0x33, 0x00,
+    0x44, 0x65, 0x20, 0x4b, 0x61, 0x6c, 0x62, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e,
+    0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x34, 0x31,
+    0x00, 0x43, 0x68, 0x61, 0x72, 0x69, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30,
+    0x30, 0x38, 0x39, 0x00, 0x4d, 0x63, 0x43, 0x75, 0x72, 0x74, 0x61, 0x69,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00,
+    0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x30, 0x31, 0x38, 0x39, 0x00, 0x53, 0x74, 0x65, 0x76,
+    0x65, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x32, 0x36, 0x37, 0x00, 0x4b, 0x69, 0x6d, 0x62,
+    0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x35, 0x30, 0x33, 0x37, 0x00, 0x43, 0x72, 0x6f, 0x73, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72,
+    0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x31, 0x30, 0x31, 0x33, 0x00, 0x43, 0x72, 0x6f, 0x6f, 0x6b, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72,
+    0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x33,
+    0x31, 0x36, 0x33, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x38, 0x33, 0x31, 0x33, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x36, 0x30, 0x37, 0x37, 0x00, 0x4f, 0x74, 0x73, 0x65, 0x67, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x31, 0x30, 0x30, 0x37, 0x00, 0x41, 0x6d, 0x65, 0x6c, 0x69,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x30, 0x30, 0x30, 0x37, 0x00, 0x42, 0x65, 0x61, 0x76,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b,
+    0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x38, 0x35, 0x00, 0x44, 0x61, 0x77,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x30, 0x34, 0x39, 0x00, 0x42, 0x72, 0x6f,
+    0x77, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x30, 0x30, 0x32, 0x31, 0x00, 0x44, 0x61, 0x77, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d,
+    0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00,
+    0x35, 0x30, 0x30, 0x31, 0x35, 0x00, 0x4c, 0x61, 0x6d, 0x6f, 0x69, 0x6c,
+    0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54,
+    0x00, 0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x39, 0x30, 0x39, 0x39, 0x00, 0x4a, 0x65, 0x66, 0x66,
+    0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x36, 0x33, 0x00,
+    0x4b, 0x65, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x31, 0x30, 0x37, 0x31, 0x00, 0x59, 0x61, 0x6d, 0x68,
+    0x69, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x32, 0x30, 0x32, 0x37, 0x00, 0x43, 0x65, 0x6e, 0x74,
+    0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41,
+    0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x34, 0x37,
+    0x00, 0x48, 0x61, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x30, 0x30, 0x33, 0x00, 0x41,
+    0x64, 0x61, 0x6d, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x31, 0x30, 0x37, 0x37, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6c,
+    0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45,
+    0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x30, 0x30, 0x30, 0x33, 0x00, 0x42, 0x65, 0x6e,
+    0x6e, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x56, 0x54, 0x00, 0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e,
+    0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x30, 0x35, 0x33,
+    0x00, 0x44, 0x65, 0x63, 0x61, 0x74, 0x75, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x33, 0x33, 0x00, 0x45,
+    0x61, 0x73, 0x74, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x30, 0x37, 0x31, 0x00, 0x4c,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c,
+    0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x33, 0x30, 0x34, 0x33, 0x00, 0x43, 0x61, 0x6e, 0x64,
+    0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x35, 0x37, 0x00, 0x48, 0x65, 0x6d,
+    0x70, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x32, 0x35,
+    0x00, 0x43, 0x72, 0x61, 0x77, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30,
+    0x37, 0x39, 0x00, 0x4b, 0x61, 0x6c, 0x6b, 0x61, 0x73, 0x6b, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x31, 0x31, 0x38, 0x33, 0x00, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00,
+    0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x37, 0x00, 0x32, 0x35, 0x30, 0x30, 0x31, 0x00, 0x42, 0x61, 0x72, 0x6e,
+    0x73, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68,
+    0x75, 0x73, 0x65, 0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x33, 0x30, 0x32, 0x33, 0x00, 0x47, 0x61, 0x72, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x38, 0x31, 0x30, 0x33, 0x00,
+    0x57, 0x65, 0x6c, 0x6c, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38,
+    0x31, 0x33, 0x33, 0x00, 0x50, 0x75, 0x74, 0x6e, 0x61, 0x6d, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31,
+    0x32, 0x30, 0x37, 0x00, 0x52, 0x75, 0x73, 0x73, 0x65, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x33, 0x30, 0x36, 0x37, 0x00, 0x54, 0x68, 0x75, 0x72, 0x73, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x30, 0x36, 0x30, 0x38, 0x33, 0x00,
+    0x53, 0x61, 0x6e, 0x74, 0x61, 0x20, 0x42, 0x61, 0x72, 0x62, 0x61, 0x72,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00,
+    0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x31, 0x38, 0x30, 0x32, 0x37, 0x00, 0x44, 0x61,
+    0x76, 0x69, 0x65, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x38, 0x35, 0x00, 0x47,
+    0x72, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x33, 0x39, 0x00, 0x4d, 0x6f, 0x75,
+    0x6c, 0x74, 0x72, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x31, 0x33, 0x00,
+    0x4d, 0x63, 0x50, 0x68, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x33,
+    0x31, 0x00, 0x43, 0x6f, 0x6d, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c,
+    0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x38, 0x30, 0x35, 0x37, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00,
+    0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x39, 0x31, 0x37, 0x33, 0x00, 0x52, 0x61, 0x6c, 0x6c, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d,
+    0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x37, 0x31, 0x37, 0x31, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x33, 0x33, 0x35, 0x00, 0x4d, 0x69, 0x74, 0x63, 0x68,
+    0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x37, 0x31, 0x38, 0x37, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x37, 0x31, 0x36, 0x33, 0x00, 0x53, 0x61, 0x6d, 0x70, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x32, 0x33,
+    0x31, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x36, 0x30, 0x32, 0x39, 0x00, 0x50, 0x61,
+    0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59,
+    0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x35, 0x31, 0x36, 0x37, 0x38, 0x00, 0x4c, 0x65, 0x78, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x31, 0x30, 0x34, 0x33, 0x00, 0x4c, 0x69,
+    0x6e, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52,
+    0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x33, 0x31, 0x31, 0x32, 0x33, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x69,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45,
+    0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00,
+    0x2d, 0x37, 0x00, 0x34, 0x38, 0x32, 0x31, 0x31, 0x00, 0x48, 0x65, 0x6d,
+    0x70, 0x68, 0x69, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x37, 0x39, 0x00, 0x52, 0x61, 0x70,
+    0x69, 0x64, 0x65, 0x73, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00,
+    0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30, 0x38, 0x37, 0x00,
+    0x4c, 0x6f, 0x77, 0x6e, 0x64, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70,
+    0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x36,
+    0x33, 0x00, 0x44, 0x75, 0x72, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x31, 0x39, 0x00, 0x42, 0x6f, 0x6f,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x39, 0x33, 0x00, 0x57, 0x69, 0x6c,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x30, 0x31, 0x35, 0x37, 0x00, 0x52, 0x65, 0x70, 0x75, 0x62,
+    0x6c, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x31, 0x30, 0x33, 0x39, 0x00, 0x4c, 0x61, 0x6e, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f,
+    0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x35,
+    0x34, 0x30, 0x32, 0x39, 0x00, 0x48, 0x61, 0x6e, 0x63, 0x6f, 0x63, 0x6b,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x38, 0x33, 0x00,
+    0x57, 0x68, 0x65, 0x65, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x31, 0x33, 0x00, 0x44,
+    0x61, 0x6c, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x38, 0x30, 0x39, 0x31, 0x00, 0x4d, 0x61, 0x72,
+    0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x35, 0x35, 0x00, 0x50, 0x65,
+    0x6d, 0x69, 0x73, 0x63, 0x6f, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x30, 0x31,
+    0x00, 0x41, 0x64, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x31, 0x36, 0x30, 0x35, 0x33, 0x00, 0x4a, 0x65, 0x72, 0x6f,
+    0x6d, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44,
+    0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x30, 0x36, 0x30, 0x36, 0x35, 0x00, 0x52, 0x69, 0x76, 0x65, 0x72, 0x73,
+    0x69, 0x64, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x38, 0x30, 0x32, 0x39, 0x00,
+    0x44, 0x65, 0x61, 0x72, 0x62, 0x6f, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x37,
+    0x39, 0x00, 0x4c, 0x75, 0x7a, 0x65, 0x72, 0x6e, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e,
+    0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x35, 0x30, 0x30, 0x33, 0x00, 0x41, 0x73, 0x68, 0x6c,
+    0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x30, 0x35, 0x00,
+    0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x38, 0x31, 0x00,
+    0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30, 0x36, 0x35, 0x00,
+    0x48, 0x75, 0x67, 0x68, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44,
+    0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x34,
+    0x35, 0x30, 0x32, 0x37, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x65, 0x6e, 0x64,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31,
+    0x38, 0x31, 0x00, 0x53, 0x68, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31,
+    0x34, 0x35, 0x00, 0x53, 0x74, 0x65, 0x61, 0x72, 0x6e, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x39, 0x30, 0x36, 0x39, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x30,
+    0x33, 0x00, 0x41, 0x6c, 0x67, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x31, 0x33,
+    0x33, 0x00, 0x53, 0x65, 0x76, 0x69, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x31,
+    0x30, 0x31, 0x00, 0x57, 0x65, 0x62, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73,
+    0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x36, 0x33, 0x30, 0x00, 0x46, 0x72,
+    0x65, 0x64, 0x65, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x62, 0x75, 0x72, 0x67,
+    0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x37, 0x30, 0x38, 0x35, 0x00, 0x4a, 0x6f, 0x20, 0x44, 0x61, 0x76, 0x69,
+    0x65, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x36, 0x35, 0x00, 0x47, 0x61,
+    0x69, 0x6e, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x30, 0x31, 0x31, 0x35, 0x00, 0x4d, 0x61, 0x72, 0x69,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x31, 0x30, 0x35, 0x35, 0x00, 0x53, 0x68, 0x65, 0x72, 0x6d,
+    0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52,
+    0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x31, 0x33, 0x31, 0x31, 0x35, 0x00, 0x46, 0x6c, 0x6f, 0x79, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x31, 0x30, 0x38, 0x39, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x75,
+    0x70, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00,
+    0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x36, 0x30, 0x38, 0x37, 0x00, 0x53, 0x61, 0x6e, 0x74,
+    0x61, 0x20, 0x43, 0x72, 0x75, 0x7a, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x37, 0x31,
+    0x33, 0x39, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65,
+    0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37,
+    0x30, 0x37, 0x37, 0x00, 0x48, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x33, 0x30, 0x35, 0x35, 0x00, 0x53, 0x61, 0x6e, 0x20,
+    0x4a, 0x75, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x35, 0x30, 0x30,
+    0x36, 0x00, 0x43, 0x69, 0x62, 0x6f, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d,
+    0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31,
+    0x39, 0x31, 0x39, 0x33, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x62, 0x75, 0x72,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00,
+    0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36,
+    0x30, 0x37, 0x33, 0x00, 0x4a, 0x65, 0x72, 0x61, 0x75, 0x6c, 0x64, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x37, 0x00, 0x32, 0x37, 0x31, 0x35, 0x33, 0x00, 0x54, 0x6f,
+    0x64, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x36, 0x35, 0x00, 0x43, 0x61,
+    0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x37, 0x31, 0x36, 0x31, 0x00, 0x53, 0x74, 0x65, 0x77,
+    0x61, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x30, 0x39, 0x33, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x6f, 0x75, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76,
+    0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38,
+    0x30, 0x35, 0x33, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30,
+    0x31, 0x39, 0x00, 0x42, 0x65, 0x6e, 0x7a, 0x69, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68,
+    0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39,
+    0x31, 0x34, 0x31, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x33, 0x30, 0x32, 0x35, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x74, 0x6c, 0x65,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x33, 0x33, 0x30, 0x31, 0x00, 0x57, 0x61, 0x72, 0x72, 0x65,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x34, 0x30, 0x37, 0x37, 0x00, 0x50, 0x72, 0x65, 0x73, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x33,
+    0x33, 0x00, 0x43, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x32, 0x30, 0x30, 0x35, 0x00, 0x41, 0x73, 0x63, 0x65, 0x6e,
+    0x73, 0x69, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00,
+    0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x35, 0x35, 0x00,
+    0x48, 0x75, 0x65, 0x72, 0x66, 0x61, 0x6e, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72,
+    0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x37, 0x31,
+    0x30, 0x37, 0x00, 0x4d, 0x63, 0x4d, 0x69, 0x6e, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31,
+    0x30, 0x32, 0x37, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x30,
+    0x33, 0x00, 0x4c, 0x75, 0x62, 0x62, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x31, 0x32, 0x33,
+    0x00, 0x57, 0x65, 0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x38, 0x31, 0x33, 0x35, 0x00,
+    0x54, 0x61, 0x6c, 0x6c, 0x61, 0x68, 0x61, 0x74, 0x63, 0x68, 0x69, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d,
+    0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x38, 0x30, 0x32, 0x33, 0x00, 0x43, 0x6f, 0x73, 0x74, 0x69,
+    0x6c, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x32, 0x37, 0x39, 0x00, 0x4c, 0x61,
+    0x6d, 0x62, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x39, 0x31, 0x30, 0x31, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00,
+    0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x30, 0x30, 0x34, 0x35, 0x00, 0x45, 0x6c, 0x6c, 0x69,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00,
+    0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x35, 0x31, 0x32, 0x31, 0x00, 0x54, 0x72, 0x65, 0x6d,
+    0x70, 0x65, 0x61, 0x6c, 0x65, 0x61, 0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32,
+    0x31, 0x31, 0x39, 0x00, 0x57, 0x65, 0x62, 0x73, 0x74, 0x65, 0x72, 0x20,
+    0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f,
+    0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x39, 0x30, 0x32, 0x31, 0x00, 0x42, 0x75, 0x65, 0x6e, 0x61,
+    0x20, 0x56, 0x69, 0x73, 0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x31, 0x35, 0x00, 0x43, 0x61, 0x6e,
+    0x6e, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x37, 0x33, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31,
+    0x36, 0x39, 0x00, 0x54, 0x72, 0x6f, 0x75, 0x73, 0x64, 0x61, 0x6c, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x31, 0x30, 0x34, 0x39, 0x00, 0x44, 0x65, 0x75, 0x65, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x39, 0x31, 0x36, 0x39, 0x00, 0x53, 0x74, 0x6f, 0x72, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49,
+    0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31,
+    0x35, 0x37, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6c, 0x70, 0x68, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x37, 0x30, 0x33, 0x37, 0x00, 0x44, 0x65, 0x4b, 0x61, 0x6c, 0x62,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x30, 0x30, 0x36, 0x37, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x31, 0x38, 0x35, 0x00, 0x57,
+    0x68, 0x69, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30, 0x38, 0x39, 0x00, 0x4d,
+    0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x38, 0x33, 0x00,
+    0x48, 0x6f, 0x64, 0x67, 0x65, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x33, 0x35,
+    0x00, 0x47, 0x77, 0x69, 0x6e, 0x6e, 0x65, 0x74, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30,
+    0x39, 0x35, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35,
+    0x30, 0x38, 0x33, 0x00, 0x53, 0x70, 0x61, 0x72, 0x74, 0x61, 0x6e, 0x62,
+    0x75, 0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30,
+    0x30, 0x35, 0x35, 0x00, 0x4d, 0x63, 0x43, 0x6f, 0x6e, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x35,
+    0x30, 0x37, 0x39, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72,
+    0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x30, 0x31, 0x30, 0x35, 0x00, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d,
+    0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00,
+    0x32, 0x36, 0x30, 0x37, 0x37, 0x00, 0x4b, 0x61, 0x6c, 0x61, 0x6d, 0x61,
+    0x7a, 0x6f, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x37, 0x33, 0x00, 0x53, 0x61,
+    0x6e, 0x20, 0x44, 0x69, 0x65, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f,
+    0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x30,
+    0x31, 0x33, 0x35, 0x00, 0x4e, 0x65, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31, 0x37, 0x35,
+    0x00, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x39, 0x30, 0x36,
+    0x35, 0x00, 0x46, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x39, 0x31, 0x00,
+    0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73,
+    0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30, 0x30,
+    0x37, 0x00, 0x42, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30,
+    0x33, 0x31, 0x00, 0x43, 0x6f, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74,
+    0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x35, 0x30, 0x30, 0x39, 0x00, 0x42, 0x61, 0x6d, 0x62,
+    0x65, 0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31,
+    0x31, 0x33, 0x37, 0x00, 0x50, 0x68, 0x65, 0x6c, 0x70, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30,
+    0x31, 0x30, 0x31, 0x31, 0x00, 0x42, 0x75, 0x6c, 0x6c, 0x6f, 0x63, 0x6b,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41,
+    0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x36, 0x30, 0x30, 0x35, 0x00, 0x41, 0x6d, 0x61, 0x64, 0x6f, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43,
+    0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00,
+    0x2d, 0x38, 0x00, 0x32, 0x39, 0x31, 0x35, 0x39, 0x00, 0x50, 0x65, 0x74,
+    0x74, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x37, 0x31, 0x00, 0x54, 0x65,
+    0x6c, 0x66, 0x61, 0x69, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x30, 0x31, 0x00, 0x4a,
+    0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x39, 0x31, 0x00, 0x57,
+    0x61, 0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x37, 0x39, 0x00, 0x48,
+    0x61, 0x72, 0x76, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x31, 0x39, 0x00, 0x43, 0x61,
+    0x6c, 0x63, 0x61, 0x73, 0x69, 0x65, 0x75, 0x20, 0x50, 0x61, 0x72, 0x69,
+    0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30,
+    0x39, 0x35, 0x00, 0x4d, 0x65, 0x6c, 0x6c, 0x65, 0x74, 0x74, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x37, 0x00, 0x32, 0x31, 0x32, 0x32, 0x37, 0x00, 0x57, 0x61,
+    0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x39, 0x39, 0x00, 0x54,
+    0x65, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x32, 0x37, 0x30, 0x35, 0x35, 0x00, 0x48, 0x6f,
+    0x75, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x33, 0x30, 0x31, 0x37,
+    0x00, 0x53, 0x74, 0x72, 0x61, 0x66, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x48, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68, 0x69, 0x72, 0x65, 0x00, 0x30,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31, 0x35, 0x39, 0x00, 0x53, 0x6d,
+    0x69, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x34, 0x30, 0x30, 0x37, 0x00, 0x50, 0x72,
+    0x6f, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x52, 0x49, 0x00, 0x52, 0x68, 0x6f, 0x64, 0x65,
+    0x20, 0x49, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x30, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x36, 0x30, 0x31, 0x35, 0x00, 0x42, 0x6f, 0x69, 0x73, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49,
+    0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x36,
+    0x30, 0x31, 0x39, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79,
+    0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x30,
+    0x31, 0x30, 0x36, 0x37, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61,
+    0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30,
+    0x31, 0x30, 0x31, 0x00, 0x54, 0x6f, 0x6f, 0x6c, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74,
+    0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x31,
+    0x37, 0x37, 0x00, 0x53, 0x70, 0x6f, 0x74, 0x73, 0x79, 0x6c, 0x76, 0x61,
+    0x6e, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x32, 0x39, 0x00, 0x42, 0x75,
+    0x6c, 0x6c, 0x69, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x31, 0x31, 0x31, 0x00,
+    0x4f, 0x6b, 0x6d, 0x75, 0x6c, 0x67, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x31,
+    0x32, 0x33, 0x00, 0x54, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x31,
+    0x33, 0x35, 0x00, 0x4e, 0x6f, 0x74, 0x74, 0x6f, 0x77, 0x61, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x39, 0x31, 0x33, 0x33, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x31, 0x32, 0x39, 0x00,
+    0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61,
+    0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38,
+    0x30, 0x33, 0x35, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f,
+    0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x35, 0x35, 0x31, 0x33, 0x33, 0x00, 0x57, 0x61, 0x75, 0x6b, 0x65, 0x73,
+    0x68, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49,
+    0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x31, 0x33, 0x31, 0x00, 0x4f,
+    0x62, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x30, 0x36, 0x31, 0x00, 0x48,
+    0x75, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x64, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e,
+    0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x36, 0x30, 0x31, 0x33, 0x00, 0x42, 0x72, 0x6f, 0x77,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x38, 0x37, 0x00,
+    0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x34, 0x31,
+    0x00, 0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65,
+    0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38,
+    0x30, 0x34, 0x33, 0x00, 0x47, 0x72, 0x65, 0x6e, 0x61, 0x64, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x36, 0x30, 0x37, 0x39, 0x00, 0x50, 0x75, 0x74, 0x6e, 0x61, 0x6d,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x32, 0x30, 0x36, 0x37, 0x00, 0x4a, 0x75, 0x6e, 0x69, 0x61,
+    0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41,
+    0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x30, 0x39,
+    0x00, 0x4c, 0x6f, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x31, 0x31, 0x35, 0x00, 0x50,
+    0x6f, 0x70, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x32, 0x39, 0x00, 0x42, 0x72,
+    0x79, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x39, 0x30, 0x33, 0x39, 0x00, 0x53, 0x61, 0x6e,
+    0x70, 0x65, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x32, 0x39, 0x30, 0x31, 0x31, 0x00, 0x42, 0x61, 0x72, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00,
+    0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x30, 0x30, 0x39, 0x37, 0x00, 0x4b, 0x69, 0x6f, 0x77,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x30, 0x30, 0x38, 0x31, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00,
+    0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x32, 0x39, 0x37, 0x00, 0x4c, 0x69, 0x76, 0x65,
+    0x20, 0x4f, 0x61, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x32, 0x36, 0x39, 0x00, 0x4b, 0x69, 0x6e, 0x67,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37,
+    0x31, 0x32, 0x31, 0x00, 0x4d, 0x69, 0x74, 0x63, 0x68, 0x65, 0x6c, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x34, 0x33,
+    0x00, 0x46, 0x6c, 0x6f, 0x79, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x31, 0x31, 0x35, 0x00,
+    0x4c, 0x6f, 0x75, 0x70, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x32, 0x35, 0x39, 0x00, 0x4b,
+    0x65, 0x6e, 0x64, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x39, 0x35, 0x00, 0x4d, 0x61,
+    0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x32, 0x31, 0x00, 0x43,
+    0x61, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x32, 0x33, 0x00, 0x50,
+    0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x33, 0x33, 0x00, 0x47, 0x61,
+    0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x32, 0x31, 0x33, 0x31, 0x00,
+    0x57, 0x61, 0x6c, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x36, 0x30, 0x34, 0x39, 0x00,
+    0x49, 0x64, 0x61, 0x68, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x34, 0x35, 0x30, 0x31, 0x33, 0x00, 0x42, 0x65, 0x61,
+    0x75, 0x66, 0x6f, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x30, 0x31, 0x32, 0x39, 0x00, 0x4d, 0x6f, 0x72, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x38, 0x30, 0x33, 0x33, 0x00, 0x44, 0x6f, 0x6c, 0x6f, 0x72, 0x65, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43,
+    0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x31, 0x38, 0x31, 0x36, 0x39, 0x00, 0x57, 0x61, 0x62, 0x61, 0x73,
+    0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00,
+    0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x39, 0x31, 0x37, 0x35, 0x00, 0x57, 0x79, 0x61, 0x6e, 0x64,
+    0x6f, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48,
+    0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x32, 0x30, 0x38, 0x37, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c,
+    0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x38, 0x31, 0x33, 0x31, 0x00, 0x53, 0x74, 0x6f, 0x6e, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x38, 0x31, 0x34, 0x37, 0x00, 0x53, 0x70, 0x65, 0x6e, 0x63, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49,
+    0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x37, 0x30, 0x37, 0x35, 0x00, 0x49, 0x72, 0x6f, 0x71, 0x75, 0x6f,
+    0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x34, 0x33, 0x00, 0x43, 0x6c, 0x61,
+    0x72, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x35, 0x39, 0x00, 0x48, 0x61,
+    0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x32, 0x30, 0x33, 0x35,
+    0x00, 0x43, 0x6c, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73,
+    0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x37, 0x31, 0x38, 0x35, 0x00, 0x57, 0x61, 0x62, 0x61, 0x73,
+    0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00,
+    0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x39, 0x30, 0x33, 0x31, 0x00, 0x43, 0x6f, 0x73, 0x68,
+    0x6f, 0x63, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x30, 0x31, 0x31, 0x31, 0x31, 0x00, 0x52, 0x61, 0x6e, 0x64,
+    0x6f, 0x6c, 0x70, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x35, 0x30, 0x32, 0x38, 0x00, 0x4c, 0x6f,
+    0x73, 0x20, 0x41, 0x6c, 0x61, 0x6d, 0x6f, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d,
+    0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32,
+    0x38, 0x30, 0x38, 0x39, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d,
+    0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x36, 0x31, 0x31, 0x37, 0x00, 0x53, 0x74, 0x61, 0x6e, 0x6c,
+    0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33, 0x31, 0x38, 0x35,
+    0x00, 0x4c, 0x6f, 0x77, 0x6e, 0x64, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x32,
+    0x33, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x73, 0x20, 0x4d, 0x69,
+    0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x36, 0x31, 0x00,
+    0x53, 0x61, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x32, 0x30, 0x31, 0x31, 0x00, 0x42, 0x65, 0x61, 0x75, 0x72, 0x65,
+    0x67, 0x61, 0x72, 0x64, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00,
+    0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x35, 0x37, 0x00,
+    0x50, 0x6f, 0x77, 0x65, 0x73, 0x68, 0x69, 0x65, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x34, 0x31, 0x00,
+    0x4c, 0x65, 0x77, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x30, 0x35, 0x30,
+    0x35, 0x35, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38,
+    0x31, 0x35, 0x33, 0x00, 0x53, 0x75, 0x6c, 0x6c, 0x69, 0x76, 0x61, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49,
+    0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x35, 0x30, 0x36, 0x31, 0x00, 0x4b, 0x65, 0x77, 0x61, 0x75, 0x6e,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49,
+    0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30, 0x31, 0x35, 0x00, 0x42,
+    0x65, 0x72, 0x6b, 0x65, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x31, 0x30, 0x31, 0x37, 0x00, 0x44, 0x65, 0x73, 0x63,
+    0x68, 0x75, 0x74, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x32, 0x31, 0x31, 0x38, 0x39, 0x00, 0x4f, 0x77,
+    0x73, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x32, 0x39, 0x00, 0x43,
+    0x6c, 0x65, 0x62, 0x75, 0x72, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x31, 0x33, 0x31,
+    0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73,
+    0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x36, 0x30, 0x37, 0x37, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x4a,
+    0x6f, 0x61, 0x71, 0x75, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x39, 0x30,
+    0x30, 0x35, 0x00, 0x41, 0x74, 0x63, 0x68, 0x69, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x31, 0x30, 0x30, 0x39, 0x00, 0x42, 0x6c, 0x61, 0x69, 0x6e, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x37, 0x30, 0x33, 0x37, 0x00, 0x43, 0x68, 0x61, 0x74, 0x68,
+    0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30,
+    0x33, 0x39, 0x00, 0x45, 0x76, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x6e,
+    0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00,
+    0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x32, 0x30, 0x39, 0x39, 0x00, 0x50, 0x61, 0x6c,
+    0x6d, 0x20, 0x42, 0x65, 0x61, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x33, 0x31,
+    0x00, 0x43, 0x6f, 0x66, 0x66, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x32, 0x33,
+    0x00, 0x44, 0x65, 0x57, 0x69, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x36, 0x35, 0x00, 0x4d,
+    0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x37, 0x31, 0x33, 0x33, 0x00, 0x4f, 0x76, 0x65, 0x72, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x36, 0x31, 0x33, 0x33, 0x00, 0x4f, 0x73, 0x63, 0x65, 0x6f,
+    0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49,
+    0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x30, 0x31, 0x32, 0x31, 0x00, 0x50, 0x69, 0x74,
+    0x74, 0x73, 0x62, 0x75, 0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d,
+    0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x34, 0x37,
+    0x00, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x75, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x34, 0x37, 0x00, 0x46, 0x72,
+    0x65, 0x65, 0x62, 0x6f, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x31, 0x30,
+    0x33, 0x00, 0x4e, 0x6f, 0x78, 0x75, 0x62, 0x65, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73,
+    0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x30, 0x37, 0x33, 0x00, 0x43, 0x68, 0x65, 0x72, 0x6f, 0x6b, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31,
+    0x31, 0x34, 0x39, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x39, 0x31,
+    0x39, 0x37, 0x00, 0x57, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x31, 0x34, 0x33, 0x00,
+    0x52, 0x68, 0x65, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x34, 0x30, 0x30, 0x31, 0x00, 0x41,
+    0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6e, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61,
+    0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x38,
+    0x35, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6d, 0x6f, 0x6e, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x31, 0x31, 0x38, 0x35, 0x00, 0x4f, 0x6c, 0x64, 0x68, 0x61, 0x6d, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x38, 0x31, 0x35, 0x39, 0x00, 0x57, 0x69, 0x6e, 0x73, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x37, 0x31, 0x34, 0x39, 0x00, 0x52, 0x75, 0x74, 0x68,
+    0x65, 0x72, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65,
+    0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30, 0x31, 0x37,
+    0x00, 0x42, 0x72, 0x65, 0x6d, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30, 0x35, 0x31, 0x00, 0x4d, 0x75,
+    0x6c, 0x74, 0x6e, 0x6f, 0x6d, 0x61, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x32, 0x31, 0x32, 0x35, 0x00,
+    0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x31, 0x33, 0x00, 0x41, 0x72, 0x6c,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x33, 0x31,
+    0x00, 0x44, 0x65, 0x20, 0x53, 0x6f, 0x74, 0x6f, 0x20, 0x50, 0x61, 0x72,
+    0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39,
+    0x31, 0x30, 0x37, 0x00, 0x4b, 0x65, 0x6f, 0x6b, 0x75, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x35, 0x31,
+    0x00, 0x53, 0x63, 0x72, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x35,
+    0x39, 0x00, 0x4d, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x39, 0x30, 0x31, 0x31, 0x00, 0x42, 0x65, 0x6e, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00,
+    0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36,
+    0x30, 0x32, 0x33, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63,
+    0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35,
+    0x31, 0x37, 0x32, 0x30, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x20,
+    0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x32,
+    0x31, 0x33, 0x30, 0x00, 0x4b, 0x65, 0x74, 0x63, 0x68, 0x69, 0x6b, 0x61,
+    0x6e, 0x20, 0x47, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x20, 0x42, 0x6f,
+    0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x33, 0x35, 0x30,
+    0x33, 0x33, 0x00, 0x4d, 0x6f, 0x72, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65,
+    0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x39,
+    0x30, 0x37, 0x31, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d,
+    0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x32, 0x30, 0x34, 0x33, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74,
+    0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c,
+    0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x34, 0x30, 0x34, 0x33, 0x00, 0x4c, 0x69, 0x6e, 0x63,
+    0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31,
+    0x31, 0x33, 0x00, 0x4d, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x37, 0x30, 0x35, 0x33, 0x00, 0x46, 0x6f, 0x72,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00,
+    0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x37, 0x30, 0x30, 0x31, 0x00, 0x41, 0x6c, 0x61, 0x6d,
+    0x61, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x38, 0x30, 0x39, 0x39, 0x00, 0x57, 0x61, 0x6c, 0x73, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x32, 0x30, 0x37, 0x35, 0x00, 0x4c, 0x65, 0x62,
+    0x61, 0x6e, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61,
+    0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30,
+    0x39, 0x37, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30,
+    0x32, 0x33, 0x00, 0x42, 0x6f, 0x74, 0x65, 0x74, 0x6f, 0x75, 0x72, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x31, 0x31, 0x37, 0x31, 0x00, 0x53, 0x68, 0x65, 0x6e, 0x61,
+    0x6e, 0x64, 0x6f, 0x61, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x36, 0x31, 0x00,
+    0x48, 0x61, 0x72, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x33,
+    0x35, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31,
+    0x30, 0x39, 0x31, 0x00, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x61, 0x6e, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x30, 0x30, 0x34, 0x35, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c,
+    0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x31, 0x30, 0x35, 0x39, 0x00, 0x46, 0x69, 0x6c, 0x6c, 0x6d,
+    0x6f, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x35, 0x37, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59,
+    0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30,
+    0x30, 0x35, 0x00, 0x41, 0x74, 0x63, 0x68, 0x69, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37,
+    0x31, 0x34, 0x37, 0x00, 0x52, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x30, 0x34, 0x33, 0x00, 0x42, 0x72, 0x65, 0x77,
+    0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x35, 0x31, 0x31, 0x37, 0x00, 0x50, 0x72, 0x61, 0x69,
+    0x72, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x31, 0x35, 0x37, 0x00, 0x54, 0x75,
+    0x73, 0x63, 0x6f, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x36, 0x31, 0x00,
+    0x48, 0x61, 0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44,
+    0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x34,
+    0x38, 0x30, 0x36, 0x31, 0x00, 0x43, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31,
+    0x30, 0x37, 0x37, 0x00, 0x47, 0x61, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x32, 0x30, 0x37, 0x33, 0x00, 0x4c, 0x61, 0x77, 0x72, 0x65,
+    0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50,
+    0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e,
+    0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x33,
+    0x37, 0x00, 0x45, 0x64, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x31, 0x31,
+    0x00, 0x42, 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f,
+    0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x32, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x33, 0x37, 0x00, 0x44, 0x75, 0x62,
+    0x6f, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x34, 0x33, 0x00, 0x4f, 0x73, 0x63,
+    0x65, 0x6f, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x32, 0x30, 0x30, 0x35, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c,
+    0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56,
+    0x00, 0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38,
+    0x00, 0x35, 0x30, 0x30, 0x32, 0x35, 0x00, 0x57, 0x69, 0x6e, 0x64, 0x68,
+    0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54,
+    0x00, 0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x35, 0x30, 0x36, 0x33, 0x00, 0x4c, 0x65, 0x78, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x32, 0x30, 0x38, 0x35, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46,
+    0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x36, 0x30, 0x39, 0x33, 0x00, 0x4d, 0x65, 0x61, 0x64, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x37, 0x00, 0x32, 0x37, 0x30, 0x37, 0x35, 0x00, 0x4c, 0x61,
+    0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x33, 0x33, 0x00, 0x43, 0x6f,
+    0x6d, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31, 0x33, 0x39, 0x00, 0x4c,
+    0x69, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39,
+    0x30, 0x32, 0x33, 0x00, 0x42, 0x75, 0x74, 0x6c, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x36, 0x37,
+    0x00, 0x50, 0x61, 0x72, 0x6b, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x31, 0x39, 0x00, 0x46,
+    0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x30, 0x39, 0x30, 0x31,
+    0x35, 0x00, 0x57, 0x69, 0x6e, 0x64, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x54, 0x00, 0x43, 0x6f, 0x6e, 0x6e,
+    0x65, 0x63, 0x74, 0x69, 0x63, 0x75, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x38, 0x33, 0x31, 0x35, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x31, 0x36, 0x35, 0x00, 0x4d, 0x65, 0x6e, 0x69, 0x66, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x33, 0x30, 0x34, 0x33, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f,
+    0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x39, 0x31, 0x30, 0x39, 0x00,
+    0x4b, 0x6f, 0x73, 0x73, 0x75, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x33, 0x35, 0x00, 0x43, 0x72,
+    0x61, 0x69, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x33, 0x37, 0x00, 0x43, 0x68,
+    0x61, 0x72, 0x6c, 0x6f, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x32,
+    0x39, 0x00, 0x53, 0x74, 0x65, 0x70, 0x68, 0x65, 0x6e, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x39,
+    0x33, 0x00, 0x53, 0x69, 0x6c, 0x76, 0x65, 0x72, 0x20, 0x42, 0x6f, 0x77,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d,
+    0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00,
+    0x35, 0x34, 0x30, 0x38, 0x33, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6c,
+    0x70, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x30, 0x37,
+    0x38, 0x00, 0x4d, 0x65, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69,
+    0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x31, 0x31, 0x38, 0x33, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x37, 0x30, 0x36, 0x33, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x30, 0x39, 0x00, 0x42, 0x61,
+    0x63, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f,
+    0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x30, 0x36, 0x30, 0x35, 0x33, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x65, 0x72, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e,
+    0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x39, 0x31, 0x36,
+    0x31, 0x00, 0x50, 0x68, 0x65, 0x6c, 0x70, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75,
+    0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30,
+    0x36, 0x37, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x39, 0x31, 0x31, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x38,
+    0x39, 0x00, 0x48, 0x61, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x35, 0x37, 0x00, 0x53, 0x74,
+    0x65, 0x70, 0x68, 0x65, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31, 0x36, 0x37, 0x00,
+    0x50, 0x6f, 0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x37, 0x31, 0x00, 0x4f,
+    0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b,
+    0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x30, 0x34, 0x37, 0x00,
+    0x43, 0x72, 0x61, 0x77, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30, 0x38, 0x35, 0x00, 0x4c,
+    0x79, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x32, 0x30,
+    0x39, 0x31, 0x00, 0x4f, 0x6b, 0x61, 0x6c, 0x6f, 0x6f, 0x73, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c,
+    0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x39, 0x31, 0x35, 0x33, 0x00, 0x4f, 0x7a, 0x61, 0x72, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x31, 0x30, 0x39, 0x00, 0x43, 0x75, 0x6c, 0x62, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x38, 0x30, 0x30, 0x39, 0x00, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x66,
+    0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x30, 0x30, 0x33, 0x33, 0x00, 0x43, 0x6f, 0x74,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x35, 0x35, 0x00, 0x46, 0x6f,
+    0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x38, 0x30, 0x37, 0x33, 0x00, 0x4c, 0x61, 0x6d, 0x61, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d,
+    0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x37, 0x31, 0x30, 0x37, 0x00, 0x4c, 0x6f, 0x67, 0x61, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x38, 0x30, 0x31, 0x33, 0x00, 0x42, 0x75, 0x72, 0x6b, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x37, 0x35, 0x00, 0x47,
+    0x65, 0x6e, 0x74, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x35, 0x30, 0x31, 0x33, 0x00,
+    0x44, 0x6f, 0x6e, 0x61, 0x20, 0x41, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d,
+    0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35,
+    0x31, 0x31, 0x30, 0x37, 0x00, 0x4c, 0x6f, 0x75, 0x64, 0x6f, 0x75, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x36, 0x30, 0x32, 0x33, 0x00, 0x48, 0x75, 0x6d, 0x62, 0x6f,
+    0x6c, 0x64, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x31, 0x31, 0x39, 0x33, 0x00,
+    0x50, 0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x32, 0x30, 0x33, 0x00,
+    0x57, 0x69, 0x63, 0x68, 0x69, 0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x30, 0x35, 0x33, 0x00,
+    0x45, 0x73, 0x63, 0x61, 0x6d, 0x62, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x34,
+    0x39, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x50, 0x61,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69,
+    0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x32, 0x30, 0x32, 0x35, 0x00, 0x43, 0x61, 0x72, 0x62, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65,
+    0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x32, 0x30, 0x32, 0x33, 0x00, 0x4e, 0x79,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00,
+    0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00,
+    0x33, 0x32, 0x30, 0x33, 0x31, 0x00, 0x57, 0x61, 0x73, 0x68, 0x6f, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00, 0x4e,
+    0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00, 0x33,
+    0x31, 0x31, 0x32, 0x37, 0x00, 0x4e, 0x65, 0x6d, 0x61, 0x68, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65,
+    0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00,
+    0x34, 0x38, 0x31, 0x32, 0x31, 0x00, 0x44, 0x65, 0x6e, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39,
+    0x31, 0x36, 0x33, 0x00, 0x56, 0x69, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x32, 0x39,
+    0x00, 0x43, 0x6c, 0x65, 0x61, 0x72, 0x77, 0x61, 0x74, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x39, 0x30, 0x38, 0x31, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x38, 0x30, 0x39, 0x39, 0x00, 0x50, 0x72, 0x6f, 0x77, 0x65,
+    0x72, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f,
+    0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x34, 0x39, 0x30, 0x30, 0x35, 0x00, 0x43, 0x61, 0x63,
+    0x68, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54,
+    0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33,
+    0x31, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x39, 0x31, 0x31, 0x31, 0x00, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x35, 0x30, 0x31, 0x31, 0x00, 0x42, 0x61, 0x72, 0x6e, 0x77, 0x65, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x33,
+    0x35, 0x00, 0x46, 0x75, 0x6c, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59,
+    0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30,
+    0x36, 0x35, 0x00, 0x49, 0x7a, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30,
+    0x31, 0x39, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x37, 0x35,
+    0x00, 0x52, 0x65, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x38, 0x31, 0x30, 0x39, 0x00, 0x53, 0x61, 0x67, 0x75,
+    0x61, 0x63, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x36, 0x30, 0x33, 0x37, 0x00, 0x44,
+    0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x38, 0x39,
+    0x00, 0x4f, 0x74, 0x65, 0x72, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x31, 0x32, 0x31, 0x37,
+    0x00, 0x54, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63,
+    0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x30, 0x37,
+    0x31, 0x00, 0x47, 0x61, 0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x39, 0x30, 0x30, 0x37, 0x00, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x73,
+    0x65, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x54,
+    0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x63, 0x75, 0x74,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x31, 0x31, 0x00,
+    0x4f, 0x74, 0x74, 0x65, 0x72, 0x20, 0x54, 0x61, 0x69, 0x6c, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x33, 0x37, 0x35, 0x00, 0x50, 0x6f, 0x74, 0x74, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37,
+    0x30, 0x34, 0x31, 0x00, 0x44, 0x65, 0x4b, 0x61, 0x6c, 0x62, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x38, 0x30, 0x31, 0x31, 0x00, 0x41, 0x72, 0x6d, 0x73, 0x74, 0x72, 0x6f,
+    0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x33, 0x33, 0x31, 0x00, 0x4d, 0x69, 0x6c, 0x61, 0x6d, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30,
+    0x30, 0x39, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f,
+    0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x69, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x30, 0x30, 0x37, 0x37, 0x00, 0x4c, 0x61, 0x74, 0x69, 0x6d, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f,
+    0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x33, 0x33, 0x33, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30,
+    0x31, 0x34, 0x31, 0x00, 0x4f, 0x73, 0x62, 0x6f, 0x72, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37,
+    0x30, 0x31, 0x37, 0x00, 0x42, 0x6c, 0x61, 0x64, 0x65, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x38, 0x31, 0x00, 0x57,
+    0x61, 0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x32, 0x30, 0x31, 0x33, 0x00, 0x43, 0x61, 0x6c, 0x68,
+    0x6f, 0x75, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46,
+    0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x30, 0x35, 0x00, 0x4d, 0x65, 0x69,
+    0x67, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48,
+    0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x37, 0x31, 0x36, 0x39, 0x00, 0x53, 0x74, 0x6f, 0x6b, 0x65, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x31, 0x32, 0x33, 0x00,
+    0x56, 0x65, 0x72, 0x6e, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30,
+    0x31, 0x31, 0x00, 0x43, 0x6f, 0x6f, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x31, 0x30, 0x38, 0x35, 0x00,
+    0x48, 0x61, 0x79, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x35, 0x31, 0x00,
+    0x43, 0x68, 0x61, 0x74, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x31, 0x34, 0x33,
+    0x00, 0x52, 0x6f, 0x73, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63,
+    0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x39, 0x30, 0x39, 0x33, 0x00, 0x49, 0x72, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x30, 0x37, 0x35, 0x00, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x73,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x35, 0x30, 0x33, 0x31, 0x00, 0x4d, 0x63, 0x4b, 0x69, 0x6e, 0x6c, 0x65,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x31, 0x32, 0x30, 0x33, 0x39, 0x00, 0x47, 0x61,
+    0x64, 0x73, 0x64, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31, 0x32, 0x33, 0x00, 0x4d,
+    0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x34, 0x35, 0x00,
+    0x45, 0x64, 0x67, 0x61, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x38, 0x37, 0x00,
+    0x53, 0x74, 0x61, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30, 0x35, 0x39, 0x00,
+    0x44, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x37, 0x33, 0x00,
+    0x47, 0x61, 0x73, 0x63, 0x6f, 0x6e, 0x61, 0x64, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x39,
+    0x30, 0x33, 0x35, 0x00, 0x53, 0x61, 0x6c, 0x74, 0x20, 0x4c, 0x61, 0x6b,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00,
+    0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33,
+    0x32, 0x31, 0x35, 0x00, 0x4d, 0x75, 0x73, 0x63, 0x6f, 0x67, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x38, 0x30, 0x35, 0x37, 0x00, 0x4d, 0x65, 0x72, 0x63, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x38, 0x31, 0x00, 0x54,
+    0x65, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x32, 0x30, 0x38, 0x35, 0x00, 0x4d, 0x65, 0x72, 0x63,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41,
+    0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x30, 0x38, 0x35,
+    0x00, 0x4c, 0x6f, 0x76, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x35, 0x31, 0x00,
+    0x4f, 0x73, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x31, 0x33, 0x00,
+    0x48, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x35, 0x39,
+    0x00, 0x48, 0x61, 0x72, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f,
+    0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x33,
+    0x31, 0x00, 0x44, 0x65, 0x63, 0x61, 0x74, 0x75, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x35, 0x30,
+    0x36, 0x39, 0x00, 0x4d, 0x61, 0x72, 0x6c, 0x62, 0x6f, 0x72, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x31, 0x31, 0x33, 0x00,
+    0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x39,
+    0x33, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x33,
+    0x35, 0x00, 0x4f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x39, 0x30, 0x38, 0x37, 0x00, 0x48, 0x65, 0x6e,
+    0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x37, 0x31, 0x38, 0x35, 0x00, 0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x35, 0x31, 0x00,
+    0x4c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x32, 0x30, 0x33, 0x37,
+    0x00, 0x45, 0x61, 0x73, 0x74, 0x20, 0x46, 0x65, 0x6c, 0x69, 0x63, 0x69,
+    0x61, 0x6e, 0x61, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c,
+    0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x35, 0x39, 0x00, 0x52,
+    0x69, 0x63, 0x68, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f,
+    0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x38,
+    0x37, 0x00, 0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x31, 0x31, 0x37,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20,
+    0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f,
+    0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x32, 0x36, 0x35, 0x00, 0x4b, 0x65, 0x72, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x30,
+    0x38, 0x33, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x30,
+    0x35, 0x35, 0x00, 0x43, 0x61, 0x6c, 0x64, 0x77, 0x65, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30,
+    0x31, 0x31, 0x00, 0x42, 0x61, 0x6e, 0x6b, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x37, 0x37,
+    0x30, 0x00, 0x52, 0x6f, 0x61, 0x6e, 0x6f, 0x6b, 0x65, 0x20, 0x63, 0x69,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30, 0x30,
+    0x39, 0x00, 0x42, 0x61, 0x72, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x39, 0x39,
+    0x00, 0x48, 0x61, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x36, 0x33, 0x00,
+    0x46, 0x6c, 0x6f, 0x79, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x30, 0x39, 0x37, 0x00,
+    0x4d, 0x61, 0x79, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30, 0x37, 0x35, 0x00,
+    0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x38,
+    0x30, 0x37, 0x31, 0x00, 0x52, 0x61, 0x6d, 0x73, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x35, 0x35, 0x00, 0x47, 0x72, 0x65,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b,
+    0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x31, 0x30, 0x34, 0x37, 0x00, 0x4d, 0x61, 0x72,
+    0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x37, 0x30, 0x38, 0x39, 0x00, 0x4a, 0x65, 0x66, 0x66,
+    0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x33, 0x33, 0x00,
+    0x47, 0x6f, 0x6c, 0x64, 0x65, 0x6e, 0x20, 0x56, 0x61, 0x6c, 0x6c, 0x65,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x31, 0x35, 0x33, 0x00,
+    0x57, 0x6f, 0x6f, 0x64, 0x77, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30,
+    0x32, 0x37, 0x00, 0x43, 0x6f, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x34, 0x38, 0x37, 0x00, 0x57, 0x69, 0x6c, 0x62, 0x61, 0x72, 0x67,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x35, 0x35, 0x30, 0x32, 0x31, 0x00, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62,
+    0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49,
+    0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x36, 0x31, 0x00, 0x52,
+    0x75, 0x74, 0x68, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x31, 0x34, 0x35, 0x00, 0x53, 0x68,
+    0x65, 0x6c, 0x62, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x31, 0x33, 0x00, 0x42, 0x75,
+    0x74, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x37, 0x35, 0x00, 0x54, 0x72,
+    0x61, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x33, 0x39, 0x00, 0x4f,
+    0x73, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x37, 0x33, 0x00, 0x46, 0x72, 0x61,
+    0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36, 0x30, 0x30, 0x39, 0x00,
+    0x43, 0x61, 0x6c, 0x61, 0x76, 0x65, 0x72, 0x61, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69,
+    0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x32, 0x38, 0x30, 0x39, 0x37, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f,
+    0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x38, 0x31, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30, 0x33, 0x31, 0x00, 0x43, 0x6f,
+    0x66, 0x66, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x30, 0x35, 0x00, 0x41, 0x73, 0x68,
+    0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x37, 0x30, 0x37, 0x37, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20,
+    0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x57, 0x6f, 0x6f, 0x64, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d,
+    0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x31, 0x30, 0x39, 0x39, 0x00, 0x4b, 0x69, 0x6e, 0x67,
+    0x20, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x31,
+    0x35, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x37, 0x33, 0x00, 0x50, 0x6c,
+    0x65, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x31, 0x30, 0x32, 0x33, 0x00, 0x42, 0x72, 0x61, 0x63, 0x6b,
+    0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59,
+    0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x36, 0x39, 0x00, 0x4a, 0x6f, 0x68,
+    0x6e, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x31, 0x35, 0x00,
+    0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x37, 0x31, 0x38, 0x31, 0x00, 0x56, 0x61, 0x6e,
+    0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32,
+    0x35, 0x39, 0x00, 0x53, 0x74, 0x65, 0x77, 0x61, 0x72, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31,
+    0x30, 0x39, 0x39, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61,
+    0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33,
+    0x30, 0x38, 0x37, 0x00, 0x44, 0x65, 0x63, 0x61, 0x74, 0x75, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x31, 0x30, 0x30, 0x39, 0x00, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x69,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00,
+    0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x34, 0x39, 0x30, 0x34, 0x37, 0x00, 0x55, 0x69, 0x6e, 0x74, 0x61, 0x68,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55,
+    0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x30,
+    0x32, 0x35, 0x00, 0x42, 0x72, 0x75, 0x6e, 0x73, 0x77, 0x69, 0x63, 0x6b,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x38, 0x31, 0x33, 0x39, 0x00, 0x54, 0x69, 0x70, 0x70, 0x61,
+    0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x33, 0x30, 0x36, 0x31, 0x00, 0x53, 0x6e, 0x6f, 0x68,
+    0x6f, 0x6d, 0x69, 0x73, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x30, 0x31,
+    0x32, 0x35, 0x00, 0x50, 0x6f, 0x74, 0x74, 0x61, 0x77, 0x61, 0x74, 0x6f,
+    0x6d, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x32, 0x33, 0x00, 0x43, 0x72,
+    0x61, 0x77, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30,
+    0x36, 0x39, 0x00, 0x49, 0x6f, 0x73, 0x63, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69,
+    0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31,
+    0x35, 0x35, 0x00, 0x50, 0x6f, 0x74, 0x74, 0x61, 0x77, 0x61, 0x74, 0x74,
+    0x61, 0x6d, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x34, 0x30, 0x30, 0x33, 0x00, 0x43, 0x6f, 0x63, 0x68, 0x69,
+    0x73, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a,
+    0x00, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x33, 0x36, 0x31, 0x31, 0x33, 0x00, 0x57, 0x61, 0x72, 0x72,
+    0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x35, 0x31, 0x00, 0x47, 0x72, 0x61,
+    0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x30, 0x36, 0x39,
+    0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x36, 0x30, 0x35, 0x39, 0x00, 0x4c,
+    0x65, 0x6d, 0x68, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x35, 0x30, 0x33, 0x37, 0x00, 0x45, 0x64, 0x67, 0x65,
+    0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x31, 0x31, 0x34, 0x33, 0x00, 0x4c, 0x79, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x36, 0x30, 0x30, 0x39, 0x00, 0x43, 0x61, 0x74, 0x74, 0x61, 0x72, 0x61,
+    0x75, 0x67, 0x75, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x30, 0x31, 0x39, 0x00, 0x42,
+    0x61, 0x6e, 0x64, 0x65, 0x72, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x38, 0x37, 0x00, 0x4d, 0x61,
+    0x68, 0x6e, 0x6f, 0x6d, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x34,
+    0x31, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37,
+    0x30, 0x39, 0x37, 0x00, 0x49, 0x72, 0x65, 0x64, 0x65, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x39, 0x35, 0x00,
+    0x54, 0x72, 0x65, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x37, 0x39, 0x30, 0x00, 0x53, 0x74,
+    0x61, 0x75, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31, 0x35, 0x37, 0x00, 0x52,
+    0x6f, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x36, 0x30, 0x32, 0x31, 0x00, 0x4c, 0x61,
+    0x72, 0x61, 0x6d, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x36, 0x30, 0x30, 0x00, 0x46,
+    0x61, 0x69, 0x72, 0x66, 0x61, 0x78, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x30, 0x33, 0x00, 0x42,
+    0x61, 0x6b, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x33, 0x39, 0x00, 0x44, 0x65,
+    0x75, 0x65, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x39,
+    0x35, 0x00, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x20, 0x43, 0x69, 0x74, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x36, 0x30, 0x36, 0x33, 0x00, 0x50, 0x6c, 0x75, 0x6d, 0x61,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00,
+    0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x32, 0x30, 0x30, 0x36, 0x39, 0x00, 0x47, 0x72,
+    0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x31, 0x39, 0x31, 0x00, 0x48, 0x61, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31,
+    0x39, 0x35, 0x00, 0x57, 0x69, 0x73, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x31, 0x34,
+    0x33, 0x00, 0x54, 0x75, 0x6c, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f,
+    0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x34,
+    0x35, 0x00, 0x49, 0x62, 0x65, 0x72, 0x69, 0x61, 0x20, 0x50, 0x61, 0x72,
+    0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33,
+    0x30, 0x33, 0x35, 0x00, 0x4b, 0x69, 0x74, 0x73, 0x61, 0x70, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73,
+    0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x35, 0x30, 0x30, 0x35, 0x00, 0x41, 0x6c, 0x6c, 0x65,
+    0x6e, 0x64, 0x61, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x32, 0x30, 0x34, 0x37, 0x00, 0x45, 0x6c, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e,
+    0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x38, 0x32, 0x37, 0x35, 0x00, 0x4b, 0x6e, 0x6f, 0x78,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31,
+    0x30, 0x37, 0x39, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x38, 0x31, 0x30, 0x33, 0x00, 0x4d, 0x69, 0x61, 0x6d, 0x69, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39,
+    0x30, 0x37, 0x39, 0x00, 0x47, 0x72, 0x75, 0x6e, 0x64, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x37, 0x31, 0x33, 0x39, 0x00, 0x50, 0x61, 0x73, 0x71, 0x75, 0x6f, 0x74,
+    0x61, 0x6e, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32,
+    0x30, 0x36, 0x35, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00,
+    0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61,
+    0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x32, 0x35, 0x00,
+    0x43, 0x6c, 0x61, 0x69, 0x62, 0x6f, 0x72, 0x6e, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37,
+    0x31, 0x37, 0x33, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x62, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x34, 0x30, 0x30, 0x39, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x52,
+    0x49, 0x00, 0x52, 0x68, 0x6f, 0x64, 0x65, 0x20, 0x49, 0x73, 0x6c, 0x61,
+    0x6e, 0x64, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x31,
+    0x35, 0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62,
+    0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30,
+    0x38, 0x37, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f,
+    0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x35,
+    0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x37, 0x31, 0x32, 0x39, 0x00, 0x4d, 0x65, 0x6e, 0x61, 0x72, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x37, 0x30, 0x39, 0x33, 0x00, 0x4b, 0x6e, 0x6f, 0x78, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65,
+    0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x31, 0x31, 0x36, 0x37, 0x00, 0x4d, 0x65, 0x72, 0x63, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x31, 0x31, 0x37, 0x39, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37,
+    0x00, 0x33, 0x38, 0x30, 0x39, 0x31, 0x00, 0x53, 0x74, 0x65, 0x65, 0x6c,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x39, 0x31, 0x00,
+    0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x32,
+    0x35, 0x00, 0x44, 0x61, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31,
+    0x36, 0x31, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x64, 0x61, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65,
+    0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00,
+    0x35, 0x34, 0x31, 0x30, 0x39, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e,
+    0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00,
+    0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x31, 0x33, 0x33,
+    0x00, 0x53, 0x65, 0x6d, 0x69, 0x6e, 0x6f, 0x6c, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61,
+    0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36,
+    0x31, 0x30, 0x35, 0x00, 0x4d, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68,
+    0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x34,
+    0x35, 0x31, 0x30, 0x00, 0x42, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x6f, 0x72,
+    0x65, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61,
+    0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x39, 0x30, 0x32, 0x35, 0x00, 0x43, 0x6c, 0x65, 0x72, 0x6d, 0x6f,
+    0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48,
+    0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x32, 0x30, 0x38, 0x37, 0x00, 0x4d, 0x69, 0x66, 0x66, 0x6c, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x33, 0x30, 0x30, 0x39, 0x00, 0x48,
+    0x61, 0x6e, 0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30,
+    0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x33, 0x39, 0x00, 0x45, 0x6c,
+    0x6b, 0x68, 0x61, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x35, 0x37, 0x00, 0x46,
+    0x6f, 0x72, 0x74, 0x20, 0x42, 0x65, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30, 0x31, 0x35, 0x00,
+    0x43, 0x75, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x30, 0x31, 0x30, 0x36, 0x31, 0x00, 0x47, 0x65,
+    0x6e, 0x65, 0x76, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x35, 0x33, 0x00, 0x50, 0x69,
+    0x65, 0x72, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x38, 0x32, 0x39,
+    0x39, 0x00, 0x4c, 0x6c, 0x61, 0x6e, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x35, 0x33, 0x00, 0x4a,
+    0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30,
+    0x31, 0x39, 0x00, 0x43, 0x61, 0x76, 0x61, 0x6c, 0x69, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x33, 0x31, 0x00, 0x50, 0x61,
+    0x73, 0x73, 0x61, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73,
+    0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x38,
+    0x39, 0x00, 0x4c, 0x65, 0x65, 0x6c, 0x61, 0x6e, 0x61, 0x75, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63,
+    0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x32, 0x30, 0x31, 0x31, 0x00, 0x45, 0x75, 0x72, 0x65, 0x6b, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00, 0x4e, 0x65,
+    0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x31,
+    0x30, 0x30, 0x37, 0x00, 0x42, 0x61, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x37, 0x30, 0x31, 0x35, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x31, 0x39, 0x35, 0x00, 0x48, 0x61, 0x6e, 0x73, 0x66,
+    0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x34, 0x30, 0x33, 0x33, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31,
+    0x37, 0x31, 0x00, 0x55, 0x6e, 0x69, 0x63, 0x6f, 0x69, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30,
+    0x31, 0x30, 0x33, 0x00, 0x4e, 0x6f, 0x62, 0x6c, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61,
+    0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x32,
+    0x30, 0x30, 0x39, 0x00, 0x45, 0x73, 0x6d, 0x65, 0x72, 0x61, 0x6c, 0x64,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00,
+    0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00,
+    0x30, 0x38, 0x30, 0x36, 0x37, 0x00, 0x4c, 0x61, 0x20, 0x50, 0x6c, 0x61,
+    0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f,
+    0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x34, 0x38, 0x31, 0x36, 0x37, 0x00, 0x47, 0x61, 0x6c,
+    0x76, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x30, 0x33, 0x31, 0x00, 0x43, 0x68,
+    0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x33, 0x30, 0x32, 0x37, 0x00, 0x57,
+    0x61, 0x6c, 0x64, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x39, 0x30, 0x35, 0x37, 0x00, 0x57, 0x65, 0x62, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00,
+    0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x36,
+    0x31, 0x31, 0x31, 0x00, 0x56, 0x65, 0x6e, 0x74, 0x75, 0x72, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61,
+    0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x36, 0x31, 0x32, 0x31, 0x00, 0x54, 0x6f, 0x64, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53,
+    0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x37, 0x30, 0x31, 0x39, 0x00, 0x43,
+    0x68, 0x61, 0x6d, 0x70, 0x61, 0x69, 0x67, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e,
+    0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30,
+    0x39, 0x33, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x73, 0x73, 0x69, 0x70,
+    0x70, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52,
+    0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x37, 0x33, 0x00, 0x53, 0x6d, 0x79,
+    0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x37, 0x33, 0x00, 0x49, 0x73, 0x61,
+    0x62, 0x65, 0x6c, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x30, 0x34, 0x33, 0x00,
+    0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73,
+    0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x36,
+    0x37, 0x00, 0x49, 0x6f, 0x6e, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x38,
+    0x31, 0x00, 0x54, 0x6f, 0x77, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x30, 0x35, 0x37,
+    0x00, 0x4a, 0x75, 0x6e, 0x65, 0x61, 0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30,
+    0x30, 0x37, 0x35, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x35, 0x30, 0x38, 0x37, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x38, 0x35, 0x00, 0x48,
+    0x61, 0x6e, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x39, 0x33,
+    0x00, 0x4c, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x38, 0x30, 0x37, 0x39, 0x00, 0x43, 0x6f, 0x63, 0x68, 0x72, 0x61,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x31, 0x30, 0x37, 0x35, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x37, 0x31, 0x34, 0x37, 0x00, 0x50, 0x69, 0x61, 0x74, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35,
+    0x35, 0x30, 0x33, 0x37, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x65, 0x6e, 0x63,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00,
+    0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x39, 0x37, 0x00, 0x43, 0x6f,
+    0x6f, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x35, 0x30, 0x37, 0x37, 0x00, 0x4d, 0x61, 0x72, 0x71, 0x75,
+    0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69,
+    0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x39, 0x33,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x6d, 0x6f, 0x72, 0x65, 0x6c, 0x61, 0x6e,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x30, 0x39, 0x30, 0x30, 0x39, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x48, 0x61, 0x76, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x54, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69,
+    0x63, 0x75, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38, 0x30,
+    0x32, 0x35, 0x00, 0x43, 0x72, 0x6f, 0x77, 0x6c, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c,
+    0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31,
+    0x37, 0x30, 0x32, 0x35, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36,
+    0x31, 0x30, 0x37, 0x00, 0x4d, 0x65, 0x63, 0x6f, 0x73, 0x74, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x37, 0x30, 0x36, 0x35, 0x00, 0x45, 0x64, 0x67, 0x65, 0x63, 0x6f,
+    0x6d, 0x62, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31,
+    0x30, 0x31, 0x33, 0x00, 0x42, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30,
+    0x38, 0x31, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x39, 0x31, 0x30, 0x37, 0x00, 0x4c, 0x61, 0x66, 0x61, 0x79, 0x65,
+    0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x39, 0x30, 0x31, 0x37, 0x00, 0x47, 0x61,
+    0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x31, 0x38, 0x30, 0x31, 0x31, 0x00, 0x42, 0x6f, 0x6f,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e,
+    0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x35, 0x30, 0x32, 0x37, 0x00, 0x44, 0x6f, 0x64, 0x67,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00,
+    0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x33, 0x37, 0x00, 0x4f, 0x72,
+    0x61, 0x6e, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x39, 0x39, 0x00, 0x50,
+    0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61,
+    0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30,
+    0x32, 0x31, 0x00, 0x42, 0x6f, 0x79, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x34, 0x30,
+    0x31, 0x31, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x6c, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72,
+    0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33,
+    0x31, 0x30, 0x32, 0x39, 0x00, 0x43, 0x68, 0x61, 0x73, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x33, 0x30, 0x35, 0x00, 0x4c, 0x79, 0x6e, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x39, 0x35,
+    0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61,
+    0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x32, 0x34, 0x35, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35,
+    0x31, 0x30, 0x33, 0x31, 0x00, 0x43, 0x61, 0x6d, 0x70, 0x62, 0x65, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x31, 0x31, 0x34, 0x35, 0x00, 0x50, 0x6f, 0x77, 0x68,
+    0x61, 0x74, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x34, 0x35, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x31, 0x30, 0x30, 0x39, 0x00, 0x42, 0x6c, 0x6f, 0x75,
+    0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c,
+    0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x31, 0x31, 0x35, 0x37, 0x00, 0x52, 0x61, 0x70, 0x70,
+    0x61, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x31,
+    0x35, 0x35, 0x00, 0x53, 0x68, 0x69, 0x61, 0x77, 0x61, 0x73, 0x73, 0x65,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00,
+    0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x38, 0x30, 0x38, 0x35, 0x00, 0x4b, 0x6f, 0x73, 0x63,
+    0x69, 0x75, 0x73, 0x6b, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x36, 0x33, 0x00, 0x52,
+    0x6f, 0x6f, 0x6b, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x33, 0x35, 0x00, 0x47, 0x6c, 0x61,
+    0x63, 0x69, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x33, 0x36, 0x35, 0x00, 0x50, 0x61,
+    0x6e, 0x6f, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x31, 0x30, 0x37, 0x33, 0x00, 0x47, 0x6c, 0x6f, 0x75,
+    0x63, 0x65, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x30, 0x39, 0x37,
+    0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x33,
+    0x31, 0x00, 0x44, 0x75, 0x76, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x38, 0x39,
+    0x00, 0x4c, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x31, 0x31, 0x37, 0x00, 0x57,
+    0x61, 0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x38, 0x33, 0x00, 0x48,
+    0x65, 0x6e, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x33, 0x30, 0x31, 0x31, 0x00, 0x48,
+    0x69, 0x6c, 0x6c, 0x73, 0x62, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x48, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68, 0x69, 0x72, 0x65, 0x00,
+    0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x30, 0x32, 0x35, 0x00, 0x42,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x37, 0x31, 0x30, 0x39, 0x00, 0x4d, 0x63, 0x4e, 0x61, 0x69, 0x72,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x31, 0x31, 0x38, 0x35, 0x00, 0x54, 0x61, 0x7a, 0x65,
+    0x77, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x35, 0x30, 0x38, 0x35, 0x00, 0x53,
+    0x75, 0x6d, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x32, 0x30, 0x38, 0x39, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x31, 0x32, 0x31, 0x00, 0x52,
+    0x61, 0x6e, 0x64, 0x6f, 0x6c, 0x70, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x35,
+    0x33, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x33, 0x35, 0x00, 0x45,
+    0x61, 0x73, 0x74, 0x20, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20,
+    0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f,
+    0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x31, 0x36, 0x33, 0x00, 0x46, 0x72, 0x69, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30,
+    0x32, 0x31, 0x00, 0x43, 0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x61, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x34, 0x30, 0x31, 0x32, 0x00, 0x4c, 0x61, 0x20, 0x50, 0x61,
+    0x7a, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a, 0x00,
+    0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x35, 0x34, 0x30, 0x34, 0x31, 0x00, 0x4c, 0x65, 0x77, 0x69, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x30, 0x33, 0x35, 0x00,
+    0x46, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70,
+    0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x32, 0x31,
+    0x35, 0x00, 0x53, 0x70, 0x65, 0x6e, 0x63, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38,
+    0x31, 0x31, 0x35, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x33, 0x30,
+    0x37, 0x00, 0x57, 0x65, 0x62, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30,
+    0x30, 0x33, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x36, 0x30, 0x30,
+    0x39, 0x00, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f,
+    0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x30,
+    0x31, 0x30, 0x35, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31,
+    0x32, 0x33, 0x35, 0x00, 0x57, 0x68, 0x69, 0x74, 0x6c, 0x65, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x39, 0x31, 0x36, 0x39, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x31, 0x30,
+    0x37, 0x00, 0x53, 0x63, 0x68, 0x75, 0x79, 0x6c, 0x6b, 0x69, 0x6c, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x37, 0x37, 0x00, 0x54,
+    0x69, 0x66, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x35, 0x30, 0x33, 0x33, 0x00, 0x44, 0x69, 0x6c,
+    0x6c, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32,
+    0x30, 0x33, 0x33, 0x00, 0x45, 0x61, 0x73, 0x74, 0x20, 0x42, 0x61, 0x74,
+    0x6f, 0x6e, 0x20, 0x52, 0x6f, 0x75, 0x67, 0x65, 0x20, 0x50, 0x61, 0x72,
+    0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37,
+    0x31, 0x35, 0x31, 0x00, 0x50, 0x6f, 0x70, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e,
+    0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x30,
+    0x39, 0x35, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x61, 0x6d, 0x70, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41,
+    0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x38, 0x33,
+    0x00, 0x47, 0x72, 0x65, 0x67, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x31, 0x33, 0x00, 0x4e, 0x6f,
+    0x62, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x35, 0x39, 0x00, 0x44, 0x61, 0x6c,
+    0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x35, 0x37, 0x00, 0x45, 0x73,
+    0x73, 0x65, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x36, 0x37, 0x00, 0x53, 0x69,
+    0x6f, 0x75, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x31, 0x31, 0x39, 0x35, 0x00, 0x50, 0x69, 0x6b, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x31, 0x30, 0x38, 0x31, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00,
+    0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x32, 0x30, 0x37, 0x39, 0x00, 0x4d, 0x61, 0x64, 0x69,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46,
+    0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x37, 0x30, 0x30, 0x35, 0x00, 0x42, 0x6f, 0x6e,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00,
+    0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x31, 0x39, 0x37, 0x00, 0x48, 0x61, 0x72, 0x64,
+    0x65, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x30, 0x31, 0x31, 0x39, 0x00, 0x4d, 0x65, 0x61, 0x64,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x37, 0x30, 0x33, 0x39, 0x00, 0x44, 0x65, 0x20, 0x57, 0x69, 0x74,
+    0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00,
+    0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x32, 0x30, 0x32, 0x33, 0x00, 0x43, 0x6f, 0x6c, 0x75,
+    0x6d, 0x62, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x31, 0x35, 0x00, 0x42, 0x65,
+    0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x30, 0x39, 0x00, 0x42,
+    0x72, 0x6f, 0x77, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x34, 0x31, 0x00, 0x4f,
+    0x2d, 0x42, 0x72, 0x69, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x30, 0x39, 0x00, 0x4d, 0x63, 0x4c,
+    0x65, 0x6e, 0x6e, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x33, 0x35, 0x00, 0x50, 0x75, 0x6c,
+    0x61, 0x73, 0x6b, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x36, 0x35, 0x00, 0x4a, 0x65,
+    0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31, 0x32, 0x33,
+    0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x30, 0x32, 0x33, 0x00,
+    0x43, 0x6c, 0x61, 0x72, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70,
+    0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x31, 0x39,
+    0x00, 0x43, 0x61, 0x72, 0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30,
+    0x35, 0x37, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x30,
+    0x30, 0x39, 0x33, 0x00, 0x4b, 0x65, 0x61, 0x72, 0x6e, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30,
+    0x35, 0x31, 0x00, 0x46, 0x75, 0x6c, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x32, 0x31, 0x35, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30, 0x35, 0x35, 0x00,
+    0x44, 0x65, 0x6c, 0x61, 0x77, 0x61, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x36, 0x31, 0x00, 0x48,
+    0x61, 0x73, 0x6b, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d,
+    0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31, 0x30, 0x33,
+    0x00, 0x4b, 0x65, 0x79, 0x61, 0x20, 0x50, 0x61, 0x68, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33,
+    0x39, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x31, 0x37,
+    0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x37, 0x31, 0x00, 0x4b,
+    0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b,
+    0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x39, 0x35, 0x00, 0x48, 0x79, 0x64,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x32,
+    0x37, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x36, 0x39,
+    0x00, 0x50, 0x65, 0x74, 0x72, 0x6f, 0x6c, 0x65, 0x75, 0x6d, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x36,
+    0x30, 0x34, 0x35, 0x00, 0x4d, 0x65, 0x6e, 0x64, 0x6f, 0x63, 0x69, 0x6e,
+    0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00,
+    0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x32, 0x38, 0x30, 0x31, 0x31, 0x00, 0x42, 0x6f,
+    0x6c, 0x69, 0x76, 0x61, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x30, 0x31, 0x00,
+    0x4b, 0x69, 0x6e, 0x67, 0x20, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x32, 0x31, 0x31, 0x30, 0x00, 0x4a, 0x75, 0x6e, 0x65, 0x61,
+    0x75, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x41, 0x4b,
+    0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39,
+    0x00, 0x33, 0x35, 0x30, 0x34, 0x33, 0x00, 0x53, 0x61, 0x6e, 0x64, 0x6f,
+    0x76, 0x61, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33, 0x32, 0x32, 0x35, 0x00,
+    0x50, 0x65, 0x61, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x31, 0x37, 0x00, 0x4d,
+    0x6f, 0x72, 0x72, 0x6f, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x37, 0x30, 0x30, 0x39, 0x00, 0x42, 0x6c, 0x6f, 0x75,
+    0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e,
+    0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x38, 0x30, 0x31, 0x37, 0x00, 0x43, 0x68, 0x69,
+    0x63, 0x6b, 0x61, 0x73, 0x61, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70,
+    0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x36, 0x37,
+    0x00, 0x54, 0x61, 0x74, 0x74, 0x6e, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x31,
+    0x30, 0x31, 0x00, 0x4d, 0x61, 0x6e, 0x69, 0x73, 0x74, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x33, 0x30, 0x38, 0x31, 0x00, 0x43, 0x72, 0x69, 0x73, 0x70, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x33, 0x33, 0x31, 0x37, 0x00, 0x57, 0x69, 0x6c, 0x6b, 0x65, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x32, 0x30, 0x30, 0x31, 0x00, 0x41, 0x6c, 0x61, 0x63, 0x68, 0x75, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46,
+    0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x34, 0x30, 0x35, 0x31, 0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x31, 0x39,
+    0x37, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x30, 0x39,
+    0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x32, 0x31, 0x32, 0x39, 0x00, 0x57, 0x65, 0x73, 0x74, 0x6d,
+    0x6f, 0x72, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79,
+    0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x33, 0x30, 0x31, 0x33, 0x00, 0x4d, 0x65, 0x72, 0x72, 0x69, 0x6d,
+    0x61, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x48, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68,
+    0x69, 0x72, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30,
+    0x34, 0x35, 0x00, 0x46, 0x69, 0x6c, 0x6c, 0x6d, 0x6f, 0x72, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x30, 0x39, 0x31, 0x00, 0x43, 0x6f, 0x6d, 0x61, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38,
+    0x30, 0x33, 0x31, 0x00, 0x43, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x36, 0x30, 0x39, 0x31, 0x00, 0x53, 0x69, 0x65, 0x72,
+    0x72, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41,
+    0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00,
+    0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x38, 0x31, 0x35, 0x31, 0x00, 0x46,
+    0x69, 0x73, 0x68, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x37, 0x37, 0x00, 0x57, 0x61, 0x73,
+    0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x39, 0x31, 0x00, 0x44,
+    0x6f, 0x64, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x36, 0x39, 0x00, 0x56, 0x69,
+    0x63, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x31, 0x31, 0x33, 0x00, 0x4f, 0x73,
+    0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x35, 0x39, 0x00, 0x47, 0x72,
+    0x65, 0x65, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x32, 0x31, 0x37, 0x00, 0x56,
+    0x65, 0x72, 0x6e, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x31, 0x31, 0x31, 0x00,
+    0x53, 0x61, 0x75, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69,
+    0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x30, 0x36, 0x31,
+    0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72,
+    0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x34, 0x39, 0x35, 0x00, 0x57, 0x69, 0x6e, 0x6b, 0x6c, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30,
+    0x30, 0x37, 0x00, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x77, 0x61, 0x74, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37,
+    0x00, 0x32, 0x30, 0x30, 0x36, 0x35, 0x00, 0x47, 0x72, 0x61, 0x68, 0x61,
+    0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x35, 0x30, 0x32, 0x31, 0x00, 0x43, 0x68, 0x65, 0x72, 0x6f, 0x6b,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30,
+    0x36, 0x31, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x36, 0x30, 0x30,
+    0x33, 0x00, 0x42, 0x69, 0x67, 0x20, 0x48, 0x6f, 0x72, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f,
+    0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33,
+    0x31, 0x38, 0x37, 0x00, 0x4c, 0x75, 0x6d, 0x70, 0x6b, 0x69, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x39, 0x30, 0x35, 0x31, 0x00, 0x44, 0x61, 0x76, 0x69, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x31, 0x37,
+    0x00, 0x43, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x34, 0x30, 0x39, 0x33,
+    0x00, 0x54, 0x75, 0x63, 0x6b, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x30, 0x31, 0x33, 0x31, 0x00, 0x4e, 0x65, 0x6d, 0x61, 0x68,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x37, 0x30, 0x31, 0x35, 0x00, 0x42, 0x65, 0x72, 0x74, 0x69, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x31, 0x31, 0x39,
+    0x00, 0x54, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33,
+    0x31, 0x33, 0x37, 0x00, 0x48, 0x61, 0x62, 0x65, 0x72, 0x73, 0x68, 0x61,
+    0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x38, 0x30, 0x33, 0x31, 0x00, 0x42, 0x6c, 0x61, 0x6e, 0x63,
+    0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x36, 0x30, 0x35, 0x37, 0x00, 0x4c, 0x61, 0x74, 0x61, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61,
+    0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x30, 0x32,
+    0x39, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x76, 0x6f, 0x69, 0x78,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x37, 0x31, 0x30, 0x33, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x31, 0x35,
+    0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31,
+    0x31, 0x31, 0x00, 0x44, 0x61, 0x6c, 0x6c, 0x61, 0x6d, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x31, 0x34, 0x31,
+    0x00, 0x54, 0x69, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x31,
+    0x31, 0x31, 0x00, 0x4d, 0x69, 0x64, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63,
+    0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x38, 0x31, 0x35, 0x39, 0x00, 0x54, 0x69, 0x70, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x38, 0x33, 0x35, 0x39, 0x00, 0x4f, 0x6c, 0x64, 0x68, 0x61, 0x6d, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30,
+    0x35, 0x31, 0x00, 0x50, 0x65, 0x6e, 0x64, 0x20, 0x4f, 0x72, 0x65, 0x69,
+    0x6c, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x35, 0x30, 0x31, 0x37,
+    0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x32, 0x31, 0x31, 0x39, 0x00, 0x55, 0x6e, 0x69,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41,
+    0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x38, 0x35,
+    0x00, 0x57, 0x69, 0x63, 0x68, 0x69, 0x74, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x32, 0x35, 0x00,
+    0x46, 0x61, 0x6c, 0x6c, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x31, 0x30, 0x35, 0x31, 0x00,
+    0x45, 0x6c, 0x6d, 0x6f, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x39, 0x33, 0x00,
+    0x53, 0x74, 0x75, 0x74, 0x73, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x35, 0x31, 0x30, 0x35, 0x00, 0x50, 0x65, 0x72, 0x72, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41,
+    0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x30, 0x38, 0x31, 0x00, 0x43, 0x6f, 0x6b, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31,
+    0x37, 0x31, 0x00, 0x54, 0x61, 0x6d, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x32, 0x31, 0x33, 0x00, 0x54, 0x61,
+    0x6e, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31, 0x38, 0x35, 0x00, 0x59, 0x6f,
+    0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45,
+    0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x35, 0x35, 0x00, 0x54, 0x72, 0x75,
+    0x6d, 0x62, 0x75, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x36, 0x31, 0x30, 0x37, 0x00, 0x50, 0x6f, 0x74, 0x74,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x38, 0x30, 0x32, 0x33,
+    0x00, 0x44, 0x69, 0x76, 0x69, 0x64, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x30, 0x36, 0x37, 0x00, 0x43, 0x6f, 0x62, 0x62, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x36,
+    0x30, 0x33, 0x35, 0x00, 0x43, 0x6c, 0x65, 0x61, 0x72, 0x77, 0x61, 0x74,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44,
+    0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x35, 0x34, 0x30, 0x36, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x6f, 0x6e, 0x67,
+    0x61, 0x6c, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x30,
+    0x30, 0x31, 0x31, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54, 0x00, 0x56,
+    0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x32, 0x30, 0x30, 0x31, 0x00, 0x43, 0x68, 0x75, 0x72, 0x63, 0x68,
+    0x69, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x56, 0x00, 0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x37, 0x30, 0x37, 0x39, 0x00, 0x48, 0x65, 0x6e, 0x72,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x36, 0x30, 0x31, 0x37, 0x00, 0x42, 0x61, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x33, 0x30, 0x31, 0x37, 0x00, 0x42, 0x65, 0x6e, 0x20, 0x48, 0x69,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x39, 0x30, 0x35, 0x39, 0x00, 0x47, 0x75, 0x65, 0x72,
+    0x6e, 0x73, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x35, 0x30, 0x32, 0x39, 0x00, 0x43, 0x6f, 0x6e, 0x77, 0x61,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00,
+    0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x38, 0x30, 0x32, 0x33, 0x00, 0x43, 0x6c, 0x69, 0x6e,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x36, 0x31, 0x31, 0x31, 0x00, 0x53, 0x61, 0x6e,
+    0x62, 0x6f, 0x72, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x31,
+    0x32, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x37, 0x30, 0x30, 0x31, 0x00, 0x41, 0x6e, 0x64, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x39, 0x37, 0x00, 0x48,
+    0x61, 0x72, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63,
+    0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x38,
+    0x33, 0x00, 0x4c, 0x79, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x36,
+    0x39, 0x00, 0x4e, 0x61, 0x74, 0x63, 0x68, 0x69, 0x74, 0x6f, 0x63, 0x68,
+    0x65, 0x73, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41,
+    0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x33, 0x30, 0x35, 0x00, 0x57, 0x61,
+    0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x36, 0x37, 0x00, 0x46, 0x61, 0x79,
+    0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x35, 0x37, 0x00, 0x57,
+    0x61, 0x62, 0x61, 0x73, 0x68, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30, 0x30,
+    0x31, 0x00, 0x42, 0x61, 0x6b, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x33, 0x32, 0x38, 0x33, 0x00,
+    0x54, 0x72, 0x65, 0x75, 0x74, 0x6c, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x35,
+    0x31, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x38, 0x32, 0x38, 0x33, 0x00, 0x4c, 0x61, 0x20, 0x53, 0x61, 0x6c, 0x6c,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x37, 0x30, 0x31, 0x31, 0x00, 0x42, 0x75, 0x72, 0x65, 0x61, 0x75, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x36, 0x31, 0x36, 0x35, 0x00, 0x57, 0x65, 0x78, 0x66, 0x6f, 0x72,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00,
+    0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x30, 0x30, 0x39, 0x31, 0x00, 0x4d, 0x63, 0x49, 0x6e,
+    0x74, 0x6f, 0x73, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32, 0x30, 0x39, 0x00, 0x48,
+    0x61, 0x79, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x38, 0x30, 0x30, 0x37, 0x00, 0x42, 0x69, 0x6c, 0x6c, 0x69,
+    0x6e, 0x67, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30, 0x31,
+    0x37, 0x00, 0x43, 0x68, 0x69, 0x63, 0x6f, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30,
+    0x34, 0x31, 0x00, 0x48, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x33, 0x33, 0x00, 0x47,
+    0x72, 0x65, 0x65, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x39, 0x33, 0x00, 0x54,
+    0x68, 0x6f, 0x6d, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x34, 0x39, 0x00, 0x50, 0x6f,
+    0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x30,
+    0x38, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x36, 0x30, 0x30, 0x35, 0x00, 0x42, 0x65, 0x61, 0x64, 0x6c, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53,
+    0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x39, 0x37, 0x00, 0x4d,
+    0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x32, 0x33, 0x39, 0x00, 0x4a, 0x61, 0x63,
+    0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x32, 0x30, 0x39, 0x37, 0x00, 0x4f, 0x73, 0x63, 0x65,
+    0x6f, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46,
+    0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x37, 0x31, 0x30, 0x35, 0x00, 0x4c, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x37, 0x31,
+    0x00, 0x50, 0x65, 0x63, 0x6f, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x38, 0x31, 0x30, 0x00, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x20, 0x42, 0x65, 0x61, 0x63, 0x68,
+    0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x30, 0x30, 0x36, 0x35, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f,
+    0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x33, 0x31, 0x35, 0x35, 0x00, 0x49, 0x72, 0x77, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x30, 0x31, 0x30, 0x31, 0x00, 0x4c, 0x61, 0x6e, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30,
+    0x31, 0x37, 0x00, 0x43, 0x61, 0x6e, 0x61, 0x64, 0x69, 0x61, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b,
+    0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x39, 0x30, 0x37, 0x33, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49,
+    0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x35, 0x30,
+    0x31, 0x33, 0x00, 0x48, 0x61, 0x6d, 0x70, 0x64, 0x65, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x41, 0x00, 0x4d, 0x61, 0x73,
+    0x73, 0x61, 0x63, 0x68, 0x75, 0x73, 0x65, 0x74, 0x74, 0x73, 0x00, 0x30,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x34, 0x30, 0x32, 0x35, 0x00, 0x59, 0x61,
+    0x76, 0x61, 0x70, 0x61, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x37, 0x31, 0x31, 0x33, 0x00, 0x4d,
+    0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65,
+    0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x37, 0x35,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35,
+    0x35, 0x30, 0x30, 0x35, 0x00, 0x42, 0x61, 0x72, 0x72, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69,
+    0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x37, 0x31, 0x30, 0x39, 0x00, 0x4d, 0x63, 0x44, 0x6f,
+    0x6e, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x31, 0x33, 0x00,
+    0x4d, 0x63, 0x4c, 0x65, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x33, 0x33,
+    0x00, 0x42, 0x75, 0x72, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x34, 0x30, 0x32, 0x33, 0x00,
+    0x53, 0x61, 0x6e, 0x74, 0x61, 0x20, 0x43, 0x72, 0x75, 0x7a, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69,
+    0x7a, 0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x34,
+    0x30, 0x36, 0x37, 0x00, 0x4e, 0x69, 0x63, 0x68, 0x6f, 0x6c, 0x61, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x33, 0x35, 0x00,
+    0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x38, 0x33, 0x00, 0x47, 0x72, 0x61,
+    0x76, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x36, 0x37, 0x00, 0x50, 0x65,
+    0x6d, 0x62, 0x69, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39,
+    0x30, 0x33, 0x31, 0x00, 0x43, 0x65, 0x64, 0x61, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x35, 0x39, 0x00,
+    0x44, 0x61, 0x76, 0x69, 0x65, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63,
+    0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x35, 0x38,
+    0x30, 0x00, 0x43, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20,
+    0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32,
+    0x30, 0x34, 0x35, 0x00, 0x44, 0x65, 0x6c, 0x61, 0x77, 0x61, 0x72, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x30, 0x39, 0x00, 0x42,
+    0x6f, 0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x31, 0x30, 0x33, 0x00, 0x50,
+    0x69, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50,
+    0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e,
+    0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x31, 0x35,
+    0x31, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f,
+    0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x33, 0x31,
+    0x31, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x36, 0x35,
+    0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x72,
+    0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35,
+    0x30, 0x39, 0x31, 0x00, 0x50, 0x65, 0x70, 0x69, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x38, 0x30, 0x34, 0x37, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53,
+    0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x38, 0x31, 0x30, 0x35, 0x00, 0x57, 0x69, 0x6c,
+    0x6c, 0x69, 0x61, 0x6d, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32,
+    0x30, 0x39, 0x33, 0x00, 0x4f, 0x6b, 0x65, 0x65, 0x63, 0x68, 0x6f, 0x62,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c,
+    0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x37, 0x30, 0x34, 0x33, 0x00, 0x46, 0x61, 0x72, 0x69,
+    0x62, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x32, 0x37,
+    0x00, 0x43, 0x61, 0x6c, 0x6c, 0x61, 0x77, 0x61, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30,
+    0x30, 0x38, 0x31, 0x00, 0x48, 0x61, 0x73, 0x6b, 0x65, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36,
+    0x30, 0x36, 0x37, 0x00, 0x53, 0x61, 0x63, 0x72, 0x61, 0x6d, 0x65, 0x6e,
+    0x74, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41,
+    0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00,
+    0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x30, 0x30, 0x31, 0x31, 0x00, 0x42,
+    0x6f, 0x75, 0x72, 0x62, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31, 0x32, 0x39, 0x00, 0x4c,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59,
+    0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x30, 0x31, 0x30, 0x31, 0x00, 0x4d, 0x75, 0x73,
+    0x6b, 0x6f, 0x67, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x35, 0x30, 0x34, 0x35, 0x00,
+    0x53, 0x61, 0x6e, 0x20, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d,
+    0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33,
+    0x39, 0x30, 0x32, 0x31, 0x00, 0x43, 0x68, 0x61, 0x6d, 0x70, 0x61, 0x69,
+    0x67, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48,
+    0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35,
+    0x31, 0x30, 0x34, 0x35, 0x00, 0x43, 0x72, 0x61, 0x69, 0x67, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x30, 0x31, 0x32, 0x33, 0x00, 0x50, 0x6f, 0x6e, 0x74, 0x6f, 0x74, 0x6f,
+    0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00,
+    0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x34, 0x35, 0x37, 0x00, 0x54, 0x79, 0x6c, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x39, 0x30, 0x37, 0x37, 0x00, 0x48, 0x75, 0x72, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x31, 0x34, 0x31,
+    0x00, 0x54, 0x69, 0x73, 0x68, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x31, 0x31, 0x37, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x30, 0x30, 0x32, 0x35, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x30, 0x30, 0x38, 0x33, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6c, 0x61, 0x6e,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37,
+    0x00, 0x34, 0x35, 0x30, 0x30, 0x33, 0x00, 0x41, 0x69, 0x6b, 0x65, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53,
+    0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x31, 0x31, 0x33,
+    0x00, 0x4c, 0x6f, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x36, 0x37, 0x30,
+    0x00, 0x48, 0x6f, 0x70, 0x65, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x63, 0x69,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x35,
+    0x33, 0x00, 0x4d, 0x63, 0x4b, 0x65, 0x6e, 0x7a, 0x69, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x37, 0x35, 0x00, 0x4c, 0x6f, 0x67,
+    0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f,
+    0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x31, 0x37, 0x30, 0x36, 0x39, 0x00, 0x48, 0x61, 0x72,
+    0x64, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x32, 0x31, 0x37, 0x30, 0x00, 0x4d, 0x61,
+    0x74, 0x61, 0x6e, 0x75, 0x73, 0x6b, 0x61, 0x2d, 0x53, 0x75, 0x73, 0x69,
+    0x74, 0x6e, 0x61, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00,
+    0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00,
+    0x2d, 0x39, 0x00, 0x32, 0x38, 0x31, 0x31, 0x37, 0x00, 0x50, 0x72, 0x65,
+    0x6e, 0x74, 0x69, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x30, 0x37, 0x33, 0x00,
+    0x47, 0x6f, 0x73, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x30, 0x31,
+    0x00, 0x43, 0x6f, 0x74, 0x74, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30, 0x31, 0x31, 0x00, 0x42,
+    0x72, 0x61, 0x64, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x31, 0x34, 0x37,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b,
+    0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x39, 0x30, 0x36, 0x33, 0x00, 0x44, 0x65, 0x4b, 0x61, 0x6c, 0x62,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d,
+    0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x39, 0x31, 0x30, 0x39, 0x00, 0x4d, 0x69, 0x61, 0x6d, 0x69,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f,
+    0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30,
+    0x32, 0x35, 0x00, 0x43, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x61, 0x6e, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41,
+    0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x35, 0x30, 0x34, 0x31, 0x00, 0x44, 0x65, 0x73, 0x68, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41,
+    0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x38, 0x30, 0x38, 0x33, 0x00, 0x4b, 0x6e, 0x6f, 0x78, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x38, 0x30, 0x30, 0x35, 0x00, 0x42, 0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30, 0x35, 0x35, 0x00, 0x4b, 0x65,
+    0x72, 0x73, 0x68, 0x61, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x37, 0x30, 0x39, 0x35, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x38, 0x31, 0x30, 0x31, 0x00, 0x50, 0x75, 0x65, 0x62, 0x6c, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f,
+    0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x30, 0x31, 0x30, 0x37, 0x37, 0x00, 0x4c, 0x61, 0x75, 0x64, 0x65, 0x72,
+    0x64, 0x61, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x39, 0x37, 0x00, 0x53, 0x77,
+    0x65, 0x65, 0x74, 0x20, 0x47, 0x72, 0x61, 0x73, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74,
+    0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x31, 0x30,
+    0x34, 0x33, 0x00, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72,
+    0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x33, 0x30, 0x31, 0x00, 0x4c, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x32,
+    0x35, 0x00, 0x43, 0x61, 0x74, 0x61, 0x68, 0x6f, 0x75, 0x6c, 0x61, 0x20,
+    0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f,
+    0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x32, 0x30, 0x31, 0x36, 0x00, 0x41, 0x6c, 0x65, 0x75, 0x74,
+    0x69, 0x61, 0x6e, 0x73, 0x20, 0x57, 0x65, 0x73, 0x74, 0x20, 0x43, 0x65,
+    0x6e, 0x73, 0x75, 0x73, 0x20, 0x41, 0x72, 0x65, 0x61, 0x00, 0x41, 0x4b,
+    0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39,
+    0x00, 0x33, 0x30, 0x30, 0x37, 0x39, 0x00, 0x50, 0x72, 0x61, 0x69, 0x72,
+    0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54,
+    0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x37, 0x00, 0x33, 0x31, 0x31, 0x33, 0x35, 0x00, 0x50, 0x65, 0x72, 0x6b,
+    0x69, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x30, 0x36, 0x30, 0x33, 0x39, 0x00, 0x4d, 0x61,
+    0x64, 0x65, 0x72, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69,
+    0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x38, 0x31, 0x31, 0x39,
+    0x00, 0x4f, 0x77, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x34, 0x39, 0x00, 0x4d,
+    0x63, 0x4c, 0x65, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x31, 0x31, 0x39, 0x00,
+    0x53, 0x75, 0x6d, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x31, 0x38, 0x31, 0x00,
+    0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x31, 0x34, 0x39, 0x00,
+    0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70,
+    0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x31, 0x32, 0x31,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x42, 0x61, 0x74, 0x6f, 0x6e, 0x20,
+    0x52, 0x6f, 0x75, 0x67, 0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68,
+    0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e,
+    0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36, 0x30, 0x30, 0x31,
+    0x00, 0x41, 0x6c, 0x61, 0x6d, 0x65, 0x64, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66,
+    0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31,
+    0x38, 0x30, 0x31, 0x39, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37,
+    0x31, 0x37, 0x33, 0x00, 0x59, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x4d,
+    0x65, 0x64, 0x69, 0x63, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30,
+    0x31, 0x33, 0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x31, 0x30, 0x31, 0x37, 0x00, 0x43, 0x68, 0x61, 0x6d, 0x62, 0x65, 0x72,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00,
+    0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x31, 0x33, 0x31, 0x00, 0x44, 0x75, 0x76, 0x61, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x36,
+    0x30, 0x35, 0x31, 0x00, 0x4d, 0x6f, 0x6e, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66,
+    0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33,
+    0x35, 0x30, 0x30, 0x33, 0x00, 0x43, 0x61, 0x74, 0x72, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x30, 0x35, 0x31, 0x32, 0x39, 0x00, 0x53, 0x65, 0x61, 0x72,
+    0x63, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52,
+    0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x39, 0x37, 0x00, 0x50, 0x6f, 0x72,
+    0x74, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69,
+    0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31, 0x35, 0x37,
+    0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31,
+    0x30, 0x35, 0x33, 0x00, 0x44, 0x6f, 0x64, 0x67, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72,
+    0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30,
+    0x30, 0x36, 0x33, 0x00, 0x48, 0x75, 0x67, 0x68, 0x65, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c,
+    0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x35, 0x30, 0x31, 0x39, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x31, 0x30, 0x33, 0x31, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52,
+    0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x32, 0x33, 0x30, 0x32, 0x31, 0x00, 0x50, 0x69, 0x73, 0x63, 0x61,
+    0x74, 0x61, 0x71, 0x75, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30,
+    0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x31, 0x39, 0x00, 0x46, 0x72,
+    0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x31, 0x36, 0x35, 0x00,
+    0x53, 0x69, 0x6f, 0x75, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x39, 0x31, 0x37, 0x37, 0x00,
+    0x52, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x33, 0x30, 0x31, 0x31, 0x00, 0x4b, 0x65,
+    0x6e, 0x6e, 0x65, 0x62, 0x65, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x32, 0x35, 0x00, 0x43, 0x68,
+    0x69, 0x73, 0x61, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x37, 0x35,
+    0x00, 0x4b, 0x69, 0x6f, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d,
+    0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x38, 0x35,
+    0x00, 0x4f, 0x6e, 0x65, 0x69, 0x64, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39,
+    0x31, 0x31, 0x33, 0x00, 0x4c, 0x69, 0x6e, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x33, 0x39, 0x00, 0x4b,
+    0x6c, 0x69, 0x63, 0x6b, 0x69, 0x74, 0x61, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x35, 0x34, 0x30, 0x32, 0x33, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65,
+    0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x35, 0x35, 0x00, 0x4d,
+    0x63, 0x4c, 0x65, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31,
+    0x30, 0x32, 0x33, 0x00, 0x43, 0x68, 0x6f, 0x63, 0x74, 0x61, 0x77, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c,
+    0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x30, 0x35, 0x31, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x39,
+    0x30, 0x30, 0x35, 0x00, 0x4c, 0x69, 0x74, 0x63, 0x68, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x54,
+    0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x63, 0x75, 0x74,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x30, 0x32, 0x35, 0x00,
+    0x43, 0x69, 0x6d, 0x61, 0x72, 0x72, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30,
+    0x31, 0x35, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31,
+    0x31, 0x31, 0x39, 0x00, 0x4b, 0x6e, 0x6f, 0x74, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37,
+    0x30, 0x37, 0x37, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x37, 0x30, 0x37, 0x35, 0x00, 0x48, 0x61, 0x79, 0x77, 0x6f, 0x6f,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x33, 0x30, 0x32, 0x39, 0x00, 0x49, 0x73, 0x6c, 0x61,
+    0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x35, 0x30, 0x31, 0x39, 0x00,
+    0x47, 0x75, 0x61, 0x64, 0x61, 0x6c, 0x75, 0x70, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x33, 0x31, 0x30, 0x34, 0x37, 0x00, 0x44, 0x61, 0x77, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x35, 0x30, 0x36, 0x31, 0x00, 0x56, 0x61, 0x6c, 0x65, 0x6e,
+    0x63, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x37, 0x30, 0x35, 0x33, 0x00,
+    0x48, 0x65, 0x6e, 0x6e, 0x65, 0x70, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65,
+    0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39,
+    0x31, 0x35, 0x31, 0x00, 0x53, 0x74, 0x61, 0x72, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x31, 0x35, 0x00,
+    0x43, 0x68, 0x65, 0x6d, 0x75, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f,
+    0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x31,
+    0x31, 0x00, 0x41, 0x76, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x37, 0x31, 0x37, 0x39, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65,
+    0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30, 0x37, 0x35,
+    0x00, 0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x36,
+    0x30, 0x39, 0x37, 0x00, 0x4d, 0x61, 0x63, 0x6b, 0x69, 0x6e, 0x61, 0x63,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x34, 0x30, 0x33, 0x31, 0x00, 0x48, 0x61, 0x72, 0x64, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x35, 0x30, 0x34, 0x39, 0x00,
+    0x48, 0x61, 0x6d, 0x70, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x37, 0x30, 0x38, 0x35, 0x00, 0x48, 0x75, 0x6d, 0x70,
+    0x68, 0x72, 0x65, 0x79, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x30, 0x37, 0x35, 0x00,
+    0x4c, 0x61, 0x75, 0x64, 0x65, 0x72, 0x64, 0x61, 0x6c, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x31, 0x32, 0x39, 0x00, 0x44, 0x6f, 0x6e, 0x6c, 0x65, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x39, 0x30,
+    0x30, 0x31, 0x00, 0x46, 0x61, 0x69, 0x72, 0x66, 0x69, 0x65, 0x6c, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x54, 0x00, 0x43,
+    0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x63, 0x75, 0x74, 0x00, 0x30,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x30, 0x37, 0x00, 0x4d, 0x65,
+    0x72, 0x63, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x31, 0x30, 0x34, 0x35, 0x00, 0x44, 0x61, 0x77, 0x65, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x38, 0x30, 0x36, 0x31, 0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74,
+    0x72, 0x61, 0x69, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31,
+    0x36, 0x37, 0x00, 0x53, 0x74, 0x61, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32,
+    0x36, 0x31, 0x31, 0x35, 0x00, 0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69,
+    0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x31, 0x32, 0x33, 0x31, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x39, 0x30, 0x35, 0x37, 0x00, 0x44, 0x61, 0x64, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35,
+    0x31, 0x31, 0x34, 0x39, 0x00, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65, 0x20,
+    0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x31, 0x39,
+    0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x31, 0x30, 0x31, 0x00, 0x4d,
+    0x61, 0x72, 0x74, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x39, 0x30, 0x34, 0x31, 0x00, 0x53,
+    0x65, 0x76, 0x69, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x32, 0x32, 0x30, 0x35, 0x39, 0x00, 0x4c, 0x61, 0x20, 0x53,
+    0x61, 0x6c, 0x6c, 0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00,
+    0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x32, 0x37, 0x00,
+    0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x37, 0x37, 0x00,
+    0x50, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x70, 0x65,
+    0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00,
+    0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x30, 0x33, 0x00, 0x4c, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x31, 0x30, 0x34, 0x37, 0x00, 0x44, 0x61, 0x6c, 0x6c, 0x61,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00,
+    0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x37, 0x31, 0x33, 0x35, 0x00, 0x50, 0x65, 0x72, 0x72, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x35, 0x31, 0x30, 0x37, 0x00, 0x50, 0x68, 0x69, 0x6c, 0x6c,
+    0x69, 0x70, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x30, 0x37, 0x00, 0x4c, 0x65,
+    0x6e, 0x6f, 0x69, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x38, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x31, 0x31, 0x37, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x38, 0x30, 0x35, 0x37, 0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f, 0x75,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x36, 0x30, 0x37, 0x39, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74,
+    0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x38, 0x33, 0x34, 0x35, 0x00, 0x4d, 0x6f, 0x74, 0x6c,
+    0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x30, 0x30, 0x30, 0x31, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x44, 0x45, 0x00, 0x44, 0x65, 0x6c,
+    0x61, 0x77, 0x61, 0x72, 0x65, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x39, 0x30, 0x31, 0x33, 0x00, 0x42, 0x65, 0x6c, 0x6d, 0x6f, 0x6e, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f,
+    0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31,
+    0x39, 0x37, 0x00, 0x53, 0x63, 0x68, 0x75, 0x79, 0x6c, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x36, 0x30, 0x31, 0x37, 0x00, 0x42, 0x75, 0x66, 0x66, 0x61, 0x6c,
+    0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x33, 0x30, 0x33, 0x00,
+    0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37,
+    0x30, 0x30, 0x37, 0x00, 0x42, 0x6c, 0x65, 0x64, 0x73, 0x6f, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65,
+    0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x36, 0x30, 0x38, 0x33, 0x00, 0x4b, 0x65, 0x77, 0x65, 0x65, 0x6e,
+    0x61, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49,
+    0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x31, 0x31, 0x00, 0x53, 0x61, 0x6e,
+    0x20, 0x53, 0x61, 0x62, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x31, 0x35, 0x31, 0x35, 0x00, 0x42, 0x65, 0x64,
+    0x66, 0x6f, 0x72, 0x64, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x33, 0x39, 0x39, 0x00, 0x52, 0x75, 0x6e,
+    0x6e, 0x65, 0x6c, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x31, 0x37, 0x36, 0x30, 0x00, 0x52, 0x69, 0x63, 0x68,
+    0x6d, 0x6f, 0x6e, 0x64, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x31, 0x30, 0x36, 0x33, 0x00, 0x46, 0x72, 0x6f,
+    0x6e, 0x74, 0x69, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x30, 0x33, 0x33, 0x00,
+    0x43, 0x68, 0x65, 0x79, 0x65, 0x6e, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30,
+    0x33, 0x39, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73,
+    0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39,
+    0x30, 0x35, 0x35, 0x00, 0x43, 0x72, 0x61, 0x77, 0x66, 0x6f, 0x72, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d,
+    0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x31, 0x37, 0x39, 0x00, 0x47, 0x72, 0x61, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33,
+    0x33, 0x37, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x67, 0x75, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31,
+    0x30, 0x39, 0x00, 0x4c, 0x61, 0x6e, 0x63, 0x61, 0x73, 0x74, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37,
+    0x00, 0x31, 0x33, 0x30, 0x39, 0x39, 0x00, 0x45, 0x61, 0x72, 0x6c, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x39, 0x32, 0x30, 0x31, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x32, 0x30, 0x31, 0x37, 0x00, 0x43, 0x61, 0x64, 0x64, 0x6f, 0x20,
+    0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f,
+    0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x31, 0x33, 0x39, 0x00, 0x45, 0x6c, 0x6c, 0x69, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x31, 0x37, 0x35, 0x00, 0x47, 0x6f, 0x6c, 0x69, 0x61, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36, 0x30, 0x37,
+    0x35, 0x00, 0x4f, 0x73, 0x77, 0x65, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59,
+    0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30,
+    0x34, 0x31, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x34, 0x30, 0x35, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x41, 0x75, 0x67,
+    0x75, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x30, 0x34, 0x33, 0x00, 0x44, 0x75,
+    0x50, 0x61, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x36, 0x33, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e,
+    0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x36, 0x31, 0x30, 0x33, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x33, 0x38,
+    0x39, 0x00, 0x52, 0x65, 0x65, 0x76, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x34, 0x31, 0x00,
+    0x44, 0x65, 0x6c, 0x61, 0x77, 0x61, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x32, 0x35, 0x00, 0x53,
+    0x6f, 0x6d, 0x65, 0x72, 0x76, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31, 0x30, 0x31, 0x00,
+    0x48, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37,
+    0x31, 0x31, 0x39, 0x00, 0x4d, 0x65, 0x63, 0x6b, 0x6c, 0x65, 0x6e, 0x62,
+    0x75, 0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31,
+    0x30, 0x36, 0x39, 0x00, 0x47, 0x61, 0x72, 0x64, 0x65, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x32, 0x30, 0x35, 0x31, 0x00, 0x46, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x32, 0x35, 0x00, 0x44,
+    0x65, 0x6c, 0x61, 0x77, 0x61, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f,
+    0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x30, 0x37,
+    0x31, 0x00, 0x4c, 0x61, 0x66, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x32, 0x30, 0x31, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38,
+    0x30, 0x34, 0x35, 0x00, 0x48, 0x61, 0x6e, 0x63, 0x6f, 0x63, 0x6b, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x37, 0x31, 0x39, 0x37, 0x00, 0x59, 0x61, 0x64, 0x6b, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x37, 0x33,
+    0x00, 0x54, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x32, 0x33, 0x00, 0x50, 0x61,
+    0x75, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31, 0x35, 0x35, 0x00,
+    0x53, 0x65, 0x76, 0x69, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65,
+    0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x30, 0x33,
+    0x00, 0x42, 0x65, 0x72, 0x67, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65,
+    0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35,
+    0x30, 0x37, 0x31, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72,
+    0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x32, 0x39, 0x35, 0x00, 0x4c, 0x69, 0x70, 0x73, 0x63, 0x6f,
+    0x6d, 0x62, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x35, 0x30, 0x37, 0x39, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6c, 0x61,
+    0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x31,
+    0x30, 0x39, 0x00, 0x57, 0x69, 0x62, 0x61, 0x75, 0x78, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74,
+    0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x37,
+    0x33, 0x35, 0x00, 0x50, 0x6f, 0x71, 0x75, 0x6f, 0x73, 0x6f, 0x6e, 0x20,
+    0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37,
+    0x30, 0x38, 0x33, 0x00, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c,
+    0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x35, 0x30, 0x32, 0x39, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x30,
+    0x35, 0x00, 0x48, 0x69, 0x63, 0x6b, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74,
+    0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35,
+    0x30, 0x33, 0x31, 0x00, 0x44, 0x61, 0x72, 0x6c, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30,
+    0x34, 0x37, 0x00, 0x45, 0x64, 0x77, 0x61, 0x72, 0x64, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31,
+    0x37, 0x39, 0x00, 0x54, 0x61, 0x7a, 0x65, 0x77, 0x65, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x38, 0x30, 0x39, 0x35, 0x00, 0x50, 0x68, 0x69, 0x6c, 0x6c, 0x69,
+    0x70, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f,
+    0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x35, 0x31, 0x36, 0x38, 0x33, 0x00, 0x4d, 0x61, 0x6e,
+    0x61, 0x73, 0x73, 0x61, 0x73, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56,
+    0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x31, 0x33, 0x00, 0x42, 0x6c,
+    0x75, 0x65, 0x20, 0x45, 0x61, 0x72, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65,
+    0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33,
+    0x30, 0x35, 0x37, 0x00, 0x53, 0x6b, 0x61, 0x67, 0x69, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73,
+    0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x31, 0x39, 0x30, 0x38, 0x31, 0x00, 0x48, 0x61, 0x6e, 0x63,
+    0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x31, 0x33, 0x31, 0x00, 0x47, 0x72, 0x61, 0x64, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x38, 0x33, 0x37, 0x39, 0x00, 0x52, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x31,
+    0x37, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x31, 0x32, 0x33, 0x33, 0x00, 0x57, 0x65, 0x62,
+    0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x38, 0x31, 0x00, 0x47,
+    0x75, 0x69, 0x6c, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x30, 0x38, 0x31, 0x30, 0x37, 0x00, 0x52, 0x6f, 0x75, 0x74,
+    0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00,
+    0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x32, 0x31, 0x31, 0x39, 0x31, 0x00, 0x50, 0x65, 0x6e, 0x64,
+    0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x31, 0x35, 0x00,
+    0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63,
+    0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x39,
+    0x39, 0x00, 0x4d, 0x6f, 0x77, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x31,
+    0x32, 0x31, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00,
+    0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x30, 0x38, 0x30, 0x30, 0x37, 0x00, 0x41, 0x72, 0x63, 0x68,
+    0x75, 0x6c, 0x65, 0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x36, 0x30, 0x39, 0x39, 0x00,
+    0x53, 0x65, 0x6e, 0x65, 0x63, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72,
+    0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x36, 0x35,
+    0x00, 0x46, 0x6c, 0x75, 0x76, 0x61, 0x6e, 0x6e, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37,
+    0x30, 0x38, 0x37, 0x00, 0x48, 0x61, 0x79, 0x77, 0x6f, 0x6f, 0x64, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x30, 0x34, 0x39, 0x00,
+    0x49, 0x6f, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69,
+    0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x32, 0x31,
+    0x00, 0x50, 0x6f, 0x70, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x31, 0x31, 0x33,
+    0x00, 0x53, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37,
+    0x00, 0x31, 0x38, 0x31, 0x31, 0x37, 0x00, 0x4f, 0x72, 0x61, 0x6e, 0x67,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00,
+    0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x36, 0x30, 0x35, 0x33, 0x00, 0x47, 0x72, 0x65, 0x67, 0x6f,
+    0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x32, 0x31,
+    0x00, 0x43, 0x68, 0x65, 0x61, 0x74, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38,
+    0x31, 0x31, 0x37, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x69, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c,
+    0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33,
+    0x31, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6e, 0x74, 0x65, 0x6c, 0x6f, 0x70,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00,
+    0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x36, 0x30, 0x34, 0x35, 0x00, 0x45, 0x64, 0x6d, 0x75,
+    0x6e, 0x64, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53,
+    0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x35, 0x30, 0x35,
+    0x31, 0x00, 0x48, 0x6f, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x37, 0x30, 0x33, 0x39, 0x00, 0x44, 0x6f, 0x64, 0x67,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x32, 0x30, 0x31, 0x35, 0x00, 0x42, 0x72, 0x61,
+    0x64, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76,
+    0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39,
+    0x30, 0x32, 0x35, 0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x31, 0x31,
+    0x39, 0x00, 0x4d, 0x61, 0x75, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73,
+    0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x38,
+    0x39, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x31, 0x34,
+    0x37, 0x00, 0x57, 0x61, 0x6c, 0x74, 0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x35, 0x30, 0x35, 0x39, 0x00, 0x48, 0x6f, 0x74, 0x20, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x35, 0x39, 0x00, 0x44, 0x61,
+    0x76, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f,
+    0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36,
+    0x30, 0x35, 0x35, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x64, 0x20, 0x54, 0x72,
+    0x61, 0x76, 0x65, 0x72, 0x73, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x30, 0x31,
+    0x00, 0x41, 0x63, 0x63, 0x6f, 0x6d, 0x61, 0x63, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31,
+    0x30, 0x33, 0x36, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x73, 0x20,
+    0x43, 0x69, 0x74, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x32, 0x33, 0x00, 0x44,
+    0x65, 0x65, 0x72, 0x20, 0x4c, 0x6f, 0x64, 0x67, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74,
+    0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x30,
+    0x32, 0x33, 0x00, 0x42, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x32, 0x31,
+    0x00, 0x43, 0x61, 0x6c, 0x64, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x50, 0x61,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69,
+    0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x35, 0x30, 0x30, 0x35, 0x00, 0x42, 0x72, 0x69, 0x73, 0x74, 0x6f, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x41, 0x00, 0x4d,
+    0x61, 0x73, 0x73, 0x61, 0x63, 0x68, 0x75, 0x73, 0x65, 0x74, 0x74, 0x73,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x33, 0x37, 0x00,
+    0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69,
+    0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x31, 0x36,
+    0x33, 0x00, 0x59, 0x61, 0x7a, 0x6f, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70,
+    0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x30, 0x34,
+    0x39, 0x00, 0x44, 0x65, 0x4b, 0x61, 0x6c, 0x62, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x34,
+    0x31, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74, 0x65, 0x72, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x32, 0x33, 0x00, 0x43, 0x61, 0x6d,
+    0x65, 0x72, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00,
+    0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x38, 0x35, 0x00,
+    0x53, 0x74, 0x61, 0x66, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30, 0x31, 0x35,
+    0x00, 0x43, 0x68, 0x6f, 0x75, 0x74, 0x65, 0x61, 0x75, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74,
+    0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x30,
+    0x33, 0x39, 0x00, 0x42, 0x72, 0x61, 0x7a, 0x6f, 0x72, 0x69, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x30, 0x30,
+    0x30, 0x35, 0x00, 0x53, 0x75, 0x73, 0x73, 0x65, 0x78, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x44, 0x45, 0x00, 0x44, 0x65, 0x6c, 0x61,
+    0x77, 0x61, 0x72, 0x65, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x36,
+    0x30, 0x32, 0x35, 0x00, 0x4e, 0x61, 0x74, 0x72, 0x6f, 0x6e, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79,
+    0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34,
+    0x38, 0x30, 0x31, 0x37, 0x00, 0x42, 0x61, 0x69, 0x6c, 0x65, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x30,
+    0x33, 0x33, 0x00, 0x43, 0x65, 0x72, 0x72, 0x6f, 0x20, 0x47, 0x6f, 0x72,
+    0x64, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x35, 0x30, 0x30, 0x37, 0x00, 0x43, 0x6f, 0x6c, 0x66, 0x61, 0x78, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x32, 0x30, 0x33, 0x31, 0x00, 0x43, 0x6c, 0x61, 0x72,
+    0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50,
+    0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e,
+    0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x32,
+    0x39, 0x00, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x69, 0x61, 0x6e, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f,
+    0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30,
+    0x30, 0x31, 0x00, 0x41, 0x6c, 0x62, 0x61, 0x6e, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37,
+    0x30, 0x33, 0x33, 0x00, 0x43, 0x6f, 0x74, 0x74, 0x6f, 0x6e, 0x77, 0x6f,
+    0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x31, 0x31, 0x35, 0x00, 0x53, 0x75,
+    0x73, 0x71, 0x75, 0x65, 0x68, 0x61, 0x6e, 0x6e, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e,
+    0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x38, 0x30, 0x38, 0x31, 0x00, 0x53, 0x61, 0x72, 0x67,
+    0x65, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x34,
+    0x37, 0x00, 0x46, 0x61, 0x6e, 0x6e, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x34, 0x30, 0x30, 0x33, 0x00,
+    0x41, 0x6e, 0x6e, 0x65, 0x20, 0x41, 0x72, 0x75, 0x6e, 0x64, 0x65, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d,
+    0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x32, 0x30, 0x38, 0x35, 0x00, 0x53, 0x61, 0x62, 0x69, 0x6e,
+    0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00,
+    0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x37, 0x31, 0x00, 0x57, 0x72, 0x69,
+    0x67, 0x68, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x31, 0x31, 0x37, 0x00, 0x53,
+    0x68, 0x65, 0x6c, 0x62, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31, 0x33, 0x35, 0x00, 0x4d,
+    0x6f, 0x6e, 0x69, 0x74, 0x65, 0x61, 0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x36,
+    0x39, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49,
+    0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x38, 0x30, 0x38, 0x35, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x35, 0x30, 0x35, 0x35, 0x00, 0x54, 0x61, 0x6f, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x31, 0x32, 0x30, 0x31, 0x31, 0x00, 0x42, 0x72, 0x6f,
+    0x77, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30, 0x37, 0x37, 0x00, 0x47, 0x72,
+    0x61, 0x79, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x32, 0x30, 0x33, 0x00,
+    0x53, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x31, 0x37,
+    0x31, 0x00, 0x47, 0x69, 0x6c, 0x6c, 0x65, 0x73, 0x70, 0x69, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31,
+    0x33, 0x31, 0x00, 0x4d, 0x65, 0x72, 0x63, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30,
+    0x30, 0x34, 0x31, 0x00, 0x44, 0x65, 0x6c, 0x61, 0x77, 0x61, 0x72, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f,
+    0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x38, 0x30, 0x36, 0x35, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49,
+    0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x34, 0x30, 0x33, 0x37, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x31,
+    0x33, 0x35, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6c, 0x70, 0x68, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x38, 0x31, 0x32, 0x31, 0x00, 0x52, 0x61, 0x6e, 0x6b, 0x69, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x35, 0x30, 0x34, 0x31, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x65, 0x6e,
+    0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34,
+    0x33, 0x31, 0x00, 0x53, 0x74, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x67, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30,
+    0x39, 0x31, 0x00, 0x48, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37,
+    0x31, 0x39, 0x39, 0x00, 0x59, 0x61, 0x6e, 0x63, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x36, 0x35, 0x00, 0x4f,
+    0x6c, 0x69, 0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36,
+    0x31, 0x30, 0x35, 0x00, 0x50, 0x65, 0x72, 0x6b, 0x69, 0x6e, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x37, 0x00, 0x31, 0x33, 0x30, 0x31, 0x35, 0x00, 0x42, 0x61,
+    0x72, 0x74, 0x6f, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x31, 0x37, 0x35, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x61, 0x6d, 0x70, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39,
+    0x30, 0x31, 0x37, 0x00, 0x42, 0x6f, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00,
+    0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x31, 0x30, 0x39, 0x37, 0x00, 0x4a, 0x6f, 0x68, 0x6e,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x33, 0x31, 0x30, 0x33, 0x39, 0x00, 0x43, 0x75,
+    0x6d, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31, 0x32, 0x35, 0x00, 0x4c,
+    0x61, 0x75, 0x72, 0x65, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x30, 0x31, 0x00,
+    0x41, 0x64, 0x61, 0x6d, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39,
+    0x30, 0x34, 0x37, 0x00, 0x46, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x35,
+    0x37, 0x00, 0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66,
+    0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33,
+    0x35, 0x33, 0x00, 0x4e, 0x6f, 0x6c, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x31, 0x31, 0x00,
+    0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38, 0x30, 0x31, 0x35, 0x00,
+    0x43, 0x68, 0x61, 0x66, 0x66, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61,
+    0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x39, 0x30, 0x30,
+    0x37, 0x00, 0x41, 0x73, 0x68, 0x74, 0x61, 0x62, 0x75, 0x6c, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68,
+    0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x31, 0x30,
+    0x37, 0x00, 0x50, 0x61, 0x6e, 0x6f, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69,
+    0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x36, 0x30,
+    0x30, 0x35, 0x00, 0x43, 0x61, 0x6d, 0x70, 0x62, 0x65, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79,
+    0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31,
+    0x32, 0x30, 0x35, 0x35, 0x00, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x61, 0x6e,
+    0x64, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c,
+    0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x35, 0x30, 0x35, 0x37, 0x00, 0x4c, 0x61, 0x6e, 0x63,
+    0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x39, 0x31, 0x31, 0x39, 0x00, 0x4d, 0x75, 0x73, 0x6b, 0x69, 0x6e,
+    0x67, 0x75, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x31, 0x30, 0x31, 0x35, 0x00, 0x42, 0x6f, 0x79, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x39, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x69, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x35, 0x30, 0x30, 0x37,
+    0x00, 0x44, 0x75, 0x6b, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68,
+    0x75, 0x73, 0x65, 0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x36, 0x31, 0x34, 0x31, 0x00, 0x50, 0x72, 0x65, 0x73, 0x71, 0x75,
+    0x65, 0x20, 0x49, 0x73, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x31, 0x34, 0x31,
+    0x00, 0x50, 0x6c, 0x61, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x31, 0x33,
+    0x39, 0x00, 0x4f, 0x74, 0x74, 0x61, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69,
+    0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38, 0x31,
+    0x31, 0x33, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x4d, 0x69, 0x67, 0x75, 0x65,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00,
+    0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x30, 0x36, 0x30, 0x32, 0x31, 0x00, 0x47, 0x6c, 0x65, 0x6e,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00,
+    0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x32, 0x33, 0x30, 0x32, 0x39, 0x00, 0x57, 0x61,
+    0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x36, 0x30, 0x33, 0x39, 0x00,
+    0x54, 0x65, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x30, 0x39, 0x37, 0x00, 0x4b,
+    0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x51, 0x75, 0x65, 0x65,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x30, 0x32, 0x32, 0x32, 0x30, 0x00, 0x53, 0x69, 0x74, 0x6b,
+    0x61, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x41, 0x4b,
+    0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39,
+    0x00, 0x34, 0x31, 0x30, 0x35, 0x37, 0x00, 0x54, 0x69, 0x6c, 0x6c, 0x61,
+    0x6d, 0x6f, 0x6f, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00,
+    0x2d, 0x38, 0x00, 0x33, 0x35, 0x30, 0x30, 0x35, 0x00, 0x43, 0x68, 0x61,
+    0x76, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x39, 0x30, 0x35, 0x37, 0x00,
+    0x47, 0x72, 0x65, 0x65, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x35, 0x33, 0x00, 0x47, 0x69, 0x62,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x34, 0x39, 0x00, 0x4c, 0x65,
+    0x77, 0x69, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6c, 0x61, 0x72,
+    0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37,
+    0x00, 0x32, 0x30, 0x30, 0x38, 0x39, 0x00, 0x4a, 0x65, 0x77, 0x65, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x35, 0x30, 0x34, 0x33, 0x00, 0x44, 0x72, 0x65, 0x77, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x34, 0x30, 0x32, 0x31, 0x00, 0x46, 0x72, 0x65, 0x64, 0x65, 0x72, 0x69,
+    0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44,
+    0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x37, 0x30, 0x36, 0x31, 0x00, 0x47, 0x72, 0x65,
+    0x65, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x31, 0x37, 0x00, 0x43, 0x68,
+    0x69, 0x70, 0x70, 0x65, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x32,
+    0x33, 0x35, 0x00, 0x49, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x31, 0x31, 0x31, 0x00,
+    0x4d, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x37, 0x37, 0x00,
+    0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31,
+    0x37, 0x37, 0x00, 0x57, 0x61, 0x72, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36,
+    0x30, 0x31, 0x37, 0x00, 0x42, 0x6f, 0x6e, 0x6e, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61,
+    0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x35, 0x30, 0x35,
+    0x37, 0x00, 0x54, 0x6f, 0x72, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x32, 0x36, 0x31, 0x35, 0x33, 0x00, 0x53, 0x63, 0x68, 0x6f, 0x6f,
+    0x6c, 0x63, 0x72, 0x61, 0x66, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x37, 0x33,
+    0x00, 0x4c, 0x61, 0x66, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x39, 0x30, 0x35, 0x33, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55,
+    0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x35, 0x31, 0x30, 0x36, 0x37, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c,
+    0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x37, 0x31, 0x30, 0x35, 0x00, 0x4c, 0x69, 0x76,
+    0x69, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f,
+    0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x32,
+    0x31, 0x00, 0x43, 0x6f, 0x6e, 0x65, 0x6a, 0x6f, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f,
+    0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x31,
+    0x30, 0x37, 0x39, 0x00, 0x48, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x35, 0x30,
+    0x34, 0x39, 0x00, 0x53, 0x61, 0x6e, 0x74, 0x61, 0x20, 0x46, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x38, 0x34, 0x39, 0x37, 0x00, 0x57, 0x69, 0x73, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x33, 0x39, 0x37, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x77, 0x61, 0x6c, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30,
+    0x30, 0x35, 0x33, 0x00, 0x45, 0x6c, 0x6c, 0x73, 0x77, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x32, 0x31, 0x30, 0x37, 0x00, 0x54, 0x65, 0x6e, 0x73, 0x61, 0x73,
+    0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c,
+    0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x31, 0x30, 0x33, 0x35, 0x00, 0x43, 0x6c, 0x61, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x39, 0x31, 0x31, 0x39, 0x00, 0x4c, 0x79, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30, 0x35,
+    0x33, 0x00, 0x48, 0x75, 0x6d, 0x70, 0x68, 0x72, 0x65, 0x79, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x39, 0x31, 0x33, 0x31, 0x00, 0x4d, 0x69, 0x74, 0x63, 0x68, 0x65,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x37, 0x30, 0x33, 0x39, 0x00, 0x43, 0x68, 0x65, 0x72, 0x6f, 0x6b, 0x65,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x31, 0x33,
+    0x39, 0x00, 0x50, 0x69, 0x65, 0x72, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x32, 0x30,
+    0x38, 0x33, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6c, 0x61, 0x6e, 0x64, 0x20,
+    0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f,
+    0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x38, 0x30, 0x35, 0x31, 0x00, 0x47, 0x75, 0x6e, 0x6e, 0x69,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x35, 0x36, 0x30, 0x33, 0x33, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x69, 0x64, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x35, 0x33, 0x30, 0x00,
+    0x42, 0x75, 0x65, 0x6e, 0x61, 0x20, 0x56, 0x69, 0x73, 0x74, 0x61, 0x20,
+    0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36,
+    0x31, 0x31, 0x39, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x6d, 0x6f, 0x72, 0x65,
+    0x6e, 0x63, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31, 0x32, 0x31, 0x00, 0x4d, 0x65,
+    0x69, 0x67, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x32, 0x35, 0x00, 0x4d, 0x61,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30, 0x37, 0x37, 0x00, 0x4c, 0x61,
+    0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70,
+    0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x30, 0x37,
+    0x00, 0x4c, 0x69, 0x6e, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x32, 0x39, 0x00, 0x4f, 0x63,
+    0x65, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x30, 0x38, 0x33, 0x00,
+    0x48, 0x61, 0x72, 0x6c, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x38, 0x33,
+    0x00, 0x48, 0x61, 0x6c, 0x69, 0x66, 0x61, 0x78, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69,
+    0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30,
+    0x37, 0x31, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6c, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x31,
+    0x32, 0x37, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37,
+    0x00, 0x31, 0x39, 0x31, 0x32, 0x33, 0x00, 0x4d, 0x61, 0x68, 0x61, 0x73,
+    0x6b, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x36, 0x31, 0x31, 0x39, 0x00, 0x57, 0x65, 0x73, 0x74, 0x63, 0x68, 0x65,
+    0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x36, 0x31, 0x30, 0x00, 0x46,
+    0x61, 0x6c, 0x6c, 0x73, 0x20, 0x43, 0x68, 0x75, 0x72, 0x63, 0x68, 0x20,
+    0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38,
+    0x30, 0x36, 0x39, 0x00, 0x4b, 0x65, 0x6d, 0x70, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x31, 0x31, 0x33, 0x37, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x31, 0x31, 0x30, 0x33, 0x00, 0x4c, 0x61, 0x6e, 0x63, 0x61,
+    0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x36, 0x39, 0x00, 0x54,
+    0x61, 0x79, 0x6c, 0x6f, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x33, 0x39, 0x00, 0x47,
+    0x72, 0x65, 0x65, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b,
+    0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x31, 0x32, 0x33, 0x00,
+    0x4e, 0x65, 0x77, 0x61, 0x79, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67,
+    0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x34, 0x30, 0x31,
+    0x33, 0x00, 0x45, 0x73, 0x73, 0x65, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65,
+    0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37,
+    0x31, 0x39, 0x39, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x35, 0x35, 0x00, 0x50, 0x75, 0x74,
+    0x6e, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31, 0x37, 0x37, 0x00, 0x57, 0x61,
+    0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x37, 0x31,
+    0x39, 0x33, 0x00, 0x57, 0x69, 0x6c, 0x6b, 0x65, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x30, 0x39, 0x00, 0x41, 0x73,
+    0x68, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x31,
+    0x32, 0x31, 0x00, 0x53, 0x75, 0x77, 0x61, 0x6e, 0x6e, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c,
+    0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x39, 0x32, 0x32, 0x31, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x33, 0x37, 0x00, 0x43, 0x61,
+    0x6d, 0x70, 0x62, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b,
+    0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x34, 0x37,
+    0x00, 0x4f, 0x6b, 0x61, 0x6e, 0x6f, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x33, 0x30, 0x30, 0x37, 0x33, 0x00, 0x50, 0x6f, 0x6e, 0x64, 0x65,
+    0x72, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54,
+    0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x37, 0x00, 0x30, 0x31, 0x31, 0x32, 0x31, 0x00, 0x54, 0x61, 0x6c, 0x6c,
+    0x61, 0x64, 0x65, 0x67, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x34, 0x31, 0x00, 0x52,
+    0x61, 0x62, 0x75, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x34, 0x35, 0x00, 0x46, 0x61,
+    0x75, 0x6c, 0x6b, 0x6e, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x30, 0x39,
+    0x00, 0x45, 0x76, 0x61, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x31, 0x31, 0x31, 0x00,
+    0x50, 0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x38, 0x35, 0x00,
+    0x52, 0x69, 0x74, 0x63, 0x68, 0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x32, 0x30, 0x32, 0x31, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x69,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c,
+    0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x39, 0x30, 0x36, 0x39, 0x00, 0x46, 0x72, 0x61, 0x6e,
+    0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x31, 0x35, 0x39, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b,
+    0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x33, 0x33, 0x39, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67,
+    0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x31, 0x39, 0x00, 0x50, 0x6f, 0x6c,
+    0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x33, 0x37, 0x00, 0x43, 0x6c, 0x69,
+    0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x32, 0x31, 0x00, 0x4d,
+    0x69, 0x61, 0x6d, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x38, 0x35, 0x00, 0x57, 0x61, 0x79,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x39, 0x30, 0x35, 0x31, 0x00, 0x43, 0x6f, 0x6c, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x36,
+    0x31, 0x30, 0x37, 0x00, 0x54, 0x69, 0x6f, 0x67, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39,
+    0x31, 0x34, 0x35, 0x00, 0x53, 0x63, 0x69, 0x6f, 0x74, 0x6f, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x31, 0x31, 0x35,
+    0x00, 0x53, 0x61, 0x72, 0x61, 0x73, 0x6f, 0x74, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x34, 0x30,
+    0x31, 0x37, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72,
+    0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35,
+    0x33, 0x30, 0x36, 0x33, 0x00, 0x53, 0x70, 0x6f, 0x6b, 0x61, 0x6e, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x34, 0x32, 0x30, 0x30, 0x39, 0x00, 0x42, 0x65,
+    0x64, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76,
+    0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37,
+    0x31, 0x31, 0x37, 0x00, 0x4d, 0x61, 0x63, 0x6f, 0x75, 0x70, 0x69, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x32, 0x30, 0x33, 0x37, 0x00, 0x43, 0x6f, 0x6c, 0x75, 0x6d,
+    0x62, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50,
+    0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e,
+    0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x34,
+    0x39, 0x00, 0x46, 0x61, 0x75, 0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x35, 0x34, 0x30, 0x39, 0x37, 0x00, 0x55, 0x70, 0x73, 0x68, 0x75, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x38, 0x37, 0x00,
+    0x4c, 0x61, 0x67, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61,
+    0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x34, 0x30, 0x32,
+    0x37, 0x00, 0x59, 0x75, 0x6d, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x39, 0x30, 0x32, 0x39, 0x00,
+    0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x31, 0x39, 0x30, 0x31, 0x33, 0x00, 0x42, 0x6c, 0x61,
+    0x63, 0x6b, 0x20, 0x48, 0x61, 0x77, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x30, 0x33, 0x37, 0x00, 0x43, 0x6f,
+    0x6f, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x36, 0x00, 0x30, 0x39, 0x30, 0x30, 0x33, 0x00, 0x48, 0x61, 0x72,
+    0x74, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x54, 0x00, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69,
+    0x63, 0x75, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31,
+    0x37, 0x35, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6c, 0x70, 0x68, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x38, 0x30, 0x38, 0x33, 0x00, 0x4c, 0x65, 0x66, 0x6c, 0x6f, 0x72,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x39, 0x30, 0x34, 0x39, 0x00, 0x46, 0x72, 0x61, 0x6e,
+    0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x34, 0x30, 0x34, 0x35, 0x00, 0x57, 0x69, 0x63, 0x6f, 0x6d,
+    0x69, 0x63, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x32,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x33, 0x37, 0x00, 0x44, 0x61,
+    0x72, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x31, 0x31, 0x34, 0x31, 0x00, 0x4c, 0x6f, 0x67, 0x61, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x36, 0x30, 0x34, 0x33, 0x00, 0x48, 0x65, 0x72, 0x6b, 0x69, 0x6d,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x36, 0x37, 0x00, 0x4a, 0x6f, 0x68,
+    0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x30, 0x38, 0x30, 0x33, 0x37, 0x00, 0x45, 0x61,
+    0x67, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x31, 0x38, 0x30, 0x31, 0x33, 0x00, 0x42, 0x72,
+    0x6f, 0x77, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x35, 0x31, 0x00, 0x48, 0x65, 0x6e,
+    0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x39, 0x31, 0x34, 0x37, 0x00, 0x53, 0x65, 0x6e, 0x65,
+    0x63, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48,
+    0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x31, 0x30, 0x35, 0x37, 0x00, 0x43, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6c,
+    0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x37, 0x37, 0x00, 0x59, 0x61,
+    0x6b, 0x69, 0x6d, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x33, 0x30, 0x30,
+    0x33, 0x00, 0x41, 0x74, 0x6b, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33,
+    0x30, 0x38, 0x39, 0x00, 0x44, 0x65, 0x4b, 0x61, 0x6c, 0x62, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37,
+    0x30, 0x37, 0x39, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x30, 0x31, 0x37, 0x00, 0x43,
+    0x68, 0x61, 0x73, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x30, 0x31, 0x30, 0x30, 0x31, 0x00, 0x41, 0x75, 0x74,
+    0x61, 0x75, 0x67, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x36, 0x35, 0x00, 0x49, 0x6e,
+    0x67, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x30, 0x36, 0x33, 0x00, 0x43,
+    0x61, 0x6d, 0x70, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x39, 0x30, 0x39, 0x33, 0x00, 0x49, 0x64, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x37, 0x33,
+    0x00, 0x57, 0x6f, 0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x33, 0x32, 0x32, 0x37, 0x00, 0x50, 0x69, 0x63, 0x6b,
+    0x65, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x33, 0x33, 0x00, 0x43, 0x68, 0x69,
+    0x70, 0x70, 0x65, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x32, 0x33, 0x00,
+    0x42, 0x75, 0x74, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30, 0x36, 0x37,
+    0x00, 0x48, 0x61, 0x6e, 0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65,
+    0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30,
+    0x39, 0x31, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e,
+    0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x39, 0x31, 0x33, 0x39, 0x00, 0x4d, 0x75, 0x73, 0x63, 0x61, 0x74, 0x69,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35,
+    0x34, 0x30, 0x31, 0x31, 0x00, 0x43, 0x61, 0x62, 0x65, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65,
+    0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x34, 0x37, 0x00, 0x52,
+    0x6f, 0x63, 0x6b, 0x64, 0x61, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x36, 0x31,
+    0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x52, 0x69, 0x76, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00,
+    0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x31, 0x30, 0x32, 0x33, 0x00, 0x42, 0x75, 0x74, 0x6c, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00,
+    0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x38, 0x30, 0x35, 0x31, 0x00, 0x47, 0x69, 0x62, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e,
+    0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x38, 0x30, 0x37, 0x33, 0x00, 0x52, 0x61, 0x6e, 0x73,
+    0x6f, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x30, 0x38, 0x39,
+    0x00, 0x48, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72,
+    0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x30, 0x32,
+    0x33, 0x00, 0x43, 0x6c, 0x65, 0x62, 0x75, 0x72, 0x6e, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x35, 0x31, 0x30, 0x39, 0x00, 0x50, 0x69, 0x6b, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31,
+    0x36, 0x35, 0x30, 0x00, 0x48, 0x61, 0x6d, 0x70, 0x74, 0x6f, 0x6e, 0x20,
+    0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31,
+    0x30, 0x36, 0x35, 0x00, 0x48, 0x61, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x31,
+    0x31, 0x00, 0x41, 0x75, 0x67, 0x6c, 0x61, 0x69, 0x7a, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x36, 0x38, 0x35,
+    0x00, 0x4d, 0x61, 0x6e, 0x61, 0x73, 0x73, 0x61, 0x73, 0x20, 0x50, 0x61,
+    0x72, 0x6b, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x37, 0x30, 0x35, 0x39, 0x00, 0x49, 0x73, 0x61, 0x6e, 0x74,
+    0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x31, 0x30, 0x33, 0x37, 0x00, 0x43, 0x6f, 0x6c,
+    0x66, 0x61, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x34, 0x31, 0x00, 0x50, 0x61,
+    0x74, 0x72, 0x69, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x35, 0x33, 0x00,
+    0x4d, 0x61, 0x67, 0x6f, 0x66, 0x66, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x31,
+    0x33, 0x39, 0x00, 0x48, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x39, 0x31,
+    0x00, 0x4d, 0x61, 0x72, 0x65, 0x6e, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x39,
+    0x33, 0x00, 0x4d, 0x65, 0x65, 0x6b, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65,
+    0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35,
+    0x30, 0x38, 0x37, 0x00, 0x4f, 0x75, 0x74, 0x61, 0x67, 0x61, 0x6d, 0x69,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00,
+    0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x34, 0x31, 0x00, 0x45, 0x6c,
+    0x20, 0x50, 0x61, 0x73, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x39, 0x31, 0x32, 0x39, 0x00,
+    0x4d, 0x69, 0x6c, 0x6c, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x31, 0x30, 0x36, 0x33, 0x00, 0x47, 0x72, 0x65, 0x65,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c,
+    0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x37, 0x30, 0x34, 0x37, 0x00, 0x45, 0x64, 0x77, 0x61,
+    0x72, 0x64, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x31, 0x34, 0x33, 0x00, 0x53, 0x63,
+    0x6f, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x30, 0x38, 0x31, 0x31, 0x35, 0x00, 0x53, 0x65, 0x64,
+    0x67, 0x77, 0x69, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x37, 0x31, 0x37, 0x33, 0x00,
+    0x53, 0x77, 0x61, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x31, 0x31, 0x35, 0x37, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x73,
+    0x20, 0x42, 0x6c, 0x75, 0x66, 0x66, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x32, 0x31, 0x30, 0x35,
+    0x00, 0x50, 0x6f, 0x74, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79,
+    0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x37, 0x30, 0x30, 0x31, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x34, 0x30, 0x33, 0x33, 0x00, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65,
+    0x20, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61,
+    0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x39,
+    0x35, 0x00, 0x4f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69,
+    0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x31, 0x36,
+    0x39, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x36,
+    0x33, 0x00, 0x49, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e,
+    0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52,
+    0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x34, 0x31, 0x00, 0x4f, 0x67, 0x6c,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00,
+    0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x37, 0x30, 0x30, 0x39, 0x00, 0x42, 0x65, 0x6e, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e,
+    0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x31, 0x31, 0x35, 0x00, 0x50, 0x6f,
+    0x6e, 0x74, 0x6f, 0x74, 0x6f, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70,
+    0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31, 0x33, 0x33,
+    0x00, 0x4c, 0x65, 0x74, 0x63, 0x68, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x30,
+    0x34, 0x37, 0x00, 0x43, 0x75, 0x6c, 0x70, 0x65, 0x70, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x37, 0x30, 0x31, 0x39, 0x00, 0x43, 0x61, 0x72, 0x74, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x38, 0x30, 0x34, 0x39, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43,
+    0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x31, 0x37, 0x30, 0x33, 0x31, 0x00, 0x43, 0x6f, 0x6f, 0x6b, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x30, 0x37, 0x39, 0x00, 0x43, 0x72, 0x61, 0x77, 0x66, 0x6f,
+    0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x33, 0x32, 0x31, 0x37, 0x00, 0x4e, 0x65, 0x77, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x37, 0x32, 0x30, 0x31, 0x00, 0x57, 0x69, 0x6e, 0x6e,
+    0x65, 0x62, 0x61, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x33, 0x31, 0x00,
+    0x52, 0x69, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x33, 0x37, 0x00,
+    0x50, 0x75, 0x74, 0x6e, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x39, 0x31, 0x39, 0x31, 0x00, 0x57, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x68, 0x69, 0x65, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x32, 0x30, 0x37, 0x00, 0x57, 0x6f,
+    0x6f, 0x64, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x32, 0x30, 0x32, 0x30, 0x00, 0x41, 0x6e,
+    0x63, 0x68, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x42, 0x6f, 0x72, 0x6f,
+    0x75, 0x67, 0x68, 0x00, 0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00, 0x32, 0x38, 0x30, 0x36, 0x35,
+    0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x44,
+    0x61, 0x76, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x32, 0x39, 0x00, 0x4d,
+    0x69, 0x64, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x32, 0x31, 0x00, 0x4d, 0x61,
+    0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x38, 0x31, 0x31, 0x31, 0x00, 0x53, 0x61, 0x6e, 0x20,
+    0x4a, 0x75, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x37, 0x30, 0x37, 0x35, 0x00, 0x47,
+    0x72, 0x61, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x37, 0x30, 0x34, 0x33, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x31, 0x31, 0x00, 0x43,
+    0x6f, 0x6c, 0x75, 0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e,
+    0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x37, 0x30, 0x37,
+    0x31, 0x00, 0x47, 0x61, 0x73, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x36, 0x30, 0x34, 0x31, 0x00, 0x55, 0x69, 0x6e,
+    0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59,
+    0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x34, 0x35, 0x30, 0x34, 0x33, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x65, 0x74, 0x6f, 0x77, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43,
+    0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x31, 0x31, 0x39, 0x37, 0x00, 0x57, 0x79, 0x74, 0x68, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x37, 0x30, 0x32, 0x37, 0x00, 0x43, 0x6c, 0x69, 0x6e, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x35, 0x30, 0x37, 0x31, 0x00, 0x4e, 0x65, 0x77,
+    0x62, 0x65, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61,
+    0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x30, 0x30, 0x31, 0x33, 0x00, 0x43, 0x61, 0x73, 0x63, 0x61, 0x64,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37,
+    0x00, 0x35, 0x31, 0x31, 0x36, 0x33, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x62,
+    0x72, 0x69, 0x64, 0x67, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x31, 0x33, 0x35, 0x00,
+    0x52, 0x6f, 0x73, 0x65, 0x61, 0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x35,
+    0x35, 0x00, 0x54, 0x72, 0x69, 0x6e, 0x69, 0x74, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x36, 0x39,
+    0x00, 0x57, 0x69, 0x6e, 0x6f, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x30,
+    0x36, 0x35, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65,
+    0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x31, 0x30, 0x32, 0x37, 0x00, 0x42, 0x75, 0x63, 0x68, 0x61, 0x6e,
+    0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x38, 0x32, 0x32, 0x39, 0x00, 0x48, 0x75, 0x64,
+    0x73, 0x70, 0x65, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x36, 0x31, 0x30, 0x33, 0x00, 0x4d, 0x61, 0x72,
+    0x71, 0x75, 0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x34, 0x31,
+    0x00, 0x48, 0x61, 0x6e, 0x63, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x38,
+    0x37, 0x00, 0x47, 0x75, 0x61, 0x64, 0x61, 0x6c, 0x75, 0x70, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30,
+    0x38, 0x33, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x37, 0x00, 0x30, 0x36, 0x30, 0x39, 0x37, 0x00, 0x53, 0x6f, 0x6e,
+    0x6f, 0x6d, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x32, 0x30, 0x30, 0x39, 0x00,
+    0x42, 0x72, 0x65, 0x76, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x32, 0x33,
+    0x00, 0x43, 0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73,
+    0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x37, 0x31, 0x36, 0x37, 0x00, 0x54, 0x69, 0x70, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00,
+    0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x33, 0x32, 0x37, 0x00, 0x4d, 0x65, 0x6e, 0x61,
+    0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x35, 0x30, 0x30, 0x39, 0x00, 0x4d, 0x61, 0x75, 0x69, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x48, 0x49, 0x00, 0x48, 0x61, 0x77,
+    0x61, 0x69, 0x69, 0x00, 0x39, 0x00, 0x2d, 0x31, 0x30, 0x00, 0x35, 0x35,
+    0x30, 0x34, 0x35, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x30, 0x30, 0x35, 0x33, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37,
+    0x00, 0x32, 0x30, 0x30, 0x39, 0x31, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x39, 0x31, 0x32, 0x39, 0x00, 0x50, 0x69, 0x63, 0x6b, 0x61,
+    0x77, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x39, 0x31, 0x35, 0x39, 0x00, 0x52, 0x69, 0x6e, 0x67, 0x67, 0x6f,
+    0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x32, 0x30, 0x36, 0x37, 0x00, 0x4d, 0x6f, 0x72, 0x65, 0x68, 0x6f, 0x75,
+    0x73, 0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41,
+    0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x30, 0x38, 0x37, 0x00, 0x43, 0x6f,
+    0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x73, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30,
+    0x35, 0x35, 0x00, 0x47, 0x65, 0x61, 0x75, 0x67, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x36, 0x30, 0x37, 0x35, 0x00,
+    0x50, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x34, 0x39, 0x39, 0x00, 0x57,
+    0x6f, 0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x31, 0x30, 0x31, 0x31, 0x00, 0x42, 0x6f, 0x6f, 0x6e, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e,
+    0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x39, 0x30, 0x33, 0x35, 0x00, 0x43, 0x75, 0x79, 0x61, 0x68,
+    0x6f, 0x67, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x32, 0x30, 0x35, 0x35, 0x00, 0x4c, 0x61, 0x66, 0x61, 0x79, 0x65,
+    0x74, 0x74, 0x65, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c,
+    0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x31, 0x34, 0x31, 0x00, 0x52,
+    0x6f, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x30, 0x32, 0x32, 0x36, 0x31, 0x00, 0x56, 0x61, 0x6c, 0x64, 0x65, 0x7a,
+    0x2d, 0x43, 0x6f, 0x72, 0x64, 0x6f, 0x76, 0x61, 0x20, 0x43, 0x65, 0x6e,
+    0x73, 0x75, 0x73, 0x20, 0x41, 0x72, 0x65, 0x61, 0x00, 0x41, 0x4b, 0x00,
+    0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00,
+    0x35, 0x31, 0x37, 0x33, 0x30, 0x00, 0x50, 0x65, 0x74, 0x65, 0x72, 0x73,
+    0x62, 0x75, 0x72, 0x67, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x36, 0x33, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61,
+    0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x34, 0x30,
+    0x32, 0x39, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61,
+    0x6e, 0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x31, 0x30,
+    0x37, 0x00, 0x4f, 0x6b, 0x66, 0x75, 0x73, 0x6b, 0x65, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c,
+    0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x38, 0x30, 0x36, 0x37, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x31, 0x30, 0x34, 0x35, 0x00, 0x4d, 0x61, 0x6c, 0x68, 0x65, 0x75, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f,
+    0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33,
+    0x36, 0x30, 0x38, 0x31, 0x00, 0x51, 0x75, 0x65, 0x65, 0x6e, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x36, 0x30, 0x37, 0x39, 0x00, 0x53, 0x68, 0x6f, 0x73, 0x68, 0x6f,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44,
+    0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x30, 0x38, 0x30, 0x37, 0x39, 0x00, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x61,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00,
+    0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x32, 0x31, 0x31, 0x33, 0x35, 0x00, 0x4c, 0x65, 0x77, 0x69,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00,
+    0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x35, 0x30, 0x30, 0x37, 0x00, 0x42, 0x61, 0x79, 0x66,
+    0x69, 0x65, 0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69,
+    0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x35, 0x30, 0x32, 0x31,
+    0x00, 0x4e, 0x6f, 0x72, 0x66, 0x6f, 0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61,
+    0x63, 0x68, 0x75, 0x73, 0x65, 0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x32, 0x30, 0x38, 0x31, 0x00, 0x4c, 0x79, 0x63, 0x6f,
+    0x6d, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61,
+    0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30,
+    0x33, 0x35, 0x00, 0x46, 0x6c, 0x61, 0x67, 0x6c, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f,
+    0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x34,
+    0x30, 0x31, 0x37, 0x00, 0x48, 0x75, 0x64, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35,
+    0x00, 0x35, 0x33, 0x30, 0x34, 0x35, 0x00, 0x4d, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x33, 0x31, 0x31, 0x36, 0x33, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x36, 0x30, 0x38, 0x39, 0x00,
+    0x4d, 0x63, 0x50, 0x68, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74,
+    0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x37, 0x00, 0x33, 0x31, 0x30, 0x30, 0x37, 0x00, 0x42, 0x61, 0x6e, 0x6e,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45,
+    0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x32, 0x39, 0x00, 0x45, 0x6d, 0x6d,
+    0x6f, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x31, 0x38,
+    0x31, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73,
+    0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x35,
+    0x31, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x37, 0x31, 0x34, 0x33, 0x00, 0x50, 0x65, 0x6f, 0x72, 0x69, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x30, 0x30, 0x30, 0x37, 0x00, 0x43, 0x68, 0x69, 0x74, 0x74,
+    0x65, 0x6e, 0x64, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x54, 0x00, 0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00,
+    0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x34, 0x37, 0x00, 0x43,
+    0x68, 0x72, 0x69, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x31, 0x31,
+    0x34, 0x33, 0x00, 0x50, 0x6f, 0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73,
+    0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x35, 0x30, 0x35,
+    0x39, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65,
+    0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x33,
+    0x30, 0x32, 0x35, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x32, 0x30, 0x30, 0x32, 0x37, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36,
+    0x30, 0x39, 0x39, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x68, 0x61, 0x68,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x31, 0x31, 0x37, 0x31, 0x00,
+    0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x30, 0x31, 0x36, 0x37,
+    0x00, 0x52, 0x75, 0x73, 0x73, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x36, 0x33,
+    0x00, 0x4b, 0x69, 0x74, 0x20, 0x43, 0x61, 0x72, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f,
+    0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x33, 0x37, 0x30, 0x33, 0x33, 0x00, 0x43, 0x61, 0x73, 0x77, 0x65, 0x6c,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x35, 0x31, 0x30,
+    0x31, 0x00, 0x52, 0x61, 0x63, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f,
+    0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x34, 0x36, 0x33, 0x00, 0x55, 0x76, 0x61, 0x6c, 0x64, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30,
+    0x35, 0x37, 0x00, 0x4c, 0x61, 0x66, 0x6f, 0x75, 0x72, 0x63, 0x68, 0x65,
+    0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c,
+    0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x30, 0x32, 0x30, 0x31, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x35, 0x33, 0x00, 0x53,
+    0x65, 0x6d, 0x69, 0x6e, 0x6f, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32, 0x30, 0x30, 0x31,
+    0x00, 0x41, 0x63, 0x61, 0x64, 0x69, 0x61, 0x20, 0x50, 0x61, 0x72, 0x69,
+    0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30,
+    0x30, 0x39, 0x00, 0x41, 0x74, 0x68, 0x65, 0x6e, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x39, 0x33, 0x00,
+    0x48, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b,
+    0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x30, 0x38, 0x33,
+    0x00, 0x4d, 0x63, 0x4b, 0x65, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79,
+    0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x31, 0x33, 0x31, 0x36, 0x39, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x39, 0x30, 0x39, 0x39, 0x00, 0x4d, 0x61, 0x68, 0x6f, 0x6e, 0x69, 0x6e,
+    0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00,
+    0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38,
+    0x30, 0x39, 0x33, 0x00, 0x43, 0x6f, 0x6d, 0x61, 0x6e, 0x63, 0x68, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37,
+    0x30, 0x35, 0x37, 0x00, 0x47, 0x72, 0x61, 0x69, 0x6e, 0x67, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x35, 0x30, 0x30, 0x33, 0x00, 0x48, 0x6f, 0x6e, 0x6f, 0x6c,
+    0x75, 0x6c, 0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x48,
+    0x49, 0x00, 0x48, 0x61, 0x77, 0x61, 0x69, 0x69, 0x00, 0x39, 0x00, 0x2d,
+    0x31, 0x30, 0x00, 0x31, 0x33, 0x30, 0x30, 0x31, 0x00, 0x41, 0x70, 0x70,
+    0x6c, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x39, 0x31, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x69, 0x64, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x35, 0x31, 0x34, 0x33, 0x00,
+    0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x38, 0x30, 0x34, 0x35, 0x00, 0x47, 0x61, 0x72, 0x66, 0x69, 0x65, 0x6c,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f, 0x00,
+    0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x31, 0x33, 0x31, 0x35, 0x37, 0x00, 0x4a, 0x61, 0x63, 0x6b,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x39, 0x31, 0x39, 0x35, 0x00, 0x53, 0x61, 0x6c,
+    0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x36, 0x37, 0x00, 0x4d, 0x69,
+    0x6e, 0x69, 0x64, 0x6f, 0x6b, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x31, 0x39, 0x39, 0x00, 0x48, 0x61,
+    0x72, 0x64, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x36, 0x30, 0x32, 0x31, 0x00, 0x42, 0x6f, 0x75, 0x6e,
+    0x64, 0x61, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x32, 0x31, 0x31, 0x32, 0x33, 0x00, 0x4c, 0x61, 0x72, 0x75,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00,
+    0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x33, 0x30, 0x33, 0x31, 0x00, 0x59, 0x6f, 0x72, 0x6b,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x45, 0x00, 0x4d,
+    0x61, 0x69, 0x6e, 0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37,
+    0x31, 0x33, 0x33, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65,
+    0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37,
+    0x31, 0x31, 0x39, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x38, 0x31, 0x32, 0x33, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x74, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x37, 0x31, 0x34, 0x33, 0x00, 0x50, 0x65, 0x72, 0x71, 0x75, 0x69,
+    0x6d, 0x61, 0x6e, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x33, 0x31, 0x34, 0x35, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x39, 0x30, 0x32, 0x33, 0x00, 0x4a, 0x75, 0x61, 0x62, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x38, 0x30, 0x38, 0x37, 0x00,
+    0x53, 0x6c, 0x6f, 0x70, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61,
+    0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33,
+    0x31, 0x37, 0x35, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x65, 0x6e, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x39, 0x30, 0x32, 0x35, 0x00, 0x4b, 0x61, 0x6e, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55, 0x74, 0x61, 0x68,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x36, 0x30, 0x35, 0x35, 0x00,
+    0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72,
+    0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x34, 0x35,
+    0x00, 0x45, 0x61, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x39, 0x37,
+    0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72,
+    0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x32, 0x30, 0x31, 0x35, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x6f,
+    0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46,
+    0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x33, 0x30, 0x34, 0x39, 0x00, 0x43, 0x68, 0x61,
+    0x72, 0x6c, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x31, 0x35, 0x39, 0x00, 0x52,
+    0x69, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x32, 0x37, 0x37, 0x00, 0x4c, 0x61, 0x6d, 0x61,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x39, 0x30, 0x32, 0x39, 0x00, 0x43, 0x61, 0x6d, 0x64, 0x65, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x32, 0x30, 0x36, 0x37, 0x00, 0x4c, 0x61, 0x66, 0x61, 0x79, 0x65,
+    0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46,
+    0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x39, 0x32, 0x32, 0x33, 0x00, 0x57, 0x61, 0x79,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f,
+    0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x33, 0x33, 0x00, 0x53, 0x74, 0x6f,
+    0x6e, 0x65, 0x77, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x39, 0x39, 0x00, 0x4c, 0x61,
+    0x62, 0x65, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x39, 0x39, 0x00, 0x59, 0x6f,
+    0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41,
+    0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x34, 0x39, 0x00, 0x53, 0x68, 0x65,
+    0x6c, 0x62, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x32, 0x31, 0x31, 0x33, 0x00, 0x56, 0x65, 0x72, 0x6d, 0x69, 0x6c,
+    0x69, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c,
+    0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x39, 0x33, 0x00, 0x4c,
+    0x6f, 0x72, 0x61, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x33, 0x30, 0x30, 0x33, 0x00, 0x41, 0x73, 0x6f, 0x74,
+    0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x38, 0x31, 0x34, 0x39, 0x00,
+    0x53, 0x74, 0x61, 0x72, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x34, 0x31, 0x00,
+    0x44, 0x65, 0x6c, 0x74, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x30, 0x35, 0x00,
+    0x42, 0x6c, 0x61, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30, 0x35, 0x30, 0x32, 0x37, 0x00,
+    0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30,
+    0x31, 0x31, 0x00, 0x42, 0x65, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61,
+    0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x31, 0x31,
+    0x39, 0x00, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x73, 0x65, 0x78, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x38, 0x34, 0x37, 0x31, 0x00, 0x57, 0x61, 0x6c, 0x6b, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32,
+    0x30, 0x36, 0x33, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c,
+    0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x31, 0x31, 0x30, 0x31, 0x00, 0x4b, 0x65, 0x69, 0x74, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32,
+    0x31, 0x30, 0x33, 0x35, 0x00, 0x43, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x61,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00,
+    0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x38, 0x31, 0x32, 0x35, 0x00, 0x53, 0x68, 0x61, 0x72,
+    0x6b, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x35, 0x31, 0x32, 0x37, 0x00, 0x53, 0x63,
+    0x6f, 0x74, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x39, 0x33, 0x00, 0x50, 0x61,
+    0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x4f,
+    0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x32, 0x37, 0x31, 0x31, 0x35, 0x00, 0x50, 0x69, 0x6e,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x36, 0x39, 0x00, 0x57, 0x61, 0x68,
+    0x6b, 0x69, 0x61, 0x6b, 0x75, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e,
+    0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x30, 0x32,
+    0x31, 0x38, 0x30, 0x00, 0x4e, 0x6f, 0x6d, 0x65, 0x20, 0x43, 0x65, 0x6e,
+    0x73, 0x75, 0x73, 0x20, 0x41, 0x72, 0x65, 0x61, 0x00, 0x41, 0x4b, 0x00,
+    0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x39, 0x00,
+    0x32, 0x31, 0x32, 0x30, 0x35, 0x00, 0x52, 0x6f, 0x77, 0x61, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65,
+    0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x37, 0x30, 0x35, 0x37, 0x00, 0x44, 0x61, 0x76, 0x69, 0x64, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30,
+    0x31, 0x33, 0x00, 0x42, 0x65, 0x61, 0x75, 0x66, 0x6f, 0x72, 0x74, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x30, 0x30, 0x30, 0x35, 0x00,
+    0x43, 0x61, 0x6c, 0x65, 0x64, 0x6f, 0x6e, 0x69, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54, 0x00, 0x56, 0x65, 0x72, 0x6d,
+    0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30,
+    0x34, 0x33, 0x00, 0x44, 0x69, 0x63, 0x6b, 0x69, 0x6e, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x30, 0x36, 0x30, 0x31, 0x35, 0x00, 0x44, 0x65, 0x6c, 0x20, 0x4e,
+    0x6f, 0x72, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69,
+    0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x35, 0x35, 0x31, 0x30, 0x37,
+    0x00, 0x52, 0x75, 0x73, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73,
+    0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x30, 0x36,
+    0x31, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x50, 0x61,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69,
+    0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x31, 0x31, 0x37, 0x00, 0x44, 0x65, 0x61, 0x66, 0x20, 0x53, 0x6d,
+    0x69, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x37, 0x30, 0x37, 0x39, 0x00, 0x4c, 0x65, 0x20, 0x53, 0x75,
+    0x65, 0x75, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x33, 0x33, 0x00, 0x43,
+    0x72, 0x61, 0x77, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6c,
+    0x65, 0x78, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x31, 0x30, 0x31, 0x31, 0x00, 0x42, 0x61, 0x74, 0x68,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36,
+    0x00, 0x30, 0x38, 0x30, 0x30, 0x35, 0x00, 0x41, 0x72, 0x61, 0x70, 0x61,
+    0x68, 0x6f, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x35, 0x31, 0x37, 0x37, 0x35, 0x00, 0x53, 0x61,
+    0x6c, 0x65, 0x6d, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x36, 0x30, 0x36, 0x31, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x59, 0x6f, 0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x30, 0x31, 0x00, 0x41,
+    0x6c, 0x63, 0x6f, 0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x34, 0x31, 0x00,
+    0x47, 0x69, 0x6c, 0x63, 0x68, 0x72, 0x69, 0x73, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x33, 0x30,
+    0x31, 0x35, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x68, 0x61,
+    0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x48, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68, 0x69, 0x72,
+    0x65, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x35, 0x30, 0x30, 0x37,
+    0x00, 0x4b, 0x61, 0x75, 0x61, 0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x48, 0x49, 0x00, 0x48, 0x61, 0x77, 0x61, 0x69, 0x69, 0x00,
+    0x39, 0x00, 0x2d, 0x31, 0x30, 0x00, 0x34, 0x37, 0x31, 0x36, 0x33, 0x00,
+    0x53, 0x75, 0x6c, 0x6c, 0x69, 0x76, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65,
+    0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x31,
+    0x39, 0x31, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00,
+    0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x35, 0x31, 0x31, 0x37, 0x00, 0x53, 0x68, 0x65, 0x62,
+    0x6f, 0x79, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73,
+    0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x30, 0x35,
+    0x31, 0x00, 0x48, 0x65, 0x6e, 0x64, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69,
+    0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x35, 0x31,
+    0x30, 0x00, 0x41, 0x6c, 0x65, 0x78, 0x61, 0x6e, 0x64, 0x72, 0x69, 0x61,
+    0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x31, 0x30, 0x34, 0x35, 0x00, 0x43, 0x61, 0x73, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x31, 0x31, 0x32, 0x35, 0x00, 0x4e, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62,
+    0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32,
+    0x37, 0x31, 0x35, 0x35, 0x00, 0x54, 0x72, 0x61, 0x76, 0x65, 0x72, 0x73,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x30, 0x35, 0x00, 0x42, 0x75, 0x72,
+    0x6c, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65,
+    0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32,
+    0x30, 0x30, 0x35, 0x00, 0x42, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x31, 0x37,
+    0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65,
+    0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39, 0x30,
+    0x33, 0x35, 0x00, 0x43, 0x68, 0x65, 0x72, 0x6f, 0x6b, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x34,
+    0x33, 0x00, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6c, 0x70, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35,
+    0x31, 0x33, 0x35, 0x00, 0x53, 0x68, 0x61, 0x72, 0x70, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61,
+    0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37,
+    0x30, 0x31, 0x37, 0x00, 0x43, 0x61, 0x72, 0x6c, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x34, 0x33, 0x35, 0x00, 0x53, 0x75, 0x74, 0x74, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x33, 0x30, 0x30, 0x39, 0x00, 0x47, 0x72, 0x61, 0x66, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x48, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x48, 0x61, 0x6d, 0x70, 0x73, 0x68, 0x69, 0x72, 0x65,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x30, 0x31, 0x37, 0x00,
+    0x42, 0x75, 0x74, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x32, 0x31, 0x00, 0x43, 0x6f, 0x6c,
+    0x75, 0x6d, 0x62, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b,
+    0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x31, 0x30, 0x36, 0x31, 0x00,
+    0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x31, 0x33, 0x30, 0x35, 0x39, 0x00, 0x43, 0x6c,
+    0x61, 0x72, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x32, 0x34, 0x33, 0x00, 0x4a, 0x65,
+    0x66, 0x66, 0x20, 0x44, 0x61, 0x76, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x35, 0x35, 0x00,
+    0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63,
+    0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x36, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6c, 0x6c, 0x65, 0x67, 0x61,
+    0x6e, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x31, 0x31, 0x35, 0x39, 0x00, 0x52, 0x69, 0x63,
+    0x68, 0x6d, 0x6f, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x34, 0x33, 0x00,
+    0x4b, 0x69, 0x64, 0x64, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44,
+    0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x32, 0x31, 0x35, 0x00, 0x48, 0x69, 0x64, 0x61, 0x6c, 0x67, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37,
+    0x30, 0x37, 0x33, 0x00, 0x4c, 0x61, 0x63, 0x20, 0x71, 0x75, 0x69, 0x20,
+    0x50, 0x61, 0x72, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x31, 0x35,
+    0x00, 0x43, 0x61, 0x6c, 0x75, 0x6d, 0x65, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f,
+    0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x31, 0x31, 0x39, 0x00, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x39,
+    0x35, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x68, 0x65, 0x72, 0x74, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x39, 0x31, 0x36, 0x35, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x62, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x33, 0x30, 0x31,
+    0x37, 0x00, 0x44, 0x6f, 0x75, 0x67, 0x6c, 0x61, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x31, 0x39, 0x30, 0x38, 0x39, 0x00, 0x48, 0x6f, 0x77, 0x61, 0x72,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00,
+    0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31,
+    0x30, 0x37, 0x33, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00,
+    0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x38, 0x30, 0x34, 0x37, 0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x33, 0x31, 0x37, 0x39, 0x00, 0x4c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x30, 0x30, 0x35, 0x35, 0x00, 0x46, 0x69, 0x6e, 0x6e, 0x65, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x37, 0x31, 0x36, 0x31, 0x00, 0x57, 0x61, 0x73, 0x65, 0x63, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x39, 0x31, 0x38, 0x37, 0x00, 0x57, 0x65, 0x62, 0x73, 0x74,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41,
+    0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32,
+    0x38, 0x30, 0x30, 0x35, 0x00, 0x41, 0x6d, 0x69, 0x74, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x35, 0x30, 0x31, 0x35, 0x00, 0x45, 0x64, 0x64, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x34, 0x38, 0x34, 0x31, 0x35, 0x00, 0x53, 0x63, 0x75, 0x72, 0x72, 0x79,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30,
+    0x30, 0x33, 0x35, 0x00, 0x43, 0x6f, 0x77, 0x6c, 0x65, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30,
+    0x39, 0x33, 0x00, 0x49, 0x73, 0x6c, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x57,
+    0x69, 0x67, 0x68, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31, 0x34, 0x33, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x4d, 0x61, 0x64, 0x72, 0x69, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38,
+    0x30, 0x31, 0x33, 0x00, 0x41, 0x74, 0x61, 0x73, 0x63, 0x6f, 0x73, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31,
+    0x30, 0x36, 0x39, 0x00, 0x48, 0x6f, 0x75, 0x73, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c,
+    0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x39, 0x31, 0x35, 0x31, 0x00, 0x50, 0x6f, 0x63, 0x61, 0x68, 0x6f, 0x6e,
+    0x74, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x36, 0x30, 0x32, 0x37, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x30, 0x36, 0x31, 0x30, 0x37, 0x00, 0x54, 0x75, 0x6c,
+    0x61, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x30, 0x31, 0x30, 0x37, 0x39, 0x00,
+    0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61,
+    0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x37,
+    0x37, 0x00, 0x50, 0x72, 0x65, 0x73, 0x69, 0x64, 0x69, 0x6f, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x31, 0x31,
+    0x35, 0x00, 0x4f, 0x74, 0x74, 0x61, 0x77, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30,
+    0x39, 0x31, 0x00, 0x4c, 0x61, 0x20, 0x50, 0x6f, 0x72, 0x74, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e,
+    0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x32, 0x30, 0x35, 0x37, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x62, 0x6f,
+    0x72, 0x6f, 0x75, 0x67, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x38, 0x35, 0x00, 0x53,
+    0x69, 0x6f, 0x75, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x32, 0x31,
+    0x33, 0x33, 0x00, 0x59, 0x6f, 0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79,
+    0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00,
+    0x30, 0x38, 0x30, 0x35, 0x39, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x38,
+    0x00, 0x2d, 0x37, 0x00, 0x31, 0x33, 0x32, 0x30, 0x39, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x35, 0x30, 0x34,
+    0x31, 0x00, 0x52, 0x6f, 0x6f, 0x73, 0x65, 0x76, 0x65, 0x6c, 0x74, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65,
+    0x77, 0x20, 0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d,
+    0x37, 0x00, 0x35, 0x35, 0x30, 0x33, 0x39, 0x00, 0x46, 0x6f, 0x6e, 0x64,
+    0x20, 0x64, 0x75, 0x20, 0x4c, 0x61, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33,
+    0x33, 0x30, 0x39, 0x00, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x33, 0x32, 0x39, 0x39, 0x00, 0x57, 0x61, 0x72, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30,
+    0x36, 0x39, 0x00, 0x4b, 0x69, 0x74, 0x74, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x36, 0x30, 0x35, 0x35, 0x00, 0x4e, 0x61, 0x70, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c,
+    0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x35, 0x34, 0x30, 0x33, 0x35, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x33,
+    0x33, 0x00, 0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x35,
+    0x30, 0x31, 0x37, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x4d, 0x65, 0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x34, 0x38, 0x30, 0x32, 0x31, 0x00, 0x42, 0x61, 0x73, 0x74, 0x72, 0x6f,
+    0x70, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x37, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6c, 0x65, 0x78, 0x61, 0x6e, 0x64,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x37, 0x31, 0x00, 0x46, 0x6c, 0x6f,
+    0x79, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59,
+    0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x33, 0x37, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x34, 0x34, 0x37, 0x00, 0x54, 0x68, 0x72, 0x6f,
+    0x63, 0x6b, 0x6d, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36, 0x30, 0x30, 0x37, 0x00,
+    0x42, 0x65, 0x61, 0x72, 0x20, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x39, 0x30, 0x37, 0x39,
+    0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x39, 0x33, 0x00, 0x53,
+    0x69, 0x73, 0x6b, 0x69, 0x79, 0x6f, 0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f,
+    0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x36,
+    0x30, 0x35, 0x39, 0x00, 0x4e, 0x61, 0x73, 0x73, 0x61, 0x75, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77,
+    0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x36, 0x30, 0x39, 0x37, 0x00, 0x53, 0x63, 0x68, 0x75, 0x79, 0x6c, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x31, 0x30, 0x35, 0x37, 0x00, 0x44, 0x75, 0x6e, 0x64,
+    0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00,
+    0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x37, 0x31, 0x34, 0x37, 0x00, 0x50, 0x69, 0x74, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e,
+    0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31, 0x35, 0x32, 0x30,
+    0x00, 0x42, 0x72, 0x69, 0x73, 0x74, 0x6f, 0x6c, 0x20, 0x63, 0x69, 0x74,
+    0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69,
+    0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x38, 0x37,
+    0x00, 0x52, 0x6f, 0x61, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x35, 0x34, 0x31, 0x30, 0x33, 0x00, 0x57, 0x65, 0x74, 0x7a, 0x65, 0x6c,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x31, 0x34, 0x37, 0x00,
+    0x57, 0x6f, 0x6f, 0x64, 0x72, 0x75, 0x66, 0x66, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39, 0x31,
+    0x31, 0x39, 0x00, 0x4d, 0x63, 0x44, 0x6f, 0x6e, 0x61, 0x6c, 0x64, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x30, 0x31, 0x33, 0x35, 0x00, 0x53, 0x65, 0x71, 0x75, 0x6f, 0x79,
+    0x61, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b,
+    0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x34, 0x35, 0x00, 0x52, 0x69, 0x63,
+    0x68, 0x6d, 0x6f, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x32, 0x37, 0x00, 0x43,
+    0x61, 0x73, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x36, 0x30, 0x37, 0x37, 0x00, 0x4b, 0x69,
+    0x6e, 0x67, 0x73, 0x62, 0x75, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00,
+    0x33, 0x30, 0x30, 0x30, 0x31, 0x00, 0x42, 0x65, 0x61, 0x76, 0x65, 0x72,
+    0x68, 0x65, 0x61, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x30, 0x36, 0x30, 0x34, 0x31, 0x00, 0x4d, 0x61,
+    0x72, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43,
+    0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x38, 0x32, 0x31, 0x39, 0x00,
+    0x48, 0x6f, 0x63, 0x6b, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x30, 0x31, 0x00, 0x41,
+    0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65,
+    0x72, 0x73, 0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38,
+    0x30, 0x32, 0x39, 0x00, 0x42, 0x65, 0x78, 0x61, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x31, 0x30, 0x31,
+    0x00, 0x4d, 0x6f, 0x6f, 0x64, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44,
+    0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x32,
+    0x30, 0x31, 0x35, 0x33, 0x00, 0x52, 0x61, 0x77, 0x6c, 0x69, 0x6e, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x30,
+    0x35, 0x30, 0x30, 0x35, 0x00, 0x42, 0x61, 0x78, 0x74, 0x65, 0x72, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72,
+    0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x32, 0x30, 0x32, 0x31, 0x00, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x61,
+    0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00,
+    0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00,
+    0x31, 0x33, 0x32, 0x37, 0x35, 0x00, 0x54, 0x68, 0x6f, 0x6d, 0x61, 0x73,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x30, 0x31, 0x32, 0x33, 0x00, 0x4d, 0x69, 0x74, 0x63, 0x68, 0x65,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x39, 0x30, 0x39, 0x37, 0x00, 0x4a, 0x61, 0x73, 0x70, 0x65,
+    0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00,
+    0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x35, 0x30, 0x38, 0x31, 0x00, 0x53, 0x61, 0x6c, 0x75,
+    0x64, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x31,
+    0x30, 0x31, 0x00, 0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c,
+    0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x36, 0x30, 0x38, 0x37, 0x00, 0x4c, 0x61, 0x70, 0x65, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x32, 0x30, 0x31, 0x37, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f,
+    0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56,
+    0x00, 0x4e, 0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38,
+    0x00, 0x34, 0x36, 0x30, 0x30, 0x33, 0x00, 0x41, 0x75, 0x72, 0x6f, 0x72,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x35, 0x35, 0x00,
+    0x43, 0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x31,
+    0x33, 0x32, 0x32, 0x39, 0x00, 0x50, 0x69, 0x65, 0x72, 0x63, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65,
+    0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x38, 0x31, 0x31, 0x35, 0x00, 0x44, 0x61, 0x77, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37, 0x30,
+    0x38, 0x35, 0x00, 0x48, 0x61, 0x72, 0x6e, 0x65, 0x74, 0x74, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x36, 0x37, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x31, 0x38, 0x39, 0x00,
+    0x57, 0x69, 0x6c, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65,
+    0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x35, 0x33,
+    0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30, 0x36, 0x37,
+    0x00, 0x48, 0x75, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x33, 0x35, 0x31, 0x00, 0x4e, 0x65,
+    0x77, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x34, 0x38, 0x30, 0x34, 0x35, 0x00, 0x42, 0x72, 0x69, 0x73,
+    0x63, 0x6f, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x37, 0x30, 0x31, 0x39, 0x00, 0x42, 0x72, 0x75, 0x6e, 0x73,
+    0x77, 0x69, 0x63, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31,
+    0x33, 0x33, 0x31, 0x33, 0x00, 0x57, 0x68, 0x69, 0x74, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x34, 0x30, 0x30, 0x33, 0x00, 0x42, 0x65, 0x72, 0x6b,
+    0x65, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33,
+    0x32, 0x39, 0x31, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30,
+    0x34, 0x37, 0x00, 0x4b, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59,
+    0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x31,
+    0x32, 0x37, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73,
+    0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x31, 0x31, 0x34, 0x35, 0x00, 0x52, 0x65, 0x64, 0x20, 0x57,
+    0x69, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61,
+    0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x38, 0x30, 0x36, 0x31, 0x00,
+    0x4a, 0x61, 0x73, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70,
+    0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x31, 0x31, 0x39,
+    0x00, 0x54, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61,
+    0x64, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x39, 0x30, 0x38,
+    0x35, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x39, 0x31, 0x33, 0x37,
+    0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f,
+    0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30, 0x30,
+    0x35, 0x00, 0x43, 0x6c, 0x61, 0x63, 0x6b, 0x61, 0x6d, 0x61, 0x73, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72,
+    0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x32,
+    0x30, 0x31, 0x31, 0x00, 0x42, 0x65, 0x72, 0x6b, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e,
+    0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x36, 0x30, 0x30, 0x39, 0x00, 0x41, 0x6e, 0x74, 0x72,
+    0x69, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49,
+    0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x30, 0x38, 0x30, 0x31, 0x33, 0x00, 0x42, 0x6f, 0x75,
+    0x6c, 0x64, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00,
+    0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x36, 0x31, 0x35, 0x31, 0x00, 0x53,
+    0x61, 0x6e, 0x69, 0x6c, 0x61, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x33, 0x31,
+    0x00, 0x47, 0x61, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74,
+    0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x30,
+    0x30, 0x39, 0x00, 0x41, 0x72, 0x63, 0x68, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x38, 0x30, 0x36, 0x35,
+    0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64, 0x6f,
+    0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x37, 0x30, 0x33, 0x31, 0x00,
+    0x43, 0x6f, 0x66, 0x66, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65,
+    0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x30, 0x30, 0x38, 0x37,
+    0x00, 0x52, 0x6f, 0x73, 0x65, 0x62, 0x75, 0x64, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61,
+    0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x30, 0x30, 0x35,
+    0x33, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f,
+    0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x38,
+    0x33, 0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x64, 0x61, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x31, 0x30, 0x39, 0x35, 0x00, 0x48, 0x61, 0x72,
+    0x6c, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x30, 0x32, 0x39, 0x00, 0x43, 0x6c,
+    0x6f, 0x75, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b,
+    0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x35, 0x30, 0x33, 0x35, 0x00, 0x45, 0x61, 0x75, 0x20,
+    0x43, 0x6c, 0x61, 0x69, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e,
+    0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31,
+    0x31, 0x31, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b,
+    0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x36, 0x31, 0x32, 0x31, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69,
+    0x6e, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x34, 0x30, 0x34, 0x37, 0x00, 0x57, 0x6f, 0x72,
+    0x63, 0x65, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x44, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x6c, 0x61, 0x6e,
+    0x64, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x30, 0x32, 0x30, 0x39,
+    0x00, 0x57, 0x79, 0x61, 0x6e, 0x64, 0x6f, 0x74, 0x74, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x31,
+    0x30, 0x33, 0x00, 0x54, 0x72, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f,
+    0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x30,
+    0x31, 0x30, 0x31, 0x39, 0x00, 0x43, 0x68, 0x65, 0x72, 0x6f, 0x6b, 0x65,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00,
+    0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x30, 0x31, 0x39, 0x37, 0x00, 0x57, 0x61, 0x62, 0x61, 0x75,
+    0x6e, 0x73, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x36, 0x30, 0x34, 0x35, 0x00, 0x57, 0x65, 0x73,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x34, 0x37, 0x31, 0x37, 0x33, 0x00, 0x55, 0x6e, 0x69,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e,
+    0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x32, 0x31, 0x30, 0x31, 0x00, 0x50, 0x61, 0x73,
+    0x63, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c,
+    0x00, 0x46, 0x6c, 0x6f, 0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x38, 0x30, 0x38, 0x31, 0x00, 0x4c, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69,
+    0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x39, 0x30, 0x34, 0x37, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73,
+    0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x30, 0x31, 0x31, 0x31, 0x00, 0x59, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x73,
+    0x74, 0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36,
+    0x00, 0x2d, 0x37, 0x00, 0x34, 0x37, 0x31, 0x33, 0x39, 0x00, 0x50, 0x6f,
+    0x6c, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e,
+    0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x37, 0x31, 0x30, 0x39, 0x00, 0x4c, 0x69, 0x6e,
+    0x63, 0x6f, 0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x37, 0x31, 0x32, 0x39, 0x00, 0x52, 0x65, 0x6e, 0x76, 0x69, 0x6c, 0x6c,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00,
+    0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x30, 0x35, 0x00, 0x42, 0x6f, 0x6f,
+    0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x33,
+    0x33, 0x00, 0x43, 0x6c, 0x65, 0x61, 0x72, 0x66, 0x69, 0x65, 0x6c, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x32, 0x30, 0x31, 0x33, 0x00, 0x48,
+    0x75, 0x6d, 0x62, 0x6f, 0x6c, 0x64, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x56, 0x00, 0x4e, 0x65, 0x76, 0x61, 0x64, 0x61,
+    0x00, 0x38, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x35, 0x30, 0x32, 0x33, 0x00,
+    0x48, 0x69, 0x64, 0x61, 0x6c, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4e, 0x4d, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x65,
+    0x78, 0x69, 0x63, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x39,
+    0x31, 0x35, 0x37, 0x00, 0x54, 0x75, 0x73, 0x63, 0x61, 0x72, 0x61, 0x77,
+    0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48,
+    0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x30, 0x31, 0x37, 0x33, 0x00, 0x53, 0x65, 0x64, 0x67, 0x77, 0x69, 0x63,
+    0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00,
+    0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x32, 0x39, 0x35, 0x00, 0x57, 0x61, 0x6c, 0x6b, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x34, 0x39, 0x30, 0x34, 0x33, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x69, 0x74,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54, 0x00, 0x55,
+    0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x35, 0x33, 0x30,
+    0x36, 0x35, 0x00, 0x53, 0x74, 0x65, 0x76, 0x65, 0x6e, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73,
+    0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d,
+    0x38, 0x00, 0x34, 0x39, 0x30, 0x30, 0x37, 0x00, 0x43, 0x61, 0x72, 0x62,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x55, 0x54,
+    0x00, 0x55, 0x74, 0x61, 0x68, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31,
+    0x36, 0x30, 0x36, 0x33, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49,
+    0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x30,
+    0x30, 0x33, 0x37, 0x00, 0x43, 0x72, 0x61, 0x77, 0x66, 0x6f, 0x72, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b,
+    0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x37, 0x30, 0x32, 0x35, 0x00, 0x43, 0x61, 0x62, 0x61, 0x72, 0x72, 0x75,
+    0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00,
+    0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69,
+    0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x36,
+    0x39, 0x00, 0x50, 0x69, 0x65, 0x72, 0x63, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x37, 0x30, 0x39, 0x37, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x69,
+    0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x38, 0x34, 0x30, 0x00, 0x57,
+    0x69, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x74, 0x65, 0x72, 0x20, 0x63, 0x69,
+    0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x37,
+    0x31, 0x00, 0x50, 0x65, 0x6e, 0x64, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65,
+    0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x35, 0x30, 0x33, 0x33, 0x00, 0x43,
+    0x72, 0x61, 0x77, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x41, 0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x39, 0x30, 0x37,
+    0x33, 0x00, 0x48, 0x6f, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f,
+    0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x38, 0x30, 0x33, 0x31, 0x00,
+    0x44, 0x65, 0x6e, 0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x32, 0x34, 0x37,
+    0x00, 0x4a, 0x69, 0x6d, 0x20, 0x48, 0x6f, 0x67, 0x67, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x34, 0x33,
+    0x00, 0x48, 0x61, 0x72, 0x61, 0x6c, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72,
+    0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30,
+    0x31, 0x35, 0x00, 0x42, 0x61, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69,
+    0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x31,
+    0x31, 0x33, 0x00, 0x59, 0x6f, 0x6c, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f,
+    0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x39,
+    0x30, 0x33, 0x39, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x32, 0x33,
+    0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69,
+    0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x39,
+    0x30, 0x39, 0x35, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x38, 0x32, 0x32, 0x37, 0x00, 0x48, 0x6f, 0x77, 0x61, 0x72, 0x64,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54,
+    0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31,
+    0x31, 0x30, 0x33, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61,
+    0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x32,
+    0x30, 0x35, 0x30, 0x00, 0x42, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x20, 0x43,
+    0x65, 0x6e, 0x73, 0x75, 0x73, 0x20, 0x41, 0x72, 0x65, 0x61, 0x00, 0x41,
+    0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00, 0x2d,
+    0x39, 0x00, 0x35, 0x35, 0x30, 0x37, 0x33, 0x00, 0x4d, 0x61, 0x72, 0x61,
+    0x74, 0x68, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69,
+    0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x35, 0x36, 0x30,
+    0x00, 0x43, 0x6c, 0x69, 0x66, 0x74, 0x6f, 0x6e, 0x20, 0x46, 0x6f, 0x72,
+    0x67, 0x65, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x33, 0x30, 0x34, 0x37, 0x00, 0x43, 0x61, 0x74, 0x6f, 0x6f,
+    0x73, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x35, 0x30, 0x30, 0x32, 0x33, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x56, 0x54, 0x00, 0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x36, 0x30, 0x33, 0x37, 0x00,
+    0x53, 0x77, 0x65, 0x65, 0x74, 0x77, 0x61, 0x74, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f,
+    0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x31,
+    0x31, 0x37, 0x35, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34,
+    0x38, 0x35, 0x30, 0x35, 0x00, 0x5a, 0x61, 0x70, 0x61, 0x74, 0x61, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x34, 0x30,
+    0x30, 0x35, 0x00, 0x43, 0x6f, 0x63, 0x6f, 0x6e, 0x69, 0x6e, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x5a, 0x00, 0x41, 0x72,
+    0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33,
+    0x36, 0x30, 0x33, 0x37, 0x00, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x65, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e,
+    0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x36, 0x30, 0x30, 0x37, 0x00, 0x41, 0x6c, 0x70, 0x65, 0x6e,
+    0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00,
+    0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x31, 0x37, 0x30, 0x36, 0x33, 0x00, 0x47, 0x72, 0x75, 0x6e,
+    0x64, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c,
+    0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00,
+    0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x34, 0x39, 0x00, 0x46, 0x75, 0x6c,
+    0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00,
+    0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x30, 0x35, 0x00, 0x4d, 0x69, 0x74,
+    0x63, 0x68, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x32, 0x37, 0x33, 0x00, 0x4b,
+    0x6c, 0x65, 0x62, 0x65, 0x72, 0x67, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x37, 0x37, 0x00, 0x52, 0x69,
+    0x63, 0x68, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44,
+    0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x32, 0x30, 0x32, 0x39, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50,
+    0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x32, 0x33, 0x31, 0x00, 0x50,
+    0x69, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47,
+    0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x33, 0x30, 0x37, 0x31, 0x00, 0x57, 0x61, 0x6c,
+    0x6c, 0x61, 0x20, 0x57, 0x61, 0x6c, 0x6c, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00,
+    0x32, 0x31, 0x30, 0x36, 0x31, 0x00, 0x45, 0x64, 0x6d, 0x6f, 0x6e, 0x73,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59,
+    0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x34, 0x30, 0x30, 0x39, 0x00, 0x43, 0x61, 0x70,
+    0x65, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4e, 0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73,
+    0x65, 0x79, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x30, 0x32,
+    0x37, 0x00, 0x43, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b,
+    0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x34, 0x37, 0x30, 0x32, 0x37, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x30,
+    0x36, 0x30, 0x34, 0x39, 0x00, 0x4d, 0x6f, 0x64, 0x6f, 0x63, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c,
+    0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x34, 0x35, 0x30, 0x32, 0x33, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x43,
+    0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x31,
+    0x31, 0x33, 0x00, 0x53, 0x75, 0x6c, 0x6c, 0x69, 0x76, 0x61, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65,
+    0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31,
+    0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x31, 0x30, 0x35, 0x00, 0x57, 0x69,
+    0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e,
+    0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x30, 0x30,
+    0x37, 0x00, 0x42, 0x75, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f,
+    0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x36,
+    0x30, 0x33, 0x37, 0x00, 0x43, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61,
+    0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33, 0x32, 0x31,
+    0x39, 0x00, 0x4f, 0x63, 0x6f, 0x6e, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67,
+    0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x34, 0x30, 0x35,
+    0x37, 0x00, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74,
+    0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00,
+    0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x34, 0x39, 0x00, 0x47, 0x65, 0x6e,
+    0x65, 0x73, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x31, 0x32, 0x37, 0x00, 0x47,
+    0x6c, 0x79, 0x6e, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x30, 0x32, 0x35, 0x00, 0x43, 0x61,
+    0x6c, 0x64, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x30, 0x35,
+    0x00, 0x45, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x31, 0x32, 0x31,
+    0x00, 0x56, 0x65, 0x6e, 0x61, 0x6e, 0x67, 0x6f, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73,
+    0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35,
+    0x00, 0x32, 0x38, 0x30, 0x30, 0x33, 0x00, 0x41, 0x6c, 0x63, 0x6f, 0x72,
+    0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x35, 0x35, 0x30, 0x35, 0x31, 0x00, 0x49, 0x72, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57,
+    0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x31, 0x35, 0x00, 0x4d, 0x61, 0x74,
+    0x68, 0x65, 0x77, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x37, 0x30, 0x36, 0x35, 0x00, 0x4b,
+    0x61, 0x6e, 0x61, 0x62, 0x65, 0x63, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
+    0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x34,
+    0x39, 0x00, 0x50, 0x6f, 0x74, 0x74, 0x61, 0x77, 0x61, 0x74, 0x6f, 0x6d,
+    0x69, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53,
+    0x00, 0x4b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x32, 0x35, 0x30, 0x31, 0x39, 0x00, 0x4e, 0x61, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x65, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x41, 0x00, 0x4d, 0x61, 0x73, 0x73, 0x61, 0x63, 0x68, 0x75, 0x73,
+    0x65, 0x74, 0x74, 0x73, 0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x39,
+    0x31, 0x31, 0x37, 0x00, 0x4c, 0x75, 0x63, 0x61, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x31, 0x35, 0x00,
+    0x42, 0x75, 0x72, 0x6c, 0x65, 0x69, 0x67, 0x68, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x31, 0x30, 0x34, 0x31, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f,
+    0x6c, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52,
+    0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x35, 0x30, 0x30, 0x31, 0x33, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x64,
+    0x20, 0x49, 0x73, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x56, 0x54, 0x00, 0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00,
+    0x30, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x35, 0x35, 0x00, 0x47,
+    0x69, 0x6c, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x31, 0x30, 0x30, 0x37, 0x00, 0x42,
+    0x69, 0x62, 0x62, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00,
+    0x2d, 0x36, 0x00, 0x35, 0x31, 0x31, 0x34, 0x33, 0x00, 0x50, 0x69, 0x74,
+    0x74, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67,
+    0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31,
+    0x30, 0x36, 0x31, 0x00, 0x46, 0x61, 0x75, 0x71, 0x75, 0x69, 0x65, 0x72,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56,
+    0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x38, 0x30, 0x36, 0x39, 0x00, 0x43, 0x61, 0x73, 0x74, 0x72,
+    0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x33,
+    0x39, 0x30, 0x37, 0x31, 0x00, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x61, 0x6e,
+    0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00,
+    0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x32,
+    0x31, 0x38, 0x35, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x53, 0x6c,
+    0x6f, 0x70, 0x65, 0x20, 0x42, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00,
+    0x41, 0x4b, 0x00, 0x41, 0x6c, 0x61, 0x73, 0x6b, 0x61, 0x00, 0x39, 0x00,
+    0x2d, 0x39, 0x00, 0x35, 0x36, 0x30, 0x31, 0x35, 0x00, 0x47, 0x6f, 0x73,
+    0x68, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x31, 0x37, 0x31, 0x36, 0x35, 0x00, 0x53, 0x61, 0x6c,
+    0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x31, 0x36, 0x37, 0x00, 0x57, 0x69,
+    0x6c, 0x6b, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30, 0x30, 0x39, 0x00,
+    0x42, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70,
+    0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x38, 0x30, 0x31, 0x33,
+    0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69,
+    0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x32, 0x31,
+    0x30, 0x37, 0x00, 0x50, 0x75, 0x74, 0x6e, 0x61, 0x6d, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x30,
+    0x34, 0x31, 0x00, 0x43, 0x75, 0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72,
+    0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37,
+    0x30, 0x39, 0x39, 0x00, 0x4c, 0x61, 0x20, 0x53, 0x61, 0x6c, 0x6c, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49,
+    0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36,
+    0x00, 0x34, 0x37, 0x31, 0x37, 0x35, 0x00, 0x56, 0x61, 0x6e, 0x20, 0x42,
+    0x75, 0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00,
+    0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x30, 0x36, 0x35, 0x00, 0x43,
+    0x6c, 0x69, 0x6e, 0x63, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x37, 0x31, 0x31, 0x31, 0x00, 0x4d,
+    0x63, 0x48, 0x65, 0x6e, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69,
+    0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x32, 0x31, 0x31, 0x35,
+    0x00, 0x56, 0x65, 0x72, 0x6e, 0x6f, 0x6e, 0x20, 0x50, 0x61, 0x72, 0x69,
+    0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c, 0x6f, 0x75, 0x69, 0x73, 0x69,
+    0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33,
+    0x34, 0x39, 0x00, 0x4e, 0x61, 0x76, 0x61, 0x72, 0x72, 0x6f, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78,
+    0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x31,
+    0x35, 0x00, 0x4d, 0x61, 0x63, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f,
+    0x69, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x31, 0x30, 0x30,
+    0x33, 0x00, 0x41, 0x6c, 0x62, 0x65, 0x6d, 0x61, 0x72, 0x6c, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x30, 0x31, 0x30, 0x38, 0x37, 0x00, 0x4d, 0x61, 0x63, 0x6f, 0x6e, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c,
+    0x61, 0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x35,
+    0x34, 0x30, 0x30, 0x37, 0x00, 0x42, 0x72, 0x61, 0x78, 0x74, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x56, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39, 0x31, 0x31, 0x33, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d, 0x65, 0x72, 0x79, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69,
+    0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x32, 0x30, 0x35, 0x33,
+    0x00, 0x48, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x64, 0x6f, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f, 0x72,
+    0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x37, 0x31,
+    0x38, 0x39, 0x00, 0x57, 0x61, 0x74, 0x61, 0x75, 0x67, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x30, 0x30, 0x30, 0x39, 0x00, 0x42,
+    0x65, 0x63, 0x6b, 0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d,
+    0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x38, 0x30, 0x36, 0x33,
+    0x00, 0x48, 0x65, 0x6e, 0x64, 0x72, 0x69, 0x63, 0x6b, 0x73, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32,
+    0x30, 0x36, 0x39, 0x00, 0x4c, 0x61, 0x63, 0x6b, 0x61, 0x77, 0x61, 0x6e,
+    0x6e, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41,
+    0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69,
+    0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x36, 0x30, 0x32, 0x37,
+    0x00, 0x4e, 0x69, 0x6f, 0x62, 0x72, 0x61, 0x72, 0x61, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d,
+    0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x39, 0x30,
+    0x39, 0x39, 0x00, 0x4a, 0x61, 0x73, 0x70, 0x65, 0x72, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x41, 0x00, 0x49, 0x6f, 0x77, 0x61,
+    0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x35, 0x30, 0x38, 0x39, 0x00,
+    0x4f, 0x7a, 0x61, 0x75, 0x6b, 0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73, 0x63, 0x6f, 0x6e,
+    0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x37,
+    0x31, 0x33, 0x33, 0x00, 0x4f, 0x6e, 0x73, 0x6c, 0x6f, 0x77, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72,
+    0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x34, 0x37, 0x00, 0x4c,
+    0x6f, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x30, 0x30,
+    0x36, 0x31, 0x00, 0x4d, 0x69, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e,
+    0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38,
+    0x30, 0x37, 0x37, 0x00, 0x43, 0x6c, 0x61, 0x79, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73,
+    0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x34, 0x33, 0x00,
+    0x4d, 0x6f, 0x72, 0x72, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x32, 0x36, 0x33, 0x00, 0x54, 0x61,
+    0x6c, 0x62, 0x6f, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x33, 0x35, 0x00, 0x47, 0x72,
+    0x61, 0x6e, 0x64, 0x20, 0x46, 0x6f, 0x72, 0x6b, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x32, 0x38, 0x31, 0x30, 0x39, 0x00, 0x50, 0x65, 0x61, 0x72,
+    0x6c, 0x20, 0x52, 0x69, 0x76, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70,
+    0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x33, 0x30,
+    0x37, 0x00, 0x4d, 0x63, 0x43, 0x75, 0x6c, 0x6c, 0x6f, 0x63, 0x68, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30,
+    0x32, 0x33, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f,
+    0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x32, 0x30, 0x30, 0x35,
+    0x00, 0x41, 0x72, 0x6d, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x31, 0x31, 0x38, 0x31, 0x00, 0x57, 0x65, 0x62,
+    0x73, 0x74, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x37, 0x31, 0x37, 0x31, 0x00, 0x53,
+    0x75, 0x72, 0x72, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x43, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72,
+    0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x31, 0x30, 0x32, 0x35, 0x00, 0x43, 0x61, 0x73, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72,
+    0x61, 0x73, 0x6b, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36,
+    0x30, 0x32, 0x33, 0x00, 0x42, 0x75, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00, 0x49, 0x64, 0x61, 0x68,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x30, 0x30, 0x38, 0x37,
+    0x00, 0x4d, 0x63, 0x43, 0x6c, 0x61, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31,
+    0x35, 0x31, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x33,
+    0x32, 0x30, 0x31, 0x39, 0x00, 0x4c, 0x79, 0x6f, 0x6e, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00, 0x4e, 0x65, 0x76, 0x61,
+    0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x31, 0x31, 0x39,
+    0x37, 0x00, 0x50, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75,
+    0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x30,
+    0x31, 0x39, 0x00, 0x42, 0x65, 0x72, 0x72, 0x69, 0x65, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39,
+    0x31, 0x34, 0x37, 0x00, 0x4e, 0x6f, 0x64, 0x61, 0x77, 0x61, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f,
+    0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x33, 0x30, 0x32, 0x33, 0x00, 0x42, 0x6c, 0x65, 0x63, 0x6b, 0x6c,
+    0x65, 0x79, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x34, 0x32, 0x30, 0x39, 0x37, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x34, 0x32, 0x31, 0x32, 0x33, 0x00, 0x57, 0x61, 0x72,
+    0x72, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50,
+    0x41, 0x00, 0x50, 0x65, 0x6e, 0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e,
+    0x69, 0x61, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x31, 0x31, 0x30,
+    0x37, 0x00, 0x4b, 0x6e, 0x6f, 0x78, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x34, 0x38, 0x34, 0x37, 0x33,
+    0x00, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00,
+    0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x38, 0x34, 0x30, 0x33, 0x00, 0x53,
+    0x61, 0x62, 0x69, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x32, 0x38, 0x31, 0x31, 0x33, 0x00, 0x50, 0x69, 0x6b,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x30, 0x38, 0x31, 0x30, 0x33, 0x00, 0x52, 0x69, 0x6f, 0x20,
+    0x42, 0x6c, 0x61, 0x6e, 0x63, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x4f, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x72, 0x61, 0x64,
+    0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x33, 0x39, 0x30, 0x35, 0x33,
+    0x00, 0x47, 0x61, 0x6c, 0x6c, 0x69, 0x61, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x32, 0x30, 0x39, 0x00, 0x53, 0x74,
+    0x6f, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00, 0x36,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30, 0x38, 0x37, 0x00, 0x4d, 0x63,
+    0x43, 0x6f, 0x6f, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37, 0x00, 0x31, 0x33, 0x31,
+    0x30, 0x37, 0x00, 0x45, 0x6d, 0x61, 0x6e, 0x75, 0x65, 0x6c, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f,
+    0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x39,
+    0x31, 0x32, 0x35, 0x00, 0x50, 0x61, 0x75, 0x6c, 0x64, 0x69, 0x6e, 0x67,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x48, 0x00, 0x4f,
+    0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x30, 0x36, 0x30,
+    0x37, 0x39, 0x00, 0x53, 0x61, 0x6e, 0x20, 0x4c, 0x75, 0x69, 0x73, 0x20,
+    0x4f, 0x62, 0x69, 0x73, 0x70, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x31, 0x32, 0x31,
+    0x32, 0x39, 0x00, 0x57, 0x61, 0x6b, 0x75, 0x6c, 0x6c, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x46, 0x4c, 0x00, 0x46, 0x6c, 0x6f,
+    0x72, 0x69, 0x64, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x33,
+    0x30, 0x35, 0x39, 0x00, 0x53, 0x6b, 0x61, 0x6d, 0x61, 0x6e, 0x69, 0x61,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41, 0x00, 0x57,
+    0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x39,
+    0x00, 0x2d, 0x38, 0x00, 0x31, 0x33, 0x31, 0x32, 0x33, 0x00, 0x47, 0x69,
+    0x6c, 0x6d, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x34, 0x35, 0x30, 0x34, 0x37, 0x00, 0x47, 0x72,
+    0x65, 0x65, 0x6e, 0x77, 0x6f, 0x6f, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x53, 0x43, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x20,
+    0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x32, 0x30, 0x30, 0x37, 0x00, 0x45, 0x6c, 0x6b, 0x6f,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00, 0x4e,
+    0x65, 0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00, 0x35,
+    0x35, 0x30, 0x31, 0x39, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x49, 0x00, 0x57, 0x69, 0x73,
+    0x63, 0x6f, 0x6e, 0x6e, 0x73, 0x69, 0x6e, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x33, 0x31, 0x36, 0x31, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x20,
+    0x44, 0x61, 0x76, 0x69, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00,
+    0x33, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x36, 0x30, 0x30, 0x35, 0x00, 0x41,
+    0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61,
+    0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x38, 0x31, 0x36, 0x31,
+    0x00, 0x59, 0x61, 0x6c, 0x6f, 0x62, 0x75, 0x73, 0x68, 0x61, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73,
+    0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x37, 0x30, 0x34, 0x37, 0x00, 0x46, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54,
+    0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35,
+    0x00, 0x33, 0x36, 0x30, 0x34, 0x35, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65,
+    0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00,
+    0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x39, 0x31, 0x32, 0x31, 0x00, 0x4d,
+    0x61, 0x63, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72, 0x69, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x30, 0x31, 0x30, 0x34, 0x33, 0x00, 0x43,
+    0x75, 0x6c, 0x6c, 0x6d, 0x61, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61, 0x62, 0x61, 0x6d, 0x61,
+    0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x37, 0x31, 0x37, 0x35, 0x00,
+    0x53, 0x74, 0x61, 0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x49, 0x4c, 0x00, 0x49, 0x6c, 0x6c, 0x69, 0x6e, 0x6f, 0x69, 0x73,
+    0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x37, 0x31, 0x35, 0x33, 0x00,
+    0x53, 0x65, 0x71, 0x75, 0x61, 0x74, 0x63, 0x68, 0x69, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e,
+    0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x34, 0x35, 0x31, 0x00, 0x54, 0x6f, 0x6d, 0x20, 0x47, 0x72, 0x65,
+    0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x38, 0x31, 0x33, 0x39, 0x00, 0x52, 0x75, 0x73, 0x68, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64,
+    0x69, 0x61, 0x6e, 0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x35, 0x31,
+    0x36, 0x38, 0x30, 0x00, 0x4c, 0x79, 0x6e, 0x63, 0x68, 0x62, 0x75, 0x72,
+    0x67, 0x20, 0x63, 0x69, 0x74, 0x79, 0x00, 0x56, 0x41, 0x00, 0x56, 0x69,
+    0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00,
+    0x32, 0x33, 0x30, 0x30, 0x31, 0x00, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x73,
+    0x63, 0x6f, 0x67, 0x67, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x45, 0x00, 0x4d, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x30,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x38, 0x30, 0x39, 0x35, 0x00, 0x54, 0x6f,
+    0x77, 0x6e, 0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b,
+    0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30,
+    0x31, 0x39, 0x00, 0x42, 0x75, 0x74, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x33, 0x32, 0x35, 0x31, 0x30, 0x00, 0x43, 0x61, 0x72, 0x73, 0x6f,
+    0x6e, 0x20, 0x43, 0x69, 0x74, 0x79, 0x00, 0x4e, 0x56, 0x00, 0x4e, 0x65,
+    0x76, 0x61, 0x64, 0x61, 0x00, 0x38, 0x00, 0x2d, 0x38, 0x00, 0x34, 0x36,
+    0x30, 0x36, 0x39, 0x00, 0x48, 0x79, 0x64, 0x65, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x37,
+    0x00, 0x30, 0x35, 0x30, 0x30, 0x31, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e,
+    0x73, 0x61, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41,
+    0x52, 0x00, 0x41, 0x72, 0x6b, 0x61, 0x6e, 0x73, 0x61, 0x73, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x31, 0x35, 0x00, 0x43, 0x61,
+    0x64, 0x64, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f,
+    0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37,
+    0x00, 0x2d, 0x36, 0x00, 0x32, 0x36, 0x30, 0x33, 0x35, 0x00, 0x43, 0x6c,
+    0x61, 0x72, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d,
+    0x49, 0x00, 0x4d, 0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34,
+    0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31, 0x35, 0x35, 0x00, 0x4d, 0x61,
+    0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63, 0x6b, 0x79, 0x00,
+    0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x31, 0x32, 0x37, 0x00, 0x44,
+    0x69, 0x6d, 0x6d, 0x69, 0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00,
+    0x2d, 0x36, 0x00, 0x33, 0x37, 0x30, 0x32, 0x33, 0x00, 0x42, 0x75, 0x72,
+    0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c,
+    0x69, 0x6e, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x31,
+    0x38, 0x37, 0x00, 0x4f, 0x77, 0x65, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63,
+    0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x32, 0x30, 0x33,
+    0x39, 0x00, 0x43, 0x72, 0x61, 0x77, 0x66, 0x6f, 0x72, 0x64, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x50, 0x41, 0x00, 0x50, 0x65, 0x6e,
+    0x6e, 0x73, 0x79, 0x6c, 0x76, 0x61, 0x6e, 0x69, 0x61, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x35, 0x33, 0x30, 0x31, 0x31, 0x00, 0x43, 0x6c, 0x61,
+    0x72, 0x6b, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x41,
+    0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x33, 0x39, 0x31, 0x32, 0x31, 0x00,
+    0x4e, 0x6f, 0x62, 0x6c, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x4f, 0x48, 0x00, 0x4f, 0x68, 0x69, 0x6f, 0x00, 0x34, 0x00, 0x2d,
+    0x35, 0x00, 0x33, 0x38, 0x30, 0x33, 0x39, 0x00, 0x47, 0x72, 0x69, 0x67,
+    0x67, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74,
+    0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x30, 0x31, 0x34, 0x37,
+    0x00, 0x50, 0x68, 0x69, 0x6c, 0x6c, 0x69, 0x70, 0x73, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x53, 0x00, 0x4b, 0x61, 0x6e, 0x73,
+    0x61, 0x73, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x33, 0x38, 0x30, 0x36,
+    0x33, 0x00, 0x4e, 0x65, 0x6c, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4e, 0x44, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x35, 0x30, 0x30, 0x31, 0x37, 0x00, 0x4f, 0x72, 0x61, 0x6e, 0x67,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x56, 0x54, 0x00,
+    0x56, 0x65, 0x72, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x30, 0x00, 0x2d, 0x35,
+    0x00, 0x31, 0x33, 0x32, 0x39, 0x33, 0x00, 0x55, 0x70, 0x73, 0x6f, 0x6e,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00,
+    0x33, 0x30, 0x30, 0x38, 0x31, 0x00, 0x52, 0x61, 0x76, 0x61, 0x6c, 0x6c,
+    0x69, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x54, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e, 0x61, 0x00, 0x36, 0x00, 0x2d, 0x37,
+    0x00, 0x34, 0x38, 0x30, 0x39, 0x39, 0x00, 0x43, 0x6f, 0x72, 0x79, 0x65,
+    0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58,
+    0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x32, 0x36, 0x30, 0x39, 0x39, 0x00, 0x4d, 0x61, 0x63, 0x6f, 0x6d, 0x62,
+    0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x49, 0x00, 0x4d,
+    0x69, 0x63, 0x68, 0x69, 0x67, 0x61, 0x6e, 0x00, 0x34, 0x00, 0x2d, 0x35,
+    0x00, 0x34, 0x37, 0x30, 0x31, 0x33, 0x00, 0x43, 0x61, 0x6d, 0x70, 0x62,
+    0x65, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54,
+    0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x65, 0x65, 0x00, 0x33,
+    0x00, 0x2d, 0x35, 0x00, 0x33, 0x34, 0x30, 0x33, 0x39, 0x00, 0x55, 0x6e,
+    0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x4a, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4a, 0x65, 0x72, 0x73, 0x65, 0x79,
+    0x00, 0x30, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x31, 0x30, 0x37, 0x39, 0x00,
+    0x47, 0x61, 0x72, 0x72, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x75, 0x63,
+    0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x31, 0x30, 0x30,
+    0x33, 0x00, 0x42, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67, 0x6f,
+    0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x32, 0x39, 0x31, 0x30, 0x39,
+    0x00, 0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f,
+    0x75, 0x72, 0x72, 0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x36,
+    0x30, 0x31, 0x37, 0x00, 0x48, 0x6f, 0x74, 0x20, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57,
+    0x59, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00,
+    0x2d, 0x37, 0x00, 0x35, 0x31, 0x31, 0x36, 0x31, 0x00, 0x52, 0x6f, 0x61,
+    0x6e, 0x6f, 0x6b, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x56, 0x41, 0x00, 0x56, 0x69, 0x72, 0x67, 0x69, 0x6e, 0x69, 0x61, 0x00,
+    0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x38, 0x30, 0x37, 0x39, 0x00, 0x4a,
+    0x65, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x49, 0x4e, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e,
+    0x61, 0x00, 0x34, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x37, 0x30, 0x37, 0x31,
+    0x00, 0x48, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x54, 0x4e, 0x00, 0x54, 0x65, 0x6e, 0x6e, 0x65, 0x73,
+    0x65, 0x65, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x34, 0x38, 0x34, 0x38,
+    0x39, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x61, 0x63, 0x79, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65, 0x78, 0x61,
+    0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x37, 0x30, 0x31, 0x31,
+    0x00, 0x42, 0x69, 0x67, 0x20, 0x53, 0x74, 0x6f, 0x6e, 0x65, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69, 0x6e,
+    0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x33, 0x37, 0x31, 0x32, 0x35, 0x00, 0x4d, 0x6f, 0x6f, 0x72, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x43, 0x00, 0x4e, 0x6f,
+    0x72, 0x74, 0x68, 0x20, 0x43, 0x61, 0x72, 0x6f, 0x6c, 0x69, 0x6e, 0x61,
+    0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x31, 0x33, 0x30, 0x34, 0x35, 0x00,
+    0x43, 0x61, 0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x47, 0x41, 0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69,
+    0x61, 0x00, 0x33, 0x00, 0x2d, 0x35, 0x00, 0x33, 0x36, 0x30, 0x38, 0x37,
+    0x00, 0x52, 0x6f, 0x63, 0x6b, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59, 0x00, 0x4e, 0x65, 0x77, 0x20,
+    0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00, 0x2d, 0x35, 0x00, 0x32, 0x32,
+    0x30, 0x37, 0x33, 0x00, 0x4f, 0x75, 0x61, 0x63, 0x68, 0x69, 0x74, 0x61,
+    0x20, 0x50, 0x61, 0x72, 0x69, 0x73, 0x68, 0x00, 0x4c, 0x41, 0x00, 0x4c,
+    0x6f, 0x75, 0x69, 0x73, 0x69, 0x61, 0x6e, 0x61, 0x00, 0x37, 0x00, 0x2d,
+    0x36, 0x00, 0x31, 0x36, 0x30, 0x31, 0x31, 0x00, 0x42, 0x69, 0x6e, 0x67,
+    0x68, 0x61, 0x6d, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x44, 0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x34, 0x38, 0x30, 0x35, 0x33, 0x00, 0x42, 0x75, 0x72, 0x6e, 0x65,
+    0x74, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00,
+    0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x38, 0x30, 0x39, 0x35, 0x00, 0x43, 0x6f, 0x6e, 0x63, 0x68, 0x6f, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x54, 0x58, 0x00, 0x54, 0x65,
+    0x78, 0x61, 0x73, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x36, 0x30,
+    0x39, 0x31, 0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x53, 0x44, 0x00, 0x53, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x44, 0x61, 0x6b, 0x6f, 0x74, 0x61, 0x00, 0x35,
+    0x00, 0x2d, 0x37, 0x00, 0x33, 0x30, 0x30, 0x34, 0x33, 0x00, 0x4a, 0x65,
+    0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e,
+    0x74, 0x79, 0x00, 0x4d, 0x54, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x6e,
+    0x61, 0x00, 0x36, 0x00, 0x2d, 0x37, 0x00, 0x32, 0x39, 0x30, 0x31, 0x33,
+    0x00, 0x42, 0x61, 0x74, 0x65, 0x73, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+    0x79, 0x00, 0x4d, 0x4f, 0x00, 0x4d, 0x6f, 0x73, 0x6f, 0x75, 0x72, 0x72,
+    0x69, 0x00, 0x36, 0x00, 0x2d, 0x36, 0x00, 0x34, 0x30, 0x30, 0x30, 0x33,
+    0x00, 0x41, 0x6c, 0x66, 0x61, 0x6c, 0x66, 0x61, 0x20, 0x43, 0x6f, 0x75,
+    0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b, 0x6c, 0x61, 0x68,
+    0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00, 0x32, 0x31, 0x31,
+    0x30, 0x39, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4b, 0x59, 0x00, 0x4b, 0x65, 0x6e,
+    0x74, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x34, 0x00, 0x2d, 0x36, 0x00, 0x34,
+    0x30, 0x31, 0x31, 0x37, 0x00, 0x50, 0x61, 0x77, 0x6e, 0x65, 0x65, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x4b, 0x00, 0x4f, 0x6b,
+    0x6c, 0x61, 0x68, 0x6f, 0x6d, 0x61, 0x00, 0x37, 0x00, 0x2d, 0x36, 0x00,
+    0x30, 0x36, 0x30, 0x32, 0x39, 0x00, 0x4b, 0x65, 0x72, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x43, 0x41, 0x00, 0x43, 0x61, 0x6c,
+    0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x00, 0x39, 0x00, 0x2d, 0x38,
+    0x00, 0x35, 0x36, 0x30, 0x33, 0x31, 0x00, 0x50, 0x6c, 0x61, 0x74, 0x74,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x57, 0x59, 0x00,
+    0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x00, 0x38, 0x00, 0x2d, 0x37,
+    0x00, 0x32, 0x38, 0x30, 0x32, 0x31, 0x00, 0x43, 0x6c, 0x61, 0x69, 0x62,
+    0x6f, 0x72, 0x6e, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4d, 0x53, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00,
+    0x35, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x33, 0x31, 0x37, 0x37, 0x00, 0x4c,
+    0x65, 0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x47, 0x41,
+    0x00, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x69, 0x61, 0x00, 0x33, 0x00, 0x2d,
+    0x35, 0x00, 0x32, 0x38, 0x30, 0x37, 0x39, 0x00, 0x4c, 0x65, 0x61, 0x6b,
+    0x65, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x53, 0x00,
+    0x4d, 0x69, 0x73, 0x73, 0x69, 0x70, 0x70, 0x69, 0x00, 0x35, 0x00, 0x2d,
+    0x36, 0x00, 0x33, 0x36, 0x31, 0x31, 0x31, 0x00, 0x55, 0x6c, 0x73, 0x74,
+    0x65, 0x72, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4e, 0x59,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x31, 0x00,
+    0x2d, 0x35, 0x00, 0x33, 0x31, 0x30, 0x31, 0x39, 0x00, 0x42, 0x75, 0x66,
+    0x66, 0x61, 0x6c, 0x6f, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00,
+    0x4e, 0x45, 0x00, 0x4e, 0x65, 0x62, 0x72, 0x61, 0x73, 0x6b, 0x61, 0x00,
+    0x36, 0x00, 0x2d, 0x36, 0x00, 0x35, 0x34, 0x30, 0x34, 0x39, 0x00, 0x4d,
+    0x61, 0x72, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x57, 0x56, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x56, 0x69, 0x72,
+    0x67, 0x69, 0x6e, 0x69, 0x61, 0x00, 0x32, 0x00, 0x2d, 0x35, 0x00, 0x32,
+    0x37, 0x31, 0x30, 0x31, 0x00, 0x4d, 0x75, 0x72, 0x72, 0x61, 0x79, 0x20,
+    0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x4d, 0x4e, 0x00, 0x4d, 0x69,
+    0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36,
+    0x00, 0x31, 0x39, 0x31, 0x34, 0x39, 0x00, 0x50, 0x6c, 0x79, 0x6d, 0x6f,
+    0x75, 0x74, 0x68, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49,
+    0x41, 0x00, 0x49, 0x6f, 0x77, 0x61, 0x00, 0x35, 0x00, 0x2d, 0x36, 0x00,
+    0x31, 0x36, 0x30, 0x32, 0x39, 0x00, 0x43, 0x61, 0x72, 0x69, 0x62, 0x6f,
+    0x75, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44, 0x00,
+    0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00, 0x34,
+    0x31, 0x30, 0x35, 0x33, 0x00, 0x50, 0x6f, 0x6c, 0x6b, 0x20, 0x43, 0x6f,
+    0x75, 0x6e, 0x74, 0x79, 0x00, 0x4f, 0x52, 0x00, 0x4f, 0x72, 0x65, 0x67,
+    0x6f, 0x6e, 0x00, 0x39, 0x00, 0x2d, 0x38, 0x00, 0x30, 0x31, 0x30, 0x35,
+    0x39, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x69, 0x6e, 0x20, 0x43,
+    0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x41, 0x4c, 0x00, 0x41, 0x6c, 0x61,
+    0x62, 0x61, 0x6d, 0x61, 0x00, 0x33, 0x00, 0x2d, 0x36, 0x00, 0x31, 0x36,
+    0x30, 0x38, 0x37, 0x00, 0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x20, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x79, 0x00, 0x49, 0x44,
+    0x00, 0x49, 0x64, 0x61, 0x68, 0x6f, 0x00, 0x38, 0x00, 0x2d, 0x37, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xbf,
+    0x00, 0x00, 0x09, 0x92, 0x00, 0x00, 0x0d, 0x4a, 0x00, 0x00, 0x09, 0xa4,
+    0x00, 0x00, 0x01, 0xe9, 0x00, 0x00, 0x0b, 0x8d, 0x00, 0x00, 0x0d, 0xf2,
+    0x00, 0x00, 0x09, 0xb7, 0x00, 0x00, 0x0e, 0x48, 0x00, 0x00, 0x09, 0xb8,
+    0x00, 0x00, 0x0e, 0x55, 0x00, 0x00, 0x09, 0xcf, 0x00, 0x00, 0x0e, 0x8d,
+    0x00, 0x00, 0x09, 0xe5, 0x00, 0x00, 0x02, 0x9d, 0x00, 0x00, 0x0c, 0x25,
+    0x00, 0x00, 0x09, 0xf3, 0x00, 0x00, 0x0f, 0x0d, 0x00, 0x00, 0x00, 0xf0,
+    0x00, 0x00, 0x09, 0x0d, 0x00, 0x00, 0x0f, 0x59, 0x00, 0x00, 0x0a, 0x12,
+    0x00, 0x00, 0x0f, 0x87, 0x00, 0x00, 0x0a, 0x1d, 0x00, 0x00, 0x0f, 0xb1,
+    0x00, 0x00, 0x0a, 0x37, 0x00, 0x00, 0x0f, 0xcc, 0x00, 0x00, 0x0a, 0x3a,
+    0x00, 0x00, 0x0f, 0xd0, 0x00, 0x00, 0x0a, 0x55, 0x00, 0x00, 0x0f, 0xea,
+    0x00, 0x00, 0x0a, 0x5c, 0x00, 0x00, 0x10, 0x45, 0x00, 0x00, 0x0a, 0x5d,
+    0x00, 0x00, 0x03, 0x6f, 0x00, 0x00, 0x0d, 0xa4, 0x00, 0x00, 0x0a, 0x6d,
+    0x00, 0x00, 0x12, 0xbf, 0x00, 0x00, 0x0a, 0x7a, 0x00, 0x00, 0x13, 0x0d,
+    0x00, 0x00, 0x0a, 0xc2, 0x00, 0x00, 0x13, 0x25, 0x00, 0x00, 0x0a, 0xd1,
+    0x00, 0x00, 0x0e, 0xd1, 0x00, 0x00, 0x04, 0x5b, 0x00, 0x00, 0x0a, 0xdc,
+    0x00, 0x00, 0x13, 0x6e, 0x00, 0x00, 0x0b, 0x05, 0x00, 0x00, 0x14, 0x52,
+    0x00, 0x00, 0x09, 0xe8, 0x00, 0x00, 0x01, 0x3b, 0x00, 0x00, 0x14, 0x71,
+    0x00, 0x00, 0x0b, 0x28, 0x00, 0x00, 0x10, 0x4c, 0x00, 0x00, 0x05, 0x48,
+    0x00, 0x00, 0x0b, 0x42, 0x00, 0x00, 0x16, 0x0c, 0x00, 0x00, 0x0a, 0x32,
+    0x00, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x17, 0xd7, 0x00, 0x00, 0x0b, 0xb2,
+    0x00, 0x00, 0x18, 0x1a, 0x00, 0x00, 0x0b, 0xf0, 0x00, 0x00, 0x12, 0x1b,
+    0x00, 0x00, 0x06, 0xce, 0x00, 0x00, 0x0c, 0x04, 0x00, 0x00, 0x1b, 0x22,
+    0x00, 0x00, 0x0c, 0x0a, 0x00, 0x00, 0x13, 0xe9, 0x00, 0x00, 0x08, 0x8a,
+    0x00, 0x00, 0x0c, 0x79, 0x00, 0x00, 0x1d, 0xf0, 0x00, 0x00, 0x0c, 0x94,
+    0x00, 0x00, 0x15, 0x9c, 0x00, 0x00, 0x0a, 0x5e, 0x00, 0x00, 0x0c, 0xc4,
+    0x00, 0x00, 0x22, 0xde, 0x00, 0x00, 0x0c, 0xe1, 0x00, 0x00, 0x18, 0x27,
+    0x00, 0x00, 0x0b, 0xbf, 0x00, 0x00, 0x0c, 0xea, 0x00, 0x00, 0x17, 0x9f,
+    0x00, 0x00, 0x0f, 0x0b, 0x00, 0x00, 0x0c, 0xed, 0x00, 0x00, 0x19, 0xa4,
+    0x00, 0x00, 0x0d, 0xef, 0x00, 0x00, 0x0c, 0xfd, 0x00, 0x00, 0x1a, 0xfb,
+    0x00, 0x00, 0x0f, 0x77, 0x00, 0x00, 0x0d, 0x13, 0x00, 0x04, 0xd6, 0x48,
+    0x00, 0x00, 0x0f, 0xbf, 0x00, 0x00, 0x09, 0x92, 0x00, 0x00, 0x0d, 0x4a,
+    0x00, 0x00, 0x09, 0xa4, 0x00, 0x00, 0x01, 0xe9, 0x00, 0x00, 0x0b, 0x8d,
+    0x00, 0x00, 0x0d, 0xf2, 0x00, 0x00, 0x09, 0xb7, 0x00, 0x00, 0x0e, 0x48,
+    0x00, 0x00, 0x09, 0xb8, 0x00, 0x00, 0x0e, 0x55, 0x00, 0x00, 0x09, 0xcf,
+    0x00, 0x00, 0x0e, 0x8d, 0x00, 0x00, 0x09, 0xe5, 0x00, 0x00, 0x02, 0x9d,
+    0x00, 0x00, 0x0c, 0x25, 0x00, 0x00, 0x09, 0xf3, 0x00, 0x00, 0x0f, 0x0d,
+    0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x09, 0x0d, 0x00, 0x00, 0x0f, 0x59,
+    0x00, 0x00, 0x0a, 0x12, 0x00, 0x00, 0x0f, 0x87, 0x00, 0x00, 0x0a, 0x1d,
+    0x00, 0x00, 0x0a, 0x35, 0x00, 0x00, 0x0a, 0x37, 0x00, 0x00, 0x0f, 0xcc,
+    0x00, 0x00, 0x0a, 0x3a, 0x00, 0x00, 0x0f, 0xd0, 0x00, 0x00, 0x0a, 0x55,
+    0x00, 0x00, 0x0f, 0xea, 0x00, 0x00, 0x0a, 0x5c, 0x00, 0x00, 0x10, 0x45,
+    0x00, 0x00, 0x0a, 0x5d, 0x00, 0x00, 0x03, 0x6f, 0x00, 0x00, 0x0d, 0xa4,
+    0x00, 0x00, 0x0a, 0x6d, 0x00, 0x00, 0x12, 0xbf, 0x00, 0x00, 0x0a, 0x7a,
+    0x00, 0x00, 0x13, 0x0d, 0x00, 0x00, 0x0a, 0xc2, 0x00, 0x00, 0x13, 0x25,
+    0x00, 0x00, 0x0a, 0xd1, 0x00, 0x00, 0x0e, 0xd1, 0x00, 0x00, 0x04, 0x5b,
+    0x00, 0x00, 0x0a, 0xdc, 0x00, 0x00, 0x13, 0x6e, 0x00, 0x00, 0x0b, 0x05,
+    0x00, 0x00, 0x14, 0x52, 0x00, 0x00, 0x09, 0xe8, 0x00, 0x00, 0x01, 0x3b,
+    0x00, 0x00, 0x14, 0x71, 0x00, 0x00, 0x0b, 0x28, 0x00, 0x00, 0x10, 0x4c,
+    0x00, 0x00, 0x05, 0x48, 0x00, 0x00, 0x0b, 0x42, 0x00, 0x00, 0x16, 0x0c,
+    0x00, 0x00, 0x0a, 0x32, 0x00, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x17, 0xd7,
+    0x00, 0x00, 0x0b, 0xb2, 0x00, 0x00, 0x18, 0x1a, 0x00, 0x00, 0x0b, 0xf0,
+    0x00, 0x00, 0x12, 0x1b, 0x00, 0x00, 0x06, 0xce, 0x00, 0x00, 0x0c, 0x04,
+    0x00, 0x00, 0x1b, 0x22, 0x00, 0x00, 0x0c, 0x0a, 0x00, 0x00, 0x13, 0xe9,
+    0x00, 0x00, 0x08, 0x8a, 0x00, 0x00, 0x0c, 0x79, 0x00, 0x00, 0x1d, 0xf0,
+    0x00, 0x00, 0x0c, 0x94, 0x00, 0x00, 0x15, 0x9c, 0x00, 0x00, 0x0a, 0x5e,
+    0x00, 0x00, 0x0c, 0xc4, 0x00, 0x00, 0x22, 0xde, 0x00, 0x00, 0x0c, 0xe1,
+    0x00, 0x00, 0x18, 0x27, 0x00, 0x00, 0x0b, 0xbf, 0x00, 0x00, 0x0c, 0xea,
+    0x00, 0x00, 0x17, 0x9f, 0x00, 0x00, 0x0f, 0x0b, 0x00, 0x00, 0x0c, 0xed,
+    0x00, 0x00, 0x19, 0xa4, 0x00, 0x00, 0x0d, 0xef, 0x00, 0x00, 0x0c, 0xfd,
+    0x00, 0x00, 0x1a, 0xfb, 0x00, 0x00, 0x0f, 0x77, 0x00, 0x00, 0x0d, 0x13,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1f,
+    0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x32,
+    0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x47,
+    0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x5f,
+    0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x75,
+    0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x92,
+    0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0xa6,
+    0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0xaf, 0x00, 0x00, 0x00, 0xb6,
+    0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0xce,
+    0x00, 0x00, 0x00, 0xd4, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0xe1,
+    0x00, 0x00, 0x00, 0xe7, 0x00, 0x00, 0x00, 0xee, 0x00, 0x00, 0x00, 0xf6,
+    0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x05,
+    0x00, 0x00, 0x01, 0x0c, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x1a,
+    0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x01, 0x25, 0x00, 0x00, 0x01, 0x2b,
+    0x00, 0x00, 0x01, 0x2f, 0x00, 0x00, 0x01, 0x35, 0x00, 0x00, 0x01, 0x3c,
+    0x00, 0x00, 0x01, 0x47, 0x00, 0x00, 0x01, 0x4e, 0x00, 0x00, 0x01, 0x53,
+    0x00, 0x00, 0x01, 0x58, 0x00, 0x00, 0x01, 0x63, 0x00, 0x00, 0x01, 0x67,
+    0x00, 0x00, 0x01, 0x6d, 0x00, 0x00, 0x01, 0x71, 0x00, 0x00, 0x01, 0x77,
+    0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x01, 0x86, 0x00, 0x00, 0x01, 0x8b,
+    0x00, 0x00, 0x01, 0x96, 0x00, 0x00, 0x01, 0x9c, 0x00, 0x00, 0x01, 0xa5,
+    0x00, 0x00, 0x01, 0xaa, 0x00, 0x00, 0x01, 0xaf, 0x00, 0x00, 0x01, 0xb3,
+    0x00, 0x00, 0x01, 0xbb, 0x00, 0x00, 0x01, 0xc1, 0x00, 0x00, 0x01, 0xc5,
+    0x00, 0x00, 0x01, 0xcc, 0x00, 0x00, 0x01, 0xd0, 0x00, 0x00, 0x01, 0xd6,
+    0x00, 0x00, 0x01, 0xdd, 0x00, 0x00, 0x01, 0xe2, 0x00, 0x00, 0x01, 0xe8,
+    0x00, 0x00, 0x01, 0xec, 0x00, 0x00, 0x01, 0xf2, 0x00, 0x00, 0x01, 0xf9,
+    0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x02, 0x06, 0x00, 0x00, 0x02, 0x0a,
+    0x00, 0x00, 0x02, 0x11, 0x00, 0x00, 0x02, 0x1b, 0x00, 0x00, 0x02, 0x1f,
+    0x00, 0x00, 0x02, 0x25, 0x00, 0x00, 0x02, 0x2c, 0x00, 0x00, 0x02, 0x30,
+    0x00, 0x00, 0x02, 0x36, 0x00, 0x00, 0x02, 0x3e, 0x00, 0x00, 0x02, 0x42,
+    0x00, 0x00, 0x02, 0x49, 0x00, 0x43, 0x68, 0x75, 0x72, 0x63, 0x68, 0x00,
+    0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x00, 0x43, 0x65, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x67, 0x65, 0x00, 0x54,
+    0x77, 0x65, 0x6c, 0x66, 0x74, 0x68, 0x00, 0x31, 0x32, 0x74, 0x68, 0x00,
+    0x53, 0x6f, 0x75, 0x74, 0x68, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x76, 0x69,
+    0x65, 0x77, 0x00, 0x57, 0x65, 0x73, 0x74, 0x00, 0x4d, 0x69, 0x6c, 0x6c,
+    0x65, 0x72, 0x00, 0x43, 0x68, 0x65, 0x72, 0x72, 0x79, 0x00, 0x42, 0x72,
+    0x6f, 0x61, 0x64, 0x77, 0x61, 0x79, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73,
+    0x6f, 0x6e, 0x00, 0x53, 0x79, 0x63, 0x61, 0x6d, 0x6f, 0x72, 0x65, 0x00,
+    0x45, 0x6c, 0x65, 0x76, 0x6e, 0x74, 0x68, 0x00, 0x31, 0x31, 0x74, 0x68,
+    0x00, 0x48, 0x69, 0x6c, 0x6c, 0x63, 0x72, 0x65, 0x73, 0x74, 0x00, 0x52,
+    0x61, 0x69, 0x6c, 0x72, 0x6f, 0x61, 0x64, 0x00, 0x46, 0x69, 0x66, 0x74,
+    0x65, 0x65, 0x6e, 0x74, 0x68, 0x00, 0x31, 0x35, 0x74, 0x68, 0x00, 0x53,
+    0x75, 0x6e, 0x73, 0x65, 0x74, 0x00, 0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f,
+    0x6e, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x00, 0x41, 0x73, 0x68, 0x00, 0x57,
+    0x69, 0x6c, 0x6c, 0x6f, 0x77, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x6c, 0x61,
+    0x6e, 0x64, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x00, 0x4c,
+    0x6f, 0x63, 0x75, 0x73, 0x74, 0x00, 0x52, 0x69, 0x64, 0x67, 0x65, 0x00,
+    0x50, 0x6f, 0x70, 0x6c, 0x61, 0x72, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x00, 0x44, 0x6f, 0x67, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x54, 0x65,
+    0x6e, 0x74, 0x68, 0x00, 0x31, 0x30, 0x74, 0x68, 0x00, 0x4c, 0x65, 0x65,
+    0x00, 0x57, 0x61, 0x6c, 0x6e, 0x75, 0x74, 0x00, 0x57, 0x69, 0x6c, 0x6c,
+    0x69, 0x61, 0x6d, 0x73, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x42, 0x69,
+    0x72, 0x63, 0x68, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x00, 0x44, 0x61, 0x76,
+    0x69, 0x73, 0x00, 0x39, 0x74, 0x68, 0x00, 0x4e, 0x69, 0x6e, 0x74, 0x68,
+    0x00, 0x4c, 0x61, 0x75, 0x72, 0x65, 0x6c, 0x00, 0x57, 0x61, 0x73, 0x68,
+    0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x70, 0x72, 0x75, 0x63,
+    0x65, 0x00, 0x56, 0x69, 0x65, 0x77, 0x00, 0x31, 0x34, 0x74, 0x68, 0x00,
+    0x46, 0x6f, 0x75, 0x72, 0x74, 0x65, 0x65, 0x6e, 0x74, 0x68, 0x00, 0x45,
+    0x6c, 0x6d, 0x00, 0x41, 0x64, 0x61, 0x6d, 0x73, 0x00, 0x38, 0x74, 0x68,
+    0x00, 0x45, 0x69, 0x67, 0x74, 0x68, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b,
+    0x6c, 0x69, 0x6e, 0x00, 0x43, 0x65, 0x64, 0x61, 0x72, 0x00, 0x31, 0x33,
+    0x74, 0x68, 0x00, 0x54, 0x68, 0x69, 0x72, 0x74, 0x65, 0x65, 0x6e, 0x74,
+    0x68, 0x00, 0x4d, 0x61, 0x70, 0x6c, 0x65, 0x00, 0x43, 0x68, 0x65, 0x73,
+    0x74, 0x6e, 0x75, 0x74, 0x00, 0x50, 0x69, 0x6e, 0x65, 0x00, 0x45, 0x61,
+    0x73, 0x74, 0x00, 0x37, 0x74, 0x68, 0x00, 0x53, 0x65, 0x76, 0x65, 0x6e,
+    0x74, 0x68, 0x00, 0x53, 0x6d, 0x69, 0x74, 0x68, 0x00, 0x4f, 0x61, 0x6b,
+    0x00, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x36, 0x74, 0x68, 0x00,
+    0x53, 0x69, 0x78, 0x74, 0x68, 0x00, 0x4d, 0x65, 0x61, 0x64, 0x6f, 0x77,
+    0x00, 0x4d, 0x61, 0x69, 0x6e, 0x00, 0x52, 0x69, 0x76, 0x65, 0x72, 0x00,
+    0x35, 0x74, 0x68, 0x00, 0x46, 0x69, 0x66, 0x74, 0x68, 0x00, 0x57, 0x69,
+    0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x50, 0x61, 0x72, 0x6b, 0x00, 0x48, 0x69,
+    0x63, 0x6b, 0x6f, 0x72, 0x79, 0x00, 0x34, 0x74, 0x68, 0x00, 0x46, 0x6f,
+    0x75, 0x72, 0x74, 0x68, 0x00, 0x4a, 0x65, 0x66, 0x66, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x00, 0x31, 0x73, 0x74, 0x00, 0x46, 0x69, 0x72, 0x73, 0x74,
+    0x00, 0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x00, 0x33, 0x72, 0x64, 0x00,
+    0x54, 0x68, 0x69, 0x72, 0x64, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f,
+    0x6e, 0x00, 0x32, 0x6e, 0x64, 0x00, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64,
+    0x00, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x11, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00,
+    0x00, 0x24, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00,
+    0x00, 0x34, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00,
+    0x00, 0x40, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00,
+    0x00, 0x51, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00,
+    0x00, 0x5e, 0x00, 0x00, 0x00, 0x64, 0x53, 0x74, 0x72, 0x65, 0x65, 0x74,
+    0x00, 0x53, 0x54, 0x00, 0x41, 0x76, 0x65, 0x6e, 0x75, 0x65, 0x00, 0x41,
+    0x76, 0x65, 0x00, 0x42, 0x6f, 0x75, 0x6c, 0x65, 0x76, 0x61, 0x72, 0x64,
+    0x00, 0x42, 0x6c, 0x76, 0x64, 0x00, 0x52, 0x6f, 0x61, 0x64, 0x00, 0x52,
+    0x44, 0x00, 0x50, 0x61, 0x72, 0x6b, 0x77, 0x61, 0x79, 0x00, 0x50, 0x6b,
+    0x77, 0x79, 0x00, 0x57, 0x61, 0x79, 0x00, 0x57, 0x79, 0x00, 0x44, 0x72,
+    0x69, 0x76, 0x65, 0x00, 0x44, 0x72, 0x2e, 0x00, 0x43, 0x69, 0x72, 0x63,
+    0x6c, 0x65, 0x00, 0x43, 0x69, 0x72, 0x2e, 0x00, 0x4c, 0x61, 0x6e, 0x65,
+    0x00, 0x4c, 0x6e, 0x00, 0x43, 0x6f, 0x75, 0x72, 0x74, 0x00, 0x43, 0x74,
+    0x2e, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00,
+    0x00, 0x6c, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00,
+    0x00, 0x2b, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00,
+    0x00, 0x28, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
+    0x00, 0x23, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+    0x00, 0x20, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00,
+    0x00, 0x1c, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00,
+    0x00, 0x1a, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+    0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+    0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00,
+    0x00, 0x15, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+    0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+    0x00, 0x13, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+    0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+    0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00,
+    0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+    0x00, 0x10, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00,
+    0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00,
+    0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00,
+    0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
+    0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+    0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+    0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
+    0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
+    0x00, 0x0c, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
+    0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
+    0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+    0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+    0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+    0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+    0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
+    0x00, 0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x0f, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00,
+    0x00, 0x23, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00,
+    0x00, 0x36, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00,
+    0x00, 0x51, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00,
+    0x00, 0x6a, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00,
+    0x00, 0x7c, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, 0x8b, 0x00, 0x00,
+    0x00, 0x90, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x9b, 0x00, 0x00,
+    0x00, 0xa0, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0xae, 0x00, 0x00,
+    0x00, 0xb3, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00,
+    0x00, 0xd0, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0xe5, 0x00, 0x00,
+    0x00, 0xed, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00,
+    0x00, 0xfe, 0x00, 0x00, 0x01, 0x06, 0x00, 0x00, 0x01, 0x0b, 0x00, 0x00,
+    0x01, 0x11, 0x00, 0x00, 0x01, 0x17, 0x00, 0x00, 0x01, 0x1f, 0x00, 0x00,
+    0x01, 0x29, 0x00, 0x00, 0x01, 0x31, 0x00, 0x00, 0x01, 0x37, 0x00, 0x00,
+    0x01, 0x3f, 0x00, 0x00, 0x01, 0x48, 0x00, 0x00, 0x01, 0x4f, 0x00, 0x00,
+    0x01, 0x54, 0x00, 0x00, 0x01, 0x5b, 0x00, 0x00, 0x01, 0x62, 0x00, 0x00,
+    0x01, 0x69, 0x00, 0x00, 0x01, 0x71, 0x00, 0x00, 0x01, 0x79, 0x00, 0x00,
+    0x01, 0x83, 0x00, 0x00, 0x01, 0x8c, 0x00, 0x00, 0x01, 0x94, 0x00, 0x00,
+    0x01, 0x9a, 0x00, 0x00, 0x01, 0x9f, 0x00, 0x00, 0x01, 0xa4, 0x00, 0x00,
+    0x01, 0xad, 0x00, 0x00, 0x01, 0xb3, 0x00, 0x00, 0x01, 0xba, 0x00, 0x00,
+    0x01, 0xc0, 0x00, 0x00, 0x01, 0xc8, 0x00, 0x00, 0x01, 0xcd, 0x00, 0x00,
+    0x01, 0xd3, 0x00, 0x00, 0x01, 0xda, 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00,
+    0x01, 0xe6, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x01, 0xf6, 0x00, 0x00,
+    0x02, 0x02, 0x00, 0x00, 0x02, 0x0a, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00,
+    0x02, 0x19, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x02, 0x2b, 0x00, 0x00,
+    0x02, 0x33, 0x00, 0x00, 0x02, 0x37, 0x00, 0x00, 0x02, 0x3d, 0x00, 0x00,
+    0x02, 0x48, 0x00, 0x00, 0x02, 0x51, 0x00, 0x00, 0x02, 0x55, 0x00, 0x00,
+    0x02, 0x5d, 0x00, 0x00, 0x02, 0x66, 0x00, 0x00, 0x02, 0x6a, 0x00, 0x00,
+    0x02, 0x71, 0x00, 0x00, 0x02, 0x76, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00,
+    0x02, 0x86, 0x00, 0x00, 0x02, 0x92, 0x00, 0x00, 0x02, 0x98, 0x00, 0x00,
+    0x02, 0x9f, 0x00, 0x00, 0x02, 0xab, 0x00, 0x00, 0x02, 0xb4, 0x00, 0x00,
+    0x02, 0xc1, 0x00, 0x00, 0x02, 0xc9, 0x00, 0x00, 0x02, 0xd2, 0x00, 0x00,
+    0x02, 0xdb, 0x00, 0x00, 0x02, 0xe6, 0x00, 0x00, 0x02, 0xec, 0x00, 0x00,
+    0x02, 0xf1, 0x00, 0x00, 0x02, 0xfb, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x0d, 0x00, 0x00, 0x03, 0x16, 0x00, 0x00, 0x03, 0x1c, 0x00, 0x00,
+    0x03, 0x21, 0x00, 0x00, 0x03, 0x27, 0x00, 0x00, 0x03, 0x33, 0x00, 0x00,
+    0x03, 0x39, 0x00, 0x00, 0x03, 0x41, 0x00, 0x00, 0x03, 0x49, 0x00, 0x00,
+    0x03, 0x4e, 0x00, 0x00, 0x03, 0x5a, 0x00, 0x00, 0x03, 0x66, 0x00, 0x00,
+    0x03, 0x6c, 0x00, 0x00, 0x03, 0x71, 0x00, 0x00, 0x03, 0x7a, 0x00, 0x00,
+    0x03, 0x84, 0x00, 0x00, 0x03, 0x8b, 0x00, 0x00, 0x03, 0x91, 0x00, 0x00,
+    0x03, 0x96, 0x00, 0x00, 0x03, 0x9e, 0x00, 0x00, 0x03, 0xa2, 0x00, 0x00,
+    0x03, 0xab, 0x00, 0x00, 0x03, 0xb4, 0x00, 0x00, 0x03, 0xbc, 0x00, 0x00,
+    0x03, 0xc6, 0x00, 0x00, 0x03, 0xcf, 0x00, 0x00, 0x03, 0xd8, 0x00, 0x00,
+    0x03, 0xe0, 0x00, 0x00, 0x03, 0xe6, 0x00, 0x00, 0x03, 0xeb, 0x00, 0x00,
+    0x03, 0xf0, 0x00, 0x00, 0x03, 0xf4, 0x00, 0x00, 0x03, 0xfb, 0x00, 0x00,
+    0x04, 0x02, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x04, 0x16, 0x00, 0x00,
+    0x04, 0x1e, 0x00, 0x00, 0x04, 0x29, 0x00, 0x00, 0x04, 0x2f, 0x00, 0x00,
+    0x04, 0x35, 0x00, 0x00, 0x04, 0x3f, 0x00, 0x00, 0x04, 0x46, 0x00, 0x00,
+    0x04, 0x4d, 0x00, 0x00, 0x04, 0x55, 0x00, 0x00, 0x04, 0x5a, 0x00, 0x00,
+    0x04, 0x60, 0x00, 0x00, 0x04, 0x67, 0x00, 0x00, 0x04, 0x71, 0x00, 0x00,
+    0x04, 0x78, 0x00, 0x00, 0x04, 0x7e, 0x00, 0x00, 0x04, 0x85, 0x00, 0x00,
+    0x04, 0x8a, 0x00, 0x00, 0x04, 0x94, 0x00, 0x00, 0x04, 0x9d, 0x00, 0x00,
+    0x04, 0xa5, 0x00, 0x00, 0x04, 0xae, 0x00, 0x00, 0x04, 0xb3, 0x00, 0x00,
+    0x04, 0xb8, 0x00, 0x00, 0x04, 0xc1, 0x00, 0x00, 0x04, 0xc5, 0x00, 0x00,
+    0x04, 0xd0, 0x00, 0x00, 0x04, 0xd6, 0x00, 0x00, 0x04, 0xdd, 0x00, 0x00,
+    0x04, 0xe4, 0x00, 0x00, 0x04, 0xee, 0x00, 0x00, 0x04, 0xf7, 0x00, 0x00,
+    0x04, 0xfc, 0x00, 0x00, 0x05, 0x05, 0x00, 0x00, 0x05, 0x0d, 0x00, 0x00,
+    0x05, 0x18, 0x00, 0x00, 0x05, 0x1d, 0x00, 0x00, 0x05, 0x23, 0x00, 0x00,
+    0x05, 0x29, 0x00, 0x00, 0x05, 0x32, 0x00, 0x00, 0x05, 0x37, 0x00, 0x00,
+    0x05, 0x40, 0x00, 0x00, 0x05, 0x4b, 0x00, 0x00, 0x05, 0x57, 0x00, 0x00,
+    0x05, 0x5f, 0x00, 0x00, 0x05, 0x64, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00,
+    0x05, 0x76, 0x00, 0x00, 0x05, 0x7b, 0x00, 0x00, 0x05, 0x81, 0x00, 0x00,
+    0x05, 0x8c, 0x00, 0x00, 0x05, 0x93, 0x00, 0x00, 0x05, 0x9b, 0x00, 0x00,
+    0x05, 0xa0, 0x00, 0x00, 0x05, 0xa7, 0x00, 0x00, 0x05, 0xab, 0x00, 0x00,
+    0x05, 0xb1, 0x00, 0x00, 0x05, 0xbc, 0x00, 0x00, 0x05, 0xc6, 0x00, 0x00,
+    0x05, 0xd1, 0x00, 0x00, 0x05, 0xd8, 0x00, 0x00, 0x05, 0xe1, 0x00, 0x00,
+    0x05, 0xeb, 0x00, 0x00, 0x05, 0xf1, 0x00, 0x00, 0x05, 0xf7, 0x00, 0x00,
+    0x06, 0x03, 0x00, 0x00, 0x06, 0x07, 0x00, 0x00, 0x06, 0x10, 0x00, 0x00,
+    0x06, 0x1b, 0x00, 0x00, 0x06, 0x20, 0x00, 0x00, 0x06, 0x2a, 0x00, 0x00,
+    0x06, 0x33, 0x00, 0x00, 0x06, 0x3b, 0x00, 0x00, 0x06, 0x40, 0x00, 0x00,
+    0x06, 0x4a, 0x00, 0x00, 0x06, 0x51, 0x00, 0x00, 0x06, 0x5a, 0x00, 0x00,
+    0x06, 0x66, 0x00, 0x00, 0x06, 0x6d, 0x00, 0x00, 0x06, 0x74, 0x00, 0x00,
+    0x06, 0x7e, 0x00, 0x00, 0x06, 0x83, 0x00, 0x00, 0x06, 0x89, 0x00, 0x00,
+    0x06, 0x8e, 0x00, 0x00, 0x06, 0x96, 0x00, 0x00, 0x06, 0x9d, 0x00, 0x00,
+    0x06, 0xa4, 0x00, 0x00, 0x06, 0xac, 0x00, 0x00, 0x06, 0xb1, 0x00, 0x00,
+    0x06, 0xb6, 0x00, 0x00, 0x06, 0xc1, 0x00, 0x00, 0x06, 0xca, 0x00, 0x00,
+    0x06, 0xd3, 0x00, 0x00, 0x06, 0xda, 0x00, 0x00, 0x06, 0xe4, 0x00, 0x00,
+    0x06, 0xec, 0x00, 0x00, 0x06, 0xf1, 0x00, 0x00, 0x06, 0xf7, 0x00, 0x00,
+    0x07, 0x01, 0x00, 0x00, 0x07, 0x0b, 0x00, 0x00, 0x07, 0x19, 0x00, 0x00,
+    0x07, 0x22, 0x00, 0x00, 0x07, 0x2b, 0x00, 0x00, 0x07, 0x32, 0x00, 0x00,
+    0x07, 0x38, 0x00, 0x00, 0x07, 0x40, 0x00, 0x00, 0x07, 0x4a, 0x00, 0x00,
+    0x07, 0x52, 0x00, 0x00, 0x07, 0x5a, 0x00, 0x00, 0x07, 0x60, 0x00, 0x00,
+    0x07, 0x68, 0x00, 0x00, 0x07, 0x70, 0x00, 0x00, 0x07, 0x76, 0x00, 0x00,
+    0x07, 0x7c, 0x00, 0x00, 0x07, 0x84, 0x00, 0x00, 0x07, 0x8e, 0x00, 0x00,
+    0x07, 0x96, 0x00, 0x00, 0x07, 0x9b, 0x00, 0x00, 0x07, 0xa1, 0x00, 0x00,
+    0x07, 0xad, 0x00, 0x00, 0x07, 0xb3, 0x00, 0x00, 0x07, 0xba, 0x00, 0x00,
+    0x07, 0xbe, 0x00, 0x00, 0x07, 0xc3, 0x00, 0x00, 0x07, 0xcc, 0x00, 0x00,
+    0x07, 0xd6, 0x00, 0x00, 0x07, 0xdd, 0x00, 0x00, 0x07, 0xe5, 0x00, 0x00,
+    0x07, 0xed, 0x00, 0x00, 0x07, 0xf1, 0x00, 0x00, 0x07, 0xf9, 0x00, 0x00,
+    0x08, 0x02, 0x00, 0x00, 0x08, 0x0c, 0x00, 0x00, 0x08, 0x19, 0x00, 0x00,
+    0x08, 0x22, 0x00, 0x00, 0x08, 0x2a, 0x00, 0x00, 0x08, 0x32, 0x00, 0x00,
+    0x08, 0x37, 0x00, 0x00, 0x08, 0x3d, 0x00, 0x00, 0x08, 0x43, 0x00, 0x00,
+    0x08, 0x4e, 0x00, 0x00, 0x08, 0x54, 0x00, 0x00, 0x08, 0x5c, 0x00, 0x00,
+    0x08, 0x65, 0x00, 0x00, 0x08, 0x6c, 0x00, 0x00, 0x08, 0x73, 0x00, 0x00,
+    0x08, 0x7b, 0x00, 0x00, 0x08, 0x86, 0x00, 0x00, 0x08, 0x8c, 0x00, 0x00,
+    0x08, 0x91, 0x00, 0x00, 0x08, 0x9b, 0x00, 0x00, 0x08, 0xa2, 0x00, 0x00,
+    0x08, 0xae, 0x00, 0x00, 0x08, 0xb7, 0x00, 0x00, 0x08, 0xbc, 0x00, 0x00,
+    0x08, 0xc4, 0x00, 0x00, 0x08, 0xca, 0x00, 0x00, 0x08, 0xd3, 0x00, 0x00,
+    0x08, 0xdd, 0x00, 0x00, 0x08, 0xe8, 0x00, 0x00, 0x08, 0xf0, 0x00, 0x00,
+    0x08, 0xf7, 0x00, 0x00, 0x08, 0xff, 0x00, 0x00, 0x09, 0x09, 0x00, 0x00,
+    0x09, 0x11, 0x00, 0x00, 0x09, 0x17, 0x00, 0x00, 0x09, 0x1c, 0x00, 0x00,
+    0x09, 0x23, 0x00, 0x00, 0x09, 0x29, 0x00, 0x00, 0x09, 0x33, 0x00, 0x00,
+    0x09, 0x37, 0x00, 0x00, 0x09, 0x3f, 0x00, 0x00, 0x09, 0x45, 0x00, 0x00,
+    0x09, 0x50, 0x00, 0x00, 0x09, 0x5a, 0x00, 0x00, 0x09, 0x63, 0x00, 0x00,
+    0x09, 0x69, 0x00, 0x00, 0x09, 0x6f, 0x00, 0x00, 0x09, 0x74, 0x00, 0x00,
+    0x09, 0x7d, 0x00, 0x00, 0x09, 0x82, 0x00, 0x00, 0x09, 0x8a, 0x00, 0x00,
+    0x09, 0x8e, 0x00, 0x00, 0x09, 0x97, 0x00, 0x00, 0x09, 0xa0, 0x00, 0x00,
+    0x09, 0xa8, 0x00, 0x00, 0x09, 0xae, 0x00, 0x00, 0x09, 0xb5, 0x00, 0x00,
+    0x09, 0xbc, 0x00, 0x00, 0x09, 0xc5, 0x00, 0x00, 0x09, 0xca, 0x00, 0x00,
+    0x09, 0xcf, 0x00, 0x00, 0x09, 0xd8, 0x00, 0x00, 0x09, 0xdf, 0x00, 0x00,
+    0x09, 0xe7, 0x00, 0x00, 0x09, 0xee, 0x00, 0x00, 0x09, 0xf5, 0x00, 0x00,
+    0x09, 0xfc, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x00, 0x0a, 0x09, 0x00, 0x00,
+    0x0a, 0x12, 0x00, 0x00, 0x0a, 0x17, 0x00, 0x00, 0x0a, 0x1f, 0x00, 0x00,
+    0x0a, 0x28, 0x00, 0x00, 0x0a, 0x31, 0x00, 0x00, 0x0a, 0x3a, 0x00, 0x00,
+    0x0a, 0x44, 0x00, 0x00, 0x0a, 0x4f, 0x00, 0x00, 0x0a, 0x59, 0x00, 0x00,
+    0x0a, 0x62, 0x00, 0x00, 0x0a, 0x69, 0x00, 0x00, 0x0a, 0x72, 0x00, 0x00,
+    0x0a, 0x7c, 0x00, 0x00, 0x0a, 0x82, 0x00, 0x00, 0x0a, 0x8f, 0x00, 0x00,
+    0x0a, 0x9c, 0x00, 0x00, 0x0a, 0xa6, 0x00, 0x00, 0x0a, 0xb4, 0x00, 0x00,
+    0x0a, 0xc0, 0x00, 0x00, 0x0a, 0xc7, 0x00, 0x00, 0x0a, 0xd3, 0x00, 0x00,
+    0x0a, 0xd9, 0x00, 0x00, 0x0a, 0xe3, 0x00, 0x00, 0x0a, 0xeb, 0x00, 0x00,
+    0x0a, 0xf1, 0x00, 0x00, 0x0a, 0xf6, 0x00, 0x00, 0x0a, 0xfc, 0x00, 0x00,
+    0x0b, 0x09, 0x00, 0x00, 0x0b, 0x11, 0x00, 0x00, 0x0b, 0x20, 0x00, 0x00,
+    0x0b, 0x29, 0x00, 0x00, 0x0b, 0x34, 0x00, 0x00, 0x0b, 0x3d, 0x00, 0x00,
+    0x0b, 0x45, 0x00, 0x00, 0x0b, 0x49, 0x00, 0x00, 0x0b, 0x54, 0x00, 0x00,
+    0x0b, 0x5c, 0x00, 0x00, 0x0b, 0x64, 0x00, 0x00, 0x0b, 0x6e, 0x00, 0x00,
+    0x0b, 0x74, 0x00, 0x00, 0x0b, 0x7b, 0x00, 0x00, 0x0b, 0x85, 0x00, 0x00,
+    0x0b, 0x90, 0x00, 0x00, 0x0b, 0x9b, 0x00, 0x00, 0x0b, 0xa6, 0x00, 0x00,
+    0x0b, 0xaf, 0x00, 0x00, 0x0b, 0xb6, 0x00, 0x00, 0x0b, 0xbc, 0x00, 0x00,
+    0x0b, 0xc1, 0x00, 0x00, 0x0b, 0xc7, 0x00, 0x00, 0x0b, 0xd3, 0x00, 0x00,
+    0x0b, 0xd9, 0x00, 0x00, 0x0b, 0xe3, 0x00, 0x00, 0x0b, 0xea, 0x00, 0x00,
+    0x0b, 0xf4, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x0a, 0x00, 0x00,
+    0x0c, 0x15, 0x00, 0x00, 0x0c, 0x1b, 0x00, 0x00, 0x0c, 0x29, 0x00, 0x00,
+    0x0c, 0x2e, 0x00, 0x00, 0x0c, 0x38, 0x00, 0x00, 0x0c, 0x3f, 0x00, 0x00,
+    0x0c, 0x46, 0x00, 0x00, 0x0c, 0x4d, 0x00, 0x00, 0x0c, 0x53, 0x00, 0x00,
+    0x0c, 0x5c, 0x00, 0x00, 0x0c, 0x63, 0x00, 0x00, 0x0c, 0x70, 0x00, 0x00,
+    0x0c, 0x76, 0x00, 0x00, 0x0c, 0x7c, 0x00, 0x00, 0x0c, 0x8a, 0x00, 0x00,
+    0x0c, 0x96, 0x00, 0x00, 0x0c, 0x9d, 0x00, 0x00, 0x0c, 0xa6, 0x00, 0x00,
+    0x0c, 0xae, 0x00, 0x00, 0x0c, 0xb2, 0x00, 0x00, 0x0c, 0xbb, 0x00, 0x00,
+    0x0c, 0xc3, 0x00, 0x00, 0x0c, 0xd1, 0x00, 0x00, 0x0c, 0xd7, 0x00, 0x00,
+    0x0c, 0xe1, 0x00, 0x00, 0x0c, 0xe8, 0x00, 0x00, 0x0c, 0xf5, 0x00, 0x00,
+    0x0c, 0xfe, 0x00, 0x00, 0x0d, 0x06, 0x00, 0x00, 0x0d, 0x0f, 0x00, 0x00,
+    0x0d, 0x14, 0x00, 0x00, 0x0d, 0x1c, 0x00, 0x00, 0x0d, 0x25, 0x00, 0x00,
+    0x0d, 0x31, 0x00, 0x00, 0x0d, 0x39, 0x00, 0x00, 0x0d, 0x3f, 0x00, 0x00,
+    0x0d, 0x47, 0x00, 0x00, 0x0d, 0x50, 0x00, 0x00, 0x0d, 0x5b, 0x00, 0x00,
+    0x0d, 0x5f, 0x00, 0x00, 0x0d, 0x67, 0x00, 0x00, 0x0d, 0x6e, 0x00, 0x00,
+    0x0d, 0x76, 0x00, 0x00, 0x0d, 0x7f, 0x00, 0x00, 0x0d, 0x86, 0x00, 0x00,
+    0x0d, 0x8c, 0x00, 0x00, 0x0d, 0x95, 0x00, 0x00, 0x0d, 0x9c, 0x00, 0x00,
+    0x0d, 0xa3, 0x00, 0x00, 0x0d, 0xaa, 0x00, 0x00, 0x0d, 0xaf, 0x00, 0x00,
+    0x0d, 0xb4, 0x00, 0x00, 0x0d, 0xbc, 0x00, 0x00, 0x0d, 0xc5, 0x00, 0x00,
+    0x0d, 0xca, 0x00, 0x00, 0x0d, 0xd3, 0x00, 0x00, 0x0d, 0xd7, 0x00, 0x00,
+    0x0d, 0xdf, 0x00, 0x00, 0x0d, 0xe4, 0x00, 0x00, 0x0d, 0xef, 0x00, 0x00,
+    0x0d, 0xf4, 0x00, 0x00, 0x0d, 0xfb, 0x00, 0x00, 0x0e, 0x01, 0x00, 0x00,
+    0x0e, 0x08, 0x00, 0x00, 0x0e, 0x11, 0x00, 0x00, 0x0e, 0x18, 0x00, 0x00,
+    0x0e, 0x21, 0x00, 0x00, 0x0e, 0x2a, 0x00, 0x00, 0x0e, 0x32, 0x00, 0x00,
+    0x0e, 0x3b, 0x00, 0x00, 0x0e, 0x46, 0x00, 0x00, 0x0e, 0x51, 0x00, 0x00,
+    0x0e, 0x5c, 0x00, 0x00, 0x0e, 0x67, 0x00, 0x00, 0x0e, 0x6b, 0x00, 0x00,
+    0x0e, 0x73, 0x00, 0x00, 0x0e, 0x7d, 0x00, 0x00, 0x0e, 0x83, 0x00, 0x00,
+    0x0e, 0x8a, 0x00, 0x00, 0x0e, 0x8f, 0x00, 0x00, 0x0e, 0x98, 0x00, 0x00,
+    0x0e, 0xa0, 0x00, 0x00, 0x0e, 0xa5, 0x00, 0x00, 0x0e, 0xae, 0x00, 0x00,
+    0x0e, 0xb4, 0x00, 0x00, 0x0e, 0xb9, 0x00, 0x00, 0x0e, 0xbf, 0x00, 0x00,
+    0x0e, 0xc6, 0x00, 0x00, 0x0e, 0xcf, 0x00, 0x00, 0x0e, 0xd7, 0x00, 0x00,
+    0x0e, 0xdb, 0x00, 0x00, 0x0e, 0xe1, 0x00, 0x00, 0x0e, 0xea, 0x00, 0x00,
+    0x0e, 0xf2, 0x00, 0x00, 0x0e, 0xfb, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x06, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x0f, 0x13, 0x00, 0x00,
+    0x0f, 0x18, 0x00, 0x00, 0x0f, 0x1e, 0x00, 0x00, 0x0f, 0x26, 0x00, 0x00,
+    0x0f, 0x34, 0x00, 0x00, 0x0f, 0x41, 0x00, 0x00, 0x0f, 0x47, 0x00, 0x00,
+    0x0f, 0x4f, 0x00, 0x00, 0x0f, 0x58, 0x00, 0x00, 0x0f, 0x5f, 0x00, 0x00,
+    0x0f, 0x68, 0x00, 0x00, 0x0f, 0x73, 0x00, 0x00, 0x0f, 0x7d, 0x00, 0x00,
+    0x0f, 0x86, 0x00, 0x00, 0x0f, 0x92, 0x00, 0x00, 0x0f, 0x9a, 0x00, 0x00,
+    0x0f, 0xa3, 0x00, 0x00, 0x0f, 0xa9, 0x00, 0x00, 0x0f, 0xb4, 0x00, 0x00,
+    0x0f, 0xbe, 0x00, 0x00, 0x0f, 0xc8, 0x00, 0x00, 0x0f, 0xcd, 0x00, 0x00,
+    0x0f, 0xd2, 0x00, 0x00, 0x0f, 0xda, 0x00, 0x00, 0x0f, 0xe3, 0x00, 0x00,
+    0x0f, 0xf1, 0x00, 0x00, 0x0f, 0xfc, 0x00, 0x00, 0x10, 0x0b, 0x00, 0x00,
+    0x10, 0x16, 0x00, 0x00, 0x10, 0x20, 0x00, 0x00, 0x10, 0x29, 0x00, 0x00,
+    0x10, 0x31, 0x00, 0x00, 0x10, 0x3a, 0x00, 0x00, 0x10, 0x40, 0x00, 0x00,
+    0x10, 0x49, 0x00, 0x00, 0x10, 0x50, 0x00, 0x00, 0x10, 0x5a, 0x00, 0x00,
+    0x10, 0x61, 0x00, 0x00, 0x10, 0x67, 0x00, 0x00, 0x10, 0x6e, 0x00, 0x00,
+    0x10, 0x73, 0x00, 0x00, 0x10, 0x79, 0x00, 0x00, 0x10, 0x83, 0x00, 0x00,
+    0x10, 0x8e, 0x00, 0x00, 0x10, 0x98, 0x00, 0x00, 0x10, 0x9f, 0x00, 0x00,
+    0x10, 0xa5, 0x00, 0x00, 0x10, 0xad, 0x00, 0x00, 0x10, 0xb6, 0x00, 0x00,
+    0x10, 0xbc, 0x00, 0x00, 0x10, 0xc2, 0x00, 0x00, 0x10, 0xcb, 0x00, 0x00,
+    0x10, 0xd2, 0x00, 0x00, 0x10, 0xdd, 0x00, 0x00, 0x10, 0xe5, 0x00, 0x00,
+    0x10, 0xf3, 0x00, 0x00, 0x10, 0xf8, 0x00, 0x00, 0x11, 0x03, 0x00, 0x00,
+    0x11, 0x0b, 0x00, 0x00, 0x11, 0x12, 0x00, 0x00, 0x11, 0x1a, 0x00, 0x00,
+    0x11, 0x20, 0x00, 0x00, 0x11, 0x28, 0x00, 0x00, 0x11, 0x33, 0x00, 0x00,
+    0x11, 0x3c, 0x00, 0x00, 0x11, 0x45, 0x00, 0x00, 0x11, 0x4b, 0x00, 0x00,
+    0x11, 0x53, 0x00, 0x00, 0x11, 0x5e, 0x00, 0x00, 0x11, 0x6a, 0x00, 0x00,
+    0x11, 0x71, 0x00, 0x00, 0x11, 0x79, 0x00, 0x00, 0x11, 0x80, 0x00, 0x00,
+    0x11, 0x8e, 0x00, 0x00, 0x11, 0x98, 0x00, 0x00, 0x11, 0xa2, 0x00, 0x00,
+    0x11, 0xaa, 0x00, 0x00, 0x11, 0xb7, 0x00, 0x00, 0x11, 0xbc, 0x00, 0x00,
+    0x11, 0xc1, 0x00, 0x00, 0x11, 0xc9, 0x00, 0x00, 0x11, 0xd2, 0x00, 0x00,
+    0x11, 0xdd, 0x00, 0x00, 0x11, 0xe4, 0x00, 0x00, 0x11, 0xea, 0x00, 0x00,
+    0x11, 0xf0, 0x00, 0x00, 0x11, 0xf9, 0x00, 0x00, 0x12, 0x02, 0x00, 0x00,
+    0x12, 0x0e, 0x00, 0x00, 0x12, 0x15, 0x00, 0x00, 0x12, 0x1d, 0x00, 0x00,
+    0x12, 0x2b, 0x00, 0x00, 0x12, 0x36, 0x00, 0x00, 0x12, 0x42, 0x00, 0x00,
+    0x12, 0x4b, 0x00, 0x00, 0x12, 0x51, 0x00, 0x00, 0x12, 0x5c, 0x00, 0x00,
+    0x12, 0x65, 0x00, 0x00, 0x12, 0x6b, 0x00, 0x00, 0x12, 0x74, 0x00, 0x00,
+    0x12, 0x7b, 0x00, 0x00, 0x12, 0x86, 0x00, 0x00, 0x12, 0x8d, 0x00, 0x00,
+    0x12, 0x98, 0x00, 0x00, 0x12, 0xa3, 0x00, 0x00, 0x12, 0xaa, 0x00, 0x00,
+    0x12, 0xb3, 0x00, 0x00, 0x12, 0xc3, 0x00, 0x00, 0x12, 0xc9, 0x00, 0x00,
+    0x12, 0xcf, 0x00, 0x00, 0x12, 0xd6, 0x00, 0x00, 0x12, 0xdd, 0x00, 0x00,
+    0x12, 0xe2, 0x00, 0x00, 0x12, 0xe9, 0x00, 0x00, 0x12, 0xf0, 0x00, 0x00,
+    0x12, 0xf9, 0x00, 0x00, 0x13, 0x05, 0x00, 0x00, 0x13, 0x0f, 0x00, 0x00,
+    0x13, 0x17, 0x00, 0x00, 0x13, 0x1d, 0x00, 0x00, 0x13, 0x23, 0x00, 0x00,
+    0x13, 0x2d, 0x00, 0x00, 0x13, 0x33, 0x00, 0x00, 0x13, 0x38, 0x00, 0x00,
+    0x13, 0x40, 0x00, 0x00, 0x13, 0x45, 0x00, 0x00, 0x13, 0x49, 0x00, 0x00,
+    0x13, 0x54, 0x00, 0x00, 0x13, 0x5a, 0x00, 0x00, 0x13, 0x61, 0x00, 0x00,
+    0x13, 0x69, 0x00, 0x00, 0x13, 0x72, 0x00, 0x00, 0x13, 0x79, 0x00, 0x00,
+    0x13, 0x83, 0x00, 0x00, 0x13, 0x8a, 0x00, 0x00, 0x13, 0x94, 0x00, 0x00,
+    0x13, 0x9b, 0x00, 0x00, 0x13, 0xa2, 0x00, 0x00, 0x13, 0xaa, 0x00, 0x00,
+    0x13, 0xb3, 0x00, 0x00, 0x13, 0xb9, 0x00, 0x00, 0x13, 0xc4, 0x00, 0x00,
+    0x13, 0xcb, 0x00, 0x00, 0x13, 0xd5, 0x00, 0x00, 0x13, 0xe0, 0x00, 0x00,
+    0x13, 0xec, 0x00, 0x00, 0x13, 0xf5, 0x00, 0x00, 0x14, 0x04, 0x00, 0x00,
+    0x14, 0x0e, 0x00, 0x00, 0x14, 0x19, 0x00, 0x00, 0x14, 0x23, 0x00, 0x00,
+    0x14, 0x2b, 0x00, 0x00, 0x14, 0x35, 0x00, 0x00, 0x14, 0x3c, 0x00, 0x00,
+    0x14, 0x43, 0x00, 0x00, 0x14, 0x4f, 0x00, 0x00, 0x14, 0x5a, 0x00, 0x00,
+    0x14, 0x65, 0x00, 0x00, 0x14, 0x71, 0x00, 0x00, 0x14, 0x7b, 0x00, 0x00,
+    0x14, 0x87, 0x00, 0x00, 0x14, 0x90, 0x00, 0x00, 0x14, 0x9b, 0x00, 0x00,
+    0x14, 0xa6, 0x00, 0x00, 0x14, 0xaf, 0x00, 0x00, 0x14, 0xb9, 0x00, 0x00,
+    0x14, 0xc2, 0x00, 0x00, 0x14, 0xca, 0x00, 0x00, 0x14, 0xd6, 0x00, 0x00,
+    0x14, 0xdf, 0x00, 0x00, 0x14, 0xe8, 0x00, 0x00, 0x14, 0xef, 0x00, 0x00,
+    0x14, 0xf6, 0x00, 0x00, 0x14, 0xfe, 0x00, 0x00, 0x15, 0x06, 0x00, 0x00,
+    0x15, 0x0c, 0x00, 0x00, 0x15, 0x1a, 0x00, 0x00, 0x15, 0x25, 0x00, 0x00,
+    0x15, 0x2e, 0x00, 0x00, 0x15, 0x37, 0x00, 0x00, 0x15, 0x3f, 0x00, 0x00,
+    0x15, 0x47, 0x00, 0x00, 0x15, 0x4f, 0x00, 0x00, 0x15, 0x59, 0x00, 0x00,
+    0x15, 0x62, 0x00, 0x00, 0x15, 0x6e, 0x00, 0x00, 0x15, 0x76, 0x00, 0x00,
+    0x15, 0x7e, 0x00, 0x00, 0x15, 0x87, 0x00, 0x00, 0x15, 0x96, 0x00, 0x00,
+    0x15, 0x9d, 0x00, 0x00, 0x15, 0xa2, 0x00, 0x00, 0x15, 0xad, 0x00, 0x00,
+    0x15, 0xb9, 0x00, 0x00, 0x15, 0xc1, 0x00, 0x00, 0x15, 0xc9, 0x00, 0x00,
+    0x15, 0xd7, 0x00, 0x00, 0x15, 0xe4, 0x00, 0x00, 0x15, 0xee, 0x00, 0x00,
+    0x15, 0xf4, 0x00, 0x00, 0x15, 0xfc, 0x00, 0x00, 0x16, 0x02, 0x00, 0x00,
+    0x16, 0x0a, 0x00, 0x00, 0x16, 0x17, 0x00, 0x00, 0x16, 0x1c, 0x00, 0x00,
+    0x16, 0x23, 0x00, 0x00, 0x16, 0x29, 0x00, 0x00, 0x16, 0x30, 0x00, 0x00,
+    0x16, 0x36, 0x00, 0x00, 0x16, 0x3c, 0x00, 0x00, 0x16, 0x47, 0x00, 0x00,
+    0x16, 0x4f, 0x00, 0x00, 0x16, 0x59, 0x00, 0x00, 0x16, 0x5f, 0x00, 0x00,
+    0x16, 0x65, 0x00, 0x00, 0x16, 0x70, 0x00, 0x00, 0x16, 0x7a, 0x00, 0x00,
+    0x16, 0x82, 0x00, 0x00, 0x16, 0x8a, 0x00, 0x00, 0x16, 0x8f, 0x00, 0x00,
+    0x16, 0x9c, 0x00, 0x00, 0x16, 0xa9, 0x00, 0x00, 0x16, 0xb0, 0x00, 0x00,
+    0x16, 0xbe, 0x00, 0x00, 0x16, 0xc7, 0x00, 0x00, 0x16, 0xd2, 0x00, 0x00,
+    0x16, 0xd9, 0x00, 0x00, 0x16, 0xe6, 0x00, 0x00, 0x16, 0xf1, 0x00, 0x00,
+    0x16, 0xf8, 0x00, 0x00, 0x16, 0xff, 0x00, 0x00, 0x17, 0x0d, 0x00, 0x00,
+    0x17, 0x18, 0x00, 0x00, 0x17, 0x24, 0x00, 0x00, 0x17, 0x2d, 0x00, 0x00,
+    0x17, 0x33, 0x00, 0x00, 0x17, 0x38, 0x00, 0x00, 0x17, 0x3e, 0x00, 0x00,
+    0x17, 0x43, 0x00, 0x00, 0x17, 0x49, 0x00, 0x00, 0x17, 0x50, 0x00, 0x00,
+    0x17, 0x57, 0x00, 0x00, 0x17, 0x5e, 0x00, 0x00, 0x17, 0x66, 0x00, 0x00,
+    0x17, 0x6d, 0x00, 0x00, 0x17, 0x75, 0x00, 0x00, 0x17, 0x80, 0x00, 0x00,
+    0x17, 0x8c, 0x00, 0x00, 0x17, 0x98, 0x00, 0x00, 0x17, 0xa0, 0x00, 0x00,
+    0x17, 0xa5, 0x00, 0x00, 0x17, 0xad, 0x00, 0x00, 0x17, 0xb8, 0x00, 0x00,
+    0x17, 0xc2, 0x00, 0x00, 0x17, 0xcb, 0x00, 0x00, 0x17, 0xd8, 0x00, 0x00,
+    0x17, 0xe1, 0x00, 0x00, 0x17, 0xeb, 0x00, 0x00, 0x17, 0xf7, 0x00, 0x00,
+    0x18, 0x04, 0x00, 0x00, 0x18, 0x0f, 0x00, 0x00, 0x18, 0x16, 0x00, 0x00,
+    0x18, 0x23, 0x00, 0x00, 0x18, 0x31, 0x00, 0x00, 0x18, 0x3a, 0x00, 0x00,
+    0x18, 0x41, 0x00, 0x00, 0x18, 0x4a, 0x00, 0x00, 0x18, 0x56, 0x00, 0x00,
+    0x18, 0x5f, 0x00, 0x00, 0x18, 0x6a, 0x00, 0x00, 0x18, 0x78, 0x00, 0x00,
+    0x18, 0x81, 0x00, 0x00, 0x18, 0x8a, 0x00, 0x00, 0x18, 0x93, 0x00, 0x00,
+    0x18, 0x9b, 0x00, 0x00, 0x18, 0xa7, 0x00, 0x00, 0x18, 0xb3, 0x00, 0x00,
+    0x18, 0xba, 0x00, 0x00, 0x18, 0xc2, 0x00, 0x00, 0x18, 0xcb, 0x00, 0x00,
+    0x18, 0xd6, 0x00, 0x00, 0x18, 0xdd, 0x00, 0x00, 0x18, 0xe3, 0x00, 0x00,
+    0x18, 0xec, 0x00, 0x00, 0x18, 0xf2, 0x00, 0x00, 0x18, 0xf7, 0x00, 0x00,
+    0x18, 0xfd, 0x00, 0x00, 0x19, 0x05, 0x00, 0x00, 0x19, 0x0c, 0x00, 0x00,
+    0x19, 0x15, 0x00, 0x00, 0x19, 0x1b, 0x00, 0x00, 0x19, 0x28, 0x00, 0x00,
+    0x19, 0x30, 0x00, 0x00, 0x19, 0x34, 0x00, 0x00, 0x19, 0x3c, 0x00, 0x00,
+    0x19, 0x47, 0x00, 0x00, 0x19, 0x51, 0x00, 0x00, 0x19, 0x5b, 0x00, 0x00,
+    0x19, 0x67, 0x00, 0x00, 0x19, 0x72, 0x00, 0x00, 0x19, 0x77, 0x00, 0x00,
+    0x19, 0x7b, 0x00, 0x00, 0x19, 0x82, 0x00, 0x00, 0x19, 0x89, 0x00, 0x00,
+    0x19, 0x90, 0x00, 0x00, 0x19, 0x9a, 0x00, 0x00, 0x19, 0xa0, 0x00, 0x00,
+    0x19, 0xac, 0x00, 0x00, 0x19, 0xb8, 0x00, 0x00, 0x19, 0xbe, 0x00, 0x00,
+    0x19, 0xc7, 0x00, 0x00, 0x19, 0xd0, 0x00, 0x00, 0x19, 0xd7, 0x00, 0x00,
+    0x19, 0xe3, 0x00, 0x00, 0x19, 0xea, 0x00, 0x00, 0x19, 0xf4, 0x00, 0x00,
+    0x19, 0xfe, 0x00, 0x00, 0x1a, 0x08, 0x00, 0x00, 0x1a, 0x14, 0x00, 0x00,
+    0x1a, 0x21, 0x00, 0x00, 0x1a, 0x26, 0x00, 0x00, 0x1a, 0x2f, 0x00, 0x00,
+    0x1a, 0x37, 0x00, 0x00, 0x1a, 0x41, 0x00, 0x00, 0x1a, 0x4d, 0x00, 0x00,
+    0x1a, 0x58, 0x00, 0x00, 0x1a, 0x65, 0x00, 0x00, 0x1a, 0x6d, 0x00, 0x00,
+    0x1a, 0x79, 0x00, 0x00, 0x1a, 0x83, 0x00, 0x00, 0x1a, 0x8c, 0x00, 0x00,
+    0x1a, 0x94, 0x00, 0x00, 0x1a, 0x9c, 0x00, 0x00, 0x1a, 0xa6, 0x00, 0x00,
+    0x1a, 0xac, 0x00, 0x00, 0x1a, 0xb4, 0x00, 0x00, 0x1a, 0xba, 0x00, 0x00,
+    0x1a, 0xbf, 0x00, 0x00, 0x1a, 0xc4, 0x00, 0x00, 0x1a, 0xcd, 0x00, 0x00,
+    0x1a, 0xd6, 0x00, 0x00, 0x1a, 0xdd, 0x00, 0x00, 0x1a, 0xe5, 0x00, 0x00,
+    0x1a, 0xf3, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x0b, 0x00, 0x00,
+    0x1b, 0x16, 0x00, 0x00, 0x1b, 0x1e, 0x00, 0x00, 0x1b, 0x29, 0x00, 0x00,
+    0x1b, 0x33, 0x00, 0x00, 0x1b, 0x3e, 0x00, 0x00, 0x1b, 0x48, 0x00, 0x00,
+    0x1b, 0x52, 0x00, 0x00, 0x1b, 0x5b, 0x00, 0x00, 0x1b, 0x66, 0x00, 0x00,
+    0x1b, 0x6f, 0x00, 0x00, 0x1b, 0x79, 0x00, 0x00, 0x1b, 0x82, 0x00, 0x00,
+    0x1b, 0x89, 0x00, 0x00, 0x1b, 0x91, 0x00, 0x00, 0x1b, 0x96, 0x00, 0x00,
+    0x1b, 0x9c, 0x00, 0x00, 0x1b, 0xa2, 0x00, 0x00, 0x1b, 0xa8, 0x00, 0x00,
+    0x1b, 0xaf, 0x00, 0x00, 0x1b, 0xbd, 0x00, 0x00, 0x1b, 0xc2, 0x00, 0x00,
+    0x1b, 0xcd, 0x00, 0x00, 0x1b, 0xd8, 0x00, 0x00, 0x1b, 0xe1, 0x00, 0x00,
+    0x1b, 0xec, 0x00, 0x00, 0x1b, 0xf6, 0x00, 0x00, 0x1c, 0x02, 0x00, 0x00,
+    0x1c, 0x0a, 0x00, 0x00, 0x1c, 0x17, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00,
+    0x1c, 0x2b, 0x00, 0x00, 0x1c, 0x37, 0x00, 0x00, 0x1c, 0x41, 0x00, 0x00,
+    0x1c, 0x4c, 0x00, 0x00, 0x1c, 0x58, 0x00, 0x00, 0x1c, 0x63, 0x00, 0x00,
+    0x1c, 0x6d, 0x00, 0x00, 0x1c, 0x76, 0x00, 0x00, 0x1c, 0x80, 0x00, 0x00,
+    0x1c, 0x89, 0x00, 0x00, 0x1c, 0x92, 0x00, 0x00, 0x1c, 0x9d, 0x00, 0x00,
+    0x1c, 0xa6, 0x00, 0x00, 0x1c, 0xb0, 0x00, 0x00, 0x1c, 0xb8, 0x00, 0x00,
+    0x1c, 0xbf, 0x00, 0x00, 0x1c, 0xc6, 0x00, 0x00, 0x1c, 0xce, 0x00, 0x00,
+    0x1c, 0xd6, 0x00, 0x00, 0x1c, 0xdd, 0x00, 0x00, 0x1c, 0xe6, 0x00, 0x00,
+    0x1c, 0xef, 0x00, 0x00, 0x1c, 0xf8, 0x00, 0x00, 0x1d, 0x01, 0x00, 0x00,
+    0x1d, 0x08, 0x00, 0x00, 0x1d, 0x0f, 0x00, 0x00, 0x1d, 0x1a, 0x00, 0x00,
+    0x1d, 0x23, 0x00, 0x00, 0x1d, 0x2b, 0x00, 0x00, 0x1d, 0x31, 0x00, 0x00,
+    0x1d, 0x38, 0x00, 0x00, 0x1d, 0x3f, 0x00, 0x00, 0x1d, 0x44, 0x00, 0x00,
+    0x1d, 0x4a, 0x00, 0x00, 0x1d, 0x52, 0x00, 0x00, 0x1d, 0x5d, 0x00, 0x00,
+    0x1d, 0x68, 0x00, 0x00, 0x1d, 0x6d, 0x00, 0x00, 0x1d, 0x75, 0x00, 0x00,
+    0x1d, 0x80, 0x00, 0x00, 0x1d, 0x87, 0x00, 0x00, 0x1d, 0x90, 0x00, 0x00,
+    0x1d, 0x9b, 0x00, 0x00, 0x1d, 0xa1, 0x00, 0x00, 0x1d, 0xa9, 0x00, 0x00,
+    0x1d, 0xb2, 0x00, 0x00, 0x1d, 0xbd, 0x00, 0x00, 0x1d, 0xc7, 0x00, 0x00,
+    0x1d, 0xcc, 0x00, 0x00, 0x1d, 0xd6, 0x00, 0x00, 0x1d, 0xe1, 0x00, 0x00,
+    0x1d, 0xeb, 0x00, 0x00, 0x1d, 0xf5, 0x00, 0x00, 0x1d, 0xfd, 0x00, 0x00,
+    0x1e, 0x05, 0x00, 0x00, 0x1e, 0x10, 0x00, 0x00, 0x1e, 0x19, 0x00, 0x00,
+    0x1e, 0x21, 0x00, 0x00, 0x1e, 0x2a, 0x00, 0x00, 0x1e, 0x30, 0x00, 0x00,
+    0x1e, 0x38, 0x00, 0x00, 0x1e, 0x43, 0x00, 0x00, 0x1e, 0x4c, 0x00, 0x00,
+    0x1e, 0x53, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x00, 0x6e, 0x65, 0x77, 0x00,
+    0x67, 0x6f, 0x6f, 0x64, 0x00, 0x6f, 0x6c, 0x64, 0x00, 0x64, 0x69, 0x66,
+    0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x6c, 0x6f, 0x63, 0x61, 0x6c,
+    0x00, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x6c, 0x00, 0x73, 0x6d, 0x61, 0x6c,
+    0x6c, 0x00, 0x67, 0x72, 0x65, 0x61, 0x74, 0x00, 0x69, 0x6d, 0x70, 0x6f,
+    0x72, 0x74, 0x61, 0x6e, 0x74, 0x00, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x61, 0x6c, 0x00, 0x62, 0x72, 0x69, 0x74, 0x69, 0x73, 0x68, 0x00, 0x70,
+    0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x6c, 0x61, 0x72, 0x67,
+    0x65, 0x00, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x00,
+    0x79, 0x6f, 0x75, 0x6e, 0x67, 0x00, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+    0x00, 0x68, 0x69, 0x67, 0x68, 0x00, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,
+    0x62, 0x6c, 0x65, 0x00, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x66, 0x75, 0x6c,
+    0x6c, 0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x00, 0x6d, 0x61, 0x6a, 0x6f, 0x72,
+    0x00, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d,
+    0x69, 0x63, 0x00, 0x72, 0x65, 0x61, 0x6c, 0x00, 0x6c, 0x6f, 0x6e, 0x67,
+    0x00, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x73, 0x70,
+    0x65, 0x63, 0x69, 0x61, 0x6c, 0x00, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+    0x75, 0x6c, 0x61, 0x72, 0x00, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75,
+    0x6c, 0x74, 0x00, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x00, 0x62,
+    0x6c, 0x61, 0x63, 0x6b, 0x00, 0x62, 0x69, 0x67, 0x00, 0x6c, 0x69, 0x74,
+    0x74, 0x6c, 0x65, 0x00, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x00,
+    0x66, 0x72, 0x65, 0x65, 0x00, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x00, 0x77,
+    0x68, 0x69, 0x74, 0x65, 0x00, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72,
+    0x00, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x00, 0x65,
+    0x6e, 0x67, 0x6c, 0x69, 0x73, 0x68, 0x00, 0x65, 0x61, 0x72, 0x6c, 0x79,
+    0x00, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x00, 0x70, 0x65, 0x72,
+    0x73, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e,
+    0x00, 0x74, 0x72, 0x75, 0x65, 0x00, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67,
+    0x00, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x00, 0x72, 0x65, 0x63, 0x65,
+    0x6e, 0x74, 0x00, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x00, 0x66,
+    0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x00, 0x66, 0x69, 0x6e, 0x61, 0x6e,
+    0x63, 0x69, 0x61, 0x6c, 0x00, 0x61, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61,
+    0x6e, 0x00, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x72, 0x6f,
+    0x79, 0x61, 0x6c, 0x00, 0x70, 0x6f, 0x6f, 0x72, 0x00, 0x6f, 0x70, 0x65,
+    0x6e, 0x00, 0x65, 0x75, 0x72, 0x6f, 0x70, 0x65, 0x61, 0x6e, 0x00, 0x77,
+    0x68, 0x6f, 0x6c, 0x65, 0x00, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x00,
+    0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x61,
+    0x6c, 0x00, 0x73, 0x75, 0x72, 0x65, 0x00, 0x73, 0x68, 0x6f, 0x72, 0x74,
+    0x00, 0x6d, 0x6f, 0x64, 0x65, 0x72, 0x6e, 0x00, 0x6c, 0x65, 0x67, 0x61,
+    0x6c, 0x00, 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x00, 0x66, 0x6f, 0x6c, 0x6c,
+    0x6f, 0x77, 0x69, 0x6e, 0x67, 0x00, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x00,
+    0x73, 0x69, 0x67, 0x6e, 0x69, 0x66, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x00,
+    0x73, 0x65, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x70, 0x72, 0x69, 0x6d,
+    0x65, 0x00, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x6e,
+    0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x00, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74,
+    0x72, 0x69, 0x61, 0x6c, 0x00, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+    0x00, 0x62, 0x61, 0x64, 0x00, 0x77, 0x72, 0x6f, 0x6e, 0x67, 0x00, 0x73,
+    0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x00, 0x73, 0x70,
+    0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x00, 0x72, 0x65, 0x64, 0x00, 0x70,
+    0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x00, 0x6d, 0x69, 0x6c, 0x69, 0x74,
+    0x61, 0x72, 0x79, 0x00, 0x6c, 0x6f, 0x77, 0x00, 0x6c, 0x61, 0x62, 0x6f,
+    0x75, 0x72, 0x00, 0x64, 0x65, 0x61, 0x64, 0x00, 0x63, 0x6f, 0x6e, 0x63,
+    0x65, 0x72, 0x6e, 0x65, 0x64, 0x00, 0x62, 0x61, 0x73, 0x69, 0x63, 0x00,
+    0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x00,
+    0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x00, 0x75, 0x73, 0x65, 0x66, 0x75, 0x6c,
+    0x00, 0x74, 0x72, 0x61, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+    0x00, 0x73, 0x63, 0x6f, 0x74, 0x74, 0x69, 0x73, 0x68, 0x00, 0x70, 0x72,
+    0x6f, 0x66, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x70,
+    0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x00, 0x70, 0x68, 0x79, 0x73, 0x69,
+    0x63, 0x61, 0x6c, 0x00, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c,
+    0x00, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x00,
+    0x68, 0x61, 0x70, 0x70, 0x79, 0x00, 0x66, 0x69, 0x6e, 0x65, 0x00, 0x65,
+    0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00, 0x65, 0x61, 0x73,
+    0x79, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x61, 0x62,
+    0x6c, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x00,
+    0x61, 0x77, 0x61, 0x72, 0x65, 0x00, 0x77, 0x69, 0x64, 0x65, 0x00, 0x74,
+    0x6f, 0x74, 0x61, 0x6c, 0x00, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+    0x69, 0x62, 0x6c, 0x65, 0x00, 0x72, 0x65, 0x61, 0x64, 0x79, 0x00, 0x6f,
+    0x62, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x6d, 0x65, 0x64, 0x69, 0x63,
+    0x61, 0x6c, 0x00, 0x6c, 0x65, 0x66, 0x74, 0x00, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x69, 0x6e, 0x64, 0x65,
+    0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x00, 0x68, 0x65, 0x61, 0x76,
+    0x79, 0x00, 0x68, 0x61, 0x72, 0x64, 0x00, 0x65, 0x78, 0x69, 0x73, 0x74,
+    0x69, 0x6e, 0x67, 0x00, 0x65, 0x73, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x61,
+    0x6c, 0x00, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x00, 0x63, 0x69, 0x76,
+    0x69, 0x6c, 0x00, 0x62, 0x6c, 0x75, 0x65, 0x00, 0x77, 0x65, 0x73, 0x74,
+    0x65, 0x72, 0x6e, 0x00, 0x74, 0x6f, 0x70, 0x00, 0x73, 0x65, 0x70, 0x61,
+    0x72, 0x61, 0x74, 0x65, 0x00, 0x72, 0x65, 0x6c, 0x65, 0x76, 0x61, 0x6e,
+    0x74, 0x00, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x72, 0x00, 0x70, 0x72,
+    0x61, 0x63, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x70, 0x6f, 0x77, 0x65,
+    0x72, 0x66, 0x75, 0x6c, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76,
+    0x65, 0x00, 0x6e, 0x75, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x00, 0x6c, 0x69,
+    0x67, 0x68, 0x74, 0x00, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x68, 0x75, 0x67,
+    0x65, 0x00, 0x68, 0x6f, 0x74, 0x00, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65,
+    0x00, 0x66, 0x72, 0x65, 0x6e, 0x63, 0x68, 0x00, 0x65, 0x78, 0x74, 0x72,
+    0x61, 0x00, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e,
+    0x74, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x00,
+    0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x72, 0x63, 0x69, 0x61, 0x6c, 0x00, 0x63,
+    0x6c, 0x6f, 0x73, 0x65, 0x00, 0x63, 0x68, 0x69, 0x65, 0x66, 0x00, 0x62,
+    0x65, 0x61, 0x75, 0x74, 0x69, 0x66, 0x75, 0x6c, 0x00, 0x61, 0x6e, 0x6e,
+    0x75, 0x61, 0x6c, 0x00, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00, 0x77,
+    0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x00, 0x76, 0x65, 0x72, 0x79, 0x00,
+    0x75, 0x73, 0x75, 0x61, 0x6c, 0x00, 0x75, 0x6e, 0x61, 0x62, 0x6c, 0x65,
+    0x00, 0x74, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x73,
+    0x6f, 0x76, 0x69, 0x65, 0x74, 0x00, 0x73, 0x6f, 0x72, 0x72, 0x79, 0x00,
+    0x73, 0x65, 0x78, 0x75, 0x61, 0x6c, 0x00, 0x72, 0x69, 0x63, 0x68, 0x00,
+    0x72, 0x65, 0x6c, 0x69, 0x67, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x72, 0x65,
+    0x67, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x70, 0x72, 0x69, 0x6d, 0x61,
+    0x72, 0x79, 0x00, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x00,
+    0x6e, 0x69, 0x63, 0x65, 0x00, 0x6d, 0x61, 0x6c, 0x65, 0x00, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x00, 0x69, 0x6e, 0x63, 0x00, 0x69,
+    0x6d, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x66, 0x72,
+    0x65, 0x73, 0x68, 0x00, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x00, 0x66,
+    0x61, 0x6d, 0x6f, 0x75, 0x73, 0x00, 0x65, 0x78, 0x63, 0x65, 0x6c, 0x6c,
+    0x65, 0x6e, 0x74, 0x00, 0x64, 0x6f, 0x6d, 0x65, 0x73, 0x74, 0x69, 0x63,
+    0x00, 0x64, 0x61, 0x72, 0x6b, 0x00, 0x63, 0x75, 0x6c, 0x74, 0x75, 0x72,
+    0x61, 0x6c, 0x00, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67, 0x65, 0x00, 0x61,
+    0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x77, 0x61,
+    0x72, 0x6d, 0x00, 0x75, 0x72, 0x62, 0x61, 0x6e, 0x00, 0x75, 0x70, 0x70,
+    0x65, 0x72, 0x00, 0x75, 0x6e, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x00,
+    0x74, 0x69, 0x6e, 0x79, 0x00, 0x73, 0x75, 0x69, 0x74, 0x61, 0x62, 0x6c,
+    0x65, 0x00, 0x73, 0x75, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74,
+    0x00, 0x73, 0x75, 0x62, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x69, 0x61, 0x6c,
+    0x00, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x73, 0x6f, 0x66,
+    0x74, 0x00, 0x73, 0x65, 0x6e, 0x69, 0x6f, 0x72, 0x00, 0x73, 0x63, 0x69,
+    0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x00, 0x73, 0x61, 0x66, 0x65,
+    0x00, 0x72, 0x75, 0x72, 0x61, 0x6c, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f,
+    0x6e, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72,
+    0x00, 0x70, 0x65, 0x72, 0x66, 0x65, 0x63, 0x74, 0x00, 0x70, 0x61, 0x73,
+    0x74, 0x00, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x00, 0x6b, 0x65, 0x79,
+    0x00, 0x6a, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x65, 0x73, 0x74, 0x65, 0x64, 0x00, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69,
+    0x61, 0x74, 0x65, 0x00, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63,
+    0x61, 0x6c, 0x00, 0x67, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x66, 0x61,
+    0x6d, 0x69, 0x6c, 0x69, 0x61, 0x72, 0x00, 0x65, 0x78, 0x70, 0x65, 0x6e,
+    0x73, 0x69, 0x76, 0x65, 0x00, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x00, 0x65,
+    0x6d, 0x70, 0x74, 0x79, 0x00, 0x65, 0x64, 0x75, 0x63, 0x61, 0x74, 0x69,
+    0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x64, 0x75, 0x65, 0x00, 0x64, 0x65, 0x74,
+    0x61, 0x69, 0x6c, 0x65, 0x64, 0x00, 0x64, 0x65, 0x6d, 0x6f, 0x63, 0x72,
+    0x61, 0x74, 0x69, 0x63, 0x00, 0x64, 0x65, 0x65, 0x70, 0x00, 0x64, 0x61,
+    0x6e, 0x67, 0x65, 0x72, 0x6f, 0x75, 0x73, 0x00, 0x63, 0x72, 0x69, 0x74,
+    0x69, 0x63, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74,
+    0x00, 0x63, 0x6f, 0x6c, 0x64, 0x00, 0x63, 0x68, 0x72, 0x69, 0x73, 0x74,
+    0x69, 0x61, 0x6e, 0x00, 0x62, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x61,
+    0x70, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x61, 0x6c, 0x74, 0x65,
+    0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x00, 0x61, 0x66, 0x72, 0x61,
+    0x69, 0x64, 0x00, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x00, 0x77, 0x6f,
+    0x6e, 0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x00, 0x77, 0x69, 0x6c, 0x64,
+    0x00, 0x76, 0x69, 0x74, 0x61, 0x6c, 0x00, 0x76, 0x61, 0x73, 0x74, 0x00,
+    0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x00, 0x75, 0x6e, 0x69, 0x74,
+    0x65, 0x64, 0x00, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x00, 0x74, 0x79,
+    0x70, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x74, 0x68, 0x69, 0x6e, 0x00, 0x74,
+    0x61, 0x6c, 0x6c, 0x00, 0x73, 0x75, 0x62, 0x73, 0x65, 0x71, 0x75, 0x65,
+    0x6e, 0x74, 0x00, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x00,
+    0x73, 0x6f, 0x75, 0x74, 0x68, 0x65, 0x72, 0x6e, 0x00, 0x73, 0x65, 0x76,
+    0x65, 0x72, 0x65, 0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72,
+    0x79, 0x00, 0x72, 0x75, 0x73, 0x73, 0x69, 0x61, 0x6e, 0x00, 0x72, 0x61,
+    0x72, 0x65, 0x00, 0x71, 0x75, 0x69, 0x65, 0x74, 0x00, 0x70, 0x6f, 0x74,
+    0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x00, 0x70, 0x65, 0x72, 0x6d, 0x61,
+    0x6e, 0x65, 0x6e, 0x74, 0x00, 0x70, 0x61, 0x72, 0x6c, 0x69, 0x61, 0x6d,
+    0x65, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x00, 0x6f, 0x66, 0x66, 0x69, 0x63,
+    0x69, 0x61, 0x6c, 0x00, 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x65, 0x72, 0x6e,
+    0x00, 0x6e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x00, 0x6d, 0x69, 0x6e, 0x6f,
+    0x72, 0x00, 0x6d, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x00, 0x6c, 0x6f,
+    0x6e, 0x67, 0x2d, 0x74, 0x65, 0x72, 0x6d, 0x00, 0x6c, 0x69, 0x6d, 0x69,
+    0x74, 0x65, 0x64, 0x00, 0x6c, 0x69, 0x62, 0x65, 0x72, 0x61, 0x6c, 0x00,
+    0x6c, 0x65, 0x76, 0x65, 0x6c, 0x00, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e,
+    0x67, 0x00, 0x69, 0x74, 0x61, 0x6c, 0x69, 0x61, 0x6e, 0x00, 0x69, 0x72,
+    0x69, 0x73, 0x68, 0x00, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x00, 0x69, 0x6e,
+    0x69, 0x74, 0x69, 0x61, 0x6c, 0x00, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61,
+    0x73, 0x65, 0x64, 0x00, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x00,
+    0x67, 0x72, 0x65, 0x79, 0x00, 0x67, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x66,
+    0x75, 0x6e, 0x64, 0x61, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x00, 0x66,
+    0x72, 0x6f, 0x6e, 0x74, 0x00, 0x66, 0x65, 0x6d, 0x61, 0x6c, 0x65, 0x00,
+    0x66, 0x61, 0x72, 0x00, 0x66, 0x61, 0x69, 0x72, 0x00, 0x65, 0x78, 0x74,
+    0x65, 0x72, 0x6e, 0x61, 0x6c, 0x00, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+    0x69, 0x76, 0x65, 0x00, 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65, 0x00, 0x65,
+    0x6c, 0x64, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x65, 0x61, 0x73, 0x74, 0x65,
+    0x72, 0x6e, 0x00, 0x64, 0x72, 0x79, 0x00, 0x63, 0x72, 0x75, 0x63, 0x69,
+    0x61, 0x6c, 0x00, 0x63, 0x72, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x00,
+    0x63, 0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x65, 0x00, 0x63, 0x6f,
+    0x6e, 0x74, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61, 0x72, 0x79, 0x00, 0x63,
+    0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x00, 0x63, 0x61, 0x72, 0x65,
+    0x66, 0x75, 0x6c, 0x00, 0x63, 0x61, 0x70, 0x61, 0x62, 0x6c, 0x65, 0x00,
+    0x62, 0x75, 0x73, 0x79, 0x00, 0x62, 0x72, 0x6f, 0x61, 0x64, 0x00, 0x62,
+    0x72, 0x69, 0x65, 0x66, 0x00, 0x61, 0x74, 0x74, 0x72, 0x61, 0x63, 0x74,
+    0x69, 0x76, 0x65, 0x00, 0x61, 0x6e, 0x67, 0x72, 0x79, 0x00, 0x61, 0x6e,
+    0x63, 0x69, 0x65, 0x6e, 0x74, 0x00, 0x61, 0x63, 0x61, 0x64, 0x65, 0x6d,
+    0x69, 0x63, 0x00, 0x79, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x00, 0x77, 0x6f,
+    0x6f, 0x64, 0x65, 0x6e, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67,
+    0x00, 0x77, 0x69, 0x64, 0x65, 0x73, 0x70, 0x72, 0x65, 0x61, 0x64, 0x00,
+    0x77, 0x65, 0x6c, 0x73, 0x68, 0x00, 0x77, 0x65, 0x61, 0x6b, 0x00, 0x76,
+    0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x00, 0x76, 0x69, 0x73,
+    0x75, 0x61, 0x6c, 0x00, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2d, 0x74, 0x61,
+    0x70, 0x65, 0x64, 0x00, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x62, 0x6c, 0x65,
+    0x00, 0x75, 0x73, 0x65, 0x64, 0x00, 0x75, 0x6e, 0x75, 0x73, 0x75, 0x61,
+    0x6c, 0x00, 0x74, 0x69, 0x72, 0x65, 0x64, 0x00, 0x74, 0x65, 0x72, 0x72,
+    0x69, 0x62, 0x6c, 0x65, 0x00, 0x74, 0x65, 0x6d, 0x70, 0x6f, 0x72, 0x61,
+    0x72, 0x79, 0x00, 0x73, 0x75, 0x72, 0x70, 0x72, 0x69, 0x73, 0x69, 0x6e,
+    0x67, 0x00, 0x73, 0x75, 0x70, 0x72, 0x65, 0x6d, 0x65, 0x00, 0x73, 0x75,
+    0x64, 0x64, 0x65, 0x6e, 0x00, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74,
+    0x00, 0x73, 0x74, 0x61, 0x74, 0x75, 0x74, 0x6f, 0x72, 0x79, 0x00, 0x73,
+    0x70, 0x61, 0x6e, 0x69, 0x73, 0x68, 0x00, 0x73, 0x6f, 0x6c, 0x69, 0x64,
+    0x00, 0x73, 0x6c, 0x6f, 0x77, 0x00, 0x73, 0x69, 0x6c, 0x65, 0x6e, 0x74,
+    0x00, 0x73, 0x68, 0x61, 0x72, 0x70, 0x00, 0x73, 0x65, 0x6e, 0x73, 0x69,
+    0x74, 0x69, 0x76, 0x65, 0x00, 0x73, 0x61, 0x64, 0x00, 0x72, 0x75, 0x6e,
+    0x6e, 0x69, 0x6e, 0x67, 0x00, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x72,
+    0x65, 0x6d, 0x61, 0x72, 0x6b, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x72, 0x65,
+    0x6d, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x72, 0x65, 0x6c, 0x61,
+    0x74, 0x69, 0x76, 0x65, 0x00, 0x72, 0x61, 0x70, 0x69, 0x64, 0x00, 0x71,
+    0x75, 0x69, 0x63, 0x6b, 0x00, 0x70, 0x75, 0x72, 0x65, 0x00, 0x70, 0x72,
+    0x6f, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x00, 0x70, 0x61, 0x6c, 0x65, 0x00,
+    0x6f, 0x76, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x00, 0x6f, 0x64, 0x64, 0x00,
+    0x6e, 0x75, 0x6d, 0x65, 0x72, 0x6f, 0x75, 0x73, 0x00, 0x6e, 0x65, 0x67,
+    0x61, 0x74, 0x69, 0x76, 0x65, 0x00, 0x6d, 0x61, 0x72, 0x72, 0x69, 0x65,
+    0x64, 0x00, 0x6c, 0x75, 0x63, 0x6b, 0x79, 0x00, 0x6c, 0x6f, 0x76, 0x65,
+    0x6c, 0x79, 0x00, 0x6c, 0x69, 0x76, 0x69, 0x6e, 0x67, 0x00, 0x6c, 0x69,
+    0x74, 0x65, 0x72, 0x61, 0x72, 0x79, 0x00, 0x6b, 0x65, 0x65, 0x6e, 0x00,
+    0x6a, 0x75, 0x73, 0x74, 0x00, 0x6a, 0x61, 0x70, 0x61, 0x6e, 0x65, 0x73,
+    0x65, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x00, 0x68, 0x65, 0x61,
+    0x6c, 0x74, 0x68, 0x79, 0x00, 0x67, 0x75, 0x69, 0x6c, 0x74, 0x79, 0x00,
+    0x67, 0x6f, 0x6c, 0x64, 0x65, 0x6e, 0x00, 0x67, 0x6c, 0x6f, 0x62, 0x61,
+    0x6c, 0x00, 0x67, 0x6c, 0x61, 0x64, 0x00, 0x67, 0x65, 0x6e, 0x75, 0x69,
+    0x6e, 0x65, 0x00, 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x6c, 0x79, 0x00,
+    0x66, 0x69, 0x72, 0x6d, 0x00, 0x66, 0x65, 0x64, 0x65, 0x72, 0x61, 0x6c,
+    0x00, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x00, 0x65, 0x78,
+    0x63, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x65, 0x6e, 0x6f, 0x72, 0x6d,
+    0x6f, 0x75, 0x73, 0x00, 0x65, 0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+    0x6c, 0x00, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63,
+    0x00, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x00, 0x64,
+    0x72, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x00, 0x64, 0x6f, 0x75, 0x62,
+    0x6c, 0x65, 0x00, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x63, 0x74, 0x00,
+    0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x00, 0x64, 0x61,
+    0x69, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x69,
+    0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x76,
+    0x61, 0x74, 0x69, 0x76, 0x65, 0x00, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64,
+    0x65, 0x6e, 0x74, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x68, 0x65,
+    0x6e, 0x73, 0x69, 0x76, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x65, 0x74,
+    0x69, 0x74, 0x69, 0x76, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67,
+    0x00, 0x63, 0x6f, 0x6d, 0x66, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65,
+    0x00, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x00, 0x63, 0x6c, 0x61, 0x73, 0x73,
+    0x69, 0x63, 0x61, 0x6c, 0x00, 0x63, 0x61, 0x70, 0x69, 0x74, 0x61, 0x6c,
+    0x00, 0x62, 0x72, 0x6f, 0x77, 0x6e, 0x00, 0x62, 0x61, 0x63, 0x6b, 0x00,
+    0x61, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x61, 0x67, 0x72, 0x69, 0x63, 0x75,
+    0x6c, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x00, 0x61, 0x66, 0x72, 0x69, 0x63,
+    0x61, 0x6e, 0x00, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x72,
+    0x61, 0x74, 0x69, 0x76, 0x65, 0x00, 0x61, 0x64, 0x65, 0x71, 0x75, 0x61,
+    0x74, 0x65, 0x00, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x61, 0x62, 0x6c,
+    0x65, 0x00, 0x61, 0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x00, 0x77,
+    0x72, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x00, 0x77, 0x65, 0x74, 0x00, 0x76,
+    0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x76, 0x69,
+    0x73, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x76, 0x69, 0x6f, 0x6c, 0x65, 0x6e,
+    0x74, 0x00, 0x76, 0x69, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x6e, 0x00,
+    0x76, 0x61, 0x6c, 0x69, 0x64, 0x00, 0x75, 0x72, 0x67, 0x65, 0x6e, 0x74,
+    0x00, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x61, 0x6c, 0x00, 0x75,
+    0x6e, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x00, 0x75, 0x6e,
+    0x65, 0x6d, 0x70, 0x6c, 0x6f, 0x79, 0x65, 0x64, 0x00, 0x75, 0x6e, 0x64,
+    0x65, 0x72, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x00, 0x75, 0x6c, 0x74, 0x69,
+    0x6d, 0x61, 0x74, 0x65, 0x00, 0x74, 0x72, 0x79, 0x69, 0x6e, 0x67, 0x00,
+    0x74, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x74, 0x6f, 0x72, 0x79, 0x00, 0x74,
+    0x68, 0x69, 0x63, 0x6b, 0x00, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x65, 0x74,
+    0x69, 0x63, 0x61, 0x6c, 0x00, 0x73, 0x77, 0x65, 0x65, 0x74, 0x00, 0x73,
+    0x75, 0x72, 0x70, 0x72, 0x69, 0x73, 0x65, 0x64, 0x00, 0x73, 0x74, 0x75,
+    0x70, 0x69, 0x64, 0x00, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69,
+    0x63, 0x00, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x61,
+    0x6c, 0x00, 0x73, 0x70, 0x69, 0x72, 0x69, 0x74, 0x75, 0x61, 0x6c, 0x00,
+    0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x69, 0x73, 0x74, 0x00, 0x73,
+    0x6f, 0x75, 0x6e, 0x64, 0x00, 0x73, 0x6f, 0x70, 0x68, 0x69, 0x73, 0x74,
+    0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x00, 0x73, 0x6f, 0x6c, 0x65, 0x00,
+    0x73, 0x6f, 0x2d, 0x63, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x00, 0x73, 0x6d,
+    0x6f, 0x6f, 0x74, 0x68, 0x00, 0x73, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x00,
+    0x73, 0x69, 0x6c, 0x76, 0x65, 0x72, 0x00, 0x73, 0x69, 0x6c, 0x6c, 0x79,
+    0x00, 0x73, 0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x73, 0x65,
+    0x63, 0x72, 0x65, 0x74, 0x00, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x61,
+    0x63, 0x74, 0x6f, 0x72, 0x79, 0x00, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x00,
+    0x72, 0x6f, 0x6d, 0x61, 0x6e, 0x00, 0x72, 0x65, 0x76, 0x6f, 0x6c, 0x75,
+    0x74, 0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, 0x00, 0x72, 0x65, 0x73, 0x69,
+    0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x00, 0x72, 0x65, 0x6d, 0x6f,
+    0x74, 0x65, 0x00, 0x72, 0x65, 0x6c, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x00,
+    0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x00, 0x72, 0x61, 0x77, 0x00,
+    0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x72, 0x61, 0x64,
+    0x69, 0x63, 0x61, 0x6c, 0x00, 0x70, 0x73, 0x79, 0x63, 0x68, 0x6f, 0x6c,
+    0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x70, 0x72, 0x6f, 0x75, 0x64,
+    0x00, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x00, 0x70,
+    0x72, 0x65, 0x74, 0x74, 0x79, 0x00, 0x70, 0x72, 0x65, 0x73, 0x69, 0x64,
+    0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x00, 0x70, 0x72, 0x65, 0x67, 0x6e,
+    0x61, 0x6e, 0x74, 0x00, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x65, 0x00,
+    0x70, 0x6c, 0x65, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x00, 0x70, 0x69, 0x6e,
+    0x6b, 0x00, 0x70, 0x61, 0x74, 0x69, 0x65, 0x6e, 0x74, 0x00, 0x6f, 0x76,
+    0x65, 0x72, 0x73, 0x65, 0x61, 0x73, 0x00, 0x6f, 0x75, 0x74, 0x73, 0x74,
+    0x61, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x6f, 0x75, 0x74, 0x73, 0x69,
+    0x64, 0x65, 0x00, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x00, 0x6f, 0x72, 0x67,
+    0x61, 0x6e, 0x69, 0x63, 0x00, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74,
+    0x65, 0x00, 0x6f, 0x63, 0x63, 0x61, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+    0x00, 0x6e, 0x65, 0x74, 0x00, 0x6e, 0x65, 0x72, 0x76, 0x6f, 0x75, 0x73,
+    0x00, 0x6d, 0x75, 0x74, 0x75, 0x61, 0x6c, 0x00, 0x6d, 0x75, 0x73, 0x69,
+    0x63, 0x61, 0x6c, 0x00, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65,
+    0x00, 0x6d, 0x6f, 0x76, 0x69, 0x6e, 0x67, 0x00, 0x6d, 0x6f, 0x72, 0x61,
+    0x6c, 0x00, 0x6d, 0x6f, 0x6e, 0x65, 0x74, 0x61, 0x72, 0x79, 0x00, 0x6d,
+    0x6f, 0x64, 0x65, 0x73, 0x74, 0x00, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65,
+    0x00, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x00, 0x6d, 0x65, 0x72, 0x65,
+    0x00, 0x6d, 0x65, 0x61, 0x6e, 0x00, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75,
+    0x6d, 0x00, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x00, 0x6d,
+    0x61, 0x73, 0x73, 0x00, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x61, 0x6c,
+    0x00, 0x6d, 0x61, 0x64, 0x00, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c,
+    0x00, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x6c, 0x69, 0x6e, 0x67, 0x75, 0x69,
+    0x73, 0x74, 0x69, 0x63, 0x00, 0x6c, 0x69, 0x6b, 0x65, 0x00, 0x6c, 0x69,
+    0x61, 0x62, 0x6c, 0x65, 0x00, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x00, 0x6a,
+    0x75, 0x6e, 0x69, 0x6f, 0x72, 0x00, 0x6a, 0x75, 0x64, 0x69, 0x63, 0x69,
+    0x61, 0x6c, 0x00, 0x6a, 0x65, 0x77, 0x69, 0x73, 0x68, 0x00, 0x69, 0x73,
+    0x6f, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x00, 0x69, 0x6e, 0x76, 0x6f, 0x6c,
+    0x76, 0x65, 0x64, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x73, 0x65, 0x00,
+    0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x00, 0x69, 0x6e, 0x65,
+    0x76, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x69, 0x6e, 0x63, 0x72,
+    0x65, 0x61, 0x73, 0x69, 0x6e, 0x67, 0x00, 0x69, 0x6e, 0x61, 0x64, 0x65,
+    0x71, 0x75, 0x61, 0x74, 0x65, 0x00, 0x69, 0x6d, 0x70, 0x72, 0x65, 0x73,
+    0x73, 0x69, 0x76, 0x65, 0x00, 0x69, 0x6c, 0x6c, 0x00, 0x69, 0x6c, 0x6c,
+    0x65, 0x67, 0x61, 0x6c, 0x00, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x63,
+    0x61, 0x6c, 0x00, 0x69, 0x64, 0x65, 0x61, 0x6c, 0x00, 0x68, 0x6f, 0x6e,
+    0x65, 0x73, 0x74, 0x00, 0x68, 0x6f, 0x6c, 0x79, 0x00, 0x68, 0x69, 0x73,
+    0x74, 0x6f, 0x72, 0x69, 0x63, 0x00, 0x68, 0x65, 0x6c, 0x70, 0x66, 0x75,
+    0x6c, 0x00, 0x68, 0x65, 0x61, 0x64, 0x00, 0x67, 0x72, 0x61, 0x74, 0x65,
+    0x66, 0x75, 0x6c, 0x00, 0x67, 0x72, 0x61, 0x6e, 0x64, 0x00, 0x67, 0x6f,
+    0x6c, 0x64, 0x00, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x00, 0x67, 0x65, 0x6e,
+    0x74, 0x6c, 0x65, 0x00, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x6f, 0x75, 0x73,
+    0x00, 0x67, 0x61, 0x73, 0x74, 0x72, 0x69, 0x63, 0x00, 0x66, 0x75, 0x6e,
+    0x00, 0x66, 0x75, 0x6e, 0x6e, 0x79, 0x00, 0x66, 0x72, 0x65, 0x71, 0x75,
+    0x65, 0x6e, 0x74, 0x00, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x00,
+    0x66, 0x6c, 0x65, 0x78, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x66, 0x6c, 0x61,
+    0x74, 0x00, 0x66, 0x69, 0x78, 0x65, 0x64, 0x00, 0x66, 0x61, 0x76, 0x6f,
+    0x72, 0x69, 0x74, 0x65, 0x00, 0x66, 0x61, 0x74, 0x00, 0x66, 0x61, 0x73,
+    0x74, 0x00, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x00, 0x65, 0x78, 0x74, 0x72,
+    0x65, 0x6d, 0x65, 0x00, 0x65, 0x78, 0x74, 0x72, 0x61, 0x6f, 0x72, 0x64,
+    0x69, 0x6e, 0x61, 0x72, 0x79, 0x00, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69,
+    0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x00, 0x65, 0x78, 0x61, 0x63, 0x74,
+    0x00, 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x00, 0x65, 0x76, 0x65,
+    0x72, 0x79, 0x64, 0x61, 0x79, 0x00, 0x65, 0x74, 0x68, 0x6e, 0x69, 0x63,
+    0x00, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x69, 0x63, 0x00, 0x65, 0x6c,
+    0x65, 0x63, 0x74, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x65, 0x6c, 0x65,
+    0x63, 0x74, 0x6f, 0x72, 0x61, 0x6c, 0x00, 0x64, 0x6f, 0x6d, 0x69, 0x6e,
+    0x61, 0x6e, 0x74, 0x00, 0x64, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x63, 0x74,
+    0x69, 0x76, 0x65, 0x00, 0x64, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x00,
+    0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x00, 0x64, 0x69, 0x72,
+    0x74, 0x79, 0x00, 0x64, 0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65,
+    0x64, 0x00, 0x64, 0x65, 0x73, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x00,
+    0x64, 0x65, 0x73, 0x69, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x64, 0x65,
+    0x61, 0x72, 0x00, 0x64, 0x65, 0x61, 0x66, 0x00, 0x63, 0x75, 0x72, 0x69,
+    0x6f, 0x75, 0x73, 0x00, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x76, 0x65,
+    0x00, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x73, 0x69,
+    0x61, 0x6c, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x6f, 0x75,
+    0x73, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69,
+    0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74,
+    0x65, 0x6e, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x63, 0x69, 0x6f, 0x75,
+    0x73, 0x00, 0x63, 0x6c, 0x69, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x63,
+    0x68, 0x69, 0x6e, 0x65, 0x73, 0x65, 0x00, 0x63, 0x68, 0x65, 0x6d, 0x69,
+    0x63, 0x61, 0x6c, 0x00, 0x63, 0x68, 0x65, 0x61, 0x70, 0x00, 0x63, 0x61,
+    0x74, 0x68, 0x6f, 0x6c, 0x69, 0x63, 0x00, 0x62, 0x72, 0x6f, 0x6b, 0x65,
+    0x6e, 0x00, 0x62, 0x72, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x74, 0x00,
+    0x62, 0x6c, 0x6f, 0x6f, 0x64, 0x79, 0x00, 0x62, 0x6c, 0x69, 0x6e, 0x64,
+    0x00, 0x62, 0x69, 0x74, 0x74, 0x65, 0x72, 0x00, 0x62, 0x61, 0x72, 0x65,
+    0x00, 0x61, 0x77, 0x66, 0x75, 0x6c, 0x00, 0x61, 0x75, 0x74, 0x6f, 0x6d,
+    0x61, 0x74, 0x69, 0x63, 0x00, 0x61, 0x75, 0x73, 0x74, 0x72, 0x61, 0x6c,
+    0x69, 0x61, 0x6e, 0x00, 0x61, 0x73, 0x73, 0x69, 0x73, 0x74, 0x61, 0x6e,
+    0x74, 0x00, 0x61, 0x73, 0x6c, 0x65, 0x65, 0x70, 0x00, 0x61, 0x72, 0x6d,
+    0x65, 0x64, 0x00, 0x61, 0x6e, 0x78, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x61,
+    0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x64, 0x00, 0x61, 0x64, 0x75, 0x6c,
+    0x74, 0x00, 0x61, 0x63, 0x75, 0x74, 0x65, 0x00, 0x61, 0x63, 0x63, 0x75,
+    0x72, 0x61, 0x74, 0x65, 0x00, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x79, 0x00,
+    0x77, 0x6f, 0x72, 0x74, 0x68, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x00, 0x77,
+    0x6f, 0x72, 0x72, 0x69, 0x65, 0x64, 0x00, 0x77, 0x6f, 0x72, 0x6b, 0x69,
+    0x6e, 0x67, 0x2d, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x77, 0x69, 0x73,
+    0x65, 0x00, 0x77, 0x65, 0x6c, 0x6c, 0x2d, 0x6b, 0x6e, 0x6f, 0x77, 0x6e,
+    0x00, 0x77, 0x65, 0x6c, 0x63, 0x6f, 0x6d, 0x65, 0x00, 0x77, 0x65, 0x65,
+    0x6b, 0x6c, 0x79, 0x00, 0x77, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x79, 0x00,
+    0x77, 0x61, 0x73, 0x74, 0x65, 0x00, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e,
+    0x67, 0x00, 0x76, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
+    0x00, 0x76, 0x65, 0x72, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x76, 0x61,
+    0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x76, 0x61, 0x67, 0x75, 0x65,
+    0x00, 0x75, 0x73, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x00, 0x75, 0x6e, 0x70,
+    0x6c, 0x65, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x00, 0x75, 0x6e, 0x6e, 0x65,
+    0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x79, 0x00, 0x75, 0x6e, 0x6c, 0x69,
+    0x6b, 0x65, 0x00, 0x75, 0x6e, 0x68, 0x61, 0x70, 0x70, 0x79, 0x00, 0x75,
+    0x6e, 0x66, 0x61, 0x69, 0x72, 0x00, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x66,
+    0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x75, 0x6e, 0x63, 0x68,
+    0x61, 0x6e, 0x67, 0x65, 0x64, 0x00, 0x75, 0x6e, 0x63, 0x65, 0x72, 0x74,
+    0x61, 0x69, 0x6e, 0x00, 0x75, 0x6e, 0x61, 0x77, 0x61, 0x72, 0x65, 0x00,
+    0x75, 0x6e, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x61, 0x62, 0x6c, 0x65,
+    0x00, 0x75, 0x67, 0x6c, 0x79, 0x00, 0x74, 0x77, 0x69, 0x6e, 0x00, 0x74,
+    0x75, 0x72, 0x6b, 0x69, 0x73, 0x68, 0x00, 0x74, 0x72, 0x6f, 0x70, 0x69,
+    0x63, 0x61, 0x6c, 0x00, 0x74, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x64, 0x6f,
+    0x75, 0x73, 0x00, 0x74, 0x72, 0x61, 0x67, 0x69, 0x63, 0x00, 0x74, 0x6f,
+    0x78, 0x69, 0x63, 0x00, 0x74, 0x69, 0x67, 0x68, 0x74, 0x00, 0x74, 0x68,
+    0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x74, 0x68, 0x69, 0x6e, 0x6b,
+    0x69, 0x6e, 0x67, 0x00, 0x74, 0x65, 0x72, 0x72, 0x69, 0x74, 0x6f, 0x72,
+    0x69, 0x61, 0x6c, 0x00, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x74,
+    0x65, 0x65, 0x6e, 0x61, 0x67, 0x65, 0x00, 0x74, 0x65, 0x63, 0x68, 0x6e,
+    0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x73, 0x79, 0x73,
+    0x74, 0x65, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x00, 0x73, 0x79, 0x6d, 0x70,
+    0x61, 0x74, 0x68, 0x65, 0x74, 0x69, 0x63, 0x00, 0x73, 0x79, 0x6d, 0x62,
+    0x6f, 0x6c, 0x69, 0x63, 0x00, 0x73, 0x77, 0x69, 0x73, 0x73, 0x00, 0x73,
+    0x75, 0x73, 0x70, 0x69, 0x63, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x73, 0x75,
+    0x70, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x00, 0x73, 0x75, 0x70, 0x65, 0x72,
+    0x00, 0x73, 0x75, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x00, 0x73, 0x75,
+    0x70, 0x65, 0x72, 0x62, 0x00, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73,
+    0x69, 0x76, 0x65, 0x00, 0x73, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x00, 0x73,
+    0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00, 0x73, 0x74,
+    0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x00, 0x73, 0x74, 0x72,
+    0x69, 0x63, 0x74, 0x00, 0x73, 0x74, 0x72, 0x61, 0x69, 0x67, 0x68, 0x74,
+    0x00, 0x73, 0x74, 0x72, 0x61, 0x69, 0x67, 0x68, 0x74, 0x66, 0x6f, 0x72,
+    0x77, 0x61, 0x72, 0x64, 0x00, 0x73, 0x74, 0x69, 0x6c, 0x6c, 0x00, 0x73,
+    0x74, 0x65, 0x65, 0x70, 0x00, 0x73, 0x74, 0x65, 0x61, 0x64, 0x79, 0x00,
+    0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x00, 0x73, 0x74, 0x61, 0x72, 0x00,
+    0x73, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x73, 0x71, 0x75, 0x61, 0x72,
+    0x65, 0x00, 0x73, 0x70, 0x6c, 0x65, 0x6e, 0x64, 0x69, 0x64, 0x00, 0x73,
+    0x70, 0x65, 0x63, 0x74, 0x61, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x00, 0x73,
+    0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x00, 0x73, 0x70, 0x61,
+    0x74, 0x69, 0x61, 0x6c, 0x00, 0x73, 0x70, 0x61, 0x72, 0x65, 0x00, 0x73,
+    0x6f, 0x6c, 0x61, 0x72, 0x00, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x6c, 0x69,
+    0x73, 0x74, 0x00, 0x73, 0x6d, 0x61, 0x72, 0x74, 0x00, 0x73, 0x6c, 0x69,
+    0x6d, 0x00, 0x73, 0x6b, 0x69, 0x6c, 0x6c, 0x65, 0x64, 0x00, 0x73, 0x69,
+    0x63, 0x6b, 0x00, 0x73, 0x68, 0x79, 0x00, 0x73, 0x68, 0x6f, 0x72, 0x74,
+    0x2d, 0x74, 0x65, 0x72, 0x6d, 0x00, 0x73, 0x68, 0x65, 0x65, 0x72, 0x00,
+    0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x00, 0x73, 0x68, 0x61, 0x6c, 0x6c,
+    0x6f, 0x77, 0x00, 0x73, 0x65, 0x6d, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x00,
+    0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x00, 0x73, 0x65, 0x6c, 0x65, 0x63,
+    0x74, 0x69, 0x76, 0x65, 0x00, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x00,
+    0x73, 0x61, 0x74, 0x69, 0x73, 0x66, 0x69, 0x65, 0x64, 0x00, 0x73, 0x61,
+    0x63, 0x72, 0x65, 0x64, 0x00, 0x72, 0x75, 0x6c, 0x69, 0x6e, 0x67, 0x00,
+    0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x65, 0x00, 0x72, 0x6f, 0x6d, 0x61,
+    0x6e, 0x74, 0x69, 0x63, 0x00, 0x72, 0x69, 0x67, 0x69, 0x64, 0x00, 0x72,
+    0x69, 0x64, 0x69, 0x63, 0x75, 0x6c, 0x6f, 0x75, 0x73, 0x00, 0x72, 0x65,
+    0x74, 0x61, 0x69, 0x6c, 0x00, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x69,
+    0x6e, 0x67, 0x00, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76,
+    0x65, 0x00, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x61, 0x62, 0x6c,
+    0x65, 0x00, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x00, 0x72,
+    0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x76,
+    0x65, 0x00, 0x72, 0x65, 0x6c, 0x75, 0x63, 0x74, 0x61, 0x6e, 0x74, 0x00,
+    0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x74, 0x6f, 0x72, 0x79, 0x00, 0x72,
+    0x65, 0x64, 0x75, 0x6e, 0x64, 0x61, 0x6e, 0x74, 0x00, 0x72, 0x65, 0x64,
+    0x75, 0x63, 0x65, 0x64, 0x00, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x74,
+    0x69, 0x63, 0x00, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x00, 0x72, 0x61,
+    0x63, 0x69, 0x61, 0x6c, 0x00, 0x70, 0x73, 0x79, 0x63, 0x68, 0x69, 0x61,
+    0x74, 0x72, 0x69, 0x63, 0x00, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x6e, 0x63,
+    0x69, 0x61, 0x6c, 0x00, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69,
+    0x76, 0x65, 0x00, 0x70, 0x72, 0x6f, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69,
+    0x76, 0x65, 0x00, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x6e, 0x65, 0x6e, 0x74,
+    0x00, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x69, 0x76, 0x65,
+    0x00, 0x70, 0x72, 0x6f, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x00, 0x70, 0x72,
+    0x6f, 0x66, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x70, 0x72, 0x6f,
+    0x64, 0x75, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00, 0x70, 0x72, 0x6f, 0x62,
+    0x61, 0x62, 0x6c, 0x65, 0x00, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69,
+    0x76, 0x65, 0x00, 0x70, 0x72, 0x65, 0x70, 0x61, 0x72, 0x65, 0x64, 0x00,
+    0x70, 0x72, 0x65, 0x6d, 0x69, 0x65, 0x72, 0x00, 0x70, 0x72, 0x65, 0x6c,
+    0x69, 0x6d, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x00, 0x70, 0x72, 0x65, 0x63,
+    0x69, 0x6f, 0x75, 0x73, 0x00, 0x70, 0x6f, 0x73, 0x74, 0x2d, 0x77, 0x61,
+    0x72, 0x00, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x00, 0x70, 0x6f, 0x6c,
+    0x69, 0x73, 0x68, 0x00, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x00,
+    0x70, 0x6c, 0x61, 0x6e, 0x6e, 0x65, 0x64, 0x00, 0x70, 0x6c, 0x61, 0x69,
+    0x6e, 0x00, 0x70, 0x68, 0x69, 0x6c, 0x6f, 0x73, 0x6f, 0x70, 0x68, 0x69,
+    0x63, 0x61, 0x6c, 0x00, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65,
+    0x6e, 0x74, 0x00, 0x70, 0x65, 0x63, 0x75, 0x6c, 0x69, 0x61, 0x72, 0x00,
+    0x70, 0x65, 0x61, 0x63, 0x65, 0x66, 0x75, 0x6c, 0x00, 0x70, 0x61, 0x79,
+    0x61, 0x62, 0x6c, 0x65, 0x00, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65,
+    0x00, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x00, 0x70, 0x61, 0x72,
+    0x74, 0x2d, 0x74, 0x69, 0x6d, 0x65, 0x00, 0x70, 0x61, 0x72, 0x65, 0x6e,
+    0x74, 0x61, 0x6c, 0x00, 0x70, 0x61, 0x6c, 0x65, 0x73, 0x74, 0x69, 0x6e,
+    0x69, 0x61, 0x6e, 0x00, 0x70, 0x61, 0x69, 0x6e, 0x66, 0x75, 0x6c, 0x00,
+    0x6f, 0x75, 0x74, 0x64, 0x6f, 0x6f, 0x72, 0x00, 0x6f, 0x72, 0x74, 0x68,
+    0x6f, 0x64, 0x6f, 0x78, 0x00, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x73,
+    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x6f, 0x72, 0x61, 0x6e,
+    0x67, 0x65, 0x00, 0x6f, 0x72, 0x61, 0x6c, 0x00, 0x6f, 0x70, 0x74, 0x69,
+    0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x00, 0x6f, 0x70, 0x65, 0x72, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x6f, 0x70, 0x65, 0x6e, 0x69,
+    0x6e, 0x67, 0x00, 0x6f, 0x6c, 0x79, 0x6d, 0x70, 0x69, 0x63, 0x00, 0x6f,
+    0x6c, 0x64, 0x2d, 0x66, 0x61, 0x73, 0x68, 0x69, 0x6f, 0x6e, 0x65, 0x64,
+    0x00, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+    0x6c, 0x00, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00,
+    0x6e, 0x6f, 0x76, 0x65, 0x6c, 0x00, 0x6e, 0x6f, 0x74, 0x61, 0x62, 0x6c,
+    0x65, 0x00, 0x6e, 0x6f, 0x62, 0x6c, 0x65, 0x00, 0x6e, 0x65, 0x75, 0x74,
+    0x72, 0x61, 0x6c, 0x00, 0x6e, 0x65, 0x69, 0x67, 0x68, 0x62, 0x6f, 0x75,
+    0x72, 0x69, 0x6e, 0x67, 0x00, 0x6e, 0x65, 0x61, 0x74, 0x00, 0x6e, 0x65,
+    0x61, 0x72, 0x62, 0x79, 0x00, 0x6e, 0x61, 0x76, 0x61, 0x6c, 0x00, 0x6e,
+    0x61, 0x74, 0x69, 0x76, 0x65, 0x00, 0x6e, 0x61, 0x73, 0x74, 0x79, 0x00,
+    0x6e, 0x61, 0x6b, 0x65, 0x64, 0x00, 0x6d, 0x79, 0x73, 0x74, 0x65, 0x72,
+    0x69, 0x6f, 0x75, 0x73, 0x00, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x6c, 0x79,
+    0x00, 0x6d, 0x6f, 0x6c, 0x65, 0x63, 0x75, 0x6c, 0x61, 0x72, 0x00, 0x6d,
+    0x6f, 0x64, 0x65, 0x6c, 0x00, 0x6d, 0x69, 0x78, 0x65, 0x64, 0x00, 0x6d,
+    0x69, 0x73, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x6d, 0x69,
+    0x73, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x6d, 0x69, 0x6e, 0x69,
+    0x6d, 0x75, 0x6d, 0x00, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x61, 0x6c, 0x00,
+    0x6d, 0x69, 0x6c, 0x64, 0x00, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x2d,
+    0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x6d, 0x65, 0x74, 0x72, 0x6f, 0x70,
+    0x6f, 0x6c, 0x69, 0x74, 0x61, 0x6e, 0x00, 0x6d, 0x65, 0x64, 0x69, 0x75,
+    0x6d, 0x00, 0x6d, 0x65, 0x64, 0x69, 0x74, 0x65, 0x72, 0x72, 0x61, 0x6e,
+    0x65, 0x61, 0x6e, 0x00, 0x6d, 0x65, 0x64, 0x69, 0x65, 0x76, 0x61, 0x6c,
+    0x00, 0x6d, 0x65, 0x63, 0x68, 0x61, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x00,
+    0x6d, 0x61, 0x74, 0x75, 0x72, 0x65, 0x00, 0x6d, 0x61, 0x74, 0x68, 0x65,
+    0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x6d, 0x61, 0x72, 0x76,
+    0x65, 0x6c, 0x6c, 0x6f, 0x75, 0x73, 0x00, 0x6d, 0x61, 0x72, 0x6b, 0x65,
+    0x64, 0x00, 0x6d, 0x61, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x6d, 0x61, 0x6e,
+    0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x6d,
+    0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x00, 0x6d, 0x61,
+    0x67, 0x6e, 0x69, 0x66, 0x69, 0x63, 0x65, 0x6e, 0x74, 0x00, 0x6d, 0x61,
+    0x67, 0x6e, 0x65, 0x74, 0x69, 0x63, 0x00, 0x6d, 0x61, 0x67, 0x69, 0x63,
+    0x00, 0x6c, 0x74, 0x64, 0x2e, 0x00, 0x6c, 0x6f, 0x79, 0x61, 0x6c, 0x00,
+    0x6c, 0x6f, 0x73, 0x74, 0x00, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x00, 0x6c,
+    0x6f, 0x6e, 0x65, 0x6c, 0x79, 0x00, 0x6c, 0x69, 0x76, 0x65, 0x6c, 0x79,
+    0x00, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x00, 0x6c, 0x65, 0x78, 0x69,
+    0x63, 0x61, 0x6c, 0x00, 0x6c, 0x65, 0x73, 0x73, 0x65, 0x72, 0x00, 0x6c,
+    0x65, 0x6e, 0x67, 0x74, 0x68, 0x79, 0x00, 0x6c, 0x65, 0x67, 0x69, 0x74,
+    0x69, 0x6d, 0x61, 0x74, 0x65, 0x00, 0x6c, 0x65, 0x67, 0x69, 0x73, 0x6c,
+    0x61, 0x74, 0x69, 0x76, 0x65, 0x00, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x2d,
+    0x73, 0x63, 0x61, 0x6c, 0x65, 0x00, 0x6c, 0x61, 0x63, 0x6b, 0x69, 0x6e,
+    0x67, 0x00, 0x6b, 0x69, 0x6e, 0x64, 0x00, 0x69, 0x73, 0x6c, 0x61, 0x6d,
+    0x69, 0x63, 0x00, 0x69, 0x72, 0x72, 0x65, 0x6c, 0x65, 0x76, 0x61, 0x6e,
+    0x74, 0x00, 0x69, 0x6e, 0x76, 0x69, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x00,
+    0x69, 0x6e, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x00, 0x69, 0x6e, 0x74,
+    0x65, 0x72, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x00, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x69, 0x6f, 0x72, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+    0x73, 0x69, 0x76, 0x65, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x6c, 0x6c, 0x69,
+    0x67, 0x65, 0x6e, 0x74, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x6c, 0x6c, 0x65,
+    0x63, 0x74, 0x75, 0x61, 0x6c, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72,
+    0x61, 0x74, 0x65, 0x64, 0x00, 0x69, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x00,
+    0x69, 0x6e, 0x73, 0x75, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74,
+    0x00, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x69, 0x6f, 0x6e,
+    0x61, 0x6c, 0x00, 0x69, 0x6e, 0x6e, 0x6f, 0x63, 0x65, 0x6e, 0x74, 0x00,
+    0x69, 0x6e, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x69, 0x6e, 0x68, 0x65, 0x72,
+    0x65, 0x6e, 0x74, 0x00, 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65, 0x6e, 0x74,
+    0x69, 0x61, 0x6c, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74,
+    0x00, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x64, 0x69, 0x62, 0x6c, 0x65, 0x00,
+    0x69, 0x6e, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, 0x74,
+    0x65, 0x00, 0x69, 0x6d, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x00, 0x69,
+    0x6d, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x00, 0x69, 0x6d, 0x70, 0x65,
+    0x72, 0x69, 0x61, 0x6c, 0x00, 0x69, 0x6d, 0x6d, 0x65, 0x6e, 0x73, 0x65,
+    0x00, 0x69, 0x6d, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65,
+    0x00, 0x69, 0x64, 0x65, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c,
+    0x00, 0x68, 0x75, 0x6e, 0x67, 0x72, 0x79, 0x00, 0x68, 0x6f, 0x73, 0x74,
+    0x69, 0x6c, 0x65, 0x00, 0x68, 0x6f, 0x72, 0x72, 0x69, 0x62, 0x6c, 0x65,
+    0x00, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x74, 0x61, 0x6c, 0x00,
+    0x68, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x00, 0x68, 0x61, 0x72, 0x73, 0x68,
+    0x00, 0x68, 0x61, 0x6e, 0x64, 0x73, 0x6f, 0x6d, 0x65, 0x00, 0x67, 0x72,
+    0x6f, 0x73, 0x73, 0x00, 0x67, 0x72, 0x69, 0x6d, 0x00, 0x67, 0x72, 0x65,
+    0x65, 0x6b, 0x00, 0x67, 0x72, 0x61, 0x64, 0x75, 0x61, 0x6c, 0x00, 0x67,
+    0x6f, 0x74, 0x68, 0x69, 0x63, 0x00, 0x67, 0x6c, 0x6f, 0x72, 0x69, 0x6f,
+    0x75, 0x73, 0x00, 0x67, 0x69, 0x61, 0x6e, 0x74, 0x00, 0x67, 0x65, 0x6f,
+    0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x67, 0x65,
+    0x6e, 0x65, 0x74, 0x69, 0x63, 0x00, 0x67, 0x61, 0x79, 0x00, 0x66, 0x75,
+    0x72, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
+    0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x66, 0x75, 0x6c, 0x6c, 0x2d, 0x74, 0x69,
+    0x6d, 0x65, 0x00, 0x66, 0x6f, 0x72, 0x74, 0x75, 0x6e, 0x61, 0x74, 0x65,
+    0x00, 0x66, 0x6f, 0x72, 0x74, 0x68, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67,
+    0x00, 0x66, 0x6f, 0x72, 0x6d, 0x69, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x00,
+    0x66, 0x6f, 0x6e, 0x64, 0x00, 0x66, 0x69, 0x74, 0x00, 0x66, 0x69, 0x73,
+    0x63, 0x61, 0x6c, 0x00, 0x66, 0x69, 0x65, 0x72, 0x63, 0x65, 0x00, 0x66,
+    0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x00, 0x66, 0x61, 0x76, 0x6f, 0x72, 0x61,
+    0x62, 0x6c, 0x65, 0x00, 0x66, 0x61, 0x74, 0x61, 0x6c, 0x00, 0x66, 0x61,
+    0x73, 0x68, 0x69, 0x6f, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x66, 0x61,
+    0x73, 0x63, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x66, 0x61,
+    0x69, 0x6e, 0x74, 0x00, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64,
+    0x00, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x00, 0x65, 0x78,
+    0x70, 0x65, 0x72, 0x74, 0x00, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x65,
+    0x6e, 0x63, 0x65, 0x64, 0x00, 0x65, 0x78, 0x6f, 0x74, 0x69, 0x63, 0x00,
+    0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x76, 0x65, 0x00, 0x65, 0x78,
+    0x63, 0x6c, 0x75, 0x73, 0x69, 0x76, 0x65, 0x00, 0x65, 0x78, 0x63, 0x65,
+    0x73, 0x73, 0x69, 0x76, 0x65, 0x00, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74,
+    0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x65, 0x76, 0x6f, 0x6c, 0x75, 0x74,
+    0x69, 0x6f, 0x6e, 0x61, 0x72, 0x79, 0x00, 0x65, 0x76, 0x69, 0x6c, 0x00,
+    0x65, 0x76, 0x65, 0x6e, 0x74, 0x75, 0x61, 0x6c, 0x00, 0x65, 0x74, 0x68,
+    0x69, 0x63, 0x61, 0x6c, 0x00, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74,
+    0x65, 0x64, 0x00, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68,
+    0x65, 0x64, 0x00, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61, 0x6c, 0x65, 0x6e,
+    0x74, 0x00, 0x65, 0x6e, 0x74, 0x68, 0x75, 0x73, 0x69, 0x61, 0x73, 0x74,
+    0x69, 0x63, 0x00, 0x65, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x00, 0x65,
+    0x6e, 0x63, 0x6f, 0x75, 0x72, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x00, 0x65,
+    0x6d, 0x70, 0x69, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x65, 0x6c, 0x69,
+    0x67, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x6e,
+    0x74, 0x00, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x65, 0x64, 0x00, 0x65, 0x6c,
+    0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x65, 0x00, 0x65, 0x61, 0x67, 0x65,
+    0x72, 0x00, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x00, 0x64, 0x75,
+    0x74, 0x63, 0x68, 0x00, 0x64, 0x75, 0x6c, 0x6c, 0x00, 0x64, 0x75, 0x61,
+    0x6c, 0x00, 0x64, 0x72, 0x65, 0x61, 0x64, 0x66, 0x75, 0x6c, 0x00, 0x64,
+    0x6f, 0x75, 0x62, 0x74, 0x66, 0x75, 0x6c, 0x00, 0x64, 0x69, 0x76, 0x69,
+    0x6e, 0x65, 0x00, 0x64, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x00, 0x64,
+    0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x75, 0x69, 0x73, 0x68, 0x65, 0x64,
+    0x00, 0x64, 0x69, 0x73, 0x63, 0x69, 0x70, 0x6c, 0x69, 0x6e, 0x61, 0x72,
+    0x79, 0x00, 0x64, 0x69, 0x73, 0x61, 0x73, 0x74, 0x72, 0x6f, 0x75, 0x73,
+    0x00, 0x64, 0x69, 0x70, 0x6c, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x00,
+    0x64, 0x69, 0x67, 0x69, 0x74, 0x61, 0x6c, 0x00, 0x64, 0x65, 0x76, 0x65,
+    0x6c, 0x6f, 0x70, 0x69, 0x6e, 0x67, 0x00, 0x64, 0x65, 0x6d, 0x61, 0x6e,
+    0x64, 0x69, 0x6e, 0x67, 0x00, 0x64, 0x65, 0x6c, 0x69, 0x67, 0x68, 0x74,
+    0x66, 0x75, 0x6c, 0x00, 0x64, 0x65, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x65,
+    0x64, 0x00, 0x64, 0x65, 0x6c, 0x69, 0x63, 0x69, 0x6f, 0x75, 0x73, 0x00,
+    0x64, 0x65, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x64, 0x65, 0x6c,
+    0x69, 0x62, 0x65, 0x72, 0x61, 0x74, 0x65, 0x00, 0x64, 0x65, 0x66, 0x69,
+    0x6e, 0x69, 0x74, 0x65, 0x00, 0x64, 0x65, 0x66, 0x65, 0x6e, 0x73, 0x69,
+    0x76, 0x65, 0x00, 0x64, 0x65, 0x63, 0x69, 0x73, 0x69, 0x76, 0x65, 0x00,
+    0x64, 0x65, 0x63, 0x65, 0x6e, 0x74, 0x00, 0x64, 0x61, 0x72, 0x6c, 0x69,
+    0x6e, 0x67, 0x00, 0x64, 0x61, 0x6d, 0x70, 0x00, 0x63, 0x72, 0x75, 0x65,
+    0x6c, 0x00, 0x63, 0x72, 0x75, 0x64, 0x65, 0x00, 0x63, 0x72, 0x61, 0x7a,
+    0x79, 0x00, 0x63, 0x6f, 0x73, 0x74, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x72,
+    0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x63,
+    0x6f, 0x6f, 0x6c, 0x00, 0x63, 0x6f, 0x6e, 0x76, 0x69, 0x6e, 0x63, 0x69,
+    0x6e, 0x67, 0x00, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e,
+    0x74, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x72, 0x79, 0x00, 0x63,
+    0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x69, 0x6e, 0x67, 0x00, 0x63, 0x6f,
+    0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x64, 0x00, 0x63, 0x6f, 0x6e, 0x74,
+    0x69, 0x6e, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x6e, 0x74,
+    0x65, 0x6e, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e,
+    0x74, 0x69, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x6e, 0x63, 0x72, 0x65, 0x74,
+    0x65, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x6c, 0x73, 0x6f, 0x72, 0x79,
+    0x00, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64,
+    0x00, 0x63, 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x00, 0x63,
+    0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x63, 0x6f,
+    0x6d, 0x70, 0x61, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x00, 0x63, 0x6f,
+    0x6d, 0x70, 0x61, 0x72, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x63, 0x6f, 0x6d,
+    0x6d, 0x75, 0x6e, 0x69, 0x73, 0x74, 0x00, 0x63, 0x6f, 0x6d, 0x62, 0x69,
+    0x6e, 0x65, 0x64, 0x00, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x66, 0x75,
+    0x6c, 0x00, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x65, 0x64, 0x00, 0x63,
+    0x6f, 0x6c, 0x6f, 0x6e, 0x69, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x6c, 0x6c,
+    0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x00, 0x63, 0x6f, 0x68, 0x65, 0x72,
+    0x65, 0x6e, 0x74, 0x00, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x74, 0x69, 0x76,
+    0x65, 0x00, 0x63, 0x6f, 0x61, 0x73, 0x74, 0x61, 0x6c, 0x00, 0x63, 0x6c,
+    0x6f, 0x73, 0x65, 0x64, 0x00, 0x63, 0x6c, 0x65, 0x76, 0x65, 0x72, 0x00,
+    0x63, 0x6c, 0x61, 0x73, 0x73, 0x69, 0x63, 0x00, 0x63, 0x68, 0x72, 0x6f,
+    0x6e, 0x69, 0x63, 0x00, 0x63, 0x68, 0x6f, 0x73, 0x65, 0x6e, 0x00, 0x63,
+    0x68, 0x65, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x00, 0x63, 0x68, 0x61, 0x72,
+    0x6d, 0x69, 0x6e, 0x67, 0x00, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x69, 0x6e,
+    0x67, 0x00, 0x63, 0x61, 0x75, 0x74, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x63,
+    0x61, 0x75, 0x73, 0x61, 0x6c, 0x00, 0x63, 0x61, 0x73, 0x75, 0x61, 0x6c,
+    0x00, 0x63, 0x61, 0x70, 0x69, 0x74, 0x61, 0x6c, 0x69, 0x73, 0x74, 0x00,
+    0x63, 0x61, 0x6e, 0x61, 0x64, 0x69, 0x61, 0x6e, 0x00, 0x62, 0x75, 0x72,
+    0x6e, 0x69, 0x6e, 0x67, 0x00, 0x62, 0x72, 0x61, 0x76, 0x65, 0x00, 0x62,
+    0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x00, 0x62, 0x6f, 0x72, 0x69, 0x6e, 0x67,
+    0x00, 0x62, 0x6f, 0x6c, 0x64, 0x00, 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x00,
+    0x62, 0x69, 0x7a, 0x61, 0x72, 0x72, 0x65, 0x00, 0x62, 0x69, 0x6f, 0x6c,
+    0x6f, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x62, 0x65, 0x6e, 0x65, 0x66,
+    0x69, 0x63, 0x69, 0x61, 0x6c, 0x00, 0x62, 0x61, 0x73, 0x65, 0x00, 0x61,
+    0x77, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x00, 0x61, 0x75, 0x74, 0x6f, 0x6e,
+    0x6f, 0x6d, 0x6f, 0x75, 0x73, 0x00, 0x61, 0x74, 0x6f, 0x6d, 0x69, 0x63,
+    0x00, 0x61, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x00, 0x61, 0x73,
+    0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x00, 0x61, 0x73, 0x69,
+    0x61, 0x6e, 0x00, 0x61, 0x73, 0x68, 0x61, 0x6d, 0x65, 0x64, 0x00, 0x61,
+    0x72, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x00, 0x61, 0x72, 0x74, 0x69,
+    0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x00, 0x61, 0x72, 0x62, 0x69, 0x74,
+    0x72, 0x61, 0x72, 0x79, 0x00, 0x61, 0x72, 0x61, 0x62, 0x00, 0x61, 0x70,
+    0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x64, 0x00, 0x61, 0x70, 0x70, 0x6c,
+    0x69, 0x63, 0x61, 0x62, 0x6c, 0x65, 0x00, 0x61, 0x6e, 0x6f, 0x6e, 0x79,
+    0x6d, 0x6f, 0x75, 0x73, 0x00, 0x61, 0x6d, 0x62, 0x69, 0x74, 0x69, 0x6f,
+    0x75, 0x73, 0x00, 0x61, 0x6d, 0x61, 0x7a, 0x69, 0x6e, 0x67, 0x00, 0x61,
+    0x6c, 0x6c, 0x65, 0x67, 0x65, 0x64, 0x00, 0x61, 0x67, 0x67, 0x72, 0x65,
+    0x73, 0x73, 0x69, 0x76, 0x65, 0x00, 0x61, 0x64, 0x76, 0x69, 0x73, 0x6f,
+    0x72, 0x79, 0x00, 0x61, 0x64, 0x76, 0x65, 0x72, 0x73, 0x65, 0x00, 0x61,
+    0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x74, 0x00, 0x61, 0x64, 0x64, 0x65,
+    0x64, 0x00, 0x61, 0x63, 0x63, 0x75, 0x73, 0x65, 0x64, 0x00, 0x61, 0x63,
+    0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x00, 0x61, 0x62, 0x73,
+    0x74, 0x72, 0x61, 0x63, 0x74, 0x00, 0x61, 0x62, 0x73, 0x65, 0x6e, 0x74,
+    0x00, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x02, 0x6b, 0x00, 0x00, 0x02, 0x67, 0x00, 0x00, 0x02, 0x50, 0x00,
+    0x00, 0x02, 0x1c, 0x00, 0x00, 0x02, 0x1a, 0x00, 0x00, 0x02, 0x0c, 0x00,
+    0x00, 0x01, 0xb4, 0x00, 0x00, 0x01, 0xaf, 0x00, 0x00, 0x01, 0xaa, 0x00,
+    0x00, 0x01, 0x49, 0x00, 0x00, 0x01, 0x3e, 0x00, 0x00, 0x01, 0x3c, 0x00,
+    0x00, 0x01, 0x18, 0x00, 0x00, 0x01, 0x0d, 0x00, 0x00, 0x01, 0x07, 0x00,
+    0x00, 0x01, 0x07, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xf1, 0x00,
+    0x00, 0x00, 0xec, 0x00, 0x00, 0x00, 0xd8, 0x00, 0x00, 0x00, 0xc7, 0x00,
+    0x00, 0x00, 0xb2, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0x9c, 0x00,
+    0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0x97, 0x00,
+    0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x8d, 0x00,
+    0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x7e, 0x00,
+    0x00, 0x00, 0x77, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x72, 0x00,
+    0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x6f, 0x00,
+    0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, 0x69, 0x00,
+    0x00, 0x00, 0x66, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x65, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x5e, 0x00,
+    0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x57, 0x00,
+    0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x53, 0x00,
+    0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x4e, 0x00,
+    0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x4a, 0x00,
+    0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x42, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x41, 0x00,
+    0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3d, 0x00,
+    0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x38, 0x00,
+    0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x32, 0x00,
+    0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x2f, 0x00,
+    0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2d, 0x00,
+    0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x2b, 0x00,
+    0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00,
+    0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x29, 0x00,
+    0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00,
+    0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x27, 0x00,
+    0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x26, 0x00,
+    0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x24, 0x00,
+    0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x23, 0x00,
+    0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00,
+    0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00,
+    0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00,
+    0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00,
+    0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00,
+    0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00,
+    0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00,
+    0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x28, 0x00,
+    0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x37, 0x00,
+    0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x4a, 0x00,
+    0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x5a, 0x00,
+    0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x6c, 0x00,
+    0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x80, 0x00,
+    0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x93, 0x00,
+    0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0xa6, 0x00,
+    0x00, 0x00, 0xaa, 0x00, 0x00, 0x00, 0xaf, 0x00, 0x00, 0x00, 0xb9, 0x00,
+    0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0xcc, 0x00,
+    0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0xe8, 0x00,
+    0x00, 0x00, 0xf2, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x06, 0x00, 0x00, 0x01, 0x0b, 0x00, 0x00, 0x01, 0x18, 0x00,
+    0x00, 0x01, 0x1c, 0x00, 0x00, 0x01, 0x23, 0x00, 0x00, 0x01, 0x2b, 0x00,
+    0x00, 0x01, 0x35, 0x00, 0x00, 0x01, 0x3f, 0x00, 0x00, 0x01, 0x47, 0x00,
+    0x00, 0x01, 0x4e, 0x00, 0x00, 0x01, 0x52, 0x00, 0x00, 0x01, 0x59, 0x00,
+    0x00, 0x01, 0x64, 0x00, 0x00, 0x01, 0x69, 0x00, 0x00, 0x01, 0x6e, 0x00,
+    0x00, 0x01, 0x78, 0x00, 0x00, 0x01, 0x7d, 0x00, 0x00, 0x01, 0x82, 0x00,
+    0x00, 0x01, 0x8a, 0x00, 0x00, 0x01, 0x91, 0x00, 0x00, 0x01, 0x96, 0x00,
+    0x00, 0x01, 0x9b, 0x00, 0x00, 0x01, 0xa2, 0x00, 0x00, 0x01, 0xab, 0x00,
+    0x00, 0x01, 0xb3, 0x00, 0x00, 0x01, 0xba, 0x00, 0x00, 0x01, 0xc3, 0x00,
+    0x00, 0x01, 0xcc, 0x00, 0x00, 0x01, 0xd4, 0x00, 0x00, 0x01, 0xdd, 0x00,
+    0x00, 0x01, 0xe7, 0x00, 0x00, 0x01, 0xee, 0x00, 0x00, 0x01, 0xf4, 0x00,
+    0x00, 0x01, 0xfe, 0x00, 0x00, 0x02, 0x06, 0x00, 0x00, 0x02, 0x0c, 0x00,
+    0x00, 0x02, 0x13, 0x00, 0x00, 0x02, 0x1a, 0x00, 0x00, 0x02, 0x26, 0x00,
+    0x00, 0x02, 0x2d, 0x00, 0x00, 0x02, 0x35, 0x00, 0x00, 0x02, 0x3b, 0x00,
+    0x00, 0x02, 0x45, 0x00, 0x00, 0x02, 0x4b, 0x00, 0x00, 0x02, 0x53, 0x00,
+    0x00, 0x02, 0x5e, 0x00, 0x00, 0x02, 0x67, 0x00, 0x00, 0x02, 0x6e, 0x00,
+    0x00, 0x02, 0x73, 0x00, 0x00, 0x02, 0x79, 0x00, 0x00, 0x02, 0x80, 0x00,
+    0x00, 0x02, 0x89, 0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x02, 0x99, 0x00,
+    0x00, 0x02, 0xa3, 0x00, 0x00, 0x02, 0xac, 0x00, 0x00, 0x02, 0xb3, 0x00,
+    0x00, 0x02, 0xbe, 0x00, 0x00, 0x02, 0xc9, 0x00, 0x00, 0x02, 0xd0, 0x00,
+    0x00, 0x02, 0xd6, 0x00, 0x00, 0x02, 0xdb, 0x00, 0x00, 0x02, 0xe4, 0x00,
+    0x00, 0x02, 0xe9, 0x00, 0x00, 0x02, 0xf1, 0x00, 0x00, 0x02, 0xf9, 0x00,
+    0x00, 0x02, 0xfe, 0x00, 0x00, 0x03, 0x0b, 0x00, 0x00, 0x03, 0x12, 0x00,
+    0x00, 0x03, 0x1c, 0x00, 0x00, 0x03, 0x27, 0x00, 0x00, 0x03, 0x2e, 0x00,
+    0x00, 0x03, 0x37, 0x00, 0x00, 0x03, 0x42, 0x00, 0x00, 0x03, 0x49, 0x00,
+    0x00, 0x03, 0x56, 0x00, 0x00, 0x03, 0x60, 0x00, 0x00, 0x03, 0x6d, 0x00,
+    0x00, 0x03, 0x7b, 0x00, 0x00, 0x03, 0x84, 0x00, 0x00, 0x03, 0x8c, 0x00,
+    0x00, 0x03, 0x95, 0x00, 0x00, 0x03, 0x9f, 0x00, 0x00, 0x03, 0xa7, 0x00,
+    0x00, 0x03, 0xac, 0x00, 0x00, 0x03, 0xb3, 0x00, 0x00, 0x03, 0xbe, 0x00,
+    0x00, 0x03, 0xc4, 0x00, 0x00, 0x03, 0xcb, 0x00, 0x00, 0x03, 0xd1, 0x00,
+    0x00, 0x03, 0xd8, 0x00, 0x00, 0x03, 0xdf, 0x00, 0x00, 0x03, 0xe9, 0x00,
+    0x00, 0x03, 0xf3, 0x00, 0x00, 0x03, 0xfd, 0x00, 0x00, 0x04, 0x05, 0x00,
+    0x00, 0x04, 0x0e, 0x00, 0x00, 0x04, 0x17, 0x00, 0x00, 0x04, 0x1f, 0x00,
+    0x00, 0x04, 0x2b, 0x00, 0x00, 0x04, 0x32, 0x00, 0x00, 0x04, 0x3c, 0x00,
+    0x00, 0x04, 0x44, 0x00, 0x00, 0x04, 0x4c, 0x00, 0x00, 0x04, 0x55, 0x00,
+    0x00, 0x04, 0x59, 0x00, 0x00, 0x04, 0x63, 0x00, 0x00, 0x04, 0x69, 0x00,
+    0x00, 0x04, 0x75, 0x00, 0x00, 0x04, 0x7e, 0x00, 0x00, 0x04, 0x88, 0x00,
+    0x00, 0x04, 0x90, 0x00, 0x00, 0x04, 0x99, 0x00, 0x00, 0x04, 0x9f, 0x00,
+    0x00, 0x04, 0xa8, 0x00, 0x00, 0x04, 0xb1, 0x00, 0x00, 0x04, 0xbd, 0x00,
+    0x00, 0x04, 0xc5, 0x00, 0x00, 0x04, 0xcf, 0x00, 0x00, 0x04, 0xdd, 0x00,
+    0x00, 0x04, 0xe5, 0x00, 0x00, 0x04, 0xed, 0x00, 0x00, 0x04, 0xfb, 0x00,
+    0x00, 0x05, 0x02, 0x00, 0x00, 0x05, 0x0c, 0x00, 0x00, 0x05, 0x17, 0x00,
+    0x00, 0x05, 0x1b, 0x00, 0x00, 0x05, 0x22, 0x00, 0x00, 0x05, 0x28, 0x00,
+    0x00, 0x05, 0x33, 0x00, 0x00, 0x05, 0x3b, 0x00, 0x00, 0x05, 0x45, 0x00,
+    0x00, 0x05, 0x50, 0x00, 0x00, 0x05, 0x58, 0x00, 0x00, 0x05, 0x5f, 0x00,
+    0x00, 0x05, 0x66, 0x00, 0x00, 0x05, 0x6e, 0x00, 0x00, 0x05, 0x78, 0x00,
+    0x00, 0x05, 0x83, 0x00, 0x00, 0x05, 0x8b, 0x00, 0x00, 0x05, 0x95, 0x00,
+    0x00, 0x05, 0xa2, 0x00, 0x00, 0x05, 0xa9, 0x00, 0x00, 0x05, 0xb3, 0x00,
+    0x00, 0x05, 0xba, 0x00, 0x00, 0x05, 0xc0, 0x00, 0x00, 0x05, 0xc7, 0x00,
+    0x00, 0x05, 0xd4, 0x00, 0x00, 0x05, 0xe1, 0x00, 0x00, 0x05, 0xe7, 0x00,
+    0x00, 0x05, 0xf1, 0x00, 0x00, 0x05, 0xf7, 0x00, 0x00, 0x06, 0x04, 0x00,
+    0x00, 0x06, 0x0e, 0x00, 0x00, 0x06, 0x16, 0x00, 0x00, 0x06, 0x21, 0x00,
+    0x00, 0x06, 0x29, 0x00, 0x00, 0x06, 0x35, 0x00, 0x00, 0x06, 0x3a, 0x00,
+    0x00, 0x06, 0x40, 0x00, 0x00, 0x06, 0x49, 0x00, 0x00, 0x06, 0x56, 0x00,
+    0x00, 0x06, 0x5d, 0x00, 0x00, 0x06, 0x62, 0x00, 0x00, 0x06, 0x68, 0x00,
+    0x00, 0x06, 0x6d, 0x00, 0x00, 0x06, 0x77, 0x00, 0x00, 0x06, 0x82, 0x00,
+    0x00, 0x06, 0x8e, 0x00, 0x00, 0x06, 0x93, 0x00, 0x00, 0x06, 0x9e, 0x00,
+    0x00, 0x06, 0xa6, 0x00, 0x00, 0x06, 0xb1, 0x00, 0x00, 0x06, 0xbc, 0x00,
+    0x00, 0x06, 0xc3, 0x00, 0x00, 0x06, 0xc9, 0x00, 0x00, 0x06, 0xd4, 0x00,
+    0x00, 0x06, 0xdf, 0x00, 0x00, 0x06, 0xe7, 0x00, 0x00, 0x06, 0xf2, 0x00,
+    0x00, 0x06, 0xf8, 0x00, 0x00, 0x07, 0x02, 0x00, 0x00, 0x07, 0x0d, 0x00,
+    0x00, 0x07, 0x1a, 0x00, 0x00, 0x07, 0x27, 0x00, 0x00, 0x07, 0x35, 0x00,
+    0x00, 0x07, 0x43, 0x00, 0x00, 0x07, 0x4b, 0x00, 0x00, 0x07, 0x58, 0x00,
+    0x00, 0x07, 0x65, 0x00, 0x00, 0x07, 0x6c, 0x00, 0x00, 0x07, 0x74, 0x00,
+    0x00, 0x07, 0x7d, 0x00, 0x00, 0x07, 0x82, 0x00, 0x00, 0x07, 0x8b, 0x00,
+    0x00, 0x07, 0x92, 0x00, 0x00, 0x07, 0x9e, 0x00, 0x00, 0x07, 0xa5, 0x00,
+    0x00, 0x07, 0xb1, 0x00, 0x00, 0x07, 0xbc, 0x00, 0x00, 0x07, 0xc6, 0x00,
+    0x00, 0x07, 0xce, 0x00, 0x00, 0x07, 0xd3, 0x00, 0x00, 0x07, 0xd7, 0x00,
+    0x00, 0x07, 0xe4, 0x00, 0x00, 0x07, 0xeb, 0x00, 0x00, 0x07, 0xf2, 0x00,
+    0x00, 0x07, 0xfe, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x08, 0x0a, 0x00,
+    0x00, 0x08, 0x10, 0x00, 0x00, 0x08, 0x1a, 0x00, 0x00, 0x08, 0x20, 0x00,
+    0x00, 0x08, 0x28, 0x00, 0x00, 0x08, 0x30, 0x00, 0x00, 0x08, 0x37, 0x00,
+    0x00, 0x08, 0x3e, 0x00, 0x00, 0x08, 0x43, 0x00, 0x00, 0x08, 0x4a, 0x00,
+    0x00, 0x08, 0x55, 0x00, 0x00, 0x08, 0x5c, 0x00, 0x00, 0x08, 0x6a, 0x00,
+    0x00, 0x08, 0x71, 0x00, 0x00, 0x08, 0x7c, 0x00, 0x00, 0x08, 0x85, 0x00,
+    0x00, 0x08, 0x8f, 0x00, 0x00, 0x08, 0x95, 0x00, 0x00, 0x08, 0xa0, 0x00,
+    0x00, 0x08, 0xa9, 0x00, 0x00, 0x08, 0xb1, 0x00, 0x00, 0x08, 0xba, 0x00,
+    0x00, 0x08, 0xc6, 0x00, 0x00, 0x08, 0xd4, 0x00, 0x00, 0x08, 0xdd, 0x00,
+    0x00, 0x08, 0xe4, 0x00, 0x00, 0x08, 0xeb, 0x00, 0x00, 0x08, 0xf1, 0x00,
+    0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x09, 0x00, 0x00, 0x09, 0x14, 0x00,
+    0x00, 0x09, 0x1d, 0x00, 0x00, 0x09, 0x24, 0x00, 0x00, 0x09, 0x30, 0x00,
+    0x00, 0x09, 0x3b, 0x00, 0x00, 0x09, 0x43, 0x00, 0x00, 0x09, 0x4d, 0x00,
+    0x00, 0x09, 0x55, 0x00, 0x00, 0x09, 0x5d, 0x00, 0x00, 0x09, 0x6f, 0x00,
+    0x00, 0x09, 0x78, 0x00, 0x00, 0x09, 0x80, 0x00, 0x00, 0x09, 0x85, 0x00,
+    0x00, 0x09, 0x91, 0x00, 0x00, 0x09, 0x98, 0x00, 0x00, 0x09, 0xa2, 0x00,
+    0x00, 0x09, 0xaa, 0x00, 0x00, 0x09, 0xb4, 0x00, 0x00, 0x09, 0xc2, 0x00,
+    0x00, 0x09, 0xca, 0x00, 0x00, 0x09, 0xd3, 0x00, 0x00, 0x09, 0xde, 0x00,
+    0x00, 0x09, 0xe7, 0x00, 0x00, 0x09, 0xee, 0x00, 0x00, 0x09, 0xf9, 0x00,
+    0x00, 0x0a, 0x04, 0x00, 0x00, 0x0a, 0x0f, 0x00, 0x00, 0x0a, 0x18, 0x00,
+    0x00, 0x0a, 0x1d, 0x00, 0x00, 0x0a, 0x28, 0x00, 0x00, 0x0a, 0x32, 0x00,
+    0x00, 0x0a, 0x3b, 0x00, 0x00, 0x0a, 0x44, 0x00, 0x00, 0x0a, 0x4b, 0x00,
+    0x00, 0x0a, 0x57, 0x00, 0x00, 0x0a, 0x5f, 0x00, 0x00, 0x0a, 0x69, 0x00,
+    0x00, 0x0a, 0x76, 0x00, 0x00, 0x0a, 0x81, 0x00, 0x00, 0x0a, 0x8e, 0x00,
+    0x00, 0x0a, 0x9a, 0x00, 0x00, 0x0a, 0xa2, 0x00, 0x00, 0x0a, 0xac, 0x00,
+    0x00, 0x0a, 0xb4, 0x00, 0x00, 0x0a, 0xbd, 0x00, 0x00, 0x0a, 0xc5, 0x00,
+    0x00, 0x0a, 0xcb, 0x00, 0x00, 0x0a, 0xd3, 0x00, 0x00, 0x0a, 0xd9, 0x00,
+    0x00, 0x0a, 0xe5, 0x00, 0x00, 0x0a, 0xed, 0x00, 0x00, 0x0a, 0xf7, 0x00,
+    0x00, 0x0b, 0x02, 0x00, 0x00, 0x0b, 0x10, 0x00, 0x00, 0x0b, 0x1c, 0x00,
+    0x00, 0x0b, 0x27, 0x00, 0x00, 0x0b, 0x31, 0x00, 0x00, 0x0b, 0x38, 0x00,
+    0x00, 0x0b, 0x40, 0x00, 0x00, 0x0b, 0x43, 0x00, 0x00, 0x0b, 0x4c, 0x00,
+    0x00, 0x0b, 0x58, 0x00, 0x00, 0x0b, 0x66, 0x00, 0x00, 0x0b, 0x72, 0x00,
+    0x00, 0x0b, 0x7c, 0x00, 0x00, 0x0b, 0x86, 0x00, 0x00, 0x0b, 0x8f, 0x00,
+    0x00, 0x0b, 0x95, 0x00, 0x00, 0x0b, 0x9e, 0x00, 0x00, 0x0b, 0xa7, 0x00,
+    0x00, 0x0b, 0xb0, 0x00, 0x00, 0x0b, 0xbb, 0x00, 0x00, 0x0b, 0xc3, 0x00,
+    0x00, 0x0b, 0xcf, 0x00, 0x00, 0x0b, 0xdb, 0x00, 0x00, 0x0b, 0xe2, 0x00,
+    0x00, 0x0b, 0xeb, 0x00, 0x00, 0x0b, 0xf6, 0x00, 0x00, 0x0c, 0x00, 0x00,
+    0x00, 0x0c, 0x07, 0x00, 0x00, 0x0c, 0x10, 0x00, 0x00, 0x0c, 0x1a, 0x00,
+    0x00, 0x0c, 0x23, 0x00, 0x00, 0x0c, 0x2b, 0x00, 0x00, 0x0c, 0x35, 0x00,
+    0x00, 0x0c, 0x41, 0x00, 0x00, 0x0c, 0x49, 0x00, 0x00, 0x0c, 0x50, 0x00,
+    0x00, 0x0c, 0x57, 0x00, 0x00, 0x0c, 0x5e, 0x00, 0x00, 0x0c, 0x67, 0x00,
+    0x00, 0x0c, 0x6f, 0x00, 0x00, 0x0c, 0x7a, 0x00, 0x00, 0x0c, 0x87, 0x00,
+    0x00, 0x0c, 0x92, 0x00, 0x00, 0x0c, 0x9a, 0x00, 0x00, 0x0c, 0xa4, 0x00,
+    0x00, 0x0c, 0xac, 0x00, 0x00, 0x0c, 0xb1, 0x00, 0x00, 0x0c, 0xb8, 0x00,
+    0x00, 0x0c, 0xc4, 0x00, 0x00, 0x0c, 0xca, 0x00, 0x00, 0x0c, 0xd8, 0x00,
+    0x00, 0x0c, 0xde, 0x00, 0x00, 0x0c, 0xe7, 0x00, 0x00, 0x0c, 0xee, 0x00,
+    0x00, 0x0c, 0xfa, 0x00, 0x00, 0x0d, 0x03, 0x00, 0x00, 0x0d, 0x0b, 0x00,
+    0x00, 0x0d, 0x15, 0x00, 0x00, 0x0d, 0x1b, 0x00, 0x00, 0x0d, 0x26, 0x00,
+    0x00, 0x0d, 0x2f, 0x00, 0x00, 0x0d, 0x35, 0x00, 0x00, 0x0d, 0x3b, 0x00,
+    0x00, 0x0d, 0x40, 0x00, 0x00, 0x0d, 0x48, 0x00, 0x00, 0x0d, 0x51, 0x00,
+    0x00, 0x0d, 0x5b, 0x00, 0x00, 0x0d, 0x68, 0x00, 0x00, 0x0d, 0x72, 0x00,
+    0x00, 0x0d, 0x7e, 0x00, 0x00, 0x0d, 0x89, 0x00, 0x00, 0x0d, 0x93, 0x00,
+    0x00, 0x0d, 0x9c, 0x00, 0x00, 0x0d, 0xa1, 0x00, 0x00, 0x0d, 0xaa, 0x00,
+    0x00, 0x0d, 0xb0, 0x00, 0x00, 0x0d, 0xb9, 0x00, 0x00, 0x0d, 0xc5, 0x00,
+    0x00, 0x0d, 0xcb, 0x00, 0x00, 0x0d, 0xd2, 0x00, 0x00, 0x0d, 0xdb, 0x00,
+    0x00, 0x0d, 0xe7, 0x00, 0x00, 0x0d, 0xf1, 0x00, 0x00, 0x0d, 0xf8, 0x00,
+    0x00, 0x0d, 0xfe, 0x00, 0x00, 0x0e, 0x08, 0x00, 0x00, 0x0e, 0x11, 0x00,
+    0x00, 0x0e, 0x1b, 0x00, 0x00, 0x0e, 0x24, 0x00, 0x00, 0x0e, 0x2c, 0x00,
+    0x00, 0x0e, 0x37, 0x00, 0x00, 0x0e, 0x44, 0x00, 0x00, 0x0e, 0x4e, 0x00,
+    0x00, 0x0e, 0x57, 0x00, 0x00, 0x0e, 0x5f, 0x00, 0x00, 0x0e, 0x66, 0x00,
+    0x00, 0x0e, 0x74, 0x00, 0x00, 0x0e, 0x7d, 0x00, 0x00, 0x0e, 0x83, 0x00,
+    0x00, 0x0e, 0x89, 0x00, 0x00, 0x0e, 0x95, 0x00, 0x00, 0x0e, 0xa3, 0x00,
+    0x00, 0x0e, 0xb0, 0x00, 0x00, 0x0e, 0xb5, 0x00, 0x00, 0x0e, 0xbf, 0x00,
+    0x00, 0x0e, 0xca, 0x00, 0x00, 0x0e, 0xd4, 0x00, 0x00, 0x0e, 0xd9, 0x00,
+    0x00, 0x0e, 0xe6, 0x00, 0x00, 0x0e, 0xf2, 0x00, 0x00, 0x0e, 0xf8, 0x00,
+    0x00, 0x0e, 0xff, 0x00, 0x00, 0x0f, 0x03, 0x00, 0x00, 0x0f, 0x0e, 0x00,
+    0x00, 0x0f, 0x19, 0x00, 0x00, 0x0f, 0x27, 0x00, 0x00, 0x0f, 0x2d, 0x00,
+    0x00, 0x0f, 0x3a, 0x00, 0x00, 0x0f, 0x42, 0x00, 0x00, 0x0f, 0x49, 0x00,
+    0x00, 0x0f, 0x53, 0x00, 0x00, 0x0f, 0x5e, 0x00, 0x00, 0x0f, 0x69, 0x00,
+    0x00, 0x0f, 0x71, 0x00, 0x00, 0x0f, 0x7c, 0x00, 0x00, 0x0f, 0x81, 0x00,
+    0x00, 0x0f, 0x8e, 0x00, 0x00, 0x0f, 0x93, 0x00, 0x00, 0x0f, 0x9b, 0x00,
+    0x00, 0x0f, 0xaa, 0x00, 0x00, 0x0f, 0xb9, 0x00, 0x00, 0x0f, 0xc2, 0x00,
+    0x00, 0x0f, 0xca, 0x00, 0x00, 0x0f, 0xd3, 0x00, 0x00, 0x0f, 0xdd, 0x00,
+    0x00, 0x0f, 0xe5, 0x00, 0x00, 0x0f, 0xf3, 0x00, 0x00, 0x0f, 0xfe, 0x00,
+    0x00, 0x10, 0x09, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x10, 0x1a, 0x00,
+    0x00, 0x10, 0x24, 0x00, 0x00, 0x10, 0x2f, 0x00, 0x00, 0x10, 0x35, 0x00,
+    0x00, 0x10, 0x43, 0x00, 0x00, 0x10, 0x4a, 0x00, 0x00, 0x10, 0x54, 0x00,
+    0x00, 0x10, 0x5b, 0x00, 0x00, 0x10, 0x66, 0x00, 0x00, 0x10, 0x6f, 0x00,
+    0x00, 0x10, 0x78, 0x00, 0x00, 0x10, 0x7f, 0x00, 0x00, 0x10, 0x88, 0x00,
+    0x00, 0x10, 0x8d, 0x00, 0x00, 0x10, 0x93, 0x00, 0x00, 0x10, 0x9b, 0x00,
+    0x00, 0x10, 0xa0, 0x00, 0x00, 0x10, 0xa6, 0x00, 0x00, 0x10, 0xad, 0x00,
+    0x00, 0x10, 0xb4, 0x00, 0x00, 0x10, 0xc4, 0x00, 0x00, 0x10, 0xd2, 0x00,
+    0x00, 0x10, 0xe0, 0x00, 0x00, 0x10, 0xe8, 0x00, 0x00, 0x10, 0xf3, 0x00,
+    0x00, 0x10, 0xfd, 0x00, 0x00, 0x11, 0x0a, 0x00, 0x00, 0x11, 0x12, 0x00,
+    0x00, 0x11, 0x1a, 0x00, 0x00, 0x11, 0x1e, 0x00, 0x00, 0x11, 0x28, 0x00,
+    0x00, 0x11, 0x30, 0x00, 0x00, 0x11, 0x38, 0x00, 0x00, 0x11, 0x4b, 0x00,
+    0x00, 0x11, 0x5d, 0x00, 0x00, 0x11, 0x66, 0x00, 0x00, 0x11, 0x6f, 0x00,
+    0x00, 0x11, 0x7b, 0x00, 0x00, 0x11, 0x80, 0x00, 0x00, 0x11, 0x87, 0x00,
+    0x00, 0x11, 0x93, 0x00, 0x00, 0x11, 0x9b, 0x00, 0x00, 0x11, 0xa2, 0x00,
+    0x00, 0x11, 0xad, 0x00, 0x00, 0x11, 0xb9, 0x00, 0x00, 0x11, 0xc1, 0x00,
+    0x00, 0x11, 0xc5, 0x00, 0x00, 0x11, 0xcf, 0x00, 0x00, 0x11, 0xd6, 0x00,
+    0x00, 0x11, 0xdb, 0x00, 0x00, 0x11, 0xe6, 0x00, 0x00, 0x11, 0xf3, 0x00,
+    0x00, 0x11, 0xff, 0x00, 0x00, 0x12, 0x0c, 0x00, 0x00, 0x12, 0x12, 0x00,
+    0x00, 0x12, 0x1a, 0x00, 0x00, 0x12, 0x24, 0x00, 0x00, 0x12, 0x2f, 0x00,
+    0x00, 0x12, 0x38, 0x00, 0x00, 0x12, 0x3f, 0x00, 0x00, 0x12, 0x46, 0x00,
+    0x00, 0x12, 0x4a, 0x00, 0x00, 0x12, 0x4e, 0x00, 0x00, 0x12, 0x57, 0x00,
+    0x00, 0x12, 0x5f, 0x00, 0x00, 0x12, 0x66, 0x00, 0x00, 0x12, 0x6f, 0x00,
+    0x00, 0x12, 0x7a, 0x00, 0x00, 0x12, 0x84, 0x00, 0x00, 0x12, 0x8f, 0x00,
+    0x00, 0x12, 0x9b, 0x00, 0x00, 0x12, 0xa5, 0x00, 0x00, 0x12, 0xad, 0x00,
+    0x00, 0x12, 0xb4, 0x00, 0x00, 0x12, 0xbb, 0x00, 0x00, 0x12, 0xc7, 0x00,
+    0x00, 0x12, 0xcf, 0x00, 0x00, 0x12, 0xd8, 0x00, 0x00, 0x12, 0xdf, 0x00,
+    0x00, 0x12, 0xe8, 0x00, 0x00, 0x12, 0xf6, 0x00, 0x00, 0x13, 0x02, 0x00,
+    0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x12, 0x00, 0x00, 0x13, 0x1b, 0x00,
+    0x00, 0x13, 0x2a, 0x00, 0x00, 0x13, 0x36, 0x00, 0x00, 0x13, 0x44, 0x00,
+    0x00, 0x13, 0x50, 0x00, 0x00, 0x13, 0x5b, 0x00, 0x00, 0x13, 0x62, 0x00,
+    0x00, 0x13, 0x6a, 0x00, 0x00, 0x13, 0x78, 0x00, 0x00, 0x13, 0x83, 0x00,
+    0x00, 0x13, 0x89, 0x00, 0x00, 0x13, 0x91, 0x00, 0x00, 0x13, 0x98, 0x00,
+    0x00, 0x13, 0xa6, 0x00, 0x00, 0x13, 0xb4, 0x00, 0x00, 0x13, 0xbd, 0x00,
+    0x00, 0x13, 0xc8, 0x00, 0x00, 0x13, 0xce, 0x00, 0x00, 0x13, 0xd7, 0x00,
+    0x00, 0x13, 0xe6, 0x00, 0x00, 0x13, 0xed, 0x00, 0x00, 0x13, 0xfc, 0x00,
+    0x00, 0x14, 0x07, 0x00, 0x00, 0x14, 0x12, 0x00, 0x00, 0x14, 0x1c, 0x00,
+    0x00, 0x14, 0x25, 0x00, 0x00, 0x14, 0x33, 0x00, 0x00, 0x14, 0x42, 0x00,
+    0x00, 0x14, 0x4b, 0x00, 0x00, 0x14, 0x55, 0x00, 0x00, 0x14, 0x5e, 0x00,
+    0x00, 0x14, 0x69, 0x00, 0x00, 0x14, 0x75, 0x00, 0x00, 0x14, 0x7d, 0x00,
+    0x00, 0x14, 0x89, 0x00, 0x00, 0x14, 0x94, 0x00, 0x00, 0x14, 0x9f, 0x00,
+    0x00, 0x14, 0xa7, 0x00, 0x00, 0x14, 0xb1, 0x00, 0x00, 0x14, 0xb6, 0x00,
+    0x00, 0x14, 0xbd, 0x00, 0x00, 0x14, 0xc8, 0x00, 0x00, 0x14, 0xd1, 0x00,
+    0x00, 0x14, 0xdb, 0x00, 0x00, 0x14, 0xe6, 0x00, 0x00, 0x14, 0xf1, 0x00,
+    0x00, 0x14, 0xfe, 0x00, 0x00, 0x15, 0x06, 0x00, 0x00, 0x15, 0x11, 0x00,
+    0x00, 0x15, 0x1c, 0x00, 0x00, 0x15, 0x27, 0x00, 0x00, 0x15, 0x33, 0x00,
+    0x00, 0x15, 0x3d, 0x00, 0x00, 0x15, 0x47, 0x00, 0x00, 0x15, 0x52, 0x00,
+    0x00, 0x15, 0x59, 0x00, 0x00, 0x15, 0x64, 0x00, 0x00, 0x15, 0x6b, 0x00,
+    0x00, 0x15, 0x71, 0x00, 0x00, 0x15, 0x7c, 0x00, 0x00, 0x15, 0x88, 0x00,
+    0x00, 0x15, 0x94, 0x00, 0x00, 0x15, 0x9f, 0x00, 0x00, 0x15, 0xaa, 0x00,
+    0x00, 0x15, 0xba, 0x00, 0x00, 0x15, 0xc4, 0x00, 0x00, 0x15, 0xd4, 0x00,
+    0x00, 0x15, 0xe5, 0x00, 0x00, 0x15, 0xee, 0x00, 0x00, 0x15, 0xf4, 0x00,
+    0x00, 0x15, 0xfe, 0x00, 0x00, 0x16, 0x0a, 0x00, 0x00, 0x16, 0x15, 0x00,
+    0x00, 0x16, 0x21, 0x00, 0x00, 0x16, 0x2e, 0x00, 0x00, 0x16, 0x35, 0x00,
+    0x00, 0x16, 0x40, 0x00, 0x00, 0x16, 0x48, 0x00, 0x00, 0x16, 0x5b, 0x00,
+    0x00, 0x16, 0x63, 0x00, 0x00, 0x16, 0x6f, 0x00, 0x00, 0x16, 0x78, 0x00,
+    0x00, 0x16, 0x83, 0x00, 0x00, 0x16, 0x86, 0x00, 0x00, 0x16, 0x90, 0x00,
+    0x00, 0x16, 0x9a, 0x00, 0x00, 0x16, 0xa5, 0x00, 0x00, 0x16, 0xb2, 0x00,
+    0x00, 0x16, 0xbc, 0x00, 0x00, 0x16, 0xc9, 0x00, 0x00, 0x16, 0xd1, 0x00,
+    0x00, 0x16, 0xde, 0x00, 0x00, 0x16, 0xe4, 0x00, 0x00, 0x16, 0xea, 0x00,
+    0x00, 0x16, 0xf2, 0x00, 0x00, 0x16, 0xfc, 0x00, 0x00, 0x17, 0x03, 0x00,
+    0x00, 0x17, 0x0a, 0x00, 0x00, 0x17, 0x11, 0x00, 0x00, 0x17, 0x19, 0x00,
+    0x00, 0x17, 0x21, 0x00, 0x00, 0x17, 0x2c, 0x00, 0x00, 0x17, 0x37, 0x00,
+    0x00, 0x17, 0x41, 0x00, 0x00, 0x17, 0x48, 0x00, 0x00, 0x17, 0x51, 0x00,
+    0x00, 0x17, 0x5d, 0x00, 0x00, 0x17, 0x66, 0x00, 0x00, 0x17, 0x72, 0x00,
+    0x00, 0x17, 0x81, 0x00, 0x00, 0x17, 0x8e, 0x00, 0x00, 0x17, 0x9d, 0x00,
+    0x00, 0x17, 0xa7, 0x00, 0x00, 0x17, 0xb1, 0x00, 0x00, 0x17, 0xba, 0x00,
+    0x00, 0x17, 0xc8, 0x00, 0x00, 0x17, 0xd1, 0x00, 0x00, 0x17, 0xdf, 0x00,
+    0x00, 0x17, 0xeb, 0x00, 0x00, 0x17, 0xf8, 0x00, 0x00, 0x18, 0x05, 0x00,
+    0x00, 0x18, 0x10, 0x00, 0x00, 0x18, 0x1b, 0x00, 0x00, 0x18, 0x2a, 0x00,
+    0x00, 0x18, 0x32, 0x00, 0x00, 0x18, 0x3a, 0x00, 0x00, 0x18, 0x41, 0x00,
+    0x00, 0x18, 0x4d, 0x00, 0x00, 0x18, 0x56, 0x00, 0x00, 0x18, 0x66, 0x00,
+    0x00, 0x18, 0x6e, 0x00, 0x00, 0x18, 0x7b, 0x00, 0x00, 0x18, 0x89, 0x00,
+    0x00, 0x18, 0x92, 0x00, 0x00, 0x18, 0x99, 0x00, 0x00, 0x18, 0xa4, 0x00,
+    0x00, 0x18, 0xaf, 0x00, 0x00, 0x18, 0xbd, 0x00, 0x00, 0x18, 0xc5, 0x00,
+    0x00, 0x18, 0xcd, 0x00, 0x00, 0x18, 0xd6, 0x00, 0x00, 0x18, 0xdf, 0x00,
+    0x00, 0x18, 0xe7, 0x00, 0x00, 0x18, 0xf0, 0x00, 0x00, 0x18, 0xf8, 0x00,
+    0x00, 0x18, 0xff, 0x00, 0x00, 0x19, 0x09, 0x00, 0x00, 0x19, 0x15, 0x00,
+    0x00, 0x19, 0x1e, 0x00, 0x00, 0x19, 0x2d, 0x00, 0x00, 0x19, 0x34, 0x00,
+    0x00, 0x19, 0x3d, 0x00, 0x00, 0x19, 0x43, 0x00, 0x00, 0x19, 0x4e, 0x00,
+    0x00, 0x19, 0x57, 0x00, 0x00, 0x19, 0x61, 0x00, 0x00, 0x19, 0x6c, 0x00,
+    0x00, 0x19, 0x74, 0x00, 0x00, 0x19, 0x7f, 0x00, 0x00, 0x19, 0x88, 0x00,
+    0x00, 0x19, 0x91, 0x00, 0x00, 0x19, 0x9e, 0x00, 0x00, 0x19, 0xaa, 0x00,
+    0x00, 0x19, 0xaf, 0x00, 0x00, 0x19, 0xbd, 0x00, 0x00, 0x19, 0xc3, 0x00,
+    0x00, 0x19, 0xce, 0x00, 0x00, 0x19, 0xd7, 0x00, 0x00, 0x19, 0xdf, 0x00,
+    0x00, 0x19, 0xef, 0x00, 0x00, 0x19, 0xfb, 0x00, 0x00, 0x1a, 0x01, 0x00,
+    0x00, 0x1a, 0x0d, 0x00, 0x00, 0x1a, 0x19, 0x00, 0x00, 0x1a, 0x23, 0x00,
+    0x00, 0x1a, 0x2d, 0x00, 0x00, 0x1a, 0x3a, 0x00, 0x00, 0x1a, 0x47, 0x00,
+    0x00, 0x1a, 0x4e, 0x00, 0x00, 0x1a, 0x59, 0x00, 0x00, 0x1a, 0x64, 0x00,
+    0x00, 0x1a, 0x6f, 0x00, 0x00, 0x1a, 0x78, 0x00, 0x00, 0x1a, 0x85, 0x00,
+    0x00, 0x1a, 0x8f, 0x00, 0x00, 0x1a, 0x97, 0x00, 0x00, 0x1a, 0xa0, 0x00,
+    0x00, 0x1a, 0xab, 0x00, 0x00, 0x1a, 0xbc, 0x00, 0x00, 0x1a, 0xbf, 0x00,
+    0x00, 0x1a, 0xc4, 0x00, 0x00, 0x1a, 0xcd, 0x00, 0x00, 0x1a, 0xd9, 0x00,
+    0x00, 0x1a, 0xdd, 0x00, 0x00, 0x1a, 0xe8, 0x00, 0x00, 0x1a, 0xf3, 0x00,
+    0x00, 0x1a, 0xfd, 0x00, 0x00, 0x1b, 0x05, 0x00, 0x00, 0x1b, 0x10, 0x00,
+    0x00, 0x1b, 0x1b, 0x00, 0x00, 0x1b, 0x28, 0x00, 0x00, 0x1b, 0x30, 0x00,
+    0x00, 0x1b, 0x39, 0x00, 0x00, 0x1b, 0x44, 0x00, 0x00, 0x1b, 0x4e, 0x00,
+    0x00, 0x1b, 0x5b, 0x00, 0x00, 0x1b, 0x66, 0x00, 0x00, 0x1b, 0x73, 0x00,
+    0x00, 0x1b, 0x7e, 0x00, 0x00, 0x1b, 0x88, 0x00, 0x00, 0x1b, 0x91, 0x00,
+    0x00, 0x1b, 0x97, 0x00, 0x00, 0x1b, 0xa0, 0x00, 0x00, 0x1b, 0xad, 0x00,
+    0x00, 0x1b, 0xb2, 0x00, 0x00, 0x1b, 0xb9, 0x00, 0x00, 0x1b, 0xc2, 0x00,
+    0x00, 0x1b, 0xc9, 0x00, 0x00, 0x1b, 0xd3, 0x00, 0x00, 0x1b, 0xdb, 0x00,
+    0x00, 0x1b, 0xe2, 0x00, 0x00, 0x1b, 0xe9, 0x00, 0x00, 0x1b, 0xf5, 0x00,
+    0x00, 0x1b, 0xfb, 0x00, 0x00, 0x1c, 0x05, 0x00, 0x00, 0x1c, 0x0d, 0x00,
+    0x00, 0x1c, 0x16, 0x00, 0x00, 0x1c, 0x24, 0x00, 0x00, 0x1c, 0x32, 0x00,
+    0x00, 0x1c, 0x3d, 0x00, 0x00, 0x1c, 0x4c, 0x00, 0x00, 0x1c, 0x57, 0x00,
+    0x00, 0x1c, 0x65, 0x00, 0x00, 0x1c, 0x74, 0x00, 0x00, 0x1c, 0x7f, 0x00,
+    0x00, 0x1c, 0x86, 0x00, 0x00, 0x1c, 0x93, 0x00, 0x00, 0x1c, 0x9e, 0x00,
+    0x00, 0x1c, 0xab, 0x00, 0x00, 0x1c, 0xb6, 0x00, 0x00, 0x1c, 0xc2, 0x00,
+    0x00, 0x1c, 0xce, 0x00, 0x00, 0x1c, 0xdc, 0x00, 0x00, 0x1c, 0xe5, 0x00,
+    0x00, 0x1c, 0xf1, 0x00, 0x00, 0x1c, 0xf9, 0x00, 0x00, 0x1d, 0x02, 0x00,
+    0x00, 0x1d, 0x07, 0x00, 0x00, 0x1d, 0x0c, 0x00, 0x00, 0x1d, 0x12, 0x00,
+    0x00, 0x1d, 0x1a, 0x00, 0x00, 0x1d, 0x21, 0x00, 0x00, 0x1d, 0x27, 0x00,
+    0x00, 0x1d, 0x30, 0x00, 0x00, 0x1d, 0x3d, 0x00, 0x00, 0x1d, 0x48, 0x00,
+    0x00, 0x1d, 0x4f, 0x00, 0x00, 0x1d, 0x5a, 0x00, 0x00, 0x1d, 0x62, 0x00,
+    0x00, 0x1d, 0x6b, 0x00, 0x00, 0x1d, 0x74, 0x00, 0x00, 0x1d, 0x7f, 0x00,
+    0x00, 0x1d, 0x8a, 0x00, 0x00, 0x1d, 0x92, 0x00, 0x00, 0x1d, 0x9a, 0x00,
+    0x00, 0x1d, 0xa5, 0x00, 0x00, 0x1d, 0xb1, 0x00, 0x00, 0x1d, 0xbc, 0x00,
+    0x00, 0x1d, 0xc5, 0x00, 0x00, 0x1d, 0xcc, 0x00, 0x00, 0x1d, 0xd5, 0x00,
+    0x00, 0x1d, 0xe4, 0x00, 0x00, 0x1d, 0xf0, 0x00, 0x00, 0x1d, 0xf5, 0x00,
+    0x00, 0x1d, 0xff, 0x00, 0x00, 0x1e, 0x09, 0x00, 0x00, 0x1e, 0x12, 0x00,
+    0x00, 0x1e, 0x1d, 0x00, 0x00, 0x1e, 0x26, 0x00, 0x00, 0x1e, 0x2d, 0x00,
+    0x00, 0x1e, 0x32, 0x00, 0x00, 0x1e, 0x3a, 0x00, 0x00, 0x1e, 0x42, 0x00,
+    0x00, 0x1e, 0x4d, 0x00, 0x00, 0x1e, 0x56, 0x00, 0x00, 0x1e, 0x65, 0x00,
+    0x00, 0x1e, 0x6f, 0x00, 0x00, 0x1e, 0x7b, 0x00, 0x00, 0x1e, 0x87, 0x00,
+    0x00, 0x1e, 0x8f, 0x00, 0x00, 0x1e, 0x99, 0x00, 0x00, 0x1e, 0xa6, 0x00,
+    0x00, 0x1e, 0xb0, 0x00, 0x00, 0x1e, 0xba, 0x00, 0x00, 0x1e, 0xc9, 0x00,
+    0x00, 0x1e, 0xd6, 0x00, 0x00, 0x1e, 0xe0, 0x00, 0x00, 0x1e, 0xea, 0x00,
+    0x00, 0x1e, 0xf6, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x00, 0x1f, 0x0a, 0x00,
+    0x00, 0x1f, 0x15, 0x00, 0x00, 0x1f, 0x1c, 0x00, 0x00, 0x1f, 0x23, 0x00,
+    0x00, 0x1f, 0x36, 0x00, 0x00, 0x1f, 0x41, 0x00, 0x00, 0x1f, 0x47, 0x00,
+    0x00, 0x1f, 0x4f, 0x00, 0x00, 0x1f, 0x5a, 0x00, 0x00, 0x1f, 0x64, 0x00,
+    0x00, 0x1f, 0x70, 0x00, 0x00, 0x1f, 0x7b, 0x00, 0x00, 0x1f, 0x82, 0x00,
+    0x00, 0x1f, 0x89, 0x00, 0x00, 0x1f, 0x94, 0x00, 0x00, 0x1f, 0x9c, 0x00,
+    0x00, 0x1f, 0xa4, 0x00, 0x00, 0x1f, 0xae, 0x00, 0x00, 0x1f, 0xb6, 0x00,
+    0x00, 0x1f, 0xc6, 0x00, 0x00, 0x1f, 0xcd, 0x00, 0x00, 0x1f, 0xda, 0x00,
+    0x00, 0x1f, 0xe9, 0x00, 0x00, 0x1f, 0xf7, 0x00, 0x00, 0x20, 0x03, 0x00,
+    0x00, 0x20, 0x0b, 0x00, 0x00, 0x20, 0x16, 0x00, 0x00, 0x20, 0x1f, 0x00,
+    0x00, 0x20, 0x25, 0x00, 0x00, 0x20, 0x30, 0x00, 0x00, 0x20, 0x3b, 0x00,
+    0x00, 0x20, 0x48, 0x00, 0x00, 0x20, 0x4f, 0x00, 0x00, 0x20, 0x58, 0x00,
+    0x00, 0x20, 0x60, 0x00, 0x00, 0x20, 0x67, 0x00, 0x00, 0x20, 0x6f, 0x00,
+    0x00, 0x20, 0x77, 0x00, 0x00, 0x20, 0x7f, 0x00, 0x00, 0x20, 0x87, 0x00,
+    0x00, 0x20, 0x91, 0x00, 0x00, 0x20, 0x9b, 0x00, 0x00, 0x20, 0xa3, 0x00,
+    0x00, 0x20, 0xac, 0x00, 0x00, 0x20, 0xb4, 0x00, 0x00, 0x20, 0xc2, 0x00,
+    0x00, 0x20, 0xd6, 0x00, 0x00, 0x20, 0xe3, 0x00, 0x00, 0x20, 0xef, 0x00,
+    0x00, 0x20, 0xf6, 0x00, 0x00, 0x21, 0x05, 0x00, 0x00, 0x21, 0x0d, 0x00,
+    0x00, 0x21, 0x14, 0x00, 0x00, 0x21, 0x21, 0x00, 0x00, 0x21, 0x2b, 0x00,
+    0x00, 0x21, 0x37, 0x00, 0x00, 0x21, 0x3d, 0x00, 0x00, 0x21, 0x4d, 0x00,
+    0x00, 0x21, 0x58, 0x00, 0x00, 0x21, 0x65, 0x00, 0x00, 0x21, 0x6c, 0x00,
+    0x00, 0x21, 0x7b, 0x00, 0x00, 0x21, 0x85, 0x00, 0x00, 0x21, 0x8f, 0x00,
+    0x00, 0x21, 0x98, 0x00, 0x00, 0x21, 0x9f, 0x00, 0x00, 0x21, 0xa5, 0x00,
+    0x00, 0x21, 0xaa, 0x74, 0x68, 0x65, 0x6e, 0x00, 0x6d, 0x6f, 0x72, 0x65,
+    0x00, 0x61, 0x6c, 0x73, 0x6f, 0x00, 0x73, 0x6f, 0x00, 0x6e, 0x6f, 0x77,
+    0x00, 0x6f, 0x6e, 0x6c, 0x79, 0x00, 0x61, 0x73, 0x00, 0x76, 0x65, 0x72,
+    0x79, 0x00, 0x6a, 0x75, 0x73, 0x74, 0x00, 0x65, 0x76, 0x65, 0x6e, 0x00,
+    0x73, 0x74, 0x69, 0x6c, 0x6c, 0x00, 0x74, 0x6f, 0x6f, 0x00, 0x68, 0x6f,
+    0x77, 0x65, 0x76, 0x65, 0x72, 0x00, 0x74, 0x68, 0x65, 0x72, 0x65, 0x00,
+    0x6d, 0x6f, 0x73, 0x74, 0x00, 0x68, 0x65, 0x72, 0x65, 0x00, 0x6d, 0x75,
+    0x63, 0x68, 0x00, 0x6e, 0x65, 0x76, 0x65, 0x72, 0x00, 0x61, 0x67, 0x61,
+    0x69, 0x6e, 0x00, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x61, 0x6c, 0x77, 0x61,
+    0x79, 0x73, 0x00, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x00, 0x61, 0x62, 0x6f,
+    0x75, 0x74, 0x00, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x00, 0x79,
+    0x65, 0x74, 0x00, 0x70, 0x65, 0x72, 0x68, 0x61, 0x70, 0x73, 0x00, 0x61,
+    0x6c, 0x6d, 0x6f, 0x73, 0x74, 0x00, 0x71, 0x75, 0x69, 0x74, 0x65, 0x00,
+    0x72, 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6c, 0x61, 0x74, 0x65, 0x72,
+    0x00, 0x61, 0x6c, 0x6c, 0x00, 0x62, 0x6f, 0x74, 0x68, 0x00, 0x6f, 0x66,
+    0x20, 0x63, 0x6f, 0x75, 0x72, 0x73, 0x65, 0x00, 0x61, 0x74, 0x20, 0x6c,
+    0x65, 0x61, 0x73, 0x74, 0x00, 0x6c, 0x65, 0x73, 0x73, 0x00, 0x65, 0x76,
+    0x65, 0x72, 0x00, 0x65, 0x6e, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x66, 0x6f,
+    0x72, 0x20, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x00, 0x74, 0x6f,
+    0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x00, 0x74, 0x68, 0x65, 0x72, 0x65,
+    0x66, 0x6f, 0x72, 0x65, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x70, 0x72,
+    0x6f, 0x62, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x74, 0x6f, 0x64, 0x61, 0x79,
+    0x00, 0x74, 0x68, 0x75, 0x73, 0x00, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63,
+    0x75, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x00, 0x66, 0x61, 0x72, 0x00, 0x72,
+    0x61, 0x74, 0x68, 0x65, 0x72, 0x00, 0x66, 0x75, 0x72, 0x74, 0x68, 0x65,
+    0x72, 0x00, 0x73, 0x6f, 0x6d, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x00,
+    0x79, 0x65, 0x73, 0x74, 0x65, 0x72, 0x64, 0x61, 0x79, 0x00, 0x75, 0x73,
+    0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x64, 0x65, 0x65, 0x64,
+    0x00, 0x61, 0x67, 0x6f, 0x00, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x79, 0x00,
+    0x65, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x65,
+    0x6c, 0x73, 0x65, 0x00, 0x68, 0x6f, 0x6d, 0x65, 0x00, 0x63, 0x65, 0x72,
+    0x74, 0x61, 0x69, 0x6e, 0x6c, 0x79, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0x00,
+    0x73, 0x6f, 0x6f, 0x6e, 0x00, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x6c, 0x79,
+    0x00, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x00, 0x6c, 0x6f, 0x6e, 0x67,
+    0x00, 0x61, 0x77, 0x61, 0x79, 0x00, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72,
+    0x00, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x66, 0x69,
+    0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x61, 0x74, 0x20, 0x61, 0x6c, 0x6c,
+    0x00, 0x69, 0x6e, 0x20, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x00, 0x72, 0x65,
+    0x63, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x71, 0x75, 0x69, 0x63, 0x6b,
+    0x6c, 0x79, 0x00, 0x73, 0x75, 0x64, 0x64, 0x65, 0x6e, 0x6c, 0x79, 0x00,
+    0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6e, 0x65,
+    0x61, 0x72, 0x6c, 0x79, 0x00, 0x61, 0x62, 0x6f, 0x76, 0x65, 0x00, 0x6d,
+    0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x00, 0x66, 0x6f, 0x72,
+    0x77, 0x61, 0x72, 0x64, 0x00, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x70,
+    0x6c, 0x65, 0x61, 0x73, 0x65, 0x00, 0x65, 0x61, 0x73, 0x69, 0x6c, 0x79,
+    0x00, 0x69, 0x6d, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x6c, 0x79,
+    0x00, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x79, 0x00, 0x65, 0x61, 0x72, 0x6c,
+    0x69, 0x65, 0x72, 0x00, 0x65, 0x61, 0x72, 0x6c, 0x79, 0x00, 0x6e, 0x6f,
+    0x20, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x66, 0x75, 0x6c, 0x6c,
+    0x79, 0x00, 0x65, 0x78, 0x61, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x65, 0x76,
+    0x65, 0x6e, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x64, 0x69, 0x72,
+    0x65, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x68, 0x61, 0x72, 0x64, 0x6c, 0x79,
+    0x00, 0x62, 0x65, 0x73, 0x74, 0x00, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x00,
+    0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x00, 0x73, 0x6c, 0x69, 0x67, 0x68,
+    0x74, 0x6c, 0x79, 0x00, 0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x00, 0x6f, 0x74,
+    0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x00, 0x6f, 0x62, 0x76, 0x69,
+    0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x61, 0x20, 0x6c, 0x69, 0x74, 0x74,
+    0x6c, 0x65, 0x00, 0x73, 0x6c, 0x6f, 0x77, 0x6c, 0x79, 0x00, 0x63, 0x6f,
+    0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x72, 0x65, 0x6c,
+    0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x6d, 0x65, 0x72, 0x65,
+    0x6c, 0x79, 0x00, 0x6d, 0x61, 0x79, 0x62, 0x65, 0x00, 0x68, 0x69, 0x67,
+    0x68, 0x00, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6c,
+    0x61, 0x74, 0x65, 0x00, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x6c, 0x79, 0x00,
+    0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x00, 0x73, 0x75, 0x72, 0x65,
+    0x00, 0x6e, 0x65, 0x76, 0x65, 0x72, 0x74, 0x68, 0x65, 0x6c, 0x65, 0x73,
+    0x73, 0x00, 0x6c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x00, 0x63, 0x61, 0x72,
+    0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x61, 0x70, 0x70, 0x61, 0x72,
+    0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x61, 0x6e, 0x79, 0x77, 0x61, 0x79,
+    0x00, 0x74, 0x6f, 0x6d, 0x6f, 0x72, 0x72, 0x6f, 0x77, 0x00, 0x70, 0x72,
+    0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x6d, 0x61, 0x69,
+    0x6e, 0x6c, 0x79, 0x00, 0x66, 0x6f, 0x72, 0x20, 0x69, 0x6e, 0x73, 0x74,
+    0x61, 0x6e, 0x63, 0x65, 0x00, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74,
+    0x6c, 0x79, 0x00, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x69, 0x6e,
+    0x67, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69,
+    0x63, 0x75, 0x6c, 0x61, 0x72, 0x00, 0x65, 0x6e, 0x74, 0x69, 0x72, 0x65,
+    0x6c, 0x79, 0x00, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x70,
+    0x6f, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x74, 0x72,
+    0x65, 0x6d, 0x65, 0x6c, 0x79, 0x00, 0x65, 0x71, 0x75, 0x61, 0x6c, 0x6c,
+    0x79, 0x00, 0x68, 0x61, 0x72, 0x64, 0x00, 0x73, 0x75, 0x72, 0x65, 0x6c,
+    0x79, 0x00, 0x66, 0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x6c, 0x79,
+    0x00, 0x61, 0x68, 0x65, 0x61, 0x64, 0x00, 0x77, 0x69, 0x64, 0x65, 0x6c,
+    0x79, 0x00, 0x74, 0x77, 0x69, 0x63, 0x65, 0x00, 0x70, 0x61, 0x72, 0x74,
+    0x6c, 0x79, 0x00, 0x66, 0x61, 0x69, 0x72, 0x6c, 0x79, 0x00, 0x73, 0x6f,
+    0x6d, 0x65, 0x77, 0x68, 0x65, 0x72, 0x65, 0x00, 0x73, 0x65, 0x72, 0x69,
+    0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x65, 0x6c, 0x73, 0x65, 0x77, 0x68,
+    0x65, 0x72, 0x65, 0x00, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x6c, 0x79, 0x00,
+    0x73, 0x74, 0x72, 0x61, 0x69, 0x67, 0x68, 0x74, 0x00, 0x6e, 0x6f, 0x20,
+    0x64, 0x6f, 0x75, 0x62, 0x74, 0x00, 0x6e, 0x65, 0x69, 0x74, 0x68, 0x65,
+    0x72, 0x00, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x61, 0x72, 0x69, 0x6c,
+    0x79, 0x00, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x00, 0x61, 0x6c, 0x6c,
+    0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x74, 0x6f, 0x74, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x74, 0x6f, 0x6e, 0x69, 0x67, 0x68, 0x74, 0x00, 0x70,
+    0x72, 0x6f, 0x70, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x65, 0x74, 0x63, 0x00,
+    0x6d, 0x65, 0x61, 0x6e, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x00, 0x68, 0x65,
+    0x6e, 0x63, 0x65, 0x00, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76,
+    0x65, 0x6c, 0x79, 0x00, 0x73, 0x6f, 0x6d, 0x65, 0x77, 0x68, 0x61, 0x74,
+    0x00, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x00, 0x72,
+    0x61, 0x70, 0x69, 0x64, 0x6c, 0x79, 0x00, 0x61, 0x74, 0x20, 0x66, 0x69,
+    0x72, 0x73, 0x74, 0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x73, 0x74,
+    0x72, 0x6f, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x72, 0x65, 0x6f,
+    0x76, 0x65, 0x72, 0x00, 0x69, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74,
+    0x69, 0x6f, 0x6e, 0x00, 0x61, 0x74, 0x20, 0x6c, 0x61, 0x73, 0x74, 0x00,
+    0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x75, 0x6e,
+    0x66, 0x6f, 0x72, 0x74, 0x75, 0x6e, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00,
+    0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x00, 0x73, 0x6f, 0x6d, 0x65,
+    0x68, 0x6f, 0x77, 0x00, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x66, 0x69, 0x63,
+    0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x72, 0x61, 0x72, 0x65, 0x6c, 0x79,
+    0x00, 0x70, 0x65, 0x72, 0x66, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x6f,
+    0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6c, 0x6f,
+    0x77, 0x00, 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x00, 0x62, 0x61, 0x64,
+    0x6c, 0x79, 0x00, 0x61, 0x66, 0x74, 0x65, 0x72, 0x77, 0x61, 0x72, 0x64,
+    0x73, 0x00, 0x71, 0x75, 0x69, 0x65, 0x74, 0x6c, 0x79, 0x00, 0x6e, 0x61,
+    0x74, 0x75, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x20, 0x67,
+    0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x00, 0x68, 0x65, 0x61, 0x76, 0x69,
+    0x6c, 0x79, 0x00, 0x67, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x66, 0x69,
+    0x72, 0x6d, 0x6c, 0x79, 0x00, 0x61, 0x74, 0x20, 0x6f, 0x6e, 0x63, 0x65,
+    0x00, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x6f, 0x20, 0x6f, 0x6e, 0x00, 0x61,
+    0x62, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x73, 0x68,
+    0x6f, 0x72, 0x74, 0x6c, 0x79, 0x00, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61,
+    0x72, 0x6c, 0x79, 0x00, 0x6f, 0x63, 0x63, 0x61, 0x73, 0x69, 0x6f, 0x6e,
+    0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x73, 0x74, 0x6c, 0x79, 0x00,
+    0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x64, 0x65,
+    0x65, 0x70, 0x6c, 0x79, 0x00, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x00, 0x61,
+    0x62, 0x72, 0x6f, 0x61, 0x64, 0x00, 0x73, 0x75, 0x62, 0x73, 0x65, 0x71,
+    0x75, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x73, 0x70, 0x65, 0x63, 0x69,
+    0x66, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x68, 0x6f, 0x72,
+    0x74, 0x00, 0x67, 0x72, 0x61, 0x64, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x61, 0x73, 0x69, 0x64, 0x65, 0x00, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73,
+    0x73, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x65, 0x63, 0x69,
+    0x73, 0x65, 0x6c, 0x79, 0x00, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65,
+    0x00, 0x6f, 0x6e, 0x63, 0x65, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x00,
+    0x67, 0x72, 0x65, 0x61, 0x74, 0x6c, 0x79, 0x00, 0x65, 0x73, 0x73, 0x65,
+    0x6e, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x65, 0x61, 0x73, 0x79,
+    0x00, 0x61, 0x70, 0x61, 0x72, 0x74, 0x00, 0x61, 0x6e, 0x79, 0x77, 0x68,
+    0x65, 0x72, 0x65, 0x00, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69,
+    0x76, 0x65, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x65, 0x74, 0x74, 0x79, 0x00,
+    0x6f, 0x70, 0x65, 0x6e, 0x00, 0x74, 0x72, 0x75, 0x6c, 0x79, 0x00, 0x74,
+    0x68, 0x61, 0x74, 0x00, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x69, 0x6c,
+    0x79, 0x00, 0x69, 0x6e, 0x65, 0x76, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x79,
+    0x00, 0x66, 0x75, 0x72, 0x74, 0x68, 0x65, 0x72, 0x6d, 0x6f, 0x72, 0x65,
+    0x00, 0x66, 0x61, 0x73, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61,
+    0x6e, 0x74, 0x6c, 0x79, 0x00, 0x62, 0x72, 0x69, 0x65, 0x66, 0x6c, 0x79,
+    0x00, 0x61, 0x74, 0x20, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x00,
+    0x61, 0x6c, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65, 0x72, 0x00, 0x61,
+    0x63, 0x72, 0x6f, 0x73, 0x73, 0x00, 0x61, 0x20, 0x62, 0x69, 0x74, 0x00,
+    0x75, 0x6c, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x72,
+    0x65, 0x61, 0x73, 0x6f, 0x6e, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x72, 0x65,
+    0x61, 0x64, 0x69, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x65, 0x73, 0x75, 0x6d,
+    0x61, 0x62, 0x6c, 0x79, 0x00, 0x6e, 0x65, 0x77, 0x6c, 0x79, 0x00, 0x6c,
+    0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x00, 0x65, 0x76, 0x65,
+    0x72, 0x79, 0x77, 0x68, 0x65, 0x72, 0x65, 0x00, 0x64, 0x65, 0x6c, 0x69,
+    0x62, 0x65, 0x72, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6e,
+    0x73, 0x69, 0x64, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x61, 0x75,
+    0x74, 0x6f, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x61, 0x70, 0x70, 0x72, 0x6f, 0x78, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x6c,
+    0x79, 0x00, 0x74, 0x68, 0x65, 0x72, 0x65, 0x62, 0x79, 0x00, 0x73, 0x75,
+    0x72, 0x70, 0x72, 0x69, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x73,
+    0x75, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00,
+    0x73, 0x6f, 0x66, 0x74, 0x6c, 0x79, 0x00, 0x73, 0x68, 0x61, 0x72, 0x70,
+    0x6c, 0x79, 0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x6c, 0x79, 0x00,
+    0x64, 0x65, 0x65, 0x70, 0x00, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x6c,
+    0x79, 0x00, 0x62, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x00, 0x75, 0x6e, 0x64,
+    0x6f, 0x75, 0x62, 0x74, 0x65, 0x64, 0x6c, 0x79, 0x00, 0x70, 0x75, 0x72,
+    0x65, 0x6c, 0x79, 0x00, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0x20, 0x6d, 0x6f, 0x72, 0x65,
+    0x00, 0x6e, 0x6f, 0x74, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x6e, 0x65, 0x61,
+    0x72, 0x00, 0x69, 0x6c, 0x6c, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x71,
+    0x75, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x63, 0x6c, 0x6f, 0x73, 0x65,
+    0x72, 0x00, 0x62, 0x61, 0x72, 0x65, 0x6c, 0x79, 0x00, 0x61, 0x63, 0x63,
+    0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x77, 0x69, 0x64,
+    0x65, 0x00, 0x77, 0x68, 0x6f, 0x6c, 0x6c, 0x79, 0x00, 0x75, 0x70, 0x20,
+    0x74, 0x6f, 0x00, 0x74, 0x79, 0x70, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79,
+    0x00, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x00, 0x72, 0x6f, 0x75, 0x67, 0x68,
+    0x6c, 0x79, 0x00, 0x6e, 0x6f, 0x77, 0x68, 0x65, 0x72, 0x65, 0x00, 0x6e,
+    0x61, 0x6d, 0x65, 0x6c, 0x79, 0x00, 0x6c, 0x6f, 0x6e, 0x67, 0x65, 0x72,
+    0x00, 0x67, 0x6f, 0x6f, 0x64, 0x00, 0x65, 0x61, 0x73, 0x69, 0x65, 0x72,
+    0x00, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x6c, 0x79, 0x00,
+    0x62, 0x79, 0x20, 0x6e, 0x6f, 0x77, 0x00, 0x74, 0x72, 0x61, 0x64, 0x69,
+    0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x74, 0x68, 0x6f,
+    0x75, 0x67, 0x68, 0x00, 0x74, 0x68, 0x6f, 0x72, 0x6f, 0x75, 0x67, 0x68,
+    0x6c, 0x79, 0x00, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x6c, 0x79, 0x00,
+    0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x61,
+    0x64, 0x6c, 0x79, 0x00, 0x70, 0x68, 0x79, 0x73, 0x69, 0x63, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x6c, 0x69, 0x67, 0x68, 0x74, 0x6c, 0x79, 0x00, 0x66, 0x6f, 0x72, 0x6d,
+    0x61, 0x6c, 0x6c, 0x79, 0x00, 0x64, 0x65, 0x73, 0x70, 0x65, 0x72, 0x61,
+    0x74, 0x65, 0x6c, 0x79, 0x00, 0x73, 0x75, 0x62, 0x73, 0x74, 0x61, 0x6e,
+    0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x74, 0x65, 0x61, 0x64,
+    0x69, 0x6c, 0x79, 0x00, 0x73, 0x6f, 0x6f, 0x6e, 0x65, 0x72, 0x00, 0x73,
+    0x6f, 0x6c, 0x65, 0x6c, 0x79, 0x00, 0x73, 0x6f, 0x20, 0x61, 0x73, 0x00,
+    0x73, 0x69, 0x6d, 0x75, 0x6c, 0x74, 0x61, 0x6e, 0x65, 0x6f, 0x75, 0x73,
+    0x6c, 0x79, 0x00, 0x73, 0x65, 0x76, 0x65, 0x72, 0x65, 0x6c, 0x79, 0x00,
+    0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x73,
+    0x63, 0x61, 0x72, 0x63, 0x65, 0x6c, 0x79, 0x00, 0x73, 0x61, 0x66, 0x65,
+    0x6c, 0x79, 0x00, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x6f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x6c,
+    0x79, 0x00, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6c, 0x69,
+    0x74, 0x65, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x20, 0x70,
+    0x61, 0x72, 0x74, 0x00, 0x68, 0x61, 0x70, 0x70, 0x69, 0x6c, 0x79, 0x00,
+    0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x6f,
+    0x20, 0x74, 0x69, 0x6d, 0x65, 0x00, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x72,
+    0x6c, 0x79, 0x00, 0x66, 0x6f, 0x72, 0x65, 0x76, 0x65, 0x72, 0x00, 0x66,
+    0x61, 0x69, 0x72, 0x00, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x76,
+    0x65, 0x6c, 0x79, 0x00, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x00, 0x63,
+    0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x62, 0x65, 0x73,
+    0x69, 0x64, 0x65, 0x73, 0x00, 0x62, 0x61, 0x73, 0x69, 0x63, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69,
+    0x76, 0x65, 0x6c, 0x79, 0x00, 0x75, 0x70, 0x77, 0x61, 0x72, 0x64, 0x73,
+    0x00, 0x75, 0x70, 0x73, 0x74, 0x61, 0x69, 0x72, 0x73, 0x00, 0x74, 0x68,
+    0x65, 0x72, 0x65, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00, 0x73, 0x6f, 0x63,
+    0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x65, 0x6c, 0x64, 0x6f, 0x6d,
+    0x00, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x6c, 0x79, 0x00,
+    0x72, 0x65, 0x6d, 0x61, 0x72, 0x6b, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x72,
+    0x65, 0x67, 0x61, 0x72, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x00, 0x70, 0x75,
+    0x62, 0x6c, 0x69, 0x63, 0x6c, 0x79, 0x00, 0x70, 0x61, 0x73, 0x74, 0x00,
+    0x69, 0x6e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x69,
+    0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x20,
+    0x73, 0x68, 0x6f, 0x72, 0x74, 0x00, 0x68, 0x69, 0x74, 0x68, 0x65, 0x72,
+    0x74, 0x6f, 0x00, 0x66, 0x72, 0x65, 0x65, 0x6c, 0x79, 0x00, 0x66, 0x6f,
+    0x72, 0x74, 0x75, 0x6e, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x66, 0x69,
+    0x72, 0x73, 0x74, 0x6c, 0x79, 0x00, 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e,
+    0x74, 0x6c, 0x79, 0x00, 0x64, 0x72, 0x61, 0x6d, 0x61, 0x74, 0x69, 0x63,
+    0x61, 0x6c, 0x6c, 0x79, 0x00, 0x64, 0x6f, 0x77, 0x6e, 0x73, 0x74, 0x61,
+    0x69, 0x72, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x65,
+    0x6e, 0x74, 0x6c, 0x79, 0x00, 0x62, 0x79, 0x20, 0x6e, 0x6f, 0x20, 0x6d,
+    0x65, 0x61, 0x6e, 0x73, 0x00, 0x62, 0x72, 0x6f, 0x61, 0x64, 0x6c, 0x79,
+    0x00, 0x62, 0x61, 0x63, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x61,
+    0x6c, 0x6c, 0x20, 0x62, 0x75, 0x74, 0x00, 0x61, 0x63, 0x74, 0x69, 0x76,
+    0x65, 0x6c, 0x79, 0x00, 0x75, 0x74, 0x74, 0x65, 0x72, 0x6c, 0x79, 0x00,
+    0x74, 0x69, 0x67, 0x68, 0x74, 0x00, 0x74, 0x69, 0x67, 0x68, 0x74, 0x6c,
+    0x79, 0x00, 0x74, 0x68, 0x69, 0x63, 0x6b, 0x00, 0x74, 0x65, 0x6d, 0x70,
+    0x6f, 0x72, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x73, 0x77, 0x69, 0x66,
+    0x74, 0x6c, 0x79, 0x00, 0x73, 0x65, 0x65, 0x6d, 0x69, 0x6e, 0x67, 0x6c,
+    0x79, 0x00, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x6c, 0x79,
+    0x00, 0x70, 0x72, 0x65, 0x64, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6e, 0x74,
+    0x6c, 0x79, 0x00, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x6c,
+    0x79, 0x00, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x6f, 0x70, 0x65, 0x6e, 0x6c, 0x79, 0x00, 0x6f, 0x6e, 0x77, 0x61, 0x72,
+    0x64, 0x73, 0x00, 0x6e, 0x6f, 0x00, 0x6e, 0x6f, 0x77, 0x61, 0x64, 0x61,
+    0x79, 0x73, 0x00, 0x6e, 0x6f, 0x6e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x65,
+    0x73, 0x73, 0x00, 0x69, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65,
+    0x6e, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x61,
+    0x6e, 0x74, 0x6c, 0x79, 0x00, 0x68, 0x6f, 0x70, 0x65, 0x66, 0x75, 0x6c,
+    0x6c, 0x79, 0x00, 0x67, 0x65, 0x6e, 0x75, 0x69, 0x6e, 0x65, 0x6c, 0x79,
+    0x00, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x66, 0x6f,
+    0x72, 0x74, 0x68, 0x00, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x6f, 0x6e, 0x67,
+    0x00, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x76, 0x65, 0x72, 0x00, 0x66, 0x61,
+    0x72, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x00, 0x65, 0x78, 0x70, 0x6c, 0x69,
+    0x63, 0x69, 0x74, 0x6c, 0x79, 0x00, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x73,
+    0x6f, 0x00, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x6c,
+    0x79, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x61, 0x6c, 0x6c,
+    0x79, 0x00, 0x61, 0x73, 0x20, 0x79, 0x65, 0x74, 0x00, 0x61, 0x73, 0x20,
+    0x75, 0x73, 0x75, 0x61, 0x6c, 0x00, 0x61, 0x63, 0x63, 0x75, 0x72, 0x61,
+    0x74, 0x65, 0x6c, 0x79, 0x00, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x77, 0x69,
+    0x64, 0x65, 0x00, 0x77, 0x69, 0x74, 0x68, 0x69, 0x6e, 0x00, 0x74, 0x65,
+    0x72, 0x72, 0x69, 0x62, 0x6c, 0x79, 0x00, 0x73, 0x69, 0x6e, 0x63, 0x65,
+    0x72, 0x65, 0x6c, 0x79, 0x00, 0x73, 0x69, 0x6c, 0x65, 0x6e, 0x74, 0x6c,
+    0x79, 0x00, 0x72, 0x69, 0x67, 0x68, 0x74, 0x6c, 0x79, 0x00, 0x70, 0x72,
+    0x69, 0x76, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x70, 0x65, 0x72, 0x6d,
+    0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x6f, 0x76, 0x65, 0x72,
+    0x61, 0x6c, 0x6c, 0x00, 0x6e, 0x65, 0x61, 0x74, 0x6c, 0x79, 0x00, 0x6e,
+    0x65, 0x61, 0x72, 0x62, 0x79, 0x00, 0x6c, 0x6f, 0x75, 0x64, 0x6c, 0x79,
+    0x00, 0x6c, 0x69, 0x6b, 0x65, 0x77, 0x69, 0x73, 0x65, 0x00, 0x6c, 0x65,
+    0x67, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6a, 0x75, 0x73, 0x74, 0x20, 0x61,
+    0x62, 0x6f, 0x75, 0x74, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x76, 0x69, 0x64,
+    0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x72, 0x65,
+    0x63, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x20, 0x66, 0x75, 0x6c, 0x6c,
+    0x00, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x00, 0x69,
+    0x64, 0x65, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x68, 0x61, 0x6c, 0x66, 0x00,
+    0x66, 0x61, 0x73, 0x74, 0x65, 0x72, 0x00, 0x65, 0x66, 0x66, 0x69, 0x63,
+    0x69, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x64, 0x61, 0x69, 0x6c, 0x79,
+    0x00, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65,
+    0x6c, 0x79, 0x00, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x00, 0x62, 0x69, 0x74,
+    0x74, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x62, 0x65, 0x79, 0x6f, 0x6e, 0x64,
+    0x00, 0x62, 0x65, 0x61, 0x75, 0x74, 0x69, 0x66, 0x75, 0x6c, 0x6c, 0x79,
+    0x00, 0x61, 0x6e, 0x6e, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x61, 0x6e,
+    0x67, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x61, 0x6c, 0x6c, 0x65, 0x67, 0x65,
+    0x64, 0x6c, 0x79, 0x00, 0x61, 0x6c, 0x69, 0x6b, 0x65, 0x00, 0x61, 0x64,
+    0x65, 0x71, 0x75, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x61, 0x62, 0x72,
+    0x75, 0x70, 0x74, 0x6c, 0x79, 0x00, 0x77, 0x72, 0x6f, 0x6e, 0x67, 0x00,
+    0x77, 0x6f, 0x72, 0x73, 0x65, 0x00, 0x77, 0x69, 0x6c, 0x64, 0x00, 0x76,
+    0x61, 0x67, 0x75, 0x65, 0x6c, 0x79, 0x00, 0x75, 0x72, 0x67, 0x65, 0x6e,
+    0x74, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x75, 0x73, 0x75, 0x61, 0x6c, 0x6c,
+    0x79, 0x00, 0x75, 0x6e, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64,
+    0x6c, 0x79, 0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x77, 0x61, 0x79,
+    0x00, 0x74, 0x65, 0x63, 0x68, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79,
+    0x00, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x6c, 0x79, 0x00,
+    0x73, 0x74, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x79, 0x00, 0x73, 0x6d,
+    0x6f, 0x6f, 0x74, 0x68, 0x6c, 0x79, 0x00, 0x73, 0x6c, 0x6f, 0x77, 0x00,
+    0x73, 0x69, 0x64, 0x65, 0x77, 0x61, 0x79, 0x73, 0x00, 0x73, 0x68, 0x61,
+    0x72, 0x70, 0x00, 0x73, 0x65, 0x78, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x72, 0x65, 0x6c, 0x75, 0x63, 0x74, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00,
+    0x71, 0x75, 0x69, 0x63, 0x6b, 0x00, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+    0x00, 0x70, 0x72, 0x6f, 0x6d, 0x70, 0x74, 0x6c, 0x79, 0x00, 0x70, 0x72,
+    0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x72,
+    0x65, 0x73, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x70, 0x6f, 0x6f, 0x72,
+    0x6c, 0x79, 0x00, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x00, 0x70, 0x65, 0x72,
+    0x20, 0x61, 0x6e, 0x6e, 0x75, 0x6d, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x73,
+    0x65, 0x61, 0x73, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x69, 0x67, 0x68,
+    0x74, 0x00, 0x6f, 0x6e, 0x20, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x00, 0x6a,
+    0x6f, 0x69, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x72, 0x6f, 0x6e, 0x69,
+    0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x63, 0x69, 0x64, 0x65,
+    0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x20, 0x70, 0x75,
+    0x62, 0x6c, 0x69, 0x63, 0x00, 0x68, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x6c,
+    0x79, 0x00, 0x68, 0x61, 0x73, 0x74, 0x69, 0x6c, 0x79, 0x00, 0x68, 0x61,
+    0x72, 0x64, 0x65, 0x72, 0x00, 0x66, 0x75, 0x6e, 0x64, 0x61, 0x6d, 0x65,
+    0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x66, 0x69, 0x65, 0x72, 0x63,
+    0x65, 0x6c, 0x79, 0x00, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x00, 0x65, 0x78,
+    0x74, 0x72, 0x61, 0x00, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x76,
+    0x65, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f,
+    0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d,
+    0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x64, 0x75, 0x6c, 0x79, 0x00,
+    0x64, 0x6f, 0x75, 0x62, 0x74, 0x6c, 0x65, 0x73, 0x73, 0x00, 0x64, 0x69,
+    0x73, 0x74, 0x69, 0x6e, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x63, 0x75, 0x72,
+    0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6f, 0x6c, 0x00,
+    0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x6f, 0x75, 0x73, 0x6c, 0x79,
+    0x00, 0x63, 0x6f, 0x6d, 0x66, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x79,
+    0x00, 0x63, 0x68, 0x65, 0x61, 0x70, 0x00, 0x62, 0x79, 0x20, 0x66, 0x61,
+    0x72, 0x00, 0x62, 0x75, 0x74, 0x00, 0x61, 0x73, 0x20, 0x67, 0x6f, 0x6f,
+    0x64, 0x20, 0x61, 0x73, 0x00, 0x61, 0x73, 0x20, 0x61, 0x20, 0x77, 0x68,
+    0x6f, 0x6c, 0x65, 0x00, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69,
+    0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x61, 0x6c, 0x6f, 0x75, 0x64, 0x00,
+    0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65,
+    0x00, 0x77, 0x72, 0x6f, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x77, 0x69, 0x6c,
+    0x64, 0x6c, 0x79, 0x00, 0x76, 0x69, 0x6f, 0x6c, 0x65, 0x6e, 0x74, 0x6c,
+    0x79, 0x00, 0x76, 0x69, 0x67, 0x6f, 0x72, 0x6f, 0x75, 0x73, 0x6c, 0x79,
+    0x00, 0x76, 0x69, 0x63, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x61, 0x00,
+    0x75, 0x70, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x75, 0x6e, 0x64, 0x65,
+    0x72, 0x6e, 0x65, 0x61, 0x74, 0x68, 0x00, 0x74, 0x72, 0x75, 0x65, 0x00,
+    0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x66, 0x75, 0x6c, 0x6c, 0x79,
+    0x00, 0x74, 0x68, 0x69, 0x73, 0x00, 0x74, 0x68, 0x69, 0x72, 0x64, 0x6c,
+    0x79, 0x00, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x6f,
+    0x20, 0x73, 0x61, 0x79, 0x00, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x61,
+    0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x75, 0x69, 0x74,
+    0x61, 0x62, 0x6c, 0x79, 0x00, 0x73, 0x6f, 0x72, 0x74, 0x20, 0x6f, 0x66,
+    0x00, 0x73, 0x65, 0x63, 0x72, 0x65, 0x74, 0x6c, 0x79, 0x00, 0x72, 0x61,
+    0x64, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x6f, 0x75,
+    0x64, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73,
+    0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x6f, 0x66, 0x6f, 0x75,
+    0x6e, 0x64, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x61,
+    0x62, 0x6c, 0x79, 0x00, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x6c, 0x79,
+    0x00, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x6c, 0x79, 0x00, 0x70, 0x61, 0x69,
+    0x6e, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x20,
+    0x74, 0x68, 0x65, 0x72, 0x65, 0x00, 0x6f, 0x64, 0x64, 0x6c, 0x79, 0x00,
+    0x6e, 0x6f, 0x6e, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x65, 0x73,
+    0x73, 0x00, 0x6e, 0x69, 0x63, 0x65, 0x6c, 0x79, 0x00, 0x6e, 0x65, 0x72,
+    0x76, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x6e, 0x65, 0x61, 0x72, 0x65,
+    0x72, 0x00, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79,
+    0x00, 0x6e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x6c, 0x79, 0x00, 0x6d, 0x75,
+    0x74, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6d, 0x69, 0x6c, 0x64, 0x6c,
+    0x79, 0x00, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x64, 0x6c, 0x79, 0x00, 0x6c,
+    0x6f, 0x75, 0x64, 0x00, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x00, 0x6c, 0x6f,
+    0x6f, 0x73, 0x65, 0x6c, 0x79, 0x00, 0x6c, 0x69, 0x6b, 0x65, 0x00, 0x6c,
+    0x65, 0x61, 0x73, 0x74, 0x00, 0x6c, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00,
+    0x6b, 0x69, 0x6e, 0x64, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x72,
+    0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x6c, 0x79,
+    0x00, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x6e, 0x63, 0x74, 0x69, 0x76, 0x65,
+    0x6c, 0x79, 0x00, 0x69, 0x6e, 0x64, 0x6f, 0x6f, 0x72, 0x73, 0x00, 0x69,
+    0x6e, 0x63, 0x72, 0x65, 0x64, 0x69, 0x62, 0x6c, 0x79, 0x00, 0x69, 0x6d,
+    0x6d, 0x65, 0x6e, 0x73, 0x65, 0x6c, 0x79, 0x00, 0x68, 0x69, 0x73, 0x74,
+    0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x68, 0x69, 0x67,
+    0x68, 0x65, 0x73, 0x74, 0x00, 0x68, 0x61, 0x6c, 0x66, 0x77, 0x61, 0x79,
+    0x00, 0x67, 0x6d, 0x74, 0x00, 0x66, 0x75, 0x72, 0x69, 0x6f, 0x75, 0x73,
+    0x6c, 0x79, 0x00, 0x66, 0x72, 0x65, 0x73, 0x68, 0x6c, 0x79, 0x00, 0x66,
+    0x72, 0x61, 0x6e, 0x6b, 0x6c, 0x79, 0x00, 0x66, 0x6f, 0x72, 0x20, 0x74,
+    0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x62, 0x65, 0x69, 0x6e,
+    0x67, 0x00, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f,
+    0x73, 0x74, 0x20, 0x70, 0x61, 0x72, 0x74, 0x00, 0x66, 0x6f, 0x72, 0x20,
+    0x6f, 0x6e, 0x63, 0x65, 0x00, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x6f, 0x6f,
+    0x64, 0x00, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69,
+    0x6e, 0x00, 0x66, 0x6c, 0x61, 0x74, 0x00, 0x66, 0x69, 0x6e, 0x65, 0x6c,
+    0x79, 0x00, 0x66, 0x69, 0x6e, 0x61, 0x6e, 0x63, 0x69, 0x61, 0x6c, 0x6c,
+    0x79, 0x00, 0x66, 0x61, 0x69, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x65, 0x76,
+    0x65, 0x6e, 0x6c, 0x79, 0x00, 0x65, 0x6e, 0x6f, 0x72, 0x6d, 0x6f, 0x75,
+    0x73, 0x6c, 0x79, 0x00, 0x65, 0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x65, 0x61, 0x67, 0x65, 0x72, 0x6c, 0x79, 0x00,
+    0x64, 0x75, 0x65, 0x00, 0x64, 0x6f, 0x77, 0x6e, 0x77, 0x61, 0x72, 0x64,
+    0x73, 0x00, 0x64, 0x65, 0x65, 0x70, 0x65, 0x72, 0x00, 0x64, 0x65, 0x61,
+    0x64, 0x00, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x65, 0x6c, 0x79,
+    0x00, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e, 0x69, 0x65, 0x6e, 0x74, 0x6c,
+    0x79, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x63, 0x69, 0x6f, 0x75, 0x73, 0x6c,
+    0x79, 0x00, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x72, 0x63, 0x69, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x00, 0x63, 0x68, 0x69,
+    0x65, 0x66, 0x6c, 0x79, 0x00, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x63, 0x61, 0x75, 0x74, 0x69, 0x6f, 0x75, 0x73, 0x6c,
+    0x79, 0x00, 0x63, 0x61, 0x73, 0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x63,
+    0x61, 0x6c, 0x6d, 0x6c, 0x79, 0x00, 0x62, 0x6c, 0x6f, 0x6f, 0x64, 0x79,
+    0x00, 0x62, 0x69, 0x67, 0x00, 0x62, 0x61, 0x64, 0x00, 0x61, 0x74, 0x20,
+    0x6c, 0x61, 0x72, 0x67, 0x65, 0x00, 0x61, 0x74, 0x20, 0x62, 0x65, 0x73,
+    0x74, 0x00, 0x61, 0x73, 0x68, 0x6f, 0x72, 0x65, 0x00, 0x61, 0x72, 0x67,
+    0x75, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x61, 0x6e, 0x79, 0x20, 0x6c, 0x6f,
+    0x6e, 0x67, 0x65, 0x72, 0x00, 0x61, 0x6e, 0x78, 0x69, 0x6f, 0x75, 0x73,
+    0x6c, 0x79, 0x00, 0x61, 0x64, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x6c,
+    0x79, 0x00, 0x77, 0x6f, 0x6e, 0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x6c,
+    0x79, 0x00, 0x77, 0x69, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00,
+    0x77, 0x65, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x77, 0x65, 0x61, 0x6b,
+    0x6c, 0x79, 0x00, 0x77, 0x61, 0x72, 0x6d, 0x6c, 0x79, 0x00, 0x76, 0x6f,
+    0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x76, 0x69,
+    0x76, 0x69, 0x64, 0x6c, 0x79, 0x00, 0x76, 0x69, 0x73, 0x75, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x76, 0x61, 0x73, 0x74, 0x6c, 0x79, 0x00, 0x75, 0x73,
+    0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x6e, 0x65, 0x63,
+    0x65, 0x73, 0x73, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x69,
+    0x76, 0x65, 0x72, 0x73, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x69,
+    0x71, 0x75, 0x65, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x64, 0x75, 0x6c, 0x79,
+    0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x77, 0x61, 0x79, 0x00, 0x75, 0x6e,
+    0x64, 0x65, 0x72, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x79,
+    0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64,
+    0x00, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x66, 0x6f, 0x72, 0x74, 0x61, 0x62,
+    0x6c, 0x79, 0x00, 0x75, 0x6e, 0x61, 0x6e, 0x69, 0x6d, 0x6f, 0x75, 0x73,
+    0x6c, 0x79, 0x00, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x6f, 0x75,
+    0x74, 0x00, 0x74, 0x68, 0x69, 0x6e, 0x6c, 0x79, 0x00, 0x74, 0x68, 0x65,
+    0x72, 0x65, 0x6f, 0x66, 0x00, 0x74, 0x68, 0x65, 0x6f, 0x72, 0x65, 0x74,
+    0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x74, 0x68, 0x61, 0x6e, 0x6b,
+    0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x74, 0x69, 0x66, 0x66, 0x00,
+    0x73, 0x74, 0x69, 0x66, 0x66, 0x6c, 0x79, 0x00, 0x73, 0x74, 0x65, 0x61,
+    0x64, 0x79, 0x00, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63,
+    0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x70, 0x6f, 0x6e, 0x74, 0x61, 0x6e,
+    0x65, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x73, 0x6f, 0x6d, 0x65, 0x74,
+    0x69, 0x6d, 0x65, 0x00, 0x73, 0x6f, 0x20, 0x6d, 0x75, 0x63, 0x68, 0x20,
+    0x61, 0x73, 0x00, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x00, 0x73, 0x65, 0x6e,
+    0x73, 0x69, 0x62, 0x6c, 0x79, 0x00, 0x73, 0x61, 0x74, 0x69, 0x73, 0x66,
+    0x61, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x72, 0x69, 0x63,
+    0x68, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x6f, 0x66, 0x65, 0x73, 0x73, 0x69,
+    0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x6f, 0x77, 0x65, 0x72,
+    0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x6c, 0x65, 0x61, 0x73, 0x61,
+    0x6e, 0x74, 0x6c, 0x79, 0x00, 0x70, 0x61, 0x74, 0x69, 0x65, 0x6e, 0x74,
+    0x6c, 0x79, 0x00, 0x70, 0x61, 0x72, 0x61, 0x6c, 0x6c, 0x65, 0x6c, 0x00,
+    0x70, 0x61, 0x72, 0x61, 0x64, 0x6f, 0x78, 0x69, 0x63, 0x61, 0x6c, 0x6c,
+    0x79, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x77, 0x68, 0x65, 0x6c, 0x6d, 0x69,
+    0x6e, 0x67, 0x6c, 0x79, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x68, 0x65, 0x61,
+    0x64, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x68, 0x65, 0x72, 0x65, 0x00,
+    0x6f, 0x75, 0x74, 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x6f, 0x73, 0x74,
+    0x65, 0x6e, 0x73, 0x69, 0x62, 0x6c, 0x79, 0x00, 0x6e, 0x6f, 0x74, 0x6f,
+    0x72, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x72, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x72,
+    0x69, 0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x64, 0x65, 0x72, 0x61, 0x74, 0x65,
+    0x6c, 0x79, 0x00, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x6c,
+    0x79, 0x00, 0x6c, 0x75, 0x63, 0x6b, 0x69, 0x6c, 0x79, 0x00, 0x6c, 0x6f,
+    0x67, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6c, 0x69, 0x76, 0x65,
+    0x00, 0x6c, 0x69, 0x6b, 0x65, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+    0x74, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x73, 0x65, 0x6c,
+    0x79, 0x00, 0x69, 0x6e, 0x68, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x6c, 0x79,
+    0x00, 0x69, 0x6e, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x6c, 0x79, 0x00,
+    0x69, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x65, 0x6c, 0x79,
+    0x00, 0x69, 0x6e, 0x20, 0x76, 0x61, 0x69, 0x6e, 0x00, 0x69, 0x6e, 0x20,
+    0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x00, 0x69, 0x6e, 0x20, 0x62,
+    0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x00, 0x69, 0x6d, 0x70, 0x6c, 0x69,
+    0x63, 0x69, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x6d, 0x70, 0x61, 0x74, 0x69,
+    0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x6c, 0x6c, 0x65, 0x67, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x68, 0x75, 0x72, 0x72, 0x69, 0x65, 0x64, 0x6c,
+    0x79, 0x00, 0x68, 0x6f, 0x70, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x6c, 0x79,
+    0x00, 0x68, 0x69, 0x67, 0x68, 0x65, 0x72, 0x00, 0x68, 0x65, 0x6c, 0x70,
+    0x6c, 0x65, 0x73, 0x73, 0x6c, 0x79, 0x00, 0x67, 0x72, 0x69, 0x6d, 0x6c,
+    0x79, 0x00, 0x67, 0x72, 0x65, 0x61, 0x74, 0x00, 0x67, 0x65, 0x6e, 0x65,
+    0x72, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x20,
+    0x6e, 0x6f, 0x77, 0x20, 0x6f, 0x6e, 0x00, 0x66, 0x72, 0x61, 0x6e, 0x74,
+    0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x66, 0x61, 0x76, 0x6f, 0x75,
+    0x72, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x66, 0x61, 0x69, 0x74, 0x68, 0x66,
+    0x75, 0x6c, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x74, 0x72, 0x61, 0x6f, 0x72,
+    0x64, 0x69, 0x6e, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x70,
+    0x72, 0x65, 0x73, 0x73, 0x6c, 0x79, 0x00, 0x65, 0x6e, 0x76, 0x69, 0x72,
+    0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x65,
+    0x6e, 0x74, 0x68, 0x75, 0x73, 0x69, 0x61, 0x73, 0x74, 0x69, 0x63, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x65, 0x6e, 0x20, 0x72, 0x6f, 0x75, 0x74, 0x65,
+    0x00, 0x64, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x64, 0x65, 0x63, 0x69, 0x64,
+    0x65, 0x64, 0x6c, 0x79, 0x00, 0x64, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x6f,
+    0x75, 0x73, 0x6c, 0x79, 0x00, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x6e,
+    0x74, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69,
+    0x76, 0x65, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6c, 0x64, 0x6c, 0x79, 0x00,
+    0x63, 0x68, 0x65, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x63,
+    0x68, 0x65, 0x61, 0x70, 0x6c, 0x79, 0x00, 0x63, 0x68, 0x61, 0x72, 0x61,
+    0x63, 0x74, 0x65, 0x72, 0x69, 0x73, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c,
+    0x79, 0x00, 0x62, 0x72, 0x69, 0x73, 0x6b, 0x6c, 0x79, 0x00, 0x62, 0x72,
+    0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x62, 0x72,
+    0x69, 0x67, 0x68, 0x74, 0x6c, 0x79, 0x00, 0x62, 0x65, 0x66, 0x6f, 0x72,
+    0x65, 0x68, 0x61, 0x6e, 0x64, 0x00, 0x62, 0x63, 0x00, 0x61, 0x74, 0x20,
+    0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x00, 0x61, 0x74, 0x20, 0x6c, 0x65,
+    0x6e, 0x67, 0x74, 0x68, 0x00, 0x61, 0x73, 0x20, 0x69, 0x74, 0x20, 0x77,
+    0x65, 0x72, 0x65, 0x00, 0x61, 0x6e, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67,
+    0x20, 0x62, 0x75, 0x74, 0x00, 0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x69,
+    0x64, 0x65, 0x00, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x61, 0x63, 0x75, 0x74, 0x65, 0x6c, 0x79, 0x00,
+    0x61, 0x63, 0x63, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x79,
+    0x00, 0x77, 0x72, 0x79, 0x6c, 0x79, 0x00, 0x77, 0x6f, 0x72, 0x73, 0x74,
+    0x00, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x00, 0x77, 0x69, 0x73,
+    0x74, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x77, 0x69, 0x73, 0x65, 0x6c,
+    0x79, 0x00, 0x77, 0x65, 0x65, 0x6b, 0x6c, 0x79, 0x00, 0x77, 0x61, 0x72,
+    0x69, 0x6c, 0x79, 0x00, 0x76, 0x69, 0x74, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x76, 0x69, 0x73, 0x69, 0x62, 0x6c, 0x79, 0x00, 0x76, 0x65, 0x72, 0x74,
+    0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x76, 0x65, 0x68, 0x65, 0x6d,
+    0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75,
+    0x73, 0x6c, 0x79, 0x00, 0x75, 0x70, 0x77, 0x61, 0x72, 0x64, 0x00, 0x75,
+    0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x00, 0x75, 0x70, 0x73, 0x69,
+    0x64, 0x65, 0x20, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x75, 0x70, 0x20, 0x66,
+    0x72, 0x6f, 0x6e, 0x74, 0x00, 0x75, 0x6e, 0x77, 0x69, 0x74, 0x74, 0x69,
+    0x6e, 0x67, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x73, 0x75, 0x63, 0x63, 0x65,
+    0x73, 0x73, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x71,
+    0x75, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x62, 0x6c, 0x79, 0x00,
+    0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x6c, 0x79, 0x00, 0x75, 0x6e,
+    0x68, 0x61, 0x70, 0x70, 0x69, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x66, 0x61,
+    0x69, 0x72, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x65, 0x71, 0x75, 0x69, 0x76,
+    0x6f, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x65, 0x61, 0x73,
+    0x69, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x73, 0x63, 0x69,
+    0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x75, 0x6e, 0x63, 0x65, 0x72, 0x74,
+    0x61, 0x69, 0x6e, 0x6c, 0x79, 0x00, 0x74, 0x72, 0x69, 0x75, 0x6d, 0x70,
+    0x68, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x74, 0x72, 0x65, 0x6d, 0x65,
+    0x6e, 0x64, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x74, 0x72, 0x61, 0x67,
+    0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x74, 0x6f, 0x20, 0x61, 0x6e,
+    0x64, 0x20, 0x66, 0x72, 0x6f, 0x00, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x61,
+    0x6e, 0x64, 0x20, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x00, 0x74, 0x68, 0x69,
+    0x63, 0x6b, 0x6c, 0x79, 0x00, 0x74, 0x68, 0x65, 0x72, 0x65, 0x69, 0x6e,
+    0x00, 0x74, 0x68, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x74, 0x65, 0x6e, 0x74,
+    0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x74, 0x65, 0x6e, 0x64,
+    0x65, 0x72, 0x6c, 0x79, 0x00, 0x73, 0x79, 0x6d, 0x70, 0x61, 0x74, 0x68,
+    0x65, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x77, 0x65,
+    0x65, 0x74, 0x6c, 0x79, 0x00, 0x73, 0x75, 0x73, 0x70, 0x69, 0x63, 0x69,
+    0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x73, 0x75, 0x70, 0x65, 0x72, 0x66,
+    0x69, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x73, 0x75, 0x70, 0x65,
+    0x72, 0x62, 0x6c, 0x79, 0x00, 0x73, 0x75, 0x62, 0x74, 0x6c, 0x79, 0x00,
+    0x73, 0x74, 0x75, 0x62, 0x62, 0x6f, 0x72, 0x6e, 0x6c, 0x79, 0x00, 0x73,
+    0x74, 0x72, 0x69, 0x6b, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x73, 0x74,
+    0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x73, 0x74, 0x65, 0x72, 0x6e, 0x6c, 0x79, 0x00, 0x73, 0x74, 0x65, 0x65,
+    0x70, 0x6c, 0x79, 0x00, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x6c, 0x79,
+    0x00, 0x73, 0x70, 0x65, 0x65, 0x64, 0x69, 0x6c, 0x79, 0x00, 0x73, 0x6f,
+    0x6c, 0x69, 0x64, 0x6c, 0x79, 0x00, 0x73, 0x6f, 0x6c, 0x65, 0x6d, 0x6e,
+    0x6c, 0x79, 0x00, 0x73, 0x6d, 0x61, 0x72, 0x74, 0x6c, 0x79, 0x00, 0x73,
+    0x6c, 0x6f, 0x77, 0x65, 0x72, 0x00, 0x73, 0x6b, 0x69, 0x6c, 0x66, 0x75,
+    0x6c, 0x6c, 0x79, 0x00, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x76,
+    0x65, 0x6c, 0x79, 0x00, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x6c, 0x79,
+    0x00, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x73, 0x63, 0x61, 0x72, 0x63, 0x65, 0x00, 0x73,
+    0x61, 0x76, 0x61, 0x67, 0x65, 0x6c, 0x79, 0x00, 0x73, 0x61, 0x66, 0x65,
+    0x72, 0x00, 0x72, 0x75, 0x74, 0x68, 0x6c, 0x65, 0x73, 0x73, 0x6c, 0x79,
+    0x00, 0x72, 0x75, 0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x72, 0x6f,
+    0x75, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x79, 0x00, 0x72, 0x69, 0x67, 0x6f,
+    0x72, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x72, 0x69, 0x67, 0x69, 0x64,
+    0x6c, 0x79, 0x00, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x65, 0x6c,
+    0x79, 0x00, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x72,
+    0x65, 0x6c, 0x69, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x72, 0x65, 0x6c, 0x65,
+    0x6e, 0x74, 0x6c, 0x65, 0x73, 0x73, 0x6c, 0x79, 0x00, 0x72, 0x65, 0x67,
+    0x72, 0x65, 0x74, 0x74, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x72, 0x65, 0x61,
+    0x6c, 0x00, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x63, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x72, 0x65, 0x61, 0x64, 0x79, 0x00, 0x72, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x72, 0x61, 0x6e,
+    0x64, 0x6f, 0x6d, 0x6c, 0x79, 0x00, 0x71, 0x75, 0x69, 0x63, 0x6b, 0x65,
+    0x72, 0x00, 0x70, 0x73, 0x79, 0x63, 0x68, 0x6f, 0x6c, 0x6f, 0x67, 0x69,
+    0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x6f, 0x6d, 0x69, 0x6e,
+    0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x00,
+    0x70, 0x72, 0x65, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x65, 0x6c, 0x79, 0x00,
+    0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x61, 0x62, 0x6c, 0x79, 0x00,
+    0x70, 0x6f, 0x70, 0x75, 0x6c, 0x61, 0x72, 0x6c, 0x79, 0x00, 0x70, 0x6f,
+    0x69, 0x6e, 0x74, 0x65, 0x64, 0x6c, 0x79, 0x00, 0x70, 0x65, 0x72, 0x73,
+    0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x70, 0x65, 0x72,
+    0x69, 0x6f, 0x64, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x70, 0x65,
+    0x72, 0x20, 0x73, 0x65, 0x00, 0x70, 0x65, 0x72, 0x20, 0x63, 0x61, 0x70,
+    0x69, 0x74, 0x61, 0x00, 0x70, 0x65, 0x63, 0x75, 0x6c, 0x69, 0x61, 0x72,
+    0x6c, 0x79, 0x00, 0x70, 0x65, 0x61, 0x63, 0x65, 0x66, 0x75, 0x6c, 0x6c,
+    0x79, 0x00, 0x70, 0x61, 0x74, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x70,
+    0x61, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00,
+    0x70, 0x61, 0x72, 0x74, 0x2d, 0x74, 0x69, 0x6d, 0x65, 0x00, 0x6f, 0x76,
+    0x65, 0x72, 0x74, 0x6c, 0x79, 0x00, 0x6f, 0x75, 0x74, 0x72, 0x69, 0x67,
+    0x68, 0x74, 0x00, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x72, 0x69, 0x6c,
+    0x79, 0x00, 0x6f, 0x6e, 0x63, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66,
+    0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x00, 0x6f, 0x6b, 0x00, 0x6f, 0x6b,
+    0x61, 0x79, 0x00, 0x6f, 0x66, 0x66, 0x73, 0x68, 0x6f, 0x72, 0x65, 0x00,
+    0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00,
+    0x6e, 0x6f, 0x74, 0x00, 0x6e, 0x6f, 0x74, 0x69, 0x63, 0x65, 0x61, 0x62,
+    0x6c, 0x79, 0x00, 0x6e, 0x6f, 0x72, 0x74, 0x68, 0x77, 0x61, 0x72, 0x64,
+    0x73, 0x00, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x6e, 0x6f, 0x69, 0x73, 0x69, 0x6c, 0x79, 0x00, 0x6e, 0x65, 0x67, 0x61,
+    0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x6e, 0x61, 0x74, 0x69, 0x6f,
+    0x6e, 0x77, 0x69, 0x64, 0x65, 0x00, 0x6d, 0x79, 0x73, 0x74, 0x65, 0x72,
+    0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x6e, 0x74, 0x68,
+    0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x64, 0x65, 0x73, 0x74, 0x6c, 0x79, 0x00,
+    0x6d, 0x69, 0x73, 0x74, 0x61, 0x6b, 0x65, 0x6e, 0x6c, 0x79, 0x00, 0x6d,
+    0x69, 0x73, 0x65, 0x72, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x6d, 0x69, 0x72,
+    0x61, 0x63, 0x75, 0x6c, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x00, 0x6d, 0x65,
+    0x72, 0x63, 0x69, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x6d, 0x65, 0x63,
+    0x68, 0x61, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6d, 0x61,
+    0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x6d, 0x61, 0x73,
+    0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x6d, 0x61, 0x6e, 0x75, 0x61,
+    0x6c, 0x6c, 0x79, 0x00, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x00, 0x6c, 0x6f,
+    0x76, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x6c, 0x65, 0x67, 0x69, 0x74,
+    0x69, 0x6d, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x6c, 0x65, 0x66, 0x74,
+    0x00, 0x6c, 0x61, 0x7a, 0x69, 0x6c, 0x79, 0x00, 0x6c, 0x61, 0x74, 0x74,
+    0x65, 0x72, 0x6c, 0x79, 0x00, 0x6c, 0x61, 0x73, 0x74, 0x6c, 0x79, 0x00,
+    0x6b, 0x6e, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x6b, 0x69,
+    0x6e, 0x64, 0x20, 0x6f, 0x66, 0x00, 0x6b, 0x65, 0x65, 0x6e, 0x6c, 0x79,
+    0x00, 0x6a, 0x75, 0x73, 0x74, 0x6c, 0x79, 0x00, 0x6a, 0x75, 0x73, 0x74,
+    0x69, 0x66, 0x69, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x6a, 0x6f, 0x6c, 0x6c,
+    0x79, 0x00, 0x69, 0x72, 0x72, 0x69, 0x74, 0x61, 0x62, 0x6c, 0x79, 0x00,
+    0x69, 0x6e, 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x69, 0x6e, 0x77, 0x61,
+    0x72, 0x64, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x76, 0x6f, 0x6c, 0x75, 0x6e,
+    0x74, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x74, 0x72, 0x69,
+    0x6e, 0x73, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x74,
+    0x69, 0x6d, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x20, 0x61, 0x6c, 0x69, 0x61, 0x00, 0x69, 0x6e,
+    0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x69, 0x6e, 0x74, 0x65, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x75, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x69, 0x6e, 0x6e, 0x6f, 0x63, 0x65, 0x6e, 0x74, 0x6c,
+    0x79, 0x00, 0x69, 0x6e, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x69, 0x6e, 0x66,
+    0x72, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x6e,
+    0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x65,
+    0x78, 0x74, 0x72, 0x69, 0x63, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x69, 0x6e,
+    0x65, 0x78, 0x6f, 0x72, 0x61, 0x62, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x64,
+    0x69, 0x67, 0x6e, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x63,
+    0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x00, 0x69, 0x6e, 0x61,
+    0x64, 0x76, 0x65, 0x72, 0x74, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x69,
+    0x6e, 0x20, 0x76, 0x69, 0x74, 0x72, 0x6f, 0x00, 0x69, 0x6e, 0x20, 0x74,
+    0x68, 0x65, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x69, 0x6e, 0x20, 0x73,
+    0x69, 0x74, 0x75, 0x00, 0x69, 0x6e, 0x20, 0x62, 0x72, 0x69, 0x65, 0x66,
+    0x00, 0x69, 0x64, 0x6c, 0x79, 0x00, 0x69, 0x62, 0x69, 0x64, 0x00, 0x69,
+    0x62, 0x69, 0x64, 0x2e, 0x00, 0x68, 0x75, 0x73, 0x6b, 0x69, 0x6c, 0x79,
+    0x00, 0x68, 0x75, 0x67, 0x65, 0x6c, 0x79, 0x00, 0x68, 0x6f, 0x74, 0x6c,
+    0x79, 0x00, 0x68, 0x6f, 0x72, 0x72, 0x69, 0x62, 0x6c, 0x79, 0x00, 0x68,
+    0x6f, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x68, 0x65, 0x73, 0x69, 0x74, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x68,
+    0x65, 0x72, 0x65, 0x62, 0x79, 0x00, 0x68, 0x65, 0x6e, 0x63, 0x65, 0x66,
+    0x6f, 0x72, 0x74, 0x68, 0x00, 0x68, 0x61, 0x72, 0x73, 0x68, 0x6c, 0x79,
+    0x00, 0x68, 0x61, 0x6c, 0x66, 0x2d, 0x77, 0x61, 0x79, 0x00, 0x68, 0x61,
+    0x6c, 0x66, 0x20, 0x77, 0x61, 0x79, 0x00, 0x68, 0x61, 0x62, 0x69, 0x74,
+    0x75, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x67, 0x72, 0x75, 0x64, 0x67, 0x69,
+    0x6e, 0x67, 0x6c, 0x79, 0x00, 0x67, 0x72, 0x6f, 0x73, 0x73, 0x6c, 0x79,
+    0x00, 0x67, 0x72, 0x61, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x67, 0x72, 0x61,
+    0x74, 0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x67, 0x72, 0x61, 0x70,
+    0x68, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x67, 0x72, 0x61, 0x63,
+    0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x67, 0x6c, 0x6f, 0x6f, 0x6d,
+    0x69, 0x6c, 0x79, 0x00, 0x67, 0x6c, 0x61, 0x64, 0x6c, 0x79, 0x00, 0x67,
+    0x69, 0x6e, 0x67, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x67, 0x65, 0x6f, 0x67,
+    0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x67,
+    0x65, 0x6e, 0x65, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x66,
+    0x75, 0x6c, 0x6c, 0x00, 0x66, 0x75, 0x6c, 0x6c, 0x2d, 0x74, 0x69, 0x6d,
+    0x65, 0x00, 0x66, 0x6f, 0x72, 0x74, 0x68, 0x77, 0x69, 0x74, 0x68, 0x00,
+    0x66, 0x6f, 0x72, 0x63, 0x69, 0x62, 0x6c, 0x79, 0x00, 0x66, 0x6f, 0x72,
+    0x63, 0x65, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x66, 0x6f, 0x72, 0x20,
+    0x73, 0x75, 0x72, 0x65, 0x00, 0x66, 0x6c, 0x61, 0x74, 0x6c, 0x79, 0x00,
+    0x66, 0x69, 0x6e, 0x65, 0x00, 0x66, 0x61, 0x72, 0x74, 0x68, 0x65, 0x72,
+    0x00, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x74,
+    0x65, 0x72, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x70, 0x65,
+    0x72, 0x74, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d,
+    0x65, 0x6e, 0x74, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x63, 0x69,
+    0x74, 0x65, 0x64, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x63, 0x65, 0x73, 0x73,
+    0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x65, 0x78, 0x63, 0x65, 0x65, 0x64,
+    0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x65, 0x76, 0x65, 0x72, 0x20, 0x73,
+    0x6f, 0x00, 0x65, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x6c, 0x79, 0x00,
+    0x65, 0x6d, 0x70, 0x68, 0x61, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79,
+    0x00, 0x65, 0x6d, 0x69, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x65,
+    0x6c, 0x65, 0x67, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x65, 0x6c, 0x65,
+    0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x65, 0x66, 0x66, 0x6f, 0x72, 0x74, 0x6c, 0x65, 0x73, 0x73, 0x6c, 0x79,
+    0x00, 0x65, 0x61, 0x73, 0x74, 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x65,
+    0x61, 0x72, 0x6e, 0x65, 0x73, 0x74, 0x6c, 0x79, 0x00, 0x64, 0x72, 0x61,
+    0x73, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x64, 0x6f, 0x77,
+    0x6e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x00, 0x64, 0x6f, 0x77, 0x6e,
+    0x68, 0x69, 0x6c, 0x6c, 0x00, 0x64, 0x6f, 0x75, 0x62, 0x74, 0x66, 0x75,
+    0x6c, 0x6c, 0x79, 0x00, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x79, 0x00, 0x64,
+    0x6f, 0x75, 0x62, 0x6c, 0x65, 0x00, 0x64, 0x69, 0x73, 0x70, 0x72, 0x6f,
+    0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x74, 0x65, 0x6c, 0x79,
+    0x00, 0x64, 0x69, 0x73, 0x63, 0x72, 0x65, 0x65, 0x74, 0x6c, 0x79, 0x00,
+    0x64, 0x69, 0x6d, 0x6c, 0x79, 0x00, 0x64, 0x65, 0x6e, 0x73, 0x65, 0x6c,
+    0x79, 0x00, 0x64, 0x65, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x6c, 0x79,
+    0x00, 0x64, 0x65, 0x66, 0x69, 0x61, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x64,
+    0x65, 0x66, 0x65, 0x6e, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x64,
+    0x65, 0x63, 0x69, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x64, 0x65,
+    0x61, 0x72, 0x6c, 0x79, 0x00, 0x64, 0x61, 0x72, 0x6b, 0x6c, 0x79, 0x00,
+    0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x63,
+    0x72, 0x75, 0x65, 0x6c, 0x6c, 0x79, 0x00, 0x63, 0x72, 0x75, 0x64, 0x65,
+    0x6c, 0x79, 0x00, 0x63, 0x72, 0x75, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79,
+    0x00, 0x63, 0x72, 0x6f, 0x73, 0x73, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x72,
+    0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x6c, 0x79,
+    0x00, 0x63, 0x6f, 0x6f, 0x6c, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6e, 0x76,
+    0x69, 0x6e, 0x63, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6e,
+    0x76, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x6c, 0x79, 0x00,
+    0x63, 0x6f, 0x6e, 0x73, 0x70, 0x69, 0x63, 0x75, 0x6f, 0x75, 0x73, 0x6c,
+    0x79, 0x00, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x69, 0x76, 0x61, 0x62, 0x6c,
+    0x79, 0x00, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x73, 0x74, 0x00, 0x63, 0x6c,
+    0x69, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x63, 0x6c, 0x65,
+    0x76, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x63, 0x69, 0x72, 0x63, 0x61, 0x00,
+    0x63, 0x68, 0x65, 0x6d, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x63,
+    0x61, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x6c, 0x79, 0x00, 0x62, 0x79,
+    0x20, 0x61, 0x6e, 0x64, 0x20, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x00, 0x62,
+    0x75, 0x73, 0x69, 0x6c, 0x79, 0x00, 0x62, 0x72, 0x75, 0x74, 0x61, 0x6c,
+    0x6c, 0x79, 0x00, 0x62, 0x72, 0x61, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x62,
+    0x6f, 0x6c, 0x64, 0x6c, 0x79, 0x00, 0x62, 0x6c, 0x75, 0x6e, 0x74, 0x6c,
+    0x79, 0x00, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x6c, 0x79, 0x00, 0x62, 0x6c,
+    0x61, 0x6e, 0x6b, 0x6c, 0x79, 0x00, 0x62, 0x65, 0x6e, 0x65, 0x61, 0x74,
+    0x68, 0x00, 0x62, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x6c, 0x79, 0x00,
+    0x61, 0x77, 0x6b, 0x77, 0x61, 0x72, 0x64, 0x6c, 0x79, 0x00, 0x61, 0x77,
+    0x66, 0x75, 0x6c, 0x6c, 0x79, 0x00, 0x61, 0x74, 0x20, 0x77, 0x6f, 0x72,
+    0x73, 0x74, 0x00, 0x61, 0x74, 0x20, 0x6d, 0x6f, 0x73, 0x74, 0x00, 0x61,
+    0x73, 0x74, 0x6f, 0x6e, 0x69, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x6c, 0x79,
+    0x00, 0x61, 0x73, 0x20, 0x61, 0x20, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72,
+    0x20, 0x6f, 0x66, 0x20, 0x66, 0x61, 0x63, 0x74, 0x00, 0x61, 0x72, 0x74,
+    0x69, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x61, 0x72,
+    0x62, 0x69, 0x74, 0x72, 0x61, 0x72, 0x69, 0x6c, 0x79, 0x00, 0x61, 0x70,
+    0x70, 0x72, 0x6f, 0x78, 0x00, 0x61, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x65,
+    0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x61, 0x6e, 0x79, 0x6d,
+    0x6f, 0x72, 0x65, 0x00, 0x61, 0x6e, 0x79, 0x68, 0x6f, 0x77, 0x00, 0x61,
+    0x6e, 0x64, 0x20, 0x73, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x74, 0x68, 0x00,
+    0x61, 0x6d, 0x61, 0x7a, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x61, 0x6c,
+    0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x61, 0x6c,
+    0x6f, 0x66, 0x74, 0x00, 0x61, 0x6c, 0x6c, 0x20, 0x6f, 0x66, 0x20, 0x61,
+    0x20, 0x73, 0x75, 0x64, 0x64, 0x65, 0x6e, 0x00, 0x61, 0x6c, 0x61, 0x72,
+    0x6d, 0x69, 0x6e, 0x67, 0x6c, 0x79, 0x00, 0x61, 0x67, 0x67, 0x72, 0x65,
+    0x73, 0x73, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x00, 0x61, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x00, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+    0x61, 0x74, 0x65, 0x6c, 0x79, 0x00, 0x61, 0x64, 0x76, 0x65, 0x72, 0x73,
+    0x65, 0x6c, 0x79, 0x00, 0x61, 0x64, 0x6d, 0x69, 0x72, 0x61, 0x62, 0x6c,
+    0x79, 0x00, 0x61, 0x62, 0x73, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x00, 0x61,
+    0x62, 0x6f, 0x61, 0x72, 0x64, 0x00, 0x61, 0x62, 0x61, 0x63, 0x6b, 0x00,
+    0x61, 0x2e, 0x64, 0x2e, 0x00, 0x61, 0x20, 0x6c, 0x6f, 0x74, 0x00, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xa3, 0x00, 0x00, 0x01, 0xf8, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0c, 0x74, 0x68, 0x65, 0x00, 0x61,
+    0x00, 0x61, 0x6e, 0x00, 0x6e, 0x6f, 0x00, 0x65, 0x76, 0x65, 0x72, 0x79,
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00,
+    0x2f, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+    0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
+    0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+    0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+    0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
+    0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x2a, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00,
+    0x40, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00,
+    0x58, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00,
+    0x6b, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00,
+    0x7e, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
+    0x95, 0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00,
+    0xad, 0x00, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00,
+    0xc7, 0x00, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x00, 0xda, 0x00, 0x00, 0x00,
+    0xdf, 0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
+    0xf8, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x01, 0x06, 0x00, 0x00, 0x01,
+    0x0b, 0x00, 0x00, 0x01, 0x12, 0x00, 0x00, 0x01, 0x1c, 0x00, 0x00, 0x01,
+    0x24, 0x00, 0x00, 0x01, 0x2a, 0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x01,
+    0x3e, 0x00, 0x00, 0x01, 0x48, 0x00, 0x00, 0x01, 0x4e, 0x00, 0x00, 0x01,
+    0x54, 0x00, 0x00, 0x01, 0x5b, 0x00, 0x00, 0x01, 0x63, 0x00, 0x00, 0x01,
+    0x6e, 0x00, 0x00, 0x01, 0x77, 0x00, 0x00, 0x01, 0x7f, 0x00, 0x00, 0x01,
+    0x88, 0x00, 0x00, 0x01, 0x8f, 0x00, 0x00, 0x01, 0x97, 0x00, 0x00, 0x01,
+    0x9e, 0x00, 0x00, 0x01, 0xa4, 0x00, 0x00, 0x01, 0xab, 0x00, 0x00, 0x01,
+    0xb2, 0x00, 0x00, 0x01, 0xba, 0x00, 0x00, 0x01, 0xbf, 0x00, 0x00, 0x01,
+    0xc9, 0x00, 0x00, 0x01, 0xcf, 0x00, 0x00, 0x01, 0xd5, 0x00, 0x00, 0x01,
+    0xdf, 0x00, 0x00, 0x01, 0xe6, 0x00, 0x00, 0x01, 0xec, 0x00, 0x00, 0x01,
+    0xf6, 0x00, 0x00, 0x01, 0xfc, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x02,
+    0x0a, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x02, 0x20, 0x00, 0x00, 0x02,
+    0x26, 0x00, 0x00, 0x02, 0x2f, 0x00, 0x00, 0x02, 0x35, 0x00, 0x00, 0x02,
+    0x3b, 0x00, 0x00, 0x02, 0x41, 0x00, 0x00, 0x02, 0x49, 0x00, 0x00, 0x02,
+    0x4e, 0x00, 0x00, 0x02, 0x54, 0x00, 0x00, 0x02, 0x5a, 0x00, 0x00, 0x02,
+    0x62, 0x00, 0x00, 0x02, 0x6a, 0x00, 0x00, 0x02, 0x70, 0x00, 0x00, 0x02,
+    0x79, 0x00, 0x00, 0x02, 0x80, 0x00, 0x00, 0x02, 0x87, 0x00, 0x00, 0x02,
+    0x8f, 0x00, 0x00, 0x02, 0x96, 0x00, 0x00, 0x02, 0x9f, 0x00, 0x00, 0x02,
+    0xa7, 0x00, 0x00, 0x02, 0xaf, 0x00, 0x00, 0x02, 0xbb, 0x00, 0x00, 0x02,
+    0xc2, 0x00, 0x00, 0x02, 0xc8, 0x00, 0x00, 0x02, 0xd1, 0x00, 0x00, 0x02,
+    0xda, 0x00, 0x00, 0x02, 0xe6, 0x00, 0x00, 0x02, 0xee, 0x00, 0x00, 0x02,
+    0xf4, 0x00, 0x00, 0x02, 0xf9, 0x00, 0x00, 0x02, 0xff, 0x00, 0x00, 0x03,
+    0x06, 0x00, 0x00, 0x03, 0x0c, 0x00, 0x00, 0x03, 0x12, 0x00, 0x00, 0x03,
+    0x1a, 0x00, 0x00, 0x03, 0x21, 0x00, 0x00, 0x03, 0x2b, 0x00, 0x00, 0x03,
+    0x32, 0x00, 0x00, 0x03, 0x38, 0x00, 0x00, 0x03, 0x42, 0x00, 0x00, 0x03,
+    0x4c, 0x00, 0x00, 0x03, 0x52, 0x00, 0x00, 0x03, 0x5a, 0x00, 0x00, 0x03,
+    0x60, 0x00, 0x00, 0x03, 0x6d, 0x00, 0x00, 0x03, 0x78, 0x00, 0x00, 0x03,
+    0x81, 0x00, 0x00, 0x03, 0x8e, 0x00, 0x00, 0x03, 0x98, 0x00, 0x00, 0x03,
+    0xa2, 0x00, 0x00, 0x03, 0xaa, 0x00, 0x00, 0x03, 0xaf, 0x00, 0x00, 0x03,
+    0xb6, 0x00, 0x00, 0x03, 0xbf, 0x00, 0x00, 0x03, 0xc5, 0x00, 0x00, 0x03,
+    0xcd, 0x00, 0x00, 0x03, 0xd5, 0x00, 0x00, 0x03, 0xdb, 0x00, 0x00, 0x03,
+    0xe6, 0x00, 0x00, 0x03, 0xec, 0x00, 0x00, 0x03, 0xf3, 0x00, 0x00, 0x03,
+    0xf9, 0x00, 0x00, 0x04, 0x06, 0x00, 0x00, 0x04, 0x0e, 0x00, 0x00, 0x04,
+    0x1c, 0x00, 0x00, 0x04, 0x24, 0x00, 0x00, 0x04, 0x2d, 0x00, 0x00, 0x04,
+    0x38, 0x00, 0x00, 0x04, 0x43, 0x00, 0x00, 0x04, 0x47, 0x00, 0x00, 0x04,
+    0x4e, 0x00, 0x00, 0x04, 0x55, 0x00, 0x00, 0x04, 0x5e, 0x00, 0x00, 0x04,
+    0x65, 0x00, 0x00, 0x04, 0x73, 0x00, 0x00, 0x04, 0x7e, 0x00, 0x00, 0x04,
+    0x88, 0x00, 0x00, 0x04, 0x91, 0x00, 0x00, 0x04, 0x9a, 0x00, 0x00, 0x04,
+    0x9f, 0x00, 0x00, 0x04, 0xa5, 0x00, 0x00, 0x04, 0xad, 0x00, 0x00, 0x04,
+    0xb3, 0x00, 0x00, 0x04, 0xb9, 0x00, 0x00, 0x04, 0xc1, 0x00, 0x00, 0x04,
+    0xcb, 0x00, 0x00, 0x04, 0xd4, 0x00, 0x00, 0x04, 0xde, 0x00, 0x00, 0x04,
+    0xe6, 0x00, 0x00, 0x04, 0xed, 0x00, 0x00, 0x04, 0xf5, 0x00, 0x00, 0x04,
+    0xff, 0x00, 0x00, 0x05, 0x0c, 0x00, 0x00, 0x05, 0x19, 0x00, 0x00, 0x05,
+    0x22, 0x00, 0x00, 0x05, 0x29, 0x00, 0x00, 0x05, 0x33, 0x00, 0x00, 0x05,
+    0x3b, 0x00, 0x00, 0x05, 0x41, 0x00, 0x00, 0x05, 0x47, 0x00, 0x00, 0x05,
+    0x4f, 0x00, 0x00, 0x05, 0x58, 0x00, 0x00, 0x05, 0x60, 0x00, 0x00, 0x05,
+    0x6a, 0x00, 0x00, 0x05, 0x75, 0x00, 0x00, 0x05, 0x7c, 0x00, 0x00, 0x05,
+    0x85, 0x00, 0x00, 0x05, 0x93, 0x00, 0x00, 0x05, 0x9a, 0x00, 0x00, 0x05,
+    0xa0, 0x00, 0x00, 0x05, 0xa7, 0x00, 0x00, 0x05, 0xb0, 0x00, 0x00, 0x05,
+    0xb5, 0x00, 0x00, 0x05, 0xba, 0x00, 0x00, 0x05, 0xc0, 0x00, 0x00, 0x05,
+    0xcc, 0x00, 0x00, 0x05, 0xd6, 0x00, 0x00, 0x05, 0xde, 0x00, 0x00, 0x05,
+    0xe5, 0x00, 0x00, 0x05, 0xee, 0x00, 0x00, 0x05, 0xf4, 0x00, 0x00, 0x06,
+    0x01, 0x00, 0x00, 0x06, 0x09, 0x00, 0x00, 0x06, 0x14, 0x00, 0x00, 0x06,
+    0x1c, 0x00, 0x00, 0x06, 0x24, 0x00, 0x00, 0x06, 0x2c, 0x00, 0x00, 0x06,
+    0x32, 0x00, 0x00, 0x06, 0x3c, 0x00, 0x00, 0x06, 0x41, 0x00, 0x00, 0x06,
+    0x49, 0x00, 0x00, 0x06, 0x52, 0x00, 0x00, 0x06, 0x5a, 0x00, 0x00, 0x06,
+    0x61, 0x00, 0x00, 0x06, 0x67, 0x00, 0x00, 0x06, 0x70, 0x00, 0x00, 0x06,
+    0x79, 0x00, 0x00, 0x06, 0x80, 0x00, 0x00, 0x06, 0x86, 0x00, 0x00, 0x06,
+    0x8c, 0x00, 0x00, 0x06, 0x92, 0x00, 0x00, 0x06, 0x98, 0x00, 0x00, 0x06,
+    0x9e, 0x00, 0x00, 0x06, 0xa9, 0x00, 0x00, 0x06, 0xb1, 0x00, 0x00, 0x06,
+    0xbc, 0x00, 0x00, 0x06, 0xc2, 0x00, 0x00, 0x06, 0xc9, 0x00, 0x00, 0x06,
+    0xd0, 0x00, 0x00, 0x06, 0xda, 0x00, 0x00, 0x06, 0xe5, 0x00, 0x00, 0x06,
+    0xeb, 0x00, 0x00, 0x06, 0xf5, 0x00, 0x00, 0x06, 0xfb, 0x00, 0x00, 0x07,
+    0x04, 0x00, 0x00, 0x07, 0x0c, 0x00, 0x00, 0x07, 0x12, 0x00, 0x00, 0x07,
+    0x1a, 0x00, 0x00, 0x07, 0x26, 0x00, 0x00, 0x07, 0x2e, 0x00, 0x00, 0x07,
+    0x39, 0x00, 0x00, 0x07, 0x44, 0x00, 0x00, 0x07, 0x50, 0x00, 0x00, 0x07,
+    0x5a, 0x00, 0x00, 0x07, 0x64, 0x00, 0x00, 0x07, 0x6c, 0x00, 0x00, 0x07,
+    0x74, 0x00, 0x00, 0x07, 0x7d, 0x00, 0x00, 0x07, 0x83, 0x00, 0x00, 0x07,
+    0x8a, 0x00, 0x00, 0x07, 0x92, 0x00, 0x00, 0x07, 0x9a, 0x00, 0x00, 0x07,
+    0xa5, 0x00, 0x00, 0x07, 0xad, 0x00, 0x00, 0x07, 0xb7, 0x00, 0x00, 0x07,
+    0xbf, 0x00, 0x00, 0x07, 0xc8, 0x00, 0x00, 0x07, 0xcf, 0x00, 0x00, 0x07,
+    0xd6, 0x00, 0x00, 0x07, 0xdc, 0x00, 0x00, 0x07, 0xe7, 0x00, 0x00, 0x07,
+    0xf4, 0x00, 0x00, 0x07, 0xfd, 0x00, 0x00, 0x08, 0x04, 0x00, 0x00, 0x08,
+    0x0a, 0x00, 0x00, 0x08, 0x12, 0x00, 0x00, 0x08, 0x1c, 0x00, 0x00, 0x08,
+    0x23, 0x00, 0x00, 0x08, 0x29, 0x00, 0x00, 0x08, 0x2f, 0x00, 0x00, 0x08,
+    0x34, 0x00, 0x00, 0x08, 0x3e, 0x00, 0x00, 0x08, 0x46, 0x00, 0x00, 0x08,
+    0x50, 0x00, 0x00, 0x08, 0x5c, 0x00, 0x00, 0x08, 0x66, 0x00, 0x00, 0x08,
+    0x73, 0x00, 0x00, 0x08, 0x7f, 0x00, 0x00, 0x08, 0x87, 0x00, 0x00, 0x08,
+    0x8e, 0x00, 0x00, 0x08, 0x95, 0x00, 0x00, 0x08, 0xa0, 0x00, 0x00, 0x08,
+    0xb0, 0x00, 0x00, 0x08, 0xb8, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x00, 0x08,
+    0xc8, 0x00, 0x00, 0x08, 0xd0, 0x00, 0x00, 0x08, 0xd6, 0x00, 0x00, 0x08,
+    0xdf, 0x00, 0x00, 0x08, 0xe5, 0x00, 0x00, 0x08, 0xeb, 0x00, 0x00, 0x08,
+    0xf4, 0x00, 0x00, 0x08, 0xff, 0x00, 0x00, 0x09, 0x06, 0x00, 0x00, 0x09,
+    0x0f, 0x00, 0x00, 0x09, 0x16, 0x00, 0x00, 0x09, 0x1b, 0x00, 0x00, 0x09,
+    0x24, 0x00, 0x00, 0x09, 0x2a, 0x00, 0x00, 0x09, 0x30, 0x00, 0x00, 0x09,
+    0x3d, 0x00, 0x00, 0x09, 0x46, 0x00, 0x00, 0x09, 0x50, 0x00, 0x00, 0x09,
+    0x5b, 0x00, 0x00, 0x09, 0x61, 0x00, 0x00, 0x09, 0x6b, 0x00, 0x00, 0x09,
+    0x7b, 0x00, 0x00, 0x09, 0x85, 0x00, 0x00, 0x09, 0x8e, 0x00, 0x00, 0x09,
+    0x9a, 0x00, 0x00, 0x09, 0xa6, 0x00, 0x00, 0x09, 0xb0, 0x00, 0x00, 0x09,
+    0xb9, 0x00, 0x00, 0x09, 0xc3, 0x00, 0x00, 0x09, 0xd1, 0x00, 0x00, 0x09,
+    0xd9, 0x00, 0x00, 0x09, 0xe3, 0x00, 0x00, 0x09, 0xee, 0x00, 0x00, 0x09,
+    0xf9, 0x00, 0x00, 0x0a, 0x06, 0x00, 0x00, 0x0a, 0x0e, 0x00, 0x00, 0x0a,
+    0x16, 0x00, 0x00, 0x0a, 0x1d, 0x00, 0x00, 0x0a, 0x24, 0x00, 0x00, 0x0a,
+    0x2e, 0x00, 0x00, 0x0a, 0x33, 0x00, 0x00, 0x0a, 0x40, 0x00, 0x00, 0x0a,
+    0x47, 0x00, 0x00, 0x0a, 0x4e, 0x00, 0x00, 0x0a, 0x57, 0x00, 0x00, 0x0a,
+    0x5d, 0x00, 0x00, 0x0a, 0x63, 0x00, 0x00, 0x0a, 0x6b, 0x00, 0x00, 0x0a,
+    0x77, 0x00, 0x00, 0x0a, 0x83, 0x00, 0x00, 0x0a, 0x90, 0x00, 0x00, 0x0a,
+    0x95, 0x00, 0x00, 0x0a, 0x9a, 0x00, 0x00, 0x0a, 0xa3, 0x00, 0x00, 0x0a,
+    0xaf, 0x00, 0x00, 0x0a, 0xb7, 0x00, 0x00, 0x0a, 0xc0, 0x00, 0x00, 0x0a,
+    0xc9, 0x00, 0x00, 0x0a, 0xd0, 0x00, 0x00, 0x0a, 0xd9, 0x00, 0x00, 0x0a,
+    0xe3, 0x00, 0x00, 0x0a, 0xee, 0x00, 0x00, 0x0a, 0xfd, 0x00, 0x00, 0x0b,
+    0x06, 0x00, 0x00, 0x0b, 0x0c, 0x00, 0x00, 0x0b, 0x15, 0x00, 0x00, 0x0b,
+    0x1e, 0x00, 0x00, 0x0b, 0x28, 0x00, 0x00, 0x0b, 0x33, 0x00, 0x00, 0x0b,
+    0x39, 0x00, 0x00, 0x0b, 0x44, 0x00, 0x00, 0x0b, 0x4f, 0x00, 0x00, 0x0b,
+    0x58, 0x00, 0x00, 0x0b, 0x61, 0x00, 0x00, 0x0b, 0x6a, 0x00, 0x00, 0x0b,
+    0x71, 0x00, 0x00, 0x0b, 0x7a, 0x00, 0x00, 0x0b, 0x7f, 0x00, 0x00, 0x0b,
+    0x86, 0x00, 0x00, 0x0b, 0x8f, 0x00, 0x00, 0x0b, 0x9a, 0x00, 0x00, 0x0b,
+    0xa1, 0x00, 0x00, 0x0b, 0xa7, 0x00, 0x00, 0x0b, 0xaf, 0x00, 0x00, 0x0b,
+    0xb5, 0x00, 0x00, 0x0b, 0xbb, 0x00, 0x00, 0x0b, 0xc2, 0x00, 0x00, 0x0b,
+    0xc8, 0x00, 0x00, 0x0b, 0xcf, 0x00, 0x00, 0x0b, 0xd6, 0x00, 0x00, 0x0b,
+    0xdf, 0x00, 0x00, 0x0b, 0xe7, 0x00, 0x00, 0x0b, 0xf0, 0x00, 0x00, 0x0b,
+    0xfb, 0x00, 0x00, 0x0c, 0x05, 0x00, 0x00, 0x0c, 0x12, 0x00, 0x00, 0x0c,
+    0x1b, 0x00, 0x00, 0x0c, 0x22, 0x00, 0x00, 0x0c, 0x29, 0x00, 0x00, 0x0c,
+    0x36, 0x00, 0x00, 0x0c, 0x3d, 0x00, 0x00, 0x0c, 0x44, 0x00, 0x00, 0x0c,
+    0x4b, 0x00, 0x00, 0x0c, 0x53, 0x00, 0x00, 0x0c, 0x59, 0x00, 0x00, 0x0c,
+    0x5f, 0x00, 0x00, 0x0c, 0x66, 0x00, 0x00, 0x0c, 0x72, 0x00, 0x00, 0x0c,
+    0x79, 0x00, 0x00, 0x0c, 0x84, 0x00, 0x00, 0x0c, 0x8b, 0x00, 0x00, 0x0c,
+    0x93, 0x00, 0x00, 0x0c, 0x9c, 0x00, 0x00, 0x0c, 0xa3, 0x00, 0x00, 0x0c,
+    0xa9, 0x00, 0x00, 0x0c, 0xaf, 0x00, 0x00, 0x0c, 0xb9, 0x00, 0x00, 0x0c,
+    0xc4, 0x00, 0x00, 0x0c, 0xca, 0x00, 0x00, 0x0c, 0xd1, 0x00, 0x00, 0x0c,
+    0xd6, 0x00, 0x00, 0x0c, 0xdf, 0x00, 0x00, 0x0c, 0xea, 0x00, 0x00, 0x0c,
+    0xf2, 0x00, 0x00, 0x0c, 0xfb, 0x00, 0x00, 0x0d, 0x02, 0x00, 0x00, 0x0d,
+    0x0a, 0x00, 0x00, 0x0d, 0x12, 0x00, 0x00, 0x0d, 0x18, 0x00, 0x00, 0x0d,
+    0x1e, 0x00, 0x00, 0x0d, 0x24, 0x00, 0x00, 0x0d, 0x2b, 0x00, 0x00, 0x0d,
+    0x31, 0x00, 0x00, 0x0d, 0x3e, 0x00, 0x00, 0x0d, 0x4f, 0x00, 0x00, 0x0d,
+    0x59, 0x00, 0x00, 0x0d, 0x65, 0x00, 0x00, 0x0d, 0x6f, 0x00, 0x00, 0x0d,
+    0x78, 0x00, 0x00, 0x0d, 0x80, 0x00, 0x00, 0x0d, 0x8b, 0x00, 0x00, 0x0d,
+    0x9b, 0x00, 0x00, 0x0d, 0xa5, 0x00, 0x00, 0x0d, 0xb0, 0x00, 0x00, 0x0d,
+    0xba, 0x00, 0x00, 0x0d, 0xc9, 0x00, 0x00, 0x0d, 0xd6, 0x00, 0x00, 0x0d,
+    0xe4, 0x00, 0x00, 0x0d, 0xef, 0x00, 0x00, 0x0d, 0xf9, 0x00, 0x00, 0x0e,
+    0x07, 0x00, 0x00, 0x0e, 0x0d, 0x00, 0x00, 0x0e, 0x1b, 0x00, 0x00, 0x0e,
+    0x26, 0x00, 0x00, 0x0e, 0x33, 0x00, 0x00, 0x0e, 0x39, 0x00, 0x00, 0x0e,
+    0x41, 0x00, 0x00, 0x0e, 0x4a, 0x00, 0x00, 0x0e, 0x57, 0x00, 0x00, 0x0e,
+    0x63, 0x00, 0x00, 0x0e, 0x6a, 0x00, 0x00, 0x0e, 0x71, 0x00, 0x00, 0x0e,
+    0x79, 0x00, 0x00, 0x0e, 0x83, 0x00, 0x00, 0x0e, 0x8b, 0x00, 0x00, 0x0e,
+    0x91, 0x00, 0x00, 0x0e, 0x9a, 0x00, 0x00, 0x0e, 0xa3, 0x00, 0x00, 0x0e,
+    0xac, 0x00, 0x00, 0x0e, 0xb7, 0x00, 0x00, 0x0e, 0xbd, 0x00, 0x00, 0x0e,
+    0xc3, 0x00, 0x00, 0x0e, 0xd1, 0x00, 0x00, 0x0e, 0xd7, 0x00, 0x00, 0x0e,
+    0xe3, 0x00, 0x00, 0x0e, 0xe9, 0x00, 0x00, 0x0e, 0xef, 0x00, 0x00, 0x0e,
+    0xf5, 0x00, 0x00, 0x0e, 0xfc, 0x00, 0x00, 0x0f, 0x06, 0x00, 0x00, 0x0f,
+    0x0e, 0x00, 0x00, 0x0f, 0x16, 0x00, 0x00, 0x0f, 0x1d, 0x00, 0x00, 0x0f,
+    0x23, 0x00, 0x00, 0x0f, 0x28, 0x00, 0x00, 0x0f, 0x2f, 0x00, 0x00, 0x0f,
+    0x37, 0x00, 0x00, 0x0f, 0x41, 0x00, 0x00, 0x0f, 0x4d, 0x00, 0x00, 0x0f,
+    0x56, 0x00, 0x00, 0x0f, 0x62, 0x00, 0x00, 0x0f, 0x69, 0x00, 0x00, 0x0f,
+    0x76, 0x00, 0x00, 0x0f, 0x7d, 0x00, 0x00, 0x0f, 0x84, 0x00, 0x00, 0x0f,
+    0x8e, 0x00, 0x00, 0x0f, 0x94, 0x00, 0x00, 0x0f, 0x9d, 0x00, 0x00, 0x0f,
+    0xa3, 0x00, 0x00, 0x0f, 0xa9, 0x00, 0x00, 0x0f, 0xae, 0x00, 0x00, 0x0f,
+    0xb9, 0x00, 0x00, 0x0f, 0xc1, 0x00, 0x00, 0x0f, 0xc9, 0x00, 0x00, 0x0f,
+    0xcf, 0x00, 0x00, 0x0f, 0xdb, 0x00, 0x00, 0x0f, 0xe3, 0x00, 0x00, 0x0f,
+    0xeb, 0x00, 0x00, 0x0f, 0xf1, 0x00, 0x00, 0x0f, 0xf7, 0x00, 0x00, 0x0f,
+    0xff, 0x00, 0x00, 0x10, 0x04, 0x00, 0x00, 0x10, 0x0a, 0x00, 0x00, 0x10,
+    0x0f, 0x00, 0x00, 0x10, 0x18, 0x00, 0x00, 0x10, 0x20, 0x00, 0x00, 0x10,
+    0x27, 0x00, 0x00, 0x10, 0x2c, 0x00, 0x00, 0x10, 0x35, 0x00, 0x00, 0x10,
+    0x3d, 0x00, 0x00, 0x10, 0x44, 0x00, 0x00, 0x10, 0x4d, 0x00, 0x00, 0x10,
+    0x54, 0x00, 0x00, 0x10, 0x5e, 0x00, 0x00, 0x10, 0x69, 0x00, 0x00, 0x10,
+    0x71, 0x00, 0x00, 0x10, 0x79, 0x00, 0x00, 0x10, 0x83, 0x00, 0x00, 0x10,
+    0x8b, 0x00, 0x00, 0x10, 0x92, 0x00, 0x00, 0x10, 0x9c, 0x00, 0x00, 0x10,
+    0xa2, 0x00, 0x00, 0x10, 0xa7, 0x00, 0x00, 0x10, 0xaf, 0x00, 0x00, 0x10,
+    0xb7, 0x00, 0x00, 0x10, 0xc0, 0x00, 0x00, 0x10, 0xce, 0x00, 0x00, 0x10,
+    0xd8, 0x00, 0x00, 0x10, 0xe7, 0x00, 0x00, 0x10, 0xf5, 0x00, 0x00, 0x11,
+    0x01, 0x00, 0x00, 0x11, 0x0d, 0x00, 0x00, 0x11, 0x16, 0x00, 0x00, 0x11,
+    0x1f, 0x00, 0x00, 0x11, 0x2e, 0x00, 0x00, 0x11, 0x39, 0x00, 0x00, 0x11,
+    0x44, 0x00, 0x00, 0x11, 0x4d, 0x00, 0x00, 0x11, 0x57, 0x00, 0x00, 0x11,
+    0x60, 0x00, 0x00, 0x11, 0x67, 0x00, 0x00, 0x11, 0x6e, 0x00, 0x00, 0x11,
+    0x74, 0x00, 0x00, 0x11, 0x7a, 0x00, 0x00, 0x11, 0x85, 0x00, 0x00, 0x11,
+    0x8b, 0x00, 0x00, 0x11, 0x91, 0x00, 0x00, 0x11, 0x97, 0x00, 0x00, 0x11,
+    0x9d, 0x00, 0x00, 0x11, 0xa4, 0x00, 0x00, 0x11, 0xab, 0x00, 0x00, 0x11,
+    0xb0, 0x00, 0x00, 0x11, 0xb6, 0x00, 0x00, 0x11, 0xbe, 0x00, 0x00, 0x11,
+    0xc3, 0x00, 0x00, 0x11, 0xc8, 0x00, 0x00, 0x11, 0xce, 0x00, 0x00, 0x11,
+    0xd5, 0x00, 0x00, 0x11, 0xdc, 0x00, 0x00, 0x11, 0xe4, 0x00, 0x00, 0x11,
+    0xec, 0x00, 0x00, 0x11, 0xf8, 0x00, 0x00, 0x12, 0x05, 0x00, 0x00, 0x12,
+    0x10, 0x00, 0x00, 0x12, 0x18, 0x00, 0x00, 0x12, 0x20, 0x00, 0x00, 0x12,
+    0x2a, 0x00, 0x00, 0x12, 0x2f, 0x00, 0x00, 0x12, 0x3a, 0x00, 0x00, 0x12,
+    0x3f, 0x00, 0x00, 0x12, 0x49, 0x00, 0x00, 0x12, 0x54, 0x00, 0x00, 0x12,
+    0x5d, 0x00, 0x00, 0x12, 0x64, 0x00, 0x00, 0x12, 0x6b, 0x00, 0x00, 0x12,
+    0x75, 0x00, 0x00, 0x12, 0x7b, 0x00, 0x00, 0x12, 0x85, 0x00, 0x00, 0x12,
+    0x8c, 0x00, 0x00, 0x12, 0x92, 0x00, 0x00, 0x12, 0x98, 0x00, 0x00, 0x12,
+    0x9f, 0x00, 0x00, 0x12, 0xa8, 0x00, 0x00, 0x12, 0xb3, 0x00, 0x00, 0x12,
+    0xb8, 0x00, 0x00, 0x12, 0xc3, 0x00, 0x00, 0x12, 0xcb, 0x00, 0x00, 0x12,
+    0xd2, 0x00, 0x00, 0x12, 0xd9, 0x00, 0x00, 0x12, 0xe1, 0x00, 0x00, 0x12,
+    0xec, 0x00, 0x00, 0x12, 0xf6, 0x00, 0x00, 0x12, 0xfb, 0x00, 0x00, 0x13,
+    0x01, 0x00, 0x00, 0x13, 0x08, 0x00, 0x00, 0x13, 0x11, 0x00, 0x00, 0x13,
+    0x1a, 0x00, 0x00, 0x13, 0x25, 0x00, 0x00, 0x13, 0x2c, 0x00, 0x00, 0x13,
+    0x37, 0x00, 0x00, 0x13, 0x3e, 0x00, 0x00, 0x13, 0x46, 0x00, 0x00, 0x13,
+    0x4d, 0x00, 0x00, 0x13, 0x52, 0x00, 0x00, 0x13, 0x5b, 0x00, 0x00, 0x13,
+    0x62, 0x00, 0x00, 0x13, 0x67, 0x00, 0x00, 0x13, 0x6d, 0x00, 0x00, 0x13,
+    0x72, 0x00, 0x00, 0x13, 0x7a, 0x00, 0x00, 0x13, 0x81, 0x00, 0x00, 0x13,
+    0x8d, 0x00, 0x00, 0x13, 0x96, 0x00, 0x00, 0x13, 0x9e, 0x00, 0x00, 0x13,
+    0xab, 0x00, 0x00, 0x13, 0xbe, 0x00, 0x00, 0x13, 0xcb, 0x00, 0x00, 0x13,
+    0xd3, 0x00, 0x00, 0x13, 0xd9, 0x00, 0x00, 0x13, 0xdf, 0x00, 0x00, 0x13,
+    0xe7, 0x00, 0x00, 0x13, 0xef, 0x00, 0x00, 0x13, 0xf7, 0x00, 0x00, 0x14,
+    0x04, 0x00, 0x00, 0x14, 0x0d, 0x00, 0x00, 0x14, 0x16, 0x00, 0x00, 0x14,
+    0x20, 0x00, 0x00, 0x14, 0x25, 0x00, 0x00, 0x14, 0x2f, 0x00, 0x00, 0x14,
+    0x3a, 0x00, 0x00, 0x14, 0x44, 0x00, 0x00, 0x14, 0x4c, 0x00, 0x00, 0x14,
+    0x56, 0x00, 0x00, 0x14, 0x60, 0x00, 0x00, 0x14, 0x67, 0x00, 0x00, 0x14,
+    0x6e, 0x00, 0x00, 0x14, 0x74, 0x00, 0x00, 0x14, 0x7d, 0x00, 0x00, 0x14,
+    0x87, 0x00, 0x00, 0x14, 0x93, 0x00, 0x00, 0x14, 0x9a, 0x00, 0x00, 0x14,
+    0xa0, 0x00, 0x00, 0x14, 0xa8, 0x00, 0x00, 0x14, 0xb0, 0x00, 0x00, 0x14,
+    0xb6, 0x00, 0x00, 0x14, 0xbe, 0x00, 0x00, 0x14, 0xc5, 0x00, 0x00, 0x14,
+    0xcd, 0x00, 0x00, 0x14, 0xd9, 0x00, 0x00, 0x14, 0xe2, 0x00, 0x00, 0x14,
+    0xec, 0x00, 0x00, 0x14, 0xf3, 0x00, 0x00, 0x14, 0xf9, 0x00, 0x00, 0x15,
+    0x01, 0x00, 0x00, 0x15, 0x09, 0x00, 0x00, 0x15, 0x0f, 0x00, 0x00, 0x15,
+    0x16, 0x00, 0x00, 0x15, 0x1f, 0x00, 0x00, 0x15, 0x26, 0x00, 0x00, 0x15,
+    0x30, 0x00, 0x00, 0x15, 0x39, 0x00, 0x00, 0x15, 0x3e, 0x00, 0x00, 0x15,
+    0x46, 0x00, 0x00, 0x15, 0x4b, 0x00, 0x00, 0x15, 0x52, 0x00, 0x00, 0x15,
+    0x59, 0x00, 0x00, 0x15, 0x5f, 0x00, 0x00, 0x15, 0x66, 0x00, 0x00, 0x15,
+    0x6c, 0x00, 0x00, 0x15, 0x74, 0x00, 0x00, 0x15, 0x7d, 0x00, 0x00, 0x15,
+    0x89, 0x00, 0x00, 0x15, 0x95, 0x00, 0x00, 0x15, 0x9e, 0x00, 0x00, 0x15,
+    0xa7, 0x00, 0x00, 0x15, 0xb4, 0x00, 0x00, 0x15, 0xbd, 0x00, 0x00, 0x15,
+    0xc7, 0x00, 0x00, 0x15, 0xd7, 0x00, 0x00, 0x15, 0xdf, 0x00, 0x00, 0x15,
+    0xe7, 0x00, 0x00, 0x15, 0xf2, 0x00, 0x00, 0x15, 0xfd, 0x00, 0x00, 0x16,
+    0x04, 0x00, 0x00, 0x16, 0x09, 0x00, 0x00, 0x16, 0x0f, 0x00, 0x00, 0x16,
+    0x18, 0x00, 0x00, 0x16, 0x1e, 0x00, 0x00, 0x16, 0x27, 0x00, 0x00, 0x16,
+    0x2c, 0x00, 0x00, 0x16, 0x37, 0x00, 0x00, 0x16, 0x41, 0x00, 0x00, 0x16,
+    0x4a, 0x00, 0x00, 0x16, 0x53, 0x00, 0x00, 0x16, 0x5d, 0x00, 0x00, 0x16,
+    0x69, 0x00, 0x00, 0x16, 0x72, 0x00, 0x00, 0x16, 0x7c, 0x00, 0x00, 0x16,
+    0x83, 0x00, 0x00, 0x16, 0x8e, 0x00, 0x00, 0x16, 0x96, 0x00, 0x00, 0x16,
+    0x9e, 0x00, 0x00, 0x16, 0xa7, 0x00, 0x00, 0x16, 0xb4, 0x00, 0x00, 0x16,
+    0xc0, 0x00, 0x00, 0x16, 0xc8, 0x00, 0x00, 0x16, 0xd1, 0x00, 0x00, 0x16,
+    0xd7, 0x00, 0x00, 0x16, 0xe3, 0x00, 0x00, 0x16, 0xe9, 0x00, 0x00, 0x16,
+    0xef, 0x00, 0x00, 0x16, 0xf9, 0x00, 0x00, 0x16, 0xff, 0x00, 0x00, 0x17,
+    0x05, 0x00, 0x00, 0x17, 0x0b, 0x00, 0x00, 0x17, 0x13, 0x00, 0x00, 0x17,
+    0x1a, 0x00, 0x00, 0x17, 0x21, 0x00, 0x00, 0x17, 0x28, 0x00, 0x00, 0x17,
+    0x30, 0x00, 0x00, 0x17, 0x3a, 0x00, 0x00, 0x17, 0x41, 0x00, 0x00, 0x17,
+    0x4e, 0x00, 0x00, 0x17, 0x5a, 0x00, 0x00, 0x17, 0x62, 0x00, 0x00, 0x17,
+    0x6b, 0x00, 0x00, 0x17, 0x76, 0x00, 0x00, 0x17, 0x80, 0x00, 0x00, 0x17,
+    0x89, 0x00, 0x00, 0x17, 0x8f, 0x00, 0x00, 0x17, 0x98, 0x00, 0x00, 0x17,
+    0xa2, 0x00, 0x00, 0x17, 0xad, 0x00, 0x00, 0x17, 0xb4, 0x00, 0x00, 0x17,
+    0xba, 0x00, 0x00, 0x17, 0xc3, 0x00, 0x00, 0x17, 0xcc, 0x00, 0x00, 0x17,
+    0xd3, 0x00, 0x00, 0x17, 0xdd, 0x00, 0x00, 0x17, 0xe8, 0x00, 0x00, 0x17,
+    0xf2, 0x00, 0x00, 0x17, 0xfb, 0x00, 0x00, 0x18, 0x05, 0x00, 0x00, 0x18,
+    0x0c, 0x00, 0x00, 0x18, 0x16, 0x00, 0x00, 0x18, 0x1b, 0x00, 0x00, 0x18,
+    0x27, 0x00, 0x00, 0x18, 0x31, 0x00, 0x00, 0x18, 0x3c, 0x00, 0x00, 0x18,
+    0x43, 0x00, 0x00, 0x18, 0x4b, 0x00, 0x00, 0x18, 0x54, 0x00, 0x00, 0x18,
+    0x5b, 0x00, 0x00, 0x18, 0x65, 0x00, 0x00, 0x18, 0x6d, 0x00, 0x00, 0x18,
+    0x74, 0x00, 0x00, 0x18, 0x7a, 0x00, 0x00, 0x18, 0x82, 0x00, 0x00, 0x18,
+    0x8c, 0x00, 0x00, 0x18, 0x92, 0x00, 0x00, 0x18, 0x9b, 0x00, 0x00, 0x18,
+    0xa4, 0x00, 0x00, 0x18, 0xaa, 0x00, 0x00, 0x18, 0xb1, 0x00, 0x00, 0x18,
+    0xba, 0x00, 0x00, 0x18, 0xbf, 0x00, 0x00, 0x18, 0xc6, 0x00, 0x00, 0x18,
+    0xd0, 0x00, 0x00, 0x18, 0xdd, 0x00, 0x00, 0x18, 0xe6, 0x00, 0x00, 0x18,
+    0xee, 0x00, 0x00, 0x18, 0xf6, 0x00, 0x00, 0x18, 0xfd, 0x00, 0x00, 0x19,
+    0x05, 0x00, 0x00, 0x19, 0x0a, 0x00, 0x00, 0x19, 0x12, 0x00, 0x00, 0x19,
+    0x19, 0x00, 0x00, 0x19, 0x23, 0x00, 0x00, 0x19, 0x2a, 0x00, 0x00, 0x19,
+    0x30, 0x00, 0x00, 0x19, 0x3a, 0x00, 0x00, 0x19, 0x46, 0x00, 0x00, 0x19,
+    0x52, 0x00, 0x00, 0x19, 0x5a, 0x00, 0x00, 0x19, 0x63, 0x00, 0x00, 0x19,
+    0x69, 0x00, 0x00, 0x19, 0x70, 0x00, 0x00, 0x19, 0x76, 0x00, 0x00, 0x19,
+    0x7c, 0x00, 0x00, 0x19, 0x81, 0x00, 0x00, 0x19, 0x8e, 0x00, 0x00, 0x19,
+    0x94, 0x00, 0x00, 0x19, 0x9f, 0x00, 0x00, 0x19, 0xa8, 0x00, 0x00, 0x19,
+    0xb4, 0x00, 0x00, 0x19, 0xb9, 0x00, 0x00, 0x19, 0xbf, 0x00, 0x00, 0x19,
+    0xcb, 0x00, 0x00, 0x19, 0xda, 0x00, 0x00, 0x19, 0xe5, 0x00, 0x00, 0x19,
+    0xef, 0x00, 0x00, 0x19, 0xff, 0x00, 0x00, 0x1a, 0x0c, 0x00, 0x00, 0x1a,
+    0x17, 0x00, 0x00, 0x1a, 0x21, 0x00, 0x00, 0x1a, 0x29, 0x00, 0x00, 0x1a,
+    0x35, 0x00, 0x00, 0x1a, 0x41, 0x00, 0x00, 0x1a, 0x4c, 0x00, 0x00, 0x1a,
+    0x57, 0x00, 0x00, 0x1a, 0x5f, 0x00, 0x00, 0x1a, 0x69, 0x00, 0x00, 0x1a,
+    0x71, 0x00, 0x00, 0x1a, 0x7b, 0x00, 0x00, 0x1a, 0x86, 0x00, 0x00, 0x1a,
+    0x8e, 0x00, 0x00, 0x1a, 0x9c, 0x00, 0x00, 0x1a, 0xa5, 0x00, 0x00, 0x1a,
+    0xb0, 0x00, 0x00, 0x1a, 0xb8, 0x00, 0x00, 0x1a, 0xc0, 0x00, 0x00, 0x1a,
+    0xcb, 0x00, 0x00, 0x1a, 0xd2, 0x00, 0x00, 0x1a, 0xd8, 0x00, 0x00, 0x1a,
+    0xdf, 0x00, 0x00, 0x1a, 0xe6, 0x00, 0x00, 0x1a, 0xed, 0x00, 0x00, 0x1a,
+    0xf4, 0x00, 0x00, 0x1a, 0xfe, 0x00, 0x00, 0x1b, 0x03, 0x00, 0x00, 0x1b,
+    0x09, 0x00, 0x00, 0x1b, 0x13, 0x00, 0x00, 0x1b, 0x19, 0x00, 0x00, 0x1b,
+    0x1e, 0x00, 0x00, 0x1b, 0x28, 0x00, 0x00, 0x1b, 0x2e, 0x00, 0x00, 0x1b,
+    0x36, 0x00, 0x00, 0x1b, 0x3d, 0x00, 0x00, 0x1b, 0x44, 0x00, 0x00, 0x1b,
+    0x4e, 0x00, 0x00, 0x1b, 0x5a, 0x00, 0x00, 0x1b, 0x63, 0x00, 0x00, 0x1b,
+    0x6e, 0x00, 0x00, 0x1b, 0x78, 0x00, 0x00, 0x1b, 0x7d, 0x00, 0x00, 0x1b,
+    0x84, 0x00, 0x00, 0x1b, 0x8c, 0x00, 0x00, 0x1b, 0x92, 0x00, 0x00, 0x1b,
+    0x99, 0x00, 0x00, 0x1b, 0x9f, 0x00, 0x00, 0x1b, 0xa7, 0x00, 0x00, 0x1b,
+    0xad, 0x00, 0x00, 0x1b, 0xb3, 0x00, 0x00, 0x1b, 0xbc, 0x00, 0x00, 0x1b,
+    0xc6, 0x00, 0x00, 0x1b, 0xcf, 0x00, 0x00, 0x1b, 0xdb, 0x00, 0x00, 0x1b,
+    0xe3, 0x00, 0x00, 0x1b, 0xf0, 0x00, 0x00, 0x1b, 0xfc, 0x00, 0x00, 0x1c,
+    0x06, 0x00, 0x00, 0x1c, 0x11, 0x00, 0x00, 0x1c, 0x1b, 0x00, 0x00, 0x1c,
+    0x26, 0x00, 0x00, 0x1c, 0x33, 0x00, 0x00, 0x1c, 0x3c, 0x00, 0x00, 0x1c,
+    0x46, 0x00, 0x00, 0x1c, 0x50, 0x00, 0x00, 0x1c, 0x5d, 0x00, 0x00, 0x1c,
+    0x65, 0x00, 0x00, 0x1c, 0x71, 0x00, 0x00, 0x1c, 0x7b, 0x00, 0x00, 0x1c,
+    0x83, 0x00, 0x00, 0x1c, 0x8d, 0x00, 0x00, 0x1c, 0x95, 0x00, 0x00, 0x1c,
+    0x9f, 0x00, 0x00, 0x1c, 0xa5, 0x00, 0x00, 0x1c, 0xaf, 0x00, 0x00, 0x1c,
+    0xb6, 0x00, 0x00, 0x1c, 0xbe, 0x00, 0x00, 0x1c, 0xc8, 0x00, 0x00, 0x1c,
+    0xd1, 0x00, 0x00, 0x1c, 0xd8, 0x00, 0x00, 0x1c, 0xe1, 0x00, 0x00, 0x1c,
+    0xed, 0x00, 0x00, 0x1c, 0xf8, 0x00, 0x00, 0x1d, 0x03, 0x00, 0x00, 0x1d,
+    0x0e, 0x00, 0x00, 0x1d, 0x18, 0x00, 0x00, 0x1d, 0x25, 0x00, 0x00, 0x1d,
+    0x2e, 0x00, 0x00, 0x1d, 0x35, 0x00, 0x00, 0x1d, 0x3e, 0x00, 0x00, 0x1d,
+    0x4d, 0x00, 0x00, 0x1d, 0x57, 0x00, 0x00, 0x1d, 0x63, 0x00, 0x00, 0x1d,
+    0x6e, 0x00, 0x00, 0x1d, 0x77, 0x00, 0x00, 0x1d, 0x7d, 0x00, 0x00, 0x1d,
+    0x83, 0x00, 0x00, 0x1d, 0x8b, 0x00, 0x00, 0x1d, 0x95, 0x00, 0x00, 0x1d,
+    0x9d, 0x00, 0x00, 0x1d, 0xa5, 0x00, 0x00, 0x1d, 0xae, 0x00, 0x00, 0x1d,
+    0xb3, 0x00, 0x00, 0x1d, 0xbc, 0x00, 0x00, 0x1d, 0xc3, 0x00, 0x00, 0x1d,
+    0xc9, 0x00, 0x00, 0x1d, 0xd4, 0x00, 0x00, 0x1d, 0xdb, 0x00, 0x00, 0x1d,
+    0xe1, 0x00, 0x00, 0x1d, 0xeb, 0x00, 0x00, 0x1d, 0xf5, 0x00, 0x00, 0x1d,
+    0xfd, 0x00, 0x00, 0x1e, 0x06, 0x00, 0x00, 0x1e, 0x12, 0x00, 0x00, 0x1e,
+    0x1f, 0x00, 0x00, 0x1e, 0x27, 0x00, 0x00, 0x1e, 0x33, 0x00, 0x00, 0x1e,
+    0x3c, 0x00, 0x00, 0x1e, 0x45, 0x00, 0x00, 0x1e, 0x51, 0x00, 0x00, 0x1e,
+    0x5d, 0x00, 0x00, 0x1e, 0x67, 0x00, 0x00, 0x1e, 0x73, 0x00, 0x00, 0x1e,
+    0x7f, 0x00, 0x00, 0x1e, 0x8b, 0x00, 0x00, 0x1e, 0x97, 0x00, 0x00, 0x1e,
+    0xa2, 0x00, 0x00, 0x1e, 0xae, 0x00, 0x00, 0x1e, 0xbb, 0x00, 0x00, 0x1e,
+    0xc8, 0x00, 0x00, 0x1e, 0xd0, 0x00, 0x00, 0x1e, 0xd9, 0x00, 0x00, 0x1e,
+    0xe5, 0x00, 0x00, 0x1e, 0xeb, 0x00, 0x00, 0x1e, 0xf2, 0x00, 0x00, 0x1e,
+    0xf9, 0x00, 0x00, 0x1f, 0x01, 0x00, 0x00, 0x1f, 0x0c, 0x00, 0x00, 0x1f,
+    0x17, 0x00, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x1f, 0x25, 0x00, 0x00, 0x1f,
+    0x2c, 0x00, 0x00, 0x1f, 0x33, 0x00, 0x00, 0x1f, 0x3a, 0x00, 0x00, 0x1f,
+    0x43, 0x00, 0x00, 0x1f, 0x4d, 0x00, 0x00, 0x1f, 0x5b, 0x00, 0x00, 0x1f,
+    0x62, 0x00, 0x00, 0x1f, 0x69, 0x00, 0x00, 0x1f, 0x6e, 0x00, 0x00, 0x1f,
+    0x79, 0x00, 0x00, 0x1f, 0x80, 0x00, 0x00, 0x1f, 0x88, 0x00, 0x00, 0x1f,
+    0x8e, 0x00, 0x00, 0x1f, 0x98, 0x00, 0x00, 0x1f, 0xa0, 0x00, 0x00, 0x1f,
+    0xad, 0x00, 0x00, 0x1f, 0xb4, 0x00, 0x00, 0x1f, 0xc0, 0x00, 0x00, 0x1f,
+    0xc6, 0x00, 0x00, 0x1f, 0xce, 0x00, 0x00, 0x1f, 0xd6, 0x00, 0x00, 0x1f,
+    0xde, 0x00, 0x00, 0x1f, 0xe6, 0x00, 0x00, 0x1f, 0xec, 0x00, 0x00, 0x1f,
+    0xf2, 0x00, 0x00, 0x1f, 0xf9, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20,
+    0x08, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x20, 0x17, 0x00, 0x00, 0x20,
+    0x1f, 0x00, 0x00, 0x20, 0x25, 0x00, 0x00, 0x20, 0x2e, 0x00, 0x00, 0x20,
+    0x34, 0x00, 0x00, 0x20, 0x39, 0x00, 0x00, 0x20, 0x42, 0x00, 0x00, 0x20,
+    0x48, 0x00, 0x00, 0x20, 0x51, 0x00, 0x00, 0x20, 0x5b, 0x00, 0x00, 0x20,
+    0x67, 0x00, 0x00, 0x20, 0x73, 0x00, 0x00, 0x20, 0x7a, 0x00, 0x00, 0x20,
+    0x85, 0x00, 0x00, 0x20, 0x92, 0x00, 0x00, 0x20, 0x9d, 0x00, 0x00, 0x20,
+    0xa9, 0x00, 0x00, 0x20, 0xb1, 0x00, 0x00, 0x20, 0xb8, 0x00, 0x00, 0x20,
+    0xc2, 0x00, 0x00, 0x20, 0xcf, 0x00, 0x00, 0x20, 0xda, 0x00, 0x00, 0x20,
+    0xe1, 0x00, 0x00, 0x20, 0xed, 0x00, 0x00, 0x20, 0xf6, 0x00, 0x00, 0x21,
+    0x05, 0x00, 0x00, 0x21, 0x0e, 0x00, 0x00, 0x21, 0x18, 0x00, 0x00, 0x21,
+    0x1f, 0x00, 0x00, 0x21, 0x25, 0x00, 0x00, 0x21, 0x2b, 0x00, 0x00, 0x21,
+    0x38, 0x00, 0x00, 0x21, 0x44, 0x79, 0x65, 0x61, 0x72, 0x73, 0x00, 0x63,
+    0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x00, 0x77, 0x6f, 0x6d, 0x65,
+    0x6e, 0x00, 0x6d, 0x65, 0x6e, 0x00, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x73,
+    0x00, 0x65, 0x79, 0x65, 0x73, 0x00, 0x64, 0x61, 0x79, 0x73, 0x00, 0x6d,
+    0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x00, 0x6f, 0x74, 0x68, 0x65, 0x72,
+    0x73, 0x00, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x65, 0x00, 0x70, 0x72, 0x6f,
+    0x62, 0x6c, 0x65, 0x6d, 0x73, 0x00, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x00,
+    0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x00, 0x6d, 0x6f, 0x6e,
+    0x74, 0x68, 0x73, 0x00, 0x77, 0x6f, 0x72, 0x64, 0x73, 0x00, 0x61, 0x72,
+    0x65, 0x61, 0x73, 0x00, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x00, 0x68,
+    0x61, 0x6e, 0x64, 0x73, 0x00, 0x63, 0x61, 0x73, 0x65, 0x73, 0x00, 0x73,
+    0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x00, 0x70, 0x61, 0x74, 0x69, 0x65,
+    0x6e, 0x74, 0x73, 0x00, 0x68, 0x6f, 0x75, 0x72, 0x73, 0x00, 0x63, 0x6f,
+    0x6d, 0x70, 0x61, 0x6e, 0x69, 0x65, 0x73, 0x00, 0x74, 0x65, 0x72, 0x6d,
+    0x73, 0x00, 0x6d, 0x69, 0x6e, 0x75, 0x74, 0x65, 0x73, 0x00, 0x63, 0x6f,
+    0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x00, 0x63, 0x68, 0x61, 0x6e,
+    0x67, 0x65, 0x73, 0x00, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x00,
+    0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x77,
+    0x6f, 0x72, 0x6b, 0x65, 0x72, 0x73, 0x00, 0x77, 0x61, 0x79, 0x73, 0x00,
+    0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x73, 0x63, 0x68,
+    0x6f, 0x6f, 0x6c, 0x73, 0x00, 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x73,
+    0x00, 0x77, 0x65, 0x65, 0x6b, 0x73, 0x00, 0x73, 0x74, 0x75, 0x64, 0x69,
+    0x65, 0x73, 0x00, 0x66, 0x65, 0x65, 0x74, 0x00, 0x72, 0x69, 0x67, 0x68,
+    0x74, 0x73, 0x00, 0x71, 0x75, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x70, 0x61, 0x72, 0x74, 0x69, 0x65, 0x73, 0x00, 0x62, 0x6f, 0x6f,
+    0x6b, 0x73, 0x00, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x69,
+    0x65, 0x73, 0x00, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x00, 0x72,
+    0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x72, 0x61, 0x74,
+    0x65, 0x73, 0x00, 0x70, 0x61, 0x72, 0x74, 0x73, 0x00, 0x6c, 0x65, 0x76,
+    0x65, 0x6c, 0x73, 0x00, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x00,
+    0x61, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x74,
+    0x65, 0x61, 0x63, 0x68, 0x65, 0x72, 0x73, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73,
+    0x00, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x00, 0x6e, 0x75, 0x6d, 0x62,
+    0x65, 0x72, 0x73, 0x00, 0x69, 0x73, 0x73, 0x75, 0x65, 0x73, 0x00, 0x69,
+    0x64, 0x65, 0x61, 0x73, 0x00, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x73, 0x00,
+    0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x65, 0x66, 0x66, 0x65, 0x63,
+    0x74, 0x73, 0x00, 0x61, 0x72, 0x6d, 0x73, 0x00, 0x73, 0x74, 0x61, 0x6e,
+    0x64, 0x61, 0x72, 0x64, 0x73, 0x00, 0x73, 0x61, 0x6c, 0x65, 0x73, 0x00,
+    0x72, 0x75, 0x6c, 0x65, 0x73, 0x00, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72,
+    0x63, 0x65, 0x73, 0x00, 0x70, 0x72, 0x69, 0x63, 0x65, 0x73, 0x00, 0x6c,
+    0x69, 0x6e, 0x65, 0x73, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x73,
+    0x74, 0x73, 0x00, 0x67, 0x6f, 0x6f, 0x64, 0x73, 0x00, 0x66, 0x69, 0x67,
+    0x75, 0x72, 0x65, 0x73, 0x00, 0x63, 0x6f, 0x73, 0x74, 0x73, 0x00, 0x63,
+    0x69, 0x72, 0x63, 0x75, 0x6d, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73,
+    0x00, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x00, 0x74, 0x79, 0x70,
+    0x65, 0x73, 0x00, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x65, 0x73, 0x00,
+    0x70, 0x6c, 0x61, 0x6e, 0x73, 0x00, 0x6e, 0x65, 0x65, 0x64, 0x73, 0x00,
+    0x6d, 0x69, 0x6c, 0x65, 0x73, 0x00, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64,
+    0x73, 0x00, 0x6a, 0x6f, 0x62, 0x73, 0x00, 0x67, 0x69, 0x72, 0x6c, 0x73,
+    0x00, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x00, 0x66, 0x61, 0x63, 0x74, 0x6f,
+    0x72, 0x73, 0x00, 0x61, 0x6e, 0x69, 0x6d, 0x61, 0x6c, 0x73, 0x00, 0x74,
+    0x72, 0x65, 0x65, 0x73, 0x00, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74,
+    0x73, 0x00, 0x73, 0x68, 0x61, 0x72, 0x65, 0x73, 0x00, 0x70, 0x75, 0x70,
+    0x69, 0x6c, 0x73, 0x00, 0x70, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73, 0x00,
+    0x70, 0x6c, 0x61, 0x63, 0x65, 0x73, 0x00, 0x6f, 0x66, 0x66, 0x69, 0x63,
+    0x65, 0x72, 0x73, 0x00, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73, 0x00,
+    0x6c, 0x65, 0x74, 0x74, 0x65, 0x72, 0x73, 0x00, 0x69, 0x6e, 0x64, 0x69,
+    0x76, 0x69, 0x64, 0x75, 0x61, 0x6c, 0x73, 0x00, 0x68, 0x6f, 0x75, 0x73,
+    0x65, 0x73, 0x00, 0x66, 0x69, 0x72, 0x6d, 0x73, 0x00, 0x66, 0x65, 0x61,
+    0x74, 0x75, 0x72, 0x65, 0x73, 0x00, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x69,
+    0x65, 0x73, 0x00, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
+    0x65, 0x73, 0x00, 0x63, 0x6f, 0x75, 0x72, 0x73, 0x65, 0x73, 0x00, 0x63,
+    0x65, 0x6c, 0x6c, 0x73, 0x00, 0x62, 0x6f, 0x79, 0x73, 0x00, 0x76, 0x69,
+    0x65, 0x77, 0x73, 0x00, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x00, 0x75,
+    0x73, 0x65, 0x72, 0x73, 0x00, 0x75, 0x6e, 0x69, 0x74, 0x73, 0x00, 0x73,
+    0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x00, 0x73, 0x6b, 0x69, 0x6c, 0x6c,
+    0x73, 0x00, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x73, 0x00,
+    0x70, 0x6c, 0x61, 0x6e, 0x74, 0x73, 0x00, 0x6e, 0x61, 0x6d, 0x65, 0x73,
+    0x00, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x65, 0x72, 0x73, 0x00, 0x6d,
+    0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x73, 0x00, 0x6c, 0x69, 0x76,
+    0x65, 0x73, 0x00, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x00, 0x69,
+    0x74, 0x65, 0x6d, 0x73, 0x00, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x66, 0x61, 0x63, 0x69, 0x6c, 0x69,
+    0x74, 0x69, 0x65, 0x73, 0x00, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65,
+    0x73, 0x00, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x69,
+    0x65, 0x73, 0x00, 0x64, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x73, 0x00, 0x63,
+    0x6c, 0x6f, 0x74, 0x68, 0x65, 0x73, 0x00, 0x63, 0x61, 0x72, 0x73, 0x00,
+    0x62, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x00, 0x62, 0x65, 0x6e, 0x65, 0x66,
+    0x69, 0x74, 0x73, 0x00, 0x62, 0x61, 0x6e, 0x6b, 0x73, 0x00, 0x61, 0x73,
+    0x70, 0x65, 0x63, 0x74, 0x73, 0x00, 0x61, 0x66, 0x66, 0x61, 0x69, 0x72,
+    0x73, 0x00, 0x77, 0x61, 0x6c, 0x6c, 0x73, 0x00, 0x74, 0x65, 0x63, 0x68,
+    0x6e, 0x69, 0x71, 0x75, 0x65, 0x73, 0x00, 0x73, 0x74, 0x65, 0x70, 0x73,
+    0x00, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x00, 0x73, 0x69, 0x64, 0x65,
+    0x73, 0x00, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x6d, 0x65, 0x6e,
+    0x74, 0x73, 0x00, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x00, 0x72,
+    0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x73,
+    0x00, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x00, 0x70, 0x75, 0x72,
+    0x70, 0x6f, 0x73, 0x65, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,
+    0x6d, 0x6d, 0x65, 0x73, 0x00, 0x70, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70,
+    0x6c, 0x65, 0x73, 0x00, 0x70, 0x70, 0x2e, 0x00, 0x70, 0x6f, 0x77, 0x65,
+    0x72, 0x73, 0x00, 0x70, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x00, 0x70, 0x61,
+    0x74, 0x74, 0x65, 0x72, 0x6e, 0x73, 0x00, 0x70, 0x61, 0x70, 0x65, 0x72,
+    0x73, 0x00, 0x6f, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x75, 0x6e, 0x69, 0x74,
+    0x69, 0x65, 0x73, 0x00, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f,
+    0x6e, 0x73, 0x00, 0x6f, 0x66, 0x66, 0x69, 0x63, 0x69, 0x61, 0x6c, 0x73,
+    0x00, 0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x73, 0x00, 0x6d, 0x61,
+    0x6e, 0x61, 0x67, 0x65, 0x72, 0x73, 0x00, 0x6c, 0x65, 0x67, 0x73, 0x00,
+    0x68, 0x6f, 0x6d, 0x65, 0x73, 0x00, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64,
+    0x73, 0x00, 0x67, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x66, 0x75, 0x6e, 0x64,
+    0x73, 0x00, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x73, 0x00, 0x65, 0x6d,
+    0x70, 0x6c, 0x6f, 0x79, 0x65, 0x65, 0x73, 0x00, 0x65, 0x6c, 0x65, 0x6d,
+    0x65, 0x6e, 0x74, 0x73, 0x00, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f,
+    0x6e, 0x73, 0x00, 0x65, 0x66, 0x66, 0x6f, 0x72, 0x74, 0x73, 0x00, 0x63,
+    0x6f, 0x75, 0x72, 0x74, 0x73, 0x00, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65,
+    0x73, 0x00, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x00,
+    0x61, 0x72, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73,
+    0x00, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x76, 0x69, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x74,
+    0x72, 0x6f, 0x6f, 0x70, 0x73, 0x00, 0x74, 0x68, 0x6f, 0x75, 0x73, 0x61,
+    0x6e, 0x64, 0x73, 0x00, 0x73, 0x74, 0x72, 0x65, 0x65, 0x74, 0x73, 0x00,
+    0x73, 0x69, 0x74, 0x65, 0x73, 0x00, 0x72, 0x6f, 0x6f, 0x6d, 0x73, 0x00,
+    0x72, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x6a,
+    0x65, 0x63, 0x74, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x74, 0x73,
+    0x00, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x73, 0x00, 0x70,
+    0x72, 0x6f, 0x63, 0x65, 0x64, 0x75, 0x72, 0x65, 0x73, 0x00, 0x70, 0x69,
+    0x65, 0x63, 0x65, 0x73, 0x00, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65,
+    0x73, 0x00, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x73, 0x61, 0x74, 0x69,
+    0x6f, 0x6e, 0x73, 0x00, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x00, 0x6e,
+    0x6f, 0x74, 0x65, 0x73, 0x00, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x00,
+    0x6d, 0x65, 0x65, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x6c, 0x69, 0x70,
+    0x73, 0x00, 0x6c, 0x61, 0x77, 0x73, 0x00, 0x68, 0x65, 0x61, 0x64, 0x73,
+    0x00, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x73,
+    0x00, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x66,
+    0x6c, 0x6f, 0x77, 0x65, 0x72, 0x73, 0x00, 0x66, 0x69, 0x65, 0x6c, 0x64,
+    0x73, 0x00, 0x66, 0x65, 0x65, 0x6c, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x66,
+    0x61, 0x63, 0x74, 0x73, 0x00, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
+    0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64,
+    0x73, 0x00, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x61, 0x67, 0x75, 0x65, 0x73,
+    0x00, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x63, 0x68, 0x61,
+    0x72, 0x67, 0x65, 0x73, 0x00, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x65, 0x73,
+    0x00, 0x62, 0x69, 0x72, 0x64, 0x73, 0x00, 0x61, 0x74, 0x74, 0x69, 0x74,
+    0x75, 0x64, 0x65, 0x73, 0x00, 0x61, 0x72, 0x74, 0x73, 0x00, 0x61, 0x63,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e,
+    0x74, 0x73, 0x00, 0x77, 0x65, 0x61, 0x70, 0x6f, 0x6e, 0x73, 0x00, 0x75,
+    0x6e, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x74, 0x6f, 0x77, 0x6e, 0x73, 0x00,
+    0x74, 0x68, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x73, 0x00, 0x74, 0x68, 0x65,
+    0x6f, 0x72, 0x69, 0x65, 0x73, 0x00, 0x74, 0x68, 0x61, 0x6e, 0x6b, 0x73,
+    0x00, 0x74, 0x65, 0x73, 0x74, 0x73, 0x00, 0x74, 0x65, 0x65, 0x74, 0x68,
+    0x00, 0x74, 0x65, 0x61, 0x72, 0x73, 0x00, 0x74, 0x65, 0x61, 0x6d, 0x73,
+    0x00, 0x74, 0x61, 0x6c, 0x6b, 0x73, 0x00, 0x73, 0x74, 0x72, 0x75, 0x63,
+    0x74, 0x75, 0x72, 0x65, 0x73, 0x00, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x65,
+    0x73, 0x00, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73,
+    0x00, 0x73, 0x74, 0x61, 0x72, 0x73, 0x00, 0x73, 0x74, 0x61, 0x67, 0x65,
+    0x73, 0x00, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x00, 0x73, 0x6f, 0x63,
+    0x69, 0x65, 0x74, 0x69, 0x65, 0x73, 0x00, 0x73, 0x69, 0x74, 0x75, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x73, 0x69, 0x67, 0x6e, 0x73, 0x00,
+    0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x73, 0x00, 0x73, 0x68,
+    0x6f, 0x70, 0x73, 0x00, 0x73, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x00, 0x73, 0x65, 0x61,
+    0x74, 0x73, 0x00, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x73, 0x00, 0x72,
+    0x65, 0x67, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x72,
+    0x65, 0x67, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x76, 0x69,
+    0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72,
+    0x74, 0x69, 0x65, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x65, 0x64,
+    0x69, 0x6e, 0x67, 0x73, 0x00, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x63,
+    0x65, 0x73, 0x00, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x65, 0x72,
+    0x69, 0x6f, 0x64, 0x73, 0x00, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74,
+    0x73, 0x00, 0x70, 0x61, 0x67, 0x65, 0x73, 0x00, 0x6f, 0x77, 0x6e, 0x65,
+    0x72, 0x73, 0x00, 0x6f, 0x66, 0x66, 0x69, 0x63, 0x65, 0x73, 0x00, 0x6f,
+    0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x00, 0x6f, 0x62, 0x6a, 0x65, 0x63,
+    0x74, 0x69, 0x76, 0x65, 0x73, 0x00, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x6d, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00,
+    0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x73, 0x00, 0x6d, 0x61, 0x63, 0x68,
+    0x69, 0x6e, 0x65, 0x73, 0x00, 0x6c, 0x6f, 0x73, 0x73, 0x65, 0x73, 0x00,
+    0x6c, 0x69, 0x67, 0x68, 0x74, 0x73, 0x00, 0x6b, 0x69, 0x6e, 0x64, 0x73,
+    0x00, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72, 0x69, 0x65, 0x73, 0x00,
+    0x69, 0x6d, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x68, 0x75, 0x6e, 0x64, 0x72, 0x65, 0x64, 0x73, 0x00, 0x68, 0x6f,
+    0x72, 0x73, 0x65, 0x73, 0x00, 0x67, 0x6f, 0x61, 0x6c, 0x73, 0x00, 0x66,
+    0x61, 0x72, 0x6d, 0x65, 0x72, 0x73, 0x00, 0x65, 0x6d, 0x70, 0x6c, 0x6f,
+    0x79, 0x65, 0x72, 0x73, 0x00, 0x64, 0x75, 0x74, 0x69, 0x65, 0x73, 0x00,
+    0x64, 0x72, 0x75, 0x67, 0x73, 0x00, 0x64, 0x6f, 0x6f, 0x72, 0x73, 0x00,
+    0x64, 0x6f, 0x67, 0x73, 0x00, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e,
+    0x74, 0x73, 0x00, 0x64, 0x6f, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x64,
+    0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x64, 0x65, 0x70,
+    0x61, 0x72, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x63, 0x6f, 0x6e,
+    0x74, 0x72, 0x61, 0x63, 0x74, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x65,
+    0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x63, 0x6f, 0x6d, 0x6d,
+    0x75, 0x6e, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x63, 0x6f, 0x6c, 0x6f,
+    0x75, 0x72, 0x73, 0x00, 0x63, 0x6c, 0x61, 0x69, 0x6d, 0x73, 0x00, 0x63,
+    0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63,
+    0x74, 0x65, 0x72, 0x73, 0x00, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74,
+    0x65, 0x72, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x00, 0x61, 0x72, 0x74,
+    0x69, 0x73, 0x74, 0x73, 0x00, 0x61, 0x72, 0x67, 0x75, 0x6d, 0x65, 0x6e,
+    0x74, 0x73, 0x00, 0x79, 0x61, 0x72, 0x64, 0x73, 0x00, 0x77, 0x72, 0x69,
+    0x74, 0x65, 0x72, 0x73, 0x00, 0x77, 0x61, 0x67, 0x65, 0x73, 0x00, 0x76,
+    0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x73, 0x00, 0x74, 0x6f, 0x6f, 0x6c,
+    0x73, 0x00, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x00, 0x73, 0x79, 0x6d, 0x70,
+    0x74, 0x6f, 0x6d, 0x73, 0x00, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74,
+    0x65, 0x72, 0x73, 0x00, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x73, 0x00, 0x73,
+    0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x73, 0x74, 0x61, 0x69,
+    0x72, 0x73, 0x00, 0x73, 0x6f, 0x6e, 0x73, 0x00, 0x73, 0x6f, 0x6c, 0x64,
+    0x69, 0x65, 0x72, 0x73, 0x00, 0x73, 0x68, 0x6f, 0x77, 0x73, 0x00, 0x73,
+    0x68, 0x6f, 0x65, 0x73, 0x00, 0x73, 0x68, 0x61, 0x72, 0x65, 0x68, 0x6f,
+    0x6c, 0x64, 0x65, 0x72, 0x73, 0x00, 0x73, 0x65, 0x72, 0x76, 0x61, 0x6e,
+    0x74, 0x73, 0x00, 0x73, 0x65, 0x6e, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x73,
+    0x00, 0x73, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x69, 0x73, 0x74, 0x73, 0x00,
+    0x72, 0x6f, 0x61, 0x64, 0x73, 0x00, 0x72, 0x65, 0x73, 0x69, 0x64, 0x65,
+    0x6e, 0x74, 0x73, 0x00, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e,
+    0x74, 0x61, 0x74, 0x69, 0x76, 0x65, 0x73, 0x00, 0x70, 0x72, 0x69, 0x73,
+    0x6f, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x70, 0x72, 0x65, 0x6d, 0x69, 0x73,
+    0x65, 0x73, 0x00, 0x70, 0x6f, 0x6c, 0x69, 0x74, 0x69, 0x63, 0x69, 0x61,
+    0x6e, 0x73, 0x00, 0x70, 0x68, 0x6f, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70,
+    0x68, 0x73, 0x00, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x6e, 0x65, 0x6c,
+    0x00, 0x70, 0x61, 0x72, 0x74, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x70, 0x61,
+    0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x6f, 0x72, 0x67, 0x61,
+    0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x6f, 0x70,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x6f, 0x63, 0x63, 0x61, 0x73, 0x69,
+    0x6f, 0x6e, 0x73, 0x00, 0x6e, 0x65, 0x77, 0x73, 0x70, 0x61, 0x70, 0x65,
+    0x72, 0x73, 0x00, 0x6e, 0x65, 0x69, 0x67, 0x68, 0x62, 0x6f, 0x75, 0x72,
+    0x73, 0x00, 0x6e, 0x65, 0x67, 0x6f, 0x74, 0x69, 0x61, 0x74, 0x69, 0x6f,
+    0x6e, 0x73, 0x00, 0x6d, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x73, 0x00, 0x6d,
+    0x6f, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x6d, 0x65, 0x74, 0x72, 0x65,
+    0x73, 0x00, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x00, 0x6c, 0x61, 0x6e,
+    0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x00, 0x6b, 0x69, 0x64, 0x73, 0x00,
+    0x69, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x00, 0x67, 0x75, 0x65, 0x73,
+    0x74, 0x73, 0x00, 0x66, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x00,
+    0x66, 0x69, 0x6c, 0x6d, 0x73, 0x00, 0x66, 0x61, 0x63, 0x65, 0x73, 0x00,
+    0x65, 0x78, 0x70, 0x65, 0x72, 0x74, 0x73, 0x00, 0x65, 0x78, 0x70, 0x65,
+    0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x65, 0x78, 0x70, 0x65,
+    0x72, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x65, 0x78, 0x70, 0x65,
+    0x63, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x65, 0x67, 0x67,
+    0x73, 0x00, 0x65, 0x61, 0x72, 0x73, 0x00, 0x65, 0x61, 0x72, 0x6e, 0x69,
+    0x6e, 0x67, 0x73, 0x00, 0x64, 0x69, 0x73, 0x63, 0x75, 0x73, 0x73, 0x69,
+    0x6f, 0x6e, 0x73, 0x00, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x73, 0x00,
+    0x63, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x00, 0x63, 0x6f, 0x75,
+    0x6e, 0x63, 0x69, 0x6c, 0x73, 0x00, 0x63, 0x6f, 0x70, 0x69, 0x65, 0x73,
+    0x00, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x63, 0x6f,
+    0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x73, 0x00, 0x63, 0x6f, 0x6d, 0x70,
+    0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x63, 0x6f, 0x6d, 0x6d, 0x75,
+    0x6e, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x63, 0x6f,
+    0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x63, 0x6c, 0x75, 0x62, 0x73,
+    0x00, 0x63, 0x69, 0x74, 0x69, 0x7a, 0x65, 0x6e, 0x73, 0x00, 0x63, 0x68,
+    0x75, 0x72, 0x63, 0x68, 0x65, 0x73, 0x00, 0x63, 0x65, 0x6e, 0x74, 0x75,
+    0x72, 0x69, 0x65, 0x73, 0x00, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72,
+    0x69, 0x65, 0x73, 0x00, 0x63, 0x61, 0x72, 0x64, 0x73, 0x00, 0x63, 0x61,
+    0x6e, 0x64, 0x69, 0x64, 0x61, 0x74, 0x65, 0x73, 0x00, 0x62, 0x75, 0x73,
+    0x69, 0x6e, 0x65, 0x73, 0x73, 0x65, 0x73, 0x00, 0x62, 0x72, 0x6f, 0x74,
+    0x68, 0x65, 0x72, 0x73, 0x00, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x65,
+    0x73, 0x00, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x73, 0x00, 0x61,
+    0x73, 0x73, 0x65, 0x74, 0x73, 0x00, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c,
+    0x65, 0x73, 0x00, 0x61, 0x67, 0x65, 0x73, 0x00, 0x61, 0x67, 0x65, 0x6e,
+    0x74, 0x73, 0x00, 0x61, 0x67, 0x65, 0x6e, 0x63, 0x69, 0x65, 0x73, 0x00,
+    0x61, 0x64, 0x76, 0x61, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x73, 0x00, 0x61,
+    0x64, 0x75, 0x6c, 0x74, 0x73, 0x00, 0x77, 0x69, 0x76, 0x65, 0x73, 0x00,
+    0x77, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x77, 0x69, 0x6e, 0x67,
+    0x73, 0x00, 0x77, 0x61, 0x76, 0x65, 0x73, 0x00, 0x77, 0x61, 0x74, 0x65,
+    0x72, 0x73, 0x00, 0x76, 0x6f, 0x74, 0x65, 0x73, 0x00, 0x76, 0x6f, 0x74,
+    0x65, 0x72, 0x73, 0x00, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x00, 0x76,
+    0x69, 0x6c, 0x6c, 0x61, 0x67, 0x65, 0x73, 0x00, 0x76, 0x69, 0x63, 0x74,
+    0x69, 0x6d, 0x73, 0x00, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x76, 0x61, 0x72, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x00, 0x75, 0x6e,
+    0x69, 0x76, 0x65, 0x72, 0x73, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x74,
+    0x72, 0x6f, 0x75, 0x73, 0x65, 0x72, 0x73, 0x00, 0x74, 0x72, 0x69, 0x61,
+    0x6c, 0x73, 0x00, 0x74, 0x72, 0x65, 0x6e, 0x64, 0x73, 0x00, 0x74, 0x72,
+    0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x74,
+    0x6f, 0x70, 0x69, 0x63, 0x73, 0x00, 0x74, 0x6f, 0x6e, 0x6e, 0x65, 0x73,
+    0x00, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x73, 0x00, 0x74, 0x69, 0x63, 0x6b,
+    0x65, 0x74, 0x73, 0x00, 0x74, 0x65, 0x78, 0x74, 0x73, 0x00, 0x74, 0x61,
+    0x78, 0x65, 0x73, 0x00, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x00, 0x73,
+    0x75, 0x67, 0x67, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x73,
+    0x74, 0x79, 0x6c, 0x65, 0x73, 0x00, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65,
+    0x67, 0x69, 0x65, 0x73, 0x00, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x00,
+    0x73, 0x70, 0x69, 0x72, 0x69, 0x74, 0x73, 0x00, 0x73, 0x70, 0x65, 0x61,
+    0x6b, 0x65, 0x72, 0x73, 0x00, 0x73, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x00,
+    0x73, 0x6f, 0x72, 0x74, 0x73, 0x00, 0x73, 0x6f, 0x6e, 0x67, 0x73, 0x00,
+    0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x73, 0x6f,
+    0x6c, 0x69, 0x63, 0x69, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x73, 0x68, 0x69,
+    0x70, 0x73, 0x00, 0x73, 0x68, 0x65, 0x65, 0x74, 0x73, 0x00, 0x73, 0x65,
+    0x74, 0x73, 0x00, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x73, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x73,
+    0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x73, 0x63, 0x69, 0x65, 0x6e,
+    0x63, 0x65, 0x73, 0x00, 0x73, 0x63, 0x65, 0x6e, 0x65, 0x73, 0x00, 0x73,
+    0x61, 0x76, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x73, 0x61, 0x6d, 0x70, 0x6c,
+    0x65, 0x73, 0x00, 0x72, 0x6f, 0x6f, 0x74, 0x73, 0x00, 0x72, 0x6f, 0x6c,
+    0x65, 0x73, 0x00, 0x72, 0x6f, 0x63, 0x6b, 0x73, 0x00, 0x72, 0x69, 0x76,
+    0x65, 0x72, 0x73, 0x00, 0x72, 0x69, 0x73, 0x6b, 0x73, 0x00, 0x72, 0x65,
+    0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x72,
+    0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74,
+    0x69, 0x65, 0x73, 0x00, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+    0x73, 0x00, 0x72, 0x65, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x65, 0x72,
+    0x73, 0x00, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76, 0x65, 0x73, 0x00,
+    0x72, 0x65, 0x66, 0x75, 0x67, 0x65, 0x65, 0x73, 0x00, 0x72, 0x65, 0x66,
+    0x6f, 0x72, 0x6d, 0x73, 0x00, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e,
+    0x63, 0x65, 0x73, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e,
+    0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x72, 0x65, 0x61, 0x63,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x71, 0x75, 0x61, 0x6e, 0x74, 0x69,
+    0x74, 0x69, 0x65, 0x73, 0x00, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x74, 0x69,
+    0x65, 0x73, 0x00, 0x71, 0x75, 0x61, 0x6c, 0x69, 0x66, 0x69, 0x63, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63,
+    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x66, 0x65,
+    0x73, 0x73, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x73, 0x00, 0x70, 0x72, 0x69,
+    0x6f, 0x72, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x70, 0x72, 0x65, 0x73,
+    0x73, 0x75, 0x72, 0x65, 0x73, 0x00, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69,
+    0x74, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x70, 0x6f, 0x73, 0x74,
+    0x73, 0x00, 0x70, 0x6f, 0x73, 0x73, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74,
+    0x69, 0x65, 0x73, 0x00, 0x70, 0x61, 0x73, 0x73, 0x65, 0x6e, 0x67, 0x65,
+    0x72, 0x73, 0x00, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61,
+    0x6e, 0x74, 0x73, 0x00, 0x70, 0x61, 0x69, 0x72, 0x73, 0x00, 0x6f, 0x72,
+    0x69, 0x67, 0x69, 0x6e, 0x73, 0x00, 0x6f, 0x66, 0x66, 0x65, 0x6e, 0x63,
+    0x65, 0x73, 0x00, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69,
+    0x6f, 0x6e, 0x73, 0x00, 0x6f, 0x62, 0x6c, 0x69, 0x67, 0x61, 0x74, 0x69,
+    0x6f, 0x6e, 0x73, 0x00, 0x6e, 0x75, 0x72, 0x73, 0x65, 0x73, 0x00, 0x6e,
+    0x69, 0x67, 0x68, 0x74, 0x73, 0x00, 0x6d, 0x75, 0x73, 0x63, 0x6c, 0x65,
+    0x73, 0x00, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x00,
+    0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x73, 0x00, 0x6d, 0x69, 0x6e, 0x64,
+    0x73, 0x00, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x6d,
+    0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x00, 0x6d, 0x65, 0x6d, 0x6f,
+    0x72, 0x69, 0x65, 0x73, 0x00, 0x6d, 0x65, 0x63, 0x68, 0x61, 0x6e, 0x69,
+    0x73, 0x6d, 0x73, 0x00, 0x6d, 0x65, 0x61, 0x6c, 0x73, 0x00, 0x6d, 0x61,
+    0x72, 0x6b, 0x73, 0x00, 0x6d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74,
+    0x75, 0x72, 0x65, 0x72, 0x73, 0x00, 0x6d, 0x61, 0x6c, 0x65, 0x73, 0x00,
+    0x6d, 0x61, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x73, 0x00,
+    0x6c, 0x6f, 0x61, 0x6e, 0x73, 0x00, 0x6c, 0x69, 0x73, 0x74, 0x73, 0x00,
+    0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x00, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x73,
+    0x00, 0x6c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x69, 0x65, 0x73, 0x00, 0x6c,
+    0x65, 0x73, 0x73, 0x6f, 0x6e, 0x73, 0x00, 0x6c, 0x61, 0x77, 0x79, 0x65,
+    0x72, 0x73, 0x00, 0x6c, 0x61, 0x64, 0x69, 0x65, 0x73, 0x00, 0x6b, 0x6e,
+    0x65, 0x65, 0x73, 0x00, 0x6b, 0x65, 0x79, 0x73, 0x00, 0x6a, 0x75, 0x64,
+    0x67, 0x65, 0x73, 0x00, 0x69, 0x73, 0x6c, 0x61, 0x6e, 0x64, 0x73, 0x00,
+    0x69, 0x6e, 0x76, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x69, 0x6e,
+    0x73, 0x74, 0x72, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x69, 0x6e,
+    0x6a, 0x75, 0x72, 0x69, 0x65, 0x73, 0x00, 0x69, 0x6e, 0x69, 0x74, 0x69,
+    0x61, 0x74, 0x69, 0x76, 0x65, 0x73, 0x00, 0x69, 0x6e, 0x63, 0x68, 0x65,
+    0x73, 0x00, 0x69, 0x6d, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x6d, 0x65, 0x6e,
+    0x74, 0x73, 0x00, 0x68, 0x75, 0x6d, 0x61, 0x6e, 0x73, 0x00, 0x68, 0x6f,
+    0x74, 0x65, 0x6c, 0x73, 0x00, 0x68, 0x6f, 0x73, 0x70, 0x69, 0x74, 0x61,
+    0x6c, 0x73, 0x00, 0x68, 0x6f, 0x70, 0x65, 0x73, 0x00, 0x68, 0x6f, 0x6c,
+    0x69, 0x64, 0x61, 0x79, 0x73, 0x00, 0x68, 0x6f, 0x6c, 0x65, 0x73, 0x00,
+    0x68, 0x69, 0x6c, 0x6c, 0x73, 0x00, 0x67, 0x75, 0x6e, 0x73, 0x00, 0x67,
+    0x75, 0x69, 0x64, 0x65, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x67, 0x6c,
+    0x61, 0x73, 0x73, 0x65, 0x73, 0x00, 0x67, 0x65, 0x72, 0x6d, 0x61, 0x6e,
+    0x73, 0x00, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x00, 0x67, 0x65, 0x6e, 0x65,
+    0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x67, 0x61, 0x72, 0x64,
+    0x65, 0x6e, 0x73, 0x00, 0x66, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x73, 0x00,
+    0x66, 0x6f, 0x6f, 0x64, 0x73, 0x00, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x00,
+    0x66, 0x65, 0x6d, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x66, 0x65, 0x65, 0x73,
+    0x00, 0x66, 0x65, 0x61, 0x72, 0x73, 0x00, 0x66, 0x61, 0x6e, 0x73, 0x00,
+    0x65, 0x78, 0x70, 0x65, 0x6e, 0x73, 0x65, 0x73, 0x00, 0x65, 0x73, 0x74,
+    0x61, 0x74, 0x65, 0x73, 0x00, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x00,
+    0x65, 0x6e, 0x64, 0x73, 0x00, 0x65, 0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x64, 0x72, 0x69, 0x76, 0x65, 0x72, 0x73, 0x00, 0x64, 0x72,
+    0x65, 0x61, 0x6d, 0x73, 0x00, 0x64, 0x72, 0x61, 0x77, 0x69, 0x6e, 0x67,
+    0x73, 0x00, 0x64, 0x6f, 0x75, 0x62, 0x74, 0x73, 0x00, 0x64, 0x69, 0x76,
+    0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x64, 0x69, 0x72, 0x65, 0x63,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65,
+    0x73, 0x00, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x73, 0x00, 0x64, 0x65,
+    0x6d, 0x6f, 0x63, 0x72, 0x61, 0x74, 0x73, 0x00, 0x64, 0x65, 0x63, 0x61,
+    0x64, 0x65, 0x73, 0x00, 0x64, 0x65, 0x61, 0x74, 0x68, 0x73, 0x00, 0x64,
+    0x61, 0x75, 0x67, 0x68, 0x74, 0x65, 0x72, 0x73, 0x00, 0x64, 0x61, 0x74,
+    0x65, 0x73, 0x00, 0x63, 0x75, 0x74, 0x73, 0x00, 0x63, 0x75, 0x73, 0x74,
+    0x6f, 0x6d, 0x73, 0x00, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x73, 0x00,
+    0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x73, 0x00, 0x63, 0x6f, 0x6e,
+    0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x63,
+    0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x00, 0x63, 0x6f, 0x6e,
+    0x73, 0x69, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74, 0x69, 0x76, 0x65,
+    0x73, 0x00, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x63, 0x6f, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72, 0x6e, 0x73, 0x00, 0x63,
+    0x6f, 0x6e, 0x63, 0x65, 0x70, 0x74, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x63,
+    0x65, 0x6e, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x63,
+    0x6f, 0x6d, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x00, 0x63, 0x6f,
+    0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x00, 0x63, 0x6f, 0x6c,
+    0x6c, 0x65, 0x67, 0x65, 0x73, 0x00, 0x63, 0x68, 0x65, 0x6d, 0x69, 0x63,
+    0x61, 0x6c, 0x73, 0x00, 0x63, 0x68, 0x61, 0x70, 0x74, 0x65, 0x72, 0x73,
+    0x00, 0x63, 0x61, 0x75, 0x73, 0x65, 0x73, 0x00, 0x63, 0x61, 0x74, 0x74,
+    0x6c, 0x65, 0x00, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x00, 0x62, 0x6f, 0x78,
+    0x65, 0x73, 0x00, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x61, 0x72, 0x69, 0x65,
+    0x73, 0x00, 0x62, 0x6f, 0x6f, 0x74, 0x73, 0x00, 0x62, 0x6f, 0x6e, 0x65,
+    0x73, 0x00, 0x62, 0x6f, 0x6e, 0x64, 0x73, 0x00, 0x62, 0x6f, 0x61, 0x74,
+    0x73, 0x00, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x73, 0x00, 0x62, 0x6c, 0x6f,
+    0x63, 0x6b, 0x73, 0x00, 0x62, 0x69, 0x74, 0x73, 0x00, 0x62, 0x69, 0x6c,
+    0x6c, 0x73, 0x00, 0x62, 0x65, 0x6c, 0x69, 0x65, 0x66, 0x73, 0x00, 0x62,
+    0x65, 0x64, 0x73, 0x00, 0x62, 0x61, 0x72, 0x73, 0x00, 0x62, 0x61, 0x6e,
+    0x64, 0x73, 0x00, 0x62, 0x61, 0x62, 0x69, 0x65, 0x73, 0x00, 0x61, 0x77,
+    0x61, 0x72, 0x64, 0x73, 0x00, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x73,
+    0x00, 0x61, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x73, 0x00, 0x61, 0x73, 0x73,
+    0x75, 0x6d, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x61, 0x73, 0x73,
+    0x6f, 0x63, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x61, 0x70,
+    0x70, 0x72, 0x6f, 0x61, 0x63, 0x68, 0x65, 0x73, 0x00, 0x61, 0x6e, 0x73,
+    0x77, 0x65, 0x72, 0x73, 0x00, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73,
+    0x00, 0x61, 0x6d, 0x65, 0x72, 0x69, 0x63, 0x61, 0x6e, 0x73, 0x00, 0x61,
+    0x69, 0x6d, 0x73, 0x00, 0x61, 0x67, 0x72, 0x65, 0x65, 0x6d, 0x65, 0x6e,
+    0x74, 0x73, 0x00, 0x61, 0x63, 0x74, 0x73, 0x00, 0x61, 0x63, 0x63, 0x69,
+    0x64, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x79, 0x6f, 0x75, 0x6e, 0x67, 0x73,
+    0x74, 0x65, 0x72, 0x73, 0x00, 0x77, 0x72, 0x69, 0x74, 0x69, 0x6e, 0x67,
+    0x73, 0x00, 0x77, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x00, 0x77, 0x6f, 0x72,
+    0x6c, 0x64, 0x73, 0x00, 0x77, 0x6f, 0x72, 0x6b, 0x73, 0x68, 0x6f, 0x70,
+    0x73, 0x00, 0x77, 0x6f, 0x6f, 0x64, 0x73, 0x00, 0x77, 0x69, 0x74, 0x6e,
+    0x65, 0x73, 0x73, 0x65, 0x73, 0x00, 0x77, 0x69, 0x73, 0x68, 0x65, 0x73,
+    0x00, 0x77, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x77, 0x69, 0x6e, 0x64, 0x73,
+    0x00, 0x77, 0x68, 0x65, 0x65, 0x6c, 0x73, 0x00, 0x77, 0x65, 0x65, 0x6b,
+    0x65, 0x6e, 0x64, 0x73, 0x00, 0x77, 0x65, 0x61, 0x6b, 0x6e, 0x65, 0x73,
+    0x73, 0x65, 0x73, 0x00, 0x77, 0x61, 0x72, 0x73, 0x00, 0x76, 0x6f, 0x6c,
+    0x75, 0x6e, 0x74, 0x65, 0x65, 0x72, 0x73, 0x00, 0x76, 0x6f, 0x6c, 0x75,
+    0x6d, 0x65, 0x73, 0x00, 0x76, 0x69, 0x73, 0x69, 0x74, 0x73, 0x00, 0x76,
+    0x69, 0x64, 0x65, 0x6f, 0x73, 0x00, 0x76, 0x65, 0x73, 0x73, 0x65, 0x6c,
+    0x73, 0x00, 0x76, 0x65, 0x67, 0x65, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73,
+    0x00, 0x76, 0x61, 0x72, 0x69, 0x65, 0x74, 0x69, 0x65, 0x73, 0x00, 0x75,
+    0x73, 0x65, 0x73, 0x00, 0x74, 0x77, 0x69, 0x6e, 0x73, 0x00, 0x74, 0x72,
+    0x75, 0x73, 0x74, 0x73, 0x00, 0x74, 0x72, 0x75, 0x73, 0x74, 0x65, 0x65,
+    0x73, 0x00, 0x74, 0x72, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x73, 0x00, 0x74,
+    0x72, 0x61, 0x76, 0x65, 0x6c, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x74, 0x72,
+    0x61, 0x69, 0x6e, 0x73, 0x00, 0x74, 0x72, 0x61, 0x64, 0x69, 0x74, 0x69,
+    0x6f, 0x6e, 0x73, 0x00, 0x74, 0x72, 0x61, 0x64, 0x65, 0x73, 0x00, 0x74,
+    0x72, 0x61, 0x64, 0x65, 0x72, 0x73, 0x00, 0x74, 0x72, 0x61, 0x63, 0x6b,
+    0x73, 0x00, 0x74, 0x6f, 0x79, 0x73, 0x00, 0x74, 0x6f, 0x75, 0x72, 0x69,
+    0x73, 0x74, 0x73, 0x00, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x00, 0x74,
+    0x6f, 0x6e, 0x73, 0x00, 0x74, 0x69, 0x6c, 0x65, 0x73, 0x00, 0x74, 0x69,
+    0x65, 0x73, 0x00, 0x74, 0x68, 0x72, 0x65, 0x61, 0x74, 0x73, 0x00, 0x74,
+    0x68, 0x65, 0x6d, 0x65, 0x73, 0x00, 0x74, 0x65, 0x72, 0x72, 0x69, 0x74,
+    0x6f, 0x72, 0x69, 0x65, 0x73, 0x00, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+    0x6e, 0x73, 0x00, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x73, 0x00, 0x74,
+    0x65, 0x6d, 0x70, 0x65, 0x72, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x00,
+    0x74, 0x65, 0x6c, 0x65, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63,
+    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x74, 0x65, 0x63, 0x68, 0x6e,
+    0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x65, 0x73, 0x00, 0x74, 0x61, 0x72, 0x67,
+    0x65, 0x74, 0x73, 0x00, 0x74, 0x61, 0x6e, 0x6b, 0x73, 0x00, 0x74, 0x61,
+    0x6c, 0x65, 0x73, 0x00, 0x74, 0x61, 0x63, 0x74, 0x69, 0x63, 0x73, 0x00,
+    0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x73, 0x00, 0x73, 0x75, 0x72, 0x76,
+    0x65, 0x79, 0x73, 0x00, 0x73, 0x75, 0x72, 0x72, 0x6f, 0x75, 0x6e, 0x64,
+    0x69, 0x6e, 0x67, 0x73, 0x00, 0x73, 0x75, 0x72, 0x66, 0x61, 0x63, 0x65,
+    0x73, 0x00, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x73, 0x00, 0x73,
+    0x75, 0x70, 0x70, 0x6c, 0x69, 0x65, 0x72, 0x73, 0x00, 0x73, 0x75, 0x6d,
+    0x73, 0x00, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x65, 0x73, 0x00,
+    0x73, 0x75, 0x62, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x73,
+    0x75, 0x62, 0x73, 0x69, 0x64, 0x69, 0x65, 0x73, 0x00, 0x73, 0x74, 0x72,
+    0x69, 0x6e, 0x67, 0x73, 0x00, 0x73, 0x74, 0x72, 0x65, 0x6e, 0x67, 0x74,
+    0x68, 0x73, 0x00, 0x73, 0x74, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x73,
+    0x00, 0x73, 0x74, 0x6f, 0x63, 0x6b, 0x73, 0x00, 0x73, 0x74, 0x61, 0x6e,
+    0x64, 0x73, 0x00, 0x73, 0x70, 0x6f, 0x74, 0x73, 0x00, 0x73, 0x70, 0x65,
+    0x65, 0x63, 0x68, 0x65, 0x73, 0x00, 0x73, 0x70, 0x65, 0x63, 0x69, 0x6d,
+    0x65, 0x6e, 0x73, 0x00, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x69,
+    0x73, 0x74, 0x73, 0x00, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x00, 0x73,
+    0x69, 0x7a, 0x65, 0x73, 0x00, 0x73, 0x69, 0x73, 0x74, 0x65, 0x72, 0x73,
+    0x00, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x73, 0x00, 0x73, 0x68, 0x6f,
+    0x74, 0x73, 0x00, 0x73, 0x68, 0x65, 0x6c, 0x76, 0x65, 0x73, 0x00, 0x73,
+    0x68, 0x61, 0x70, 0x65, 0x73, 0x00, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77,
+    0x73, 0x00, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
+    0x73, 0x00, 0x73, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x73,
+    0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x73, 0x65, 0x6e,
+    0x73, 0x65, 0x73, 0x00, 0x73, 0x65, 0x65, 0x64, 0x73, 0x00, 0x73, 0x65,
+    0x63, 0x72, 0x65, 0x74, 0x73, 0x00, 0x73, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x73, 0x00, 0x73, 0x63, 0x6f, 0x74, 0x73, 0x00, 0x73, 0x63, 0x6f, 0x72,
+    0x65, 0x73, 0x00, 0x73, 0x63, 0x68, 0x6f, 0x6c, 0x61, 0x72, 0x73, 0x00,
+    0x73, 0x63, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x73, 0x61, 0x6e, 0x63, 0x74,
+    0x69, 0x6f, 0x6e, 0x73, 0x00, 0x72, 0x75, 0x73, 0x73, 0x69, 0x61, 0x6e,
+    0x73, 0x00, 0x72, 0x75, 0x6e, 0x73, 0x00, 0x72, 0x75, 0x6d, 0x6f, 0x75,
+    0x72, 0x73, 0x00, 0x72, 0x6f, 0x77, 0x73, 0x00, 0x72, 0x6f, 0x75, 0x74,
+    0x65, 0x73, 0x00, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x00, 0x72, 0x6f,
+    0x73, 0x65, 0x73, 0x00, 0x72, 0x69, 0x76, 0x61, 0x6c, 0x73, 0x00, 0x72,
+    0x69, 0x73, 0x65, 0x73, 0x00, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x73,
+    0x00, 0x72, 0x65, 0x76, 0x65, 0x6e, 0x75, 0x65, 0x73, 0x00, 0x72, 0x65,
+    0x73, 0x74, 0x61, 0x75, 0x72, 0x61, 0x6e, 0x74, 0x73, 0x00, 0x72, 0x65,
+    0x73, 0x70, 0x6f, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x72, 0x65,
+    0x73, 0x70, 0x65, 0x63, 0x74, 0x73, 0x00, 0x72, 0x65, 0x73, 0x65, 0x72,
+    0x76, 0x65, 0x73, 0x00, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x61, 0x74,
+    0x69, 0x6f, 0x6e, 0x73, 0x00, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+    0x73, 0x00, 0x72, 0x65, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x73, 0x00,
+    0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69,
+    0x6f, 0x6e, 0x73, 0x00, 0x72, 0x65, 0x6d, 0x61, 0x72, 0x6b, 0x73, 0x00,
+    0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x00, 0x72, 0x65, 0x64, 0x75,
+    0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x72,
+    0x64, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x72, 0x65, 0x62, 0x65, 0x6c, 0x73,
+    0x00, 0x72, 0x61, 0x74, 0x73, 0x00, 0x72, 0x61, 0x6e, 0x6b, 0x73, 0x00,
+    0x72, 0x61, 0x69, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x00, 0x72, 0x61, 0x63,
+    0x65, 0x73, 0x00, 0x71, 0x75, 0x61, 0x72, 0x74, 0x65, 0x72, 0x73, 0x00,
+    0x70, 0x75, 0x62, 0x73, 0x00, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
+    0x65, 0x72, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x6e, 0x63, 0x65,
+    0x73, 0x00, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x73, 0x74, 0x73, 0x00, 0x70,
+    0x72, 0x6f, 0x74, 0x65, 0x69, 0x6e, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x73,
+    0x70, 0x65, 0x63, 0x74, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x72,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,
+    0x6d, 0x73, 0x00, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x72, 0x73,
+    0x00, 0x70, 0x72, 0x69, 0x7a, 0x65, 0x73, 0x00, 0x70, 0x72, 0x69, 0x76,
+    0x69, 0x6c, 0x65, 0x67, 0x65, 0x73, 0x00, 0x70, 0x72, 0x69, 0x73, 0x6f,
+    0x6e, 0x73, 0x00, 0x70, 0x72, 0x69, 0x65, 0x73, 0x74, 0x73, 0x00, 0x70,
+    0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x70, 0x72, 0x65, 0x70,
+    0x61, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x72, 0x65,
+    0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x70, 0x72, 0x61,
+    0x79, 0x65, 0x72, 0x73, 0x00, 0x70, 0x6f, 0x74, 0x61, 0x74, 0x6f, 0x65,
+    0x73, 0x00, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x00, 0x70, 0x6f, 0x70, 0x75,
+    0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x6f, 0x6f, 0x6c,
+    0x73, 0x00, 0x70, 0x6f, 0x6c, 0x6c, 0x73, 0x00, 0x70, 0x6f, 0x6c, 0x69,
+    0x63, 0x65, 0x6d, 0x65, 0x6e, 0x00, 0x70, 0x6f, 0x6c, 0x65, 0x73, 0x00,
+    0x70, 0x6f, 0x65, 0x74, 0x73, 0x00, 0x70, 0x6f, 0x65, 0x6d, 0x73, 0x00,
+    0x70, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x00, 0x70, 0x6c, 0x61, 0x74,
+    0x65, 0x73, 0x00, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x73, 0x00, 0x70, 0x69,
+    0x6c, 0x6f, 0x74, 0x73, 0x00, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x73,
+    0x00, 0x70, 0x68, 0x65, 0x6e, 0x6f, 0x6d, 0x65, 0x6e, 0x61, 0x00, 0x70,
+    0x68, 0x61, 0x73, 0x65, 0x73, 0x00, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72,
+    0x6d, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x70, 0x65, 0x72, 0x63, 0x65,
+    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x70, 0x65, 0x6f, 0x70, 0x6c,
+    0x65, 0x73, 0x00, 0x70, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x70, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x70,
+    0x65, 0x6e, 0x61, 0x6c, 0x74, 0x69, 0x65, 0x73, 0x00, 0x70, 0x65, 0x61,
+    0x73, 0x61, 0x6e, 0x74, 0x73, 0x00, 0x70, 0x61, 0x74, 0x68, 0x73, 0x00,
+    0x70, 0x61, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x00, 0x70, 0x61, 0x72,
+    0x74, 0x69, 0x63, 0x6c, 0x65, 0x73, 0x00, 0x70, 0x61, 0x72, 0x61, 0x6d,
+    0x65, 0x74, 0x65, 0x72, 0x73, 0x00, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x73,
+    0x00, 0x70, 0x61, 0x69, 0x6e, 0x73, 0x00, 0x70, 0x61, 0x63, 0x6b, 0x61,
+    0x67, 0x65, 0x73, 0x00, 0x6f, 0x75, 0x74, 0x63, 0x6f, 0x6d, 0x65, 0x73,
+    0x00, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x73, 0x00, 0x6f, 0x72, 0x67, 0x61,
+    0x6e, 0x69, 0x73, 0x6d, 0x73, 0x00, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69,
+    0x73, 0x65, 0x72, 0x73, 0x00, 0x6f, 0x70, 0x70, 0x6f, 0x6e, 0x65, 0x6e,
+    0x74, 0x73, 0x00, 0x6f, 0x70, 0x69, 0x6e, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x6f, 0x66,
+    0x66, 0x65, 0x72, 0x73, 0x00, 0x6f, 0x66, 0x66, 0x65, 0x6e, 0x64, 0x65,
+    0x72, 0x73, 0x00, 0x6f, 0x64, 0x64, 0x73, 0x00, 0x6f, 0x63, 0x63, 0x75,
+    0x70, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x6f, 0x62, 0x73, 0x65,
+    0x72, 0x76, 0x65, 0x72, 0x73, 0x00, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74,
+    0x69, 0x6f, 0x6e, 0x73, 0x00, 0x6e, 0x6f, 0x76, 0x65, 0x6c, 0x73, 0x00,
+    0x6e, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x6e, 0x65, 0x74, 0x77,
+    0x6f, 0x72, 0x6b, 0x73, 0x00, 0x6e, 0x65, 0x72, 0x76, 0x65, 0x73, 0x00,
+    0x6d, 0x75, 0x73, 0x69, 0x63, 0x69, 0x61, 0x6e, 0x73, 0x00, 0x6d, 0x75,
+    0x73, 0x65, 0x75, 0x6d, 0x73, 0x00, 0x6d, 0x6f, 0x76, 0x69, 0x65, 0x73,
+    0x00, 0x6d, 0x6f, 0x76, 0x65, 0x73, 0x00, 0x6d, 0x6f, 0x74, 0x69, 0x76,
+    0x65, 0x73, 0x00, 0x6d, 0x6f, 0x6c, 0x65, 0x63, 0x75, 0x6c, 0x65, 0x73,
+    0x00, 0x6d, 0x6f, 0x64, 0x65, 0x73, 0x00, 0x6d, 0x69, 0x73, 0x74, 0x61,
+    0x6b, 0x65, 0x73, 0x00, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6c, 0x65, 0x73,
+    0x00, 0x6d, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x6d, 0x69, 0x6e, 0x65, 0x72,
+    0x73, 0x00, 0x6d, 0x69, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x73, 0x00, 0x6d,
+    0x69, 0x63, 0x65, 0x00, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x73, 0x00, 0x6d,
+    0x65, 0x72, 0x63, 0x68, 0x61, 0x6e, 0x74, 0x73, 0x00, 0x6d, 0x65, 0x61,
+    0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x6d, 0x65,
+    0x61, 0x6e, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x6d, 0x61, 0x74, 0x63, 0x68,
+    0x65, 0x73, 0x00, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x73, 0x00, 0x6d,
+    0x61, 0x73, 0x73, 0x65, 0x73, 0x00, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e,
+    0x73, 0x00, 0x6d, 0x61, 0x70, 0x73, 0x00, 0x6d, 0x61, 0x6d, 0x6d, 0x61,
+    0x6c, 0x73, 0x00, 0x6d, 0x61, 0x6b, 0x65, 0x72, 0x73, 0x00, 0x6d, 0x61,
+    0x67, 0x61, 0x7a, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x6c, 0x6f, 0x76, 0x65,
+    0x72, 0x73, 0x00, 0x6c, 0x6f, 0x6f, 0x6b, 0x73, 0x00, 0x6c, 0x6f, 0x63,
+    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x6c, 0x69, 0x6d, 0x69, 0x74,
+    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x6c, 0x69, 0x61, 0x62, 0x69,
+    0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x6c, 0x65, 0x6e, 0x67, 0x74,
+    0x68, 0x73, 0x00, 0x6c, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x00,
+    0x6c, 0x65, 0x61, 0x64, 0x73, 0x00, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x73,
+    0x00, 0x6c, 0x61, 0x6e, 0x64, 0x73, 0x00, 0x6c, 0x61, 0x6b, 0x65, 0x73,
+    0x00, 0x6c, 0x61, 0x64, 0x73, 0x00, 0x6c, 0x61, 0x62, 0x6f, 0x72, 0x61,
+    0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x00, 0x6b, 0x69, 0x6e, 0x67, 0x73,
+    0x00, 0x6b, 0x69, 0x6c, 0x6f, 0x6d, 0x65, 0x74, 0x72, 0x65, 0x73, 0x00,
+    0x6a, 0x6f, 0x75, 0x72, 0x6e, 0x61, 0x6c, 0x73, 0x00, 0x6a, 0x6f, 0x75,
+    0x72, 0x6e, 0x61, 0x6c, 0x69, 0x73, 0x74, 0x73, 0x00, 0x6a, 0x65, 0x77,
+    0x73, 0x00, 0x6a, 0x65, 0x61, 0x6e, 0x73, 0x00, 0x69, 0x6e, 0x76, 0x65,
+    0x73, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x69, 0x6e, 0x76, 0x65,
+    0x73, 0x74, 0x69, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x69,
+    0x6e, 0x74, 0x65, 0x72, 0x76, 0x69, 0x65, 0x77, 0x73, 0x00, 0x69, 0x6e,
+    0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x73, 0x00, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x70, 0x72, 0x65, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x69, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x69, 0x6e,
+    0x73, 0x65, 0x63, 0x74, 0x73, 0x00, 0x69, 0x6e, 0x68, 0x61, 0x62, 0x69,
+    0x74, 0x61, 0x6e, 0x74, 0x73, 0x00, 0x69, 0x6e, 0x67, 0x72, 0x65, 0x64,
+    0x69, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x69, 0x6e, 0x66, 0x6c, 0x75, 0x65,
+    0x6e, 0x63, 0x65, 0x73, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74,
+    0x6f, 0x72, 0x73, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x73, 0x00,
+    0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x73, 0x00, 0x69, 0x6e,
+    0x63, 0x6f, 0x6d, 0x65, 0x73, 0x00, 0x69, 0x6e, 0x63, 0x69, 0x64, 0x65,
+    0x6e, 0x74, 0x73, 0x00, 0x69, 0x6e, 0x63, 0x65, 0x6e, 0x74, 0x69, 0x76,
+    0x65, 0x73, 0x00, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x00, 0x69,
+    0x6c, 0x6c, 0x75, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x68, 0x75, 0x73, 0x62, 0x61, 0x6e, 0x64, 0x73, 0x00, 0x68, 0x6f,
+    0x75, 0x73, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x73, 0x00, 0x68, 0x6f, 0x6e,
+    0x6f, 0x75, 0x72, 0x73, 0x00, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x73,
+    0x00, 0x68, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x61, 0x6e, 0x73, 0x00,
+    0x68, 0x65, 0x72, 0x6f, 0x65, 0x73, 0x00, 0x68, 0x65, 0x65, 0x6c, 0x73,
+    0x00, 0x68, 0x65, 0x61, 0x72, 0x74, 0x73, 0x00, 0x68, 0x61, 0x62, 0x69,
+    0x74, 0x73, 0x00, 0x67, 0x75, 0x61, 0x72, 0x64, 0x73, 0x00, 0x67, 0x72,
+    0x61, 0x6e, 0x74, 0x73, 0x00, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x6f,
+    0x72, 0x73, 0x00, 0x67, 0x6f, 0x64, 0x73, 0x00, 0x67, 0x69, 0x66, 0x74,
+    0x73, 0x00, 0x67, 0x65, 0x6e, 0x74, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x00,
+    0x67, 0x61, 0x74, 0x65, 0x73, 0x00, 0x67, 0x61, 0x70, 0x73, 0x00, 0x67,
+    0x61, 0x6c, 0x6c, 0x65, 0x72, 0x69, 0x65, 0x73, 0x00, 0x67, 0x61, 0x69,
+    0x6e, 0x73, 0x00, 0x66, 0x75, 0x74, 0x75, 0x72, 0x65, 0x73, 0x00, 0x66,
+    0x72, 0x75, 0x69, 0x74, 0x73, 0x00, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73,
+    0x00, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x66,
+    0x6f, 0x75, 0x6e, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x66,
+    0x6f, 0x72, 0x74, 0x75, 0x6e, 0x65, 0x73, 0x00, 0x66, 0x6f, 0x72, 0x65,
+    0x69, 0x67, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x66, 0x6f, 0x6c, 0x6c, 0x6f,
+    0x77, 0x65, 0x72, 0x73, 0x00, 0x66, 0x6f, 0x6c, 0x6b, 0x00, 0x66, 0x6c,
+    0x6f, 0x6f, 0x72, 0x73, 0x00, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x73,
+    0x00, 0x66, 0x6c, 0x61, 0x74, 0x73, 0x00, 0x66, 0x6c, 0x61, 0x6d, 0x65,
+    0x73, 0x00, 0x66, 0x69, 0x72, 0x65, 0x73, 0x00, 0x66, 0x61, 0x74, 0x68,
+    0x65, 0x72, 0x73, 0x00, 0x66, 0x61, 0x72, 0x6d, 0x73, 0x00, 0x66, 0x61,
+    0x6c, 0x6c, 0x73, 0x00, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x73,
+    0x00, 0x66, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x00, 0x65,
+    0x79, 0x65, 0x62, 0x72, 0x6f, 0x77, 0x73, 0x00, 0x65, 0x78, 0x70, 0x72,
+    0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x65, 0x78, 0x70, 0x6f,
+    0x72, 0x74, 0x73, 0x00, 0x65, 0x78, 0x70, 0x6c, 0x61, 0x6e, 0x61, 0x74,
+    0x69, 0x6f, 0x6e, 0x73, 0x00, 0x65, 0x78, 0x68, 0x69, 0x62, 0x69, 0x74,
+    0x69, 0x6f, 0x6e, 0x73, 0x00, 0x65, 0x78, 0x65, 0x72, 0x63, 0x69, 0x73,
+    0x65, 0x73, 0x00, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x76, 0x65,
+    0x73, 0x00, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x00,
+    0x65, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x65,
+    0x78, 0x61, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x65, 0x76, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x65, 0x73, 0x74,
+    0x69, 0x6d, 0x61, 0x74, 0x65, 0x73, 0x00, 0x65, 0x71, 0x75, 0x61, 0x74,
+    0x69, 0x6f, 0x6e, 0x73, 0x00, 0x65, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e,
+    0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x65, 0x6e, 0x74, 0x72, 0x69, 0x65,
+    0x73, 0x00, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x69, 0x73, 0x65,
+    0x73, 0x00, 0x65, 0x6e, 0x71, 0x75, 0x69, 0x72, 0x69, 0x65, 0x73, 0x00,
+    0x65, 0x6e, 0x67, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x65, 0x6e, 0x67, 0x69,
+    0x6e, 0x65, 0x65, 0x72, 0x73, 0x00, 0x65, 0x6e, 0x65, 0x6d, 0x69, 0x65,
+    0x73, 0x00, 0x65, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x65, 0x64, 0x67, 0x65, 0x73, 0x00, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d,
+    0x69, 0x65, 0x73, 0x00, 0x64, 0x72, 0x69, 0x6e, 0x6b, 0x73, 0x00, 0x64,
+    0x6f, 0x6c, 0x6c, 0x61, 0x72, 0x73, 0x00, 0x64, 0x69, 0x73, 0x74, 0x72,
+    0x69, 0x63, 0x74, 0x73, 0x00, 0x64, 0x69, 0x73, 0x70, 0x75, 0x74, 0x65,
+    0x73, 0x00, 0x64, 0x69, 0x73, 0x68, 0x65, 0x73, 0x00, 0x64, 0x69, 0x73,
+    0x65, 0x61, 0x73, 0x65, 0x73, 0x00, 0x64, 0x69, 0x73, 0x63, 0x69, 0x70,
+    0x6c, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73,
+    0x69, 0x6f, 0x6e, 0x73, 0x00, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
+    0x65, 0x72, 0x73, 0x00, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x69, 0x76,
+    0x65, 0x73, 0x00, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x73,
+    0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x64, 0x65, 0x70, 0x75, 0x74, 0x69, 0x65, 0x73, 0x00, 0x64,
+    0x65, 0x70, 0x74, 0x68, 0x73, 0x00, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69,
+    0x74, 0x73, 0x00, 0x64, 0x65, 0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61,
+    0x74, 0x65, 0x73, 0x00, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69,
+    0x6f, 0x6e, 0x73, 0x00, 0x64, 0x65, 0x66, 0x65, 0x6e, 0x64, 0x61, 0x6e,
+    0x74, 0x73, 0x00, 0x64, 0x65, 0x66, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x00,
+    0x64, 0x65, 0x62, 0x74, 0x73, 0x00, 0x64, 0x65, 0x61, 0x6c, 0x73, 0x00,
+    0x64, 0x65, 0x61, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x64, 0x61, 0x74, 0x61,
+    0x62, 0x61, 0x73, 0x65, 0x73, 0x00, 0x64, 0x61, 0x6e, 0x67, 0x65, 0x72,
+    0x73, 0x00, 0x64, 0x61, 0x6d, 0x61, 0x67, 0x65, 0x73, 0x00, 0x63, 0x75,
+    0x72, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x00, 0x63, 0x75, 0x70, 0x73, 0x00,
+    0x63, 0x75, 0x6c, 0x74, 0x75, 0x72, 0x65, 0x73, 0x00, 0x63, 0x72, 0x6f,
+    0x77, 0x64, 0x73, 0x00, 0x63, 0x72, 0x6f, 0x70, 0x73, 0x00, 0x63, 0x72,
+    0x69, 0x74, 0x69, 0x63, 0x69, 0x73, 0x6d, 0x73, 0x00, 0x63, 0x72, 0x69,
+    0x6d, 0x65, 0x73, 0x00, 0x63, 0x72, 0x65, 0x77, 0x73, 0x00, 0x63, 0x72,
+    0x65, 0x64, 0x69, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x63, 0x72, 0x65, 0x61,
+    0x74, 0x75, 0x72, 0x65, 0x73, 0x00, 0x63, 0x6f, 0x75, 0x70, 0x6c, 0x65,
+    0x73, 0x00, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x65, 0x73, 0x00, 0x63,
+    0x6f, 0x75, 0x6e, 0x63, 0x69, 0x6c, 0x6c, 0x6f, 0x72, 0x73, 0x00, 0x63,
+    0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x63, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x76,
+    0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x74,
+    0x65, 0x78, 0x74, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74,
+    0x73, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6c, 0x74, 0x61, 0x6e, 0x74,
+    0x73, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74,
+    0x73, 0x00, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x73, 0x00,
+    0x63, 0x6f, 0x6e, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x00,
+    0x63, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00,
+    0x63, 0x6f, 0x6d, 0x70, 0x65, 0x74, 0x69, 0x74, 0x6f, 0x72, 0x73, 0x00,
+    0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x73, 0x00,
+    0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x73, 0x74, 0x73, 0x00, 0x63,
+    0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x63,
+    0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x00,
+    0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x00, 0x63, 0x6f, 0x6c,
+    0x6f, 0x6e, 0x69, 0x65, 0x73, 0x00, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63,
+    0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0x00,
+    0x63, 0x6c, 0x6f, 0x75, 0x64, 0x73, 0x00, 0x63, 0x6c, 0x65, 0x72, 0x67,
+    0x79, 0x00, 0x63, 0x69, 0x72, 0x63, 0x6c, 0x65, 0x73, 0x00, 0x63, 0x69,
+    0x67, 0x61, 0x72, 0x65, 0x74, 0x74, 0x65, 0x73, 0x00, 0x63, 0x68, 0x72,
+    0x69, 0x73, 0x74, 0x69, 0x61, 0x6e, 0x73, 0x00, 0x63, 0x68, 0x6f, 0x69,
+    0x63, 0x65, 0x73, 0x00, 0x63, 0x68, 0x69, 0x70, 0x73, 0x00, 0x63, 0x68,
+    0x69, 0x65, 0x66, 0x73, 0x00, 0x63, 0x68, 0x65, 0x65, 0x6b, 0x73, 0x00,
+    0x63, 0x68, 0x61, 0x72, 0x74, 0x73, 0x00, 0x63, 0x68, 0x61, 0x6e, 0x6e,
+    0x65, 0x6c, 0x73, 0x00, 0x63, 0x68, 0x61, 0x6d, 0x70, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x63, 0x68, 0x61, 0x6d, 0x70, 0x69, 0x6f, 0x6e, 0x73, 0x68,
+    0x69, 0x70, 0x73, 0x00, 0x63, 0x68, 0x61, 0x69, 0x72, 0x73, 0x00, 0x63,
+    0x68, 0x61, 0x69, 0x6e, 0x73, 0x00, 0x63, 0x61, 0x74, 0x73, 0x00, 0x63,
+    0x61, 0x73, 0x75, 0x61, 0x6c, 0x74, 0x69, 0x65, 0x73, 0x00, 0x63, 0x61,
+    0x72, 0x65, 0x72, 0x73, 0x00, 0x63, 0x61, 0x72, 0x65, 0x65, 0x72, 0x73,
+    0x00, 0x63, 0x61, 0x6d, 0x70, 0x73, 0x00, 0x63, 0x61, 0x6d, 0x70, 0x61,
+    0x69, 0x67, 0x6e, 0x73, 0x00, 0x63, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x73,
+    0x00, 0x63, 0x61, 0x6c, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x62, 0x75, 0x79, 0x65, 0x72, 0x73, 0x00, 0x62, 0x75, 0x73,
+    0x69, 0x6e, 0x65, 0x73, 0x73, 0x6d, 0x65, 0x6e, 0x00, 0x62, 0x75, 0x73,
+    0x65, 0x73, 0x00, 0x62, 0x75, 0x64, 0x67, 0x65, 0x74, 0x73, 0x00, 0x62,
+    0x72, 0x65, 0x61, 0x73, 0x74, 0x73, 0x00, 0x62, 0x6f, 0x74, 0x74, 0x6c,
+    0x65, 0x73, 0x00, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x00, 0x62,
+    0x6f, 0x6d, 0x62, 0x73, 0x00, 0x62, 0x6c, 0x75, 0x65, 0x73, 0x00, 0x62,
+    0x6c, 0x61, 0x63, 0x6b, 0x73, 0x00, 0x62, 0x69, 0x73, 0x68, 0x6f, 0x70,
+    0x73, 0x00, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x62, 0x65, 0x64,
+    0x72, 0x6f, 0x6f, 0x6d, 0x73, 0x00, 0x62, 0x65, 0x61, 0x6e, 0x73, 0x00,
+    0x62, 0x65, 0x61, 0x63, 0x68, 0x65, 0x73, 0x00, 0x62, 0x61, 0x73, 0x65,
+    0x73, 0x00, 0x62, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x73, 0x00, 0x62,
+    0x61, 0x6c, 0x6c, 0x73, 0x00, 0x62, 0x61, 0x67, 0x73, 0x00, 0x62, 0x61,
+    0x63, 0x74, 0x65, 0x72, 0x69, 0x61, 0x00, 0x62, 0x61, 0x63, 0x6b, 0x73,
+    0x00, 0x61, 0x75, 0x64, 0x69, 0x74, 0x6f, 0x72, 0x73, 0x00, 0x61, 0x75,
+    0x64, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x61, 0x73, 0x73, 0x65,
+    0x73, 0x73, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x61, 0x73, 0x70, 0x69,
+    0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x61, 0x72, 0x6d, 0x69,
+    0x65, 0x73, 0x00, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74,
+    0x73, 0x00, 0x61, 0x70, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x6d, 0x65, 0x6e,
+    0x74, 0x73, 0x00, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x6e, 0x74,
+    0x73, 0x00, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x61, 0x6e, 0x63, 0x65,
+    0x73, 0x00, 0x61, 0x70, 0x70, 0x65, 0x61, 0x6c, 0x73, 0x00, 0x61, 0x6e,
+    0x67, 0x6c, 0x65, 0x73, 0x00, 0x61, 0x6d, 0x62, 0x69, 0x74, 0x69, 0x6f,
+    0x6e, 0x73, 0x00, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69,
+    0x76, 0x65, 0x73, 0x00, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x61, 0x6e, 0x63,
+    0x65, 0x73, 0x00, 0x61, 0x6c, 0x6c, 0x69, 0x65, 0x73, 0x00, 0x61, 0x6c,
+    0x6c, 0x65, 0x67, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x61, 0x64,
+    0x76, 0x69, 0x73, 0x65, 0x72, 0x73, 0x00, 0x61, 0x64, 0x76, 0x65, 0x72,
+    0x74, 0x69, 0x73, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x00, 0x61, 0x64,
+    0x76, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x61, 0x64, 0x64, 0x72, 0x65,
+    0x73, 0x73, 0x65, 0x73, 0x00, 0x61, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x00,
+    0x61, 0x63, 0x72, 0x65, 0x73, 0x00, 0x61, 0x63, 0x69, 0x64, 0x73, 0x00,
+    0x61, 0x63, 0x68, 0x69, 0x65, 0x76, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73,
+    0x00, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x6e, 0x74, 0x73,
+    0x00, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x02, 0x96, 0x72, 0x00, 0x01, 0x4a, 0x37, 0x00,
+    0x01, 0x2c, 0x59, 0x00, 0x00, 0xec, 0xba, 0x00, 0x00, 0xe6, 0x96, 0x00,
+    0x00, 0xbf, 0xab, 0x00, 0x00, 0xaa, 0x25, 0x00, 0x00, 0x98, 0xaf, 0x00,
+    0x00, 0x3b, 0x87, 0x00, 0x00, 0x2d, 0x4a, 0x00, 0x00, 0x29, 0x3c, 0x00,
+    0x00, 0x22, 0x52, 0x00, 0x00, 0x21, 0xff, 0x00, 0x00, 0x1a, 0x6a, 0x00,
+    0x00, 0x17, 0x09, 0x00, 0x00, 0x14, 0xea, 0x00, 0x00, 0x14, 0xc7, 0x00,
+    0x00, 0x13, 0xa0, 0x00, 0x00, 0x11, 0x29, 0x00, 0x00, 0x10, 0xff, 0x00,
+    0x00, 0x10, 0x99, 0x00, 0x00, 0x10, 0x93, 0x00, 0x00, 0x0e, 0x4e, 0x00,
+    0x00, 0x0c, 0x59, 0x00, 0x00, 0x0a, 0xac, 0x00, 0x00, 0x09, 0x8d, 0x00,
+    0x00, 0x08, 0xd9, 0x00, 0x00, 0x08, 0xd3, 0x00, 0x00, 0x08, 0xd1, 0x00,
+    0x00, 0x08, 0xbc, 0x00, 0x00, 0x07, 0xe7, 0x00, 0x00, 0x07, 0x9d, 0x00,
+    0x00, 0x07, 0x1b, 0x00, 0x00, 0x06, 0x94, 0x00, 0x00, 0x06, 0x72, 0x00,
+    0x00, 0x06, 0x63, 0x00, 0x00, 0x05, 0xfe, 0x00, 0x00, 0x05, 0x9c, 0x00,
+    0x00, 0x05, 0x58, 0x00, 0x00, 0x05, 0x19, 0x00, 0x00, 0x04, 0xfb, 0x00,
+    0x00, 0x04, 0xdd, 0x00, 0x00, 0x04, 0xdc, 0x00, 0x00, 0x04, 0x6c, 0x00,
+    0x00, 0x04, 0x48, 0x00, 0x00, 0x04, 0x2a, 0x00, 0x00, 0x04, 0x0c, 0x00,
+    0x00, 0x03, 0x7f, 0x00, 0x00, 0x03, 0x58, 0x00, 0x00, 0x03, 0x58, 0x00,
+    0x00, 0x03, 0x31, 0x00, 0x00, 0x03, 0x13, 0x00, 0x00, 0x03, 0x0d, 0x00,
+    0x00, 0x02, 0xe2, 0x00, 0x00, 0x02, 0x95, 0x00, 0x00, 0x02, 0x6b, 0x00,
+    0x00, 0x02, 0x50, 0x00, 0x00, 0x02, 0x4d, 0x00, 0x00, 0x02, 0x39, 0x00,
+    0x00, 0x02, 0x33, 0x00, 0x00, 0x02, 0x25, 0x00, 0x00, 0x02, 0x0a, 0x00,
+    0x00, 0x01, 0xf1, 0x00, 0x00, 0x01, 0xe8, 0x00, 0x00, 0x01, 0xdb, 0x00,
+    0x00, 0x01, 0xd8, 0x00, 0x00, 0x01, 0xc8, 0x00, 0x00, 0x01, 0xac, 0x00,
+    0x00, 0x01, 0xa7, 0x00, 0x00, 0x01, 0x91, 0x00, 0x00, 0x01, 0x4b, 0x00,
+    0x00, 0x01, 0x47, 0x00, 0x00, 0x01, 0x35, 0x00, 0x00, 0x01, 0x32, 0x00,
+    0x00, 0x01, 0x31, 0x00, 0x00, 0x01, 0x28, 0x00, 0x00, 0x01, 0x26, 0x00,
+    0x00, 0x01, 0x13, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x01, 0x0a, 0x00,
+    0x00, 0x01, 0x09, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0xf6, 0x00,
+    0x00, 0x00, 0xf5, 0x00, 0x00, 0x00, 0xdf, 0x00, 0x00, 0x00, 0xdb, 0x00,
+    0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0xc3, 0x00, 0x00, 0x00, 0xc3, 0x00,
+    0x00, 0x00, 0xbe, 0x00, 0x00, 0x00, 0xaa, 0x00, 0x00, 0x00, 0xaa, 0x00,
+    0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x97, 0x00,
+    0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x94, 0x00,
+    0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x8f, 0x00,
+    0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x80, 0x00,
+    0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x75, 0x00,
+    0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x6e, 0x00,
+    0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x64, 0x00,
+    0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x5c, 0x00,
+    0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x51, 0x00,
+    0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x4d, 0x00,
+    0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x4c, 0x00,
+    0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x45, 0x00,
+    0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x40, 0x00,
+    0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x36, 0x00,
+    0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x35, 0x00,
+    0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x30, 0x00,
+    0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x2b, 0x00,
+    0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x28, 0x00,
+    0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x26, 0x00,
+    0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00,
+    0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00,
+    0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x28, 0x00,
+    0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x38, 0x00,
+    0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x4e, 0x00,
+    0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x60, 0x00,
+    0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00, 0x76, 0x00,
+    0x00, 0x00, 0x7d, 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x8d, 0x00,
+    0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0xa0, 0x00,
+    0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0xb2, 0x00,
+    0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00, 0x00, 0xc9, 0x00,
+    0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0xdb, 0x00, 0x00, 0x00, 0xe8, 0x00,
+    0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xf6, 0x00, 0x00, 0x00, 0xfb, 0x00,
+    0x00, 0x00, 0xff, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x01, 0x0a, 0x00,
+    0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x1f, 0x00, 0x00, 0x01, 0x27, 0x00,
+    0x00, 0x01, 0x2e, 0x00, 0x00, 0x01, 0x34, 0x00, 0x00, 0x01, 0x40, 0x00,
+    0x00, 0x01, 0x47, 0x00, 0x00, 0x01, 0x4d, 0x00, 0x00, 0x01, 0x53, 0x00,
+    0x00, 0x01, 0x59, 0x00, 0x00, 0x01, 0x5f, 0x00, 0x00, 0x01, 0x66, 0x00,
+    0x00, 0x01, 0x6b, 0x00, 0x00, 0x01, 0x76, 0x00, 0x00, 0x01, 0x82, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x97, 0x00, 0x00, 0x01, 0x9d, 0x00,
+    0x00, 0x01, 0xa2, 0x00, 0x00, 0x01, 0xad, 0x00, 0x00, 0x01, 0xb5, 0x00,
+    0x00, 0x01, 0xc0, 0x00, 0x00, 0x01, 0xc5, 0x00, 0x00, 0x01, 0xc9, 0x00,
+    0x00, 0x01, 0xd8, 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x01, 0xeb, 0x00,
+    0x00, 0x01, 0xfa, 0x00, 0x00, 0x02, 0x07, 0x00, 0x00, 0x02, 0x0e, 0x00,
+    0x00, 0x02, 0x13, 0x00, 0x00, 0x02, 0x1e, 0x00, 0x00, 0x02, 0x27, 0x00,
+    0x00, 0x02, 0x2f, 0x00, 0x00, 0x02, 0x3b, 0x00, 0x00, 0x02, 0x49, 0x00,
+    0x00, 0x02, 0x53, 0x00, 0x00, 0x02, 0x5b, 0x00, 0x00, 0x02, 0x62, 0x00,
+    0x00, 0x02, 0x6b, 0x00, 0x00, 0x02, 0x78, 0x00, 0x00, 0x02, 0x82, 0x00,
+    0x00, 0x02, 0x8c, 0x00, 0x00, 0x02, 0x99, 0x00, 0x00, 0x02, 0xa8, 0x00,
+    0x00, 0x02, 0xbb, 0x00, 0x00, 0x02, 0xc6, 0x00, 0x00, 0x02, 0xd6, 0x00,
+    0x00, 0x02, 0xdd, 0x00, 0x00, 0x02, 0xe8, 0x00, 0x00, 0x02, 0xf5, 0x00,
+    0x00, 0x03, 0x04, 0x00, 0x00, 0x03, 0x17, 0x00, 0x00, 0x03, 0x23, 0x00,
+    0x00, 0x03, 0x32, 0x00, 0x00, 0x03, 0x36, 0x00, 0x00, 0x03, 0x41, 0x00,
+    0x00, 0x03, 0x4f, 0x00, 0x00, 0x03, 0x59, 0x00, 0x00, 0x03, 0x69, 0x00,
+    0x00, 0x03, 0x75, 0x00, 0x00, 0x03, 0x7c, 0x00, 0x00, 0x03, 0x90, 0x00,
+    0x00, 0x03, 0x9d, 0x00, 0x00, 0x03, 0xa2, 0x00, 0x00, 0x03, 0xac, 0x00,
+    0x00, 0x03, 0xba, 0x00, 0x00, 0x03, 0xbf, 0x00, 0x00, 0x03, 0xcd, 0x00,
+    0x00, 0x03, 0xda, 0x00, 0x00, 0x03, 0xe6, 0x00, 0x00, 0x03, 0xf4, 0x00,
+    0x00, 0x03, 0xfb, 0x00, 0x00, 0x04, 0x05, 0x00, 0x00, 0x04, 0x15, 0x00,
+    0x00, 0x04, 0x1d, 0x00, 0x00, 0x04, 0x2c, 0x00, 0x00, 0x04, 0x38, 0x00,
+    0x00, 0x04, 0x41, 0x00, 0x00, 0x04, 0x49, 0x00, 0x00, 0x04, 0x56, 0x00,
+    0x00, 0x04, 0x62, 0x00, 0x00, 0x04, 0x6d, 0x00, 0x00, 0x04, 0x7c, 0x00,
+    0x00, 0x04, 0x82, 0x00, 0x00, 0x04, 0x8d, 0x00, 0x00, 0x04, 0x98, 0x00,
+    0x00, 0x04, 0xa2, 0x00, 0x00, 0x04, 0xab, 0x00, 0x00, 0x04, 0xb6, 0x00,
+    0x00, 0x04, 0xbd, 0x00, 0x00, 0x04, 0xc5, 0x00, 0x00, 0x04, 0xce, 0x00,
+    0x00, 0x04, 0xde, 0x00, 0x00, 0x04, 0xea, 0x00, 0x00, 0x04, 0xf8, 0x00,
+    0x00, 0x04, 0xff, 0x00, 0x00, 0x05, 0x0f, 0x00, 0x00, 0x05, 0x18, 0x00,
+    0x00, 0x05, 0x2b, 0x00, 0x00, 0x05, 0x37, 0x00, 0x00, 0x05, 0x42, 0x00,
+    0x00, 0x05, 0x48, 0x00, 0x00, 0x05, 0x58, 0x00, 0x00, 0x05, 0x6c, 0x00,
+    0x00, 0x05, 0x76, 0x00, 0x00, 0x05, 0x7b, 0x00, 0x00, 0x05, 0x8d, 0x00,
+    0x00, 0x05, 0x99, 0x00, 0x00, 0x05, 0xa3, 0x00, 0x00, 0x05, 0xb1, 0x00,
+    0x00, 0x05, 0xc2, 0x00, 0x00, 0x05, 0xcd, 0x00, 0x00, 0x05, 0xda, 0x00,
+    0x00, 0x05, 0xe5, 0x00, 0x00, 0x05, 0xf0, 0x00, 0x00, 0x05, 0xfd, 0x00,
+    0x00, 0x06, 0x07, 0x00, 0x00, 0x06, 0x14, 0x00, 0x00, 0x06, 0x25, 0x00,
+    0x00, 0x06, 0x2d, 0x00, 0x00, 0x06, 0x38, 0x00, 0x00, 0x06, 0x3d, 0x00,
+    0x00, 0x06, 0x4c, 0x00, 0x00, 0x06, 0x5a, 0x00, 0x00, 0x06, 0x63, 0x00,
+    0x00, 0x06, 0x6e, 0x00, 0x00, 0x06, 0x73, 0x00, 0x00, 0x06, 0x81, 0x00,
+    0x00, 0x06, 0x85, 0x00, 0x00, 0x06, 0x8a, 0x00, 0x00, 0x06, 0x8d, 0x00,
+    0x00, 0x06, 0x98, 0x00, 0x00, 0x06, 0xa4, 0x00, 0x00, 0x06, 0xb9, 0x00,
+    0x00, 0x06, 0xc0, 0x00, 0x00, 0x06, 0xcb, 0x00, 0x00, 0x06, 0xda, 0x00,
+    0x00, 0x06, 0xdf, 0x00, 0x00, 0x06, 0xee, 0x00, 0x00, 0x06, 0xfc, 0x00,
+    0x00, 0x07, 0x03, 0x00, 0x00, 0x07, 0x09, 0x00, 0x00, 0x07, 0x11, 0x00,
+    0x00, 0x07, 0x19, 0x00, 0x00, 0x07, 0x25, 0x00, 0x00, 0x07, 0x33, 0x00,
+    0x00, 0x07, 0x45, 0x00, 0x00, 0x07, 0x4b, 0x00, 0x00, 0x07, 0x56, 0x00,
+    0x00, 0x07, 0x5b, 0x00, 0x00, 0x07, 0x63, 0x00, 0x00, 0x07, 0x6d, 0x00,
+    0x00, 0x07, 0x73, 0x00, 0x00, 0x07, 0x7e, 0x00, 0x00, 0x07, 0x82, 0x00,
+    0x00, 0x07, 0x93, 0x00, 0x00, 0x07, 0x97, 0x00, 0x00, 0x07, 0xab, 0x00,
+    0x00, 0x07, 0xb5, 0x00, 0x00, 0x07, 0xba, 0x00, 0x00, 0x07, 0xc1, 0x00,
+    0x00, 0x07, 0xc5, 0x00, 0x00, 0x07, 0xd0, 0x00, 0x00, 0x07, 0xdc, 0x00,
+    0x00, 0x07, 0xe0, 0x00, 0x00, 0x07, 0xe6, 0x00, 0x00, 0x07, 0xef, 0x00,
+    0x00, 0x07, 0xf6, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x08, 0x0a, 0x00,
+    0x00, 0x08, 0x16, 0x69, 0x6e, 0x00, 0x74, 0x6f, 0x00, 0x66, 0x6f, 0x72,
+    0x00, 0x77, 0x69, 0x74, 0x68, 0x00, 0x6f, 0x6e, 0x00, 0x62, 0x79, 0x00,
+    0x61, 0x74, 0x00, 0x66, 0x72, 0x6f, 0x6d, 0x00, 0x69, 0x6e, 0x74, 0x6f,
+    0x00, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x00, 0x61, 0x73, 0x00, 0x6c, 0x69,
+    0x6b, 0x65, 0x00, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x00, 0x74,
+    0x68, 0x72, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x61, 0x66, 0x74, 0x65, 0x72,
+    0x00, 0x61, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x74, 0x00, 0x75, 0x6e, 0x64,
+    0x65, 0x72, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x6f, 0x75, 0x74, 0x20,
+    0x6f, 0x66, 0x00, 0x77, 0x69, 0x74, 0x68, 0x6f, 0x75, 0x74, 0x00, 0x77,
+    0x69, 0x74, 0x68, 0x69, 0x6e, 0x00, 0x64, 0x75, 0x72, 0x69, 0x6e, 0x67,
+    0x00, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x00, 0x73, 0x75, 0x63, 0x68,
+    0x20, 0x61, 0x73, 0x00, 0x74, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x73, 0x00,
+    0x75, 0x70, 0x00, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67,
+    0x00, 0x61, 0x6d, 0x6f, 0x6e, 0x67, 0x00, 0x75, 0x70, 0x6f, 0x6e, 0x00,
+    0x75, 0x70, 0x20, 0x74, 0x6f, 0x00, 0x61, 0x63, 0x72, 0x6f, 0x73, 0x73,
+    0x00, 0x62, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x00, 0x6f, 0x66, 0x66, 0x00,
+    0x72, 0x61, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61, 0x6e, 0x00,
+    0x61, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x00, 0x62, 0x65, 0x63, 0x61, 0x75,
+    0x73, 0x65, 0x20, 0x6f, 0x66, 0x00, 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64,
+    0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x00, 0x64, 0x65, 0x73, 0x70, 0x69,
+    0x74, 0x65, 0x00, 0x73, 0x69, 0x6e, 0x63, 0x65, 0x00, 0x64, 0x6f, 0x77,
+    0x6e, 0x00, 0x70, 0x65, 0x72, 0x00, 0x6e, 0x65, 0x61, 0x72, 0x00, 0x61,
+    0x62, 0x6f, 0x76, 0x65, 0x00, 0x74, 0x68, 0x72, 0x6f, 0x75, 0x67, 0x68,
+    0x6f, 0x75, 0x74, 0x00, 0x61, 0x77, 0x61, 0x79, 0x20, 0x66, 0x72, 0x6f,
+    0x6d, 0x00, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x00, 0x62, 0x65,
+    0x79, 0x6f, 0x6e, 0x64, 0x00, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x00, 0x69,
+    0x6e, 0x20, 0x74, 0x65, 0x72, 0x6d, 0x73, 0x20, 0x6f, 0x66, 0x00, 0x64,
+    0x75, 0x65, 0x20, 0x74, 0x6f, 0x00, 0x77, 0x6f, 0x72, 0x74, 0x68, 0x00,
+    0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x00,
+    0x61, 0x73, 0x20, 0x74, 0x6f, 0x00, 0x69, 0x6e, 0x73, 0x69, 0x64, 0x65,
+    0x00, 0x70, 0x6c, 0x75, 0x73, 0x00, 0x61, 0x70, 0x61, 0x72, 0x74, 0x20,
+    0x66, 0x72, 0x6f, 0x6d, 0x00, 0x69, 0x6e, 0x20, 0x66, 0x72, 0x6f, 0x6e,
+    0x74, 0x20, 0x6f, 0x66, 0x00, 0x74, 0x6f, 0x67, 0x65, 0x74, 0x68, 0x65,
+    0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x62, 0x65, 0x73, 0x69, 0x64,
+    0x65, 0x00, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x00, 0x6f, 0x6e, 0x74, 0x6f,
+    0x00, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x74, 0x6f, 0x00,
+    0x62, 0x65, 0x6e, 0x65, 0x61, 0x74, 0x68, 0x00, 0x61, 0x6c, 0x6f, 0x6e,
+    0x67, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x70, 0x61, 0x73, 0x74, 0x00,
+    0x76, 0x69, 0x61, 0x00, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x74,
+    0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x00, 0x61, 0x6d, 0x6f, 0x6e, 0x67,
+    0x73, 0x74, 0x00, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x61,
+    0x6e, 0x00, 0x69, 0x6e, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f,
+    0x6e, 0x20, 0x74, 0x6f, 0x00, 0x69, 0x6e, 0x20, 0x66, 0x61, 0x76, 0x6f,
+    0x75, 0x72, 0x20, 0x6f, 0x66, 0x00, 0x75, 0x6e, 0x6c, 0x69, 0x6b, 0x65,
+    0x00, 0x61, 0x67, 0x65, 0x64, 0x00, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72,
+    0x6e, 0x69, 0x6e, 0x67, 0x00, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x20, 0x74,
+    0x6f, 0x00, 0x62, 0x75, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x00, 0x69, 0x6e,
+    0x20, 0x73, 0x70, 0x69, 0x74, 0x65, 0x20, 0x6f, 0x66, 0x00, 0x69, 0x6e,
+    0x20, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x20, 0x6f, 0x66, 0x00,
+    0x61, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x69, 0x64, 0x65, 0x00, 0x6e, 0x65,
+    0x78, 0x74, 0x20, 0x74, 0x6f, 0x00, 0x61, 0x73, 0x20, 0x66, 0x6f, 0x72,
+    0x00, 0x61, 0x68, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x00, 0x6f, 0x6e,
+    0x20, 0x62, 0x65, 0x68, 0x61, 0x6c, 0x66, 0x20, 0x6f, 0x66, 0x00, 0x6f,
+    0x6e, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x00, 0x72, 0x65, 0x67,
+    0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x64, 0x65, 0x70, 0x65, 0x6e,
+    0x64, 0x69, 0x6e, 0x67, 0x20, 0x6f, 0x6e, 0x00, 0x69, 0x6e, 0x20, 0x72,
+    0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x00, 0x69,
+    0x6e, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64, 0x61, 0x6e, 0x63, 0x65,
+    0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74,
+    0x20, 0x66, 0x6f, 0x72, 0x00, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20,
+    0x6c, 0x69, 0x67, 0x68, 0x74, 0x20, 0x6f, 0x66, 0x00, 0x65, 0x78, 0x63,
+    0x65, 0x70, 0x74, 0x00, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20,
+    0x6f, 0x66, 0x00, 0x69, 0x6e, 0x20, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65,
+    0x20, 0x6f, 0x66, 0x00, 0x77, 0x69, 0x74, 0x68, 0x20, 0x72, 0x65, 0x67,
+    0x61, 0x72, 0x64, 0x20, 0x74, 0x6f, 0x00, 0x69, 0x6e, 0x20, 0x63, 0x6f,
+    0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74,
+    0x68, 0x00, 0x62, 0x79, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73, 0x20, 0x6f,
+    0x66, 0x00, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x72,
+    0x74, 0x20, 0x6f, 0x66, 0x00, 0x6f, 0x75, 0x74, 0x00, 0x69, 0x6e, 0x20,
+    0x76, 0x69, 0x65, 0x77, 0x20, 0x6f, 0x66, 0x00, 0x61, 0x73, 0x20, 0x6f,
+    0x70, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x00, 0x62, 0x79,
+    0x20, 0x77, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x00, 0x77, 0x69, 0x74, 0x68,
+    0x20, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x20, 0x74, 0x6f, 0x00,
+    0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x72, 0x79, 0x20, 0x74, 0x6f, 0x00,
+    0x74, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x00, 0x69, 0x6e, 0x20, 0x63, 0x6f,
+    0x6e, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69,
+    0x74, 0x68, 0x00, 0x69, 0x6e, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x77,
+    0x69, 0x74, 0x68, 0x00, 0x74, 0x69, 0x6c, 0x6c, 0x00, 0x66, 0x6f, 0x6c,
+    0x6c, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x00, 0x69, 0x6e, 0x20, 0x74, 0x6f,
+    0x75, 0x63, 0x68, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x61, 0x6d, 0x69,
+    0x64, 0x00, 0x69, 0x6e, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74,
+    0x20, 0x6f, 0x66, 0x00, 0x69, 0x6e, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63,
+    0x68, 0x20, 0x6f, 0x66, 0x00, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x76,
+    0x65, 0x20, 0x74, 0x6f, 0x00, 0x69, 0x6e, 0x20, 0x72, 0x65, 0x74, 0x75,
+    0x72, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x00, 0x76, 0x65, 0x72, 0x73, 0x75,
+    0x73, 0x00, 0x6c, 0x65, 0x74, 0x20, 0x61, 0x6c, 0x6f, 0x6e, 0x65, 0x00,
+    0x69, 0x72, 0x72, 0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65,
+    0x20, 0x6f, 0x66, 0x00, 0x62, 0x65, 0x73, 0x69, 0x64, 0x65, 0x73, 0x00,
+    0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x76, 0x69, 0x65, 0x77, 0x20,
+    0x74, 0x6f, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x69,
+    0x6e, 0x67, 0x00, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x00,
+    0x6e, 0x65, 0x61, 0x72, 0x20, 0x74, 0x6f, 0x00, 0x69, 0x6e, 0x20, 0x65,
+    0x78, 0x63, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x00, 0x69, 0x6e, 0x20,
+    0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x00, 0x69, 0x6e, 0x20,
+    0x6e, 0x65, 0x65, 0x64, 0x20, 0x6f, 0x66, 0x00, 0x69, 0x6e, 0x20, 0x63,
+    0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x61,
+    0x73, 0x20, 0x6f, 0x66, 0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6e, 0x65,
+    0x61, 0x74, 0x68, 0x00, 0x6f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x20,
+    0x6f, 0x66, 0x00, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67,
+    0x00, 0x75, 0x70, 0x20, 0x75, 0x6e, 0x74, 0x69, 0x6c, 0x00, 0x61, 0x73,
+    0x20, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x73, 0x00, 0x61, 0x62, 0x6f,
+    0x61, 0x72, 0x64, 0x00, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x00,
+    0x6f, 0x6e, 0x20, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x00, 0x6e, 0x6f, 0x74,
+    0x77, 0x69, 0x74, 0x68, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x69, 0x6e, 0x67,
+    0x00, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f,
+    0x00, 0x6f, 0x6e, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x20,
+    0x6f, 0x66, 0x00, 0x61, 0x6d, 0x69, 0x64, 0x73, 0x74, 0x00, 0x69, 0x6e,
+    0x20, 0x6b, 0x65, 0x65, 0x70, 0x69, 0x6e, 0x67, 0x20, 0x77, 0x69, 0x74,
+    0x68, 0x00, 0x6f, 0x70, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x00, 0x69,
+    0x6e, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e,
+    0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x70, 0x75, 0x72, 0x73, 0x75, 0x61,
+    0x6e, 0x74, 0x20, 0x74, 0x6f, 0x00, 0x61, 0x73, 0x20, 0x61, 0x67, 0x61,
+    0x69, 0x6e, 0x73, 0x74, 0x00, 0x6d, 0x69, 0x6e, 0x75, 0x73, 0x00, 0x69,
+    0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x20, 0x77, 0x69,
+    0x74, 0x68, 0x00, 0x69, 0x6e, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69,
+    0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x74,
+    0x68, 0x61, 0x6e, 0x6b, 0x73, 0x20, 0x74, 0x6f, 0x00, 0x75, 0x6e, 0x74,
+    0x6f, 0x00, 0x77, 0x69, 0x74, 0x68, 0x20, 0x72, 0x65, 0x66, 0x65, 0x72,
+    0x65, 0x6e, 0x63, 0x65, 0x20, 0x74, 0x6f, 0x00, 0x66, 0x6f, 0x72, 0x20,
+    0x66, 0x65, 0x61, 0x72, 0x20, 0x6f, 0x66, 0x00, 0x6e, 0x65, 0x61, 0x72,
+    0x65, 0x72, 0x20, 0x74, 0x6f, 0x00, 0x69, 0x6e, 0x20, 0x70, 0x75, 0x72,
+    0x73, 0x75, 0x69, 0x74, 0x20, 0x6f, 0x66, 0x00, 0x69, 0x6e, 0x20, 0x70,
+    0x6f, 0x73, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66,
+    0x00, 0x69, 0x6e, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x00,
+    0x62, 0x79, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x6f, 0x66,
+    0x00, 0x69, 0x6e, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x00,
+    0x61, 0x73, 0x69, 0x64, 0x65, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x00, 0x69,
+    0x6e, 0x20, 0x61, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x20, 0x74, 0x6f, 0x00,
+    0x69, 0x6e, 0x20, 0x61, 0x69, 0x64, 0x20, 0x6f, 0x66, 0x00, 0x69, 0x6e,
+    0x20, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x20, 0x74, 0x6f, 0x00, 0x69,
+    0x6e, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e,
+    0x20, 0x74, 0x6f, 0x00, 0x61, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x00,
+    0x61, 0x73, 0x20, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x00, 0x73,
+    0x61, 0x76, 0x65, 0x00, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x6c, 0x69, 0x6e,
+    0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x69, 0x6e, 0x20, 0x64, 0x65,
+    0x66, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66, 0x00, 0x73, 0x61, 0x76,
+    0x65, 0x20, 0x66, 0x6f, 0x72, 0x00, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c,
+    0x6c, 0x20, 0x61, 0x73, 0x00, 0x76, 0x69, 0x63, 0x65, 0x00, 0x69, 0x6e,
+    0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x20, 0x6f, 0x66, 0x00,
+    0x70, 0x72, 0x6f, 0x00, 0x74, 0x68, 0x61, 0x6e, 0x00, 0x6f, 0x66, 0x00,
+    0x6e, 0x65, 0x61, 0x72, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x00, 0x69,
+    0x6e, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x79, 0x20, 0x74, 0x6f, 0x00, 0x69,
+    0x6e, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6c, 0x74, 0x61, 0x74, 0x69,
+    0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x6e, 0x65, 0x61, 0x72,
+    0x65, 0x72, 0x00, 0x69, 0x6e, 0x20, 0x6c, 0x69, 0x65, 0x75, 0x20, 0x6f,
+    0x66, 0x00, 0x69, 0x6e, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64, 0x20,
+    0x77, 0x69, 0x74, 0x68, 0x00, 0x61, 0x74, 0x6f, 0x70, 0x00, 0x69, 0x6e,
+    0x20, 0x64, 0x65, 0x66, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x6f, 0x66,
+    0x00, 0x70, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20,
+    0x74, 0x6f, 0x00, 0x6f, 0x66, 0x66, 0x20, 0x6f, 0x66, 0x00, 0x67, 0x69,
+    0x76, 0x65, 0x6e, 0x00, 0x61, 0x73, 0x74, 0x72, 0x69, 0x64, 0x65, 0x00,
+    0x6e, 0x65, 0x61, 0x72, 0x65, 0x73, 0x74, 0x00, 0x69, 0x6e, 0x20, 0x6c,
+    0x69, 0x67, 0x68, 0x74, 0x20, 0x6f, 0x66, 0x00, 0x73, 0x75, 0x62, 0x73,
+    0x65, 0x71, 0x75, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x00, 0x6f, 0x75,
+    0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x20, 0x77,
+    0x69, 0x74, 0x68, 0x00, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x00, 0x72, 0x65,
+    0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x61, 0x20, 0x6c,
+    0x61, 0x00, 0x62, 0x61, 0x72, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x76, 0x69,
+    0x73, 0x2d, 0x61, 0x2d, 0x76, 0x69, 0x73, 0x00, 0x74, 0x69, 0x6d, 0x65,
+    0x73, 0x00, 0x69, 0x6e, 0x20, 0x66, 0x61, 0x63, 0x65, 0x20, 0x6f, 0x66,
+    0x00, 0x62, 0x75, 0x74, 0x00, 0x6f, 0x75, 0x74, 0x20, 0x6f, 0x66, 0x20,
+    0x6c, 0x69, 0x6e, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x64, 0x75,
+    0x65, 0x00, 0x69, 0x6e, 0x20, 0x63, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61,
+    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x69, 0x74, 0x68, 0x00, 0x65, 0x78,
+    0x63, 0x65, 0x70, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x74, 0x68, 0x72, 0x75,
+    0x00, 0x74, 0x6f, 0x70, 0x20, 0x6f, 0x66, 0x00, 0x70, 0x72, 0x70, 0x00,
+    0x69, 0x6e, 0x2d, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x00, 0x69,
+    0x6e, 0x20, 0x66, 0x61, 0x76, 0x6f, 0x72, 0x20, 0x6f, 0x66, 0x00, 0x65,
+    0x72, 0x65, 0x00, 0x61, 0x66, 0x6f, 0x72, 0x65, 0x00, 0x74, 0x65, 0x72,
+    0x6d, 0x73, 0x20, 0x6f, 0x66, 0x00, 0x73, 0x61, 0x76, 0x69, 0x6e, 0x67,
+    0x00, 0x69, 0x6e, 0x20, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x66,
+    0x00, 0x61, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x00, 0x61, 0x64, 0x64,
+    0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x00, 0x61, 0x63, 0x63,
+    0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x02, 0x0b, 0x00, 0x00, 0x01, 0xe7, 0x00, 0x00, 0x01, 0xd0, 0x00,
+    0x00, 0x01, 0xb4, 0x00, 0x00, 0x01, 0x99, 0x00, 0x00, 0x01, 0x67, 0x00,
+    0x00, 0x01, 0x19, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00, 0x01, 0x09, 0x00,
+    0x00, 0x00, 0xee, 0x00, 0x00, 0x00, 0xeb, 0x00, 0x00, 0x00, 0xd1, 0x00,
+    0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0xa8, 0x00,
+    0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0xa1, 0x00,
+    0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0x9d, 0x00, 0x00, 0x00, 0x81, 0x00,
+    0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x70, 0x00,
+    0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00, 0x66, 0x00,
+    0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x62, 0x00,
+    0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x5d, 0x00,
+    0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x57, 0x00,
+    0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x52, 0x00,
+    0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x50, 0x00,
+    0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x4d, 0x00,
+    0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x49, 0x00,
+    0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x47, 0x00,
+    0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x44, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x40, 0x00,
+    0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, 0x00,
+    0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x3e, 0x00,
+    0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x3d, 0x00,
+    0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x3b, 0x00,
+    0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x39, 0x00,
+    0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x38, 0x00,
+    0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x37, 0x00,
+    0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x35, 0x00,
+    0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x33, 0x00,
+    0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x32, 0x00,
+    0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x31, 0x00,
+    0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x2e, 0x00,
+    0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00,
+    0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x2b, 0x00,
+    0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x2b, 0x00,
+    0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x29, 0x00,
+    0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00,
+    0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00,
+    0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00,
+    0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x26, 0x00,
+    0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00,
+    0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00,
+    0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00,
+    0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00,
+    0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00,
+    0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00,
+    0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00,
+    0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00,
+    0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00,
+    0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00,
+    0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00,
+    0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
+    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0d, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x1a, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x28, 0x00,
+    0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x38, 0x00,
+    0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x46, 0x00,
+    0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x55, 0x00,
+    0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x69, 0x00,
+    0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x76, 0x00,
+    0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x86, 0x00,
+    0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x9b, 0x00,
+    0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00, 0xaa, 0x00,
+    0x00, 0x00, 0xae, 0x00, 0x00, 0x00, 0xb6, 0x00, 0x00, 0x00, 0xbb, 0x00,
+    0x00, 0x00, 0xc2, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0xcc, 0x00,
+    0x00, 0x00, 0xd2, 0x00, 0x00, 0x00, 0xd7, 0x00, 0x00, 0x00, 0xe0, 0x00,
+    0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0xed, 0x00, 0x00, 0x00, 0xf4, 0x00,
+    0x00, 0x00, 0xf9, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x01, 0x02, 0x00,
+    0x00, 0x01, 0x06, 0x00, 0x00, 0x01, 0x0a, 0x00, 0x00, 0x01, 0x10, 0x00,
+    0x00, 0x01, 0x19, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x01, 0x25, 0x00,
+    0x00, 0x01, 0x2e, 0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x01, 0x3b, 0x00,
+    0x00, 0x01, 0x43, 0x00, 0x00, 0x01, 0x48, 0x00, 0x00, 0x01, 0x4e, 0x00,
+    0x00, 0x01, 0x54, 0x00, 0x00, 0x01, 0x5a, 0x00, 0x00, 0x01, 0x61, 0x00,
+    0x00, 0x01, 0x67, 0x00, 0x00, 0x01, 0x6e, 0x00, 0x00, 0x01, 0x75, 0x00,
+    0x00, 0x01, 0x7c, 0x00, 0x00, 0x01, 0x84, 0x00, 0x00, 0x01, 0x8c, 0x00,
+    0x00, 0x01, 0x93, 0x00, 0x00, 0x01, 0x98, 0x00, 0x00, 0x01, 0x9c, 0x00,
+    0x00, 0x01, 0xa4, 0x00, 0x00, 0x01, 0xac, 0x00, 0x00, 0x01, 0xb3, 0x00,
+    0x00, 0x01, 0xb9, 0x00, 0x00, 0x01, 0xbd, 0x00, 0x00, 0x01, 0xc4, 0x00,
+    0x00, 0x01, 0xca, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x01, 0xd9, 0x00,
+    0x00, 0x01, 0xde, 0x00, 0x00, 0x01, 0xe3, 0x00, 0x00, 0x01, 0xeb, 0x00,
+    0x00, 0x01, 0xf1, 0x00, 0x00, 0x01, 0xf6, 0x00, 0x00, 0x01, 0xfd, 0x00,
+    0x00, 0x02, 0x03, 0x00, 0x00, 0x02, 0x09, 0x00, 0x00, 0x02, 0x0f, 0x00,
+    0x00, 0x02, 0x17, 0x00, 0x00, 0x02, 0x1c, 0x00, 0x00, 0x02, 0x22, 0x00,
+    0x00, 0x02, 0x28, 0x00, 0x00, 0x02, 0x2e, 0x00, 0x00, 0x02, 0x33, 0x00,
+    0x00, 0x02, 0x3d, 0x00, 0x00, 0x02, 0x44, 0x00, 0x00, 0x02, 0x49, 0x00,
+    0x00, 0x02, 0x51, 0x00, 0x00, 0x02, 0x56, 0x00, 0x00, 0x02, 0x5b, 0x00,
+    0x00, 0x02, 0x64, 0x00, 0x00, 0x02, 0x68, 0x00, 0x00, 0x02, 0x6d, 0x00,
+    0x00, 0x02, 0x75, 0x00, 0x00, 0x02, 0x7d, 0x00, 0x00, 0x02, 0x82, 0x00,
+    0x00, 0x02, 0x88, 0x00, 0x00, 0x02, 0x8e, 0x00, 0x00, 0x02, 0x94, 0x00,
+    0x00, 0x02, 0x98, 0x00, 0x00, 0x02, 0xa1, 0x00, 0x00, 0x02, 0xa5, 0x00,
+    0x00, 0x02, 0xac, 0x00, 0x00, 0x02, 0xb1, 0x00, 0x00, 0x02, 0xb8, 0x00,
+    0x00, 0x02, 0xbc, 0x00, 0x00, 0x02, 0xc6, 0x00, 0x00, 0x02, 0xcd, 0x00,
+    0x00, 0x02, 0xd3, 0x00, 0x00, 0x02, 0xdb, 0x00, 0x00, 0x02, 0xe0, 0x00,
+    0x00, 0x02, 0xe6, 0x00, 0x00, 0x02, 0xeb, 0x00, 0x00, 0x02, 0xf2, 0x00,
+    0x00, 0x02, 0xf7, 0x00, 0x00, 0x02, 0xfb, 0x00, 0x00, 0x03, 0x03, 0x00,
+    0x00, 0x03, 0x0a, 0x00, 0x00, 0x03, 0x0f, 0x00, 0x00, 0x03, 0x15, 0x00,
+    0x00, 0x03, 0x1a, 0x00, 0x00, 0x03, 0x20, 0x00, 0x00, 0x03, 0x24, 0x00,
+    0x00, 0x03, 0x2a, 0x00, 0x00, 0x03, 0x30, 0x00, 0x00, 0x03, 0x35, 0x00,
+    0x00, 0x03, 0x3d, 0x00, 0x00, 0x03, 0x42, 0x00, 0x00, 0x03, 0x49, 0x00,
+    0x00, 0x03, 0x4e, 0x00, 0x00, 0x03, 0x52, 0x00, 0x00, 0x03, 0x57, 0x00,
+    0x00, 0x03, 0x5d, 0x00, 0x00, 0x03, 0x62, 0x00, 0x00, 0x03, 0x68, 0x00,
+    0x00, 0x03, 0x72, 0x00, 0x00, 0x03, 0x77, 0x00, 0x00, 0x03, 0x7e, 0x00,
+    0x00, 0x03, 0x84, 0x00, 0x00, 0x03, 0x89, 0x00, 0x00, 0x03, 0x8f, 0x00,
+    0x00, 0x03, 0x94, 0x00, 0x00, 0x03, 0x99, 0x00, 0x00, 0x03, 0x9e, 0x00,
+    0x00, 0x03, 0xa4, 0x00, 0x00, 0x03, 0xaa, 0x00, 0x00, 0x03, 0xb2, 0x00,
+    0x00, 0x03, 0xb8, 0x00, 0x00, 0x03, 0xbf, 0x00, 0x00, 0x03, 0xc3, 0x00,
+    0x00, 0x03, 0xcc, 0x00, 0x00, 0x03, 0xd3, 0x00, 0x00, 0x03, 0xd9, 0x00,
+    0x00, 0x03, 0xe3, 0x00, 0x00, 0x03, 0xe9, 0x00, 0x00, 0x03, 0xef, 0x00,
+    0x00, 0x03, 0xf6, 0x00, 0x00, 0x03, 0xfe, 0x00, 0x00, 0x04, 0x06, 0x00,
+    0x00, 0x04, 0x0e, 0x00, 0x00, 0x04, 0x15, 0x00, 0x00, 0x04, 0x1d, 0x00,
+    0x00, 0x04, 0x25, 0x00, 0x00, 0x04, 0x2b, 0x00, 0x00, 0x04, 0x31, 0x00,
+    0x00, 0x04, 0x37, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x04, 0x44, 0x00,
+    0x00, 0x04, 0x4e, 0x00, 0x00, 0x04, 0x56, 0x00, 0x00, 0x04, 0x5d, 0x00,
+    0x00, 0x04, 0x66, 0x00, 0x00, 0x04, 0x6b, 0x00, 0x00, 0x04, 0x71, 0x00,
+    0x00, 0x04, 0x7b, 0x00, 0x00, 0x04, 0x83, 0x00, 0x00, 0x04, 0x8b, 0x00,
+    0x00, 0x04, 0x92, 0x00, 0x00, 0x04, 0x99, 0x00, 0x00, 0x04, 0xa2, 0x00,
+    0x00, 0x04, 0xa9, 0x00, 0x00, 0x04, 0xb1, 0x00, 0x00, 0x04, 0xba, 0x00,
+    0x00, 0x04, 0xc1, 0x00, 0x00, 0x04, 0xc9, 0x00, 0x00, 0x04, 0xcf, 0x00,
+    0x00, 0x04, 0xd4, 0x00, 0x00, 0x04, 0xd9, 0x00, 0x00, 0x04, 0xe0, 0x00,
+    0x00, 0x04, 0xe7, 0x00, 0x00, 0x04, 0xee, 0x00, 0x00, 0x04, 0xf3, 0x00,
+    0x00, 0x04, 0xfb, 0x00, 0x00, 0x05, 0x07, 0x00, 0x00, 0x05, 0x0d, 0x00,
+    0x00, 0x05, 0x15, 0x00, 0x00, 0x05, 0x1c, 0x00, 0x00, 0x05, 0x23, 0x00,
+    0x00, 0x05, 0x2b, 0x00, 0x00, 0x05, 0x34, 0x00, 0x00, 0x05, 0x38, 0x00,
+    0x00, 0x05, 0x44, 0x00, 0x00, 0x05, 0x49, 0x00, 0x00, 0x05, 0x50, 0x00,
+    0x00, 0x05, 0x58, 0x00, 0x00, 0x05, 0x5d, 0x00, 0x00, 0x05, 0x63, 0x00,
+    0x00, 0x05, 0x69, 0x00, 0x00, 0x05, 0x70, 0x00, 0x00, 0x05, 0x76, 0x00,
+    0x00, 0x05, 0x7b, 0x00, 0x00, 0x05, 0x7f, 0x00, 0x00, 0x05, 0x87, 0x00,
+    0x00, 0x05, 0x8e, 0x00, 0x00, 0x05, 0x95, 0x00, 0x00, 0x05, 0x9c, 0x00,
+    0x00, 0x05, 0xa3, 0x00, 0x00, 0x05, 0xaa, 0x00, 0x00, 0x05, 0xb0, 0x00,
+    0x00, 0x05, 0xb7, 0x00, 0x00, 0x05, 0xbd, 0x00, 0x00, 0x05, 0xc5, 0x00,
+    0x00, 0x05, 0xcd, 0x00, 0x00, 0x05, 0xd3, 0x00, 0x00, 0x05, 0xd9, 0x00,
+    0x00, 0x05, 0xe1, 0x00, 0x00, 0x05, 0xe6, 0x00, 0x00, 0x05, 0xec, 0x00,
+    0x00, 0x05, 0xf4, 0x00, 0x00, 0x05, 0xfa, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x07, 0x00, 0x00, 0x06, 0x12, 0x00, 0x00, 0x06, 0x1a, 0x00,
+    0x00, 0x06, 0x1f, 0x00, 0x00, 0x06, 0x26, 0x00, 0x00, 0x06, 0x2c, 0x00,
+    0x00, 0x06, 0x37, 0x00, 0x00, 0x06, 0x3d, 0x00, 0x00, 0x06, 0x42, 0x00,
+    0x00, 0x06, 0x48, 0x00, 0x00, 0x06, 0x4d, 0x00, 0x00, 0x06, 0x55, 0x00,
+    0x00, 0x06, 0x5c, 0x00, 0x00, 0x06, 0x64, 0x00, 0x00, 0x06, 0x6e, 0x00,
+    0x00, 0x06, 0x75, 0x00, 0x00, 0x06, 0x7a, 0x00, 0x00, 0x06, 0x7f, 0x00,
+    0x00, 0x06, 0x8b, 0x00, 0x00, 0x06, 0x90, 0x00, 0x00, 0x06, 0x9c, 0x00,
+    0x00, 0x06, 0xa4, 0x00, 0x00, 0x06, 0xab, 0x00, 0x00, 0x06, 0xb3, 0x00,
+    0x00, 0x06, 0xb9, 0x00, 0x00, 0x06, 0xc1, 0x00, 0x00, 0x06, 0xc6, 0x00,
+    0x00, 0x06, 0xcb, 0x00, 0x00, 0x06, 0xd2, 0x00, 0x00, 0x06, 0xda, 0x00,
+    0x00, 0x06, 0xdf, 0x00, 0x00, 0x06, 0xe6, 0x00, 0x00, 0x06, 0xec, 0x00,
+    0x00, 0x06, 0xf4, 0x00, 0x00, 0x06, 0xfc, 0x00, 0x00, 0x07, 0x04, 0x00,
+    0x00, 0x07, 0x0c, 0x00, 0x00, 0x07, 0x11, 0x00, 0x00, 0x07, 0x16, 0x00,
+    0x00, 0x07, 0x1c, 0x00, 0x00, 0x07, 0x26, 0x00, 0x00, 0x07, 0x2c, 0x00,
+    0x00, 0x07, 0x33, 0x00, 0x00, 0x07, 0x3c, 0x00, 0x00, 0x07, 0x40, 0x00,
+    0x00, 0x07, 0x47, 0x00, 0x00, 0x07, 0x4b, 0x00, 0x00, 0x07, 0x54, 0x00,
+    0x00, 0x07, 0x5a, 0x00, 0x00, 0x07, 0x5f, 0x00, 0x00, 0x07, 0x66, 0x00,
+    0x00, 0x07, 0x6f, 0x00, 0x00, 0x07, 0x76, 0x00, 0x00, 0x07, 0x7e, 0x00,
+    0x00, 0x07, 0x86, 0x00, 0x00, 0x07, 0x90, 0x00, 0x00, 0x07, 0x98, 0x00,
+    0x00, 0x07, 0xa0, 0x00, 0x00, 0x07, 0xa7, 0x00, 0x00, 0x07, 0xae, 0x00,
+    0x00, 0x07, 0xb5, 0x00, 0x00, 0x07, 0xc1, 0x00, 0x00, 0x07, 0xc6, 0x00,
+    0x00, 0x07, 0xcb, 0x00, 0x00, 0x07, 0xd2, 0x00, 0x00, 0x07, 0xd7, 0x00,
+    0x00, 0x07, 0xdd, 0x00, 0x00, 0x07, 0xe6, 0x00, 0x00, 0x07, 0xed, 0x00,
+    0x00, 0x07, 0xf2, 0x00, 0x00, 0x07, 0xf9, 0x00, 0x00, 0x08, 0x02, 0x00,
+    0x00, 0x08, 0x07, 0x00, 0x00, 0x08, 0x0d, 0x00, 0x00, 0x08, 0x15, 0x00,
+    0x00, 0x08, 0x1b, 0x00, 0x00, 0x08, 0x21, 0x00, 0x00, 0x08, 0x2b, 0x00,
+    0x00, 0x08, 0x30, 0x00, 0x00, 0x08, 0x37, 0x00, 0x00, 0x08, 0x3f, 0x00,
+    0x00, 0x08, 0x4b, 0x00, 0x00, 0x08, 0x52, 0x00, 0x00, 0x08, 0x59, 0x00,
+    0x00, 0x08, 0x60, 0x00, 0x00, 0x08, 0x6c, 0x00, 0x00, 0x08, 0x73, 0x00,
+    0x00, 0x08, 0x7a, 0x00, 0x00, 0x08, 0x82, 0x00, 0x00, 0x08, 0x8a, 0x00,
+    0x00, 0x08, 0x91, 0x00, 0x00, 0x08, 0x99, 0x00, 0x00, 0x08, 0xa1, 0x00,
+    0x00, 0x08, 0xa7, 0x00, 0x00, 0x08, 0xac, 0x00, 0x00, 0x08, 0xb3, 0x00,
+    0x00, 0x08, 0xba, 0x00, 0x00, 0x08, 0xbf, 0x00, 0x00, 0x08, 0xc4, 0x00,
+    0x00, 0x08, 0xcf, 0x00, 0x00, 0x08, 0xd7, 0x00, 0x00, 0x08, 0xde, 0x00,
+    0x00, 0x08, 0xe2, 0x00, 0x00, 0x08, 0xe8, 0x00, 0x00, 0x08, 0xee, 0x00,
+    0x00, 0x08, 0xf6, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x05, 0x00,
+    0x00, 0x09, 0x0d, 0x00, 0x00, 0x09, 0x12, 0x00, 0x00, 0x09, 0x1b, 0x00,
+    0x00, 0x09, 0x23, 0x00, 0x00, 0x09, 0x2e, 0x00, 0x00, 0x09, 0x34, 0x00,
+    0x00, 0x09, 0x3a, 0x00, 0x00, 0x09, 0x3f, 0x00, 0x00, 0x09, 0x44, 0x00,
+    0x00, 0x09, 0x4b, 0x00, 0x00, 0x09, 0x50, 0x00, 0x00, 0x09, 0x57, 0x00,
+    0x00, 0x09, 0x5e, 0x00, 0x00, 0x09, 0x65, 0x00, 0x00, 0x09, 0x6b, 0x00,
+    0x00, 0x09, 0x74, 0x00, 0x00, 0x09, 0x7d, 0x00, 0x00, 0x09, 0x85, 0x00,
+    0x00, 0x09, 0x8d, 0x00, 0x00, 0x09, 0x91, 0x00, 0x00, 0x09, 0x9b, 0x00,
+    0x00, 0x09, 0xa3, 0x00, 0x00, 0x09, 0xaa, 0x00, 0x00, 0x09, 0xb4, 0x00,
+    0x00, 0x09, 0xbe, 0x00, 0x00, 0x09, 0xc6, 0x00, 0x00, 0x09, 0xcf, 0x00,
+    0x00, 0x09, 0xd5, 0x00, 0x00, 0x09, 0xdf, 0x00, 0x00, 0x09, 0xe6, 0x00,
+    0x00, 0x09, 0xee, 0x00, 0x00, 0x09, 0xfa, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x0a, 0x05, 0x00, 0x00, 0x0a, 0x0c, 0x00, 0x00, 0x0a, 0x11, 0x00,
+    0x00, 0x0a, 0x18, 0x00, 0x00, 0x0a, 0x20, 0x00, 0x00, 0x0a, 0x27, 0x00,
+    0x00, 0x0a, 0x2d, 0x00, 0x00, 0x0a, 0x32, 0x00, 0x00, 0x0a, 0x38, 0x00,
+    0x00, 0x0a, 0x3f, 0x00, 0x00, 0x0a, 0x49, 0x00, 0x00, 0x0a, 0x51, 0x00,
+    0x00, 0x0a, 0x56, 0x00, 0x00, 0x0a, 0x5d, 0x00, 0x00, 0x0a, 0x66, 0x00,
+    0x00, 0x0a, 0x6c, 0x00, 0x00, 0x0a, 0x71, 0x00, 0x00, 0x0a, 0x77, 0x00,
+    0x00, 0x0a, 0x7d, 0x00, 0x00, 0x0a, 0x88, 0x00, 0x00, 0x0a, 0x8f, 0x00,
+    0x00, 0x0a, 0x97, 0x00, 0x00, 0x0a, 0x9f, 0x00, 0x00, 0x0a, 0xa6, 0x00,
+    0x00, 0x0a, 0xae, 0x00, 0x00, 0x0a, 0xb5, 0x00, 0x00, 0x0a, 0xbc, 0x00,
+    0x00, 0x0a, 0xc6, 0x00, 0x00, 0x0a, 0xcf, 0x00, 0x00, 0x0a, 0xd6, 0x00,
+    0x00, 0x0a, 0xdf, 0x00, 0x00, 0x0a, 0xe8, 0x00, 0x00, 0x0a, 0xf0, 0x00,
+    0x00, 0x0a, 0xf6, 0x00, 0x00, 0x0a, 0xfd, 0x00, 0x00, 0x0b, 0x07, 0x00,
+    0x00, 0x0b, 0x0c, 0x00, 0x00, 0x0b, 0x12, 0x00, 0x00, 0x0b, 0x18, 0x00,
+    0x00, 0x0b, 0x21, 0x00, 0x00, 0x0b, 0x26, 0x00, 0x00, 0x0b, 0x2d, 0x00,
+    0x00, 0x0b, 0x33, 0x00, 0x00, 0x0b, 0x3b, 0x00, 0x00, 0x0b, 0x42, 0x00,
+    0x00, 0x0b, 0x47, 0x00, 0x00, 0x0b, 0x4e, 0x00, 0x00, 0x0b, 0x53, 0x00,
+    0x00, 0x0b, 0x58, 0x00, 0x00, 0x0b, 0x5d, 0x00, 0x00, 0x0b, 0x67, 0x00,
+    0x00, 0x0b, 0x71, 0x00, 0x00, 0x0b, 0x78, 0x00, 0x00, 0x0b, 0x7e, 0x00,
+    0x00, 0x0b, 0x84, 0x00, 0x00, 0x0b, 0x89, 0x00, 0x00, 0x0b, 0x94, 0x00,
+    0x00, 0x0b, 0x9d, 0x00, 0x00, 0x0b, 0xa4, 0x00, 0x00, 0x0b, 0xac, 0x00,
+    0x00, 0x0b, 0xb6, 0x00, 0x00, 0x0b, 0xbb, 0x00, 0x00, 0x0b, 0xc5, 0x00,
+    0x00, 0x0b, 0xcc, 0x00, 0x00, 0x0b, 0xd4, 0x00, 0x00, 0x0b, 0xdc, 0x00,
+    0x00, 0x0b, 0xe4, 0x00, 0x00, 0x0b, 0xed, 0x00, 0x00, 0x0b, 0xf5, 0x00,
+    0x00, 0x0b, 0xfb, 0x00, 0x00, 0x0c, 0x02, 0x00, 0x00, 0x0c, 0x08, 0x00,
+    0x00, 0x0c, 0x0f, 0x00, 0x00, 0x0c, 0x14, 0x00, 0x00, 0x0c, 0x19, 0x00,
+    0x00, 0x0c, 0x1e, 0x00, 0x00, 0x0c, 0x24, 0x00, 0x00, 0x0c, 0x28, 0x00,
+    0x00, 0x0c, 0x2e, 0x00, 0x00, 0x0c, 0x34, 0x00, 0x00, 0x0c, 0x3a, 0x00,
+    0x00, 0x0c, 0x41, 0x00, 0x00, 0x0c, 0x4a, 0x00, 0x00, 0x0c, 0x53, 0x00,
+    0x00, 0x0c, 0x5c, 0x00, 0x00, 0x0c, 0x64, 0x00, 0x00, 0x0c, 0x69, 0x00,
+    0x00, 0x0c, 0x75, 0x00, 0x00, 0x0c, 0x7a, 0x00, 0x00, 0x0c, 0x81, 0x00,
+    0x00, 0x0c, 0x89, 0x00, 0x00, 0x0c, 0x8d, 0x00, 0x00, 0x0c, 0x93, 0x00,
+    0x00, 0x0c, 0x9a, 0x00, 0x00, 0x0c, 0x9e, 0x00, 0x00, 0x0c, 0xa5, 0x00,
+    0x00, 0x0c, 0xac, 0x00, 0x00, 0x0c, 0xb3, 0x00, 0x00, 0x0c, 0xbe, 0x00,
+    0x00, 0x0c, 0xc9, 0x00, 0x00, 0x0c, 0xd0, 0x00, 0x00, 0x0c, 0xd6, 0x00,
+    0x00, 0x0c, 0xde, 0x00, 0x00, 0x0c, 0xe3, 0x00, 0x00, 0x0c, 0xeb, 0x00,
+    0x00, 0x0c, 0xf3, 0x00, 0x00, 0x0c, 0xfb, 0x00, 0x00, 0x0d, 0x02, 0x00,
+    0x00, 0x0d, 0x08, 0x00, 0x00, 0x0d, 0x12, 0x00, 0x00, 0x0d, 0x18, 0x00,
+    0x00, 0x0d, 0x1e, 0x00, 0x00, 0x0d, 0x28, 0x00, 0x00, 0x0d, 0x32, 0x00,
+    0x00, 0x0d, 0x38, 0x00, 0x00, 0x0d, 0x3d, 0x00, 0x00, 0x0d, 0x44, 0x00,
+    0x00, 0x0d, 0x4a, 0x00, 0x00, 0x0d, 0x50, 0x00, 0x00, 0x0d, 0x55, 0x00,
+    0x00, 0x0d, 0x5b, 0x00, 0x00, 0x0d, 0x62, 0x00, 0x00, 0x0d, 0x6a, 0x00,
+    0x00, 0x0d, 0x74, 0x00, 0x00, 0x0d, 0x7c, 0x00, 0x00, 0x0d, 0x82, 0x00,
+    0x00, 0x0d, 0x88, 0x00, 0x00, 0x0d, 0x8f, 0x00, 0x00, 0x0d, 0x95, 0x00,
+    0x00, 0x0d, 0x9c, 0x00, 0x00, 0x0d, 0xa3, 0x00, 0x00, 0x0d, 0xa8, 0x00,
+    0x00, 0x0d, 0xae, 0x00, 0x00, 0x0d, 0xb7, 0x00, 0x00, 0x0d, 0xbc, 0x00,
+    0x00, 0x0d, 0xc6, 0x00, 0x00, 0x0d, 0xcc, 0x00, 0x00, 0x0d, 0xd5, 0x00,
+    0x00, 0x0d, 0xdd, 0x00, 0x00, 0x0d, 0xe3, 0x00, 0x00, 0x0d, 0xeb, 0x00,
+    0x00, 0x0d, 0xf0, 0x00, 0x00, 0x0d, 0xf6, 0x00, 0x00, 0x0d, 0xfe, 0x00,
+    0x00, 0x0e, 0x03, 0x00, 0x00, 0x0e, 0x0b, 0x00, 0x00, 0x0e, 0x13, 0x00,
+    0x00, 0x0e, 0x1a, 0x00, 0x00, 0x0e, 0x22, 0x00, 0x00, 0x0e, 0x2c, 0x00,
+    0x00, 0x0e, 0x31, 0x00, 0x00, 0x0e, 0x39, 0x00, 0x00, 0x0e, 0x3d, 0x00,
+    0x00, 0x0e, 0x43, 0x00, 0x00, 0x0e, 0x4c, 0x00, 0x00, 0x0e, 0x55, 0x00,
+    0x00, 0x0e, 0x5d, 0x00, 0x00, 0x0e, 0x63, 0x00, 0x00, 0x0e, 0x68, 0x00,
+    0x00, 0x0e, 0x6e, 0x00, 0x00, 0x0e, 0x73, 0x00, 0x00, 0x0e, 0x78, 0x00,
+    0x00, 0x0e, 0x7e, 0x00, 0x00, 0x0e, 0x83, 0x00, 0x00, 0x0e, 0x88, 0x00,
+    0x00, 0x0e, 0x90, 0x00, 0x00, 0x0e, 0x98, 0x00, 0x00, 0x0e, 0x9f, 0x00,
+    0x00, 0x0e, 0xa5, 0x00, 0x00, 0x0e, 0xac, 0x00, 0x00, 0x0e, 0xb3, 0x00,
+    0x00, 0x0e, 0xba, 0x00, 0x00, 0x0e, 0xc2, 0x00, 0x00, 0x0e, 0xcb, 0x00,
+    0x00, 0x0e, 0xd3, 0x00, 0x00, 0x0e, 0xd9, 0x00, 0x00, 0x0e, 0xde, 0x00,
+    0x00, 0x0e, 0xe4, 0x00, 0x00, 0x0e, 0xed, 0x00, 0x00, 0x0e, 0xf4, 0x00,
+    0x00, 0x0e, 0xfb, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x07, 0x00,
+    0x00, 0x0f, 0x10, 0x00, 0x00, 0x0f, 0x15, 0x00, 0x00, 0x0f, 0x1a, 0x00,
+    0x00, 0x0f, 0x24, 0x00, 0x00, 0x0f, 0x2c, 0x00, 0x00, 0x0f, 0x33, 0x00,
+    0x00, 0x0f, 0x3b, 0x00, 0x00, 0x0f, 0x45, 0x00, 0x00, 0x0f, 0x4a, 0x00,
+    0x00, 0x0f, 0x4f, 0x00, 0x00, 0x0f, 0x55, 0x00, 0x00, 0x0f, 0x5a, 0x00,
+    0x00, 0x0f, 0x5f, 0x00, 0x00, 0x0f, 0x66, 0x00, 0x00, 0x0f, 0x6e, 0x00,
+    0x00, 0x0f, 0x77, 0x00, 0x00, 0x0f, 0x7c, 0x00, 0x00, 0x0f, 0x83, 0x00,
+    0x00, 0x0f, 0x8b, 0x00, 0x00, 0x0f, 0x94, 0x00, 0x00, 0x0f, 0x9b, 0x00,
+    0x00, 0x0f, 0xa3, 0x00, 0x00, 0x0f, 0xac, 0x00, 0x00, 0x0f, 0xb4, 0x00,
+    0x00, 0x0f, 0xbd, 0x00, 0x00, 0x0f, 0xc8, 0x00, 0x00, 0x0f, 0xcf, 0x00,
+    0x00, 0x0f, 0xd5, 0x00, 0x00, 0x0f, 0xdc, 0x00, 0x00, 0x0f, 0xe3, 0x00,
+    0x00, 0x0f, 0xea, 0x00, 0x00, 0x0f, 0xee, 0x00, 0x00, 0x0f, 0xf6, 0x00,
+    0x00, 0x0f, 0xfd, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, 0x10, 0x0a, 0x00,
+    0x00, 0x10, 0x14, 0x00, 0x00, 0x10, 0x18, 0x00, 0x00, 0x10, 0x1d, 0x00,
+    0x00, 0x10, 0x23, 0x00, 0x00, 0x10, 0x2b, 0x00, 0x00, 0x10, 0x33, 0x00,
+    0x00, 0x10, 0x3d, 0x00, 0x00, 0x10, 0x46, 0x00, 0x00, 0x10, 0x4f, 0x00,
+    0x00, 0x10, 0x5a, 0x00, 0x00, 0x10, 0x63, 0x00, 0x00, 0x10, 0x69, 0x00,
+    0x00, 0x10, 0x6f, 0x00, 0x00, 0x10, 0x75, 0x00, 0x00, 0x10, 0x7b, 0x00,
+    0x00, 0x10, 0x80, 0x00, 0x00, 0x10, 0x86, 0x00, 0x00, 0x10, 0x8c, 0x00,
+    0x00, 0x10, 0x91, 0x00, 0x00, 0x10, 0x9b, 0x00, 0x00, 0x10, 0xa2, 0x00,
+    0x00, 0x10, 0xac, 0x00, 0x00, 0x10, 0xb2, 0x00, 0x00, 0x10, 0xbb, 0x00,
+    0x00, 0x10, 0xc2, 0x00, 0x00, 0x10, 0xc9, 0x00, 0x00, 0x10, 0xd3, 0x00,
+    0x00, 0x10, 0xd9, 0x00, 0x00, 0x10, 0xde, 0x00, 0x00, 0x10, 0xe6, 0x00,
+    0x00, 0x10, 0xee, 0x00, 0x00, 0x10, 0xf7, 0x00, 0x00, 0x10, 0xfc, 0x00,
+    0x00, 0x11, 0x02, 0x00, 0x00, 0x11, 0x0b, 0x00, 0x00, 0x11, 0x15, 0x00,
+    0x00, 0x11, 0x19, 0x00, 0x00, 0x11, 0x20, 0x00, 0x00, 0x11, 0x27, 0x00,
+    0x00, 0x11, 0x2d, 0x00, 0x00, 0x11, 0x31, 0x00, 0x00, 0x11, 0x3a, 0x00,
+    0x00, 0x11, 0x45, 0x00, 0x00, 0x11, 0x4a, 0x00, 0x00, 0x11, 0x4f, 0x00,
+    0x00, 0x11, 0x57, 0x00, 0x00, 0x11, 0x60, 0x00, 0x00, 0x11, 0x66, 0x00,
+    0x00, 0x11, 0x6b, 0x00, 0x00, 0x11, 0x74, 0x00, 0x00, 0x11, 0x79, 0x00,
+    0x00, 0x11, 0x7f, 0x00, 0x00, 0x11, 0x84, 0x00, 0x00, 0x11, 0x8b, 0x00,
+    0x00, 0x11, 0x95, 0x00, 0x00, 0x11, 0x9c, 0x00, 0x00, 0x11, 0xa4, 0x00,
+    0x00, 0x11, 0xab, 0x00, 0x00, 0x11, 0xb1, 0x00, 0x00, 0x11, 0xba, 0x00,
+    0x00, 0x11, 0xc4, 0x00, 0x00, 0x11, 0xcb, 0x00, 0x00, 0x11, 0xd5, 0x00,
+    0x00, 0x11, 0xdd, 0x00, 0x00, 0x11, 0xe4, 0x00, 0x00, 0x11, 0xea, 0x00,
+    0x00, 0x11, 0xf0, 0x00, 0x00, 0x11, 0xf7, 0x00, 0x00, 0x12, 0x02, 0x00,
+    0x00, 0x12, 0x0a, 0x00, 0x00, 0x12, 0x15, 0x00, 0x00, 0x12, 0x19, 0x00,
+    0x00, 0x12, 0x20, 0x00, 0x00, 0x12, 0x27, 0x00, 0x00, 0x12, 0x2d, 0x00,
+    0x00, 0x12, 0x34, 0x00, 0x00, 0x12, 0x3c, 0x00, 0x00, 0x12, 0x41, 0x00,
+    0x00, 0x12, 0x46, 0x00, 0x00, 0x12, 0x4b, 0x00, 0x00, 0x12, 0x57, 0x00,
+    0x00, 0x12, 0x5f, 0x00, 0x00, 0x12, 0x67, 0x00, 0x00, 0x12, 0x6f, 0x00,
+    0x00, 0x12, 0x78, 0x00, 0x00, 0x12, 0x84, 0x00, 0x00, 0x12, 0x89, 0x00,
+    0x00, 0x12, 0x8e, 0x00, 0x00, 0x12, 0x94, 0x00, 0x00, 0x12, 0x99, 0x00,
+    0x00, 0x12, 0x9d, 0x00, 0x00, 0x12, 0xa7, 0x00, 0x00, 0x12, 0xae, 0x00,
+    0x00, 0x12, 0xb9, 0x00, 0x00, 0x12, 0xc0, 0x00, 0x00, 0x12, 0xcb, 0x00,
+    0x00, 0x12, 0xd3, 0x00, 0x00, 0x12, 0xdb, 0x00, 0x00, 0x12, 0xe5, 0x00,
+    0x00, 0x12, 0xeb, 0x00, 0x00, 0x12, 0xf1, 0x00, 0x00, 0x12, 0xf8, 0x00,
+    0x00, 0x12, 0xfd, 0x00, 0x00, 0x13, 0x04, 0x00, 0x00, 0x13, 0x0c, 0x00,
+    0x00, 0x13, 0x13, 0x00, 0x00, 0x13, 0x19, 0x00, 0x00, 0x13, 0x23, 0x00,
+    0x00, 0x13, 0x29, 0x00, 0x00, 0x13, 0x2d, 0x00, 0x00, 0x13, 0x37, 0x00,
+    0x00, 0x13, 0x41, 0x00, 0x00, 0x13, 0x45, 0x00, 0x00, 0x13, 0x4b, 0x00,
+    0x00, 0x13, 0x51, 0x00, 0x00, 0x13, 0x59, 0x00, 0x00, 0x13, 0x63, 0x00,
+    0x00, 0x13, 0x6a, 0x00, 0x00, 0x13, 0x72, 0x00, 0x00, 0x13, 0x77, 0x00,
+    0x00, 0x13, 0x7c, 0x00, 0x00, 0x13, 0x82, 0x00, 0x00, 0x13, 0x8a, 0x00,
+    0x00, 0x13, 0x90, 0x00, 0x00, 0x13, 0x9a, 0x00, 0x00, 0x13, 0xa0, 0x00,
+    0x00, 0x13, 0xa7, 0x00, 0x00, 0x13, 0xac, 0x00, 0x00, 0x13, 0xb4, 0x00,
+    0x00, 0x13, 0xbb, 0x00, 0x00, 0x13, 0xc0, 0x00, 0x00, 0x13, 0xc6, 0x00,
+    0x00, 0x13, 0xcf, 0x00, 0x00, 0x13, 0xd8, 0x00, 0x00, 0x13, 0xe0, 0x00,
+    0x00, 0x13, 0xeb, 0x00, 0x00, 0x13, 0xf3, 0x00, 0x00, 0x13, 0xf8, 0x00,
+    0x00, 0x13, 0xff, 0x00, 0x00, 0x14, 0x07, 0x00, 0x00, 0x14, 0x0e, 0x00,
+    0x00, 0x14, 0x16, 0x00, 0x00, 0x14, 0x1b, 0x00, 0x00, 0x14, 0x24, 0x00,
+    0x00, 0x14, 0x29, 0x00, 0x00, 0x14, 0x30, 0x00, 0x00, 0x14, 0x36, 0x00,
+    0x00, 0x14, 0x3d, 0x00, 0x00, 0x14, 0x49, 0x00, 0x00, 0x14, 0x4e, 0x00,
+    0x00, 0x14, 0x56, 0x00, 0x00, 0x14, 0x60, 0x00, 0x00, 0x14, 0x68, 0x00,
+    0x00, 0x14, 0x70, 0x00, 0x00, 0x14, 0x78, 0x00, 0x00, 0x14, 0x7e, 0x00,
+    0x00, 0x14, 0x83, 0x00, 0x00, 0x14, 0x8a, 0x00, 0x00, 0x14, 0x8f, 0x00,
+    0x00, 0x14, 0x95, 0x00, 0x00, 0x14, 0x9c, 0x00, 0x00, 0x14, 0xa5, 0x00,
+    0x00, 0x14, 0xae, 0x00, 0x00, 0x14, 0xb3, 0x00, 0x00, 0x14, 0xb8, 0x00,
+    0x00, 0x14, 0xbe, 0x00, 0x00, 0x14, 0xc3, 0x00, 0x00, 0x14, 0xce, 0x00,
+    0x00, 0x14, 0xd6, 0x00, 0x00, 0x14, 0xde, 0x00, 0x00, 0x14, 0xe5, 0x00,
+    0x00, 0x14, 0xec, 0x00, 0x00, 0x14, 0xf3, 0x00, 0x00, 0x14, 0xfb, 0x00,
+    0x00, 0x15, 0x05, 0x00, 0x00, 0x15, 0x0b, 0x00, 0x00, 0x15, 0x11, 0x00,
+    0x00, 0x15, 0x18, 0x00, 0x00, 0x15, 0x20, 0x00, 0x00, 0x15, 0x29, 0x00,
+    0x00, 0x15, 0x36, 0x00, 0x00, 0x15, 0x3f, 0x00, 0x00, 0x15, 0x47, 0x00,
+    0x00, 0x15, 0x50, 0x00, 0x00, 0x15, 0x5a, 0x00, 0x00, 0x15, 0x60, 0x00,
+    0x00, 0x15, 0x6b, 0x00, 0x00, 0x15, 0x70, 0x00, 0x00, 0x15, 0x79, 0x00,
+    0x00, 0x15, 0x81, 0x00, 0x00, 0x15, 0x8d, 0x00, 0x00, 0x15, 0x95, 0x00,
+    0x00, 0x15, 0x9d, 0x00, 0x00, 0x15, 0xa5, 0x00, 0x00, 0x15, 0xae, 0x00,
+    0x00, 0x15, 0xb6, 0x00, 0x00, 0x15, 0xc1, 0x00, 0x00, 0x15, 0xcc, 0x00,
+    0x00, 0x15, 0xd7, 0x00, 0x00, 0x15, 0xe0, 0x00, 0x00, 0x15, 0xe8, 0x00,
+    0x00, 0x15, 0xee, 0x00, 0x00, 0x15, 0xf4, 0x00, 0x00, 0x15, 0xf9, 0x00,
+    0x00, 0x15, 0xff, 0x00, 0x00, 0x16, 0x04, 0x00, 0x00, 0x16, 0x08, 0x00,
+    0x00, 0x16, 0x0d, 0x00, 0x00, 0x16, 0x12, 0x00, 0x00, 0x16, 0x19, 0x00,
+    0x00, 0x16, 0x20, 0x00, 0x00, 0x16, 0x2a, 0x00, 0x00, 0x16, 0x33, 0x00,
+    0x00, 0x16, 0x3d, 0x00, 0x00, 0x16, 0x46, 0x00, 0x00, 0x16, 0x50, 0x00,
+    0x00, 0x16, 0x5a, 0x00, 0x00, 0x16, 0x65, 0x00, 0x00, 0x16, 0x6a, 0x00,
+    0x00, 0x16, 0x73, 0x00, 0x00, 0x16, 0x78, 0x00, 0x00, 0x16, 0x7d, 0x00,
+    0x00, 0x16, 0x82, 0x00, 0x00, 0x16, 0x8a, 0x00, 0x00, 0x16, 0x91, 0x00,
+    0x00, 0x16, 0x99, 0x00, 0x00, 0x16, 0x9e, 0x00, 0x00, 0x16, 0xa5, 0x00,
+    0x00, 0x16, 0xaf, 0x00, 0x00, 0x16, 0xbd, 0x00, 0x00, 0x16, 0xc5, 0x00,
+    0x00, 0x16, 0xcd, 0x00, 0x00, 0x16, 0xd2, 0x00, 0x00, 0x16, 0xdb, 0x00,
+    0x00, 0x16, 0xe0, 0x00, 0x00, 0x16, 0xe6, 0x00, 0x00, 0x16, 0xee, 0x00,
+    0x00, 0x16, 0xf5, 0x00, 0x00, 0x16, 0xfb, 0x00, 0x00, 0x17, 0x02, 0x00,
+    0x00, 0x17, 0x06, 0x00, 0x00, 0x17, 0x0c, 0x00, 0x00, 0x17, 0x10, 0x00,
+    0x00, 0x17, 0x1b, 0x00, 0x00, 0x17, 0x25, 0x00, 0x00, 0x17, 0x2b, 0x00,
+    0x00, 0x17, 0x32, 0x00, 0x00, 0x17, 0x39, 0x00, 0x00, 0x17, 0x3e, 0x00,
+    0x00, 0x17, 0x45, 0x00, 0x00, 0x17, 0x4e, 0x00, 0x00, 0x17, 0x56, 0x00,
+    0x00, 0x17, 0x5e, 0x00, 0x00, 0x17, 0x65, 0x00, 0x00, 0x17, 0x6a, 0x00,
+    0x00, 0x17, 0x70, 0x00, 0x00, 0x17, 0x75, 0x00, 0x00, 0x17, 0x7c, 0x00,
+    0x00, 0x17, 0x86, 0x00, 0x00, 0x17, 0x8a, 0x00, 0x00, 0x17, 0x8e, 0x00,
+    0x00, 0x17, 0x95, 0x00, 0x00, 0x17, 0x9c, 0x00, 0x00, 0x17, 0xa3, 0x00,
+    0x00, 0x17, 0xab, 0x00, 0x00, 0x17, 0xb3, 0x00, 0x00, 0x17, 0xbc, 0x00,
+    0x00, 0x17, 0xc5, 0x00, 0x00, 0x17, 0xca, 0x00, 0x00, 0x17, 0xd1, 0x00,
+    0x00, 0x17, 0xd9, 0x00, 0x00, 0x17, 0xe1, 0x00, 0x00, 0x17, 0xed, 0x00,
+    0x00, 0x17, 0xf5, 0x00, 0x00, 0x17, 0xfa, 0x00, 0x00, 0x18, 0x00, 0x00,
+    0x00, 0x18, 0x06, 0x00, 0x00, 0x18, 0x0b, 0x00, 0x00, 0x18, 0x14, 0x00,
+    0x00, 0x18, 0x1e, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x18, 0x31, 0x00,
+    0x00, 0x18, 0x38, 0x00, 0x00, 0x18, 0x41, 0x00, 0x00, 0x18, 0x46, 0x00,
+    0x00, 0x18, 0x4e, 0x00, 0x00, 0x18, 0x52, 0x00, 0x00, 0x18, 0x58, 0x00,
+    0x00, 0x18, 0x5c, 0x00, 0x00, 0x18, 0x64, 0x00, 0x00, 0x18, 0x6a, 0x00,
+    0x00, 0x18, 0x6f, 0x00, 0x00, 0x18, 0x75, 0x00, 0x00, 0x18, 0x79, 0x00,
+    0x00, 0x18, 0x83, 0x00, 0x00, 0x18, 0x8c, 0x00, 0x00, 0x18, 0x95, 0x00,
+    0x00, 0x18, 0x9d, 0x00, 0x00, 0x18, 0xa4, 0x00, 0x00, 0x18, 0xac, 0x00,
+    0x00, 0x18, 0xb3, 0x00, 0x00, 0x18, 0xb6, 0x00, 0x00, 0x18, 0xbd, 0x00,
+    0x00, 0x18, 0xc5, 0x00, 0x00, 0x18, 0xcc, 0x00, 0x00, 0x18, 0xd5, 0x00,
+    0x00, 0x18, 0xda, 0x00, 0x00, 0x18, 0xe0, 0x00, 0x00, 0x18, 0xe6, 0x00,
+    0x00, 0x18, 0xeb, 0x00, 0x00, 0x18, 0xf0, 0x00, 0x00, 0x18, 0xf7, 0x00,
+    0x00, 0x18, 0xfc, 0x00, 0x00, 0x19, 0x01, 0x00, 0x00, 0x19, 0x08, 0x00,
+    0x00, 0x19, 0x0f, 0x00, 0x00, 0x19, 0x16, 0x00, 0x00, 0x19, 0x20, 0x00,
+    0x00, 0x19, 0x29, 0x00, 0x00, 0x19, 0x30, 0x00, 0x00, 0x19, 0x39, 0x00,
+    0x00, 0x19, 0x40, 0x00, 0x00, 0x19, 0x48, 0x00, 0x00, 0x19, 0x50, 0x00,
+    0x00, 0x19, 0x56, 0x00, 0x00, 0x19, 0x5c, 0x00, 0x00, 0x19, 0x63, 0x00,
+    0x00, 0x19, 0x6b, 0x00, 0x00, 0x19, 0x70, 0x00, 0x00, 0x19, 0x75, 0x00,
+    0x00, 0x19, 0x7c, 0x00, 0x00, 0x19, 0x82, 0x00, 0x00, 0x19, 0x89, 0x00,
+    0x00, 0x19, 0x91, 0x00, 0x00, 0x19, 0x97, 0x00, 0x00, 0x19, 0x9c, 0x00,
+    0x00, 0x19, 0xa3, 0x00, 0x00, 0x19, 0xab, 0x00, 0x00, 0x19, 0xb1, 0x00,
+    0x00, 0x19, 0xb7, 0x00, 0x00, 0x19, 0xbd, 0x00, 0x00, 0x19, 0xc7, 0x00,
+    0x00, 0x19, 0xcd, 0x00, 0x00, 0x19, 0xd6, 0x00, 0x00, 0x19, 0xde, 0x00,
+    0x00, 0x19, 0xe8, 0x00, 0x00, 0x19, 0xf0, 0x00, 0x00, 0x19, 0xf7, 0x00,
+    0x00, 0x19, 0xfe, 0x00, 0x00, 0x1a, 0x06, 0x00, 0x00, 0x1a, 0x0b, 0x00,
+    0x00, 0x1a, 0x11, 0x00, 0x00, 0x1a, 0x17, 0x00, 0x00, 0x1a, 0x1d, 0x00,
+    0x00, 0x1a, 0x23, 0x00, 0x00, 0x1a, 0x2b, 0x00, 0x00, 0x1a, 0x34, 0x00,
+    0x00, 0x1a, 0x3c, 0x00, 0x00, 0x1a, 0x45, 0x00, 0x00, 0x1a, 0x4e, 0x00,
+    0x00, 0x1a, 0x58, 0x00, 0x00, 0x1a, 0x60, 0x00, 0x00, 0x1a, 0x69, 0x00,
+    0x00, 0x1a, 0x77, 0x00, 0x00, 0x1a, 0x7f, 0x00, 0x00, 0x1a, 0x86, 0x00,
+    0x00, 0x1a, 0x8e, 0x00, 0x00, 0x1a, 0x96, 0x00, 0x00, 0x1a, 0x9d, 0x00,
+    0x00, 0x1a, 0xa5, 0x00, 0x00, 0x1a, 0xac, 0x00, 0x00, 0x1a, 0xb6, 0x00,
+    0x00, 0x1a, 0xc0, 0x00, 0x00, 0x1a, 0xc6, 0x00, 0x00, 0x1a, 0xcd, 0x00,
+    0x00, 0x1a, 0xd8, 0x00, 0x00, 0x1a, 0xe2, 0x00, 0x00, 0x1a, 0xea, 0x00,
+    0x00, 0x1a, 0xf2, 0x00, 0x00, 0x1a, 0xfb, 0x00, 0x00, 0x1b, 0x03, 0x00,
+    0x00, 0x1b, 0x0b, 0x00, 0x00, 0x1b, 0x18, 0x00, 0x00, 0x1b, 0x21, 0x00,
+    0x00, 0x1b, 0x29, 0x00, 0x00, 0x1b, 0x30, 0x00, 0x00, 0x1b, 0x39, 0x00,
+    0x00, 0x1b, 0x45, 0x00, 0x00, 0x1b, 0x4b, 0x00, 0x00, 0x1b, 0x54, 0x00,
+    0x00, 0x1b, 0x59, 0x00, 0x00, 0x1b, 0x5f, 0x00, 0x00, 0x1b, 0x68, 0x00,
+    0x00, 0x1b, 0x6e, 0x00, 0x00, 0x1b, 0x76, 0x00, 0x00, 0x1b, 0x7e, 0x00,
+    0x00, 0x1b, 0x83, 0x00, 0x00, 0x1b, 0x89, 0x00, 0x00, 0x1b, 0x8d, 0x00,
+    0x00, 0x1b, 0x94, 0x00, 0x00, 0x1b, 0x98, 0x00, 0x00, 0x1b, 0x9e, 0x00,
+    0x00, 0x1b, 0xa4, 0x00, 0x00, 0x1b, 0xaa, 0x00, 0x00, 0x1b, 0xb4, 0x00,
+    0x00, 0x1b, 0xbb, 0x00, 0x00, 0x1b, 0xc6, 0x00, 0x00, 0x1b, 0xcd, 0x00,
+    0x00, 0x1b, 0xd3, 0x00, 0x00, 0x1b, 0xd9, 0x00, 0x00, 0x1b, 0xe0, 0x00,
+    0x00, 0x1b, 0xe9, 0x00, 0x00, 0x1b, 0xf0, 0x00, 0x00, 0x1b, 0xfb, 0x00,
+    0x00, 0x1c, 0x06, 0x00, 0x00, 0x1c, 0x0d, 0x00, 0x00, 0x1c, 0x13, 0x00,
+    0x00, 0x1c, 0x1b, 0x00, 0x00, 0x1c, 0x21, 0x00, 0x00, 0x1c, 0x26, 0x00,
+    0x00, 0x1c, 0x2e, 0x00, 0x00, 0x1c, 0x35, 0x00, 0x00, 0x1c, 0x3b, 0x00,
+    0x00, 0x1c, 0x43, 0x00, 0x00, 0x1c, 0x49, 0x00, 0x00, 0x1c, 0x4f, 0x00,
+    0x00, 0x1c, 0x59, 0x00, 0x00, 0x1c, 0x63, 0x00, 0x00, 0x1c, 0x6d, 0x00,
+    0x00, 0x1c, 0x75, 0x00, 0x00, 0x1c, 0x7a, 0x00, 0x00, 0x1c, 0x81, 0x00,
+    0x00, 0x1c, 0x8a, 0x00, 0x00, 0x1c, 0x90, 0x00, 0x00, 0x1c, 0x98, 0x00,
+    0x00, 0x1c, 0x9f, 0x00, 0x00, 0x1c, 0xa7, 0x00, 0x00, 0x1c, 0xae, 0x00,
+    0x00, 0x1c, 0xb5, 0x00, 0x00, 0x1c, 0xba, 0x00, 0x00, 0x1c, 0xc3, 0x00,
+    0x00, 0x1c, 0xcb, 0x00, 0x00, 0x1c, 0xd1, 0x00, 0x00, 0x1c, 0xd6, 0x00,
+    0x00, 0x1c, 0xdb, 0x00, 0x00, 0x1c, 0xe0, 0x00, 0x00, 0x1c, 0xe5, 0x00,
+    0x00, 0x1c, 0xed, 0x00, 0x00, 0x1c, 0xf3, 0x00, 0x00, 0x1c, 0xfd, 0x00,
+    0x00, 0x1d, 0x04, 0x00, 0x00, 0x1d, 0x08, 0x00, 0x00, 0x1d, 0x0d, 0x00,
+    0x00, 0x1d, 0x12, 0x00, 0x00, 0x1d, 0x19, 0x00, 0x00, 0x1d, 0x21, 0x00,
+    0x00, 0x1d, 0x28, 0x00, 0x00, 0x1d, 0x2e, 0x00, 0x00, 0x1d, 0x34, 0x00,
+    0x00, 0x1d, 0x3a, 0x00, 0x00, 0x1d, 0x3f, 0x00, 0x00, 0x1d, 0x46, 0x00,
+    0x00, 0x1d, 0x50, 0x00, 0x00, 0x1d, 0x5a, 0x00, 0x00, 0x1d, 0x5f, 0x00,
+    0x00, 0x1d, 0x67, 0x00, 0x00, 0x1d, 0x74, 0x00, 0x00, 0x1d, 0x7e, 0x00,
+    0x00, 0x1d, 0x85, 0x00, 0x00, 0x1d, 0x8d, 0x00, 0x00, 0x1d, 0x93, 0x00,
+    0x00, 0x1d, 0x9a, 0x00, 0x00, 0x1d, 0xa1, 0x00, 0x00, 0x1d, 0xa7, 0x00,
+    0x00, 0x1d, 0xae, 0x00, 0x00, 0x1d, 0xb9, 0x00, 0x00, 0x1d, 0xc0, 0x00,
+    0x00, 0x1d, 0xc7, 0x00, 0x00, 0x1d, 0xcc, 0x00, 0x00, 0x1d, 0xd3, 0x00,
+    0x00, 0x1d, 0xd9, 0x00, 0x00, 0x1d, 0xdf, 0x00, 0x00, 0x1d, 0xe9, 0x00,
+    0x00, 0x1d, 0xf3, 0x00, 0x00, 0x1d, 0xfa, 0x00, 0x00, 0x1e, 0x02, 0x00,
+    0x00, 0x1e, 0x07, 0x00, 0x00, 0x1e, 0x0d, 0x00, 0x00, 0x1e, 0x18, 0x00,
+    0x00, 0x1e, 0x1e, 0x00, 0x00, 0x1e, 0x25, 0x00, 0x00, 0x1e, 0x2a, 0x00,
+    0x00, 0x1e, 0x2f, 0x00, 0x00, 0x1e, 0x35, 0x00, 0x00, 0x1e, 0x3b, 0x00,
+    0x00, 0x1e, 0x42, 0x00, 0x00, 0x1e, 0x48, 0x00, 0x00, 0x1e, 0x4d, 0x00,
+    0x00, 0x1e, 0x56, 0x00, 0x00, 0x1e, 0x5c, 0x00, 0x00, 0x1e, 0x65, 0x00,
+    0x00, 0x1e, 0x6d, 0x00, 0x00, 0x1e, 0x73, 0x00, 0x00, 0x1e, 0x79, 0x00,
+    0x00, 0x1e, 0x80, 0x00, 0x00, 0x1e, 0x88, 0x00, 0x00, 0x1e, 0x8e, 0x00,
+    0x00, 0x1e, 0x96, 0x00, 0x00, 0x1e, 0x9d, 0x00, 0x00, 0x1e, 0xa3, 0x00,
+    0x00, 0x1e, 0xaa, 0x00, 0x00, 0x1e, 0xb2, 0x00, 0x00, 0x1e, 0xb8, 0x00,
+    0x00, 0x1e, 0xbf, 0x00, 0x00, 0x1e, 0xc8, 0x00, 0x00, 0x1e, 0xce, 0x00,
+    0x00, 0x1e, 0xd3, 0x00, 0x00, 0x1e, 0xd9, 0x00, 0x00, 0x1e, 0xe0, 0x00,
+    0x00, 0x1e, 0xe9, 0x00, 0x00, 0x1e, 0xf1, 0x00, 0x00, 0x1e, 0xf6, 0x00,
+    0x00, 0x1e, 0xfc, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x07, 0x00,
+    0x00, 0x1f, 0x0c, 0x00, 0x00, 0x1f, 0x11, 0x00, 0x00, 0x1f, 0x15, 0x00,
+    0x00, 0x1f, 0x1a, 0x00, 0x00, 0x1f, 0x20, 0x00, 0x00, 0x1f, 0x24, 0x00,
+    0x00, 0x1f, 0x2c, 0x00, 0x00, 0x1f, 0x33, 0x00, 0x00, 0x1f, 0x3b, 0x00,
+    0x00, 0x1f, 0x45, 0x00, 0x00, 0x1f, 0x51, 0x00, 0x00, 0x1f, 0x59, 0x00,
+    0x00, 0x1f, 0x60, 0x00, 0x00, 0x1f, 0x67, 0x00, 0x00, 0x1f, 0x6e, 0x00,
+    0x00, 0x1f, 0x78, 0x00, 0x00, 0x1f, 0x7f, 0x00, 0x00, 0x1f, 0x88, 0x00,
+    0x00, 0x1f, 0x8f, 0x00, 0x00, 0x1f, 0x98, 0x00, 0x00, 0x1f, 0x9f, 0x00,
+    0x00, 0x1f, 0xaa, 0x00, 0x00, 0x1f, 0xb1, 0x00, 0x00, 0x1f, 0xbb, 0x00,
+    0x00, 0x1f, 0xc4, 0x00, 0x00, 0x1f, 0xcb, 0x00, 0x00, 0x1f, 0xd2, 0x00,
+    0x00, 0x1f, 0xda, 0x00, 0x00, 0x1f, 0xe1, 0x00, 0x00, 0x1f, 0xe9, 0x00,
+    0x00, 0x1f, 0xef, 0x00, 0x00, 0x1f, 0xf8, 0x00, 0x00, 0x1f, 0xff, 0x00,
+    0x00, 0x20, 0x06, 0x00, 0x00, 0x20, 0x0d, 0x00, 0x00, 0x20, 0x17, 0x00,
+    0x00, 0x20, 0x20, 0x00, 0x00, 0x20, 0x29, 0x00, 0x00, 0x20, 0x2e, 0x00,
+    0x00, 0x20, 0x33, 0x00, 0x00, 0x20, 0x3c, 0x00, 0x00, 0x20, 0x44, 0x00,
+    0x00, 0x20, 0x51, 0x00, 0x00, 0x20, 0x58, 0x00, 0x00, 0x20, 0x5d, 0x00,
+    0x00, 0x20, 0x62, 0x00, 0x00, 0x20, 0x68, 0x00, 0x00, 0x20, 0x70, 0x00,
+    0x00, 0x20, 0x76, 0x00, 0x00, 0x20, 0x7b, 0x00, 0x00, 0x20, 0x85, 0x00,
+    0x00, 0x20, 0x8d, 0x00, 0x00, 0x20, 0x92, 0x00, 0x00, 0x20, 0x9c, 0x00,
+    0x00, 0x20, 0xa3, 0x00, 0x00, 0x20, 0xab, 0x00, 0x00, 0x20, 0xb4, 0x00,
+    0x00, 0x20, 0xbc, 0x00, 0x00, 0x20, 0xc5, 0x00, 0x00, 0x20, 0xcb, 0x00,
+    0x00, 0x20, 0xd5, 0x00, 0x00, 0x20, 0xdb, 0x00, 0x00, 0x20, 0xe3, 0x00,
+    0x00, 0x20, 0xed, 0x00, 0x00, 0x20, 0xf9, 0x00, 0x00, 0x21, 0x01, 0x00,
+    0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x11, 0x00, 0x00, 0x21, 0x18, 0x00,
+    0x00, 0x21, 0x1f, 0x00, 0x00, 0x21, 0x24, 0x00, 0x00, 0x21, 0x2b, 0x00,
+    0x00, 0x21, 0x30, 0x00, 0x00, 0x21, 0x38, 0x00, 0x00, 0x21, 0x3e, 0x00,
+    0x00, 0x21, 0x47, 0x00, 0x00, 0x21, 0x4f, 0x00, 0x00, 0x21, 0x5a, 0x00,
+    0x00, 0x21, 0x65, 0x00, 0x00, 0x21, 0x6d, 0x00, 0x00, 0x21, 0x72, 0x00,
+    0x00, 0x21, 0x7c, 0x00, 0x00, 0x21, 0x85, 0x00, 0x00, 0x21, 0x8e, 0x00,
+    0x00, 0x21, 0x96, 0x00, 0x00, 0x21, 0x9f, 0x00, 0x00, 0x21, 0xa4, 0x00,
+    0x00, 0x21, 0xa9, 0x00, 0x00, 0x21, 0xb2, 0x00, 0x00, 0x21, 0xbb, 0x00,
+    0x00, 0x21, 0xbf, 0x00, 0x00, 0x21, 0xcb, 0x00, 0x00, 0x21, 0xd0, 0x00,
+    0x00, 0x21, 0xd9, 0x00, 0x00, 0x21, 0xe0, 0x00, 0x00, 0x21, 0xe9, 0x00,
+    0x00, 0x21, 0xef, 0x00, 0x00, 0x21, 0xf8, 0x00, 0x00, 0x22, 0x02, 0x00,
+    0x00, 0x22, 0x0b, 0x00, 0x00, 0x22, 0x11, 0x00, 0x00, 0x22, 0x1a, 0x00,
+    0x00, 0x22, 0x23, 0x00, 0x00, 0x22, 0x2b, 0x00, 0x00, 0x22, 0x31, 0x00,
+    0x00, 0x22, 0x39, 0x00, 0x00, 0x22, 0x3e, 0x00, 0x00, 0x22, 0x44, 0x00,
+    0x00, 0x22, 0x49, 0x00, 0x00, 0x22, 0x51, 0x00, 0x00, 0x22, 0x5a, 0x00,
+    0x00, 0x22, 0x61, 0x00, 0x00, 0x22, 0x66, 0x00, 0x00, 0x22, 0x72, 0x00,
+    0x00, 0x22, 0x77, 0x00, 0x00, 0x22, 0x7b, 0x00, 0x00, 0x22, 0x85, 0x00,
+    0x00, 0x22, 0x8e, 0x00, 0x00, 0x22, 0x93, 0x00, 0x00, 0x22, 0x99, 0x00,
+    0x00, 0x22, 0xa0, 0x00, 0x00, 0x22, 0xa6, 0x00, 0x00, 0x22, 0xac, 0x00,
+    0x00, 0x22, 0xb3, 0x00, 0x00, 0x22, 0xbb, 0x00, 0x00, 0x22, 0xc0, 0x00,
+    0x00, 0x22, 0xc8, 0x00, 0x00, 0x22, 0xd1, 0x00, 0x00, 0x22, 0xd8, 0x00,
+    0x00, 0x22, 0xdd, 0x00, 0x00, 0x22, 0xe3, 0x00, 0x00, 0x22, 0xed, 0x00,
+    0x00, 0x22, 0xf5, 0x00, 0x00, 0x22, 0xfc, 0x00, 0x00, 0x23, 0x02, 0x00,
+    0x00, 0x23, 0x0d, 0x00, 0x00, 0x23, 0x12, 0x00, 0x00, 0x23, 0x17, 0x00,
+    0x00, 0x23, 0x1f, 0x00, 0x00, 0x23, 0x2a, 0x00, 0x00, 0x23, 0x34, 0x00,
+    0x00, 0x23, 0x3e, 0x00, 0x00, 0x23, 0x45, 0x00, 0x00, 0x23, 0x4d, 0x00,
+    0x00, 0x23, 0x54, 0x00, 0x00, 0x23, 0x5b, 0x00, 0x00, 0x23, 0x62, 0x00,
+    0x00, 0x23, 0x69, 0x00, 0x00, 0x23, 0x70, 0x00, 0x00, 0x23, 0x7b, 0x00,
+    0x00, 0x23, 0x80, 0x00, 0x00, 0x23, 0x85, 0x00, 0x00, 0x23, 0x8b, 0x00,
+    0x00, 0x23, 0x90, 0x00, 0x00, 0x23, 0x97, 0x00, 0x00, 0x23, 0x9f, 0x00,
+    0x00, 0x23, 0xa6, 0x00, 0x00, 0x23, 0xae, 0x00, 0x00, 0x23, 0xb5, 0x00,
+    0x00, 0x23, 0xba, 0x00, 0x00, 0x23, 0xc0, 0x00, 0x00, 0x23, 0xc7, 0x00,
+    0x00, 0x23, 0xcf, 0x00, 0x00, 0x23, 0xda, 0x00, 0x00, 0x23, 0xe5, 0x00,
+    0x00, 0x23, 0xea, 0x00, 0x00, 0x23, 0xf2, 0x00, 0x00, 0x23, 0xf7, 0x00,
+    0x00, 0x24, 0x01, 0x00, 0x00, 0x24, 0x07, 0x00, 0x00, 0x24, 0x0d, 0x00,
+    0x00, 0x24, 0x13, 0x00, 0x00, 0x24, 0x1d, 0x00, 0x00, 0x24, 0x26, 0x00,
+    0x00, 0x24, 0x2b, 0x00, 0x00, 0x24, 0x30, 0x00, 0x00, 0x24, 0x36, 0x00,
+    0x00, 0x24, 0x3d, 0x00, 0x00, 0x24, 0x43, 0x00, 0x00, 0x24, 0x49, 0x00,
+    0x00, 0x24, 0x50, 0x00, 0x00, 0x24, 0x55, 0x00, 0x00, 0x24, 0x5c, 0x00,
+    0x00, 0x24, 0x61, 0x00, 0x00, 0x24, 0x69, 0x00, 0x00, 0x24, 0x6f, 0x00,
+    0x00, 0x24, 0x76, 0x00, 0x00, 0x24, 0x7c, 0x00, 0x00, 0x24, 0x83, 0x00,
+    0x00, 0x24, 0x8e, 0x00, 0x00, 0x24, 0x97, 0x00, 0x00, 0x24, 0x9e, 0x00,
+    0x00, 0x24, 0xa5, 0x00, 0x00, 0x24, 0xaa, 0x00, 0x00, 0x24, 0xb2, 0x00,
+    0x00, 0x24, 0xb9, 0x00, 0x00, 0x24, 0xbf, 0x00, 0x00, 0x24, 0xc6, 0x00,
+    0x00, 0x24, 0xcd, 0x00, 0x00, 0x24, 0xd5, 0x00, 0x00, 0x24, 0xdf, 0x00,
+    0x00, 0x24, 0xe8, 0x00, 0x00, 0x24, 0xf0, 0x00, 0x00, 0x24, 0xf6, 0x00,
+    0x00, 0x24, 0xfc, 0x00, 0x00, 0x25, 0x05, 0x00, 0x00, 0x25, 0x0c, 0x00,
+    0x00, 0x25, 0x16, 0x00, 0x00, 0x25, 0x20, 0x00, 0x00, 0x25, 0x2a, 0x00,
+    0x00, 0x25, 0x2f, 0x00, 0x00, 0x25, 0x34, 0x00, 0x00, 0x25, 0x39, 0x00,
+    0x00, 0x25, 0x3e, 0x00, 0x00, 0x25, 0x44, 0x00, 0x00, 0x25, 0x4b, 0x00,
+    0x00, 0x25, 0x51, 0x00, 0x00, 0x25, 0x5a, 0x00, 0x00, 0x25, 0x5f, 0x00,
+    0x00, 0x25, 0x69, 0x00, 0x00, 0x25, 0x72, 0x00, 0x00, 0x25, 0x7c, 0x00,
+    0x00, 0x25, 0x84, 0x00, 0x00, 0x25, 0x8d, 0x00, 0x00, 0x25, 0x96, 0x00,
+    0x00, 0x25, 0x9d, 0x00, 0x00, 0x25, 0xa7, 0x00, 0x00, 0x25, 0xb0, 0x00,
+    0x00, 0x25, 0xb8, 0x00, 0x00, 0x25, 0xc4, 0x00, 0x00, 0x25, 0xce, 0x00,
+    0x00, 0x25, 0xd7, 0x00, 0x00, 0x25, 0xe2, 0x00, 0x00, 0x25, 0xea, 0x00,
+    0x00, 0x25, 0xf1, 0x00, 0x00, 0x25, 0xfc, 0x00, 0x00, 0x26, 0x00, 0x00,
+    0x00, 0x26, 0x05, 0x00, 0x00, 0x26, 0x0c, 0x00, 0x00, 0x26, 0x15, 0x00,
+    0x00, 0x26, 0x1d, 0x00, 0x00, 0x26, 0x29, 0x00, 0x00, 0x26, 0x30, 0x00,
+    0x00, 0x26, 0x37, 0x00, 0x00, 0x26, 0x3f, 0x00, 0x00, 0x26, 0x47, 0x00,
+    0x00, 0x26, 0x4e, 0x00, 0x00, 0x26, 0x58, 0x00, 0x00, 0x26, 0x5f, 0x00,
+    0x00, 0x26, 0x67, 0x00, 0x00, 0x26, 0x6f, 0x00, 0x00, 0x26, 0x76, 0x00,
+    0x00, 0x26, 0x7d, 0x00, 0x00, 0x26, 0x86, 0x00, 0x00, 0x26, 0x8d, 0x00,
+    0x00, 0x26, 0x96, 0x00, 0x00, 0x26, 0x9e, 0x00, 0x00, 0x26, 0xa5, 0x00,
+    0x00, 0x26, 0xae, 0x00, 0x00, 0x26, 0xb3, 0x00, 0x00, 0x26, 0xba, 0x00,
+    0x00, 0x26, 0xc2, 0x00, 0x00, 0x26, 0xca, 0x00, 0x00, 0x26, 0xd0, 0x00,
+    0x00, 0x26, 0xd7, 0x00, 0x00, 0x26, 0xde, 0x00, 0x00, 0x26, 0xe7, 0x00,
+    0x00, 0x26, 0xf0, 0x00, 0x00, 0x26, 0xf6, 0x00, 0x00, 0x26, 0xfb, 0x00,
+    0x00, 0x27, 0x03, 0x00, 0x00, 0x27, 0x08, 0x00, 0x00, 0x27, 0x0e, 0x00,
+    0x00, 0x27, 0x16, 0x00, 0x00, 0x27, 0x1c, 0x00, 0x00, 0x27, 0x22, 0x00,
+    0x00, 0x27, 0x2c, 0x00, 0x00, 0x27, 0x37, 0x00, 0x00, 0x27, 0x3f, 0x00,
+    0x00, 0x27, 0x47, 0x00, 0x00, 0x27, 0x50, 0x00, 0x00, 0x27, 0x5b, 0x00,
+    0x00, 0x27, 0x65, 0x00, 0x00, 0x27, 0x6d, 0x00, 0x00, 0x27, 0x75, 0x00,
+    0x00, 0x27, 0x7d, 0x00, 0x00, 0x27, 0x88, 0x00, 0x00, 0x27, 0x90, 0x00,
+    0x00, 0x27, 0x97, 0x00, 0x00, 0x27, 0xa2, 0x00, 0x00, 0x27, 0xaa, 0x00,
+    0x00, 0x27, 0xb1, 0x00, 0x00, 0x27, 0xbd, 0x00, 0x00, 0x27, 0xc4, 0x00,
+    0x00, 0x27, 0xc9, 0x00, 0x00, 0x27, 0xd4, 0x00, 0x00, 0x27, 0xde, 0x00,
+    0x00, 0x27, 0xe4, 0x00, 0x00, 0x27, 0xe9, 0x00, 0x00, 0x27, 0xef, 0x00,
+    0x00, 0x27, 0xf5, 0x00, 0x00, 0x28, 0x02, 0x00, 0x00, 0x28, 0x0f, 0x00,
+    0x00, 0x28, 0x17, 0x00, 0x00, 0x28, 0x1d, 0x00, 0x00, 0x28, 0x23, 0x00,
+    0x00, 0x28, 0x2e, 0x00, 0x00, 0x28, 0x33, 0x00, 0x00, 0x28, 0x3a, 0x00,
+    0x00, 0x28, 0x3f, 0x00, 0x00, 0x28, 0x45, 0x00, 0x00, 0x28, 0x4c, 0x00,
+    0x00, 0x28, 0x56, 0x00, 0x00, 0x28, 0x5f, 0x00, 0x00, 0x28, 0x66, 0x00,
+    0x00, 0x28, 0x6e, 0x00, 0x00, 0x28, 0x72, 0x00, 0x00, 0x28, 0x77, 0x00,
+    0x00, 0x28, 0x7e, 0x00, 0x00, 0x28, 0x83, 0x00, 0x00, 0x28, 0x88, 0x00,
+    0x00, 0x28, 0x8e, 0x00, 0x00, 0x28, 0x94, 0x00, 0x00, 0x28, 0x9a, 0x00,
+    0x00, 0x28, 0xa1, 0x00, 0x00, 0x28, 0xa5, 0x00, 0x00, 0x28, 0xac, 0x00,
+    0x00, 0x28, 0xb0, 0x00, 0x00, 0x28, 0xb8, 0x00, 0x00, 0x28, 0xbf, 0x00,
+    0x00, 0x28, 0xc7, 0x00, 0x00, 0x28, 0xcd, 0x00, 0x00, 0x28, 0xd7, 0x00,
+    0x00, 0x28, 0xdf, 0x00, 0x00, 0x28, 0xea, 0x00, 0x00, 0x28, 0xf1, 0x00,
+    0x00, 0x28, 0xfd, 0x00, 0x00, 0x29, 0x05, 0x00, 0x00, 0x29, 0x0d, 0x00,
+    0x00, 0x29, 0x17, 0x00, 0x00, 0x29, 0x1d, 0x00, 0x00, 0x29, 0x23, 0x00,
+    0x00, 0x29, 0x29, 0x00, 0x00, 0x29, 0x2f, 0x00, 0x00, 0x29, 0x38, 0x00,
+    0x00, 0x29, 0x3f, 0x00, 0x00, 0x29, 0x48, 0x00, 0x00, 0x29, 0x4f, 0x00,
+    0x00, 0x29, 0x56, 0x6d, 0x61, 0x6b, 0x65, 0x00, 0x73, 0x65, 0x65, 0x00,
+    0x67, 0x65, 0x74, 0x00, 0x74, 0x61, 0x6b, 0x65, 0x00, 0x67, 0x6f, 0x00,
+    0x6b, 0x6e, 0x6f, 0x77, 0x00, 0x73, 0x61, 0x79, 0x00, 0x66, 0x69, 0x6e,
+    0x64, 0x00, 0x67, 0x69, 0x76, 0x65, 0x00, 0x74, 0x68, 0x69, 0x6e, 0x6b,
+    0x00, 0x63, 0x6f, 0x6d, 0x65, 0x00, 0x68, 0x65, 0x6c, 0x70, 0x00, 0x75,
+    0x73, 0x65, 0x00, 0x6c, 0x6f, 0x6f, 0x6b, 0x00, 0x77, 0x61, 0x6e, 0x74,
+    0x00, 0x74, 0x65, 0x6c, 0x6c, 0x00, 0x6b, 0x65, 0x65, 0x70, 0x00, 0x6c,
+    0x69, 0x6b, 0x65, 0x00, 0x77, 0x6f, 0x72, 0x6b, 0x00, 0x70, 0x72, 0x6f,
+    0x76, 0x69, 0x64, 0x65, 0x00, 0x62, 0x65, 0x63, 0x6f, 0x6d, 0x65, 0x00,
+    0x70, 0x75, 0x74, 0x00, 0x70, 0x61, 0x79, 0x00, 0x66, 0x65, 0x65, 0x6c,
+    0x00, 0x6e, 0x65, 0x65, 0x64, 0x00, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x00,
+    0x6d, 0x65, 0x65, 0x74, 0x00, 0x62, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x61,
+    0x73, 0x6b, 0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x74, 0x61, 0x6e,
+    0x64, 0x00, 0x73, 0x68, 0x6f, 0x77, 0x00, 0x6d, 0x65, 0x61, 0x6e, 0x00,
+    0x70, 0x6c, 0x61, 0x79, 0x00, 0x74, 0x72, 0x79, 0x00, 0x62, 0x65, 0x6c,
+    0x69, 0x65, 0x76, 0x65, 0x00, 0x68, 0x65, 0x61, 0x72, 0x00, 0x65, 0x6e,
+    0x73, 0x75, 0x72, 0x65, 0x00, 0x73, 0x74, 0x6f, 0x70, 0x00, 0x6d, 0x6f,
+    0x76, 0x65, 0x00, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x00, 0x73, 0x65, 0x65,
+    0x6d, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x69, 0x6e, 0x75, 0x65, 0x00, 0x70,
+    0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x00, 0x74, 0x61, 0x6c, 0x6b, 0x00,
+    0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x73, 0x74, 0x61, 0x79, 0x00,
+    0x62, 0x75, 0x79, 0x00, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x6c, 0x65, 0x74,
+    0x00, 0x72, 0x75, 0x6e, 0x00, 0x73, 0x74, 0x61, 0x72, 0x74, 0x00, 0x63,
+    0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65, 0x72, 0x00, 0x61, 0x63, 0x63, 0x65,
+    0x70, 0x74, 0x00, 0x74, 0x75, 0x72, 0x6e, 0x00, 0x72, 0x65, 0x6d, 0x65,
+    0x6d, 0x62, 0x65, 0x72, 0x00, 0x64, 0x65, 0x76, 0x65, 0x6c, 0x6f, 0x70,
+    0x00, 0x6c, 0x65, 0x61, 0x64, 0x00, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64,
+    0x65, 0x00, 0x68, 0x6f, 0x6c, 0x64, 0x00, 0x61, 0x76, 0x6f, 0x69, 0x64,
+    0x00, 0x63, 0x61, 0x72, 0x72, 0x79, 0x00, 0x6f, 0x66, 0x66, 0x65, 0x72,
+    0x00, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x00, 0x73, 0x70, 0x65, 0x61,
+    0x6b, 0x00, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x00, 0x61, 0x70, 0x70,
+    0x65, 0x61, 0x72, 0x00, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x00, 0x65,
+    0x78, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x00, 0x70, 0x72, 0x65, 0x76, 0x65,
+    0x6e, 0x74, 0x00, 0x68, 0x61, 0x70, 0x70, 0x65, 0x6e, 0x00, 0x63, 0x61,
+    0x6c, 0x6c, 0x00, 0x77, 0x69, 0x6e, 0x00, 0x73, 0x75, 0x70, 0x70, 0x6f,
+    0x72, 0x74, 0x00, 0x61, 0x63, 0x68, 0x69, 0x65, 0x76, 0x65, 0x00, 0x72,
+    0x65, 0x64, 0x75, 0x63, 0x65, 0x00, 0x77, 0x72, 0x69, 0x74, 0x65, 0x00,
+    0x73, 0x65, 0x74, 0x00, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x00, 0x6c,
+    0x65, 0x61, 0x72, 0x6e, 0x00, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73,
+    0x65, 0x00, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x00, 0x6a, 0x6f, 0x69, 0x6e,
+    0x00, 0x72, 0x65, 0x61, 0x64, 0x00, 0x69, 0x6d, 0x70, 0x72, 0x6f, 0x76,
+    0x65, 0x00, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x00, 0x73, 0x65, 0x6c, 0x6c,
+    0x00, 0x72, 0x65, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x72, 0x65, 0x61, 0x63,
+    0x68, 0x00, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x00, 0x70, 0x72, 0x6f, 0x76,
+    0x65, 0x00, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x00, 0x64, 0x65,
+    0x61, 0x6c, 0x00, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x00, 0x73, 0x70, 0x65,
+    0x6e, 0x64, 0x00, 0x72, 0x61, 0x69, 0x73, 0x65, 0x00, 0x66, 0x6f, 0x72,
+    0x6d, 0x00, 0x65, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x00,
+    0x64, 0x65, 0x63, 0x69, 0x64, 0x65, 0x00, 0x77, 0x61, 0x69, 0x74, 0x00,
+    0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x00, 0x6c, 0x6f, 0x73, 0x65,
+    0x00, 0x66, 0x61, 0x6c, 0x6c, 0x00, 0x6d, 0x61, 0x69, 0x6e, 0x74, 0x61,
+    0x69, 0x6e, 0x00, 0x61, 0x63, 0x74, 0x00, 0x73, 0x65, 0x6e, 0x64, 0x00,
+    0x64, 0x69, 0x73, 0x63, 0x75, 0x73, 0x73, 0x00, 0x73, 0x75, 0x67, 0x67,
+    0x65, 0x73, 0x74, 0x00, 0x73, 0x61, 0x76, 0x65, 0x00, 0x63, 0x6f, 0x76,
+    0x65, 0x72, 0x00, 0x63, 0x61, 0x75, 0x73, 0x65, 0x00, 0x62, 0x72, 0x65,
+    0x61, 0x6b, 0x00, 0x73, 0x69, 0x74, 0x00, 0x69, 0x64, 0x65, 0x6e, 0x74,
+    0x69, 0x66, 0x79, 0x00, 0x65, 0x61, 0x74, 0x00, 0x6f, 0x62, 0x74, 0x61,
+    0x69, 0x6e, 0x00, 0x66, 0x61, 0x63, 0x65, 0x00, 0x63, 0x68, 0x6f, 0x6f,
+    0x73, 0x65, 0x00, 0x61, 0x64, 0x64, 0x00, 0x65, 0x6e, 0x63, 0x6f, 0x75,
+    0x72, 0x61, 0x67, 0x65, 0x00, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x00,
+    0x61, 0x67, 0x72, 0x65, 0x65, 0x00, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
+    0x65, 0x00, 0x70, 0x61, 0x73, 0x73, 0x00, 0x65, 0x6e, 0x6a, 0x6f, 0x79,
+    0x00, 0x64, 0x72, 0x61, 0x77, 0x00, 0x61, 0x66, 0x66, 0x6f, 0x72, 0x64,
+    0x00, 0x6f, 0x70, 0x65, 0x6e, 0x00, 0x65, 0x6e, 0x64, 0x00, 0x63, 0x6f,
+    0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x00, 0x61, 0x6e, 0x73, 0x77, 0x65, 0x72,
+    0x00, 0x77, 0x61, 0x6c, 0x6b, 0x00, 0x76, 0x69, 0x73, 0x69, 0x74, 0x00,
+    0x73, 0x65, 0x65, 0x6b, 0x00, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x63,
+    0x75, 0x74, 0x00, 0x73, 0x65, 0x72, 0x76, 0x65, 0x00, 0x6f, 0x63, 0x63,
+    0x75, 0x72, 0x00, 0x6b, 0x69, 0x6c, 0x6c, 0x00, 0x69, 0x6d, 0x61, 0x67,
+    0x69, 0x6e, 0x65, 0x00, 0x67, 0x72, 0x6f, 0x77, 0x00, 0x66, 0x6f, 0x72,
+    0x67, 0x65, 0x74, 0x00, 0x63, 0x6f, 0x70, 0x65, 0x00, 0x64, 0x69, 0x65,
+    0x00, 0x62, 0x65, 0x61, 0x72, 0x00, 0x77, 0x6f, 0x72, 0x72, 0x79, 0x00,
+    0x77, 0x69, 0x73, 0x68, 0x00, 0x77, 0x61, 0x74, 0x63, 0x68, 0x00, 0x64,
+    0x65, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x00, 0x63, 0x61, 0x72,
+    0x65, 0x00, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x00, 0x73, 0x68, 0x61,
+    0x72, 0x65, 0x00, 0x70, 0x69, 0x63, 0x6b, 0x00, 0x63, 0x61, 0x74, 0x63,
+    0x68, 0x00, 0x6d, 0x69, 0x6e, 0x64, 0x00, 0x6c, 0x6f, 0x76, 0x65, 0x00,
+    0x67, 0x61, 0x69, 0x6e, 0x00, 0x66, 0x69, 0x67, 0x68, 0x74, 0x00, 0x65,
+    0x78, 0x69, 0x73, 0x74, 0x00, 0x65, 0x78, 0x61, 0x6d, 0x69, 0x6e, 0x65,
+    0x00, 0x63, 0x6c, 0x65, 0x61, 0x72, 0x00, 0x6d, 0x61, 0x6e, 0x61, 0x67,
+    0x65, 0x00, 0x66, 0x69, 0x74, 0x00, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
+    0x62, 0x65, 0x00, 0x61, 0x74, 0x74, 0x65, 0x6e, 0x64, 0x00, 0x73, 0x6c,
+    0x65, 0x65, 0x70, 0x00, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63,
+    0x65, 0x00, 0x64, 0x72, 0x69, 0x76, 0x65, 0x00, 0x63, 0x68, 0x65, 0x63,
+    0x6b, 0x00, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x00, 0x69, 0x6e, 0x76,
+    0x6f, 0x6c, 0x76, 0x65, 0x00, 0x73, 0x75, 0x72, 0x76, 0x69, 0x76, 0x65,
+    0x00, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x00, 0x72, 0x65, 0x6d,
+    0x6f, 0x76, 0x65, 0x00, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x65, 0x00,
+    0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x00, 0x63, 0x6c, 0x61, 0x69,
+    0x6d, 0x00, 0x61, 0x72, 0x67, 0x75, 0x65, 0x00, 0x61, 0x64, 0x6d, 0x69,
+    0x74, 0x00, 0x72, 0x69, 0x73, 0x65, 0x00, 0x72, 0x65, 0x73, 0x70, 0x6f,
+    0x6e, 0x64, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x73, 0x65,
+    0x00, 0x72, 0x65, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x00, 0x65, 0x73, 0x63,
+    0x61, 0x70, 0x65, 0x00, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72,
+    0x00, 0x77, 0x65, 0x61, 0x72, 0x00, 0x73, 0x74, 0x75, 0x64, 0x79, 0x00,
+    0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x00, 0x72, 0x65,
+    0x66, 0x6c, 0x65, 0x63, 0x74, 0x00, 0x70, 0x65, 0x72, 0x66, 0x6f, 0x72,
+    0x6d, 0x00, 0x6d, 0x61, 0x74, 0x74, 0x65, 0x72, 0x00, 0x6c, 0x69, 0x73,
+    0x74, 0x65, 0x6e, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65,
+    0x00, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x00, 0x63, 0x6f, 0x6e, 0x74,
+    0x61, 0x69, 0x6e, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65,
+    0x00, 0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x00, 0x70, 0x72, 0x65, 0x73,
+    0x65, 0x6e, 0x74, 0x00, 0x6d, 0x61, 0x72, 0x72, 0x79, 0x00, 0x6c, 0x61,
+    0x73, 0x74, 0x00, 0x66, 0x69, 0x6c, 0x6c, 0x00, 0x64, 0x65, 0x70, 0x65,
+    0x6e, 0x64, 0x00, 0x61, 0x73, 0x73, 0x65, 0x73, 0x73, 0x00, 0x73, 0x65,
+    0x63, 0x75, 0x72, 0x65, 0x00, 0x70, 0x75, 0x6c, 0x6c, 0x00, 0x6d, 0x65,
+    0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x6e,
+    0x74, 0x72, 0x61, 0x74, 0x65, 0x00, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x00,
+    0x62, 0x65, 0x6e, 0x65, 0x66, 0x69, 0x74, 0x00, 0x61, 0x73, 0x73, 0x69,
+    0x73, 0x74, 0x00, 0x74, 0x72, 0x61, 0x76, 0x65, 0x6c, 0x00, 0x70, 0x72,
+    0x65, 0x70, 0x61, 0x72, 0x65, 0x00, 0x70, 0x65, 0x72, 0x73, 0x75, 0x61,
+    0x64, 0x65, 0x00, 0x6c, 0x69, 0x65, 0x00, 0x69, 0x6e, 0x76, 0x65, 0x73,
+    0x74, 0x69, 0x67, 0x61, 0x74, 0x65, 0x00, 0x68, 0x6f, 0x70, 0x65, 0x00,
+    0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x00, 0x65, 0x78, 0x70, 0x72, 0x65,
+    0x73, 0x73, 0x00, 0x63, 0x6f, 0x73, 0x74, 0x00, 0x74, 0x72, 0x65, 0x61,
+    0x74, 0x00, 0x74, 0x65, 0x61, 0x63, 0x68, 0x00, 0x73, 0x75, 0x66, 0x66,
+    0x65, 0x72, 0x00, 0x73, 0x6f, 0x75, 0x6e, 0x64, 0x00, 0x6d, 0x69, 0x73,
+    0x73, 0x00, 0x66, 0x6c, 0x79, 0x00, 0x61, 0x74, 0x74, 0x72, 0x61, 0x63,
+    0x74, 0x00, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x00, 0x73, 0x65, 0x74,
+    0x74, 0x6c, 0x65, 0x00, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x00, 0x72,
+    0x65, 0x74, 0x61, 0x69, 0x6e, 0x00, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74,
+    0x00, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x00, 0x6e, 0x6f, 0x74, 0x69, 0x63,
+    0x65, 0x00, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, 0x65, 0x78, 0x70, 0x6c,
+    0x6f, 0x72, 0x65, 0x00, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x00,
+    0x61, 0x64, 0x6f, 0x70, 0x74, 0x00, 0x74, 0x68, 0x72, 0x6f, 0x77, 0x00,
+    0x73, 0x75, 0x63, 0x63, 0x65, 0x65, 0x64, 0x00, 0x72, 0x65, 0x6c, 0x79,
+    0x00, 0x72, 0x65, 0x66, 0x65, 0x72, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x76,
+    0x65, 0x72, 0x00, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x66, 0x6f, 0x72,
+    0x63, 0x65, 0x00, 0x64, 0x65, 0x66, 0x65, 0x6e, 0x64, 0x00, 0x63, 0x6f,
+    0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x00, 0x63, 0x6f, 0x6e,
+    0x66, 0x69, 0x72, 0x6d, 0x00, 0x62, 0x65, 0x61, 0x74, 0x00, 0x61, 0x72,
+    0x72, 0x69, 0x76, 0x65, 0x00, 0x61, 0x72, 0x69, 0x73, 0x65, 0x00, 0x61,
+    0x70, 0x70, 0x72, 0x65, 0x63, 0x69, 0x61, 0x74, 0x65, 0x00, 0x74, 0x6f,
+    0x75, 0x63, 0x68, 0x00, 0x74, 0x65, 0x73, 0x74, 0x00, 0x73, 0x6f, 0x6c,
+    0x76, 0x65, 0x00, 0x73, 0x69, 0x67, 0x6e, 0x00, 0x73, 0x61, 0x74, 0x69,
+    0x73, 0x66, 0x79, 0x00, 0x72, 0x65, 0x73, 0x69, 0x73, 0x74, 0x00, 0x6a,
+    0x75, 0x73, 0x74, 0x69, 0x66, 0x79, 0x00, 0x69, 0x6e, 0x66, 0x6c, 0x75,
+    0x65, 0x6e, 0x63, 0x65, 0x00, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x00,
+    0x68, 0x69, 0x64, 0x65, 0x00, 0x64, 0x72, 0x6f, 0x70, 0x00, 0x64, 0x69,
+    0x73, 0x74, 0x69, 0x6e, 0x67, 0x75, 0x69, 0x73, 0x68, 0x00, 0x64, 0x65,
+    0x6e, 0x79, 0x00, 0x64, 0x65, 0x6d, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61,
+    0x74, 0x65, 0x00, 0x64, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x00, 0x64,
+    0x65, 0x66, 0x69, 0x6e, 0x65, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63,
+    0x74, 0x00, 0x62, 0x6c, 0x61, 0x6d, 0x65, 0x00, 0x61, 0x74, 0x74, 0x65,
+    0x6d, 0x70, 0x74, 0x00, 0x73, 0x75, 0x69, 0x74, 0x00, 0x72, 0x65, 0x73,
+    0x74, 0x00, 0x70, 0x75, 0x72, 0x73, 0x75, 0x65, 0x00, 0x70, 0x72, 0x6f,
+    0x63, 0x65, 0x65, 0x64, 0x00, 0x6e, 0x6f, 0x74, 0x65, 0x00, 0x66, 0x69,
+    0x6e, 0x69, 0x73, 0x68, 0x00, 0x64, 0x72, 0x69, 0x6e, 0x6b, 0x00, 0x64,
+    0x65, 0x73, 0x74, 0x72, 0x6f, 0x79, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x65,
+    0x74, 0x65, 0x00, 0x61, 0x72, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x61,
+    0x63, 0x71, 0x75, 0x69, 0x72, 0x65, 0x00, 0x76, 0x6f, 0x74, 0x65, 0x00,
+    0x76, 0x61, 0x72, 0x79, 0x00, 0x74, 0x72, 0x75, 0x73, 0x74, 0x00, 0x72,
+    0x65, 0x63, 0x6f, 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x00, 0x70, 0x72, 0x65,
+    0x73, 0x73, 0x00, 0x70, 0x72, 0x65, 0x66, 0x65, 0x72, 0x00, 0x6f, 0x76,
+    0x65, 0x72, 0x63, 0x6f, 0x6d, 0x65, 0x00, 0x6c, 0x61, 0x79, 0x00, 0x69,
+    0x6d, 0x70, 0x6f, 0x73, 0x65, 0x00, 0x68, 0x69, 0x74, 0x00, 0x67, 0x65,
+    0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x00, 0x66, 0x6f, 0x63, 0x75, 0x73,
+    0x00, 0x66, 0x61, 0x69, 0x6c, 0x00, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64,
+    0x00, 0x65, 0x78, 0x65, 0x72, 0x63, 0x69, 0x73, 0x65, 0x00, 0x61, 0x64,
+    0x76, 0x69, 0x73, 0x65, 0x00, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+    0x00, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x75, 0x6e, 0x64,
+    0x65, 0x72, 0x74, 0x61, 0x6b, 0x65, 0x00, 0x73, 0x75, 0x70, 0x70, 0x6f,
+    0x73, 0x65, 0x00, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x00, 0x72,
+    0x65, 0x66, 0x75, 0x73, 0x65, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64,
+    0x00, 0x72, 0x65, 0x63, 0x61, 0x6c, 0x6c, 0x00, 0x70, 0x61, 0x72, 0x74,
+    0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x65, 0x00, 0x6d, 0x61, 0x72, 0x6b,
+    0x00, 0x66, 0x65, 0x65, 0x64, 0x00, 0x65, 0x6d, 0x65, 0x72, 0x67, 0x65,
+    0x00, 0x64, 0x61, 0x74, 0x65, 0x00, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x00,
+    0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x00, 0x74, 0x61, 0x63,
+    0x6b, 0x6c, 0x65, 0x00, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x72, 0x65, 0x67,
+    0x61, 0x72, 0x64, 0x00, 0x70, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65,
+    0x00, 0x70, 0x6c, 0x61, 0x6e, 0x00, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x00,
+    0x6d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x00, 0x6c, 0x61, 0x75, 0x67,
+    0x68, 0x00, 0x6a, 0x75, 0x64, 0x67, 0x65, 0x00, 0x69, 0x6d, 0x70, 0x6c,
+    0x65, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x65, 0x61, 0x72, 0x6e, 0x00, 0x63,
+    0x6f, 0x6d, 0x70, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72,
+    0x65, 0x00, 0x63, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74,
+    0x65, 0x00, 0x62, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x00, 0x61, 0x74, 0x74,
+    0x61, 0x63, 0x6b, 0x00, 0x61, 0x70, 0x70, 0x65, 0x61, 0x6c, 0x00, 0x61,
+    0x63, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x64, 0x61, 0x74, 0x65, 0x00, 0x77,
+    0x6f, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x73, 0x74, 0x72, 0x69, 0x6b, 0x65,
+    0x00, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x00, 0x72, 0x65, 0x6c,
+    0x65, 0x61, 0x73, 0x65, 0x00, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x00,
+    0x72, 0x65, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x00, 0x6f, 0x62, 0x73, 0x65,
+    0x72, 0x76, 0x65, 0x00, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x00, 0x6c, 0x69,
+    0x66, 0x74, 0x00, 0x69, 0x6e, 0x76, 0x65, 0x73, 0x74, 0x00, 0x69, 0x6e,
+    0x66, 0x6f, 0x72, 0x6d, 0x00, 0x68, 0x75, 0x72, 0x74, 0x00, 0x68, 0x61,
+    0x6e, 0x67, 0x00, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x65, 0x6e, 0x63,
+    0x65, 0x00, 0x65, 0x6e, 0x68, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x64, 0x65,
+    0x74, 0x65, 0x63, 0x74, 0x00, 0x63, 0x72, 0x79, 0x00, 0x63, 0x72, 0x6f,
+    0x73, 0x73, 0x00, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x63, 0x6f, 0x6d,
+    0x6d, 0x65, 0x6e, 0x74, 0x00, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e,
+    0x67, 0x65, 0x00, 0x62, 0x61, 0x63, 0x6b, 0x00, 0x77, 0x65, 0x6c, 0x63,
+    0x6f, 0x6d, 0x65, 0x00, 0x76, 0x69, 0x65, 0x77, 0x00, 0x74, 0x72, 0x61,
+    0x6e, 0x73, 0x66, 0x65, 0x72, 0x00, 0x73, 0x75, 0x73, 0x74, 0x61, 0x69,
+    0x6e, 0x00, 0x73, 0x74, 0x72, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x65, 0x6e,
+    0x00, 0x73, 0x74, 0x69, 0x63, 0x6b, 0x00, 0x73, 0x74, 0x61, 0x74, 0x65,
+    0x00, 0x73, 0x6f, 0x72, 0x74, 0x00, 0x73, 0x69, 0x6e, 0x67, 0x00, 0x73,
+    0x65, 0x6c, 0x65, 0x63, 0x74, 0x00, 0x72, 0x69, 0x64, 0x65, 0x00, 0x72,
+    0x65, 0x76, 0x69, 0x65, 0x77, 0x00, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74,
+    0x00, 0x72, 0x65, 0x6d, 0x69, 0x6e, 0x64, 0x00, 0x72, 0x65, 0x6c, 0x61,
+    0x78, 0x00, 0x71, 0x75, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x70,
+    0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x00, 0x70, 0x75, 0x62, 0x6c,
+    0x69, 0x73, 0x68, 0x00, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x74, 0x00,
+    0x6f, 0x77, 0x6e, 0x00, 0x6e, 0x65, 0x67, 0x6f, 0x74, 0x69, 0x61, 0x74,
+    0x65, 0x00, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x00, 0x6c, 0x61,
+    0x75, 0x6e, 0x63, 0x68, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72,
+    0x65, 0x74, 0x00, 0x67, 0x75, 0x61, 0x72, 0x61, 0x6e, 0x74, 0x65, 0x65,
+    0x00, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x00, 0x63, 0x6f, 0x6e,
+    0x76, 0x69, 0x6e, 0x63, 0x65, 0x00, 0x63, 0x6c, 0x69, 0x6d, 0x62, 0x00,
+    0x63, 0x65, 0x6c, 0x65, 0x62, 0x72, 0x61, 0x74, 0x65, 0x00, 0x62, 0x65,
+    0x68, 0x61, 0x76, 0x65, 0x00, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x65,
+    0x00, 0x61, 0x63, 0x6b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65,
+    0x00, 0x74, 0x68, 0x61, 0x6e, 0x6b, 0x00, 0x74, 0x65, 0x6e, 0x64, 0x00,
+    0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x00, 0x73, 0x74, 0x65, 0x70, 0x00,
+    0x73, 0x70, 0x72, 0x65, 0x61, 0x64, 0x00, 0x73, 0x70, 0x65, 0x63, 0x69,
+    0x66, 0x79, 0x00, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x00, 0x73, 0x63,
+    0x6f, 0x72, 0x65, 0x00, 0x72, 0x69, 0x73, 0x6b, 0x00, 0x72, 0x65, 0x70,
+    0x6c, 0x79, 0x00, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x00, 0x72, 0x65,
+    0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x64, 0x00, 0x71, 0x75, 0x61, 0x6c,
+    0x69, 0x66, 0x79, 0x00, 0x70, 0x75, 0x73, 0x68, 0x00, 0x70, 0x65, 0x72,
+    0x6d, 0x69, 0x74, 0x00, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x73, 0x65,
+    0x00, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x00, 0x6c, 0x61, 0x6e, 0x64, 0x00,
+    0x69, 0x73, 0x73, 0x75, 0x65, 0x00, 0x69, 0x6d, 0x70, 0x6c, 0x79, 0x00,
+    0x69, 0x6c, 0x6c, 0x75, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x00, 0x66,
+    0x75, 0x6c, 0x66, 0x69, 0x6c, 0x00, 0x66, 0x69, 0x6e, 0x61, 0x6e, 0x63,
+    0x65, 0x00, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0x69, 0x74, 0x00, 0x65, 0x6d,
+    0x70, 0x6c, 0x6f, 0x79, 0x00, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79,
+    0x00, 0x64, 0x65, 0x6d, 0x61, 0x6e, 0x64, 0x00, 0x63, 0x6f, 0x6e, 0x76,
+    0x65, 0x79, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74,
+    0x00, 0x63, 0x6f, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x00, 0x63, 0x6f,
+    0x6d, 0x6d, 0x69, 0x74, 0x00, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x61, 0x63,
+    0x68, 0x00, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x00, 0x61,
+    0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x74, 0x72, 0x61, 0x69, 0x6e,
+    0x00, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68, 0x00, 0x73, 0x74, 0x69, 0x6d,
+    0x75, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x73, 0x6c, 0x69, 0x70, 0x00, 0x73,
+    0x68, 0x6f, 0x6f, 0x74, 0x00, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x00, 0x73,
+    0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x00, 0x72, 0x75, 0x6c, 0x65,
+    0x00, 0x72, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x00, 0x72, 0x65, 0x61, 0x63,
+    0x74, 0x00, 0x70, 0x72, 0x65, 0x74, 0x65, 0x6e, 0x64, 0x00, 0x70, 0x6c,
+    0x65, 0x61, 0x73, 0x65, 0x00, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x6d, 0x61,
+    0x72, 0x6b, 0x65, 0x74, 0x00, 0x6c, 0x69, 0x6e, 0x6b, 0x00, 0x6c, 0x65,
+    0x6e, 0x64, 0x00, 0x6a, 0x75, 0x6d, 0x70, 0x00, 0x69, 0x6e, 0x74, 0x65,
+    0x72, 0x76, 0x65, 0x6e, 0x65, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66,
+    0x65, 0x72, 0x65, 0x00, 0x69, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x00, 0x67,
+    0x75, 0x65, 0x73, 0x73, 0x00, 0x67, 0x72, 0x61, 0x6e, 0x74, 0x00, 0x66,
+    0x72, 0x65, 0x65, 0x00, 0x66, 0x61, 0x63, 0x69, 0x6c, 0x69, 0x74, 0x61,
+    0x74, 0x65, 0x00, 0x65, 0x76, 0x61, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x00,
+    0x65, 0x6e, 0x67, 0x61, 0x67, 0x65, 0x00, 0x65, 0x6e, 0x66, 0x6f, 0x72,
+    0x63, 0x65, 0x00, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65,
+    0x00, 0x65, 0x61, 0x73, 0x65, 0x00, 0x64, 0x69, 0x73, 0x61, 0x70, 0x70,
+    0x65, 0x61, 0x72, 0x00, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x00, 0x63,
+    0x6f, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x75,
+    0x6c, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x64, 0x75, 0x63, 0x74, 0x00, 0x63,
+    0x6f, 0x6d, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x00, 0x63, 0x6f, 0x6d, 0x62,
+    0x69, 0x6e, 0x65, 0x00, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x00, 0x62, 0x6f,
+    0x72, 0x72, 0x6f, 0x77, 0x00, 0x62, 0x6f, 0x6f, 0x73, 0x74, 0x00, 0x62,
+    0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x77, 0x61, 0x73, 0x68, 0x00, 0x77,
+    0x61, 0x72, 0x6e, 0x00, 0x77, 0x61, 0x6b, 0x65, 0x00, 0x74, 0x72, 0x61,
+    0x63, 0x65, 0x00, 0x73, 0x75, 0x65, 0x00, 0x73, 0x70, 0x61, 0x72, 0x65,
+    0x00, 0x73, 0x6d, 0x69, 0x6c, 0x65, 0x00, 0x73, 0x68, 0x69, 0x66, 0x74,
+    0x00, 0x72, 0x65, 0x74, 0x69, 0x72, 0x65, 0x00, 0x72, 0x65, 0x73, 0x74,
+    0x72, 0x69, 0x63, 0x74, 0x00, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
+    0x72, 0x00, 0x70, 0x72, 0x61, 0x63, 0x74, 0x69, 0x73, 0x65, 0x00, 0x70,
+    0x6f, 0x73, 0x73, 0x65, 0x73, 0x73, 0x00, 0x6b, 0x69, 0x73, 0x73, 0x00,
+    0x69, 0x6e, 0x63, 0x6f, 0x72, 0x70, 0x6f, 0x72, 0x61, 0x74, 0x65, 0x00,
+    0x68, 0x65, 0x61, 0x64, 0x00, 0x67, 0x61, 0x74, 0x68, 0x65, 0x72, 0x00,
+    0x66, 0x6f, 0x72, 0x67, 0x69, 0x76, 0x65, 0x00, 0x66, 0x69, 0x78, 0x00,
+    0x66, 0x65, 0x74, 0x63, 0x68, 0x00, 0x65, 0x78, 0x63, 0x65, 0x65, 0x64,
+    0x00, 0x64, 0x72, 0x79, 0x00, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x00,
+    0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x00, 0x64, 0x61, 0x6d, 0x61, 0x67,
+    0x65, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74, 0x65,
+    0x00, 0x63, 0x6f, 0x6d, 0x70, 0x65, 0x6e, 0x73, 0x61, 0x74, 0x65, 0x00,
+    0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0x00, 0x63, 0x65, 0x61, 0x73, 0x65,
+    0x00, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x00, 0x62, 0x75, 0x72,
+    0x6e, 0x00, 0x62, 0x72, 0x65, 0x61, 0x74, 0x68, 0x65, 0x00, 0x61, 0x70,
+    0x70, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x61, 0x70, 0x70, 0x6f, 0x69, 0x6e,
+    0x74, 0x00, 0x61, 0x64, 0x6a, 0x75, 0x73, 0x74, 0x00, 0x61, 0x64, 0x61,
+    0x70, 0x74, 0x00, 0x61, 0x63, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79,
+    0x00, 0x79, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x77, 0x61, 0x73, 0x74, 0x65,
+    0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x65, 0x00, 0x74,
+    0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x74, 0x72, 0x61,
+    0x64, 0x65, 0x00, 0x73, 0x77, 0x69, 0x6d, 0x00, 0x73, 0x74, 0x72, 0x65,
+    0x73, 0x73, 0x00, 0x73, 0x74, 0x65, 0x61, 0x6c, 0x00, 0x73, 0x6d, 0x65,
+    0x6c, 0x6c, 0x00, 0x73, 0x68, 0x75, 0x74, 0x00, 0x73, 0x65, 0x6e, 0x73,
+    0x65, 0x00, 0x72, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x00, 0x72, 0x65, 0x6c,
+    0x69, 0x65, 0x76, 0x65, 0x00, 0x72, 0x65, 0x69, 0x6e, 0x66, 0x6f, 0x72,
+    0x63, 0x65, 0x00, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x00, 0x70,
+    0x61, 0x69, 0x6e, 0x74, 0x00, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x00, 0x6c,
+    0x6f, 0x63, 0x61, 0x74, 0x65, 0x00, 0x6b, 0x6e, 0x6f, 0x63, 0x6b, 0x00,
+    0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x6e,
+    0x64, 0x00, 0x68, 0x61, 0x74, 0x65, 0x00, 0x67, 0x75, 0x69, 0x64, 0x65,
+    0x00, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x66, 0x65,
+    0x61, 0x72, 0x00, 0x65, 0x6d, 0x70, 0x68, 0x61, 0x73, 0x69, 0x73, 0x65,
+    0x00, 0x64, 0x6f, 0x75, 0x62, 0x74, 0x00, 0x64, 0x6f, 0x6d, 0x69, 0x6e,
+    0x61, 0x74, 0x65, 0x00, 0x64, 0x69, 0x73, 0x6d, 0x69, 0x73, 0x73, 0x00,
+    0x64, 0x65, 0x6c, 0x61, 0x79, 0x00, 0x64, 0x65, 0x63, 0x6c, 0x61, 0x72,
+    0x65, 0x00, 0x64, 0x61, 0x72, 0x65, 0x00, 0x64, 0x61, 0x6e, 0x63, 0x65,
+    0x00, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x00, 0x63, 0x6f, 0x6f,
+    0x6b, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x73, 0x74, 0x00, 0x63, 0x6f,
+    0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x63, 0x6f, 0x6d, 0x62, 0x61, 0x74,
+    0x00, 0x63, 0x6c, 0x61, 0x72, 0x69, 0x66, 0x79, 0x00, 0x63, 0x61, 0x6c,
+    0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x62, 0x6c, 0x6f, 0x77, 0x00,
+    0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x61, 0x69, 0x64, 0x00,
+    0x75, 0x70, 0x73, 0x65, 0x74, 0x00, 0x74, 0x6f, 0x6c, 0x65, 0x72, 0x61,
+    0x74, 0x65, 0x00, 0x74, 0x68, 0x72, 0x65, 0x61, 0x74, 0x65, 0x6e, 0x00,
+    0x73, 0x74, 0x72, 0x65, 0x74, 0x63, 0x68, 0x00, 0x73, 0x74, 0x6f, 0x72,
+    0x65, 0x00, 0x73, 0x70, 0x6f, 0x74, 0x00, 0x73, 0x70, 0x65, 0x65, 0x64,
+    0x00, 0x73, 0x6c, 0x6f, 0x77, 0x00, 0x73, 0x69, 0x6e, 0x6b, 0x00, 0x73,
+    0x68, 0x6f, 0x75, 0x74, 0x00, 0x72, 0x75, 0x73, 0x68, 0x00, 0x72, 0x6f,
+    0x6c, 0x6c, 0x00, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x00, 0x72,
+    0x65, 0x73, 0x70, 0x65, 0x63, 0x74, 0x00, 0x72, 0x65, 0x73, 0x63, 0x75,
+    0x65, 0x00, 0x72, 0x65, 0x70, 0x61, 0x79, 0x00, 0x72, 0x65, 0x70, 0x61,
+    0x69, 0x72, 0x00, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x72, 0x65,
+    0x67, 0x61, 0x69, 0x6e, 0x00, 0x72, 0x65, 0x63, 0x72, 0x75, 0x69, 0x74,
+    0x00, 0x72, 0x65, 0x61, 0x73, 0x73, 0x75, 0x72, 0x65, 0x00, 0x70, 0x72,
+    0x6f, 0x74, 0x65, 0x73, 0x74, 0x00, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x00,
+    0x70, 0x72, 0x61, 0x79, 0x00, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x00, 0x6f,
+    0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x65, 0x00, 0x6f, 0x70, 0x70, 0x6f,
+    0x73, 0x65, 0x00, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x79, 0x00, 0x6f, 0x62,
+    0x65, 0x79, 0x00, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x00, 0x6d, 0x69,
+    0x6e, 0x69, 0x6d, 0x69, 0x73, 0x65, 0x00, 0x6c, 0x69, 0x73, 0x74, 0x00,
+    0x6b, 0x69, 0x63, 0x6b, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61,
+    0x74, 0x65, 0x00, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x00, 0x69,
+    0x6e, 0x64, 0x75, 0x63, 0x65, 0x00, 0x69, 0x6d, 0x70, 0x72, 0x65, 0x73,
+    0x73, 0x00, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x00,
+    0x68, 0x61, 0x72, 0x6d, 0x00, 0x68, 0x61, 0x6c, 0x74, 0x00, 0x67, 0x72,
+    0x61, 0x73, 0x70, 0x00, 0x66, 0x6c, 0x6f, 0x77, 0x00, 0x66, 0x69, 0x72,
+    0x65, 0x00, 0x66, 0x61, 0x76, 0x6f, 0x75, 0x72, 0x00, 0x65, 0x78, 0x74,
+    0x72, 0x61, 0x63, 0x74, 0x00, 0x65, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74,
+    0x65, 0x00, 0x64, 0x72, 0x61, 0x67, 0x00, 0x64, 0x69, 0x76, 0x69, 0x64,
+    0x65, 0x00, 0x64, 0x69, 0x73, 0x74, 0x75, 0x72, 0x62, 0x00, 0x64, 0x69,
+    0x73, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x00, 0x64, 0x65, 0x72, 0x69, 0x76,
+    0x65, 0x00, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x63, 0x6f,
+    0x6e, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x63, 0x65,
+    0x61, 0x6c, 0x00, 0x63, 0x6f, 0x69, 0x6e, 0x63, 0x69, 0x64, 0x65, 0x00,
+    0x63, 0x6f, 0x2d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x00, 0x63,
+    0x61, 0x6e, 0x63, 0x65, 0x6c, 0x00, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x00,
+    0x61, 0x73, 0x73, 0x75, 0x72, 0x65, 0x00, 0x61, 0x73, 0x73, 0x65, 0x72,
+    0x74, 0x00, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x61, 0x69, 0x6d,
+    0x00, 0x61, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x61, 0x62, 0x73,
+    0x6f, 0x72, 0x62, 0x00, 0x77, 0x69, 0x70, 0x65, 0x00, 0x75, 0x6e, 0x64,
+    0x65, 0x72, 0x67, 0x6f, 0x00, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61,
+    0x74, 0x65, 0x00, 0x74, 0x69, 0x65, 0x00, 0x74, 0x65, 0x61, 0x72, 0x00,
+    0x74, 0x61, 0x73, 0x74, 0x65, 0x00, 0x73, 0x77, 0x61, 0x6c, 0x6c, 0x6f,
+    0x77, 0x00, 0x73, 0x75, 0x73, 0x70, 0x65, 0x63, 0x74, 0x00, 0x73, 0x75,
+    0x72, 0x72, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x73, 0x75, 0x72, 0x70,
+    0x72, 0x69, 0x73, 0x65, 0x00, 0x73, 0x75, 0x70, 0x70, 0x72, 0x65, 0x73,
+    0x73, 0x00, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74,
+    0x00, 0x73, 0x74, 0x72, 0x75, 0x67, 0x67, 0x6c, 0x65, 0x00, 0x73, 0x74,
+    0x61, 0x72, 0x65, 0x00, 0x73, 0x70, 0x6c, 0x69, 0x74, 0x00, 0x73, 0x70,
+    0x65, 0x6c, 0x6c, 0x00, 0x73, 0x6d, 0x6f, 0x6b, 0x65, 0x00, 0x73, 0x68,
+    0x65, 0x64, 0x00, 0x73, 0x68, 0x61, 0x70, 0x65, 0x00, 0x73, 0x65, 0x69,
+    0x7a, 0x65, 0x00, 0x73, 0x61, 0x69, 0x6c, 0x00, 0x73, 0x61, 0x66, 0x65,
+    0x67, 0x75, 0x61, 0x72, 0x64, 0x00, 0x72, 0x65, 0x76, 0x69, 0x76, 0x65,
+    0x00, 0x72, 0x65, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x00, 0x72,
+    0x65, 0x6e, 0x65, 0x77, 0x00, 0x72, 0x65, 0x67, 0x75, 0x6c, 0x61, 0x74,
+    0x65, 0x00, 0x72, 0x65, 0x67, 0x72, 0x65, 0x74, 0x00, 0x72, 0x65, 0x66,
+    0x6f, 0x72, 0x6d, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x63, 0x69, 0x6c,
+    0x65, 0x00, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x00, 0x71, 0x75, 0x69, 0x74,
+    0x00, 0x70, 0x72, 0x6f, 0x76, 0x6f, 0x6b, 0x65, 0x00, 0x70, 0x72, 0x6f,
+    0x6d, 0x69, 0x73, 0x65, 0x00, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73,
+    0x73, 0x00, 0x70, 0x6f, 0x73, 0x65, 0x00, 0x70, 0x6c, 0x61, 0x6e, 0x74,
+    0x00, 0x70, 0x65, 0x72, 0x63, 0x65, 0x69, 0x76, 0x65, 0x00, 0x70, 0x65,
+    0x6e, 0x65, 0x74, 0x72, 0x61, 0x74, 0x65, 0x00, 0x6f, 0x70, 0x74, 0x00,
+    0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x00, 0x6d, 0x75, 0x72, 0x64, 0x65,
+    0x72, 0x00, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x6d, 0x69, 0x78, 0x00,
+    0x6d, 0x61, 0x78, 0x69, 0x6d, 0x69, 0x73, 0x65, 0x00, 0x6d, 0x61, 0x6e,
+    0x69, 0x70, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x6c, 0x61, 0x63, 0x6b,
+    0x00, 0x6b, 0x6e, 0x69, 0x74, 0x00, 0x69, 0x6e, 0x73, 0x70, 0x65, 0x63,
+    0x74, 0x00, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x00, 0x68,
+    0x6f, 0x75, 0x73, 0x65, 0x00, 0x68, 0x69, 0x72, 0x65, 0x00, 0x68, 0x65,
+    0x73, 0x69, 0x74, 0x61, 0x74, 0x65, 0x00, 0x68, 0x61, 0x6e, 0x64, 0x00,
+    0x67, 0x72, 0x65, 0x65, 0x74, 0x00, 0x67, 0x72, 0x61, 0x62, 0x00, 0x66,
+    0x6f, 0x73, 0x74, 0x65, 0x72, 0x00, 0x66, 0x6f, 0x72, 0x6d, 0x75, 0x6c,
+    0x61, 0x74, 0x65, 0x00, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x00, 0x66,
+    0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x00, 0x65, 0x78, 0x70, 0x6f, 0x73,
+    0x65, 0x00, 0x65, 0x78, 0x65, 0x72, 0x74, 0x00, 0x65, 0x78, 0x63, 0x68,
+    0x61, 0x6e, 0x67, 0x65, 0x00, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x74, 0x61,
+    0x69, 0x6e, 0x00, 0x65, 0x6e, 0x64, 0x75, 0x72, 0x65, 0x00, 0x65, 0x6d,
+    0x70, 0x68, 0x61, 0x73, 0x69, 0x7a, 0x65, 0x00, 0x65, 0x6d, 0x62, 0x72,
+    0x61, 0x63, 0x65, 0x00, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x00, 0x64,
+    0x72, 0x65, 0x73, 0x73, 0x00, 0x64, 0x72, 0x65, 0x61, 0x6d, 0x00, 0x64,
+    0x6f, 0x75, 0x62, 0x6c, 0x65, 0x00, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69,
+    0x62, 0x75, 0x74, 0x65, 0x00, 0x64, 0x69, 0x73, 0x70, 0x6f, 0x73, 0x65,
+    0x00, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x75, 0x72, 0x61, 0x67, 0x65, 0x00,
+    0x64, 0x69, 0x67, 0x00, 0x64, 0x65, 0x76, 0x6f, 0x74, 0x65, 0x00, 0x64,
+    0x65, 0x76, 0x69, 0x73, 0x65, 0x00, 0x64, 0x65, 0x74, 0x65, 0x72, 0x00,
+    0x64, 0x65, 0x66, 0x65, 0x61, 0x74, 0x00, 0x64, 0x65, 0x63, 0x6c, 0x69,
+    0x6e, 0x65, 0x00, 0x63, 0x75, 0x72, 0x65, 0x00, 0x63, 0x75, 0x72, 0x62,
+    0x00, 0x63, 0x6f, 0x6f, 0x6c, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6d,
+    0x70, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63,
+    0x74, 0x00, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x72, 0x6e, 0x00, 0x63, 0x6f,
+    0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x00, 0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x70,
+    0x73, 0x65, 0x00, 0x63, 0x6f, 0x2d, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61,
+    0x74, 0x65, 0x00, 0x63, 0x61, 0x73, 0x74, 0x00, 0x63, 0x61, 0x6c, 0x6d,
+    0x00, 0x62, 0x72, 0x65, 0x65, 0x64, 0x00, 0x62, 0x69, 0x6e, 0x64, 0x00,
+    0x62, 0x61, 0x6e, 0x00, 0x61, 0x73, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69,
+    0x6e, 0x00, 0x61, 0x72, 0x72, 0x65, 0x73, 0x74, 0x00, 0x61, 0x6e, 0x74,
+    0x69, 0x63, 0x69, 0x70, 0x61, 0x74, 0x65, 0x00, 0x61, 0x64, 0x6d, 0x69,
+    0x72, 0x65, 0x00, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x65,
+    0x72, 0x00, 0x61, 0x62, 0x6f, 0x6c, 0x69, 0x73, 0x68, 0x00, 0x77, 0x69,
+    0x74, 0x6e, 0x65, 0x73, 0x73, 0x00, 0x77, 0x69, 0x74, 0x68, 0x73, 0x74,
+    0x61, 0x6e, 0x64, 0x00, 0x77, 0x69, 0x64, 0x65, 0x6e, 0x00, 0x77, 0x65,
+    0x69, 0x67, 0x68, 0x00, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x6e, 0x00, 0x77,
+    0x61, 0x72, 0x6d, 0x00, 0x77, 0x61, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x75,
+    0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x00, 0x75, 0x70, 0x64, 0x61, 0x74,
+    0x65, 0x00, 0x75, 0x6e, 0x69, 0x74, 0x65, 0x00, 0x74, 0x72, 0x61, 0x6e,
+    0x73, 0x70, 0x6f, 0x72, 0x74, 0x00, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x00,
+    0x74, 0x6f, 0x70, 0x00, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74,
+    0x65, 0x00, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x00,
+    0x74, 0x61, 0x78, 0x00, 0x73, 0x77, 0x69, 0x6e, 0x67, 0x00, 0x73, 0x77,
+    0x65, 0x65, 0x70, 0x00, 0x73, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x00,
+    0x73, 0x75, 0x70, 0x65, 0x72, 0x76, 0x69, 0x73, 0x65, 0x00, 0x73, 0x75,
+    0x6d, 0x6d, 0x6f, 0x6e, 0x00, 0x73, 0x75, 0x66, 0x66, 0x69, 0x63, 0x65,
+    0x00, 0x73, 0x74, 0x69, 0x72, 0x00, 0x73, 0x74, 0x65, 0x6d, 0x00, 0x73,
+    0x74, 0x65, 0x65, 0x72, 0x00, 0x73, 0x71, 0x75, 0x65, 0x65, 0x7a, 0x65,
+    0x00, 0x73, 0x70, 0x6f, 0x69, 0x6c, 0x00, 0x73, 0x70, 0x65, 0x63, 0x75,
+    0x6c, 0x61, 0x74, 0x65, 0x00, 0x73, 0x6c, 0x69, 0x64, 0x65, 0x00, 0x73,
+    0x69, 0x67, 0x6e, 0x61, 0x6c, 0x00, 0x73, 0x68, 0x69, 0x70, 0x00, 0x73,
+    0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x00, 0x73, 0x63, 0x72, 0x65, 0x61,
+    0x6d, 0x00, 0x72, 0x75, 0x69, 0x6e, 0x00, 0x72, 0x6f, 0x75, 0x6e, 0x64,
+    0x00, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x00, 0x72, 0x65,
+    0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x00, 0x72, 0x65, 0x71, 0x75, 0x65,
+    0x73, 0x74, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, 0x65,
+    0x72, 0x00, 0x72, 0x65, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x00, 0x72, 0x61,
+    0x63, 0x65, 0x00, 0x70, 0x75, 0x6e, 0x69, 0x73, 0x68, 0x00, 0x70, 0x72,
+    0x6f, 0x6a, 0x65, 0x63, 0x74, 0x00, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x74,
+    0x00, 0x70, 0x72, 0x65, 0x76, 0x61, 0x69, 0x6c, 0x00, 0x70, 0x6f, 0x75,
+    0x72, 0x00, 0x70, 0x6f, 0x73, 0x74, 0x70, 0x6f, 0x6e, 0x65, 0x00, 0x70,
+    0x61, 0x63, 0x6b, 0x00, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x00, 0x6d,
+    0x65, 0x72, 0x67, 0x65, 0x00, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x00,
+    0x6d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, 0x65, 0x00,
+    0x6c, 0x6f, 0x63, 0x6b, 0x00, 0x69, 0x73, 0x6f, 0x6c, 0x61, 0x74, 0x65,
+    0x00, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x69, 0x65, 0x77, 0x00, 0x69,
+    0x6e, 0x73, 0x70, 0x69, 0x72, 0x65, 0x00, 0x69, 0x6e, 0x68, 0x69, 0x62,
+    0x69, 0x74, 0x00, 0x69, 0x6e, 0x64, 0x75, 0x6c, 0x67, 0x65, 0x00, 0x68,
+    0x75, 0x72, 0x72, 0x79, 0x00, 0x68, 0x75, 0x6e, 0x74, 0x00, 0x68, 0x6f,
+    0x6e, 0x6f, 0x75, 0x72, 0x00, 0x68, 0x65, 0x61, 0x6c, 0x00, 0x67, 0x75,
+    0x61, 0x72, 0x64, 0x00, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x00, 0x66,
+    0x72, 0x69, 0x67, 0x68, 0x74, 0x65, 0x6e, 0x00, 0x66, 0x6c, 0x6f, 0x75,
+    0x72, 0x69, 0x73, 0x68, 0x00, 0x66, 0x6c, 0x65, 0x65, 0x00, 0x66, 0x69,
+    0x73, 0x68, 0x00, 0x66, 0x61, 0x6e, 0x63, 0x79, 0x00, 0x66, 0x61, 0x64,
+    0x65, 0x00, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74,
+    0x00, 0x65, 0x78, 0x68, 0x69, 0x62, 0x69, 0x74, 0x00, 0x65, 0x78, 0x65,
+    0x63, 0x75, 0x74, 0x65, 0x00, 0x65, 0x78, 0x63, 0x75, 0x73, 0x65, 0x00,
+    0x65, 0x76, 0x6f, 0x6c, 0x76, 0x65, 0x00, 0x65, 0x6e, 0x74, 0x61, 0x69,
+    0x6c, 0x00, 0x65, 0x6e, 0x64, 0x6f, 0x72, 0x73, 0x65, 0x00, 0x65, 0x6e,
+    0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x65, 0x6c, 0x65, 0x63,
+    0x74, 0x00, 0x64, 0x72, 0x69, 0x66, 0x74, 0x00, 0x64, 0x69, 0x76, 0x65,
+    0x72, 0x74, 0x00, 0x64, 0x69, 0x73, 0x72, 0x75, 0x70, 0x74, 0x00, 0x64,
+    0x69, 0x73, 0x67, 0x75, 0x69, 0x73, 0x65, 0x00, 0x64, 0x69, 0x73, 0x63,
+    0x72, 0x69, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x00, 0x64, 0x69, 0x6d,
+    0x69, 0x6e, 0x69, 0x73, 0x68, 0x00, 0x64, 0x65, 0x73, 0x65, 0x72, 0x76,
+    0x65, 0x00, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x00, 0x63,
+    0x72, 0x69, 0x74, 0x69, 0x63, 0x69, 0x73, 0x65, 0x00, 0x63, 0x72, 0x61,
+    0x63, 0x6b, 0x00, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+    0x64, 0x00, 0x63, 0x6f, 0x70, 0x79, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x72,
+    0x61, 0x63, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x00,
+    0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x00,
+    0x63, 0x6f, 0x6e, 0x66, 0x75, 0x73, 0x65, 0x00, 0x63, 0x6f, 0x6e, 0x66,
+    0x65, 0x73, 0x73, 0x00, 0x63, 0x6f, 0x6e, 0x64, 0x65, 0x6d, 0x6e, 0x00,
+    0x63, 0x6f, 0x6e, 0x63, 0x65, 0x69, 0x76, 0x65, 0x00, 0x63, 0x6f, 0x6e,
+    0x63, 0x65, 0x64, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x6f, 0x6d,
+    0x69, 0x73, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x68, 0x65,
+    0x6e, 0x64, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e,
+    0x74, 0x00, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x63,
+    0x6f, 0x6d, 0x66, 0x6f, 0x72, 0x74, 0x00, 0x63, 0x68, 0x65, 0x65, 0x72,
+    0x00, 0x63, 0x61, 0x74, 0x65, 0x72, 0x00, 0x62, 0x75, 0x72, 0x79, 0x00,
+    0x62, 0x75, 0x72, 0x73, 0x74, 0x00, 0x62, 0x69, 0x74, 0x65, 0x00, 0x62,
+    0x65, 0x74, 0x00, 0x62, 0x65, 0x6e, 0x64, 0x00, 0x62, 0x61, 0x73, 0x65,
+    0x00, 0x61, 0x74, 0x74, 0x61, 0x69, 0x6e, 0x00, 0x61, 0x74, 0x74, 0x61,
+    0x63, 0x68, 0x00, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65,
+    0x00, 0x61, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x00, 0x61, 0x70,
+    0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x73, 0x65, 0x00, 0x61, 0x6c, 0x6c, 0x6f,
+    0x63, 0x61, 0x74, 0x65, 0x00, 0x61, 0x6c, 0x6c, 0x65, 0x76, 0x69, 0x61,
+    0x74, 0x65, 0x00, 0x61, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65,
+    0x00, 0x61, 0x63, 0x63, 0x65, 0x6c, 0x65, 0x72, 0x61, 0x74, 0x65, 0x00,
+    0x7a, 0x65, 0x72, 0x6f, 0x00, 0x77, 0x69, 0x74, 0x68, 0x68, 0x6f, 0x6c,
+    0x64, 0x00, 0x77, 0x69, 0x6e, 0x64, 0x00, 0x77, 0x65, 0x65, 0x70, 0x00,
+    0x77, 0x61, 0x76, 0x65, 0x00, 0x77, 0x61, 0x72, 0x72, 0x61, 0x6e, 0x74,
+    0x00, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x00, 0x76, 0x65, 0x6e, 0x74,
+    0x75, 0x72, 0x65, 0x00, 0x75, 0x72, 0x67, 0x65, 0x00, 0x75, 0x70, 0x68,
+    0x6f, 0x6c, 0x64, 0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x6c, 0x69, 0x6e,
+    0x65, 0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x65, 0x73, 0x74, 0x69, 0x6d,
+    0x61, 0x74, 0x65, 0x00, 0x74, 0x72, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x00,
+    0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x00, 0x74, 0x72, 0x61, 0x70,
+    0x00, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6d, 0x69, 0x74, 0x00, 0x74, 0x6f,
+    0x75, 0x72, 0x00, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x00, 0x74, 0x69, 0x67,
+    0x68, 0x74, 0x65, 0x6e, 0x00, 0x74, 0x68, 0x72, 0x69, 0x76, 0x65, 0x00,
+    0x74, 0x65, 0x6d, 0x70, 0x74, 0x00, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74,
+    0x00, 0x74, 0x61, 0x70, 0x00, 0x73, 0x77, 0x65, 0x61, 0x72, 0x00, 0x73,
+    0x75, 0x6d, 0x00, 0x73, 0x75, 0x62, 0x73, 0x74, 0x69, 0x74, 0x75, 0x74,
+    0x65, 0x00, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x00,
+    0x73, 0x74, 0x72, 0x69, 0x70, 0x00, 0x73, 0x70, 0x72, 0x69, 0x6e, 0x67,
+    0x00, 0x73, 0x6f, 0x66, 0x74, 0x65, 0x6e, 0x00, 0x73, 0x6e, 0x61, 0x70,
+    0x00, 0x73, 0x6d, 0x6f, 0x6f, 0x74, 0x68, 0x00, 0x73, 0x69, 0x6d, 0x70,
+    0x6c, 0x69, 0x66, 0x79, 0x00, 0x73, 0x69, 0x6c, 0x65, 0x6e, 0x63, 0x65,
+    0x00, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x66, 0x79, 0x00, 0x73, 0x68, 0x72,
+    0x69, 0x6e, 0x6b, 0x00, 0x73, 0x68, 0x6f, 0x70, 0x00, 0x73, 0x68, 0x69,
+    0x6e, 0x65, 0x00, 0x73, 0x65, 0x61, 0x6c, 0x00, 0x73, 0x61, 0x6d, 0x70,
+    0x6c, 0x65, 0x00, 0x73, 0x61, 0x63, 0x72, 0x69, 0x66, 0x69, 0x63, 0x65,
+    0x00, 0x72, 0x75, 0x62, 0x00, 0x72, 0x69, 0x64, 0x00, 0x72, 0x65, 0x77,
+    0x61, 0x72, 0x64, 0x00, 0x72, 0x65, 0x76, 0x69, 0x73, 0x65, 0x00, 0x72,
+    0x65, 0x76, 0x65, 0x72, 0x74, 0x00, 0x72, 0x65, 0x74, 0x72, 0x65, 0x61,
+    0x74, 0x00, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x00, 0x72, 0x65,
+    0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x00, 0x72, 0x65, 0x73, 0x65, 0x61,
+    0x72, 0x63, 0x68, 0x00, 0x72, 0x65, 0x6e, 0x74, 0x00, 0x72, 0x65, 0x6d,
+    0x65, 0x64, 0x79, 0x00, 0x72, 0x65, 0x66, 0x72, 0x61, 0x69, 0x6e, 0x00,
+    0x72, 0x65, 0x63, 0x74, 0x69, 0x66, 0x79, 0x00, 0x72, 0x65, 0x63, 0x6f,
+    0x6e, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x00, 0x72, 0x65, 0x63, 0x6c,
+    0x61, 0x69, 0x6d, 0x00, 0x72, 0x61, 0x74, 0x65, 0x00, 0x72, 0x61, 0x6e,
+    0x67, 0x65, 0x00, 0x72, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x72, 0x61, 0x69,
+    0x6e, 0x00, 0x71, 0x75, 0x61, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x00, 0x70,
+    0x72, 0x6f, 0x73, 0x65, 0x63, 0x75, 0x74, 0x65, 0x00, 0x70, 0x72, 0x65,
+    0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x00, 0x70, 0x72, 0x65, 0x63, 0x6c,
+    0x75, 0x64, 0x65, 0x00, 0x70, 0x72, 0x65, 0x61, 0x63, 0x68, 0x00, 0x70,
+    0x72, 0x61, 0x63, 0x74, 0x69, 0x63, 0x65, 0x00, 0x70, 0x6f, 0x73, 0x74,
+    0x00, 0x70, 0x6f, 0x72, 0x74, 0x72, 0x61, 0x79, 0x00, 0x70, 0x6f, 0x70,
+    0x00, 0x70, 0x6c, 0x65, 0x61, 0x64, 0x00, 0x70, 0x69, 0x6e, 0x00, 0x70,
+    0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x00, 0x70, 0x61, 0x75, 0x73, 0x65,
+    0x00, 0x70, 0x61, 0x72, 0x6b, 0x00, 0x70, 0x61, 0x6e, 0x69, 0x63, 0x00,
+    0x6f, 0x77, 0x65, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x74, 0x68, 0x72, 0x6f,
+    0x77, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x00, 0x6f,
+    0x76, 0x65, 0x72, 0x6c, 0x6f, 0x6f, 0x6b, 0x00, 0x6f, 0x75, 0x74, 0x6c,
+    0x69, 0x6e, 0x65, 0x00, 0x6f, 0x66, 0x66, 0x65, 0x6e, 0x64, 0x00, 0x6f,
+    0x62, 0x73, 0x63, 0x75, 0x72, 0x65, 0x00, 0x6f, 0x62, 0x6c, 0x69, 0x67,
+    0x65, 0x00, 0x6e, 0x6f, 0x00, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x00,
+    0x6e, 0x65, 0x67, 0x6c, 0x65, 0x63, 0x74, 0x00, 0x6d, 0x75, 0x73, 0x74,
+    0x65, 0x72, 0x00, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x00,
+    0x6d, 0x65, 0x6c, 0x74, 0x00, 0x6d, 0x61, 0x72, 0x63, 0x68, 0x00, 0x6c,
+    0x75, 0x6e, 0x63, 0x68, 0x00, 0x6c, 0x6f, 0x6e, 0x67, 0x00, 0x6c, 0x6f,
+    0x61, 0x64, 0x00, 0x6c, 0x65, 0x73, 0x73, 0x65, 0x6e, 0x00, 0x6c, 0x65,
+    0x61, 0x70, 0x00, 0x6c, 0x65, 0x61, 0x6e, 0x00, 0x69, 0x6e, 0x76, 0x6f,
+    0x6b, 0x65, 0x00, 0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x00, 0x69, 0x6e,
+    0x76, 0x61, 0x64, 0x65, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x75,
+    0x70, 0x74, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, 0x00,
+    0x69, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x00, 0x69, 0x6e, 0x73, 0x74, 0x72,
+    0x75, 0x63, 0x74, 0x00, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x00, 0x69,
+    0x6e, 0x68, 0x65, 0x72, 0x69, 0x74, 0x00, 0x69, 0x6e, 0x66, 0x6c, 0x69,
+    0x63, 0x74, 0x00, 0x69, 0x6e, 0x66, 0x65, 0x72, 0x00, 0x69, 0x6e, 0x63,
+    0x75, 0x72, 0x00, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x00, 0x69, 0x6d,
+    0x69, 0x74, 0x61, 0x74, 0x65, 0x00, 0x68, 0x6f, 0x73, 0x74, 0x00, 0x68,
+    0x65, 0x61, 0x74, 0x00, 0x67, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x67,
+    0x61, 0x75, 0x67, 0x65, 0x00, 0x66, 0x72, 0x65, 0x65, 0x7a, 0x65, 0x00,
+    0x66, 0x6f, 0x72, 0x65, 0x73, 0x65, 0x65, 0x00, 0x66, 0x6c, 0x6f, 0x61,
+    0x74, 0x00, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x65, 0x78, 0x70, 0x6f, 0x72,
+    0x74, 0x00, 0x65, 0x78, 0x70, 0x6c, 0x6f, 0x64, 0x65, 0x00, 0x65, 0x76,
+    0x6f, 0x6b, 0x65, 0x00, 0x65, 0x76, 0x61, 0x64, 0x65, 0x00, 0x65, 0x72,
+    0x65, 0x63, 0x74, 0x00, 0x65, 0x72, 0x61, 0x64, 0x69, 0x63, 0x61, 0x74,
+    0x65, 0x00, 0x65, 0x71, 0x75, 0x69, 0x70, 0x00, 0x65, 0x6e, 0x76, 0x69,
+    0x73, 0x61, 0x67, 0x65, 0x00, 0x65, 0x6e, 0x71, 0x75, 0x69, 0x72, 0x65,
+    0x00, 0x65, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x73, 0x73, 0x00, 0x65,
+    0x6d, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x65, 0x6d, 0x62, 0x61, 0x72,
+    0x6b, 0x00, 0x65, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x00, 0x65, 0x64, 0x75,
+    0x63, 0x61, 0x74, 0x65, 0x00, 0x65, 0x64, 0x69, 0x74, 0x00, 0x64, 0x77,
+    0x65, 0x6c, 0x6c, 0x00, 0x64, 0x72, 0x6f, 0x77, 0x6e, 0x00, 0x64, 0x72,
+    0x61, 0x69, 0x6e, 0x00, 0x64, 0x72, 0x61, 0x66, 0x74, 0x00, 0x64, 0x69,
+    0x76, 0x6f, 0x72, 0x63, 0x65, 0x00, 0x64, 0x69, 0x73, 0x74, 0x72, 0x61,
+    0x63, 0x74, 0x00, 0x64, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x74, 0x00, 0x64,
+    0x69, 0x73, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x00, 0x64, 0x69, 0x73, 0x70,
+    0x65, 0x6e, 0x73, 0x65, 0x00, 0x64, 0x69, 0x73, 0x63, 0x68, 0x61, 0x72,
+    0x67, 0x65, 0x00, 0x64, 0x69, 0x73, 0x63, 0x65, 0x72, 0x6e, 0x00, 0x64,
+    0x69, 0x73, 0x61, 0x67, 0x72, 0x65, 0x65, 0x00, 0x64, 0x69, 0x66, 0x66,
+    0x65, 0x72, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, 0x00, 0x64, 0x69,
+    0x63, 0x74, 0x61, 0x74, 0x65, 0x00, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c,
+    0x00, 0x64, 0x65, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x00, 0x64, 0x65, 0x70,
+    0x72, 0x69, 0x76, 0x65, 0x00, 0x64, 0x65, 0x70, 0x61, 0x72, 0x74, 0x00,
+    0x64, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x00, 0x64, 0x65, 0x62, 0x61,
+    0x74, 0x65, 0x00, 0x63, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65,
+    0x00, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x69, 0x7a, 0x65, 0x00, 0x63,
+    0x72, 0x65, 0x65, 0x70, 0x00, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x00,
+    0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x61, 0x63, 0x74, 0x00, 0x63,
+    0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x00, 0x63, 0x6f, 0x6e,
+    0x74, 0x65, 0x73, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65,
+    0x00, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x00, 0x63, 0x6f,
+    0x6e, 0x73, 0x65, 0x6e, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x71, 0x75, 0x65,
+    0x72, 0x00, 0x63, 0x6f, 0x6e, 0x67, 0x72, 0x61, 0x74, 0x75, 0x6c, 0x61,
+    0x74, 0x65, 0x00, 0x63, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x00,
+    0x63, 0x6f, 0x6e, 0x66, 0x69, 0x6e, 0x65, 0x00, 0x63, 0x6f, 0x6e, 0x66,
+    0x65, 0x72, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x69, 0x73, 0x65, 0x00,
+    0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x61, 0x74, 0x65, 0x00,
+    0x63, 0x6c, 0x69, 0x6e, 0x67, 0x00, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x69,
+    0x66, 0x79, 0x00, 0x63, 0x68, 0x61, 0x74, 0x00, 0x63, 0x68, 0x61, 0x73,
+    0x65, 0x00, 0x63, 0x61, 0x6d, 0x70, 0x61, 0x69, 0x67, 0x6e, 0x00, 0x62,
+    0x72, 0x75, 0x73, 0x68, 0x00, 0x62, 0x72, 0x6f, 0x61, 0x64, 0x65, 0x6e,
+    0x00, 0x62, 0x6f, 0x6c, 0x73, 0x74, 0x65, 0x72, 0x00, 0x62, 0x6f, 0x69,
+    0x6c, 0x00, 0x62, 0x6f, 0x61, 0x73, 0x74, 0x00, 0x62, 0x69, 0x64, 0x00,
+    0x62, 0x65, 0x74, 0x72, 0x61, 0x79, 0x00, 0x62, 0x65, 0x67, 0x00, 0x61,
+    0x77, 0x61, 0x72, 0x64, 0x00, 0x61, 0x77, 0x61, 0x69, 0x74, 0x00, 0x61,
+    0x76, 0x65, 0x72, 0x74, 0x00, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75,
+    0x74, 0x65, 0x00, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x00, 0x61, 0x72,
+    0x74, 0x69, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x61, 0x72, 0x6f,
+    0x75, 0x73, 0x65, 0x00, 0x61, 0x6d, 0x65, 0x6e, 0x64, 0x00, 0x61, 0x6c,
+    0x65, 0x72, 0x74, 0x00, 0x61, 0x64, 0x68, 0x65, 0x72, 0x65, 0x00, 0x61,
+    0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x00, 0x61, 0x63, 0x63, 0x75,
+    0x73, 0x65, 0x00, 0x61, 0x63, 0x63, 0x75, 0x6d, 0x75, 0x6c, 0x61, 0x74,
+    0x65, 0x00, 0x61, 0x63, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x69, 0x73, 0x68,
+    0x00, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x00, 0x61, 0x62, 0x69, 0x64,
+    0x65, 0x00, 0x77, 0x72, 0x69, 0x67, 0x67, 0x6c, 0x65, 0x00, 0x77, 0x72,
+    0x65, 0x63, 0x6b, 0x00, 0x77, 0x72, 0x61, 0x70, 0x00, 0x77, 0x6f, 0x72,
+    0x73, 0x68, 0x69, 0x70, 0x00, 0x77, 0x6f, 0x72, 0x73, 0x65, 0x6e, 0x00,
+    0x77, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x77, 0x68, 0x69, 0x73, 0x70, 0x65,
+    0x72, 0x00, 0x77, 0x65, 0x61, 0x76, 0x65, 0x00, 0x77, 0x61, 0x69, 0x76,
+    0x65, 0x00, 0x76, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x65, 0x65, 0x72, 0x00,
+    0x76, 0x69, 0x73, 0x75, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x00, 0x76, 0x69,
+    0x73, 0x75, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x00, 0x76, 0x69, 0x6f, 0x6c,
+    0x61, 0x74, 0x65, 0x00, 0x76, 0x65, 0x74, 0x6f, 0x00, 0x76, 0x61, 0x6e,
+    0x69, 0x73, 0x68, 0x00, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65,
+    0x00, 0x75, 0x74, 0x74, 0x65, 0x72, 0x00, 0x75, 0x74, 0x69, 0x6c, 0x69,
+    0x73, 0x65, 0x00, 0x75, 0x6e, 0x76, 0x65, 0x69, 0x6c, 0x00, 0x75, 0x6e,
+    0x72, 0x61, 0x76, 0x65, 0x6c, 0x00, 0x75, 0x6e, 0x6c, 0x6f, 0x63, 0x6b,
+    0x00, 0x75, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x00, 0x75, 0x6e, 0x64, 0x6f,
+    0x00, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x70, 0x69, 0x6e, 0x00, 0x75, 0x6e,
+    0x63, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x74, 0x77, 0x69, 0x73, 0x74, 0x00,
+    0x74, 0x75, 0x6e, 0x65, 0x00, 0x74, 0x75, 0x63, 0x6b, 0x00, 0x74, 0x72,
+    0x69, 0x70, 0x00, 0x74, 0x72, 0x69, 0x6d, 0x00, 0x74, 0x72, 0x65, 0x6d,
+    0x62, 0x6c, 0x65, 0x00, 0x74, 0x72, 0x65, 0x61, 0x64, 0x00, 0x74, 0x72,
+    0x61, 0x6e, 0x73, 0x63, 0x65, 0x6e, 0x64, 0x00, 0x74, 0x6f, 0x70, 0x70,
+    0x6c, 0x65, 0x00, 0x74, 0x69, 0x70, 0x00, 0x74, 0x69, 0x64, 0x79, 0x00,
+    0x74, 0x69, 0x63, 0x6b, 0x00, 0x74, 0x68, 0x77, 0x61, 0x72, 0x74, 0x00,
+    0x74, 0x65, 0x73, 0x74, 0x69, 0x66, 0x79, 0x00, 0x74, 0x65, 0x6e, 0x64,
+    0x65, 0x72, 0x00, 0x74, 0x65, 0x61, 0x73, 0x65, 0x00, 0x73, 0x77, 0x65,
+    0x6c, 0x6c, 0x00, 0x73, 0x77, 0x65, 0x61, 0x74, 0x00, 0x73, 0x77, 0x61,
+    0x70, 0x00, 0x73, 0x75, 0x72, 0x76, 0x65, 0x79, 0x00, 0x73, 0x75, 0x6d,
+    0x6d, 0x61, 0x72, 0x69, 0x7a, 0x65, 0x00, 0x73, 0x75, 0x6d, 0x6d, 0x61,
+    0x72, 0x69, 0x73, 0x65, 0x00, 0x73, 0x75, 0x63, 0x6b, 0x00, 0x73, 0x75,
+    0x63, 0x63, 0x75, 0x6d, 0x62, 0x00, 0x73, 0x75, 0x62, 0x73, 0x74, 0x61,
+    0x6e, 0x74, 0x69, 0x61, 0x74, 0x65, 0x00, 0x73, 0x75, 0x62, 0x73, 0x69,
+    0x64, 0x69, 0x73, 0x65, 0x00, 0x73, 0x75, 0x62, 0x64, 0x75, 0x65, 0x00,
+    0x73, 0x74, 0x75, 0x6d, 0x62, 0x6c, 0x65, 0x00, 0x73, 0x74, 0x75, 0x66,
+    0x66, 0x00, 0x73, 0x74, 0x72, 0x6f, 0x6b, 0x65, 0x00, 0x73, 0x74, 0x72,
+    0x69, 0x76, 0x65, 0x00, 0x73, 0x74, 0x72, 0x61, 0x79, 0x00, 0x73, 0x74,
+    0x72, 0x61, 0x69, 0x6e, 0x00, 0x73, 0x74, 0x72, 0x61, 0x69, 0x67, 0x68,
+    0x74, 0x65, 0x6e, 0x00, 0x73, 0x74, 0x69, 0x66, 0x6c, 0x65, 0x00, 0x73,
+    0x74, 0x65, 0x61, 0x64, 0x79, 0x00, 0x73, 0x74, 0x61, 0x72, 0x00, 0x73,
+    0x74, 0x61, 0x72, 0x76, 0x65, 0x00, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x00,
+    0x73, 0x74, 0x61, 0x66, 0x66, 0x00, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c,
+    0x69, 0x7a, 0x65, 0x00, 0x73, 0x74, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x73,
+    0x65, 0x00, 0x73, 0x71, 0x75, 0x61, 0x72, 0x65, 0x00, 0x73, 0x70, 0x6f,
+    0x6e, 0x73, 0x6f, 0x72, 0x00, 0x73, 0x70, 0x69, 0x6e, 0x00, 0x73, 0x70,
+    0x69, 0x6c, 0x6c, 0x00, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c, 0x69,
+    0x73, 0x65, 0x00, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x00, 0x73, 0x6f, 0x6f,
+    0x74, 0x68, 0x65, 0x00, 0x73, 0x6f, 0x61, 0x72, 0x00, 0x73, 0x6f, 0x61,
+    0x6b, 0x00, 0x73, 0x6e, 0x69, 0x66, 0x66, 0x00, 0x73, 0x6e, 0x65, 0x61,
+    0x6b, 0x00, 0x73, 0x6e, 0x61, 0x74, 0x63, 0x68, 0x00, 0x73, 0x6d, 0x61,
+    0x73, 0x68, 0x00, 0x73, 0x6b, 0x69, 0x70, 0x00, 0x73, 0x69, 0x6d, 0x75,
+    0x6c, 0x61, 0x74, 0x65, 0x00, 0x73, 0x68, 0x72, 0x75, 0x67, 0x00, 0x73,
+    0x68, 0x6f, 0x75, 0x6c, 0x64, 0x65, 0x72, 0x00, 0x73, 0x68, 0x6f, 0x72,
+    0x74, 0x65, 0x6e, 0x00, 0x73, 0x68, 0x6f, 0x72, 0x65, 0x00, 0x73, 0x68,
+    0x6f, 0x63, 0x6b, 0x00, 0x73, 0x68, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x73,
+    0x68, 0x65, 0x6c, 0x74, 0x65, 0x72, 0x00, 0x73, 0x68, 0x61, 0x76, 0x65,
+    0x00, 0x73, 0x68, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x00, 0x73, 0x65, 0x64,
+    0x75, 0x63, 0x65, 0x00, 0x73, 0x63, 0x72, 0x65, 0x77, 0x00, 0x73, 0x63,
+    0x72, 0x65, 0x65, 0x6e, 0x00, 0x73, 0x63, 0x72, 0x61, 0x74, 0x63, 0x68,
+    0x00, 0x73, 0x63, 0x72, 0x61, 0x70, 0x00, 0x73, 0x63, 0x72, 0x61, 0x70,
+    0x65, 0x00, 0x73, 0x63, 0x72, 0x61, 0x6d, 0x62, 0x6c, 0x65, 0x00, 0x73,
+    0x63, 0x61, 0x72, 0x65, 0x00, 0x73, 0x63, 0x61, 0x6e, 0x00, 0x73, 0x63,
+    0x61, 0x6c, 0x65, 0x00, 0x73, 0x61, 0x76, 0x6f, 0x75, 0x72, 0x00, 0x73,
+    0x61, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x73, 0x61, 0x6c, 0x76,
+    0x61, 0x67, 0x65, 0x00, 0x73, 0x61, 0x63, 0x6b, 0x00, 0x72, 0x6f, 0x75,
+    0x73, 0x65, 0x00, 0x72, 0x6f, 0x74, 0x00, 0x72, 0x6f, 0x74, 0x61, 0x74,
+    0x65, 0x00, 0x72, 0x6f, 0x6f, 0x74, 0x00, 0x72, 0x6f, 0x63, 0x6b, 0x00,
+    0x72, 0x6f, 0x62, 0x00, 0x72, 0x6f, 0x61, 0x6d, 0x00, 0x72, 0x69, 0x76,
+    0x61, 0x6c, 0x00, 0x72, 0x69, 0x70, 0x00, 0x72, 0x65, 0x77, 0x72, 0x69,
+    0x74, 0x65, 0x00, 0x72, 0x65, 0x76, 0x6f, 0x6b, 0x65, 0x00, 0x72, 0x65,
+    0x74, 0x68, 0x69, 0x6e, 0x6b, 0x00, 0x72, 0x65, 0x74, 0x61, 0x6c, 0x69,
+    0x61, 0x74, 0x65, 0x00, 0x72, 0x65, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74,
+    0x75, 0x72, 0x65, 0x00, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x00,
+    0x72, 0x65, 0x73, 0x6f, 0x72, 0x74, 0x00, 0x72, 0x65, 0x73, 0x69, 0x64,
+    0x65, 0x00, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x00, 0x72, 0x65, 0x70,
+    0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x72, 0x65, 0x6f, 0x70, 0x65,
+    0x6e, 0x00, 0x72, 0x65, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x00, 0x72,
+    0x65, 0x6d, 0x61, 0x72, 0x6b, 0x00, 0x72, 0x65, 0x6c, 0x6f, 0x63, 0x61,
+    0x74, 0x65, 0x00, 0x72, 0x65, 0x6c, 0x69, 0x73, 0x68, 0x00, 0x72, 0x65,
+    0x6c, 0x69, 0x6e, 0x71, 0x75, 0x69, 0x73, 0x68, 0x00, 0x72, 0x65, 0x6a,
+    0x6f, 0x69, 0x6e, 0x00, 0x72, 0x65, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x74,
+    0x65, 0x00, 0x72, 0x65, 0x68, 0x65, 0x61, 0x72, 0x73, 0x65, 0x00, 0x72,
+    0x65, 0x66, 0x75, 0x74, 0x65, 0x00, 0x72, 0x65, 0x66, 0x69, 0x6e, 0x65,
+    0x00, 0x72, 0x65, 0x64, 0x72, 0x65, 0x73, 0x73, 0x00, 0x72, 0x65, 0x64,
+    0x65, 0x65, 0x6d, 0x00, 0x72, 0x65, 0x63, 0x79, 0x63, 0x6c, 0x65, 0x00,
+    0x72, 0x65, 0x63, 0x75, 0x72, 0x00, 0x72, 0x65, 0x63, 0x72, 0x65, 0x61,
+    0x74, 0x65, 0x00, 0x72, 0x65, 0x63, 0x6f, 0x75, 0x70, 0x00, 0x72, 0x65,
+    0x63, 0x6b, 0x6f, 0x6e, 0x00, 0x72, 0x65, 0x63, 0x69, 0x74, 0x65, 0x00,
+    0x72, 0x65, 0x63, 0x61, 0x70, 0x74, 0x75, 0x72, 0x65, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x73, 0x65, 0x73, 0x73, 0x00, 0x72, 0x65, 0x61, 0x73, 0x73,
+    0x65, 0x72, 0x74, 0x00, 0x72, 0x65, 0x61, 0x72, 0x00, 0x72, 0x65, 0x61,
+    0x70, 0x00, 0x72, 0x65, 0x61, 0x70, 0x70, 0x65, 0x61, 0x72, 0x00, 0x72,
+    0x65, 0x2d, 0x6f, 0x70, 0x65, 0x6e, 0x00, 0x72, 0x65, 0x2d, 0x65, 0x73,
+    0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x00, 0x72, 0x61, 0x74, 0x69,
+    0x66, 0x79, 0x00, 0x72, 0x61, 0x70, 0x65, 0x00, 0x72, 0x61, 0x6e, 0x6b,
+    0x00, 0x71, 0x75, 0x65, 0x6c, 0x6c, 0x00, 0x71, 0x75, 0x61, 0x72, 0x72,
+    0x65, 0x6c, 0x00, 0x70, 0x75, 0x6e, 0x63, 0x68, 0x00, 0x70, 0x75, 0x6d,
+    0x70, 0x00, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x69, 0x73, 0x65, 0x00,
+    0x70, 0x72, 0x6f, 0x73, 0x70, 0x65, 0x72, 0x00, 0x70, 0x72, 0x6f, 0x70,
+    0x00, 0x70, 0x72, 0x6f, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x00, 0x70,
+    0x72, 0x6f, 0x6d, 0x70, 0x74, 0x00, 0x70, 0x72, 0x6f, 0x6c, 0x6f, 0x6e,
+    0x67, 0x00, 0x70, 0x72, 0x6f, 0x68, 0x69, 0x62, 0x69, 0x74, 0x00, 0x70,
+    0x72, 0x6f, 0x63, 0x75, 0x72, 0x65, 0x00, 0x70, 0x72, 0x6f, 0x63, 0x6c,
+    0x61, 0x69, 0x6d, 0x00, 0x70, 0x72, 0x6f, 0x62, 0x65, 0x00, 0x70, 0x72,
+    0x69, 0x76, 0x61, 0x74, 0x69, 0x73, 0x65, 0x00, 0x70, 0x72, 0x69, 0x73,
+    0x65, 0x00, 0x70, 0x72, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x00, 0x70, 0x72,
+    0x65, 0x6a, 0x75, 0x64, 0x69, 0x63, 0x65, 0x00, 0x70, 0x72, 0x65, 0x63,
+    0x69, 0x70, 0x69, 0x74, 0x61, 0x74, 0x65, 0x00, 0x70, 0x72, 0x65, 0x63,
+    0x65, 0x64, 0x65, 0x00, 0x70, 0x72, 0x61, 0x69, 0x73, 0x65, 0x00, 0x70,
+    0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x70, 0x6f, 0x69, 0x73,
+    0x6f, 0x6e, 0x00, 0x70, 0x6c, 0x75, 0x6e, 0x67, 0x65, 0x00, 0x70, 0x6c,
+    0x75, 0x67, 0x00, 0x70, 0x6c, 0x6f, 0x75, 0x67, 0x68, 0x00, 0x70, 0x6c,
+    0x6f, 0x74, 0x00, 0x70, 0x6c, 0x61, 0x63, 0x61, 0x74, 0x65, 0x00, 0x70,
+    0x69, 0x74, 0x63, 0x68, 0x00, 0x70, 0x69, 0x6e, 0x70, 0x6f, 0x69, 0x6e,
+    0x74, 0x00, 0x70, 0x69, 0x63, 0x74, 0x75, 0x72, 0x65, 0x00, 0x70, 0x68,
+    0x6f, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x00, 0x70, 0x65, 0x72,
+    0x70, 0x65, 0x74, 0x75, 0x61, 0x74, 0x65, 0x00, 0x70, 0x65, 0x72, 0x66,
+    0x65, 0x63, 0x74, 0x00, 0x70, 0x65, 0x65, 0x72, 0x00, 0x6f, 0x76, 0x65,
+    0x72, 0x77, 0x68, 0x65, 0x6c, 0x6d, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x74,
+    0x75, 0x72, 0x6e, 0x00, 0x6f, 0x76, 0x65, 0x72, 0x74, 0x61, 0x6b, 0x65,
+    0x00, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x61, 0x70, 0x00, 0x6f, 0x75, 0x74,
+    0x77, 0x65, 0x69, 0x67, 0x68, 0x00, 0x6f, 0x75, 0x73, 0x74, 0x00, 0x6f,
+    0x6d, 0x69, 0x74, 0x00, 0x6f, 0x62, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74,
+    0x00, 0x6e, 0x6f, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x00, 0x6e, 0x6f,
+    0x64, 0x00, 0x6e, 0x65, 0x63, 0x65, 0x73, 0x73, 0x69, 0x74, 0x61, 0x74,
+    0x65, 0x00, 0x6e, 0x65, 0x61, 0x72, 0x00, 0x6e, 0x61, 0x76, 0x69, 0x67,
+    0x61, 0x74, 0x65, 0x00, 0x6e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x00, 0x6d,
+    0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x75, 0x6c,
+    0x64, 0x00, 0x6d, 0x6f, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x00, 0x6d,
+    0x6f, 0x64, 0x65, 0x72, 0x6e, 0x69, 0x73, 0x65, 0x00, 0x6d, 0x6f, 0x64,
+    0x65, 0x72, 0x61, 0x74, 0x65, 0x00, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x00,
+    0x6d, 0x6f, 0x62, 0x69, 0x6c, 0x69, 0x7a, 0x65, 0x00, 0x6d, 0x69, 0x74,
+    0x69, 0x67, 0x61, 0x74, 0x65, 0x00, 0x6d, 0x69, 0x73, 0x6c, 0x65, 0x61,
+    0x64, 0x00, 0x6d, 0x69, 0x6d, 0x69, 0x63, 0x00, 0x6d, 0x69, 0x67, 0x72,
+    0x61, 0x74, 0x65, 0x00, 0x6d, 0x65, 0x73, 0x73, 0x00, 0x6d, 0x65, 0x72,
+    0x69, 0x74, 0x00, 0x6d, 0x65, 0x6e, 0x64, 0x00, 0x6d, 0x65, 0x64, 0x69,
+    0x61, 0x74, 0x65, 0x00, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x69, 0x7a, 0x65,
+    0x00, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x65, 0x00, 0x6d, 0x61, 0x74, 0x65,
+    0x00, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x73, 0x65,
+    0x00, 0x6d, 0x61, 0x73, 0x6b, 0x00, 0x6d, 0x61, 0x70, 0x00, 0x6d, 0x61,
+    0x6e, 0x6f, 0x65, 0x75, 0x76, 0x72, 0x65, 0x00, 0x6d, 0x61, 0x6e, 0x69,
+    0x66, 0x65, 0x73, 0x74, 0x00, 0x6c, 0x75, 0x72, 0x65, 0x00, 0x6c, 0x6f,
+    0x6f, 0x73, 0x65, 0x00, 0x6c, 0x6f, 0x6f, 0x73, 0x65, 0x6e, 0x00, 0x6c,
+    0x6f, 0x64, 0x67, 0x65, 0x00, 0x6c, 0x6f, 0x62, 0x62, 0x79, 0x00, 0x6c,
+    0x69, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x65,
+    0x6e, 0x00, 0x6c, 0x69, 0x63, 0x6b, 0x00, 0x6c, 0x69, 0x63, 0x65, 0x6e,
+    0x73, 0x65, 0x00, 0x6c, 0x69, 0x62, 0x65, 0x72, 0x61, 0x74, 0x65, 0x00,
+    0x6c, 0x69, 0x61, 0x69, 0x73, 0x65, 0x00, 0x6c, 0x65, 0x76, 0x79, 0x00,
+    0x6c, 0x65, 0x76, 0x65, 0x6c, 0x00, 0x6c, 0x65, 0x67, 0x69, 0x73, 0x6c,
+    0x61, 0x74, 0x65, 0x00, 0x6c, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x00,
+    0x6c, 0x61, 0x62, 0x6f, 0x75, 0x72, 0x00, 0x6c, 0x61, 0x62, 0x65, 0x6c,
+    0x00, 0x6a, 0x65, 0x6f, 0x70, 0x61, 0x72, 0x64, 0x69, 0x73, 0x65, 0x00,
+    0x6a, 0x61, 0x69, 0x6c, 0x00, 0x69, 0x72, 0x6f, 0x6e, 0x00, 0x69, 0x6e,
+    0x74, 0x72, 0x75, 0x64, 0x65, 0x00, 0x69, 0x6e, 0x74, 0x69, 0x6d, 0x69,
+    0x64, 0x61, 0x74, 0x65, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x65,
+    0x70, 0x74, 0x00, 0x69, 0x6e, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x66, 0x79,
+    0x00, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x6c, 0x00, 0x69, 0x6e, 0x71, 0x75,
+    0x69, 0x72, 0x65, 0x00, 0x69, 0x6e, 0x6a, 0x75, 0x72, 0x65, 0x00, 0x69,
+    0x6e, 0x6a, 0x65, 0x63, 0x74, 0x00, 0x69, 0x6d, 0x70, 0x65, 0x64, 0x65,
+    0x00, 0x69, 0x6d, 0x70, 0x61, 0x72, 0x74, 0x00, 0x69, 0x6d, 0x70, 0x61,
+    0x69, 0x72, 0x00, 0x69, 0x6c, 0x6c, 0x75, 0x6d, 0x69, 0x6e, 0x61, 0x74,
+    0x65, 0x00, 0x68, 0x6f, 0x6f, 0x6b, 0x00, 0x68, 0x65, 0x65, 0x64, 0x00,
+    0x68, 0x61, 0x75, 0x6e, 0x74, 0x00, 0x68, 0x61, 0x75, 0x6c, 0x00, 0x68,
+    0x61, 0x73, 0x74, 0x65, 0x6e, 0x00, 0x68, 0x61, 0x72, 0x6e, 0x65, 0x73,
+    0x73, 0x00, 0x68, 0x61, 0x72, 0x64, 0x65, 0x6e, 0x00, 0x68, 0x61, 0x72,
+    0x62, 0x6f, 0x75, 0x72, 0x00, 0x68, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x00,
+    0x67, 0x72, 0x69, 0x70, 0x00, 0x67, 0x72, 0x69, 0x6e, 0x64, 0x00, 0x67,
+    0x72, 0x69, 0x65, 0x76, 0x65, 0x00, 0x67, 0x6c, 0x69, 0x6d, 0x70, 0x73,
+    0x65, 0x00, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x7a, 0x65,
+    0x00, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x73, 0x65, 0x00,
+    0x67, 0x61, 0x7a, 0x65, 0x00, 0x66, 0x75, 0x72, 0x6e, 0x69, 0x73, 0x68,
+    0x00, 0x66, 0x75, 0x63, 0x6b, 0x00, 0x66, 0x72, 0x75, 0x73, 0x74, 0x72,
+    0x61, 0x74, 0x65, 0x00, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x00, 0x66, 0x6f,
+    0x72, 0x67, 0x6f, 0x00, 0x66, 0x6f, 0x72, 0x67, 0x65, 0x00, 0x66, 0x6f,
+    0x72, 0x65, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x00, 0x66, 0x6f, 0x72, 0x65,
+    0x63, 0x61, 0x73, 0x74, 0x00, 0x66, 0x6f, 0x6f, 0x6c, 0x00, 0x66, 0x6f,
+    0x6c, 0x64, 0x00, 0x66, 0x6c, 0x75, 0x73, 0x68, 0x00, 0x66, 0x6c, 0x6f,
+    0x77, 0x65, 0x72, 0x00, 0x66, 0x6c, 0x6f, 0x6f, 0x64, 0x00, 0x66, 0x6c,
+    0x61, 0x73, 0x68, 0x00, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x00, 0x66,
+    0x65, 0x6e, 0x64, 0x00, 0x66, 0x61, 0x74, 0x68, 0x6f, 0x6d, 0x00, 0x66,
+    0x61, 0x73, 0x74, 0x00, 0x66, 0x61, 0x73, 0x68, 0x69, 0x6f, 0x6e, 0x00,
+    0x66, 0x61, 0x69, 0x6e, 0x74, 0x00, 0x65, 0x78, 0x70, 0x69, 0x72, 0x65,
+    0x00, 0x65, 0x78, 0x70, 0x65, 0x6c, 0x00, 0x65, 0x78, 0x63, 0x69, 0x74,
+    0x65, 0x00, 0x65, 0x78, 0x61, 0x67, 0x67, 0x65, 0x72, 0x61, 0x74, 0x65,
+    0x00, 0x65, 0x76, 0x61, 0x63, 0x75, 0x61, 0x74, 0x65, 0x00, 0x65, 0x73,
+    0x63, 0x6f, 0x72, 0x74, 0x00, 0x65, 0x71, 0x75, 0x61, 0x74, 0x65, 0x00,
+    0x65, 0x6e, 0x76, 0x79, 0x00, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x6c, 0x65,
+    0x00, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x65, 0x00, 0x65, 0x6e, 0x73, 0x75,
+    0x65, 0x00, 0x65, 0x6e, 0x72, 0x69, 0x63, 0x68, 0x00, 0x65, 0x6e, 0x6c,
+    0x69, 0x73, 0x74, 0x00, 0x65, 0x6e, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x00,
+    0x65, 0x6e, 0x64, 0x65, 0x61, 0x76, 0x6f, 0x75, 0x72, 0x00, 0x65, 0x6e,
+    0x64, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x65, 0x6e, 0x63, 0x6c, 0x6f,
+    0x73, 0x65, 0x00, 0x65, 0x6e, 0x61, 0x63, 0x74, 0x00, 0x65, 0x6d, 0x70,
+    0x74, 0x79, 0x00, 0x65, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x00,
+    0x65, 0x6d, 0x62, 0x6f, 0x64, 0x79, 0x00, 0x65, 0x6d, 0x62, 0x61, 0x72,
+    0x72, 0x61, 0x73, 0x73, 0x00, 0x65, 0x6c, 0x75, 0x63, 0x69, 0x64, 0x61,
+    0x74, 0x65, 0x00, 0x65, 0x6c, 0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x65,
+    0x00, 0x65, 0x63, 0x68, 0x6f, 0x00, 0x64, 0x75, 0x73, 0x74, 0x00, 0x64,
+    0x75, 0x6d, 0x70, 0x00, 0x64, 0x75, 0x63, 0x6b, 0x00, 0x64, 0x72, 0x69,
+    0x6c, 0x6c, 0x00, 0x64, 0x6f, 0x6e, 0x61, 0x74, 0x65, 0x00, 0x64, 0x6f,
+    0x64, 0x67, 0x65, 0x00, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74,
+    0x00, 0x64, 0x69, 0x76, 0x65, 0x00, 0x64, 0x69, 0x76, 0x65, 0x72, 0x73,
+    0x69, 0x66, 0x79, 0x00, 0x64, 0x69, 0x73, 0x73, 0x75, 0x61, 0x64, 0x65,
+    0x00, 0x64, 0x69, 0x73, 0x72, 0x65, 0x67, 0x61, 0x72, 0x64, 0x00, 0x64,
+    0x69, 0x73, 0x70, 0x75, 0x74, 0x65, 0x00, 0x64, 0x69, 0x73, 0x70, 0x6c,
+    0x61, 0x63, 0x65, 0x00, 0x64, 0x69, 0x73, 0x70, 0x65, 0x72, 0x73, 0x65,
+    0x00, 0x64, 0x69, 0x73, 0x70, 0x65, 0x6c, 0x00, 0x64, 0x69, 0x73, 0x6d,
+    0x61, 0x6e, 0x74, 0x6c, 0x65, 0x00, 0x64, 0x69, 0x73, 0x6c, 0x6f, 0x64,
+    0x67, 0x65, 0x00, 0x64, 0x69, 0x73, 0x6c, 0x69, 0x6b, 0x65, 0x00, 0x64,
+    0x69, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x6e, 0x67, 0x6c, 0x65, 0x00, 0x64,
+    0x69, 0x73, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x00, 0x64, 0x69, 0x73,
+    0x63, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x64, 0x69, 0x73, 0x63, 0x69, 0x70,
+    0x6c, 0x69, 0x6e, 0x65, 0x00, 0x64, 0x69, 0x73, 0x63, 0x61, 0x72, 0x64,
+    0x00, 0x64, 0x69, 0x73, 0x61, 0x72, 0x6d, 0x00, 0x64, 0x69, 0x73, 0x61,
+    0x70, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x64, 0x69, 0x70, 0x00, 0x64,
+    0x69, 0x6e, 0x65, 0x00, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x00, 0x64,
+    0x69, 0x61, 0x67, 0x6e, 0x6f, 0x73, 0x65, 0x00, 0x64, 0x65, 0x74, 0x72,
+    0x61, 0x63, 0x74, 0x00, 0x64, 0x65, 0x74, 0x65, 0x72, 0x69, 0x6f, 0x72,
+    0x61, 0x74, 0x65, 0x00, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6e, 0x00, 0x64,
+    0x65, 0x74, 0x61, 0x63, 0x68, 0x00, 0x64, 0x65, 0x73, 0x70, 0x69, 0x73,
+    0x65, 0x00, 0x64, 0x65, 0x73, 0x70, 0x61, 0x69, 0x72, 0x00, 0x64, 0x65,
+    0x73, 0x69, 0x72, 0x65, 0x00, 0x64, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x61,
+    0x74, 0x65, 0x00, 0x64, 0x65, 0x73, 0x65, 0x72, 0x74, 0x00, 0x64, 0x65,
+    0x70, 0x72, 0x65, 0x73, 0x73, 0x00, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69,
+    0x74, 0x00, 0x64, 0x65, 0x70, 0x6c, 0x6f, 0x79, 0x00, 0x64, 0x65, 0x70,
+    0x69, 0x63, 0x74, 0x00, 0x64, 0x65, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65,
+    0x00, 0x64, 0x65, 0x6e, 0x6f, 0x74, 0x65, 0x00, 0x64, 0x65, 0x6d, 0x6f,
+    0x6c, 0x69, 0x73, 0x68, 0x00, 0x64, 0x65, 0x6c, 0x69, 0x67, 0x68, 0x74,
+    0x00, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x00, 0x64, 0x65, 0x6c, 0x65,
+    0x67, 0x61, 0x74, 0x65, 0x00, 0x64, 0x65, 0x66, 0x79, 0x00, 0x64, 0x65,
+    0x66, 0x75, 0x73, 0x65, 0x00, 0x64, 0x65, 0x66, 0x72, 0x61, 0x75, 0x64,
+    0x00, 0x64, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x00, 0x64, 0x65, 0x66,
+    0x65, 0x72, 0x00, 0x64, 0x65, 0x65, 0x70, 0x65, 0x6e, 0x00, 0x64, 0x65,
+    0x64, 0x75, 0x63, 0x65, 0x00, 0x64, 0x65, 0x63, 0x6f, 0x72, 0x61, 0x74,
+    0x65, 0x00, 0x64, 0x65, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x00, 0x64,
+    0x65, 0x63, 0x61, 0x79, 0x00, 0x64, 0x61, 0x73, 0x68, 0x00, 0x63, 0x75,
+    0x72, 0x74, 0x61, 0x69, 0x6c, 0x00, 0x63, 0x75, 0x72, 0x6c, 0x00, 0x63,
+    0x72, 0x75, 0x73, 0x68, 0x00, 0x63, 0x72, 0x75, 0x6d, 0x62, 0x6c, 0x65,
+    0x00, 0x63, 0x72, 0x61, 0x77, 0x6c, 0x00, 0x63, 0x72, 0x61, 0x73, 0x68,
+    0x00, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x63,
+    0x6f, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x74, 0x65, 0x00, 0x63, 0x6f,
+    0x6e, 0x76, 0x69, 0x63, 0x74, 0x00, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x6e,
+    0x65, 0x00, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x73, 0x74, 0x00, 0x63,
+    0x6f, 0x6e, 0x74, 0x72, 0x61, 0x64, 0x69, 0x63, 0x74, 0x00, 0x63, 0x6f,
+    0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x00, 0x63, 0x6f, 0x6e, 0x6a,
+    0x75, 0x72, 0x65, 0x00, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x64, 0x65, 0x00,
+    0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x70,
+    0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x69,
+    0x6c, 0x65, 0x00, 0x63, 0x6f, 0x6d, 0x70, 0x65, 0x6c, 0x00, 0x63, 0x6f,
+    0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x63, 0x6f, 0x6d,
+    0x6d, 0x65, 0x6e, 0x64, 0x00, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x00,
+    0x63, 0x6f, 0x6c, 0x6c, 0x61, 0x62, 0x6f, 0x72, 0x61, 0x74, 0x65, 0x00,
+    0x63, 0x6c, 0x69, 0x6e, 0x63, 0x68, 0x00, 0x63, 0x69, 0x74, 0x65, 0x00,
+    0x63, 0x69, 0x72, 0x63, 0x75, 0x6d, 0x76, 0x65, 0x6e, 0x74, 0x00, 0x63,
+    0x69, 0x72, 0x63, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x63, 0x68, 0x6f,
+    0x6b, 0x65, 0x00, 0x63, 0x68, 0x65, 0x77, 0x00, 0x63, 0x68, 0x65, 0x61,
+    0x74, 0x00, 0x63, 0x68, 0x61, 0x72, 0x74, 0x00, 0x63, 0x68, 0x61, 0x72,
+    0x61, 0x63, 0x74, 0x65, 0x72, 0x69, 0x7a, 0x65, 0x00, 0x63, 0x68, 0x61,
+    0x72, 0x61, 0x63, 0x74, 0x65, 0x72, 0x69, 0x73, 0x65, 0x00, 0x63, 0x68,
+    0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x00, 0x63, 0x68, 0x61, 0x69, 0x72, 0x00,
+    0x63, 0x61, 0x72, 0x76, 0x65, 0x00, 0x63, 0x61, 0x70, 0x69, 0x74, 0x61,
+    0x6c, 0x69, 0x73, 0x65, 0x00, 0x63, 0x61, 0x6d, 0x70, 0x00, 0x62, 0x79,
+    0x70, 0x61, 0x73, 0x73, 0x00, 0x62, 0x75, 0x6d, 0x70, 0x00, 0x62, 0x75,
+    0x64, 0x67, 0x65, 0x00, 0x62, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x00, 0x62,
+    0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x00, 0x62, 0x72, 0x69,
+    0x67, 0x68, 0x74, 0x65, 0x6e, 0x00, 0x62, 0x72, 0x65, 0x61, 0x63, 0x68,
+    0x00, 0x62, 0x6f, 0x79, 0x63, 0x6f, 0x74, 0x74, 0x00, 0x62, 0x6f, 0x77,
+    0x00, 0x62, 0x6f, 0x77, 0x6c, 0x00, 0x62, 0x6f, 0x75, 0x6e, 0x63, 0x65,
+    0x00, 0x62, 0x6f, 0x6f, 0x74, 0x00, 0x62, 0x6f, 0x6d, 0x62, 0x00, 0x62,
+    0x6f, 0x61, 0x72, 0x64, 0x00, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x00, 0x62,
+    0x6c, 0x65, 0x6e, 0x64, 0x00, 0x62, 0x65, 0x77, 0x61, 0x72, 0x65, 0x00,
+    0x62, 0x61, 0x74, 0x00, 0x62, 0x61, 0x74, 0x74, 0x6c, 0x65, 0x00, 0x62,
+    0x61, 0x72, 0x00, 0x62, 0x61, 0x72, 0x67, 0x61, 0x69, 0x6e, 0x00, 0x62,
+    0x61, 0x6e, 0x69, 0x73, 0x68, 0x00, 0x61, 0x76, 0x65, 0x72, 0x61, 0x67,
+    0x65, 0x00, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x00, 0x61, 0x75, 0x74, 0x68,
+    0x6f, 0x72, 0x69, 0x73, 0x65, 0x00, 0x61, 0x75, 0x67, 0x6d, 0x65, 0x6e,
+    0x74, 0x00, 0x61, 0x73, 0x73, 0x69, 0x6d, 0x69, 0x6c, 0x61, 0x74, 0x65,
+    0x00, 0x61, 0x73, 0x70, 0x69, 0x72, 0x65, 0x00, 0x61, 0x70, 0x70, 0x72,
+    0x6f, 0x70, 0x72, 0x69, 0x61, 0x74, 0x65, 0x00, 0x61, 0x70, 0x70, 0x6c,
+    0x61, 0x75, 0x64, 0x00, 0x61, 0x70, 0x70, 0x65, 0x61, 0x73, 0x65, 0x00,
+    0x61, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x69, 0x7a, 0x65, 0x00, 0x61, 0x6e,
+    0x6e, 0x6f, 0x79, 0x00, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x00, 0x61, 0x6d,
+    0x75, 0x73, 0x65, 0x00, 0x61, 0x6c, 0x6c, 0x61, 0x79, 0x00, 0x61, 0x6c,
+    0x69, 0x65, 0x6e, 0x61, 0x74, 0x65, 0x00, 0x61, 0x66, 0x66, 0x69, 0x72,
+    0x6d, 0x00, 0x61, 0x64, 0x76, 0x6f, 0x63, 0x61, 0x74, 0x65, 0x00, 0x61,
+    0x63, 0x63, 0x72, 0x75, 0x65, 0x00, 0x61, 0x63, 0x63, 0x6f, 0x72, 0x64,
+    0x00, 0x61, 0x62, 0x75, 0x73, 0x65, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2a, 0x00,
+    0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x3e, 0x00,
+    0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x55, 0x00,
+    0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x6c, 0x00,
+    0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x86, 0x00,
+    0x00, 0x00, 0x8c, 0x77, 0x69, 0x6c, 0x6c, 0x00, 0x77, 0x69, 0x6c, 0x6c,
+    0x20, 0x6e, 0x6f, 0x74, 0x00, 0x73, 0x68, 0x61, 0x6c, 0x6c, 0x00, 0x73,
+    0x68, 0x61, 0x6c, 0x6c, 0x20, 0x6e, 0x6f, 0x74, 0x00, 0x6d, 0x61, 0x79,
+    0x00, 0x6d, 0x61, 0x79, 0x20, 0x6e, 0x6f, 0x74, 0x00, 0x6d, 0x69, 0x67,
+    0x68, 0x74, 0x00, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x6e, 0x6f, 0x74,
+    0x00, 0x63, 0x61, 0x6e, 0x00, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x00,
+    0x63, 0x6f, 0x75, 0x6c, 0x64, 0x00, 0x63, 0x6f, 0x75, 0x6c, 0x64, 0x20,
+    0x6e, 0x6f, 0x74, 0x00, 0x6d, 0x75, 0x73, 0x74, 0x00, 0x6d, 0x75, 0x73,
+    0x74, 0x20, 0x6e, 0x6f, 0x74, 0x00, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x20,
+    0x74, 0x6f, 0x00, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x00, 0x73,
+    0x68, 0x6f, 0x75, 0x6c, 0x64, 0x00, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64,
+    0x20, 0x6e, 0x6f, 0x74, 0x00, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x00, 0x77,
+    0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x04, 0x2e, 0x00, 0x3b, 0x00, 0x20, 0x20, 0x61, 0x64, 0x64, 0x20, 0x28,
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
+    0x3b, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00,
+    0x56, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00,
+    0x76, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00,
+    0x9c, 0x00, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00,
+    0xc4, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00,
+    0xef, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x12, 0x00, 0x00, 0x01,
+    0x1f, 0x00, 0x00, 0x01, 0x2e, 0x00, 0x00, 0x01, 0x40, 0x00, 0x00, 0x01,
+    0x51, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x01, 0x71, 0x00, 0x00, 0x01,
+    0x85, 0x00, 0x00, 0x01, 0x98, 0x00, 0x00, 0x01, 0x9f, 0x00, 0x00, 0x01,
+    0xa8, 0x00, 0x00, 0x01, 0xb4, 0x00, 0x00, 0x01, 0xbf, 0x00, 0x00, 0x01,
+    0xc8, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x01, 0xe1, 0x00, 0x00, 0x01,
+    0xee, 0x00, 0x00, 0x01, 0xf7, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02,
+    0x10, 0x00, 0x00, 0x02, 0x1d, 0x00, 0x00, 0x02, 0x28, 0x00, 0x00, 0x02,
+    0x35, 0x00, 0x00, 0x02, 0x45, 0x00, 0x00, 0x02, 0x54, 0x00, 0x00, 0x02,
+    0x5d, 0x00, 0x00, 0x02, 0x68, 0x00, 0x00, 0x02, 0x76, 0x00, 0x00, 0x02,
+    0x83, 0x00, 0x00, 0x02, 0x8e, 0x00, 0x00, 0x02, 0x9b, 0x00, 0x00, 0x02,
+    0xab, 0x00, 0x00, 0x02, 0xba, 0x00, 0x00, 0x02, 0xc5, 0x00, 0x00, 0x02,
+    0xd2, 0x00, 0x00, 0x02, 0xe2, 0x00, 0x00, 0x02, 0xf1, 0x00, 0x00, 0x02,
+    0xfe, 0x00, 0x00, 0x03, 0x0d, 0x00, 0x00, 0x03, 0x1f, 0x00, 0x00, 0x03,
+    0x32, 0x00, 0x00, 0x03, 0x3e, 0x00, 0x00, 0x03, 0x4c, 0x00, 0x00, 0x03,
+    0x5d, 0x00, 0x00, 0x03, 0x6d, 0x00, 0x00, 0x03, 0x7b, 0x00, 0x00, 0x03,
+    0x8b, 0x00, 0x00, 0x03, 0x9e, 0x00, 0x00, 0x03, 0xb0, 0x00, 0x00, 0x03,
+    0xbe, 0x00, 0x00, 0x03, 0xce, 0x00, 0x00, 0x03, 0xe1, 0x00, 0x00, 0x03,
+    0xf3, 0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x04, 0x15, 0x00, 0x00, 0x04,
+    0x2a, 0x00, 0x00, 0x04, 0x3e, 0x00, 0x00, 0x04, 0x49, 0x00, 0x00, 0x04,
+    0x56, 0x00, 0x00, 0x04, 0x66, 0x00, 0x00, 0x04, 0x75, 0x00, 0x00, 0x04,
+    0x82, 0x00, 0x00, 0x04, 0x91, 0x00, 0x00, 0x04, 0xa3, 0x00, 0x00, 0x04,
+    0xb4, 0x00, 0x00, 0x04, 0xc1, 0x00, 0x00, 0x04, 0xd0, 0x00, 0x00, 0x04,
+    0xe2, 0x00, 0x00, 0x04, 0xf3, 0x00, 0x00, 0x05, 0x02, 0x00, 0x00, 0x05,
+    0x13, 0x00, 0x00, 0x05, 0x27, 0x4e, 0x20, 0x56, 0x54, 0x00, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20,
+    0x56, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x54, 0x00,
+    0x4e, 0x20, 0x58, 0x20, 0x56, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x58,
+    0x20, 0x56, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58,
+    0x20, 0x56, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20,
+    0x56, 0x54, 0x00, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x54, 0x00, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x20, 0x44, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x20, 0x44, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e,
+    0x20, 0x56, 0x20, 0x44, 0x54, 0x00, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20,
+    0x44, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44,
+    0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56,
+    0x20, 0x44, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20,
+    0x56, 0x20, 0x44, 0x54, 0x00, 0x4e, 0x20, 0x56, 0x20, 0x50, 0x20, 0x41,
+    0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x50, 0x20,
+    0x41, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20,
+    0x56, 0x20, 0x50, 0x20, 0x41, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a,
+    0x20, 0x4e, 0x20, 0x56, 0x20, 0x50, 0x20, 0x41, 0x20, 0x4e, 0x54, 0x00,
+    0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x50, 0x20, 0x41, 0x20, 0x4e, 0x54,
+    0x00, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x50, 0x20, 0x41,
+    0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58,
+    0x20, 0x56, 0x20, 0x50, 0x20, 0x41, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20,
+    0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x50, 0x20, 0x41, 0x20,
+    0x4e, 0x54, 0x00, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x50, 0x20, 0x41,
+    0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20,
+    0x50, 0x20, 0x41, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x50, 0x20, 0x41, 0x20, 0x4e, 0x54,
+    0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x50,
+    0x20, 0x41, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20,
+    0x44, 0x20, 0x50, 0x20, 0x41, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e,
+    0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x50, 0x20, 0x41, 0x20, 0x4e,
+    0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56,
+    0x20, 0x44, 0x20, 0x50, 0x20, 0x41, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20,
+    0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x50, 0x20,
+    0x41, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x56, 0x20, 0x4e, 0x54, 0x00,
+    0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20,
+    0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a,
+    0x20, 0x4e, 0x20, 0x56, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x58, 0x20,
+    0x56, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56,
+    0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58,
+    0x20, 0x56, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20,
+    0x58, 0x20, 0x56, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x56, 0x20, 0x44,
+    0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20,
+    0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20,
+    0x44, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56,
+    0x20, 0x44, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20,
+    0x44, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56,
+    0x20, 0x44, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e,
+    0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20,
+    0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4e, 0x54,
+    0x00, 0x4e, 0x20, 0x56, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20,
+    0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x44,
+    0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00,
+    0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a,
+    0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00,
+    0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x4a,
+    0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20,
+    0x56, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x56, 0x20, 0x44,
+    0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20,
+    0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x44,
+    0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e,
+    0x54, 0x00, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x20,
+    0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44,
+    0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e,
+    0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00,
+    0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20,
+    0x4a, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x56, 0x20, 0x4a,
+    0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x56,
+    0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20,
+    0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e,
+    0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x4a, 0x2c,
+    0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20,
+    0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20,
+    0x58, 0x20, 0x56, 0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00,
+    0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x4a,
+    0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e,
+    0x20, 0x58, 0x20, 0x56, 0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54,
+    0x00, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20,
+    0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a,
+    0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e,
+    0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20,
+    0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x58, 0x20,
+    0x56, 0x20, 0x44, 0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00,
+    0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x2c,
+    0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e,
+    0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20,
+    0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56,
+    0x20, 0x44, 0x20, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4e,
+    0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a,
+    0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x20,
+    0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44,
+    0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20,
+    0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x58,
+    0x20, 0x56, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c,
+    0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x4a,
+    0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20,
+    0x56, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4e, 0x20, 0x56,
+    0x20, 0x44, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x20,
+    0x4e, 0x20, 0x56, 0x20, 0x44, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54,
+    0x00, 0x4a, 0x2c, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x56, 0x20, 0x44, 0x20,
+    0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e,
+    0x20, 0x56, 0x20, 0x44, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00,
+    0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x44, 0x20, 0x4a, 0x20,
+    0x4e, 0x54, 0x00, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44,
+    0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x4a, 0x2c, 0x20, 0x4a,
+    0x20, 0x4e, 0x20, 0x58, 0x20, 0x56, 0x20, 0x44, 0x20, 0x44, 0x20, 0x4a,
+    0x20, 0x4e, 0x54, 0x00, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x20, 0x58, 0x20,
+    0x56, 0x20, 0x44, 0x20, 0x44, 0x20, 0x4a, 0x20, 0x4e, 0x54, 0x00, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x1c, 0x00,
+    0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x2d, 0x62,
+    0x61, 0x72, 0x00, 0x6f, 0x75, 0x67, 0x68, 0x74, 0x00, 0x61, 0x62, 0x6c,
+    0x65, 0x00, 0x70, 0x72, 0x69, 0x00, 0x65, 0x73, 0x65, 0x00, 0x61, 0x6e,
+    0x74, 0x69, 0x00, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x00, 0x61, 0x74, 0x69,
+    0x6f, 0x6e, 0x00, 0x65, 0x69, 0x6e, 0x67, 0x00, 0x6e, 0x20, 0x73, 0x74,
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xd4, 0x00, 0x00, 0x00,
+    0xc7, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00,
+    0x77, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00,
+    0x6c, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00,
+    0x62, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00,
+    0x57, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00,
+    0x55, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00,
+    0x4e, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00,
+    0x49, 0x00, 0x00, 0x00, 0x49, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00,
+    0x43, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00,
+    0x3e, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+    0x3b, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00,
+    0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00,
+    0x37, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00,
+    0x35, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+    0x34, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x30, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
+    0x2f, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
+    0x2f, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
+    0x2e, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
+    0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00,
+    0x2d, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00,
+    0x2c, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00,
+    0x2c, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00,
+    0x2b, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
+    0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
+    0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00,
+    0x2a, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+    0x29, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x27, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x26, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00,
+    0x4d, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00,
+    0x69, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
+    0x87, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00,
+    0xa4, 0x00, 0x00, 0x00, 0xae, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00,
+    0xc5, 0x00, 0x00, 0x00, 0xcc, 0x00, 0x00, 0x00, 0xd5, 0x00, 0x00, 0x00,
+    0xdd, 0x00, 0x00, 0x00, 0xe8, 0x00, 0x00, 0x00, 0xf4, 0x00, 0x00, 0x00,
+    0xfd, 0x00, 0x00, 0x01, 0x05, 0x00, 0x00, 0x01, 0x0e, 0x00, 0x00, 0x01,
+    0x17, 0x00, 0x00, 0x01, 0x22, 0x00, 0x00, 0x01, 0x2c, 0x00, 0x00, 0x01,
+    0x38, 0x00, 0x00, 0x01, 0x41, 0x00, 0x00, 0x01, 0x4d, 0x00, 0x00, 0x01,
+    0x58, 0x00, 0x00, 0x01, 0x60, 0x00, 0x00, 0x01, 0x6a, 0x00, 0x00, 0x01,
+    0x76, 0x00, 0x00, 0x01, 0x7f, 0x00, 0x00, 0x01, 0x8d, 0x00, 0x00, 0x01,
+    0x96, 0x00, 0x00, 0x01, 0x9f, 0x00, 0x00, 0x01, 0xac, 0x00, 0x00, 0x01,
+    0xb5, 0x00, 0x00, 0x01, 0xbe, 0x00, 0x00, 0x01, 0xc8, 0x00, 0x00, 0x01,
+    0xd0, 0x00, 0x00, 0x01, 0xde, 0x00, 0x00, 0x01, 0xeb, 0x00, 0x00, 0x01,
+    0xf6, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x02, 0x0c, 0x00, 0x00, 0x02,
+    0x18, 0x00, 0x00, 0x02, 0x21, 0x00, 0x00, 0x02, 0x2b, 0x00, 0x00, 0x02,
+    0x36, 0x00, 0x00, 0x02, 0x3e, 0x00, 0x00, 0x02, 0x45, 0x00, 0x00, 0x02,
+    0x4f, 0x00, 0x00, 0x02, 0x57, 0x00, 0x00, 0x02, 0x62, 0x00, 0x00, 0x02,
+    0x70, 0x00, 0x00, 0x02, 0x7d, 0x00, 0x00, 0x02, 0x88, 0x00, 0x00, 0x02,
+    0x92, 0x00, 0x00, 0x02, 0x9a, 0x00, 0x00, 0x02, 0xa2, 0x00, 0x00, 0x02,
+    0xac, 0x00, 0x00, 0x02, 0xb7, 0x00, 0x00, 0x02, 0xc0, 0x00, 0x00, 0x02,
+    0xca, 0x00, 0x00, 0x02, 0xd5, 0x00, 0x00, 0x02, 0xde, 0x00, 0x00, 0x02,
+    0xe6, 0x00, 0x00, 0x02, 0xf0, 0x00, 0x00, 0x02, 0xf7, 0x00, 0x00, 0x03,
+    0x01, 0x00, 0x00, 0x03, 0x0a, 0x00, 0x00, 0x03, 0x12, 0x00, 0x00, 0x03,
+    0x1d, 0x00, 0x00, 0x03, 0x2d, 0x00, 0x00, 0x03, 0x35, 0x00, 0x00, 0x03,
+    0x3d, 0x00, 0x00, 0x03, 0x48, 0x00, 0x00, 0x03, 0x53, 0x00, 0x00, 0x03,
+    0x5f, 0x00, 0x00, 0x03, 0x67, 0x00, 0x00, 0x03, 0x70, 0x00, 0x00, 0x03,
+    0x79, 0x00, 0x00, 0x03, 0x85, 0x00, 0x00, 0x03, 0x8f, 0x00, 0x00, 0x03,
+    0x9b, 0x00, 0x00, 0x03, 0xa4, 0x00, 0x00, 0x03, 0xac, 0x00, 0x00, 0x03,
+    0xb7, 0x00, 0x00, 0x03, 0xc3, 0x00, 0x00, 0x03, 0xcd, 0x00, 0x00, 0x03,
+    0xd4, 0x00, 0x00, 0x03, 0xdd, 0x00, 0x00, 0x03, 0xe7, 0x00, 0x00, 0x03,
+    0xf3, 0x00, 0x00, 0x03, 0xfe, 0x00, 0x00, 0x04, 0x08, 0x00, 0x00, 0x04,
+    0x10, 0x00, 0x00, 0x04, 0x19, 0x00, 0x00, 0x04, 0x23, 0x00, 0x00, 0x04,
+    0x30, 0x00, 0x00, 0x04, 0x37, 0x00, 0x00, 0x04, 0x40, 0x00, 0x00, 0x04,
+    0x4b, 0x00, 0x00, 0x04, 0x54, 0x00, 0x00, 0x04, 0x61, 0x00, 0x00, 0x04,
+    0x68, 0x00, 0x00, 0x04, 0x6d, 0x00, 0x00, 0x04, 0x73, 0x00, 0x00, 0x04,
+    0x7b, 0x00, 0x00, 0x04, 0x83, 0x00, 0x00, 0x04, 0x8c, 0x00, 0x00, 0x04,
+    0x9a, 0x00, 0x00, 0x04, 0xa1, 0x00, 0x00, 0x04, 0xae, 0x00, 0x00, 0x04,
+    0xb8, 0x00, 0x00, 0x04, 0xc5, 0x00, 0x00, 0x04, 0xd0, 0x00, 0x00, 0x04,
+    0xd9, 0x00, 0x00, 0x04, 0xe0, 0x00, 0x00, 0x04, 0xe7, 0x00, 0x00, 0x04,
+    0xf0, 0x00, 0x00, 0x04, 0xf7, 0x00, 0x00, 0x05, 0x04, 0x00, 0x00, 0x05,
+    0x0e, 0x00, 0x00, 0x05, 0x18, 0x00, 0x00, 0x05, 0x21, 0x00, 0x00, 0x05,
+    0x2d, 0x00, 0x00, 0x05, 0x38, 0x00, 0x00, 0x05, 0x43, 0x00, 0x00, 0x05,
+    0x48, 0x00, 0x00, 0x05, 0x51, 0x00, 0x00, 0x05, 0x58, 0x00, 0x00, 0x05,
+    0x60, 0x00, 0x00, 0x05, 0x6b, 0x00, 0x00, 0x05, 0x76, 0x00, 0x00, 0x05,
+    0x7e, 0x00, 0x00, 0x05, 0x8b, 0x00, 0x00, 0x05, 0x94, 0x00, 0x00, 0x05,
+    0x9e, 0x00, 0x00, 0x05, 0xa7, 0x00, 0x00, 0x05, 0xaf, 0x00, 0x00, 0x05,
+    0xb6, 0x00, 0x00, 0x05, 0xc0, 0x00, 0x00, 0x05, 0xca, 0x00, 0x00, 0x05,
+    0xd1, 0x00, 0x00, 0x05, 0xda, 0x00, 0x00, 0x05, 0xe5, 0x00, 0x00, 0x05,
+    0xed, 0x00, 0x00, 0x05, 0xf8, 0x00, 0x00, 0x05, 0xfe, 0x00, 0x00, 0x06,
+    0x07, 0x00, 0x00, 0x06, 0x0e, 0x00, 0x00, 0x06, 0x1e, 0x00, 0x00, 0x06,
+    0x2d, 0x00, 0x00, 0x06, 0x39, 0x00, 0x00, 0x06, 0x40, 0x00, 0x00, 0x06,
+    0x48, 0x00, 0x00, 0x06, 0x50, 0x00, 0x00, 0x06, 0x58, 0x00, 0x00, 0x06,
+    0x5f, 0x00, 0x00, 0x06, 0x68, 0x00, 0x00, 0x06, 0x71, 0x00, 0x00, 0x06,
+    0x79, 0x00, 0x00, 0x06, 0x81, 0x00, 0x00, 0x06, 0x8b, 0x00, 0x00, 0x06,
+    0x93, 0x00, 0x00, 0x06, 0x9e, 0x00, 0x00, 0x06, 0xa6, 0x00, 0x00, 0x06,
+    0xad, 0x00, 0x00, 0x06, 0xb6, 0x00, 0x00, 0x06, 0xbd, 0x00, 0x00, 0x06,
+    0xc6, 0x00, 0x00, 0x06, 0xd0, 0x00, 0x00, 0x06, 0xdf, 0x00, 0x00, 0x06,
+    0xec, 0x00, 0x00, 0x06, 0xf7, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x07,
+    0x0f, 0x00, 0x00, 0x07, 0x1a, 0x00, 0x00, 0x07, 0x24, 0x00, 0x00, 0x07,
+    0x2c, 0x00, 0x00, 0x07, 0x36, 0x00, 0x00, 0x07, 0x3e, 0x00, 0x00, 0x07,
+    0x47, 0x00, 0x00, 0x07, 0x50, 0x00, 0x00, 0x07, 0x57, 0x00, 0x00, 0x07,
+    0x5e, 0x00, 0x00, 0x07, 0x65, 0x00, 0x00, 0x07, 0x75, 0x00, 0x00, 0x07,
+    0x7e, 0x00, 0x00, 0x07, 0x88, 0x00, 0x00, 0x07, 0x90, 0x00, 0x00, 0x07,
+    0x97, 0x00, 0x00, 0x07, 0x9e, 0x00, 0x00, 0x07, 0xa6, 0x00, 0x00, 0x07,
+    0xac, 0x00, 0x00, 0x07, 0xb4, 0x00, 0x00, 0x07, 0xb9, 0x00, 0x00, 0x07,
+    0xc1, 0x00, 0x00, 0x07, 0xcc, 0x00, 0x00, 0x07, 0xd3, 0x00, 0x00, 0x07,
+    0xdc, 0x00, 0x00, 0x07, 0xe7, 0x00, 0x00, 0x07, 0xef, 0x00, 0x00, 0x07,
+    0xfa, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x08, 0x0f, 0x00, 0x00, 0x08,
+    0x1c, 0x00, 0x00, 0x08, 0x26, 0x00, 0x00, 0x08, 0x2d, 0x00, 0x00, 0x08,
+    0x37, 0x00, 0x00, 0x08, 0x3f, 0x00, 0x00, 0x08, 0x47, 0x00, 0x00, 0x08,
+    0x4f, 0x00, 0x00, 0x08, 0x5c, 0x00, 0x00, 0x08, 0x66, 0x00, 0x00, 0x08,
+    0x72, 0x00, 0x00, 0x08, 0x79, 0x00, 0x00, 0x08, 0x82, 0x00, 0x00, 0x08,
+    0x89, 0x00, 0x00, 0x08, 0x8f, 0x00, 0x00, 0x08, 0x94, 0x00, 0x00, 0x08,
+    0x9c, 0x00, 0x00, 0x08, 0xa4, 0x00, 0x00, 0x08, 0xae, 0x00, 0x00, 0x08,
+    0xb5, 0x00, 0x00, 0x08, 0xc2, 0x00, 0x00, 0x08, 0xc9, 0x00, 0x00, 0x08,
+    0xd6, 0x00, 0x00, 0x08, 0xdf, 0x00, 0x00, 0x08, 0xe8, 0x00, 0x00, 0x08,
+    0xf1, 0x00, 0x00, 0x08, 0xfd, 0x00, 0x00, 0x09, 0x07, 0x00, 0x00, 0x09,
+    0x12, 0x00, 0x00, 0x09, 0x1b, 0x00, 0x00, 0x09, 0x22, 0x00, 0x00, 0x09,
+    0x2b, 0x00, 0x00, 0x09, 0x32, 0x00, 0x00, 0x09, 0x3b, 0x00, 0x00, 0x09,
+    0x48, 0x00, 0x00, 0x09, 0x4f, 0x00, 0x00, 0x09, 0x56, 0x00, 0x00, 0x09,
+    0x60, 0x00, 0x00, 0x09, 0x6b, 0x00, 0x00, 0x09, 0x71, 0x00, 0x00, 0x09,
+    0x7c, 0x00, 0x00, 0x09, 0x84, 0x00, 0x00, 0x09, 0x8e, 0x00, 0x00, 0x09,
+    0x95, 0x00, 0x00, 0x09, 0xa0, 0x00, 0x00, 0x09, 0xa8, 0x00, 0x00, 0x09,
+    0xaf, 0x00, 0x00, 0x09, 0xb7, 0x00, 0x00, 0x09, 0xc4, 0x00, 0x00, 0x09,
+    0xd2, 0x00, 0x00, 0x09, 0xdb, 0x00, 0x00, 0x09, 0xe6, 0x00, 0x00, 0x09,
+    0xef, 0x00, 0x00, 0x09, 0xfa, 0x00, 0x00, 0x0a, 0x03, 0x00, 0x00, 0x0a,
+    0x0c, 0x00, 0x00, 0x0a, 0x14, 0x00, 0x00, 0x0a, 0x1b, 0x00, 0x00, 0x0a,
+    0x28, 0x00, 0x00, 0x0a, 0x31, 0x00, 0x00, 0x0a, 0x3d, 0x00, 0x00, 0x0a,
+    0x49, 0x00, 0x00, 0x0a, 0x55, 0x00, 0x00, 0x0a, 0x5d, 0x00, 0x00, 0x0a,
+    0x67, 0x00, 0x00, 0x0a, 0x6e, 0x00, 0x00, 0x0a, 0x74, 0x00, 0x00, 0x0a,
+    0x79, 0x00, 0x00, 0x0a, 0x84, 0x00, 0x00, 0x0a, 0x8e, 0x00, 0x00, 0x0a,
+    0x97, 0x00, 0x00, 0x0a, 0x9d, 0x00, 0x00, 0x0a, 0xa8, 0x00, 0x00, 0x0a,
+    0xb4, 0x00, 0x00, 0x0a, 0xbd, 0x00, 0x00, 0x0a, 0xc9, 0x00, 0x00, 0x0a,
+    0xd1, 0x00, 0x00, 0x0a, 0xda, 0x00, 0x00, 0x0a, 0xe1, 0x00, 0x00, 0x0a,
+    0xe8, 0x00, 0x00, 0x0a, 0xf1, 0x00, 0x00, 0x0a, 0xfb, 0x00, 0x00, 0x0b,
+    0x04, 0x00, 0x00, 0x0b, 0x0b, 0x00, 0x00, 0x0b, 0x15, 0x00, 0x00, 0x0b,
+    0x1c, 0x00, 0x00, 0x0b, 0x26, 0x00, 0x00, 0x0b, 0x2d, 0x00, 0x00, 0x0b,
+    0x34, 0x00, 0x00, 0x0b, 0x3e, 0x00, 0x00, 0x0b, 0x49, 0x00, 0x00, 0x0b,
+    0x50, 0x00, 0x00, 0x0b, 0x57, 0x00, 0x00, 0x0b, 0x5e, 0x00, 0x00, 0x0b,
+    0x6c, 0x00, 0x00, 0x0b, 0x73, 0x00, 0x00, 0x0b, 0x7d, 0x00, 0x00, 0x0b,
+    0x88, 0x00, 0x00, 0x0b, 0x92, 0x00, 0x00, 0x0b, 0x9c, 0x00, 0x00, 0x0b,
+    0xa8, 0x00, 0x00, 0x0b, 0xaf, 0x00, 0x00, 0x0b, 0xb6, 0x00, 0x00, 0x0b,
+    0xbf, 0x00, 0x00, 0x0b, 0xc8, 0x00, 0x00, 0x0b, 0xd2, 0x00, 0x00, 0x0b,
+    0xe1, 0x00, 0x00, 0x0b, 0xe8, 0x00, 0x00, 0x0b, 0xf5, 0x00, 0x00, 0x0b,
+    0xfb, 0x00, 0x00, 0x0c, 0x02, 0x00, 0x00, 0x0c, 0x0b, 0x00, 0x00, 0x0c,
+    0x12, 0x00, 0x00, 0x0c, 0x19, 0x00, 0x00, 0x0c, 0x23, 0x00, 0x00, 0x0c,
+    0x2d, 0x00, 0x00, 0x0c, 0x33, 0x00, 0x00, 0x0c, 0x3d, 0x00, 0x00, 0x0c,
+    0x46, 0x00, 0x00, 0x0c, 0x50, 0x00, 0x00, 0x0c, 0x5e, 0x00, 0x00, 0x0c,
+    0x67, 0x00, 0x00, 0x0c, 0x6f, 0x00, 0x00, 0x0c, 0x76, 0x00, 0x00, 0x0c,
+    0x7c, 0x00, 0x00, 0x0c, 0x82, 0x00, 0x00, 0x0c, 0x90, 0x00, 0x00, 0x0c,
+    0x97, 0x00, 0x00, 0x0c, 0x9f, 0x00, 0x00, 0x0c, 0xa9, 0x00, 0x00, 0x0c,
+    0xb3, 0x00, 0x00, 0x0c, 0xba, 0x00, 0x00, 0x0c, 0xc0, 0x00, 0x00, 0x0c,
+    0xc9, 0x00, 0x00, 0x0c, 0xd5, 0x00, 0x00, 0x0c, 0xdd, 0x00, 0x00, 0x0c,
+    0xe5, 0x00, 0x00, 0x0c, 0xf1, 0x00, 0x00, 0x0c, 0xfc, 0x00, 0x00, 0x0d,
+    0x01, 0x00, 0x00, 0x0d, 0x0a, 0x00, 0x00, 0x0d, 0x14, 0x00, 0x00, 0x0d,
+    0x1c, 0x00, 0x00, 0x0d, 0x25, 0x00, 0x00, 0x0d, 0x2b, 0x00, 0x00, 0x0d,
+    0x33, 0x00, 0x00, 0x0d, 0x3a, 0x00, 0x00, 0x0d, 0x43, 0x00, 0x00, 0x0d,
+    0x4e, 0x00, 0x00, 0x0d, 0x5b, 0x00, 0x00, 0x0d, 0x62, 0x00, 0x00, 0x0d,
+    0x6c, 0x00, 0x00, 0x0d, 0x74, 0x00, 0x00, 0x0d, 0x7f, 0x00, 0x00, 0x0d,
+    0x8a, 0x00, 0x00, 0x0d, 0x97, 0x00, 0x00, 0x0d, 0x9d, 0x00, 0x00, 0x0d,
+    0xa6, 0x00, 0x00, 0x0d, 0xab, 0x00, 0x00, 0x0d, 0xb4, 0x00, 0x00, 0x0d,
+    0xbd, 0x00, 0x00, 0x0d, 0xc8, 0x00, 0x00, 0x0d, 0xd1, 0x00, 0x00, 0x0d,
+    0xd6, 0x00, 0x00, 0x0d, 0xde, 0x00, 0x00, 0x0d, 0xe4, 0x00, 0x00, 0x0d,
+    0xee, 0x00, 0x00, 0x0d, 0xf8, 0x00, 0x00, 0x0e, 0x01, 0x00, 0x00, 0x0e,
+    0x07, 0x00, 0x00, 0x0e, 0x0d, 0x00, 0x00, 0x0e, 0x19, 0x00, 0x00, 0x0e,
+    0x22, 0x00, 0x00, 0x0e, 0x2a, 0x00, 0x00, 0x0e, 0x33, 0x00, 0x00, 0x0e,
+    0x3d, 0x00, 0x00, 0x0e, 0x47, 0x00, 0x00, 0x0e, 0x4e, 0x00, 0x00, 0x0e,
+    0x58, 0x00, 0x00, 0x0e, 0x62, 0x00, 0x00, 0x0e, 0x69, 0x00, 0x00, 0x0e,
+    0x72, 0x00, 0x00, 0x0e, 0x81, 0x00, 0x00, 0x0e, 0x8a, 0x00, 0x00, 0x0e,
+    0x91, 0x00, 0x00, 0x0e, 0x9d, 0x00, 0x00, 0x0e, 0xa9, 0x00, 0x00, 0x0e,
+    0xb1, 0x00, 0x00, 0x0e, 0xb7, 0x00, 0x00, 0x0e, 0xbe, 0x00, 0x00, 0x0e,
+    0xc5, 0x00, 0x00, 0x0e, 0xcd, 0x00, 0x00, 0x0e, 0xd2, 0x00, 0x00, 0x0e,
+    0xd7, 0x00, 0x00, 0x0e, 0xde, 0x00, 0x00, 0x0e, 0xeb, 0x00, 0x00, 0x0e,
+    0xf7, 0x00, 0x00, 0x0f, 0x04, 0x00, 0x00, 0x0f, 0x0a, 0x00, 0x00, 0x0f,
+    0x11, 0x00, 0x00, 0x0f, 0x1a, 0x00, 0x00, 0x0f, 0x26, 0x00, 0x00, 0x0f,
+    0x2e, 0x00, 0x00, 0x0f, 0x35, 0x00, 0x00, 0x0f, 0x3c, 0x00, 0x00, 0x0f,
+    0x43, 0x00, 0x00, 0x0f, 0x4b, 0x00, 0x00, 0x0f, 0x54, 0x00, 0x00, 0x0f,
+    0x5d, 0x00, 0x00, 0x0f, 0x68, 0x00, 0x00, 0x0f, 0x6d, 0x00, 0x00, 0x0f,
+    0x74, 0x00, 0x00, 0x0f, 0x81, 0x00, 0x00, 0x0f, 0x89, 0x00, 0x00, 0x0f,
+    0x91, 0x00, 0x00, 0x0f, 0x9c, 0x00, 0x00, 0x0f, 0xa5, 0x00, 0x00, 0x0f,
+    0xac, 0x00, 0x00, 0x0f, 0xb5, 0x00, 0x00, 0x0f, 0xbf, 0x00, 0x00, 0x0f,
+    0xc6, 0x00, 0x00, 0x0f, 0xcd, 0x00, 0x00, 0x0f, 0xdc, 0x00, 0x00, 0x0f,
+    0xe7, 0x00, 0x00, 0x0f, 0xee, 0x00, 0x00, 0x0f, 0xf6, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x10, 0x09, 0x00, 0x00, 0x10, 0x12, 0x00, 0x00, 0x10,
+    0x1c, 0x00, 0x00, 0x10, 0x26, 0x00, 0x00, 0x10, 0x2e, 0x00, 0x00, 0x10,
+    0x35, 0x00, 0x00, 0x10, 0x3d, 0x00, 0x00, 0x10, 0x4a, 0x00, 0x00, 0x10,
+    0x52, 0x00, 0x00, 0x10, 0x5d, 0x00, 0x00, 0x10, 0x64, 0x00, 0x00, 0x10,
+    0x6c, 0x00, 0x00, 0x10, 0x72, 0x00, 0x00, 0x10, 0x79, 0x00, 0x00, 0x10,
+    0x80, 0x00, 0x00, 0x10, 0x86, 0x00, 0x00, 0x10, 0x8d, 0x00, 0x00, 0x10,
+    0x96, 0x00, 0x00, 0x10, 0xab, 0x00, 0x00, 0x10, 0xb9, 0x00, 0x00, 0x10,
+    0xc3, 0x00, 0x00, 0x10, 0xcb, 0x00, 0x00, 0x10, 0xd7, 0x00, 0x00, 0x10,
+    0xde, 0x00, 0x00, 0x10, 0xe5, 0x00, 0x00, 0x10, 0xf0, 0x00, 0x00, 0x10,
+    0xf5, 0x00, 0x00, 0x10, 0xfe, 0x00, 0x00, 0x11, 0x09, 0x00, 0x00, 0x11,
+    0x0f, 0x00, 0x00, 0x11, 0x17, 0x00, 0x00, 0x11, 0x20, 0x00, 0x00, 0x11,
+    0x27, 0x00, 0x00, 0x11, 0x32, 0x00, 0x00, 0x11, 0x3b, 0x00, 0x00, 0x11,
+    0x47, 0x00, 0x00, 0x11, 0x50, 0x00, 0x00, 0x11, 0x5a, 0x00, 0x00, 0x11,
+    0x62, 0x00, 0x00, 0x11, 0x6b, 0x00, 0x00, 0x11, 0x75, 0x00, 0x00, 0x11,
+    0x7f, 0x00, 0x00, 0x11, 0x88, 0x00, 0x00, 0x11, 0x92, 0x00, 0x00, 0x11,
+    0x9d, 0x00, 0x00, 0x11, 0xa5, 0x00, 0x00, 0x11, 0xae, 0x00, 0x00, 0x11,
+    0xb7, 0x00, 0x00, 0x11, 0xc0, 0x00, 0x00, 0x11, 0xca, 0x00, 0x00, 0x11,
+    0xd0, 0x00, 0x00, 0x11, 0xdb, 0x00, 0x00, 0x11, 0xe5, 0x00, 0x00, 0x11,
+    0xea, 0x00, 0x00, 0x11, 0xf5, 0x00, 0x00, 0x11, 0xfe, 0x00, 0x00, 0x12,
+    0x03, 0x00, 0x00, 0x12, 0x0d, 0x00, 0x00, 0x12, 0x17, 0x00, 0x00, 0x12,
+    0x1d, 0x00, 0x00, 0x12, 0x2b, 0x00, 0x00, 0x12, 0x35, 0x00, 0x00, 0x12,
+    0x3e, 0x00, 0x00, 0x12, 0x47, 0x00, 0x00, 0x12, 0x52, 0x00, 0x00, 0x12,
+    0x57, 0x00, 0x00, 0x12, 0x60, 0x00, 0x00, 0x12, 0x67, 0x00, 0x00, 0x12,
+    0x71, 0x00, 0x00, 0x12, 0x7a, 0x00, 0x00, 0x12, 0x84, 0x00, 0x00, 0x12,
+    0x99, 0x00, 0x00, 0x12, 0xa1, 0x00, 0x00, 0x12, 0xa9, 0x00, 0x00, 0x12,
+    0xb1, 0x00, 0x00, 0x12, 0xbc, 0x00, 0x00, 0x12, 0xc3, 0x00, 0x00, 0x12,
+    0xca, 0x00, 0x00, 0x12, 0xd4, 0x00, 0x00, 0x12, 0xdc, 0x00, 0x00, 0x12,
+    0xe3, 0x00, 0x00, 0x12, 0xea, 0x00, 0x00, 0x12, 0xf1, 0x00, 0x00, 0x12,
+    0xf8, 0x00, 0x00, 0x13, 0x02, 0x00, 0x00, 0x13, 0x08, 0x00, 0x00, 0x13,
+    0x0f, 0x00, 0x00, 0x13, 0x15, 0x00, 0x00, 0x13, 0x1f, 0x00, 0x00, 0x13,
+    0x29, 0x00, 0x00, 0x13, 0x34, 0x00, 0x00, 0x13, 0x3e, 0x00, 0x00, 0x13,
+    0x4a, 0x00, 0x00, 0x13, 0x51, 0x00, 0x00, 0x13, 0x56, 0x00, 0x00, 0x13,
+    0x5f, 0x00, 0x00, 0x13, 0x6d, 0x00, 0x00, 0x13, 0x77, 0x00, 0x00, 0x13,
+    0x7f, 0x00, 0x00, 0x13, 0x89, 0x00, 0x00, 0x13, 0x94, 0x00, 0x00, 0x13,
+    0x9f, 0x00, 0x00, 0x13, 0xaa, 0x00, 0x00, 0x13, 0xb2, 0x00, 0x00, 0x13,
+    0xbb, 0x00, 0x00, 0x13, 0xc2, 0x00, 0x00, 0x13, 0xcc, 0x00, 0x00, 0x13,
+    0xd6, 0x00, 0x00, 0x13, 0xdf, 0x00, 0x00, 0x13, 0xe4, 0x00, 0x00, 0x13,
+    0xed, 0x00, 0x00, 0x13, 0xf5, 0x00, 0x00, 0x13, 0xfd, 0x00, 0x00, 0x14,
+    0x05, 0x00, 0x00, 0x14, 0x0d, 0x00, 0x00, 0x14, 0x15, 0x00, 0x00, 0x14,
+    0x1a, 0x00, 0x00, 0x14, 0x20, 0x00, 0x00, 0x14, 0x27, 0x00, 0x00, 0x14,
+    0x2e, 0x00, 0x00, 0x14, 0x35, 0x00, 0x00, 0x14, 0x3d, 0x00, 0x00, 0x14,
+    0x43, 0x00, 0x00, 0x14, 0x50, 0x00, 0x00, 0x14, 0x5c, 0x00, 0x00, 0x14,
+    0x68, 0x00, 0x00, 0x14, 0x70, 0x00, 0x00, 0x14, 0x78, 0x00, 0x00, 0x14,
+    0x7f, 0x00, 0x00, 0x14, 0x88, 0x00, 0x00, 0x14, 0x8f, 0x00, 0x00, 0x14,
+    0x96, 0x00, 0x00, 0x14, 0x9b, 0x00, 0x00, 0x14, 0xa5, 0x00, 0x00, 0x14,
+    0xab, 0x00, 0x00, 0x14, 0xb6, 0x00, 0x00, 0x14, 0xc1, 0x00, 0x00, 0x14,
+    0xcd, 0x00, 0x00, 0x14, 0xd4, 0x00, 0x00, 0x14, 0xda, 0x00, 0x00, 0x14,
+    0xe7, 0x00, 0x00, 0x14, 0xf2, 0x00, 0x00, 0x14, 0xf7, 0x00, 0x00, 0x14,
+    0xff, 0x00, 0x00, 0x15, 0x08, 0x00, 0x00, 0x15, 0x11, 0x00, 0x00, 0x15,
+    0x17, 0x00, 0x00, 0x15, 0x1e, 0x00, 0x00, 0x15, 0x29, 0x00, 0x00, 0x15,
+    0x39, 0x00, 0x00, 0x15, 0x42, 0x00, 0x00, 0x15, 0x47, 0x00, 0x00, 0x15,
+    0x4e, 0x00, 0x00, 0x15, 0x54, 0x00, 0x00, 0x15, 0x5e, 0x00, 0x00, 0x15,
+    0x69, 0x00, 0x00, 0x15, 0x70, 0x00, 0x00, 0x15, 0x79, 0x00, 0x00, 0x15,
+    0x83, 0x00, 0x00, 0x15, 0x91, 0x00, 0x00, 0x15, 0x97, 0x00, 0x00, 0x15,
+    0x9e, 0x00, 0x00, 0x15, 0xa9, 0x00, 0x00, 0x15, 0xb3, 0x00, 0x00, 0x15,
+    0xba, 0x00, 0x00, 0x15, 0xc2, 0x00, 0x00, 0x15, 0xc8, 0x00, 0x00, 0x15,
+    0xd2, 0x00, 0x00, 0x15, 0xda, 0x00, 0x00, 0x15, 0xe6, 0x00, 0x00, 0x15,
+    0xf3, 0x00, 0x00, 0x15, 0xfa, 0x00, 0x00, 0x16, 0x05, 0x00, 0x00, 0x16,
+    0x0e, 0x00, 0x00, 0x16, 0x17, 0x00, 0x00, 0x16, 0x1f, 0x00, 0x00, 0x16,
+    0x28, 0x00, 0x00, 0x16, 0x31, 0x00, 0x00, 0x16, 0x38, 0x00, 0x00, 0x16,
+    0x3f, 0x00, 0x00, 0x16, 0x47, 0x00, 0x00, 0x16, 0x4e, 0x00, 0x00, 0x16,
+    0x59, 0x00, 0x00, 0x16, 0x60, 0x00, 0x00, 0x16, 0x68, 0x00, 0x00, 0x16,
+    0x75, 0x00, 0x00, 0x16, 0x84, 0x00, 0x00, 0x16, 0x91, 0x00, 0x00, 0x16,
+    0x9a, 0x00, 0x00, 0x16, 0xa2, 0x00, 0x00, 0x16, 0xaa, 0x00, 0x00, 0x16,
+    0xb1, 0x00, 0x00, 0x16, 0xbd, 0x00, 0x00, 0x16, 0xc7, 0x00, 0x00, 0x16,
+    0xce, 0x00, 0x00, 0x16, 0xd6, 0x00, 0x00, 0x16, 0xdf, 0x00, 0x00, 0x16,
+    0xe6, 0x00, 0x00, 0x16, 0xee, 0x00, 0x00, 0x16, 0xf4, 0x00, 0x00, 0x17,
+    0x03, 0x00, 0x00, 0x17, 0x0c, 0x00, 0x00, 0x17, 0x1b, 0x00, 0x00, 0x17,
+    0x28, 0x00, 0x00, 0x17, 0x35, 0x00, 0x00, 0x17, 0x3d, 0x00, 0x00, 0x17,
+    0x49, 0x00, 0x00, 0x17, 0x50, 0x00, 0x00, 0x17, 0x56, 0x00, 0x00, 0x17,
+    0x63, 0x00, 0x00, 0x17, 0x6e, 0x00, 0x00, 0x17, 0x76, 0x00, 0x00, 0x17,
+    0x7f, 0x00, 0x00, 0x17, 0x85, 0x00, 0x00, 0x17, 0x8d, 0x00, 0x00, 0x17,
+    0x9b, 0x00, 0x00, 0x17, 0xa6, 0x00, 0x00, 0x17, 0xaf, 0x00, 0x00, 0x17,
+    0xb6, 0x00, 0x00, 0x17, 0xbe, 0x00, 0x00, 0x17, 0xc7, 0x00, 0x00, 0x17,
+    0xcd, 0x00, 0x00, 0x17, 0xd8, 0x00, 0x00, 0x17, 0xe3, 0x00, 0x00, 0x17,
+    0xe8, 0x00, 0x00, 0x17, 0xf4, 0x00, 0x00, 0x17, 0xfb, 0x00, 0x00, 0x18,
+    0x01, 0x00, 0x00, 0x18, 0x0d, 0x00, 0x00, 0x18, 0x14, 0x00, 0x00, 0x18,
+    0x1f, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x18, 0x32, 0x00, 0x00, 0x18,
+    0x39, 0x00, 0x00, 0x18, 0x40, 0x00, 0x00, 0x18, 0x46, 0x00, 0x00, 0x18,
+    0x51, 0x00, 0x00, 0x18, 0x56, 0x00, 0x00, 0x18, 0x5e, 0x00, 0x00, 0x18,
+    0x67, 0x00, 0x00, 0x18, 0x71, 0x00, 0x00, 0x18, 0x77, 0x00, 0x00, 0x18,
+    0x7e, 0x00, 0x00, 0x18, 0x87, 0x00, 0x00, 0x18, 0x8e, 0x00, 0x00, 0x18,
+    0x95, 0x00, 0x00, 0x18, 0x9d, 0x00, 0x00, 0x18, 0xa8, 0x00, 0x00, 0x18,
+    0xb1, 0x00, 0x00, 0x18, 0xc1, 0x00, 0x00, 0x18, 0xcb, 0x00, 0x00, 0x18,
+    0xd5, 0x00, 0x00, 0x18, 0xdc, 0x00, 0x00, 0x18, 0xe8, 0x00, 0x00, 0x18,
+    0xf3, 0x00, 0x00, 0x18, 0xfb, 0x00, 0x00, 0x19, 0x04, 0x00, 0x00, 0x19,
+    0x0a, 0x00, 0x00, 0x19, 0x18, 0x00, 0x00, 0x19, 0x24, 0x00, 0x00, 0x19,
+    0x2b, 0x00, 0x00, 0x19, 0x38, 0x00, 0x00, 0x19, 0x45, 0x00, 0x00, 0x19,
+    0x4b, 0x00, 0x00, 0x19, 0x54, 0x00, 0x00, 0x19, 0x5f, 0x00, 0x00, 0x19,
+    0x6a, 0x00, 0x00, 0x19, 0x72, 0x00, 0x00, 0x19, 0x78, 0x00, 0x00, 0x19,
+    0x7f, 0x00, 0x00, 0x19, 0x87, 0x00, 0x00, 0x19, 0x95, 0x00, 0x00, 0x19,
+    0x9c, 0x00, 0x00, 0x19, 0xa7, 0x00, 0x00, 0x19, 0xaf, 0x00, 0x00, 0x19,
+    0xb7, 0x00, 0x00, 0x19, 0xbe, 0x00, 0x00, 0x19, 0xc5, 0x00, 0x00, 0x19,
+    0xd0, 0x00, 0x00, 0x19, 0xd6, 0x00, 0x00, 0x19, 0xdd, 0x00, 0x00, 0x19,
+    0xe9, 0x00, 0x00, 0x19, 0xf4, 0x00, 0x00, 0x19, 0xfe, 0x00, 0x00, 0x1a,
+    0x09, 0x00, 0x00, 0x1a, 0x12, 0x00, 0x00, 0x1a, 0x1b, 0x00, 0x00, 0x1a,
+    0x27, 0x00, 0x00, 0x1a, 0x2d, 0x00, 0x00, 0x1a, 0x35, 0x00, 0x00, 0x1a,
+    0x3e, 0x00, 0x00, 0x1a, 0x44, 0x00, 0x00, 0x1a, 0x4c, 0x00, 0x00, 0x1a,
+    0x53, 0x00, 0x00, 0x1a, 0x5a, 0x00, 0x00, 0x1a, 0x69, 0x00, 0x00, 0x1a,
+    0x76, 0x00, 0x00, 0x1a, 0x7d, 0x00, 0x00, 0x1a, 0x84, 0x00, 0x00, 0x1a,
+    0x8e, 0x00, 0x00, 0x1a, 0x96, 0x00, 0x00, 0x1a, 0x9c, 0x00, 0x00, 0x1a,
+    0xa5, 0x00, 0x00, 0x1a, 0xab, 0x00, 0x00, 0x1a, 0xb0, 0x00, 0x00, 0x1a,
+    0xb4, 0x00, 0x00, 0x1a, 0xba, 0x00, 0x00, 0x1a, 0xc2, 0x00, 0x00, 0x1a,
+    0xce, 0x00, 0x00, 0x1a, 0xd7, 0x00, 0x00, 0x1a, 0xde, 0x00, 0x00, 0x1a,
+    0xe9, 0x00, 0x00, 0x1a, 0xf2, 0x00, 0x00, 0x1a, 0xfc, 0x00, 0x00, 0x1b,
+    0x03, 0x00, 0x00, 0x1b, 0x09, 0x00, 0x00, 0x1b, 0x10, 0x00, 0x00, 0x1b,
+    0x1a, 0x00, 0x00, 0x1b, 0x20, 0x00, 0x00, 0x1b, 0x27, 0x00, 0x00, 0x1b,
+    0x31, 0x00, 0x00, 0x1b, 0x3b, 0x00, 0x00, 0x1b, 0x45, 0x00, 0x00, 0x1b,
+    0x4b, 0x00, 0x00, 0x1b, 0x51, 0x00, 0x00, 0x1b, 0x59, 0x00, 0x00, 0x1b,
+    0x61, 0x00, 0x00, 0x1b, 0x72, 0x00, 0x00, 0x1b, 0x79, 0x00, 0x00, 0x1b,
+    0x83, 0x00, 0x00, 0x1b, 0x92, 0x00, 0x00, 0x1b, 0x9b, 0x00, 0x00, 0x1b,
+    0xa5, 0x00, 0x00, 0x1b, 0xad, 0x00, 0x00, 0x1b, 0xb7, 0x00, 0x00, 0x1b,
+    0xc2, 0x00, 0x00, 0x1b, 0xcc, 0x00, 0x00, 0x1b, 0xd7, 0x00, 0x00, 0x1b,
+    0xde, 0x00, 0x00, 0x1b, 0xe6, 0x00, 0x00, 0x1b, 0xef, 0x00, 0x00, 0x1b,
+    0xf8, 0x00, 0x00, 0x1b, 0xff, 0x00, 0x00, 0x1c, 0x07, 0x00, 0x00, 0x1c,
+    0x10, 0x00, 0x00, 0x1c, 0x18, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x1c,
+    0x31, 0x00, 0x00, 0x1c, 0x39, 0x00, 0x00, 0x1c, 0x3e, 0x00, 0x00, 0x1c,
+    0x51, 0x00, 0x00, 0x1c, 0x5d, 0x00, 0x00, 0x1c, 0x66, 0x00, 0x00, 0x1c,
+    0x6e, 0x00, 0x00, 0x1c, 0x7b, 0x00, 0x00, 0x1c, 0x8a, 0x00, 0x00, 0x1c,
+    0x94, 0x00, 0x00, 0x1c, 0x9c, 0x00, 0x00, 0x1c, 0xa8, 0x00, 0x00, 0x1c,
+    0xb5, 0x00, 0x00, 0x1c, 0xba, 0x00, 0x00, 0x1c, 0xbf, 0x00, 0x00, 0x1c,
+    0xc3, 0x00, 0x00, 0x1c, 0xcb, 0x00, 0x00, 0x1c, 0xd4, 0x00, 0x00, 0x1c,
+    0xdb, 0x00, 0x00, 0x1c, 0xe7, 0x00, 0x00, 0x1c, 0xf1, 0x00, 0x00, 0x1c,
+    0xfc, 0x00, 0x00, 0x1d, 0x04, 0x00, 0x00, 0x1d, 0x0e, 0x00, 0x00, 0x1d,
+    0x1a, 0x00, 0x00, 0x1d, 0x21, 0x00, 0x00, 0x1d, 0x29, 0x00, 0x00, 0x1d,
+    0x30, 0x00, 0x00, 0x1d, 0x36, 0x00, 0x00, 0x1d, 0x41, 0x00, 0x00, 0x1d,
+    0x4b, 0x00, 0x00, 0x1d, 0x54, 0x00, 0x00, 0x1d, 0x59, 0x00, 0x00, 0x1d,
+    0x5f, 0x00, 0x00, 0x1d, 0x6c, 0x00, 0x00, 0x1d, 0x77, 0x00, 0x00, 0x1d,
+    0x7e, 0x00, 0x00, 0x1d, 0x89, 0x00, 0x00, 0x1d, 0x92, 0x00, 0x00, 0x1d,
+    0x9c, 0x00, 0x00, 0x1d, 0xa2, 0x00, 0x00, 0x1d, 0xac, 0x00, 0x00, 0x1d,
+    0xb5, 0x00, 0x00, 0x1d, 0xc3, 0x00, 0x00, 0x1d, 0xcc, 0x00, 0x00, 0x1d,
+    0xd2, 0x00, 0x00, 0x1d, 0xd9, 0x00, 0x00, 0x1d, 0xe1, 0x00, 0x00, 0x1d,
+    0xf0, 0x00, 0x00, 0x1d, 0xfa, 0x00, 0x00, 0x1e, 0x01, 0x00, 0x00, 0x1e,
+    0x0b, 0x00, 0x00, 0x1e, 0x19, 0x00, 0x00, 0x1e, 0x20, 0x00, 0x00, 0x1e,
+    0x27, 0x00, 0x00, 0x1e, 0x31, 0x00, 0x00, 0x1e, 0x39, 0x00, 0x00, 0x1e,
+    0x43, 0x00, 0x00, 0x1e, 0x4d, 0x00, 0x00, 0x1e, 0x55, 0x00, 0x00, 0x1e,
+    0x5e, 0x00, 0x00, 0x1e, 0x66, 0x00, 0x00, 0x1e, 0x6a, 0x00, 0x00, 0x1e,
+    0x76, 0x00, 0x00, 0x1e, 0x80, 0x00, 0x00, 0x1e, 0x87, 0x00, 0x00, 0x1e,
+    0x91, 0x00, 0x00, 0x1e, 0x96, 0x00, 0x00, 0x1e, 0xa1, 0x00, 0x00, 0x1e,
+    0xac, 0x00, 0x00, 0x1e, 0xb3, 0x00, 0x00, 0x1e, 0xbe, 0x00, 0x00, 0x1e,
+    0xc8, 0x00, 0x00, 0x1e, 0xce, 0x00, 0x00, 0x1e, 0xd9, 0x00, 0x00, 0x1e,
+    0xe3, 0x00, 0x00, 0x1e, 0xeb, 0x00, 0x00, 0x1e, 0xf4, 0x00, 0x00, 0x1e,
+    0xfb, 0x00, 0x00, 0x1f, 0x02, 0x00, 0x00, 0x1f, 0x0b, 0x00, 0x00, 0x1f,
+    0x13, 0x00, 0x00, 0x1f, 0x1b, 0x00, 0x00, 0x1f, 0x25, 0x00, 0x00, 0x1f,
+    0x2a, 0x00, 0x00, 0x1f, 0x33, 0x00, 0x00, 0x1f, 0x3e, 0x00, 0x00, 0x1f,
+    0x4c, 0x00, 0x00, 0x1f, 0x59, 0x00, 0x00, 0x1f, 0x60, 0x00, 0x00, 0x1f,
+    0x67, 0x00, 0x00, 0x1f, 0x6f, 0x00, 0x00, 0x1f, 0x76, 0x00, 0x00, 0x1f,
+    0x7e, 0x00, 0x00, 0x1f, 0x84, 0x00, 0x00, 0x1f, 0x8b, 0x00, 0x00, 0x1f,
+    0x99, 0x00, 0x00, 0x1f, 0xa4, 0x00, 0x00, 0x1f, 0xaa, 0x00, 0x00, 0x1f,
+    0xb1, 0x00, 0x00, 0x1f, 0xba, 0x00, 0x00, 0x1f, 0xbf, 0x00, 0x00, 0x1f,
+    0xc8, 0x00, 0x00, 0x1f, 0xd6, 0x00, 0x00, 0x1f, 0xdd, 0x00, 0x00, 0x1f,
+    0xe4, 0x00, 0x00, 0x1f, 0xe9, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x00, 0x1f,
+    0xfc, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x20, 0x11, 0x00, 0x00, 0x20,
+    0x18, 0x00, 0x00, 0x20, 0x1e, 0x00, 0x00, 0x20, 0x23, 0x00, 0x00, 0x20,
+    0x28, 0x00, 0x00, 0x20, 0x2e, 0x00, 0x00, 0x20, 0x35, 0x00, 0x00, 0x20,
+    0x3f, 0x00, 0x00, 0x20, 0x47, 0x00, 0x00, 0x20, 0x50, 0x00, 0x00, 0x20,
+    0x57, 0x00, 0x00, 0x20, 0x5e, 0x00, 0x00, 0x20, 0x69, 0x00, 0x00, 0x20,
+    0x74, 0x00, 0x00, 0x20, 0x82, 0x00, 0x00, 0x20, 0x88, 0x00, 0x00, 0x20,
+    0x92, 0x00, 0x00, 0x20, 0x9c, 0x00, 0x00, 0x20, 0xa9, 0x00, 0x00, 0x20,
+    0xb0, 0x00, 0x00, 0x20, 0xb8, 0x00, 0x00, 0x20, 0xc2, 0x00, 0x00, 0x20,
+    0xce, 0x00, 0x00, 0x20, 0xd8, 0x00, 0x00, 0x20, 0xdd, 0x00, 0x00, 0x20,
+    0xe5, 0x00, 0x00, 0x20, 0xf2, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21,
+    0x0a, 0x00, 0x00, 0x21, 0x13, 0x00, 0x00, 0x21, 0x19, 0x00, 0x00, 0x21,
+    0x21, 0x00, 0x00, 0x21, 0x29, 0x00, 0x00, 0x21, 0x35, 0x00, 0x00, 0x21,
+    0x3c, 0x00, 0x00, 0x21, 0x42, 0x00, 0x00, 0x21, 0x47, 0x00, 0x00, 0x21,
+    0x50, 0x00, 0x00, 0x21, 0x5c, 0x00, 0x00, 0x21, 0x63, 0x00, 0x00, 0x21,
+    0x69, 0x00, 0x00, 0x21, 0x72, 0x00, 0x00, 0x21, 0x7f, 0x00, 0x00, 0x21,
+    0x8c, 0x00, 0x00, 0x21, 0x97, 0x00, 0x00, 0x21, 0x9f, 0x00, 0x00, 0x21,
+    0xa8, 0x00, 0x00, 0x21, 0xae, 0x00, 0x00, 0x21, 0xb5, 0x00, 0x00, 0x21,
+    0xbc, 0x00, 0x00, 0x21, 0xc4, 0x00, 0x00, 0x21, 0xd1, 0x00, 0x00, 0x21,
+    0xda, 0x00, 0x00, 0x21, 0xe6, 0x00, 0x00, 0x21, 0xf4, 0x00, 0x00, 0x21,
+    0xfa, 0x00, 0x00, 0x22, 0x04, 0x00, 0x00, 0x22, 0x0e, 0x00, 0x00, 0x22,
+    0x14, 0x00, 0x00, 0x22, 0x1e, 0x00, 0x00, 0x22, 0x26, 0x00, 0x00, 0x22,
+    0x2e, 0x00, 0x00, 0x22, 0x33, 0x00, 0x00, 0x22, 0x39, 0x00, 0x00, 0x22,
+    0x40, 0x00, 0x00, 0x22, 0x46, 0x00, 0x00, 0x22, 0x4f, 0x00, 0x00, 0x22,
+    0x56, 0x00, 0x00, 0x22, 0x61, 0x00, 0x00, 0x22, 0x6a, 0x00, 0x00, 0x22,
+    0x74, 0x00, 0x00, 0x22, 0x7b, 0x00, 0x00, 0x22, 0x82, 0x00, 0x00, 0x22,
+    0x8b, 0x00, 0x00, 0x22, 0x97, 0x00, 0x00, 0x22, 0xa3, 0x00, 0x00, 0x22,
+    0xac, 0x00, 0x00, 0x22, 0xb9, 0x00, 0x00, 0x22, 0xbf, 0x00, 0x00, 0x22,
+    0xc5, 0x00, 0x00, 0x22, 0xd1, 0x00, 0x00, 0x22, 0xd6, 0x00, 0x00, 0x22,
+    0xe1, 0x00, 0x00, 0x22, 0xec, 0x00, 0x00, 0x22, 0xf8, 0x00, 0x00, 0x22,
+    0xfe, 0x00, 0x00, 0x23, 0x0b, 0x00, 0x00, 0x23, 0x17, 0x00, 0x00, 0x23,
+    0x1f, 0x00, 0x00, 0x23, 0x29, 0x00, 0x00, 0x23, 0x37, 0x00, 0x00, 0x23,
+    0x42, 0x00, 0x00, 0x23, 0x4d, 0x00, 0x00, 0x23, 0x57, 0x00, 0x00, 0x23,
+    0x61, 0x00, 0x00, 0x23, 0x66, 0x00, 0x00, 0x23, 0x6e, 0x00, 0x00, 0x23,
+    0x79, 0x00, 0x00, 0x23, 0x82, 0x00, 0x00, 0x23, 0x8d, 0x00, 0x00, 0x23,
+    0x95, 0x00, 0x00, 0x23, 0x9d, 0x00, 0x00, 0x23, 0xa3, 0x6e, 0x61, 0x6d,
+    0x65, 0x00, 0x75, 0x73, 0x67, 0x73, 0x00, 0x75, 0x6e, 0x69, 0x66, 0x6f,
+    0x72, 0x6d, 0x00, 0x6c, 0x61, 0x72, 0x67, 0x65, 0x00, 0x6d, 0x65, 0x64,
+    0x69, 0x75, 0x6d, 0x00, 0x73, 0x6d, 0x61, 0x6c, 0x6c, 0x00, 0x75, 0x6e,
+    0x69, 0x66, 0x69, 0x65, 0x64, 0x00, 0x4d, 0x69, 0x64, 0x77, 0x61, 0x79,
+    0x00, 0x46, 0x61, 0x69, 0x72, 0x76, 0x69, 0x65, 0x77, 0x00, 0x4f, 0x61,
+    0x6b, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x46, 0x69, 0x76, 0x65,
+    0x20, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x00, 0x50, 0x6c, 0x65, 0x61,
+    0x73, 0x61, 0x6e, 0x74, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x52, 0x69,
+    0x76, 0x65, 0x72, 0x73, 0x69, 0x64, 0x65, 0x00, 0x4d, 0x6f, 0x75, 0x6e,
+    0x74, 0x20, 0x50, 0x6c, 0x65, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x00, 0x43,
+    0x65, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x42,
+    0x65, 0x74, 0x68, 0x65, 0x6c, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x48, 0x6f,
+    0x70, 0x65, 0x00, 0x4c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x79, 0x00, 0x55,
+    0x6e, 0x69, 0x6f, 0x6e, 0x00, 0x50, 0x6c, 0x65, 0x61, 0x73, 0x61, 0x6e,
+    0x74, 0x20, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x4f, 0x61, 0x6b,
+    0x6c, 0x61, 0x6e, 0x64, 0x00, 0x53, 0x61, 0x6c, 0x65, 0x6d, 0x00, 0x50,
+    0x6c, 0x65, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x20, 0x47, 0x72, 0x6f, 0x76,
+    0x65, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x77, 0x6f, 0x6f, 0x64, 0x00,
+    0x53, 0x68, 0x61, 0x64, 0x79, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00,
+    0x50, 0x69, 0x6e, 0x65, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x53,
+    0x68, 0x69, 0x6c, 0x6f, 0x68, 0x00, 0x4f, 0x61, 0x6b, 0x20, 0x48, 0x69,
+    0x6c, 0x6c, 0x00, 0x43, 0x6f, 0x6e, 0x63, 0x6f, 0x72, 0x64, 0x00, 0x47,
+    0x65, 0x6f, 0x72, 0x67, 0x65, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x43, 0x65,
+    0x64, 0x61, 0x72, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x4c, 0x61,
+    0x6b, 0x65, 0x76, 0x69, 0x65, 0x77, 0x00, 0x41, 0x6e, 0x74, 0x69, 0x6f,
+    0x63, 0x68, 0x00, 0x47, 0x6c, 0x65, 0x6e, 0x64, 0x61, 0x6c, 0x65, 0x00,
+    0x48, 0x6f, 0x70, 0x65, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x46, 0x72, 0x69,
+    0x65, 0x6e, 0x64, 0x73, 0x68, 0x69, 0x70, 0x00, 0x53, 0x75, 0x6e, 0x6e,
+    0x79, 0x73, 0x69, 0x64, 0x65, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67,
+    0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x77, 0x6f,
+    0x6f, 0x64, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x00, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x77,
+    0x6e, 0x00, 0x48, 0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x79, 0x00, 0x52, 0x69,
+    0x76, 0x65, 0x72, 0x76, 0x69, 0x65, 0x77, 0x00, 0x42, 0x75, 0x65, 0x6e,
+    0x61, 0x20, 0x56, 0x69, 0x73, 0x74, 0x61, 0x00, 0x48, 0x69, 0x67, 0x68,
+    0x6c, 0x61, 0x6e, 0x64, 0x00, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x61, 0x6e,
+    0x64, 0x20, 0x50, 0x61, 0x72, 0x6b, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b,
+    0x6c, 0x69, 0x6e, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x6c, 0x61, 0x77, 0x6e,
+    0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x56, 0x65, 0x72, 0x6e, 0x6f,
+    0x6e, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x73, 0x69, 0x64, 0x65, 0x00, 0x47,
+    0x6c, 0x65, 0x6e, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x46, 0x61, 0x69, 0x72,
+    0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x4f, 0x61, 0x6b, 0x64, 0x61, 0x6c,
+    0x65, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x56, 0x61, 0x6c,
+    0x6c, 0x65, 0x79, 0x00, 0x57, 0x61, 0x6c, 0x6e, 0x75, 0x74, 0x20, 0x47,
+    0x72, 0x6f, 0x76, 0x65, 0x00, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65,
+    0x6e, 0x63, 0x65, 0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x5a, 0x69,
+    0x6f, 0x6e, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x76, 0x69, 0x6c, 0x6c,
+    0x65, 0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x4f, 0x6c, 0x69, 0x76,
+    0x65, 0x00, 0x57, 0x69, 0x6c, 0x64, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x48,
+    0x69, 0x6c, 0x6c, 0x63, 0x72, 0x65, 0x73, 0x74, 0x00, 0x43, 0x72, 0x6f,
+    0x73, 0x73, 0x72, 0x6f, 0x61, 0x64, 0x73, 0x00, 0x42, 0x65, 0x6c, 0x6d,
+    0x6f, 0x6e, 0x74, 0x00, 0x57, 0x69, 0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x52,
+    0x69, 0x76, 0x65, 0x72, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x4e, 0x65, 0x77,
+    0x70, 0x6f, 0x72, 0x74, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x64,
+    0x61, 0x6c, 0x65, 0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x61, 0x69, 0x6e,
+    0x20, 0x56, 0x69, 0x65, 0x77, 0x00, 0x46, 0x6f, 0x72, 0x65, 0x73, 0x74,
+    0x20, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x00, 0x42, 0x72, 0x69, 0x64, 0x67,
+    0x65, 0x70, 0x6f, 0x72, 0x74, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65, 0x20,
+    0x4f, 0x61, 0x6b, 0x00, 0x4f, 0x61, 0x6b, 0x77, 0x6f, 0x6f, 0x64, 0x00,
+    0x4e, 0x65, 0x77, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x4d, 0x61, 0x63, 0x65,
+    0x64, 0x6f, 0x6e, 0x69, 0x61, 0x00, 0x46, 0x69, 0x76, 0x65, 0x20, 0x46,
+    0x6f, 0x72, 0x6b, 0x73, 0x00, 0x45, 0x64, 0x67, 0x65, 0x77, 0x6f, 0x6f,
+    0x64, 0x00, 0x41, 0x72, 0x6c, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00,
+    0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x52,
+    0x65, 0x64, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x43, 0x6c, 0x69, 0x6e,
+    0x74, 0x6f, 0x6e, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x76, 0x69, 0x6c, 0x6c,
+    0x65, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x69, 0x74, 0x00, 0x4a, 0x61, 0x6d,
+    0x65, 0x73, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x48, 0x61, 0x6d, 0x69, 0x6c,
+    0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6c, 0x69, 0x66, 0x74, 0x6f, 0x6e, 0x00,
+    0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x53,
+    0x75, 0x6c, 0x70, 0x68, 0x75, 0x72, 0x20, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x73, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x00, 0x4c,
+    0x65, 0x62, 0x61, 0x6e, 0x6f, 0x6e, 0x00, 0x46, 0x61, 0x72, 0x6d, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x45, 0x6e, 0x74, 0x65, 0x72, 0x70,
+    0x72, 0x69, 0x73, 0x65, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e, 0x73, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x41, 0x73, 0x68, 0x6c, 0x61, 0x6e, 0x64,
+    0x00, 0x57, 0x6f, 0x6f, 0x64, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x57, 0x61,
+    0x74, 0x65, 0x72, 0x6c, 0x6f, 0x6f, 0x00, 0x56, 0x61, 0x6c, 0x6c, 0x65,
+    0x79, 0x20, 0x56, 0x69, 0x65, 0x77, 0x00, 0x4f, 0x61, 0x6b, 0x20, 0x52,
+    0x69, 0x64, 0x67, 0x65, 0x00, 0x4d, 0x61, 0x70, 0x6c, 0x65, 0x20, 0x47,
+    0x72, 0x6f, 0x76, 0x65, 0x00, 0x4b, 0x69, 0x6e, 0x67, 0x73, 0x74, 0x6f,
+    0x6e, 0x00, 0x4a, 0x61, 0x63, 0x6b, 0x73, 0x6f, 0x6e, 0x00, 0x47, 0x72,
+    0x65, 0x65, 0x6e, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x47, 0x72, 0x65,
+    0x65, 0x6e, 0x20, 0x41, 0x63, 0x72, 0x65, 0x73, 0x00, 0x50, 0x6c, 0x61,
+    0x69, 0x6e, 0x76, 0x69, 0x65, 0x77, 0x00, 0x4d, 0x61, 0x72, 0x69, 0x6f,
+    0x6e, 0x00, 0x46, 0x6c, 0x6f, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x00, 0x44,
+    0x65, 0x65, 0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x42, 0x75, 0x6e,
+    0x6b, 0x65, 0x72, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x6d, 0x69,
+    0x74, 0x68, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x52, 0x6f, 0x63, 0x6b,
+    0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x65, 0x6c, 0x72, 0x6f, 0x73,
+    0x65, 0x00, 0x4d, 0x61, 0x67, 0x6e, 0x6f, 0x6c, 0x69, 0x61, 0x00, 0x4a,
+    0x65, 0x66, 0x66, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x4a, 0x61, 0x63,
+    0x6b, 0x73, 0x6f, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x48, 0x65,
+    0x62, 0x72, 0x6f, 0x6e, 0x00, 0x41, 0x76, 0x6f, 0x6e, 0x64, 0x61, 0x6c,
+    0x65, 0x00, 0x50, 0x65, 0x74, 0x65, 0x72, 0x73, 0x62, 0x75, 0x72, 0x67,
+    0x00, 0x4e, 0x65, 0x65, 0x64, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x4d, 0x6f,
+    0x75, 0x6e, 0x74, 0x20, 0x43, 0x61, 0x72, 0x6d, 0x65, 0x6c, 0x00, 0x45,
+    0x75, 0x72, 0x65, 0x6b, 0x61, 0x00, 0x45, 0x64, 0x65, 0x6e, 0x00, 0x44,
+    0x6f, 0x76, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x72, 0x69, 0x6e, 0x74, 0x68,
+    0x00, 0x42, 0x75, 0x66, 0x66, 0x61, 0x6c, 0x6f, 0x00, 0x52, 0x6f, 0x73,
+    0x65, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x50, 0x6c, 0x65, 0x61, 0x73, 0x61,
+    0x6e, 0x74, 0x20, 0x56, 0x69, 0x65, 0x77, 0x00, 0x4d, 0x69, 0x6c, 0x74,
+    0x6f, 0x6e, 0x00, 0x49, 0x6e, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65,
+    0x6e, 0x63, 0x65, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x64, 0x76, 0x69, 0x65,
+    0x77, 0x00, 0x46, 0x6f, 0x75, 0x72, 0x20, 0x43, 0x6f, 0x72, 0x6e, 0x65,
+    0x72, 0x73, 0x00, 0x43, 0x6c, 0x6f, 0x76, 0x65, 0x72, 0x64, 0x61, 0x6c,
+    0x65, 0x00, 0x57, 0x65, 0x73, 0x74, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x56,
+    0x65, 0x72, 0x6e, 0x6f, 0x6e, 0x00, 0x53, 0x68, 0x61, 0x72, 0x6f, 0x6e,
+    0x00, 0x52, 0x69, 0x63, 0x68, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x42, 0x65,
+    0x75, 0x6c, 0x61, 0x68, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d,
+    0x73, 0x62, 0x75, 0x72, 0x67, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x79, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x64, 0x61, 0x6c,
+    0x65, 0x00, 0x45, 0x62, 0x65, 0x6e, 0x65, 0x7a, 0x65, 0x72, 0x00, 0x43,
+    0x72, 0x6f, 0x73, 0x73, 0x20, 0x52, 0x6f, 0x61, 0x64, 0x73, 0x00, 0x57,
+    0x69, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x74, 0x65, 0x72, 0x00, 0x57, 0x61,
+    0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x72, 0x6f,
+    0x79, 0x00, 0x50, 0x72, 0x6f, 0x73, 0x70, 0x65, 0x63, 0x74, 0x00, 0x4f,
+    0x78, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x4e, 0x6f, 0x72, 0x77, 0x6f, 0x6f,
+    0x64, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x20, 0x43, 0x72, 0x65, 0x65, 0x6b,
+    0x00, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x74, 0x6f, 0x77, 0x6e, 0x00,
+    0x4a, 0x65, 0x72, 0x69, 0x63, 0x68, 0x6f, 0x00, 0x46, 0x6f, 0x72, 0x65,
+    0x73, 0x74, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x00, 0x43, 0x6f, 0x6c,
+    0x75, 0x6d, 0x62, 0x69, 0x61, 0x00, 0x42, 0x65, 0x74, 0x68, 0x6c, 0x65,
+    0x68, 0x65, 0x6d, 0x00, 0x41, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e,
+    0x00, 0x57, 0x61, 0x76, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x57, 0x61, 0x74,
+    0x73, 0x6f, 0x6e, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x20, 0x48, 0x69, 0x6c,
+    0x6c, 0x00, 0x50, 0x69, 0x6e, 0x65, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00,
+    0x4d, 0x6f, 0x6e, 0x72, 0x6f, 0x65, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x74,
+    0x6f, 0x77, 0x6e, 0x00, 0x4d, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x73, 0x74,
+    0x65, 0x72, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x74, 0x6f, 0x70, 0x00, 0x48,
+    0x61, 0x72, 0x72, 0x69, 0x73, 0x62, 0x75, 0x72, 0x67, 0x00, 0x44, 0x69,
+    0x78, 0x69, 0x65, 0x00, 0x42, 0x65, 0x6c, 0x6c, 0x65, 0x76, 0x75, 0x65,
+    0x00, 0x53, 0x6d, 0x79, 0x72, 0x6e, 0x61, 0x00, 0x53, 0x68, 0x65, 0x72,
+    0x77, 0x6f, 0x6f, 0x64, 0x20, 0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x00,
+    0x50, 0x6c, 0x65, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x20, 0x52, 0x69, 0x64,
+    0x67, 0x65, 0x00, 0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x20, 0x50, 0x61,
+    0x72, 0x6b, 0x00, 0x44, 0x61, 0x79, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6c,
+    0x61, 0x79, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74, 0x65,
+    0x72, 0x00, 0x57, 0x65, 0x62, 0x73, 0x74, 0x65, 0x72, 0x00, 0x57, 0x61,
+    0x72, 0x72, 0x65, 0x6e, 0x00, 0x53, 0x6f, 0x6d, 0x65, 0x72, 0x73, 0x65,
+    0x74, 0x00, 0x52, 0x69, 0x63, 0x68, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x4d,
+    0x69, 0x6c, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73,
+    0x6f, 0x6e, 0x00, 0x45, 0x76, 0x65, 0x72, 0x67, 0x72, 0x65, 0x65, 0x6e,
+    0x00, 0x45, 0x6c, 0x6d, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x42, 0x6c, 0x6f,
+    0x6f, 0x6d, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x42, 0x65, 0x74, 0x68,
+    0x61, 0x6e, 0x79, 0x00, 0x41, 0x75, 0x62, 0x75, 0x72, 0x6e, 0x00, 0x57,
+    0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73, 0x00, 0x57, 0x61, 0x6c, 0x6b,
+    0x65, 0x72, 0x00, 0x52, 0x6f, 0x73, 0x65, 0x6d, 0x6f, 0x6e, 0x74, 0x00,
+    0x4d, 0x69, 0x6c, 0x6c, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x65,
+    0x63, 0x68, 0x61, 0x6e, 0x69, 0x63, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65,
+    0x00, 0x4c, 0x69, 0x62, 0x65, 0x72, 0x74, 0x79, 0x20, 0x48, 0x69, 0x6c,
+    0x6c, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x62, 0x6f, 0x72, 0x6f, 0x00, 0x48,
+    0x69, 0x63, 0x6b, 0x6f, 0x72, 0x79, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65,
+    0x00, 0x47, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x74, 0x6f, 0x77, 0x6e, 0x00,
+    0x46, 0x6c, 0x61, 0x74, 0x20, 0x52, 0x6f, 0x63, 0x6b, 0x00, 0x44, 0x6f,
+    0x75, 0x67, 0x6c, 0x61, 0x73, 0x00, 0x43, 0x6c, 0x65, 0x76, 0x65, 0x6c,
+    0x61, 0x6e, 0x64, 0x00, 0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x00,
+    0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x6c, 0x79, 0x6e, 0x00, 0x42, 0x72, 0x69,
+    0x67, 0x68, 0x74, 0x6f, 0x6e, 0x00, 0x41, 0x6c, 0x70, 0x69, 0x6e, 0x65,
+    0x00, 0x57, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x61, 0x79, 0x6c,
+    0x6f, 0x72, 0x00, 0x53, 0x68, 0x65, 0x72, 0x77, 0x6f, 0x6f, 0x64, 0x20,
+    0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x64,
+    0x61, 0x6c, 0x65, 0x00, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x65, 0x74, 0x6f,
+    0x6e, 0x00, 0x50, 0x72, 0x65, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x4e, 0x65,
+    0x6c, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x00,
+    0x4d, 0x61, 0x64, 0x69, 0x73, 0x6f, 0x6e, 0x00, 0x4c, 0x6f, 0x67, 0x61,
+    0x6e, 0x00, 0x4c, 0x69, 0x6e, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x48, 0x6f,
+    0x70, 0x65, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x48,
+    0x69, 0x67, 0x68, 0x20, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x47, 0x6f,
+    0x73, 0x68, 0x65, 0x6e, 0x00, 0x44, 0x61, 0x6e, 0x76, 0x69, 0x6c, 0x6c,
+    0x65, 0x00, 0x42, 0x75, 0x72, 0x6c, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e,
+    0x00, 0x57, 0x61, 0x6c, 0x6c, 0x61, 0x63, 0x65, 0x00, 0x52, 0x6f, 0x63,
+    0x6b, 0x20, 0x43, 0x72, 0x65, 0x65, 0x6b, 0x00, 0x4f, 0x61, 0x6b, 0x20,
+    0x50, 0x61, 0x72, 0x6b, 0x00, 0x4d, 0x65, 0x61, 0x64, 0x6f, 0x77, 0x62,
+    0x72, 0x6f, 0x6f, 0x6b, 0x00, 0x4c, 0x6f, 0x63, 0x75, 0x73, 0x74, 0x20,
+    0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x4c, 0x65, 0x78, 0x69, 0x6e, 0x67,
+    0x74, 0x6f, 0x6e, 0x00, 0x48, 0x6f, 0x77, 0x61, 0x72, 0x64, 0x00, 0x48,
+    0x65, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x48, 0x61, 0x6e,
+    0x6f, 0x76, 0x65, 0x72, 0x00, 0x48, 0x61, 0x6d, 0x70, 0x74, 0x6f, 0x6e,
+    0x00, 0x48, 0x61, 0x6d, 0x62, 0x75, 0x72, 0x67, 0x00, 0x46, 0x69, 0x76,
+    0x65, 0x20, 0x43, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x46, 0x61,
+    0x69, 0x72, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x00, 0x43, 0x68, 0x61, 0x70,
+    0x65, 0x6c, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x43, 0x61, 0x6e, 0x74,
+    0x6f, 0x6e, 0x00, 0x43, 0x61, 0x6d, 0x70, 0x62, 0x65, 0x6c, 0x6c, 0x00,
+    0x42, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x00, 0x42, 0x61, 0x6b, 0x65, 0x72,
+    0x00, 0x41, 0x76, 0x6f, 0x6e, 0x00, 0x41, 0x72, 0x63, 0x61, 0x64, 0x69,
+    0x61, 0x00, 0x57, 0x69, 0x6e, 0x64, 0x73, 0x6f, 0x72, 0x00, 0x57, 0x65,
+    0x73, 0x74, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x53, 0x61, 0x72, 0x64,
+    0x69, 0x73, 0x00, 0x52, 0x75, 0x73, 0x73, 0x65, 0x6c, 0x6c, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x00, 0x52, 0x6f, 0x67, 0x65, 0x72, 0x73, 0x00, 0x52,
+    0x6f, 0x63, 0x6b, 0x20, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x00,
+    0x52, 0x69, 0x76, 0x65, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x52, 0x61, 0x6e,
+    0x64, 0x6f, 0x6c, 0x70, 0x68, 0x00, 0x50, 0x6c, 0x79, 0x6d, 0x6f, 0x75,
+    0x74, 0x68, 0x00, 0x50, 0x69, 0x6e, 0x65, 0x79, 0x20, 0x47, 0x72, 0x6f,
+    0x76, 0x65, 0x00, 0x50, 0x69, 0x6e, 0x65, 0x68, 0x75, 0x72, 0x73, 0x74,
+    0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x48, 0x6f, 0x70, 0x65, 0x00,
+    0x4d, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x73, 0x65, 0x00, 0x4d, 0x69, 0x6c,
+    0x6c, 0x65, 0x72, 0x00, 0x4d, 0x61, 0x72, 0x73, 0x68, 0x61, 0x6c, 0x6c,
+    0x00, 0x4c, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4b, 0x65, 0x79, 0x73,
+    0x74, 0x6f, 0x6e, 0x65, 0x00, 0x49, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x20,
+    0x48, 0x69, 0x6c, 0x6c, 0x73, 0x00, 0x48, 0x75, 0x64, 0x73, 0x6f, 0x6e,
+    0x00, 0x47, 0x65, 0x6e, 0x65, 0x76, 0x61, 0x00, 0x45, 0x6e, 0x67, 0x6c,
+    0x65, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x43, 0x6f, 0x74, 0x74, 0x6f, 0x6e,
+    0x77, 0x6f, 0x6f, 0x64, 0x00, 0x43, 0x6c, 0x79, 0x64, 0x65, 0x00, 0x43,
+    0x65, 0x64, 0x61, 0x72, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x42, 0x72,
+    0x69, 0x73, 0x74, 0x6f, 0x6c, 0x00, 0x42, 0x65, 0x65, 0x63, 0x68, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x41, 0x75, 0x72, 0x6f, 0x72, 0x61, 0x00, 0x57,
+    0x65, 0x73, 0x74, 0x20, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x54, 0x72,
+    0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x75, 0x6e, 0x73, 0x65, 0x74,
+    0x00, 0x53, 0x75, 0x6e, 0x72, 0x69, 0x73, 0x65, 0x00, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x20, 0x43, 0x72, 0x65, 0x65, 0x6b, 0x00, 0x52, 0x6f,
+    0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x00,
+    0x50, 0x6f, 0x72, 0x74, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x50, 0x69, 0x6e,
+    0x65, 0x20, 0x52, 0x69, 0x64, 0x67, 0x65, 0x00, 0x50, 0x61, 0x72, 0x61,
+    0x64, 0x69, 0x73, 0x65, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x69, 0x63, 0x65,
+    0x6c, 0x6c, 0x6f, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x79,
+    0x00, 0x4d, 0x69, 0x74, 0x63, 0x68, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x69,
+    0x64, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x4a, 0x6f, 0x72, 0x64, 0x61, 0x6e,
+    0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x56, 0x61, 0x6c, 0x6c, 0x65,
+    0x79, 0x00, 0x47, 0x61, 0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x47,
+    0x61, 0x72, 0x64, 0x65, 0x6e, 0x20, 0x43, 0x69, 0x74, 0x79, 0x00, 0x43,
+    0x6f, 0x6c, 0x64, 0x20, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x00, 0x43,
+    0x6c, 0x61, 0x72, 0x6b, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x43,
+    0x61, 0x6d, 0x65, 0x72, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x6d, 0x62, 0x72,
+    0x69, 0x64, 0x67, 0x65, 0x00, 0x41, 0x73, 0x62, 0x75, 0x72, 0x79, 0x00,
+    0x41, 0x64, 0x61, 0x6d, 0x73, 0x00, 0x59, 0x6f, 0x72, 0x6b, 0x00, 0x57,
+    0x68, 0x69, 0x74, 0x65, 0x20, 0x52, 0x6f, 0x63, 0x6b, 0x00, 0x57, 0x61,
+    0x6b, 0x65, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x56, 0x69, 0x63, 0x74,
+    0x6f, 0x72, 0x69, 0x61, 0x00, 0x55, 0x6e, 0x69, 0x74, 0x79, 0x00, 0x54,
+    0x77, 0x69, 0x6e, 0x20, 0x4c, 0x61, 0x6b, 0x65, 0x73, 0x00, 0x54, 0x68,
+    0x72, 0x65, 0x65, 0x20, 0x46, 0x6f, 0x72, 0x6b, 0x73, 0x00, 0x53, 0x79,
+    0x63, 0x61, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x52, 0x75, 0x73, 0x73, 0x65,
+    0x6c, 0x6c, 0x00, 0x52, 0x69, 0x64, 0x67, 0x65, 0x77, 0x61, 0x79, 0x00,
+    0x50, 0x69, 0x73, 0x67, 0x61, 0x68, 0x00, 0x4d, 0x6f, 0x72, 0x67, 0x61,
+    0x6e, 0x00, 0x4d, 0x61, 0x79, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x4d,
+    0x61, 0x70, 0x6c, 0x65, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4c, 0x6f, 0x6e,
+    0x67, 0x76, 0x69, 0x65, 0x77, 0x00, 0x4c, 0x69, 0x6e, 0x64, 0x65, 0x6e,
+    0x00, 0x4c, 0x61, 0x6e, 0x63, 0x61, 0x73, 0x74, 0x65, 0x72, 0x00, 0x48,
+    0x61, 0x72, 0x72, 0x69, 0x73, 0x00, 0x47, 0x6f, 0x6f, 0x64, 0x20, 0x48,
+    0x6f, 0x70, 0x65, 0x00, 0x47, 0x69, 0x62, 0x73, 0x6f, 0x6e, 0x00, 0x46,
+    0x75, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x44, 0x65, 0x65, 0x72, 0x20, 0x50,
+    0x61, 0x72, 0x6b, 0x00, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x73, 0x74,
+    0x6f, 0x6e, 0x00, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x43, 0x61,
+    0x6e, 0x61, 0x61, 0x6e, 0x00, 0x42, 0x6f, 0x73, 0x74, 0x6f, 0x6e, 0x00,
+    0x42, 0x65, 0x76, 0x65, 0x72, 0x6c, 0x79, 0x20, 0x48, 0x69, 0x6c, 0x6c,
+    0x73, 0x00, 0x42, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x6f, 0x6f,
+    0x64, 0x73, 0x74, 0x6f, 0x63, 0x6b, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65,
+    0x20, 0x43, 0x69, 0x74, 0x79, 0x00, 0x57, 0x65, 0x73, 0x74, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x00, 0x57, 0x61, 0x74, 0x65, 0x72, 0x66, 0x6f, 0x72,
+    0x64, 0x00, 0x57, 0x61, 0x6c, 0x6e, 0x75, 0x74, 0x20, 0x48, 0x69, 0x6c,
+    0x6c, 0x00, 0x56, 0x65, 0x72, 0x6f, 0x6e, 0x61, 0x00, 0x54, 0x75, 0x72,
+    0x6e, 0x65, 0x72, 0x00, 0x53, 0x74, 0x65, 0x72, 0x6c, 0x69, 0x6e, 0x67,
+    0x00, 0x53, 0x68, 0x65, 0x72, 0x69, 0x64, 0x61, 0x6e, 0x00, 0x53, 0x61,
+    0x6e, 0x64, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x50, 0x75, 0x6d, 0x70,
+    0x6b, 0x69, 0x6e, 0x20, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x00, 0x50,
+    0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x50, 0x6f, 0x70, 0x6c, 0x61, 0x72,
+    0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x50, 0x65, 0x72, 0x72, 0x79,
+    0x00, 0x50, 0x61, 0x72, 0x6b, 0x65, 0x72, 0x00, 0x4f, 0x6c, 0x64, 0x20,
+    0x54, 0x6f, 0x77, 0x6e, 0x00, 0x4f, 0x61, 0x6b, 0x6c, 0x65, 0x79, 0x00,
+    0x4e, 0x65, 0x77, 0x74, 0x6f, 0x6e, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x53,
+    0x61, 0x6c, 0x65, 0x6d, 0x00, 0x4e, 0x61, 0x73, 0x68, 0x76, 0x69, 0x6c,
+    0x6c, 0x65, 0x00, 0x4c, 0x79, 0x6f, 0x6e, 0x73, 0x00, 0x4c, 0x6f, 0x6e,
+    0x65, 0x20, 0x53, 0x74, 0x61, 0x72, 0x00, 0x4b, 0x6c, 0x6f, 0x6e, 0x64,
+    0x69, 0x6b, 0x65, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x74, 0x6f, 0x77,
+    0x6e, 0x00, 0x48, 0x6f, 0x6c, 0x6c, 0x79, 0x20, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x73, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73, 0x6f, 0x6e,
+    0x00, 0x47, 0x61, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x46, 0x6f, 0x73,
+    0x74, 0x65, 0x72, 0x00, 0x45, 0x67, 0x79, 0x70, 0x74, 0x00, 0x44, 0x61,
+    0x76, 0x69, 0x73, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74, 0x6e, 0x75, 0x74,
+    0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x43, 0x61, 0x6d, 0x64, 0x65, 0x6e,
+    0x00, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x79, 0x65, 0x00, 0x42, 0x72, 0x6f,
+    0x6f, 0x6b, 0x73, 0x69, 0x64, 0x65, 0x00, 0x42, 0x72, 0x65, 0x6e, 0x74,
+    0x77, 0x6f, 0x6f, 0x64, 0x00, 0x41, 0x75, 0x73, 0x74, 0x69, 0x6e, 0x00,
+    0x41, 0x6c, 0x6c, 0x65, 0x6e, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x73, 0x69,
+    0x64, 0x65, 0x00, 0x53, 0x74, 0x6f, 0x6e, 0x79, 0x20, 0x50, 0x6f, 0x69,
+    0x6e, 0x74, 0x00, 0x53, 0x74, 0x61, 0x6e, 0x6c, 0x65, 0x79, 0x00, 0x53,
+    0x69, 0x6d, 0x70, 0x73, 0x6f, 0x6e, 0x00, 0x53, 0x69, 0x6c, 0x76, 0x65,
+    0x72, 0x20, 0x4c, 0x61, 0x6b, 0x65, 0x00, 0x53, 0x61, 0x69, 0x6e, 0x74,
+    0x20, 0x50, 0x61, 0x75, 0x6c, 0x00, 0x52, 0x6f, 0x6d, 0x65, 0x00, 0x52,
+    0x6f, 0x63, 0x6b, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x52, 0x69, 0x64, 0x67,
+    0x65, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x52, 0x61, 0x79, 0x6d, 0x6f, 0x6e,
+    0x64, 0x00, 0x50, 0x69, 0x65, 0x64, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x50,
+    0x61, 0x72, 0x69, 0x73, 0x00, 0x50, 0x61, 0x6c, 0x6d, 0x79, 0x72, 0x61,
+    0x00, 0x4f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x4f, 0x61, 0x6b, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x67, 0x6f, 0x6d,
+    0x65, 0x72, 0x79, 0x00, 0x4c, 0x69, 0x6e, 0x63, 0x6f, 0x6c, 0x6e, 0x20,
+    0x50, 0x61, 0x72, 0x6b, 0x00, 0x4c, 0x61, 0x75, 0x72, 0x65, 0x6c, 0x00,
+    0x4c, 0x61, 0x6b, 0x65, 0x20, 0x43, 0x69, 0x74, 0x79, 0x00, 0x4b, 0x65,
+    0x6e, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x48, 0x75, 0x6e, 0x74, 0x73, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x00, 0x48, 0x69, 0x63, 0x6b, 0x6f, 0x72, 0x79, 0x20,
+    0x48, 0x69, 0x6c, 0x6c, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x74, 0x00, 0x46,
+    0x65, 0x72, 0x6e, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x45, 0x6e, 0x6f, 0x6e,
+    0x00, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x62, 0x75, 0x73, 0x00, 0x43, 0x61,
+    0x72, 0x6c, 0x69, 0x73, 0x6c, 0x65, 0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b,
+    0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x42, 0x72, 0x61, 0x64, 0x66, 0x6f,
+    0x72, 0x64, 0x00, 0x42, 0x6f, 0x79, 0x64, 0x00, 0x42, 0x61, 0x6c, 0x64,
+    0x77, 0x69, 0x6e, 0x00, 0x41, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x41, 0x6c,
+    0x6c, 0x65, 0x6e, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x57, 0x68, 0x69, 0x74,
+    0x65, 0x68, 0x61, 0x6c, 0x6c, 0x00, 0x57, 0x65, 0x73, 0x74, 0x77, 0x6f,
+    0x6f, 0x64, 0x00, 0x57, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x55, 0x74, 0x69,
+    0x63, 0x61, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x47, 0x72, 0x6f,
+    0x76, 0x65, 0x00, 0x54, 0x68, 0x6f, 0x72, 0x6e, 0x74, 0x6f, 0x6e, 0x00,
+    0x53, 0x68, 0x69, 0x72, 0x6c, 0x65, 0x79, 0x00, 0x52, 0x6f, 0x62, 0x69,
+    0x6e, 0x73, 0x6f, 0x6e, 0x00, 0x50, 0x61, 0x74, 0x74, 0x65, 0x72, 0x73,
+    0x6f, 0x6e, 0x00, 0x50, 0x61, 0x6c, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65,
+    0x00, 0x4e, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x4e, 0x6f, 0x72, 0x74,
+    0x68, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x48, 0x61,
+    0x76, 0x65, 0x6e, 0x00, 0x4d, 0x6f, 0x73, 0x63, 0x6f, 0x77, 0x00, 0x4c,
+    0x61, 0x6b, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x49, 0x6e, 0x64, 0x69,
+    0x61, 0x6e, 0x20, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x48,
+    0x69, 0x6c, 0x6c, 0x73, 0x69, 0x64, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x65,
+    0x6e, 0x61, 0x00, 0x48, 0x61, 0x72, 0x72, 0x69, 0x73, 0x76, 0x69, 0x6c,
+    0x6c, 0x65, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x41, 0x63, 0x72,
+    0x65, 0x73, 0x00, 0x46, 0x61, 0x69, 0x72, 0x66, 0x61, 0x78, 0x00, 0x45,
+    0x6c, 0x6c, 0x69, 0x73, 0x00, 0x45, 0x61, 0x73, 0x74, 0x6f, 0x6e, 0x00,
+    0x44, 0x75, 0x72, 0x68, 0x61, 0x6d, 0x00, 0x44, 0x69, 0x61, 0x6d, 0x6f,
+    0x6e, 0x64, 0x00, 0x44, 0x61, 0x6c, 0x65, 0x00, 0x43, 0x75, 0x62, 0x61,
+    0x00, 0x43, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x00, 0x43, 0x6f, 0x6c, 0x64,
+    0x20, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x43, 0x68, 0x65,
+    0x72, 0x72, 0x79, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x43, 0x65, 0x6e,
+    0x74, 0x65, 0x72, 0x20, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x43, 0x61,
+    0x69, 0x72, 0x6f, 0x00, 0x42, 0x75, 0x74, 0x6c, 0x65, 0x72, 0x00, 0x42,
+    0x75, 0x63, 0x6b, 0x68, 0x6f, 0x72, 0x6e, 0x00, 0x42, 0x65, 0x65, 0x63,
+    0x68, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x41, 0x75, 0x67, 0x75,
+    0x73, 0x74, 0x61, 0x00, 0x41, 0x74, 0x68, 0x65, 0x6e, 0x73, 0x00, 0x41,
+    0x6c, 0x62, 0x69, 0x6f, 0x6e, 0x00, 0x57, 0x69, 0x6e, 0x6f, 0x6e, 0x61,
+    0x00, 0x57, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x64, 0x00, 0x57, 0x65, 0x73,
+    0x74, 0x70, 0x6f, 0x72, 0x74, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x45,
+    0x6e, 0x64, 0x00, 0x57, 0x65, 0x6c, 0x6c, 0x69, 0x6e, 0x67, 0x74, 0x6f,
+    0x6e, 0x00, 0x57, 0x61, 0x72, 0x64, 0x00, 0x56, 0x69, 0x63, 0x74, 0x6f,
+    0x72, 0x00, 0x53, 0x75, 0x6e, 0x73, 0x65, 0x74, 0x20, 0x42, 0x65, 0x61,
+    0x63, 0x68, 0x00, 0x53, 0x74, 0x61, 0x6e, 0x74, 0x6f, 0x6e, 0x00, 0x53,
+    0x70, 0x65, 0x6e, 0x63, 0x65, 0x72, 0x00, 0x53, 0x6d, 0x69, 0x74, 0x68,
+    0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x53, 0x6c, 0x61, 0x62, 0x74, 0x6f,
+    0x77, 0x6e, 0x00, 0x53, 0x69, 0x64, 0x6e, 0x65, 0x79, 0x00, 0x53, 0x68,
+    0x65, 0x72, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x20,
+    0x48, 0x69, 0x6c, 0x6c, 0x00, 0x52, 0x61, 0x6d, 0x73, 0x65, 0x79, 0x00,
+    0x50, 0x6f, 0x72, 0x74, 0x65, 0x72, 0x00, 0x50, 0x6f, 0x70, 0x6c, 0x61,
+    0x72, 0x20, 0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x50, 0x65,
+    0x72, 0x72, 0x79, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x50, 0x61, 0x6c,
+    0x6d, 0x65, 0x72, 0x00, 0x4e, 0x65, 0x77, 0x62, 0x75, 0x72, 0x67, 0x00,
+    0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x4d, 0x61,
+    0x70, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x77, 0x72, 0x65,
+    0x6e, 0x63, 0x65, 0x00, 0x4c, 0x61, 0x66, 0x61, 0x79, 0x65, 0x74, 0x74,
+    0x65, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x74, 0x6f, 0x77, 0x6e, 0x00,
+    0x4a, 0x69, 0x6d, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x48, 0x75, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x48, 0x6f, 0x75, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x48,
+    0x61, 0x70, 0x70, 0x79, 0x20, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00,
+    0x48, 0x61, 0x6d, 0x6d, 0x6f, 0x6e, 0x64, 0x00, 0x47, 0x72, 0x65, 0x65,
+    0x6e, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x47, 0x6f, 0x72, 0x64, 0x6f,
+    0x6e, 0x00, 0x47, 0x6c, 0x65, 0x6e, 0x63, 0x6f, 0x65, 0x00, 0x45, 0x6c,
+    0x67, 0x69, 0x6e, 0x00, 0x44, 0x75, 0x6e, 0x64, 0x65, 0x65, 0x00, 0x44,
+    0x75, 0x6e, 0x63, 0x61, 0x6e, 0x00, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x00,
+    0x44, 0x61, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x72, 0x61, 0x77, 0x66,
+    0x6f, 0x72, 0x64, 0x00, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x20,
+    0x43, 0x6c, 0x75, 0x62, 0x20, 0x45, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73,
+    0x00, 0x43, 0x65, 0x64, 0x61, 0x72, 0x20, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x73, 0x00, 0x42, 0x72, 0x69, 0x61, 0x72, 0x77, 0x6f, 0x6f, 0x64,
+    0x00, 0x42, 0x72, 0x61, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x42, 0x6c, 0x6f,
+    0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x41, 0x72, 0x6e,
+    0x6f, 0x6c, 0x64, 0x00, 0x41, 0x6c, 0x62, 0x61, 0x6e, 0x79, 0x00, 0x41,
+    0x64, 0x61, 0x6d, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x5a, 0x69,
+    0x6f, 0x6e, 0x00, 0x57, 0x65, 0x73, 0x74, 0x6f, 0x76, 0x65, 0x72, 0x00,
+    0x57, 0x61, 0x74, 0x65, 0x72, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x55,
+    0x70, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x72, 0x69, 0x6e, 0x69, 0x74, 0x79,
+    0x00, 0x54, 0x68, 0x6f, 0x6d, 0x70, 0x73, 0x6f, 0x6e, 0x00, 0x54, 0x68,
+    0x6f, 0x6d, 0x61, 0x73, 0x00, 0x54, 0x61, 0x6e, 0x67, 0x6c, 0x65, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x53, 0x75, 0x6e, 0x73, 0x68, 0x69, 0x6e, 0x65,
+    0x00, 0x53, 0x75, 0x67, 0x61, 0x72, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65,
+    0x00, 0x53, 0x74, 0x6f, 0x63, 0x6b, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x6e,
+    0x6f, 0x77, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x68, 0x65, 0x72,
+    0x6d, 0x61, 0x6e, 0x00, 0x53, 0x63, 0x6f, 0x74, 0x6c, 0x61, 0x6e, 0x64,
+    0x00, 0x52, 0x6f, 0x73, 0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x52,
+    0x6f, 0x6f, 0x73, 0x65, 0x76, 0x65, 0x6c, 0x74, 0x00, 0x52, 0x6f, 0x63,
+    0x6b, 0x70, 0x6f, 0x72, 0x74, 0x00, 0x52, 0x6f, 0x63, 0x68, 0x65, 0x73,
+    0x74, 0x65, 0x72, 0x00, 0x50, 0x6c, 0x61, 0x69, 0x6e, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x00, 0x4f, 0x73, 0x63, 0x65, 0x6f, 0x6c, 0x61, 0x00, 0x4d,
+    0x75, 0x6c, 0x62, 0x65, 0x72, 0x72, 0x79, 0x00, 0x4d, 0x69, 0x6c, 0x6c,
+    0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4d, 0x63, 0x44, 0x6f, 0x6e, 0x61, 0x6c,
+    0x64, 0x00, 0x4d, 0x61, 0x79, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00,
+    0x4d, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x4d, 0x61, 0x72, 0x79, 0x73, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4d, 0x61, 0x6e, 0x73, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x00, 0x4c, 0x6f, 0x64, 0x69, 0x00, 0x4c, 0x69, 0x76, 0x69,
+    0x6e, 0x67, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x4b, 0x69, 0x72, 0x6b, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x4b, 0x65, 0x6e, 0x74, 0x00, 0x49, 0x6e, 0x67,
+    0x6c, 0x65, 0x73, 0x69, 0x64, 0x65, 0x00, 0x48, 0x79, 0x64, 0x65, 0x20,
+    0x50, 0x61, 0x72, 0x6b, 0x00, 0x48, 0x6f, 0x6d, 0x65, 0x72, 0x00, 0x48,
+    0x69, 0x63, 0x6b, 0x6f, 0x72, 0x79, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x73,
+    0x00, 0x48, 0x61, 0x77, 0x74, 0x68, 0x6f, 0x72, 0x6e, 0x65, 0x00, 0x48,
+    0x61, 0x72, 0x74, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x46, 0x72, 0x65, 0x64,
+    0x6f, 0x6e, 0x69, 0x61, 0x00, 0x45, 0x76, 0x61, 0x6e, 0x73, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x00, 0x45, 0x74, 0x6e, 0x61, 0x00, 0x45, 0x64, 0x67,
+    0x65, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x44, 0x65, 0x78, 0x74, 0x65, 0x72,
+    0x00, 0x43, 0x72, 0x65, 0x73, 0x74, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x43,
+    0x72, 0x65, 0x73, 0x63, 0x65, 0x6e, 0x74, 0x00, 0x43, 0x6f, 0x76, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x72,
+    0x79, 0x20, 0x43, 0x6c, 0x75, 0x62, 0x20, 0x45, 0x73, 0x74, 0x61, 0x74,
+    0x65, 0x73, 0x00, 0x43, 0x6f, 0x6c, 0x65, 0x6d, 0x61, 0x6e, 0x00, 0x43,
+    0x68, 0x65, 0x6c, 0x73, 0x65, 0x61, 0x00, 0x43, 0x68, 0x61, 0x70, 0x6d,
+    0x61, 0x6e, 0x00, 0x43, 0x65, 0x64, 0x61, 0x72, 0x76, 0x69, 0x6c, 0x6c,
+    0x65, 0x00, 0x42, 0x75, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x79,
+    0x61, 0x6e, 0x74, 0x00, 0x42, 0x72, 0x6f, 0x77, 0x6e, 0x74, 0x6f, 0x77,
+    0x6e, 0x00, 0x42, 0x65, 0x76, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x42, 0x65,
+    0x61, 0x76, 0x65, 0x72, 0x00, 0x42, 0x61, 0x78, 0x74, 0x65, 0x72, 0x00,
+    0x42, 0x61, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x41, 0x73, 0x68, 0x74, 0x6f,
+    0x6e, 0x00, 0x41, 0x72, 0x6d, 0x73, 0x74, 0x72, 0x6f, 0x6e, 0x67, 0x00,
+    0x41, 0x66, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x61, 0x72, 0x73, 0x61, 0x77,
+    0x00, 0x56, 0x69, 0x6f, 0x6c, 0x61, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e,
+    0x74, 0x6f, 0x77, 0x6e, 0x00, 0x54, 0x77, 0x69, 0x6e, 0x20, 0x4f, 0x61,
+    0x6b, 0x73, 0x00, 0x53, 0x77, 0x65, 0x65, 0x74, 0x77, 0x61, 0x74, 0x65,
+    0x72, 0x00, 0x53, 0x74, 0x6f, 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x6c, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x4c, 0x61, 0x6b, 0x65, 0x00,
+    0x53, 0x70, 0x61, 0x72, 0x74, 0x61, 0x00, 0x52, 0x75, 0x62, 0x79, 0x00,
+    0x52, 0x6f, 0x73, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x50, 0x6c, 0x65,
+    0x61, 0x73, 0x61, 0x6e, 0x74, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x50,
+    0x69, 0x74, 0x74, 0x73, 0x62, 0x75, 0x72, 0x67, 0x00, 0x50, 0x69, 0x6f,
+    0x6e, 0x65, 0x65, 0x72, 0x00, 0x50, 0x69, 0x6e, 0x65, 0x76, 0x69, 0x6c,
+    0x6c, 0x65, 0x00, 0x4f, 0x61, 0x6b, 0x20, 0x46, 0x6f, 0x72, 0x65, 0x73,
+    0x74, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x66, 0x69, 0x65, 0x6c, 0x64,
+    0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x20, 0x41, 0x69, 0x72, 0x79, 0x00,
+    0x4d, 0x61, 0x78, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x4d, 0x61, 0x72, 0x69,
+    0x65, 0x74, 0x74, 0x61, 0x00, 0x4c, 0x61, 0x6d, 0x6f, 0x6e, 0x74, 0x00,
+    0x4c, 0x61, 0x6b, 0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x00, 0x4b, 0x6e,
+    0x6f, 0x78, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x49, 0x64, 0x6c, 0x65,
+    0x77, 0x69, 0x6c, 0x64, 0x00, 0x48, 0x6f, 0x6c, 0x74, 0x00, 0x48, 0x61,
+    0x73, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x48, 0x61, 0x6e, 0x63, 0x6f,
+    0x63, 0x6b, 0x00, 0x47, 0x69, 0x6c, 0x62, 0x65, 0x72, 0x74, 0x00, 0x47,
+    0x61, 0x72, 0x64, 0x6e, 0x65, 0x72, 0x00, 0x46, 0x72, 0x65, 0x65, 0x64,
+    0x6f, 0x6d, 0x00, 0x45, 0x6d, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x00, 0x45,
+    0x63, 0x68, 0x6f, 0x00, 0x44, 0x69, 0x78, 0x6f, 0x6e, 0x00, 0x44, 0x65,
+    0x6e, 0x76, 0x65, 0x72, 0x00, 0x44, 0x65, 0x6e, 0x74, 0x6f, 0x6e, 0x00,
+    0x43, 0x75, 0x72, 0x74, 0x69, 0x73, 0x00, 0x43, 0x72, 0x65, 0x73, 0x74,
+    0x6f, 0x6e, 0x00, 0x43, 0x6c, 0x61, 0x72, 0x6b, 0x00, 0x43, 0x68, 0x65,
+    0x73, 0x74, 0x65, 0x72, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x43, 0x65,
+    0x64, 0x61, 0x72, 0x20, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x00, 0x43, 0x65,
+    0x64, 0x61, 0x72, 0x20, 0x43, 0x72, 0x65, 0x65, 0x6b, 0x00, 0x43, 0x61,
+    0x73, 0x63, 0x61, 0x64, 0x65, 0x00, 0x42, 0x72, 0x61, 0x6e, 0x64, 0x6f,
+    0x6e, 0x00, 0x42, 0x6c, 0x61, 0x69, 0x6e, 0x65, 0x00, 0x42, 0x61, 0x6e,
+    0x63, 0x72, 0x6f, 0x66, 0x74, 0x00, 0x41, 0x76, 0x61, 0x6c, 0x6f, 0x6e,
+    0x00, 0x41, 0x74, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x41, 0x6c, 0x6d, 0x61,
+    0x00, 0x57, 0x68, 0x65, 0x61, 0x74, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x57,
+    0x65, 0x6c, 0x6c, 0x73, 0x00, 0x53, 0x75, 0x6e, 0x20, 0x56, 0x61, 0x6c,
+    0x6c, 0x65, 0x79, 0x00, 0x53, 0x74, 0x61, 0x74, 0x65, 0x20, 0x4c, 0x69,
+    0x6e, 0x65, 0x00, 0x53, 0x69, 0x6c, 0x76, 0x65, 0x72, 0x20, 0x43, 0x69,
+    0x74, 0x79, 0x00, 0x53, 0x65, 0x6e, 0x65, 0x63, 0x61, 0x00, 0x53, 0x65,
+    0x6c, 0x6d, 0x61, 0x00, 0x53, 0x61, 0x69, 0x6e, 0x74, 0x20, 0x4a, 0x6f,
+    0x73, 0x65, 0x70, 0x68, 0x00, 0x53, 0x61, 0x69, 0x6e, 0x74, 0x20, 0x4a,
+    0x6f, 0x68, 0x6e, 0x00, 0x52, 0x6f, 0x73, 0x73, 0x00, 0x52, 0x6f, 0x62,
+    0x65, 0x72, 0x74, 0x73, 0x00, 0x52, 0x65, 0x79, 0x6e, 0x6f, 0x6c, 0x64,
+    0x73, 0x00, 0x52, 0x65, 0x64, 0x20, 0x52, 0x6f, 0x63, 0x6b, 0x00, 0x4f,
+    0x67, 0x64, 0x65, 0x6e, 0x00, 0x4e, 0x65, 0x77, 0x61, 0x72, 0x6b, 0x00,
+    0x4e, 0x65, 0x77, 0x20, 0x4c, 0x6f, 0x6e, 0x64, 0x6f, 0x6e, 0x00, 0x4d,
+    0x69, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x20, 0x53, 0x70, 0x72, 0x69, 0x6e,
+    0x67, 0x73, 0x00, 0x4d, 0x65, 0x72, 0x69, 0x64, 0x69, 0x61, 0x6e, 0x00,
+    0x4c, 0x79, 0x6e, 0x6e, 0x00, 0x4c, 0x69, 0x73, 0x62, 0x6f, 0x6e, 0x00,
+    0x4c, 0x61, 0x6d, 0x61, 0x72, 0x00, 0x4b, 0x6e, 0x6f, 0x6c, 0x6c, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x4b, 0x65, 0x6e, 0x73, 0x69, 0x6e, 0x67, 0x74,
+    0x6f, 0x6e, 0x00, 0x48, 0x6f, 0x72, 0x74, 0x6f, 0x6e, 0x00, 0x48, 0x6f,
+    0x6d, 0x65, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x48, 0x6f, 0x6d, 0x65, 0x73,
+    0x74, 0x65, 0x61, 0x64, 0x00, 0x48, 0x6f, 0x6c, 0x69, 0x64, 0x61, 0x79,
+    0x20, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x00, 0x48, 0x65, 0x6e, 0x72, 0x79,
+    0x00, 0x48, 0x61, 0x72, 0x70, 0x65, 0x72, 0x00, 0x47, 0x72, 0x65, 0x65,
+    0x6e, 0x62, 0x72, 0x69, 0x61, 0x72, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x47, 0x72, 0x61, 0x68, 0x61, 0x6d, 0x00,
+    0x47, 0x72, 0x61, 0x66, 0x74, 0x6f, 0x6e, 0x00, 0x47, 0x65, 0x6e, 0x6f,
+    0x61, 0x00, 0x46, 0x72, 0x75, 0x69, 0x74, 0x6c, 0x61, 0x6e, 0x64, 0x00,
+    0x46, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x46, 0x6f, 0x72, 0x65,
+    0x73, 0x74, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x46, 0x6f, 0x72, 0x65,
+    0x73, 0x74, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x46, 0x6f, 0x6c,
+    0x73, 0x6f, 0x6d, 0x00, 0x46, 0x6c, 0x69, 0x6e, 0x74, 0x20, 0x48, 0x69,
+    0x6c, 0x6c, 0x00, 0x46, 0x69, 0x6c, 0x6c, 0x6d, 0x6f, 0x72, 0x65, 0x00,
+    0x46, 0x65, 0x72, 0x6e, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x46, 0x61, 0x79,
+    0x65, 0x74, 0x74, 0x65, 0x00, 0x46, 0x61, 0x69, 0x72, 0x6d, 0x6f, 0x6e,
+    0x74, 0x00, 0x45, 0x61, 0x73, 0x74, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x44,
+    0x75, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x44, 0x75, 0x62, 0x6c, 0x69, 0x6e,
+    0x00, 0x44, 0x6f, 0x67, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x44, 0x61, 0x77,
+    0x73, 0x6f, 0x6e, 0x00, 0x43, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x68,
+    0x61, 0x6d, 0x00, 0x43, 0x6f, 0x6e, 0x77, 0x61, 0x79, 0x00, 0x43, 0x6f,
+    0x6c, 0x6c, 0x69, 0x6e, 0x73, 0x00, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x67,
+    0x65, 0x20, 0x50, 0x61, 0x72, 0x6b, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74,
+    0x6e, 0x75, 0x74, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x43, 0x68,
+    0x65, 0x72, 0x72, 0x79, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x43,
+    0x68, 0x65, 0x72, 0x6f, 0x6b, 0x65, 0x65, 0x00, 0x43, 0x68, 0x61, 0x74,
+    0x68, 0x61, 0x6d, 0x00, 0x43, 0x61, 0x6d, 0x65, 0x6c, 0x6f, 0x74, 0x00,
+    0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x73, 0x00, 0x42, 0x69, 0x67, 0x20, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x42, 0x69, 0x67, 0x20, 0x43,
+    0x72, 0x65, 0x65, 0x6b, 0x00, 0x42, 0x65, 0x6e, 0x73, 0x6f, 0x6e, 0x00,
+    0x42, 0x65, 0x64, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x42, 0x61, 0x72, 0x74,
+    0x6c, 0x65, 0x74, 0x74, 0x00, 0x42, 0x61, 0x69, 0x6c, 0x65, 0x79, 0x00,
+    0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x61, 0x00, 0x41, 0x6c, 0x70, 0x68,
+    0x61, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x48,
+    0x69, 0x6c, 0x6c, 0x73, 0x00, 0x57, 0x69, 0x6e, 0x66, 0x69, 0x65, 0x6c,
+    0x64, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x6f, 0x77, 0x20, 0x53, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x73, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x6f, 0x77, 0x20,
+    0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61,
+    0x6d, 0x73, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x57, 0x68, 0x65, 0x65, 0x6c,
+    0x65, 0x72, 0x00, 0x57, 0x65, 0x73, 0x74, 0x63, 0x68, 0x65, 0x73, 0x74,
+    0x65, 0x72, 0x00, 0x57, 0x61, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x79,
+    0x6c, 0x65, 0x72, 0x00, 0x54, 0x61, 0x79, 0x6c, 0x6f, 0x72, 0x73, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x53, 0x74, 0x69, 0x6c, 0x6c, 0x77, 0x61,
+    0x74, 0x65, 0x72, 0x00, 0x53, 0x68, 0x61, 0x77, 0x6e, 0x65, 0x65, 0x00,
+    0x53, 0x68, 0x61, 0x6d, 0x72, 0x6f, 0x63, 0x6b, 0x00, 0x53, 0x63, 0x6f,
+    0x74, 0x74, 0x00, 0x53, 0x61, 0x6e, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x53,
+    0x61, 0x69, 0x6e, 0x74, 0x20, 0x43, 0x68, 0x61, 0x72, 0x6c, 0x65, 0x73,
+    0x00, 0x52, 0x6f, 0x63, 0x6b, 0x79, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00,
+    0x52, 0x6f, 0x63, 0x6b, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x52, 0x69, 0x70,
+    0x6c, 0x65, 0x79, 0x00, 0x50, 0x75, 0x6c, 0x61, 0x73, 0x6b, 0x69, 0x00,
+    0x50, 0x68, 0x69, 0x6c, 0x6c, 0x69, 0x70, 0x73, 0x00, 0x50, 0x65, 0x61,
+    0x72, 0x6c, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x4d, 0x61, 0x72, 0x6b, 0x65,
+    0x74, 0x00, 0x4e, 0x65, 0x77, 0x20, 0x42, 0x6f, 0x73, 0x74, 0x6f, 0x6e,
+    0x00, 0x4e, 0x65, 0x62, 0x6f, 0x00, 0x4d, 0x6f, 0x75, 0x6e, 0x74, 0x20,
+    0x54, 0x61, 0x62, 0x6f, 0x72, 0x00, 0x4d, 0x6f, 0x72, 0x74, 0x6f, 0x6e,
+    0x00, 0x4d, 0x6f, 0x6f, 0x72, 0x65, 0x00, 0x4c, 0x6f, 0x6e, 0x67, 0x20,
+    0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x00, 0x4c, 0x6f, 0x6e, 0x64, 0x6f,
+    0x6e, 0x00, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65,
+    0x00, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x74, 0x6f, 0x6e, 0x00, 0x4a, 0x65,
+    0x72, 0x75, 0x73, 0x61, 0x6c, 0x65, 0x6d, 0x00, 0x4a, 0x61, 0x73, 0x70,
+    0x65, 0x72, 0x00, 0x48, 0x61, 0x64, 0x6c, 0x65, 0x79, 0x00, 0x47, 0x72,
+    0x6f, 0x76, 0x65, 0x00, 0x47, 0x72, 0x65, 0x65, 0x6e, 0x62, 0x72, 0x69,
+    0x65, 0x72, 0x00, 0x47, 0x72, 0x61, 0x79, 0x00, 0x47, 0x6c, 0x61, 0x73,
+    0x67, 0x6f, 0x77, 0x00, 0x46, 0x6c, 0x65, 0x74, 0x63, 0x68, 0x65, 0x72,
+    0x00, 0x46, 0x61, 0x69, 0x72, 0x20, 0x4f, 0x61, 0x6b, 0x73, 0x00, 0x45,
+    0x73, 0x73, 0x65, 0x78, 0x00, 0x45, 0x6c, 0x77, 0x6f, 0x6f, 0x64, 0x00,
+    0x45, 0x6c, 0x64, 0x6f, 0x72, 0x61, 0x64, 0x6f, 0x00, 0x44, 0x75, 0x6e,
+    0x6c, 0x61, 0x70, 0x00, 0x44, 0x75, 0x6e, 0x62, 0x61, 0x72, 0x00, 0x44,
+    0x65, 0x63, 0x61, 0x74, 0x75, 0x72, 0x00, 0x44, 0x61, 0x72, 0x6c, 0x69,
+    0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x00, 0x44, 0x61, 0x6d, 0x61, 0x73, 0x63,
+    0x75, 0x73, 0x00, 0x43, 0x72, 0x79, 0x73, 0x74, 0x61, 0x6c, 0x20, 0x53,
+    0x70, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x43, 0x72, 0x65, 0x73, 0x74,
+    0x76, 0x69, 0x65, 0x77, 0x00, 0x43, 0x6f, 0x6c, 0x64, 0x77, 0x61, 0x74,
+    0x65, 0x72, 0x00, 0x43, 0x6c, 0x69, 0x6d, 0x61, 0x78, 0x00, 0x43, 0x65,
+    0x6e, 0x74, 0x65, 0x72, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x43, 0x61,
+    0x72, 0x72, 0x6f, 0x6c, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x72,
+    0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x43, 0x61, 0x6c, 0x64, 0x77, 0x65, 0x6c,
+    0x6c, 0x00, 0x42, 0x79, 0x72, 0x6f, 0x6e, 0x00, 0x42, 0x72, 0x6f, 0x77,
+    0x6e, 0x73, 0x20, 0x43, 0x6f, 0x72, 0x6e, 0x65, 0x72, 0x00, 0x42, 0x72,
+    0x69, 0x64, 0x67, 0x65, 0x77, 0x61, 0x74, 0x65, 0x72, 0x00, 0x42, 0x6f,
+    0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x42, 0x6c, 0x75, 0x65, 0x20, 0x53, 0x70,
+    0x72, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x42, 0x6c, 0x6f, 0x6f, 0x6d, 0x69,
+    0x6e, 0x67, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x42, 0x6c, 0x61, 0x69, 0x72,
+    0x00, 0x42, 0x65, 0x74, 0x68, 0x65, 0x73, 0x64, 0x61, 0x00, 0x42, 0x65,
+    0x6c, 0x6c, 0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x42, 0x65, 0x61,
+    0x72, 0x20, 0x43, 0x72, 0x65, 0x65, 0x6b, 0x00, 0x42, 0x61, 0x79, 0x76,
+    0x69, 0x65, 0x77, 0x00, 0x41, 0x76, 0x6f, 0x63, 0x61, 0x00, 0x41, 0x72,
+    0x67, 0x79, 0x6c, 0x65, 0x00, 0x57, 0x79, 0x6f, 0x6d, 0x69, 0x6e, 0x67,
+    0x00, 0x57, 0x6f, 0x6f, 0x64, 0x6c, 0x61, 0x6e, 0x64, 0x20, 0x50, 0x61,
+    0x72, 0x6b, 0x00, 0x57, 0x69, 0x6c, 0x74, 0x6f, 0x6e, 0x00, 0x57, 0x68,
+    0x69, 0x74, 0x65, 0x20, 0x48, 0x61, 0x6c, 0x6c, 0x00, 0x57, 0x61, 0x74,
+    0x6b, 0x69, 0x6e, 0x73, 0x00, 0x57, 0x61, 0x72, 0x77, 0x69, 0x63, 0x6b,
+    0x00, 0x57, 0x61, 0x6c, 0x6e, 0x75, 0x74, 0x00, 0x56, 0x69, 0x65, 0x6e,
+    0x6e, 0x61, 0x00, 0x55, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x43, 0x69, 0x74,
+    0x79, 0x00, 0x54, 0x65, 0x78, 0x61, 0x73, 0x00, 0x53, 0x75, 0x6d, 0x6e,
+    0x65, 0x72, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65, 0x72, 0x66, 0x69, 0x65,
+    0x6c, 0x64, 0x00, 0x53, 0x75, 0x67, 0x61, 0x72, 0x20, 0x48, 0x69, 0x6c,
+    0x6c, 0x00, 0x53, 0x74, 0x72, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x64, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x53,
+    0x61, 0x72, 0x61, 0x74, 0x6f, 0x67, 0x61, 0x00, 0x53, 0x61, 0x6e, 0x20,
+    0x4a, 0x6f, 0x73, 0x65, 0x00, 0x53, 0x61, 0x69, 0x6e, 0x74, 0x20, 0x4a,
+    0x6f, 0x68, 0x6e, 0x73, 0x00, 0x52, 0x6f, 0x79, 0x61, 0x6c, 0x00, 0x52,
+    0x6f, 0x73, 0x65, 0x62, 0x75, 0x64, 0x00, 0x52, 0x6f, 0x63, 0x6b, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x52, 0x69, 0x6c, 0x65, 0x79, 0x00, 0x52, 0x65,
+    0x64, 0x20, 0x4f, 0x61, 0x6b, 0x00, 0x51, 0x75, 0x69, 0x6e, 0x63, 0x79,
+    0x00, 0x50, 0x6f, 0x6d, 0x6f, 0x6e, 0x61, 0x00, 0x50, 0x6f, 0x69, 0x6e,
+    0x74, 0x20, 0x50, 0x6c, 0x65, 0x61, 0x73, 0x61, 0x6e, 0x74, 0x00, 0x50,
+    0x68, 0x69, 0x6c, 0x61, 0x64, 0x65, 0x6c, 0x70, 0x68, 0x69, 0x61, 0x00,
+    0x50, 0x65, 0x6f, 0x72, 0x69, 0x61, 0x00, 0x4d, 0x75, 0x72, 0x72, 0x61,
+    0x79, 0x00, 0x4d, 0x69, 0x6c, 0x6c, 0x62, 0x72, 0x6f, 0x6f, 0x6b, 0x00,
+    0x4d, 0x61, 0x79, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4d, 0x61, 0x63, 0x6f,
+    0x6e, 0x00, 0x4c, 0x6f, 0x6e, 0x65, 0x20, 0x4f, 0x61, 0x6b, 0x00, 0x4c,
+    0x65, 0x77, 0x69, 0x73, 0x00, 0x4c, 0x65, 0x6f, 0x6e, 0x00, 0x4c, 0x65,
+    0x65, 0x00, 0x4a, 0x6f, 0x6e, 0x65, 0x73, 0x00, 0x48, 0x75, 0x62, 0x62,
+    0x61, 0x72, 0x64, 0x00, 0x47, 0x75, 0x6d, 0x20, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x73, 0x00, 0x47, 0x75, 0x69, 0x6c, 0x66, 0x6f, 0x72, 0x64,
+    0x00, 0x47, 0x61, 0x6c, 0x65, 0x6e, 0x61, 0x00, 0x46, 0x72, 0x65, 0x6e,
+    0x63, 0x68, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x46, 0x72, 0x65, 0x65, 0x70,
+    0x6f, 0x72, 0x74, 0x00, 0x46, 0x72, 0x61, 0x6e, 0x6b, 0x66, 0x6f, 0x72,
+    0x74, 0x00, 0x46, 0x6f, 0x77, 0x6c, 0x65, 0x72, 0x00, 0x46, 0x6c, 0x6f,
+    0x79, 0x64, 0x00, 0x46, 0x69, 0x73, 0x68, 0x65, 0x72, 0x00, 0x46, 0x61,
+    0x69, 0x72, 0x62, 0x61, 0x6e, 0x6b, 0x73, 0x00, 0x45, 0x76, 0x61, 0x6e,
+    0x73, 0x00, 0x45, 0x6d, 0x70, 0x69, 0x72, 0x65, 0x00, 0x45, 0x6c, 0x6d,
+    0x20, 0x47, 0x72, 0x6f, 0x76, 0x65, 0x00, 0x45, 0x6c, 0x6c, 0x73, 0x77,
+    0x6f, 0x72, 0x74, 0x68, 0x00, 0x45, 0x64, 0x67, 0x65, 0x77, 0x61, 0x74,
+    0x65, 0x72, 0x00, 0x44, 0x65, 0x77, 0x65, 0x79, 0x00, 0x44, 0x65, 0x72,
+    0x62, 0x79, 0x00, 0x44, 0x65, 0x6e, 0x6d, 0x61, 0x72, 0x6b, 0x00, 0x43,
+    0x6f, 0x72, 0x64, 0x6f, 0x76, 0x61, 0x00, 0x43, 0x6f, 0x6c, 0x6f, 0x6e,
+    0x69, 0x61, 0x6c, 0x20, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x00,
+    0x43, 0x6f, 0x6c, 0x66, 0x61, 0x78, 0x00, 0x43, 0x6c, 0x65, 0x61, 0x72,
+    0x76, 0x69, 0x65, 0x77, 0x00, 0x43, 0x68, 0x65, 0x73, 0x74, 0x6e, 0x75,
+    0x74, 0x20, 0x52, 0x69, 0x64, 0x67, 0x65, 0x00, 0x43, 0x61, 0x72, 0x74,
+    0x68, 0x61, 0x67, 0x65, 0x00, 0x43, 0x61, 0x72, 0x70, 0x65, 0x6e, 0x74,
+    0x65, 0x72, 0x00, 0x43, 0x61, 0x6c, 0x68, 0x6f, 0x75, 0x6e, 0x00, 0x42,
+    0x72, 0x6f, 0x6f, 0x6b, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x42, 0x72, 0x6f,
+    0x6f, 0x6b, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x42, 0x72, 0x65, 0x6e,
+    0x74, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x42, 0x69, 0x72, 0x6d, 0x69, 0x6e,
+    0x67, 0x68, 0x61, 0x6d, 0x00, 0x41, 0x72, 0x63, 0x6f, 0x6c, 0x61, 0x00,
+    0x41, 0x6e, 0x64, 0x6f, 0x76, 0x65, 0x72, 0x00, 0x41, 0x62, 0x65, 0x72,
+    0x64, 0x65, 0x65, 0x6e, 0x00, 0x59, 0x6f, 0x72, 0x6b, 0x74, 0x6f, 0x77,
+    0x6e, 0x00, 0x57, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x57, 0x6f, 0x6f,
+    0x64, 0x72, 0x6f, 0x77, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x62, 0x75, 0x72,
+    0x79, 0x00, 0x57, 0x69, 0x6e, 0x73, 0x6c, 0x6f, 0x77, 0x00, 0x57, 0x68,
+    0x69, 0x74, 0x6e, 0x65, 0x79, 0x00, 0x57, 0x68, 0x69, 0x73, 0x70, 0x65,
+    0x72, 0x69, 0x6e, 0x67, 0x20, 0x50, 0x69, 0x6e, 0x65, 0x73, 0x00, 0x57,
+    0x65, 0x6c, 0x63, 0x6f, 0x6d, 0x65, 0x00, 0x57, 0x65, 0x62, 0x62, 0x00,
+    0x57, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x74, 0x6f, 0x6e, 0x20, 0x48,
+    0x65, 0x69, 0x67, 0x68, 0x74, 0x73, 0x00, 0x53, 0x75, 0x6d, 0x6d, 0x65,
+    0x72, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x53, 0x75, 0x6c, 0x6c, 0x69,
+    0x76, 0x61, 0x6e, 0x00, 0x53, 0x74, 0x65, 0x77, 0x61, 0x72, 0x74, 0x00,
+    0x53, 0x70, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x47, 0x72, 0x6f, 0x76, 0x65,
+    0x00, 0x53, 0x69, 0x6c, 0x76, 0x65, 0x72, 0x20, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x73, 0x00, 0x53, 0x68, 0x65, 0x66, 0x66, 0x69, 0x65, 0x6c,
+    0x64, 0x00, 0x53, 0x68, 0x61, 0x6e, 0x6e, 0x6f, 0x6e, 0x00, 0x53, 0x63,
+    0x6f, 0x74, 0x74, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x53, 0x61,
+    0x69, 0x6e, 0x74, 0x20, 0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x00, 0x52,
+    0x79, 0x61, 0x6e, 0x00, 0x52, 0x75, 0x74, 0x68, 0x00, 0x52, 0x6f, 0x79,
+    0x00, 0x52, 0x6f, 0x78, 0x62, 0x75, 0x72, 0x79, 0x00, 0x52, 0x6f, 0x73,
+    0x65, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x52, 0x6f, 0x73, 0x63, 0x6f, 0x65,
+    0x00, 0x52, 0x6f, 0x63, 0x6b, 0x79, 0x20, 0x50, 0x6f, 0x69, 0x6e, 0x74,
+    0x00, 0x52, 0x69, 0x63, 0x68, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x00, 0x52,
+    0x69, 0x63, 0x68, 0x61, 0x72, 0x64, 0x73, 0x6f, 0x6e, 0x00, 0x50, 0x72,
+    0x6f, 0x63, 0x74, 0x6f, 0x72, 0x00, 0x50, 0x69, 0x6e, 0x65, 0x63, 0x72,
+    0x65, 0x73, 0x74, 0x00, 0x50, 0x69, 0x6e, 0x65, 0x20, 0x56, 0x61, 0x6c,
+    0x6c, 0x65, 0x79, 0x00, 0x50, 0x69, 0x65, 0x72, 0x63, 0x65, 0x00, 0x50,
+    0x65, 0x72, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x50, 0x61, 0x78, 0x74, 0x6f,
+    0x6e, 0x00, 0x4f, 0x6d, 0x65, 0x67, 0x61, 0x00, 0x4e, 0x6f, 0x74, 0x74,
+    0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x65,
+    0x7a, 0x75, 0x6d, 0x61, 0x00, 0x4d, 0x6f, 0x6e, 0x74, 0x61, 0x67, 0x75,
+    0x65, 0x00, 0x4d, 0x69, 0x6c, 0x6f, 0x00, 0x4d, 0x69, 0x6c, 0x61, 0x6e,
+    0x00, 0x4d, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x73, 0x76, 0x69, 0x6c, 0x6c,
+    0x65, 0x00, 0x4d, 0x61, 0x70, 0x6c, 0x65, 0x20, 0x48, 0x69, 0x6c, 0x6c,
+    0x00, 0x4c, 0x75, 0x64, 0x6c, 0x6f, 0x77, 0x00, 0x4c, 0x6f, 0x75, 0x69,
+    0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4c, 0x6f, 0x6e, 0x67, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x4c, 0x65, 0x77, 0x69, 0x73, 0x62, 0x75, 0x72,
+    0x67, 0x00, 0x4c, 0x65, 0x6e, 0x6f, 0x78, 0x00, 0x4c, 0x65, 0x65, 0x73,
+    0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4c, 0x65, 0x65, 0x73, 0x62, 0x75,
+    0x72, 0x67, 0x00, 0x4c, 0x61, 0x77, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x4b, 0x69, 0x72, 0x6b, 0x6c, 0x61, 0x6e,
+    0x64, 0x00, 0x4b, 0x65, 0x6c, 0x6c, 0x79, 0x00, 0x4a, 0x65, 0x72, 0x6f,
+    0x6d, 0x65, 0x00, 0x4a, 0x65, 0x6e, 0x6b, 0x69, 0x6e, 0x73, 0x00, 0x49,
+    0x6e, 0x64, 0x69, 0x61, 0x6e, 0x20, 0x56, 0x69, 0x6c, 0x6c, 0x61, 0x67,
+    0x65, 0x00, 0x48, 0x75, 0x72, 0x72, 0x69, 0x63, 0x61, 0x6e, 0x65, 0x00,
+    0x48, 0x6f, 0x77, 0x65, 0x6c, 0x6c, 0x00, 0x48, 0x69, 0x6c, 0x6c, 0x63,
+    0x72, 0x65, 0x73, 0x74, 0x00, 0x48, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x20,
+    0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x48, 0x61, 0x72, 0x76, 0x65,
+    0x79, 0x00, 0x48, 0x61, 0x72, 0x6d, 0x6f, 0x6e, 0x00, 0x47, 0x72, 0x65,
+    0x65, 0x6e, 0x64, 0x61, 0x6c, 0x65, 0x00, 0x47, 0x72, 0x61, 0x6e, 0x69,
+    0x74, 0x65, 0x00, 0x47, 0x6c, 0x65, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65,
+    0x00, 0x47, 0x6c, 0x61, 0x64, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x00, 0x47,
+    0x69, 0x6c, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x47, 0x61, 0x72, 0x72, 0x69,
+    0x73, 0x6f, 0x6e, 0x00, 0x46, 0x72, 0x65, 0x65, 0x6d, 0x61, 0x6e, 0x00,
+    0x46, 0x6f, 0x78, 0x00, 0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x00, 0x46, 0x6c, 0x61, 0x74, 0x77, 0x6f, 0x6f, 0x64,
+    0x73, 0x00, 0x45, 0x6c, 0x6b, 0x74, 0x6f, 0x6e, 0x00, 0x45, 0x6c, 0x69,
+    0x7a, 0x61, 0x62, 0x65, 0x74, 0x68, 0x00, 0x45, 0x6c, 0x62, 0x61, 0x00,
+    0x43, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x43,
+    0x6c, 0x65, 0x61, 0x72, 0x77, 0x61, 0x74, 0x65, 0x72, 0x00, 0x43, 0x61,
+    0x72, 0x74, 0x65, 0x72, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x43, 0x61, 0x6c, 0x65, 0x64, 0x6f, 0x6e, 0x69,
+    0x61, 0x00, 0x42, 0x75, 0x72, 0x6e, 0x73, 0x00, 0x42, 0x75, 0x63, 0x6b,
+    0x69, 0x6e, 0x67, 0x68, 0x61, 0x6d, 0x00, 0x42, 0x72, 0x75, 0x6e, 0x73,
+    0x77, 0x69, 0x63, 0x6b, 0x00, 0x42, 0x65, 0x6e, 0x6e, 0x65, 0x74, 0x74,
+    0x00, 0x42, 0x61, 0x79, 0x20, 0x56, 0x69, 0x65, 0x77, 0x00, 0x42, 0x61,
+    0x72, 0x6e, 0x65, 0x73, 0x00, 0x41, 0x72, 0x74, 0x68, 0x75, 0x72, 0x00,
+    0x41, 0x70, 0x70, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x00, 0x41, 0x6d, 0x68,
+    0x65, 0x72, 0x73, 0x74, 0x00, 0x41, 0x6c, 0x6c, 0x69, 0x73, 0x6f, 0x6e,
+    0x00, 0x41, 0x6c, 0x6c, 0x65, 0x6e, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x41,
+    0x63, 0x6d, 0x65, 0x00, 0x57, 0x6f, 0x6f, 0x64, 0x62, 0x69, 0x6e, 0x65,
+    0x00, 0x57, 0x6f, 0x6c, 0x66, 0x20, 0x43, 0x72, 0x65, 0x65, 0x6b, 0x00,
+    0x57, 0x69, 0x6c, 0x6c, 0x69, 0x61, 0x6d, 0x73, 0x76, 0x69, 0x6c, 0x6c,
+    0x65, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65, 0x20, 0x50, 0x6c, 0x61, 0x69,
+    0x6e, 0x73, 0x00, 0x57, 0x65, 0x73, 0x6c, 0x65, 0x79, 0x00, 0x57, 0x65,
+    0x6c, 0x64, 0x6f, 0x6e, 0x00, 0x57, 0x61, 0x79, 0x6c, 0x61, 0x6e, 0x64,
+    0x00, 0x54, 0x79, 0x72, 0x6f, 0x6e, 0x65, 0x00, 0x54, 0x72, 0x65, 0x6d,
+    0x6f, 0x6e, 0x74, 0x00, 0x54, 0x72, 0x61, 0x63, 0x79, 0x00, 0x54, 0x69,
+    0x70, 0x74, 0x6f, 0x6e, 0x00, 0x54, 0x68, 0x6f, 0x6d, 0x70, 0x73, 0x6f,
+    0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x54, 0x61, 0x6e, 0x67, 0x6c,
+    0x65, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x54, 0x61, 0x62, 0x6f, 0x72, 0x00,
+    0x53, 0x75, 0x74, 0x74, 0x6f, 0x6e, 0x00, 0x53, 0x75, 0x70, 0x65, 0x72,
+    0x69, 0x6f, 0x72, 0x00, 0x53, 0x74, 0x61, 0x72, 0x00, 0x53, 0x74, 0x61,
+    0x66, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x53, 0x6c, 0x65, 0x65, 0x70, 0x79,
+    0x20, 0x48, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x00, 0x53, 0x69, 0x6c, 0x6f,
+    0x61, 0x6d, 0x00, 0x53, 0x68, 0x65, 0x6c, 0x62, 0x79, 0x00, 0x53, 0x68,
+    0x61, 0x77, 0x00, 0x53, 0x61, 0x77, 0x79, 0x65, 0x72, 0x00, 0x53, 0x61,
+    0x69, 0x6e, 0x74, 0x20, 0x4a, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x53, 0x61,
+    0x69, 0x6e, 0x74, 0x20, 0x43, 0x6c, 0x61, 0x69, 0x72, 0x00, 0x52, 0x65,
+    0x64, 0x20, 0x42, 0x61, 0x6e, 0x6b, 0x00, 0x52, 0x61, 0x6e, 0x6b, 0x69,
+    0x6e, 0x00, 0x50, 0x72, 0x69, 0x63, 0x65, 0x00, 0x50, 0x65, 0x72, 0x75,
+    0x00, 0x50, 0x61, 0x67, 0x65, 0x00, 0x4f, 0x77, 0x65, 0x6e, 0x73, 0x00,
+    0x4f, 0x6e, 0x65, 0x69, 0x64, 0x61, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x77, 0x6f, 0x6f, 0x64, 0x00, 0x4e, 0x69, 0x63, 0x68, 0x6f, 0x6c, 0x73,
+    0x00, 0x4e, 0x65, 0x77, 0x20, 0x54, 0x6f, 0x77, 0x6e, 0x00, 0x4d, 0x75,
+    0x72, 0x70, 0x68, 0x79, 0x00, 0x4d, 0x6f, 0x72, 0x72, 0x69, 0x73, 0x00,
+    0x4d, 0x6f, 0x72, 0x67, 0x61, 0x6e, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x4d,
+    0x6f, 0x6e, 0x74, 0x70, 0x65, 0x6c, 0x69, 0x65, 0x72, 0x00, 0x4d, 0x65,
+    0x63, 0x68, 0x61, 0x6e, 0x69, 0x63, 0x73, 0x62, 0x75, 0x72, 0x67, 0x00,
+    0x4c, 0x75, 0x63, 0x61, 0x73, 0x00, 0x4c, 0x6f, 0x6e, 0x65, 0x20, 0x50,
+    0x69, 0x6e, 0x65, 0x00, 0x4c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x74, 0x6f,
+    0x6e, 0x00, 0x4c, 0x69, 0x74, 0x74, 0x6c, 0x65, 0x20, 0x52, 0x69, 0x76,
+    0x65, 0x72, 0x00, 0x4c, 0x65, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x4c, 0x61,
+    0x6e, 0x67, 0x64, 0x6f, 0x6e, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x00, 0x4c, 0x61, 0x6b, 0x65, 0x20, 0x46, 0x6f, 0x72,
+    0x65, 0x73, 0x74, 0x00, 0x4c, 0x61, 0x20, 0x47, 0x72, 0x61, 0x6e, 0x67,
+    0x65, 0x00, 0x4b, 0x69, 0x6e, 0x67, 0x00, 0x4b, 0x69, 0x6d, 0x62, 0x61,
+    0x6c, 0x6c, 0x00, 0x4a, 0x6f, 0x68, 0x6e, 0x73, 0x6f, 0x6e, 0x76, 0x69,
+    0x6c, 0x6c, 0x65, 0x00, 0x48, 0x69, 0x67, 0x68, 0x6c, 0x61, 0x6e, 0x64,
+    0x20, 0x50, 0x61, 0x72, 0x6b, 0x00, 0x48, 0x61, 0x7a, 0x65, 0x6c, 0x77,
+    0x6f, 0x6f, 0x64, 0x00, 0x48, 0x61, 0x72, 0x74, 0x6c, 0x61, 0x6e, 0x64,
+    0x00, 0x48, 0x61, 0x72, 0x64, 0x79, 0x00, 0x47, 0x75, 0x74, 0x68, 0x72,
+    0x69, 0x65, 0x00, 0x47, 0x72, 0x69, 0x66, 0x66, 0x69, 0x6e, 0x00, 0x47,
+    0x72, 0x61, 0x76, 0x65, 0x6c, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x47,
+    0x6f, 0x6c, 0x64, 0x65, 0x6e, 0x00, 0x47, 0x6c, 0x6f, 0x62, 0x65, 0x00,
+    0x47, 0x61, 0x72, 0x79, 0x00, 0x46, 0x72, 0x6f, 0x67, 0x74, 0x6f, 0x77,
+    0x6e, 0x00, 0x46, 0x6f, 0x75, 0x72, 0x20, 0x50, 0x6f, 0x69, 0x6e, 0x74,
+    0x73, 0x00, 0x46, 0x6f, 0x72, 0x65, 0x73, 0x74, 0x00, 0x46, 0x6c, 0x69,
+    0x6e, 0x74, 0x00, 0x46, 0x65, 0x72, 0x67, 0x75, 0x73, 0x6f, 0x6e, 0x00,
+    0x46, 0x61, 0x79, 0x65, 0x74, 0x74, 0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65,
+    0x00, 0x46, 0x61, 0x72, 0x6d, 0x65, 0x72, 0x73, 0x76, 0x69, 0x6c, 0x6c,
+    0x65, 0x00, 0x45, 0x6c, 0x6c, 0x69, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65,
+    0x00, 0x45, 0x64, 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x45, 0x64, 0x67,
+    0x65, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x44, 0x6f, 0x79, 0x6c, 0x65, 0x00,
+    0x44, 0x65, 0x6c, 0x6d, 0x61, 0x72, 0x00, 0x44, 0x61, 0x6c, 0x6c, 0x61,
+    0x73, 0x00, 0x43, 0x72, 0x79, 0x73, 0x74, 0x61, 0x6c, 0x00, 0x43, 0x6f,
+    0x6c, 0x6c, 0x69, 0x6e, 0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x43,
+    0x6c, 0x69, 0x66, 0x66, 0x6f, 0x72, 0x64, 0x00, 0x43, 0x68, 0x75, 0x72,
+    0x63, 0x68, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x00, 0x43, 0x68, 0x65, 0x72,
+    0x72, 0x79, 0x20, 0x56, 0x61, 0x6c, 0x6c, 0x65, 0x79, 0x00, 0x43, 0x65,
+    0x64, 0x61, 0x72, 0x00, 0x42, 0x72, 0x6f, 0x6f, 0x6b, 0x77, 0x6f, 0x6f,
+    0x64, 0x00, 0x42, 0x6c, 0x61, 0x6e, 0x63, 0x68, 0x61, 0x72, 0x64, 0x00,
+    0x42, 0x65, 0x72, 0x65, 0x61, 0x00, 0x42, 0x65, 0x6c, 0x6c, 0x65, 0x76,
+    0x69, 0x65, 0x77, 0x00, 0x42, 0x65, 0x6c, 0x66, 0x61, 0x73, 0x74, 0x00,
+    0x42, 0x61, 0x79, 0x73, 0x69, 0x64, 0x65, 0x00, 0x42, 0x61, 0x74, 0x68,
+    0x00, 0x41, 0x76, 0x65, 0x72, 0x79, 0x00, 0x41, 0x73, 0x68, 0x6c, 0x65,
+    0x79, 0x00, 0x41, 0x6d, 0x69, 0x74, 0x79, 0x00, 0x41, 0x6c, 0x74, 0x61,
+    0x6d, 0x6f, 0x6e, 0x74, 0x00, 0x41, 0x64, 0x72, 0x69, 0x61, 0x6e, 0x00,
+    0x59, 0x6f, 0x75, 0x6e, 0x67, 0x73, 0x74, 0x6f, 0x77, 0x6e, 0x00, 0x57,
+    0x6f, 0x6f, 0x64, 0x72, 0x75, 0x66, 0x66, 0x00, 0x57, 0x6f, 0x6f, 0x64,
+    0x63, 0x72, 0x65, 0x73, 0x74, 0x00, 0x57, 0x69, 0x6c, 0x6c, 0x6f, 0x77,
+    0x00, 0x57, 0x69, 0x6c, 0x6c, 0x69, 0x73, 0x00, 0x57, 0x69, 0x6c, 0x64,
+    0x77, 0x6f, 0x6f, 0x64, 0x00, 0x57, 0x68, 0x69, 0x74, 0x65, 0x73, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x57, 0x65, 0x73, 0x74, 0x6d, 0x69, 0x6e,
+    0x73, 0x74, 0x65, 0x72, 0x00, 0x57, 0x65, 0x73, 0x74, 0x67, 0x61, 0x74,
+    0x65, 0x00, 0x57, 0x65, 0x73, 0x74, 0x20, 0x4c, 0x69, 0x62, 0x65, 0x72,
+    0x74, 0x79, 0x00, 0x56, 0x69, 0x73, 0x74, 0x61, 0x00, 0x56, 0x61, 0x6e,
+    0x63, 0x65, 0x00, 0x54, 0x68, 0x65, 0x20, 0x4d, 0x65, 0x61, 0x64, 0x6f,
+    0x77, 0x73, 0x00, 0x54, 0x61, 0x66, 0x74, 0x00, 0x53, 0x70, 0x72, 0x69,
+    0x6e, 0x67, 0x68, 0x69, 0x6c, 0x6c, 0x00, 0x53, 0x6f, 0x6d, 0x65, 0x72,
+    0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x53, 0x6e, 0x75, 0x67, 0x20, 0x48,
+    0x61, 0x72, 0x62, 0x6f, 0x72, 0x00, 0x53, 0x6d, 0x69, 0x74, 0x68, 0x00,
+    0x53, 0x69, 0x6c, 0x76, 0x65, 0x72, 0x20, 0x43, 0x72, 0x65, 0x65, 0x6b,
+    0x00, 0x53, 0x68, 0x6f, 0x72, 0x65, 0x20, 0x41, 0x63, 0x72, 0x65, 0x73,
+    0x00, 0x52, 0x75, 0x74, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x52, 0x6f, 0x73,
+    0x73, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x52, 0x6f, 0x6c, 0x6c, 0x69,
+    0x6e, 0x67, 0x20, 0x48, 0x69, 0x6c, 0x6c, 0x73, 0x00, 0x52, 0x69, 0x76,
+    0x65, 0x72, 0x20, 0x4f, 0x61, 0x6b, 0x73, 0x00, 0x52, 0x69, 0x64, 0x67,
+    0x65, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x52, 0x69, 0x63, 0x68, 0x76,
+    0x69, 0x6c, 0x6c, 0x65, 0x00, 0x52, 0x69, 0x63, 0x65, 0x76, 0x69, 0x6c,
+    0x6c, 0x65, 0x00, 0x52, 0x65, 0x6e, 0x6f, 0x00, 0x52, 0x65, 0x64, 0x6c,
+    0x61, 0x6e, 0x64, 0x00, 0x50, 0x72, 0x6f, 0x73, 0x70, 0x65, 0x72, 0x69,
+    0x74, 0x79, 0x00, 0x50, 0x6f, 0x73, 0x74, 0x20, 0x4f, 0x61, 0x6b, 0x00,
+    0x50, 0x6c, 0x61, 0x69, 0x6e, 0x76, 0x69, 0x6c, 0x6c, 0x65, 0x00, 0x50,
+    0x69, 0x6e, 0x68, 0x6f, 0x6f, 0x6b, 0x00, 0x50, 0x68, 0x6f, 0x65, 0x6e,
+    0x69, 0x78, 0x00, 0x50, 0x61, 0x79, 0x6e, 0x65, 0x00, 0x50, 0x61, 0x72,
+    0x6b, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
+    0x00, 0x3e, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00,
+    0x00, 0x7d, 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00,
+    0x00, 0xb7, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00,
+    0x00, 0x2d, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x57, 0x00, 0x00,
+    0x00, 0x6d, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00,
+    0x00, 0xaa, 0x00, 0x00, 0x00, 0xc3, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+    0x00, 0x22, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00,
+    0x00, 0x63, 0x00, 0x00, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x8d, 0x00, 0x00,
+    0x00, 0xa2, 0x00, 0x00, 0x00, 0xb5, 0x00, 0x00, 0x00, 0xd4, 0x57, 0x6f,
+    0x6d, 0x65, 0x6e, 0x00, 0x77, 0x6f, 0x6d, 0x65, 0x6e, 0x5f, 0x63, 0x6c,
+    0x61, 0x73, 0x73, 0x00, 0x31, 0x00, 0x4d, 0x65, 0x6e, 0x00, 0x6d, 0x65,
+    0x6e, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x31, 0x00, 0x43, 0x68,
+    0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x00, 0x63, 0x68, 0x69, 0x6c, 0x64,
+    0x72, 0x65, 0x6e, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x31, 0x00,
+    0x53, 0x68, 0x6f, 0x65, 0x73, 0x00, 0x73, 0x68, 0x6f, 0x65, 0x5f, 0x63,
+    0x6c, 0x61, 0x73, 0x73, 0x00, 0x31, 0x00, 0x4d, 0x75, 0x73, 0x69, 0x63,
+    0x00, 0x6d, 0x75, 0x73, 0x69, 0x63, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73,
+    0x00, 0x30, 0x00, 0x4a, 0x65, 0x77, 0x65, 0x6c, 0x72, 0x79, 0x00, 0x6a,
+    0x65, 0x77, 0x65, 0x6c, 0x72, 0x79, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73,
+    0x00, 0x30, 0x00, 0x48, 0x6f, 0x6d, 0x65, 0x00, 0x68, 0x6f, 0x6d, 0x65,
+    0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x30, 0x00, 0x53, 0x70, 0x6f,
+    0x72, 0x74, 0x73, 0x00, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x63, 0x6c,
+    0x61, 0x73, 0x73, 0x00, 0x30, 0x00, 0x42, 0x6f, 0x6f, 0x6b, 0x73, 0x00,
+    0x62, 0x6f, 0x6f, 0x6b, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x30,
+    0x00, 0x45, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x73,
+    0x00, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x5f,
+    0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x23,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x2c, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x00,
+    0x32, 0x00, 0x66, 0x72, 0x61, 0x67, 0x72, 0x61, 0x6e, 0x63, 0x65, 0x73,
+    0x00, 0x32, 0x00, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x6e, 0x69, 0x74, 0x79,
+    0x00, 0x32, 0x00, 0x73, 0x77, 0x69, 0x6d, 0x77, 0x65, 0x61, 0x72, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
+    0x00, 0x17, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
+    0x00, 0x15, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x2e, 0x61, 0x63,
+    0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x00, 0x32, 0x00,
+    0x73, 0x68, 0x69, 0x72, 0x74, 0x73, 0x00, 0x32, 0x00, 0x70, 0x61, 0x6e,
+    0x74, 0x73, 0x00, 0x32, 0x00, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2d,
+    0x61, 0x70, 0x70, 0x61, 0x72, 0x65, 0x6c, 0x00, 0x32, 0x00, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00,
+    0x00, 0x1f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+    0x00, 0x1d, 0x00, 0x00, 0x00, 0x2f, 0x6e, 0x65, 0x77, 0x62, 0x6f, 0x72,
+    0x6e, 0x00, 0x32, 0x00, 0x69, 0x6e, 0x66, 0x61, 0x6e, 0x74, 0x73, 0x00,
+    0x32, 0x00, 0x74, 0x6f, 0x64, 0x64, 0x6c, 0x65, 0x72, 0x73, 0x00, 0x32,
+    0x00, 0x73, 0x63, 0x68, 0x6f, 0x6f, 0x6c, 0x2d, 0x75, 0x6e, 0x69, 0x66,
+    0x6f, 0x72, 0x6d, 0x73, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x17, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x15, 0x00,
+    0x00, 0x00, 0x20, 0x77, 0x6f, 0x6d, 0x65, 0x6e, 0x73, 0x00, 0x32, 0x00,
+    0x6d, 0x65, 0x6e, 0x73, 0x00, 0x32, 0x00, 0x6b, 0x69, 0x64, 0x73, 0x00,
+    0x32, 0x00, 0x61, 0x74, 0x68, 0x6c, 0x65, 0x74, 0x69, 0x63, 0x00, 0x32,
+    0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x21, 0x72, 0x6f, 0x63,
+    0x6b, 0x00, 0x32, 0x00, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x00,
+    0x32, 0x00, 0x70, 0x6f, 0x70, 0x00, 0x32, 0x00, 0x63, 0x6c, 0x61, 0x73,
+    0x73, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x1b,
+    0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x39,
+    0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x60,
+    0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x8a,
+    0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0xa2, 0x00, 0x00, 0x00, 0xab,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x37,
+    0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x5e,
+    0x00, 0x00, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x88,
+    0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0xa9,
+    0x00, 0x00, 0x00, 0xb7, 0x62, 0x69, 0x72, 0x64, 0x61, 0x6c, 0x00, 0x38,
+    0x00, 0x64, 0x69, 0x61, 0x6d, 0x6f, 0x6e, 0x64, 0x73, 0x00, 0x38, 0x00,
+    0x67, 0x6f, 0x6c, 0x64, 0x00, 0x38, 0x00, 0x62, 0x72, 0x61, 0x63, 0x65,
+    0x6c, 0x65, 0x74, 0x73, 0x00, 0x38, 0x00, 0x65, 0x61, 0x72, 0x69, 0x6e,
+    0x67, 0x73, 0x00, 0x38, 0x00, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x38,
+    0x00, 0x70, 0x65, 0x6e, 0x64, 0x61, 0x6e, 0x74, 0x73, 0x00, 0x38, 0x00,
+    0x6d, 0x65, 0x6e, 0x73, 0x20, 0x77, 0x61, 0x74, 0x63, 0x68, 0x00, 0x38,
+    0x00, 0x77, 0x6f, 0x6d, 0x65, 0x6e, 0x73, 0x20, 0x77, 0x61, 0x74, 0x63,
+    0x68, 0x00, 0x38, 0x00, 0x6a, 0x65, 0x77, 0x65, 0x6c, 0x72, 0x79, 0x20,
+    0x62, 0x6f, 0x78, 0x65, 0x73, 0x00, 0x38, 0x00, 0x73, 0x65, 0x6d, 0x69,
+    0x2d, 0x70, 0x72, 0x65, 0x63, 0x69, 0x6f, 0x75, 0x73, 0x00, 0x38, 0x00,
+    0x63, 0x6f, 0x73, 0x74, 0x75, 0x6d, 0x65, 0x00, 0x38, 0x00, 0x6c, 0x6f,
+    0x6f, 0x73, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x6e, 0x65, 0x73, 0x00, 0x38,
+    0x00, 0x65, 0x73, 0x74, 0x61, 0x74, 0x65, 0x00, 0x38, 0x00, 0x63, 0x75,
+    0x73, 0x74, 0x6f, 0x6d, 0x00, 0x38, 0x00, 0x63, 0x6f, 0x6e, 0x73, 0x69,
+    0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00,
+    0x4b, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00,
+    0x6e, 0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00,
+    0x8d, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00,
+    0xb1, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
+    0x48, 0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00,
+    0x6b, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00,
+    0x8a, 0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00,
+    0xae, 0x00, 0x00, 0x00, 0xbb, 0x62, 0x61, 0x74, 0x68, 0x72, 0x6f, 0x6f,
+    0x6d, 0x00, 0x31, 0x30, 0x00, 0x62, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67,
+    0x00, 0x31, 0x30, 0x00, 0x6b, 0x69, 0x64, 0x73, 0x00, 0x31, 0x30, 0x00,
+    0x63, 0x75, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x2f, 0x64, 0x72, 0x61,
+    0x70, 0x65, 0x73, 0x00, 0x31, 0x30, 0x00, 0x62, 0x6c, 0x69, 0x6e, 0x64,
+    0x73, 0x2f, 0x73, 0x68, 0x61, 0x64, 0x65, 0x73, 0x00, 0x31, 0x30, 0x00,
+    0x72, 0x75, 0x67, 0x73, 0x00, 0x31, 0x30, 0x00, 0x64, 0x65, 0x63, 0x6f,
+    0x72, 0x00, 0x31, 0x30, 0x00, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x69, 0x6e,
+    0x67, 0x00, 0x31, 0x30, 0x00, 0x6d, 0x61, 0x74, 0x74, 0x72, 0x65, 0x73,
+    0x73, 0x65, 0x73, 0x00, 0x31, 0x30, 0x00, 0x66, 0x6c, 0x61, 0x74, 0x77,
+    0x61, 0x72, 0x65, 0x00, 0x31, 0x30, 0x00, 0x61, 0x63, 0x63, 0x65, 0x6e,
+    0x74, 0x00, 0x31, 0x30, 0x00, 0x70, 0x61, 0x69, 0x6e, 0x74, 0x00, 0x31,
+    0x30, 0x00, 0x77, 0x61, 0x6c, 0x6c, 0x70, 0x61, 0x70, 0x65, 0x72, 0x00,
+    0x31, 0x30, 0x00, 0x67, 0x6c, 0x61, 0x73, 0x73, 0x77, 0x61, 0x72, 0x65,
+    0x00, 0x31, 0x30, 0x00, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x00, 0x31,
+    0x30, 0x00, 0x66, 0x75, 0x72, 0x6e, 0x69, 0x74, 0x75, 0x72, 0x65, 0x00,
+    0x31, 0x30, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x37, 0x00,
+    0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x00, 0x58, 0x00,
+    0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x76, 0x00,
+    0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0x94, 0x00,
+    0x00, 0x00, 0x9e, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0x0f, 0x00,
+    0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x34, 0x00,
+    0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00, 0x55, 0x00,
+    0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00, 0x73, 0x00,
+    0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x86, 0x00, 0x00, 0x00, 0x91, 0x00,
+    0x00, 0x00, 0x9b, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0xae, 0x61,
+    0x74, 0x68, 0x6c, 0x65, 0x74, 0x69, 0x63, 0x20, 0x73, 0x68, 0x6f, 0x65,
+    0x73, 0x00, 0x31, 0x30, 0x00, 0x62, 0x61, 0x73, 0x65, 0x62, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x30, 0x00, 0x62, 0x61, 0x73, 0x6b, 0x65, 0x74, 0x62,
+    0x61, 0x6c, 0x6c, 0x00, 0x31, 0x30, 0x00, 0x63, 0x61, 0x6d, 0x70, 0x69,
+    0x6e, 0x67, 0x00, 0x31, 0x30, 0x00, 0x66, 0x69, 0x74, 0x6e, 0x65, 0x73,
+    0x73, 0x00, 0x31, 0x30, 0x00, 0x66, 0x6f, 0x6f, 0x74, 0x62, 0x61, 0x6c,
+    0x6c, 0x00, 0x31, 0x30, 0x00, 0x68, 0x6f, 0x63, 0x6b, 0x65, 0x79, 0x00,
+    0x31, 0x30, 0x00, 0x6f, 0x75, 0x74, 0x64, 0x6f, 0x6f, 0x72, 0x00, 0x31,
+    0x30, 0x00, 0x6f, 0x70, 0x74, 0x69, 0x63, 0x73, 0x00, 0x31, 0x30, 0x00,
+    0x70, 0x6f, 0x6f, 0x6c, 0x73, 0x00, 0x31, 0x30, 0x00, 0x61, 0x72, 0x63,
+    0x68, 0x65, 0x72, 0x79, 0x00, 0x31, 0x30, 0x00, 0x67, 0x75, 0x6e, 0x73,
+    0x00, 0x31, 0x30, 0x00, 0x73, 0x61, 0x69, 0x6c, 0x69, 0x6e, 0x67, 0x00,
+    0x31, 0x30, 0x00, 0x74, 0x65, 0x6e, 0x6e, 0x69, 0x73, 0x00, 0x31, 0x30,
+    0x00, 0x66, 0x69, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x00, 0x31, 0x30, 0x00,
+    0x67, 0x6f, 0x6c, 0x66, 0x00, 0x31, 0x30, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x21,
+    0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x4b,
+    0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x63, 0x00, 0x00, 0x00, 0x6e,
+    0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x92,
+    0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x00, 0xb4,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x6b,
+    0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x8f,
+    0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0xb1,
+    0x00, 0x00, 0x00, 0xbc, 0x61, 0x72, 0x74, 0x73, 0x00, 0x31, 0x32, 0x00,
+    0x62, 0x75, 0x73, 0x69, 0x6e, 0x65, 0x73, 0x73, 0x00, 0x31, 0x32, 0x00,
+    0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x72, 0x73, 0x00, 0x31, 0x32,
+    0x00, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x6d, 0x65,
+    0x6e, 0x74, 0x73, 0x00, 0x31, 0x32, 0x00, 0x68, 0x69, 0x73, 0x74, 0x6f,
+    0x72, 0x79, 0x00, 0x31, 0x32, 0x00, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74,
+    0x69, 0x6e, 0x67, 0x00, 0x31, 0x32, 0x00, 0x72, 0x65, 0x66, 0x65, 0x72,
+    0x65, 0x6e, 0x63, 0x65, 0x00, 0x31, 0x32, 0x00, 0x72, 0x6f, 0x6d, 0x61,
+    0x6e, 0x63, 0x65, 0x00, 0x31, 0x32, 0x00, 0x73, 0x63, 0x69, 0x65, 0x6e,
+    0x63, 0x65, 0x00, 0x31, 0x32, 0x00, 0x74, 0x72, 0x61, 0x76, 0x65, 0x6c,
+    0x00, 0x31, 0x32, 0x00, 0x63, 0x6f, 0x6f, 0x6b, 0x69, 0x6e, 0x67, 0x00,
+    0x31, 0x32, 0x00, 0x68, 0x6f, 0x6d, 0x65, 0x20, 0x72, 0x65, 0x70, 0x61,
+    0x69, 0x72, 0x00, 0x31, 0x32, 0x00, 0x73, 0x65, 0x6c, 0x66, 0x2d, 0x68,
+    0x65, 0x6c, 0x70, 0x00, 0x31, 0x32, 0x00, 0x73, 0x70, 0x6f, 0x72, 0x74,
+    0x73, 0x00, 0x31, 0x32, 0x00, 0x66, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+    0x00, 0x31, 0x32, 0x00, 0x6d, 0x79, 0x73, 0x74, 0x65, 0x72, 0x79, 0x00,
+    0x31, 0x32, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x35, 0x00,
+    0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x56, 0x00,
+    0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x71, 0x00, 0x00, 0x00, 0x7b, 0x00,
+    0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00, 0xa0, 0x00,
+    0x00, 0x00, 0xae, 0x00, 0x00, 0x00, 0xba, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x32, 0x00,
+    0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x53, 0x00,
+    0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x6e, 0x00, 0x00, 0x00, 0x78, 0x00,
+    0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x93, 0x00, 0x00, 0x00, 0x9d, 0x00,
+    0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00, 0xc3, 0x63,
+    0x61, 0x6d, 0x65, 0x72, 0x61, 0x73, 0x00, 0x31, 0x37, 0x00, 0x63, 0x61,
+    0x6d, 0x63, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x73, 0x00, 0x31, 0x37, 0x00,
+    0x64, 0x76, 0x64, 0x2f, 0x76, 0x63, 0x72, 0x20, 0x70, 0x6c, 0x61, 0x79,
+    0x65, 0x72, 0x73, 0x00, 0x31, 0x37, 0x00, 0x61, 0x75, 0x64, 0x69, 0x6f,
+    0x00, 0x31, 0x37, 0x00, 0x6b, 0x61, 0x72, 0x6f, 0x6b, 0x65, 0x00, 0x31,
+    0x37, 0x00, 0x6d, 0x75, 0x73, 0x69, 0x63, 0x61, 0x6c, 0x00, 0x31, 0x37,
+    0x00, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x6c, 0x00, 0x31, 0x37,
+    0x00, 0x73, 0x63, 0x61, 0x6e, 0x6e, 0x65, 0x72, 0x73, 0x00, 0x31, 0x37,
+    0x00, 0x74, 0x65, 0x6c, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x31, 0x37, 0x00, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x00, 0x31,
+    0x37, 0x00, 0x64, 0x69, 0x73, 0x6b, 0x20, 0x64, 0x72, 0x69, 0x76, 0x65,
+    0x73, 0x00, 0x31, 0x37, 0x00, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72,
+    0x73, 0x00, 0x31, 0x37, 0x00, 0x73, 0x74, 0x65, 0x72, 0x65, 0x6f, 0x00,
+    0x31, 0x37, 0x00, 0x61, 0x75, 0x74, 0x6f, 0x6d, 0x6f, 0x74, 0x69, 0x76,
+    0x65, 0x00, 0x31, 0x37, 0x00, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c,
+    0x65, 0x00, 0x31, 0x37, 0x00, 0x77, 0x69, 0x72, 0x65, 0x6c, 0x65, 0x73,
+    0x73, 0x00, 0x31, 0x37, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x2e, 0x70, 0x65, 0x74, 0x69, 0x74, 0x65, 0x00, 0x73, 0x6d, 0x61, 0x6c,
+    0x6c, 0x00, 0x6d, 0x65, 0x64, 0x69, 0x75, 0x6d, 0x00, 0x6c, 0x61, 0x72,
+    0x67, 0x65, 0x00, 0x65, 0x78, 0x74, 0x72, 0x61, 0x20, 0x6c, 0x61, 0x72,
+    0x67, 0x65, 0x00, 0x65, 0x63, 0x6f, 0x6e, 0x6f, 0x6d, 0x79, 0x00, 0x4e,
+    0x2f, 0x41, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x01, 0x90, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00,
+    0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x13, 0x00,
+    0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x25, 0x00,
+    0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x36, 0x00,
+    0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x43, 0x00,
+    0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x53, 0x00,
+    0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x5f, 0x00,
+    0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x69, 0x55, 0x6e, 0x6b, 0x6e, 0x6f,
+    0x77, 0x6e, 0x00, 0x45, 0x61, 0x63, 0x68, 0x00, 0x44, 0x6f, 0x7a, 0x65,
+    0x6e, 0x00, 0x43, 0x61, 0x73, 0x65, 0x00, 0x50, 0x61, 0x6c, 0x6c, 0x65,
+    0x74, 0x00, 0x47, 0x72, 0x6f, 0x73, 0x73, 0x00, 0x43, 0x61, 0x72, 0x74,
+    0x6f, 0x6e, 0x00, 0x42, 0x6f, 0x78, 0x00, 0x42, 0x75, 0x6e, 0x63, 0x68,
+    0x00, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x00, 0x4f, 0x7a, 0x00, 0x4c,
+    0x62, 0x00, 0x54, 0x6f, 0x6e, 0x00, 0x4f, 0x75, 0x6e, 0x63, 0x65, 0x00,
+    0x50, 0x6f, 0x75, 0x6e, 0x64, 0x00, 0x54, 0x73, 0x70, 0x00, 0x54, 0x62,
+    0x6c, 0x00, 0x43, 0x75, 0x70, 0x00, 0x44, 0x72, 0x61, 0x6d, 0x00, 0x47,
+    0x72, 0x61, 0x6d, 0x00, 0x4e, 0x2f, 0x41, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x55, 0x6e, 0x6b, 0x6e,
+    0x6f, 0x77, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0f,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x26,
+    0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x3c,
+    0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x4d,
+    0x00, 0x00, 0x00, 0x57, 0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x00, 0x6c,
+    0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x84,
+    0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x9e,
+    0x00, 0x00, 0x00, 0xa3, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0xad,
+    0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0xbd,
+    0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0xce, 0x00, 0x00, 0x00, 0xd5,
+    0x00, 0x00, 0x00, 0xdd, 0x00, 0x00, 0x00, 0xe7, 0x00, 0x00, 0x00, 0xed,
+    0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x01, 0x02,
+    0x00, 0x00, 0x01, 0x0b, 0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x01, 0x16,
+    0x00, 0x00, 0x01, 0x1c, 0x00, 0x00, 0x01, 0x22, 0x00, 0x00, 0x01, 0x27,
+    0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x01, 0x35, 0x00, 0x00, 0x01, 0x3b,
+    0x00, 0x00, 0x01, 0x41, 0x00, 0x00, 0x01, 0x46, 0x00, 0x00, 0x01, 0x4c,
+    0x00, 0x00, 0x01, 0x54, 0x00, 0x00, 0x01, 0x5b, 0x00, 0x00, 0x01, 0x62,
+    0x00, 0x00, 0x01, 0x6b, 0x00, 0x00, 0x01, 0x74, 0x00, 0x00, 0x01, 0x79,
+    0x00, 0x00, 0x01, 0x7f, 0x00, 0x00, 0x01, 0x88, 0x00, 0x00, 0x01, 0x8f,
+    0x00, 0x00, 0x01, 0x94, 0x00, 0x00, 0x01, 0x9a, 0x00, 0x00, 0x01, 0xa1,
+    0x00, 0x00, 0x01, 0xa8, 0x00, 0x00, 0x01, 0xad, 0x00, 0x00, 0x01, 0xb4,
+    0x00, 0x00, 0x01, 0xba, 0x00, 0x00, 0x01, 0xbf, 0x00, 0x00, 0x01, 0xc4,
+    0x00, 0x00, 0x01, 0xc9, 0x00, 0x00, 0x01, 0xd0, 0x00, 0x00, 0x01, 0xd5,
+    0x00, 0x00, 0x01, 0xdc, 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x01, 0xe5,
+    0x00, 0x00, 0x01, 0xea, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x01, 0xf7,
+    0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x02, 0x0d,
+    0x00, 0x00, 0x02, 0x14, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x02, 0x1e,
+    0x00, 0x00, 0x02, 0x24, 0x00, 0x00, 0x02, 0x29, 0x00, 0x00, 0x02, 0x30,
+    0x00, 0x00, 0x02, 0x36, 0x00, 0x00, 0x02, 0x3a, 0x00, 0x00, 0x02, 0x42,
+    0x00, 0x00, 0x02, 0x49, 0x00, 0x00, 0x02, 0x53, 0x00, 0x00, 0x02, 0x5a,
+    0x00, 0x00, 0x02, 0x60, 0x00, 0x00, 0x02, 0x66, 0x6e, 0x61, 0x6d, 0x65,
+    0x00, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x00, 0x73, 0x6b, 0x65,
+    0x77, 0x65, 0x64, 0x00, 0x6c, 0x6f, 0x77, 0x00, 0x6d, 0x65, 0x64, 0x69,
+    0x75, 0x6d, 0x00, 0x68, 0x69, 0x67, 0x68, 0x00, 0x61, 0x6c, 0x6d, 0x6f,
+    0x6e, 0x64, 0x00, 0x61, 0x6e, 0x74, 0x69, 0x71, 0x75, 0x65, 0x00, 0x61,
+    0x71, 0x75, 0x61, 0x6d, 0x61, 0x72, 0x69, 0x6e, 0x65, 0x00, 0x61, 0x7a,
+    0x75, 0x72, 0x65, 0x00, 0x62, 0x65, 0x69, 0x67, 0x65, 0x00, 0x62, 0x69,
+    0x73, 0x71, 0x75, 0x65, 0x00, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x00, 0x62,
+    0x6c, 0x61, 0x6e, 0x63, 0x68, 0x65, 0x64, 0x00, 0x62, 0x6c, 0x75, 0x65,
+    0x00, 0x62, 0x6c, 0x75, 0x73, 0x68, 0x00, 0x62, 0x72, 0x6f, 0x77, 0x6e,
+    0x00, 0x62, 0x75, 0x72, 0x6c, 0x79, 0x77, 0x6f, 0x6f, 0x64, 0x00, 0x62,
+    0x75, 0x72, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x00, 0x63, 0x68, 0x61,
+    0x72, 0x74, 0x72, 0x65, 0x75, 0x73, 0x65, 0x00, 0x63, 0x68, 0x69, 0x66,
+    0x66, 0x6f, 0x6e, 0x00, 0x63, 0x68, 0x6f, 0x63, 0x6f, 0x6c, 0x61, 0x74,
+    0x65, 0x00, 0x63, 0x6f, 0x72, 0x61, 0x6c, 0x00, 0x63, 0x6f, 0x72, 0x6e,
+    0x66, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x00, 0x63, 0x6f, 0x72, 0x6e, 0x73,
+    0x69, 0x6c, 0x6b, 0x00, 0x63, 0x72, 0x65, 0x61, 0x6d, 0x00, 0x63, 0x79,
+    0x61, 0x6e, 0x00, 0x64, 0x61, 0x72, 0x6b, 0x00, 0x64, 0x65, 0x65, 0x70,
+    0x00, 0x64, 0x69, 0x6d, 0x00, 0x64, 0x6f, 0x64, 0x67, 0x65, 0x72, 0x00,
+    0x64, 0x72, 0x61, 0x62, 0x00, 0x66, 0x69, 0x72, 0x65, 0x62, 0x72, 0x69,
+    0x63, 0x6b, 0x00, 0x66, 0x6c, 0x6f, 0x72, 0x61, 0x6c, 0x00, 0x66, 0x6f,
+    0x72, 0x65, 0x73, 0x74, 0x00, 0x66, 0x72, 0x6f, 0x73, 0x74, 0x65, 0x64,
+    0x00, 0x67, 0x61, 0x69, 0x6e, 0x73, 0x62, 0x6f, 0x72, 0x6f, 0x00, 0x67,
+    0x68, 0x6f, 0x73, 0x74, 0x00, 0x67, 0x6f, 0x6c, 0x64, 0x65, 0x6e, 0x72,
+    0x6f, 0x64, 0x00, 0x67, 0x72, 0x65, 0x65, 0x6e, 0x00, 0x67, 0x72, 0x65,
+    0x79, 0x00, 0x68, 0x6f, 0x6e, 0x65, 0x79, 0x64, 0x65, 0x77, 0x00, 0x68,
+    0x6f, 0x74, 0x00, 0x69, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x00, 0x69, 0x76,
+    0x6f, 0x72, 0x79, 0x00, 0x6b, 0x68, 0x61, 0x6b, 0x69, 0x00, 0x6c, 0x61,
+    0x63, 0x65, 0x00, 0x6c, 0x61, 0x76, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x00,
+    0x6c, 0x61, 0x77, 0x6e, 0x00, 0x6c, 0x65, 0x6d, 0x6f, 0x6e, 0x00, 0x6c,
+    0x69, 0x67, 0x68, 0x74, 0x00, 0x6c, 0x69, 0x6d, 0x65, 0x00, 0x6c, 0x69,
+    0x6e, 0x65, 0x6e, 0x00, 0x6d, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x61, 0x00,
+    0x6d, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x00, 0x6d, 0x65, 0x64, 0x69, 0x75,
+    0x6d, 0x00, 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x6c, 0x69, 0x63, 0x00, 0x6d,
+    0x69, 0x64, 0x6e, 0x69, 0x67, 0x68, 0x74, 0x00, 0x6d, 0x69, 0x6e, 0x74,
+    0x00, 0x6d, 0x69, 0x73, 0x74, 0x79, 0x00, 0x6d, 0x6f, 0x63, 0x63, 0x61,
+    0x73, 0x69, 0x6e, 0x00, 0x6e, 0x61, 0x76, 0x61, 0x6a, 0x6f, 0x00, 0x6e,
+    0x61, 0x76, 0x79, 0x00, 0x6f, 0x6c, 0x69, 0x76, 0x65, 0x00, 0x6f, 0x72,
+    0x61, 0x6e, 0x67, 0x65, 0x00, 0x6f, 0x72, 0x63, 0x68, 0x69, 0x64, 0x00,
+    0x70, 0x61, 0x6c, 0x65, 0x00, 0x70, 0x61, 0x70, 0x61, 0x79, 0x61, 0x00,
+    0x70, 0x65, 0x61, 0x63, 0x68, 0x00, 0x70, 0x65, 0x72, 0x75, 0x00, 0x70,
+    0x69, 0x6e, 0x6b, 0x00, 0x70, 0x6c, 0x75, 0x6d, 0x00, 0x70, 0x6f, 0x77,
+    0x64, 0x65, 0x72, 0x00, 0x70, 0x75, 0x66, 0x66, 0x00, 0x70, 0x75, 0x72,
+    0x70, 0x6c, 0x65, 0x00, 0x72, 0x65, 0x64, 0x00, 0x72, 0x6f, 0x73, 0x65,
+    0x00, 0x72, 0x6f, 0x73, 0x79, 0x00, 0x72, 0x6f, 0x79, 0x61, 0x6c, 0x00,
+    0x73, 0x61, 0x64, 0x64, 0x6c, 0x65, 0x00, 0x73, 0x61, 0x6c, 0x6d, 0x6f,
+    0x6e, 0x00, 0x73, 0x61, 0x6e, 0x64, 0x79, 0x00, 0x73, 0x65, 0x61, 0x73,
+    0x68, 0x65, 0x6c, 0x6c, 0x00, 0x73, 0x69, 0x65, 0x6e, 0x6e, 0x61, 0x00,
+    0x73, 0x6b, 0x79, 0x00, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x00, 0x73, 0x6d,
+    0x6f, 0x6b, 0x65, 0x00, 0x73, 0x6e, 0x6f, 0x77, 0x00, 0x73, 0x70, 0x72,
+    0x69, 0x6e, 0x67, 0x00, 0x73, 0x74, 0x65, 0x65, 0x6c, 0x00, 0x74, 0x61,
+    0x6e, 0x00, 0x74, 0x68, 0x69, 0x73, 0x74, 0x6c, 0x65, 0x00, 0x74, 0x6f,
+    0x6d, 0x61, 0x74, 0x6f, 0x00, 0x74, 0x75, 0x72, 0x71, 0x75, 0x6f, 0x69,
+    0x73, 0x65, 0x00, 0x76, 0x69, 0x6f, 0x6c, 0x65, 0x74, 0x00, 0x77, 0x68,
+    0x65, 0x61, 0x74, 0x00, 0x77, 0x68, 0x69, 0x74, 0x65, 0x00, 0x79, 0x65,
+    0x6c, 0x6c, 0x6f, 0x77, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x0b, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0x37, 0x00, 0x00, 0x00, 0x40, 0x75, 0x6e, 0x69, 0x76, 0x00, 0x61, 0x6d,
+    0x61, 0x6c, 0x67, 0x00, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x6f, 0x00,
+    0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x00, 0x65, 0x64, 0x75, 0x20,
+    0x70, 0x61, 0x63, 0x6b, 0x00, 0x73, 0x63, 0x68, 0x6f, 0x6c, 0x61, 0x72,
+    0x00, 0x63, 0x6f, 0x72, 0x70, 0x00, 0x62, 0x72, 0x61, 0x6e, 0x64, 0x00,
+    0x6e, 0x61, 0x6d, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x00, 0x6d, 0x61, 0x78,
+    0x69, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
+    0x00, 0x18, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
+    0x00, 0x1a, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00,
+    0x00, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x00, 0x6c, 0x6f, 0x77, 0x5f,
+    0x62, 0x6f, 0x75, 0x6e, 0x64, 0x00, 0x68, 0x69, 0x67, 0x68, 0x5f, 0x62,
+    0x6f, 0x75, 0x6e, 0x64, 0x00, 0x73, 0x6b, 0x65, 0x77, 0x00, 0x68, 0x69,
+    0x67, 0x68, 0x00, 0x6d, 0x65, 0x64, 0x69, 0x75, 0x6d, 0x00, 0x6c, 0x6f,
+    0x77, 0x00, 0x31, 0x00, 0x30, 0x2e, 0x30, 0x39, 0x00, 0x34, 0x2e, 0x39,
+    0x39, 0x00, 0x32, 0x00, 0x35, 0x2e, 0x30, 0x30, 0x00, 0x39, 0x2e, 0x39,
+    0x39, 0x00, 0x33, 0x00, 0x31, 0x30, 0x2e, 0x30, 0x30, 0x00, 0x39, 0x39,
+    0x2e, 0x39, 0x39, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x1e,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x18, 0x31, 0x00, 0x31, 0x00, 0x33, 0x33, 0x33, 0x00,
+    0x32, 0x00, 0x33, 0x33, 0x34, 0x00, 0x36, 0x36, 0x36, 0x00, 0x33, 0x00,
+    0x36, 0x36, 0x37, 0x00, 0x31, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x3c, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x14, 0x31, 0x00, 0x31,
+    0x00, 0x33, 0x33, 0x00, 0x32, 0x00, 0x33, 0x34, 0x00, 0x36, 0x36, 0x00,
+    0x33, 0x00, 0x36, 0x37, 0x00, 0x31, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x2d, 0xc6, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x4b,
+    0x08, 0x00, 0x01, 0x1d, 0x59, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00,
+    0x14, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x01,
+    0x2c, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x06, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x18, 0x00, 0x01, 0x51,
+    0x80, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1e, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00,
+    0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x96, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x05, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x04, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x2e,
+    0xe0, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x01,
+    0xf4, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x4b, 0x08, 0x00, 0x01, 0x1d,
+    0x59, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x01, 0xf4, 0x00, 0x00, 0x00,
+    0x2d, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x33, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x01, 0x51, 0x80, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x64, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x02,
+    0x58, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x0a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0xd2, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x0a, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x14, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x4f, 0xb0, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x06, 0x40, 0x00, 0x00, 0x07, 0xd0, 0x00, 0x00, 0x03,
+    0xe8, 0x00, 0x00, 0x4b, 0x08, 0x00, 0x01, 0x1d, 0x59, 0x00, 0x00, 0x1c,
+    0x20, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x66, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0xc9, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x09,
+    0x60, 0x00, 0x01, 0x51, 0x80, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x03,
+    0xfc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x17, 0x70, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x0a, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x50, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x02, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x28, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0xc8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x03,
+    0xe8, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x00, 0x65, 0x90, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x12,
+    0xc0, 0x00, 0x00, 0x13, 0x88, 0x00, 0x00, 0x09, 0xc4, 0x00, 0x00, 0x4b,
+    0x08, 0x00, 0x01, 0x1d, 0x59, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00,
+    0x14, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x05,
+    0x14, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x01,
+    0x92, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x01, 0x51,
+    0x80, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x05, 0x16, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x46, 0x50, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
+    0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x01, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x32, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01,
+    0x2c, 0x00, 0x00, 0x00, 0x0d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x0d, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x04, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x78, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01,
+    0x04, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x75,
+    0x30, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x3e, 0x80, 0x00, 0x00, 0x2e,
+    0xe0, 0x00, 0x00, 0x17, 0x70, 0x00, 0x00, 0x4b, 0x08, 0x00, 0x01, 0x1d,
+    0x59, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x05, 0xdc, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x01, 0xf5, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x5d, 0xc0, 0x00, 0x01, 0x51, 0x80, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x05, 0xdc, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xea,
+    0x60, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03,
+    0xe8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x78, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00,
+    0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x03,
+    0x20, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x05, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01,
+    0x90, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x2c, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x1b, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x8c, 0xa0, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0xbb, 0x80, 0x00, 0x00, 0x75, 0x30, 0x00, 0x00, 0x3a,
+    0x98, 0x00, 0x00, 0x4b, 0x08, 0x00, 0x01, 0x1d, 0x59, 0x00, 0x00, 0x1c,
+    0x20, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0xb4, 0x00, 0x00, 0x07, 0x08, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x02, 0xa3, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x19,
+    0x40, 0x00, 0x01, 0x51, 0x80, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x07,
+    0x08, 0xff, 0xff, 0xff, 0xff, 0x00, 0x02, 0xbf, 0x20, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x05,
+    0xdc, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x0b, 0xb8, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x2c, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x0b, 0xb8, 0x00, 0x00, 0x00, 0x12, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x09, 0x60, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x04, 0xb0, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x01, 0x68, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x03,
+    0xe8, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x5a, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x9c, 0x40, 0xff, 0xff, 0xff, 0xff, 0x00, 0x02, 0x71,
+    0x00, 0x00, 0x00, 0xfd, 0xe8, 0x00, 0x00, 0x7e, 0xf4, 0x00, 0x00, 0x4b,
+    0x08, 0x00, 0x01, 0x1d, 0x59, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00,
+    0x14, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xc9, 0x00, 0x00, 0x07,
+    0xd0, 0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x02,
+    0xee, 0xff, 0xff, 0xff, 0xff, 0x00, 0x03, 0xa9, 0x80, 0x00, 0x01, 0x51,
+    0x80, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x07, 0xd1, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x09, 0x27, 0xc0, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00,
+    0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x0c, 0xb2, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x27, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x02, 0x8a, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x27,
+    0x10, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x1f, 0x40, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x0f, 0xa0, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01,
+    0x90, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00,
+    0x51, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0xb3,
+    0xb0, 0xff, 0xff, 0xff, 0xff, 0x00, 0x07, 0x53, 0x00, 0x00, 0x01, 0x38,
+    0x80, 0x00, 0x00, 0x9c, 0x40, 0x00, 0x00, 0x4b, 0x08, 0x00, 0x01, 0x1d,
+    0x59, 0x00, 0x00, 0x1c, 0x20, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0xe7, 0x00, 0x00, 0x08, 0xfc, 0x00, 0x00, 0x00,
+    0x48, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x03, 0x54, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x0a, 0xfc, 0x80, 0x00, 0x01, 0x51, 0x80, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x00, 0x08, 0xfd, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1b, 0x77,
+    0x40, 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x0f, 0xa0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x75,
+    0x30, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x03,
+    0x20, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x75, 0x30, 0x00, 0x00, 0x00,
+    0x17, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x5d,
+    0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x2e,
+    0xe0, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0xcc, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x01, 0x0e, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00,
+    0x2a, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0xc3, 0x50, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x18, 0x6a, 0x00, 0x00, 0x01, 0x86, 0xa0, 0x00, 0x00, 0xc3,
+    0x50, 0x00, 0x00, 0x4b, 0x08, 0x00, 0x01, 0x1d, 0x59, 0x00, 0x00, 0x1c,
+    0x20, 0x00, 0x00, 0x00, 0x14, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+    0xfb, 0x00, 0x00, 0x09, 0xc4, 0x00, 0x00, 0x00, 0x4b, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x03, 0xb7, 0xff, 0xff, 0xff, 0xff, 0x00, 0x24, 0x9f,
+    0x00, 0x00, 0x01, 0x51, 0x80, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x09,
+    0xc6, 0xff, 0xff, 0xff, 0xff, 0x00, 0x5b, 0x8d, 0x80, 0x00, 0x00, 0x00,
+    0x30, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x13,
+    0x88, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x86, 0xa0, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x03, 0xe8, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x01, 0x86, 0xa0, 0x00, 0x00, 0x00, 0x19, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x19, 0x00, 0x02, 0xbf, 0x20, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x09, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x9c, 0x40, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x01, 0xf4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x03,
+    0xe8, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x01,
+    0xef, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00,
+    0x83, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00,
+    0xb7, 0x00, 0x00, 0x00, 0xc7, 0x00, 0x00, 0x00, 0xd0, 0x00, 0x00, 0x00,
+    0xde, 0x00, 0x00, 0x00, 0xe9, 0x00, 0x00, 0x00, 0xf7, 0x00, 0x00, 0x01,
+    0x01, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00, 0x01, 0x25, 0x00, 0x00, 0x01,
+    0x2e, 0x00, 0x00, 0x01, 0x3c, 0x00, 0x00, 0x01, 0x49, 0x00, 0x00, 0x01,
+    0x59, 0x00, 0x00, 0x01, 0x67, 0x00, 0x00, 0x01, 0x74, 0x00, 0x00, 0x01,
+    0x86, 0x00, 0x00, 0x01, 0x92, 0x00, 0x00, 0x01, 0xa9, 0x00, 0x00, 0x01,
+    0xbb, 0x00, 0x00, 0x01, 0xc9, 0x00, 0x00, 0x01, 0xdd, 0x00, 0x00, 0x01,
+    0xf4, 0x00, 0x00, 0x02, 0x07, 0x00, 0x00, 0x02, 0x26, 0x00, 0x00, 0x02,
+    0x3c, 0x00, 0x00, 0x02, 0x4b, 0x00, 0x00, 0x02, 0x57, 0x00, 0x00, 0x02,
+    0x65, 0x00, 0x00, 0x02, 0x74, 0x00, 0x00, 0x02, 0x83, 0x00, 0x00, 0x02,
+    0x93, 0x00, 0x00, 0x02, 0x9e, 0x00, 0x00, 0x02, 0xac, 0x00, 0x00, 0x02,
+    0xbf, 0x00, 0x00, 0x02, 0xcc, 0x00, 0x00, 0x02, 0xda, 0x00, 0x00, 0x02,
+    0xea, 0x00, 0x00, 0x02, 0xf9, 0x00, 0x00, 0x03, 0x11, 0x00, 0x00, 0x03,
+    0x1e, 0x00, 0x00, 0x03, 0x2a, 0x00, 0x00, 0x03, 0x47, 0x00, 0x00, 0x03,
+    0x5b, 0x00, 0x00, 0x03, 0x6d, 0x00, 0x00, 0x03, 0x7c, 0x00, 0x00, 0x03,
+    0x8c, 0x00, 0x00, 0x03, 0x9c, 0x00, 0x00, 0x03, 0xb5, 0x00, 0x00, 0x03,
+    0xc4, 0x00, 0x00, 0x03, 0xdf, 0x00, 0x00, 0x03, 0xf1, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x04, 0x11, 0x00, 0x00, 0x04, 0x21, 0x00, 0x00, 0x04,
+    0x32, 0x00, 0x00, 0x04, 0x46, 0x00, 0x00, 0x04, 0x54, 0x00, 0x00, 0x04,
+    0x62, 0x00, 0x00, 0x04, 0x7b, 0x00, 0x00, 0x04, 0x8d, 0x00, 0x00, 0x04,
+    0xa1, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x31, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00,
+    0x65, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00,
+    0xa3, 0x00, 0x00, 0x00, 0xb3, 0x00, 0x00, 0x00, 0xc1, 0x00, 0x00, 0x00,
+    0xcc, 0x00, 0x00, 0x00, 0xda, 0x00, 0x00, 0x00, 0xe5, 0x00, 0x00, 0x00,
+    0xf3, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x01,
+    0x21, 0x00, 0x00, 0x01, 0x2a, 0x00, 0x00, 0x01, 0x38, 0x00, 0x00, 0x01,
+    0x45, 0x00, 0x00, 0x01, 0x55, 0x00, 0x00, 0x01, 0x63, 0x00, 0x00, 0x01,
+    0x70, 0x00, 0x00, 0x01, 0x82, 0x00, 0x00, 0x01, 0x8e, 0x00, 0x00, 0x01,
+    0xa5, 0x00, 0x00, 0x01, 0xb7, 0x00, 0x00, 0x01, 0xc5, 0x00, 0x00, 0x01,
+    0xd9, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x02,
+    0x22, 0x00, 0x00, 0x02, 0x38, 0x00, 0x00, 0x02, 0x47, 0x00, 0x00, 0x02,
+    0x53, 0x00, 0x00, 0x02, 0x61, 0x00, 0x00, 0x02, 0x70, 0x00, 0x00, 0x02,
+    0x7f, 0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x02, 0x9a, 0x00, 0x00, 0x02,
+    0xa8, 0x00, 0x00, 0x02, 0xbb, 0x00, 0x00, 0x02, 0xc8, 0x00, 0x00, 0x02,
+    0xd6, 0x00, 0x00, 0x02, 0xe6, 0x00, 0x00, 0x02, 0xf5, 0x00, 0x00, 0x03,
+    0x0d, 0x00, 0x00, 0x03, 0x1a, 0x00, 0x00, 0x03, 0x26, 0x00, 0x00, 0x03,
+    0x43, 0x00, 0x00, 0x03, 0x57, 0x00, 0x00, 0x03, 0x69, 0x00, 0x00, 0x03,
+    0x78, 0x00, 0x00, 0x03, 0x88, 0x00, 0x00, 0x03, 0x98, 0x00, 0x00, 0x03,
+    0xb1, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x00, 0x03, 0xdb, 0x00, 0x00, 0x03,
+    0xed, 0x00, 0x00, 0x03, 0xfc, 0x00, 0x00, 0x04, 0x0d, 0x00, 0x00, 0x04,
+    0x1d, 0x00, 0x00, 0x04, 0x2e, 0x00, 0x00, 0x04, 0x42, 0x00, 0x00, 0x04,
+    0x50, 0x00, 0x00, 0x04, 0x5e, 0x00, 0x00, 0x04, 0x77, 0x00, 0x00, 0x04,
+    0x89, 0x00, 0x00, 0x04, 0x9d, 0x00, 0x00, 0x04, 0xaf, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
+    0x45, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x67, 0x00, 0x00, 0x00,
+    0x81, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0xa5, 0x00, 0x00, 0x00,
+    0xb5, 0x00, 0x00, 0x00, 0xc4, 0x00, 0x00, 0x00, 0xce, 0x00, 0x00, 0x00,
+    0xdc, 0x00, 0x00, 0x00, 0xe7, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x00, 0x00,
+    0xff, 0x00, 0x00, 0x01, 0x12, 0x00, 0x00, 0x01, 0x23, 0x00, 0x00, 0x01,
+    0x2c, 0x00, 0x00, 0x01, 0x3a, 0x00, 0x00, 0x01, 0x47, 0x00, 0x00, 0x01,
+    0x57, 0x00, 0x00, 0x01, 0x65, 0x00, 0x00, 0x01, 0x72, 0x00, 0x00, 0x01,
+    0x84, 0x00, 0x00, 0x01, 0x90, 0x00, 0x00, 0x01, 0xa7, 0x00, 0x00, 0x01,
+    0xb9, 0x00, 0x00, 0x01, 0xc7, 0x00, 0x00, 0x01, 0xdb, 0x00, 0x00, 0x01,
+    0xf2, 0x00, 0x00, 0x02, 0x05, 0x00, 0x00, 0x02, 0x24, 0x00, 0x00, 0x02,
+    0x3a, 0x00, 0x00, 0x02, 0x49, 0x00, 0x00, 0x02, 0x55, 0x00, 0x00, 0x02,
+    0x63, 0x00, 0x00, 0x02, 0x72, 0x00, 0x00, 0x02, 0x81, 0x00, 0x00, 0x02,
+    0x91, 0x00, 0x00, 0x02, 0x9c, 0x00, 0x00, 0x02, 0xaa, 0x00, 0x00, 0x02,
+    0xbd, 0x00, 0x00, 0x02, 0xca, 0x00, 0x00, 0x02, 0xd8, 0x00, 0x00, 0x02,
+    0xe8, 0x00, 0x00, 0x02, 0xf7, 0x00, 0x00, 0x03, 0x0f, 0x00, 0x00, 0x03,
+    0x1c, 0x00, 0x00, 0x03, 0x28, 0x00, 0x00, 0x03, 0x45, 0x00, 0x00, 0x03,
+    0x59, 0x00, 0x00, 0x03, 0x6b, 0x00, 0x00, 0x03, 0x7a, 0x00, 0x00, 0x03,
+    0x8a, 0x00, 0x00, 0x03, 0x9a, 0x00, 0x00, 0x03, 0xb3, 0x00, 0x00, 0x03,
+    0xc2, 0x00, 0x00, 0x03, 0xdd, 0x00, 0x00, 0x03, 0xef, 0x00, 0x00, 0x03,
+    0xfe, 0x00, 0x00, 0x04, 0x0f, 0x00, 0x00, 0x04, 0x1f, 0x00, 0x00, 0x04,
+    0x30, 0x00, 0x00, 0x04, 0x44, 0x00, 0x00, 0x04, 0x52, 0x00, 0x00, 0x04,
+    0x60, 0x00, 0x00, 0x04, 0x79, 0x00, 0x00, 0x04, 0x8b, 0x00, 0x00, 0x04,
+    0x9f, 0x00, 0x00, 0x04, 0xb1, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x63, 0x65,
+    0x6e, 0x74, 0x65, 0x72, 0x00, 0x30, 0x00, 0x33, 0x00, 0x63, 0x61, 0x74,
+    0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x00, 0x30, 0x00,
+    0x31, 0x00, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x72, 0x65,
+    0x74, 0x75, 0x72, 0x6e, 0x73, 0x00, 0x34, 0x00, 0x32, 0x00, 0x63, 0x61,
+    0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x73, 0x61, 0x6c, 0x65, 0x73, 0x00,
+    0x34, 0x00, 0x32, 0x00, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72,
+    0x00, 0x33, 0x00, 0x33, 0x00, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65,
+    0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x00, 0x33, 0x00,
+    0x33, 0x00, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x5f, 0x64,
+    0x65, 0x6d, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x00,
+    0x32, 0x00, 0x31, 0x00, 0x64, 0x61, 0x74, 0x65, 0x00, 0x30, 0x00, 0x31,
+    0x00, 0x68, 0x6f, 0x75, 0x73, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x5f, 0x64,
+    0x65, 0x6d, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x00,
+    0x30, 0x00, 0x31, 0x00, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x65, 0x5f, 0x62,
+    0x61, 0x6e, 0x64, 0x00, 0x30, 0x00, 0x31, 0x00, 0x69, 0x6e, 0x76, 0x65,
+    0x6e, 0x74, 0x6f, 0x72, 0x79, 0x00, 0x2d, 0x31, 0x00, 0x2d, 0x31, 0x00,
+    0x69, 0x74, 0x65, 0x6d, 0x00, 0x33, 0x00, 0x33, 0x00, 0x70, 0x72, 0x6f,
+    0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x30, 0x00, 0x33, 0x00, 0x72,
+    0x65, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x30, 0x00, 0x33, 0x00, 0x73, 0x68,
+    0x69, 0x70, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x00, 0x30, 0x00, 0x31, 0x00,
+    0x73, 0x74, 0x6f, 0x72, 0x65, 0x00, 0x30, 0x00, 0x33, 0x00, 0x73, 0x74,
+    0x6f, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x00,
+    0x2d, 0x31, 0x00, 0x2d, 0x31, 0x00, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f,
+    0x73, 0x61, 0x6c, 0x65, 0x73, 0x00, 0x34, 0x00, 0x32, 0x00, 0x74, 0x69,
+    0x6d, 0x65, 0x00, 0x30, 0x00, 0x31, 0x00, 0x77, 0x61, 0x72, 0x65, 0x68,
+    0x6f, 0x75, 0x73, 0x65, 0x00, 0x30, 0x00, 0x33, 0x00, 0x77, 0x65, 0x62,
+    0x5f, 0x70, 0x61, 0x67, 0x65, 0x00, 0x30, 0x00, 0x33, 0x00, 0x77, 0x65,
+    0x62, 0x5f, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x00, 0x34, 0x00,
+    0x32, 0x00, 0x77, 0x65, 0x62, 0x5f, 0x73, 0x61, 0x6c, 0x65, 0x73, 0x00,
+    0x33, 0x00, 0x32, 0x00, 0x77, 0x65, 0x62, 0x5f, 0x73, 0x69, 0x74, 0x65,
+    0x00, 0x30, 0x00, 0x33, 0x00, 0x64, 0x62, 0x67, 0x65, 0x6e, 0x5f, 0x76,
+    0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x30, 0x00, 0x31, 0x00, 0x73,
+    0x5f, 0x62, 0x72, 0x61, 0x6e, 0x64, 0x00, 0x32, 0x00, 0x32, 0x00, 0x73,
+    0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x5f, 0x61, 0x64,
+    0x64, 0x72, 0x65, 0x73, 0x73, 0x00, 0x30, 0x00, 0x32, 0x00, 0x73, 0x5f,
+    0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x00,
+    0x30, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f,
+    0x67, 0x00, 0x30, 0x00, 0x30, 0x00, 0x73, 0x5f, 0x63, 0x61, 0x74, 0x61,
+    0x6c, 0x6f, 0x67, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x00, 0x32, 0x00,
+    0x31, 0x00, 0x73, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f,
+    0x6c, 0x69, 0x6e, 0x65, 0x69, 0x74, 0x65, 0x6d, 0x00, 0x30, 0x00, 0x31,
+    0x00, 0x73, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x70,
+    0x61, 0x67, 0x65, 0x00, 0x30, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x63, 0x61,
+    0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74,
+    0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x00, 0x32,
+    0x00, 0x32, 0x00, 0x73, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67,
+    0x5f, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x00, 0x32, 0x00, 0x32,
+    0x00, 0x73, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x79, 0x00,
+    0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00,
+    0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e,
+    0x79, 0x00, 0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x63, 0x75, 0x73, 0x74,
+    0x6f, 0x6d, 0x65, 0x72, 0x00, 0x33, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x64,
+    0x69, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x32, 0x00, 0x32, 0x00,
+    0x73, 0x5f, 0x69, 0x6e, 0x76, 0x65, 0x6e, 0x74, 0x6f, 0x72, 0x79, 0x00,
+    0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x00, 0x32,
+    0x00, 0x32, 0x00, 0x73, 0x5f, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72,
+    0x00, 0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x6d, 0x61, 0x6e, 0x75, 0x66,
+    0x61, 0x63, 0x74, 0x75, 0x72, 0x65, 0x72, 0x00, 0x32, 0x00, 0x32, 0x00,
+    0x73, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x65, 0x74, 0x00, 0x32, 0x00, 0x32,
+    0x00, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x00, 0x32,
+    0x00, 0x32, 0x00, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x69,
+    0x6f, 0x6e, 0x00, 0x30, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x70, 0x75, 0x72,
+    0x63, 0x68, 0x61, 0x73, 0x65, 0x00, 0x33, 0x00, 0x31, 0x00, 0x73, 0x5f,
+    0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x6c, 0x69, 0x6e,
+    0x65, 0x69, 0x74, 0x65, 0x6d, 0x00, 0x32, 0x00, 0x32, 0x00, 0x73, 0x5f,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x00, 0x32, 0x00, 0x32, 0x00, 0x73,
+    0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x00, 0x30, 0x00, 0x32, 0x00, 0x73,
+    0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x6f,
+    0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x00,
+    0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f,
+    0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x73, 0x00, 0x32, 0x00, 0x32, 0x00,
+    0x73, 0x5f, 0x73, 0x75, 0x62, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72,
+    0x79, 0x00, 0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x73, 0x75, 0x62, 0x63,
+    0x6c, 0x61, 0x73, 0x73, 0x00, 0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x77,
+    0x61, 0x72, 0x65, 0x68, 0x6f, 0x75, 0x73, 0x65, 0x00, 0x30, 0x00, 0x32,
+    0x00, 0x73, 0x5f, 0x77, 0x65, 0x62, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72,
+    0x00, 0x33, 0x00, 0x31, 0x00, 0x73, 0x5f, 0x77, 0x65, 0x62, 0x5f, 0x6f,
+    0x72, 0x64, 0x65, 0x72, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x69, 0x74, 0x65,
+    0x6d, 0x00, 0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x77, 0x65, 0x62, 0x5f,
+    0x70, 0x61, 0x67, 0x65, 0x00, 0x30, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x77,
+    0x65, 0x62, 0x5f, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e,
+    0x61, 0x6c, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x00, 0x32, 0x00, 0x32, 0x00,
+    0x73, 0x5f, 0x77, 0x65, 0x62, 0x5f, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
+    0x73, 0x00, 0x32, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x77, 0x65, 0x62, 0x5f,
+    0x73, 0x69, 0x74, 0x65, 0x00, 0x30, 0x00, 0x32, 0x00, 0x73, 0x5f, 0x7a,
+    0x69, 0x70, 0x5f, 0x74, 0x6f, 0x5f, 0x67, 0x6d, 0x74, 0x00, 0x33, 0x00,
+    0x32, 0x00, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x62, 0x72, 0x61, 0x6e, 0x64,
+    0x73, 0x00, 0x30, 0x00, 0x31, 0x00, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x63,
+    0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x00, 0x30, 0x00, 0x31, 0x00, 0x69,
+    0x74, 0x65, 0x6d, 0x5f, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x69,
+    0x65, 0x73, 0x00, 0x30, 0x00, 0x31, 0x00, 0x64, 0x69, 0x76, 0x69, 0x73,
+    0x69, 0x6f, 0x6e, 0x73, 0x00, 0x30, 0x00, 0x33, 0x00, 0x63, 0x6f, 0x6d,
+    0x70, 0x61, 0x6e, 0x69, 0x65, 0x73, 0x00, 0x30, 0x00, 0x33, 0x00, 0x63,
+    0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x77, 0x65,
+    0x62, 0x5f, 0x73, 0x69, 0x74, 0x65, 0x73, 0x00, 0x30, 0x00, 0x33, 0x00,
+    0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x69, 0x74, 0x69, 0x65,
+    0x73, 0x00, 0x30, 0x00, 0x33, 0x00, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65,
+    0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x69, 0x65, 0x73, 0x00, 0x30, 0x00,
+    0x33, 0x00, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x73, 0x74, 0x61,
+    0x74, 0x65, 0x73, 0x00, 0x30, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x4d, 0x00, 0x46, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x08, 0x4d, 0x00, 0x53, 0x00, 0x44, 0x00, 0x57, 0x00,
+    0x55, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x02, 0x8a, 0x00, 0x00, 0x0c, 0xb2, 0x00, 0x00, 0x02, 0x8a, 0x00, 0x00,
+    0x03, 0xcf, 0x00, 0x00, 0x02, 0x8a, 0x00, 0x00, 0x01, 0x45, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00, 0x04, 0xe2, 0x00, 0x00,
+    0x00, 0xfa, 0x00, 0x00, 0x01, 0x77, 0x00, 0x00, 0x00, 0xfa, 0x00, 0x00,
+    0x00, 0x7d, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00,
+    0x01, 0xf4, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00,
+    0x00, 0x64, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00,
+    0x00, 0x1a, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00,
+    0x00, 0x42, 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x00, 0x53, 0x65,
+    0x63, 0x6f, 0x6e, 0x64, 0x61, 0x72, 0x79, 0x00, 0x43, 0x6f, 0x6c, 0x6c,
+    0x65, 0x67, 0x65, 0x00, 0x32, 0x20, 0x79, 0x72, 0x20, 0x44, 0x65, 0x67,
+    0x72, 0x65, 0x65, 0x00, 0x34, 0x20, 0x79, 0x72, 0x20, 0x44, 0x65, 0x67,
+    0x72, 0x65, 0x65, 0x00, 0x41, 0x64, 0x76, 0x61, 0x6e, 0x63, 0x65, 0x64,
+    0x20, 0x44, 0x65, 0x67, 0x72, 0x65, 0x65, 0x00, 0x55, 0x6e, 0x6b, 0x6e,
+    0x6f, 0x77, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x13,
+    0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x22,
+    0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x31,
+    0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x40,
+    0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x4f,
+    0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x5e,
+    0x35, 0x30, 0x30, 0x00, 0x31, 0x30, 0x30, 0x30, 0x00, 0x31, 0x35, 0x30,
+    0x30, 0x00, 0x32, 0x30, 0x30, 0x30, 0x00, 0x32, 0x35, 0x30, 0x30, 0x00,
+    0x33, 0x30, 0x30, 0x30, 0x00, 0x33, 0x35, 0x30, 0x30, 0x00, 0x34, 0x30,
+    0x30, 0x30, 0x00, 0x34, 0x35, 0x30, 0x30, 0x00, 0x35, 0x30, 0x30, 0x30,
+    0x00, 0x35, 0x35, 0x30, 0x30, 0x00, 0x36, 0x30, 0x30, 0x30, 0x00, 0x36,
+    0x35, 0x30, 0x30, 0x00, 0x37, 0x30, 0x30, 0x30, 0x00, 0x37, 0x35, 0x30,
+    0x30, 0x00, 0x38, 0x30, 0x30, 0x30, 0x00, 0x38, 0x35, 0x30, 0x30, 0x00,
+    0x39, 0x30, 0x30, 0x30, 0x00, 0x39, 0x35, 0x30, 0x30, 0x00, 0x31, 0x30,
+    0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x19,
+    0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x2b, 0x30, 0x2d, 0x35, 0x30,
+    0x30, 0x00, 0x35, 0x30, 0x31, 0x2d, 0x31, 0x30, 0x30, 0x30, 0x00, 0x31,
+    0x30, 0x30, 0x31, 0x2d, 0x35, 0x30, 0x30, 0x30, 0x00, 0x35, 0x30, 0x30,
+    0x31, 0x2d, 0x31, 0x30, 0x30, 0x30, 0x30, 0x00, 0x3e, 0x31, 0x30, 0x30,
+    0x30, 0x30, 0x00, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x00, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x19, 0x00,
+    0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x18, 0x47,
+    0x6f, 0x6f, 0x64, 0x00, 0x4c, 0x6f, 0x77, 0x20, 0x52, 0x69, 0x73, 0x6b,
+    0x00, 0x48, 0x69, 0x67, 0x68, 0x20, 0x52, 0x69, 0x73, 0x6b, 0x00, 0x55,
+    0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x14, 0x00,
+    0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x38, 0x00,
+    0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x5c, 0x00,
+    0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x75, 0x00, 0x00, 0x00, 0x83, 0x00,
+    0x00, 0x00, 0x91, 0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0xad, 0x00,
+    0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, 0xc9, 0x00, 0x00, 0x00, 0xd7, 0x00,
+    0x00, 0x00, 0xe5, 0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x26, 0x00,
+    0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x4a, 0x00,
+    0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00, 0x6e, 0x00,
+    0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x98, 0x00,
+    0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00, 0xc2, 0x00,
+    0x00, 0x00, 0xd0, 0x00, 0x00, 0x00, 0xde, 0x00, 0x00, 0x00, 0xec, 0x00,
+    0x00, 0x00, 0xfa, 0x30, 0x00, 0x31, 0x30, 0x30, 0x30, 0x30, 0x00, 0x31,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x32, 0x30, 0x30, 0x30, 0x30, 0x00, 0x32,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x33, 0x30, 0x30, 0x30, 0x30, 0x00, 0x33,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x34, 0x30, 0x30, 0x30, 0x30, 0x00, 0x34,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x35, 0x30, 0x30, 0x30, 0x30, 0x00, 0x35,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x36, 0x30, 0x30, 0x30, 0x30, 0x00, 0x36,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x37, 0x30, 0x30, 0x30, 0x30, 0x00, 0x37,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x38, 0x30, 0x30, 0x30, 0x30, 0x00, 0x38,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x39, 0x30, 0x30, 0x30, 0x30, 0x00, 0x39,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00,
+    0x31, 0x30, 0x30, 0x30, 0x30, 0x31, 0x00, 0x31, 0x31, 0x30, 0x30, 0x30,
+    0x30, 0x00, 0x31, 0x31, 0x30, 0x30, 0x30, 0x31, 0x00, 0x31, 0x32, 0x30,
+    0x30, 0x30, 0x30, 0x00, 0x31, 0x32, 0x30, 0x30, 0x30, 0x31, 0x00, 0x31,
+    0x33, 0x30, 0x30, 0x30, 0x30, 0x00, 0x31, 0x33, 0x30, 0x30, 0x30, 0x31,
+    0x00, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x00, 0x31, 0x34, 0x30, 0x30,
+    0x30, 0x31, 0x00, 0x31, 0x35, 0x30, 0x30, 0x30, 0x30, 0x00, 0x31, 0x35,
+    0x30, 0x30, 0x30, 0x31, 0x00, 0x31, 0x36, 0x30, 0x30, 0x30, 0x30, 0x00,
+    0x31, 0x36, 0x30, 0x30, 0x30, 0x31, 0x00, 0x31, 0x37, 0x30, 0x30, 0x30,
+    0x30, 0x00, 0x31, 0x37, 0x30, 0x30, 0x30, 0x31, 0x00, 0x31, 0x38, 0x30,
+    0x30, 0x30, 0x30, 0x00, 0x31, 0x38, 0x30, 0x30, 0x30, 0x31, 0x00, 0x31,
+    0x39, 0x30, 0x30, 0x30, 0x30, 0x00, 0x31, 0x39, 0x30, 0x30, 0x30, 0x31,
+    0x00, 0x32, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x07,
+    0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x0a,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x08,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x0e,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x12, 0x30, 0x00, 0x31, 0x00,
+    0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00,
+    0x38, 0x00, 0x39, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x11,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x16,
+    0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0a, 0x30, 0x00, 0x31, 0x00,
+    0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x2d, 0x31, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x55, 0x6e, 0x6b,
+    0x6e, 0x6f, 0x77, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+    0x3b, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00,
+    0x92, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0xb7, 0x00, 0x00, 0x00,
+    0xce, 0x00, 0x00, 0x00, 0xe4, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x01,
+    0x1d, 0x00, 0x00, 0x01, 0x3d, 0x00, 0x00, 0x01, 0x69, 0x00, 0x00, 0x01,
+    0x7e, 0x00, 0x00, 0x01, 0x8a, 0x00, 0x00, 0x01, 0x95, 0x00, 0x00, 0x01,
+    0xa1, 0x00, 0x00, 0x01, 0xb6, 0x00, 0x00, 0x01, 0xc9, 0x00, 0x00, 0x01,
+    0xd6, 0x00, 0x00, 0x01, 0xe3, 0x00, 0x00, 0x01, 0xed, 0x00, 0x00, 0x01,
+    0xf7, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x02, 0x0b, 0x00, 0x00, 0x02,
+    0x15, 0x00, 0x00, 0x02, 0x1f, 0x00, 0x00, 0x02, 0x29, 0x00, 0x00, 0x02,
+    0x33, 0x00, 0x00, 0x02, 0x3d, 0x00, 0x00, 0x02, 0x47, 0x00, 0x00, 0x02,
+    0x51, 0x00, 0x00, 0x02, 0x5b, 0x00, 0x00, 0x02, 0x65, 0x00, 0x00, 0x02,
+    0x6f, 0x00, 0x00, 0x02, 0x79, 0x00, 0x00, 0x02, 0x83, 0x00, 0x00, 0x02,
+    0x8d, 0x00, 0x00, 0x02, 0x97, 0x00, 0x00, 0x02, 0xa1, 0x00, 0x00, 0x02,
+    0xab, 0x00, 0x00, 0x02, 0xb5, 0x00, 0x00, 0x02, 0xbf, 0x00, 0x00, 0x02,
+    0xc9, 0x00, 0x00, 0x02, 0xd3, 0x00, 0x00, 0x02, 0xdd, 0x00, 0x00, 0x02,
+    0xe7, 0x00, 0x00, 0x02, 0xf1, 0x00, 0x00, 0x02, 0xfb, 0x00, 0x00, 0x03,
+    0x05, 0x00, 0x00, 0x03, 0x0f, 0x00, 0x00, 0x03, 0x19, 0x00, 0x00, 0x03,
+    0x23, 0x00, 0x00, 0x03, 0x2d, 0x00, 0x00, 0x03, 0x37, 0x00, 0x00, 0x03,
+    0x41, 0x00, 0x00, 0x03, 0x4b, 0x00, 0x00, 0x03, 0x55, 0x00, 0x00, 0x03,
+    0x5f, 0x00, 0x00, 0x03, 0x69, 0x00, 0x00, 0x03, 0x73, 0x00, 0x00, 0x03,
+    0x7d, 0x00, 0x00, 0x03, 0x87, 0x00, 0x00, 0x03, 0x91, 0x00, 0x00, 0x03,
+    0x9b, 0x00, 0x00, 0x03, 0xa5, 0x00, 0x00, 0x03, 0xaf, 0x00, 0x00, 0x03,
+    0xb9, 0x00, 0x00, 0x03, 0xc3, 0x00, 0x00, 0x03, 0xcd, 0x00, 0x00, 0x03,
+    0xd7, 0x00, 0x00, 0x03, 0xe1, 0x00, 0x00, 0x03, 0xeb, 0x50, 0x61, 0x63,
+    0x6b, 0x61, 0x67, 0x65, 0x20, 0x77, 0x61, 0x73, 0x20, 0x64, 0x61, 0x6d,
+    0x61, 0x67, 0x65, 0x64, 0x00, 0x53, 0x74, 0x6f, 0x70, 0x70, 0x65, 0x64,
+    0x20, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x00, 0x44, 0x69, 0x64,
+    0x20, 0x6e, 0x6f, 0x74, 0x20, 0x67, 0x65, 0x74, 0x20, 0x69, 0x74, 0x20,
+    0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x00, 0x4e, 0x6f, 0x74, 0x20,
+    0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x20,
+    0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x61, 0x73, 0x20, 0x6f, 0x72, 0x64,
+    0x72, 0x65, 0x64, 0x00, 0x50, 0x61, 0x72, 0x74, 0x73, 0x20, 0x6d, 0x69,
+    0x73, 0x73, 0x69, 0x6e, 0x67, 0x00, 0x44, 0x6f, 0x65, 0x73, 0x20, 0x6e,
+    0x6f, 0x74, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x20, 0x77, 0x69, 0x74, 0x68,
+    0x20, 0x61, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x20, 0x74,
+    0x68, 0x61, 0x74, 0x20, 0x49, 0x20, 0x68, 0x61, 0x76, 0x65, 0x00, 0x47,
+    0x69, 0x66, 0x74, 0x20, 0x65, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65,
+    0x00, 0x44, 0x69, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x69, 0x6b,
+    0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00,
+    0x44, 0x69, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x69, 0x6b, 0x65,
+    0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x00, 0x44,
+    0x69, 0x64, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20,
+    0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x6b, 0x65, 0x00, 0x44, 0x69, 0x64,
+    0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x74, 0x68,
+    0x65, 0x20, 0x77, 0x61, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x79, 0x00, 0x4e,
+    0x6f, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, 0x6c, 0x6f,
+    0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x6d, 0x79,
+    0x20, 0x61, 0x72, 0x65, 0x61, 0x00, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20,
+    0x61, 0x20, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72, 0x20, 0x70, 0x72, 0x69,
+    0x63, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x74, 0x6f, 0x72,
+    0x65, 0x00, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x62, 0x65,
+    0x74, 0x74, 0x65, 0x72, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65,
+    0x64, 0x20, 0x77, 0x61, 0x72, 0x72, 0x61, 0x6e, 0x74, 0x79, 0x20, 0x69,
+    0x6e, 0x20, 0x61, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x00, 0x4e, 0x6f,
+    0x74, 0x20, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e,
+    0x79, 0x20, 0x6d, 0x6f, 0x72, 0x65, 0x00, 0x44, 0x69, 0x64, 0x20, 0x6e,
+    0x6f, 0x74, 0x20, 0x66, 0x69, 0x74, 0x00, 0x57, 0x72, 0x6f, 0x6e, 0x67,
+    0x20, 0x73, 0x69, 0x7a, 0x65, 0x00, 0x4c, 0x6f, 0x73, 0x74, 0x20, 0x6d,
+    0x79, 0x20, 0x6a, 0x6f, 0x62, 0x00, 0x75, 0x6e, 0x61, 0x75, 0x74, 0x68,
+    0x6f, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x70, 0x75, 0x72, 0x63, 0x68, 0x61,
+    0x73, 0x65, 0x00, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65,
+    0x20, 0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x00, 0x69, 0x74,
+    0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x62, 0x6f, 0x79, 0x00, 0x69,
+    0x74, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x67, 0x69, 0x72, 0x6c, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x32, 0x33, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x32, 0x34, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x32, 0x35, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x32, 0x36, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x32,
+    0x37, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x32, 0x38, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x32, 0x39, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x33, 0x31, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x33, 0x31, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x33, 0x32, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x33,
+    0x33, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x33, 0x34, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x33, 0x35, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x33, 0x36, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x33, 0x37, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x33, 0x38, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x33,
+    0x39, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x34, 0x30, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x34, 0x31, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x34, 0x32, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x34, 0x33, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x34, 0x34, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x34,
+    0x35, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x34, 0x36, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x34, 0x37, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x34, 0x38, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x34, 0x39, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x35, 0x30, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x35,
+    0x31, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x35, 0x32, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x35, 0x33, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x35, 0x34, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x35, 0x35, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x35, 0x36, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x35,
+    0x37, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x35, 0x38, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x35, 0x39, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x36, 0x30, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x36, 0x31, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x36, 0x32, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x36,
+    0x33, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x36, 0x34, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x36, 0x35, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x36, 0x36, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x36, 0x37, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x36, 0x38, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x36,
+    0x39, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x37, 0x30, 0x00,
+    0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x37, 0x31, 0x00, 0x72, 0x65,
+    0x61, 0x73, 0x6f, 0x6e, 0x20, 0x37, 0x32, 0x00, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x20, 0x37, 0x33, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e,
+    0x20, 0x37, 0x34, 0x00, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x37,
+    0x35, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
+    0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
+    0x00, 0x10, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00,
+    0x00, 0x27, 0x42, 0x69, 0x67, 0x20, 0x42, 0x6f, 0x78, 0x00, 0x32, 0x30,
+    0x30, 0x00, 0x33, 0x30, 0x30, 0x00, 0x35, 0x30, 0x30, 0x30, 0x30, 0x30,
+    0x30, 0x00, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x00, 0x31,
+    0x30, 0x30, 0x30, 0x30, 0x00, 0x32, 0x30, 0x30, 0x30, 0x30, 0x00, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x55,
+    0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x55, 0x6e, 0x6b, 0x6e, 0x6f,
+    0x77, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x00, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x00, 0x00,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x08, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x07, 0x00,
+    0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x36, 0x00,
+    0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x00, 0x00, 0x6c, 0x00,
+    0x00, 0x00, 0x89, 0x00, 0x00, 0x00, 0xa6, 0x00, 0x00, 0x00, 0xc3, 0x00,
+    0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0xf5, 0x00, 0x00, 0x01, 0x0a, 0x00,
+    0x00, 0x01, 0x26, 0x00, 0x00, 0x01, 0x42, 0x00, 0x00, 0x01, 0x5e, 0x00,
+    0x00, 0x01, 0x76, 0x00, 0x00, 0x01, 0x8e, 0x00, 0x00, 0x01, 0xaa, 0x00,
+    0x00, 0x01, 0xc6, 0x00, 0x00, 0x01, 0xe2, 0x00, 0x00, 0x01, 0xf8, 0x00,
+    0x00, 0x02, 0x0e, 0x00, 0x00, 0x02, 0x24, 0x00, 0x00, 0x00, 0x02, 0x00,
+    0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x38, 0x00,
+    0x00, 0x00, 0x4a, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x6e, 0x00,
+    0x00, 0x00, 0x8b, 0x00, 0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0xc5, 0x00,
+    0x00, 0x00, 0xe3, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x01, 0x0d, 0x00,
+    0x00, 0x01, 0x29, 0x00, 0x00, 0x01, 0x45, 0x00, 0x00, 0x01, 0x61, 0x00,
+    0x00, 0x01, 0x79, 0x00, 0x00, 0x01, 0x91, 0x00, 0x00, 0x01, 0xad, 0x00,
+    0x00, 0x01, 0xc9, 0x00, 0x00, 0x01, 0xe5, 0x00, 0x00, 0x01, 0xfb, 0x00,
+    0x00, 0x02, 0x11, 0x00, 0x00, 0x02, 0x27, 0x00, 0x00, 0x00, 0x05, 0x00,
+    0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x3b, 0x00,
+    0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x5f, 0x00, 0x00, 0x00, 0x71, 0x00,
+    0x00, 0x00, 0x8e, 0x00, 0x00, 0x00, 0xab, 0x00, 0x00, 0x00, 0xc8, 0x00,
+    0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x01, 0x10, 0x00,
+    0x00, 0x01, 0x2c, 0x00, 0x00, 0x01, 0x48, 0x00, 0x00, 0x01, 0x64, 0x00,
+    0x00, 0x01, 0x7c, 0x00, 0x00, 0x01, 0x94, 0x00, 0x00, 0x01, 0xb0, 0x00,
+    0x00, 0x01, 0xcc, 0x00, 0x00, 0x01, 0xe8, 0x00, 0x00, 0x01, 0xfe, 0x00,
+    0x00, 0x02, 0x14, 0x00, 0x00, 0x02, 0x2a, 0x00, 0x00, 0x00, 0x0b, 0x00,
+    0x00, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x41, 0x00,
+    0x00, 0x00, 0x53, 0x00, 0x00, 0x00, 0x65, 0x00, 0x00, 0x00, 0x77, 0x00,
+    0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00, 0xce, 0x00,
+    0x00, 0x00, 0xec, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x16, 0x00,
+    0x00, 0x01, 0x32, 0x00, 0x00, 0x01, 0x4e, 0x00, 0x00, 0x01, 0x6b, 0x00,
+    0x00, 0x01, 0x83, 0x00, 0x00, 0x01, 0x9b, 0x00, 0x00, 0x01, 0xb7, 0x00,
+    0x00, 0x01, 0xd3, 0x00, 0x00, 0x01, 0xef, 0x00, 0x00, 0x02, 0x05, 0x00,
+    0x00, 0x02, 0x1b, 0x00, 0x00, 0x02, 0x30, 0x00, 0x00, 0x00, 0x11, 0x00,
+    0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x47, 0x00,
+    0x00, 0x00, 0x59, 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x7f, 0x00,
+    0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00, 0xd6, 0x00,
+    0x00, 0x00, 0xf4, 0x00, 0x00, 0x01, 0x09, 0x00, 0x00, 0x01, 0x20, 0x00,
+    0x00, 0x01, 0x3c, 0x00, 0x00, 0x01, 0x58, 0x00, 0x00, 0x01, 0x75, 0x00,
+    0x00, 0x01, 0x8d, 0x00, 0x00, 0x01, 0xa3, 0x00, 0x00, 0x01, 0xbf, 0x00,
+    0x00, 0x01, 0xdb, 0x00, 0x00, 0x01, 0xf7, 0x00, 0x00, 0x02, 0x0d, 0x00,
+    0x00, 0x02, 0x23, 0x00, 0x00, 0x02, 0x38, 0x30, 0x00, 0x41, 0x4d, 0x00,
+    0x74, 0x68, 0x69, 0x72, 0x64, 0x00, 0x6e, 0x69, 0x67, 0x68, 0x74, 0x00,
+    0x00, 0x31, 0x00, 0x41, 0x4d, 0x00, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00,
+    0x6e, 0x69, 0x67, 0x68, 0x74, 0x00, 0x00, 0x32, 0x00, 0x41, 0x4d, 0x00,
+    0x74, 0x68, 0x69, 0x72, 0x64, 0x00, 0x6e, 0x69, 0x67, 0x68, 0x74, 0x00,
+    0x00, 0x33, 0x00, 0x41, 0x4d, 0x00, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00,
+    0x6e, 0x69, 0x67, 0x68, 0x74, 0x00, 0x00, 0x34, 0x00, 0x41, 0x4d, 0x00,
+    0x74, 0x68, 0x69, 0x72, 0x64, 0x00, 0x6e, 0x69, 0x67, 0x68, 0x74, 0x00,
+    0x00, 0x35, 0x00, 0x41, 0x4d, 0x00, 0x74, 0x68, 0x69, 0x72, 0x64, 0x00,
+    0x6e, 0x69, 0x67, 0x68, 0x74, 0x00, 0x00, 0x36, 0x00, 0x41, 0x4d, 0x00,
+    0x74, 0x68, 0x69, 0x72, 0x64, 0x00, 0x6d, 0x6f, 0x72, 0x6e, 0x69, 0x6e,
+    0x67, 0x00, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x66, 0x61, 0x73, 0x74, 0x00,
+    0x37, 0x00, 0x41, 0x4d, 0x00, 0x66, 0x69, 0x72, 0x73, 0x74, 0x00, 0x6d,
+    0x6f, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x62, 0x72, 0x65, 0x61, 0x6b,
+    0x66, 0x61, 0x73, 0x74, 0x00, 0x38, 0x00, 0x41, 0x4d, 0x00, 0x66, 0x69,
+    0x72, 0x73, 0x74, 0x00, 0x6d, 0x6f, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x00,
+    0x62, 0x72, 0x65, 0x61, 0x6b, 0x66, 0x61, 0x73, 0x74, 0x00, 0x39, 0x00,
+    0x41, 0x4d, 0x00, 0x66, 0x69, 0x72, 0x73, 0x74, 0x00, 0x6d, 0x6f, 0x72,
+    0x6e, 0x69, 0x6e, 0x67, 0x00, 0x62, 0x72, 0x65, 0x61, 0x6b, 0x66, 0x61,
+    0x73, 0x74, 0x00, 0x31, 0x30, 0x00, 0x41, 0x4d, 0x00, 0x66, 0x69, 0x72,
+    0x73, 0x74, 0x00, 0x6d, 0x6f, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x00,
+    0x31, 0x31, 0x00, 0x41, 0x4d, 0x00, 0x66, 0x69, 0x72, 0x73, 0x74, 0x00,
+    0x6d, 0x6f, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x31, 0x32, 0x00,
+    0x50, 0x4d, 0x00, 0x66, 0x69, 0x72, 0x73, 0x74, 0x00, 0x61, 0x66, 0x74,
+    0x65, 0x72, 0x6e, 0x6f, 0x6f, 0x6e, 0x00, 0x6c, 0x75, 0x6e, 0x63, 0x68,
+    0x00, 0x31, 0x33, 0x00, 0x50, 0x4d, 0x00, 0x66, 0x69, 0x72, 0x73, 0x74,
+    0x00, 0x61, 0x66, 0x74, 0x65, 0x72, 0x6e, 0x6f, 0x6f, 0x6e, 0x00, 0x6c,
+    0x75, 0x6e, 0x63, 0x68, 0x00, 0x31, 0x34, 0x00, 0x50, 0x4d, 0x00, 0x66,
+    0x69, 0x72, 0x73, 0x74, 0x00, 0x61, 0x66, 0x74, 0x65, 0x72, 0x6e, 0x6f,
+    0x6f, 0x6e, 0x00, 0x6c, 0x75, 0x6e, 0x63, 0x68, 0x00, 0x31, 0x35, 0x00,
+    0x50, 0x4d, 0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00, 0x61, 0x66,
+    0x74, 0x65, 0x72, 0x6e, 0x6f, 0x6f, 0x6e, 0x00, 0x00, 0x31, 0x36, 0x00,
+    0x50, 0x4d, 0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00, 0x61, 0x66,
+    0x74, 0x65, 0x72, 0x6e, 0x6f, 0x6f, 0x6e, 0x00, 0x00, 0x31, 0x37, 0x00,
+    0x50, 0x4d, 0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00, 0x65, 0x76,
+    0x65, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x64, 0x69, 0x6e, 0x6e, 0x65, 0x72,
+    0x00, 0x31, 0x38, 0x00, 0x50, 0x4d, 0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e,
+    0x64, 0x00, 0x65, 0x76, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x64, 0x69,
+    0x6e, 0x6e, 0x65, 0x72, 0x00, 0x31, 0x39, 0x00, 0x50, 0x4d, 0x00, 0x73,
+    0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00, 0x65, 0x76, 0x65, 0x6e, 0x69, 0x6e,
+    0x67, 0x00, 0x64, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x00, 0x32, 0x30, 0x00,
+    0x50, 0x4d, 0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00, 0x65, 0x76,
+    0x65, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x32, 0x31, 0x00, 0x50, 0x4d,
+    0x00, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00, 0x65, 0x76, 0x65, 0x6e,
+    0x69, 0x6e, 0x67, 0x00, 0x00, 0x32, 0x32, 0x00, 0x50, 0x4d, 0x00, 0x73,
+    0x65, 0x63, 0x6f, 0x6e, 0x64, 0x00, 0x65, 0x76, 0x65, 0x6e, 0x69, 0x6e,
+    0x67, 0x00, 0x00, 0x32, 0x33, 0x00, 0x50, 0x4d, 0x00, 0x74, 0x68, 0x69,
+    0x72, 0x64, 0x00, 0x65, 0x76, 0x65, 0x6e, 0x69, 0x6e, 0x67, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x09,
+    0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x03,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2f,
+    0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x4d, 0x00, 0x00, 0x00, 0x5b,
+    0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x82,
+    0x00, 0x00, 0x00, 0x90, 0x4e, 0x65, 0x77, 0x20, 0x45, 0x6e, 0x67, 0x6c,
+    0x61, 0x6e, 0x64, 0x00, 0x4e, 0x59, 0x20, 0x4d, 0x65, 0x74, 0x72, 0x6f,
+    0x00, 0x4d, 0x69, 0x64, 0x20, 0x41, 0x74, 0x6c, 0x61, 0x6e, 0x74, 0x69,
+    0x63, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x65, 0x61, 0x73, 0x74, 0x65,
+    0x72, 0x6e, 0x00, 0x4e, 0x6f, 0x72, 0x74, 0x68, 0x20, 0x4d, 0x69, 0x64,
+    0x77, 0x65, 0x73, 0x74, 0x00, 0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c,
+    0x20, 0x4d, 0x69, 0x64, 0x77, 0x65, 0x73, 0x74, 0x00, 0x53, 0x6f, 0x75,
+    0x74, 0x68, 0x20, 0x4d, 0x69, 0x64, 0x77, 0x65, 0x73, 0x74, 0x00, 0x50,
+    0x61, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x4e, 0x6f, 0x72, 0x74, 0x68,
+    0x77, 0x65, 0x73, 0x74, 0x00, 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72,
+    0x6e, 0x69, 0x61, 0x00, 0x53, 0x6f, 0x75, 0x74, 0x68, 0x77, 0x65, 0x73,
+    0x74, 0x00, 0x48, 0x61, 0x77, 0x61, 0x69, 0x69, 0x2f, 0x41, 0x6c, 0x61,
+    0x73, 0x6b, 0x61, 0x00, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x00, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x70, 0x80, 0x00, 0x00, 0x70, 0x80, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0x00, 0x01, 0x51, 0x7f, 0x00, 0x01,
+    0x51, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+    0x00, 0x11, 0x38, 0x41, 0x4d, 0x2d, 0x34, 0x50, 0x4d, 0x00, 0x38, 0x41,
+    0x4d, 0x2d, 0x31, 0x32, 0x41, 0x4d, 0x00, 0x38, 0x41, 0x4d, 0x2d, 0x38,
+    0x41, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0d, 0x73, 0x6d, 0x61, 0x6c, 0x6c,
+    0x00, 0x6d, 0x65, 0x64, 0x69, 0x75, 0x6d, 0x00, 0x6c, 0x61, 0x72, 0x67,
+    0x65, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x04, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+    0x00, 0x12, 0x00, 0x00, 0x00, 0x16, 0x4d, 0x72, 0x2e, 0x00, 0x4d, 0x72,
+    0x73, 0x2e, 0x00, 0x4d, 0x73, 0x2e, 0x00, 0x4d, 0x69, 0x73, 0x73, 0x00,
+    0x53, 0x69, 0x72, 0x00, 0x44, 0x72, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x06,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x15,
+    0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x2a, 0x41, 0x49, 0x52, 0x00,
+    0x53, 0x55, 0x52, 0x46, 0x41, 0x43, 0x45, 0x00, 0x53, 0x45, 0x41, 0x00,
+    0x42, 0x49, 0x4b, 0x45, 0x00, 0x48, 0x41, 0x4e, 0x44, 0x20, 0x43, 0x41,
+    0x52, 0x52, 0x59, 0x00, 0x4d, 0x45, 0x53, 0x53, 0x45, 0x4e, 0x47, 0x45,
+    0x52, 0x00, 0x43, 0x4f, 0x55, 0x52, 0x49, 0x45, 0x52, 0x00, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,
+    0x00, 0x10, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00,
+    0x00, 0x2b, 0x52, 0x45, 0x47, 0x55, 0x4c, 0x41, 0x52, 0x00, 0x45, 0x58,
+    0x50, 0x52, 0x45, 0x53, 0x53, 0x00, 0x4e, 0x45, 0x58, 0x54, 0x20, 0x44,
+    0x41, 0x59, 0x00, 0x4f, 0x56, 0x45, 0x52, 0x4e, 0x49, 0x47, 0x48, 0x54,
+    0x00, 0x54, 0x57, 0x4f, 0x20, 0x44, 0x41, 0x59, 0x00, 0x4c, 0x49, 0x42,
+    0x52, 0x41, 0x52, 0x59, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x38, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00,
+    0x51, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x6a, 0x00, 0x00, 0x00,
+    0x72, 0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
+    0x8a, 0x55, 0x50, 0x53, 0x00, 0x46, 0x45, 0x44, 0x45, 0x58, 0x00, 0x41,
+    0x49, 0x52, 0x42, 0x4f, 0x52, 0x4e, 0x45, 0x00, 0x55, 0x53, 0x50, 0x53,
+    0x00, 0x44, 0x48, 0x4c, 0x00, 0x54, 0x42, 0x53, 0x00, 0x5a, 0x48, 0x4f,
+    0x55, 0x00, 0x5a, 0x4f, 0x55, 0x52, 0x4f, 0x53, 0x00, 0x4d, 0x53, 0x43,
+    0x00, 0x4c, 0x41, 0x54, 0x56, 0x49, 0x41, 0x4e, 0x00, 0x41, 0x4c, 0x4c,
+    0x49, 0x41, 0x4e, 0x43, 0x45, 0x00, 0x4f, 0x52, 0x49, 0x45, 0x4e, 0x54,
+    0x41, 0x4c, 0x00, 0x42, 0x41, 0x52, 0x49, 0x41, 0x4e, 0x00, 0x42, 0x4f,
+    0x58, 0x42, 0x55, 0x4e, 0x44, 0x4c, 0x45, 0x53, 0x00, 0x47, 0x52, 0x45,
+    0x41, 0x54, 0x20, 0x45, 0x41, 0x53, 0x54, 0x45, 0x52, 0x4e, 0x00, 0x44,
+    0x49, 0x41, 0x4d, 0x4f, 0x4e, 0x44, 0x00, 0x52, 0x55, 0x50, 0x45, 0x4b,
+    0x53, 0x41, 0x00, 0x47, 0x45, 0x52, 0x4d, 0x41, 0x00, 0x48, 0x41, 0x52,
+    0x4d, 0x53, 0x54, 0x4f, 0x52, 0x46, 0x00, 0x50, 0x52, 0x49, 0x56, 0x41,
+    0x54, 0x45, 0x43, 0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x00, 0x00, 0x00,
+    0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x08, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00,
+    0x00, 0x19, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2c, 0x67, 0x65,
+    0x6e, 0x65, 0x72, 0x61, 0x6c, 0x00, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x00,
+    0x77, 0x65, 0x6c, 0x63, 0x6f, 0x6d, 0x65, 0x00, 0x61, 0x64, 0x00, 0x66,
+    0x65, 0x65, 0x64, 0x62, 0x61, 0x63, 0x6b, 0x00, 0x70, 0x72, 0x6f, 0x74,
+    0x65, 0x63, 0x74, 0x65, 0x64, 0x00, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69,
+    0x63, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00,
+    0x00, 0x14, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
+    0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x05, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00,
+    0x00, 0x11, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00,
+    0x00, 0x1d, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00,
+    0x00, 0x29, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00,
+    0x00, 0x34, 0x00, 0x00, 0x00, 0x38, 0x68, 0x74, 0x6d, 0x6c, 0x00, 0x68,
+    0x74, 0x6d, 0x00, 0x70, 0x64, 0x66, 0x00, 0x67, 0x69, 0x66, 0x00, 0x6a,
+    0x70, 0x67, 0x00, 0x70, 0x68, 0x70, 0x00, 0x61, 0x73, 0x70, 0x00, 0x70,
+    0x70, 0x74, 0x00, 0x78, 0x6c, 0x73, 0x00, 0x64, 0x61, 0x74, 0x00, 0x64,
+    0x6f, 0x63, 0x00, 0x77, 0x70, 0x00, 0x64, 0x62, 0x66, 0x00, 0x63, 0x73,
+    0x76, 0x00, 0x6a, 0x6d, 0x73, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00,
+    0x00, 0x32, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x14, 0x62, 0x69,
+    0x2d, 0x61, 0x6e, 0x6e, 0x75, 0x61, 0x6c, 0x00, 0x71, 0x75, 0x61, 0x72,
+    0x74, 0x65, 0x72, 0x6c, 0x79, 0x00, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x6c,
+    0x79, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00,
+    0x00, 0x19, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x0e, 0x00, 0x00, 0x00, 0x14, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65,
+    0x20, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x00, 0x63, 0x6f, 0x6e, 0x64,
+    0x6f, 0x00, 0x61, 0x70, 0x61, 0x72, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+    0x00, 0x00, 0x00, 0x08, 0x63, 0x6f, 0x6d, 0x00, 0x6f, 0x72, 0x67, 0x00,
+    0x65, 0x64, 0x75, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
+    0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x2a,
+    0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x48,
+    0x00, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 0x70,
+    0x00, 0x00, 0x00, 0x7a, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x88,
+    0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x9a, 0x00, 0x00, 0x00, 0xa5,
+    0x00, 0x00, 0x00, 0xad, 0x00, 0x00, 0x00, 0xb5, 0x00, 0x00, 0x00, 0xc0,
+    0x00, 0x00, 0x00, 0xc9, 0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0xd9,
+    0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0xe6, 0x00, 0x00, 0x00, 0xee,
+    0x00, 0x00, 0x00, 0xf5, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00, 0x01, 0x06,
+    0x00, 0x00, 0x01, 0x14, 0x00, 0x00, 0x01, 0x1b, 0x00, 0x00, 0x01, 0x2d,
+    0x00, 0x00, 0x01, 0x36, 0x00, 0x00, 0x01, 0x43, 0x00, 0x00, 0x01, 0x4b,
+    0x00, 0x00, 0x01, 0x54, 0x00, 0x00, 0x01, 0x5d, 0x00, 0x00, 0x01, 0x64,
+    0x00, 0x00, 0x01, 0x6f, 0x00, 0x00, 0x01, 0x7e, 0x00, 0x00, 0x01, 0x84,
+    0x00, 0x00, 0x01, 0x8a, 0x00, 0x00, 0x01, 0x9b, 0x00, 0x00, 0x01, 0xa3,
+    0x00, 0x00, 0x01, 0xa9, 0x00, 0x00, 0x01, 0xb4, 0x00, 0x00, 0x01, 0xc3,
+    0x00, 0x00, 0x01, 0xcb, 0x00, 0x00, 0x01, 0xd0, 0x00, 0x00, 0x01, 0xd7,
+    0x00, 0x00, 0x01, 0xe6, 0x00, 0x00, 0x01, 0xee, 0x00, 0x00, 0x01, 0xf7,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x08, 0x00, 0x00, 0x02, 0x0e,
+    0x00, 0x00, 0x02, 0x1a, 0x00, 0x00, 0x02, 0x2c, 0x00, 0x00, 0x02, 0x34,
+    0x00, 0x00, 0x02, 0x3c, 0x00, 0x00, 0x02, 0x45, 0x00, 0x00, 0x02, 0x53,
+    0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0x02, 0x60, 0x00, 0x00, 0x02, 0x67,
+    0x00, 0x00, 0x02, 0x75, 0x00, 0x00, 0x02, 0x86, 0x00, 0x00, 0x02, 0x8c,
+    0x00, 0x00, 0x02, 0x93, 0x00, 0x00, 0x02, 0x9b, 0x00, 0x00, 0x02, 0xa3,
+    0x00, 0x00, 0x02, 0xa9, 0x00, 0x00, 0x02, 0xb3, 0x00, 0x00, 0x02, 0xba,
+    0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x02, 0xcc, 0x00, 0x00, 0x02, 0xd7,
+    0x00, 0x00, 0x02, 0xdc, 0x00, 0x00, 0x02, 0xe6, 0x00, 0x00, 0x02, 0xef,
+    0x00, 0x00, 0x02, 0xf6, 0x00, 0x00, 0x03, 0x04, 0x00, 0x00, 0x03, 0x0b,
+    0x00, 0x00, 0x03, 0x11, 0x00, 0x00, 0x03, 0x1a, 0x00, 0x00, 0x03, 0x24,
+    0x00, 0x00, 0x03, 0x2c, 0x00, 0x00, 0x03, 0x34, 0x00, 0x00, 0x03, 0x3a,
+    0x00, 0x00, 0x03, 0x44, 0x00, 0x00, 0x03, 0x49, 0x00, 0x00, 0x03, 0x51,
+    0x00, 0x00, 0x03, 0x5d, 0x00, 0x00, 0x03, 0x64, 0x00, 0x00, 0x03, 0x6a,
+    0x00, 0x00, 0x03, 0x72, 0x00, 0x00, 0x03, 0x78, 0x00, 0x00, 0x03, 0x7f,
+    0x00, 0x00, 0x03, 0x86, 0x00, 0x00, 0x03, 0x91, 0x00, 0x00, 0x03, 0x97,
+    0x00, 0x00, 0x03, 0xa0, 0x00, 0x00, 0x03, 0xb3, 0x00, 0x00, 0x03, 0xba,
+    0x00, 0x00, 0x03, 0xc5, 0x00, 0x00, 0x03, 0xcc, 0x00, 0x00, 0x03, 0xd4,
+    0x00, 0x00, 0x03, 0xdc, 0x00, 0x00, 0x03, 0xe4, 0x00, 0x00, 0x03, 0xf2,
+    0x00, 0x00, 0x03, 0xfc, 0x00, 0x00, 0x04, 0x07, 0x00, 0x00, 0x04, 0x0d,
+    0x00, 0x00, 0x04, 0x18, 0x00, 0x00, 0x04, 0x1f, 0x00, 0x00, 0x04, 0x28,
+    0x00, 0x00, 0x04, 0x31, 0x00, 0x00, 0x04, 0x36, 0x00, 0x00, 0x04, 0x3c,
+    0x00, 0x00, 0x04, 0x4d, 0x00, 0x00, 0x04, 0x58, 0x00, 0x00, 0x04, 0x63,
+    0x00, 0x00, 0x04, 0x6d, 0x00, 0x00, 0x04, 0x75, 0x00, 0x00, 0x04, 0x7c,
+    0x00, 0x00, 0x04, 0x91, 0x00, 0x00, 0x04, 0x98, 0x00, 0x00, 0x04, 0xa1,
+    0x00, 0x00, 0x04, 0xac, 0x00, 0x00, 0x04, 0xb7, 0x00, 0x00, 0x04, 0xbf,
+    0x00, 0x00, 0x04, 0xca, 0x00, 0x00, 0x04, 0xd2, 0x00, 0x00, 0x04, 0xda,
+    0x00, 0x00, 0x04, 0xe0, 0x00, 0x00, 0x04, 0xe6, 0x00, 0x00, 0x04, 0xf2,
+    0x00, 0x00, 0x05, 0x07, 0x00, 0x00, 0x05, 0x15, 0x00, 0x00, 0x05, 0x21,
+    0x00, 0x00, 0x05, 0x2b, 0x00, 0x00, 0x05, 0x31, 0x00, 0x00, 0x05, 0x39,
+    0x00, 0x00, 0x05, 0x3e, 0x00, 0x00, 0x05, 0x4d, 0x00, 0x00, 0x05, 0x54,
+    0x00, 0x00, 0x05, 0x59, 0x00, 0x00, 0x05, 0x62, 0x00, 0x00, 0x05, 0x68,
+    0x00, 0x00, 0x05, 0x6f, 0x00, 0x00, 0x05, 0x80, 0x00, 0x00, 0x05, 0x89,
+    0x00, 0x00, 0x05, 0x8e, 0x00, 0x00, 0x05, 0x9a, 0x00, 0x00, 0x05, 0xa3,
+    0x00, 0x00, 0x05, 0xaa, 0x00, 0x00, 0x05, 0xb3, 0x00, 0x00, 0x05, 0xbf,
+    0x00, 0x00, 0x05, 0xc5, 0x00, 0x00, 0x05, 0xce, 0x00, 0x00, 0x05, 0xd6,
+    0x00, 0x00, 0x05, 0xe9, 0x00, 0x00, 0x05, 0xf0, 0x00, 0x00, 0x05, 0xfd,
+    0x00, 0x00, 0x06, 0x09, 0x00, 0x00, 0x06, 0x0f, 0x00, 0x00, 0x06, 0x1a,
+    0x00, 0x00, 0x06, 0x27, 0x00, 0x00, 0x06, 0x2f, 0x00, 0x00, 0x06, 0x36,
+    0x00, 0x00, 0x06, 0x41, 0x00, 0x00, 0x06, 0x4e, 0x00, 0x00, 0x06, 0x58,
+    0x00, 0x00, 0x06, 0x61, 0x00, 0x00, 0x06, 0x6a, 0x00, 0x00, 0x06, 0x7a,
+    0x00, 0x00, 0x06, 0x82, 0x00, 0x00, 0x06, 0x8f, 0x00, 0x00, 0x06, 0x95,
+    0x00, 0x00, 0x06, 0x9f, 0x00, 0x00, 0x06, 0xa5, 0x00, 0x00, 0x06, 0xae,
+    0x00, 0x00, 0x06, 0xb8, 0x00, 0x00, 0x06, 0xbf, 0x00, 0x00, 0x06, 0xcb,
+    0x00, 0x00, 0x06, 0xe0, 0x00, 0x00, 0x06, 0xeb, 0x00, 0x00, 0x06, 0xf4,
+    0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x05, 0x00, 0x00, 0x07, 0x0d,
+    0x00, 0x00, 0x07, 0x13, 0x00, 0x00, 0x07, 0x27, 0x00, 0x00, 0x07, 0x2f,
+    0x00, 0x00, 0x07, 0x36, 0x00, 0x00, 0x07, 0x43, 0x00, 0x00, 0x07, 0x4a,
+    0x00, 0x00, 0x07, 0x51, 0x00, 0x00, 0x07, 0x59, 0x00, 0x00, 0x07, 0x6e,
+    0x00, 0x00, 0x07, 0x7d, 0x00, 0x00, 0x07, 0x8b, 0x00, 0x00, 0x07, 0x93,
+    0x00, 0x00, 0x07, 0x9e, 0x00, 0x00, 0x07, 0xa6, 0x00, 0x00, 0x07, 0xb0,
+    0x00, 0x00, 0x07, 0xb9, 0x00, 0x00, 0x07, 0xce, 0x00, 0x00, 0x07, 0xe0,
+    0x00, 0x00, 0x07, 0xef, 0x00, 0x00, 0x07, 0xf5, 0x00, 0x00, 0x07, 0xfc,
+    0x41, 0x46, 0x47, 0x48, 0x41, 0x4e, 0x49, 0x53, 0x54, 0x41, 0x4e, 0x00,
+    0x41, 0x4c, 0x41, 0x4e, 0x44, 0x20, 0x49, 0x53, 0x4c, 0x41, 0x4e, 0x44,
+    0x53, 0x00, 0x41, 0x4c, 0x42, 0x41, 0x4e, 0x49, 0x41, 0x00, 0x41, 0x4c,
+    0x47, 0x45, 0x52, 0x49, 0x41, 0x00, 0x41, 0x4d, 0x45, 0x52, 0x49, 0x43,
+    0x41, 0x4e, 0x20, 0x53, 0x41, 0x4d, 0x4f, 0x41, 0x00, 0x41, 0x4e, 0x44,
+    0x4f, 0x52, 0x52, 0x41, 0x00, 0x41, 0x4e, 0x47, 0x4f, 0x4c, 0x41, 0x00,
+    0x41, 0x4e, 0x47, 0x55, 0x49, 0x4c, 0x4c, 0x41, 0x00, 0x41, 0x4e, 0x54,
+    0x41, 0x52, 0x43, 0x54, 0x49, 0x43, 0x41, 0x00, 0x41, 0x4e, 0x54, 0x49,
+    0x47, 0x55, 0x41, 0x20, 0x41, 0x4e, 0x44, 0x20, 0x42, 0x41, 0x52, 0x42,
+    0x55, 0x44, 0x41, 0x00, 0x41, 0x52, 0x47, 0x45, 0x4e, 0x54, 0x49, 0x4e,
+    0x41, 0x00, 0x41, 0x52, 0x4d, 0x45, 0x4e, 0x49, 0x41, 0x00, 0x41, 0x52,
+    0x55, 0x42, 0x41, 0x00, 0x41, 0x55, 0x53, 0x54, 0x52, 0x41, 0x4c, 0x49,
+    0x41, 0x00, 0x41, 0x55, 0x53, 0x54, 0x52, 0x49, 0x41, 0x00, 0x41, 0x5a,
+    0x45, 0x52, 0x42, 0x41, 0x49, 0x4a, 0x41, 0x4e, 0x00, 0x42, 0x41, 0x48,
+    0x41, 0x4d, 0x41, 0x53, 0x00, 0x42, 0x41, 0x48, 0x52, 0x41, 0x49, 0x4e,
+    0x00, 0x42, 0x41, 0x4e, 0x47, 0x4c, 0x41, 0x44, 0x45, 0x53, 0x48, 0x00,
+    0x42, 0x41, 0x52, 0x42, 0x41, 0x44, 0x4f, 0x53, 0x00, 0x42, 0x45, 0x4c,
+    0x41, 0x52, 0x55, 0x53, 0x00, 0x42, 0x45, 0x4c, 0x47, 0x49, 0x55, 0x4d,
+    0x00, 0x42, 0x45, 0x4c, 0x49, 0x5a, 0x45, 0x00, 0x42, 0x45, 0x4e, 0x49,
+    0x4e, 0x00, 0x42, 0x45, 0x52, 0x4d, 0x55, 0x44, 0x41, 0x00, 0x42, 0x48,
+    0x55, 0x54, 0x41, 0x4e, 0x00, 0x42, 0x4f, 0x4c, 0x49, 0x56, 0x49, 0x41,
+    0x00, 0x42, 0x4f, 0x54, 0x53, 0x57, 0x41, 0x4e, 0x41, 0x00, 0x42, 0x4f,
+    0x55, 0x56, 0x45, 0x54, 0x20, 0x49, 0x53, 0x4c, 0x41, 0x4e, 0x44, 0x00,
+    0x42, 0x52, 0x41, 0x5a, 0x49, 0x4c, 0x00, 0x42, 0x52, 0x55, 0x4e, 0x45,
+    0x49, 0x20, 0x44, 0x41, 0x52, 0x55, 0x53, 0x53, 0x41, 0x4c, 0x41, 0x4d,
+    0x00, 0x42, 0x55, 0x4c, 0x47, 0x41, 0x52, 0x49, 0x41, 0x00, 0x42, 0x55,
+    0x52, 0x4b, 0x49, 0x4e, 0x41, 0x20, 0x46, 0x41, 0x53, 0x4f, 0x00, 0x42,
+    0x55, 0x52, 0x55, 0x4e, 0x44, 0x49, 0x00, 0x43, 0x41, 0x4d, 0x42, 0x4f,
+    0x44, 0x49, 0x41, 0x00, 0x43, 0x41, 0x4d, 0x45, 0x52, 0x4f, 0x4f, 0x4e,
+    0x00, 0x43, 0x41, 0x4e, 0x41, 0x44, 0x41, 0x00, 0x43, 0x41, 0x50, 0x45,
+    0x20, 0x56, 0x45, 0x52, 0x44, 0x45, 0x00, 0x43, 0x41, 0x59, 0x4d, 0x41,
+    0x4e, 0x20, 0x49, 0x53, 0x4c, 0x41, 0x4e, 0x44, 0x53, 0x00, 0x43, 0x48,
+    0x49, 0x4c, 0x45, 0x00, 0x43, 0x48, 0x49, 0x4e, 0x41, 0x00, 0x43, 0x48,
+    0x52, 0x49, 0x53, 0x54, 0x4d, 0x41, 0x53, 0x20, 0x49, 0x53, 0x4c, 0x41,
+    0x4e, 0x44, 0x00, 0x43, 0x4f, 0x4d, 0x4f, 0x52, 0x4f, 0x53, 0x00, 0x61,
+    0x64, 0x64, 0x20, 0x28, 0x00, 0x43, 0x4f, 0x53, 0x54, 0x41, 0x20, 0x52,
+    0x49, 0x43, 0x41, 0x00, 0x43, 0xc3, 0x94, 0x54, 0x45, 0x20, 0x44, 0x27,
+    0x49, 0x56, 0x4f, 0x49, 0x52, 0x45, 0x00, 0x43, 0x52, 0x4f, 0x41, 0x54,
+    0x49, 0x41, 0x00, 0x43, 0x55, 0x42, 0x41, 0x00, 0x43, 0x59, 0x50, 0x52,
+    0x55, 0x53, 0x00, 0x43, 0x5a, 0x45, 0x43, 0x48, 0x20, 0x52, 0x45, 0x50,
+    0x55, 0x42, 0x4c, 0x49, 0x43, 0x00, 0x44, 0x45, 0x4e, 0x4d, 0x41, 0x52,
+    0x4b, 0x00, 0x44, 0x4a, 0x49, 0x42, 0x4f, 0x55, 0x54, 0x49, 0x00, 0x44,
+    0x4f, 0x4d, 0x49, 0x4e, 0x49, 0x43, 0x41, 0x00, 0x45, 0x43, 0x55, 0x41,
+    0x44, 0x4f, 0x52, 0x00, 0x45, 0x47, 0x59, 0x50, 0x54, 0x00, 0x45, 0x4c,
+    0x20, 0x53, 0x41, 0x4c, 0x56, 0x41, 0x44, 0x4f, 0x52, 0x00, 0x45, 0x51,
+    0x55, 0x41, 0x54, 0x4f, 0x52, 0x49, 0x41, 0x4c, 0x20, 0x47, 0x55, 0x49,
+    0x4e, 0x45, 0x41, 0x00, 0x45, 0x52, 0x49, 0x54, 0x52, 0x45, 0x41, 0x00,
+    0x45, 0x53, 0x54, 0x4f, 0x4e, 0x49, 0x41, 0x00, 0x45, 0x54, 0x48, 0x49,
+    0x4f, 0x50, 0x49, 0x41, 0x00, 0x46, 0x41, 0x52, 0x4f, 0x45, 0x20, 0x49,
+    0x53, 0x4c, 0x41, 0x4e, 0x44, 0x53, 0x00, 0x46, 0x49, 0x4a, 0x49, 0x00,
+    0x46, 0x49, 0x4e, 0x4c, 0x41, 0x4e, 0x44, 0x00, 0x46, 0x52, 0x41, 0x4e,
+    0x43, 0x45, 0x00, 0x46, 0x52, 0x45, 0x4e, 0x43, 0x48, 0x20, 0x47, 0x55,
+    0x49, 0x41, 0x4e, 0x41, 0x00, 0x46, 0x52, 0x45, 0x4e, 0x43, 0x48, 0x20,
+    0x50, 0x4f, 0x4c, 0x59, 0x4e, 0x45, 0x53, 0x49, 0x41, 0x00, 0x47, 0x41,
+    0x42, 0x4f, 0x4e, 0x00, 0x47, 0x41, 0x4d, 0x42, 0x49, 0x41, 0x00, 0x47,
+    0x45, 0x4f, 0x52, 0x47, 0x49, 0x41, 0x00, 0x47, 0x45, 0x52, 0x4d, 0x41,
+    0x4e, 0x59, 0x00, 0x47, 0x48, 0x41, 0x4e, 0x41, 0x00, 0x47, 0x49, 0x42,
+    0x52, 0x41, 0x4c, 0x54, 0x41, 0x52, 0x00, 0x47, 0x52, 0x45, 0x45, 0x43,
+    0x45, 0x00, 0x47, 0x52, 0x45, 0x45, 0x4e, 0x4c, 0x41, 0x4e, 0x44, 0x00,
+    0x47, 0x52, 0x45, 0x4e, 0x41, 0x44, 0x41, 0x00, 0x47, 0x55, 0x41, 0x44,
+    0x45, 0x4c, 0x4f, 0x55, 0x50, 0x45, 0x00, 0x47, 0x55, 0x41, 0x4d, 0x00,
+    0x47, 0x55, 0x41, 0x54, 0x45, 0x4d, 0x41, 0x4c, 0x41, 0x00, 0x47, 0x55,
+    0x45, 0x52, 0x4e, 0x53, 0x45, 0x59, 0x00, 0x47, 0x55, 0x49, 0x4e, 0x45,
+    0x41, 0x00, 0x47, 0x55, 0x49, 0x4e, 0x45, 0x41, 0x2d, 0x42, 0x49, 0x53,
+    0x53, 0x41, 0x55, 0x00, 0x47, 0x55, 0x59, 0x41, 0x4e, 0x41, 0x00, 0x48,
+    0x41, 0x49, 0x54, 0x49, 0x00, 0x48, 0x4f, 0x4e, 0x44, 0x55, 0x52, 0x41,
+    0x53, 0x00, 0x48, 0x4f, 0x4e, 0x47, 0x20, 0x4b, 0x4f, 0x4e, 0x47, 0x00,
+    0x48, 0x55, 0x4e, 0x47, 0x41, 0x52, 0x59, 0x00, 0x49, 0x43, 0x45, 0x4c,
+    0x41, 0x4e, 0x44, 0x00, 0x49, 0x4e, 0x44, 0x49, 0x41, 0x00, 0x49, 0x4e,
+    0x44, 0x4f, 0x4e, 0x45, 0x53, 0x49, 0x41, 0x00, 0x49, 0x52, 0x41, 0x51,
+    0x00, 0x49, 0x52, 0x45, 0x4c, 0x41, 0x4e, 0x44, 0x00, 0x49, 0x53, 0x4c,
+    0x45, 0x20, 0x4f, 0x46, 0x20, 0x4d, 0x41, 0x4e, 0x00, 0x49, 0x53, 0x52,
+    0x41, 0x45, 0x4c, 0x00, 0x49, 0x54, 0x41, 0x4c, 0x59, 0x00, 0x4a, 0x41,
+    0x4d, 0x41, 0x49, 0x43, 0x41, 0x00, 0x4a, 0x41, 0x50, 0x41, 0x4e, 0x00,
+    0x4a, 0x45, 0x52, 0x53, 0x45, 0x59, 0x00, 0x4a, 0x4f, 0x52, 0x44, 0x41,
+    0x4e, 0x00, 0x4b, 0x41, 0x5a, 0x41, 0x4b, 0x48, 0x53, 0x54, 0x41, 0x4e,
+    0x00, 0x4b, 0x45, 0x4e, 0x59, 0x41, 0x00, 0x4b, 0x49, 0x52, 0x49, 0x42,
+    0x41, 0x54, 0x49, 0x00, 0x4b, 0x4f, 0x52, 0x45, 0x41, 0x2c, 0x20, 0x52,
+    0x45, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x43, 0x20, 0x4f, 0x46, 0x00, 0x4b,
+    0x55, 0x57, 0x41, 0x49, 0x54, 0x00, 0x4b, 0x59, 0x52, 0x47, 0x59, 0x5a,
+    0x53, 0x54, 0x41, 0x4e, 0x00, 0x4c, 0x41, 0x54, 0x56, 0x49, 0x41, 0x00,
+    0x4c, 0x45, 0x42, 0x41, 0x4e, 0x4f, 0x4e, 0x00, 0x4c, 0x45, 0x53, 0x4f,
+    0x54, 0x48, 0x4f, 0x00, 0x4c, 0x49, 0x42, 0x45, 0x52, 0x49, 0x41, 0x00,
+    0x4c, 0x49, 0x45, 0x43, 0x48, 0x54, 0x45, 0x4e, 0x53, 0x54, 0x45, 0x49,
+    0x4e, 0x00, 0x4c, 0x49, 0x54, 0x48, 0x55, 0x41, 0x4e, 0x49, 0x41, 0x00,
+    0x4c, 0x55, 0x58, 0x45, 0x4d, 0x42, 0x4f, 0x55, 0x52, 0x47, 0x00, 0x4d,
+    0x41, 0x43, 0x41, 0x4f, 0x00, 0x4d, 0x41, 0x44, 0x41, 0x47, 0x41, 0x53,
+    0x43, 0x41, 0x52, 0x00, 0x4d, 0x41, 0x4c, 0x41, 0x57, 0x49, 0x00, 0x4d,
+    0x41, 0x4c, 0x41, 0x59, 0x53, 0x49, 0x41, 0x00, 0x4d, 0x41, 0x4c, 0x44,
+    0x49, 0x56, 0x45, 0x53, 0x00, 0x4d, 0x41, 0x4c, 0x49, 0x00, 0x4d, 0x41,
+    0x4c, 0x54, 0x41, 0x00, 0x4d, 0x41, 0x52, 0x53, 0x48, 0x41, 0x4c, 0x4c,
+    0x20, 0x49, 0x53, 0x4c, 0x41, 0x4e, 0x44, 0x53, 0x00, 0x4d, 0x41, 0x52,
+    0x54, 0x49, 0x4e, 0x49, 0x51, 0x55, 0x45, 0x00, 0x4d, 0x41, 0x55, 0x52,
+    0x49, 0x54, 0x41, 0x4e, 0x49, 0x41, 0x00, 0x4d, 0x41, 0x55, 0x52, 0x49,
+    0x54, 0x49, 0x55, 0x53, 0x00, 0x4d, 0x41, 0x59, 0x4f, 0x54, 0x54, 0x45,
+    0x00, 0x4d, 0x45, 0x58, 0x49, 0x43, 0x4f, 0x00, 0x4d, 0x4f, 0x4c, 0x44,
+    0x4f, 0x56, 0x41, 0x2c, 0x20, 0x52, 0x45, 0x50, 0x55, 0x42, 0x4c, 0x49,
+    0x43, 0x20, 0x4f, 0x46, 0x00, 0x4d, 0x4f, 0x4e, 0x41, 0x43, 0x4f, 0x00,
+    0x4d, 0x4f, 0x4e, 0x47, 0x4f, 0x4c, 0x49, 0x41, 0x00, 0x4d, 0x4f, 0x4e,
+    0x54, 0x45, 0x4e, 0x45, 0x47, 0x52, 0x4f, 0x00, 0x4d, 0x4f, 0x4e, 0x54,
+    0x53, 0x45, 0x52, 0x52, 0x41, 0x54, 0x00, 0x4d, 0x4f, 0x52, 0x4f, 0x43,
+    0x43, 0x4f, 0x00, 0x4d, 0x4f, 0x5a, 0x41, 0x4d, 0x42, 0x49, 0x51, 0x55,
+    0x45, 0x00, 0x4d, 0x59, 0x41, 0x4e, 0x4d, 0x41, 0x52, 0x00, 0x4e, 0x41,
+    0x4d, 0x49, 0x42, 0x49, 0x41, 0x00, 0x4e, 0x41, 0x55, 0x52, 0x55, 0x00,
+    0x4e, 0x45, 0x50, 0x41, 0x4c, 0x00, 0x4e, 0x45, 0x54, 0x48, 0x45, 0x52,
+    0x4c, 0x41, 0x4e, 0x44, 0x53, 0x00, 0x4e, 0x45, 0x54, 0x48, 0x45, 0x52,
+    0x4c, 0x41, 0x4e, 0x44, 0x53, 0x20, 0x41, 0x4e, 0x54, 0x49, 0x4c, 0x4c,
+    0x45, 0x53, 0x00, 0x4e, 0x45, 0x57, 0x20, 0x43, 0x41, 0x4c, 0x45, 0x44,
+    0x4f, 0x4e, 0x49, 0x41, 0x00, 0x4e, 0x45, 0x57, 0x20, 0x5a, 0x45, 0x41,
+    0x4c, 0x41, 0x4e, 0x44, 0x00, 0x4e, 0x49, 0x43, 0x41, 0x52, 0x41, 0x47,
+    0x55, 0x41, 0x00, 0x4e, 0x49, 0x47, 0x45, 0x52, 0x00, 0x4e, 0x49, 0x47,
+    0x45, 0x52, 0x49, 0x41, 0x00, 0x4e, 0x49, 0x55, 0x45, 0x00, 0x4e, 0x4f,
+    0x52, 0x46, 0x4f, 0x4c, 0x4b, 0x20, 0x49, 0x53, 0x4c, 0x41, 0x4e, 0x44,
+    0x00, 0x4e, 0x4f, 0x52, 0x57, 0x41, 0x59, 0x00, 0x4f, 0x4d, 0x41, 0x4e,
+    0x00, 0x50, 0x41, 0x4b, 0x49, 0x53, 0x54, 0x41, 0x4e, 0x00, 0x50, 0x41,
+    0x4c, 0x41, 0x55, 0x00, 0x50, 0x41, 0x4e, 0x41, 0x4d, 0x41, 0x00, 0x50,
+    0x41, 0x50, 0x55, 0x41, 0x20, 0x4e, 0x45, 0x57, 0x20, 0x47, 0x55, 0x49,
+    0x4e, 0x45, 0x41, 0x00, 0x50, 0x41, 0x52, 0x41, 0x47, 0x55, 0x41, 0x59,
+    0x00, 0x50, 0x45, 0x52, 0x55, 0x00, 0x50, 0x48, 0x49, 0x4c, 0x49, 0x50,
+    0x50, 0x49, 0x4e, 0x45, 0x53, 0x00, 0x50, 0x49, 0x54, 0x43, 0x41, 0x49,
+    0x52, 0x4e, 0x00, 0x50, 0x4f, 0x4c, 0x41, 0x4e, 0x44, 0x00, 0x50, 0x4f,
+    0x52, 0x54, 0x55, 0x47, 0x41, 0x4c, 0x00, 0x50, 0x55, 0x45, 0x52, 0x54,
+    0x4f, 0x20, 0x52, 0x49, 0x43, 0x4f, 0x00, 0x51, 0x41, 0x54, 0x41, 0x52,
+    0x00, 0x52, 0xc3, 0x89, 0x55, 0x4e, 0x49, 0x4f, 0x4e, 0x00, 0x52, 0x4f,
+    0x4d, 0x41, 0x4e, 0x49, 0x41, 0x00, 0x52, 0x55, 0x53, 0x53, 0x49, 0x41,
+    0x4e, 0x20, 0x46, 0x45, 0x44, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e,
+    0x00, 0x52, 0x57, 0x41, 0x4e, 0x44, 0x41, 0x00, 0x53, 0x41, 0x49, 0x4e,
+    0x54, 0x20, 0x48, 0x45, 0x4c, 0x45, 0x4e, 0x41, 0x00, 0x53, 0x41, 0x49,
+    0x4e, 0x54, 0x20, 0x4c, 0x55, 0x43, 0x49, 0x41, 0x00, 0x53, 0x41, 0x4d,
+    0x4f, 0x41, 0x00, 0x53, 0x41, 0x4e, 0x20, 0x4d, 0x41, 0x52, 0x49, 0x4e,
+    0x4f, 0x00, 0x53, 0x41, 0x55, 0x44, 0x49, 0x20, 0x41, 0x52, 0x41, 0x42,
+    0x49, 0x41, 0x00, 0x53, 0x45, 0x4e, 0x45, 0x47, 0x41, 0x4c, 0x00, 0x53,
+    0x45, 0x52, 0x42, 0x49, 0x41, 0x00, 0x53, 0x45, 0x59, 0x43, 0x48, 0x45,
+    0x4c, 0x4c, 0x45, 0x53, 0x00, 0x53, 0x49, 0x45, 0x52, 0x52, 0x41, 0x20,
+    0x4c, 0x45, 0x4f, 0x4e, 0x45, 0x00, 0x53, 0x49, 0x4e, 0x47, 0x41, 0x50,
+    0x4f, 0x52, 0x45, 0x00, 0x53, 0x4c, 0x4f, 0x56, 0x41, 0x4b, 0x49, 0x41,
+    0x00, 0x53, 0x4c, 0x4f, 0x56, 0x45, 0x4e, 0x49, 0x41, 0x00, 0x53, 0x4f,
+    0x4c, 0x4f, 0x4d, 0x4f, 0x4e, 0x20, 0x49, 0x53, 0x4c, 0x41, 0x4e, 0x44,
+    0x53, 0x00, 0x53, 0x4f, 0x4d, 0x41, 0x4c, 0x49, 0x41, 0x00, 0x53, 0x4f,
+    0x55, 0x54, 0x48, 0x20, 0x41, 0x46, 0x52, 0x49, 0x43, 0x41, 0x00, 0x53,
+    0x50, 0x41, 0x49, 0x4e, 0x00, 0x53, 0x52, 0x49, 0x20, 0x4c, 0x41, 0x4e,
+    0x4b, 0x41, 0x00, 0x53, 0x55, 0x44, 0x41, 0x4e, 0x00, 0x53, 0x55, 0x52,
+    0x49, 0x4e, 0x41, 0x4d, 0x45, 0x00, 0x53, 0x57, 0x41, 0x5a, 0x49, 0x4c,
+    0x41, 0x4e, 0x44, 0x00, 0x53, 0x57, 0x45, 0x44, 0x45, 0x4e, 0x00, 0x53,
+    0x57, 0x49, 0x54, 0x5a, 0x45, 0x52, 0x4c, 0x41, 0x4e, 0x44, 0x00, 0x53,
+    0x59, 0x52, 0x49, 0x41, 0x4e, 0x20, 0x41, 0x52, 0x41, 0x42, 0x20, 0x52,
+    0x45, 0x50, 0x55, 0x42, 0x4c, 0x49, 0x43, 0x00, 0x54, 0x41, 0x4a, 0x49,
+    0x4b, 0x49, 0x53, 0x54, 0x41, 0x4e, 0x00, 0x54, 0x48, 0x41, 0x49, 0x4c,
+    0x41, 0x4e, 0x44, 0x00, 0x54, 0x49, 0x4d, 0x4f, 0x52, 0x2d, 0x4c, 0x45,
+    0x53, 0x54, 0x45, 0x00, 0x54, 0x4f, 0x47, 0x4f, 0x00, 0x54, 0x4f, 0x4b,
+    0x45, 0x4c, 0x41, 0x55, 0x00, 0x54, 0x4f, 0x4e, 0x47, 0x41, 0x00, 0x54,
+    0x52, 0x49, 0x4e, 0x49, 0x44, 0x41, 0x44, 0x20, 0x41, 0x4e, 0x44, 0x20,
+    0x54, 0x4f, 0x42, 0x41, 0x47, 0x4f, 0x00, 0x54, 0x55, 0x4e, 0x49, 0x53,
+    0x49, 0x41, 0x00, 0x54, 0x55, 0x52, 0x4b, 0x45, 0x59, 0x00, 0x54, 0x55,
+    0x52, 0x4b, 0x4d, 0x45, 0x4e, 0x49, 0x53, 0x54, 0x41, 0x4e, 0x00, 0x54,
+    0x55, 0x56, 0x41, 0x4c, 0x55, 0x00, 0x55, 0x47, 0x41, 0x4e, 0x44, 0x41,
+    0x00, 0x55, 0x4b, 0x52, 0x41, 0x49, 0x4e, 0x45, 0x00, 0x55, 0x4e, 0x49,
+    0x54, 0x45, 0x44, 0x20, 0x41, 0x52, 0x41, 0x42, 0x20, 0x45, 0x4d, 0x49,
+    0x52, 0x41, 0x54, 0x45, 0x53, 0x00, 0x55, 0x4e, 0x49, 0x54, 0x45, 0x44,
+    0x20, 0x4b, 0x49, 0x4e, 0x47, 0x44, 0x4f, 0x4d, 0x00, 0x55, 0x4e, 0x49,
+    0x54, 0x45, 0x44, 0x20, 0x53, 0x54, 0x41, 0x54, 0x45, 0x53, 0x00, 0x55,
+    0x52, 0x55, 0x47, 0x55, 0x41, 0x59, 0x00, 0x55, 0x5a, 0x42, 0x45, 0x4b,
+    0x49, 0x53, 0x54, 0x41, 0x4e, 0x00, 0x56, 0x41, 0x4e, 0x55, 0x41, 0x54,
+    0x55, 0x00, 0x56, 0x45, 0x4e, 0x45, 0x5a, 0x55, 0x45, 0x4c, 0x41, 0x00,
+    0x56, 0x49, 0x45, 0x54, 0x20, 0x4e, 0x41, 0x4d, 0x00, 0x56, 0x49, 0x52,
+    0x47, 0x49, 0x4e, 0x20, 0x49, 0x53, 0x4c, 0x41, 0x4e, 0x44, 0x53, 0x2c,
+    0x20, 0x55, 0x2e, 0x53, 0x2e, 0x00, 0x57, 0x41, 0x4c, 0x4c, 0x49, 0x53,
+    0x20, 0x41, 0x4e, 0x44, 0x20, 0x46, 0x55, 0x54, 0x55, 0x4e, 0x41, 0x00,
+    0x57, 0x45, 0x53, 0x54, 0x45, 0x52, 0x4e, 0x20, 0x53, 0x41, 0x48, 0x41,
+    0x52, 0x41, 0x00, 0x59, 0x45, 0x4d, 0x45, 0x4e, 0x00, 0x5a, 0x41, 0x4d,
+    0x42, 0x49, 0x41, 0x00, 0x5a, 0x49, 0x4d, 0x42, 0x41, 0x42, 0x57, 0x45,
+    0x00, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x8d, 0x1a, 0x00, 0x00, 0x14,
+    0x2b, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x19, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x01, 0xcf, 0xeb, 0x00, 0x00, 0x8d, 0xf0, 0x00, 0x00, 0x13,
+    0x88, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x61, 0x6c, 0x65, 0x6e, 0x64, 0x61, 0x72, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x02, 0xfa, 0x1f, 0x00, 0x00, 0x2a, 0xc0, 0x00, 0x00, 0x01,
+    0x6e, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x8f, 0x77, 0x65, 0x65, 0x6b, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x03, 0x8c, 0x7e, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x00, 0x66, 0x69, 0x70, 0x73, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x79,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x03, 0x8d, 0x4f, 0x00, 0x01, 0xcd, 0x04, 0x00, 0x00, 0x0c,
+    0x24, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
+    0x41, 0x73, 0x74, 0x72, 0x65, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
+    0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x07, 0xa1, 0x6c, 0x00, 0x00, 0x02, 0x52, 0x00, 0x00, 0x00,
+    0x5b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x74, 0x72, 0x65, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x07, 0xa8, 0x06, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x61, 0x64, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x73, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x08, 0x00, 0x07, 0xa9, 0x12, 0x00, 0x00, 0x1e, 0x59, 0x00, 0x00, 0x03,
+    0xa6, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x61, 0x64, 0x76, 0x65, 0x72, 0x62, 0x73, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x09, 0x00, 0x07, 0xe4, 0x9f, 0x00, 0x00, 0x21, 0xb0, 0x00, 0x00, 0x03,
+    0x9e, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x61, 0x72, 0x74, 0x69, 0x63, 0x6c, 0x65, 0x73, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x08, 0x23, 0x43, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x6e, 0x6f, 0x75, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0b, 0x00, 0x08, 0x23, 0x81, 0x00, 0x00, 0x21, 0x4e, 0x00, 0x00, 0x03,
+    0xe1, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x70, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+    0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x08, 0x63, 0xdb, 0x00, 0x00, 0x08, 0x20, 0x00, 0x00, 0x00,
+    0xd8, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x76, 0x65, 0x72, 0x62, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0d, 0x00, 0x08, 0x72, 0xbf, 0x00, 0x00, 0x29, 0x5c, 0x00, 0x00, 0x05,
+    0xc6, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x61, 0x75, 0x78, 0x69, 0x6c, 0x69, 0x61, 0x72, 0x69, 0x65, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0e, 0x00, 0x08, 0xca, 0x4f, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x74, 0x65, 0x72, 0x6d, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x08, 0xcb, 0x89, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x65, 0x6e, 0x74, 0x65, 0x6e, 0x63, 0x65, 0x73, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x08, 0xcb, 0xb1, 0x00, 0x00, 0x05, 0x3a, 0x00, 0x00, 0x00,
+    0x60, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x79, 0x6c, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x11, 0x00, 0x08, 0xd3, 0xef, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x69, 0x74, 0x69, 0x65, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x12, 0x00, 0x08, 0xd4, 0x75, 0x00, 0x00, 0x23, 0xac, 0x00, 0x00, 0x03,
+    0xe8, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x2d, 0x63, 0x61, 0x74, 0x65, 0x67, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x13, 0x00, 0x09, 0x65, 0xb2, 0x00, 0x00, 0x00, 0xd6, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x00, 0x77, 0x6f, 0x6d, 0x65, 0x6e, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x09, 0x67, 0x34, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x6d, 0x65, 0x6e, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x09, 0x67, 0x9a, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e, 0x5f, 0x63, 0x6c,
+    0x61, 0x73, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x16, 0x00, 0x09, 0x68, 0x02, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x68, 0x6f, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x17, 0x00, 0x09, 0x68, 0x6b, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x6d, 0x75, 0x73, 0x69, 0x63, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x09, 0x68, 0xc5, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x6a, 0x65, 0x77, 0x65, 0x6c, 0x72, 0x79, 0x5f, 0x63, 0x6c, 0x61,
+    0x73, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x19, 0x00, 0x09, 0x69, 0x20, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x68, 0x6f, 0x6d, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x1a, 0x00, 0x09, 0x6a, 0xa1, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x1b, 0x00, 0x09, 0x6c, 0x27, 0x00, 0x00, 0x00, 0xb1, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x62, 0x6f, 0x6f, 0x6b, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x1c, 0x00, 0x09, 0x6d, 0xa0, 0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x72, 0x6f, 0x6e, 0x69, 0x63, 0x5f,
+    0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x1d, 0x00, 0x09, 0x6f, 0x27, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x00, 0x00,
+    0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x69, 0x7a, 0x65, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x09, 0x70, 0xb5, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x75, 0x6e, 0x69, 0x74, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x1f, 0x00, 0x09, 0x71, 0x5b, 0x00, 0x00, 0x00, 0x6d, 0x00, 0x00, 0x00,
+    0x15, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x20, 0x00, 0x09, 0x72, 0x74, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x21, 0x00, 0x09, 0x72, 0x88, 0x00, 0x00, 0x02, 0x6d, 0x00, 0x00, 0x00,
+    0x5c, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x24, 0x62, 0x72, 0x61, 0x6e, 0x64, 0x5f, 0x73, 0x79, 0x6c, 0x6c, 0x61,
+    0x62, 0x6c, 0x65, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x22, 0x00, 0x09, 0x7d, 0xbd, 0x00, 0x00, 0x00, 0x45, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x69, 0x5f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x70,
+    0x72, 0x69, 0x63, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x23, 0x00, 0x09, 0x7e, 0x56, 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x30, 0x69, 0x5f, 0x6d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74, 0x5f,
+    0x69, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x09, 0x7f, 0x0c, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x00, 0x69, 0x5f, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x72, 0x5f, 0x69,
+    0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x25, 0x00, 0x09, 0x7f, 0x89, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x00, 0x72, 0x6f, 0x77, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x26, 0x00, 0x09, 0x80, 0x01, 0x00, 0x00, 0x04, 0xb3, 0x00, 0x00, 0x00,
+    0x47, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+    0x00, 0x67, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x27, 0x00, 0x09, 0x93, 0x2c, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x6d, 0x61, 0x72, 0x69, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x61,
+    0x74, 0x75, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x28, 0x00, 0x09, 0x93, 0x44, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x65, 0x64, 0x75, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x29, 0x00, 0x09, 0x93, 0x7a, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x70, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x5f, 0x62, 0x61,
+    0x6e, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2a, 0x00, 0x09, 0x94, 0x54, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x62, 0x75, 0x79, 0x5f, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x69,
+    0x61, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2b, 0x00, 0x09, 0x95, 0x5c, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x5f, 0x72, 0x61, 0x74, 0x69,
+    0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2c, 0x00, 0x09, 0x95, 0xc3, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x65, 0x5f, 0x62, 0x61, 0x6e, 0x64,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2d, 0x00, 0x09, 0x96, 0x07, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x74, 0x5f, 0x63,
+    0x6f, 0x75, 0x6e, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2e, 0x00, 0x09, 0x98, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+    0x0a, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x76, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x5f, 0x63, 0x6f, 0x75,
+    0x6e, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x2f, 0x00, 0x09, 0x98, 0x68, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x70, 0x72, 0x6f, 0x6d, 0x6f, 0x5f, 0x70, 0x75, 0x72, 0x70, 0x6f,
+    0x73, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x30, 0x00, 0x09, 0x98, 0xa9, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x5f, 0x72, 0x65, 0x61, 0x73,
+    0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x31, 0x00, 0x09, 0x98, 0xbd, 0x00, 0x00, 0x03, 0xf5, 0x00, 0x00, 0x00,
+    0x4b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x32, 0x00, 0x09, 0x9f, 0x0e, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
+    0x00, 0x67, 0x65, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x79, 0x5f, 0x63,
+    0x6c, 0x61, 0x73, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x33, 0x00, 0x09, 0x9f, 0x77, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x64, 0x69, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x34, 0x00, 0x09, 0x9f, 0x8b, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x35, 0x00, 0x09, 0x9f, 0x9f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x68, 0x6f, 0x75, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x36, 0x00, 0x09, 0x9f, 0xb3, 0x00, 0x00, 0x02, 0x39, 0x00, 0x00, 0x00,
+    0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72,
+    0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x37, 0x00, 0x09, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x96, 0x00, 0x00, 0x00,
+    0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72,
+    0x5f, 0x68, 0x6f, 0x75, 0x72, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x38, 0x00, 0x09, 0xa6, 0x2a, 0x00, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72,
+    0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x39, 0x00, 0x09, 0xa6, 0x77, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x61, 0x6c, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x3a, 0x00, 0x09, 0xa6, 0xa6, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x68, 0x69, 0x70, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x5f, 0x63,
+    0x6f, 0x64, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x3b, 0x00, 0x09, 0xa7, 0x24, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x68, 0x69, 0x70, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x5f, 0x74,
+    0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x3c, 0x00, 0x09, 0xa7, 0x92, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00,
+    0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x73, 0x68, 0x69, 0x70, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x5f, 0x63,
+    0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x3d, 0x00, 0x09, 0xa7, 0xf9, 0x00, 0x00, 0x00, 0x99, 0x00, 0x00, 0x00,
+    0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x77, 0x65, 0x62, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x75, 0x73,
+    0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x3e, 0x00, 0x09, 0xa9, 0x36, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x77, 0x65, 0x62, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79,
+    0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x3f, 0x00, 0x09, 0xa9, 0xa6, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00,
+    0x0f, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x5f, 0x70, 0x61, 0x67,
+    0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x40, 0x00, 0x09, 0xaa, 0x5e, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79,
+    0x70, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x41, 0x00, 0x09, 0xaa, 0xa2, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x74, 0x6f, 0x70, 0x5f, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x42, 0x00, 0x09, 0xaa, 0xe8, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x43, 0x00, 0x09, 0xab, 0x10, 0x00, 0x00, 0x08, 0x05, 0x00, 0x00, 0x00,
+    0xd4, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+    0x00};
+unsigned int tpcds_idx_len = 640585;
diff --git a/velox/tpcds/gen/dsdgen/include/w_call_center.h b/velox/tpcds/gen/dsdgen/include/w_call_center.h
new file mode 100644
index 000000000000..70eb393609a3
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_call_center.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_CALL_CENTER_H
+#define W_CALL_CENTER_H
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+
+#define MIN_CC_TAX_PERCENTAGE "0.00"
+#define MAX_CC_TAX_PERCENTAGE "0.12"
+
+int mk_w_call_center(
+    void* pDest,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+int pr_w_call_center(void* pSrc);
+int ld_w_call_center(void* r);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_catalog_page.h b/velox/tpcds/gen/dsdgen/include/w_catalog_page.h
new file mode 100644
index 000000000000..1157d978f604
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_catalog_page.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef CATALOG_PAGE_H
+#define CATALOG_PAGE_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_catalog_page(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_catalog_returns.h b/velox/tpcds/gen/dsdgen/include/w_catalog_returns.h
new file mode 100644
index 000000000000..aa75a8dbefda
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_catalog_returns.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_CATALOG_RETURNS_H
+#define W_CATALOG_RETURNS_H
+
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+
+int mk_w_catalog_returns(
+    void* row,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_catalog_sales.h b/velox/tpcds/gen/dsdgen/include/w_catalog_sales.h
new file mode 100644
index 000000000000..dce335d5cd07
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_catalog_sales.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_CATALOG_SALES_H
+#define W_CATALOG_SALES_H
+
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+
+int mk_w_catalog_sales(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext);
+int vld_w_catalog_sales(
+    int nTable,
+    ds_key_t kRow,
+    int* Permutation,
+    DSDGenContext& dsdGenContext);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_customer.h b/velox/tpcds/gen/dsdgen/include/w_customer.h
new file mode 100644
index 000000000000..252f34fffe54
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_customer.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_CUSTOMER_H
+#define W_CUSTOMER_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_customer(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_customer_address.h b/velox/tpcds/gen/dsdgen/include/w_customer_address.h
new file mode 100644
index 000000000000..81c14affe7fa
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_customer_address.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_CUSTOMER_ADDRESS_H
+#define W_CUSTOMER_ADDRESS_H
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_customer_address(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_customer_demographics.h b/velox/tpcds/gen/dsdgen/include/w_customer_demographics.h
new file mode 100644
index 000000000000..e5db58c6b5f4
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_customer_demographics.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_CUSTOMER_DEMOGRAPHICS_H
+#define W_CUSTOMER_DEMOGRAPHICS_H
+
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+/***
+*** CD_xxx Customer Demographcis Defines
+***/
+#define CD_MAX_CHILDREN 7
+#define CD_MAX_EMPLOYED 7
+#define CD_MAX_COLLEGE 7
+
+int mk_w_customer_demographics(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_datetbl.h b/velox/tpcds/gen/dsdgen/include/w_datetbl.h
new file mode 100644
index 000000000000..fcdad6159db5
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_datetbl.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+/*
+ * DATE table structure
+ */
+#ifndef W_DATETBL_H
+#define W_DATETBL_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/dist.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/porting.h" // @manual
+
+int mk_w_date(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
+
+int vld_w_date(
+    int nTable,
+    ds_key_t kRow,
+    int* Permutation,
+    DSDGenContext& dsdGenContext);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_household_demographics.h b/velox/tpcds/gen/dsdgen/include/w_household_demographics.h
new file mode 100644
index 000000000000..e3b2ef026a63
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_household_demographics.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_HOUSEHOLD_DEMOGRAPHICS_H
+#define W_HOUSEHOLD_DEMOGRAPHICS_H
+
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_household_demographics(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_income_band.h b/velox/tpcds/gen/dsdgen/include/w_income_band.h
new file mode 100644
index 000000000000..9856cbc85d10
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_income_band.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_income_band(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/include/w_inventory.h b/velox/tpcds/gen/dsdgen/include/w_inventory.h
new file mode 100644
index 000000000000..705b1978fb68
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_inventory.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_inventory(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+
+ds_key_t sc_w_inventory(int nScale, DSDGenContext& dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/include/w_item.h b/velox/tpcds/gen/dsdgen/include/w_item.h
new file mode 100644
index 000000000000..375cf5ee6655
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_item.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_ITEM_H
+#define W_ITEM_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+#define I_PROMO_PERCENTAGE \
+  20 /* percent of items that have associated promotions */
+#define MIN_ITEM_MARKDOWN_PCT "0.30"
+#define MAX_ITEM_MARKDOWN_PCT "0.90"
+
+int mk_w_item(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
+int vld_w_item(
+    int nTable,
+    ds_key_t kRow,
+    int* Permutation,
+    DSDGenContext& dsdGenContext);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_promotion.h b/velox/tpcds/gen/dsdgen/include/w_promotion.h
new file mode 100644
index 000000000000..f38a275f647c
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_promotion.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_PROMOTION_H
+#define W_PROMOTION_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_promotion(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_reason.h b/velox/tpcds/gen/dsdgen/include/w_reason.h
new file mode 100644
index 000000000000..71b2257fc6b2
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_reason.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_REASON_H
+#define W_REASON_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_reason(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_ship_mode.h b/velox/tpcds/gen/dsdgen/include/w_ship_mode.h
new file mode 100644
index 000000000000..6c118e7b1cd6
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_ship_mode.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_SHIP_MODE_H
+#define W_SHIP_MODE_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_ship_mode(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_store.h b/velox/tpcds/gen/dsdgen/include/w_store.h
new file mode 100644
index 000000000000..3c445ef57155
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_store.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_STORE_H
+#define W_STORE_H
+
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+
+int mk_w_store(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_store_returns.h b/velox/tpcds/gen/dsdgen/include/w_store_returns.h
new file mode 100644
index 000000000000..6047b97e2fe1
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_store_returns.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_STORE_RETURNS_H
+#define W_STORE_RETURNS_H
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+
+#define SR_SAME_CUSTOMER 80
+
+int mk_w_store_returns(
+    void* row,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_store_sales.h b/velox/tpcds/gen/dsdgen/include/w_store_sales.h
new file mode 100644
index 000000000000..5affc56f4c72
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_store_sales.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_STORE_SALES_H
+#define W_STORE_SALES_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+
+int mk_w_store_sales(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+int vld_w_store_sales(
+    int nTable,
+    ds_key_t kRow,
+    int* Permutation,
+    DSDGenContext& dsdGenContext);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_timetbl.h b/velox/tpcds/gen/dsdgen/include/w_timetbl.h
new file mode 100644
index 000000000000..685c76e2160f
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_timetbl.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+/*
+ * TIME table structure
+ */
+#ifndef W_TIME_TBL_H
+#define W_TIME_TBL_H
+
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_time(void* info_arr, ds_key_t kIndex, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_warehouse.h b/velox/tpcds/gen/dsdgen/include/w_warehouse.h
new file mode 100644
index 000000000000..34dd34044cd3
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_warehouse.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_WAREHOUSE_H
+#define W_WAREHOUSE_H
+
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_warehouse(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_web_page.h b/velox/tpcds/gen/dsdgen/include/w_web_page.h
new file mode 100644
index 000000000000..b2da00a57893
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_web_page.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+int mk_w_web_page(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/include/w_web_returns.h b/velox/tpcds/gen/dsdgen/include/w_web_returns.h
new file mode 100644
index 000000000000..7414cea0eb4c
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_web_returns.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#ifndef W_WEB_RETURNS_H
+#define W_WEB_RETURNS_H
+
+int mk_w_web_returns(void* row, ds_key_t kIndex, DSDGenContext& dsdGenContext);
+
+#endif
diff --git a/velox/tpcds/gen/dsdgen/include/w_web_sales.h b/velox/tpcds/gen/dsdgen/include/w_web_sales.h
new file mode 100644
index 000000000000..929c12323d48
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_web_sales.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+
+/***
+*** WS_xxx Web Sales Defines
+***/
+#define WS_QUANTITY_MAX "100"
+#define WS_MARKUP_MAX "2.00"
+#define WS_DISCOUNT_MAX "1.00"
+#define WS_WHOLESALE_MAX "100.00"
+#define WS_COUPON_MAX "0.50"
+#define WS_GIFT_PCT                                         \
+  7 /* liklihood that a purchase is shipped to someone else \
+     */
+#define WS_ITEMS_PER_ORDER 9 /* number of lineitems in an order */
+#define WS_MIN_SHIP_DELAY 1 /* time between order date and ship date */
+#define WS_MAX_SHIP_DELAY 120
+
+int mk_w_web_sales(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+int vld_web_sales(
+    int nTable,
+    ds_key_t kRow,
+    int* Permutation,
+    DSDGenContext& dsdGenContext);
diff --git a/velox/tpcds/gen/dsdgen/include/w_web_site.h b/velox/tpcds/gen/dsdgen/include/w_web_site.h
new file mode 100644
index 000000000000..dba1660271ae
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/include/w_web_site.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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.
+ */
+
+#ifndef W_WEB_SITE_H
+#define W_WEB_SITE_H
+
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+
+#define WEB_MIN_TAX_PERCENTAGE "0.00"
+#define WEB_MAX_TAX_PERCENTAGE "0.12"
+
+int mk_w_web_site(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext);
+#endif
diff --git a/velox/tpcds/gen/dsdgen/join.cpp b/velox/tpcds/gen/dsdgen/join.cpp
new file mode 100644
index 000000000000..de2e8d58088f
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/join.cpp
@@ -0,0 +1,469 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/sparse.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/tpcds.idx.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
+
+ds_key_t web_join(int col, ds_key_t join_key, DSDGenContext& dsdGenContext);
+
+/*
+ * Routine: date_join(int from_tbl, int join_count)
+ * Purpose: account for the different date-adjusted patterns in the data set
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: Relies on existing RNG code, which isn't really 64bit; will probably
+ * requre a rework of the genrand_xx routines
+ */
+static ds_key_t date_join(
+    int from_tbl,
+    int from_col,
+    ds_key_t join_count,
+    int nYear,
+    DSDGenContext& dsdGenContext) {
+  int nDay, nTemp, nMin = -1, nMax = -1, nResult;
+  int jToday;
+  date_t TempDate;
+
+  strtodt(&TempDate, TODAYS_DATE);
+  jToday = dttoj(&TempDate);
+
+  switch (from_tbl) {
+    case STORE_SALES:
+    case CATALOG_SALES:
+    case WEB_SALES:
+      pick_distribution(
+          &nDay,
+          "calendar",
+          1,
+          calendar_sales + is_leap(nYear),
+          from_col,
+          dsdGenContext);
+      break;
+
+    /*
+     * returns are keyed to the sale date, with the lag between sale and return
+     * selected within a known range, based on sales channel
+     */
+    case STORE_RETURNS:
+      nMin = SS_MIN_SHIP_DELAY;
+      nMax = SS_MAX_SHIP_DELAY;
+    case CATALOG_RETURNS:
+      if (nMin == -1) {
+        nMin = CS_MIN_SHIP_DELAY;
+        nMax = CS_MAX_SHIP_DELAY;
+      }
+    case WEB_RETURNS:
+      if (nMin == -1) {
+        nMin = WS_MIN_SHIP_DELAY;
+        nMax = WS_MAX_SHIP_DELAY;
+      }
+      genrand_integer(
+          &nTemp, DIST_UNIFORM, nMin * 2, nMax * 2, 0, from_col, dsdGenContext);
+      return (join_count + nTemp);
+    case WEB_SITE:
+    case WEB_PAGE:
+      return (web_join(from_col, join_count, dsdGenContext));
+    default:
+      pick_distribution(
+          &nDay, "calendar", 1, 1 + is_leap(nYear), from_col, dsdGenContext);
+      break;
+  }
+
+  TempDate.year = nYear;
+  TempDate.month = 1;
+  TempDate.day = 1;
+
+  nResult = dttoj(&TempDate) + nDay;
+
+  return (static_cast<ds_key_t>(nResult > jToday) ? -1 : nResult);
+}
+
+/*
+ * Routine: time_join(int from_tbl, int join_count)
+ * Purpose: create joins that are time-skewed
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: Relies on existing RNG code, which isn't really 64bit; will probably
+ * requre a rework of the genrand_xx routines
+ */
+ds_key_t time_join(
+    int to_tbl,
+    int to_col,
+    ds_key_t join_count,
+    DSDGenContext& dsdGenContext) {
+  int hour, secs;
+
+  switch (to_tbl) {
+    case STORE_SALES:
+    case STORE_RETURNS:
+      pick_distribution(&hour, "hours", 1, 2, to_col, dsdGenContext);
+      break;
+    case CATALOG_SALES:
+    case WEB_SALES:
+    case CATALOG_RETURNS:
+    case WEB_RETURNS:
+      pick_distribution(&hour, "hours", 1, 3, to_col, dsdGenContext);
+      break;
+    default:
+      pick_distribution(&hour, "hours", 1, 1, to_col, dsdGenContext);
+      break;
+  }
+  genrand_integer(&secs, DIST_UNIFORM, 0, 3599, 0, to_col, dsdGenContext);
+
+  return (static_cast<ds_key_t>(hour * 3600 + secs));
+}
+
+/*
+ * Routine: cp_join(int from_tbl, int join_count)
+ * Purpose: create joins to catalog_page
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+static ds_key_t
+cp_join(int tbl, int col, ds_key_t jDate, DSDGenContext& dsdGenContext) {
+  ds_key_t res;
+  static int nPagePerCatalog;
+  int nType, nCount, nOffset, nPage;
+  static date_t dTemp;
+  char* szTemp = nullptr;
+
+  if (!dsdGenContext.cp_join_init) {
+    nPagePerCatalog =
+        (static_cast<int>(get_rowcount(CATALOG_PAGE, dsdGenContext)) /
+         CP_CATALOGS_PER_YEAR) /
+        (YEAR_MAXIMUM - YEAR_MINIMUM + 2);
+    strtodt(&dTemp, DATA_START_DATE);
+    dsdGenContext.cp_join_init = 1;
+  }
+
+  nType =
+      pick_distribution(&szTemp, "catalog_page_type", 1, 2, col, dsdGenContext);
+  genrand_integer(
+      &nPage, DIST_UNIFORM, 1, nPagePerCatalog, 0, col, dsdGenContext);
+  nOffset = static_cast<int>(jDate) - dTemp.julian - 1;
+  nCount = (nOffset / 365) * CP_CATALOGS_PER_YEAR;
+  nOffset %= 365;
+
+  switch (nType) {
+    case 1: /* bi-annual */
+      if (nOffset > 183)
+        nCount += 1;
+      break;
+    case 2: /* quarterly */
+      nCount += (nOffset / 91);
+      break;
+    case 3: /* monthly */
+      nCount += (nOffset / 31);
+      break;
+  }
+
+  res = CP_SK(nCount, nPagePerCatalog, nPage);
+
+  return (res);
+}
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t getCatalogNumberFromPage(
+    ds_key_t kPageNumber,
+    DSDGenContext& dsdGenContext) {
+  static int nPagePerCatalog;
+
+  if (!dsdGenContext.getCatalogNumberFromPage_init) {
+    nPagePerCatalog =
+        (static_cast<int>(get_rowcount(CATALOG_PAGE, dsdGenContext)) /
+         CP_CATALOGS_PER_YEAR) /
+        (YEAR_MAXIMUM - YEAR_MINIMUM + 2);
+    dsdGenContext.getCatalogNumberFromPage_init = 1;
+  }
+
+  return (kPageNumber / nPagePerCatalog);
+}
+
+/*
+ * Routine: web_join(int col, ds_key_t join_key, DSDGenContext& dsdGenContext)
+ * Purpose: create joins to web_site/web_page. These need to be handled
+ *together, since the date of transaction must fit within the lifetime of a
+ *particular page, which must fit within the lifetime of a particular site Data
+ *Structures:
+ *
+ * Params:
+ *	join_key is one of two things:
+ *		1. the xxx_sk for a particular row in the dimension for which we
+ *need appropriate dates
+ *		2. a julian date for which we need to pick a valid xxx_sk value
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t web_join(int col, ds_key_t join_key, DSDGenContext& dsdGenContext) {
+  ds_key_t res = -1, kSite;
+  static int nConcurrentSites, nSiteDuration, nOffset;
+  static date_t dSiteOpen, /* open/close dates for current web site */
+      dSiteClose;
+  int nTemp;
+  tdef* pWS = getSimpleTdefsByNumber(WEB_SITE, dsdGenContext);
+  tdef* pWP = getSimpleTdefsByNumber(WEB_PAGE, dsdGenContext);
+
+  if (!dsdGenContext.web_join_init) {
+    strtodt(&dSiteClose, WEB_END_DATE);
+    nSiteDuration = dSiteClose.julian;
+    nConcurrentSites =
+        static_cast<int>(get_rowcount(CONCURRENT_WEB_SITES, dsdGenContext));
+    strtodt(&dSiteOpen, WEB_START_DATE);
+    nSiteDuration -= dSiteOpen.julian;
+    nSiteDuration *= nConcurrentSites;
+    nOffset = (dSiteClose.julian - dSiteOpen.julian) / (2 * nSiteDuration);
+    dsdGenContext.web_join_init = 1;
+  }
+
+  switch (col) {
+      /**************
+       * join_key is the xxx_sk value for a dimension
+       */
+    case WEB_OPEN_DATE:
+      strtodt(&dSiteOpen, DATE_MINIMUM);
+      res = dSiteOpen.julian -
+          ((join_key * WEB_DATE_STAGGER) % nSiteDuration / 2);
+      if (WEB_IS_REPLACED(join_key)) /* this site is completely replaced */
+      {
+        if (WEB_IS_REPLACEMENT(join_key)) /* this is the second site */
+        {
+          /* the open date of the second site needs to align on a revision
+           * boundary */
+          res += nOffset * nSiteDuration;
+        }
+      }
+      break;
+    case WEB_CLOSE_DATE:
+      strtodt(&dSiteOpen, DATE_MINIMUM);
+      res = dSiteOpen.julian -
+          ((join_key * WEB_DATE_STAGGER) % nSiteDuration / 2);
+      res += pWS->nParam * nSiteDuration;
+      if (WEB_IS_REPLACED(join_key)) /* this site is completely replaced */
+      {
+        if (!WEB_IS_REPLACEMENT(join_key)) /* this is the first site */
+        {
+          /* the close date of the first site needs to align on a revision
+           * boundary */
+          res -= pWS->nParam * nSiteDuration / 2;
+        }
+      }
+      break;
+    case WEB_REC_START_DATE_ID:
+      strtodt(&dSiteOpen, DATE_MINIMUM);
+      res = dSiteOpen.julian -
+          (((join_key - 1) * WEB_DATE_STAGGER) % nSiteDuration / 2);
+      res += (join_key % pWS->nParam) * nSiteDuration;
+      break;
+    case WEB_REC_END_DATE_ID:
+      strtodt(&dSiteOpen, DATE_MINIMUM);
+      res = dSiteOpen.julian -
+          ((join_key * WEB_DATE_STAGGER) % nSiteDuration / 2);
+      res += ((join_key + 1) % pWS->nParam) * nSiteDuration * 5 - 1;
+      break;
+    case WP_REC_START_DATE_ID:
+      strtodt(&dSiteOpen, DATE_MINIMUM);
+      res = dSiteOpen.julian -
+          (((join_key - 1) * WEB_DATE_STAGGER) % nSiteDuration / 2);
+      res += (join_key % pWP->nParam) * nSiteDuration * 5;
+      break;
+    case WP_REC_END_DATE_ID:
+      strtodt(&dSiteOpen, DATE_MINIMUM);
+      res = dSiteOpen.julian -
+          ((join_key * WEB_DATE_STAGGER) % nSiteDuration / 2);
+      res += ((join_key + 1) % pWP->nParam) * nSiteDuration - 1;
+      break;
+    case WP_CREATION_DATE_SK:
+      /* page creation has to happen outside of the page window, to assure a
+       * constant number of pages, so it occurs in the gap between site
+       * creation and the site's actual activity. For sites that are replaced
+       * in the time span of the data set, this will depend on whether they
+       * are the first version or the second
+       */
+      strtodt(&dSiteOpen, DATE_MINIMUM);
+      kSite = join_key / WEB_PAGES_PER_SITE + 1;
+      res = dSiteOpen.julian -
+          ((static_cast<int>(kSite) * WEB_DATE_STAGGER) % nSiteDuration / 2);
+      if ((static_cast<int>(kSite) % pWP->nParam) ==
+          0) /* this is a site that gets replaced */
+      {
+        genrand_integer(
+            &nTemp,
+            DIST_UNIFORM,
+            static_cast<int>(res),
+            dSiteOpen.julian,
+            0,
+            col,
+            dsdGenContext);
+        res = nTemp;
+      }
+      break;
+      /*****************
+       * join key from here on is a date for which a valid site/page must be
+       * found the sk for a web page is a compound value: <site id><page id>
+       * and each component is a combination of the unique site or page and
+       * the active revision to it
+       */
+    case WR_WEB_PAGE_SK:
+    case WS_WEB_PAGE_SK:
+      res = genrand_integer(
+          NULL, DIST_UNIFORM, 1, WEB_PAGES_PER_SITE, 0, col, dsdGenContext);
+      break;
+  }
+
+  return (res);
+}
+
+/*
+ * Routine: mk_join(int from_tbl, int to_tbl, int join_count)
+ * Purpose: return a primary key for to_tbl, creating a join between from_tbl
+ *and to_tbl Algorithm: all joins are currently uniformly distributed. The
+ *calling convention allows for each join in the schema to be distributed
+ *differently Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: Relies on existing RNG code, which isn't really 64bit; will probably
+ *requre a rework of the genrand_xx routines
+ */
+ds_key_t mk_join(
+    int from_col,
+    int to_tbl,
+    ds_key_t join_count,
+    DSDGenContext& dsdGenContext) {
+  ds_key_t res;
+  int nYear, nFromTable = 0, nTableIndex = to_tbl;
+  tdef* pTdef;
+
+  nFromTable = getTableFromColumn(from_col, dsdGenContext);
+
+  /*
+   * if the table being joined to employs sparse keys, the join gets handled
+   * in sparse.c
+   */
+  pTdef = getSimpleTdefsByNumber(to_tbl, dsdGenContext);
+  if (pTdef->flags & FL_SPARSE) {
+    if (pTdef->arSparseKeys.data() == NULL)
+      initSparseKeys(to_tbl, dsdGenContext);
+  }
+
+  switch (to_tbl) {
+    /* some tables require special handling */
+    case CATALOG_PAGE:
+      return (cp_join(nFromTable, from_col, join_count, dsdGenContext));
+    case DATET:
+      genrand_integer(
+          &nYear,
+          DIST_UNIFORM,
+          YEAR_MINIMUM,
+          YEAR_MAXIMUM,
+          0,
+          from_col,
+          dsdGenContext);
+      return (
+          date_join(nFromTable, from_col, join_count, nYear, dsdGenContext));
+    case TIMET:
+      return (time_join(nFromTable, from_col, join_count, dsdGenContext));
+      /* the rest of the tables use standard, uniform joins */
+    default:
+      /*
+       * all TYPE2 tables (i.e., history keeping dimensions) need a special
+       * join algorithm
+       */
+      if (pTdef->flags & FL_TYPE_2)
+        return (scd_join(nTableIndex, from_col, join_count, dsdGenContext));
+
+      if (pTdef->flags & FL_SPARSE)
+        return (randomSparseKey(nTableIndex, from_col, dsdGenContext));
+
+      genrand_key(
+          &res,
+          DIST_UNIFORM,
+          static_cast<ds_key_t>(1),
+          get_rowcount(nTableIndex, dsdGenContext),
+          static_cast<ds_key_t>(0),
+          from_col,
+          dsdGenContext);
+      break;
+  }
+
+  return (static_cast<ds_key_t>(res));
+}
diff --git a/velox/tpcds/gen/dsdgen/list.cpp b/velox/tpcds/gen/dsdgen/list.cpp
new file mode 100644
index 000000000000..cd1e9d5733ce
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/list.cpp
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/list.h"
+#include <assert.h>
+#include <stdio.h>
+#include <cstdint>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void* getHead(list_t* pList) {
+  assert(pList);
+
+  if (!pList->head)
+    return (NULL);
+
+  pList->pCurrent = pList->head;
+
+  return (pList->pCurrent->pData);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void* getTail(list_t* pList) {
+  assert(pList);
+
+  if (!pList->tail)
+    return (NULL);
+
+  pList->pCurrent = pList->tail;
+
+  return (pList->pCurrent->pData);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void* getNext(list_t* pList) {
+  assert(pList);
+
+  if (!pList->pCurrent->pNext)
+    return (NULL);
+
+  pList->pCurrent = pList->pCurrent->pNext;
+
+  return (pList->pCurrent->pData);
+}
+
+/*
+ * Routine:
+ * Purpose: findList(list_t *pList, void *pData)
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void* findList(list_t* pList, void* pData) {
+  void* pNode;
+  struct LIST_NODE_T* pOldCurrent = pList->pCurrent;
+
+  for (pNode = getHead(pList); pNode; pNode = getNext(pList))
+    if (pList->pSortFunc(pNode, pData) == 0) {
+      pList->pCurrent = pOldCurrent;
+      return (pNode);
+    }
+
+  pList->pCurrent = pOldCurrent;
+  return (NULL);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void* getItem(list_t* pList, int nIndex) {
+  void* pResult;
+  struct LIST_NODE_T* pOldCurrent = pList->pCurrent;
+
+  if (nIndex > length(pList))
+    return (NULL);
+
+  for (pResult = getHead(pList); --nIndex; pResult = getNext(pList))
+    ;
+
+  pList->pCurrent = pOldCurrent;
+  return (pResult);
+}
diff --git a/velox/tpcds/gen/dsdgen/load.cpp b/velox/tpcds/gen/dsdgen/load.cpp
new file mode 100644
index 000000000000..3d6d35ce0949
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/load.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+
+#ifdef SQLSERVER
+// ODBC headers
+#include <odbcss.h>
+#include <sql.h>
+#include <sqlext.h>
+SQLHENV henv;
+#endif
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int create_table(int nTable) {
+  return (0);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void load_init(void)
+
+{
+#ifdef SQLSERVER
+  SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
+  SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
+#endif
+
+  return;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void load_close(void) {
+#ifdef SQLSERVER
+  SQLFreeHandle(SQL_HANDLE_ENV, henv);
+#endif
+
+  return;
+}
diff --git a/velox/tpcds/gen/dsdgen/misc.cpp b/velox/tpcds/gen/dsdgen/misc.cpp
new file mode 100644
index 000000000000..f71074a33ff1
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/misc.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 <ctype.h>
+#include <errno.h>
+#include <math.h>
+#include <stdio.h>
+#include <time.h>
+#include <cstdint>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#ifndef USE_STDLIB_H
+#include <malloc.h>
+#endif
+#include <fcntl.h>
+#ifdef AIX
+#include <sys/mode.h> // @manual
+#endif /* AIX */
+#include <sys/stat.h>
+#include <sys/types.h>
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+static const char* alpha_num =
+    "0123456789abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ,";
+
+char* getenv(const char* name);
+int print_separator(int sep);
+
+extern long Seed[];
+
+#ifdef WIN32
+#define PATH_SEP '\\'
+#else
+#define PATH_SEP '/'
+#endif
+
+int file_num = -1;
+
+/*
+ *
+ * Various routines that handle distributions, value selections and
+ * seed value management for the DSS benchmark. Current functions:
+ * env_config -- set config vars with optional environment override
+ * a_rnd(min, max) -- random alphanumeric within length range
+ */
+
+/*
+ * env_config: look for a environmental variable setting and return its
+ * value; otherwise return the default supplied
+ */
+char* env_config(char* var, 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)
+ */
+int a_rnd(
+    int min,
+    int max,
+    int column,
+    char* dest,
+    DSDGenContext& dsdGenContext) {
+  int i, len, char_int;
+
+  genrand_integer(&len, DIST_UNIFORM, min, max, 0, column, dsdGenContext);
+  for (i = 0; i < len; i++) {
+    if (i % 5 == 0)
+      genrand_integer(
+          &char_int,
+          DIST_UNIFORM,
+          0,
+          static_cast<uint32_t>(1) << 30,
+          0,
+          column,
+          dsdGenContext);
+    *(dest + i) = alpha_num[static_cast<uint32_t>(char_int) & 077];
+    char_int = static_cast<int>(static_cast<uint32_t>(char_int) >> 6);
+  }
+  *(dest + len) = '\0';
+  return (len);
+}
diff --git a/velox/tpcds/gen/dsdgen/nulls.cpp b/velox/tpcds/gen/dsdgen/nulls.cpp
new file mode 100644
index 000000000000..63afde4a1d13
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/nulls.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+/*
+ * Routine: nullCheck(int nColumn, DSDGenContext& dsdGenContext)
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int nullCheck(int nColumn, DSDGenContext& dsdGenContext) {
+  int nLastTable = 0;
+  tdef* pTdef;
+  ds_key_t kBitMask = 1;
+
+  nLastTable = getTableFromColumn(nColumn, dsdGenContext);
+  pTdef = getSimpleTdefsByNumber(nLastTable, dsdGenContext);
+
+  kBitMask <<= nColumn - pTdef->nFirstColumn;
+
+  return ((pTdef->kNullBitMap & kBitMask) != 0);
+}
+
+/*
+* Routine: nullSet(int *pDest, int nStream, DSDGenContext& dsdGenContext)
+* Purpose: set the kNullBitMap for a particular table
+* Algorithm:
+*	1. if random[1,100] >= table's NULL pct, clear map and return
+*	2. set map
+
+* Data Structures:
+*
+* Params:
+* Returns:
+* Called By:
+* Calls:
+* Assumptions:
+* Side Effects: uses 2 RNG calls
+* TODO: None
+*/
+void nullSet(ds_key_t* pDest, int nStream, DSDGenContext& dsdGenContext) {
+  int nThreshold;
+  ds_key_t kBitMap;
+  int nLastTable = 0;
+  tdef* pTdef;
+
+  nLastTable = getTableFromColumn(nStream, dsdGenContext);
+  pTdef = getSimpleTdefsByNumber(nLastTable, dsdGenContext);
+
+  /* burn the RNG calls */
+  genrand_integer(
+      &nThreshold, DIST_UNIFORM, 0, 9999, 0, nStream, dsdGenContext);
+  genrand_key(&kBitMap, DIST_UNIFORM, 1, MAXINT, 0, nStream, dsdGenContext);
+
+  /* set the bitmap based on threshold and NOT NULL definitions */
+  *pDest = 0;
+  if (nThreshold < pTdef->nNullPct) {
+    *pDest = kBitMap;
+    *pDest &= ~pTdef->kNotNullBitMap;
+  }
+
+  return;
+}
diff --git a/velox/tpcds/gen/dsdgen/parallel.cpp b/velox/tpcds/gen/dsdgen/parallel.cpp
new file mode 100644
index 000000000000..c576fb95c72d
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/parallel.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+/*
+ * Routine: split_work(int tnum, worker_t *w)
+ * Purpose: allocate work between processes and threads
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int split_work(
+    int tnum,
+    ds_key_t* pkFirstRow,
+    ds_key_t* pkRowCount,
+    DSDGenContext& dsdGenContext) {
+  ds_key_t kTotalRows, kRowsetSize, kExtraRows;
+  int nParallel, nChild;
+
+  kTotalRows = get_rowcount(tnum, dsdGenContext);
+  nParallel = get_int("PARALLEL", dsdGenContext);
+  nChild = get_int("CHILD", dsdGenContext) + 1;
+
+  /*
+   * 1. small tables aren't paralelized
+   * 2. nothing is parallelized unless a command line arg is supplied
+   */
+  *pkFirstRow = 1;
+  *pkRowCount = kTotalRows;
+
+  if (kTotalRows < 1000000) {
+    if (nChild > 1) /* small table; only build it once */
+    {
+      *pkFirstRow = 1;
+      *pkRowCount = 0;
+      return (0);
+    }
+    return (1);
+  }
+
+  if (!is_set("PARALLEL", dsdGenContext)) {
+    return (1);
+  }
+
+  /*
+   * at this point, do the calculation to set the rowcount for this part of a
+   * parallel build
+   */
+  kExtraRows = kTotalRows % nParallel;
+  kRowsetSize = (kTotalRows - kExtraRows) / nParallel;
+
+  /* start the starting row id */
+  *pkFirstRow += (nChild - 1) * kRowsetSize;
+  if (kExtraRows && (nChild - 1))
+    *pkFirstRow += ((nChild - 1) < kExtraRows) ? (nChild - 1) : kExtraRows;
+
+  /* set the rowcount for this child */
+  *pkRowCount = kRowsetSize;
+  if (kExtraRows && (nChild <= kExtraRows))
+    *pkRowCount += 1;
+
+  return (1);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int checkSeeds(tdef* pTdef, DSDGenContext& dsdGenContext) {
+  int i, res, nReturnCode = 0;
+  static int bSetSeeds = 0;
+
+  if (!dsdGenContext.checkSeeds_init) {
+    bSetSeeds = is_set("CHKSEEDS", dsdGenContext);
+    dsdGenContext.checkSeeds_init = 1;
+  }
+
+  for (i = pTdef->nFirstColumn; i <= pTdef->nLastColumn; i++) {
+    while (dsdGenContext.Streams[i].nUsed <
+           dsdGenContext.Streams[i].nUsedPerRow)
+      genrand_integer(&res, DIST_UNIFORM, 1, 100, 0, i, dsdGenContext);
+    if (bSetSeeds) {
+      if (dsdGenContext.Streams[i].nUsed >
+          dsdGenContext.Streams[i].nUsedPerRow) {
+        fprintf(
+            stderr,
+            "Seed overrun on column %d. Used: %d\n",
+            i,
+            dsdGenContext.Streams[i].nUsed);
+        dsdGenContext.Streams[i].nUsedPerRow = dsdGenContext.Streams[i].nUsed;
+        nReturnCode = 1;
+      }
+    }
+    dsdGenContext.Streams[i].nUsed = 0; /* reset for the next time */
+  }
+
+  return (nReturnCode);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int row_stop(int tbl, DSDGenContext& dsdGenContext) {
+  tdef* pTdef;
+
+  pTdef = getSimpleTdefsByNumber(tbl, dsdGenContext);
+  checkSeeds(pTdef, dsdGenContext);
+  if (pTdef->flags & FL_PARENT) {
+    pTdef = getSimpleTdefsByNumber(pTdef->nParam, dsdGenContext);
+    checkSeeds(pTdef, dsdGenContext);
+  }
+  return (0);
+}
+
+/*
+ * Routine: row_skip
+ * Purpose: skip over un-used rows in a table
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20020816 jms The second parameter should really be a ds_key_t to allow
+ * BIG skips
+ */
+int row_skip(int tbl, ds_key_t count, DSDGenContext& dsdGenContext) {
+  int i;
+  for (i = 0; dsdGenContext.Streams[i].nColumn != -1; i++) {
+    if (dsdGenContext.Streams[i].nTable == tbl) {
+      skip_random(
+          i, count * dsdGenContext.Streams[i].nUsedPerRow, dsdGenContext);
+      dsdGenContext.Streams[i].nUsed = 0;
+      dsdGenContext.Streams[i].nTotal =
+          count * dsdGenContext.Streams[i].nUsedPerRow;
+    }
+    if (dsdGenContext.Streams[i].nDuplicateOf &&
+        (dsdGenContext.Streams[i].nDuplicateOf != i)) {
+      skip_random(
+          dsdGenContext.Streams[i].nDuplicateOf,
+          count *
+              dsdGenContext.Streams[dsdGenContext.Streams[i].nDuplicateOf]
+                  .nUsedPerRow,
+          dsdGenContext);
+      dsdGenContext.Streams[dsdGenContext.Streams[i].nDuplicateOf].nUsed = 0;
+      dsdGenContext.Streams[dsdGenContext.Streams[i].nDuplicateOf].nTotal =
+          count * dsdGenContext.Streams[i].nUsedPerRow;
+    }
+  }
+
+  return (0);
+}
diff --git a/velox/tpcds/gen/dsdgen/permute.cpp b/velox/tpcds/gen/dsdgen/permute.cpp
new file mode 100644
index 000000000000..9dfa7c52cab6
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/permute.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#ifndef USE_STDLIB_H
+#include <malloc.h>
+#endif
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+
+/*
+ * Routine: MakePermutation(int nSize)
+ * Purpose: Permute the integers in [1..nSize]
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int* makePermutation(int nSize, int nStream, DSDGenContext& dsdGenContext) {
+  int i, nTemp, nIndex, *pInt;
+
+  if (nSize <= 0)
+    return (NULL);
+
+  std::vector<int32_t> nNumberSet(nSize);
+  pInt = nNumberSet.data();
+  for (i = 0; i < nSize; i++)
+    *pInt++ = i;
+
+  for (i = 0; i < nSize; i++) {
+    nIndex = genrand_integer(
+        NULL, DIST_UNIFORM, 0, nSize - 1, 0, nStream, dsdGenContext);
+    nTemp = nNumberSet[i];
+    nNumberSet[i] = nNumberSet[nIndex];
+    nNumberSet[nIndex] = nTemp;
+  }
+
+  return std::move(nNumberSet.data());
+}
diff --git a/velox/tpcds/gen/dsdgen/pricing.cpp b/velox/tpcds/gen/dsdgen/pricing.cpp
new file mode 100644
index 000000000000..73d9967a554b
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/pricing.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/pricing.h"
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
+
+#define MAX_LIMIT 12
+static const ds_limits_t aPriceLimits[MAX_LIMIT] = {
+    {CS_PRICING,
+     CS_QUANTITY_MAX,
+     CS_MARKUP_MAX,
+     CS_DISCOUNT_MAX,
+     CS_WHOLESALE_MAX,
+     CS_COUPON_MAX},
+    {SS_PRICING,
+     SS_QUANTITY_MAX,
+     SS_MARKUP_MAX,
+     SS_DISCOUNT_MAX,
+     SS_WHOLESALE_MAX,
+     SS_COUPON_MAX},
+    {WS_PRICING,
+     WS_QUANTITY_MAX,
+     WS_MARKUP_MAX,
+     WS_DISCOUNT_MAX,
+     WS_WHOLESALE_MAX,
+     WS_COUPON_MAX},
+    {CR_PRICING,
+     CS_QUANTITY_MAX,
+     CS_MARKUP_MAX,
+     CS_DISCOUNT_MAX,
+     CS_WHOLESALE_MAX,
+     CS_COUPON_MAX},
+    {SR_PRICING,
+     SS_QUANTITY_MAX,
+     SS_MARKUP_MAX,
+     SS_DISCOUNT_MAX,
+     SS_WHOLESALE_MAX,
+     SS_COUPON_MAX},
+    {WR_PRICING,
+     WS_QUANTITY_MAX,
+     WS_MARKUP_MAX,
+     WS_DISCOUNT_MAX,
+     WS_WHOLESALE_MAX,
+     WS_COUPON_MAX},
+    {S_PLINE_PRICING,
+     WS_QUANTITY_MAX,
+     WS_MARKUP_MAX,
+     WS_DISCOUNT_MAX,
+     WS_WHOLESALE_MAX,
+     WS_COUPON_MAX},
+    {S_CLIN_PRICING,
+     WS_QUANTITY_MAX,
+     WS_MARKUP_MAX,
+     WS_DISCOUNT_MAX,
+     WS_WHOLESALE_MAX,
+     WS_COUPON_MAX},
+    {S_WLIN_PRICING,
+     WS_QUANTITY_MAX,
+     WS_MARKUP_MAX,
+     WS_DISCOUNT_MAX,
+     WS_WHOLESALE_MAX,
+     WS_COUPON_MAX},
+    {S_SRET_PRICING,
+     WS_QUANTITY_MAX,
+     WS_MARKUP_MAX,
+     WS_DISCOUNT_MAX,
+     WS_WHOLESALE_MAX,
+     WS_COUPON_MAX},
+    {S_CRET_PRICING,
+     WS_QUANTITY_MAX,
+     WS_MARKUP_MAX,
+     WS_DISCOUNT_MAX,
+     WS_WHOLESALE_MAX,
+     WS_COUPON_MAX},
+    {S_WRET_PRICING,
+     WS_QUANTITY_MAX,
+     WS_MARKUP_MAX,
+     WS_DISCOUNT_MAX,
+     WS_WHOLESALE_MAX,
+     WS_COUPON_MAX}
+
+};
+
+/*
+ * Routine: set_pricing(int nTabId, ds_pricing_t *pPricing)
+ * Purpose: handle the various pricing calculations for the fact tables
+ * Notes:
+ *	the RNG usage is not kept in sync between sales pricing and returns
+ *pricing. If the calculations look wrong, it may be necessary to "waste" some
+ *RNG calls on one side or the other to bring things back in line Data
+ *Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void set_pricing(
+    int nTabId,
+    ds_pricing_t* pPricing,
+    DSDGenContext& dsdGenContext) {
+  int nLastId = -1, nQuantityMax = std::numeric_limits<int>::max(),
+      nQuantityMin = 1;
+  decimal_t dQuantity, dMarkupMin, dDiscountMin, dWholesaleMin, dMarkupMax,
+      dDiscountMax, dWholesaleMax, dCouponMin, dCouponMax, dZero, dOneHalf,
+      d9pct, dOne, dTemp, dHundred;
+  decimal_t dMarkup, dCoupon, dShipping, dDiscount, dTemp2;
+  int i, nCashPct, nCreditPct, nCouponUsage;
+
+  strtodec(&dMarkupMin, "0.00");
+  strtodec(&dDiscountMin, "0.00");
+  strtodec(&dWholesaleMin, "1.00");
+  strtodec(&dCouponMin, "0.00");
+  strtodec(&dZero, "0.00");
+  strtodec(&dOneHalf, "0.50");
+  strtodec(&d9pct, "0.09");
+  strtodec(&dWholesaleMin, "1.00");
+  strtodec(&dHundred, "100.00");
+  strtodec(&dOne, "1.00");
+
+  if (nTabId != nLastId) {
+    nLastId = -1;
+    for (i = 0; i < MAX_LIMIT; i++) {
+      if (nTabId == aPriceLimits[i].nId)
+        nLastId = i;
+    }
+    if (nLastId == -1)
+      INTERNAL("No pricing limits defined");
+    nQuantityMax = atoi(aPriceLimits[nLastId].szQuantity);
+    strtodec(&dDiscountMax, aPriceLimits[nLastId].szDiscount);
+    strtodec(&dMarkupMax, aPriceLimits[nLastId].szMarkUp);
+    strtodec(&dWholesaleMax, aPriceLimits[nLastId].szWholesale);
+    strtodec(&dCouponMax, aPriceLimits[nLastId].szCoupon);
+  }
+
+  switch (nTabId) {
+    case SS_PRICING:
+    case CS_PRICING:
+    case WS_PRICING:
+    case S_PLINE_PRICING:
+    case S_CLIN_PRICING:
+    case S_WLIN_PRICING:
+      genrand_integer(
+          &pPricing->quantity,
+          DIST_UNIFORM,
+          nQuantityMin,
+          nQuantityMax,
+          0,
+          nTabId,
+          dsdGenContext);
+      itodec(&dQuantity, pPricing->quantity);
+      genrand_decimal(
+          &pPricing->wholesale_cost,
+          DIST_UNIFORM,
+          &dWholesaleMin,
+          &dWholesaleMax,
+          NULL,
+          nTabId,
+          dsdGenContext);
+
+      /* ext_wholesale_cost = wholesale_cost * quantity */
+      decimal_t_op(
+          &pPricing->ext_wholesale_cost,
+          OP_MULT,
+          &dQuantity,
+          &pPricing->wholesale_cost);
+
+      /* list_price = wholesale_cost * (1 + markup) */
+      genrand_decimal(
+          &dMarkup,
+          DIST_UNIFORM,
+          &dMarkupMin,
+          &dMarkupMax,
+          NULL,
+          nTabId,
+          dsdGenContext);
+      decimal_t_op(&dMarkup, OP_PLUS, &dMarkup, &dOne);
+      decimal_t_op(
+          &pPricing->list_price, OP_MULT, &pPricing->wholesale_cost, &dMarkup);
+
+      /* sales_price = list_price * (1 - discount)*/
+      genrand_decimal(
+          &dDiscount,
+          DIST_UNIFORM,
+          &dDiscountMin,
+          &dDiscountMax,
+          NULL,
+          nTabId,
+          dsdGenContext);
+      NegateDecimal(&dDiscount);
+      decimal_t_op(&pPricing->ext_discount_amt, OP_PLUS, &dDiscount, &dOne);
+      decimal_t_op(
+          &pPricing->sales_price,
+          OP_MULT,
+          &pPricing->list_price,
+          &pPricing->ext_discount_amt);
+
+      /* ext_list_price = list_price * quantity */
+      decimal_t_op(
+          &pPricing->ext_list_price,
+          OP_MULT,
+          &pPricing->list_price,
+          &dQuantity);
+
+      /* ext_sales_price = sales_price * quantity */
+      decimal_t_op(
+          &pPricing->ext_sales_price,
+          OP_MULT,
+          &pPricing->sales_price,
+          &dQuantity);
+
+      /* ext_discount_amt = ext_list_price - ext_sales_price */
+      decimal_t_op(
+          &pPricing->ext_discount_amt,
+          OP_MINUS,
+          &pPricing->ext_list_price,
+          &pPricing->ext_sales_price);
+
+      /* coupon_amt = ext_sales_price * coupon */
+      genrand_decimal(
+          &dCoupon, DIST_UNIFORM, &dZero, &dOne, NULL, nTabId, dsdGenContext);
+      genrand_integer(
+          &nCouponUsage, DIST_UNIFORM, 1, 100, 0, nTabId, dsdGenContext);
+      if (nCouponUsage <= 20) /* 20% of sales employ a coupon */
+        decimal_t_op(
+            &pPricing->coupon_amt,
+            OP_MULT,
+            &pPricing->ext_sales_price,
+            &dCoupon);
+      else
+        memcpy(&pPricing->coupon_amt, &dZero, sizeof(decimal_t));
+
+      /* net_paid = ext_sales_price - coupon_amt */
+      decimal_t_op(
+          &pPricing->net_paid,
+          OP_MINUS,
+          &pPricing->ext_sales_price,
+          &pPricing->coupon_amt);
+
+      /* shipping_cost = list_price * shipping */
+      genrand_decimal(
+          &dShipping,
+          DIST_UNIFORM,
+          &dZero,
+          &dOneHalf,
+          NULL,
+          nTabId,
+          dsdGenContext);
+      decimal_t_op(
+          &pPricing->ship_cost, OP_MULT, &pPricing->list_price, &dShipping);
+
+      /* ext_shipping_cost = shipping_cost * quantity */
+      decimal_t_op(
+          &pPricing->ext_ship_cost, OP_MULT, &pPricing->ship_cost, &dQuantity);
+
+      /* net_paid_inc_ship = net_paid + ext_shipping_cost */
+      decimal_t_op(
+          &pPricing->net_paid_inc_ship,
+          OP_PLUS,
+          &pPricing->net_paid,
+          &pPricing->ext_ship_cost);
+
+      /* ext_tax = tax * net_paid */
+      genrand_decimal(
+          &pPricing->tax_pct,
+          DIST_UNIFORM,
+          &dZero,
+          &d9pct,
+          NULL,
+          nTabId,
+          dsdGenContext);
+      decimal_t_op(
+          &pPricing->ext_tax, OP_MULT, &pPricing->net_paid, &pPricing->tax_pct);
+
+      /* net_paid_inc_tax = net_paid + ext_tax */
+      decimal_t_op(
+          &pPricing->net_paid_inc_tax,
+          OP_PLUS,
+          &pPricing->net_paid,
+          &pPricing->ext_tax);
+
+      /* net_paid_inc_ship_tax = net_paid_inc_tax + ext_shipping_cost */
+      decimal_t_op(
+          &pPricing->net_paid_inc_ship_tax,
+          OP_PLUS,
+          &pPricing->net_paid_inc_ship,
+          &pPricing->ext_tax);
+
+      /* net_profit = net_paid - ext_wholesale_cost */
+      decimal_t_op(
+          &pPricing->net_profit,
+          OP_MINUS,
+          &pPricing->net_paid,
+          &pPricing->ext_wholesale_cost);
+      break;
+    case CR_PRICING:
+    case SR_PRICING:
+    case WR_PRICING:
+      /* quantity is determined before we are called */
+      /* ext_wholesale_cost = wholesale_cost * quantity */
+      itodec(&dQuantity, pPricing->quantity);
+      decimal_t_op(
+          &pPricing->ext_wholesale_cost,
+          OP_MULT,
+          &dQuantity,
+          &pPricing->wholesale_cost);
+
+      /* ext_list_price = list_price * quantity */
+      decimal_t_op(
+          &pPricing->ext_list_price,
+          OP_MULT,
+          &pPricing->list_price,
+          &dQuantity);
+
+      /* ext_sales_price = sales_price * quantity */
+      decimal_t_op(
+          &pPricing->ext_sales_price,
+          OP_MULT,
+          &pPricing->sales_price,
+          &dQuantity);
+
+      /* net_paid = ext_list_price (couppons don't effect returns) */
+      memcpy(
+          &pPricing->net_paid, &pPricing->ext_sales_price, sizeof(decimal_t));
+
+      /* shipping_cost = list_price * shipping */
+      genrand_decimal(
+          &dShipping,
+          DIST_UNIFORM,
+          &dZero,
+          &dOneHalf,
+          NULL,
+          nTabId,
+          dsdGenContext);
+      decimal_t_op(
+          &pPricing->ship_cost, OP_MULT, &pPricing->list_price, &dShipping);
+
+      /* ext_shipping_cost = shipping_cost * quantity */
+      decimal_t_op(
+          &pPricing->ext_ship_cost, OP_MULT, &pPricing->ship_cost, &dQuantity);
+
+      /* net_paid_inc_ship = net_paid + ext_shipping_cost */
+      decimal_t_op(
+          &pPricing->net_paid_inc_ship,
+          OP_PLUS,
+          &pPricing->net_paid,
+          &pPricing->ext_ship_cost);
+
+      /* ext_tax = tax * net_paid */
+      decimal_t_op(
+          &pPricing->ext_tax, OP_MULT, &pPricing->net_paid, &pPricing->tax_pct);
+
+      /* net_paid_inc_tax = net_paid + ext_tax */
+      decimal_t_op(
+          &pPricing->net_paid_inc_tax,
+          OP_PLUS,
+          &pPricing->net_paid,
+          &pPricing->ext_tax);
+
+      /* net_paid_inc_ship_tax = net_paid_inc_tax + ext_shipping_cost */
+      decimal_t_op(
+          &pPricing->net_paid_inc_ship_tax,
+          OP_PLUS,
+          &pPricing->net_paid_inc_ship,
+          &pPricing->ext_tax);
+
+      /* net_profit = net_paid - ext_wholesale_cost */
+      decimal_t_op(
+          &pPricing->net_profit,
+          OP_MINUS,
+          &pPricing->net_paid,
+          &pPricing->ext_wholesale_cost);
+
+      /* see to it that the returned amounts add up to the total returned */
+      /* allocate some of return to cash */
+      genrand_integer(
+          &nCashPct, DIST_UNIFORM, 0, 100, 0, nTabId, dsdGenContext);
+      itodec(&dTemp, nCashPct);
+      decimal_t_op(&pPricing->refunded_cash, OP_DIV, &dTemp, &dHundred);
+      decimal_t_op(
+          &pPricing->refunded_cash,
+          OP_MULT,
+          &pPricing->refunded_cash,
+          &pPricing->net_paid);
+
+      /* allocate some to reversed charges */
+      genrand_integer(
+          &nCreditPct, DIST_UNIFORM, 1, 100, 0, nTabId, dsdGenContext);
+      itodec(&dTemp2, nCreditPct);
+      decimal_t_op(&dTemp, OP_DIV, &dTemp2, &dHundred);
+      decimal_t_op(
+          &dTemp2, OP_MINUS, &pPricing->net_paid, &pPricing->refunded_cash);
+      decimal_t_op(&pPricing->reversed_charge, OP_MULT, &dTemp2, &dTemp);
+
+      /* the rest is store credit */
+      decimal_t_op(
+          &pPricing->store_credit,
+          OP_MINUS,
+          &pPricing->net_paid,
+          &pPricing->reversed_charge);
+      decimal_t_op(
+          &pPricing->store_credit,
+          OP_MINUS,
+          &pPricing->store_credit,
+          &pPricing->refunded_cash);
+
+      /* pick a fee for the return */
+      genrand_decimal(
+          &pPricing->fee,
+          DIST_UNIFORM,
+          &dOneHalf,
+          &dHundred,
+          &dZero,
+          nTabId,
+          dsdGenContext);
+
+      /* and calculate the net effect */
+      decimal_t_op(
+          &pPricing->net_loss,
+          OP_MINUS,
+          &pPricing->net_paid_inc_ship_tax,
+          &pPricing->store_credit);
+      decimal_t_op(
+          &pPricing->net_loss,
+          OP_MINUS,
+          &pPricing->net_loss,
+          &pPricing->refunded_cash);
+      decimal_t_op(
+          &pPricing->net_loss,
+          OP_MINUS,
+          &pPricing->net_loss,
+          &pPricing->reversed_charge);
+      decimal_t_op(
+          &pPricing->net_loss, OP_PLUS, &pPricing->net_loss, &pPricing->fee);
+      break;
+  }
+
+  return;
+}
diff --git a/velox/tpcds/gen/dsdgen/r_params.cpp b/velox/tpcds/gen/dsdgen/r_params.cpp
new file mode 100644
index 000000000000..af80ecbb9a0b
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/r_params.cpp
@@ -0,0 +1,734 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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.
+ */
+
+/*
+ * parameter handling functions
+ */
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <cassert>
+#include <cstdint>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#define PARAM_MAX_LEN 80
+#define MAX_LINE_LEN 120
+#ifdef WIN32
+#define OPTION_START '/'
+#else
+#define OPTION_START '-'
+#endif
+
+#ifndef TEST
+extern option_t options[];
+extern char* params[];
+#else
+option_t options[] = {
+    {"PROG", OPT_STR | OPT_HIDE, 0, NULL, NULL, "tester"},
+    {"PARAMS", OPT_STR, 1, "read parameters from file <s>", read_file, ""},
+    {"DISTRIBUTIONS",
+     OPT_STR,
+     2,
+     "read distributions from file <s>",
+     NULL,
+     "tester_dist.idx"},
+    {"OUTDIR", OPT_STR, 3, "generate files in directory <s>", NULL, "./"},
+    {"VERBOSE", OPT_FLG, 4, "enable verbose output", NULL, "N"},
+    {"HELP", OPT_FLG, 5, "display this message", usage, "N"},
+    {"scale", OPT_INT, 6, "set scale to <i>", NULL, "1"},
+    NULL};
+char* params[9];
+#endif
+
+int read_file(const char* param_name, const char* option);
+int fnd_param(const char* name, DSDGenContext& dsdGenContext);
+void print_params(DSDGenContext& dsdGenContext);
+
+/*
+ * Routine:  load_params()
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20010621 JMS shared memory not yet implemented
+ */
+void load_params() {
+  /*
+      int i=0;
+      while (options[i].name != NULL)
+      {
+          load_param(i, GetSharedMemoryParam(options[i].index));
+          i++;
+      }
+      SetSharedMemoryStat(STAT_ROWCOUNT, get_int("STEP"), 0);
+  */
+  return;
+}
+
+/*
+ * Routine:  set_flag(int f)
+ * Purpose:  set a toggle parameter
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void set_flg(const char* flag, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  init_params(dsdGenContext);
+  nParam = fnd_param(flag, dsdGenContext);
+  if (nParam >= 0)
+    strcpy(
+        dsdGenContext.params[dsdGenContext.options[nParam].index].data(), "Y");
+
+  return;
+}
+
+/*
+ * Routine: clr_flg(f)
+ * Purpose: clear a toggle parameter
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void clr_flg(const char* flag, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  init_params(dsdGenContext);
+  nParam = fnd_param(flag, dsdGenContext);
+  if (nParam >= 0)
+    strcpy(
+        dsdGenContext.params[dsdGenContext.options[nParam].index].data(), "N");
+  return;
+}
+
+/*
+ * Routine: is_set(int f)
+ * Purpose: return the state of a toggle parameter, or whether or not a string
+ * or int parameter has been set Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int is_set(const char* flag, DSDGenContext& dsdGenContext) {
+  int nParam, bIsSet = 0;
+
+  init_params(dsdGenContext);
+  nParam = fnd_param(flag, dsdGenContext);
+  if (nParam >= 0) {
+    if ((static_cast<uint32_t>(dsdGenContext.options[nParam].flags) &
+         TYPE_MASK) == OPT_FLG)
+      bIsSet =
+          (dsdGenContext.params[dsdGenContext.options[nParam].index][0] == 'Y')
+          ? 1
+          : 0;
+    else
+      bIsSet = (static_cast<uint32_t>(dsdGenContext.options[nParam].flags) &
+                OPT_SET) ||
+          (strlen(dsdGenContext.options[nParam].dflt.data()) > 0);
+  }
+
+  return (bIsSet); /* better a false negative than a false positive ? */
+}
+
+/*
+ * Routine: set_int(int var, char *value)
+ * Purpose: set an integer parameter
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void set_int(const char* var, const char* val, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  init_params(dsdGenContext);
+  nParam = fnd_param(var, dsdGenContext);
+  if (nParam >= 0) {
+    strcpy(
+        dsdGenContext.params[dsdGenContext.options[nParam].index].data(), val);
+    dsdGenContext.options[nParam].flags = static_cast<int>(
+        static_cast<uint32_t>(dsdGenContext.options[nParam].flags) | OPT_SET);
+  }
+  return;
+}
+
+/*
+ * Routine: get_int(char *var)
+ * Purpose: return the value of an integer parameter
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int get_int(const char* var, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  init_params(dsdGenContext);
+  nParam = fnd_param(var, dsdGenContext);
+  if (nParam >= 0)
+    return (
+        atoi(dsdGenContext.params[dsdGenContext.options[nParam].index].data()));
+  else
+    return (0);
+}
+
+double get_dbl(const char* var, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  init_params(dsdGenContext);
+  nParam = fnd_param(var, dsdGenContext);
+  if (nParam >= 0)
+    return (
+        atof(dsdGenContext.params[dsdGenContext.options[nParam].index].data()));
+  else
+    return (0);
+}
+
+/*
+ * Routine: set_str(int var, char *value)
+ * Purpose: set a character parameter
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void set_str(const char* var, const char* val, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  init_params(dsdGenContext);
+  nParam = fnd_param(var, dsdGenContext);
+  if (nParam >= 0) {
+    strcpy(
+        dsdGenContext.params[dsdGenContext.options[nParam].index].data(), val);
+    dsdGenContext.options[nParam].flags = static_cast<int>(
+        static_cast<uint32_t>(dsdGenContext.options[nParam].flags) | OPT_SET);
+  }
+
+  return;
+}
+
+/*
+ * Routine: get_str(char * var)
+ * Purpose: return the value of a character parameter
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+const char* get_str(const char* var, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  init_params(dsdGenContext);
+  nParam = fnd_param(var, dsdGenContext);
+  if (nParam >= 0)
+    return (dsdGenContext.params[dsdGenContext.options[nParam].index].data());
+  else
+    return (NULL);
+}
+
+/*
+ * Routine: init_params(DSDGenContext& dsdGenContext)
+ * Purpose: initialize a parameter set, setting default values
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int init_params(DSDGenContext& dsdGenContext) {
+  int i;
+
+  if (dsdGenContext.init_params_init)
+    return (0);
+
+  for (i = 0; dsdGenContext.options[i].name != NULL; i++) {
+    dsdGenContext.params[dsdGenContext.options[i].index].resize(PARAM_MAX_LEN);
+    snprintf(
+        dsdGenContext.params[dsdGenContext.options[i].index].data(),
+        PARAM_MAX_LEN,
+        "%s",
+        dsdGenContext.options[i].dflt.data());
+    if (!dsdGenContext.options[i].dflt.empty())
+      dsdGenContext.options[i].flags = static_cast<int>(
+          static_cast<uint32_t>(dsdGenContext.options[i].flags) | OPT_DFLT);
+  }
+
+  dsdGenContext.init_params_init = 1;
+
+  return (0);
+}
+
+/*
+ * Routine: save_file(char *path)
+ * Purpose: print a summary of options
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int save_file(const char* path, DSDGenContext& dsdGenContext) {
+  int i, w_adjust;
+  FILE* ofp;
+  time_t timestamp;
+
+  init_params(dsdGenContext);
+  time(&timestamp);
+
+  if ((ofp = fopen(path, "w")) == NULL)
+    return (-1);
+
+  auto result = fprintf(
+      ofp,
+      "--\n-- %s Benchmark Parameter File\n-- Created: %s",
+      get_str("PROG", dsdGenContext),
+      ctime(&timestamp));
+  if (result < 0)
+    perror("sprintf failed");
+  result = fprintf(
+      ofp,
+      "--\n-- Each entry is of the form: '<parameter> = <value> -- "
+      "optional comment'\n");
+  if (result < 0)
+    perror("sprintf failed");
+  result = fprintf(
+      ofp, "-- Refer to benchmark documentation for more details\n--\n");
+  if (result < 0)
+    perror("sprintf failed");
+
+  for (i = 0; dsdGenContext.options[i].name != NULL; i++) {
+    if (static_cast<uint32_t>(dsdGenContext.options[i].flags) &
+        OPT_HIDE) /* hidden option */
+      continue;
+    if (strlen(dsdGenContext.params[dsdGenContext.options[i].index].data()) ==
+        0)
+      continue;
+
+    result = fprintf(ofp, "%s = ", dsdGenContext.options[i].name);
+    if (result < 0)
+      perror("sprintf failed");
+    w_adjust = strlen(dsdGenContext.options[i].name) + 3;
+    if (static_cast<uint32_t>(dsdGenContext.options[i].flags) & OPT_STR) {
+      result = fprintf(
+          ofp,
+          "\"%s\"",
+          dsdGenContext.params[dsdGenContext.options[i].index].data());
+      if (result < 0)
+        perror("sprintf failed");
+      w_adjust += 2;
+    } else {
+      result = fprintf(
+          ofp,
+          "%s",
+          dsdGenContext.params[dsdGenContext.options[i].index].data());
+      if (result < 0)
+        perror("sprintf failed");
+    }
+    w_adjust +=
+        strlen(dsdGenContext.params[dsdGenContext.options[i].index].data()) + 3;
+    w_adjust = 60 - w_adjust;
+    result =
+        fprintf(ofp, "%*s-- %s", w_adjust, " ", dsdGenContext.options[i].usage);
+    if (result < 0)
+      perror("sprintf failed");
+    if (static_cast<uint32_t>(dsdGenContext.options[i].flags) & OPT_NOP) {
+      result = fprintf(ofp, " NOT IMPLEMENTED");
+      if (result < 0)
+        perror("sprintf failed");
+    }
+    result = fprintf(ofp, "\n");
+    if (result < 0)
+      perror("sprintf failed");
+  }
+
+  fclose(ofp);
+
+  return (0);
+}
+
+/*
+ * Routine: set_option(int var, char *value)
+ * Purpose: set a particular parameter; main entry point for the module
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int set_option(const char* name, const char* param) {
+  printf("ERROR: set_option not supported");
+  assert(0);
+  exit(1);
+}
+
+/*
+ * Routine: process_options(int count, char **vector)
+ * Purpose:  process a set of command line options
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20000309 need to return integer to allow processing of left-over args
+ */
+int process_options(
+    int count,
+    const char** vector,
+    DSDGenContext& dsdGenContext) {
+  int option_num = 1, res = 1;
+
+  init_params(dsdGenContext);
+
+  while (option_num < count) {
+    if (*vector[option_num] == OPTION_START) {
+      if (option_num == (count - 1))
+        res = set_option(vector[option_num] + 1, NULL);
+      else
+        res = set_option(vector[option_num] + 1, vector[option_num + 1]);
+    }
+
+    if (res < 0) {
+      auto result = printf(
+          "ERROR: option '%s' or its argument unknown.\n",
+          (vector[option_num] + 1));
+      if (result < 0)
+        perror("sprintf failed");
+      usage(NULL, NULL, dsdGenContext);
+      exit(1);
+    } else
+      option_num += res;
+  }
+
+#ifdef JMS
+  if (is_set("VERBOSE", dsdGenContext))
+    print_params(dsdGenContext);
+#endif
+
+  return (option_num);
+}
+
+/*
+ * Routine: print_params(DSDGenContext& dsdGenContext)
+ * Purpose: print a parameter summary to display current settings
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void print_params(DSDGenContext& dsdGenContext) {
+  int i;
+
+  init_params(dsdGenContext);
+
+  for (i = 0; dsdGenContext.options[i].name != NULL; i++)
+    if (dsdGenContext.options[i].name != NULL) {
+      auto result = printf("%s = ", dsdGenContext.options[i].name);
+      if (result < 0)
+        perror("sprintf failed");
+      switch (static_cast<uint32_t>(dsdGenContext.options[i].flags) &
+              TYPE_MASK) {
+        case OPT_INT: {
+          result = printf(
+              "%d\n",
+              get_int(
+                  const_cast<char*>(dsdGenContext.options[i].name),
+                  dsdGenContext));
+          if (result < 0)
+            perror("sprintf failed");
+          break;
+        }
+        case OPT_STR: {
+          result = printf(
+              "%s\n",
+              get_str(
+                  const_cast<char*>(dsdGenContext.options[i].name),
+                  dsdGenContext));
+          if (result < 0)
+            perror("sprintf failed");
+          break;
+        }
+        case OPT_FLG: {
+          result = printf(
+              "%c\n",
+              is_set(
+                  const_cast<char*>(dsdGenContext.options[i].name),
+                  dsdGenContext)
+                  ? 'Y'
+                  : 'N');
+          if (result < 0)
+            perror("sprintf failed");
+          break;
+        }
+      }
+    }
+
+  return;
+}
+
+/*
+ * Routine: fnd_param(char *name, int *type, char *value, DSDGenContext&
+ * dsdGenContext) Purpose: traverse the defined parameters, looking for a match
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns: index of option
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int fnd_param(const char* name, DSDGenContext& dsdGenContext) {
+  int i, res = -1;
+
+  for (i = 0; dsdGenContext.options[i].name != NULL; i++) {
+    if (strncasecmp(name, dsdGenContext.options[i].name, strlen(name)) == 0) {
+      if (res == -1)
+        res = i;
+      else
+        return (-1);
+    }
+  }
+
+  return (res);
+}
+
+/*
+ * Routine:  GetParamName(int nParam)
+ * Purpose:  Translate between a parameter index and its name
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+char* GetParamName(int nParam, DSDGenContext& dsdGenContext) {
+  init_params(dsdGenContext);
+
+  return const_cast<char*>(dsdGenContext.options[nParam].name);
+}
+
+/*
+ * Routine:  GetParamValue(int nParam)
+ * Purpose:  Retrieve a parameters string value based on an index
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+const char* GetParamValue(int nParam, DSDGenContext& dsdGenContext) {
+  init_params(dsdGenContext);
+
+  return (dsdGenContext.params[dsdGenContext.options[nParam].index].data());
+}
+
+/*
+ * Routine:  load_param(char *szValue, int nParam)
+ * Purpose:  Set a parameter based on an index
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int load_param(int nParam, const char* szValue, DSDGenContext& dsdGenContext) {
+  init_params(dsdGenContext);
+
+  if (static_cast<uint32_t>(dsdGenContext.options[nParam].flags) &
+      OPT_SET) /* already set from the command line */
+    return (0);
+  else
+    strcpy(
+        dsdGenContext.params[dsdGenContext.options[nParam].index].data(),
+        szValue);
+
+  return (0);
+}
+
+/*
+ * Routine:  IsIntParam(char *szValue, int nParam)
+ * Purpose:  Boolean test for integer parameter
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int IsIntParam(const char* szParam, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  if ((nParam = fnd_param(szParam, dsdGenContext)) == -1)
+    return (nParam);
+
+  return (
+      (static_cast<uint32_t>(dsdGenContext.options[nParam].flags) & OPT_INT)
+          ? 1
+          : 0);
+}
+
+/*
+ * Routine:  IsStrParam(char *szValue, int nParam)
+ * Purpose:  Boolean test for string parameter
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int IsStrParam(const char* szParam, DSDGenContext& dsdGenContext) {
+  int nParam;
+
+  if ((nParam = fnd_param(szParam, dsdGenContext)) == -1)
+    return (nParam);
+
+  return (
+      (static_cast<uint32_t>(dsdGenContext.options[nParam].flags) & OPT_STR)
+          ? 1
+          : 0);
+}
+
+#ifdef TEST
+
+main() {
+  init_params();
+  set_int("SCALE", "7");
+  set_flg("VERBOSE");
+  set_str("DISTRIBUTIONS", "'some file name'");
+  print_params();
+  set_int("s", "8");
+  clr_flg("VERBOSE");
+  printf("DIST is %s\n", get_str("DISTRIBUTIONS"));
+  print_params();
+  usage(NULL, NULL);
+}
+#endif /* TEST_PARAMS */
diff --git a/velox/tpcds/gen/dsdgen/scaling.cpp b/velox/tpcds/gen/dsdgen/scaling.cpp
new file mode 100644
index 000000000000..3992128e35d6
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/scaling.cpp
@@ -0,0 +1,800 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include <assert.h>
+#include <stdio.h>
+#include <cmath>
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/tpcds.idx.h"
+#include "velox/tpcds/gen/dsdgen/include/w_inventory.h"
+
+void setUpdateScaling(int table, DSDGenContext& dsdGenContext);
+int row_skip(int tbl, ds_key_t count, DSDGenContext& dsdGenContext);
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int getScaleSlot(int nTargetGB, DSDGenContext& dsdGenContext) {
+  int i;
+
+  for (i = 0; nTargetGB > dsdGenContext.arScaleVolume[i]; i++)
+    ;
+
+  return (i);
+}
+
+/*
+ * Routine: LogScale(void)
+ * Purpose: use the command line volume target, in GB, to calculate the global
+ * rowcount multiplier Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects: arRowcounts are set to the appropriate number of rows for the
+ * target scale factor
+ * TODO: None
+ */
+static ds_key_t
+LogScale(int nTable, int nTargetGB, DSDGenContext& dsdGenContext) {
+  int nIndex = 1, nDelta, i;
+  float fOffset;
+  ds_key_t hgRowcount = 0;
+
+  i = getScaleSlot(nTargetGB, dsdGenContext);
+
+  nDelta = dist_weight(NULL, "rowcounts", nTable + 1, i + 1, dsdGenContext) -
+      dist_weight(NULL, "rowcounts", nTable + 1, i, dsdGenContext);
+  fOffset =
+      static_cast<float>(nTargetGB - dsdGenContext.arScaleVolume[i - 1]) /
+      static_cast<float>(
+          dsdGenContext.arScaleVolume[i] - dsdGenContext.arScaleVolume[i - 1]);
+
+  hgRowcount = static_cast<int>(fOffset * static_cast<float>(nDelta));
+  hgRowcount +=
+      dist_weight(NULL, "rowcounts", nTable + 1, nIndex, dsdGenContext);
+
+  return (hgRowcount);
+}
+
+/*
+ * Routine: StaticScale(void)
+ * Purpose: use the command line volume target, in GB, to calculate the global
+ * rowcount multiplier Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects: arRowcounts are set to the appropriate number of rows for the
+ * target scale factor
+ * TODO: None
+ */
+static ds_key_t
+StaticScale(int nTable, int nTargetGB, DSDGenContext& dsdGenContext) {
+  return (dist_weight(NULL, "rowcounts", nTable + 1, 1, dsdGenContext));
+}
+
+/*
+ * Routine: LinearScale(void)
+ * Purpose: use the command line volume target, in GB, to calculate the global
+ *rowcount multiplier Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions: scale factors defined in rowcounts distribution define
+ *1/10/100/1000/... GB with sufficient accuracy Side Effects: arRowcounts are
+ *set to the appropriate number of rows for the target scale factor
+ * TODO: None
+ */
+static ds_key_t
+LinearScale(int nTable, int nTargetGB, DSDGenContext& dsdGenContext) {
+  int i;
+  ds_key_t hgRowcount = 0;
+
+  for (i = 8; i >= 0; i--) /* work from large scales down)*/
+  {
+    /*
+     * use the defined rowcounts to build up the target GB volume
+     */
+    while (nTargetGB >= dsdGenContext.arScaleVolume[i]) {
+      hgRowcount +=
+          dist_weight(NULL, "rowcounts", nTable + 1, i + 1, dsdGenContext);
+      nTargetGB -= dsdGenContext.arScaleVolume[i];
+    }
+  }
+
+  return (hgRowcount);
+}
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t getIDCount(int nTable, DSDGenContext& dsdGenContext) {
+  ds_key_t kRowcount, kUniqueCount;
+  tdef* pTdef;
+
+  kRowcount = get_rowcount(nTable, dsdGenContext);
+  if (nTable >= PSEUDO_TABLE_START)
+    return (kRowcount);
+  pTdef = getSimpleTdefsByNumber(nTable, dsdGenContext);
+  if (pTdef->flags & FL_TYPE_2) {
+    kUniqueCount = (kRowcount / 6) * 3;
+    switch (kRowcount % 6) {
+      case 1:
+        kUniqueCount += 1;
+        break;
+      case 2:
+      case 3:
+        kUniqueCount += 2;
+        break;
+      case 4:
+      case 5:
+        kUniqueCount += 3;
+        break;
+    }
+    return (kUniqueCount);
+  } else {
+    return (kRowcount);
+  }
+}
+
+/*
+ * Routine: get_rowcount(int table)
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20040820 jms Need to address special case scaling in a more general
+ * fashion
+ */
+ds_key_t get_rowcount(int table, DSDGenContext& dsdGenContext) {
+  static double nScale;
+  int nTable, nMultiplier, i, nRowcountOffset = 0;
+  // int nBadScale = 0;
+  tdef* pTdef;
+
+  if (!dsdGenContext.get_rowcount_init) {
+    nScale = get_dbl("SCALE", dsdGenContext);
+    if (nScale > 100000)
+      ReportErrorNoLine(QERR_BAD_SCALE, NULL, 1);
+
+    memset(dsdGenContext.arRowcount, 0, sizeof(long) * MAX_TABLE);
+    int iScale = nScale < 1 ? 1 : static_cast<int>(nScale);
+    for (nTable = CALL_CENTER; nTable <= MAX_TABLE; nTable++) {
+      switch (iScale) {
+        case 100000:
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              9,
+              dsdGenContext);
+          break;
+        case 30000:
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              8,
+              dsdGenContext);
+          break;
+        case 10000:
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              7,
+              dsdGenContext);
+          break;
+        case 3000:
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              6,
+              dsdGenContext);
+          break;
+        case 1000:
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              5,
+              dsdGenContext);
+          break;
+        case 300:
+          // nBadScale = QERR_BAD_SCALE;
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              4,
+              dsdGenContext);
+          break;
+        case 100:
+          // nBadScale = QERR_BAD_SCALE;
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              3,
+              dsdGenContext);
+          break;
+        case 10:
+          // nBadScale = QERR_BAD_SCALE;
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              2,
+              dsdGenContext);
+          break;
+        case 1:
+          // nBadScale = QERR_QUALIFICATION_SCALE;
+          dsdGenContext.arRowcount[nTable].kBaseRowcount = dist_weight(
+              NULL,
+              "rowcounts",
+              nTable + nRowcountOffset + 1,
+              1,
+              dsdGenContext);
+          break;
+        default:
+          // nBadScale = QERR_BAD_SCALE;
+          int mem =
+              dist_member(NULL, "rowcounts", nTable + 1, 3, dsdGenContext);
+          switch (mem) {
+            case 2:
+              dsdGenContext.arRowcount[nTable].kBaseRowcount =
+                  LinearScale(nTable + nRowcountOffset, nScale, dsdGenContext);
+              break;
+            case 1:
+              dsdGenContext.arRowcount[nTable].kBaseRowcount =
+                  StaticScale(nTable + nRowcountOffset, nScale, dsdGenContext);
+              break;
+            case 3:
+              dsdGenContext.arRowcount[nTable].kBaseRowcount =
+                  LogScale(nTable + nRowcountOffset, nScale, dsdGenContext);
+              break;
+          } /* switch(FL_SCALE_MASK) */
+          break;
+      } /* switch(nScale) */
+
+      /* now adjust for the multiplier */
+      nMultiplier = 1;
+      if (nTable < PSEUDO_TABLE_START) {
+        pTdef = getSimpleTdefsByNumber(nTable, dsdGenContext);
+        nMultiplier = (pTdef->flags & FL_TYPE_2) ? 2 : 1;
+      }
+      for (i = 1;
+           i <= dist_member(NULL, "rowcounts", nTable + 1, 2, dsdGenContext);
+           i++) {
+        nMultiplier *= 10;
+      }
+      if (dsdGenContext.arRowcount[nTable].kBaseRowcount >= 0) {
+        if (nScale < 1) {
+          int mem =
+              dist_member(NULL, "rowcounts", nTable + 1, 3, dsdGenContext);
+          if ((mem > 1)) {
+            dsdGenContext.arRowcount[nTable].kBaseRowcount = static_cast<int>(
+                dsdGenContext.arRowcount[nTable].kBaseRowcount * nScale);
+          }
+          if (dsdGenContext.arRowcount[nTable].kBaseRowcount == 0) {
+            dsdGenContext.arRowcount[nTable].kBaseRowcount = 1;
+          }
+        }
+      }
+      dsdGenContext.arRowcount[nTable].kBaseRowcount *= nMultiplier;
+    } /* for each table */
+
+    //		if (nBadScale && !is_set("QUIET"))
+    //			ReportErrorNoLine(nBadScale, NULL, 0);
+
+    dsdGenContext.get_rowcount_init = 1;
+  }
+
+  if (table == INVENTORY)
+    return (sc_w_inventory(nScale, dsdGenContext));
+  if (table == S_INVENTORY)
+    return (
+        getIDCount(ITEM, dsdGenContext) *
+        get_rowcount(WAREHOUSE, dsdGenContext) * 6);
+
+  return (dsdGenContext.arRowcount[table].kBaseRowcount);
+}
+
+/*
+ * Routine: setUpdateDates
+ * Purpose: determine the dates for fact table updates
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void setUpdateDates(DSDGenContext& dsdGenContext) {
+  assert(0);
+  int nDay, nUpdate, i;
+  date_t dtTemp;
+
+  nUpdate = get_int("UPDATE", dsdGenContext);
+  while (nUpdate--) {
+    /* pick two adjacent days in the low density zone */
+    dsdGenContext.arUpdateDates[0] =
+        getSkewedJulianDate(calendar_low, 0, dsdGenContext);
+    jtodt(&dtTemp, dsdGenContext.arUpdateDates[0]);
+    dist_weight(
+        &nDay,
+        "calendar",
+        day_number(&dtTemp) + 1,
+        calendar_low,
+        dsdGenContext);
+    if (nDay)
+      dsdGenContext.arUpdateDates[1] = dsdGenContext.arUpdateDates[0] + 1;
+    else
+      dsdGenContext.arUpdateDates[1] = dsdGenContext.arUpdateDates[0] - 1;
+
+    /*
+     * pick the related Thursdays for inventory
+     * 1. shift first date to the Thursday in the current update week
+     * 2. move forward/back to get into correct comparability zone
+     * 3. set next date to next/prior Thursday based on comparability zone
+     */
+    jtodt(&dtTemp, dsdGenContext.arUpdateDates[0] + (4 - set_dow(&dtTemp)));
+    dist_weight(
+        &nDay, "calendar", day_number(&dtTemp), calendar_low, dsdGenContext);
+    dsdGenContext.arInventoryUpdateDates[0] = dtTemp.julian;
+    if (!nDay) {
+      jtodt(&dtTemp, dtTemp.julian - 7);
+      dsdGenContext.arInventoryUpdateDates[0] = dtTemp.julian;
+      dist_weight(
+          &nDay, "calendar", day_number(&dtTemp), calendar_low, dsdGenContext);
+      if (!nDay)
+        dsdGenContext.arInventoryUpdateDates[0] += 14;
+    }
+
+    dsdGenContext.arInventoryUpdateDates[1] =
+        dsdGenContext.arInventoryUpdateDates[0] + 7;
+    jtodt(&dtTemp, dsdGenContext.arInventoryUpdateDates[1]);
+    dist_weight(
+        &nDay,
+        "calendar",
+        day_number(&dtTemp) + 1,
+        calendar_low,
+        dsdGenContext);
+    if (!nDay)
+      dsdGenContext.arInventoryUpdateDates[1] -= 14;
+
+    /* repeat for medium calendar zone */
+    dsdGenContext.arUpdateDates[2] =
+        getSkewedJulianDate(calendar_medium, 0, dsdGenContext);
+    jtodt(&dtTemp, dsdGenContext.arUpdateDates[2]);
+    dist_weight(
+        &nDay,
+        "calendar",
+        day_number(&dtTemp) + 1,
+        calendar_medium,
+        dsdGenContext);
+    if (nDay)
+      dsdGenContext.arUpdateDates[3] = dsdGenContext.arUpdateDates[2] + 1;
+    else
+      dsdGenContext.arUpdateDates[3] = dsdGenContext.arUpdateDates[2] - 1;
+
+    jtodt(&dtTemp, dsdGenContext.arUpdateDates[2] + (4 - set_dow(&dtTemp)));
+    dist_weight(
+        &nDay, "calendar", day_number(&dtTemp), calendar_medium, dsdGenContext);
+    dsdGenContext.arInventoryUpdateDates[2] = dtTemp.julian;
+    if (!nDay) {
+      jtodt(&dtTemp, dtTemp.julian - 7);
+      dsdGenContext.arInventoryUpdateDates[2] = dtTemp.julian;
+      dist_weight(
+          &nDay,
+          "calendar",
+          day_number(&dtTemp),
+          calendar_medium,
+          dsdGenContext);
+      if (!nDay)
+        dsdGenContext.arInventoryUpdateDates[2] += 14;
+    }
+
+    dsdGenContext.arInventoryUpdateDates[3] =
+        dsdGenContext.arInventoryUpdateDates[2] + 7;
+    jtodt(&dtTemp, dsdGenContext.arInventoryUpdateDates[3]);
+    dist_weight(
+        &nDay, "calendar", day_number(&dtTemp), calendar_medium, dsdGenContext);
+    if (!nDay)
+      dsdGenContext.arInventoryUpdateDates[3] -= 14;
+
+    /* repeat for high calendar zone */
+    dsdGenContext.arUpdateDates[4] =
+        getSkewedJulianDate(calendar_high, 0, dsdGenContext);
+    jtodt(&dtTemp, dsdGenContext.arUpdateDates[4]);
+    dist_weight(
+        &nDay,
+        "calendar",
+        day_number(&dtTemp) + 1,
+        calendar_high,
+        dsdGenContext);
+    if (nDay)
+      dsdGenContext.arUpdateDates[5] = dsdGenContext.arUpdateDates[4] + 1;
+    else
+      dsdGenContext.arUpdateDates[5] = dsdGenContext.arUpdateDates[4] - 1;
+
+    jtodt(&dtTemp, dsdGenContext.arUpdateDates[4] + (4 - set_dow(&dtTemp)));
+    dist_weight(
+        &nDay, "calendar", day_number(&dtTemp), calendar_high, dsdGenContext);
+    dsdGenContext.arInventoryUpdateDates[4] = dtTemp.julian;
+    if (!nDay) {
+      jtodt(&dtTemp, dtTemp.julian - 7);
+      dsdGenContext.arInventoryUpdateDates[4] = dtTemp.julian;
+      dist_weight(
+          &nDay, "calendar", day_number(&dtTemp), calendar_high, dsdGenContext);
+      if (!nDay)
+        dsdGenContext.arInventoryUpdateDates[4] += 14;
+    }
+
+    dsdGenContext.arInventoryUpdateDates[5] =
+        dsdGenContext.arInventoryUpdateDates[4] + 7;
+    jtodt(&dtTemp, dsdGenContext.arInventoryUpdateDates[5]);
+    dist_weight(
+        &nDay, "calendar", day_number(&dtTemp), calendar_high, dsdGenContext);
+    if (!nDay)
+      dsdGenContext.arInventoryUpdateDates[5] -= 14;
+  }
+
+  //	/*
+  //	 * output the update dates for this update set
+  //	 */
+  //	openDeleteFile(1);
+  //	for (i = 0; i < 6; i += 2)
+  //		print_delete(&arUpdateDates[i]);
+  //
+  //	/*
+  //	 * inventory uses separate dates
+  //	 */
+  //	openDeleteFile(2);
+  //	for (i = 0; i < 6; i += 2)
+  //		print_delete(&arInventoryUpdateDates[i]);
+  //	openDeleteFile(0);
+
+  return;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int getUpdateDate(
+    int nTable,
+    ds_key_t kRowcount,
+    DSDGenContext& dsdGenContext) {
+  static int nIndex = 0, nLastTable = -1;
+
+  if (nLastTable != nTable) {
+    nLastTable = nTable;
+    get_rowcount(nTable, dsdGenContext);
+    nIndex = 0;
+  }
+
+  for (nIndex = 0;
+       kRowcount > dsdGenContext.arRowcount[nTable].kDayRowcount[nIndex];
+       nIndex++)
+    if (nIndex == 5)
+      break;
+
+  if (nTable == S_INVENTORY) {
+    return (dsdGenContext.arInventoryUpdateDates[nIndex]);
+  } else
+    return (dsdGenContext.arUpdateDates[nIndex]);
+}
+
+/*
+ * Routine: getUpdateID(int nTable, ds_key_t *pDest)
+ * Purpose: select the primary key for an update set row
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns: 1 if the row is new, 0 if it is reusing an existing ID
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: 20040326 jms getUpdateID() this MUST be updated for 64bit -- all usages
+ * use casts today
+ * TODO:	20060102 jms this will need to be looked at for parallelism at
+ * some point
+ */
+/*
+int
+getUpdateID(ds_key_t *pDest, int nTable, int nColumn)
+{
+    int bIsUpdate = 0,
+        nTemp;
+
+    if (genrand_integer(NULL, DIST_UNIFORM, 0, 99, 0, nColumn, dsdGenContext) <
+arRowcount[nTable].nUpdatePercentage)
+    {
+        bIsUpdate = 1;
+        genrand_integer(&nTemp, DIST_UNIFORM, 1, (int,
+dsdGenContext)getIDCount(nTable), 0, nColumn); *pDest = (ds_key_t)nTemp;
+    }
+    else
+    {
+        *pDest = ++arRowcount[nTable].kNextInsertValue;
+    }
+
+    return(bIsUpdate);
+}
+*/
+
+/*
+ * Routine: getSkewedJulianDate(int nWeight, int nColumn, DSDGenContext&
+ * dsdGenContext) Purpose: return a julian date based on the given skew and
+ * column Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int getSkewedJulianDate(
+    int nWeight,
+    int nColumn,
+    DSDGenContext& dsdGenContext) {
+  int i;
+  date_t Date;
+
+  pick_distribution(&i, "calendar", 1, nWeight, nColumn, dsdGenContext);
+  genrand_integer(
+      &Date.year,
+      DIST_UNIFORM,
+      YEAR_MINIMUM,
+      YEAR_MAXIMUM,
+      0,
+      nColumn,
+      dsdGenContext);
+  dist_member(&Date.day, "calendar", i, 3, dsdGenContext);
+  dist_member(&Date.month, "calendar", i, 5, dsdGenContext);
+  return (dttoj(&Date));
+}
+
+/*
+ * Routine: dateScaling(int nTable, ds_key_t jDate)
+ * Purpose: determine the number of rows to build for a given date and fact
+ * table Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t dateScaling(int nTable, ds_key_t jDate, DSDGenContext& dsdGenContext) {
+  const d_idx_t* pDistIndex;
+  date_t Date;
+  int nDateWeight = 1, nCalendarTotal, nDayWeight;
+  ds_key_t kRowCount = -1;
+  tdef* pTdef = getSimpleTdefsByNumber(nTable, dsdGenContext);
+  pDistIndex = find_dist("calendar");
+  const dist_t* pDist = &pDistIndex->dist;
+  if (!pDist)
+    ReportError(QERR_NO_MEMORY, "dateScaling()", 1);
+
+  jtodt(&Date, static_cast<int>(jDate));
+
+  switch (nTable) {
+    case STORE_SALES:
+    case CATALOG_SALES:
+    case WEB_SALES:
+      kRowCount = get_rowcount(nTable, dsdGenContext);
+      nDateWeight = calendar_sales;
+      break;
+    case S_CATALOG_ORDER:
+      kRowCount = get_rowcount(CATALOG_SALES, dsdGenContext);
+      nDateWeight = calendar_sales;
+      break;
+    case S_PURCHASE:
+      kRowCount = get_rowcount(STORE_SALES, dsdGenContext);
+      nDateWeight = calendar_sales;
+      break;
+    case S_WEB_ORDER:
+      kRowCount = get_rowcount(WEB_SALES, dsdGenContext);
+      nDateWeight = calendar_sales;
+      break;
+    case S_INVENTORY:
+    case INVENTORY:
+      nDateWeight = calendar_uniform;
+      kRowCount = get_rowcount(WAREHOUSE, dsdGenContext) *
+          getIDCount(ITEM, dsdGenContext);
+      break;
+    default:
+      ReportErrorNoLine(QERR_TABLE_NOP, pTdef->name, 1);
+      break;
+  }
+
+  if (nTable !=
+      INVENTORY) /* inventory rowcount is uniform thorughout the year */
+  {
+    if (is_leap(Date.year))
+      nDateWeight += 1;
+
+    nCalendarTotal = dist_max(pDist, nDateWeight, dsdGenContext);
+    nCalendarTotal *= 5; /* assumes date range is 5 years */
+
+    dist_weight(
+        &nDayWeight, "calendar", day_number(&Date), nDateWeight, dsdGenContext);
+    kRowCount *= nDayWeight;
+    kRowCount += nCalendarTotal / 2;
+    kRowCount /= nCalendarTotal;
+  }
+
+  return (kRowCount);
+}
+
+/*
+ * Routine: getUpdateBase(int nTable)
+ * Purpose: return the offset to the first order in this update set for a given
+ * table Algorithm: Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t getUpdateBase(int nTable, DSDGenContext& dsdGenContext) {
+  return (dsdGenContext.arRowcount[nTable - S_BRAND].kNextInsertValue);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void setUpdateScaling(int nTable, DSDGenContext& dsdGenContext) {
+  tdef* pTdef;
+  int i, nBaseTable;
+  ds_key_t kNewRowcount = 0;
+
+  pTdef = getSimpleTdefsByNumber(nTable, dsdGenContext);
+  if (!(pTdef->flags & FL_SOURCE_DDL) || !(pTdef->flags & FL_DATE_BASED) ||
+      (pTdef->flags & FL_NOP))
+    return;
+
+  switch (nTable) {
+    case S_PURCHASE:
+      nBaseTable = STORE_SALES;
+      break;
+    case S_CATALOG_ORDER:
+      nBaseTable = CATALOG_SALES;
+      break;
+    case S_WEB_ORDER:
+      nBaseTable = WEB_SALES;
+      break;
+    case S_INVENTORY:
+      nBaseTable = INVENTORY;
+      break;
+    default: {
+      auto result =
+          fprintf(stderr, "ERROR: Invalid table in setUpdateScaling\n");
+      if (result < 0)
+        perror("sprintf failed");
+      exit(1);
+      break;
+    }
+  }
+
+  dsdGenContext.arRowcount[nTable].kNextInsertValue =
+      dsdGenContext.arRowcount[nTable].kBaseRowcount;
+
+  for (i = 0; i < 6; i++) {
+    kNewRowcount +=
+        dateScaling(nBaseTable, dsdGenContext.arUpdateDates[i], dsdGenContext);
+    dsdGenContext.arRowcount[nTable].kDayRowcount[i] = kNewRowcount;
+  }
+
+  dsdGenContext.arRowcount[nTable].kBaseRowcount = kNewRowcount;
+  dsdGenContext.arRowcount[nTable].kNextInsertValue +=
+      kNewRowcount * (get_int("update", dsdGenContext) - 1);
+
+  return;
+}
diff --git a/velox/tpcds/gen/dsdgen/scd.cpp b/velox/tpcds/gen/dsdgen/scd.cpp
new file mode 100644
index 000000000000..81d32c85b9e2
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/scd.cpp
@@ -0,0 +1,395 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/scd.h"
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/params.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+/* an array of the most recent business key for each table */
+char arBKeys[MAX_TABLE][17];
+
+/*
+ * Routine: setSCDKey
+ * Purpose: handle the versioning and date stamps for slowly changing dimensions
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params: 1 if there is a new id; 0 otherwise
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions: Table indexs (surrogate keys) are 1-based. This assures that the
+ *arBKeys[] entry for each table is initialized. Otherwise, parallel generation
+ *would be more difficult. Side Effects:
+ * TODO: None
+ */
+int setSCDKeys(
+    int nColumnID,
+    ds_key_t kIndex,
+    char* szBKey,
+    ds_key_t* pkBeginDateKey,
+    ds_key_t* pkEndDateKey,
+    DSDGenContext& dsdGenContext) {
+  int bNewBKey = 0, nModulo;
+  ds_key_t jMinimumDataDate, jMaximumDataDate, jH1DataDate, jT1DataDate,
+      jT2DataDate;
+  date_t dtTemp;
+  int nTableID;
+
+  strtodt(&dtTemp, DATA_START_DATE);
+  jMinimumDataDate = dtTemp.julian;
+  strtodt(&dtTemp, DATA_END_DATE);
+  jMaximumDataDate = dtTemp.julian;
+  jH1DataDate = jMinimumDataDate + (jMaximumDataDate - jMinimumDataDate) / 2;
+  jT2DataDate = (jMaximumDataDate - jMinimumDataDate) / 3;
+  jT1DataDate = jMinimumDataDate + jT2DataDate;
+  jT2DataDate += jT1DataDate;
+
+  nTableID = getTableFromColumn(nColumnID, dsdGenContext);
+  nModulo = (int)(kIndex % 6);
+  switch (nModulo) {
+    case 1: /* 1 revision */
+      mk_bkey(arBKeys[nTableID], kIndex, nColumnID);
+      bNewBKey = 1;
+      *pkBeginDateKey = jMinimumDataDate - nTableID * 6;
+      *pkEndDateKey = -1;
+      break;
+    case 2: /* 1 of 2 revisions */
+      mk_bkey(arBKeys[nTableID], kIndex, nColumnID);
+      bNewBKey = 1;
+      *pkBeginDateKey = jMinimumDataDate - nTableID * 6;
+      *pkEndDateKey = jH1DataDate - nTableID * 6;
+      break;
+    case 3: /* 2 of 2 revisions */
+      mk_bkey(arBKeys[nTableID], kIndex - 1, nColumnID);
+      *pkBeginDateKey = jH1DataDate - nTableID * 6 + 1;
+      *pkEndDateKey = -1;
+      break;
+    case 4: /* 1 of 3 revisions */
+      mk_bkey(arBKeys[nTableID], kIndex, nColumnID);
+      bNewBKey = 1;
+      *pkBeginDateKey = jMinimumDataDate - nTableID * 6;
+      *pkEndDateKey = jT1DataDate - nTableID * 6;
+      break;
+    case 5: /* 2 of 3 revisions */
+      mk_bkey(arBKeys[nTableID], kIndex - 1, nColumnID);
+      *pkBeginDateKey = jT1DataDate - nTableID * 6 + 1;
+      *pkEndDateKey = jT2DataDate - nTableID * 6;
+      break;
+    case 0: /* 3 of 3 revisions */
+      mk_bkey(arBKeys[nTableID], kIndex - 2, nColumnID);
+      *pkBeginDateKey = jT2DataDate - nTableID * 6 + 1;
+      *pkEndDateKey = -1;
+      break;
+  }
+
+  /* can't have a revision in the future, per bug 114 */
+  if (*pkEndDateKey > jMaximumDataDate)
+    *pkEndDateKey = -1;
+
+  strcpy(szBKey, arBKeys[nTableID]);
+
+  return (bNewBKey);
+}
+
+/*
+ * Routine: scd_join(int tbl, int col, ds_key_t jDate)
+ * Purpose: create joins to slowly changing dimensions
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t
+scd_join(int tbl, int col, ds_key_t jDate, DSDGenContext& dsdGenContext) {
+  ds_key_t res, kRowcount;
+  static int jMinimumDataDate, jMaximumDataDate, jT1DataDate, jT2DataDate;
+  date_t dtTemp;
+
+  if (!dsdGenContext.scd_join_init) {
+    strtodt(&dtTemp, DATA_START_DATE);
+    jMinimumDataDate = dtTemp.julian;
+    strtodt(&dtTemp, DATA_END_DATE);
+    jMaximumDataDate = dtTemp.julian;
+    jT2DataDate = (jMaximumDataDate - jMinimumDataDate) / 3;
+    jT1DataDate = jMinimumDataDate + jT2DataDate;
+    jT2DataDate += jT1DataDate;
+    dsdGenContext.scd_join_init = 1;
+  }
+
+  kRowcount = getIDCount(tbl, dsdGenContext);
+  genrand_key(
+      &res,
+      DIST_UNIFORM,
+      1,
+      kRowcount,
+      0,
+      col,
+      dsdGenContext); /* pick the id */
+  res = matchSCDSK(
+      res,
+      jDate,
+      tbl,
+      dsdGenContext); /* map to the date-sensitive surrogate key */
+
+  /* can't have a revision in the future, per bug 114 */
+  if (jDate > jMaximumDataDate)
+    res = -1;
+
+  return ((res > get_rowcount(tbl, dsdGenContext)) ? -1 : res);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t matchSCDSK(
+    ds_key_t kUnique,
+    ds_key_t jDate,
+    int nTable,
+    DSDGenContext& dsdGenContext) {
+  ds_key_t kReturn = -1;
+  int jMinimumDataDate, jMaximumDataDate;
+  int jH1DataDate, jT1DataDate, jT2DataDate;
+  date_t dtTemp;
+
+  strtodt(&dtTemp, DATA_START_DATE);
+  jMinimumDataDate = dtTemp.julian;
+  strtodt(&dtTemp, DATA_END_DATE);
+  jMaximumDataDate = dtTemp.julian;
+  jH1DataDate = jMinimumDataDate + (jMaximumDataDate - jMinimumDataDate) / 2;
+  jT2DataDate = (jMaximumDataDate - jMinimumDataDate) / 3;
+  jT1DataDate = jMinimumDataDate + jT2DataDate;
+  jT2DataDate += jT1DataDate;
+
+  switch (kUnique % 3) /* number of revisions for the ID */
+  {
+    case 1: /* only one occurrence of this ID */
+      kReturn = (kUnique / 3) * 6;
+      kReturn += 1;
+      break;
+    case 2: /* two revisions of this ID */
+      kReturn = (kUnique / 3) * 6;
+      kReturn += 2;
+      if (jDate > jH1DataDate)
+        kReturn += 1;
+      break;
+    case 0: /* three revisions of this ID */
+      kReturn = (kUnique / 3) * 6;
+      kReturn += -2;
+      if (jDate > jT1DataDate)
+        kReturn += 1;
+      if (jDate > jT2DataDate)
+        kReturn += 1;
+      break;
+  }
+
+  if (kReturn > get_rowcount(nTable, dsdGenContext))
+    kReturn = get_rowcount(nTable, dsdGenContext);
+
+  return (kReturn);
+}
+
+/*
+ * Routine:
+ * Purpose: map from a unique ID to a random SK
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t getSKFromID(ds_key_t kID, int nColumn, DSDGenContext& dsdGenContext) {
+  ds_key_t kTemp = -1;
+
+  switch (kID % 3) {
+    case 1: /* single revision */
+      kTemp = kID / 3;
+      kTemp *= 6;
+      kTemp += 1;
+      break;
+    case 2: /* two revisions */
+      kTemp = kID / 3;
+      kTemp *= 6;
+      kTemp +=
+          genrand_integer(NULL, DIST_UNIFORM, 2, 3, 0, nColumn, dsdGenContext);
+      break;
+    case 0: /* three revisions */
+      kTemp = kID / 3;
+      kTemp -= 1;
+      kTemp *= 6;
+      kTemp +=
+          genrand_integer(NULL, DIST_UNIFORM, 4, 6, 0, nColumn, dsdGenContext);
+      break;
+  }
+
+  return (kTemp);
+}
+
+/*
+ * Routine: getFirstSK
+ * Purpose: map from id to an SK that can be mapped back to an id by printID()
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t getFirstSK(ds_key_t kID) {
+  ds_key_t kTemp = -1;
+
+  switch (kID % 3) {
+    case 1: /* single revision */
+      kTemp = kID / 3;
+      kTemp *= 6;
+      kTemp += 1;
+      break;
+    case 2: /* two revisions */
+      kTemp = kID / 3;
+      kTemp *= 6;
+      kTemp += 2;
+      break;
+    case 0: /* three revisions */
+      kTemp = kID / 3;
+      kTemp -= 1;
+      kTemp *= 6;
+      kTemp += 4;
+      break;
+  }
+
+  return (kTemp);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void changeSCD(
+    int nDataType,
+    void* pNewData,
+    void* pOldData,
+    int* nFlags,
+    int bFirst) {
+  /**
+   * if nFlags is odd, then this value will be retained
+   */
+  if ((*nFlags != ((*nFlags / 2) * 2)) && (bFirst == 0)) {
+    /*
+     * the method to retain the old value depends on the data type
+     */
+    switch (nDataType) {
+      case SCD_INT:
+        *static_cast<int*>(pNewData) = *static_cast<int*>(pOldData);
+        break;
+      case SCD_PTR:
+        pNewData = pOldData;
+        break;
+      case SCD_KEY:
+        *static_cast<ds_key_t*>(pNewData) = *static_cast<ds_key_t*>(pOldData);
+        break;
+      case SCD_CHAR:
+        strcpy(static_cast<char*>(pNewData), static_cast<char*>(pOldData));
+        break;
+      case SCD_DEC:
+        if (pNewData && pOldData)
+          memcpy(pNewData, pOldData, sizeof(decimal_t));
+        break;
+    }
+  } else {
+    /*
+     * the method to set the old value depends on the data type
+     */
+    switch (nDataType) {
+      case SCD_INT:
+        *static_cast<int*>(pOldData) = *static_cast<int*>(pNewData);
+        break;
+      case SCD_PTR:
+        pOldData = pNewData;
+        break;
+      case SCD_KEY:
+        *static_cast<ds_key_t*>(pOldData) = *static_cast<ds_key_t*>(pNewData);
+        break;
+      case SCD_CHAR:
+        strcpy(static_cast<char*>(pOldData), static_cast<char*>(pNewData));
+        break;
+      case SCD_DEC:
+        if (pOldData && pNewData)
+          memcpy(pOldData, pNewData, sizeof(decimal_t));
+        break;
+    }
+  }
+
+  *nFlags /= 2;
+
+  return;
+}
diff --git a/velox/tpcds/gen/dsdgen/skip_days.cpp b/velox/tpcds/gen/dsdgen/skip_days.cpp
new file mode 100644
index 000000000000..70badd3f0ed8
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/skip_days.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/skip_days.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+
+ds_key_t
+skipDays(int nTable, ds_key_t* pRemainder, DSDGenContext& dsdGenContext) {
+  date_t BaseDate;
+  ds_key_t jDate;
+  ds_key_t kRowCount, kFirstRow, kDayCount, index = 1;
+
+  if (!dsdGenContext.skipDays_init) {
+    *pRemainder = 0;
+    dsdGenContext.skipDays_init = 1;
+  }
+  strtodt(&BaseDate, DATA_START_DATE);
+
+  // set initial conditions
+  jDate = BaseDate.julian;
+  *pRemainder = dateScaling(nTable, jDate, dsdGenContext) + index;
+
+  // now check to see if we need to move to the
+  // the next piece of a parallel build
+  // move forward one day at a time
+  split_work(nTable, &kFirstRow, &kRowCount, dsdGenContext);
+  while (index < kFirstRow) {
+    kDayCount = dateScaling(nTable, jDate, dsdGenContext);
+    index += kDayCount;
+    jDate += 1;
+    *pRemainder = index;
+  }
+  if (index > kFirstRow) {
+    jDate -= 1;
+  }
+  return (jDate);
+}
diff --git a/velox/tpcds/gen/dsdgen/sparse.cpp b/velox/tpcds/gen/dsdgen/sparse.cpp
new file mode 100644
index 000000000000..7a79f1fd47c5
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/sparse.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/sparse.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+/*
+ * Routine: initSparseKeys()
+ * Purpose: set up the set of valid key values for a sparse table.
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions: The total population will fit in 32b
+ * Side Effects:
+ * TODO: None
+ */
+int initSparseKeys(int nTable, DSDGenContext& dsdGenContext) {
+  ds_key_t kRowcount, kOldSeed;
+  int k;
+  tdef* pTdef;
+
+  kRowcount = get_rowcount(nTable, dsdGenContext);
+  pTdef = getTdefsByNumber(nTable, dsdGenContext);
+
+  pTdef->arSparseKeys.resize(kRowcount, 0);
+  kOldSeed = setSeed(0, nTable, dsdGenContext);
+  for (k = 0; k < kRowcount; k++)
+    genrand_key(
+        &pTdef->arSparseKeys[k],
+        DIST_UNIFORM,
+        1,
+        pTdef->nParam,
+        0,
+        0,
+        dsdGenContext);
+  setSeed(0, static_cast<int>(kOldSeed), dsdGenContext);
+
+  return (0);
+}
+
+/*
+ * Routine: randomSparseKey()
+ * Purpose: randomly select one of the valid key values for a sparse table
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t
+randomSparseKey(int nTable, int nColumn, DSDGenContext& dsdGenContext) {
+  int nKeyIndex;
+  ds_key_t kRowcount;
+  tdef* pTdef;
+
+  pTdef = getTdefsByNumber(nTable, dsdGenContext);
+  kRowcount = get_rowcount(nTable, dsdGenContext);
+  genrand_integer(
+      &nKeyIndex,
+      DIST_UNIFORM,
+      1,
+      static_cast<long>(kRowcount),
+      0,
+      nColumn,
+      dsdGenContext);
+
+  return (pTdef->arSparseKeys[nKeyIndex]);
+}
diff --git a/velox/tpcds/gen/dsdgen/tdef_functions.cpp b/velox/tpcds/gen/dsdgen/tdef_functions.cpp
new file mode 100644
index 000000000000..989870cd6648
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/tdef_functions.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
+#include "velox/tpcds/gen/dsdgen/include/dbgen_version.h"
+#include "velox/tpcds/gen/dsdgen/include/w_call_center.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_page.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer_address.h"
+#include "velox/tpcds/gen/dsdgen/include/w_customer_demographics.h"
+#include "velox/tpcds/gen/dsdgen/include/w_datetbl.h"
+#include "velox/tpcds/gen/dsdgen/include/w_household_demographics.h"
+#include "velox/tpcds/gen/dsdgen/include/w_income_band.h"
+#include "velox/tpcds/gen/dsdgen/include/w_inventory.h"
+#include "velox/tpcds/gen/dsdgen/include/w_item.h"
+#include "velox/tpcds/gen/dsdgen/include/w_promotion.h"
+#include "velox/tpcds/gen/dsdgen/include/w_reason.h"
+#include "velox/tpcds/gen/dsdgen/include/w_ship_mode.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/w_timetbl.h"
+#include "velox/tpcds/gen/dsdgen/include/w_warehouse.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_page.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_returns.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_site.h"
+
+table_func_t w_tdef_funcs[] = {
+    {"call_center", mk_w_call_center, {NULL, NULL}, NULL},
+    {"catalog_page", mk_w_catalog_page, {NULL, NULL}, NULL},
+    {"catalog_returns", NULL, {NULL, NULL}, NULL},
+    {"catalog_sales", mk_w_catalog_sales, {NULL, NULL}, NULL},
+    {"customer", mk_w_customer, {NULL, NULL}, NULL},
+    {"customer_address", mk_w_customer_address, {NULL, NULL}, NULL},
+    {"customer_demographics", mk_w_customer_demographics, {NULL, NULL}, NULL},
+    {"date", mk_w_date, {NULL, NULL}, NULL},
+    {"household_demographics", mk_w_household_demographics, {NULL, NULL}, NULL},
+    {"income_band", mk_w_income_band, {NULL, NULL}, NULL},
+    {"inventory", mk_w_inventory, {NULL, NULL}, NULL},
+    {"item", mk_w_item, {NULL, NULL}, NULL},
+    {"promotion", mk_w_promotion, {NULL, NULL}, NULL},
+    {"reason", mk_w_reason, {NULL, NULL}, NULL},
+    {"ship_mode", mk_w_ship_mode, {NULL, NULL}, NULL},
+    {"store", mk_w_store, {NULL, NULL}, NULL},
+    {"store_returns", mk_w_store_returns, {NULL, NULL}, NULL},
+    {"store_sales", mk_w_store_sales, {NULL, NULL}, NULL},
+    {"time", mk_w_time, {NULL, NULL}, NULL},
+    {"warehouse", mk_w_warehouse, {NULL, NULL}, NULL},
+    {"web_page", mk_w_web_page, {NULL, NULL}, NULL},
+    {"web_returns", mk_w_web_returns, {NULL, NULL}, NULL},
+    {"web_sales", mk_w_web_sales, {NULL, NULL}, NULL},
+    {"web_site", mk_w_web_site, {NULL, NULL}, NULL},
+    {"dbgen_version", mk_dbgen_version, {NULL, NULL}, NULL},
+    {NULL, NULL, {NULL, NULL}, NULL}};
+
+table_func_t* getTdefFunctionsByNumber(int nTable) {
+  return (&w_tdef_funcs[nTable]);
+}
diff --git a/velox/tpcds/gen/dsdgen/tdefs.cpp b/velox/tpcds/gen/dsdgen/tdefs.cpp
new file mode 100644
index 000000000000..51ff9606376e
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/tdefs.cpp
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdef_functions.h"
+
+/*
+ * Routine: get_rowcount(int table)
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t GetRowcountByName(char* szName, DSDGenContext& dsdGenContext) {
+  int nTable = -1;
+
+  nTable = GetTableNumber(szName, dsdGenContext);
+  if (nTable >= 0)
+    return (get_rowcount(nTable - 1, dsdGenContext));
+
+  nTable = distsize(szName, dsdGenContext);
+  return (nTable);
+}
+
+/*
+ * Routine: GetTableNumber(char *szName, DSDGenContext& dsdGenContext)
+ * Purpose: Return size of table, pseudo table or distribution
+ * Algorithm: Need to use rowcount distribution, since argument could be a
+ * pseudo table Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int GetTableNumber(char* szName, DSDGenContext& dsdGenContext) {
+  int i;
+
+  for (i = 1; i <= distsize("rowcounts", dsdGenContext); i++) {
+    char* szTable = new char[100];
+    dist_member(szTable, "rowcounts", i, 1, dsdGenContext);
+    if (strcasecmp(szTable, szName) == 0)
+      return (i - 1);
+  }
+
+  return (-1);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+/*
+tdef *
+getTdefsByNumber(int nTable)
+{
+   if (is_set("UPDATE"))
+   {
+      if (s_tdefs[nTable].flags & FL_PASSTHRU)
+      {
+         switch(nTable + S_BRAND)
+         {
+         case S_CATALOG_PAGE: nTable = CATALOG_PAGE; break;
+         case S_CUSTOMER_ADDRESS: nTable = CUSTOMER_ADDRESS; break;
+         case S_PROMOTION: nTable = PROMOTION; break;
+         }
+         return(&w_tdefs[nTable]);
+      }
+      else
+         return(&s_tdefs[nTable]);
+   }
+    else
+        return(&w_tdefs[nTable]);
+}
+*/
+tdef* getSimpleTdefsByNumber(int nTable, DSDGenContext& dsdGenContext) {
+  if (nTable >= S_BRAND)
+    return (&dsdGenContext.s_tdefs[nTable - S_BRAND]);
+  return (&dsdGenContext.w_tdefs[nTable]);
+}
+
+tdef* getTdefsByNumber(int nTable, DSDGenContext& dsdGenContext) {
+  if (is_set("UPDATE", dsdGenContext) && is_set("VALIDATE", dsdGenContext)) {
+    if (static_cast<unsigned int>(dsdGenContext.s_tdefs[nTable].flags) &
+        FL_PASSTHRU) {
+      switch (nTable + S_BRAND) {
+        case S_CATALOG_PAGE:
+          nTable = CATALOG_PAGE;
+          break;
+        case S_CUSTOMER_ADDRESS:
+          nTable = CUSTOMER_ADDRESS;
+          break;
+        case S_PROMOTION:
+          nTable = PROMOTION;
+          break;
+      }
+      return (&dsdGenContext.w_tdefs[nTable]);
+    } else
+      return (&dsdGenContext.s_tdefs[nTable]);
+  }
+
+  return (getSimpleTdefsByNumber(nTable, dsdGenContext));
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+const char* getTableNameByID(int i, DSDGenContext& dsdGenContext) {
+  tdef* pT = getSimpleTdefsByNumber(i, dsdGenContext);
+
+  return (pT->name);
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int getTableFromColumn(int nColumn, DSDGenContext& dsdGenContext) {
+  int i;
+  tdef* pT;
+
+  for (i = 0; i <= MAX_TABLE; i++) {
+    pT = getSimpleTdefsByNumber(i, dsdGenContext);
+    if ((nColumn >= pT->nFirstColumn) && (nColumn <= pT->nLastColumn))
+      return (i);
+  }
+  return (-1);
+}
diff --git a/velox/tpcds/gen/dsdgen/text.cpp b/velox/tpcds/gen/dsdgen/text.cpp
new file mode 100644
index 000000000000..7484be0053fe
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/text.cpp
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+
+/*
+ * Routine: mk_sentence()
+ * Purpose: create a sample sentence
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+#define SPACE_INCREMENT 100
+
+char* mk_sentence(int stream, DSDGenContext& dsdGenContext) {
+  char* verbiage = nullptr;
+  int used_space = 0; /* current length of the sentence being built */
+  int allocated_space = 0;
+  int word_len = 0;
+  char *syntax = nullptr, *cp = nullptr, *word = nullptr, temp[2];
+
+  temp[1] = '\0';
+  pick_distribution(&syntax, "sentences", 1, 1, stream, dsdGenContext);
+
+  for (cp = syntax; *cp; cp++) {
+    switch (*cp) {
+      case 'N': /* pick a noun */
+        pick_distribution(&word, "nouns", 1, 1, stream, dsdGenContext);
+        break;
+      case 'V': /* pick a verb */
+        pick_distribution(&word, "verbs", 1, 1, stream, dsdGenContext);
+        break;
+      case 'J': /* pick a adjective */
+        pick_distribution(&word, "adjectives", 1, 1, stream, dsdGenContext);
+        break;
+      case 'D': /* pick a adverb */
+        pick_distribution(&word, "adverbs", 1, 1, stream, dsdGenContext);
+        break;
+      case 'X': /* pick a auxiliary verb */
+        pick_distribution(&word, "auxiliaries", 1, 1, stream, dsdGenContext);
+        break;
+      case 'P': /* pick a preposition */
+        pick_distribution(&word, "prepositions", 1, 1, stream, dsdGenContext);
+        break;
+      case 'A': /* pick an article */
+        pick_distribution(&word, "articles", 1, 1, stream, dsdGenContext);
+        break;
+      case 'T': /* pick an terminator */
+        pick_distribution(&word, "terminators", 1, 1, stream, dsdGenContext);
+        break;
+      default:
+        temp[0] = *cp;
+        break;
+    }
+
+    if (word == nullptr)
+      word_len = 1;
+    else
+      word_len = strlen(word);
+
+    if (used_space + word_len >= allocated_space) {
+      verbiage = static_cast<char*>(
+          realloc(verbiage, allocated_space + SPACE_INCREMENT));
+      MALLOC_CHECK(verbiage);
+      allocated_space += SPACE_INCREMENT;
+    }
+
+    if (word == nullptr)
+      strcpy(&verbiage[used_space], temp);
+    else
+      strcpy(&verbiage[used_space], word);
+    used_space += word_len;
+    word = nullptr;
+  }
+
+  return (verbiage);
+}
+
+/*
+ * Routine: gen_text()
+ * Purpose: entry point for this module. Generate a truncated sentence in a
+ *                     given length range
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+void gen_text(
+    char* dest,
+    int min,
+    int max,
+    int stream,
+    DSDGenContext& dsdGenContext) {
+  int target_len = 0, generated_length = 0, capitalize = 1;
+  char* s = nullptr;
+
+  genrand_integer(
+      &target_len, DIST_UNIFORM, min, max, 0, stream, dsdGenContext);
+  if (dest)
+    *dest = '\0';
+
+  while (target_len > 0) {
+    s = mk_sentence(stream, dsdGenContext);
+    if (capitalize)
+      *s = toupper(*s);
+    generated_length = strlen(s);
+    capitalize = (s[generated_length - 1] == '.');
+    if (target_len <= generated_length)
+      s[target_len] = '\0';
+    strcat(dest, s);
+    target_len -= generated_length;
+    if (target_len > 0) {
+      strcat(dest, " ");
+      target_len -= 1;
+    }
+    free(s);
+  }
+}
+
+#ifdef TEST
+#define DECLARER
+#include "velox/tpcds/gen/dsdgen/include/r_driver.h" // @manual
+#include "velox/tpcds/gen/dsdgen/include/r_params.h" // @manual
+
+typedef struct {
+  char* name;
+} tdef;
+/* tdef tdefs[] = {NULL}; */
+
+option_t options[] = {
+
+    {"DISTRIBUTIONS", OPT_STR, 0, NULL, NULL, "tester_dist.idx"},
+    NULL};
+
+char* params[2];
+
+main() {
+  char test_dest[201];
+  int i;
+
+  init_params();
+
+  for (i = 0; i < 100; i++) {
+    gen_text(test_dest, 100, 200, 1);
+    printf("%s\n", test_dest);
+    test_dest[0] = '\0';
+  }
+
+  return (0);
+}
+#endif
diff --git a/velox/tpcds/gen/dsdgen/w_call_center.cpp b/velox/tpcds/gen/dsdgen/w_call_center.cpp
new file mode 100644
index 000000000000..562ed4be6c3f
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_call_center.cpp
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_call_center.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/r_params.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+static struct CALL_CENTER_TBL g_call_center_OldValues;
+
+/*
+ * Routine: mk_w_call_center()
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20020830 jms Need to populate open and close dates
+ */
+
+int mk_w_call_center(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int32_t jDateStart;
+  int32_t nSuffix, bFirstRecord = 0, nFieldChangeFlags;
+  char *cp = nullptr, *sName1 = nullptr, *sName2 = nullptr;
+  decimal_t dMinTaxPercentage, dMaxTaxPercentage;
+  tdef* pTdef = getSimpleTdefsByNumber(CALL_CENTER, dsdGenContext);
+
+  /* begin locals declarations */
+  date_t dTemp;
+  double nScale;
+  struct CALL_CENTER_TBL *r, *rOldValues = &g_call_center_OldValues;
+
+  r = &dsdGenContext.g_w_call_center;
+
+  strtodt(&dTemp, DATA_START_DATE);
+  jDateStart = dttoj(&dTemp) - WEB_SITE;
+  nScale = get_dbl("SCALE", dsdGenContext);
+
+  r->cc_division_id = -1;
+  r->cc_closed_date_id = -1;
+  strcpy(r->cc_division_name, "No Name");
+
+  strtodec(&dMinTaxPercentage, MIN_CC_TAX_PERCENTAGE);
+  strtodec(&dMaxTaxPercentage, MAX_CC_TAX_PERCENTAGE);
+
+  nullSet(&pTdef->kNullBitMap, CC_NULLS, dsdGenContext);
+  r->cc_call_center_sk = index;
+
+  /* if we have generated the required history for this business key and
+   * generate a new one then reset associate fields (e.g., rec_start_date
+   * minimums)
+   */
+  if (setSCDKeys(
+          CC_CALL_CENTER_ID,
+          index,
+          r->cc_call_center_id,
+          &r->cc_rec_start_date_id,
+          &r->cc_rec_end_date_id,
+          dsdGenContext)) {
+    r->cc_open_date_id =
+        jDateStart -
+        genrand_integer(
+            NULL, DIST_UNIFORM, -365, 0, 0, CC_OPEN_DATE_ID, dsdGenContext);
+
+    /*
+     * some fields are not changed, even when a new version of the row is
+     * written
+     */
+    nSuffix = static_cast<int>(index / distsize("call_centers", dsdGenContext));
+    dist_member(
+        &cp,
+        "call_centers",
+        static_cast<int>((index % distsize("call_centers", dsdGenContext)) + 1),
+        1,
+        dsdGenContext);
+    if (nSuffix > 0) {
+      snprintf(r->cc_name, RS_CC_NAME + 1, "%s_%d", cp, nSuffix);
+    } else {
+      strcpy(r->cc_name, cp);
+    }
+
+    mk_address(&r->cc_address, CC_ADDRESS, dsdGenContext);
+    bFirstRecord = 1;
+  }
+
+  /*
+   * this is  where we select the random number that controls if a field
+   * changes from one record to the next.
+   */
+  nFieldChangeFlags = next_random(CC_SCD, dsdGenContext);
+
+  /* the rest of the record in a history-keeping dimension can either be a new
+   * data value or not; use a random number and its bit pattern to determine
+   * which fields to replace and which to retain
+   */
+  pick_distribution(
+      &r->cc_class, "call_center_class", 1, 1, CC_CLASS, dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->cc_class,
+      &rOldValues->cc_class,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->cc_employees,
+      DIST_UNIFORM,
+      1,
+      nScale >= 1 ? static_cast<int64_t>(CC_EMPLOYEE_MAX * nScale * nScale)
+                  : static_cast<int>(CC_EMPLOYEE_MAX),
+      0,
+      CC_EMPLOYEES,
+      dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->cc_employees,
+      &rOldValues->cc_employees,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->cc_sq_ft, DIST_UNIFORM, 100, 700, 0, CC_SQ_FT, dsdGenContext);
+  r->cc_sq_ft *= r->cc_employees;
+  changeSCD(
+      SCD_INT,
+      &r->cc_sq_ft,
+      &rOldValues->cc_sq_ft,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(
+      &r->cc_hours, "call_center_hours", 1, 1, CC_HOURS, dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->cc_hours,
+      &rOldValues->cc_hours,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(&sName1, "first_names", 1, 1, CC_MANAGER, dsdGenContext);
+  pick_distribution(&sName2, "last_names", 1, 1, CC_MANAGER, dsdGenContext);
+  snprintf(&r->cc_manager[0], RS_CC_MANAGER + 1, "%s %s", sName1, sName2);
+  changeSCD(
+      SCD_CHAR,
+      &r->cc_manager,
+      &rOldValues->cc_manager,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->cc_market_id, DIST_UNIFORM, 1, 6, 0, CC_MARKET_ID, dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->cc_market_id,
+      &rOldValues->cc_market_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  gen_text(
+      r->cc_market_class,
+      20,
+      RS_CC_MARKET_CLASS,
+      CC_MARKET_CLASS,
+      dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->cc_market_class,
+      &rOldValues->cc_market_class,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  gen_text(
+      r->cc_market_desc, 20, RS_CC_MARKET_DESC, CC_MARKET_DESC, dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->cc_market_desc,
+      &rOldValues->cc_market_desc,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(
+      &sName1, "first_names", 1, 1, CC_MARKET_MANAGER, dsdGenContext);
+  pick_distribution(
+      &sName2, "last_names", 1, 1, CC_MARKET_MANAGER, dsdGenContext);
+  snprintf(
+      &r->cc_market_manager[0],
+      RS_CC_MARKET_MANAGER + 1,
+      "%s %s",
+      sName1,
+      sName2);
+  changeSCD(
+      SCD_CHAR,
+      &r->cc_market_manager,
+      &rOldValues->cc_market_manager,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->cc_company, DIST_UNIFORM, 1, 6, 0, CC_COMPANY, dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->cc_company,
+      &rOldValues->cc_company,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->cc_division_id, DIST_UNIFORM, 1, 6, 0, CC_COMPANY, dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->cc_division_id,
+      &rOldValues->cc_division_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  mk_word(
+      r->cc_division_name,
+      "syllables",
+      r->cc_division_id,
+      RS_CC_DIVISION_NAME,
+      CC_DIVISION_NAME,
+      dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->cc_division_name,
+      &rOldValues->cc_division_name,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  mk_companyname(
+      r->cc_company_name, CC_COMPANY_NAME, r->cc_company, dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->cc_company_name,
+      &rOldValues->cc_company_name,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_decimal(
+      &r->cc_tax_percentage,
+      DIST_UNIFORM,
+      &dMinTaxPercentage,
+      &dMaxTaxPercentage,
+      NULL,
+      CC_TAX_PERCENTAGE,
+      dsdGenContext);
+  changeSCD(
+      SCD_DEC,
+      &r->cc_tax_percentage,
+      &rOldValues->cc_tax_percentage,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  // append the newly created row
+  std::vector<char> szTemp(128);
+
+  void* info = append_info_get(info_arr, CALL_CENTER);
+
+  append_row_start(info);
+  append_key(CC_CALL_CENTER_SK, info, r->cc_call_center_sk);
+  append_varchar(CC_CALL_CENTER_ID, info, r->cc_call_center_id);
+  append_date(CC_REC_START_DATE_ID, info, r->cc_rec_start_date_id);
+  append_date(CC_REC_END_DATE_ID, info, r->cc_rec_end_date_id);
+  append_integer(CC_CLOSED_DATE_ID, info, r->cc_closed_date_id);
+  append_integer(CC_OPEN_DATE_ID, info, r->cc_open_date_id);
+  append_varchar(CC_NAME, info, r->cc_name);
+  append_varchar(CC_CLASS, info, &r->cc_class[0]);
+  append_integer(CC_EMPLOYEES, info, r->cc_employees);
+  append_integer(CC_SQ_FT, info, r->cc_sq_ft);
+  append_varchar(CC_HOURS, info, r->cc_hours);
+  append_varchar(CC_MANAGER, info, &r->cc_manager[0]);
+  append_integer(CC_MARKET_ID, info, r->cc_market_id);
+  append_varchar(CC_MARKET_CLASS, info, &r->cc_market_class[0]);
+  append_varchar(CC_MARKET_DESC, info, &r->cc_market_desc[0]);
+  append_varchar(CC_MARKET_MANAGER, info, &r->cc_market_manager[0]);
+  append_integer(CC_DIVISION, info, r->cc_division_id);
+  append_varchar(CC_DIVISION_NAME, info, &r->cc_division_name[0]);
+  append_integer(CC_COMPANY, info, r->cc_company);
+  append_varchar(CC_COMPANY_NAME, info, &r->cc_company_name[0]);
+  append_varchar(CC_ADDRESS, info, std::to_string(r->cc_address.street_num));
+
+  if (r->cc_address.street_name2) {
+    snprintf(
+        szTemp.data(),
+        szTemp.size(),
+        "%s %s",
+        r->cc_address.street_name1,
+        r->cc_address.street_name2);
+    append_varchar(CC_ADDRESS, info, szTemp.data());
+  } else {
+    append_varchar(CC_ADDRESS, info, r->cc_address.street_name1);
+  }
+
+  append_varchar(CC_ADDRESS, info, r->cc_address.street_type);
+  append_varchar(CC_ADDRESS, info, &r->cc_address.suite_num[0]);
+  append_varchar(CC_ADDRESS, info, r->cc_address.city);
+  append_varchar(CC_ADDRESS, info, r->cc_address.county);
+  append_varchar(CC_ADDRESS, info, r->cc_address.state);
+  snprintf(szTemp.data(), szTemp.size(), "%05d", r->cc_address.zip);
+  append_varchar(CC_ADDRESS, info, szTemp.data());
+  append_varchar(CC_ADDRESS, info, &r->cc_address.country[0]);
+  append_integer_decimal(CC_GMT_OFFSET, info, r->cc_address.gmt_offset);
+  append_decimal(CC_TAX_PERCENTAGE, info, &r->cc_tax_percentage);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_catalog_page.cpp b/velox/tpcds/gen/dsdgen/w_catalog_page.cpp
new file mode 100644
index 000000000000..995fad7b60f1
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_catalog_page.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_catalog_page.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * Routine: mk_catalog_page()
+ * Purpose: populate the catalog_page table
+ * Algorithm:
+ *	catalogs are issued either monthly, quarterly or bi-annually (cp_type)
+ *	there is 1 of each type circulating at all times
+ * Data tdefsures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20020903 jms cp_department needs to be randomized
+ * 20020903 jms cp_description needs to be randomized
+ */
+int mk_w_catalog_page(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  date_t dStartDate;
+  int nCatalogPageMax;
+  int nDuration, nOffset, nType;
+  struct CATALOG_PAGE_TBL* r;
+  int nCatalogInterval;
+  tdef* pTdef = getSimpleTdefsByNumber(CATALOG_PAGE, dsdGenContext);
+
+  r = &dsdGenContext.g_w_catalog_page;
+
+  nCatalogPageMax =
+      (static_cast<int>(
+          get_rowcount(CATALOG_PAGE, dsdGenContext) / CP_CATALOGS_PER_YEAR)) /
+      (YEAR_MAXIMUM - YEAR_MINIMUM + 2);
+  dStartDate = strtodate(DATA_START_DATE);
+  strcpy(r->cp_department, "DEPARTMENT");
+
+  nullSet(&pTdef->kNullBitMap, CP_NULLS, dsdGenContext);
+  r->cp_catalog_page_sk = index;
+  mk_bkey(&r->cp_catalog_page_id[0], index, CP_CATALOG_PAGE_ID);
+  r->cp_catalog_number = static_cast<long>((index - 1) / nCatalogPageMax + 1);
+  r->cp_catalog_page_number =
+      static_cast<long>((index - 1) % nCatalogPageMax + 1);
+  switch (nCatalogInterval =
+              ((r->cp_catalog_number - 1) % CP_CATALOGS_PER_YEAR)) {
+    case 0: /* bi-annual */
+    case 1:
+      nType = 1;
+      nDuration = 182;
+      nOffset = nCatalogInterval * nDuration;
+      break;
+    case 2:
+    case 3: /* Q2 */
+    case 4: /* Q3 */
+    case 5: /* Q4 */
+      nDuration = 91;
+      nOffset = (nCatalogInterval - 2) * nDuration;
+      nType = 2;
+      break;
+    default:
+      nDuration = 30;
+      nOffset = (nCatalogInterval - 6) * nDuration;
+      nType = 3; /* monthly */
+  }
+  r->cp_start_date_id = dStartDate.julian + nOffset;
+  r->cp_start_date_id +=
+      ((r->cp_catalog_number - 1) / CP_CATALOGS_PER_YEAR) * 365;
+  r->cp_end_date_id = r->cp_start_date_id + nDuration - 1;
+  dist_member(&r->cp_type, "catalog_page_type", nType, 1, dsdGenContext);
+  gen_text(
+      &r->cp_description[0],
+      RS_CP_DESCRIPTION / 2,
+      RS_CP_DESCRIPTION - 1,
+      CP_DESCRIPTION,
+      dsdGenContext);
+
+  void* info = append_info_get(info_arr, CATALOG_PAGE);
+
+  append_row_start(info);
+
+  append_key(CP_CATALOG_PAGE_SK, info, r->cp_catalog_page_sk);
+  append_varchar(CP_CATALOG_PAGE_ID, info, r->cp_catalog_page_id);
+  append_integer(CP_START_DATE_ID, info, r->cp_start_date_id);
+  append_integer(CP_END_DATE_ID, info, r->cp_end_date_id);
+  append_varchar(CP_DEPARTMENT, info, &r->cp_department[0]);
+  append_integer(CP_CATALOG_NUMBER, info, r->cp_catalog_number);
+  append_integer(CP_CATALOG_PAGE_NUMBER, info, r->cp_catalog_page_number);
+  append_varchar(CP_DESCRIPTION, info, &r->cp_description[0]);
+  append_varchar(CP_TYPE, info, r->cp_type);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_catalog_returns.cpp b/velox/tpcds/gen/dsdgen/w_catalog_returns.cpp
new file mode 100644
index 000000000000..f76c0c97bd6d
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_catalog_returns.cpp
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_catalog_returns.h"
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_sales.h"
+
+/*
+ * Routine: mk_catalog_returns()
+ * Purpose: populate a return fact *sync'd with a sales fact*
+ * Algorithm: Since the returns need to be in line with a prior sale, they need
+ *	to use the output of the mk_catalog_sales() routine, and then add
+ *return-related information Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20020902 jms Need to link call center to date/time of return
+ * 20031023 jms removed ability for stand alone generation
+ */
+int mk_w_catalog_returns(
+    void* row,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int res = 0;
+
+  decimal_t dHundred;
+  int nTemp;
+  struct W_CATALOG_RETURNS_TBL* r;
+  struct W_CATALOG_SALES_TBL* sale = &dsdGenContext.g_w_catalog_sales;
+  static int bStandAlone = 0;
+  tdef* pTdef = getSimpleTdefsByNumber(CATALOG_RETURNS, dsdGenContext);
+
+  if (row == NULL)
+    r = &dsdGenContext.g_w_catalog_returns;
+  else
+    r = static_cast<W_CATALOG_RETURNS_TBL*>(row);
+  strtodec(&dHundred, "100.00");
+
+  /* if we were not called from the parent table's mk_xxx routine, then
+   * move to a parent row that needs to be returned, and generate it
+   */
+  nullSet(&pTdef->kNullBitMap, CR_NULLS, dsdGenContext);
+  if (bStandAlone) {
+    genrand_integer(
+        &nTemp, DIST_UNIFORM, 0, 99, 0, CR_IS_RETURNED, dsdGenContext);
+    if (nTemp >= CR_RETURN_PCT) {
+      row_skip(CATALOG_SALES, 1, dsdGenContext);
+      return (1);
+    }
+    mk_w_catalog_sales(&dsdGenContext.g_w_catalog_sales, index, dsdGenContext);
+  }
+
+  /*
+   * Some of the information in the return is taken from the original sale
+   * which has been regenerated
+   */
+  r->cr_item_sk = sale->cs_sold_item_sk;
+  r->cr_catalog_page_sk = sale->cs_catalog_page_sk;
+  r->cr_order_number = sale->cs_order_number;
+  memcpy(&r->cr_pricing, &sale->cs_pricing, sizeof(ds_pricing_t));
+  r->cr_refunded_customer_sk = sale->cs_bill_customer_sk;
+  r->cr_refunded_cdemo_sk = sale->cs_bill_cdemo_sk;
+  r->cr_refunded_hdemo_sk = sale->cs_bill_hdemo_sk;
+  r->cr_refunded_addr_sk = sale->cs_bill_addr_sk;
+  r->cr_call_center_sk = sale->cs_call_center_sk;
+
+  /*
+   * some of the fields are conditionally taken from the sale
+   */
+  r->cr_returning_customer_sk =
+      mk_join(CR_RETURNING_CUSTOMER_SK, CUSTOMER, 2, dsdGenContext);
+  r->cr_returning_cdemo_sk =
+      mk_join(CR_RETURNING_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 2, dsdGenContext);
+  r->cr_returning_hdemo_sk =
+      mk_join(CR_RETURNING_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 2, dsdGenContext);
+  r->cr_returning_addr_sk =
+      mk_join(CR_RETURNING_ADDR_SK, CUSTOMER_ADDRESS, 2, dsdGenContext);
+  if (genrand_integer(
+          NULL,
+          DIST_UNIFORM,
+          0,
+          99,
+          0,
+          CR_RETURNING_CUSTOMER_SK,
+          dsdGenContext) < CS_GIFT_PCT) {
+    r->cr_returning_customer_sk = sale->cs_ship_customer_sk;
+    r->cr_returning_cdemo_sk = sale->cs_ship_cdemo_sk;
+    /* cr_returning_hdemo_sk removed, since it doesn't exist on the sales
+     * record */
+    r->cr_returning_addr_sk = sale->cs_ship_addr_sk;
+  }
+
+  /**
+   * the rest of the columns are generated for this specific return
+   */
+  /* the items cannot be returned until they are shipped; offset is handled in
+   * mk_join, based on sales date */
+  r->cr_returned_date_sk =
+      mk_join(CR_RETURNED_DATE_SK, DATET, sale->cs_ship_date_sk, dsdGenContext);
+
+  /* the call center determines the time of the return */
+  r->cr_returned_time_sk =
+      mk_join(CR_RETURNED_TIME_SK, TIMET, 1, dsdGenContext);
+
+  r->cr_ship_mode_sk = mk_join(CR_SHIP_MODE_SK, SHIP_MODE, 1, dsdGenContext);
+  r->cr_warehouse_sk = mk_join(CR_WAREHOUSE_SK, WAREHOUSE, 1, dsdGenContext);
+  r->cr_reason_sk = mk_join(CR_REASON_SK, REASON, 1, dsdGenContext);
+  if (sale->cs_pricing.quantity != -1)
+    genrand_integer(
+        &r->cr_pricing.quantity,
+        DIST_UNIFORM,
+        1,
+        sale->cs_pricing.quantity,
+        0,
+        CR_PRICING,
+        dsdGenContext);
+  else
+    r->cr_pricing.quantity = -1;
+  set_pricing(CR_PRICING, &r->cr_pricing, dsdGenContext);
+
+  return (res);
+}
diff --git a/velox/tpcds/gen/dsdgen/w_catalog_sales.cpp b/velox/tpcds/gen/dsdgen/w_catalog_sales.cpp
new file mode 100644
index 000000000000..4eff2f3cc582
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_catalog_sales.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_catalog_sales.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/params.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_catalog_returns.h"
+
+#include <stdio.h>
+
+ds_key_t
+skipDays(int nTable, ds_key_t* pRemainder, DSDGenContext& dsdGenContext);
+
+/*
+ * the validation process requires generating a single lineitem
+ * so the main mk_xxx routine has been split into a master record portion
+ * and a detail/lineitem portion.
+ */
+W_CATALOG_SALES_TBL* mk_catalog_sales_master(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  decimal_t dZero, dHundred, dOne, dOneHalf;
+  int nGiftPct;
+  struct W_CATALOG_SALES_TBL* r;
+  r = &dsdGenContext.g_w_catalog_sales;
+
+  if (!dsdGenContext.mk_master_catalog_sales_init) {
+    dsdGenContext.jDate =
+        skipDays(CATALOG_SALES, &dsdGenContext.kNewDateIndex, dsdGenContext);
+    dsdGenContext.pCatalogSalesItemPermutation = makePermutation(
+        (dsdGenContext.nCatalogSalesItemCount =
+             static_cast<int>(getIDCount(ITEM, dsdGenContext))),
+        CS_PERMUTE,
+        dsdGenContext);
+
+    dsdGenContext.mk_master_catalog_sales_init = 1;
+  }
+
+  strtodec(&dZero, "0.00");
+  strtodec(&dHundred, "100.00");
+  strtodec(&dOne, "1.00");
+  strtodec(&dOneHalf, "0.50");
+
+  while (index > dsdGenContext.kNewDateIndex) /* need to move to a new date */
+  {
+    dsdGenContext.jDate += 1;
+    dsdGenContext.kNewDateIndex +=
+        dateScaling(CATALOG_SALES, dsdGenContext.jDate, dsdGenContext);
+  }
+
+  /***
+   * some attributes remain the same for each lineitem in an order; others are
+   * different for each lineitem.
+   *
+   * Parallel generation causes another problem, since the values that get
+   * seeded may come from a prior row. If we are seeding at the start of a
+   * parallel chunk, hunt backwards in the RNG stream to find the most recent
+   * values that were used to set the values of the orderline-invariant
+   * columns
+   */
+
+  r->cs_sold_date_sk = dsdGenContext.jDate;
+  r->cs_sold_time_sk =
+      mk_join(CS_SOLD_TIME_SK, TIMET, r->cs_call_center_sk, dsdGenContext);
+  r->cs_call_center_sk = (r->cs_sold_date_sk == -1)
+      ? -1
+      : mk_join(
+            CS_CALL_CENTER_SK, CALL_CENTER, r->cs_sold_date_sk, dsdGenContext);
+
+  r->cs_bill_customer_sk =
+      mk_join(CS_BILL_CUSTOMER_SK, CUSTOMER, 1, dsdGenContext);
+  r->cs_bill_cdemo_sk =
+      mk_join(CS_BILL_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1, dsdGenContext);
+  r->cs_bill_hdemo_sk =
+      mk_join(CS_BILL_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1, dsdGenContext);
+  r->cs_bill_addr_sk =
+      mk_join(CS_BILL_ADDR_SK, CUSTOMER_ADDRESS, 1, dsdGenContext);
+
+  /* most orders are for the ordering customers, some are not */
+  genrand_integer(
+      &nGiftPct, DIST_UNIFORM, 0, 99, 0, CS_SHIP_CUSTOMER_SK, dsdGenContext);
+  if (nGiftPct <= CS_GIFT_PCT) {
+    r->cs_ship_customer_sk =
+        mk_join(CS_SHIP_CUSTOMER_SK, CUSTOMER, 2, dsdGenContext);
+    r->cs_ship_cdemo_sk =
+        mk_join(CS_SHIP_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 2, dsdGenContext);
+    r->cs_ship_hdemo_sk =
+        mk_join(CS_SHIP_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 2, dsdGenContext);
+    r->cs_ship_addr_sk =
+        mk_join(CS_SHIP_ADDR_SK, CUSTOMER_ADDRESS, 2, dsdGenContext);
+  } else {
+    r->cs_ship_customer_sk = r->cs_bill_customer_sk;
+    r->cs_ship_cdemo_sk = r->cs_bill_cdemo_sk;
+    r->cs_ship_hdemo_sk = r->cs_bill_hdemo_sk;
+    r->cs_ship_addr_sk = r->cs_bill_addr_sk;
+  }
+
+  r->cs_order_number = index;
+  genrand_integer(
+      &dsdGenContext.nTicketItemBase,
+      DIST_UNIFORM,
+      1,
+      dsdGenContext.nCatalogSalesItemCount,
+      0,
+      CS_SOLD_ITEM_SK,
+      dsdGenContext);
+
+  return r;
+}
+
+static void mk_detail(
+    void* info_arr,
+    int bPrint,
+    struct W_CATALOG_SALES_TBL* r,
+    DSDGenContext& dsdGenContext) {
+  int nShipLag, nTemp;
+  ds_key_t kItem;
+  tdef* pTdef = getSimpleTdefsByNumber(CATALOG_SALES, dsdGenContext);
+
+  r = &dsdGenContext.g_w_catalog_sales;
+
+  nullSet(&pTdef->kNullBitMap, CS_NULLS, dsdGenContext);
+
+  /* orders are shipped some number of days after they are ordered */
+  genrand_integer(
+      &nShipLag,
+      DIST_UNIFORM,
+      CS_MIN_SHIP_DELAY,
+      CS_MAX_SHIP_DELAY,
+      0,
+      CS_SHIP_DATE_SK,
+      dsdGenContext);
+  r->cs_ship_date_sk =
+      (r->cs_sold_date_sk == -1) ? -1 : r->cs_sold_date_sk + nShipLag;
+
+  /*
+   * items need to be unique within an order
+   * use a sequence within the permutation
+   * NB: Permutations are 1-based
+   */
+  if (++dsdGenContext.nTicketItemBase > dsdGenContext.nCatalogSalesItemCount)
+    dsdGenContext.nTicketItemBase = 1;
+  kItem = getPermutationEntry(
+      dsdGenContext.pCatalogSalesItemPermutation,
+      dsdGenContext.nTicketItemBase);
+  r->cs_sold_item_sk =
+      matchSCDSK(kItem, r->cs_sold_date_sk, ITEM, dsdGenContext);
+
+  /* catalog page needs to be from a catlog active at the time of the sale */
+  r->cs_catalog_page_sk = (r->cs_sold_date_sk == -1) ? -1
+                                                     : mk_join(
+                                                           CS_CATALOG_PAGE_SK,
+                                                           CATALOG_PAGE,
+                                                           r->cs_sold_date_sk,
+                                                           dsdGenContext);
+
+  r->cs_ship_mode_sk = mk_join(CS_SHIP_MODE_SK, SHIP_MODE, 1, dsdGenContext);
+  r->cs_warehouse_sk = mk_join(CS_WAREHOUSE_SK, WAREHOUSE, 1, dsdGenContext);
+  r->cs_promo_sk = mk_join(CS_PROMO_SK, PROMOTION, 1, dsdGenContext);
+  set_pricing(CS_PRICING, &r->cs_pricing, dsdGenContext);
+
+  /**
+   * having gone to the trouble to make the sale, now let's see if it gets
+   * returned
+   */
+  genrand_integer(
+      &nTemp, DIST_UNIFORM, 0, 99, 0, CR_IS_RETURNED, dsdGenContext);
+  if (nTemp < CR_RETURN_PCT) {
+    struct W_CATALOG_RETURNS_TBL w_catalog_returns;
+    struct W_CATALOG_RETURNS_TBL* rr = &dsdGenContext.g_w_catalog_returns;
+    mk_w_catalog_returns(rr, 1, dsdGenContext);
+
+    void* info = append_info_get(info_arr, CATALOG_RETURNS);
+    append_row_start(info);
+
+    append_key(CR_RETURNED_DATE_SK, info, rr->cr_returned_date_sk);
+    append_key(CR_RETURNED_TIME_SK, info, rr->cr_returned_time_sk);
+    append_key(CR_ITEM_SK, info, rr->cr_item_sk);
+    append_key(CR_REFUNDED_CUSTOMER_SK, info, rr->cr_refunded_customer_sk);
+    append_key(CR_REFUNDED_CDEMO_SK, info, rr->cr_refunded_cdemo_sk);
+    append_key(CR_REFUNDED_HDEMO_SK, info, rr->cr_refunded_hdemo_sk);
+    append_key(CR_REFUNDED_ADDR_SK, info, rr->cr_refunded_addr_sk);
+    append_key(CR_RETURNING_CUSTOMER_SK, info, rr->cr_returning_customer_sk);
+    append_key(CR_RETURNING_CDEMO_SK, info, rr->cr_returning_cdemo_sk);
+    append_key(CR_RETURNING_HDEMO_SK, info, rr->cr_returning_hdemo_sk);
+    append_key(CR_RETURNING_ADDR_SK, info, rr->cr_returning_addr_sk);
+    append_key(CR_CALL_CENTER_SK, info, rr->cr_call_center_sk);
+    append_key(CR_CATALOG_PAGE_SK, info, rr->cr_catalog_page_sk);
+    append_key(CR_SHIP_MODE_SK, info, rr->cr_ship_mode_sk);
+    append_key(CR_WAREHOUSE_SK, info, rr->cr_warehouse_sk);
+    append_key(CR_REASON_SK, info, rr->cr_reason_sk);
+    append_key(CR_ORDER_NUMBER, info, rr->cr_order_number);
+    append_integer(CR_PRICING_QUANTITY, info, rr->cr_pricing.quantity);
+    append_decimal(CR_PRICING_NET_PAID, info, &rr->cr_pricing.net_paid);
+    append_decimal(CR_PRICING_EXT_TAX, info, &rr->cr_pricing.ext_tax);
+    append_decimal(
+        CR_PRICING_NET_PAID_INC_TAX, info, &rr->cr_pricing.net_paid_inc_tax);
+    append_decimal(CR_PRICING_FEE, info, &rr->cr_pricing.fee);
+    append_decimal(
+        CR_PRICING_EXT_SHIP_COST, info, &rr->cr_pricing.ext_ship_cost);
+    append_decimal(
+        CR_PRICING_REFUNDED_CASH, info, &rr->cr_pricing.refunded_cash);
+    append_decimal(
+        CR_PRICING_REVERSED_CHARGE, info, &rr->cr_pricing.reversed_charge);
+    append_decimal(CR_PRICING_STORE_CREDIT, info, &rr->cr_pricing.store_credit);
+    append_decimal(CR_PRICING_NET_LOSS, info, &rr->cr_pricing.net_loss);
+
+    append_row_end(info);
+  }
+
+  void* info = append_info_get(info_arr, CATALOG_SALES);
+  append_row_start(info);
+
+  append_key(CS_SOLD_DATE_SK, info, r->cs_sold_date_sk);
+  append_key(CS_SOLD_TIME_SK, info, r->cs_sold_time_sk);
+  append_key(CS_SHIP_DATE_SK, info, r->cs_ship_date_sk);
+  append_key(CS_BILL_CUSTOMER_SK, info, r->cs_bill_customer_sk);
+  append_key(CS_BILL_CDEMO_SK, info, r->cs_bill_cdemo_sk);
+  append_key(CS_BILL_HDEMO_SK, info, r->cs_bill_hdemo_sk);
+  append_key(CS_BILL_ADDR_SK, info, r->cs_bill_addr_sk);
+  append_key(CS_SHIP_CUSTOMER_SK, info, r->cs_ship_customer_sk);
+  append_key(CS_SHIP_CDEMO_SK, info, r->cs_ship_cdemo_sk);
+  append_key(CS_SHIP_HDEMO_SK, info, r->cs_ship_hdemo_sk);
+  append_key(CS_SHIP_ADDR_SK, info, r->cs_ship_addr_sk);
+  append_key(CS_CALL_CENTER_SK, info, r->cs_call_center_sk);
+  append_key(CS_CATALOG_PAGE_SK, info, r->cs_catalog_page_sk);
+  append_key(CS_SHIP_MODE_SK, info, r->cs_ship_mode_sk);
+  append_key(CS_WAREHOUSE_SK, info, r->cs_warehouse_sk);
+  append_key(CS_SOLD_ITEM_SK, info, r->cs_sold_item_sk);
+  append_key(CS_PROMO_SK, info, r->cs_promo_sk);
+  append_key(CS_ORDER_NUMBER, info, r->cs_order_number);
+  append_integer(CS_PRICING_QUANTITY, info, r->cs_pricing.quantity);
+  append_decimal(
+      CS_PRICING_WHOLESALE_COST, info, &r->cs_pricing.wholesale_cost);
+  append_decimal(CS_PRICING_LIST_PRICE, info, &r->cs_pricing.list_price);
+  append_decimal(CS_PRICING_SALES_PRICE, info, &r->cs_pricing.sales_price);
+  append_decimal(
+      CS_PRICING_EXT_DISCOUNT_AMOUNT, info, &r->cs_pricing.ext_discount_amt);
+  append_decimal(
+      CS_PRICING_EXT_SALES_PRICE, info, &r->cs_pricing.ext_sales_price);
+  append_decimal(
+      CS_PRICING_EXT_WHOLESALE_COST, info, &r->cs_pricing.ext_wholesale_cost);
+  append_decimal(
+      CS_PRICING_EXT_LIST_PRICE, info, &r->cs_pricing.ext_list_price);
+  append_decimal(CS_PRICING_EXT_TAX, info, &r->cs_pricing.ext_tax);
+  append_decimal(CS_PRICING_COUPON_AMT, info, &r->cs_pricing.coupon_amt);
+  append_decimal(CS_PRICING_EXT_SHIP_COST, info, &r->cs_pricing.ext_ship_cost);
+  append_decimal(CS_PRICING_NET_PAID, info, &r->cs_pricing.net_paid);
+  append_decimal(
+      CS_PRICING_NET_PAID_INC_TAX, info, &r->cs_pricing.net_paid_inc_tax);
+  append_decimal(
+      CS_PRICING_NET_PAID_INC_SHIP, info, &r->cs_pricing.net_paid_inc_ship);
+  append_decimal(
+      CS_PRICING_NET_PAID_INC_SHIP_TAX,
+      info,
+      &r->cs_pricing.net_paid_inc_ship_tax);
+  append_decimal(CS_PRICING_NET_PROFIT, info, &r->cs_pricing.net_profit);
+
+  append_row_end(info);
+
+  return;
+}
+
+/*
+ * Routine: mk_catalog_sales()
+ * Purpose: build rows for the catalog sales table
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20020902 jms Need to link order date/time to call center record
+ * 20020902 jms Should promos be tied to item id?
+ */
+int mk_w_catalog_sales(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int nLineitems, i;
+
+  row_skip(CATALOG_RETURNS, (index - 1), dsdGenContext);
+  struct W_CATALOG_SALES_TBL* r;
+  r = mk_catalog_sales_master(info_arr, index, dsdGenContext);
+
+  /*
+   * now we select the number of lineitems in this order, and loop through
+   * them, printing as we go
+   */
+  genrand_integer(
+      &nLineitems, DIST_UNIFORM, 4, 14, 0, CS_ORDER_NUMBER, dsdGenContext);
+  for (i = 1; i <= nLineitems; i++) {
+    mk_detail(info_arr, 1, r, dsdGenContext);
+  }
+
+  /**
+   * and finally return 1 since we have already printed the rows.
+   */
+  return 0;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int vld_w_catalog_sales(
+    int nTable,
+    ds_key_t kRow,
+    int* Permutation,
+    DSDGenContext& dsdGenContext) {
+  int nLineitem, nMaxLineitem, i;
+
+  row_skip(nTable, kRow - 1, dsdGenContext);
+  row_skip(CATALOG_RETURNS, (kRow - 1), dsdGenContext);
+  dsdGenContext.jDate =
+      skipDays(CATALOG_SALES, &dsdGenContext.kNewDateIndex, dsdGenContext);
+
+  struct W_CATALOG_SALES_TBL* r;
+  r = mk_catalog_sales_master(NULL, kRow, dsdGenContext);
+  genrand_integer(
+      &nMaxLineitem, DIST_UNIFORM, 4, 14, 9, CS_ORDER_NUMBER, dsdGenContext);
+  genrand_integer(
+      &nLineitem,
+      DIST_UNIFORM,
+      1,
+      nMaxLineitem,
+      0,
+      CS_PRICING_QUANTITY,
+      dsdGenContext);
+  for (i = 1; i < nLineitem; i++) {
+    mk_detail(NULL, 0, r, dsdGenContext);
+  }
+  mk_detail(NULL, 1, r, dsdGenContext);
+
+  return (0);
+}
diff --git a/velox/tpcds/gen/dsdgen/w_customer.cpp b/velox/tpcds/gen/dsdgen/w_customer.cpp
new file mode 100644
index 000000000000..b13301ad49de
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_customer.cpp
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_customer.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+/* extern tdef w_tdefs[]; */
+
+/*
+ * Routine: mk_customer
+ * Purpose: populate the customer dimension
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+int mk_w_customer(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int nTemp;
+
+  /* begin locals declarations */
+  int nNameIndex, nGender;
+  struct W_CUSTOMER_TBL* r;
+  date_t dtTemp;
+  date_t dtBirthMin, dtBirthMax, dtToday, dt1YearAgo, dt10YearsAgo;
+  tdef* pT = getSimpleTdefsByNumber(CUSTOMER, dsdGenContext);
+  r = &dsdGenContext.g_w_customer;
+
+  strtodt(&dtBirthMax, "1992-12-31");
+  strtodt(&dtBirthMin, "1924-01-01");
+  strtodt(&dtToday, TODAYS_DATE);
+  jtodt(&dt1YearAgo, dtToday.julian - 365);
+  jtodt(&dt10YearsAgo, dtToday.julian - 3650);
+
+  nullSet(&pT->kNullBitMap, C_NULLS, dsdGenContext);
+  r->c_customer_sk = index;
+  mk_bkey(&r->c_customer_id[0], index, C_CUSTOMER_ID);
+  genrand_integer(
+      &nTemp, DIST_UNIFORM, 1, 100, 0, C_PREFERRED_CUST_FLAG, dsdGenContext);
+  r->c_preferred_cust_flag = (nTemp < C_PREFERRED_PCT) ? 1 : 0;
+
+  /* demographic keys are a composite of values. rebuild them a la
+   * bitmap_to_dist */
+  r->c_current_hdemo_sk =
+      mk_join(C_CURRENT_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1, dsdGenContext);
+
+  r->c_current_cdemo_sk =
+      mk_join(C_CURRENT_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1, dsdGenContext);
+
+  r->c_current_addr_sk = mk_join(
+      C_CURRENT_ADDR_SK, CUSTOMER_ADDRESS, r->c_customer_sk, dsdGenContext);
+  nNameIndex = pick_distribution(
+      &r->c_first_name, "first_names", 1, 3, C_FIRST_NAME, dsdGenContext);
+  pick_distribution(
+      &r->c_last_name, "last_names", 1, 1, C_LAST_NAME, dsdGenContext);
+  dist_weight(&nGender, "first_names", nNameIndex, 2, dsdGenContext);
+  pick_distribution(
+      &r->c_salutation,
+      "salutations",
+      1,
+      (nGender == 0) ? 2 : 3,
+      C_SALUTATION,
+      dsdGenContext);
+
+  genrand_date(
+      &dtTemp,
+      DIST_UNIFORM,
+      &dtBirthMin,
+      &dtBirthMax,
+      NULL,
+      C_BIRTH_DAY,
+      dsdGenContext);
+  r->c_birth_day = dtTemp.day;
+  r->c_birth_month = dtTemp.month;
+  r->c_birth_year = dtTemp.year;
+  genrand_email(
+      r->c_email_address,
+      r->c_first_name,
+      r->c_last_name,
+      C_EMAIL_ADDRESS,
+      dsdGenContext);
+  genrand_date(
+      &dtTemp,
+      DIST_UNIFORM,
+      &dt1YearAgo,
+      &dtToday,
+      NULL,
+      C_LAST_REVIEW_DATE,
+      dsdGenContext);
+  r->c_last_review_date = dtTemp.julian;
+  genrand_date(
+      &dtTemp,
+      DIST_UNIFORM,
+      &dt10YearsAgo,
+      &dtToday,
+      NULL,
+      C_FIRST_SALES_DATE_ID,
+      dsdGenContext);
+  r->c_first_sales_date_id = dtTemp.julian;
+  r->c_first_shipto_date_id = r->c_first_sales_date_id + 30;
+
+  pick_distribution(
+      &r->c_birth_country, "countries", 1, 1, C_BIRTH_COUNTRY, dsdGenContext);
+
+  void* info = append_info_get(info_arr, CUSTOMER);
+  append_row_start(info);
+
+  append_key(C_CUSTOMER_SK, info, r->c_customer_sk);
+  append_varchar(C_CUSTOMER_ID, info, r->c_customer_id);
+  append_key(C_CURRENT_CDEMO_SK, info, r->c_current_cdemo_sk);
+  append_key(C_CURRENT_HDEMO_SK, info, r->c_current_hdemo_sk);
+  append_key(C_CURRENT_ADDR_SK, info, r->c_current_addr_sk);
+  append_key(C_FIRST_SHIPTO_DATE_ID, info, r->c_first_shipto_date_id);
+  append_key(C_FIRST_SALES_DATE_ID, info, r->c_first_sales_date_id);
+  append_varchar(C_SALUTATION, info, r->c_salutation);
+  append_varchar(C_FIRST_NAME, info, r->c_first_name);
+  append_varchar(C_LAST_NAME, info, r->c_last_name);
+  append_varchar(
+      C_PREFERRED_CUST_FLAG, info, r->c_preferred_cust_flag ? "Y" : "N");
+  append_integer(C_BIRTH_DAY, info, r->c_birth_day);
+  append_integer(C_BIRTH_MONTH, info, r->c_birth_month);
+  append_integer(C_BIRTH_YEAR, info, r->c_birth_year);
+  append_varchar(C_BIRTH_COUNTRY, info, r->c_birth_country);
+  append_varchar(C_LOGIN, info, &r->c_login[0]);
+  append_varchar(C_EMAIL_ADDRESS, info, &r->c_email_address[0]);
+  append_key(C_LAST_REVIEW_DATE, info, r->c_last_review_date);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_customer_address.cpp b/velox/tpcds/gen/dsdgen/w_customer_address.cpp
new file mode 100644
index 000000000000..83b827c6de72
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_customer_address.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_customer_address.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * mk_customer_address
+ */
+int mk_w_customer_address(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  /* begin locals declarations */
+  struct W_CUSTOMER_ADDRESS_TBL* r;
+  tdef* pTdef = getSimpleTdefsByNumber(CUSTOMER_ADDRESS, dsdGenContext);
+
+  r = &dsdGenContext.g_w_customer_address;
+
+  nullSet(&pTdef->kNullBitMap, CA_NULLS, dsdGenContext);
+  r->ca_addr_sk = index;
+  mk_bkey(&r->ca_addr_id[0], index, CA_ADDRESS_ID);
+  pick_distribution(
+      &r->ca_location_type,
+      "location_type",
+      1,
+      1,
+      CA_LOCATION_TYPE,
+      dsdGenContext);
+  mk_address(&r->ca_address, CA_ADDRESS, dsdGenContext);
+
+  void* info = append_info_get(info_arr, CUSTOMER_ADDRESS);
+  append_row_start(info);
+
+  std::vector<char> szTemp(128);
+
+  append_key(CA_ADDRESS_SK, info, r->ca_addr_sk);
+  append_varchar(CA_ADDRESS_ID, info, r->ca_addr_id);
+  append_varchar(
+      CA_ADDRESS_STREET_NUM, info, std::to_string(r->ca_address.street_num));
+  if (r->ca_address.street_name2) {
+    snprintf(
+        szTemp.data(),
+        szTemp.size(),
+        "%s %s",
+        r->ca_address.street_name1,
+        r->ca_address.street_name2);
+    append_varchar(CA_ADDRESS_STREET_NAME1, info, szTemp.data());
+  } else
+    append_varchar(CA_ADDRESS_STREET_NAME1, info, r->ca_address.street_name1);
+  append_varchar(CA_ADDRESS_STREET_TYPE, info, r->ca_address.street_type);
+  append_varchar(CA_ADDRESS_SUITE_NUM, info, &r->ca_address.suite_num[0]);
+  append_varchar(CA_ADDRESS_CITY, info, r->ca_address.city);
+  append_varchar(CA_ADDRESS_COUNTY, info, r->ca_address.county);
+  append_varchar(CA_ADDRESS_STATE, info, r->ca_address.state);
+  snprintf(szTemp.data(), szTemp.size(), "%05d", r->ca_address.zip);
+  append_varchar(CA_ADDRESS_ZIP, info, szTemp.data());
+  append_varchar(CA_ADDRESS_COUNTRY, info, &r->ca_address.country[0]);
+  append_integer_decimal(CA_ADDRESS_GMT_OFFSET, info, r->ca_address.gmt_offset);
+  append_varchar(CA_LOCATION_TYPE, info, r->ca_location_type);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_customer_demographics.cpp b/velox/tpcds/gen/dsdgen/w_customer_demographics.cpp
new file mode 100644
index 000000000000..87686bfb0703
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_customer_demographics.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_customer_demographics.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/sparse.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * mk_customer_demographics
+ */
+int mk_w_customer_demographics(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  struct W_CUSTOMER_DEMOGRAPHICS_TBL* r;
+  ds_key_t kTemp;
+  tdef* pTdef = getSimpleTdefsByNumber(CUSTOMER_DEMOGRAPHICS, dsdGenContext);
+
+  r = &dsdGenContext.g_w_customer_demographics;
+
+  nullSet(&pTdef->kNullBitMap, CD_NULLS, dsdGenContext);
+  r->cd_demo_sk = index;
+  kTemp = r->cd_demo_sk - 1;
+  bitmap_to_dist(
+      &r->cd_gender, "gender", &kTemp, 1, CUSTOMER_DEMOGRAPHICS, dsdGenContext);
+  bitmap_to_dist(
+      &r->cd_marital_status,
+      "marital_status",
+      &kTemp,
+      1,
+      CUSTOMER_DEMOGRAPHICS,
+      dsdGenContext);
+  bitmap_to_dist(
+      &r->cd_education_status,
+      "education",
+      &kTemp,
+      1,
+      CUSTOMER_DEMOGRAPHICS,
+      dsdGenContext);
+  bitmap_to_dist(
+      &r->cd_purchase_estimate,
+      "purchase_band",
+      &kTemp,
+      1,
+      CUSTOMER_DEMOGRAPHICS,
+      dsdGenContext);
+  bitmap_to_dist(
+      &r->cd_credit_rating,
+      "credit_rating",
+      &kTemp,
+      1,
+      CUSTOMER_DEMOGRAPHICS,
+      dsdGenContext);
+  r->cd_dep_count =
+      static_cast<int>((kTemp % static_cast<ds_key_t>(CD_MAX_CHILDREN)));
+  kTemp /= static_cast<ds_key_t>(CD_MAX_CHILDREN);
+  r->cd_dep_employed_count =
+      static_cast<int>((kTemp % static_cast<ds_key_t>(CD_MAX_EMPLOYED)));
+  kTemp /= static_cast<ds_key_t>(CD_MAX_EMPLOYED);
+  r->cd_dep_college_count =
+      static_cast<int>((kTemp % static_cast<ds_key_t>(CD_MAX_COLLEGE)));
+
+  void* info = append_info_get(info_arr, CUSTOMER_DEMOGRAPHICS);
+  append_row_start(info);
+
+  append_key(CD_DEMO_SK, info, r->cd_demo_sk);
+  append_varchar(CD_GENDER, info, r->cd_gender);
+  append_varchar(CD_MARITAL_STATUS, info, r->cd_marital_status);
+  append_varchar(CD_EDUCATION_STATUS, info, r->cd_education_status);
+  append_integer(CD_PURCHASE_ESTIMATE, info, r->cd_purchase_estimate);
+  append_varchar(CD_CREDIT_RATING, info, r->cd_credit_rating);
+  append_integer(CD_DEP_COUNT, info, r->cd_dep_count);
+  append_integer(CD_DEP_EMPLOYED_COUNT, info, r->cd_dep_employed_count);
+  append_integer(CD_DEP_COLLEGE_COUNT, info, r->cd_dep_college_count);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_datetbl.cpp b/velox/tpcds/gen/dsdgen/w_datetbl.cpp
new file mode 100644
index 000000000000..2617448d8b86
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_datetbl.cpp
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_datetbl.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/* extern tdef w_tdefs[]; */
+
+/*
+ * Routine: mk_datetbl
+ * Purpose: populate the date dimension
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+int mk_w_date(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
+  int res = 0;
+
+  /* begin locals declarations */
+  date_t base_date;
+  int day_index, nTemp;
+  date_t temp_date, dTemp2;
+  struct W_DATE_TBL* r;
+  tdef* pT = getSimpleTdefsByNumber(DATET, dsdGenContext);
+
+  r = &dsdGenContext.g_w_date;
+
+  if (!dsdGenContext.mk_w_date_init) {
+    r->d_month_seq = 0;
+    r->d_week_seq = 1;
+    r->d_quarter_seq = 1;
+    r->d_current_month = 0;
+    r->d_current_quarter = 0;
+    r->d_current_week = 0;
+    strtodt(&base_date, "1900-01-01");
+    /* Make exceptions to the 1-rng-call-per-row rule */
+    dsdGenContext.mk_w_date_init = 1;
+  } else {
+    strtodt(&base_date, "1900-01-01");
+  }
+
+  nullSet(&pT->kNullBitMap, D_NULLS, dsdGenContext);
+  nTemp = static_cast<long>(index + base_date.julian);
+  r->d_date_sk = nTemp;
+  mk_bkey(&r->d_date_id[0], nTemp, D_DATE_ID);
+  jtodt(&temp_date, nTemp);
+  r->d_year = temp_date.year;
+  r->d_dow = set_dow(&temp_date);
+  r->d_moy = temp_date.month;
+  r->d_dom = temp_date.day;
+  /* set the sequence counts; assumes that the date table starts on a year
+   * boundary */
+  r->d_week_seq = (static_cast<int>(index + 6)) / 7;
+  r->d_month_seq = (r->d_year - 1900) * 12 + r->d_moy - 1;
+  r->d_quarter_seq = (r->d_year - 1900) * 4 + r->d_moy / 3 + 1;
+  day_index = day_number(&temp_date);
+  dist_member(&r->d_qoy, "calendar", day_index, 6, dsdGenContext);
+  /* fiscal year is identical to calendar year */
+  r->d_fy_year = r->d_year;
+  r->d_fy_quarter_seq = r->d_quarter_seq;
+  r->d_fy_week_seq = r->d_week_seq;
+  r->d_day_name = weekday_names[r->d_dow + 1];
+  dist_member(&r->d_holiday, "calendar", day_index, 8, dsdGenContext);
+  if ((r->d_dow == 5) || (r->d_dow == 6))
+    r->d_weekend = 1;
+  else
+    r->d_weekend = 0;
+  if (day_index == 1)
+    dist_member(
+        &r->d_following_holiday,
+        "calendar",
+        365 + is_leap(r->d_year - 1),
+        8,
+        dsdGenContext);
+  else
+    dist_member(
+        &r->d_following_holiday, "calendar", day_index - 1, 8, dsdGenContext);
+  date_t_op(&dTemp2, OP_FIRST_DOM, &temp_date, 0);
+  r->d_first_dom = dTemp2.julian;
+  date_t_op(&dTemp2, OP_LAST_DOM, &temp_date, 0);
+  r->d_last_dom = dTemp2.julian;
+  date_t_op(&dTemp2, OP_SAME_LY, &temp_date, 0);
+  r->d_same_day_ly = dTemp2.julian;
+  date_t_op(&dTemp2, OP_SAME_LQ, &temp_date, 0);
+  r->d_same_day_lq = dTemp2.julian;
+  r->d_current_day = (r->d_date_sk == CURRENT_DAY) ? 1 : 0;
+  r->d_current_year = (r->d_year == CURRENT_YEAR) ? 1 : 0;
+  if (r->d_current_year) {
+    r->d_current_month = (r->d_moy == CURRENT_MONTH) ? 1 : 0;
+    r->d_current_quarter = (r->d_qoy == CURRENT_QUARTER) ? 1 : 0;
+    r->d_current_week = (r->d_week_seq == CURRENT_WEEK) ? 1 : 0;
+  }
+
+  std::vector<char> sQuarterName(7);
+
+  void* info = append_info_get(info_arr, DATET);
+  append_row_start(info);
+
+  append_key(D_DATE_SK, info, r->d_date_sk);
+  append_varchar(D_DATE_ID, info, r->d_date_id);
+  append_date(D_DATE_SK, info, r->d_date_sk);
+  append_integer(D_MONTH_SEQ, info, r->d_month_seq);
+  append_integer(D_WEEK_SEQ, info, r->d_week_seq);
+  append_integer(D_QUARTER_SEQ, info, r->d_quarter_seq);
+  append_integer(D_YEAR, info, r->d_year);
+  append_integer(D_DOW, info, r->d_dow);
+  append_integer(D_MOY, info, r->d_moy);
+  append_integer(D_DOM, info, r->d_dom);
+  append_integer(D_QOY, info, r->d_qoy);
+  append_integer(D_FY_YEAR, info, r->d_fy_year);
+  append_integer(D_FY_QUARTER_SEQ, info, r->d_fy_quarter_seq);
+  append_integer(D_FY_WEEK_SEQ, info, r->d_fy_week_seq);
+  append_varchar(D_DAY_NAME, info, r->d_day_name);
+  snprintf(
+      sQuarterName.data(), sQuarterName.size(), "%4dQ%d", r->d_year, r->d_qoy);
+  append_varchar(D_QUARTER_NAME, info, sQuarterName.data());
+  append_varchar(D_HOLIDAY, info, r->d_holiday ? "Y" : "N");
+  append_varchar(D_WEEKEND, info, r->d_weekend ? "Y" : "N");
+  append_varchar(D_FOLLOWING_HOLIDAY, info, r->d_following_holiday ? "Y" : "N");
+  append_integer(D_FIRST_DOM, info, r->d_first_dom);
+  append_integer(D_LAST_DOM, info, r->d_last_dom);
+  append_integer(D_SAME_DAY_LY, info, r->d_same_day_ly);
+  append_integer(D_SAME_DAY_LQ, info, r->d_same_day_lq);
+  append_varchar(D_CURRENT_DAY, info, r->d_current_day ? "Y" : "N");
+  append_varchar(D_CURRENT_WEEK, info, r->d_current_week ? "Y" : "N");
+  append_varchar(D_CURRENT_MONTH, info, r->d_current_month ? "Y" : "N");
+  append_varchar(D_CURRENT_QUARTER, info, r->d_current_quarter ? "Y" : "N");
+  append_varchar(D_CURRENT_YEAR, info, r->d_current_year ? "Y" : "N");
+
+  append_row_end(info);
+
+  return (res);
+}
diff --git a/velox/tpcds/gen/dsdgen/w_household_demographics.cpp b/velox/tpcds/gen/dsdgen/w_household_demographics.cpp
new file mode 100644
index 000000000000..ae1fc527d295
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_household_demographics.cpp
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_household_demographics.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/sparse.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * mk_household_demographics
+ */
+int mk_w_household_demographics(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  /* begin locals declarations */
+  ds_key_t nTemp;
+  struct W_HOUSEHOLD_DEMOGRAPHICS_TBL* r;
+  tdef* pTdef = getSimpleTdefsByNumber(HOUSEHOLD_DEMOGRAPHICS, dsdGenContext);
+
+  r = &dsdGenContext.g_w_household_demographics;
+
+  nullSet(&pTdef->kNullBitMap, HD_NULLS, dsdGenContext);
+  r->hd_demo_sk = index;
+  nTemp = r->hd_demo_sk;
+  r->hd_income_band_id = (nTemp % distsize("income_band", dsdGenContext)) + 1;
+  nTemp /= distsize("income_band", dsdGenContext);
+  bitmap_to_dist(
+      &r->hd_buy_potential,
+      "buy_potential",
+      &nTemp,
+      1,
+      HOUSEHOLD_DEMOGRAPHICS,
+      dsdGenContext);
+  bitmap_to_dist(
+      &r->hd_dep_count,
+      "dependent_count",
+      &nTemp,
+      1,
+      HOUSEHOLD_DEMOGRAPHICS,
+      dsdGenContext);
+  bitmap_to_dist(
+      &r->hd_vehicle_count,
+      "vehicle_count",
+      &nTemp,
+      1,
+      HOUSEHOLD_DEMOGRAPHICS,
+      dsdGenContext);
+
+  void* info = append_info_get(info_arr, HOUSEHOLD_DEMOGRAPHICS);
+  append_row_start(info);
+  append_key(HD_DEMO_SK, info, r->hd_demo_sk);
+  append_key(HD_INCOME_BAND_ID, info, r->hd_income_band_id);
+  append_varchar(HD_BUY_POTENTIAL, info, r->hd_buy_potential);
+  append_integer(HD_DEP_COUNT, info, r->hd_dep_count);
+  append_integer(HD_VEHICLE_COUNT, info, r->hd_vehicle_count);
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_income_band.cpp b/velox/tpcds/gen/dsdgen/w_income_band.cpp
new file mode 100644
index 000000000000..a60eba75afab
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_income_band.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_income_band.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * mk_income_band
+ */
+int mk_w_income_band(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  struct W_INCOME_BAND_TBL* r;
+  tdef* pTdef = getSimpleTdefsByNumber(INCOME_BAND, dsdGenContext);
+
+  r = &dsdGenContext.g_w_income_band;
+
+  nullSet(&pTdef->kNullBitMap, IB_NULLS, dsdGenContext);
+  r->ib_income_band_id = static_cast<long>(index);
+  dist_member(
+      &r->ib_lower_bound,
+      "income_band",
+      static_cast<long>(index),
+      1,
+      dsdGenContext);
+  dist_member(
+      &r->ib_upper_bound,
+      "income_band",
+      static_cast<long>(index),
+      2,
+      dsdGenContext);
+
+  void* info = append_info_get(info_arr, INCOME_BAND);
+  append_row_start(info);
+  append_key(IB_INCOME_BAND_ID, info, r->ib_income_band_id);
+  append_integer(IB_LOWER_BOUND, info, r->ib_lower_bound);
+  append_integer(IB_UPPER_BOUND, info, r->ib_upper_bound);
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_inventory.cpp b/velox/tpcds/gen/dsdgen/w_inventory.cpp
new file mode 100644
index 000000000000..4ca16d014781
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_inventory.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_inventory.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int mk_w_inventory(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  struct W_INVENTORY_TBL* r;
+  ds_key_t item_count;
+  ds_key_t warehouse_count;
+  int jDate;
+  date_t base_date_storage;
+  date_t* base_date = &base_date_storage;
+  int nTemp;
+  tdef* pTdef = getSimpleTdefsByNumber(INVENTORY, dsdGenContext);
+
+  r = &dsdGenContext.g_w_inventory;
+
+  if (!dsdGenContext.mk_w_promotion_init) {
+    memset(&dsdGenContext.g_w_inventory, 0, sizeof(struct W_INVENTORY_TBL));
+    dsdGenContext.mk_w_promotion_init = 1;
+  }
+  item_count = getIDCount(ITEM, dsdGenContext);
+  warehouse_count = get_rowcount(WAREHOUSE, dsdGenContext);
+  strtodt(base_date, DATE_MINIMUM);
+  jDate = base_date->julian;
+  set_dow(base_date);
+  /* Make exceptions to the 1-rng-call-per-row rule */
+
+  nullSet(&pTdef->kNullBitMap, INV_NULLS, dsdGenContext);
+  nTemp = static_cast<long>(index - 1);
+  r->inv_item_sk = (nTemp % item_count) + 1;
+  nTemp /= static_cast<long>(item_count);
+  r->inv_warehouse_sk = (nTemp % warehouse_count) + 1;
+  nTemp /= static_cast<long>(warehouse_count);
+  r->inv_date_sk = jDate + (nTemp * 7); /* inventory is updated weekly */
+
+  /*
+   * the join between item and inventory is tricky. The item_id selected above
+   * identifies a unique part num but item is an SCD, so we need to account
+   * for that in selecting the SK to join with
+   */
+  r->inv_item_sk =
+      matchSCDSK(r->inv_item_sk, r->inv_date_sk, ITEM, dsdGenContext);
+
+  genrand_integer(
+      &r->inv_quantity_on_hand,
+      DIST_UNIFORM,
+      INV_QUANTITY_MIN,
+      INV_QUANTITY_MAX,
+      0,
+      INV_QUANTITY_ON_HAND,
+      dsdGenContext);
+
+  void* info = append_info_get(info_arr, INVENTORY);
+  append_row_start(info);
+  append_key(INV_DATE_SK, info, r->inv_date_sk);
+  append_key(INV_ITEM_SK, info, r->inv_item_sk);
+  append_key(INV_WAREHOUSE_SK, info, r->inv_warehouse_sk);
+  append_integer(INV_QUANTITY_ON_HAND, info, r->inv_quantity_on_hand);
+  append_row_end(info);
+
+  return 0;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+ds_key_t sc_w_inventory(int nScale, DSDGenContext& dsdGenContext) {
+  ds_key_t kRes;
+  date_t dTemp;
+  int nDays;
+
+  kRes = getIDCount(ITEM, dsdGenContext);
+  kRes *= get_rowcount(WAREHOUSE, dsdGenContext);
+  strtodt(&dTemp, DATE_MAXIMUM);
+  nDays = dTemp.julian;
+  strtodt(&dTemp, DATE_MINIMUM);
+  nDays -= dTemp.julian;
+  nDays += 1;
+  nDays += 6;
+  nDays /= 7; /* each items inventory is updated weekly */
+  kRes *= nDays;
+
+  return (kRes);
+}
diff --git a/velox/tpcds/gen/dsdgen/w_item.cpp b/velox/tpcds/gen/dsdgen/w_item.cpp
new file mode 100644
index 000000000000..2fd7b8b5fb72
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_item.cpp
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_item.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/* extern tdef w_tdefs[]; */
+
+static struct W_ITEM_TBL g_OldValues;
+
+/*
+ * mk_item
+ */
+int mk_w_item(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
+  /* begin locals declarations */
+  decimal_t dMinPrice, dMaxPrice, dMarkdown;
+  decimal_t dMinMarkdown, dMaxMarkdown;
+  int32_t bUseSize, bFirstRecord = 0, nFieldChangeFlags, nMin, nMax, nIndex,
+                    nTemp;
+  char* cp = nullptr;
+  struct W_ITEM_TBL* r;
+  struct W_ITEM_TBL* rOldValues = &g_OldValues;
+  char *szMinPrice = nullptr, *szMaxPrice = nullptr;
+  tdef* pT = getSimpleTdefsByNumber(ITEM, dsdGenContext);
+
+  r = &dsdGenContext.g_w_item;
+
+  strtodec(&dMinMarkdown, MIN_ITEM_MARKDOWN_PCT);
+  strtodec(&dMaxMarkdown, MAX_ITEM_MARKDOWN_PCT);
+  memset(r, 0, sizeof(struct W_ITEM_TBL));
+
+  /* build the new value */
+  nullSet(&pT->kNullBitMap, I_NULLS, dsdGenContext);
+  r->i_item_sk = index;
+
+  nIndex = pick_distribution(
+      &nMin, "i_manager_id", 2, 1, I_MANAGER_ID, dsdGenContext);
+  dist_member(&nMax, "i_manager_id", nIndex, 3, dsdGenContext);
+  genrand_key(
+      &r->i_manager_id,
+      DIST_UNIFORM,
+      static_cast<ds_key_t>(nMin),
+      static_cast<ds_key_t>(nMax),
+      0,
+      I_MANAGER_ID,
+      dsdGenContext);
+
+  /* if we have generated the required history for this business key and
+   * generate a new one then reset associated fields (e.g., rec_start_date
+   * minimums)
+   */
+  if (setSCDKeys(
+          I_ITEM_ID,
+          index,
+          r->i_item_id,
+          &r->i_rec_start_date_id,
+          &r->i_rec_end_date_id,
+          dsdGenContext)) {
+    /*
+     * some fields are not changed, even when a new version of the row is
+     * written
+     */
+    bFirstRecord = 1;
+  }
+
+  /*
+   * this is  where we select the random number that controls if a field
+   * changes from one record to the next.
+   */
+  nFieldChangeFlags = next_random(I_SCD, dsdGenContext);
+
+  /* the rest of the record in a history-keeping dimension can either be a new
+   * data value or not; use a random number and its bit pattern to determine
+   * which fields to replace and which to retain
+   */
+  gen_text(r->i_item_desc, 1, RS_I_ITEM_DESC, I_ITEM_DESC, dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->i_item_desc,
+      &rOldValues->i_item_desc,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  nIndex = pick_distribution(
+      &szMinPrice, "i_current_price", 2, 1, I_CURRENT_PRICE, dsdGenContext);
+  dist_member(&szMaxPrice, "i_current_price", nIndex, 3, dsdGenContext);
+  strtodec(&dMinPrice, szMinPrice);
+  strtodec(&dMaxPrice, szMaxPrice);
+  genrand_decimal(
+      &r->i_current_price,
+      DIST_UNIFORM,
+      &dMinPrice,
+      &dMaxPrice,
+      NULL,
+      I_CURRENT_PRICE,
+      dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->i_current_price,
+      &rOldValues->i_current_price,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_decimal(
+      &dMarkdown,
+      DIST_UNIFORM,
+      &dMinMarkdown,
+      &dMaxMarkdown,
+      NULL,
+      I_WHOLESALE_COST,
+      dsdGenContext);
+  decimal_t_op(&r->i_wholesale_cost, OP_MULT, &r->i_current_price, &dMarkdown);
+  changeSCD(
+      SCD_DEC,
+      &r->i_wholesale_cost,
+      &rOldValues->i_wholesale_cost,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  hierarchy_item(
+      I_CATEGORY, &r->i_category_id, &r->i_category, index, dsdGenContext);
+  /*
+   * changeSCD(SCD_INT, &r->i_category_id, &rOldValues->i_category_id,
+   * &nFieldChangeFlags,  bFirstRecord);
+   */
+
+  hierarchy_item(I_CLASS, &r->i_class_id, &r->i_class, index, dsdGenContext);
+  changeSCD(
+      SCD_KEY,
+      &r->i_class_id,
+      &rOldValues->i_class_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  cp = &r->i_brand[0];
+  hierarchy_item(I_BRAND, &r->i_brand_id, &cp, index, dsdGenContext);
+  changeSCD(
+      SCD_KEY,
+      &r->i_brand_id,
+      &rOldValues->i_brand_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  /* some categories have meaningful sizes, some don't */
+  if (r->i_category_id) {
+    dist_member(
+        &bUseSize,
+        "categories",
+        static_cast<int>(r->i_category_id),
+        3,
+        dsdGenContext);
+    pick_distribution(
+        &r->i_size, "sizes", 1, bUseSize + 2, I_SIZE, dsdGenContext);
+    changeSCD(
+        SCD_PTR,
+        &r->i_size,
+        &rOldValues->i_size,
+        &nFieldChangeFlags,
+        bFirstRecord);
+  } else {
+    bUseSize = 0;
+    r->i_size = NULL;
+  }
+
+  nIndex = pick_distribution(
+      &nMin, "i_manufact_id", 2, 1, I_MANUFACT_ID, dsdGenContext);
+  genrand_integer(
+      &nTemp,
+      DIST_UNIFORM,
+      nMin,
+      dist_member(NULL, "i_manufact_id", nIndex, 3, dsdGenContext),
+      0,
+      I_MANUFACT_ID,
+      dsdGenContext);
+  r->i_manufact_id = nTemp;
+  changeSCD(
+      SCD_KEY,
+      &r->i_manufact_id,
+      &rOldValues->i_manufact_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  mk_word(
+      r->i_manufact,
+      "syllables",
+      static_cast<int>(r->i_manufact_id),
+      RS_I_MANUFACT,
+      ITEM,
+      dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->i_manufact,
+      &rOldValues->i_manufact,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  gen_charset(
+      r->i_formulation,
+      DIGITS,
+      RS_I_FORMULATION,
+      RS_I_FORMULATION,
+      I_FORMULATION,
+      dsdGenContext);
+  embed_string(r->i_formulation, "colors", 1, 2, I_FORMULATION, dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->i_formulation,
+      &rOldValues->i_formulation,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(&r->i_color, "colors", 1, 2, I_COLOR, dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->i_color,
+      &rOldValues->i_color,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(&r->i_units, "units", 1, 1, I_UNITS, dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->i_units,
+      &rOldValues->i_units,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(&r->i_container, "container", 1, 1, ITEM, dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->i_container,
+      &rOldValues->i_container,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  mk_word(
+      r->i_product_name,
+      "syllables",
+      static_cast<int>(index),
+      RS_I_PRODUCT_NAME,
+      ITEM,
+      dsdGenContext);
+
+  r->i_promo_sk = mk_join(I_PROMO_SK, PROMOTION, 1, dsdGenContext);
+  genrand_integer(&nTemp, DIST_UNIFORM, 1, 100, 0, I_PROMO_SK, dsdGenContext);
+  if (nTemp > I_PROMO_PERCENTAGE)
+    r->i_promo_sk = -1;
+
+  /*
+   * if this is the first of a set of revisions, then baseline the old values
+   */
+  if (bFirstRecord)
+    memcpy(&g_OldValues, r, sizeof(struct W_ITEM_TBL));
+
+  if (index == 1)
+    memcpy(&g_OldValues, r, sizeof(struct W_ITEM_TBL));
+
+  void* info = append_info_get(info_arr, ITEM);
+  append_row_start(info);
+
+  append_key(I_ITEM_SK, info, r->i_item_sk);
+  append_varchar(I_ITEM_ID, info, r->i_item_id);
+  append_date(I_REC_START_DATE_ID, info, r->i_rec_start_date_id);
+  append_date(I_REC_END_DATE_ID, info, r->i_rec_end_date_id);
+  append_varchar(I_ITEM_DESC, info, r->i_item_desc);
+  append_decimal(I_CURRENT_PRICE, info, &r->i_current_price);
+  append_decimal(I_WHOLESALE_COST, info, &r->i_wholesale_cost);
+  append_integer(I_BRAND_ID, info, r->i_brand_id);
+  append_varchar(I_BRAND, info, r->i_brand);
+  append_integer(I_CLASS_ID, info, r->i_class_id);
+  append_varchar(I_CLASS, info, r->i_class);
+  append_integer(I_CATEGORY_ID, info, r->i_category_id);
+  append_varchar(I_CATEGORY, info, r->i_category);
+  append_integer(I_MANUFACT_ID, info, r->i_manufact_id);
+  append_varchar(I_MANUFACT, info, r->i_manufact);
+  append_varchar(I_SIZE, info, r->i_size);
+  append_varchar(I_FORMULATION, info, r->i_formulation);
+  append_varchar(I_COLOR, info, r->i_color);
+  append_varchar(I_UNITS, info, r->i_units);
+  append_varchar(I_CONTAINER, info, r->i_container);
+  append_integer(I_MANAGER_ID, info, r->i_manager_id);
+  append_varchar(I_PRODUCT_NAME, info, r->i_product_name);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_promotion.cpp b/velox/tpcds/gen/dsdgen/w_promotion.cpp
new file mode 100644
index 000000000000..c45b8fdb85fa
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_promotion.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_promotion.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * Routine: mk_promotion
+ * Purpose: populate the promotion table
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20020829 jms RNG usage on p_promo_name may be too large
+ * 20020829 jms RNG usage on P_CHANNEL_DETAILS may be too large
+ */
+int mk_w_promotion(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  struct W_PROMOTION_TBL* r;
+
+  /* begin locals declarations */
+  date_t start_date;
+  int nFlags;
+  tdef* pTdef = getSimpleTdefsByNumber(PROMOTION, dsdGenContext);
+
+  r = &dsdGenContext.g_w_promotion;
+
+  if (!dsdGenContext.mk_w_promotion_init) {
+    memset(&dsdGenContext.g_w_promotion, 0, sizeof(struct W_PROMOTION_TBL));
+    strtodt(&start_date, DATE_MINIMUM);
+    dsdGenContext.mk_w_promotion_init = 1;
+  } else {
+    strtodt(&start_date, DATE_MINIMUM);
+  }
+
+  nullSet(&pTdef->kNullBitMap, P_NULLS, dsdGenContext);
+  r->p_promo_sk = index;
+  mk_bkey(&r->p_promo_id[0], index, P_PROMO_ID);
+  r->p_start_date_id = start_date.julian +
+      genrand_integer(NULL,
+                      DIST_UNIFORM,
+                      PROMO_START_MIN,
+                      PROMO_START_MAX,
+                      PROMO_START_MEAN,
+                      P_START_DATE_ID,
+                      dsdGenContext);
+  r->p_end_date_id = r->p_start_date_id +
+      genrand_integer(NULL,
+                      DIST_UNIFORM,
+                      PROMO_LEN_MIN,
+                      PROMO_LEN_MAX,
+                      PROMO_LEN_MEAN,
+                      P_END_DATE_ID,
+                      dsdGenContext);
+  r->p_item_sk = mk_join(P_ITEM_SK, ITEM, 1, dsdGenContext);
+  strtodec(&r->p_cost, "1000.00");
+  r->p_response_target = 1;
+  mk_word(
+      &r->p_promo_name[0],
+      "syllables",
+      static_cast<int>(index),
+      PROMO_NAME_LEN,
+      P_PROMO_NAME,
+      dsdGenContext);
+  nFlags = static_cast<unsigned int>(genrand_integer(
+      NULL, DIST_UNIFORM, 0, 511, 0, P_CHANNEL_DMAIL, dsdGenContext));
+  r->p_channel_dmail = nFlags & 0x01;
+  nFlags <<= 1;
+  r->p_channel_email = nFlags & 0x01;
+  nFlags <<= 1;
+  r->p_channel_catalog = nFlags & 0x01;
+  nFlags <<= 1;
+  r->p_channel_tv = nFlags & 0x01;
+  nFlags <<= 1;
+  r->p_channel_radio = nFlags & 0x01;
+  nFlags <<= 1;
+  r->p_channel_press = nFlags & 0x01;
+  nFlags <<= 1;
+  r->p_channel_event = nFlags & 0x01;
+  nFlags <<= 1;
+  r->p_channel_demo = nFlags & 0x01;
+  nFlags <<= 1;
+  r->p_discount_active = nFlags & 0x01;
+  gen_text(
+      &r->p_channel_details[0],
+      PROMO_DETAIL_LEN_MIN,
+      PROMO_DETAIL_LEN_MAX,
+      P_CHANNEL_DETAILS,
+      dsdGenContext);
+  pick_distribution(
+      &r->p_purpose, "promo_purpose", 1, 1, P_PURPOSE, dsdGenContext);
+
+  void* info = append_info_get(info_arr, PROMOTION);
+  append_row_start(info);
+  append_key(P_PROMO_SK, info, r->p_promo_sk);
+  append_varchar(P_PROMO_ID, info, r->p_promo_id);
+  append_key(P_START_DATE_ID, info, r->p_start_date_id);
+  append_key(P_END_DATE_ID, info, r->p_end_date_id);
+  append_key(P_ITEM_SK, info, r->p_item_sk);
+  append_decimal(P_COST, info, &r->p_cost);
+  append_integer(P_RESPONSE_TARGET, info, r->p_response_target);
+  append_varchar(P_PROMO_NAME, info, &r->p_promo_name[0]);
+  append_varchar(P_CHANNEL_DMAIL, info, r->p_channel_dmail ? "Y" : "N");
+  append_varchar(P_CHANNEL_EMAIL, info, r->p_channel_email ? "Y" : "N");
+  append_varchar(P_CHANNEL_CATALOG, info, r->p_channel_catalog ? "Y" : "N");
+  append_varchar(P_CHANNEL_TV, info, r->p_channel_tv ? "Y" : "N");
+  append_varchar(P_CHANNEL_RADIO, info, r->p_channel_radio ? "Y" : "N");
+  append_varchar(P_CHANNEL_PRESS, info, r->p_channel_press ? "Y" : "N");
+  append_varchar(P_CHANNEL_EVENT, info, r->p_channel_event ? "Y" : "N");
+  append_varchar(P_CHANNEL_DEMO, info, r->p_channel_demo ? "Y" : "N");
+  append_varchar(P_CHANNEL_DETAILS, info, &r->p_channel_details[0]);
+  append_varchar(P_PURPOSE, info, r->p_purpose);
+  append_varchar(P_DISCOUNT_ACTIVE, info, r->p_discount_active ? "Y" : "N");
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_reason.cpp b/velox/tpcds/gen/dsdgen/w_reason.cpp
new file mode 100644
index 000000000000..b046a8707027
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_reason.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_reason.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * mk_reason
+ */
+int mk_w_reason(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
+  struct W_REASON_TBL* r;
+  tdef* pTdef = getSimpleTdefsByNumber(REASON, dsdGenContext);
+
+  r = &dsdGenContext.g_w_reason;
+
+  if (!dsdGenContext.mk_w_reason_init) {
+    memset(&dsdGenContext.g_w_reason, 0, sizeof(struct W_REASON_TBL));
+    dsdGenContext.mk_w_reason_init = 1;
+  }
+
+  nullSet(&pTdef->kNullBitMap, R_NULLS, dsdGenContext);
+  r->r_reason_sk = index;
+  mk_bkey(&r->r_reason_id[0], index, R_REASON_ID);
+  dist_member(
+      &r->r_reason_description,
+      "return_reasons",
+      static_cast<int>(index),
+      1,
+      dsdGenContext);
+
+  void* info = append_info_get(info_arr, REASON);
+  append_row_start(info);
+  append_key(R_REASON_SK, info, r->r_reason_sk);
+  append_varchar(R_REASON_ID, info, r->r_reason_id);
+  append_varchar(R_REASON_DESCRIPTION, info, r->r_reason_description);
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_ship_mode.cpp b/velox/tpcds/gen/dsdgen/w_ship_mode.cpp
new file mode 100644
index 000000000000..718d900b74f7
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_ship_mode.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_ship_mode.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int mk_w_ship_mode(
+    void* info_arr,
+    ds_key_t kIndex,
+    DSDGenContext& dsdGenContext) {
+  struct W_SHIP_MODE_TBL* r;
+  ds_key_t nTemp;
+  tdef* pTdef = getSimpleTdefsByNumber(SHIP_MODE, dsdGenContext);
+
+  r = &dsdGenContext.g_w_ship_mode;
+
+  if (dsdGenContext.mk_w_ship_mode_init) {
+    memset(&dsdGenContext.g_w_ship_mode, 0, sizeof(struct W_SHIP_MODE_TBL));
+    dsdGenContext.mk_w_ship_mode_init = 1;
+  }
+
+  nullSet(&pTdef->kNullBitMap, SM_NULLS, dsdGenContext);
+  r->sm_ship_mode_sk = kIndex;
+  mk_bkey(&r->sm_ship_mode_id[0], kIndex, SM_SHIP_MODE_ID);
+  nTemp = static_cast<long>(kIndex);
+  bitmap_to_dist(
+      &r->sm_type, "ship_mode_type", &nTemp, 1, SHIP_MODE, dsdGenContext);
+  bitmap_to_dist(
+      &r->sm_code, "ship_mode_code", &nTemp, 1, SHIP_MODE, dsdGenContext);
+  dist_member(
+      &r->sm_carrier,
+      "ship_mode_carrier",
+      static_cast<int>(kIndex),
+      1,
+      dsdGenContext);
+  gen_charset(
+      r->sm_contract, ALPHANUM, 1, RS_SM_CONTRACT, SM_CONTRACT, dsdGenContext);
+
+  void* info = append_info_get(info_arr, SHIP_MODE);
+  append_row_start(info);
+  append_key(SM_SHIP_MODE_SK, info, r->sm_ship_mode_sk);
+  append_varchar(SM_SHIP_MODE_ID, info, r->sm_ship_mode_id);
+  append_varchar(SM_TYPE, info, r->sm_type);
+  append_varchar(SM_CODE, info, r->sm_code);
+  append_varchar(SM_CARRIER, info, r->sm_carrier);
+  append_varchar(SM_CONTRACT, info, &r->sm_contract[0]);
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_store.cpp b/velox/tpcds/gen/dsdgen/w_store.cpp
new file mode 100644
index 000000000000..9ac8958ad1ff
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_store.cpp
@@ -0,0 +1,406 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_store.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+#include <string>
+
+static struct W_STORE_TBL g_store_OldValues;
+/*
+ * mk_store
+ */
+int mk_w_store(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
+  int32_t nFieldChangeFlags = 0, bFirstRecord = 0;
+
+  /* begin locals declarations */
+  static decimal_t dRevMin, dRevMax;
+  char *sName1 = nullptr, *sName2 = nullptr, *szTemp = nullptr;
+  int32_t nStoreType, nPercentage, nDaysOpen, nMin, nMax;
+  static date_t tDate;
+  static decimal_t min_rev_growth, max_rev_growth, dMinTaxPercentage,
+      dMaxTaxPercentage;
+  struct W_STORE_TBL *r, *rOldValues = &g_store_OldValues;
+  tdef* pT = getSimpleTdefsByNumber(STORE, dsdGenContext);
+
+  r = &dsdGenContext.g_w_store;
+
+  if (!dsdGenContext.mk_w_store_init) {
+    strtodt(&tDate, DATE_MINIMUM);
+    strtodec(&min_rev_growth, STORE_MIN_REV_GROWTH);
+    strtodec(&max_rev_growth, STORE_MAX_REV_GROWTH);
+    strtodec(&dRevMin, "1.00");
+    strtodec(&dRevMax, "1000000.00");
+    strtodec(&dMinTaxPercentage, STORE_MIN_TAX_PERCENTAGE);
+    strtodec(&dMaxTaxPercentage, STORE_MAX_TAX_PERCENTAGE);
+
+    /* columns that should be dynamic */
+    r->rec_end_date_id = -1;
+    dsdGenContext.mk_w_store_init = 1;
+  }
+
+  nullSet(&pT->kNullBitMap, W_STORE_NULLS, dsdGenContext);
+  r->store_sk = index;
+
+  /* if we have generated the required history for this business key and
+   * generate a new one then reset associate fields (e.g., rec_start_date
+   * minimums)
+   */
+  if (setSCDKeys(
+          S_STORE_ID,
+          index,
+          r->store_id,
+          &r->rec_start_date_id,
+          &r->rec_end_date_id,
+          dsdGenContext)) {
+    bFirstRecord = 1;
+  }
+
+  /*
+   * this is  where we select the random number that controls if a field
+   * changes from one record to the next.
+   */
+  nFieldChangeFlags = next_random(W_STORE_SCD, dsdGenContext);
+
+  /* the rest of the record in a history-keeping dimension can either be a new
+   * data value or not; use a random number and its bit pattern to determine
+   * which fields to replace and which to retain
+   */
+  nPercentage = genrand_integer(
+      NULL, DIST_UNIFORM, 1, 100, 0, W_STORE_CLOSED_DATE_ID, dsdGenContext);
+  nDaysOpen = genrand_integer(
+      NULL,
+      DIST_UNIFORM,
+      STORE_MIN_DAYS_OPEN,
+      STORE_MAX_DAYS_OPEN,
+      0,
+      W_STORE_CLOSED_DATE_ID,
+      dsdGenContext);
+  if (nPercentage < STORE_CLOSED_PCT)
+    r->closed_date_id = tDate.julian + nDaysOpen;
+  else
+    r->closed_date_id = -1;
+  changeSCD(
+      SCD_KEY,
+      &r->closed_date_id,
+      &rOldValues->closed_date_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  if (!r->closed_date_id)
+    r->closed_date_id = -1; /* dates use a special NULL indicator */
+
+  mk_word(
+      r->store_name,
+      "syllables",
+      static_cast<long>(index),
+      5,
+      W_STORE_NAME,
+      dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->store_name,
+      &rOldValues->store_name,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  /*
+   * use the store type to set the parameters for the rest of the attributes
+   */
+  nStoreType = pick_distribution(
+      &szTemp, "store_type", 1, 1, W_STORE_TYPE, dsdGenContext);
+  dist_member(&nMin, "store_type", nStoreType, 2, dsdGenContext);
+  dist_member(&nMax, "store_type", nStoreType, 3, dsdGenContext);
+  genrand_integer(
+      &r->employees,
+      DIST_UNIFORM,
+      nMin,
+      nMax,
+      0,
+      W_STORE_EMPLOYEES,
+      dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->employees,
+      &rOldValues->employees,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  dist_member(&nMin, "store_type", nStoreType, 4, dsdGenContext);
+  dist_member(&nMax, "store_type", nStoreType, 5, dsdGenContext),
+      genrand_integer(
+          &r->floor_space,
+          DIST_UNIFORM,
+          nMin,
+          nMax,
+          0,
+          W_STORE_FLOOR_SPACE,
+          dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->floor_space,
+      &rOldValues->floor_space,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(
+      &r->hours, "call_center_hours", 1, 1, W_STORE_HOURS, dsdGenContext);
+  changeSCD(
+      SCD_PTR, &r->hours, &rOldValues->hours, &nFieldChangeFlags, bFirstRecord);
+
+  pick_distribution(
+      &sName1, "first_names", 1, 1, W_STORE_MANAGER, dsdGenContext);
+  pick_distribution(
+      &sName2, "last_names", 1, 1, W_STORE_MANAGER, dsdGenContext);
+  snprintf(r->store_manager, sizeof(r->store_manager), "%s %s", sName1, sName2);
+  changeSCD(
+      SCD_CHAR,
+      &r->store_manager,
+      &rOldValues->store_manager,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  r->market_id = genrand_integer(
+      NULL, DIST_UNIFORM, 1, 10, 0, W_STORE_MARKET_ID, dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->market_id,
+      &rOldValues->market_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_decimal(
+      &r->dTaxPercentage,
+      DIST_UNIFORM,
+      &dMinTaxPercentage,
+      &dMaxTaxPercentage,
+      NULL,
+      W_STORE_TAX_PERCENTAGE,
+      dsdGenContext);
+  changeSCD(
+      SCD_DEC,
+      &r->dTaxPercentage,
+      &rOldValues->dTaxPercentage,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(
+      &r->geography_class,
+      "geography_class",
+      1,
+      1,
+      W_STORE_GEOGRAPHY_CLASS,
+      dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->geography_class,
+      &rOldValues->geography_class,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  gen_text(
+      &r->market_desc[0],
+      STORE_DESC_MIN,
+      RS_S_MARKET_DESC,
+      W_STORE_MARKET_DESC,
+      dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->market_desc,
+      &rOldValues->market_desc,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(
+      &sName1, "first_names", 1, 1, W_STORE_MARKET_MANAGER, dsdGenContext);
+  pick_distribution(
+      &sName2, "last_names", 1, 1, W_STORE_MARKET_MANAGER, dsdGenContext);
+  snprintf(
+      r->market_manager, sizeof(r->market_manager), "%s %s", sName1, sName2);
+  changeSCD(
+      SCD_CHAR,
+      &r->market_manager,
+      &rOldValues->market_manager,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  r->division_id = pick_distribution(
+      &r->division_name,
+      "divisions",
+      1,
+      1,
+      W_STORE_DIVISION_NAME,
+      dsdGenContext);
+  changeSCD(
+      SCD_KEY,
+      &r->division_id,
+      &rOldValues->division_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->division_name,
+      &rOldValues->division_name,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  r->company_id = pick_distribution(
+      &r->company_name, "stores", 1, 1, W_STORE_COMPANY_NAME, dsdGenContext);
+  changeSCD(
+      SCD_KEY,
+      &r->company_id,
+      &rOldValues->company_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->company_name,
+      &rOldValues->company_name,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  mk_address(&r->address, W_STORE_ADDRESS, dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->address.city,
+      &rOldValues->address.city,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->address.county,
+      &rOldValues->address.county,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_INT,
+      &r->address.gmt_offset,
+      &rOldValues->address.gmt_offset,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->address.state,
+      &rOldValues->address.state,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->address.street_type,
+      &rOldValues->address.street_type,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->address.street_name1,
+      &rOldValues->address.street_name1,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->address.street_name2,
+      &rOldValues->address.street_name2,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_INT,
+      &r->address.street_num,
+      &rOldValues->address.street_num,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_INT,
+      &r->address.zip,
+      &rOldValues->address.zip,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  std::vector<char> szTemp2(128);
+
+  void* info = append_info_get(info_arr, STORE);
+  append_row_start(info);
+
+  append_key(W_STORE_SK, info, r->store_sk);
+  append_varchar(W_STORE_ID, info, r->store_id);
+  append_date(W_STORE_REC_START_DATE_ID, info, r->rec_start_date_id);
+  append_date(W_STORE_REC_END_DATE_ID, info, r->rec_end_date_id);
+  append_key(W_STORE_CLOSED_DATE_ID, info, r->closed_date_id);
+  append_varchar(W_STORE_NAME, info, r->store_name);
+  append_integer(W_STORE_EMPLOYEES, info, r->employees);
+  append_integer(W_STORE_FLOOR_SPACE, info, r->floor_space);
+  append_varchar(W_STORE_HOURS, info, r->hours);
+  append_varchar(W_STORE_MANAGER, info, &r->store_manager[0]);
+  append_integer(W_STORE_MARKET_ID, info, r->market_id);
+  append_varchar(W_STORE_GEOGRAPHY_CLASS, info, r->geography_class);
+  append_varchar(W_STORE_MARKET_DESC, info, &r->market_desc[0]);
+  append_varchar(W_STORE_MARKET_MANAGER, info, &r->market_manager[0]);
+  append_integer(W_STORE_DIVISION_ID, info, r->division_id);
+  append_varchar(W_STORE_DIVISION_NAME, info, r->division_name);
+  append_integer(W_STORE_COMPANY_ID, info, r->company_id);
+  append_varchar(W_STORE_COMPANY_NAME, info, r->company_name);
+  append_varchar(
+      W_STORE_ADDRESS_STREET_NUM, info, std::to_string(r->address.street_num));
+  if (r->address.street_name2) {
+    snprintf(
+        szTemp2.data(),
+        szTemp2.size(),
+        "%s %s",
+        r->address.street_name1,
+        r->address.street_name2);
+    append_varchar(W_STORE_ADDRESS_STREET_NAME1, info, szTemp2.data());
+  } else
+    append_varchar(W_STORE_ADDRESS_STREET_NAME1, info, r->address.street_name1);
+  append_varchar(W_STORE_ADDRESS_STREET_TYPE, info, r->address.street_type);
+  append_varchar(W_STORE_ADDRESS_SUITE_NUM, info, r->address.suite_num);
+  append_varchar(W_STORE_ADDRESS_CITY, info, r->address.city);
+  append_varchar(W_STORE_ADDRESS_COUNTY, info, r->address.county);
+  append_varchar(W_STORE_ADDRESS_STATE, info, r->address.state);
+  snprintf(szTemp2.data(), szTemp2.size(), "%05d", r->address.zip);
+  append_varchar(W_STORE_ADDRESS_ZIP, info, szTemp2.data());
+  append_varchar(W_STORE_ADDRESS_COUNTRY, info, r->address.country);
+  append_integer_decimal(
+      W_STORE_ADDRESS_GMT_OFFSET, info, r->address.gmt_offset);
+  append_decimal(W_STORE_TAX_PERCENTAGE, info, &r->dTaxPercentage);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_store_returns.cpp b/velox/tpcds/gen/dsdgen/w_store_returns.cpp
new file mode 100644
index 000000000000..2e5e7d450e6f
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_store_returns.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_store_returns.h"
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_sales.h"
+
+/*
+ * Routine: mk_store_returns()
+ * Purpose: populate a return fact *sync'd with a sales fact*
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int mk_w_store_returns(
+    void* row,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int res = 0, nTemp;
+  struct W_STORE_RETURNS_TBL* r;
+  struct W_STORE_SALES_TBL* sale = &dsdGenContext.g_w_store_sales;
+  tdef* pT = getSimpleTdefsByNumber(STORE_RETURNS, dsdGenContext);
+
+  decimal_t dMin, dMax;
+  /* begin locals declarations */
+  if (row == NULL)
+    r = &dsdGenContext.g_w_store_returns;
+  else
+    r = static_cast<W_STORE_RETURNS_TBL*>(row);
+
+  strtodec(&dMin, "1.00");
+  strtodec(&dMax, "100000.00");
+
+  nullSet(&pT->kNullBitMap, SR_NULLS, dsdGenContext);
+  /*
+   * Some of the information in the return is taken from the original sale
+   * which has been regenerated
+   */
+  r->sr_ticket_number = sale->ss_ticket_number;
+  r->sr_item_sk = sale->ss_sold_item_sk;
+  memcpy(
+      static_cast<void*>(&r->sr_pricing),
+      static_cast<void*>(&sale->ss_pricing),
+      sizeof(ds_pricing_t));
+
+  /*
+   * some of the fields are conditionally taken from the sale
+   */
+  r->sr_customer_sk = mk_join(SR_CUSTOMER_SK, CUSTOMER, 1, dsdGenContext);
+  if (genrand_integer(
+          NULL, DIST_UNIFORM, 1, 100, 0, SR_TICKET_NUMBER, dsdGenContext) <
+      SR_SAME_CUSTOMER)
+    r->sr_customer_sk = sale->ss_sold_customer_sk;
+
+  /*
+   * the rest of the columns are generated for this specific return
+   */
+  /* the items cannot be returned until they are sold; offset is handled in
+   * mk_join, based on sales date */
+  r->sr_returned_date_sk =
+      mk_join(SR_RETURNED_DATE_SK, DATET, sale->ss_sold_date_sk, dsdGenContext);
+  genrand_integer(
+      &nTemp,
+      DIST_UNIFORM,
+      (8 * 3600) - 1,
+      (17 * 3600) - 1,
+      0,
+      SR_RETURNED_TIME_SK,
+      dsdGenContext);
+  r->sr_returned_time_sk = nTemp;
+  r->sr_cdemo_sk =
+      mk_join(SR_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1, dsdGenContext);
+  r->sr_hdemo_sk =
+      mk_join(SR_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1, dsdGenContext);
+  r->sr_addr_sk = mk_join(SR_ADDR_SK, CUSTOMER_ADDRESS, 1, dsdGenContext);
+  r->sr_store_sk = mk_join(SR_STORE_SK, STORE, 1, dsdGenContext);
+  r->sr_reason_sk = mk_join(SR_REASON_SK, REASON, 1, dsdGenContext);
+  genrand_integer(
+      &r->sr_pricing.quantity,
+      DIST_UNIFORM,
+      1,
+      sale->ss_pricing.quantity,
+      0,
+      SR_PRICING,
+      dsdGenContext);
+  set_pricing(SR_PRICING, &r->sr_pricing, dsdGenContext);
+
+  return (res);
+}
diff --git a/velox/tpcds/gen/dsdgen/w_store_sales.cpp b/velox/tpcds/gen/dsdgen/w_store_sales.cpp
new file mode 100644
index 000000000000..6778efcb3da8
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_store_sales.cpp
@@ -0,0 +1,271 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_store_sales.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_store_returns.h"
+
+// ds_key_t
+// skipDays(int nTable, ds_key_t* pRemainder, DSDGenContext& dsdGenContext);
+
+/*
+ * mk_store_sales
+ */
+W_STORE_SALES_TBL* mk_master_store_sales(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  decimal_t dMin, dMax;
+  struct W_STORE_SALES_TBL* r;
+  r = &dsdGenContext.g_w_store_sales;
+
+  if (!dsdGenContext.mk_master_store_sales_init) {
+    strtodec(&dMin, "1.00");
+    strtodec(&dMax, "100000.00");
+    dsdGenContext.pStoreSalesItemPermutation = makePermutation(
+        dsdGenContext.nStoreSalesItemCount =
+            static_cast<int>(getIDCount(ITEM, dsdGenContext)),
+        SS_PERMUTATION,
+        dsdGenContext);
+
+    dsdGenContext.mk_master_store_sales_init = 1;
+  } else {
+    strtodec(&dMin, "1.00");
+    strtodec(&dMax, "100000.00");
+  }
+
+  r->ss_sold_store_sk = mk_join(SS_SOLD_STORE_SK, STORE, 1, dsdGenContext);
+  r->ss_sold_time_sk = mk_join(SS_SOLD_TIME_SK, TIMET, 1, dsdGenContext);
+  r->ss_sold_date_sk = mk_join(SS_SOLD_DATE_SK, DATET, 1, dsdGenContext);
+  r->ss_sold_customer_sk =
+      mk_join(SS_SOLD_CUSTOMER_SK, CUSTOMER, 1, dsdGenContext);
+  r->ss_sold_cdemo_sk =
+      mk_join(SS_SOLD_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1, dsdGenContext);
+  r->ss_sold_hdemo_sk =
+      mk_join(SS_SOLD_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1, dsdGenContext);
+  r->ss_sold_addr_sk =
+      mk_join(SS_SOLD_ADDR_SK, CUSTOMER_ADDRESS, 1, dsdGenContext);
+  r->ss_ticket_number = index;
+  genrand_integer(
+      &dsdGenContext.nStoreSalesItemIndex,
+      DIST_UNIFORM,
+      1,
+      dsdGenContext.nStoreSalesItemCount,
+      0,
+      SS_SOLD_ITEM_SK,
+      dsdGenContext);
+
+  return r;
+}
+
+void mk_detail(
+    void* info_arr,
+    int bPrint,
+    struct W_STORE_SALES_TBL* r,
+    DSDGenContext& dsdGenContext) {
+  int nTemp;
+  tdef* pT = getSimpleTdefsByNumber(STORE_SALES, dsdGenContext);
+
+  nullSet(&pT->kNullBitMap, SS_NULLS, dsdGenContext);
+  /*
+   * items need to be unique within an order
+   * use a sequence within the permutation
+   */
+  if (++dsdGenContext.nStoreSalesItemIndex > dsdGenContext.nStoreSalesItemCount)
+    dsdGenContext.nStoreSalesItemIndex = 1;
+  int getperm = getPermutationEntry(
+      dsdGenContext.pStoreSalesItemPermutation,
+      dsdGenContext.nStoreSalesItemIndex);
+  r->ss_sold_item_sk =
+      matchSCDSK(getperm, r->ss_sold_date_sk, ITEM, dsdGenContext);
+  r->ss_sold_promo_sk = mk_join(SS_SOLD_PROMO_SK, PROMOTION, 1, dsdGenContext);
+  set_pricing(SS_PRICING, &r->ss_pricing, dsdGenContext);
+
+  /**
+   * having gone to the trouble to make the sale, now let's see if it gets
+   * returned
+   */
+  genrand_integer(
+      &nTemp, DIST_UNIFORM, 0, 99, 0, SR_IS_RETURNED, dsdGenContext);
+  if (nTemp < SR_RETURN_PCT) {
+    struct W_STORE_RETURNS_TBL w_web_returns;
+    struct W_STORE_RETURNS_TBL* rr = &w_web_returns;
+    mk_w_store_returns(rr, 1, dsdGenContext);
+
+    void* info = append_info_get(info_arr, STORE_RETURNS);
+    append_row_start(info);
+
+    append_key(SR_RETURNED_DATE_SK, info, rr->sr_returned_date_sk);
+    append_key(SR_RETURNED_TIME_SK, info, rr->sr_returned_time_sk);
+    append_key(SR_ITEM_SK, info, rr->sr_item_sk);
+    append_key(SR_CUSTOMER_SK, info, rr->sr_customer_sk);
+    append_key(SR_CDEMO_SK, info, rr->sr_cdemo_sk);
+    append_key(SR_HDEMO_SK, info, rr->sr_hdemo_sk);
+    append_key(SR_ADDR_SK, info, rr->sr_addr_sk);
+    append_key(SR_STORE_SK, info, rr->sr_store_sk);
+    append_key(SR_REASON_SK, info, rr->sr_reason_sk);
+    append_key(SR_TICKET_NUMBER, info, rr->sr_ticket_number);
+    append_integer(SR_PRICING_QUANTITY, info, rr->sr_pricing.quantity);
+    append_decimal(SR_PRICING_NET_PAID, info, &rr->sr_pricing.net_paid);
+    append_decimal(SR_PRICING_EXT_TAX, info, &rr->sr_pricing.ext_tax);
+    append_decimal(
+        SR_PRICING_NET_PAID_INC_TAX, info, &rr->sr_pricing.net_paid_inc_tax);
+    append_decimal(SR_PRICING_FEE, info, &rr->sr_pricing.fee);
+    append_decimal(
+        SR_PRICING_EXT_SHIP_COST, info, &rr->sr_pricing.ext_ship_cost);
+    append_decimal(
+        SR_PRICING_REFUNDED_CASH, info, &rr->sr_pricing.refunded_cash);
+    append_decimal(
+        SR_PRICING_REVERSED_CHARGE, info, &rr->sr_pricing.reversed_charge);
+    append_decimal(SR_PRICING_STORE_CREDIT, info, &rr->sr_pricing.store_credit);
+    append_decimal(SR_PRICING_NET_LOSS, info, &rr->sr_pricing.net_loss);
+    append_row_end(info);
+  }
+
+  void* info = append_info_get(info_arr, STORE_SALES);
+  append_row_start(info);
+
+  append_key(SS_SOLD_DATE_SK, info, r->ss_sold_date_sk);
+  append_key(SS_SOLD_TIME_SK, info, r->ss_sold_time_sk);
+  append_key(SS_SOLD_ITEM_SK, info, r->ss_sold_item_sk);
+  append_key(SS_SOLD_CUSTOMER_SK, info, r->ss_sold_customer_sk);
+  append_key(SS_SOLD_CDEMO_SK, info, r->ss_sold_cdemo_sk);
+  append_key(SS_SOLD_HDEMO_SK, info, r->ss_sold_hdemo_sk);
+  append_key(SS_SOLD_ADDR_SK, info, r->ss_sold_addr_sk);
+  append_key(SS_SOLD_STORE_SK, info, r->ss_sold_store_sk);
+  append_key(SS_SOLD_PROMO_SK, info, r->ss_sold_promo_sk);
+  append_key(SS_TICKET_NUMBER, info, r->ss_ticket_number);
+  append_integer(SS_PRICING_QUANTITY, info, r->ss_pricing.quantity);
+  append_decimal(
+      SS_PRICING_WHOLESALE_COST, info, &r->ss_pricing.wholesale_cost);
+  append_decimal(SS_PRICING_LIST_PRICE, info, &r->ss_pricing.list_price);
+  append_decimal(SS_PRICING_SALES_PRICE, info, &r->ss_pricing.sales_price);
+  append_decimal(SS_PRICING_COUPON_AMT, info, &r->ss_pricing.coupon_amt);
+  append_decimal(
+      SS_PRICING_EXT_SALES_PRICE, info, &r->ss_pricing.ext_sales_price);
+  append_decimal(
+      SS_PRICING_EXT_WHOLESALE_COST, info, &r->ss_pricing.ext_wholesale_cost);
+  append_decimal(
+      SS_PRICING_EXT_LIST_PRICE, info, &r->ss_pricing.ext_list_price);
+  append_decimal(SS_PRICING_EXT_TAX, info, &r->ss_pricing.ext_tax);
+  append_decimal(SS_PRICING_COUPON_AMT, info, &r->ss_pricing.coupon_amt);
+  append_decimal(SS_PRICING_NET_PAID, info, &r->ss_pricing.net_paid);
+  append_decimal(
+      SS_PRICING_NET_PAID_INC_TAX, info, &r->ss_pricing.net_paid_inc_tax);
+  append_decimal(SS_PRICING_NET_PROFIT, info, &r->ss_pricing.net_profit);
+
+  append_row_end(info);
+
+  return;
+}
+
+/*
+ * mk_store_sales
+ */
+int mk_w_store_sales(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int nLineitems, i;
+  row_skip(STORE_RETURNS, (index - 1), dsdGenContext);
+
+  /* build the static portion of an order */
+  struct W_STORE_SALES_TBL* r;
+  r = mk_master_store_sales(info_arr, index, dsdGenContext);
+
+  /* set the number of lineitems and build them */
+  genrand_integer(
+      &nLineitems, DIST_UNIFORM, 8, 16, 0, SS_TICKET_NUMBER, dsdGenContext);
+  for (i = 1; i <= nLineitems; i++) {
+    mk_detail(info_arr, 1, r, dsdGenContext);
+  }
+
+  /**
+   * and finally return 1 since we have already printed the rows
+   */
+  return 0;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int vld_w_store_sales(
+    int nTable,
+    ds_key_t kRow,
+    int* Permutation,
+    DSDGenContext& dsdGenContext) {
+  int nLineitem, nMaxLineitem, i;
+
+  row_skip(nTable, kRow - 1, dsdGenContext);
+  row_skip(STORE_RETURNS, kRow - 1, dsdGenContext);
+  // dsdGenContext.jDate =
+  //     skipDays(STORE_SALES, &dsdGenContext.kNewDateIndex, dsdGenContext);
+
+  struct W_STORE_SALES_TBL* r;
+  r = mk_master_store_sales(NULL, kRow, dsdGenContext);
+  genrand_integer(
+      &nMaxLineitem, DIST_UNIFORM, 8, 16, 9, SS_TICKET_NUMBER, dsdGenContext);
+  genrand_integer(
+      &nLineitem,
+      DIST_UNIFORM,
+      1,
+      nMaxLineitem,
+      0,
+      SS_PRICING_QUANTITY,
+      dsdGenContext);
+  for (i = 1; i < nLineitem; i++) {
+    mk_detail(NULL, 0, r, dsdGenContext);
+  }
+  mk_detail(NULL, 1, r, dsdGenContext);
+
+  return (0);
+}
diff --git a/velox/tpcds/gen/dsdgen/w_timetbl.cpp b/velox/tpcds/gen/dsdgen/w_timetbl.cpp
new file mode 100644
index 000000000000..4d91f96fbb9b
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_timetbl.cpp
@@ -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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_timetbl.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * mk_time
+ */
+int mk_w_time(void* info_arr, ds_key_t index, DSDGenContext& dsdGenContext) {
+  /* begin locals declarations */
+  int nTemp;
+  struct W_TIME_TBL* r;
+  tdef* pT = getSimpleTdefsByNumber(TIMET, dsdGenContext);
+
+  r = &dsdGenContext.g_w_time;
+
+  nullSet(&pT->kNullBitMap, T_NULLS, dsdGenContext);
+  r->t_time_sk = index - 1;
+  mk_bkey(&r->t_time_id[0], index, T_TIME_ID);
+  r->t_time = static_cast<long>(index - 1);
+  nTemp = static_cast<long>(index - 1);
+  r->t_second = nTemp % 60;
+  nTemp /= 60;
+  r->t_minute = nTemp % 60;
+  nTemp /= 60;
+  r->t_hour = nTemp % 24;
+  dist_member(&r->t_am_pm, "hours", r->t_hour + 1, 2, dsdGenContext);
+  dist_member(&r->t_shift, "hours", r->t_hour + 1, 3, dsdGenContext);
+  dist_member(&r->t_sub_shift, "hours", r->t_hour + 1, 4, dsdGenContext);
+  dist_member(&r->t_meal_time, "hours", r->t_hour + 1, 5, dsdGenContext);
+
+  void* info = append_info_get(info_arr, TIMET);
+  append_row_start(info);
+  append_key(T_TIME_SK, info, r->t_time_sk);
+  append_varchar(T_TIME_ID, info, r->t_time_id);
+  append_integer(T_TIME, info, r->t_time);
+  append_integer(T_HOUR, info, r->t_hour);
+  append_integer(T_MINUTE, info, r->t_minute);
+  append_integer(T_SECOND, info, r->t_second);
+  append_varchar(T_AM_PM, info, r->t_am_pm);
+  append_varchar(T_SHIFT, info, r->t_shift);
+  append_varchar(T_SUB_SHIFT, info, r->t_sub_shift);
+  append_varchar(T_MEAL_TIME, info, r->t_meal_time, false);
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_warehouse.cpp b/velox/tpcds/gen/dsdgen/w_warehouse.cpp
new file mode 100644
index 000000000000..1c7f70115ee5
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_warehouse.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_warehouse.h"
+
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+/*
+ * mk_warehouse
+ */
+int mk_w_warehouse(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  /* begin locals declarations */
+  struct W_WAREHOUSE_TBL* r;
+  tdef* pT = getSimpleTdefsByNumber(WAREHOUSE, dsdGenContext);
+
+  r = &dsdGenContext.g_w_warehouse;
+
+  nullSet(&pT->kNullBitMap, W_NULLS, dsdGenContext);
+  r->w_warehouse_sk = index;
+  mk_bkey(&r->w_warehouse_id[0], index, W_WAREHOUSE_ID);
+  gen_text(
+      &r->w_warehouse_name[0],
+      W_NAME_MIN,
+      RS_W_WAREHOUSE_NAME,
+      W_WAREHOUSE_NAME,
+      dsdGenContext);
+  r->w_warehouse_sq_ft = genrand_integer(
+      NULL,
+      DIST_UNIFORM,
+      W_SQFT_MIN,
+      W_SQFT_MAX,
+      0,
+      W_WAREHOUSE_SQ_FT,
+      dsdGenContext);
+
+  mk_address(&r->w_address, W_WAREHOUSE_ADDRESS, dsdGenContext);
+
+  std::vector<char> szTemp(128);
+
+  void* info = append_info_get(info_arr, WAREHOUSE);
+  append_row_start(info);
+
+  append_key(W_WAREHOUSE_SK, info, r->w_warehouse_sk);
+  append_varchar(W_WAREHOUSE_ID, info, r->w_warehouse_id);
+  append_varchar(W_WAREHOUSE_NAME, info, &r->w_warehouse_name[0]);
+  append_integer(W_WAREHOUSE_SQ_FT, info, r->w_warehouse_sq_ft);
+  append_varchar(
+      W_ADDRESS_STREET_NUM, info, std::to_string(r->w_address.street_num));
+  if (r->w_address.street_name2 != NULL) {
+    snprintf(
+        szTemp.data(),
+        szTemp.size(),
+        "%s %s",
+        r->w_address.street_name1,
+        r->w_address.street_name2);
+    append_varchar(W_ADDRESS_STREET_NAME1, info, szTemp.data());
+  } else
+    append_varchar(W_ADDRESS_STREET_NAME1, info, r->w_address.street_name1);
+  append_varchar(W_ADDRESS_STREET_TYPE, info, r->w_address.street_type);
+  append_varchar(W_ADDRESS_SUITE_NUM, info, r->w_address.suite_num);
+  append_varchar(W_ADDRESS_CITY, info, r->w_address.city);
+  append_varchar(W_ADDRESS_COUNTY, info, r->w_address.county);
+  append_varchar(W_ADDRESS_STATE, info, r->w_address.state);
+  snprintf(szTemp.data(), szTemp.size(), "%05d", r->w_address.zip);
+  append_varchar(W_ADDRESS_ZIP, info, szTemp.data());
+  append_varchar(W_ADDRESS_COUNTRY, info, r->w_address.country);
+  append_integer_decimal(W_ADDRESS_GMT_OFFSET, info, r->w_address.gmt_offset);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_web_page.cpp b/velox/tpcds/gen/dsdgen/w_web_page.cpp
new file mode 100644
index 000000000000..22504fb60a56
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_web_page.cpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_web_page.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+static struct W_WEB_PAGE_TBL g_web_page_OldValues;
+
+/*
+ * Routine: mk_web_page()
+ * Purpose: populate the web_page table
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ * 20020815 jms check text generation/seed usage
+ */
+int mk_w_web_page(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int32_t bFirstRecord = 0, nFieldChangeFlags;
+  date_t dToday;
+
+  /* begin locals declarations */
+  int32_t nTemp, nAccess;
+  std::vector<char> szTemp(16);
+  struct W_WEB_PAGE_TBL *r, *rOldValues = &g_web_page_OldValues;
+  tdef* pT = getSimpleTdefsByNumber(WEB_PAGE, dsdGenContext);
+
+  r = &dsdGenContext.g_w_web_page;
+
+  /* setup invariant values */
+  snprintf(
+      szTemp.data(),
+      szTemp.size(),
+      "%d-%d-%d",
+      CURRENT_YEAR,
+      CURRENT_MONTH,
+      CURRENT_DAY);
+  strtodt(&dToday, szTemp.data());
+  /* set up for the SCD handling */
+
+  nullSet(&pT->kNullBitMap, WP_NULLS, dsdGenContext);
+  r->wp_page_sk = index;
+
+  /* if we have generated the required history for this business key and
+   * generate a new one then reset associate fields (e.g., rec_start_date
+   * minimums)
+   */
+  if (setSCDKeys(
+          WP_PAGE_ID,
+          index,
+          r->wp_page_id,
+          &r->wp_rec_start_date_id,
+          &r->wp_rec_end_date_id,
+          dsdGenContext)) {
+    /*
+     * some fields are not changed, even when a new version of the row is
+     * written
+     */
+    bFirstRecord = 1;
+  }
+
+  /*
+   * this is  where we select the random number that controls if a field
+   * changes from one record to the next.
+   */
+  nFieldChangeFlags = next_random(WP_SCD, dsdGenContext);
+
+  r->wp_creation_date_sk =
+      mk_join(WP_CREATION_DATE_SK, DATET, index, dsdGenContext);
+  changeSCD(
+      SCD_KEY,
+      &r->wp_creation_date_sk,
+      &rOldValues->wp_creation_date_sk,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &nAccess,
+      DIST_UNIFORM,
+      0,
+      WP_IDLE_TIME_MAX,
+      0,
+      WP_ACCESS_DATE_SK,
+      dsdGenContext);
+  r->wp_access_date_sk = dToday.julian - nAccess;
+  changeSCD(
+      SCD_KEY,
+      &r->wp_access_date_sk,
+      &rOldValues->wp_access_date_sk,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  if (r->wp_access_date_sk == 0)
+    r->wp_access_date_sk = -1; /* special case for dates */
+
+  genrand_integer(
+      &nTemp, DIST_UNIFORM, 0, 99, 0, WP_AUTOGEN_FLAG, dsdGenContext);
+  r->wp_autogen_flag = (nTemp < WP_AUTOGEN_PCT) ? 1 : 0;
+  changeSCD(
+      SCD_INT,
+      &r->wp_autogen_flag,
+      &rOldValues->wp_autogen_flag,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  r->wp_customer_sk = mk_join(WP_CUSTOMER_SK, CUSTOMER, 1, dsdGenContext);
+  changeSCD(
+      SCD_KEY,
+      &r->wp_customer_sk,
+      &rOldValues->wp_customer_sk,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  if (!r->wp_autogen_flag)
+    r->wp_customer_sk = -1;
+
+  genrand_url(r->wp_url, WP_URL);
+  changeSCD(
+      SCD_CHAR,
+      &r->wp_url,
+      &rOldValues->wp_url,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(&r->wp_type, "web_page_use", 1, 1, WP_TYPE, dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->wp_type,
+      &rOldValues->wp_type,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->wp_link_count,
+      DIST_UNIFORM,
+      WP_LINK_MIN,
+      WP_LINK_MAX,
+      0,
+      WP_LINK_COUNT,
+      dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->wp_link_count,
+      &rOldValues->wp_link_count,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->wp_image_count,
+      DIST_UNIFORM,
+      WP_IMAGE_MIN,
+      WP_IMAGE_MAX,
+      0,
+      WP_IMAGE_COUNT,
+      dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->wp_image_count,
+      &rOldValues->wp_image_count,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->wp_max_ad_count,
+      DIST_UNIFORM,
+      WP_AD_MIN,
+      WP_AD_MAX,
+      0,
+      WP_MAX_AD_COUNT,
+      dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->wp_max_ad_count,
+      &rOldValues->wp_max_ad_count,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->wp_char_count,
+      DIST_UNIFORM,
+      r->wp_link_count * 125 + r->wp_image_count * 50,
+      r->wp_link_count * 300 + r->wp_image_count * 150,
+      0,
+      WP_CHAR_COUNT,
+      dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->wp_char_count,
+      &rOldValues->wp_char_count,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  void* info = append_info_get(info_arr, WEB_PAGE);
+  append_row_start(info);
+
+  append_key(WP_PAGE_SK, info, r->wp_page_sk);
+  append_varchar(WP_PAGE_ID, info, r->wp_page_id);
+  append_date(WP_REC_START_DATE_ID, info, r->wp_rec_start_date_id);
+  append_date(WP_REC_END_DATE_ID, info, r->wp_rec_end_date_id);
+  append_key(WP_CREATION_DATE_SK, info, r->wp_creation_date_sk);
+  append_key(WP_ACCESS_DATE_SK, info, r->wp_access_date_sk);
+  append_varchar(WP_AUTOGEN_FLAG, info, r->wp_autogen_flag ? "Y" : "N");
+  append_key(WP_CUSTOMER_SK, info, r->wp_customer_sk);
+  append_varchar(WP_URL, info, &r->wp_url[0]);
+  append_varchar(WP_TYPE, info, &r->wp_type[0]);
+  append_integer(WP_CHAR_COUNT, info, r->wp_char_count);
+  append_integer(WP_LINK_COUNT, info, r->wp_link_count);
+  append_integer(WP_IMAGE_COUNT, info, r->wp_image_count);
+  append_integer(WP_MAX_AD_COUNT, info, r->wp_max_ad_count);
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/dsdgen/w_web_returns.cpp b/velox/tpcds/gen/dsdgen/w_web_returns.cpp
new file mode 100644
index 000000000000..2fc68eba8f89
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_web_returns.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.
+ */
+/*
+ * Copyright owned by the Transaction Processing Performance Council.
+ *
+ * A copy of the license is included under tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_web_returns.h"
+#include <stdio.h>
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/error_msg.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
+
+/*
+ * Routine: mk_web_returns()
+ * Purpose: populate a return fact *sync'd with a sales fact*
+ * Algorithm: Since the returns need to be in line with a prior sale, they are
+ *built by a call from the mk_catalog_sales() routine, and then add
+ *return-related information Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int mk_w_web_returns(void* row, ds_key_t index, DSDGenContext& dsdGenContext) {
+  int res = 0;
+
+  decimal_t dMin, dMax;
+  struct W_WEB_SALES_TBL* sale = &dsdGenContext.g_w_web_sales;
+  struct W_WEB_RETURNS_TBL* r;
+  tdef* pT = getSimpleTdefsByNumber(WEB_RETURNS, dsdGenContext);
+
+  if (row == NULL)
+    r = &dsdGenContext.g_w_web_returns;
+  else
+    r = static_cast<W_WEB_RETURNS_TBL*>(row);
+
+  strtodec(&dMin, "1.00");
+  strtodec(&dMax, "100000.00");
+
+  nullSet(&pT->kNullBitMap, WR_NULLS, dsdGenContext);
+
+  /*
+   * Some of the information in the return is taken from the original sale
+   * which has been regenerated
+   */
+  r->wr_item_sk = sale->ws_item_sk;
+  r->wr_order_number = sale->ws_order_number;
+  memcpy(
+      static_cast<void*>(&r->wr_pricing),
+      static_cast<void*>(&sale->ws_pricing),
+      sizeof(ds_pricing_t));
+  r->wr_web_page_sk = sale->ws_web_page_sk;
+
+  /*
+   * the rest of the columns are generated for this specific return
+   */
+  /* the items cannot be returned until they are shipped; offset is handled in
+   * mk_join, based on sales date */
+  r->wr_returned_date_sk =
+      mk_join(WR_RETURNED_DATE_SK, DATET, sale->ws_ship_date_sk, dsdGenContext);
+  r->wr_returned_time_sk =
+      mk_join(WR_RETURNED_TIME_SK, TIMET, 1, dsdGenContext);
+
+  /* most items are returned by the people they were shipped to, but some are
+   * returned by other folks
+   */
+  r->wr_refunded_customer_sk =
+      mk_join(WR_REFUNDED_CUSTOMER_SK, CUSTOMER, 1, dsdGenContext);
+  r->wr_refunded_cdemo_sk =
+      mk_join(WR_REFUNDED_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1, dsdGenContext);
+  r->wr_refunded_hdemo_sk =
+      mk_join(WR_REFUNDED_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1, dsdGenContext);
+  r->wr_refunded_addr_sk =
+      mk_join(WR_REFUNDED_ADDR_SK, CUSTOMER_ADDRESS, 1, dsdGenContext);
+  if (genrand_integer(
+          NULL,
+          DIST_UNIFORM,
+          0,
+          99,
+          0,
+          WR_RETURNING_CUSTOMER_SK,
+          dsdGenContext) < WS_GIFT_PCT) {
+    r->wr_refunded_customer_sk = sale->ws_ship_customer_sk;
+    r->wr_refunded_cdemo_sk = sale->ws_ship_cdemo_sk;
+    r->wr_refunded_hdemo_sk = sale->ws_ship_hdemo_sk;
+    r->wr_refunded_addr_sk = sale->ws_ship_addr_sk;
+  }
+  r->wr_returning_customer_sk = r->wr_refunded_customer_sk;
+  r->wr_returning_cdemo_sk = r->wr_refunded_cdemo_sk;
+  r->wr_returning_hdemo_sk = r->wr_refunded_hdemo_sk;
+  r->wr_returning_addr_sk = r->wr_refunded_addr_sk;
+
+  r->wr_reason_sk = mk_join(WR_REASON_SK, REASON, 1, dsdGenContext);
+  genrand_integer(
+      &r->wr_pricing.quantity,
+      DIST_UNIFORM,
+      1,
+      sale->ws_pricing.quantity,
+      0,
+      WR_PRICING,
+      dsdGenContext);
+  set_pricing(WR_PRICING, &r->wr_pricing, dsdGenContext);
+
+  return (res);
+}
diff --git a/velox/tpcds/gen/dsdgen/w_web_sales.cpp b/velox/tpcds/gen/dsdgen/w_web_sales.cpp
new file mode 100644
index 000000000000..29d565e8fed6
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_web_sales.cpp
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_web_sales.h"
+
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/decimal.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/parallel.h"
+#include "velox/tpcds/gen/dsdgen/include/permute.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/pricing.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+#include "velox/tpcds/gen/dsdgen/include/w_web_returns.h"
+
+#include <stdio.h>
+
+// ds_key_t
+// skipDays(int nTable, ds_key_t* pRemainder, DSDGenContext& dsdGenContext);
+
+/*
+ * the validation process requires generating a single lineitem
+ * so the main mk_xxx routine has been split into a master record portion
+ * and a detail/lineitem portion.
+ */
+W_WEB_SALES_TBL* mk_web_sales_master(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  decimal_t dMin, dMax;
+  int nGiftPct;
+  struct W_WEB_SALES_TBL* r;
+  r = &dsdGenContext.g_w_web_sales;
+
+  if (!dsdGenContext.mk_master_web_sales_init) {
+    dsdGenContext.pWebSalesItemPermutation = makePermutation(
+        dsdGenContext.nWebSalesItemCount =
+            static_cast<int>(getIDCount(ITEM, dsdGenContext)),
+        WS_PERMUTATION,
+        dsdGenContext);
+    dsdGenContext.mk_master_web_sales_init = 1;
+  }
+  strtodec(&dMin, "1.00");
+  strtodec(&dMax, "100000.00");
+
+  /***
+   * some attributes reamin the same for each lineitem in an order; others are
+   * different for each lineitem. Since the number of lineitems per order is
+   * static, we can use a modulo to determine when to change the semi-static
+   * values
+   */
+
+  r->ws_sold_date_sk = mk_join(WS_SOLD_DATE_SK, DATET, 1, dsdGenContext);
+  r->ws_sold_time_sk = mk_join(WS_SOLD_TIME_SK, TIMET, 1, dsdGenContext);
+  r->ws_bill_customer_sk =
+      mk_join(WS_BILL_CUSTOMER_SK, CUSTOMER, 1, dsdGenContext);
+  r->ws_bill_cdemo_sk =
+      mk_join(WS_BILL_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 1, dsdGenContext);
+  r->ws_bill_hdemo_sk =
+      mk_join(WS_BILL_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 1, dsdGenContext);
+  r->ws_bill_addr_sk =
+      mk_join(WS_BILL_ADDR_SK, CUSTOMER_ADDRESS, 1, dsdGenContext);
+
+  /* most orders are for the ordering customers, some are not */
+  genrand_integer(
+      &nGiftPct, DIST_UNIFORM, 0, 99, 0, WS_SHIP_CUSTOMER_SK, dsdGenContext);
+  if (nGiftPct > WS_GIFT_PCT) {
+    r->ws_ship_customer_sk =
+        mk_join(WS_SHIP_CUSTOMER_SK, CUSTOMER, 2, dsdGenContext);
+    r->ws_ship_cdemo_sk =
+        mk_join(WS_SHIP_CDEMO_SK, CUSTOMER_DEMOGRAPHICS, 2, dsdGenContext);
+    r->ws_ship_hdemo_sk =
+        mk_join(WS_SHIP_HDEMO_SK, HOUSEHOLD_DEMOGRAPHICS, 2, dsdGenContext);
+    r->ws_ship_addr_sk =
+        mk_join(WS_SHIP_ADDR_SK, CUSTOMER_ADDRESS, 2, dsdGenContext);
+  } else {
+    r->ws_ship_customer_sk = r->ws_bill_customer_sk;
+    r->ws_ship_cdemo_sk = r->ws_bill_cdemo_sk;
+    r->ws_ship_hdemo_sk = r->ws_bill_hdemo_sk;
+    r->ws_ship_addr_sk = r->ws_bill_addr_sk;
+  }
+
+  r->ws_order_number = index;
+  genrand_integer(
+      &dsdGenContext.nWebSalesItemIndex,
+      DIST_UNIFORM,
+      1,
+      dsdGenContext.nWebSalesItemCount,
+      0,
+      WS_ITEM_SK,
+      dsdGenContext);
+
+  return r;
+}
+
+void mk_detail(
+    void* info_arr,
+    int bPrint,
+    struct W_WEB_SALES_TBL* r,
+    DSDGenContext& dsdGenContext) {
+  int nShipLag, nTemp;
+  tdef* pT = getSimpleTdefsByNumber(WEB_SALES, dsdGenContext);
+  // r = &dsdGenContext.g_w_web_sales;
+
+  nullSet(&pT->kNullBitMap, WS_NULLS, dsdGenContext);
+
+  /* orders are shipped some number of days after they are ordered,
+   * and not all lineitems ship at the same time
+   */
+  genrand_integer(
+      &nShipLag,
+      DIST_UNIFORM,
+      WS_MIN_SHIP_DELAY,
+      WS_MAX_SHIP_DELAY,
+      0,
+      WS_SHIP_DATE_SK,
+      dsdGenContext);
+  r->ws_ship_date_sk = r->ws_sold_date_sk + nShipLag;
+
+  if (++dsdGenContext.nWebSalesItemIndex > dsdGenContext.nWebSalesItemCount)
+    dsdGenContext.nWebSalesItemIndex = 1;
+  r->ws_item_sk = matchSCDSK(
+      getPermutationEntry(
+          dsdGenContext.pWebSalesItemPermutation,
+          dsdGenContext.nWebSalesItemIndex),
+      r->ws_sold_date_sk,
+      ITEM,
+      dsdGenContext);
+
+  /* the web page needs to be valid for the sale date */
+  r->ws_web_page_sk =
+      mk_join(WS_WEB_PAGE_SK, WEB_PAGE, r->ws_sold_date_sk, dsdGenContext);
+  r->ws_web_site_sk =
+      mk_join(WS_WEB_SITE_SK, WEB_SITE, r->ws_sold_date_sk, dsdGenContext);
+
+  r->ws_ship_mode_sk = mk_join(WS_SHIP_MODE_SK, SHIP_MODE, 1, dsdGenContext);
+  r->ws_warehouse_sk = mk_join(WS_WAREHOUSE_SK, WAREHOUSE, 1, dsdGenContext);
+  r->ws_promo_sk = mk_join(WS_PROMO_SK, PROMOTION, 1, dsdGenContext);
+  set_pricing(WS_PRICING, &r->ws_pricing, dsdGenContext);
+
+  /**
+   * having gone to the trouble to make the sale, now let's see if it gets
+   * returned
+   */
+  genrand_integer(
+      &nTemp, DIST_UNIFORM, 0, 99, 0, WR_IS_RETURNED, dsdGenContext);
+  if (nTemp < WR_RETURN_PCT) {
+    struct W_WEB_RETURNS_TBL w_web_returns;
+    struct W_WEB_RETURNS_TBL* rr = &dsdGenContext.g_w_web_returns;
+    mk_w_web_returns(rr, 1, dsdGenContext);
+
+    void* info = append_info_get(info_arr, WEB_RETURNS);
+    append_row_start(info);
+
+    append_key(WR_RETURNED_DATE_SK, info, rr->wr_returned_date_sk);
+    append_key(WR_RETURNED_TIME_SK, info, rr->wr_returned_time_sk);
+    append_key(WR_ITEM_SK, info, rr->wr_item_sk);
+    append_key(WR_REFUNDED_CUSTOMER_SK, info, rr->wr_refunded_customer_sk);
+    append_key(WR_REFUNDED_CDEMO_SK, info, rr->wr_refunded_cdemo_sk);
+    append_key(WR_REFUNDED_HDEMO_SK, info, rr->wr_refunded_hdemo_sk);
+    append_key(WR_REFUNDED_ADDR_SK, info, rr->wr_refunded_addr_sk);
+    append_key(WR_RETURNING_CUSTOMER_SK, info, rr->wr_returning_customer_sk);
+    append_key(WR_RETURNING_CDEMO_SK, info, rr->wr_returning_cdemo_sk);
+    append_key(WR_RETURNING_HDEMO_SK, info, rr->wr_returning_hdemo_sk);
+    append_key(WR_RETURNING_ADDR_SK, info, rr->wr_returning_addr_sk);
+    append_key(WR_WEB_PAGE_SK, info, rr->wr_web_page_sk);
+    append_key(WR_REASON_SK, info, rr->wr_reason_sk);
+    append_key(WR_ORDER_NUMBER, info, rr->wr_order_number);
+    append_integer(WR_PRICING_QUANTITY, info, rr->wr_pricing.quantity);
+    append_decimal(WR_PRICING_NET_PAID, info, &rr->wr_pricing.net_paid);
+    append_decimal(WR_PRICING_EXT_TAX, info, &rr->wr_pricing.ext_tax);
+    append_decimal(
+        WR_PRICING_NET_PAID_INC_TAX, info, &rr->wr_pricing.net_paid_inc_tax);
+    append_decimal(WR_PRICING_FEE, info, &rr->wr_pricing.fee);
+    append_decimal(
+        WR_PRICING_EXT_SHIP_COST, info, &rr->wr_pricing.ext_ship_cost);
+    append_decimal(
+        WR_PRICING_REFUNDED_CASH, info, &rr->wr_pricing.refunded_cash);
+    append_decimal(
+        WR_PRICING_REVERSED_CHARGE, info, &rr->wr_pricing.reversed_charge);
+    append_decimal(WR_PRICING_STORE_CREDIT, info, &rr->wr_pricing.store_credit);
+    append_decimal(WR_PRICING_NET_LOSS, info, &rr->wr_pricing.net_loss);
+
+    append_row_end(info);
+  }
+
+  void* info = append_info_get(info_arr, WEB_SALES);
+  append_row_start(info);
+
+  append_key(WS_SOLD_DATE_SK, info, r->ws_sold_date_sk);
+  append_key(WS_SOLD_TIME_SK, info, r->ws_sold_time_sk);
+  append_key(WS_SHIP_DATE_SK, info, r->ws_ship_date_sk);
+  append_key(WS_ITEM_SK, info, r->ws_item_sk);
+  append_key(WS_BILL_CUSTOMER_SK, info, r->ws_bill_customer_sk);
+  append_key(WS_BILL_CDEMO_SK, info, r->ws_bill_cdemo_sk);
+  append_key(WS_BILL_HDEMO_SK, info, r->ws_bill_hdemo_sk);
+  append_key(WS_BILL_ADDR_SK, info, r->ws_bill_addr_sk);
+  append_key(WS_SHIP_CUSTOMER_SK, info, r->ws_ship_customer_sk);
+  append_key(WS_SHIP_CDEMO_SK, info, r->ws_ship_cdemo_sk);
+  append_key(WS_SHIP_HDEMO_SK, info, r->ws_ship_hdemo_sk);
+  append_key(WS_SHIP_ADDR_SK, info, r->ws_ship_addr_sk);
+  append_key(WS_WEB_PAGE_SK, info, r->ws_web_page_sk);
+  append_key(WS_WEB_SITE_SK, info, r->ws_web_site_sk);
+  append_key(WS_SHIP_MODE_SK, info, r->ws_ship_mode_sk);
+  append_key(WS_WAREHOUSE_SK, info, r->ws_warehouse_sk);
+  append_key(WS_PROMO_SK, info, r->ws_promo_sk);
+  append_key(WS_ORDER_NUMBER, info, r->ws_order_number);
+  append_integer(WS_PRICING_QUANTITY, info, r->ws_pricing.quantity);
+  append_decimal(
+      WS_PRICING_WHOLESALE_COST, info, &r->ws_pricing.wholesale_cost);
+  append_decimal(WS_PRICING_LIST_PRICE, info, &r->ws_pricing.list_price);
+  append_decimal(WS_PRICING_SALES_PRICE, info, &r->ws_pricing.sales_price);
+  append_decimal(
+      WS_PRICING_EXT_DISCOUNT_AMT, info, &r->ws_pricing.ext_discount_amt);
+  append_decimal(
+      WS_PRICING_EXT_SALES_PRICE, info, &r->ws_pricing.ext_sales_price);
+  append_decimal(
+      WS_PRICING_EXT_WHOLESALE_COST, info, &r->ws_pricing.ext_wholesale_cost);
+  append_decimal(
+      WS_PRICING_EXT_LIST_PRICE, info, &r->ws_pricing.ext_list_price);
+  append_decimal(WS_PRICING_EXT_TAX, info, &r->ws_pricing.ext_tax);
+  append_decimal(WS_PRICING_COUPON_AMT, info, &r->ws_pricing.coupon_amt);
+  append_decimal(WS_PRICING_EXT_SHIP_COST, info, &r->ws_pricing.ext_ship_cost);
+  append_decimal(WS_PRICING_NET_PAID, info, &r->ws_pricing.net_paid);
+  append_decimal(
+      WS_PRICING_NET_PAID_INC_TAX, info, &r->ws_pricing.net_paid_inc_tax);
+  append_decimal(
+      WS_PRICING_NET_PAID_INC_SHIP, info, &r->ws_pricing.net_paid_inc_ship);
+  append_decimal(
+      WS_PRICING_NET_PAID_INC_SHIP_TAX,
+      info,
+      &r->ws_pricing.net_paid_inc_ship_tax);
+  append_decimal(WS_PRICING_NET_PROFIT, info, &r->ws_pricing.net_profit);
+
+  append_row_end(info);
+
+  return;
+}
+
+/*
+ * mk_web_sales
+ */
+int mk_w_web_sales(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int nLineitems, i;
+
+  row_skip(WEB_RETURNS, (index - 1), dsdGenContext);
+  /* build the static portion of an order */
+  struct W_WEB_SALES_TBL* r;
+  r = mk_web_sales_master(info_arr, index, dsdGenContext);
+
+  /* set the number of lineitems and build them */
+  genrand_integer(
+      &nLineitems, DIST_UNIFORM, 8, 16, 9, WS_ORDER_NUMBER, dsdGenContext);
+  for (i = 1; i <= nLineitems; i++) {
+    mk_detail(info_arr, 1, r, dsdGenContext);
+  }
+
+  /**
+   * and finally return 1 since we have already printed the rows
+   */
+  return 0;
+}
+
+/*
+ * Routine:
+ * Purpose:
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO: None
+ */
+int vld_web_sales(
+    int nTable,
+    ds_key_t kRow,
+    int* Permutation,
+    DSDGenContext& dsdGenContext) {
+  int nLineitem, nMaxLineitem, i;
+
+  row_skip(nTable, kRow - 1, dsdGenContext);
+  row_skip(WEB_RETURNS, (kRow - 1), dsdGenContext);
+  struct W_WEB_SALES_TBL* r;
+  r = mk_web_sales_master(NULL, kRow, dsdGenContext);
+  genrand_integer(
+      &nMaxLineitem, DIST_UNIFORM, 8, 16, 9, WS_ORDER_NUMBER, dsdGenContext);
+  genrand_integer(
+      &nLineitem,
+      DIST_UNIFORM,
+      1,
+      nMaxLineitem,
+      0,
+      WS_PRICING_QUANTITY,
+      dsdGenContext);
+  for (i = 1; i < nLineitem; i++) {
+    mk_detail(NULL, 0, r, dsdGenContext);
+  }
+  mk_detail(NULL, 1, r, dsdGenContext);
+
+  return (0);
+}
diff --git a/velox/tpcds/gen/dsdgen/w_web_site.cpp b/velox/tpcds/gen/dsdgen/w_web_site.cpp
new file mode 100644
index 000000000000..96c67527336c
--- /dev/null
+++ b/velox/tpcds/gen/dsdgen/w_web_site.cpp
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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 tpcds/gen/dsdgen/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 "velox/tpcds/gen/dsdgen/include/w_web_site.h"
+
+#include "velox/tpcds/gen/dsdgen/include/address.h"
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/build_support.h"
+#include "velox/tpcds/gen/dsdgen/include/columns.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/constants.h"
+#include "velox/tpcds/gen/dsdgen/include/genrand.h"
+#include "velox/tpcds/gen/dsdgen/include/misc.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/tpcds/gen/dsdgen/include/scaling.h"
+#include "velox/tpcds/gen/dsdgen/include/scd.h"
+#include "velox/tpcds/gen/dsdgen/include/tables.h"
+#include "velox/tpcds/gen/dsdgen/include/tdefs.h"
+
+#include <stdio.h>
+
+static struct W_WEB_SITE_TBL g_OldValues;
+
+/*
+ * Routine: mk_web_site()
+ * Purpose: populate the web_site table
+ * Algorithm:
+ * Data Structures:
+ *
+ * Params:
+ * Returns:
+ * Called By:
+ * Calls:
+ * Assumptions:
+ * Side Effects:
+ * TODO:
+ */
+int mk_w_web_site(
+    void* info_arr,
+    ds_key_t index,
+    DSDGenContext& dsdGenContext) {
+  int32_t nFieldChangeFlags, bFirstRecord = 0;
+  decimal_t dMinTaxPercentage, dMaxTaxPercentage;
+
+  /* begin locals declarations */
+  std::vector<char> szTemp(16);
+  char *sName1 = nullptr, *sName2 = nullptr;
+  struct W_WEB_SITE_TBL *r, *rOldValues = &g_OldValues;
+  tdef* pT = getSimpleTdefsByNumber(WEB_SITE, dsdGenContext);
+
+  r = &dsdGenContext.g_w_web_site;
+
+  snprintf(
+      szTemp.data(),
+      szTemp.size(),
+      "%d-%d-%d",
+      CURRENT_YEAR,
+      CURRENT_MONTH,
+      CURRENT_DAY);
+  strcpy(r->web_class, "Unknown");
+  strtodec(&dMinTaxPercentage, WEB_MIN_TAX_PERCENTAGE);
+  strtodec(&dMaxTaxPercentage, WEB_MAX_TAX_PERCENTAGE);
+
+  nullSet(&pT->kNullBitMap, WEB_NULLS, dsdGenContext);
+  r->web_site_sk = index;
+
+  /* if we have generated the required history for this business key and
+   * generate a new one then reset associate fields (e.g., rec_start_date
+   * minimums)
+   */
+  if (setSCDKeys(
+          WEB_SITE_ID,
+          index,
+          r->web_site_id,
+          &r->web_rec_start_date_id,
+          &r->web_rec_end_date_id,
+          dsdGenContext)) {
+    r->web_open_date = mk_join(WEB_OPEN_DATE, DATET, index, dsdGenContext);
+    r->web_close_date = mk_join(WEB_CLOSE_DATE, DATET, index, dsdGenContext);
+    if (r->web_close_date > r->web_rec_end_date_id)
+      r->web_close_date = -1;
+    snprintf(
+        r->web_name,
+        sizeof(r->web_name),
+        "site_%d",
+        static_cast<int>(index / 6));
+    bFirstRecord = 1;
+  }
+
+  /*
+   * this is  where we select the random number that controls if a field
+   * changes from one record to the next.
+   */
+  nFieldChangeFlags = next_random(WEB_SCD, dsdGenContext);
+
+  /* the rest of the record in a history-keeping dimension can either be a new
+   * data value or not; use a random number and its bit pattern to determine
+   * which fields to replace and which to retain
+   */
+  pick_distribution(&sName1, "first_names", 1, 1, WEB_MANAGER, dsdGenContext);
+  pick_distribution(&sName2, "last_names", 1, 1, WEB_MANAGER, dsdGenContext);
+  snprintf(r->web_manager, sizeof(r->web_manager), "%s %s", sName1, sName2);
+  changeSCD(
+      SCD_CHAR,
+      &r->web_manager,
+      &rOldValues->web_manager,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->web_market_id, DIST_UNIFORM, 1, 6, 0, WEB_MARKET_ID, dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->web_market_id,
+      &rOldValues->web_market_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  gen_text(
+      r->web_market_class,
+      20,
+      RS_WEB_MARKET_CLASS,
+      WEB_MARKET_CLASS,
+      dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->web_market_class,
+      &rOldValues->web_market_class,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  gen_text(
+      r->web_market_desc,
+      20,
+      RS_WEB_MARKET_DESC,
+      WEB_MARKET_DESC,
+      dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->web_market_desc,
+      &rOldValues->web_market_desc,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  pick_distribution(
+      &sName1, "first_names", 1, 1, WEB_MARKET_MANAGER, dsdGenContext);
+  pick_distribution(
+      &sName2, "last_names", 1, 1, WEB_MARKET_MANAGER, dsdGenContext);
+  snprintf(
+      r->web_market_manager,
+      sizeof(r->web_market_manager),
+      "%s %s",
+      sName1,
+      sName2);
+  changeSCD(
+      SCD_CHAR,
+      &r->web_market_manager,
+      &rOldValues->web_market_manager,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_integer(
+      &r->web_company_id, DIST_UNIFORM, 1, 6, 0, WEB_COMPANY_ID, dsdGenContext);
+  changeSCD(
+      SCD_INT,
+      &r->web_company_id,
+      &rOldValues->web_company_id,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  mk_word(
+      r->web_company_name,
+      "syllables",
+      r->web_company_id,
+      RS_WEB_COMPANY_NAME,
+      WEB_COMPANY_NAME,
+      dsdGenContext);
+  changeSCD(
+      SCD_CHAR,
+      &r->web_company_name,
+      &rOldValues->web_company_name,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  mk_address(&r->web_address, WEB_ADDRESS, dsdGenContext);
+  changeSCD(
+      SCD_PTR,
+      &r->web_address.city,
+      &rOldValues->web_address.city,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->web_address.county,
+      &rOldValues->web_address.county,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_INT,
+      &r->web_address.gmt_offset,
+      &rOldValues->web_address.gmt_offset,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->web_address.state,
+      &rOldValues->web_address.state,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->web_address.street_type,
+      &rOldValues->web_address.street_type,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->web_address.street_name1,
+      &rOldValues->web_address.street_name1,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_PTR,
+      &r->web_address.street_name2,
+      &rOldValues->web_address.street_name2,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_INT,
+      &r->web_address.street_num,
+      &rOldValues->web_address.street_num,
+      &nFieldChangeFlags,
+      bFirstRecord);
+  changeSCD(
+      SCD_INT,
+      &r->web_address.zip,
+      &rOldValues->web_address.zip,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  genrand_decimal(
+      &r->web_tax_percentage,
+      DIST_UNIFORM,
+      &dMinTaxPercentage,
+      &dMaxTaxPercentage,
+      NULL,
+      WEB_TAX_PERCENTAGE,
+      dsdGenContext);
+  changeSCD(
+      SCD_DEC,
+      &r->web_tax_percentage,
+      &rOldValues->web_tax_percentage,
+      &nFieldChangeFlags,
+      bFirstRecord);
+
+  void* info = append_info_get(info_arr, WEB_SITE);
+  append_row_start(info);
+
+  std::vector<char> szStreetName(128);
+
+  append_key(WEB_SITE_SK, info, r->web_site_sk);
+  append_varchar(WEB_SITE_ID, info, &r->web_site_id[0]);
+  append_date(
+      WEB_REC_START_DATE_ID, info, static_cast<int>(r->web_rec_start_date_id));
+  append_date(
+      WEB_REC_END_DATE_ID, info, static_cast<int>(r->web_rec_end_date_id));
+  append_varchar(WEB_NAME, info, &r->web_name[0]);
+  append_key(WEB_OPEN_DATE, info, r->web_open_date);
+  append_key(WEB_CLOSE_DATE, info, r->web_close_date);
+  append_varchar(WEB_CLASS, info, &r->web_class[0]);
+  append_varchar(WEB_MANAGER, info, &r->web_manager[0]);
+  append_integer(WEB_MARKET_ID, info, r->web_market_id);
+  append_varchar(WEB_MARKET_CLASS, info, &r->web_market_class[0]);
+  append_varchar(WEB_MARKET_DESC, info, &r->web_market_desc[0]);
+  append_varchar(WEB_MARKET_MANAGER, info, &r->web_market_manager[0]);
+  append_integer(WEB_COMPANY_ID, info, r->web_company_id);
+  append_varchar(WEB_COMPANY_NAME, info, &r->web_company_name[0]);
+  append_varchar(
+      WEB_ADDRESS_STREET_NUM, info, std::to_string(r->web_address.street_num));
+  if (r->web_address.street_name2) {
+    snprintf(
+        szStreetName.data(),
+        szStreetName.size(),
+        "%s %s",
+        r->web_address.street_name1,
+        r->web_address.street_name2);
+    append_varchar(WEB_ADDRESS_STREET_NAME1, info, szStreetName.data());
+  } else
+    append_varchar(WEB_ADDRESS_STREET_NAME1, info, r->web_address.street_name1);
+  append_varchar(WEB_ADDRESS_STREET_TYPE, info, r->web_address.street_type);
+  append_varchar(WEB_ADDRESS_SUITE_NUM, info, r->web_address.suite_num);
+  append_varchar(WEB_ADDRESS_CITY, info, r->web_address.city);
+  append_varchar(WEB_ADDRESS_COUNTY, info, r->web_address.county);
+  append_varchar(WEB_ADDRESS_STATE, info, r->web_address.state);
+  snprintf(
+      szStreetName.data(), szStreetName.size(), "%05d", r->web_address.zip);
+  append_varchar(WEB_ADDRESS_ZIP, info, szStreetName.data());
+  append_varchar(WEB_ADDRESS_COUNTRY, info, r->web_address.country);
+  append_integer_decimal(
+      WEB_ADDRESS_GMT_OFFSET, info, r->web_address.gmt_offset);
+  append_decimal(WEB_TAX_PERCENTAGE, info, &r->web_tax_percentage);
+
+  append_row_end(info);
+
+  return 0;
+}
diff --git a/velox/tpcds/gen/tests/CMakeLists.txt b/velox/tpcds/gen/tests/CMakeLists.txt
new file mode 100644
index 000000000000..964c445a60f3
--- /dev/null
+++ b/velox/tpcds/gen/tests/CMakeLists.txt
@@ -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.
+add_executable(velox_tpcds_gen_test TpcdsGenTest.cpp)
+
+add_test(velox_tpcds_gen_test velox_tpcds_gen_test)
+
+target_link_libraries(
+  velox_tpcds_gen_test
+  velox_tpcds_gen
+  velox_vector
+  velox_memory
+  Folly::folly
+  GTest::gtest
+  GTest::gtest_main
+)
diff --git a/velox/tpcds/gen/tests/TpcdsGenTest.cpp b/velox/tpcds/gen/tests/TpcdsGenTest.cpp
new file mode 100644
index 000000000000..5a065b58437b
--- /dev/null
+++ b/velox/tpcds/gen/tests/TpcdsGenTest.cpp
@@ -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.
+ */
+
+#include <folly/init/Init.h>
+#include "gtest/gtest.h"
+
+#include "velox/common/memory/Memory.h"
+#include "velox/tpcds/gen/TpcdsGen.h"
+#include "velox/vector/ComplexVector.h"
+#include "velox/vector/FlatVector.h"
+
+namespace {
+
+using namespace facebook::velox;
+
+class TpcdsGenTest : public testing::Test {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    pool_ = memory::memoryManager()->addLeafPool("TpcdsGenTest");
+  }
+
+  std::shared_ptr<memory::MemoryPool> pool_;
+};
+
+TEST_F(TpcdsGenTest, batches) {
+  auto rowVector1 =
+      genTpcdsData(tpcds::Table::TBL_ITEM, 5000, 0, pool_.get(), 1, 1, 1);
+
+  EXPECT_EQ(22, rowVector1->childrenSize());
+  EXPECT_EQ(5000, rowVector1->size());
+
+  auto itemKey = rowVector1->childAt(0)->asFlatVector<int64_t>();
+  auto itemId = rowVector1->childAt(1)->asFlatVector<StringView>();
+  auto itemStartDate = rowVector1->childAt(2)->asFlatVector<int32_t>();
+
+  EXPECT_EQ(1, itemKey->valueAt(0));
+  EXPECT_EQ("AAAAAAAABAAAAAAA", itemId->valueAt(0));
+  EXPECT_EQ("1997-10-27", DATE()->toString(itemStartDate->valueAt(0)));
+  LOG(INFO) << rowVector1->toString(0);
+
+  EXPECT_EQ(4001, itemKey->valueAt(4000));
+  EXPECT_EQ("AAAAAAAAAKPAAAAA", itemId->valueAt(4000));
+  EXPECT_EQ("1999-10-28", DATE()->toString(itemStartDate->valueAt(4000)));
+  LOG(INFO) << rowVector1->toString(4000);
+
+  // Get second batch.
+  auto rowVector2 =
+      genTpcdsData(tpcds::Table::TBL_ITEM, 5000, 5000, pool_.get(), 1, 1, 1);
+
+  EXPECT_EQ(22, rowVector2->childrenSize());
+  EXPECT_EQ(5000, rowVector2->size());
+
+  itemKey = rowVector2->childAt(0)->asFlatVector<int64_t>();
+  itemId = rowVector2->childAt(1)->asFlatVector<StringView>();
+  itemStartDate = rowVector2->childAt(2)->asFlatVector<int32_t>();
+
+  EXPECT_EQ(5001, itemKey->valueAt(0));
+  EXPECT_EQ("AAAAAAAAIIDBAAAA", itemId->valueAt(0));
+  EXPECT_EQ("2000-10-27", DATE()->toString(itemStartDate->valueAt(0)));
+  LOG(INFO) << rowVector2->toString(0);
+
+  EXPECT_EQ(9001, itemKey->valueAt(4000));
+  EXPECT_EQ("AAAAAAAAJCDCAAAA", itemId->valueAt(4000));
+  EXPECT_EQ("1997-10-27", DATE()->toString(itemStartDate->valueAt(4000)));
+  LOG(INFO) << rowVector2->toString(4000);
+}
+
+TEST_F(TpcdsGenTest, lastBatch) {
+  // Ask for 10000 but there are only 5000 left.
+  auto rowVector = genTpcdsData(
+      tpcds::Table::TBL_CUSTOMER_ADDRESS, 10000, 45000, pool_.get(), 1, 1, 1);
+  EXPECT_EQ(5000, rowVector->size());
+
+  // Ensure we get 10000 on a larger scale factor.
+  rowVector = genTpcdsData(
+      tpcds::Table::TBL_CUSTOMER_ADDRESS, 10000, 45000, pool_.get(), 10, 1, 1);
+  EXPECT_EQ(10000, rowVector->size());
+}
+
+TEST_F(TpcdsGenTest, reproducible) {
+  // Ensure data generated is reproducible.
+  {
+    auto rowVector1 = genTpcdsData(
+        tpcds::Table::TBL_CUSTOMER_ADDRESS, 5000, 0, pool_.get(), 1, 1, 1);
+    auto rowVector2 = genTpcdsData(
+        tpcds::Table::TBL_CUSTOMER_ADDRESS, 5000, 0, pool_.get(), 1, 1, 1);
+    auto rowVector3 = genTpcdsData(
+        tpcds::Table::TBL_CUSTOMER_ADDRESS, 5000, 0, pool_.get(), 1, 1, 1);
+
+    for (size_t i = 0; i < rowVector1->size(); ++i) {
+      ASSERT_TRUE(rowVector1->equalValueAt(rowVector2.get(), i, i));
+      ASSERT_TRUE(rowVector1->equalValueAt(rowVector3.get(), i, i));
+    }
+  }
+
+  // Ensure it's also reproducible if we add an offset.
+  {
+    auto rowVector1 = genTpcdsData(
+        tpcds::Table::TBL_CUSTOMER_ADDRESS, 5000, 1000, pool_.get(), 1, 1, 1);
+    auto rowVector2 = genTpcdsData(
+        tpcds::Table::TBL_CUSTOMER_ADDRESS, 5000, 1000, pool_.get(), 1, 1, 1);
+    auto rowVector3 = genTpcdsData(
+        tpcds::Table::TBL_CUSTOMER_ADDRESS, 5000, 1000, pool_.get(), 1, 1, 1);
+
+    for (size_t i = 0; i < rowVector1->size(); ++i) {
+      ASSERT_TRUE(rowVector1->equalValueAt(rowVector2.get(), i, i));
+      ASSERT_TRUE(rowVector1->equalValueAt(rowVector3.get(), i, i));
+    }
+  }
+
+  // Ensure that if the offsets are different, records will be different.
+  {
+    auto rowVector1 = genTpcdsData(
+        tpcds::Table::TBL_CUSTOMER_ADDRESS, 5000, 0, pool_.get(), 1, 1, 1);
+    auto rowVector2 = genTpcdsData(
+        tpcds::Table::TBL_CUSTOMER_ADDRESS, 5000, 500, pool_.get(), 1, 1, 1);
+
+    for (size_t i = 0; i < rowVector2->size(); ++i) {
+      ASSERT_FALSE(rowVector1->equalValueAt(rowVector2.get(), i, i));
+    }
+  }
+}
+
+} // 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/tpcds/gen/utils/CMakeLists.txt b/velox/tpcds/gen/utils/CMakeLists.txt
new file mode 100644
index 000000000000..78986bf151a1
--- /dev/null
+++ b/velox/tpcds/gen/utils/CMakeLists.txt
@@ -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.
+
+velox_add_library(velox_tpcds_append_info append_info-c.cpp)
+velox_link_libraries(velox_tpcds_append_info PRIVATE velox_vector fmt::fmt)
diff --git a/velox/tpcds/gen/utils/append_info-c.cpp b/velox/tpcds/gen/utils/append_info-c.cpp
new file mode 100644
index 000000000000..45b46e6b5e16
--- /dev/null
+++ b/velox/tpcds/gen/utils/append_info-c.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/tpcds/gen/utils/append_info-c.h"
+
+#include <fmt/format.h>
+#include "velox/tpcds/gen/dsdgen/include/append_info.h"
+#include "velox/tpcds/gen/dsdgen/include/config.h"
+#include "velox/tpcds/gen/dsdgen/include/date.h"
+#include "velox/tpcds/gen/dsdgen/include/nulls.h"
+#include "velox/tpcds/gen/dsdgen/include/porting.h"
+#include "velox/vector/FlatVector.h"
+
+using namespace facebook::velox;
+
+append_info* append_info_get(void* info_list, int table_id) {
+  auto& append_vector =
+      *((std::vector<std::unique_ptr<tpcds::TpcdsTableDef>>*)info_list);
+  return (append_info*)append_vector[table_id].get();
+}
+
+bool facebook::velox::tpcds::TpcdsTableDef::IsNull(int32_t column) {
+  return nullCheck(column, *dsdGenContext);
+}
+
+void append_row_start(append_info /*info*/) {}
+
+void append_row_end(append_info info) {
+  auto append_info = (tpcds::TpcdsTableDef*)info;
+  append_info->colIndex %= append_info->children.size();
+  append_info->rowIndex++;
+}
+
+void append_varchar(
+    int32_t column,
+    append_info info,
+    const char* value,
+    bool fillEmptyStringAsNull) {
+  auto append_info = (tpcds::TpcdsTableDef*)info;
+  if (((append_info->IsNull(column)) || (!value) || (*value == '\0')) &&
+      (fillEmptyStringAsNull)) {
+    append_info->children[append_info->colIndex]->setNull(
+        append_info->rowIndex, true);
+  } else {
+    append_info->children[append_info->colIndex]
+        ->asFlatVector<StringView>()
+        ->set(append_info->rowIndex, value);
+  }
+  append_info->colIndex++;
+}
+
+void append_varchar(
+    int32_t column,
+    append_info info,
+    std::string value,
+    bool fillEmptyStringAsNull) {
+  append_varchar(column, info, value.data(), fillEmptyStringAsNull);
+}
+
+void append_key(int32_t column, append_info info, int64_t value) {
+  auto append_info = (tpcds::TpcdsTableDef*)info;
+  if (append_info->IsNull(column) || value < 0) {
+    append_info->children[append_info->colIndex]->setNull(
+        append_info->rowIndex, true);
+  } else {
+    append_info->children[append_info->colIndex]->asFlatVector<int64_t>()->set(
+        append_info->rowIndex, value);
+  }
+  append_info->colIndex++;
+}
+
+void append_integer(int32_t column, append_info info, int32_t value) {
+  auto append_info = (tpcds::TpcdsTableDef*)info;
+  if (append_info->IsNull(column) || (column == CC_CLOSED_DATE_ID)) {
+    append_info->children[append_info->colIndex]->setNull(
+        append_info->rowIndex, true);
+  } else {
+    append_info->children[append_info->colIndex]->asFlatVector<int32_t>()->set(
+        append_info->rowIndex, value);
+  }
+  append_info->colIndex++;
+}
+
+void append_boolean(int32_t column, append_info info, int32_t value) {
+  auto append_info = (tpcds::TpcdsTableDef*)info;
+  if (append_info->IsNull(column)) {
+    append_info->children[append_info->colIndex]->setNull(
+        append_info->rowIndex, true);
+  } else {
+    append_info->children[append_info->colIndex]->asFlatVector<int32_t>()->set(
+        append_info->rowIndex, value != 0);
+  }
+  append_info->colIndex++;
+}
+
+// value is a Julian date
+// FIXME: direct int conversion, offsets should be constant
+void append_date(int32_t column, append_info info, int64_t value) {
+  auto append_info = (tpcds::TpcdsTableDef*)info;
+  if (append_info->IsNull(column) || value < 0) {
+    append_info->children[append_info->colIndex]->setNull(
+        append_info->rowIndex, true);
+  } else {
+    date_t dTemp;
+    jtodt(&dTemp, (int)value);
+    auto stringDate =
+        fmt::format("{}-{}-{}", dTemp.year, dTemp.month, dTemp.day);
+    auto date = DATE()->toDays(stringDate);
+    append_info->children[append_info->colIndex]->asFlatVector<int32_t>()->set(
+        append_info->rowIndex, date);
+  }
+  append_info->colIndex++;
+}
+
+void append_decimal(int32_t column, append_info info, decimal_t* val) {
+  auto append_info = (tpcds::TpcdsTableDef*)info;
+  if (append_info->IsNull(column)) {
+    append_info->children[append_info->colIndex]->setNull(
+        append_info->rowIndex, true);
+  } else {
+    auto type = append_info->children[append_info->colIndex]->type();
+    if (type->isShortDecimal()) {
+      append_info->children[append_info->colIndex]
+          ->asFlatVector<int64_t>()
+          ->set(append_info->rowIndex, val->number);
+    } else {
+      append_info->children[append_info->colIndex]
+          ->asFlatVector<int128_t>()
+          ->set(append_info->rowIndex, val->number);
+    }
+  }
+  append_info->colIndex++;
+}
+
+void append_integer_decimal(int32_t column, append_info info, int32_t value) {
+  auto append_info = (tpcds::TpcdsTableDef*)info;
+  if (append_info->IsNull(column)) {
+    append_info->children[append_info->colIndex]->setNull(
+        append_info->rowIndex, true);
+  } else {
+    append_info->children[append_info->colIndex]->asFlatVector<int64_t>()->set(
+        append_info->rowIndex, (int64_t)value * 100);
+  }
+  append_info->colIndex++;
+}
diff --git a/velox/tpcds/gen/utils/append_info-c.h b/velox/tpcds/gen/utils/append_info-c.h
new file mode 100644
index 000000000000..cfcdf9456348
--- /dev/null
+++ b/velox/tpcds/gen/utils/append_info-c.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 <memory>
+#include "velox/tpcds/gen/dsdgen/include/dist.h"
+
+namespace facebook::velox {
+class BaseVector;
+using VectorPtr = std::shared_ptr<BaseVector>;
+} // namespace facebook::velox
+
+namespace facebook::velox::tpcds {
+
+struct TpcdsTableDef {
+  const char* name = "";
+  int fl_small = 0;
+  int fl_child = 0;
+  int first_column = 0;
+  int colIndex = 0;
+  int rowIndex = 0;
+  DSDGenContext* dsdGenContext = nullptr;
+  std::vector<velox::VectorPtr> children = {};
+  bool IsNull(int32_t column);
+};
+} // namespace facebook::velox::tpcds
diff --git a/velox/tpch/gen/CMakeLists.txt b/velox/tpch/gen/CMakeLists.txt
index eada0a24676d..558e6a89f778 100644
--- a/velox/tpch/gen/CMakeLists.txt
+++ b/velox/tpch/gen/CMakeLists.txt
@@ -18,7 +18,10 @@ 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)
+velox_link_libraries(
+  velox_tpch_gen
+  PUBLIC velox_memory velox_vector "$<BUILD_LOCAL_INTERFACE:dbgen>"
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/tpch/gen/dbgen/CMakeLists.txt b/velox/tpch/gen/dbgen/CMakeLists.txt
index 484a3455b374..7cad1f25a6b3 100644
--- a/velox/tpch/gen/dbgen/CMakeLists.txt
+++ b/velox/tpch/gen/dbgen/CMakeLists.txt
@@ -11,13 +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.
-cmake_minimum_required(VERSION 3.0.0)
+cmake_minimum_required(VERSION 3.10)
 cmake_policy(SET CMP0063 NEW)
 
 project(dbgen CXX C)
 
 add_library(
-  dbgen STATIC
+  dbgen
+  STATIC
   dbgen.cpp
   dbgen_gunk.cpp
   bm_utils.cpp
@@ -26,13 +27,12 @@ add_library(
   rnd.cpp
   rng64.cpp
   speed_seed.cpp
-  text.cpp)
+  text.cpp
+)
 
 target_compile_definitions(dbgen PRIVATE DBNAME=dss MAC ORACLE TPCH)
 target_include_directories(dbgen PRIVATE include)
-target_link_libraries(
-  dbgen
-  PRIVATE fmt::fmt Folly::folly)
+target_link_libraries(dbgen PRIVATE fmt::fmt Folly::folly)
 
 # 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
index b52d2f5b7eec..fcab31f2b6ce 100644
--- a/velox/tpch/gen/dbgen/bm_utils.cpp
+++ b/velox/tpch/gen/dbgen/bm_utils.cpp
@@ -107,7 +107,7 @@ char* getenv PROTO((const char* name));
 namespace facebook::velox::tpch::dbgen {
 
 void usage();
-void permute_dist(distribution* d, seed_t* seed);
+void permute_dist(distribution* d, seed_t* seed, DBGenContext* ctx);
 
 /*
  * tpch_env_config: look for a environmental variable setting and return its
@@ -297,7 +297,6 @@ void read_dist(const char* path, const char* name, distribution* target) {
     fprintf(stderr, "Read error on dist '%s'\n", name);
     exit(1);
   }
-  target->permute = reinterpret_cast<long*>(NULL);
   return;
 }
 
@@ -305,16 +304,21 @@ void read_dist(const char* path, const char* name, distribution* target) {
  * 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) {
+void agg_str(
+    distribution* set,
+    long count,
+    seed_t* seed,
+    char* dest,
+    DBGenContext* ctx) {
   distribution* d;
   int i;
 
   d = set;
   *dest = '\0';
 
-  permute_dist(d, seed);
+  permute_dist(d, seed, ctx);
   for (i = 0; i < count; i++) {
-    strcat(dest, DIST_MEMBER(set, DIST_PERMUTE(d, i)));
+    strcat(dest, DIST_MEMBER(set, ctx->permute[i]));
     strcat(dest, " ");
   }
   *(dest + static_cast<int>(strlen(dest)) - 1) = '\0';
diff --git a/velox/tpch/gen/dbgen/build.cpp b/velox/tpch/gen/dbgen/build.cpp
index 0fae068922fa..4f0692185a83 100644
--- a/velox/tpch/gen/dbgen/build.cpp
+++ b/velox/tpch/gen/dbgen/build.cpp
@@ -268,7 +268,11 @@ long mk_part(DSS_HUGE index, part_t* p, DBGenContext* ctx) {
 
   p->partkey = index;
   agg_str(
-      &colors, static_cast<long>(P_NAME_SCL), &ctx->Seed[P_NAME_SD], p->name);
+      &colors,
+      static_cast<long>(P_NAME_SCL),
+      &ctx->Seed[P_NAME_SD],
+      p->name,
+      ctx);
   RANDOM(temp, P_MFG_MIN, P_MFG_MAX, &ctx->Seed[P_MFG_SD]);
   sprintf(p->mfgr, partSzFormat, P_MFG_TAG, temp);
   RANDOM(brnd, P_BRND_MIN, P_BRND_MAX, &ctx->Seed[P_BRND_SD]);
diff --git a/velox/tpch/gen/dbgen/dbgen_gunk.cpp b/velox/tpch/gen/dbgen/dbgen_gunk.cpp
index 0a57b4e77056..13a2ade51c3b 100644
--- a/velox/tpch/gen/dbgen/dbgen_gunk.cpp
+++ b/velox/tpch/gen/dbgen/dbgen_gunk.cpp
@@ -72,10 +72,6 @@ static void cleanup_dist(distribution* target) {
     }
     free(target->list);
   }
-  /* Allocated from permute_dist */
-  if (target->permute) {
-    free(target->permute);
-  }
 }
 
 void cleanup_dists(void) {
diff --git a/velox/tpch/gen/dbgen/include/dbgen/dss.h b/velox/tpch/gen/dbgen/include/dbgen/dss.h
index 34174c5e18f8..749b46785255 100644
--- a/velox/tpch/gen/dbgen/include/dbgen/dss.h
+++ b/velox/tpch/gen/dbgen/include/dbgen/dss.h
@@ -129,14 +129,12 @@ 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) (reinterpret_cast<set_member*>((d)->list + i))->text
-#define DIST_PERMUTE(d, i) (d->permute[i])
 
 typedef struct {
   const char* name;
@@ -171,7 +169,12 @@ 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 agg_str PROTO(
+    (distribution * set,
+     long count,
+     seed_t* seed,
+     char* dest,
+     DBGenContext* ctx));
 void read_dist
     PROTO((const char* path, const char* name, distribution* target));
 void embed_str
@@ -517,6 +520,13 @@ int dbg_print(int dt, FILE* tgt, void* data, int len, int eol);
 #define BBB_OFFSET_SD 47
 
 struct DBGenContext {
+  ~DBGenContext() {
+    if (permute) {
+      free(permute);
+      permute = nullptr;
+    }
+  }
+
   seed_t Seed[MAX_STREAM + 1] = {
       {PART, 1, 0, 1}, /* P_MFG_SD     0 */
       {PART, 46831694, 0, 1}, /* P_BRND_SD    1 */
@@ -590,6 +600,7 @@ struct DBGenContext {
   };
 
   long scale_factor = 1;
+  long* permute = nullptr;
 };
 
 } // namespace facebook::velox::tpch::dbgen
diff --git a/velox/tpch/gen/dbgen/permute.cpp b/velox/tpch/gen/dbgen/permute.cpp
index 48e52cd454a8..619293b00686 100644
--- a/velox/tpch/gen/dbgen/permute.cpp
+++ b/velox/tpch/gen/dbgen/permute.cpp
@@ -34,7 +34,7 @@ namespace facebook::velox::tpch::dbgen {
 
 DSS_HUGE NextRand(DSS_HUGE seed);
 void permute(long* set, int cnt, seed_t* seed);
-void permute_dist(distribution* d, seed_t* seed);
+void permute_dist(distribution* d, seed_t* seed, DBGenContext* ctx);
 long seed;
 char* eol[2] = {" ", "},"};
 
@@ -44,8 +44,8 @@ char* eol[2] = {" ", "},"};
 
 void permute(long* a, int c, seed_t* seed) {
   int i;
-  static DSS_HUGE source;
-  static long temp;
+  DSS_HUGE source;
+  long temp;
 
   if (a != reinterpret_cast<long*>(NULL)) {
     for (i = 0; i < c; i++) {
@@ -59,17 +59,18 @@ void permute(long* a, int c, seed_t* seed) {
   return;
 }
 
-void permute_dist(distribution* d, seed_t* seed) {
+void permute_dist(distribution* d, seed_t* seed, DBGenContext* ctx) {
   int i;
 
   if (d != NULL) {
-    if (d->permute == reinterpret_cast<long*>(NULL)) {
-      d->permute = reinterpret_cast<long*>(malloc(sizeof(long) * DIST_SIZE(d)));
-      MALLOC_CHECK(d->permute);
+    if (ctx->permute == reinterpret_cast<long*>(NULL)) {
+      ctx->permute =
+          reinterpret_cast<long*>(malloc(sizeof(long) * DIST_SIZE(d)));
+      MALLOC_CHECK(ctx->permute);
     }
     for (i = 0; i < DIST_SIZE(d); i++)
-      *(d->permute + i) = i;
-    permute(d->permute, DIST_SIZE(d), seed);
+      *(ctx->permute + i) = i;
+    permute(ctx->permute, DIST_SIZE(d), seed);
   } else
     INTERNAL_ERROR("Bad call to permute_dist");
 
diff --git a/velox/tpch/gen/tests/CMakeLists.txt b/velox/tpch/gen/tests/CMakeLists.txt
index 9bd7c6bdd4b1..7686a764660e 100644
--- a/velox/tpch/gen/tests/CMakeLists.txt
+++ b/velox/tpch/gen/tests/CMakeLists.txt
@@ -21,4 +21,5 @@ target_link_libraries(
   velox_type
   velox_vector
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/type/CMakeLists.txt b/velox/type/CMakeLists.txt
index 8e251dac4b09..27a9653da494 100644
--- a/velox/type/CMakeLists.txt
+++ b/velox/type/CMakeLists.txt
@@ -29,13 +29,16 @@ velox_add_library(
   StringView.cpp
   StringView.h
   Subfield.cpp
+  Time.cpp
   Timestamp.cpp
   TimestampConversion.cpp
   Tokenizer.cpp
   Type.cpp
+  TypeCoercer.cpp
   TypeEncodingUtil.cpp
   TypeUtil.cpp
-  Variant.cpp)
+  Variant.cpp
+)
 
 velox_link_libraries(
   velox_type
@@ -48,4 +51,5 @@ velox_link_libraries(
   velox_status
   Boost::headers
   Folly::folly
-  re2::re2)
+  re2::re2
+)
diff --git a/velox/type/Conversions.h b/velox/type/Conversions.h
index bab6e2a49e96..a4d92453f6f1 100644
--- a/velox/type/Conversions.h
+++ b/velox/type/Conversions.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <fmt/compile.h>
 #include <folly/Conv.h>
 #include <folly/Expected.h>
 #include <cctype>
@@ -24,6 +25,7 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/Status.h"
 #include "velox/type/CppToType.h"
+#include "velox/type/StringView.h"
 #include "velox/type/TimestampConversion.h"
 #include "velox/type/Type.h"
 
@@ -46,6 +48,12 @@ struct SparkCastPolicy {
   static constexpr bool throwOnUnicode = false;
 };
 
+struct SparkTryCastPolicy {
+  static constexpr bool truncate = false;
+  static constexpr bool legacyCast = false;
+  static constexpr bool throwOnUnicode = false;
+};
+
 struct LegacyCastPolicy {
   static constexpr bool truncate = false;
   static constexpr bool legacyCast = true;
@@ -82,7 +90,9 @@ Expected<bool> castToBoolean(const char* data, size_t len) {
     if (character == 'F' || character == '0') {
       return false;
     }
-    if constexpr (std::is_same_v<TPolicy, SparkCastPolicy>) {
+    if constexpr (
+        std::is_same_v<TPolicy, SparkCastPolicy> ||
+        std::is_same_v<TPolicy, SparkTryCastPolicy>) {
       if (character == 'Y') {
         return true;
       }
@@ -104,7 +114,9 @@ Expected<bool> castToBoolean(const char* data, size_t len) {
     return false;
   }
 
-  if constexpr (std::is_same_v<TPolicy, SparkCastPolicy>) {
+  if constexpr (
+      std::is_same_v<TPolicy, SparkCastPolicy> ||
+      std::is_same_v<TPolicy, SparkTryCastPolicy>) {
     // Case-insensitive 'yes'.
     if ((len == 3) && (TU(data[0]) == 'Y') && (TU(data[1]) == 'E') &&
         (TU(data[2]) == 'S')) {
@@ -117,8 +129,9 @@ Expected<bool> castToBoolean(const char* data, size_t len) {
     }
   }
 
-  return folly::makeUnexpected(Status::UserError(
-      "Cannot cast {} to BOOLEAN", std::string_view(data, len)));
+  return folly::makeUnexpected(
+      Status::UserError(
+          "Cannot cast {} to BOOLEAN", std::string_view(data, len)));
 }
 
 namespace detail {
@@ -130,8 +143,9 @@ Expected<T> callFollyTo(const F& v) {
     if (threadSkipErrorDetails()) {
       return folly::makeUnexpected(Status::UserError());
     }
-    return folly::makeUnexpected(Status::UserError(
-        "{}", folly::makeConversionError(result.error(), "").what()));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "{}", folly::makeConversionError(result.error(), "").what()));
   }
 
   return result.value();
@@ -154,7 +168,7 @@ struct Converter<TypeKind::BOOLEAN, void, TPolicy> {
     return detail::callFollyTo<T>(v);
   }
 
-  static Expected<T> tryCast(folly::StringPiece v) {
+  static Expected<T> tryCast(std::string_view v) {
     return castToBoolean<TPolicy>(v.data(), v.size());
   }
 
@@ -225,8 +239,9 @@ struct Converter<TypeKind::BOOLEAN, void, TPolicy> {
   }
 
   static Expected<T> tryCast(const Timestamp&) {
-    return folly::makeUnexpected(Status::UserError(
-        "Conversion of Timestamp to Boolean is not supported"));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Conversion of Timestamp to Boolean is not supported"));
   }
 };
 
@@ -255,14 +270,15 @@ struct Converter<
     return folly::makeUnexpected(Status::UserError(kErrorMessage));
   }
 
-  static Expected<T> convertStringToInt(const folly::StringPiece v) {
+  static Expected<T> convertStringToInt(const std::string_view 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."));
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Cannot cast an empty string to an integral value."));
     }
 
     // Setting negative flag
@@ -271,8 +287,9 @@ struct Converter<
     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]));
+        return folly::makeUnexpected(
+            Status::UserError(
+                "Cannot cast an '{}' string to an integral value.", v[0]));
       }
       negative = v[0] == '-';
       index = 1;
@@ -318,7 +335,7 @@ struct Converter<
     return result;
   }
 
-  static Expected<T> tryCast(folly::StringPiece v) {
+  static Expected<T> tryCast(std::string_view v) {
     if constexpr (TPolicy::truncate) {
       return convertStringToInt(v);
     } else {
@@ -329,7 +346,7 @@ struct Converter<
 
   static Expected<T> tryCast(const StringView& v) {
     if constexpr (TPolicy::truncate) {
-      return convertStringToInt(folly::StringPiece(v));
+      return convertStringToInt(std::string_view(v));
     } else {
       auto trimmed = trimWhiteSpace(v.data(), v.size());
       return detail::callFollyTo<T>(trimmed);
@@ -410,6 +427,9 @@ struct Converter<
         return folly::makeUnexpected(
             Status::UserError("Cannot cast NaN to an integral value."));
       }
+      if constexpr (std::is_same_v<TPolicy, SparkTryCastPolicy>) {
+        return detail::callFollyTo<T>(std::trunc(v));
+      }
       return detail::callFollyTo<T>(std::round(v));
     }
   }
@@ -434,6 +454,9 @@ struct Converter<
         return folly::makeUnexpected(
             Status::UserError("Cannot cast NaN to an integral value."));
       }
+      if constexpr (std::is_same_v<TPolicy, SparkTryCastPolicy>) {
+        return detail::callFollyTo<T>(std::trunc(v));
+      }
       return detail::callFollyTo<T>(std::round(v));
     }
   }
@@ -484,12 +507,12 @@ struct Converter<
     return detail::callFollyTo<T>(v);
   }
 
-  static Expected<T> tryCast(folly::StringPiece v) {
-    return tryCast<folly::StringPiece>(v);
+  static Expected<T> tryCast(std::string_view v) {
+    return tryCast<std::string_view>(v);
   }
 
   static Expected<T> tryCast(const StringView& v) {
-    return tryCast<folly::StringPiece>(folly::StringPiece(v));
+    return tryCast<std::string_view>(std::string_view(v));
   }
 
   static Expected<T> tryCast(const std::string& v) {
@@ -539,8 +562,9 @@ struct Converter<
   }
 
   static Expected<T> tryCast(const Timestamp&) {
-    return folly::makeUnexpected(Status::UserError(
-        "Conversion of Timestamp to Real or Double is not supported"));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Conversion of Timestamp to Real or Double is not supported"));
   }
 };
 
@@ -574,14 +598,18 @@ struct Converter<TypeKind::VARCHAR, void, TPolicy> {
       }
       if ((val > -10'000'000 && val <= -0.001) ||
           (val >= 0.001 && val < 10'000'000) || val == 0.0) {
-        auto str = fmt::format("{}", val);
+        auto str = fmt::format(FMT_COMPILE("{}"), val);
         normalizeStandardNotation(str);
         return str;
       }
       // 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);
+      std::string str;
+      if constexpr (std::is_same_v<T, float>) {
+        str = fmt::format(FMT_COMPILE("{:.7E}"), val);
+      } else {
+        str = fmt::format(FMT_COMPILE("{:.16E}"), val);
+      }
       normalizeScientificNotation(str);
       return str;
     }
@@ -637,7 +665,7 @@ struct Converter<TypeKind::VARCHAR, void, TPolicy> {
     }
     str[pos++] = 'E';
 
-    int startExp = idxE + 1;
+    size_t startExp = idxE + 1;
     if (str[startExp] == '-') {
       str[pos++] = '-';
       startExp++;
@@ -664,7 +692,7 @@ struct Converter<TypeKind::TIMESTAMP, void, TPolicy> {
         Status::UserError("Conversion to Timestamp is not supported"));
   }
 
-  static Expected<Timestamp> tryCast(folly::StringPiece v) {
+  static Expected<Timestamp> tryCast(std::string_view v) {
     return fromTimestampString(
         v.data(), v.size(), TimestampParseMode::kPrestoCast);
   }
diff --git a/velox/type/CppToType.h b/velox/type/CppToType.h
index 332026b14b6c..b3543391608e 100644
--- a/velox/type/CppToType.h
+++ b/velox/type/CppToType.h
@@ -67,6 +67,8 @@ template <>
 struct CppToType<folly::StringPiece> : public CppToTypeBase<TypeKind::VARCHAR> {
 };
 
+// VARBINARY also uses StringView as the native type but its CppToType template
+// is omitted to avoid conflict with VARCHAR.
 template <>
 struct CppToType<velox::StringView> : public CppToTypeBase<TypeKind::VARCHAR> {
 };
@@ -80,10 +82,6 @@ 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> {};
 
@@ -93,6 +91,9 @@ struct CppToType<double> : public CppToTypeBase<TypeKind::DOUBLE> {};
 template <>
 struct CppToType<Timestamp> : public CppToTypeBase<TypeKind::TIMESTAMP> {};
 
+template <>
+struct CppToType<Time> : public CppToTypeBase<TypeKind::BIGINT> {};
+
 // TODO: maybe do something smarter than just matching any shared_ptr, e.g. we
 // can declare "registered" types explicitly
 template <typename T>
diff --git a/velox/type/DecimalUtil.cpp b/velox/type/DecimalUtil.cpp
index f07b34a11528..dff6ac394fc4 100644
--- a/velox/type/DecimalUtil.cpp
+++ b/velox/type/DecimalUtil.cpp
@@ -54,8 +54,8 @@ std::string formatDecimal(uint8_t scale, int128_t unscaledValue) {
 }
 } // namespace
 
-std::string DecimalUtil::toString(int128_t value, const TypePtr& type) {
-  auto [precision, scale] = getDecimalPrecisionScale(*type);
+std::string DecimalUtil::toString(int128_t value, const Type& type) {
+  auto [precision, scale] = getDecimalPrecisionScale(type);
   return formatDecimal(scale, value);
 }
 
@@ -98,6 +98,17 @@ void DecimalUtil::computeAverage(
     divideWithRoundUp<int128_t, int128_t, int64_t>(
         avg, sum, count, false, 0, 0);
   } else {
+    // The average is computed as `(sum + overflow * kOverflowMultiplier) /
+    // count`:
+    //  1. sum / count → quotient quotSum, remainder remSum.
+    //  2. (overflow * kOverflowMultiplier) / count → quotient quotMul,
+    //  remainder remMul.
+    //  3. (remSum + remMul) / count -> remTotal
+    //  4. final result = quotSum + quotMul + remTotal
+    // Since we only use quotients (no rounding needed, set "noRoundUp = true")
+    // and combine remainders to compute the final average, rounding is applied
+    // based on the combined remainder values (set "noRoundUp = false"), which
+    // ensures accuracy.
     VELOX_DCHECK_LE(overflow, count);
     __uint128_t quotMul, remMul;
     __int128_t quotSum, remSum;
@@ -109,7 +120,7 @@ void DecimalUtil::computeAverage(
     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);
+        remTotal, remMul + remSum, count, false, 0, 0);
     avg = quotMul + quotSum + remTotal;
   }
 }
@@ -125,4 +136,225 @@ int32_t DecimalUtil::maxStringViewSize(int precision, int scale) {
   return rowSize;
 }
 
+namespace {
+
+// 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;
+};
+
+// Extract a string view of continuous digits.
+std::string_view 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);
+}
+
+// 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) {
+  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 = 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 = 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;
+    if (pos == size) {
+      return Status::UserError("The exponent part is empty.");
+    }
+    bool withSign = 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 folly::tryTo allows
+    // leading and trailing whitespaces.
+    for (auto i = static_cast<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.");
+      }
+    }
+    out.exponent = folly::to<int32_t>(std::string_view(s + pos, size - pos));
+    return Status::OK();
+  }
+  return pos == size ? Status::OK() : Status::UserError("Chars are invalid.");
+}
+
+// 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) {
+  // Parse the whole digits.
+  if (decimalComponents.wholeDigits.size() > 0) {
+    const auto tryValue = folly::tryTo<int128_t>(std::string_view(
+        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>(
+        std::string_view(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
+
+Status DecimalUtil::parseStringToDecimalComponents(
+    const StringView& s,
+    int32_t toScale,
+    int32_t& parsedPrecision,
+    int32_t& parsedScale,
+    int128_t& out) {
+  DecimalComponents decimalComponents;
+  if (auto status =
+          parseDecimalComponents(s.data(), s.size(), decimalComponents);
+      !status.ok()) {
+    return Status::UserError("Value is not a number. " + status.message());
+  }
+
+  // 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;
+  }
+  parsedPrecision = static_cast<int32_t>(significantDigits);
+
+  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;
+    }
+  } 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();
+      }
+    }
+  }
+
+  VELOX_RETURN_NOT_OK(parseHugeInt(decimalComponents, out));
+
+  if (roundUp) {
+    bool overflow = __builtin_add_overflow(out, 1, &out);
+    if (UNLIKELY(overflow)) {
+      return Status::UserError("Value too large.");
+    }
+  }
+  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, kPowersOfTen[-parsedScale + toScale], &out);
+    if (UNLIKELY(overflow)) {
+      return Status::UserError("Value too large.");
+    }
+    parsedPrecision -= parsedScale;
+    parsedScale = toScale;
+  }
+  return Status::OK();
+}
+
 } // namespace facebook::velox
diff --git a/velox/type/DecimalUtil.h b/velox/type/DecimalUtil.h
index 98d1959aafcd..581c776f7c97 100644
--- a/velox/type/DecimalUtil.h
+++ b/velox/type/DecimalUtil.h
@@ -102,7 +102,12 @@ class DecimalUtil {
   }
 
   /// Helper function to convert a decimal value to string.
-  static std::string toString(int128_t value, const TypePtr& type);
+  static std::string toString(int128_t value, const Type& type);
+
+  // TODO Remove.
+  static std::string toString(int128_t value, const TypePtr& type) {
+    return toString(value, *type);
+  }
 
   template <typename T>
   inline static void fillDecimals(
@@ -502,6 +507,53 @@ class DecimalUtil {
     }
   }
 
+  /// Converts string view to decimal value of given precision and scale.
+  /// Derives from Arrow function DecimalFromString. Arrow implementation:
+  /// https://github.com/apache/arrow/blob/56c0e2f508fdc5137d6734b406634386f9284a52/cpp/src/arrow/util/decimal.cc#L862.
+  ///
+  /// 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>
+  static Status castFromString(
+      const StringView s,
+      int32_t toPrecision,
+      int32_t toScale,
+      T& decimalValue) {
+    int32_t parsedPrecision = 0;
+    int32_t parsedScale = 0;
+    int128_t out = 0;
+    VELOX_RETURN_NOT_OK(parseStringToDecimalComponents(
+        s, toScale, parsedPrecision, parsedScale, out));
+
+    const auto status = rescaleWithRoundUp<int128_t, T>(
+        out,
+        std::min(
+            static_cast<uint8_t>(parsedPrecision),
+            LongDecimalType::kMaxPrecision),
+        parsedScale,
+        toPrecision,
+        toScale,
+        decimalValue);
+    if (!status.ok()) {
+      return Status::UserError("Value too large.");
+    }
+    return status;
+  }
+
   static constexpr __uint128_t kOverflowMultiplier = ((__uint128_t)1 << 127);
+
+ private:
+  // Parses the string view to decimal components, which contains the
+  // unscaled value, precision, and scale. The parsed precision and scale are
+  // returned through the reference parameters. The unscaled value is returned
+  // through the out parameter.
+  static Status parseStringToDecimalComponents(
+      const StringView& s,
+      int32_t toScale,
+      int32_t& parsedPrecision,
+      int32_t& parsedScale,
+      int128_t& out);
 }; // DecimalUtil
 } // namespace facebook::velox
diff --git a/velox/type/Filter.cpp b/velox/type/Filter.cpp
index af6da372e22d..d00ee159fe2c 100644
--- a/velox/type/Filter.cpp
+++ b/velox/type/Filter.cpp
@@ -20,124 +20,55 @@
 #include <set>
 #include <string>
 
-#include "velox/common/base/Exceptions.h"
 #include "velox/type/Filter.h"
 
 namespace facebook::velox::common {
 
-std::string Filter::toString() const {
-  std::string strKind;
-  switch (kind_) {
-    case FilterKind::kAlwaysFalse:
-      strKind = "AlwaysFalse";
-      break;
-    case FilterKind::kAlwaysTrue:
-      strKind = "AlwaysTrue";
-      break;
-    case FilterKind::kIsNull:
-      strKind = "IsNull";
-      break;
-    case FilterKind::kIsNotNull:
-      strKind = "IsNotNull";
-      break;
-    case FilterKind::kBoolValue:
-      strKind = "BoolValue";
-      break;
-    case FilterKind::kBigintRange:
-      strKind = "BigintRange";
-      break;
-    case FilterKind::kNegatedBigintRange:
-      strKind = "NegatedBigintRange";
-      break;
-    case FilterKind::kBigintValuesUsingHashTable:
-      strKind = "BigintValuesUsingHashTable";
-      break;
-    case FilterKind::kBigintValuesUsingBitmask:
-      strKind = "BigintValuesUsingBitmask";
-      break;
-    case FilterKind::kNegatedBigintValuesUsingHashTable:
-      strKind = "NegatedBigintValuesUsingHashTable";
-      break;
-    case FilterKind::kNegatedBigintValuesUsingBitmask:
-      strKind = "NegatedBigintValuesUsingBitmask";
-      break;
-    case FilterKind::kDoubleRange:
-      strKind = "DoubleRange";
-      break;
-    case FilterKind::kFloatRange:
-      strKind = "FloatRange";
-      break;
-    case FilterKind::kBytesRange:
-      strKind = "BytesRange";
-      break;
-    case FilterKind::kNegatedBytesRange:
-      strKind = "NegatedBytesRange";
-      break;
-    case FilterKind::kBytesValues:
-      strKind = "BytesValues";
-      break;
-    case FilterKind::kNegatedBytesValues:
-      strKind = "NegatedBytesValues";
-      break;
-    case FilterKind::kBigintMultiRange:
-      strKind = "BigintMultiRange";
-      break;
-    case FilterKind::kMultiRange:
-      strKind = "MultiRange";
-      break;
-    case FilterKind::kHugeintRange:
-      strKind = "HugeintRange";
-      break;
-    case FilterKind::kTimestampRange:
-      strKind = "TimestampRange";
-      break;
-    case FilterKind::kHugeintValuesUsingHashTable:
-      strKind = "HugeintValuesUsingHashTable";
-      break;
+namespace {
+const auto& filterKindNames() {
+  static const folly::F14FastMap<FilterKind, std::string_view> kNames = {
+      {FilterKind::kAlwaysFalse, "AlwaysFalse"},
+      {FilterKind::kAlwaysTrue, "AlwaysTrue"},
+      {FilterKind::kIsNull, "IsNull"},
+      {FilterKind::kIsNotNull, "IsNotNull"},
+      {FilterKind::kBoolValue, "BoolValue"},
+      {FilterKind::kBigintRange, "BigintRange"},
+      {FilterKind::kNegatedBigintRange, "NegatedBigintRange"},
+      {FilterKind::kBigintValuesUsingHashTable, "BigintValuesUsingHashTable"},
+      {FilterKind::kBigintValuesUsingBitmask, "BigintValuesUsingBitmask"},
+      {FilterKind::kNegatedBigintValuesUsingHashTable,
+       "NegatedBigintValuesUsingHashTable"},
+      {FilterKind::kNegatedBigintValuesUsingBitmask,
+       "NegatedBigintValuesUsingBitmask"},
+      {FilterKind::kDoubleRange, "DoubleRange"},
+      {FilterKind::kFloatRange, "FloatRange"},
+      {FilterKind::kBytesRange, "BytesRange"},
+      {FilterKind::kNegatedBytesRange, "NegatedBytesRange"},
+      {FilterKind::kBytesValues, "BytesValues"},
+      {FilterKind::kNegatedBytesValues, "NegatedBytesValues"},
+      {FilterKind::kBigintMultiRange, "BigintMultiRange"},
+      {FilterKind::kMultiRange, "MultiRange"},
+      {FilterKind::kHugeintRange, "HugeintRange"},
+      {FilterKind::kTimestampRange, "TimestampRange"},
+      {FilterKind::kHugeintValuesUsingHashTable, "HugeintValuesUsingHashTable"},
+      {FilterKind::kBigintValuesUsingBloomFilter,
+       "BigintValuesUsingBloomFilter"},
   };
+  return kNames;
+}
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(FilterKind, filterKindNames);
 
+std::string Filter::toString() const {
   return fmt::format(
       "Filter({}, {}, {})",
-      strKind,
+      kindName(),
       deterministic_ ? "deterministic" : "nondeterministic",
-      nullAllowed_ ? "null allowed" : "null not allowed");
+      nullAllowed_ ? "with nulls" : "no nulls");
 }
 
 namespace {
-std::unordered_map<FilterKind, std::string> filterKindNames() {
-  return {
-      {FilterKind::kAlwaysFalse, "kAlwaysFalse"},
-      {FilterKind::kAlwaysTrue, "kAlwaysTrue"},
-      {FilterKind::kIsNull, "kIsNull"},
-      {FilterKind::kIsNotNull, "kIsNotNull"},
-      {FilterKind::kBoolValue, "kBoolValue"},
-      {FilterKind::kBigintRange, "kBigintRange"},
-      {FilterKind::kBigintValuesUsingHashTable, "kBigintValuesUsingHashTable"},
-      {FilterKind::kBigintValuesUsingBitmask, "kBigintValuesUsingBitmask"},
-      {FilterKind::kNegatedBigintRange, "kNegatedBigintRange"},
-      {FilterKind::kNegatedBigintValuesUsingHashTable,
-       "kNegatedBigintValuesUsingHashTable"},
-      {FilterKind::kNegatedBigintValuesUsingBitmask,
-       "kNegatedBigintValuesUsingBitmask"},
-      {FilterKind::kDoubleRange, "kDoubleRange"},
-      {FilterKind::kFloatRange, "kFloatRange"},
-      {FilterKind::kBytesRange, "kBytesRange"},
-      {FilterKind::kNegatedBytesRange, "kNegatedBytesRange"},
-      {FilterKind::kBytesValues, "kBytesValues"},
-      {FilterKind::kNegatedBytesValues, "kNegatedBytesValues"},
-      {FilterKind::kBigintMultiRange, "kBigintMultiRange"},
-      {FilterKind::kMultiRange, "kMultiRange"},
-      {FilterKind::kHugeintRange, "kHugeintRange"},
-      {FilterKind::kTimestampRange, "kTimestampRange"},
-      {FilterKind::kHugeintValuesUsingHashTable,
-       "kHugeintValuesUsingHashTable"},
-  };
-}
-
-const char* filterKindName(FilterKind kind) {
-  static const auto kNames = filterKindNames();
-  return kNames.at(kind).c_str();
-}
 
 bool deserializeNullAllowed(const folly::dynamic& obj) {
   return obj["nullAllowed"].asBool();
@@ -182,6 +113,8 @@ void Filter::registerSerDe() {
       "BigintValuesUsingHashTable", BigintValuesUsingHashTable::create);
   registry.Register(
       "BigintValuesUsingBitmask", BigintValuesUsingBitmask::create);
+  registry.Register(
+      "BigintValuesUsingBloomFilter", BigintValuesUsingBloomFilter::create);
   registry.Register(
       "NegatedBigintValuesUsingHashTable",
       NegatedBigintValuesUsingHashTable::create);
@@ -201,72 +134,74 @@ void Filter::registerSerDe() {
   registry.Register("TimestampRange", TimestampRange::create);
 }
 
-folly::dynamic Filter::serializeBase(std::string_view name) const {
+folly::dynamic Filter::serializeBase() const {
   folly::dynamic obj = folly::dynamic::object;
-  obj["name"] = name;
+  obj["name"] = kindName();
   obj["nullAllowed"] = nullAllowed_;
-  obj["kind"] = filterKindName(kind_);
   return obj;
 }
 
 folly::dynamic AlwaysFalse::serialize() const {
-  return Filter::serializeBase("AlwaysFalse");
+  return Filter::serializeBase();
 }
 
-FilterPtr AlwaysFalse::create(const folly::dynamic& /*obj*/) {
+std::unique_ptr<Filter> AlwaysFalse::create(const folly::dynamic& /*obj*/) {
   return std::make_unique<AlwaysFalse>();
 }
 
 folly::dynamic AlwaysTrue::serialize() const {
-  return Filter::serializeBase("AlwaysTrue");
+  return Filter::serializeBase();
 }
 
-FilterPtr AlwaysTrue::create(const folly::dynamic& /*obj*/) {
+std::unique_ptr<Filter> AlwaysTrue::create(const folly::dynamic& /*obj*/) {
   return std::make_unique<AlwaysTrue>();
 }
 
 folly::dynamic IsNull::serialize() const {
-  return Filter::serializeBase("IsNull");
+  return Filter::serializeBase();
 }
 
-FilterPtr IsNull::create(const folly::dynamic& /*obj*/) {
+std::unique_ptr<Filter> IsNull::create(const folly::dynamic& /*obj*/) {
   return std::make_unique<IsNull>();
 }
 
 folly::dynamic IsNotNull::serialize() const {
-  return Filter::serializeBase("IsNotNull");
+  return Filter::serializeBase();
 }
 
-FilterPtr IsNotNull::create(const folly::dynamic& /*obj*/) {
+std::unique_ptr<Filter> IsNotNull::create(const folly::dynamic& /*obj*/) {
   return std::make_unique<IsNotNull>();
 }
 
 folly::dynamic BoolValue::serialize() const {
-  auto obj = Filter::serializeBase("BoolValue");
+  auto obj = Filter::serializeBase();
   obj["value"] = value_;
   return obj;
 }
 
-FilterPtr BoolValue::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> BoolValue::create(const folly::dynamic& obj) {
   auto value = obj["value"].asBool();
   auto nullAllowed = deserializeNullAllowed(obj);
   return std::make_unique<BoolValue>(value, nullAllowed);
 }
 
 bool BoolValue::testingEquals(const Filter& other) const {
-  auto otherBoolValue = dynamic_cast<const BoolValue*>(&other);
-  return otherBoolValue != nullptr && Filter::testingBaseEquals(other) &&
-      (value_ == otherBoolValue->value_);
+  if (const auto* otherBoolValue =
+          Filter::testingBaseEquals<BoolValue>(other)) {
+    return value_ == otherBoolValue->value_;
+  }
+
+  return false;
 }
 
 folly::dynamic BigintRange::serialize() const {
-  auto obj = Filter::serializeBase("BigintRange");
+  auto obj = Filter::serializeBase();
   obj["lower"] = lower_;
   obj["upper"] = upper_;
   return obj;
 }
 
-FilterPtr BigintRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> BigintRange::create(const folly::dynamic& obj) {
   auto lower = obj["lower"].asInt();
   auto upper = obj["upper"].asInt();
   auto nullAllowed = deserializeNullAllowed(obj);
@@ -274,20 +209,21 @@ FilterPtr BigintRange::create(const folly::dynamic& obj) {
 }
 
 bool BigintRange::testingEquals(const Filter& other) const {
-  auto otherBigintRange = dynamic_cast<const BigintRange*>(&other);
-  return otherBigintRange != nullptr && Filter::testingBaseEquals(other) &&
-      (lower_ == otherBigintRange->lower_) &&
-      (upper_ == otherBigintRange->upper_);
+  if (const auto* otherRange = Filter::testingBaseEquals<BigintRange>(other)) {
+    return (lower_ == otherRange->lower_) && (upper_ == otherRange->upper_);
+  }
+
+  return false;
 }
 
 folly::dynamic NegatedBigintRange::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBigintRange");
+  auto obj = Filter::serializeBase();
   obj["lower"] = nonNegated_->lower();
   obj["upper"] = nonNegated_->upper();
   return obj;
 }
 
-FilterPtr NegatedBigintRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> NegatedBigintRange::create(const folly::dynamic& obj) {
   auto lower = obj["lower"].asInt();
   auto upper = obj["upper"].asInt();
   auto nullAllowed = deserializeNullAllowed(obj);
@@ -295,21 +231,22 @@ FilterPtr NegatedBigintRange::create(const folly::dynamic& obj) {
 }
 
 bool NegatedBigintRange::testingEquals(const Filter& other) const {
-  auto otherNegatedBigintRange =
-      dynamic_cast<const NegatedBigintRange*>(&other);
-  return otherNegatedBigintRange != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals(*(otherNegatedBigintRange->nonNegated_));
+  if (const auto* otherRange =
+          Filter::testingBaseEquals<NegatedBigintRange>(other)) {
+    return nonNegated_->testingEquals(*(otherRange->nonNegated_));
+  }
+
+  return false;
 }
 
 folly::dynamic HugeintRange::serialize() const {
-  auto obj = Filter::serializeBase("HugeintRange");
+  auto obj = Filter::serializeBase();
   obj["lower"] = std::to_string(lower_);
   obj["upper"] = std::to_string(upper_);
   return obj;
 }
 
-FilterPtr HugeintRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> HugeintRange::create(const folly::dynamic& obj) {
   auto lower = HugeInt::parse(obj["lower"].asString());
   auto upper = HugeInt::parse(obj["upper"].asString());
   auto nullAllowed = deserializeNullAllowed(obj);
@@ -317,20 +254,21 @@ FilterPtr HugeintRange::create(const folly::dynamic& obj) {
 }
 
 bool HugeintRange::testingEquals(const Filter& other) const {
-  auto otherHugeintRange = dynamic_cast<const HugeintRange*>(&other);
-  return otherHugeintRange != nullptr && Filter::testingBaseEquals(other) &&
-      lower_ == otherHugeintRange->lower_ &&
-      upper_ == otherHugeintRange->upper_;
+  if (const auto* otherRange = Filter::testingBaseEquals<HugeintRange>(other)) {
+    return lower_ == otherRange->lower_ && upper_ == otherRange->upper_;
+  }
+
+  return false;
 }
 
 folly::dynamic TimestampRange::serialize() const {
-  auto obj = Filter::serializeBase("TimestampRange");
+  auto obj = Filter::serializeBase();
   obj["lower"] = lower_.serialize();
   obj["upper"] = upper_.serialize();
   return obj;
 }
 
-FilterPtr TimestampRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> TimestampRange::create(const folly::dynamic& obj) {
   auto lower = ISerializable::deserialize<Timestamp>(obj["lower"]);
   auto upper = ISerializable::deserialize<Timestamp>(obj["upper"]);
   auto nullAllowed = deserializeNullAllowed(obj);
@@ -338,14 +276,16 @@ FilterPtr TimestampRange::create(const folly::dynamic& obj) {
 }
 
 bool TimestampRange::testingEquals(const Filter& other) const {
-  auto otherTimestampRange = dynamic_cast<const TimestampRange*>(&other);
-  return otherTimestampRange != nullptr && Filter::testingBaseEquals(other) &&
-      (lower_ == otherTimestampRange->lower_) &&
-      (upper_ == otherTimestampRange->upper_);
+  if (const auto* otherRange =
+          Filter::testingBaseEquals<TimestampRange>(other)) {
+    return (lower_ == otherRange->lower_) && (upper_ == otherRange->upper_);
+  }
+
+  return false;
 }
 
 folly::dynamic BigintValuesUsingHashTable::serialize() const {
-  auto obj = Filter::serializeBase("BigintValuesUsingHashTable");
+  auto obj = Filter::serializeBase();
   obj["min"] = min_;
   obj["max"] = max_;
 
@@ -358,7 +298,8 @@ folly::dynamic BigintValuesUsingHashTable::serialize() const {
   return obj;
 }
 
-FilterPtr BigintValuesUsingHashTable::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> BigintValuesUsingHashTable::create(
+    const folly::dynamic& obj) {
   auto nullAllowed = deserializeNullAllowed(obj);
   auto min = obj["min"].asInt();
   auto max = obj["max"].asInt();
@@ -369,28 +310,31 @@ FilterPtr BigintValuesUsingHashTable::create(const folly::dynamic& obj) {
 }
 
 bool BigintValuesUsingHashTable::testingEquals(const Filter& other) const {
-  auto otherBigintValues =
-      dynamic_cast<const BigintValuesUsingHashTable*>(&other);
-  bool res = otherBigintValues != nullptr && Filter::testingBaseEquals(other) &&
-      min_ == otherBigintValues->min_ && max_ == otherBigintValues->max_ &&
-      values_.size() == otherBigintValues->values_.size();
+  if (const auto* otherBigintValues =
+          Filter::testingBaseEquals<BigintValuesUsingHashTable>(other)) {
+    bool res = min_ == otherBigintValues->min_ &&
+        max_ == otherBigintValues->max_ &&
+        values_.size() == otherBigintValues->values_.size();
 
-  if (!res) {
-    return false;
-  }
-
-  // values_ can be compared pair-wise since they are sorted.
-  for (size_t i = 0; i < values_.size(); ++i) {
-    if (values_.at(i) != otherBigintValues->values_.at(i)) {
+    if (!res) {
       return false;
     }
+
+    // values_ can be compared pair-wise since they are sorted.
+    for (size_t i = 0; i < values_.size(); ++i) {
+      if (values_[i] != otherBigintValues->values_[i]) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 folly::dynamic BigintValuesUsingBitmask::serialize() const {
-  auto obj = Filter::serializeBase("BigintValuesUsingBitmask");
+  auto obj = Filter::serializeBase();
   obj["min"] = min_;
   obj["max"] = max_;
 
@@ -405,7 +349,8 @@ folly::dynamic BigintValuesUsingBitmask::serialize() const {
   return obj;
 }
 
-FilterPtr BigintValuesUsingBitmask::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> BigintValuesUsingBitmask::create(
+    const folly::dynamic& obj) {
   auto min = obj["min"].asInt();
   auto max = obj["max"].asInt();
   auto nullAllowed = deserializeNullAllowed(obj);
@@ -416,32 +361,83 @@ FilterPtr BigintValuesUsingBitmask::create(const folly::dynamic& obj) {
 }
 
 bool BigintValuesUsingBitmask::testingEquals(const Filter& other) const {
-  auto otherBigintValues =
-      dynamic_cast<const BigintValuesUsingBitmask*>(&other);
-  bool res = otherBigintValues != nullptr && Filter::testingBaseEquals(other) &&
-      min_ == otherBigintValues->min_ && max_ == otherBigintValues->max_ &&
-      bitmask_.size() == otherBigintValues->bitmask_.size();
+  if (const auto* otherBigintValues =
+          Filter::testingBaseEquals<BigintValuesUsingBitmask>(other)) {
+    bool res = min_ == otherBigintValues->min_ &&
+        max_ == otherBigintValues->max_ &&
+        bitmask_.size() == otherBigintValues->bitmask_.size();
 
-  if (!res) {
-    return false;
+    if (!res) {
+      return false;
+    }
+
+    for (size_t i = 0; i < bitmask_.size(); ++i) {
+      if (bitmask_.at(i) != otherBigintValues->bitmask_.at(i)) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  for (size_t i = 0; i < bitmask_.size(); ++i) {
-    if (bitmask_.at(i) != otherBigintValues->bitmask_.at(i)) {
-      return false;
+  return false;
+}
+
+folly::dynamic BigintValuesUsingBloomFilter::serialize() const {
+  auto obj = Filter::serializeBase();
+  folly::dynamic words = folly::dynamic::array;
+  for (auto& block : blocks_) {
+    for (auto word : block.data) {
+      words.push_back(word);
     }
   }
+  obj["numHashes"] = xsimd::batch<uint32_t>::size;
+  obj["blockWords"] = words;
+  return obj;
+}
 
-  return true;
+std::unique_ptr<Filter> BigintValuesUsingBloomFilter::create(
+    const folly::dynamic& obj) {
+  VELOX_USER_CHECK_EQ(
+      obj["numHashes"].asInt(),
+      xsimd::batch<uint32_t>::size,
+      "Cannot deserialize BigintValuesUsingBloomFilter serialized on hardware with different SIMD length");
+  auto nullAllowed = deserializeNullAllowed(obj);
+  std::vector<SplitBlockBloomFilter::Block> blocks;
+  int i = 0;
+  SplitBlockBloomFilter::Block current{};
+  for (auto& word : obj["blockWords"]) {
+    current.data[i++] = word.asInt();
+    if (i == xsimd::batch<uint32_t>::size) {
+      blocks.push_back(current);
+      i = 0;
+    }
+  }
+  return std::unique_ptr<BigintValuesUsingBloomFilter>(
+      new BigintValuesUsingBloomFilter(nullAllowed, std::move(blocks)));
+}
+
+bool BigintValuesUsingBloomFilter::testingEquals(const Filter& other) const {
+  auto* typedOther =
+      Filter::testingBaseEquals<BigintValuesUsingBloomFilter>(other);
+  if (!typedOther) {
+    return false;
+  }
+  return blocks_.size() == typedOther->blocks_.size() &&
+      memcmp(
+          blocks_.data(),
+          typedOther->blocks_.data(),
+          blocks_.size() * sizeof(SplitBlockBloomFilter::Block)) == 0;
 }
 
 folly::dynamic NegatedBigintValuesUsingHashTable::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBigintValuesUsingHashTable");
+  auto obj = Filter::serializeBase();
   obj["nonNegated"] = nonNegated_->serialize();
   return obj;
 }
 
-FilterPtr NegatedBigintValuesUsingHashTable::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> NegatedBigintValuesUsingHashTable::create(
+    const folly::dynamic& obj) {
   auto nullAllowed = deserializeNullAllowed(obj);
   auto nonNegated =
       ISerializable::deserialize<BigintValuesUsingHashTable>(obj["nonNegated"]);
@@ -455,22 +451,24 @@ FilterPtr NegatedBigintValuesUsingHashTable::create(const folly::dynamic& obj) {
 
 bool NegatedBigintValuesUsingHashTable::testingEquals(
     const Filter& other) const {
-  auto otherNegatedBigintValues =
-      dynamic_cast<const NegatedBigintValuesUsingHashTable*>(&other);
-  return otherNegatedBigintValues != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals(*(otherNegatedBigintValues->nonNegated_));
+  if (const auto* otherNegated =
+          Filter::testingBaseEquals<NegatedBigintValuesUsingHashTable>(other)) {
+    return nonNegated_->testingEquals(*(otherNegated->nonNegated_));
+  }
+
+  return false;
 }
 
 folly::dynamic NegatedBigintValuesUsingBitmask::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBigintValuesUsingBitmask");
+  auto obj = Filter::serializeBase();
   obj["min"] = min_;
   obj["max"] = max_;
   obj["nonNegated"] = nonNegated_->serialize();
   return obj;
 }
 
-FilterPtr NegatedBigintValuesUsingBitmask::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> NegatedBigintValuesUsingBitmask::create(
+    const folly::dynamic& obj) {
   auto min = obj["min"].asInt();
   auto max = obj["max"].asInt();
   auto nullAllowed = deserializeNullAllowed(obj);
@@ -482,30 +480,15 @@ FilterPtr NegatedBigintValuesUsingBitmask::create(const folly::dynamic& obj) {
 }
 
 bool NegatedBigintValuesUsingBitmask::testingEquals(const Filter& other) const {
-  auto otherNegatedBigintValues =
-      dynamic_cast<const NegatedBigintValuesUsingBitmask*>(&other);
-  return otherNegatedBigintValues != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals(*(otherNegatedBigintValues->nonNegated_));
-}
-
-template <>
-folly::dynamic FloatingPointRange<float>::serialize() const {
-  auto obj = AbstractRange::serializeBase("FloatRange");
-  obj["lower"] = lower_;
-  obj["upper"] = upper_;
-  return obj;
-}
+  if (const auto* otherNegated =
+          Filter::testingBaseEquals<NegatedBigintValuesUsingBitmask>(other)) {
+    return nonNegated_->testingEquals(*(otherNegated->nonNegated_));
+  }
 
-template <>
-folly::dynamic FloatingPointRange<double>::serialize() const {
-  auto obj = AbstractRange::serializeBase("DoubleRange");
-  obj["lower"] = lower_;
-  obj["upper"] = upper_;
-  return obj;
+  return false;
 }
 
-FilterPtr AbstractRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> AbstractRange::create(const folly::dynamic& obj) {
   auto lowerUnbounded = obj["lowerUnbounded"].asBool();
   auto lowerExclusive = obj["lowerExclusive"].asBool();
   auto upperUnbounded = obj["upperUnbounded"].asBool();
@@ -537,14 +520,14 @@ FilterPtr AbstractRange::create(const folly::dynamic& obj) {
 }
 
 folly::dynamic BytesRange::serialize() const {
-  auto obj = AbstractRange::serializeBase("BytesRange");
+  auto obj = AbstractRange::serializeBase();
   obj["lower"] = lower_;
   obj["upper"] = upper_;
   obj["singleValue"] = singleValue_;
   return obj;
 }
 
-FilterPtr BytesRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> BytesRange::create(const folly::dynamic& obj) {
   auto lowerUnbounded = obj["lowerUnbounded"].asBool();
   auto lowerExclusive = obj["lowerExclusive"].asBool();
   auto upperUnbounded = obj["upperUnbounded"].asBool();
@@ -563,19 +546,22 @@ FilterPtr BytesRange::create(const folly::dynamic& obj) {
 }
 
 bool BytesRange::testingEquals(const Filter& other) const {
-  auto otherBytesRange = dynamic_cast<const BytesRange*>(&other);
-  return otherBytesRange != nullptr && Filter::testingBaseEquals(other) &&
-      lower_ == otherBytesRange->lower_ && upper_ == otherBytesRange->upper_ &&
-      singleValue_ == otherBytesRange->singleValue_;
+  if (const auto* otherRange =
+          AbstractRange::testingBaseEquals<BytesRange>(other)) {
+    return lower_ == otherRange->lower_ && upper_ == otherRange->upper_ &&
+        singleValue_ == otherRange->singleValue_;
+  }
+
+  return false;
 }
 
 folly::dynamic NegatedBytesRange::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBytesRange");
+  auto obj = Filter::serializeBase();
   obj["nonNegated"] = nonNegated_->serialize();
   return obj;
 }
 
-FilterPtr NegatedBytesRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> NegatedBytesRange::create(const folly::dynamic& obj) {
   auto nonNegated = ISerializable::deserialize<BytesRange>(obj["nonNegated"]);
 
   return std::make_unique<NegatedBytesRange>(
@@ -589,14 +575,16 @@ FilterPtr NegatedBytesRange::create(const folly::dynamic& obj) {
 }
 
 bool NegatedBytesRange::testingEquals(const Filter& other) const {
-  auto otherNegatedBytesRange = dynamic_cast<const NegatedBytesRange*>(&other);
-  return otherNegatedBytesRange != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals(*(otherNegatedBytesRange->nonNegated_));
+  if (const auto* otherNegated =
+          Filter::testingBaseEquals<NegatedBytesRange>(other)) {
+    return nonNegated_->testingEquals(*(otherNegated->nonNegated_));
+  }
+
+  return false;
 }
 
 folly::dynamic BytesValues::serialize() const {
-  auto obj = Filter::serializeBase("BytesValues");
+  auto obj = Filter::serializeBase();
   folly::dynamic values = folly::dynamic::array;
   for (auto v : values_) {
     values.push_back(v);
@@ -605,7 +593,7 @@ folly::dynamic BytesValues::serialize() const {
   return obj;
 }
 
-FilterPtr BytesValues::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> BytesValues::create(const folly::dynamic& obj) {
   auto nullAllowed = deserializeNullAllowed(obj);
   auto arr = obj["values"];
   std::vector<std::string> values;
@@ -619,34 +607,37 @@ FilterPtr BytesValues::create(const folly::dynamic& obj) {
 }
 
 bool BytesValues::testingEquals(const Filter& other) const {
-  auto otherBytesValues = dynamic_cast<const BytesValues*>(&other);
-  auto res = otherBytesValues != nullptr && Filter::testingBaseEquals(other) &&
-      lower_ == otherBytesValues->lower_ &&
-      upper_ == otherBytesValues->upper_ &&
-      values_.size() == otherBytesValues->values_.size() &&
-      lengths_.size() == otherBytesValues->lengths_.size();
-
-  if (!res) {
-    return false;
-  }
-
-  for (const auto& v : values_) {
-    if (!otherBytesValues->values_.contains(v)) {
+  if (const auto* otherBytesValues =
+          Filter::testingBaseEquals<BytesValues>(other)) {
+    auto res = lower_ == otherBytesValues->lower_ &&
+        upper_ == otherBytesValues->upper_ &&
+        values_.size() == otherBytesValues->values_.size() &&
+        lengths_.size() == otherBytesValues->lengths_.size();
+
+    if (!res) {
       return false;
     }
-  }
 
-  for (auto l : lengths_) {
-    if (!otherBytesValues->lengths_.contains(l)) {
-      return false;
+    for (const auto& v : values_) {
+      if (!otherBytesValues->values_.contains(v)) {
+        return false;
+      }
+    }
+
+    for (auto l : lengths_) {
+      if (!otherBytesValues->lengths_.contains(l)) {
+        return false;
+      }
     }
+
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 folly::dynamic BigintMultiRange::serialize() const {
-  auto obj = Filter::serializeBase("BigintMultiRange");
+  auto obj = Filter::serializeBase();
   folly::dynamic arr = folly::dynamic::array;
   for (const auto& r : ranges_) {
     arr.push_back(r->serialize());
@@ -655,45 +646,47 @@ folly::dynamic BigintMultiRange::serialize() const {
   return obj;
 }
 
-FilterPtr BigintMultiRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> BigintMultiRange::create(const folly::dynamic& obj) {
   auto nullAllowed = deserializeNullAllowed(obj);
   auto arr = obj["ranges"];
   std::vector<std::unique_ptr<BigintRange>> ranges;
   ranges.reserve(arr.size());
   for (const auto& r : arr) {
-    ranges.push_back(std::make_unique<BigintRange>(
-        *ISerializable::deserialize<BigintRange>(r)));
+    ranges.push_back(
+        std::make_unique<BigintRange>(
+            *ISerializable::deserialize<BigintRange>(r)));
   }
   return std::make_unique<BigintMultiRange>(std::move(ranges), nullAllowed);
 }
 
 bool BigintMultiRange::testingEquals(const Filter& other) const {
-  auto otherBigintMultiRange = dynamic_cast<const BigintMultiRange*>(&other);
-  auto res = otherBigintMultiRange != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      ranges_.size() == otherBigintMultiRange->ranges_.size();
+  if (const auto* otherMultiRange =
+          Filter::testingBaseEquals<BigintMultiRange>(other)) {
+    auto res = ranges_.size() == otherMultiRange->ranges_.size();
 
-  if (!res) {
-    return false;
-  }
-
-  for (size_t i = 0; i < ranges_.size(); ++i) {
-    if (!(ranges_.at(i)->testingEquals(
-            *(otherBigintMultiRange->ranges_.at(i))))) {
+    if (!res) {
       return false;
     }
+
+    for (size_t i = 0; i < ranges_.size(); ++i) {
+      if (!(ranges_.at(i)->testingEquals(*(otherMultiRange->ranges_.at(i))))) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 folly::dynamic NegatedBytesValues::serialize() const {
-  auto obj = Filter::serializeBase("NegatedBytesValues");
+  auto obj = Filter::serializeBase();
   obj["nonNegated"] = nonNegated_->serialize();
   return obj;
 }
 
-FilterPtr NegatedBytesValues::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> NegatedBytesValues::create(const folly::dynamic& obj) {
   auto nullAllowed = deserializeNullAllowed(obj);
   auto nonNegated = ISerializable::deserialize<BytesValues>(obj["nonNegated"]);
   return std::make_unique<NegatedBytesValues>(
@@ -703,15 +696,16 @@ FilterPtr NegatedBytesValues::create(const folly::dynamic& obj) {
 }
 
 bool NegatedBytesValues::testingEquals(const Filter& other) const {
-  auto otherNegatedBytesValues =
-      dynamic_cast<const NegatedBytesValues*>(&other);
-  return otherNegatedBytesValues != nullptr &&
-      Filter::testingBaseEquals(other) &&
-      nonNegated_->testingEquals((*(otherNegatedBytesValues->nonNegated_)));
+  if (const auto* otherNegated =
+          Filter::testingBaseEquals<NegatedBytesValues>(other)) {
+    return nonNegated_->testingEquals((*(otherNegated->nonNegated_)));
+  }
+
+  return false;
 }
 
 folly::dynamic MultiRange::serialize() const {
-  auto obj = Filter::serializeBase("MultiRange");
+  auto obj = Filter::serializeBase();
   folly::dynamic arr = folly::dynamic::array;
   for (const auto& f : filters_) {
     arr.push_back(f->serialize());
@@ -720,7 +714,7 @@ folly::dynamic MultiRange::serialize() const {
   return obj;
 }
 
-FilterPtr MultiRange::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> MultiRange::create(const folly::dynamic& obj) {
   auto nullAllowed = deserializeNullAllowed(obj);
   folly::dynamic arr = obj["filters"];
   auto tmpFilters = ISerializable::deserialize<std::vector<Filter>>(arr);
@@ -735,23 +729,25 @@ FilterPtr MultiRange::create(const folly::dynamic& obj) {
 }
 
 bool MultiRange::testingEquals(const Filter& other) const {
-  auto otherMultiRange = dynamic_cast<const MultiRange*>(&other);
-  auto res = otherMultiRange != nullptr && Filter::testingBaseEquals(other) &&
-
-      filters_.size() == otherMultiRange->filters_.size();
-
-  if (!res) {
-    return false;
-  }
+  if (const auto* otherMultiRange =
+          Filter::testingBaseEquals<MultiRange>(other)) {
+    auto res = filters_.size() == otherMultiRange->filters_.size();
 
-  for (size_t i = 0; i < filters_.size(); ++i) {
-    if (!filters_.at(i)->testingEquals(
-            *(otherMultiRange->filters_.at(i)->clone()))) {
+    if (!res) {
       return false;
     }
+
+    for (size_t i = 0; i < filters_.size(); ++i) {
+      if (!filters_.at(i)->testingEquals(
+              *(otherMultiRange->filters_.at(i)->clone()))) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
-  return true;
+  return false;
 }
 
 BigintValuesUsingBitmask::BigintValuesUsingBitmask(
@@ -781,13 +777,6 @@ BigintValuesUsingBitmask::BigintValuesUsingBitmask(
   }
 }
 
-bool BigintValuesUsingBitmask::testInt64(int64_t value) const {
-  if (value < min_ || value > max_) {
-    return false;
-  }
-  return bitmask_[value - min_];
-}
-
 std::vector<int64_t> BigintValuesUsingBitmask::values() const {
   std::vector<int64_t> values;
   for (int i = 0; i < bitmask_.size(); i++) {
@@ -864,98 +853,6 @@ BigintValuesUsingHashTable::BigintValuesUsingHashTable(
   std::sort(values_.begin(), values_.end());
 }
 
-bool BigintValuesUsingHashTable::testInt64(int64_t value) const {
-  if (containsEmptyMarker_ && value == kEmptyMarker) {
-    return true;
-  }
-  if (value < min_ || value > max_) {
-    return false;
-  }
-  uint32_t pos = (value * M) & sizeMask_;
-  for (auto i = pos; i <= pos + sizeMask_; i++) {
-    int32_t idx = i & sizeMask_;
-    int64_t l = hashTable_[idx];
-    if (l == kEmptyMarker) {
-      return false;
-    }
-    if (l == value) {
-      return true;
-    }
-  }
-  return false;
-}
-
-xsimd::batch_bool<int64_t> BigintValuesUsingHashTable::testValues(
-    xsimd::batch<int64_t> x) const {
-  auto outOfRange = (x < xsimd::broadcast<int64_t>(min_)) |
-      (x > xsimd::broadcast<int64_t>(max_));
-  if (simd::toBitMask(outOfRange) == simd::allSetBitMask<int64_t>()) {
-    return xsimd::batch_bool<int64_t>(false);
-  }
-  if (containsEmptyMarker_) {
-    return Filter::testValues(x);
-  }
-  auto allEmpty = xsimd::broadcast<int64_t>(kEmptyMarker);
-  // Temporarily casted to unsigned to suppress overflow error.
-  auto indices = simd::reinterpretBatch<int64_t>(
-      simd::reinterpretBatch<uint64_t>(x) * M & sizeMask_);
-  auto data =
-      simd::maskGather(allEmpty, ~outOfRange, hashTable_.data(), indices);
-  // The lanes with kEmptyMarker missed, the lanes matching x hit and the other
-  // lanes must check next positions.
-
-  auto result = x == data;
-  auto resultBits = simd::toBitMask(result);
-  auto missed = simd::toBitMask(data == allEmpty);
-  static_assert(decltype(result)::size <= 16);
-  uint16_t unresolved = simd::allSetBitMask<int64_t>() ^ (resultBits | missed);
-  if (!unresolved) {
-    return result;
-  }
-  constexpr int kAlign = xsimd::default_arch::alignment();
-  constexpr int kArraySize = xsimd::batch<int64_t>::size;
-  alignas(kAlign) int64_t indicesArray[kArraySize];
-  alignas(kAlign) int64_t valuesArray[kArraySize];
-  (indices + 1).store_aligned(indicesArray);
-  x.store_aligned(valuesArray);
-  while (unresolved) {
-    auto lane = bits::getAndClearLastSetBit(unresolved);
-    // Loop for each unresolved (not hit and
-    // not empty) until finding hit or empty.
-    int64_t index = indicesArray[lane];
-    int64_t value = valuesArray[lane];
-    auto allValue = xsimd::broadcast<int64_t>(value);
-    for (;;) {
-      auto line = xsimd::load_unaligned(hashTable_.data() + index);
-
-      if (simd::toBitMask(line == allValue)) {
-        resultBits |= 1 << lane;
-        break;
-      }
-      if (simd::toBitMask(line == allEmpty)) {
-        resultBits &= ~(1 << lane);
-        break;
-      }
-      index += line.size;
-      if (index > sizeMask_) {
-        index = 0;
-      }
-    }
-  }
-  return simd::fromBitMask<int64_t>(resultBits);
-}
-
-xsimd::batch_bool<int32_t> BigintValuesUsingHashTable::testValues(
-    xsimd::batch<int32_t> x) const {
-  // Calls 4x64 twice since the hash table is 64 bits wide in any
-  // case. A 32-bit hash table would be possible but all the use
-  // cases seen are in the 64 bit range.
-  auto first = simd::toBitMask(testValues(simd::getHalf<int64_t, 0>(x)));
-  auto second = simd::toBitMask(testValues(simd::getHalf<int64_t, 1>(x)));
-  return simd::fromBitMask<int32_t>(
-      first | (second << xsimd::batch<int64_t>::size));
-}
-
 bool BigintValuesUsingHashTable::testInt64Range(
     int64_t min,
     int64_t max,
@@ -980,7 +877,7 @@ bool BigintValuesUsingHashTable::testInt64Range(
 }
 
 folly::dynamic HugeintValuesUsingHashTable::serialize() const {
-  auto obj = Filter::serializeBase("HugeintValuesUsingHashTable");
+  auto obj = Filter::serializeBase();
   obj["min_lower"] = HugeInt::lower(min_);
   obj["min_upper"] = HugeInt::upper(min_);
   obj["max_lower"] = HugeInt::lower(max_);
@@ -998,7 +895,8 @@ folly::dynamic HugeintValuesUsingHashTable::serialize() const {
   return obj;
 }
 
-FilterPtr HugeintValuesUsingHashTable::create(const folly::dynamic& obj) {
+std::unique_ptr<Filter> HugeintValuesUsingHashTable::create(
+    const folly::dynamic& obj) {
   auto nullAllowed = deserializeNullAllowed(obj);
   auto min = HugeInt::build(obj["min_upper"].asInt(), obj["min_lower"].asInt());
   auto max = HugeInt::build(obj["max_upper"].asInt(), obj["max_lower"].asInt());
@@ -1033,22 +931,24 @@ bool HugeintValuesUsingHashTable::testInt128(const int128_t& value) const {
 }
 
 bool HugeintValuesUsingHashTable::testingEquals(const Filter& other) const {
-  auto otherHugeintValues =
-      dynamic_cast<const HugeintValuesUsingHashTable*>(&other);
-  bool res = otherHugeintValues != nullptr &&
-      Filter::testingBaseEquals(other) && min_ == otherHugeintValues->min_ &&
-      max_ == otherHugeintValues->max_ &&
-      values_.size() == otherHugeintValues->values_.size();
-  if (!res) {
-    return false;
-  }
-
-  for (auto value : values_) {
-    if (!otherHugeintValues->values_.contains(value)) {
+  if (const auto* otherHugeintValues =
+          Filter::testingBaseEquals<HugeintValuesUsingHashTable>(other)) {
+    bool res = min_ == otherHugeintValues->min_ &&
+        max_ == otherHugeintValues->max_ &&
+        values_.size() == otherHugeintValues->values_.size();
+    if (!res) {
       return false;
     }
+
+    for (auto value : values_) {
+      if (!otherHugeintValues->values_.contains(value)) {
+        return false;
+      }
+    }
+    return true;
   }
-  return true;
+
+  return false;
 }
 
 NegatedBigintValuesUsingBitmask::NegatedBigintValuesUsingBitmask(
@@ -1129,7 +1029,7 @@ bool NegatedBigintValuesUsingHashTable::testInt64Range(
   // of things between min and max
   // if distance is any less, then we are missing an element => something
   // in the range is accepted
-  return (std::distance(lo, hi) != max - min);
+  return std::distance(lo, hi) != static_cast<int128_t>(max) - min;
 }
 
 namespace {
@@ -1245,6 +1145,20 @@ BigintMultiRange::BigintMultiRange(
   }
 }
 
+std::string BigintMultiRange::toString() const {
+  std::ostringstream out;
+  out << "BigintMultiRange: [";
+  for (auto i = 0; i < ranges_.size(); i++) {
+    if (i > 0) {
+      out << ", ";
+    }
+    out << fmt::format("[{}, {}]", ranges_[i]->lower(), ranges_[i]->upper());
+  }
+
+  out << "] " << (nullAllowed_ ? "with nulls" : "no nulls");
+  return out.str();
+}
+
 namespace {
 int compareRanges(const char* lhs, size_t length, const std::string& rhs) {
   int size = std::min(length, rhs.length());
@@ -1357,24 +1271,26 @@ bool NegatedBytesRange::testBytesRange(
 std::unique_ptr<Filter> NegatedBytesRange::toMultiRange() const {
   std::vector<std::unique_ptr<Filter>> accepted;
   if (!isLowerUnbounded()) {
-    accepted.push_back(std::make_unique<BytesRange>(
-        "",
-        true,
-        false,
-        lower(),
-        false,
-        !testBytes(lower().data(), lower().length()),
-        false));
+    accepted.push_back(
+        std::make_unique<BytesRange>(
+            "",
+            true,
+            false,
+            lower(),
+            false,
+            !testBytes(lower().data(), lower().length()),
+            false));
   }
   if (!isUpperUnbounded()) {
-    accepted.push_back(std::make_unique<BytesRange>(
-        upper(),
-        false,
-        !testBytes(upper().data(), upper().length()),
-        "",
-        true,
-        false,
-        false));
+    accepted.push_back(
+        std::make_unique<BytesRange>(
+            upper(),
+            false,
+            !testBytes(upper().data(), upper().length()),
+            "",
+            true,
+            false,
+            false));
   }
 
   if (accepted.size() == 0) {
@@ -1489,6 +1405,15 @@ bool MultiRange::testFloat(float value) const {
   return false;
 }
 
+bool MultiRange::testInt128(const int128_t& value) const {
+  for (const auto& filter : filters_) {
+    if (filter->testInt128(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 bool MultiRange::testBytes(const char* value, int32_t length) const {
   for (const auto& filter : filters_) {
     if (filter->testBytes(value, length)) {
@@ -1565,9 +1490,38 @@ std::unique_ptr<Filter> MultiRange::mergeWith(const Filter* other) const {
     case FilterKind::kIsNotNull:
       return this->clone(/*nullAllowed=*/false);
     case FilterKind::kDoubleRange:
-    case FilterKind::kFloatRange:
-      // TODO: Implement
-      VELOX_UNREACHABLE();
+    case FilterKind::kFloatRange: {
+      bool bothNullAllowed = nullAllowed_ && other->testNull();
+      std::vector<std::unique_ptr<Filter>> merged;
+
+      for (auto const& filter : this->filters()) {
+        auto innerMerged = filter->mergeWith(other);
+        switch (innerMerged->kind()) {
+          case FilterKind::kAlwaysFalse:
+          case FilterKind::kIsNull:
+            continue;
+          case FilterKind::kMultiRange: {
+            auto innerMergedMulti =
+                static_cast<const MultiRange*>(innerMerged.get());
+            merged.reserve(merged.size() + innerMergedMulti->filters().size());
+            for (int i = 0; i < innerMergedMulti->filters().size(); ++i) {
+              merged.emplace_back(innerMergedMulti->filters()[i]->clone());
+            }
+            break;
+          }
+          default:
+            merged.emplace_back(innerMerged.release());
+        }
+      }
+
+      if (merged.empty()) {
+        return nullOrFalse(bothNullAllowed);
+      } else if (merged.size() == 1) {
+        return merged.front()->clone(bothNullAllowed);
+      } else {
+        return std::make_unique<MultiRange>(std::move(merged), bothNullAllowed);
+      }
+    }
     case FilterKind::kBytesValues:
     case FilterKind::kNegatedBytesValues:
     case FilterKind::kBytesRange:
@@ -1622,8 +1576,9 @@ std::unique_ptr<Filter> MultiRange::mergeWith(const Filter* other) const {
       }
 
       if (!byteValues.empty()) {
-        merged.emplace_back(std::make_unique<BytesValues>(
-            std::move(byteValues), bothNullAllowed));
+        merged.emplace_back(
+            std::make_unique<BytesValues>(
+                std::move(byteValues), bothNullAllowed));
       }
 
       if (merged.empty()) {
@@ -1787,16 +1742,19 @@ std::unique_ptr<Filter> combineNegatedRangeOnIntRanges(
   for (int i = 0; i < ranges.size(); ++i) {
     if (negatedUpper < ranges[i]->lower() ||
         ranges[i]->upper() < negatedLower) {
-      outRanges.emplace_back(std::make_unique<BigintRange>(
-          ranges[i]->lower(), ranges[i]->upper(), false));
+      outRanges.emplace_back(
+          std::make_unique<BigintRange>(
+              ranges[i]->lower(), ranges[i]->upper(), false));
     } else {
       if (ranges[i]->lower() < negatedLower) {
-        outRanges.emplace_back(std::make_unique<BigintRange>(
-            ranges[i]->lower(), negatedLower - 1, false));
+        outRanges.emplace_back(
+            std::make_unique<BigintRange>(
+                ranges[i]->lower(), negatedLower - 1, false));
       }
       if (negatedUpper < ranges[i]->upper()) {
-        outRanges.emplace_back(std::make_unique<BigintRange>(
-            negatedUpper + 1, ranges[i]->upper(), false));
+        outRanges.emplace_back(
+            std::make_unique<BigintRange>(
+                negatedUpper + 1, ranges[i]->upper(), false));
       }
     }
   }
@@ -1812,8 +1770,9 @@ std::vector<std::unique_ptr<BigintRange>> negatedValuesToRanges(
   std::vector<std::unique_ptr<BigintRange>> res;
   res.reserve(values.size() + 1);
   if (*back > std::numeric_limits<int64_t>::min()) {
-    res.emplace_back(std::make_unique<BigintRange>(
-        std::numeric_limits<int64_t>::min(), *back - 1, false));
+    res.emplace_back(
+        std::make_unique<BigintRange>(
+            std::numeric_limits<int64_t>::min(), *back - 1, false));
   }
   while (front != values.end()) {
     if (*back + 1 <= *front - 1) {
@@ -1824,8 +1783,9 @@ std::vector<std::unique_ptr<BigintRange>> negatedValuesToRanges(
     ++back;
   }
   if (*back < std::numeric_limits<int64_t>::max()) {
-    res.emplace_back(std::make_unique<BigintRange>(
-        *back + 1, std::numeric_limits<int64_t>::max(), false));
+    res.emplace_back(
+        std::make_unique<BigintRange>(
+            *back + 1, std::numeric_limits<int64_t>::max(), false));
   }
   return res;
 }
@@ -1856,6 +1816,7 @@ std::unique_ptr<Filter> BigintRange::mergeWith(const Filter* other) const {
     case FilterKind::kNegatedBigintRange:
     case FilterKind::kBigintValuesUsingBitmask:
     case FilterKind::kBigintValuesUsingHashTable:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
     case FilterKind::kBigintMultiRange: {
       auto otherMultiRange = dynamic_cast<const BigintMultiRange*>(other);
@@ -1937,8 +1898,9 @@ std::unique_ptr<Filter> NegatedBigintRange::mergeWith(
       bool bothNullAllowed = nullAllowed_ && other->testNull();
       auto otherRange = static_cast<const BigintRange*>(other);
       std::vector<std::unique_ptr<common::BigintRange>> rangeList;
-      rangeList.emplace_back(std::make_unique<BigintRange>(
-          otherRange->lower(), otherRange->upper(), false));
+      rangeList.emplace_back(
+          std::make_unique<BigintRange>(
+              otherRange->lower(), otherRange->upper(), false));
       return combineNegatedRangeOnIntRanges(
           this->lower(), this->upper(), rangeList, bothNullAllowed);
     }
@@ -1956,17 +1918,20 @@ std::unique_ptr<Filter> NegatedBigintRange::mergeWith(
         int64_t bigLower = otherNegatedRange->lower();
         int64_t bigUpper = otherNegatedRange->upper();
         if (smallLower > std::numeric_limits<int64_t>::min()) {
-          outRanges.emplace_back(std::make_unique<common::BigintRange>(
-              std::numeric_limits<int64_t>::min(), smallLower - 1, false));
+          outRanges.emplace_back(
+              std::make_unique<common::BigintRange>(
+                  std::numeric_limits<int64_t>::min(), smallLower - 1, false));
         }
         if (smallUpper < std::numeric_limits<int64_t>::max() &&
             bigLower > std::numeric_limits<int64_t>::min()) {
-          outRanges.emplace_back(std::make_unique<common::BigintRange>(
-              smallUpper + 1, bigLower - 1, false));
+          outRanges.emplace_back(
+              std::make_unique<common::BigintRange>(
+                  smallUpper + 1, bigLower - 1, false));
         }
         if (bigUpper < std::numeric_limits<int64_t>::max()) {
-          outRanges.emplace_back(std::make_unique<common::BigintRange>(
-              bigUpper + 1, std::numeric_limits<int64_t>::max(), false));
+          outRanges.emplace_back(
+              std::make_unique<common::BigintRange>(
+                  bigUpper + 1, std::numeric_limits<int64_t>::max(), false));
         }
         return combineBigintRanges(std::move(outRanges), bothNullAllowed);
       }
@@ -1986,6 +1951,7 @@ std::unique_ptr<Filter> NegatedBigintRange::mergeWith(
     }
     case FilterKind::kBigintValuesUsingHashTable:
     case FilterKind::kBigintValuesUsingBitmask:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
     case FilterKind::kNegatedBigintValuesUsingHashTable:
     case FilterKind::kNegatedBigintValuesUsingBitmask: {
@@ -2041,6 +2007,7 @@ std::unique_ptr<Filter> BigintValuesUsingHashTable::mergeWith(
       return mergeWith(min, max, other);
     }
     case FilterKind::kBigintValuesUsingBitmask:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
     case FilterKind::kBigintMultiRange: {
       auto otherMultiRange = dynamic_cast<const BigintMultiRange*>(other);
@@ -2114,6 +2081,7 @@ std::unique_ptr<Filter> BigintValuesUsingBitmask::mergeWith(
     case FilterKind::kAlwaysTrue:
     case FilterKind::kAlwaysFalse:
     case FilterKind::kIsNull:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
     case FilterKind::kIsNotNull:
       return std::make_unique<BigintValuesUsingBitmask>(*this, false);
@@ -2203,9 +2171,9 @@ std::unique_ptr<Filter> NegatedBigintValuesUsingHashTable::mergeWith(
     case FilterKind::kBigintValuesUsingHashTable:
     case FilterKind::kBigintValuesUsingBitmask:
     case FilterKind::kBigintRange:
-    case FilterKind::kBigintMultiRange: {
+    case FilterKind::kBigintMultiRange:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
-    }
     case FilterKind::kNegatedBigintValuesUsingHashTable: {
       auto otherNegated =
           static_cast<const NegatedBigintValuesUsingHashTable*>(other);
@@ -2243,9 +2211,9 @@ std::unique_ptr<Filter> NegatedBigintValuesUsingBitmask::mergeWith(
     case FilterKind::kBigintValuesUsingBitmask:
     case FilterKind::kBigintRange:
     case FilterKind::kNegatedBigintRange:
-    case FilterKind::kBigintMultiRange: {
+    case FilterKind::kBigintMultiRange:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
-    }
     case FilterKind::kNegatedBigintValuesUsingHashTable: {
       auto otherHashTable =
           dynamic_cast<const NegatedBigintValuesUsingHashTable*>(other);
@@ -2283,9 +2251,9 @@ std::unique_ptr<Filter> BigintMultiRange::mergeWith(const Filter* other) const {
     case FilterKind::kBigintRange:
     case FilterKind::kNegatedBigintRange:
     case FilterKind::kBigintValuesUsingBitmask:
-    case FilterKind::kBigintValuesUsingHashTable: {
+    case FilterKind::kBigintValuesUsingHashTable:
+    case FilterKind::kBigintValuesUsingBloomFilter:
       return other->mergeWith(this);
-    }
     case FilterKind::kBigintMultiRange: {
       std::vector<std::unique_ptr<BigintRange>> newRanges;
       for (const auto& range : ranges_) {
@@ -2339,6 +2307,70 @@ std::unique_ptr<Filter> BigintMultiRange::mergeWith(const Filter* other) const {
   }
 }
 
+std::unique_ptr<Filter> BigintValuesUsingBloomFilter::mergeWith(
+    const Filter* other) const {
+  switch (other->kind()) {
+    case FilterKind::kAlwaysFalse:
+    case FilterKind::kAlwaysTrue:
+    case FilterKind::kIsNull:
+      return other->mergeWith(this);
+    case FilterKind::kIsNotNull:
+      return clone(false);
+    case FilterKind::kBigintRange: {
+      auto* filter = other->as<BigintRange>();
+      // If the hash table or bitmask generated is not small enough to fit in
+      // cache, we would rather not merging it.
+      int64_t range;
+      if (__builtin_sub_overflow(filter->upper(), filter->lower(), &range) ||
+          range > 100'000) {
+        return other->clone();
+      }
+      std::vector<int64_t> values;
+      values.reserve(range + 1);
+      for (int64_t i = filter->lower(); i <= filter->upper(); ++i) {
+        if (testInt64(i)) {
+          values.push_back(i);
+        }
+      }
+      return createBigintValues(values, nullAllowed_ && other->testNull());
+    }
+    case FilterKind::kBigintValuesUsingHashTable: {
+      auto* filter = other->as<BigintValuesUsingHashTable>();
+      auto values = filter->values();
+      int64_t size = 0;
+      for (int64_t i = 0; i < values.size(); ++i) {
+        if (testInt64(values[i])) {
+          values[size++] = values[i];
+        }
+      }
+      values.resize(size);
+      return createBigintValues(values, nullAllowed_ && other->testNull());
+    }
+    case FilterKind::kBigintValuesUsingBitmask: {
+      auto* filter = other->as<BigintValuesUsingBitmask>();
+      std::vector<int64_t> values;
+      values.reserve(filter->max() - filter->min() + 1);
+      for (int64_t i = filter->min(); i <= filter->max(); ++i) {
+        if (filter->testInt64(i) && testInt64(i)) {
+          values.push_back(i);
+        }
+      }
+      return createBigintValues(values, nullAllowed_ && other->testNull());
+    }
+    case FilterKind::kNegatedBigintRange:
+    case FilterKind::kNegatedBigintValuesUsingHashTable:
+    case FilterKind::kNegatedBigintValuesUsingBitmask:
+    case FilterKind::kBigintMultiRange:
+    case FilterKind::kBigintValuesUsingBloomFilter:
+      // Bloom filter allows false positive so dropping it will not affect
+      // correctness.  We can do so if we think merging will not improve
+      // performance.
+      return other->clone();
+    default:
+      VELOX_FAIL("Cannot merge {} with {}", kindName(), other->kindName());
+  }
+}
+
 namespace {
 // compareResult = left < right for upper, right < left for lower
 bool mergeExclusive(int compareResult, bool left, bool right) {
@@ -2631,32 +2663,36 @@ std::unique_ptr<Filter> NegatedBytesValues::mergeWith(
       ranges.reserve(rejectedValues.size() + 1);
       auto back = rejectedValues.begin();
       auto front = ++(rejectedValues.begin());
-      ranges.emplace_back(std::make_unique<BytesRange>(
-          bytesRangeOther->lower(),
-          bytesRangeOther->lowerUnbounded(),
-          loExclusive,
-          *back,
-          false, // not unbounded
-          true, // exclusive
-          false));
+      ranges.emplace_back(
+          std::make_unique<BytesRange>(
+              bytesRangeOther->lower(),
+              bytesRangeOther->lowerUnbounded(),
+              loExclusive,
+              *back,
+              false, // not unbounded
+              true, // exclusive
+              false));
       while (front != rejectedValues.end()) {
-        ranges.emplace_back(std::make_unique<BytesRange>(
-            *back, false, true, *front, false, true, false));
+        ranges.emplace_back(
+            std::make_unique<BytesRange>(
+                *back, false, true, *front, false, true, false));
         ++front;
         ++back;
       }
-      ranges.emplace_back(std::make_unique<BytesRange>(
-          *back,
-          false,
-          true,
-          bytesRangeOther->upper(),
-          bytesRangeOther->upperUnbounded(),
-          hiExclusive,
-          false));
+      ranges.emplace_back(
+          std::make_unique<BytesRange>(
+              *back,
+              false,
+              true,
+              bytesRangeOther->upper(),
+              bytesRangeOther->upperUnbounded(),
+              hiExclusive,
+              false));
       return std::make_unique<MultiRange>(std::move(ranges), bothNullAllowed);
     }
     default:
       VELOX_UNREACHABLE();
   }
 }
+
 } // namespace facebook::velox::common
diff --git a/velox/type/Filter.h b/velox/type/Filter.h
index 3e2088ef425e..1555e8481196 100644
--- a/velox/type/Filter.h
+++ b/velox/type/Filter.h
@@ -15,18 +15,13 @@
  */
 #pragma once
 
-#include <algorithm>
-#include <cmath>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <vector>
-
 #include <folly/Range.h>
 #include <folly/container/F14Set.h>
-
+#include <xsimd/xsimd.hpp>
+#include "velox/common/Enums.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/SimdUtil.h"
+#include "velox/common/base/SplitBlockBloomFilter.h"
 #include "velox/common/serialization/Serializable.h"
 #include "velox/type/StringView.h"
 #include "velox/type/Subfield.h"
@@ -57,17 +52,19 @@ enum class FilterKind {
   kHugeintRange,
   kTimestampRange,
   kHugeintValuesUsingHashTable,
+  kBigintValuesUsingBloomFilter,
 };
 
+VELOX_DECLARE_ENUM_NAME(FilterKind);
+
 class Filter;
-using FilterPtr = std::unique_ptr<Filter>;
+using FilterPtr = std::shared_ptr<Filter>;
 
-using SubfieldFilters = std::unordered_map<Subfield, std::unique_ptr<Filter>>;
+using SubfieldFilters = std::unordered_map<Subfield, FilterPtr>;
 
-/**
- * A simple filter (e.g. comparison with literal) that can be applied
- * efficiently while extracting values from an ORC stream.
- */
+/// A simple filter (e.g. comparison with literal) that can be applied
+/// efficiently while extracting values from an ORC, DWRF, Parquet, or Nimble
+/// stream.
 class Filter : public velox::ISerializable {
  protected:
   Filter(bool _deterministic, bool _nullAllowed, FilterKind _kind)
@@ -80,74 +77,85 @@ class Filter : public velox::ISerializable {
 
   static void registerSerDe();
 
-  // Templates parametrized on filter need to know determinism at compile
-  // time. If this is false, deterministic() will be consulted at
-  // runtime.
+  /// Templates parametrized on filter need to know determinism at compile
+  /// time. If this is false, deterministic() will be consulted at
+  /// runtime.
   static constexpr bool deterministic = true;
 
   FilterKind kind() const {
     return kind_;
   }
 
+  std::string_view kindName() const {
+    return FilterKindName::toName(kind_);
+  }
+
+  bool is(FilterKind kind) const {
+    return kind_ == kind;
+  }
+
+  /// @pre The caller must ensure this filter's kind matches TFilter.
+  template <typename TFilter>
+  TFilter* as() {
+    static_assert(std::is_base_of_v<Filter, TFilter>);
+    return static_cast<TFilter*>(this);
+  }
+
+  /// @pre The caller must ensure this filter's kind matches TFilter.
+  template <typename TFilter>
+  const TFilter* as() const {
+    static_assert(std::is_base_of_v<Filter, TFilter>);
+    return static_cast<const TFilter*>(this);
+  }
+
+  bool nullAllowed() const {
+    return nullAllowed_;
+  }
+
   /// Return a copy of this filter. If nullAllowed is set, modified the
   /// nullAllowed flag in the copy to match.
   virtual std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const = 0;
 
-  /**
-   * A filter becomes non-deterministic when applies to nested column,
-   * e.g. a[1] > 10 is non-deterministic because > 10 filter applies only to
-   * some positions, e.g. first entry in a set of entries that correspond to a
-   * single top-level position.
-   */
-  virtual bool isDeterministic() const {
+  /// A filter becomes non-deterministic when applied to a nested column,
+  /// e.g. a[1] > 10 is non-deterministic because > 10 filter applies only to
+  /// some positions, e.g. first entry in a set of entries that correspond to a
+  /// single top-level position.
+  bool isDeterministic() const {
     return deterministic_;
   }
 
-  /**
-   * When a filter applied to a nested column fails, the whole top-level
-   * position should fail. To enable this functionality, the filter keeps track
-   * of the boundaries of top-level positions and allows the caller to find out
-   * where the current top-level position started and how far it continues.
-   * @return number of positions from the start of the current top-level
-   * position up to the current position (excluding current position)
-   */
-  virtual int getPrecedingPositionsToFail() const {
+  /// When a filter applied to a nested column fails, the whole top-level
+  /// position should fail. To enable this functionality, the filter keeps track
+  /// of the boundaries of top-level positions and allows the caller to find out
+  /// where the current top-level position started and how far it continues.
+  /// @return number of positions from the start of the current top-level
+  /// position up to the current position (excluding current position)
+  int getPrecedingPositionsToFail() const {
     return 0;
   }
 
-  /**
-   * Only used in test code.
-   * @return Whether an object is the same as itself.
-   */
+  /// Only used in test code.
+  /// @return Whether an object is the same as itself.
   virtual bool testingEquals(const Filter& other) const = 0;
 
-  bool testingBaseEquals(const Filter& other) const {
-    return deterministic_ == other.isDeterministic() &&
-        nullAllowed_ == other.nullAllowed_ && kind_ == other.kind();
-  }
-
-  /**
-   * @return number of positions remaining until the end of the current
-   * top-level position
-   */
-  virtual int getSucceedingPositionsToFail() const {
+  /// @return number of positions remaining until the end of the current
+  /// top-level position
+  int getSucceedingPositionsToFail() const {
     return 0;
   }
 
-  virtual bool testNull() const {
+  bool testNull() const {
     return nullAllowed_;
   }
 
-  /**
-   * Used to apply is [not] null filters to complex types, e.g.
-   * a[1] is null AND a[3] is not null, where a is an array(array(T)).
-   *
-   * In these case, the exact values are not known, but it is known whether they
-   * are null or not. Furthermore, for some positions only nulls are allowed
-   * (a[1] is null), for others only non-nulls (a[3] is not null), and for the
-   * rest both are allowed (a[2] and a[N], where N > 3).
-   */
+  /// Used to apply is [not] null filters to complex types, e.g.
+  /// a[1] is null AND a[3] is not null, where a is an array(array(T)).
+  ///
+  /// In these case, the exact values are not known, but it is known whether
+  /// they are null or not. Furthermore, for some positions only nulls are
+  /// allowed (a[1] is null), for others only non-nulls (a[3] is not null), and
+  /// for the rest both are allowed (a[2] and a[N], where N > 3).
   virtual bool testNonNull() const {
     VELOX_UNSUPPORTED("{}: testNonNull() is not supported.", toString());
   }
@@ -196,39 +204,41 @@ class Filter : public velox::ISerializable {
     VELOX_UNSUPPORTED("{}: testBytes() is not supported.", toString());
   }
 
+  virtual bool testStringView(const StringView& view) const {
+    return testBytes(view.data(), view.size());
+  }
+
   virtual bool testTimestamp(const Timestamp& /* unused */) const {
     VELOX_UNSUPPORTED("{}: testTimestamp() is not supported.", toString());
   }
 
-  // Returns true if it is useful to call testLength before other
-  // tests. This should be true for string IN and equals because it is
-  // possible to fail these based on the length alone. This would
-  // typically be false of string ranges because these cannot be
-  // generally decided without looking at the string itself.
+  /// Returns true if it is useful to call testLength before other
+  /// tests. This should be true for string IN and equals because it is
+  /// possible to fail these based on the length alone. This would
+  /// typically be false of string ranges because these cannot be
+  /// generally decided without looking at the string itself.
   virtual bool hasTestLength() const {
     return false;
   }
 
-  /**
-   * Filters like string equality and IN, as well as conditions on cardinality
-   * of lists and maps can be at least partly decided by looking at lengths
-   * alone. If this is false, then no further checks are needed. If true,
-   * eventual filters on the data itself need to be evaluated.
-   */
+  /// Filters like string equality and IN, as well as conditions on cardinality
+  /// of lists and maps can be at least partly decided by looking at lengths
+  /// alone. If this is false, then no further checks are needed. If true,
+  /// eventual filters on the data itself need to be evaluated.
   virtual bool testLength(int32_t /* unused */) const {
     VELOX_UNSUPPORTED("{}: testLength() is not supported.", toString());
   }
 
-  // Tests multiple lengths at a time.
+  /// Tests multiple lengths at a time.
   virtual xsimd::batch_bool<int32_t> testLengths(
       xsimd::batch<int32_t> lengths) const {
     return genericTestValues(
         lengths, [this](int32_t x) { return testLength(x); });
   }
 
-  // Returns true if at least one value in the specified range can pass the
-  // filter. The range is defined as all values between min and max inclusive
-  // plus null if hasNull is true.
+  /// Returns true if at least one value in the specified range can pass the
+  /// filter. The range is defined as all values between min and max inclusive
+  /// plus null if hasNull is true.
   virtual bool
   testInt64Range(int64_t /*min*/, int64_t /*max*/, bool /*hasNull*/) const {
     VELOX_UNSUPPORTED("{}: testInt64Range() is not supported.", toString());
@@ -241,9 +251,9 @@ class Filter : public velox::ISerializable {
     VELOX_UNSUPPORTED("{}: testInt128Range() is not supported.", toString());
   }
 
-  // Returns true if at least one value in the specified range can pass the
-  // filter. The range is defined as all values between min and max inclusive
-  // plus null if hasNull is true.
+  /// Returns true if at least one value in the specified range can pass the
+  /// filter. The range is defined as all values between min and max inclusive
+  /// plus null if hasNull is true.
   virtual bool testDoubleRange(double /*min*/, double /*max*/, bool /*hasNull*/)
       const {
     VELOX_UNSUPPORTED("{}: testDoubleRange() is not supported.", toString());
@@ -263,26 +273,41 @@ class Filter : public velox::ISerializable {
     VELOX_UNSUPPORTED("{}: testTimestampRange() is not supported.", toString());
   }
 
-  // Combines this filter with another filter using 'AND' logic.
+  /// Combines this filter with another filter using 'AND' logic.
   virtual std::unique_ptr<Filter> mergeWith(const Filter* /*other*/) const {
     VELOX_UNSUPPORTED("{}: mergeWith() is not supported.", toString());
   }
 
+  static void merge(
+      const std::shared_ptr<Filter>& newFilter,
+      std::shared_ptr<Filter>& filter) {
+    if (filter) {
+      filter = filter->mergeWith(newFilter.get());
+    } else {
+      filter = newFilter;
+    }
+  }
+
   virtual std::string toString() const;
 
  protected:
-  folly::dynamic serializeBase(std::string_view name) const;
+  template <typename TFilter>
+  const TFilter* testingBaseEquals(const Filter& other) const {
+    if (deterministic_ == other.isDeterministic() &&
+        nullAllowed_ == other.nullAllowed_ && kind_ == other.kind()) {
+      return other.as<TFilter>();
+    }
 
- protected:
-  const bool nullAllowed_;
+    return nullptr;
+  }
 
- private:
-  const bool deterministic_;
-  const FilterKind kind_;
+  folly::dynamic serializeBase() const;
 
+ protected:
   template <typename T, typename F>
-  xsimd::batch_bool<T> genericTestValues(xsimd::batch<T> batch, F&& testValue)
-      const {
+  static xsimd::batch_bool<T> genericTestValues(
+      xsimd::batch<T> batch,
+      F&& testValue) {
     constexpr int N = decltype(batch)::size;
     constexpr int kAlign = decltype(batch)::arch_type::alignment();
     alignas(kAlign) T data[N];
@@ -293,6 +318,12 @@ class Filter : public velox::ISerializable {
     }
     return xsimd::broadcast<T>(0) != xsimd::load_aligned(res);
   }
+
+  const bool nullAllowed_;
+
+ private:
+  const bool deterministic_;
+  const FilterKind kind_;
 };
 
 /// TODO Check if this filter is needed. This should not be passed down.
@@ -302,10 +333,10 @@ class AlwaysFalse final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& /*obj*/);
+  static std::unique_ptr<Filter> create(const folly::dynamic& /*obj*/);
 
   bool testingEquals(const Filter& other) const final {
-    return Filter::testingBaseEquals(other);
+    return Filter::testingBaseEquals<AlwaysFalse>(other);
   }
 
   std::unique_ptr<Filter> clone(
@@ -317,10 +348,6 @@ class AlwaysFalse final : public Filter {
     return false;
   }
 
-  bool testNull() const final {
-    return false;
-  }
-
   bool testInt64(int64_t /* unused */) const final {
     return false;
   }
@@ -398,14 +425,10 @@ class AlwaysTrue final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& /*obj*/);
+  static std::unique_ptr<Filter> create(const folly::dynamic& /*obj*/);
 
   bool testingEquals(const Filter& other) const final {
-    return Filter::testingBaseEquals(other);
-  }
-
-  bool testNull() const final {
-    return true;
+    return Filter::testingBaseEquals<AlwaysTrue>(other);
   }
 
   bool testNonNull() const final {
@@ -484,10 +507,10 @@ class IsNull final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& /*obj*/);
+  static std::unique_ptr<Filter> create(const folly::dynamic& /*obj*/);
 
   bool testingEquals(const Filter& other) const final {
-    return Filter::testingBaseEquals(other);
+    return Filter::testingBaseEquals<IsNull>(other);
   }
 
   std::unique_ptr<Filter> clone(
@@ -572,10 +595,10 @@ class IsNotNull final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& /*obj*/);
+  static std::unique_ptr<Filter> create(const folly::dynamic& /*obj*/);
 
   bool testingEquals(const Filter& other) const final {
-    return Filter::testingBaseEquals(other);
+    return Filter::testingBaseEquals<IsNotNull>(other);
   }
 
   std::unique_ptr<Filter> clone(
@@ -665,7 +688,7 @@ class BoolValue final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   bool testingEquals(const Filter& other) const final;
 
@@ -731,7 +754,7 @@ class BigintRange final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -842,7 +865,7 @@ class NegatedBigintRange final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -895,6 +918,10 @@ class NegatedBigintRange final : public Filter {
 
   bool testingEquals(const Filter& other) const final;
 
+  const BigintRange* getNonNegated() const {
+    return nonNegated_.get();
+  }
+
  private:
   std::unique_ptr<BigintRange> nonNegated_;
 };
@@ -911,7 +938,7 @@ class HugeintRange final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -987,7 +1014,7 @@ class BigintValuesUsingHashTable final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -999,12 +1026,101 @@ class BigintValuesUsingHashTable final : public Filter {
     }
   }
 
-  bool testInt64(int64_t value) const final;
-  xsimd::batch_bool<int64_t> testValues(xsimd::batch<int64_t>) const final;
-  xsimd::batch_bool<int32_t> testValues(xsimd::batch<int32_t>) const final;
+  bool testInt64(int64_t value) const final {
+    if (containsEmptyMarker_ && value == kEmptyMarker) {
+      return true;
+    }
+    if (value < min_ || value > max_) {
+      return false;
+    }
+    uint32_t pos = (value * M) & sizeMask_;
+    for (auto i = pos; i <= pos + sizeMask_; i++) {
+      int32_t idx = i & sizeMask_;
+      int64_t l = hashTable_[idx];
+      if (l == kEmptyMarker) {
+        return false;
+      }
+      if (l == value) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  xsimd::batch_bool<int64_t> testValues(xsimd::batch<int64_t> x) const final {
+    auto outOfRange = (x < xsimd::broadcast<int64_t>(min_)) |
+        (x > xsimd::broadcast<int64_t>(max_));
+    if (simd::toBitMask(outOfRange) == simd::allSetBitMask<int64_t>()) {
+      return xsimd::batch_bool<int64_t>(false);
+    }
+    if (containsEmptyMarker_) {
+      return Filter::testValues(x);
+    }
+    auto allEmpty = xsimd::broadcast<int64_t>(kEmptyMarker);
+    // Temporarily casted to unsigned to suppress overflow error.
+    auto indices = simd::reinterpretBatch<int64_t>(
+        simd::reinterpretBatch<uint64_t>(x) * M & sizeMask_);
+    auto data =
+        simd::maskGather(allEmpty, ~outOfRange, hashTable_.data(), indices);
+    // The lanes with kEmptyMarker missed, the lanes matching x hit and the
+    // other lanes must check next positions.
+
+    auto result = x == data;
+    auto resultBits = simd::toBitMask(result);
+    auto missed = simd::toBitMask(data == allEmpty);
+    static_assert(decltype(result)::size <= 16);
+    uint16_t unresolved =
+        simd::allSetBitMask<int64_t>() ^ (resultBits | missed);
+    if (!unresolved) {
+      return result;
+    }
+    constexpr int kAlign = xsimd::default_arch::alignment();
+    constexpr int kArraySize = xsimd::batch<int64_t>::size;
+    alignas(kAlign) int64_t indicesArray[kArraySize];
+    alignas(kAlign) int64_t valuesArray[kArraySize];
+    (indices + 1).store_aligned(indicesArray);
+    x.store_aligned(valuesArray);
+    while (unresolved) {
+      auto lane = bits::getAndClearLastSetBit(unresolved);
+      // Loop for each unresolved (not hit and
+      // not empty) until finding hit or empty.
+      int64_t index = indicesArray[lane];
+      int64_t value = valuesArray[lane];
+      auto allValue = xsimd::broadcast<int64_t>(value);
+      for (;;) {
+        auto line = xsimd::load_unaligned(hashTable_.data() + index);
+
+        if (simd::toBitMask(line == allValue)) {
+          resultBits |= 1 << lane;
+          break;
+        }
+        if (simd::toBitMask(line == allEmpty)) {
+          resultBits &= ~(1 << lane);
+          break;
+        }
+        index += line.size;
+        if (index > sizeMask_) {
+          index = 0;
+        }
+      }
+    }
+    return simd::fromBitMask<int64_t>(resultBits);
+  }
+
+  xsimd::batch_bool<int32_t> testValues(xsimd::batch<int32_t> x) const final {
+    // Calls 4x64 twice since the hash table is 64 bits wide in any
+    // case. A 32-bit hash table would be possible but all the use
+    // cases seen are in the 64 bit range.
+    auto first = simd::toBitMask(testValues(simd::getHalf<int64_t, 0>(x)));
+    auto second = simd::toBitMask(testValues(simd::getHalf<int64_t, 1>(x)));
+    return simd::fromBitMask<int32_t>(
+        first | (second << xsimd::batch<int64_t>::size));
+  }
+
   xsimd::batch_bool<int16_t> testValues(xsimd::batch<int16_t> x) const final {
-    return Filter::testValues(x);
+    return genericTestValues(x, [this](int16_t x) { return testInt64(x); });
   }
+
   bool testInt64Range(int64_t min, int64_t max, bool hashNull) const final;
 
   std::unique_ptr<Filter> mergeWith(const Filter* other) const final;
@@ -1040,7 +1156,8 @@ class BigintValuesUsingHashTable final : public Filter {
   mergeWith(int64_t min, int64_t max, const Filter* other) const;
 
   static constexpr int64_t kEmptyMarker = 0xdeadbeefbadefeedL;
-  // from Murmur hash
+
+  // From Murmur hash.
   static constexpr uint64_t M = 0xc6a4a7935bd1e995L;
 
   const int64_t min_;
@@ -1070,7 +1187,7 @@ class HugeintValuesUsingHashTable final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -1086,6 +1203,18 @@ class HugeintValuesUsingHashTable final : public Filter {
 
   bool testingEquals(const Filter& other) const final;
 
+  int128_t min() const {
+    return min_;
+  }
+
+  int128_t max() const {
+    return max_;
+  }
+
+  const folly::F14FastSet<int128_t>& values() const {
+    return values_;
+  }
+
  private:
   const int128_t min_;
   const int128_t max_;
@@ -1117,7 +1246,7 @@ class BigintValuesUsingBitmask final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -1131,7 +1260,12 @@ class BigintValuesUsingBitmask final : public Filter {
 
   std::vector<int64_t> values() const;
 
-  bool testInt64(int64_t value) const final;
+  bool testInt64(int64_t value) const final {
+    if (value < min_ || value > max_) {
+      return false;
+    }
+    return bitmask_[value - min_];
+  }
 
   bool testInt64Range(int64_t min, int64_t max, bool hasNull) const final;
 
@@ -1139,6 +1273,14 @@ class BigintValuesUsingBitmask final : public Filter {
 
   bool testingEquals(const Filter& other) const final;
 
+  int64_t min() const {
+    return min_;
+  }
+
+  int64_t max() const {
+    return max_;
+  }
+
  private:
   std::unique_ptr<Filter>
   mergeWith(int64_t min, int64_t max, const Filter* other) const;
@@ -1148,6 +1290,85 @@ class BigintValuesUsingBitmask final : public Filter {
   const int64_t max_;
 };
 
+class BigintValuesUsingBloomFilter final : public Filter {
+ public:
+  static int64_t numBlocks(int64_t capacity) {
+    return SplitBlockBloomFilter::numBlocks(capacity, 0.01);
+  }
+
+  BigintValuesUsingBloomFilter(int64_t capacity, bool nullAllowed)
+      : Filter(true, nullAllowed, FilterKind::kBigintValuesUsingBloomFilter),
+        blocks_(numBlocks(capacity)),
+        filter_(blocks_) {}
+
+  bool testInt64(int64_t value) const final {
+    return filter_.mayContain(hash(value));
+  }
+
+  xsimd::batch_bool<int64_t> testValues(xsimd::batch<int64_t> x) const final {
+    return genericTestValues(x, [this](int64_t x) { return testInt64(x); });
+  }
+
+  xsimd::batch_bool<int32_t> testValues(xsimd::batch<int32_t> x) const final {
+    return genericTestValues(x, [this](int32_t x) { return testInt64(x); });
+  }
+
+  xsimd::batch_bool<int16_t> testValues(xsimd::batch<int16_t> x) const final {
+    return genericTestValues(x, [this](int16_t x) { return testInt64(x); });
+  }
+
+  bool testInt64Range(int64_t /*min*/, int64_t /*max*/, bool /*hasNull*/)
+      const final {
+    return true;
+  }
+
+  std::unique_ptr<Filter> clone(
+      std::optional<bool> nullAllowed) const override {
+    return std::unique_ptr<BigintValuesUsingBloomFilter>(
+        new BigintValuesUsingBloomFilter(
+            nullAllowed.value_or(nullAllowed_), blocks_));
+  }
+
+  folly::dynamic serialize() const override;
+
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
+
+  bool testingEquals(const Filter& other) const override;
+
+  std::unique_ptr<Filter> mergeWith(const Filter* other) const override;
+
+  void insert(int64_t value) {
+    filter_.insert(hash(value));
+  }
+
+  uint64_t blockIndex(int64_t value) const {
+    return filter_.blockIndex(hash(value));
+  }
+
+  int64_t blocksByteSize() const {
+    return blocks_.size() * sizeof(SplitBlockBloomFilter::Block);
+  }
+
+ private:
+  static uint64_t hash(int64_t value) {
+    // Simple multiplication hash like the one in BigintValuesUsingHashTable
+    // does not distribute values evenly.  Maybe we need to reconsider the hash
+    // choice in BigintValuesUsingHashTable as well in the future.
+    return folly::hasher<int64_t>()(value);
+  }
+
+  // Private constructor used by clone() and create().
+  BigintValuesUsingBloomFilter(
+      bool nullAllowed,
+      std::vector<SplitBlockBloomFilter::Block> blocks)
+      : Filter(true, nullAllowed, FilterKind::kBigintValuesUsingBloomFilter),
+        blocks_(std::move(blocks)),
+        filter_(blocks_) {}
+
+  std::vector<SplitBlockBloomFilter::Block> blocks_;
+  SplitBlockBloomFilter filter_;
+};
+
 // NOT IN-list filter for integral data types. Implemented as a hash table. Good
 // for large number of rejected values that do not fit within a small range.
 class NegatedBigintValuesUsingHashTable final : public Filter {
@@ -1172,7 +1393,7 @@ class NegatedBigintValuesUsingHashTable final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -1212,6 +1433,10 @@ class NegatedBigintValuesUsingHashTable final : public Filter {
     return nonNegated_->values();
   }
 
+  const BigintValuesUsingHashTable* getNonNegated() const {
+    return nonNegated_.get();
+  }
+
   std::string toString() const override {
     return fmt::format(
         "NegatedBigintValuesUsingHashTable: [{}, {}] {}",
@@ -1254,7 +1479,7 @@ class NegatedBigintValuesUsingBitmask final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -1276,6 +1501,18 @@ class NegatedBigintValuesUsingBitmask final : public Filter {
 
   bool testingEquals(const Filter& other) const final;
 
+  int64_t min() const {
+    return min_;
+  }
+
+  int64_t max() const {
+    return max_;
+  }
+
+  const BigintValuesUsingBitmask* getNonNegated() const {
+    return nonNegated_.get();
+  }
+
  private:
   std::unique_ptr<Filter>
   mergeWith(int64_t min, int64_t max, const Filter* other) const;
@@ -1304,7 +1541,7 @@ class AbstractRange : public Filter {
     return upperExclusive_;
   }
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
  protected:
   AbstractRange(
@@ -1316,16 +1553,30 @@ class AbstractRange : public Filter {
       FilterKind kind)
       : Filter(true, nullAllowed, kind),
         lowerUnbounded_(lowerUnbounded),
-        lowerExclusive_(lowerExclusive),
+        lowerExclusive_(lowerUnbounded ? true : lowerExclusive),
         upperUnbounded_(upperUnbounded),
-        upperExclusive_(upperExclusive) {
+        upperExclusive_(upperUnbounded ? true : upperExclusive) {
     VELOX_CHECK(
         !lowerUnbounded_ || !upperUnbounded_,
-        "A range filter must have  a lower or upper  bound");
+        "A range filter must have a lower or upper bound");
   }
 
-  folly::dynamic serializeBase(std::string_view name) const {
-    auto obj = Filter::serializeBase(name);
+  template <typename TFilter>
+  const TFilter* testingBaseEquals(const Filter& other) const {
+    if (const auto* otherRange = Filter::testingBaseEquals<TFilter>(other)) {
+      if (lowerUnbounded_ == otherRange->lowerUnbounded_ &&
+          lowerExclusive_ == otherRange->lowerExclusive_ &&
+          upperUnbounded_ == otherRange->upperUnbounded_ &&
+          upperExclusive_ == otherRange->upperExclusive_) {
+        return otherRange;
+      }
+    }
+
+    return nullptr;
+  }
+
+  folly::dynamic serializeBase() const {
+    auto obj = Filter::serializeBase();
     obj["lowerUnbounded"] = lowerUnbounded_;
     obj["lowerExclusive"] = lowerExclusive_;
     obj["upperUnbounded"] = upperUnbounded_;
@@ -1394,7 +1645,12 @@ class FloatingPointRange final : public AbstractRange {
     VELOX_CHECK(upperUnbounded_ || !std::isnan(upper_));
   }
 
-  folly::dynamic serialize() const override;
+  folly::dynamic serialize() const override {
+    auto obj = AbstractRange::serializeBase();
+    obj["lower"] = lower_;
+    obj["upper"] = upper_;
+    return obj;
+  }
 
   double lower() const {
     return lower_;
@@ -1492,17 +1748,32 @@ class FloatingPointRange final : public AbstractRange {
 
   std::string toString() const override;
 
-  bool testingEquals(const Filter& other) const final;
+  bool testingEquals(const Filter& other) const final {
+    if (const auto* otherRange =
+            AbstractRange::testingBaseEquals<FloatingPointRange<T>>(other)) {
+      return (lowerUnbounded_ ||
+              approximatelyEqual(lower_, otherRange->lower_)) &&
+          (upperUnbounded_ || approximatelyEqual(upper_, otherRange->upper_));
+    }
+
+    return false;
+  }
 
  private:
+  static bool approximatelyEqual(T a, T b) {
+    return std::fabs(a - b) < std::numeric_limits<T>::epsilon();
+  }
+
   std::string toString(const std::string& name) const {
     return fmt::format(
         "{}: {}{}, {}{} {}",
         name,
-        (lowerExclusive_ || lowerUnbounded_) ? "(" : "[",
+        (lowerUnbounded_ || lowerExclusive_) ? "(" : "[",
         lowerUnbounded_ ? "-inf" : std::to_string(lower_),
+        // "nan" is considered valid value(s) and
+        // "nan > +inf" so "nan" is the upper bound in case of unbounded range.
         upperUnbounded_ ? "nan" : std::to_string(upper_),
-        (upperExclusive_ && !upperUnbounded_) ? ")" : "]",
+        (upperUnbounded_ || upperExclusive_) ? ")" : "]",
         nullAllowed_ ? "with nulls" : "no nulls");
   }
 
@@ -1575,18 +1846,6 @@ inline std::string FloatingPointRange<float>::toString() const {
   return toString("FloatRange");
 }
 
-template <>
-inline bool FloatingPointRange<float>::testingEquals(
-    const Filter& other) const {
-  return toString() == other.toString();
-}
-
-template <>
-inline bool FloatingPointRange<double>::testingEquals(
-    const Filter& other) const {
-  return toString() == other.toString();
-}
-
 template <>
 inline xsimd::batch_bool<double> FloatingPointRange<double>::testValues(
     xsimd::batch<double> x) const {
@@ -1595,8 +1854,12 @@ inline xsimd::batch_bool<double> FloatingPointRange<double>::testValues(
 
 template <>
 inline xsimd::batch_bool<float> FloatingPointRange<double>::testValues(
-    xsimd::batch<float>) const {
-  VELOX_FAIL("Not defined for double filter");
+    xsimd::batch<float> x) const {
+  // Slow path for schema evolution:  handles the case where double filter is
+  // applied to float data (e.g., reading float column with double type
+  // request). Falls back to element-by-element testing as batch processing
+  // requires type matching.
+  return Filter::testValues(x);
 }
 
 template <>
@@ -1630,10 +1893,10 @@ class BytesRange final : public AbstractRange {
   /// the filter.
   /// @param nullAllowed Null values are passing the filter if true.
   BytesRange(
-      const std::string& lower,
+      std::string lower,
       bool lowerUnbounded,
       bool lowerExclusive,
-      const std::string& upper,
+      std::string upper,
       bool upperUnbounded,
       bool upperExclusive,
       bool nullAllowed)
@@ -1644,8 +1907,10 @@ class BytesRange final : public AbstractRange {
             upperExclusive,
             nullAllowed,
             FilterKind::kBytesRange),
-        lower_(lower),
-        upper_(upper),
+        lower_(std::move(lower)),
+        upper_(std::move(upper)),
+        lowerView_(lower_),
+        upperView_(upper_),
         singleValue_(
             !lowerExclusive_ && !upperExclusive_ && !lowerUnbounded_ &&
             !upperUnbounded_ && lower_ == upper_) {
@@ -1663,11 +1928,13 @@ class BytesRange final : public AbstractRange {
             FilterKind::kBytesRange),
         lower_(other.lower_),
         upper_(other.upper_),
+        lowerView_(lower_),
+        upperView_(upper_),
         singleValue_(other.singleValue_) {}
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -1690,6 +1957,35 @@ class BytesRange final : public AbstractRange {
 
   bool testBytes(const char* value, int32_t length) const final;
 
+  bool testStringView(const StringView& view) const final {
+    if (singleValue_) {
+      return view == lowerView_;
+    }
+    if (!lowerUnbounded_) {
+      if (lowerExclusive_) {
+        if (view <= lowerView_) {
+          return false;
+        }
+      } else {
+        if (view < lowerView_) {
+          return false;
+        }
+      }
+    }
+    if (!upperUnbounded_) {
+      if (upperExclusive_) {
+        if (view >= upperView_) {
+          return false;
+        }
+      } else {
+        if (view > upperView_) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
   bool testBytesRange(
       std::optional<std::string_view> min,
       std::optional<std::string_view> max,
@@ -1700,7 +1996,7 @@ class BytesRange final : public AbstractRange {
   }
 
   bool testLength(int length) const final {
-    return !singleValue_ || lower_.size() == length;
+    return !singleValue_ || static_cast<int64_t>(lower_.size()) == length;
   }
 
   std::unique_ptr<Filter> mergeWith(const Filter* other) const final;
@@ -1723,6 +2019,14 @@ class BytesRange final : public AbstractRange {
     return lowerUnbounded_;
   }
 
+  bool isUpperExclusive() const {
+    return upperExclusive_;
+  }
+
+  bool isLowerExclusive() const {
+    return lowerExclusive_;
+  }
+
   const std::string& lower() const {
     return lower_;
   }
@@ -1736,6 +2040,8 @@ class BytesRange final : public AbstractRange {
  private:
   const std::string lower_;
   const std::string upper_;
+  const StringView lowerView_;
+  const StringView upperView_;
   const bool singleValue_;
 };
 
@@ -1754,19 +2060,19 @@ class NegatedBytesRange final : public Filter {
   /// the filter.
   /// @param nullAllowed Null values are passing the filter if true.
   NegatedBytesRange(
-      const std::string& lower,
+      std::string lower,
       bool lowerUnbounded,
       bool lowerExclusive,
-      const std::string& upper,
+      std::string upper,
       bool upperUnbounded,
       bool upperExclusive,
       bool nullAllowed)
       : Filter(true, nullAllowed, FilterKind::kNegatedBytesRange) {
     nonNegated_ = std::make_unique<BytesRange>(
-        lower,
+        std::move(lower),
         lowerUnbounded,
         lowerExclusive,
-        upper,
+        std::move(upper),
         upperUnbounded,
         upperExclusive,
         nullAllowed);
@@ -1778,7 +2084,7 @@ class NegatedBytesRange final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -1794,14 +2100,18 @@ class NegatedBytesRange final : public Filter {
     return !nonNegated_->testBytes(value, length);
   }
 
+  bool testStringView(const StringView& view) const final {
+    return !nonNegated_->testStringView(view);
+  }
+
   bool testBytesRange(
       std::optional<std::string_view> min,
       std::optional<std::string_view> max,
       bool hasNull) const final;
 
   bool testLength(int length) const final {
-    // a range nearly never covers all values of a particular length,
-    // so at least one value of each length is probably accepted
+    // A range almost never covers all values of a particular length,
+    // so at least one value of each length is probably accepted.
     return true;
   }
 
@@ -1819,6 +2129,14 @@ class NegatedBytesRange final : public Filter {
     return nonNegated_->isLowerUnbounded();
   }
 
+  bool isUpperExclusive() const {
+    return nonNegated_->isUpperExclusive();
+  }
+
+  bool isLowerExclusive() const {
+    return nonNegated_->isLowerExclusive();
+  }
+
   const std::string& lower() const {
     return nonNegated_->lower();
   }
@@ -1829,6 +2147,10 @@ class NegatedBytesRange final : public Filter {
 
   bool testingEquals(const Filter& other) const final;
 
+  const BytesRange* getNonNegated() const {
+    return nonNegated_.get();
+  }
+
  private:
   std::unique_ptr<Filter> toMultiRange() const;
 
@@ -1862,7 +2184,7 @@ class TimestampRange : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -1911,10 +2233,6 @@ class TimestampRange : public Filter {
     return upper_;
   }
 
-  bool nullAllowed() const {
-    return nullAllowed_;
-  }
-
   bool testingEquals(const Filter& other) const final;
 
  private:
@@ -1951,7 +2269,7 @@ class BytesValues final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -1997,6 +2315,7 @@ class BytesValues final : public Filter {
 class BigintMultiRange final : public Filter {
  public:
   /// @param ranges List of range filters. Must contain at least two entries.
+  /// Ranges must be sorted in ascending order and must not overlap.
   /// @param nullAllowed Null values are passing the filter if true. nullAllowed
   /// flags in the 'ranges' filters are ignored.
   BigintMultiRange(
@@ -2007,7 +2326,7 @@ class BigintMultiRange final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final;
@@ -2022,15 +2341,7 @@ class BigintMultiRange final : public Filter {
     return ranges_;
   }
 
-  std::string toString() const override {
-    std::ostringstream out;
-    out << "BigintMultiRange: [";
-    for (const auto& range : ranges_) {
-      out << " " << range->toString();
-    }
-    out << " ]" << (nullAllowed_ ? "with nulls" : "no nulls");
-    return out.str();
-  }
+  std::string toString() const override;
 
   bool testingEquals(const Filter& other) const final;
 
@@ -2057,7 +2368,7 @@ class NegatedBytesValues final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final {
@@ -2066,7 +2377,7 @@ class NegatedBytesValues final : public Filter {
   }
 
   bool testLength(int32_t /* unused */) const final {
-    // it is very rare that we will reject all strings of a given length
+    // It is very rare that we will reject all strings of a given length
     // using a NegatedBytesValues filter.
     return true;
   }
@@ -2088,6 +2399,10 @@ class NegatedBytesValues final : public Filter {
 
   bool testingEquals(const Filter& other) const final;
 
+  const BytesValues* getNonNegated() const {
+    return nonNegated_.get();
+  }
+
  private:
   std::unique_ptr<BytesValues> nonNegated_;
 };
@@ -2112,7 +2427,7 @@ class MultiRange final : public Filter {
 
   folly::dynamic serialize() const override;
 
-  static FilterPtr create(const folly::dynamic& obj);
+  static std::unique_ptr<Filter> create(const folly::dynamic& obj);
 
   std::unique_ptr<Filter> clone(
       std::optional<bool> nullAllowed = std::nullopt) const final;
@@ -2121,6 +2436,8 @@ class MultiRange final : public Filter {
 
   bool testFloat(float value) const final;
 
+  bool testInt128(const int128_t& value) const final;
+
   bool testBytes(const char* value, int32_t length) const final;
 
   bool testTimestamp(const Timestamp& value) const final;
@@ -2174,16 +2491,16 @@ static inline bool applyFilter(TFilter& filter, const std::string& value) {
 }
 
 template <typename TFilter>
-static inline bool applyFilter(TFilter& filter, folly::StringPiece value) {
+static inline bool applyFilter(TFilter& filter, std::string_view value) {
   return filter.testBytes(value.data(), value.size());
 }
 
 template <typename TFilter>
 static inline bool applyFilter(TFilter& filter, StringView value) {
-  return filter.testBytes(value.data(), value.size());
+  return filter.testStringView(value);
 }
 
-// Creates a hash or bitmap based IN filter depending on value distribution.
+/// Create a hash or bitmap based IN filter depending on value distribution.
 std::unique_ptr<Filter> createBigintValues(
     const std::vector<int64_t>& values,
     bool nullAllowed);
@@ -2192,9 +2509,19 @@ std::unique_ptr<Filter> createHugeintValues(
     const std::vector<int128_t>& values,
     bool nullAllowed);
 
-// Creates a hash or bitmap based NOT IN filter depending on value distribution.
+/// Create a hash or bitmap based NOT IN filter depending on value distribution.
 std::unique_ptr<Filter> createNegatedBigintValues(
     const std::vector<int64_t>& values,
     bool nullAllowed);
 
 } // namespace facebook::velox::common
+
+template <>
+struct fmt::formatter<facebook::velox::common::FilterKind>
+    : formatter<std::string> {
+  auto format(facebook::velox::common::FilterKind s, format_context& ctx)
+      const {
+    return formatter<std::string>::format(
+        std::string(facebook::velox::common::FilterKindName::toName(s)), ctx);
+  }
+};
diff --git a/velox/type/FloatingPointUtil.h b/velox/type/FloatingPointUtil.h
index 082d5d8c6c5e..b2ec6ab5ea81 100644
--- a/velox/type/FloatingPointUtil.h
+++ b/velox/type/FloatingPointUtil.h
@@ -162,6 +162,6 @@ struct HashMapNaNAwareTypeTraits<double, Mapped, Alloc> {
 class DoubleUtil {
  public:
   static const std::array<double, 309> kPowersOfTen;
+};
 
-}; // DoubleUtil
 } // namespace facebook::velox
diff --git a/velox/type/OpaqueCustomTypes.h b/velox/type/OpaqueCustomTypes.h
index 12805b59036e..907f742c6872 100644
--- a/velox/type/OpaqueCustomTypes.h
+++ b/velox/type/OpaqueCustomTypes.h
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "velox/common/base/Exceptions.h"
 #include "velox/type/SimpleFunctionApi.h"
 #include "velox/type/Type.h"
 
@@ -34,14 +35,19 @@ class CastOperator;
 template <typename T, const char* customTypeName>
 class OpaqueCustomTypeRegister {
  public:
-  static bool registerType() {
-    return facebook::velox::registerCustomType(
-        customTypeName, std::make_unique<const TypeFactory>());
-  }
+  using SerializeValueFunc = OpaqueType::SerializeFunc<T>;
+  using DeserializeValueFunc = OpaqueType::DeserializeFunc<T>;
 
-  static bool unregisterType() {
-    return facebook::velox::unregisterCustomType(customTypeName);
-  }
+  // @param serializeValueFunc Optional serialization function for values of
+  // type T.
+  // @param deserializeValueFunc Optional deserialization function for values of
+  // type T. Both serializeValueFunc and deserializeValueFunc must be specified
+  // or not together.
+  static bool registerType(
+      SerializeValueFunc serializeValueFunc = nullptr,
+      DeserializeValueFunc deserializeValueFunc = nullptr);
+
+  static bool unregisterType();
 
   // Type used in the simple function interface as CustomType<TypeT>.
   struct TypeT {
@@ -51,13 +57,17 @@ class OpaqueCustomTypeRegister {
 
   using SimpleType = CustomType<TypeT>;
 
+  class VeloxType;
+  using VeloxTypePtr = std::shared_ptr<const VeloxType>;
+
   class VeloxType : public OpaqueType {
    public:
     VeloxType() : OpaqueType(std::type_index(typeid(T))) {}
 
-    static const TypePtr& get() {
-      static const TypePtr instance{new VeloxType()};
-      return instance;
+    static const VeloxTypePtr& get() {
+      static const VeloxType kInstance;
+      static const VeloxTypePtr kInstancePtr{TypePtr{}, &kInstance};
+      return kInstancePtr;
     }
 
     static const std::shared_ptr<const exec::CastOperator>& getCastOperator() {
@@ -76,18 +86,25 @@ class OpaqueCustomTypeRegister {
     std::string toString() const override {
       return customTypeName;
     }
+
+    folly::dynamic serialize() const override {
+      folly::dynamic obj = folly::dynamic::object;
+      obj["name"] = "Type";
+      obj["type"] = customTypeName;
+      return obj;
+    }
   };
 
-  static const TypePtr& singletonTypePtr() {
+  static const VeloxTypePtr& singletonTypePtr() {
     return VeloxType::get();
   }
 
-  static const TypePtr& get() {
+  static const VeloxTypePtr& get() {
     return VeloxType::get();
   }
 
  private:
-  class TypeFactory : public CustomTypeFactories {
+  class TypeFactory : public CustomTypeFactory {
    public:
     TypeFactory() = default;
 
@@ -107,4 +124,34 @@ class OpaqueCustomTypeRegister {
     }
   };
 };
+
+template <typename T, const char* customTypeName>
+bool OpaqueCustomTypeRegister<T, customTypeName>::registerType(
+    SerializeValueFunc serializeValueFunc,
+    DeserializeValueFunc deserializeValueFunc) {
+  VELOX_USER_CHECK(
+      ((serializeValueFunc && deserializeValueFunc) ||
+       (!serializeValueFunc && !deserializeValueFunc)),
+      "Both serialization and deserialization functions need to be registered for custom type {}",
+      customTypeName);
+  if (registerCustomType(
+          customTypeName, std::make_unique<const TypeFactory>())) {
+    if (serializeValueFunc && deserializeValueFunc) {
+      OpaqueType::registerSerialization<T>(
+          customTypeName, serializeValueFunc, deserializeValueFunc);
+    }
+    return true;
+  }
+  return false;
+}
+
+template <typename T, const char* customTypeName>
+bool OpaqueCustomTypeRegister<T, customTypeName>::unregisterType() {
+  if (unregisterCustomType(customTypeName)) {
+    OpaqueType::unregisterSerialization(singletonTypePtr(), customTypeName);
+    return true;
+  }
+  return false;
+}
+
 } // namespace facebook::velox
diff --git a/velox/type/SimpleFunctionApi.h b/velox/type/SimpleFunctionApi.h
index 6cd754170631..b57d6e82ef77 100644
--- a/velox/type/SimpleFunctionApi.h
+++ b/velox/type/SimpleFunctionApi.h
@@ -64,6 +64,20 @@ using S2 = IntegerVariable<6>;
 using S3 = IntegerVariable<7>;
 using S4 = IntegerVariable<8>;
 
+template <size_t id>
+struct EnumVariable {
+  static size_t getId() {
+    return id;
+  }
+
+  static std::string name() {
+    return fmt::format("E{}", id);
+  }
+};
+
+using E1 = EnumVariable<1>;
+using E2 = EnumVariable<2>;
+
 template <typename P, typename S>
 struct ShortDecimal {
  private:
@@ -220,6 +234,30 @@ struct Varchar {
   Varchar() {}
 };
 
+// Type to use for inputs and outputs of simple functions with BigintEnum types.
+// E.g. arg_type<BigintEnum<E1>> and out_type<BigintEnum<E1>>.
+template <typename E>
+struct BigintEnumT {
+  using type = int64_t;
+
+  static inline const std::string typeName = "bigint_enum(" + E::name() + ")";
+};
+
+template <typename E>
+using BigintEnum = CustomType<BigintEnumT<E>>;
+
+// Type to use for inputs and outputs of simple functions with VarcharEnum
+// types. E.g. arg_type<VarcharEnum<E1>> and out_type<VarcharEnum<E1>>.
+template <typename E>
+struct VarcharEnumT {
+  using type = Varchar;
+
+  static inline const std::string typeName = "varchar_enum(" + E::name() + ")";
+};
+
+template <typename E>
+using VarcharEnum = CustomType<VarcharEnumT<E>>;
+
 template <typename T>
 struct Constant {};
 
@@ -316,20 +354,26 @@ template <>
 struct SimpleTypeTrait<Varbinary> : public TypeTraits<TypeKind::VARBINARY> {};
 
 template <>
-struct SimpleTypeTrait<Date> : public SimpleTypeTrait<int32_t> {
+struct SimpleTypeTrait<Date> : public TypeTraits<TypeKind::INTEGER> {
   static constexpr const char* name = "DATE";
 };
 
 template <>
-struct SimpleTypeTrait<IntervalDayTime> : public SimpleTypeTrait<int64_t> {
+struct SimpleTypeTrait<IntervalDayTime> : public TypeTraits<TypeKind::BIGINT> {
   static constexpr const char* name = "INTERVAL DAY TO SECOND";
 };
 
 template <>
-struct SimpleTypeTrait<IntervalYearMonth> : public SimpleTypeTrait<int32_t> {
+struct SimpleTypeTrait<IntervalYearMonth>
+    : public TypeTraits<TypeKind::INTEGER> {
   static constexpr const char* name = "INTERVAL YEAR TO MONTH";
 };
 
+template <>
+struct SimpleTypeTrait<Time> : public TypeTraits<TypeKind::BIGINT> {
+  static constexpr const char* name = "TIME";
+};
+
 template <typename T, bool comparable, bool orderable>
 struct SimpleTypeTrait<Generic<T, comparable, orderable>> {
   static constexpr TypeKind typeKind = TypeKind::INVALID;
@@ -424,14 +468,14 @@ template <>
 struct MaterializeType<Varchar> {
   using nullable_t = std::string;
   using null_free_t = std::string;
-  static constexpr bool requiresMaterialization = false;
+  static constexpr bool requiresMaterialization = true;
 };
 
 template <>
 struct MaterializeType<Varbinary> {
   using nullable_t = std::string;
   using null_free_t = std::string;
-  static constexpr bool requiresMaterialization = false;
+  static constexpr bool requiresMaterialization = true;
 };
 
 } // namespace facebook::velox
diff --git a/velox/type/StringView.cpp b/velox/type/StringView.cpp
index 1b8f2e07f5e5..72327fe15488 100644
--- a/velox/type/StringView.cpp
+++ b/velox/type/StringView.cpp
@@ -18,8 +18,8 @@
 #include "velox/common/base/SimdUtil.h"
 
 namespace facebook::velox {
-
 namespace {
+
 int32_t linearSearchSimple(
     StringView key,
     const StringView* strings,
diff --git a/velox/type/StringView.h b/velox/type/StringView.h
index 6b9ea7c6f42c..fae0c1c5b59c 100644
--- a/velox/type/StringView.h
+++ b/velox/type/StringView.h
@@ -32,17 +32,17 @@
 
 namespace facebook::velox {
 
-// Variable length string or binary type for use in vectors. This has
-// semantics similar to std::string_view or folly::StringPiece and
-// exposes a subset of the interface. If the string is 12 characters
-// or less, it is inlined and no reference is held. If it is longer, a
-// reference to the string is held and the 4 first characters are
-// cached in the StringView. This allows failing comparisons early and
-// reduces the CPU cache working set when dealing with short strings.
-//
-// Adapted from TU Munich Umbra and CWI DuckDB.
-//
-// TODO: Extend the interface to parity with folly::StringPiece as needed.
+/// Variable length string or binary type for use in vectors. This has
+/// semantics similar to std::string_view or folly::StringPiece and
+/// exposes a subset of the interface. If the string is 12 characters
+/// or less, it is inlined and no reference is held. If it is longer, a
+/// reference to the string is held and the 4 first characters are
+/// cached in the StringView. This allows failing comparisons early and
+/// reduces the CPU cache working set when dealing with short strings.
+///
+/// Adapted from TU Munich Umbra and CWI DuckDB.
+///
+/// TODO: Extend the interface to parity with folly::StringPiece as needed.
 struct StringView {
  public:
   using value_type = char;
@@ -77,11 +77,6 @@ struct StringView {
     }
   }
 
-  static StringView makeInline(std::string str) {
-    VELOX_DCHECK(isInline(str.size()));
-    return StringView{str};
-  }
-
   // Making StringView implicitly constructible/convertible from char* and
   // string literals, in order to allow for a more flexible API and optional
   // interoperability. E.g:
@@ -111,6 +106,18 @@ struct StringView {
     return size <= kInlineSize;
   }
 
+  /// Convenience method to create an inline StringView. The API client is
+  /// reponsible for providing a string that is small enough to fit inline
+  /// (i.e <= kInlineSize).
+  static StringView makeInline(std::string_view input) {
+    VELOX_DCHECK(
+        isInline(input.size()),
+        "StringView::makeInline() requires an input string that fits "
+        "inline (got string size of {}).",
+        input.size());
+    return StringView{input};
+  }
+
   const char* data() && = delete;
   const char* data() const& {
     return isInline() ? prefix_ : value_.data;
@@ -149,10 +156,6 @@ struct StringView {
                size_ - kPrefixSize) == 0;
   }
 
-  bool operator!=(const StringView& other) const {
-    return !(*this == other);
-  }
-
   // Returns 0, if this == other
   //       < 0, if this < other
   //       > 0, if this > other
@@ -176,20 +179,11 @@ struct StringView {
     return (result != 0) ? result : size_ - other.size_;
   }
 
-  bool operator<(const StringView& other) const {
-    return compare(other) < 0;
-  }
-
-  bool operator<=(const StringView& other) const {
-    return compare(other) <= 0;
-  }
-
-  bool operator>(const StringView& other) const {
-    return compare(other) > 0;
-  }
-
-  bool operator>=(const StringView& other) const {
-    return compare(other) >= 0;
+  auto operator<=>(const StringView& other) const {
+    const auto cmp = compare(other);
+    return cmp < 0 ? std::strong_ordering::less
+        : cmp > 0  ? std::strong_ordering::greater
+                   : std::strong_ordering::equal;
   }
 
   operator folly::StringPiece() && = delete;
@@ -277,10 +271,20 @@ struct StringView {
 //
 //   auto myStringView = "my string"_sv;
 //   auto vec = {"str1"_sv, "str2"_sv};
-inline StringView operator"" _sv(const char* str, size_t len) {
+inline StringView operator""_sv(const char* str, size_t len) {
   return StringView(str, len);
 }
 
+// Specializations needed for string conversion in folly/Conv.h.
+template <class TString>
+inline void toAppend(const StringView& value, TString* result) {
+  result->append(value);
+}
+
+inline size_t estimateSpaceNeeded(const StringView& value) {
+  return value.size();
+}
+
 } // namespace facebook::velox
 
 namespace std {
@@ -293,6 +297,7 @@ struct hash<::facebook::velox::StringView> {
 } // namespace std
 
 namespace folly {
+
 template <>
 struct hasher<::facebook::velox::StringView> {
   size_t operator()(const ::facebook::velox::StringView view) const {
diff --git a/velox/type/Subfield.cpp b/velox/type/Subfield.cpp
index 3994e6ee5ab6..7c0f9bb84aba 100644
--- a/velox/type/Subfield.cpp
+++ b/velox/type/Subfield.cpp
@@ -14,21 +14,40 @@
  * limitations under the License.
  */
 #include "velox/type/Subfield.h"
+#include <boost/algorithm/string/replace.hpp>
+#include <folly/container/F14Map.h>
 #include "velox/type/Tokenizer.h"
 
 namespace facebook::velox::common {
 
+namespace {
+const auto& subfieldKindNames() {
+  static const folly::F14FastMap<SubfieldKind, std::string_view> kNames = {
+      {SubfieldKind::kAllSubscripts, "AllSubscripts"},
+      {SubfieldKind::kNestedField, "NestedField"},
+      {SubfieldKind::kStringSubscript, "StringSubscript"},
+      {SubfieldKind::kLongSubscript, "LongSubscript"},
+  };
+
+  return kNames;
+}
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(SubfieldKind, subfieldKindNames)
+
 Subfield::Subfield(
     const std::string& path,
-    const std::shared_ptr<Separators>& separators) {
-  Tokenizer tokenizer(path, separators);
+    std::shared_ptr<const Separators> separators) {
+  Tokenizer tokenizer{path, std::move(separators)};
   VELOX_CHECK(tokenizer.hasNext(), "Column name is missing: {}", path);
 
   auto firstElement = tokenizer.next();
-  VELOX_CHECK(
-      firstElement->kind() == kNestedField,
+  VELOX_CHECK_EQ(
+      firstElement->kind(),
+      SubfieldKind::kNestedField,
       "Subfield path must start with a name: {}",
       path);
+
   std::vector<std::unique_ptr<PathElement>> pathElements;
   pathElements.push_back(std::move(firstElement));
   while (tokenizer.hasNext()) {
@@ -40,6 +59,10 @@ Subfield::Subfield(
 Subfield::Subfield(std::vector<std::unique_ptr<Subfield::PathElement>>&& path)
     : path_(std::move(path)) {
   VELOX_CHECK_GE(path_.size(), 1);
+  VELOX_CHECK_EQ(
+      path_[0]->kind(),
+      SubfieldKind::kNestedField,
+      "Subfield path must start with a name");
 }
 
 Subfield Subfield::clone() const {
@@ -51,4 +74,56 @@ Subfield Subfield::clone() const {
   return subfield;
 }
 
+bool Subfield::isPrefix(const Subfield& other) const {
+  if (path_.size() < other.path_.size()) {
+    for (size_t i = 0; i < path_.size(); ++i) {
+      if (!(*path_[i].get() == *other.path_[i].get())) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+std::string Subfield::toString() const {
+  if (!valid()) {
+    return "";
+  }
+  std::ostringstream out;
+  out << static_cast<const NestedField*>(path_[0].get())->name();
+  for (size_t i = 1; i < path_.size(); i++) {
+    out << path_[i]->toString();
+  }
+  return out.str();
+}
+
+bool Subfield::operator==(const Subfield& other) const {
+  if (this == &other) {
+    return true;
+  }
+
+  if (path_.size() != other.path_.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < path_.size(); ++i) {
+    if (!(*path_[i].get() == *other.path_[i].get())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+size_t Subfield::hash() const {
+  size_t result = 1;
+  for (size_t i = 0; i < path_.size(); ++i) {
+    result = result * 31 + path_[i]->hash();
+  }
+  return result;
+}
+
+std::string Subfield::StringSubscript::toString() const {
+  return "[\"" + boost::replace_all_copy(index_, "\"", "\\\"") + "\"]";
+}
+
 } // namespace facebook::velox::common
diff --git a/velox/type/Subfield.h b/velox/type/Subfield.h
index 9fc7f343b214..437f3d6cf4d4 100644
--- a/velox/type/Subfield.h
+++ b/velox/type/Subfield.h
@@ -15,33 +15,34 @@
  */
 #pragma once
 
-#include <boost/algorithm/string/replace.hpp>
 #include <fmt/format.h>
 #include <ostream>
 
+#include "velox/common/Enums.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/Macros.h"
 
 namespace facebook::velox::common {
 
-enum SubfieldKind {
+enum class SubfieldKind {
   kAllSubscripts,
   kNestedField,
   kStringSubscript,
-  kLongSubscript
+  kLongSubscript,
 };
 
+VELOX_DECLARE_ENUM_NAME(SubfieldKind)
+
 // Contains field name separators to be used in Tokenizer.
 struct Separators {
-  static const std::shared_ptr<Separators>& get() {
-    static const std::shared_ptr<Separators> instance =
-        std::make_shared<Separators>();
-    return instance;
+  static std::shared_ptr<const Separators> get() {
+    VELOX_CONSTEXPR_SINGLETON Separators kInstance;
+    return {std::shared_ptr<const Separators>{}, &kInstance};
   }
 
   bool isSeparator(char c) const {
-    return (
-        c == closeBracket || c == dot || c == openBracket || c == quote ||
-        c == wildCard);
+    return c == closeBracket || c == dot || c == openBracket || c == quote ||
+        c == wildCard;
   }
 
   char backSlash = '\\';
@@ -57,25 +58,43 @@ class Subfield {
  public:
   class PathElement {
    public:
+    explicit PathElement(SubfieldKind kind) : kind_{kind} {}
+
     virtual ~PathElement() = default;
-    virtual SubfieldKind kind() const = 0;
-    virtual bool isSubscript() const = 0;
+
+    SubfieldKind kind() const {
+      return kind_;
+    }
+
+    bool isSubscript() const {
+      return kind_ != SubfieldKind::kNestedField;
+    }
+
     virtual std::string toString() const = 0;
+
     virtual size_t hash() const = 0;
+
     virtual bool operator==(const PathElement& other) const = 0;
+
     virtual std::unique_ptr<PathElement> clone() = 0;
-  };
 
-  class AllSubscripts final : public PathElement {
-   public:
-    SubfieldKind kind() const override {
-      return kAllSubscripts;
+    bool is(SubfieldKind k) const {
+      return kind_ == k;
     }
 
-    bool isSubscript() const override {
-      return true;
+    template <typename T>
+    const T* as() const {
+      return dynamic_cast<const T*>(this);
     }
 
+   private:
+    const SubfieldKind kind_;
+  };
+
+  class AllSubscripts final : public PathElement {
+   public:
+    AllSubscripts() : PathElement(SubfieldKind::kAllSubscripts) {}
+
     std::string toString() const override {
       return "[*]";
     }
@@ -85,7 +104,7 @@ class Subfield {
     }
 
     bool operator==(const PathElement& other) const override {
-      return other.kind() == kAllSubscripts;
+      return other.kind() == SubfieldKind::kAllSubscripts;
     }
 
     std::unique_ptr<PathElement> clone() override {
@@ -95,15 +114,12 @@ class Subfield {
 
   class NestedField final : public PathElement {
    public:
-    explicit NestedField(const std::string& name) : name_(name) {
+    explicit NestedField(const std::string& name)
+        : PathElement(SubfieldKind::kNestedField), name_(name) {
       VELOX_USER_CHECK(
           !name.empty(), "NestedFields must have non-empty names.");
     }
 
-    SubfieldKind kind() const override {
-      return kNestedField;
-    }
-
     const std::string& name() const {
       return name_;
     }
@@ -112,23 +128,18 @@ class Subfield {
       if (this == &other) {
         return true;
       }
-      return other.kind() == kNestedField &&
-          reinterpret_cast<const NestedField*>(&other)->name_ == name_;
+      return other.kind() == SubfieldKind::kNestedField &&
+          other.as<NestedField>()->name_ == name_;
     }
 
     size_t hash() const override {
-      std::hash<std::string> hash;
-      return hash(name_);
+      return std::hash<std::string>()(name_);
     }
 
     std::string toString() const override {
       return "." + name_;
     }
 
-    bool isSubscript() const override {
-      return false;
-    }
-
     std::unique_ptr<PathElement> clone() override {
       return std::make_unique<NestedField>(name_);
     }
@@ -139,11 +150,8 @@ class Subfield {
 
   class LongSubscript final : public PathElement {
    public:
-    explicit LongSubscript(long index) : index_(index) {}
-
-    SubfieldKind kind() const override {
-      return kLongSubscript;
-    }
+    explicit LongSubscript(long index)
+        : PathElement(SubfieldKind::kLongSubscript), index_(index) {}
 
     long index() const {
       return index_;
@@ -153,23 +161,18 @@ class Subfield {
       if (this == &other) {
         return true;
       }
-      return other.kind() == kLongSubscript &&
-          reinterpret_cast<const LongSubscript*>(&other)->index_ == index_;
+      return other.kind() == SubfieldKind::kLongSubscript &&
+          other.as<LongSubscript>()->index_ == index_;
     }
 
     size_t hash() const override {
-      std::hash<long> hash;
-      return hash(index_);
+      return std::hash<long>()(index_);
     }
 
     std::string toString() const override {
       return "[" + std::to_string(index_) + "]";
     }
 
-    bool isSubscript() const override {
-      return true;
-    }
-
     std::unique_ptr<PathElement> clone() override {
       return std::make_unique<LongSubscript>(index_);
     }
@@ -180,11 +183,8 @@ class Subfield {
 
   class StringSubscript final : public PathElement {
    public:
-    explicit StringSubscript(const std::string& index) : index_(index) {}
-
-    SubfieldKind kind() const override {
-      return kStringSubscript;
-    }
+    explicit StringSubscript(const std::string& index)
+        : PathElement(SubfieldKind::kStringSubscript), index_(index) {}
 
     const std::string index() const {
       return index_;
@@ -194,22 +194,15 @@ class Subfield {
       if (this == &other) {
         return true;
       }
-      return other.kind() == kStringSubscript &&
-          reinterpret_cast<const StringSubscript*>(&other)->index_ == index_;
+      return other.kind() == SubfieldKind::kStringSubscript &&
+          other.as<StringSubscript>()->index_ == index_;
     }
 
     size_t hash() const override {
-      std::hash<std::string> hash;
-      return hash(index_);
-    }
-
-    std::string toString() const override {
-      return "[\"" + boost::replace_all_copy(index_, "\"", "\\\"") + "\"]";
+      return std::hash<std::string>()(index_);
     }
 
-    bool isSubscript() const override {
-      return true;
-    }
+    std::string toString() const override;
 
     std::unique_ptr<PathElement> clone() override {
       return std::make_unique<StringSubscript>(index_);
@@ -222,7 +215,7 @@ class Subfield {
   // Separators: the customized separators to tokenize field name.
   explicit Subfield(
       const std::string& path,
-      const std::shared_ptr<Separators>& separators = Separators::get());
+      std::shared_ptr<const Separators> separators = Separators::get());
 
   explicit Subfield(std::vector<std::unique_ptr<PathElement>>&& path);
 
@@ -234,6 +227,11 @@ class Subfield {
     return std::make_unique<Subfield>(std::move(path));
   }
 
+  /// @return The name of the base column.
+  const std::string& baseName() const {
+    return path_[0]->as<NestedField>()->name();
+  }
+
   const std::vector<std::unique_ptr<PathElement>>& path() const {
     return path_;
   }
@@ -242,56 +240,16 @@ class Subfield {
     return path_;
   }
 
-  bool isPrefix(const Subfield& other) const {
-    if (path_.size() < other.path_.size()) {
-      for (int i = 0; i < path_.size(); ++i) {
-        if (!(*path_[i].get() == *other.path_[i].get())) {
-          return false;
-        }
-      }
-      return true;
-    }
-    return false;
-  }
-
-  std::string toString() const {
-    if (!valid()) {
-      return "";
-    }
-    std::ostringstream out;
-    out << static_cast<const NestedField*>(path_[0].get())->name();
-    for (int i = 1; i < path_.size(); i++) {
-      out << path_[i]->toString();
-    }
-    return out.str();
-  }
+  bool isPrefix(const Subfield& other) const;
 
-  bool operator==(const Subfield& other) const {
-    if (this == &other) {
-      return true;
-    }
+  std::string toString() const;
 
-    if (path_.size() != other.path_.size()) {
-      return false;
-    }
-    for (int i = 0; i < path_.size(); ++i) {
-      if (!(*path_[i].get() == *other.path_[i].get())) {
-        return false;
-      }
-    }
-    return true;
-  }
+  bool operator==(const Subfield& other) const;
 
-  size_t hash() const {
-    size_t result = 1;
-    for (int i = 0; i < path_.size(); ++i) {
-      result = result * 31 + path_[i]->hash();
-    }
-    return result;
-  }
+  size_t hash() const;
 
   bool valid() const {
-    return !path_.empty() && path_[0]->kind() == kNestedField;
+    return !path_.empty() && path_[0]->is(SubfieldKind::kNestedField);
   }
 
   Subfield clone() const;
diff --git a/velox/type/Time.cpp b/velox/type/Time.cpp
new file mode 100644
index 000000000000..02316083fca5
--- /dev/null
+++ b/velox/type/Time.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/type/Time.h"
+#include <charconv>
+#include "velox/type/TimestampConversion.h"
+
+namespace facebook::velox::util {
+
+namespace {
+
+// Helper: Parse a number from the given position using std::from_chars
+bool parseNumber(const char* data, size_t size, size_t& pos, int32_t& result) {
+  if (pos >= size) {
+    return false;
+  }
+
+  const char* start = data + pos;
+  const char* end = data + size;
+
+  auto parseResult = std::from_chars(start, end, result);
+  if (parseResult.ec != std::errc{}) {
+    return false;
+  }
+
+  // Update position
+  pos += (parseResult.ptr - start);
+  return true;
+}
+
+// Helper: Parse fractional seconds (milliseconds)
+Expected<int32_t>
+parseFractionalSeconds(const char* data, size_t size, size_t& pos) {
+  if (pos >= size || data[pos] != '.') {
+    return 0; // No fractional part
+  }
+
+  pos++; // Skip the '.'
+
+  if (pos >= size) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time format: fractional seconds incomplete"));
+  }
+
+  // Parse fractional seconds (milliseconds)
+  int32_t fractionalPart = 0;
+
+  const char* start = data + pos;
+  const char* end = data + size;
+
+  auto parseResult = std::from_chars(start, end, fractionalPart);
+  if (parseResult.ec != std::errc{}) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time format: failed to parse fractional seconds"));
+  }
+
+  size_t digitCount = parseResult.ptr - start;
+  pos += digitCount;
+
+  // Check that we don't have more than 3 digits (millisecond precision)
+  if (digitCount > 3) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time format: Microsecond precision not supported"));
+  }
+
+  // Convert to milliseconds by padding with zeros if needed
+  // e.g., .1 -> 100ms, .12 -> 120ms, .123 -> 123ms
+  for (size_t i = digitCount; i < 3; i++) {
+    fractionalPart *= 10;
+  }
+
+  return fractionalPart;
+}
+
+// Helper: Validate time components
+Status validateTimeComponents(const TimeComponents& components) {
+  if (components.hour < 0 || components.hour >= kHoursPerDay) {
+    return Status::UserError("Invalid hour value: {}", components.hour);
+  }
+  if (components.minute < 0 || components.minute >= kMinsPerHour) {
+    return Status::UserError("Invalid minute value: {}", components.minute);
+  }
+  if (components.second < 0 || components.second >= kSecsPerMinute) {
+    return Status::UserError("Invalid second value: {}", components.second);
+  }
+  if (components.millis < 0 || components.millis >= kMsecsPerSec) {
+    return Status::UserError(
+        "Invalid millisecond value: {}", components.millis);
+  }
+  return Status::OK();
+}
+
+// Helper: Convert time components to milliseconds since midnight
+Expected<int64_t> timeComponentsToMillis(const TimeComponents& components) {
+  int64_t result = static_cast<int64_t>(components.hour) * kMillisInHour +
+      static_cast<int64_t>(components.minute) * kMillisInMinute +
+      static_cast<int64_t>(components.second) * kMillisInSecond +
+      static_cast<int64_t>(components.millis);
+
+  // Validate time range (0 to 86399999 ms in a day)
+  if (result < 0 || result >= kMillisInDay) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Time value {} is out of range [0, {})", result, kMillisInDay));
+  }
+
+  return result;
+}
+
+// Helper: Parse time components from string (H:m[:s[.SSS]])
+Expected<TimeComponents> parseTimeComponents(const char* buf, size_t len) {
+  TimeComponents components;
+  size_t pos = 0;
+
+  // Parse hour (required, 1-2 digits)
+  if (!parseNumber(buf, len, pos, components.hour)) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid time format: failed to parse hour"));
+  }
+
+  // Skip first ':'
+  if (pos >= len || buf[pos] != ':') {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid time format: expected ':' after hour"));
+  }
+  pos++;
+
+  // Parse minute (required, 1-2 digits)
+  if (!parseNumber(buf, len, pos, components.minute)) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid time format: failed to parse minute"));
+  }
+
+  // Check if there's a second ':' for seconds (OPTIONAL)
+  if (pos < len && buf[pos] == ':') {
+    pos++; // Skip the ':'
+
+    // Parse second (optional, 1-2 digits)
+    if (!parseNumber(buf, len, pos, components.second)) {
+      return folly::makeUnexpected(
+          Status::UserError("Invalid time format: failed to parse second"));
+    }
+
+    // Parse optional fractional seconds
+    auto millisResult = parseFractionalSeconds(buf, len, pos);
+    if (millisResult.hasError()) {
+      return folly::makeUnexpected(millisResult.error());
+    }
+    components.millis = millisResult.value();
+  }
+  // If no second ':', seconds and millis remain at 0 (default)
+
+  // Check for trailing characters
+  if (pos < len) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time format: unexpected trailing characters at position {}",
+            pos));
+  }
+
+  return components;
+}
+
+} // namespace
+
+Expected<int64_t> fromTimeString(const char* buf, size_t len) {
+  auto componentsResult = parseTimeComponents(buf, len);
+  if (componentsResult.hasError()) {
+    return folly::makeUnexpected(componentsResult.error());
+  }
+
+  auto components = componentsResult.value();
+
+  // Validate all components
+  auto validationStatus = validateTimeComponents(components);
+  if (!validationStatus.ok()) {
+    return folly::makeUnexpected(validationStatus);
+  }
+
+  // Convert to milliseconds since midnight
+  return timeComponentsToMillis(components);
+}
+
+Expected<int16_t>
+parseTimezoneOffset(const char* buf, size_t len, bool allowCompactFormat) {
+  if (len < 2) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid timezone offset: too short"));
+  }
+
+  char sign = buf[0];
+  if (sign != '+' && sign != '-') {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid timezone offset: must start with + or -"));
+  }
+
+  int signMultiplier = (sign == '+') ? 1 : -1;
+
+  // Start parsing after the sign
+  size_t pos = 1;
+  const size_t startPos = pos;
+
+  // Parse offset hours/minutes
+  // Supports formats based on allowCompactFormat flag:
+  // Always supported:
+  //   1. +HH:mm (e.g., +07:09) - colon separates hours and minutes
+  //   2. +HH (e.g., +07) - exactly 2 digits, no colon
+  // Conditionally supported (allowCompactFormat=true):
+  //   3. +HHmm (e.g., +0709) - exactly 4 digits, no colon
+
+  int32_t offsetHours = 0;
+  int32_t offsetMinutes = 0;
+
+  // Try to parse as many digits as we can for hours
+  if (!parseNumber(buf, len, pos, offsetHours)) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid timezone offset: failed to parse hours"));
+  }
+
+  size_t digitsRead = pos - startPos;
+
+  // Check what comes next
+  if (pos < len && buf[pos] == ':') {
+    // Format: +HH:mm
+    // Hours should be 2 digits only when followed by colon
+    if (digitsRead != 2) {
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Invalid timezone offset format: digits before ':' not equal to 2"));
+    }
+    pos++; // Skip ':'
+    if (!parseNumber(buf, len, pos, offsetMinutes)) {
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Invalid timezone offset: failed to parse minutes after ':'"));
+    }
+  } else if (digitsRead == 4) {
+    // Format: +HHmm (e.g., +0709)
+    // Only allowed if allowCompactFormat is true
+    if (!allowCompactFormat) {
+      return folly::makeUnexpected(
+          Status::UserError(
+              "Invalid timezone offset format: compact format +HHmm not allowed, use +HH:mm or +HH"));
+    }
+    // Extract last 2 digits as minutes
+    offsetMinutes = offsetHours % 100;
+    offsetHours = offsetHours / 100;
+  } else if (digitsRead != 2) {
+    // Valid : 2
+    //    Format: +HH (e.g., +07)
+    //    Minutes remain 0
+    // Invalid: 1, 3, or 5+ digits without colon
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid timezone offset format: expected +HH:mm or +HH"));
+  }
+
+  // Check for trailing characters
+  if (pos < len) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid timezone offset: unexpected trailing characters at position {}",
+            pos));
+  }
+
+  // Calculate total offset in minutes
+  auto totalOffsetMinutes =
+      (signMultiplier * (offsetHours * 60 + offsetMinutes));
+
+  // Validate timezone offset range (-840 to 840 minutes, i.e., -14:00 to
+  // +14:00)
+  if (totalOffsetMinutes < -kTimeZoneBias ||
+      totalOffsetMinutes > kTimeZoneBias) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Timezone offset {} minutes is out of range [-840, 840]",
+            totalOffsetMinutes));
+  }
+
+  return static_cast<int16_t>(totalOffsetMinutes);
+}
+
+Expected<int64_t> fromTimeWithTimezoneString(
+    const char* buf,
+    size_t len,
+    bool allowCompactFormat) {
+  if (len == 0) {
+    return folly::makeUnexpected(
+        Status::UserError("Invalid time with timezone: empty string"));
+  }
+
+  // Find timezone offset marker (+ or -)
+  // Search from right to left for better performance
+  std::string_view sv(buf, len);
+  auto tzPos = sv.find_last_of("+-");
+  int tzStartPos =
+      (tzPos != std::string_view::npos) ? static_cast<int>(tzPos) : -1;
+
+  if (tzStartPos == -1) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time with timezone: missing timezone offset"));
+  }
+
+  // Extract time component (before timezone, trimming optional space)
+  int timeEndPos = tzStartPos;
+  if (timeEndPos > 0 && buf[timeEndPos - 1] == ' ') {
+    timeEndPos--; // Remove space before timezone
+  }
+
+  if (timeEndPos == 0) {
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Invalid time with timezone: missing time component"));
+  }
+
+  // Parse time component
+  auto timeResult = fromTimeString(buf, timeEndPos);
+  if (timeResult.hasError()) {
+    return folly::makeUnexpected(timeResult.error());
+  }
+
+  int64_t millisLocal = timeResult.value();
+
+  // Parse timezone offset, passing through the allowCompactFormat flag
+  auto tzOffsetResult = parseTimezoneOffset(
+      buf + tzStartPos, len - tzStartPos, allowCompactFormat);
+  if (tzOffsetResult.hasError()) {
+    return folly::makeUnexpected(tzOffsetResult.error());
+  }
+
+  int16_t offsetMinutes = tzOffsetResult.value();
+
+  // Convert local time to UTC using utility function
+  // Example: 12:00:00+05:30 means the local time is 12:00 in UTC+5:30
+  // To get UTC time, we subtract 5:30, resulting in 06:30:00 UTC
+  int64_t millisUtc = localToUtcTime(millisLocal, offsetMinutes);
+
+  // Encode timezone offset and pack with time
+  int16_t encodedTimezone = biasEncode(offsetMinutes);
+  return pack(millisUtc, encodedTimezone);
+}
+
+} // namespace facebook::velox::util
diff --git a/velox/type/Time.h b/velox/type/Time.h
new file mode 100644
index 000000000000..d0329d929014
--- /dev/null
+++ b/velox/type/Time.h
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS 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/Status.h"
+#include "velox/type/StringView.h"
+
+namespace facebook::velox::util {
+
+// Constants for time calculations (aligned with TimestampConversion.h)
+constexpr const int64_t kMillisInSecond = 1000;
+constexpr const int64_t kMillisInMinute = 60 * kMillisInSecond;
+constexpr const int64_t kMillisInHour = 60 * kMillisInMinute;
+constexpr const int64_t kMillisInDay = 24 * kMillisInHour;
+
+/// Represents parsed time components
+struct TimeComponents {
+  int32_t hour = 0;
+  int32_t minute = 0;
+  int32_t second = 0;
+  int32_t millis = 0;
+};
+
+/// Parse a TIME string (H:m[:s[.SSS]] format)
+/// Supports formats:
+/// - "H:m" -> "1:30"
+/// - "H:m:s" -> "1:30:45"
+/// - "H:m:s.SSS" -> "1:30:45.123"
+///
+/// Returns milliseconds since midnight (0 to 86399999)
+/// Returns Unexpected with UserError status if parsing fails
+Expected<int64_t> fromTimeString(const char* buf, size_t len);
+
+inline Expected<int64_t> fromTimeString(const StringView& str) {
+  return fromTimeString(str.data(), str.size());
+}
+
+// Constants for TIME WITH TIME ZONE encoding
+constexpr int32_t kMillisShift = 12;
+constexpr int32_t kTimezoneMask = (1 << kMillisShift) - 1;
+constexpr int16_t kTimeZoneBias = 840;
+constexpr int16_t kMinutesInHour = 60;
+
+/// Unpacks the milliseconds since midnight from a packed TIME WITH TIME ZONE
+/// value
+inline int64_t unpackMillisUtc(int64_t timeWithTimeZone) {
+  return timeWithTimeZone >> kMillisShift;
+}
+
+/// Unpacks the timezone offset from a packed TIME WITH TIME ZONE value
+inline int16_t unpackZoneOffset(int64_t timeWithTimeZone) {
+  return timeWithTimeZone & kTimezoneMask;
+}
+
+/// Packs milliseconds since midnight and timezone offset into a 64-bit value
+/// The packed value stores time in the upper bits and timezone in the lower 12
+/// bits
+inline int64_t pack(int64_t millisUtc, int16_t timeZoneKey) {
+  return (millisUtc << kMillisShift) | (timeZoneKey & kTimezoneMask);
+}
+
+/// Encodes timezone offset using bias encoding to ensure positive values
+/// This aligns with the bias encoding used in Presto for offsets
+/// Converts timezone offset from range [-840, 840] to [0, 1680]
+/// 0 -> 0
+/// [-840, -1] -> [1, 840]
+/// [1, 840] -> [841, 1680]
+inline int16_t biasEncode(int16_t timeZoneOffsetMinutes) {
+  VELOX_CHECK(
+      -kTimeZoneBias <= timeZoneOffsetMinutes &&
+          timeZoneOffsetMinutes <= kTimeZoneBias,
+      "Timezone offset must be between -840 and 840 minutes. Got: {}",
+      timeZoneOffsetMinutes);
+
+  if (timeZoneOffsetMinutes == 0) {
+    return 0;
+  }
+  if (timeZoneOffsetMinutes < 0) {
+    return timeZoneOffsetMinutes + kTimeZoneBias + 1;
+  }
+  return timeZoneOffsetMinutes + kTimeZoneBias;
+}
+
+/// Decode timezone offset from bias-encoded value
+/// Converts from bias-encoded range [0, 1680] to signed offset [-840, 840]
+/// This is the inverse of biasEncode():
+///   - 0 → 0 (UTC)
+///   - [1, 840] → [-840, -1] (negative offsets)
+///   - [841, 1680] → [1, 840] (positive offsets)
+///
+/// @param encodedTimezone Bias-encoded timezone [0, 1680]
+/// @return Timezone offset in minutes [-840, 840]
+inline int16_t decodeTimezoneOffset(int16_t encodedTimezone) {
+  if (encodedTimezone == 0) {
+    return 0;
+  }
+  if (encodedTimezone <= kTimeZoneBias) {
+    return encodedTimezone - kTimeZoneBias - 1;
+  }
+  return encodedTimezone - kTimeZoneBias;
+}
+
+/// Parse a TIME WITH TIME ZONE string and return packed 64-bit value
+/// Supports formats (with optional space before timezone):
+/// - "H:m+HH:mm" or "H:m +HH:mm" -> "1:30+05:30" or "1:30 +05:30"
+/// - "H:m:s+HH:mm" or "H:m:s +HH:mm" -> "1:30:45+05:30"
+/// - "H:m:s.SSS+HH:mm" -> "1:30:45.123+05:30"
+/// - "H:m+HHmm" -> "1:30+0530" (only if allowCompactFormat=true)
+/// - "H:m+HH" or "H:m +HH" -> "1:30+05" or "1:30 +05"
+/// - "H:m:s+HH" -> "1:30:45+05"
+/// - "H:m:s.SSS+HH" -> "1:30:45.123+05"
+///
+/// @param buf Pointer to the TIME WITH TIME ZONE string
+/// @param len Length of the string
+/// @param allowCompactFormat If true, accepts +HHmm format for timezone offset.
+///                           Default is true for backward compatibility.
+/// @return Packed 64-bit value where the upper bits contain milliseconds
+///         since midnight and the lower 12 bits contain the bias-encoded
+///         timezone offset.
+/// @return Unexpected with UserError status if parsing fails
+Expected<int64_t> fromTimeWithTimezoneString(
+    const char* buf,
+    size_t len,
+    bool allowCompactFormat = true);
+
+inline Expected<int64_t> fromTimeWithTimezoneString(
+    const StringView& str,
+    bool allowCompactFormat = true) {
+  return fromTimeWithTimezoneString(str.data(), str.size(), allowCompactFormat);
+}
+
+/// Parse timezone offset from string
+/// Supports formats:
+/// - "+HH:mm" or "-HH:mm" -> "+05:30", "-08:00"
+/// - "+HH" or "-HH" -> "+05", "-08"
+/// - "+HHmm" or "-HHmm" -> "+0530", "-0800" (only if allowCompactFormat=true)
+///
+/// @param buf Pointer to the timezone offset string
+/// @param len Length of the string
+/// @param allowCompactFormat If true, accepts +HHmm format in addition to
+///                           Presto-compatible formats (+HH:mm, +HH).
+///                           Default is true for backward compatibility.
+/// @return Timezone offset in minutes (-840 to 840)
+/// @return Unexpected with UserError status if parsing fails
+Expected<int16_t> parseTimezoneOffset(
+    const char* buf,
+    size_t len,
+    bool allowCompactFormat = true);
+
+inline Expected<int16_t> parseTimezoneOffset(
+    const StringView& str,
+    bool allowCompactFormat = true) {
+  return parseTimezoneOffset(str.data(), str.size(), allowCompactFormat);
+}
+
+/// Convert UTC time to local time by adding timezone offset
+/// Handles day boundary wrap-around (since max timezone offset is ±14 hours,
+/// only one day boundary crossing is possible)
+///
+/// @param millisUtc UTC time in milliseconds since midnight [0, kMillisInDay)
+/// @param offsetMinutes Timezone offset in minutes [-840, 840]
+/// @return Local time in milliseconds since midnight [0, kMillisInDay)
+inline int64_t utcToLocalTime(int64_t millisUtc, int16_t offsetMinutes) {
+  VELOX_DCHECK_GE(millisUtc, 0);
+  VELOX_DCHECK_LT(millisUtc, kMillisInDay);
+  int64_t millisLocal = millisUtc + (offsetMinutes * kMillisInMinute);
+
+  // Handle wrap-around for local time
+  if (millisLocal < 0) {
+    millisLocal += kMillisInDay;
+  } else if (millisLocal >= kMillisInDay) {
+    millisLocal -= kMillisInDay;
+  }
+
+  return millisLocal;
+}
+
+/// Convert local time to UTC by subtracting timezone offset
+/// Handles day boundary wrap-around (since max timezone offset is ±14 hours,
+/// only one day boundary crossing is possible)
+///
+/// @param millisLocal Local time in milliseconds since midnight [0,
+/// kMillisInDay)
+/// @param offsetMinutes Timezone offset in minutes [-840, 840]
+/// @return UTC time in milliseconds since midnight [0, kMillisInDay)
+inline int64_t localToUtcTime(int64_t millisLocal, int16_t offsetMinutes) {
+  int64_t millisUtc = millisLocal - (offsetMinutes * kMillisInMinute);
+
+  // Handle wrap-around for UTC time
+  if (millisUtc < 0) {
+    millisUtc += kMillisInDay;
+  } else if (millisUtc >= kMillisInDay) {
+    millisUtc -= kMillisInDay;
+  }
+
+  return millisUtc;
+}
+
+} // namespace facebook::velox::util
diff --git a/velox/type/Timestamp.cpp b/velox/type/Timestamp.cpp
index e159596cab99..b19225415d3f 100644
--- a/velox/type/Timestamp.cpp
+++ b/velox/type/Timestamp.cpp
@@ -202,7 +202,7 @@ StringView Timestamp::tmToStringView(
     uint64_t nanos,
     const TimestampToStringOptions& options,
     char* const startPosition) {
-  VELOX_DCHECK_LT(nanos, 1'000'000'000);
+  VELOX_CHECK_LT(nanos, 1'000'000'000);
 
   const auto appendDigits = [](const int value,
                                const std::optional<uint32_t> minWidth,
@@ -352,10 +352,6 @@ std::string::size_type getMaxStringLength(
   }
 }
 
-void parseTo(folly::StringPiece in, ::facebook::velox::Timestamp& out) {
-  // TODO Implement
-}
-
 } // namespace facebook::velox
 
 namespace std {
diff --git a/velox/type/Timestamp.h b/velox/type/Timestamp.h
index 05d8e4533451..bd749f11420f 100644
--- a/velox/type/Timestamp.h
+++ b/velox/type/Timestamp.h
@@ -358,12 +358,12 @@ struct Timestamp {
       const TimestampToStringOptions& options,
       char* const startPosition);
 
-  // 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
+  /// 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
@@ -377,33 +377,8 @@ struct Timestamp {
   /// 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_;
-  }
-
-  bool operator!=(const Timestamp& b) const {
-    return seconds_ != b.seconds_ || nanos_ != b.nanos_;
-  }
-
-  bool operator<(const Timestamp& b) const {
-    return seconds_ < b.seconds_ ||
-        (seconds_ == b.seconds_ && nanos_ < b.nanos_);
-  }
-
-  bool operator<=(const Timestamp& b) const {
-    return seconds_ < b.seconds_ ||
-        (seconds_ == b.seconds_ && nanos_ <= b.nanos_);
-  }
-
-  bool operator>(const Timestamp& b) const {
-    return seconds_ > b.seconds_ ||
-        (seconds_ == b.seconds_ && nanos_ > b.nanos_);
-  }
-
-  bool operator>=(const Timestamp& b) const {
-    return seconds_ > b.seconds_ ||
-        (seconds_ == b.seconds_ && nanos_ >= b.nanos_);
-  }
+  bool operator==(const Timestamp& b) const = default;
+  auto operator<=>(const Timestamp& b) const = default;
 
   void operator++() {
     if (nanos_ < kMaxNanos) {
@@ -474,8 +449,6 @@ struct Timestamp {
   uint64_t nanos_;
 };
 
-void parseTo(folly::StringPiece in, ::facebook::velox::Timestamp& out);
-
 template <typename T>
 void toAppend(const ::facebook::velox::Timestamp& value, T* result) {
   result->append(value.toString());
diff --git a/velox/type/TimestampConversion.cpp b/velox/type/TimestampConversion.cpp
index 0cdef8a3dde7..11c182b90b23 100644
--- a/velox/type/TimestampConversion.cpp
+++ b/velox/type/TimestampConversion.cpp
@@ -776,8 +776,9 @@ Expected<int64_t> daysSinceEpochFromWeekDate(
     if (threadSkipErrorDetails()) {
       return folly::makeUnexpected(Status::UserError());
     }
-    return folly::makeUnexpected(Status::UserError(
-        "Date out of range: {}-{}-{}", weekYear, weekOfYear, dayOfWeek));
+    return folly::makeUnexpected(
+        Status::UserError(
+            "Date out of range: {}-{}-{}", weekYear, weekOfYear, dayOfWeek));
   }
 
   return daysSinceEpochFromDate(weekYear, 1, 4)
@@ -801,8 +802,13 @@ Expected<int64_t> daysSinceEpochFromWeekOfMonthDate(
     if (threadSkipErrorDetails()) {
       return folly::makeUnexpected(Status::UserError());
     }
-    return folly::makeUnexpected(Status::UserError(
-        "Date out of range: {}-{}-{}-{}", year, month, weekOfMonth, dayOfWeek));
+    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,
@@ -860,27 +866,30 @@ Expected<int32_t> fromDateString(const char* str, size_t len, ParseMode mode) {
 
     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)));
+        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)));
+        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)));
+        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();
     }
diff --git a/velox/type/Tokenizer.cpp b/velox/type/Tokenizer.cpp
index 24505ab32a76..06196c5d6ec9 100644
--- a/velox/type/Tokenizer.cpp
+++ b/velox/type/Tokenizer.cpp
@@ -19,14 +19,11 @@ namespace facebook::velox::common {
 
 Tokenizer::Tokenizer(
     const std::string& path,
-    const std::shared_ptr<Separators>& separators)
-    : path_(path), separators_(separators) {
-  state = State::kNotReady;
-  index_ = 0;
-}
+    std::shared_ptr<const Separators> separators)
+    : path_{path}, separators_{std::move(separators)} {}
 
 bool Tokenizer::hasNext() {
-  switch (state) {
+  switch (state_) {
     case State::kDone:
       return false;
     case State::kReady:
@@ -43,7 +40,7 @@ std::unique_ptr<Subfield::PathElement> Tokenizer::next() {
   if (!hasNext()) {
     VELOX_FAIL("No more tokens");
   }
-  state = State::kNotReady;
+  state_ = State::kNotReady;
   return std::move(next_);
 }
 
@@ -53,30 +50,33 @@ bool Tokenizer::hasNextCharacter() {
 
 std::unique_ptr<Subfield::PathElement> Tokenizer::computeNext() {
   if (!hasNextCharacter()) {
-    state = State::kDone;
+    state_ = State::kDone;
     return nullptr;
   }
 
   if (tryMatchSeparator(separators_->dot)) {
-    std::unique_ptr<Subfield::PathElement> token = matchPathSegment();
-    firstSegment = false;
+    auto token = matchPathSegment();
+    firstSegment_ = false;
     return token;
   }
 
   if (tryMatchSeparator(separators_->openBracket)) {
-    std::unique_ptr<Subfield::PathElement> token =
-        tryMatchSeparator(separators_->quote)      ? matchQuotedSubscript()
-        : tryMatchSeparator(separators_->wildCard) ? matchWildcardSubscript()
-                                                   : matchUnquotedSubscript();
+    // These empty comments only needs to make clang-format happy.
+    auto token = //
+        tryMatchSeparator(separators_->quote) //
+        ? matchQuotedSubscript()
+        : tryMatchSeparator(separators_->wildCard) //
+            ? matchWildcardSubscript()
+            : matchUnquotedSubscript();
 
     match(separators_->closeBracket);
-    firstSegment = false;
+    firstSegment_ = false;
     return token;
   }
 
-  if (firstSegment) {
-    std::unique_ptr<Subfield::PathElement> token = matchPathSegment();
-    firstSegment = false;
+  if (firstSegment_) {
+    auto token = matchPathSegment();
+    firstSegment_ = false;
     return token;
   }
 
@@ -214,10 +214,10 @@ std::string Tokenizer::toString() {
 }
 
 bool Tokenizer::tryToComputeNext() {
-  state = State::kFailed; // temporary pessimism
+  state_ = State::kFailed; // temporary pessimism
   next_ = computeNext();
-  if (state != State::kDone) {
-    state = State::kReady;
+  if (state_ != State::kDone) {
+    state_ = State::kReady;
     return true;
   }
   return false;
diff --git a/velox/type/Tokenizer.h b/velox/type/Tokenizer.h
index 9b14d532449c..a02440bc6dfc 100644
--- a/velox/type/Tokenizer.h
+++ b/velox/type/Tokenizer.h
@@ -38,7 +38,7 @@ class Tokenizer {
   // Separators: the customized separators to tokenize field name.
   explicit Tokenizer(
       const std::string& path,
-      const std::shared_ptr<Separators>& separators);
+      std::shared_ptr<const Separators> separators);
 
   bool hasNext();
 
@@ -47,11 +47,11 @@ class Tokenizer {
  private:
   const std::string path_;
   // Customized separators to tokenize field name.
-  std::shared_ptr<Separators> separators_;
+  std::shared_ptr<const Separators> separators_;
 
-  int index_;
-  State state;
-  bool firstSegment = true;
+  int index_ = 0;
+  State state_ = State::kNotReady;
+  bool firstSegment_ = true;
   std::unique_ptr<Subfield::PathElement> next_;
 
   bool hasNextCharacter();
diff --git a/velox/type/Tree.h b/velox/type/Tree.h
index 269553f911e7..56c27804e6f1 100644
--- a/velox/type/Tree.h
+++ b/velox/type/Tree.h
@@ -60,10 +60,6 @@ class TreeIterator {
     return &tree_ == &rhs.tree_ && idx_ == rhs.idx_;
   }
 
-  bool operator!=(const self_type& rhs) const {
-    return (&tree_ != &(rhs.tree_)) || idx_ != rhs.idx_;
-  }
-
  private:
   const Tree<T>& tree_;
   size_t idx_;
diff --git a/velox/type/Type.cpp b/velox/type/Type.cpp
index 2b57ba543e40..bd89e8ec8f90 100644
--- a/velox/type/Type.cpp
+++ b/velox/type/Type.cpp
@@ -24,6 +24,9 @@
 #include <sstream>
 #include <typeindex>
 
+#include "velox/external/tzdb/exception.h"
+#include "velox/type/DecimalUtil.h"
+#include "velox/type/Time.h"
 #include "velox/type/TimestampConversion.h"
 
 namespace std {
@@ -35,62 +38,15 @@ struct hash<facebook::velox::TypeKind> {
 };
 } // namespace std
 
+namespace facebook::velox {
 namespace {
 bool isColumnNameRequiringEscaping(const std::string& name) {
   static const std::string re("^[a-zA-Z_][a-zA-Z0-9_]*$");
   return !RE2::FullMatch(name, re);
 }
-} // namespace
-
-namespace facebook::velox {
-
-// Static variable intialization is not thread safe for non
-// constant-initialization, but scoped static initialization is thread safe.
-const std::unordered_map<std::string, TypeKind>& getTypeStringMap() {
-  static const std::unordered_map<std::string, TypeKind> kTypeStringMap{
-      {"BOOLEAN", TypeKind::BOOLEAN},
-      {"TINYINT", TypeKind::TINYINT},
-      {"SMALLINT", TypeKind::SMALLINT},
-      {"INTEGER", TypeKind::INTEGER},
-      {"BIGINT", TypeKind::BIGINT},
-      {"HUGEINT", TypeKind::HUGEINT},
-      {"REAL", TypeKind::REAL},
-      {"DOUBLE", TypeKind::DOUBLE},
-      {"VARCHAR", TypeKind::VARCHAR},
-      {"VARBINARY", TypeKind::VARBINARY},
-      {"TIMESTAMP", TypeKind::TIMESTAMP},
-      {"ARRAY", TypeKind::ARRAY},
-      {"MAP", TypeKind::MAP},
-      {"ROW", TypeKind::ROW},
-      {"FUNCTION", TypeKind::FUNCTION},
-      {"UNKNOWN", TypeKind::UNKNOWN},
-      {"OPAQUE", TypeKind::OPAQUE},
-      {"INVALID", TypeKind::INVALID}};
-  return kTypeStringMap;
-}
-
-std::optional<TypeKind> tryMapNameToTypeKind(const std::string& name) {
-  auto found = getTypeStringMap().find(name);
-
-  if (found == getTypeStringMap().end()) {
-    return std::nullopt;
-  }
 
-  return found->second;
-}
-
-TypeKind mapNameToTypeKind(const std::string& name) {
-  auto found = getTypeStringMap().find(name);
-
-  if (found == getTypeStringMap().end()) {
-    VELOX_USER_FAIL("Specified element is not found : {}", name);
-  }
-
-  return found->second;
-}
-
-std::string mapTypeKindToName(const TypeKind& typeKind) {
-  static std::unordered_map<TypeKind, std::string> typeEnumMap{
+const auto& typeKindNames() {
+  static const folly::F14FastMap<TypeKind, std::string_view> kNames = {
       {TypeKind::BOOLEAN, "BOOLEAN"},
       {TypeKind::TINYINT, "TINYINT"},
       {TypeKind::SMALLINT, "SMALLINT"},
@@ -108,16 +64,13 @@ std::string mapTypeKindToName(const TypeKind& typeKind) {
       {TypeKind::FUNCTION, "FUNCTION"},
       {TypeKind::UNKNOWN, "UNKNOWN"},
       {TypeKind::OPAQUE, "OPAQUE"},
-      {TypeKind::INVALID, "INVALID"}};
-
-  auto found = typeEnumMap.find(typeKind);
-
-  if (found == typeEnumMap.end()) {
-    VELOX_USER_FAIL("Specified element is not found : {}", (int32_t)typeKind);
-  }
-
-  return found->second;
+      {TypeKind::INVALID, "INVALID"},
+  };
+  return kNames;
 }
+} // namespace
+
+VELOX_DEFINE_ENUM_NAME(TypeKind, typeKindNames);
 
 std::pair<uint8_t, uint8_t> getDecimalPrecisionScale(const Type& type) {
   if (type.isShortDecimal()) {
@@ -148,17 +101,93 @@ struct OpaqueSerdeRegistry {
 };
 } // namespace
 
-std::ostream& operator<<(std::ostream& os, const TypeKind& kind) {
-  os << mapTypeKindToName(kind);
-  return os;
-}
-
 namespace {
 std::vector<TypePtr> deserializeChildTypes(const folly::dynamic& obj) {
   return velox::ISerializable::deserialize<std::vector<Type>>(obj["cTypes"]);
 }
+
+template <typename TValue>
+folly::dynamic serializeEnumParam(
+    const std::string& name,
+    const std::unordered_map<std::string, TValue>& valuesMap) {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["enumName"] = name;
+  folly::dynamic follyMap = folly::dynamic::object;
+  for (const auto& [key, value] : valuesMap) {
+    follyMap[key] = value;
+  }
+  obj["valuesMap"] = follyMap;
+  return obj;
+}
+
+template <typename TValue>
+TypeParameter deserializeEnumParam(const folly::dynamic& obj) {
+  auto enumName = obj["enumName"].asString();
+  VELOX_CHECK(obj["valuesMap"].isObject());
+  auto valuesMap = obj["valuesMap"];
+
+  // Construct the values map
+  std::unordered_map<std::string, TValue> map;
+  for (const auto& item : valuesMap.items()) {
+    std::string key = item.first.asString();
+    if constexpr (std::is_same_v<TValue, int64_t>) {
+      int64_t value = item.second.asInt();
+      map.emplace(std::move(key), value);
+    } else if constexpr (std::is_same_v<TValue, std::string>) {
+      std::string value = item.second.asString();
+      map.emplace(std::move(key), std::move(value));
+    } else {
+      VELOX_UNREACHABLE(
+          "Only int64_t and std::string value types are supported for enum types.");
+    }
+  }
+
+  // Construct the corresponding TypeParameter
+  if constexpr (std::is_same_v<TValue, int64_t>) {
+    return TypeParameter(LongEnumParameter(enumName, map));
+  } else if constexpr (std::is_same_v<TValue, std::string>) {
+    return TypeParameter(VarcharEnumParameter(enumName, map));
+  }
+  VELOX_UNREACHABLE(
+      "Only int64_t and std::string value types are supported for enum types.");
+}
+
+template <typename TParameter>
+size_t hashEnumParam(const TParameter& param) {
+  uint64_t nameHash = folly::Hash{}(param.name);
+
+  // Hash each key-value pair and combine using commutativeHashMix
+  // to ensure order independence.
+  uint64_t mapHash = facebook::velox::bits::kNullHash;
+  for (const auto& [key, value] : param.valuesMap) {
+    const auto elementHash = facebook::velox::bits::hashMix(
+        folly::Hash{}(key), folly::Hash{}(value));
+    mapHash = facebook::velox::bits::commutativeHashMix(mapHash, elementHash);
+  }
+
+  // Combine name hash with map hash.
+  return facebook::velox::bits::hashMix(nameHash, mapHash);
+}
 } // namespace
 
+folly::dynamic LongEnumParameter::serialize() const {
+  return serializeEnumParam<int64_t>(name, valuesMap);
+}
+
+size_t LongEnumParameter::Hash::operator()(
+    const LongEnumParameter& param) const {
+  return hashEnumParam<LongEnumParameter>(param);
+}
+
+folly::dynamic VarcharEnumParameter::serialize() const {
+  return serializeEnumParam<std::string>(name, valuesMap);
+}
+
+size_t VarcharEnumParameter::Hash::operator()(
+    const VarcharEnumParameter& param) const {
+  return hashEnumParam<VarcharEnumParameter>(param);
+}
+
 TypePtr Type::create(const folly::dynamic& obj) {
   if (obj.find("ref") != obj.items().end()) {
     const auto id = obj["ref"].asInt();
@@ -177,15 +206,24 @@ TypePtr Type::create(const folly::dynamic& obj) {
   // Checks if 'typeName' specifies a custom type.
   if (customTypeExists(typeName)) {
     std::vector<TypeParameter> params;
-    params.reserve(childTypes.size());
-    for (auto& child : childTypes) {
-      params.emplace_back(child);
+    if (obj.find("cTypes") != obj.items().end()) {
+      params.reserve(childTypes.size());
+      for (auto& child : childTypes) {
+        params.emplace_back(child);
+      }
+    }
+    if (obj.find("kLongEnumParam") != obj.items().end()) {
+      params.emplace_back(deserializeEnumParam<int64_t>(obj["kLongEnumParam"]));
+    }
+    if (obj.find("kVarcharEnumParam") != obj.items().end()) {
+      params.emplace_back(
+          deserializeEnumParam<std::string>(obj["kVarcharEnumParam"]));
     }
     return getCustomType(typeName, params);
   }
 
   // 'typeName' must be a built-in type.
-  TypeKind typeKind = mapNameToTypeKind(typeName);
+  TypeKind typeKind = TypeKindName::toTypeKind(typeName);
   switch (typeKind) {
     case TypeKind::ROW: {
       VELOX_USER_CHECK(obj["names"].isArray());
@@ -194,8 +232,7 @@ TypePtr Type::create(const folly::dynamic& obj) {
         names.push_back(name.asString());
       }
 
-      return std::make_shared<const RowType>(
-          std::move(names), std::move(childTypes));
+      return ROW(std::move(names), std::move(childTypes));
     }
 
     case TypeKind::OPAQUE: {
@@ -228,6 +265,7 @@ void Type::registerSerDe() {
   registry.Register(
       "IntervalYearMonthType", IntervalYearMonthType::deserialize);
   registry.Register("DateType", DateType::deserialize);
+  registry.Register("TimeType", TimeType::deserialize);
 }
 
 std::string ArrayType::toString() const {
@@ -240,7 +278,7 @@ const TypePtr& ArrayType::childAt(uint32_t idx) const {
 }
 
 ArrayType::ArrayType(TypePtr child)
-    : child_{std::move(child)}, parameters_{{TypeParameter(child_)}} {}
+    : child_{std::move(child)}, parameter_{child_} {}
 
 bool ArrayType::equivalent(const Type& other) const {
   if (&other == this) {
@@ -301,7 +339,7 @@ const char* MapType::nameOf(uint32_t idx) const {
 MapType::MapType(TypePtr keyType, TypePtr valueType)
     : keyType_{std::move(keyType)},
       valueType_{std::move(valueType)},
-      parameters_{{TypeParameter(keyType_), TypeParameter(valueType_)}} {}
+      parameters_{TypeParameter(keyType_), TypeParameter(valueType_)} {}
 
 std::string MapType::toString() const {
   return "MAP<" + keyType()->toString() + "," + valueType()->toString() + ">";
@@ -375,14 +413,50 @@ RowType::RowType(std::vector<std::string>&& names, std::vector<TypePtr>&& types)
 }
 
 RowType::~RowType() {
-  if (auto* parameters = parameters_.load()) {
-    delete parameters;
-  }
+  auto* parameters = parameters_.load(std::memory_order_acquire);
+  delete parameters;
+
+  auto* nameToIndex = nameToIndex_.load(std::memory_order_acquire);
+  delete nameToIndex;
 }
 
-std::unique_ptr<std::vector<TypeParameter>> RowType::makeParameters() const {
-  return std::make_unique<std::vector<TypeParameter>>(
+const std::vector<TypeParameter>* RowType::ensureParameters() const {
+  auto newParameters = std::make_unique<std::vector<TypeParameter>>(
       createTypeParameters(children_));
+
+  std::vector<TypeParameter>* oldParameters = nullptr;
+  if (!parameters_.compare_exchange_strong(
+          oldParameters,
+          newParameters.get(),
+          std::memory_order_acq_rel,
+          std::memory_order_acquire)) [[unlikely]] {
+    return oldParameters;
+  }
+
+  return newParameters.release();
+}
+
+const RowType::NameToIndex* RowType::ensureNameToIndex() const {
+  auto newNameToIndex = std::make_unique<NameToIndex>();
+  newNameToIndex->reserve(names_.size());
+  for (uint32_t i = 0; const auto& name : names_) {
+    if (auto* oldNameToIndex = nameToIndex_.load(std::memory_order_acquire))
+        [[unlikely]] {
+      return oldNameToIndex;
+    }
+    newNameToIndex->emplace(NameIndex{name, i++});
+  }
+
+  NameToIndex* oldNameToIndex = nullptr;
+  if (!nameToIndex_.compare_exchange_strong(
+          oldNameToIndex,
+          newNameToIndex.get(),
+          std::memory_order_acq_rel,
+          std::memory_order_acquire)) [[unlikely]] {
+    return oldNameToIndex;
+  }
+
+  return newNameToIndex.release();
 }
 
 namespace {
@@ -390,24 +464,31 @@ template <typename T>
 std::string makeFieldNotFoundErrorMessage(
     const T& name,
     const std::vector<std::string>& availableNames) {
+  static constexpr auto kMaxFields = 50;
+
+  const auto numAvailable = availableNames.size();
+
   std::stringstream errorMessage;
   errorMessage << "Field not found: " << name << ". Available fields are: ";
-  for (auto i = 0; i < availableNames.size(); ++i) {
+  for (auto i = 0; i < numAvailable && i < kMaxFields; ++i) {
     if (i > 0) {
       errorMessage << ", ";
     }
     errorMessage << availableNames[i];
   }
+
+  if (numAvailable > kMaxFields) {
+    errorMessage << ", ..." << (numAvailable - kMaxFields) << " more";
+  }
+
   errorMessage << ".";
   return errorMessage.str();
 }
 } // namespace
 
-const TypePtr& RowType::findChild(folly::StringPiece name) const {
-  for (uint32_t i = 0; i < names_.size(); ++i) {
-    if (names_.at(i) == name) {
-      return children_.at(i);
-    }
+const TypePtr& RowType::findChild(std::string_view name) const {
+  if (auto i = getChildIdxIfExists(name)) {
+    return children_[*i];
   }
   VELOX_USER_FAIL(makeFieldNotFoundErrorMessage(name, names_));
 }
@@ -427,7 +508,7 @@ bool RowType::isComparable() const {
 }
 
 bool RowType::containsChild(std::string_view name) const {
-  return std::find(names_.begin(), names_.end(), name) != names_.end();
+  return nameToIndex().contains(NameIndex{name, 0});
 }
 
 uint32_t RowType::getChildIdx(std::string_view name) const {
@@ -440,10 +521,10 @@ uint32_t RowType::getChildIdx(std::string_view name) const {
 
 std::optional<uint32_t> RowType::getChildIdxIfExists(
     std::string_view name) const {
-  for (uint32_t i = 0; i < names_.size(); i++) {
-    if (names_.at(i) == name) {
-      return i;
-    }
+  const auto& nameToIndex = this->nameToIndex();
+  auto it = nameToIndex.find(NameIndex{name, 0});
+  if (it != nameToIndex.end()) {
+    return it->index;
   }
   return std::nullopt;
 }
@@ -514,18 +595,14 @@ void RowType::printChildren(std::stringstream& ss, std::string_view delimiter)
   }
 }
 
-std::shared_ptr<RowType> RowType::unionWith(
-    std::shared_ptr<const RowType> rowType) const {
+RowTypePtr RowType::unionWith(const RowTypePtr& other) const {
   std::vector<std::string> names;
   std::vector<TypePtr> types;
   copy(names_.begin(), names_.end(), back_inserter(names));
-  copy(rowType->names_.begin(), rowType->names_.end(), back_inserter(names));
+  copy(other->names_.begin(), other->names_.end(), back_inserter(names));
   copy(children_.begin(), children_.end(), back_inserter(types));
-  copy(
-      rowType->children_.begin(),
-      rowType->children_.end(),
-      back_inserter(types));
-  return std::make_shared<RowType>(std::move(names), std::move(types));
+  copy(other->children_.begin(), other->children_.end(), back_inserter(types));
+  return ROW(std::move(names), std::move(types));
 }
 
 std::string RowType::toString() const {
@@ -560,8 +637,9 @@ folly::dynamic SerializedTypeCache::serialize() {
   // populated.
   std::vector<std::pair<int32_t, const folly::dynamic*>> cacheEntries;
   for (const auto& [_, pair] : cache_) {
-    cacheEntries.emplace_back(std::make_pair<int32_t, const folly::dynamic*>(
-        (int32_t)pair.first, &pair.second));
+    cacheEntries.emplace_back(
+        std::make_pair<int32_t, const folly::dynamic*>(
+            (int32_t)pair.first, &pair.second));
   }
 
   std::sort(cacheEntries.begin(), cacheEntries.end(), [](auto& a, auto& b) {
@@ -765,9 +843,6 @@ folly::dynamic FunctionType::serialize() const {
   return obj;
 }
 
-OpaqueType::OpaqueType(const std::type_index& typeIndex)
-    : typeIndex_(typeIndex) {}
-
 bool OpaqueType::equivalent(const Type& other) const {
   if (&other == this) {
     return true;
@@ -832,6 +907,15 @@ std::shared_ptr<const OpaqueType> OpaqueType::deserializeExtra(
   return nullptr;
 }
 
+bool OpaqueType::unregisterSerialization(
+    const OpaqueTypePtr& opaqueType,
+    const std::string& persistentName) {
+  VELOX_CHECK_NOT_NULL(opaqueType);
+  auto& registry = OpaqueSerdeRegistry::get();
+  registry.reverse.erase(persistentName);
+  return registry.mapping.erase(opaqueType->typeIndex_);
+}
+
 void OpaqueType::clearSerializationRegistry() {
   auto& registry = OpaqueSerdeRegistry::get();
   registry.mapping.clear();
@@ -862,37 +946,52 @@ void OpaqueType::registerSerializationTypeErased(
   registry.reverse[persistentName] = type;
 }
 
-std::shared_ptr<const ArrayType> ARRAY(TypePtr elementType) {
-  return std::make_shared<const ArrayType>(std::move(elementType));
+ArrayTypePtr ARRAY(TypePtr elementType) {
+  return TypeFactory<TypeKind::ARRAY>::create(std::move(elementType));
 }
 
-std::shared_ptr<const RowType> ROW(
-    std::vector<std::string>&& names,
-    std::vector<TypePtr>&& types) {
+MapTypePtr MAP(TypePtr keyType, TypePtr valueType) {
+  return TypeFactory<TypeKind::MAP>::create(
+      std::move(keyType), std::move(valueType));
+}
+
+RowTypePtr ROW(std::vector<std::string> names, std::vector<TypePtr> types) {
   return TypeFactory<TypeKind::ROW>::create(std::move(names), std::move(types));
 }
 
-std::shared_ptr<const RowType> ROW(
+RowTypePtr ROW(std::vector<std::string> names, const TypePtr& childType) {
+  const auto cnt = names.size();
+  return ROW(std::move(names), std::vector(cnt, childType));
+}
+
+RowTypePtr ROW(
+    std::initializer_list<std::string> names,
+    const TypePtr& childType) {
+  const auto cnt = names.size();
+  return TypeFactory<TypeKind::ROW>::create(
+      std::vector(names), std::vector(cnt, childType));
+}
+
+RowTypePtr ROW(std::string name, TypePtr type) {
+  return ROW({{std::move(name), std::move(type)}});
+}
+
+RowTypePtr ROW(
     std::initializer_list<std::pair<const std::string, TypePtr>>&& pairs) {
-  std::vector<TypePtr> types;
   std::vector<std::string> names;
-  types.reserve(pairs.size());
+  std::vector<TypePtr> types;
   names.reserve(pairs.size());
-  for (auto& p : pairs) {
-    types.push_back(p.second);
-    names.push_back(p.first);
+  types.reserve(pairs.size());
+  for (const auto& [name, type] : pairs) {
+    names.push_back(name);
+    types.push_back(type);
   }
   return TypeFactory<TypeKind::ROW>::create(std::move(names), std::move(types));
 }
 
-std::shared_ptr<const RowType> ROW(std::vector<TypePtr>&& types) {
+RowTypePtr ROW(std::vector<TypePtr>&& types) {
   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));
+  return ROW(std::move(names), std::move(types));
 }
 
 std::shared_ptr<const FunctionType> FUNCTION(
@@ -932,6 +1031,11 @@ TypePtr DECIMAL(const uint8_t precision, const uint8_t scale) {
   return std::make_shared<LongDecimalType>(precision, scale);
 }
 
+// static
+std::string LongDecimalType::toString(int128_t value, const Type& type) {
+  return DecimalUtil::toString(value, type);
+}
+
 TypePtr createScalarType(TypeKind kind) {
   return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(createScalarType, kind);
 }
@@ -942,9 +1046,9 @@ TypePtr createType(TypeKind kind, std::vector<TypePtr>&& children) {
         children.size(),
         1,
         "FUNCTION type should have at least one child type");
-    std::vector<TypePtr> argTypes(
-        children.begin(), children.begin() + children.size() - 1);
-    return std::make_shared<FunctionType>(std::move(argTypes), children.back());
+    auto returnType = std::move(children.back());
+    children.pop_back();
+    return FUNCTION(std::move(children), std::move(returnType));
   }
 
   if (kind == TypeKind::UNKNOWN) {
@@ -1020,10 +1124,10 @@ std::string Type::toSummaryString(TypeSummaryOptions options) const {
 
 namespace {
 
-std::unordered_map<std::string, std::unique_ptr<const CustomTypeFactories>>&
+std::unordered_map<std::string, std::unique_ptr<const CustomTypeFactory>>&
 typeFactories() {
   static std::
-      unordered_map<std::string, std::unique_ptr<const CustomTypeFactories>>
+      unordered_map<std::string, std::unique_ptr<const CustomTypeFactory>>
           factories;
   return factories;
 }
@@ -1044,9 +1148,9 @@ std::unordered_map<std::type_index, std::string>& getOpaqueAliasByTypeIndex() {
 
 bool registerCustomType(
     const std::string& name,
-    std::unique_ptr<const CustomTypeFactories> factories) {
+    std::unique_ptr<const CustomTypeFactory> factory) {
   auto uppercaseName = boost::algorithm::to_upper_copy(name);
-  return typeFactories().emplace(uppercaseName, std::move(factories)).second;
+  return typeFactories().emplace(uppercaseName, std::move(factory)).second;
 }
 
 bool customTypeExists(const std::string& name) {
@@ -1067,8 +1171,8 @@ bool unregisterCustomType(const std::string& name) {
   return typeFactories().erase(uppercaseName) == 1;
 }
 
-const CustomTypeFactories* FOLLY_NULLABLE
-getTypeFactories(const std::string& name) {
+const CustomTypeFactory* FOLLY_NULLABLE
+getTypeFactory(const std::string& name) {
   auto uppercaseName = boost::algorithm::to_upper_copy(name);
   auto it = typeFactories().find(uppercaseName);
 
@@ -1082,33 +1186,33 @@ getTypeFactories(const std::string& name) {
 TypePtr getCustomType(
     const std::string& name,
     const std::vector<TypeParameter>& parameters) {
-  auto factories = getTypeFactories(name);
-  if (factories) {
-    return factories->getType(parameters);
+  auto factory = getTypeFactory(name);
+  if (factory) {
+    return factory->getType(parameters);
   }
 
   return nullptr;
 }
 
 exec::CastOperatorPtr getCustomTypeCastOperator(const std::string& name) {
-  auto factories = getTypeFactories(name);
-  if (factories) {
-    return factories->getCastOperator();
+  auto factory = getTypeFactory(name);
+  if (factory) {
+    return factory->getCastOperator();
   }
 
   return nullptr;
 }
 
-CustomTypeFactories::~CustomTypeFactories() = default;
+CustomTypeFactory::~CustomTypeFactory() = default;
 
 AbstractInputGenerator::~AbstractInputGenerator() = default;
 
 AbstractInputGeneratorPtr getCustomTypeInputGenerator(
     const std::string& name,
     const InputGeneratorConfig& config) {
-  auto factories = getTypeFactories(name);
-  if (factories) {
-    return factories->getInputGenerator(config);
+  auto factory = getTypeFactory(name);
+  if (factory) {
+    return factory->getInputGenerator(config);
   }
 
   return nullptr;
@@ -1222,7 +1326,7 @@ std::string DateType::toIso8601(int32_t days) {
   return result;
 }
 
-int32_t DateType::toDays(folly::StringPiece in) const {
+int32_t DateType::toDays(std::string_view in) const {
   return toDays(in.data(), in.size());
 }
 
@@ -1252,6 +1356,7 @@ const SingletonTypeMap& singletonBuiltInTypes() {
       {"INTERVAL DAY TO SECOND", INTERVAL_DAY_TIME()},
       {"INTERVAL YEAR TO MONTH", INTERVAL_YEAR_MONTH()},
       {"DATE", DATE()},
+      {"TIME", TIME()},
       {"UNKNOWN", UNKNOWN()},
   };
   return kTypes;
@@ -1401,4 +1506,127 @@ std::string getOpaqueAliasForTypeId(std::type_index typeIndex) {
       typeIndex.name());
   return it->second;
 }
+
+folly::dynamic TimeType::serialize() const {
+  folly::dynamic obj = folly::dynamic::object;
+  obj["name"] = "TimeType";
+  obj["type"] = name();
+  return obj;
+}
+
+StringView TimeType::valueToString(int64_t value, char* const startPos) const {
+  // Ensure the value is within valid TIME range
+  VELOX_USER_CHECK(
+      !(value < 0 || value >= 86400000),
+      "TIME value {} is out of range [0, 86400000)",
+      value);
+
+  int64_t hours = value / kMillisInHour;
+  int64_t remainingMs = value % kMillisInHour;
+  int64_t minutes = remainingMs / kMillisInMinute;
+  remainingMs = remainingMs % kMillisInMinute;
+  int64_t seconds = remainingMs / kMillisInSecond;
+  int64_t millis = remainingMs % kMillisInSecond;
+
+  // TIME is represented as milliseconds since midnight
+  // Convert to HH:mm:ss.SSS format
+
+  fmt::format_to_n(
+      startPos,
+      kTimeToVarcharRowSize,
+      "{:02d}:{:02d}:{:02d}.{:03d}",
+      hours,
+      minutes,
+      seconds,
+      millis);
+  return StringView{startPos, kTimeToVarcharRowSize};
+}
+
+int64_t TimeType::valueToTime(const StringView& timeStr) const {
+  return util::fromTimeString(timeStr).thenOrThrow(
+      folly::identity,
+      [&](const Status& status) { VELOX_USER_FAIL("{}", status.message()); });
+}
+
+int64_t TimeType::valueToTime(
+    const StringView& timeStr,
+    const tz::TimeZone* timeZone,
+    int64_t sessionStartTimeMs) const {
+  // First parse the time string normally to get local time
+  int64_t parsedTimeMillis = valueToTime(timeStr);
+
+  // Apply timezone conversion if provided
+  if (FOLLY_UNLIKELY(!timeZone)) {
+    return parsedTimeMillis;
+  }
+
+  // Get the day boundary from session start time
+  auto sessionStartTime = std::chrono::milliseconds{sessionStartTimeMs};
+  auto systemDayStart =
+      std::chrono::duration_cast<std::chrono::days>(sessionStartTime);
+
+  // Create a local timestamp for the current day with the parsed time
+  auto localSystemTime =
+      std::chrono::duration_cast<std::chrono::milliseconds>(systemDayStart)
+          .count() +
+      parsedTimeMillis;
+
+  // Convert from local time to UTC with proper exception handling
+  std::chrono::milliseconds utcTime;
+  try {
+    utcTime = timeZone->to_sys(std::chrono::milliseconds{localSystemTime});
+  } catch (const facebook::velox::tzdb::ambiguous_local_time&) {
+    // If the time is ambiguous during DST fall-back, pick the earlier
+    // possibility to be consistent with Presto.
+    utcTime = timeZone->to_sys(
+        std::chrono::milliseconds{localSystemTime},
+        tz::TimeZone::TChoose::kEarliest);
+  } catch (const facebook::velox::tzdb::nonexistent_local_time&) {
+    // If the time does not exist during DST spring-forward, fail the
+    // conversion.
+    VELOX_USER_FAIL(
+        "Cannot cast VARCHAR '{}' to TIME. Time does not exist due to DST gap.",
+        std::string(timeStr));
+  }
+
+  int64_t adjustedTime =
+      (utcTime % std::chrono::milliseconds{kMillisInDay}).count();
+
+  // Handle day wrapping
+  if (adjustedTime < 0) {
+    adjustedTime += kMillisInDay;
+  } else if (adjustedTime >= kMillisInDay) {
+    adjustedTime -= kMillisInDay;
+  }
+
+  return adjustedTime;
+}
+
+std::string stringifyTruncatedElementList(
+    size_t size,
+    const std::function<void(std::stringstream&, size_t)>& stringifyElement,
+    size_t limit) {
+  if (size == 0) {
+    return "<empty>";
+  }
+
+  VELOX_CHECK_GT(limit, 0);
+
+  const size_t limitedSize = std::min(size, limit);
+
+  std::stringstream out;
+  out << "{";
+  for (size_t i = 0; i < limitedSize; ++i) {
+    if (i > 0) {
+      out << ", ";
+    }
+    stringifyElement(out, i);
+  }
+
+  if (size > limitedSize) {
+    out << ", ..." << (size - limitedSize) << " more";
+  }
+  out << "}";
+  return out.str();
+}
 } // namespace facebook::velox
diff --git a/velox/type/Type.h b/velox/type/Type.h
index 3fe46ed7c2fc..b2a922169b5c 100644
--- a/velox/type/Type.h
+++ b/velox/type/Type.h
@@ -16,8 +16,9 @@
 #pragma once
 
 #include <folly/CPortability.h>
+#include <folly/Hash.h>
 #include <folly/Random.h>
-#include <folly/Range.h>
+#include <folly/container/F14Set.h>
 #include <folly/dynamic.h>
 
 #include <cstdint>
@@ -27,18 +28,23 @@
 #include <limits>
 #include <memory>
 #include <optional>
+#include <span>
 #include <string>
 #include <type_traits>
 #include <typeindex>
 #include <vector>
 
+#include <velox/common/Enums.h>
+#include "velox/common/base/BitUtil.h"
 #include "velox/common/base/ClassName.h"
 #include "velox/common/base/Exceptions.h"
+#include "velox/common/base/Macros.h"
 #include "velox/common/serialization/Serializable.h"
 #include "velox/type/HugeInt.h"
 #include "velox/type/StringView.h"
 #include "velox/type/Timestamp.h"
 #include "velox/type/Tree.h"
+#include "velox/type/tz/TimeZoneMap.h"
 
 namespace facebook::velox {
 
@@ -87,16 +93,7 @@ enum class TypeKind : int8_t {
   INVALID = 36
 };
 
-/// Returns the typekind represented by the `name`. Throws if no match found.
-TypeKind mapNameToTypeKind(const std::string& name);
-
-/// Returns the typekind represented by the `name` and std::nullopt if no
-/// match found.
-std::optional<TypeKind> tryMapNameToTypeKind(const std::string& name);
-
-std::string mapTypeKindToName(const TypeKind& typeKind);
-
-std::ostream& operator<<(std::ostream& os, const TypeKind& kind);
+VELOX_DECLARE_ENUM_NAME(TypeKind);
 
 template <TypeKind KIND>
 class ScalarType;
@@ -114,24 +111,8 @@ struct UnknownValue {
     return true;
   }
 
-  bool operator!=(const UnknownValue& /* b */) const {
-    return false;
-  }
-
-  bool operator<(const UnknownValue& /* b */) const {
-    return false;
-  }
-
-  bool operator<=(const UnknownValue& /* b */) const {
-    return true;
-  }
-
-  bool operator>(const UnknownValue& /* b */) const {
-    return false;
-  }
-
-  bool operator>=(const UnknownValue& /* b */) const {
-    return true;
+  auto operator<=>(const UnknownValue& /* b */) const {
+    return std::strong_ordering::equal;
   }
 };
 
@@ -382,6 +363,17 @@ struct TypeTraits<TypeKind::OPAQUE> {
   static constexpr const char* name = "OPAQUE";
 };
 
+// Convenience constexpr function to check for string-like and nested type
+// kinds.
+constexpr bool is_string_kind(TypeKind kind) {
+  return kind == TypeKind::VARCHAR || kind == TypeKind::VARBINARY;
+}
+
+constexpr bool is_nested_kind(TypeKind kind) {
+  return kind == TypeKind::ARRAY || kind == TypeKind::MAP ||
+      kind == TypeKind::ROW;
+}
+
 template <TypeKind KIND>
 struct TypeFactory;
 
@@ -396,11 +388,63 @@ struct TypeFactory;
 class Type;
 using TypePtr = std::shared_ptr<const Type>;
 
+/// Represents the parameters for a BigintEnumType.
+/// Consists of the name of the enum and a map of string keys to bigint values.
+struct LongEnumParameter {
+  LongEnumParameter() = default;
+
+  LongEnumParameter(
+      std::string enumName,
+      std::unordered_map<std::string, int64_t> enumValuesMap)
+      : name(std::move(enumName)), valuesMap(std::move(enumValuesMap)) {}
+
+  bool operator==(const LongEnumParameter& other) const {
+    return name == other.name && valuesMap == other.valuesMap;
+  }
+
+  folly::dynamic serialize() const;
+
+  struct Hash {
+    size_t operator()(const LongEnumParameter& param) const;
+  };
+
+  std::string name;
+  std::unordered_map<std::string, int64_t> valuesMap;
+};
+
+/// Represents the parameters for a VarcharEnumType.
+/// Consists of the name of the enum and a map of string keys to string values.
+struct VarcharEnumParameter {
+  VarcharEnumParameter() = default;
+
+  VarcharEnumParameter(
+      std::string enumName,
+      std::unordered_map<std::string, std::string> enumValuesMap)
+      : name(std::move(enumName)), valuesMap(std::move(enumValuesMap)) {}
+
+  bool operator==(const VarcharEnumParameter& other) const {
+    return name == other.name && valuesMap == other.valuesMap;
+  }
+
+  folly::dynamic serialize() const;
+
+  struct Hash {
+    size_t operator()(const VarcharEnumParameter& param) const;
+  };
+
+  std::string name;
+  std::unordered_map<std::string, std::string> valuesMap;
+};
+
 enum class TypeParameterKind {
   /// Type. For example, element type in the array, map, or row children type.
   kType,
   /// Integer. For example, precision in a decimal type.
   kLongLiteral,
+  /// LongEnumLiteral. Used for BigintEnum types.
+  kLongEnumLiteral,
+  /// VarcharEnumLiteral. Used for VarcharEnum types.
+  kVarcharEnumLiteral,
 };
 
 struct TypeParameter {
@@ -414,6 +458,14 @@ struct TypeParameter {
   /// or unset.
   const std::optional<int64_t> longLiteral;
 
+  /// Must be set when kind is kLongEnumLiteral. All other properties should
+  /// be null or unset.
+  const std::optional<LongEnumParameter> longEnumLiteral;
+
+  /// Must be set when kind is kVarcharEnumLiteral. All other properties should
+  /// be null or unset.
+  const std::optional<VarcharEnumParameter> varcharEnumLiteral;
+
   /// If this parameter is a child of another parent row type, it can optionally
   /// have a name, e.g, "id" for `row(id bigint)`. Only set when kind is kType
   const std::optional<std::string> rowFieldName;
@@ -425,13 +477,35 @@ struct TypeParameter {
       : kind{TypeParameterKind::kType},
         type{std::move(_type)},
         longLiteral{std::nullopt},
-        rowFieldName(_rowFieldName) {}
+        longEnumLiteral{std::nullopt},
+        varcharEnumLiteral(std::nullopt),
+        rowFieldName(std::move(_rowFieldName)) {}
 
   /// Creates kLongLiteral parameter.
   explicit TypeParameter(int64_t _longLiteral)
       : kind{TypeParameterKind::kLongLiteral},
         type{nullptr},
         longLiteral{_longLiteral},
+        longEnumLiteral{std::nullopt},
+        varcharEnumLiteral(std::nullopt),
+        rowFieldName{std::nullopt} {}
+
+  /// Creates kLongEnumLiteral parameter.
+  explicit TypeParameter(LongEnumParameter _longEnumParameter)
+      : kind{TypeParameterKind::kLongEnumLiteral},
+        type{nullptr},
+        longLiteral{std::nullopt},
+        longEnumLiteral{std::move(_longEnumParameter)},
+        varcharEnumLiteral(std::nullopt),
+        rowFieldName{std::nullopt} {}
+
+  /// Creates kVarcharEnumLiteral parameter.
+  explicit TypeParameter(VarcharEnumParameter _varcharEnumParameter)
+      : kind{TypeParameterKind::kVarcharEnumLiteral},
+        type{nullptr},
+        longLiteral{std::nullopt},
+        longEnumLiteral{std::nullopt},
+        varcharEnumLiteral{std::move(_varcharEnumParameter)},
         rowFieldName{std::nullopt} {}
 };
 
@@ -449,14 +523,14 @@ struct TypeParameter {
 ///                   BigintType
 class Type : public Tree<const TypePtr>, public velox::ISerializable {
  public:
-  explicit Type(TypeKind kind, bool providesCustomComparison = false)
-      : kind_{kind}, providesCustomComparison_(providesCustomComparison) {}
+  constexpr explicit Type(TypeKind kind, bool providesCustomComparison = false)
+      : kind_{kind}, providesCustomComparison_{providesCustomComparison} {}
 
   TypeKind kind() const {
     return kind_;
   }
 
-  virtual ~Type() = default;
+  ~Type() override = default;
 
   /// This convenience method makes pattern matching easier. Rather than having
   /// to know the implementation type up front, just use as<TypeKind::MAP> (for
@@ -492,7 +566,7 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   virtual const char* name() const = 0;
 
   /// Returns a possibly empty list of type parameters.
-  virtual const std::vector<TypeParameter>& parameters() const = 0;
+  virtual std::span<const TypeParameter> parameters() const = 0;
 
   /// Returns physical type name. Multiple logical types may share the same
   /// physical type backing and therefore return the same physical type name.
@@ -524,10 +598,6 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
     return this->equals(other);
   }
 
-  inline bool operator!=(const Type& other) const {
-    return !(*this == other);
-  }
-
   // todo(youknowjack): avoid expensive virtual function calls for these
   // simple functions
   virtual size_t cppSizeInBytes() const {
@@ -538,7 +608,7 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
 
   virtual bool isFixedWidth() const = 0;
 
-  static std::shared_ptr<const Type> create(const folly::dynamic& obj);
+  static TypePtr create(const folly::dynamic& obj);
 
   static void registerSerDe();
 
@@ -546,7 +616,7 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
   virtual size_t hashKind() const;
 
   /// Recursive kind match (uses only TypeKind).
-  bool kindEquals(const std::shared_ptr<const Type>& other) const;
+  bool kindEquals(const TypePtr& other) const;
 
   template <TypeKind KIND, typename... CHILDREN>
   static std::shared_ptr<const typename TypeTraits<KIND>::ImplType> create(
@@ -581,10 +651,15 @@ class Type : public Tree<const TypePtr>, public velox::ISerializable {
 
   bool isIntervalDayTime() const;
 
+  bool isTime() const;
+
   bool isDate() const;
 
   bool containsUnknown() const;
 
+  template <typename T>
+  std::string valueToString(T value) const;
+
   VELOX_DEFINE_CLASS_NAME(Type)
 
  protected:
@@ -616,8 +691,11 @@ template <TypeKind KIND>
 struct kindCanProvideCustomComparison<
     KIND,
     std::enable_if_t<
-        TypeTraits<KIND>::isPrimitiveType && TypeTraits<KIND>::isFixedWidth>> {
-  static constexpr bool value = true;
+        TypeTraits<KIND>::isPrimitiveType && TypeTraits<KIND>::isFixedWidth>>
+    : std::true_type {};
+
+struct ProvideCustomComparison {
+  explicit ProvideCustomComparison() = default;
 };
 
 template <TypeKind KIND>
@@ -625,13 +703,12 @@ class TypeBase : public Type {
  public:
   using NativeType = typename TypeTraits<KIND>::NativeType;
 
-  explicit TypeBase(bool providesCustomComparison = false)
-      : Type{KIND, providesCustomComparison} {
-    if (providesCustomComparison) {
-      VELOX_CHECK(
-          kindCanProvideCustomComparison<KIND>::value,
-          "Custom comparisons are only supported for primitive types that are fixed width.");
-    }
+  constexpr explicit TypeBase() : Type{KIND, false} {}
+
+  constexpr explicit TypeBase(ProvideCustomComparison tag) : Type{KIND, true} {
+    static_assert(
+        kindCanProvideCustomComparison<KIND>::value,
+        "Custom comparisons are only supported for primitive types that are fixed width.");
   }
 
   bool isPrimitiveType() const override {
@@ -658,17 +735,15 @@ class TypeBase : public Type {
     return TypeTraits<KIND>::name;
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    static const std::vector<TypeParameter> kEmpty = {};
-    return kEmpty;
+  std::span<const TypeParameter> parameters() const override {
+    return {};
   }
 };
 
 template <TypeKind KIND>
 class CanProvideCustomComparisonType : public TypeBase<KIND> {
  public:
-  explicit CanProvideCustomComparisonType(bool providesCustomComparison = false)
-      : TypeBase<KIND>{providesCustomComparison} {}
+  using TypeBase<KIND>::TypeBase;
 
   virtual int32_t compare(
       const typename TypeBase<KIND>::NativeType& /*left*/,
@@ -691,14 +766,13 @@ class CanProvideCustomComparisonType : public TypeBase<KIND> {
 template <TypeKind KIND>
 class ScalarType : public CanProvideCustomComparisonType<KIND> {
  public:
-  explicit ScalarType(bool providesCustomComparison = false)
-      : CanProvideCustomComparisonType<KIND>{providesCustomComparison} {}
+  using CanProvideCustomComparisonType<KIND>::CanProvideCustomComparisonType;
 
   uint32_t size() const override {
     return 0;
   }
 
-  const std::shared_ptr<const Type>& childAt(uint32_t) const override {
+  const TypePtr& childAt(uint32_t) const override {
     VELOX_FAIL("scalar type has no children");
   }
 
@@ -722,7 +796,13 @@ class ScalarType : public CanProvideCustomComparisonType<KIND> {
     return Type::cppSizeInBytes();
   }
 
-  FOLLY_NOINLINE static const std::shared_ptr<const ScalarType<KIND>> create();
+  // TODO: This and all similar functions should be constexpr starting from
+  // C++23. In such case similar places but with type parameters can be
+  // constexpr too.
+  static std::shared_ptr<const ScalarType<KIND>> create() {
+    static constexpr ScalarType<KIND> kInstance;
+    return {std::shared_ptr<const ScalarType<KIND>>{}, &kInstance};
+  }
 
   bool equivalent(const Type& other) const override {
     return Type::hasSameTypeId(other);
@@ -737,12 +817,6 @@ class ScalarType : public CanProvideCustomComparisonType<KIND> {
   }
 };
 
-template <TypeKind KIND>
-const std::shared_ptr<const ScalarType<KIND>> ScalarType<KIND>::create() {
-  static const auto instance = std::make_shared<const ScalarType<KIND>>();
-  return instance;
-}
-
 /// 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
@@ -788,7 +862,7 @@ class DecimalType : public ScalarType<KIND> {
     return obj;
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
+  std::span<const TypeParameter> parameters() const override {
     return parameters_;
   }
 
@@ -812,19 +886,24 @@ class DecimalType : public ScalarType<KIND> {
   }
 
  private:
-  const std::vector<TypeParameter> parameters_;
+  const std::array<TypeParameter, 2> parameters_;
 };
 
-class ShortDecimalType : public DecimalType<TypeKind::BIGINT> {
+class ShortDecimalType final : public DecimalType<TypeKind::BIGINT> {
  public:
   ShortDecimalType(int precision, int scale)
       : DecimalType<TypeKind::BIGINT>(precision, scale) {}
 };
 
-class LongDecimalType : public DecimalType<TypeKind::HUGEINT> {
+class LongDecimalType final : public DecimalType<TypeKind::HUGEINT> {
  public:
+  // Ensure toString from the parent is not hidden.
+  using DecimalType<TypeKind::HUGEINT>::toString;
+
   LongDecimalType(int precision, int scale)
       : DecimalType<TypeKind::HUGEINT>(precision, scale) {}
+
+  static std::string toString(int128_t value, const Type& type);
 };
 
 TypePtr DECIMAL(uint8_t precision, uint8_t scale);
@@ -857,15 +936,14 @@ std::pair<uint8_t, uint8_t> getDecimalPrecisionScale(const Type& type);
 
 class UnknownType : public CanProvideCustomComparisonType<TypeKind::UNKNOWN> {
  public:
-  explicit UnknownType(bool proivdesCustomComparison = false)
-      : CanProvideCustomComparisonType<TypeKind::UNKNOWN>(
-            proivdesCustomComparison) {}
+  using CanProvideCustomComparisonType<
+      TypeKind::UNKNOWN>::CanProvideCustomComparisonType;
 
   uint32_t size() const override {
     return 0;
   }
 
-  const std::shared_ptr<const Type>& childAt(uint32_t) const override {
+  const TypePtr& childAt(uint32_t) const override {
     throw std::invalid_argument{"UnknownType type has no children"};
   }
 
@@ -930,7 +1008,7 @@ class ArrayType : public TypeBase<TypeKind::ARRAY> {
     return child_->isComparable();
   }
 
-  const std::shared_ptr<const Type>& childAt(uint32_t idx) const override;
+  const TypePtr& childAt(uint32_t idx) const override;
 
   const char* nameOf(uint32_t idx) const {
     VELOX_USER_CHECK_EQ(idx, 0, "Array type should have only one child");
@@ -943,17 +1021,19 @@ class ArrayType : public TypeBase<TypeKind::ARRAY> {
 
   folly::dynamic serialize() const override;
 
-  const std::vector<TypeParameter>& parameters() const override {
-    return parameters_;
+  std::span<const TypeParameter> parameters() const override {
+    return {&parameter_, 1};
   }
 
  protected:
   bool equals(const Type& other) const override;
 
-  TypePtr child_;
-  const std::vector<TypeParameter> parameters_;
+  const TypePtr child_;
+  const TypeParameter parameter_;
 };
 
+using ArrayTypePtr = std::shared_ptr<const ArrayType>;
+
 class MapType : public TypeBase<TypeKind::MAP> {
  public:
   MapType(TypePtr keyType, TypePtr valueType);
@@ -997,7 +1077,7 @@ class MapType : public TypeBase<TypeKind::MAP> {
 
   folly::dynamic serialize() const override;
 
-  const std::vector<TypeParameter>& parameters() const override {
+  std::span<const TypeParameter> parameters() const override {
     return parameters_;
   }
 
@@ -1007,14 +1087,45 @@ class MapType : public TypeBase<TypeKind::MAP> {
  private:
   TypePtr keyType_;
   TypePtr valueType_;
-  const std::vector<TypeParameter> parameters_;
+  const std::array<TypeParameter, 2> parameters_;
 };
 
+using MapTypePtr = std::shared_ptr<const MapType>;
+
 class RowType : public TypeBase<TypeKind::ROW> {
+  // This Set<NameIndex> written only to decrease memory footprint.
+  // In general it can be replaced with Map<string_view, size_t>
+  struct NameIndex {
+    explicit NameIndex(std::string_view name, uint32_t index)
+        : data{name.data()},
+          size{static_cast<uint32_t>(name.size())},
+          index{index} {}
+
+    const char* data = nullptr;
+    uint32_t size = 0;
+
+    bool operator==(const NameIndex& other) const {
+      return size == other.size && std::memcmp(data, other.data, size) == 0;
+    }
+
+    uint32_t index = 0;
+  };
+
+  struct NameIndexHasher {
+    size_t operator()(const NameIndex& nameIndex) const {
+      folly::f14::DefaultHasher<std::string_view> hasher;
+      return hasher(std::string_view{nameIndex.data, nameIndex.size});
+    }
+  };
+
+  // TODO: Consider using absl::flat_hash_set instead.
+  using NameToIndex = folly::F14ValueSet<NameIndex, NameIndexHasher>;
+
  public:
-  RowType(
-      std::vector<std::string>&& names,
-      std::vector<std::shared_ptr<const Type>>&& types);
+  /// @param names Child names. Case sensitive. Can be empty. May contain
+  /// duplicates.
+  /// @param types List of child types aligned with 'names'.
+  RowType(std::vector<std::string>&& names, std::vector<TypePtr>&& types);
 
   ~RowType() override;
 
@@ -1027,27 +1138,38 @@ class RowType : public TypeBase<TypeKind::ROW> {
     return children_[idx];
   }
 
-  const std::vector<std::shared_ptr<const Type>>& children() const {
+  const std::vector<TypePtr>& children() const {
     return children_;
   }
 
+  /// Returns true if all child types are orderable.
   bool isOrderable() const override;
 
+  /// Returns true if all child types are comparable.
   bool isComparable() const override;
 
-  const std::shared_ptr<const Type>& findChild(folly::StringPiece name) const;
+  /// Returns type of the first child with matching name. Throws if child with
+  /// this name doesn't exist.
+  const TypePtr& findChild(std::string_view name) const;
 
+  /// Returns true if child with specified name exists.
   bool containsChild(std::string_view name) const;
 
+  /// Returns zero-based index of the first child with matching name. Throws if
+  /// child with this name doesn't exist.
   uint32_t getChildIdx(std::string_view name) const;
 
+  /// Returns an optional zero-based index of the first child with matching
+  /// name. Return std::nullopt if child with this name doesn't exist.
   std::optional<uint32_t> getChildIdxIfExists(std::string_view name) const;
 
+  /// Returns the name of the child at specified index.
   const std::string& nameOf(uint32_t idx) const {
     VELOX_CHECK_LT(idx, names_.size());
     return names_[idx];
   }
 
+  /// Returns true if the 'other' type is the same except for child names.
   bool equivalent(const Type& other) const override;
 
   std::string toString() const override;
@@ -1056,8 +1178,10 @@ class RowType : public TypeBase<TypeKind::ROW> {
   void printChildren(std::stringstream& ss, std::string_view delimiter = ",")
       const;
 
-  std::shared_ptr<RowType> unionWith(
-      std::shared_ptr<const RowType> rowType) const;
+  /// Concatenates child names and types of 'this' with 'other'.
+  /// {a, b, c}->unionWith({d, e, f}) => {a, b, c, d, e, f}.
+  std::shared_ptr<const RowType> unionWith(
+      const std::shared_ptr<const RowType>& other) const;
 
   folly::dynamic serialize() const override;
 
@@ -1065,17 +1189,20 @@ class RowType : public TypeBase<TypeKind::ROW> {
     return names_;
   }
 
-  const std::vector<TypeParameter>& parameters() const override {
-    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;
-      }
+  std::span<const TypeParameter> parameters() const override {
+    const auto* parameters = parameters_.load(std::memory_order_acquire);
+    if (parameters) [[likely]] {
+      return *parameters;
+    }
+    return *ensureParameters();
+  }
+
+  const NameToIndex& nameToIndex() const {
+    const auto* nameToIndex = nameToIndex_.load(std::memory_order_acquire);
+    if (nameToIndex) [[likely]] {
+      return *nameToIndex;
     }
-    return *parameters;
+    return *ensureNameToIndex();
   }
 
   size_t hashKind() const override;
@@ -1084,11 +1211,13 @@ class RowType : public TypeBase<TypeKind::ROW> {
   bool equals(const Type& other) const override;
 
  private:
-  std::unique_ptr<std::vector<TypeParameter>> makeParameters() const;
+  const std::vector<TypeParameter>* ensureParameters() const;
+  const NameToIndex* ensureNameToIndex() const;
 
   const std::vector<std::string> names_;
-  const std::vector<std::shared_ptr<const Type>> children_;
+  const std::vector<TypePtr> children_;
   mutable std::atomic<std::vector<TypeParameter>*> parameters_{nullptr};
+  mutable std::atomic<NameToIndex*> nameToIndex_{nullptr};
   mutable std::atomic_bool hashKindComputed_{false};
   mutable std::atomic_size_t hashKind_;
 };
@@ -1103,20 +1232,18 @@ inline RowTypePtr asRowType(const TypePtr& type) {
 /// followed by the return value type.
 class FunctionType : public TypeBase<TypeKind::FUNCTION> {
  public:
-  FunctionType(
-      std::vector<std::shared_ptr<const Type>>&& argumentTypes,
-      std::shared_ptr<const Type> returnType);
+  FunctionType(std::vector<TypePtr>&& argumentTypes, TypePtr returnType);
 
   uint32_t size() const override {
     return children_.size();
   }
 
-  const std::shared_ptr<const Type>& childAt(uint32_t idx) const override {
+  const TypePtr& childAt(uint32_t idx) const override {
     VELOX_CHECK_LT(idx, children_.size());
     return children_[idx];
   }
 
-  const std::vector<std::shared_ptr<const Type>>& children() const {
+  const std::vector<TypePtr>& children() const {
     return children_;
   }
 
@@ -1134,7 +1261,7 @@ class FunctionType : public TypeBase<TypeKind::FUNCTION> {
 
   folly::dynamic serialize() const override;
 
-  const std::vector<TypeParameter>& parameters() const override {
+  std::span<const TypeParameter> parameters() const override {
     return parameters_;
   }
 
@@ -1142,15 +1269,15 @@ class FunctionType : public TypeBase<TypeKind::FUNCTION> {
   bool equals(const Type& other) const override;
 
  private:
-  static std::vector<std::shared_ptr<const Type>> allChildren(
-      std::vector<std::shared_ptr<const Type>>&& argumentTypes,
-      std::shared_ptr<const Type> returnType) {
+  static std::vector<TypePtr> allChildren(
+      std::vector<TypePtr>&& argumentTypes,
+      TypePtr returnType) {
     auto children = std::move(argumentTypes);
     children.push_back(returnType);
     return children;
   }
   // Argument types from left to right followed by return value type.
-  const std::vector<std::shared_ptr<const Type>> children_;
+  const std::vector<TypePtr> children_;
   const std::vector<TypeParameter> parameters_;
 };
 
@@ -1161,13 +1288,13 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
   template <typename T>
   using DeserializeFunc = std::function<std::shared_ptr<T>(const std::string&)>;
 
-  explicit OpaqueType(const std::type_index& typeIndex);
+  explicit OpaqueType(std::type_index typeIndex) : typeIndex_{typeIndex} {}
 
   uint32_t size() const override {
     return 0;
   }
 
-  const std::shared_ptr<const Type>& childAt(uint32_t) const override {
+  const TypePtr& childAt(uint32_t) const override {
     VELOX_FAIL("OpaqueType type has no children");
   }
 
@@ -1175,11 +1302,12 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
 
   bool equivalent(const Type& other) const override;
 
-  const std::type_index& typeIndex() const {
+  std::type_index typeIndex() const {
     return typeIndex_;
   }
 
   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,
@@ -1200,9 +1328,8 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
   FOLLY_NOINLINE static std::shared_ptr<const OpaqueType> create() {
     /// static vars in templates are dangerous across DSOs, but it's just a
     /// performance optimization. Comparison looks at type_index anyway.
-    static const auto instance =
-        std::make_shared<const OpaqueType>(std::type_index(typeid(Class)));
-    return instance;
+    static const OpaqueType kInstance{std::type_index(typeid(Class))};
+    return {std::shared_ptr<const OpaqueType>{}, &kInstance};
   }
 
   /// This function currently doesn't do synchronization neither with reads
@@ -1235,6 +1362,15 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
         deserializeTypeErased);
   }
 
+  // This function is used to remove the serialization/deserialization functions
+  // for a type. It reverses the state changes made by registerSerialization
+  // function.
+  // @return true if the functions are found and removed
+  // successfully. False otherwise.
+  static bool unregisterSerialization(
+      const std::shared_ptr<const OpaqueType>& opaqueType,
+      const std::string& persistentName);
+
   static void clearSerializationRegistry();
 
  protected:
@@ -1250,6 +1386,8 @@ class OpaqueType : public TypeBase<TypeKind::OPAQUE> {
       DeserializeFunc<void> deserialize = nullptr);
 };
 
+using OpaqueTypePtr = std::shared_ptr<const OpaqueType>;
+
 using IntegerType = ScalarType<TypeKind::INTEGER>;
 using BooleanType = ScalarType<TypeKind::BOOLEAN>;
 using TinyintType = ScalarType<TypeKind::TINYINT>;
@@ -1268,15 +1406,13 @@ constexpr long kMillisInHour = 60 * kMillisInMinute;
 constexpr long kMillisInDay = 24 * kMillisInHour;
 
 /// Time interval in milliseconds.
-class IntervalDayTimeType : public BigintType {
- private:
+class IntervalDayTimeType final : public BigintType {
   IntervalDayTimeType() = default;
 
  public:
-  static const std::shared_ptr<const IntervalDayTimeType>& get() {
-    static const std::shared_ptr<const IntervalDayTimeType> kType{
-        new IntervalDayTimeType()};
-    return kType;
+  static std::shared_ptr<const IntervalDayTimeType> get() {
+    VELOX_CONSTEXPR_SINGLETON IntervalDayTimeType kInstance;
+    return {std::shared_ptr<const IntervalDayTimeType>{}, &kInstance};
   }
 
   const char* name() const override {
@@ -1310,7 +1446,7 @@ class IntervalDayTimeType : public BigintType {
   }
 };
 
-FOLLY_ALWAYS_INLINE const std::shared_ptr<const IntervalDayTimeType>&
+FOLLY_ALWAYS_INLINE std::shared_ptr<const IntervalDayTimeType>
 INTERVAL_DAY_TIME() {
   return IntervalDayTimeType::get();
 }
@@ -1322,15 +1458,13 @@ FOLLY_ALWAYS_INLINE bool Type::isIntervalDayTime() const {
 
 constexpr long kMonthInYear = 12;
 /// Time interval in months.
-class IntervalYearMonthType : public IntegerType {
- private:
+class IntervalYearMonthType final : public IntegerType {
   IntervalYearMonthType() = default;
 
  public:
-  static const std::shared_ptr<const IntervalYearMonthType>& get() {
-    static const std::shared_ptr<const IntervalYearMonthType> kType{
-        new IntervalYearMonthType()};
-    return kType;
+  static std::shared_ptr<const IntervalYearMonthType> get() {
+    VELOX_CONSTEXPR_SINGLETON IntervalYearMonthType kInstance;
+    return {std::shared_ptr<const IntervalYearMonthType>{}, &kInstance};
   }
 
   const char* name() const override {
@@ -1363,7 +1497,7 @@ class IntervalYearMonthType : public IntegerType {
   }
 };
 
-FOLLY_ALWAYS_INLINE const std::shared_ptr<const IntervalYearMonthType>&
+FOLLY_ALWAYS_INLINE std::shared_ptr<const IntervalYearMonthType>
 INTERVAL_YEAR_MONTH() {
   return IntervalYearMonthType::get();
 }
@@ -1374,14 +1508,13 @@ FOLLY_ALWAYS_INLINE bool Type::isIntervalYearMonth() const {
 }
 
 /// Date is represented as the number of days since epoch start using int32_t.
-class DateType : public IntegerType {
- private:
+class DateType final : public IntegerType {
   DateType() = default;
 
  public:
-  static const std::shared_ptr<const DateType>& get() {
-    static const std::shared_ptr<const DateType> kType{new DateType()};
-    return kType;
+  static std::shared_ptr<const DateType> get() {
+    VELOX_CONSTEXPR_SINGLETON DateType kInstance;
+    return {std::shared_ptr<const DateType>{}, &kInstance};
   }
 
   const char* name() const override {
@@ -1402,7 +1535,7 @@ class DateType : public IntegerType {
   /// as an ISO 8601-formatted string.
   static std::string toIso8601(int32_t days);
 
-  int32_t toDays(folly::StringPiece in) const;
+  int32_t toDays(std::string_view in) const;
 
   int32_t toDays(const char* in, size_t len) const;
 
@@ -1418,7 +1551,7 @@ class DateType : public IntegerType {
   }
 };
 
-FOLLY_ALWAYS_INLINE const std::shared_ptr<const DateType>& DATE() {
+FOLLY_ALWAYS_INLINE std::shared_ptr<const DateType> DATE() {
   return DateType::get();
 }
 
@@ -1431,6 +1564,86 @@ FOLLY_ALWAYS_INLINE bool Type::isDate() const {
   return this == DATE().get();
 }
 
+/// Represents TIME as a bigint (milliseconds since midnight).
+class TimeType final : public BigintType {
+  TimeType() = default;
+
+ public:
+  static std::shared_ptr<const TimeType> get() {
+    VELOX_CONSTEXPR_SINGLETON TimeType kInstance;
+    return {std::shared_ptr<const TimeType>{}, &kInstance};
+  }
+
+  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 "TIME";
+  }
+
+  std::string toString() const override {
+    return name();
+  }
+
+  /// Returns the time 'value' (milliseconds since midnight) formatted as
+  /// HH:MM:SS.mmm .
+  /// It is the callers responsiblity to ensure that the value is in range
+  /// and converted to the right time zone.
+  StringView valueToString(int64_t value, char* const startPos) const;
+
+  /// Parses a time string in HH:MM:SS[.sss] format and returns milliseconds
+  /// since midnight. It is the caller's responsibility to ensure that the
+  /// input string is valid and handle error conditions as needed.
+  int64_t valueToTime(const StringView& timeStr) const;
+
+  /// Parses a time string in HH:MM:SS[.sss] format and returns milliseconds
+  /// since midnight, applying timezone conversion if provided.
+  /// @param timeStr The time string to parse
+  /// @param timeZone Optional timezone for conversion
+  /// @param sessionStartTimeMs Session start time in milliseconds for timezone
+  /// calculations
+  int64_t valueToTime(
+      const StringView& timeStr,
+      const tz::TimeZone* timeZone,
+      int64_t sessionStartTimeMs) const;
+
+  folly::dynamic serialize() const override;
+
+  static TypePtr deserialize(const folly::dynamic& /*obj*/) {
+    return TimeType::get();
+  }
+
+  bool isOrderable() const override {
+    return true;
+  }
+
+  bool isComparable() const override {
+    return true;
+  }
+
+  // When casting from TIME to varchar , the resultant varchar will always
+  // be 12 bytes long (HH:MM:SS.mmm).
+  static const size_t kTimeToVarcharRowSize = 12;
+};
+
+using TimeTypePtr = std::shared_ptr<const TimeType>;
+
+FOLLY_ALWAYS_INLINE TimeTypePtr TIME() {
+  return TimeType::get();
+}
+
+FOLLY_ALWAYS_INLINE bool Type::isTime() const {
+  // Pointer comparison works since this type is a singleton.
+  return (this == TIME().get());
+}
+
+struct Time {
+ private:
+  Time() {}
+};
+
 /// Used as T for SimpleVector subclasses that wrap another vector when
 /// the wrapped vector is of a complex type. Applies to
 /// DictionaryVector, SequenceVector and ConstantVector. This must have
@@ -1456,47 +1669,80 @@ struct TypeFactory {
 template <>
 struct TypeFactory<TypeKind::UNKNOWN> {
   static std::shared_ptr<const UnknownType> create() {
-    return std::make_shared<UnknownType>();
+    VELOX_CONSTEXPR_SINGLETON UnknownType kInstance;
+    return {std::shared_ptr<const UnknownType>{}, &kInstance};
   }
 };
 
 template <>
 struct TypeFactory<TypeKind::ARRAY> {
-  static std::shared_ptr<const ArrayType> create(TypePtr elementType) {
-    return std::make_shared<ArrayType>(std::move(elementType));
+  static ArrayTypePtr create(TypePtr elementType) {
+    return std::make_shared<const ArrayType>(std::move(elementType));
   }
 };
 
 template <>
 struct TypeFactory<TypeKind::MAP> {
-  static std::shared_ptr<const MapType> create(
-      TypePtr keyType,
-      TypePtr valType) {
-    return std::make_shared<MapType>(std::move(keyType), std::move(valType));
+  static MapTypePtr create(TypePtr keyType, TypePtr valType) {
+    return std::make_shared<const MapType>(
+        std::move(keyType), std::move(valType));
   }
 };
 
 template <>
 struct TypeFactory<TypeKind::ROW> {
-  static std::shared_ptr<const RowType> create(
+  static RowTypePtr create(
       std::vector<std::string>&& names,
       std::vector<TypePtr>&& types) {
     return std::make_shared<const RowType>(std::move(names), std::move(types));
   }
 };
 
-std::shared_ptr<const ArrayType> ARRAY(TypePtr elementType);
+/// Returns an array of 'elementType'.
+///
+/// Example: ARRAY(INTEGER()).
+ArrayTypePtr ARRAY(TypePtr elementType);
+
+/// Returns a map of 'keyType' and 'valueType'.
+///
+/// Example: MAP(INTEGER(), REAL()).
+MapTypePtr MAP(TypePtr keyType, TypePtr valueType);
 
-std::shared_ptr<const RowType> ROW(
-    std::vector<std::string>&& names,
-    std::vector<TypePtr>&& types);
+/// Returns a struct with specified field names and types. Number of 'names'
+/// must match number of 'types'. Empty 'names' and 'types' are allowed.
+///
+/// Example: ROW({"a", "b", "c"}, {INTEGER(), BIGINT(), VARCHAR()}).
+RowTypePtr ROW(std::vector<std::string> names, std::vector<TypePtr> types);
 
-std::shared_ptr<const RowType> ROW(
+/// Returns a homogenous struct where all fields have the same type.
+///
+/// Example:
+///
+///   ROW({"a", "b", "c"}, REAL()) is a shortcut for
+///     ROW({"a", "b", "c"}, {REAL(), REAL(), REAL()}).
+RowTypePtr ROW(std::vector<std::string> names, const TypePtr& childType);
+
+RowTypePtr ROW(
+    std::initializer_list<std::string> names,
+    const TypePtr& childType);
+
+/// Creates a RowType from list of (name, type) pairs.
+///
+/// Example: ROW({{"a", INTEGER()}, {"b", BIGINT()}, {"c", VARCHAR()}}).
+RowTypePtr ROW(
     std::initializer_list<std::pair<const std::string, TypePtr>>&& pairs);
 
-std::shared_ptr<const RowType> ROW(std::vector<TypePtr>&& pairs);
+/// Returns a struct with a single field.
+///
+/// Example: ROW("a", BIGINT()) is a shortcut for ROW({{"a", BIGINT()}}).
+RowTypePtr ROW(std::string name, TypePtr type);
 
-std::shared_ptr<const MapType> MAP(TypePtr keyType, TypePtr valType);
+/// Returns anonymoous struct where field names are empty.
+///
+/// Examples:
+///    ROW({INTEGER(), BIGINT(), VARCHAR()})
+///    ROW({}) // Struct with no fields.
+RowTypePtr ROW(std::vector<TypePtr>&& types);
 
 std::shared_ptr<const FunctionType> FUNCTION(
     std::vector<TypePtr>&& argumentTypes,
@@ -1555,7 +1801,8 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
       }                                                                       \
       default:                                                                \
         VELOX_FAIL(                                                           \
-            "not a scalar type! kind: {}", mapTypeKindToName(typeKind));      \
+            "not a scalar type! kind: {}",                                    \
+            ::facebook::velox::TypeKindName::toName(typeKind));               \
     }                                                                         \
   }()
 
@@ -1609,7 +1856,8 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
       }                                                                  \
       default:                                                           \
         VELOX_FAIL(                                                      \
-            "not a scalar type! kind: {}", mapTypeKindToName(typeKind)); \
+            "not a scalar type! kind: {}",                               \
+            ::facebook::velox::TypeKindName::toName(typeKind));          \
     }                                                                    \
   }()
 
@@ -1673,7 +1921,9 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
             __VA_ARGS__);                                                     \
       }                                                                       \
       default:                                                                \
-        VELOX_FAIL("not a known type kind: {}", mapTypeKindToName(typeKind)); \
+        VELOX_FAIL(                                                           \
+            "not a known type kind: {}",                                      \
+            ::facebook::velox::TypeKindName::toName(typeKind));               \
     }                                                                         \
   }()
 
@@ -1760,7 +2010,9 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
         return PREFIX<::facebook::velox::TypeKind::ROW> SUFFIX(__VA_ARGS__);   \
       }                                                                        \
       default:                                                                 \
-        VELOX_FAIL("not a known type kind: {}", mapTypeKindToName(typeKind));  \
+        VELOX_FAIL(                                                            \
+            "not a known type kind: {}",                                       \
+            ::facebook::velox::TypeKindName::toName(typeKind));                \
     }                                                                          \
   }()
 
@@ -1802,51 +2054,53 @@ std::shared_ptr<const OpaqueType> OPAQUE() {
 #define VELOX_SCALAR_ACCESSOR(KIND) \
   std::shared_ptr<const ScalarType<TypeKind::KIND>> KIND()
 
-#define VELOX_STATIC_FIELD_DYNAMIC_DISPATCH(CLASS, FIELD, typeKind)           \
-  [&]() {                                                                     \
-    switch (typeKind) {                                                       \
-      case ::facebook::velox::TypeKind::BOOLEAN: {                            \
-        return CLASS<::facebook::velox::TypeKind::BOOLEAN>::FIELD;            \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::INTEGER: {                            \
-        return CLASS<::facebook::velox::TypeKind::INTEGER>::FIELD;            \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::TINYINT: {                            \
-        return CLASS<::facebook::velox::TypeKind::TINYINT>::FIELD;            \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::SMALLINT: {                           \
-        return CLASS<::facebook::velox::TypeKind::SMALLINT>::FIELD;           \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::BIGINT: {                             \
-        return CLASS<::facebook::velox::TypeKind::BIGINT>::FIELD;             \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::REAL: {                               \
-        return CLASS<::facebook::velox::TypeKind::REAL>::FIELD;               \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::DOUBLE: {                             \
-        return CLASS<::facebook::velox::TypeKind::DOUBLE>::FIELD;             \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::VARCHAR: {                            \
-        return CLASS<::facebook::velox::TypeKind::VARCHAR>::FIELD;            \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::VARBINARY: {                          \
-        return CLASS<::facebook::velox::TypeKind::VARBINARY>::FIELD;          \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::TIMESTAMP: {                          \
-        return CLASS<::facebook::velox::TypeKind::TIMESTAMP>::FIELD;          \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::ARRAY: {                              \
-        return CLASS<::facebook::velox::TypeKind::ARRAY>::FIELD;              \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::MAP: {                                \
-        return CLASS<::facebook::velox::TypeKind::MAP>::FIELD;                \
-      }                                                                       \
-      case ::facebook::velox::TypeKind::ROW: {                                \
-        return CLASS<::facebook::velox::TypeKind::ROW>::FIELD;                \
-      }                                                                       \
-      default:                                                                \
-        VELOX_FAIL("not a known type kind: {}", mapTypeKindToName(typeKind)); \
-    }                                                                         \
+#define VELOX_STATIC_FIELD_DYNAMIC_DISPATCH(CLASS, FIELD, typeKind)  \
+  [&]() {                                                            \
+    switch (typeKind) {                                              \
+      case ::facebook::velox::TypeKind::BOOLEAN: {                   \
+        return CLASS<::facebook::velox::TypeKind::BOOLEAN>::FIELD;   \
+      }                                                              \
+      case ::facebook::velox::TypeKind::INTEGER: {                   \
+        return CLASS<::facebook::velox::TypeKind::INTEGER>::FIELD;   \
+      }                                                              \
+      case ::facebook::velox::TypeKind::TINYINT: {                   \
+        return CLASS<::facebook::velox::TypeKind::TINYINT>::FIELD;   \
+      }                                                              \
+      case ::facebook::velox::TypeKind::SMALLINT: {                  \
+        return CLASS<::facebook::velox::TypeKind::SMALLINT>::FIELD;  \
+      }                                                              \
+      case ::facebook::velox::TypeKind::BIGINT: {                    \
+        return CLASS<::facebook::velox::TypeKind::BIGINT>::FIELD;    \
+      }                                                              \
+      case ::facebook::velox::TypeKind::REAL: {                      \
+        return CLASS<::facebook::velox::TypeKind::REAL>::FIELD;      \
+      }                                                              \
+      case ::facebook::velox::TypeKind::DOUBLE: {                    \
+        return CLASS<::facebook::velox::TypeKind::DOUBLE>::FIELD;    \
+      }                                                              \
+      case ::facebook::velox::TypeKind::VARCHAR: {                   \
+        return CLASS<::facebook::velox::TypeKind::VARCHAR>::FIELD;   \
+      }                                                              \
+      case ::facebook::velox::TypeKind::VARBINARY: {                 \
+        return CLASS<::facebook::velox::TypeKind::VARBINARY>::FIELD; \
+      }                                                              \
+      case ::facebook::velox::TypeKind::TIMESTAMP: {                 \
+        return CLASS<::facebook::velox::TypeKind::TIMESTAMP>::FIELD; \
+      }                                                              \
+      case ::facebook::velox::TypeKind::ARRAY: {                     \
+        return CLASS<::facebook::velox::TypeKind::ARRAY>::FIELD;     \
+      }                                                              \
+      case ::facebook::velox::TypeKind::MAP: {                       \
+        return CLASS<::facebook::velox::TypeKind::MAP>::FIELD;       \
+      }                                                              \
+      case ::facebook::velox::TypeKind::ROW: {                       \
+        return CLASS<::facebook::velox::TypeKind::ROW>::FIELD;       \
+      }                                                              \
+      default:                                                       \
+        VELOX_FAIL(                                                  \
+            "not a known type kind: {}",                             \
+            ::facebook::velox::TypeKindName::toName(typeKind));      \
+    }                                                                \
   }()
 
 #define VELOX_STATIC_FIELD_DYNAMIC_DISPATCH_ALL(CLASS, FIELD, typeKind)   \
@@ -1879,15 +2133,13 @@ VELOX_SCALAR_ACCESSOR(VARBINARY);
 TypePtr UNKNOWN();
 
 template <TypeKind KIND>
-std::shared_ptr<const Type> createScalarType() {
+TypePtr createScalarType() {
   return ScalarType<KIND>::create();
 }
 
-std::shared_ptr<const Type> createScalarType(TypeKind kind);
+TypePtr createScalarType(TypeKind kind);
 
-std::shared_ptr<const Type> createType(
-    TypeKind kind,
-    std::vector<std::shared_ptr<const Type>>&& children);
+TypePtr createType(TypeKind kind, std::vector<TypePtr>&& children);
 
 /// Returns true built-in or custom type with specified name exists.
 bool hasType(const std::string& name);
@@ -1899,8 +2151,7 @@ TypePtr getType(
     const std::vector<TypeParameter>& parameters);
 
 template <TypeKind KIND>
-std::shared_ptr<const Type> createType(
-    std::vector<std::shared_ptr<const Type>>&& children) {
+TypePtr createType(std::vector<TypePtr>&& children) {
   if (children.size() != 0) {
     throw std::invalid_argument{
         std::string(TypeTraits<KIND>::name) +
@@ -1911,20 +2162,16 @@ std::shared_ptr<const Type> createType(
 }
 
 template <>
-std::shared_ptr<const Type> createType<TypeKind::ROW>(
-    std::vector<std::shared_ptr<const Type>>&& children);
+TypePtr createType<TypeKind::ROW>(std::vector<TypePtr>&& children);
 
 template <>
-std::shared_ptr<const Type> createType<TypeKind::ARRAY>(
-    std::vector<std::shared_ptr<const Type>>&& children);
+TypePtr createType<TypeKind::ARRAY>(std::vector<TypePtr>&& children);
 
 template <>
-std::shared_ptr<const Type> createType<TypeKind::MAP>(
-    std::vector<std::shared_ptr<const Type>>&& children);
+TypePtr createType<TypeKind::MAP>(std::vector<TypePtr>&& children);
 
 template <>
-std::shared_ptr<const Type> createType<TypeKind::OPAQUE>(
-    std::vector<std::shared_ptr<const Type>>&& children);
+TypePtr createType<TypeKind::OPAQUE>(std::vector<TypePtr>&& children);
 
 #undef VELOX_SCALAR_ACCESSOR
 
@@ -1979,7 +2226,7 @@ static inline T to(const U& value) {
 }
 
 template <>
-inline Timestamp to(const std::string& value) {
+inline Timestamp to(const std::string&) {
   return Timestamp(0, 0);
 }
 
@@ -1998,13 +2245,18 @@ inline std::string to(const int128_t& value) {
   return std::to_string(value);
 }
 
+template <typename T>
+inline T to(const velox::StringView& value) {
+  return to<T>(std::string_view(value.data(), value.size()));
+}
+
 template <>
 inline std::string to(const velox::StringView& value) {
   return std::string(value.data(), value.size());
 }
 
 template <>
-inline std::string to(const ComplexType& value) {
+inline std::string to(const ComplexType&) {
   return std::string("ComplexType");
 }
 
@@ -2022,9 +2274,13 @@ using CastOperatorPtr = std::shared_ptr<const CastOperator>;
 } // namespace exec
 
 /// Forward declaration.
-class variant;
+class Variant;
 class AbstractInputGenerator;
 
+namespace memory {
+class MemoryPool;
+} // namespace memory
+
 using AbstractInputGeneratorPtr = std::shared_ptr<AbstractInputGenerator>;
 using FuzzerGenerator = folly::detail::DefaultGenerator;
 
@@ -2032,13 +2288,15 @@ struct InputGeneratorConfig {
   // TODO: hook up the rest options in VectorFuzzer::Options.
   size_t seed_;
   double nullRatio_;
+  memory::MemoryPool* pool_;
+  TypePtr type_{nullptr}; // Added type to support
 };
 
 /// Associates custom types with their custom operators to be the payload in
 /// the custom type registry.
-class CustomTypeFactories {
+class CustomTypeFactory {
  public:
-  virtual ~CustomTypeFactories();
+  virtual ~CustomTypeFactory();
 
   /// Returns a shared pointer to the custom type.
   virtual TypePtr getType(
@@ -2067,7 +2325,7 @@ class AbstractInputGenerator {
 
   virtual ~AbstractInputGenerator();
 
-  virtual variant generate() = 0;
+  virtual Variant generate() = 0;
 
   TypePtr type() const {
     return type_;
@@ -2088,7 +2346,7 @@ class AbstractInputGenerator {
 /// false if type with the specified name already exists.
 bool registerCustomType(
     const std::string& name,
-    std::unique_ptr<const CustomTypeFactories> factories);
+    std::unique_ptr<const CustomTypeFactory> factories);
 
 // See registerOpaqueType() for documentation on type index and opaque type
 // alias.
@@ -2124,6 +2382,7 @@ bool registerOpaqueType(const std::string& alias) {
 template <typename Class>
 bool unregisterOpaqueType(const std::string& alias) {
   auto typeIndex = std::type_index(typeid(Class));
+  OpaqueType::unregisterSerialization(OpaqueType::create<Class>(), alias);
   return getTypeIndexByOpaqueAlias().erase(alias) == 1 &&
       getOpaqueAliasByTypeIndex().erase(typeIndex) == 1;
 }
@@ -2254,6 +2513,42 @@ class DeserializedTypeCache {
 
 DeserializedTypeCache& deserializedTypeCache();
 
+template <typename T>
+std::string Type::valueToString(T value) const {
+  if constexpr (std::is_same_v<T, bool>) {
+    return value ? "true" : "false";
+  } else if constexpr (std::is_same_v<T, std::shared_ptr<void>>) {
+    return "<opaque>";
+  } else if constexpr (
+      std::is_same_v<T, int64_t> || std::is_same_v<T, int128_t>) {
+    if (isDecimal()) {
+      return LongDecimalType::toString(value, *this);
+    } else {
+      return velox::to<std::string>(value);
+    }
+  } else if constexpr (std::is_same_v<T, int32_t>) {
+    if (isDate()) {
+      return DATE()->toString(value);
+    } else {
+      return velox::to<std::string>(value);
+    }
+  } else {
+    return velox::to<std::string>(value);
+  }
+}
+
+/// Return a string representation of a limited number of elements at the
+/// start of the array or map.
+///
+/// @param size Total number of elements.
+/// @param stringifyElement Function to call to append individual elements.
+/// Will be called up to 'limit' times.
+/// @param limit Maximum number of elements to include in the result.
+std::string stringifyTruncatedElementList(
+    size_t size,
+    const std::function<void(std::stringstream&, size_t)>& stringifyElement,
+    size_t limit = 5);
+
 } // namespace facebook::velox
 
 namespace folly {
@@ -2276,7 +2571,7 @@ class FormatValue<facebook::velox::TypeKind> {
   template <typename FormatCallback>
   void format(FormatArg& arg, FormatCallback& cb) const {
     return format_value::formatString(
-        facebook::velox::mapTypeKindToName(type_), arg, cb);
+        facebook::velox::TypeKindName::toName(type_), arg, cb);
   }
 
  private:
@@ -2308,7 +2603,7 @@ struct fmt::formatter<facebook::velox::TypeKind> : fmt::formatter<string_view> {
   template <typename FormatContext>
   auto format(facebook::velox::TypeKind k, FormatContext& ctx) const {
     return formatter<string_view>::format(
-        facebook::velox::mapTypeKindToName(k), ctx);
+        facebook::velox::TypeKindName::toName(k), ctx);
   }
 };
 
diff --git a/velox/type/TypeCoercer.cpp b/velox/type/TypeCoercer.cpp
new file mode 100644
index 000000000000..a5a1bed40c50
--- /dev/null
+++ b/velox/type/TypeCoercer.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 "velox/type/TypeCoercer.h"
+
+namespace facebook::velox {
+
+int64_t Coercion::overallCost(const std::vector<Coercion>& coercions) {
+  int64_t cost = 0;
+  for (const auto& coercion : coercions) {
+    if (coercion.type != nullptr) {
+      cost += coercion.cost;
+    }
+  }
+
+  return cost;
+}
+
+namespace {
+
+std::unordered_map<std::pair<std::string, std::string>, Coercion>
+allowedCoercions() {
+  std::unordered_map<std::pair<std::string, std::string>, Coercion> coercions;
+
+  auto add = [&](const TypePtr& from, const std::vector<TypePtr>& to) {
+    int32_t cost = 0;
+    for (const auto& toType : to) {
+      coercions.emplace(
+          std::make_pair<std::string, std::string>(
+              from->kindName(), toType->kindName()),
+          Coercion{.type = toType, .cost = ++cost});
+    }
+  };
+
+  add(TINYINT(), {SMALLINT(), INTEGER(), BIGINT(), REAL(), DOUBLE()});
+  add(SMALLINT(), {INTEGER(), BIGINT(), REAL(), DOUBLE()});
+  add(INTEGER(), {BIGINT(), REAL(), DOUBLE()});
+  add(BIGINT(), {DOUBLE()});
+  add(REAL(), {DOUBLE()});
+
+  return coercions;
+}
+} // namespace
+
+// static
+std::optional<Coercion> TypeCoercer::coerceTypeBase(
+    const TypePtr& fromType,
+    const std::string& toTypeName) {
+  static const auto kAllowedCoercions = allowedCoercions();
+  if (fromType->name() == toTypeName) {
+    return Coercion{.type = fromType, .cost = 0};
+  }
+
+  auto it = kAllowedCoercions.find({fromType->name(), toTypeName});
+  if (it != kAllowedCoercions.end()) {
+    return it->second;
+  }
+
+  return std::nullopt;
+}
+
+// static
+std::optional<int32_t> TypeCoercer::coercible(
+    const TypePtr& fromType,
+    const TypePtr& toType) {
+  if (fromType->isUnKnown()) {
+    return 1;
+  }
+
+  if (fromType->size() == 0) {
+    if (auto coercion = TypeCoercer::coerceTypeBase(fromType, toType->name())) {
+      return coercion->cost;
+    }
+
+    return std::nullopt;
+  }
+
+  if (fromType->name() != toType->name() ||
+      fromType->size() != toType->size()) {
+    return std::nullopt;
+  }
+
+  int32_t totalCost = 0;
+  for (auto i = 0; i < fromType->size(); i++) {
+    if (auto cost = coercible(fromType->childAt(i), toType->childAt(i))) {
+      totalCost += cost.value();
+    } else {
+      return std::nullopt;
+    }
+  }
+
+  return totalCost;
+}
+
+// static
+TypePtr TypeCoercer::leastCommonSuperType(const TypePtr& a, const TypePtr& b) {
+  if (a->isUnKnown()) {
+    return b;
+  }
+
+  if (b->isUnKnown()) {
+    return a;
+  }
+
+  if (a->size() != b->size()) {
+    return nullptr;
+  }
+
+  if (a->size() == 0) {
+    if (TypeCoercer::coerceTypeBase(a, b->name())) {
+      return b;
+    }
+
+    if (TypeCoercer::coerceTypeBase(b, a->name())) {
+      return a;
+    }
+
+    return nullptr;
+  }
+
+  if (a->name() != b->name()) {
+    return nullptr;
+  }
+
+  std::vector<TypeParameter> childTypes;
+  childTypes.reserve(a->size());
+  for (auto i = 0; i < a->size(); i++) {
+    if (auto childType = leastCommonSuperType(a->childAt(i), b->childAt(i))) {
+      childTypes.push_back(TypeParameter(childType));
+    } else {
+      return nullptr;
+    }
+  }
+
+  return getType(a->name(), childTypes);
+}
+
+} // namespace facebook::velox
diff --git a/velox/type/TypeCoercer.h b/velox/type/TypeCoercer.h
new file mode 100644
index 000000000000..84b8a7e30ef8
--- /dev/null
+++ b/velox/type/TypeCoercer.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/type/Type.h"
+
+namespace facebook::velox {
+
+/// Type coercion necessary to bind a type to a signature.
+struct Coercion {
+  TypePtr type;
+  int32_t cost{0};
+
+  std::string toString() const {
+    if (type == nullptr) {
+      return "null";
+    }
+
+    return fmt::format("{} ({})", type->toString(), cost);
+  }
+
+  void reset() {
+    type = nullptr;
+    cost = 0;
+  }
+
+  /// Returns overall cost of a list of coercions by adding up individual costs.
+  static int64_t overallCost(const std::vector<Coercion>& coercions);
+
+  /// Returns an index of the lowest cost coercion in 'candidates' or nullptr if
+  /// 'candidates' is empty or there is a tie.
+  template <typename T>
+  static std::optional<size_t> pickLowestCost(
+      const std::vector<std::pair<std::vector<Coercion>, T>>& candidates) {
+    if (candidates.empty()) {
+      return std::nullopt;
+    }
+
+    if (candidates.size() == 1) {
+      return 0;
+    }
+
+    std::vector<std::pair<size_t, int64_t>> costs;
+    costs.reserve(candidates.size());
+    for (auto i = 0; i < candidates.size(); ++i) {
+      costs.emplace_back(i, overallCost(candidates[i].first));
+    }
+
+    std::sort(costs.begin(), costs.end(), [](const auto& a, const auto& b) {
+      return a.second < b.second;
+    });
+
+    if (costs[0].second < costs[1].second) {
+      return costs[0].first;
+    }
+
+    return std::nullopt;
+  }
+};
+
+class TypeCoercer {
+ public:
+  /// Checks if the base of 'fromType' can be implicitly converted to a type
+  /// with the given name.
+  ///
+  /// @return "to" type and cost if conversion is possible.
+  static std::optional<Coercion> coerceTypeBase(
+      const TypePtr& fromType,
+      const std::string& toTypeName);
+
+  /// Checks if 'fromType' can be implicitly converted to 'toType'.
+  ///
+  /// @return Cost of conversion is possible. std::nullopt otherwise.
+  static std::optional<int32_t> coercible(
+      const TypePtr& fromType,
+      const TypePtr& toType);
+
+  /// Returns least common type for 'a' and 'b', i.e. a type that both 'a' and
+  /// 'b' are coercible to. Returns nullptr if no such type exists.
+  static TypePtr leastCommonSuperType(const TypePtr& a, const TypePtr& b);
+};
+
+} // namespace facebook::velox
diff --git a/velox/type/TypeUtil.cpp b/velox/type/TypeUtil.cpp
index fc2645e5b742..01bb38445a8a 100644
--- a/velox/type/TypeUtil.cpp
+++ b/velox/type/TypeUtil.cpp
@@ -18,10 +18,9 @@
 
 namespace facebook::velox::type {
 
-velox::RowTypePtr concatRowTypes(
-    const std::vector<velox::RowTypePtr>& rowTypes) {
+RowTypePtr concatRowTypes(const std::vector<RowTypePtr>& rowTypes) {
   std::vector<std::string> columnNames;
-  std::vector<velox::TypePtr> columnTypes;
+  std::vector<TypePtr> columnTypes;
   for (auto& rowType : rowTypes) {
     columnNames.insert(
         columnNames.end(), rowType->names().begin(), rowType->names().end());
@@ -30,7 +29,28 @@ velox::RowTypePtr concatRowTypes(
         rowType->children().begin(),
         rowType->children().end());
   }
-  return velox::ROW(std::move(columnNames), std::move(columnTypes));
+  return ROW(std::move(columnNames), std::move(columnTypes));
+}
+
+TypePtr tryGetHomogeneousRowChild(const TypePtr& type) {
+  VELOX_DCHECK(type != nullptr);
+  if (type->kind() != TypeKind::ROW) {
+    return nullptr;
+  }
+
+  const auto childCount = type->size();
+  if (childCount == 0) {
+    return nullptr; // No child type to infer
+  }
+
+  const auto& first = type->childAt(0);
+  for (size_t i = 1; i < childCount; ++i) {
+    const auto& child = type->childAt(i);
+    if (!(*first == *child)) {
+      return nullptr;
+    }
+  }
+  return first;
 }
 
 } // namespace facebook::velox::type
diff --git a/velox/type/TypeUtil.h b/velox/type/TypeUtil.h
index ae03cc2570e2..00a6d346b55e 100644
--- a/velox/type/TypeUtil.h
+++ b/velox/type/TypeUtil.h
@@ -22,7 +22,11 @@
 
 namespace facebook::velox::type {
 
-velox::RowTypePtr concatRowTypes(
-    const std::vector<velox::RowTypePtr>& rowTypes);
+RowTypePtr concatRowTypes(const std::vector<RowTypePtr>& rowTypes);
+
+/// Returns the common child type if 'type' is a Row where all children are
+/// the same. Returns nullptr otherwise. Empty row returns nullptr.
+/// @pre 'type' must not be null.
+TypePtr tryGetHomogeneousRowChild(const TypePtr& type);
 
 } // namespace facebook::velox::type
diff --git a/velox/type/Variant.cpp b/velox/type/Variant.cpp
index add350c79009..1cf4daf35a1c 100644
--- a/velox/type/Variant.cpp
+++ b/velox/type/Variant.cpp
@@ -17,26 +17,21 @@
 #include "velox/type/Variant.h"
 #include <cfloat>
 #include "folly/json.h"
+#include "velox/common/base/BitUtil.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 {
-
 namespace {
-const folly::json::serialization_opts& getOpts() {
-  static const folly::json::serialization_opts opts_ = []() {
-    folly::json::serialization_opts opts;
-    opts.sort_keys = true;
-    return opts;
-  }();
-  return opts_;
-}
-} // namespace
+
+bool dispatchDynamicVariantEquality(
+    const Variant& a,
+    const Variant& b,
+    const bool& enableNullEqualsNull);
 
 template <bool nullEqualsNull>
-bool evaluateNullEquality(const variant& a, const variant& b) {
+bool evaluateNullEquality(const Variant& a, const Variant& b) {
   if constexpr (nullEqualsNull) {
     if (a.isNull() && b.isNull()) {
       return true;
@@ -45,11 +40,14 @@ bool evaluateNullEquality(const variant& a, const variant& b) {
   return false;
 }
 
+template <TypeKind KIND>
+struct VariantEquality;
+
 // scalars
 template <TypeKind KIND>
 struct VariantEquality {
   template <bool NullEqualsNull>
-  static bool equals(const variant& a, const variant& b) {
+  static bool equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
       return evaluateNullEquality<NullEqualsNull>(a, b);
     }
@@ -61,7 +59,7 @@ struct VariantEquality {
 template <>
 struct VariantEquality<TypeKind::TIMESTAMP> {
   template <bool NullEqualsNull>
-  static bool equals(const variant& a, const variant& b) {
+  static bool equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
       return evaluateNullEquality<NullEqualsNull>(a, b);
     } else {
@@ -74,7 +72,7 @@ struct VariantEquality<TypeKind::TIMESTAMP> {
 template <>
 struct VariantEquality<TypeKind::ARRAY> {
   template <bool NullEqualsNull>
-  static bool equals(const variant& a, const variant& b) {
+  static bool equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
       return evaluateNullEquality<NullEqualsNull>(a, b);
     }
@@ -98,7 +96,7 @@ struct VariantEquality<TypeKind::ARRAY> {
 template <>
 struct VariantEquality<TypeKind::ROW> {
   template <bool NullEqualsNull>
-  static bool equals(const variant& a, const variant& b) {
+  static bool equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
       return evaluateNullEquality<NullEqualsNull>(a, b);
     }
@@ -124,7 +122,7 @@ struct VariantEquality<TypeKind::ROW> {
 template <>
 struct VariantEquality<TypeKind::MAP> {
   template <bool NullEqualsNull>
-  static bool equals(const variant& a, const variant& b) {
+  static bool equals(const Variant& a, const Variant& b) {
     if (a.isNull() || b.isNull()) {
       return evaluateNullEquality<NullEqualsNull>(a, b);
     }
@@ -153,8 +151,8 @@ struct VariantEquality<TypeKind::MAP> {
 };
 
 bool dispatchDynamicVariantEquality(
-    const variant& a,
-    const variant& b,
+    const Variant& a,
+    const Variant& b,
     const bool& enableNullEqualsNull) {
   if (enableNullEqualsNull) {
     return VELOX_DYNAMIC_TYPE_DISPATCH_METHOD(
@@ -164,6 +162,8 @@ bool dispatchDynamicVariantEquality(
       VariantEquality, equals<false>, a.kind(), a, b);
 }
 
+} // namespace
+
 std::string encloseWithQuote(std::string str) {
   constexpr auto kDoubleQuote = '"';
 
@@ -181,25 +181,25 @@ std::string stringifyFloatingPointerValue(T val) {
   }
 }
 
-void variant::throwCheckIsKindError(TypeKind kind) const {
+void Variant::throwCheckIsKindError(TypeKind kind) const {
   throw std::invalid_argument{fmt::format(
       "wrong kind! {} != {}",
-      mapTypeKindToName(kind_),
-      mapTypeKindToName(kind))};
+      TypeKindName::toName(kind_),
+      TypeKindName::toName(kind))};
 }
 
-void variant::throwCheckPtrError() const {
-  throw std::invalid_argument{"missing variant value"};
+void Variant::throwCheckPtrError() const {
+  throw std::invalid_argument{"missing Variant value"};
 }
 
-std::string variant::toString(const TypePtr& type) const {
+std::string Variant::toString(const TypePtr& type) const {
   if (isNull()) {
     return "null";
   }
 
   VELOX_CHECK(type);
 
-  VELOX_CHECK_EQ(this->kind(), type->kind(), "Wrong type in variant::toString");
+  VELOX_CHECK_EQ(this->kind(), type->kind(), "Wrong type in Variant::toString");
 
   switch (type->kind()) {
     case TypeKind::VARBINARY: {
@@ -252,15 +252,102 @@ std::string variant::toString(const TypePtr& type) const {
     case TypeKind::FUNCTION:
     case TypeKind::UNKNOWN:
     case TypeKind::INVALID:
-      VELOX_NYI();
+      return toJson(type);
   }
 
-  VELOX_UNSUPPORTED(
-      "Given type {} is not supported in variant::toString()",
-      mapTypeKindToName(kind_));
+  folly::assume_unreachable();
+}
+
+namespace {
+
+std::string toStringAsVectorImpl(const TypePtr& type, const Variant& value);
+
+template <TypeKind Kind>
+std::string toStringAsVectorNoNull(const TypePtr& type, const Variant& value) {
+  using T = typename TypeTraits<Kind>::NativeType;
+
+  return type->template valueToString<T>(T(value.value<Kind>()));
+}
+
+template <>
+std::string toStringAsVectorNoNull<TypeKind::OPAQUE>(
+    const TypePtr& type,
+    const Variant& value) {
+  return "<opaque>";
+}
+
+template <>
+std::string toStringAsVectorNoNull<TypeKind::ARRAY>(
+    const TypePtr& type,
+    const Variant& value) {
+  const auto& arrayValue = value.value<TypeKind::ARRAY>();
+  const auto& elementType = type->childAt(0);
+
+  return stringifyTruncatedElementList(
+      arrayValue.size(), [&](auto& out, auto i) {
+        out << toStringAsVectorImpl(elementType, arrayValue.at(i));
+      });
+}
+
+template <>
+std::string toStringAsVectorNoNull<TypeKind::MAP>(
+    const TypePtr& type,
+    const Variant& value) {
+  const auto& mapValue = value.value<TypeKind::MAP>();
+  const auto& keyType = type->childAt(0);
+  const auto& valueType = type->childAt(1);
+
+  auto it = mapValue.begin();
+
+  return stringifyTruncatedElementList(mapValue.size(), [&](auto& out, auto i) {
+    out << toStringAsVectorImpl(keyType, it->first) << " => "
+        << toStringAsVectorImpl(valueType, it->second);
+    ++it;
+  });
+}
+
+template <>
+std::string toStringAsVectorNoNull<TypeKind::ROW>(
+    const TypePtr& type,
+    const Variant& value) {
+  const auto size = type->size();
+
+  const auto& rowValue = value.value<TypeKind::ROW>();
+  VELOX_CHECK_EQ(size, rowValue.size());
+
+  return stringifyTruncatedElementList(size, [&](auto& out, auto i) {
+    out << toStringAsVectorImpl(type->childAt(i), rowValue.at(i));
+  });
+}
+
+std::string toStringAsVectorImpl(const TypePtr& type, const Variant& value) {
+  if (value.isNull()) {
+    return "null";
+  }
+
+  return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
+      toStringAsVectorNoNull, type->kind(), type, value);
 }
 
-std::string variant::toJson(const TypePtr& type) const {
+} // namespace
+
+std::string Variant::toStringAsVector(const TypePtr& type) const {
+  return toStringAsVectorImpl(type, *this);
+}
+
+namespace {
+const folly::json::serialization_opts& getOpts() {
+  static const folly::json::serialization_opts kOpts;
+  return kOpts;
+}
+} // namespace
+
+std::string Variant::toJson(const TypePtr& type) const {
+  VELOX_CHECK(type);
+  return toJson(*type);
+}
+
+std::string Variant::toJson(const Type& type) const {
   // todo(youknowjack): consistent story around std::stringifying, converting,
   // and other basic operations. Stringification logic should not be specific
   // to variants; it should be consistent for all map representations
@@ -269,9 +356,7 @@ std::string variant::toJson(const TypePtr& type) const {
     return "null";
   }
 
-  VELOX_CHECK(type);
-
-  VELOX_CHECK_EQ(this->kind(), type->kind(), "Wrong type in variant::toJson");
+  VELOX_CHECK_EQ(this->kind(), type.kind(), "Wrong type in Variant::toJson");
 
   switch (kind_) {
     case TypeKind::MAP: {
@@ -284,9 +369,9 @@ std::string variant::toJson(const TypePtr& type) const {
           b += ",";
         }
         b += "{\"key\":";
-        b += pair.first.toJson(type->childAt(0));
+        b += pair.first.toJson(type.childAt(0));
         b += ",\"value\":";
-        b += pair.second.toJson(type->childAt(1));
+        b += pair.second.toJson(type.childAt(1));
         b += "}";
         first = false;
       }
@@ -301,13 +386,13 @@ std::string variant::toJson(const TypePtr& type) const {
       uint32_t idx = 0;
       VELOX_CHECK_EQ(
           row.size(),
-          type->size(),
-          "Wrong number of fields in a struct in variant::toJson");
+          type.size(),
+          "Wrong number of fields in a struct in Variant::toJson");
       for (auto& v : row) {
         if (!first) {
           b += ",";
         }
-        b += v.toJson(type->childAt(idx++));
+        b += v.toJson(type.childAt(idx++));
         first = false;
       }
       b += "]";
@@ -318,7 +403,7 @@ std::string variant::toJson(const TypePtr& type) const {
       std::string b{};
       b += "[";
       bool first = true;
-      auto arrayElementType = type->childAt(0);
+      auto arrayElementType = type.childAt(0);
       for (auto& v : array) {
         if (!first) {
           b += ",";
@@ -341,7 +426,7 @@ std::string variant::toJson(const TypePtr& type) const {
       return target;
     }
     case TypeKind::HUGEINT: {
-      VELOX_CHECK(type->isLongDecimal());
+      VELOX_CHECK(type.isLongDecimal());
       return DecimalUtil::toString(value<TypeKind::HUGEINT>(), type);
     }
     case TypeKind::TINYINT:
@@ -349,12 +434,12 @@ std::string variant::toJson(const TypePtr& type) const {
     case TypeKind::SMALLINT:
       [[fallthrough]];
     case TypeKind::INTEGER:
-      if (type->isDate()) {
+      if (type.isDate()) {
         return '"' + DATE()->toString(value<TypeKind::INTEGER>()) + '"';
       }
       [[fallthrough]];
     case TypeKind::BIGINT:
-      if (type->isShortDecimal()) {
+      if (type.isShortDecimal()) {
         return DecimalUtil::toString(value<TypeKind::BIGINT>(), type);
       }
       [[fallthrough]];
@@ -394,12 +479,13 @@ std::string variant::toJson(const TypePtr& type) const {
   }
 
   VELOX_UNSUPPORTED(
-      "Unsupported: given type {} is not json-ready", mapTypeKindToName(kind_));
+      "Unsupported: given type {} is not json-ready",
+      TypeKindName::toName(kind_));
 }
 
 // This is the unsafe older implementation of toJson. It is kept here for
 // backward compatibility with Meta's internal python bindings.
-std::string variant::toJsonUnsafe(const TypePtr& type) const {
+std::string Variant::toJsonUnsafe(const TypePtr& type) const {
   if (isNull()) {
     return "null";
   }
@@ -520,7 +606,8 @@ std::string variant::toJsonUnsafe(const TypePtr& type) const {
   }
 
   VELOX_UNSUPPORTED(
-      "Unsupported: given type {} is not json-ready", mapTypeKindToName(kind_));
+      "Unsupported: given type {} is not json-ready",
+      TypeKindName::toName(kind_));
 }
 
 void serializeOpaque(
@@ -539,11 +626,10 @@ void serializeOpaque(
   }
 }
 
-folly::dynamic variant::serialize() const {
+folly::dynamic Variant::serialize() const {
   folly::dynamic variantObj = folly::dynamic::object;
 
-  variantObj["type"] = std::string(
-      VELOX_STATIC_FIELD_DYNAMIC_DISPATCH_ALL(TypeTraits, name, kind_));
+  variantObj["type"] = std::string(TypeKindName::toName(kind_));
   auto& objValue = variantObj["value"];
   if (isNull()) {
     objValue = nullptr;
@@ -636,7 +722,7 @@ folly::dynamic variant::serialize() const {
   return variantObj;
 }
 
-variant deserializeOpaque(const folly::dynamic& variantobj) {
+Variant deserializeOpaque(const folly::dynamic& variantobj) {
   auto typ = folly::parseJson(variantobj["opaque_type"].asString());
   auto opaqueType =
       std::dynamic_pointer_cast<const OpaqueType>(Type::create(typ));
@@ -644,7 +730,7 @@ variant deserializeOpaque(const folly::dynamic& variantobj) {
   try {
     auto deserializeFunc = opaqueType->getDeserializeFunc();
     auto value = variantobj["value"].asString();
-    return variant::opaque(deserializeFunc(value), opaqueType);
+    return Variant::opaque(deserializeFunc(value), opaqueType);
   } catch (VeloxRuntimeError& ex) {
     // Re-throw error for backwards compatibility.
     // Want to return error_code::kNotImplemented rather
@@ -652,58 +738,59 @@ variant deserializeOpaque(const folly::dynamic& variantobj) {
     VELOX_NYI(ex.message());
   }
 }
-variant variant::create(const folly::dynamic& variantobj) {
-  TypeKind kind = mapNameToTypeKind(variantobj["type"].asString());
+
+Variant Variant::create(const folly::dynamic& variantobj) {
+  TypeKind kind = TypeKindName::toTypeKind(variantobj["type"].asString());
   const folly::dynamic& obj = variantobj["value"];
 
   if (obj.isNull()) {
-    return variant::null(kind);
+    return Variant::null(kind);
   }
   switch (kind) {
     case TypeKind::MAP: {
-      std::map<variant, variant> map;
+      std::map<Variant, Variant> 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 = variant::create(keys[idx]);
-        auto second = variant::create(values[idx]);
-        map.insert(std::pair<variant, variant>(first, second));
+        auto first = Variant::create(keys[idx]);
+        auto second = Variant::create(values[idx]);
+        map.insert(std::pair<Variant, Variant>(first, second));
       }
-      return variant::map(map);
+      return Variant::map(map);
     }
     case TypeKind::ROW:
       [[fallthrough]];
     case TypeKind::ARRAY: {
       VELOX_USER_CHECK(kind == TypeKind::ARRAY || kind == TypeKind::ROW);
-      std::vector<variant> values;
+      std::vector<Variant> values;
       for (auto& val : obj) {
-        values.push_back(variant::create(val));
+        values.push_back(Variant::create(val));
       }
-      return kind == TypeKind::ARRAY ? variant::array(values)
-                                     : variant::row(values);
+      return kind == TypeKind::ARRAY ? Variant::array(values)
+                                     : Variant::row(values);
     }
 
     case TypeKind::VARBINARY: {
       auto str = obj.asString();
       auto result = encoding::Base64::decode(str);
-      return variant::binary(std::move(result));
+      return Variant::binary(std::move(result));
     }
     case TypeKind::VARCHAR:
-      return variant::create<TypeKind::VARCHAR>(obj.asString());
+      return Variant::create<TypeKind::VARCHAR>(obj.asString());
     case TypeKind::TINYINT:
-      return variant::create<TypeKind::TINYINT>(obj.asInt());
+      return Variant::create<TypeKind::TINYINT>(obj.asInt());
     case TypeKind::SMALLINT:
-      return variant::create<TypeKind::SMALLINT>(obj.asInt());
+      return Variant::create<TypeKind::SMALLINT>(obj.asInt());
     case TypeKind::INTEGER:
-      return variant::create<TypeKind::INTEGER>(obj.asInt());
+      return Variant::create<TypeKind::INTEGER>(obj.asInt());
     case TypeKind::BIGINT:
-      return variant::create<TypeKind::BIGINT>(obj.asInt());
+      return Variant::create<TypeKind::BIGINT>(obj.asInt());
     case TypeKind::HUGEINT:
-      return variant::create<TypeKind::HUGEINT>(obj.asInt());
+      return Variant::create<TypeKind::HUGEINT>(obj.asInt());
     case TypeKind::BOOLEAN: {
-      return variant(obj.asBool());
+      return Variant(obj.asBool());
     }
     case TypeKind::REAL:
       if (obj.isInt()) {
@@ -711,20 +798,20 @@ variant variant::create(const folly::dynamic& variantobj) {
         // to int64 instead of double, and asDouble() will throw
         // "folly::ConversionError: Loss of precision", so we do
         // the check here to make it more robust.
-        return variant::create<TypeKind::REAL>(obj.asInt());
+        return Variant::create<TypeKind::REAL>(obj.asInt());
       }
-      return variant::create<TypeKind::REAL>(obj.asDouble());
+      return Variant::create<TypeKind::REAL>(obj.asDouble());
     case TypeKind::DOUBLE: {
       if (obj.isInt()) {
-        return variant::create<TypeKind::DOUBLE>(obj.asInt());
+        return Variant::create<TypeKind::DOUBLE>(obj.asInt());
       }
-      return variant::create<TypeKind::DOUBLE>(obj.asDouble());
+      return Variant::create<TypeKind::DOUBLE>(obj.asDouble());
     }
     case TypeKind::OPAQUE: {
       return deserializeOpaque(variantobj);
     }
     case TypeKind::TIMESTAMP: {
-      return variant::create<TypeKind::TIMESTAMP>(Timestamp(
+      return Variant::create<TypeKind::TIMESTAMP>(Timestamp(
           variantobj["seconds"].asInt(), variantobj["nanos"].asInt()));
     }
     case TypeKind::INVALID:
@@ -732,13 +819,13 @@ variant variant::create(const folly::dynamic& variantobj) {
 
     default:
       VELOX_UNSUPPORTED(
-          "specified object can not be converted to variant ",
+          "specified object can not be converted to Variant: {}",
           variantobj["type"].asString());
   }
 }
 
 template <TypeKind KIND>
-bool variant::lessThan(const variant& other) const {
+bool Variant::lessThan(const Variant& other) const {
   using namespace facebook::velox::util::floating_point;
   if (isNull() && !other.isNull()) {
     return true;
@@ -761,7 +848,7 @@ bool variant::lessThan(const variant& other) const {
   return value<KIND>() < other.value<KIND>();
 }
 
-bool variant::operator<(const variant& other) const {
+bool Variant::operator<(const Variant& other) const {
   if (other.kind_ != this->kind_) {
     return other.kind_ < this->kind_;
   }
@@ -769,7 +856,7 @@ bool variant::operator<(const variant& other) const {
 }
 
 template <TypeKind KIND>
-bool variant::equals(const variant& other) const {
+bool Variant::equals(const Variant& other) const {
   using namespace facebook::velox::util::floating_point;
   if (isNull() || other.isNull()) {
     return false;
@@ -789,7 +876,7 @@ bool variant::equals(const variant& other) const {
   return value<KIND>() == other.value<KIND>();
 }
 
-bool variant::equals(const variant& other) const {
+bool Variant::equals(const Variant& other) const {
   if (other.kind_ != this->kind_) {
     return false;
   }
@@ -800,7 +887,7 @@ bool variant::equals(const variant& other) const {
 }
 
 template <TypeKind KIND>
-uint64_t variant::hash() const {
+uint64_t Variant::hash() const {
   using namespace facebook::velox::util::floating_point;
   using T = typename TypeTraits<KIND>::NativeType;
 
@@ -818,57 +905,46 @@ uint64_t variant::hash() const {
 }
 
 template <>
-uint64_t variant::hash<TypeKind::ARRAY>() const {
-  auto& arrayVariant = value<TypeKind::ARRAY>();
-  auto hasher = folly::Hash{};
-  uint64_t hash = 0;
-  for (int32_t i = 0; i < arrayVariant.size(); i++) {
-    hash =
-        folly::hash::hash_combine_generic(hasher, hash, arrayVariant[i].hash());
+uint64_t Variant::hash<TypeKind::ARRAY>() const {
+  const auto& arrayVariant = value<TypeKind::ARRAY>();
+  uint64_t hash = bits::kNullHash;
+  for (int32_t i = 0; i < arrayVariant.size(); ++i) {
+    hash = bits::hashMix(hash, arrayVariant[i].hash());
   }
   return hash;
 }
 
 template <>
-uint64_t variant::hash<TypeKind::ROW>() const {
-  auto hasher = folly::Hash{};
-  uint64_t hash = 0;
-  auto& rowVariant = value<TypeKind::ROW>();
-  for (int32_t i = 0; i < rowVariant.size(); i++) {
-    hash =
-        folly::hash::hash_combine_generic(hasher, hash, rowVariant[i].hash());
+uint64_t Variant::hash<TypeKind::ROW>() const {
+  const auto& rowVariant = value<TypeKind::ROW>();
+  uint64_t hash = bits::kNullHash;
+  for (int32_t i = 0; i < rowVariant.size(); ++i) {
+    const auto childHash = rowVariant[i].hash();
+    hash = (i == 0 ? childHash : bits::hashMix(hash, childHash));
   }
   return hash;
 }
 
 template <>
-uint64_t variant::hash<TypeKind::TIMESTAMP>() const {
+uint64_t Variant::hash<TypeKind::TIMESTAMP>() const {
   auto timestampValue = value<TypeKind::TIMESTAMP>();
   return folly::Hash{}(timestampValue.getSeconds(), timestampValue.getNanos());
 }
 
 template <>
-uint64_t variant::hash<TypeKind::MAP>() const {
-  auto hasher = folly::Hash{};
-  auto& mapVariant = value<TypeKind::MAP>();
-  uint64_t combinedKeyHash = 0, combinedValueHash = 0;
-  uint64_t singleKeyHash = 0, singleValueHash = 0;
-  for (auto it = mapVariant.begin(); it != mapVariant.end(); ++it) {
-    singleKeyHash = it->first.hash();
-    singleValueHash = it->second.hash();
-    combinedKeyHash = folly::hash::commutative_hash_combine_value_generic(
-        combinedKeyHash, hasher, singleKeyHash);
-    combinedValueHash = folly::hash::commutative_hash_combine_value_generic(
-        combinedValueHash, hasher, singleValueHash);
+uint64_t Variant::hash<TypeKind::MAP>() const {
+  const auto& mapVariant = value<TypeKind::MAP>();
+  uint64_t hash = bits::kNullHash;
+  for (const auto& [key, value] : mapVariant) {
+    const auto elementHash = bits::hashMix(key.hash(), value.hash());
+    hash = bits::commutativeHashMix(hash, elementHash);
   }
-
-  return folly::hash::hash_combine_generic(
-      folly::Hash{}, combinedKeyHash, combinedValueHash);
+  return hash;
 }
 
-uint64_t variant::hash() const {
+uint64_t Variant::hash() const {
   if (isNull()) {
-    return folly::Hash{}(static_cast<int32_t>(kind_));
+    return bits::kNullHash;
   }
 
   return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(hash, kind_);
@@ -881,7 +957,7 @@ namespace {
 // https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
 // for details.
 template <TypeKind KIND, typename TFloat>
-bool equalsFloatingPointWithEpsilonTyped(const variant& a, const variant& b) {
+bool equalsFloatingPointWithEpsilonTyped(const Variant& a, const Variant& b) {
   TFloat f1 = a.value<KIND>();
   TFloat f2 = b.value<KIND>();
 
@@ -897,7 +973,7 @@ bool equalsFloatingPointWithEpsilonTyped(const variant& a, const variant& b) {
 
   // Check if the numbers are really close -- needed
   // when comparing numbers near zero.
-  if (fabs(f1 - f2) < kEpsilon) {
+  if (fabs(f1 - f2) < Variant::kEpsilon) {
     return true;
   }
 
@@ -906,7 +982,7 @@ bool equalsFloatingPointWithEpsilonTyped(const variant& a, const variant& b) {
   return fabs(f1 - f2) <= largest * 2 * FLT_EPSILON;
 }
 
-bool equalsFloatingPointWithEpsilon(const variant& a, const variant& b) {
+bool equalsFloatingPointWithEpsilon(const Variant& a, const Variant& b) {
   if (a.isNull() or b.isNull()) {
     return false;
   }
@@ -920,7 +996,7 @@ bool equalsFloatingPointWithEpsilon(const variant& a, const variant& b) {
 }
 } // namespace
 
-bool variant::lessThanWithEpsilon(const variant& other) const {
+bool Variant::lessThanWithEpsilon(const Variant& other) const {
   if (other.kind_ != this->kind_) {
     return other.kind_ < this->kind_;
   }
@@ -946,7 +1022,7 @@ namespace {
 
 // Compare variants of Array or Row type.
 template <TypeKind KIND>
-bool compareComplexTypeWithEpsilon(const variant& left, const variant& right) {
+bool compareComplexTypeWithEpsilon(const Variant& left, const Variant& right) {
   auto& leftContainer = left.value<KIND>();
   auto& rightContainer = right.value<KIND>();
   if (leftContainer.size() != rightContainer.size()) {
@@ -963,8 +1039,8 @@ bool compareComplexTypeWithEpsilon(const variant& left, const variant& right) {
 // Compare variants of Map type.
 template <>
 bool compareComplexTypeWithEpsilon<TypeKind::MAP>(
-    const variant& left,
-    const variant& right) {
+    const Variant& left,
+    const Variant& right) {
   auto& leftMap = left.value<TypeKind::MAP>();
   auto& rightMap = right.value<TypeKind::MAP>();
   if (leftMap.size() != rightMap.size()) {
@@ -983,9 +1059,9 @@ bool compareComplexTypeWithEpsilon<TypeKind::MAP>(
 }
 } // namespace
 
-// Uses kEpsilon to compare floating point types (REAL and DOUBLE).
+// Uses Variant::kEpsilon to compare floating point types (REAL and DOUBLE).
 // For testing purposes.
-bool variant::equalsWithEpsilon(const variant& other) const {
+bool Variant::equalsWithEpsilon(const Variant& other) const {
   if (other.kind_ != this->kind_) {
     return false;
   }
@@ -1008,7 +1084,7 @@ bool variant::equalsWithEpsilon(const variant& other) const {
   }
 }
 
-void variant::verifyArrayElements(const std::vector<variant>& inputs) {
+void Variant::verifyArrayElements(const std::vector<Variant>& inputs) {
   if (!inputs.empty()) {
     auto elementTypeKind = TypeKind::UNKNOWN;
     // Find the typeKind from the first non-null element.
@@ -1031,6 +1107,141 @@ void variant::verifyArrayElements(const std::vector<variant>& inputs) {
   }
 }
 
+bool Variant::equalsWithNullEqualsNull(const Variant& other) const {
+  if (other.kind_ != this->kind_) {
+    return false;
+  }
+  return dispatchDynamicVariantEquality(*this, other, true);
+}
+
+TypePtr Variant::inferType() const {
+  switch (kind_) {
+    case TypeKind::MAP: {
+      TypePtr keyType;
+      TypePtr valueType;
+      if (!isNull()) {
+        const auto& m = map();
+        for (const auto& [key, value] : m) {
+          if (keyType == nullptr && !key.isNull()) {
+            keyType = key.inferType();
+          }
+          if (valueType == nullptr && !value.isNull()) {
+            valueType = value.inferType();
+          }
+          if (keyType && valueType) {
+            break;
+          }
+        }
+      }
+      return MAP(
+          keyType ? keyType : UNKNOWN(), valueType ? valueType : UNKNOWN());
+    }
+    case TypeKind::ROW: {
+      std::vector<TypePtr> children;
+      if (!isNull()) {
+        const auto& r = row();
+        children.reserve(r.size());
+        for (auto& v : r) {
+          children.push_back(v.inferType());
+        }
+      }
+      return ROW(std::move(children));
+    }
+    case TypeKind::ARRAY: {
+      TypePtr elementType = UNKNOWN();
+      if (!isNull()) {
+        const auto& a = array();
+        if (!a.empty()) {
+          elementType = a.at(0).inferType();
+        }
+      }
+      return ARRAY(std::move(elementType));
+    }
+    case TypeKind::OPAQUE: {
+      if (isNull()) {
+        return UNKNOWN();
+      }
+      return value<TypeKind::OPAQUE>().type;
+    }
+    case TypeKind::UNKNOWN: {
+      return UNKNOWN();
+    }
+    default:
+      return createScalarType(kind_);
+  }
+}
+
+bool Variant::isTypeCompatible(const TypePtr& type) const {
+  if (kind_ == TypeKind::UNKNOWN) {
+    return true;
+  }
+
+  if (kind_ != type->kind()) {
+    return false;
+  }
+
+  switch (kind_) {
+    case TypeKind::ARRAY: {
+      if (!isNull()) {
+        const auto& a = array();
+        if (!a.empty()) {
+          if (!a[0].isTypeCompatible(type->childAt(0))) {
+            return false;
+          }
+        }
+      }
+
+      return true;
+    }
+    case TypeKind::MAP: {
+      if (!isNull()) {
+        bool keyTypeChecked = false;
+        bool valueTypeChecked = false;
+
+        const auto& m = map();
+        for (auto& [key, value] : m) {
+          if (!keyTypeChecked && !key.isNull()) {
+            if (!key.isTypeCompatible(type->childAt(0))) {
+              return false;
+            }
+            keyTypeChecked = true;
+          }
+          if (!valueTypeChecked && !value.isNull()) {
+            if (!value.isTypeCompatible(type->childAt(1))) {
+              return false;
+            }
+            valueTypeChecked = true;
+          }
+
+          if (keyTypeChecked && valueTypeChecked) {
+            break;
+          }
+        }
+      }
+
+      return true;
+    }
+    case TypeKind::ROW: {
+      if (!isNull()) {
+        const auto& r = row();
+        if (r.size() != type->size()) {
+          return false;
+        }
+
+        for (auto i = 0; i < r.size(); ++i) {
+          if (!r[i].isTypeCompatible(type->childAt(i))) {
+            return false;
+          }
+        }
+      }
+
+      return true;
+    }
+    default:
+      return true;
+  }
+}
+
 } // namespace facebook::velox
 
 namespace folly {
diff --git a/velox/type/Variant.h b/velox/type/Variant.h
index fd2b8d0c1b61..e2b21b4aff46 100644
--- a/velox/type/Variant.h
+++ b/velox/type/Variant.h
@@ -23,43 +23,96 @@
 
 #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 {
 
-// Constant used in comparison of REAL and DOUBLE values.
-constexpr double kEpsilon{0.00001};
-
-// note: while this is not intended for use in real critical code paths,
-//       it's probably worthwhile to make it not completely suck
-// todo(youknowjack): make this class not completely suck
-
-struct VariantConverter;
-
-class variant;
-
-template <TypeKind KIND>
-struct VariantEquality;
-
-template <>
-struct VariantEquality<TypeKind::TIMESTAMP>;
-
-template <>
-struct VariantEquality<TypeKind::ARRAY>;
-
-template <>
-struct VariantEquality<TypeKind::ROW>;
-
-template <>
-struct VariantEquality<TypeKind::MAP>;
-
-bool dispatchDynamicVariantEquality(
-    const variant& a,
-    const variant& b,
-    const bool& enableNullEqualsNull);
+/// Variant is a dynamically-typed container that can hold values of any Velox
+/// type, providing a type-safe way to work with heterogeneous data at runtime.
+///
+/// A Variant encapsulates a value along with its TypeKind, supporting all Velox
+/// types including scalars (INTEGER, VARCHAR, DOUBLE, etc.), complex types
+/// (ARRAY, MAP, ROW), and special types (TIMESTAMP, OPAQUE). Variants can also
+/// represent null values of any type.
+///
+/// Note that Variants only store the physical type of a variable (the
+/// TypeKind), and not its logical type (TypePtr). Variants also do not store
+/// the field names of a row/struct.
+///
+/// **IMPORTANT**: Variants are NOT intended for performance-critical code
+/// paths. For production workloads processing large amounts of data, use
+/// Vectors instead:
+///
+/// ## Supported Types
+///
+/// Scalar types:
+/// - Numeric: BOOLEAN, TINYINT, SMALLINT, INTEGER, BIGINT, HUGEINT, REAL,
+///   DOUBLE
+/// - String: VARCHAR, VARBINARY
+/// - Temporal: TIMESTAMP, DATE (via INTEGER)
+/// - Special: UNKNOWN (null variant)
+///
+/// Complex types:
+/// - ARRAY: Ordered collection of Variants (all elements must have same
+///   TypeKind)
+/// - MAP: Key-value mapping of Variants
+/// - ROW: Heterogeneous tuple of Variants
+///
+/// Special types:
+/// - OPAQUE: Type-erased wrapper for custom C++ objects
+///
+/// ## Construction and Factory Methods
+///
+/// Variants can be created via:
+/// - Implicit constructors from native types: `Variant(42)`, `Variant("hello")`
+/// - Explicit factory methods: `Variant::create<KIND>(value)`
+/// - Type-specific factories: `Variant::array()`, `Variant::map()`,
+///   `Variant::row()`
+/// - Null values: `Variant::null(TypeKind)` or `Variant(TypeKind)`
+/// - Deserialization: `Variant::create(folly::dynamic)`
+///
+/// ## Type Safety and Value Access
+///
+/// Variants provide runtime type checking:
+/// - `kind()` returns the TypeKind
+/// - `value<KIND>()` extracts the value (throws if wrong type)
+/// - `isNull()` checks for null values
+/// - `inferType()` returns the full Type descriptor
+///
+/// ## Example Usage
+///
+/// ```cpp
+/// // Creating variants
+/// Variant intVar = 42;                    // INTEGER
+/// Variant strVar = "hello";               // VARCHAR
+/// Variant dblVar = 3.14;                  // DOUBLE
+/// Variant nullVar = Variant::null(TypeKind::INTEGER);
+///
+/// // Complex types
+/// Variant arr = Variant::array({Variant(1), Variant(2), Variant(3)});
+/// Variant map = Variant::map({{Variant("key"), Variant("value")}});
+/// Variant row = Variant::row({Variant(1), Variant("test"), Variant(3.14)});
+///
+/// // Accessing values
+/// int32_t i = intVar.value<TypeKind::INTEGER>();
+/// std::string s = strVar.value<TypeKind::VARCHAR>();
+/// const auto& elements = arr.value<TypeKind::ARRAY>();
+///
+/// // Serialization
+/// auto serialized = arr.serialize();              // to folly::dynamic
+/// auto deserialized = Variant::create(serialized); // from folly::dynamic
+/// assert(arr == deserialized);
+/// ```
+///
+/// ## Memory and Lifetime
+///
+/// - Variants own their data and perform deep copies on assignment.
+/// - Values are heap-allocated (except for primitive types).
+/// - Variants are movable and copyable with expected semantics
+/// - For OPAQUE types, Variants hold shared_ptr, allowing shared ownership.
+class Variant;
 
 namespace detail {
 template <typename T, TypeKind KIND, bool usesCustomComparison>
@@ -85,8 +138,7 @@ struct VariantTypeTraits<
     KIND,
     usesCustomComparison,
     std::enable_if_t<
-        TypeTraits<KIND>::isPrimitiveType && KIND != TypeKind::VARCHAR &&
-            KIND != TypeKind::VARBINARY,
+        TypeTraits<KIND>::isPrimitiveType && !is_string_kind(KIND),
         void>> {
   using native_type = typename TypeTraits<KIND>::NativeType;
   using stored_type =
@@ -98,10 +150,8 @@ template <TypeKind KIND, bool usesCustomComparison>
 struct VariantTypeTraits<
     KIND,
     usesCustomComparison,
-    std::enable_if_t<
-        KIND == TypeKind::VARCHAR || KIND == TypeKind::VARBINARY,
-        void>> {
-  using native_type = folly::StringPiece;
+    std::enable_if_t<is_string_kind(KIND), void>> {
+  using native_type = std::string_view;
   using stored_type =
       TypeStorage<scalar_stored_type<KIND>, KIND, usesCustomComparison>;
   using value_type = scalar_stored_type<KIND>;
@@ -110,24 +160,24 @@ struct VariantTypeTraits<
 template <bool usesCustomComparison>
 struct VariantTypeTraits<TypeKind::ROW, usesCustomComparison> {
   using stored_type =
-      TypeStorage<std::vector<variant>, TypeKind::ROW, usesCustomComparison>;
-  using value_type = std::vector<variant>;
+      TypeStorage<std::vector<Variant>, TypeKind::ROW, usesCustomComparison>;
+  using value_type = std::vector<Variant>;
 };
 
 template <bool usesCustomComparison>
 struct VariantTypeTraits<TypeKind::MAP, usesCustomComparison> {
   using stored_type = TypeStorage<
-      std::map<variant, variant>,
+      std::map<Variant, Variant>,
       TypeKind::MAP,
       usesCustomComparison>;
-  using value_type = std::map<variant, variant>;
+  using value_type = std::map<Variant, Variant>;
 };
 
 template <bool usesCustomComparison>
 struct VariantTypeTraits<TypeKind::ARRAY, usesCustomComparison> {
   using stored_type =
-      TypeStorage<std::vector<variant>, TypeKind::ARRAY, usesCustomComparison>;
-  using value_type = std::vector<variant>;
+      TypeStorage<std::vector<Variant>, TypeKind::ARRAY, usesCustomComparison>;
+  using value_type = std::vector<Variant>;
 };
 
 struct OpaqueCapsule {
@@ -154,99 +204,66 @@ struct VariantTypeTraits<TypeKind::OPAQUE, usesCustomComparison> {
 };
 } // namespace detail
 
-class variant {
- private:
-  variant(TypeKind kind, void* ptr, bool usesCustomComparison = false)
-      : ptr_{ptr}, kind_{kind}, usesCustomComparison_(usesCustomComparison) {}
-
-  template <TypeKind KIND>
-  bool lessThan(const variant& other) const;
-
-  template <TypeKind KIND>
-  bool equals(const variant& other) const;
-
-  template <TypeKind KIND>
-  uint64_t hash() const;
-
-  template <bool usesCustomComparison, TypeKind KIND>
-  void typedDestroy() {
-    delete static_cast<const typename detail::VariantTypeTraits<
-        KIND,
-        usesCustomComparison>::stored_type*>(ptr_);
-    ptr_ = nullptr;
-  }
-
-  template <bool usesCustomComparison, TypeKind KIND>
-  void typedCopy(const void* other) {
-    using stored_type = typename detail::
-        VariantTypeTraits<KIND, usesCustomComparison>::stored_type;
-    ptr_ = new stored_type{*static_cast<const stored_type*>(other)};
-  }
+class Variant {
+ public:
+  /// Constructs a NULL variant with type set to UNKNOWN.
+  Variant()
+      : ptr_{nullptr}, kind_{TypeKind::UNKNOWN}, usesCustomComparison_(false) {}
 
-  void dynamicCopy(const void* p, const TypeKind kind) {
-    if (usesCustomComparison_) {
-      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedCopy, true, kind, p);
-    } else {
-      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedCopy, false, kind, p);
-    }
-  }
+  /* implicit */ Variant(TypeKind kind)
+      : ptr_{nullptr}, kind_{kind}, usesCustomComparison_(false) {}
 
-  void dynamicFree() {
-    if (usesCustomComparison_) {
-      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedDestroy, true, kind_);
-    } else {
-      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedDestroy, false, kind_);
+  Variant(const Variant& other)
+      : ptr_{nullptr},
+        kind_{other.kind_},
+        usesCustomComparison_(other.usesCustomComparison_) {
+    auto op = other.ptr_;
+    if (op != nullptr) {
+      dynamicCopy(other.ptr_, other.kind_);
     }
   }
 
-  template <TypeKind K>
-  static const std::shared_ptr<const Type> kind2type() {
-    return TypeFactory<K>::create();
-  }
-
-  [[noreturn]] void throwCheckIsKindError(TypeKind kind) const;
+  /// String construction methods.
+  // Support construction from velox::StringView as well as std::string_view.
+  /* implicit */ Variant(StringView view) : Variant{std::string_view{view}} {}
 
-  [[noreturn]] void throwCheckPtrError() const;
-
- public:
-  struct Hasher {
-    size_t operator()(variant const& input) const noexcept {
-      return input.hash();
-    }
-  };
+  // Break ties between implicit conversions to StringView/std::string_view.
+  /* implicit */ Variant(std::string str)
+      : ptr_{new std::string{std::move(str)}},
+        kind_{TypeKind::VARCHAR},
+        usesCustomComparison_(false) {}
 
-  struct NullEqualsNullsComparator {
-    bool operator()(const variant& a, const variant& b) const {
-      return a.equalsWithNullEqualsNull(b);
-    }
-  };
+  /* implicit */ Variant(const char* str)
+      : ptr_{new std::string{str}},
+        kind_{TypeKind::VARCHAR},
+        usesCustomComparison_(false) {}
 
-#define VELOX_VARIANT_SCALAR_MEMBERS(KIND)                                \
-  /* implicit */ variant(                                                 \
+#define VELOX_VARIANT_SCALAR_CONSTRUCTOR(KIND)                            \
+  /* implicit */ Variant(                                                 \
       typename detail::VariantTypeTraits<KIND, false>::native_type v)     \
       : ptr_{new detail::VariantTypeTraits<KIND, false>::stored_type{v}}, \
         kind_{KIND},                                                      \
         usesCustomComparison_{false} {}
 
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::BOOLEAN)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::TINYINT)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::SMALLINT)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::INTEGER)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::BIGINT)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::HUGEINT)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::REAL)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::DOUBLE)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::BOOLEAN)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::TINYINT)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::SMALLINT)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::INTEGER)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::BIGINT)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::HUGEINT)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::REAL)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::DOUBLE)
   // VARBINARY conflicts with VARCHAR, so we don't gen these methods
-  // VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::VARBINARY);
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::TIMESTAMP)
-  VELOX_VARIANT_SCALAR_MEMBERS(TypeKind::UNKNOWN)
-#undef VELOX_VARIANT_SCALAR_MEMBERS
+  // VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::VARBINARY);
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::TIMESTAMP)
+  VELOX_VARIANT_SCALAR_CONSTRUCTOR(TypeKind::UNKNOWN)
+#undef VELOX_VARIANT_SCALAR_CONSTRUCTOR
 
-  /* implicit */ variant(
+  /* implicit */ Variant(
       typename detail::VariantTypeTraits<TypeKind::VARCHAR, false>::native_type
           v)
       : ptr_{new detail::VariantTypeTraits<TypeKind::VARCHAR, false>::
-                 stored_type{v.str()}},
+                 stored_type{std::string(v)}},
         kind_{TypeKind::VARCHAR},
         usesCustomComparison_{false} {}
 
@@ -259,9 +276,192 @@ class variant {
       std::enable_if_t<
           std::is_same_v<T, long long> && !std::is_same_v<long long, int64_t>,
           bool> = true>
-  /* implicit */ variant(const T& v) : variant(static_cast<int64_t>(v)) {}
+  /* implicit */ Variant(const T& v) : Variant(static_cast<int64_t>(v)) {}
 
-  static variant row(const std::vector<variant>& inputs) {
+  // Move constructor.
+  Variant(Variant&& other) noexcept
+      : ptr_{other.ptr_},
+        kind_{other.kind_},
+        usesCustomComparison_(other.usesCustomComparison_) {
+    other.ptr_ = nullptr;
+  }
+
+  ~Variant() {
+    if (ptr_ != nullptr) {
+      dynamicFree();
+    }
+  }
+
+  /// Creates a non-null Variant of the specified TypeKind with the provided
+  /// value.
+  ///
+  /// This factory method provides explicit control over the Variant's TypeKind
+  /// and is particularly useful for:
+  ///
+  /// - Creating variants for complex types (ARRAY, MAP, ROW, VARCHAR,
+  ///   VARBINARY) that require std::vector or std::map containers
+  /// - Disambiguating between similar types (e.g., VARCHAR vs VARBINARY)
+  /// - Creating variants when the TypeKind is determined at runtime or from
+  ///   template parameters
+  ///
+  /// @tparam KIND The TypeKind of the variant to create (e.g., TypeKind::ARRAY,
+  ///              TypeKind::VARCHAR, TypeKind::INTEGER)
+  /// @param v The value to store in the variant. The type must match the
+  ///          expected value_type for the given KIND:
+  ///          - Scalar types: Native C++ type (int8_t, int32_t, float, etc.)
+  ///          - VARCHAR/VARBINARY: std::string
+  ///          - ARRAY/ROW: std::vector<Variant>
+  ///          - MAP: std::map<Variant, Variant>
+  ///          - TIMESTAMP: Timestamp
+  ///          - OPAQUE: OpaqueCapsule
+  ///          The parameter is passed by value and moved into the Variant.
+  ///
+  /// @return A new non-null Variant containing the provided value
+  ///
+  /// Example usage:
+  ///   // Create an array variant
+  ///   auto arr = Variant::create<TypeKind::ARRAY>(
+  ///       std::vector<Variant>{Variant(1), Variant(2), Variant(3)});
+  ///
+  ///   // Create a string variant (disambiguating VARCHAR)
+  ///   auto str = Variant::create<TypeKind::VARCHAR>(std::string("hello"));
+  ///
+  ///   // Create a map variant
+  ///   std::map<Variant, Variant> m = {{Variant(1), Variant("one")}};
+  ///   auto mapVar = Variant::create<TypeKind::MAP>(std::move(m));
+  template <TypeKind KIND>
+  static Variant create(
+      typename detail::VariantTypeTraits<KIND, false>::value_type v) {
+    return Variant{
+        KIND,
+        new typename detail::VariantTypeTraits<KIND, false>::stored_type{
+            std::move(v)},
+    };
+  }
+
+  // Explicit specializations for other non-deep copied string types.
+  template <TypeKind KIND>
+  static std::enable_if_t<is_string_kind(KIND), Variant> create(StringView v) {
+    return create<KIND>(std::string(v));
+  }
+
+  template <TypeKind KIND>
+  static std::enable_if_t<is_string_kind(KIND), Variant> create(
+      std::string_view v) {
+    return create<KIND>(std::string(v));
+  }
+
+  template <TypeKind KIND>
+  static std::enable_if_t<is_string_kind(KIND), Variant> create(const char* v) {
+    return create<KIND>(std::string(v));
+  }
+
+  /// Creates a non-null Variant by deducing the TypeKind from the C++ template
+  /// type parameter.
+  ///
+  /// This overload automatically maps C++ types to their corresponding TypeKind
+  /// using CppToType traits. Note that while this function provides a more
+  /// convenient way to map directly from a C++ type to TypeKind, it is not
+  /// guaranteed that every TypeKind will have a direct C++ type mapping. So
+  /// this is mostly useful for test code.
+  ///
+  /// @tparam T The C++ type that determines the TypeKind (e.g., int32_t maps to
+  ///           TypeKind::INTEGER, std::string maps to TypeKind::VARCHAR)
+  /// @param v The value to store in the variant. Must be of type value_type for
+  ///          the deduced TypeKind. The parameter is passed by const reference
+  ///          and copied into the Variant.
+  ///
+  /// @return A new non-null Variant containing the provided value
+  ///
+  /// Example usage:
+  ///   // Deduce TypeKind::INTEGER from int32_t
+  ///   auto intVar = Variant::create<int32_t>(42);
+  ///
+  ///   // Deduce TypeKind::DOUBLE from double
+  ///   auto doubleVar = Variant::create<double>(3.14);
+  ///
+  /// Note: For most scalar types, the implicit Variant constructors are more
+  /// convenient (e.g., Variant(42) instead of Variant::create<int32_t>(42)).
+  /// This method is primarily useful when type deduction from template
+  /// parameters is needed or for consistency with the TypeKind-based overload.
+  template <typename T>
+  static Variant create(
+      const typename detail::VariantTypeTraits<CppToType<T>::typeKind, false>::
+          value_type& v) {
+    return create<CppToType<T>::typeKind>(v);
+  }
+
+  /// Deserializes a Variant from a folly::dynamic object.
+  ///
+  /// This method reconstructs a Variant from its serialized representation,
+  /// serving as the inverse operation of serialize(). It parses a
+  /// folly::dynamic object that contains type metadata and value data, and
+  /// creates the corresponding Variant.
+  ///
+  /// @param obj A folly::dynamic object containing the serialized Variant data.
+  ///            The object must have the following structure:
+  ///            - "type": A string field specifying the TypeKind name (e.g.,
+  ///              "INTEGER", "VARCHAR", "ARRAY", "MAP", "ROW", "TIMESTAMP")
+  ///            - "value": The actual value, whose format depends on the type:
+  ///
+  ///              Scalar types (BOOLEAN, TINYINT, SMALLINT, INTEGER, BIGINT,
+  ///              HUGEINT, REAL, DOUBLE, VARCHAR):
+  ///                The primitive value directly (int, double, string, bool)
+  ///
+  ///              VARBINARY:
+  ///                Base64-encoded string representation of binary data
+  ///
+  ///              ARRAY or ROW:
+  ///                folly::dynamic array where each element is a serialized
+  ///                Variant object (recursive structure)
+  ///
+  ///              MAP:
+  ///                folly::dynamic object with two fields:
+  ///                - "keys": Array of serialized Variant objects
+  ///                - "values": Array of serialized Variant objects
+  ///                Both arrays must have the same length
+  ///
+  ///              TIMESTAMP:
+  ///                folly::dynamic object with two fields:
+  ///                - "seconds": Integer seconds since epoch
+  ///                - "nanos": Integer nanoseconds component
+  ///
+  ///              Null values:
+  ///                null (nullptr in folly::dynamic)
+  ///
+  /// @return A Variant containing the deserialized value
+  ///
+  /// @throws VeloxUserError if the object structure is invalid (e.g., unknown
+  ///         type name, malformed value data, mismatched array sizes for maps)
+  ///
+  /// Example usage:
+  ///   // Deserialize a scalar value
+  ///   folly::dynamic obj = folly::dynamic::object("type", "INTEGER")
+  ///                                               ("value", 42);
+  ///   auto var = Variant::create(obj);
+  ///
+  ///   // Deserialize an array
+  ///   folly::dynamic arrObj = folly::dynamic::object
+  ///     ("type", "ARRAY")
+  ///     ("value", folly::dynamic::array(
+  ///       folly::dynamic::object("type", "INTEGER")("value", 1),
+  ///       folly::dynamic::object("type", "INTEGER")("value", 2)
+  ///     ));
+  ///   auto arrVar = Variant::create(arrObj);
+  ///
+  ///   // Round-trip serialization/deserialization
+  ///   Variant original = Variant::array({Variant(1), Variant(2)});
+  ///   auto serialized = original.serialize();
+  ///   auto deserialized = Variant::create(serialized);
+  ///   // original == deserialized
+  ///
+  /// Note: This method is commonly used for persistence, network transmission,
+  /// or interfacing with JSON-based systems. For creating Variants from native
+  /// C++ values, use the template-based create() methods or constructors
+  /// instead.
+  static Variant create(const folly::dynamic& obj);
+
+  static Variant row(const std::vector<Variant>& inputs) {
     return {
         TypeKind::ROW,
         new
@@ -269,7 +469,7 @@ class variant {
             inputs}};
   }
 
-  static variant row(std::vector<variant>&& inputs) {
+  static Variant row(std::vector<Variant>&& inputs) {
     return {
         TypeKind::ROW,
         new
@@ -277,7 +477,7 @@ class variant {
             std::move(inputs)}};
   }
 
-  static variant map(const std::map<variant, variant>& inputs) {
+  static Variant map(const std::map<Variant, Variant>& inputs) {
     return {
         TypeKind::MAP,
         new
@@ -285,7 +485,7 @@ class variant {
             inputs}};
   }
 
-  static variant map(std::map<variant, variant>&& inputs) {
+  static Variant map(std::map<Variant, Variant>&& inputs) {
     return {
         TypeKind::MAP,
         new
@@ -293,7 +493,7 @@ class variant {
             std::move(inputs)}};
   }
 
-  static variant timestamp(const Timestamp& input) {
+  static Variant timestamp(const Timestamp& input) {
     return {
         TypeKind::TIMESTAMP,
         new typename detail::VariantTypeTraits<TypeKind::TIMESTAMP, false>::
@@ -301,36 +501,35 @@ class variant {
   }
 
   template <TypeKind KIND>
-  static variant typeWithCustomComparison(
+  static Variant typeWithCustomComparison(
       typename TypeTraits<KIND>::NativeType input,
       const TypePtr& type) {
+    using variant_traits = detail::VariantTypeTraits<KIND, true>;
     return {
         KIND,
-        new typename detail::VariantTypeTraits<KIND, true>::stored_type{
-            input,
+        new typename variant_traits::stored_type{
+            typename variant_traits::value_type{std::move(input)},
             std::dynamic_pointer_cast<
                 const CanProvideCustomComparisonType<KIND>>(type)},
         true};
   }
 
   template <class T>
-  static variant opaque(const std::shared_ptr<T>& input) {
-    VELOX_CHECK(input.get(), "Can't create a variant of nullptr opaque type");
+  static Variant opaque(const std::shared_ptr<T>& input) {
+    VELOX_CHECK(input.get(), "Can't create a Variant of nullptr opaque type");
     return {
         TypeKind::OPAQUE,
         new detail::OpaqueCapsule{OpaqueType::create<T>(), input}};
   }
 
-  static variant opaque(
+  static Variant opaque(
       const std::shared_ptr<void>& input,
       const std::shared_ptr<const OpaqueType>& type) {
-    VELOX_CHECK(input.get(), "Can't create a variant of nullptr opaque type");
+    VELOX_CHECK(input.get(), "Can't create a Variant of nullptr opaque type");
     return {TypeKind::OPAQUE, new detail::OpaqueCapsule{type, input}};
   }
 
-  static void verifyArrayElements(const std::vector<variant>& inputs);
-
-  static variant array(const std::vector<variant>& inputs) {
+  static Variant array(const std::vector<Variant>& inputs) {
     verifyArrayElements(inputs);
     return {
         TypeKind::ARRAY,
@@ -339,7 +538,7 @@ class variant {
             inputs}};
   }
 
-  static variant array(std::vector<variant>&& inputs) {
+  static Variant array(std::vector<Variant>&& inputs) {
     verifyArrayElements(inputs);
     return {
         TypeKind::ARRAY,
@@ -348,69 +547,81 @@ class variant {
             std::move(inputs)}};
   }
 
-  variant()
-      : ptr_{nullptr}, kind_{TypeKind::INVALID}, usesCustomComparison_(false) {}
-
-  /* implicit */ variant(TypeKind kind)
-      : ptr_{nullptr}, kind_{kind}, usesCustomComparison_(false) {}
+  static void verifyArrayElements(const std::vector<Variant>& inputs);
 
-  variant(const variant& other)
-      : ptr_{nullptr},
-        kind_{other.kind_},
-        usesCustomComparison_(other.usesCustomComparison_) {
-    auto op = other.ptr_;
-    if (op != nullptr) {
-      dynamicCopy(other.ptr_, other.kind_);
-    }
+  static Variant null(TypeKind kind) {
+    return Variant{kind};
   }
 
-  // Support construction from StringView as well as StringPiece.
-  /* implicit */ variant(StringView view) : variant{folly::StringPiece{view}} {}
+  static Variant binary(std::string val) {
+    return Variant{TypeKind::VARBINARY, new std::string{std::move(val)}};
+  }
 
-  // Break ties between implicit conversions to StringView/StringPiece.
-  /* implicit */ variant(std::string str)
-      : ptr_{new std::string{std::move(str)}},
-        kind_{TypeKind::VARCHAR},
-        usesCustomComparison_(false) {}
+ private:
+  Variant(TypeKind kind, void* ptr, bool usesCustomComparison = false)
+      : ptr_{ptr}, kind_{kind}, usesCustomComparison_(usesCustomComparison) {}
 
-  /* implicit */ variant(const char* str)
-      : ptr_{new std::string{str}},
-        kind_{TypeKind::VARCHAR},
-        usesCustomComparison_(false) {}
+  template <TypeKind KIND>
+  bool lessThan(const Variant& other) const;
 
   template <TypeKind KIND>
-  static variant create(
-      typename detail::VariantTypeTraits<KIND, false>::value_type&& v) {
-    return variant{
-        KIND,
-        new typename detail::VariantTypeTraits<KIND, false>::stored_type{
-            std::move(v)}};
-  }
+  bool equals(const Variant& other) const;
 
   template <TypeKind KIND>
-  static variant create(
-      const typename detail::VariantTypeTraits<KIND, false>::value_type& v) {
-    return variant{
+  uint64_t hash() const;
+
+  template <bool usesCustomComparison, TypeKind KIND>
+  void typedDestroy() {
+    delete static_cast<const typename detail::VariantTypeTraits<
         KIND,
-        new typename detail::VariantTypeTraits<KIND, false>::stored_type{v}};
+        usesCustomComparison>::stored_type*>(ptr_);
+    ptr_ = nullptr;
   }
 
-  template <typename T>
-  static variant create(const typename detail::VariantTypeTraits<
-                        CppToType<T>::typeKind,
-                        false>::value_type& v) {
-    return create<CppToType<T>::typeKind>(v);
+  template <bool usesCustomComparison, TypeKind KIND>
+  void typedCopy(const void* other) {
+    using stored_type = typename detail::
+        VariantTypeTraits<KIND, usesCustomComparison>::stored_type;
+    ptr_ = new stored_type{*static_cast<const stored_type*>(other)};
   }
 
-  static variant null(TypeKind kind) {
-    return variant{kind};
+  void dynamicCopy(const void* p, const TypeKind kind) {
+    if (usesCustomComparison_) {
+      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedCopy, true, kind, p);
+    } else {
+      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedCopy, false, kind, p);
+    }
   }
 
-  static variant binary(std::string val) {
-    return variant{TypeKind::VARBINARY, new std::string{std::move(val)}};
+  void dynamicFree() {
+    if (usesCustomComparison_) {
+      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedDestroy, true, kind_);
+    } else {
+      VELOX_DYNAMIC_TEMPLATE_TYPE_DISPATCH_ALL(typedDestroy, false, kind_);
+    }
   }
 
-  variant& operator=(const variant& other) {
+  [[noreturn]] void throwCheckIsKindError(TypeKind kind) const;
+
+  [[noreturn]] void throwCheckPtrError() const;
+
+ public:
+  // Constant used in comparison of REAL and DOUBLE values.
+  static constexpr double kEpsilon{0.00001};
+
+  struct Hasher {
+    size_t operator()(Variant const& input) const noexcept {
+      return input.hash();
+    }
+  };
+
+  struct NullEqualsNullsComparator {
+    bool operator()(const Variant& a, const Variant& b) const {
+      return a.equalsWithNullEqualsNull(b);
+    }
+  };
+
+  Variant& operator=(const Variant& other) {
     if (ptr_ != nullptr) {
       dynamicFree();
     }
@@ -422,7 +633,7 @@ class variant {
     return *this;
   }
 
-  variant& operator=(variant&& other) noexcept {
+  Variant& operator=(Variant&& other) noexcept {
     if (ptr_ != nullptr) {
       dynamicFree();
     }
@@ -435,31 +646,16 @@ class variant {
     return *this;
   }
 
-  bool operator<(const variant& other) const;
+  bool operator<(const Variant& other) const;
 
-  bool equals(const variant& other) const;
+  bool equals(const Variant& other) const;
 
-  bool equalsWithNullEqualsNull(const variant& other) const {
-    if (other.kind_ != this->kind_) {
-      return false;
-    }
-    return dispatchDynamicVariantEquality(*this, other, true);
-  }
+  bool equalsWithNullEqualsNull(const Variant& other) const;
 
-  variant(variant&& other) noexcept
-      : ptr_{other.ptr_},
-        kind_{other.kind_},
-        usesCustomComparison_(other.usesCustomComparison_) {
-    other.ptr_ = nullptr;
-  }
+  std::string toJson(const TypePtr& type) const;
 
-  ~variant() {
-    if (ptr_ != nullptr) {
-      dynamicFree();
-    }
-  }
+  std::string toJson(const Type& type) const;
 
-  std::string toJson(const TypePtr& type) const;
   std::string toJsonUnsafe(const TypePtr& type = nullptr) const;
 
   /// Used by python binding, do not change signature.
@@ -467,13 +663,14 @@ class variant {
     return toJsonUnsafe();
   }
 
-  /// Returns a string of the variant value. Currently only supports scalar
-  /// types.
+  /// Returns a string of the Variant value.
   std::string toString(const TypePtr& type) const;
 
-  folly::dynamic serialize() const;
+  /// Returns a string representation identical to
+  /// BaseVector::createConstant(type, *this)->toString(0).
+  std::string toStringAsVector(const TypePtr& type) const;
 
-  static variant create(const folly::dynamic&);
+  folly::dynamic serialize() const;
 
   bool hasValue() const {
     return !isNull();
@@ -549,18 +746,158 @@ class variant {
     return valuePointer<CppToType<T>::typeKind>();
   }
 
-  const std::vector<variant>& row() const {
+  const std::vector<Variant>& row() const {
     return value<TypeKind::ROW>();
   }
 
-  const std::map<variant, variant>& map() const {
+  /// Returns a map of Variants.
+  const std::map<Variant, Variant>& map() const {
     return value<TypeKind::MAP>();
   }
 
-  const std::vector<variant>& array() const {
+  /// Returns a map of primitive values. Assumes all keys and values are not
+  /// null.
+  template <typename K, typename V>
+  std::map<K, V> map() const {
+    const auto& variants = value<TypeKind::MAP>();
+
+    std::map<K, V> values;
+    for (const auto& [k, v] : variants) {
+      values.emplace(k.template value<K>(), v.template value<V>());
+    }
+
+    return values;
+  }
+
+  /// Returns a map of optional primitive values. All keys are assumed to be not
+  /// null. Null values are returned as unset optional.
+  template <typename K, typename V>
+  std::map<K, std::optional<V>> nullableMap() const {
+    const auto& variants = value<TypeKind::MAP>();
+
+    std::map<K, std::optional<V>> values;
+    for (const auto& [k, v] : variants) {
+      if (v.isNull()) {
+        values.emplace(k.template value<K>(), std::nullopt);
+      } else {
+        values.emplace(k.template value<K>(), v.template value<V>());
+      }
+    }
+
+    return values;
+  }
+
+  /// Returns a std::map of primitive keys to std::vector of primitive values.
+  /// Assumes all keys and values are not null.
+  template <typename K, typename V>
+  std::map<K, std::vector<V>> mapOfArrays() const {
+    const auto& variants = value<TypeKind::MAP>();
+
+    std::map<K, std::vector<V>> values;
+    for (const auto& [k, v] : variants) {
+      values.emplace(k.template value<K>(), v.template array<V>());
+    }
+
+    return values;
+  }
+
+  /// Returns a std::map of primitive keys to optional std::vector of optional
+  /// primitive values. Null values are returned as unset optional.
+  template <typename K, typename V>
+  std::map<K, std::optional<std::vector<std::optional<V>>>>
+  nullableMapOfArrays() const {
+    const auto& variants = value<TypeKind::MAP>();
+
+    std::map<K, std::optional<std::vector<std::optional<V>>>> values;
+    for (const auto& [k, v] : variants) {
+      if (v.isNull()) {
+        values.emplace(k.template value<K>(), std::nullopt);
+      } else {
+        values.emplace(k.template value<K>(), v.template nullableArray<V>());
+      }
+    }
+
+    return values;
+  }
+
+  /// Returns a std::vector of Variants.
+  const std::vector<Variant>& array() const {
     return value<TypeKind::ARRAY>();
   }
 
+  /// Returns a std::vector of primitive values. Assumes that all values are not
+  /// null.
+  template <typename T>
+  std::vector<T> array() const {
+    const auto& variants = value<TypeKind::ARRAY>();
+
+    std::vector<T> values;
+    values.reserve(variants.size());
+
+    for (const auto& v : variants) {
+      values.emplace_back(v.template value<T>());
+    }
+
+    return values;
+  }
+
+  /// Returns a std::vector of optional primitive values. Null values are
+  /// returned as unset optional.
+  template <typename T>
+  std::vector<std::optional<T>> nullableArray() const {
+    const auto& variants = value<TypeKind::ARRAY>();
+
+    std::vector<std::optional<T>> values;
+    values.reserve(variants.size());
+
+    for (const auto& v : variants) {
+      if (v.isNull()) {
+        values.emplace_back(std::nullopt);
+      } else {
+        values.emplace_back(v.template value<T>());
+      }
+    }
+
+    return values;
+  }
+
+  /// Returns a std::vector of std::vector of primitive values. Assumes that all
+  /// values are not null.
+  template <typename T>
+  std::vector<std::vector<T>> arrayOfArrays() const {
+    const auto& variants = value<TypeKind::ARRAY>();
+
+    std::vector<std::vector<T>> values;
+    values.reserve(variants.size());
+
+    for (const auto& v : variants) {
+      values.emplace_back(v.template array<T>());
+    }
+
+    return values;
+  }
+
+  /// Returns a std::vector of std::vector of primitive values.Null values are
+  /// returned as unset optional.
+  template <typename T>
+  std::vector<std::optional<std::vector<std::optional<T>>>>
+  nullableArrayOfArrays() const {
+    const auto& variants = value<TypeKind::ARRAY>();
+
+    std::vector<std::optional<std::vector<std::optional<T>>>> values;
+    values.reserve(variants.size());
+
+    for (const auto& v : variants) {
+      if (v.isNull()) {
+        values.emplace_back(std::nullopt);
+      } else {
+        values.emplace_back(v.template nullableArray<T>());
+      }
+    }
+
+    return values;
+  }
+
   template <class T>
   std::shared_ptr<T> opaque() const {
     const auto& capsule = value<TypeKind::OPAQUE>();
@@ -573,7 +910,7 @@ class variant {
   }
 
   /// Try to cast to the target custom type
-  /// Throw if the variant is not an opaque type
+  /// Throw if the Variant is not an opaque type
   /// Return nullptr if it's opaque type but the underlying custom type doesn't
   /// match the target. Otherwise return the data in custom type.
   template <class T>
@@ -585,57 +922,14 @@ class variant {
     return nullptr;
   }
 
-  std::shared_ptr<const Type> inferType() const {
-    switch (kind_) {
-      case TypeKind::MAP: {
-        TypePtr keyType;
-        TypePtr valueType;
-        auto& m = map();
-        for (auto& pair : m) {
-          if (keyType == nullptr && !pair.first.isNull()) {
-            keyType = pair.first.inferType();
-          }
-          if (valueType == nullptr && !pair.second.isNull()) {
-            valueType = pair.second.inferType();
-          }
-          if (keyType && valueType) {
-            break;
-          }
-        }
-        return MAP(
-            keyType ? keyType : UNKNOWN(), valueType ? valueType : UNKNOWN());
-      }
-      case TypeKind::ROW: {
-        auto& r = row();
-        std::vector<std::shared_ptr<const Type>> children{};
-        children.reserve(r.size());
-        for (auto& v : r) {
-          children.push_back(v.inferType());
-        }
-        return ROW(std::move(children));
-      }
-      case TypeKind::ARRAY: {
-        TypePtr elementType = UNKNOWN();
-        if (!isNull()) {
-          auto& a = array();
-          if (!a.empty()) {
-            elementType = a.at(0).inferType();
-          }
-        }
-        return ARRAY(elementType);
-      }
-      case TypeKind::OPAQUE: {
-        return value<TypeKind::OPAQUE>().type;
-      }
-      case TypeKind::UNKNOWN: {
-        return UNKNOWN();
-      }
-      default:
-        return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(kind2type, kind_);
-    }
-  }
+  TypePtr inferType() const;
 
-  friend std::ostream& operator<<(std::ostream& stream, const variant& k) {
+  /// Returns true if the type of this Variant is compatible with the specified
+  /// type. Similar to inferType()->kindEquals(type), but treats
+  /// TypeKind::UNKNOWN equal to any other TypeKind.
+  bool isTypeCompatible(const TypePtr& type) const;
+
+  friend std::ostream& operator<<(std::ostream& stream, const Variant& k) {
     const auto type = k.inferType();
     stream << k.toJson(type);
     return stream;
@@ -643,11 +937,11 @@ class variant {
 
   // Uses kEpsilon to compare floating point types (REAL and DOUBLE).
   // For testing purposes.
-  bool lessThanWithEpsilon(const variant& other) const;
+  bool lessThanWithEpsilon(const Variant& other) const;
 
   // Uses kEpsilon to compare floating point types (REAL and DOUBLE).
   // For testing purposes.
-  bool equalsWithEpsilon(const variant& other) const;
+  bool equalsWithEpsilon(const Variant& other) const;
 
  private:
   template <TypeKind KIND>
@@ -662,24 +956,21 @@ class variant {
   // problem
   const void* ptr_;
   TypeKind kind_;
-  // If the variant represents the value of a type that provides custom
+
+  // If the Variant represents the value of a type that provides custom
   // comparisons.
   bool usesCustomComparison_;
 };
 
-inline bool operator==(const variant& a, const variant& b) {
+inline bool operator==(const Variant& a, const Variant& b) {
   return a.equals(b);
 }
 
-inline bool operator!=(const variant& a, const variant& b) {
-  return !(a == b);
-}
-
 struct VariantConverter {
   template <TypeKind FromKind, TypeKind ToKind>
-  static variant convert(const variant& value) {
+  static Variant convert(const Variant& value) {
     if (value.isNull()) {
-      return variant{value.kind()};
+      return Variant{value.kind()};
     }
 
     const auto converted =
@@ -691,7 +982,7 @@ struct VariantConverter {
   }
 
   template <TypeKind ToKind>
-  static variant convert(const variant& value) {
+  static Variant convert(const Variant& value) {
     switch (value.kind()) {
       case TypeKind::BOOLEAN:
         return convert<TypeKind::BOOLEAN, ToKind>(value);
@@ -724,9 +1015,12 @@ struct VariantConverter {
     }
   }
 
-  static variant convert(const variant& value, TypeKind toKind) {
+  static Variant convert(const Variant& value, TypeKind toKind) {
     return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(convert, toKind, value);
   }
 };
 
+// For backward compatibility.
+using variant = Variant;
+
 } // namespace facebook::velox
diff --git a/velox/type/fbhive/HiveTypeParser.cpp b/velox/type/fbhive/HiveTypeParser.cpp
index 0ab9e4007123..7cd57c0eff41 100644
--- a/velox/type/fbhive/HiveTypeParser.cpp
+++ b/velox/type/fbhive/HiveTypeParser.cpp
@@ -17,18 +17,16 @@
 #include "velox/type/fbhive/HiveTypeParser.h"
 
 #include <cctype>
-#include <stdexcept>
 #include <string>
 #include <utility>
 
 #include "velox/common/base/Exceptions.h"
 
-using facebook::velox::Type;
-using facebook::velox::TypeKind;
-
+namespace facebook::velox::type::fbhive {
 namespace {
+
 /// Returns true only if 'str' contains digits.
-bool isPositiveInteger(const std::string& str) {
+bool isPositiveInteger(std::string_view str) {
   return !str.empty() &&
       std::find_if(str.begin(), str.end(), [](unsigned char c) {
         return !std::isdigit(c);
@@ -39,9 +37,18 @@ bool isSupportedSpecialChar(char c) {
   static std::unordered_set<char> supported{'_', '$', '#'};
   return supported.count(c) == 1;
 }
-} // namespace
 
-namespace facebook::velox::type::fbhive {
+/// Returns whether `prefix` is non-empty case-insensitive prefix of `input`.
+bool isPrefix(std::string_view input, std::string_view prefix) {
+  return prefix.size() > 0 && input.size() >= prefix.size() &&
+      std::equal(
+             prefix.begin(),
+             prefix.end(),
+             input.begin(),
+             folly::AsciiCaseInsensitive{});
+}
+
+} // namespace
 
 HiveTypeParser::HiveTypeParser() {
   metadata_.resize(static_cast<size_t>(TokenType::MaxTokenType));
@@ -73,15 +80,15 @@ HiveTypeParser::HiveTypeParser() {
   setupMetadata<TokenType::EndOfStream, TypeKind::INVALID>();
 }
 
-std::shared_ptr<const Type> HiveTypeParser::parse(const std::string& ser) {
-  remaining_ = folly::StringPiece(ser);
+TypePtr HiveTypeParser::parse(std::string_view input) {
+  remaining_ = input;
   Result result = parseType();
   VELOX_CHECK(
       remaining_.size() == 0 || TokenType::EndOfStream == lookAhead(),
       "Input remaining after parsing the Hive type \"{}\"\n"
       "Remaining: \"{}\"",
-      ser,
-      remaining_.toString());
+      input,
+      remaining_);
   return result.type;
 }
 
@@ -92,8 +99,8 @@ Result HiveTypeParser::parseType() {
   if (!nt.isValidType()) {
     VELOX_FAIL(
         "Unexpected token {} at {}. typeKind = {}",
-        nt.value.toString(),
-        remaining_.toString(),
+        nt.value,
+        remaining_,
         nt.typeKind());
   }
 
@@ -102,12 +109,12 @@ Result HiveTypeParser::parseType() {
       eatToken(TokenType::LeftRoundBracket);
       Token precision = nextToken();
       VELOX_CHECK(
-          isPositiveInteger(precision.value.toString()),
+          isPositiveInteger(precision.value),
           "Decimal precision must be a positive integer");
       eatToken(TokenType::Comma);
       Token scale = nextToken();
       VELOX_CHECK(
-          isPositiveInteger(scale.value.toString()),
+          isPositiveInteger(scale.value),
           "Decimal scale must be a positive integer");
       eatToken(TokenType::RightRoundBracket);
       return Result{DECIMAL(
@@ -123,18 +130,20 @@ Result HiveTypeParser::parseType() {
       eatToken(TokenType::LeftRoundBracket);
       Token length = nextToken();
       VELOX_CHECK(
-          isPositiveInteger(length.value.toString()),
+          isPositiveInteger(length.value),
           "Varchar length must be a positive integer");
       eatToken(TokenType::RightRoundBracket);
     }
     return Result{scalarType};
   } else if (nt.isOpaqueType()) {
     eatToken(TokenType::StartSubType);
-    folly::StringPiece innerTypeName =
+    std::string_view innerTypeName =
         eatToken(TokenType::Identifier, true).value;
     eatToken(TokenType::EndSubType);
 
-    auto typeIndex = getTypeIdForOpaqueTypeAlias(innerTypeName.str());
+    // TODO: `getTypeIdForOpaqueTypeAlias()` should take a std::string_view so
+    // we don't need to needlessly construct a std::string.
+    auto typeIndex = getTypeIdForOpaqueTypeAlias(std::string(innerTypeName));
     auto instance = std::make_shared<const OpaqueType>(typeIndex);
     return Result{instance};
   } else {
@@ -144,27 +153,31 @@ Result HiveTypeParser::parseType() {
         return Result{velox::ROW(
             std::move(resultList.names), std::move(resultList.typelist))};
       case velox::TypeKind::MAP: {
-        VELOX_CHECK(
-            resultList.typelist.size() == 2,
+        VELOX_CHECK_EQ(
+            resultList.typelist.size(),
+            2,
             "wrong param count for map type def");
         return Result{
             velox::MAP(resultList.typelist.at(0), resultList.typelist.at(1))};
       }
       case velox::TypeKind::ARRAY: {
-        VELOX_CHECK(
-            resultList.typelist.size() == 1,
+        VELOX_CHECK_EQ(
+            resultList.typelist.size(),
+            1,
             "wrong param count for array type def");
         return Result{velox::ARRAY(resultList.typelist.at(0))};
       }
       default:
-        VELOX_FAIL("unsupported kind: " + mapTypeKindToName(nt.typeKind()));
+        VELOX_FAIL(
+            "Unsupported kind: '{}'", TypeKindName::toName(nt.typeKind()));
     }
   }
 }
 
 ResultList HiveTypeParser::parseTypeList(bool hasFieldNames) {
-  std::vector<std::shared_ptr<const Type>> subTypeList{};
+  std::vector<TypePtr> subTypeList{};
   std::vector<std::string> names{};
+
   eatToken(TokenType::StartSubType);
   while (true) {
     if (TokenType::EndSubType == lookAhead()) {
@@ -172,11 +185,11 @@ ResultList HiveTypeParser::parseTypeList(bool hasFieldNames) {
       return ResultList{std::move(subTypeList), std::move(names)};
     }
 
-    folly::StringPiece fieldName;
+    std::string_view fieldName;
     if (hasFieldNames) {
       fieldName = eatToken(TokenType::Identifier, true).value;
       eatToken(TokenType::Colon);
-      names.push_back(fieldName.toString());
+      names.emplace_back(fieldName);
     }
 
     Result result = parseType();
@@ -198,7 +211,7 @@ Token HiveTypeParser::eatToken(TokenType tokenType, bool ignorePredefined) {
     return token;
   }
 
-  VELOX_FAIL("Unexpected token " + token.remaining.toString());
+  VELOX_FAIL("Unexpected token '{}'", token.remaining);
 }
 
 Token HiveTypeParser::nextToken(bool ignorePredefined) {
@@ -208,29 +221,28 @@ Token HiveTypeParser::nextToken(bool ignorePredefined) {
 }
 
 TokenAndRemaining HiveTypeParser::nextToken(
-    folly::StringPiece sp,
+    std::string_view sv,
     bool ignorePredefined) const {
-  while (!sp.empty() && isspace(sp.front())) {
-    sp.advance(1);
+  while (!sv.empty() && isspace(sv.front())) {
+    sv.remove_prefix(1);
   }
 
-  if (sp.empty()) {
-    return makeExtendedToken(getMetadata(TokenType::EndOfStream), sp, 0);
+  if (sv.empty()) {
+    return makeExtendedToken(getMetadata(TokenType::EndOfStream), sv, 0);
   }
 
   if (!ignorePredefined) {
     for (auto& metadata : metadata_) {
       for (auto& token : metadata->tokenString) {
-        folly::StringPiece match(token);
-        if (match.size() > 0 &&
-            sp.startsWith(match, folly::AsciiCaseInsensitive{})) {
-          return makeExtendedToken(metadata.get(), sp, match.size());
+        std::string_view match(token);
+        if (isPrefix(sv, match)) {
+          return makeExtendedToken(metadata.get(), sv, match.size());
         }
       }
     }
   }
 
-  auto iter = sp.cbegin();
+  auto iter = sv.cbegin();
   size_t len = 0;
   while (isalnum(*iter) || isSupportedSpecialChar(*iter)) {
     ++len;
@@ -238,10 +250,10 @@ TokenAndRemaining HiveTypeParser::nextToken(
   }
 
   if (len > 0) {
-    return makeExtendedToken(getMetadata(TokenType::Identifier), sp, len);
+    return makeExtendedToken(getMetadata(TokenType::Identifier), sv, len);
   }
 
-  VELOX_FAIL("Bad Token at " + sp.toString());
+  VELOX_FAIL("Bad Token at '{}'", sv);
 }
 
 TokenType Token::tokenType() const {
@@ -274,15 +286,15 @@ int8_t HiveTypeParser::makeTokenId(TokenType tokenType) const {
 
 TokenAndRemaining HiveTypeParser::makeExtendedToken(
     TokenMetadata* tokenMetadata,
-    folly::StringPiece sp,
+    std::string_view sv,
     size_t len) const {
-  folly::StringPiece spmatch(sp.cbegin(), sp.cbegin() + len);
-  sp.advance(len);
+  std::string_view spmatch{sv.data(), len};
+  sv.remove_prefix(len);
 
   TokenAndRemaining result;
   result.metadata = tokenMetadata;
   result.value = spmatch;
-  result.remaining = sp;
+  result.remaining = sv;
   return result;
 }
 
diff --git a/velox/type/fbhive/HiveTypeParser.h b/velox/type/fbhive/HiveTypeParser.h
index 1469ee41502b..66763bc9ccc9 100644
--- a/velox/type/fbhive/HiveTypeParser.h
+++ b/velox/type/fbhive/HiveTypeParser.h
@@ -22,9 +22,7 @@
 #include <string>
 #include <vector>
 
-#include <folly/Range.h>
-
-#include "velox/type/TypeParser.h"
+#include "velox/type/Type.h"
 
 namespace facebook::velox::type::fbhive {
 
@@ -78,7 +76,7 @@ struct TokenMetadata {
 
 struct Token {
   TokenMetadata* metadata;
-  folly::StringPiece value;
+  std::string_view value;
 
   TokenType tokenType() const;
 
@@ -94,25 +92,23 @@ struct Token {
 };
 
 struct TokenAndRemaining : public Token {
-  folly::StringPiece remaining;
+  std::string_view remaining;
 };
 
 struct Result {
-  std::shared_ptr<const velox::Type> type;
+  TypePtr type;
 };
 
 struct ResultList {
-  std::vector<std::shared_ptr<const velox::Type>> typelist;
+  std::vector<TypePtr> typelist;
   std::vector<std::string> names;
 };
 
-class HiveTypeParser : public type::TypeParser {
+class HiveTypeParser {
  public:
   HiveTypeParser();
 
-  ~HiveTypeParser() override = default;
-
-  std::shared_ptr<const velox::Type> parse(const std::string& ser) override;
+  TypePtr parse(std::string_view input);
 
  private:
   int8_t makeTokenId(TokenType tokenType) const;
@@ -128,12 +124,12 @@ class HiveTypeParser : public type::TypeParser {
   Token nextToken(bool ignorePredefined = false);
 
   TokenAndRemaining nextToken(
-      folly::StringPiece sp,
+      std::string_view sv,
       bool ignorePredefined = false) const;
 
   TokenAndRemaining makeExtendedToken(
       TokenMetadata* tokenMetadata,
-      folly::StringPiece sp,
+      std::string_view sv,
       size_t len) const;
 
   template <TokenType KIND, velox::TypeKind TYPEKIND>
@@ -151,9 +147,8 @@ class HiveTypeParser : public type::TypeParser {
 
   TokenMetadata* getMetadata(TokenType type) const;
 
- private:
   std::vector<std::unique_ptr<TokenMetadata>> metadata_;
-  folly::StringPiece remaining_;
+  std::string_view remaining_;
 };
 
 } // namespace facebook::velox::type::fbhive
diff --git a/velox/type/fbhive/HiveTypeSerializer.cpp b/velox/type/fbhive/HiveTypeSerializer.cpp
index acf8e23e7624..6d2dce82053e 100644
--- a/velox/type/fbhive/HiveTypeSerializer.cpp
+++ b/velox/type/fbhive/HiveTypeSerializer.cpp
@@ -17,15 +17,10 @@
 #include "velox/type/fbhive/HiveTypeSerializer.h"
 
 #include <cstddef>
-#include <stdexcept>
-
-using facebook::velox::Type;
-using facebook::velox::TypeKind;
 
 namespace facebook::velox::type::fbhive {
 
-std::string HiveTypeSerializer::serialize(
-    const std::shared_ptr<const Type>& type) {
+std::string HiveTypeSerializer::serialize(const TypePtr& type) {
   HiveTypeSerializer serializer;
   return serializer.visit(*type);
 }
@@ -67,7 +62,7 @@ std::string HiveTypeSerializer::visit(const Type& type) const {
   }
 }
 
-std::string HiveTypeSerializer::visitChildren(const velox::RowType& t) const {
+std::string HiveTypeSerializer::visitChildren(const RowType& t) const {
   std::string result;
   for (size_t i = 0; i < t.size(); ++i) {
     if (i != 0) {
@@ -81,7 +76,7 @@ std::string HiveTypeSerializer::visitChildren(const velox::RowType& t) const {
   return result;
 }
 
-std::string HiveTypeSerializer::visitChildren(const velox::Type& t) const {
+std::string HiveTypeSerializer::visitChildren(const Type& t) const {
   std::string result;
   for (size_t i = 0; i < t.size(); ++i) {
     if (i != 0) {
diff --git a/velox/type/fbhive/HiveTypeSerializer.h b/velox/type/fbhive/HiveTypeSerializer.h
index 91cb6dd94b97..fd04955914b7 100644
--- a/velox/type/fbhive/HiveTypeSerializer.h
+++ b/velox/type/fbhive/HiveTypeSerializer.h
@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include <memory>
 #include <string>
 
 #include "velox/type/Type.h"
@@ -25,19 +24,18 @@ namespace facebook::velox::type::fbhive {
 
 class HiveTypeSerializer {
  public:
-  static std::string serialize(const std::shared_ptr<const velox::Type>& type);
+  static std::string serialize(const TypePtr& type);
 
  private:
-  std::string visit(const velox::Type& type) const;
+  std::string visit(const Type& type) const;
 
  private:
   HiveTypeSerializer() = default;
-
   ~HiveTypeSerializer() = default;
 
-  std::string visitChildren(const velox::RowType& t) const;
+  std::string visitChildren(const RowType& t) const;
 
-  std::string visitChildren(const velox::Type& t) const;
+  std::string visitChildren(const Type& t) const;
 };
 
 } // namespace facebook::velox::type::fbhive
diff --git a/velox/type/fbhive/tests/CMakeLists.txt b/velox/type/fbhive/tests/CMakeLists.txt
index e94ac225051d..582bcbedb032 100644
--- a/velox/type/fbhive/tests/CMakeLists.txt
+++ b/velox/type/fbhive/tests/CMakeLists.txt
@@ -17,7 +17,8 @@ add_executable(velox_type_fbhive_test HiveTypeParserTests.cpp)
 add_test(
   NAME velox_type_fbhive_test
   COMMAND velox_type_fbhive_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_type_fbhive_test
@@ -25,14 +26,16 @@ target_link_libraries(
   velox_type
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
 
 add_executable(velox_type_serializer_fbhive_test HiveTypeSerializerTests.cpp)
 
 add_test(
   NAME velox_type_serializer_fbhive_test
   COMMAND velox_type_serializer_fbhive_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_type_serializer_fbhive_test
@@ -40,4 +43,5 @@ target_link_libraries(
   velox_type
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
diff --git a/velox/type/fbhive/tests/HiveTypeParserTests.cpp b/velox/type/fbhive/tests/HiveTypeParserTests.cpp
index c35e8bffacaa..9e93e5602aea 100644
--- a/velox/type/fbhive/tests/HiveTypeParserTests.cpp
+++ b/velox/type/fbhive/tests/HiveTypeParserTests.cpp
@@ -128,7 +128,7 @@ TEST(FbHive, badParse) {
       "Unexpected token uniontype at < bigint , int, float");
   VELOX_ASSERT_THROW(parser.parse("badid"), "Unexpected token badid at ");
   VELOX_ASSERT_THROW(
-      parser.parse("struct<int, bigint>"), "Unexpected token  bigint>");
+      parser.parse("struct<int, bigint>"), "Unexpected token ' bigint>'");
   VELOX_ASSERT_THROW(parser.parse("list<>"), "Unexpected token list at <>");
   VELOX_ASSERT_THROW(
       parser.parse("map<>"), "wrong param count for map type def");
@@ -140,7 +140,7 @@ TEST(FbHive, badParse) {
   VELOX_ASSERT_THROW(
       parser.parse("map<int>"), "wrong param count for map type def");
   VELOX_ASSERT_THROW(
-      parser.parse("decimal<20, 10>"), "Unexpected token 20, 10>");
+      parser.parse("decimal<20, 10>"), "Unexpected token '20, 10>'");
   VELOX_ASSERT_THROW(parser.parse("decimal(20, 10>"), "Unexpected token ");
   VELOX_ASSERT_THROW(
       parser.parse("decimal(a, 10)"),
diff --git a/velox/type/parser/CMakeLists.txt b/velox/type/parser/CMakeLists.txt
index 93d380e58b80..e6f46ebc4615 100644
--- a/velox/type/parser/CMakeLists.txt
+++ b/velox/type/parser/CMakeLists.txt
@@ -17,24 +17,34 @@ if(${VELOX_BUILD_TESTING})
 endif()
 
 bison_target(
-  TypeParser TypeParser.yy ${CMAKE_CURRENT_BINARY_DIR}/TypeParser.yy.cc
+  TypeParser
+  TypeParser.yy
+  ${CMAKE_CURRENT_BINARY_DIR}/TypeParser.yy.cc
   DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/TypeParser.yy.h
-  COMPILE_FLAGS "-Werror -Wno-deprecated")
+  COMPILE_FLAGS "-Werror -Wno-deprecated"
+)
 
 flex_target(
-  TypeParserScanner TypeParser.ll ${CMAKE_CURRENT_BINARY_DIR}/Scanner.cpp
-  COMPILE_FLAGS "-Cf --prefix=veloxtp")
+  TypeParserScanner
+  TypeParser.ll
+  ${CMAKE_CURRENT_BINARY_DIR}/Scanner.cpp
+  COMPILE_FLAGS "-Cf --prefix=veloxtpdeprecated"
+)
 
 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})
+    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_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
index 77470469b5ad..0412991e4c29 100644
--- a/velox/type/parser/ParserUtil.cpp
+++ b/velox/type/parser/ParserUtil.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <boost/algorithm/string.hpp>
 #include <string>
 #include "velox/type/Type.h"
 
@@ -65,4 +66,133 @@ std::pair<std::string, std::shared_ptr<const Type>> inferTypeWithSpaces(
       fieldName, typeFromString(allWords.substr(fieldName.size() + 1)));
 }
 
+namespace {
+std::array<int, 256> base32CharMap() {
+  std::array<int, 256> map{};
+  map.fill(-1);
+  const std::string base32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+  for (size_t i = 0; i < base32Chars.size(); ++i) {
+    char upper = base32Chars[i];
+    char lower = std::tolower(upper);
+    map[static_cast<unsigned char>(upper)] = static_cast<int>(i);
+    map[static_cast<unsigned char>(lower)] = static_cast<int>(i);
+  }
+  return map;
+}
+
+static const std::array<int, 256> base32Map = base32CharMap();
+
+std::string base32Decode(const std::string& encoded) {
+  std::vector<uint8_t> decodedBytes;
+  int buffer = 0;
+  int bitsLeft = 0;
+
+  for (char c : encoded) {
+    // Skip padding and whitespace.
+    if (c == '=' || std::isspace(static_cast<unsigned char>(c))) {
+      continue;
+    }
+
+    int val = base32Map[static_cast<unsigned char>(c)];
+    VELOX_CHECK_NE(
+        val,
+        -1,
+        "Failed to parse value {}, invalid Base32 character: {}",
+        encoded,
+        c);
+
+    buffer = (buffer << 5) | val;
+    bitsLeft += 5;
+    if (bitsLeft >= 8) {
+      bitsLeft -= 8;
+      decodedBytes.push_back((buffer >> bitsLeft) & 0xFF);
+    }
+  }
+  std::string decoded(decodedBytes.begin(), decodedBytes.end());
+
+  return decoded;
+}
+
+// The values map of the enum type is passed into this function in the format:
+// "[["CURIOUS",-2], ["HAPPY",0]]" as an array of key-value pairs (as opposed
+// to a JSON map like "{"CURIOUS":-2, "HAPPY":0}") so that the function can
+// fail on duplicate keys and values. folly::parseJson on a JSON map will
+// silently drop duplicate elements.
+template <typename T>
+std::unordered_map<std::string, T> parseMapFromString(
+    const std::string& input) {
+  folly::dynamic obj = folly::parseJson(input);
+  VELOX_CHECK(
+      obj.isArray(),
+      "Expected an array of key-value pairs for input: {}",
+      input);
+  std::unordered_map<std::string, T> result;
+  std::unordered_set<T> seenValues;
+
+  for (const auto& pair : obj) {
+    VELOX_CHECK(
+        pair.isArray() && pair.size() == 2 && pair[0].isString(),
+        "Failed to parse map: {}, each element must be have a string key.",
+        input);
+    std::string key = boost::algorithm::to_upper_copy(pair[0].asString());
+    VELOX_CHECK(
+        !result.contains(key),
+        "Failed to parse map: {}, duplicate key found: {}",
+        input,
+        key);
+    T value;
+    if constexpr (std::is_same_v<T, int64_t>) {
+      VELOX_CHECK(
+          pair[1].isInt(),
+          "Failed to parse map: {}, each element must have an integer value.",
+          input);
+      value = pair[1].asInt();
+    } else if constexpr (std::is_same_v<T, std::string>) {
+      VELOX_CHECK(
+          pair[1].isString(),
+          "Failed to parse map: {}, each element must have a string value.",
+          input);
+      // For a VarcharEnum map where the values are strings, the values from the
+      // Presto coordinator are received as base32-encoded strings to match the
+      // standard Presto TypeSignature format.
+      // Hence decode the value before creating a VarcharEnumParameter.
+      // https://github.com/prestodb/presto/blob/master/presto-common/src/main/java/com/facebook/presto/common/type/VarcharEnumType.java#L128
+      value = base32Decode(pair[1].asString());
+    } else {
+      VELOX_UNSUPPORTED(
+          "parseMapFromString is only supported for int64_t and std::string values.");
+    }
+    VELOX_CHECK(
+        seenValues.insert(value).second,
+        "Failed to parse map: {}, duplicate value found: {}",
+        input,
+        value);
+
+    result[key] = value;
+  }
+  return result;
+}
+} // namespace
+
+TypePtr getEnumType(
+    const std::string& enumType,
+    const std::string& enumName,
+    const std::string& valuesMap) {
+  std::vector<TypeParameter> params;
+  if (enumType == "BigintEnum") {
+    LongEnumParameter longEnumParameter(
+        enumName, parseMapFromString<int64_t>(valuesMap));
+    params.emplace_back(TypeParameter(longEnumParameter));
+    return getType("BIGINT_ENUM", params);
+  } else if (enumType == "VarcharEnum") {
+    VarcharEnumParameter varcharEnumParameter(
+        enumName, parseMapFromString<std::string>(valuesMap));
+    params.emplace_back(TypeParameter(varcharEnumParameter));
+    return getType("VARCHAR_ENUM", params);
+  }
+
+  VELOX_UNREACHABLE(
+      "Invalid type {}, expected BigintEnum or VarcharEnum", enumType);
+}
 } // namespace facebook::velox
diff --git a/velox/type/parser/ParserUtil.h b/velox/type/parser/ParserUtil.h
index 9095edb25011..2238323c38e5 100644
--- a/velox/type/parser/ParserUtil.h
+++ b/velox/type/parser/ParserUtil.h
@@ -31,6 +31,16 @@ TypePtr customTypeWithChildren(
     const std::string& name,
     const std::vector<TypePtr>& children);
 
+/// Creates a LongEnumParameter with the enumName and valuesMap and passes it in
+/// as a parameter to BIGINT_ENUM type to return an enum Type.
+/// The valuesMap is assumed to have a format of "[["CURIOUS",-2], ["HAPPY",0]]"
+/// so that folly::parseJson can be used to parse and throw on duplicate keys
+/// and/or values.
+TypePtr getEnumType(
+    const std::string& enumType,
+    const std::string& enumName,
+    const std::string& valuesMap);
+
 /// 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
diff --git a/velox/type/parser/Scanner.h b/velox/type/parser/Scanner.h
index bc4a820c4c93..91f0fb397b84 100644
--- a/velox/type/parser/Scanner.h
+++ b/velox/type/parser/Scanner.h
@@ -26,6 +26,9 @@
 
 namespace facebook::velox::type {
 
+/// velox/type/parser has been moved to velox/functions/prestosql/types/parser.
+/// This file is for backward compatibility and will be removed once Presto is
+/// updated with the new Velox version.
 class Scanner : public yyFlexLexer {
  public:
   Scanner(
@@ -35,7 +38,10 @@ class Scanner : public yyFlexLexer {
       const std::string_view input)
       : yyFlexLexer(&arg_yyin, &arg_yyout),
         outputType_(outputType),
-        input_(input){};
+        input_(input) {}
+
+  ~Scanner() = default;
+
   int lex(Parser::semantic_type* yylval);
 
   void setType(TypePtr type) {
@@ -51,5 +57,4 @@ class Scanner : public yyFlexLexer {
   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
index e7d08b7313d0..489f65d48163 100644
--- a/velox/type/parser/TypeParser.h
+++ b/velox/type/parser/TypeParser.h
@@ -20,9 +20,12 @@
 #include "velox/type/Type.h"
 
 namespace facebook::velox {
+/// velox/type/parser has been moved to velox/functions/prestosql/types/parser.
+/// This file is for backward compatibility and will be removed once Presto is
+/// updated with the new Velox version.
 
-/// Parses a type string in Presto format to Velox type.
-/// Example type strings:
+/// Parses a type string in Presto format to
+/// Velox type. Example type strings:
 ///    row(col0 bigint, varchar)
 ///    array(bigint)
 ///    map(bigint, array(bigint))
diff --git a/velox/type/parser/TypeParser.ll b/velox/type/parser/TypeParser.ll
index 3bab4a169f99..5961ac8baaeb 100644
--- a/velox/type/parser/TypeParser.ll
+++ b/velox/type/parser/TypeParser.ll
@@ -1,13 +1,15 @@
 %{
 #include <vector>
 #include <memory>
+#include <map>
 
 #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
+%option c++ noyywrap noyylineno nodefault caseless ecs
 
 A   [A|a]
 B   [B|b]
@@ -34,15 +36,21 @@ Y   [Y|y]
 Z   [Z|z]
 
 WORD              ([[:alpha:][:alnum:]_]*)
-QUOTED_ID         (['"'][[:alnum:][:space:]_]*['"'])
+QUOTED_ID         (['"']([^"\n]|"")*['"'])
 NUMBER            ([[:digit:]]+)
+SIGNED_INT        (-?[[:digit:]]+)
 VARIABLE          (VARCHAR|VARBINARY)
+WORD_WITH_PERIODS ([[:alpha:]_][[:alnum:]_]*)(\.([[:alpha:]_][[:alnum:]_]*))*
 
 %%
 
 "("                return Parser::token::LPAREN;
 ")"                return Parser::token::RPAREN;
+"{"                return Parser::token::LBRACE;
+"}"                return Parser::token::RBRACE;
 ","                return Parser::token::COMMA;
+"."                return Parser::token::PERIOD;
+":"                return Parser::token::COLON;
 (ARRAY)            return Parser::token::ARRAY;
 (MAP)              return Parser::token::MAP;
 (FUNCTION)         return Parser::token::FUNCTION;
@@ -50,7 +58,9 @@ VARIABLE          (VARCHAR|VARBINARY)
 (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;
+{SIGNED_INT}       yylval->build<long long>(folly::to<int>(YYText())); return Parser::token::SIGNED_INT;
 {WORD}             yylval->build<std::string>(YYText()); return Parser::token::WORD;
+{WORD_WITH_PERIODS}             yylval->build<std::string>(YYText()); return Parser::token::WORD_WITH_PERIODS;
 {QUOTED_ID}        yylval->build<std::string>(YYText()); return Parser::token::QUOTED_ID;
 <<EOF>>            return Parser::token::YYEOF;
 .               /* no action on unmatched input */
diff --git a/velox/type/parser/TypeParser.yy b/velox/type/parser/TypeParser.yy
index 945232bde6fd..8f7992c1754f 100644
--- a/velox/type/parser/TypeParser.yy
+++ b/velox/type/parser/TypeParser.yy
@@ -29,22 +29,23 @@
 
 %code
 {
-    #include <velox/type/parser/Scanner.h>
+    #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               LPAREN RPAREN COMMA PERIOD COLON ARRAY MAP ROW FUNCTION DECIMAL LBRACE RBRACE
+%token <std::string> WORD VARIABLE QUOTED_ID WORD_WITH_PERIODS
+%token <long long>   NUMBER SIGNED_INT
 %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 custom_type_with_children
+%nterm <std::shared_ptr<const Type>> special_type function_type decimal_type row_type array_type map_type variable_type custom_type_with_children enum_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
+%nterm <std::string> field_name enum_name enum_kind enum_map_entry enum_map_entries enum_map_entries_json
 
 %start type_spec
 
@@ -69,6 +70,7 @@ special_type : array_type     { $$ = $1; }
              | variable_type  { $$ = $1; }
              | decimal_type   { $$ = $1; }
              | custom_type_with_children { $$ = $1; }
+             | enum_type { $$ = $1; }
 
 /*
  * Types with spaces have at least two words. They are joined in an
@@ -148,6 +150,44 @@ named_type : type_single_word        { $$ = std::make_pair("", $1); }
            | type_with_spaces        { $$ = inferTypeWithSpaces($1, false); }
            | QUOTED_ID type          { $1.erase(0, 1); $1.pop_back(); $$ = std::make_pair($1, $2); }  // Remove the quotes.
            ;
+/*
+ * Enum types have a format of:
+ * "test.enum.mood:BigintEnum(test.enum.mood{"CURIOUS":2, "HAPPY":0})"
+ * where "test.enum.mood" is the enum name, "BigintEnum" is the enum kind,
+ * and "CURIOUS":2, "HAPPY":0 are the enum values.
+ * These values are passed as parameters to BIGINT_ENUM type.
+ */
+enum_map_entries : enum_map_entry { $$ = $1; }
+            | enum_map_entries COMMA enum_map_entry { $$ = $1 + ", " + $3; }
+            ;
+
+/*
+ * Formats the values map like "[["CURIOUS",-2], ["HAPPY",0]]"
+ * so that it can be parsed as an array of pairs using folly::parseJson in getEnumType.
+ */
+enum_map_entries_json : LBRACE enum_map_entries RBRACE {$$ = "[" + $2 + "]"; }
+                    ;
+
+enum_map_entry : QUOTED_ID COLON SIGNED_INT {  $$ = "[" + $1 + "," + std::to_string($3) + "]"; }
+               | QUOTED_ID COLON NUMBER     {  $$ = "[" + $1 + "," + std::to_string($3) + "]"; }
+               | QUOTED_ID COLON QUOTED_ID  {  $$ = "[" + $1 + "," + $3 + "]"; }
+               ;
+
+enum_kind : WORD { if ($1 != "BigintEnum" && $1 != "VarcharEnum" )
+                    {
+                        std::string msg = "Invalid type " + $1 + ", expected BigintEnum or VarcharEnum";
+                        error(msg.c_str());
+                    }
+                $$ = $1; }
+                ;
+
+enum_name : WORD_WITH_PERIODS { $$ = $1; }
+          | WORD { $$ = $1; }
+          ;
+
+enum_type : enum_name COLON enum_kind LPAREN enum_name enum_map_entries_json RPAREN
+          { $$ = getEnumType($3, $1, $6); }
+          ;
 
 %%
 
diff --git a/velox/type/parser/tests/CMakeLists.txt b/velox/type/parser/tests/CMakeLists.txt
index 5894a12867b3..510caebe25dc 100644
--- a/velox/type/parser/tests/CMakeLists.txt
+++ b/velox/type/parser/tests/CMakeLists.txt
@@ -20,6 +20,8 @@ target_link_libraries(
   velox_type_parser_test
   velox_type_parser
   velox_type
+  velox_presto_types
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
diff --git a/velox/type/parser/tests/TypeParserTest.cpp b/velox/type/parser/tests/TypeParserTest.cpp
index cf938fd90d16..9469046fa65b 100644
--- a/velox/type/parser/tests/TypeParserTest.cpp
+++ b/velox/type/parser/tests/TypeParserTest.cpp
@@ -17,6 +17,10 @@
 #include <gtest/gtest.h>
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/functions/prestosql/types/BigintEnumRegistration.h"
+#include "velox/functions/prestosql/types/BigintEnumType.h"
+#include "velox/functions/prestosql/types/VarcharEnumRegistration.h"
+#include "velox/functions/prestosql/types/VarcharEnumType.h"
 #include "velox/type/parser/TypeParser.h"
 
 namespace facebook::velox {
@@ -42,9 +46,9 @@ static const TypePtr& TIMESTAMP_WITH_TIME_ZONE() {
   return instance;
 }
 
-class TypeFactories : public CustomTypeFactories {
+class TypeFactory : public CustomTypeFactory {
  public:
-  TypeFactories(const TypePtr& type) : type_(type) {}
+  TypeFactory(const TypePtr& type) : type_(type) {}
 
   TypePtr getType(
       const std::vector<TypeParameter>& /*parameters*/) const override {
@@ -68,10 +72,10 @@ 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("json", std::make_unique<const TypeFactory>(JSON()));
     registerCustomType(
         "timestamp with time zone",
-        std::make_unique<const TypeFactories>(TIMESTAMP_WITH_TIME_ZONE()));
+        std::make_unique<const TypeFactory>(TIMESTAMP_WITH_TIME_ZONE()));
   }
 };
 
@@ -200,8 +204,9 @@ TEST_F(TypeParserTest, rowType) {
       *ROW({"12 tb", "b", "c"}, {BIGINT(), BIGINT(), BIGINT()}));
 
   ASSERT_EQ(
-      *parseType("row(\"a\" bigint, \"b\" array(varchar), "
-                 "\"c\" timestamp with time zone)"),
+      *parseType(
+          "row(\"a\" bigint, \"b\" array(varchar), "
+          "\"c\" timestamp with time zone)"),
       *ROW(
           {"a", "b", "c"},
           {BIGINT(), ARRAY(VARCHAR()), TIMESTAMP_WITH_TIME_ZONE()}));
@@ -297,6 +302,11 @@ TEST_F(TypeParserTest, typesWithSpaces) {
           {"timestamp with time zone", "double"},
           {TIMESTAMP_WITH_TIME_ZONE(), DOUBLE()}));
 
+  // quoted filed name with special characters & spaces
+  ASSERT_EQ(
+      *parseType("row(\"Nested Some more weirdtt +- \\:\\: charact\" varchar)"),
+      *ROW({"Nested Some more weirdtt +- \\:\\: charact"}, {VARCHAR()}));
+
   // quoted field name with invalid type with spaces.
   VELOX_ASSERT_UNSUPPORTED_THROW(
       parseType(
@@ -338,9 +348,10 @@ TEST_F(TypeParserTest, decimalType) {
 // 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))"),
+      *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",
@@ -362,5 +373,199 @@ TEST_F(TypeParserTest, fieldNames) {
            ARRAY(BIGINT())}));
 }
 
+TEST_F(TypeParserTest, bigintEnumBasic) {
+  registerBigintEnumType();
+  LongEnumParameter moodInfo("test.enum.mood", {{"CURIOUS", 2}, {"HAPPY", 0}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":2, \"HAPPY\":0})"),
+      *BIGINT_ENUM(moodInfo));
+
+  // Parse negative integers.
+  LongEnumParameter moodWithNegativeValue(
+      "test.enum.mood", {{"CURIOUS", -2}, {"HAPPY", 0}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})"),
+      *BIGINT_ENUM(moodWithNegativeValue));
+
+  // Enum name that is not in the form catalog.namespace.enum_name.
+  LongEnumParameter otherEnumInfo(
+      "someEnumType", {{"CURIOUS", 2}, {"HAPPY", 0}});
+  auto otherEnumString =
+      "someEnumType:BigintEnum(someEnumType{\"CURIOUS\": 2, \"HAPPY\": 0})";
+  ASSERT_EQ(*parseType(otherEnumString), *BIGINT_ENUM(otherEnumInfo));
+
+  // Array type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "array(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":2, \"HAPPY\":0}))"),
+      *ARRAY(BIGINT_ENUM(moodInfo)));
+
+  // Map type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "map(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}), bigint)"),
+      *MAP(BIGINT_ENUM(moodWithNegativeValue), BIGINT()));
+  ASSERT_EQ(
+      *parseType(
+          "map(bigint,test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}))"),
+      *MAP(BIGINT(), BIGINT_ENUM(moodWithNegativeValue)));
+
+  // Row type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "row(test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0}))"),
+      *ROW({BIGINT_ENUM(moodWithNegativeValue)}));
+  ASSERT_EQ(
+      *parseType(
+          "row(c0 test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2,\"HAPPY\":0}))"),
+      *ROW({"c0"}, {BIGINT_ENUM(moodWithNegativeValue)}));
+}
+
+TEST_F(TypeParserTest, invalidBigintEnums) {
+  // Duplicate keys.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"CURIOUS\":0})"),
+      "Failed to parse map: [[\"CURIOUS\",-2], [\"CURIOUS\",0]], duplicate key found: CURIOUS");
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"Curious\":0})"),
+      "Failed to parse map: [[\"CURIOUS\",-2], [\"Curious\",0]], duplicate key found: CURIOUS");
+
+  // Duplicate values.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":-2})"),
+      "Failed to parse map: [[\"CURIOUS\",-2], [\"HAPPY\",-2]], duplicate value found: -2");
+
+  // Invalid enum type SmallintEnum.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:SmallintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})"),
+      "Failed to parse type [test.enum.mood:SmallintEnum(test.enum.mood{\"CURIOUS\":-2, \"HAPPY\":0})]. Invalid type SmallintEnum, expected BigintEnum or VarcharEnum");
+
+  // Invalid format: missing ":"
+  VELOX_ASSERT_THROW(
+      parseType("testNoColon(test.enum.mood{“CURIOUS”:-2, “HAPPY”:0})"),
+      "Failed to parse type [testNoColon(test.enum.mood{“CURIOUS”:-2, “HAPPY”:0})]. syntax error, unexpected LBRACE, expecting COLON");
+
+  // Invalid format: missing "("
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.moodCURIOUS”:-2, “HAPPY”:0})"),
+      "Failed to parse type [test.enum.mood:BigintEnum(test.enum.moodCURIOUS”:-2, “HAPPY”:0})]. syntax error, unexpected COLON, expecting LBRACE");
+
+  // Invalid enum type with non integral values.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": \"varchar value\", \"HAPPY\": \"0\"})"),
+      "Failed to parse map: [[\"CURIOUS\",\"varchar value\"], [\"HAPPY\",\"0\"]], each element must have an integer value.");
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": 1.1, \"HAPPY\": -1.0})"),
+      "Failed to parse type [test.enum.mood:BigintEnum(test.enum.mood{\"CURIOUS\": 1.1, \"HAPPY\": -1.0})]. syntax error, unexpected PERIOD, expecting COMMA or RBRACE");
+}
+
+TEST_F(TypeParserTest, varcharEnumBasic) {
+  registerVarcharEnumType();
+  VarcharEnumParameter moodInfo(
+      "test.enum.mood",
+      {{"CURIOUS", "someValue"},
+       {"HAPPY", "some value"},
+       {"SAD", "SOME VALUE"}});
+  ASSERT_EQ(
+      *parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})"),
+      *VARCHAR_ENUM(moodInfo));
+
+  // Enum name that is not in the form catalog.namespace.enum_name.
+  VarcharEnumParameter otherEnumInfo(
+      "someEnumType",
+      {{"CURIOUS", "someValue"},
+       {"HAPPY", "some value"},
+       {"SAD", "SOME VALUE"}});
+  auto otherEnumString =
+      "someEnumType:VarcharEnum(someEnumType{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
+  ASSERT_EQ(*parseType(otherEnumString), *VARCHAR_ENUM(otherEnumInfo));
+
+  auto sameEnumDiffOrderMap =
+      "someEnumType:VarcharEnum(someEnumType{\"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"SAD\":\"KNHU2RJAKZAUYVKF\"})";
+  ASSERT_EQ(*parseType(sameEnumDiffOrderMap), *VARCHAR_ENUM(otherEnumInfo));
+
+  // Array type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "array(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
+      *ARRAY(VARCHAR_ENUM(moodInfo)));
+
+  // Map type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "map(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}), bigint)"),
+      *MAP(VARCHAR_ENUM(moodInfo), BIGINT()));
+  ASSERT_EQ(
+      *parseType(
+          "map(bigint,test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
+      *MAP(BIGINT(), VARCHAR_ENUM(moodInfo)));
+
+  // Row type with enum values.
+  ASSERT_EQ(
+      *parseType(
+          "row(test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
+      *ROW({VARCHAR_ENUM(moodInfo)}));
+  ASSERT_EQ(
+      *parseType(
+          "row(c0 test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZJAOZQWY5LF\" , \"SAD\":\"KNHU2RJAKZAUYVKF\"}))"),
+      *ROW({"c0"}, {VARCHAR_ENUM(moodInfo)}));
+}
+
+TEST_F(TypeParserTest, invalidVarcharEnums) {
+  // Duplicate keys or values.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"CURIOUS\":\"ONXW2ZJAOZQWY5LF\"})"),
+      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"CURIOUS\",\"ONXW2ZJAOZQWY5LF\"]], duplicate key found: CURIOUS");
+
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"curious\":\"ONXW2ZJAOZQWY5LF\"})"),
+      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"curious\",\"ONXW2ZJAOZQWY5LF\"]], duplicate key found: CURIOUS");
+
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"ONXW2ZKWMFWHKZI=\", \"HAPPY\":\"ONXW2ZKWMFWHKZI=\"})"),
+      "Failed to parse map: [[\"CURIOUS\",\"ONXW2ZKWMFWHKZI=\"], [\"HAPPY\",\"ONXW2ZKWMFWHKZI=\"]], duplicate value found: someValue");
+
+  // Invalid base 32 encoded values.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\":\"12345\", \"HAPPY\":\"ONXW2ZKWMFWHKZI=\"})"),
+      "Failed to parse value 12345, invalid Base32 character: 1");
+
+  // Invalid format: missing ":"
+  VELOX_ASSERT_THROW(
+      parseType(
+          "testNoColon(test.enum.mood{\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})"),
+      "Failed to parse type [testNoColon(test.enum.mood{\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})]. syntax error, unexpected LBRACE, expecting COLON");
+
+  // Invalid format: missing "{"
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})"),
+      "Failed to parse type [test.enum.mood:VarcharEnum(test.enum.mood\"CURIOUS\":\"2\", \"HAPPY\":\"happy\"})]. syntax error, unexpected QUOTED_ID, expecting LBRACE");
+
+  // Invalid enum type with values of different types.
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\": 0, \"HAPPY\":\"happy\"})"),
+      "Failed to parse map: [[\"CURIOUS\",0], [\"HAPPY\",\"happy\"]], each element must have a string value.");
+  VELOX_ASSERT_THROW(
+      parseType(
+          "test.enum.mood:VarcharEnum(test.enum.mood{\"CURIOUS\": 0, \"HAPPY\":1})"),
+      "Failed to parse map: [[\"CURIOUS\",0], [\"HAPPY\",1]], each element must have a string value.");
+}
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/type/tests/CMakeLists.txt b/velox/type/tests/CMakeLists.txt
index 9aec020d5deb..f00c38451a40 100644
--- a/velox/type/tests/CMakeLists.txt
+++ b/velox/type/tests/CMakeLists.txt
@@ -21,12 +21,15 @@ add_executable(
   FilterSerDeTest.cpp
   FloatingPointUtilTest.cpp
   HugeIntTest.cpp
+  OpaqueCustomTypesTest.cpp
   StringViewTest.cpp
   SubfieldTest.cpp
   TimestampConversionTest.cpp
   TimestampTest.cpp
   TypeTest.cpp
-  VariantTest.cpp)
+  TypeCoercerTest.cpp
+  VariantTest.cpp
+)
 
 add_test(velox_type_test velox_type_test)
 
@@ -39,7 +42,8 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
   GTest::gmock
-  glog::glog)
+  glog::glog
+)
 
 if(VELOX_ENABLE_BENCHMARKS)
   add_executable(velox_filter_benchmark FilterBenchmark.cpp)
@@ -52,10 +56,10 @@ if(VELOX_ENABLE_BENCHMARKS)
     Folly::follybenchmark
     GTest::gtest
     GTest::gtest_main
-    glog::glog)
+    glog::glog
+  )
 
-  add_executable(velox_negated_values_filter_benchmark
-                 NegatedValuesFilterBenchmark.cpp)
+  add_executable(velox_negated_values_filter_benchmark NegatedValuesFilterBenchmark.cpp)
 
   target_link_libraries(
     velox_negated_values_filter_benchmark
@@ -65,10 +69,10 @@ if(VELOX_ENABLE_BENCHMARKS)
     Folly::follybenchmark
     GTest::gtest
     GTest::gtest_main
-    glog::glog)
+    glog::glog
+  )
 
-  add_executable(velox_negated_bytes_values_benchmark
-                 NegatedBytesValuesBenchmark.cpp)
+  add_executable(velox_negated_bytes_values_benchmark NegatedBytesValuesBenchmark.cpp)
 
   target_link_libraries(
     velox_negated_bytes_values_benchmark
@@ -78,10 +82,10 @@ if(VELOX_ENABLE_BENCHMARKS)
     Folly::follybenchmark
     GTest::gtest
     GTest::gtest_main
-    glog::glog)
+    glog::glog
+  )
 
-  add_executable(velox_negated_bigint_range_benchmark
-                 NegatedBigintRangeBenchmark.cpp)
+  add_executable(velox_negated_bigint_range_benchmark NegatedBigintRangeBenchmark.cpp)
 
   target_link_libraries(
     velox_negated_bigint_range_benchmark
@@ -91,10 +95,10 @@ if(VELOX_ENABLE_BENCHMARKS)
     Folly::follybenchmark
     GTest::gtest
     GTest::gtest_main
-    glog::glog)
+    glog::glog
+  )
 
-  add_executable(velox_negated_bytes_range_benchmark
-                 NegatedBytesRangeBenchmark.cpp)
+  add_executable(velox_negated_bytes_range_benchmark NegatedBytesRangeBenchmark.cpp)
 
   target_link_libraries(
     velox_negated_bytes_range_benchmark
@@ -104,7 +108,8 @@ if(VELOX_ENABLE_BENCHMARKS)
     Folly::follybenchmark
     GTest::gtest
     GTest::gtest_main
-    glog::glog)
+    glog::glog
+  )
 
   add_executable(velox_string_view_benchmark StringViewBenchmark.cpp)
 
@@ -115,5 +120,6 @@ if(VELOX_ENABLE_BENCHMARKS)
     Folly::follybenchmark
     GTest::gtest
     GTest::gtest_main
-    glog::glog)
+    glog::glog
+  )
 endif()
diff --git a/velox/type/tests/ConversionsTest.cpp b/velox/type/tests/ConversionsTest.cpp
index f099a6e30954..635eb080d9f9 100644
--- a/velox/type/tests/ConversionsTest.cpp
+++ b/velox/type/tests/ConversionsTest.cpp
@@ -300,7 +300,7 @@ TEST_F(ConversionsTest, toBoolean) {
   }
 }
 
-TEST_F(ConversionsTest, toIntegeralTypes) {
+TEST_F(ConversionsTest, toIntegralTypes) {
   // From double.
   {
     // When TRUNCATE = false.
diff --git a/velox/type/tests/DecimalTest.cpp b/velox/type/tests/DecimalTest.cpp
index ecef7801167f..0d5ad1013d68 100644
--- a/velox/type/tests/DecimalTest.cpp
+++ b/velox/type/tests/DecimalTest.cpp
@@ -128,6 +128,39 @@ void testMaxStringViewSize(
       DecimalUtil::maxStringViewSize(precision, scale), expectedMaxStringSize);
 }
 
+template <typename T>
+void testCastFromString(
+    const std::vector<std::string>& inputs,
+    int toPrecision,
+    int toScale,
+    const std::vector<T>& expectedUnscaleValues) {
+  for (int i = 0; i < inputs.size(); ++i) {
+    SCOPED_TRACE(
+        fmt::format(
+            "Index: {}, input: {}, expectedUnscaleValue: {}.",
+            i,
+            inputs[i],
+            expectedUnscaleValues[i]));
+    T decimalValue;
+    auto status = DecimalUtil::castFromString<T>(
+        StringView(inputs[i]), toPrecision, toScale, decimalValue);
+    EXPECT_TRUE(status.ok());
+    EXPECT_EQ(expectedUnscaleValues[i], decimalValue);
+  }
+}
+
+template <typename T>
+void testCastFromString(
+    const std::string& input,
+    int toPrecision,
+    int toScale,
+    const std::string& expectedError) {
+  T decimalValue;
+  auto status = DecimalUtil::castFromString<T>(
+      StringView(input), toPrecision, toScale, decimalValue);
+  EXPECT_EQ(status, Status::UserError(expectedError));
+}
+
 std::string zeros(uint32_t numZeros) {
   return std::string(numZeros, '0');
 }
@@ -282,16 +315,21 @@ TEST(DecimalTest, valueInPrecisionRange) {
   ASSERT_TRUE(DecimalUtil::valueInPrecisionRange<int64_t>(999, 3));
   ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int64_t>(1000, 3));
   ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int64_t>(1234, 3));
-  ASSERT_TRUE(DecimalUtil::valueInPrecisionRange<int64_t>(
-      DecimalUtil::kShortDecimalMax, ShortDecimalType::kMaxPrecision));
-  ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int64_t>(
-      DecimalUtil::kShortDecimalMax + 1, ShortDecimalType::kMaxPrecision));
-  ASSERT_TRUE(DecimalUtil::valueInPrecisionRange<int128_t>(
-      DecimalUtil::kLongDecimalMax, LongDecimalType::kMaxPrecision));
-  ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int128_t>(
-      DecimalUtil::kLongDecimalMax + 1, LongDecimalType::kMaxPrecision));
-  ASSERT_FALSE(DecimalUtil::valueInPrecisionRange<int128_t>(
-      DecimalUtil::kLongDecimalMin - 1, LongDecimalType::kMaxPrecision));
+  ASSERT_TRUE(
+      DecimalUtil::valueInPrecisionRange<int64_t>(
+          DecimalUtil::kShortDecimalMax, ShortDecimalType::kMaxPrecision));
+  ASSERT_FALSE(
+      DecimalUtil::valueInPrecisionRange<int64_t>(
+          DecimalUtil::kShortDecimalMax + 1, ShortDecimalType::kMaxPrecision));
+  ASSERT_TRUE(
+      DecimalUtil::valueInPrecisionRange<int128_t>(
+          DecimalUtil::kLongDecimalMax, LongDecimalType::kMaxPrecision));
+  ASSERT_FALSE(
+      DecimalUtil::valueInPrecisionRange<int128_t>(
+          DecimalUtil::kLongDecimalMax + 1, LongDecimalType::kMaxPrecision));
+  ASSERT_FALSE(
+      DecimalUtil::valueInPrecisionRange<int128_t>(
+          DecimalUtil::kLongDecimalMin - 1, LongDecimalType::kMaxPrecision));
 }
 
 TEST(DecimalTest, computeAverage) {
@@ -570,5 +608,193 @@ TEST(DecimalTest, castToString) {
   testcastToString<int128_t>(
       DecimalUtil::kLongDecimalMin, 38, 0, 39, "-" + std::string(38, '9'));
 }
+
+TEST(DecimalTest, castFromString) {
+  testCastFromString<int64_t>(
+      {"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"},
+      12,
+      2,
+      {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});
+
+  // Truncates the fractional digits with exponent.
+  testCastFromString<int128_t>(
+      {"112345612.23e-6",
+       "112345662.23e-6",
+       "1.23e-6",
+       "1.23e-3",
+       "1.26e-3",
+       "1.23456781e3",
+       "1.23456789e3",
+       "1.23456789123451789123456789e9",
+       "1.23456789123456789123456789e9"},
+      20,
+      4,
+      {1123456,
+       1123457,
+       0,
+       12,
+       13,
+       12345678,
+       12345679,
+       12345678912345,
+       12345678912346});
+
+  const auto minDecimalStr = '-' + std::string(36, '9') + '.' + "99";
+  const auto maxDecimalStr = std::string(36, '9') + '.' + "99";
+  testCastFromString<int128_t>(
+      {minDecimalStr, maxDecimalStr, "123456789012345678901234.567"},
+      38,
+      2,
+      {
+          DecimalUtil::kLongDecimalMin,
+          DecimalUtil::kLongDecimalMax,
+          HugeInt::build(
+              669260, 10962463713375599297U), // 12345678901234567890123457
+      });
+
+  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";
+  testCastFromString<int128_t>(
+      {('-' + std::string(38, '9')),
+       std::string(38, '9'),
+       fractionLarge,
+       fractionLargeExp,
+       fractionLargeNegExp},
+      38,
+      0,
+      {DecimalUtil::kLongDecimalMin, DecimalUtil::kLongDecimalMax, 2, 200, 10});
+}
+
+TEST(DecimalTest, castFromStringError) {
+  testCastFromString<int128_t>(
+      std::string(280, '9'), 38, 0, "Value too large.");
+
+  // Overflows when parsing fractional digits.
+  const std::string fractionOverflow = std::string(36, '9') + '.' + "23456";
+  testCastFromString<int128_t>(fractionOverflow, 38, 10, "Value too large.");
+
+  const std::string fractionRoundUp = "0." + std::string(38, '9') + "6";
+  testCastFromString<int128_t>(fractionRoundUp, 38, 38, "Value too large.");
+
+  testCastFromString<int128_t>(
+      "0.0444a", 38, 0, "Value is not a number. Chars are invalid.");
+
+  testCastFromString<int128_t>(
+      "", 38, 0, "Value is not a number. Input is empty.");
+
+  // Exponent > LongDecimalType::kMaxPrecision.
+  testCastFromString<int128_t>("1.23e67", 38, 0, "Value too large.");
+
+  // Forcing the scale to be zero overflows.
+  testCastFromString<int128_t>("20908.23e35", 38, 0, "Value too large.");
+
+  // Rescale overflows.
+  testCastFromString<int128_t>(
+      "111111111111111111.23", 38, 38, "Value too large.");
+
+  testCastFromString<int128_t>(
+      "23e-5d",
+      38,
+      0,
+      "Value is not a number. Non-digit character is not allowed in the exponent part.");
+
+  // Whitespaces.
+  testCastFromString<int128_t>(
+      "1. 23", 38, 0, "Value is not a number. Chars are invalid.");
+  testCastFromString<int128_t>(
+      "-3E+ 2",
+      12,
+      2,
+      "Value is not a number. Non-digit character is not allowed in the exponent part.");
+  testCastFromString<int128_t>(
+      "1.23 ", 38, 0, "Value is not a number. Chars are invalid.");
+  testCastFromString<int64_t>(
+      "-3E+2 ",
+      12,
+      2,
+      "Value is not a number. Non-digit character is not allowed in the exponent part.");
+  testCastFromString<int128_t>(
+      " 1.23", 38, 0, "Value is not a number. Extracted digits are empty.");
+  testCastFromString<int64_t>(
+      " -3E+2", 12, 2, "Value is not a number. Extracted digits are empty.");
+
+  testCastFromString<int64_t>(
+      "-3E+2.1",
+      12,
+      2,
+      "Value is not a number. Non-digit character is not allowed in the exponent part.");
+
+  testCastFromString<int64_t>(
+      "-3E+",
+      12,
+      2,
+      "Value is not a number. The exponent part only contains sign.");
+
+  testCastFromString<int64_t>(
+      "-3E-",
+      12,
+      2,
+      "Value is not a number. The exponent part only contains sign.");
+  testCastFromString<int64_t>(
+      "9e", 12, 2, "Value is not a number. The exponent part is empty.");
+  testCastFromString<int64_t>(
+      "09{xi+yD", 12, 2, "Value is not a number. Chars are invalid.");
+}
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/type/tests/FilterBenchmark.cpp b/velox/type/tests/FilterBenchmark.cpp
index c699b4da1e95..2cc3f4371506 100644
--- a/velox/type/tests/FilterBenchmark.cpp
+++ b/velox/type/tests/FilterBenchmark.cpp
@@ -14,15 +14,10 @@
  * limitations under the License.
  */
 
-#include <limits>
 #include "folly/Benchmark.h"
-#include "folly/Portability.h"
 #include "folly/Random.h"
-#include "folly/Varint.h"
 #include "folly/init/Init.h"
-#include "folly/lang/Bits.h"
-#include "velox/dwio/common/exception/Exception.h"
-
+#include "velox/common/base/SimdUtil.h"
 #include "velox/type/Filter.h"
 
 using namespace facebook::velox;
diff --git a/velox/type/tests/FilterSerDeTest.cpp b/velox/type/tests/FilterSerDeTest.cpp
index 0b4c52c1a902..21a7dfa9fb82 100644
--- a/velox/type/tests/FilterSerDeTest.cpp
+++ b/velox/type/tests/FilterSerDeTest.cpp
@@ -149,8 +149,9 @@ TEST_F(FilterSerDeTest, multiFilter) {
   std::vector<int64_t> values{3, 7, 18};
   filters.emplace_back(
       std::make_unique<BigintValuesUsingHashTable>(1, 10, values, true));
-  filters.emplace_back(std::make_unique<BytesRange>(
-      "ABCD", true, true, "FFFF", false, true, false));
+  filters.emplace_back(
+      std::make_unique<BytesRange>(
+          "ABCD", true, true, "FFFF", false, true, false));
 
   MultiRange multiRange(std::move(filters), true);
   testSerde(multiRange);
diff --git a/velox/type/tests/FilterTest.cpp b/velox/type/tests/FilterTest.cpp
index d4ecffed10c7..db5992cb1698 100644
--- a/velox/type/tests/FilterTest.cpp
+++ b/velox/type/tests/FilterTest.cpp
@@ -26,7 +26,9 @@
 
 #include <gtest/gtest.h>
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
+
 using namespace facebook::velox::common;
 using namespace facebook::velox::exec;
 
@@ -39,8 +41,7 @@ TEST(FilterTest, alwaysFalse) {
   EXPECT_FALSE(alwaysFalse.testNull());
 
   EXPECT_EQ(
-      "Filter(AlwaysFalse, deterministic, null not allowed)",
-      alwaysFalse.toString());
+      "Filter(AlwaysFalse, deterministic, no nulls)", alwaysFalse.toString());
 }
 
 TEST(FilterTest, alwaysTrue) {
@@ -63,7 +64,7 @@ TEST(FilterTest, alwaysTrue) {
       simd::allSetBitMask<int16_t>(),
       simd::toBitMask(alwaysTrue.testValues(int16s)));
   EXPECT_EQ(
-      "Filter(AlwaysTrue, deterministic, null allowed)", alwaysTrue.toString());
+      "Filter(AlwaysTrue, deterministic, with nulls)", alwaysTrue.toString());
 }
 
 TEST(FilterTest, isNotNull) {
@@ -86,7 +87,7 @@ TEST(FilterTest, isNull) {
   EXPECT_FALSE(isNull.testInt128Range(0, 0, false));
   EXPECT_TRUE(isNull.testInt128Range(0, 0, true));
 
-  EXPECT_EQ("Filter(IsNull, deterministic, null allowed)", isNull.toString());
+  EXPECT_EQ("Filter(IsNull, deterministic, with nulls)", isNull.toString());
 }
 
 // Applies 'filter' to all T type lanes of 'values' and compares the result to
@@ -304,6 +305,13 @@ TEST(FilterTest, bigintValuesUsingHashTable) {
   EXPECT_TRUE(filter->testInt64Range(0, 1, false));
 }
 
+TEST(FilterTest, negatedBigintValuesUsingHashTableOverflow) {
+  auto filter = createNegatedBigintValues(
+      {-9074444101981834051, 7013258837215469735}, false);
+  EXPECT_TRUE(
+      filter->testInt64Range(-9074444101981834051, 7013258837215469735, false));
+}
+
 TEST(FilterTest, negatedBigintValuesUsingHashTable) {
   auto filter = createNegatedBigintValues({1, 6, 10'000, 8, 9, 100, 10}, false);
   auto castedFilter =
@@ -470,7 +478,10 @@ TEST(FilterTest, negatedBigintValuesUsingHashTableSimd) {
 
 TEST(FilterTest, bigintValuesUsingBitmask) {
   auto filter = createBigintValues({1, 10, 100, 1000}, false);
-  ASSERT_TRUE(dynamic_cast<BigintValuesUsingBitmask*>(filter.get()));
+  auto castedFilter = dynamic_cast<BigintValuesUsingBitmask*>(filter.get());
+  ASSERT_TRUE(castedFilter);
+  ASSERT_EQ(castedFilter->min(), 1);
+  ASSERT_EQ(castedFilter->max(), 1000);
 
   EXPECT_TRUE(filter->testInt64(1));
   EXPECT_TRUE(filter->testInt64(10));
@@ -496,6 +507,8 @@ TEST(FilterTest, negatedBigintValuesUsingBitmask) {
   ASSERT_TRUE(castedFilter);
   std::vector<int64_t> filterVals = {1, 6, 8, 9, 10, 100, 1000};
   ASSERT_EQ(castedFilter->values(), filterVals);
+  ASSERT_EQ(castedFilter->min(), 1);
+  ASSERT_EQ(castedFilter->max(), 1000);
 
   EXPECT_FALSE(filter->testInt64(1));
   EXPECT_FALSE(filter->testInt64(10));
@@ -602,6 +615,70 @@ TEST(FilterTest, negatedBigintValuesEdgeCases) {
   EXPECT_TRUE(not_equal->testInt64(1));
 }
 
+TEST(FilterTest, bigintValuesUsingBloomFilter) {
+  BigintValuesUsingBloomFilter filter(10, false);
+  folly::F14FastSet<int64_t> inserted;
+  for (int64_t x : {2, 3, 5, 7, 11, 13, 17, 19}) {
+    filter.insert(x);
+    inserted.insert(x);
+  }
+  ASSERT_FALSE(filter.testNull());
+  for (int i = 0; i < 20; ++i) {
+    ASSERT_EQ(filter.testInt64(i), inserted.contains(i));
+  }
+  ASSERT_TRUE(filter.testInt64Range(20, 30, true));
+  ASSERT_TRUE(filter.testingEquals(filter));
+  Filter::registerSerDe();
+  auto serialized = filter.serialize();
+  auto deserialized =
+      ISerializable::deserialize<BigintValuesUsingBloomFilter>(serialized);
+  ASSERT_TRUE(deserialized->testingEquals(filter));
+  ASSERT_FALSE(filter.testInt64(23));
+  filter.insert(23);
+  ASSERT_TRUE(filter.testInt64(23));
+  ASSERT_FALSE(deserialized->testingEquals(filter));
+  ASSERT_TRUE(filter.clone(std::nullopt)->testingEquals(filter));
+  auto nullAllowedClone = filter.clone(true);
+  ASSERT_TRUE(nullAllowedClone->testNull());
+  ASSERT_TRUE(nullAllowedClone->clone(false)->testingEquals(filter));
+}
+
+TEST(FilterTest, bigintValuesUsingBloomFilterMergeWith) {
+  BigintValuesUsingBloomFilter filter(4, false);
+  for (int64_t x : {2, 3, 5, 7}) {
+    filter.insert(x);
+  }
+  auto test = [&](const Filter& other, const Filter& expected) {
+    auto merged = filter.mergeWith(&other);
+    ASSERT_TRUE(merged->testingEquals(expected));
+    auto merged2 = other.mergeWith(&filter);
+    ASSERT_TRUE(merged->testingEquals(*merged2));
+  };
+  {
+    SCOPED_TRACE("BigintRange");
+    test(BigintRange(2, 5, true), *createBigintValues({2, 3, 5}, false));
+  }
+  {
+    SCOPED_TRACE("Huge BigintRange");
+    BigintRange other(-1, INT64_MAX, true);
+    test(other, other);
+  }
+  {
+    SCOPED_TRACE("BigintValuesUsingHashTable");
+    std::vector<int64_t> otherValues = {INT64_MIN, 0, 3, 6, 9, INT64_MAX};
+    BigintValuesUsingHashTable other(
+        otherValues.front(), otherValues.back(), otherValues, true);
+    test(other, *createBigintValues({3}, false));
+  }
+  {
+    SCOPED_TRACE("BigintValuesUsingBitmask");
+    std::vector<int64_t> otherValues = {0, 3, 6, 9};
+    BigintValuesUsingBitmask other(
+        otherValues.front(), otherValues.back(), otherValues, true);
+    test(other, *createBigintValues({3}, false));
+  }
+}
+
 TEST(FilterTest, bigintMultiRange) {
   // x between 1 and 10 or x between 100 and 120
   auto filter = bigintOr(between(1, 10), between(100, 120));
@@ -713,6 +790,32 @@ TEST(FilterTest, doubleRange) {
   EXPECT_FALSE(filter->testDouble(1));
   EXPECT_TRUE(filter->testDouble(3));
   EXPECT_TRUE(filter->testDouble(100));
+
+  // Test DoubleRange filter with float batch (schema evolution slow path).
+  // When a double filter is applied to float data, it falls back to
+  // element-by-element testing instead of SIMD batch processing.
+  filter = betweenDouble(1.2, 3.4);
+  {
+    auto verifyFloat = [&](float x) { return filter->testFloat(x); };
+    float n8[] = {1.0f, std::nanf("nan"), 3.4f, 3.1f, -1e20f, 0.0f, 1.1f, 1.2f};
+    checkSimd(filter.get(), n8, verifyFloat);
+  }
+
+  filter = lessThanOrEqualDouble(1.2);
+  {
+    auto verifyFloat = [&](float x) { return filter->testFloat(x); };
+    float n8[] = {
+        1.0f, std::nanf("nan"), 1.3f, 1e20f, -1e20f, 0.0f, 1.1f, 1.2f};
+    checkSimd(filter.get(), n8, verifyFloat);
+  }
+
+  filter = greaterThanDouble(1.2);
+  {
+    auto verifyFloat = [&](float x) { return filter->testFloat(x); };
+    float n8[] = {
+        1.0f, std::nanf("nan"), 1.3f, 1e20f, -1e20f, 0.0f, 1.1f, 1.2f};
+    checkSimd(filter.get(), n8, verifyFloat);
+  }
 }
 
 TEST(FilterTest, floatRange) {
@@ -780,11 +883,17 @@ TEST(FilterTest, floatRange) {
   EXPECT_TRUE(filter->testFloat(100));
 }
 
+bool testBytes(const Filter& filter, std::string_view value) {
+  bool result = filter.testBytes(value.data(), value.size());
+  VELOX_CHECK_EQ(filter.testStringView(StringView(value)), result);
+  return result;
+}
+
 TEST(FilterTest, bytesRange) {
   {
     auto filter = equal("abc");
-    EXPECT_TRUE(filter->testBytes("abc", 3));
-    EXPECT_FALSE(filter->testBytes("acb", 3));
+    EXPECT_TRUE(testBytes(*filter, "abc"));
+    EXPECT_FALSE(testBytes(*filter, "acb"));
     EXPECT_TRUE(filter->testLength(3));
     // The bit for lane 2 should be set.
     int32_t lens[] = {0, 1, 3, 0, 4, 10, 11, 12};
@@ -792,8 +901,8 @@ TEST(FilterTest, bytesRange) {
         4, simd::toBitMask(filter->testLengths(xsimd::load_unaligned(lens))));
 
     EXPECT_FALSE(filter->testNull());
-    EXPECT_FALSE(filter->testBytes("apple", 5));
-    EXPECT_FALSE(filter->testBytes(nullptr, 0));
+    EXPECT_FALSE(testBytes(*filter, "apple"));
+    EXPECT_FALSE(testBytes(*filter, {}));
     EXPECT_FALSE(filter->testLength(4));
 
     EXPECT_TRUE(filter->testBytesRange("abc", "abc", false));
@@ -812,132 +921,132 @@ TEST(FilterTest, bytesRange) {
 
     // = ''
     filter = equal("");
-    EXPECT_TRUE(filter->testBytes(nullptr, 0));
-    EXPECT_FALSE(filter->testBytes("abc", 3));
+    EXPECT_TRUE(testBytes(*filter, {}));
+    EXPECT_FALSE(testBytes(*filter, "abc"));
   }
 
   char const* theBestOfTimes =
       "It was the best of times, it was the worst of times, it was the age of wisdom, it was the age of foolishness, it was the epoch of belief, it was the epoch of incredulity,...";
   auto filter = lessThanOrEqual(theBestOfTimes);
-  EXPECT_TRUE(filter->testBytes(theBestOfTimes, std::strlen(theBestOfTimes)));
-  EXPECT_TRUE(filter->testBytes(theBestOfTimes, 5));
-  EXPECT_TRUE(filter->testBytes(theBestOfTimes, 50));
-  EXPECT_TRUE(filter->testBytes(theBestOfTimes, 100));
+  EXPECT_TRUE(testBytes(*filter, theBestOfTimes));
+  EXPECT_TRUE(testBytes(*filter, {theBestOfTimes, 5}));
+  EXPECT_TRUE(testBytes(*filter, {theBestOfTimes, 50}));
+  EXPECT_TRUE(testBytes(*filter, {theBestOfTimes, 100}));
   // testLength is true of all lengths for a range filter.
   EXPECT_TRUE(filter->testLength(1));
   EXPECT_TRUE(filter->testLength(1000));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("Zzz", 3));
-  EXPECT_FALSE(filter->testBytes("It was the best of times, zzz", 30));
+  EXPECT_FALSE(testBytes(*filter, "Zzz"));
+  EXPECT_FALSE(testBytes(*filter, {"It was the best of times, zzz", 30}));
 
   EXPECT_TRUE(filter->testBytesRange("Apple", "banana", false));
   EXPECT_FALSE(filter->testBytesRange("Pear", "Plum", false));
   EXPECT_FALSE(filter->testBytesRange("apple", "banana", false));
 
   filter = greaterThanOrEqual("abc");
-  EXPECT_TRUE(filter->testBytes("abc", 3));
-  EXPECT_TRUE(filter->testBytes("ad", 2));
-  EXPECT_TRUE(filter->testBytes("apple", 5));
-  EXPECT_TRUE(filter->testBytes("banana", 6));
+  EXPECT_TRUE(testBytes(*filter, "abc"));
+  EXPECT_TRUE(testBytes(*filter, "ad"));
+  EXPECT_TRUE(testBytes(*filter, "apple"));
+  EXPECT_TRUE(testBytes(*filter, "banana"));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("ab", 2));
-  EXPECT_FALSE(filter->testBytes("_abc", 4));
+  EXPECT_FALSE(testBytes(*filter, "ab"));
+  EXPECT_FALSE(testBytes(*filter, "_abc"));
 
   filter = between("apple", "banana");
-  EXPECT_TRUE(filter->testBytes("apple", 5));
-  EXPECT_TRUE(filter->testBytes("banana", 6));
-  EXPECT_TRUE(filter->testBytes("avocado", 7));
+  EXPECT_TRUE(testBytes(*filter, "apple"));
+  EXPECT_TRUE(testBytes(*filter, "banana"));
+  EXPECT_TRUE(testBytes(*filter, "avocado"));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("camel", 5));
-  EXPECT_FALSE(filter->testBytes("_abc", 4));
+  EXPECT_FALSE(testBytes(*filter, "camel"));
+  EXPECT_FALSE(testBytes(*filter, "_abc"));
 
   filter = std::make_unique<BytesRange>(
       "apple", false, true, "banana", false, false, false);
-  EXPECT_TRUE(filter->testBytes("banana", 6));
-  EXPECT_TRUE(filter->testBytes("avocado", 7));
+  EXPECT_TRUE(testBytes(*filter, "banana"));
+  EXPECT_TRUE(testBytes(*filter, "avocado"));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("apple", 5));
-  EXPECT_FALSE(filter->testBytes("camel", 5));
-  EXPECT_FALSE(filter->testBytes("_abc", 4));
+  EXPECT_FALSE(testBytes(*filter, "apple"));
+  EXPECT_FALSE(testBytes(*filter, "camel"));
+  EXPECT_FALSE(testBytes(*filter, "_abc"));
 
   filter = std::make_unique<BytesRange>(
       "apple", false, true, "banana", false, true, false);
-  EXPECT_TRUE(filter->testBytes("avocado", 7));
+  EXPECT_TRUE(testBytes(*filter, "avocado"));
 
   EXPECT_FALSE(filter->testNull());
-  EXPECT_FALSE(filter->testBytes("apple", 5));
-  EXPECT_FALSE(filter->testBytes("banana", 6));
-  EXPECT_FALSE(filter->testBytes("camel", 5));
-  EXPECT_FALSE(filter->testBytes("_abc", 4));
+  EXPECT_FALSE(testBytes(*filter, "apple"));
+  EXPECT_FALSE(testBytes(*filter, "banana"));
+  EXPECT_FALSE(testBytes(*filter, "camel"));
+  EXPECT_FALSE(testBytes(*filter, "_abc"));
 
   // < b
   filter = lessThan("b");
-  EXPECT_TRUE(filter->testBytes("a", 1));
-  EXPECT_FALSE(filter->testBytes("b", 1));
-  EXPECT_FALSE(filter->testBytes("c", 1));
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
+  EXPECT_TRUE(testBytes(*filter, "a"));
+  EXPECT_FALSE(testBytes(*filter, "b"));
+  EXPECT_FALSE(testBytes(*filter, "c"));
+  EXPECT_TRUE(testBytes(*filter, {}));
   EXPECT_FALSE(filter->testBytesRange("b", "c", false));
 
   // <= b
   filter = lessThanOrEqual("b");
-  EXPECT_TRUE(filter->testBytes("a", 1));
-  EXPECT_TRUE(filter->testBytes("b", 1));
-  EXPECT_FALSE(filter->testBytes("c", 1));
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
+  EXPECT_TRUE(testBytes(*filter, "a"));
+  EXPECT_TRUE(testBytes(*filter, "b"));
+  EXPECT_FALSE(testBytes(*filter, "c"));
+  EXPECT_TRUE(testBytes(*filter, {}));
   EXPECT_TRUE(filter->testBytesRange("b", "c", false));
 
   // >= b
   filter = greaterThanOrEqual("b");
-  EXPECT_FALSE(filter->testBytes("a", 1));
-  EXPECT_TRUE(filter->testBytes("b", 1));
-  EXPECT_TRUE(filter->testBytes("c", 1));
-  EXPECT_FALSE(filter->testBytes(nullptr, 0));
+  EXPECT_FALSE(testBytes(*filter, "a"));
+  EXPECT_TRUE(testBytes(*filter, "b"));
+  EXPECT_TRUE(testBytes(*filter, "c"));
+  EXPECT_FALSE(testBytes(*filter, {}));
   EXPECT_TRUE(filter->testBytesRange("a", "b", false));
 
   // > b
   filter = greaterThan("b");
-  EXPECT_FALSE(filter->testBytes("a", 1));
-  EXPECT_FALSE(filter->testBytes("b", 1));
-  EXPECT_TRUE(filter->testBytes("c", 1));
-  EXPECT_FALSE(filter->testBytes(nullptr, 0));
+  EXPECT_FALSE(testBytes(*filter, "a"));
+  EXPECT_FALSE(testBytes(*filter, "b"));
+  EXPECT_TRUE(testBytes(*filter, "c"));
+  EXPECT_FALSE(testBytes(*filter, {}));
   EXPECT_FALSE(filter->testBytesRange("a", "b", false));
 
   // < ''
   filter = lessThan("");
-  EXPECT_FALSE(filter->testBytes(nullptr, 0));
-  EXPECT_FALSE(filter->testBytes("abc", 3));
+  EXPECT_FALSE(testBytes(*filter, {}));
+  EXPECT_FALSE(testBytes(*filter, "abc"));
 
   // <= ''
   filter = lessThanOrEqual("");
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
-  EXPECT_FALSE(filter->testBytes("abc", 3));
+  EXPECT_TRUE(testBytes(*filter, {}));
+  EXPECT_FALSE(testBytes(*filter, "abc"));
 
   // > ''
   filter = greaterThan("");
-  EXPECT_FALSE(filter->testBytes(nullptr, 0));
-  EXPECT_TRUE(filter->testBytes("abc", 3));
+  EXPECT_FALSE(testBytes(*filter, {}));
+  EXPECT_TRUE(testBytes(*filter, "abc"));
 
   // >= ''
   filter = greaterThanOrEqual("");
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
-  EXPECT_TRUE(filter->testBytes("abc", 3));
+  EXPECT_TRUE(testBytes(*filter, {}));
+  EXPECT_TRUE(testBytes(*filter, "abc"));
 }
 
 TEST(FilterTest, negatedBytesRange) {
   auto filter = notBetween("a", "c");
 
-  EXPECT_TRUE(filter->testBytes("A", 1));
-  EXPECT_TRUE(filter->testBytes(nullptr, 0));
-  EXPECT_TRUE(filter->testBytes("ca", 2));
-  EXPECT_TRUE(filter->testBytes("z", 1));
+  EXPECT_TRUE(testBytes(*filter, "A"));
+  EXPECT_TRUE(testBytes(*filter, {}));
+  EXPECT_TRUE(testBytes(*filter, "ca"));
+  EXPECT_TRUE(testBytes(*filter, "z"));
 
-  EXPECT_FALSE(filter->testBytes("a", 1));
-  EXPECT_FALSE(filter->testBytes("apple", 5));
-  EXPECT_FALSE(filter->testBytes("c", 1));
+  EXPECT_FALSE(testBytes(*filter, "a"));
+  EXPECT_FALSE(testBytes(*filter, "apple"));
+  EXPECT_FALSE(testBytes(*filter, "c"));
   EXPECT_FALSE(filter->testNull());
 
   EXPECT_TRUE(filter->testLength(1));
@@ -958,10 +1067,12 @@ TEST(FilterTest, negatedBytesRange) {
   EXPECT_EQ("c", filter->upper());
   EXPECT_FALSE(filter->isLowerUnbounded());
   EXPECT_FALSE(filter->isUpperUnbounded());
+  EXPECT_FALSE(filter->isLowerExclusive());
+  EXPECT_FALSE(filter->isUpperExclusive());
 
   filter = notBetweenExclusive("b", "d");
-  EXPECT_TRUE(filter->testBytes("b", 1));
-  EXPECT_TRUE(filter->testBytes("d", 1));
+  EXPECT_TRUE(testBytes(*filter, "b"));
+  EXPECT_TRUE(testBytes(*filter, "d"));
 
   EXPECT_TRUE(filter->testBytesRange("b", "c", false));
   EXPECT_TRUE(filter->testBytesRange("c", "d", false));
@@ -972,6 +1083,8 @@ TEST(FilterTest, negatedBytesRange) {
   EXPECT_EQ("d", filter->upper());
   EXPECT_FALSE(filter->isLowerUnbounded());
   EXPECT_FALSE(filter->isUpperUnbounded());
+  EXPECT_TRUE(filter->isLowerExclusive());
+  EXPECT_TRUE(filter->isUpperExclusive());
 
   auto filter_with_null = filter->clone(true);
   EXPECT_TRUE(filter_with_null->testBytesRange("bb", "cc", true));
@@ -2023,3 +2136,6 @@ TEST(FilterTest, timestampRange) {
   EXPECT_TRUE(filter->testTimestampRange(
       Timestamp(5, 123000000), Timestamp(30, 123000000), true));
 }
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/FloatingPointUtilTest.cpp b/velox/type/tests/FloatingPointUtilTest.cpp
index c603d18d0e5d..3a59b8078952 100644
--- a/velox/type/tests/FloatingPointUtilTest.cpp
+++ b/velox/type/tests/FloatingPointUtilTest.cpp
@@ -26,9 +26,9 @@ 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();
+  static constexpr T kNaN = std::numeric_limits<T>::quiet_NaN();
+  static constexpr T kSNAN = std::numeric_limits<T>::signaling_NaN();
+  static constexpr T kInf = std::numeric_limits<T>::infinity();
 
   ASSERT_TRUE(NaNAwareEquals<T>{}(kNaN, kNaN));
   ASSERT_TRUE(NaNAwareEquals<T>{}(kNaN, kSNAN));
@@ -64,11 +64,30 @@ void testFloatingPoint() {
   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));
+
+  HashSetNaNAware<T> set;
+  set.insert(kNaN);
+  set.insert(kSNAN);
+  ASSERT_EQ(set.size(), 1);
+  ASSERT_TRUE(NaNAwareEquals<T>{}(*set.begin(), kSNAN));
+  ASSERT_TRUE(NaNAwareEquals<T>{}(*set.begin(), kNaN));
+  ASSERT_NE(*set.begin(), kNaN);
+  ASSERT_NE(*set.begin(), kSNAN);
+
+  typename HashMapNaNAwareTypeTraits<
+      T,
+      int32_t,
+      folly::f14::DefaultAlloc<std::pair<const T, int32_t>>>::Type map;
+  map[kNaN] = 1;
+  map[kSNAN] = 2;
+  ASSERT_EQ(map.size(), 1);
+  ASSERT_EQ(map[kNaN], 2);
+  ASSERT_EQ(map[kSNAN], 2);
 }
+} // namespace
 
 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 7da7b4073a7e..34e2f24cc49c 100644
--- a/velox/type/tests/NegatedBigintRangeBenchmark.cpp
+++ b/velox/type/tests/NegatedBigintRangeBenchmark.cpp
@@ -127,10 +127,12 @@ int32_t main(int32_t argc, char* argv[]) {
 
   negatedRangeNeq = std::make_unique<NegatedBigintRange>(0, 0, false);
   std::vector<std::unique_ptr<BigintRange>> zeroRanges;
-  zeroRanges.emplace_back(std::make_unique<BigintRange>(
-      std::numeric_limits<int64_t>::min(), -1, false));
-  zeroRanges.emplace_back(std::make_unique<BigintRange>(
-      1, std::numeric_limits<int64_t>::max(), false));
+  zeroRanges.emplace_back(
+      std::make_unique<BigintRange>(
+          std::numeric_limits<int64_t>::min(), -1, false));
+  zeroRanges.emplace_back(
+      std::make_unique<BigintRange>(
+          1, std::numeric_limits<int64_t>::max(), false));
   multiRangeNeq =
       std::make_unique<BigintMultiRange>(std::move(zeroRanges), false);
 
@@ -151,13 +153,18 @@ int32_t main(int32_t argc, char* argv[]) {
 
   for (int i = 0; i < rangeBounds.size(); ++i) {
     filterSizeIndices[rangeBounds[i]] = i;
-    negatedRanges.emplace_back(std::make_unique<NegatedBigintRange>(
-        -1 * rangeBounds[i], rangeBounds[i], false));
+    negatedRanges.emplace_back(
+        std::make_unique<NegatedBigintRange>(
+            -1 * rangeBounds[i], rangeBounds[i], false));
     std::vector<std::unique_ptr<BigintRange>> ranges;
-    ranges.emplace_back(std::make_unique<BigintRange>(
-        std::numeric_limits<int64_t>::min(), -1 * (rangeBounds[i] + 1), false));
-    ranges.emplace_back(std::make_unique<BigintRange>(
-        rangeBounds[i] + 1, std::numeric_limits<int64_t>::max(), false));
+    ranges.emplace_back(
+        std::make_unique<BigintRange>(
+            std::numeric_limits<int64_t>::min(),
+            -1 * (rangeBounds[i] + 1),
+            false));
+    ranges.emplace_back(
+        std::make_unique<BigintRange>(
+            rangeBounds[i] + 1, std::numeric_limits<int64_t>::max(), false));
     multiRanges.emplace_back(
         std::make_unique<BigintMultiRange>(std::move(ranges), false));
   }
diff --git a/velox/type/tests/NegatedBytesRangeBenchmark.cpp b/velox/type/tests/NegatedBytesRangeBenchmark.cpp
index 8459e6db74e6..d5053f244c30 100644
--- a/velox/type/tests/NegatedBytesRangeBenchmark.cpp
+++ b/velox/type/tests/NegatedBytesRangeBenchmark.cpp
@@ -160,15 +160,18 @@ int32_t main(int32_t argc, char** argv) {
       std::string hi = string_pool[kStringPoolSize * (50 + pct / 2) / 100];
 
       // create NegatedBytesRange filter
-      negateds.emplace_back(std::make_unique<common::NegatedBytesRange>(
-          lo, false, false, hi, false, true, false));
+      negateds.emplace_back(
+          std::make_unique<common::NegatedBytesRange>(
+              lo, false, false, hi, false, true, false));
 
       // create MultiRange filter
       std::vector<std::unique_ptr<common::Filter>> rangeFilters;
-      rangeFilters.emplace_back(std::make_unique<common::BytesRange>(
-          "", true, false, lo, false, true, false));
-      rangeFilters.emplace_back(std::make_unique<common::BytesRange>(
-          hi, false, false, "", true, false, false));
+      rangeFilters.emplace_back(
+          std::make_unique<common::BytesRange>(
+              "", 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));
 
diff --git a/velox/type/tests/NegatedBytesValuesBenchmark.cpp b/velox/type/tests/NegatedBytesValuesBenchmark.cpp
index 78da7f714dca..5f917f31a665 100644
--- a/velox/type/tests/NegatedBytesValuesBenchmark.cpp
+++ b/velox/type/tests/NegatedBytesValuesBenchmark.cpp
@@ -167,18 +167,22 @@ int32_t main(int32_t argc, char* argv[]) {
       std::vector<std::unique_ptr<common::Filter>> range_filters;
       auto front = ++(reject_vector.begin());
       auto back = reject_vector.begin();
-      range_filters.emplace_back(std::make_unique<common::BytesRange>(
-          "", true, true, *back, false, true, false));
+      range_filters.emplace_back(
+          std::make_unique<common::BytesRange>(
+              "", true, true, *back, false, true, false));
       while (front != reject_vector.end()) {
-        range_filters.emplace_back(std::make_unique<common::BytesRange>(
-            *back, false, true, *front, false, true, false));
+        range_filters.emplace_back(
+            std::make_unique<common::BytesRange>(
+                *back, false, true, *front, false, true, false));
         ++front;
         ++back;
       }
-      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));
+      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));
 
       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 62393b9124b1..8f1e99ed4027 100644
--- a/velox/type/tests/NegatedValuesFilterBenchmark.cpp
+++ b/velox/type/tests/NegatedValuesFilterBenchmark.cpp
@@ -145,14 +145,17 @@ int32_t main(int32_t argc, char* argv[]) {
     subfilters.reserve(kFilterSizes[i]);
     int64_t start = std::numeric_limits<int64_t>::min();
     for (auto j = 0; j < kFilterSizes[i]; ++j) {
-      subfilters.emplace_back(std::make_unique<common::BigintRange>(
-          start, rejectedValues[i][j] - 1, false));
+      subfilters.emplace_back(
+          std::make_unique<common::BigintRange>(
+              start, rejectedValues[i][j] - 1, false));
       start = rejectedValues[i][j] + 1;
     }
-    subfilters.emplace_back(std::make_unique<common::BigintRange>(
-        start, std::numeric_limits<int64_t>::max(), false));
-    multiRangeFilters.emplace_back(std::make_unique<common::BigintMultiRange>(
-        std::move(subfilters), false));
+    subfilters.emplace_back(
+        std::make_unique<common::BigintRange>(
+            start, std::numeric_limits<int64_t>::max(), false));
+    multiRangeFilters.emplace_back(
+        std::make_unique<common::BigintMultiRange>(
+            std::move(subfilters), false));
   }
 
   veryDenseValues.resize(kNumValues);
diff --git a/velox/type/tests/OpaqueCustomTypesTest.cpp b/velox/type/tests/OpaqueCustomTypesTest.cpp
new file mode 100644
index 000000000000..bf5268f4a90b
--- /dev/null
+++ b/velox/type/tests/OpaqueCustomTypesTest.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 <folly/dynamic.h>
+#include <gtest/gtest.h>
+
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/type/OpaqueCustomTypes.h"
+#include "velox/type/Variant.h"
+
+namespace facebook::velox {
+namespace {
+
+class OpaqueCustomTypeTest : public testing::Test {
+ public:
+  OpaqueCustomTypeTest()
+      : testCustomType_(TestCustomTypeRegister::VeloxType::get()) {}
+
+ protected:
+  struct TestCustomType {
+    std::string name;
+
+    bool operator==(const TestCustomType& other) const {
+      return name == other.name;
+    }
+
+    folly::dynamic serialize() const {
+      folly::dynamic obj = folly::dynamic::object();
+      obj["name"] = name;
+      return obj;
+    }
+
+    static std::shared_ptr<TestCustomType> create(const folly::dynamic& obj) {
+      return std::make_shared<TestCustomType>(obj["name"].asString());
+    }
+  };
+
+  static constexpr char testCustomTypeName[] = "my_test_custom_type";
+  using TestCustomTypeRegister =
+      OpaqueCustomTypeRegister<TestCustomType, testCustomTypeName>;
+
+  TestCustomTypeRegister::VeloxTypePtr testCustomType_;
+
+  void testUnregisterType() {
+    TestCustomTypeRegister::unregisterType();
+    ASSERT_EQ(getCustomType(testCustomTypeName, {}), nullptr);
+    VELOX_ASSERT_THROW(
+        testCustomType_->getSerializeFunc(),
+        "No serialization function registered for my_test_custom_type");
+    VELOX_ASSERT_THROW(
+        testCustomType_->getDeserializeFunc(),
+        "No deserialization function registered for my_test_custom_type");
+  }
+
+  void testTypeSerde() {
+    auto serializedCustomType = testCustomType_->serialize();
+    EXPECT_EQ(testCustomType_->name(), serializedCustomType["type"]);
+    auto deserializedType = Type::create(serializedCustomType);
+    EXPECT_EQ(testCustomType_, deserializedType);
+  }
+};
+
+TEST_F(OpaqueCustomTypeTest, registerWithoutSerde) {
+  // Register type without serialization/deserialization and build a TypePtr.
+  TestCustomTypeRegister::registerType();
+  testTypeSerde();
+  testUnregisterType();
+}
+
+TEST_F(OpaqueCustomTypeTest, registerWithSerde) {
+  // Register type with serialization/deserialization and build a TypePtr.
+  TestCustomTypeRegister::registerType(
+      /*serializeValueFunc=*/
+      [](const auto& obj) { return folly::toJson(obj->serialize()); },
+      /*deserializeValueFunc=*/
+      [](const auto& str) {
+        return TestCustomType::create(folly::parseJson(str));
+      });
+
+  // Test value serialization/deserialization, with serde functions provided in
+  // TestCustomTypeRegister::registerType() method.
+  auto original = std::make_shared<TestCustomType>("test");
+  auto opaque = Variant::create(Variant::opaque(original).serialize())
+                    .value<TypeKind::OPAQUE>()
+                    .obj;
+  auto copy = std::static_pointer_cast<TestCustomType>(opaque);
+  EXPECT_EQ(*original, *copy);
+
+  testTypeSerde();
+  testUnregisterType();
+}
+
+TEST_F(OpaqueCustomTypeTest, registerWithIncompleteSerde) {
+  VELOX_ASSERT_THROW(
+      TestCustomTypeRegister::registerType(
+          /*serializeValueFunc=*/nullptr,
+          /*deserializeValueFunc=*/
+          [](const auto& str) {
+            return TestCustomType::create(folly::parseJson(str));
+          }),
+      "Both serialization and deserialization functions need to be registered for custom type my_test_custom_type");
+
+  VELOX_ASSERT_THROW(
+      TestCustomTypeRegister::registerType(
+          /*serializeValueFunc=*/
+          [](const auto& obj) { return folly::toJson(obj->serialize()); },
+          /*deserializeValueFunc=*/nullptr),
+      "Both serialization and deserialization functions need to be registered for custom type my_test_custom_type");
+
+  testUnregisterType();
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/StringViewTest.cpp b/velox/type/tests/StringViewTest.cpp
index ff22f35c84a2..619207b5b3cc 100644
--- a/velox/type/tests/StringViewTest.cpp
+++ b/velox/type/tests/StringViewTest.cpp
@@ -13,15 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <sstream>
+
 #include "velox/common/base/SimdUtil.h"
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/RawVector.h"
 #include "velox/common/time/Timer.h"
 #include "velox/type/Type.h"
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
 
 TEST(StringView, basic) {
   std::string text = "We are stardust, we are golden...";
@@ -181,6 +185,27 @@ int32_t linearSearchSimple(
   return -1;
 }
 
+TEST(StringView, makeInline) {
+  const std::string_view shortString = "hola";
+
+  // Test makeInline using std::string and std::string_view.
+  auto sv1 = StringView::makeInline(shortString);
+  EXPECT_TRUE(sv1.isInline());
+  EXPECT_EQ(sv1, StringView{shortString});
+
+  auto sv2 = StringView::makeInline(std::string(shortString));
+  EXPECT_TRUE(sv2.isInline());
+  EXPECT_EQ(sv2, StringView{shortString});
+
+// Only checks and throws in debug mode.
+#ifndef NDEBUG
+  VELOX_ASSERT_THROW(
+      StringView::makeInline(
+          std::string_view("slightly longer non-inlinable string")),
+      "StringView::makeInline() requires an input string that fits inline");
+#endif
+}
+
 TEST(StringView, linearSearch) {
   constexpr int32_t kSize = 1003;
   std::vector<raw_vector<char>> data(kSize);
@@ -285,3 +310,6 @@ TEST(StringView, linearSearch) {
             << simdIndicesUsec << " scalar: " << loopUsec << " / "
             << loopIndicesUsec;
 }
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/SubfieldTest.cpp b/velox/type/tests/SubfieldTest.cpp
index 7edeab16aeb8..a2004ba0faee 100644
--- a/velox/type/tests/SubfieldTest.cpp
+++ b/velox/type/tests/SubfieldTest.cpp
@@ -21,9 +21,9 @@ using namespace facebook::velox::common;
 
 std::vector<std::unique_ptr<Subfield::PathElement>> tokenize(
     const std::string& path,
-    const std::shared_ptr<Separators>& separators = Separators::get()) {
+    std::shared_ptr<const Separators> separators = Separators::get()) {
   std::vector<std::unique_ptr<Subfield::PathElement>> elements;
-  Tokenizer tokenizer(path, separators);
+  Tokenizer tokenizer(path, std::move(separators));
   while (tokenizer.hasNext()) {
     elements.push_back(tokenizer.next());
   }
@@ -50,8 +50,8 @@ TEST(SubfieldTest, invalidPaths) {
 
 void testColumnName(
     const std::string& name,
-    const std::shared_ptr<Separators>& separators = Separators::get()) {
-  auto elements = tokenize(name, separators);
+    std::shared_ptr<const Separators> separators = Separators::get()) {
+  auto elements = tokenize(name, std::move(separators));
   EXPECT_EQ(elements.size(), 1);
   EXPECT_EQ(*elements[0].get(), Subfield::NestedField(name));
 }
diff --git a/velox/type/tests/TimestampTest.cpp b/velox/type/tests/TimestampTest.cpp
index 44f1ffc9e427..9e3ee43e9ed7 100644
--- a/velox/type/tests/TimestampTest.cpp
+++ b/velox/type/tests/TimestampTest.cpp
@@ -279,8 +279,9 @@ std::string toStringAlt(
 }
 
 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));
+  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;
@@ -479,12 +480,13 @@ void testTmToString(
     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));
+      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);
diff --git a/velox/type/tests/TypeCoercerTest.cpp b/velox/type/tests/TypeCoercerTest.cpp
new file mode 100644
index 000000000000..b6147f5b3beb
--- /dev/null
+++ b/velox/type/tests/TypeCoercerTest.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/type/TypeCoercer.h"
+#include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
+
+namespace facebook::velox {
+namespace {
+
+void testCoercion(const TypePtr& fromType, const TypePtr& toType) {
+  auto coercion = TypeCoercer::coerceTypeBase(fromType, toType->name());
+  ASSERT_TRUE(coercion.has_value());
+  VELOX_EXPECT_EQ_TYPES(coercion->type, toType);
+}
+
+void testBaseCoercion(const TypePtr& fromType) {
+  auto coercion = TypeCoercer::coerceTypeBase(fromType, fromType->kindName());
+  ASSERT_TRUE(coercion.has_value());
+  VELOX_EXPECT_EQ_TYPES(coercion->type, fromType);
+}
+
+void testNoCoercion(const TypePtr& fromType, const TypePtr& toType) {
+  auto coercion = TypeCoercer::coerceTypeBase(fromType, toType->name());
+  ASSERT_FALSE(coercion.has_value());
+}
+
+TEST(TypeCoercerTest, basic) {
+  testCoercion(TINYINT(), TINYINT());
+  testCoercion(TINYINT(), BIGINT());
+  testCoercion(TINYINT(), REAL());
+
+  testNoCoercion(TINYINT(), VARCHAR());
+  testNoCoercion(TINYINT(), DATE());
+
+  testBaseCoercion(ARRAY(TINYINT()));
+  testNoCoercion(ARRAY(TINYINT()), MAP(INTEGER(), REAL()));
+}
+
+TEST(TypeCoercerTest, unknown) {
+  ASSERT_TRUE(TypeCoercer::coercible(UNKNOWN(), BOOLEAN()));
+  ASSERT_TRUE(TypeCoercer::coercible(UNKNOWN(), BIGINT()));
+  ASSERT_TRUE(TypeCoercer::coercible(UNKNOWN(), VARCHAR()));
+  ASSERT_TRUE(TypeCoercer::coercible(UNKNOWN(), ARRAY(INTEGER())));
+}
+
+TEST(TypeCoercerTest, array) {
+  ASSERT_TRUE(TypeCoercer::coercible(ARRAY(UNKNOWN()), ARRAY(INTEGER())));
+  ASSERT_TRUE(
+      TypeCoercer::coercible(ARRAY(UNKNOWN()), ARRAY(ARRAY(VARCHAR()))));
+
+  ASSERT_FALSE(TypeCoercer::coercible(ARRAY(BIGINT()), ARRAY(REAL())));
+  ASSERT_FALSE(
+      TypeCoercer::coercible(ARRAY(UNKNOWN()), MAP(INTEGER(), REAL())));
+  ASSERT_FALSE(TypeCoercer::coercible(ARRAY(UNKNOWN()), ROW({UNKNOWN()})));
+  ASSERT_FALSE(TypeCoercer::coercible(ARRAY(VARCHAR()), VARCHAR()));
+}
+
+TEST(TypeCoercerTest, map) {
+  ASSERT_TRUE(
+      TypeCoercer::coercible(
+          MAP(UNKNOWN(), UNKNOWN()), MAP(INTEGER(), REAL())));
+  ASSERT_TRUE(
+      TypeCoercer::coercible(MAP(VARCHAR(), REAL()), MAP(VARCHAR(), DOUBLE())));
+  ASSERT_TRUE(
+      TypeCoercer::coercible(MAP(INTEGER(), REAL()), MAP(BIGINT(), DOUBLE())));
+
+  ASSERT_FALSE(
+      TypeCoercer::coercible(MAP(INTEGER(), REAL()), MAP(BIGINT(), INTEGER())));
+  ASSERT_FALSE(
+      TypeCoercer::coercible(MAP(UNKNOWN(), UNKNOWN()), ARRAY(BIGINT())));
+  ASSERT_FALSE(
+      TypeCoercer::coercible(
+          MAP(UNKNOWN(), UNKNOWN()), ROW({INTEGER(), BIGINT()})));
+}
+
+TEST(TypeCoercerTest, row) {
+  ASSERT_TRUE(
+      TypeCoercer::coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}),
+          ROW({SMALLINT(), BIGINT(), DOUBLE()})));
+
+  ASSERT_FALSE(
+      TypeCoercer::coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}),
+          ROW({SMALLINT(), VARCHAR(), DOUBLE()})));
+
+  ASSERT_FALSE(
+      TypeCoercer::coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}), ARRAY(INTEGER())));
+  ASSERT_FALSE(
+      TypeCoercer::coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}), MAP(INTEGER(), REAL())));
+  ASSERT_FALSE(
+      TypeCoercer::coercible(
+          ROW({UNKNOWN(), INTEGER(), REAL()}), ROW({UNKNOWN(), INTEGER()})));
+  ASSERT_FALSE(
+      TypeCoercer::coercible(ROW({UNKNOWN(), INTEGER(), REAL()}), BIGINT()));
+}
+
+TEST(TypeCoercerTest, leastCommonSuperType) {
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::leastCommonSuperType(INTEGER(), BIGINT()), BIGINT());
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::leastCommonSuperType(ARRAY(INTEGER()), ARRAY(TINYINT())),
+      ARRAY(INTEGER()));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::leastCommonSuperType(
+          MAP(TINYINT(), DOUBLE()), MAP(INTEGER(), REAL())),
+      MAP(INTEGER(), DOUBLE()));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::leastCommonSuperType(
+          ROW({TINYINT(), DOUBLE()}), ROW({INTEGER(), REAL()})),
+      ROW({INTEGER(), DOUBLE()}));
+
+  VELOX_ASSERT_EQ_TYPES(
+      TypeCoercer::leastCommonSuperType(
+          ROW({"", "", ""}, INTEGER()), ROW({"", "", ""}, SMALLINT())),
+      ROW({"", "", ""}, INTEGER()));
+
+  ASSERT_TRUE(
+      TypeCoercer::leastCommonSuperType(VARCHAR(), TINYINT()) == nullptr);
+
+  ASSERT_TRUE(
+      TypeCoercer::leastCommonSuperType(ARRAY(TINYINT()), TINYINT()) ==
+      nullptr);
+
+  ASSERT_TRUE(
+      TypeCoercer::leastCommonSuperType(ARRAY(TINYINT()), ARRAY(VARCHAR())) ==
+      nullptr);
+
+  ASSERT_TRUE(
+      TypeCoercer::leastCommonSuperType(
+          ROW({""}, TINYINT()), ROW({"", ""}, TINYINT())) == nullptr);
+
+  ASSERT_TRUE(
+      TypeCoercer::leastCommonSuperType(
+          MAP(INTEGER(), REAL()), ROW({INTEGER(), REAL()})) == nullptr);
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/type/tests/TypeTest.cpp b/velox/type/tests/TypeTest.cpp
index f315c1490458..46d93cf01506 100644
--- a/velox/type/tests/TypeTest.cpp
+++ b/velox/type/tests/TypeTest.cpp
@@ -488,6 +488,21 @@ TEST(TypeTest, row) {
   testTypeSerde(rowInner);
 }
 
+TEST(TypeTest, wideRow) {
+  std::vector<std::string> names;
+  names.reserve(1'000);
+  for (auto i = 0; i < 1'000; ++i) {
+    names.push_back(fmt::format("c{}", i));
+  }
+
+  auto rowType = ROW(std::move(names), BIGINT());
+
+  ASSERT_EQ(rowType->findChild("c17")->toString(), "BIGINT");
+  VELOX_ASSERT_THROW(
+      rowType->findChild("blah"),
+      "Field not found: blah. Available fields are: c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20, c21, c22, c23, c24, c25, c26, c27, c28, c29, c30, c31, c32, c33, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46, c47, c48, c49, ...950 more");
+}
+
 TEST(TypeTest, serdeCache) {
   std::vector<std::string> names;
   names.reserve(100);
@@ -532,6 +547,26 @@ TEST(TypeTest, emptyRow) {
   testTypeSerde(row);
 }
 
+TEST(TypeTest, singleFieldRow) {
+  auto rowType = ROW("a", REAL());
+  testTypeSerde(rowType);
+
+  auto equivalentRowType = ROW({{"a", REAL()}});
+  ASSERT_EQ(*rowType, *equivalentRowType);
+  testTypeSerde(equivalentRowType);
+
+  equivalentRowType = ROW({"a"}, {REAL()});
+  ASSERT_EQ(*rowType, *equivalentRowType);
+  testTypeSerde(equivalentRowType);
+}
+
+TEST(TypeTest, homogenousRow) {
+  auto rowType = ROW({"a", "b", "c"}, REAL());
+  auto equivalentRowType = ROW({"a", "b", "c"}, {REAL(), REAL(), REAL()});
+  ASSERT_EQ(*rowType, *equivalentRowType);
+  testTypeSerde(rowType);
+}
+
 TEST(TypeTest, rowParametersMultiThreaded) {
   std::vector<std::string> names;
   std::vector<TypePtr> types;
@@ -542,20 +577,21 @@ TEST(TypeTest, rowParametersMultiThreaded) {
   }
   auto type = ROW(std::move(names), std::move(types));
   constexpr int kNumThreads = 72;
-  const std::vector<TypeParameter>* parameters[kNumThreads];
+  std::span<const TypeParameter> parameters[kNumThreads];
   std::vector<std::thread> threads;
   for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([&, i] { parameters[i] = &type->parameters(); });
+    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_TRUE(parameters[i].data() == parameters[0].data());
+    ASSERT_TRUE(parameters[i].size() == parameters[0].size());
   }
-  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());
+  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());
   }
 }
 
@@ -625,12 +661,24 @@ TEST(TypeTest, opaque) {
   auto foo3 = Type::create(foo->serialize());
   ASSERT_EQ(*foo, *foo3);
 
+  // Clearing the serialization registry when no serialization/deserialization
+  // functions have been provided, should return true, since the registry
+  // contained nullptr as serialization/deserialization functions.
+  EXPECT_TRUE(OpaqueType::unregisterSerialization(foo2, "id_of_foo"));
+  // Clearing the serialization registry a second time should return false.
+  EXPECT_FALSE(OpaqueType::unregisterSerialization(foo2, "id_of_foo"));
+
   OpaqueType::registerSerialization<Bar>(
       "id_of_bar",
       [](const std::shared_ptr<Bar>&) -> std::string { return ""; },
       [](const std::string&) -> std::shared_ptr<Bar> { return nullptr; });
   bar->getSerializeFunc();
   bar->getDeserializeFunc();
+
+  // Clearing the serialization registry should return true.
+  EXPECT_TRUE(
+      OpaqueType::unregisterSerialization(
+          OpaqueType::create<Bar>(), "id_of_bar"));
 }
 
 // Example of an opaque type that keeps some additional type-level metadata.
@@ -674,7 +722,7 @@ TEST(TypeTest, opaqueWithMetadata) {
   auto type = std::make_shared<OpaqueWithMetadataType>(123);
   auto type2 = std::make_shared<OpaqueWithMetadataType>(123);
   auto other = std::make_shared<OpaqueWithMetadataType>(234);
-  EXPECT_TRUE(def->operator!=(*type));
+  EXPECT_TRUE(*def != *type);
   EXPECT_EQ(*type, *type2);
   EXPECT_NE(*type, *other);
 
@@ -771,7 +819,6 @@ TEST(TypeTest, cpp2Type) {
   EXPECT_EQ(*CppToType<int8_t>::create(), *TINYINT());
   EXPECT_EQ(*CppToType<velox::StringView>::create(), *VARCHAR());
   EXPECT_EQ(*CppToType<std::string>::create(), *VARCHAR());
-  EXPECT_EQ(*CppToType<folly::ByteRange>::create(), *VARBINARY());
   EXPECT_EQ(*CppToType<float>::create(), *REAL());
   EXPECT_EQ(*CppToType<double>::create(), *DOUBLE());
   EXPECT_EQ(*CppToType<bool>::create(), *BOOLEAN());
@@ -1121,18 +1168,15 @@ TEST(TypeTest, providesCustomComparison) {
 
   // 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_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);
 }
 
 TEST(TypeTest, toSummaryString) {
@@ -1171,3 +1215,26 @@ TEST(TypeTest, toSummaryString) {
       "ROW(BOOLEAN, INTEGER, VARCHAR, ARRAY, MAP, ROW)",
       rowType->toSummaryString({.maxChildren = 10}));
 }
+
+TEST(TypeTest, time) {
+  const auto timeType = TIME();
+  ASSERT_EQ(timeType->toString(), "TIME");
+  ASSERT_EQ(timeType->size(), 0);
+  VELOX_ASSERT_THROW(timeType->childAt(0), "scalar type has no children");
+  ASSERT_EQ(timeType->kind(), TypeKind::BIGINT); // Physical type
+  EXPECT_STREQ(timeType->kindName(), "BIGINT"); // Physical kind name
+  ASSERT_EQ(timeType->begin(), timeType->end());
+  ASSERT_EQ(approximateTypeEncodingwidth(timeType), 1);
+
+  // Test logical vs physical type behavior (similar to DATE test)
+  ASSERT_TRUE(timeType->kindEquals(BIGINT())); // Same physical kind
+  ASSERT_NE(*timeType, *BIGINT()); // Different logical types
+  ASSERT_FALSE(timeType->equivalent(*BIGINT())); // Not equivalent
+  ASSERT_FALSE(BIGINT()->equivalent(*timeType)); // Not equivalent reverse
+
+  // Test orderability and comparability
+  ASSERT_TRUE(timeType->isOrderable());
+  ASSERT_TRUE(timeType->isComparable());
+
+  testTypeSerde(timeType);
+}
diff --git a/velox/type/tests/TypeUtilTest.cpp b/velox/type/tests/TypeUtilTest.cpp
index 321d702fade9..2476dc7f4cb0 100644
--- a/velox/type/tests/TypeUtilTest.cpp
+++ b/velox/type/tests/TypeUtilTest.cpp
@@ -21,19 +21,30 @@
 namespace facebook::velox::type {
 namespace {
 
-TEST(TypeUtilTest, ConcatRowTypes) {
-  auto keyType = velox::ROW({"k0", "k1"}, {velox::BIGINT(), velox::INTEGER()});
-  auto valueType = velox::ROW(
-      {"v0", "v1"}, {velox::VARBINARY(), velox::ARRAY(velox::BIGINT())});
+TEST(TypeUtilTest, concatRowTypes) {
+  auto keyType = ROW({"k0", "k1"}, {BIGINT(), INTEGER()});
+  auto valueType = ROW({"v0", "v1"}, {VARBINARY(), ARRAY(BIGINT())});
   auto type = concatRowTypes({keyType, valueType});
-  auto expected = velox::ROW(
-      {"k0", "k1", "v0", "v1"},
-      {velox::BIGINT(),
-       velox::INTEGER(),
-       velox::VARBINARY(),
-       velox::ARRAY(velox::BIGINT())});
+  auto expected =
+      ROW({"k0", "k1", "v0", "v1"},
+          {BIGINT(), INTEGER(), VARBINARY(), ARRAY(BIGINT())});
   EXPECT_EQ(type->toString(), expected->toString());
 }
 
+TEST(TypeUtilTest, tryGetHomogeneousRowChild) {
+  {
+    auto child = tryGetHomogeneousRowChild(ROW({"c1", "c2", "c3"}, BIGINT()));
+    ASSERT_NE(child, nullptr);
+    ASSERT_EQ(*child, *BIGINT());
+  }
+
+  ASSERT_EQ(tryGetHomogeneousRowChild(INTEGER()), nullptr);
+  ASSERT_EQ(tryGetHomogeneousRowChild(ROW({})), nullptr);
+  ASSERT_EQ(tryGetHomogeneousRowChild(ROW({BIGINT(), VARCHAR()})), nullptr);
+  ASSERT_EQ(
+      tryGetHomogeneousRowChild(ROW({"c1", "c2"}, {BIGINT(), VARCHAR()})),
+      nullptr);
+}
+
 } // namespace
 } // namespace facebook::velox::type
diff --git a/velox/type/tests/VariantTest.cpp b/velox/type/tests/VariantTest.cpp
index d1416d0cf0f3..9ec19a31c413 100644
--- a/velox/type/tests/VariantTest.cpp
+++ b/velox/type/tests/VariantTest.cpp
@@ -20,129 +20,693 @@
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/type/tests/utils/CustomTypesForTesting.h"
 
-using namespace facebook::velox;
-
+namespace facebook::velox::test {
 namespace {
-void testSerDe(const variant& value) {
-  auto serialized = value.serialize();
-  auto copy = variant::create(serialized);
 
-  ASSERT_EQ(value, copy);
+// Comprehensive tests for Variant::create() method.
+
+template <TypeKind KIND, typename T>
+void testCreate(T value) {
+  T maxVal = std::numeric_limits<T>::max();
+  T minVal = std::numeric_limits<T>::lowest(); // since we also test floats.
+
+  auto maxVariant = Variant::template create<KIND>(maxVal);
+  EXPECT_FALSE(maxVariant.isNull());
+  EXPECT_EQ(maxVariant.kind(), KIND);
+  EXPECT_EQ(maxVariant.template value<KIND>(), maxVal);
+
+  auto minVariant = Variant::template create<KIND>(minVal);
+  EXPECT_EQ(minVariant.template value<KIND>(), minVal);
+  EXPECT_EQ(minVariant.template value<KIND>(), minVal);
+
+  auto testVariant = Variant::template create<KIND>(value);
+  EXPECT_EQ(testVariant.template value<KIND>(), value);
+};
+
+TEST(VariantCreateTest, primitiveTypes) {
+  // Different integer precisions.
+  testCreate<TypeKind::TINYINT>((int8_t)-5);
+  testCreate<TypeKind::SMALLINT>((int16_t)12345);
+  testCreate<TypeKind::INTEGER>((int32_t)123456789);
+  testCreate<TypeKind::BIGINT>((int64_t)9876543210LL);
+  testCreate<TypeKind::HUGEINT>((int128_t)1234567890123456789LL);
+  testCreate<TypeKind::HUGEINT>((int128_t)0);
+
+  // Boolean.
+  testCreate<TypeKind::BOOLEAN>(true);
+  testCreate<TypeKind::BOOLEAN>(false);
+
+  // Float/double values.
+  testCreate<TypeKind::REAL>((float)0.0);
+  testCreate<TypeKind::REAL>((float)3.14159f);
+  testCreate<TypeKind::REAL>((float)-123.456f);
+
+  testCreate<TypeKind::DOUBLE>((double)0.0);
+  testCreate<TypeKind::DOUBLE>((double)3.141592653589793);
+  testCreate<TypeKind::DOUBLE>((double)-987654.321);
+
+  // Test special float values.
+  auto infVariant =
+      Variant::create<TypeKind::REAL>(std::numeric_limits<float>::infinity());
+  EXPECT_TRUE(std::isinf(infVariant.value<TypeKind::REAL>()));
+
+  auto nanVariant =
+      Variant::create<TypeKind::REAL>(std::numeric_limits<float>::quiet_NaN());
+  EXPECT_TRUE(std::isnan(nanVariant.value<TypeKind::REAL>()));
+
+  infVariant = Variant::create<TypeKind::DOUBLE>(
+      std::numeric_limits<double>::infinity());
+  EXPECT_TRUE(std::isinf(infVariant.value<TypeKind::DOUBLE>()));
+
+  nanVariant = Variant::create<TypeKind::DOUBLE>(
+      std::numeric_limits<double>::quiet_NaN());
+  EXPECT_TRUE(std::isnan(nanVariant.value<TypeKind::DOUBLE>()));
+
+  // Timestamps.
+  testCreate<TypeKind::TIMESTAMP>(Timestamp(0, 0));
+  testCreate<TypeKind::TIMESTAMP>(Timestamp(1234567890, 123456789));
+  testCreate<TypeKind::TIMESTAMP>(Timestamp(999999, 888888));
+}
+
+TEST(VariantCreateTest, varcharType) {
+  // Test VARCHAR type.
+  std::string emptyStr = "";
+  std::string simpleStr = "Hello, Velox!";
+  std::string longStr(10000, 'a');
+  std::string specialChars = "Special chars: \n\t\r !@#$%^&*()";
+  std::string unicodeStr = "Unicode: 你好世界 🌍";
+
+  auto emptyVariant = Variant::create<TypeKind::VARCHAR>(emptyStr);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(emptyVariant.value<TypeKind::VARCHAR>(), emptyStr);
+
+  auto simpleVariant = Variant::create<TypeKind::VARCHAR>(simpleStr);
+  EXPECT_EQ(simpleVariant.value<TypeKind::VARCHAR>(), simpleStr);
+
+  auto longVariant = Variant::create<TypeKind::VARCHAR>(longStr);
+  EXPECT_EQ(longVariant.value<TypeKind::VARCHAR>(), longStr);
+
+  auto specialVariant = Variant::create<TypeKind::VARCHAR>(specialChars);
+  EXPECT_EQ(specialVariant.value<TypeKind::VARCHAR>(), specialChars);
+
+  auto unicodeVariant = Variant::create<TypeKind::VARCHAR>(unicodeStr);
+  EXPECT_EQ(unicodeVariant.value<TypeKind::VARCHAR>(), unicodeStr);
+
+  // Other string types.
+  auto stdStringViewVariant =
+      Variant::create<TypeKind::VARCHAR>(std::string_view(longStr));
+  EXPECT_EQ(stdStringViewVariant.value<TypeKind::VARCHAR>(), longStr);
+
+  auto stringViewVariant =
+      Variant::create<TypeKind::VARCHAR>(StringView(longStr));
+  EXPECT_EQ(stringViewVariant.value<TypeKind::VARCHAR>(), longStr);
+
+  // Test move semantics
+  std::string moveStr = "Move me!";
+  auto moveVariant = Variant::create<TypeKind::VARCHAR>(std::move(moveStr));
+  EXPECT_EQ(moveVariant.value<TypeKind::VARCHAR>(), "Move me!");
+}
+
+TEST(VariantCreateTest, varbinaryType) {
+  // Test VARBINARY type.
+  std::string emptyBinary = "";
+  std::string simpleBinary = "Binary data \0 with nulls \x00\x01\x02";
+  std::string largeBinary(5000, '\xFF');
+
+  auto emptyVariant = Variant::create<TypeKind::VARBINARY>(emptyBinary);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::VARBINARY);
+  EXPECT_EQ(emptyVariant.value<TypeKind::VARBINARY>(), emptyBinary);
+
+  auto simpleVariant = Variant::create<TypeKind::VARBINARY>(simpleBinary);
+  EXPECT_EQ(simpleVariant.value<TypeKind::VARBINARY>(), simpleBinary);
+
+  auto largeVariant = Variant::create<TypeKind::VARBINARY>(largeBinary);
+  EXPECT_EQ(largeVariant.value<TypeKind::VARBINARY>(), largeBinary);
+
+  // Other string types.
+  auto stdStringViewVariant =
+      Variant::create<TypeKind::VARBINARY>(std::string_view(simpleBinary));
+  EXPECT_EQ(stdStringViewVariant.value<TypeKind::VARBINARY>(), simpleBinary);
+
+  auto stringViewVariant =
+      Variant::create<TypeKind::VARBINARY>(StringView(simpleBinary));
+  EXPECT_EQ(stringViewVariant.value<TypeKind::VARBINARY>(), simpleBinary);
+
+  // Test move semantics.
+  std::string moveBinary = "Move binary!";
+  auto moveVariant =
+      Variant::create<TypeKind::VARBINARY>(std::move(moveBinary));
+  EXPECT_EQ(moveVariant.value<TypeKind::VARBINARY>(), "Move binary!");
+}
+
+TEST(VariantCreateTest, arrayType) {
+  // Empty array.
+  std::vector<Variant> emptyArray;
+  auto emptyVariant = Variant::create<TypeKind::ARRAY>(emptyArray);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::ARRAY);
+  EXPECT_TRUE(emptyVariant.value<TypeKind::ARRAY>().empty());
+
+  // Array of integers.
+  std::vector<Variant> intArray = {
+      Variant(1), Variant(2), Variant(3), Variant(4)};
+  auto intVariant = Variant::create<TypeKind::ARRAY>(intArray);
+  const auto& resultIntArray = intVariant.value<TypeKind::ARRAY>();
+  EXPECT_EQ(resultIntArray.size(), 4);
+  EXPECT_EQ(resultIntArray[0].value<TypeKind::INTEGER>(), 1);
+  EXPECT_EQ(resultIntArray[3].value<TypeKind::INTEGER>(), 4);
+
+  // Array of strings.
+  std::vector<Variant> strArray = {
+      Variant("apple"), Variant("banana"), Variant("cherry")};
+  auto strVariant = Variant::create<TypeKind::ARRAY>(strArray);
+  const auto& resultStrArray = strVariant.value<TypeKind::ARRAY>();
+  EXPECT_EQ(resultStrArray.size(), 3);
+  EXPECT_EQ(resultStrArray[0].value<TypeKind::VARCHAR>(), "apple");
+
+  // Array with null elements.
+  std::vector<Variant> nullArray = {
+      Variant(1), Variant::null(TypeKind::INTEGER), Variant(3)};
+  auto nullVariant = Variant::create<TypeKind::ARRAY>(nullArray);
+  const auto& resultNullArray = nullVariant.value<TypeKind::ARRAY>();
+  EXPECT_EQ(resultNullArray.size(), 3);
+  EXPECT_FALSE(resultNullArray[0].isNull());
+  EXPECT_TRUE(resultNullArray[1].isNull());
+  EXPECT_FALSE(resultNullArray[2].isNull());
+
+  // Nested arrays.
+  std::vector<Variant> nestedArray = {
+      Variant::array({Variant(1), Variant(2)}),
+      Variant::array({Variant(3), Variant(4), Variant(5)})};
+  auto nestedVariant = Variant::create<TypeKind::ARRAY>(nestedArray);
+  const auto& resultNestedArray = nestedVariant.value<TypeKind::ARRAY>();
+  EXPECT_EQ(resultNestedArray.size(), 2);
+  EXPECT_EQ(resultNestedArray[0].value<TypeKind::ARRAY>().size(), 2);
+  EXPECT_EQ(resultNestedArray[1].value<TypeKind::ARRAY>().size(), 3);
+
+  // Test move semantics.
+  std::vector<Variant> moveArray = {Variant(100), Variant(200)};
+  auto moveVariant = Variant::create<TypeKind::ARRAY>(std::move(moveArray));
+  EXPECT_EQ(moveVariant.value<TypeKind::ARRAY>().size(), 2);
+}
+
+TEST(VariantCreateTest, mapType) {
+  // Empty map.
+  std::map<Variant, Variant> emptyMap;
+  auto emptyVariant = Variant::create<TypeKind::MAP>(emptyMap);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::MAP);
+  EXPECT_TRUE(emptyVariant.value<TypeKind::MAP>().empty());
+
+  // Simple map.
+  std::map<Variant, Variant> simpleMap = {
+      {Variant(1), Variant("one")},
+      {Variant(2), Variant("two")},
+      {Variant(3), Variant("three")}};
+  auto simpleVariant = Variant::create<TypeKind::MAP>(simpleMap);
+  const auto& resultMap = simpleVariant.value<TypeKind::MAP>();
+  EXPECT_EQ(resultMap.size(), 3);
+  EXPECT_EQ(
+      resultMap.at(Variant(1)).value<TypeKind::VARCHAR>(), std::string("one"));
+  EXPECT_EQ(
+      resultMap.at(Variant(2)).value<TypeKind::VARCHAR>(), std::string("two"));
+
+  // Map with various key types.
+  std::map<Variant, Variant> stringKeyMap = {
+      {Variant("key1"), Variant(100)}, {Variant("key2"), Variant(200)}};
+  auto stringKeyVariant = Variant::create<TypeKind::MAP>(stringKeyMap);
+  const auto& resultStringKeyMap = stringKeyVariant.value<TypeKind::MAP>();
+  EXPECT_EQ(resultStringKeyMap.size(), 2);
+
+  // Map with null values.
+  std::map<Variant, Variant> nullValueMap = {
+      {Variant(1), Variant(10)},
+      {Variant(2), Variant::null(TypeKind::INTEGER)},
+      {Variant(3), Variant(30)}};
+  auto nullValueVariant = Variant::create<TypeKind::MAP>(nullValueMap);
+  const auto& resultNullValueMap = nullValueVariant.value<TypeKind::MAP>();
+  EXPECT_EQ(resultNullValueMap.size(), 3);
+  EXPECT_FALSE(resultNullValueMap.at(Variant(1)).isNull());
+  EXPECT_TRUE(resultNullValueMap.at(Variant(2)).isNull());
+
+  // Nested map.
+  std::map<Variant, Variant> nestedMap = {
+      {Variant(1), Variant::map({{Variant("a"), Variant(1)}})},
+      {Variant(2), Variant::map({{Variant("b"), Variant(2)}})}};
+  auto nestedVariant = Variant::create<TypeKind::MAP>(nestedMap);
+  const auto& resultNestedMap = nestedVariant.value<TypeKind::MAP>();
+  EXPECT_EQ(resultNestedMap.size(), 2);
+
+  // Test move semantics.
+  std::map<Variant, Variant> moveMap = {{Variant(99), Variant("ninety-nine")}};
+  auto moveVariant = Variant::create<TypeKind::MAP>(std::move(moveMap));
+  EXPECT_EQ(moveVariant.value<TypeKind::MAP>().size(), 1);
+}
+
+TEST(VariantCreateTest, rowType) {
+  // Empty row.
+  std::vector<Variant> emptyRow;
+  auto emptyVariant = Variant::create<TypeKind::ROW>(emptyRow);
+  EXPECT_FALSE(emptyVariant.isNull());
+  EXPECT_EQ(emptyVariant.kind(), TypeKind::ROW);
+  EXPECT_TRUE(emptyVariant.value<TypeKind::ROW>().empty());
+
+  // Simple row.
+  std::vector<Variant> simpleRow = {Variant(1), Variant("test"), Variant(3.14)};
+  auto simpleVariant = Variant::create<TypeKind::ROW>(simpleRow);
+  const auto& resultRow = simpleVariant.value<TypeKind::ROW>();
+  EXPECT_EQ(resultRow.size(), 3);
+  EXPECT_EQ(resultRow[0].value<TypeKind::INTEGER>(), 1);
+  EXPECT_EQ(resultRow[1].value<TypeKind::VARCHAR>(), "test");
+  EXPECT_DOUBLE_EQ(resultRow[2].value<TypeKind::DOUBLE>(), 3.14);
+
+  // Row with null fields
+  std::vector<Variant> nullRow = {
+      Variant(100),
+      Variant::null(TypeKind::VARCHAR),
+      Variant(200),
+      Variant::null(TypeKind::DOUBLE)};
+  auto nullVariant = Variant::create<TypeKind::ROW>(nullRow);
+  const auto& resultNullRow = nullVariant.value<TypeKind::ROW>();
+  EXPECT_EQ(resultNullRow.size(), 4);
+  EXPECT_FALSE(resultNullRow[0].isNull());
+  EXPECT_TRUE(resultNullRow[1].isNull());
+  EXPECT_FALSE(resultNullRow[2].isNull());
+  EXPECT_TRUE(resultNullRow[3].isNull());
+
+  // Nested row.
+  std::vector<Variant> nestedRow = {
+      Variant(1),
+      Variant::row({Variant("nested"), Variant(42)}),
+      Variant(true)};
+  auto nestedVariant = Variant::create<TypeKind::ROW>(nestedRow);
+  const auto& resultNestedRow = nestedVariant.value<TypeKind::ROW>();
+  EXPECT_EQ(resultNestedRow.size(), 3);
+  EXPECT_EQ(resultNestedRow[1].value<TypeKind::ROW>().size(), 2);
+
+  // Complex row with mixed types.
+  std::vector<Variant> complexRow = {
+      Variant(static_cast<int8_t>(127)),
+      Variant(static_cast<int16_t>(32000)),
+      Variant(static_cast<int32_t>(2000000)),
+      Variant(static_cast<int64_t>(9000000000LL)),
+      Variant(static_cast<int128_t>(12345)),
+      Variant(1.23f),
+      Variant(4.56789),
+      Variant("complex string"),
+      Variant(Timestamp(1000, 2000)),
+      Variant::array({Variant(1), Variant(2), Variant(3)}),
+      Variant::map({{Variant("key"), Variant("value")}})};
+  auto complexVariant = Variant::create<TypeKind::ROW>(complexRow);
+  const auto& resultComplexRow = complexVariant.value<TypeKind::ROW>();
+  EXPECT_EQ(resultComplexRow.size(), 11);
+
+  // Test move semantics.
+  std::vector<Variant> moveRow = {Variant(999), Variant("move")};
+  auto moveVariant = Variant::create<TypeKind::ROW>(std::move(moveRow));
+  EXPECT_EQ(moveVariant.value<TypeKind::ROW>().size(), 2);
+}
+
+// Test the template <typename T> create() version. This version uses
+// CppToType<T>::typeKind to deduce the TypeKind.
+TEST(VariantCreateTest, templateTypeVersion) {
+  // Test with bool.
+  bool boolVal = true;
+  auto boolVariant = Variant::create<bool>(boolVal);
+  EXPECT_EQ(boolVariant.kind(), TypeKind::BOOLEAN);
+  EXPECT_TRUE(boolVariant.value<TypeKind::BOOLEAN>());
+
+  // Test with int32_t.
+  int32_t intVal = 42;
+  auto intVariant = Variant::create<int32_t>(intVal);
+  EXPECT_EQ(intVariant.kind(), TypeKind::INTEGER);
+  EXPECT_EQ(intVariant.value<TypeKind::INTEGER>(), 42);
+
+  // Test with int64_t.
+  int64_t bigintVal = 9876543210LL;
+  auto bigintVariant = Variant::create<int64_t>(bigintVal);
+  EXPECT_EQ(bigintVariant.kind(), TypeKind::BIGINT);
+  EXPECT_EQ(bigintVariant.value<TypeKind::BIGINT>(), 9876543210LL);
+
+  // Test with float.
+  float floatVal = 3.14f;
+  auto floatVariant = Variant::create<float>(floatVal);
+  EXPECT_EQ(floatVariant.kind(), TypeKind::REAL);
+  EXPECT_FLOAT_EQ(floatVariant.value<TypeKind::REAL>(), 3.14f);
+
+  // Test with double.
+  double doubleVal = 2.71828;
+  auto doubleVariant = Variant::create<double>(doubleVal);
+  EXPECT_EQ(doubleVariant.kind(), TypeKind::DOUBLE);
+  EXPECT_DOUBLE_EQ(doubleVariant.value<TypeKind::DOUBLE>(), 2.71828);
+
+  // Test with std::string (VARCHAR).
+  std::string strVal = "test string";
+  auto strVariant = Variant::create<std::string>(strVal);
+  EXPECT_EQ(strVariant.kind(), TypeKind::VARCHAR);
+  EXPECT_EQ(strVariant.value<TypeKind::VARCHAR>(), "test string");
+}
+
+TEST(VariantCreateTest, moveSemantics) {
+  // Test move semantics explicitly for large objects
+
+  // Large string.
+  std::string largeString(10000, 'x');
+  auto moveStringVariant =
+      Variant::create<TypeKind::VARCHAR>(std::move(largeString));
+  EXPECT_EQ(moveStringVariant.value<TypeKind::VARCHAR>().size(), 10000);
+  // Original string should be moved-from (typically empty, but not guaranteed)
+
+  // Large array.
+  std::vector<Variant> largeArray;
+  for (int i = 0; i < 1000; ++i) {
+    largeArray.push_back(Variant(i));
+  }
+  auto moveArrayVariant =
+      Variant::create<TypeKind::ARRAY>(std::move(largeArray));
+  EXPECT_EQ(moveArrayVariant.value<TypeKind::ARRAY>().size(), 1000);
+
+  // Large map.
+  std::map<Variant, Variant> largeMap;
+  for (int i = 0; i < 1000; ++i) {
+    largeMap.emplace(Variant(i), Variant(i * 2));
+  }
+  auto moveMapVariant = Variant::create<TypeKind::MAP>(std::move(largeMap));
+  EXPECT_EQ(moveMapVariant.value<TypeKind::MAP>().size(), 1000);
+
+  // Large row.
+  std::vector<Variant> largeRow;
+  for (int i = 0; i < 5000; ++i) {
+    largeRow.push_back(Variant(static_cast<int64_t>(i)));
+  }
+  auto moveRowVariant = Variant::create<TypeKind::ROW>(std::move(largeRow));
+  EXPECT_EQ(moveRowVariant.value<TypeKind::ROW>().size(), 5000);
+}
+
+TEST(VariantCreateTest, copySemantics) {
+  // Test copy semantics to ensure values are properly copied
+
+  // Test with string
+  std::string originalString = "original";
+  auto copiedStringVariant = Variant::create<TypeKind::VARCHAR>(originalString);
+  EXPECT_EQ(copiedStringVariant.value<TypeKind::VARCHAR>(), "original");
+  EXPECT_EQ(originalString, "original"); // Original should be unchanged
+
+  // Test with array
+  std::vector<Variant> originalArray = {Variant(1), Variant(2), Variant(3)};
+  auto copiedArrayVariant = Variant::create<TypeKind::ARRAY>(originalArray);
+  EXPECT_EQ(copiedArrayVariant.value<TypeKind::ARRAY>().size(), 3);
+  EXPECT_EQ(originalArray.size(), 3); // Original should be unchanged
+
+  // Test with map
+  std::map<Variant, Variant> originalMap = {
+      {Variant(1), Variant("one")}, {Variant(2), Variant("two")}};
+  auto copiedMapVariant = Variant::create<TypeKind::MAP>(originalMap);
+  EXPECT_EQ(copiedMapVariant.value<TypeKind::MAP>().size(), 2);
+  EXPECT_EQ(originalMap.size(), 2); // Original should be unchanged
+
+  // Test with row
+  std::vector<Variant> originalRow = {
+      Variant(100), Variant("test"), Variant(3.14)};
+  auto copiedRowVariant = Variant::create<TypeKind::ROW>(originalRow);
+  EXPECT_EQ(copiedRowVariant.value<TypeKind::ROW>().size(), 3);
+  EXPECT_EQ(originalRow.size(), 3); // Original should be unchanged
+}
+
+TEST(VariantCreateTest, equalityAfterCreate) {
+  // Test that variants created via create() are equal to those created via
+  // constructors/factory methods
+
+  // BOOLEAN
+  auto boolCreate = Variant::create<TypeKind::BOOLEAN>(true);
+  auto boolConstructor = Variant(true);
+  EXPECT_EQ(boolCreate, boolConstructor);
+
+  // INTEGER
+  auto intCreate = Variant::create<TypeKind::INTEGER>(42);
+  auto intConstructor = Variant(42);
+  EXPECT_EQ(intCreate, intConstructor);
+
+  // BIGINT
+  auto bigintCreate = Variant::create<TypeKind::BIGINT>(9876543210LL);
+  auto bigintConstructor = Variant(9876543210LL);
+  EXPECT_EQ(bigintCreate, bigintConstructor);
+
+  // REAL
+  auto realCreate = Variant::create<TypeKind::REAL>(3.14f);
+  auto realConstructor = Variant(3.14f);
+  EXPECT_TRUE(realCreate.equalsWithEpsilon(realConstructor));
+
+  // DOUBLE
+  auto doubleCreate = Variant::create<TypeKind::DOUBLE>(2.71828);
+  auto doubleConstructor = Variant(2.71828);
+  EXPECT_TRUE(doubleCreate.equalsWithEpsilon(doubleConstructor));
+
+  // VARCHAR
+  auto varcharCreate = Variant::create<TypeKind::VARCHAR>(std::string("test"));
+  auto varcharConstructor = Variant("test");
+  EXPECT_EQ(varcharCreate, varcharConstructor);
+
+  // TIMESTAMP
+  Timestamp ts(12345, 67890);
+  auto timestampCreate = Variant::create<TypeKind::TIMESTAMP>(ts);
+  auto timestampFactory = Variant::timestamp(ts);
+  EXPECT_EQ(timestampCreate, timestampFactory);
+
+  // ARRAY
+  std::vector<Variant> arr = {Variant(1), Variant(2), Variant(3)};
+  auto arrayCreate = Variant::create<TypeKind::ARRAY>(arr);
+  auto arrayFactory = Variant::array(arr);
+  EXPECT_EQ(arrayCreate, arrayFactory);
+
+  // MAP
+  std::map<Variant, Variant> mp = {
+      {Variant(1), Variant("one")}, {Variant(2), Variant("two")}};
+  auto mapCreate = Variant::create<TypeKind::MAP>(mp);
+  auto mapFactory = Variant::map(mp);
+  EXPECT_EQ(mapCreate, mapFactory);
+
+  // ROW
+  std::vector<Variant> r = {Variant(1), Variant("test"), Variant(3.14)};
+  auto rowCreate = Variant::create<TypeKind::ROW>(r);
+  auto rowFactory = Variant::row(r);
+  EXPECT_EQ(rowCreate, rowFactory);
+}
+
+TEST(VariantCreateTest, hashConsistency) {
+  // Test that variants created via create() have consistent hashes
+
+  // Same values should have same hash
+  auto v1 = Variant::create<TypeKind::INTEGER>(42);
+  auto v2 = Variant::create<TypeKind::INTEGER>(42);
+  EXPECT_EQ(v1.hash(), v2.hash());
+
+  // Different values should (usually) have different hashes
+  auto v3 = Variant::create<TypeKind::INTEGER>(43);
+  EXPECT_NE(v1.hash(), v3.hash());
+
+  // Test with strings
+  auto s1 = Variant::create<TypeKind::VARCHAR>(std::string("hello"));
+  auto s2 = Variant::create<TypeKind::VARCHAR>(std::string("hello"));
+  auto s3 = Variant::create<TypeKind::VARCHAR>(std::string("world"));
+  EXPECT_EQ(s1.hash(), s2.hash());
+  EXPECT_NE(s1.hash(), s3.hash());
+
+  // Test with arrays
+  std::vector<Variant> arr1 = {Variant(1), Variant(2)};
+  std::vector<Variant> arr2 = {Variant(1), Variant(2)};
+  std::vector<Variant> arr3 = {Variant(1), Variant(3)};
+  auto a1 = Variant::create<TypeKind::ARRAY>(arr1);
+  auto a2 = Variant::create<TypeKind::ARRAY>(arr2);
+  auto a3 = Variant::create<TypeKind::ARRAY>(arr3);
+  EXPECT_EQ(a1.hash(), a2.hash());
+  EXPECT_NE(a1.hash(), a3.hash());
+}
+
+TEST(VariantCreateTest, typeInference) {
+  // Test that variants created via create() correctly infer their types
+
+  auto boolVar = Variant::create<TypeKind::BOOLEAN>(true);
+  EXPECT_EQ(*boolVar.inferType(), *BOOLEAN());
+
+  auto intVar = Variant::create<TypeKind::INTEGER>(42);
+  EXPECT_EQ(*intVar.inferType(), *INTEGER());
+
+  auto bigintVar = Variant::create<TypeKind::BIGINT>(9876543210LL);
+  EXPECT_EQ(*bigintVar.inferType(), *BIGINT());
+
+  auto realVar = Variant::create<TypeKind::REAL>(3.14f);
+  EXPECT_EQ(*realVar.inferType(), *REAL());
+
+  auto doubleVar = Variant::create<TypeKind::DOUBLE>(2.71828);
+  EXPECT_EQ(*doubleVar.inferType(), *DOUBLE());
+
+  auto varcharVar = Variant::create<TypeKind::VARCHAR>(std::string("test"));
+  EXPECT_EQ(*varcharVar.inferType(), *VARCHAR());
+
+  auto timestampVar =
+      Variant::create<TypeKind::TIMESTAMP>(Timestamp(12345, 67890));
+  EXPECT_EQ(*timestampVar.inferType(), *TIMESTAMP());
+
+  auto arrayVar =
+      Variant::create<TypeKind::ARRAY>(std::vector<Variant>{Variant(1)});
+  EXPECT_EQ(*arrayVar.inferType(), *ARRAY(INTEGER()));
+
+  auto mapVar = Variant::create<TypeKind::MAP>(
+      std::map<Variant, Variant>{{Variant(1), Variant("one")}});
+  EXPECT_EQ(*mapVar.inferType(), *MAP(INTEGER(), VARCHAR()));
+
+  auto rowVar = Variant::create<TypeKind::ROW>(
+      std::vector<Variant>{Variant(1), Variant("test")});
+  EXPECT_EQ(*rowVar.inferType(), *ROW({INTEGER(), VARCHAR()}));
 }
-} // namespace
 
 TEST(VariantTest, arrayInferType) {
-  EXPECT_EQ(*ARRAY(UNKNOWN()), *variant(TypeKind::ARRAY).inferType());
-  EXPECT_EQ(*ARRAY(UNKNOWN()), *variant::array({}).inferType());
+  EXPECT_EQ(*ARRAY(UNKNOWN()), *Variant(TypeKind::ARRAY).inferType());
+  EXPECT_EQ(*ARRAY(UNKNOWN()), *Variant::array({}).inferType());
+  EXPECT_EQ(*ARRAY(UNKNOWN()), *Variant::null(TypeKind::ARRAY).inferType());
   EXPECT_EQ(
       *ARRAY(BIGINT()),
-      *variant::array({variant(TypeKind::BIGINT)}).inferType());
+      *Variant::array({Variant(TypeKind::BIGINT)}).inferType());
   EXPECT_EQ(
       *ARRAY(VARCHAR()),
-      *variant::array({variant(TypeKind::VARCHAR)}).inferType());
+      *Variant::array({Variant(TypeKind::VARCHAR)}).inferType());
   EXPECT_EQ(
       *ARRAY(ARRAY(DOUBLE())),
-      *variant::array({variant::array({variant(TypeKind::DOUBLE)})})
+      *Variant::array({Variant::array({Variant(TypeKind::DOUBLE)})})
            .inferType());
   VELOX_ASSERT_THROW(
-      variant::array({variant(123456789), variant("velox")}),
+      Variant::array({Variant(123456789), Variant("velox")}),
       "All array elements must be of the same kind");
 }
 
 TEST(VariantTest, mapInferType) {
-  EXPECT_EQ(*variant::map({{1LL, 1LL}}).inferType(), *MAP(BIGINT(), BIGINT()));
-  EXPECT_EQ(*variant::map({}).inferType(), *MAP(UNKNOWN(), UNKNOWN()));
+  EXPECT_EQ(*Variant::map({{1LL, 1LL}}).inferType(), *MAP(BIGINT(), BIGINT()));
+  EXPECT_EQ(*Variant::map({}).inferType(), *MAP(UNKNOWN(), UNKNOWN()));
+  EXPECT_EQ(
+      *MAP(UNKNOWN(), UNKNOWN()), *Variant::null(TypeKind::MAP).inferType());
 
-  const variant nullBigint = variant::null(TypeKind::BIGINT);
-  const variant nullReal = variant::null(TypeKind::REAL);
+  const Variant nullBigint = Variant::null(TypeKind::BIGINT);
+  const Variant nullReal = Variant::null(TypeKind::REAL);
   EXPECT_EQ(
-      *variant::map({{nullBigint, nullReal}, {1LL, 1.0f}}).inferType(),
+      *Variant::map({{nullBigint, nullReal}, {1LL, 1.0f}}).inferType(),
       *MAP(BIGINT(), REAL()));
   EXPECT_EQ(
-      *variant::map({{nullBigint, 1.0f}, {1LL, nullReal}}).inferType(),
+      *Variant::map({{nullBigint, 1.0f}, {1LL, nullReal}}).inferType(),
       *MAP(BIGINT(), REAL()));
   EXPECT_EQ(
-      *variant::map({{nullBigint, 1.0f}}).inferType(), *MAP(UNKNOWN(), REAL()));
+      *Variant::map({{nullBigint, 1.0f}}).inferType(), *MAP(UNKNOWN(), REAL()));
 }
 
-struct Foo {};
+TEST(VariantTest, rowInferType) {
+  EXPECT_EQ(
+      *ROW({BIGINT(), VARCHAR()}),
+      *Variant::row({Variant(1LL), Variant("velox")}).inferType());
+  EXPECT_EQ(*ROW({}), *Variant::null(TypeKind::ROW).inferType());
+}
 
-struct Bar {};
+TEST(VariantTest, arrayTypeCompatibility) {
+  const auto empty = Variant::array({});
 
-TEST(VariantTest, opaque) {
-  auto foo = std::make_shared<Foo>();
-  auto foo2 = std::make_shared<Foo>();
-  auto bar = std::make_shared<Bar>();
-  {
-    variant v = variant::opaque(foo);
-    EXPECT_TRUE(v.hasValue());
-    EXPECT_EQ(TypeKind::OPAQUE, v.kind());
-    EXPECT_EQ(foo, v.opaque<Foo>());
-    EXPECT_THROW(v.opaque<Bar>(), std::exception);
-    EXPECT_EQ(*v.inferType(), *OPAQUE<Foo>());
-  }
+  EXPECT_TRUE(empty.isTypeCompatible(ARRAY(UNKNOWN())));
+  EXPECT_TRUE(empty.isTypeCompatible(ARRAY(BIGINT())));
 
-  // Check that the expected shared ptrs are acquired.
-  {
-    EXPECT_EQ(1, foo.use_count());
-    variant v = variant::opaque(foo);
-    EXPECT_EQ(2, foo.use_count());
-    variant vv = v;
-    EXPECT_EQ(3, foo.use_count());
-    { variant tmp = std::move(vv); }
-    EXPECT_EQ(2, foo.use_count());
-    v = 0;
-    EXPECT_EQ(1, foo.use_count());
-  }
+  EXPECT_FALSE(empty.isTypeCompatible(UNKNOWN()));
+  EXPECT_FALSE(empty.isTypeCompatible(BIGINT()));
+  EXPECT_FALSE(empty.isTypeCompatible(MAP(INTEGER(), REAL())));
 
-  // Test opaque equality.
-  {
-    variant v1 = variant::opaque(foo);
-    variant vv1 = variant::opaque(foo);
-    variant v2 = variant::opaque(foo2);
-    variant v3 = variant::opaque(bar);
-    variant vint = 123;
-    EXPECT_EQ(v1, vv1);
-    EXPECT_NE(v1, v2);
-    EXPECT_NE(v1, v3);
-    EXPECT_NE(v1, vint);
-  }
+  const auto null = Variant::null(TypeKind::ARRAY);
 
-  // Test hashes. The semantic of the hash follows the object it points to
-  // (it hashes the pointer).
-  {
-    variant v1 = variant::opaque(foo);
-    variant vv1 = variant::opaque(foo);
+  EXPECT_TRUE(null.isTypeCompatible(ARRAY(UNKNOWN())));
+  EXPECT_TRUE(null.isTypeCompatible(ARRAY(BIGINT())));
 
-    variant v2 = variant::opaque(foo2);
-    variant v3 = variant::opaque(bar);
+  EXPECT_FALSE(null.isTypeCompatible(UNKNOWN()));
+  EXPECT_FALSE(null.isTypeCompatible(BIGINT()));
+  EXPECT_FALSE(null.isTypeCompatible(MAP(INTEGER(), REAL())));
 
-    EXPECT_EQ(v1.hash(), vv1.hash());
-    EXPECT_NE(v1.hash(), v2.hash());
-    EXPECT_NE(vv1.hash(), v2.hash());
+  const auto array = Variant::array({1, 2, 3});
 
-    EXPECT_NE(v1.hash(), v3.hash());
-    EXPECT_NE(v2.hash(), v3.hash());
-  }
+  EXPECT_TRUE(array.isTypeCompatible(ARRAY(INTEGER())));
 
-  // Test opaque casting.
-  {
-    variant fooOpaque = variant::opaque(foo);
-    variant barOpaque = variant::opaque(bar);
-    variant int1 = variant((int64_t)123);
+  EXPECT_FALSE(array.isTypeCompatible(INTEGER()));
+  EXPECT_FALSE(array.isTypeCompatible(ARRAY(REAL())));
+}
 
-    auto castFoo1 = fooOpaque.tryOpaque<Foo>();
-    auto castBar1 = fooOpaque.tryOpaque<Bar>();
-    auto castBar2 = barOpaque.tryOpaque<Bar>();
+TEST(VariantTest, mapTypeCompatibility) {
+  const auto empty = Variant::map({});
 
-    EXPECT_EQ(castFoo1, foo);
-    EXPECT_EQ(castBar1, nullptr);
-    EXPECT_EQ(castBar2, bar);
-    EXPECT_THROW(int1.tryOpaque<Foo>(), std::invalid_argument);
-  }
+  EXPECT_TRUE(empty.isTypeCompatible(MAP(UNKNOWN(), UNKNOWN())));
+  EXPECT_TRUE(empty.isTypeCompatible(MAP(BIGINT(), BIGINT())));
+  EXPECT_TRUE(empty.isTypeCompatible(MAP(REAL(), UNKNOWN())));
+  EXPECT_TRUE(empty.isTypeCompatible(MAP(INTEGER(), DOUBLE())));
+
+  EXPECT_FALSE(empty.isTypeCompatible(UNKNOWN()));
+  EXPECT_FALSE(empty.isTypeCompatible(BIGINT()));
+  EXPECT_FALSE(empty.isTypeCompatible(ARRAY(INTEGER())));
+
+  const auto null = Variant::null(TypeKind::MAP);
+
+  EXPECT_TRUE(null.isTypeCompatible(MAP(UNKNOWN(), UNKNOWN())));
+  EXPECT_TRUE(null.isTypeCompatible(MAP(BIGINT(), BIGINT())));
+  EXPECT_TRUE(null.isTypeCompatible(MAP(REAL(), UNKNOWN())));
+  EXPECT_TRUE(null.isTypeCompatible(MAP(INTEGER(), DOUBLE())));
+
+  EXPECT_FALSE(null.isTypeCompatible(UNKNOWN()));
+  EXPECT_FALSE(null.isTypeCompatible(BIGINT()));
+  EXPECT_FALSE(null.isTypeCompatible(ARRAY(INTEGER())));
+
+  const auto map = Variant::map({{1, 1.0f}, {2, 2.0f}});
+
+  EXPECT_TRUE(map.isTypeCompatible(MAP(INTEGER(), REAL())));
+
+  EXPECT_FALSE(map.isTypeCompatible(MAP(INTEGER(), DOUBLE())));
+  EXPECT_FALSE(map.isTypeCompatible(UNKNOWN()));
+  EXPECT_FALSE(map.isTypeCompatible(ARRAY(BIGINT())));
 }
 
-/// Test variant::equalsWithEpsilon by summing up large 64-bit integers (> 15
+TEST(VariantTest, rowTypeCompatibility) {
+  const auto empty = Variant::row({});
+
+  EXPECT_TRUE(empty.isTypeCompatible(ROW({})));
+
+  EXPECT_FALSE(empty.isTypeCompatible(BIGINT()));
+  EXPECT_FALSE(empty.isTypeCompatible(ROW({INTEGER(), REAL()})));
+
+  const auto null = Variant::null(TypeKind::ROW);
+
+  EXPECT_TRUE(null.isTypeCompatible(ROW({INTEGER(), REAL()})));
+  EXPECT_TRUE(null.isTypeCompatible(ROW({"a", "b"}, {INTEGER(), REAL()})));
+
+  EXPECT_FALSE(null.isTypeCompatible(BIGINT()));
+
+  const auto row = Variant::row({1, 2.0f});
+
+  EXPECT_TRUE(row.isTypeCompatible(ROW({INTEGER(), REAL()})));
+  EXPECT_TRUE(row.isTypeCompatible(ROW({"a", "b"}, {INTEGER(), REAL()})));
+
+  EXPECT_FALSE(row.isTypeCompatible(ROW({INTEGER()})));
+  EXPECT_FALSE(row.isTypeCompatible(ROW({INTEGER(), DOUBLE()})));
+  EXPECT_FALSE(row.isTypeCompatible(BIGINT()));
+}
+
+TEST(VariantTest, nullVariant) {
+  // Type of null variant is UNKNOWN and should be compatible with all types.
+  auto nullVariant = Variant{};
+  ASSERT_TRUE(nullVariant.isTypeCompatible(VARCHAR()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(INTEGER()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(BIGINT()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(DOUBLE()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(DATE()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(TIMESTAMP()));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(MAP(BIGINT(), DOUBLE())));
+  ASSERT_TRUE(nullVariant.isTypeCompatible(ARRAY(DATE())));
+  ASSERT_TRUE(
+      nullVariant.isTypeCompatible(ROW({DATE(), BIGINT(), TIMESTAMP()})));
+}
+
+/// Test Variant::equalsWithEpsilon by summing up large 64-bit integers (> 15
 /// digits long) into double in different order to get slightly different
 /// results due to loss of precision.
 TEST(VariantTest, equalsWithEpsilonDouble) {
@@ -174,7 +738,7 @@ TEST(VariantTest, equalsWithEpsilonDouble) {
 
   ASSERT_NE(sum1, sum2);
   ASSERT_DOUBLE_EQ(sum1, sum2);
-  ASSERT_TRUE(variant(sum1).equalsWithEpsilon(variant(sum2)));
+  ASSERT_TRUE(Variant(sum1).equalsWithEpsilon(Variant(sum2)));
 
   // Add up all numbers but one. Make sure the result is not equal to sum1.
   double sum3 = 0;
@@ -185,10 +749,10 @@ TEST(VariantTest, equalsWithEpsilonDouble) {
   }
 
   ASSERT_NE(sum1, sum3);
-  ASSERT_FALSE(variant(sum1).equalsWithEpsilon(variant(sum3)));
+  ASSERT_FALSE(Variant(sum1).equalsWithEpsilon(Variant(sum3)));
 }
 
-/// Similar to equalsWithEpsilonDouble, test variant::equalsWithEpsilon by
+/// Similar to equalsWithEpsilonDouble, test Variant::equalsWithEpsilon by
 /// summing up large 32-bit integers into float in different order to get
 /// slightly different results due to loss of precision.
 TEST(VariantTest, equalsWithEpsilonFloat) {
@@ -221,7 +785,7 @@ TEST(VariantTest, equalsWithEpsilonFloat) {
 
   ASSERT_NE(sum1, sum2);
   ASSERT_FLOAT_EQ(sum1, sum2);
-  ASSERT_TRUE(variant(sum1).equalsWithEpsilon(variant(sum2)));
+  ASSERT_TRUE(Variant(sum1).equalsWithEpsilon(Variant(sum2)));
 
   // Add up all numbers but one. Make sure the result is not equal to sum1.
   float sum3 = 0;
@@ -232,7 +796,7 @@ TEST(VariantTest, equalsWithEpsilonFloat) {
   }
 
   ASSERT_NE(sum1, sum3);
-  ASSERT_FALSE(variant(sum1).equalsWithEpsilon(variant(sum3)));
+  ASSERT_FALSE(Variant(sum1).equalsWithEpsilon(Variant(sum3)));
 }
 
 TEST(VariantTest, mapWithNaNKey) {
@@ -242,54 +806,475 @@ TEST(VariantTest, mapWithNaNKey) {
   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)});
+    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));
+        R"([{"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)});
+    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));
+        R"([{"key":1.2,"value":2},{"key":12.4,"value":3},{"key":"NaN","value":1}])",
+        Variant::map(mapVariant).toJson(mapType));
+  }
+}
+
+struct Foo {};
+struct Bar {};
+
+TEST(VariantOpaqueTest, opaque) {
+  auto foo = std::make_shared<Foo>();
+  auto foo2 = std::make_shared<Foo>();
+  auto bar = std::make_shared<Bar>();
+  {
+    Variant v = Variant::opaque(foo);
+    EXPECT_TRUE(v.hasValue());
+    EXPECT_EQ(TypeKind::OPAQUE, v.kind());
+    EXPECT_EQ(foo, v.opaque<Foo>());
+    EXPECT_THROW(v.opaque<Bar>(), std::exception);
+    EXPECT_EQ(*v.inferType(), *OPAQUE<Foo>());
+  }
+
+  // Check that the expected shared ptrs are acquired.
+  {
+    EXPECT_EQ(1, foo.use_count());
+    Variant v = Variant::opaque(foo);
+    EXPECT_EQ(2, foo.use_count());
+    Variant vv = v;
+    EXPECT_EQ(3, foo.use_count());
+    {
+      Variant tmp = std::move(vv);
+    }
+    EXPECT_EQ(2, foo.use_count());
+    v = 0;
+    EXPECT_EQ(1, foo.use_count());
   }
+
+  // Test opaque equality.
+  {
+    Variant v1 = Variant::opaque(foo);
+    Variant vv1 = Variant::opaque(foo);
+    Variant v2 = Variant::opaque(foo2);
+    Variant v3 = Variant::opaque(bar);
+    Variant vint = 123;
+    EXPECT_EQ(v1, vv1);
+    EXPECT_NE(v1, v2);
+    EXPECT_NE(v1, v3);
+    EXPECT_NE(v1, vint);
+  }
+
+  // Test hashes. The semantic of the hash follows the object it points to
+  // (it hashes the pointer).
+  {
+    Variant v1 = Variant::opaque(foo);
+    Variant vv1 = Variant::opaque(foo);
+
+    Variant v2 = Variant::opaque(foo2);
+    Variant v3 = Variant::opaque(bar);
+
+    EXPECT_EQ(v1.hash(), vv1.hash());
+    EXPECT_NE(v1.hash(), v2.hash());
+    EXPECT_NE(vv1.hash(), v2.hash());
+
+    EXPECT_NE(v1.hash(), v3.hash());
+    EXPECT_NE(v2.hash(), v3.hash());
+  }
+
+  // Test opaque casting.
+  {
+    Variant fooOpaque = Variant::opaque(foo);
+    Variant barOpaque = Variant::opaque(bar);
+    Variant int1 = Variant((int64_t)123);
+
+    auto castFoo1 = fooOpaque.tryOpaque<Foo>();
+    auto castBar1 = fooOpaque.tryOpaque<Bar>();
+    auto castBar2 = barOpaque.tryOpaque<Bar>();
+
+    EXPECT_EQ(castFoo1, foo);
+    EXPECT_EQ(castBar1, nullptr);
+    EXPECT_EQ(castBar2, bar);
+    EXPECT_THROW(int1.tryOpaque<Foo>(), std::invalid_argument);
+  }
+}
+
+void testSerDe(const Variant& value) {
+  auto serialized = value.serialize();
+  auto copy = Variant::create(serialized);
+
+  ASSERT_EQ(value, copy);
 }
 
-TEST(VariantTest, serialize) {
+TEST(VariantSerializationTest, serialize) {
   // Null values.
-  testSerDe(variant(TypeKind::BOOLEAN));
-  testSerDe(variant(TypeKind::TINYINT));
-  testSerDe(variant(TypeKind::SMALLINT));
-  testSerDe(variant(TypeKind::INTEGER));
-  testSerDe(variant(TypeKind::BIGINT));
-  testSerDe(variant(TypeKind::REAL));
-  testSerDe(variant(TypeKind::DOUBLE));
-  testSerDe(variant(TypeKind::VARCHAR));
-  testSerDe(variant(TypeKind::VARBINARY));
-  testSerDe(variant(TypeKind::TIMESTAMP));
-  testSerDe(variant(TypeKind::ARRAY));
-  testSerDe(variant(TypeKind::MAP));
-  testSerDe(variant(TypeKind::ROW));
-  testSerDe(variant(TypeKind::UNKNOWN));
+  testSerDe(Variant(TypeKind::BOOLEAN));
+  testSerDe(Variant(TypeKind::TINYINT));
+  testSerDe(Variant(TypeKind::SMALLINT));
+  testSerDe(Variant(TypeKind::INTEGER));
+  testSerDe(Variant(TypeKind::BIGINT));
+  testSerDe(Variant(TypeKind::REAL));
+  testSerDe(Variant(TypeKind::DOUBLE));
+  testSerDe(Variant(TypeKind::VARCHAR));
+  testSerDe(Variant(TypeKind::VARBINARY));
+  testSerDe(Variant(TypeKind::TIMESTAMP));
+  testSerDe(Variant(TypeKind::ARRAY));
+  testSerDe(Variant(TypeKind::MAP));
+  testSerDe(Variant(TypeKind::ROW));
+  testSerDe(Variant(TypeKind::UNKNOWN));
 
   // Non-null values.
-  testSerDe(variant(true));
-  testSerDe(variant((int8_t)12));
-  testSerDe(variant((int16_t)1234));
-  testSerDe(variant((int32_t)12345));
-  testSerDe(variant((int64_t)1234567));
-  testSerDe(variant((float)1.2));
-  testSerDe(variant((double)1.234));
-  testSerDe(variant("This is a test."));
-  testSerDe(variant::binary("This is a test."));
-  testSerDe(variant(Timestamp(1, 2)));
+  testSerDe(Variant(true));
+  testSerDe(Variant(static_cast<int8_t>(12)));
+  testSerDe(Variant(static_cast<int16_t>(1234)));
+  testSerDe(Variant(static_cast<int32_t>(12345)));
+  testSerDe(Variant(static_cast<int64_t>(1234567)));
+  testSerDe(Variant(static_cast<float>(1.2f)));
+  testSerDe(Variant(static_cast<double>(1.234)));
+  testSerDe(Variant("This is a test."));
+  testSerDe(Variant::binary("This is a test."));
+  testSerDe(Variant(Timestamp(1, 2)));
+}
+
+TEST(VariantSerializationTest, serializeArrayTypes) {
+  // Empty array.
+  testSerDe(Variant::array({}));
+
+  // Simple array with primitive elements.
+  testSerDe(Variant::array({Variant(1), Variant(2), Variant(3)}));
+
+  // Array with integers of same type.
+  testSerDe(
+      Variant::array({
+          Variant(static_cast<int32_t>(1)),
+          Variant(static_cast<int32_t>(100)),
+          Variant(static_cast<int32_t>(10000)),
+      }));
+
+  // Array with strings.
+  testSerDe(
+      Variant::array({
+          Variant("hello"),
+          Variant("world"),
+          Variant("test"),
+      }));
+
+  // Array with mixed null and non-null elements.
+  testSerDe(
+      Variant::array({
+          Variant(1),
+          Variant::null(TypeKind::INTEGER),
+          Variant(3),
+          Variant::null(TypeKind::INTEGER),
+      }));
+
+  // Array with floating point values.
+  testSerDe(
+      Variant::array({
+          Variant(1.5),
+          Variant(2.7),
+          Variant(-3.14),
+      }));
+
+  // Array with boolean values.
+  testSerDe(
+      Variant::array({
+          Variant(true),
+          Variant(false),
+          Variant(true),
+      }));
+
+  // Array with timestamps.
+  testSerDe(
+      Variant::array({
+          Variant(Timestamp(1000, 500)),
+          Variant(Timestamp(2000, 1000)),
+      }));
+
+  // Nested array (array of arrays).
+  testSerDe(
+      Variant::array({
+          Variant::array({Variant(1), Variant(2)}),
+          Variant::array({Variant(3), Variant(4), Variant(5)}),
+          Variant::array({}),
+      }));
+
+  // Deeply nested arrays.
+  testSerDe(
+      Variant::array({Variant::array(
+          {Variant::array({Variant(1), Variant(2)}),
+           Variant::array({Variant(3)})})}));
+
+  // Array with null array elements.
+  testSerDe(
+      Variant::array({
+          Variant::array({Variant(1)}),
+          Variant::null(TypeKind::ARRAY),
+          Variant::array({Variant(2)}),
+      }));
+
+  // Large array.
+  std::vector<Variant> largeArray;
+  for (int i = 0; i < 100; ++i) {
+    largeArray.push_back(Variant(i));
+  }
+  testSerDe(Variant::array(largeArray));
+}
+
+TEST(VariantSerializationTest, serializeMapTypes) {
+  // Empty map.
+  testSerDe(Variant::map({}));
+
+  // Simple map with integer keys and string values.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant("one")},
+          {Variant(2), Variant("two")},
+          {Variant(3), Variant("three")},
+      }));
+
+  // Map with string keys and integer values.
+  testSerDe(
+      Variant::map({
+          {Variant("a"), Variant(1)},
+          {Variant("b"), Variant(2)},
+          {Variant("c"), Variant(3)},
+      }));
+
+  // Map with null values.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant(100)},
+          {Variant(2), Variant::null(TypeKind::INTEGER)},
+          {Variant(3), Variant(300)},
+      }));
+
+  // Map with floating point keys and values.
+  testSerDe(
+      Variant::map({
+          {Variant(1.5), Variant(10.5)},
+          {Variant(2.5), Variant(20.5)},
+      }));
+
+  // Map with boolean keys.
+  testSerDe(
+      Variant::map({
+          {Variant(true), Variant("yes")},
+          {Variant(false), Variant("no")},
+      }));
+
+  // Nested map (map of maps).
+  testSerDe(
+      Variant::map({
+          {Variant(1),
+           Variant::map({
+               {Variant("a"), Variant(10)},
+               {Variant("b"), Variant(20)},
+           })},
+          {Variant(2),
+           Variant::map({
+               {Variant("c"), Variant(30)},
+           })},
+      }));
+
+  // Map with array values.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant::array({Variant(10), Variant(20)})},
+          {Variant(2), Variant::array({Variant(30), Variant(40), Variant(50)})},
+      }));
+
+  // Map with complex mixed types.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant("string")},
+          {Variant(2), Variant(42)},
+          {Variant(3), Variant(3.14)},
+          {Variant(4), Variant(true)},
+      }));
+
+  // Map with timestamp keys and values.
+  testSerDe(
+      Variant::map({
+          {Variant(Timestamp(1000, 0)), Variant(Timestamp(2000, 0))},
+          {Variant(Timestamp(3000, 500)), Variant(Timestamp(4000, 1000))},
+      }));
+
+  // Large map.
+  std::map<Variant, Variant> largeMap;
+  for (int i = 0; i < 100; ++i) {
+    largeMap.emplace(Variant(i), Variant(i * 10));
+  }
+  testSerDe(Variant::map(largeMap));
+}
+
+TEST(VariantSerializationTest, serializeRowTypes) {
+  // Empty row.
+  testSerDe(Variant::row({}));
+
+  // Simple row with primitive fields.
+  testSerDe(Variant::row({Variant(1), Variant("test"), Variant(3.14)}));
+
+  // Row with different integer types.
+  testSerDe(
+      Variant::row({
+          Variant(static_cast<int8_t>(1)),
+          Variant(static_cast<int16_t>(100)),
+          Variant(static_cast<int32_t>(10000)),
+          Variant(static_cast<int64_t>(1000000LL)),
+      }));
+
+  // Row with null fields.
+  testSerDe(
+      Variant::row({
+          Variant(1),
+          Variant::null(TypeKind::VARCHAR),
+          Variant(3.14),
+          Variant::null(TypeKind::INTEGER),
+      }));
+
+  // Row with all null fields.
+  testSerDe(
+      Variant::row({
+          Variant::null(TypeKind::INTEGER),
+          Variant::null(TypeKind::VARCHAR),
+          Variant::null(TypeKind::DOUBLE),
+      }));
+
+  // Row with boolean fields.
+  testSerDe(Variant::row({Variant(true), Variant(false), Variant(true)}));
+
+  // Row with floating point fields.
+  testSerDe(
+      Variant::row({Variant(1.5f), Variant(2.7), Variant(-3.14159265358979)}));
+
+  // Row with timestamp fields.
+  testSerDe(
+      Variant::row({
+          Variant(Timestamp(1000, 500)),
+          Variant(Timestamp(2000, 1000)),
+          Variant(Timestamp(3000, 1500)),
+      }));
+
+  // Nested row (row containing rows).
+  testSerDe(
+      Variant::row({
+          Variant(1),
+          Variant::row({Variant("inner"), Variant(42)}),
+          Variant(3.14),
+      }));
+
+  // Row with array fields.
+  testSerDe(
+      Variant::row({
+          Variant::array({Variant(1), Variant(2), Variant(3)}),
+          Variant::array({Variant("a"), Variant("b")}),
+      }));
+
+  // Row with map fields.
+  testSerDe(
+      Variant::row({
+          Variant::map({
+              {Variant(1), Variant("one")},
+              {Variant(2), Variant("two")},
+          }),
+          Variant::map({
+              {Variant("x"), Variant(10)},
+              {Variant("y"), Variant(20)},
+          }),
+      }));
+
+  // Complex nested row with mixed types.
+  testSerDe(
+      Variant::row({
+          Variant(1),
+          Variant::array({Variant(10), Variant(20)}),
+          Variant::map({
+              {Variant("key"), Variant("value")},
+          }),
+          Variant::row({Variant(true), Variant(false)}),
+          Variant("string field"),
+      }));
+
+  // Deeply nested row structure.
+  testSerDe(
+      Variant::row({
+          Variant::row({
+              Variant::row({Variant(1), Variant(2)}),
+              Variant::row({Variant(3), Variant(4)}),
+          }),
+          Variant(100),
+      }));
+
+  // Large row.
+  std::vector<Variant> largeRow;
+  for (int i = 0; i < 100; ++i) {
+    largeRow.push_back(Variant(i));
+  }
+  testSerDe(Variant::row(largeRow));
+}
+
+TEST(VariantSerializationTest, serializeComplexNestedStructures) {
+  // Array of maps (all elements must be MAP type).
+  testSerDe(
+      Variant::array({
+          Variant::map({
+              {Variant(1), Variant("a")},
+              {Variant(2), Variant("b")},
+          }),
+          Variant::map({
+              {Variant(3), Variant("c")},
+          }),
+      }));
+
+  // Map with row values.
+  testSerDe(
+      Variant::map({
+          {Variant(1), Variant::row({Variant(10), Variant("ten")})},
+          {Variant(2), Variant::row({Variant(20), Variant("twenty")})},
+      }));
+
+  // Row of arrays of maps.
+  testSerDe(
+      Variant::row({
+          Variant::array({
+              Variant::map({{Variant(1), Variant(100)}}),
+              Variant::map({{Variant(2), Variant(200)}}),
+          }),
+          Variant::array({
+              Variant::map({{Variant(3), Variant(300)}}),
+          }),
+      }));
+
+  // Map with array keys and row values (complex structure).
+  testSerDe(
+      Variant::map({
+          {Variant::array({Variant(1), Variant(2)}),
+           Variant::row({Variant("a"), Variant(true)})},
+          {Variant::array({Variant(3)}),
+           Variant::row({Variant("b"), Variant(false)})},
+      }));
+
+  // Array of arrays (homogeneous).
+  testSerDe(
+      Variant::array({
+          Variant::array({Variant(1), Variant(2)}),
+          Variant::array({Variant(3), Variant(4)}),
+          Variant::null(TypeKind::ARRAY),
+      }));
+
+  // Array of rows (homogeneous).
+  testSerDe(
+      Variant::array({
+          Variant::row({Variant(true), Variant(3.14)}),
+          Variant::row({Variant(false), Variant(2.71)}),
+      }));
 }
 
 struct SerializableClass {
@@ -299,7 +1284,7 @@ struct SerializableClass {
       : name(std::move(name)), value(value) {}
 };
 
-class VariantSerializationTest : public ::testing::Test {
+class VariantOpaqueSerializationTest : public ::testing::Test {
  protected:
   void SetUp() override {
     static folly::once_flag once;
@@ -317,61 +1302,63 @@ class VariantSerializationTest : public ::testing::Test {
                 obj["name"].asString(), obj["value"].asBool());
           });
     });
-    var_ = variant::opaque<SerializableClass>(
+
+    value_ = Variant::opaque<SerializableClass>(
         std::make_shared<SerializableClass>("test_class", false));
   }
 
-  variant var_;
+  Variant value_;
 };
 
-TEST_F(VariantSerializationTest, serializeOpaque) {
-  auto serialized = var_.serialize();
-  auto deserialized_variant = variant::create(serialized);
-  auto opaque = deserialized_variant.value<TypeKind::OPAQUE>().obj;
-  auto original_class = std::static_pointer_cast<SerializableClass>(opaque);
-  EXPECT_EQ(original_class->name, "test_class");
-  EXPECT_EQ(original_class->value, false);
+TEST_F(VariantOpaqueSerializationTest, serializeOpaque) {
+  auto serialized = value_.serialize();
+  auto deserialized = Variant::create(serialized);
+  auto opaque = deserialized.value<TypeKind::OPAQUE>().obj;
+  auto original = std::static_pointer_cast<SerializableClass>(opaque);
+  EXPECT_EQ(original->name, "test_class");
+  EXPECT_EQ(original->value, false);
 }
 
-TEST_F(VariantSerializationTest, opaqueToString) {
-  const auto type = var_.inferType();
-  auto s = var_.toJson(type);
-  EXPECT_EQ(
-      s,
-      "Opaque<type:OPAQUE<SerializableClass>,value:\"{\"name\":\"test_class\",\"value\":false}\">");
+TEST_F(VariantOpaqueSerializationTest, opaqueToJson) {
+  const auto type = value_.inferType();
+
+  const auto expected =
+      R"(Opaque<type:OPAQUE<facebook::velox::test::(anonymous namespace)::SerializableClass>,value:"{"name":"test_class","value":false}">)";
+  EXPECT_EQ(value_.toJson(type), expected);
+  EXPECT_EQ(value_.toString(type), expected);
 }
 
 TEST(VariantFloatingToJsonTest, normalTest) {
   // Zero
-  EXPECT_EQ(variant::create<float>(0).toJson(REAL()), "0");
-  EXPECT_EQ(variant::create<double>(0).toJson(DOUBLE()), "0");
+  EXPECT_EQ(Variant::create<float>(0).toJson(REAL()), "0");
+  EXPECT_EQ(Variant::create<double>(0).toJson(DOUBLE()), "0");
 
   // Infinite
   EXPECT_EQ(
-      variant::create<float>(std::numeric_limits<float>::infinity())
+      Variant::create<float>(std::numeric_limits<float>::infinity())
           .toJson(REAL()),
-      "\"Infinity\"");
+      R"("Infinity")");
   EXPECT_EQ(
-      variant::create<double>(std::numeric_limits<double>::infinity())
+      Variant::create<double>(std::numeric_limits<double>::infinity())
           .toJson(DOUBLE()),
-      "\"Infinity\"");
+      R"("Infinity")");
 
   // NaN
-  EXPECT_EQ(variant::create<float>(0.0 / 0.0).toJson(REAL()), "\"NaN\"");
-  EXPECT_EQ(variant::create<double>(0.0 / 0.0).toJson(DOUBLE()), "\"NaN\"");
+  EXPECT_EQ(Variant::create<float>(0.0 / 0.0).toJson(REAL()), R"("NaN")");
+  EXPECT_EQ(Variant::create<double>(0.0 / 0.0).toJson(DOUBLE()), R"("NaN")");
 }
 
 TEST(VariantTest, opaqueSerializationNotRegistered) {
   struct opaqueSerializationTestStruct {};
   auto opaqueBeforeRegistration =
-      variant::opaque<opaqueSerializationTestStruct>(
+      Variant::opaque<opaqueSerializationTestStruct>(
           std::make_shared<opaqueSerializationTestStruct>());
   EXPECT_THROW(opaqueBeforeRegistration.serialize(), VeloxException);
 
   OpaqueType::registerSerialization<opaqueSerializationTestStruct>(
       "opaqueSerializationStruct");
 
-  auto opaqueAfterRegistration = variant::opaque<opaqueSerializationTestStruct>(
+  auto opaqueAfterRegistration = Variant::opaque<opaqueSerializationTestStruct>(
       std::make_shared<opaqueSerializationTestStruct>());
   EXPECT_THROW(opaqueAfterRegistration.serialize(), VeloxException);
 }
@@ -380,56 +1367,54 @@ TEST(VariantTest, toJsonRow) {
   auto rowType = ROW({{"c0", DECIMAL(20, 3)}});
   EXPECT_EQ(
       "[123456.789]",
-      variant::row({static_cast<int128_t>(123456789)}).toJson(rowType));
+      Variant::row({static_cast<int128_t>(123456789)}).toJson(rowType));
 
   rowType = ROW({{"c0", DECIMAL(10, 2)}});
-  EXPECT_EQ("[12345.67]", variant::row({1234567LL}).toJson(rowType));
+  EXPECT_EQ("[12345.67]", Variant::row({1234567LL}).toJson(rowType));
 
   rowType = ROW({{"c0", DECIMAL(20, 1)}, {"c1", BOOLEAN()}, {"c3", VARCHAR()}});
   EXPECT_EQ(
-      "[1234567890.1,true,\"test works fine\"]",
-      variant::row({static_cast<int128_t>(12345678901),
-                    variant((bool)true),
-                    variant((std::string) "test works fine")})
+      R"([1234567890.1,true,"test works fine"])",
+      Variant::row({static_cast<int128_t>(12345678901),
+                    Variant((bool)true),
+                    Variant((std::string) "test works fine")})
           .toJson(rowType));
 
-  // Row variant tests with wrong type passed to variant::toJson()
+  // Row Variant tests with wrong type passed to Variant::toJson()
   rowType = ROW({{"c0", DECIMAL(10, 3)}});
   VELOX_ASSERT_THROW(
-      variant::row({static_cast<int128_t>(123456789)}).toJson(rowType),
-      "(HUGEINT vs. BIGINT) Wrong type in variant::toJson");
+      Variant::row({static_cast<int128_t>(123456789)}).toJson(rowType),
+      "(HUGEINT vs. BIGINT) Wrong type in Variant::toJson");
 
   rowType = ROW({{"c0", DECIMAL(20, 3)}});
   VELOX_ASSERT_THROW(
-      variant::row({123456789LL}).toJson(rowType),
-      "(BIGINT vs. HUGEINT) Wrong type in variant::toJson");
+      Variant::row({123456789LL}).toJson(rowType),
+      "(BIGINT vs. HUGEINT) Wrong type in Variant::toJson");
   VELOX_ASSERT_THROW(
-      variant::row(
+      Variant::row(
           {static_cast<int128_t>(123456789),
-           variant((
-               std::
-                   string) "test confirms variant child count is greater than expected"),
-           variant((bool)false)})
+           Variant(
+               "test confirms Variant child count is greater than expected"),
+           Variant(false)})
           .toJson(rowType),
-      "(3 vs. 1) Wrong number of fields in a struct in variant::toJson");
+      "(3 vs. 1) Wrong number of fields in a struct in Variant::toJson");
 
   rowType =
       ROW({{"c0", DECIMAL(19, 4)}, {"c1", VARCHAR()}, {"c2", DECIMAL(10, 3)}});
   VELOX_ASSERT_THROW(
-      variant::row(
+      Variant::row(
           {static_cast<int128_t>(12345678912),
-           variant((
-               std::
-                   string) "test confirms variant child count is lesser than expected")})
+           Variant(
+               "test confirms Variant child count is lesser than expected")})
           .toJson(rowType),
-      "(2 vs. 3) Wrong number of fields in a struct in variant::toJson");
+      "(2 vs. 3) Wrong number of fields in a struct in Variant::toJson");
 
-  // Row variant tests that contains NULL variants.
+  // Row Variant tests that contains NULL variants.
   EXPECT_EQ(
       "[null,null,null]",
-      variant::row({variant::null(TypeKind::HUGEINT),
-                    variant::null(TypeKind::VARCHAR),
-                    variant::null(TypeKind::BIGINT)})
+      Variant::row({Variant::null(TypeKind::HUGEINT),
+                    Variant::null(TypeKind::VARCHAR),
+                    Variant::null(TypeKind::BIGINT)})
           .toJson(rowType));
 }
 
@@ -437,63 +1422,62 @@ TEST(VariantTest, toJsonArray) {
   auto arrayType = ARRAY(DECIMAL(9, 2));
   EXPECT_EQ(
       "[1234567.89,6345654.64,2345452.78]",
-      variant::array({123456789LL, 634565464LL, 234545278LL})
+      Variant::array({123456789LL, 634565464LL, 234545278LL})
           .toJson(arrayType));
 
   arrayType = ARRAY(DECIMAL(20, 3));
   EXPECT_EQ(
       "[123456.789,634565.464,234545.278]",
-      variant::array({static_cast<int128_t>(123456789),
+      Variant::array({static_cast<int128_t>(123456789),
                       static_cast<int128_t>(634565464),
                       static_cast<int128_t>(234545278)})
           .toJson(arrayType));
 
   // Array is empty.
-  EXPECT_EQ("[]", variant::array({}).toJson(arrayType));
+  EXPECT_EQ("[]", Variant::array({}).toJson(arrayType));
 
-  // Array variant tests that contains NULL variants.
+  // Array Variant tests that contains NULL variants.
   EXPECT_EQ(
       "[null,null,null]",
-      variant::array({variant::null(TypeKind::HUGEINT),
-                      variant::null(TypeKind::HUGEINT),
-                      variant::null(TypeKind::HUGEINT)})
+      Variant::array({Variant::null(TypeKind::HUGEINT),
+                      Variant::null(TypeKind::HUGEINT),
+                      Variant::null(TypeKind::HUGEINT)})
           .toJson(arrayType));
 }
 
 TEST(VariantTest, toJsonMap) {
   auto mapType = MAP(VARCHAR(), DECIMAL(6, 3));
-  std::map<variant, variant> mapValue = {
-      {(std::string) "key1", 235499LL}, {(std::string) "key2", 123456LL}};
+  std::map<Variant, Variant> mapValue = {
+      {"key1", 235499LL}, {"key2", 123456LL}};
   EXPECT_EQ(
-      "[{\"key\":\"key1\",\"value\":235.499},{\"key\":\"key2\",\"value\":123.456}]",
-      variant::map(mapValue).toJson(mapType));
+      R"([{"key":"key1","value":235.499},{"key":"key2","value":123.456}])",
+      Variant::map(mapValue).toJson(mapType));
 
   mapType = MAP(VARCHAR(), DECIMAL(20, 3));
   mapValue = {
-      {(std::string) "key1", static_cast<int128_t>(45464562323423)},
-      {(std::string) "key2", static_cast<int128_t>(12334581232456)}};
+      {"key1", static_cast<int128_t>(45464562323423)},
+      {"key2", static_cast<int128_t>(12334581232456)}};
   EXPECT_EQ(
-      "[{\"key\":\"key1\",\"value\":45464562323.423},{\"key\":\"key2\",\"value\":12334581232.456}]",
-      variant::map(mapValue).toJson(mapType));
+      R"([{"key":"key1","value":45464562323.423},{"key":"key2","value":12334581232.456}])",
+      Variant::map(mapValue).toJson(mapType));
 
-  // Map variant tests that contains NULL variants.
+  // Map Variant tests that contains NULL variants.
   mapValue = {
-      {variant::null(TypeKind::VARCHAR), variant::null(TypeKind::HUGEINT)}};
+      {Variant::null(TypeKind::VARCHAR), Variant::null(TypeKind::HUGEINT)}};
   EXPECT_EQ(
-      "[{\"key\":null,\"value\":null}]",
-      variant::map(mapValue).toJson(mapType));
+      R"([{"key":null,"value":null}])", Variant::map(mapValue).toJson(mapType));
 }
 
 TEST(VariantTest, typeWithCustomComparison) {
-  auto zero = variant::typeWithCustomComparison<TypeKind::BIGINT>(
+  auto zero = Variant::typeWithCustomComparison<TypeKind::BIGINT>(
       0, test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON());
-  auto one = variant::typeWithCustomComparison<TypeKind::BIGINT>(
+  auto one = Variant::typeWithCustomComparison<TypeKind::BIGINT>(
       1, test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON());
-  auto zeroEquivalent = variant::typeWithCustomComparison<TypeKind::BIGINT>(
+  auto zeroEquivalent = Variant::typeWithCustomComparison<TypeKind::BIGINT>(
       256, test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON());
-  auto oneEquivalent = variant::typeWithCustomComparison<TypeKind::BIGINT>(
+  auto oneEquivalent = Variant::typeWithCustomComparison<TypeKind::BIGINT>(
       257, test::BIGINT_TYPE_WITH_CUSTOM_COMPARISON());
-  auto null = variant::null(TypeKind::BIGINT);
+  auto null = Variant::null(TypeKind::BIGINT);
 
   ASSERT_TRUE(zero.equals(zeroEquivalent));
   ASSERT_TRUE(zero.equalsWithEpsilon(zeroEquivalent));
@@ -536,3 +1520,320 @@ TEST(VariantTest, typeWithCustomComparison) {
   ASSERT_NE(zero.hash(), one.hash());
   ASSERT_NE(zero.hash(), null.hash());
 }
+
+TEST(VariantTest, hashMap) {
+  auto a = Variant::map({{1, 10}, {2, 20}});
+  auto b = Variant::map({{1, 20}, {2, 10}});
+  auto c = Variant::map({{2, 20}, {1, 10}});
+  auto d = Variant::map({{1, 10}, {2, 20}, {3, 30}});
+
+  ASSERT_NE(a.hash(), b.hash());
+  ASSERT_EQ(a.hash(), c.hash());
+  ASSERT_NE(a.hash(), d.hash());
+}
+
+TEST(VariantTest, toString) {
+  EXPECT_EQ(Variant::array({1, 2, 3}).toString(ARRAY(INTEGER())), "[1,2,3]");
+  EXPECT_EQ(
+      Variant::map({{1, 2}, {3, 4}}).toString(MAP(INTEGER(), INTEGER())),
+      R"([{"key":1,"value":2},{"key":3,"value":4}])");
+  EXPECT_EQ(
+      Variant::row({1, 2, 3}).toString(ROW({INTEGER(), INTEGER(), INTEGER()})),
+      "[1,2,3]");
+}
+
+template <typename T>
+void testPrimitiveGetter(T v) {
+  auto value = Variant(v);
+  EXPECT_FALSE(value.isNull());
+  EXPECT_EQ(value.value<T>(), value);
+}
+
+TEST(VariantTest, primitiveGetters) {
+  testPrimitiveGetter<bool>(true);
+  testPrimitiveGetter<int32_t>(10);
+  testPrimitiveGetter<int64_t>(10);
+  testPrimitiveGetter<float>(1.2);
+  testPrimitiveGetter<double>(1.2);
+}
+
+template <typename T>
+void testArrayGetter(const std::vector<T>& inputs) {
+  std::vector<Variant> variants;
+  variants.reserve(inputs.size());
+  for (const auto& v : inputs) {
+    variants.emplace_back(v);
+  }
+
+  auto value = Variant::array(variants);
+
+  EXPECT_FALSE(value.isNull());
+
+  {
+    auto variantItems = value.array();
+    EXPECT_EQ(variantItems.size(), inputs.size());
+    for (auto i = 0; i < inputs.size(); ++i) {
+      EXPECT_FALSE(variantItems.at(i).isNull());
+      EXPECT_EQ(variantItems.at(i).template value<T>(), inputs.at(i));
+    }
+  }
+
+  {
+    auto primitiveItems = value.template array<T>();
+    EXPECT_EQ(primitiveItems, inputs);
+  }
+
+  {
+    auto primitiveItems = value.template nullableArray<T>();
+    EXPECT_EQ(primitiveItems.size(), inputs.size());
+    for (auto i = 0; i < inputs.size(); ++i) {
+      EXPECT_TRUE(primitiveItems.at(i).has_value());
+      EXPECT_EQ(primitiveItems.at(i).value(), inputs.at(i));
+    }
+  }
+}
+
+template <typename T>
+void testNullableArrayGetter(const std::vector<std::optional<T>>& inputs) {
+  std::vector<Variant> variants;
+  variants.reserve(inputs.size());
+  for (const auto& v : inputs) {
+    if (v.has_value()) {
+      variants.emplace_back(v.value());
+    } else {
+      variants.emplace_back(Variant::null(CppToType<T>::typeKind));
+    }
+  }
+
+  auto value = Variant::array(variants);
+  EXPECT_FALSE(value.isNull());
+
+  auto primitiveItems = value.template nullableArray<T>();
+  EXPECT_EQ(primitiveItems, inputs);
+}
+
+TEST(VariantTest, arrayGetter) {
+  testArrayGetter<bool>({true, false, true});
+  testArrayGetter<int32_t>({1, 2, 3});
+  testArrayGetter<int64_t>({1, 2, 3});
+  testArrayGetter<float>({1.2, 2.3, 3.4});
+  testArrayGetter<double>({1.2, 2.3, 3.4});
+
+  testNullableArrayGetter<bool>({true, false, std::nullopt});
+  testNullableArrayGetter<int32_t>({1, 2, std::nullopt, 4});
+  testNullableArrayGetter<int64_t>({1, 2, std::nullopt, 4});
+  testNullableArrayGetter<float>({1.1, 2.2, std::nullopt});
+  testNullableArrayGetter<double>({1.1, 2.2, std::nullopt});
+}
+
+template <typename K, typename V>
+void testMapGetter(const std::map<K, V>& inputs) {
+  std::map<Variant, Variant> variants;
+  for (const auto& [k, v] : inputs) {
+    variants.emplace(k, v);
+  }
+
+  auto value = Variant::map(variants);
+
+  EXPECT_FALSE(value.isNull());
+
+  {
+    auto variantItems = value.map();
+    EXPECT_EQ(variantItems.size(), inputs.size());
+
+    auto expectedIt = inputs.begin();
+    for (auto it = variantItems.begin(); it != variantItems.end(); it++) {
+      auto [k, v] = *it;
+
+      EXPECT_FALSE(k.isNull());
+      EXPECT_FALSE(v.isNull());
+      EXPECT_EQ(k.template value<K>(), (*expectedIt).first);
+      EXPECT_EQ(v.template value<V>(), (*expectedIt).second);
+      expectedIt++;
+    }
+  }
+
+  {
+    auto primitiveItems = value.template map<K, V>();
+    EXPECT_EQ(primitiveItems, inputs);
+  }
+
+  {
+    auto primitiveItems = value.template nullableMap<K, V>();
+    EXPECT_EQ(primitiveItems.size(), inputs.size());
+
+    auto expectedIt = inputs.begin();
+    for (auto it = primitiveItems.begin(); it != primitiveItems.end(); it++) {
+      auto [k, v] = *it;
+
+      EXPECT_TRUE(v.has_value());
+      EXPECT_EQ(k, (*expectedIt).first);
+      EXPECT_EQ(v.value(), (*expectedIt).second);
+      expectedIt++;
+    }
+  }
+}
+
+template <typename K, typename V>
+void testNullableMapGetter(const std::map<K, std::optional<V>>& inputs) {
+  std::map<Variant, Variant> variants;
+  for (const auto& [k, v] : inputs) {
+    if (v.has_value()) {
+      variants.emplace(k, v.value());
+    } else {
+      variants.emplace(k, Variant::null(CppToType<V>::typeKind));
+    }
+  }
+
+  auto value = Variant::map(variants);
+  EXPECT_FALSE(value.isNull());
+
+  auto primitiveItems = value.template nullableMap<K, V>();
+  EXPECT_EQ(primitiveItems, inputs);
+}
+
+TEST(VariantTest, mapGetter) {
+  testMapGetter<int32_t, float>({{1, 1.2}, {2, 2.3}, {3, 3.4}});
+  testMapGetter<int8_t, double>({{1, 1.2}, {2, 2.3}, {3, 3.4}});
+
+  testNullableMapGetter<int32_t, float>(
+      {{1, 1.2}, {2, std::nullopt}, {3, 3.4}});
+  testNullableMapGetter<int8_t, double>(
+      {{1, 1.2}, {2, 2.3}, {3, std::nullopt}});
+}
+
+template <typename T>
+void testArrayOfArraysGetter(const std::vector<std::vector<T>>& inputs) {
+  std::vector<Variant> variants;
+  variants.reserve(inputs.size());
+
+  for (const auto& input : inputs) {
+    std::vector<Variant> innerVariants;
+    innerVariants.reserve(input.size());
+    for (const auto& v : input) {
+      innerVariants.emplace_back(v);
+    }
+    variants.emplace_back(Variant::array(innerVariants));
+  }
+
+  auto value = Variant::array(variants);
+  EXPECT_FALSE(value.isNull());
+
+  {
+    auto primitiveItems = value.template arrayOfArrays<T>();
+    EXPECT_EQ(primitiveItems, inputs);
+  }
+}
+
+TEST(VariantTest, arrayOfArraysGetter) {
+  testArrayOfArraysGetter<int32_t>({{1, 2}, {3, 4, 5}, {}});
+  testArrayOfArraysGetter<double>({{1.1, 2.2}, {}, {3.3}});
+}
+
+template <typename K, typename V>
+void testMapOfArraysGetter(const std::map<K, std::vector<V>>& inputs) {
+  std::map<Variant, Variant> variants;
+
+  for (const auto& [k, input] : inputs) {
+    std::vector<Variant> innerVariants;
+    innerVariants.reserve(input.size());
+    for (const auto& v : input) {
+      innerVariants.emplace_back(v);
+    }
+    variants.emplace(k, Variant::array(innerVariants));
+  }
+
+  auto value = Variant::map(variants);
+  EXPECT_FALSE(value.isNull());
+
+  {
+    auto primitiveItems = value.template mapOfArrays<K, V>();
+    EXPECT_EQ(primitiveItems, inputs);
+  }
+}
+
+TEST(VariantTest, mapOfArraysGetter) {
+  testMapOfArraysGetter<int32_t, float>(
+      {{1, {1.1f, 2.2f}}, {2, {3.3f}}, {3, {}}});
+  testMapOfArraysGetter<std::string, int64_t>(
+      {{"a", {1, 2}}, {"b", {}}, {"c", {3}}});
+}
+
+template <typename T>
+void testNullableArrayOfArraysGetter(
+    const std::vector<std::optional<std::vector<std::optional<T>>>>& inputs) {
+  std::vector<Variant> variants;
+  variants.reserve(inputs.size());
+  for (const auto& arrOpt : inputs) {
+    if (!arrOpt.has_value()) {
+      variants.emplace_back(Variant::null(TypeKind::ARRAY));
+    } else {
+      std::vector<Variant> innerVariants;
+      innerVariants.reserve(arrOpt->size());
+      for (const auto& vOpt : *arrOpt) {
+        if (vOpt.has_value()) {
+          innerVariants.emplace_back(*vOpt);
+        } else {
+          innerVariants.emplace_back(Variant::null(CppToType<T>::typeKind));
+        }
+      }
+      variants.emplace_back(Variant::array(innerVariants));
+    }
+  }
+  auto value = Variant::array(variants);
+  EXPECT_FALSE(value.isNull());
+  auto primitiveItems = value.template nullableArrayOfArrays<T>();
+  EXPECT_EQ(primitiveItems, inputs);
+}
+
+TEST(VariantTest, nullableArrayOfArraysGetter) {
+  testNullableArrayOfArraysGetter<int32_t>(
+      {std::nullopt,
+       std::vector<std::optional<int32_t>>{1, std::nullopt, 3},
+       std::vector<std::optional<int32_t>>{},
+       std::vector<std::optional<int32_t>>{std::nullopt, 2}});
+  testNullableArrayOfArraysGetter<double>(
+      {std::vector<std::optional<double>>{1.1, std::nullopt},
+       std::nullopt,
+       std::vector<std::optional<double>>{3.3}});
+}
+
+template <typename K, typename V>
+void testNullableMapOfArraysGetter(
+    const std::map<K, std::optional<std::vector<std::optional<V>>>>& inputs) {
+  std::map<Variant, Variant> variants;
+  for (const auto& [k, arrOpt] : inputs) {
+    if (!arrOpt.has_value()) {
+      variants.emplace(k, Variant::null(TypeKind::ARRAY));
+    } else {
+      std::vector<Variant> innerVariants;
+      innerVariants.reserve(arrOpt->size());
+      for (const auto& vOpt : *arrOpt) {
+        if (vOpt.has_value()) {
+          innerVariants.emplace_back(*vOpt);
+        } else {
+          innerVariants.emplace_back(Variant::null(CppToType<V>::typeKind));
+        }
+      }
+      variants.emplace(k, Variant::array(innerVariants));
+    }
+  }
+  auto value = Variant::map(variants);
+  EXPECT_FALSE(value.isNull());
+  auto primitiveItems = value.template nullableMapOfArrays<K, V>();
+  EXPECT_EQ(primitiveItems, inputs);
+}
+
+TEST(VariantTest, nullableMapOfArraysGetter) {
+  testNullableMapOfArraysGetter<int32_t, float>(
+      {{1, std::nullopt},
+       {2, std::vector<std::optional<float>>{1.1f, std::nullopt}},
+       {3, std::vector<std::optional<float>>{}}});
+  testNullableMapOfArraysGetter<std::string, int64_t>(
+      {{"a", std::vector<std::optional<int64_t>>{1, std::nullopt}},
+       {"b", std::nullopt},
+       {"c", std::vector<std::optional<int64_t>>{3}}});
+}
+
+} // namespace
+} // namespace facebook::velox::test
diff --git a/velox/type/tests/utils/CMakeLists.txt b/velox/type/tests/utils/CMakeLists.txt
index 54a2bced108f..8ed4f644bb1b 100644
--- a/velox/type/tests/utils/CMakeLists.txt
+++ b/velox/type/tests/utils/CMakeLists.txt
@@ -13,6 +13,4 @@
 # limitations under the License.
 add_library(velox_type_test_lib INTERFACE)
 
-target_link_libraries(
-  velox_type_test_lib
-  INTERFACE velox_type)
+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
index 9fc4ea806cfc..baa0c3e188c5 100644
--- a/velox/type/tests/utils/CustomTypesForTesting.h
+++ b/velox/type/tests/utils/CustomTypesForTesting.h
@@ -19,16 +19,15 @@
 
 namespace facebook::velox::test {
 /// A custom type that provides custom comparison and hash functions.
-class BigintTypeWithCustomComparison : public BigintType {
-  BigintTypeWithCustomComparison() : BigintType(true) {}
+class BigintTypeWithCustomComparison final : public BigintType {
+  constexpr BigintTypeWithCustomComparison()
+      : BigintType{ProvideCustomComparison{}} {}
 
  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;
+  static std::shared_ptr<const BigintTypeWithCustomComparison> get() {
+    VELOX_CONSTEXPR_SINGLETON BigintTypeWithCustomComparison kInstance;
+    return {
+        std::shared_ptr<const BigintTypeWithCustomComparison>{}, &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -55,11 +54,6 @@ class BigintTypeWithCustomComparison : public BigintType {
     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();
   }
@@ -79,17 +73,16 @@ BIGINT_TYPE_WITH_CUSTOM_COMPARISON() {
 
 /// 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) {}
+class BigintTypeWithInvalidCustomComparison final : public BigintType {
+  constexpr BigintTypeWithInvalidCustomComparison()
+      : BigintType{ProvideCustomComparison{}} {}
 
  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;
+  static std::shared_ptr<const BigintTypeWithInvalidCustomComparison> get() {
+    VELOX_CONSTEXPR_SINGLETON BigintTypeWithInvalidCustomComparison kInstance;
+    return {
+        std::shared_ptr<const BigintTypeWithInvalidCustomComparison>{},
+        &kInstance};
   }
 
   bool equivalent(const Type& other) const override {
@@ -101,11 +94,6 @@ class BigintTypeWithInvalidCustomComparison : public BigintType {
     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();
   }
@@ -124,56 +112,6 @@ BIGINT_TYPE_WITH_INVALID_CUSTOM_COMPARISON() {
 }
 
 /// 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;
-  }
-
-  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();
-}
+/// hash functions. This is not currently supported and it is checked in compile
+/// time (static_assert).
 } // namespace facebook::velox::test
diff --git a/velox/type/tz/CMakeLists.txt b/velox/type/tz/CMakeLists.txt
index 9f474a9cddc3..b1d16071aab0 100644
--- a/velox/type/tz/CMakeLists.txt
+++ b/velox/type/tz/CMakeLists.txt
@@ -21,12 +21,7 @@ velox_add_library(
   TimeZoneLinks.cpp
   TimeZoneMap.cpp
   TimeZoneNames.h
-  TimeZoneNames.cpp)
+  TimeZoneNames.cpp
+)
 
-velox_link_libraries(
-  velox_type_tz
-  velox_exception
-  velox_external_tzdb
-  Boost::regex
-  fmt::fmt
-  Folly::folly)
+velox_link_libraries(velox_type_tz velox_exception velox_external_tzdb fmt::fmt Folly::folly)
diff --git a/velox/type/tz/GenTimeZoneNames.java b/velox/type/tz/GenTimeZoneNames.java
index e275e677d6cb..d7e89e25ebd7 100644
--- a/velox/type/tz/GenTimeZoneNames.java
+++ b/velox/type/tz/GenTimeZoneNames.java
@@ -43,7 +43,7 @@ public static void main(String[] args) {
     System.out.println("//");
     System.out.println("// Use the version of Java with which you're running Presto to generate");
     System.out.println("// compatible names. This version was generated using openjdk version ");
-    System.out.println("// \"1.8.0_362\"");
+    System.out.println("// \"17.0.2\"");
     System.out.println("// @generated");
     System.out.println("");
     System.out.println("#include \"velox/type/tz/TimeZoneNames.h\"");
diff --git a/velox/type/tz/TimeZoneMap.cpp b/velox/type/tz/TimeZoneMap.cpp
index 2240f9aea8f6..88528f9a0122 100644
--- a/velox/type/tz/TimeZoneMap.cpp
+++ b/velox/type/tz/TimeZoneMap.cpp
@@ -38,7 +38,6 @@ using TTimeZoneIndex = folly::F14FastMap<std::string, const TimeZone*>;
 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) {
diff --git a/velox/type/tz/TimeZoneMap.h b/velox/type/tz/TimeZoneMap.h
index ba9eccc0c46b..957031d64a6d 100644
--- a/velox/type/tz/TimeZoneMap.h
+++ b/velox/type/tz/TimeZoneMap.h
@@ -17,6 +17,7 @@
 #pragma once
 
 #include <chrono>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -167,6 +168,15 @@ class TimeZone {
     return tz_;
   }
 
+  /// Returns the fixed offset for offset-based time zones (e.g., "+05:30").
+  /// Returns std::nullopt for time zones with a tzdb::time_zone pointer.
+  std::optional<std::chrono::minutes> offset() const {
+    if (tz_ == nullptr) {
+      return offset_;
+    }
+    return std::nullopt;
+  }
+
   /// Returns the short name (abbreviation) of the time zone for the given
   /// timestamp. Note that the timestamp is needed for time zones that support
   /// daylight savings time as the short name will change depending on the date
diff --git a/velox/type/tz/TimeZoneNames.cpp b/velox/type/tz/TimeZoneNames.cpp
index f1e2d22b9314..af3827726618 100644
--- a/velox/type/tz/TimeZoneNames.cpp
+++ b/velox/type/tz/TimeZoneNames.cpp
@@ -21,7 +21,7 @@
 //
 // Use the version of Java with which you're running Presto to generate
 // compatible names. This version was generated using openjdk version
-// "1.8.0_362"
+// "17.0.2"
 // @generated
 
 #include "velox/type/tz/TimeZoneNames.h"
@@ -44,35 +44,23 @@ const std::unordered_map<std::string, TimeZoneNames>& getTimeZoneNames() {
     return std::unordered_map<std::string, TimeZoneNames>{
         {"America/Los_Angeles",
          {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"PST",
-         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
         {"America/Denver",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"MST",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
         {"America/Phoenix",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"PNT",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
         {"America/Chicago",
          {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"CST",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
         {"America/New_York",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"EST",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
         {"America/Indianapolis",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"IET",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
         {"Pacific/Honolulu",
-         {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
-        {"HST", {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
+         {"Hawaii-Aleutian Standard Time",
+          "HST",
+          "Hawaii-Aleutian Daylight Time",
+          "HDT"}},
         {"America/Anchorage",
          {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
-        {"AST",
-         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
         {"America/Halifax",
          {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
         {"America/Sitka",
@@ -82,1639 +70,1729 @@ const std::unordered_map<std::string, TimeZoneNames>& getTimeZoneNames() {
           "NST",
           "Newfoundland Daylight Time",
           "NDT"}},
-        {"CNT",
-         {"Newfoundland Standard Time",
-          "NST",
-          "Newfoundland Daylight Time",
-          "NDT"}},
         {"Europe/Paris",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"ECT",
-         {"Central European Time",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
         {"GMT", {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Casablanca",
-         {"Western European Time",
-          "WET",
-          "Western European Summer Time",
-          "WEST"}},
         {"Asia/Jerusalem",
          {"Israel Standard Time", "IST", "Israel Daylight Time", "IDT"}},
         {"Asia/Tokyo",
          {"Japan Standard Time", "JST", "Japan Daylight Time", "JDT"}},
-        {"JST", {"Japan Standard Time", "JST", "Japan Daylight Time", "JDT"}},
         {"Europe/Bucharest",
-         {"Eastern European Time",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
         {"Asia/Shanghai",
          {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
-        {"CTT", {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
         {"UTC",
          {"Coordinated Universal Time",
           "UTC",
           "Coordinated Universal Time",
           "UTC"}},
         {"ACT",
-         {"Australian Central Standard Time (Northern Territory)",
+         {"Australian Central Standard Time",
           "ACST",
-          "Australian Central Daylight Time (Northern Territory)",
+          "Australian Central Daylight Time",
           "ACDT"}},
         {"AET",
-         {"Australian Eastern Standard Time (New South Wales)",
+         {"Australian Eastern Standard Time",
           "AEST",
-          "Australian Eastern Daylight Time (New South Wales)",
+          "Australian Eastern Daylight Time",
           "AEDT"}},
-        {"AGT", {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
         {"ART",
-         {"Eastern European Time",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Africa/Abidjan",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Accra",
-         {"Ghana Mean Time", "GMT", "Ghana Summer Time", "GHST"}},
-        {"Africa/Addis_Ababa",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Africa/Algiers",
-         {"Central European Time",
+        {"AST",
+         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
+        {"BET",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"BST",
+         {"Bangladesh Standard Time", "BDT", "Bangladesh Summer Time", "BDST"}},
+        {"CAT",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"CNT",
+         {"Newfoundland Standard Time",
+          "NST",
+          "Newfoundland Daylight Time",
+          "NDT"}},
+        {"CST",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"CTT", {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
+        {"EAT",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"ECT",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Africa/Asmara",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Africa/Asmera",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Africa/Bamako",
+        {"JST", {"Japan Standard Time", "JST", "Japan Daylight Time", "JDT"}},
+        {"MIT", {"Apia Standard Time", "WSST", "Apia Daylight Time", "WSDT"}},
+        {"NET",
+         {"Armenia Standard Time", "AMT", "Armenia Summer Time", "AMST"}},
+        {"NST",
+         {"New Zealand Standard Time",
+          "NZST",
+          "New Zealand Daylight Time",
+          "NZDT"}},
+        {"PLT",
+         {"Pakistan Standard Time", "PKT", "Pakistan Summer Time", "PKST"}},
+        {"PNT",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"PRT",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"PST",
+         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
+        {"SST",
+         {"Solomon Islands Time", "SBT", "Solomon Is. Summer Time", "SBST"}},
+        {"CST6CDT",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"EST5EDT",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"Etc/GMT",
          {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Bangui",
-         {"Western African Time",
-          "WAT",
-          "Western African Summer Time",
-          "WAST"}},
-        {"Africa/Banjul",
+        {"Etc/UTC",
+         {"Coordinated Universal Time",
+          "UTC",
+          "Coordinated Universal Time",
+          "UTC"}},
+        {"MST7MDT",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"PST8PDT",
+         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
+        {"Asia/Aden",
+         {"Arabian Standard Time", "AST", "Arabian Daylight Time", "ADT"}},
+        {"Asia/Baku",
+         {"Azerbaijan Standard Time", "AZT", "Azerbaijan Summer Time", "AZST"}},
+        {"Asia/Dili",
+         {"East Timor Time", "TLT", "Timor-Leste Summer Time", "TLST"}},
+        {"Asia/Gaza",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Asia/Hovd",
+         {"Hovd Standard Time", "HOVT", "Hovd Summer Time", "HOVST"}},
+        {"Asia/Omsk",
+         {"Omsk Standard Time", "OMST", "Omsk Summer Time", "OMSST"}},
+        {"Asia/Oral",
+         {"West Kazakhstan Time", "ORAT", "Oral Summer Time", "ORAST"}},
+        {"Asia/Amman",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Asia/Aqtau",
+         {"West Kazakhstan Time", "AQTT", "Aqtau Summer Time", "AQTST"}},
+        {"Asia/Chita",
+         {"Yakutsk Standard Time", "YAKT", "Yakutsk Summer Time", "YAKST"}},
+        {"Asia/Dhaka",
+         {"Bangladesh Standard Time", "BDT", "Bangladesh Summer Time", "BDST"}},
+        {"Asia/Dubai",
+         {"Gulf Standard Time", "GST", "Gulf Daylight Time", "GDT"}},
+        {"Asia/Kabul",
+         {"Afghanistan Time", "AFT", "Afghanistan Summer Time", "AFST"}},
+        {"Asia/Macau",
+         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
+        {"Asia/Qatar",
+         {"Arabian Standard Time", "AST", "Arabian Daylight Time", "ADT"}},
+        {"Asia/Seoul",
+         {"Korean Standard Time", "KST", "Korean Daylight Time", "KDT"}},
+        {"Africa/Juba",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"Africa/Lome",
          {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Bissau",
+        {"Asia/Almaty",
+         {"East Kazakhstan Time", "ALMT", "Alma-Ata Summer Time", "ALMST"}},
+        {"Asia/Anadyr",
+         {"Anadyr Standard Time", "ANAT", "Anadyr Summer Time", "ANAST"}},
+        {"Asia/Aqtobe",
+         {"West Kazakhstan Time", "AQTT", "Aqtobe Summer Time", "AQTST"}},
+        {"Asia/Atyrau",
+         {"West Kazakhstan Time",
+          "GMT+05:00",
+          "Atyrau Daylight Time",
+          "GMT+05:00"}},
+        {"Asia/Beirut",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Asia/Brunei",
+         {"Brunei Darussalam Time", "BNT", "Brunei Summer Time", "BNST"}},
+        {"Asia/Harbin",
+         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
+        {"Asia/Hebron",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Asia/Kuwait",
+         {"Arabian Standard Time", "AST", "Arabian Daylight Time", "ADT"}},
+        {"Asia/Manila",
+         {"Philippine Standard Time", "PST", "Philippine Summer Time", "PDT"}},
+        {"Asia/Muscat",
+         {"Gulf Standard Time", "GST", "Gulf Daylight Time", "GDT"}},
+        {"Asia/Riyadh",
+         {"Arabian Standard Time", "AST", "Arabian Daylight Time", "ADT"}},
+        {"Asia/Saigon",
+         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
+        {"Asia/Taipei",
+         {"Taipei Standard Time", "CST", "Taipei Daylight Time", "CDT"}},
+        {"Asia/Tehran",
+         {"Iran Standard Time", "IRST", "Iran Daylight Time", "IRDT"}},
+        {"Europe/Kiev",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Europe/Oslo",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Riga",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Europe/Rome",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Indian/Mahe",
+         {"Seychelles Time", "SCT", "Seychelles Summer Time", "SCST"}},
+        {"Pacific/Yap", {"Chuuk Time", "CHUT", "Chuuk Summer Time", "CHUST"}},
+        {"Africa/Accra",
+         {"Greenwich Mean Time", "GMT", "Ghana Summer Time", "GHST"}},
+        {"Africa/Cairo",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Africa/Ceuta",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Africa/Dakar",
          {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Blantyre",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
-        {"Africa/Brazzaville",
-         {"Western African Time",
+        {"Africa/Lagos",
+         {"West Africa Standard Time",
           "WAT",
-          "Western African Summer Time",
+          "West Africa Summer Time",
           "WAST"}},
-        {"Africa/Bujumbura",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
-        {"Africa/Cairo",
-         {"Eastern European Time",
+        {"Africa/Tunis",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"America/Adak",
+         {"Hawaii-Aleutian Standard Time",
+          "HAST",
+          "Hawaii-Aleutian Daylight Time",
+          "HADT"}},
+        {"America/Lima",
+         {"Peru Standard Time", "PET", "Peru Summer Time", "PEST"}},
+        {"America/Nome",
+         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
+        {"Asia/Baghdad",
+         {"Arabian Standard Time", "AST", "Arabian Daylight Time", "ADT"}},
+        {"Asia/Bahrain",
+         {"Arabian Standard Time", "AST", "Arabian Daylight Time", "ADT"}},
+        {"Asia/Bangkok",
+         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
+        {"Asia/Bishkek",
+         {"Kyrgyzstan Time", "KGT", "Kirgizstan Summer Time", "KGST"}},
+        {"Asia/Colombo",
+         {"India Standard Time", "IST", "India Daylight Time", "IDT"}},
+        {"Asia/Irkutsk",
+         {"Irkutsk Standard Time", "IRKT", "Irkutsk Summer Time", "IRKST"}},
+        {"Asia/Jakarta",
+         {"Western Indonesia Time",
+          "WIB",
+          "West Indonesia Summer Time",
+          "WIST"}},
+        {"Asia/Karachi",
+         {"Pakistan Standard Time", "PKT", "Pakistan Summer Time", "PKST"}},
+        {"Asia/Kuching",
+         {"Malaysia Time", "MYT", "Malaysia Summer Time", "MYST"}},
+        {"Asia/Magadan",
+         {"Magadan Standard Time", "MAGT", "Magadan Summer Time", "MAGST"}},
+        {"Asia/Nicosia",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Africa/Ceuta",
-         {"Central European Time",
+        {"Asia/Rangoon",
+         {"Myanmar Time", "MMT", "Myanmar Summer Time", "MMST"}},
+        {"Asia/Tbilisi",
+         {"Georgia Standard Time", "GET", "Georgia Summer Time", "GEST"}},
+        {"Asia/Thimphu", {"Bhutan Time", "BTT", "Bhutan Summer Time", "BTST"}},
+        {"Asia/Yakutsk",
+         {"Yakutsk Standard Time", "YAKT", "Yakutsk Summer Time", "YAKST"}},
+        {"Asia/Yerevan",
+         {"Armenia Standard Time", "AMT", "Armenia Summer Time", "AMST"}},
+        {"Europe/Malta",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Africa/Conakry",
+        {"Europe/Minsk",
+         {"Moscow Standard Time", "MSK", "Moscow Summer Time", "MSD"}},
+        {"Europe/Sofia",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Europe/Vaduz",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Indian/Cocos",
+         {"Cocos Islands Time", "CCT", "Cocos Islands Summer Time", "CCST"}},
+        {"Pacific/Apia",
+         {"Apia Standard Time", "WSST", "Apia Daylight Time", "WSDT"}},
+        {"Pacific/Fiji",
+         {"Fiji Standard Time", "FJT", "Fiji Summer Time", "FJST"}},
+        {"Pacific/Guam",
+         {"Chamorro Standard Time", "ChST", "Chamorro Daylight Time", "ChDT"}},
+        {"Pacific/Niue", {"Niue Time", "NUT", "Niue Summer Time", "NUST"}},
+        {"Pacific/Truk", {"Chuuk Time", "CHUT", "Chuuk Summer Time", "CHUST"}},
+        {"Pacific/Wake",
+         {"Wake Island Time", "WAKT", "Wake Summer Time", "WAKST"}},
+        {"SystemV/AST4",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"SystemV/CST6",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"SystemV/EST5",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"SystemV/MST7",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"SystemV/PST8",
+         {"Pitcairn Time", "PST", "Pacific Daylight Time", "PDT"}},
+        {"SystemV/YST9",
+         {"Gambier Time", "AKST", "Alaska Daylight Time", "AKDT"}},
+        {"Africa/Asmera",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"Africa/Bamako",
          {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Dakar",
+        {"Africa/Bangui",
+         {"West Africa Standard Time",
+          "WAT",
+          "West Africa Summer Time",
+          "WAST"}},
+        {"Africa/Banjul",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Africa/Bissau",
          {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Dar_es_Salaam",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Africa/Djibouti",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
         {"Africa/Douala",
-         {"Western African Time",
+         {"West Africa Standard Time",
           "WAT",
-          "Western African Summer Time",
+          "West Africa Summer Time",
           "WAST"}},
-        {"Africa/El_Aaiun",
-         {"Western European Time",
-          "WET",
-          "Western European Summer Time",
-          "WEST"}},
-        {"Africa/Freetown",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Gaborone",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
         {"Africa/Harare",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
-        {"Africa/Johannesburg",
-         {"South Africa Standard Time",
-          "SAST",
-          "South Africa Summer Time",
-          "SAST"}},
-        {"Africa/Juba",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
-        {"Africa/Kampala",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Africa/Khartoum",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
         {"Africa/Kigali",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
-        {"Africa/Kinshasa",
-         {"Western African Time",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"Africa/Luanda",
+         {"West Africa Standard Time",
           "WAT",
-          "Western African Summer Time",
+          "West Africa Summer Time",
           "WAST"}},
-        {"Africa/Lagos",
-         {"Western African Time",
+        {"Africa/Lusaka",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"Africa/Malabo",
+         {"West Africa Standard Time",
           "WAT",
-          "Western African Summer Time",
-          "WAST"}},
-        {"Africa/Libreville",
-         {"Western African Time",
-          "WAT",
-          "Western African Summer Time",
-          "WAST"}},
-        {"Africa/Lome",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Luanda",
-         {"Western African Time",
-          "WAT",
-          "Western African Summer Time",
-          "WAST"}},
-        {"Africa/Lubumbashi",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
-        {"Africa/Lusaka",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
-        {"Africa/Malabo",
-         {"Western African Time",
-          "WAT",
-          "Western African Summer Time",
+          "West Africa Summer Time",
           "WAST"}},
         {"Africa/Maputo",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
         {"Africa/Maseru",
          {"South Africa Standard Time",
           "SAST",
           "South Africa Summer Time",
           "SAST"}},
+        {"Africa/Niamey",
+         {"West Africa Standard Time",
+          "WAT",
+          "West Africa Summer Time",
+          "WAST"}},
+        {"America/Aruba",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Bahia",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"America/Belem",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"America/Boise",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"America/Jujuy",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Thule",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"Asia/Ashgabat",
+         {"Turkmenistan Standard Time",
+          "TMT",
+          "Turkmenistan Summer Time",
+          "TMST"}},
+        {"Asia/Calcutta",
+         {"India Standard Time", "IST", "India Daylight Time", "IDT"}},
+        {"Asia/Damascus",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Asia/Dushanbe",
+         {"Tajikistan Time", "TJT", "Tajikistan Summer Time", "TJST"}},
+        {"Asia/Jayapura",
+         {"Eastern Indonesia Time",
+          "WIT",
+          "East Indonesia Summer Time",
+          "EIST"}},
+        {"Asia/Katmandu", {"Nepal Time", "NPT", "Nepal Summer Time", "NPST"}},
+        {"Asia/Khandyga",
+         {"Yakutsk Standard Time", "YAKT", "Yakutsk Summer Time", "YAKST"}},
+        {"Asia/Makassar",
+         {"Central Indonesia Time",
+          "WITA",
+          "Central Indonesia Summer Time",
+          "CIST"}},
+        {"Asia/Qostanay",
+         {"East Kazakhstan Time", "QOST", "Kostanay Summer Time", "QOSST"}},
+        {"Asia/Sakhalin",
+         {"Sakhalin Standard Time", "SAKT", "Sakhalin Summer Time", "SAKST"}},
+        {"Asia/Tashkent",
+         {"Uzbekistan Standard Time", "UZT", "Uzbekistan Summer Time", "UZST"}},
+        {"Asia/Ust-Nera",
+         {"Vladivostok Standard Time",
+          "VLAT",
+          "Vladivostok Summer Time",
+          "VLAST"}},
+        {"Europe/Athens",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Europe/Berlin",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Dublin",
+         {"Greenwich Mean Time", "GMT", "Irish Standard Time", "IST"}},
+        {"Europe/Jersey",
+         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
+        {"Europe/Lisbon",
+         {"Western European Standard Time",
+          "WET",
+          "Western European Summer Time",
+          "WEST"}},
+        {"Europe/London",
+         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
+        {"Europe/Madrid",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Monaco",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Moscow",
+         {"Moscow Standard Time", "MSK", "Moscow Summer Time", "MSD"}},
+        {"Europe/Prague",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Samara",
+         {"Samara Standard Time", "SAMT", "Samara Summer Time", "SAMST"}},
+        {"Europe/Skopje",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Tirane",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Vienna",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Warsaw",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Zagreb",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Zurich",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Indian/Chagos",
+         {"Indian Ocean Time",
+          "IOT",
+          "Indian Ocean Territory Summer Time",
+          "IOST"}},
+        {"Indian/Comoro",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"Pacific/Efate",
+         {"Vanuatu Standard Time", "VUT", "Vanuatu Summer Time", "VUST"}},
+        {"Pacific/Nauru", {"Nauru Time", "NRT", "Nauru Summer Time", "NRST"}},
+        {"Pacific/Palau", {"Palau Time", "PWT", "Palau Summer Time", "PWST"}},
+        {"SystemV/HST10",
+         {"Hawaii-Aleutian Standard Time",
+          "HST",
+          "Hawaii-Aleutian Daylight Time",
+          "HDT"}},
+        {"Africa/Abidjan",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Africa/Algiers",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Africa/Conakry",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Africa/Kampala",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
         {"Africa/Mbabane",
          {"South Africa Standard Time",
           "SAST",
           "South Africa Summer Time",
           "SAST"}},
-        {"Africa/Mogadishu",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Africa/Monrovia",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
         {"Africa/Nairobi",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Africa/Ndjamena",
-         {"Western African Time",
-          "WAT",
-          "Western African Summer Time",
-          "WAST"}},
-        {"Africa/Niamey",
-         {"Western African Time",
-          "WAT",
-          "Western African Summer Time",
-          "WAST"}},
-        {"Africa/Nouakchott",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Ouagadougou",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Porto-Novo",
-         {"Western African Time",
-          "WAT",
-          "Western African Summer Time",
-          "WAST"}},
-        {"Africa/Sao_Tome",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Africa/Timbuktu",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
         {"Africa/Tripoli",
-         {"Eastern European Time",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Africa/Tunis",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Africa/Windhoek",
-         {"Central African Time", "CAT", "Western African Time", "WAT"}},
-        {"America/Adak",
-         {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
-        {"America/Anguilla",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Antigua",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Araguaina",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
-        {"America/Argentina/Buenos_Aires",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/Catamarca",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/ComodRivadavia",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/Cordoba",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/Jujuy",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/La_Rioja",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/Mendoza",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/Rio_Gallegos",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/Salta",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/San_Juan",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/San_Luis",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/Tucuman",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Argentina/Ushuaia",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Aruba",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Asuncion",
-         {"Paraguay Time", "PYT", "Paraguay Summer Time", "PYST"}},
-        {"America/Atikokan",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Atka",
-         {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
-        {"America/Bahia",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
-        {"America/Bahia_Banderas",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Barbados",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Belem",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
         {"America/Belize",
          {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Blanc-Sablon",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Boa_Vista",
-         {"Amazon Time", "AMT", "Amazon Summer Time", "AMST"}},
         {"America/Bogota",
-         {"Colombia Time", "COT", "Colombia Summer Time", "COST"}},
-        {"America/Boise",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Buenos_Aires",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Cambridge_Bay",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Campo_Grande",
-         {"Amazon Time", "AMT", "Amazon Summer Time", "AMST"}},
+         {"Colombia Standard Time", "COT", "Colombia Summer Time", "COST"}},
         {"America/Cancun",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Caracas",
-         {"Venezuela Time", "VET", "Venezuela Summer Time", "VEST"}},
-        {"America/Catamarca",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Cayenne",
-         {"French Guiana Time", "GFT", "French Guiana Summer Time", "GFST"}},
         {"America/Cayman",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Chihuahua",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Ciudad_Juarez",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Creston",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Coral_Harbour",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Cordoba",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Costa_Rica",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
         {"America/Cuiaba",
-         {"Amazon Time", "AMT", "Amazon Summer Time", "AMST"}},
-        {"America/Curacao",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Danmarkshavn",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+         {"Amazon Standard Time", "AMT", "Amazon Summer Time", "AMST"}},
         {"America/Dawson",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Dawson_Creek",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Detroit",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Dominica",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Edmonton",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Eirunepe", {"Acre Time", "ACT", "Acre Summer Time", "ACST"}},
-        {"America/El_Salvador",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Ensenada",
-         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"America/Fort_Nelson",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Fort_Wayne",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Fortaleza",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
-        {"America/Glace_Bay",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Godthab",
-         {"Western Greenland Time",
-          "WGT",
-          "Western Greenland Summer Time",
-          "WGST"}},
-        {"America/Goose_Bay",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Grand_Turk",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Grenada",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Guadeloupe",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Guatemala",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Guayaquil",
-         {"Ecuador Time", "ECT", "Ecuador Summer Time", "ECST"}},
         {"America/Guyana",
          {"Guyana Time", "GYT", "Guyana Summer Time", "GYST"}},
         {"America/Havana",
          {"Cuba Standard Time", "CST", "Cuba Daylight Time", "CDT"}},
-        {"America/Hermosillo",
+        {"America/Inuvik",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Indiana/Indianapolis",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Indiana/Knox",
+        {"America/Juneau",
+         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
+        {"America/La_Paz",
+         {"Bolivia Time", "BOT", "Bolivia Summer Time", "BOST"}},
+        {"America/Maceio",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"America/Manaus",
+         {"Amazon Standard Time", "AMT", "Amazon Summer Time", "AMST"}},
+        {"America/Merida",
          {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Indiana/Marengo",
+        {"America/Nassau",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Indiana/Petersburg",
+        {"America/Panama",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Indiana/Tell_City",
+        {"America/Recife",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"America/Regina",
          {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Indiana/Vevay",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Indiana/Vincennes",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Indiana/Winamac",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Inuvik",
+        {"Asia/Chongqing",
+         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
+        {"Asia/Hong_Kong",
+         {"Hong Kong Standard Time", "HKT", "Hong Kong Summer Time", "HKST"}},
+        {"Asia/Kamchatka",
+         {"Petropavlovsk-Kamchatski Standard Time",
+          "PETT",
+          "Petropavlovsk-Kamchatski Summer Time",
+          "PETST"}},
+        {"Asia/Pontianak",
+         {"Western Indonesia Time",
+          "WIB",
+          "West Indonesia Summer Time",
+          "WIST"}},
+        {"Asia/Pyongyang",
+         {"Korean Standard Time", "KST", "Korean Daylight Time", "KDT"}},
+        {"Asia/Qyzylorda",
+         {"West Kazakhstan Time", "QYZT", "Qyzylorda Summer Time", "QYZST"}},
+        {"Asia/Samarkand",
+         {"Uzbekistan Standard Time", "UZT", "Uzbekistan Summer Time", "UZST"}},
+        {"Asia/Singapore",
+         {"Singapore Standard Time", "SGT", "Singapore Summer Time", "SGST"}},
+        {"Asia/Vientiane",
+         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
+        {"Europe/Andorra",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Belfast",
+         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
+        {"Europe/Tallinn",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Europe/Vatican",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Vilnius",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Indian/Mayotte",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"Indian/Reunion",
+         {"Réunion Time", "RET", "Reunion Summer Time", "REST"}},
+        {"Pacific/Easter",
+         {"Easter Island Standard Time",
+          "EAST",
+          "Easter Island Summer Time",
+          "EASST"}},
+        {"Pacific/Kosrae",
+         {"Kosrae Time", "KOST", "Kosrae Summer Time", "KOSST"}},
+        {"Pacific/Majuro",
+         {"Marshall Islands Time",
+          "MHT",
+          "Marshall Islands Summer Time",
+          "MHST"}},
+        {"Pacific/Midway",
+         {"Samoa Standard Time", "SST", "Samoa Daylight Time", "SDT"}},
+        {"Pacific/Noumea",
+         {"New Caledonia Standard Time",
+          "NCT",
+          "New Caledonia Summer Time",
+          "NCST"}},
+        {"Pacific/Ponape",
+         {"Ponape Time", "PONT", "Pohnpei Summer Time", "PONST"}},
+        {"Pacific/Saipan",
+         {"Chamorro Standard Time", "ChST", "Chamorro Daylight Time", "ChDT"}},
+        {"Pacific/Tahiti",
+         {"Tahiti Time", "TAHT", "Tahiti Summer Time", "TAHST"}},
+        {"Pacific/Tarawa",
+         {"Gilbert Islands Time", "GILT", "Gilbert Is. Summer Time", "GILST"}},
+        {"Pacific/Wallis",
+         {"Wallis & Futuna Time",
+          "WFT",
+          "Wallis & Futuna Summer Time",
+          "WFST"}},
+        {"Africa/Blantyre",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"Africa/Djibouti",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"Africa/Freetown",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Africa/Gaborone",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"Africa/Khartoum",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"Africa/Kinshasa",
+         {"West Africa Standard Time",
+          "WAT",
+          "West Africa Summer Time",
+          "WAST"}},
+        {"Africa/Monrovia",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Africa/Ndjamena",
+         {"West Africa Standard Time",
+          "WAT",
+          "West Africa Summer Time",
+          "WAST"}},
+        {"Africa/Sao_Tome",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Africa/Timbuktu",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Africa/Windhoek",
+         {"Central Africa Time", "CAT", "Western African Time", "WAT"}},
+        {"America/Antigua",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Caracas",
+         {"Venezuela Time", "VET", "Venezuela Summer Time", "VEST"}},
+        {"America/Cayenne",
+         {"French Guiana Time", "GFT", "French Guiana Summer Time", "GFST"}},
+        {"America/Cordoba",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Creston",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"America/Curacao",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Detroit",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Godthab",
+         {"West Greenland Standard Time",
+          "WGT",
+          "West Greenland Summer Time",
+          "WGST"}},
+        {"America/Grenada",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
         {"America/Iqaluit",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
         {"America/Jamaica",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Jujuy",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Juneau",
-         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
-        {"America/Kentucky/Louisville",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Kentucky/Monticello",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Knox_IN",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Kralendijk",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/La_Paz",
-         {"Bolivia Time", "BOT", "Bolivia Summer Time", "BOST"}},
-        {"America/Lima", {"Peru Time", "PET", "Peru Summer Time", "PEST"}},
-        {"America/Louisville",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Lower_Princes",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Maceio",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
         {"America/Managua",
          {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Manaus",
-         {"Amazon Time", "AMT", "Amazon Summer Time", "AMST"}},
         {"America/Marigot",
          {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Martinique",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Matamoros",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Mazatlan",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
         {"America/Mendoza",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Menominee",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Merida",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Metlakatla",
-         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
-        {"America/Mexico_City",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Miquelon",
-         {"Pierre & Miquelon Standard Time",
-          "PMST",
-          "Pierre & Miquelon Daylight Time",
-          "PMDT"}},
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
         {"America/Moncton",
          {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Montevideo",
-         {"Uruguay Time", "UYT", "Uruguay Summer Time", "UYST"}},
-        {"America/Monterrey",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Montreal",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Montserrat",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Nassau",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
         {"America/Nipigon",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Nome",
-         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
         {"America/Noronha",
-         {"Fernando de Noronha Time",
+         {"Fernando de Noronha Standard Time",
           "FNT",
           "Fernando de Noronha Summer Time",
           "FNST"}},
-        {"America/North_Dakota/Beulah",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/North_Dakota/Center",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/North_Dakota/New_Salem",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Nuuk",
-         {"Western Greenland Time",
-          "WGT",
-          "Western Greenland Summer Time",
-          "WGST"}},
         {"America/Ojinaga",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Panama",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Pangnirtung",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Paramaribo",
-         {"Suriname Time", "SRT", "Suriname Summer Time", "SRST"}},
-        {"America/Port-au-Prince",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"America/Port_of_Spain",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Porto_Acre",
-         {"Acre Time", "ACT", "Acre Summer Time", "ACST"}},
-        {"America/Porto_Velho",
-         {"Amazon Time", "AMT", "Amazon Summer Time", "AMST"}},
-        {"America/Puerto_Rico",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Rainy_River",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Rankin_Inlet",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Recife",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
-        {"America/Regina",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Resolute",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Rio_Branco",
-         {"Acre Time", "ACT", "Acre Summer Time", "ACST"}},
-        {"America/Rosario",
-         {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
-        {"America/Santa_Isabel",
-         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"America/Santarem",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
-        {"America/Santiago",
-         {"Chile Time", "CLT", "Chile Summer Time", "CLST"}},
-        {"America/Santo_Domingo",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Sao_Paulo",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
-        {"America/Scoresbysund",
-         {"Eastern Greenland Time",
-          "EGT",
-          "Eastern Greenland Summer Time",
-          "EGST"}},
-        {"America/Shiprock",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/St_Barthelemy",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/St_Kitts",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/St_Lucia",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/St_Thomas",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/St_Vincent",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Swift_Current",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Tegucigalpa",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"America/Thule",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Thunder_Bay",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
         {"America/Tijuana",
          {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
         {"America/Toronto",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
         {"America/Tortola",
          {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Vancouver",
-         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"America/Virgin",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"America/Whitehorse",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"America/Winnipeg",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
         {"America/Yakutat",
          {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
-        {"America/Yellowknife",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"Antarctica/Casey",
+        {"Asia/Choibalsan",
+         {"Ulaanbaatar Standard Time",
+          "CHOT",
+          "Ulaanbaatar Summer Time",
+          "CHOST"}},
+        {"Asia/Phnom_Penh",
+         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
+        {"Atlantic/Azores",
+         {"Azores Standard Time", "AZOT", "Azores Summer Time", "AZOST"}},
+        {"Atlantic/Canary",
+         {"Western European Standard Time",
+          "WET",
+          "Western European Summer Time",
+          "WEST"}},
+        {"Atlantic/Faeroe",
+         {"Western European Standard Time",
+          "WET",
+          "Western European Summer Time",
+          "WEST"}},
+        {"Australia/Eucla",
+         {"Australian Central Western Standard Time",
+          "ACWST",
+          "Australian Central Western Daylight Time",
+          "ACWDT"}},
+        {"Australia/Perth",
          {"Australian Western Standard Time",
           "AWST",
           "Australian Western Daylight Time",
           "AWDT"}},
-        {"Antarctica/Davis",
-         {"Davis Time", "DAVT", "Davis Summer Time", "DAVST"}},
-        {"Antarctica/DumontDUrville",
-         {"Dumont-d'Urville Time",
-          "DDUT",
-          "Dumont-d'Urville Summer Time",
-          "DDUST"}},
-        {"Antarctica/Macquarie",
-         {"Australian Eastern Standard Time (Macquarie)",
-          "AEST",
-          "Australian Eastern Daylight Time (Macquarie)",
-          "AEDT"}},
-        {"Antarctica/Mawson",
-         {"Mawson Time", "MAWT", "Mawson Summer Time", "MAWST"}},
-        {"Antarctica/McMurdo",
-         {"New Zealand Standard Time",
-          "NZST",
-          "New Zealand Daylight Time",
-          "NZDT"}},
-        {"Antarctica/Palmer",
-         {"Chile Time", "CLT", "Chile Summer Time", "CLST"}},
-        {"Antarctica/Rothera",
-         {"Rothera Time", "ROTT", "Rothera Summer Time", "ROTST"}},
-        {"Antarctica/South_Pole",
-         {"New Zealand Standard Time",
-          "NZST",
-          "New Zealand Daylight Time",
-          "NZDT"}},
-        {"Antarctica/Syowa",
-         {"Syowa Time", "SYOT", "Syowa Summer Time", "SYOST"}},
-        {"Antarctica/Troll",
-         {"Coordinated Universal Time",
-          "UTC",
+        {"Europe/Belgrade",
+         {"Central European Standard Time",
+          "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Antarctica/Vostok",
-         {"Vostok Time", "VOST", "Vostok Summer Time", "VOSST"}},
-        {"Arctic/Longyearbyen",
-         {"Central European Time",
+        {"Europe/Brussels",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Asia/Aden",
-         {"Arabia Standard Time", "AST", "Arabia Daylight Time", "ADT"}},
-        {"Asia/Almaty",
-         {"Alma-Ata Time", "ALMT", "Alma-Ata Summer Time", "ALMST"}},
-        {"Asia/Amman",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Asia/Anadyr", {"Anadyr Time", "ANAT", "Anadyr Summer Time", "ANAST"}},
-        {"Asia/Aqtau", {"Aqtau Time", "AQTT", "Aqtau Summer Time", "AQTST"}},
-        {"Asia/Aqtobe", {"Aqtobe Time", "AQTT", "Aqtobe Summer Time", "AQTST"}},
-        {"Asia/Ashgabat",
-         {"Turkmenistan Time", "TMT", "Turkmenistan Summer Time", "TMST"}},
-        {"Asia/Ashkhabad",
-         {"Turkmenistan Time", "TMT", "Turkmenistan Summer Time", "TMST"}},
-        {"Asia/Baghdad",
-         {"Arabia Standard Time", "AST", "Arabia Daylight Time", "ADT"}},
-        {"Asia/Bahrain",
-         {"Arabia Standard Time", "AST", "Arabia Daylight Time", "ADT"}},
-        {"Asia/Baku",
-         {"Azerbaijan Time", "AZT", "Azerbaijan Summer Time", "AZST"}},
-        {"Asia/Bangkok",
-         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
-        {"Asia/Beirut",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Asia/Bishkek",
-         {"Kirgizstan Time", "KGT", "Kirgizstan Summer Time", "KGST"}},
-        {"Asia/Brunei", {"Brunei Time", "BNT", "Brunei Summer Time", "BNST"}},
-        {"Asia/Calcutta",
-         {"India Standard Time", "IST", "India Daylight Time", "IDT"}},
-        {"Asia/Chita",
-         {"Yakutsk Time", "YAKT", "Yakutsk Summer Time", "YAKST"}},
-        {"Asia/Choibalsan",
-         {"Choibalsan Time", "CHOT", "Choibalsan Summer Time", "CHOST"}},
-        {"Asia/Chongqing",
-         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
-        {"Asia/Chungking",
-         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
-        {"Asia/Colombo",
-         {"India Standard Time", "IST", "India Daylight Time", "IDT"}},
-        {"Asia/Dacca",
-         {"Bangladesh Time", "BDT", "Bangladesh Summer Time", "BDST"}},
-        {"Asia/Dhaka",
-         {"Bangladesh Time", "BDT", "Bangladesh Summer Time", "BDST"}},
-        {"Asia/Dili",
-         {"Timor-Leste Time", "TLT", "Timor-Leste Summer Time", "TLST"}},
-        {"Asia/Damascus",
-         {"Eastern European Time",
+        {"Europe/Budapest",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Busingen",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Chisinau",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Asia/Dubai",
-         {"Gulf Standard Time", "GST", "Gulf Daylight Time", "GDT"}},
-        {"Asia/Dushanbe",
-         {"Tajikistan Time", "TJT", "Tajikistan Summer Time", "TJST"}},
-        {"Asia/Gaza",
-         {"Eastern European Time",
+        {"Europe/Guernsey",
+         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
+        {"Europe/Helsinki",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Asia/Harbin",
-         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
-        {"Asia/Hebron",
-         {"Eastern European Time",
+        {"Europe/Sarajevo",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Europe/Uzhgorod",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Asia/Ho_Chi_Minh",
-         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
-        {"Asia/Hong_Kong",
-         {"Hong Kong Time", "HKT", "Hong Kong Summer Time", "HKST"}},
-        {"Asia/Hovd", {"Hovd Time", "HOVT", "Hovd Summer Time", "HOVST"}},
-        {"Asia/Irkutsk",
-         {"Irkutsk Time", "IRKT", "Irkutsk Summer Time", "IRKST"}},
-        {"Asia/Istanbul", {"Turkey Time", "TRT", "Turkey Summer Time", "TRST"}},
-        {"Asia/Jakarta",
-         {"West Indonesia Time", "WIB", "West Indonesia Summer Time", "WIST"}},
-        {"Asia/Jayapura",
-         {"East Indonesia Time", "WIT", "East Indonesia Summer Time", "EIST"}},
-        {"Asia/Kabul",
-         {"Afghanistan Time", "AFT", "Afghanistan Summer Time", "AFST"}},
-        {"Asia/Kamchatka",
-         {"Petropavlovsk-Kamchatski Time",
-          "PETT",
-          "Petropavlovsk-Kamchatski Summer Time",
-          "PETST"}},
-        {"Asia/Karachi",
-         {"Pakistan Time", "PKT", "Pakistan Summer Time", "PKST"}},
-        {"Asia/Kashgar",
-         {"Xinjiang Standard Time", "XJT", "Xinjiang Daylight Time", "XJDT"}},
-        {"Asia/Kathmandu", {"Nepal Time", "NPT", "Nepal Summer Time", "NPST"}},
-        {"Asia/Katmandu", {"Nepal Time", "NPT", "Nepal Summer Time", "NPST"}},
-        {"Asia/Khandyga",
-         {"Yakutsk Time", "YAKT", "Yakutsk Summer Time", "YAKST"}},
-        {"Asia/Kolkata",
-         {"India Standard Time", "IST", "India Daylight Time", "IDT"}},
+        {"Indian/Maldives",
+         {"Maldives Time", "MVT", "Maldives Summer Time", "MVST"}},
+        {"Pacific/Chatham",
+         {"Chatham Standard Time", "CHAST", "Chatham Daylight Time", "CHADT"}},
+        {"Pacific/Fakaofo",
+         {"Tokelau Time", "TKT", "Tokelau Summer Time", "TKST"}},
+        {"Pacific/Gambier",
+         {"Gambier Time", "GAMT", "Gambier Summer Time", "GAMST"}},
+        {"Pacific/Norfolk",
+         {"Norfolk Island Standard Time",
+          "NFT",
+          "Norfolk Island Daylight Time",
+          "NFST"}},
+        {"SystemV/AST4ADT",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"SystemV/CST6CDT",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"SystemV/EST5EDT",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"SystemV/MST7MDT",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"SystemV/PST8PDT",
+         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
+        {"SystemV/YST9YDT",
+         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
+        {"Africa/Bujumbura",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"Africa/Mogadishu",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"America/Anguilla",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Asuncion",
+         {"Paraguay Standard Time", "PYT", "Paraguay Summer Time", "PYST"}},
+        {"America/Barbados",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Dominica",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Edmonton",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"America/Eirunepe",
+         {"Acre Standard Time", "ACT", "Acre Summer Time", "ACST"}},
+        {"America/Mazatlan",
+         {"Mexican Pacific Standard Time",
+          "MST",
+          "Mexican Pacific Daylight Time",
+          "MDT"}},
+        {"America/Miquelon",
+         {"St. Pierre & Miquelon Standard Time",
+          "PMST",
+          "St. Pierre & Miquelon Daylight Time",
+          "PMDT"}},
+        {"America/Montreal",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Resolute",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Santarem",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"America/Santiago",
+         {"Chile Standard Time", "CLT", "Chile Summer Time", "CLST"}},
+        {"America/Shiprock",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"America/St_Kitts",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/St_Lucia",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Winnipeg",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"Antarctica/Casey",
+         {"Casey Time", "AWST", "Australian Western Daylight Time", "AWDT"}},
+        {"Antarctica/Davis",
+         {"Davis Time", "DAVT", "Davis Summer Time", "DAVST"}},
+        {"Antarctica/Syowa",
+         {"Syowa Time", "SYOT", "Syowa Summer Time", "SYOST"}},
+        {"Antarctica/Troll",
+         {"Greenwich Mean Time",
+          "GMT",
+          "Central European Summer Time",
+          "CEST"}},
         {"Asia/Krasnoyarsk",
-         {"Krasnoyarsk Time", "KRAT", "Krasnoyarsk Summer Time", "KRAST"}},
-        {"Asia/Kuala_Lumpur",
-         {"Malaysia Time", "MYT", "Malaysia Summer Time", "MYST"}},
-        {"Asia/Kuching",
-         {"Malaysia Time", "MYT", "Malaysia Summer Time", "MYST"}},
-        {"Asia/Kuwait",
-         {"Arabia Standard Time", "AST", "Arabia Daylight Time", "ADT"}},
-        {"Asia/Macao",
-         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
-        {"Asia/Macau",
-         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
-        {"Asia/Magadan",
-         {"Magadan Time", "MAGT", "Magadan Summer Time", "MAGST"}},
-        {"Asia/Makassar",
-         {"Central Indonesia Time",
-          "WITA",
-          "Central Indonesia Summer Time",
-          "CIST"}},
-        {"Asia/Manila",
-         {"Philippines Standard Time",
-          "PST",
-          "Philippines Daylight Time",
-          "PDT"}},
-        {"Asia/Muscat",
-         {"Gulf Standard Time", "GST", "Gulf Daylight Time", "GDT"}},
-        {"Asia/Nicosia",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Asia/Novokuznetsk",
-         {"Krasnoyarsk Time", "KRAT", "Krasnoyarsk Summer Time", "KRAST"}},
+         {"Krasnoyarsk Standard Time",
+          "KRAT",
+          "Krasnoyarsk Summer Time",
+          "KRAST"}},
         {"Asia/Novosibirsk",
-         {"Novosibirsk Time", "NOVT", "Novosibirsk Summer Time", "NOVST"}},
-        {"Asia/Oral", {"Oral Time", "ORAT", "Oral Summer Time", "ORAST"}},
-        {"Asia/Omsk", {"Omsk Time", "OMST", "Omsk Summer Time", "OMSST"}},
-        {"Asia/Phnom_Penh",
-         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
-        {"Asia/Pontianak",
-         {"West Indonesia Time", "WIB", "West Indonesia Summer Time", "WIST"}},
-        {"Asia/Pyongyang",
-         {"Korea Standard Time", "KST", "Korea Daylight Time", "KDT"}},
-        {"Asia/Qatar",
-         {"Arabia Standard Time", "AST", "Arabia Daylight Time", "ADT"}},
-        {"Asia/Qostanay",
-         {"Kostanay Standard Time", "QOST", "Kostanay Summer Time", "QOSST"}},
-        {"Asia/Qyzylorda",
-         {"Qyzylorda Time", "QYZT", "Qyzylorda Summer Time", "QYZST"}},
-        {"Asia/Rangoon",
-         {"Myanmar Time", "MMT", "Myanmar Summer Time", "MMST"}},
-        {"Asia/Riyadh",
-         {"Arabia Standard Time", "AST", "Arabia Daylight Time", "ADT"}},
-        {"Asia/Saigon",
-         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
-        {"Asia/Sakhalin",
-         {"Sakhalin Time", "SAKT", "Sakhalin Summer Time", "SAKST"}},
-        {"Asia/Samarkand",
-         {"Uzbekistan Time", "UZT", "Uzbekistan Summer Time", "UZST"}},
-        {"Asia/Seoul",
-         {"Korea Standard Time", "KST", "Korea Daylight Time", "KDT"}},
-        {"Asia/Singapore",
-         {"Singapore Time", "SGT", "Singapore Summer Time", "SGST"}},
-        {"Asia/Srednekolymsk",
-         {"Srednekolymsk Time",
-          "SRET",
-          "Srednekolymsk Daylight Time",
-          "SREDT"}},
-        {"Asia/Taipei",
-         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
-        {"Asia/Tel_Aviv",
-         {"Israel Standard Time", "IST", "Israel Daylight Time", "IDT"}},
-        {"Asia/Tashkent",
-         {"Uzbekistan Time", "UZT", "Uzbekistan Summer Time", "UZST"}},
-        {"Asia/Tbilisi",
-         {"Georgia Time", "GET", "Georgia Summer Time", "GEST"}},
-        {"Asia/Tehran",
-         {"Iran Standard Time", "IRST", "Iran Daylight Time", "IRDT"}},
-        {"Asia/Thimbu", {"Bhutan Time", "BTT", "Bhutan Summer Time", "BTST"}},
-        {"Asia/Thimphu", {"Bhutan Time", "BTT", "Bhutan Summer Time", "BTST"}},
-        {"Asia/Ujung_Pandang",
-         {"Central Indonesia Time",
-          "WITA",
-          "Central Indonesia Summer Time",
-          "CIST"}},
+         {"Novosibirsk Standard Time",
+          "NOVT",
+          "Novosibirsk Summer Time",
+          "NOVST"}},
         {"Asia/Ulaanbaatar",
-         {"Ulaanbaatar Time", "ULAT", "Ulaanbaatar Summer Time", "ULAST"}},
-        {"Asia/Ulan_Bator",
-         {"Ulaanbaatar Time", "ULAT", "Ulaanbaatar Summer Time", "ULAST"}},
-        {"Asia/Urumqi",
-         {"Xinjiang Standard Time", "XJT", "Xinjiang Daylight Time", "XJDT"}},
-        {"Asia/Ust-Nera",
-         {"Ust-Nera Time", "VLAT", "Ust-Nera Summer Time", "VLAST"}},
-        {"Asia/Vientiane",
-         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
+         {"Ulaanbaatar Standard Time",
+          "ULAT",
+          "Ulaanbaatar Summer Time",
+          "ULAST"}},
         {"Asia/Vladivostok",
-         {"Vladivostok Time", "VLAT", "Vladivostok Summer Time", "VLAST"}},
-        {"Asia/Yakutsk",
-         {"Yakutsk Time", "YAKT", "Yakutsk Summer Time", "YAKST"}},
-        {"Asia/Yangon", {"Myanmar Time", "MMT", "Myanmar Summer Time", "MMST"}},
-        {"Asia/Yekaterinburg",
-         {"Yekaterinburg Time", "YEKT", "Yekaterinburg Summer Time", "YEKST"}},
-        {"Asia/Yerevan",
-         {"Armenia Time", "AMT", "Armenia Summer Time", "AMST"}},
-        {"Atlantic/Azores",
-         {"Azores Time", "AZOT", "Azores Summer Time", "AZOST"}},
+         {"Vladivostok Standard Time",
+          "VLAT",
+          "Vladivostok Summer Time",
+          "VLAST"}},
         {"Atlantic/Bermuda",
          {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"Atlantic/Canary",
-         {"Western European Time",
-          "WET",
-          "Western European Summer Time",
-          "WEST"}},
-        {"Atlantic/Cape_Verde",
-         {"Cape Verde Time", "CVT", "Cape Verde Summer Time", "CVST"}},
-        {"Atlantic/Faeroe",
-         {"Western European Time",
-          "WET",
-          "Western European Summer Time",
-          "WEST"}},
-        {"Atlantic/Faroe",
-         {"Western European Time",
+        {"Atlantic/Madeira",
+         {"Western European Standard Time",
           "WET",
           "Western European Summer Time",
           "WEST"}},
-        {"Atlantic/Jan_Mayen",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Atlantic/Madeira",
-         {"Western European Time",
-          "WET",
-          "Western European Summer Time",
-          "WEST"}},
-        {"Atlantic/Reykjavik",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Atlantic/South_Georgia",
-         {"South Georgia Standard Time",
-          "GST",
-          "South Georgia Daylight Time",
-          "GDT"}},
-        {"Atlantic/St_Helena",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
         {"Atlantic/Stanley",
-         {"Falkland Is. Time", "FKT", "Falkland Is. Summer Time", "FKST"}},
-        {"Australia/ACT",
-         {"Australian Eastern Standard Time (New South Wales)",
-          "AEST",
-          "Australian Eastern Daylight Time (New South Wales)",
-          "AEDT"}},
-        {"Australia/Adelaide",
-         {"Australian Central Standard Time (South Australia)",
-          "ACST",
-          "Australian Central Daylight Time (South Australia)",
-          "ACDT"}},
-        {"Australia/Brisbane",
-         {"Australian Eastern Standard Time (Queensland)",
-          "AEST",
-          "Australian Eastern Daylight Time (Queensland)",
-          "AEDT"}},
-        {"Australia/Broken_Hill",
-         {"Australian Central Standard Time (South Australia/New South Wales)",
-          "ACST",
-          "Australian Central Daylight Time (South Australia/New South Wales)",
-          "ACDT"}},
-        {"Australia/Canberra",
-         {"Australian Eastern Standard Time (New South Wales)",
-          "AEST",
-          "Australian Eastern Daylight Time (New South Wales)",
-          "AEDT"}},
+         {"Falkland Islands Standard Time",
+          "FKT",
+          "Falkland Islands Summer Time",
+          "FKST"}},
         {"Australia/Currie",
-         {"Australian Eastern Standard Time (New South Wales)",
+         {"Australian Eastern Standard Time",
           "AEST",
-          "Australian Eastern Daylight Time (New South Wales)",
+          "Australian Eastern Daylight Time",
           "AEDT"}},
         {"Australia/Darwin",
-         {"Australian Central Standard Time (Northern Territory)",
+         {"Australian Central Standard Time",
           "ACST",
-          "Australian Central Daylight Time (Northern Territory)",
+          "Australian Central Daylight Time",
           "ACDT"}},
-        {"Australia/Eucla",
-         {"Australian Central Western Standard Time",
-          "ACWST",
-          "Australian Central Western Daylight Time",
-          "ACWDT"}},
         {"Australia/Hobart",
-         {"Australian Eastern Standard Time (Tasmania)",
-          "AEST",
-          "Australian Eastern Daylight Time (Tasmania)",
-          "AEDT"}},
-        {"Australia/LHI",
-         {"Lord Howe Standard Time",
-          "LHST",
-          "Lord Howe Daylight Time",
-          "LHDT"}},
-        {"Australia/Lindeman",
-         {"Australian Eastern Standard Time (Queensland)",
-          "AEST",
-          "Australian Eastern Daylight Time (Queensland)",
-          "AEDT"}},
-        {"Australia/Lord_Howe",
-         {"Lord Howe Standard Time",
-          "LHST",
-          "Lord Howe Daylight Time",
-          "LHDT"}},
-        {"Australia/Melbourne",
-         {"Australian Eastern Standard Time (Victoria)",
-          "AEST",
-          "Australian Eastern Daylight Time (Victoria)",
-          "AEDT"}},
-        {"Australia/North",
-         {"Australian Central Standard Time (Northern Territory)",
-          "ACST",
-          "Australian Central Daylight Time (Northern Territory)",
-          "ACDT"}},
-        {"Australia/NSW",
-         {"Australian Eastern Standard Time (New South Wales)",
-          "AEST",
-          "Australian Eastern Daylight Time (New South Wales)",
-          "AEDT"}},
-        {"Australia/Perth",
-         {"Australian Western Standard Time",
-          "AWST",
-          "Australian Western Daylight Time",
-          "AWDT"}},
-        {"Australia/Queensland",
-         {"Australian Eastern Standard Time (Queensland)",
+         {"Australian Eastern Standard Time",
           "AEST",
-          "Australian Eastern Daylight Time (Queensland)",
+          "Australian Eastern Daylight Time",
           "AEDT"}},
-        {"Australia/South",
-         {"Australian Central Standard Time (South Australia)",
-          "ACST",
-          "Australian Central Daylight Time (South Australia)",
-          "ACDT"}},
         {"Australia/Sydney",
-         {"Australian Eastern Standard Time (New South Wales)",
-          "AEST",
-          "Australian Eastern Daylight Time (New South Wales)",
-          "AEDT"}},
-        {"Australia/Tasmania",
-         {"Australian Eastern Standard Time (Tasmania)",
-          "AEST",
-          "Australian Eastern Daylight Time (Tasmania)",
-          "AEDT"}},
-        {"Australia/Victoria",
-         {"Australian Eastern Standard Time (Victoria)",
+         {"Australian Eastern Standard Time",
           "AEST",
-          "Australian Eastern Daylight Time (Victoria)",
+          "Australian Eastern Daylight Time",
           "AEDT"}},
-        {"Australia/West",
-         {"Australian Western Standard Time",
-          "AWST",
-          "Australian Western Daylight Time",
-          "AWDT"}},
-        {"Australia/Yancowinna",
-         {"Australian Central Standard Time (South Australia/New South Wales)",
-          "ACST",
-          "Australian Central Daylight Time (South Australia/New South Wales)",
-          "ACDT"}},
-        {"BET", {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
-        {"BST", {"Bangladesh Time", "BDT", "Bangladesh Summer Time", "BDST"}},
-        {"Brazil/Acre", {"Acre Time", "ACT", "Acre Summer Time", "ACST"}},
-        {"Brazil/DeNoronha",
-         {"Fernando de Noronha Time",
-          "FNT",
-          "Fernando de Noronha Summer Time",
-          "FNST"}},
-        {"Brazil/East",
-         {"Brasilia Time", "BRT", "Brasilia Summer Time", "BRST"}},
-        {"Brazil/West", {"Amazon Time", "AMT", "Amazon Summer Time", "AMST"}},
-        {"Canada/Atlantic",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"Canada/Central",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"Canada/Eastern",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"Canada/Mountain",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"Canada/Newfoundland",
-         {"Newfoundland Standard Time",
-          "NST",
-          "Newfoundland Daylight Time",
-          "NDT"}},
-        {"Canada/Pacific",
-         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"Canada/Yukon",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"Canada/Saskatchewan",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"CAT",
-         {"Central African Time",
-          "CAT",
-          "Central African Summer Time",
-          "CAST"}},
-        {"CET",
-         {"Central European Time",
+        {"Europe/Amsterdam",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Chile/Continental",
-         {"Chile Time", "CLT", "Chile Summer Time", "CLST"}},
-        {"Chile/EasterIsland",
-         {"Easter Is. Time", "EAST", "Easter Is. Summer Time", "EASST"}},
-        {"CST6CDT",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"Cuba", {"Cuba Standard Time", "CST", "Cuba Daylight Time", "CDT"}},
-        {"EAT",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"EET",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Egypt",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Eire", {"Greenwich Mean Time", "GMT", "Irish Summer Time", "IST"}},
-        {"EST5EDT",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"Etc/Greenwich",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Etc/UCT",
-         {"Coordinated Universal Time",
-          "UTC",
-          "Coordinated Universal Time",
-          "UTC"}},
-        {"Etc/Universal",
-         {"Coordinated Universal Time",
-          "UTC",
-          "Coordinated Universal Time",
-          "UTC"}},
-        {"Etc/UTC",
-         {"Coordinated Universal Time",
-          "UTC",
-          "Coordinated Universal Time",
-          "UTC"}},
-        {"Etc/Zulu",
-         {"Coordinated Universal Time",
-          "UTC",
-          "Coordinated Universal Time",
-          "UTC"}},
-        {"Europe/Amsterdam",
-         {"Central European Time",
+        {"Europe/Gibraltar",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Andorra",
-         {"Central European Time",
+        {"Europe/Ljubljana",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Athens",
-         {"Eastern European Time",
+        {"Europe/Mariehamn",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Europe/Belfast",
-         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
-        {"Europe/Belgrade",
-         {"Central European Time",
+        {"Europe/Podgorica",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Berlin",
-         {"Central European Time",
+        {"Europe/Stockholm",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
+        {"Europe/Volgograd",
+         {"Volgograd Standard Time", "MSK", "Volgograd Summer Time", "MSD"}},
+        {"Indian/Christmas",
+         {"Christmas Island Time",
+          "CXT",
+          "Christmas Island Summer Time",
+          "CXST"}},
+        {"Indian/Kerguelen",
+         {"French Southern & Antarctic Time",
+          "TFT",
+          "French Southern & Antarctic Lands Summer Time",
+          "TFST"}},
+        {"Indian/Mauritius",
+         {"Mauritius Standard Time", "MUT", "Mauritius Summer Time", "MUST"}},
+        {"Pacific/Auckland",
+         {"New Zealand Standard Time",
+          "NZST",
+          "New Zealand Daylight Time",
+          "NZDT"}},
+        {"Pacific/Funafuti",
+         {"Tuvalu Time", "TVT", "Tuvalu Summer Time", "TVST"}},
+        {"Pacific/Johnston",
+         {"Hawaii-Aleutian Standard Time",
+          "HAST",
+          "Hawaii-Aleutian Daylight Time",
+          "HADT"}},
+        {"Pacific/Pitcairn",
+         {"Pitcairn Time", "PST", "Pitcairn Daylight Time", "PDT"}},
+        {"Africa/Libreville",
+         {"West Africa Standard Time",
+          "WAT",
+          "West Africa Summer Time",
+          "WAST"}},
+        {"Africa/Lubumbashi",
+         {"Central Africa Time", "CAT", "Central African Summer Time", "CAST"}},
+        {"Africa/Nouakchott",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Africa/Porto-Novo",
+         {"West Africa Standard Time",
+          "WAT",
+          "West Africa Summer Time",
+          "WAST"}},
+        {"America/Araguaina",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"America/Boa_Vista",
+         {"Amazon Standard Time", "AMT", "Amazon Summer Time", "AMST"}},
+        {"America/Catamarca",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Chihuahua",
+         {"Mexican Pacific Standard Time",
+          "MST",
+          "Mexican Pacific Daylight Time",
+          "MDT"}},
+        {"America/Fortaleza",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"America/Glace_Bay",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Goose_Bay",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Guatemala",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Guayaquil",
+         {"Ecuador Time", "ECT", "Ecuador Summer Time", "ECST"}},
+        {"America/Matamoros",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Menominee",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Monterrey",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Sao_Paulo",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"America/St_Thomas",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Vancouver",
+         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
+        {"Antarctica/Mawson",
+         {"Mawson Time", "MAWT", "Mawson Summer Time", "MAWST"}},
+        {"Antarctica/Vostok",
+         {"Vostok Time", "VOST", "Vostok Summer Time", "VOSST"}},
+        {"Asia/Kuala_Lumpur",
+         {"Malaysia Time", "MYT", "Malaysia Summer Time", "MYST"}},
+        {"Asia/Novokuznetsk",
+         {"Krasnoyarsk Standard Time",
+          "KRAT",
+          "Krasnoyarsk Summer Time",
+          "KRAST"}},
         {"Europe/Bratislava",
-         {"Central European Time",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Brussels",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Budapest",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Busingen",
-         {"Central European Time",
+        {"Europe/Copenhagen",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Chisinau",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Copenhagen",
-         {"Central European Time",
+        {"Europe/Luxembourg",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Dublin",
-         {"Greenwich Mean Time", "GMT", "Irish Summer Time", "IST"}},
-        {"Europe/Gibraltar",
-         {"Central European Time",
+        {"Europe/San_Marino",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Guernsey",
-         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
-        {"Europe/Helsinki",
-         {"Eastern European Time",
+        {"Europe/Simferopol",
+         {"Moscow Standard Time", "MSK", "Moscow Summer Time", "MSD"}},
+        {"Europe/Zaporozhye",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Europe/Isle_of_Man",
-         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
-        {"Europe/Istanbul",
-         {"Turkey Time", "TRT", "Turkey Summer Time", "TRST"}},
-        {"Europe/Jersey",
+        {"Pacific/Enderbury",
+         {"Phoenix Islands Time", "PHOT", "Phoenix Is. Summer Time", "PHOST"}},
+        {"Pacific/Galapagos",
+         {"Galapagos Time", "GALT", "Galapagos Summer Time", "GALST"}},
+        {"Pacific/Kwajalein",
+         {"Marshall Islands Time",
+          "MHT",
+          "Marshall Islands Summer Time",
+          "MHST"}},
+        {"Pacific/Marquesas",
+         {"Marquesas Time", "MART", "Marquesas Summer Time", "MARST"}},
+        {"Pacific/Pago_Pago",
+         {"Samoa Standard Time", "SST", "Samoa Daylight Time", "SDT"}},
+        {"Pacific/Rarotonga",
+         {"Cook Islands Standard Time",
+          "CKT",
+          "Cook Islands Half Summer Time",
+          "CKHST"}},
+        {"Pacific/Tongatapu",
+         {"Tonga Standard Time", "TOT", "Tonga Summer Time", "TOST"}},
+        {"Africa/Addis_Ababa",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"Africa/Brazzaville",
+         {"West Africa Standard Time",
+          "WAT",
+          "West Africa Summer Time",
+          "WAST"}},
+        {"Africa/Ouagadougou",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"America/Costa_Rica",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Grand_Turk",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Guadeloupe",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Hermosillo",
+         {"Mexican Pacific Standard Time",
+          "MST",
+          "Mexican Pacific Daylight Time",
+          "MDT"}},
+        {"America/Kralendijk",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Louisville",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Martinique",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Metlakatla",
+         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
+        {"America/Montevideo",
+         {"Uruguay Standard Time", "UYT", "Uruguay Summer Time", "UYST"}},
+        {"America/Montserrat",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Paramaribo",
+         {"Suriname Time", "SRT", "Suriname Summer Time", "SRST"}},
+        {"America/Rio_Branco",
+         {"Acre Standard Time", "ACT", "Acre Summer Time", "ACST"}},
+        {"America/St_Vincent",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Whitehorse",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"Antarctica/McMurdo",
+         {"New Zealand Standard Time",
+          "NZST",
+          "New Zealand Daylight Time",
+          "NZDT"}},
+        {"Antarctica/Rothera",
+         {"Rothera Time", "ROTT", "Rothera Summer Time", "ROTST"}},
+        {"Asia/Yekaterinburg",
+         {"Yekaterinburg Standard Time",
+          "YEKT",
+          "Yekaterinburg Summer Time",
+          "YEKST"}},
+        {"Atlantic/Jan_Mayen",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Atlantic/Reykjavik",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Atlantic/St_Helena",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Australia/Adelaide",
+         {"Australian Central Standard Time",
+          "ACST",
+          "Australian Central Daylight Time",
+          "ACDT"}},
+        {"Australia/Brisbane",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"Australia/Lindeman",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"Europe/Isle_of_Man",
          {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
         {"Europe/Kaliningrad",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Kiev",
-         {"Eastern European Time",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Europe/Lisbon",
-         {"Western European Time",
-          "WET",
-          "Western European Summer Time",
-          "WEST"}},
-        {"Europe/Ljubljana",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/London",
-         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
-        {"Europe/Luxembourg",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Madrid",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Malta",
-         {"Central European Time",
+        {"Pacific/Kiritimati",
+         {"Line Islands Time", "LINT", "Line Is. Summer Time", "LINST"}},
+        {"Africa/Johannesburg",
+         {"South Africa Standard Time",
+          "SAST",
+          "South Africa Summer Time",
+          "SAST"}},
+        {"America/El_Salvador",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Fort_Nelson",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"America/Mexico_City",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Pangnirtung",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Porto_Velho",
+         {"Amazon Standard Time", "AMT", "Amazon Summer Time", "AMST"}},
+        {"America/Puerto_Rico",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Rainy_River",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Tegucigalpa",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Thunder_Bay",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Yellowknife",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"Arctic/Longyearbyen",
+         {"Central European Standard Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Mariehamn",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Minsk",
-         {"Moscow Standard Time", "MSK", "Moscow Daylight Time", "MSD"}},
-        {"Europe/Monaco",
+        {"Atlantic/Cape_Verde",
+         {"Cape Verde Standard Time", "CVT", "Cape Verde Summer Time", "CVST"}},
+        {"Australia/Lord_Howe",
+         {"Lord Howe Standard Time",
+          "LHST",
+          "Lord Howe Daylight Time",
+          "LHDT"}},
+        {"Australia/Melbourne",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"Indian/Antananarivo",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"Pacific/Guadalcanal",
+         {"Solomon Islands Time", "SBT", "Solomon Is. Summer Time", "SBST"}},
+        {"Africa/Dar_es_Salaam",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"America/Blanc-Sablon",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Buenos_Aires",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Campo_Grande",
+         {"Amazon Standard Time", "AMT", "Amazon Summer Time", "AMST"}},
+        {"America/Danmarkshavn",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"America/Dawson_Creek",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"America/Indiana/Knox",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Rankin_Inlet",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Santa_Isabel",
+         {"Northwest Mexico Standard Time",
+          "PST",
+          "Northwest Mexico Daylight Time",
+          "PDT"}},
+        {"America/Scoresbysund",
+         {"East Greenland Standard Time",
+          "EGT",
+          "East Greenland Summer Time",
+          "EGST"}},
+        {"Antarctica/Macquarie",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"Pacific/Port_Moresby",
+         {"Papua New Guinea Time",
+          "PGT",
+          "Papua New Guinea Summer Time",
+          "PGST"}},
+        {"America/Cambridge_Bay",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"America/Coral_Harbour",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Indiana/Vevay",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Lower_Princes",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Port_of_Spain",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Santo_Domingo",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/St_Barthelemy",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"America/Swift_Current",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"Antarctica/South_Pole",
+         {"New Zealand Standard Time",
+          "NZST",
+          "New Zealand Daylight Time",
+          "NZDT"}},
+        {"Australia/Broken_Hill",
+         {"Australian Central Standard Time",
+          "ACST",
+          "Australian Central Daylight Time",
+          "ACDT"}},
+        {"America/Bahia_Banderas",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Port-au-Prince",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"Atlantic/South_Georgia",
+         {"South Georgia Time", "GST", "South Georgia Daylight Time", "GDT"}},
+        {"America/Argentina/Salta",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Indiana/Marengo",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Indiana/Winamac",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Argentina/Tucuman",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Argentina/Ushuaia",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Indiana/Tell_City",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Indiana/Vincennes",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"Antarctica/DumontDUrville",
+         {"Dumont-d’Urville Time",
+          "DDUT",
+          "Dumont-d'Urville Summer Time",
+          "DDUST"}},
+        {"America/Argentina/La_Rioja",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Argentina/San_Juan",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Argentina/San_Luis",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/Indiana/Petersburg",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/Kentucky/Monticello",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"America/North_Dakota/Beulah",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/North_Dakota/Center",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"America/Argentina/Rio_Gallegos",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"America/North_Dakota/New_Salem",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"Asia/Chungking",
+         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
+        {"Asia/Kashgar",
+         {"Xinjiang Standard Time", "XJT", "Xinjiang Daylight Time", "XJDT"}},
+        {"Chile/Continental",
+         {"Chile Standard Time", "CLT", "Chile Summer Time", "CLST"}},
+        {"CET",
          {"Central European Time",
           "CET",
           "Central European Summer Time",
           "CEST"}},
-        {"Europe/Moscow",
-         {"Moscow Standard Time", "MSK", "Moscow Daylight Time", "MSD"}},
-        {"Europe/Nicosia",
-         {"Eastern European Time",
+        {"Europe/Istanbul",
+         {"Turkey Time", "TRT", "Turkey Summer Time", "TRST"}},
+        {"America/Argentina/Catamarca",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"Canada/Yukon",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"Canada/Atlantic",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"Australia/Tasmania",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"Libya",
+         {"Eastern European Standard Time",
           "EET",
           "Eastern European Summer Time",
           "EEST"}},
-        {"Europe/Oslo",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Podgorica",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Prague",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Riga",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Rome",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Samara",
-         {"Samara Time", "SAMT", "Samara Summer Time", "SAMST"}},
-        {"Europe/San_Marino",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Sarajevo",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Simferopol",
-         {"Moscow Standard Time", "MSK", "Moscow Daylight Time", "MSD"}},
-        {"Europe/Skopje",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Sofia",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Stockholm",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Tallinn",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Tirane",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Tiraspol",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Uzhgorod",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Vaduz",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Vatican",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Vienna",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Vilnius",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Volgograd",
-         {"Moscow Standard Time", "MSK", "Moscow Daylight Time", "MSD"}},
-        {"Europe/Warsaw",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Zagreb",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"Europe/Zaporozhye",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"Europe/Zurich",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"GB", {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
-        {"GB-Eire",
-         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
-        {"Greenwich",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Hongkong",
-         {"Hong Kong Time", "HKT", "Hong Kong Summer Time", "HKST"}},
-        {"Iceland",
-         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
-        {"Iran", {"Iran Standard Time", "IRST", "Iran Daylight Time", "IRDT"}},
+        {"America/Argentina/Cordoba",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
         {"IST", {"India Standard Time", "IST", "India Daylight Time", "IDT"}},
-        {"Indian/Antananarivo",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Indian/Chagos",
-         {"Indian Ocean Territory Time",
-          "IOT",
-          "Indian Ocean Territory Summer Time",
-          "IOST"}},
-        {"Indian/Christmas",
-         {"Christmas Island Time",
-          "CXT",
-          "Christmas Island Summer Time",
-          "CXST"}},
-        {"Indian/Cocos",
-         {"Cocos Islands Time", "CCT", "Cocos Islands Summer Time", "CCST"}},
-        {"Indian/Comoro",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Indian/Kerguelen",
-         {"French Southern & Antarctic Lands Time",
-          "TFT",
-          "French Southern & Antarctic Lands Summer Time",
-          "TFST"}},
-        {"Indian/Mahe",
-         {"Seychelles Time", "SCT", "Seychelles Summer Time", "SCST"}},
-        {"Indian/Maldives",
-         {"Maldives Time", "MVT", "Maldives Summer Time", "MVST"}},
-        {"Indian/Mauritius",
-         {"Mauritius Time", "MUT", "Mauritius Summer Time", "MUST"}},
-        {"Indian/Mayotte",
-         {"Eastern African Time",
-          "EAT",
-          "Eastern African Summer Time",
-          "EAST"}},
-        {"Indian/Reunion",
-         {"Reunion Time", "RET", "Reunion Summer Time", "REST"}},
+        {"US/Alaska",
+         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
+        {"Cuba", {"Cuba Standard Time", "CST", "Cuba Daylight Time", "CDT"}},
         {"Israel",
          {"Israel Standard Time", "IST", "Israel Daylight Time", "IDT"}},
-        {"Jamaica",
-         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"Japan", {"Japan Standard Time", "JST", "Japan Daylight Time", "JDT"}},
-        {"Kwajalein",
-         {"Marshall Islands Time",
-          "MHT",
-          "Marshall Islands Summer Time",
-          "MHST"}},
-        {"Libya",
-         {"Eastern European Time",
-          "EET",
-          "Eastern European Summer Time",
-          "EEST"}},
-        {"MET",
-         {"Middle Europe Time", "MET", "Middle Europe Summer Time", "MEST"}},
-        {"Mexico/BajaNorte",
-         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"Mexico/BajaSur",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"Mexico/General",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"MIT",
-         {"West Samoa Standard Time",
-          "WSST",
-          "West Samoa Daylight Time",
-          "WSDT"}},
-        {"MST7MDT",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"Navajo",
+        {"US/Arizona",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"NET", {"Armenia Time", "AMT", "Armenia Summer Time", "AMST"}},
-        {"NST",
-         {"New Zealand Standard Time",
-          "NZST",
-          "New Zealand Daylight Time",
-          "NZDT"}},
-        {"NZ",
-         {"New Zealand Standard Time",
-          "NZST",
-          "New Zealand Daylight Time",
-          "NZDT"}},
-        {"NZ-CHAT",
-         {"Chatham Standard Time", "CHAST", "Chatham Daylight Time", "CHADT"}},
-        {"PLT", {"Pakistan Time", "PKT", "Pakistan Summer Time", "PKST"}},
-        {"Portugal",
-         {"Western European Time",
-          "WET",
-          "Western European Summer Time",
-          "WEST"}},
-        {"PRT",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"Pacific/Apia",
-         {"West Samoa Standard Time",
-          "WSST",
-          "West Samoa Daylight Time",
-          "WSDT"}},
-        {"Pacific/Auckland",
-         {"New Zealand Standard Time",
-          "NZST",
-          "New Zealand Daylight Time",
-          "NZDT"}},
-        {"Pacific/Bougainville",
-         {"Bougainville Standard Time",
-          "BST",
-          "Bougainville Daylight Time",
-          "BST"}},
-        {"Pacific/Chatham",
-         {"Chatham Standard Time", "CHAST", "Chatham Daylight Time", "CHADT"}},
-        {"Pacific/Chuuk", {"Chuuk Time", "CHUT", "Chuuk Summer Time", "CHUST"}},
-        {"Pacific/Easter",
-         {"Easter Is. Time", "EAST", "Easter Is. Summer Time", "EASST"}},
-        {"Pacific/Efate",
-         {"Vanuatu Time", "VUT", "Vanuatu Summer Time", "VUST"}},
-        {"Pacific/Enderbury",
-         {"Phoenix Is. Time", "PHOT", "Phoenix Is. Summer Time", "PHOST"}},
-        {"Pacific/Fakaofo",
-         {"Tokelau Time", "TKT", "Tokelau Summer Time", "TKST"}},
-        {"Pacific/Fiji", {"Fiji Time", "FJT", "Fiji Summer Time", "FJST"}},
-        {"Pacific/Funafuti",
-         {"Tuvalu Time", "TVT", "Tuvalu Summer Time", "TVST"}},
-        {"Pacific/Galapagos",
-         {"Galapagos Time", "GALT", "Galapagos Summer Time", "GALST"}},
-        {"Pacific/Gambier",
-         {"Gambier Time", "GAMT", "Gambier Summer Time", "GAMST"}},
-        {"Pacific/Guadalcanal",
-         {"Solomon Is. Time", "SBT", "Solomon Is. Summer Time", "SBST"}},
-        {"Pacific/Guam",
-         {"Chamorro Standard Time", "ChST", "Chamorro Daylight Time", "ChDT"}},
-        {"Pacific/Johnston",
-         {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
-        {"Pacific/Kiritimati",
-         {"Line Is. Time", "LINT", "Line Is. Summer Time", "LINST"}},
-        {"Pacific/Kosrae",
-         {"Kosrae Time", "KOST", "Kosrae Summer Time", "KOSST"}},
-        {"Pacific/Kwajalein",
-         {"Marshall Islands Time",
-          "MHT",
-          "Marshall Islands Summer Time",
-          "MHST"}},
-        {"Pacific/Majuro",
-         {"Marshall Islands Time",
-          "MHT",
-          "Marshall Islands Summer Time",
-          "MHST"}},
-        {"Pacific/Marquesas",
-         {"Marquesas Time", "MART", "Marquesas Summer Time", "MARST"}},
-        {"Pacific/Midway",
-         {"Samoa Standard Time", "SST", "Samoa Daylight Time", "SDT"}},
-        {"Pacific/Nauru", {"Nauru Time", "NRT", "Nauru Summer Time", "NRST"}},
-        {"Pacific/Niue", {"Niue Time", "NUT", "Niue Summer Time", "NUST"}},
-        {"Pacific/Norfolk",
-         {"Norfolk Time", "NFT", "Norfolk Summer Time", "NFST"}},
-        {"Pacific/Noumea",
-         {"New Caledonia Time", "NCT", "New Caledonia Summer Time", "NCST"}},
-        {"Pacific/Pago_Pago",
-         {"Samoa Standard Time", "SST", "Samoa Daylight Time", "SDT"}},
-        {"Pacific/Palau", {"Palau Time", "PWT", "Palau Summer Time", "PWST"}},
-        {"Pacific/Pitcairn",
-         {"Pitcairn Standard Time", "PST", "Pitcairn Daylight Time", "PDT"}},
-        {"Pacific/Pohnpei",
-         {"Pohnpei Time", "PONT", "Pohnpei Summer Time", "PONST"}},
-        {"Pacific/Ponape",
-         {"Pohnpei Time", "PONT", "Pohnpei Summer Time", "PONST"}},
-        {"Pacific/Port_Moresby",
-         {"Papua New Guinea Time",
-          "PGT",
-          "Papua New Guinea Summer Time",
-          "PGST"}},
-        {"Pacific/Rarotonga",
-         {"Cook Is. Time", "CKT", "Cook Is. Summer Time", "CKHST"}},
-        {"Pacific/Saipan",
-         {"Chamorro Standard Time", "ChST", "Chamorro Daylight Time", "ChDT"}},
-        {"Pacific/Samoa",
-         {"Samoa Standard Time", "SST", "Samoa Daylight Time", "SDT"}},
-        {"Pacific/Tahiti",
-         {"Tahiti Time", "TAHT", "Tahiti Summer Time", "TAHST"}},
-        {"Pacific/Tarawa",
-         {"Gilbert Is. Time", "GILT", "Gilbert Is. Summer Time", "GILST"}},
-        {"Pacific/Tongatapu",
-         {"Tonga Time", "TOT", "Tonga Summer Time", "TOST"}},
-        {"Pacific/Truk", {"Chuuk Time", "CHUT", "Chuuk Summer Time", "CHUST"}},
-        {"Pacific/Wake", {"Wake Time", "WAKT", "Wake Summer Time", "WAKST"}},
-        {"Pacific/Wallis",
-         {"Wallis & Futuna Time",
-          "WFT",
-          "Wallis & Futuna Summer Time",
-          "WFST"}},
-        {"Pacific/Yap", {"Chuuk Time", "CHUT", "Chuuk Summer Time", "CHUST"}},
-        {"Poland",
-         {"Central European Time",
-          "CET",
-          "Central European Summer Time",
-          "CEST"}},
-        {"PRC", {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
-        {"PST8PDT",
-         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"ROK", {"Korea Standard Time", "KST", "Korea Daylight Time", "KDT"}},
-        {"Singapore",
-         {"Singapore Time", "SGT", "Singapore Summer Time", "SGST"}},
-        {"SST", {"Solomon Is. Time", "SBT", "Solomon Is. Summer Time", "SBST"}},
-        {"SystemV/AST4",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"SystemV/AST4ADT",
-         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
-        {"SystemV/CST6",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"SystemV/CST6CDT",
+        {"Brazil/East",
+         {"Brasilia Standard Time", "BRT", "Brasilia Summer Time", "BRST"}},
+        {"Asia/Macao",
+         {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
+        {"Asia/Tomsk",
+         {"Tomsk Standard Time",
+          "GMT+07:00",
+          "Tomsk Daylight Time",
+          "GMT+07:00"}},
+        {"America/Argentina/Mendoza",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"Mexico/BajaSur",
+         {"Mexican Pacific Standard Time",
+          "MST",
+          "Mexican Pacific Daylight Time",
+          "MDT"}},
+        {"HST", {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
+        {"Australia/ACT",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"GB-Eire",
+         {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
+        {"Asia/Dacca",
+         {"Bangladesh Standard Time", "BDT", "Bangladesh Summer Time", "BDST"}},
+        {"Pacific/Samoa",
+         {"Samoa Standard Time", "SST", "Samoa Daylight Time", "SDT"}},
+        {"America/Fort_Wayne",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"Europe/Saratov",
+         {"Saratov Standard Time",
+          "GMT+04:00",
+          "Saratov Standard Time",
+          "GMT+04:00"}},
+        {"GB", {"Greenwich Mean Time", "GMT", "British Summer Time", "BST"}},
+        {"Mexico/General",
          {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"SystemV/EST5",
+        {"Asia/Istanbul", {"Turkey Time", "TRT", "Turkey Summer Time", "TRST"}},
+        {"NZ-CHAT",
+         {"Chatham Standard Time", "CHAST", "Chatham Daylight Time", "CHADT"}},
+        {"America/Porto_Acre",
+         {"Acre Standard Time", "ACT", "Acre Summer Time", "ACST"}},
+        {"AGT", {"Argentine Time", "ART", "Argentine Summer Time", "ARST"}},
+        {"US/Michigan",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"SystemV/EST5EDT",
+        {"Europe/Tiraspol",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Portugal",
+         {"Western European Standard Time",
+          "WET",
+          "Western European Summer Time",
+          "WEST"}},
+        {"America/Argentina/Jujuy",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"Universal",
+         {"Coordinated Universal Time",
+          "UTC",
+          "Coordinated Universal Time",
+          "UTC"}},
+        {"Asia/Tel_Aviv",
+         {"Israel Standard Time", "IST", "Israel Daylight Time", "IDT"}},
+        {"Pacific/Bougainville",
+         {"Bougainville Standard Time",
+          "BST",
+          "Bougainville Daylight Time",
+          "BST"}},
+        {"US/Central",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"Australia/North",
+         {"Australian Central Standard Time",
+          "ACST",
+          "Australian Central Daylight Time",
+          "ACDT"}},
+        {"VST", {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
+        {"Australia/Yancowinna",
+         {"Australian Central Standard Time",
+          "ACST",
+          "Australian Central Daylight Time",
+          "ACDT"}},
+        {"Australia/Victoria",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"Asia/Barnaul",
+         {"Barnaul Standard Time",
+          "GMT+07:00",
+          "Barnaul Daylight Time",
+          "GMT+07:00"}},
+        {"EST",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"SystemV/HST10",
-         {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
-        {"SystemV/MST7",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"SystemV/MST7MDT",
-         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"SystemV/PST8",
+        {"Canada/Pacific",
          {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"SystemV/PST8PDT",
+        {"Pacific/Chuuk", {"Chuuk Time", "CHUT", "Chuuk Summer Time", "CHUST"}},
+        {"Etc/Universal",
+         {"Coordinated Universal Time",
+          "UTC",
+          "Coordinated Universal Time",
+          "UTC"}},
+        {"Canada/Newfoundland",
+         {"Newfoundland Standard Time",
+          "NST",
+          "Newfoundland Daylight Time",
+          "NDT"}},
+        {"America/Kentucky/Louisville",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"Asia/Ho_Chi_Minh",
+         {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
+        {"Africa/Asmara",
+         {"East Africa Time", "EAT", "Eastern African Summer Time", "EAST"}},
+        {"ROK", {"Korean Standard Time", "KST", "Korean Daylight Time", "KDT"}},
+        {"Australia/Queensland",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"Asia/Kolkata",
+         {"India Standard Time", "IST", "India Daylight Time", "IDT"}},
+        {"Australia/Canberra",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"MET",
+         {"Middle Europe Time", "MET", "Middle Europe Summer Time", "MEST"}},
+        {"Kwajalein",
+         {"Marshall Islands Time",
+          "MHT",
+          "Marshall Islands Summer Time",
+          "MHST"}},
+        {"Asia/Ulan_Bator",
+         {"Ulaanbaatar Standard Time",
+          "ULAT",
+          "Ulaanbaatar Summer Time",
+          "ULAST"}},
+        {"NZ",
+         {"New Zealand Standard Time",
+          "NZST",
+          "New Zealand Daylight Time",
+          "NZDT"}},
+        {"Eire", {"Greenwich Mean Time", "GMT", "Irish Standard Time", "IST"}},
+        {"Atlantic/Faroe",
+         {"Western European Standard Time",
+          "WET",
+          "Western European Summer Time",
+          "WEST"}},
+        {"Mexico/BajaNorte",
          {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"SystemV/YST9",
-         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
-        {"SystemV/YST9YDT",
-         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
-        {"Turkey", {"Turkey Time", "TRT", "Turkey Summer Time", "TRST"}},
-        {"UCT",
+        {"Etc/UCT",
          {"Coordinated Universal Time",
           "UTC",
           "Coordinated Universal Time",
           "UTC"}},
-        {"Universal",
+        {"America/Atka",
+         {"Hawaii-Aleutian Standard Time",
+          "HAST",
+          "Hawaii-Aleutian Daylight Time",
+          "HADT"}},
+        {"America/Atikokan",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"Australia/NSW",
+         {"Australian Eastern Standard Time",
+          "AEST",
+          "Australian Eastern Daylight Time",
+          "AEDT"}},
+        {"US/Hawaii",
+         {"Hawaii-Aleutian Standard Time",
+          "HST",
+          "Hawaii-Aleutian Daylight Time",
+          "HDT"}},
+        {"Zulu",
          {"Coordinated Universal Time",
           "UTC",
           "Coordinated Universal Time",
           "UTC"}},
-        {"US/Alaska",
-         {"Alaska Standard Time", "AKST", "Alaska Daylight Time", "AKDT"}},
-        {"US/Aleutian",
-         {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
-        {"US/Arizona",
+        {"Africa/El_Aaiun",
+         {"Western European Time",
+          "WET",
+          "Western European Summer Time",
+          "WEST"}},
+        {"Brazil/West",
+         {"Amazon Standard Time", "AMT", "Amazon Summer Time", "AMST"}},
+        {"Chile/EasterIsland",
+         {"Easter Island Standard Time",
+          "EAST",
+          "Easter Island Summer Time",
+          "EASST"}},
+        {"America/Indiana/Indianapolis",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
+        {"US/Mountain",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"US/Central",
+        {"Poland",
+         {"Central European Standard Time",
+          "CET",
+          "Central European Summer Time",
+          "CEST"}},
+        {"Antarctica/Palmer",
+         {"Chile Time", "CLT", "Chile Summer Time", "CLST"}},
+        {"Asia/Yangon", {"Myanmar Time", "MMT", "Myanmar Summer Time", "MMST"}},
+        {"Brazil/DeNoronha",
+         {"Fernando de Noronha Standard Time",
+          "FNT",
+          "Fernando de Noronha Summer Time",
+          "FNST"}},
+        {"Asia/Ashkhabad",
+         {"Turkmenistan Standard Time",
+          "TMT",
+          "Turkmenistan Summer Time",
+          "TMST"}},
+        {"Etc/Zulu",
+         {"Coordinated Universal Time",
+          "UTC",
+          "Coordinated Universal Time",
+          "UTC"}},
+        {"America/Punta_Arenas",
+         {"Punta Arenas Standard Time",
+          "GMT-03:00",
+          "Punta Arenas Standard Time",
+          "GMT-03:00"}},
+        {"US/Samoa",
+         {"Samoa Standard Time", "SST", "Samoa Daylight Time", "SDT"}},
+        {"PRC", {"China Standard Time", "CST", "China Daylight Time", "CDT"}},
+        {"Iceland",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Pacific/Pohnpei",
+         {"Ponape Time", "PONT", "Pohnpei Summer Time", "PONST"}},
+        {"Asia/Ujung_Pandang",
+         {"Central Indonesia Time",
+          "WITA",
+          "Central Indonesia Summer Time",
+          "CIST"}},
+        {"America/Knox_IN",
          {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"Europe/Kirov",
+         {"Kirov Standard Time",
+          "GMT+03:00",
+          "Kirov Daylight Time",
+          "GMT+03:00"}},
+        {"Pacific/Kanton",
+         {"Kanton Standard Time",
+          "GMT+13:00",
+          "Kanton Daylight Time",
+          "GMT+13:00"}},
+        {"Greenwich",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"Australia/South",
+         {"Australian Central Standard Time",
+          "ACST",
+          "Australian Central Daylight Time",
+          "ACDT"}},
+        {"Canada/Central",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"IET",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
         {"US/Eastern",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"US/Hawaii",
-         {"Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT"}},
-        {"US/Indiana-Starke",
-         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
-        {"US/East-Indiana",
+        {"Africa/Casablanca",
+         {"Western European Time",
+          "WET",
+          "Western European Summer Time",
+          "WEST"}},
+        {"Canada/Eastern",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"US/Michigan",
+        {"Singapore",
+         {"Singapore Standard Time", "SGT", "Singapore Summer Time", "SGST"}},
+        {"Brazil/Acre",
+         {"Acre Standard Time", "ACT", "Acre Summer Time", "ACST"}},
+        {"US/East-Indiana",
          {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
-        {"US/Mountain",
+        {"Asia/Kathmandu", {"Nepal Time", "NPT", "Nepal Summer Time", "NPST"}},
+        {"Australia/LHI",
+         {"Lord Howe Standard Time",
+          "LHST",
+          "Lord Howe Daylight Time",
+          "LHDT"}},
+        {"Canada/Mountain",
          {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
-        {"US/Pacific",
-         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
-        {"US/Samoa",
-         {"Samoa Standard Time", "SST", "Samoa Daylight Time", "SDT"}},
-        {"VST", {"Indochina Time", "ICT", "Indochina Summer Time", "ICST"}},
-        {"W-SU",
-         {"Moscow Standard Time", "MSK", "Moscow Daylight Time", "MSD"}},
+        {"Australia/West",
+         {"Australian Western Standard Time",
+          "AWST",
+          "Australian Western Daylight Time",
+          "AWDT"}},
+        {"US/Indiana-Starke",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"Asia/Urumqi",
+         {"Xinjiang Standard Time", "XJT", "Xinjiang Daylight Time", "XJDT"}},
+        {"US/Aleutian",
+         {"Hawaii-Aleutian Standard Time",
+          "HAST",
+          "Hawaii-Aleutian Daylight Time",
+          "HADT"}},
+        {"Iran", {"Iran Standard Time", "IRST", "Iran Daylight Time", "IRDT"}},
+        {"Asia/Thimbu", {"Bhutan Time", "BTT", "Bhutan Summer Time", "BTST"}},
+        {"Navajo",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"Turkey", {"Turkey Time", "TRT", "Turkey Summer Time", "TRST"}},
+        {"Jamaica",
+         {"Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT"}},
         {"WET",
          {"Western European Time",
           "WET",
           "Western European Summer Time",
           "WEST"}},
-        {"Zulu",
+        {"Europe/Astrakhan",
+         {"Astrakhan Standard Time",
+          "GMT+04:00",
+          "Astrakhan Standard Time",
+          "GMT+04:00"}},
+        {"Etc/Greenwich",
+         {"Greenwich Mean Time", "GMT", "Greenwich Mean Time", "GMT"}},
+        {"America/Ensenada",
+         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
+        {"America/Virgin",
+         {"Atlantic Standard Time", "AST", "Atlantic Daylight Time", "ADT"}},
+        {"MST",
+         {"Mountain Standard Time", "MST", "Mountain Daylight Time", "MDT"}},
+        {"Hongkong",
+         {"Hong Kong Standard Time", "HKT", "Hong Kong Summer Time", "HKST"}},
+        {"UCT",
          {"Coordinated Universal Time",
           "UTC",
           "Coordinated Universal Time",
           "UTC"}},
+        {"America/Argentina/ComodRivadavia",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"Asia/Famagusta",
+         {"Eastern European Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Japan", {"Japan Standard Time", "JST", "Japan Daylight Time", "JDT"}},
+        {"America/Nuuk",
+         {"West Greenland Standard Time",
+          "WGT",
+          "West Greenland Summer Time",
+          "WGST"}},
+        {"Europe/Ulyanovsk",
+         {"Ulyanovsk Standard Time",
+          "GMT+04:00",
+          "Ulyanovsk Standard Time",
+          "GMT+04:00"}},
+        {"W-SU", {"Moscow Standard Time", "MSK", "Moscow Summer Time", "MSD"}},
+        {"EET",
+         {"Eastern European Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"America/Rosario",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"Canada/Saskatchewan",
+         {"Central Standard Time", "CST", "Central Daylight Time", "CDT"}},
+        {"Egypt",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"Asia/Srednekolymsk",
+         {"Srednekolymsk Time",
+          "SRET",
+          "Srednekolymsk Daylight Time",
+          "SREDT"}},
+        {"America/Argentina/Buenos_Aires",
+         {"Argentina Standard Time", "ART", "Argentina Summer Time", "ARST"}},
+        {"Europe/Nicosia",
+         {"Eastern European Standard Time",
+          "EET",
+          "Eastern European Summer Time",
+          "EEST"}},
+        {"US/Pacific",
+         {"Pacific Standard Time", "PST", "Pacific Daylight Time", "PDT"}},
     };
   }());
   return *timeZoneNames;
diff --git a/velox/type/tz/tests/CMakeLists.txt b/velox/type/tz/tests/CMakeLists.txt
index 5c17513afaad..b5eb3f0ca3d4 100644
--- a/velox/type/tz/tests/CMakeLists.txt
+++ b/velox/type/tz/tests/CMakeLists.txt
@@ -21,10 +21,10 @@ target_link_libraries(
   velox_exception
   GTest::gtest
   GTest::gtest_main
-  pthread)
+  pthread
+)
 
-add_executable(velox_type_tz_ext_invalid_test
-               TimeZoneMapExternalInvalidTest.cpp)
+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(
@@ -34,4 +34,5 @@ target_link_libraries(
   velox_exception
   GTest::gtest
   GTest::gtest_main
-  pthread)
+  pthread
+)
diff --git a/velox/type/tz/tests/TimeZoneMapTest.cpp b/velox/type/tz/tests/TimeZoneMapTest.cpp
index e45fca96baee..52bdbf44f270 100644
--- a/velox/type/tz/tests/TimeZoneMapTest.cpp
+++ b/velox/type/tz/tests/TimeZoneMapTest.cpp
@@ -254,6 +254,57 @@ TEST(TimeZoneMapTest, getTimeZoneIDFromOffset) {
   VELOX_ASSERT_THROW(getTimeZoneID(-15'000), "Invalid timezone offset");
 }
 
+TEST(TimeZoneMapTest, offset) {
+  // Test offset-based timezones - should return the offset value.
+  {
+    const auto* tz = locateZone("+05:30");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    ASSERT_TRUE(offset.has_value());
+    EXPECT_EQ(offset->count(), 330); // 5*60 + 30 = 330 minutes
+  }
+
+  {
+    const auto* tz = locateZone("-08:00");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    ASSERT_TRUE(offset.has_value());
+    EXPECT_EQ(offset->count(), -480); // -8*60 = -480 minutes
+  }
+
+  {
+    const auto* tz = locateZone("+00:01");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    ASSERT_TRUE(offset.has_value());
+    EXPECT_EQ(offset->count(), 1); // 1 minute
+  }
+
+  // Test named timezones - should return std::nullopt.
+  // Note: UTC is a named timezone with tzdb::time_zone pointer, not
+  // offset-based
+  {
+    const auto* tz = locateZone("UTC");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    EXPECT_FALSE(offset.has_value());
+  }
+
+  {
+    const auto* tz = locateZone("America/Los_Angeles");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    EXPECT_FALSE(offset.has_value());
+  }
+
+  {
+    const auto* tz = locateZone("Europe/London");
+    ASSERT_NE(tz, nullptr);
+    auto offset = tz->offset();
+    EXPECT_FALSE(offset.has_value());
+  }
+}
+
 TEST(TimeZoneMapTest, invalid) {
   VELOX_ASSERT_THROW(getTimeZoneName(99999999), "Unable to resolve timeZoneID");
   VELOX_ASSERT_THROW(getTimeZoneID("This is a test"), "Unknown time zone");
diff --git a/velox/exec/AggregationHook.h b/velox/vector/AggregationHook.h
similarity index 100%
rename from velox/exec/AggregationHook.h
rename to velox/vector/AggregationHook.h
diff --git a/velox/vector/BaseVector.cpp b/velox/vector/BaseVector.cpp
index 906fbf1ef715..81935d67afd1 100644
--- a/velox/vector/BaseVector.cpp
+++ b/velox/vector/BaseVector.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "velox/vector/BaseVector.h"
+#include <map>
+#include <vector>
 #include "velox/type/StringView.h"
 #include "velox/type/Type.h"
 #include "velox/type/Variant.h"
@@ -30,13 +32,122 @@
 #include "velox/vector/VectorTypeUtils.h"
 
 namespace facebook::velox {
+namespace {
+
+Variant nullVariant(const TypePtr& type) {
+  return Variant(type->kind());
+}
+
+template <TypeKind kind>
+Variant variantAtTyped(const BaseVector* vector, vector_size_t row) {
+  using T = typename TypeTraits<kind>::NativeType;
+
+  const T value = vector->as<SimpleVector<T>>()->valueAt(row);
+
+  if (vector->type()->providesCustomComparison()) {
+    return Variant::typeWithCustomComparison<kind>(value, vector->type());
+  }
+
+  return Variant(value);
+}
+
+template <>
+Variant variantAtTyped<TypeKind::VARBINARY>(
+    const BaseVector* vector,
+    vector_size_t row) {
+  return Variant::binary(
+      std::string(vector->as<SimpleVector<StringView>>()->valueAt(row)));
+}
+
+Variant variantAtImpl(const BaseVector* vector, vector_size_t row);
+
+Variant arrayVariantAt(const BaseVector* vector, vector_size_t row) {
+  auto arrayVector = vector->wrappedVector()->as<ArrayVector>();
+  auto& elements = arrayVector->elements();
+
+  auto wrappedRow = vector->wrappedIndex(row);
+  auto offset = arrayVector->offsetAt(wrappedRow);
+  auto size = arrayVector->sizeAt(wrappedRow);
+
+  std::vector<Variant> array;
+  array.reserve(size);
+  for (auto i = 0; i < size; i++) {
+    auto innerRow = offset + i;
+    array.push_back(variantAtImpl(elements.get(), innerRow));
+  }
+  return Variant::array(array);
+}
+
+Variant mapVariantAt(const BaseVector* vector, vector_size_t row) {
+  auto mapVector = vector->wrappedVector()->as<MapVector>();
+  auto& mapKeys = mapVector->mapKeys();
+  auto& mapValues = mapVector->mapValues();
+
+  auto wrappedRow = vector->wrappedIndex(row);
+  auto offset = mapVector->offsetAt(wrappedRow);
+  auto size = mapVector->sizeAt(wrappedRow);
+
+  std::map<Variant, Variant> map;
+  for (auto i = 0; i < size; i++) {
+    auto innerRow = offset + i;
+    auto key = variantAtImpl(mapKeys.get(), innerRow);
+    auto value = variantAtImpl(mapValues.get(), innerRow);
+    map.insert({key, value});
+  }
+  return Variant::map(map);
+}
+
+Variant rowVariantAt(const BaseVector* vector, vector_size_t row) {
+  auto rowValues = vector->wrappedVector()->as<RowVector>();
+  auto wrappedRow = vector->wrappedIndex(row);
+
+  std::vector<Variant> values;
+  for (auto& child : rowValues->children()) {
+    values.push_back(variantAtImpl(child.get(), wrappedRow));
+  }
+  return Variant::row(std::move(values));
+}
+
+Variant variantAtImpl(const BaseVector* vector, vector_size_t row) {
+  if (vector->isNullAt(row)) {
+    return nullVariant(vector->type());
+  }
+
+  auto typeKind = vector->typeKind();
+  if (typeKind == TypeKind::ROW) {
+    return rowVariantAt(vector, row);
+  }
+
+  if (typeKind == TypeKind::ARRAY) {
+    return arrayVariantAt(vector, row);
+  }
+
+  if (typeKind == TypeKind::MAP) {
+    return mapVariantAt(vector, row);
+  }
+
+  if (typeKind == TypeKind::OPAQUE) {
+    return Variant::opaque(
+        vector->as<SimpleVector<std::shared_ptr<void>>>()->valueAt(row),
+        std::dynamic_pointer_cast<const OpaqueType>(vector->type()));
+  }
+
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      variantAtTyped, typeKind, vector, row);
+}
+
+} // namespace
+
+Variant BaseVector::variantAt(vector_size_t index) const {
+  return variantAtImpl(this, index);
+}
 
 BaseVector::BaseVector(
     velox::memory::MemoryPool* pool,
     std::shared_ptr<const Type> type,
     VectorEncoding::Simple encoding,
     BufferPtr nulls,
-    size_t length,
+    vector_size_t length,
     std::optional<vector_size_t> distinctValueCount,
     std::optional<vector_size_t> nullCount,
     std::optional<ByteCount> representedByteCount,
@@ -69,7 +180,6 @@ BaseVector::BaseVector(
       // second reference to an immutable 'nulls_'.
       nulls_->setSize(bytes);
     }
-    inMemoryBytes_ += nulls_->size();
   }
 }
 
@@ -159,7 +269,7 @@ VectorPtr BaseVector::wrapInDictionary(
     shouldFlatten = !isLazyNotLoaded(*base) && (base->size() / 8) > size;
   }
 
-  auto kind = vector->typeKind();
+  const auto kind = vector->typeKind();
   auto result = VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
       addDictionary,
       kind,
@@ -199,11 +309,8 @@ VectorPtr BaseVector::wrapInSequence(
 }
 
 template <TypeKind kind>
-static VectorPtr addConstant(
-    vector_size_t size,
-    vector_size_t index,
-    VectorPtr vector,
-    bool copyBase) {
+static VectorPtr
+addConstant(vector_size_t size, vector_size_t index, VectorPtr vector) {
   using T = typename KindToFlatVector<kind>::WrapperType;
 
   auto* pool = vector->pool();
@@ -242,13 +349,6 @@ static VectorPtr addConstant(
     }
   }
 
-  if (copyBase) {
-    VectorPtr copy = BaseVector::create(vector->type(), 1, pool);
-    copy->copy(vector.get(), 0, index, 1);
-    return std::make_shared<ConstantVector<T>>(
-        pool, size, 0, std::move(copy), SimpleVectorStats<T>{});
-  }
-
   return std::make_shared<ConstantVector<T>>(
       pool, size, index, std::move(vector), SimpleVectorStats<T>{});
 }
@@ -257,11 +357,10 @@ static VectorPtr addConstant(
 VectorPtr BaseVector::wrapInConstant(
     vector_size_t length,
     vector_size_t index,
-    VectorPtr vector,
-    bool copyBase) {
+    VectorPtr vector) {
   const auto kind = vector->typeKind();
   return VELOX_DYNAMIC_TYPE_DISPATCH_ALL(
-      addConstant, kind, length, index, std::move(vector), copyBase);
+      addConstant, kind, length, index, std::move(vector));
 }
 
 std::optional<bool> BaseVector::equalValueAt(
@@ -550,7 +649,7 @@ std::string BaseVector::toString(vector_size_t index) const {
   if (!nulls_) {
     out << "no nulls";
   } else if (isNullAt(index)) {
-    out << "null";
+    out << kNullValueString;
   } else {
     out << "not null";
   }
@@ -593,6 +692,7 @@ void BaseVector::ensureWritable(const SelectivityVector& rows) {
   this->resetDataDependentFlags(&rows);
 }
 
+// static
 void BaseVector::ensureWritable(
     const SelectivityVector& rows,
     const TypePtr& type,
@@ -607,17 +707,22 @@ void BaseVector::ensureWritable(
     }
     return;
   }
+
   if (result->encoding() == VectorEncoding::Simple::LAZY) {
     result = BaseVector::loadedVectorShared(result);
   }
+
   const auto& resultType = result->type();
   const bool isUnknownType = resultType->containsUnknown();
+
+  // Check if ensure writable can work in place.
   if (result.use_count() == 1 && !isUnknownType) {
     switch (result->encoding()) {
       case VectorEncoding::Simple::FLAT:
       case VectorEncoding::Simple::ROW:
       case VectorEncoding::Simple::ARRAY:
       case VectorEncoding::Simple::MAP:
+      case VectorEncoding::Simple::FLAT_MAP:
       case VectorEncoding::Simple::FUNCTION: {
         result->ensureWritable(rows);
         return;
@@ -627,6 +732,8 @@ void BaseVector::ensureWritable(
     }
   }
 
+  // Otherwise, allocate a new vector and copy the remaining values over.
+
   // The copy-on-write size is the max of the writable row set and the
   // vector.
   auto targetSize = std::max<vector_size_t>(rows.end(), result->size());
@@ -638,8 +745,10 @@ void BaseVector::ensureWritable(
     copy =
         BaseVector::create(isUnknownType ? type : resultType, targetSize, pool);
   }
+
   SelectivityVector copyRows(result->size());
   copyRows.deselect(rows);
+
   if (copyRows.hasSelections()) {
     copy->copy(result.get(), copyRows, nullptr);
   }
@@ -649,7 +758,7 @@ void BaseVector::ensureWritable(
 template <TypeKind kind>
 VectorPtr newConstant(
     const TypePtr& type,
-    variant& value,
+    const Variant& value,
     vector_size_t size,
     velox::memory::MemoryPool* pool) {
   using T = typename KindToFlatVector<kind>::WrapperType;
@@ -672,7 +781,7 @@ VectorPtr newConstant(
 template <>
 VectorPtr newConstant<TypeKind::OPAQUE>(
     const TypePtr& type,
-    variant& value,
+    const Variant& value,
     vector_size_t size,
     velox::memory::MemoryPool* pool) {
   const auto& capsule = value.value<TypeKind::OPAQUE>();
@@ -681,15 +790,236 @@ VectorPtr newConstant<TypeKind::OPAQUE>(
       pool, size, value.isNull(), type, std::shared_ptr<void>(capsule.obj));
 }
 
+namespace {
+
+VectorPtr callMakeVector(
+    TypePtr type,
+    const std::vector<Variant>& data,
+    memory::MemoryPool* pool);
+
+template <TypeKind KIND, typename = void>
+struct VariantToVector {
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& /*data*/,
+      memory::MemoryPool* /*pool*/) {
+    VELOX_NYI("Type not supported: {}", type->toString());
+  }
+};
+
+template <TypeKind KIND>
+struct VariantToVector<
+    KIND,
+    std::enable_if_t<
+        TypeTraits<KIND>::isFixedWidth || KIND == TypeKind::VARCHAR ||
+            KIND == TypeKind::VARBINARY || KIND == TypeKind::OPAQUE,
+        void>> {
+  static constexpr bool kIsOpaque = (KIND == TypeKind::OPAQUE);
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& data,
+      memory::MemoryPool* pool) {
+    using T = typename TypeTraits<KIND>::NativeType;
+
+    const vector_size_t dataSize = data.size();
+    BufferPtr valuesBuffer;
+    if constexpr (std::is_same_v<T, StringView>) {
+      // Make sure to initialize StringView values so they can be safely
+      // accessed.
+      valuesBuffer = AlignedBuffer::allocate<T>(dataSize, pool, T());
+    } else {
+      valuesBuffer = AlignedBuffer::allocate<T>(dataSize, pool);
+    }
+    BufferPtr nulls = allocateNulls(dataSize, pool, bits::kNull);
+
+    auto values = std::make_shared<FlatVector<T>>(
+        pool,
+        type,
+        nulls,
+        dataSize,
+        std::move(valuesBuffer),
+        std::vector<BufferPtr>());
+
+    for (size_t i = 0; i < dataSize; i++) {
+      if (!data[i].isNull()) {
+        if constexpr (kIsOpaque) {
+          values->set(i, T(data[i].value<KIND>().obj));
+        } else {
+          values->set(i, T(data[i].value<KIND>()));
+        }
+      }
+    }
+    return values;
+  }
+};
+
+template <>
+struct VariantToVector<TypeKind::ARRAY> {
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& data,
+      memory::MemoryPool* pool) {
+    vector_size_t size = data.size();
+    BufferPtr offsets = allocateOffsets(size, pool);
+    BufferPtr sizes = allocateSizes(size, pool);
+    BufferPtr nulls = allocateNulls(size, pool);
+    auto rawOffsets = offsets->asMutable<vector_size_t>();
+    auto rawSizes = sizes->asMutable<vector_size_t>();
+    auto rawNulls = nulls->asMutable<uint64_t>();
+
+    std::vector<Variant> elements;
+    vector_size_t index = 0;
+    vector_size_t nullCount = 0;
+    for (size_t i = 0; i < data.size(); ++i) {
+      auto isNull = data[i].isNull();
+      *rawOffsets++ = index;
+      *rawSizes++ = !isNull ? data[i].array().size() : 0;
+      if (isNull) {
+        ++nullCount;
+        bits::setNull(rawNulls, i, true);
+        continue;
+      }
+      for (const auto& arrayElement : data[i].array()) {
+        elements.push_back(arrayElement);
+        ++index;
+      }
+    }
+
+    auto elementsVector = callMakeVector(type->childAt(0), elements, pool);
+
+    return std::make_shared<ArrayVector>(
+        pool,
+        type,
+        nulls,
+        size,
+        offsets,
+        sizes,
+        std::move(elementsVector),
+        nullCount);
+  }
+};
+
+template <>
+struct VariantToVector<TypeKind::MAP> {
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& data,
+      memory::MemoryPool* pool) {
+    vector_size_t size = data.size();
+    BufferPtr offsets = allocateOffsets(size, pool);
+    BufferPtr sizes = allocateSizes(size, pool);
+    BufferPtr nulls = allocateNulls(size, pool);
+    auto rawOffsets = offsets->asMutable<vector_size_t>();
+    auto rawSizes = sizes->asMutable<vector_size_t>();
+    auto rawNulls = nulls->asMutable<uint64_t>();
+
+    std::vector<Variant> keys;
+    std::vector<Variant> values;
+    vector_size_t index = 0;
+    vector_size_t nullCount = 0;
+    for (size_t i = 0; i < data.size(); ++i) {
+      auto isNull = data[i].isNull();
+      *rawOffsets++ = index;
+      *rawSizes++ = !isNull ? data[i].map().size() : 0;
+      if (isNull) {
+        ++nullCount;
+        bits::setNull(rawNulls, i, true);
+        continue;
+      }
+      for (const auto& pair : data[i].map()) {
+        keys.push_back(pair.first);
+        values.push_back(pair.second);
+        ++index;
+      }
+    }
+
+    auto keysVector = callMakeVector(type->childAt(0), keys, pool);
+    auto valuesVector = callMakeVector(type->childAt(1), values, pool);
+
+    return std::make_shared<MapVector>(
+        pool,
+        type,
+        nulls,
+        size,
+        offsets,
+        sizes,
+        std::move(keysVector),
+        std::move(valuesVector),
+        nullCount);
+  }
+};
+
+template <>
+struct VariantToVector<TypeKind::ROW> {
+  static VectorPtr makeVector(
+      TypePtr type,
+      const std::vector<Variant>& data,
+      memory::MemoryPool* pool) {
+    vector_size_t size = data.size();
+    BufferPtr nulls = allocateNulls(size, pool);
+    auto rawNulls = nulls->asMutable<uint64_t>();
+
+    auto childCount = type->size();
+    std::vector<std::vector<Variant>> children;
+    children.reserve(childCount);
+    for (size_t i = 0; i < childCount; ++i) {
+      std::vector<Variant> child;
+      child.reserve(size);
+      children.push_back(child);
+    }
+
+    for (size_t i = 0; i < data.size(); ++i) {
+      if (data[i].isNull()) {
+        bits::setNull(rawNulls, i, true);
+        continue;
+      }
+      const auto& row = data[i].row();
+      VELOX_CHECK_EQ(row.size(), children.size());
+      for (size_t j = 0; j < row.size(); ++j) {
+        children[j].push_back(row[j]);
+      }
+    }
+
+    std::vector<VectorPtr> childVectors;
+    childVectors.reserve(childCount);
+    for (size_t i = 0; i < childCount; ++i) {
+      childVectors.push_back(
+          callMakeVector(type->childAt(i), children[i], pool));
+    }
+
+    return std::make_shared<RowVector>(
+        pool, type, nulls, size, std::move(childVectors));
+  }
+};
+
+VectorPtr callMakeVector(
+    TypePtr type,
+    const std::vector<Variant>& data,
+    memory::MemoryPool* pool) {
+  return VELOX_DYNAMIC_TYPE_DISPATCH_METHOD_ALL(
+      VariantToVector, makeVector, type->kind(), type, data, pool);
+}
+
+} // namespace
+
 // static
 VectorPtr BaseVector::createConstant(
     const TypePtr& type,
-    variant value,
+    const Variant value,
     vector_size_t size,
     velox::memory::MemoryPool* pool) {
   VELOX_CHECK_EQ(type->kind(), value.kind());
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
-      newConstant, value.kind(), type, value, size, pool);
+  if (type->isPrimitiveType()) {
+    return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
+        newConstant, value.kind(), type, value, size, pool);
+  }
+
+  if (value.isNull()) {
+    return BaseVector::createNullConstant(type, size, pool);
+  }
+
+  auto variantVector = callMakeVector(type, {value}, pool);
+  return BaseVector::wrapInConstant(size, 0, std::move(variantVector));
 }
 
 // static
@@ -740,6 +1070,18 @@ void BaseVector::copy(
   copyRanges(source, ranges);
 }
 
+void BaseVector::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  if (pool == pool_) {
+    return;
+  }
+
+  if (nulls_ && !nulls_->transferTo(pool)) {
+    nulls_ = AlignedBuffer::copy<bool>(nulls_, pool);
+    rawNulls_ = nulls_->as<uint64_t>();
+  }
+  pool_ = pool;
+}
+
 namespace {
 
 template <TypeKind kind>
@@ -835,7 +1177,7 @@ uint64_t BaseVector::estimateFlatSize() const {
     const auto& leafType = leaf->type();
     return length_ *
         (leafType->isFixedWidth() ? leafType->cppSizeInBytes() : 0) +
-        BaseVector::retainedSize();
+        BaseVector::retainedSizeImpl();
   }
 
   auto avgRowSize = 1.0 * leaf->retainedSize() / leaf->size();
@@ -878,9 +1220,8 @@ void BaseVector::flattenVector(VectorPtr& vector) {
       return;
     }
     case VectorEncoding::Simple::LAZY: {
-      auto& loadedVector =
-          vector->asUnchecked<LazyVector>()->loadedVectorShared();
-      BaseVector::flattenVector(loadedVector);
+      vector = vector->asUnchecked<LazyVector>()->loadedVectorShared();
+      BaseVector::flattenVector(vector);
       return;
     }
     default:
diff --git a/velox/vector/BaseVector.h b/velox/vector/BaseVector.h
index 46d271929dc0..53726013010d 100644
--- a/velox/vector/BaseVector.h
+++ b/velox/vector/BaseVector.h
@@ -70,14 +70,14 @@ class BaseVector {
   BaseVector(const BaseVector&) = delete;
   BaseVector& operator=(const BaseVector&) = delete;
 
-  static constexpr uint64_t kNullHash = 1;
+  static constexpr uint64_t kNullHash = bits::kNullHash;
 
   BaseVector(
       velox::memory::MemoryPool* pool,
       TypePtr type,
       VectorEncoding::Simple encoding,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       std::optional<vector_size_t> distinctValueCount = std::nullopt,
       std::optional<vector_size_t> nullCount = std::nullopt,
       std::optional<ByteCount> representedByteCount = std::nullopt,
@@ -107,7 +107,7 @@ class BaseVector {
 
   inline bool isIndexInRange(vector_size_t index) const {
     // This compiles better than index >= 0 && index < length_.
-    return static_cast<uint32_t>(index) < length_;
+    return static_cast<uint32_t>(index) < static_cast<uint32_t>(length_);
   }
 
   template <typename T>
@@ -294,11 +294,6 @@ class BaseVector {
     return representedByteCount_;
   }
 
-  /// @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
@@ -547,6 +542,13 @@ class BaseVector {
   virtual VectorPtr testingCopyPreserveEncodings(
       velox::memory::MemoryPool* pool = nullptr) const = 0;
 
+  /// Transfer or copy this vector and all its buffers recursively to 'pool'.
+  /// The transfer of a buffer is allowed if its original pool and 'pool' are
+  /// from the same MemoryAllocator and the buffer is not a BufferView. If a
+  /// buffer is not allowed to be transferred, it is copied to pool. After this
+  /// call, this vector and all its buffers are owned by 'pool'.
+  virtual void transferOrCopyTo(velox::memory::MemoryPool* pool);
+
   /// 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;
@@ -598,7 +600,7 @@ class BaseVector {
 
   static VectorPtr createConstant(
       const TypePtr& type,
-      variant value,
+      Variant value,
       vector_size_t size,
       velox::memory::MemoryPool* pool);
 
@@ -628,14 +630,9 @@ class BaseVector {
   /// 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);
+  /// dictionary vector.
+  static VectorPtr
+  wrapInConstant(vector_size_t length, vector_size_t index, VectorPtr vector);
 
   /// Makes 'result' writable for 'rows'. A wrapper (e.g. dictionary, constant,
   /// sequence) is flattened and a multiply referenced flat vector is copied.
@@ -662,7 +659,7 @@ class BaseVector {
   /// 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.
+  ///  * 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
@@ -781,7 +778,7 @@ class BaseVector {
       velox::memory::MemoryPool* pool,
       BufferPtr* buffer,
       RawT** raw) {
-    vector_size_t minBytes = byteSize<T>(size);
+    auto minBytes = static_cast<uint64_t>(byteSize<T>(size));
     if (*buffer && (*buffer)->capacity() >= minBytes && (*buffer)->unique()) {
       (*buffer)->setSize(minBytes);
       if (raw) {
@@ -801,8 +798,17 @@ class BaseVector {
   }
 
   /// Returns the byte size of memory that is kept live through 'this'.
-  virtual uint64_t retainedSize() const {
-    return nulls_ ? nulls_->capacity() : 0;
+  uint64_t retainedSize() const {
+    uint64_t totalStringBufferSize{0};
+    return retainedSizeImpl(totalStringBufferSize);
+  }
+
+  /// Returns the byte size of memory that is kept live through 'this'. Also add
+  /// the total size of all string buffers recursively carried by 'this' to
+  /// totalStringBufferSize. To get the total size of all string buffers, set
+  /// the initial value of totalStringBufferSize to 0 when calling this method.
+  uint64_t retainedSize(uint64_t& totalStringBufferSize) const {
+    return retainedSizeImpl(totalStringBufferSize);
   }
 
   /// Returns an estimate of the 'retainedSize' of a flat representation of the
@@ -851,6 +857,11 @@ class BaseVector {
     return toString(false);
   }
 
+  static constexpr std::string_view kNullValueString = "null";
+
+  /// Returns the value at specified index as a Variant.
+  Variant variantAt(vector_size_t index) const;
+
   /// Returns string representation of the value in the specified row.
   virtual std::string toString(vector_size_t index) const;
 
@@ -970,6 +981,13 @@ class BaseVector {
     return nulls_ ? Buffer::slice<bool>(nulls_, offset, length, pool_) : nulls_;
   }
 
+  virtual uint64_t retainedSizeImpl(
+      uint64_t& /*totalStringBufferSize*/) const = 0;
+
+  uint64_t retainedSizeImpl() const {
+    return nulls_ ? nulls_->capacity() : 0;
+  }
+
   TypePtr type_;
   const TypeKind typeKind_;
   // Whether `type_` is a type that provides custom comparison operations.
@@ -993,7 +1011,6 @@ class BaseVector {
   std::optional<vector_size_t> distinctValueCount_;
   std::optional<ByteCount> representedByteCount_;
   std::optional<ByteCount> storageByteCount_;
-  ByteCount inMemoryBytes_ = 0;
 
  private:
   static VectorPtr createInternal(
diff --git a/velox/vector/BiasVector-inl.h b/velox/vector/BiasVector-inl.h
index 8265ac6ee64b..f6a2f7cb5664 100644
--- a/velox/vector/BiasVector-inl.h
+++ b/velox/vector/BiasVector-inl.h
@@ -33,7 +33,7 @@ template <typename T>
 BiasVector<T>::BiasVector(
     velox::memory::MemoryPool* pool,
     BufferPtr nulls,
-    size_t length,
+    vector_size_t length,
     TypeKind valueType,
     BufferPtr values,
     T bias,
@@ -47,7 +47,7 @@ BiasVector<T>::BiasVector(
           pool,
           CppToType<T>::create(),
           VectorEncoding::Simple::BIASED,
-          nulls,
+          std::move(nulls),
           length,
           stats,
           distinctCount,
@@ -63,9 +63,10 @@ BiasVector<T>::BiasVector(
           valueType_ == TypeKind::TINYINT,
       "Invalid array type for biased values");
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   biasBuffer_ = simd::setAll(bias_);
+#endif
   rawValues_ = values_->as<uint8_t>();
-  BaseVector::inMemoryBytes_ += values_->size();
 }
 
 template <typename T>
@@ -110,6 +111,7 @@ const T BiasVector<T>::valueAtFast(vector_size_t idx) const {
   }
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 xsimd::batch<T> BiasVector<T>::loadSIMDValueBufferAt(size_t index) const {
   if constexpr (std::is_same_v<T, int64_t>) {
@@ -143,5 +145,6 @@ xsimd::batch<T> BiasVector<T>::loadSIMDValueBufferAt(size_t index) const {
     VELOX_UNSUPPORTED("Unsupported type for biased vector");
   }
 }
+#endif
 
 } // namespace facebook::velox
diff --git a/velox/vector/BiasVector.h b/velox/vector/BiasVector.h
index bc81fb02b277..bb2a74a8c34b 100644
--- a/velox/vector/BiasVector.h
+++ b/velox/vector/BiasVector.h
@@ -92,14 +92,16 @@ class BiasVector : public SimpleVector<T> {
   //    bias");
 
  public:
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd =
       (std::is_same_v<T, int64_t> || std::is_same_v<T, int32_t> ||
        std::is_same_v<T, int16_t>);
+#endif
 
   BiasVector(
       velox::memory::MemoryPool* pool,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       TypeKind valueType,
       BufferPtr values,
       T bias,
@@ -123,6 +125,7 @@ class BiasVector : public SimpleVector<T> {
     return valueAtFast(idx);
   }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /**
    * Loads a SIMD vector of data at the virtual byteOffset given
    * Note this method is implemented on each vector type, but is intentionally
@@ -131,6 +134,7 @@ class BiasVector : public SimpleVector<T> {
    * @param byteOffset - the byte offset to laod from
    */
   xsimd::batch<T> loadSIMDValueBufferAt(size_t index) const;
+#endif
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
@@ -142,10 +146,6 @@ class BiasVector : public SimpleVector<T> {
     return valueType_;
   }
 
-  uint64_t retainedSize() const override {
-    return BaseVector::retainedSize() + values_->capacity();
-  }
-
   /**
    * Returns a shared_ptr to the underlying arrow array holding the values for
    * this vector. This is used during execution to process over the subset of
@@ -181,13 +181,24 @@ class BiasVector : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* /*pool*/) override {
+    VELOX_UNSUPPORTED("transferTo not defined for BiasVector");
+  }
+
  private:
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   template <typename U>
   inline xsimd::batch<T> loadSIMDInternal(size_t byteOffset) const {
     auto mem = reinterpret_cast<const U*>(
         rawValues_ + byteOffset / sizeof(T) * sizeof(U));
     return xsimd::batch<T>::load_unaligned(mem);
   }
+#endif
+
+  uint64_t retainedSizeImpl(
+      uint64_t& /*totalStringBufferSize*/) const override {
+    return BaseVector::retainedSizeImpl() + values_->capacity();
+  }
 
   TypeKind valueType_;
   BufferPtr values_;
@@ -197,8 +208,10 @@ class BiasVector : public SimpleVector<T> {
   // support is 64 bit and all biasing requires a smaller internal type.
   T bias_;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   // Used to debias several values at a time.
   std::conditional_t<can_simd, xsimd::batch<T>, char> biasBuffer_;
+#endif
 };
 
 template <typename T>
diff --git a/velox/vector/CMakeLists.txt b/velox/vector/CMakeLists.txt
index 11782f2a7ffb..10769cc214d9 100644
--- a/velox/vector/CMakeLists.txt
+++ b/velox/vector/CMakeLists.txt
@@ -31,7 +31,8 @@ velox_add_library(
   VectorPool.cpp
   VectorPrinter.cpp
   VectorSaver.cpp
-  VectorStream.cpp)
+  VectorStream.cpp
+)
 
 velox_link_libraries(
   velox_vector
@@ -40,7 +41,8 @@ velox_link_libraries(
   velox_row_fast
   velox_time
   velox_type
-  velox_buffer)
+  velox_buffer
+)
 
 add_subdirectory(arrow)
 add_subdirectory(fuzzer)
diff --git a/velox/vector/ComplexVector.cpp b/velox/vector/ComplexVector.cpp
index 03d385cfba02..dde09e3a873f 100644
--- a/velox/vector/ComplexVector.cpp
+++ b/velox/vector/ComplexVector.cpp
@@ -21,51 +21,20 @@
 #include "velox/common/base/Exceptions.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
+#include "velox/vector/FlatMapVector.h"
+#include "velox/vector/LazyVector.h"
 #include "velox/vector/SimpleVector.h"
 
 namespace facebook::velox {
 
-// Up to # of elements to show as debug string for `toString()`.
-constexpr vector_size_t kMaxElementsInToString = 5;
-
-std::string stringifyTruncatedElementList(
-    vector_size_t start,
-    vector_size_t size,
-    vector_size_t limit,
-    std::string_view delimiter,
-    const std::function<void(std::stringstream&, vector_size_t)>&
-        stringifyElementCB) {
-  std::stringstream out;
-  if (size == 0) {
-    return "<empty>";
-  }
-  out << size << " elements starting at " << start << " {";
-
-  const vector_size_t limitedSize = std::min(size, limit);
-  for (vector_size_t i = 0; i < limitedSize; ++i) {
-    if (i > 0) {
-      out << delimiter;
-    }
-    stringifyElementCB(out, start + i);
-  }
-
-  if (size > limitedSize) {
-    if (limitedSize) {
-      out << delimiter;
-    }
-    out << "...";
-  }
-  out << "}";
-  return out.str();
-}
-
 // static
 std::shared_ptr<RowVector> RowVector::createEmpty(
     std::shared_ptr<const Type> type,
     velox::memory::MemoryPool* pool) {
   VELOX_CHECK_NOT_NULL(type, "Vector creation requires a non-null type.");
   VELOX_CHECK(type->isRow());
-  return std::static_pointer_cast<RowVector>(BaseVector::create(type, 0, pool));
+  return BaseVector::create<RowVector>(type, 0, pool);
 }
 
 bool RowVector::containsNullAt(vector_size_t idx) const {
@@ -280,7 +249,10 @@ 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));
+    auto& child = children_[i];
+    if (child) {
+      child->setType(type_->asRow().childAt(i));
+    }
   }
 }
 
@@ -378,10 +350,12 @@ void RowVector::copyRanges(
 }
 
 uint64_t RowVector::hashValueAt(vector_size_t index) const {
+  uint64_t hash = BaseVector::kNullHash;
+
   if (isNullAt(index)) {
-    return BaseVector::kNullHash;
+    return hash;
   }
-  uint64_t hash = BaseVector::kNullHash;
+
   bool isFirst = true;
   for (auto i = 0; i < childrenSize(); ++i) {
     auto& child = children_[i];
@@ -399,20 +373,26 @@ std::unique_ptr<SimpleVector<uint64_t>> RowVector::hashAll() const {
 }
 
 std::string RowVector::toString(vector_size_t index) const {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  return deprecatedToString(index, 5 /* limit */);
+#pragma GCC diagnostic pop
+}
+
+std::string RowVector::deprecatedToString(
+    vector_size_t index,
+    vector_size_t limit) const {
   VELOX_CHECK_LT(index, length_, "Vector index should be less than length.");
   if (isNullAt(index)) {
-    return "null";
-  }
-  std::stringstream out;
-  out << "{";
-  for (int32_t i = 0; i < children_.size(); ++i) {
-    if (i > 0) {
-      out << ", ";
-    }
-    out << (children_[i] ? children_[i]->toString(index) : "<not set>");
+    return std::string(BaseVector::kNullValueString);
   }
-  out << "}";
-  return out.str();
+
+  return stringifyTruncatedElementList(
+      children_.size(),
+      [&](auto& out, auto i) {
+        out << (children_[i] ? children_[i]->toString(index) : "<not set>");
+      },
+      limit);
 }
 
 void RowVector::ensureWritable(const SelectivityVector& rows) {
@@ -437,8 +417,18 @@ bool RowVector::isWritable() const {
   return isNullsWritable();
 }
 
+void RowVector::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  BaseVector::transferOrCopyTo(pool);
+  for (auto& child : children_) {
+    child->transferOrCopyTo(pool);
+  }
+  if (rawVectorForBatchReader_) {
+    rawVectorForBatchReader_->transferOrCopyTo(pool);
+  }
+}
+
 uint64_t RowVector::estimateFlatSize() const {
-  uint64_t total = BaseVector::retainedSize();
+  uint64_t total = BaseVector::retainedSizeImpl();
   for (const auto& child : children_) {
     if (child) {
       total += child->estimateFlatSize();
@@ -941,6 +931,28 @@ bool ArrayVectorBase::hasOverlappingRanges(
   return false;
 }
 
+void ArrayVectorBase::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  BaseVector::transferOrCopyTo(pool);
+  if (!offsets_->transferTo(pool)) {
+    offsets_ = AlignedBuffer::copy<vector_size_t>(offsets_, pool);
+    rawOffsets_ = offsets_->as<vector_size_t>();
+  }
+  if (!sizes_->transferTo(pool)) {
+    sizes_ = AlignedBuffer::copy<vector_size_t>(sizes_, pool);
+    rawSizes_ = sizes_->as<vector_size_t>();
+  }
+}
+
+void ArrayVectorBase::ensureNullRowsEmpty() {
+  if (!rawNulls_) {
+    return;
+  }
+  auto* offsets = offsets_->asMutable<vector_size_t>();
+  auto* sizes = sizes_->asMutable<vector_size_t>();
+  bits::forEachUnsetBit(
+      rawNulls_, 0, size(), [&](auto i) { offsets[i] = sizes[i] = 0; });
+}
+
 void ArrayVectorBase::validateArrayVectorBase(
     const VectorValidateOptions& options,
     vector_size_t minChildVectorSize) const {
@@ -1113,26 +1125,22 @@ void ArrayVector::setType(const TypePtr& type) {
   elements_->setType(type_->asArray().elementType());
 }
 
-namespace {
-uint64_t hashArray(
-    uint64_t hash,
-    const BaseVector& elements,
-    vector_size_t offset,
-    vector_size_t size) {
-  for (auto i = 0; i < size; ++i) {
-    auto elementHash = elements.hashValueAt(offset + i);
-    hash = bits::commutativeHashMix(hash, elementHash);
-  }
-  return hash;
-}
-} // namespace
-
 uint64_t ArrayVector::hashValueAt(vector_size_t index) const {
+  uint64_t hash = kNullHash;
+
   if (isNullAt(index)) {
-    return BaseVector::kNullHash;
+    return hash;
+  }
+
+  const auto offset = rawOffsets_[index];
+  const auto size = rawSizes_[index];
+
+  for (auto i = 0; i < size; ++i) {
+    auto elementHash = elements_->hashValueAt(offset + i);
+    hash = bits::hashMix(hash, elementHash);
   }
-  return hashArray(
-      BaseVector::kNullHash, *elements_, rawOffsets_[index], rawSizes_[index]);
+
+  return hash;
 }
 
 std::unique_ptr<SimpleVector<uint64_t>> ArrayVector::hashAll() const {
@@ -1142,22 +1150,20 @@ std::unique_ptr<SimpleVector<uint64_t>> ArrayVector::hashAll() const {
 std::string ArrayVector::toString(vector_size_t index) const {
   VELOX_CHECK_LT(index, length_, "Vector index should be less than length.");
   if (isNullAt(index)) {
-    return "null";
+    return std::string(BaseVector::kNullValueString);
   }
 
+  const auto offset = rawOffsets_[index];
+
   return stringifyTruncatedElementList(
-      rawOffsets_[index],
-      rawSizes_[index],
-      kMaxElementsInToString,
-      ", ",
-      [this](std::stringstream& ss, vector_size_t index) {
-        ss << elements_->toString(index);
+      rawSizes_[index], [&](std::stringstream& ss, vector_size_t index) {
+        ss << elements_->toString(offset + index);
       });
 }
 
 void ArrayVector::ensureWritable(const SelectivityVector& rows) {
   auto newSize = std::max<vector_size_t>(rows.end(), BaseVector::length_);
-  if (offsets_ && !offsets_->unique()) {
+  if (offsets_ && !offsets_->isMutable()) {
     BufferPtr newOffsets =
         AlignedBuffer::allocate<vector_size_t>(newSize, BaseVector::pool_);
     auto rawNewOffsets = newOffsets->asMutable<vector_size_t>();
@@ -1176,7 +1182,7 @@ void ArrayVector::ensureWritable(const SelectivityVector& rows) {
     rawOffsets_ = offsets_->as<vector_size_t>();
   }
 
-  if (sizes_ && !sizes_->unique()) {
+  if (sizes_ && !sizes_->isMutable()) {
     BufferPtr newSizes =
         AlignedBuffer::allocate<vector_size_t>(newSize, BaseVector::pool_);
     auto rawNewSizes = newSizes->asMutable<vector_size_t>();
@@ -1209,8 +1215,13 @@ bool ArrayVector::isWritable() const {
   return isNullsWritable() && BaseVector::isVectorWritable(elements_);
 }
 
+void ArrayVector::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  ArrayVectorBase::transferOrCopyTo(pool);
+  elements_->transferOrCopyTo(pool);
+}
+
 uint64_t ArrayVector::estimateFlatSize() const {
-  return BaseVector::retainedSize() + offsets_->capacity() +
+  return BaseVector::retainedSizeImpl() + offsets_->capacity() +
       sizes_->capacity() + elements_->estimateFlatSize();
 }
 
@@ -1298,55 +1309,71 @@ std::optional<int32_t> MapVector::compare(
 
   auto otherValue = other->wrappedVector();
   auto wrappedOtherIndex = other->wrappedIndex(otherIndex);
-  VELOX_CHECK_EQ(
-      VectorEncoding::Simple::MAP,
-      otherValue->encoding(),
-      "Compare of MAP and non-MAP: {} and {}",
-      BaseVector::toString(),
-      otherValue->BaseVector::toString());
-  auto otherMap = otherValue->as<MapVector>();
 
-  if (keys_->typeKind() != otherMap->keys_->typeKind() ||
-      values_->typeKind() != otherMap->values_->typeKind()) {
-    VELOX_FAIL(
-        "Compare of maps of different key/value types: {} and {}",
-        BaseVector::toString(),
-        otherMap->BaseVector::toString());
-  }
+  if (otherValue->encoding() == VectorEncoding::Simple::MAP) {
+    auto otherMap = otherValue->as<MapVector>();
 
-  if (flags.equalsOnly &&
-      rawSizes_[index] != otherMap->rawSizes_[wrappedOtherIndex]) {
-    return 1;
-  }
+    if (keys_->typeKind() != otherMap->keys_->typeKind() ||
+        values_->typeKind() != otherMap->values_->typeKind()) {
+      VELOX_FAIL(
+          "Compare of maps of different key/value types: {} and {}",
+          BaseVector::toString(),
+          otherMap->BaseVector::toString());
+    }
 
-  auto leftIndices = sortedKeyIndices(index);
-  auto rightIndices = otherMap->sortedKeyIndices(wrappedOtherIndex);
+    if (flags.equalsOnly &&
+        rawSizes_[index] != otherMap->rawSizes_[wrappedOtherIndex]) {
+      return 1;
+    }
 
-  auto result =
-      compareArrays(*keys_, *otherMap->keys_, leftIndices, rightIndices, flags);
-  VELOX_DCHECK(result.has_value(), "Keys may not have nulls or nested nulls");
+    auto leftIndices = sortedKeyIndices(index);
+    auto rightIndices = otherMap->sortedKeyIndices(wrappedOtherIndex);
 
-  // Keys are not the same, values not compared.
-  if (result.value()) {
-    return result;
-  }
+    auto result = compareArrays(
+        *keys_, *otherMap->keys_, leftIndices, rightIndices, flags);
+    VELOX_DCHECK(result.has_value(), "Keys may not have nulls or nested nulls");
 
-  return compareArrays(
-      *values_, *otherMap->values_, leftIndices, rightIndices, flags);
+    // Keys are not the same, values not compared.
+    if (result.value()) {
+      return result;
+    }
+
+    return compareArrays(
+        *values_, *otherMap->values_, leftIndices, rightIndices, flags);
+  } else if (otherValue->encoding() == VectorEncoding::Simple::FLAT_MAP) {
+    auto otherFlatMap = otherValue->as<FlatMapVector>();
+
+    // Reverse the order and compare the flat map to the map, this way we can
+    // reuse the implementation in FlatMapVector.
+    return otherFlatMap->compare(
+        this, wrappedOtherIndex, index, CompareFlags::reverseDirection(flags));
+  } else {
+    VELOX_FAIL(
+        "Compare of MAP and non-MAP: {} and {}",
+        BaseVector::toString(),
+        otherValue->BaseVector::toString());
+  }
 }
 
 uint64_t MapVector::hashValueAt(vector_size_t index) const {
+  uint64_t hash = BaseVector::kNullHash;
+
   if (isNullAt(index)) {
-    return BaseVector::kNullHash;
+    return hash;
   }
+
+  // We use a commutative hash mix, thus we do not sort first.
   auto offset = rawOffsets_[index];
   auto size = rawSizes_[index];
-  // We use a commutative hash mix, thus we do not sort first.
-  return hashArray(
-      hashArray(BaseVector::kNullHash, *keys_, offset, size),
-      *values_,
-      offset,
-      size);
+
+  for (auto i = 0; i < size; ++i) {
+    auto elementHash = bits::hashMix(
+        keys_->hashValueAt(offset + i), values_->hashValueAt(offset + i));
+
+    hash = bits::commutativeHashMix(hash, elementHash);
+  }
+
+  return hash;
 }
 
 std::unique_ptr<SimpleVector<uint64_t>> MapVector::hashAll() const {
@@ -1444,21 +1471,21 @@ BufferPtr MapVector::elementIndices() const {
 std::string MapVector::toString(vector_size_t index) const {
   VELOX_CHECK_LT(index, length_, "Vector index should be less than length.");
   if (isNullAt(index)) {
-    return "null";
+    return std::string(BaseVector::kNullValueString);
   }
+
+  const auto offset = rawOffsets_[index];
+
   return stringifyTruncatedElementList(
-      rawOffsets_[index],
-      rawSizes_[index],
-      kMaxElementsInToString,
-      ", ",
-      [this](std::stringstream& ss, vector_size_t index) {
-        ss << keys_->toString(index) << " => " << values_->toString(index);
+      rawSizes_[index], [&](std::stringstream& ss, vector_size_t index) {
+        ss << keys_->toString(offset + index) << " => "
+           << values_->toString(offset + index);
       });
 }
 
 void MapVector::ensureWritable(const SelectivityVector& rows) {
   auto newSize = std::max<vector_size_t>(rows.end(), BaseVector::length_);
-  if (offsets_ && !offsets_->unique()) {
+  if (offsets_ && !offsets_->isMutable()) {
     BufferPtr newOffsets =
         AlignedBuffer::allocate<vector_size_t>(newSize, BaseVector::pool_);
     auto rawNewOffsets = newOffsets->asMutable<vector_size_t>();
@@ -1477,7 +1504,7 @@ void MapVector::ensureWritable(const SelectivityVector& rows) {
     rawOffsets_ = offsets_->as<vector_size_t>();
   }
 
-  if (sizes_ && !sizes_->unique()) {
+  if (sizes_ && !sizes_->isMutable()) {
     BufferPtr newSizes =
         AlignedBuffer::allocate<vector_size_t>(newSize, BaseVector::pool_);
     auto rawNewSizes = newSizes->asMutable<vector_size_t>();
@@ -1513,8 +1540,14 @@ bool MapVector::isWritable() const {
       BaseVector::isVectorWritable(values_);
 }
 
+void MapVector::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  ArrayVectorBase::transferOrCopyTo(pool);
+  keys_->transferOrCopyTo(pool);
+  values_->transferOrCopyTo(pool);
+}
+
 uint64_t MapVector::estimateFlatSize() const {
-  return BaseVector::retainedSize() + offsets_->capacity() +
+  return BaseVector::retainedSizeImpl() + offsets_->capacity() +
       sizes_->capacity() + keys_->estimateFlatSize() +
       values_->estimateFlatSize();
 }
@@ -1650,12 +1683,17 @@ MapVectorPtr MapVector::updateImpl(
     }
     if (newNulls.get() == nulls().get()) {
       newNulls = allocateNulls(size(), pool());
-      bits::andBits(
-          newNulls->asMutable<uint64_t>(),
-          rawNulls(),
-          other.nulls(),
-          0,
-          size());
+      if (!rawNulls()) {
+        bits::copyBits(
+            other.nulls(), 0, newNulls->asMutable<uint64_t>(), 0, size());
+      } else {
+        bits::andBits(
+            newNulls->asMutable<uint64_t>(),
+            rawNulls(),
+            other.nulls(),
+            0,
+            size());
+      }
     } else {
       bits::andBits(newNulls->asMutable<uint64_t>(), other.nulls(), 0, size());
     }
@@ -1714,7 +1752,7 @@ MapVectorPtr MapVector::updateImpl(
       auto size = vector->sizeAt(ii);
       for (vector_size_t j = 0; j < size; ++j) {
         auto jj = offset + j;
-        VELOX_DCHECK(!keys[k].isNullAt(jj));
+        VELOX_CHECK(!keys[k].isNullAt(jj), "Map key cannot be null");
         mapRow.insert(&keys[k], jj, k);
       }
     }
diff --git a/velox/vector/ComplexVector.h b/velox/vector/ComplexVector.h
index 961960ab0753..eefe7d93510d 100644
--- a/velox/vector/ComplexVector.h
+++ b/velox/vector/ComplexVector.h
@@ -16,15 +16,12 @@
 
 #pragma once
 
-#include <type_traits>
-
 #include <folly/container/F14Map.h>
 #include <folly/hash/Hash.h>
 #include <glog/logging.h>
 
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
-#include "velox/vector/LazyVector.h"
 #include "velox/vector/TypeAliases.h"
 
 namespace facebook::velox {
@@ -36,16 +33,16 @@ class RowVector : public BaseVector {
 
   RowVector(
       velox::memory::MemoryPool* pool,
-      std::shared_ptr<const Type> type,
+      const TypePtr& type,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       std::vector<VectorPtr> children,
       std::optional<vector_size_t> nullCount = std::nullopt)
       : BaseVector(
             pool,
             type,
             VectorEncoding::Simple::ROW,
-            nulls,
+            std::move(nulls),
             length,
             std::nullopt,
             nullCount,
@@ -59,7 +56,7 @@ class RowVector : public BaseVector {
 
     // Check child vector types.
     // This can be an expensive operation, so it's only done at debug time.
-    for (auto i = 0; i < children_.size(); i++) {
+    for (size_t i = 0; i < children_.size(); i++) {
       const auto& child = children_[i];
       if (child) {
         VELOX_DCHECK(
@@ -69,7 +66,6 @@ class RowVector : public BaseVector {
             rowType->nameOf(i),
             i,
             type->childAt(i)->toString());
-        BaseVector::inMemoryBytes_ += child->inMemoryBytes();
       }
     }
     updateContainsLazyNotLoaded();
@@ -79,7 +75,7 @@ class RowVector : public BaseVector {
       std::shared_ptr<const Type> type,
       velox::memory::MemoryPool* pool);
 
-  virtual ~RowVector() override {}
+  ~RowVector() override = default;
 
   bool containsNullAt(vector_size_t idx) const override;
 
@@ -99,6 +95,11 @@ class RowVector : public BaseVector {
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
+  /// Convenience getter. Shortcut for asRowType(type()).
+  RowTypePtr rowType() const {
+    return asRowType(type());
+  }
+
   /// Return the number of child vectors.
   /// This will exactly match the number of fields.
   size_t childrenSize() const {
@@ -168,7 +169,7 @@ class RowVector : public BaseVector {
       velox::memory::MemoryPool* pool = nullptr) const override {
     std::vector<VectorPtr> copiedChildren(children_.size());
 
-    for (auto i = 0; i < children_.size(); ++i) {
+    for (size_t i = 0; i < children_.size(); ++i) {
       copiedChildren[i] = children_[i]->testingCopyPreserveEncodings(pool);
     }
 
@@ -182,15 +183,7 @@ class RowVector : public BaseVector {
         nullCount_);
   }
 
-  uint64_t retainedSize() const override {
-    auto size = BaseVector::retainedSize();
-    for (auto& child : children_) {
-      if (child) {
-        size += child->retainedSize();
-      }
-    }
-    return size;
-  }
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
 
   uint64_t estimateFlatSize() const override;
 
@@ -198,6 +191,12 @@ class RowVector : public BaseVector {
 
   std::string toString(vector_size_t index) const override;
 
+  /// For backwards compatibility.
+  /// TODO Remove after updating callsites.
+  [[deprecated]]
+  std::string deprecatedToString(vector_size_t index, vector_size_t limit)
+      const;
+
   void ensureWritable(const SelectivityVector& rows) override;
 
   bool isWritable() const override;
@@ -285,6 +284,16 @@ class RowVector : public BaseVector {
       vector_size_t count,
       vector_size_t childSize);
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    auto size = BaseVector::retainedSizeImpl();
+    for (auto& child : children_) {
+      if (child) {
+        size += child->retainedSize(totalStringBufferSize);
+      }
+    }
+    return size;
+  }
+
   const size_t childrenSize_;
   mutable std::vector<VectorPtr> children_;
 
@@ -312,6 +321,7 @@ class RowVector : public BaseVector {
 /// 'sizes' data and provide manipulations on them.
 struct ArrayVectorBase : BaseVector {
   ArrayVectorBase(const ArrayVectorBase&) = delete;
+
   const BufferPtr& offsets() const {
     return offsets_;
   }
@@ -336,12 +346,12 @@ struct ArrayVectorBase : BaseVector {
     return rawSizes_[index];
   }
 
-  BufferPtr mutableOffsets(size_t size) {
+  BufferPtr mutableOffsets(vector_size_t size) {
     BaseVector::resizeIndices(length_, size, pool_, offsets_, &rawOffsets_);
     return offsets_;
   }
 
-  BufferPtr mutableSizes(size_t size) {
+  BufferPtr mutableSizes(vector_size_t size) {
     BaseVector::resizeIndices(length_, size, pool_, sizes_, &rawSizes_);
     return sizes_;
   }
@@ -363,6 +373,8 @@ struct ArrayVectorBase : BaseVector {
     sizes_->asMutable<vector_size_t>()[i] = size;
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
+
   /// Check if there is any overlapping [offset, size] ranges.
   bool hasOverlappingRanges() const {
     std::vector<vector_size_t> indices;
@@ -382,19 +394,24 @@ struct ArrayVectorBase : BaseVector {
       const vector_size_t* sizes,
       std::vector<vector_size_t>& indices);
 
+  /// Ensure the offsets and sizes of null rows are all 0.  It's caller's
+  /// responsibility to make sure the vector as well as offsets and sizes
+  /// buffers are mutable (e.g. singly referenced).
+  void ensureNullRowsEmpty();
+
  protected:
   ArrayVectorBase(
       velox::memory::MemoryPool* pool,
-      std::shared_ptr<const Type> type,
+      TypePtr type,
       VectorEncoding::Simple encoding,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       std::optional<vector_size_t> nullCount,
       BufferPtr offsets,
       BufferPtr lengths)
       : BaseVector(
             pool,
-            type,
+            std::move(type),
             encoding,
             std::move(nulls),
             length,
@@ -436,7 +453,7 @@ class ArrayVector : public ArrayVectorBase {
       velox::memory::MemoryPool* pool,
       std::shared_ptr<const Type> type,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       BufferPtr offsets,
       BufferPtr lengths,
       VectorPtr elements,
@@ -450,10 +467,11 @@ class ArrayVector : public ArrayVectorBase {
             nullCount,
             std::move(offsets),
             std::move(lengths)),
-        elements_(BaseVector::getOrCreateEmpty(
-            std::move(elements),
-            type->childAt(0),
-            pool)) {
+        elements_(
+            BaseVector::getOrCreateEmpty(
+                std::move(elements),
+                type->childAt(0),
+                pool)) {
     VELOX_CHECK_EQ(type->kind(), TypeKind::ARRAY);
     VELOX_CHECK(
         elements_->type()->kindEquals(type->childAt(0)),
@@ -507,10 +525,7 @@ class ArrayVector : public ArrayVectorBase {
         nullCount_);
   }
 
-  uint64_t retainedSize() const override {
-    return BaseVector::retainedSize() + offsets_->capacity() +
-        sizes_->capacity() + elements_->retainedSize();
-  }
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
 
   uint64_t estimateFlatSize() const override;
 
@@ -538,6 +553,11 @@ class ArrayVector : public ArrayVectorBase {
   void validate(const VectorValidateOptions& options) const override;
 
  private:
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return BaseVector::retainedSizeImpl() + offsets_->capacity() +
+        sizes_->capacity() + elements_->retainedSize(totalStringBufferSize);
+  }
+
   VectorPtr elements_;
 };
 
@@ -548,9 +568,9 @@ class MapVector : public ArrayVectorBase {
 
   MapVector(
       velox::memory::MemoryPool* pool,
-      std::shared_ptr<const Type> type,
+      const TypePtr& type,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       BufferPtr offsets,
       BufferPtr sizes,
       VectorPtr keys,
@@ -566,14 +586,16 @@ class MapVector : public ArrayVectorBase {
             nullCount,
             std::move(offsets),
             std::move(sizes)),
-        keys_(BaseVector::getOrCreateEmpty(
-            std::move(keys),
-            type->childAt(0),
-            pool)),
-        values_(BaseVector::getOrCreateEmpty(
-            std::move(values),
-            type->childAt(1),
-            pool)),
+        keys_(
+            BaseVector::getOrCreateEmpty(
+                std::move(keys),
+                type->childAt(0),
+                pool)),
+        values_(
+            BaseVector::getOrCreateEmpty(
+                std::move(values),
+                type->childAt(1),
+                pool)),
         sortedKeys_{sortedKeys} {
     VELOX_CHECK_EQ(type->kind(), TypeKind::MAP);
 
@@ -589,7 +611,7 @@ class MapVector : public ArrayVectorBase {
         type->childAt(1)->toString());
   }
 
-  virtual ~MapVector() override {}
+  ~MapVector() override = default;
 
   bool containsNullAt(vector_size_t idx) const override;
 
@@ -652,10 +674,7 @@ class MapVector : public ArrayVectorBase {
         sortedKeys_);
   }
 
-  uint64_t retainedSize() const override {
-    return BaseVector::retainedSize() + offsets_->capacity() +
-        sizes_->capacity() + keys_->retainedSize() + values_->retainedSize();
-  }
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
 
   uint64_t estimateFlatSize() const override;
 
@@ -709,7 +728,7 @@ class MapVector : public ArrayVectorBase {
       const folly::Range<DecodedVector*>& others) const;
 
  protected:
-  virtual void resetDataDependentFlags(const SelectivityVector* rows) override {
+  void resetDataDependentFlags(const SelectivityVector* rows) override {
     BaseVector::resetDataDependentFlags(rows);
     sortedKeys_ = false;
   }
@@ -727,6 +746,12 @@ class MapVector : public ArrayVectorBase {
   std::shared_ptr<MapVector> updateImpl(
       const folly::Range<DecodedVector*>& others) const;
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return BaseVector::retainedSizeImpl() + offsets_->capacity() +
+        sizes_->capacity() + keys_->retainedSize(totalStringBufferSize) +
+        values_->retainedSize(totalStringBufferSize);
+  }
+
   VectorPtr keys_;
   VectorPtr values_;
   bool sortedKeys_;
diff --git a/velox/vector/ConstantVector.h b/velox/vector/ConstantVector.h
index 53f286c1a4a5..46e33519f3df 100644
--- a/velox/vector/ConstantVector.h
+++ b/velox/vector/ConstantVector.h
@@ -39,14 +39,16 @@ class ConstantVector final : public SimpleVector<T> {
   ConstantVector(const ConstantVector&) = delete;
   ConstantVector& operator=(const ConstantVector&) = delete;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd =
       (std::is_same_v<T, int64_t> || std::is_same_v<T, int32_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>);
+#endif
 
   ConstantVector(
       velox::memory::MemoryPool* pool,
-      size_t length,
+      vector_size_t length,
       bool isNull,
       TypePtr type,
       T&& val,
@@ -70,7 +72,7 @@ class ConstantVector final : public SimpleVector<T> {
         initialized_(true) {
     makeNullsBuffer();
     // Special handling for complex types
-    if (type->size() > 0) {
+    if (type->size() > 0 || type->kind() == TypeKind::ROW) {
       // Only allow null constants to be created through this interface.
       VELOX_CHECK(isNull_);
       valueVector_ = BaseVector::create(type, 1, pool);
@@ -82,10 +84,12 @@ class ConstantVector final : public SimpleVector<T> {
         setValue(value_.str());
       }
     }
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
     // If this is not encoded integer, or string, set value buffer
     if constexpr (can_simd) {
       valueBuffer_ = simd::setAll(value_);
     }
+#endif
   }
 
   /// Creates constant vector with value coming from 'index' element of the
@@ -187,6 +191,7 @@ class ConstantVector final : public SimpleVector<T> {
     return &value_;
   }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /// 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
@@ -194,20 +199,10 @@ class ConstantVector final : public SimpleVector<T> {
     VELOX_DCHECK(initialized_);
     return valueBuffer_;
   }
+#endif
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
-  uint64_t retainedSize() const override {
-    VELOX_DCHECK(initialized_);
-    if (valueVector_) {
-      return valueVector_->retainedSize();
-    }
-    if (stringBuffer_) {
-      return stringBuffer_->capacity();
-    }
-    return sizeof(T);
-  }
-
   BaseVector* loadedVector() override {
     if (!valueVector_) {
       return this;
@@ -242,10 +237,11 @@ class ConstantVector final : public SimpleVector<T> {
     static const DummyReleaser kDummy;
     auto* wrapInfo = wrapInfo_.load();
     if (FOLLY_UNLIKELY(!wrapInfo)) {
-      wrapInfo = new BufferPtr(BufferView<DummyReleaser>::create(
-          reinterpret_cast<const uint8_t*>(&index_),
-          sizeof(vector_size_t),
-          kDummy));
+      wrapInfo = new BufferPtr(
+          BufferView<DummyReleaser>::create(
+              reinterpret_cast<const uint8_t*>(&index_),
+              sizeof(vector_size_t),
+              kDummy));
       BufferPtr* oldWrapInfo = nullptr;
       if (!wrapInfo_.compare_exchange_strong(oldWrapInfo, wrapInfo)) {
         delete wrapInfo;
@@ -345,9 +341,9 @@ class ConstantVector final : public SimpleVector<T> {
     }
 
     if (isNull_) {
-      return "null";
+      return std::string(BaseVector::kNullValueString);
     } else {
-      return SimpleVector<T>::valueToString(value());
+      return BaseVector::type()->template valueToString<T>(value());
     }
   }
 
@@ -396,6 +392,22 @@ class ConstantVector final : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override {
+    BaseVector::transferOrCopyTo(pool);
+    if (valueVector_) {
+      valueVector_->transferOrCopyTo(pool);
+    }
+    if constexpr (std::is_same_v<T, StringView>) {
+      if (stringBuffer_ && !stringBuffer_->transferTo(pool)) {
+        auto newBuffer = AlignedBuffer::copy<char>(stringBuffer_, pool);
+        auto offset = value_.data() - stringBuffer_->template as<char>();
+        value_ =
+            StringView(newBuffer->template as<char>() + offset, value_.size());
+        stringBuffer_ = std::move(newBuffer);
+      }
+    }
+  }
+
  protected:
   std::string toSummaryString() const override {
     std::stringstream out;
@@ -447,11 +459,12 @@ class ConstantVector final : public SimpleVector<T> {
   }
 
   void setValue(const std::string& string) {
-    BaseVector::inMemoryBytes_ += string.size();
     value_ = velox::to<decltype(value_)>(string);
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
     if constexpr (can_simd) {
       valueBuffer_ = simd::setAll(value_);
     }
+#endif
   }
 
   void makeNullsBuffer() {
@@ -465,6 +478,18 @@ class ConstantVector final : public SimpleVector<T> {
     *BaseVector::nulls_->asMutable<uint64_t>() = bits::kNull64;
   }
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    VELOX_DCHECK(initialized_);
+    if (valueVector_) {
+      return valueVector_->retainedSize(totalStringBufferSize);
+    }
+    if (stringBuffer_) {
+      totalStringBufferSize += stringBuffer_->capacity();
+      return stringBuffer_->capacity();
+    }
+    return sizeof(T);
+  }
+
   // 'valueVector_' element 'index_' represents a complex constant
   // value. 'valueVector_' is nullptr if the constant is scalar.
   VectorPtr valueVector_;
@@ -477,8 +502,10 @@ class ConstantVector final : public SimpleVector<T> {
   bool initialized_{false};
   mutable std::atomic<BufferPtr*> wrapInfo_{nullptr};
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   // This must be at end to avoid memory corruption.
   std::conditional_t<can_simd, xsimd::batch<T>, char> valueBuffer_;
+#endif
 };
 
 template <>
diff --git a/velox/vector/DecodedVector.cpp b/velox/vector/DecodedVector.cpp
index ce358a440279..eb8c4906a892 100644
--- a/velox/vector/DecodedVector.cpp
+++ b/velox/vector/DecodedVector.cpp
@@ -83,6 +83,7 @@ VectorPtr DecodedVector::decodeImpl(
     case VectorEncoding::Simple::BIASED:
     case VectorEncoding::Simple::ROW:
     case VectorEncoding::Simple::ARRAY:
+    case VectorEncoding::Simple::FLAT_MAP:
     case VectorEncoding::Simple::MAP:
     case VectorEncoding::Simple::LAZY:
       isIdentityMapping_ = true;
@@ -234,6 +235,7 @@ void DecodedVector::combineWrappers(
       case VectorEncoding::Simple::BIASED:
       case VectorEncoding::Simple::ROW:
       case VectorEncoding::Simple::ARRAY:
+      case VectorEncoding::Simple::FLAT_MAP:
       case VectorEncoding::Simple::MAP:
         setBaseData(values, rows, sharedBase);
         return;
@@ -367,6 +369,7 @@ void DecodedVector::setBaseData(
       break;
     case VectorEncoding::Simple::ROW:
     case VectorEncoding::Simple::ARRAY:
+    case VectorEncoding::Simple::FLAT_MAP:
     case VectorEncoding::Simple::MAP:
       setFlatNulls(*vector, rows);
       break;
diff --git a/velox/vector/DecodedVector.h b/velox/vector/DecodedVector.h
index fd829293e2b9..3302913ba8c8 100644
--- a/velox/vector/DecodedVector.h
+++ b/velox/vector/DecodedVector.h
@@ -152,6 +152,9 @@ class DecodedVector {
 
   /// Returns the mapping from top-level rows to rows in the base vector or
   /// data() buffer.
+  ///
+  /// NOTE: This method allocates non-trivial amount of memory and should not
+  /// be called if encoding is constant or flat.
   const vector_size_t* indices() const {
     if (!indices_) {
       fillInIndices();
diff --git a/velox/vector/DictionaryVector-inl.h b/velox/vector/DictionaryVector-inl.h
index 98f12713fa21..0668a1932ca4 100644
--- a/velox/vector/DictionaryVector-inl.h
+++ b/velox/vector/DictionaryVector-inl.h
@@ -53,18 +53,13 @@ void DictionaryVector<T>::setInternalState() {
     }
   }
   initialized_ = true;
-
-  BaseVector::inMemoryBytes_ =
-      BaseVector::nulls_ ? BaseVector::nulls_->capacity() : 0;
-  BaseVector::inMemoryBytes_ += indices_->capacity();
-  BaseVector::inMemoryBytes_ += dictionaryValues_->inMemoryBytes();
 }
 
 template <typename T>
 DictionaryVector<T>::DictionaryVector(
     velox::memory::MemoryPool* pool,
     BufferPtr nulls,
-    size_t length,
+    vector_size_t length,
     VectorPtr dictionaryValues,
     BufferPtr dictionaryIndices,
     const SimpleVectorStats<T>& stats,
@@ -77,7 +72,7 @@ DictionaryVector<T>::DictionaryVector(
           pool,
           dictionaryValues->type(),
           VectorEncoding::Simple::DICTIONARY,
-          nulls,
+          std::move(nulls),
           length,
           stats,
           distinctValueCount,
@@ -159,6 +154,7 @@ std::unique_ptr<SimpleVector<uint64_t>> DictionaryVector<T>::hashAll() const {
       sizeof(uint64_t) * BaseVector::length_ /* representedBytes */);
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 xsimd::batch<T> DictionaryVector<T>::loadSIMDValueBufferAt(
     size_t byteOffset) const {
@@ -174,6 +170,7 @@ xsimd::batch<T> DictionaryVector<T>::loadSIMDValueBufferAt(
     VELOX_UNREACHABLE();
   }
 }
+#endif
 
 template <typename T>
 VectorPtr DictionaryVector<T>::slice(vector_size_t offset, vector_size_t length)
diff --git a/velox/vector/DictionaryVector.h b/velox/vector/DictionaryVector.h
index 851b18d17205..20f44020a8cd 100644
--- a/velox/vector/DictionaryVector.h
+++ b/velox/vector/DictionaryVector.h
@@ -32,7 +32,9 @@ class DictionaryVector : public SimpleVector<T> {
   DictionaryVector(const DictionaryVector&) = delete;
   DictionaryVector& operator=(const DictionaryVector&) = delete;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd = std::is_same_v<T, int64_t>;
+#endif
 
   // Creates dictionary vector using base vector (dictionaryValues) and a set
   // of indices (dictionaryIndexArray).
@@ -53,7 +55,7 @@ class DictionaryVector : public SimpleVector<T> {
   DictionaryVector(
       velox::memory::MemoryPool* pool,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       VectorPtr dictionaryValues,
       BufferPtr dictionaryIndexArray,
       const SimpleVectorStats<T>& stats = {},
@@ -108,6 +110,7 @@ class DictionaryVector : public SimpleVector<T> {
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /**
    * Loads a SIMD vector of data at the virtual byteOffset given
    * Note this method is implemented on each vector type, but is intentionally
@@ -117,6 +120,7 @@ class DictionaryVector : public SimpleVector<T> {
    * @return the vector of values starting at the given index
    */
   xsimd::batch<T> loadSIMDValueBufferAt(size_t index) const;
+#endif
 
   inline const BufferPtr& indices() const {
     return indices_;
@@ -148,11 +152,6 @@ class DictionaryVector : public SimpleVector<T> {
     return indices_;
   }
 
-  uint64_t retainedSize() const override {
-    return BaseVector::retainedSize() + dictionaryValues_->retainedSize() +
-        indices_->capacity();
-  }
-
   bool isScalar() const override {
     return dictionaryValues_->isScalar();
   }
@@ -250,6 +249,15 @@ class DictionaryVector : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override {
+    BaseVector::transferOrCopyTo(pool);
+    dictionaryValues_->transferOrCopyTo(pool);
+    if (!indices_->transferTo(pool)) {
+      indices_ = AlignedBuffer::copy<vector_size_t>(indices_, pool);
+      rawIndices_ = indices_->as<vector_size_t>();
+    }
+  }
+
  private:
   // return the dictionary index for the specified vector index.
   inline vector_size_t getDictionaryIndex(vector_size_t idx) const {
@@ -258,6 +266,12 @@ class DictionaryVector : public SimpleVector<T> {
 
   void setInternalState();
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return BaseVector::retainedSizeImpl() +
+        dictionaryValues_->retainedSize(totalStringBufferSize) +
+        indices_->capacity();
+  }
+
   BufferPtr indices_;
   const vector_size_t* rawIndices_ = nullptr;
 
diff --git a/velox/vector/EncodedVectorCopy.cpp b/velox/vector/EncodedVectorCopy.cpp
index 93516f383aa3..924f3a2730c5 100644
--- a/velox/vector/EncodedVectorCopy.cpp
+++ b/velox/vector/EncodedVectorCopy.cpp
@@ -18,6 +18,7 @@
 
 #include "velox/vector/ConstantVector.h"
 #include "velox/vector/DecodedVector.h"
+#include "velox/vector/LazyVector.h"
 #include "velox/vector/VectorTypeUtils.h"
 
 namespace facebook::velox {
@@ -1066,7 +1067,7 @@ void encodedVectorCopy(
     VELOX_CHECK(source->pool() == options.pool);
   }
   if (target) {
-    VELOX_CHECK(*target->type() == *source->type());
+    VELOX_CHECK(target->type()->equivalent(*source->type()));
     VELOX_CHECK(target->pool() == options.pool);
   }
   VELOX_CHECK(
diff --git a/velox/vector/FlatMapVector.cpp b/velox/vector/FlatMapVector.cpp
index 8f2d15206e13..a1bcbfa8308a 100644
--- a/velox/vector/FlatMapVector.cpp
+++ b/velox/vector/FlatMapVector.cpp
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-#include "velox/vector/FlatMapVector.h"
 #include <folly/hash/Hash.h>
-#include "velox/vector/FlatVector.h"
+
+#include "velox/vector/FlatMapVector.h"
+#include "velox/vector/SimpleVector.h"
 
 namespace facebook::velox {
 namespace {
@@ -34,9 +35,9 @@ std::optional<column_index_t> getKeyChannelImpl(
     return std::nullopt;
   }
 
-  auto distinctFlatKeys = distinctKeys->as<FlatVector<T>>();
+  auto simpleKeys = distinctKeys->as<SimpleVector<T>>();
   VELOX_CHECK(
-      distinctFlatKeys != nullptr,
+      simpleKeys != nullptr,
       "Incompatible vector type for flat map vector keys: {}",
       distinctKeys->toString());
 
@@ -51,7 +52,7 @@ std::optional<column_index_t> getKeyChannelImpl(
   // Here there was at least one hash match. Need to compare to the keys vector
   // to ensure it's an actual match and not a hash collision.
   for (auto it = range.first; it != range.second; ++it) {
-    if (distinctFlatKeys->valueAtFast(it->second) == keyValue) {
+    if (simpleKeys->valueAt(it->second) == keyValue) {
       return it->second;
     }
   }
@@ -294,33 +295,78 @@ std::vector<vector_size_t> FlatMapVector::sortedKeyIndices(
   return indices;
 }
 
-// This function's logic is largely based on MapVector::compare().
-std::optional<int32_t> FlatMapVector::compare(
-    const BaseVector* other,
+std::optional<int32_t> FlatMapVector::compareToMap(
+    const MapVector* otherMap,
     vector_size_t index,
-    vector_size_t otherIndex,
+    vector_size_t wrappedOtherIndex,
     CompareFlags flags) const {
-  VELOX_CHECK(
-      flags.nullAsValue() || flags.equalsOnly, "Map is not orderable type");
+  if (keyType()->kind() != otherMap->mapKeys()->typeKind() ||
+      valueType()->kind() != otherMap->mapValues()->typeKind()) {
+    VELOX_FAIL(
+        "Compare of maps of different key/value types: {} and {}",
+        BaseVector::toString(),
+        otherMap->BaseVector::toString());
+  }
 
-  // If maps are null.
-  bool isNull = isNullAt(index);
-  bool otherNull = other->isNullAt(otherIndex);
-  if (isNull || otherNull) {
-    return BaseVector::compareNulls(isNull, otherNull, flags);
+  // We first get sorted key indices for both maps.
+  auto leftIndices = sortedKeyIndices(index);
+  auto rightIndices = otherMap->sortedKeyIndices(wrappedOtherIndex);
+
+  // If equalsOnly and maps have different sizes, we can bail fast.
+  if (flags.equalsOnly && leftIndices.size() != rightIndices.size()) {
+    int result = leftIndices.size() - rightIndices.size();
+    return flags.ascending ? result : result * -1;
   }
 
-  // Validate we have compatible map types for comparison.
-  auto otherValue = other->wrappedVector();
-  auto wrappedOtherIndex = other->wrappedIndex(otherIndex);
-  VELOX_CHECK_EQ(
-      VectorEncoding::Simple::FLAT_MAP,
-      otherValue->encoding(),
-      "Compare of FLAT_MAP and non-FLAT_MAP: {} and {}",
-      BaseVector::toString(),
-      otherValue->BaseVector::toString());
-  auto otherFlatMap = otherValue->as<FlatMapVector>();
+  // Compare each key value pair, using the sorted key order.
+  auto compareSize = std::min(leftIndices.size(), rightIndices.size());
+  bool resultIsIndeterminate = false;
+
+  for (auto i = 0; i < compareSize; ++i) {
+    // First compare the keys.
+    auto result = distinctKeys_->compare(
+        otherMap->mapKeys().get(), leftIndices[i], rightIndices[i], flags);
+
+    // Key mismatch; comparison can stop.
+    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 keys are same, compare values.
+    else {
+      auto valueResult = mapValues_[leftIndices[i]]->compare(
+          otherMap->mapValues().get(), index, rightIndices[i], flags);
+
+      // If value mismatch, comparison can also stop.
+      if (valueResult == kIndeterminate) {
+        VELOX_DCHECK(
+            flags.equalsOnly,
+            "Compare should have thrown when null is encountered in child.");
+        resultIsIndeterminate = true;
+      } else if (valueResult.value() != 0) {
+        return valueResult;
+      }
+    }
+  }
+
+  if (resultIsIndeterminate) {
+    return kIndeterminate;
+  }
+
+  // If one map was smaller than the other.
+  int result = leftIndices.size() - rightIndices.size();
+  return flags.ascending ? result : result * -1;
+}
 
+std::optional<int32_t> FlatMapVector::compareToFlatMap(
+    const FlatMapVector* otherFlatMap,
+    vector_size_t index,
+    vector_size_t wrappedOtherIndex,
+    CompareFlags flags) const {
   if (keyType()->kind() != otherFlatMap->keyType()->kind() ||
       valueType()->kind() != otherFlatMap->valueType()->kind()) {
     VELOX_FAIL(
@@ -389,6 +435,174 @@ std::optional<int32_t> FlatMapVector::compare(
   return flags.ascending ? result : result * -1;
 }
 
+// This function's logic is largely based on MapVector::compare().
+std::optional<int32_t> FlatMapVector::compare(
+    const BaseVector* other,
+    vector_size_t index,
+    vector_size_t otherIndex,
+    CompareFlags flags) const {
+  VELOX_CHECK(
+      flags.nullAsValue() || flags.equalsOnly, "Map is not orderable type");
+
+  // If maps are null.
+  bool isNull = isNullAt(index);
+  bool otherNull = other->isNullAt(otherIndex);
+  if (isNull || otherNull) {
+    return BaseVector::compareNulls(isNull, otherNull, flags);
+  }
+
+  // Validate we have compatible map types for comparison.
+  auto otherValue = other->wrappedVector();
+  auto wrappedOtherIndex = other->wrappedIndex(otherIndex);
+
+  if (otherValue->encoding() == VectorEncoding::Simple::FLAT_MAP) {
+    return compareToFlatMap(
+        otherValue->as<FlatMapVector>(), index, wrappedOtherIndex, flags);
+  } else if (otherValue->encoding() == VectorEncoding::Simple::MAP) {
+    return compareToMap(
+        otherValue->as<MapVector>(), index, wrappedOtherIndex, flags);
+  } else {
+    VELOX_FAIL(
+        "Compare of FLAT_MAP and non-MAP: {} and {}",
+        BaseVector::toString(),
+        otherValue->BaseVector::toString());
+  }
+}
+
+void FlatMapVector::copyInMapRanges(
+    column_index_t targetChannel,
+    const uint64_t* sourceInMaps,
+    const folly::Range<const BaseVector::CopyRange*>& ranges) {
+  auto* targetInMaps = mutableRawInMapsAt(targetChannel);
+
+  // This means that the key being copied exists in all maps from both source
+  // and target; nothing to update.
+  if (sourceInMaps == nullptr && targetInMaps == nullptr) {
+    return;
+  }
+
+  // If there is something we need to copy, allocate the target in map buffer in
+  // case there isn't one.
+  if (targetInMaps == nullptr) {
+    inMapsAt(targetChannel, true) =
+        AlignedBuffer::allocate<bool>(size(), pool(), false);
+    targetInMaps = mutableRawInMapsAt(targetChannel);
+  }
+
+  // If there is source in map, we need to copy the buffer range regions from
+  // it.
+  if (sourceInMaps != nullptr) {
+    applyToEachRange(
+        ranges,
+        [targetInMaps, sourceInMaps](
+            auto targetIndex, auto sourceIndex, auto count) {
+          bits::copyBits(
+              sourceInMaps, sourceIndex, targetInMaps, targetIndex, count);
+        });
+  }
+  // If the buffer doesn't exist, it means the key is available on every row. In
+  // such case we just need to set the right ranges.
+  else {
+    applyToEachRange(
+        ranges,
+        [targetInMaps](auto targetIndex, auto /* sourceIndex */, auto count) {
+          bits::fillBits(targetInMaps, targetIndex, targetIndex + count, true);
+        });
+  }
+}
+
+void FlatMapVector::copyRanges(
+    const BaseVector* source,
+    const folly::Range<const CopyRange*>& ranges) {
+  if (ranges.empty()) {
+    return;
+  }
+
+  auto* sourceFlatMap = source->loadedVector()->as<FlatMapVector>();
+  if (sourceFlatMap == nullptr) {
+    VELOX_NYI(
+        "FlatMapVector::copyRanges expects a FlatMapVector, got {}.",
+        source->toString());
+  }
+
+  // If source may have nulls, copy top-level nulls from the ranges first.
+  if (sourceFlatMap->mayHaveNulls()) {
+    copyNulls(mutableRawNulls(), sourceFlatMap->rawNulls(), ranges);
+  }
+
+  auto startingNumDistinctKeys = numDistinctKeys();
+
+  // First, for each distinct key in the source vector, we look for a key match
+  // on the target. If there is not, we create a new distinct key, then copy the
+  // map values and update the in map buffers.
+  for (column_index_t i = 0; i < sourceFlatMap->distinctKeys_->size(); ++i) {
+    const auto channel = getKeyChannel(sourceFlatMap->distinctKeys_, i)
+                             .value_or(distinctKeys_->size());
+
+    if (channel == distinctKeys_->size()) {
+      // First append the new key to the distinct keys internal vector.
+      appendDistinctKey(sourceFlatMap->distinctKeys_, i);
+
+      // Then we allocate a new key values vector and in map buffer.
+      inMapsAt(channel, true) =
+          AlignedBuffer::allocate<bool>(size(), pool(), false);
+      mapValues_.back() = BaseVector::create(valueType(), size(), pool());
+    }
+
+    // Finally, copy the map values and update the in map buffers.
+    mapValues_[channel]->copyRanges(sourceFlatMap->mapValues_[i].get(), ranges);
+    copyInMapRanges(channel, sourceFlatMap->rawInMapsAt(i), ranges);
+  }
+
+  // Keys that exist in the target but not in the source may need to be updated
+  // (since they could have got overwritten/erased).
+  for (column_index_t i = 0; i < startingNumDistinctKeys; ++i) {
+    // If a key doesn't exist in the source, we need to go and clean its in map
+    // buffer entries for all rows in range.
+    if (sourceFlatMap->getKeyChannel(distinctKeys_, i) == std::nullopt) {
+      auto& targetInMapsBuffer = inMapsAt(i, true);
+      if (targetInMapsBuffer == nullptr) {
+        targetInMapsBuffer =
+            AlignedBuffer::allocate<bool>(size(), pool(), false);
+      }
+      auto* targetInMaps = targetInMapsBuffer->asMutable<uint64_t>();
+
+      applyToEachRange(
+          ranges,
+          [targetInMaps](auto targetIndex, auto /* sourceIndex */, auto count) {
+            bits::fillBits(
+                targetInMaps, targetIndex, targetIndex + count, false);
+          });
+    }
+  }
+}
+
+void FlatMapVector::ensureWritable(const SelectivityVector& rows) {
+  // Top-level and mapValues row ids are the same, so we can just propagate the
+  // selectivity vector.
+  for (size_t i = 0; i < numDistinctKeys(); ++i) {
+    BaseVector::ensureWritable(
+        rows, valueType(), BaseVector::pool_, mapValues_[i]);
+  }
+
+  for (auto& inMap : inMaps_) {
+    // Similar to top-level nulls, if the buffer is not mutable, copy on write
+    // it over.
+    if (inMap && !inMap->isMutable()) {
+      BufferPtr newInMap = AlignedBuffer::allocate<bool>(size(), pool_);
+      auto rawNewInMap = newInMap->asMutable<uint64_t>();
+      memcpy(rawNewInMap, inMap->as<uint64_t>(), bits::nbytes(size()));
+      inMap = std::move(newInMap);
+    }
+  }
+
+  // Distinct keys may be associated with all rows, hence all values already
+  // written must be preserved.
+  BaseVector::ensureWritable(
+      SelectivityVector::empty(), keyType(), BaseVector::pool_, distinctKeys_);
+  BaseVector::ensureWritable(rows);
+}
+
 // This function will copy map value elements from the individual mapValues_
 // std::vector into a single flattened one that can be used by a MapVector.
 //
diff --git a/velox/vector/FlatMapVector.h b/velox/vector/FlatMapVector.h
index bacfebcd01bf..d60546ecdad8 100644
--- a/velox/vector/FlatMapVector.h
+++ b/velox/vector/FlatMapVector.h
@@ -89,9 +89,9 @@ class FlatMapVector : public BaseVector {
   // in-map buffers may not be present).
   FlatMapVector(
       velox::memory::MemoryPool* pool,
-      std::shared_ptr<const Type> type,
+      const TypePtr& type,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       VectorPtr distinctKeys,
       std::vector<VectorPtr> mapValues,
       std::vector<BufferPtr> inMaps,
@@ -101,7 +101,7 @@ class FlatMapVector : public BaseVector {
             pool,
             type,
             VectorEncoding::Simple::FLAT_MAP,
-            nulls,
+            std::move(nulls),
             length,
             std::nullopt,
             nullCount),
@@ -121,7 +121,7 @@ class FlatMapVector : public BaseVector {
         inMaps_.size(), numDistinctKeys(), "Wrong number of in map buffers.");
   }
 
-  virtual ~FlatMapVector() override {}
+  ~FlatMapVector() override = default;
 
   /// Overwrites the existing distinct keys vector, resizing map values and
   /// clearing in-map buffers.
@@ -204,6 +204,15 @@ class FlatMapVector : public BaseVector {
     return nullptr;
   }
 
+  /// Same as above but allows for `keysVector` at index `index` (similar
+  /// distinction between getKeyChannel we see above).
+  VectorPtr projectKey(const VectorPtr& keysVector, vector_size_t index) const {
+    if (auto channel = getKeyChannel(keysVector, index)) {
+      return mapValues_[channel.value()];
+    }
+    return nullptr;
+  }
+
   /// Returns the size for the map at position `index`. Size means the number of
   /// logical key value pairs in the map. Note that this is not a particularly
   /// efficient operation in flat maps as it requires accessing the inMap bitmap
@@ -211,8 +220,15 @@ class FlatMapVector : public BaseVector {
   vector_size_t sizeAt(vector_size_t index) const;
 
   bool isInMap(column_index_t keyChannel, vector_size_t index) const {
-    auto* inMap = inMapsAt(keyChannel)->asMutable<uint64_t>();
-    return inMap ? bits::isBitSet(inMap, index) : true;
+    if (inMaps_.size() <= keyChannel) {
+      return true;
+    }
+    if (auto& inMap = inMapsAt(keyChannel)) {
+      return bits::isBitSet(inMap->as<uint64_t>(), index);
+    } else {
+      // If inMap is null, key is present in all rows.
+      return true;
+    }
   }
 
   /// Get the map values vector at a given a map key channel.
@@ -233,7 +249,8 @@ class FlatMapVector : public BaseVector {
     return mapValues_[index];
   }
 
-  /// Get the in map buffer for a given a map key channel.
+  /// Get the in map buffer for a given a map key channel. Throws if in maps
+  /// does not exist for this channel.
   const BufferPtr& inMapsAt(column_index_t index) const {
     VELOX_CHECK_LT(
         index,
@@ -242,6 +259,31 @@ class FlatMapVector : public BaseVector {
     return inMaps_[index];
   }
 
+  /// Get the in map buffer reference for a given map key channel. If `resize`
+  /// is true, may resize up to `numDistinctKeys()` to ensure that the inMaps
+  /// vector has the appropriate length.
+  BufferPtr& inMapsAt(column_index_t index, bool resize = false) {
+    if (index < inMaps_.size()) {
+      return inMaps_[index];
+    } else if (!resize || index >= numDistinctKeys()) {
+      VELOX_CHECK_LT(
+          index,
+          inMaps_.size(),
+          "Trying to access non-existing key channel in FlatMapVector.");
+    }
+    inMaps_.resize(index + 1);
+    return inMaps_[index];
+  }
+
+  const uint64_t* rawInMapsAt(column_index_t index) const {
+    return inMaps_.size() > index ? inMaps_[index]->as<uint64_t>() : nullptr;
+  }
+
+  uint64_t* mutableRawInMapsAt(column_index_t index) {
+    return inMaps_.size() > index ? inMaps_[index]->asMutable<uint64_t>()
+                                  : nullptr;
+  }
+
   using BaseVector::toString;
   std::string toString(vector_size_t index) const override;
 
@@ -269,6 +311,17 @@ class FlatMapVector : public BaseVector {
       vector_size_t otherIndex,
       CompareFlags flags) const override;
 
+  /// Copy the ranges defined by `ranges` from source into `this`.
+  void copyRanges(
+      const BaseVector* source,
+      const folly::Range<const CopyRange*>& ranges) override;
+
+  void ensureWritable(const SelectivityVector& rows) override;
+
+  bool isWritable() const override {
+    return true;
+  }
+
   /// Returns the hash of the value at the given index in this vector.
   uint64_t hashValueAt(vector_size_t index) const override;
 
@@ -284,6 +337,13 @@ class FlatMapVector : public BaseVector {
   /// testing/validation purposes, and not for performance critical paths.
   MapVectorPtr toMapVector() const;
 
+  void transferOrCopyTo(velox::memory::MemoryPool* /*pool*/) override {
+    // TODO: enable this after
+    // https://github.com/facebookincubator/velox/issues/15485 is resolved to
+    // allow proper testing.
+    VELOX_NYI("{} unsupported", __FUNCTION__);
+  }
+
  private:
   void setDistinctKeysImpl(VectorPtr distinctKeys) {
     VELOX_CHECK(distinctKeys != nullptr);
@@ -292,14 +352,70 @@ class FlatMapVector : public BaseVector {
         "Unexpected key type: {}",
         distinctKeys->type()->toString());
 
-    distinctKeys_ = distinctKeys;
+    distinctKeys_ = std::move(distinctKeys);
     keyToChannel_.clear();
 
     for (vector_size_t i = 0; i < numDistinctKeys(); i++) {
-      keyToChannel_.insert({distinctKeys->hashValueAt(i), i});
+      keyToChannel_.insert({distinctKeys_->hashValueAt(i), i});
     }
   }
 
+  /// Appends a new distinct key to the flat map specified by `sourceChannel` on
+  /// `sourceDistinctKeys`.
+  void appendDistinctKey(
+      const VectorPtr& sourceDistinctKeys,
+      column_index_t sourceChannel) {
+    column_index_t targetChannel = distinctKeys_->size();
+
+    distinctKeys_->resize(targetChannel + 1);
+    distinctKeys_->copy(
+        sourceDistinctKeys.get(), targetChannel, sourceChannel, 1);
+    mapValues_.resize(distinctKeys_->size());
+
+    keyToChannel_.insert(
+        {distinctKeys_->hashValueAt(targetChannel), targetChannel});
+    sortedKeys_ = false;
+  }
+
+  /// Updates the in map buffer from the key defined by `targetChannel` based on
+  /// values from `sourceInMaps`. Updates based on the ranges defined in
+  /// `ranges`.
+  ///
+  /// In case neither targetChannel nor sourceInMaps have in map buffers
+  /// allocated, returns early since this means that key is specified
+  /// everywhere (no update needed).
+  void copyInMapRanges(
+      column_index_t targetChannel,
+      const uint64_t* sourceInMaps,
+      const folly::Range<const BaseVector::CopyRange*>& ranges);
+
+  /// Compares a map in this Vector with a map in a MapVector.
+  std::optional<int32_t> compareToMap(
+      const MapVector* other,
+      vector_size_t index,
+      // The other MapVector may have been encoded, pass the wrappedIndex from
+      // the other Vector here.
+      vector_size_t wrappedOtherIndex,
+      CompareFlags flags) const;
+
+  /// Compares a map in this Vector with a map in another FlatMapVector.
+  std::optional<int32_t> compareToFlatMap(
+      const FlatMapVector* other,
+      vector_size_t index,
+      // The other FlatMapVector may have been encoded, pass the wrappedIndex
+      // from the other Vector here.
+      vector_size_t wrappedOtherIndex,
+      CompareFlags flags) const;
+
+  uint64_t retainedSizeImpl(
+      uint64_t& /*totalStringBufferSize*/) const override {
+    // TODO: since FlatMapVector didn't override BaseVector::retainedSize(),
+    // this override of retainedSizeImpl keeps the original behavior of
+    // FlatMapVector::retainedSize(). We should update this method to reflect
+    // the actual memory usage of FlatMapVector.
+    return BaseVector::retainedSizeImpl();
+  }
+
   // Vector containing the distinct map keys.
   VectorPtr distinctKeys_;
 
diff --git a/velox/vector/FlatVector-inl.h b/velox/vector/FlatVector-inl.h
index defc1035544f..6c0d0969e4aa 100644
--- a/velox/vector/FlatVector-inl.h
+++ b/velox/vector/FlatVector-inl.h
@@ -18,6 +18,7 @@
 #include "velox/common/base/BitUtil.h"
 #include "velox/common/base/Exceptions.h"
 #include "velox/common/base/SimdUtil.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/vector/BuilderTypeUtils.h"
 #include "velox/vector/ConstantVector.h"
 #include "velox/vector/DecodedVector.h"
@@ -25,6 +26,7 @@
 
 namespace facebook::velox {
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 // Here are some common intel intrsic operations. Please refer to
 // https://software.intel.com/sites/landingpage/IntrinsicsGuide for examples.
 
@@ -48,8 +50,9 @@ namespace facebook::velox {
 
 // cost factors for individual operations on different filter paths - these are
 // experimentally derived from micro-bench perf testing.
-const double SIMD_CMP_COST = 0.00000051;
-const double SET_CMP_COST = 0.000023;
+static constexpr double SIMD_CMP_COST = 0.00000051;
+static constexpr double SET_CMP_COST = 0.000023;
+#endif
 
 template <typename T>
 const T* FlatVector<T>::rawValues() const {
@@ -67,6 +70,7 @@ Range<T> FlatVector<T>::asRange() const {
   return Range<T>(rawValues(), 0, BaseVector::length_);
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 xsimd::batch<T> FlatVector<T>::loadSIMDValueBufferAt(size_t byteOffset) const {
   auto mem = reinterpret_cast<uint8_t*>(rawValues_) + byteOffset;
@@ -76,25 +80,27 @@ xsimd::batch<T> FlatVector<T>::loadSIMDValueBufferAt(size_t byteOffset) const {
     return xsimd::load_unaligned(reinterpret_cast<T*>(mem));
   }
 }
+#endif
 
 template <typename T>
 std::unique_ptr<SimpleVector<uint64_t>> FlatVector<T>::hashAll() const {
+  using len_type = decltype(BaseVector::length_);
   BufferPtr hashBuffer =
       AlignedBuffer::allocate<uint64_t>(BaseVector::length_, BaseVector::pool_);
   auto hashData = hashBuffer->asMutable<uint64_t>();
 
-  if (rawValues_ != nullptr) { // non all-null case
-    folly::hasher<T> hasher;
-    for (size_t i = 0; i < BaseVector::length_; ++i) {
+  folly::hasher<T> hasher;
+  if (!BaseVector::rawNulls_) {
+    VELOX_DCHECK_NOT_NULL(rawValues_);
+    for (len_type i = 0; i < BaseVector::length_; ++i) {
       hashData[i] = hasher(valueAtFast(i));
     }
-  }
-
-  // overwrite the null hash values
-  if (BaseVector::rawNulls_ != nullptr) {
-    for (size_t i = 0; i < BaseVector::length_; ++i) {
+  } else {
+    for (len_type i = 0; i < BaseVector::length_; ++i) {
       if (bits::isBitNull(BaseVector::rawNulls_, i)) {
         hashData[i] = BaseVector::kNullHash;
+      } else {
+        hashData[i] = hasher(valueAtFast(i));
       }
     }
   }
@@ -112,6 +118,7 @@ std::unique_ptr<SimpleVector<uint64_t>> FlatVector<T>::hashAll() const {
       sizeof(uint64_t) * BaseVector::length_ /*representedBytes*/);
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 bool FlatVector<T>::useSimdEquality(size_t numCmpVals) const {
   if constexpr (!std::is_integral_v<T>) {
@@ -126,6 +133,7 @@ bool FlatVector<T>::useSimdEquality(size_t numCmpVals) const {
     return simdCost <= fallbackCost;
   }
 }
+#endif
 
 template <typename T>
 void FlatVector<T>::copyValuesAndNulls(
@@ -443,40 +451,42 @@ void FlatVector<T>::resize(vector_size_t newSize, bool setNotNull) {
   if (newSize == previousSize) {
     return;
   }
-  BaseVector::resize(newSize, setNotNull);
-  if (!values_) {
-    return;
-  }
 
-  if constexpr (std::is_same_v<T, StringView>) {
-    resizeValues(newSize, StringView());
-    if (newSize < previousSize) {
-      // 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.
-      // TODO: remove this when resizeValues() checks against size() instead of
-      // capacity() when deciding to init values.
-      auto stringViews = reinterpret_cast<StringView*>(rawValues_);
-      for (auto index = previousSize; index < newSize; ++index) {
-        new (&stringViews[index]) StringView();
+  if (values_) {
+    if constexpr (std::is_same_v<T, StringView>) {
+      resizeValues(newSize, previousSize, StringView());
+      if (newSize < previousSize) {
+        // 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.
+        // TODO: remove this when resizeValues() checks against size() instead
+        // of capacity() when deciding to init values.
+        auto stringViews = reinterpret_cast<StringView*>(rawValues_);
+        for (auto index = previousSize; index < newSize; ++index) {
+          new (&stringViews[index]) StringView();
+        }
+        SimpleVector<StringView>::resizeIsAsciiIfNotEmpty(newSize, false);
       }
-      SimpleVector<StringView>::resizeIsAsciiIfNotEmpty(newSize, false);
-    }
-    if (newSize == 0) {
-      keepAtMostOneStringBuffer();
+      if (newSize == 0) {
+        keepAtMostOneStringBuffer();
+      }
+    } else {
+      resizeValues(newSize, previousSize, std::nullopt);
     }
-  } else {
-    resizeValues(newSize, std::nullopt);
   }
+
+  // Call resize on the BaseVector at the end, so we only update length_ if we
+  // successfully resized the values Buffer.
+  BaseVector::resize(newSize, setNotNull);
 }
 
 template <typename T>
 void FlatVector<T>::ensureWritable(const SelectivityVector& rows) {
-  auto newSize = std::max<vector_size_t>(rows.end(), BaseVector::length_);
   if (values_ && !values_->isMutable()) {
+    auto newSize = std::max<vector_size_t>(rows.end(), BaseVector::length_);
     BufferPtr newValues;
     if constexpr (std::is_same_v<T, StringView>) {
       // Make sure to initialize StringView values so they can be safely
@@ -530,7 +540,10 @@ void FlatVector<T>::prepareForReuse() {
 template <typename T>
 void FlatVector<T>::resizeValues(
     vector_size_t newSize,
+    vector_size_t previousSize,
     const std::optional<T>& initialValue) {
+  common::testutil::TestValue::adjust(
+      "facebook::velox::FlatVector::resizeValues", this);
   // TODO: change this to isMutable(). See
   // https://github.com/facebookincubator/velox/issues/6562.
   if (values_ && !values_->isView()) {
@@ -547,16 +560,16 @@ void FlatVector<T>::resizeValues(
       AlignedBuffer::allocate<T>(newSize, BaseVector::pool_, initialValue);
 
   if (values_) {
+    auto len = std::min(newSize, previousSize);
+
     if constexpr (Buffer::is_pod_like_v<T>) {
       auto dst = newValues->asMutable<T>();
       auto src = values_->as<T>();
-      auto len = std::min(values_->size(), newValues->size());
-      memcpy(dst, src, len);
+      auto byteLen = BaseVector::byteSize<T>(len);
+      memcpy(dst, src, byteLen);
     } else {
-      const vector_size_t previousSize = BaseVector::length_;
-      auto* rawOldValues = newValues->asMutable<T>();
+      const auto* rawOldValues = values_->as<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];
       }
@@ -569,7 +582,10 @@ void FlatVector<T>::resizeValues(
 template <>
 inline void FlatVector<bool>::resizeValues(
     vector_size_t newSize,
+    vector_size_t previousSize,
     const std::optional<bool>& initialValue) {
+  common::testutil::TestValue::adjust(
+      "facebook::velox::FlatVector::resizeValues", this);
   // TODO: change this to isMutable(). See
   // https://github.com/facebookincubator/velox/issues/6562.
   if (values_ && !values_->isView()) {
@@ -579,13 +595,6 @@ inline void FlatVector<bool>::resizeValues(
     } else {
       values_->setSize(newByteSize);
     }
-    // ensure that the newly added positions have the right initial value for
-    // the case where changes in size don't result in change in the size of
-    // the underlying buffer.
-    if (initialValue.has_value() && length_ < newSize) {
-      auto rawData = values_->asMutable<uint64_t>();
-      bits::fillBits(rawData, length_, newSize, initialValue.value());
-    }
     rawValues_ = values_->asMutable<bool>();
     return;
   }
@@ -595,11 +604,92 @@ inline void FlatVector<bool>::resizeValues(
   if (values_) {
     auto dst = newValues->asMutable<char>();
     auto src = values_->as<char>();
-    auto len = std::min(values_->size(), newValues->size());
+    auto len = BaseVector::byteSize<bool>(std::min(newSize, previousSize));
     memcpy(dst, src, len);
   }
   values_ = std::move(newValues);
   rawValues_ = values_->asMutable<bool>();
 }
 
+template <typename T>
+void FlatVector<T>::transferAndUpdateStringBuffers(
+    velox::memory::MemoryPool* /*pool*/) {
+  VELOX_CHECK(stringBuffers_.empty());
+}
+
+template <>
+inline void FlatVector<StringView>::transferAndUpdateStringBuffers(
+    velox::memory::MemoryPool* pool) {
+  struct StringBufferRemapping {
+    const char* oldStart;
+    const char* newStart;
+    size_t size;
+  };
+  std::vector<StringBufferRemapping> stringBufferRemapping;
+  for (auto& buffer : stringBuffers_) {
+    if (!buffer->transferTo(pool)) {
+      VELOX_CHECK_NE(
+          stringBufferSet_.erase(buffer.get()),
+          0,
+          "Easure of existing string buffer should always succeed.");
+      auto newBuffer = AlignedBuffer::copy<char>(buffer, pool);
+      stringBufferRemapping.push_back(
+          {buffer->as<char>(), newBuffer->as<char>(), buffer->size()});
+      buffer = std::move(newBuffer);
+      VELOX_CHECK(stringBufferSet_.insert(buffer.get()).second);
+    }
+  }
+  if (stringBufferRemapping.empty()) {
+    return;
+  }
+
+  std::sort(
+      stringBufferRemapping.begin(),
+      stringBufferRemapping.end(),
+      [](const StringBufferRemapping& lhs, const StringBufferRemapping& rhs) {
+        return lhs.oldStart < rhs.oldStart;
+      });
+  auto rawValues = values_->asMutable<StringView>();
+  for (auto i = 0; i < BaseVector::length_; ++i) {
+    if (BaseVector::isNullAt(i)) {
+      continue;
+    }
+    auto& stringView = rawValues[i];
+    if (stringView.isInline()) {
+      continue;
+    }
+    // Find the first remapping whose oldStart is strictly greater than
+    // stringView.data(). The remapping before it is the candidate that
+    // contains stringView.data().
+    auto remapping = std::upper_bound(
+        stringBufferRemapping.cbegin(),
+        stringBufferRemapping.cend(),
+        stringView.data(),
+        [](const char* lhs, const StringBufferRemapping& rhs) {
+          return lhs < rhs.oldStart;
+        });
+    // There is no remapping whose oldStart is smaller than or equal to
+    // stringView.data().
+    if (remapping == stringBufferRemapping.begin()) {
+      continue;
+    }
+    remapping--;
+    if (stringView.data() >= remapping->oldStart &&
+        stringView.data() < remapping->oldStart + remapping->size) {
+      auto offset = stringView.data() - remapping->oldStart;
+      stringView = StringView(remapping->newStart + offset, stringView.size());
+    }
+  }
+}
+
+template <typename T>
+void FlatVector<T>::transferOrCopyTo(velox::memory::MemoryPool* pool) {
+  BaseVector::transferOrCopyTo(pool);
+  if (values_ && !values_->transferTo(pool)) {
+    values_ = AlignedBuffer::copy<T>(values_, pool);
+    rawValues_ = const_cast<T*>(values_->as<T>());
+  }
+  transferAndUpdateStringBuffers(pool);
+}
+
 } // namespace facebook::velox
diff --git a/velox/vector/FlatVector.h b/velox/vector/FlatVector.h
index 6fcc030ca7ce..8ec000fef89d 100644
--- a/velox/vector/FlatVector.h
+++ b/velox/vector/FlatVector.h
@@ -37,10 +37,12 @@ class FlatVector final : public SimpleVector<T> {
   FlatVector(const FlatVector&) = delete;
   FlatVector& operator=(const FlatVector&) = delete;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd =
       (std::is_same_v<T, int64_t> || std::is_same_v<T, int32_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>);
+#endif
 
   /// 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
@@ -56,7 +58,7 @@ class FlatVector final : public SimpleVector<T> {
       velox::memory::MemoryPool* pool,
       const TypePtr& type,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       BufferPtr values,
       std::vector<BufferPtr>&& stringBuffers,
       const SimpleVectorStats<T>& stats = {},
@@ -103,11 +105,6 @@ class FlatVector final : public SimpleVector<T> {
       // immutable Buffer.
       values_->setSize(byteSize);
     }
-
-    BaseVector::inMemoryBytes_ += values_->capacity();
-    for (const auto& stringBuffer : stringBuffers_) {
-      BaseVector::inMemoryBytes_ += stringBuffer->capacity();
-    }
   }
 
   virtual ~FlatVector() override = default;
@@ -120,11 +117,13 @@ class FlatVector final : public SimpleVector<T> {
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /// 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;
+#endif
 
   /// dictionary vector makes internal usehere for SIMD functions
   template <typename X>
@@ -141,23 +140,23 @@ class FlatVector final : public SimpleVector<T> {
     return values_;
   }
 
-  /// Ensures that 'values_' is singly-referenced and has space for 'size'
-  /// elements. Sets elements between the old and new sizes to T() if
-  /// the new size > old size.
+  /// Ensures that 'values_' is singly-referenced and has space for the current
+  /// size of the Vector. Sets any newly added elements to T() if the new size >
+  /// old size.
   ///
   /// If 'values_' is nullptr, read-only, not uniquely-referenced, or doesn't
   /// have capacity for 'size' elements allocates new buffer and copies data to
   /// it. Updates 'rawValues_' to point to element 0 of
   /// values_->as<T>().
-  BufferPtr mutableValues(vector_size_t size) {
-    const auto numNewBytes = BaseVector::byteSize<T>(size);
+  BufferPtr mutableValues(vector_size_t /*ignored*/ = 0) {
+    const auto numNewBytes = BaseVector::byteSize<T>(BaseVector::length_);
     if (values_ && !values_->isView() && values_->unique()) {
       if (values_->size() < numNewBytes) {
-        AlignedBuffer::reallocate<T>(&values_, size, T());
+        AlignedBuffer::reallocate<T>(&values_, BaseVector::length_, T());
       }
     } else {
-      BufferPtr newValues =
-          AlignedBuffer::allocate<T>(size, BaseVector::pool(), T());
+      BufferPtr newValues = AlignedBuffer::allocate<T>(
+          BaseVector::length_, BaseVector::pool(), T());
       if (values_) {
         const auto numCopyBytes =
             std::min<vector_size_t>(values_->size(), numNewBytes);
@@ -182,10 +181,12 @@ class FlatVector final : public SimpleVector<T> {
     return values_;
   }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /// 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;
+#endif
 
   /// Returns the raw values of this vector as a continuous array.
   const T* rawValues() const;
@@ -289,6 +290,8 @@ class FlatVector final : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override;
+
   void resize(vector_size_t newSize, bool setNotNull = true) override;
 
   VectorPtr slice(vector_size_t offset, vector_size_t length) const override;
@@ -414,15 +417,6 @@ class FlatVector final : public SimpleVector<T> {
     return this->typeKind() != TypeKind::UNKNOWN;
   }
 
-  uint64_t retainedSize() const override {
-    auto size =
-        BaseVector::retainedSize() + (values_ ? values_->capacity() : 0);
-    for (auto& buffer : stringBuffers_) {
-      size += buffer->capacity();
-    }
-    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
@@ -431,6 +425,16 @@ class FlatVector final : public SimpleVector<T> {
     return stringBuffers_;
   }
 
+  /// Used for vectors of type VARCHAR and VARBINARY. Returns the total size in
+  /// bytes of string buffers held by this vector.
+  uint64_t stringBufferSize() const {
+    uint64_t size = 0;
+    for (const auto& buffer : stringBuffers_) {
+      size += buffer->capacity();
+    }
+    return size;
+  }
+
   /// Used for vectors of type VARCHAR and VARBINARY to replace the old data
   /// buffers with 'buffers' which are referenced by StringView's.
   void setStringBuffers(std::vector<BufferPtr> buffers) {
@@ -555,10 +559,11 @@ class FlatVector final : public SimpleVector<T> {
       const vector_size_t* toSourceRow);
 
   // Ensures that the values buffer has space for 'newSize' elements and is
-  // mutable. Sets elements between the old and new sizes to 'initialValue' if
-  // the new size > old size.
+  // mutable. Sets elements between the previous and new sizes to 'initialValue'
+  // if the new size > previous size.
   void resizeValues(
       vector_size_t newSize,
+      vector_size_t previousSize,
       const std::optional<T>& initialValue);
 
   // Check string buffers. Keep at most one singly-referenced buffer if it is
@@ -578,6 +583,21 @@ class FlatVector final : public SimpleVector<T> {
     }
   }
 
+  // Transfer or copy string buffers to 'pool'. Update StringViews in values_ to
+  // reference addresses in the new buffers. Non-StringView-typed FlatVector
+  // should not have string buffers.
+  void transferAndUpdateStringBuffers(velox::memory::MemoryPool* pool);
+
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    auto size =
+        BaseVector::retainedSizeImpl() + (values_ ? values_->capacity() : 0);
+    for (auto& buffer : stringBuffers_) {
+      size += buffer->capacity();
+      totalStringBufferSize += buffer->capacity();
+    }
+    return size;
+  }
+
   // Contiguous values.
   // If strings, these are velox::StringViews into memory held by
   // 'stringBuffers_'
diff --git a/velox/vector/FunctionVector.h b/velox/vector/FunctionVector.h
index 796936e4dde8..8d51ec58985d 100644
--- a/velox/vector/FunctionVector.h
+++ b/velox/vector/FunctionVector.h
@@ -94,7 +94,7 @@ class FunctionVector : public BaseVector {
       /// Rows that lambda applies to.
       SelectivityVector* rows;
 
-      operator bool() const {
+      explicit operator bool() const {
         return callable != nullptr;
       }
     };
@@ -130,7 +130,7 @@ class FunctionVector : public BaseVector {
   FunctionVector(velox::memory::MemoryPool* pool, TypePtr type)
       : BaseVector(
             pool,
-            type,
+            std::move(type),
             VectorEncoding::Simple::FUNCTION,
             BufferPtr(nullptr),
             0) {}
@@ -153,7 +153,7 @@ class FunctionVector : public BaseVector {
     }
 
     rowSets_.push_back(rows);
-    functions_.push_back(callable);
+    functions_.push_back(std::move(callable));
   }
 
   bool containsNullAt(vector_size_t idx) const override {
@@ -202,7 +202,16 @@ class FunctionVector : public BaseVector {
         "testingCopyPreserveEncodings not defined for FunctionVector");
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* /*pool*/) override {
+    VELOX_UNSUPPORTED("transferTo not defined for FunctionVector");
+  }
+
  private:
+  uint64_t retainedSizeImpl(
+      uint64_t& /*totalStringBufferSize*/) const override {
+    VELOX_UNREACHABLE("retainedSize should not be called on FunctionVector");
+  }
+
   std::vector<std::shared_ptr<Callable>> functions_;
   std::vector<SelectivityVector> rowSets_;
 };
diff --git a/velox/vector/LazyVector.cpp b/velox/vector/LazyVector.cpp
index 491902436d0a..f0c46bef8afb 100644
--- a/velox/vector/LazyVector.cpp
+++ b/velox/vector/LazyVector.cpp
@@ -77,7 +77,8 @@ void VectorLoader::load(
     const SelectivityVector& rows,
     ValueHook* hook,
     vector_size_t resultSize,
-    VectorPtr* result) {
+    VectorPtr* result,
+    memory::MemoryPool* pool) {
   if (rows.isAllSelected()) {
     const auto& indices = DecodedVector::consecutiveIndices();
     VELOX_DCHECK(!indices.empty());
@@ -90,7 +91,7 @@ void VectorLoader::load(
       return;
     }
   }
-  raw_vector<vector_size_t> positions(rows.countSelected());
+  raw_vector<vector_size_t> positions(rows.countSelected(), pool);
   simd::indicesOfSetBits(
       rows.allBits(), rows.begin(), rows.end(), positions.data());
   load(positions, hook, resultSize, result);
@@ -191,7 +192,7 @@ void LazyVector::ensureLoadedRowsImpl(
 
   if (!baseLazyVector->isLoaded()) {
     // Create rowSet.
-    raw_vector<vector_size_t> rowNumbers;
+    raw_vector<vector_size_t> rowNumbers(baseLazyVector->pool());
     RowSet rowSet;
     if (decoded.isConstantMapping()) {
       rowNumbers.push_back(decoded.index(rows.begin()));
@@ -202,15 +203,17 @@ void LazyVector::ensureLoadedRowsImpl(
         rowSet = RowSet(iota, rows.end());
       } else {
         rowNumbers.resize(rows.end());
-        rowNumbers.resize(simd::indicesOfSetBits(
-            rows.asRange().bits(), 0, rows.end(), rowNumbers.data()));
+        rowNumbers.resize(
+            simd::indicesOfSetBits(
+                rows.asRange().bits(), 0, rows.end(), rowNumbers.data()));
         rowSet = RowSet(rowNumbers);
       }
     } else {
       selectBaseRowsToLoad(decoded, baseRows, rows);
       rowNumbers.resize(baseRows.end());
-      rowNumbers.resize(simd::indicesOfSetBits(
-          baseRows.asRange().bits(), 0, baseRows.end(), rowNumbers.data()));
+      rowNumbers.resize(
+          simd::indicesOfSetBits(
+              baseRows.asRange().bits(), 0, baseRows.end(), rowNumbers.data()));
 
       rowSet = RowSet(rowNumbers);
     }
@@ -254,6 +257,7 @@ void LazyVector::validate(const VectorValidateOptions& options) const {
 
 void LazyVector::load(RowSet rows, ValueHook* hook) const {
   VELOX_CHECK(!allLoaded_, "A LazyVector can be loaded at most once");
+  VELOX_CHECK(!hook || supportsHook());
 
   allLoaded_ = true;
   if (rows.empty()) {
@@ -280,7 +284,7 @@ void LazyVector::loadVectorInternal() const {
       vector_ = BaseVector::create(type_, 0, pool_);
     }
     SelectivityVector allRows(BaseVector::length_);
-    loader_->load(allRows, nullptr, size(), &vector_);
+    loader_->load(allRows, nullptr, size(), &vector_, pool_);
     VELOX_CHECK_NOT_NULL(vector_);
     if (vector_->encoding() == VectorEncoding::Simple::LAZY) {
       vector_ = vector_->asUnchecked<LazyVector>()->loadedVectorShared();
diff --git a/velox/vector/LazyVector.h b/velox/vector/LazyVector.h
index c7dc8801f8c6..b50b60901c94 100644
--- a/velox/vector/LazyVector.h
+++ b/velox/vector/LazyVector.h
@@ -78,7 +78,7 @@ class ValueHook {
     VELOX_UNSUPPORTED();
   }
 
-  virtual void addValue(vector_size_t /*row*/, folly::StringPiece /*value*/) {
+  virtual void addValue(vector_size_t /*row*/, std::string_view /*value*/) {
     VELOX_UNSUPPORTED();
   }
 
@@ -159,7 +159,8 @@ class ValueHook {
       const StringView* values,
       vector_size_t size) {
     for (auto i = 0; i < size; ++i) {
-      addValue(rows[i], values[i]);
+      // TODO: Remove explicit std::string_view cast.
+      addValue(rows[i], std::string_view(values[i]));
     }
   }
 
@@ -167,12 +168,17 @@ class ValueHook {
   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 if constexpr (std::is_same_v<T, StringView>) {
+      // TODO: Remove explicit std::string_view cast.
+      addValue(row, std::string_view(value));
     } else {
       addValue(row, value);
     }
   }
 };
 
+class ChainedVectorLoader;
+
 // Produces values for a LazyVector for a set of positions.
 class VectorLoader {
  public:
@@ -199,9 +205,16 @@ class VectorLoader {
       const SelectivityVector& rows,
       ValueHook* hook,
       vector_size_t resultSize,
-      VectorPtr* result);
+      VectorPtr* result,
+      memory::MemoryPool* pool);
+
+  virtual bool supportsHook() const {
+    return false;
+  }
 
  protected:
+  friend class ChainedVectorLoader;
+
   virtual void loadInternal(
       RowSet rows,
       ValueHook* hook,
@@ -209,6 +222,29 @@ class VectorLoader {
       VectorPtr* result) = 0;
 };
 
+class ChainedVectorLoader : public VectorLoader {
+ public:
+  using PostVectorLoadProcessor = std::function<void(VectorPtr&)>;
+
+  ChainedVectorLoader(
+      std::unique_ptr<VectorLoader> loader,
+      PostVectorLoadProcessor postLoadProc)
+      : loader_(std::move(loader)), postLoadProc_(std::move(postLoadProc)) {}
+
+ private:
+  void loadInternal(
+      RowSet rows,
+      ValueHook* hook,
+      vector_size_t resultSize,
+      VectorPtr* result) override {
+    loader_->loadInternal(rows, hook, resultSize, result);
+    postLoadProc_(*result);
+  }
+
+  std::unique_ptr<VectorLoader> loader_;
+  PostVectorLoadProcessor postLoadProc_;
+};
+
 // Vector class which produces values on first use. This is used for
 // loading columns on demand. This allows eliding load of
 // columns which have all values filtered out by e.g. joins or which
@@ -330,11 +366,6 @@ class LazyVector : public BaseVector {
     return loadedVector()->containsNullAt(index);
   }
 
-  uint64_t retainedSize() const override {
-    return isLoaded() ? loadedVector()->retainedSize()
-                      : BaseVector::retainedSize();
-  }
-
   /// Returns zero if vector has not been loaded yet.
   uint64_t estimateFlatSize() const override {
     return isLoaded() ? loadedVector()->estimateFlatSize() : 0;
@@ -346,6 +377,16 @@ class LazyVector : public BaseVector {
 
   VectorPtr slice(vector_size_t offset, vector_size_t length) const override;
 
+  bool supportsHook() const {
+    return loader_->supportsHook();
+  }
+
+  void chain(ChainedVectorLoader::PostVectorLoadProcessor postLoadProc) {
+    VELOX_CHECK(!allLoaded_);
+    loader_ = std::make_unique<ChainedVectorLoader>(
+        std::move(loader_), std::move(postLoadProc));
+  }
+
   // Loads 'rows' of 'vector'. 'vector' may be an arbitrary wrapping
   // of a LazyVector. 'rows' are translated through the wrappers. If
   // there is no LazyVector inside 'vector', this has no
@@ -370,6 +411,13 @@ class LazyVector : public BaseVector {
     return loadedVector()->testingCopyPreserveEncodings(pool);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* pool) override {
+    BaseVector::transferOrCopyTo(pool);
+    if (vector_) {
+      vector_->transferOrCopyTo(pool);
+    }
+  }
+
  private:
   static void ensureLoadedRowsImpl(
       const VectorPtr& vector,
@@ -379,6 +427,11 @@ class LazyVector : public BaseVector {
 
   void loadVectorInternal() const;
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return isLoaded() ? loadedVector()->retainedSize(totalStringBufferSize)
+                      : BaseVector::retainedSizeImpl();
+  }
+
   std::unique_ptr<VectorLoader> loader_;
 
   // True if all values are loaded.
diff --git a/velox/vector/SelectivityVector.h b/velox/vector/SelectivityVector.h
index 6e4eb0cab291..7c8779d33518 100644
--- a/velox/vector/SelectivityVector.h
+++ b/velox/vector/SelectivityVector.h
@@ -338,9 +338,6 @@ class SelectivityVector {
                  return bits_[index] == other.bits_[index];
                });
   }
-  bool operator!=(const SelectivityVector& other) const {
-    return !(*this == other);
-  }
 
   /// Invokes a function on each selected row. The function must take a single
   /// "row" argument of type vector_size_t and return void.
@@ -364,7 +361,7 @@ class SelectivityVector {
 
     // Intentionally going from zero to avoid surprises debugging if begin() and
     // end() not correct
-    for (size_t i = 0; i < selectivityVector.size(); ++i) {
+    for (size_t i = 0; i < static_cast<size_t>(selectivityVector.size()); ++i) {
       if (selectivityVector.isValid(i)) {
         if (!firstValidEncountered) {
           os << ", ";
@@ -441,6 +438,8 @@ class SelectivityIterator {
 template <typename Callable>
 inline void SelectivityVector::applyToSelected(Callable func) const {
   if (isAllSelected()) {
+    // IMPORTANT: Do not remove this line.  Without it the compiler would not be
+    // able to vectorize or unroll the loop.
     const auto end = end_;
     for (vector_size_t row = begin_; row < end; ++row) {
       func(row);
diff --git a/velox/vector/SequenceVector-inl.h b/velox/vector/SequenceVector-inl.h
index 27e47271c379..f63014ca6204 100644
--- a/velox/vector/SequenceVector-inl.h
+++ b/velox/vector/SequenceVector-inl.h
@@ -23,7 +23,7 @@ namespace facebook::velox {
 template <typename T>
 SequenceVector<T>::SequenceVector(
     velox::memory::MemoryPool* pool,
-    size_t length,
+    vector_size_t length,
     VectorPtr sequenceValues,
     BufferPtr sequenceLengths,
     const SimpleVectorStats<T>& stats,
@@ -62,8 +62,6 @@ void SequenceVector<T>::setInternalState() {
   }
   lengths_ = sequenceLengths_->as<vector_size_t>();
   lastIndexRangeEnd_ = lengths_[0];
-  BaseVector::inMemoryBytes_ += sequenceValues_->inMemoryBytes();
-  BaseVector::inMemoryBytes_ += sequenceLengths_->capacity();
 }
 
 template <typename T>
@@ -119,6 +117,7 @@ std::unique_ptr<SimpleVector<uint64_t>> SequenceVector<T>::hashAll() const {
       0 /* nullSequenceCount */);
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T>
 xsimd::batch<T> SequenceVector<T>::loadSIMDValueBufferAt(
     size_t byteOffset) const {
@@ -138,6 +137,7 @@ xsimd::batch<T> SequenceVector<T>::loadSIMDValueBufferAt(
     return xsimd::load_aligned(tmp);
   }
 }
+#endif
 
 template <typename T>
 bool SequenceVector<T>::checkLoadRange(size_t index, size_t count) const {
diff --git a/velox/vector/SequenceVector.h b/velox/vector/SequenceVector.h
index a87d7534e882..99ad41acf16a 100644
--- a/velox/vector/SequenceVector.h
+++ b/velox/vector/SequenceVector.h
@@ -34,14 +34,16 @@ namespace facebook::velox {
 template <typename T>
 class SequenceVector : public SimpleVector<T> {
  public:
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   static constexpr bool can_simd =
       (std::is_same_v<T, int64_t> || std::is_same_v<T, int32_t> ||
        std::is_same_v<T, int16_t> || std::is_same_v<T, int8_t> ||
        std::is_same_v<T, size_t>);
+#endif
 
   SequenceVector(
       velox::memory::MemoryPool* pool,
-      size_t length,
+      vector_size_t length,
       VectorPtr sequenceValues,
       BufferPtr sequenceLengths,
       const SimpleVectorStats<T>& stats = {},
@@ -89,6 +91,7 @@ class SequenceVector : public SimpleVector<T> {
 
   std::unique_ptr<SimpleVector<uint64_t>> hashAll() const override;
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
   /**
    * Loads a 256bit vector of data at the virtual byteOffset given
    * Note this method is implemented on each vector type, but is intentionally
@@ -97,6 +100,7 @@ class SequenceVector : public SimpleVector<T> {
    * @param byteOffset - the byte offset to laod from
    */
   xsimd::batch<T> loadSIMDValueBufferAt(size_t index) const;
+#endif
 
   /**
    * Returns a shared_ptr to the underlying byte buffer holding the values for
@@ -144,10 +148,6 @@ class SequenceVector : public SimpleVector<T> {
     return sequenceLengths_;
   }
 
-  uint64_t retainedSize() const override {
-    return sequenceValues_->retainedSize() + sequenceLengths_->capacity();
-  }
-
   bool isScalar() const override {
     return sequenceValues_->isScalar();
   }
@@ -210,12 +210,21 @@ class SequenceVector : public SimpleVector<T> {
         BaseVector::storageByteCount_);
   }
 
+  void transferOrCopyTo(velox::memory::MemoryPool* /*pool*/) override {
+    VELOX_NYI("{} unsupported", __FUNCTION__);
+  }
+
  private:
   // Prepares for use after construction.
   void setInternalState();
 
   bool checkLoadRange(size_t idx, size_t count) const;
 
+  uint64_t retainedSizeImpl(uint64_t& totalStringBufferSize) const override {
+    return sequenceValues_->retainedSize(totalStringBufferSize) +
+        sequenceLengths_->capacity();
+  }
+
   VectorPtr sequenceValues_;
   SimpleVector<T>* scalarSequenceValues_ = nullptr;
   BufferPtr sequenceLengths_;
diff --git a/velox/vector/SimpleVector.h b/velox/vector/SimpleVector.h
index 3c485fceba96..42abccb761e6 100644
--- a/velox/vector/SimpleVector.h
+++ b/velox/vector/SimpleVector.h
@@ -113,7 +113,7 @@ class SimpleVector : public BaseVector {
       TypePtr type,
       VectorEncoding::Simple encoding,
       BufferPtr nulls,
-      size_t length,
+      vector_size_t length,
       const SimpleVectorStats<T>& stats,
       std::optional<vector_size_t> distinctValueCount,
       std::optional<vector_size_t> nullCount,
@@ -134,7 +134,7 @@ class SimpleVector : public BaseVector {
         elementSize_(sizeof(T)),
         stats_(stats) {}
 
-  virtual ~SimpleVector() override {}
+  ~SimpleVector() override = default;
 
   SimpleVectorStats<T> getStats() const {
     return stats_;
@@ -183,7 +183,9 @@ class SimpleVector : public BaseVector {
   }
 
   template <TypeKind Kind>
-  uint64_t hashValueAt(const T& value) const {
+  static uint64_t hashValueAtWithCustomType(
+      const TypePtr& type,
+      const T& value) {
     if constexpr (!std::is_same<T, typename TypeTraits<Kind>::NativeType>()) {
       VELOX_UNSUPPORTED(
           "Cannot apply custom comparisons when the value type of the Vector {} does not match the NativeType associated with the Type of the Vector {}",
@@ -191,11 +193,16 @@ class SimpleVector : public BaseVector {
           typeid(T).name());
     } else {
       return static_cast<const CanProvideCustomComparisonType<Kind>*>(
-                 type_.get())
+                 type.get())
           ->hash(value);
     }
   }
 
+  static uint64_t hashValueAtWithCustomType(const TypePtr& type, T value) {
+    return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+        hashValueAtWithCustomType, type->kind(), type, value);
+  }
+
   /**
    * @return the hash of the value at the given index in this vector
    */
@@ -205,8 +212,7 @@ class SimpleVector : public BaseVector {
     }
 
     if (type_->providesCustomComparison()) {
-      return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-          hashValueAt, type_->kind(), valueAt(index));
+      return hashValueAtWithCustomType(type_, valueAt(index));
     }
 
     if constexpr (std::is_floating_point_v<T>) {
@@ -238,36 +244,13 @@ class SimpleVector : public BaseVector {
 
   using BaseVector::toString;
 
-  std::string valueToString(T value) const {
-    if constexpr (std::is_same_v<T, bool>) {
-      return value ? "true" : "false";
-    } else if constexpr (std::is_same_v<T, std::shared_ptr<void>>) {
-      return "<opaque>";
-    } else if constexpr (
-        std::is_same_v<T, int64_t> || std::is_same_v<T, int128_t>) {
-      if (type()->isDecimal()) {
-        return DecimalUtil::toString(value, type());
-      } else {
-        return velox::to<std::string>(value);
-      }
-    } else if constexpr (std::is_same_v<T, int32_t>) {
-      if (type()->isDate()) {
-        return DATE()->toString(value);
-      } else {
-        return velox::to<std::string>(value);
-      }
-    } else {
-      return velox::to<std::string>(value);
-    }
-  }
-
   std::string toString(vector_size_t index) const override {
     VELOX_CHECK_LT(index, length_, "Vector index should be less than length.");
     std::stringstream out;
     if (isNullAt(index)) {
-      out << "null";
+      out << kNullValueString;
     } else {
-      out << valueToString(valueAt(index));
+      out << type()->valueToString(valueAt(index));
     }
     return out.str();
   }
@@ -555,8 +538,10 @@ inline std::optional<int32_t> SimpleVector<ComplexType>::compare(
   other = other->loadedVector();
   auto wrapped = wrappedVector();
   auto otherWrapped = other->wrappedVector();
-  DCHECK(wrapped->encoding() == otherWrapped->encoding())
-      << "Attempting to compare vectors not of the same type";
+  VELOX_DCHECK_EQ(
+      wrapped->typeKind(),
+      otherWrapped->typeKind(),
+      "Attempting to compare vectors not of the same type");
 
   bool otherNull = other->isNullAt(otherIndex);
   bool isNull = isNullAt(index);
diff --git a/velox/vector/VariantToVector.cpp b/velox/vector/VariantToVector.cpp
index 95b593e0b676..9bb85e7b9a19 100644
--- a/velox/vector/VariantToVector.cpp
+++ b/velox/vector/VariantToVector.cpp
@@ -15,66 +15,129 @@
  */
 
 #include "velox/vector/VariantToVector.h"
+#include "velox/vector/ComplexVector.h"
 #include "velox/vector/FlatVector.h"
 
-namespace facebook::velox::core {
+#include <map>
+
+namespace facebook::velox {
+
+VectorPtr variantToVector(
+    const TypePtr& type,
+    const Variant& value,
+    memory::MemoryPool* pool) {
+  return BaseVector::createConstant(type, value, 1, pool);
+}
+
 namespace {
 
-template <TypeKind KIND>
-ArrayVectorPtr variantArrayToVectorImpl(
-    const TypePtr& arrayType,
-    const std::vector<variant>& variantArray,
-    velox::memory::MemoryPool* pool) {
-  using T = typename TypeTraits<KIND>::NativeType;
-
-  // First generate internal arrayVector elements.
-  const size_t variantArraySize = variantArray.size();
-
-  // Create array elements flat vector.
-  auto arrayElements = BaseVector::create<FlatVector<T>>(
-      arrayType->childAt(0), variantArraySize, pool);
-
-  // Populate internal array elements (flat vector).
-  for (vector_size_t i = 0; i < variantArraySize; i++) {
-    const auto& value = variantArray[i];
-    if (!value.isNull()) {
-      // `getOwnedValue` copies the content to its internal buffers (in case of
-      // string/StringView); no-op for other primitive types.
-      arrayElements->set(i, T(value.value<KIND>()));
-    } else {
-      arrayElements->setNull(i, true);
-    }
+Variant nullVariant(const TypePtr& type) {
+  return Variant(type->kind());
+}
+
+template <TypeKind kind>
+Variant variantAt(const VectorPtr& vector, int32_t row) {
+  using T = typename TypeTraits<kind>::NativeType;
+
+  const T value = vector->as<SimpleVector<T>>()->valueAt(row);
+
+  if (vector->type()->providesCustomComparison()) {
+    return Variant::typeWithCustomComparison<kind>(value, vector->type());
   }
 
-  // Create ArrayVector around the FlatVector containing array elements.
-  BufferPtr offsets = allocateOffsets(1, pool);
-  BufferPtr sizes = allocateSizes(1, pool);
+  return Variant(value);
+}
+
+template <>
+Variant variantAt<TypeKind::VARBINARY>(const VectorPtr& vector, int32_t row) {
+  return Variant::binary(
+      std::string(vector->as<SimpleVector<StringView>>()->valueAt(row)));
+}
+
+Variant variantAt(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();
 
-  auto rawSizes = sizes->asMutable<vector_size_t>();
-  rawSizes[0] = variantArraySize;
+  auto wrappedRow = vector->wrappedIndex(row);
+  auto offset = arrayVector->offsetAt(wrappedRow);
+  auto size = arrayVector->sizeAt(wrappedRow);
 
-  return std::make_shared<ArrayVector>(
-      pool, arrayType, nullptr, 1, offsets, sizes, arrayElements);
+  std::vector<Variant> array;
+  array.reserve(size);
+  for (vector_size_t i = 0; i < size; ++i) {
+    array.push_back(variantAt(elements, offset + i));
+  }
+
+  return Variant::array(array);
 }
-} // namespace
 
-ArrayVectorPtr variantArrayToVector(
-    const TypePtr& arrayType,
-    const std::vector<variant>& variantArray,
-    velox::memory::MemoryPool* pool) {
-  VELOX_CHECK_EQ(TypeKind::ARRAY, arrayType->kind());
+Variant mapVariantAt(const VectorPtr& vector, vector_size_t row) {
+  auto mapVector = vector->wrappedVector()->as<MapVector>();
+  auto& keys = mapVector->mapKeys();
+  auto& values = mapVector->mapValues();
+
+  auto wrappedRow = vector->wrappedIndex(row);
+  auto offset = mapVector->offsetAt(wrappedRow);
+  auto size = mapVector->sizeAt(wrappedRow);
 
-  if (arrayType->childAt(0)->isUnKnown()) {
-    return variantArrayToVectorImpl<TypeKind::UNKNOWN>(
-        arrayType, variantArray, pool);
+  std::map<Variant, Variant> map;
+  for (vector_size_t i = 0; i < size; ++i) {
+    map.emplace(variantAt(keys, offset + i), variantAt(values, offset + i));
   }
 
-  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
-      variantArrayToVectorImpl,
-      arrayType->childAt(0)->kind(),
-      arrayType,
-      variantArray,
-      pool);
+  return Variant::map(std::move(map));
+}
+
+Variant rowVariantAt(const VectorPtr& vector, vector_size_t row) {
+  auto rowVector = vector->wrappedVector()->as<RowVector>();
+  auto wrappedRow = vector->wrappedIndex(row);
+
+  std::vector<Variant> rowValues;
+  rowValues.reserve(rowVector->childrenSize());
+  for (vector_size_t i = 0; i < rowVector->childrenSize(); ++i) {
+    rowValues.push_back(variantAt(rowVector->childAt(i), wrappedRow));
+  }
+
+  return Variant::row(rowValues);
+}
+
+Variant variantAt(const VectorPtr& vector, vector_size_t row) {
+  if (vector->isNullAt(row)) {
+    return nullVariant(vector->type());
+  }
+
+  auto typeKind = vector->typeKind();
+
+  if (vector->isConstantEncoding()) {
+    if (vector->valueVector()) {
+      return variantAt(vector->valueVector(), vector->wrappedIndex(row));
+    }
+    return variantAt(BaseVector::wrappedVectorShared(vector), 0);
+  }
+
+  switch (typeKind) {
+    case TypeKind::ARRAY:
+      return arrayVariantAt(vector, row);
+    case TypeKind::MAP:
+      return mapVariantAt(vector, row);
+    case TypeKind::ROW:
+      return rowVariantAt(vector, row);
+    case TypeKind::OPAQUE:
+      return Variant::opaque(
+          vector->as<SimpleVector<std::shared_ptr<void>>>()->valueAt(row),
+          std::dynamic_pointer_cast<const OpaqueType>(vector->type()));
+    default:
+      return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+          variantAt, typeKind, vector, row);
+  }
+}
+
+} // namespace
+
+Variant vectorToVariant(const VectorPtr& vector, vector_size_t index) {
+  return variantAt(vector, index);
 }
 
-} // namespace facebook::velox::core
+} // namespace facebook::velox
diff --git a/velox/vector/VariantToVector.h b/velox/vector/VariantToVector.h
index 94dd3cdb16ee..0ec557e284c2 100644
--- a/velox/vector/VariantToVector.h
+++ b/velox/vector/VariantToVector.h
@@ -15,16 +15,21 @@
  */
 #pragma once
 
-#include "velox/vector/ComplexVector.h"
+#include "velox/vector/BaseVector.h"
 
-namespace facebook::velox::core {
+namespace facebook::velox {
 
-// Converts a sequence of values from a variant array to an ArrayVector. The
-// output ArrayVector contains one single row, which contains the elements
-// extracted from the input variant vector.
-ArrayVectorPtr variantArrayToVector(
-    const TypePtr& arrayType,
-    const std::vector<variant>& variantArray,
-    velox::memory::MemoryPool* pool);
+// Converts Variant `value` into a Velox vector using specified type.
+//
+// Supports all primitive types and complex types.
+//
+// @returns ConstantVector of size 1.
+//
+// Deprecated: use BaseVector::createConstant instead.
+[[deprecated("Use BaseVector::createConstant")]]
+VectorPtr variantToVector(
+    const TypePtr& type,
+    const Variant& value,
+    memory::MemoryPool* pool);
 
-} // namespace facebook::velox::core
+} // namespace facebook::velox
diff --git a/velox/vector/VectorPrinter.cpp b/velox/vector/VectorPrinter.cpp
index f0eff3ca0648..5a3ab59ae195 100644
--- a/velox/vector/VectorPrinter.cpp
+++ b/velox/vector/VectorPrinter.cpp
@@ -16,6 +16,7 @@
 #include "velox/vector/VectorPrinter.h"
 #include <sstream>
 #include "velox/vector/ComplexVector.h"
+#include "velox/vector/DecodedVector.h"
 
 namespace facebook::velox {
 
diff --git a/velox/vector/VectorSaver.cpp b/velox/vector/VectorSaver.cpp
index 75535c8b4ee7..f4374073cd24 100644
--- a/velox/vector/VectorSaver.cpp
+++ b/velox/vector/VectorSaver.cpp
@@ -17,6 +17,7 @@
 #include <fstream>
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/FlatVector.h"
+#include "velox/vector/LazyVector.h"
 
 namespace facebook::velox {
 
@@ -247,10 +248,11 @@ void writeStringViews(
   std::vector<BufferMetadata> sortedStringBuffers;
   sortedStringBuffers.reserve(stringBuffers.size());
   for (int64_t i = 0; i < stringBuffers.size(); ++i) {
-    sortedStringBuffers.push_back(BufferMetadata{
-        stringBuffers[i]->as<char>(),
-        stringBuffers[i]->as<char>() + stringBuffers[i]->size(),
-        i});
+    sortedStringBuffers.push_back(
+        BufferMetadata{
+            stringBuffers[i]->as<char>(),
+            stringBuffers[i]->as<char>() + stringBuffers[i]->size(),
+            i});
   }
 
   std::sort(
diff --git a/velox/vector/VectorStream.cpp b/velox/vector/VectorStream.cpp
index 32d5886ca457..85f682767958 100644
--- a/velox/vector/VectorStream.cpp
+++ b/velox/vector/VectorStream.cpp
@@ -322,10 +322,11 @@ RowVectorPtr IOBufToRowVector(
   ranges.reserve(4);
 
   for (const auto& range : ioBuf) {
-    ranges.emplace_back(ByteRange{
-        const_cast<uint8_t*>(range.data()),
-        static_cast<int32_t>(range.size()),
-        0});
+    ranges.emplace_back(
+        ByteRange{
+            const_cast<uint8_t*>(range.data()),
+            static_cast<int32_t>(range.size()),
+            0});
   }
 
   auto byteStream = std::make_unique<BufferInputStream>(std::move(ranges));
@@ -340,4 +341,31 @@ RowVectorPtr IOBufToRowVector(
   return outputVector;
 }
 
+folly::IOBuf rowVectorToIOBufBatch(
+    const RowVectorPtr& rowVector,
+    memory::MemoryPool& pool,
+    VectorSerde* serde,
+    const VectorSerde::Options* options) {
+  return rowVectorToIOBufBatch(
+      rowVector, rowVector->size(), pool, serde, options);
+}
+
+folly::IOBuf rowVectorToIOBufBatch(
+    const RowVectorPtr& rowVector,
+    vector_size_t rangeEnd,
+    memory::MemoryPool& pool,
+    VectorSerde* serde,
+    const VectorSerde::Options* options) {
+  if (serde == nullptr) {
+    serde = getVectorSerde();
+  }
+
+  auto serializer = serde->createBatchSerializer(&pool, options);
+  IOBufOutputStream stream(pool);
+  IndexRange range{0, rangeEnd};
+  Scratch scratch;
+  serializer->serialize(rowVector, folly::Range(&range, 1), scratch, &stream);
+  return std::move(*stream.getIOBuf());
+}
+
 } // namespace facebook::velox
diff --git a/velox/vector/VectorStream.h b/velox/vector/VectorStream.h
index 3219ed095f6f..dc5751b5139e 100644
--- a/velox/vector/VectorStream.h
+++ b/velox/vector/VectorStream.h
@@ -36,7 +36,7 @@ struct IndexRange {
 namespace row {
 class CompactRow;
 class UnsafeRowFast;
-}; // namespace row
+} // namespace row
 
 struct CompressionStats {
   // Number of times compression was not attempted.
@@ -190,7 +190,13 @@ class RowIterator {
 
   virtual bool hasNext() const = 0;
 
-  virtual std::unique_ptr<std::string> next() = 0;
+  virtual std::unique_ptr<std::string> nextRow() = 0;
+
+  /// Returns a batch of serialized rows as string views. Reads up to maxRows
+  /// from the source stream. The returned views are valid until the next call
+  /// to nextBatch or object destruction. This method provides better
+  /// performance for bulk operations compared to repeated nextRow() calls.
+  virtual std::vector<std::string_view> nextBatch(size_t maxRows) = 0;
 
  protected:
   ByteInputStream* const source_;
@@ -467,7 +473,9 @@ class VectorStreamGroup : public StreamArena {
       const VectorSerde::Options* options);
 
   void clear() override {
+    serializer_->clear();
     StreamArena::clear();
+    // TODO: provide a separate method to initialize the serializer header.
     serializer_->clear();
   }
 
@@ -499,6 +507,22 @@ folly::IOBuf rowVectorToIOBuf(
     memory::MemoryPool& pool,
     VectorSerde* serde = nullptr);
 
+/// Convenience function to serialize a single rowVector into an IOBuf using
+/// BatchVectorSerializer, which preserves encodings of input vectors.
+folly::IOBuf rowVectorToIOBufBatch(
+    const RowVectorPtr& rowVector,
+    memory::MemoryPool& pool,
+    VectorSerde* serde = nullptr,
+    const VectorSerde::Options* options = nullptr);
+
+/// Same as above but serializes up until row `rangeEnd`.
+folly::IOBuf rowVectorToIOBufBatch(
+    const RowVectorPtr& rowVector,
+    vector_size_t rangeEnd,
+    memory::MemoryPool& pool,
+    VectorSerde* serde = nullptr,
+    const VectorSerde::Options* options = nullptr);
+
 /// Convenience function to deserialize an IOBuf into a rowVector. If `serde` is
 /// nullptr, use the default installed serializer.
 RowVectorPtr IOBufToRowVector(
diff --git a/velox/vector/VectorUtil.h b/velox/vector/VectorUtil.h
index 76cadcfc720d..2de9e902f884 100644
--- a/velox/vector/VectorUtil.h
+++ b/velox/vector/VectorUtil.h
@@ -26,7 +26,7 @@ template <typename T>
 static inline BufferPtr copyToBuffer(
     const T& values,
     velox::memory::MemoryPool* pool,
-    folly::Optional<int32_t> size = folly::none,
+    std::optional<int32_t> size = std::nullopt,
     bool returnsNullptr = false) {
   using Value = typename T::value_type;
   VELOX_CHECK(pool, "pool must be non-null");
diff --git a/velox/vector/arrow/Bridge.cpp b/velox/vector/arrow/Bridge.cpp
index 2c81819163c4..84e65a039f10 100644
--- a/velox/vector/arrow/Bridge.cpp
+++ b/velox/vector/arrow/Bridge.cpp
@@ -286,6 +286,11 @@ const char* exportArrowFormatStr(
       }
       return "i"; // int32
     case TypeKind::BIGINT:
+      if (type->isTime()) {
+        // TIME is stored as milliseconds since midnight in Velox.
+        // Export as Arrow time32 with milliseconds unit.
+        return "ttm";
+      }
       return "l"; // int64
     case TypeKind::REAL:
       return "f"; // float32
@@ -385,6 +390,30 @@ struct Selection {
   vector_size_t total_;
 };
 
+// Gather values from time buffer. Nulls are skipped.
+// TIME is stored as int64_t milliseconds in Velox, converted to int32_t
+// milliseconds for Arrow time32.
+void gatherFromTimeBuffer(
+    const BaseVector& vec,
+    const Selection& rows,
+    Buffer& out) {
+  auto src = (*vec.values()).as<int64_t>();
+  auto dst = out.asMutable<int32_t>();
+  vector_size_t j = 0;
+  if (!vec.mayHaveNulls() || vec.getNullCount() == 0) {
+    // Convert int64 milliseconds to int32 milliseconds.
+    rows.apply(
+        [&](vector_size_t i) { dst[j++] = static_cast<int32_t>(src[i]); });
+    return;
+  }
+  rows.apply([&](vector_size_t i) {
+    if (!vec.isNullAt(i)) {
+      dst[j] = static_cast<int32_t>(src[i]); // int64 to int32 milliseconds.
+    }
+    j++;
+  });
+}
+
 // Gather values from timestamp buffer. Nulls are skipped.
 void gatherFromTimestampBuffer(
     const BaseVector& vec,
@@ -532,14 +561,14 @@ VectorPtr createFlatVector(
     memory::MemoryPool* pool,
     const TypePtr& type,
     BufferPtr nulls,
-    size_t length,
+    vector_size_t length,
     BufferPtr values,
     int64_t nullCount) {
   using T = typename TypeTraits<kind>::NativeType;
   return std::make_shared<FlatVector<T>>(
       pool,
       type,
-      nulls,
+      std::move(nulls),
       length,
       values,
       std::vector<BufferPtr>(),
@@ -611,7 +640,7 @@ VectorPtr createStringFlatVector(
     memory::MemoryPool* pool,
     const TypePtr& type,
     BufferPtr nulls,
-    size_t length,
+    vector_size_t length,
     const TOffset* offsets,
     const char* values,
     int64_t nullCount,
@@ -621,8 +650,16 @@ VectorPtr createStringFlatVector(
   bool shouldAcquireStringBuffer = false;
 
   for (size_t i = 0; i < length; ++i) {
-    rawStringViews[i] =
-        StringView(values + offsets[i], offsets[i + 1] - offsets[i]);
+    const auto rowBytes = offsets[i + 1] - offsets[i];
+    if constexpr (!std::is_same_v<TOffset, int32_t>) {
+      VELOX_CHECK(
+          rowBytes >= 0 && rowBytes <= std::numeric_limits<int32_t>::max(),
+          "Offset difference (rowBytes = {}) is negative or out of int32_t range at index {}",
+          rowBytes,
+          i);
+    }
+
+    rawStringViews[i] = StringView(values + offsets[i], rowBytes);
     shouldAcquireStringBuffer |= !rawStringViews[i].isInline();
   }
 
@@ -634,7 +671,7 @@ VectorPtr createStringFlatVector(
   return std::make_shared<FlatVector<StringView>>(
       pool,
       type,
-      nulls,
+      std::move(nulls),
       length,
       stringViews,
       std::move(stringViewBuffers),
@@ -682,7 +719,8 @@ bool isFlatScalarZeroCopy(const TypePtr& type) {
   // mapped to Arrow Decimal128.
   // - Velox's Timestamp representation (2x 64bit values) does not have an
   // equivalent in Arrow.
-  return !type->isShortDecimal() && !type->isTimestamp();
+  // - Velox's TIME is in milliseconds, Arrow time64 is in microseconds.
+  return !type->isShortDecimal() && !type->isTimestamp() && !type->isTime();
 }
 
 // Returns the size of a single element of a given `type` in the target arrow
@@ -692,6 +730,9 @@ size_t getArrowElementSize(const TypePtr& type) {
     return sizeof(int128_t);
   } else if (type->isTimestamp()) {
     return sizeof(int64_t);
+  } else if (type->isTime()) {
+    // TIME is exported as Arrow time32 (int32_t).
+    return sizeof(int32_t);
   } else {
     return type->cppSizeInBytes();
   }
@@ -708,7 +749,11 @@ void exportValues(
   out.n_buffers = 2;
 
   if (!rows.changed() && isFlatScalarZeroCopy(type)) {
-    holder.setBuffer(1, vec.values());
+    // Arrow does not allow a nullptr for the values buffer. If the input vector
+    // has no values buffer (all-null case), allocate an empty buffer of size 0.
+    auto values =
+        vec.values() ? vec.values() : AlignedBuffer::allocate<uint8_t>(0, pool);
+    holder.setBuffer(1, values);
     return;
   }
 
@@ -720,6 +765,8 @@ void exportValues(
             checkedMultiply<size_t>(out.length, size), pool);
   if (type->kind() == TypeKind::TIMESTAMP) {
     gatherFromTimestampBuffer(vec, rows, options.timestampUnit, *values);
+  } else if (type->kind() == TypeKind::BIGINT && type->isTime()) {
+    gatherFromTimeBuffer(vec, rows, *values);
   } else {
     gatherFromBuffer(*type, *vec.values(), rows, options, *values);
   }
@@ -799,13 +846,15 @@ void exportViews(
       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 < (reinterpret_cast<uint64_t*>(&out.buffers[2]))[rhs];
-            }));
+        auto it = std::prev(
+            std::upper_bound(
+                stringBufferVec.begin(),
+                stringBufferVec.end(),
+                currAddr,
+                [&out](const auto& lhs, const auto& rhs) {
+                  return lhs <
+                      (reinterpret_cast<uint64_t*>(&out.buffers[2]))[rhs];
+                }));
         bufferAddrCache = (reinterpret_cast<uint64_t*>(&out.buffers[2]))[*it];
         bufferIdxCache = *it;
       }
@@ -867,9 +916,11 @@ void exportFlat(
     case TypeKind::REAL:
     case TypeKind::DOUBLE:
     case TypeKind::TIMESTAMP:
-    case TypeKind::UNKNOWN:
       exportValues(vec, rows, options, out, pool, holder);
       break;
+    case TypeKind::UNKNOWN:
+      // Keep out.n_children = 0 for UNKNOWN type.
+      break;
     case TypeKind::VARCHAR:
     case TypeKind::VARBINARY:
       if (options.exportToStringView) {
@@ -1108,19 +1159,23 @@ void exportConstantValue(
     // 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);
+    if (vec.typeKind() == TypeKind::UNKNOWN) {
+      valuesVector = BaseVector::create(vec.type(), 1, pool);
+    } else {
+      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);
 }
@@ -1299,6 +1354,9 @@ TypePtr importFromArrowImpl(
       if (format[1] == 'd' && format[2] == 'D') {
         return DATE();
       }
+      if (format[1] == 't') {
+        return TIME();
+      }
       if (format[1] == 'i' && format[2] == 'M') {
         return INTERVAL_YEAR_MONTH();
       }
@@ -1540,6 +1598,32 @@ TypePtr importFromArrow(const ArrowSchema& arrowSchema) {
 
 namespace {
 
+enum class TimeUnit { kSecond, kMilli, kMicro, kNano };
+
+TimeUnit getTimeUnit(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 time should contain 'tt' and unit char.");
+  VELOX_USER_CHECK_EQ(format[0], 't', "The first character should be 't'.");
+  VELOX_USER_CHECK_EQ(format[1], 't', "The second character should be 't'.");
+  switch (format[2]) {
+    case 's':
+      return TimeUnit::kSecond;
+    case 'm':
+      return TimeUnit::kMilli;
+    case 'u':
+      return TimeUnit::kMicro;
+    case 'n':
+      return TimeUnit::kNano;
+    default:
+      VELOX_UNREACHABLE();
+  }
+}
+
 TimestampUnit getTimestampUnit(const ArrowSchema& arrowSchema) {
   const char* format = arrowSchema.dictionary ? arrowSchema.dictionary->format
                                               : arrowSchema.format;
@@ -1831,13 +1915,133 @@ void setTimestamps(
   }
 }
 
+// Create TIME vector from Arrow time32 or time64 data.
+template <typename TArrowTime>
+VectorPtr createTimeVectorFromArrow(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    TimeUnit unit,
+    BufferPtr nulls,
+    const TArrowTime* input,
+    vector_size_t length,
+    int64_t nullCount) {
+  BufferPtr times = AlignedBuffer::allocate<int64_t>(length, pool);
+  auto* rawTimes = times->asMutable<int64_t>();
+
+  // Convert from Arrow time unit to Velox TIME (int64_t milliseconds).
+  if (nulls == nullptr) {
+    switch (unit) {
+      case TimeUnit::kSecond:
+        for (auto i = 0; i < length; ++i) {
+          rawTimes[i] = static_cast<int64_t>(input[i]) *
+              1'000; // seconds to milliseconds.
+        }
+        break;
+      case TimeUnit::kMilli:
+        for (auto i = 0; i < length; ++i) {
+          rawTimes[i] =
+              static_cast<int64_t>(input[i]); // already in milliseconds.
+        }
+        break;
+      case TimeUnit::kMicro:
+        for (auto i = 0; i < length; ++i) {
+          rawTimes[i] = static_cast<int64_t>(input[i]) /
+              1'000; // microseconds to milliseconds.
+        }
+        break;
+      case TimeUnit::kNano:
+        for (auto i = 0; i < length; ++i) {
+          rawTimes[i] = static_cast<int64_t>(input[i]) /
+              1'000'000; // nanoseconds to milliseconds.
+        }
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+  } else if (length > nullCount) {
+    const auto* rawNulls = nulls->as<const uint64_t>();
+    switch (unit) {
+      case TimeUnit::kSecond:
+        for (auto i = 0; i < length; ++i) {
+          if (!bits::isBitNull(rawNulls, i)) {
+            rawTimes[i] = static_cast<int64_t>(input[i]) * 1'000;
+          }
+        }
+        break;
+      case TimeUnit::kMilli:
+        for (auto i = 0; i < length; ++i) {
+          if (!bits::isBitNull(rawNulls, i)) {
+            rawTimes[i] = static_cast<int64_t>(input[i]);
+          }
+        }
+        break;
+      case TimeUnit::kMicro:
+        for (auto i = 0; i < length; ++i) {
+          if (!bits::isBitNull(rawNulls, i)) {
+            rawTimes[i] = static_cast<int64_t>(input[i]) / 1'000;
+          }
+        }
+        break;
+      case TimeUnit::kNano:
+        for (auto i = 0; i < length; ++i) {
+          if (!bits::isBitNull(rawNulls, i)) {
+            rawTimes[i] = static_cast<int64_t>(input[i]) / 1'000'000;
+          }
+        }
+        break;
+      default:
+        VELOX_UNREACHABLE();
+    }
+  }
+
+  return std::make_shared<FlatVector<int64_t>>(
+      pool,
+      type,
+      std::move(nulls),
+      length,
+      times,
+      std::vector<BufferPtr>(),
+      SimpleVectorStats<int64_t>{},
+      std::nullopt,
+      optionalNullCount(nullCount));
+}
+
+VectorPtr createTimeVector(
+    memory::MemoryPool* pool,
+    const TypePtr& type,
+    TimeUnit unit,
+    BufferPtr nulls,
+    const void* input,
+    vector_size_t length,
+    int64_t nullCount,
+    bool isTime32) {
+  if (isTime32) {
+    return createTimeVectorFromArrow<int32_t>(
+        pool,
+        type,
+        unit,
+        nulls,
+        static_cast<const int32_t*>(input),
+        length,
+        nullCount);
+  }
+  return createTimeVectorFromArrow<int64_t>(
+      pool,
+      type,
+      unit,
+      nulls,
+      static_cast<const int64_t*>(input),
+      length,
+      nullCount);
+}
+
 VectorPtr createTimestampVector(
     memory::MemoryPool* pool,
     const TypePtr& type,
     TimestampUnit unit,
     BufferPtr nulls,
     const int64_t* input,
-    size_t length,
+    vector_size_t length,
     int64_t nullCount) {
   BufferPtr timestamps = AlignedBuffer::allocate<Timestamp>(length, pool);
   auto* rawTimestamps = timestamps->asMutable<Timestamp>();
@@ -1849,7 +2053,7 @@ VectorPtr createTimestampVector(
   return std::make_shared<FlatVector<Timestamp>>(
       pool,
       type,
-      nulls,
+      std::move(nulls),
       length,
       timestamps,
       std::vector<BufferPtr>(),
@@ -1863,7 +2067,7 @@ VectorPtr createShortDecimalVector(
     const TypePtr& type,
     BufferPtr nulls,
     const int128_t* input,
-    size_t length,
+    vector_size_t length,
     int64_t nullCount) {
   auto values = AlignedBuffer::allocate<int64_t>(length, pool);
   auto rawValues = values->asMutable<int64_t>();
@@ -1872,7 +2076,7 @@ VectorPtr createShortDecimalVector(
   }
 
   return createFlatVector<TypeKind::BIGINT>(
-      pool, type, nulls, length, values, nullCount);
+      pool, type, std::move(nulls), length, values, nullCount);
 }
 
 // Arrow uses two uint64_t values to represent a 128-bit decimal value. The
@@ -1883,7 +2087,7 @@ VectorPtr createLongDecimalVector(
     const TypePtr& type,
     BufferPtr nulls,
     const int128_t* input,
-    size_t length,
+    vector_size_t length,
     int64_t nullCount,
     WrapInBufferViewFunc wrapInBufferView) {
   if ((reinterpret_cast<uintptr_t>(input) & 0xf) == 0) {
@@ -1891,7 +2095,7 @@ VectorPtr createLongDecimalVector(
     return createFlatVector<TypeKind::HUGEINT>(
         pool,
         type,
-        nulls,
+        std::move(nulls),
         length,
         wrapInBufferView(input, length * type->cppSizeInBytes()),
         nullCount);
@@ -1902,7 +2106,7 @@ VectorPtr createLongDecimalVector(
   memcpy(rawValues, input, length * sizeof(int128_t));
 
   return createFlatVector<TypeKind::HUGEINT>(
-      pool, type, nulls, length, values, nullCount);
+      pool, type, std::move(nulls), length, values, nullCount);
 }
 
 bool isREE(const ArrowSchema& arrowSchema) {
@@ -1973,6 +2177,17 @@ VectorPtr importFromArrowImpl(
         arrowArray.n_buffers,
         3,
         "Expecting three buffers as input for string types.");
+    if (arrowSchema.format[0] == 'U' || arrowSchema.format[0] == 'Z') {
+      return createStringFlatVector(
+          pool,
+          type,
+          nulls,
+          arrowArray.length,
+          static_cast<const int64_t*>(arrowArray.buffers[1]), // offsets
+          static_cast<const char*>(arrowArray.buffers[2]), // values
+          arrowArray.null_count,
+          wrapInBufferView);
+    }
     return createStringFlatVector(
         pool,
         type,
@@ -1991,6 +2206,19 @@ VectorPtr importFromArrowImpl(
         static_cast<const int64_t*>(arrowArray.buffers[1]),
         arrowArray.length,
         arrowArray.null_count);
+  } else if (type->isTime()) {
+    auto timeUnit = getTimeUnit(arrowSchema);
+    bool isTime32 =
+        (timeUnit == TimeUnit::kSecond || timeUnit == TimeUnit::kMilli);
+    return createTimeVector(
+        pool,
+        type,
+        timeUnit,
+        nulls,
+        arrowArray.buffers[1],
+        arrowArray.length,
+        arrowArray.null_count,
+        isTime32);
   } else if (type->isShortDecimal()) {
     return createShortDecimalVector(
         pool,
diff --git a/velox/vector/arrow/CMakeLists.txt b/velox/vector/arrow/CMakeLists.txt
index ed3733205fbf..e479a28fe2de 100644
--- a/velox/vector/arrow/CMakeLists.txt
+++ b/velox/vector/arrow/CMakeLists.txt
@@ -13,12 +13,7 @@
 # limitations under the License.
 velox_add_library(velox_arrow_bridge Bridge.cpp)
 
-velox_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 3493f5f0de82..1923a26b4d35 100644
--- a/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp
+++ b/velox/vector/arrow/tests/ArrowBridgeArrayTest.cpp
@@ -113,6 +113,7 @@ class ArrowBridgeArrayExportTest : public testing::Test {
       const ArrowArray& arrowArray) {
     const bool isString =
         std::is_same_v<T, StringView> or std::is_same_v<T, std::string>;
+    const bool isUnknownType = std::is_same_v<T, UnknownValue>;
 
     EXPECT_EQ(inputData.size(), arrowArray.length);
     EXPECT_EQ(0, arrowArray.offset);
@@ -127,11 +128,17 @@ class ArrowBridgeArrayExportTest : public testing::Test {
     // Validate array contents.
     if constexpr (isString) {
       validateStringArray(inputData, arrowArray);
+    } else if constexpr (isUnknownType) {
+      validateNullArray(arrowArray);
     } else {
       validateNumericalArray(inputData, arrowArray);
     }
   }
 
+  void validateNullArray(const ArrowArray& arrowArray) {
+    ASSERT_EQ(0, arrowArray.n_buffers);
+  }
+
   template <typename T>
   void validateNumericalArray(
       const std::vector<std::optional<T>>& inputData,
@@ -231,6 +238,7 @@ class ArrowBridgeArrayExportTest : public testing::Test {
       const ArrowArray& arrowArray) {
     const bool isString =
         std::is_same_v<T, StringView> or std::is_same_v<T, std::string>;
+    const bool isUnknownType = std::is_same_v<T, UnknownValue>;
 
     EXPECT_EQ(inputData.size(), arrowArray.length);
     EXPECT_EQ(0, arrowArray.offset);
@@ -266,6 +274,8 @@ class ArrowBridgeArrayExportTest : public testing::Test {
 
     if constexpr (isString) {
       validateStringArray(flattenedData, *childArray);
+    } else if constexpr (isUnknownType) {
+      validateNullArray(*childArray);
     } else {
       validateNumericalArray(flattenedData, *childArray);
     }
@@ -547,6 +557,48 @@ TEST_F(ArrowBridgeArrayExportTest, flatTimestamp) {
       VeloxUserError);
 }
 
+TEST_F(ArrowBridgeArrayExportTest, flatTime) {
+  std::vector<std::optional<int64_t>> inputData = {
+      0L,
+      std::nullopt,
+      1'000L,
+      60'000L,
+      3'600'000L,
+      std::nullopt,
+      50'402'000L,
+      86'399'999L,
+      std::nullopt};
+
+  auto flatVector = vectorMaker_.flatVectorNullable(inputData, TIME());
+  ArrowArray arrowArray;
+  ArrowSchema arrowSchema;
+  velox::exportToArrow(flatVector, arrowArray, pool_.get(), options_);
+  velox::exportToArrow(flatVector, arrowSchema, options_);
+
+  EXPECT_STREQ(arrowSchema.format, "ttm"); // time32 milliseconds.
+  EXPECT_EQ(arrowArray.length, inputData.size());
+  EXPECT_EQ(arrowArray.n_buffers, 2);
+
+  const uint64_t* nulls = static_cast<const uint64_t*>(arrowArray.buffers[0]);
+  const int32_t* values = static_cast<const int32_t*>(arrowArray.buffers[1]);
+
+  ASSERT_NE(nulls, nullptr);
+
+  for (auto i = 0; i < inputData.size(); ++i) {
+    if (inputData[i] == std::nullopt) {
+      EXPECT_TRUE(bits::isBitNull(nulls, i));
+    } else {
+      EXPECT_FALSE(bits::isBitNull(nulls, i));
+      // Velox milliseconds exported as Arrow time32 milliseconds (int32).
+      EXPECT_EQ(static_cast<int32_t>(inputData[i].value()), values[i])
+          << "mismatch at index " << i;
+    }
+  }
+
+  arrowArray.release(&arrowArray);
+  arrowSchema.release(&arrowSchema);
+}
+
 TEST_F(ArrowBridgeArrayExportTest, flatString) {
   testFlatVector<std::string>({
       "my string",
@@ -1007,6 +1059,13 @@ TEST_F(ArrowBridgeArrayExportTest, dictionaryNested) {
   EXPECT_EQ(values.Value(2), 3);
 }
 
+TEST_F(ArrowBridgeArrayExportTest, unknownType) {
+  VectorPtr vector =
+      BaseVector::createNullConstant(UNKNOWN(), 2048, pool_.get());
+  testConstantVector<true, UnknownValue>(
+      vector, std::vector<std::optional<UnknownValue>>{std::nullopt});
+}
+
 TEST_F(ArrowBridgeArrayExportTest, constants) {
   testConstant((int64_t)987654321);
   testConstant((int32_t)1234);
@@ -1117,6 +1176,7 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     return makeArrowArray(holder.buffers, 2, length, nullCount);
   }
 
+  template <typename TOffsets = int32_t>
   ArrowArray fillArrowArray(
       const std::vector<std::optional<std::string>>& inputValues,
       ArrowContextHolder& holder) {
@@ -1132,11 +1192,11 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     }
 
     holder.nulls = AlignedBuffer::allocate<uint64_t>(length, pool_.get());
-    holder.offsets = AlignedBuffer::allocate<int32_t>(length + 1, pool_.get());
+    holder.offsets = AlignedBuffer::allocate<TOffsets>(length + 1, pool_.get());
     holder.values = AlignedBuffer::allocate<char>(bufferSize, pool_.get());
 
     auto rawNulls = holder.nulls->asMutable<uint64_t>();
-    auto rawOffsets = holder.offsets->asMutable<int32_t>();
+    auto rawOffsets = holder.offsets->asMutable<TOffsets>();
     auto rawValues = holder.values->asMutable<char>();
     *rawOffsets = 0;
 
@@ -1164,6 +1224,10 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     return makeArrowArray(holder.buffers, 3, length, nullCount);
   }
 
+  bool is64Offsets(const char* format) {
+    return format != nullptr && (format[0] == 'U' || format[0] == 'Z');
+  }
+
   // 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.
@@ -1172,7 +1236,21 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
       const char* format,
       const std::vector<std::optional<TInput>>& inputValues) {
     ArrowContextHolder holder;
-    auto arrowArray = fillArrowArray(inputValues, holder);
+    auto arrowArray = [&] {
+      if constexpr (std::is_same_v<TInput, std::string>) {
+        if (is64Offsets(format)) {
+          return fillArrowArray<int64_t>(inputValues, holder);
+        }
+      }
+      return fillArrowArray(inputValues, holder);
+    }();
+
+    // for format U or Z, the offsets buffer is int64_t
+    if (is64Offsets(format)) {
+      EXPECT_EQ(arrowArray.n_buffers, 3);
+      EXPECT_EQ(
+          holder.offsets->size(), (inputValues.size() + 1) * sizeof(int64_t));
+    }
 
     auto arrowSchema = makeArrowSchema(format);
     auto output = importFromArrow(arrowSchema, arrowArray, pool_.get());
@@ -1184,6 +1262,18 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
         std::is_same_v<TInput, int128_t> && std::is_same_v<TOutput, int64_t>) {
       assertShortDecimalVectorContent(
           inputValues, output, arrowArray.null_count);
+    } else if constexpr (
+        std::is_same_v<TOutput, int64_t> &&
+        (std::is_same_v<TInput, int32_t> || std::is_same_v<TInput, int64_t>)) {
+      // TIME: Arrow time32 (int32) or time64 (int64) to Velox TIME (int64
+      // millis) Check if format starts with "tt" to distinguish from regular
+      // int32/int64.
+      if (format[0] == 't' && format[1] == 't') {
+        assertTimeVectorContent(
+            inputValues, output, arrowArray.null_count, format);
+      } else {
+        assertVectorContent(inputValues, output, arrowArray.null_count);
+      }
     } else {
       assertVectorContent(inputValues, output, arrowArray.null_count);
     }
@@ -1268,6 +1358,29 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
           tsString, {0, std::nullopt, Timestamp::kMaxSeconds});
     }
 
+    testArrowImport<int64_t, int32_t>(
+        "tts", {0, std::nullopt, 1, 60, 3600, 50402, 86399});
+    testArrowImport<int64_t, int32_t>(
+        "ttm", {0, std::nullopt, 1000, 60000, 3600000, 50402000, 86399999});
+    testArrowImport<int64_t, int64_t>(
+        "ttu",
+        {0,
+         std::nullopt,
+         1'000'000,
+         60'000'000,
+         3'600'000'000,
+         50'402'000'000,
+         86'399'999'000});
+    testArrowImport<int64_t, int64_t>(
+        "ttn",
+        {0,
+         std::nullopt,
+         1'000'000'000,
+         60'000'000'000,
+         3'600'000'000'000,
+         50'402'000'000'000,
+         86'399'999'000'000});
+
     testArrowImport<int64_t, int128_t>(
         "d:5,2", {1, -1, 0, 12345, -12345, std::nullopt});
     testArrowImport<int128_t, int128_t>(
@@ -1304,6 +1417,17 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
         std::is_same_v<TInput, int64_t> && std::is_same_v<TOutput, Timestamp>) {
       assertTimestampVectorContent(
           inputValues, output, arrowArray1.null_count, format);
+    } else if constexpr (
+        std::is_same_v<TOutput, int64_t> &&
+        (std::is_same_v<TInput, int32_t> || std::is_same_v<TInput, int64_t>)) {
+      // TIME: Arrow time32 (int32) or time64 (int64) to Velox TIME (int64
+      // millis).
+      if (format[0] == 't' && format[1] == 't') {
+        assertTimeVectorContent(
+            inputValues, output, arrowArray1.null_count, format);
+      } else {
+        assertVectorContent(inputValues, output, arrowArray1.null_count);
+      }
     } else {
       assertVectorContent(inputValues, output, arrowArray1.null_count);
     }
@@ -1357,6 +1481,37 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
         });
   }
 
+  void testImportString64() {
+    testArrowImport<std::string>("U", {});
+    testArrowImport<std::string>("U", {"single"});
+    testArrowImport<std::string>(
+        "U",
+        {
+            "hello world",
+            "larger string which should not be inlined...",
+            std::nullopt,
+            "hello",
+            "from",
+            "the",
+            "other",
+            "side",
+            std::nullopt,
+            std::nullopt,
+        });
+
+    testArrowImport<std::string>(
+        "Z",
+        {
+            std::nullopt,
+            "testing",
+            "a",
+            std::nullopt,
+            "varbinary",
+            "vector",
+            std::nullopt,
+        });
+  }
+
  private:
   // Creates short decimals from int128 and asserts the content of actual vector
   // with the expected values.
@@ -1376,6 +1531,47 @@ class ArrowBridgeArrayImportTest : public ArrowBridgeArrayExportTest {
     assertVectorContent(decValues, actual, nullCount);
   }
 
+  // Creates TIME from int32/int64 and asserts the content of actual vector with
+  // the expected TIME values (in milliseconds).
+  template <typename TInput>
+  void assertTimeVectorContent(
+      const std::vector<std::optional<TInput>>& 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<int64_t>> timeValues;
+    timeValues.reserve(expectedValues.size());
+    for (const auto& value : expectedValues) {
+      if (!value.has_value()) {
+        timeValues.emplace_back(std::nullopt);
+      } else {
+        int64_t millis;
+        // Convert from Arrow time unit to Velox TIME (milliseconds).
+        switch (format[2]) {
+          case 's':
+            millis = static_cast<int64_t>(value.value()) * 1'000;
+            break;
+          case 'm':
+            millis = static_cast<int64_t>(value.value());
+            break;
+          case 'u':
+            millis = static_cast<int64_t>(value.value()) / 1'000;
+            break;
+          case 'n':
+            millis = static_cast<int64_t>(value.value()) / 1'000'000;
+            break;
+          default:
+            VELOX_UNREACHABLE();
+        }
+        timeValues.emplace_back(millis);
+      }
+    }
+    auto expected = vectorMaker_.flatVectorNullable(timeValues, TIME());
+    assertVectorContent(timeValues, actual, nullCount);
+  }
+
   // Creates timestamp from bigint and asserts the content of actual vector with
   // the expected timestamp values.
   void assertTimestampVectorContent(
@@ -1837,6 +2033,10 @@ TEST_F(ArrowBridgeArrayImportAsViewerTest, string) {
   testImportString();
 }
 
+TEST_F(ArrowBridgeArrayImportAsViewerTest, string64) {
+  testImportString64();
+}
+
 TEST_F(ArrowBridgeArrayImportAsViewerTest, stringview) {
   testImportStringView();
 }
@@ -1894,6 +2094,10 @@ TEST_F(ArrowBridgeArrayImportAsOwnerTest, string) {
   testImportString();
 }
 
+TEST_F(ArrowBridgeArrayImportAsOwnerTest, string64) {
+  testImportString64();
+}
+
 TEST_F(ArrowBridgeArrayImportAsOwnerTest, stringview) {
   testImportStringView();
 }
@@ -1962,7 +2166,9 @@ TEST_F(ArrowBridgeArrayImportAsOwnerTest, releaseCalled) {
 
   // Create a Velox Vector from Arrow and then destruct it to trigger the
   // release callback calling
-  { auto _ = importFromArrowAsOwner(arrowSchema, arrowArray, pool_.get()); }
+  {
+    auto _ = importFromArrowAsOwner(arrowSchema, arrowArray, pool_.get());
+  }
 
   EXPECT_TRUE(TestReleaseCalled::schemaReleaseCalled);
   EXPECT_TRUE(TestReleaseCalled::arrayReleaseCalled);
diff --git a/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp b/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
index 1b37010b8298..2369504081cd 100644
--- a/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
+++ b/velox/vector/arrow/tests/ArrowBridgeSchemaTest.cpp
@@ -487,8 +487,6 @@ TEST_F(ArrowBridgeSchemaImportTest, unsupported) {
   EXPECT_THROW(testSchemaImport("w:42"), VeloxUserError);
 
   EXPECT_THROW(testSchemaImport("tdm"), VeloxUserError);
-  EXPECT_THROW(testSchemaImport("tts"), VeloxUserError);
-  EXPECT_THROW(testSchemaImport("ttm"), VeloxUserError);
   EXPECT_THROW(testSchemaImport("tDs"), VeloxUserError);
 
   EXPECT_THROW(testSchemaImport("+"), VeloxUserError);
diff --git a/velox/vector/arrow/tests/CMakeLists.txt b/velox/vector/arrow/tests/CMakeLists.txt
index c4a396812afe..99cd601dc23e 100644
--- a/velox/vector/arrow/tests/CMakeLists.txt
+++ b/velox/vector/arrow/tests/CMakeLists.txt
@@ -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.
-add_executable(velox_arrow_bridge_test ArrowBridgeArrayTest.cpp
-                                       ArrowBridgeSchemaTest.cpp)
+add_executable(velox_arrow_bridge_test ArrowBridgeArrayTest.cpp ArrowBridgeSchemaTest.cpp)
 
 add_test(velox_arrow_bridge_test velox_arrow_bridge_test)
 
@@ -25,4 +24,5 @@ target_link_libraries(
   GTest::gtest
   GTest::gtest_main
   glog::glog
-  dl)
+  dl
+)
diff --git a/velox/vector/benchmarks/CMakeLists.txt b/velox/vector/benchmarks/CMakeLists.txt
index 275864423e84..0cb3c78bfd88 100644
--- a/velox/vector/benchmarks/CMakeLists.txt
+++ b/velox/vector/benchmarks/CMakeLists.txt
@@ -18,22 +18,23 @@ target_link_libraries(
   velox_vector
   Folly::folly
   Folly::follybenchmark
-  fmt::fmt)
+  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::gtest)
+target_link_libraries(velox_vector_hash_all_benchmark GTest::gtest)
 
-add_executable(velox_vector_selectivity_vector_benchmark
-               SelectivityVectorBenchmark.cpp)
+add_executable(velox_vector_selectivity_vector_benchmark SelectivityVectorBenchmark.cpp)
 
 target_link_libraries(
-  velox_vector_selectivity_vector_benchmark velox_vector Folly::folly
-  Folly::follybenchmark)
+  velox_vector_selectivity_vector_benchmark
+  velox_vector
+  Folly::folly
+  Folly::follybenchmark
+)
 
 add_executable(copy_benchmark CopyBenchmark.cpp)
 
-target_link_libraries(
-  copy_benchmark velox_vector_test_lib Folly::folly Folly::follybenchmark)
+target_link_libraries(copy_benchmark velox_vector_test_lib Folly::folly Folly::follybenchmark)
 
 add_executable(velox_vector_map_update_benchmark MapUpdateBenchmark.cpp)
 target_link_libraries(
@@ -42,4 +43,5 @@ target_link_libraries(
   Folly::folly
   Folly::follybenchmark
   gflags::gflags
-  glog::glog)
+  glog::glog
+)
diff --git a/velox/vector/fuzzer/CMakeLists.txt b/velox/vector/fuzzer/CMakeLists.txt
index c73571041bad..4fd8c4afcab7 100644
--- a/velox/vector/fuzzer/CMakeLists.txt
+++ b/velox/vector/fuzzer/CMakeLists.txt
@@ -14,8 +14,7 @@
 
 add_library(velox_vector_fuzzer_util Utils.cpp)
 
-target_link_libraries(
-  velox_vector_fuzzer_util velox_vector velox_common_fuzzer_util)
+target_link_libraries(velox_vector_fuzzer_util velox_vector velox_common_fuzzer_util)
 
 add_library(velox_vector_fuzzer GeneratorSpec.cpp VectorFuzzer.cpp)
 
@@ -26,11 +25,11 @@ target_link_libraries(
   velox_vector_fuzzer_util
   velox_common_fuzzer_util
   velox_presto_types
-  velox_constrained_vector_generator)
+  velox_constrained_vector_generator
+)
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  target_compile_options(velox_vector_fuzzer
-                         PRIVATE -Wno-deprecated-declarations)
+  target_compile_options(velox_vector_fuzzer PRIVATE -Wno-deprecated-declarations)
 endif()
 
 add_library(velox_constrained_vector_generator ConstrainedVectorGenerator.cpp)
@@ -40,7 +39,8 @@ target_link_libraries(
   velox_vector
   velox_expression
   velox_constrained_input_generators
-  velox_vector_fuzzer_util)
+  velox_vector_fuzzer_util
+)
 
 if(${VELOX_BUILD_TESTING})
   add_subdirectory(tests)
diff --git a/velox/vector/fuzzer/VectorFuzzer.cpp b/velox/vector/fuzzer/VectorFuzzer.cpp
index c2b386f0a6fd..943991142e79 100644
--- a/velox/vector/fuzzer/VectorFuzzer.cpp
+++ b/velox/vector/fuzzer/VectorFuzzer.cpp
@@ -27,6 +27,7 @@
 #include "velox/type/Timestamp.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/FlatVector.h"
+#include "velox/vector/LazyVector.h"
 #include "velox/vector/NullsBuilder.h"
 #include "velox/vector/VectorTypeUtils.h"
 #include "velox/vector/fuzzer/ConstrainedVectorGenerator.h"
@@ -162,7 +163,14 @@ void fuzzFlatPrimitiveImpl(
     } else if constexpr (std::is_same_v<TCpp, Timestamp>) {
       flatVector->set(i, randTimestamp(rng, opts.timestampPrecision));
     } else if constexpr (std::is_same_v<TCpp, int64_t>) {
-      if (vector->type()->isShortDecimal()) {
+      if (vector->type()->isIntervalDayTime()) {
+        flatVector->set(
+            i,
+            rand<TCpp>(
+                rng,
+                -VectorFuzzer::kMaxAllowedIntervalDayTime,
+                VectorFuzzer::kMaxAllowedIntervalDayTime));
+      } else if (vector->type()->isShortDecimal()) {
         flatVector->set(i, randShortDecimal(vector->type(), rng));
       } else {
         flatVector->set(i, rand<TCpp>(rng, opts.dataSpec));
@@ -176,7 +184,14 @@ void fuzzFlatPrimitiveImpl(
         VELOX_NYI();
       }
     } else if constexpr (std::is_same_v<TCpp, int32_t>) {
-      if (vector->type()->isDate()) {
+      if (vector->type()->isIntervalYearMonth()) {
+        flatVector->set(
+            i,
+            rand<TCpp>(
+                rng,
+                -VectorFuzzer::kMaxAllowedIntervalYearMonth,
+                VectorFuzzer::kMaxAllowedIntervalYearMonth));
+      } else if (vector->type()->isDate()) {
         flatVector->set(i, randDate(rng));
       } else {
         flatVector->set(i, rand<TCpp>(rng));
@@ -230,14 +245,45 @@ bool hasNestedDictionaryLayers(const VectorPtr& baseVector) {
 AbstractInputGeneratorPtr maybeGetCustomTypeInputGenerator(
     const TypePtr& type,
     const double nullRatio,
-    FuzzerGenerator& rng) {
+    FuzzerGenerator& rng,
+    memory::MemoryPool* pool) {
   if (customTypeExists(type->name())) {
-    InputGeneratorConfig config{rand<uint32_t>(rng), nullRatio};
+    InputGeneratorConfig config{rand<uint32_t>(rng), nullRatio, pool, type};
     return getCustomTypeInputGenerator(type->name(), config);
   }
 
   return nullptr;
 }
+
+template <TypeKind kind>
+VectorPtr extractDistinctKeys(VectorPtr allKeys, memory::MemoryPool* pool) {
+  using TCpp = typename TypeTraits<kind>::NativeType;
+
+  std::vector<TCpp> distinctKeys;
+  std::unordered_set<TCpp> keySet;
+  auto flatKeys = allKeys->asFlatVector<TCpp>();
+  auto result = BaseVector::create<FlatVector<TCpp>>(
+      allKeys->type(), allKeys->size(), pool);
+
+  auto index = 0;
+  for (int i = 0; i < flatKeys->size(); ++i) {
+    auto key = flatKeys->valueAt(i);
+    if (keySet.find(key) == keySet.end()) {
+      keySet.insert(key);
+      distinctKeys.push_back(key);
+      result->set(index++, key);
+    }
+  }
+
+  result->resize(index);
+  if (allKeys->getDistinctValueCount().has_value())
+    VELOX_CHECK_EQ(
+        result->size(),
+        allKeys->getDistinctValueCount().value(),
+        "extracted distinct keys size should match input distinct value count");
+  return result;
+}
+
 } // namespace
 
 VectorPtr VectorFuzzer::fuzzNotNull(
@@ -269,7 +315,7 @@ VectorPtr VectorFuzzer::fuzz(
   vector_size_t vectorSize = size;
   const auto inputGenerator = customGenerator
       ? customGenerator
-      : maybeGetCustomTypeInputGenerator(type, opts_.nullRatio, rng_);
+      : maybeGetCustomTypeInputGenerator(type, opts_.nullRatio, rng_, pool_);
 
   bool usingLazyVector = opts_.allowLazyVector && coinToss(0.1);
   // Lazy Vectors cannot be sliced, so we skip this if using lazy wrapping.
@@ -332,7 +378,7 @@ VectorPtr VectorFuzzer::fuzzConstant(
     const AbstractInputGeneratorPtr& customGenerator) {
   const auto inputGenerator = customGenerator
       ? customGenerator
-      : maybeGetCustomTypeInputGenerator(type, opts_.nullRatio, rng_);
+      : maybeGetCustomTypeInputGenerator(type, opts_.nullRatio, rng_, pool_);
 
   // For constants, there are two possible cases:
   // - generate a regular constant vector (only for primitive types).
@@ -345,11 +391,6 @@ VectorPtr VectorFuzzer::fuzzConstant(
     if (type->isUnKnown()) {
       return BaseVector::createNullConstant(type, size, pool_);
     } else {
-      auto inputGenerator = customGenerator;
-      if (!inputGenerator && customTypeExists(type->name())) {
-        InputGeneratorConfig config{rand<uint32_t>(rng_), opts_.nullRatio};
-        inputGenerator = getCustomTypeInputGenerator(type->name(), config);
-      }
       return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
           fuzzConstantPrimitiveImpl,
           type->kind(),
@@ -406,11 +447,9 @@ VectorPtr VectorFuzzer::fuzzFlat(
     const TypePtr& type,
     vector_size_t size,
     const AbstractInputGeneratorPtr& customGenerator) {
-  auto inputGenerator = customGenerator;
-  if (!inputGenerator && customTypeExists(type->name())) {
-    InputGeneratorConfig config{rand<uint32_t>(rng_), opts_.nullRatio};
-    inputGenerator = getCustomTypeInputGenerator(type->name(), config);
-  }
+  const auto inputGenerator = customGenerator
+      ? customGenerator
+      : maybeGetCustomTypeInputGenerator(type, opts_.nullRatio, rng_, pool_);
   if (inputGenerator) {
     return fuzzer::ConstrainedVectorGenerator::generateFlat(
         inputGenerator, size, pool_);
@@ -457,6 +496,17 @@ VectorPtr VectorFuzzer::fuzzFlat(
   }
 }
 
+VectorPtr VectorFuzzer::fuzzUniqueFlatNotNull(
+    const TypePtr& type,
+    vector_size_t size) {
+  // Generate a random vector of non-null keys.
+  auto allKeys = fuzzFlatNotNull(type, getElementsVectorLength(opts_, size));
+
+  // Extract and return the distinct keys.
+  return VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH(
+      extractDistinctKeys, type->kind(), allKeys, pool_);
+}
+
 VectorPtr VectorFuzzer::fuzzMap(
     const TypePtr& keyType,
     const TypePtr& valueType,
@@ -487,11 +537,10 @@ VectorPtr VectorFuzzer::fuzzFlatPrimitive(
     VELOX_DYNAMIC_SCALAR_TYPE_DISPATCH_ALL(
         fuzzFlatPrimitiveImpl, kind, vector, rng_, opts_);
 
-    // Second, generate a random null vector.
-    for (size_t i = 0; i < vector->size(); ++i) {
-      if (coinToss(opts_.nullRatio)) {
-        vector->setNull(i, true);
-      }
+    // Second, generate nulls using the configured null pattern.
+    auto nulls = fuzzNulls(size);
+    if (nulls) {
+      vector->setNulls(nulls);
     }
   }
   return vector;
@@ -522,19 +571,24 @@ VectorPtr VectorFuzzer::fuzzComplex(const TypePtr& type, vector_size_t 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.
-      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);
+      if (opts_.allowFlatMapVector && coinToss(opts_.flatMapRatio)) {
+        return fuzzFlatMap(
+            type->asMap().keyType(), type->asMap().valueType(), size);
+      } else {
+        // 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.
+        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);
+      }
     }
 
     default:
@@ -619,6 +673,17 @@ void VectorFuzzer::fuzzOffsetsAndSizes(
   }
 }
 
+ArrayVectorPtr VectorFuzzer::fuzzArray(
+    const TypePtr& elementType,
+    vector_size_t size) {
+  const auto length = getElementsVectorLength(opts_, size);
+
+  auto elements = opts_.containerHasNulls
+      ? fuzzFlat(elementType, length)
+      : fuzzFlatNotNull(elementType, length);
+  return fuzzArray(elements, size);
+}
+
 ArrayVectorPtr VectorFuzzer::fuzzArray(
     const VectorPtr& elements,
     vector_size_t size) {
@@ -693,6 +758,32 @@ MapVectorPtr VectorFuzzer::fuzzMap(
       values);
 }
 
+FlatMapVectorPtr VectorFuzzer::fuzzFlatMap(
+    const TypePtr& keyType,
+    const TypePtr& valueType,
+    vector_size_t size) {
+  // All keys present in the entirety of the FlatMap column.
+  VectorPtr distinctKeys =
+      fuzzUniqueFlatNotNull(keyType, opts_.containerLength);
+
+  // inMaps buffer and mapValues vector should be the same size.
+  std::vector<VectorPtr> mapValues(distinctKeys->size());
+  std::vector<BufferPtr> inMaps(distinctKeys->size());
+  for (int i = 0; i < mapValues.size(); ++i) {
+    mapValues[i] = fuzz(valueType, size);
+    inMaps[i] = fuzzFlatMapInMap(size);
+  }
+
+  return std::make_shared<FlatMapVector>(
+      pool_,
+      MAP(keyType, valueType),
+      fuzzNulls(size),
+      size,
+      distinctKeys,
+      mapValues,
+      inMaps);
+}
+
 RowVectorPtr VectorFuzzer::fuzzInputRow(
     const RowTypePtr& rowType,
     const std::vector<AbstractInputGeneratorPtr>& inputGenerators) {
@@ -778,11 +869,71 @@ RowVectorPtr VectorFuzzer::fuzzRow(
 
 BufferPtr VectorFuzzer::fuzzNulls(vector_size_t size) {
   NullsBuilder builder{size, pool_};
-  for (size_t i = 0; i < size; ++i) {
-    if (coinToss(opts_.nullRatio)) {
-      builder.setNull(i);
+
+  // Randomly select a pattern with weighted distribution:
+  // 70% kRandom, 30% split equally among kHeadOnly, kTailOnly, kHeadAndTail
+  // (each gets 10%)
+
+  // default to kRandom pattern
+  int patternChoice = 0;
+
+  if (opts_.useRandomNullPattern) {
+    auto randValue = fuzzer::rand<uint32_t>(rng_) % 100;
+    if (randValue < 70) {
+      patternChoice = 0; // kRandom - 70%
+    } else if (randValue < 80) {
+      patternChoice = 1; // kHeadOnly - 10%
+    } else if (randValue < 90) {
+      patternChoice = 2; // kTailOnly - 10%
+    } else {
+      patternChoice = 3; // kHeadAndTail - 10%
     }
   }
+
+  switch (patternChoice) {
+    case 0: // kRandom pattern
+      for (size_t i = 0; i < size; ++i) {
+        if (coinToss(opts_.nullRatio)) {
+          builder.setNull(i);
+        }
+      }
+      break;
+
+    case 1: { // kHeadOnly pattern
+      auto headNulls =
+          std::min<size_t>(static_cast<size_t>(size * opts_.nullRatio), size);
+      for (size_t i = 0; i < headNulls; ++i) {
+        builder.setNull(i);
+      }
+      break;
+    }
+
+    case 2: { // kTailOnly pattern
+      auto tailNulls =
+          std::min<size_t>(static_cast<size_t>(size * opts_.nullRatio), size);
+      auto startIdx = size > tailNulls ? size - tailNulls : 0;
+      for (size_t i = startIdx; i < size; ++i) {
+        builder.setNull(i);
+      }
+      break;
+    }
+
+    case 3: { // kHeadAndTail pattern
+      // Split nullRatio between head and tail to match total nulls of other
+      // patterns
+      auto edgeNulls = std::min<size_t>(
+          static_cast<size_t>(size * opts_.nullRatio / 2.0), size / 2);
+      for (size_t i = 0; i < edgeNulls; ++i) {
+        builder.setNull(i);
+      }
+      auto tailStart = size > edgeNulls ? size - edgeNulls : 0;
+      for (size_t i = tailStart; i < size; ++i) {
+        builder.setNull(i);
+      }
+      break;
+    }
+  }
+
   return builder.build();
 }
 
@@ -799,6 +950,26 @@ BufferPtr VectorFuzzer::fuzzIndices(
   return indices;
 }
 
+BufferPtr VectorFuzzer::fuzzFlatMapInMap(vector_size_t size) {
+  VELOX_CHECK_GE(size, 0);
+
+  // When inMap buffer is null, key is present in all rows.
+  if (size == 0 || coinToss(opts_.inMapNullRatio)) {
+    return nullptr;
+  }
+
+  auto inMap = AlignedBuffer::allocate<bool>(size, pool_, 0);
+  auto* mutableInMap = inMap->asMutable<uint64_t>();
+
+  for (auto row = 0; row < size; ++row) {
+    if (coinToss(opts_.inMapRatio)) {
+      bits::setBit(mutableInMap, row);
+    }
+  }
+
+  return inMap;
+}
+
 std::pair<int8_t, int8_t> VectorFuzzer::randPrecisionScale(
     int8_t maxPrecision) {
   // Generate precision in range [1, Decimal type max precision]
diff --git a/velox/vector/fuzzer/VectorFuzzer.h b/velox/vector/fuzzer/VectorFuzzer.h
index 8af5f73dfeb2..c1557fe00174 100644
--- a/velox/vector/fuzzer/VectorFuzzer.h
+++ b/velox/vector/fuzzer/VectorFuzzer.h
@@ -21,6 +21,7 @@
 #include "velox/type/Type.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/ComplexVector.h"
+#include "velox/vector/FlatMapVector.h"
 #include "velox/vector/fuzzer/GeneratorSpec.h"
 #include "velox/vector/fuzzer/Utils.h"
 
@@ -78,10 +79,22 @@ class VectorFuzzer {
   struct Options {
     size_t vectorSize{100};
 
-    /// Chance of generating a null value in the output vector (`nullRatio` is a
-    /// double between 0 and 1).
+    /// Controls NULL generation in vectors. This is a probability (0.0-1.0)
+    /// or fraction used by NULL patterns:
+    /// - When useRandomNullPattern=false (default): Uses kRandom pattern only
+    ///   - nullRatio is the probability that each element is NULL
+    /// - When useRandomNullPattern=true: Randomly selects pattern, then:
+    ///   - Random (70%): Probability that each element is NULL
+    ///   - HeadOnly (10%): Fraction of vector that's NULL at beginning
+    ///   - TailOnly (10%): Fraction of vector that's NULL at end
+    ///   - HeadAndTail (10%): Half the fraction at head, half at tail
     double nullRatio{0};
 
+    /// If true, randomly selects NULL patterns (kRandom 70%, kHeadOnly 10%,
+    /// kTailOnly 10%, kHeadAndTail 10%). If false, uses only kRandom pattern.
+    /// Default is false to preserve backward compatibility.
+    bool useRandomNullPattern{false};
+
     /// If false, fuzzer will not generate nulls for elements within containers
     /// (arrays/maps/rows). It might still generate null for the container
     /// itself.
@@ -143,6 +156,22 @@ class VectorFuzzer {
 
     /// Data spec for randomly generated data.
     fuzzer::DataSpec dataSpec{false, false};
+
+    /// FlatMap options:
+    ///
+    /// Toggle for functions that support flat map vector encodings.
+    bool allowFlatMapVector{false};
+
+    /// Flat map vs regular map generation ratio.
+    double flatMapRatio{.5};
+
+    /// Probability of a particular inMap BufferPtr bit being set, signifying
+    /// whether or not the corresponding key is present in that row's map.
+    double inMapRatio{.25};
+
+    /// Probability of a inMap buffer being null (suggesting key is present in
+    /// all rows).
+    double inMapNullRatio{.1};
   };
 
   // Suppress spurious warnings in GCC 12.4 and later
@@ -154,15 +183,13 @@ class VectorFuzzer {
       const VectorFuzzer::Options& options,
       memory::MemoryPool* pool,
       size_t seed = 123456)
-      : opts_(options),
-        pool_(pool),
-        rng_(seed){}
+      : opts_(options), pool_(pool), rng_(seed) {}
 #if defined(__GNUC__) && \
     ((__GNUC__ > 12) || (__GNUC__ == 12 && __GNUC_MINOR__ >= 4))
-        VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
+  VELOX_UNSUPPRESS_STRINGOP_OVERFLOW_WARNING
 #endif
 
-        void setOptions(const VectorFuzzer::Options& options) {
+  void setOptions(const VectorFuzzer::Options& options) {
     opts_ = options;
   }
 
@@ -215,6 +242,9 @@ class VectorFuzzer {
   VectorPtr fuzzFlatNotNull(const TypePtr& type);
   VectorPtr fuzzFlatNotNull(const TypePtr& type, vector_size_t size);
 
+  /// Generate a distinct vector of non-null values of type type.
+  VectorPtr fuzzUniqueFlatNotNull(const TypePtr& type, vector_size_t size);
+
   /// Returns a map vector with randomized values and nulls. Returns a vector
   /// containing `opts_.vectorSize` or `size` elements.
   VectorPtr
@@ -244,6 +274,11 @@ class VectorFuzzer {
   /// `opts.containerVariableLength`).
   ArrayVectorPtr fuzzArray(const VectorPtr& elements, vector_size_t size);
 
+  /// Same as above, but fuzz the element vector. The length of the element
+  /// vector is based on opts.containerLength and does not exceed
+  /// opts.complexElementsMaxSize.
+  ArrayVectorPtr fuzzArray(const TypePtr& elementType, vector_size_t size);
+
   /// Uses `keys` and `values` as the internal elements vectors, wrapping them
   /// into a MapVector of `size` rows.
   ///
@@ -257,6 +292,18 @@ class VectorFuzzer {
   MapVectorPtr
   fuzzMap(const VectorPtr& keys, const VectorPtr& values, vector_size_t size);
 
+  /// Generates a fuzzed flat map vector using the given key and value types.
+  ///
+  /// This function will fuzz keys values and use them to generate the distinct
+  /// keys for the flat map. Subsequent inMaps and mapValues buffers and vectors
+  /// (respectively) are generated per channel. The result is a flatMapVectorPtr
+  /// generated from the ground up. This can be used with
+  /// FlatMapVector::toMapVector for encoding testing.
+  FlatMapVectorPtr fuzzFlatMap(
+      const TypePtr& keyType,
+      const TypePtr& valueType,
+      vector_size_t size);
+
   /// Returns a "fuzzed" row vector with randomized data and nulls.
   RowVectorPtr fuzzRow(const RowTypePtr& rowType);
 
@@ -377,12 +424,20 @@ class VectorFuzzer {
   /// pointing to (baseVectorSize-1).
   BufferPtr fuzzIndices(vector_size_t size, vector_size_t baseVectorSize);
 
+  /// Generate a random inMap buffer (for use with flat map vectors) of 'size'
+  /// number of rows. This should randomize the keys per row in the map.
+  BufferPtr fuzzFlatMapInMap(vector_size_t size);
+
   template <typename Class>
   void registerOpaqueTypeGenerator(
       std::function<std::shared_ptr<Class>(FuzzerGenerator& rng)> generator) {
     opaqueTypeGenerators_[std::type_index(typeid(Class))] = generator;
   }
 
+  // Maximum values allowed values by Presto for interval types.
+  static const int64_t kMaxAllowedIntervalDayTime = 2147483647;
+  static const int32_t kMaxAllowedIntervalYearMonth = 178956970;
+
  private:
   // Generates a flat vector for primitive types.
   VectorPtr fuzzFlatPrimitive(const TypePtr& type, vector_size_t size);
diff --git a/velox/vector/fuzzer/tests/CMakeLists.txt b/velox/vector/fuzzer/tests/CMakeLists.txt
index 869736af92e5..11f1d381538d 100644
--- a/velox/vector/fuzzer/tests/CMakeLists.txt
+++ b/velox/vector/fuzzer/tests/CMakeLists.txt
@@ -23,15 +23,16 @@ target_link_libraries(
   velox_memory
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
 
-add_executable(velox_constrained_vector_generator_test
-               ConstrainedVectorGeneratorTest.cpp)
+add_executable(velox_constrained_vector_generator_test ConstrainedVectorGeneratorTest.cpp)
 
 add_test(
   NAME velox_constrained_vector_generator_test
   COMMAND velox_constrained_vector_generator_test
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
 
 target_link_libraries(
   velox_constrained_vector_generator_test
@@ -39,4 +40,5 @@ target_link_libraries(
   velox_vector_test_lib
   GTest::gtest
   GTest::gtest_main
-  GTest::gmock)
+  GTest::gmock
+)
diff --git a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
index a77518d1eee3..15d66c59a965 100644
--- a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
+++ b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
@@ -22,6 +22,8 @@
 #include "velox/common/memory/Memory.h"
 #include "velox/functions/prestosql/types/JsonRegistration.h"
 #include "velox/functions/prestosql/types/JsonType.h"
+#include "velox/functions/prestosql/types/QDigestRegistration.h"
+#include "velox/functions/prestosql/types/QDigestType.h"
 #include "velox/type/TypeEncodingUtil.h"
 #include "velox/vector/DictionaryVector.h"
 #include "velox/vector/fuzzer/VectorFuzzer.h"
@@ -39,6 +41,7 @@ class VectorFuzzerTest : public testing::Test {
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
     registerJsonType();
+    registerQDigestType();
   }
 
   memory::MemoryPool* pool() const {
@@ -414,6 +417,24 @@ TEST_F(VectorFuzzerTest, array) {
   ASSERT_EQ(arraySize, vector->size());
   ASSERT_GE(
       100, vector->offsetAt(arraySize - 1) + vector->sizeAt(arraySize - 1));
+
+  // Test fuzzArray with given element type. Check that element size doesn't
+  // exceed opts.complexElementsMaxSize.
+  const auto kElementMaxSize = 100;
+  opts.complexElementsMaxSize = kElementMaxSize;
+  fuzzer.setOptions(opts);
+
+  auto checkElementSize = [&](size_t arraySize) {
+    vector = fuzzer.fuzzArray(BIGINT(), arraySize);
+    ASSERT_TRUE(vector->type()->childAt(0)->isBigint());
+    ASSERT_EQ(arraySize, vector->size());
+    ASSERT_LE(
+        vector->offsetAt(arraySize - 1) + vector->sizeAt(arraySize - 1),
+        kElementMaxSize);
+  };
+  checkElementSize(kElementMaxSize);
+  checkElementSize(kElementMaxSize - 70);
+  checkElementSize(kElementMaxSize + 50);
 }
 
 TEST_F(VectorFuzzerTest, map) {
@@ -975,14 +996,14 @@ TEST_F(VectorFuzzerTest, randTypeByWidth) {
       {INTEGER(), ARRAY(BIGINT()), MAP(VARCHAR(), DOUBLE()), ROW({TINYINT()})});
   ASSERT_EQ(approximateTypeEncodingwidth(type), 7);
 
-  // Test randType by width. Results should be at least a RowType with one
-  // field, so the minimal type width is 2.
+  // Test randType by width. Results should has at least one field, so the
+  // minimal type width is 1.
   type = fuzzer.randRowTypeByWidth(-1);
-  ASSERT_GE(approximateTypeEncodingwidth(type), 2);
+  ASSERT_GE(approximateTypeEncodingwidth(type), 1);
   type = fuzzer.randRowTypeByWidth(0);
-  ASSERT_GE(approximateTypeEncodingwidth(type), 2);
+  ASSERT_GE(approximateTypeEncodingwidth(type), 1);
   type = fuzzer.randRowTypeByWidth(1);
-  ASSERT_GE(approximateTypeEncodingwidth(type), 2);
+  ASSERT_GE(approximateTypeEncodingwidth(type), 1);
 
   folly::Random::DefaultGenerator rng;
   rng.seed(0);
@@ -1015,9 +1036,9 @@ TEST_F(VectorFuzzerTest, customTypeGenerator) {
       if (decoded.isNullAt(j)) {
         continue;
       }
-      std::string value = decoded.valueAt<StringView>(j);
       try {
-        json = folly::parseJson(value, opts);
+        auto stringView = decoded.valueAt<StringView>(j);
+        json = folly::parseJson(std::string_view(stringView), opts);
       } catch (...) {
         EXPECT_TRUE(false);
       }
@@ -1057,9 +1078,10 @@ TEST_F(VectorFuzzerTest, jsonConstrained) {
       if (decoded.isNullAt(j)) {
         continue;
       }
-      std::string value = decoded.valueAt<StringView>(j);
       folly::dynamic json;
-      EXPECT_NO_THROW(json = folly::parseJson(value, jsonOpts));
+      auto stringView = decoded.valueAt<StringView>(j);
+      EXPECT_NO_THROW(
+          json = folly::parseJson(std::string_view(stringView), jsonOpts));
       EXPECT_TRUE(json.isNull() || json.isArray());
     }
   }
@@ -1077,8 +1099,105 @@ TEST_F(VectorFuzzerTest, setConstrained) {
 
   DecodedVector decoded(*vector, SelectivityVector(kSize));
   for (auto i = 0; i < kSize; ++i) {
-    std::string value = decoded.valueAt<StringView>(i);
+    auto value = decoded.valueAt<StringView>(i);
     EXPECT_TRUE(value == "a" || value == "b");
   }
 }
+
+TEST_F(VectorFuzzerTest, qdigestTypeGeneration) {
+  VectorFuzzer::Options opts;
+  opts.nullRatio = 0.2;
+  opts.vectorSize = 10;
+  VectorFuzzer fuzzer(opts, pool());
+
+  const auto qdigestRealType = QDIGEST(REAL());
+  const auto qdigestDoulbeType = QDIGEST(DOUBLE());
+  const auto qdigestBigIntType = QDIGEST(BIGINT());
+
+  // Test QDigest with BIGINT parameter
+  {
+    auto vector = fuzzer.fuzz(QDIGEST(BIGINT()));
+    ASSERT_NE(vector, nullptr);
+    EXPECT_TRUE(vector->type()->equivalent(*qdigestBigIntType));
+    EXPECT_EQ(vector->size(), opts.vectorSize);
+  }
+
+  // Test QDigest with REAL parameter
+  {
+    auto vector = fuzzer.fuzz(QDIGEST(REAL()));
+    ASSERT_NE(vector, nullptr);
+    EXPECT_TRUE(vector->type()->equivalent(*qdigestRealType));
+    EXPECT_EQ(vector->size(), opts.vectorSize);
+  }
+
+  // Test QDigest with DOUBLE parameter
+  {
+    auto vector = fuzzer.fuzz(QDIGEST(BIGINT()));
+    ASSERT_NE(vector, nullptr);
+    EXPECT_TRUE(vector->type()->equivalent(*qdigestBigIntType));
+    EXPECT_EQ(vector->size(), opts.vectorSize);
+  }
+}
+
+TEST_F(VectorFuzzerTest, nullRatioPatternVariety) {
+  // Test that we get variety in NULL patterns when feature is enabled
+  VectorFuzzer::Options opts;
+  opts.vectorSize = 100;
+  opts.nullRatio = 0.2;
+  opts.useRandomNullPattern = true; // Enable random NULL pattern selection
+
+  VectorFuzzer fuzzer(opts, pool());
+
+  // Track different null patterns we see
+  bool seenAllAtStart = false;
+  bool seenAllAtEnd = false;
+  bool seenScattered = false;
+
+  for (size_t iter = 0; iter < 200; ++iter) {
+    auto vector = fuzzer.fuzzFlat(INTEGER());
+    ASSERT_EQ(vector->size(), 100);
+
+    size_t nullCount = 0;
+    size_t firstNull = 0;
+    size_t lastNull = 0;
+    bool foundFirst = false;
+
+    for (size_t i = 0; i < vector->size(); ++i) {
+      if (vector->isNullAt(i)) {
+        nullCount++;
+        if (!foundFirst) {
+          firstNull = i;
+          foundFirst = true;
+        }
+        lastNull = i;
+      }
+    }
+
+    if (nullCount == 0) {
+      continue; // Skip empty vectors
+    }
+
+    // Detect patterns:
+    // HeadOnly: all nulls at start (firstNull < 5)
+    if (firstNull < 5 && lastNull < nullCount + 5) {
+      seenAllAtStart = true;
+    }
+    // TailOnly: all nulls at end (firstNull > 100 - nullCount - 5)
+    if (firstNull > 100 - nullCount - 5 && lastNull > 95) {
+      seenAllAtEnd = true;
+    }
+    // Scattered (Random or HeadAndTail with gaps)
+    size_t gapSize = lastNull - firstNull - nullCount + 1;
+    if (gapSize > 10) {
+      seenScattered = true;
+    }
+  }
+
+  // We should see all different patterns across 200 iterations
+  int patternsObserved = (seenAllAtStart ? 1 : 0) + (seenAllAtEnd ? 1 : 0) +
+      (seenScattered ? 1 : 0);
+  EXPECT_EQ(patternsObserved, 3)
+      << "Expected to observe multiple NULL patterns, but only saw "
+      << patternsObserved;
+}
 } // namespace
diff --git a/velox/vector/tests/CMakeLists.txt b/velox/vector/tests/CMakeLists.txt
index 28e8df935808..c626b340e63d 100644
--- a/velox/vector/tests/CMakeLists.txt
+++ b/velox/vector/tests/CMakeLists.txt
@@ -33,34 +33,34 @@ add_executable(
   VectorPoolTest.cpp
   VectorPrepareForReuseTest.cpp
   VectorPrinterTest.cpp
+  VectorRetainedSizeTest.cpp
   VectorSaverTest.cpp
   VectorStreamTest.cpp
+  VectorStreamGroupTest.cpp
   VectorTest.cpp
   VectorTestUtils.cpp
-  VectorToStringTest.cpp)
+  VectorToStringTest.cpp
+)
 
 add_test(velox_vector_test velox_vector_test)
 
 target_link_libraries(
   velox_vector_test
+  velox_time
+  velox_vector_fuzzer
   velox_vector_test_lib
   velox_buffer
-  velox_vector
-  velox_vector_fuzzer
   velox_serialization
-  velox_memory
   velox_presto_serializer
   velox_presto_types
   velox_temp_path
-  velox_test_util
   velox_type_test_lib
-  velox_vector_fuzzer
+  velox_common_fuzzer_util
   Boost::atomic
   Boost::context
   Boost::date_time
   Boost::filesystem
   Boost::program_options
-  Boost::regex
   Boost::thread
   Boost::system
   GTest::gtest
@@ -69,7 +69,8 @@ target_link_libraries(
   Folly::folly
   glog::glog
   fmt::fmt
-  dl)
+  dl
+)
 
 add_executable(simple_vector_test SimpleVectorTest.cpp ToStringUtilityTest.cpp)
 
@@ -85,7 +86,8 @@ target_link_libraries(
   GTest::gtest_main
   Folly::folly
   glog::glog
-  fmt::fmt)
+  fmt::fmt
+)
 
 add_executable(bias_vector_test BiasVectorTest.cpp)
 
@@ -99,4 +101,5 @@ target_link_libraries(
   GTest::gtest_main
   Folly::folly
   glog::glog
-  fmt::fmt)
+  fmt::fmt
+)
diff --git a/velox/vector/tests/DecodedVectorTest.cpp b/velox/vector/tests/DecodedVectorTest.cpp
index f2e08dbc934a..f777de427aad 100644
--- a/velox/vector/tests/DecodedVectorTest.cpp
+++ b/velox/vector/tests/DecodedVectorTest.cpp
@@ -209,6 +209,27 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
     }
   }
 
+  void testFlatMapEncoding(
+      const FlatMapVectorPtr& vector,
+      vector_size_t index) {
+    SCOPED_TRACE(vector->toString());
+
+    auto check = [&](auto& decoded) {
+      EXPECT_EQ(vector->encoding(), decoded.base()->encoding());
+      auto base = decoded.base();
+      const FlatMapVector& flatMap = *base->template as<FlatMapVector>();
+      EXPECT_EQ(vector->distinctKeys(), flatMap.distinctKeys());
+      EXPECT_EQ(vector->inMaps()[index], flatMap.inMaps()[index]);
+      EXPECT_EQ(vector->mapValues()[index], flatMap.mapValues()[index]);
+    };
+
+    {
+      SelectivityVector selection(100);
+      DecodedVector decoded(*vector);
+      check(decoded);
+    }
+  }
+
   template <typename T>
   void testConstantOpaque(const std::shared_ptr<T>& value) {
     int uses = value.use_count();
@@ -456,16 +477,15 @@ class DecodedVectorTest : public testing::Test, public VectorTestBase {
 
 template <>
 void DecodedVectorTest::testConstant<StringView>(const StringView& value) {
-  auto val = value.getString();
-  auto constantVector = BaseVector::createConstant(
-      VARCHAR(), folly::StringPiece{val}, 100, pool_.get());
+  auto constantVector =
+      BaseVector::createConstant(VARCHAR(), value, 100, pool_.get());
 
   auto check = [&](auto& decoded) {
     EXPECT_TRUE(decoded.isConstantMapping());
     EXPECT_FALSE(decoded.isIdentityMapping());
     for (int32_t i = 0; i < 100; i++) {
       EXPECT_FALSE(decoded.isNullAt(i));
-      EXPECT_EQ(decoded.template valueAt<StringView>(i).getString(), val);
+      EXPECT_EQ(decoded.template valueAt<StringView>(i).getString(), value);
     }
   };
 
@@ -552,6 +572,7 @@ TEST_F(DecodedVectorTest, constantNull) {
   testConstantNull(ARRAY(INTEGER()));
   testConstantNull(MAP(INTEGER(), INTEGER()));
   testConstantNull(ROW({INTEGER()}));
+  testConstantNull(ROW({}));
 }
 
 TEST_F(DecodedVectorTest, constantComplexType) {
@@ -573,6 +594,43 @@ TEST_F(DecodedVectorTest, constantComplexType) {
   testConstant(mapVector, 0);
   testConstant(mapVector, 3);
   testConstant(mapVector, 5); // null
+
+  auto flatMapVector = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:null, 4:40, 5:50}",
+      "{1:10, 2:20, 3:null, 4:40, 5:50}",
+      "{1:10, 2:null, 4:40, 5:null}",
+      "{}",
+      "{2:20, 4:null, 5:null}",
+      "{2:20, 4:null, 5:50}",
+      "{1:10, 4:null, 5:null}",
+      "{2:20, 3:30, 5:null}",
+      "{}",
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+  testConstant(flatMapVector, 0);
+  testConstant(flatMapVector, 3);
+  testConstant(flatMapVector, 5);
+}
+
+TEST_F(DecodedVectorTest, flatMap) {
+  auto flatMapVector = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:null, 4:40, 5:50}",
+      "{1:10, 2:20, 3:null, 4:40, 5:50}",
+      "{1:10, 2:null, 4:40, 5:null}",
+      "{}",
+      "{2:20, 4:null, 5:null}",
+      "{2:20, 4:null, 5:50}",
+      "{1:10, 4:null, 5:null}",
+      "{2:20, 3:30, 5:null}",
+      "{}",
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+
+  testFlatMapEncoding(flatMapVector, 0);
+  testFlatMapEncoding(flatMapVector, 1);
+  testFlatMapEncoding(flatMapVector, 2);
+  testFlatMapEncoding(flatMapVector, 3);
+  testFlatMapEncoding(flatMapVector, 4);
 }
 
 TEST_F(DecodedVectorTest, dictionary) {
@@ -642,6 +700,43 @@ TEST_F(DecodedVectorTest, dictionaryOverLazy) {
   }
 }
 
+TEST_F(DecodedVectorTest, dictionaryOverFlatMapVector) {
+  auto flatMapVector = makeFlatMapVectorFromJson<int64_t, int32_t>({
+      "{1:10, 2:20, 3:null, 4:40, 5:50}",
+      "{1:10, 2:20, 3:null, 4:40, 5:50}",
+      "{1:10, 2:null, 4:40, 5:null}",
+      "{}",
+      "{2:20, 4:null, 5:null}",
+      "{2:20, 4:null, 5:50}",
+      "{1:10, 4:null, 5:null}",
+      "{2:20, 3:30, 5:null}",
+      "{}",
+      "{1:10, 2:20, 3:30, 4:40, 5:50}",
+  });
+  auto indices =
+      makeIndices(flatMapVector->size(), [](auto row) { return row; });
+
+  auto dict = BaseVector::wrapInDictionary(
+      nullptr, indices, flatMapVector->size(), flatMapVector);
+  DecodedVector decodedVector(*dict);
+  EXPECT_FALSE(decodedVector.isConstantMapping());
+
+  auto check = [&](auto& decoded, vector_size_t index) {
+    EXPECT_EQ(flatMapVector->encoding(), decoded.base()->encoding());
+    auto base = decoded.base();
+    const FlatMapVector& flatMap = *base->template as<FlatMapVector>();
+    EXPECT_EQ(flatMapVector->distinctKeys(), flatMap.distinctKeys());
+    EXPECT_EQ(flatMapVector->inMaps()[index], flatMap.inMaps()[index]);
+    EXPECT_EQ(flatMapVector->mapValues()[index], flatMap.mapValues()[index]);
+  };
+
+  check(decodedVector, 0);
+  check(decodedVector, 1);
+  check(decodedVector, 2);
+  check(decodedVector, 3);
+  check(decodedVector, 4);
+}
+
 TEST_F(DecodedVectorTest, nestedLazy) {
   constexpr vector_size_t size = 1000;
   auto columnType = ROW({"a", "b"}, {INTEGER(), INTEGER()});
@@ -1530,4 +1625,13 @@ TEST_F(DecodedVectorTest, toString) {
   }
 }
 
+TEST_F(DecodedVectorTest, emptyStruct) {
+  auto vector = makeRowVector(ROW({}), 1);
+  DecodedVector decoded;
+  decoded.decode(*vector);
+  EXPECT_EQ(decoded.base(), vector.get());
+  EXPECT_EQ(decoded.size(), 1);
+  EXPECT_FALSE(decoded.isNullAt(0));
+}
+
 } // namespace facebook::velox::test
diff --git a/velox/vector/tests/EncodedVectorCopyTest.cpp b/velox/vector/tests/EncodedVectorCopyTest.cpp
index f1ac7c8a4dee..bd3f1e1202e0 100644
--- a/velox/vector/tests/EncodedVectorCopyTest.cpp
+++ b/velox/vector/tests/EncodedVectorCopyTest.cpp
@@ -54,8 +54,9 @@ void compareVectors(const VectorPtr& actual, const VectorPtr& expected) {
   }
   switch (actual->encoding()) {
     case VectorEncoding::Simple::DICTIONARY:
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actual->wrapInfo(), *expected->wrapInfo(), actual->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actual->wrapInfo(), *expected->wrapInfo(), actual->size()));
       compareVectors(actual->valueVector(), expected->valueVector());
       break;
     case VectorEncoding::Simple::ROW: {
@@ -69,10 +70,14 @@ void compareVectors(const VectorPtr& actual, const VectorPtr& expected) {
     case VectorEncoding::Simple::MAP: {
       auto* actualMap = actual->asChecked<MapVector>();
       auto* expectedMap = expected->asChecked<MapVector>();
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actualMap->offsets(), *expectedMap->offsets(), actualMap->size()));
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actualMap->sizes(), *expectedMap->sizes(), actualMap->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actualMap->offsets(),
+              *expectedMap->offsets(),
+              actualMap->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actualMap->sizes(), *expectedMap->sizes(), actualMap->size()));
       compareVectors(actualMap->mapKeys(), expectedMap->mapKeys());
       compareVectors(actualMap->mapValues(), expectedMap->mapValues());
       break;
@@ -80,12 +85,16 @@ void compareVectors(const VectorPtr& actual, const VectorPtr& expected) {
     case VectorEncoding::Simple::ARRAY: {
       auto* actualArray = actual->asChecked<ArrayVector>();
       auto* expectedArray = expected->asChecked<ArrayVector>();
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actualArray->offsets(),
-          *expectedArray->offsets(),
-          actualArray->size()));
-      ASSERT_TRUE(bufferEqual<vector_size_t>(
-          *actualArray->sizes(), *expectedArray->sizes(), actualArray->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actualArray->offsets(),
+              *expectedArray->offsets(),
+              actualArray->size()));
+      ASSERT_TRUE(
+          bufferEqual<vector_size_t>(
+              *actualArray->sizes(),
+              *expectedArray->sizes(),
+              actualArray->size()));
       compareVectors(actualArray->elements(), expectedArray->elements());
       break;
     }
diff --git a/velox/vector/tests/EnsureWritableVectorTest.cpp b/velox/vector/tests/EnsureWritableVectorTest.cpp
index 66c29e01edac..f74a6dfa6a9a 100644
--- a/velox/vector/tests/EnsureWritableVectorTest.cpp
+++ b/velox/vector/tests/EnsureWritableVectorTest.cpp
@@ -240,13 +240,13 @@ struct VectorPointersBase {
     sizesUnique = unique;
   }
 
-  void assertUnique(const VectorPtr& vector) {
+  void assertMutable(const VectorPtr& vector) {
     ASSERT_EQ(vector.use_count(), 1);
 
     auto* typedVector = vector->as<T>();
-    ASSERT_EQ(nullsUnique, typedVector->nulls()->unique());
-    ASSERT_EQ(offsetsUnique, typedVector->offsets()->unique());
-    ASSERT_EQ(sizesUnique, typedVector->sizes()->unique());
+    ASSERT_EQ(nullsUnique, typedVector->nulls()->isMutable());
+    ASSERT_EQ(offsetsUnique, typedVector->offsets()->isMutable());
+    ASSERT_EQ(sizesUnique, typedVector->sizes()->isMutable());
   }
 
   void assertPointers(const VectorPtr& vector) {
@@ -295,11 +295,12 @@ struct ArrayVectorPointers : public VectorPointersBase<ArrayVector> {
     elementsUnique = unique;
   }
 
-  void assertUnique(const VectorPtr& vector) {
-    VectorPointersBase<ArrayVector>::assertUnique(vector);
+  void assertMutable(const VectorPtr& vector) {
+    VectorPointersBase<ArrayVector>::assertMutable(vector);
 
     auto* arrayVector = vector->as<ArrayVector>();
-    ASSERT_EQ(elementsUnique, (arrayVector->elements().use_count() == 1));
+    ASSERT_EQ(
+        elementsUnique, BaseVector::isVectorWritable(arrayVector->elements()));
   }
 
   void assertPointers(const VectorPtr& vector) {
@@ -334,12 +335,13 @@ struct MapVectorPointers : public VectorPointersBase<MapVector> {
     valuesUnique = unique;
   }
 
-  void assertUnique(const VectorPtr& vector) {
-    VectorPointersBase<MapVector>::assertUnique(vector);
+  void assertMutable(const VectorPtr& vector) {
+    VectorPointersBase<MapVector>::assertMutable(vector);
 
     auto* mapVector = vector->as<MapVector>();
-    ASSERT_EQ(keysUnique, (mapVector->mapKeys().use_count() == 1));
-    ASSERT_EQ(valuesUnique, (mapVector->mapValues().use_count() == 1));
+    ASSERT_EQ(keysUnique, BaseVector::isVectorWritable(mapVector->mapKeys()));
+    ASSERT_EQ(
+        valuesUnique, BaseVector::isVectorWritable(mapVector->mapValues()));
   }
 
   void assertPointers(const VectorPtr& vector) {
@@ -451,6 +453,13 @@ TEST_F(EnsureWritableVectorTest, constant) {
   }
 }
 
+struct MockBufferViewReleaser {
+  void addRef() {}
+  void release() {}
+};
+using MockBufferView = BufferView<MockBufferViewReleaser&>;
+MockBufferViewReleaser releaser;
+
 TEST_F(EnsureWritableVectorTest, array) {
   vector_size_t size = 1'000;
   auto a = makeArrayVector<int32_t>(
@@ -474,7 +483,7 @@ TEST_F(EnsureWritableVectorTest, array) {
 
   result->copy(a.get(), rows, nullptr);
 
-  // Multiply-referenced vector
+  // Multiply-referenced vector.
   auto resultCopy = result;
   ASSERT_FALSE(result.use_count() == 1);
 
@@ -483,12 +492,12 @@ TEST_F(EnsureWritableVectorTest, array) {
   ASSERT_TRUE(result.use_count() == 1);
   ASSERT_NE(resultCopy.get(), result.get());
 
-  // Verify that even rows were copied over
+  // Verify that even rows were copied over.
   for (vector_size_t i = 0; i < size; i += 2) {
     ASSERT_TRUE(a->equalValueAt(result.get(), i, i));
   }
 
-  // Modify odd rows and verify that resultCopy is not affected
+  // Modify odd rows and verify that resultCopy is not affected.
   result->copy(b.get(), oddRows, nullptr);
 
   for (vector_size_t i = 0; i < size; i++) {
@@ -498,7 +507,7 @@ TEST_F(EnsureWritableVectorTest, array) {
     ASSERT_TRUE(a->equalValueAt(resultCopy.get(), i, i));
   }
 
-  // Singly referenced array vector; multiply-referenced elements vector
+  // Singly referenced array vector; multiply-referenced elements vector.
   result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
@@ -506,19 +515,19 @@ TEST_F(EnsureWritableVectorTest, array) {
   pointers.initialize(result);
   auto elementsCopy = result->as<ArrayVector>()->elements();
   pointers.setElementsUnique(false);
-  pointers.assertUnique(result);
+  pointers.assertMutable(result);
 
   BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool(), result);
   pointers.assertPointers(result);
 
-  // Verify that even rows were copied over
+  // Verify that even rows were copied over.
   for (vector_size_t i = 0; i < size; i += 2) {
     ASSERT_TRUE(a->equalValueAt(result.get(), i, i)) << "at " << i;
   }
 
   result->copy(b.get(), oddRows, nullptr);
 
-  // Verify that elementsCopy is not modified
+  // Verify that elementsCopy is not modified.
   for (vector_size_t i = 0; i < size; i++) {
     ArrayVectorPtr expected = (i % 2 == 0) ? a : b;
     ASSERT_TRUE(expected->equalValueAt(result.get(), i, i)) << "at " << i;
@@ -529,21 +538,21 @@ TEST_F(EnsureWritableVectorTest, array) {
         << "at " << i;
   }
 
-  // Singly referenced array vector; multiply-referenced offsets buffer
+  // Singly referenced array vector; multiply-referenced offsets buffer.
   result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
   auto offsetsCopy = result->as<ArrayVector>()->offsets();
   pointers.setOffsetsUnique(false);
-  pointers.assertUnique(result);
+  pointers.assertMutable(result);
 
   BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
 
-  // Verify offsetsCopy is unmodified
+  // Verify offsetsCopy is unmodified.
   for (vector_size_t i = 0; i < size; i++) {
     ArrayVectorPtr expected = (i % 2 == 0) ? a : b;
     ASSERT_TRUE(expected->equalValueAt(result.get(), i, i)) << "at " << i;
@@ -551,27 +560,64 @@ TEST_F(EnsureWritableVectorTest, array) {
 
   assertEqualOffsetsOrSizes(a->offsets(), offsetsCopy, a->size(), isNullAt(a));
 
-  // Singly referenced array vector; multiply-referenced sizes buffer
+  // Singly referenced array vector; multiply-referenced sizes buffer.
   result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
   auto sizesCopy = result->as<ArrayVector>()->sizes();
   pointers.setSizesUnique(false);
-  pointers.assertUnique(result);
+  pointers.assertMutable(result);
 
   BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
 
-  // Verify sizesCopy is unmodified
+  // Verify sizesCopy is unmodified.
   for (vector_size_t i = 0; i < size; i++) {
     ArrayVectorPtr expected = (i % 2 == 0) ? a : b;
     ASSERT_TRUE(expected->equalValueAt(result.get(), i, i)) << "at " << i;
   }
 
   assertEqualOffsetsOrSizes(a->sizes(), sizesCopy, a->size(), isNullAt(a));
+
+  // Test arrays containing buffer views. Buffer views are not mutable even if
+  // they are unique, and must always be copied on write.
+  auto copyOfA = BaseVector::copy(*a);
+
+  result = std::make_shared<ArrayVector>(
+      pool(),
+      a->type(),
+      MockBufferView::create(a->nulls(), releaser),
+      a->size(),
+      MockBufferView::create(a->offsets(), releaser),
+      MockBufferView::create(a->sizes(), releaser),
+      a->elements());
+
+  pointers.initialize(result);
+  pointers.setNullsUnique(false);
+
+  pointers.setOffsetsUnique(false);
+  pointers.setSizesUnique(false);
+
+  pointers.setElementsUnique(false);
+  pointers.assertMutable(result);
+
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
+  pointers.assertPointers(result);
+
+  result->copy(b.get(), oddRows, nullptr);
+
+  // Verify the result is as expected.
+  for (vector_size_t i = 0; i < size; i++) {
+    ArrayVectorPtr expected = (i % 2 == 0) ? a : b;
+    ASSERT_TRUE(expected->equalValueAt(result.get(), i, i)) << "at " << i;
+  }
+
+  // Verify the initial "a" map where we created buffer views has not being
+  // overwritten.
+  test::assertEqualVectors(a, copyOfA);
 }
 
 TEST_F(EnsureWritableVectorTest, map) {
@@ -599,7 +645,7 @@ TEST_F(EnsureWritableVectorTest, map) {
 
   result->copy(a.get(), rows, nullptr);
 
-  // Multiply-referenced vector
+  // Multiply-referenced vector.
   auto resultCopy = result;
   ASSERT_FALSE(result.use_count() == 1);
 
@@ -608,12 +654,12 @@ TEST_F(EnsureWritableVectorTest, map) {
   ASSERT_TRUE(result.use_count() == 1);
   ASSERT_NE(resultCopy.get(), result.get());
 
-  // Verify that even rows were copied over
+  // Verify that even rows were copied over.
   for (vector_size_t i = 0; i < size; i += 2) {
     ASSERT_TRUE(a->equalValueAt(result.get(), i, i));
   }
 
-  // Modify odd rows and verify that resultCopy is not affected
+  // Modify odd rows and verify that resultCopy is not affected.
   result->copy(b.get(), oddRows, nullptr);
 
   for (vector_size_t i = 0; i < size; i++) {
@@ -623,7 +669,7 @@ TEST_F(EnsureWritableVectorTest, map) {
     ASSERT_TRUE(a->equalValueAt(resultCopy.get(), i, i));
   }
 
-  // Singly referenced map vector; multiply-referenced keys vector
+  // Singly referenced map vector; multiply-referenced keys vector.
   result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
@@ -631,19 +677,19 @@ TEST_F(EnsureWritableVectorTest, map) {
   pointers.initialize(result);
   auto keysCopy = result->as<MapVector>()->mapKeys();
   pointers.setKeysUnique(false);
-  pointers.assertUnique(result);
+  pointers.assertMutable(result);
 
   BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool(), result);
   pointers.assertPointers(result);
 
-  // Verify that even rows were copied over
+  // Verify that even rows were copied over.
   for (vector_size_t i = 0; i < size; i += 2) {
     ASSERT_TRUE(a->equalValueAt(result.get(), i, i)) << "at " << i;
   }
 
   result->copy(b.get(), oddRows, nullptr);
 
-  // Verify that keysCopy is not modified
+  // Verify that keysCopy is not modified.
   for (vector_size_t i = 0; i < size; i++) {
     MapVectorPtr expected = (i % 2 == 0) ? a : b;
     ASSERT_TRUE(expected->equalValueAt(result.get(), i, i)) << "at " << i;
@@ -653,26 +699,26 @@ TEST_F(EnsureWritableVectorTest, map) {
     ASSERT_TRUE(a->mapKeys()->equalValueAt(keysCopy.get(), i, i)) << "at " << i;
   }
 
-  // Singly referenced map vector; multiply-referenced keys vector
+  // Singly referenced map vector; multiply-referenced values vector.
   result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
   auto valuesCopy = result->as<MapVector>()->mapValues();
   pointers.setValuesUnique(false);
-  pointers.assertUnique(result);
+  pointers.assertMutable(result);
 
   BaseVector::ensureWritable(oddRows, ARRAY(INTEGER()), pool(), result);
   pointers.assertPointers(result);
 
-  // Verify that even rows were copied over
+  // Verify that even rows were copied over.
   for (vector_size_t i = 0; i < size; i += 2) {
     ASSERT_TRUE(a->equalValueAt(result.get(), i, i)) << "at " << i;
   }
 
   result->copy(b.get(), oddRows, nullptr);
 
-  // Verify that valuesCopy is not modified
+  // Verify that valuesCopy is not modified.
   for (vector_size_t i = 0; i < size; i++) {
     MapVectorPtr expected = (i % 2 == 0) ? a : b;
     ASSERT_TRUE(expected->equalValueAt(result.get(), i, i)) << "at " << i;
@@ -683,14 +729,14 @@ TEST_F(EnsureWritableVectorTest, map) {
         << "at " << i;
   }
 
-  // Singly referenced map vector; multiply-referenced offsets buffer
+  // Singly referenced map vector; multiply-referenced offsets buffer.
   result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
   auto offsetsCopy = result->as<MapVector>()->offsets();
   pointers.setOffsetsUnique(false);
-  pointers.assertUnique(result);
+  pointers.assertMutable(result);
 
   BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   pointers.assertPointers(result);
@@ -705,27 +751,119 @@ TEST_F(EnsureWritableVectorTest, map) {
 
   assertEqualOffsetsOrSizes(a->offsets(), offsetsCopy, a->size(), isNullAt(a));
 
-  // Singly referenced map vector; multiply-referenced sizes buffer
+  // Singly referenced map vector; multiply-referenced sizes buffer.
   result = BaseVector::create(result->type(), rows.size(), pool());
   result->copy(a.get(), rows, nullptr);
 
   pointers.initialize(result);
   auto sizesCopy = result->as<MapVector>()->sizes();
   pointers.setSizesUnique(false);
-  pointers.assertUnique(result);
+  pointers.assertMutable(result);
 
   BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
   pointers.assertPointers(result);
 
   result->copy(b.get(), oddRows, nullptr);
 
-  // Verify sizesCopy is unmodified
+  // Verify sizesCopy is unmodified.
   for (vector_size_t i = 0; i < size; i++) {
     MapVectorPtr expected = (i % 2 == 0) ? a : b;
     ASSERT_TRUE(expected->equalValueAt(result.get(), i, i)) << "at " << i;
   }
 
   assertEqualOffsetsOrSizes(a->sizes(), sizesCopy, a->size(), isNullAt(a));
+
+  // Test maps containing buffer views. Buffer views are not mutable even if
+  // they are unique, and must always be copied on write.
+  auto copyOfA = BaseVector::copy(*a);
+
+  result = std::make_shared<MapVector>(
+      pool(),
+      a->type(),
+      MockBufferView::create(a->nulls(), releaser),
+      a->size(),
+      MockBufferView::create(a->offsets(), releaser),
+      MockBufferView::create(a->sizes(), releaser),
+      a->mapKeys(),
+      a->mapValues());
+
+  pointers.initialize(result);
+  pointers.setNullsUnique(false);
+
+  pointers.setOffsetsUnique(false);
+  pointers.setSizesUnique(false);
+
+  pointers.setKeysUnique(false);
+  pointers.setValuesUnique(false);
+  pointers.assertMutable(result);
+
+  BaseVector::ensureWritable(oddRows, result->type(), pool(), result);
+  pointers.assertPointers(result);
+
+  result->copy(b.get(), oddRows, nullptr);
+
+  // Verify the result is as expected.
+  for (vector_size_t i = 0; i < size; i++) {
+    MapVectorPtr expected = (i % 2 == 0) ? a : b;
+    ASSERT_TRUE(expected->equalValueAt(result.get(), i, i)) << "at " << i;
+  }
+
+  // Verify the initial "a" map where we created buffer views has not being
+  // overwritten.
+  test::assertEqualVectors(a, copyOfA);
+}
+
+TEST_F(EnsureWritableVectorTest, flatMap) {
+  std::vector<std::string> jsonData = {
+      "{1:10, 2:20, 3:null}",
+      "{7:60}",
+      "{}",
+      "{4:40, 5:null, 6:null}",
+  };
+  std::vector<std::string> otherJsonData = {
+      "null",
+      "{6:10, 2:20, 7:null}",
+      "{3:60}",
+      "{}",
+  };
+  vector_size_t size = jsonData.size();
+
+  auto flatMap = makeFlatMapVectorFromJson<int64_t, int32_t>(jsonData);
+  auto otherFlatMap =
+      makeFlatMapVectorFromJson<int64_t, int32_t>(otherJsonData);
+
+  // Make a shallow copy that points to all the same buffers as `flatMap`.
+  VectorPtr shallowCopy = std::make_shared<FlatMapVector>(
+      pool(),
+      flatMap->type(),
+      flatMap->nulls(),
+      flatMap->size(),
+      flatMap->distinctKeys(),
+      flatMap->mapValues(),
+      flatMap->inMaps());
+  test::assertEqualVectors(shallowCopy, flatMap);
+
+  auto oddRows = selectOddRows(size);
+  SelectivityVector evenRows(size);
+  evenRows.deselect(oddRows);
+
+  // Copy the odd rows from otherFlatMap into shallowCopy. We want to make sure
+  // ensure writable will detect and copy on write the buffers as expected.
+  BaseVector::ensureWritable(oddRows, flatMap->type(), pool(), shallowCopy);
+
+  // Ensure that the even rows (the ones that won't be overwritten) were
+  // properly copied.
+  test::assertEqualVectors(shallowCopy, flatMap, evenRows);
+
+  shallowCopy->copy(otherFlatMap.get(), oddRows, nullptr);
+
+  // Ensure that the original buffers from flatMap have not been modified.
+  test::assertEqualVectors(
+      flatMap, makeFlatMapVectorFromJson<int64_t, int32_t>(jsonData));
+
+  // Ensure the written vector has the correct even and odd rows.
+  test::assertEqualVectors(shallowCopy, otherFlatMap, oddRows);
+  test::assertEqualVectors(shallowCopy, flatMap, evenRows);
 }
 
 TEST_F(EnsureWritableVectorTest, allNullArray) {
diff --git a/velox/vector/tests/FlatMapVectorTest.cpp b/velox/vector/tests/FlatMapVectorTest.cpp
index ef038c6a952b..9fc52d9ee2a4 100644
--- a/velox/vector/tests/FlatMapVectorTest.cpp
+++ b/velox/vector/tests/FlatMapVectorTest.cpp
@@ -17,9 +17,9 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "velox/common/base/VeloxException.h"
 #include "velox/common/base/tests/GTestUtils.h"
 #include "velox/common/memory/Memory.h"
+#include "velox/common/testutil/OptionalEmpty.h"
 #include "velox/vector/tests/utils/VectorMaker.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -42,11 +42,159 @@ class FlatMapVectorTest : public testing::Test, public VectorTestBase {
     assertEqualVectors(mapVector, flatMapVector->toMapVector());
   }
 
+  void testFlatMapCopy(
+      const std::vector<std::string>& baseData,
+      const std::vector<std::string>& sourceData,
+      const std::vector<std::string>& expectedData,
+      const std::vector<BaseVector::CopyRange>& ranges) {
+    auto baseFlatMap = makeFlatMapVectorFromJson<int64_t, int32_t>(baseData);
+    auto sourceFlatMap =
+        makeFlatMapVectorFromJson<int64_t, int32_t>(sourceData);
+    baseFlatMap->copyRanges(
+        sourceFlatMap.get(),
+        folly::Range<const BaseVector::CopyRange*>{ranges});
+
+    // Validate that the updated flat map matches the expectation.
+    auto expectedFlatMap =
+        makeFlatMapVectorFromJson<int64_t, int32_t>(expectedData);
+    EXPECT_EQ(baseFlatMap->size(), expectedFlatMap->size());
+
+    for (vector_size_t i = 0; i < baseFlatMap->size(); ++i) {
+      EXPECT_EQ(
+          baseFlatMap->compare(
+              expectedFlatMap.get(), i, i, CompareFlags{.equalsOnly = true}),
+          0)
+          << "Failed at index " << i << ":\n  " << baseFlatMap->toString(i)
+          << "\nvs.\n  " << expectedFlatMap->toString(i);
+    }
+  }
+
   std::shared_ptr<memory::MemoryPool> pool_{
       memory::memoryManager()->addLeafPool()};
   VectorMaker maker_{pool_.get()};
 };
 
+TEST_F(FlatMapVectorTest, encodedKeys) {
+  const auto constructFlatMap = [&](VectorPtr keys) {
+    return std::make_shared<FlatMapVector>(
+        pool_.get(),
+        MAP(INTEGER(), INTEGER()),
+        nullptr,
+        3,
+        keys,
+        std::vector<VectorPtr>{
+            makeFlatVector<int32_t>({1, 2, 3}),
+            makeFlatVector<int32_t>({4, 5, 6}),
+            makeFlatVector<int32_t>({7, 8, 9})},
+        std::vector<BufferPtr>{nullptr, nullptr, nullptr});
+  };
+
+  // Dictionary wrapped keys
+  {
+    // Simple case
+    auto flatMap = constructFlatMap(
+        BaseVector::wrapInDictionary(
+            nullptr,
+            makeIndices({0, 1, 2}),
+            3,
+            makeFlatVector<int32_t>({1, 2, 3})));
+
+    auto mapValues = flatMap->projectKey(1)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 1);
+    EXPECT_EQ(mapValues->valueAt(1), 2);
+    EXPECT_EQ(mapValues->valueAt(2), 3);
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 4);
+    EXPECT_EQ(mapValues->valueAt(1), 5);
+    EXPECT_EQ(mapValues->valueAt(2), 6);
+    mapValues = flatMap->projectKey(3)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 7);
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+
+    // Random indices
+    flatMap = constructFlatMap(
+        BaseVector::wrapInDictionary(
+            nullptr,
+            makeIndices({2, 0, 1}),
+            3,
+            makeFlatVector<int32_t>({1, 2, 3})));
+
+    mapValues = flatMap->projectKey(1)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 4);
+    EXPECT_EQ(mapValues->valueAt(1), 5);
+    EXPECT_EQ(mapValues->valueAt(2), 6);
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 7);
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+    mapValues = flatMap->projectKey(3)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 1);
+    EXPECT_EQ(mapValues->valueAt(1), 2);
+    EXPECT_EQ(mapValues->valueAt(2), 3);
+
+    // Cardinality change
+    flatMap = constructFlatMap(
+        BaseVector::wrapInDictionary(
+            nullptr,
+            makeIndices({1, 3, 5}),
+            3,
+            makeFlatVector<int32_t>({1, 2, 3, 4, 5, 6})));
+
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 1);
+    EXPECT_EQ(mapValues->valueAt(1), 2);
+    EXPECT_EQ(mapValues->valueAt(2), 3);
+    mapValues = flatMap->projectKey(4)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 4);
+    EXPECT_EQ(mapValues->valueAt(1), 5);
+    EXPECT_EQ(mapValues->valueAt(2), 6);
+    mapValues = flatMap->projectKey(6)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 7);
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+    EXPECT_EQ(flatMap->projectKey(1)->as<FlatVector<int32_t>>(), nullptr);
+    EXPECT_EQ(flatMap->projectKey(3)->as<FlatVector<int32_t>>(), nullptr);
+    EXPECT_EQ(flatMap->projectKey(5)->as<FlatVector<int32_t>>(), nullptr);
+
+    // Repeated keys
+    flatMap = constructFlatMap(
+        BaseVector::wrapInDictionary(
+            nullptr,
+            makeIndices({2, 1, 1}),
+            3,
+            makeFlatVector<int32_t>({1, 2, 3})));
+
+    mapValues = flatMap->projectKey(1)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues, nullptr);
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->size(), 3);
+    EXPECT_EQ(mapValues->valueAt(0), 7); // Becomes last set vector
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+    mapValues = flatMap->projectKey(3)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->valueAt(0), 1);
+    EXPECT_EQ(mapValues->valueAt(1), 2);
+    EXPECT_EQ(mapValues->valueAt(2), 3);
+  }
+
+  // Constant wrapped keys
+  {
+    auto flatMap = constructFlatMap(
+        BaseVector::wrapInConstant(3, 0, makeFlatVector<int32_t>({1, 2, 3})));
+
+    auto mapValues = flatMap->projectKey(1)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues->size(), 3);
+    EXPECT_EQ(mapValues->valueAt(0), 7); // Becomes last set vector
+    EXPECT_EQ(mapValues->valueAt(1), 8);
+    EXPECT_EQ(mapValues->valueAt(2), 9);
+    mapValues = flatMap->projectKey(2)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues, nullptr);
+    mapValues = flatMap->projectKey(3)->as<FlatVector<int32_t>>();
+    EXPECT_EQ(mapValues, nullptr);
+  }
+}
+
 TEST_F(FlatMapVectorTest, fail) {
   auto buildVector = [&](const TypePtr& type,
                          const VectorPtr& keys = nullptr,
@@ -226,6 +374,28 @@ TEST_F(FlatMapVectorTest, withNulls) {
   EXPECT_TRUE(flatMapVector->isInMap(*channel, 2));
 }
 
+TEST_F(FlatMapVectorTest, nullInMaps) {
+  // Construct a flat map with two null BufferPtrs in the inMaps vector.
+  auto vectorSize = 1;
+  auto distinctKeys = maker_.flatVector<int32_t>({1, 2, 3});
+  std::vector<VectorPtr> mapValues(distinctKeys->size());
+  std::vector<BufferPtr> inMaps(distinctKeys->size());
+  inMaps[1] = AlignedBuffer::allocate<bool>(vectorSize, pool_.get(), 0);
+  auto flatMap = std::make_shared<FlatMapVector>(
+      pool_.get(),
+      MAP(INTEGER(), INTEGER()),
+      nullptr,
+      vectorSize,
+      distinctKeys,
+      mapValues,
+      inMaps);
+
+  // Channels with null inMaps (0 and 2) will always return true.
+  EXPECT_TRUE(flatMap->isInMap(0, 0));
+  EXPECT_FALSE(flatMap->isInMap(1, 0));
+  EXPECT_TRUE(flatMap->isInMap(2, 0));
+}
+
 TEST_F(FlatMapVectorTest, primitiveKeys) {
   // bigint key.
   auto flatMapVector = maker_.flatMapVector<int64_t, double>({
@@ -394,13 +564,14 @@ TEST_F(FlatMapVectorTest, sortedKeyIndices) {
 }
 
 TEST_F(FlatMapVectorTest, toString) {
-  auto vector = maker_.flatMapVectorNullable<int64_t, int64_t>({
-      {{}},
-      {std::nullopt},
-      {{{1, 0}}},
-      {{{1, 1}, {2, std::nullopt}}},
-      {{{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}}},
-  });
+  auto vector = maker_.flatMapVectorNullable<int64_t, int64_t>(
+      {common::testutil::optionalEmpty,
+       std::nullopt,
+       std::vector<std::pair<int64_t, std::optional<int64_t>>>{{1, 0}},
+       std::vector<std::pair<int64_t, std::optional<int64_t>>>{
+           {1, 1}, {2, std::nullopt}},
+       std::vector<std::pair<int64_t, std::optional<int64_t>>>{
+           {0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}}});
 
   EXPECT_EQ(
       vector->toString(), "[FLAT_MAP MAP<BIGINT,BIGINT>: 5 elements, 1 nulls]");
@@ -425,30 +596,71 @@ TEST_F(FlatMapVectorTest, compare) {
       {{{3, 0}, {1, 0}, {2, 1}}}, // 6
   });
 
+  enum class Result {
+    kEq,
+    kNe,
+    kLt,
+    kGt,
+  };
+
+  const auto testCompare =
+      [&](int32_t left, int32_t right, CompareFlags flags, Result expected) {
+        auto mapVector = vector->toMapVector();
+        auto flatMapFlatMapResult =
+            vector->compare(vector.get(), left, right, flags);
+        auto flatMapMapResult =
+            vector->compare(mapVector.get(), left, right, flags);
+        auto mapFlatMapResult =
+            mapVector->compare(vector.get(), left, right, flags);
+
+        switch (expected) {
+          case Result::kEq:
+            EXPECT_EQ(flatMapFlatMapResult, 0);
+            EXPECT_EQ(flatMapMapResult, 0);
+            EXPECT_EQ(mapFlatMapResult, 0);
+            break;
+          case Result::kNe:
+            EXPECT_NE(flatMapFlatMapResult, 0);
+            EXPECT_NE(flatMapMapResult, 0);
+            EXPECT_NE(mapFlatMapResult, 0);
+            break;
+          case Result::kLt:
+            EXPECT_LT(flatMapFlatMapResult, 0);
+            EXPECT_LT(flatMapMapResult, 0);
+            EXPECT_LT(mapFlatMapResult, 0);
+            break;
+          case Result::kGt:
+            EXPECT_GT(flatMapFlatMapResult, 0);
+            EXPECT_GT(flatMapMapResult, 0);
+            EXPECT_GT(mapFlatMapResult, 0);
+            break;
+        }
+      };
+
   // Null map equals to null.
-  EXPECT_EQ(vector->compare(vector.get(), 0, 0, {}), 0);
+  testCompare(0, 0, {}, Result::kEq);
 
   // Maps of different sizes.
-  EXPECT_NE(vector->compare(vector.get(), 1, 2, {.equalsOnly = true}), 0);
+  testCompare(1, 2, {.equalsOnly = true}, Result::kNe);
 
-  EXPECT_LT(vector->compare(vector.get(), 2, 3, {.equalsOnly = true}), 0);
-  EXPECT_GT(vector->compare(vector.get(), 3, 2, {.equalsOnly = true}), 0);
+  testCompare(2, 3, {.equalsOnly = true}, Result::kLt);
+  testCompare(3, 2, {.equalsOnly = true}, Result::kGt);
 
-  EXPECT_LT(vector->compare(vector.get(), 2, 3, {}), 0);
-  EXPECT_GT(vector->compare(vector.get(), 3, 2, {}), 0);
+  testCompare(2, 3, {}, Result::kLt);
+  testCompare(3, 2, {}, Result::kGt);
 
-  EXPECT_LT(vector->compare(vector.get(), 2, 4, {}), 0);
-  EXPECT_GT(vector->compare(vector.get(), 4, 2, {}), 0);
+  testCompare(2, 4, {}, Result::kLt);
+  testCompare(4, 2, {}, Result::kGt);
 
-  EXPECT_EQ(vector->compare(vector.get(), 4, 5, {}), 0);
-  EXPECT_EQ(vector->compare(vector.get(), 5, 4, {}), 0);
+  testCompare(4, 5, {}, Result::kEq);
+  testCompare(5, 4, {}, Result::kEq);
 
-  EXPECT_LT(vector->compare(vector.get(), 5, 6, {}), 0);
-  EXPECT_GT(vector->compare(vector.get(), 6, 5, {}), 0);
+  testCompare(5, 6, {}, Result::kLt);
+  testCompare(6, 5, {}, Result::kGt);
 
   // Descending.
-  EXPECT_GT(vector->compare(vector.get(), 5, 6, {.ascending = false}), 0);
-  EXPECT_LT(vector->compare(vector.get(), 6, 5, {.ascending = false}), 0);
+  testCompare(5, 6, {.ascending = false}, Result::kGt);
+  testCompare(6, 5, {.ascending = false}, Result::kLt);
 
   // Cannot compare maps with nulls as indeterminate.
   VELOX_ASSERT_THROW(
@@ -459,6 +671,16 @@ TEST_F(FlatMapVectorTest, compare) {
           {.nullHandlingMode =
                CompareFlags::NullHandlingMode::kNullAsIndeterminate}),
       "Map is not orderable type");
+
+  // Cannot compare maps with nulls as indeterminate.
+  VELOX_ASSERT_THROW(
+      vector->compare(
+          vector->toMapVector().get(),
+          6,
+          5,
+          {.nullHandlingMode =
+               CompareFlags::NullHandlingMode::kNullAsIndeterminate}),
+      "Map is not orderable type");
 }
 
 TEST_F(FlatMapVectorTest, hash) {
@@ -526,5 +748,123 @@ TEST_F(FlatMapVectorTest, toMapVector) {
   });
 }
 
+TEST_F(FlatMapVectorTest, copyRanges) {
+  std::vector<std::string> baseData = {
+      "{1:10, 2:20, 3:null}",
+      "null",
+      "{}",
+      "{4:40, 5:null, 6:null}",
+  };
+
+  std::vector<BaseVector::CopyRange> fullRange = {
+      BaseVector::CopyRange{0, 0, (vector_size_t)baseData.size()},
+  };
+
+  // Empty and identity copy.
+  testFlatMapCopy(baseData, {}, baseData, {});
+  testFlatMapCopy(baseData, baseData, baseData, fullRange);
+
+  std::vector<std::string> updatedData = {
+      "{1:null, 3:30, 6:66}",
+      "{7:60}",
+      "{8:80}",
+      "null",
+  };
+
+  // Test ranges with size zero.
+  testFlatMapCopy(
+      baseData, updatedData, baseData, {BaseVector::CopyRange{0, 0, 0}});
+  testFlatMapCopy(
+      baseData, updatedData, baseData, {BaseVector::CopyRange{1, 1, 0}});
+
+  // Test copy all records in both directions.
+  testFlatMapCopy(baseData, updatedData, updatedData, fullRange);
+  testFlatMapCopy(updatedData, baseData, baseData, fullRange);
+
+  // Copy first row only.
+  testFlatMapCopy(
+      baseData,
+      updatedData,
+      {
+          "{1:null, 3:30, 6:66}",
+          "null",
+          "{}",
+          "{4:40, 5:null, 6:null}",
+      },
+      {BaseVector::CopyRange{0, 0, 1}});
+
+  // Only second row.
+  testFlatMapCopy(
+      baseData,
+      updatedData,
+      {
+          "{1:10, 2:20, 3:null}",
+          "{7:60}",
+          "{}",
+          "{4:40, 5:null, 6:null}",
+      },
+      {BaseVector::CopyRange{1, 1, 1}});
+
+  // Second and third row.
+  testFlatMapCopy(
+      baseData,
+      updatedData,
+      {
+          "{1:10, 2:20, 3:null}",
+          "{7:60}",
+          "{8:80}",
+          "{4:40, 5:null, 6:null}",
+      },
+      {BaseVector::CopyRange{1, 1, 2}});
+
+  // Copy first row into the second.
+  testFlatMapCopy(
+      baseData,
+      updatedData,
+      {
+          "{1:10, 2:20, 3:null}",
+          "{1:null, 3:30, 6:66}",
+          "{}",
+          "{4:40, 5:null, 6:null}",
+      },
+      {BaseVector::CopyRange{0, 1, 1}});
+
+  // Copy second row into the first.
+  testFlatMapCopy(
+      baseData,
+      updatedData,
+      {
+          "{7:60}",
+          "null",
+          "{}",
+          "{4:40, 5:null, 6:null}",
+      },
+      {BaseVector::CopyRange{1, 0, 1}});
+
+  // Copy elements 1 and 2 into 0 and 1.
+  testFlatMapCopy(
+      baseData,
+      updatedData,
+      {
+          "{7:60}",
+          "{8:80}",
+          "{}",
+          "{4:40, 5:null, 6:null}",
+      },
+      {BaseVector::CopyRange{1, 0, 2}});
+
+  // Copy elements 0 and 1 into 1 and 2, and 3 into 3.
+  testFlatMapCopy(
+      baseData,
+      updatedData,
+      {
+          "{1:10, 2:20, 3:null}",
+          "{1:null, 3:30, 6:66}",
+          "{7:60}",
+          "null",
+      },
+      {BaseVector::CopyRange{0, 1, 2}, BaseVector::CopyRange{3, 3, 1}});
+}
+
 } // namespace
 } // namespace facebook::velox::test
diff --git a/velox/vector/tests/LazyVectorTest.cpp b/velox/vector/tests/LazyVectorTest.cpp
index 2d522330210b..b231c5e4bdfe 100644
--- a/velox/vector/tests/LazyVectorTest.cpp
+++ b/velox/vector/tests/LazyVectorTest.cpp
@@ -19,7 +19,9 @@
 #include "velox/common/memory/RawVector.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
-using namespace facebook::velox;
+namespace facebook::velox {
+namespace {
+
 using namespace facebook::velox::test;
 
 class LazyVectorTest : public testing::Test, public VectorTestBase {
@@ -696,3 +698,25 @@ TEST_F(LazyVectorTest, runtimeStats) {
   ASSERT_EQ(stats[2].first, LazyVector::kWallNanos);
   ASSERT_GE(stats[2].second.value, 0);
 }
+
+TEST_F(LazyVectorTest, chain) {
+  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);
+      }));
+  lazy->chain([](auto& vector) {
+    auto* values =
+        vector->template asChecked<FlatVector<int32_t>>()->mutableRawValues();
+    for (vector_size_t i = 0; i < vector->size(); ++i) {
+      values[i] *= 2;
+    }
+  });
+  auto expected = makeFlatVector<int32_t>(10, [](auto i) { return i * 2; });
+  assertEqualVectors(expected, lazy);
+}
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/vector/tests/SimpleVectorTest.cpp b/velox/vector/tests/SimpleVectorTest.cpp
index 9f2e30af95d9..8b38b8c183a8 100644
--- a/velox/vector/tests/SimpleVectorTest.cpp
+++ b/velox/vector/tests/SimpleVectorTest.cpp
@@ -747,6 +747,7 @@ TYPED_TEST(SimpleVectorCompareTest, compareDescNullsLast) {
   this->runTest({/*nullsFirst=*/false, /*ascending=*/false});
 }
 
+#ifdef VELOX_ENABLE_LOAD_SIMD_VALUE_BUFFER
 template <typename T, int32_t offset>
 inline T simd256_extract_value(xsimd::batch<T> simdValue) {
   if constexpr (std::is_same_v<T, bool>) {
@@ -925,6 +926,7 @@ TYPED_TEST(SimpleVectorSimdTypedTest, flatVectorTest) {
 TYPED_TEST(SimpleVectorSimdTypedTest, sequenceVectorTest) {
   this->template runTest<VectorEncoding::Simple::SEQUENCE>();
 }
+#endif
 
 // See instructions in SimpleVectorTestHelper.h. By implementing this, a bunch
 // of SimpleVector test cases will be run.
diff --git a/velox/vector/tests/ToStringUtilityTest.cpp b/velox/vector/tests/ToStringUtilityTest.cpp
index 21fd9ffe2c77..04925fdcee8a 100644
--- a/velox/vector/tests/ToStringUtilityTest.cpp
+++ b/velox/vector/tests/ToStringUtilityTest.cpp
@@ -15,50 +15,24 @@
  */
 
 #include <gtest/gtest.h>
-#include <sstream>
-#include "folly/Conv.h"
-#include "velox/vector/TypeAliases.h"
+#include "velox/type/Type.h"
 
 namespace facebook::velox {
-
-// Forward declaration, which is defined in ComplexVector.cpp
-std::string stringifyTruncatedElementList(
-    vector_size_t start,
-    vector_size_t size,
-    vector_size_t limit,
-    std::string_view delimiter,
-    const std::function<void(std::stringstream&, vector_size_t)>&
-        stringifyElementCB);
-
 namespace {
 TEST(ToStringUtil, stringifyTruncatedElementList) {
-  const auto indexAsString = [](std::stringstream& ss, vector_size_t i) {
+  const auto indexAsString = [](std::stringstream& ss, size_t i) {
     ss << folly::to<std::string>(i);
   };
 
   // no item
-  EXPECT_EQ(
-      stringifyTruncatedElementList(0, 0, 0, ", ", indexAsString), "<empty>");
+  EXPECT_EQ(stringifyTruncatedElementList(0, indexAsString), "<empty>");
   // exact item
-  EXPECT_EQ(
-      stringifyTruncatedElementList(0, 5, 5, ", ", indexAsString),
-      "5 elements starting at 0 {0, 1, 2, 3, 4}");
+  EXPECT_EQ(stringifyTruncatedElementList(5, indexAsString), "{0, 1, 2, 3, 4}");
   // more items
   EXPECT_EQ(
-      stringifyTruncatedElementList(1, 3, 2, ", ", indexAsString),
-      "3 elements starting at 1 {1, 2, ...}");
+      stringifyTruncatedElementList(5, indexAsString, 2), "{0, 1, ...3 more}");
   // less items
-  EXPECT_EQ(
-      stringifyTruncatedElementList(1, 3, 5, ", ", indexAsString),
-      "3 elements starting at 1 {1, 2, 3}");
-  // zero limit.
-  EXPECT_EQ(
-      stringifyTruncatedElementList(1, 5, 0, ", ", indexAsString),
-      "5 elements starting at 1 {...}");
-  // different delimiter
-  EXPECT_EQ(
-      stringifyTruncatedElementList(0, 3, 5, "<delimiter>", indexAsString),
-      "3 elements starting at 0 {0<delimiter>1<delimiter>2}");
+  EXPECT_EQ(stringifyTruncatedElementList(3, indexAsString), "{0, 1, 2}");
 }
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/vector/tests/VariantToVectorTest.cpp b/velox/vector/tests/VariantToVectorTest.cpp
index 406f9bca3879..fa16f5941c0e 100644
--- a/velox/vector/tests/VariantToVectorTest.cpp
+++ b/velox/vector/tests/VariantToVectorTest.cpp
@@ -13,147 +13,209 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <stdio.h>
-
+#include "velox/vector/VariantToVector.h"
 #include <glog/logging.h>
 #include <gtest/gtest.h>
+#include "velox/common/base/tests/GTestUtils.h"
 #include "velox/type/Variant.h"
-#include "velox/vector/FlatVector.h"
-#include "velox/vector/SimpleVector.h"
-#include "velox/vector/VariantToVector.h"
+#include "velox/vector/BaseVector.h"
+#include "velox/vector/VectorSaver.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
 
-using namespace facebook::velox;
-
-class VariantToVectorTest : public testing::Test {
-  std::shared_ptr<memory::MemoryPool> pool_{
-      memory::memoryManager()->addLeafPool()};
+namespace facebook::velox {
+namespace {
 
+class VariantToVectorTest : public testing::Test, public test::VectorTestBase {
  public:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
   }
 
-  template <TypeKind KIND>
-  void testCreateVector(
+  void testNull(const TypePtr& type) const {
+    auto vector = BaseVector::createConstant(
+        type, Variant::null(type->kind()), 1, pool());
+
+    EXPECT_TRUE(vector->isConstantEncoding());
+    EXPECT_EQ(vector->type()->toString(), type->toString());
+    EXPECT_TRUE(vector->isNullAt(0));
+
+    auto copy = vector->variantAt(0);
+    EXPECT_TRUE(copy.isNull());
+    EXPECT_TRUE(copy.isTypeCompatible(type));
+  }
+
+  void testValue(
       const TypePtr& type,
-      const std::vector<variant>& inputArray) {
-    using TCpp = typename TypeTraits<KIND>::NativeType;
-
-    auto varArray = variant::array(inputArray);
-    auto arrayVector =
-        core::variantArrayToVector(type, varArray.array(), pool_.get());
-    ASSERT_TRUE(arrayVector != nullptr);
-    ASSERT_EQ(1, arrayVector->size());
-
-    auto elements = arrayVector->elements()->as<FlatVector<TCpp>>();
-    if (!inputArray.empty()) {
-      ASSERT_TRUE(elements != nullptr);
-    }
-
-    for (size_t i = 0; i < inputArray.size(); i++) {
-      auto& var = inputArray[i];
-      if (var.isNull()) {
-        ASSERT_TRUE(elements->isNullAt(i));
-      } else if constexpr (std::is_same_v<TCpp, StringView>) {
-        ASSERT_EQ(
-            var.template value<KIND>(), std::string(elements->valueAt(i)));
-      } else {
-        ASSERT_EQ(var.template value<KIND>(), elements->valueAt(i));
-      }
-    }
+      const Variant& value,
+      const VectorPtr& expected) {
+    auto vector = BaseVector::createConstant(type, value, 1, pool());
+
+    EXPECT_TRUE(vector->isConstantEncoding());
+    EXPECT_EQ(vector->type()->toString(), type->toString());
+    EXPECT_TRUE(expected->equalValueAt(vector.get(), 0, 0))
+        << "Expected: " << expected->toString(0)
+        << ", but got: " << vector->toString(0);
+
+    auto copy = vector->variantAt(0);
+    EXPECT_FALSE(copy.isNull());
+    EXPECT_TRUE(copy.isTypeCompatible(type));
+    EXPECT_EQ(copy, value);
   }
 };
 
-TEST_F(VariantToVectorTest, bigint) {
-  testCreateVector<TypeKind::BIGINT>(
-      ARRAY(BIGINT()),
-      {
-          variant::create<TypeKind::BIGINT>(4432),
-          variant::null(TypeKind::BIGINT),
-          variant::create<TypeKind::BIGINT>(-123456789),
-      });
+TEST_F(VariantToVectorTest, integer) {
+  testNull(INTEGER());
+  testValue(
+      INTEGER(),
+      Variant::create<int32_t>(123),
+      makeFlatVector(std::vector<int32_t>{123}));
 }
 
-TEST_F(VariantToVectorTest, integer) {
-  testCreateVector<TypeKind::INTEGER>(
-      ARRAY(INTEGER()),
-      {
-          variant::create<TypeKind::INTEGER>(122133),
-          variant::create<TypeKind::INTEGER>(35121),
-      });
+TEST_F(VariantToVectorTest, decimal) {
+  auto type = DECIMAL(20, 3);
+  testNull(type);
+
+  std::vector<int128_t> data = {1000123};
+  VectorPtr expected = makeFlatVector<int128_t>(data, type);
+  testValue(type, Variant(data[0]), expected);
+
+  std::vector<int128_t> arrayData = {1000123, 1000456, 10000789};
+
+  std::vector<Variant> arrayInputData = {
+      Variant(arrayData[0]), Variant(arrayData[1]), Variant(arrayData[2])};
+  Variant arrayInput = Variant::array(arrayInputData);
+
+  auto expectedVector = makeArrayVector<int128_t>({arrayData}, type);
+  testValue(ARRAY(type), arrayInput, expectedVector);
 }
 
-TEST_F(VariantToVectorTest, smallint) {
-  testCreateVector<TypeKind::SMALLINT>(
-      ARRAY(SMALLINT()),
-      {
-          variant::create<TypeKind::SMALLINT>(123),
-          variant::create<TypeKind::SMALLINT>(-63),
-          variant::null(TypeKind::SMALLINT),
-      });
+TEST_F(VariantToVectorTest, timestamp) {
+  auto type = TIMESTAMP();
+  auto data = util::fromTimestampString(
+                  "2022-06-27 00:00:00", util::TimestampParseMode::kPrestoCast)
+                  .value();
+
+  testNull(type);
+  testValue(type, Variant(data), makeFlatVector<Timestamp>({data}));
 }
 
-TEST_F(VariantToVectorTest, tinyint) {
-  testCreateVector<TypeKind::TINYINT>(
-      ARRAY(TINYINT()),
-      {
-          variant::create<TypeKind::TINYINT>(-12),
-          variant::create<TypeKind::TINYINT>(51),
-      });
+TEST_F(VariantToVectorTest, varchar) {
+  auto type = VARCHAR();
+  testNull(type);
+  testValue(type, Variant("hello"), makeFlatVector<StringView>({"hello"}));
+  testValue(
+      type,
+      Variant("non_inline_string"),
+      makeFlatVector<StringView>({"non_inline_string"}));
 }
 
-TEST_F(VariantToVectorTest, boolean) {
-  testCreateVector<TypeKind::BOOLEAN>(
-      ARRAY(BOOLEAN()),
-      {
-          variant::null(TypeKind::BOOLEAN),
-          variant::create<TypeKind::BOOLEAN>(false),
-          variant::create<TypeKind::BOOLEAN>(true),
-      });
+TEST_F(VariantToVectorTest, array) {
+  auto type = ARRAY(INTEGER());
+  testNull(type);
+
+  testValue(
+      type,
+      Variant::array({1, 2, 3, 4}),
+      makeArrayVectorFromJson<int32_t>({"[1, 2, 3, 4]"}));
+
+  // Empty array.
+  testValue(type, Variant::array({}), makeArrayVectorFromJson<int32_t>({"[]"}));
+
+  // Array with null elements.
+  testValue(
+      type,
+      Variant::array({1, 2, Variant::null(TypeKind::INTEGER), 4}),
+      makeArrayVectorFromJson<int32_t>({"[1, 2, null, 4]"}));
 }
 
-TEST_F(VariantToVectorTest, real) {
-  testCreateVector<TypeKind::REAL>(
-      ARRAY(REAL()),
-      {
-          variant::create<TypeKind::REAL>(-4.78),
-          variant::create<TypeKind::REAL>(123.45),
-      });
+TEST_F(VariantToVectorTest, saveVarcharArrayVector) {
+  auto type = ARRAY(VARCHAR());
+  auto variant =
+      Variant::array({"a", "b", Variant::null(TypeKind::VARCHAR), "d"});
+  auto vectorWithNulls = BaseVector::createConstant(type, variant, 1, pool());
+  std::ostringstream out;
+  saveVector(*vectorWithNulls, out);
+  std::istringstream in(out.str());
+  auto vectorCopy = restoreVector(in, pool());
+  auto variantCopy = vectorCopy->variantAt(0);
+  EXPECT_EQ(variantCopy, variant);
 }
 
-TEST_F(VariantToVectorTest, double) {
-  testCreateVector<TypeKind::DOUBLE>(
-      ARRAY(DOUBLE()),
-      {
-          variant::create<TypeKind::DOUBLE>(-99.948),
-          variant::create<TypeKind::DOUBLE>(-123.456),
-          variant::create<TypeKind::DOUBLE>(78.91),
-          variant::null(TypeKind::DOUBLE),
-      });
+TEST_F(VariantToVectorTest, nestedContainers) {
+  auto type = MAP(DOUBLE(), ARRAY(INTEGER()));
+  testNull(type);
+
+  auto keys = makeFlatVector<double>({1.0, 2.0});
+  std::vector<std::vector<int32_t>> data = {{1, 2, 3, 4}, {2, 3, 4, 5}};
+  auto values = makeArrayVector(data);
+  auto expected = makeMapVector({0}, keys, values);
+
+  auto value = Variant::map(
+      {{1.0, Variant::array({1, 2, 3, 4})},
+       {2.0, Variant::array({2, 3, 4, 5})}});
+
+  testValue(type, value, expected);
 }
 
-TEST_F(VariantToVectorTest, varchar) {
-  testCreateVector<TypeKind::VARCHAR>(
-      ARRAY(VARCHAR()),
-      {
-          variant::create<TypeKind::VARCHAR>("hello"),
-          variant::create<TypeKind::VARCHAR>("world"),
-          variant::create<TypeKind::VARCHAR>(
-              "Some longer string that doesn't get inlined..."),
-      });
+TEST_F(VariantToVectorTest, map) {
+  auto type = MAP(INTEGER(), DOUBLE());
+  testNull(type);
+
+  auto expected = makeMapVectorFromJson<int32_t, double>(
+      {"{1: 1.0, 2: 2.0, 3: 3.0, 4: 4.0}"});
+
+  auto value = Variant::map({
+      {1, 1.0},
+      {2, 2.0},
+      {3, 3.0},
+      {4, 4.0},
+  });
+  testValue(type, value, expected);
+}
+
+TEST_F(VariantToVectorTest, row) {
+  auto type = ROW({"a", "b"}, {INTEGER(), DOUBLE()});
+  testNull(type);
+
+  auto expected = makeRowVector({
+      makeFlatVector(std::vector<int32_t>{1}),
+      makeFlatVector(std::vector<double>{1.0}),
+  });
+
+  testValue(type, Variant::row({1, 1.0}), expected);
 }
 
-TEST_F(VariantToVectorTest, varbinary) {
-  testCreateVector<TypeKind::VARBINARY>(
-      ARRAY(VARBINARY()),
-      {
-          variant::create<TypeKind::VARBINARY>("hello"),
-          variant::create<TypeKind::VARBINARY>("world"),
-          variant::create<TypeKind::VARBINARY>(
-              "Some longer string that doesn't get inlined..."),
-      });
+TEST_F(VariantToVectorTest, rowOfComplexTypes) {
+  auto type = ROW({"a", "b"}, {ARRAY(INTEGER()), MAP(INTEGER(), DOUBLE())});
+  testNull(type);
+
+  auto expected = makeRowVector(
+      {makeArrayVectorFromJson<int32_t>({"[1, 2, 3, 4]"}),
+       makeMapVectorFromJson<int32_t, double>(
+           {"{1: 1.0, 2: 2.0, 3: 3.0, 4: 4.0}"})});
+
+  auto row = Variant::row({
+      Variant::array({1, 2, 3, 4}),
+      Variant::map({{1, 1.0}, {2, 2.0}, {3, 3.0}, {4, 4.0}}),
+  });
+
+  testValue(type, row, expected);
 }
 
-TEST_F(VariantToVectorTest, empty) {
-  testCreateVector<TypeKind::BIGINT>(ARRAY(BIGINT()), {});
+struct OpaqueValue {
+  int value;
+  explicit OpaqueValue(int v) : value{v} {}
+};
+
+TEST_F(VariantToVectorTest, opaque) {
+  auto type = OPAQUE<OpaqueValue>();
+  testNull(type);
+
+  auto data = std::make_shared<OpaqueValue>(1);
+  auto expected = makeFlatVector<std::shared_ptr<void>>({data});
+
+  testValue(type, Variant::opaque(data), expected);
 }
+
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/vector/tests/VectorMakerTest.cpp b/velox/vector/tests/VectorMakerTest.cpp
index 0e7fbc488b51..6b0eee31c229 100644
--- a/velox/vector/tests/VectorMakerTest.cpp
+++ b/velox/vector/tests/VectorMakerTest.cpp
@@ -139,16 +139,17 @@ TEST_F(VectorMakerTest, flatVectorStringNullableTypes) {
       maker_.flatVectorNullable<const char*>({"hello", std::nullopt, "world"}));
 
   // std::string
-  validate(maker_.flatVectorNullable(std::vector<std::optional<std::string>>(
-      {"hello", std::nullopt, "world"})));
+  validate(maker_.flatVectorNullable(
+      std::vector<std::optional<std::string>>(
+          {"hello", std::nullopt, "world"})));
 
   // StringView
   validate(
       maker_.flatVectorNullable<StringView>({"hello", std::nullopt, "world"}));
 
   // std::string_view
-  validate(
-      maker_.flatVectorNullable(std::vector<std::optional<std::string_view>>(
+  validate(maker_.flatVectorNullable(
+      std::vector<std::optional<std::string_view>>(
           {"hello", std::nullopt, "world"})));
 }
 
@@ -693,16 +694,6 @@ TEST_F(VectorMakerTest, mapVectorUsingKeyValueVectorsUnevenKeysValues) {
   EXPECT_THROW(maker_.mapVector({0, 2, 4}, keys, values), VeloxRuntimeError);
 }
 
-TEST_F(VectorMakerTest, mapVectorUsingKeyValueVectorsNullsInvalidIndices) {
-  auto keys = maker_.flatVector<int32_t>({0, 1, 2, 3, 4, 5});
-  auto values = maker_.flatVector<int64_t>({6, 7, 8, 9, 10, 11});
-
-  // The middle map is NULL, but according to the offsets it has size 2, this
-  // should fail.
-  EXPECT_THROW(
-      maker_.mapVector({0, 2, 4}, keys, values, {1}), VeloxRuntimeError);
-}
-
 TEST_F(VectorMakerTest, mapVectorStringString) {
   auto mapVector = maker_.mapVector<std::string, std::string>({
       {{"a", "1"}, {"b", "2"}},
diff --git a/velox/vector/tests/VectorPoolTest.cpp b/velox/vector/tests/VectorPoolTest.cpp
index 4f5d4691fc91..acb018cc5f36 100644
--- a/velox/vector/tests/VectorPoolTest.cpp
+++ b/velox/vector/tests/VectorPoolTest.cpp
@@ -110,7 +110,9 @@ TEST_F(VectorPoolTest, vectorRecycler) {
 
   // Empty scoped vector does nothing.
   VectorPtr vectorPtr;
-  { VectorRecycler vectorRecycler(vectorPtr, &vectorPool); }
+  {
+    VectorRecycler vectorRecycler(vectorPtr, &vectorPool);
+  }
 
   // Get new vector from the pool and release it back.
   BaseVector* rawPtr;
diff --git a/velox/vector/tests/VectorRetainedSizeTest.cpp b/velox/vector/tests/VectorRetainedSizeTest.cpp
new file mode 100644
index 000000000000..5a45d1ffc3b6
--- /dev/null
+++ b/velox/vector/tests/VectorRetainedSizeTest.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/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox::test {
+namespace {
+
+class VectorRetainedSizeTest : public testing::Test,
+                               public velox::test::VectorTestBase {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  uint64_t getTotalStringBufferSize(const VectorPtr& vector) {
+    auto* flatVector = vector->asFlatVector<StringView>();
+    VELOX_CHECK_NOT_NULL(flatVector, nullptr);
+    return flatVector->stringBufferSize();
+  }
+};
+
+} // namespace
+
+TEST_F(VectorRetainedSizeTest, flatNoStrings) {
+  auto vector = makeFlatVector<int32_t>(1'000, folly::identity);
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, flatInlinedStrings) {
+  auto vector = makeFlatVector<std::string>(
+      1'000, [](auto row) { return std::string(row % 3, '.'); });
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, flatMultipleStringBuffers) {
+  auto vector = makeFlatVector<StringView>({});
+  vector->resize(3);
+
+  std::vector<BufferPtr> buffers;
+  for (auto i = 1; i <= 3; ++i) {
+    vector->getBufferWithSpace(i * 100);
+    // Update buffers to hold a shared pointer to every existing string buffer,
+    // so that the next getBufferWithSpace call will create a new buffer.
+    buffers = vector->stringBuffers();
+  }
+  EXPECT_EQ(vector->stringBuffers().size(), 3);
+
+  for (auto& buffer : buffers) {
+    std::string str(100, 'a');
+    memcpy(buffer->asMutable<char>(), str.data(), str.size());
+    vector->setNoCopy(0, StringView(buffer->as<char>(), str.size()));
+  }
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize = getTotalStringBufferSize(vector);
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, constantWithStringBuffer) {
+  auto vector = makeConstant(std::string(100, 'a'), 50);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(
+      totalStringBufferSize,
+      vector->as<ConstantVector<StringView>>()->getStringBuffer()->capacity());
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, constantWithInlinedString) {
+  auto vector = makeConstant("short", 100);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, constantWithValueVector) {
+  auto valueVector = makeFlatVector<std::string>(
+      10, [&](auto /*row*/) { return std::string(100, 'a'); });
+  auto vector =
+      std::make_shared<ConstantVector<StringView>>(pool(), 100, 5, valueVector);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = vector->retainedSize(totalStringBufferSize);
+
+  auto stringBuffer =
+      vector->as<ConstantVector<StringView>>()->getStringBuffer();
+  EXPECT_TRUE(stringBuffer != nullptr);
+  EXPECT_EQ(totalStringBufferSize, stringBuffer->capacity());
+  EXPECT_EQ(retainedSize, vector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, dictionaryWithStrings) {
+  auto baseVector = makeFlatVector<std::string>(
+      1'000, [&](auto /*row*/) { return std::string(100, 'a'); });
+  auto indices = makeIndices(100, folly::identity);
+  auto dictVector = wrapInDictionary(indices, 100, baseVector);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = dictVector->retainedSize(totalStringBufferSize);
+
+  uint64_t expectedBufferSize = getTotalStringBufferSize(baseVector);
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, dictVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, dictionaryNoStrings) {
+  auto baseVector = makeFlatVector<int32_t>(1'000, folly::identity);
+  auto indices = makeIndices(100, folly::identity);
+  auto dictVector = wrapInDictionary(indices, 100, baseVector);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = dictVector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, dictVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, rowVectorMultipleStringChildren) {
+  auto longStringAt = [&](auto /*row*/) { return std::string(100, 'a'); };
+
+  auto rowVector = makeRowVector({
+      makeFlatVector<std::string>(1'000, longStringAt),
+      makeFlatVector<int32_t>(1'000, folly::identity),
+      makeFlatVector<std::string>(1'000, longStringAt),
+  });
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = rowVector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize =
+      getTotalStringBufferSize(rowVector->childAt(0)) +
+      getTotalStringBufferSize(rowVector->childAt(2));
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, rowVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, arrayWithStringElements) {
+  auto arrayVector = makeArrayVector<std::string>(
+      1'000,
+      [](auto /*row*/) { return 3; },
+      [&](auto /*row*/) { return std::string(100, 'a'); });
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = arrayVector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize =
+      getTotalStringBufferSize(arrayVector->elements());
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, arrayVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, arrayNoStrings) {
+  auto arrayVector = makeArrayVector<int32_t>(
+      1'000,
+      [](auto /*row*/) { return 3; },
+      [](auto row, auto index) { return row + index; });
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = arrayVector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, arrayVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, mapWithStringKeysAndValues) {
+  auto longStringAt = [&](auto /*row*/) { return std::string(100, 'a'); };
+
+  auto mapVector = makeMapVector<std::string, std::string>(
+      1'000, [](auto /*row*/) { return 2; }, longStringAt, longStringAt);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = mapVector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize = getTotalStringBufferSize(mapVector->mapKeys()) +
+      getTotalStringBufferSize(mapVector->mapValues());
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, mapVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, nestedComplexWithStrings) {
+  auto innerArray = makeArrayVector<std::string>(
+      1'000,
+      [](auto /*row*/) { return 2; },
+      [&](auto /*row*/) { return std::string(100, 'a'); });
+
+  auto outerArray = makeArrayVector({0, 10, 20}, innerArray);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = outerArray->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize = getTotalStringBufferSize(
+      outerArray->elements()->as<ArrayVector>()->elements());
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, outerArray->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, lazyNotLoaded) {
+  auto lazyVector = std::make_shared<LazyVector>(
+      pool(),
+      VARCHAR(),
+      100,
+      std::make_unique<test::SimpleVectorLoader>([&](auto /*rows*/) {
+        return makeFlatVector<std::string>(
+            100, [&](auto /*row*/) { return std::string(100, 'a'); });
+      }));
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = lazyVector->retainedSize(totalStringBufferSize);
+
+  EXPECT_EQ(totalStringBufferSize, 0);
+  EXPECT_EQ(retainedSize, lazyVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, lazyLoaded) {
+  auto lazyVector = std::make_shared<LazyVector>(
+      pool(),
+      VARCHAR(),
+      100,
+      std::make_unique<test::SimpleVectorLoader>([&](auto /*rows*/) {
+        return makeFlatVector<std::string>(
+            100, [&](auto /*row*/) { return std::string(100, 'a'); });
+      }));
+
+  SelectivityVector rows(100);
+  LazyVector::ensureLoadedRows(lazyVector, rows);
+
+  uint64_t totalStringBufferSize = 0;
+  auto retainedSize = lazyVector->retainedSize(totalStringBufferSize);
+  uint64_t expectedBufferSize =
+      getTotalStringBufferSize(lazyVector->loadedVectorShared());
+
+  EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+  EXPECT_EQ(retainedSize, lazyVector->retainedSize());
+}
+
+TEST_F(VectorRetainedSizeTest, sharedStringBuffers) {
+  auto baseVector = makeFlatVector<std::string>(
+      1'000, [&](auto /*row*/) { return std::string(100, 'a'); });
+
+  auto indices = makeIndices(100, folly::identity);
+  std::vector<VectorPtr> dictionaries;
+  dictionaries.emplace_back(wrapInDictionary(indices, 100, baseVector));
+  dictionaries.emplace_back(wrapInDictionary(indices, 100, baseVector));
+
+  auto expectedBufferSize = getTotalStringBufferSize(baseVector);
+  for (auto& dictVector : dictionaries) {
+    uint64_t totalStringBufferSize = 0;
+    auto retainedSize = dictVector->retainedSize(totalStringBufferSize);
+
+    EXPECT_EQ(totalStringBufferSize, expectedBufferSize);
+    EXPECT_EQ(retainedSize, dictVector->retainedSize());
+  }
+}
+
+} // namespace facebook::velox::test
diff --git a/velox/vector/tests/VectorSaverTest.cpp b/velox/vector/tests/VectorSaverTest.cpp
index 11cdd8fac403..0991f7ee090e 100644
--- a/velox/vector/tests/VectorSaverTest.cpp
+++ b/velox/vector/tests/VectorSaverTest.cpp
@@ -352,8 +352,9 @@ TEST_F(VectorSaverTest, flatBoolean) {
   testRoundTrip(makeFlatVector<bool>({true, false, true, true, false}));
 
   // Some nulls.
-  testRoundTrip(makeNullableFlatVector<bool>(
-      {true, std::nullopt, true, std::nullopt, false}));
+  testRoundTrip(
+      makeNullableFlatVector<bool>(
+          {true, std::nullopt, true, std::nullopt, false}));
 
   // Empty vector.
   testRoundTrip(BaseVector::create(BOOLEAN(), 0, pool()));
@@ -363,8 +364,9 @@ TEST_F(VectorSaverTest, flatBoolean) {
       makeFlatVector<bool>(10'000, [](auto row) { return row % 7 == 2; }));
 
   // Long vector with nulls.
-  testRoundTrip(makeFlatVector<bool>(
-      10'000, [](auto row) { return row % 2 == 1; }, nullEvery(17)));
+  testRoundTrip(
+      makeFlatVector<bool>(
+          10'000, [](auto row) { return row % 2 == 1; }, nullEvery(17)));
 }
 
 TEST_F(VectorSaverTest, flatVarchar) {
@@ -566,14 +568,15 @@ TEST_F(VectorSaverTest, dictionaryArray) {
   auto offsets = makeEvenIndices(64);
   auto sizes = makeIndices(64, [](auto /* row */) { return 2; });
 
-  testRoundTrip(std::make_shared<ArrayVector>(
-      pool(),
-      ARRAY(INTEGER()),
-      makeNulls(64, nullEvery(7)),
-      64,
-      offsets,
-      sizes,
-      elementsVector));
+  testRoundTrip(
+      std::make_shared<ArrayVector>(
+          pool(),
+          ARRAY(INTEGER()),
+          makeNulls(64, nullEvery(7)),
+          64,
+          offsets,
+          sizes,
+          elementsVector));
 }
 
 TEST_F(VectorSaverTest, dictionaryMap) {
diff --git a/velox/vector/tests/VectorStreamGroupTest.cpp b/velox/vector/tests/VectorStreamGroupTest.cpp
new file mode 100644
index 000000000000..55e0009d5246
--- /dev/null
+++ b/velox/vector/tests/VectorStreamGroupTest.cpp
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES 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 <cstdint>
+#include "velox/common/base/tests/GTestUtils.h"
+#include "velox/serializers/CompactRowSerializer.h"
+#include "velox/serializers/PrestoSerializer.h"
+#include "velox/serializers/UnsafeRowSerializer.h"
+#include "velox/vector/VectorStream.h"
+#include "velox/vector/fuzzer/VectorFuzzer.h"
+#include "velox/vector/tests/utils/VectorTestBase.h"
+
+namespace facebook::velox {
+namespace {
+class VectorStreamGroupTest
+    : public testing::Test,
+      public velox::test::VectorTestBase,
+      public testing::WithParamInterface<VectorSerde::Kind> {
+ protected:
+  static void SetUpTestCase() {
+    memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+  }
+
+  void SetUp() override {
+    if (isRegisteredNamedVectorSerde(VectorSerde::Kind::kPresto)) {
+      deregisterNamedVectorSerde(VectorSerde::Kind::kPresto);
+    }
+    serializer::presto::PrestoVectorSerde::registerNamedVectorSerde();
+
+    if (isRegisteredNamedVectorSerde(VectorSerde::Kind::kCompactRow)) {
+      deregisterNamedVectorSerde(VectorSerde::Kind::kCompactRow);
+    }
+    serializer::CompactRowVectorSerde::registerNamedVectorSerde();
+
+    if (isRegisteredNamedVectorSerde(VectorSerde::Kind::kUnsafeRow)) {
+      deregisterNamedVectorSerde(VectorSerde::Kind::kUnsafeRow);
+    }
+    serializer::spark::UnsafeRowVectorSerde::registerNamedVectorSerde();
+  }
+
+  std::unique_ptr<ByteInputStream> prepareInput(std::string& string) {
+    const int32_t size = string.size();
+    std::vector<ByteRange> ranges;
+    for (int32_t i = 0; i < 10; ++i) {
+      int32_t start = i * (size / 10);
+      int32_t end = (i == 9) ? size : (i + 1) * (size / 10);
+      ranges.emplace_back();
+      ranges.back().buffer = reinterpret_cast<uint8_t*>(&string[start]);
+      ranges.back().size = end - start;
+      ranges.back().position = 0;
+    }
+    return std::make_unique<BufferInputStream>(std::move(ranges));
+  }
+};
+
+TEST_P(VectorStreamGroupTest, clear) {
+  const auto dataType = ROW({BIGINT()});
+  const int numBatches = 10;
+  const int vectorSize = 100;
+  VectorFuzzer::Options opts;
+  opts.vectorSize = vectorSize;
+  VectorFuzzer fuzzer(opts, pool());
+  std::vector<RowVectorPtr> inputVectors;
+  inputVectors.reserve(10);
+  for (int i = 0; i < numBatches; ++i) {
+    inputVectors.push_back(fuzzer.fuzzInputRow(dataType));
+  }
+  VectorStreamGroup vectorGroup(pool(), getNamedVectorSerde(GetParam()));
+  vectorGroup.createStreamTree(dataType, numBatches * vectorSize);
+  for (int i = 0; i < numBatches; ++i) {
+    vectorGroup.append(inputVectors[i]);
+  }
+  std::stringstream output;
+  OStreamOutputStream outputStream(&output);
+  vectorGroup.flush(&outputStream);
+  vectorGroup.clear();
+  if (GetParam() == VectorSerde::Kind::kPresto) {
+    // We expect two pages for header after clear.
+    ASSERT_EQ(
+        vectorGroup.size(),
+        memory::AllocationTraits::pageBytes(
+            vectorGroup.testingAllocationQuantum()));
+  } else {
+    ASSERT_EQ(vectorGroup.size(), 0);
+  }
+  auto outputStr = output.str();
+  RowVectorPtr resultRow;
+  auto deserializeInput = prepareInput(outputStr);
+  VectorStreamGroup::read(
+      deserializeInput.get(),
+      pool(),
+      dataType,
+      getNamedVectorSerde(GetParam()),
+      &resultRow,
+      nullptr);
+  ASSERT_EQ(resultRow->size(), numBatches * vectorSize);
+}
+
+VELOX_INSTANTIATE_TEST_SUITE_P(
+    VectorStreamGroupTest,
+    VectorStreamGroupTest,
+    testing::ValuesIn(
+        {VectorSerde::Kind::kPresto,
+         VectorSerde::Kind::kCompactRow,
+         VectorSerde::Kind::kUnsafeRow}));
+} // namespace
+} // namespace facebook::velox
diff --git a/velox/vector/tests/VectorTest.cpp b/velox/vector/tests/VectorTest.cpp
index 2ca313f52ffa..524039e65d91 100644
--- a/velox/vector/tests/VectorTest.cpp
+++ b/velox/vector/tests/VectorTest.cpp
@@ -22,8 +22,10 @@
 #include <optional>
 
 #include "velox/common/base/tests/GTestUtils.h"
+#include "velox/common/fuzzer/Utils.h"
 #include "velox/common/memory/ByteStream.h"
 #include "velox/common/testutil/OptionalEmpty.h"
+#include "velox/common/testutil/TestValue.h"
 #include "velox/serializers/PrestoSerializer.h"
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/ComplexVector.h"
@@ -34,6 +36,7 @@
 #include "velox/vector/SelectivityVector.h"
 #include "velox/vector/SimpleVector.h"
 #include "velox/vector/TypeAliases.h"
+#include "velox/vector/VariantToVector.h"
 #include "velox/vector/VectorTypeUtils.h"
 #include "velox/vector/tests/utils/VectorTestBase.h"
 
@@ -65,6 +68,10 @@ class TestingLoader : public VectorLoader {
     return rowCounter_;
   }
 
+  bool supportsHook() const override {
+    return true;
+  }
+
  private:
   template <TypeKind Kind>
   void applyHook(RowSet rows, ValueHook* hook) {
@@ -112,6 +119,7 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
  protected:
   static void SetUpTestCase() {
     memory::MemoryManager::testingSetInstance(memory::MemoryManager::Options{});
+    common::testutil::TestValue::enable();
   }
 
   void SetUp() override {
@@ -291,6 +299,24 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
       EXPECT_EQ(flat->valueAt(size * 2 - 1).size(), 0);
     }
 
+// This part of the test relies on TestValues to inject a failure, these are
+// only enabled in debug builds.
+#ifndef NDEBUG
+    {
+      // Make a copy so we don't modify the original Vector.
+      const auto slice = flat->slice(0, flat->size());
+
+      const std::string errorMessage = "Simulated failure in memory allocation";
+      SCOPED_TESTVALUE_SET(
+          "facebook::velox::FlatVector::resizeValues",
+          std::function<void(FlatVector<T>*)>(
+              [&](FlatVector<T>*) { VELOX_FAIL(errorMessage); }));
+
+      VELOX_ASSERT_THROW(slice->resize(slice->size() * 2), errorMessage);
+      slice->validate();
+    }
+#endif
+
     // Fill, the values at size * 2 - 1 gets assigned a second time.
     for (int32_t i = 0; i < flat->size(); ++i) {
       if (withNulls && i % 3 == 0) {
@@ -663,11 +689,12 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
       int level,
       vector_size_t offset,
       vector_size_t length) {
-    SCOPED_TRACE(fmt::format(
-        "testSlice encoding={} offset={} length={}",
-        vec->encoding(),
-        offset,
-        length));
+    SCOPED_TRACE(
+        fmt::format(
+            "testSlice encoding={} offset={} length={}",
+            vec->encoding(),
+            offset,
+            length));
     ASSERT_GE(vec->size(), offset + length);
     auto slice = vec->loadedVector()->slice(offset, length);
     ASSERT_EQ(slice->size(), length);
@@ -743,14 +770,17 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
       // immutable. This is true for a slice since it creates buffer views over
       // the buffers of the original vector that it sliced.
       auto newSize = slice->size() * 2;
+      auto sliceCopy = BaseVector::copy(*slice);
       slice->resize(newSize);
       EXPECT_EQ(slice->size(), newSize);
+      slice->resize(sliceCopy->size());
+      test::assertEqualVectors(slice, sliceCopy);
     }
   }
 
   static void testSlices(const VectorPtr& slice, int level = 2) {
     for (vector_size_t offset : {0, 16, 17}) {
-      for (vector_size_t length : {0, 1, 83}) {
+      for (vector_size_t length : {0, 1, 83, 100}) {
         if (offset + length <= slice->size()) {
           testSlice(slice, level, offset, length);
         }
@@ -871,6 +901,17 @@ class VectorTest : public testing::Test, public velox::test::VectorTestBase {
     OStreamOutputStream oddOutputStream(&oddStream);
     even.flush(&evenOutputStream);
     odd.flush(&oddOutputStream);
+    ASSERT_GT(even.size(), 0);
+    even.clear();
+    // We expect two pages for header after clear.
+    ASSERT_EQ(
+        even.size(),
+        memory::AllocationTraits::pageBytes(even.testingAllocationQuantum()));
+    ASSERT_GT(odd.size(), 0);
+    odd.clear();
+    ASSERT_EQ(
+        odd.size(),
+        memory::AllocationTraits::pageBytes(odd.testingAllocationQuantum()));
 
     auto evenString = evenStream.str();
     checkSizes(source.get(), evenSizes, evenString);
@@ -1472,16 +1513,6 @@ TEST_F(VectorTest, wrapInConstant) {
     ASSERT_TRUE(constArrayVector->equalValueAt(arrayVector.get(), i, 3));
   }
 
-  // Wrap constant with valueVector and null value.
-  constBaseVector = std::make_shared<ConstantVector<ComplexType>>(
-      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.
@@ -1497,78 +1528,6 @@ TEST_F(VectorTest, wrapInConstant) {
   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 constVector = std::dynamic_pointer_cast<ConstantVector<int32_t>>(
-      BaseVector::wrapInConstant(size, 5, flatVector, true));
-  EXPECT_EQ(constVector->valueVector(), nullptr);
-  for (auto i = 0; i < size; i++) {
-    ASSERT_FALSE(constVector->isNullAt(i));
-    ASSERT_EQ(5, constVector->valueAt(i));
-  }
-
-  constVector = std::dynamic_pointer_cast<ConstantVector<int32_t>>(
-      BaseVector::wrapInConstant(size, 7, flatVector, true));
-  EXPECT_EQ(constVector->valueVector(), nullptr);
-  for (auto i = 0; i < size; i++) {
-    ASSERT_TRUE(constVector->isNullAt(i));
-  }
-
-  // Wrap dictionary vector.
-  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 = allocateNulls(size, pool());
-  auto rawNulls = nulls->asMutable<uint64_t>();
-  for (auto i = 0; i < size; i++) {
-    bits::setNull(rawNulls, i, i % 11 == 0);
-  }
-
-  auto dictVector =
-      BaseVector::wrapInDictionary(nulls, indices, size, flatVector);
-
-  constVector = std::dynamic_pointer_cast<ConstantVector<int32_t>>(
-      BaseVector::wrapInConstant(size, 5, dictVector, true));
-  EXPECT_EQ(constVector->valueVector(), nullptr);
-  for (auto i = 0; i < size; i++) {
-    ASSERT_FALSE(constVector->isNullAt(i));
-    ASSERT_EQ(10, constVector->valueAt(i));
-  }
-
-  // Wrap constant with valueVector.
-  auto arrayVector = makeArrayVector<int32_t>(
-      size, [](auto) { return 10; }, [](auto i) { return i; }, nullEvery(7));
-  auto constBaseVector = std::make_shared<ConstantVector<ComplexType>>(
-      pool(), size, 3, arrayVector);
-  auto constArrayVector =
-      std::dynamic_pointer_cast<ConstantVector<ComplexType>>(
-          BaseVector::wrapInConstant(size, 22, constBaseVector, true));
-  EXPECT_NE(constArrayVector->valueVector(), nullptr);
-  EXPECT_EQ(constArrayVector->valueVector().use_count(), 1);
-  for (auto i = 0; i < size; i++) {
-    ASSERT_FALSE(constArrayVector->isNullAt(i));
-    ASSERT_TRUE(constArrayVector->equalValueAt(arrayVector.get(), i, 3));
-  }
-
-  // Wrap constant with valueVector and null value.
-  constBaseVector = std::make_shared<ConstantVector<ComplexType>>(
-      pool(), size, 7, arrayVector);
-  constArrayVector = std::dynamic_pointer_cast<ConstantVector<ComplexType>>(
-      BaseVector::wrapInConstant(size, 22, constBaseVector, true));
-  EXPECT_NE(constArrayVector->valueVector(), nullptr);
-  EXPECT_EQ(constArrayVector->valueVector().use_count(), 1);
-  for (auto i = 0; i < size; i++) {
-    ASSERT_TRUE(constArrayVector->isNullAt(i));
-  }
-}
-
 TEST_F(VectorTest, rowResize) {
   auto testRowResize = [&](const VectorPtr& vector, bool setNotNull) {
     auto rowVector = vector->as<RowVector>();
@@ -1675,6 +1634,15 @@ TEST_F(VectorTest, rowPrepareForReuse) {
   }
 }
 
+TEST_F(VectorTest, makeFlatVectorWithInitializerList) {
+  auto vector = makeFlatVector<int64_t>({803});
+
+  ASSERT_NE(vector, nullptr);
+  EXPECT_EQ(vector->size(), 1);
+
+  EXPECT_EQ(vector->asFlatVector<int64_t>()->valueAt(0), 803);
+}
+
 TEST_F(VectorTest, wrapConstantInDictionary) {
   // Wrap Constant in Dictionary with no extra nulls. Expect Constant.
   auto indices = makeIndices(10, [](auto row) { return row % 2; });
@@ -2007,6 +1975,8 @@ TEST_F(VectorCreateConstantTest, complex) {
   testComplexConstant<TypeKind::ROW>(
       ROW({{"c0", INTEGER()}}),
       makeRowVector({makeFlatVector<int32_t>(1, [](auto i) { return i; })}));
+
+  testComplexConstant<TypeKind::ROW>(ROW({}), makeRowVector(ROW({}), 1));
 }
 
 TEST_F(VectorCreateConstantTest, null) {
@@ -2030,6 +2000,7 @@ TEST_F(VectorCreateConstantTest, null) {
   testNullConstant<TypeKind::VARBINARY>(VARBINARY());
 
   testNullConstant<TypeKind::ROW>(ROW({BIGINT(), REAL()}));
+  testNullConstant<TypeKind::ROW>(ROW({}));
   testNullConstant<TypeKind::ARRAY>(ARRAY(DOUBLE()));
   testNullConstant<TypeKind::MAP>(MAP(INTEGER(), DOUBLE()));
 }
@@ -2053,6 +2024,7 @@ class TestingHook : public ValueHook {
       }
     }
   }
+
   int32_t errors() const {
     return errors_;
   }
@@ -2284,8 +2256,9 @@ TEST_F(VectorTest, nestedLazy) {
 
   // Verify that the unloaded dictionary can be nested as long as it has one top
   // level vector.
-  EXPECT_NO_THROW(BaseVector::wrapInDictionary(
-      nullptr, makeIndices(size, indexAt), size, dict));
+  EXPECT_NO_THROW(
+      BaseVector::wrapInDictionary(
+          nullptr, makeIndices(size, indexAt), size, dict));
 
   // Limitation: Current checks cannot prevent existing references of the lazy
   // vector to load rows. For example, the following would succeed even though
@@ -2734,14 +2707,16 @@ TEST_F(VectorTest, testCopyWithZeroCount) {
   runTest(makeFlatVector<int32_t>({1, 2}));
 
   // Complex types.
-  runTest(makeArrayVector<int32_t>(
-      1, [](auto) { return 10; }, [](auto i) { return i; }));
+  runTest(
+      makeArrayVector<int32_t>(
+          1, [](auto) { return 10; }, [](auto i) { return i; }));
 
-  runTest(makeMapVector<int32_t, float>(
-      1,
-      [](auto) { return 10; },
-      [](auto i) { return i; },
-      [](auto i) { return i; }));
+  runTest(
+      makeMapVector<int32_t, float>(
+          1,
+          [](auto) { return 10; },
+          [](auto i) { return i; },
+          [](auto i) { return i; }));
 
   runTest(
       makeRowVector({makeFlatVector<int32_t>(1, [](auto i) { return i; })}));
@@ -2775,24 +2750,43 @@ TEST_F(VectorTest, flattenVector) {
 
   VectorPtr lazy = std::make_shared<LazyVector>(
       pool(), INTEGER(), flat->size(), std::make_unique<TestingLoader>(flat));
-  test(lazy, true);
+  test(lazy, false);
 
-  // Constant
+  // Constant.
   VectorPtr constant = BaseVector::wrapInConstant(100, 1, flat);
   test(constant, false);
   EXPECT_TRUE(constant->isFlatEncoding());
 
-  // Dictionary
+  // Dictionary.
   VectorPtr dictionary = BaseVector::wrapInDictionary(
       nullptr, makeIndices(100, [](auto row) { return row % 2; }), 100, flat);
   test(dictionary, false);
   EXPECT_TRUE(dictionary->isFlatEncoding());
 
+  // Lazy dictionary.
   VectorPtr lazyDictionary =
       wrapInLazyDictionary(makeFlatVector<int32_t>({1, 2, 3}));
-  test(lazyDictionary, true);
-  EXPECT_TRUE(lazyDictionary->isLazy());
-  EXPECT_TRUE(lazyDictionary->loadedVector()->isFlatEncoding());
+  test(lazyDictionary, false);
+  EXPECT_TRUE(lazyDictionary->isFlatEncoding());
+
+  // Lazy dictionary row, where children are also lazy dictionaries.
+  VectorPtr rowWithLazyDictionaryChildren = wrapInLazyDictionary(makeRowVector(
+      {wrapInLazyDictionary(makeFlatVector<int32_t>({1, 2, 3})),
+       wrapInLazyDictionary(array),
+       wrapInLazyDictionary(map)}));
+  test(rowWithLazyDictionaryChildren, false);
+  EXPECT_EQ(
+      rowWithLazyDictionaryChildren->encoding(), VectorEncoding::Simple::ROW);
+  RowVector* rowWithLazyDictionaryChildrenRowVector =
+      rowWithLazyDictionaryChildren->as<RowVector>();
+  EXPECT_TRUE(
+      rowWithLazyDictionaryChildrenRowVector->childAt(0)->isFlatEncoding());
+  EXPECT_EQ(
+      rowWithLazyDictionaryChildrenRowVector->childAt(1)->encoding(),
+      VectorEncoding::Simple::ARRAY);
+  EXPECT_EQ(
+      rowWithLazyDictionaryChildrenRowVector->childAt(2)->encoding(),
+      VectorEncoding::Simple::MAP);
 
   // Array with constant elements.
   auto* arrayVector = array->as<ArrayVector>();
@@ -3270,26 +3264,19 @@ TEST_F(VectorTest, mutableValues) {
   auto vector = makeFlatVector<int64_t>(1'000, [](auto row) { return row; });
 
   auto* rawValues = vector->rawValues();
-  vector->mutableValues(1'001);
+  vector->mutableValues();
   ASSERT_EQ(rawValues, vector->rawValues());
   for (auto i = 0; i < 1'000; ++i) {
     EXPECT_EQ(rawValues[i], i);
   }
 
-  vector->mutableValues(10'000);
-  ASSERT_NE(rawValues, vector->rawValues());
-  rawValues = vector->rawValues();
-  for (auto i = 0; i < 1'000; ++i) {
-    EXPECT_EQ(rawValues[i], i);
-  }
-
-  auto values = vector->mutableValues(2'000);
+  auto values = vector->mutableValues();
   ASSERT_EQ(rawValues, vector->rawValues());
   for (auto i = 0; i < 1'000; ++i) {
     EXPECT_EQ(rawValues[i], i);
   }
 
-  vector->mutableValues(500);
+  vector->mutableValues();
   ASSERT_NE(rawValues, vector->rawValues());
   rawValues = vector->rawValues();
   for (auto i = 0; i < 500; ++i) {
@@ -3643,6 +3630,81 @@ TEST_F(VectorTest, flatAllNulls) {
   }
 }
 
+TEST_F(VectorTest, hashValueAtArray) {
+  auto data = makeArrayVectorFromJson<int32_t>({
+      "[1, 2, 3]",
+      "[2, 1, 3]",
+      "[3, 2, 1]",
+      "[1, 2, 3, 4]",
+      "[1, null, 3]",
+      "[1, 2, 3]",
+  });
+
+  std::unordered_set<uint64_t> hashes;
+  for (auto i = 0; i < 5; ++i) {
+    EXPECT_TRUE(hashes.insert(data->hashValueAt(i)).second);
+  }
+  EXPECT_EQ(5, hashes.size());
+
+  EXPECT_EQ(data->hashValueAt(0), data->hashValueAt(5));
+}
+
+TEST_F(VectorTest, hashValueAtMap) {
+  auto data = makeMapVectorFromJson<int32_t, int32_t>({
+      "{1: 10, 2: 20}",
+      "{1: 20, 2: 10}",
+      "{10: 1, 20: 2}",
+      "{1: 2, 3: 4}",
+      "{1: 2, 3: 4, 5: 6}",
+      "{2: 20, 1: 10}",
+  });
+
+  std::unordered_set<uint64_t> hashes;
+  for (auto i = 0; i < 5; ++i) {
+    EXPECT_TRUE(hashes.insert(data->hashValueAt(i)).second);
+  }
+  EXPECT_EQ(5, hashes.size());
+
+  EXPECT_EQ(data->hashValueAt(0), data->hashValueAt(5));
+}
+
+TEST_F(VectorTest, variantHashMatchesVectorHash) {
+  auto flat = makeNullableFlatVector<int64_t>({1, std::nullopt, 3});
+  for (vector_size_t i = 0; i < flat->size(); ++i) {
+    auto v = flat->variantAt(i);
+    EXPECT_EQ(flat->hashValueAt(i), v.hash()) << "at " << i;
+  }
+
+  auto array = makeArrayVectorFromJson<int64_t>({
+      "[1, 2, 3]",
+      "null",
+      "[1, null, 3]",
+  });
+  for (vector_size_t i = 0; i < array->size(); ++i) {
+    auto v = array->variantAt(i);
+    EXPECT_EQ(array->hashValueAt(i), v.hash()) << "at " << i;
+  }
+
+  auto map = makeMapVectorFromJson<int64_t, int64_t>({
+      "{1: 10}",
+      "null",
+      "{1: null}",
+  });
+  for (vector_size_t i = 0; i < map->size(); ++i) {
+    auto v = map->variantAt(i);
+    EXPECT_EQ(map->hashValueAt(i), v.hash()) << "at " << i;
+  }
+
+  auto child1 = makeFlatVector<int64_t>({1, 2, 3});
+  auto child2 = makeNullableFlatVector<int64_t>({4, 5, std::nullopt});
+  auto row =
+      makeRowVector({child1, child2}, [](vector_size_t i) { return i == 1; });
+  for (vector_size_t i = 0; i < row->size(); ++i) {
+    auto v = row->variantAt(i);
+    EXPECT_EQ(row->hashValueAt(i), v.hash()) << "at " << i;
+  }
+}
+
 TEST_F(VectorTest, hashAll) {
   auto data = makeFlatVector<int32_t>({1, 2, 3});
   ASSERT_TRUE(data->getNullCount().has_value());
@@ -3662,11 +3724,40 @@ TEST_F(VectorTest, hashAll) {
 }
 
 TEST_F(VectorTest, setType) {
+  std::function<void(const VectorPtr&, const TypePtr&)> checkType =
+      [&](const VectorPtr& vector, const TypePtr& type) {
+        EXPECT_EQ(vector->type()->toString(), type->toString());
+        switch (vector->typeKind()) {
+          case TypeKind::ROW: {
+            auto rowVector = vector->as<RowVector>();
+            for (auto i = 0; i < rowVector->childrenSize(); ++i) {
+              auto& child = rowVector->childAt(i);
+              if (child) {
+                checkType(child, type->childAt(i));
+              }
+            }
+            break;
+          }
+          case TypeKind::ARRAY: {
+            checkType(vector->as<ArrayVector>()->elements(), type->childAt(0));
+            break;
+          }
+          case TypeKind::MAP: {
+            auto mapVector = vector->as<MapVector>();
+            checkType(mapVector->mapKeys(), type->childAt(0));
+            checkType(mapVector->mapValues(), type->childAt(1));
+            break;
+          }
+          default:
+            break;
+        }
+      };
+
   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());
+    checkType(vector, newType);
 
     VELOX_ASSERT_RUNTIME_THROW(
         vector->setType(invalidNewType),
@@ -3716,6 +3807,21 @@ TEST_F(VectorTest, setType) {
                ROW({"ee", "ff"}, {VARCHAR(), BIGINT()})),
            BIGINT()});
   test(type, newType, invalidNewType);
+
+  // Row with missing fields
+  type = ROW({"a", "b"}, {BIGINT(), BIGINT()});
+  newType = ROW({"aa", "bb"}, {BIGINT(), BIGINT()});
+  auto vector = std::make_shared<RowVector>(
+      pool(),
+      type,
+      nullptr,
+      1,
+      std::vector<VectorPtr>{
+          BaseVector::create(BIGINT(), 1, pool()),
+          nullptr,
+      });
+  vector->setType(newType);
+  checkType(vector, newType);
 }
 
 TEST_F(VectorTest, getLargeStringBuffer) {
@@ -3726,20 +3832,45 @@ TEST_F(VectorTest, getLargeStringBuffer) {
 }
 
 TEST_F(VectorTest, mapUpdate) {
-  auto base = makeNullableMapVector<int64_t, int64_t>({
+  auto verifyUpdate =
+      [](MapVectorPtr& base, MapVectorPtr& update, MapVectorPtr& expected) {
+        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));
+        }
+      };
+
+  auto baseNoNulls = makeMapVector<int64_t, int64_t>({
+      {{{1, 1}, {2, 1}}},
+      common::testutil::Empty,
+      {{{3, 1}}},
+      {{{4, 1}}},
+      {{{4, 1}}},
+  });
+  auto updateNoNulls = makeMapVector<int64_t, int64_t>({
+      {{{2, 2}, {3, 2}}},
+      {{{4, 2}}},
+      common::testutil::Empty,
+      {{{5, 2}}},
+      {{{4, 1}}},
+  });
+  auto baseWithNulls = makeNullableMapVector<int64_t, int64_t>({
       {{{1, 1}, {2, 1}}},
       common::testutil::optionalEmpty,
       {{{3, 1}}},
       std::nullopt,
       {{{4, 1}}},
   });
-  auto update = makeNullableMapVector<int64_t, int64_t>({
+  auto updateWithNulls = makeNullableMapVector<int64_t, int64_t>({
       {{{2, 2}, {3, 2}}},
       {{{4, 2}}},
       common::testutil::optionalEmpty,
       {{{5, 2}}},
       std::nullopt,
   });
+
+  // Case 1: Both base and update have nulls
   auto expected = makeNullableMapVector<int64_t, int64_t>({
       {{{2, 2}, {3, 2}, {1, 1}}},
       {{{4, 2}}},
@@ -3747,11 +3878,35 @@ TEST_F(VectorTest, mapUpdate) {
       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));
-  }
+  verifyUpdate(baseWithNulls, updateWithNulls, expected);
+
+  // Case 2: Only base has nulls
+  expected = makeNullableMapVector<int64_t, int64_t>({
+      {{{2, 2}, {3, 2}, {1, 1}}},
+      {{{4, 2}}},
+      {{{3, 1}}},
+      std::nullopt,
+      {{{4, 1}}},
+  });
+  verifyUpdate(baseWithNulls, updateNoNulls, expected);
+  // Case 3: Only update has nulls
+  expected = makeNullableMapVector<int64_t, int64_t>({
+      {{{2, 2}, {3, 2}, {1, 1}}},
+      {{{4, 2}}},
+      {{{3, 1}}},
+      {{{4, 1}, {5, 2}}},
+      std::nullopt,
+  });
+  verifyUpdate(baseNoNulls, updateWithNulls, expected);
+  // Case 4: Both base and update do not have nulls
+  expected = makeNullableMapVector<int64_t, int64_t>({
+      {{{2, 2}, {3, 2}, {1, 1}}},
+      {{{4, 2}}},
+      {{{3, 1}}},
+      {{{4, 1}, {5, 2}}},
+      {{{4, 1}}},
+  });
+  verifyUpdate(baseNoNulls, updateNoNulls, expected);
 }
 
 TEST_F(VectorTest, mapUpdateRowKeyType) {
@@ -3883,6 +4038,27 @@ TEST_F(VectorTest, mapUpdateDictionary) {
   test::assertEqualVectors(expected, actual);
 }
 
+TEST_F(VectorTest, ensureNullRowsEmpty) {
+  constexpr int kSize = 10;
+  ArrayVector vector(
+      pool(),
+      ARRAY(BIGINT()),
+      makeNulls(kSize, nullEvery(3)),
+      kSize,
+      makeIndices(kSize, [](auto i) { return i; }),
+      makeIndices(kSize, [](auto) { return 1; }),
+      makeFlatVector<int64_t>(kSize, [](auto i) { return i; }));
+  ASSERT_EQ(vector.sizeAt(3), 1);
+  ASSERT_EQ(vector.offsetAt(3), 3);
+  vector.ensureNullRowsEmpty();
+  for (int i = 0; i < kSize; ++i) {
+    if (vector.isNullAt(i)) {
+      ASSERT_EQ(vector.sizeAt(i), 0);
+      ASSERT_EQ(vector.offsetAt(i), 0);
+    }
+  }
+}
+
 TEST_F(VectorTest, pushDictionaryToRowVectorLeaves) {
   auto iota = makeFlatVector<int64_t>(10, folly::identity);
   auto output = RowVector::pushDictionaryToRowVectorLeaves(iota);
@@ -4143,5 +4319,200 @@ TEST_F(VectorTest, estimateFlatSize) {
   arrayVector->prepareForReuse();
 }
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+TEST_F(VectorTest, transferOrCopyTo) {
+  auto rootPool = memory::memoryManager()->addRootPool("long-living");
+  auto pool = rootPool->addLeafChild("long-living leaf");
+  memory::MemoryManager anotherManager{memory::MemoryManager::Options{}};
+
+  VectorPtr vector;
+  VectorPtr expected;
+
+  // Test primitive type.
+  auto testPrimitive = [&](memory::MemoryManager* memoryManager) {
+    std::vector<int64_t> c0;
+    std::vector<std::string> c1;
+    {
+      auto localRootPool = memoryManager->addRootPool("short-living");
+      auto localPool = localRootPool->addLeafChild("short-living leaf");
+      FuzzerGenerator rng{123};
+      std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> converter;
+      for (auto i = 0; i < 1000; ++i) {
+        c0.push_back(fuzzer::rand<int64_t>(rng, fuzzer::DataSpec{}));
+        std::string buf;
+        fuzzer::randString(
+            rng,
+            fuzzer::rand<uint64_t>(rng, 0, 100),
+            {fuzzer::UTF8CharList::ASCII,
+             fuzzer::UTF8CharList::UNICODE_CASE_SENSITIVE,
+             fuzzer::UTF8CharList::EXTENDED_UNICODE},
+            buf,
+            converter);
+        c1.push_back(buf);
+      }
+      test::VectorMaker maker{localPool.get()};
+      vector = maker.rowVector(
+          {maker.flatVector<int64_t>(c0), maker.flatVector<std::string>(c1)});
+      vector->transferOrCopyTo(pool.get());
+    }
+    ASSERT_EQ(vector->pool(), pool.get());
+    test::VectorMaker maker{pool.get()};
+    expected = maker.rowVector(
+        {maker.flatVector<int64_t>(c0), maker.flatVector<std::string>(c1)});
+    test::assertEqualVectors(expected, vector);
+  };
+  testPrimitive(memory::memoryManager());
+  testPrimitive(&anotherManager);
+
+  // Test complex type.
+  auto testComplex = [&](memory::MemoryManager* memoryManager) {
+    {
+      auto localRootPool = memoryManager->addRootPool("short-living");
+      auto localPool = localRootPool->addLeafChild("short-living leaf");
+      test::VectorMaker maker{localPool.get()};
+      vector = maker.rowVector(
+          {maker.flatVector<double>(
+               3,
+               [](auto row) { return row; },
+               [](auto row) { return row == 2; }),
+           maker.constantVector<bool>({true, true, true}),
+           maker.dictionaryVector<int64_t>({1, std::nullopt, 1}),
+           maker.arrayVector<int64_t>(
+               3,
+               [](auto row) { return row; },
+               [](auto row) { return row; },
+               [](auto row) { return row == 0; },
+               [](auto row) { return row == 1; }),
+           maker.mapVector<int64_t, int64_t>(
+               3,
+               [](auto row) { return row; },
+               [](auto row) { return row; },
+               [](auto row) { return row + 1; },
+               [](auto row) { return row == 1; },
+               [](auto row) { return row == 2; })});
+      expected = BaseVector::copy(*vector, pool.get());
+      vector->transferOrCopyTo(pool.get());
+    }
+    ASSERT_EQ(vector->pool(), pool.get());
+    test::assertEqualVectors(expected, vector);
+  };
+  testComplex(memory::memoryManager());
+  testComplex(&anotherManager);
+
+  // Test with fuzzing.
+  // TODO: FlatMapVector doesn't support copy() yet. Add it later when it
+  // supports.
+  VectorFuzzer::Options options{
+      .nullRatio = 0.2,
+      .stringVariableLength = true,
+      .allowLazyVector = true,
+      .allowFlatMapVector = false};
+  const int kNumIterations = 500;
+  auto testFuzz = [&](memory::MemoryManager* memoryManager) {
+    for (auto i = 0; i < kNumIterations; ++i) {
+      {
+        auto localRootPool = memoryManager->addRootPool("short-living");
+        auto localPool = localRootPool->addLeafChild("short-living leaf");
+
+        VectorFuzzer fuzzer{options, localPool.get(), 123};
+        auto type = fuzzer.randType();
+        vector = fuzzer.fuzz(type);
+        expected = BaseVector::copy(*vector, pool.get());
+        vector->transferOrCopyTo(pool.get());
+      }
+      ASSERT_EQ(vector->pool(), pool.get());
+      test::assertEqualVectors(expected, vector);
+    }
+  };
+  testFuzz(memory::memoryManager());
+  testFuzz(&anotherManager);
+
+  // Test complex-typed vectors with buffers from different pools.
+  auto testBufferFromDifferentPools =
+      [&](memory::MemoryManager* memoryManager) {
+        VectorFuzzer fuzzer{options, pool.get(), 123};
+        for (auto i = 0; i < kNumIterations; ++i) {
+          {
+            auto localRootPool = memoryManager->addRootPool("short-living");
+            auto localPool = localRootPool->addLeafChild("short-living leaf");
+            VectorFuzzer localFuzzer{options, localPool.get(), 123};
+
+            auto type = fuzzer.randType();
+            auto elements = localFuzzer.fuzz(type);
+            auto arrays = fuzzer.fuzzArray(elements, 70);
+            fuzzer.setOptions({});
+            auto keys = fuzzer.fuzz(BIGINT());
+            fuzzer.setOptions(options);
+            auto maps = localFuzzer.fuzzMap(keys, arrays, 50);
+            vector = localFuzzer.fuzzRow({maps}, 50);
+
+            expected = BaseVector::copy(*vector, pool.get());
+            vector->transferOrCopyTo(pool.get());
+          }
+          ASSERT_EQ(vector->pool(), pool.get());
+          test::assertEqualVectors(expected, vector);
+        }
+      };
+  testBufferFromDifferentPools(memory::memoryManager());
+  testBufferFromDifferentPools(&anotherManager);
+
+  // Test opaque vector.
+  auto testOpaque = [&](memory::MemoryManager* memoryManager) {
+    {
+      auto localRootPool = memoryManager->addRootPool("short-living");
+      auto localPool = localRootPool->addLeafChild("short-living leaf");
+
+      auto type = OPAQUE<NonPOD>();
+      auto size = 100;
+      vector = BaseVector::create(type, size, localPool.get());
+      auto opaqueObj = std::make_shared<NonPOD>();
+      for (auto i = 0; i < size; ++i) {
+        vector->as<FlatVector<std::shared_ptr<void>>>()->set(i, opaqueObj);
+      }
+      expected = BaseVector::copy(*vector, pool.get());
+      vector->transferOrCopyTo(pool.get());
+    }
+    ASSERT_EQ(vector->pool(), pool.get());
+    test::assertEqualVectors(expected, vector);
+  };
+  testOpaque(memory::memoryManager());
+  testOpaque(&anotherManager);
+
+  auto testMemoryStats = [&options](size_t seed) {
+    auto localRoot1 = memory::memoryManager()->addRootPool("local root 1");
+    auto localLeaf1 = localRoot1->addLeafChild("local leaf 1");
+    auto localRoot2 = memory::memoryManager()->addRootPool("local root 2");
+    auto localLeaf2 = localRoot2->addLeafChild("local leaf 2");
+
+    EXPECT_EQ(localLeaf1->usedBytes(), 0);
+    EXPECT_EQ(localLeaf1->peakBytes(), 0);
+    EXPECT_EQ(localLeaf2->usedBytes(), 0);
+    EXPECT_EQ(localLeaf2->peakBytes(), 0);
+
+    VectorFuzzer fuzzer{options, localLeaf1.get(), seed};
+    auto size = fuzzer.randInRange(0, 10000);
+    auto type = fuzzer.randType();
+    auto vector = fuzzer.fuzz(type, size);
+    auto usedBytes = localLeaf1->usedBytes();
+    auto peakBytes = localLeaf1->peakBytes();
+
+    vector->transferOrCopyTo(localLeaf2.get());
+    EXPECT_LE(localLeaf2->usedBytes(), usedBytes);
+    EXPECT_LE(localLeaf2->peakBytes(), peakBytes);
+    if (localLeaf2->usedBytes() == 0) {
+      auto tmp = facebook::velox::isLazyNotLoaded(*vector) ||
+          vector->isConstantEncoding();
+      EXPECT_TRUE(tmp);
+    }
+    vector = nullptr;
+  };
+
+  for (auto i = 0; i < kNumIterations; ++i) {
+    testMemoryStats(kNumIterations * i + i);
+  }
+}
+#pragma GCC diagnostic pop
+
 } // namespace
 } // namespace facebook::velox
diff --git a/velox/vector/tests/VectorTestUtils.h b/velox/vector/tests/VectorTestUtils.h
index be04bb310106..d9e50583c7f9 100644
--- a/velox/vector/tests/VectorTestUtils.h
+++ b/velox/vector/tests/VectorTestUtils.h
@@ -136,12 +136,13 @@ VectorGeneratedData<T> genTestData(
   testData.reserve(cardinality);
 
   for (int64_t m = 0; m < cardinality; m++) {
-    testData.push_back(VectorValueGenerator::cardValueOf<T>(
-        useFullTypeRange,
-        rng,
-        testData.stringViewBufferHolder(),
-        fixedWidthStringSize,
-        type));
+    testData.push_back(
+        VectorValueGenerator::cardValueOf<T>(
+            useFullTypeRange,
+            rng,
+            testData.stringViewBufferHolder(),
+            fixedWidthStringSize,
+            type));
   }
 
   if (includeNulls) {
diff --git a/velox/vector/tests/VectorToStringTest.cpp b/velox/vector/tests/VectorToStringTest.cpp
index d67e423ff104..1a6abc1c62f8 100644
--- a/velox/vector/tests/VectorToStringTest.cpp
+++ b/velox/vector/tests/VectorToStringTest.cpp
@@ -48,13 +48,13 @@ TEST_F(VectorToStringTest, arrayOfIntegers) {
   auto arr = makeArrayVector<int64_t>(
       {{0}, {1, 2}, {3, 4, 5}, {6}, {}, {8, 9, 10, 11}});
   ASSERT_EQ(arr->toString(), "[ARRAY ARRAY<BIGINT>: 6 elements, no nulls]");
-  ASSERT_EQ(arr->toString(3), "1 elements starting at 6 {6}");
+  ASSERT_EQ(arr->toString(3), "{6}");
   ASSERT_EQ(
       arr->toString(2, 6),
-      "2: 3 elements starting at 3 {3, 4, 5}\n"
-      "3: 1 elements starting at 6 {6}\n"
+      "2: {3, 4, 5}\n"
+      "3: {6}\n"
       "4: <empty>\n"
-      "5: 4 elements starting at 7 {8, 9, 10, 11}");
+      "5: {8, 9, 10, 11}");
 
   // With nulls.
   arr = makeNullableArrayVector<int64_t>(
@@ -63,21 +63,18 @@ TEST_F(VectorToStringTest, arrayOfIntegers) {
   ASSERT_EQ(arr->toString(4), "<empty>");
   ASSERT_EQ(
       arr->toString(2, 6),
-      "2: 3 elements starting at 3 {3, 4, 5}\n"
-      "3: 1 elements starting at 6 {6}\n"
+      "2: {3, 4, 5}\n"
+      "3: {6}\n"
       "4: <empty>\n"
-      "5: 2 elements starting at 7 {null, 5}");
+      "5: {null, 5}");
 }
 
 TEST_F(VectorToStringTest, mapOfIntegerToDouble) {
   auto map = makeMapVector<int32_t, double>(
       {{{1, 0.1}, {2, 0.2}, {3, 0.3}}, {}, {{4, 0.4}, {5, 0.5}}});
   ASSERT_EQ(map->toString(), "[MAP MAP<INTEGER,DOUBLE>: 3 elements, no nulls]");
-  ASSERT_EQ(
-      map->toString(0),
-      "3 elements starting at 0 {1 => 0.1, 2 => 0.2, 3 => 0.3}");
-  ASSERT_EQ(
-      map->toString(2, 6), "2: 2 elements starting at 3 {4 => 0.4, 5 => 0.5}");
+  ASSERT_EQ(map->toString(0), "{1 => 0.1, 2 => 0.2, 3 => 0.3}");
+  ASSERT_EQ(map->toString(2, 6), "2: {4 => 0.4, 5 => 0.5}");
 }
 
 TEST_F(VectorToStringTest, row) {
@@ -194,9 +191,9 @@ TEST_F(VectorToStringTest, constant) {
   auto constant = BaseVector::wrapInConstant(100, 1, arrayVector);
   ASSERT_EQ(
       constant->toString(true),
-      "[CONSTANT ARRAY<INTEGER>: 100 elements, 2 elements starting at 3 {4, 5}], "
+      "[CONSTANT ARRAY<INTEGER>: 100 elements, {4, 5}], "
       "[ARRAY ARRAY<INTEGER>: 3 elements, no nulls]");
-  ASSERT_EQ(constant->toString(3), "2 elements starting at 3 {4, 5}");
+  ASSERT_EQ(constant->toString(3), "{4, 5}");
 }
 
 TEST_F(VectorToStringTest, dictionary) {
diff --git a/velox/vector/tests/VectorUtilTest.cpp b/velox/vector/tests/VectorUtilTest.cpp
index a7e6836135fe..f12d01dedf7f 100644
--- a/velox/vector/tests/VectorUtilTest.cpp
+++ b/velox/vector/tests/VectorUtilTest.cpp
@@ -29,7 +29,7 @@ namespace facebook::velox::test {
 template <typename T>
 class VectorUtilTest : public testing::Test {
  public:
-  void runTest(folly::Optional<int32_t> size = folly::none) {
+  void runTest(std::optional<int32_t> size = std::nullopt) {
     std::vector<T> vec;
     constexpr int32_t kSize = 3;
     for (size_t i = 1; i <= kSize; ++i) {
@@ -37,7 +37,7 @@ class VectorUtilTest : public testing::Test {
     }
     auto buffer = copyToBuffer(vec, pool_.get(), size);
     int32_t actualBufferSize =
-        size.hasValue() ? std::min(size.value(), kSize) : kSize;
+        size.has_value() ? std::min(size.value(), kSize) : kSize;
     ASSERT_EQ(actualBufferSize * sizeof(T), buffer->size());
   }
 
@@ -50,7 +50,7 @@ class VectorUtilTest : public testing::Test {
   void runTestWithEmptyVectorAndReturnsNullptr() {
     std::vector<T> vec;
     auto buffer = copyToBuffer(
-        vec, pool_.get(), folly::none /*size*/, true /*returnsNullptr*/);
+        vec, pool_.get(), std::nullopt /*size*/, true /*returnsNullptr*/);
     ASSERT_EQ(nullptr, buffer);
   }
 
diff --git a/velox/vector/tests/utils/CMakeLists.txt b/velox/vector/tests/utils/CMakeLists.txt
index 1947ce5e198e..4d61ce356e6e 100644
--- a/velox/vector/tests/utils/CMakeLists.txt
+++ b/velox/vector/tests/utils/CMakeLists.txt
@@ -18,4 +18,5 @@ target_link_libraries(
   velox_row_fast
   velox_vector
   GTest::gtest
-  GTest::gtest_main)
+  GTest::gtest_main
+)
diff --git a/velox/vector/tests/utils/VectorMaker-inl.h b/velox/vector/tests/utils/VectorMaker-inl.h
index ef813b0e736a..632f5cc94805 100644
--- a/velox/vector/tests/utils/VectorMaker-inl.h
+++ b/velox/vector/tests/utils/VectorMaker-inl.h
@@ -50,13 +50,8 @@ BiasVectorPtr<EvalType<T>> VectorMaker::biasVector(
     TEvalType min = *stats.min;
     TEvalType max = *stats.max;
 
-    // This ensures the math conversions when getting a delta on signed
-    // values at opposite ends of the int64 range do not overflow a
-    // temporary signed value.
-    uint64_t delta = max < 0 ? max - min
-        : min < 0
-        ? static_cast<uint64_t>(max) + static_cast<uint64_t>(std::abs(min))
-        : max - min;
+    // Calculate delta safely without risk of overflow.
+    uint64_t delta = checkedMinus<TEvalType>(max, min);
 
     VELOX_CHECK(deltaAllowsBias<TEvalType>(delta));
 
diff --git a/velox/vector/tests/utils/VectorMaker.cpp b/velox/vector/tests/utils/VectorMaker.cpp
index 9fceb8363ea3..bdd175baa1a3 100644
--- a/velox/vector/tests/utils/VectorMaker.cpp
+++ b/velox/vector/tests/utils/VectorMaker.cpp
@@ -226,7 +226,6 @@ ArrayVectorPtr VectorMaker::arrayVector(
     auto rawNulls = nullsBuffer->asMutable<uint64_t>();
 
     for (int i = 0; i < nulls.size(); i++) {
-      VELOX_CHECK_EQ(rawSizes[nulls[i]], 0);
       bits::setNull(rawNulls, nulls[i]);
     }
   }
@@ -267,7 +266,6 @@ MapVectorPtr VectorMaker::mapVector(
     auto rawNulls = nullsBuffer->asMutable<uint64_t>();
 
     for (int i = 0; i < nulls.size(); i++) {
-      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 92fa96112abd..35c74fe272ec 100644
--- a/velox/vector/tests/utils/VectorMaker.h
+++ b/velox/vector/tests/utils/VectorMaker.h
@@ -53,19 +53,19 @@ T jsonValue(const folly::dynamic& jsonValue) {
 }
 
 template <typename T>
-void appendVariant(std::vector<variant>& values, const T& x) {
+void appendVariant(std::vector<Variant>& values, const T& x) {
   values.push_back(x);
 };
 
 template <typename TupleT, std::size_t... Is>
-variant toVariantRow(const TupleT& tp, std::index_sequence<Is...>) {
-  std::vector<variant> values;
+Variant toVariantRow(const TupleT& tp, std::index_sequence<Is...>) {
+  std::vector<Variant> values;
   (appendVariant(values, std::get<Is>(tp)), ...);
-  return variant::row(values);
+  return Variant::row(values);
 }
 
 template <typename TupleT, std::size_t TupleSize = std::tuple_size_v<TupleT>>
-variant toVariantRow(const TupleT& tp) {
+Variant toVariantRow(const TupleT& tp) {
   return toVariantRow(tp, std::make_index_sequence<TupleSize>{});
 }
 
@@ -146,7 +146,7 @@ class VectorMaker {
         pool_,
         CppToType<T>::create(),
         size,
-        std::make_unique<SimpleVectorLoader>([=](RowSet rowSet) {
+        std::make_unique<SimpleVectorLoader>([=, this](RowSet rowSet) {
           // Populate requested rows with correct data and fill in gaps with
           // "garbage".
           SelectivityVector rows(rowSet.back() + 1, false);
@@ -455,7 +455,7 @@ class VectorMaker {
   /// Create an ArrayVector<ROW> from nested std::vectors of Variants.
   ArrayVectorPtr arrayOfRowVector(
       const RowTypePtr& rowType,
-      const std::vector<std::vector<variant>>& data);
+      const std::vector<std::vector<Variant>>& data);
 
   /// Creates an ARRAY(ROW(...)) vector from a list of lists of optional tuples.
   ///
@@ -478,14 +478,14 @@ class VectorMaker {
   ArrayVectorPtr arrayOfRowVector(
       const std::vector<std::vector<std::optional<TupleT>>>& data,
       const RowTypePtr& rowType) {
-    std::vector<std::vector<variant>> arrays;
+    std::vector<std::vector<Variant>> arrays;
     for (const auto& tuples : data) {
-      std::vector<variant> elements;
+      std::vector<Variant> elements;
       for (const auto& t : tuples) {
         if (t.has_value()) {
           elements.push_back(detail::toVariantRow(t.value()));
         } else {
-          elements.push_back(variant::null(TypeKind::ROW));
+          elements.push_back(Variant::null(TypeKind::ROW));
         }
       }
       arrays.push_back(elements);
@@ -911,6 +911,72 @@ class VectorMaker {
         std::move(inMaps));
   }
 
+  template <typename TKey>
+  FlatMapVectorPtr flatMapVector(MapVectorPtr mapVector) {
+    std::unordered_map<TKey, vector_size_t> keysMap;
+    vector_size_t keyChannel = 0;
+    vector_size_t index = 0;
+
+    std::vector<TKey> flatKeys;
+    std::vector<VectorPtr> values;
+    std::vector<BufferPtr> inMaps;
+
+    VectorPtr* curValues;
+    uint64_t* curInMaps;
+
+    DecodedVector decodedKeys(*mapVector->mapKeys());
+
+    BufferPtr nulls = allocateNulls(mapVector->size(), pool_);
+    auto rawNulls = nulls->asMutable<uint64_t>();
+    bool hasNulls = false;
+
+    for (vector_size_t row = 0; row < mapVector->size(); row++) {
+      if (mapVector->isNullAt(row)) {
+        hasNulls = true;
+        bits::setNull(rawNulls, index, true);
+      } else {
+        for (vector_size_t entry = mapVector->offsetAt(row);
+             entry < mapVector->offsetAt(row) + mapVector->sizeAt(row);
+             entry++) {
+          TKey key = decodedKeys.valueAt<TKey>(entry);
+          auto it = keysMap.find(key);
+
+          // First time we see this key.
+          if (it == keysMap.end()) {
+            keysMap.insert({key, keyChannel++});
+            flatKeys.push_back(key);
+            values.push_back(
+                BaseVector::create(
+                    mapVector->type()->childAt(1), mapVector->size(), pool_));
+
+            // We allocate a new inMaps buffer, setting "not in map" by default.
+            // Then set the current key to in map.
+            inMaps.push_back(
+                AlignedBuffer::allocate<bool>(mapVector->size(), pool_, 0));
+            curInMaps = inMaps.back()->asMutable<uint64_t>();
+
+            curValues = &values.back();
+          } else {
+            curValues = &values[it->second];
+            curInMaps = inMaps[it->second]->template asMutable<uint64_t>();
+          }
+          (*curValues)->copy(mapVector->mapValues().get(), index, entry, 1);
+          bits::setBit(curInMaps, index);
+        }
+      }
+      ++index;
+    }
+
+    return std::make_shared<FlatMapVector>(
+        pool_,
+        mapVector->type(),
+        hasNulls ? nulls : nullptr,
+        mapVector->size(),
+        flatKeys.empty() ? nullptr : flatVector(flatKeys),
+        std::move(values),
+        std::move(inMaps));
+  }
+
   template <typename TKey, typename TValue>
   FlatMapVectorPtr flatMapVectorFromJson(
       const std::vector<std::string>& jsonMaps,
@@ -920,9 +986,9 @@ class VectorMaker {
         jsonMapToVectorOfPairs<TKey, TValue>(jsonMaps), mapType);
   }
 
-  /// Create a FlatVector from a variant containing a scalar value.
+  /// Create a FlatVector from a Variant containing a scalar value.
   template <TypeKind kind>
-  VectorPtr toFlatVector(variant value) {
+  VectorPtr toFlatVector(const Variant& value) {
     using T = typename TypeTraits<kind>::NativeType;
     if constexpr (std::is_same_v<T, StringView>) {
       return flatVector<StringView>({StringView(value.value<const char*>())});
@@ -931,9 +997,9 @@ class VectorMaker {
     }
   }
 
-  /// Create constant vector of type ROW from a variant.
+  /// Create constant vector of type ROW from a Variant.
   VectorPtr
-  constantRow(const RowTypePtr& rowType, variant value, vector_size_t size) {
+  constantRow(const RowTypePtr& rowType, Variant value, vector_size_t size) {
     VELOX_CHECK_EQ(value.kind(), TypeKind::ROW);
 
     std::vector<VectorPtr> fields(rowType->size());
diff --git a/velox/vector/tests/utils/VectorTestBase.cpp b/velox/vector/tests/utils/VectorTestBase.cpp
index d0a172f2023c..f47383bcada1 100644
--- a/velox/vector/tests/utils/VectorTestBase.cpp
+++ b/velox/vector/tests/utils/VectorTestBase.cpp
@@ -121,13 +121,15 @@ std::vector<RowVectorPtr> VectorTestBase::split(
 
   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)));
+    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)));
+  vectors.push_back(
+      std::dynamic_pointer_cast<RowVector>(
+          vector->slice(offset, numRows - offset)));
   return vectors;
 }
 
diff --git a/velox/vector/tests/utils/VectorTestBase.h b/velox/vector/tests/utils/VectorTestBase.h
index 5071aa89d765..5b15ca53b5b2 100644
--- a/velox/vector/tests/utils/VectorTestBase.h
+++ b/velox/vector/tests/utils/VectorTestBase.h
@@ -17,6 +17,7 @@
 
 #include <folly/Executor.h>
 #include <folly/executors/CPUThreadPoolExecutor.h>
+#include <folly/system/HardwareConcurrency.h>
 
 #include "velox/common/base/RuntimeMetrics.h"
 #include "velox/vector/FlatVector.h"
@@ -195,6 +196,13 @@ class VectorTestBase {
     return vectorMaker_.flatVector<T>(data, type);
   }
 
+  template <typename T>
+  FlatVectorPtr<EvalType<T>> makeFlatVector(
+      const std::initializer_list<T>& data,
+      const TypePtr& type = CppToType<T>::create()) {
+    return vectorMaker_.flatVector<T>(data, type);
+  }
+
   template <typename T>
   FlatVectorPtr<EvalType<T>> makeNullableFlatVector(
       const std::vector<std::optional<T>>& data,
@@ -251,16 +259,16 @@ class VectorTestBase {
   // Create an ArrayVector<ROW> from nested std::vectors of variants.
   // Example:
   //   auto arrayVector = makeArrayOfRowVector({
-  //       {variant::row({1, "red"}), variant::row({1, "blue"})},
+  //       {Variant::row({1, "red"}), Variant::row({1, "blue"})},
   //       {},
-  //       {variant::row({3, "green"})},
+  //       {Variant::row({3, "green"})},
   //   });
   //   EXPECT_EQ(3, arrayVector->size());
   //
-  // Use variant(TypeKind::ROW) to specify a null array element.
+  // Use Variant(TypeKind::ROW) to specify a null array element.
   ArrayVectorPtr makeArrayOfRowVector(
       const RowTypePtr& rowType,
-      const std::vector<std::vector<variant>>& data) {
+      const std::vector<std::vector<Variant>>& data) {
     return vectorMaker_.arrayOfRowVector(rowType, data);
   }
 
@@ -615,6 +623,16 @@ class VectorTestBase {
     return vectorMaker_.flatMapVector(maps, mapType);
   }
 
+  // Create nullabe flat map vector from nested std::vector representation.
+  template <typename TKey, typename TValue>
+  FlatMapVectorPtr makeNullableFlatMapVector(
+      const std::vector<std::optional<
+          std::vector<std::pair<TKey, std::optional<TValue>>>>>& maps,
+      const TypePtr& mapType =
+          MAP(CppToType<TKey>::create(), CppToType<TValue>::create())) {
+    return vectorMaker_.flatMapVectorNullable(maps, mapType);
+  }
+
   /// Same as above but constructs a FlatMapVector instead of a MapVector.
   template <typename TKey, typename TValue>
   FlatMapVectorPtr makeFlatMapVectorFromJson(
@@ -652,7 +670,7 @@ class VectorTestBase {
     return vectorMaker_.allNullMapVector(size, keyType, valueType);
   }
 
-  VectorPtr makeConstant(const variant& value, vector_size_t size) {
+  VectorPtr makeConstant(const Variant& value, vector_size_t size) {
     return BaseVector::createConstant(value.inferType(), value, size, pool());
   }
 
@@ -662,7 +680,7 @@ class VectorTestBase {
       vector_size_t size,
       const TypePtr& type = CppToType<EvalType<T>>::create()) {
     return std::make_shared<ConstantVector<EvalType<T>>>(
-        pool(), size, false, type, std::move(value));
+        pool(), size, false, type, EvalType<T>(value));
   }
 
   template <typename T>
@@ -683,7 +701,7 @@ class VectorTestBase {
   /// Create constant vector of type ROW from a Variant.
   VectorPtr makeConstantRow(
       const RowTypePtr& rowType,
-      variant value,
+      Variant value,
       vector_size_t size) {
     return vectorMaker_.constantRow(rowType, value, size);
   }
@@ -800,7 +818,7 @@ class VectorTestBase {
         pool(),
         CppToType<T>::create(),
         size,
-        std::make_unique<SimpleVectorLoader>([=](RowSet rows) {
+        std::make_unique<SimpleVectorLoader>([=, this](RowSet rows) {
           if (expectedSize.has_value()) {
             VELOX_CHECK_EQ(rows.size(), *expectedSize);
           }
@@ -818,7 +836,7 @@ class VectorTestBase {
         pool(),
         vector->type(),
         vector->size(),
-        std::make_unique<SimpleVectorLoader>([=](RowSet /*rows*/) {
+        std::make_unique<SimpleVectorLoader>([=, this](RowSet /*rows*/) {
           auto indices =
               makeIndices(vector->size(), [](auto row) { return row; });
           return wrapInDictionary(indices, vector->size(), vector);
@@ -829,12 +847,12 @@ class VectorTestBase {
       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::unique_ptr<folly::Executor> executor_{
+      std::make_unique<folly::CPUThreadPoolExecutor>(
+          folly::hardware_concurrency())};
   std::shared_ptr<folly::Executor> spillExecutor_{
       std::make_shared<folly::CPUThreadPoolExecutor>(
-          std::thread::hardware_concurrency())};
+          folly::hardware_concurrency())};
 };
 
 class TestRuntimeStatWriter : public BaseRuntimeStatWriter {
diff --git a/website/blog/2025-07-07-segfault-dependency-update.mdx b/website/blog/2025-07-07-segfault-dependency-update.mdx
new file mode 100644
index 000000000000..fb02f44d0668
--- /dev/null
+++ b/website/blog/2025-07-07-segfault-dependency-update.mdx
@@ -0,0 +1,82 @@
+---
+slug: segfault-dependency-update
+title: "SEGFAULT due to Dependency Update"
+authors: [majetideepak, czentgr]
+tags: [tech-blog, build]
+---
+
+## Background
+Velox depends on several [libraries](https://github.com/facebookincubator/velox/blob/main/CMake/resolve_dependency_modules/README.md).
+Some of these dependencies include open-source libraries from Meta, including [Folly](https://github.com/facebook/folly) and
+[Facebook Thrift](https://github.com/facebook/fbthrift). These libraries are in active development and also depend on each other, so they all have to be updated to the same version at the same time.
+
+Updating these dependencies typically involves modifying the Velox code to align with any public API or semantic changes in these dependencies.
+However, a recent upgrade of Folly and Facebook Thrift to version *v2025.04.28.00* caused a *SEGFAULT* only in one unit test in Velox
+named *velox_functions_remote_client_test*.
+
+## Investigation
+We immediately put on our [gdb](https://en.wikipedia.org/wiki/GNU_Debugger) gloves and looked at the stack traces. This issue was also reproducible in a debug build.
+The SEGFAULT occurred in Facebook Thrift's *ThriftServer* Class during it's initialization but the offending call was invoking a destructor of a certain handler.
+However, the corresponding source code was pointing to an invocation of a different function. And this code was present inside a Facebook Thrift
+header called *AsyncProcessor.h*.
+
+This handler (*RemoteServer*) was implemented in Velox as a Thrift definition. Velox compiled this thrift file using Facebook Thrift, and the generated code
+was using the *ServerInterface* class in Facebook Thrift. This *ServerInterface* class was further extended from both the *AsyncProcessorFactory* and
+*ServiceHandlerBase* interfaces in Facebook Thrift.
+
+One of the culprits resulting in SEGFAULTs in the past was the conflict due to the usage of Apache Thrift and Facebook Thrift.
+However, this was not the root cause this time because we were able to reproduce this issue by just building the test without the Apache Thrift dependency installed.
+We were entering a new territory to investigate, and we were not sure where to start.
+
+We then compiled an example called *EchoService* in Facebook Thrift that was very similar to the *RemoteServer*, and it worked. Then we copied and compiled the Velox *RemoteServer*
+in Facebook Thrift and that worked too! So the culprit was likely in the compilation flags, which likely differed between Facebook Thrift and Velox.
+We enabled the verbose logging for both builds and were able to spot one difference. We saw the GCC *coroutines* flag being used in the Facebook Thrift build.
+
+We were also curious about the invocation of the destructor instead of the actual function. We put our gdb gloves back on and dumped the entire
+[vtable](https://en.wikipedia.org/wiki/Virtual_method_table) for the *RemoteServer* class and its base classes. The vtables were different when it was built in Velox vs. Facebook Thrift.
+Specifically, the list of functions inherited from *ServiceHandlerBase* was different.
+
+The vtable for the *RemoteServer* handler in the Velox build had the following entries:
+
+```
+folly::SemiFuture<folly::Unit> semifuture_onStartServing()
+folly::SemiFuture<folly::Unit> semifuture_onStopRequested()
+Thunk ServiceHandlerBase::~ServiceHandlerBase
+```
+
+The vtable for the *RemoteServer* handler in the Facebook Thrift build had the following entries:
+
+```
+folly::coro::Task<void> co_onStartServing()
+folly::coro::Task<void> co_onStopRequested()
+folly::SemiFuture<folly::Unit> semifuture_onStartServing()
+folly::SemiFuture<folly::Unit> semifuture_onStopRequested()
+Thunk ServiceHandlerBase::~ServiceHandlerBase
+```
+
+Tying up both pieces of evidence, we could conclude that Velox generated a different vtable structure compared to what Facebook Thrift (and thus ThriftServer) was built with.
+Looking around further, we noticed that the ServiceHandlerBase was conditionally adding functions based on the *coroutines* compile flag that influences the *FOLLY_HAS_COROUTINES* macro from the portability header.
+
+```
+class ServiceHandlerBase {
+  ....
+ public:
+#if FOLLY_HAS_COROUTINES
+  virtual folly::coro::Task<void> co_onStartServing() { co_return; }
+  virtual folly::coro::Task<void> co_onStopRequested() {
+    throw MethodNotImplemented();
+  }
+#endif
+
+  virtual folly::SemiFuture<folly::Unit> semifuture_onStartServing() {
+#if FOLLY_HAS_COROUTINES
+    return co_onStartServing().semi();
+#else
+    return folly::makeSemiFuture();
+#endif
+  }
+```
+
+As a result, the ThriftServer would access an incorrect function (*~ServiceHandlerBase* destructor at offset 3 in the first vtable above) instead of the expected
+initialization function (*semifuture_onStartServing* at offset 3 in the second vtable above), thus resulting in a SEGFAULT.
+We recompiled the Facebook Thrift dependency for Velox with the *coroutines* compile flag disabled, and the test passed.
diff --git a/website/blog/2025-07-11-extending-velox-with-cudf.mdx b/website/blog/2025-07-11-extending-velox-with-cudf.mdx
new file mode 100644
index 000000000000..80e61b30b2dd
--- /dev/null
+++ b/website/blog/2025-07-11-extending-velox-with-cudf.mdx
@@ -0,0 +1,34 @@
+---
+slug: extending-velox-with-cudf
+title: "Extending Velox - GPU Acceleration with cuDF"
+authors: [GregoryKimball]
+tags: [tech-blog]
+---
+
+## TL;DR
+
+This post describes the design principles and software components for extending Velox with hardware acceleration libraries like NVIDIA's [cuDF](https://github.com/rapidsai/cudf). Velox provides a flexible execution model for hardware accelerators, and cuDF's data structures and algorithms align well with core components in Velox.
+
+## How Velox and cuDF Fit Together
+
+Extensibility is a key feature in Velox. The cuDF library integrates with Velox using the [DriverAdapter](https://github.com/facebookincubator/velox/blob/2a9c9043264a60c9a1b01324f8371c64bd095af9/velox/experimental/cudf/exec/ToCudf.cpp#L293) interface to rewrite query plans for GPU execution. The rewriting process allows for operator replacement, operator fusion and operator addition, giving cuDF a lot of freedom when preparing a query plan with GPU operators. Once Velox converts a query plan into executable pipelines, the cuDF DriverAdapter rewrites the plan to use GPU operators:
+
+<figure>
+ <img src="/img/2025-07-11-cudf-driveradapter.png" height= "100%" width="100%"/>
+</figure>
+
+Generally the cuDF DriverAdapter replaces operators one-to-one. An exception happens when a GPU operator is not yet implemented in cuDF, in which case a [CudfConversion](https://github.com/facebookincubator/velox/blob/main/velox/experimental/cudf/exec/CudfConversion.h) operator must be added to transfer from GPU to CPU, fallback to CPU execution, and then transfer back to GPU. For end-to-end GPU execution where cuDF replaces all of the Velox CPU operators, cuDF relies on Velox's [pipeline-based execution model](https://facebookincubator.github.io/velox/develop/task.html) to separate stages of execution, partition the work across drivers, and schedule concurrent work on the GPU.
+
+Velox and cuDF benefit from a shared data format, using columnar layout and [Arrow-compatible buffers](https://engineering.fb.com/2024/02/20/developer-tools/velox-apache-arrow-15-composable-data-management/). The [CudfVector](https://github.com/facebookincubator/velox/tree/2a9c9043264a60c9a1b01324f8371c64bd095af9/velox/experimental/cudf/vector) type in the experimental cuDF backend inherits from Velox's [RowVector](https://facebookincubator.github.io/velox/develop/vectors.html#rowvector) type, and manages a `std::unique_ptr` to a `cudf::table` ([link](https://docs.rapids.ai/api/libcudf/stable/classcudf_1_1table)) which owns the GPU-resident data. CudfVector also maintains an `rmm::cuda_stream_view` ([link](https://docs.rapids.ai/api/rmm/stable/librmm_docs/cuda_streams/)) to ensure that asynchronously launched GPU operations are [stream-ordered](https://developer.nvidia.com/blog/using-cuda-stream-ordered-memory-allocator-part-1/). Even when the data resides in GPU memory, CudfVector allows the operator interfaces to follow Velox's standard execution model of producing and consuming RowVector objects.
+
+The first set of GPU operators in the experimental cuDF backend include [TableScan](https://github.com/facebookincubator/velox/tree/2a9c9043264a60c9a1b01324f8371c64bd095af9/velox/experimental/cudf/connectors), [HashJoin](https://github.com/facebookincubator/velox/blob/2a9c9043264a60c9a1b01324f8371c64bd095af9/velox/experimental/cudf/exec/CudfHashJoin.h), [HashAggregation](https://github.com/facebookincubator/velox/blob/2a9c9043264a60c9a1b01324f8371c64bd095af9/velox/experimental/cudf/exec/CudfHashAggregation.h), [FilterProject](https://github.com/facebookincubator/velox/blob/2a9c9043264a60c9a1b01324f8371c64bd095af9/velox/experimental/cudf/exec/CudfFilterProject.h), [OrderBy](https://github.com/facebookincubator/velox/blob/2a9c9043264a60c9a1b01324f8371c64bd095af9/velox/experimental/cudf/exec/CudfOrderBy.h) and more. cuDF's C++ API covers many features beyond this initial set, including broad support for list and struct types, high-performance string operations, and configurable null handling. These features are critical for running workloads in Velox with correct semantics for Presto and Spark users. Future work will integrate cuDF support for more Velox operators.
+
+## GPU execution: fewer drivers and larger batches
+
+Compared to the typical settings for CPU execution, GPU execution with cuDF benefits from a lower driver count and larger batch size. Whereas Velox CPU performs best with ~1K rows per batch and driver count equal to the number of physical CPU cores, we have found Velox's cuDF backend to perform best with ~1 GiB batch size and 2-8 drivers for a single GPU. cuDF GPU operators launch one or more device-wide kernels and a single driver may not fully utilize GPU compute. Additional drivers improve throughput by queuing up more GPU work and avoiding stalling during host-to-device copies. Adding more drivers increases memory pressure linearly, and query processing throughput saturates once GPU compute is fully utilized. Please check out our talk, “[Accelerating Velox with RAPIDS cuDF](https://www.youtube.com/watch?v=l1JEo-mTNlw)” from VeloxCon 2025 to learn more.
+
+## Call to Action
+
+The [experimental cuDF backend in Velox](https://github.com/facebookincubator/velox/tree/main/velox/experimental/cudf) is under active development. It is implemented entirely in C++ and does not require CUDA programming knowledge. There are dozens more APIs in cuDF that can be integrated as Velox operators, and many design areas to explore such as spilling, remote storage connectors, and expression handling.
+
+If you're interested in bringing GPU acceleration to the Velox ecosystem, please join us in the #velox-oss-community channel on the Velox Slack workspace. Your contributions will help push the limits of performance in Presto, Spark and other tools powered by Velox.
diff --git a/website/blog/2025-08-30-cpp20-standard.mdx b/website/blog/2025-08-30-cpp20-standard.mdx
new file mode 100644
index 000000000000..de4e4172e814
--- /dev/null
+++ b/website/blog/2025-08-30-cpp20-standard.mdx
@@ -0,0 +1,58 @@
+---
+slug: cpp20-standard
+title: "Velox switches to C++20 standard"
+authors: [czentgr]
+tags: [build]
+---
+
+## Background
+The C++ standard used in a project determines what built-in functionality developers can use to ease development and extended capabilities.
+
+Since its inception in August of 2021 Velox used the C++17 standard.
+
+## Benefits
+
+Switching to C++20 contributes to having a modern ecosystem that is attractive in use, to develop in, and to maintain.
+Going forward Velox is looking to enhance the codebase by making use of newer compiler functionalities, such as sanitization checks, by also moving to support newer compiler versions for both GCC and Clang.
+
+## Changes
+
+### New minimum compiler versions
+This change also changes the minimum required compiler versions for GCC and CLang.
+The following minimum versions are now required:
+
+- GCC11 and later
+- CLang 15 and later
+
+### C++20 major new features relevant to Velox
+- coroutines language feature
+- modules language feature
+- Calendar and Timezone library `<chrono>`
+- constraints and concepts language feature
+- 3-way operator language feature
+- Ranges library feature
+
+Please refer to the C++20 standard for a complete list of new features.
+
+The minimum targeted compiler versions support
+- coroutines
+- Calendar and Timezone library `<chrono>`
+
+Newer versions of compilers implement more and more and C++20 features and library support.
+Supporting Velox on newer compiler versions is a continuous effort.
+
+## Lessons
+
+There was some interesting behavior by the compilers. Changing the C++20 standard caused some compile errors in the existing code.
+One of these errors was caused by a compiler issue itself.
+
+In GCC 12.2.1, which is used in the CI, the std::string `+` operator implementation ran into a known issue causing a warning.
+Because all warnings are errors we had to explictly add an exemption for this particlar compiler version.
+
+In general, however, the found compile errors were reasonably easy to fix.
+Most of the changes were compatible with C++17 as well which means the code is bit more clean.
+However, one change caused slight trouble because it emitted warnings in C++17 causing build failures due to turning all warnigns into errors.
+This was the change to require `this` in the lambda capture where applicable.
+On the other hand, not addressing the changes to the lamda capture caused errors in C++20.
+
+Overall, the switch to C++20 took some time but was not overly complicated. No changes to the CI pipelines used in the project were needed. It was limited to CMake and code changes.
diff --git a/website/blog/2025-11-01-shared-build.mdx b/website/blog/2025-11-01-shared-build.mdx
new file mode 100644
index 000000000000..1fa49b995e53
--- /dev/null
+++ b/website/blog/2025-11-01-shared-build.mdx
@@ -0,0 +1,103 @@
+---
+slug: shared-build
+title: "Enabling Shared Library Builds in Velox"
+authors: [jwujciak]
+tags: [tech-blog, packaging]
+---
+
+# Enabling Shared Library Builds in Velox
+
+In this post, I’ll share how we unblocked shared library builds in Velox, the challenges we encountered with our large CMake build system, and the creative solution that let us move forward without disrupting contributors or downstream users.
+
+## The State of the Velox Build System
+
+Velox’s codebase was started in Meta’s internal monorepo, which still serves as a source of truth. Changes from pull requests in the Github repository are not merged directly via the web UI. Instead, the changes are imported into the internal review and CI tool [Phabricator](https://developers.facebook.com/blog/post/2022/11/15/meta-developers-workflow-exploring-tools-used-to-code/), as a ‘diff’. There, it has to pass an additional set of CI checks before being merged into the monorepo and in turn, exported to Github as a commit on the ‘main’ branch.
+
+Internally, Meta uses the Buck2 build system which, like its predecessor Buck, promotes   small, [granular build targets](https://buck.build/concept/what_makes_buck_so_fast.html) to improve caching and distributed compilation. Externally, however, the open-source community relies on CMake as a build system. When the CMake build system was first added, its structure mirrored the granular nature of the internal build targets.
+
+The result was hundreds of targets: over one hundred library targets, built as static libraries, and more than two hundred executables for tests and examples. While Buck(2) is optimized  for managing such  granular targets, the same can not be said for CMake. Each subdirectory maintained its own `CMakeLists.txt`, and header includes were managed through global `include_directories()`, with no direct link between targets and their associated header files. This approach encouraged tight coupling across module boundaries. Over the years, dependencies accumulated organically, resulting in a highly interconnected, and in parts cyclic, dependency graph.
+
+## Static Linking vs. Shared Linking
+
+The combination of 300+ targets and static linking resulted in a massive build tree, dozens of GiB when building in release mode and several times larger when built with debug information. This grew to the point where we had to provision larger CI runners just to accommodate the build tree in debug mode\!
+
+Individual test executables could reach several GiB, making it impractical to transfer the executables between runners to parallelize the execution of the tests across different CI runners. Significantly delaying CI feedback for developers when pushing changes to a PR.
+
+This size is the result of each static library containing a full copy of all of its dependencies' object files. With over 100+ strongly connected libraries, we end up with countless redundant copies of the same objects scattered throughout the build tree, blowing up the total size.
+
+CMake usually [requires](https://cmake.org/cmake/help/latest/command/target_link_libraries.html?utm_source=chatgpt.com#id12) the library dependency graph to be acyclic (a DAG). However it allows circular dependencies between static libraries, because it’s possible to adjust the linker invocation to work around possible issues with missing symbols.
+
+For example, say library `A` depends on `foo()` from library `B`, and `B` in turn depends on `bar()` defined in `A`. If we link them in order `A B`, the linker will find `foo()` in `B` for use in `A` but will fail to find `bar()` for use in `B`. This happens because the linker processes the libraries from left to right and symbols that are not (yet) required are effectively ignored.
+
+The trick is now simply to repeat the entire circular group in the linker arguments `A B A B`. Previously ignored symbols are now in the list of required symbols and can be resolved when the linker processes the repeated libraries.
+
+However, there is no workaround for shared libraries. So the moment we attempted to build Velox as a set of shared libraries, CMake failed to configure. The textbook solution would involve refactoring dependencies between targets, explicitly marking dependencies \- as `PUBLIC`( meaning forwarded to both direct and transitive dependents) or `PRIVATE`, ( required only for this target at build time), and manually breaking cycles. But with hundreds of targets and years of organic growth, this became an unmanageable task.
+
+## ~~Solution~~ Attempt 1: Automate
+
+Manually addressing this was unmanageable so, our first instinct as Software Engineers was, of course, to automate the process. I wrote a [python package](https://github.com/assignUser/cmake-refactor) that parses all `CMakelists.txt` files in the repository using [Antlr4](https://github.com/antlr/antlr4/), tracks which source files and headers belong to which target and reconstructs the library dependency graph. Based on the graph and whether headers are included from a source or a header file, the tool grouped the linked targets as either PRIVATE or PUBLIC.
+
+While this worked locally and made it easier to resolve the circular dependencies, it proved far too brittle and disruptive to implement at scale. Velox's high development velocity meant many parts of the code base changed daily, making it impossible to land modifications  across over 250+ CMake files in a timely manner while also allowing for thorough review and testing. Maintaining this carefully constructed DAG of dependencies would also have required an unsustainable amount of specialized reviewer attention, time that could be spent much more productively elsewhere.
+
+## Solution: Monolithic Library via CMake Wrappers
+
+Given the practical constraints we needed a solution that would unblock shared builds without disrupting the ongoing development. To achieve this we used a common pattern of larger CMake code bases, project specific wrapper functions. A special thanks to [Marcus Hanwell](https://github.com/cryos) for introducing me to the pattern he successfully used in [VTK](https://www.kitware.com/vtk-modularization-and-modernization/).
+
+We created wrapper functions for a selection of the CMake commands that create and manage build targets: `add_library` became `velox_add_library`, `target_link_libraries` turned into `velox_link_libraries` etc. These functions just forward the arguments to the wrapped core command, unless the option to build Velox as a monolithic library is set. In the latter case instead of ~100 only a single library target is created.
+
+Each call to `velox_add_library` just adds the relevant source files to the main `velox` target. To ensure drop-in compatibility, for every original library target, the wrapper creates an `ALIAS` target referring to `velox`. This way, all existing code, downstream consumers, old and new test targets, can continue to link to their accustomed `velox_xyz` targets, which effectively point to the same monolithic library. There is no need to adjust CMake files throughout the codebase, keeping the migration quick and entirely transparent to developers and users.
+
+Some special-case libraries, such as those involving the CUDA driver, still needed to be built separately for runtime or integration reasons. The wrapper logic allows exemptions for these, letting them be built as standalone libraries even in monolithic mode.
+
+Here's a simplified version of the relevant logic:
+```cmake
+function(velox_add_library TARGET)
+  if(VELOX_MONO_LIBRARY)
+      if(TARGET velox)
+        # Target already exists, append sources to it.
+        target_sources(velox PRIVATE ${ARGN})
+      else()
+        add_library(velox ${ARGN})
+      endif()
+      # create alias for compatibility
+      add_library(${TARGET} ALIAS velox)
+  else()
+    # Just call add_library as normal
+    add_library(${TARGET} ${ARGN})
+  endif()
+endfunction()
+```
+
+This new, monolithic library obviously doesn’t suffer from cyclic dependencies, as it only has external dependencies. So after implementing the wrapper functions, building Velox as a shared library only required some minor adjustments\!
+
+We have now switched the default configuration to build the monolithic library and transitioned to build the shared library in our main [PR CI](https://github.com/facebookincubator/velox/actions/workflows/linux-build.yml) and [macOS builds](https://github.com/facebookincubator/velox/actions/workflows/macos.yml).
+
+## Result
+
+The results of our efforts can be clearly seen in our [Build Metrics Report](https://facebookincubator.github.io/velox/bm-report) with the size of the resulting binaries being the biggest win as seen in Table 1\. The workflow that collects these metrics uses our regular CI image with GCC 12.2 and ld 2.38.
+
+![Velox Build Metrics Report](/img/bm-report.png)
+
+The new executables built against the shared [`libvelox.so`](http://libvelox.so) are a mere \~4% of their previous size\! This unlocks improvements across the board both for the local developer experience, packaging/deployments for downstream users as well as CI.
+
+| Size of executables | Static | Shared |
+| :---- | :---- | :---- |
+| Release | 18.31G | 0.76G |
+| Debug | 244G | 8.8G |
+
+Table 1: Total size of test, fuzzer and benchmark executables
+
+Less impressive but still notable is the reduction of the debug build time by almost two hours[^1]. The improvement is entirely explained by the much faster link time for the shared build of \~30 minutes compared to the 2 hours and 20 minutes it takes to link the static library.
+
+[^1]: This is of course much less in terms of wall time the user experiences (~ `CPU time/n` where n is the number of cores used for the build)
+
+| Total CPU Time | Static | Shared |
+| :---- | :---- | :---- |
+| Release | 13:21h | 13:23h |
+| Debug | 12:50h | 11:07h |
+
+Table 2: Total time spent on compilation and linking across all cores
+
+In addition to unblocking shared builds, the wrapper function pattern offers further benefits for future feature additions or build-system wide adjustments with minimal disruption. We already use them to automate installation of header files along the Velox libraries, with no changes to the targets themselves.
+
+The wrapper functions will also help with defining and enforcing the public Velox API by allowing us to manage header visibility, component libraries like GPU and Cloud extensions and versioning in a consistent and centralized manner.
diff --git a/website/blog/2025-11-09-multiround-local-merge.mdx b/website/blog/2025-11-09-multiround-local-merge.mdx
new file mode 100644
index 000000000000..daa423740797
--- /dev/null
+++ b/website/blog/2025-11-09-multiround-local-merge.mdx
@@ -0,0 +1,118 @@
+---
+slug: multi-round-local-merge
+title: "Multi-Round Lazy Start Merge"
+authors: [duanmeng, xiaoxmeng, pedroerp]
+tags: [tech-blog, spill, operator]
+---
+
+## Background
+
+Efficiently merging sorted data partitions at scale is crucial for a variety of training data preparation
+workloads, especially for Generative Recommenders (GRs) a new paradigm introduced in the paper
+*[Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations](https://arxiv.org/pdf/2402.17152)*.
+A key requirement is to merge training data across partitions—for example, merging hourly partitions into
+daily ones—while ensuring that all rows sharing the same primary key are stored consecutively. Training data is
+typically partitioned and bucketed by primary key, with rows sharing the same key
+stored consecutively, so merging across partitions essentially becomes a [multi-way merge problem](https://en.wikipedia.org/wiki/K-way_merge_algorithm#).
+
+Normally, [Apache Spark](https://spark.apache.org/) can be used for this sort-merge requirement — for example, via `CLUSTER BY`.
+However, training datasets for a single job can often reach the PB scale, which in turn generates shuffle data at PB scale.
+Although we typically apply bucketing and ordering by key when preparing training data in production,
+Spark can eliminate the shuffle when merging training data from multiple hourly partitions.
+However, each Spark task can only read the files planned from various partitions within a split
+sequentially, placing them into the sorter and spilling as needed. Only after all files have been read
+does Spark perform a sort-merge of the spilled files. This process produces a large number of small
+spill files, which further degrades efficiency.
+
+Moreover, Spark’s spill is row-based with a low compression ratio, resulting in approximately 4 times
+amplification compared to the original columnar training data in the data lake. These factors
+significantly degrade task stability and performance. Velox has a `LocalMerge` operator that can be
+introduced into Apache Spark via [Gluten](https://gluten.apache.org/) or [PySpark on Velox](https://www.youtube.com/watch?v=oq5M2861WaQ).
+
+*Note: To keep the focus on merging, the remainder of this article also assumes that each partition’s
+training data is already sorted by primary key—a common setup in training data pipelines.*
+
+
+## LocalMerge Operator
+
+The `LocalMerge` operator consolidates its sources’ outputs into a single, sorted stream of rows.
+It runs single-threaded, while its upstream sources may run multi-threaded within the same task,
+producing multiple sorted inputs concurrently. For example, when merging 24 hourly partitions into
+a single daily partition (as shown in the figure below), the merge plan fragment is split into two pipelines:
+
+- Pipeline 0: contains two operators, `TableScan` and `CallbackSink`. 24 drivers are instantiated to scan the 24 hourly partitions.
+- Pipeline 1: contains only a single operator, `LocalMerge`, with one driver responsible for performing the sort merge.
+
+A `CallbackSink` operator is installed at the end of each driver in Pipeline 0. It pushes the `TableScan`
+operator’s output vectors into the queues backing the merge streams. Inside `LocalMerge`, a `TreeOfLosers`
+performs a k-way merge over the 24 merge streams supplied by the Pipeline 0 drivers, producing a single,
+globally sorted output stream.
+
+
+<figure>
+    <img src="/img/merge.png" height= "100%" width="100%"/>
+</figure>
+
+## Multi-Round Spill Merge
+
+Although `LocalMerge` minimizes comparisons during merging, preserves row-ordering guarantees, and cleanly
+isolates the single-threaded merge from the multi-threaded scan phase for predictable performance, it can
+cause substantial memory pressure—particularly in training-data pipelines. In these workloads, extremely
+wide tables are common, and even after column pruning, thousands of columns may remain.
+
+Moreover, training data is typically stored in [PAX-style formats such as Parquet, ORC, or DRWF](https://www.vldb.org/pvldb/vol17/p148-zeng.pdf).
+Using Parquet as an example, the reader often needs to keep at least one page per column in memory. As a result,
+simply opening a Parquet file with thousands of columns can consume significant memory even before any
+merging occurs. Wide schemas further amplify per-column metadata, dictionary pages, and decompression buffers,
+inflating the overall footprint. In addition, the k-way merge must hold input vectors from multiple sources
+concurrently, which drives peak memory usage even higher.
+
+To cap memory usage and avoid OOM when merging a large number of partitions, we extend `LocalMerge` to
+process fewer local sources at a time, leverage existing spill facilities to persist intermediate
+results, and introduce lazy-start activation for merge inputs. Using the case of merging 24 hourly
+partitions into a single daily partition, the process is organized into two phases:
+
+**Phase 1**
+
+1. Break the scan-and-merge into multiple rounds (e.g., 3 rounds).
+2. In each round, lazily start a limited number of drivers (e.g., drivers 0–7, eight at a time).
+3. The started drivers scan data and push it into the queues backing their respective merge streams.
+4. Perform an in-memory k-way merge and spill the results, producing a spill-file group (one or more spill files per group).
+5. After all inputs from drivers 0–7 are consumed and spilled, the drivers will be closed, and close the file streams opened by their `TableScan` operators, and release associated memory.
+6. Repeat the above steps for the remaining rounds (drivers 8–15, then drivers 16–23), ensuring peak memory stays within budget.
+
+**Phase 2**
+
+1. Create a concatenated file stream for each spill-file group produced in Phase 1.
+2. Schedule one async callback for each concatenated stream to prefetch and push data into a merge stream.
+3. Merge the outputs of the three merge streams using a k-way merge (e.g., a loser-tree), and begin streaming the final, globally sorted results to downstream operators.
+4. The output batch rows is limited adaptively by estimating row size from the merge streams which use the averaged row size from the first batch.
+
+<figure>
+    <img src="/img/spill.merge.png" height= "100%" width="100%"/>
+</figure>
+
+## How To Use
+
+Set `local_merge_spill_enabled` to `true` to enable spilling for the `LocalMerge`
+operator (it is `false` by default). Then, set `local_merge_max_num_merge_sources` to
+control the number of merge sources per round according to your memory management strategy.
+
+*Note: An executor must be configured for spilling, as it would schedule an asynchronous
+callback for each concatenated stream to prefetch data and push it into the merge stream.*
+
+## Future Work
+
+The number of merge sources is adjusted dynamically based on available memory, rather than being
+determined by the `local_merge_max_num_merge_sources` parameter. The process starts with a small
+number of sources, such as 2, and incrementally increases this number for subsequent
+rounds (e.g., to 4) as long as sufficient memory is available. The number of sources stops increasing
+once it reaches a memory-constrained limit.
+
+## Acknowledgements
+
+Thanks to [Xiaoxuan Meng](https://www.linkedin.com/in/xiaoxuanmeng/) and [Pedro Pederia](https://www.linkedin.com/in/pedro-pedreira/) for their guidance, review, and brainstorming.
+I also appreciate the excellent collaboration and work from my colleagues,
+[Xiang Yao](https://www.linkedin.com/in/%E7%BF%94-%E5%A7%9A-1b513a359/),
+[Gang Wang](https://github.com/zjuwangg),
+and [Weixin Xu](https://www.linkedin.com/in/xu-weixin-75b06786/).
diff --git a/website/blog/2025-12-24-why-row-based-sort.mdx b/website/blog/2025-12-24-why-row-based-sort.mdx
new file mode 100644
index 000000000000..5669b24a46f0
--- /dev/null
+++ b/website/blog/2025-12-24-why-row-based-sort.mdx
@@ -0,0 +1,172 @@
+---
+slug: why-row-based-sort
+title: "Why Sort is row-based in Velox — A Quantitative Assessment"
+authors: [duanmeng, xiaoxmeng]
+tags: [tech-blog, sort, operator]
+---
+
+## TL;DR
+
+Velox is a fully vectorized execution engine[1]. Its internal columnar memory layout enhances cache
+locality, exposes more inter-instruction parallelism to CPUs, and enables the use of SIMD instructions,
+significantly accelerating large-scale query processing.
+
+However, some operators in Velox utilize a hybrid layout, where datasets can be temporarily converted
+to a row-oriented format. The `OrderBy` operator is one example, where our implementation first
+materializes the input vectors into rows, containing both sort keys and payload columns, sorts them, and
+converts the rows back to vectors.
+
+In this article, we explain the rationale behind this design decision and provide experimental evidence
+for its implementation. We show a prototype of a hybrid sorting strategy that materializes only the
+sort-key columns, reducing the overhead of materializing payload columns. Contrary to expectations, the
+end-to-end performance did not improve—in fact, it was even up to **3×** slower. We present the two
+variants and discuss why one is counter-intuitively faster than the other.
+
+## Row-based vs. Non-Materialized
+
+### Row-based Sort
+
+The `OrderBy` operator in Velox’s current implementation uses a utility called `SortBuffer` to perform
+the sorting, which consists of three stages:
+
+1. Input Stage: Serializes input Columnar Vectors into a row format, stored in a RowContainer.
+2. Sort Stage: Sorts based on keys within the RowContainer.
+3. Output Stage: Extract output vectors column by column from the RowContainer in sorted order.
+
+<figure>
+    <img src="/img/row-sort.png" height= "100%" width="100%"/>
+</figure>
+
+While row-based sorting is more efficient than column-based sorting[2,3], what if we only
+materialize the sort key columns? We could then use the resulting sort indices to gather
+the payload data into the output vectors directly. This would save the cost of converting
+the payload columns to rows and back again. More importantly, it would allow us to spill
+the original vectors directly to disk rather than first converting rows back into vectors
+for spilling.
+
+### Non-Materialized Sort
+We have implemented a [non-materializing sort strategy](https://github.com/facebookincubator/velox/pull/15157) designed
+to improve sorting performance. The approach materializes only the sort key columns and their original vector indices,
+which are then used to gather the corresponding rows from the original input vectors into the output vector after the
+sort completes. It changes the `SortBuffer` to `NonMaterizedSortBuffer`, which consists of three stages:
+
+1. Input Stage: Holds the input vector (its shared pointer) in a list, serializes key columns
+and additional index columns (VectorIndex and RowIndex) into rows, stored in a RowContainer.
+2. Sort Stage: Sorts based on keys within the RowContainer.
+3. Output Stage: Extracts the VectorIndex and RowIndex columns, uses them together to gather
+the corresponding rows from the original input vectors into the output vector.
+
+<figure>
+    <img src="/img/column-sort.png" height= "100%" width="100%"/>
+</figure>
+
+In theory, this should have significantly reduced the overhead of materializing payload columns,
+especially for wide tables, since only sorting keys are materialized. However, the benchmark results
+were the exact opposite of our expectations. Despite successfully eliminating expensive serialization
+overhead and reducing the total instruction the end-to-end performance was **3x times slower**.
+
+## Benchmark Result
+
+To validate the effectiveness of our new strategy, we designed a benchmark with a varying number of
+payload columns:
+
+- Inputs: 1000 Input Vectors, 4096 rows per vector.
+- Number of payload columns: 64, 128, 256.
+- L2 cache: 80 MiB, L3 cache: 108 MiB.
+
+| numPayloadColumns | Mode | Input Time  | Sorting Time | Output Time  | Total Time  | Desc  |
+| --- | --- | --- | --- | --- | --- | --- |
+| 64 | Row-based | 4.27s | 0.79s | 4.23s | 11.64s | Row-based is 3.9x faster |
+|  | Columnar | 0.28s | 0.84s | 42.30s  | 45.90s | |
+| 128 | Row-based | 20.25s | 1.11s | 5.49s | 31.43s | Row-based is 2.0x faster |
+|  | Columnar | 0.27s | 0.51s | 59.15s | 64.20s |  |
+| 256 | Rows-based | 29.34s | 1.02s | 12.85s | 51.48s | Row-based is 3.0x faster |
+|  | Columnar | 0.87s | 1.10s | 144.00s | 154.80s |  |
+
+The benchmark results confirm that Row-based Sort is the superior strategy,
+delivering a 1.9x to 3.9x overall speedup compared to Columnar Sort. While Row-based Sort
+incurs a significantly higher upfront cost during the Input phase (peaking at 104s), it
+maintains a highly stable and efficient Output phase (maximum 32s). In contrast, Columnar
+Sort suffers from severe performance degradation in the Output phase as the payload increases,
+with execution times surging from 42s to 283s, resulting in a much slower total execution time
+despite its negligible input overhead.
+
+To identify the root cause of the performance divergence, we utilized `perf stat` to analyze
+micro-architectural efficiency and `perf mem` to profile memory access patterns during the critical
+Output phase.
+
+| Metrics | Row-based | Columnar | Desc |
+| --- | --- | --- | --- |
+| Total Instructions | 555.6 Billion | 475.6 Billion | Row +17% |
+| IPC (Instructions Per Cycle) | 2.4 | 0.82 | Row 2.9x Higher |
+| LLC Load Misses (Last Level Cache) | 0.14 Billion | 5.01 Billion | Columnar 35x Higher |
+
+| Memory Level | Row-based Output | Columnar Outputs |
+| --- | --- | --- |
+| RAM Hit | 5.8% | 38.1% |
+| LFB Hit | 1.7% | 18.9% |
+| RAM Hit | 5.8% | 38.1% |
+
+The results reveal a stark contrast in CPU utilization. Although the Row-based approach
+executes 17% more instructions (due to serialization overhead), it maintains a high IPC of 2.4,
+indicating a fully utilized pipeline. In contrast, the Columnar approach suffers from a low IPC
+of 0.82, meaning the CPU is stalled for the majority of cycles. This is directly driven by the
+35x difference in LLC Load Misses, which forces the Columnar implementation to fetch data from
+main memory repeatedly. The memory profile further confirms this bottleneck: Columnar mode is
+severely latency-bound, spending 38.1% of its execution time waiting for DRAM (RAM Hit) and
+experiencing significant congestion in the Line Fill Buffer (18.9% LFB Hit), while Row-based
+mode effectively utilizes the cache hierarchy.
+
+## The Memory Access Pattern
+
+Why does the non-materializing sort, specifically its gather method, cause so many cache misses?
+The answer lies in its memory access pattern. Since Velox is a columnar engine, the output is
+constructed column by column. For each column in an output vector, the gather process does the following:
+1. It iterates through all rows of the current output vector.
+2. For each row, locate the corresponding input vector via the sorted vector index.
+3. Locates the source row in the corresponding input vector.
+4. Copies the data from that single source cell to the target cell.
+
+The sorted indices, by nature, offer low predictability. This forces the gather operation for a single
+output column to jump unpredictably across as many as different input vectors, fetching just one
+value from each. This random access pattern has two devastating consequences for performance.
+
+First, at the micro-level, every single data read becomes a "long-distance" memory jump.
+The CPU's hardware prefetcher is rendered completely ineffective by this chaotic access pattern,
+resulting in almost every lookup yielding a cache miss.
+
+Second, at the macro-level, the problem compounds with each column processed. The sheer
+volume of data touched potentially exceeds the size of the L3 cache. This ensures
+that by the time we start processing the next payload column, the necessary vectors have already
+been evicted from the cache. Consequently, the gather process must re-fetch the same vector
+metadata and data from main memory over and over again for each of the 256 payload columns.
+This results in 256 passes of cache-thrashing, random memory access, leading to a catastrophic
+number of cache misses and explaining the severe performance degradation.
+
+<figure>
+    <img src="/img/columnar-mem.png" height= "100%" width="100%"/>
+</figure>
+
+In contrast, Velox’s current row-based approach serializes all input vectors into rows, with
+each allocation producing a contiguous buffer that holds a subset of those rows. Despite the
+serialization, the row layout preserves strong locality when materializing output
+vectors: once rows are in the cache, they can be used to extract multiple output columns.
+This leads to much better cache-line utilization and fewer cache misses than a columnar layout,
+where each fetched line often yields only a single value per column. Moreover, the largely
+sequential scans over contiguous buffers let the hardware prefetcher operate effectively,
+boosting throughput even in the presence of serialization overhead.
+
+<figure>
+    <img src="/img/row-mem.png" height= "100%" width="100%"/>
+</figure>
+
+## Conclusion
+This study reinforces the core principle of performance engineering: Hardware Sympathy.
+Without understanding the characteristics of the memory hierarchy and optimizing for it,
+simply reducing the instruction count usually does not guarantee better performance.
+
+## Reference
+
+- [1] https://velox-lib.io/blog/velox-primer-part-1/
+- [2] https://duckdb.org/pdf/ICDE2023-kuiper-muehleisen-sorting.pdf
+- [3] https://duckdb.org/2021/08/27/external-sorting
diff --git a/website/blog/authors.yml b/website/blog/authors.yml
index cffe9df50581..d616967290c9 100644
--- a/website/blog/authors.yml
+++ b/website/blog/authors.yml
@@ -26,7 +26,7 @@ mbasmanova:
 
 majetideepak:
   name: Deepak Majeti
-  title: Principal Engineer @ Ahana
+  title: Software Engineer @ IBM
   url: https://github.com/majetideepak
   image_url: https://github.com/majetideepak.png
 
@@ -83,3 +83,15 @@ oerling:
   title: Software Engineer @ Meta
   url: https://github.com/oerling
   image_url: https://github.com/oerling.png
+
+czentgr:
+  name: Christian Zentgraf
+  title: Software Engineer @ IBM
+  url: https://github.com/czentgr
+  image_url: https://github.com/czentgr.png
+
+GregoryKimball:
+  name: Gregory Kimball
+  title: Software Engineer @ NVIDIA
+  url: https://github.com/GregoryKimball
+  image_url: https://github.com/GregoryKimball.png
diff --git a/website/docs/community/03-components-and-maintainers.md b/website/docs/community/03-components-and-maintainers.md
index 2983c33e8f0b..983c4eaeba93 100644
--- a/website/docs/community/03-components-and-maintainers.md
+++ b/website/docs/community/03-components-and-maintainers.md
@@ -84,11 +84,17 @@ maintainers of that component.
 ### Storage Adapters (S3/HDFS/GCS/ABFS)
 
 * Deepak Majeti - [majetideepak](https://github.com/majetideepak) / deepak.majeti@ibm.com
+* Ke Jia - [JkSelf](https://github.com/jkself) / ke.a.jia@intel.com
+
+### LibcuDF Bindings
+
+* Karthikeyan Natarajan - [karthikeyann](https://github.com/karthikeyann) / knataraj@nvidia.com
 
 ### Builds and CI
 
+* Christian Zentgraf - [czentgr](https://github.com/czentgr) / czentgr@us.ibm.com
 * Deepak Majeti - [majetideepak](https://github.com/majetideepak) / deepak.majeti@ibm.com
-* Jacob Wujciak-Jens - [assignUser](https://github.com/assignUser) / jacob@voltrondata.com
+* Jacob Wujciak-Jens - [assignUser](https://github.com/assignUser) / jacob@wujciak.de
 * Krishna Pai - [kgpai](https://github.com/kgpai) / kpai@meta.com
 
 ### Fuzzers and Test Frameworks
diff --git a/website/package-lock.json b/website/package-lock.json
index 806cccc12aea..d7c941a65d0a 100644
--- a/website/package-lock.json
+++ b/website/package-lock.json
@@ -5722,9 +5722,9 @@
       }
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0",
@@ -6287,16 +6287,16 @@
       }
     },
     "node_modules/compression": {
-      "version": "1.7.5",
-      "resolved": "https://registry.npmjs.org/compression/-/compression-1.7.5.tgz",
-      "integrity": "sha512-bQJ0YRck5ak3LgtnpKkiabX5pNF7tMUh1BSy2ZBOTh0Dim0BUu6aPPwByIns6/A5Prh8PufSPerMDUklpzes2Q==",
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/compression/-/compression-1.8.1.tgz",
+      "integrity": "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==",
       "license": "MIT",
       "dependencies": {
         "bytes": "3.1.2",
         "compressible": "~2.0.18",
         "debug": "2.6.9",
         "negotiator": "~0.6.4",
-        "on-headers": "~1.0.2",
+        "on-headers": "~1.1.0",
         "safe-buffer": "5.2.1",
         "vary": "~1.1.2"
       },
@@ -9341,9 +9341,9 @@
       }
     },
     "node_modules/http-proxy-middleware": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.7.tgz",
-      "integrity": "sha512-fgVY8AV7qU7z/MmXJ/rxwbrtQH4jBQ9m7kp3llF0liB7glmFeVZFBepQb32T3y8n8k2+AEYuMPCpinYW+/CuRA==",
+      "version": "2.0.9",
+      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz",
+      "integrity": "sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==",
       "license": "MIT",
       "dependencies": {
         "@types/http-proxy": "^1.17.8",
@@ -12898,9 +12898,9 @@
       }
     },
     "node_modules/on-headers": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.0.2.tgz",
-      "integrity": "sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.1.0.tgz",
+      "integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.8"
diff --git a/website/src/components/VeloxConBanner/index.js b/website/src/components/VeloxConBanner/index.js
index 78dce089f33a..80d9f707a137 100644
--- a/website/src/components/VeloxConBanner/index.js
+++ b/website/src/components/VeloxConBanner/index.js
@@ -1,27 +1,23 @@
 import React from 'react';
-import clsx from 'clsx';
 import styles from './styles.module.css';
-import useBaseUrl from "@docusaurus/useBaseUrl";
+import Link from '@docusaurus/Link';
 
 export default function VeloxConBanner() {
   return (
-    <section className={styles.banner}>
-      <div className="container">
-        <div className="row">
-          <div className="col col--9">
-            <h2>VeloxCon 2025 Sessions Are Now Available On-Demand</h2>
-          </div>
-          <div className="col col--3">
-            <a
-              className="button button--info button--lg"
-              href="https://www.youtube.com/playlist?list=PLJvBe8nQAEsE0dT7XVIrD8QE-gmuX3Fe6"
-              target="_blank"
-              rel="noopener noreferrer"
-            >
-              Watch Now
-            </a>
-          </div>
+    <section className={styles.banner} role="region" aria-label="VeloxCon China announcement">
+      <div className={styles.container}>
+        <div className={styles.text}>
+          <h2 className={styles.title}>Announcing VeloxCon China 2025</h2>
+          <p className={styles.subtitle}>December 13 | Ant Group Offices, Beijing</p>
         </div>
+        <Link
+          className={styles.button}
+          to="https://www.bagevent.com/event/veloxcon-china-2025-en"
+          target="_blank"
+          rel="noopener noreferrer"
+        >
+          Learn more and Register →
+        </Link>
       </div>
     </section>
   );
diff --git a/website/src/components/VeloxConBanner/styles.module.css b/website/src/components/VeloxConBanner/styles.module.css
index f670fe2fc7da..dd1bf51334f7 100644
--- a/website/src/components/VeloxConBanner/styles.module.css
+++ b/website/src/components/VeloxConBanner/styles.module.css
@@ -1,20 +1,69 @@
 .banner {
+  background-color: #c62828;
+  /* optional subtle crosshatch pattern */
+  background-image:
+    repeating-linear-gradient(
+      45deg,
+      rgba(255, 255, 255, 0.05),
+      rgba(255, 255, 255, 0.05) 2px,
+      transparent 2px,
+      transparent 40px
+    ),
+    repeating-linear-gradient(
+      -45deg,
+      rgba(255, 255, 255, 0.05),
+      rgba(255, 255, 255, 0.05) 2px,
+      transparent 2px,
+      transparent 40px
+    );
+  background-blend-mode: overlay;
+  color: #ffffff;
+  padding: 20px 16px; /* thinner! was 40px 16px */
+  border-top: 1px solid rgba(255, 255, 255, 0.08);
+  border-bottom: 1px solid rgba(0, 0, 0, 0.08);
+}
+
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  text-align: center;
   display: flex;
+  flex-direction: column;
   align-items: center;
-  padding: 1rem 0;
-  width: 100%;
-  background: url("/static/img/banner-pattern.svg") center center #143d99;
-  color: #fff;
+  justify-content: center;
 }
 
-.banner >div>div {
-  max-width: 600px;
-  justify-content: space-around;
-  align-items: center;
-  margin: 0 auto;
-  text-align:center;
+.text {
+  text-align: center;
+  margin-bottom: 8px;
+}
+
+.title {
+  font-size: 1.6rem; /* slightly smaller to match new height */
+  font-weight: 700;
+  margin: 0;
+  line-height: 1.2;
+}
+
+.subtitle {
+  font-size: 1rem;
+  margin: 4px 0 12px;
+  opacity: 0.95;
+}
+
+.button {
+  display: inline-block;
+  background-color: #ffffff;
+  color: #c62828;
+  padding: 8px 16px;
+  border-radius: 6px;
+  font-weight: 600;
+  text-decoration: none;
+  transition: transform 0.15s ease, background-color 0.15s ease, color 0.15s ease;
 }
 
-.banner h2, .banner p {
-  margin-bottom: 5px;
+.button:hover {
+  background-color: #ffe5e5;
+  color: #b71c1c;
+  transform: translateY(-1px);
 }
diff --git a/website/src/pages/index.js b/website/src/pages/index.js
index c97d5d25c6bd..bb5bfd670ff1 100644
--- a/website/src/pages/index.js
+++ b/website/src/pages/index.js
@@ -239,6 +239,48 @@ function LatestCommunityNews() {
 
           <div className={styles.tileScroll} ref={scrollRef}>
             {/* Each tile is boxed */}
+            <a href="https://veloxcon.io/veloxcon-china/" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Event</span>
+  <h3>VeloxCon China 2025</h3>
+  <p>Join us in Beijing on December 13 for our first community event in China.</p>
+  <span className={styles.newsDate}>December 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/multi-round-local-merge" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Multi-Round Lazy Start Merge</h3>
+  <p>The latest Velox update introduces a multi-round spill merge with lazy-start activation.</p>
+  <span className={styles.newsDate}>November 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/shared-build" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Enabling Shared Library Builds in Velox</h3>
+  <p>Learn how we unblocked shared library builds in Velox.</p>
+  <span className={styles.newsDate}>November 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/cpp20-standard" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Velox switches to C++20 standard</h3>
+  <p>Going forward Velox is looking to enhance the codebase by making use of newer compiler functionalities.</p>
+  <span className={styles.newsDate}>August 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/extending-velox-with-cudf" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>Extending Velox – GPU Acceleration with cuDF</h3>
+  <p>This post describes the design principles and software components for extending Velox with hardware acceleration using NVIDIA's cuDF.</p>
+  <span className={styles.newsDate}>July 2025</span>
+</a>
+
+<a href="https://velox-lib.io/blog/segfault-dependency-update" className={styles.newsTile} target="_blank" rel="noopener">
+  <span className={styles.newsTag}>Blog</span>
+  <h3>SEGFAULT due to Dependency Update</h3>
+  <p>How upgrading Folly and Facebook Thrift revealed a surprising issue with coroutine compile flags and vtable structures.</p>
+  <span className={styles.newsDate}>July 2025</span>
+</a>
+
             <a href="https://velox-lib.io/blog/velox-primer-part-3" className={styles.newsTile} target="_blank" rel="noopener">
               <span className={styles.newsTag}>Blog</span>
               <h3>Velox Primer: Part 3</h3>
diff --git a/website/static/img/2025-07-11-cudf-driveradapter.png b/website/static/img/2025-07-11-cudf-driveradapter.png
new file mode 100644
index 000000000000..d01edc0b67db
Binary files /dev/null and b/website/static/img/2025-07-11-cudf-driveradapter.png differ
diff --git a/website/static/img/bm-report.png b/website/static/img/bm-report.png
new file mode 100644
index 000000000000..4e493cf4db07
Binary files /dev/null and b/website/static/img/bm-report.png differ
diff --git a/website/static/img/column-sort.png b/website/static/img/column-sort.png
new file mode 100644
index 000000000000..36a047854dd6
Binary files /dev/null and b/website/static/img/column-sort.png differ
diff --git a/website/static/img/columnar-mem.png b/website/static/img/columnar-mem.png
new file mode 100644
index 000000000000..05044b89ec26
Binary files /dev/null and b/website/static/img/columnar-mem.png differ
diff --git a/website/static/img/merge.png b/website/static/img/merge.png
new file mode 100644
index 000000000000..3c075138a372
Binary files /dev/null and b/website/static/img/merge.png differ
diff --git a/website/static/img/row-mem.png b/website/static/img/row-mem.png
new file mode 100644
index 000000000000..06e2c2e4ed8f
Binary files /dev/null and b/website/static/img/row-mem.png differ
diff --git a/website/static/img/row-sort.png b/website/static/img/row-sort.png
new file mode 100644
index 000000000000..b50410109e68
Binary files /dev/null and b/website/static/img/row-sort.png differ
diff --git a/website/static/img/spill.merge.png b/website/static/img/spill.merge.png
new file mode 100644
index 000000000000..d8e74cc7702e
Binary files /dev/null and b/website/static/img/spill.merge.png differ
diff --git a/website/yarn.lock b/website/yarn.lock
index e192b8484b05..f5ee9d96a08b 100644
--- a/website/yarn.lock
+++ b/website/yarn.lock
@@ -139,16 +139,6 @@
     "@algolia/requester-fetch" "5.18.0"
     "@algolia/requester-node-http" "5.18.0"
 
-"@algolia/client-search@>= 4.9.1 < 6", "@algolia/client-search@5.18.0":
-  version "5.18.0"
-  resolved "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.18.0.tgz"
-  integrity sha512-qI3LcFsVgtvpsBGR7aNSJYxhsR+Zl46+958ODzg8aCxIcdxiK7QEVLMJMZAR57jGqW0Lg/vrjtuLFDMfSE53qA==
-  dependencies:
-    "@algolia/client-common" "5.18.0"
-    "@algolia/requester-browser-xhr" "5.18.0"
-    "@algolia/requester-fetch" "5.18.0"
-    "@algolia/requester-node-http" "5.18.0"
-
 "@algolia/client-search@4.24.0":
   version "4.24.0"
   resolved "https://registry.npmjs.org/@algolia/client-search/-/client-search-4.24.0.tgz"
@@ -158,6 +148,16 @@
     "@algolia/requester-common" "4.24.0"
     "@algolia/transporter" "4.24.0"
 
+"@algolia/client-search@5.18.0":
+  version "5.18.0"
+  resolved "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.18.0.tgz"
+  integrity sha512-qI3LcFsVgtvpsBGR7aNSJYxhsR+Zl46+958ODzg8aCxIcdxiK7QEVLMJMZAR57jGqW0Lg/vrjtuLFDMfSE53qA==
+  dependencies:
+    "@algolia/client-common" "5.18.0"
+    "@algolia/requester-browser-xhr" "5.18.0"
+    "@algolia/requester-fetch" "5.18.0"
+    "@algolia/requester-node-http" "5.18.0"
+
 "@algolia/events@^4.0.1":
   version "4.0.1"
   resolved "https://registry.npmjs.org/@algolia/events/-/events-4.0.1.tgz"
@@ -293,7 +293,7 @@
   resolved "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.26.3.tgz"
   integrity sha512-nHIxvKPniQXpmQLb0vhY3VaFb3S0YrTAwpOWJZh1wn3oJPjJk9Asva204PsBdmAE8vpzfHudT8DB0scYvy9q0g==
 
-"@babel/core@^7.0.0", "@babel/core@^7.0.0-0", "@babel/core@^7.0.0-0 || ^8.0.0-0 <8.0.0", "@babel/core@^7.12.0", "@babel/core@^7.13.0", "@babel/core@^7.21.3", "@babel/core@^7.25.9", "@babel/core@^7.4.0 || ^8.0.0-0 <8.0.0":
+"@babel/core@^7.21.3", "@babel/core@^7.25.9":
   version "7.26.0"
   resolved "https://registry.npmjs.org/@babel/core/-/core-7.26.0.tgz"
   integrity sha512-i1SLeK+DzNnQ3LL/CswPCa/E5u4lh1k6IAEphON8F+cXt0t9euTshDru0q7/IqMa1PMPz5RnHuHscF8/ZJsStg==
@@ -1700,7 +1700,7 @@
     utility-types "^3.10.0"
     webpack "^5.88.1"
 
-"@docusaurus/plugin-content-docs@*", "@docusaurus/plugin-content-docs@3.6.3":
+"@docusaurus/plugin-content-docs@3.6.3":
   version "3.6.3"
   resolved "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.6.3.tgz"
   integrity sha512-r2wS8y/fsaDcxkm20W5bbYJFPzdWdEaTWVYjNxlHlcmX086eqQR1Fomlg9BHTJ0dLXPzAlbC8EN4XqMr3QzNCQ==
@@ -1759,7 +1759,7 @@
     "@docusaurus/utils-validation" "3.6.3"
     tslib "^2.6.0"
 
-"@docusaurus/plugin-google-gtag@^3.6.3", "@docusaurus/plugin-google-gtag@3.6.3":
+"@docusaurus/plugin-google-gtag@3.6.3", "@docusaurus/plugin-google-gtag@^3.6.3":
   version "3.6.3"
   resolved "https://registry.npmjs.org/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.6.3.tgz"
   integrity sha512-+OyDvhM6rqVkQOmLVkQWVJAizEEfkPzVWtIHXlWPOCFGK9X4/AWeBSrU0WG4iMg9Z4zD4YDRrU+lvI4s6DSC+w==
@@ -2079,7 +2079,7 @@
     "@nodelib/fs.stat" "2.0.5"
     run-parallel "^1.1.9"
 
-"@nodelib/fs.stat@^2.0.2", "@nodelib/fs.stat@2.0.5":
+"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
   version "2.0.5"
   resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz"
   integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
@@ -2213,7 +2213,7 @@
     "@svgr/babel-plugin-transform-react-native-svg" "8.1.0"
     "@svgr/babel-plugin-transform-svg-component" "8.0.0"
 
-"@svgr/core@*", "@svgr/core@8.1.0":
+"@svgr/core@8.1.0":
   version "8.1.0"
   resolved "https://registry.npmjs.org/@svgr/core/-/core-8.1.0.tgz"
   integrity sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==
@@ -2534,7 +2534,7 @@
     "@types/history" "^4.7.11"
     "@types/react" "*"
 
-"@types/react@*", "@types/react@>= 16.8.0 < 19.0.0", "@types/react@>=16":
+"@types/react@*":
   version "18.3.18"
   resolved "https://registry.npmjs.org/@types/react/-/react-18.3.18.tgz"
   integrity sha512-t4yC+vtgnkYjNSKlFx1jkAhH8LgTo2N/7Qvi83kdEaUtMDiwpbLAktKDaAMlRcJ5eSxZkH74eEGt1ky31d7kfQ==
@@ -2619,7 +2619,7 @@
   resolved "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.1.tgz"
   integrity sha512-fEzPV3hSkSMltkw152tJKNARhOupqbH96MZWyRjNaYZOMIzbrTeQDG+MTc6Mr2pgzFQzFxAfmhGDNP5QK++2ZA==
 
-"@webassemblyjs/ast@^1.14.1", "@webassemblyjs/ast@1.14.1":
+"@webassemblyjs/ast@1.14.1", "@webassemblyjs/ast@^1.14.1":
   version "1.14.1"
   resolved "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz"
   integrity sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==
@@ -2720,7 +2720,7 @@
     "@webassemblyjs/wasm-gen" "1.14.1"
     "@webassemblyjs/wasm-parser" "1.14.1"
 
-"@webassemblyjs/wasm-parser@^1.14.1", "@webassemblyjs/wasm-parser@1.14.1":
+"@webassemblyjs/wasm-parser@1.14.1", "@webassemblyjs/wasm-parser@^1.14.1":
   version "1.14.1"
   resolved "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz"
   integrity sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==
@@ -2770,7 +2770,7 @@ acorn-walk@^8.0.0:
   dependencies:
     acorn "^8.11.0"
 
-"acorn@^6.0.0 || ^7.0.0 || ^8.0.0", acorn@^8.0.0, acorn@^8.0.4, acorn@^8.11.0, acorn@^8.14.0, acorn@^8.8.2:
+acorn@^8.0.0, acorn@^8.0.4, acorn@^8.11.0, acorn@^8.14.0, acorn@^8.8.2:
   version "8.14.0"
   resolved "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz"
   integrity sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==
@@ -2795,12 +2795,7 @@ ajv-formats@^2.1.1:
   dependencies:
     ajv "^8.0.0"
 
-ajv-keywords@^3.4.1:
-  version "3.5.2"
-  resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz"
-  integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
-
-ajv-keywords@^3.5.2:
+ajv-keywords@^3.4.1, ajv-keywords@^3.5.2:
   version "3.5.2"
   resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz"
   integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
@@ -2812,7 +2807,7 @@ ajv-keywords@^5.1.0:
   dependencies:
     fast-deep-equal "^3.1.3"
 
-ajv@^6.12.2, ajv@^6.12.5, ajv@^6.9.1:
+ajv@^6.12.2, ajv@^6.12.5:
   version "6.12.6"
   resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
@@ -2822,7 +2817,7 @@ ajv@^6.12.2, ajv@^6.12.5, ajv@^6.9.1:
     json-schema-traverse "^0.4.1"
     uri-js "^4.2.2"
 
-ajv@^8.0.0, ajv@^8.8.2, ajv@^8.9.0:
+ajv@^8.0.0, ajv@^8.9.0:
   version "8.17.1"
   resolved "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz"
   integrity sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==
@@ -2839,7 +2834,7 @@ algoliasearch-helper@^3.13.3:
   dependencies:
     "@algolia/events" "^4.0.1"
 
-algoliasearch@^4.18.0, "algoliasearch@>= 3.1 < 6", "algoliasearch@>= 4.9.1 < 6":
+algoliasearch@^4.18.0:
   version "4.24.0"
   resolved "https://registry.npmjs.org/algoliasearch/-/algoliasearch-4.24.0.tgz"
   integrity sha512-bf0QV/9jVejssFBmz2HQLxUadxk574t4iwjCKp5E7NBzwKkrDEhKPISIIjAU/p6K5qDx3qoeh4+26zWN1jmw3g==
@@ -3115,9 +3110,9 @@ boxen@^7.0.0:
     wrap-ansi "^8.1.0"
 
 brace-expansion@^1.1.7:
-  version "1.1.11"
-  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz"
-  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
+  version "1.1.12"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.12.tgz#ab9b454466e5a8cc3a187beaad580412a9c5b843"
+  integrity sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==
   dependencies:
     balanced-match "^1.0.0"
     concat-map "0.0.1"
@@ -3129,7 +3124,7 @@ braces@^3.0.3, braces@~3.0.2:
   dependencies:
     fill-range "^7.1.1"
 
-browserslist@^4.0.0, browserslist@^4.18.1, browserslist@^4.23.0, browserslist@^4.23.1, browserslist@^4.23.3, browserslist@^4.24.0, browserslist@^4.24.2, "browserslist@>= 4.21.0":
+browserslist@^4.0.0, browserslist@^4.18.1, browserslist@^4.23.0, browserslist@^4.23.1, browserslist@^4.23.3, browserslist@^4.24.0, browserslist@^4.24.2:
   version "4.24.3"
   resolved "https://registry.npmjs.org/browserslist/-/browserslist-4.24.3.tgz"
   integrity sha512-1CPmv8iobE2fyRMV97dAcMVegvvWKxmq94hkLiAkUGwKVTyDLw33K+ZxiFrREKmmps4rIw6grcCFCnTMSZ/YiA==
@@ -3451,15 +3446,15 @@ compressible@~2.0.18:
     mime-db ">= 1.43.0 < 2"
 
 compression@^1.7.4:
-  version "1.7.5"
-  resolved "https://registry.npmjs.org/compression/-/compression-1.7.5.tgz"
-  integrity sha512-bQJ0YRck5ak3LgtnpKkiabX5pNF7tMUh1BSy2ZBOTh0Dim0BUu6aPPwByIns6/A5Prh8PufSPerMDUklpzes2Q==
+  version "1.8.1"
+  resolved "https://registry.yarnpkg.com/compression/-/compression-1.8.1.tgz#4a45d909ac16509195a9a28bd91094889c180d79"
+  integrity sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==
   dependencies:
     bytes "3.1.2"
     compressible "~2.0.18"
     debug "2.6.9"
     negotiator "~0.6.4"
-    on-headers "~1.0.2"
+    on-headers "~1.1.0"
     safe-buffer "5.2.1"
     vary "~1.1.2"
 
@@ -3789,27 +3784,20 @@ debounce@^1.2.1:
   resolved "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz"
   integrity sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==
 
-debug@^2.6.0:
+debug@2.6.9, debug@^2.6.0:
   version "2.6.9"
   resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz"
   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
   dependencies:
     ms "2.0.0"
 
-debug@^4.0.0, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@4:
+debug@4, debug@^4.0.0, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1:
   version "4.4.0"
   resolved "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz"
   integrity sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==
   dependencies:
     ms "^2.1.3"
 
-debug@2.6.9:
-  version "2.6.9"
-  resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz"
-  integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
-  dependencies:
-    ms "2.0.0"
-
 decode-named-character-reference@^1.0.0:
   version "1.0.2"
   resolved "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.0.2.tgz"
@@ -3888,16 +3876,16 @@ delayed-stream@~1.0.0:
   resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz"
   integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
 
-depd@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz"
-  integrity sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==
-
 depd@2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz"
   integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
 
+depd@~1.1.2:
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz"
+  integrity sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==
+
 dequal@^2.0.0:
   version "2.0.3"
   resolved "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz"
@@ -4437,7 +4425,7 @@ figures@^3.2.0:
   dependencies:
     escape-string-regexp "^1.0.5"
 
-file-loader@*, file-loader@^6.2.0:
+file-loader@^6.2.0:
   version "6.2.0"
   resolved "https://registry.npmjs.org/file-loader/-/file-loader-6.2.0.tgz"
   integrity sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==
@@ -4751,16 +4739,16 @@ got@^12.1.0:
     p-cancelable "^3.0.0"
     responselike "^3.0.0"
 
-graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.11, graceful-fs@^4.2.4, graceful-fs@^4.2.6, graceful-fs@^4.2.9:
-  version "4.2.11"
-  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz"
-  integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
-
 graceful-fs@4.2.10:
   version "4.2.10"
   resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz"
   integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==
 
+graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.11, graceful-fs@^4.2.4, graceful-fs@^4.2.6, graceful-fs@^4.2.9:
+  version "4.2.11"
+  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz"
+  integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
+
 gray-matter@^4.0.3:
   version "4.0.3"
   resolved "https://registry.npmjs.org/gray-matter/-/gray-matter-4.0.3.tgz"
@@ -5047,16 +5035,6 @@ http-deceiver@^1.2.7:
   resolved "https://registry.npmjs.org/http-deceiver/-/http-deceiver-1.2.7.tgz"
   integrity sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==
 
-http-errors@~1.6.2:
-  version "1.6.3"
-  resolved "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz"
-  integrity sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==
-  dependencies:
-    depd "~1.1.2"
-    inherits "2.0.3"
-    setprototypeof "1.1.0"
-    statuses ">= 1.4.0 < 2"
-
 http-errors@2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz"
@@ -5068,15 +5046,25 @@ http-errors@2.0.0:
     statuses "2.0.1"
     toidentifier "1.0.1"
 
+http-errors@~1.6.2:
+  version "1.6.3"
+  resolved "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz"
+  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.npmjs.org/http-parser-js/-/http-parser-js-0.5.8.tgz"
   integrity sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==
 
 http-proxy-middleware@^2.0.3:
-  version "2.0.7"
-  resolved "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.7.tgz"
-  integrity sha512-fgVY8AV7qU7z/MmXJ/rxwbrtQH4jBQ9m7kp3llF0liB7glmFeVZFBepQb32T3y8n8k2+AEYuMPCpinYW+/CuRA==
+  version "2.0.9"
+  resolved "https://registry.yarnpkg.com/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz#e9e63d68afaa4eee3d147f39149ab84c0c2815ef"
+  integrity sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==
   dependencies:
     "@types/http-proxy" "^1.17.8"
     http-proxy "^1.18.1"
@@ -5171,7 +5159,7 @@ inflight@^1.0.4:
     once "^1.3.0"
     wrappy "1"
 
-inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.3, inherits@2, inherits@2.0.4:
+inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.3:
   version "2.0.4"
   resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
@@ -5181,16 +5169,16 @@ inherits@2.0.3:
   resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz"
   integrity sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==
 
-ini@^1.3.4, ini@^1.3.5, ini@~1.3.0:
-  version "1.3.8"
-  resolved "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz"
-  integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
-
 ini@2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz"
   integrity sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==
 
+ini@^1.3.4, ini@^1.3.5, ini@~1.3.0:
+  version "1.3.8"
+  resolved "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz"
+  integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
+
 inline-style-parser@0.1.1:
   version "0.1.1"
   resolved "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.1.1.tgz"
@@ -5213,16 +5201,16 @@ invariant@^2.2.4:
   dependencies:
     loose-envify "^1.0.0"
 
-ipaddr.js@^2.0.1:
-  version "2.2.0"
-  resolved "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.2.0.tgz"
-  integrity sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==
-
 ipaddr.js@1.9.1:
   version "1.9.1"
   resolved "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz"
   integrity sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==
 
+ipaddr.js@^2.0.1:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.2.0.tgz"
+  integrity sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==
+
 is-alphabetical@^2.0.0:
   version "2.0.1"
   resolved "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz"
@@ -5386,16 +5374,16 @@ is-yarn-global@^0.4.0:
   resolved "https://registry.npmjs.org/is-yarn-global/-/is-yarn-global-0.4.1.tgz"
   integrity sha512-/kppl+R+LO5VmhYSEWARUFjodS25D68gvj8W7z0I7OWhUla5xWu8KL6CtB2V0R6yqhnRgbcaREMr4EEM6htLPQ==
 
-isarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz"
-  integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==
-
 isarray@0.0.1:
   version "0.0.1"
   resolved "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz"
   integrity sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==
 
+isarray@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz"
+  integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==
+
 isexe@^2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
@@ -6363,7 +6351,7 @@ micromatch@^4.0.2, micromatch@^4.0.4, micromatch@^4.0.5:
     braces "^3.0.3"
     picomatch "^2.3.1"
 
-"mime-db@>= 1.43.0 < 2", mime-db@1.52.0:
+mime-db@1.52.0, "mime-db@>= 1.43.0 < 2":
   version "1.52.0"
   resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz"
   integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
@@ -6373,13 +6361,6 @@ mime-db@~1.33.0:
   resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.33.0.tgz"
   integrity sha512-BHJ/EKruNIqJf/QahvxwQZXKygOQ256myeN/Ew+THcAa5q+PjyTTMMeNQC4DZw5AwfvelsUrA6B67NKMqXDbzQ==
 
-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.npmjs.org/mime-types/-/mime-types-2.1.35.tgz"
-  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
-  dependencies:
-    mime-db "1.52.0"
-
 mime-types@2.1.18:
   version "2.1.18"
   resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.18.tgz"
@@ -6387,6 +6368,13 @@ mime-types@2.1.18:
   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.npmjs.org/mime-types/-/mime-types-2.1.35.tgz"
+  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
+  dependencies:
+    mime-db "1.52.0"
+
 mime@1.6.0:
   version "1.6.0"
   resolved "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz"
@@ -6420,7 +6408,7 @@ minimalistic-assert@^1.0.0:
   resolved "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz"
   integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
 
-minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@3.1.2:
+minimatch@3.1.2, minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1:
   version "3.1.2"
   resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz"
   integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
@@ -6437,16 +6425,16 @@ mrmime@^2.0.0:
   resolved "https://registry.npmjs.org/mrmime/-/mrmime-2.0.0.tgz"
   integrity sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==
 
-ms@^2.1.3, ms@2.1.3:
-  version "2.1.3"
-  resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz"
-  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
-
 ms@2.0.0:
   version "2.0.0"
   resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz"
   integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
 
+ms@2.1.3, ms@^2.1.3:
+  version "2.1.3"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz"
+  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
+
 multicast-dns@^7.2.5:
   version "7.2.5"
   resolved "https://registry.npmjs.org/multicast-dns/-/multicast-dns-7.2.5.tgz"
@@ -6460,16 +6448,16 @@ nanoid@^3.3.7:
   resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz"
   integrity sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==
 
-negotiator@~0.6.4:
-  version "0.6.4"
-  resolved "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz"
-  integrity sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==
-
 negotiator@0.6.3:
   version "0.6.3"
   resolved "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz"
   integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==
 
+negotiator@~0.6.4:
+  version "0.6.4"
+  resolved "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz"
+  integrity sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==
+
 neo-async@^2.6.2:
   version "2.6.2"
   resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz"
@@ -6584,10 +6572,10 @@ on-finished@2.4.1:
   dependencies:
     ee-first "1.1.1"
 
-on-headers@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.npmjs.org/on-headers/-/on-headers-1.0.2.tgz"
-  integrity sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==
+on-headers@~1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/on-headers/-/on-headers-1.1.0.tgz#59da4f91c45f5f989c6e4bcedc5a3b0aed70ff65"
+  integrity sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==
 
 once@^1.3.0:
   version "1.4.0"
@@ -6800,13 +6788,6 @@ path-parse@^1.0.7:
   resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz"
   integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
 
-path-to-regexp@^1.7.0:
-  version "1.9.0"
-  resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.9.0.tgz"
-  integrity sha512-xIp7/apCFJuUHdDLWe8O1HIkb0kQrOMb/0u6FXQjemHn/ii5LrIzU6bdECnsiTF/GjZkMEKg1xdiZwNqDYlZ6g==
-  dependencies:
-    isarray "0.0.1"
-
 path-to-regexp@0.1.12:
   version "0.1.12"
   resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz"
@@ -6817,6 +6798,13 @@ path-to-regexp@3.3.0:
   resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-3.3.0.tgz"
   integrity sha512-qyCH421YQPS2WFDxDjftfc1ZR5WKQzVzqsp4n9M2kQhVOo/ByahFoUNJfl58kOcEGfQ//7weFTDhm+ss8Ecxgw==
 
+path-to-regexp@^1.7.0:
+  version "1.9.0"
+  resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.9.0.tgz"
+  integrity sha512-xIp7/apCFJuUHdDLWe8O1HIkb0kQrOMb/0u6FXQjemHn/ii5LrIzU6bdECnsiTF/GjZkMEKg1xdiZwNqDYlZ6g==
+  dependencies:
+    isarray "0.0.1"
+
 path-type@^4.0.0:
   version "4.0.0"
   resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz"
@@ -7393,7 +7381,7 @@ postcss-zindex@^6.0.2:
   resolved "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-6.0.2.tgz"
   integrity sha512-5BxW9l1evPB/4ZIc+2GobEBoKC+h8gPGCMi+jxsYvd2x0mjq7wazk6DrP71pStqxE9Foxh5TVnonbWpFZzXaYg==
 
-"postcss@^7.0.0 || ^8.0.1", postcss@^8, postcss@^8.0.3, postcss@^8.0.9, postcss@^8.1.0, postcss@^8.2.2, postcss@^8.4, postcss@^8.4.21, postcss@^8.4.23, postcss@^8.4.24, postcss@^8.4.26, postcss@^8.4.31, postcss@^8.4.33, postcss@^8.4.38, postcss@^8.4.6:
+postcss@^8.4.21, postcss@^8.4.24, postcss@^8.4.26, postcss@^8.4.33, postcss@^8.4.38:
   version "8.4.49"
   resolved "https://registry.npmjs.org/postcss/-/postcss-8.4.49.tgz"
   integrity sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==
@@ -7516,21 +7504,16 @@ randombytes@^2.1.0:
   dependencies:
     safe-buffer "^5.1.0"
 
-range-parser@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz"
-  integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
-
-range-parser@~1.2.1:
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz"
-  integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
-
 range-parser@1.2.0:
   version "1.2.0"
   resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz"
   integrity sha512-kA5WQoNVo4t9lNx2kQNFCxKeBl5IbbSNBl1M/tLkw9WCn+hxNBAW5Qh8gdhs63CJnhjJ2zQWFoqPJP2sK1AV5A==
 
+range-parser@^1.2.1, range-parser@~1.2.1:
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz"
+  integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
+
 raw-body@2.5.2:
   version "2.5.2"
   resolved "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz"
@@ -7581,7 +7564,7 @@ react-dev-utils@^12.0.1:
     strip-ansi "^6.0.1"
     text-table "^0.2.0"
 
-react-dom@*, "react-dom@^16.6.0 || ^17.0.0 || ^18.0.0", react-dom@^18.0.0, react-dom@^18.3.1, "react-dom@>= 16.8.0 < 19.0.0":
+react-dom@^18.3.1:
   version "18.3.1"
   resolved "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz"
   integrity sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==
@@ -7627,7 +7610,7 @@ react-loadable-ssr-addon-v5-slorber@^1.0.1:
   dependencies:
     "@babel/runtime" "^7.10.3"
 
-react-loadable@*, "react-loadable@npm:@docusaurus/react-loadable@6.0.0":
+"react-loadable@npm:@docusaurus/react-loadable@6.0.0":
   version "6.0.0"
   resolved "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz"
   integrity sha512-YMMxTUQV/QFSnbgrP3tjDzLHRg7vsbMn8e9HAa8o/1iXoiomo48b7sk/kkmWEuWNDPJVlKSJRB6Y2fHqdJk+SQ==
@@ -7654,7 +7637,7 @@ react-router-dom@^5.3.4:
     tiny-invariant "^1.0.2"
     tiny-warning "^1.0.0"
 
-react-router@^5.3.4, react-router@>=5, react-router@5.3.4:
+react-router@5.3.4, react-router@^5.3.4:
   version "5.3.4"
   resolved "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz"
   integrity sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==
@@ -7669,7 +7652,7 @@ react-router@^5.3.4, react-router@>=5, react-router@5.3.4:
     tiny-invariant "^1.0.2"
     tiny-warning "^1.0.0"
 
-react@*, "react@^16.13.1 || ^17.0.0 || ^18.0.0", "react@^16.6.0 || ^17.0.0 || ^18.0.0", react@^18.0.0, react@^18.3.1, "react@>= 16.8.0 < 19.0.0", react@>=15, react@>=16, react@>=16.0.0:
+react@^18.3.1:
   version "18.3.1"
   resolved "https://registry.npmjs.org/react/-/react-18.3.1.tgz"
   integrity sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==
@@ -8031,7 +8014,7 @@ run-parallel@^1.1.9:
   dependencies:
     queue-microtask "^1.2.2"
 
-safe-buffer@^5.1.0, safe-buffer@>=5.1.0, safe-buffer@~5.2.0, safe-buffer@5.2.1:
+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.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
@@ -8058,16 +8041,16 @@ scheduler@^0.23.2:
   dependencies:
     loose-envify "^1.1.0"
 
-schema-utils@^3.0.0:
-  version "3.3.0"
-  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz"
-  integrity sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==
+schema-utils@2.7.0:
+  version "2.7.0"
+  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.0.tgz"
+  integrity sha512-0ilKFI6QQF5nxDZLFn2dMjvc4hjg/Wkg7rHd3jK6/A4a1Hl9VFdQWvgB1UMGoU94pad1P/8N7fMcEnLnSiju8A==
   dependencies:
-    "@types/json-schema" "^7.0.8"
-    ajv "^6.12.5"
-    ajv-keywords "^3.5.2"
+    "@types/json-schema" "^7.0.4"
+    ajv "^6.12.2"
+    ajv-keywords "^3.4.1"
 
-schema-utils@^3.2.0:
+schema-utils@^3.0.0, schema-utils@^3.2.0:
   version "3.3.0"
   resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz"
   integrity sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==
@@ -8086,20 +8069,6 @@ schema-utils@^4.0.0, schema-utils@^4.0.1, schema-utils@^4.3.0:
     ajv-formats "^2.1.1"
     ajv-keywords "^5.1.0"
 
-schema-utils@2.7.0:
-  version "2.7.0"
-  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.0.tgz"
-  integrity sha512-0ilKFI6QQF5nxDZLFn2dMjvc4hjg/Wkg7rHd3jK6/A4a1Hl9VFdQWvgB1UMGoU94pad1P/8N7fMcEnLnSiju8A==
-  dependencies:
-    "@types/json-schema" "^7.0.4"
-    ajv "^6.12.2"
-    ajv-keywords "^3.4.1"
-
-"search-insights@>= 1 < 3":
-  version "2.17.3"
-  resolved "https://registry.npmjs.org/search-insights/-/search-insights-2.17.3.tgz"
-  integrity sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==
-
 section-matter@^1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/section-matter/-/section-matter-1.0.0.tgz"
@@ -8381,7 +8350,7 @@ source-map-support@~0.5.20:
     buffer-from "^1.0.0"
     source-map "^0.6.0"
 
-source-map@^0.6.0:
+source-map@^0.6.0, source-map@~0.6.0:
   version "0.6.1"
   resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
@@ -8391,11 +8360,6 @@ source-map@^0.7.0:
   resolved "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz"
   integrity sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==
 
-source-map@~0.6.0:
-  version "0.6.1"
-  resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
-  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
-
 space-separated-tokens@^2.0.0:
   version "2.0.2"
   resolved "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz"
@@ -8434,45 +8398,22 @@ srcset@^4.0.0:
   resolved "https://registry.npmjs.org/srcset/-/srcset-4.0.0.tgz"
   integrity sha512-wvLeHgcVHKO8Sc/H/5lkGreJQVeYMm9rlmt8PuR1xE31rIuXhuzznUUqAt8MqLhB3MqJdFzlNAfpcWnxiFUcPw==
 
-"statuses@>= 1.4.0 < 2":
-  version "1.5.0"
-  resolved "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz"
-  integrity sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==
-
 statuses@2.0.1:
   version "2.0.1"
   resolved "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz"
   integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==
 
+"statuses@>= 1.4.0 < 2":
+  version "1.5.0"
+  resolved "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz"
+  integrity sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==
+
 std-env@^3.7.0:
   version "3.8.0"
   resolved "https://registry.npmjs.org/std-env/-/std-env-3.8.0.tgz"
   integrity sha512-Bc3YwwCB+OzldMxOXJIIvC6cPRWr/LxOp48CdQTOkPyk/t4JWWJbrilwBd7RJzKV8QW7tJkcgAmeuLLJugl5/w==
 
-string_decoder@^1.1.1:
-  version "1.3.0"
-  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
-  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.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz"
-  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
-  dependencies:
-    safe-buffer "~5.1.0"
-
-string-width@^4.1.0:
-  version "4.2.3"
-  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
-  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@^4.2.0:
+string-width@^4.1.0, string-width@^4.2.0:
   version "4.2.3"
   resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
@@ -8490,6 +8431,20 @@ string-width@^5.0.1, string-width@^5.1.2:
     emoji-regex "^9.2.2"
     strip-ansi "^7.0.1"
 
+string_decoder@^1.1.1:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
+  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.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz"
+  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
+  dependencies:
+    safe-buffer "~5.1.0"
+
 stringify-entities@^4.0.0:
   version "4.0.4"
   resolved "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz"
@@ -8713,11 +8668,6 @@ typedarray-to-buffer@^3.1.5:
   dependencies:
     is-typedarray "^1.0.0"
 
-"typescript@>= 2.7", typescript@>=4.9.5:
-  version "5.7.2"
-  resolved "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz"
-  integrity sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==
-
 undici-types@~6.20.0:
   version "6.20.0"
   resolved "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz"
@@ -8821,7 +8771,7 @@ universalify@^2.0.0:
   resolved "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz"
   integrity sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==
 
-unpipe@~1.0.0, unpipe@1.0.0:
+unpipe@1.0.0, unpipe@~1.0.0:
   version "1.0.0"
   resolved "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz"
   integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==
@@ -9037,7 +8987,7 @@ webpack-sources@^3.2.3:
   resolved "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz"
   integrity sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==
 
-"webpack@^4.0.0 || ^5.0.0", "webpack@^4.37.0 || ^5.0.0", webpack@^5.0.0, webpack@^5.1.0, webpack@^5.20.0, webpack@^5.88.1, webpack@^5.95.0, "webpack@>= 4", "webpack@>=4.41.1 || 5.x", webpack@>=5, "webpack@3 || 4 || 5":
+webpack@^5.88.1, webpack@^5.95.0:
   version "5.97.1"
   resolved "https://registry.npmjs.org/webpack/-/webpack-5.97.1.tgz"
   integrity sha512-EksG6gFY3L1eFMROS/7Wzgrii5mBAFe4rIr3r2BTfo7bcc+DWwFZ4OJ/miOuHJO/A85HwyI4eQ0F6IKXesO7Fg==
@@ -9080,7 +9030,7 @@ webpackbar@^6.0.1:
     std-env "^3.7.0"
     wrap-ansi "^7.0.0"
 
-websocket-driver@^0.7.4, websocket-driver@>=0.5.1:
+websocket-driver@>=0.5.1, websocket-driver@^0.7.4:
   version "0.7.4"
   resolved "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz"
   integrity sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==